From ad9ad6f402e3e15706519e59ef111a941d28d5af Mon Sep 17 00:00:00 2001
From: rail <12975677+rail-rain@users.noreply.github.com>
Date: Mon, 27 Apr 2020 17:42:57 +1200
Subject: Don't negate resulted offsets when `offset` is subtraction by 0

---
 clippy_lints/src/loops.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index cb44eccae68..f16b98883b8 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -960,8 +960,8 @@ fn detect_manual_memcpy<'a, 'tcx>(
             let print_sum = |arg1: &Offset, arg2: &Offset| -> String {
                 match (&arg1.value[..], arg1.negate, &arg2.value[..], arg2.negate) {
                     ("0", _, "0", _) => "".into(),
-                    ("0", _, x, false) | (x, false, "0", false) => x.into(),
-                    ("0", _, x, true) | (x, false, "0", true) => format!("-{}", x),
+                    ("0", _, x, false) | (x, false, "0", _) => x.into(),
+                    ("0", _, x, true) => format!("-{}", x),
                     (x, false, y, false) => format!("({} + {})", x, y),
                     (x, false, y, true) => {
                         if x == y {
-- 
cgit 1.4.1-3-g733a5


From 37261a904ce2fbd4137180500c57f75f29945828 Mon Sep 17 00:00:00 2001
From: rail <12975677+rail-rain@users.noreply.github.com>
Date: Mon, 27 Apr 2020 17:51:01 +1200
Subject: Print 0 when `end` and `offset` is 0, and also simplify the
 suggestion

---
 clippy_lints/src/loops.rs     | 15 ++++++++++++---
 tests/ui/manual_memcpy.stderr |  4 ++--
 2 files changed, 14 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index f16b98883b8..6b5a8498dc9 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -959,7 +959,7 @@ fn detect_manual_memcpy<'a, 'tcx>(
         if let PatKind::Binding(_, canonical_id, _, _) = pat.kind {
             let print_sum = |arg1: &Offset, arg2: &Offset| -> String {
                 match (&arg1.value[..], arg1.negate, &arg2.value[..], arg2.negate) {
-                    ("0", _, "0", _) => "".into(),
+                    ("0", _, "0", _) => "0".into(),
                     ("0", _, x, false) | (x, false, "0", _) => x.into(),
                     ("0", _, x, true) => format!("-{}", x),
                     (x, false, y, false) => format!("({} + {})", x, y),
@@ -981,6 +981,15 @@ fn detect_manual_memcpy<'a, 'tcx>(
                 }
             };
 
+            let print_offset = |start_str: &Offset, inline_offset: &Offset| -> String {
+                let offset = print_sum(start_str, inline_offset);
+                if offset.as_str() == "0" {
+                    "".into()
+                } else {
+                    offset
+                }
+            };
+
             let print_limit = |end: &Option<&Expr<'_>>, offset: Offset, var_name: &str| {
                 if let Some(end) = *end {
                     if_chain! {
@@ -1020,9 +1029,9 @@ fn detect_manual_memcpy<'a, 'tcx>(
                 .into_iter()
                 .map(|(dst_var, src_var)| {
                     let start_str = Offset::positive(snippet(cx, start.span, "").to_string());
-                    let dst_offset = print_sum(&start_str, &dst_var.offset);
+                    let dst_offset = print_offset(&start_str, &dst_var.offset);
                     let dst_limit = print_limit(end, dst_var.offset, &dst_var.var_name);
-                    let src_offset = print_sum(&start_str, &src_var.offset);
+                    let src_offset = print_offset(&start_str, &src_var.offset);
                     let src_limit = print_limit(end, src_var.offset, &src_var.var_name);
                     let dst = if dst_offset == "" && dst_limit == "" {
                         dst_var.var_name
diff --git a/tests/ui/manual_memcpy.stderr b/tests/ui/manual_memcpy.stderr
index 3dbb2155d4d..ec80f6070d6 100644
--- a/tests/ui/manual_memcpy.stderr
+++ b/tests/ui/manual_memcpy.stderr
@@ -58,13 +58,13 @@ error: it looks like you're manually copying between slices
   --> $DIR/manual_memcpy.rs:94:14
    |
 LL |     for i in from..from + src.len() {
-   |              ^^^^^^^^^^^^^^^^^^^^^^ help: try replacing the loop by: `dst[from..from + src.len()].clone_from_slice(&src[0..(from + src.len() - from)])`
+   |              ^^^^^^^^^^^^^^^^^^^^^^ help: try replacing the loop by: `dst[from..from + src.len()].clone_from_slice(&src[..(from + src.len() - from)])`
 
 error: it looks like you're manually copying between slices
   --> $DIR/manual_memcpy.rs:98:14
    |
 LL |     for i in from..from + 3 {
-   |              ^^^^^^^^^^^^^^ help: try replacing the loop by: `dst[from..from + 3].clone_from_slice(&src[0..(from + 3 - from)])`
+   |              ^^^^^^^^^^^^^^ help: try replacing the loop by: `dst[from..from + 3].clone_from_slice(&src[..(from + 3 - from)])`
 
 error: it looks like you're manually copying between slices
   --> $DIR/manual_memcpy.rs:105:14
-- 
cgit 1.4.1-3-g733a5


From 75ad839cd26c1da17fe6ba3aae1153ee96de26c8 Mon Sep 17 00:00:00 2001
From: rail <12975677+rail-rain@users.noreply.github.com>
Date: Mon, 27 Apr 2020 18:04:37 +1200
Subject: Do not trigger `manual_memcpy` for `RangeTo`

---
 clippy_lints/src/loops.rs     | 50 ++++++++++++++++++++-----------------------
 tests/ui/manual_memcpy.rs     |  5 +++++
 tests/ui/manual_memcpy.stderr |  2 +-
 3 files changed, 29 insertions(+), 28 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 6b5a8498dc9..ca61c97e3e3 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -951,7 +951,7 @@ fn detect_manual_memcpy<'a, 'tcx>(
 ) {
     if let Some(higher::Range {
         start: Some(start),
-        ref end,
+        end: Some(end),
         limits,
     }) = higher::range(cx, arg)
     {
@@ -990,35 +990,31 @@ fn detect_manual_memcpy<'a, 'tcx>(
                 }
             };
 
-            let print_limit = |end: &Option<&Expr<'_>>, offset: Offset, var_name: &str| {
-                if let Some(end) = *end {
-                    if_chain! {
-                        if let ExprKind::MethodCall(ref method, _, ref len_args) = end.kind;
-                        if method.ident.name == sym!(len);
-                        if len_args.len() == 1;
-                        if let Some(arg) = len_args.get(0);
-                        if snippet(cx, arg.span, "??") == var_name;
-                        then {
-                            return if offset.negate {
-                                format!("({} - {})", snippet(cx, end.span, "<src>.len()"), offset.value)
-                            } else {
-                                String::new()
-                            };
-                        }
+            let print_limit = |end: &Expr<'_>, offset: Offset, var_name: &str| {
+                if_chain! {
+                    if let ExprKind::MethodCall(ref method, _, ref len_args) = end.kind;
+                    if method.ident.name == sym!(len);
+                    if len_args.len() == 1;
+                    if let Some(arg) = len_args.get(0);
+                    if snippet(cx, arg.span, "??") == var_name;
+                    then {
+                        return if offset.negate {
+                            format!("({} - {})", snippet(cx, end.span, "<src>.len()"), offset.value)
+                        } else {
+                            String::new()
+                        };
                     }
+                }
 
-                    let end_str = match limits {
-                        ast::RangeLimits::Closed => {
-                            let end = sugg::Sugg::hir(cx, end, "<count>");
-                            format!("{}", end + sugg::ONE)
-                        },
-                        ast::RangeLimits::HalfOpen => format!("{}", snippet(cx, end.span, "..")),
-                    };
+                let end_str = match limits {
+                    ast::RangeLimits::Closed => {
+                        let end = sugg::Sugg::hir(cx, end, "<count>");
+                        format!("{}", end + sugg::ONE)
+                    },
+                    ast::RangeLimits::HalfOpen => format!("{}", snippet(cx, end.span, "..")),
+                };
 
-                    print_sum(&Offset::positive(end_str), &offset)
-                } else {
-                    "..".into()
-                }
+                print_sum(&Offset::positive(end_str), &offset)
             };
 
             // The only statements in the for loops can be indexed assignments from
diff --git a/tests/ui/manual_memcpy.rs b/tests/ui/manual_memcpy.rs
index aa347288875..1f41838fa16 100644
--- a/tests/ui/manual_memcpy.rs
+++ b/tests/ui/manual_memcpy.rs
@@ -98,6 +98,11 @@ pub fn manual_copy(src: &[i32], dst: &mut [i32], dst2: &mut [i32]) {
     for i in from..from + 3 {
         dst[i] = src[i - from];
     }
+
+    // `RangeTo` `for` loop - don't trigger lint
+    for i in 0.. {
+        dst[i] = src[i];
+    }
 }
 
 #[warn(clippy::needless_range_loop, clippy::manual_memcpy)]
diff --git a/tests/ui/manual_memcpy.stderr b/tests/ui/manual_memcpy.stderr
index ec80f6070d6..95114c46f36 100644
--- a/tests/ui/manual_memcpy.stderr
+++ b/tests/ui/manual_memcpy.stderr
@@ -67,7 +67,7 @@ LL |     for i in from..from + 3 {
    |              ^^^^^^^^^^^^^^ help: try replacing the loop by: `dst[from..from + 3].clone_from_slice(&src[..(from + 3 - from)])`
 
 error: it looks like you're manually copying between slices
-  --> $DIR/manual_memcpy.rs:105:14
+  --> $DIR/manual_memcpy.rs:110:14
    |
 LL |     for i in 0..src.len() {
    |              ^^^^^^^^^^^^ help: try replacing the loop by: `dst[..src.len()].clone_from_slice(&src[..])`
-- 
cgit 1.4.1-3-g733a5


From c94f0f49f8e025aae11534f9f2b4c59c34b1edb8 Mon Sep 17 00:00:00 2001
From: rail <12975677+rail-rain@users.noreply.github.com>
Date: Mon, 27 Apr 2020 18:22:10 +1200
Subject: Remove all `ref` keyword

---
 clippy_lints/src/loops.rs | 26 ++++++++++++--------------
 1 file changed, 12 insertions(+), 14 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index ca61c97e3e3..502bd42214e 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -772,8 +772,8 @@ fn check_for_loop<'a, 'tcx>(
 
 fn same_var<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &Expr<'_>, var: HirId) -> bool {
     if_chain! {
-        if let ExprKind::Path(ref qpath) = expr.kind;
-        if let QPath::Resolved(None, ref path) = *qpath;
+        if let ExprKind::Path(qpath) = &expr.kind;
+        if let QPath::Resolved(None, path) = qpath;
         if path.segments.len() == 1;
         if let Res::Local(local_id) = qpath_res(cx, qpath, expr.hir_id);
         // our variable!
@@ -821,8 +821,8 @@ fn is_slice_like<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, ty: Ty<'_>) -> bool {
 
 fn get_fixed_offset_var<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &Expr<'_>, var: HirId) -> Option<FixedOffsetVar> {
     fn extract_offset<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, e: &Expr<'_>, var: HirId) -> Option<String> {
-        match e.kind {
-            ExprKind::Lit(ref l) => match l.node {
+        match &e.kind {
+            ExprKind::Lit(l) => match l.node {
                 ast::LitKind::Int(x, _ty) => Some(x.to_string()),
                 _ => None,
             },
@@ -831,14 +831,14 @@ fn get_fixed_offset_var<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &Expr<'_>, v
         }
     }
 
-    if let ExprKind::Index(ref seqexpr, ref idx) = expr.kind {
+    if let ExprKind::Index(seqexpr, idx) = expr.kind {
         let ty = cx.tables.expr_ty(seqexpr);
         if !is_slice_like(cx, ty) {
             return None;
         }
 
         let offset = match idx.kind {
-            ExprKind::Binary(op, ref lhs, ref rhs) => match op.node {
+            ExprKind::Binary(op, lhs, rhs) => match op.node {
                 BinOpKind::Add => {
                     let offset_opt = if same_var(cx, lhs, var) {
                         extract_offset(cx, rhs, var)
@@ -878,7 +878,7 @@ fn fetch_cloned_fixed_offset_var<'a, 'tcx>(
     var: HirId,
 ) -> Option<FixedOffsetVar> {
     if_chain! {
-        if let ExprKind::MethodCall(ref method, _, ref args) = expr.kind;
+        if let ExprKind::MethodCall(method, _, args) = expr.kind;
         if method.ident.name == sym!(clone);
         if args.len() == 1;
         if let Some(arg) = args.get(0);
@@ -900,7 +900,7 @@ fn get_indexed_assignments<'a, 'tcx>(
         e: &Expr<'_>,
         var: HirId,
     ) -> Option<(FixedOffsetVar, FixedOffsetVar)> {
-        if let ExprKind::Assign(ref lhs, ref rhs, _) = e.kind {
+        if let ExprKind::Assign(lhs, rhs, _) = e.kind {
             match (
                 get_fixed_offset_var(cx, lhs, var),
                 fetch_cloned_fixed_offset_var(cx, rhs, var),
@@ -920,16 +920,14 @@ fn get_indexed_assignments<'a, 'tcx>(
         }
     }
 
-    if let ExprKind::Block(ref b, _) = body.kind {
-        let Block {
-            ref stmts, ref expr, ..
-        } = **b;
+    if let ExprKind::Block(b, _) = body.kind {
+        let Block { stmts, expr, .. } = *b;
 
         stmts
             .iter()
             .map(|stmt| match stmt.kind {
                 StmtKind::Local(..) | StmtKind::Item(..) => None,
-                StmtKind::Expr(ref e) | StmtKind::Semi(ref e) => Some(get_assignment(cx, e, var)),
+                StmtKind::Expr(e) | StmtKind::Semi(e) => Some(get_assignment(cx, e, var)),
             })
             .chain(expr.as_ref().into_iter().map(|e| Some(get_assignment(cx, &*e, var))))
             .filter_map(|op| op)
@@ -992,7 +990,7 @@ fn detect_manual_memcpy<'a, 'tcx>(
 
             let print_limit = |end: &Expr<'_>, offset: Offset, var_name: &str| {
                 if_chain! {
-                    if let ExprKind::MethodCall(ref method, _, ref len_args) = end.kind;
+                    if let ExprKind::MethodCall(method, _, len_args) = end.kind;
                     if method.ident.name == sym!(len);
                     if len_args.len() == 1;
                     if let Some(arg) = len_args.get(0);
-- 
cgit 1.4.1-3-g733a5


From 7dd0f3459f558c1b557223a042f549b378cacae9 Mon Sep 17 00:00:00 2001
From: rail <12975677+rail-rain@users.noreply.github.com>
Date: Mon, 27 Apr 2020 18:47:24 +1200
Subject: Refactor `if` to use `else` and iterator combinators

---
 clippy_lints/src/loops.rs | 50 +++++++++++++++++++++--------------------------
 1 file changed, 22 insertions(+), 28 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 502bd42214e..3dd3a79b287 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -779,11 +779,11 @@ fn same_var<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &Expr<'_>, var: HirId) -
         // our variable!
         if local_id == var;
         then {
-            return true;
+            true
+        } else {
+            false
         }
     }
-
-    false
 }
 
 struct Offset {
@@ -853,13 +853,7 @@ fn get_fixed_offset_var<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &Expr<'_>, v
                 BinOpKind::Sub if same_var(cx, lhs, var) => extract_offset(cx, rhs, var).map(Offset::negative),
                 _ => None,
             },
-            ExprKind::Path(..) => {
-                if same_var(cx, idx, var) {
-                    Some(Offset::positive("0".into()))
-                } else {
-                    None
-                }
-            },
+            ExprKind::Path(..) if same_var(cx, idx, var) => Some(Offset::positive("0".into())),
             _ => None,
         };
 
@@ -883,11 +877,11 @@ fn fetch_cloned_fixed_offset_var<'a, 'tcx>(
         if args.len() == 1;
         if let Some(arg) = args.get(0);
         then {
-            return get_fixed_offset_var(cx, arg, var);
+            get_fixed_offset_var(cx, arg, var)
+        } else {
+            get_fixed_offset_var(cx, expr, var)
         }
     }
-
-    get_fixed_offset_var(cx, expr, var)
 }
 
 fn get_indexed_assignments<'a, 'tcx>(
@@ -925,12 +919,12 @@ fn get_indexed_assignments<'a, 'tcx>(
 
         stmts
             .iter()
-            .map(|stmt| match stmt.kind {
+            .filter_map(|stmt| match stmt.kind {
                 StmtKind::Local(..) | StmtKind::Item(..) => None,
-                StmtKind::Expr(e) | StmtKind::Semi(e) => Some(get_assignment(cx, e, var)),
+                StmtKind::Expr(e) | StmtKind::Semi(e) => Some(e),
             })
-            .chain(expr.as_ref().into_iter().map(|e| Some(get_assignment(cx, &*e, var))))
-            .filter_map(|op| op)
+            .chain(expr.into_iter())
+            .map(|op| get_assignment(cx, op, var))
             .collect::<Option<Vec<_>>>()
             .unwrap_or_default()
     } else {
@@ -996,23 +990,23 @@ fn detect_manual_memcpy<'a, 'tcx>(
                     if let Some(arg) = len_args.get(0);
                     if snippet(cx, arg.span, "??") == var_name;
                     then {
-                        return if offset.negate {
+                        if offset.negate {
                             format!("({} - {})", snippet(cx, end.span, "<src>.len()"), offset.value)
                         } else {
                             String::new()
+                        }
+                    } else {
+                        let end_str = match limits {
+                            ast::RangeLimits::Closed => {
+                                let end = sugg::Sugg::hir(cx, end, "<count>");
+                                format!("{}", end + sugg::ONE)
+                            },
+                            ast::RangeLimits::HalfOpen => format!("{}", snippet(cx, end.span, "..")),
                         };
+
+                        print_sum(&Offset::positive(end_str), &offset)
                     }
                 }
-
-                let end_str = match limits {
-                    ast::RangeLimits::Closed => {
-                        let end = sugg::Sugg::hir(cx, end, "<count>");
-                        format!("{}", end + sugg::ONE)
-                    },
-                    ast::RangeLimits::HalfOpen => format!("{}", snippet(cx, end.span, "..")),
-                };
-
-                print_sum(&Offset::positive(end_str), &offset)
             };
 
             // The only statements in the for loops can be indexed assignments from
-- 
cgit 1.4.1-3-g733a5


From 3f1e51b3f4a7bfb42c442caf2cb836ba62e2ba53 Mon Sep 17 00:00:00 2001
From: rail <12975677+rail-rain@users.noreply.github.com>
Date: Mon, 27 Apr 2020 18:57:36 +1200
Subject: Rename `negate` to `sign` and make it strong types then make `art1`
 &str

---
 clippy_lints/src/loops.rs | 56 +++++++++++++++++++++++------------------------
 1 file changed, 28 insertions(+), 28 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 3dd3a79b287..321d5265d0c 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -786,20 +786,29 @@ fn same_var<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &Expr<'_>, var: HirId) -
     }
 }
 
+#[derive(Clone, Copy)]
+enum OffsetSign {
+    Positive,
+    Negative,
+}
+
 struct Offset {
     value: String,
-    negate: bool,
+    sign: OffsetSign,
 }
 
 impl Offset {
-    fn negative(s: String) -> Self {
-        Self { value: s, negate: true }
+    fn negative(value: String) -> Self {
+        Self {
+            value,
+            sign: OffsetSign::Negative,
+        }
     }
 
-    fn positive(s: String) -> Self {
+    fn positive(value: String) -> Self {
         Self {
-            value: s,
-            negate: false,
+            value,
+            sign: OffsetSign::Positive,
         }
     }
 }
@@ -949,31 +958,23 @@ fn detect_manual_memcpy<'a, 'tcx>(
     {
         // the var must be a single name
         if let PatKind::Binding(_, canonical_id, _, _) = pat.kind {
-            let print_sum = |arg1: &Offset, arg2: &Offset| -> String {
-                match (&arg1.value[..], arg1.negate, &arg2.value[..], arg2.negate) {
-                    ("0", _, "0", _) => "0".into(),
-                    ("0", _, x, false) | (x, false, "0", _) => x.into(),
-                    ("0", _, x, true) => format!("-{}", x),
-                    (x, false, y, false) => format!("({} + {})", x, y),
-                    (x, false, y, true) => {
+            let print_sum = |arg1: &str, arg2: &Offset| -> String {
+                match (arg1, &arg2.value[..], arg2.sign) {
+                    ("0", "0", _) => "0".into(),
+                    ("0", x, OffsetSign::Positive) | (x, "0", _) => x.into(),
+                    ("0", x, OffsetSign::Negative) => format!("-{}", x),
+                    (x, y, OffsetSign::Positive) => format!("({} + {})", x, y),
+                    (x, y, OffsetSign::Negative) => {
                         if x == y {
                             "0".into()
                         } else {
                             format!("({} - {})", x, y)
                         }
                     },
-                    (x, true, y, false) => {
-                        if x == y {
-                            "0".into()
-                        } else {
-                            format!("({} - {})", y, x)
-                        }
-                    },
-                    (x, true, y, true) => format!("-({} + {})", x, y),
                 }
             };
 
-            let print_offset = |start_str: &Offset, inline_offset: &Offset| -> String {
+            let print_offset = |start_str: &str, inline_offset: &Offset| -> String {
                 let offset = print_sum(start_str, inline_offset);
                 if offset.as_str() == "0" {
                     "".into()
@@ -990,10 +991,9 @@ fn detect_manual_memcpy<'a, 'tcx>(
                     if let Some(arg) = len_args.get(0);
                     if snippet(cx, arg.span, "??") == var_name;
                     then {
-                        if offset.negate {
-                            format!("({} - {})", snippet(cx, end.span, "<src>.len()"), offset.value)
-                        } else {
-                            String::new()
+                        match offset.sign {
+                            OffsetSign::Negative => format!("({} - {})", snippet(cx, end.span, "<src>.len()"), offset.value),
+                            OffsetSign::Positive => "".into(),
                         }
                     } else {
                         let end_str = match limits {
@@ -1004,7 +1004,7 @@ fn detect_manual_memcpy<'a, 'tcx>(
                             ast::RangeLimits::HalfOpen => format!("{}", snippet(cx, end.span, "..")),
                         };
 
-                        print_sum(&Offset::positive(end_str), &offset)
+                        print_sum(&end_str, &offset)
                     }
                 }
             };
@@ -1016,7 +1016,7 @@ fn detect_manual_memcpy<'a, 'tcx>(
             let big_sugg = manual_copies
                 .into_iter()
                 .map(|(dst_var, src_var)| {
-                    let start_str = Offset::positive(snippet(cx, start.span, "").to_string());
+                    let start_str = snippet(cx, start.span, "").to_string();
                     let dst_offset = print_offset(&start_str, &dst_var.offset);
                     let dst_limit = print_limit(end, dst_var.offset, &dst_var.var_name);
                     let src_offset = print_offset(&start_str, &src_var.offset);
-- 
cgit 1.4.1-3-g733a5


From ecb472c052c746d87ce26f6b184f2c5f11537e0c Mon Sep 17 00:00:00 2001
From: rail <12975677+rail-rain@users.noreply.github.com>
Date: Mon, 27 Apr 2020 19:02:08 +1200
Subject: Use `fn` instead of closures where unnecessary

---
 clippy_lints/src/loops.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 321d5265d0c..e37c44dc026 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -958,7 +958,7 @@ fn detect_manual_memcpy<'a, 'tcx>(
     {
         // the var must be a single name
         if let PatKind::Binding(_, canonical_id, _, _) = pat.kind {
-            let print_sum = |arg1: &str, arg2: &Offset| -> String {
+            fn print_sum(arg1: &str, arg2: &Offset) -> String {
                 match (arg1, &arg2.value[..], arg2.sign) {
                     ("0", "0", _) => "0".into(),
                     ("0", x, OffsetSign::Positive) | (x, "0", _) => x.into(),
@@ -972,16 +972,16 @@ fn detect_manual_memcpy<'a, 'tcx>(
                         }
                     },
                 }
-            };
+            }
 
-            let print_offset = |start_str: &str, inline_offset: &Offset| -> String {
+            fn print_offset(start_str: &str, inline_offset: &Offset) -> String {
                 let offset = print_sum(start_str, inline_offset);
                 if offset.as_str() == "0" {
                     "".into()
                 } else {
                     offset
                 }
-            };
+            }
 
             let print_limit = |end: &Expr<'_>, offset: Offset, var_name: &str| {
                 if_chain! {
-- 
cgit 1.4.1-3-g733a5


From aab80eedf3e271ada92a6509727461cc3aa6bb12 Mon Sep 17 00:00:00 2001
From: rail <12975677+rail-rain@users.noreply.github.com>
Date: Mon, 27 Apr 2020 19:04:56 +1200
Subject: Extract `get_fixed_offset_var`` from `fetch_cloned_fixed_offset_var`

---
 clippy_lints/src/loops.rs | 30 +++++++++++-------------------
 1 file changed, 11 insertions(+), 19 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index e37c44dc026..2dc95f53078 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -828,6 +828,16 @@ fn is_slice_like<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, ty: Ty<'_>) -> bool {
     is_slice || is_type_diagnostic_item(cx, ty, sym!(vec_type)) || is_type_diagnostic_item(cx, ty, sym!(vecdeque_type))
 }
 
+fn fetch_cloned_expr<'tcx>(expr: &'tcx Expr<'tcx>) -> &'tcx Expr<'tcx> {
+    if_chain! {
+        if let ExprKind::MethodCall(method, _, args) = expr.kind;
+        if method.ident.name == sym!(clone);
+        if args.len() == 1;
+        if let Some(arg) = args.get(0);
+        then { arg } else { expr }
+    }
+}
+
 fn get_fixed_offset_var<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &Expr<'_>, var: HirId) -> Option<FixedOffsetVar> {
     fn extract_offset<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, e: &Expr<'_>, var: HirId) -> Option<String> {
         match &e.kind {
@@ -875,24 +885,6 @@ fn get_fixed_offset_var<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &Expr<'_>, v
     }
 }
 
-fn fetch_cloned_fixed_offset_var<'a, 'tcx>(
-    cx: &LateContext<'a, 'tcx>,
-    expr: &Expr<'_>,
-    var: HirId,
-) -> Option<FixedOffsetVar> {
-    if_chain! {
-        if let ExprKind::MethodCall(method, _, args) = expr.kind;
-        if method.ident.name == sym!(clone);
-        if args.len() == 1;
-        if let Some(arg) = args.get(0);
-        then {
-            get_fixed_offset_var(cx, arg, var)
-        } else {
-            get_fixed_offset_var(cx, expr, var)
-        }
-    }
-}
-
 fn get_indexed_assignments<'a, 'tcx>(
     cx: &LateContext<'a, 'tcx>,
     body: &Expr<'_>,
@@ -906,7 +898,7 @@ fn get_indexed_assignments<'a, 'tcx>(
         if let ExprKind::Assign(lhs, rhs, _) = e.kind {
             match (
                 get_fixed_offset_var(cx, lhs, var),
-                fetch_cloned_fixed_offset_var(cx, rhs, var),
+                get_fixed_offset_var(cx, fetch_cloned_expr(rhs), var),
             ) {
                 (Some(offset_left), Some(offset_right)) => {
                     // Source and destination must be different
-- 
cgit 1.4.1-3-g733a5


From 3d121d53af9a73ba11226715cd8132f6981ffee9 Mon Sep 17 00:00:00 2001
From: rail <12975677+rail-rain@users.noreply.github.com>
Date: Mon, 27 Apr 2020 19:15:51 +1200
Subject: Extract roles getting indexes from `get_indexed_assignments`

---
 clippy_lints/src/loops.rs | 106 ++++++++++++++++++++++++----------------------
 1 file changed, 55 insertions(+), 51 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 2dc95f53078..0753b23e45b 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -10,7 +10,6 @@ use crate::utils::{
 };
 use crate::utils::{is_type_diagnostic_item, qpath_res, same_tys, sext, sugg};
 use if_chain::if_chain;
-use itertools::Itertools;
 use rustc_ast::ast;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_errors::Applicability;
@@ -885,52 +884,39 @@ fn get_fixed_offset_var<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &Expr<'_>, v
     }
 }
 
-fn get_indexed_assignments<'a, 'tcx>(
-    cx: &LateContext<'a, 'tcx>,
-    body: &Expr<'_>,
-    var: HirId,
-) -> Vec<(FixedOffsetVar, FixedOffsetVar)> {
-    fn get_assignment<'a, 'tcx>(
-        cx: &LateContext<'a, 'tcx>,
-        e: &Expr<'_>,
-        var: HirId,
-    ) -> Option<(FixedOffsetVar, FixedOffsetVar)> {
+fn get_assignments<'a, 'tcx>(
+    body: &'tcx Expr<'tcx>,
+) -> impl Iterator<Item = Option<(&'tcx Expr<'tcx>, &'tcx Expr<'tcx>)>> {
+    fn get_assignment<'a, 'tcx>(e: &'tcx Expr<'tcx>) -> Option<(&'tcx Expr<'tcx>, &'tcx Expr<'tcx>)> {
         if let ExprKind::Assign(lhs, rhs, _) = e.kind {
-            match (
-                get_fixed_offset_var(cx, lhs, var),
-                get_fixed_offset_var(cx, fetch_cloned_expr(rhs), var),
-            ) {
-                (Some(offset_left), Some(offset_right)) => {
-                    // Source and destination must be different
-                    if offset_left.var_name == offset_right.var_name {
-                        None
-                    } else {
-                        Some((offset_left, offset_right))
-                    }
-                },
-                _ => None,
-            }
+            Some((lhs, rhs))
         } else {
             None
         }
     }
 
+    // This is one of few ways to return different iterators
+    // derived from: https://stackoverflow.com/questions/29760668/conditionally-iterate-over-one-of-several-possible-iterators/52064434#52064434
+    let mut iter_a = None;
+    let mut iter_b = None;
+
     if let ExprKind::Block(b, _) = body.kind {
         let Block { stmts, expr, .. } = *b;
 
-        stmts
+        iter_a = stmts
             .iter()
             .filter_map(|stmt| match stmt.kind {
                 StmtKind::Local(..) | StmtKind::Item(..) => None,
                 StmtKind::Expr(e) | StmtKind::Semi(e) => Some(e),
             })
             .chain(expr.into_iter())
-            .map(|op| get_assignment(cx, op, var))
-            .collect::<Option<Vec<_>>>()
-            .unwrap_or_default()
+            .map(get_assignment)
+            .into()
     } else {
-        get_assignment(cx, body, var).into_iter().collect()
+        iter_b = Some(get_assignment(body))
     }
+
+    iter_a.into_iter().flatten().chain(iter_b.into_iter())
 }
 
 /// Checks for for loops that sequentially copy items from one slice-like
@@ -1003,30 +989,48 @@ fn detect_manual_memcpy<'a, 'tcx>(
 
             // The only statements in the for loops can be indexed assignments from
             // indexed retrievals.
-            let manual_copies = get_indexed_assignments(cx, body, canonical_id);
-
-            let big_sugg = manual_copies
-                .into_iter()
-                .map(|(dst_var, src_var)| {
-                    let start_str = snippet(cx, start.span, "").to_string();
-                    let dst_offset = print_offset(&start_str, &dst_var.offset);
-                    let dst_limit = print_limit(end, dst_var.offset, &dst_var.var_name);
-                    let src_offset = print_offset(&start_str, &src_var.offset);
-                    let src_limit = print_limit(end, src_var.offset, &src_var.var_name);
-                    let dst = if dst_offset == "" && dst_limit == "" {
-                        dst_var.var_name
-                    } else {
-                        format!("{}[{}..{}]", dst_var.var_name, dst_offset, dst_limit)
-                    };
+            let big_sugg = get_assignments(body)
+                .map(|o| {
+                    o.and_then(|(lhs, rhs)| {
+                        let rhs = fetch_cloned_expr(rhs);
+                        if_chain! {
+                            if let Some(offset_left) = get_fixed_offset_var(cx, lhs, canonical_id);
+                            if let Some(offset_right) = get_fixed_offset_var(cx, rhs, canonical_id);
+
+                            // Source and destination must be different
+                            if offset_left.var_name != offset_right.var_name;
+                            then {
+                                Some((offset_left, offset_right))
+                            } else {
+                                return None
+                            }
+                        }
+                    })
+                })
+                .map(|o| {
+                    o.map(|(dst_var, src_var)| {
+                        let start_str = snippet(cx, start.span, "").to_string();
+                        let dst_offset = print_offset(&start_str, &dst_var.offset);
+                        let dst_limit = print_limit(end, dst_var.offset, &dst_var.var_name);
+                        let src_offset = print_offset(&start_str, &src_var.offset);
+                        let src_limit = print_limit(end, src_var.offset, &src_var.var_name);
+                        let dst = if dst_offset == "" && dst_limit == "" {
+                            dst_var.var_name
+                        } else {
+                            format!("{}[{}..{}]", dst_var.var_name, dst_offset, dst_limit)
+                        };
 
-                    format!(
-                        "{}.clone_from_slice(&{}[{}..{}])",
-                        dst, src_var.var_name, src_offset, src_limit
-                    )
+                        format!(
+                            "{}.clone_from_slice(&{}[{}..{}])",
+                            dst, src_var.var_name, src_offset, src_limit
+                        )
+                    })
                 })
-                .join("\n    ");
+                .collect::<Option<Vec<_>>>()
+                .filter(|v| !v.is_empty())
+                .map(|v| v.join("\n    "));
 
-            if !big_sugg.is_empty() {
+            if let Some(big_sugg) = big_sugg {
                 span_lint_and_sugg(
                     cx,
                     MANUAL_MEMCPY,
-- 
cgit 1.4.1-3-g733a5


From 4f2617c059f693ec72e5d31ad31fd85eba019ab1 Mon Sep 17 00:00:00 2001
From: rail <12975677+rail-rain@users.noreply.github.com>
Date: Mon, 27 Apr 2020 19:26:00 +1200
Subject: Separate getting offsets and getting index expressions

---
 clippy_lints/src/loops.rs | 63 +++++++++++++++++++++--------------------------
 1 file changed, 28 insertions(+), 35 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 0753b23e45b..75955997af2 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -837,7 +837,7 @@ fn fetch_cloned_expr<'tcx>(expr: &'tcx Expr<'tcx>) -> &'tcx Expr<'tcx> {
     }
 }
 
-fn get_fixed_offset_var<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &Expr<'_>, var: HirId) -> Option<FixedOffsetVar> {
+fn get_offset<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, idx: &Expr<'_>, var: HirId) -> Option<Offset> {
     fn extract_offset<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, e: &Expr<'_>, var: HirId) -> Option<String> {
         match &e.kind {
             ExprKind::Lit(l) => match l.node {
@@ -849,38 +849,24 @@ fn get_fixed_offset_var<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &Expr<'_>, v
         }
     }
 
-    if let ExprKind::Index(seqexpr, idx) = expr.kind {
-        let ty = cx.tables.expr_ty(seqexpr);
-        if !is_slice_like(cx, ty) {
-            return None;
-        }
-
-        let offset = match idx.kind {
-            ExprKind::Binary(op, lhs, rhs) => match op.node {
-                BinOpKind::Add => {
-                    let offset_opt = if same_var(cx, lhs, var) {
-                        extract_offset(cx, rhs, var)
-                    } else if same_var(cx, rhs, var) {
-                        extract_offset(cx, lhs, var)
-                    } else {
-                        None
-                    };
+    match idx.kind {
+        ExprKind::Binary(op, lhs, rhs) => match op.node {
+            BinOpKind::Add => {
+                let offset_opt = if same_var(cx, lhs, var) {
+                    extract_offset(cx, rhs, var)
+                } else if same_var(cx, rhs, var) {
+                    extract_offset(cx, lhs, var)
+                } else {
+                    None
+                };
 
-                    offset_opt.map(Offset::positive)
-                },
-                BinOpKind::Sub if same_var(cx, lhs, var) => extract_offset(cx, rhs, var).map(Offset::negative),
-                _ => None,
+                offset_opt.map(Offset::positive)
             },
-            ExprKind::Path(..) if same_var(cx, idx, var) => Some(Offset::positive("0".into())),
+            BinOpKind::Sub if same_var(cx, lhs, var) => extract_offset(cx, rhs, var).map(Offset::negative),
             _ => None,
-        };
-
-        offset.map(|o| FixedOffsetVar {
-            var_name: snippet_opt(cx, seqexpr.span).unwrap_or_else(|| "???".into()),
-            offset: o,
-        })
-    } else {
-        None
+        },
+        ExprKind::Path(..) if same_var(cx, idx, var) => Some(Offset::positive("0".into())),
+        _ => None,
     }
 }
 
@@ -994,15 +980,22 @@ fn detect_manual_memcpy<'a, 'tcx>(
                     o.and_then(|(lhs, rhs)| {
                         let rhs = fetch_cloned_expr(rhs);
                         if_chain! {
-                            if let Some(offset_left) = get_fixed_offset_var(cx, lhs, canonical_id);
-                            if let Some(offset_right) = get_fixed_offset_var(cx, rhs, canonical_id);
+                            if let ExprKind::Index(seqexpr_left, idx_left) = lhs.kind;
+                            if let ExprKind::Index(seqexpr_right, idx_right) = rhs.kind;
+                            if is_slice_like(cx, cx.tables.expr_ty(seqexpr_left))
+                                && is_slice_like(cx, cx.tables.expr_ty(seqexpr_right));
+                            if let Some(offset_left) = get_offset(cx, &idx_left, canonical_id);
+                            if let Some(offset_right) = get_offset(cx, &idx_right, canonical_id);
+                            let var_name_left = snippet_opt(cx, seqexpr_left.span).unwrap_or_else(|| "???".into());
+                            let var_name_right = snippet_opt(cx, seqexpr_right.span).unwrap_or_else(|| "???".into());
 
                             // Source and destination must be different
-                            if offset_left.var_name != offset_right.var_name;
+                            if var_name_left != var_name_right;
                             then {
-                                Some((offset_left, offset_right))
+                                Some((FixedOffsetVar { var_name: var_name_left, offset: offset_left },
+                                    FixedOffsetVar { var_name: var_name_right, offset: offset_right }))
                             } else {
-                                return None
+                                None
                             }
                         }
                     })
-- 
cgit 1.4.1-3-g733a5


From 9fc6f37778789de94caa280f41afdf651bf5ae10 Mon Sep 17 00:00:00 2001
From: rail <12975677+rail-rain@users.noreply.github.com>
Date: Mon, 27 Apr 2020 19:34:41 +1200
Subject: Delay getting the snippet from slices

---
 clippy_lints/src/loops.rs | 30 ++++++++++++++++--------------
 1 file changed, 16 insertions(+), 14 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 75955997af2..8ab35556670 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -812,8 +812,8 @@ impl Offset {
     }
 }
 
-struct FixedOffsetVar {
-    var_name: String,
+struct FixedOffsetVar<'hir> {
+    var: &'hir Expr<'hir>,
     offset: Offset,
 }
 
@@ -947,13 +947,13 @@ fn detect_manual_memcpy<'a, 'tcx>(
                 }
             }
 
-            let print_limit = |end: &Expr<'_>, offset: Offset, var_name: &str| {
+            let print_limit = |end: &Expr<'_>, offset: Offset, var: &Expr<'_>| {
                 if_chain! {
                     if let ExprKind::MethodCall(method, _, len_args) = end.kind;
                     if method.ident.name == sym!(len);
                     if len_args.len() == 1;
                     if let Some(arg) = len_args.get(0);
-                    if snippet(cx, arg.span, "??") == var_name;
+                    if var_def_id(cx, arg) == var_def_id(cx, var);
                     then {
                         match offset.sign {
                             OffsetSign::Negative => format!("({} - {})", snippet(cx, end.span, "<src>.len()"), offset.value),
@@ -986,14 +986,12 @@ fn detect_manual_memcpy<'a, 'tcx>(
                                 && is_slice_like(cx, cx.tables.expr_ty(seqexpr_right));
                             if let Some(offset_left) = get_offset(cx, &idx_left, canonical_id);
                             if let Some(offset_right) = get_offset(cx, &idx_right, canonical_id);
-                            let var_name_left = snippet_opt(cx, seqexpr_left.span).unwrap_or_else(|| "???".into());
-                            let var_name_right = snippet_opt(cx, seqexpr_right.span).unwrap_or_else(|| "???".into());
 
                             // Source and destination must be different
-                            if var_name_left != var_name_right;
+                            if var_def_id(cx, seqexpr_left) != var_def_id(cx, seqexpr_right);
                             then {
-                                Some((FixedOffsetVar { var_name: var_name_left, offset: offset_left },
-                                    FixedOffsetVar { var_name: var_name_right, offset: offset_right }))
+                                Some((FixedOffsetVar { var: seqexpr_left, offset: offset_left },
+                                    FixedOffsetVar { var: seqexpr_right, offset: offset_right }))
                             } else {
                                 None
                             }
@@ -1004,18 +1002,22 @@ fn detect_manual_memcpy<'a, 'tcx>(
                     o.map(|(dst_var, src_var)| {
                         let start_str = snippet(cx, start.span, "").to_string();
                         let dst_offset = print_offset(&start_str, &dst_var.offset);
-                        let dst_limit = print_limit(end, dst_var.offset, &dst_var.var_name);
+                        let dst_limit = print_limit(end, dst_var.offset, dst_var.var);
                         let src_offset = print_offset(&start_str, &src_var.offset);
-                        let src_limit = print_limit(end, src_var.offset, &src_var.var_name);
+                        let src_limit = print_limit(end, src_var.offset, src_var.var);
+
+                        let dst_var_name = snippet_opt(cx, dst_var.var.span).unwrap_or_else(|| "???".into());
+                        let src_var_name = snippet_opt(cx, src_var.var.span).unwrap_or_else(|| "???".into());
+
                         let dst = if dst_offset == "" && dst_limit == "" {
-                            dst_var.var_name
+                            dst_var_name
                         } else {
-                            format!("{}[{}..{}]", dst_var.var_name, dst_offset, dst_limit)
+                            format!("{}[{}..{}]", dst_var_name, dst_offset, dst_limit)
                         };
 
                         format!(
                             "{}.clone_from_slice(&{}[{}..{}])",
-                            dst, src_var.var_name, src_offset, src_limit
+                            dst, src_var_name, src_offset, src_limit
                         )
                     })
                 })
-- 
cgit 1.4.1-3-g733a5


From 582614fbbe76fed1b06feb640229b71a1886ffd7 Mon Sep 17 00:00:00 2001
From: rail <12975677+rail-rain@users.noreply.github.com>
Date: Mon, 27 Apr 2020 19:44:44 +1200
Subject: Extract building the suggestion of `manual_memcpy`

---
 clippy_lints/src/loops.rs | 154 ++++++++++++++++++++++++----------------------
 1 file changed, 80 insertions(+), 74 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 8ab35556670..7cf3e16bef9 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -905,6 +905,85 @@ fn get_assignments<'a, 'tcx>(
     iter_a.into_iter().flatten().chain(iter_b.into_iter())
 }
 
+fn build_manual_memcpy_suggestion<'a, 'tcx>(
+    cx: &LateContext<'a, 'tcx>,
+    start: &Expr<'_>,
+    end: &Expr<'_>,
+    limits: ast::RangeLimits,
+    dst_var: FixedOffsetVar<'_>,
+    src_var: FixedOffsetVar<'_>,
+) -> String {
+    fn print_sum(arg1: &str, arg2: &Offset) -> String {
+        match (arg1, &arg2.value[..], arg2.sign) {
+            ("0", "0", _) => "0".into(),
+            ("0", x, OffsetSign::Positive) | (x, "0", _) => x.into(),
+            ("0", x, OffsetSign::Negative) => format!("-{}", x),
+            (x, y, OffsetSign::Positive) => format!("({} + {})", x, y),
+            (x, y, OffsetSign::Negative) => {
+                if x == y {
+                    "0".into()
+                } else {
+                    format!("({} - {})", x, y)
+                }
+            },
+        }
+    }
+
+    fn print_offset(start_str: &str, inline_offset: &Offset) -> String {
+        let offset = print_sum(start_str, inline_offset);
+        if offset.as_str() == "0" {
+            "".into()
+        } else {
+            offset
+        }
+    }
+
+    let print_limit = |end: &Expr<'_>, offset: Offset, var: &Expr<'_>| {
+        if_chain! {
+            if let ExprKind::MethodCall(method, _, len_args) = end.kind;
+            if method.ident.name == sym!(len);
+            if len_args.len() == 1;
+            if let Some(arg) = len_args.get(0);
+            if var_def_id(cx, arg) == var_def_id(cx, var);
+            then {
+                match offset.sign {
+                    OffsetSign::Negative => format!("({} - {})", snippet(cx, end.span, "<src>.len()"), offset.value),
+                    OffsetSign::Positive => "".into(),
+                }
+            } else {
+                let end_str = match limits {
+                    ast::RangeLimits::Closed => {
+                        let end = sugg::Sugg::hir(cx, end, "<count>");
+                        format!("{}", end + sugg::ONE)
+                    },
+                    ast::RangeLimits::HalfOpen => format!("{}", snippet(cx, end.span, "..")),
+                };
+
+                print_sum(&end_str, &offset)
+            }
+        }
+    };
+
+    let start_str = snippet(cx, start.span, "").to_string();
+    let dst_offset = print_offset(&start_str, &dst_var.offset);
+    let dst_limit = print_limit(end, dst_var.offset, dst_var.var);
+    let src_offset = print_offset(&start_str, &src_var.offset);
+    let src_limit = print_limit(end, src_var.offset, src_var.var);
+
+    let dst_var_name = snippet_opt(cx, dst_var.var.span).unwrap_or_else(|| "???".into());
+    let src_var_name = snippet_opt(cx, src_var.var.span).unwrap_or_else(|| "???".into());
+
+    let dst = if dst_offset == "" && dst_limit == "" {
+        dst_var_name
+    } else {
+        format!("{}[{}..{}]", dst_var_name, dst_offset, dst_limit)
+    };
+
+    format!(
+        "{}.clone_from_slice(&{}[{}..{}])",
+        dst, src_var_name, src_offset, src_limit
+    )
+}
 /// Checks for for loops that sequentially copy items from one slice-like
 /// object to another.
 fn detect_manual_memcpy<'a, 'tcx>(
@@ -922,57 +1001,6 @@ fn detect_manual_memcpy<'a, 'tcx>(
     {
         // the var must be a single name
         if let PatKind::Binding(_, canonical_id, _, _) = pat.kind {
-            fn print_sum(arg1: &str, arg2: &Offset) -> String {
-                match (arg1, &arg2.value[..], arg2.sign) {
-                    ("0", "0", _) => "0".into(),
-                    ("0", x, OffsetSign::Positive) | (x, "0", _) => x.into(),
-                    ("0", x, OffsetSign::Negative) => format!("-{}", x),
-                    (x, y, OffsetSign::Positive) => format!("({} + {})", x, y),
-                    (x, y, OffsetSign::Negative) => {
-                        if x == y {
-                            "0".into()
-                        } else {
-                            format!("({} - {})", x, y)
-                        }
-                    },
-                }
-            }
-
-            fn print_offset(start_str: &str, inline_offset: &Offset) -> String {
-                let offset = print_sum(start_str, inline_offset);
-                if offset.as_str() == "0" {
-                    "".into()
-                } else {
-                    offset
-                }
-            }
-
-            let print_limit = |end: &Expr<'_>, offset: Offset, var: &Expr<'_>| {
-                if_chain! {
-                    if let ExprKind::MethodCall(method, _, len_args) = end.kind;
-                    if method.ident.name == sym!(len);
-                    if len_args.len() == 1;
-                    if let Some(arg) = len_args.get(0);
-                    if var_def_id(cx, arg) == var_def_id(cx, var);
-                    then {
-                        match offset.sign {
-                            OffsetSign::Negative => format!("({} - {})", snippet(cx, end.span, "<src>.len()"), offset.value),
-                            OffsetSign::Positive => "".into(),
-                        }
-                    } else {
-                        let end_str = match limits {
-                            ast::RangeLimits::Closed => {
-                                let end = sugg::Sugg::hir(cx, end, "<count>");
-                                format!("{}", end + sugg::ONE)
-                            },
-                            ast::RangeLimits::HalfOpen => format!("{}", snippet(cx, end.span, "..")),
-                        };
-
-                        print_sum(&end_str, &offset)
-                    }
-                }
-            };
-
             // The only statements in the for loops can be indexed assignments from
             // indexed retrievals.
             let big_sugg = get_assignments(body)
@@ -998,29 +1026,7 @@ fn detect_manual_memcpy<'a, 'tcx>(
                         }
                     })
                 })
-                .map(|o| {
-                    o.map(|(dst_var, src_var)| {
-                        let start_str = snippet(cx, start.span, "").to_string();
-                        let dst_offset = print_offset(&start_str, &dst_var.offset);
-                        let dst_limit = print_limit(end, dst_var.offset, dst_var.var);
-                        let src_offset = print_offset(&start_str, &src_var.offset);
-                        let src_limit = print_limit(end, src_var.offset, src_var.var);
-
-                        let dst_var_name = snippet_opt(cx, dst_var.var.span).unwrap_or_else(|| "???".into());
-                        let src_var_name = snippet_opt(cx, src_var.var.span).unwrap_or_else(|| "???".into());
-
-                        let dst = if dst_offset == "" && dst_limit == "" {
-                            dst_var_name
-                        } else {
-                            format!("{}[{}..{}]", dst_var_name, dst_offset, dst_limit)
-                        };
-
-                        format!(
-                            "{}.clone_from_slice(&{}[{}..{}])",
-                            dst, src_var_name, src_offset, src_limit
-                        )
-                    })
-                })
+                .map(|o| o.map(|(dst, src)| build_manual_memcpy_suggestion(cx, start, end, limits, dst, src)))
                 .collect::<Option<Vec<_>>>()
                 .filter(|v| !v.is_empty())
                 .map(|v| v.join("\n    "));
-- 
cgit 1.4.1-3-g733a5


From 51585a129892f42eb23b0b37fea0e729f6678994 Mon Sep 17 00:00:00 2001
From: rail <12975677+rail-rain@users.noreply.github.com>
Date: Mon, 27 Apr 2020 20:37:21 +1200
Subject: Removed unused lifetimes and a needless bool

---
 clippy_lints/src/loops.rs | 11 ++++-------
 1 file changed, 4 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 7cf3e16bef9..5f7f0897943 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -775,10 +775,9 @@ fn same_var<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &Expr<'_>, var: HirId) -
         if let QPath::Resolved(None, path) = qpath;
         if path.segments.len() == 1;
         if let Res::Local(local_id) = qpath_res(cx, qpath, expr.hir_id);
-        // our variable!
-        if local_id == var;
         then {
-            true
+            // our variable!
+            local_id == var
         } else {
             false
         }
@@ -870,10 +869,8 @@ fn get_offset<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, idx: &Expr<'_>, var: HirId)
     }
 }
 
-fn get_assignments<'a, 'tcx>(
-    body: &'tcx Expr<'tcx>,
-) -> impl Iterator<Item = Option<(&'tcx Expr<'tcx>, &'tcx Expr<'tcx>)>> {
-    fn get_assignment<'a, 'tcx>(e: &'tcx Expr<'tcx>) -> Option<(&'tcx Expr<'tcx>, &'tcx Expr<'tcx>)> {
+fn get_assignments<'tcx>(body: &'tcx Expr<'tcx>) -> impl Iterator<Item = Option<(&'tcx Expr<'tcx>, &'tcx Expr<'tcx>)>> {
+    fn get_assignment<'tcx>(e: &'tcx Expr<'tcx>) -> Option<(&'tcx Expr<'tcx>, &'tcx Expr<'tcx>)> {
         if let ExprKind::Assign(lhs, rhs, _) = e.kind {
             Some((lhs, rhs))
         } else {
-- 
cgit 1.4.1-3-g733a5


From 1afb6e6e3b23bd5555f34cc4dcd20349dfd789de Mon Sep 17 00:00:00 2001
From: Stanislav Tkach <stanislav.tkach@gmail.com>
Date: Tue, 28 Apr 2020 12:08:38 +0300
Subject: Extend example for the `unneeded_field_pattern` lint

Current example is incorrect (or pseudo-code) because a struct name is omitted. I have used the code from the tests instead. Perhaps this example can be made less verbose, but I think it is more convenient to see a "real" code as an example.
---
 clippy_lints/src/misc_early.rs | 21 +++++++++++++++++++--
 1 file changed, 19 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/misc_early.rs b/clippy_lints/src/misc_early.rs
index adfd8dfb1c1..62ee051624b 100644
--- a/clippy_lints/src/misc_early.rs
+++ b/clippy_lints/src/misc_early.rs
@@ -24,8 +24,25 @@ declare_clippy_lint! {
     /// **Known problems:** None.
     ///
     /// **Example:**
-    /// ```ignore
-    /// let { a: _, b: ref b, c: _ } = ..
+    /// ```rust
+    /// # struct Foo {
+    /// #     a: i32,
+    /// #     b: i32,
+    /// #     c: i32,
+    /// # }
+    /// let f = Foo { a: 0, b: 0, c: 0 };
+    ///
+    /// // Bad
+    /// match f {
+    ///     Foo { a: _, b: 0, .. } => {},
+    ///     Foo { a: _, b: _, c: _ } => {},
+    /// }
+    ///
+    /// // Good
+    /// match f {
+    ///     Foo { b: 0, .. } => {},
+    ///     Foo { .. } => {},
+    /// }
     /// ```
     pub UNNEEDED_FIELD_PATTERN,
     restriction,
-- 
cgit 1.4.1-3-g733a5


From f072ded3bf6286668ff8eade5b58e471dbe66f2a Mon Sep 17 00:00:00 2001
From: Eduardo Broto <ebroto@tutanota.com>
Date: Fri, 1 May 2020 01:44:17 +0200
Subject: Implement the manual_non_exhaustive lint

---
 CHANGELOG.md                              |   1 +
 clippy_lints/src/lib.rs                   |   5 +
 clippy_lints/src/manual_non_exhaustive.rs | 167 ++++++++++++++++++++++++++++++
 src/lintlist/mod.rs                       |   7 ++
 tests/ui/manual_non_exhaustive.rs         | 124 ++++++++++++++++++++++
 tests/ui/manual_non_exhaustive.stderr     |  48 +++++++++
 6 files changed, 352 insertions(+)
 create mode 100644 clippy_lints/src/manual_non_exhaustive.rs
 create mode 100644 tests/ui/manual_non_exhaustive.rs
 create mode 100644 tests/ui/manual_non_exhaustive.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 575773580c0..facf363e371 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1423,6 +1423,7 @@ Released 2018-09-13
 [`macro_use_imports`]: https://rust-lang.github.io/rust-clippy/master/index.html#macro_use_imports
 [`main_recursion`]: https://rust-lang.github.io/rust-clippy/master/index.html#main_recursion
 [`manual_memcpy`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_memcpy
+[`manual_non_exhaustive`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_non_exhaustive
 [`manual_saturating_arithmetic`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_saturating_arithmetic
 [`manual_swap`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_swap
 [`many_single_char_names`]: https://rust-lang.github.io/rust-clippy/master/index.html#many_single_char_names
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index c995be5edc2..64f3a8a0ebb 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -247,6 +247,7 @@ mod literal_representation;
 mod loops;
 mod macro_use;
 mod main_recursion;
+mod manual_non_exhaustive;
 mod map_clone;
 mod map_unit_fn;
 mod match_on_vec_items;
@@ -628,6 +629,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &loops::WHILE_LET_ON_ITERATOR,
         &macro_use::MACRO_USE_IMPORTS,
         &main_recursion::MAIN_RECURSION,
+        &manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE,
         &map_clone::MAP_CLONE,
         &map_unit_fn::OPTION_MAP_UNIT_FN,
         &map_unit_fn::RESULT_MAP_UNIT_FN,
@@ -1064,6 +1066,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box utils::internal_lints::CollapsibleCalls);
     store.register_late_pass(|| box if_let_mutex::IfLetMutex);
     store.register_late_pass(|| box match_on_vec_items::MatchOnVecItems);
+    store.register_early_pass(|| box manual_non_exhaustive::ManualNonExhaustive);
 
     store.register_group(true, "clippy::restriction", Some("clippy_restriction"), vec![
         LintId::of(&arithmetic::FLOAT_ARITHMETIC),
@@ -1280,6 +1283,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&loops::WHILE_LET_LOOP),
         LintId::of(&loops::WHILE_LET_ON_ITERATOR),
         LintId::of(&main_recursion::MAIN_RECURSION),
+        LintId::of(&manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE),
         LintId::of(&map_clone::MAP_CLONE),
         LintId::of(&map_unit_fn::OPTION_MAP_UNIT_FN),
         LintId::of(&map_unit_fn::RESULT_MAP_UNIT_FN),
@@ -1474,6 +1478,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&loops::NEEDLESS_RANGE_LOOP),
         LintId::of(&loops::WHILE_LET_ON_ITERATOR),
         LintId::of(&main_recursion::MAIN_RECURSION),
+        LintId::of(&manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE),
         LintId::of(&map_clone::MAP_CLONE),
         LintId::of(&matches::INFALLIBLE_DESTRUCTURING_MATCH),
         LintId::of(&matches::MATCH_OVERLAPPING_ARM),
diff --git a/clippy_lints/src/manual_non_exhaustive.rs b/clippy_lints/src/manual_non_exhaustive.rs
new file mode 100644
index 00000000000..ca2a2cf2e1e
--- /dev/null
+++ b/clippy_lints/src/manual_non_exhaustive.rs
@@ -0,0 +1,167 @@
+use crate::utils::{snippet_opt, span_lint_and_then};
+use if_chain::if_chain;
+use rustc_ast::ast::{Attribute, Ident, Item, ItemKind, StructField, TyKind, Variant, VariantData, VisibilityKind};
+use rustc_attr as attr;
+use rustc_errors::Applicability;
+use rustc_lint::{EarlyContext, EarlyLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for manual implementations of the non-exhaustive pattern.
+    ///
+    /// **Why is this bad?** Using the #[non_exhaustive] attribute expresses better the intent
+    /// and allows possible optimizations when applied to enums.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// struct S {
+    ///     pub a: i32,
+    ///     pub b: i32,
+    ///     _c: (),
+    /// }
+    ///
+    /// enum E {
+    ///     A,
+    ///     B,
+    ///     #[doc(hidden)]
+    ///     _C,
+    /// }
+    ///
+    /// struct T(pub i32, pub i32, ());
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// #[non_exhaustive]
+    /// struct S {
+    ///     pub a: i32,
+    ///     pub b: i32,
+    /// }
+    ///
+    /// #[non_exhaustive]
+    /// enum E {
+    ///     A,
+    ///     B,
+    /// }
+    ///
+    /// #[non_exhaustive]
+    /// struct T(pub i32, pub i32);
+    /// ```
+    pub MANUAL_NON_EXHAUSTIVE,
+    style,
+    "manual implementations of the non-exhaustive pattern can be simplified using #[non_exhaustive]"
+}
+
+declare_lint_pass!(ManualNonExhaustive => [MANUAL_NON_EXHAUSTIVE]);
+
+impl EarlyLintPass for ManualNonExhaustive {
+    fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {
+        match &item.kind {
+            ItemKind::Enum(def, _) => {
+                check_manual_non_exhaustive_enum(cx, item, &def.variants);
+            },
+            ItemKind::Struct(variant_data, _) => {
+                if let VariantData::Unit(..) = variant_data {
+                    return;
+                }
+
+                check_manual_non_exhaustive_struct(cx, item, variant_data);
+            },
+            _ => {},
+        }
+    }
+}
+
+fn check_manual_non_exhaustive_enum(cx: &EarlyContext<'_>, item: &Item, variants: &[Variant]) {
+    fn is_non_exhaustive_marker(variant: &Variant) -> bool {
+        matches!(variant.data, VariantData::Unit(_))
+            && variant.ident.as_str().starts_with('_')
+            && variant.attrs.iter().any(|a| is_doc_hidden(a))
+    }
+
+    fn is_doc_hidden(attr: &Attribute) -> bool {
+        attr.check_name(sym!(doc))
+            && match attr.meta_item_list() {
+                Some(l) => attr::list_contains_name(&l, sym!(hidden)),
+                None => false,
+            }
+    }
+
+    if_chain! {
+        if !attr::contains_name(&item.attrs, sym!(non_exhaustive));
+        let markers = variants.iter().filter(|v| is_non_exhaustive_marker(v)).count();
+        if markers == 1 && variants.len() > markers;
+        if let Some(variant) = variants.last();
+        if is_non_exhaustive_marker(variant);
+        then {
+            span_lint_and_then(
+                cx,
+                MANUAL_NON_EXHAUSTIVE,
+                item.span,
+                "this seems like a manual implementation of the non-exhaustive pattern",
+                |diag| {
+                    let header_span = cx.sess.source_map().span_until_char(item.span, '{');
+
+                    if let Some(snippet) = snippet_opt(cx, header_span) {
+                        diag.span_suggestion(
+                            item.span,
+                            "add the attribute",
+                            format!("#[non_exhaustive] {}", snippet),
+                            Applicability::Unspecified,
+                        );
+                        diag.span_help(variant.span, "and remove this variant");
+                    }
+                });
+        }
+    }
+}
+
+fn check_manual_non_exhaustive_struct(cx: &EarlyContext<'_>, item: &Item, data: &VariantData) {
+    fn is_private(field: &StructField) -> bool {
+        matches!(field.vis.node, VisibilityKind::Inherited)
+    }
+
+    fn is_non_exhaustive_marker(name: &Option<Ident>) -> bool {
+        name.map(|n| n.as_str().starts_with('_')).unwrap_or(true)
+    }
+
+    let fields = data.fields();
+    let private_fields = fields.iter().filter(|f| is_private(f)).count();
+    let public_fields = fields.iter().filter(|f| f.vis.node.is_pub()).count();
+
+    if_chain! {
+        if !attr::contains_name(&item.attrs, sym!(non_exhaustive));
+        if private_fields == 1 && public_fields >= private_fields && public_fields == fields.len() - 1;
+        if let Some(field) = fields.iter().find(|f| is_private(f));
+        if is_non_exhaustive_marker(&field.ident);
+        if let TyKind::Tup(tup_fields) = &field.ty.kind;
+        if tup_fields.is_empty();
+        then {
+            span_lint_and_then(
+                cx,
+                MANUAL_NON_EXHAUSTIVE,
+                item.span,
+                "this seems like a manual implementation of the non-exhaustive pattern",
+                |diag| {
+                    let delimiter = match data {
+                        VariantData::Struct(..) => '{',
+                        VariantData::Tuple(..) => '(',
+                        _ => unreachable!(),
+                    };
+                    let header_span = cx.sess.source_map().span_until_char(item.span, delimiter);
+
+                    if let Some(snippet) = snippet_opt(cx, header_span) {
+                        diag.span_suggestion(
+                            item.span,
+                            "add the attribute",
+                            format!("#[non_exhaustive] {}", snippet),
+                            Applicability::Unspecified,
+                        );
+                        diag.span_help(field.span, "and remove this field");
+                    }
+                });
+        }
+    }
+}
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index 72675c25175..c5360002fa0 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -1088,6 +1088,13 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
         deprecation: None,
         module: "loops",
     },
+    Lint {
+        name: "manual_non_exhaustive",
+        group: "style",
+        desc: "manual implementations of the non-exhaustive pattern can be simplified using #[non_exhaustive]",
+        deprecation: None,
+        module: "manual_non_exhaustive",
+    },
     Lint {
         name: "manual_saturating_arithmetic",
         group: "style",
diff --git a/tests/ui/manual_non_exhaustive.rs b/tests/ui/manual_non_exhaustive.rs
new file mode 100644
index 00000000000..9c239db6e00
--- /dev/null
+++ b/tests/ui/manual_non_exhaustive.rs
@@ -0,0 +1,124 @@
+#![warn(clippy::manual_non_exhaustive)]
+#![allow(unused)]
+
+mod enums {
+    enum E {
+        A,
+        B,
+        #[doc(hidden)]
+        _C,
+    }
+
+    // last variant does not have doc hidden attribute, should be ignored
+    enum NoDocHidden {
+        A,
+        B,
+        _C,
+    }
+
+    // name of variant with doc hidden does not start with underscore, should be ignored
+    enum NoUnderscore {
+        A,
+        B,
+        #[doc(hidden)]
+        C,
+    }
+
+    // variant with doc hidden is not unit, should be ignored
+    enum NotUnit {
+        A,
+        B,
+        #[doc(hidden)]
+        _C(bool),
+    }
+
+    // variant with doc hidden is not the last one, should be ignored
+    enum NotLast {
+        A,
+        #[doc(hidden)]
+        _B,
+        C,
+    }
+
+    // variant with doc hidden is the only one, should be ignored
+    enum OnlyMarker {
+        #[doc(hidden)]
+        _A,
+    }
+
+    // variant with multiple non-exhaustive "markers", should be ignored
+    enum MultipleMarkers {
+        A,
+        #[doc(hidden)]
+        _B,
+        #[doc(hidden)]
+        _C,
+    }
+
+    // already non_exhaustive, should be ignored
+    #[non_exhaustive]
+    enum NonExhaustive {
+        A,
+        B,
+    }
+}
+
+mod structs {
+    struct S {
+        pub a: i32,
+        pub b: i32,
+        _c: (),
+    }
+
+    // some other fields are private, should be ignored
+    struct PrivateFields {
+        a: i32,
+        pub b: i32,
+        _c: (),
+    }
+
+    // private field name does not start with underscore, should be ignored
+    struct NoUnderscore {
+        pub a: i32,
+        pub b: i32,
+        c: (),
+    }
+
+    // private field is not unit type, should be ignored
+    struct NotUnit {
+        pub a: i32,
+        pub b: i32,
+        _c: i32,
+    }
+
+    // private field is the only field, should be ignored
+    struct OnlyMarker {
+        _a: (),
+    }
+
+    // already non exhaustive, should be ignored
+    #[non_exhaustive]
+    struct NonExhaustive {
+        pub a: i32,
+        pub b: i32,
+    }
+}
+
+mod tuple_structs {
+    struct T(pub i32, pub i32, ());
+
+    // some other fields are private, should be ignored
+    struct PrivateFields(pub i32, i32, ());
+
+    // private field is not unit type, should be ignored
+    struct NotUnit(pub i32, pub i32, i32);
+
+    // private field is the only field, should be ignored
+    struct OnlyMarker(());
+
+    // already non exhaustive, should be ignored
+    #[non_exhaustive]
+    struct NonExhaustive(pub i32, pub i32);
+}
+
+fn main() {}
diff --git a/tests/ui/manual_non_exhaustive.stderr b/tests/ui/manual_non_exhaustive.stderr
new file mode 100644
index 00000000000..d6719bca0d4
--- /dev/null
+++ b/tests/ui/manual_non_exhaustive.stderr
@@ -0,0 +1,48 @@
+error: this seems like a manual implementation of the non-exhaustive pattern
+  --> $DIR/manual_non_exhaustive.rs:5:5
+   |
+LL | /     enum E {
+LL | |         A,
+LL | |         B,
+LL | |         #[doc(hidden)]
+LL | |         _C,
+LL | |     }
+   | |_____^ help: add the attribute: `#[non_exhaustive] enum E`
+   |
+   = note: `-D clippy::manual-non-exhaustive` implied by `-D warnings`
+help: and remove this variant
+  --> $DIR/manual_non_exhaustive.rs:9:9
+   |
+LL |         _C,
+   |         ^^
+
+error: this seems like a manual implementation of the non-exhaustive pattern
+  --> $DIR/manual_non_exhaustive.rs:67:5
+   |
+LL | /     struct S {
+LL | |         pub a: i32,
+LL | |         pub b: i32,
+LL | |         _c: (),
+LL | |     }
+   | |_____^ help: add the attribute: `#[non_exhaustive] struct S`
+   |
+help: and remove this field
+  --> $DIR/manual_non_exhaustive.rs:70:9
+   |
+LL |         _c: (),
+   |         ^^^^^^
+
+error: this seems like a manual implementation of the non-exhaustive pattern
+  --> $DIR/manual_non_exhaustive.rs:108:5
+   |
+LL |     struct T(pub i32, pub i32, ());
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: add the attribute: `#[non_exhaustive] struct T`
+   |
+help: and remove this field
+  --> $DIR/manual_non_exhaustive.rs:108:32
+   |
+LL |     struct T(pub i32, pub i32, ());
+   |                                ^^
+
+error: aborting due to 3 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 42b0b4754c881101cefb0307c489d6159c19b2f3 Mon Sep 17 00:00:00 2001
From: Eduardo Broto <ebroto@tutanota.com>
Date: Fri, 1 May 2020 22:37:14 +0200
Subject: Apply suggestions from PR review

---
 clippy_lints/src/manual_non_exhaustive.rs | 84 +++++++++++++++++--------------
 tests/ui/manual_non_exhaustive.rs         | 39 +++++++++-----
 tests/ui/manual_non_exhaustive.stderr     | 81 ++++++++++++++++++++++++-----
 3 files changed, 139 insertions(+), 65 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_non_exhaustive.rs b/clippy_lints/src/manual_non_exhaustive.rs
index ca2a2cf2e1e..a4273da1d74 100644
--- a/clippy_lints/src/manual_non_exhaustive.rs
+++ b/clippy_lints/src/manual_non_exhaustive.rs
@@ -1,10 +1,11 @@
 use crate::utils::{snippet_opt, span_lint_and_then};
 use if_chain::if_chain;
-use rustc_ast::ast::{Attribute, Ident, Item, ItemKind, StructField, TyKind, Variant, VariantData, VisibilityKind};
+use rustc_ast::ast::{Attribute, Item, ItemKind, StructField, Variant, VariantData, VisibilityKind};
 use rustc_attr as attr;
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::Span;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for manual implementations of the non-exhaustive pattern.
@@ -90,11 +91,9 @@ fn check_manual_non_exhaustive_enum(cx: &EarlyContext<'_>, item: &Item, variants
     }
 
     if_chain! {
-        if !attr::contains_name(&item.attrs, sym!(non_exhaustive));
-        let markers = variants.iter().filter(|v| is_non_exhaustive_marker(v)).count();
-        if markers == 1 && variants.len() > markers;
-        if let Some(variant) = variants.last();
-        if is_non_exhaustive_marker(variant);
+        let mut markers = variants.iter().filter(|v| is_non_exhaustive_marker(v));
+        if let Some(marker) = markers.next();
+        if markers.count() == 0 && variants.len() > 1;
         then {
             span_lint_and_then(
                 cx,
@@ -102,17 +101,20 @@ fn check_manual_non_exhaustive_enum(cx: &EarlyContext<'_>, item: &Item, variants
                 item.span,
                 "this seems like a manual implementation of the non-exhaustive pattern",
                 |diag| {
-                    let header_span = cx.sess.source_map().span_until_char(item.span, '{');
-
-                    if let Some(snippet) = snippet_opt(cx, header_span) {
-                        diag.span_suggestion(
-                            item.span,
-                            "add the attribute",
-                            format!("#[non_exhaustive] {}", snippet),
-                            Applicability::Unspecified,
-                        );
-                        diag.span_help(variant.span, "and remove this variant");
+                    if_chain! {
+                        if !attr::contains_name(&item.attrs, sym!(non_exhaustive));
+                        let header_span = cx.sess.source_map().span_until_char(item.span, '{');
+                        if let Some(snippet) = snippet_opt(cx, header_span);
+                        then {
+                            diag.span_suggestion(
+                                header_span,
+                                "add the attribute",
+                                format!("#[non_exhaustive] {}", snippet),
+                                Applicability::Unspecified,
+                            );
+                        }
                     }
+                    diag.span_help(marker.span, "remove this variant");
                 });
         }
     }
@@ -123,8 +125,18 @@ fn check_manual_non_exhaustive_struct(cx: &EarlyContext<'_>, item: &Item, data:
         matches!(field.vis.node, VisibilityKind::Inherited)
     }
 
-    fn is_non_exhaustive_marker(name: &Option<Ident>) -> bool {
-        name.map(|n| n.as_str().starts_with('_')).unwrap_or(true)
+    fn is_non_exhaustive_marker(field: &StructField) -> bool {
+        is_private(field) && field.ty.kind.is_unit() && field.ident.map_or(true, |n| n.as_str().starts_with('_'))
+    }
+
+    fn find_header_span(cx: &EarlyContext<'_>, item: &Item, data: &VariantData) -> Span {
+        let delimiter = match data {
+            VariantData::Struct(..) => '{',
+            VariantData::Tuple(..) => '(',
+            _ => unreachable!("`VariantData::Unit` is already handled above"),
+        };
+
+        cx.sess.source_map().span_until_char(item.span, delimiter)
     }
 
     let fields = data.fields();
@@ -132,12 +144,8 @@ fn check_manual_non_exhaustive_struct(cx: &EarlyContext<'_>, item: &Item, data:
     let public_fields = fields.iter().filter(|f| f.vis.node.is_pub()).count();
 
     if_chain! {
-        if !attr::contains_name(&item.attrs, sym!(non_exhaustive));
-        if private_fields == 1 && public_fields >= private_fields && public_fields == fields.len() - 1;
-        if let Some(field) = fields.iter().find(|f| is_private(f));
-        if is_non_exhaustive_marker(&field.ident);
-        if let TyKind::Tup(tup_fields) = &field.ty.kind;
-        if tup_fields.is_empty();
+        if private_fields == 1 && public_fields >= 1 && public_fields == fields.len() - 1;
+        if let Some(marker) = fields.iter().find(|f| is_non_exhaustive_marker(f));
         then {
             span_lint_and_then(
                 cx,
@@ -145,22 +153,20 @@ fn check_manual_non_exhaustive_struct(cx: &EarlyContext<'_>, item: &Item, data:
                 item.span,
                 "this seems like a manual implementation of the non-exhaustive pattern",
                 |diag| {
-                    let delimiter = match data {
-                        VariantData::Struct(..) => '{',
-                        VariantData::Tuple(..) => '(',
-                        _ => unreachable!(),
-                    };
-                    let header_span = cx.sess.source_map().span_until_char(item.span, delimiter);
-
-                    if let Some(snippet) = snippet_opt(cx, header_span) {
-                        diag.span_suggestion(
-                            item.span,
-                            "add the attribute",
-                            format!("#[non_exhaustive] {}", snippet),
-                            Applicability::Unspecified,
-                        );
-                        diag.span_help(field.span, "and remove this field");
+                    if_chain! {
+                        if !attr::contains_name(&item.attrs, sym!(non_exhaustive));
+                        let header_span = find_header_span(cx, item, data);
+                        if let Some(snippet) = snippet_opt(cx, header_span);
+                        then {
+                            diag.span_suggestion(
+                                header_span,
+                                "add the attribute",
+                                format!("#[non_exhaustive] {}", snippet),
+                                Applicability::Unspecified,
+                            );
+                        }
                     }
+                    diag.span_help(marker.span, "remove this field");
                 });
         }
     }
diff --git a/tests/ui/manual_non_exhaustive.rs b/tests/ui/manual_non_exhaustive.rs
index 9c239db6e00..7a788f48520 100644
--- a/tests/ui/manual_non_exhaustive.rs
+++ b/tests/ui/manual_non_exhaustive.rs
@@ -9,7 +9,16 @@ mod enums {
         _C,
     }
 
-    // last variant does not have doc hidden attribute, should be ignored
+    // user forgot to remove the marker
+    #[non_exhaustive]
+    enum Ep {
+        A,
+        B,
+        #[doc(hidden)]
+        _C,
+    }
+
+    // marker variant does not have doc hidden attribute, should be ignored
     enum NoDocHidden {
         A,
         B,
@@ -32,21 +41,13 @@ mod enums {
         _C(bool),
     }
 
-    // variant with doc hidden is not the last one, should be ignored
-    enum NotLast {
-        A,
-        #[doc(hidden)]
-        _B,
-        C,
-    }
-
     // variant with doc hidden is the only one, should be ignored
     enum OnlyMarker {
         #[doc(hidden)]
         _A,
     }
 
-    // variant with multiple non-exhaustive "markers", should be ignored
+    // variant with multiple markers, should be ignored
     enum MultipleMarkers {
         A,
         #[doc(hidden)]
@@ -55,7 +56,7 @@ mod enums {
         _C,
     }
 
-    // already non_exhaustive, should be ignored
+    // already non_exhaustive and no markers, should be ignored
     #[non_exhaustive]
     enum NonExhaustive {
         A,
@@ -70,6 +71,14 @@ mod structs {
         _c: (),
     }
 
+    // user forgot to remove the private field
+    #[non_exhaustive]
+    struct Sp {
+        pub a: i32,
+        pub b: i32,
+        _c: (),
+    }
+
     // some other fields are private, should be ignored
     struct PrivateFields {
         a: i32,
@@ -96,7 +105,7 @@ mod structs {
         _a: (),
     }
 
-    // already non exhaustive, should be ignored
+    // already non exhaustive and no private fields, should be ignored
     #[non_exhaustive]
     struct NonExhaustive {
         pub a: i32,
@@ -107,6 +116,10 @@ mod structs {
 mod tuple_structs {
     struct T(pub i32, pub i32, ());
 
+    // user forgot to remove the private field
+    #[non_exhaustive]
+    struct Tp(pub i32, pub i32, ());
+
     // some other fields are private, should be ignored
     struct PrivateFields(pub i32, i32, ());
 
@@ -116,7 +129,7 @@ mod tuple_structs {
     // private field is the only field, should be ignored
     struct OnlyMarker(());
 
-    // already non exhaustive, should be ignored
+    // already non exhaustive and no private fields, should be ignored
     #[non_exhaustive]
     struct NonExhaustive(pub i32, pub i32);
 }
diff --git a/tests/ui/manual_non_exhaustive.stderr b/tests/ui/manual_non_exhaustive.stderr
index d6719bca0d4..613c5e8ca1d 100644
--- a/tests/ui/manual_non_exhaustive.stderr
+++ b/tests/ui/manual_non_exhaustive.stderr
@@ -1,48 +1,103 @@
 error: this seems like a manual implementation of the non-exhaustive pattern
   --> $DIR/manual_non_exhaustive.rs:5:5
    |
-LL | /     enum E {
+LL |       enum E {
+   |       ^-----
+   |       |
+   |  _____help: add the attribute: `#[non_exhaustive] enum E`
+   | |
 LL | |         A,
 LL | |         B,
 LL | |         #[doc(hidden)]
 LL | |         _C,
 LL | |     }
-   | |_____^ help: add the attribute: `#[non_exhaustive] enum E`
+   | |_____^
    |
    = note: `-D clippy::manual-non-exhaustive` implied by `-D warnings`
-help: and remove this variant
+help: remove this variant
   --> $DIR/manual_non_exhaustive.rs:9:9
    |
 LL |         _C,
    |         ^^
 
 error: this seems like a manual implementation of the non-exhaustive pattern
-  --> $DIR/manual_non_exhaustive.rs:67:5
+  --> $DIR/manual_non_exhaustive.rs:14:5
    |
-LL | /     struct S {
+LL | /     enum Ep {
+LL | |         A,
+LL | |         B,
+LL | |         #[doc(hidden)]
+LL | |         _C,
+LL | |     }
+   | |_____^
+   |
+help: remove this variant
+  --> $DIR/manual_non_exhaustive.rs:18:9
+   |
+LL |         _C,
+   |         ^^
+
+error: this seems like a manual implementation of the non-exhaustive pattern
+  --> $DIR/manual_non_exhaustive.rs:68:5
+   |
+LL |       struct S {
+   |       ^-------
+   |       |
+   |  _____help: add the attribute: `#[non_exhaustive] struct S`
+   | |
+LL | |         pub a: i32,
+LL | |         pub b: i32,
+LL | |         _c: (),
+LL | |     }
+   | |_____^
+   |
+help: remove this field
+  --> $DIR/manual_non_exhaustive.rs:71:9
+   |
+LL |         _c: (),
+   |         ^^^^^^
+
+error: this seems like a manual implementation of the non-exhaustive pattern
+  --> $DIR/manual_non_exhaustive.rs:76:5
+   |
+LL | /     struct Sp {
 LL | |         pub a: i32,
 LL | |         pub b: i32,
 LL | |         _c: (),
 LL | |     }
-   | |_____^ help: add the attribute: `#[non_exhaustive] struct S`
+   | |_____^
    |
-help: and remove this field
-  --> $DIR/manual_non_exhaustive.rs:70:9
+help: remove this field
+  --> $DIR/manual_non_exhaustive.rs:79:9
    |
 LL |         _c: (),
    |         ^^^^^^
 
 error: this seems like a manual implementation of the non-exhaustive pattern
-  --> $DIR/manual_non_exhaustive.rs:108:5
+  --> $DIR/manual_non_exhaustive.rs:117:5
    |
 LL |     struct T(pub i32, pub i32, ());
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: add the attribute: `#[non_exhaustive] struct T`
+   |     --------^^^^^^^^^^^^^^^^^^^^^^^
+   |     |
+   |     help: add the attribute: `#[non_exhaustive] struct T`
    |
-help: and remove this field
-  --> $DIR/manual_non_exhaustive.rs:108:32
+help: remove this field
+  --> $DIR/manual_non_exhaustive.rs:117:32
    |
 LL |     struct T(pub i32, pub i32, ());
    |                                ^^
 
-error: aborting due to 3 previous errors
+error: this seems like a manual implementation of the non-exhaustive pattern
+  --> $DIR/manual_non_exhaustive.rs:121:5
+   |
+LL |     struct Tp(pub i32, pub i32, ());
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove this field
+  --> $DIR/manual_non_exhaustive.rs:121:33
+   |
+LL |     struct Tp(pub i32, pub i32, ());
+   |                                 ^^
+
+error: aborting due to 6 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 10e3f9bdb854e3cabbc4fda69ed713388344d524 Mon Sep 17 00:00:00 2001
From: flip1995 <hello@philkrones.com>
Date: Fri, 1 May 2020 23:02:31 +0200
Subject: Move match_on_vec_items to pedantic

---
 clippy_lints/src/lib.rs                | 3 +--
 clippy_lints/src/match_on_vec_items.rs | 2 +-
 src/lintlist/mod.rs                    | 2 +-
 3 files changed, 3 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index c995be5edc2..06e21a5272e 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1138,6 +1138,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&loops::EXPLICIT_INTO_ITER_LOOP),
         LintId::of(&loops::EXPLICIT_ITER_LOOP),
         LintId::of(&macro_use::MACRO_USE_IMPORTS),
+        LintId::of(&match_on_vec_items::MATCH_ON_VEC_ITEMS),
         LintId::of(&matches::MATCH_BOOL),
         LintId::of(&matches::SINGLE_MATCH_ELSE),
         LintId::of(&methods::FILTER_MAP),
@@ -1283,7 +1284,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&map_clone::MAP_CLONE),
         LintId::of(&map_unit_fn::OPTION_MAP_UNIT_FN),
         LintId::of(&map_unit_fn::RESULT_MAP_UNIT_FN),
-        LintId::of(&match_on_vec_items::MATCH_ON_VEC_ITEMS),
         LintId::of(&matches::INFALLIBLE_DESTRUCTURING_MATCH),
         LintId::of(&matches::MATCH_AS_REF),
         LintId::of(&matches::MATCH_OVERLAPPING_ARM),
@@ -1647,7 +1647,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&loops::NEVER_LOOP),
         LintId::of(&loops::REVERSE_RANGE_LOOP),
         LintId::of(&loops::WHILE_IMMUTABLE_CONDITION),
-        LintId::of(&match_on_vec_items::MATCH_ON_VEC_ITEMS),
         LintId::of(&mem_discriminant::MEM_DISCRIMINANT_NON_ENUM),
         LintId::of(&mem_replace::MEM_REPLACE_WITH_UNINIT),
         LintId::of(&methods::CLONE_DOUBLE_REF),
diff --git a/clippy_lints/src/match_on_vec_items.rs b/clippy_lints/src/match_on_vec_items.rs
index 4071406cc84..421571d2f2f 100644
--- a/clippy_lints/src/match_on_vec_items.rs
+++ b/clippy_lints/src/match_on_vec_items.rs
@@ -38,7 +38,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     pub MATCH_ON_VEC_ITEMS,
-    correctness,
+    pedantic,
     "matching on vector elements can panic"
 }
 
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index 72675c25175..f337db72ba0 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -1146,7 +1146,7 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
     },
     Lint {
         name: "match_on_vec_items",
-        group: "correctness",
+        group: "pedantic",
         desc: "matching on vector elements can panic",
         deprecation: None,
         module: "match_on_vec_items",
-- 
cgit 1.4.1-3-g733a5


From 350c17de24c0bc7ee1b17981fe02f88ca6ec50a4 Mon Sep 17 00:00:00 2001
From: ebroto <ebroto@tutanota.com>
Date: Fri, 1 May 2020 23:00:16 +0200
Subject: Use the only variant left instead of a wildcard

Co-authored-by: Philipp Krones <hello@philkrones.com>
---
 clippy_lints/src/manual_non_exhaustive.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_non_exhaustive.rs b/clippy_lints/src/manual_non_exhaustive.rs
index a4273da1d74..f3b8902e26f 100644
--- a/clippy_lints/src/manual_non_exhaustive.rs
+++ b/clippy_lints/src/manual_non_exhaustive.rs
@@ -133,7 +133,7 @@ fn check_manual_non_exhaustive_struct(cx: &EarlyContext<'_>, item: &Item, data:
         let delimiter = match data {
             VariantData::Struct(..) => '{',
             VariantData::Tuple(..) => '(',
-            _ => unreachable!("`VariantData::Unit` is already handled above"),
+            VariantData::Unit(_) => unreachable!("`VariantData::Unit` is already handled above"),
         };
 
         cx.sess.source_map().span_until_char(item.span, delimiter)
-- 
cgit 1.4.1-3-g733a5


From 72ce6d5be9c54775b847bc0641f8d909b2977126 Mon Sep 17 00:00:00 2001
From: ThibsG <Thibs@debian.com>
Date: Fri, 24 Apr 2020 16:46:56 +0200
Subject: Fix unwrap lint when checks are done in parameters

---
 clippy_lints/src/unwrap.rs                         | 21 ++++++++++++-----
 tests/ui/checked_unwrap/simple_conditionals.rs     | 27 ++++++++++++++++++++++
 tests/ui/checked_unwrap/simple_conditionals.stderr | 24 +++++++++----------
 3 files changed, 54 insertions(+), 18 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unwrap.rs b/clippy_lints/src/unwrap.rs
index 5235c98efab..f3844c7d3b6 100644
--- a/clippy_lints/src/unwrap.rs
+++ b/clippy_lints/src/unwrap.rs
@@ -1,4 +1,7 @@
-use crate::utils::{higher::if_block, is_type_diagnostic_item, span_lint_and_then, usage::is_potentially_mutated};
+use crate::utils::{
+    differing_macro_contexts, higher::if_block, is_type_diagnostic_item, span_lint_and_then,
+    usage::is_potentially_mutated,
+};
 use if_chain::if_chain;
 use rustc_hir::intravisit::{walk_expr, walk_fn, FnKind, NestedVisitorMap, Visitor};
 use rustc_hir::{BinOpKind, Body, Expr, ExprKind, FnDecl, HirId, Path, QPath, UnOp};
@@ -73,6 +76,8 @@ struct UnwrapInfo<'tcx> {
     ident: &'tcx Path<'tcx>,
     /// The check, like `x.is_ok()`
     check: &'tcx Expr<'tcx>,
+    /// The branch where the check takes place, like `if x.is_ok() { .. }`
+    branch: &'tcx Expr<'tcx>,
     /// Whether `is_some()` or `is_ok()` was called (as opposed to `is_err()` or `is_none()`).
     safe_to_unwrap: bool,
 }
@@ -82,19 +87,20 @@ struct UnwrapInfo<'tcx> {
 fn collect_unwrap_info<'a, 'tcx>(
     cx: &'a LateContext<'a, 'tcx>,
     expr: &'tcx Expr<'_>,
+    branch: &'tcx Expr<'_>,
     invert: bool,
 ) -> Vec<UnwrapInfo<'tcx>> {
     if let ExprKind::Binary(op, left, right) = &expr.kind {
         match (invert, op.node) {
             (false, BinOpKind::And) | (false, BinOpKind::BitAnd) | (true, BinOpKind::Or) | (true, BinOpKind::BitOr) => {
-                let mut unwrap_info = collect_unwrap_info(cx, left, invert);
-                unwrap_info.append(&mut collect_unwrap_info(cx, right, invert));
+                let mut unwrap_info = collect_unwrap_info(cx, left, branch, invert);
+                unwrap_info.append(&mut collect_unwrap_info(cx, right, branch, invert));
                 return unwrap_info;
             },
             _ => (),
         }
     } else if let ExprKind::Unary(UnOp::UnNot, expr) = &expr.kind {
-        return collect_unwrap_info(cx, expr, !invert);
+        return collect_unwrap_info(cx, expr, branch, !invert);
     } else {
         if_chain! {
             if let ExprKind::MethodCall(method_name, _, args) = &expr.kind;
@@ -111,7 +117,7 @@ fn collect_unwrap_info<'a, 'tcx>(
                     _ => unreachable!(),
                 };
                 let safe_to_unwrap = unwrappable != invert;
-                return vec![UnwrapInfo { ident: path, check: expr, safe_to_unwrap }];
+                return vec![UnwrapInfo { ident: path, check: expr, branch, safe_to_unwrap }];
             }
         }
     }
@@ -121,7 +127,7 @@ fn collect_unwrap_info<'a, 'tcx>(
 impl<'a, 'tcx> UnwrappableVariablesVisitor<'a, 'tcx> {
     fn visit_branch(&mut self, cond: &'tcx Expr<'_>, branch: &'tcx Expr<'_>, else_branch: bool) {
         let prev_len = self.unwrappables.len();
-        for unwrap_info in collect_unwrap_info(self.cx, cond, else_branch) {
+        for unwrap_info in collect_unwrap_info(self.cx, cond, branch, else_branch) {
             if is_potentially_mutated(unwrap_info.ident, cond, self.cx)
                 || is_potentially_mutated(unwrap_info.ident, branch, self.cx)
             {
@@ -158,6 +164,9 @@ impl<'a, 'tcx> Visitor<'tcx> for UnwrappableVariablesVisitor<'a, 'tcx> {
                 let call_to_unwrap = method_name.ident.name == sym!(unwrap);
                 if let Some(unwrappable) = self.unwrappables.iter()
                     .find(|u| u.ident.res == path.res);
+                // Span contexts should not differ with the conditional branch
+                if !differing_macro_contexts(unwrappable.branch.span, expr.span);
+                if !differing_macro_contexts(unwrappable.branch.span, unwrappable.check.span);
                 then {
                     if call_to_unwrap == unwrappable.safe_to_unwrap {
                         span_lint_and_then(
diff --git a/tests/ui/checked_unwrap/simple_conditionals.rs b/tests/ui/checked_unwrap/simple_conditionals.rs
index b0fc26ff76d..3e7b4b390ba 100644
--- a/tests/ui/checked_unwrap/simple_conditionals.rs
+++ b/tests/ui/checked_unwrap/simple_conditionals.rs
@@ -9,6 +9,30 @@ macro_rules! m {
     };
 }
 
+macro_rules! checks_in_param {
+    ($a:expr, $b:expr) => {
+        if $a {
+            $b;
+        }
+    };
+}
+
+macro_rules! checks_unwrap {
+    ($a:expr, $b:expr) => {
+        if $a.is_some() {
+            $b;
+        }
+    };
+}
+
+macro_rules! checks_some {
+    ($a:expr, $b:expr) => {
+        if $a {
+            $b.unwrap();
+        }
+    };
+}
+
 fn main() {
     let x = Some(());
     if x.is_some() {
@@ -22,6 +46,9 @@ fn main() {
         x.unwrap(); // unnecessary
     }
     m!(x);
+    checks_in_param!(x.is_some(), x.unwrap()); // ok
+    checks_unwrap!(x, x.unwrap()); // ok
+    checks_some!(x.is_some(), x); // ok
     let mut x: Result<(), ()> = Ok(());
     if x.is_ok() {
         x.unwrap(); // unnecessary
diff --git a/tests/ui/checked_unwrap/simple_conditionals.stderr b/tests/ui/checked_unwrap/simple_conditionals.stderr
index e40542e2e4f..4013d1ed667 100644
--- a/tests/ui/checked_unwrap/simple_conditionals.stderr
+++ b/tests/ui/checked_unwrap/simple_conditionals.stderr
@@ -1,5 +1,5 @@
 error: You checked before that `unwrap()` cannot fail. Instead of checking and unwrapping, it's better to use `if let` or `match`.
-  --> $DIR/simple_conditionals.rs:15:9
+  --> $DIR/simple_conditionals.rs:39:9
    |
 LL |     if x.is_some() {
    |        ----------- the check is happening here
@@ -13,7 +13,7 @@ LL | #![deny(clippy::panicking_unwrap, clippy::unnecessary_unwrap)]
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: This call to `unwrap()` will always panic.
-  --> $DIR/simple_conditionals.rs:17:9
+  --> $DIR/simple_conditionals.rs:41:9
    |
 LL |     if x.is_some() {
    |        ----------- because of this check
@@ -28,7 +28,7 @@ LL | #![deny(clippy::panicking_unwrap, clippy::unnecessary_unwrap)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: This call to `unwrap()` will always panic.
-  --> $DIR/simple_conditionals.rs:20:9
+  --> $DIR/simple_conditionals.rs:44:9
    |
 LL |     if x.is_none() {
    |        ----------- because of this check
@@ -36,7 +36,7 @@ LL |         x.unwrap(); // will panic
    |         ^^^^^^^^^^
 
 error: You checked before that `unwrap()` cannot fail. Instead of checking and unwrapping, it's better to use `if let` or `match`.
-  --> $DIR/simple_conditionals.rs:22:9
+  --> $DIR/simple_conditionals.rs:46:9
    |
 LL |     if x.is_none() {
    |        ----------- the check is happening here
@@ -58,7 +58,7 @@ LL |     m!(x);
    = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: You checked before that `unwrap()` cannot fail. Instead of checking and unwrapping, it's better to use `if let` or `match`.
-  --> $DIR/simple_conditionals.rs:27:9
+  --> $DIR/simple_conditionals.rs:54:9
    |
 LL |     if x.is_ok() {
    |        --------- the check is happening here
@@ -66,7 +66,7 @@ LL |         x.unwrap(); // unnecessary
    |         ^^^^^^^^^^
 
 error: This call to `unwrap_err()` will always panic.
-  --> $DIR/simple_conditionals.rs:28:9
+  --> $DIR/simple_conditionals.rs:55:9
    |
 LL |     if x.is_ok() {
    |        --------- because of this check
@@ -75,7 +75,7 @@ LL |         x.unwrap_err(); // will panic
    |         ^^^^^^^^^^^^^^
 
 error: This call to `unwrap()` will always panic.
-  --> $DIR/simple_conditionals.rs:30:9
+  --> $DIR/simple_conditionals.rs:57:9
    |
 LL |     if x.is_ok() {
    |        --------- because of this check
@@ -84,7 +84,7 @@ LL |         x.unwrap(); // will panic
    |         ^^^^^^^^^^
 
 error: You checked before that `unwrap_err()` cannot fail. Instead of checking and unwrapping, it's better to use `if let` or `match`.
-  --> $DIR/simple_conditionals.rs:31:9
+  --> $DIR/simple_conditionals.rs:58:9
    |
 LL |     if x.is_ok() {
    |        --------- the check is happening here
@@ -93,7 +93,7 @@ LL |         x.unwrap_err(); // unnecessary
    |         ^^^^^^^^^^^^^^
 
 error: This call to `unwrap()` will always panic.
-  --> $DIR/simple_conditionals.rs:34:9
+  --> $DIR/simple_conditionals.rs:61:9
    |
 LL |     if x.is_err() {
    |        ---------- because of this check
@@ -101,7 +101,7 @@ LL |         x.unwrap(); // will panic
    |         ^^^^^^^^^^
 
 error: You checked before that `unwrap_err()` cannot fail. Instead of checking and unwrapping, it's better to use `if let` or `match`.
-  --> $DIR/simple_conditionals.rs:35:9
+  --> $DIR/simple_conditionals.rs:62:9
    |
 LL |     if x.is_err() {
    |        ---------- the check is happening here
@@ -110,7 +110,7 @@ LL |         x.unwrap_err(); // unnecessary
    |         ^^^^^^^^^^^^^^
 
 error: You checked before that `unwrap()` cannot fail. Instead of checking and unwrapping, it's better to use `if let` or `match`.
-  --> $DIR/simple_conditionals.rs:37:9
+  --> $DIR/simple_conditionals.rs:64:9
    |
 LL |     if x.is_err() {
    |        ---------- the check is happening here
@@ -119,7 +119,7 @@ LL |         x.unwrap(); // unnecessary
    |         ^^^^^^^^^^
 
 error: This call to `unwrap_err()` will always panic.
-  --> $DIR/simple_conditionals.rs:38:9
+  --> $DIR/simple_conditionals.rs:65:9
    |
 LL |     if x.is_err() {
    |        ---------- because of this check
-- 
cgit 1.4.1-3-g733a5


From d0c1f8ada2306801f2a6ce193e1f9f75471dbb3c Mon Sep 17 00:00:00 2001
From: Aleksei Latyshev <alex_700_95@mail.ru>
Date: Sat, 2 May 2020 14:18:27 +0300
Subject: fix fp on while-let-on-iterator

- fix `is_refutable` for slice patterns
- fix `is_refutable` for bindings
- add some TODO-s for cases, which can not be fixed easily
---
 clippy_lints/src/utils/mod.rs         | 34 ++++++++++++--------
 tests/ui/while_let_on_iterator.fixed  | 58 +++++++++++++++++++++++++++++++++++
 tests/ui/while_let_on_iterator.rs     | 58 +++++++++++++++++++++++++++++++++++
 tests/ui/while_let_on_iterator.stderr | 28 ++++++++++++++---
 4 files changed, 160 insertions(+), 18 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index 04b4b423761..1c7b40fa908 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -933,6 +933,7 @@ pub fn is_ctor_or_promotable_const_function(cx: &LateContext<'_, '_>, expr: &Exp
 }
 
 /// Returns `true` if a pattern is refutable.
+// TODO: should be implemented using rustc/mir_build/hair machinery
 pub fn is_refutable(cx: &LateContext<'_, '_>, pat: &Pat<'_>) -> bool {
     fn is_enum_variant(cx: &LateContext<'_, '_>, qpath: &QPath<'_>, id: HirId) -> bool {
         matches!(
@@ -946,27 +947,34 @@ pub fn is_refutable(cx: &LateContext<'_, '_>, pat: &Pat<'_>) -> bool {
     }
 
     match pat.kind {
-        PatKind::Binding(..) | PatKind::Wild => false,
+        PatKind::Wild => false,
+        PatKind::Binding(_, _, _, pat) => pat.map_or(false, |pat| is_refutable(cx, pat)),
         PatKind::Box(ref pat) | PatKind::Ref(ref pat, _) => is_refutable(cx, pat),
         PatKind::Lit(..) | PatKind::Range(..) => true,
         PatKind::Path(ref qpath) => is_enum_variant(cx, qpath, pat.hir_id),
-        PatKind::Or(ref pats) | PatKind::Tuple(ref pats, _) => are_refutable(cx, pats.iter().map(|pat| &**pat)),
+        PatKind::Or(ref pats) => {
+            // TODO: should be the honest check, that pats is exhaustive set
+            are_refutable(cx, pats.iter().map(|pat| &**pat))
+        },
+        PatKind::Tuple(ref pats, _) => are_refutable(cx, pats.iter().map(|pat| &**pat)),
         PatKind::Struct(ref qpath, ref fields, _) => {
-            if is_enum_variant(cx, qpath, pat.hir_id) {
-                true
-            } else {
-                are_refutable(cx, fields.iter().map(|field| &*field.pat))
-            }
+            is_enum_variant(cx, qpath, pat.hir_id) || are_refutable(cx, fields.iter().map(|field| &*field.pat))
         },
         PatKind::TupleStruct(ref qpath, ref pats, _) => {
-            if is_enum_variant(cx, qpath, pat.hir_id) {
-                true
-            } else {
-                are_refutable(cx, pats.iter().map(|pat| &**pat))
-            }
+            is_enum_variant(cx, qpath, pat.hir_id) || are_refutable(cx, pats.iter().map(|pat| &**pat))
         },
         PatKind::Slice(ref head, ref middle, ref tail) => {
-            are_refutable(cx, head.iter().chain(middle).chain(tail.iter()).map(|pat| &**pat))
+            match &cx.tables.node_type(pat.hir_id).kind {
+                ty::Slice(..) => {
+                    // [..] is the only irrefutable slice pattern.
+                    !head.is_empty() || middle.is_none() || !tail.is_empty()
+                },
+                ty::Array(..) => are_refutable(cx, head.iter().chain(middle).chain(tail.iter()).map(|pat| &**pat)),
+                _ => {
+                    // unreachable!()
+                    true
+                },
+            }
         },
     }
 }
diff --git a/tests/ui/while_let_on_iterator.fixed b/tests/ui/while_let_on_iterator.fixed
index f5fcabf63fd..e99c98ac79f 100644
--- a/tests/ui/while_let_on_iterator.fixed
+++ b/tests/ui/while_let_on_iterator.fixed
@@ -2,6 +2,7 @@
 
 #![warn(clippy::while_let_on_iterator)]
 #![allow(clippy::never_loop, unreachable_code, unused_mut)]
+#![feature(or_patterns)]
 
 fn base() {
     let mut iter = 1..20;
@@ -77,6 +78,62 @@ fn refutable() {
     // */
 }
 
+fn refutable2() {
+    // Issue 3780
+    {
+        let v = vec![1, 2, 3];
+        let mut it = v.windows(2);
+        while let Some([x, y]) = it.next() {
+            println!("x: {}", x);
+            println!("y: {}", y);
+        }
+
+        let mut it = v.windows(2);
+        while let Some([x, ..]) = it.next() {
+            println!("x: {}", x);
+        }
+
+        let mut it = v.windows(2);
+        while let Some([.., y]) = it.next() {
+            println!("y: {}", y);
+        }
+
+        let mut it = v.windows(2);
+        for [..] in it {}
+
+        let v = vec![[1], [2], [3]];
+        let mut it = v.iter();
+        while let Some([1]) = it.next() {}
+
+        let mut it = v.iter();
+        for [_x] in it {}
+    }
+
+    // binding
+    {
+        let v = vec![1, 2, 3];
+        let mut it = v.iter();
+        while let Some(x @ 1) = it.next() {
+            println!("{}", x);
+        }
+
+        let v = vec![[1], [2], [3]];
+        let mut it = v.iter();
+        for x @ [_] in it {
+            println!("{:?}", x);
+        }
+    }
+
+    // false negative
+    {
+        let v = vec![1, 2, 3];
+        let mut it = v.iter().map(Some);
+        while let Some(Some(_) | None) = it.next() {
+            println!("1");
+        }
+    }
+}
+
 fn nested_loops() {
     let a = [42, 1337];
     let mut y = a.iter();
@@ -152,6 +209,7 @@ fn issue1654() {
 fn main() {
     base();
     refutable();
+    refutable2();
     nested_loops();
     issue1121();
     issue2965();
diff --git a/tests/ui/while_let_on_iterator.rs b/tests/ui/while_let_on_iterator.rs
index 04dce8a0289..ba13172428e 100644
--- a/tests/ui/while_let_on_iterator.rs
+++ b/tests/ui/while_let_on_iterator.rs
@@ -2,6 +2,7 @@
 
 #![warn(clippy::while_let_on_iterator)]
 #![allow(clippy::never_loop, unreachable_code, unused_mut)]
+#![feature(or_patterns)]
 
 fn base() {
     let mut iter = 1..20;
@@ -77,6 +78,62 @@ fn refutable() {
     // */
 }
 
+fn refutable2() {
+    // Issue 3780
+    {
+        let v = vec![1, 2, 3];
+        let mut it = v.windows(2);
+        while let Some([x, y]) = it.next() {
+            println!("x: {}", x);
+            println!("y: {}", y);
+        }
+
+        let mut it = v.windows(2);
+        while let Some([x, ..]) = it.next() {
+            println!("x: {}", x);
+        }
+
+        let mut it = v.windows(2);
+        while let Some([.., y]) = it.next() {
+            println!("y: {}", y);
+        }
+
+        let mut it = v.windows(2);
+        while let Some([..]) = it.next() {}
+
+        let v = vec![[1], [2], [3]];
+        let mut it = v.iter();
+        while let Some([1]) = it.next() {}
+
+        let mut it = v.iter();
+        while let Some([_x]) = it.next() {}
+    }
+
+    // binding
+    {
+        let v = vec![1, 2, 3];
+        let mut it = v.iter();
+        while let Some(x @ 1) = it.next() {
+            println!("{}", x);
+        }
+
+        let v = vec![[1], [2], [3]];
+        let mut it = v.iter();
+        while let Some(x @ [_]) = it.next() {
+            println!("{:?}", x);
+        }
+    }
+
+    // false negative
+    {
+        let v = vec![1, 2, 3];
+        let mut it = v.iter().map(Some);
+        while let Some(Some(_) | None) = it.next() {
+            println!("1");
+        }
+    }
+}
+
 fn nested_loops() {
     let a = [42, 1337];
     let mut y = a.iter();
@@ -152,6 +209,7 @@ fn issue1654() {
 fn main() {
     base();
     refutable();
+    refutable2();
     nested_loops();
     issue1121();
     issue2965();
diff --git a/tests/ui/while_let_on_iterator.stderr b/tests/ui/while_let_on_iterator.stderr
index 6de138d7227..aa980d9965c 100644
--- a/tests/ui/while_let_on_iterator.stderr
+++ b/tests/ui/while_let_on_iterator.stderr
@@ -1,5 +1,5 @@
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:8:5
+  --> $DIR/while_let_on_iterator.rs:9:5
    |
 LL |     while let Option::Some(x) = iter.next() {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for x in iter`
@@ -7,22 +7,40 @@ LL |     while let Option::Some(x) = iter.next() {
    = note: `-D clippy::while-let-on-iterator` implied by `-D warnings`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:13:5
+  --> $DIR/while_let_on_iterator.rs:14:5
    |
 LL |     while let Some(x) = iter.next() {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for x in iter`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:18:5
+  --> $DIR/while_let_on_iterator.rs:19:5
    |
 LL |     while let Some(_) = iter.next() {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for _ in iter`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:97:9
+  --> $DIR/while_let_on_iterator.rs:102:9
+   |
+LL |         while let Some([..]) = it.next() {}
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for [..] in it`
+
+error: this loop could be written as a `for` loop
+  --> $DIR/while_let_on_iterator.rs:109:9
+   |
+LL |         while let Some([_x]) = it.next() {}
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for [_x] in it`
+
+error: this loop could be written as a `for` loop
+  --> $DIR/while_let_on_iterator.rs:122:9
+   |
+LL |         while let Some(x @ [_]) = it.next() {
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for x @ [_] in it`
+
+error: this loop could be written as a `for` loop
+  --> $DIR/while_let_on_iterator.rs:154:9
    |
 LL |         while let Some(_) = y.next() {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for _ in y`
 
-error: aborting due to 4 previous errors
+error: aborting due to 7 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From e7138e06291d13163e8ab2a57fe2465451fac193 Mon Sep 17 00:00:00 2001
From: CrazyRoka <RokaRostuk@gmail.com>
Date: Sat, 2 May 2020 14:25:45 +0300
Subject: Fix match on vec items: match on vec[..]

- Added new tests
- Fixed false positive when matching on full range, which will never panic
---
 clippy_lints/src/match_on_vec_items.rs | 21 ++++++++++++++++-----
 tests/ui/match_on_vec_items.rs         | 22 ++++++++++++++++++++++
 2 files changed, 38 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/match_on_vec_items.rs b/clippy_lints/src/match_on_vec_items.rs
index 421571d2f2f..236362130e5 100644
--- a/clippy_lints/src/match_on_vec_items.rs
+++ b/clippy_lints/src/match_on_vec_items.rs
@@ -1,4 +1,4 @@
-use crate::utils::{is_type_diagnostic_item, snippet, span_lint_and_sugg, walk_ptrs_ty};
+use crate::utils::{is_type_diagnostic_item, match_type, snippet, span_lint_and_sugg, walk_ptrs_ty};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, MatchSource};
@@ -75,10 +75,9 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MatchOnVecItems {
 
 fn is_vec_indexing<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr<'tcx>) -> Option<&'tcx Expr<'tcx>> {
     if_chain! {
-        if let ExprKind::Index(ref array, _) = expr.kind;
-        let ty = cx.tables.expr_ty(array);
-        let ty = walk_ptrs_ty(ty);
-        if is_type_diagnostic_item(cx, ty, sym!(vec_type));
+        if let ExprKind::Index(ref array, ref index) = expr.kind;
+        if is_vector(cx, array);
+        if !is_full_range(cx, index);
 
         then {
             return Some(expr);
@@ -87,3 +86,15 @@ fn is_vec_indexing<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr<'tcx>)
 
     None
 }
+
+fn is_vector(cx: &LateContext<'_, '_>, expr: &Expr<'_>) -> bool {
+    let ty = cx.tables.expr_ty(expr);
+    let ty = walk_ptrs_ty(ty);
+    is_type_diagnostic_item(cx, ty, sym!(vec_type))
+}
+
+fn is_full_range(cx: &LateContext<'_, '_>, expr: &Expr<'_>) -> bool {
+    let ty = cx.tables.expr_ty(expr);
+    let ty = walk_ptrs_ty(ty);
+    match_type(cx, ty, &["core", "ops", "range", "RangeFull"])
+}
diff --git a/tests/ui/match_on_vec_items.rs b/tests/ui/match_on_vec_items.rs
index 0bb39d77e46..30415e3b94d 100644
--- a/tests/ui/match_on_vec_items.rs
+++ b/tests/ui/match_on_vec_items.rs
@@ -120,6 +120,27 @@ fn match_with_array() {
     }
 }
 
+fn match_with_endless_range() {
+    let arr = vec![0, 1, 2, 3];
+    let range = ..;
+
+    // Ok
+    match arr[range] {
+        [0, 1] => println!("0 1"),
+        [1, 2] => println!("1 2"),
+        [0, 1, 2, 3] => println!("0, 1, 2, 3"),
+        _ => {},
+    }
+
+    // Ok
+    match arr[..] {
+        [0, 1] => println!("0 1"),
+        [1, 2] => println!("1 2"),
+        [0, 1, 2, 3] => println!("0, 1, 2, 3"),
+        _ => {},
+    }
+}
+
 fn main() {
     match_with_wildcard();
     match_without_wildcard();
@@ -127,4 +148,5 @@ fn main() {
     match_vec_ref();
     match_with_get();
     match_with_array();
+    match_with_endless_range();
 }
-- 
cgit 1.4.1-3-g733a5


From de58c5644de0d9ffe46e7e2923d2301eaf4dd347 Mon Sep 17 00:00:00 2001
From: CrazyRoka <RokaRostuk@gmail.com>
Date: Sat, 2 May 2020 17:36:26 +0300
Subject: Changed RANGE_FULL constant in utils

---
 clippy_lints/src/match_on_vec_items.rs | 4 ++--
 clippy_lints/src/utils/paths.rs        | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/match_on_vec_items.rs b/clippy_lints/src/match_on_vec_items.rs
index 236362130e5..ee69628e9f0 100644
--- a/clippy_lints/src/match_on_vec_items.rs
+++ b/clippy_lints/src/match_on_vec_items.rs
@@ -1,4 +1,4 @@
-use crate::utils::{is_type_diagnostic_item, match_type, snippet, span_lint_and_sugg, walk_ptrs_ty};
+use crate::utils::{self, is_type_diagnostic_item, match_type, snippet, span_lint_and_sugg, walk_ptrs_ty};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, MatchSource};
@@ -96,5 +96,5 @@ fn is_vector(cx: &LateContext<'_, '_>, expr: &Expr<'_>) -> bool {
 fn is_full_range(cx: &LateContext<'_, '_>, expr: &Expr<'_>) -> bool {
     let ty = cx.tables.expr_ty(expr);
     let ty = walk_ptrs_ty(ty);
-    match_type(cx, ty, &["core", "ops", "range", "RangeFull"])
+    match_type(cx, ty, &utils::paths::RANGE_FULL)
 }
diff --git a/clippy_lints/src/utils/paths.rs b/clippy_lints/src/utils/paths.rs
index ca2c4ade155..79ca6845c6f 100644
--- a/clippy_lints/src/utils/paths.rs
+++ b/clippy_lints/src/utils/paths.rs
@@ -85,7 +85,7 @@ pub const RANGE: [&str; 3] = ["core", "ops", "Range"];
 pub const RANGE_ARGUMENT_TRAIT: [&str; 3] = ["core", "ops", "RangeBounds"];
 pub const RANGE_FROM: [&str; 3] = ["core", "ops", "RangeFrom"];
 pub const RANGE_FROM_STD: [&str; 3] = ["std", "ops", "RangeFrom"];
-pub const RANGE_FULL: [&str; 3] = ["core", "ops", "RangeFull"];
+pub const RANGE_FULL: [&str; 4] = ["core", "ops", "range", "RangeFull"];
 pub const RANGE_FULL_STD: [&str; 3] = ["std", "ops", "RangeFull"];
 pub const RANGE_INCLUSIVE_NEW: [&str; 4] = ["core", "ops", "RangeInclusive", "new"];
 pub const RANGE_INCLUSIVE_STD_NEW: [&str; 4] = ["std", "ops", "RangeInclusive", "new"];
-- 
cgit 1.4.1-3-g733a5


From 7744cf4e53c4e19e5753e2063be420b9d0c0d38a Mon Sep 17 00:00:00 2001
From: Oliver Scherer <github35764891676564198441@oli-obk.de>
Date: Mon, 4 May 2020 15:13:07 +0200
Subject: Update to rustc changes

---
 clippy_lints/src/redundant_clone.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/redundant_clone.rs b/clippy_lints/src/redundant_clone.rs
index d5cace0c647..d563eb886ae 100644
--- a/clippy_lints/src/redundant_clone.rs
+++ b/clippy_lints/src/redundant_clone.rs
@@ -591,7 +591,7 @@ struct PossibleBorrowerMap<'a, 'tcx> {
 impl PossibleBorrowerMap<'_, '_> {
     /// Returns true if the set of borrowers of `borrowed` living at `at` matches with `borrowers`.
     fn only_borrowers(&mut self, borrowers: &[mir::Local], borrowed: mir::Local, at: mir::Location) -> bool {
-        self.maybe_live.seek_after(at);
+        self.maybe_live.seek_after_primary_effect(at);
 
         self.bitset.0.clear();
         let maybe_live = &mut self.maybe_live;
-- 
cgit 1.4.1-3-g733a5


From 3b58d66b22fe9107a78b99c267c71322276aa15a Mon Sep 17 00:00:00 2001
From: Eduardo Broto <ebroto@tutanota.com>
Date: Thu, 7 May 2020 21:41:23 +0200
Subject: Add the manual_async_fn lint

---
 CHANGELOG.md                        |   1 +
 clippy_lints/src/lib.rs             |   5 ++
 clippy_lints/src/manual_async_fn.rs | 160 ++++++++++++++++++++++++++++++++++++
 clippy_lints/src/utils/paths.rs     |   3 +
 src/lintlist/mod.rs                 |   7 ++
 tests/ui/future_not_send.rs         |   1 +
 tests/ui/future_not_send.stderr     |   6 +-
 tests/ui/manual_async_fn.fixed      |  55 +++++++++++++
 tests/ui/manual_async_fn.rs         |  67 +++++++++++++++
 tests/ui/manual_async_fn.stderr     |  93 +++++++++++++++++++++
 10 files changed, 395 insertions(+), 3 deletions(-)
 create mode 100644 clippy_lints/src/manual_async_fn.rs
 create mode 100644 tests/ui/manual_async_fn.fixed
 create mode 100644 tests/ui/manual_async_fn.rs
 create mode 100644 tests/ui/manual_async_fn.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index facf363e371..8457d6ad05c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1422,6 +1422,7 @@ Released 2018-09-13
 [`lossy_float_literal`]: https://rust-lang.github.io/rust-clippy/master/index.html#lossy_float_literal
 [`macro_use_imports`]: https://rust-lang.github.io/rust-clippy/master/index.html#macro_use_imports
 [`main_recursion`]: https://rust-lang.github.io/rust-clippy/master/index.html#main_recursion
+[`manual_async_fn`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_async_fn
 [`manual_memcpy`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_memcpy
 [`manual_non_exhaustive`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_non_exhaustive
 [`manual_saturating_arithmetic`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_saturating_arithmetic
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 97785cba883..fb2e9932b8e 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -247,6 +247,7 @@ mod literal_representation;
 mod loops;
 mod macro_use;
 mod main_recursion;
+mod manual_async_fn;
 mod manual_non_exhaustive;
 mod map_clone;
 mod map_unit_fn;
@@ -629,6 +630,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &loops::WHILE_LET_ON_ITERATOR,
         &macro_use::MACRO_USE_IMPORTS,
         &main_recursion::MAIN_RECURSION,
+        &manual_async_fn::MANUAL_ASYNC_FN,
         &manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE,
         &map_clone::MAP_CLONE,
         &map_unit_fn::OPTION_MAP_UNIT_FN,
@@ -1067,6 +1069,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box if_let_mutex::IfLetMutex);
     store.register_late_pass(|| box match_on_vec_items::MatchOnVecItems);
     store.register_early_pass(|| box manual_non_exhaustive::ManualNonExhaustive);
+    store.register_late_pass(|| box manual_async_fn::ManualAsyncFn);
 
     store.register_group(true, "clippy::restriction", Some("clippy_restriction"), vec![
         LintId::of(&arithmetic::FLOAT_ARITHMETIC),
@@ -1284,6 +1287,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&loops::WHILE_LET_LOOP),
         LintId::of(&loops::WHILE_LET_ON_ITERATOR),
         LintId::of(&main_recursion::MAIN_RECURSION),
+        LintId::of(&manual_async_fn::MANUAL_ASYNC_FN),
         LintId::of(&manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE),
         LintId::of(&map_clone::MAP_CLONE),
         LintId::of(&map_unit_fn::OPTION_MAP_UNIT_FN),
@@ -1478,6 +1482,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&loops::NEEDLESS_RANGE_LOOP),
         LintId::of(&loops::WHILE_LET_ON_ITERATOR),
         LintId::of(&main_recursion::MAIN_RECURSION),
+        LintId::of(&manual_async_fn::MANUAL_ASYNC_FN),
         LintId::of(&manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE),
         LintId::of(&map_clone::MAP_CLONE),
         LintId::of(&matches::INFALLIBLE_DESTRUCTURING_MATCH),
diff --git a/clippy_lints/src/manual_async_fn.rs b/clippy_lints/src/manual_async_fn.rs
new file mode 100644
index 00000000000..ab8829abbf2
--- /dev/null
+++ b/clippy_lints/src/manual_async_fn.rs
@@ -0,0 +1,160 @@
+use crate::utils::paths::{FUTURE_CORE, FUTURE_FROM_GENERATOR, FUTURE_STD};
+use crate::utils::{match_function_call, match_path, snippet_block, snippet_opt, span_lint_and_then};
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir::intravisit::FnKind;
+use rustc_hir::{
+    AsyncGeneratorKind, Block, Body, Expr, ExprKind, FnDecl, FnRetTy, GeneratorKind, GenericBound, HirId, IsAsync,
+    ItemKind, TraitRef, Ty, TyKind, TypeBindingKind,
+};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::Span;
+
+declare_clippy_lint! {
+    /// **What it does:** It checks for manual implementations of `async` functions.
+    ///
+    /// **Why is this bad?** It's more idiomatic to use the dedicated syntax.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// use std::future::Future;
+    ///
+    /// fn foo() -> Future<Output = i32> { async { 42 } }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// use std::future::Future;
+    ///
+    /// async fn foo() -> i32 { 42 }
+    /// ```
+    pub MANUAL_ASYNC_FN,
+    style,
+    "manual implementations of `async` functions can be simplified using the dedicated syntax"
+}
+
+declare_lint_pass!(ManualAsyncFn => [MANUAL_ASYNC_FN]);
+
+impl<'a, 'tcx> LateLintPass<'a, 'tcx> for ManualAsyncFn {
+    fn check_fn(
+        &mut self,
+        cx: &LateContext<'a, 'tcx>,
+        kind: FnKind<'tcx>,
+        decl: &'tcx FnDecl<'_>,
+        body: &'tcx Body<'_>,
+        span: Span,
+        _: HirId,
+    ) {
+        if_chain! {
+            if let Some(header) = kind.header();
+            if let IsAsync::NotAsync = header.asyncness;
+            // Check that this function returns `impl Future`
+            if let FnRetTy::Return(ret_ty) = decl.output;
+            if let Some(trait_ref) = future_trait_ref(cx, ret_ty);
+            if let Some(output) = future_output_ty(trait_ref);
+            // Check that the body of the function consists of one async block
+            if let ExprKind::Block(block, _) = body.value.kind;
+            if block.stmts.is_empty();
+            if let Some(closure_body) = desugared_async_block(cx, block);
+            then {
+                let header_span = span.with_hi(ret_ty.span.hi());
+
+                span_lint_and_then(
+                    cx,
+                    MANUAL_ASYNC_FN,
+                    header_span,
+                    "this function can be simplified using async syntax",
+                    |diag| {
+                        if_chain! {
+                            if let Some(header_snip) = snippet_opt(cx, header_span);
+                            if let Some(ret_pos) = header_snip.rfind("->");
+                            if let Some((ret_sugg, ret_snip)) = suggested_ret(cx, output);
+                            then {
+                                let help = format!("make the function `async` and {}", ret_sugg);
+                                diag.span_suggestion(
+                                    header_span,
+                                    &help,
+                                    format!("async {}{}", &header_snip[..ret_pos], ret_snip),
+                                    Applicability::MachineApplicable
+                                );
+
+                                let body_snip = snippet_block(cx, closure_body.value.span, "..", Some(block.span));
+                                diag.span_suggestion(
+                                    block.span,
+                                    "move the body of the async block to the enclosing function",
+                                    body_snip.to_string(),
+                                    Applicability::MachineApplicable
+                                );
+                            }
+                        }
+                    },
+                );
+            }
+        }
+    }
+}
+
+fn future_trait_ref<'tcx>(cx: &LateContext<'_, 'tcx>, ty: &'tcx Ty<'tcx>) -> Option<&'tcx TraitRef<'tcx>> {
+    if_chain! {
+        if let TyKind::Def(item_id, _) = ty.kind;
+        let item = cx.tcx.hir().item(item_id.id);
+        if let ItemKind::OpaqueTy(opaque) = &item.kind;
+        if opaque.bounds.len() == 1;
+        if let GenericBound::Trait(poly, _) = &opaque.bounds[0];
+        let path = poly.trait_ref.path;
+        if match_path(&path, &FUTURE_CORE) || match_path(&path, &FUTURE_STD);
+        then {
+            return Some(&poly.trait_ref);
+        }
+    }
+
+    None
+}
+
+fn future_output_ty<'tcx>(trait_ref: &'tcx TraitRef<'tcx>) -> Option<&'tcx Ty<'tcx>> {
+    if_chain! {
+        if let Some(segment) = trait_ref.path.segments.last();
+        if let Some(args) = segment.args;
+        if args.bindings.len() == 1;
+        let binding = &args.bindings[0];
+        if binding.ident.as_str() == "Output";
+        if let TypeBindingKind::Equality{ty: output} = binding.kind;
+        then {
+            return Some(output)
+        }
+    }
+
+    None
+}
+
+fn desugared_async_block<'tcx>(cx: &LateContext<'_, 'tcx>, block: &'tcx Block<'tcx>) -> Option<&'tcx Body<'tcx>> {
+    if_chain! {
+        if let Some(block_expr) = block.expr;
+        if let Some(args) = match_function_call(cx, block_expr, &FUTURE_FROM_GENERATOR);
+        if args.len() == 1;
+        if let Expr{kind: ExprKind::Closure(_, _, body_id, ..), ..} = args[0];
+        let closure_body = cx.tcx.hir().body(body_id);
+        if let Some(GeneratorKind::Async(AsyncGeneratorKind::Block)) = closure_body.generator_kind;
+        then {
+            return Some(closure_body);
+        }
+    }
+
+    None
+}
+
+fn suggested_ret(cx: &LateContext<'_, '_>, output: &Ty<'_>) -> Option<(&'static str, String)> {
+    match output.kind {
+        TyKind::Tup(tys) if tys.is_empty() => {
+            let sugg = "remove the return type";
+            Some((sugg, "".into()))
+        },
+        _ => {
+            let sugg = "return the output of the future directly";
+            snippet_opt(cx, output.span).map(|snip| (sugg, format!("-> {}", snip)))
+        },
+    }
+}
diff --git a/clippy_lints/src/utils/paths.rs b/clippy_lints/src/utils/paths.rs
index 79ca6845c6f..74040a96c78 100644
--- a/clippy_lints/src/utils/paths.rs
+++ b/clippy_lints/src/utils/paths.rs
@@ -42,6 +42,9 @@ pub const FMT_ARGUMENTS_NEW_V1_FORMATTED: [&str; 4] = ["core", "fmt", "Arguments
 pub const FMT_ARGUMENTV1_NEW: [&str; 4] = ["core", "fmt", "ArgumentV1", "new"];
 pub const FROM_FROM: [&str; 4] = ["core", "convert", "From", "from"];
 pub const FROM_TRAIT: [&str; 3] = ["core", "convert", "From"];
+pub const FUTURE_CORE: [&str; 3] = ["core", "future", "Future"];
+pub const FUTURE_FROM_GENERATOR: [&str; 3] = ["core", "future", "from_generator"];
+pub const FUTURE_STD: [&str; 3] = ["std", "future", "Future"];
 pub const HASH: [&str; 2] = ["hash", "Hash"];
 pub const HASHMAP: [&str; 5] = ["std", "collections", "hash", "map", "HashMap"];
 pub const HASHMAP_ENTRY: [&str; 5] = ["std", "collections", "hash", "map", "Entry"];
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index a7685f67211..51d1cb2216a 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -1081,6 +1081,13 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
         deprecation: None,
         module: "main_recursion",
     },
+    Lint {
+        name: "manual_async_fn",
+        group: "style",
+        desc: "manual implementations of `async` functions can be simplified using the dedicated syntax",
+        deprecation: None,
+        module: "manual_async_fn",
+    },
     Lint {
         name: "manual_memcpy",
         group: "perf",
diff --git a/tests/ui/future_not_send.rs b/tests/ui/future_not_send.rs
index 6d09d71a630..d3a920de4b6 100644
--- a/tests/ui/future_not_send.rs
+++ b/tests/ui/future_not_send.rs
@@ -41,6 +41,7 @@ impl Dummy {
         self.private_future().await;
     }
 
+    #[allow(clippy::manual_async_fn)]
     pub fn public_send(&self) -> impl std::future::Future<Output = bool> {
         async { false }
     }
diff --git a/tests/ui/future_not_send.stderr b/tests/ui/future_not_send.stderr
index 3b4968ef0a6..d1863701bfe 100644
--- a/tests/ui/future_not_send.stderr
+++ b/tests/ui/future_not_send.stderr
@@ -96,13 +96,13 @@ LL |     }
    = note: `std::rc::Rc<[u8]>` doesn't implement `std::marker::Sync`
 
 error: future cannot be sent between threads safely
-  --> $DIR/future_not_send.rs:49:37
+  --> $DIR/future_not_send.rs:50:37
    |
 LL | async fn generic_future<T>(t: T) -> T
    |                                     ^ future returned by `generic_future` is not `Send`
    |
 note: future is not `Send` as this value is used across an await
-  --> $DIR/future_not_send.rs:54:5
+  --> $DIR/future_not_send.rs:55:5
    |
 LL |     let rt = &t;
    |         -- has type `&T` which is not `Send`
@@ -114,7 +114,7 @@ LL | }
    = note: `T` doesn't implement `std::marker::Sync`
 
 error: future cannot be sent between threads safely
-  --> $DIR/future_not_send.rs:65:34
+  --> $DIR/future_not_send.rs:66:34
    |
 LL | async fn unclear_future<T>(t: T) {}
    |                                  ^
diff --git a/tests/ui/manual_async_fn.fixed b/tests/ui/manual_async_fn.fixed
new file mode 100644
index 00000000000..84c02bba4dc
--- /dev/null
+++ b/tests/ui/manual_async_fn.fixed
@@ -0,0 +1,55 @@
+// run-rustfix
+// edition:2018
+#![warn(clippy::manual_async_fn)]
+#![allow(unused)]
+
+use std::future::Future;
+
+async fn fut() -> i32 { 42 }
+
+async fn empty_fut()  {}
+
+async fn core_fut() -> i32 { 42 }
+
+// should be ignored
+fn has_other_stmts() -> impl core::future::Future<Output = i32> {
+    let _ = 42;
+    async move { 42 }
+}
+
+// should be ignored
+fn not_fut() -> i32 {
+    42
+}
+
+// should be ignored
+async fn already_async() -> impl Future<Output = i32> {
+    async { 42 }
+}
+
+struct S {}
+impl S {
+    async fn inh_fut() -> i32 { 42 }
+
+    async fn meth_fut(&self) -> i32 { 42 }
+
+    async fn empty_fut(&self)  {}
+
+    // should be ignored
+    fn not_fut(&self) -> i32 {
+        42
+    }
+
+    // should be ignored
+    fn has_other_stmts() -> impl core::future::Future<Output = i32> {
+        let _ = 42;
+        async move { 42 }
+    }
+
+    // should be ignored
+    async fn already_async(&self) -> impl Future<Output = i32> {
+        async { 42 }
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/manual_async_fn.rs b/tests/ui/manual_async_fn.rs
new file mode 100644
index 00000000000..bd5f9d1cf5f
--- /dev/null
+++ b/tests/ui/manual_async_fn.rs
@@ -0,0 +1,67 @@
+// run-rustfix
+// edition:2018
+#![warn(clippy::manual_async_fn)]
+#![allow(unused)]
+
+use std::future::Future;
+
+fn fut() -> impl Future<Output = i32> {
+    async { 42 }
+}
+
+fn empty_fut() -> impl Future<Output = ()> {
+    async {}
+}
+
+fn core_fut() -> impl core::future::Future<Output = i32> {
+    async move { 42 }
+}
+
+// should be ignored
+fn has_other_stmts() -> impl core::future::Future<Output = i32> {
+    let _ = 42;
+    async move { 42 }
+}
+
+// should be ignored
+fn not_fut() -> i32 {
+    42
+}
+
+// should be ignored
+async fn already_async() -> impl Future<Output = i32> {
+    async { 42 }
+}
+
+struct S {}
+impl S {
+    fn inh_fut() -> impl Future<Output = i32> {
+        async { 42 }
+    }
+
+    fn meth_fut(&self) -> impl Future<Output = i32> {
+        async { 42 }
+    }
+
+    fn empty_fut(&self) -> impl Future<Output = ()> {
+        async {}
+    }
+
+    // should be ignored
+    fn not_fut(&self) -> i32 {
+        42
+    }
+
+    // should be ignored
+    fn has_other_stmts() -> impl core::future::Future<Output = i32> {
+        let _ = 42;
+        async move { 42 }
+    }
+
+    // should be ignored
+    async fn already_async(&self) -> impl Future<Output = i32> {
+        async { 42 }
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/manual_async_fn.stderr b/tests/ui/manual_async_fn.stderr
new file mode 100644
index 00000000000..016fdf95977
--- /dev/null
+++ b/tests/ui/manual_async_fn.stderr
@@ -0,0 +1,93 @@
+error: this function can be simplified using async syntax
+  --> $DIR/manual_async_fn.rs:8:1
+   |
+LL | fn fut() -> impl Future<Output = i32> {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::manual-async-fn` implied by `-D warnings`
+help: make the function `async` and return the output of the future directly
+   |
+LL | async fn fut() -> i32 {
+   | ^^^^^^^^^^^^^^^^^^^^^
+help: move the body of the async block to the enclosing function
+   |
+LL | fn fut() -> impl Future<Output = i32> { 42 }
+   |                                       ^^^^^^
+
+error: this function can be simplified using async syntax
+  --> $DIR/manual_async_fn.rs:12:1
+   |
+LL | fn empty_fut() -> impl Future<Output = ()> {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: make the function `async` and remove the return type
+   |
+LL | async fn empty_fut()  {
+   | ^^^^^^^^^^^^^^^^^^^^
+help: move the body of the async block to the enclosing function
+   |
+LL | fn empty_fut() -> impl Future<Output = ()> {}
+   |                                            ^^
+
+error: this function can be simplified using async syntax
+  --> $DIR/manual_async_fn.rs:16:1
+   |
+LL | fn core_fut() -> impl core::future::Future<Output = i32> {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: make the function `async` and return the output of the future directly
+   |
+LL | async fn core_fut() -> i32 {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^
+help: move the body of the async block to the enclosing function
+   |
+LL | fn core_fut() -> impl core::future::Future<Output = i32> { 42 }
+   |                                                          ^^^^^^
+
+error: this function can be simplified using async syntax
+  --> $DIR/manual_async_fn.rs:38:5
+   |
+LL |     fn inh_fut() -> impl Future<Output = i32> {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: make the function `async` and return the output of the future directly
+   |
+LL |     async fn inh_fut() -> i32 {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
+help: move the body of the async block to the enclosing function
+   |
+LL |     fn inh_fut() -> impl Future<Output = i32> { 42 }
+   |                                               ^^^^^^
+
+error: this function can be simplified using async syntax
+  --> $DIR/manual_async_fn.rs:42:5
+   |
+LL |     fn meth_fut(&self) -> impl Future<Output = i32> {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: make the function `async` and return the output of the future directly
+   |
+LL |     async fn meth_fut(&self) -> i32 {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+help: move the body of the async block to the enclosing function
+   |
+LL |     fn meth_fut(&self) -> impl Future<Output = i32> { 42 }
+   |                                                     ^^^^^^
+
+error: this function can be simplified using async syntax
+  --> $DIR/manual_async_fn.rs:46:5
+   |
+LL |     fn empty_fut(&self) -> impl Future<Output = ()> {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: make the function `async` and remove the return type
+   |
+LL |     async fn empty_fut(&self)  {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
+help: move the body of the async block to the enclosing function
+   |
+LL |     fn empty_fut(&self) -> impl Future<Output = ()> {}
+   |                                                     ^^
+
+error: aborting due to 6 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 4ac348b30849ec472564a81797b7e9ae42985460 Mon Sep 17 00:00:00 2001
From: Eduardo Broto <ebroto@tutanota.com>
Date: Thu, 7 May 2020 22:03:38 +0200
Subject: Fix doc comment in lint declaration

---
 clippy_lints/src/manual_async_fn.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_async_fn.rs b/clippy_lints/src/manual_async_fn.rs
index ab8829abbf2..b4be3ecfd16 100644
--- a/clippy_lints/src/manual_async_fn.rs
+++ b/clippy_lints/src/manual_async_fn.rs
@@ -23,7 +23,7 @@ declare_clippy_lint! {
     /// ```rust
     /// use std::future::Future;
     ///
-    /// fn foo() -> Future<Output = i32> { async { 42 } }
+    /// fn foo() -> impl Future<Output = i32> { async { 42 } }
     /// ```
     /// Use instead:
     /// ```rust
-- 
cgit 1.4.1-3-g733a5


From 3e4bc026e2706b1cb21bad6d55726f8b5a1d4cf1 Mon Sep 17 00:00:00 2001
From: Eduardo Broto <ebroto@tutanota.com>
Date: Thu, 7 May 2020 22:40:28 +0200
Subject: Apply suggestions from PR review

---
 clippy_lints/src/manual_async_fn.rs |  9 ++++-----
 clippy_lints/src/utils/paths.rs     |  2 --
 tests/ui/manual_async_fn.fixed      | 14 +++++++++++++-
 tests/ui/manual_async_fn.rs         | 14 +++++++++++++-
 tests/ui/manual_async_fn.stderr     | 25 +++++++++++++++----------
 5 files changed, 45 insertions(+), 19 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_async_fn.rs b/clippy_lints/src/manual_async_fn.rs
index b4be3ecfd16..cb72a240582 100644
--- a/clippy_lints/src/manual_async_fn.rs
+++ b/clippy_lints/src/manual_async_fn.rs
@@ -1,5 +1,5 @@
-use crate::utils::paths::{FUTURE_CORE, FUTURE_FROM_GENERATOR, FUTURE_STD};
-use crate::utils::{match_function_call, match_path, snippet_block, snippet_opt, span_lint_and_then};
+use crate::utils::paths::FUTURE_FROM_GENERATOR;
+use crate::utils::{match_function_call, snippet_block, snippet_opt, span_lint_and_then};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::FnKind;
@@ -66,7 +66,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for ManualAsyncFn {
                     cx,
                     MANUAL_ASYNC_FN,
                     header_span,
-                    "this function can be simplified using async syntax",
+                    "this function can be simplified using the `async fn` syntax",
                     |diag| {
                         if_chain! {
                             if let Some(header_snip) = snippet_opt(cx, header_span);
@@ -104,8 +104,7 @@ fn future_trait_ref<'tcx>(cx: &LateContext<'_, 'tcx>, ty: &'tcx Ty<'tcx>) -> Opt
         if let ItemKind::OpaqueTy(opaque) = &item.kind;
         if opaque.bounds.len() == 1;
         if let GenericBound::Trait(poly, _) = &opaque.bounds[0];
-        let path = poly.trait_ref.path;
-        if match_path(&path, &FUTURE_CORE) || match_path(&path, &FUTURE_STD);
+        if poly.trait_ref.trait_def_id() == cx.tcx.lang_items().future_trait();
         then {
             return Some(&poly.trait_ref);
         }
diff --git a/clippy_lints/src/utils/paths.rs b/clippy_lints/src/utils/paths.rs
index 74040a96c78..b3ad2ad9d99 100644
--- a/clippy_lints/src/utils/paths.rs
+++ b/clippy_lints/src/utils/paths.rs
@@ -42,9 +42,7 @@ pub const FMT_ARGUMENTS_NEW_V1_FORMATTED: [&str; 4] = ["core", "fmt", "Arguments
 pub const FMT_ARGUMENTV1_NEW: [&str; 4] = ["core", "fmt", "ArgumentV1", "new"];
 pub const FROM_FROM: [&str; 4] = ["core", "convert", "From", "from"];
 pub const FROM_TRAIT: [&str; 3] = ["core", "convert", "From"];
-pub const FUTURE_CORE: [&str; 3] = ["core", "future", "Future"];
 pub const FUTURE_FROM_GENERATOR: [&str; 3] = ["core", "future", "from_generator"];
-pub const FUTURE_STD: [&str; 3] = ["std", "future", "Future"];
 pub const HASH: [&str; 2] = ["hash", "Hash"];
 pub const HASHMAP: [&str; 5] = ["std", "collections", "hash", "map", "HashMap"];
 pub const HASHMAP_ENTRY: [&str; 5] = ["std", "collections", "hash", "map", "Entry"];
diff --git a/tests/ui/manual_async_fn.fixed b/tests/ui/manual_async_fn.fixed
index 84c02bba4dc..6bb1032a172 100644
--- a/tests/ui/manual_async_fn.fixed
+++ b/tests/ui/manual_async_fn.fixed
@@ -29,7 +29,19 @@ async fn already_async() -> impl Future<Output = i32> {
 
 struct S {}
 impl S {
-    async fn inh_fut() -> i32 { 42 }
+    async fn inh_fut() -> i32 {
+        // NOTE: this code is here just to check that the identation is correct in the suggested fix
+        let a = 42;
+        let b = 21;
+        if a < b {
+            let c = 21;
+            let d = 42;
+            if c < d {
+                let _ = 42;
+            }
+        }
+        42
+    }
 
     async fn meth_fut(&self) -> i32 { 42 }
 
diff --git a/tests/ui/manual_async_fn.rs b/tests/ui/manual_async_fn.rs
index bd5f9d1cf5f..d50c919188b 100644
--- a/tests/ui/manual_async_fn.rs
+++ b/tests/ui/manual_async_fn.rs
@@ -36,7 +36,19 @@ async fn already_async() -> impl Future<Output = i32> {
 struct S {}
 impl S {
     fn inh_fut() -> impl Future<Output = i32> {
-        async { 42 }
+        async {
+            // NOTE: this code is here just to check that the identation is correct in the suggested fix
+            let a = 42;
+            let b = 21;
+            if a < b {
+                let c = 21;
+                let d = 42;
+                if c < d {
+                    let _ = 42;
+                }
+            }
+            42
+        }
     }
 
     fn meth_fut(&self) -> impl Future<Output = i32> {
diff --git a/tests/ui/manual_async_fn.stderr b/tests/ui/manual_async_fn.stderr
index 016fdf95977..f278ee41aa3 100644
--- a/tests/ui/manual_async_fn.stderr
+++ b/tests/ui/manual_async_fn.stderr
@@ -1,4 +1,4 @@
-error: this function can be simplified using async syntax
+error: this function can be simplified using the `async fn` syntax
   --> $DIR/manual_async_fn.rs:8:1
    |
 LL | fn fut() -> impl Future<Output = i32> {
@@ -14,7 +14,7 @@ help: move the body of the async block to the enclosing function
 LL | fn fut() -> impl Future<Output = i32> { 42 }
    |                                       ^^^^^^
 
-error: this function can be simplified using async syntax
+error: this function can be simplified using the `async fn` syntax
   --> $DIR/manual_async_fn.rs:12:1
    |
 LL | fn empty_fut() -> impl Future<Output = ()> {
@@ -29,7 +29,7 @@ help: move the body of the async block to the enclosing function
 LL | fn empty_fut() -> impl Future<Output = ()> {}
    |                                            ^^
 
-error: this function can be simplified using async syntax
+error: this function can be simplified using the `async fn` syntax
   --> $DIR/manual_async_fn.rs:16:1
    |
 LL | fn core_fut() -> impl core::future::Future<Output = i32> {
@@ -44,7 +44,7 @@ help: move the body of the async block to the enclosing function
 LL | fn core_fut() -> impl core::future::Future<Output = i32> { 42 }
    |                                                          ^^^^^^
 
-error: this function can be simplified using async syntax
+error: this function can be simplified using the `async fn` syntax
   --> $DIR/manual_async_fn.rs:38:5
    |
 LL |     fn inh_fut() -> impl Future<Output = i32> {
@@ -56,11 +56,16 @@ LL |     async fn inh_fut() -> i32 {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
 help: move the body of the async block to the enclosing function
    |
-LL |     fn inh_fut() -> impl Future<Output = i32> { 42 }
-   |                                               ^^^^^^
+LL |     fn inh_fut() -> impl Future<Output = i32> {
+LL |         // NOTE: this code is here just to check that the identation is correct in the suggested fix
+LL |         let a = 42;
+LL |         let b = 21;
+LL |         if a < b {
+LL |             let c = 21;
+ ...
 
-error: this function can be simplified using async syntax
-  --> $DIR/manual_async_fn.rs:42:5
+error: this function can be simplified using the `async fn` syntax
+  --> $DIR/manual_async_fn.rs:54:5
    |
 LL |     fn meth_fut(&self) -> impl Future<Output = i32> {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -74,8 +79,8 @@ help: move the body of the async block to the enclosing function
 LL |     fn meth_fut(&self) -> impl Future<Output = i32> { 42 }
    |                                                     ^^^^^^
 
-error: this function can be simplified using async syntax
-  --> $DIR/manual_async_fn.rs:46:5
+error: this function can be simplified using the `async fn` syntax
+  --> $DIR/manual_async_fn.rs:58:5
    |
 LL |     fn empty_fut(&self) -> impl Future<Output = ()> {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From 0c14ea8ed79ebf0b7368659282136e876f247cc9 Mon Sep 17 00:00:00 2001
From: Glenn Hope <glenn.alexander.hope@gmail.com>
Date: Sun, 3 May 2020 10:56:25 -0700
Subject: Allow 'use super::*;' imports

---
 clippy_lints/src/wildcard_imports.rs | 19 +++++++++++++++---
 tests/ui/wildcard_imports.fixed      | 38 ++++++++++++++++++++++++++++++++++++
 tests/ui/wildcard_imports.rs         | 38 ++++++++++++++++++++++++++++++++++++
 tests/ui/wildcard_imports.stderr     | 20 ++++++++++++++++++-
 4 files changed, 111 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/wildcard_imports.rs b/clippy_lints/src/wildcard_imports.rs
index f3038861cee..70ad9a60a02 100644
--- a/clippy_lints/src/wildcard_imports.rs
+++ b/clippy_lints/src/wildcard_imports.rs
@@ -3,7 +3,7 @@ use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{
     def::{DefKind, Res},
-    Item, ItemKind, UseKind,
+    Item, ItemKind, PathSegment, UseKind,
 };
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -83,8 +83,8 @@ impl LateLintPass<'_, '_> for WildcardImports {
         if_chain! {
             if !in_macro(item.span);
             if let ItemKind::Use(use_path, UseKind::Glob) = &item.kind;
-            // don't lint prelude glob imports
-            if !use_path.segments.iter().last().map_or(false, |ps| ps.ident.as_str() == "prelude");
+            if !is_prelude_import(use_path.segments);
+            if !is_super_only_import_in_test(use_path.segments);
             let used_imports = cx.tcx.names_imported_by_glob_use(item.hir_id.owner);
             if !used_imports.is_empty(); // Already handled by `unused_imports`
             then {
@@ -154,3 +154,16 @@ impl LateLintPass<'_, '_> for WildcardImports {
         }
     }
 }
+
+// Allow "...prelude::*" imports.
+// Many crates have a prelude, and it is imported as a glob by design.
+fn is_prelude_import(segments: &[PathSegment<'_>]) -> bool {
+    segments.iter().last().map_or(false, |ps| ps.ident.as_str() == "prelude")
+}
+
+// Allow "super::*" imports.
+// This is intended primarily to ease the process of writing unit tests.
+fn is_super_only_import_in_test(segments: &[PathSegment<'_>]) -> bool {
+    segments.iter().len() == 1 &&
+        segments.first().map_or(false, |ps| ps.ident.as_str() == "super")
+}
diff --git a/tests/ui/wildcard_imports.fixed b/tests/ui/wildcard_imports.fixed
index ed6cc00ef04..003f11009a0 100644
--- a/tests/ui/wildcard_imports.fixed
+++ b/tests/ui/wildcard_imports.fixed
@@ -155,3 +155,41 @@ fn test_weird_formatting() {
     exported();
     foo();
 }
+
+mod test_super_imports {
+    fn foofoo() {}
+
+    mod use_super {
+        use super::*;
+
+        fn with_super() {
+            let _ = foofoo();
+        }
+    }
+
+    mod use_explicit {
+        use test_super_imports::foofoo;
+
+        fn with_explicit() {
+            let _ = foofoo();
+        }
+    }
+
+    mod use_double_super {
+        mod inner {
+            use super::super::foofoo;
+
+            fn with_double_super() {
+                let _ = foofoo();
+            }
+        }
+    }
+
+    mod use_super_explicit {
+        use super::super::test_super_imports::foofoo;
+
+        fn with_super_explicit() {
+            let _ = foofoo();
+        }
+    }
+}
diff --git a/tests/ui/wildcard_imports.rs b/tests/ui/wildcard_imports.rs
index c6d6efaece8..7bd57c7965a 100644
--- a/tests/ui/wildcard_imports.rs
+++ b/tests/ui/wildcard_imports.rs
@@ -156,3 +156,41 @@ fn test_weird_formatting() {
     exported();
     foo();
 }
+
+mod test_super_imports {
+    fn foofoo() {}
+
+    mod use_super {
+        use super::*;
+
+        fn with_super() {
+            let _ = foofoo();
+        }
+    }
+
+    mod use_explicit {
+        use test_super_imports::*;
+
+        fn with_explicit() {
+            let _ = foofoo();
+        }
+    }
+
+    mod use_double_super {
+        mod inner {
+            use super::super::*;
+
+            fn with_double_super() {
+                let _ = foofoo();
+            }
+        }
+    }
+
+    mod use_super_explicit {
+        use super::super::test_super_imports::*;
+
+        fn with_super_explicit() {
+            let _ = foofoo();
+        }
+    }
+}
diff --git a/tests/ui/wildcard_imports.stderr b/tests/ui/wildcard_imports.stderr
index 050e4c6304f..858dc28797f 100644
--- a/tests/ui/wildcard_imports.stderr
+++ b/tests/ui/wildcard_imports.stderr
@@ -92,5 +92,23 @@ LL |       use crate:: fn_mod::
 LL | |         *;
    | |_________^ help: try: `crate:: fn_mod::foo`
 
-error: aborting due to 15 previous errors
+error: usage of wildcard import
+  --> $DIR/wildcard_imports.rs:172:13
+   |
+LL |         use test_super_imports::*;
+   |             ^^^^^^^^^^^^^^^^^^^^^ help: try: `test_super_imports::foofoo`
+
+error: usage of wildcard import
+  --> $DIR/wildcard_imports.rs:181:17
+   |
+LL |             use super::super::*;
+   |                 ^^^^^^^^^^^^^^^ help: try: `super::super::foofoo`
+
+error: usage of wildcard import
+  --> $DIR/wildcard_imports.rs:190:13
+   |
+LL |         use super::super::test_super_imports::*;
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `super::super::test_super_imports::foofoo`
+
+error: aborting due to 18 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From bdc75dbb7bbdc379b1f8cc346151fac4e63d7deb Mon Sep 17 00:00:00 2001
From: Glenn Hope <glenn.alexander.hope@gmail.com>
Date: Sun, 3 May 2020 11:18:10 -0700
Subject: Run `cargo dev fmt`

---
 clippy_lints/src/wildcard_imports.rs | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/wildcard_imports.rs b/clippy_lints/src/wildcard_imports.rs
index 70ad9a60a02..e7400642b07 100644
--- a/clippy_lints/src/wildcard_imports.rs
+++ b/clippy_lints/src/wildcard_imports.rs
@@ -158,12 +158,14 @@ impl LateLintPass<'_, '_> for WildcardImports {
 // Allow "...prelude::*" imports.
 // Many crates have a prelude, and it is imported as a glob by design.
 fn is_prelude_import(segments: &[PathSegment<'_>]) -> bool {
-    segments.iter().last().map_or(false, |ps| ps.ident.as_str() == "prelude")
+    segments
+        .iter()
+        .last()
+        .map_or(false, |ps| ps.ident.as_str() == "prelude")
 }
 
 // Allow "super::*" imports.
 // This is intended primarily to ease the process of writing unit tests.
 fn is_super_only_import_in_test(segments: &[PathSegment<'_>]) -> bool {
-    segments.iter().len() == 1 &&
-        segments.first().map_or(false, |ps| ps.ident.as_str() == "super")
+    segments.iter().len() == 1 && segments.first().map_or(false, |ps| ps.ident.as_str() == "super")
 }
-- 
cgit 1.4.1-3-g733a5


From 56f4e1c3a8be54c1c80de366618e83d8d7a6e9eb Mon Sep 17 00:00:00 2001
From: Glenn Hope <glenn.alexander.hope@gmail.com>
Date: Thu, 7 May 2020 08:06:30 -0700
Subject: Check if the parent module name contains "test"

---
 clippy_lints/src/wildcard_imports.rs | 19 ++++++++++++-------
 tests/ui/wildcard_imports.fixed      | 16 ++++++++++++----
 tests/ui/wildcard_imports.rs         | 16 ++++++++++++----
 tests/ui/wildcard_imports.stderr     | 14 ++++++++++----
 4 files changed, 46 insertions(+), 19 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/wildcard_imports.rs b/clippy_lints/src/wildcard_imports.rs
index e7400642b07..a22d0e6775d 100644
--- a/clippy_lints/src/wildcard_imports.rs
+++ b/clippy_lints/src/wildcard_imports.rs
@@ -84,7 +84,7 @@ impl LateLintPass<'_, '_> for WildcardImports {
             if !in_macro(item.span);
             if let ItemKind::Use(use_path, UseKind::Glob) = &item.kind;
             if !is_prelude_import(use_path.segments);
-            if !is_super_only_import_in_test(use_path.segments);
+            if !(is_super_only_import(use_path.segments) && is_in_test_module(cx, item));
             let used_imports = cx.tcx.names_imported_by_glob_use(item.hir_id.owner);
             if !used_imports.is_empty(); // Already handled by `unused_imports`
             then {
@@ -109,8 +109,7 @@ impl LateLintPass<'_, '_> for WildcardImports {
                         span = use_path.span.with_hi(item.span.hi() - BytePos(1));
                     }
                     (
-                        span,
-                        false,
+                        span, false,
                     )
                 };
 
@@ -164,8 +163,14 @@ fn is_prelude_import(segments: &[PathSegment<'_>]) -> bool {
         .map_or(false, |ps| ps.ident.as_str() == "prelude")
 }
 
-// Allow "super::*" imports.
-// This is intended primarily to ease the process of writing unit tests.
-fn is_super_only_import_in_test(segments: &[PathSegment<'_>]) -> bool {
-    segments.iter().len() == 1 && segments.first().map_or(false, |ps| ps.ident.as_str() == "super")
+// Allow "super::*" imports in tests.
+fn is_super_only_import(segments: &[PathSegment<'_>]) -> bool {
+    segments.len() == 1 && segments[0].ident.as_str() == "super"
+}
+
+fn is_in_test_module(cx: &LateContext<'_, '_>, item: &Item<'_>) -> bool {
+    let parent = cx.tcx.hir().get_parent_node(item.hir_id);
+    let parent_item = cx.tcx.hir().expect_item(parent);
+    let parent_name = parent_item.ident.name.as_str();
+    parent_name.contains("test")
 }
diff --git a/tests/ui/wildcard_imports.fixed b/tests/ui/wildcard_imports.fixed
index 003f11009a0..1c5c01f65d1 100644
--- a/tests/ui/wildcard_imports.fixed
+++ b/tests/ui/wildcard_imports.fixed
@@ -159,7 +159,15 @@ fn test_weird_formatting() {
 mod test_super_imports {
     fn foofoo() {}
 
-    mod use_super {
+    mod use_super_should_be_replaced {
+        use super::foofoo;
+
+        fn with_super() {
+            let _ = foofoo();
+        }
+    }
+
+    mod use_super_in_test_should_pass {
         use super::*;
 
         fn with_super() {
@@ -167,7 +175,7 @@ mod test_super_imports {
         }
     }
 
-    mod use_explicit {
+    mod use_explicit_should_be_replaced {
         use test_super_imports::foofoo;
 
         fn with_explicit() {
@@ -175,7 +183,7 @@ mod test_super_imports {
         }
     }
 
-    mod use_double_super {
+    mod use_double_super_should_be_replaced {
         mod inner {
             use super::super::foofoo;
 
@@ -185,7 +193,7 @@ mod test_super_imports {
         }
     }
 
-    mod use_super_explicit {
+    mod use_super_explicit_should_be_replaced {
         use super::super::test_super_imports::foofoo;
 
         fn with_super_explicit() {
diff --git a/tests/ui/wildcard_imports.rs b/tests/ui/wildcard_imports.rs
index 7bd57c7965a..f783149ef93 100644
--- a/tests/ui/wildcard_imports.rs
+++ b/tests/ui/wildcard_imports.rs
@@ -160,7 +160,7 @@ fn test_weird_formatting() {
 mod test_super_imports {
     fn foofoo() {}
 
-    mod use_super {
+    mod use_super_should_be_replaced {
         use super::*;
 
         fn with_super() {
@@ -168,7 +168,15 @@ mod test_super_imports {
         }
     }
 
-    mod use_explicit {
+    mod use_super_in_test_should_pass {
+        use super::*;
+
+        fn with_super() {
+            let _ = foofoo();
+        }
+    }
+
+    mod use_explicit_should_be_replaced {
         use test_super_imports::*;
 
         fn with_explicit() {
@@ -176,7 +184,7 @@ mod test_super_imports {
         }
     }
 
-    mod use_double_super {
+    mod use_double_super_should_be_replaced {
         mod inner {
             use super::super::*;
 
@@ -186,7 +194,7 @@ mod test_super_imports {
         }
     }
 
-    mod use_super_explicit {
+    mod use_super_explicit_should_be_replaced {
         use super::super::test_super_imports::*;
 
         fn with_super_explicit() {
diff --git a/tests/ui/wildcard_imports.stderr b/tests/ui/wildcard_imports.stderr
index 858dc28797f..649d550a88d 100644
--- a/tests/ui/wildcard_imports.stderr
+++ b/tests/ui/wildcard_imports.stderr
@@ -93,22 +93,28 @@ LL | |         *;
    | |_________^ help: try: `crate:: fn_mod::foo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:172:13
+  --> $DIR/wildcard_imports.rs:164:13
+   |
+LL |         use super::*;
+   |             ^^^^^^^^ help: try: `super::foofoo`
+
+error: usage of wildcard import
+  --> $DIR/wildcard_imports.rs:180:13
    |
 LL |         use test_super_imports::*;
    |             ^^^^^^^^^^^^^^^^^^^^^ help: try: `test_super_imports::foofoo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:181:17
+  --> $DIR/wildcard_imports.rs:189:17
    |
 LL |             use super::super::*;
    |                 ^^^^^^^^^^^^^^^ help: try: `super::super::foofoo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:190:13
+  --> $DIR/wildcard_imports.rs:198:13
    |
 LL |         use super::super::test_super_imports::*;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `super::super::test_super_imports::foofoo`
 
-error: aborting due to 18 previous errors
+error: aborting due to 19 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From ad92486d52fdede5c712dd27c868c942d8240704 Mon Sep 17 00:00:00 2001
From: Glenn Hope <glenn.alexander.hope@gmail.com>
Date: Thu, 7 May 2020 14:41:54 -0700
Subject: Add check for "test" in parent name. Include flag for disabling
 wildcard import exceptions

---
 clippy_lints/src/lib.rs                            |  3 +-
 clippy_lints/src/utils/conf.rs                     |  2 +
 clippy_lints/src/wildcard_imports.rs               | 48 ++++++++++++++++++----
 .../toml_unknown_key/conf_unknown_key.stderr       |  2 +-
 tests/ui/wildcard_imports.fixed                    | 17 +++++---
 tests/ui/wildcard_imports.rs                       | 17 +++++---
 tests/ui/wildcard_imports.stderr                   | 14 +++----
 7 files changed, 75 insertions(+), 28 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index fb2e9932b8e..4b67c84e38e 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1058,7 +1058,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     let max_struct_bools = conf.max_struct_bools;
     store.register_early_pass(move || box excessive_bools::ExcessiveBools::new(max_struct_bools, max_fn_params_bools));
     store.register_early_pass(|| box option_env_unwrap::OptionEnvUnwrap);
-    store.register_late_pass(|| box wildcard_imports::WildcardImports);
+    let warn_on_all_wildcard_imports = conf.warn_on_all_wildcard_imports;
+    store.register_late_pass(move || box wildcard_imports::WildcardImports::new(warn_on_all_wildcard_imports));
     store.register_early_pass(|| box macro_use::MacroUseImports);
     store.register_late_pass(|| box verbose_file_reads::VerboseFileReads);
     store.register_late_pass(|| box redundant_pub_crate::RedundantPubCrate::default());
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 4b81ff33495..57b9eafd14d 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -158,6 +158,8 @@ define_Conf! {
     (max_struct_bools, "max_struct_bools": u64, 3),
     /// Lint: FN_PARAMS_EXCESSIVE_BOOLS. The maximum number of bools function parameters can have
     (max_fn_params_bools, "max_fn_params_bools": u64, 3),
+    /// Lint: WILDCARD_IMPORTS. Whether to allow certain wildcard imports (prelude, super in tests).
+    (warn_on_all_wildcard_imports, "warn_on_all_wildcard_imports": bool, false),
 }
 
 impl Default for Conf {
diff --git a/clippy_lints/src/wildcard_imports.rs b/clippy_lints/src/wildcard_imports.rs
index a22d0e6775d..43d0d1b9e96 100644
--- a/clippy_lints/src/wildcard_imports.rs
+++ b/clippy_lints/src/wildcard_imports.rs
@@ -6,7 +6,7 @@ use rustc_hir::{
     Item, ItemKind, PathSegment, UseKind,
 };
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::BytePos;
 
 declare_clippy_lint! {
@@ -73,18 +73,38 @@ declare_clippy_lint! {
     "lint `use _::*` statements"
 }
 
-declare_lint_pass!(WildcardImports => [ENUM_GLOB_USE, WILDCARD_IMPORTS]);
+#[derive(Default)]
+pub struct WildcardImports {
+    warn_on_all: bool,
+    is_test_module: bool,
+    test_modules_deep: u32,
+}
+
+impl WildcardImports {
+    pub fn new(warn_on_all: bool) -> Self {
+        Self {
+            warn_on_all,
+            is_test_module: false,
+            test_modules_deep: 0,
+        }
+    }
+}
+
+impl_lint_pass!(WildcardImports => [ENUM_GLOB_USE, WILDCARD_IMPORTS]);
 
 impl LateLintPass<'_, '_> for WildcardImports {
     fn check_item(&mut self, cx: &LateContext<'_, '_>, item: &Item<'_>) {
         if item.vis.node.is_pub() || item.vis.node.is_pub_restricted() {
             return;
         }
+        if is_test_module(item) {
+            self.is_test_module = true;
+            self.test_modules_deep += 1;
+        }
         if_chain! {
             if !in_macro(item.span);
             if let ItemKind::Use(use_path, UseKind::Glob) = &item.kind;
-            if !is_prelude_import(use_path.segments);
-            if !(is_super_only_import(use_path.segments) && is_in_test_module(cx, item));
+            if self.warn_on_all || !self.check_exceptions(use_path.segments);
             let used_imports = cx.tcx.names_imported_by_glob_use(item.hir_id.owner);
             if !used_imports.is_empty(); // Already handled by `unused_imports`
             then {
@@ -152,6 +172,19 @@ impl LateLintPass<'_, '_> for WildcardImports {
             }
         }
     }
+
+    fn check_item_post(&mut self, _: &LateContext<'_, '_>, _: &Item<'_>) {
+        if self.is_test_module {
+            self.is_test_module = false;
+            self.test_modules_deep -= 1;
+        }
+    }
+}
+
+impl WildcardImports {
+    fn check_exceptions(&self, segments: &[PathSegment<'_>]) -> bool {
+        is_prelude_import(segments) || (is_super_only_import(segments) && self.test_modules_deep > 0)
+    }
 }
 
 // Allow "...prelude::*" imports.
@@ -168,9 +201,6 @@ fn is_super_only_import(segments: &[PathSegment<'_>]) -> bool {
     segments.len() == 1 && segments[0].ident.as_str() == "super"
 }
 
-fn is_in_test_module(cx: &LateContext<'_, '_>, item: &Item<'_>) -> bool {
-    let parent = cx.tcx.hir().get_parent_node(item.hir_id);
-    let parent_item = cx.tcx.hir().expect_item(parent);
-    let parent_name = parent_item.ident.name.as_str();
-    parent_name.contains("test")
+fn is_test_module(item: &Item<'_>) -> bool {
+    item.ident.name.as_str().contains("test")
 }
diff --git a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
index 18f5d994ba8..53970af4107 100644
--- a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
+++ b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
@@ -1,4 +1,4 @@
-error: error reading Clippy's configuration file `$DIR/clippy.toml`: unknown field `foobar`, expected one of `blacklisted-names`, `cognitive-complexity-threshold`, `cyclomatic-complexity-threshold`, `doc-valid-idents`, `too-many-arguments-threshold`, `type-complexity-threshold`, `single-char-binding-names-threshold`, `too-large-for-stack`, `enum-variant-name-threshold`, `enum-variant-size-threshold`, `verbose-bit-mask-threshold`, `literal-representation-threshold`, `trivial-copy-size-limit`, `too-many-lines-threshold`, `array-size-threshold`, `vec-box-size-threshold`, `max-struct-bools`, `max-fn-params-bools`, `third-party` at line 5 column 1
+error: error reading Clippy's configuration file `$DIR/clippy.toml`: unknown field `foobar`, expected one of `blacklisted-names`, `cognitive-complexity-threshold`, `cyclomatic-complexity-threshold`, `doc-valid-idents`, `too-many-arguments-threshold`, `type-complexity-threshold`, `single-char-binding-names-threshold`, `too-large-for-stack`, `enum-variant-name-threshold`, `enum-variant-size-threshold`, `verbose-bit-mask-threshold`, `literal-representation-threshold`, `trivial-copy-size-limit`, `too-many-lines-threshold`, `array-size-threshold`, `vec-box-size-threshold`, `max-struct-bools`, `max-fn-params-bools`, `warn-on-all-wildcard-imports`, `third-party` at line 5 column 1
 
 error: aborting due to previous error
 
diff --git a/tests/ui/wildcard_imports.fixed b/tests/ui/wildcard_imports.fixed
index 1c5c01f65d1..98bf6acfe55 100644
--- a/tests/ui/wildcard_imports.fixed
+++ b/tests/ui/wildcard_imports.fixed
@@ -156,10 +156,10 @@ fn test_weird_formatting() {
     foo();
 }
 
-mod test_super_imports {
+mod super_imports {
     fn foofoo() {}
 
-    mod use_super_should_be_replaced {
+    mod should_be_replaced {
         use super::foofoo;
 
         fn with_super() {
@@ -167,7 +167,7 @@ mod test_super_imports {
         }
     }
 
-    mod use_super_in_test_should_pass {
+    mod test_should_pass {
         use super::*;
 
         fn with_super() {
@@ -175,8 +175,15 @@ mod test_super_imports {
         }
     }
 
+    mod inner {
+        fn test_should_pass() {
+            use super::*;
+            let _ = foofoo();
+        }
+    }
+
     mod use_explicit_should_be_replaced {
-        use test_super_imports::foofoo;
+        use super_imports::foofoo;
 
         fn with_explicit() {
             let _ = foofoo();
@@ -194,7 +201,7 @@ mod test_super_imports {
     }
 
     mod use_super_explicit_should_be_replaced {
-        use super::super::test_super_imports::foofoo;
+        use super::super::super_imports::foofoo;
 
         fn with_super_explicit() {
             let _ = foofoo();
diff --git a/tests/ui/wildcard_imports.rs b/tests/ui/wildcard_imports.rs
index f783149ef93..9275c5a0928 100644
--- a/tests/ui/wildcard_imports.rs
+++ b/tests/ui/wildcard_imports.rs
@@ -157,10 +157,10 @@ fn test_weird_formatting() {
     foo();
 }
 
-mod test_super_imports {
+mod super_imports {
     fn foofoo() {}
 
-    mod use_super_should_be_replaced {
+    mod should_be_replaced {
         use super::*;
 
         fn with_super() {
@@ -168,7 +168,7 @@ mod test_super_imports {
         }
     }
 
-    mod use_super_in_test_should_pass {
+    mod test_should_pass {
         use super::*;
 
         fn with_super() {
@@ -176,8 +176,15 @@ mod test_super_imports {
         }
     }
 
+    mod inner {
+        fn test_should_pass() {
+            use super::*;
+            let _ = foofoo();
+        }
+    }
+
     mod use_explicit_should_be_replaced {
-        use test_super_imports::*;
+        use super_imports::*;
 
         fn with_explicit() {
             let _ = foofoo();
@@ -195,7 +202,7 @@ mod test_super_imports {
     }
 
     mod use_super_explicit_should_be_replaced {
-        use super::super::test_super_imports::*;
+        use super::super::super_imports::*;
 
         fn with_super_explicit() {
             let _ = foofoo();
diff --git a/tests/ui/wildcard_imports.stderr b/tests/ui/wildcard_imports.stderr
index 649d550a88d..bd000ce8161 100644
--- a/tests/ui/wildcard_imports.stderr
+++ b/tests/ui/wildcard_imports.stderr
@@ -99,22 +99,22 @@ LL |         use super::*;
    |             ^^^^^^^^ help: try: `super::foofoo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:180:13
+  --> $DIR/wildcard_imports.rs:187:13
    |
-LL |         use test_super_imports::*;
-   |             ^^^^^^^^^^^^^^^^^^^^^ help: try: `test_super_imports::foofoo`
+LL |         use super_imports::*;
+   |             ^^^^^^^^^^^^^^^^ help: try: `super_imports::foofoo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:189:17
+  --> $DIR/wildcard_imports.rs:196:17
    |
 LL |             use super::super::*;
    |                 ^^^^^^^^^^^^^^^ help: try: `super::super::foofoo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:198:13
+  --> $DIR/wildcard_imports.rs:205:13
    |
-LL |         use super::super::test_super_imports::*;
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `super::super::test_super_imports::foofoo`
+LL |         use super::super::super_imports::*;
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `super::super::super_imports::foofoo`
 
 error: aborting due to 19 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From a42a2bdac2a6c881f85ebdbce66e84d977c74cfa Mon Sep 17 00:00:00 2001
From: Glenn Hope <glenn.alexander.hope@gmail.com>
Date: Thu, 7 May 2020 14:48:27 -0700
Subject: Also have flag disable macro check

---
 clippy_lints/src/wildcard_imports.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/wildcard_imports.rs b/clippy_lints/src/wildcard_imports.rs
index 43d0d1b9e96..843ddda0356 100644
--- a/clippy_lints/src/wildcard_imports.rs
+++ b/clippy_lints/src/wildcard_imports.rs
@@ -102,7 +102,7 @@ impl LateLintPass<'_, '_> for WildcardImports {
             self.test_modules_deep += 1;
         }
         if_chain! {
-            if !in_macro(item.span);
+            if self.warn_on_all || !in_macro(item.span);
             if let ItemKind::Use(use_path, UseKind::Glob) = &item.kind;
             if self.warn_on_all || !self.check_exceptions(use_path.segments);
             let used_imports = cx.tcx.names_imported_by_glob_use(item.hir_id.owner);
-- 
cgit 1.4.1-3-g733a5


From 152cdcb45be7a8f0f24dbcd4177e0858d94516b6 Mon Sep 17 00:00:00 2001
From: Glenn Hope <glenn.alexander.hope@gmail.com>
Date: Fri, 8 May 2020 18:22:27 -0700
Subject: Remove unnecessary field, check for Mod/Fn ItemKind

---
 clippy_lints/src/wildcard_imports.rs | 14 +++++---------
 1 file changed, 5 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/wildcard_imports.rs b/clippy_lints/src/wildcard_imports.rs
index 843ddda0356..48405a00d55 100644
--- a/clippy_lints/src/wildcard_imports.rs
+++ b/clippy_lints/src/wildcard_imports.rs
@@ -76,7 +76,6 @@ declare_clippy_lint! {
 #[derive(Default)]
 pub struct WildcardImports {
     warn_on_all: bool,
-    is_test_module: bool,
     test_modules_deep: u32,
 }
 
@@ -84,7 +83,6 @@ impl WildcardImports {
     pub fn new(warn_on_all: bool) -> Self {
         Self {
             warn_on_all,
-            is_test_module: false,
             test_modules_deep: 0,
         }
     }
@@ -97,8 +95,7 @@ impl LateLintPass<'_, '_> for WildcardImports {
         if item.vis.node.is_pub() || item.vis.node.is_pub_restricted() {
             return;
         }
-        if is_test_module(item) {
-            self.is_test_module = true;
+        if is_test_module_or_function(item) {
             self.test_modules_deep += 1;
         }
         if_chain! {
@@ -173,9 +170,8 @@ impl LateLintPass<'_, '_> for WildcardImports {
         }
     }
 
-    fn check_item_post(&mut self, _: &LateContext<'_, '_>, _: &Item<'_>) {
-        if self.is_test_module {
-            self.is_test_module = false;
+    fn check_item_post(&mut self, _: &LateContext<'_, '_>, item: &Item<'_>) {
+        if is_test_module_or_function(item) {
             self.test_modules_deep -= 1;
         }
     }
@@ -201,6 +197,6 @@ fn is_super_only_import(segments: &[PathSegment<'_>]) -> bool {
     segments.len() == 1 && segments[0].ident.as_str() == "super"
 }
 
-fn is_test_module(item: &Item<'_>) -> bool {
-    item.ident.name.as_str().contains("test")
+fn is_test_module_or_function(item: &Item<'_>) -> bool {
+    matches!(item.kind, ItemKind::Fn(..) | ItemKind::Mod(..)) && item.ident.name.as_str().contains("test")
 }
-- 
cgit 1.4.1-3-g733a5


From 4db6abcd50eb07a7fa8349a059f80792b7b19a2e Mon Sep 17 00:00:00 2001
From: Glenn Hope <glenn.alexander.hope@gmail.com>
Date: Sat, 9 May 2020 08:04:07 -0700
Subject: Remove check for Fn, reflect this in test cases, make test cases more
 robust/explicit

---
 clippy_lints/src/wildcard_imports.rs | 13 +++++++++----
 tests/ui/wildcard_imports.fixed      | 25 +++++++++++++++++++++++--
 tests/ui/wildcard_imports.rs         | 24 ++++++++++++++++++++++--
 tests/ui/wildcard_imports.stderr     | 14 ++++++++++----
 4 files changed, 64 insertions(+), 12 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/wildcard_imports.rs b/clippy_lints/src/wildcard_imports.rs
index 48405a00d55..e12a6659ab5 100644
--- a/clippy_lints/src/wildcard_imports.rs
+++ b/clippy_lints/src/wildcard_imports.rs
@@ -43,9 +43,14 @@ declare_clippy_lint! {
     ///
     /// This can lead to confusing error messages at best and to unexpected behavior at worst.
     ///
-    /// Note that this will not warn about wildcard imports from modules named `prelude`; many
-    /// crates (including the standard library) provide modules named "prelude" specifically
-    /// designed for wildcard import.
+    /// **Exceptions:**
+    ///
+    /// Wildcard imports are allowed from modules named `prelude`. Many crates (including the standard library)
+    /// provide modules named "prelude" specifically designed for wildcard import.
+    ///
+    /// `use super::*` is allowed in test modules. This is defined as any module with "test" in the name.
+    ///
+    /// These exceptions can be disabled using the `warn-on-all-wildcard-imports` configuration flag.
     ///
     /// **Known problems:** If macros are imported through the wildcard, this macro is not included
     /// by the suggestion and has to be added by hand.
@@ -198,5 +203,5 @@ fn is_super_only_import(segments: &[PathSegment<'_>]) -> bool {
 }
 
 fn is_test_module_or_function(item: &Item<'_>) -> bool {
-    matches!(item.kind, ItemKind::Fn(..) | ItemKind::Mod(..)) && item.ident.name.as_str().contains("test")
+    matches!(item.kind, ItemKind::Mod(..)) && item.ident.name.as_str().contains("test")
 }
diff --git a/tests/ui/wildcard_imports.fixed b/tests/ui/wildcard_imports.fixed
index 98bf6acfe55..b47c8f23e24 100644
--- a/tests/ui/wildcard_imports.fixed
+++ b/tests/ui/wildcard_imports.fixed
@@ -175,13 +175,34 @@ mod super_imports {
         }
     }
 
-    mod inner {
-        fn test_should_pass() {
+    mod test_should_pass_inside_function {
+        fn with_super_inside_function() {
             use super::*;
             let _ = foofoo();
         }
     }
 
+    mod test_should_pass_further_inside {
+        fn insidefoo() {}
+        mod inner {
+            use super::*;
+            fn with_super() {
+                let _ = insidefoo();
+            }
+        }
+    }
+
+    mod should_be_replaced_futher_inside {
+        fn insidefoo() {}
+        mod inner {
+            use super::insidefoo;
+            fn with_super() {
+                let _ = insidefoo();
+            }
+        }
+    }
+
+
     mod use_explicit_should_be_replaced {
         use super_imports::foofoo;
 
diff --git a/tests/ui/wildcard_imports.rs b/tests/ui/wildcard_imports.rs
index 9275c5a0928..3ad1a29aeba 100644
--- a/tests/ui/wildcard_imports.rs
+++ b/tests/ui/wildcard_imports.rs
@@ -176,13 +176,33 @@ mod super_imports {
         }
     }
 
-    mod inner {
-        fn test_should_pass() {
+    mod test_should_pass_inside_function {
+        fn with_super_inside_function() {
             use super::*;
             let _ = foofoo();
         }
     }
 
+    mod test_should_pass_further_inside {
+        fn insidefoo() {}
+        mod inner {
+            use super::*;
+            fn with_super() {
+                let _ = insidefoo();
+            }
+        }
+    }
+
+    mod should_be_replaced_futher_inside {
+        fn insidefoo() {}
+        mod inner {
+            use super::*;
+            fn with_super() {
+                let _ = insidefoo();
+            }
+        }
+    }
+
     mod use_explicit_should_be_replaced {
         use super_imports::*;
 
diff --git a/tests/ui/wildcard_imports.stderr b/tests/ui/wildcard_imports.stderr
index bd000ce8161..de07bd1d69b 100644
--- a/tests/ui/wildcard_imports.stderr
+++ b/tests/ui/wildcard_imports.stderr
@@ -99,22 +99,28 @@ LL |         use super::*;
    |             ^^^^^^^^ help: try: `super::foofoo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:187:13
+  --> $DIR/wildcard_imports.rs:199:17
+   |
+LL |             use super::*;
+   |                 ^^^^^^^^ help: try: `super::insidefoo`
+
+error: usage of wildcard import
+  --> $DIR/wildcard_imports.rs:208:13
    |
 LL |         use super_imports::*;
    |             ^^^^^^^^^^^^^^^^ help: try: `super_imports::foofoo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:196:17
+  --> $DIR/wildcard_imports.rs:217:17
    |
 LL |             use super::super::*;
    |                 ^^^^^^^^^^^^^^^ help: try: `super::super::foofoo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:205:13
+  --> $DIR/wildcard_imports.rs:226:13
    |
 LL |         use super::super::super_imports::*;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `super::super::super_imports::foofoo`
 
-error: aborting due to 19 previous errors
+error: aborting due to 20 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 0ba61c612ee873314d252ca1f747c14a2f0161ba Mon Sep 17 00:00:00 2001
From: Glenn Hope <glenn.alexander.hope@gmail.com>
Date: Sat, 9 May 2020 10:14:29 -0700
Subject: Check is_macro inside check_exceptions, update references to fix test

---
 clippy_lints/src/wildcard_imports.rs | 13 +++++++------
 tests/ui/wildcard_imports.stderr     |  6 +++---
 2 files changed, 10 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/wildcard_imports.rs b/clippy_lints/src/wildcard_imports.rs
index e12a6659ab5..2c4e24780e7 100644
--- a/clippy_lints/src/wildcard_imports.rs
+++ b/clippy_lints/src/wildcard_imports.rs
@@ -101,12 +101,11 @@ impl LateLintPass<'_, '_> for WildcardImports {
             return;
         }
         if is_test_module_or_function(item) {
-            self.test_modules_deep += 1;
+            self.test_modules_deep = self.test_modules_deep.saturating_add(1);
         }
         if_chain! {
-            if self.warn_on_all || !in_macro(item.span);
             if let ItemKind::Use(use_path, UseKind::Glob) = &item.kind;
-            if self.warn_on_all || !self.check_exceptions(use_path.segments);
+            if self.warn_on_all || !self.check_exceptions(item, use_path.segments);
             let used_imports = cx.tcx.names_imported_by_glob_use(item.hir_id.owner);
             if !used_imports.is_empty(); // Already handled by `unused_imports`
             then {
@@ -177,14 +176,16 @@ impl LateLintPass<'_, '_> for WildcardImports {
 
     fn check_item_post(&mut self, _: &LateContext<'_, '_>, item: &Item<'_>) {
         if is_test_module_or_function(item) {
-            self.test_modules_deep -= 1;
+            self.test_modules_deep = self.test_modules_deep.saturating_sub(1);
         }
     }
 }
 
 impl WildcardImports {
-    fn check_exceptions(&self, segments: &[PathSegment<'_>]) -> bool {
-        is_prelude_import(segments) || (is_super_only_import(segments) && self.test_modules_deep > 0)
+    fn check_exceptions(&self, item: &Item<'_>, segments: &[PathSegment<'_>]) -> bool {
+        in_macro(item.span)
+            || is_prelude_import(segments)
+            || (is_super_only_import(segments) && self.test_modules_deep > 0)
     }
 }
 
diff --git a/tests/ui/wildcard_imports.stderr b/tests/ui/wildcard_imports.stderr
index de07bd1d69b..fab43b738eb 100644
--- a/tests/ui/wildcard_imports.stderr
+++ b/tests/ui/wildcard_imports.stderr
@@ -105,19 +105,19 @@ LL |             use super::*;
    |                 ^^^^^^^^ help: try: `super::insidefoo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:208:13
+  --> $DIR/wildcard_imports.rs:207:13
    |
 LL |         use super_imports::*;
    |             ^^^^^^^^^^^^^^^^ help: try: `super_imports::foofoo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:217:17
+  --> $DIR/wildcard_imports.rs:216:17
    |
 LL |             use super::super::*;
    |                 ^^^^^^^^^^^^^^^ help: try: `super::super::foofoo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:226:13
+  --> $DIR/wildcard_imports.rs:225:13
    |
 LL |         use super::super::super_imports::*;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `super::super::super_imports::foofoo`
-- 
cgit 1.4.1-3-g733a5


From b69200b8468434bc3f5b9ef8468733e5d40f4e01 Mon Sep 17 00:00:00 2001
From: Glenn Hope <glenn.alexander.hope@gmail.com>
Date: Sat, 9 May 2020 10:16:47 -0700
Subject: Move is_test_module check to top of function

---
 clippy_lints/src/wildcard_imports.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/wildcard_imports.rs b/clippy_lints/src/wildcard_imports.rs
index 2c4e24780e7..32d9a45c37d 100644
--- a/clippy_lints/src/wildcard_imports.rs
+++ b/clippy_lints/src/wildcard_imports.rs
@@ -97,12 +97,12 @@ impl_lint_pass!(WildcardImports => [ENUM_GLOB_USE, WILDCARD_IMPORTS]);
 
 impl LateLintPass<'_, '_> for WildcardImports {
     fn check_item(&mut self, cx: &LateContext<'_, '_>, item: &Item<'_>) {
-        if item.vis.node.is_pub() || item.vis.node.is_pub_restricted() {
-            return;
-        }
         if is_test_module_or_function(item) {
             self.test_modules_deep = self.test_modules_deep.saturating_add(1);
         }
+        if item.vis.node.is_pub() || item.vis.node.is_pub_restricted() {
+            return;
+        }
         if_chain! {
             if let ItemKind::Use(use_path, UseKind::Glob) = &item.kind;
             if self.warn_on_all || !self.check_exceptions(item, use_path.segments);
-- 
cgit 1.4.1-3-g733a5


From 8ab3224b3b273f4911943800c56dc4aa925bc4c5 Mon Sep 17 00:00:00 2001
From: Camille GILLOT <gillot.camille@gmail.com>
Date: Fri, 8 May 2020 13:57:01 +0200
Subject: Fix clippy.

---
 clippy_lints/src/bytecount.rs                |  7 ++++---
 clippy_lints/src/inline_fn_without_body.rs   |  5 +++--
 clippy_lints/src/len_zero.rs                 |  6 +++---
 clippy_lints/src/lib.rs                      |  2 +-
 clippy_lints/src/map_clone.rs                |  4 ++--
 clippy_lints/src/non_expressive_names.rs     |  4 ++--
 clippy_lints/src/unsafe_removed_from_name.rs |  4 ++--
 clippy_lints/src/utils/hir_utils.rs          |  4 ++--
 clippy_lints/src/utils/internal_lints.rs     | 10 +++++-----
 clippy_lints/src/utils/mod.rs                |  2 +-
 clippy_lints/src/utils/ptr.rs                |  9 ++++-----
 clippy_lints/src/utils/usage.rs              |  5 ++---
 12 files changed, 31 insertions(+), 31 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/bytecount.rs b/clippy_lints/src/bytecount.rs
index 91d3e47d787..278d043732f 100644
--- a/clippy_lints/src/bytecount.rs
+++ b/clippy_lints/src/bytecount.rs
@@ -3,12 +3,13 @@ use crate::utils::{
     span_lint_and_sugg, walk_ptrs_ty,
 };
 use if_chain::if_chain;
-use rustc_ast::ast::{Name, UintTy};
+use rustc_ast::ast::{UintTy};
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, BorrowKind, Expr, ExprKind, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::Symbol;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for naive byte counts
@@ -95,11 +96,11 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for ByteCount {
     }
 }
 
-fn check_arg(name: Name, arg: Name, needle: &Expr<'_>) -> bool {
+fn check_arg(name: Symbol, arg: Symbol, needle: &Expr<'_>) -> bool {
     name == arg && !contains_name(name, needle)
 }
 
-fn get_path_name(expr: &Expr<'_>) -> Option<Name> {
+fn get_path_name(expr: &Expr<'_>) -> Option<Symbol> {
     match expr.kind {
         ExprKind::Box(ref e) | ExprKind::AddrOf(BorrowKind::Ref, _, ref e) | ExprKind::Unary(UnOp::UnDeref, ref e) => {
             get_path_name(e)
diff --git a/clippy_lints/src/inline_fn_without_body.rs b/clippy_lints/src/inline_fn_without_body.rs
index 1ebfb3c8162..475610dda47 100644
--- a/clippy_lints/src/inline_fn_without_body.rs
+++ b/clippy_lints/src/inline_fn_without_body.rs
@@ -2,11 +2,12 @@
 
 use crate::utils::span_lint_and_then;
 use crate::utils::sugg::DiagnosticBuilderExt;
-use rustc_ast::ast::{Attribute, Name};
+use rustc_ast::ast::Attribute;
 use rustc_errors::Applicability;
 use rustc_hir::{TraitFn, TraitItem, TraitItemKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::Symbol;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for `#[inline]` on trait methods without bodies
@@ -38,7 +39,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for InlineFnWithoutBody {
     }
 }
 
-fn check_attrs(cx: &LateContext<'_, '_>, name: Name, attrs: &[Attribute]) {
+fn check_attrs(cx: &LateContext<'_, '_>, name: Symbol, attrs: &[Attribute]) {
     for attr in attrs {
         if !attr.check_name(sym!(inline)) {
             continue;
diff --git a/clippy_lints/src/len_zero.rs b/clippy_lints/src/len_zero.rs
index 1d86ca9696f..2ec0b5a8d6f 100644
--- a/clippy_lints/src/len_zero.rs
+++ b/clippy_lints/src/len_zero.rs
@@ -1,5 +1,5 @@
 use crate::utils::{get_item_name, snippet_with_applicability, span_lint, span_lint_and_sugg, walk_ptrs_ty};
-use rustc_ast::ast::{LitKind, Name};
+use rustc_ast::ast::LitKind;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Applicability;
 use rustc_hir::def_id::DefId;
@@ -7,7 +7,7 @@ use rustc_hir::{AssocItemKind, BinOpKind, Expr, ExprKind, ImplItemRef, Item, Ite
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::source_map::{Span, Spanned};
+use rustc_span::source_map::{Span, Spanned, Symbol};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for getting the length of something via `.len()`
@@ -226,7 +226,7 @@ fn check_cmp(cx: &LateContext<'_, '_>, span: Span, method: &Expr<'_>, lit: &Expr
 fn check_len(
     cx: &LateContext<'_, '_>,
     span: Span,
-    method_name: Name,
+    method_name: Symbol,
     args: &[Expr<'_>],
     lit: &LitKind,
     op: &str,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 4b67c84e38e..51b5401da7d 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -335,7 +335,7 @@ mod zero_div_zero;
 pub use crate::utils::conf::Conf;
 
 mod reexport {
-    pub use rustc_ast::ast::Name;
+    pub use rustc_span::Symbol as Name;
 }
 
 /// Register all pre expansion lints
diff --git a/clippy_lints/src/map_clone.rs b/clippy_lints/src/map_clone.rs
index 0b346393ac3..0163b3f8dbc 100644
--- a/clippy_lints/src/map_clone.rs
+++ b/clippy_lints/src/map_clone.rs
@@ -3,14 +3,14 @@ use crate::utils::{
     is_copy, is_type_diagnostic_item, match_trait_method, remove_blocks, snippet_with_applicability, span_lint_and_sugg,
 };
 use if_chain::if_chain;
-use rustc_ast::ast::Ident;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::mir::Mutability;
 use rustc_middle::ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::source_map::Span;
+use rustc_span::Span;
+use rustc_span::symbol::Ident;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for usage of `iterator.map(|x| x.clone())` and suggests
diff --git a/clippy_lints/src/non_expressive_names.rs b/clippy_lints/src/non_expressive_names.rs
index 45809b35986..2b51b732075 100644
--- a/clippy_lints/src/non_expressive_names.rs
+++ b/clippy_lints/src/non_expressive_names.rs
@@ -1,13 +1,13 @@
 use crate::utils::{span_lint, span_lint_and_then};
 use rustc_ast::ast::{
-    Arm, AssocItem, AssocItemKind, Attribute, Block, FnDecl, Ident, Item, ItemKind, Local, MacCall, Pat, PatKind,
+    Arm, AssocItem, AssocItemKind, Attribute, Block, FnDecl, Item, ItemKind, Local, MacCall, Pat, PatKind,
 };
 use rustc_ast::attr;
 use rustc_ast::visit::{walk_block, walk_expr, walk_pat, Visitor};
 use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::Span;
-use rustc_span::symbol::SymbolStr;
+use rustc_span::symbol::{Ident, SymbolStr};
 use std::cmp::Ordering;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/unsafe_removed_from_name.rs b/clippy_lints/src/unsafe_removed_from_name.rs
index 86c469a4dcc..735800e7e74 100644
--- a/clippy_lints/src/unsafe_removed_from_name.rs
+++ b/clippy_lints/src/unsafe_removed_from_name.rs
@@ -1,9 +1,9 @@
 use crate::utils::span_lint;
-use rustc_ast::ast::{Ident, Item, ItemKind, UseTree, UseTreeKind};
+use rustc_ast::ast::{Item, ItemKind, UseTree, UseTreeKind};
 use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
-use rustc_span::symbol::SymbolStr;
+use rustc_span::symbol::{Ident, SymbolStr};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for imports that remove "unsafe" from an item's
diff --git a/clippy_lints/src/utils/hir_utils.rs b/clippy_lints/src/utils/hir_utils.rs
index 02b721fd378..bd7da57c665 100644
--- a/clippy_lints/src/utils/hir_utils.rs
+++ b/clippy_lints/src/utils/hir_utils.rs
@@ -1,6 +1,5 @@
 use crate::consts::{constant_context, constant_simple};
 use crate::utils::differing_macro_contexts;
-use rustc_ast::ast::Name;
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
 use rustc_hir::{
     BinOpKind, Block, BlockCheckMode, BodyId, BorrowKind, CaptureBy, Expr, ExprKind, Field, FnRetTy, GenericArg,
@@ -10,6 +9,7 @@ use rustc_hir::{
 use rustc_lint::LateContext;
 use rustc_middle::ich::StableHashingContextProvider;
 use rustc_middle::ty::TypeckTables;
+use rustc_span::Symbol;
 use std::hash::Hash;
 
 /// Type used to check whether two ast are the same. This is different from the
@@ -544,7 +544,7 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> {
         }
     }
 
-    pub fn hash_name(&mut self, n: Name) {
+    pub fn hash_name(&mut self, n: Symbol) {
         n.as_str().hash(&mut self.s);
     }
 
diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs
index 5bf9acdc5f7..8e1b047f6f8 100644
--- a/clippy_lints/src/utils/internal_lints.rs
+++ b/clippy_lints/src/utils/internal_lints.rs
@@ -4,7 +4,7 @@ use crate::utils::{
     span_lint_and_help, span_lint_and_sugg, walk_ptrs_ty,
 };
 use if_chain::if_chain;
-use rustc_ast::ast::{Crate as AstCrate, ItemKind, LitKind, Name, NodeId};
+use rustc_ast::ast::{Crate as AstCrate, ItemKind, LitKind, NodeId};
 use rustc_ast::visit::FnKind;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_errors::Applicability;
@@ -17,7 +17,7 @@ use rustc_lint::{EarlyContext, EarlyLintPass, LateContext, LateLintPass};
 use rustc_middle::hir::map::Map;
 use rustc_session::{declare_lint_pass, declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::{Span, Spanned};
-use rustc_span::symbol::SymbolStr;
+use rustc_span::symbol::{Symbol, SymbolStr};
 
 use std::borrow::{Borrow, Cow};
 
@@ -245,8 +245,8 @@ impl EarlyLintPass for ClippyLintsInternal {
 
 #[derive(Clone, Debug, Default)]
 pub struct LintWithoutLintPass {
-    declared_lints: FxHashMap<Name, Span>,
-    registered_lints: FxHashSet<Name>,
+    declared_lints: FxHashMap<Symbol, Span>,
+    registered_lints: FxHashSet<Symbol>,
 }
 
 impl_lint_pass!(LintWithoutLintPass => [DEFAULT_LINT, LINT_WITHOUT_LINT_PASS]);
@@ -357,7 +357,7 @@ fn is_lint_ref_type<'tcx>(cx: &LateContext<'_, 'tcx>, ty: &Ty<'_>) -> bool {
 }
 
 struct LintCollector<'a, 'tcx> {
-    output: &'a mut FxHashSet<Name>,
+    output: &'a mut FxHashSet<Symbol>,
     cx: &'a LateContext<'a, 'tcx>,
 }
 
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index 1c7b40fa908..3b8ef18bfab 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -1077,7 +1077,7 @@ pub fn is_allowed(cx: &LateContext<'_, '_>, lint: &'static Lint, id: HirId) -> b
     cx.tcx.lint_level_at_node(lint, id).0 == Level::Allow
 }
 
-pub fn get_arg_name(pat: &Pat<'_>) -> Option<ast::Name> {
+pub fn get_arg_name(pat: &Pat<'_>) -> Option<Name> {
     match pat.kind {
         PatKind::Binding(.., ident, None) => Some(ident.name),
         PatKind::Ref(ref subpat, _) => get_arg_name(subpat),
diff --git a/clippy_lints/src/utils/ptr.rs b/clippy_lints/src/utils/ptr.rs
index 240bf2449cb..fb6bd5e8158 100644
--- a/clippy_lints/src/utils/ptr.rs
+++ b/clippy_lints/src/utils/ptr.rs
@@ -1,10 +1,9 @@
 use crate::utils::{get_pat_name, match_var, snippet};
-use rustc_ast::ast::Name;
 use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
 use rustc_hir::{Body, BodyId, Expr, ExprKind, Param};
 use rustc_lint::LateContext;
 use rustc_middle::hir::map::Map;
-use rustc_span::source_map::Span;
+use rustc_span::{Span, Symbol};
 use std::borrow::Cow;
 
 pub fn get_spans(
@@ -25,7 +24,7 @@ pub fn get_spans(
 
 fn extract_clone_suggestions<'a, 'tcx>(
     cx: &LateContext<'a, 'tcx>,
-    name: Name,
+    name: Symbol,
     replace: &[(&'static str, &'static str)],
     body: &'tcx Body<'_>,
 ) -> Option<Vec<(Span, Cow<'static, str>)>> {
@@ -46,7 +45,7 @@ fn extract_clone_suggestions<'a, 'tcx>(
 
 struct PtrCloneVisitor<'a, 'tcx> {
     cx: &'a LateContext<'a, 'tcx>,
-    name: Name,
+    name: Symbol,
     replace: &'a [(&'static str, &'static str)],
     spans: Vec<(Span, Cow<'static, str>)>,
     abort: bool,
@@ -83,6 +82,6 @@ impl<'a, 'tcx> Visitor<'tcx> for PtrCloneVisitor<'a, 'tcx> {
     }
 }
 
-fn get_binding_name(arg: &Param<'_>) -> Option<Name> {
+fn get_binding_name(arg: &Param<'_>) -> Option<Symbol> {
     get_pat_name(&arg.pat)
 }
diff --git a/clippy_lints/src/utils/usage.rs b/clippy_lints/src/utils/usage.rs
index c14da6aacea..e8535677987 100644
--- a/clippy_lints/src/utils/usage.rs
+++ b/clippy_lints/src/utils/usage.rs
@@ -1,5 +1,4 @@
 use crate::utils::match_var;
-use rustc_ast::ast;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_hir::def::Res;
 use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
@@ -8,7 +7,7 @@ use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::LateContext;
 use rustc_middle::hir::map::Map;
 use rustc_middle::ty;
-use rustc_span::symbol::Ident;
+use rustc_span::symbol::{Ident, Symbol};
 use rustc_typeck::expr_use_visitor::{ConsumeMode, Delegate, ExprUseVisitor, Place, PlaceBase};
 
 /// Returns a set of mutated local variable IDs, or `None` if mutations could not be determined.
@@ -78,7 +77,7 @@ impl<'tcx> Delegate<'tcx> for MutVarsDelegate {
 }
 
 pub struct UsedVisitor {
-    pub var: ast::Name, // var to look for
+    pub var: Symbol,    // var to look for
     pub used: bool,     // has the var been used otherwise?
 }
 
-- 
cgit 1.4.1-3-g733a5


From 505280b108f777ae941d4056a87f77fb7f513a7e Mon Sep 17 00:00:00 2001
From: flip1995 <hello@philkrones.com>
Date: Mon, 11 May 2020 21:31:01 +0200
Subject: Run cargo dev fmt

---
 clippy_lints/src/bytecount.rs   | 2 +-
 clippy_lints/src/map_clone.rs   | 2 +-
 clippy_lints/src/utils/usage.rs | 4 ++--
 3 files changed, 4 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/bytecount.rs b/clippy_lints/src/bytecount.rs
index 278d043732f..90c00ad098f 100644
--- a/clippy_lints/src/bytecount.rs
+++ b/clippy_lints/src/bytecount.rs
@@ -3,7 +3,7 @@ use crate::utils::{
     span_lint_and_sugg, walk_ptrs_ty,
 };
 use if_chain::if_chain;
-use rustc_ast::ast::{UintTy};
+use rustc_ast::ast::UintTy;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, BorrowKind, Expr, ExprKind, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/map_clone.rs b/clippy_lints/src/map_clone.rs
index 0163b3f8dbc..d5adf6b0f0d 100644
--- a/clippy_lints/src/map_clone.rs
+++ b/clippy_lints/src/map_clone.rs
@@ -9,8 +9,8 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::mir::Mutability;
 use rustc_middle::ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::Span;
 use rustc_span::symbol::Ident;
+use rustc_span::Span;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for usage of `iterator.map(|x| x.clone())` and suggests
diff --git a/clippy_lints/src/utils/usage.rs b/clippy_lints/src/utils/usage.rs
index e8535677987..904d948ad29 100644
--- a/clippy_lints/src/utils/usage.rs
+++ b/clippy_lints/src/utils/usage.rs
@@ -77,8 +77,8 @@ impl<'tcx> Delegate<'tcx> for MutVarsDelegate {
 }
 
 pub struct UsedVisitor {
-    pub var: Symbol,    // var to look for
-    pub used: bool,     // has the var been used otherwise?
+    pub var: Symbol, // var to look for
+    pub used: bool,  // has the var been used otherwise?
 }
 
 impl<'tcx> Visitor<'tcx> for UsedVisitor {
-- 
cgit 1.4.1-3-g733a5


From f20b96277397db2c9021d06cf8647014ccdc0a39 Mon Sep 17 00:00:00 2001
From: Eduardo Broto <ebroto@tutanota.com>
Date: Wed, 13 May 2020 01:04:16 +0200
Subject: unused_unit: lint also in type parameters and where clauses

---
 clippy_lints/src/returns.rs | 64 +++++++++++++++++++++++++-------------
 tests/ui/unused_unit.fixed  | 21 ++++++++++---
 tests/ui/unused_unit.rs     | 18 +++++++++--
 tests/ui/unused_unit.stderr | 76 ++++++++++++++++++++++++++++++++++++++-------
 4 files changed, 138 insertions(+), 41 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
index 5c9117d5b81..35464f629c3 100644
--- a/clippy_lints/src/returns.rs
+++ b/clippy_lints/src/returns.rs
@@ -248,28 +248,7 @@ impl EarlyLintPass for Return {
             if let ast::TyKind::Tup(ref vals) = ty.kind;
             if vals.is_empty() && !ty.span.from_expansion() && get_def(span) == get_def(ty.span);
             then {
-                let (rspan, appl) = if let Ok(fn_source) =
-                        cx.sess().source_map()
-                                 .span_to_snippet(span.with_hi(ty.span.hi())) {
-                    if let Some(rpos) = fn_source.rfind("->") {
-                        #[allow(clippy::cast_possible_truncation)]
-                        (ty.span.with_lo(BytePos(span.lo().0 + rpos as u32)),
-                            Applicability::MachineApplicable)
-                    } else {
-                        (ty.span, Applicability::MaybeIncorrect)
-                    }
-                } else {
-                    (ty.span, Applicability::MaybeIncorrect)
-                };
-                span_lint_and_sugg(
-                    cx,
-                    UNUSED_UNIT,
-                    rspan,
-                    "unneeded unit return type",
-                    "remove the `-> ()`",
-                    String::new(),
-                    appl,
-                );
+                lint_unneeded_unit_return(cx, ty, span);
             }
         }
     }
@@ -313,6 +292,22 @@ impl EarlyLintPass for Return {
             _ => (),
         }
     }
+
+    fn check_poly_trait_ref(&mut self, cx: &EarlyContext<'_>, poly: &ast::PolyTraitRef, _: &ast::TraitBoundModifier) {
+        let segments = &poly.trait_ref.path.segments;
+
+        if_chain! {
+            if segments.len() == 1;
+            if ["Fn", "FnMut", "FnOnce"].contains(&&*segments[0].ident.name.as_str());
+            if let Some(args) = &segments[0].args;
+            if let ast::GenericArgs::Parenthesized(generic_args) = &**args;
+            if let ast::FnRetTy::Ty(ty) = &generic_args.output;
+            if ty.kind.is_unit();
+            then {
+                lint_unneeded_unit_return(cx, ty, generic_args.span);
+            }
+        }
+    }
 }
 
 fn attr_is_cfg(attr: &ast::Attribute) -> bool {
@@ -337,3 +332,28 @@ fn is_unit_expr(expr: &ast::Expr) -> bool {
         false
     }
 }
+
+fn lint_unneeded_unit_return(cx: &EarlyContext<'_>, ty: &ast::Ty, span: Span) {
+    let (ret_span, appl) = if let Ok(fn_source) = cx.sess().source_map().span_to_snippet(span.with_hi(ty.span.hi())) {
+        if let Some(rpos) = fn_source.rfind("->") {
+            #[allow(clippy::cast_possible_truncation)]
+            (
+                ty.span.with_lo(BytePos(span.lo().0 + rpos as u32)),
+                Applicability::MachineApplicable,
+            )
+        } else {
+            (ty.span, Applicability::MaybeIncorrect)
+        }
+    } else {
+        (ty.span, Applicability::MaybeIncorrect)
+    };
+    span_lint_and_sugg(
+        cx,
+        UNUSED_UNIT,
+        ret_span,
+        "unneeded unit return type",
+        "remove the `-> ()`",
+        String::new(),
+        appl,
+    );
+}
diff --git a/tests/ui/unused_unit.fixed b/tests/ui/unused_unit.fixed
index 3f63624720f..07f2791786d 100644
--- a/tests/ui/unused_unit.fixed
+++ b/tests/ui/unused_unit.fixed
@@ -14,11 +14,10 @@
 
 struct Unitter;
 impl Unitter {
-    // try to disorient the lint with multiple unit returns and newlines
     #[allow(clippy::no_effect)]
-    pub fn get_unit<F: Fn() -> (), G>(&self, f: F, _g: G) 
-    where G: Fn() -> () {
-        let _y: &dyn Fn() -> () = &f;
+    pub fn get_unit<F: Fn() , G>(&self, f: F, _g: G) 
+    where G: Fn()  {
+        let _y: &dyn Fn()  = &f;
         (); // this should not lint, as it's not in return type position
     }
 }
@@ -30,6 +29,20 @@ impl Into<()> for Unitter {
     }
 }
 
+trait Trait {
+    fn redundant<F: FnOnce() , G, H>(&self, _f: F, _g: G, _h: H)
+    where
+        G: FnMut() ,
+        H: Fn() ;
+}
+
+impl Trait for Unitter {
+    fn redundant<F: FnOnce() , G, H>(&self, _f: F, _g: G, _h: H)
+    where
+        G: FnMut() ,
+        H: Fn()  {}
+}
+
 fn return_unit()  {  }
 
 #[allow(clippy::needless_return)]
diff --git a/tests/ui/unused_unit.rs b/tests/ui/unused_unit.rs
index 8fc072ebd69..e2c6afb020f 100644
--- a/tests/ui/unused_unit.rs
+++ b/tests/ui/unused_unit.rs
@@ -14,10 +14,8 @@
 
 struct Unitter;
 impl Unitter {
-    // try to disorient the lint with multiple unit returns and newlines
     #[allow(clippy::no_effect)]
-    pub fn get_unit<F: Fn() -> (), G>(&self, f: F, _g: G) ->
-        ()
+    pub fn get_unit<F: Fn() -> (), G>(&self, f: F, _g: G) -> ()
     where G: Fn() -> () {
         let _y: &dyn Fn() -> () = &f;
         (); // this should not lint, as it's not in return type position
@@ -31,6 +29,20 @@ impl Into<()> for Unitter {
     }
 }
 
+trait Trait {
+    fn redundant<F: FnOnce() -> (), G, H>(&self, _f: F, _g: G, _h: H)
+    where
+        G: FnMut() -> (),
+        H: Fn() -> ();
+}
+
+impl Trait for Unitter {
+    fn redundant<F: FnOnce() -> (), G, H>(&self, _f: F, _g: G, _h: H)
+    where
+        G: FnMut() -> (),
+        H: Fn() -> () {}
+}
+
 fn return_unit() -> () { () }
 
 #[allow(clippy::needless_return)]
diff --git a/tests/ui/unused_unit.stderr b/tests/ui/unused_unit.stderr
index a013d2b3495..81e6738e6bf 100644
--- a/tests/ui/unused_unit.stderr
+++ b/tests/ui/unused_unit.stderr
@@ -1,10 +1,8 @@
 error: unneeded unit return type
-  --> $DIR/unused_unit.rs:19:59
+  --> $DIR/unused_unit.rs:18:29
    |
-LL |       pub fn get_unit<F: Fn() -> (), G>(&self, f: F, _g: G) ->
-   |  ___________________________________________________________^
-LL | |         ()
-   | |__________^ help: remove the `-> ()`
+LL |     pub fn get_unit<F: Fn() -> (), G>(&self, f: F, _g: G) -> ()
+   |                             ^^^^^ help: remove the `-> ()`
    |
 note: the lint level is defined here
   --> $DIR/unused_unit.rs:12:9
@@ -13,40 +11,94 @@ LL | #![deny(clippy::unused_unit)]
    |         ^^^^^^^^^^^^^^^^^^^
 
 error: unneeded unit return type
-  --> $DIR/unused_unit.rs:29:19
+  --> $DIR/unused_unit.rs:19:19
+   |
+LL |     where G: Fn() -> () {
+   |                   ^^^^^ help: remove the `-> ()`
+
+error: unneeded unit return type
+  --> $DIR/unused_unit.rs:18:59
+   |
+LL |     pub fn get_unit<F: Fn() -> (), G>(&self, f: F, _g: G) -> ()
+   |                                                           ^^^^^ help: remove the `-> ()`
+
+error: unneeded unit return type
+  --> $DIR/unused_unit.rs:20:27
+   |
+LL |         let _y: &dyn Fn() -> () = &f;
+   |                           ^^^^^ help: remove the `-> ()`
+
+error: unneeded unit return type
+  --> $DIR/unused_unit.rs:27:19
    |
 LL |     fn into(self) -> () {
    |                   ^^^^^ help: remove the `-> ()`
 
 error: unneeded unit expression
-  --> $DIR/unused_unit.rs:30:9
+  --> $DIR/unused_unit.rs:28:9
    |
 LL |         ()
    |         ^^ help: remove the final `()`
 
 error: unneeded unit return type
-  --> $DIR/unused_unit.rs:34:18
+  --> $DIR/unused_unit.rs:33:30
+   |
+LL |     fn redundant<F: FnOnce() -> (), G, H>(&self, _f: F, _g: G, _h: H)
+   |                              ^^^^^ help: remove the `-> ()`
+
+error: unneeded unit return type
+  --> $DIR/unused_unit.rs:35:20
+   |
+LL |         G: FnMut() -> (),
+   |                    ^^^^^ help: remove the `-> ()`
+
+error: unneeded unit return type
+  --> $DIR/unused_unit.rs:36:17
+   |
+LL |         H: Fn() -> ();
+   |                 ^^^^^ help: remove the `-> ()`
+
+error: unneeded unit return type
+  --> $DIR/unused_unit.rs:40:30
+   |
+LL |     fn redundant<F: FnOnce() -> (), G, H>(&self, _f: F, _g: G, _h: H)
+   |                              ^^^^^ help: remove the `-> ()`
+
+error: unneeded unit return type
+  --> $DIR/unused_unit.rs:42:20
+   |
+LL |         G: FnMut() -> (),
+   |                    ^^^^^ help: remove the `-> ()`
+
+error: unneeded unit return type
+  --> $DIR/unused_unit.rs:43:17
+   |
+LL |         H: Fn() -> () {}
+   |                 ^^^^^ help: remove the `-> ()`
+
+error: unneeded unit return type
+  --> $DIR/unused_unit.rs:46:18
    |
 LL | fn return_unit() -> () { () }
    |                  ^^^^^ help: remove the `-> ()`
 
 error: unneeded unit expression
-  --> $DIR/unused_unit.rs:34:26
+  --> $DIR/unused_unit.rs:46:26
    |
 LL | fn return_unit() -> () { () }
    |                          ^^ help: remove the final `()`
 
 error: unneeded `()`
-  --> $DIR/unused_unit.rs:44:14
+  --> $DIR/unused_unit.rs:56:14
    |
 LL |         break();
    |              ^^ help: remove the `()`
 
 error: unneeded `()`
-  --> $DIR/unused_unit.rs:46:11
+  --> $DIR/unused_unit.rs:58:11
    |
 LL |     return();
    |           ^^ help: remove the `()`
 
-error: aborting due to 7 previous errors
+error: aborting due to 16 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 8ffa0bfaa2452eb9c80bf0f1909b039efc8dd0c3 Mon Sep 17 00:00:00 2001
From: Eduardo Broto <ebroto@tutanota.com>
Date: Mon, 11 May 2020 00:52:33 +0200
Subject: New lint: reversed_empty_ranges

---
 CHANGELOG.md                                    |   1 +
 clippy_lints/src/lib.rs                         |   3 +
 clippy_lints/src/ranges.rs                      | 112 +++++++++++++++++++++++-
 tests/ui/reversed_empty_ranges_fixable.fixed    |  24 +++++
 tests/ui/reversed_empty_ranges_fixable.rs       |  24 +++++
 tests/ui/reversed_empty_ranges_fixable.stderr   |  47 ++++++++++
 tests/ui/reversed_empty_ranges_unfixable.rs     |  15 ++++
 tests/ui/reversed_empty_ranges_unfixable.stderr |  34 +++++++
 8 files changed, 258 insertions(+), 2 deletions(-)
 create mode 100644 tests/ui/reversed_empty_ranges_fixable.fixed
 create mode 100644 tests/ui/reversed_empty_ranges_fixable.rs
 create mode 100644 tests/ui/reversed_empty_ranges_fixable.stderr
 create mode 100644 tests/ui/reversed_empty_ranges_unfixable.rs
 create mode 100644 tests/ui/reversed_empty_ranges_unfixable.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 8457d6ad05c..33b277fbd31 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1546,6 +1546,7 @@ Released 2018-09-13
 [`result_map_unwrap_or_else`]: https://rust-lang.github.io/rust-clippy/master/index.html#result_map_unwrap_or_else
 [`result_unwrap_used`]: https://rust-lang.github.io/rust-clippy/master/index.html#result_unwrap_used
 [`reverse_range_loop`]: https://rust-lang.github.io/rust-clippy/master/index.html#reverse_range_loop
+[`reversed_empty_ranges`]: https://rust-lang.github.io/rust-clippy/master/index.html#reversed_empty_ranges
 [`same_functions_in_if_condition`]: https://rust-lang.github.io/rust-clippy/master/index.html#same_functions_in_if_condition
 [`search_is_some`]: https://rust-lang.github.io/rust-clippy/master/index.html#search_is_some
 [`serde_api_misuse`]: https://rust-lang.github.io/rust-clippy/master/index.html#serde_api_misuse
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 51b5401da7d..e1cb10a4651 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -770,6 +770,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &ranges::RANGE_MINUS_ONE,
         &ranges::RANGE_PLUS_ONE,
         &ranges::RANGE_ZIP_WITH_LEN,
+        &ranges::REVERSED_EMPTY_RANGES,
         &redundant_clone::REDUNDANT_CLONE,
         &redundant_field_names::REDUNDANT_FIELD_NAMES,
         &redundant_pattern_matching::REDUNDANT_PATTERN_MATCHING,
@@ -1384,6 +1385,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&question_mark::QUESTION_MARK),
         LintId::of(&ranges::RANGE_MINUS_ONE),
         LintId::of(&ranges::RANGE_ZIP_WITH_LEN),
+        LintId::of(&ranges::REVERSED_EMPTY_RANGES),
         LintId::of(&redundant_clone::REDUNDANT_CLONE),
         LintId::of(&redundant_field_names::REDUNDANT_FIELD_NAMES),
         LintId::of(&redundant_pattern_matching::REDUNDANT_PATTERN_MATCHING),
@@ -1675,6 +1677,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&open_options::NONSENSICAL_OPEN_OPTIONS),
         LintId::of(&option_env_unwrap::OPTION_ENV_UNWRAP),
         LintId::of(&ptr::MUT_FROM_REF),
+        LintId::of(&ranges::REVERSED_EMPTY_RANGES),
         LintId::of(&regex::INVALID_REGEX),
         LintId::of(&serde_api::SERDE_API_MISUSE),
         LintId::of(&suspicious_trait_impl::SUSPICIOUS_ARITHMETIC_IMPL),
diff --git a/clippy_lints/src/ranges.rs b/clippy_lints/src/ranges.rs
index d7ce2e66d69..86d55ccabb6 100644
--- a/clippy_lints/src/ranges.rs
+++ b/clippy_lints/src/ranges.rs
@@ -1,14 +1,17 @@
+use crate::consts::{constant, Constant};
 use if_chain::if_chain;
 use rustc_ast::ast::RangeLimits;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind, QPath};
 use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Spanned;
+use std::cmp::Ordering;
 
 use crate::utils::sugg::Sugg;
+use crate::utils::{get_parent_expr, is_integer_const, snippet, snippet_opt, span_lint, span_lint_and_then};
 use crate::utils::{higher, SpanlessEq};
-use crate::utils::{is_integer_const, snippet, snippet_opt, span_lint, span_lint_and_then};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for zipping a collection with the range of
@@ -84,10 +87,44 @@ declare_clippy_lint! {
     "`x..=(y-1)` reads better as `x..y`"
 }
 
+declare_clippy_lint! {
+    /// **What it does:** Checks for range expressions `x..y` where both `x` and `y`
+    /// are constant and `x` is greater or equal to `y`.
+    ///
+    /// **Why is this bad?** Empty ranges yield no values so iterating them is a no-op.
+    /// Moreover, trying to use a reversed range to index a slice will panic at run-time.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// fn main() {
+    ///     (10..=0).for_each(|x| println!("{}", x));
+    ///
+    ///     let arr = [1, 2, 3, 4, 5];
+    ///     let sub = &arr[3..1];
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// fn main() {
+    ///     (0..=10).rev().for_each(|x| println!("{}", x));
+    ///
+    ///     let arr = [1, 2, 3, 4, 5];
+    ///     let sub = &arr[1..3];
+    /// }
+    /// ```
+    pub REVERSED_EMPTY_RANGES,
+    correctness,
+    "reversing the limits of range expressions, resulting in empty ranges"
+}
+
 declare_lint_pass!(Ranges => [
     RANGE_ZIP_WITH_LEN,
     RANGE_PLUS_ONE,
-    RANGE_MINUS_ONE
+    RANGE_MINUS_ONE,
+    REVERSED_EMPTY_RANGES,
 ]);
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Ranges {
@@ -124,6 +161,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Ranges {
 
         check_exclusive_range_plus_one(cx, expr);
         check_inclusive_range_minus_one(cx, expr);
+        check_reversed_empty_range(cx, expr);
     }
 }
 
@@ -202,6 +240,76 @@ fn check_inclusive_range_minus_one(cx: &LateContext<'_, '_>, expr: &Expr<'_>) {
     }
 }
 
+fn check_reversed_empty_range(cx: &LateContext<'_, '_>, expr: &Expr<'_>) {
+    fn inside_indexing_expr(cx: &LateContext<'_, '_>, expr: &Expr<'_>) -> bool {
+        matches!(
+            get_parent_expr(cx, expr),
+            Some(Expr {
+                kind: ExprKind::Index(..),
+                ..
+            })
+        )
+    }
+
+    fn is_empty_range(limits: RangeLimits, ordering: Ordering) -> bool {
+        match limits {
+            RangeLimits::HalfOpen => ordering != Ordering::Less,
+            RangeLimits::Closed => ordering == Ordering::Greater,
+        }
+    }
+
+    if_chain! {
+        if let Some(higher::Range { start: Some(start), end: Some(end), limits }) = higher::range(cx, expr);
+        let ty = cx.tables.expr_ty(start);
+        if let ty::Int(_) | ty::Uint(_) = ty.kind;
+        if let Some((start_idx, _)) = constant(cx, cx.tables, start);
+        if let Some((end_idx, _)) = constant(cx, cx.tables, end);
+        if let Some(ordering) = Constant::partial_cmp(cx.tcx, ty, &start_idx, &end_idx);
+        if is_empty_range(limits, ordering);
+        then {
+            if inside_indexing_expr(cx, expr) {
+                let (reason, outcome) = if ordering == Ordering::Equal {
+                    ("empty", "always yield an empty slice")
+                } else {
+                    ("reversed", "panic at run-time")
+                };
+
+                span_lint(
+                    cx,
+                    REVERSED_EMPTY_RANGES,
+                    expr.span,
+                    &format!("this range is {} and using it to index a slice will {}", reason, outcome),
+                );
+            } else {
+                span_lint_and_then(
+                    cx,
+                    REVERSED_EMPTY_RANGES,
+                    expr.span,
+                    "this range is empty so it will yield no values",
+                    |diag| {
+                        if ordering != Ordering::Equal {
+                            let start_snippet = snippet(cx, start.span, "_");
+                            let end_snippet = snippet(cx, end.span, "_");
+                            let dots = match limits {
+                                RangeLimits::HalfOpen => "..",
+                                RangeLimits::Closed => "..="
+                            };
+
+                            diag.span_suggestion(
+                                expr.span,
+                                "consider using the following if you are attempting to iterate over this \
+                                 range in reverse",
+                                format!("({}{}{}).rev()", end_snippet, dots, start_snippet),
+                                Applicability::MaybeIncorrect,
+                            );
+                        }
+                    },
+                );
+            }
+        }
+    }
+}
+
 fn y_plus_one<'t>(cx: &LateContext<'_, '_>, expr: &'t Expr<'_>) -> Option<&'t Expr<'t>> {
     match expr.kind {
         ExprKind::Binary(
diff --git a/tests/ui/reversed_empty_ranges_fixable.fixed b/tests/ui/reversed_empty_ranges_fixable.fixed
new file mode 100644
index 00000000000..ee2cbc3cf54
--- /dev/null
+++ b/tests/ui/reversed_empty_ranges_fixable.fixed
@@ -0,0 +1,24 @@
+// run-rustfix
+#![warn(clippy::reversed_empty_ranges)]
+
+const ANSWER: i32 = 42;
+
+fn main() {
+    (21..=42).rev().for_each(|x| println!("{}", x));
+    let _ = (21..ANSWER).rev().filter(|x| x % 2 == 0).take(10).collect::<Vec<_>>();
+
+    for _ in (-42..=-21).rev() {}
+    for _ in (21u32..42u32).rev() {}
+
+    // These should be ignored as they are not empty ranges:
+
+    (21..=42).for_each(|x| println!("{}", x));
+    (21..42).for_each(|x| println!("{}", x));
+
+    let arr = [1, 2, 3, 4, 5];
+    let _ = &arr[1..=3];
+    let _ = &arr[1..3];
+
+    for _ in 21..=42 {}
+    for _ in 21..42 {}
+}
diff --git a/tests/ui/reversed_empty_ranges_fixable.rs b/tests/ui/reversed_empty_ranges_fixable.rs
new file mode 100644
index 00000000000..6ed5ca6daa0
--- /dev/null
+++ b/tests/ui/reversed_empty_ranges_fixable.rs
@@ -0,0 +1,24 @@
+// run-rustfix
+#![warn(clippy::reversed_empty_ranges)]
+
+const ANSWER: i32 = 42;
+
+fn main() {
+    (42..=21).for_each(|x| println!("{}", x));
+    let _ = (ANSWER..21).filter(|x| x % 2 == 0).take(10).collect::<Vec<_>>();
+
+    for _ in -21..=-42 {}
+    for _ in 42u32..21u32 {}
+
+    // These should be ignored as they are not empty ranges:
+
+    (21..=42).for_each(|x| println!("{}", x));
+    (21..42).for_each(|x| println!("{}", x));
+
+    let arr = [1, 2, 3, 4, 5];
+    let _ = &arr[1..=3];
+    let _ = &arr[1..3];
+
+    for _ in 21..=42 {}
+    for _ in 21..42 {}
+}
diff --git a/tests/ui/reversed_empty_ranges_fixable.stderr b/tests/ui/reversed_empty_ranges_fixable.stderr
new file mode 100644
index 00000000000..97933b8ff85
--- /dev/null
+++ b/tests/ui/reversed_empty_ranges_fixable.stderr
@@ -0,0 +1,47 @@
+error: this range is empty so it will yield no values
+  --> $DIR/reversed_empty_ranges_fixable.rs:7:5
+   |
+LL |     (42..=21).for_each(|x| println!("{}", x));
+   |     ^^^^^^^^^
+   |
+   = note: `-D clippy::reversed-empty-ranges` implied by `-D warnings`
+help: consider using the following if you are attempting to iterate over this range in reverse
+   |
+LL |     (21..=42).rev().for_each(|x| println!("{}", x));
+   |     ^^^^^^^^^^^^^^^
+
+error: this range is empty so it will yield no values
+  --> $DIR/reversed_empty_ranges_fixable.rs:8:13
+   |
+LL |     let _ = (ANSWER..21).filter(|x| x % 2 == 0).take(10).collect::<Vec<_>>();
+   |             ^^^^^^^^^^^^
+   |
+help: consider using the following if you are attempting to iterate over this range in reverse
+   |
+LL |     let _ = (21..ANSWER).rev().filter(|x| x % 2 == 0).take(10).collect::<Vec<_>>();
+   |             ^^^^^^^^^^^^^^^^^^
+
+error: this range is empty so it will yield no values
+  --> $DIR/reversed_empty_ranges_fixable.rs:10:14
+   |
+LL |     for _ in -21..=-42 {}
+   |              ^^^^^^^^^
+   |
+help: consider using the following if you are attempting to iterate over this range in reverse
+   |
+LL |     for _ in (-42..=-21).rev() {}
+   |              ^^^^^^^^^^^^^^^^^
+
+error: this range is empty so it will yield no values
+  --> $DIR/reversed_empty_ranges_fixable.rs:11:14
+   |
+LL |     for _ in 42u32..21u32 {}
+   |              ^^^^^^^^^^^^
+   |
+help: consider using the following if you are attempting to iterate over this range in reverse
+   |
+LL |     for _ in (21u32..42u32).rev() {}
+   |              ^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 4 previous errors
+
diff --git a/tests/ui/reversed_empty_ranges_unfixable.rs b/tests/ui/reversed_empty_ranges_unfixable.rs
new file mode 100644
index 00000000000..c9ca4c47668
--- /dev/null
+++ b/tests/ui/reversed_empty_ranges_unfixable.rs
@@ -0,0 +1,15 @@
+#![warn(clippy::reversed_empty_ranges)]
+
+const ANSWER: i32 = 42;
+const SOME_NUM: usize = 3;
+
+fn main() {
+    let _ = (42 + 10..42 + 10).map(|x| x / 2).find(|&x| x == 21);
+
+    let arr = [1, 2, 3, 4, 5];
+    let _ = &arr[3usize..=1usize];
+    let _ = &arr[SOME_NUM..1];
+    let _ = &arr[3..3];
+
+    for _ in ANSWER..ANSWER {}
+}
diff --git a/tests/ui/reversed_empty_ranges_unfixable.stderr b/tests/ui/reversed_empty_ranges_unfixable.stderr
new file mode 100644
index 00000000000..12e5483ecdf
--- /dev/null
+++ b/tests/ui/reversed_empty_ranges_unfixable.stderr
@@ -0,0 +1,34 @@
+error: this range is empty so it will yield no values
+  --> $DIR/reversed_empty_ranges_unfixable.rs:7:13
+   |
+LL |     let _ = (42 + 10..42 + 10).map(|x| x / 2).find(|&x| x == 21);
+   |             ^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::reversed-empty-ranges` implied by `-D warnings`
+
+error: this range is reversed and using it to index a slice will panic at run-time
+  --> $DIR/reversed_empty_ranges_unfixable.rs:10:18
+   |
+LL |     let _ = &arr[3usize..=1usize];
+   |                  ^^^^^^^^^^^^^^^
+
+error: this range is reversed and using it to index a slice will panic at run-time
+  --> $DIR/reversed_empty_ranges_unfixable.rs:11:18
+   |
+LL |     let _ = &arr[SOME_NUM..1];
+   |                  ^^^^^^^^^^^
+
+error: this range is empty and using it to index a slice will always yield an empty slice
+  --> $DIR/reversed_empty_ranges_unfixable.rs:12:18
+   |
+LL |     let _ = &arr[3..3];
+   |                  ^^^^
+
+error: this range is empty so it will yield no values
+  --> $DIR/reversed_empty_ranges_unfixable.rs:14:14
+   |
+LL |     for _ in ANSWER..ANSWER {}
+   |              ^^^^^^^^^^^^^^
+
+error: aborting due to 5 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 0f2b1193f9501ffd06f9bf2ea8ab85a4db92f47b Mon Sep 17 00:00:00 2001
From: Eduardo Broto <ebroto@tutanota.com>
Date: Mon, 11 May 2020 00:53:31 +0200
Subject: Remove reverse_range_loop lint

---
 CHANGELOG.md                       |   1 -
 clippy_lints/src/lib.rs            |   7 +--
 clippy_lints/src/loops.rs          | 102 +------------------------------------
 src/lintlist/mod.rs                |   6 +--
 tests/ui/for_loop_fixable.fixed    |  54 --------------------
 tests/ui/for_loop_fixable.rs       |  54 --------------------
 tests/ui/for_loop_fixable.stderr   |  88 ++++++--------------------------
 tests/ui/for_loop_unfixable.rs     |  18 -------
 tests/ui/for_loop_unfixable.stderr |  11 ++--
 tests/ui/manual_memcpy.rs          |   2 +-
 10 files changed, 32 insertions(+), 311 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 33b277fbd31..b25ef049356 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1545,7 +1545,6 @@ Released 2018-09-13
 [`result_map_unit_fn`]: https://rust-lang.github.io/rust-clippy/master/index.html#result_map_unit_fn
 [`result_map_unwrap_or_else`]: https://rust-lang.github.io/rust-clippy/master/index.html#result_map_unwrap_or_else
 [`result_unwrap_used`]: https://rust-lang.github.io/rust-clippy/master/index.html#result_unwrap_used
-[`reverse_range_loop`]: https://rust-lang.github.io/rust-clippy/master/index.html#reverse_range_loop
 [`reversed_empty_ranges`]: https://rust-lang.github.io/rust-clippy/master/index.html#reversed_empty_ranges
 [`same_functions_in_if_condition`]: https://rust-lang.github.io/rust-clippy/master/index.html#same_functions_in_if_condition
 [`search_is_some`]: https://rust-lang.github.io/rust-clippy/master/index.html#search_is_some
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index e1cb10a4651..0c4daeb731f 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -624,7 +624,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &loops::NEEDLESS_COLLECT,
         &loops::NEEDLESS_RANGE_LOOP,
         &loops::NEVER_LOOP,
-        &loops::REVERSE_RANGE_LOOP,
         &loops::WHILE_IMMUTABLE_CONDITION,
         &loops::WHILE_LET_LOOP,
         &loops::WHILE_LET_ON_ITERATOR,
@@ -1284,7 +1283,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&loops::NEEDLESS_COLLECT),
         LintId::of(&loops::NEEDLESS_RANGE_LOOP),
         LintId::of(&loops::NEVER_LOOP),
-        LintId::of(&loops::REVERSE_RANGE_LOOP),
         LintId::of(&loops::WHILE_IMMUTABLE_CONDITION),
         LintId::of(&loops::WHILE_LET_LOOP),
         LintId::of(&loops::WHILE_LET_ON_ITERATOR),
@@ -1658,7 +1656,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&loops::FOR_LOOP_OVER_RESULT),
         LintId::of(&loops::ITER_NEXT_LOOP),
         LintId::of(&loops::NEVER_LOOP),
-        LintId::of(&loops::REVERSE_RANGE_LOOP),
         LintId::of(&loops::WHILE_IMMUTABLE_CONDITION),
         LintId::of(&mem_discriminant::MEM_DISCRIMINANT_NON_ENUM),
         LintId::of(&mem_replace::MEM_REPLACE_WITH_UNINIT),
@@ -1788,6 +1785,10 @@ fn register_removed_non_tool_lints(store: &mut rustc_lint::LintStore) {
         "unsafe_vector_initialization",
         "the replacement suggested by this lint had substantially different behavior",
     );
+    store.register_removed(
+        "reverse_range_loop",
+        "this lint is now included in reversed_empty_ranges",
+    );
 }
 
 /// Register renamed lints.
diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 2bbf4dba614..0bc6b70855b 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -1,4 +1,4 @@
-use crate::consts::{constant, Constant};
+use crate::consts::constant;
 use crate::reexport::Name;
 use crate::utils::paths;
 use crate::utils::usage::{is_unused, mutated_variables};
@@ -8,7 +8,7 @@ use crate::utils::{
     multispan_sugg, snippet, snippet_opt, snippet_with_applicability, span_lint, span_lint_and_help,
     span_lint_and_sugg, span_lint_and_then, SpanlessEq,
 };
-use crate::utils::{is_type_diagnostic_item, qpath_res, same_tys, sext, sugg};
+use crate::utils::{is_type_diagnostic_item, qpath_res, same_tys, sugg};
 use if_chain::if_chain;
 use rustc_ast::ast;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
@@ -270,30 +270,6 @@ declare_clippy_lint! {
     "collecting an iterator when collect is not needed"
 }
 
-declare_clippy_lint! {
-    /// **What it does:** Checks for loops over ranges `x..y` where both `x` and `y`
-    /// are constant and `x` is greater or equal to `y`, unless the range is
-    /// reversed or has a negative `.step_by(_)`.
-    ///
-    /// **Why is it bad?** Such loops will either be skipped or loop until
-    /// wrap-around (in debug code, this may `panic!()`). Both options are probably
-    /// not intended.
-    ///
-    /// **Known problems:** The lint cannot catch loops over dynamically defined
-    /// ranges. Doing this would require simulating all possible inputs and code
-    /// paths through the program, which would be complex and error-prone.
-    ///
-    /// **Example:**
-    /// ```ignore
-    /// for x in 5..10 - 5 {
-    ///     ..
-    /// } // oops, stray `-`
-    /// ```
-    pub REVERSE_RANGE_LOOP,
-    correctness,
-    "iteration over an empty range, such as `10..0` or `5..5`"
-}
-
 declare_clippy_lint! {
     /// **What it does:** Checks `for` loops over slices with an explicit counter
     /// and suggests the use of `.enumerate()`.
@@ -463,7 +439,6 @@ declare_lint_pass!(Loops => [
     FOR_LOOP_OVER_OPTION,
     WHILE_LET_LOOP,
     NEEDLESS_COLLECT,
-    REVERSE_RANGE_LOOP,
     EXPLICIT_COUNTER_LOOP,
     EMPTY_LOOP,
     WHILE_LET_ON_ITERATOR,
@@ -761,7 +736,6 @@ fn check_for_loop<'a, 'tcx>(
     expr: &'tcx Expr<'_>,
 ) {
     check_for_loop_range(cx, pat, arg, body, expr);
-    check_for_loop_reverse_range(cx, arg, expr);
     check_for_loop_arg(cx, pat, arg, expr);
     check_for_loop_explicit_counter(cx, pat, arg, body, expr);
     check_for_loop_over_map_kv(cx, pat, arg, body, expr);
@@ -1248,78 +1222,6 @@ fn is_end_eq_array_len<'tcx>(
     false
 }
 
-fn check_for_loop_reverse_range<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, arg: &'tcx Expr<'_>, expr: &'tcx Expr<'_>) {
-    // if this for loop is iterating over a two-sided range...
-    if let Some(higher::Range {
-        start: Some(start),
-        end: Some(end),
-        limits,
-    }) = higher::range(cx, arg)
-    {
-        // ...and both sides are compile-time constant integers...
-        if let Some((start_idx, _)) = constant(cx, cx.tables, start) {
-            if let Some((end_idx, _)) = constant(cx, cx.tables, end) {
-                // ...and the start index is greater than the end index,
-                // this loop will never run. This is often confusing for developers
-                // who think that this will iterate from the larger value to the
-                // smaller value.
-                let ty = cx.tables.expr_ty(start);
-                let (sup, eq) = match (start_idx, end_idx) {
-                    (Constant::Int(start_idx), Constant::Int(end_idx)) => (
-                        match ty.kind {
-                            ty::Int(ity) => sext(cx.tcx, start_idx, ity) > sext(cx.tcx, end_idx, ity),
-                            ty::Uint(_) => start_idx > end_idx,
-                            _ => false,
-                        },
-                        start_idx == end_idx,
-                    ),
-                    _ => (false, false),
-                };
-
-                if sup {
-                    let start_snippet = snippet(cx, start.span, "_");
-                    let end_snippet = snippet(cx, end.span, "_");
-                    let dots = if limits == ast::RangeLimits::Closed {
-                        "..="
-                    } else {
-                        ".."
-                    };
-
-                    span_lint_and_then(
-                        cx,
-                        REVERSE_RANGE_LOOP,
-                        expr.span,
-                        "this range is empty so this for loop will never run",
-                        |diag| {
-                            diag.span_suggestion(
-                                arg.span,
-                                "consider using the following if you are attempting to iterate over this \
-                                 range in reverse",
-                                format!(
-                                    "({end}{dots}{start}).rev()",
-                                    end = end_snippet,
-                                    dots = dots,
-                                    start = start_snippet
-                                ),
-                                Applicability::MaybeIncorrect,
-                            );
-                        },
-                    );
-                } else if eq && limits != ast::RangeLimits::Closed {
-                    // if they are equal, it's also problematic - this loop
-                    // will never run.
-                    span_lint(
-                        cx,
-                        REVERSE_RANGE_LOOP,
-                        expr.span,
-                        "this range is empty so this for loop will never run",
-                    );
-                }
-            }
-        }
-    }
-}
-
 fn lint_iter_method(cx: &LateContext<'_, '_>, args: &[Expr<'_>], arg: &Expr<'_>, method_name: &str) {
     let mut applicability = Applicability::MachineApplicable;
     let object = snippet_with_applicability(cx, args[0].span, "_", &mut applicability);
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index 51d1cb2216a..e1a6d4bdd31 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -1922,11 +1922,11 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
         module: "methods",
     },
     Lint {
-        name: "reverse_range_loop",
+        name: "reversed_empty_ranges",
         group: "correctness",
-        desc: "iteration over an empty range, such as `10..0` or `5..5`",
+        desc: "reversing the limits of range expressions, resulting in empty ranges",
         deprecation: None,
-        module: "loops",
+        module: "ranges",
     },
     Lint {
         name: "same_functions_in_if_condition",
diff --git a/tests/ui/for_loop_fixable.fixed b/tests/ui/for_loop_fixable.fixed
index 5fc84ada9ef..249a88a0b39 100644
--- a/tests/ui/for_loop_fixable.fixed
+++ b/tests/ui/for_loop_fixable.fixed
@@ -21,7 +21,6 @@ impl Unrelated {
     clippy::explicit_iter_loop,
     clippy::explicit_into_iter_loop,
     clippy::iter_next_loop,
-    clippy::reverse_range_loop,
     clippy::for_kv_map
 )]
 #[allow(
@@ -32,61 +31,8 @@ impl Unrelated {
 )]
 #[allow(clippy::many_single_char_names, unused_variables)]
 fn main() {
-    const MAX_LEN: usize = 42;
     let mut vec = vec![1, 2, 3, 4];
 
-    for i in (0..10).rev() {
-        println!("{}", i);
-    }
-
-    for i in (0..=10).rev() {
-        println!("{}", i);
-    }
-
-    for i in (0..MAX_LEN).rev() {
-        println!("{}", i);
-    }
-
-    for i in 5..=5 {
-        // not an error, this is the range with only one element “5”
-        println!("{}", i);
-    }
-
-    for i in 0..10 {
-        // not an error, the start index is less than the end index
-        println!("{}", i);
-    }
-
-    for i in -10..0 {
-        // not an error
-        println!("{}", i);
-    }
-
-    for i in (10..0).map(|x| x * 2) {
-        // not an error, it can't be known what arbitrary methods do to a range
-        println!("{}", i);
-    }
-
-    // testing that the empty range lint folds constants
-    for i in (5 + 4..10).rev() {
-        println!("{}", i);
-    }
-
-    for i in ((3 - 1)..(5 + 2)).rev() {
-        println!("{}", i);
-    }
-
-    for i in (2 * 2)..(2 * 3) {
-        // no error, 4..6 is fine
-        println!("{}", i);
-    }
-
-    let x = 42;
-    for i in x..10 {
-        // no error, not constant-foldable
-        println!("{}", i);
-    }
-
     // See #601
     for i in 0..10 {
         // no error, id_col does not exist outside the loop
diff --git a/tests/ui/for_loop_fixable.rs b/tests/ui/for_loop_fixable.rs
index 4165b0dc004..306d85a6351 100644
--- a/tests/ui/for_loop_fixable.rs
+++ b/tests/ui/for_loop_fixable.rs
@@ -21,7 +21,6 @@ impl Unrelated {
     clippy::explicit_iter_loop,
     clippy::explicit_into_iter_loop,
     clippy::iter_next_loop,
-    clippy::reverse_range_loop,
     clippy::for_kv_map
 )]
 #[allow(
@@ -32,61 +31,8 @@ impl Unrelated {
 )]
 #[allow(clippy::many_single_char_names, unused_variables)]
 fn main() {
-    const MAX_LEN: usize = 42;
     let mut vec = vec![1, 2, 3, 4];
 
-    for i in 10..0 {
-        println!("{}", i);
-    }
-
-    for i in 10..=0 {
-        println!("{}", i);
-    }
-
-    for i in MAX_LEN..0 {
-        println!("{}", i);
-    }
-
-    for i in 5..=5 {
-        // not an error, this is the range with only one element “5”
-        println!("{}", i);
-    }
-
-    for i in 0..10 {
-        // not an error, the start index is less than the end index
-        println!("{}", i);
-    }
-
-    for i in -10..0 {
-        // not an error
-        println!("{}", i);
-    }
-
-    for i in (10..0).map(|x| x * 2) {
-        // not an error, it can't be known what arbitrary methods do to a range
-        println!("{}", i);
-    }
-
-    // testing that the empty range lint folds constants
-    for i in 10..5 + 4 {
-        println!("{}", i);
-    }
-
-    for i in (5 + 2)..(3 - 1) {
-        println!("{}", i);
-    }
-
-    for i in (2 * 2)..(2 * 3) {
-        // no error, 4..6 is fine
-        println!("{}", i);
-    }
-
-    let x = 42;
-    for i in x..10 {
-        // no error, not constant-foldable
-        println!("{}", i);
-    }
-
     // See #601
     for i in 0..10 {
         // no error, id_col does not exist outside the loop
diff --git a/tests/ui/for_loop_fixable.stderr b/tests/ui/for_loop_fixable.stderr
index cffb4b9f0a9..ddfe66d675f 100644
--- a/tests/ui/for_loop_fixable.stderr
+++ b/tests/ui/for_loop_fixable.stderr
@@ -1,61 +1,5 @@
-error: this range is empty so this for loop will never run
-  --> $DIR/for_loop_fixable.rs:38:14
-   |
-LL |     for i in 10..0 {
-   |              ^^^^^
-   |
-   = note: `-D clippy::reverse-range-loop` implied by `-D warnings`
-help: consider using the following if you are attempting to iterate over this range in reverse
-   |
-LL |     for i in (0..10).rev() {
-   |              ^^^^^^^^^^^^^
-
-error: this range is empty so this for loop will never run
-  --> $DIR/for_loop_fixable.rs:42:14
-   |
-LL |     for i in 10..=0 {
-   |              ^^^^^^
-   |
-help: consider using the following if you are attempting to iterate over this range in reverse
-   |
-LL |     for i in (0..=10).rev() {
-   |              ^^^^^^^^^^^^^^
-
-error: this range is empty so this for loop will never run
-  --> $DIR/for_loop_fixable.rs:46:14
-   |
-LL |     for i in MAX_LEN..0 {
-   |              ^^^^^^^^^^
-   |
-help: consider using the following if you are attempting to iterate over this range in reverse
-   |
-LL |     for i in (0..MAX_LEN).rev() {
-   |              ^^^^^^^^^^^^^^^^^^
-
-error: this range is empty so this for loop will never run
-  --> $DIR/for_loop_fixable.rs:71:14
-   |
-LL |     for i in 10..5 + 4 {
-   |              ^^^^^^^^^
-   |
-help: consider using the following if you are attempting to iterate over this range in reverse
-   |
-LL |     for i in (5 + 4..10).rev() {
-   |              ^^^^^^^^^^^^^^^^^
-
-error: this range is empty so this for loop will never run
-  --> $DIR/for_loop_fixable.rs:75:14
-   |
-LL |     for i in (5 + 2)..(3 - 1) {
-   |              ^^^^^^^^^^^^^^^^
-   |
-help: consider using the following if you are attempting to iterate over this range in reverse
-   |
-LL |     for i in ((3 - 1)..(5 + 2)).rev() {
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^
-
 error: it is more concise to loop over references to containers instead of using explicit iteration methods
-  --> $DIR/for_loop_fixable.rs:97:15
+  --> $DIR/for_loop_fixable.rs:43:15
    |
 LL |     for _v in vec.iter() {}
    |               ^^^^^^^^^^ help: to write this more concisely, try: `&vec`
@@ -63,13 +7,13 @@ LL |     for _v in vec.iter() {}
    = note: `-D clippy::explicit-iter-loop` implied by `-D warnings`
 
 error: it is more concise to loop over references to containers instead of using explicit iteration methods
-  --> $DIR/for_loop_fixable.rs:99:15
+  --> $DIR/for_loop_fixable.rs:45:15
    |
 LL |     for _v in vec.iter_mut() {}
    |               ^^^^^^^^^^^^^^ help: to write this more concisely, try: `&mut vec`
 
 error: it is more concise to loop over containers instead of using explicit iteration methods
-  --> $DIR/for_loop_fixable.rs:102:15
+  --> $DIR/for_loop_fixable.rs:48:15
    |
 LL |     for _v in out_vec.into_iter() {}
    |               ^^^^^^^^^^^^^^^^^^^ help: to write this more concisely, try: `out_vec`
@@ -77,76 +21,76 @@ LL |     for _v in out_vec.into_iter() {}
    = note: `-D clippy::explicit-into-iter-loop` implied by `-D warnings`
 
 error: it is more concise to loop over references to containers instead of using explicit iteration methods
-  --> $DIR/for_loop_fixable.rs:107:15
+  --> $DIR/for_loop_fixable.rs:53:15
    |
 LL |     for _v in [1, 2, 3].iter() {}
    |               ^^^^^^^^^^^^^^^^ help: to write this more concisely, try: `&[1, 2, 3]`
 
 error: it is more concise to loop over references to containers instead of using explicit iteration methods
-  --> $DIR/for_loop_fixable.rs:111:15
+  --> $DIR/for_loop_fixable.rs:57:15
    |
 LL |     for _v in [0; 32].iter() {}
    |               ^^^^^^^^^^^^^^ help: to write this more concisely, try: `&[0; 32]`
 
 error: it is more concise to loop over references to containers instead of using explicit iteration methods
-  --> $DIR/for_loop_fixable.rs:116:15
+  --> $DIR/for_loop_fixable.rs:62:15
    |
 LL |     for _v in ll.iter() {}
    |               ^^^^^^^^^ help: to write this more concisely, try: `&ll`
 
 error: it is more concise to loop over references to containers instead of using explicit iteration methods
-  --> $DIR/for_loop_fixable.rs:119:15
+  --> $DIR/for_loop_fixable.rs:65:15
    |
 LL |     for _v in vd.iter() {}
    |               ^^^^^^^^^ help: to write this more concisely, try: `&vd`
 
 error: it is more concise to loop over references to containers instead of using explicit iteration methods
-  --> $DIR/for_loop_fixable.rs:122:15
+  --> $DIR/for_loop_fixable.rs:68:15
    |
 LL |     for _v in bh.iter() {}
    |               ^^^^^^^^^ help: to write this more concisely, try: `&bh`
 
 error: it is more concise to loop over references to containers instead of using explicit iteration methods
-  --> $DIR/for_loop_fixable.rs:125:15
+  --> $DIR/for_loop_fixable.rs:71:15
    |
 LL |     for _v in hm.iter() {}
    |               ^^^^^^^^^ help: to write this more concisely, try: `&hm`
 
 error: it is more concise to loop over references to containers instead of using explicit iteration methods
-  --> $DIR/for_loop_fixable.rs:128:15
+  --> $DIR/for_loop_fixable.rs:74:15
    |
 LL |     for _v in bt.iter() {}
    |               ^^^^^^^^^ help: to write this more concisely, try: `&bt`
 
 error: it is more concise to loop over references to containers instead of using explicit iteration methods
-  --> $DIR/for_loop_fixable.rs:131:15
+  --> $DIR/for_loop_fixable.rs:77:15
    |
 LL |     for _v in hs.iter() {}
    |               ^^^^^^^^^ help: to write this more concisely, try: `&hs`
 
 error: it is more concise to loop over references to containers instead of using explicit iteration methods
-  --> $DIR/for_loop_fixable.rs:134:15
+  --> $DIR/for_loop_fixable.rs:80:15
    |
 LL |     for _v in bs.iter() {}
    |               ^^^^^^^^^ help: to write this more concisely, try: `&bs`
 
 error: it is more concise to loop over containers instead of using explicit iteration methods
-  --> $DIR/for_loop_fixable.rs:309:18
+  --> $DIR/for_loop_fixable.rs:255:18
    |
 LL |         for i in iterator.into_iter() {
    |                  ^^^^^^^^^^^^^^^^^^^^ help: to write this more concisely, try: `iterator`
 
 error: it is more concise to loop over references to containers instead of using explicit iteration methods
-  --> $DIR/for_loop_fixable.rs:329:18
+  --> $DIR/for_loop_fixable.rs:275:18
    |
 LL |         for _ in t.into_iter() {}
    |                  ^^^^^^^^^^^^^ help: to write this more concisely, try: `&t`
 
 error: it is more concise to loop over containers instead of using explicit iteration methods
-  --> $DIR/for_loop_fixable.rs:331:18
+  --> $DIR/for_loop_fixable.rs:277:18
    |
 LL |         for _ in r.into_iter() {}
    |                  ^^^^^^^^^^^^^ help: to write this more concisely, try: `r`
 
-error: aborting due to 20 previous errors
+error: aborting due to 15 previous errors
 
diff --git a/tests/ui/for_loop_unfixable.rs b/tests/ui/for_loop_unfixable.rs
index 179b255e08c..e73536052f0 100644
--- a/tests/ui/for_loop_unfixable.rs
+++ b/tests/ui/for_loop_unfixable.rs
@@ -5,7 +5,6 @@
     clippy::explicit_iter_loop,
     clippy::explicit_into_iter_loop,
     clippy::iter_next_loop,
-    clippy::reverse_range_loop,
     clippy::for_kv_map
 )]
 #[allow(
@@ -16,25 +15,8 @@
     unused,
     dead_code
 )]
-#[allow(clippy::many_single_char_names, unused_variables)]
 fn main() {
-    for i in 5..5 {
-        println!("{}", i);
-    }
-
     let vec = vec![1, 2, 3, 4];
 
     for _v in vec.iter().next() {}
-
-    for i in (5 + 2)..(8 - 1) {
-        println!("{}", i);
-    }
-
-    const ZERO: usize = 0;
-
-    for i in ZERO..vec.len() {
-        if f(&vec[i], &vec[i]) {
-            panic!("at the disco");
-        }
-    }
 }
diff --git a/tests/ui/for_loop_unfixable.stderr b/tests/ui/for_loop_unfixable.stderr
index 1da8e0f3588..1c9287b6acb 100644
--- a/tests/ui/for_loop_unfixable.stderr
+++ b/tests/ui/for_loop_unfixable.stderr
@@ -1,9 +1,10 @@
-error[E0425]: cannot find function `f` in this scope
-  --> $DIR/for_loop_unfixable.rs:36:12
+error: you are iterating over `Iterator::next()` which is an Option; this will compile but is probably not what you want
+  --> $DIR/for_loop_unfixable.rs:21:15
    |
-LL |         if f(&vec[i], &vec[i]) {
-   |            ^ help: a local variable with a similar name exists: `i`
+LL |     for _v in vec.iter().next() {}
+   |               ^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::iter-next-loop` implied by `-D warnings`
 
 error: aborting due to previous error
 
-For more information about this error, try `rustc --explain E0425`.
diff --git a/tests/ui/manual_memcpy.rs b/tests/ui/manual_memcpy.rs
index 9c24d6d4db1..0083f94798f 100644
--- a/tests/ui/manual_memcpy.rs
+++ b/tests/ui/manual_memcpy.rs
@@ -104,7 +104,7 @@ pub fn manual_copy(src: &[i32], dst: &mut [i32], dst2: &mut [i32]) {
         dst[i - 0] = src[i];
     }
 
-    #[allow(clippy::reverse_range_loop)]
+    #[allow(clippy::reversed_empty_ranges)]
     for i in 0..0 {
         dst[i] = src[i];
     }
-- 
cgit 1.4.1-3-g733a5


From e4cd8e7961b553cac44671d63bc6dfc2223ea66b Mon Sep 17 00:00:00 2001
From: Eduardo Broto <ebroto@tutanota.com>
Date: Tue, 12 May 2020 22:05:56 +0200
Subject: Fix ICE caused in unwrap module

---
 clippy_lints/src/unwrap.rs                     | 12 ++++++++++--
 tests/ui/checked_unwrap/simple_conditionals.rs | 21 +++++++++++++++++++++
 2 files changed, 31 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unwrap.rs b/clippy_lints/src/unwrap.rs
index f3844c7d3b6..8b971e7064b 100644
--- a/clippy_lints/src/unwrap.rs
+++ b/clippy_lints/src/unwrap.rs
@@ -8,6 +8,7 @@ use rustc_hir::{BinOpKind, Body, Expr, ExprKind, FnDecl, HirId, Path, QPath, UnO
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::map::Map;
 use rustc_middle::lint::in_external_macro;
+use rustc_middle::ty::Ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
 
@@ -90,6 +91,14 @@ fn collect_unwrap_info<'a, 'tcx>(
     branch: &'tcx Expr<'_>,
     invert: bool,
 ) -> Vec<UnwrapInfo<'tcx>> {
+    fn is_relevant_option_call(cx: &LateContext<'_, '_>, ty: Ty<'_>, method_name: &str) -> bool {
+        is_type_diagnostic_item(cx, ty, sym!(option_type)) && ["is_some", "is_none"].contains(&method_name)
+    }
+
+    fn is_relevant_result_call(cx: &LateContext<'_, '_>, ty: Ty<'_>, method_name: &str) -> bool {
+        is_type_diagnostic_item(cx, ty, sym!(result_type)) && ["is_ok", "is_err"].contains(&method_name)
+    }
+
     if let ExprKind::Binary(op, left, right) = &expr.kind {
         match (invert, op.node) {
             (false, BinOpKind::And) | (false, BinOpKind::BitAnd) | (true, BinOpKind::Or) | (true, BinOpKind::BitOr) => {
@@ -106,9 +115,8 @@ fn collect_unwrap_info<'a, 'tcx>(
             if let ExprKind::MethodCall(method_name, _, args) = &expr.kind;
             if let ExprKind::Path(QPath::Resolved(None, path)) = &args[0].kind;
             let ty = cx.tables.expr_ty(&args[0]);
-            if is_type_diagnostic_item(cx, ty, sym!(option_type)) || is_type_diagnostic_item(cx, ty, sym!(result_type));
             let name = method_name.ident.as_str();
-            if ["is_some", "is_none", "is_ok", "is_err"].contains(&&*name);
+            if is_relevant_option_call(cx, ty, &name) || is_relevant_result_call(cx, ty, &name);
             then {
                 assert!(args.len() == 1);
                 let unwrappable = match name.as_ref() {
diff --git a/tests/ui/checked_unwrap/simple_conditionals.rs b/tests/ui/checked_unwrap/simple_conditionals.rs
index 3e7b4b390ba..49794e0c241 100644
--- a/tests/ui/checked_unwrap/simple_conditionals.rs
+++ b/tests/ui/checked_unwrap/simple_conditionals.rs
@@ -78,3 +78,24 @@ fn main() {
 
     assert!(x.is_ok(), "{:?}", x.unwrap_err()); // ok, it's a common test pattern
 }
+
+mod issue_5579 {
+    trait IsErr {
+        fn is_err(&self, err: &str) -> bool;
+    }
+
+    impl<T> IsErr for Option<T> {
+        fn is_err(&self, _err: &str) -> bool {
+            true
+        }
+    }
+
+    #[allow(unused)]
+    fn boom() {
+        let t = Some(1);
+
+        if t.is_err("") {
+            t.unwrap();
+        }
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 671c1e34cc11767aa4ea257b9f5c40dcee1441fd Mon Sep 17 00:00:00 2001
From: Eduardo Broto <ebroto@tutanota.com>
Date: Wed, 13 May 2020 21:07:13 +0200
Subject: Avoid running doctest that is expected to panic

---
 clippy_lints/src/ranges.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/ranges.rs b/clippy_lints/src/ranges.rs
index 86d55ccabb6..83c6faac041 100644
--- a/clippy_lints/src/ranges.rs
+++ b/clippy_lints/src/ranges.rs
@@ -98,7 +98,7 @@ declare_clippy_lint! {
     ///
     /// **Example:**
     ///
-    /// ```rust
+    /// ```rust,no_run
     /// fn main() {
     ///     (10..=0).for_each(|x| println!("{}", x));
     ///
-- 
cgit 1.4.1-3-g733a5


From 9217675c7f6ccd2efa18047ebb0c86841683b6a5 Mon Sep 17 00:00:00 2001
From: Eduardo Broto <ebroto@tutanota.com>
Date: Thu, 14 May 2020 00:26:09 +0200
Subject: Fix comparison_chain false positive

---
 clippy_lints/src/comparison_chain.rs | 17 ++++++++--
 tests/ui/comparison_chain.rs         | 66 ++++++++++++++++++++++++++++++++++++
 2 files changed, 80 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/comparison_chain.rs b/clippy_lints/src/comparison_chain.rs
index 96df3ffe3ce..93e29edcaa5 100644
--- a/clippy_lints/src/comparison_chain.rs
+++ b/clippy_lints/src/comparison_chain.rs
@@ -81,12 +81,23 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for ComparisonChain {
 
                 // Check that both sets of operands are equal
                 let mut spanless_eq = SpanlessEq::new(cx);
-                if (!spanless_eq.eq_expr(lhs1, lhs2) || !spanless_eq.eq_expr(rhs1, rhs2))
-                    && (!spanless_eq.eq_expr(lhs1, rhs2) || !spanless_eq.eq_expr(rhs1, lhs2))
-                {
+                let same_fixed_operands = spanless_eq.eq_expr(lhs1, lhs2) && spanless_eq.eq_expr(rhs1, rhs2);
+                let same_transposed_operands = spanless_eq.eq_expr(lhs1, rhs2) && spanless_eq.eq_expr(rhs1, lhs2);
+
+                if !same_fixed_operands && !same_transposed_operands {
                     return;
                 }
 
+                // Check that if the operation is the same, either it's not `==` or the operands are transposed
+                if kind1.node == kind2.node {
+                    if kind1.node == BinOpKind::Eq {
+                        return;
+                    }
+                    if !same_transposed_operands {
+                        return;
+                    }
+                }
+
                 // Check that the type being compared implements `core::cmp::Ord`
                 let ty = cx.tables.expr_ty(lhs1);
                 let is_ord = get_trait_def_id(cx, &paths::ORD).map_or(false, |id| implements_trait(cx, ty, id, &[]));
diff --git a/tests/ui/comparison_chain.rs b/tests/ui/comparison_chain.rs
index 9c2128469de..3b03f8c7dfe 100644
--- a/tests/ui/comparison_chain.rs
+++ b/tests/ui/comparison_chain.rs
@@ -137,4 +137,70 @@ fn h<T: Ord>(x: T, y: T, z: T) {
     }
 }
 
+// The following uses should be ignored
+mod issue_5212 {
+    use super::{a, b, c};
+    fn foo() -> u8 {
+        21
+    }
+
+    fn same_operation_equals() {
+        // operands are fixed
+
+        if foo() == 42 {
+            a()
+        } else if foo() == 42 {
+            b()
+        }
+
+        if foo() == 42 {
+            a()
+        } else if foo() == 42 {
+            b()
+        } else {
+            c()
+        }
+
+        // operands are transposed
+
+        if foo() == 42 {
+            a()
+        } else if 42 == foo() {
+            b()
+        }
+    }
+
+    fn same_operation_not_equals() {
+        // operands are fixed
+
+        if foo() > 42 {
+            a()
+        } else if foo() > 42 {
+            b()
+        }
+
+        if foo() > 42 {
+            a()
+        } else if foo() > 42 {
+            b()
+        } else {
+            c()
+        }
+
+        if foo() < 42 {
+            a()
+        } else if foo() < 42 {
+            b()
+        }
+
+        if foo() < 42 {
+            a()
+        } else if foo() < 42 {
+            b()
+        } else {
+            c()
+        }
+    }
+}
+
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 945c9447093a2ca944e70bae125f2af69f8eac16 Mon Sep 17 00:00:00 2001
From: ThibsG <Thibs@debian.com>
Date: Sun, 3 May 2020 11:20:51 +0200
Subject: Merge `block_in_if_condition_expr` and `block_in_if_condition_stmt`
 lints into `block_in_if_condition` lint

---
 CHANGELOG.md                                  |  3 +-
 clippy_lints/src/block_in_if_condition.rs     | 51 +++++++++++++--------------
 clippy_lints/src/lib.rs                       |  9 ++---
 src/lintlist/mod.rs                           | 11 ++----
 tests/ui/block_in_if_condition.fixed          |  3 +-
 tests/ui/block_in_if_condition.rs             |  3 +-
 tests/ui/block_in_if_condition.stderr         | 10 +++---
 tests/ui/block_in_if_condition_closure.rs     |  5 ++-
 tests/ui/block_in_if_condition_closure.stderr |  6 ++--
 9 files changed, 41 insertions(+), 60 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index b25ef049356..0b270e6acd2 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1274,8 +1274,7 @@ Released 2018-09-13
 [`await_holding_lock`]: https://rust-lang.github.io/rust-clippy/master/index.html#await_holding_lock
 [`bad_bit_mask`]: https://rust-lang.github.io/rust-clippy/master/index.html#bad_bit_mask
 [`blacklisted_name`]: https://rust-lang.github.io/rust-clippy/master/index.html#blacklisted_name
-[`block_in_if_condition_expr`]: https://rust-lang.github.io/rust-clippy/master/index.html#block_in_if_condition_expr
-[`block_in_if_condition_stmt`]: https://rust-lang.github.io/rust-clippy/master/index.html#block_in_if_condition_stmt
+[`block_in_if_condition`]: https://rust-lang.github.io/rust-clippy/master/index.html#block_in_if_condition
 [`bool_comparison`]: https://rust-lang.github.io/rust-clippy/master/index.html#bool_comparison
 [`borrow_interior_mutable_const`]: https://rust-lang.github.io/rust-clippy/master/index.html#borrow_interior_mutable_const
 [`borrowed_box`]: https://rust-lang.github.io/rust-clippy/master/index.html#borrowed_box
diff --git a/clippy_lints/src/block_in_if_condition.rs b/clippy_lints/src/block_in_if_condition.rs
index 9e533eaa32c..8a5e595749f 100644
--- a/clippy_lints/src/block_in_if_condition.rs
+++ b/clippy_lints/src/block_in_if_condition.rs
@@ -8,43 +8,40 @@ use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for `if` conditions that use blocks to contain an
-    /// expression.
+    /// **What it does:** Checks for `if` conditions that use blocks containing an
+    /// expression, statements or conditions that use closures with blocks.
     ///
-    /// **Why is this bad?** It isn't really Rust style, same as using parentheses
-    /// to contain expressions.
+    /// **Why is this bad?** Style, using blocks in the condition makes it hard to read.
     ///
     /// **Known problems:** None.
     ///
-    /// **Example:**
+    /// **Examples:**
     /// ```rust
+    /// // Bad
     /// if { true } { /* ... */ }
+    ///
+    /// // Good
+    /// if true { /* ... */ }
     /// ```
-    pub BLOCK_IN_IF_CONDITION_EXPR,
-    style,
-    "braces that can be eliminated in conditions, e.g., `if { true } ...`"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for `if` conditions that use blocks containing
-    /// statements, or conditions that use closures with blocks.
     ///
-    /// **Why is this bad?** Using blocks in the condition makes it hard to read.
+    /// // or
     ///
-    /// **Known problems:** None.
+    /// ```rust
+    /// # fn somefunc() -> bool { true };
     ///
-    /// **Example:**
-    /// ```rust,ignore
-    /// if { let x = somefunc(); x } {}
-    /// // or
-    /// if somefunc(|x| { x == 47 }) {}
+    /// // Bad
+    /// if { let x = somefunc(); x } { /* ... */ }
+    ///
+    /// // Good
+    /// let res = { let x = somefunc(); x };
+    /// if res { /* ... */ }
     /// ```
-    pub BLOCK_IN_IF_CONDITION_STMT,
+    pub BLOCK_IN_IF_CONDITION,
     style,
-    "complex blocks in conditions, e.g., `if { let x = true; x } ...`"
+    "useless or complex blocks that can be eliminated in conditions"
 }
 
-declare_lint_pass!(BlockInIfCondition => [BLOCK_IN_IF_CONDITION_EXPR, BLOCK_IN_IF_CONDITION_STMT]);
+declare_lint_pass!(BlockInIfCondition => [BLOCK_IN_IF_CONDITION]);
 
 struct ExVisitor<'a, 'tcx> {
     found_block: Option<&'tcx Expr<'tcx>>,
@@ -72,7 +69,7 @@ impl<'a, 'tcx> Visitor<'tcx> for ExVisitor<'a, 'tcx> {
 
 const BRACED_EXPR_MESSAGE: &str = "omit braces around single expression condition";
 const COMPLEX_BLOCK_MESSAGE: &str = "in an `if` condition, avoid complex blocks or closures with blocks; \
-                                     instead, move the block or closure higher and bind it with a `let`";
+                                    instead, move the block or closure higher and bind it with a `let`";
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for BlockInIfCondition {
     fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr<'_>) {
@@ -92,7 +89,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for BlockInIfCondition {
                             let mut applicability = Applicability::MachineApplicable;
                             span_lint_and_sugg(
                                 cx,
-                                BLOCK_IN_IF_CONDITION_EXPR,
+                                BLOCK_IN_IF_CONDITION,
                                 cond.span,
                                 BRACED_EXPR_MESSAGE,
                                 "try",
@@ -118,7 +115,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for BlockInIfCondition {
                         let mut applicability = Applicability::MachineApplicable;
                         span_lint_and_sugg(
                             cx,
-                            BLOCK_IN_IF_CONDITION_STMT,
+                            BLOCK_IN_IF_CONDITION,
                             expr.span.with_hi(cond.span.hi()),
                             COMPLEX_BLOCK_MESSAGE,
                             "try",
@@ -140,7 +137,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for BlockInIfCondition {
                 let mut visitor = ExVisitor { found_block: None, cx };
                 walk_expr(&mut visitor, cond);
                 if let Some(block) = visitor.found_block {
-                    span_lint(cx, BLOCK_IN_IF_CONDITION_STMT, block.span, COMPLEX_BLOCK_MESSAGE);
+                    span_lint(cx, BLOCK_IN_IF_CONDITION, block.span, COMPLEX_BLOCK_MESSAGE);
                 }
             }
         }
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 0c4daeb731f..98b696533d8 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -507,8 +507,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &bit_mask::INEFFECTIVE_BIT_MASK,
         &bit_mask::VERBOSE_BIT_MASK,
         &blacklisted_name::BLACKLISTED_NAME,
-        &block_in_if_condition::BLOCK_IN_IF_CONDITION_EXPR,
-        &block_in_if_condition::BLOCK_IN_IF_CONDITION_STMT,
+        &block_in_if_condition::BLOCK_IN_IF_CONDITION,
         &booleans::LOGIC_BUG,
         &booleans::NONMINIMAL_BOOL,
         &bytecount::NAIVE_BYTECOUNT,
@@ -1209,8 +1208,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&bit_mask::INEFFECTIVE_BIT_MASK),
         LintId::of(&bit_mask::VERBOSE_BIT_MASK),
         LintId::of(&blacklisted_name::BLACKLISTED_NAME),
-        LintId::of(&block_in_if_condition::BLOCK_IN_IF_CONDITION_EXPR),
-        LintId::of(&block_in_if_condition::BLOCK_IN_IF_CONDITION_STMT),
+        LintId::of(&block_in_if_condition::BLOCK_IN_IF_CONDITION),
         LintId::of(&booleans::LOGIC_BUG),
         LintId::of(&booleans::NONMINIMAL_BOOL),
         LintId::of(&bytecount::NAIVE_BYTECOUNT),
@@ -1456,8 +1454,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&attrs::UNKNOWN_CLIPPY_LINTS),
         LintId::of(&bit_mask::VERBOSE_BIT_MASK),
         LintId::of(&blacklisted_name::BLACKLISTED_NAME),
-        LintId::of(&block_in_if_condition::BLOCK_IN_IF_CONDITION_EXPR),
-        LintId::of(&block_in_if_condition::BLOCK_IN_IF_CONDITION_STMT),
+        LintId::of(&block_in_if_condition::BLOCK_IN_IF_CONDITION),
         LintId::of(&collapsible_if::COLLAPSIBLE_IF),
         LintId::of(&comparison_chain::COMPARISON_CHAIN),
         LintId::of(&doc::MISSING_SAFETY_DOC),
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index e1a6d4bdd31..4ae60f7d808 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -74,16 +74,9 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
         module: "blacklisted_name",
     },
     Lint {
-        name: "block_in_if_condition_expr",
+        name: "block_in_if_condition",
         group: "style",
-        desc: "braces that can be eliminated in conditions, e.g., `if { true } ...`",
-        deprecation: None,
-        module: "block_in_if_condition",
-    },
-    Lint {
-        name: "block_in_if_condition_stmt",
-        group: "style",
-        desc: "complex blocks in conditions, e.g., `if { let x = true; x } ...`",
+        desc: "useless or complex blocks that can be eliminated in conditions",
         deprecation: None,
         module: "block_in_if_condition",
     },
diff --git a/tests/ui/block_in_if_condition.fixed b/tests/ui/block_in_if_condition.fixed
index 955801e40f9..ae01c6d3042 100644
--- a/tests/ui/block_in_if_condition.fixed
+++ b/tests/ui/block_in_if_condition.fixed
@@ -1,6 +1,5 @@
 // run-rustfix
-#![warn(clippy::block_in_if_condition_expr)]
-#![warn(clippy::block_in_if_condition_stmt)]
+#![warn(clippy::block_in_if_condition)]
 #![allow(unused, clippy::let_and_return)]
 #![warn(clippy::nonminimal_bool)]
 
diff --git a/tests/ui/block_in_if_condition.rs b/tests/ui/block_in_if_condition.rs
index a6ea01d5fc5..88555dc47c2 100644
--- a/tests/ui/block_in_if_condition.rs
+++ b/tests/ui/block_in_if_condition.rs
@@ -1,6 +1,5 @@
 // run-rustfix
-#![warn(clippy::block_in_if_condition_expr)]
-#![warn(clippy::block_in_if_condition_stmt)]
+#![warn(clippy::block_in_if_condition)]
 #![allow(unused, clippy::let_and_return)]
 #![warn(clippy::nonminimal_bool)]
 
diff --git a/tests/ui/block_in_if_condition.stderr b/tests/ui/block_in_if_condition.stderr
index b0a0a276c89..89e9ad26f49 100644
--- a/tests/ui/block_in_if_condition.stderr
+++ b/tests/ui/block_in_if_condition.stderr
@@ -1,5 +1,5 @@
 error: in an `if` condition, avoid complex blocks or closures with blocks; instead, move the block or closure higher and bind it with a `let`
-  --> $DIR/block_in_if_condition.rs:27:5
+  --> $DIR/block_in_if_condition.rs:26:5
    |
 LL | /     if {
 LL | |         let x = 3;
@@ -7,7 +7,7 @@ LL | |         x == 3
 LL | |     } {
    | |_____^
    |
-   = note: `-D clippy::block-in-if-condition-stmt` implied by `-D warnings`
+   = note: `-D clippy::block-in-if-condition` implied by `-D warnings`
 help: try
    |
 LL |     let res = {
@@ -17,15 +17,13 @@ LL |     }; if res {
    |
 
 error: omit braces around single expression condition
-  --> $DIR/block_in_if_condition.rs:38:8
+  --> $DIR/block_in_if_condition.rs:37:8
    |
 LL |     if { true } {
    |        ^^^^^^^^ help: try: `true`
-   |
-   = note: `-D clippy::block-in-if-condition-expr` implied by `-D warnings`
 
 error: this boolean expression can be simplified
-  --> $DIR/block_in_if_condition.rs:47:8
+  --> $DIR/block_in_if_condition.rs:46:8
    |
 LL |     if true && x == 3 {
    |        ^^^^^^^^^^^^^^ help: try: `x == 3`
diff --git a/tests/ui/block_in_if_condition_closure.rs b/tests/ui/block_in_if_condition_closure.rs
index bac3eda5e7f..87b3fb94daf 100644
--- a/tests/ui/block_in_if_condition_closure.rs
+++ b/tests/ui/block_in_if_condition_closure.rs
@@ -1,5 +1,4 @@
-#![warn(clippy::block_in_if_condition_expr)]
-#![warn(clippy::block_in_if_condition_stmt)]
+#![warn(clippy::block_in_if_condition)]
 #![allow(unused, clippy::let_and_return)]
 
 fn predicate<F: FnOnce(T) -> bool, T>(pfn: F, val: T) -> bool {
@@ -10,7 +9,7 @@ fn pred_test() {
     let v = 3;
     let sky = "blue";
     // This is a sneaky case, where the block isn't directly in the condition,
-    // but is actually nside a closure that the condition is using.
+    // but is actually inside a closure that the condition is using.
     // The same principle applies -- add some extra expressions to make sure
     // linter isn't confused by them.
     if v == 3
diff --git a/tests/ui/block_in_if_condition_closure.stderr b/tests/ui/block_in_if_condition_closure.stderr
index 86cd24fe763..3df25691c3c 100644
--- a/tests/ui/block_in_if_condition_closure.stderr
+++ b/tests/ui/block_in_if_condition_closure.stderr
@@ -1,5 +1,5 @@
 error: in an `if` condition, avoid complex blocks or closures with blocks; instead, move the block or closure higher and bind it with a `let`
-  --> $DIR/block_in_if_condition_closure.rs:19:17
+  --> $DIR/block_in_if_condition_closure.rs:18:17
    |
 LL |               |x| {
    |  _________________^
@@ -8,10 +8,10 @@ LL | |                 x == target
 LL | |             },
    | |_____________^
    |
-   = note: `-D clippy::block-in-if-condition-stmt` implied by `-D warnings`
+   = note: `-D clippy::block-in-if-condition` implied by `-D warnings`
 
 error: in an `if` condition, avoid complex blocks or closures with blocks; instead, move the block or closure higher and bind it with a `let`
-  --> $DIR/block_in_if_condition_closure.rs:28:13
+  --> $DIR/block_in_if_condition_closure.rs:27:13
    |
 LL |           |x| {
    |  _____________^
-- 
cgit 1.4.1-3-g733a5


From 6cbdd1e49dbb2355ac1036946a5a635e22023c6f Mon Sep 17 00:00:00 2001
From: ThibsG <Thibs@debian.com>
Date: Sun, 3 May 2020 12:28:40 +0200
Subject: Merge `option_map_unwrap_or`, `option_map_unwrap_or_else` and
 `result_map_unwrap_or_else` lints into `map_unwrap` lint

---
 CHANGELOG.md                                     |   4 +-
 clippy_lints/src/lib.rs                          |   8 +-
 clippy_lints/src/methods/mod.rs                  |  92 ++++---------
 clippy_lints/src/methods/option_map_unwrap_or.rs |   6 +-
 src/lintlist/mod.rs                              |  28 +---
 tests/ui/map_unwrap.rs                           |  99 ++++++++++++++
 tests/ui/map_unwrap.stderr                       | 161 +++++++++++++++++++++++
 tests/ui/option_map_unwrap_or.rs                 |  88 -------------
 tests/ui/option_map_unwrap_or.stderr             | 138 -------------------
 tests/ui/result_map_unwrap_or_else.rs            |  23 ----
 tests/ui/result_map_unwrap_or_else.stderr        |  27 ----
 11 files changed, 301 insertions(+), 373 deletions(-)
 create mode 100644 tests/ui/map_unwrap.rs
 create mode 100644 tests/ui/map_unwrap.stderr
 delete mode 100644 tests/ui/option_map_unwrap_or.rs
 delete mode 100644 tests/ui/option_map_unwrap_or.stderr
 delete mode 100644 tests/ui/result_map_unwrap_or_else.rs
 delete mode 100644 tests/ui/result_map_unwrap_or_else.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 0b270e6acd2..28b05044db6 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1430,6 +1430,7 @@ Released 2018-09-13
 [`map_clone`]: https://rust-lang.github.io/rust-clippy/master/index.html#map_clone
 [`map_entry`]: https://rust-lang.github.io/rust-clippy/master/index.html#map_entry
 [`map_flatten`]: https://rust-lang.github.io/rust-clippy/master/index.html#map_flatten
+[`map_unwrap`]: https://rust-lang.github.io/rust-clippy/master/index.html#map_unwrap
 [`match_as_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#match_as_ref
 [`match_bool`]: https://rust-lang.github.io/rust-clippy/master/index.html#match_bool
 [`match_on_vec_items`]: https://rust-lang.github.io/rust-clippy/master/index.html#match_on_vec_items
@@ -1499,8 +1500,6 @@ Released 2018-09-13
 [`option_expect_used`]: https://rust-lang.github.io/rust-clippy/master/index.html#option_expect_used
 [`option_map_or_none`]: https://rust-lang.github.io/rust-clippy/master/index.html#option_map_or_none
 [`option_map_unit_fn`]: https://rust-lang.github.io/rust-clippy/master/index.html#option_map_unit_fn
-[`option_map_unwrap_or`]: https://rust-lang.github.io/rust-clippy/master/index.html#option_map_unwrap_or
-[`option_map_unwrap_or_else`]: https://rust-lang.github.io/rust-clippy/master/index.html#option_map_unwrap_or_else
 [`option_option`]: https://rust-lang.github.io/rust-clippy/master/index.html#option_option
 [`option_unwrap_used`]: https://rust-lang.github.io/rust-clippy/master/index.html#option_unwrap_used
 [`or_fun_call`]: https://rust-lang.github.io/rust-clippy/master/index.html#or_fun_call
@@ -1542,7 +1541,6 @@ Released 2018-09-13
 [`result_expect_used`]: https://rust-lang.github.io/rust-clippy/master/index.html#result_expect_used
 [`result_map_or_into_option`]: https://rust-lang.github.io/rust-clippy/master/index.html#result_map_or_into_option
 [`result_map_unit_fn`]: https://rust-lang.github.io/rust-clippy/master/index.html#result_map_unit_fn
-[`result_map_unwrap_or_else`]: https://rust-lang.github.io/rust-clippy/master/index.html#result_map_unwrap_or_else
 [`result_unwrap_used`]: https://rust-lang.github.io/rust-clippy/master/index.html#result_unwrap_used
 [`reversed_empty_ranges`]: https://rust-lang.github.io/rust-clippy/master/index.html#reversed_empty_ranges
 [`same_functions_in_if_condition`]: https://rust-lang.github.io/rust-clippy/master/index.html#same_functions_in_if_condition
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 98b696533d8..c9a2ef49907 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -673,19 +673,17 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &methods::ITER_SKIP_NEXT,
         &methods::MANUAL_SATURATING_ARITHMETIC,
         &methods::MAP_FLATTEN,
+        &methods::MAP_UNWRAP,
         &methods::NEW_RET_NO_SELF,
         &methods::OK_EXPECT,
         &methods::OPTION_AND_THEN_SOME,
         &methods::OPTION_AS_REF_DEREF,
         &methods::OPTION_EXPECT_USED,
         &methods::OPTION_MAP_OR_NONE,
-        &methods::OPTION_MAP_UNWRAP_OR,
-        &methods::OPTION_MAP_UNWRAP_OR_ELSE,
         &methods::OPTION_UNWRAP_USED,
         &methods::OR_FUN_CALL,
         &methods::RESULT_EXPECT_USED,
         &methods::RESULT_MAP_OR_INTO_OPTION,
-        &methods::RESULT_MAP_UNWRAP_OR_ELSE,
         &methods::RESULT_UNWRAP_USED,
         &methods::SEARCH_IS_SOME,
         &methods::SHOULD_IMPLEMENT_TRAIT,
@@ -1152,9 +1150,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&methods::FIND_MAP),
         LintId::of(&methods::INEFFICIENT_TO_STRING),
         LintId::of(&methods::MAP_FLATTEN),
-        LintId::of(&methods::OPTION_MAP_UNWRAP_OR),
-        LintId::of(&methods::OPTION_MAP_UNWRAP_OR_ELSE),
-        LintId::of(&methods::RESULT_MAP_UNWRAP_OR_ELSE),
+        LintId::of(&methods::MAP_UNWRAP),
         LintId::of(&misc::USED_UNDERSCORE_BINDING),
         LintId::of(&misc_early::UNSEPARATED_LITERAL_SUFFIX),
         LintId::of(&mut_mut::MUT_MUT),
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 3676dc5b09d..401298b2d51 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -257,59 +257,40 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for usage of `_.map(_).unwrap_or(_)`.
+    /// **What it does:** Checks for usage of `option.map(_).unwrap_or(_)` or `option.map(_).unwrap_or_else(_)` or
+    /// `result.map(_).unwrap_or_else(_)`.
     ///
-    /// **Why is this bad?** Readability, this can be written more concisely as
-    /// `_.map_or(_, _)`.
+    /// **Why is this bad?** Readability, these can be written more concisely (resp.) as
+    /// `option.map_or(_, _)`, `option.map_or_else(_, _)` and `result.map_or_else(_, _)`.
     ///
     /// **Known problems:** The order of the arguments is not in execution order
     ///
-    /// **Example:**
+    /// **Examples:**
     /// ```rust
     /// # let x = Some(1);
-    /// x.map(|a| a + 1).unwrap_or(0);
-    /// ```
-    pub OPTION_MAP_UNWRAP_OR,
-    pedantic,
-    "using `Option.map(f).unwrap_or(a)`, which is more succinctly expressed as `map_or(a, f)`"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for usage of `_.map(_).unwrap_or_else(_)`.
-    ///
-    /// **Why is this bad?** Readability, this can be written more concisely as
-    /// `_.map_or_else(_, _)`.
     ///
-    /// **Known problems:** The order of the arguments is not in execution order.
+    /// // Bad
+    /// x.map(|a| a + 1).unwrap_or(0);
     ///
-    /// **Example:**
-    /// ```rust
-    /// # let x = Some(1);
-    /// # fn some_function() -> usize { 1 }
-    /// x.map(|a| a + 1).unwrap_or_else(some_function);
+    /// // Good
+    /// x.map_or(0, |a| a + 1);
     /// ```
-    pub OPTION_MAP_UNWRAP_OR_ELSE,
-    pedantic,
-    "using `Option.map(f).unwrap_or_else(g)`, which is more succinctly expressed as `map_or_else(g, f)`"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for usage of `result.map(_).unwrap_or_else(_)`.
     ///
-    /// **Why is this bad?** Readability, this can be written more concisely as
-    /// `result.map_or_else(_, _)`.
-    ///
-    /// **Known problems:** None.
+    /// // or
     ///
-    /// **Example:**
     /// ```rust
     /// # let x: Result<usize, ()> = Ok(1);
     /// # fn some_function(foo: ()) -> usize { 1 }
+    ///
+    /// // Bad
     /// x.map(|a| a + 1).unwrap_or_else(some_function);
+    ///
+    /// // Good
+    /// x.map_or_else(some_function, |a| a + 1);
     /// ```
-    pub RESULT_MAP_UNWRAP_OR_ELSE,
+    pub MAP_UNWRAP,
     pedantic,
-    "using `Result.map(f).unwrap_or_else(g)`, which is more succinctly expressed as `.map_or_else(g, f)`"
+    "using `.map(f).unwrap_or(a)` or `.map(f).unwrap_or_else(func)`, which are more succinctly expressed as `map_or(a, f)` or `map_or_else(a, f)`"
 }
 
 declare_clippy_lint! {
@@ -1294,9 +1275,7 @@ declare_lint_pass!(Methods => [
     WRONG_SELF_CONVENTION,
     WRONG_PUB_SELF_CONVENTION,
     OK_EXPECT,
-    OPTION_MAP_UNWRAP_OR,
-    OPTION_MAP_UNWRAP_OR_ELSE,
-    RESULT_MAP_UNWRAP_OR_ELSE,
+    MAP_UNWRAP,
     RESULT_MAP_OR_INTO_OPTION,
     OPTION_MAP_OR_NONE,
     OPTION_AND_THEN_SOME,
@@ -1503,9 +1482,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Methods {
                             cx,
                             lint,
                             first_arg.pat.span,
-                            &format!(
-                               "methods called `{}` usually take {}; consider choosing a less \
-                                 ambiguous name",
+                            &format!("methods called `{}` usually take {}; consider choosing a less ambiguous name",
                                 conv,
                                 &self_kinds
                                     .iter()
@@ -1678,7 +1655,7 @@ fn lint_or_fun_call<'a, 'tcx>(
             let self_ty = cx.tables.expr_ty(self_expr);
 
             if let Some(&(_, fn_has_arguments, poss, suffix)) =
-                   know_types.iter().find(|&&i| match_type(cx, self_ty, i.0));
+                know_types.iter().find(|&&i| match_type(cx, self_ty, i.0));
 
             if poss.contains(&name);
 
@@ -1931,7 +1908,7 @@ fn lint_clone_on_copy(cx: &LateContext<'_, '_>, expr: &hir::Expr<'_>, arg: &hir:
                 CLONE_DOUBLE_REF,
                 expr.span,
                 "using `clone` on a double-reference; \
-                 this will copy the reference instead of cloning the inner type",
+                this will copy the reference instead of cloning the inner type",
                 |diag| {
                     if let Some(snip) = sugg::Sugg::hir_opt(cx, arg) {
                         let mut ty = innermost;
@@ -2121,7 +2098,7 @@ fn lint_iter_cloned_collect<'a, 'tcx>(
                 ITER_CLONED_COLLECT,
                 to_replace,
                 "called `iter().cloned().collect()` on a slice to create a `Vec`. Calling `to_vec()` is both faster and \
-                 more readable",
+                more readable",
                 "try",
                 ".to_vec()".to_string(),
                 Applicability::MachineApplicable,
@@ -2436,7 +2413,7 @@ fn lint_unwrap(cx: &LateContext<'_, '_>, expr: &hir::Expr<'_>, unwrap_args: &[hi
             None,
             &format!(
                 "if you don't want to handle the `{}` case gracefully, consider \
-                 using `expect()` to provide a better panic message",
+                using `expect()` to provide a better panic message",
                 none_value,
             ),
         );
@@ -2494,7 +2471,7 @@ fn lint_map_flatten<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &'tcx hir::Expr<
     // lint if caller of `.map().flatten()` is an Iterator
     if match_trait_method(cx, expr, &paths::ITERATOR) {
         let msg = "called `map(..).flatten()` on an `Iterator`. \
-                   This is more succinctly expressed by calling `.flat_map(..)`";
+                    This is more succinctly expressed by calling `.flat_map(..)`";
         let self_snippet = snippet(cx, map_args[0].span, "..");
         let func_snippet = snippet(cx, map_args[1].span, "..");
         let hint = format!("{0}.flat_map({1})", self_snippet, func_snippet);
@@ -2555,10 +2532,10 @@ fn lint_map_unwrap_or_else<'a, 'tcx>(
         // lint message
         let msg = if is_option {
             "called `map(f).unwrap_or_else(g)` on an `Option` value. This can be done more directly by calling \
-             `map_or_else(g, f)` instead"
+            `map_or_else(g, f)` instead"
         } else {
             "called `map(f).unwrap_or_else(g)` on a `Result` value. This can be done more directly by calling \
-             `.map_or_else(g, f)` instead"
+            `.map_or_else(g, f)` instead"
         };
         // get snippets for args to map() and unwrap_or_else()
         let map_snippet = snippet(cx, map_args[1].span, "..");
@@ -2570,11 +2547,7 @@ fn lint_map_unwrap_or_else<'a, 'tcx>(
         if same_span && !multiline {
             span_lint_and_note(
                 cx,
-                if is_option {
-                    OPTION_MAP_UNWRAP_OR_ELSE
-                } else {
-                    RESULT_MAP_UNWRAP_OR_ELSE
-                },
+                MAP_UNWRAP,
                 expr.span,
                 msg,
                 None,
@@ -2584,16 +2557,7 @@ fn lint_map_unwrap_or_else<'a, 'tcx>(
                 ),
             );
         } else if same_span && multiline {
-            span_lint(
-                cx,
-                if is_option {
-                    OPTION_MAP_UNWRAP_OR_ELSE
-                } else {
-                    RESULT_MAP_UNWRAP_OR_ELSE
-                },
-                expr.span,
-                msg,
-            );
+            span_lint(cx, MAP_UNWRAP, expr.span, msg);
         };
     }
 }
diff --git a/clippy_lints/src/methods/option_map_unwrap_or.rs b/clippy_lints/src/methods/option_map_unwrap_or.rs
index bf9dd3c9369..fcaa9b47e64 100644
--- a/clippy_lints/src/methods/option_map_unwrap_or.rs
+++ b/clippy_lints/src/methods/option_map_unwrap_or.rs
@@ -9,7 +9,7 @@ use rustc_middle::hir::map::Map;
 use rustc_span::source_map::Span;
 use rustc_span::symbol::Symbol;
 
-use super::OPTION_MAP_UNWRAP_OR;
+use super::MAP_UNWRAP;
 
 /// lint use of `map().unwrap_or()` for `Option`s
 pub(super) fn lint<'a, 'tcx>(
@@ -62,11 +62,11 @@ pub(super) fn lint<'a, 'tcx>(
         };
         let msg = &format!(
             "called `map(f).unwrap_or({})` on an `Option` value. \
-             This can be done more directly by calling `{}` instead",
+            This can be done more directly by calling `{}` instead",
             arg, suggest
         );
 
-        span_lint_and_then(cx, OPTION_MAP_UNWRAP_OR, expr.span, msg, |diag| {
+        span_lint_and_then(cx, MAP_UNWRAP, expr.span, msg, |diag| {
             let map_arg_span = map_args[1].span;
 
             let mut suggestion = vec![
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index 4ae60f7d808..d3bd9f66e38 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -1137,6 +1137,13 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
         deprecation: None,
         module: "methods",
     },
+    Lint {
+        name: "map_unwrap",
+        group: "pedantic",
+        desc: "using `.map(f).unwrap_or(a)` or `.map(f).unwrap_or_else(func)`, which are more succinctly expressed as `map_or(a, f)` or `map_or_else(a, f)`",
+        deprecation: None,
+        module: "methods",
+    },
     Lint {
         name: "match_as_ref",
         group: "complexity",
@@ -1613,20 +1620,6 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
         deprecation: None,
         module: "map_unit_fn",
     },
-    Lint {
-        name: "option_map_unwrap_or",
-        group: "pedantic",
-        desc: "using `Option.map(f).unwrap_or(a)`, which is more succinctly expressed as `map_or(a, f)`",
-        deprecation: None,
-        module: "methods",
-    },
-    Lint {
-        name: "option_map_unwrap_or_else",
-        group: "pedantic",
-        desc: "using `Option.map(f).unwrap_or_else(g)`, which is more succinctly expressed as `map_or_else(g, f)`",
-        deprecation: None,
-        module: "methods",
-    },
     Lint {
         name: "option_option",
         group: "pedantic",
@@ -1900,13 +1893,6 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
         deprecation: None,
         module: "map_unit_fn",
     },
-    Lint {
-        name: "result_map_unwrap_or_else",
-        group: "pedantic",
-        desc: "using `Result.map(f).unwrap_or_else(g)`, which is more succinctly expressed as `.map_or_else(g, f)`",
-        deprecation: None,
-        module: "methods",
-    },
     Lint {
         name: "result_unwrap_used",
         group: "restriction",
diff --git a/tests/ui/map_unwrap.rs b/tests/ui/map_unwrap.rs
new file mode 100644
index 00000000000..53e50368231
--- /dev/null
+++ b/tests/ui/map_unwrap.rs
@@ -0,0 +1,99 @@
+// FIXME: Add "run-rustfix" once it's supported for multipart suggestions
+// aux-build:option_helpers.rs
+
+#![warn(clippy::map_unwrap)]
+
+#[macro_use]
+extern crate option_helpers;
+
+use std::collections::HashMap;
+
+#[rustfmt::skip]
+fn option_methods() {
+    let opt = Some(1);
+
+    // Check for `option.map(_).unwrap_or(_)` use.
+    // Single line case.
+    let _ = opt.map(|x| x + 1)
+        // Should lint even though this call is on a separate line.
+        .unwrap_or(0);
+    // Multi-line cases.
+    let _ = opt.map(|x| {
+        x + 1
+    }
+    ).unwrap_or(0);
+    let _ = opt.map(|x| x + 1)
+        .unwrap_or({
+            0
+        });
+    // Single line `map(f).unwrap_or(None)` case.
+    let _ = opt.map(|x| Some(x + 1)).unwrap_or(None);
+    // Multi-line `map(f).unwrap_or(None)` cases.
+    let _ = opt.map(|x| {
+        Some(x + 1)
+    }
+    ).unwrap_or(None);
+    let _ = opt
+        .map(|x| Some(x + 1))
+        .unwrap_or(None);
+    // macro case
+    let _ = opt_map!(opt, |x| x + 1).unwrap_or(0); // should not lint
+
+    // Should not lint if not copyable
+    let id: String = "identifier".to_string();
+    let _ = Some("prefix").map(|p| format!("{}.{}", p, id)).unwrap_or(id);
+    // ...but DO lint if the `unwrap_or` argument is not used in the `map`
+    let id: String = "identifier".to_string();
+    let _ = Some("prefix").map(|p| format!("{}.", p)).unwrap_or(id);
+
+    // Check for `option.map(_).unwrap_or_else(_)` use.
+    // single line case
+    let _ = opt.map(|x| x + 1)
+        // Should lint even though this call is on a separate line.
+        .unwrap_or_else(|| 0);
+    // Multi-line cases.
+    let _ = opt.map(|x| {
+        x + 1
+    }
+    ).unwrap_or_else(|| 0);
+    let _ = opt.map(|x| x + 1)
+        .unwrap_or_else(||
+            0
+        );
+    // Macro case.
+    // Should not lint.
+    let _ = opt_map!(opt, |x| x + 1).unwrap_or_else(|| 0);
+
+    // Issue #4144
+    {
+        let mut frequencies = HashMap::new();
+        let word = "foo";
+
+        frequencies
+            .get_mut(word)
+            .map(|count| {
+                *count += 1;
+            })
+            .unwrap_or_else(|| {
+                frequencies.insert(word.to_owned(), 1);
+            });
+    }
+}
+
+fn result_methods() {
+    let res: Result<i32, ()> = Ok(1);
+
+    // Check for `result.map(_).unwrap_or_else(_)` use.
+    // single line case
+    let _ = res.map(|x| x + 1).unwrap_or_else(|e| 0); // should lint even though this call is on a separate line
+                                                      // multi line cases
+    let _ = res.map(|x| x + 1).unwrap_or_else(|e| 0);
+    let _ = res.map(|x| x + 1).unwrap_or_else(|e| 0);
+    // macro case
+    let _ = opt_map!(res, |x| x + 1).unwrap_or_else(|e| 0); // should not lint
+}
+
+fn main() {
+    option_methods();
+    result_methods();
+}
diff --git a/tests/ui/map_unwrap.stderr b/tests/ui/map_unwrap.stderr
new file mode 100644
index 00000000000..2610923275d
--- /dev/null
+++ b/tests/ui/map_unwrap.stderr
@@ -0,0 +1,161 @@
+error: called `map(f).unwrap_or(a)` on an `Option` value. This can be done more directly by calling `map_or(a, f)` instead
+  --> $DIR/map_unwrap.rs:17:13
+   |
+LL |       let _ = opt.map(|x| x + 1)
+   |  _____________^
+LL | |         // Should lint even though this call is on a separate line.
+LL | |         .unwrap_or(0);
+   | |_____________________^
+   |
+   = note: `-D clippy::map-unwrap` implied by `-D warnings`
+help: use `map_or(a, f)` instead
+   |
+LL |     let _ = opt.map_or(0, |x| x + 1);
+   |                 ^^^^^^ ^^          --
+
+error: called `map(f).unwrap_or(a)` on an `Option` value. This can be done more directly by calling `map_or(a, f)` instead
+  --> $DIR/map_unwrap.rs:21:13
+   |
+LL |       let _ = opt.map(|x| {
+   |  _____________^
+LL | |         x + 1
+LL | |     }
+LL | |     ).unwrap_or(0);
+   | |__________________^
+   |
+help: use `map_or(a, f)` instead
+   |
+LL |     let _ = opt.map_or(0, |x| {
+LL |         x + 1
+LL |     }
+LL |     );
+   |
+
+error: called `map(f).unwrap_or(a)` on an `Option` value. This can be done more directly by calling `map_or(a, f)` instead
+  --> $DIR/map_unwrap.rs:25:13
+   |
+LL |       let _ = opt.map(|x| x + 1)
+   |  _____________^
+LL | |         .unwrap_or({
+LL | |             0
+LL | |         });
+   | |__________^
+   |
+help: use `map_or(a, f)` instead
+   |
+LL |     let _ = opt.map_or({
+LL |             0
+LL |         }, |x| x + 1);
+   |
+
+error: called `map(f).unwrap_or(None)` on an `Option` value. This can be done more directly by calling `and_then(f)` instead
+  --> $DIR/map_unwrap.rs:30:13
+   |
+LL |     let _ = opt.map(|x| Some(x + 1)).unwrap_or(None);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `and_then(f)` instead
+   |
+LL |     let _ = opt.and_then(|x| Some(x + 1));
+   |                 ^^^^^^^^                --
+
+error: called `map(f).unwrap_or(None)` on an `Option` value. This can be done more directly by calling `and_then(f)` instead
+  --> $DIR/map_unwrap.rs:32:13
+   |
+LL |       let _ = opt.map(|x| {
+   |  _____________^
+LL | |         Some(x + 1)
+LL | |     }
+LL | |     ).unwrap_or(None);
+   | |_____________________^
+   |
+help: use `and_then(f)` instead
+   |
+LL |     let _ = opt.and_then(|x| {
+LL |         Some(x + 1)
+LL |     }
+LL |     );
+   |
+
+error: called `map(f).unwrap_or(None)` on an `Option` value. This can be done more directly by calling `and_then(f)` instead
+  --> $DIR/map_unwrap.rs:36:13
+   |
+LL |       let _ = opt
+   |  _____________^
+LL | |         .map(|x| Some(x + 1))
+LL | |         .unwrap_or(None);
+   | |________________________^
+   |
+help: use `and_then(f)` instead
+   |
+LL |         .and_then(|x| Some(x + 1));
+   |          ^^^^^^^^                --
+
+error: called `map(f).unwrap_or(a)` on an `Option` value. This can be done more directly by calling `map_or(a, f)` instead
+  --> $DIR/map_unwrap.rs:47:13
+   |
+LL |     let _ = Some("prefix").map(|p| format!("{}.", p)).unwrap_or(id);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `map_or(a, f)` instead
+   |
+LL |     let _ = Some("prefix").map_or(id, |p| format!("{}.", p));
+   |                            ^^^^^^ ^^^                      --
+
+error: called `map(f).unwrap_or_else(g)` on an `Option` value. This can be done more directly by calling `map_or_else(g, f)` instead
+  --> $DIR/map_unwrap.rs:51:13
+   |
+LL |       let _ = opt.map(|x| x + 1)
+   |  _____________^
+LL | |         // Should lint even though this call is on a separate line.
+LL | |         .unwrap_or_else(|| 0);
+   | |_____________________________^
+   |
+   = note: replace `map(|x| x + 1).unwrap_or_else(|| 0)` with `map_or_else(|| 0, |x| x + 1)`
+
+error: called `map(f).unwrap_or_else(g)` on an `Option` value. This can be done more directly by calling `map_or_else(g, f)` instead
+  --> $DIR/map_unwrap.rs:55:13
+   |
+LL |       let _ = opt.map(|x| {
+   |  _____________^
+LL | |         x + 1
+LL | |     }
+LL | |     ).unwrap_or_else(|| 0);
+   | |__________________________^
+
+error: called `map(f).unwrap_or_else(g)` on an `Option` value. This can be done more directly by calling `map_or_else(g, f)` instead
+  --> $DIR/map_unwrap.rs:59:13
+   |
+LL |       let _ = opt.map(|x| x + 1)
+   |  _____________^
+LL | |         .unwrap_or_else(||
+LL | |             0
+LL | |         );
+   | |_________^
+
+error: called `map(f).unwrap_or_else(g)` on a `Result` value. This can be done more directly by calling `.map_or_else(g, f)` instead
+  --> $DIR/map_unwrap.rs:88:13
+   |
+LL |     let _ = res.map(|x| x + 1).unwrap_or_else(|e| 0); // should lint even though this call is on a separate line
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: replace `map(|x| x + 1).unwrap_or_else(|e| 0)` with `map_or_else(|e| 0, |x| x + 1)`
+
+error: called `map(f).unwrap_or_else(g)` on a `Result` value. This can be done more directly by calling `.map_or_else(g, f)` instead
+  --> $DIR/map_unwrap.rs:90:13
+   |
+LL |     let _ = res.map(|x| x + 1).unwrap_or_else(|e| 0);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: replace `map(|x| x + 1).unwrap_or_else(|e| 0)` with `map_or_else(|e| 0, |x| x + 1)`
+
+error: called `map(f).unwrap_or_else(g)` on a `Result` value. This can be done more directly by calling `.map_or_else(g, f)` instead
+  --> $DIR/map_unwrap.rs:91:13
+   |
+LL |     let _ = res.map(|x| x + 1).unwrap_or_else(|e| 0);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: replace `map(|x| x + 1).unwrap_or_else(|e| 0)` with `map_or_else(|e| 0, |x| x + 1)`
+
+error: aborting due to 13 previous errors
+
diff --git a/tests/ui/option_map_unwrap_or.rs b/tests/ui/option_map_unwrap_or.rs
deleted file mode 100644
index 0364d83663a..00000000000
--- a/tests/ui/option_map_unwrap_or.rs
+++ /dev/null
@@ -1,88 +0,0 @@
-// FIXME: Add "run-rustfix" once it's supported for multipart suggestions
-// aux-build:option_helpers.rs
-
-#![warn(clippy::option_map_unwrap_or, clippy::option_map_unwrap_or_else)]
-
-#[macro_use]
-extern crate option_helpers;
-
-use std::collections::HashMap;
-
-/// Checks implementation of the following lints:
-/// * `OPTION_MAP_UNWRAP_OR`
-/// * `OPTION_MAP_UNWRAP_OR_ELSE`
-#[rustfmt::skip]
-fn option_methods() {
-    let opt = Some(1);
-
-    // Check `OPTION_MAP_UNWRAP_OR`.
-    // Single line case.
-    let _ = opt.map(|x| x + 1)
-        // Should lint even though this call is on a separate line.
-        .unwrap_or(0);
-    // Multi-line cases.
-    let _ = opt.map(|x| {
-        x + 1
-    }
-    ).unwrap_or(0);
-    let _ = opt.map(|x| x + 1)
-        .unwrap_or({
-            0
-        });
-    // Single line `map(f).unwrap_or(None)` case.
-    let _ = opt.map(|x| Some(x + 1)).unwrap_or(None);
-    // Multi-line `map(f).unwrap_or(None)` cases.
-    let _ = opt.map(|x| {
-        Some(x + 1)
-    }
-    ).unwrap_or(None);
-    let _ = opt
-        .map(|x| Some(x + 1))
-        .unwrap_or(None);
-    // macro case
-    let _ = opt_map!(opt, |x| x + 1).unwrap_or(0); // should not lint
-
-    // Should not lint if not copyable
-    let id: String = "identifier".to_string();
-    let _ = Some("prefix").map(|p| format!("{}.{}", p, id)).unwrap_or(id);
-    // ...but DO lint if the `unwrap_or` argument is not used in the `map`
-    let id: String = "identifier".to_string();
-    let _ = Some("prefix").map(|p| format!("{}.", p)).unwrap_or(id);
-
-    // Check OPTION_MAP_UNWRAP_OR_ELSE
-    // single line case
-    let _ = opt.map(|x| x + 1)
-        // Should lint even though this call is on a separate line.
-        .unwrap_or_else(|| 0);
-    // Multi-line cases.
-    let _ = opt.map(|x| {
-        x + 1
-    }
-    ).unwrap_or_else(|| 0);
-    let _ = opt.map(|x| x + 1)
-        .unwrap_or_else(||
-            0
-        );
-    // Macro case.
-    // Should not lint.
-    let _ = opt_map!(opt, |x| x + 1).unwrap_or_else(|| 0);
-
-    // Issue #4144
-    {
-        let mut frequencies = HashMap::new();
-        let word = "foo";
-
-        frequencies
-            .get_mut(word)
-            .map(|count| {
-                *count += 1;
-            })
-            .unwrap_or_else(|| {
-                frequencies.insert(word.to_owned(), 1);
-            });
-    }
-}
-
-fn main() {
-    option_methods();
-}
diff --git a/tests/ui/option_map_unwrap_or.stderr b/tests/ui/option_map_unwrap_or.stderr
deleted file mode 100644
index f05f2893de2..00000000000
--- a/tests/ui/option_map_unwrap_or.stderr
+++ /dev/null
@@ -1,138 +0,0 @@
-error: called `map(f).unwrap_or(a)` on an `Option` value. This can be done more directly by calling `map_or(a, f)` instead
-  --> $DIR/option_map_unwrap_or.rs:20:13
-   |
-LL |       let _ = opt.map(|x| x + 1)
-   |  _____________^
-LL | |         // Should lint even though this call is on a separate line.
-LL | |         .unwrap_or(0);
-   | |_____________________^
-   |
-   = note: `-D clippy::option-map-unwrap-or` implied by `-D warnings`
-help: use `map_or(a, f)` instead
-   |
-LL |     let _ = opt.map_or(0, |x| x + 1);
-   |                 ^^^^^^ ^^          --
-
-error: called `map(f).unwrap_or(a)` on an `Option` value. This can be done more directly by calling `map_or(a, f)` instead
-  --> $DIR/option_map_unwrap_or.rs:24:13
-   |
-LL |       let _ = opt.map(|x| {
-   |  _____________^
-LL | |         x + 1
-LL | |     }
-LL | |     ).unwrap_or(0);
-   | |__________________^
-   |
-help: use `map_or(a, f)` instead
-   |
-LL |     let _ = opt.map_or(0, |x| {
-LL |         x + 1
-LL |     }
-LL |     );
-   |
-
-error: called `map(f).unwrap_or(a)` on an `Option` value. This can be done more directly by calling `map_or(a, f)` instead
-  --> $DIR/option_map_unwrap_or.rs:28:13
-   |
-LL |       let _ = opt.map(|x| x + 1)
-   |  _____________^
-LL | |         .unwrap_or({
-LL | |             0
-LL | |         });
-   | |__________^
-   |
-help: use `map_or(a, f)` instead
-   |
-LL |     let _ = opt.map_or({
-LL |             0
-LL |         }, |x| x + 1);
-   |
-
-error: called `map(f).unwrap_or(None)` on an `Option` value. This can be done more directly by calling `and_then(f)` instead
-  --> $DIR/option_map_unwrap_or.rs:33:13
-   |
-LL |     let _ = opt.map(|x| Some(x + 1)).unwrap_or(None);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: use `and_then(f)` instead
-   |
-LL |     let _ = opt.and_then(|x| Some(x + 1));
-   |                 ^^^^^^^^                --
-
-error: called `map(f).unwrap_or(None)` on an `Option` value. This can be done more directly by calling `and_then(f)` instead
-  --> $DIR/option_map_unwrap_or.rs:35:13
-   |
-LL |       let _ = opt.map(|x| {
-   |  _____________^
-LL | |         Some(x + 1)
-LL | |     }
-LL | |     ).unwrap_or(None);
-   | |_____________________^
-   |
-help: use `and_then(f)` instead
-   |
-LL |     let _ = opt.and_then(|x| {
-LL |         Some(x + 1)
-LL |     }
-LL |     );
-   |
-
-error: called `map(f).unwrap_or(None)` on an `Option` value. This can be done more directly by calling `and_then(f)` instead
-  --> $DIR/option_map_unwrap_or.rs:39:13
-   |
-LL |       let _ = opt
-   |  _____________^
-LL | |         .map(|x| Some(x + 1))
-LL | |         .unwrap_or(None);
-   | |________________________^
-   |
-help: use `and_then(f)` instead
-   |
-LL |         .and_then(|x| Some(x + 1));
-   |          ^^^^^^^^                --
-
-error: called `map(f).unwrap_or(a)` on an `Option` value. This can be done more directly by calling `map_or(a, f)` instead
-  --> $DIR/option_map_unwrap_or.rs:50:13
-   |
-LL |     let _ = Some("prefix").map(|p| format!("{}.", p)).unwrap_or(id);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: use `map_or(a, f)` instead
-   |
-LL |     let _ = Some("prefix").map_or(id, |p| format!("{}.", p));
-   |                            ^^^^^^ ^^^                      --
-
-error: called `map(f).unwrap_or_else(g)` on an `Option` value. This can be done more directly by calling `map_or_else(g, f)` instead
-  --> $DIR/option_map_unwrap_or.rs:54:13
-   |
-LL |       let _ = opt.map(|x| x + 1)
-   |  _____________^
-LL | |         // Should lint even though this call is on a separate line.
-LL | |         .unwrap_or_else(|| 0);
-   | |_____________________________^
-   |
-   = note: `-D clippy::option-map-unwrap-or-else` implied by `-D warnings`
-   = note: replace `map(|x| x + 1).unwrap_or_else(|| 0)` with `map_or_else(|| 0, |x| x + 1)`
-
-error: called `map(f).unwrap_or_else(g)` on an `Option` value. This can be done more directly by calling `map_or_else(g, f)` instead
-  --> $DIR/option_map_unwrap_or.rs:58:13
-   |
-LL |       let _ = opt.map(|x| {
-   |  _____________^
-LL | |         x + 1
-LL | |     }
-LL | |     ).unwrap_or_else(|| 0);
-   | |__________________________^
-
-error: called `map(f).unwrap_or_else(g)` on an `Option` value. This can be done more directly by calling `map_or_else(g, f)` instead
-  --> $DIR/option_map_unwrap_or.rs:62:13
-   |
-LL |       let _ = opt.map(|x| x + 1)
-   |  _____________^
-LL | |         .unwrap_or_else(||
-LL | |             0
-LL | |         );
-   | |_________^
-
-error: aborting due to 10 previous errors
-
diff --git a/tests/ui/result_map_unwrap_or_else.rs b/tests/ui/result_map_unwrap_or_else.rs
deleted file mode 100644
index 40751bfebe6..00000000000
--- a/tests/ui/result_map_unwrap_or_else.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-// aux-build:option_helpers.rs
-
-//! Checks implementation of `RESULT_MAP_UNWRAP_OR_ELSE`
-
-#![warn(clippy::result_map_unwrap_or_else)]
-
-#[macro_use]
-extern crate option_helpers;
-
-fn result_methods() {
-    let res: Result<i32, ()> = Ok(1);
-
-    // Check RESULT_MAP_UNWRAP_OR_ELSE
-    // single line case
-    let _ = res.map(|x| x + 1).unwrap_or_else(|e| 0); // should lint even though this call is on a separate line
-                                                      // multi line cases
-    let _ = res.map(|x| x + 1).unwrap_or_else(|e| 0);
-    let _ = res.map(|x| x + 1).unwrap_or_else(|e| 0);
-    // macro case
-    let _ = opt_map!(res, |x| x + 1).unwrap_or_else(|e| 0); // should not lint
-}
-
-fn main() {}
diff --git a/tests/ui/result_map_unwrap_or_else.stderr b/tests/ui/result_map_unwrap_or_else.stderr
deleted file mode 100644
index ec7bc8f1241..00000000000
--- a/tests/ui/result_map_unwrap_or_else.stderr
+++ /dev/null
@@ -1,27 +0,0 @@
-error: called `map(f).unwrap_or_else(g)` on a `Result` value. This can be done more directly by calling `.map_or_else(g, f)` instead
-  --> $DIR/result_map_unwrap_or_else.rs:15:13
-   |
-LL |     let _ = res.map(|x| x + 1).unwrap_or_else(|e| 0); // should lint even though this call is on a separate line
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: `-D clippy::result-map-unwrap-or-else` implied by `-D warnings`
-   = note: replace `map(|x| x + 1).unwrap_or_else(|e| 0)` with `map_or_else(|e| 0, |x| x + 1)`
-
-error: called `map(f).unwrap_or_else(g)` on a `Result` value. This can be done more directly by calling `.map_or_else(g, f)` instead
-  --> $DIR/result_map_unwrap_or_else.rs:17:13
-   |
-LL |     let _ = res.map(|x| x + 1).unwrap_or_else(|e| 0);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: replace `map(|x| x + 1).unwrap_or_else(|e| 0)` with `map_or_else(|e| 0, |x| x + 1)`
-
-error: called `map(f).unwrap_or_else(g)` on a `Result` value. This can be done more directly by calling `.map_or_else(g, f)` instead
-  --> $DIR/result_map_unwrap_or_else.rs:18:13
-   |
-LL |     let _ = res.map(|x| x + 1).unwrap_or_else(|e| 0);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: replace `map(|x| x + 1).unwrap_or_else(|e| 0)` with `map_or_else(|e| 0, |x| x + 1)`
-
-error: aborting due to 3 previous errors
-
-- 
cgit 1.4.1-3-g733a5


From bcf61666bd903c0d13c081cf222b423e45cd854e Mon Sep 17 00:00:00 2001
From: ThibsG <Thibs@debian.com>
Date: Sun, 3 May 2020 13:11:18 +0200
Subject: Merge `option_unwrap_used` and `result_unwrap_used` lints into
 `unwrap_used` lint

---
 CHANGELOG.md                    |  2 +-
 clippy_lints/src/lib.rs         |  6 ++--
 clippy_lints/src/methods/mod.rs | 68 +++++++++++++++--------------------------
 src/lintlist/mod.rs             | 14 ++++-----
 tests/ui/unwrap.rs              |  2 +-
 tests/ui/unwrap.stderr          |  3 +-
 6 files changed, 37 insertions(+), 58 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 28b05044db6..78f98bba2b4 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1501,7 +1501,6 @@ Released 2018-09-13
 [`option_map_or_none`]: https://rust-lang.github.io/rust-clippy/master/index.html#option_map_or_none
 [`option_map_unit_fn`]: https://rust-lang.github.io/rust-clippy/master/index.html#option_map_unit_fn
 [`option_option`]: https://rust-lang.github.io/rust-clippy/master/index.html#option_option
-[`option_unwrap_used`]: https://rust-lang.github.io/rust-clippy/master/index.html#option_unwrap_used
 [`or_fun_call`]: https://rust-lang.github.io/rust-clippy/master/index.html#or_fun_call
 [`out_of_bounds_indexing`]: https://rust-lang.github.io/rust-clippy/master/index.html#out_of_bounds_indexing
 [`overflow_check_conditional`]: https://rust-lang.github.io/rust-clippy/master/index.html#overflow_check_conditional
@@ -1622,6 +1621,7 @@ Released 2018-09-13
 [`unused_label`]: https://rust-lang.github.io/rust-clippy/master/index.html#unused_label
 [`unused_self`]: https://rust-lang.github.io/rust-clippy/master/index.html#unused_self
 [`unused_unit`]: https://rust-lang.github.io/rust-clippy/master/index.html#unused_unit
+[`unwrap_used`]: https://rust-lang.github.io/rust-clippy/master/index.html#unwrap_used
 [`use_debug`]: https://rust-lang.github.io/rust-clippy/master/index.html#use_debug
 [`use_self`]: https://rust-lang.github.io/rust-clippy/master/index.html#use_self
 [`used_underscore_binding`]: https://rust-lang.github.io/rust-clippy/master/index.html#used_underscore_binding
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index c9a2ef49907..bb3bc0b4545 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -680,11 +680,9 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &methods::OPTION_AS_REF_DEREF,
         &methods::OPTION_EXPECT_USED,
         &methods::OPTION_MAP_OR_NONE,
-        &methods::OPTION_UNWRAP_USED,
         &methods::OR_FUN_CALL,
         &methods::RESULT_EXPECT_USED,
         &methods::RESULT_MAP_OR_INTO_OPTION,
-        &methods::RESULT_UNWRAP_USED,
         &methods::SEARCH_IS_SOME,
         &methods::SHOULD_IMPLEMENT_TRAIT,
         &methods::SINGLE_CHAR_PATTERN,
@@ -695,6 +693,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &methods::UNINIT_ASSUMED_INIT,
         &methods::UNNECESSARY_FILTER_MAP,
         &methods::UNNECESSARY_FOLD,
+        &methods::UNWRAP_USED,
         &methods::USELESS_ASREF,
         &methods::WRONG_PUB_SELF_CONVENTION,
         &methods::WRONG_SELF_CONVENTION,
@@ -1090,9 +1089,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&methods::FILETYPE_IS_FILE),
         LintId::of(&methods::GET_UNWRAP),
         LintId::of(&methods::OPTION_EXPECT_USED),
-        LintId::of(&methods::OPTION_UNWRAP_USED),
         LintId::of(&methods::RESULT_EXPECT_USED),
-        LintId::of(&methods::RESULT_UNWRAP_USED),
+        LintId::of(&methods::UNWRAP_USED),
         LintId::of(&methods::WRONG_PUB_SELF_CONVENTION),
         LintId::of(&misc::FLOAT_CMP_CONST),
         LintId::of(&misc_early::UNNEEDED_FIELD_PATTERN),
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 401298b2d51..1af4d03c7a2 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -33,40 +33,15 @@ use crate::utils::{
 };
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for `.unwrap()` calls on `Option`s.
+    /// **What it does:** Checks for `.unwrap()` calls on `Option`s and on `Result`s.
     ///
-    /// **Why is this bad?** Usually it is better to handle the `None` case, or to
-    /// at least call `.expect(_)` with a more helpful message. Still, for a lot of
+    /// **Why is this bad?** It is better to handle the `None` or `Err` case,
+    /// or at least call `.expect(_)` with a more helpful message. Still, for a lot of
     /// quick-and-dirty code, `unwrap` is a good choice, which is why this lint is
     /// `Allow` by default.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
-    /// Using unwrap on an `Option`:
-    ///
-    /// ```rust
-    /// let opt = Some(1);
-    /// opt.unwrap();
-    /// ```
-    ///
-    /// Better:
-    ///
-    /// ```rust
-    /// let opt = Some(1);
-    /// opt.expect("more helpful message");
-    /// ```
-    pub OPTION_UNWRAP_USED,
-    restriction,
-    "using `Option.unwrap()`, which should at least get a better message using `expect()`"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for `.unwrap()` calls on `Result`s.
-    ///
-    /// **Why is this bad?** `result.unwrap()` will let the thread panic on `Err`
-    /// values. Normally, you want to implement more sophisticated error handling,
+    /// `result.unwrap()` will let the thread panic on `Err` values.
+    /// Normally, you want to implement more sophisticated error handling,
     /// and propagate errors upwards with `?` operator.
     ///
     /// Even if you want to panic on errors, not all `Error`s implement good
@@ -75,23 +50,31 @@ declare_clippy_lint! {
     ///
     /// **Known problems:** None.
     ///
-    /// **Example:**
-    /// Using unwrap on an `Result`:
-    ///
+    /// **Examples:**
     /// ```rust
-    /// let res: Result<usize, ()> = Ok(1);
-    /// res.unwrap();
+    /// # let opt = Some(1);
+    ///
+    /// // Bad
+    /// opt.unwrap();
+    ///
+    /// // Good
+    /// opt.expect("more helpful message");
     /// ```
     ///
-    /// Better:
+    /// // or
     ///
     /// ```rust
-    /// let res: Result<usize, ()> = Ok(1);
+    /// # let res: Result<usize, ()> = Ok(1);
+    ///
+    /// // Bad
+    /// res.unwrap();
+    ///
+    /// // Good
     /// res.expect("more helpful message");
     /// ```
-    pub RESULT_UNWRAP_USED,
+    pub UNWRAP_USED,
     restriction,
-    "using `Result.unwrap()`, which might be better handled"
+    "using `.unwrap()` on `Result` or `Option`, which should at least get a better message using `expect()`"
 }
 
 declare_clippy_lint! {
@@ -1267,8 +1250,7 @@ declare_clippy_lint! {
 }
 
 declare_lint_pass!(Methods => [
-    OPTION_UNWRAP_USED,
-    RESULT_UNWRAP_USED,
+    UNWRAP_USED,
     OPTION_EXPECT_USED,
     RESULT_EXPECT_USED,
     SHOULD_IMPLEMENT_TRAIT,
@@ -2397,9 +2379,9 @@ fn lint_unwrap(cx: &LateContext<'_, '_>, expr: &hir::Expr<'_>, unwrap_args: &[hi
     let obj_ty = walk_ptrs_ty(cx.tables.expr_ty(&unwrap_args[0]));
 
     let mess = if is_type_diagnostic_item(cx, obj_ty, sym!(option_type)) {
-        Some((OPTION_UNWRAP_USED, "an Option", "None"))
+        Some((UNWRAP_USED, "an Option", "None"))
     } else if is_type_diagnostic_item(cx, obj_ty, sym!(result_type)) {
-        Some((RESULT_UNWRAP_USED, "a Result", "Err"))
+        Some((UNWRAP_USED, "a Result", "Err"))
     } else {
         None
     };
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index d3bd9f66e38..5cbf3ef028c 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -1627,13 +1627,6 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
         deprecation: None,
         module: "types",
     },
-    Lint {
-        name: "option_unwrap_used",
-        group: "restriction",
-        desc: "using `Option.unwrap()`, which should at least get a better message using `expect()`",
-        deprecation: None,
-        module: "methods",
-    },
     Lint {
         name: "or_fun_call",
         group: "perf",
@@ -2404,6 +2397,13 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
         deprecation: None,
         module: "returns",
     },
+    Lint {
+        name: "unwrap_used",
+        group: "restriction",
+        desc: "using `.unwrap()` on `Result` or `Option`, which should at least get a better message using `expect()`",
+        deprecation: None,
+        module: "methods",
+    },
     Lint {
         name: "use_debug",
         group: "restriction",
diff --git a/tests/ui/unwrap.rs b/tests/ui/unwrap.rs
index fcd1fcd14d4..a4a3cd1d379 100644
--- a/tests/ui/unwrap.rs
+++ b/tests/ui/unwrap.rs
@@ -1,4 +1,4 @@
-#![warn(clippy::option_unwrap_used, clippy::result_unwrap_used)]
+#![warn(clippy::unwrap_used)]
 
 fn unwrap_option() {
     let opt = Some(0);
diff --git a/tests/ui/unwrap.stderr b/tests/ui/unwrap.stderr
index b90ce68fa97..4f0858005f6 100644
--- a/tests/ui/unwrap.stderr
+++ b/tests/ui/unwrap.stderr
@@ -4,7 +4,7 @@ error: used `unwrap()` on `an Option` value
 LL |     let _ = opt.unwrap();
    |             ^^^^^^^^^^^^
    |
-   = note: `-D clippy::option-unwrap-used` implied by `-D warnings`
+   = note: `-D clippy::unwrap-used` implied by `-D warnings`
    = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
 
 error: used `unwrap()` on `a Result` value
@@ -13,7 +13,6 @@ error: used `unwrap()` on `a Result` value
 LL |     let _ = res.unwrap();
    |             ^^^^^^^^^^^^
    |
-   = note: `-D clippy::result-unwrap-used` implied by `-D warnings`
    = help: if you don't want to handle the `Err` case gracefully, consider using `expect()` to provide a better panic message
 
 error: aborting due to 2 previous errors
-- 
cgit 1.4.1-3-g733a5


From 0e8be599cd04a8566224c63eeb07f5fa04605702 Mon Sep 17 00:00:00 2001
From: ThibsG <Thibs@debian.com>
Date: Sun, 3 May 2020 13:32:17 +0200
Subject: Merge `option_expect_used` and `result_expect_used` lints into
 `expect_used` lint

---
 CHANGELOG.md                    |  3 +-
 clippy_lints/src/lib.rs         |  6 ++--
 clippy_lints/src/methods/mod.rs | 63 +++++++++++++++--------------------------
 src/lintlist/mod.rs             | 21 +++++---------
 tests/ui/expect.rs              |  2 +-
 tests/ui/expect.stderr          |  3 +-
 6 files changed, 35 insertions(+), 63 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 78f98bba2b4..4eeb71fa5c5 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1337,6 +1337,7 @@ Released 2018-09-13
 [`excessive_precision`]: https://rust-lang.github.io/rust-clippy/master/index.html#excessive_precision
 [`exit`]: https://rust-lang.github.io/rust-clippy/master/index.html#exit
 [`expect_fun_call`]: https://rust-lang.github.io/rust-clippy/master/index.html#expect_fun_call
+[`expect_used`]: https://rust-lang.github.io/rust-clippy/master/index.html#expect_used
 [`expl_impl_clone_on_copy`]: https://rust-lang.github.io/rust-clippy/master/index.html#expl_impl_clone_on_copy
 [`explicit_counter_loop`]: https://rust-lang.github.io/rust-clippy/master/index.html#explicit_counter_loop
 [`explicit_deref_methods`]: https://rust-lang.github.io/rust-clippy/master/index.html#explicit_deref_methods
@@ -1497,7 +1498,6 @@ Released 2018-09-13
 [`option_and_then_some`]: https://rust-lang.github.io/rust-clippy/master/index.html#option_and_then_some
 [`option_as_ref_deref`]: https://rust-lang.github.io/rust-clippy/master/index.html#option_as_ref_deref
 [`option_env_unwrap`]: https://rust-lang.github.io/rust-clippy/master/index.html#option_env_unwrap
-[`option_expect_used`]: https://rust-lang.github.io/rust-clippy/master/index.html#option_expect_used
 [`option_map_or_none`]: https://rust-lang.github.io/rust-clippy/master/index.html#option_map_or_none
 [`option_map_unit_fn`]: https://rust-lang.github.io/rust-clippy/master/index.html#option_map_unit_fn
 [`option_option`]: https://rust-lang.github.io/rust-clippy/master/index.html#option_option
@@ -1537,7 +1537,6 @@ Released 2018-09-13
 [`regex_macro`]: https://rust-lang.github.io/rust-clippy/master/index.html#regex_macro
 [`replace_consts`]: https://rust-lang.github.io/rust-clippy/master/index.html#replace_consts
 [`rest_pat_in_fully_bound_structs`]: https://rust-lang.github.io/rust-clippy/master/index.html#rest_pat_in_fully_bound_structs
-[`result_expect_used`]: https://rust-lang.github.io/rust-clippy/master/index.html#result_expect_used
 [`result_map_or_into_option`]: https://rust-lang.github.io/rust-clippy/master/index.html#result_map_or_into_option
 [`result_map_unit_fn`]: https://rust-lang.github.io/rust-clippy/master/index.html#result_map_unit_fn
 [`result_unwrap_used`]: https://rust-lang.github.io/rust-clippy/master/index.html#result_unwrap_used
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index bb3bc0b4545..eaef1f543d3 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -657,6 +657,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &methods::CLONE_ON_COPY,
         &methods::CLONE_ON_REF_PTR,
         &methods::EXPECT_FUN_CALL,
+        &methods::EXPECT_USED,
         &methods::FILETYPE_IS_FILE,
         &methods::FILTER_MAP,
         &methods::FILTER_MAP_NEXT,
@@ -678,10 +679,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &methods::OK_EXPECT,
         &methods::OPTION_AND_THEN_SOME,
         &methods::OPTION_AS_REF_DEREF,
-        &methods::OPTION_EXPECT_USED,
         &methods::OPTION_MAP_OR_NONE,
         &methods::OR_FUN_CALL,
-        &methods::RESULT_EXPECT_USED,
         &methods::RESULT_MAP_OR_INTO_OPTION,
         &methods::SEARCH_IS_SOME,
         &methods::SHOULD_IMPLEMENT_TRAIT,
@@ -1086,10 +1085,9 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&matches::WILDCARD_ENUM_MATCH_ARM),
         LintId::of(&mem_forget::MEM_FORGET),
         LintId::of(&methods::CLONE_ON_REF_PTR),
+        LintId::of(&methods::EXPECT_USED),
         LintId::of(&methods::FILETYPE_IS_FILE),
         LintId::of(&methods::GET_UNWRAP),
-        LintId::of(&methods::OPTION_EXPECT_USED),
-        LintId::of(&methods::RESULT_EXPECT_USED),
         LintId::of(&methods::UNWRAP_USED),
         LintId::of(&methods::WRONG_PUB_SELF_CONVENTION),
         LintId::of(&misc::FLOAT_CMP_CONST),
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 1af4d03c7a2..2e75de019b6 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -78,61 +78,45 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for `.expect()` calls on `Option`s.
+    /// **What it does:** Checks for `.expect()` calls on `Option`s and `Result`s.
     ///
-    /// **Why is this bad?** Usually it is better to handle the `None` case. Still,
-    ///  for a lot of quick-and-dirty code, `expect` is a good choice, which is why
-    ///  this lint is `Allow` by default.
+    /// **Why is this bad?** Usually it is better to handle the `None` or `Err` case.
+    /// Still, for a lot of quick-and-dirty code, `expect` is a good choice, which is why
+    /// this lint is `Allow` by default.
     ///
-    /// **Known problems:** None.
+    /// `result.expect()` will let the thread panic on `Err`
+    /// values. Normally, you want to implement more sophisticated error handling,
+    /// and propagate errors upwards with `?` operator.
     ///
-    /// **Example:**
+    /// **Known problems:** None.
     ///
-    /// Using expect on an `Option`:
+    /// **Examples:**
+    /// ```rust,ignore
+    /// # let opt = Some(1);
     ///
-    /// ```rust
-    /// let opt = Some(1);
+    /// // Bad
     /// opt.expect("one");
-    /// ```
-    ///
-    /// Better:
     ///
-    /// ```rust,ignore
+    /// // Good
     /// let opt = Some(1);
     /// opt?;
     /// ```
-    pub OPTION_EXPECT_USED,
-    restriction,
-    "using `Option.expect()`, which might be better handled"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for `.expect()` calls on `Result`s.
-    ///
-    /// **Why is this bad?** `result.expect()` will let the thread panic on `Err`
-    /// values. Normally, you want to implement more sophisticated error handling,
-    /// and propagate errors upwards with `?` operator.
-    ///
-    /// **Known problems:** None.
     ///
-    /// **Example:**
-    /// Using expect on an `Result`:
+    /// // or
     ///
     /// ```rust
-    /// let res: Result<usize, ()> = Ok(1);
-    /// res.expect("one");
-    /// ```
+    /// # let res: Result<usize, ()> = Ok(1);
     ///
-    /// Better:
+    /// // Bad
+    /// res.expect("one");
     ///
-    /// ```rust
-    /// let res: Result<usize, ()> = Ok(1);
+    /// // Good
     /// res?;
     /// # Ok::<(), ()>(())
     /// ```
-    pub RESULT_EXPECT_USED,
+    pub EXPECT_USED,
     restriction,
-    "using `Result.expect()`, which might be better handled"
+    "using `.expect()` on `Result` or `Option`, which might be better handled"
 }
 
 declare_clippy_lint! {
@@ -1251,8 +1235,7 @@ declare_clippy_lint! {
 
 declare_lint_pass!(Methods => [
     UNWRAP_USED,
-    OPTION_EXPECT_USED,
-    RESULT_EXPECT_USED,
+    EXPECT_USED,
     SHOULD_IMPLEMENT_TRAIT,
     WRONG_SELF_CONVENTION,
     WRONG_PUB_SELF_CONVENTION,
@@ -2407,9 +2390,9 @@ fn lint_expect(cx: &LateContext<'_, '_>, expr: &hir::Expr<'_>, expect_args: &[hi
     let obj_ty = walk_ptrs_ty(cx.tables.expr_ty(&expect_args[0]));
 
     let mess = if is_type_diagnostic_item(cx, obj_ty, sym!(option_type)) {
-        Some((OPTION_EXPECT_USED, "an Option", "None"))
+        Some((EXPECT_USED, "an Option", "None"))
     } else if is_type_diagnostic_item(cx, obj_ty, sym!(result_type)) {
-        Some((RESULT_EXPECT_USED, "a Result", "Err"))
+        Some((EXPECT_USED, "a Result", "Err"))
     } else {
         None
     };
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index 5cbf3ef028c..4e79ce96bb5 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -514,6 +514,13 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
         deprecation: None,
         module: "methods",
     },
+    Lint {
+        name: "expect_used",
+        group: "restriction",
+        desc: "using `.expect()` on `Result` or `Option`, which might be better handled",
+        deprecation: None,
+        module: "methods",
+    },
     Lint {
         name: "expl_impl_clone_on_copy",
         group: "pedantic",
@@ -1599,13 +1606,6 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
         deprecation: None,
         module: "option_env_unwrap",
     },
-    Lint {
-        name: "option_expect_used",
-        group: "restriction",
-        desc: "using `Option.expect()`, which might be better handled",
-        deprecation: None,
-        module: "methods",
-    },
     Lint {
         name: "option_map_or_none",
         group: "style",
@@ -1865,13 +1865,6 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
         deprecation: None,
         module: "matches",
     },
-    Lint {
-        name: "result_expect_used",
-        group: "restriction",
-        desc: "using `Result.expect()`, which might be better handled",
-        deprecation: None,
-        module: "methods",
-    },
     Lint {
         name: "result_map_or_into_option",
         group: "style",
diff --git a/tests/ui/expect.rs b/tests/ui/expect.rs
index 0bd4252c49a..1073acf6f0c 100644
--- a/tests/ui/expect.rs
+++ b/tests/ui/expect.rs
@@ -1,4 +1,4 @@
-#![warn(clippy::option_expect_used, clippy::result_expect_used)]
+#![warn(clippy::expect_used)]
 
 fn expect_option() {
     let opt = Some(0);
diff --git a/tests/ui/expect.stderr b/tests/ui/expect.stderr
index adf9f4f1921..9d3fc7df15c 100644
--- a/tests/ui/expect.stderr
+++ b/tests/ui/expect.stderr
@@ -4,7 +4,7 @@ error: used `expect()` on `an Option` value
 LL |     let _ = opt.expect("");
    |             ^^^^^^^^^^^^^^
    |
-   = note: `-D clippy::option-expect-used` implied by `-D warnings`
+   = note: `-D clippy::expect-used` implied by `-D warnings`
    = help: if this value is an `None`, it will panic
 
 error: used `expect()` on `a Result` value
@@ -13,7 +13,6 @@ error: used `expect()` on `a Result` value
 LL |     let _ = res.expect("");
    |             ^^^^^^^^^^^^^^
    |
-   = note: `-D clippy::result-expect-used` implied by `-D warnings`
    = help: if this value is an `Err`, it will panic
 
 error: aborting due to 2 previous errors
-- 
cgit 1.4.1-3-g733a5


From adbdf7549c6b24c37629eabdc4be0346e0c8fd56 Mon Sep 17 00:00:00 2001
From: ThibsG <Thibs@debian.com>
Date: Sun, 3 May 2020 15:16:00 +0200
Subject: Merge `for_loop_over_option` and `for_loop_over_result` lints into
 `for_loop_over_fallible` lint

---
 CHANGELOG.md                                |  3 +-
 clippy_lints/src/lib.rs                     |  9 ++--
 clippy_lints/src/loops.rs                   | 64 +++++++++++--------------
 src/lintlist/mod.rs                         | 11 +----
 tests/ui/for_loop_over_fallible.rs          | 57 +++++++++++++++++++++++
 tests/ui/for_loop_over_fallible.stderr      | 71 ++++++++++++++++++++++++++++
 tests/ui/for_loop_over_option_result.rs     | 59 -----------------------
 tests/ui/for_loop_over_option_result.stderr | 72 -----------------------------
 8 files changed, 161 insertions(+), 185 deletions(-)
 create mode 100644 tests/ui/for_loop_over_fallible.rs
 create mode 100644 tests/ui/for_loop_over_fallible.stderr
 delete mode 100644 tests/ui/for_loop_over_option_result.rs
 delete mode 100644 tests/ui/for_loop_over_option_result.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 4eeb71fa5c5..3f9486e0972 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1361,8 +1361,7 @@ Released 2018-09-13
 [`fn_to_numeric_cast`]: https://rust-lang.github.io/rust-clippy/master/index.html#fn_to_numeric_cast
 [`fn_to_numeric_cast_with_truncation`]: https://rust-lang.github.io/rust-clippy/master/index.html#fn_to_numeric_cast_with_truncation
 [`for_kv_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#for_kv_map
-[`for_loop_over_option`]: https://rust-lang.github.io/rust-clippy/master/index.html#for_loop_over_option
-[`for_loop_over_result`]: https://rust-lang.github.io/rust-clippy/master/index.html#for_loop_over_result
+[`for_loop_over_fallible`]: https://rust-lang.github.io/rust-clippy/master/index.html#for_loop_over_fallible
 [`forget_copy`]: https://rust-lang.github.io/rust-clippy/master/index.html#forget_copy
 [`forget_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#forget_ref
 [`future_not_send`]: https://rust-lang.github.io/rust-clippy/master/index.html#future_not_send
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index eaef1f543d3..8de94d19d31 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -615,8 +615,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &loops::EXPLICIT_INTO_ITER_LOOP,
         &loops::EXPLICIT_ITER_LOOP,
         &loops::FOR_KV_MAP,
-        &loops::FOR_LOOP_OVER_OPTION,
-        &loops::FOR_LOOP_OVER_RESULT,
+        &loops::FOR_LOOP_OVER_FALLIBLE,
         &loops::ITER_NEXT_LOOP,
         &loops::MANUAL_MEMCPY,
         &loops::MUT_RANGE_BOUND,
@@ -1265,8 +1264,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&loops::EMPTY_LOOP),
         LintId::of(&loops::EXPLICIT_COUNTER_LOOP),
         LintId::of(&loops::FOR_KV_MAP),
-        LintId::of(&loops::FOR_LOOP_OVER_OPTION),
-        LintId::of(&loops::FOR_LOOP_OVER_RESULT),
+        LintId::of(&loops::FOR_LOOP_OVER_FALLIBLE),
         LintId::of(&loops::ITER_NEXT_LOOP),
         LintId::of(&loops::MANUAL_MEMCPY),
         LintId::of(&loops::MUT_RANGE_BOUND),
@@ -1641,8 +1639,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&inline_fn_without_body::INLINE_FN_WITHOUT_BODY),
         LintId::of(&let_underscore::LET_UNDERSCORE_LOCK),
         LintId::of(&literal_representation::MISTYPED_LITERAL_SUFFIXES),
-        LintId::of(&loops::FOR_LOOP_OVER_OPTION),
-        LintId::of(&loops::FOR_LOOP_OVER_RESULT),
+        LintId::of(&loops::FOR_LOOP_OVER_FALLIBLE),
         LintId::of(&loops::ITER_NEXT_LOOP),
         LintId::of(&loops::NEVER_LOOP),
         LintId::of(&loops::WHILE_IMMUTABLE_CONDITION),
diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 0bc6b70855b..da6793a69d6 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -168,7 +168,7 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for `for` loops over `Option` values.
+    /// **What it does:** Checks for `for` loops over `Option` or `Result` values.
     ///
     /// **Why is this bad?** Readability. This is more clearly expressed as an `if
     /// let`.
@@ -176,47 +176,38 @@ declare_clippy_lint! {
     /// **Known problems:** None.
     ///
     /// **Example:**
-    /// ```ignore
-    /// for x in option {
-    ///     ..
+    /// ```rust
+    /// # let opt = Some(1);
+    ///
+    /// // Bad
+    /// for x in opt {
+    ///     // ..
     /// }
-    /// ```
     ///
-    /// This should be
-    /// ```ignore
-    /// if let Some(x) = option {
-    ///     ..
+    /// // Good
+    /// if let Some(x) = opt {
+    ///     // ..
     /// }
     /// ```
-    pub FOR_LOOP_OVER_OPTION,
-    correctness,
-    "for-looping over an `Option`, which is more clearly expressed as an `if let`"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for `for` loops over `Result` values.
     ///
-    /// **Why is this bad?** Readability. This is more clearly expressed as an `if
-    /// let`.
+    /// // or
     ///
-    /// **Known problems:** None.
+    /// ```rust
+    /// # let res: Result<i32, std::io::Error> = Ok(1);
     ///
-    /// **Example:**
-    /// ```ignore
-    /// for x in result {
-    ///     ..
+    /// // Bad
+    /// for x in &res {
+    ///     // ..
     /// }
-    /// ```
     ///
-    /// This should be
-    /// ```ignore
-    /// if let Ok(x) = result {
-    ///     ..
+    /// // Good
+    /// if let Ok(x) = res {
+    ///     // ..
     /// }
     /// ```
-    pub FOR_LOOP_OVER_RESULT,
+    pub FOR_LOOP_OVER_FALLIBLE,
     correctness,
-    "for-looping over a `Result`, which is more clearly expressed as an `if let`"
+    "for-looping over an `Option` or a `Result`, which is more clearly expressed as an `if let`"
 }
 
 declare_clippy_lint! {
@@ -435,8 +426,7 @@ declare_lint_pass!(Loops => [
     EXPLICIT_ITER_LOOP,
     EXPLICIT_INTO_ITER_LOOP,
     ITER_NEXT_LOOP,
-    FOR_LOOP_OVER_RESULT,
-    FOR_LOOP_OVER_OPTION,
+    FOR_LOOP_OVER_FALLIBLE,
     WHILE_LET_LOOP,
     NEEDLESS_COLLECT,
     EXPLICIT_COUNTER_LOOP,
@@ -1283,7 +1273,7 @@ fn check_for_loop_arg(cx: &LateContext<'_, '_>, pat: &Pat<'_>, arg: &Expr<'_>, e
                     ITER_NEXT_LOOP,
                     expr.span,
                     "you are iterating over `Iterator::next()` which is an Option; this will compile but is \
-                     probably not what you want",
+                    probably not what you want",
                 );
                 next_loop_linted = true;
             }
@@ -1300,11 +1290,11 @@ fn check_arg_type(cx: &LateContext<'_, '_>, pat: &Pat<'_>, arg: &Expr<'_>) {
     if is_type_diagnostic_item(cx, ty, sym!(option_type)) {
         span_lint_and_help(
             cx,
-            FOR_LOOP_OVER_OPTION,
+            FOR_LOOP_OVER_FALLIBLE,
             arg.span,
             &format!(
                 "for loop over `{0}`, which is an `Option`. This is more readably written as an \
-                 `if let` statement.",
+                `if let` statement.",
                 snippet(cx, arg.span, "_")
             ),
             None,
@@ -1317,11 +1307,11 @@ fn check_arg_type(cx: &LateContext<'_, '_>, pat: &Pat<'_>, arg: &Expr<'_>) {
     } else if is_type_diagnostic_item(cx, ty, sym!(result_type)) {
         span_lint_and_help(
             cx,
-            FOR_LOOP_OVER_RESULT,
+            FOR_LOOP_OVER_FALLIBLE,
             arg.span,
             &format!(
                 "for loop over `{0}`, which is a `Result`. This is more readably written as an \
-                 `if let` statement.",
+                `if let` statement.",
                 snippet(cx, arg.span, "_")
             ),
             None,
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index 4e79ce96bb5..0ea0f55a381 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -676,16 +676,9 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
         module: "loops",
     },
     Lint {
-        name: "for_loop_over_option",
+        name: "for_loop_over_fallible",
         group: "correctness",
-        desc: "for-looping over an `Option`, which is more clearly expressed as an `if let`",
-        deprecation: None,
-        module: "loops",
-    },
-    Lint {
-        name: "for_loop_over_result",
-        group: "correctness",
-        desc: "for-looping over a `Result`, which is more clearly expressed as an `if let`",
+        desc: "for-looping over an `Option` or a `Result`, which is more clearly expressed as an `if let`",
         deprecation: None,
         module: "loops",
     },
diff --git a/tests/ui/for_loop_over_fallible.rs b/tests/ui/for_loop_over_fallible.rs
new file mode 100644
index 00000000000..e52468cdd4b
--- /dev/null
+++ b/tests/ui/for_loop_over_fallible.rs
@@ -0,0 +1,57 @@
+#![warn(clippy::for_loop_over_fallible)]
+
+fn for_loop_over_fallible() {
+    let option = Some(1);
+    let result = option.ok_or("x not found");
+    let v = vec![0, 1, 2];
+
+    // check over an `Option`
+    for x in option {
+        println!("{}", x);
+    }
+
+    // check over a `Result`
+    for x in result {
+        println!("{}", x);
+    }
+
+    for x in option.ok_or("x not found") {
+        println!("{}", x);
+    }
+
+    // make sure LOOP_OVER_NEXT lint takes clippy::precedence when next() is the last call
+    // in the chain
+    for x in v.iter().next() {
+        println!("{}", x);
+    }
+
+    // make sure we lint when next() is not the last call in the chain
+    for x in v.iter().next().and(Some(0)) {
+        println!("{}", x);
+    }
+
+    for x in v.iter().next().ok_or("x not found") {
+        println!("{}", x);
+    }
+
+    // check for false positives
+
+    // for loop false positive
+    for x in v {
+        println!("{}", x);
+    }
+
+    // while let false positive for Option
+    while let Some(x) = option {
+        println!("{}", x);
+        break;
+    }
+
+    // while let false positive for Result
+    while let Ok(x) = result {
+        println!("{}", x);
+        break;
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/for_loop_over_fallible.stderr b/tests/ui/for_loop_over_fallible.stderr
new file mode 100644
index 00000000000..4ce9a144ad8
--- /dev/null
+++ b/tests/ui/for_loop_over_fallible.stderr
@@ -0,0 +1,71 @@
+error: for loop over `option`, which is an `Option`. This is more readably written as an `if let` statement.
+  --> $DIR/for_loop_over_fallible.rs:9:14
+   |
+LL |     for x in option {
+   |              ^^^^^^
+   |
+   = note: `-D clippy::for-loop-over-fallible` implied by `-D warnings`
+   = help: consider replacing `for x in option` with `if let Some(x) = option`
+
+error: for loop over `result`, which is a `Result`. This is more readably written as an `if let` statement.
+  --> $DIR/for_loop_over_fallible.rs:14:14
+   |
+LL |     for x in result {
+   |              ^^^^^^
+   |
+   = help: consider replacing `for x in result` with `if let Ok(x) = result`
+
+error: for loop over `option.ok_or("x not found")`, which is a `Result`. This is more readably written as an `if let` statement.
+  --> $DIR/for_loop_over_fallible.rs:18:14
+   |
+LL |     for x in option.ok_or("x not found") {
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider replacing `for x in option.ok_or("x not found")` with `if let Ok(x) = option.ok_or("x not found")`
+
+error: you are iterating over `Iterator::next()` which is an Option; this will compile but is probably not what you want
+  --> $DIR/for_loop_over_fallible.rs:24:14
+   |
+LL |     for x in v.iter().next() {
+   |              ^^^^^^^^^^^^^^^
+   |
+   = note: `#[deny(clippy::iter_next_loop)]` on by default
+
+error: for loop over `v.iter().next().and(Some(0))`, which is an `Option`. This is more readably written as an `if let` statement.
+  --> $DIR/for_loop_over_fallible.rs:29:14
+   |
+LL |     for x in v.iter().next().and(Some(0)) {
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider replacing `for x in v.iter().next().and(Some(0))` with `if let Some(x) = v.iter().next().and(Some(0))`
+
+error: for loop over `v.iter().next().ok_or("x not found")`, which is a `Result`. This is more readably written as an `if let` statement.
+  --> $DIR/for_loop_over_fallible.rs:33:14
+   |
+LL |     for x in v.iter().next().ok_or("x not found") {
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider replacing `for x in v.iter().next().ok_or("x not found")` with `if let Ok(x) = v.iter().next().ok_or("x not found")`
+
+error: this loop never actually loops
+  --> $DIR/for_loop_over_fallible.rs:45:5
+   |
+LL | /     while let Some(x) = option {
+LL | |         println!("{}", x);
+LL | |         break;
+LL | |     }
+   | |_____^
+   |
+   = note: `#[deny(clippy::never_loop)]` on by default
+
+error: this loop never actually loops
+  --> $DIR/for_loop_over_fallible.rs:51:5
+   |
+LL | /     while let Ok(x) = result {
+LL | |         println!("{}", x);
+LL | |         break;
+LL | |     }
+   | |_____^
+
+error: aborting due to 8 previous errors
+
diff --git a/tests/ui/for_loop_over_option_result.rs b/tests/ui/for_loop_over_option_result.rs
deleted file mode 100644
index 6b207b26b6b..00000000000
--- a/tests/ui/for_loop_over_option_result.rs
+++ /dev/null
@@ -1,59 +0,0 @@
-#![warn(clippy::for_loop_over_option, clippy::for_loop_over_result)]
-
-/// Tests for_loop_over_result and for_loop_over_option
-
-fn for_loop_over_option_and_result() {
-    let option = Some(1);
-    let result = option.ok_or("x not found");
-    let v = vec![0, 1, 2];
-
-    // check FOR_LOOP_OVER_OPTION lint
-    for x in option {
-        println!("{}", x);
-    }
-
-    // check FOR_LOOP_OVER_RESULT lint
-    for x in result {
-        println!("{}", x);
-    }
-
-    for x in option.ok_or("x not found") {
-        println!("{}", x);
-    }
-
-    // make sure LOOP_OVER_NEXT lint takes clippy::precedence when next() is the last call
-    // in the chain
-    for x in v.iter().next() {
-        println!("{}", x);
-    }
-
-    // make sure we lint when next() is not the last call in the chain
-    for x in v.iter().next().and(Some(0)) {
-        println!("{}", x);
-    }
-
-    for x in v.iter().next().ok_or("x not found") {
-        println!("{}", x);
-    }
-
-    // check for false positives
-
-    // for loop false positive
-    for x in v {
-        println!("{}", x);
-    }
-
-    // while let false positive for Option
-    while let Some(x) = option {
-        println!("{}", x);
-        break;
-    }
-
-    // while let false positive for Result
-    while let Ok(x) = result {
-        println!("{}", x);
-        break;
-    }
-}
-
-fn main() {}
diff --git a/tests/ui/for_loop_over_option_result.stderr b/tests/ui/for_loop_over_option_result.stderr
deleted file mode 100644
index 194a0bfec5b..00000000000
--- a/tests/ui/for_loop_over_option_result.stderr
+++ /dev/null
@@ -1,72 +0,0 @@
-error: for loop over `option`, which is an `Option`. This is more readably written as an `if let` statement.
-  --> $DIR/for_loop_over_option_result.rs:11:14
-   |
-LL |     for x in option {
-   |              ^^^^^^
-   |
-   = note: `-D clippy::for-loop-over-option` implied by `-D warnings`
-   = help: consider replacing `for x in option` with `if let Some(x) = option`
-
-error: for loop over `result`, which is a `Result`. This is more readably written as an `if let` statement.
-  --> $DIR/for_loop_over_option_result.rs:16:14
-   |
-LL |     for x in result {
-   |              ^^^^^^
-   |
-   = note: `-D clippy::for-loop-over-result` implied by `-D warnings`
-   = help: consider replacing `for x in result` with `if let Ok(x) = result`
-
-error: for loop over `option.ok_or("x not found")`, which is a `Result`. This is more readably written as an `if let` statement.
-  --> $DIR/for_loop_over_option_result.rs:20:14
-   |
-LL |     for x in option.ok_or("x not found") {
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: consider replacing `for x in option.ok_or("x not found")` with `if let Ok(x) = option.ok_or("x not found")`
-
-error: you are iterating over `Iterator::next()` which is an Option; this will compile but is probably not what you want
-  --> $DIR/for_loop_over_option_result.rs:26:14
-   |
-LL |     for x in v.iter().next() {
-   |              ^^^^^^^^^^^^^^^
-   |
-   = note: `#[deny(clippy::iter_next_loop)]` on by default
-
-error: for loop over `v.iter().next().and(Some(0))`, which is an `Option`. This is more readably written as an `if let` statement.
-  --> $DIR/for_loop_over_option_result.rs:31:14
-   |
-LL |     for x in v.iter().next().and(Some(0)) {
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: consider replacing `for x in v.iter().next().and(Some(0))` with `if let Some(x) = v.iter().next().and(Some(0))`
-
-error: for loop over `v.iter().next().ok_or("x not found")`, which is a `Result`. This is more readably written as an `if let` statement.
-  --> $DIR/for_loop_over_option_result.rs:35:14
-   |
-LL |     for x in v.iter().next().ok_or("x not found") {
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: consider replacing `for x in v.iter().next().ok_or("x not found")` with `if let Ok(x) = v.iter().next().ok_or("x not found")`
-
-error: this loop never actually loops
-  --> $DIR/for_loop_over_option_result.rs:47:5
-   |
-LL | /     while let Some(x) = option {
-LL | |         println!("{}", x);
-LL | |         break;
-LL | |     }
-   | |_____^
-   |
-   = note: `#[deny(clippy::never_loop)]` on by default
-
-error: this loop never actually loops
-  --> $DIR/for_loop_over_option_result.rs:53:5
-   |
-LL | /     while let Ok(x) = result {
-LL | |         println!("{}", x);
-LL | |         break;
-LL | |     }
-   | |_____^
-
-error: aborting due to 8 previous errors
-
-- 
cgit 1.4.1-3-g733a5


From 95399f8f941b89785c6e9d94e0bc32ff5d43ba06 Mon Sep 17 00:00:00 2001
From: David Tolnay <dtolnay@gmail.com>
Date: Thu, 14 May 2020 09:57:36 -0700
Subject: Downgrade useless_let_if_seq to nursery

---
 clippy_lints/src/let_if_seq.rs | 2 +-
 clippy_lints/src/lib.rs        | 3 +--
 src/lintlist/mod.rs            | 2 +-
 3 files changed, 3 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/let_if_seq.rs b/clippy_lints/src/let_if_seq.rs
index 398a3103a03..d7bf8a14768 100644
--- a/clippy_lints/src/let_if_seq.rs
+++ b/clippy_lints/src/let_if_seq.rs
@@ -50,7 +50,7 @@ declare_clippy_lint! {
     /// };
     /// ```
     pub USELESS_LET_IF_SEQ,
-    style,
+    nursery,
     "unidiomatic `let mut` declaration followed by initialization in `if`"
 }
 
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 0c4daeb731f..b241ac5559c 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1266,7 +1266,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&large_enum_variant::LARGE_ENUM_VARIANT),
         LintId::of(&len_zero::LEN_WITHOUT_IS_EMPTY),
         LintId::of(&len_zero::LEN_ZERO),
-        LintId::of(&let_if_seq::USELESS_LET_IF_SEQ),
         LintId::of(&let_underscore::LET_UNDERSCORE_LOCK),
         LintId::of(&lifetimes::EXTRA_UNUSED_LIFETIMES),
         LintId::of(&lifetimes::NEEDLESS_LIFETIMES),
@@ -1476,7 +1475,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&inherent_to_string::INHERENT_TO_STRING),
         LintId::of(&len_zero::LEN_WITHOUT_IS_EMPTY),
         LintId::of(&len_zero::LEN_ZERO),
-        LintId::of(&let_if_seq::USELESS_LET_IF_SEQ),
         LintId::of(&literal_representation::INCONSISTENT_DIGIT_GROUPING),
         LintId::of(&loops::EMPTY_LOOP),
         LintId::of(&loops::FOR_KV_MAP),
@@ -1728,6 +1726,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&floating_point_arithmetic::IMPRECISE_FLOPS),
         LintId::of(&floating_point_arithmetic::SUBOPTIMAL_FLOPS),
         LintId::of(&future_not_send::FUTURE_NOT_SEND),
+        LintId::of(&let_if_seq::USELESS_LET_IF_SEQ),
         LintId::of(&missing_const_for_fn::MISSING_CONST_FOR_FN),
         LintId::of(&mutable_debug_assertion::DEBUG_ASSERT_WITH_MUT_CALL),
         LintId::of(&mutex_atomic::MUTEX_INTEGER),
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index e1a6d4bdd31..e1c68b58b86 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -2469,7 +2469,7 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
     },
     Lint {
         name: "useless_let_if_seq",
-        group: "style",
+        group: "nursery",
         desc: "unidiomatic `let mut` declaration followed by initialization in `if`",
         deprecation: None,
         module: "let_if_seq",
-- 
cgit 1.4.1-3-g733a5


From 94e4b5ec316993200d75276b4e7c16a059bf3a57 Mon Sep 17 00:00:00 2001
From: Vardan Margaryan <v.t.margaryan@gmail.com>
Date: Sun, 10 May 2020 00:08:41 +0300
Subject: Add the redundant_wildcard_enum_match lint

---
 CHANGELOG.md                                       |  1 +
 clippy_lints/src/lib.rs                            |  2 +
 clippy_lints/src/matches.rs                        | 48 ++++++++++++++++++++++
 src/lintlist/mod.rs                                |  7 ++++
 tests/ui/match_wildcard_for_single_variants.fixed  | 18 ++++++++
 tests/ui/match_wildcard_for_single_variants.rs     | 18 ++++++++
 tests/ui/match_wildcard_for_single_variants.stderr | 10 +++++
 7 files changed, 104 insertions(+)
 create mode 100644 tests/ui/match_wildcard_for_single_variants.fixed
 create mode 100644 tests/ui/match_wildcard_for_single_variants.rs
 create mode 100644 tests/ui/match_wildcard_for_single_variants.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index b25ef049356..d6298fec65a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1439,6 +1439,7 @@ Released 2018-09-13
 [`match_same_arms`]: https://rust-lang.github.io/rust-clippy/master/index.html#match_same_arms
 [`match_single_binding`]: https://rust-lang.github.io/rust-clippy/master/index.html#match_single_binding
 [`match_wild_err_arm`]: https://rust-lang.github.io/rust-clippy/master/index.html#match_wild_err_arm
+[`match_wildcard_for_single_variants`]: https://rust-lang.github.io/rust-clippy/master/index.html#match_wildcard_for_single_variants
 [`maybe_infinite_iter`]: https://rust-lang.github.io/rust-clippy/master/index.html#maybe_infinite_iter
 [`mem_discriminant_non_enum`]: https://rust-lang.github.io/rust-clippy/master/index.html#mem_discriminant_non_enum
 [`mem_forget`]: https://rust-lang.github.io/rust-clippy/master/index.html#mem_forget
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 0c4daeb731f..41046c18ed2 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -641,6 +641,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &matches::MATCH_OVERLAPPING_ARM,
         &matches::MATCH_REF_PATS,
         &matches::MATCH_SINGLE_BINDING,
+        &matches::MATCH_WILDCARD_FOR_SINGLE_VARIANTS,
         &matches::MATCH_WILD_ERR_ARM,
         &matches::REST_PAT_IN_FULLY_BOUND_STRUCTS,
         &matches::SINGLE_MATCH,
@@ -1147,6 +1148,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&macro_use::MACRO_USE_IMPORTS),
         LintId::of(&match_on_vec_items::MATCH_ON_VEC_ITEMS),
         LintId::of(&matches::MATCH_BOOL),
+        LintId::of(&matches::MATCH_WILDCARD_FOR_SINGLE_VARIANTS),
         LintId::of(&matches::SINGLE_MATCH_ELSE),
         LintId::of(&methods::FILTER_MAP),
         LintId::of(&methods::FILTER_MAP_NEXT),
diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index 8f86535ef1e..42a6c416619 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -229,6 +229,40 @@ declare_clippy_lint! {
     "a wildcard enum match arm using `_`"
 }
 
+declare_clippy_lint! {
+    /// **What it does:** Checks for wildcard enum matches for a single variant.
+    ///
+    /// **Why is this bad?** New enum variants added by library updates can be missed.
+    ///
+    /// **Known problems:** Suggested replacements may not use correct path to enum
+    /// if it's not present in the current scope.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// # enum Foo { A, B, C }
+    /// # let x = Foo::B;
+    /// match x {
+    ///     Foo::A => {},
+    ///     Foo::B => {},
+    ///     _ => {},
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// # enum Foo { A, B, C }
+    /// # let x = Foo::B;
+    /// match x {
+    ///     Foo::A => {},
+    ///     Foo::B => {},
+    ///     Foo::C => {},
+    /// }
+    /// ```
+    pub MATCH_WILDCARD_FOR_SINGLE_VARIANTS,
+    pedantic,
+    "a wildcard enum match for a single variant"
+}
+
 declare_clippy_lint! {
     /// **What it does:** Checks for wildcard pattern used with others patterns in same match arm.
     ///
@@ -356,6 +390,7 @@ impl_lint_pass!(Matches => [
     MATCH_WILD_ERR_ARM,
     MATCH_AS_REF,
     WILDCARD_ENUM_MATCH_ARM,
+    MATCH_WILDCARD_FOR_SINGLE_VARIANTS,
     WILDCARD_IN_OR_PATTERNS,
     MATCH_SINGLE_BINDING,
     INFALLIBLE_DESTRUCTURING_MATCH,
@@ -766,6 +801,19 @@ fn check_wild_enum_match(cx: &LateContext<'_, '_>, ex: &Expr<'_>, arms: &[Arm<'_
             }
         }
 
+        if suggestion.len() == 1 {
+            // No need to check for non-exhaustive enum as in that case len would be greater than 1
+            span_lint_and_sugg(
+                cx,
+                MATCH_WILDCARD_FOR_SINGLE_VARIANTS,
+                wildcard_span,
+                message,
+                "try this",
+                suggestion[0].clone(),
+                Applicability::MachineApplicable,
+            )
+        };
+
         span_lint_and_sugg(
             cx,
             WILDCARD_ENUM_MATCH_ARM,
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index e1a6d4bdd31..250a7c09f78 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -1200,6 +1200,13 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
         deprecation: None,
         module: "matches",
     },
+    Lint {
+        name: "match_wildcard_for_single_variants",
+        group: "pedantic",
+        desc: "a wildcard enum match for a single variant",
+        deprecation: None,
+        module: "matches",
+    },
     Lint {
         name: "maybe_infinite_iter",
         group: "pedantic",
diff --git a/tests/ui/match_wildcard_for_single_variants.fixed b/tests/ui/match_wildcard_for_single_variants.fixed
new file mode 100644
index 00000000000..5f1a559f591
--- /dev/null
+++ b/tests/ui/match_wildcard_for_single_variants.fixed
@@ -0,0 +1,18 @@
+// run-rustfix
+
+#![warn(clippy::match_wildcard_for_single_variants)]
+#![allow(dead_code)]
+
+enum Foo {
+    A,
+    B,
+    C,
+}
+
+fn main() {
+    match Foo::A {
+        Foo::A => {},
+        Foo::B => {},
+        Foo::C => {},
+    }
+}
diff --git a/tests/ui/match_wildcard_for_single_variants.rs b/tests/ui/match_wildcard_for_single_variants.rs
new file mode 100644
index 00000000000..1159f9e722d
--- /dev/null
+++ b/tests/ui/match_wildcard_for_single_variants.rs
@@ -0,0 +1,18 @@
+// run-rustfix
+
+#![warn(clippy::match_wildcard_for_single_variants)]
+#![allow(dead_code)]
+
+enum Foo {
+    A,
+    B,
+    C,
+}
+
+fn main() {
+    match Foo::A {
+        Foo::A => {},
+        Foo::B => {},
+        _ => {},
+    }
+}
diff --git a/tests/ui/match_wildcard_for_single_variants.stderr b/tests/ui/match_wildcard_for_single_variants.stderr
new file mode 100644
index 00000000000..128dd4808bf
--- /dev/null
+++ b/tests/ui/match_wildcard_for_single_variants.stderr
@@ -0,0 +1,10 @@
+error: wildcard match will miss any future added variants
+  --> $DIR/match_wildcard_for_single_variants.rs:16:9
+   |
+LL |         _ => {},
+   |         ^ help: try this: `Foo::C`
+   |
+   = note: `-D clippy::match-wildcard-for-single-variants` implied by `-D warnings`
+
+error: aborting due to previous error
+
-- 
cgit 1.4.1-3-g733a5


From 0ad9f7d651b52de4be6384c9b6dc893b389fd557 Mon Sep 17 00:00:00 2001
From: Vardan Margaryan <v.t.margaryan@gmail.com>
Date: Sun, 10 May 2020 18:33:12 +0300
Subject: Fix trivial cases of new match_wildcard_for_single_variants lint

---
 clippy_lints/src/float_literal.rs              | 2 +-
 clippy_lints/src/misc_early.rs                 | 2 +-
 clippy_lints/src/missing_const_for_fn.rs       | 2 +-
 clippy_lints/src/needless_pass_by_value.rs     | 2 +-
 clippy_lints/src/trivially_copy_pass_by_ref.rs | 2 +-
 tests/compile-test.rs                          | 2 +-
 6 files changed, 6 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/float_literal.rs b/clippy_lints/src/float_literal.rs
index 3a52b1d3fc2..4c604cd0107 100644
--- a/clippy_lints/src/float_literal.rs
+++ b/clippy_lints/src/float_literal.rs
@@ -77,7 +77,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for FloatLiteral {
                 let type_suffix = match lit_float_ty {
                     LitFloatType::Suffixed(FloatTy::F32) => Some("f32"),
                     LitFloatType::Suffixed(FloatTy::F64) => Some("f64"),
-                    _ => None
+                    LitFloatType::Unsuffixed => None
                 };
                 let (is_whole, mut float_str) = match fty {
                     FloatTy::F32 => {
diff --git a/clippy_lints/src/misc_early.rs b/clippy_lints/src/misc_early.rs
index 62ee051624b..552222eba2e 100644
--- a/clippy_lints/src/misc_early.rs
+++ b/clippy_lints/src/misc_early.rs
@@ -379,7 +379,7 @@ impl EarlyLintPass for MiscEarlyLints {
             let left_binding = match left {
                 BindingMode::ByRef(Mutability::Mut) => "ref mut ",
                 BindingMode::ByRef(Mutability::Not) => "ref ",
-                _ => "",
+                BindingMode::ByValue(..) => "",
             };
 
             if let PatKind::Wild = right.kind {
diff --git a/clippy_lints/src/missing_const_for_fn.rs b/clippy_lints/src/missing_const_for_fn.rs
index 4301157e164..9cfc8d19134 100644
--- a/clippy_lints/src/missing_const_for_fn.rs
+++ b/clippy_lints/src/missing_const_for_fn.rs
@@ -113,7 +113,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MissingConstForFn {
                     return;
                 }
             },
-            _ => return,
+            FnKind::Closure(..) => return,
         }
 
         let mir = cx.tcx.optimized_mir(def_id);
diff --git a/clippy_lints/src/needless_pass_by_value.rs b/clippy_lints/src/needless_pass_by_value.rs
index a21818701da..c099c553333 100644
--- a/clippy_lints/src/needless_pass_by_value.rs
+++ b/clippy_lints/src/needless_pass_by_value.rs
@@ -86,7 +86,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NeedlessPassByValue {
                 }
             },
             FnKind::Method(..) => (),
-            _ => return,
+            FnKind::Closure(..) => return,
         }
 
         // Exclude non-inherent impls
diff --git a/clippy_lints/src/trivially_copy_pass_by_ref.rs b/clippy_lints/src/trivially_copy_pass_by_ref.rs
index 2c101220c5d..8e0cb94317a 100644
--- a/clippy_lints/src/trivially_copy_pass_by_ref.rs
+++ b/clippy_lints/src/trivially_copy_pass_by_ref.rs
@@ -161,7 +161,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for TriviallyCopyPassByRef {
                 }
             },
             FnKind::Method(..) => (),
-            _ => return,
+            FnKind::Closure(..) => return,
         }
 
         // Exclude non-inherent impls
diff --git a/tests/compile-test.rs b/tests/compile-test.rs
index de2cf6d7873..a3df9d5ccbd 100644
--- a/tests/compile-test.rs
+++ b/tests/compile-test.rs
@@ -44,7 +44,7 @@ fn third_party_crates() -> String {
     for entry in fs::read_dir(dep_dir).unwrap() {
         let path = match entry {
             Ok(entry) => entry.path(),
-            _ => continue,
+            Err(_) => continue,
         };
         if let Some(name) = path.file_name().and_then(OsStr::to_str) {
             for dep in CRATES {
-- 
cgit 1.4.1-3-g733a5


From 494830797744c09d6de3b2b2452ab185d2204005 Mon Sep 17 00:00:00 2001
From: Vardan Margaryan <v.t.margaryan@gmail.com>
Date: Sun, 10 May 2020 18:34:29 +0300
Subject: Fix cases of match_wildcard_for_single_variants lint when it is
 spanned on Option

---
 clippy_lints/src/consts.rs                    | 9 +++++----
 clippy_lints/src/escape.rs                    | 4 ++--
 clippy_lints/src/floating_point_arithmetic.rs | 2 +-
 clippy_lints/src/loops.rs                     | 2 +-
 clippy_lints/src/misc.rs                      | 2 +-
 clippy_lints/src/modulo_arithmetic.rs         | 1 +
 clippy_lints/src/utils/mod.rs                 | 2 ++
 7 files changed, 13 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/consts.rs b/clippy_lints/src/consts.rs
index 81ddc8c0067..efb424bcb7b 100644
--- a/clippy_lints/src/consts.rs
+++ b/clippy_lints/src/consts.rs
@@ -139,6 +139,7 @@ impl Constant {
                 .find(|r| r.map_or(true, |o| o != Ordering::Equal))
                 .unwrap_or_else(|| Some(l.len().cmp(&r.len()))),
             (&Self::Repeat(ref lv, ref ls), &Self::Repeat(ref rv, ref rs)) => {
+                #[allow(clippy::match_wildcard_for_single_variants)]
                 match Self::partial_cmp(tcx, cmp_type, lv, rv) {
                     Some(Equal) => Some(ls.cmp(rs)),
                     x => x,
@@ -354,14 +355,14 @@ impl<'c, 'cc> ConstEvalLateContext<'c, 'cc> {
             (Some(Constant::Vec(vec)), Some(Constant::Int(index))) => match vec.get(index as usize) {
                 Some(Constant::F32(x)) => Some(Constant::F32(*x)),
                 Some(Constant::F64(x)) => Some(Constant::F64(*x)),
-                _ => None,
+                Some(_) | None => None,
             },
             (Some(Constant::Vec(vec)), _) => {
                 if !vec.is_empty() && vec.iter().all(|x| *x == vec[0]) {
                     match vec.get(0) {
                         Some(Constant::F32(x)) => Some(Constant::F32(*x)),
                         Some(Constant::F64(x)) => Some(Constant::F64(*x)),
-                        _ => None,
+                        Some(_) | None => None,
                     }
                 } else {
                     None
@@ -532,7 +533,7 @@ pub fn miri_to_const(result: &ty::Const<'_>) -> Option<Constant> {
                         })
                         .collect::<Option<Vec<Constant>>>()
                         .map(Constant::Vec),
-                    _ => None,
+                    Some(_) | None => None,
                 },
                 ty::Float(FloatTy::F64) => match miri_to_const(len) {
                     Some(Constant::Int(len)) => alloc
@@ -546,7 +547,7 @@ pub fn miri_to_const(result: &ty::Const<'_>) -> Option<Constant> {
                         })
                         .collect::<Option<Vec<Constant>>>()
                         .map(Constant::Vec),
-                    _ => None,
+                    Some(_) | None => None,
                 },
                 // FIXME: implement other array type conversions.
                 _ => None,
diff --git a/clippy_lints/src/escape.rs b/clippy_lints/src/escape.rs
index 1ec60a0e6e6..615afee33ef 100644
--- a/clippy_lints/src/escape.rs
+++ b/clippy_lints/src/escape.rs
@@ -95,12 +95,12 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for BoxedLocal {
 fn is_argument(map: rustc_middle::hir::map::Map<'_>, id: HirId) -> bool {
     match map.find(id) {
         Some(Node::Binding(_)) => (),
-        _ => return false,
+        Some(_) | None => return false,
     }
 
     match map.find(map.get_parent_node(id)) {
         Some(Node::Param(_)) => true,
-        _ => false,
+        Some(_) | None => false,
     }
 }
 
diff --git a/clippy_lints/src/floating_point_arithmetic.rs b/clippy_lints/src/floating_point_arithmetic.rs
index 86317fb8bd5..8c61b2f8664 100644
--- a/clippy_lints/src/floating_point_arithmetic.rs
+++ b/clippy_lints/src/floating_point_arithmetic.rs
@@ -410,7 +410,7 @@ fn is_zero(cx: &LateContext<'_, '_>, expr: &Expr<'_>) -> bool {
         Some(Constant::Int(i)) => i == 0,
         Some(Constant::F32(f)) => f == 0.0,
         Some(Constant::F64(f)) => f == 0.0,
-        _ => false,
+        Some(_) | None => false,
     }
 }
 
diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 0bc6b70855b..39908bff5ed 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -2154,7 +2154,7 @@ fn is_loop_nested(cx: &LateContext<'_, '_>, loop_expr: &Expr<'_>, iter_expr: &Ex
                 }
             },
             Some(Node::Stmt(_)) => (),
-            _ => {
+            Some(_) | None => {
                 return false;
             },
         }
diff --git a/clippy_lints/src/misc.rs b/clippy_lints/src/misc.rs
index e1d524c2231..38c2645d36e 100644
--- a/clippy_lints/src/misc.rs
+++ b/clippy_lints/src/misc.rs
@@ -509,7 +509,7 @@ fn is_allowed<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr<'_>) -> boo
             Constant::F64(f) => *f == 0.0 || (*f).is_infinite(),
             _ => false,
         }),
-        _ => false,
+        Some(_) | None => false,
     }
 }
 
diff --git a/clippy_lints/src/modulo_arithmetic.rs b/clippy_lints/src/modulo_arithmetic.rs
index 4ca90455bc4..3bb3eb15d9c 100644
--- a/clippy_lints/src/modulo_arithmetic.rs
+++ b/clippy_lints/src/modulo_arithmetic.rs
@@ -37,6 +37,7 @@ struct OperandInfo {
 }
 
 fn analyze_operand(operand: &Expr<'_>, cx: &LateContext<'_, '_>, expr: &Expr<'_>) -> Option<OperandInfo> {
+    #[allow(clippy::match_wildcard_for_single_variants)]
     match constant(cx, cx.tables, operand) {
         Some((Constant::Int(v), _)) => match cx.tables.expr_ty(expr).kind {
             ty::Int(ity) => {
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index 3b8ef18bfab..7bc8be492e8 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -370,6 +370,7 @@ pub fn trait_ref_of_method<'tcx>(cx: &LateContext<'_, 'tcx>, hir_id: HirId) -> O
 
 /// Checks whether this type implements `Drop`.
 pub fn has_drop<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, ty: Ty<'tcx>) -> bool {
+    #[allow(clippy::match_wildcard_for_single_variants)]
     match ty.ty_adt_def() {
         Some(def) => def.has_dtor(cx.tcx),
         _ => false,
@@ -444,6 +445,7 @@ pub fn is_entrypoint_fn(cx: &LateContext<'_, '_>, def_id: DefId) -> bool {
 /// Gets the name of the item the expression is in, if available.
 pub fn get_item_name(cx: &LateContext<'_, '_>, expr: &Expr<'_>) -> Option<Name> {
     let parent_id = cx.tcx.hir().get_parent_item(expr.hir_id);
+    #[allow(clippy::match_wildcard_for_single_variants)]
     match cx.tcx.hir().find(parent_id) {
         Some(
             Node::Item(Item { ident, .. })
-- 
cgit 1.4.1-3-g733a5


From 749619cfe34be1ee591f3af748fbdd4d2f54d3f0 Mon Sep 17 00:00:00 2001
From: Vardan Margaryan <v.t.margaryan@gmail.com>
Date: Thu, 14 May 2020 22:40:33 +0300
Subject: Apply suggestions from PR review

---
 clippy_lints/src/matches.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index 42a6c416619..444f5bb0db6 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -810,7 +810,7 @@ fn check_wild_enum_match(cx: &LateContext<'_, '_>, ex: &Expr<'_>, arms: &[Arm<'_
                 message,
                 "try this",
                 suggestion[0].clone(),
-                Applicability::MachineApplicable,
+                Applicability::MaybeIncorrect,
             )
         };
 
@@ -821,7 +821,7 @@ fn check_wild_enum_match(cx: &LateContext<'_, '_>, ex: &Expr<'_>, arms: &[Arm<'_
             message,
             "try this",
             suggestion.join(" | "),
-            Applicability::MachineApplicable,
+            Applicability::MaybeIncorrect,
         )
     }
 }
-- 
cgit 1.4.1-3-g733a5


From 1c59cd5f2110ff90a256f0948f05716403e84b85 Mon Sep 17 00:00:00 2001
From: Vardan Margaryan <v.t.margaryan@gmail.com>
Date: Thu, 14 May 2020 22:41:05 +0300
Subject: Fix example code of wildcard_enum_match_arm lint

---
 clippy_lints/src/matches.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index 444f5bb0db6..6fdb4cf9cd7 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -220,7 +220,7 @@ declare_clippy_lint! {
     /// # enum Foo { A(usize), B(usize) }
     /// # let x = Foo::B(1);
     /// match x {
-    ///     A => {},
+    ///     Foo::A(_) => {},
     ///     _ => {},
     /// }
     /// ```
-- 
cgit 1.4.1-3-g733a5


From 93386563f66823ac7d10641c007b0bbc23ab09e6 Mon Sep 17 00:00:00 2001
From: ThibsG <Thibs@debian.com>
Date: Sun, 3 May 2020 19:58:27 +0200
Subject: Rename lint `map_unwrap` to `map_unwrap_or` and register lints as
 renamed

---
 CHANGELOG.md                                     |   3 +-
 clippy_lints/src/lib.rs                          |  15 ++-
 clippy_lints/src/methods/mod.rs                  |   8 +-
 clippy_lints/src/methods/option_map_unwrap_or.rs |   4 +-
 src/lintlist/mod.rs                              |   9 +-
 tests/ui/map_unwrap.rs                           |  99 --------------
 tests/ui/map_unwrap.stderr                       | 161 -----------------------
 tests/ui/map_unwrap_or.rs                        |  99 ++++++++++++++
 tests/ui/map_unwrap_or.stderr                    | 161 +++++++++++++++++++++++
 9 files changed, 281 insertions(+), 278 deletions(-)
 delete mode 100644 tests/ui/map_unwrap.rs
 delete mode 100644 tests/ui/map_unwrap.stderr
 create mode 100644 tests/ui/map_unwrap_or.rs
 create mode 100644 tests/ui/map_unwrap_or.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 3f9486e0972..77272f4f78b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1430,7 +1430,7 @@ Released 2018-09-13
 [`map_clone`]: https://rust-lang.github.io/rust-clippy/master/index.html#map_clone
 [`map_entry`]: https://rust-lang.github.io/rust-clippy/master/index.html#map_entry
 [`map_flatten`]: https://rust-lang.github.io/rust-clippy/master/index.html#map_flatten
-[`map_unwrap`]: https://rust-lang.github.io/rust-clippy/master/index.html#map_unwrap
+[`map_unwrap_or`]: https://rust-lang.github.io/rust-clippy/master/index.html#map_unwrap_or
 [`match_as_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#match_as_ref
 [`match_bool`]: https://rust-lang.github.io/rust-clippy/master/index.html#match_bool
 [`match_on_vec_items`]: https://rust-lang.github.io/rust-clippy/master/index.html#match_on_vec_items
@@ -1538,7 +1538,6 @@ Released 2018-09-13
 [`rest_pat_in_fully_bound_structs`]: https://rust-lang.github.io/rust-clippy/master/index.html#rest_pat_in_fully_bound_structs
 [`result_map_or_into_option`]: https://rust-lang.github.io/rust-clippy/master/index.html#result_map_or_into_option
 [`result_map_unit_fn`]: https://rust-lang.github.io/rust-clippy/master/index.html#result_map_unit_fn
-[`result_unwrap_used`]: https://rust-lang.github.io/rust-clippy/master/index.html#result_unwrap_used
 [`reversed_empty_ranges`]: https://rust-lang.github.io/rust-clippy/master/index.html#reversed_empty_ranges
 [`same_functions_in_if_condition`]: https://rust-lang.github.io/rust-clippy/master/index.html#same_functions_in_if_condition
 [`search_is_some`]: https://rust-lang.github.io/rust-clippy/master/index.html#search_is_some
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 8de94d19d31..ff67ccae794 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -673,7 +673,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &methods::ITER_SKIP_NEXT,
         &methods::MANUAL_SATURATING_ARITHMETIC,
         &methods::MAP_FLATTEN,
-        &methods::MAP_UNWRAP,
+        &methods::MAP_UNWRAP_OR,
         &methods::NEW_RET_NO_SELF,
         &methods::OK_EXPECT,
         &methods::OPTION_AND_THEN_SOME,
@@ -1145,7 +1145,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&methods::FIND_MAP),
         LintId::of(&methods::INEFFICIENT_TO_STRING),
         LintId::of(&methods::MAP_FLATTEN),
-        LintId::of(&methods::MAP_UNWRAP),
+        LintId::of(&methods::MAP_UNWRAP_OR),
         LintId::of(&misc::USED_UNDERSCORE_BINDING),
         LintId::of(&misc_early::UNSEPARATED_LITERAL_SUFFIX),
         LintId::of(&mut_mut::MUT_MUT),
@@ -1785,6 +1785,17 @@ pub fn register_renamed(ls: &mut rustc_lint::LintStore) {
     ls.register_renamed("clippy::new_without_default_derive", "clippy::new_without_default");
     ls.register_renamed("clippy::cyclomatic_complexity", "clippy::cognitive_complexity");
     ls.register_renamed("clippy::const_static_lifetime", "clippy::redundant_static_lifetimes");
+    ls.register_renamed("clippy::block_in_if_condition_expr", "clippy::block_in_if_condition");
+    ls.register_renamed("clippy::block_in_if_condition_stmt", "clippy::block_in_if_condition");
+    ls.register_renamed("clippy::option_map_unwrap_or", "clippy::map_unwrap_or");
+    ls.register_renamed("clippy::option_map_unwrap_or_else", "clippy::map_unwrap_or");
+    ls.register_renamed("clippy::result_map_unwrap_or_else", "clippy::map_unwrap_or");
+    ls.register_renamed("clippy::option_unwrap_used", "clippy::unwrap_used");
+    ls.register_renamed("clippy::result_unwrap_used", "clippy::unwrap_used");
+    ls.register_renamed("clippy::option_expect_used", "clippy::expect_used");
+    ls.register_renamed("clippy::result_expect_used", "clippy::expect_used");
+    ls.register_renamed("clippy::for_loop_over_option", "clippy::for_loop_over_fallible");
+    ls.register_renamed("clippy::for_loop_over_result", "clippy::for_loop_over_fallible");
 }
 
 // only exists to let the dogfood integration test works.
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 2e75de019b6..e6094edc5d7 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -255,7 +255,7 @@ declare_clippy_lint! {
     /// // Good
     /// x.map_or_else(some_function, |a| a + 1);
     /// ```
-    pub MAP_UNWRAP,
+    pub MAP_UNWRAP_OR,
     pedantic,
     "using `.map(f).unwrap_or(a)` or `.map(f).unwrap_or_else(func)`, which are more succinctly expressed as `map_or(a, f)` or `map_or_else(a, f)`"
 }
@@ -1240,7 +1240,7 @@ declare_lint_pass!(Methods => [
     WRONG_SELF_CONVENTION,
     WRONG_PUB_SELF_CONVENTION,
     OK_EXPECT,
-    MAP_UNWRAP,
+    MAP_UNWRAP_OR,
     RESULT_MAP_OR_INTO_OPTION,
     OPTION_MAP_OR_NONE,
     OPTION_AND_THEN_SOME,
@@ -2512,7 +2512,7 @@ fn lint_map_unwrap_or_else<'a, 'tcx>(
         if same_span && !multiline {
             span_lint_and_note(
                 cx,
-                MAP_UNWRAP,
+                MAP_UNWRAP_OR,
                 expr.span,
                 msg,
                 None,
@@ -2522,7 +2522,7 @@ fn lint_map_unwrap_or_else<'a, 'tcx>(
                 ),
             );
         } else if same_span && multiline {
-            span_lint(cx, MAP_UNWRAP, expr.span, msg);
+            span_lint(cx, MAP_UNWRAP_OR, expr.span, msg);
         };
     }
 }
diff --git a/clippy_lints/src/methods/option_map_unwrap_or.rs b/clippy_lints/src/methods/option_map_unwrap_or.rs
index fcaa9b47e64..20c60ef3318 100644
--- a/clippy_lints/src/methods/option_map_unwrap_or.rs
+++ b/clippy_lints/src/methods/option_map_unwrap_or.rs
@@ -9,7 +9,7 @@ use rustc_middle::hir::map::Map;
 use rustc_span::source_map::Span;
 use rustc_span::symbol::Symbol;
 
-use super::MAP_UNWRAP;
+use super::MAP_UNWRAP_OR;
 
 /// lint use of `map().unwrap_or()` for `Option`s
 pub(super) fn lint<'a, 'tcx>(
@@ -66,7 +66,7 @@ pub(super) fn lint<'a, 'tcx>(
             arg, suggest
         );
 
-        span_lint_and_then(cx, MAP_UNWRAP, expr.span, msg, |diag| {
+        span_lint_and_then(cx, MAP_UNWRAP_OR, expr.span, msg, |diag| {
             let map_arg_span = map_args[1].span;
 
             let mut suggestion = vec![
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index 0ea0f55a381..e90b9c15747 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -1138,7 +1138,7 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
         module: "methods",
     },
     Lint {
-        name: "map_unwrap",
+        name: "map_unwrap_or",
         group: "pedantic",
         desc: "using `.map(f).unwrap_or(a)` or `.map(f).unwrap_or_else(func)`, which are more succinctly expressed as `map_or(a, f)` or `map_or_else(a, f)`",
         deprecation: None,
@@ -1872,13 +1872,6 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
         deprecation: None,
         module: "map_unit_fn",
     },
-    Lint {
-        name: "result_unwrap_used",
-        group: "restriction",
-        desc: "using `Result.unwrap()`, which might be better handled",
-        deprecation: None,
-        module: "methods",
-    },
     Lint {
         name: "reversed_empty_ranges",
         group: "correctness",
diff --git a/tests/ui/map_unwrap.rs b/tests/ui/map_unwrap.rs
deleted file mode 100644
index 53e50368231..00000000000
--- a/tests/ui/map_unwrap.rs
+++ /dev/null
@@ -1,99 +0,0 @@
-// FIXME: Add "run-rustfix" once it's supported for multipart suggestions
-// aux-build:option_helpers.rs
-
-#![warn(clippy::map_unwrap)]
-
-#[macro_use]
-extern crate option_helpers;
-
-use std::collections::HashMap;
-
-#[rustfmt::skip]
-fn option_methods() {
-    let opt = Some(1);
-
-    // Check for `option.map(_).unwrap_or(_)` use.
-    // Single line case.
-    let _ = opt.map(|x| x + 1)
-        // Should lint even though this call is on a separate line.
-        .unwrap_or(0);
-    // Multi-line cases.
-    let _ = opt.map(|x| {
-        x + 1
-    }
-    ).unwrap_or(0);
-    let _ = opt.map(|x| x + 1)
-        .unwrap_or({
-            0
-        });
-    // Single line `map(f).unwrap_or(None)` case.
-    let _ = opt.map(|x| Some(x + 1)).unwrap_or(None);
-    // Multi-line `map(f).unwrap_or(None)` cases.
-    let _ = opt.map(|x| {
-        Some(x + 1)
-    }
-    ).unwrap_or(None);
-    let _ = opt
-        .map(|x| Some(x + 1))
-        .unwrap_or(None);
-    // macro case
-    let _ = opt_map!(opt, |x| x + 1).unwrap_or(0); // should not lint
-
-    // Should not lint if not copyable
-    let id: String = "identifier".to_string();
-    let _ = Some("prefix").map(|p| format!("{}.{}", p, id)).unwrap_or(id);
-    // ...but DO lint if the `unwrap_or` argument is not used in the `map`
-    let id: String = "identifier".to_string();
-    let _ = Some("prefix").map(|p| format!("{}.", p)).unwrap_or(id);
-
-    // Check for `option.map(_).unwrap_or_else(_)` use.
-    // single line case
-    let _ = opt.map(|x| x + 1)
-        // Should lint even though this call is on a separate line.
-        .unwrap_or_else(|| 0);
-    // Multi-line cases.
-    let _ = opt.map(|x| {
-        x + 1
-    }
-    ).unwrap_or_else(|| 0);
-    let _ = opt.map(|x| x + 1)
-        .unwrap_or_else(||
-            0
-        );
-    // Macro case.
-    // Should not lint.
-    let _ = opt_map!(opt, |x| x + 1).unwrap_or_else(|| 0);
-
-    // Issue #4144
-    {
-        let mut frequencies = HashMap::new();
-        let word = "foo";
-
-        frequencies
-            .get_mut(word)
-            .map(|count| {
-                *count += 1;
-            })
-            .unwrap_or_else(|| {
-                frequencies.insert(word.to_owned(), 1);
-            });
-    }
-}
-
-fn result_methods() {
-    let res: Result<i32, ()> = Ok(1);
-
-    // Check for `result.map(_).unwrap_or_else(_)` use.
-    // single line case
-    let _ = res.map(|x| x + 1).unwrap_or_else(|e| 0); // should lint even though this call is on a separate line
-                                                      // multi line cases
-    let _ = res.map(|x| x + 1).unwrap_or_else(|e| 0);
-    let _ = res.map(|x| x + 1).unwrap_or_else(|e| 0);
-    // macro case
-    let _ = opt_map!(res, |x| x + 1).unwrap_or_else(|e| 0); // should not lint
-}
-
-fn main() {
-    option_methods();
-    result_methods();
-}
diff --git a/tests/ui/map_unwrap.stderr b/tests/ui/map_unwrap.stderr
deleted file mode 100644
index 2610923275d..00000000000
--- a/tests/ui/map_unwrap.stderr
+++ /dev/null
@@ -1,161 +0,0 @@
-error: called `map(f).unwrap_or(a)` on an `Option` value. This can be done more directly by calling `map_or(a, f)` instead
-  --> $DIR/map_unwrap.rs:17:13
-   |
-LL |       let _ = opt.map(|x| x + 1)
-   |  _____________^
-LL | |         // Should lint even though this call is on a separate line.
-LL | |         .unwrap_or(0);
-   | |_____________________^
-   |
-   = note: `-D clippy::map-unwrap` implied by `-D warnings`
-help: use `map_or(a, f)` instead
-   |
-LL |     let _ = opt.map_or(0, |x| x + 1);
-   |                 ^^^^^^ ^^          --
-
-error: called `map(f).unwrap_or(a)` on an `Option` value. This can be done more directly by calling `map_or(a, f)` instead
-  --> $DIR/map_unwrap.rs:21:13
-   |
-LL |       let _ = opt.map(|x| {
-   |  _____________^
-LL | |         x + 1
-LL | |     }
-LL | |     ).unwrap_or(0);
-   | |__________________^
-   |
-help: use `map_or(a, f)` instead
-   |
-LL |     let _ = opt.map_or(0, |x| {
-LL |         x + 1
-LL |     }
-LL |     );
-   |
-
-error: called `map(f).unwrap_or(a)` on an `Option` value. This can be done more directly by calling `map_or(a, f)` instead
-  --> $DIR/map_unwrap.rs:25:13
-   |
-LL |       let _ = opt.map(|x| x + 1)
-   |  _____________^
-LL | |         .unwrap_or({
-LL | |             0
-LL | |         });
-   | |__________^
-   |
-help: use `map_or(a, f)` instead
-   |
-LL |     let _ = opt.map_or({
-LL |             0
-LL |         }, |x| x + 1);
-   |
-
-error: called `map(f).unwrap_or(None)` on an `Option` value. This can be done more directly by calling `and_then(f)` instead
-  --> $DIR/map_unwrap.rs:30:13
-   |
-LL |     let _ = opt.map(|x| Some(x + 1)).unwrap_or(None);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: use `and_then(f)` instead
-   |
-LL |     let _ = opt.and_then(|x| Some(x + 1));
-   |                 ^^^^^^^^                --
-
-error: called `map(f).unwrap_or(None)` on an `Option` value. This can be done more directly by calling `and_then(f)` instead
-  --> $DIR/map_unwrap.rs:32:13
-   |
-LL |       let _ = opt.map(|x| {
-   |  _____________^
-LL | |         Some(x + 1)
-LL | |     }
-LL | |     ).unwrap_or(None);
-   | |_____________________^
-   |
-help: use `and_then(f)` instead
-   |
-LL |     let _ = opt.and_then(|x| {
-LL |         Some(x + 1)
-LL |     }
-LL |     );
-   |
-
-error: called `map(f).unwrap_or(None)` on an `Option` value. This can be done more directly by calling `and_then(f)` instead
-  --> $DIR/map_unwrap.rs:36:13
-   |
-LL |       let _ = opt
-   |  _____________^
-LL | |         .map(|x| Some(x + 1))
-LL | |         .unwrap_or(None);
-   | |________________________^
-   |
-help: use `and_then(f)` instead
-   |
-LL |         .and_then(|x| Some(x + 1));
-   |          ^^^^^^^^                --
-
-error: called `map(f).unwrap_or(a)` on an `Option` value. This can be done more directly by calling `map_or(a, f)` instead
-  --> $DIR/map_unwrap.rs:47:13
-   |
-LL |     let _ = Some("prefix").map(|p| format!("{}.", p)).unwrap_or(id);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: use `map_or(a, f)` instead
-   |
-LL |     let _ = Some("prefix").map_or(id, |p| format!("{}.", p));
-   |                            ^^^^^^ ^^^                      --
-
-error: called `map(f).unwrap_or_else(g)` on an `Option` value. This can be done more directly by calling `map_or_else(g, f)` instead
-  --> $DIR/map_unwrap.rs:51:13
-   |
-LL |       let _ = opt.map(|x| x + 1)
-   |  _____________^
-LL | |         // Should lint even though this call is on a separate line.
-LL | |         .unwrap_or_else(|| 0);
-   | |_____________________________^
-   |
-   = note: replace `map(|x| x + 1).unwrap_or_else(|| 0)` with `map_or_else(|| 0, |x| x + 1)`
-
-error: called `map(f).unwrap_or_else(g)` on an `Option` value. This can be done more directly by calling `map_or_else(g, f)` instead
-  --> $DIR/map_unwrap.rs:55:13
-   |
-LL |       let _ = opt.map(|x| {
-   |  _____________^
-LL | |         x + 1
-LL | |     }
-LL | |     ).unwrap_or_else(|| 0);
-   | |__________________________^
-
-error: called `map(f).unwrap_or_else(g)` on an `Option` value. This can be done more directly by calling `map_or_else(g, f)` instead
-  --> $DIR/map_unwrap.rs:59:13
-   |
-LL |       let _ = opt.map(|x| x + 1)
-   |  _____________^
-LL | |         .unwrap_or_else(||
-LL | |             0
-LL | |         );
-   | |_________^
-
-error: called `map(f).unwrap_or_else(g)` on a `Result` value. This can be done more directly by calling `.map_or_else(g, f)` instead
-  --> $DIR/map_unwrap.rs:88:13
-   |
-LL |     let _ = res.map(|x| x + 1).unwrap_or_else(|e| 0); // should lint even though this call is on a separate line
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: replace `map(|x| x + 1).unwrap_or_else(|e| 0)` with `map_or_else(|e| 0, |x| x + 1)`
-
-error: called `map(f).unwrap_or_else(g)` on a `Result` value. This can be done more directly by calling `.map_or_else(g, f)` instead
-  --> $DIR/map_unwrap.rs:90:13
-   |
-LL |     let _ = res.map(|x| x + 1).unwrap_or_else(|e| 0);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: replace `map(|x| x + 1).unwrap_or_else(|e| 0)` with `map_or_else(|e| 0, |x| x + 1)`
-
-error: called `map(f).unwrap_or_else(g)` on a `Result` value. This can be done more directly by calling `.map_or_else(g, f)` instead
-  --> $DIR/map_unwrap.rs:91:13
-   |
-LL |     let _ = res.map(|x| x + 1).unwrap_or_else(|e| 0);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: replace `map(|x| x + 1).unwrap_or_else(|e| 0)` with `map_or_else(|e| 0, |x| x + 1)`
-
-error: aborting due to 13 previous errors
-
diff --git a/tests/ui/map_unwrap_or.rs b/tests/ui/map_unwrap_or.rs
new file mode 100644
index 00000000000..585944032e7
--- /dev/null
+++ b/tests/ui/map_unwrap_or.rs
@@ -0,0 +1,99 @@
+// FIXME: Add "run-rustfix" once it's supported for multipart suggestions
+// aux-build:option_helpers.rs
+
+#![warn(clippy::map_unwrap_or)]
+
+#[macro_use]
+extern crate option_helpers;
+
+use std::collections::HashMap;
+
+#[rustfmt::skip]
+fn option_methods() {
+    let opt = Some(1);
+
+    // Check for `option.map(_).unwrap_or(_)` use.
+    // Single line case.
+    let _ = opt.map(|x| x + 1)
+        // Should lint even though this call is on a separate line.
+        .unwrap_or(0);
+    // Multi-line cases.
+    let _ = opt.map(|x| {
+        x + 1
+    }
+    ).unwrap_or(0);
+    let _ = opt.map(|x| x + 1)
+        .unwrap_or({
+            0
+        });
+    // Single line `map(f).unwrap_or(None)` case.
+    let _ = opt.map(|x| Some(x + 1)).unwrap_or(None);
+    // Multi-line `map(f).unwrap_or(None)` cases.
+    let _ = opt.map(|x| {
+        Some(x + 1)
+    }
+    ).unwrap_or(None);
+    let _ = opt
+        .map(|x| Some(x + 1))
+        .unwrap_or(None);
+    // macro case
+    let _ = opt_map!(opt, |x| x + 1).unwrap_or(0); // should not lint
+
+    // Should not lint if not copyable
+    let id: String = "identifier".to_string();
+    let _ = Some("prefix").map(|p| format!("{}.{}", p, id)).unwrap_or(id);
+    // ...but DO lint if the `unwrap_or` argument is not used in the `map`
+    let id: String = "identifier".to_string();
+    let _ = Some("prefix").map(|p| format!("{}.", p)).unwrap_or(id);
+
+    // Check for `option.map(_).unwrap_or_else(_)` use.
+    // single line case
+    let _ = opt.map(|x| x + 1)
+        // Should lint even though this call is on a separate line.
+        .unwrap_or_else(|| 0);
+    // Multi-line cases.
+    let _ = opt.map(|x| {
+        x + 1
+    }
+    ).unwrap_or_else(|| 0);
+    let _ = opt.map(|x| x + 1)
+        .unwrap_or_else(||
+            0
+        );
+    // Macro case.
+    // Should not lint.
+    let _ = opt_map!(opt, |x| x + 1).unwrap_or_else(|| 0);
+
+    // Issue #4144
+    {
+        let mut frequencies = HashMap::new();
+        let word = "foo";
+
+        frequencies
+            .get_mut(word)
+            .map(|count| {
+                *count += 1;
+            })
+            .unwrap_or_else(|| {
+                frequencies.insert(word.to_owned(), 1);
+            });
+    }
+}
+
+fn result_methods() {
+    let res: Result<i32, ()> = Ok(1);
+
+    // Check for `result.map(_).unwrap_or_else(_)` use.
+    // single line case
+    let _ = res.map(|x| x + 1).unwrap_or_else(|e| 0); // should lint even though this call is on a separate line
+                                                      // multi line cases
+    let _ = res.map(|x| x + 1).unwrap_or_else(|e| 0);
+    let _ = res.map(|x| x + 1).unwrap_or_else(|e| 0);
+    // macro case
+    let _ = opt_map!(res, |x| x + 1).unwrap_or_else(|e| 0); // should not lint
+}
+
+fn main() {
+    option_methods();
+    result_methods();
+}
diff --git a/tests/ui/map_unwrap_or.stderr b/tests/ui/map_unwrap_or.stderr
new file mode 100644
index 00000000000..b62080a073f
--- /dev/null
+++ b/tests/ui/map_unwrap_or.stderr
@@ -0,0 +1,161 @@
+error: called `map(f).unwrap_or(a)` on an `Option` value. This can be done more directly by calling `map_or(a, f)` instead
+  --> $DIR/map_unwrap_or.rs:17:13
+   |
+LL |       let _ = opt.map(|x| x + 1)
+   |  _____________^
+LL | |         // Should lint even though this call is on a separate line.
+LL | |         .unwrap_or(0);
+   | |_____________________^
+   |
+   = note: `-D clippy::map-unwrap-or` implied by `-D warnings`
+help: use `map_or(a, f)` instead
+   |
+LL |     let _ = opt.map_or(0, |x| x + 1);
+   |                 ^^^^^^ ^^          --
+
+error: called `map(f).unwrap_or(a)` on an `Option` value. This can be done more directly by calling `map_or(a, f)` instead
+  --> $DIR/map_unwrap_or.rs:21:13
+   |
+LL |       let _ = opt.map(|x| {
+   |  _____________^
+LL | |         x + 1
+LL | |     }
+LL | |     ).unwrap_or(0);
+   | |__________________^
+   |
+help: use `map_or(a, f)` instead
+   |
+LL |     let _ = opt.map_or(0, |x| {
+LL |         x + 1
+LL |     }
+LL |     );
+   |
+
+error: called `map(f).unwrap_or(a)` on an `Option` value. This can be done more directly by calling `map_or(a, f)` instead
+  --> $DIR/map_unwrap_or.rs:25:13
+   |
+LL |       let _ = opt.map(|x| x + 1)
+   |  _____________^
+LL | |         .unwrap_or({
+LL | |             0
+LL | |         });
+   | |__________^
+   |
+help: use `map_or(a, f)` instead
+   |
+LL |     let _ = opt.map_or({
+LL |             0
+LL |         }, |x| x + 1);
+   |
+
+error: called `map(f).unwrap_or(None)` on an `Option` value. This can be done more directly by calling `and_then(f)` instead
+  --> $DIR/map_unwrap_or.rs:30:13
+   |
+LL |     let _ = opt.map(|x| Some(x + 1)).unwrap_or(None);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `and_then(f)` instead
+   |
+LL |     let _ = opt.and_then(|x| Some(x + 1));
+   |                 ^^^^^^^^                --
+
+error: called `map(f).unwrap_or(None)` on an `Option` value. This can be done more directly by calling `and_then(f)` instead
+  --> $DIR/map_unwrap_or.rs:32:13
+   |
+LL |       let _ = opt.map(|x| {
+   |  _____________^
+LL | |         Some(x + 1)
+LL | |     }
+LL | |     ).unwrap_or(None);
+   | |_____________________^
+   |
+help: use `and_then(f)` instead
+   |
+LL |     let _ = opt.and_then(|x| {
+LL |         Some(x + 1)
+LL |     }
+LL |     );
+   |
+
+error: called `map(f).unwrap_or(None)` on an `Option` value. This can be done more directly by calling `and_then(f)` instead
+  --> $DIR/map_unwrap_or.rs:36:13
+   |
+LL |       let _ = opt
+   |  _____________^
+LL | |         .map(|x| Some(x + 1))
+LL | |         .unwrap_or(None);
+   | |________________________^
+   |
+help: use `and_then(f)` instead
+   |
+LL |         .and_then(|x| Some(x + 1));
+   |          ^^^^^^^^                --
+
+error: called `map(f).unwrap_or(a)` on an `Option` value. This can be done more directly by calling `map_or(a, f)` instead
+  --> $DIR/map_unwrap_or.rs:47:13
+   |
+LL |     let _ = Some("prefix").map(|p| format!("{}.", p)).unwrap_or(id);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `map_or(a, f)` instead
+   |
+LL |     let _ = Some("prefix").map_or(id, |p| format!("{}.", p));
+   |                            ^^^^^^ ^^^                      --
+
+error: called `map(f).unwrap_or_else(g)` on an `Option` value. This can be done more directly by calling `map_or_else(g, f)` instead
+  --> $DIR/map_unwrap_or.rs:51:13
+   |
+LL |       let _ = opt.map(|x| x + 1)
+   |  _____________^
+LL | |         // Should lint even though this call is on a separate line.
+LL | |         .unwrap_or_else(|| 0);
+   | |_____________________________^
+   |
+   = note: replace `map(|x| x + 1).unwrap_or_else(|| 0)` with `map_or_else(|| 0, |x| x + 1)`
+
+error: called `map(f).unwrap_or_else(g)` on an `Option` value. This can be done more directly by calling `map_or_else(g, f)` instead
+  --> $DIR/map_unwrap_or.rs:55:13
+   |
+LL |       let _ = opt.map(|x| {
+   |  _____________^
+LL | |         x + 1
+LL | |     }
+LL | |     ).unwrap_or_else(|| 0);
+   | |__________________________^
+
+error: called `map(f).unwrap_or_else(g)` on an `Option` value. This can be done more directly by calling `map_or_else(g, f)` instead
+  --> $DIR/map_unwrap_or.rs:59:13
+   |
+LL |       let _ = opt.map(|x| x + 1)
+   |  _____________^
+LL | |         .unwrap_or_else(||
+LL | |             0
+LL | |         );
+   | |_________^
+
+error: called `map(f).unwrap_or_else(g)` on a `Result` value. This can be done more directly by calling `.map_or_else(g, f)` instead
+  --> $DIR/map_unwrap_or.rs:88:13
+   |
+LL |     let _ = res.map(|x| x + 1).unwrap_or_else(|e| 0); // should lint even though this call is on a separate line
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: replace `map(|x| x + 1).unwrap_or_else(|e| 0)` with `map_or_else(|e| 0, |x| x + 1)`
+
+error: called `map(f).unwrap_or_else(g)` on a `Result` value. This can be done more directly by calling `.map_or_else(g, f)` instead
+  --> $DIR/map_unwrap_or.rs:90:13
+   |
+LL |     let _ = res.map(|x| x + 1).unwrap_or_else(|e| 0);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: replace `map(|x| x + 1).unwrap_or_else(|e| 0)` with `map_or_else(|e| 0, |x| x + 1)`
+
+error: called `map(f).unwrap_or_else(g)` on a `Result` value. This can be done more directly by calling `.map_or_else(g, f)` instead
+  --> $DIR/map_unwrap_or.rs:91:13
+   |
+LL |     let _ = res.map(|x| x + 1).unwrap_or_else(|e| 0);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: replace `map(|x| x + 1).unwrap_or_else(|e| 0)` with `map_or_else(|e| 0, |x| x + 1)`
+
+error: aborting due to 13 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From ab87f87ba03518da23ca510249aa3f5908a42368 Mon Sep 17 00:00:00 2001
From: ThibsG <Thibs@debian.com>
Date: Fri, 15 May 2020 18:20:07 +0200
Subject: Fix CHANGELOG.md and lint names plural

---
 CHANGELOG.md                                    |  22 ++--
 clippy_lints/src/block_in_if_condition.rs       | 145 ------------------------
 clippy_lints/src/blocks_in_if_conditions.rs     | 145 ++++++++++++++++++++++++
 clippy_lints/src/lib.rs                         |  24 ++--
 clippy_lints/src/loops.rs                       |   8 +-
 src/lintlist/mod.rs                             |   6 +-
 tests/ui/block_in_if_condition.fixed            |  74 ------------
 tests/ui/block_in_if_condition.rs               |  74 ------------
 tests/ui/block_in_if_condition.stderr           |  34 ------
 tests/ui/block_in_if_condition_closure.rs       |  47 --------
 tests/ui/block_in_if_condition_closure.stderr   |  24 ----
 tests/ui/blocks_in_if_conditions.fixed          |  74 ++++++++++++
 tests/ui/blocks_in_if_conditions.rs             |  74 ++++++++++++
 tests/ui/blocks_in_if_conditions.stderr         |  34 ++++++
 tests/ui/blocks_in_if_conditions_closure.rs     |  47 ++++++++
 tests/ui/blocks_in_if_conditions_closure.stderr |  24 ++++
 tests/ui/for_loop_over_fallible.rs              |  57 ----------
 tests/ui/for_loop_over_fallible.stderr          |  71 ------------
 tests/ui/for_loops_over_fallibles.rs            |  57 ++++++++++
 tests/ui/for_loops_over_fallibles.stderr        |  71 ++++++++++++
 20 files changed, 556 insertions(+), 556 deletions(-)
 delete mode 100644 clippy_lints/src/block_in_if_condition.rs
 create mode 100644 clippy_lints/src/blocks_in_if_conditions.rs
 delete mode 100644 tests/ui/block_in_if_condition.fixed
 delete mode 100644 tests/ui/block_in_if_condition.rs
 delete mode 100644 tests/ui/block_in_if_condition.stderr
 delete mode 100644 tests/ui/block_in_if_condition_closure.rs
 delete mode 100644 tests/ui/block_in_if_condition_closure.stderr
 create mode 100644 tests/ui/blocks_in_if_conditions.fixed
 create mode 100644 tests/ui/blocks_in_if_conditions.rs
 create mode 100644 tests/ui/blocks_in_if_conditions.stderr
 create mode 100644 tests/ui/blocks_in_if_conditions_closure.rs
 create mode 100644 tests/ui/blocks_in_if_conditions_closure.stderr
 delete mode 100644 tests/ui/for_loop_over_fallible.rs
 delete mode 100644 tests/ui/for_loop_over_fallible.stderr
 create mode 100644 tests/ui/for_loops_over_fallibles.rs
 create mode 100644 tests/ui/for_loops_over_fallibles.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 77272f4f78b..d05819a973a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -198,7 +198,7 @@ Released 2020-03-12
 
 ### Suggestion Improvements
 
-* [`option_map_unwrap_or`] [#4634](https://github.com/rust-lang/rust-clippy/pull/4634)
+* `option_map_unwrap_or` [#4634](https://github.com/rust-lang/rust-clippy/pull/4634)
 * [`wildcard_enum_match_arm`] [#4934](https://github.com/rust-lang/rust-clippy/pull/4934)
 * [`cognitive_complexity`] [#4935](https://github.com/rust-lang/rust-clippy/pull/4935)
 * [`decimal_literal_representation`] [#4956](https://github.com/rust-lang/rust-clippy/pull/4956)
@@ -282,8 +282,8 @@ Released 2019-12-19
   * [`panic`] [#4657](https://github.com/rust-lang/rust-clippy/pull/4657)
   * [`unreachable`] [#4657](https://github.com/rust-lang/rust-clippy/pull/4657)
   * [`todo`] [#4657](https://github.com/rust-lang/rust-clippy/pull/4657)
-  * [`option_expect_used`] [#4657](https://github.com/rust-lang/rust-clippy/pull/4657)
-  * [`result_expect_used`] [#4657](https://github.com/rust-lang/rust-clippy/pull/4657)
+  * `option_expect_used` [#4657](https://github.com/rust-lang/rust-clippy/pull/4657)
+  * `result_expect_used` [#4657](https://github.com/rust-lang/rust-clippy/pull/4657)
 * Move `redundant_clone` to perf group [#4509](https://github.com/rust-lang/rust-clippy/pull/4509)
 * Move `manual_mul_add` to nursery group [#4736](https://github.com/rust-lang/rust-clippy/pull/4736)
 * Expand `unit_cmp` to also work with `assert_eq!`, `debug_assert_eq!`, `assert_ne!` and `debug_assert_ne!` [#4613](https://github.com/rust-lang/rust-clippy/pull/4613)
@@ -395,7 +395,7 @@ Released 2019-08-15
 * Fix false positive in [`useless_attribute`] [#4107](https://github.com/rust-lang/rust-clippy/pull/4107)
 * Fix incorrect suggestion for [`float_cmp`] [#4214](https://github.com/rust-lang/rust-clippy/pull/4214)
 * Add suggestions for [`print_with_newline`] and [`write_with_newline`] [#4136](https://github.com/rust-lang/rust-clippy/pull/4136)
-* Improve suggestions for [`option_map_unwrap_or_else`] and [`result_map_unwrap_or_else`] [#4164](https://github.com/rust-lang/rust-clippy/pull/4164)
+* Improve suggestions for `option_map_unwrap_or_else` and `result_map_unwrap_or_else` [#4164](https://github.com/rust-lang/rust-clippy/pull/4164)
 * Improve suggestions for [`non_ascii_literal`] [#4119](https://github.com/rust-lang/rust-clippy/pull/4119)
 * Improve diagnostics for [`let_and_return`] [#4137](https://github.com/rust-lang/rust-clippy/pull/4137)
 * Improve diagnostics for [`trivially_copy_pass_by_ref`] [#4071](https://github.com/rust-lang/rust-clippy/pull/4071)
@@ -448,7 +448,7 @@ Released 2019-05-20
 * Fix false positive in [`needless_range_loop`] pertaining to structs without a `.iter()`
 * Fix false positive in [`bool_comparison`] pertaining to non-bool types
 * Fix false positive in [`redundant_closure`] pertaining to differences in borrows
-* Fix false positive in [`option_map_unwrap_or`] on non-copy types
+* Fix false positive in `option_map_unwrap_or` on non-copy types
 * Fix false positives in [`missing_const_for_fn`] pertaining to macros and trait method impls
 * Fix false positive in [`needless_pass_by_value`] pertaining to procedural macros
 * Fix false positive in [`needless_continue`] pertaining to loop labels
@@ -794,7 +794,7 @@ Released 2018-09-13
 
 ## 0.0.169
 * Rustup to *rustc 1.23.0-nightly (3b82e4c74 2017-11-05)*
-* New lints: [`just_underscores_and_digits`], [`result_map_unwrap_or_else`], [`transmute_bytes_to_str`]
+* New lints: [`just_underscores_and_digits`], `result_map_unwrap_or_else`, [`transmute_bytes_to_str`]
 
 ## 0.0.168
 * Rustup to *rustc 1.23.0-nightly (f0fe716db 2017-10-30)*
@@ -1068,7 +1068,7 @@ Released 2018-09-13
 
 ## 0.0.93 — 2016-10-03
 * Rustup to *rustc 1.14.0-nightly (144af3e97 2016-10-02)*
-* [`option_map_unwrap_or`] and [`option_map_unwrap_or_else`] are now
+* `option_map_unwrap_or` and `option_map_unwrap_or_else` are now
   allowed by default.
 * New lint: [`explicit_into_iter_loop`]
 
@@ -1087,8 +1087,8 @@ Released 2018-09-13
 ## 0.0.88 — 2016-09-04
 * Rustup to *rustc 1.13.0-nightly (70598e04f 2016-09-03)*
 * The following lints are not new but were only usable through the `clippy`
-  lint groups: [`filter_next`], [`for_loop_over_option`],
-  [`for_loop_over_result`] and [`match_overlapping_arm`]. You should now be
+  lint groups: [`filter_next`], `for_loop_over_option`,
+  `for_loop_over_result` and [`match_overlapping_arm`]. You should now be
   able to `#[allow/deny]` them individually and they are available directly
   through `cargo clippy`.
 
@@ -1274,7 +1274,7 @@ Released 2018-09-13
 [`await_holding_lock`]: https://rust-lang.github.io/rust-clippy/master/index.html#await_holding_lock
 [`bad_bit_mask`]: https://rust-lang.github.io/rust-clippy/master/index.html#bad_bit_mask
 [`blacklisted_name`]: https://rust-lang.github.io/rust-clippy/master/index.html#blacklisted_name
-[`block_in_if_condition`]: https://rust-lang.github.io/rust-clippy/master/index.html#block_in_if_condition
+[`blocks_in_if_conditions`]: https://rust-lang.github.io/rust-clippy/master/index.html#blocks_in_if_conditions
 [`bool_comparison`]: https://rust-lang.github.io/rust-clippy/master/index.html#bool_comparison
 [`borrow_interior_mutable_const`]: https://rust-lang.github.io/rust-clippy/master/index.html#borrow_interior_mutable_const
 [`borrowed_box`]: https://rust-lang.github.io/rust-clippy/master/index.html#borrowed_box
@@ -1361,7 +1361,7 @@ Released 2018-09-13
 [`fn_to_numeric_cast`]: https://rust-lang.github.io/rust-clippy/master/index.html#fn_to_numeric_cast
 [`fn_to_numeric_cast_with_truncation`]: https://rust-lang.github.io/rust-clippy/master/index.html#fn_to_numeric_cast_with_truncation
 [`for_kv_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#for_kv_map
-[`for_loop_over_fallible`]: https://rust-lang.github.io/rust-clippy/master/index.html#for_loop_over_fallible
+[`for_loops_over_fallibles`]: https://rust-lang.github.io/rust-clippy/master/index.html#for_loops_over_fallibles
 [`forget_copy`]: https://rust-lang.github.io/rust-clippy/master/index.html#forget_copy
 [`forget_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#forget_ref
 [`future_not_send`]: https://rust-lang.github.io/rust-clippy/master/index.html#future_not_send
diff --git a/clippy_lints/src/block_in_if_condition.rs b/clippy_lints/src/block_in_if_condition.rs
deleted file mode 100644
index 8a5e595749f..00000000000
--- a/clippy_lints/src/block_in_if_condition.rs
+++ /dev/null
@@ -1,145 +0,0 @@
-use crate::utils::{differing_macro_contexts, higher, snippet_block_with_applicability, span_lint, span_lint_and_sugg};
-use rustc_errors::Applicability;
-use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
-use rustc_hir::{BlockCheckMode, Expr, ExprKind};
-use rustc_lint::{LateContext, LateLintPass, LintContext};
-use rustc_middle::hir::map::Map;
-use rustc_middle::lint::in_external_macro;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for `if` conditions that use blocks containing an
-    /// expression, statements or conditions that use closures with blocks.
-    ///
-    /// **Why is this bad?** Style, using blocks in the condition makes it hard to read.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Examples:**
-    /// ```rust
-    /// // Bad
-    /// if { true } { /* ... */ }
-    ///
-    /// // Good
-    /// if true { /* ... */ }
-    /// ```
-    ///
-    /// // or
-    ///
-    /// ```rust
-    /// # fn somefunc() -> bool { true };
-    ///
-    /// // Bad
-    /// if { let x = somefunc(); x } { /* ... */ }
-    ///
-    /// // Good
-    /// let res = { let x = somefunc(); x };
-    /// if res { /* ... */ }
-    /// ```
-    pub BLOCK_IN_IF_CONDITION,
-    style,
-    "useless or complex blocks that can be eliminated in conditions"
-}
-
-declare_lint_pass!(BlockInIfCondition => [BLOCK_IN_IF_CONDITION]);
-
-struct ExVisitor<'a, 'tcx> {
-    found_block: Option<&'tcx Expr<'tcx>>,
-    cx: &'a LateContext<'a, 'tcx>,
-}
-
-impl<'a, 'tcx> Visitor<'tcx> for ExVisitor<'a, 'tcx> {
-    type Map = Map<'tcx>;
-
-    fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) {
-        if let ExprKind::Closure(_, _, eid, _, _) = expr.kind {
-            let body = self.cx.tcx.hir().body(eid);
-            let ex = &body.value;
-            if matches!(ex.kind, ExprKind::Block(_, _)) && !body.value.span.from_expansion() {
-                self.found_block = Some(ex);
-                return;
-            }
-        }
-        walk_expr(self, expr);
-    }
-    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-        NestedVisitorMap::None
-    }
-}
-
-const BRACED_EXPR_MESSAGE: &str = "omit braces around single expression condition";
-const COMPLEX_BLOCK_MESSAGE: &str = "in an `if` condition, avoid complex blocks or closures with blocks; \
-                                    instead, move the block or closure higher and bind it with a `let`";
-
-impl<'a, 'tcx> LateLintPass<'a, 'tcx> for BlockInIfCondition {
-    fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr<'_>) {
-        if in_external_macro(cx.sess(), expr.span) {
-            return;
-        }
-        if let Some((cond, _, _)) = higher::if_block(&expr) {
-            if let ExprKind::Block(block, _) = &cond.kind {
-                if block.rules == BlockCheckMode::DefaultBlock {
-                    if block.stmts.is_empty() {
-                        if let Some(ex) = &block.expr {
-                            // don't dig into the expression here, just suggest that they remove
-                            // the block
-                            if expr.span.from_expansion() || differing_macro_contexts(expr.span, ex.span) {
-                                return;
-                            }
-                            let mut applicability = Applicability::MachineApplicable;
-                            span_lint_and_sugg(
-                                cx,
-                                BLOCK_IN_IF_CONDITION,
-                                cond.span,
-                                BRACED_EXPR_MESSAGE,
-                                "try",
-                                format!(
-                                    "{}",
-                                    snippet_block_with_applicability(
-                                        cx,
-                                        ex.span,
-                                        "..",
-                                        Some(expr.span),
-                                        &mut applicability
-                                    )
-                                ),
-                                applicability,
-                            );
-                        }
-                    } else {
-                        let span = block.expr.as_ref().map_or_else(|| block.stmts[0].span, |e| e.span);
-                        if span.from_expansion() || differing_macro_contexts(expr.span, span) {
-                            return;
-                        }
-                        // move block higher
-                        let mut applicability = Applicability::MachineApplicable;
-                        span_lint_and_sugg(
-                            cx,
-                            BLOCK_IN_IF_CONDITION,
-                            expr.span.with_hi(cond.span.hi()),
-                            COMPLEX_BLOCK_MESSAGE,
-                            "try",
-                            format!(
-                                "let res = {}; if res",
-                                snippet_block_with_applicability(
-                                    cx,
-                                    block.span,
-                                    "..",
-                                    Some(expr.span),
-                                    &mut applicability
-                                ),
-                            ),
-                            applicability,
-                        );
-                    }
-                }
-            } else {
-                let mut visitor = ExVisitor { found_block: None, cx };
-                walk_expr(&mut visitor, cond);
-                if let Some(block) = visitor.found_block {
-                    span_lint(cx, BLOCK_IN_IF_CONDITION, block.span, COMPLEX_BLOCK_MESSAGE);
-                }
-            }
-        }
-    }
-}
diff --git a/clippy_lints/src/blocks_in_if_conditions.rs b/clippy_lints/src/blocks_in_if_conditions.rs
new file mode 100644
index 00000000000..8fa9b05ca32
--- /dev/null
+++ b/clippy_lints/src/blocks_in_if_conditions.rs
@@ -0,0 +1,145 @@
+use crate::utils::{differing_macro_contexts, higher, snippet_block_with_applicability, span_lint, span_lint_and_sugg};
+use rustc_errors::Applicability;
+use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
+use rustc_hir::{BlockCheckMode, Expr, ExprKind};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_middle::hir::map::Map;
+use rustc_middle::lint::in_external_macro;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for `if` conditions that use blocks containing an
+    /// expression, statements or conditions that use closures with blocks.
+    ///
+    /// **Why is this bad?** Style, using blocks in the condition makes it hard to read.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Examples:**
+    /// ```rust
+    /// // Bad
+    /// if { true } { /* ... */ }
+    ///
+    /// // Good
+    /// if true { /* ... */ }
+    /// ```
+    ///
+    /// // or
+    ///
+    /// ```rust
+    /// # fn somefunc() -> bool { true };
+    ///
+    /// // Bad
+    /// if { let x = somefunc(); x } { /* ... */ }
+    ///
+    /// // Good
+    /// let res = { let x = somefunc(); x };
+    /// if res { /* ... */ }
+    /// ```
+    pub BLOCKS_IN_IF_CONDITIONS,
+    style,
+    "useless or complex blocks that can be eliminated in conditions"
+}
+
+declare_lint_pass!(BlocksInIfConditions => [BLOCKS_IN_IF_CONDITIONS]);
+
+struct ExVisitor<'a, 'tcx> {
+    found_block: Option<&'tcx Expr<'tcx>>,
+    cx: &'a LateContext<'a, 'tcx>,
+}
+
+impl<'a, 'tcx> Visitor<'tcx> for ExVisitor<'a, 'tcx> {
+    type Map = Map<'tcx>;
+
+    fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) {
+        if let ExprKind::Closure(_, _, eid, _, _) = expr.kind {
+            let body = self.cx.tcx.hir().body(eid);
+            let ex = &body.value;
+            if matches!(ex.kind, ExprKind::Block(_, _)) && !body.value.span.from_expansion() {
+                self.found_block = Some(ex);
+                return;
+            }
+        }
+        walk_expr(self, expr);
+    }
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::None
+    }
+}
+
+const BRACED_EXPR_MESSAGE: &str = "omit braces around single expression condition";
+const COMPLEX_BLOCK_MESSAGE: &str = "in an `if` condition, avoid complex blocks or closures with blocks; \
+                                    instead, move the block or closure higher and bind it with a `let`";
+
+impl<'a, 'tcx> LateLintPass<'a, 'tcx> for BlocksInIfConditions {
+    fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr<'_>) {
+        if in_external_macro(cx.sess(), expr.span) {
+            return;
+        }
+        if let Some((cond, _, _)) = higher::if_block(&expr) {
+            if let ExprKind::Block(block, _) = &cond.kind {
+                if block.rules == BlockCheckMode::DefaultBlock {
+                    if block.stmts.is_empty() {
+                        if let Some(ex) = &block.expr {
+                            // don't dig into the expression here, just suggest that they remove
+                            // the block
+                            if expr.span.from_expansion() || differing_macro_contexts(expr.span, ex.span) {
+                                return;
+                            }
+                            let mut applicability = Applicability::MachineApplicable;
+                            span_lint_and_sugg(
+                                cx,
+                                BLOCKS_IN_IF_CONDITIONS,
+                                cond.span,
+                                BRACED_EXPR_MESSAGE,
+                                "try",
+                                format!(
+                                    "{}",
+                                    snippet_block_with_applicability(
+                                        cx,
+                                        ex.span,
+                                        "..",
+                                        Some(expr.span),
+                                        &mut applicability
+                                    )
+                                ),
+                                applicability,
+                            );
+                        }
+                    } else {
+                        let span = block.expr.as_ref().map_or_else(|| block.stmts[0].span, |e| e.span);
+                        if span.from_expansion() || differing_macro_contexts(expr.span, span) {
+                            return;
+                        }
+                        // move block higher
+                        let mut applicability = Applicability::MachineApplicable;
+                        span_lint_and_sugg(
+                            cx,
+                            BLOCKS_IN_IF_CONDITIONS,
+                            expr.span.with_hi(cond.span.hi()),
+                            COMPLEX_BLOCK_MESSAGE,
+                            "try",
+                            format!(
+                                "let res = {}; if res",
+                                snippet_block_with_applicability(
+                                    cx,
+                                    block.span,
+                                    "..",
+                                    Some(expr.span),
+                                    &mut applicability
+                                ),
+                            ),
+                            applicability,
+                        );
+                    }
+                }
+            } else {
+                let mut visitor = ExVisitor { found_block: None, cx };
+                walk_expr(&mut visitor, cond);
+                if let Some(block) = visitor.found_block {
+                    span_lint(cx, BLOCKS_IN_IF_CONDITIONS, block.span, COMPLEX_BLOCK_MESSAGE);
+                }
+            }
+        }
+    }
+}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index ff67ccae794..eba4ab5056b 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -180,7 +180,7 @@ mod attrs;
 mod await_holding_lock;
 mod bit_mask;
 mod blacklisted_name;
-mod block_in_if_condition;
+mod blocks_in_if_conditions;
 mod booleans;
 mod bytecount;
 mod cargo_common_metadata;
@@ -507,7 +507,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &bit_mask::INEFFECTIVE_BIT_MASK,
         &bit_mask::VERBOSE_BIT_MASK,
         &blacklisted_name::BLACKLISTED_NAME,
-        &block_in_if_condition::BLOCK_IN_IF_CONDITION,
+        &blocks_in_if_conditions::BLOCKS_IN_IF_CONDITIONS,
         &booleans::LOGIC_BUG,
         &booleans::NONMINIMAL_BOOL,
         &bytecount::NAIVE_BYTECOUNT,
@@ -615,7 +615,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &loops::EXPLICIT_INTO_ITER_LOOP,
         &loops::EXPLICIT_ITER_LOOP,
         &loops::FOR_KV_MAP,
-        &loops::FOR_LOOP_OVER_FALLIBLE,
+        &loops::FOR_LOOPS_OVER_FALLIBLES,
         &loops::ITER_NEXT_LOOP,
         &loops::MANUAL_MEMCPY,
         &loops::MUT_RANGE_BOUND,
@@ -894,7 +894,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box mut_reference::UnnecessaryMutPassed);
     store.register_late_pass(|| box len_zero::LenZero);
     store.register_late_pass(|| box attrs::Attributes);
-    store.register_late_pass(|| box block_in_if_condition::BlockInIfCondition);
+    store.register_late_pass(|| box blocks_in_if_conditions::BlocksInIfConditions);
     store.register_late_pass(|| box unicode::Unicode);
     store.register_late_pass(|| box strings::StringAdd);
     store.register_late_pass(|| box implicit_return::ImplicitReturn);
@@ -1199,7 +1199,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&bit_mask::INEFFECTIVE_BIT_MASK),
         LintId::of(&bit_mask::VERBOSE_BIT_MASK),
         LintId::of(&blacklisted_name::BLACKLISTED_NAME),
-        LintId::of(&block_in_if_condition::BLOCK_IN_IF_CONDITION),
+        LintId::of(&blocks_in_if_conditions::BLOCKS_IN_IF_CONDITIONS),
         LintId::of(&booleans::LOGIC_BUG),
         LintId::of(&booleans::NONMINIMAL_BOOL),
         LintId::of(&bytecount::NAIVE_BYTECOUNT),
@@ -1264,7 +1264,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&loops::EMPTY_LOOP),
         LintId::of(&loops::EXPLICIT_COUNTER_LOOP),
         LintId::of(&loops::FOR_KV_MAP),
-        LintId::of(&loops::FOR_LOOP_OVER_FALLIBLE),
+        LintId::of(&loops::FOR_LOOPS_OVER_FALLIBLES),
         LintId::of(&loops::ITER_NEXT_LOOP),
         LintId::of(&loops::MANUAL_MEMCPY),
         LintId::of(&loops::MUT_RANGE_BOUND),
@@ -1444,7 +1444,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&attrs::UNKNOWN_CLIPPY_LINTS),
         LintId::of(&bit_mask::VERBOSE_BIT_MASK),
         LintId::of(&blacklisted_name::BLACKLISTED_NAME),
-        LintId::of(&block_in_if_condition::BLOCK_IN_IF_CONDITION),
+        LintId::of(&blocks_in_if_conditions::BLOCKS_IN_IF_CONDITIONS),
         LintId::of(&collapsible_if::COLLAPSIBLE_IF),
         LintId::of(&comparison_chain::COMPARISON_CHAIN),
         LintId::of(&doc::MISSING_SAFETY_DOC),
@@ -1639,7 +1639,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&inline_fn_without_body::INLINE_FN_WITHOUT_BODY),
         LintId::of(&let_underscore::LET_UNDERSCORE_LOCK),
         LintId::of(&literal_representation::MISTYPED_LITERAL_SUFFIXES),
-        LintId::of(&loops::FOR_LOOP_OVER_FALLIBLE),
+        LintId::of(&loops::FOR_LOOPS_OVER_FALLIBLES),
         LintId::of(&loops::ITER_NEXT_LOOP),
         LintId::of(&loops::NEVER_LOOP),
         LintId::of(&loops::WHILE_IMMUTABLE_CONDITION),
@@ -1785,8 +1785,8 @@ pub fn register_renamed(ls: &mut rustc_lint::LintStore) {
     ls.register_renamed("clippy::new_without_default_derive", "clippy::new_without_default");
     ls.register_renamed("clippy::cyclomatic_complexity", "clippy::cognitive_complexity");
     ls.register_renamed("clippy::const_static_lifetime", "clippy::redundant_static_lifetimes");
-    ls.register_renamed("clippy::block_in_if_condition_expr", "clippy::block_in_if_condition");
-    ls.register_renamed("clippy::block_in_if_condition_stmt", "clippy::block_in_if_condition");
+    ls.register_renamed("clippy::block_in_if_condition_expr", "clippy::blocks_in_if_conditions");
+    ls.register_renamed("clippy::block_in_if_condition_stmt", "clippy::blocks_in_if_conditions");
     ls.register_renamed("clippy::option_map_unwrap_or", "clippy::map_unwrap_or");
     ls.register_renamed("clippy::option_map_unwrap_or_else", "clippy::map_unwrap_or");
     ls.register_renamed("clippy::result_map_unwrap_or_else", "clippy::map_unwrap_or");
@@ -1794,8 +1794,8 @@ pub fn register_renamed(ls: &mut rustc_lint::LintStore) {
     ls.register_renamed("clippy::result_unwrap_used", "clippy::unwrap_used");
     ls.register_renamed("clippy::option_expect_used", "clippy::expect_used");
     ls.register_renamed("clippy::result_expect_used", "clippy::expect_used");
-    ls.register_renamed("clippy::for_loop_over_option", "clippy::for_loop_over_fallible");
-    ls.register_renamed("clippy::for_loop_over_result", "clippy::for_loop_over_fallible");
+    ls.register_renamed("clippy::for_loop_over_option", "clippy::for_loops_over_fallibles");
+    ls.register_renamed("clippy::for_loop_over_result", "clippy::for_loops_over_fallibles");
 }
 
 // only exists to let the dogfood integration test works.
diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index da6793a69d6..9c9d1a84003 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -205,7 +205,7 @@ declare_clippy_lint! {
     ///     // ..
     /// }
     /// ```
-    pub FOR_LOOP_OVER_FALLIBLE,
+    pub FOR_LOOPS_OVER_FALLIBLES,
     correctness,
     "for-looping over an `Option` or a `Result`, which is more clearly expressed as an `if let`"
 }
@@ -426,7 +426,7 @@ declare_lint_pass!(Loops => [
     EXPLICIT_ITER_LOOP,
     EXPLICIT_INTO_ITER_LOOP,
     ITER_NEXT_LOOP,
-    FOR_LOOP_OVER_FALLIBLE,
+    FOR_LOOPS_OVER_FALLIBLES,
     WHILE_LET_LOOP,
     NEEDLESS_COLLECT,
     EXPLICIT_COUNTER_LOOP,
@@ -1290,7 +1290,7 @@ fn check_arg_type(cx: &LateContext<'_, '_>, pat: &Pat<'_>, arg: &Expr<'_>) {
     if is_type_diagnostic_item(cx, ty, sym!(option_type)) {
         span_lint_and_help(
             cx,
-            FOR_LOOP_OVER_FALLIBLE,
+            FOR_LOOPS_OVER_FALLIBLES,
             arg.span,
             &format!(
                 "for loop over `{0}`, which is an `Option`. This is more readably written as an \
@@ -1307,7 +1307,7 @@ fn check_arg_type(cx: &LateContext<'_, '_>, pat: &Pat<'_>, arg: &Expr<'_>) {
     } else if is_type_diagnostic_item(cx, ty, sym!(result_type)) {
         span_lint_and_help(
             cx,
-            FOR_LOOP_OVER_FALLIBLE,
+            FOR_LOOPS_OVER_FALLIBLES,
             arg.span,
             &format!(
                 "for loop over `{0}`, which is a `Result`. This is more readably written as an \
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index e90b9c15747..feada261a4c 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -74,11 +74,11 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
         module: "blacklisted_name",
     },
     Lint {
-        name: "block_in_if_condition",
+        name: "blocks_in_if_conditions",
         group: "style",
         desc: "useless or complex blocks that can be eliminated in conditions",
         deprecation: None,
-        module: "block_in_if_condition",
+        module: "blocks_in_if_conditions",
     },
     Lint {
         name: "bool_comparison",
@@ -676,7 +676,7 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
         module: "loops",
     },
     Lint {
-        name: "for_loop_over_fallible",
+        name: "for_loops_over_fallibles",
         group: "correctness",
         desc: "for-looping over an `Option` or a `Result`, which is more clearly expressed as an `if let`",
         deprecation: None,
diff --git a/tests/ui/block_in_if_condition.fixed b/tests/ui/block_in_if_condition.fixed
deleted file mode 100644
index ae01c6d3042..00000000000
--- a/tests/ui/block_in_if_condition.fixed
+++ /dev/null
@@ -1,74 +0,0 @@
-// run-rustfix
-#![warn(clippy::block_in_if_condition)]
-#![allow(unused, clippy::let_and_return)]
-#![warn(clippy::nonminimal_bool)]
-
-macro_rules! blocky {
-    () => {{
-        true
-    }};
-}
-
-macro_rules! blocky_too {
-    () => {{
-        let r = true;
-        r
-    }};
-}
-
-fn macro_if() {
-    if blocky!() {}
-
-    if blocky_too!() {}
-}
-
-fn condition_has_block() -> i32 {
-    let res = {
-        let x = 3;
-        x == 3
-    }; if res {
-        6
-    } else {
-        10
-    }
-}
-
-fn condition_has_block_with_single_expression() -> i32 {
-    if true {
-        6
-    } else {
-        10
-    }
-}
-
-fn condition_is_normal() -> i32 {
-    let x = 3;
-    if x == 3 {
-        6
-    } else {
-        10
-    }
-}
-
-fn condition_is_unsafe_block() {
-    let a: i32 = 1;
-
-    // this should not warn because the condition is an unsafe block
-    if unsafe { 1u32 == std::mem::transmute(a) } {
-        println!("1u32 == a");
-    }
-}
-
-fn block_in_assert() {
-    let opt = Some(42);
-    assert!(opt
-        .as_ref()
-        .and_then(|val| {
-            let mut v = val * 2;
-            v -= 1;
-            Some(v * 3)
-        })
-        .is_some());
-}
-
-fn main() {}
diff --git a/tests/ui/block_in_if_condition.rs b/tests/ui/block_in_if_condition.rs
deleted file mode 100644
index 88555dc47c2..00000000000
--- a/tests/ui/block_in_if_condition.rs
+++ /dev/null
@@ -1,74 +0,0 @@
-// run-rustfix
-#![warn(clippy::block_in_if_condition)]
-#![allow(unused, clippy::let_and_return)]
-#![warn(clippy::nonminimal_bool)]
-
-macro_rules! blocky {
-    () => {{
-        true
-    }};
-}
-
-macro_rules! blocky_too {
-    () => {{
-        let r = true;
-        r
-    }};
-}
-
-fn macro_if() {
-    if blocky!() {}
-
-    if blocky_too!() {}
-}
-
-fn condition_has_block() -> i32 {
-    if {
-        let x = 3;
-        x == 3
-    } {
-        6
-    } else {
-        10
-    }
-}
-
-fn condition_has_block_with_single_expression() -> i32 {
-    if { true } {
-        6
-    } else {
-        10
-    }
-}
-
-fn condition_is_normal() -> i32 {
-    let x = 3;
-    if true && x == 3 {
-        6
-    } else {
-        10
-    }
-}
-
-fn condition_is_unsafe_block() {
-    let a: i32 = 1;
-
-    // this should not warn because the condition is an unsafe block
-    if unsafe { 1u32 == std::mem::transmute(a) } {
-        println!("1u32 == a");
-    }
-}
-
-fn block_in_assert() {
-    let opt = Some(42);
-    assert!(opt
-        .as_ref()
-        .and_then(|val| {
-            let mut v = val * 2;
-            v -= 1;
-            Some(v * 3)
-        })
-        .is_some());
-}
-
-fn main() {}
diff --git a/tests/ui/block_in_if_condition.stderr b/tests/ui/block_in_if_condition.stderr
deleted file mode 100644
index 89e9ad26f49..00000000000
--- a/tests/ui/block_in_if_condition.stderr
+++ /dev/null
@@ -1,34 +0,0 @@
-error: in an `if` condition, avoid complex blocks or closures with blocks; instead, move the block or closure higher and bind it with a `let`
-  --> $DIR/block_in_if_condition.rs:26:5
-   |
-LL | /     if {
-LL | |         let x = 3;
-LL | |         x == 3
-LL | |     } {
-   | |_____^
-   |
-   = note: `-D clippy::block-in-if-condition` implied by `-D warnings`
-help: try
-   |
-LL |     let res = {
-LL |         let x = 3;
-LL |         x == 3
-LL |     }; if res {
-   |
-
-error: omit braces around single expression condition
-  --> $DIR/block_in_if_condition.rs:37:8
-   |
-LL |     if { true } {
-   |        ^^^^^^^^ help: try: `true`
-
-error: this boolean expression can be simplified
-  --> $DIR/block_in_if_condition.rs:46:8
-   |
-LL |     if true && x == 3 {
-   |        ^^^^^^^^^^^^^^ help: try: `x == 3`
-   |
-   = note: `-D clippy::nonminimal-bool` implied by `-D warnings`
-
-error: aborting due to 3 previous errors
-
diff --git a/tests/ui/block_in_if_condition_closure.rs b/tests/ui/block_in_if_condition_closure.rs
deleted file mode 100644
index 87b3fb94daf..00000000000
--- a/tests/ui/block_in_if_condition_closure.rs
+++ /dev/null
@@ -1,47 +0,0 @@
-#![warn(clippy::block_in_if_condition)]
-#![allow(unused, clippy::let_and_return)]
-
-fn predicate<F: FnOnce(T) -> bool, T>(pfn: F, val: T) -> bool {
-    pfn(val)
-}
-
-fn pred_test() {
-    let v = 3;
-    let sky = "blue";
-    // This is a sneaky case, where the block isn't directly in the condition,
-    // but is actually inside a closure that the condition is using.
-    // The same principle applies -- add some extra expressions to make sure
-    // linter isn't confused by them.
-    if v == 3
-        && sky == "blue"
-        && predicate(
-            |x| {
-                let target = 3;
-                x == target
-            },
-            v,
-        )
-    {}
-
-    if predicate(
-        |x| {
-            let target = 3;
-            x == target
-        },
-        v,
-    ) {}
-}
-
-fn closure_without_block() {
-    if predicate(|x| x == 3, 6) {}
-}
-
-fn macro_in_closure() {
-    let option = Some(true);
-
-    if option.unwrap_or_else(|| unimplemented!()) {
-        unimplemented!()
-    }
-}
-
-fn main() {}
diff --git a/tests/ui/block_in_if_condition_closure.stderr b/tests/ui/block_in_if_condition_closure.stderr
deleted file mode 100644
index 3df25691c3c..00000000000
--- a/tests/ui/block_in_if_condition_closure.stderr
+++ /dev/null
@@ -1,24 +0,0 @@
-error: in an `if` condition, avoid complex blocks or closures with blocks; instead, move the block or closure higher and bind it with a `let`
-  --> $DIR/block_in_if_condition_closure.rs:18:17
-   |
-LL |               |x| {
-   |  _________________^
-LL | |                 let target = 3;
-LL | |                 x == target
-LL | |             },
-   | |_____________^
-   |
-   = note: `-D clippy::block-in-if-condition` implied by `-D warnings`
-
-error: in an `if` condition, avoid complex blocks or closures with blocks; instead, move the block or closure higher and bind it with a `let`
-  --> $DIR/block_in_if_condition_closure.rs:27:13
-   |
-LL |           |x| {
-   |  _____________^
-LL | |             let target = 3;
-LL | |             x == target
-LL | |         },
-   | |_________^
-
-error: aborting due to 2 previous errors
-
diff --git a/tests/ui/blocks_in_if_conditions.fixed b/tests/ui/blocks_in_if_conditions.fixed
new file mode 100644
index 00000000000..9040552cefc
--- /dev/null
+++ b/tests/ui/blocks_in_if_conditions.fixed
@@ -0,0 +1,74 @@
+// run-rustfix
+#![warn(clippy::blocks_in_if_conditions)]
+#![allow(unused, clippy::let_and_return)]
+#![warn(clippy::nonminimal_bool)]
+
+macro_rules! blocky {
+    () => {{
+        true
+    }};
+}
+
+macro_rules! blocky_too {
+    () => {{
+        let r = true;
+        r
+    }};
+}
+
+fn macro_if() {
+    if blocky!() {}
+
+    if blocky_too!() {}
+}
+
+fn condition_has_block() -> i32 {
+    let res = {
+        let x = 3;
+        x == 3
+    }; if res {
+        6
+    } else {
+        10
+    }
+}
+
+fn condition_has_block_with_single_expression() -> i32 {
+    if true {
+        6
+    } else {
+        10
+    }
+}
+
+fn condition_is_normal() -> i32 {
+    let x = 3;
+    if x == 3 {
+        6
+    } else {
+        10
+    }
+}
+
+fn condition_is_unsafe_block() {
+    let a: i32 = 1;
+
+    // this should not warn because the condition is an unsafe block
+    if unsafe { 1u32 == std::mem::transmute(a) } {
+        println!("1u32 == a");
+    }
+}
+
+fn block_in_assert() {
+    let opt = Some(42);
+    assert!(opt
+        .as_ref()
+        .and_then(|val| {
+            let mut v = val * 2;
+            v -= 1;
+            Some(v * 3)
+        })
+        .is_some());
+}
+
+fn main() {}
diff --git a/tests/ui/blocks_in_if_conditions.rs b/tests/ui/blocks_in_if_conditions.rs
new file mode 100644
index 00000000000..2fe409b22d3
--- /dev/null
+++ b/tests/ui/blocks_in_if_conditions.rs
@@ -0,0 +1,74 @@
+// run-rustfix
+#![warn(clippy::blocks_in_if_conditions)]
+#![allow(unused, clippy::let_and_return)]
+#![warn(clippy::nonminimal_bool)]
+
+macro_rules! blocky {
+    () => {{
+        true
+    }};
+}
+
+macro_rules! blocky_too {
+    () => {{
+        let r = true;
+        r
+    }};
+}
+
+fn macro_if() {
+    if blocky!() {}
+
+    if blocky_too!() {}
+}
+
+fn condition_has_block() -> i32 {
+    if {
+        let x = 3;
+        x == 3
+    } {
+        6
+    } else {
+        10
+    }
+}
+
+fn condition_has_block_with_single_expression() -> i32 {
+    if { true } {
+        6
+    } else {
+        10
+    }
+}
+
+fn condition_is_normal() -> i32 {
+    let x = 3;
+    if true && x == 3 {
+        6
+    } else {
+        10
+    }
+}
+
+fn condition_is_unsafe_block() {
+    let a: i32 = 1;
+
+    // this should not warn because the condition is an unsafe block
+    if unsafe { 1u32 == std::mem::transmute(a) } {
+        println!("1u32 == a");
+    }
+}
+
+fn block_in_assert() {
+    let opt = Some(42);
+    assert!(opt
+        .as_ref()
+        .and_then(|val| {
+            let mut v = val * 2;
+            v -= 1;
+            Some(v * 3)
+        })
+        .is_some());
+}
+
+fn main() {}
diff --git a/tests/ui/blocks_in_if_conditions.stderr b/tests/ui/blocks_in_if_conditions.stderr
new file mode 100644
index 00000000000..9bdddc8e152
--- /dev/null
+++ b/tests/ui/blocks_in_if_conditions.stderr
@@ -0,0 +1,34 @@
+error: in an `if` condition, avoid complex blocks or closures with blocks; instead, move the block or closure higher and bind it with a `let`
+  --> $DIR/blocks_in_if_conditions.rs:26:5
+   |
+LL | /     if {
+LL | |         let x = 3;
+LL | |         x == 3
+LL | |     } {
+   | |_____^
+   |
+   = note: `-D clippy::blocks-in-if-conditions` implied by `-D warnings`
+help: try
+   |
+LL |     let res = {
+LL |         let x = 3;
+LL |         x == 3
+LL |     }; if res {
+   |
+
+error: omit braces around single expression condition
+  --> $DIR/blocks_in_if_conditions.rs:37:8
+   |
+LL |     if { true } {
+   |        ^^^^^^^^ help: try: `true`
+
+error: this boolean expression can be simplified
+  --> $DIR/blocks_in_if_conditions.rs:46:8
+   |
+LL |     if true && x == 3 {
+   |        ^^^^^^^^^^^^^^ help: try: `x == 3`
+   |
+   = note: `-D clippy::nonminimal-bool` implied by `-D warnings`
+
+error: aborting due to 3 previous errors
+
diff --git a/tests/ui/blocks_in_if_conditions_closure.rs b/tests/ui/blocks_in_if_conditions_closure.rs
new file mode 100644
index 00000000000..acbabfa20d7
--- /dev/null
+++ b/tests/ui/blocks_in_if_conditions_closure.rs
@@ -0,0 +1,47 @@
+#![warn(clippy::blocks_in_if_conditions)]
+#![allow(unused, clippy::let_and_return)]
+
+fn predicate<F: FnOnce(T) -> bool, T>(pfn: F, val: T) -> bool {
+    pfn(val)
+}
+
+fn pred_test() {
+    let v = 3;
+    let sky = "blue";
+    // This is a sneaky case, where the block isn't directly in the condition,
+    // but is actually inside a closure that the condition is using.
+    // The same principle applies -- add some extra expressions to make sure
+    // linter isn't confused by them.
+    if v == 3
+        && sky == "blue"
+        && predicate(
+            |x| {
+                let target = 3;
+                x == target
+            },
+            v,
+        )
+    {}
+
+    if predicate(
+        |x| {
+            let target = 3;
+            x == target
+        },
+        v,
+    ) {}
+}
+
+fn closure_without_block() {
+    if predicate(|x| x == 3, 6) {}
+}
+
+fn macro_in_closure() {
+    let option = Some(true);
+
+    if option.unwrap_or_else(|| unimplemented!()) {
+        unimplemented!()
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/blocks_in_if_conditions_closure.stderr b/tests/ui/blocks_in_if_conditions_closure.stderr
new file mode 100644
index 00000000000..941d604dd5f
--- /dev/null
+++ b/tests/ui/blocks_in_if_conditions_closure.stderr
@@ -0,0 +1,24 @@
+error: in an `if` condition, avoid complex blocks or closures with blocks; instead, move the block or closure higher and bind it with a `let`
+  --> $DIR/blocks_in_if_conditions_closure.rs:18:17
+   |
+LL |               |x| {
+   |  _________________^
+LL | |                 let target = 3;
+LL | |                 x == target
+LL | |             },
+   | |_____________^
+   |
+   = note: `-D clippy::blocks-in-if-conditions` implied by `-D warnings`
+
+error: in an `if` condition, avoid complex blocks or closures with blocks; instead, move the block or closure higher and bind it with a `let`
+  --> $DIR/blocks_in_if_conditions_closure.rs:27:13
+   |
+LL |           |x| {
+   |  _____________^
+LL | |             let target = 3;
+LL | |             x == target
+LL | |         },
+   | |_________^
+
+error: aborting due to 2 previous errors
+
diff --git a/tests/ui/for_loop_over_fallible.rs b/tests/ui/for_loop_over_fallible.rs
deleted file mode 100644
index e52468cdd4b..00000000000
--- a/tests/ui/for_loop_over_fallible.rs
+++ /dev/null
@@ -1,57 +0,0 @@
-#![warn(clippy::for_loop_over_fallible)]
-
-fn for_loop_over_fallible() {
-    let option = Some(1);
-    let result = option.ok_or("x not found");
-    let v = vec![0, 1, 2];
-
-    // check over an `Option`
-    for x in option {
-        println!("{}", x);
-    }
-
-    // check over a `Result`
-    for x in result {
-        println!("{}", x);
-    }
-
-    for x in option.ok_or("x not found") {
-        println!("{}", x);
-    }
-
-    // make sure LOOP_OVER_NEXT lint takes clippy::precedence when next() is the last call
-    // in the chain
-    for x in v.iter().next() {
-        println!("{}", x);
-    }
-
-    // make sure we lint when next() is not the last call in the chain
-    for x in v.iter().next().and(Some(0)) {
-        println!("{}", x);
-    }
-
-    for x in v.iter().next().ok_or("x not found") {
-        println!("{}", x);
-    }
-
-    // check for false positives
-
-    // for loop false positive
-    for x in v {
-        println!("{}", x);
-    }
-
-    // while let false positive for Option
-    while let Some(x) = option {
-        println!("{}", x);
-        break;
-    }
-
-    // while let false positive for Result
-    while let Ok(x) = result {
-        println!("{}", x);
-        break;
-    }
-}
-
-fn main() {}
diff --git a/tests/ui/for_loop_over_fallible.stderr b/tests/ui/for_loop_over_fallible.stderr
deleted file mode 100644
index 4ce9a144ad8..00000000000
--- a/tests/ui/for_loop_over_fallible.stderr
+++ /dev/null
@@ -1,71 +0,0 @@
-error: for loop over `option`, which is an `Option`. This is more readably written as an `if let` statement.
-  --> $DIR/for_loop_over_fallible.rs:9:14
-   |
-LL |     for x in option {
-   |              ^^^^^^
-   |
-   = note: `-D clippy::for-loop-over-fallible` implied by `-D warnings`
-   = help: consider replacing `for x in option` with `if let Some(x) = option`
-
-error: for loop over `result`, which is a `Result`. This is more readably written as an `if let` statement.
-  --> $DIR/for_loop_over_fallible.rs:14:14
-   |
-LL |     for x in result {
-   |              ^^^^^^
-   |
-   = help: consider replacing `for x in result` with `if let Ok(x) = result`
-
-error: for loop over `option.ok_or("x not found")`, which is a `Result`. This is more readably written as an `if let` statement.
-  --> $DIR/for_loop_over_fallible.rs:18:14
-   |
-LL |     for x in option.ok_or("x not found") {
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: consider replacing `for x in option.ok_or("x not found")` with `if let Ok(x) = option.ok_or("x not found")`
-
-error: you are iterating over `Iterator::next()` which is an Option; this will compile but is probably not what you want
-  --> $DIR/for_loop_over_fallible.rs:24:14
-   |
-LL |     for x in v.iter().next() {
-   |              ^^^^^^^^^^^^^^^
-   |
-   = note: `#[deny(clippy::iter_next_loop)]` on by default
-
-error: for loop over `v.iter().next().and(Some(0))`, which is an `Option`. This is more readably written as an `if let` statement.
-  --> $DIR/for_loop_over_fallible.rs:29:14
-   |
-LL |     for x in v.iter().next().and(Some(0)) {
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: consider replacing `for x in v.iter().next().and(Some(0))` with `if let Some(x) = v.iter().next().and(Some(0))`
-
-error: for loop over `v.iter().next().ok_or("x not found")`, which is a `Result`. This is more readably written as an `if let` statement.
-  --> $DIR/for_loop_over_fallible.rs:33:14
-   |
-LL |     for x in v.iter().next().ok_or("x not found") {
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: consider replacing `for x in v.iter().next().ok_or("x not found")` with `if let Ok(x) = v.iter().next().ok_or("x not found")`
-
-error: this loop never actually loops
-  --> $DIR/for_loop_over_fallible.rs:45:5
-   |
-LL | /     while let Some(x) = option {
-LL | |         println!("{}", x);
-LL | |         break;
-LL | |     }
-   | |_____^
-   |
-   = note: `#[deny(clippy::never_loop)]` on by default
-
-error: this loop never actually loops
-  --> $DIR/for_loop_over_fallible.rs:51:5
-   |
-LL | /     while let Ok(x) = result {
-LL | |         println!("{}", x);
-LL | |         break;
-LL | |     }
-   | |_____^
-
-error: aborting due to 8 previous errors
-
diff --git a/tests/ui/for_loops_over_fallibles.rs b/tests/ui/for_loops_over_fallibles.rs
new file mode 100644
index 00000000000..1b9dde87cd5
--- /dev/null
+++ b/tests/ui/for_loops_over_fallibles.rs
@@ -0,0 +1,57 @@
+#![warn(clippy::for_loops_over_fallibles)]
+
+fn for_loops_over_fallibles() {
+    let option = Some(1);
+    let result = option.ok_or("x not found");
+    let v = vec![0, 1, 2];
+
+    // check over an `Option`
+    for x in option {
+        println!("{}", x);
+    }
+
+    // check over a `Result`
+    for x in result {
+        println!("{}", x);
+    }
+
+    for x in option.ok_or("x not found") {
+        println!("{}", x);
+    }
+
+    // make sure LOOP_OVER_NEXT lint takes clippy::precedence when next() is the last call
+    // in the chain
+    for x in v.iter().next() {
+        println!("{}", x);
+    }
+
+    // make sure we lint when next() is not the last call in the chain
+    for x in v.iter().next().and(Some(0)) {
+        println!("{}", x);
+    }
+
+    for x in v.iter().next().ok_or("x not found") {
+        println!("{}", x);
+    }
+
+    // check for false positives
+
+    // for loop false positive
+    for x in v {
+        println!("{}", x);
+    }
+
+    // while let false positive for Option
+    while let Some(x) = option {
+        println!("{}", x);
+        break;
+    }
+
+    // while let false positive for Result
+    while let Ok(x) = result {
+        println!("{}", x);
+        break;
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/for_loops_over_fallibles.stderr b/tests/ui/for_loops_over_fallibles.stderr
new file mode 100644
index 00000000000..bef228d4b93
--- /dev/null
+++ b/tests/ui/for_loops_over_fallibles.stderr
@@ -0,0 +1,71 @@
+error: for loop over `option`, which is an `Option`. This is more readably written as an `if let` statement.
+  --> $DIR/for_loops_over_fallibles.rs:9:14
+   |
+LL |     for x in option {
+   |              ^^^^^^
+   |
+   = note: `-D clippy::for-loops-over-fallibles` implied by `-D warnings`
+   = help: consider replacing `for x in option` with `if let Some(x) = option`
+
+error: for loop over `result`, which is a `Result`. This is more readably written as an `if let` statement.
+  --> $DIR/for_loops_over_fallibles.rs:14:14
+   |
+LL |     for x in result {
+   |              ^^^^^^
+   |
+   = help: consider replacing `for x in result` with `if let Ok(x) = result`
+
+error: for loop over `option.ok_or("x not found")`, which is a `Result`. This is more readably written as an `if let` statement.
+  --> $DIR/for_loops_over_fallibles.rs:18:14
+   |
+LL |     for x in option.ok_or("x not found") {
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider replacing `for x in option.ok_or("x not found")` with `if let Ok(x) = option.ok_or("x not found")`
+
+error: you are iterating over `Iterator::next()` which is an Option; this will compile but is probably not what you want
+  --> $DIR/for_loops_over_fallibles.rs:24:14
+   |
+LL |     for x in v.iter().next() {
+   |              ^^^^^^^^^^^^^^^
+   |
+   = note: `#[deny(clippy::iter_next_loop)]` on by default
+
+error: for loop over `v.iter().next().and(Some(0))`, which is an `Option`. This is more readably written as an `if let` statement.
+  --> $DIR/for_loops_over_fallibles.rs:29:14
+   |
+LL |     for x in v.iter().next().and(Some(0)) {
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider replacing `for x in v.iter().next().and(Some(0))` with `if let Some(x) = v.iter().next().and(Some(0))`
+
+error: for loop over `v.iter().next().ok_or("x not found")`, which is a `Result`. This is more readably written as an `if let` statement.
+  --> $DIR/for_loops_over_fallibles.rs:33:14
+   |
+LL |     for x in v.iter().next().ok_or("x not found") {
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider replacing `for x in v.iter().next().ok_or("x not found")` with `if let Ok(x) = v.iter().next().ok_or("x not found")`
+
+error: this loop never actually loops
+  --> $DIR/for_loops_over_fallibles.rs:45:5
+   |
+LL | /     while let Some(x) = option {
+LL | |         println!("{}", x);
+LL | |         break;
+LL | |     }
+   | |_____^
+   |
+   = note: `#[deny(clippy::never_loop)]` on by default
+
+error: this loop never actually loops
+  --> $DIR/for_loops_over_fallibles.rs:51:5
+   |
+LL | /     while let Ok(x) = result {
+LL | |         println!("{}", x);
+LL | |         break;
+LL | |     }
+   | |_____^
+
+error: aborting due to 8 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From fc8ab099c38952b91e38608c386314bde6dd2629 Mon Sep 17 00:00:00 2001
From: Eduardo Broto <ebroto@tutanota.com>
Date: Fri, 15 May 2020 21:17:37 +0200
Subject: identity_op: allow `1 << 0`

---
 clippy_lints/src/identity_op.rs | 22 ++++++++++++++++++++--
 tests/ui/identity_op.rs         |  5 +++++
 tests/ui/identity_op.stderr     | 20 +++++++++++++++++++-
 3 files changed, 44 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/identity_op.rs b/clippy_lints/src/identity_op.rs
index 088e4ab1921..78e07d25f67 100644
--- a/clippy_lints/src/identity_op.rs
+++ b/clippy_lints/src/identity_op.rs
@@ -1,4 +1,5 @@
-use rustc_hir::{BinOpKind, Expr, ExprKind};
+use if_chain::if_chain;
+use rustc_hir::{BinOp, BinOpKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -32,7 +33,10 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for IdentityOp {
         if e.span.from_expansion() {
             return;
         }
-        if let ExprKind::Binary(ref cmp, ref left, ref right) = e.kind {
+        if let ExprKind::Binary(cmp, ref left, ref right) = e.kind {
+            if is_allowed(cx, cmp, left, right) {
+                return;
+            }
             match cmp.node {
                 BinOpKind::Add | BinOpKind::BitOr | BinOpKind::BitXor => {
                     check(cx, left, 0, e.span, right.span);
@@ -54,6 +58,20 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for IdentityOp {
     }
 }
 
+fn is_allowed(cx: &LateContext<'_, '_>, cmp: BinOp, left: &Expr<'_>, right: &Expr<'_>) -> bool {
+    // `1 << 0` is a common pattern in bit manipulation code
+    if_chain! {
+        if let BinOpKind::Shl = cmp.node;
+        if let Some(Constant::Int(0)) = constant_simple(cx, cx.tables, right);
+        if let Some(Constant::Int(1)) = constant_simple(cx, cx.tables, left);
+        then {
+            return true;
+        }
+    }
+
+    false
+}
+
 #[allow(clippy::cast_possible_wrap)]
 fn check(cx: &LateContext<'_, '_>, e: &Expr<'_>, m: i8, span: Span, arg: Span) {
     if let Some(Constant::Int(v)) = constant_simple(cx, cx.tables, e) {
diff --git a/tests/ui/identity_op.rs b/tests/ui/identity_op.rs
index ae2815d345a..ceaacaaf6bd 100644
--- a/tests/ui/identity_op.rs
+++ b/tests/ui/identity_op.rs
@@ -33,4 +33,9 @@ fn main() {
 
     let u: u8 = 0;
     u & 255;
+
+    1 << 0; // no error, this case is allowed, see issue 3430
+    42 << 0;
+    1 >> 0;
+    42 >> 0;
 }
diff --git a/tests/ui/identity_op.stderr b/tests/ui/identity_op.stderr
index 4742877706a..d8d44a74f9a 100644
--- a/tests/ui/identity_op.stderr
+++ b/tests/ui/identity_op.stderr
@@ -48,5 +48,23 @@ error: the operation is ineffective. Consider reducing it to `u`
 LL |     u & 255;
    |     ^^^^^^^
 
-error: aborting due to 8 previous errors
+error: the operation is ineffective. Consider reducing it to `42`
+  --> $DIR/identity_op.rs:38:5
+   |
+LL |     42 << 0;
+   |     ^^^^^^^
+
+error: the operation is ineffective. Consider reducing it to `1`
+  --> $DIR/identity_op.rs:39:5
+   |
+LL |     1 >> 0;
+   |     ^^^^^^
+
+error: the operation is ineffective. Consider reducing it to `42`
+  --> $DIR/identity_op.rs:40:5
+   |
+LL |     42 >> 0;
+   |     ^^^^^^^
+
+error: aborting due to 11 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 10313a2631efa6a01dc86199d554ce5a7c1bb51a Mon Sep 17 00:00:00 2001
From: Vardan Margaryan <v.t.margaryan@gmail.com>
Date: Fri, 15 May 2020 22:33:37 +0300
Subject: Revert "Fix cases of match_wildcard_for_single_variants lint when it
 is spanned on Option"

This reverts commit 494830797744c09d6de3b2b2452ab185d2204005.
---
 clippy_lints/src/consts.rs                    | 9 ++++-----
 clippy_lints/src/escape.rs                    | 4 ++--
 clippy_lints/src/floating_point_arithmetic.rs | 2 +-
 clippy_lints/src/loops.rs                     | 2 +-
 clippy_lints/src/misc.rs                      | 2 +-
 clippy_lints/src/modulo_arithmetic.rs         | 1 -
 clippy_lints/src/utils/mod.rs                 | 2 --
 7 files changed, 9 insertions(+), 13 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/consts.rs b/clippy_lints/src/consts.rs
index efb424bcb7b..81ddc8c0067 100644
--- a/clippy_lints/src/consts.rs
+++ b/clippy_lints/src/consts.rs
@@ -139,7 +139,6 @@ impl Constant {
                 .find(|r| r.map_or(true, |o| o != Ordering::Equal))
                 .unwrap_or_else(|| Some(l.len().cmp(&r.len()))),
             (&Self::Repeat(ref lv, ref ls), &Self::Repeat(ref rv, ref rs)) => {
-                #[allow(clippy::match_wildcard_for_single_variants)]
                 match Self::partial_cmp(tcx, cmp_type, lv, rv) {
                     Some(Equal) => Some(ls.cmp(rs)),
                     x => x,
@@ -355,14 +354,14 @@ impl<'c, 'cc> ConstEvalLateContext<'c, 'cc> {
             (Some(Constant::Vec(vec)), Some(Constant::Int(index))) => match vec.get(index as usize) {
                 Some(Constant::F32(x)) => Some(Constant::F32(*x)),
                 Some(Constant::F64(x)) => Some(Constant::F64(*x)),
-                Some(_) | None => None,
+                _ => None,
             },
             (Some(Constant::Vec(vec)), _) => {
                 if !vec.is_empty() && vec.iter().all(|x| *x == vec[0]) {
                     match vec.get(0) {
                         Some(Constant::F32(x)) => Some(Constant::F32(*x)),
                         Some(Constant::F64(x)) => Some(Constant::F64(*x)),
-                        Some(_) | None => None,
+                        _ => None,
                     }
                 } else {
                     None
@@ -533,7 +532,7 @@ pub fn miri_to_const(result: &ty::Const<'_>) -> Option<Constant> {
                         })
                         .collect::<Option<Vec<Constant>>>()
                         .map(Constant::Vec),
-                    Some(_) | None => None,
+                    _ => None,
                 },
                 ty::Float(FloatTy::F64) => match miri_to_const(len) {
                     Some(Constant::Int(len)) => alloc
@@ -547,7 +546,7 @@ pub fn miri_to_const(result: &ty::Const<'_>) -> Option<Constant> {
                         })
                         .collect::<Option<Vec<Constant>>>()
                         .map(Constant::Vec),
-                    Some(_) | None => None,
+                    _ => None,
                 },
                 // FIXME: implement other array type conversions.
                 _ => None,
diff --git a/clippy_lints/src/escape.rs b/clippy_lints/src/escape.rs
index 615afee33ef..1ec60a0e6e6 100644
--- a/clippy_lints/src/escape.rs
+++ b/clippy_lints/src/escape.rs
@@ -95,12 +95,12 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for BoxedLocal {
 fn is_argument(map: rustc_middle::hir::map::Map<'_>, id: HirId) -> bool {
     match map.find(id) {
         Some(Node::Binding(_)) => (),
-        Some(_) | None => return false,
+        _ => return false,
     }
 
     match map.find(map.get_parent_node(id)) {
         Some(Node::Param(_)) => true,
-        Some(_) | None => false,
+        _ => false,
     }
 }
 
diff --git a/clippy_lints/src/floating_point_arithmetic.rs b/clippy_lints/src/floating_point_arithmetic.rs
index 8c61b2f8664..86317fb8bd5 100644
--- a/clippy_lints/src/floating_point_arithmetic.rs
+++ b/clippy_lints/src/floating_point_arithmetic.rs
@@ -410,7 +410,7 @@ fn is_zero(cx: &LateContext<'_, '_>, expr: &Expr<'_>) -> bool {
         Some(Constant::Int(i)) => i == 0,
         Some(Constant::F32(f)) => f == 0.0,
         Some(Constant::F64(f)) => f == 0.0,
-        Some(_) | None => false,
+        _ => false,
     }
 }
 
diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 39908bff5ed..0bc6b70855b 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -2154,7 +2154,7 @@ fn is_loop_nested(cx: &LateContext<'_, '_>, loop_expr: &Expr<'_>, iter_expr: &Ex
                 }
             },
             Some(Node::Stmt(_)) => (),
-            Some(_) | None => {
+            _ => {
                 return false;
             },
         }
diff --git a/clippy_lints/src/misc.rs b/clippy_lints/src/misc.rs
index 38c2645d36e..e1d524c2231 100644
--- a/clippy_lints/src/misc.rs
+++ b/clippy_lints/src/misc.rs
@@ -509,7 +509,7 @@ fn is_allowed<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr<'_>) -> boo
             Constant::F64(f) => *f == 0.0 || (*f).is_infinite(),
             _ => false,
         }),
-        Some(_) | None => false,
+        _ => false,
     }
 }
 
diff --git a/clippy_lints/src/modulo_arithmetic.rs b/clippy_lints/src/modulo_arithmetic.rs
index 3bb3eb15d9c..4ca90455bc4 100644
--- a/clippy_lints/src/modulo_arithmetic.rs
+++ b/clippy_lints/src/modulo_arithmetic.rs
@@ -37,7 +37,6 @@ struct OperandInfo {
 }
 
 fn analyze_operand(operand: &Expr<'_>, cx: &LateContext<'_, '_>, expr: &Expr<'_>) -> Option<OperandInfo> {
-    #[allow(clippy::match_wildcard_for_single_variants)]
     match constant(cx, cx.tables, operand) {
         Some((Constant::Int(v), _)) => match cx.tables.expr_ty(expr).kind {
             ty::Int(ity) => {
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index 7bc8be492e8..3b8ef18bfab 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -370,7 +370,6 @@ pub fn trait_ref_of_method<'tcx>(cx: &LateContext<'_, 'tcx>, hir_id: HirId) -> O
 
 /// Checks whether this type implements `Drop`.
 pub fn has_drop<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, ty: Ty<'tcx>) -> bool {
-    #[allow(clippy::match_wildcard_for_single_variants)]
     match ty.ty_adt_def() {
         Some(def) => def.has_dtor(cx.tcx),
         _ => false,
@@ -445,7 +444,6 @@ pub fn is_entrypoint_fn(cx: &LateContext<'_, '_>, def_id: DefId) -> bool {
 /// Gets the name of the item the expression is in, if available.
 pub fn get_item_name(cx: &LateContext<'_, '_>, expr: &Expr<'_>) -> Option<Name> {
     let parent_id = cx.tcx.hir().get_parent_item(expr.hir_id);
-    #[allow(clippy::match_wildcard_for_single_variants)]
     match cx.tcx.hir().find(parent_id) {
         Some(
             Node::Item(Item { ident, .. })
-- 
cgit 1.4.1-3-g733a5


From 2620d2449da851171773f7bec1396af11babe278 Mon Sep 17 00:00:00 2001
From: Vardan Margaryan <v.t.margaryan@gmail.com>
Date: Sat, 16 May 2020 00:06:52 +0300
Subject: Fix check for missing enum variants from match expressions

TupleStruct matches are checked for exhaustiveness
---
 clippy_lints/src/matches.rs   | 16 ++++++++++++++--
 clippy_lints/src/utils/mod.rs |  2 +-
 2 files changed, 15 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index 6fdb4cf9cd7..7d722820800 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -764,9 +764,21 @@ fn check_wild_enum_match(cx: &LateContext<'_, '_>, ex: &Expr<'_>, arms: &[Arm<'_
                 if let QPath::Resolved(_, p) = path {
                     missing_variants.retain(|e| e.ctor_def_id != Some(p.res.def_id()));
                 }
-            } else if let PatKind::TupleStruct(ref path, ..) = arm.pat.kind {
+            } else if let PatKind::TupleStruct(ref path, ref patterns, ..) = arm.pat.kind {
                 if let QPath::Resolved(_, p) = path {
-                    missing_variants.retain(|e| e.ctor_def_id != Some(p.res.def_id()));
+                    // Some simple checks for exhaustive patterns.
+                    // There is a room for improvements to detect more cases,
+                    // but it can be more expensive to do so.
+                    let is_pattern_exhaustive = |pat: &&Pat<'_>| {
+                        if let PatKind::Wild | PatKind::Binding(.., None) = pat.kind {
+                            true
+                        } else {
+                            false
+                        }
+                    };
+                    if patterns.iter().all(is_pattern_exhaustive) {
+                        missing_variants.retain(|e| e.ctor_def_id != Some(p.res.def_id()));
+                    }
                 }
             }
         }
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index 3b8ef18bfab..7545235e646 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -372,7 +372,7 @@ pub fn trait_ref_of_method<'tcx>(cx: &LateContext<'_, 'tcx>, hir_id: HirId) -> O
 pub fn has_drop<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, ty: Ty<'tcx>) -> bool {
     match ty.ty_adt_def() {
         Some(def) => def.has_dtor(cx.tcx),
-        _ => false,
+        None => false,
     }
 }
 
-- 
cgit 1.4.1-3-g733a5


From e55b920970fdc33f5ddaf7757738fbacdadf15ab Mon Sep 17 00:00:00 2001
From: ThibsG <Thibs@debian.com>
Date: Mon, 4 May 2020 17:09:02 +0200
Subject: Rename lint `identity_conversion` to `useless_conversion`

---
 CHANGELOG.md                            |   4 +-
 clippy_lints/src/identity_conversion.rs | 124 ------------------------------
 clippy_lints/src/lib.rs                 |  11 +--
 clippy_lints/src/useless_conversion.rs  | 130 ++++++++++++++++++++++++++++++++
 src/lintlist/mod.rs                     |  14 ++--
 tests/ui/identity_conversion.fixed      |  58 --------------
 tests/ui/identity_conversion.rs         |  58 --------------
 tests/ui/identity_conversion.stderr     |  68 -----------------
 tests/ui/useless_conversion.fixed       |  58 ++++++++++++++
 tests/ui/useless_conversion.rs          |  58 ++++++++++++++
 tests/ui/useless_conversion.stderr      |  68 +++++++++++++++++
 11 files changed, 329 insertions(+), 322 deletions(-)
 delete mode 100644 clippy_lints/src/identity_conversion.rs
 create mode 100644 clippy_lints/src/useless_conversion.rs
 delete mode 100644 tests/ui/identity_conversion.fixed
 delete mode 100644 tests/ui/identity_conversion.rs
 delete mode 100644 tests/ui/identity_conversion.stderr
 create mode 100644 tests/ui/useless_conversion.fixed
 create mode 100644 tests/ui/useless_conversion.rs
 create mode 100644 tests/ui/useless_conversion.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index d05819a973a..9e85e6da3b9 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -805,7 +805,7 @@ Released 2018-09-13
 
 ## 0.0.166
 * Rustup to *rustc 1.22.0-nightly (b7960878b 2017-10-18)*
-* New lints: [`explicit_write`], [`identity_conversion`], [`implicit_hasher`], [`invalid_ref`], [`option_map_or_none`],
+* New lints: [`explicit_write`], `identity_conversion`, [`implicit_hasher`], [`invalid_ref`], [`option_map_or_none`],
   [`range_minus_one`], [`range_plus_one`], [`transmute_int_to_bool`], [`transmute_int_to_char`],
   [`transmute_int_to_float`]
 
@@ -1367,7 +1367,6 @@ Released 2018-09-13
 [`future_not_send`]: https://rust-lang.github.io/rust-clippy/master/index.html#future_not_send
 [`get_last_with_len`]: https://rust-lang.github.io/rust-clippy/master/index.html#get_last_with_len
 [`get_unwrap`]: https://rust-lang.github.io/rust-clippy/master/index.html#get_unwrap
-[`identity_conversion`]: https://rust-lang.github.io/rust-clippy/master/index.html#identity_conversion
 [`identity_op`]: https://rust-lang.github.io/rust-clippy/master/index.html#identity_op
 [`if_let_mutex`]: https://rust-lang.github.io/rust-clippy/master/index.html#if_let_mutex
 [`if_let_redundant_pattern_matching`]: https://rust-lang.github.io/rust-clippy/master/index.html#if_let_redundant_pattern_matching
@@ -1624,6 +1623,7 @@ Released 2018-09-13
 [`used_underscore_binding`]: https://rust-lang.github.io/rust-clippy/master/index.html#used_underscore_binding
 [`useless_asref`]: https://rust-lang.github.io/rust-clippy/master/index.html#useless_asref
 [`useless_attribute`]: https://rust-lang.github.io/rust-clippy/master/index.html#useless_attribute
+[`useless_conversion`]: https://rust-lang.github.io/rust-clippy/master/index.html#useless_conversion
 [`useless_format`]: https://rust-lang.github.io/rust-clippy/master/index.html#useless_format
 [`useless_let_if_seq`]: https://rust-lang.github.io/rust-clippy/master/index.html#useless_let_if_seq
 [`useless_transmute`]: https://rust-lang.github.io/rust-clippy/master/index.html#useless_transmute
diff --git a/clippy_lints/src/identity_conversion.rs b/clippy_lints/src/identity_conversion.rs
deleted file mode 100644
index 33a9478f058..00000000000
--- a/clippy_lints/src/identity_conversion.rs
+++ /dev/null
@@ -1,124 +0,0 @@
-use crate::utils::{
-    match_def_path, match_trait_method, paths, same_tys, snippet, snippet_with_macro_callsite, span_lint_and_sugg,
-};
-use rustc_errors::Applicability;
-use rustc_hir::{Expr, ExprKind, HirId, MatchSource};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for always-identical `Into`/`From`/`IntoIter` conversions.
-    ///
-    /// **Why is this bad?** Redundant code.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    /// ```rust
-    /// // format!() returns a `String`
-    /// let s: String = format!("hello").into();
-    /// ```
-    pub IDENTITY_CONVERSION,
-    complexity,
-    "using always-identical `Into`/`From`/`IntoIter` conversions"
-}
-
-#[derive(Default)]
-pub struct IdentityConversion {
-    try_desugar_arm: Vec<HirId>,
-}
-
-impl_lint_pass!(IdentityConversion => [IDENTITY_CONVERSION]);
-
-impl<'a, 'tcx> LateLintPass<'a, 'tcx> for IdentityConversion {
-    fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr<'_>) {
-        if e.span.from_expansion() {
-            return;
-        }
-
-        if Some(&e.hir_id) == self.try_desugar_arm.last() {
-            return;
-        }
-
-        match e.kind {
-            ExprKind::Match(_, ref arms, MatchSource::TryDesugar) => {
-                let e = match arms[0].body.kind {
-                    ExprKind::Ret(Some(ref e)) | ExprKind::Break(_, Some(ref e)) => e,
-                    _ => return,
-                };
-                if let ExprKind::Call(_, ref args) = e.kind {
-                    self.try_desugar_arm.push(args[0].hir_id);
-                }
-            },
-
-            ExprKind::MethodCall(ref name, .., ref args) => {
-                if match_trait_method(cx, e, &paths::INTO) && &*name.ident.as_str() == "into" {
-                    let a = cx.tables.expr_ty(e);
-                    let b = cx.tables.expr_ty(&args[0]);
-                    if same_tys(cx, a, b) {
-                        let sugg = snippet_with_macro_callsite(cx, args[0].span, "<expr>").to_string();
-
-                        span_lint_and_sugg(
-                            cx,
-                            IDENTITY_CONVERSION,
-                            e.span,
-                            "identical conversion",
-                            "consider removing `.into()`",
-                            sugg,
-                            Applicability::MachineApplicable, // snippet
-                        );
-                    }
-                }
-                if match_trait_method(cx, e, &paths::INTO_ITERATOR) && &*name.ident.as_str() == "into_iter" {
-                    let a = cx.tables.expr_ty(e);
-                    let b = cx.tables.expr_ty(&args[0]);
-                    if same_tys(cx, a, b) {
-                        let sugg = snippet(cx, args[0].span, "<expr>").into_owned();
-                        span_lint_and_sugg(
-                            cx,
-                            IDENTITY_CONVERSION,
-                            e.span,
-                            "identical conversion",
-                            "consider removing `.into_iter()`",
-                            sugg,
-                            Applicability::MachineApplicable, // snippet
-                        );
-                    }
-                }
-            },
-
-            ExprKind::Call(ref path, ref args) => {
-                if let ExprKind::Path(ref qpath) = path.kind {
-                    if let Some(def_id) = cx.tables.qpath_res(qpath, path.hir_id).opt_def_id() {
-                        if match_def_path(cx, def_id, &paths::FROM_FROM) {
-                            let a = cx.tables.expr_ty(e);
-                            let b = cx.tables.expr_ty(&args[0]);
-                            if same_tys(cx, a, b) {
-                                let sugg = snippet(cx, args[0].span.source_callsite(), "<expr>").into_owned();
-                                let sugg_msg =
-                                    format!("consider removing `{}()`", snippet(cx, path.span, "From::from"));
-                                span_lint_and_sugg(
-                                    cx,
-                                    IDENTITY_CONVERSION,
-                                    e.span,
-                                    "identical conversion",
-                                    &sugg_msg,
-                                    sugg,
-                                    Applicability::MachineApplicable, // snippet
-                                );
-                            }
-                        }
-                    }
-                }
-            },
-
-            _ => {},
-        }
-    }
-
-    fn check_expr_post(&mut self, _: &LateContext<'a, 'tcx>, e: &'tcx Expr<'_>) {
-        if Some(&e.hir_id) == self.try_desugar_arm.last() {
-            self.try_desugar_arm.pop();
-        }
-    }
-}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index bda0d5c0458..4dda373738b 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -221,7 +221,6 @@ mod formatting;
 mod functions;
 mod future_not_send;
 mod get_last_with_len;
-mod identity_conversion;
 mod identity_op;
 mod if_let_mutex;
 mod if_let_some_result;
@@ -324,6 +323,7 @@ mod unused_io_amount;
 mod unused_self;
 mod unwrap;
 mod use_self;
+mod useless_conversion;
 mod vec;
 mod verbose_file_reads;
 mod wildcard_dependencies;
@@ -577,7 +577,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &functions::TOO_MANY_LINES,
         &future_not_send::FUTURE_NOT_SEND,
         &get_last_with_len::GET_LAST_WITH_LEN,
-        &identity_conversion::IDENTITY_CONVERSION,
         &identity_op::IDENTITY_OP,
         &if_let_mutex::IF_LET_MUTEX,
         &if_let_some_result::IF_LET_SOME_RESULT,
@@ -843,6 +842,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &unwrap::PANICKING_UNWRAP,
         &unwrap::UNNECESSARY_UNWRAP,
         &use_self::USE_SELF,
+        &useless_conversion::USELESS_CONVERSION,
         &utils::internal_lints::CLIPPY_LINTS_INTERNAL,
         &utils::internal_lints::COLLAPSIBLE_SPAN_LINT_CALLS,
         &utils::internal_lints::COMPILER_LINT_FUNCTIONS,
@@ -980,7 +980,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box bytecount::ByteCount);
     store.register_late_pass(|| box infinite_iter::InfiniteIter);
     store.register_late_pass(|| box inline_fn_without_body::InlineFnWithoutBody);
-    store.register_late_pass(|| box identity_conversion::IdentityConversion::default());
+    store.register_late_pass(|| box useless_conversion::UselessConversion::default());
     store.register_late_pass(|| box types::ImplicitHasher);
     store.register_late_pass(|| box fallible_impl_from::FallibleImplFrom);
     store.register_late_pass(|| box types::UnitArg);
@@ -1241,7 +1241,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&functions::NOT_UNSAFE_PTR_ARG_DEREF),
         LintId::of(&functions::TOO_MANY_ARGUMENTS),
         LintId::of(&get_last_with_len::GET_LAST_WITH_LEN),
-        LintId::of(&identity_conversion::IDENTITY_CONVERSION),
         LintId::of(&identity_op::IDENTITY_OP),
         LintId::of(&if_let_mutex::IF_LET_MUTEX),
         LintId::of(&if_let_some_result::IF_LET_SOME_RESULT),
@@ -1427,6 +1426,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&unused_io_amount::UNUSED_IO_AMOUNT),
         LintId::of(&unwrap::PANICKING_UNWRAP),
         LintId::of(&unwrap::UNNECESSARY_UNWRAP),
+        LintId::of(&useless_conversion::USELESS_CONVERSION),
         LintId::of(&vec::USELESS_VEC),
         LintId::of(&write::PRINTLN_EMPTY_STRING),
         LintId::of(&write::PRINT_LITERAL),
@@ -1546,7 +1546,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&format::USELESS_FORMAT),
         LintId::of(&functions::TOO_MANY_ARGUMENTS),
         LintId::of(&get_last_with_len::GET_LAST_WITH_LEN),
-        LintId::of(&identity_conversion::IDENTITY_CONVERSION),
         LintId::of(&identity_op::IDENTITY_OP),
         LintId::of(&int_plus_one::INT_PLUS_ONE),
         LintId::of(&lifetimes::EXTRA_UNUSED_LIFETIMES),
@@ -1605,6 +1604,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&types::UNNECESSARY_CAST),
         LintId::of(&types::VEC_BOX),
         LintId::of(&unwrap::UNNECESSARY_UNWRAP),
+        LintId::of(&useless_conversion::USELESS_CONVERSION),
         LintId::of(&zero_div_zero::ZERO_DIVIDED_BY_ZERO),
     ]);
 
@@ -1795,6 +1795,7 @@ pub fn register_renamed(ls: &mut rustc_lint::LintStore) {
     ls.register_renamed("clippy::result_expect_used", "clippy::expect_used");
     ls.register_renamed("clippy::for_loop_over_option", "clippy::for_loops_over_fallibles");
     ls.register_renamed("clippy::for_loop_over_result", "clippy::for_loops_over_fallibles");
+    ls.register_renamed("clippy::identity_conversion", "clippy::useless_conversion");
 }
 
 // only exists to let the dogfood integration test works.
diff --git a/clippy_lints/src/useless_conversion.rs b/clippy_lints/src/useless_conversion.rs
new file mode 100644
index 00000000000..95921518986
--- /dev/null
+++ b/clippy_lints/src/useless_conversion.rs
@@ -0,0 +1,130 @@
+use crate::utils::{
+    match_def_path, match_trait_method, paths, same_tys, snippet, snippet_with_macro_callsite, span_lint_and_sugg,
+};
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind, HirId, MatchSource};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for `Into`/`From`/`IntoIter` calls that useless converts
+    /// to the same type as caller.
+    ///
+    /// **Why is this bad?** Redundant code.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// // Bad
+    /// // format!() returns a `String`
+    /// let s: String = format!("hello").into();
+    ///
+    /// // Good
+    /// let s: String = format!("hello");
+    /// ```
+    pub USELESS_CONVERSION,
+    complexity,
+    "calls to `Into`/`From`/`IntoIter` that performs useless conversions to the same type"
+}
+
+#[derive(Default)]
+pub struct UselessConversion {
+    try_desugar_arm: Vec<HirId>,
+}
+
+impl_lint_pass!(UselessConversion => [USELESS_CONVERSION]);
+
+impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UselessConversion {
+    fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr<'_>) {
+        if e.span.from_expansion() {
+            return;
+        }
+
+        if Some(&e.hir_id) == self.try_desugar_arm.last() {
+            return;
+        }
+
+        match e.kind {
+            ExprKind::Match(_, ref arms, MatchSource::TryDesugar) => {
+                let e = match arms[0].body.kind {
+                    ExprKind::Ret(Some(ref e)) | ExprKind::Break(_, Some(ref e)) => e,
+                    _ => return,
+                };
+                if let ExprKind::Call(_, ref args) = e.kind {
+                    self.try_desugar_arm.push(args[0].hir_id);
+                }
+            },
+
+            ExprKind::MethodCall(ref name, .., ref args) => {
+                if match_trait_method(cx, e, &paths::INTO) && &*name.ident.as_str() == "into" {
+                    let a = cx.tables.expr_ty(e);
+                    let b = cx.tables.expr_ty(&args[0]);
+                    if same_tys(cx, a, b) {
+                        let sugg = snippet_with_macro_callsite(cx, args[0].span, "<expr>").to_string();
+
+                        span_lint_and_sugg(
+                            cx,
+                            USELESS_CONVERSION,
+                            e.span,
+                            "useless conversion",
+                            "consider removing `.into()`",
+                            sugg,
+                            Applicability::MachineApplicable, // snippet
+                        );
+                    }
+                }
+                if match_trait_method(cx, e, &paths::INTO_ITERATOR) && &*name.ident.as_str() == "into_iter" {
+                    let a = cx.tables.expr_ty(e);
+                    let b = cx.tables.expr_ty(&args[0]);
+                    if same_tys(cx, a, b) {
+                        let sugg = snippet(cx, args[0].span, "<expr>").into_owned();
+                        span_lint_and_sugg(
+                            cx,
+                            USELESS_CONVERSION,
+                            e.span,
+                            "useless conversion",
+                            "consider removing `.into_iter()`",
+                            sugg,
+                            Applicability::MachineApplicable, // snippet
+                        );
+                    }
+                }
+            },
+
+            ExprKind::Call(ref path, ref args) => {
+                if let ExprKind::Path(ref qpath) = path.kind {
+                    if let Some(def_id) = cx.tables.qpath_res(qpath, path.hir_id).opt_def_id() {
+                        if match_def_path(cx, def_id, &paths::FROM_FROM) {
+                            let a = cx.tables.expr_ty(e);
+                            let b = cx.tables.expr_ty(&args[0]);
+                            if same_tys(cx, a, b) {
+                                let sugg = snippet(cx, args[0].span.source_callsite(), "<expr>").into_owned();
+                                let sugg_msg =
+                                    format!("consider removing `{}()`", snippet(cx, path.span, "From::from"));
+                                span_lint_and_sugg(
+                                    cx,
+                                    USELESS_CONVERSION,
+                                    e.span,
+                                    "useless conversion",
+                                    &sugg_msg,
+                                    sugg,
+                                    Applicability::MachineApplicable, // snippet
+                                );
+                            }
+                        }
+                    }
+                }
+            },
+
+            _ => {},
+        }
+    }
+
+    fn check_expr_post(&mut self, _: &LateContext<'a, 'tcx>, e: &'tcx Expr<'_>) {
+        if Some(&e.hir_id) == self.try_desugar_arm.last() {
+            self.try_desugar_arm.pop();
+        }
+    }
+}
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index e5e3bf453a0..e411e60782a 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -717,13 +717,6 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
         deprecation: None,
         module: "methods",
     },
-    Lint {
-        name: "identity_conversion",
-        group: "complexity",
-        desc: "using always-identical `Into`/`From`/`IntoIter` conversions",
-        deprecation: None,
-        module: "identity_conversion",
-    },
     Lint {
         name: "identity_op",
         group: "complexity",
@@ -2418,6 +2411,13 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
         deprecation: None,
         module: "attrs",
     },
+    Lint {
+        name: "useless_conversion",
+        group: "complexity",
+        desc: "calls to `Into`/`From`/`IntoIter` that performs useless conversions to the same type",
+        deprecation: None,
+        module: "useless_conversion",
+    },
     Lint {
         name: "useless_format",
         group: "complexity",
diff --git a/tests/ui/identity_conversion.fixed b/tests/ui/identity_conversion.fixed
deleted file mode 100644
index dd3fc56e98b..00000000000
--- a/tests/ui/identity_conversion.fixed
+++ /dev/null
@@ -1,58 +0,0 @@
-// run-rustfix
-
-#![deny(clippy::identity_conversion)]
-
-fn test_generic<T: Copy>(val: T) -> T {
-    let _ = val;
-    val
-}
-
-fn test_generic2<T: Copy + Into<i32> + Into<U>, U: From<T>>(val: T) {
-    // ok
-    let _: i32 = val.into();
-    let _: U = val.into();
-    let _ = U::from(val);
-}
-
-fn test_questionmark() -> Result<(), ()> {
-    {
-        let _: i32 = 0i32;
-        Ok(Ok(()))
-    }??;
-    Ok(())
-}
-
-fn test_issue_3913() -> Result<(), std::io::Error> {
-    use std::fs;
-    use std::path::Path;
-
-    let path = Path::new(".");
-    for _ in fs::read_dir(path)? {}
-
-    Ok(())
-}
-
-fn main() {
-    test_generic(10i32);
-    test_generic2::<i32, i32>(10i32);
-    test_questionmark().unwrap();
-    test_issue_3913().unwrap();
-
-    let _: String = "foo".into();
-    let _: String = From::from("foo");
-    let _ = String::from("foo");
-    #[allow(clippy::identity_conversion)]
-    {
-        let _: String = "foo".into();
-        let _ = String::from("foo");
-        let _ = "".lines().into_iter();
-    }
-
-    let _: String = "foo".to_string();
-    let _: String = "foo".to_string();
-    let _ = "foo".to_string();
-    let _ = format!("A: {:04}", 123);
-    let _ = "".lines();
-    let _ = vec![1, 2, 3].into_iter();
-    let _: String = format!("Hello {}", "world");
-}
diff --git a/tests/ui/identity_conversion.rs b/tests/ui/identity_conversion.rs
deleted file mode 100644
index 875ed7db373..00000000000
--- a/tests/ui/identity_conversion.rs
+++ /dev/null
@@ -1,58 +0,0 @@
-// run-rustfix
-
-#![deny(clippy::identity_conversion)]
-
-fn test_generic<T: Copy>(val: T) -> T {
-    let _ = T::from(val);
-    val.into()
-}
-
-fn test_generic2<T: Copy + Into<i32> + Into<U>, U: From<T>>(val: T) {
-    // ok
-    let _: i32 = val.into();
-    let _: U = val.into();
-    let _ = U::from(val);
-}
-
-fn test_questionmark() -> Result<(), ()> {
-    {
-        let _: i32 = 0i32.into();
-        Ok(Ok(()))
-    }??;
-    Ok(())
-}
-
-fn test_issue_3913() -> Result<(), std::io::Error> {
-    use std::fs;
-    use std::path::Path;
-
-    let path = Path::new(".");
-    for _ in fs::read_dir(path)? {}
-
-    Ok(())
-}
-
-fn main() {
-    test_generic(10i32);
-    test_generic2::<i32, i32>(10i32);
-    test_questionmark().unwrap();
-    test_issue_3913().unwrap();
-
-    let _: String = "foo".into();
-    let _: String = From::from("foo");
-    let _ = String::from("foo");
-    #[allow(clippy::identity_conversion)]
-    {
-        let _: String = "foo".into();
-        let _ = String::from("foo");
-        let _ = "".lines().into_iter();
-    }
-
-    let _: String = "foo".to_string().into();
-    let _: String = From::from("foo".to_string());
-    let _ = String::from("foo".to_string());
-    let _ = String::from(format!("A: {:04}", 123));
-    let _ = "".lines().into_iter();
-    let _ = vec![1, 2, 3].into_iter().into_iter();
-    let _: String = format!("Hello {}", "world").into();
-}
diff --git a/tests/ui/identity_conversion.stderr b/tests/ui/identity_conversion.stderr
deleted file mode 100644
index 57626b23795..00000000000
--- a/tests/ui/identity_conversion.stderr
+++ /dev/null
@@ -1,68 +0,0 @@
-error: identical conversion
-  --> $DIR/identity_conversion.rs:6:13
-   |
-LL |     let _ = T::from(val);
-   |             ^^^^^^^^^^^^ help: consider removing `T::from()`: `val`
-   |
-note: the lint level is defined here
-  --> $DIR/identity_conversion.rs:3:9
-   |
-LL | #![deny(clippy::identity_conversion)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: identical conversion
-  --> $DIR/identity_conversion.rs:7:5
-   |
-LL |     val.into()
-   |     ^^^^^^^^^^ help: consider removing `.into()`: `val`
-
-error: identical conversion
-  --> $DIR/identity_conversion.rs:19:22
-   |
-LL |         let _: i32 = 0i32.into();
-   |                      ^^^^^^^^^^^ help: consider removing `.into()`: `0i32`
-
-error: identical conversion
-  --> $DIR/identity_conversion.rs:51:21
-   |
-LL |     let _: String = "foo".to_string().into();
-   |                     ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into()`: `"foo".to_string()`
-
-error: identical conversion
-  --> $DIR/identity_conversion.rs:52:21
-   |
-LL |     let _: String = From::from("foo".to_string());
-   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `From::from()`: `"foo".to_string()`
-
-error: identical conversion
-  --> $DIR/identity_conversion.rs:53:13
-   |
-LL |     let _ = String::from("foo".to_string());
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `String::from()`: `"foo".to_string()`
-
-error: identical conversion
-  --> $DIR/identity_conversion.rs:54:13
-   |
-LL |     let _ = String::from(format!("A: {:04}", 123));
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `String::from()`: `format!("A: {:04}", 123)`
-
-error: identical conversion
-  --> $DIR/identity_conversion.rs:55:13
-   |
-LL |     let _ = "".lines().into_iter();
-   |             ^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `"".lines()`
-
-error: identical conversion
-  --> $DIR/identity_conversion.rs:56:13
-   |
-LL |     let _ = vec![1, 2, 3].into_iter().into_iter();
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `vec![1, 2, 3].into_iter()`
-
-error: identical conversion
-  --> $DIR/identity_conversion.rs:57:21
-   |
-LL |     let _: String = format!("Hello {}", "world").into();
-   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into()`: `format!("Hello {}", "world")`
-
-error: aborting due to 10 previous errors
-
diff --git a/tests/ui/useless_conversion.fixed b/tests/ui/useless_conversion.fixed
new file mode 100644
index 00000000000..fdd4bc581f3
--- /dev/null
+++ b/tests/ui/useless_conversion.fixed
@@ -0,0 +1,58 @@
+// run-rustfix
+
+#![deny(clippy::useless_conversion)]
+
+fn test_generic<T: Copy>(val: T) -> T {
+    let _ = val;
+    val
+}
+
+fn test_generic2<T: Copy + Into<i32> + Into<U>, U: From<T>>(val: T) {
+    // ok
+    let _: i32 = val.into();
+    let _: U = val.into();
+    let _ = U::from(val);
+}
+
+fn test_questionmark() -> Result<(), ()> {
+    {
+        let _: i32 = 0i32;
+        Ok(Ok(()))
+    }??;
+    Ok(())
+}
+
+fn test_issue_3913() -> Result<(), std::io::Error> {
+    use std::fs;
+    use std::path::Path;
+
+    let path = Path::new(".");
+    for _ in fs::read_dir(path)? {}
+
+    Ok(())
+}
+
+fn main() {
+    test_generic(10i32);
+    test_generic2::<i32, i32>(10i32);
+    test_questionmark().unwrap();
+    test_issue_3913().unwrap();
+
+    let _: String = "foo".into();
+    let _: String = From::from("foo");
+    let _ = String::from("foo");
+    #[allow(clippy::useless_conversion)]
+    {
+        let _: String = "foo".into();
+        let _ = String::from("foo");
+        let _ = "".lines().into_iter();
+    }
+
+    let _: String = "foo".to_string();
+    let _: String = "foo".to_string();
+    let _ = "foo".to_string();
+    let _ = format!("A: {:04}", 123);
+    let _ = "".lines();
+    let _ = vec![1, 2, 3].into_iter();
+    let _: String = format!("Hello {}", "world");
+}
diff --git a/tests/ui/useless_conversion.rs b/tests/ui/useless_conversion.rs
new file mode 100644
index 00000000000..4cae745e7c0
--- /dev/null
+++ b/tests/ui/useless_conversion.rs
@@ -0,0 +1,58 @@
+// run-rustfix
+
+#![deny(clippy::useless_conversion)]
+
+fn test_generic<T: Copy>(val: T) -> T {
+    let _ = T::from(val);
+    val.into()
+}
+
+fn test_generic2<T: Copy + Into<i32> + Into<U>, U: From<T>>(val: T) {
+    // ok
+    let _: i32 = val.into();
+    let _: U = val.into();
+    let _ = U::from(val);
+}
+
+fn test_questionmark() -> Result<(), ()> {
+    {
+        let _: i32 = 0i32.into();
+        Ok(Ok(()))
+    }??;
+    Ok(())
+}
+
+fn test_issue_3913() -> Result<(), std::io::Error> {
+    use std::fs;
+    use std::path::Path;
+
+    let path = Path::new(".");
+    for _ in fs::read_dir(path)? {}
+
+    Ok(())
+}
+
+fn main() {
+    test_generic(10i32);
+    test_generic2::<i32, i32>(10i32);
+    test_questionmark().unwrap();
+    test_issue_3913().unwrap();
+
+    let _: String = "foo".into();
+    let _: String = From::from("foo");
+    let _ = String::from("foo");
+    #[allow(clippy::useless_conversion)]
+    {
+        let _: String = "foo".into();
+        let _ = String::from("foo");
+        let _ = "".lines().into_iter();
+    }
+
+    let _: String = "foo".to_string().into();
+    let _: String = From::from("foo".to_string());
+    let _ = String::from("foo".to_string());
+    let _ = String::from(format!("A: {:04}", 123));
+    let _ = "".lines().into_iter();
+    let _ = vec![1, 2, 3].into_iter().into_iter();
+    let _: String = format!("Hello {}", "world").into();
+}
diff --git a/tests/ui/useless_conversion.stderr b/tests/ui/useless_conversion.stderr
new file mode 100644
index 00000000000..7df3507edfd
--- /dev/null
+++ b/tests/ui/useless_conversion.stderr
@@ -0,0 +1,68 @@
+error: useless conversion
+  --> $DIR/useless_conversion.rs:6:13
+   |
+LL |     let _ = T::from(val);
+   |             ^^^^^^^^^^^^ help: consider removing `T::from()`: `val`
+   |
+note: the lint level is defined here
+  --> $DIR/useless_conversion.rs:3:9
+   |
+LL | #![deny(clippy::useless_conversion)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: useless conversion
+  --> $DIR/useless_conversion.rs:7:5
+   |
+LL |     val.into()
+   |     ^^^^^^^^^^ help: consider removing `.into()`: `val`
+
+error: useless conversion
+  --> $DIR/useless_conversion.rs:19:22
+   |
+LL |         let _: i32 = 0i32.into();
+   |                      ^^^^^^^^^^^ help: consider removing `.into()`: `0i32`
+
+error: useless conversion
+  --> $DIR/useless_conversion.rs:51:21
+   |
+LL |     let _: String = "foo".to_string().into();
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into()`: `"foo".to_string()`
+
+error: useless conversion
+  --> $DIR/useless_conversion.rs:52:21
+   |
+LL |     let _: String = From::from("foo".to_string());
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `From::from()`: `"foo".to_string()`
+
+error: useless conversion
+  --> $DIR/useless_conversion.rs:53:13
+   |
+LL |     let _ = String::from("foo".to_string());
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `String::from()`: `"foo".to_string()`
+
+error: useless conversion
+  --> $DIR/useless_conversion.rs:54:13
+   |
+LL |     let _ = String::from(format!("A: {:04}", 123));
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `String::from()`: `format!("A: {:04}", 123)`
+
+error: useless conversion
+  --> $DIR/useless_conversion.rs:55:13
+   |
+LL |     let _ = "".lines().into_iter();
+   |             ^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `"".lines()`
+
+error: useless conversion
+  --> $DIR/useless_conversion.rs:56:13
+   |
+LL |     let _ = vec![1, 2, 3].into_iter().into_iter();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `vec![1, 2, 3].into_iter()`
+
+error: useless conversion
+  --> $DIR/useless_conversion.rs:57:21
+   |
+LL |     let _: String = format!("Hello {}", "world").into();
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into()`: `format!("Hello {}", "world")`
+
+error: aborting due to 10 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From cb7f9679a63075b3fce2fdc69f7b02fe0f482464 Mon Sep 17 00:00:00 2001
From: Aleksei Latyshev <alex_700_95@mail.ru>
Date: Sat, 25 Apr 2020 20:52:00 +0300
Subject: simplify multispan_sugg interface

- add `multispan_sugg_with_applicability`
- not it gets `&str` instead of `String`, like in `diag.multispan_suggestion`
---
 clippy_lints/src/eq_op.rs                  |  2 +-
 clippy_lints/src/loops.rs                  |  4 ++--
 clippy_lints/src/matches.rs                |  2 +-
 clippy_lints/src/needless_pass_by_value.rs |  2 +-
 clippy_lints/src/types.rs                  |  2 +-
 clippy_lints/src/utils/diagnostics.rs      | 28 ++++++++++++++--------------
 6 files changed, 20 insertions(+), 20 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/eq_op.rs b/clippy_lints/src/eq_op.rs
index 098d47bdd40..4e1c1f13140 100644
--- a/clippy_lints/src/eq_op.rs
+++ b/clippy_lints/src/eq_op.rs
@@ -115,7 +115,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for EqOp {
                                     let rsnip = snippet(cx, r.span, "...").to_string();
                                     multispan_sugg(
                                         diag,
-                                        "use the values directly".to_string(),
+                                        "use the values directly",
                                         vec![(left.span, lsnip), (right.span, rsnip)],
                                     );
                                 },
diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 9c9d1a84003..4a9c411d7c8 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -1134,7 +1134,7 @@ fn check_for_loop_range<'a, 'tcx>(
                         |diag| {
                             multispan_sugg(
                                 diag,
-                                "consider using an iterator".to_string(),
+                                "consider using an iterator",
                                 vec![
                                     (pat.span, format!("({}, <item>)", ident.name)),
                                     (
@@ -1163,7 +1163,7 @@ fn check_for_loop_range<'a, 'tcx>(
                         |diag| {
                             multispan_sugg(
                                 diag,
-                                "consider using an iterator".to_string(),
+                                "consider using an iterator",
                                 vec![(pat.span, "<item>".to_string()), (arg.span, repl)],
                             );
                         },
diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index 8f86535ef1e..bbf14374a1f 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -820,7 +820,7 @@ fn check_match_ref_pats(cx: &LateContext<'_, '_>, ex: &Expr<'_>, arms: &[Arm<'_>
 
         span_lint_and_then(cx, MATCH_REF_PATS, expr.span, title, |diag| {
             if !expr.span.from_expansion() {
-                multispan_sugg(diag, msg.to_owned(), suggs);
+                multispan_sugg(diag, msg, suggs);
             }
         });
     }
diff --git a/clippy_lints/src/needless_pass_by_value.rs b/clippy_lints/src/needless_pass_by_value.rs
index a21818701da..ed48ab54897 100644
--- a/clippy_lints/src/needless_pass_by_value.rs
+++ b/clippy_lints/src/needless_pass_by_value.rs
@@ -293,7 +293,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NeedlessPassByValue {
                             );
                             spans.sort_by_key(|&(span, _)| span);
                         }
-                        multispan_sugg(diag, "consider taking a reference instead".to_string(), spans);
+                        multispan_sugg(diag, "consider taking a reference instead", spans);
                     };
 
                     span_lint_and_then(
diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs
index 6d49f50d550..f50adbc48ab 100644
--- a/clippy_lints/src/types.rs
+++ b/clippy_lints/src/types.rs
@@ -2206,7 +2206,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for ImplicitHasher {
 
             multispan_sugg(
                 diag,
-                "consider adding a type parameter".to_string(),
+                "consider adding a type parameter",
                 vec![
                     (
                         generics_suggestion_span,
diff --git a/clippy_lints/src/utils/diagnostics.rs b/clippy_lints/src/utils/diagnostics.rs
index 24a1bdf1883..f6d87c8532e 100644
--- a/clippy_lints/src/utils/diagnostics.rs
+++ b/clippy_lints/src/utils/diagnostics.rs
@@ -1,6 +1,6 @@
 //! Clippy wrappers around rustc's diagnostic functions.
 
-use rustc_errors::{Applicability, CodeSuggestion, DiagnosticBuilder, Substitution, SubstitutionPart, SuggestionStyle};
+use rustc_errors::{Applicability, DiagnosticBuilder};
 use rustc_hir::HirId;
 use rustc_lint::{LateContext, Lint, LintContext};
 use rustc_span::source_map::{MultiSpan, Span};
@@ -198,20 +198,20 @@ pub fn span_lint_and_sugg<'a, T: LintContext>(
 /// appear once per
 /// replacement. In human-readable format though, it only appears once before
 /// the whole suggestion.
-pub fn multispan_sugg<I>(diag: &mut DiagnosticBuilder<'_>, help_msg: String, sugg: I)
+pub fn multispan_sugg<I>(diag: &mut DiagnosticBuilder<'_>, help_msg: &str, sugg: I)
 where
     I: IntoIterator<Item = (Span, String)>,
 {
-    let sugg = CodeSuggestion {
-        substitutions: vec![Substitution {
-            parts: sugg
-                .into_iter()
-                .map(|(span, snippet)| SubstitutionPart { snippet, span })
-                .collect(),
-        }],
-        msg: help_msg,
-        style: SuggestionStyle::ShowCode,
-        applicability: Applicability::Unspecified,
-    };
-    diag.suggestions.push(sugg);
+    multispan_sugg_with_applicability(diag, help_msg, Applicability::Unspecified, sugg)
+}
+
+pub fn multispan_sugg_with_applicability<I>(
+    diag: &mut DiagnosticBuilder<'_>,
+    help_msg: &str,
+    applicability: Applicability,
+    sugg: I,
+) where
+    I: IntoIterator<Item = (Span, String)>,
+{
+    diag.multipart_suggestion(help_msg, sugg.into_iter().collect(), applicability);
 }
-- 
cgit 1.4.1-3-g733a5


From 07f1edf2d43efa0ef53e5b6c56c895bc9738ab94 Mon Sep 17 00:00:00 2001
From: Aleksei Latyshev <alex_700_95@mail.ru>
Date: Sat, 25 Apr 2020 23:33:11 +0300
Subject: improve and generalize `option_and_then_some` lint

- rename it to bind_instead_of_map
---
 CHANGELOG.md                                    |   4 +-
 clippy_lints/src/lib.rs                         |   7 +-
 clippy_lints/src/loops.rs                       |   2 +-
 clippy_lints/src/methods/bind_instead_of_map.rs | 309 ++++++++++++++++++++++++
 clippy_lints/src/methods/mod.rs                 | 100 ++------
 clippy_lints/src/types.rs                       |   2 +-
 src/lintlist/mod.rs                             |  14 +-
 tests/ui/bind_instead_of_map.fixed              |  25 ++
 tests/ui/bind_instead_of_map.rs                 |  25 ++
 tests/ui/bind_instead_of_map.stderr             |  26 ++
 tests/ui/bind_instead_of_map_multipart.rs       |  61 +++++
 tests/ui/bind_instead_of_map_multipart.stderr   |  73 ++++++
 tests/ui/blocks_in_if_conditions.fixed          |   4 +-
 tests/ui/blocks_in_if_conditions.rs             |   4 +-
 tests/ui/option_and_then_some.fixed             |  25 --
 tests/ui/option_and_then_some.rs                |  25 --
 tests/ui/option_and_then_some.stderr            |  20 --
 tests/ui/option_map_or_none.fixed               |   2 +-
 tests/ui/option_map_or_none.rs                  |   2 +-
 19 files changed, 564 insertions(+), 166 deletions(-)
 create mode 100644 clippy_lints/src/methods/bind_instead_of_map.rs
 create mode 100644 tests/ui/bind_instead_of_map.fixed
 create mode 100644 tests/ui/bind_instead_of_map.rs
 create mode 100644 tests/ui/bind_instead_of_map.stderr
 create mode 100644 tests/ui/bind_instead_of_map_multipart.rs
 create mode 100644 tests/ui/bind_instead_of_map_multipart.stderr
 delete mode 100644 tests/ui/option_and_then_some.fixed
 delete mode 100644 tests/ui/option_and_then_some.rs
 delete mode 100644 tests/ui/option_and_then_some.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index d05819a973a..7abefe65424 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -315,7 +315,7 @@ Released 2019-11-07
   * [`missing_safety_doc`] [#4535](https://github.com/rust-lang/rust-clippy/pull/4535)
   * [`mem_replace_with_uninit`] [#4511](https://github.com/rust-lang/rust-clippy/pull/4511)
   * [`suspicious_map`] [#4394](https://github.com/rust-lang/rust-clippy/pull/4394)
-  * [`option_and_then_some`] [#4386](https://github.com/rust-lang/rust-clippy/pull/4386)
+  * `option_and_then_some` [#4386](https://github.com/rust-lang/rust-clippy/pull/4386)
   * [`manual_saturating_arithmetic`] [#4498](https://github.com/rust-lang/rust-clippy/pull/4498)
 * Deprecate `unused_collect` lint. This is fully covered by rustc's `#[must_use]` on `collect` [#4348](https://github.com/rust-lang/rust-clippy/pull/4348)
 * Move `type_repetition_in_bounds` to pedantic group [#4403](https://github.com/rust-lang/rust-clippy/pull/4403)
@@ -1273,6 +1273,7 @@ Released 2018-09-13
 [`assign_ops`]: https://rust-lang.github.io/rust-clippy/master/index.html#assign_ops
 [`await_holding_lock`]: https://rust-lang.github.io/rust-clippy/master/index.html#await_holding_lock
 [`bad_bit_mask`]: https://rust-lang.github.io/rust-clippy/master/index.html#bad_bit_mask
+[`bind_instead_of_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#bind_instead_of_map
 [`blacklisted_name`]: https://rust-lang.github.io/rust-clippy/master/index.html#blacklisted_name
 [`blocks_in_if_conditions`]: https://rust-lang.github.io/rust-clippy/master/index.html#blocks_in_if_conditions
 [`bool_comparison`]: https://rust-lang.github.io/rust-clippy/master/index.html#bool_comparison
@@ -1494,7 +1495,6 @@ Released 2018-09-13
 [`not_unsafe_ptr_arg_deref`]: https://rust-lang.github.io/rust-clippy/master/index.html#not_unsafe_ptr_arg_deref
 [`ok_expect`]: https://rust-lang.github.io/rust-clippy/master/index.html#ok_expect
 [`op_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#op_ref
-[`option_and_then_some`]: https://rust-lang.github.io/rust-clippy/master/index.html#option_and_then_some
 [`option_as_ref_deref`]: https://rust-lang.github.io/rust-clippy/master/index.html#option_as_ref_deref
 [`option_env_unwrap`]: https://rust-lang.github.io/rust-clippy/master/index.html#option_env_unwrap
 [`option_map_or_none`]: https://rust-lang.github.io/rust-clippy/master/index.html#option_map_or_none
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index bda0d5c0458..ec198b684b6 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -650,6 +650,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &mem_replace::MEM_REPLACE_OPTION_WITH_NONE,
         &mem_replace::MEM_REPLACE_WITH_DEFAULT,
         &mem_replace::MEM_REPLACE_WITH_UNINIT,
+        &methods::BIND_INSTEAD_OF_MAP,
         &methods::CHARS_LAST_CMP,
         &methods::CHARS_NEXT_CMP,
         &methods::CLONE_DOUBLE_REF,
@@ -676,7 +677,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &methods::MAP_UNWRAP_OR,
         &methods::NEW_RET_NO_SELF,
         &methods::OK_EXPECT,
-        &methods::OPTION_AND_THEN_SOME,
         &methods::OPTION_AS_REF_DEREF,
         &methods::OPTION_MAP_OR_NONE,
         &methods::OR_FUN_CALL,
@@ -1291,6 +1291,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&mem_replace::MEM_REPLACE_OPTION_WITH_NONE),
         LintId::of(&mem_replace::MEM_REPLACE_WITH_DEFAULT),
         LintId::of(&mem_replace::MEM_REPLACE_WITH_UNINIT),
+        LintId::of(&methods::BIND_INSTEAD_OF_MAP),
         LintId::of(&methods::CHARS_LAST_CMP),
         LintId::of(&methods::CHARS_NEXT_CMP),
         LintId::of(&methods::CLONE_DOUBLE_REF),
@@ -1307,7 +1308,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&methods::MANUAL_SATURATING_ARITHMETIC),
         LintId::of(&methods::NEW_RET_NO_SELF),
         LintId::of(&methods::OK_EXPECT),
-        LintId::of(&methods::OPTION_AND_THEN_SOME),
         LintId::of(&methods::OPTION_AS_REF_DEREF),
         LintId::of(&methods::OPTION_MAP_OR_NONE),
         LintId::of(&methods::OR_FUN_CALL),
@@ -1559,10 +1559,10 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&matches::MATCH_AS_REF),
         LintId::of(&matches::MATCH_SINGLE_BINDING),
         LintId::of(&matches::WILDCARD_IN_OR_PATTERNS),
+        LintId::of(&methods::BIND_INSTEAD_OF_MAP),
         LintId::of(&methods::CLONE_ON_COPY),
         LintId::of(&methods::FILTER_NEXT),
         LintId::of(&methods::FLAT_MAP_IDENTITY),
-        LintId::of(&methods::OPTION_AND_THEN_SOME),
         LintId::of(&methods::OPTION_AS_REF_DEREF),
         LintId::of(&methods::SEARCH_IS_SOME),
         LintId::of(&methods::SKIP_WHILE_NEXT),
@@ -1784,6 +1784,7 @@ pub fn register_renamed(ls: &mut rustc_lint::LintStore) {
     ls.register_renamed("clippy::new_without_default_derive", "clippy::new_without_default");
     ls.register_renamed("clippy::cyclomatic_complexity", "clippy::cognitive_complexity");
     ls.register_renamed("clippy::const_static_lifetime", "clippy::redundant_static_lifetimes");
+    ls.register_renamed("clippy::option_and_then_some", "clippy::bind_instead_of_map");
     ls.register_renamed("clippy::block_in_if_condition_expr", "clippy::blocks_in_if_conditions");
     ls.register_renamed("clippy::block_in_if_condition_stmt", "clippy::blocks_in_if_conditions");
     ls.register_renamed("clippy::option_map_unwrap_or", "clippy::map_unwrap_or");
diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 4a9c411d7c8..84e8a010738 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -1462,7 +1462,7 @@ fn check_for_loop_over_map_kv<'a, 'tcx>(
                         let map = sugg::Sugg::hir(cx, arg, "map");
                         multispan_sugg(
                             diag,
-                            "use the corresponding method".into(),
+                            "use the corresponding method",
                             vec![
                                 (pat_span, snippet(cx, new_pat_span, kind).into_owned()),
                                 (arg_span, format!("{}.{}s{}()", map.maybe_par(), kind, mutbl)),
diff --git a/clippy_lints/src/methods/bind_instead_of_map.rs b/clippy_lints/src/methods/bind_instead_of_map.rs
new file mode 100644
index 00000000000..32e86637569
--- /dev/null
+++ b/clippy_lints/src/methods/bind_instead_of_map.rs
@@ -0,0 +1,309 @@
+use super::{contains_return, BIND_INSTEAD_OF_MAP};
+use crate::utils::{
+    in_macro, match_qpath, match_type, method_calls, multispan_sugg_with_applicability, paths, remove_blocks, snippet,
+    snippet_with_macro_callsite, span_lint_and_sugg, span_lint_and_then,
+};
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir as hir;
+use rustc_hir::intravisit::{self, Visitor};
+use rustc_lint::LateContext;
+use rustc_middle::hir::map::Map;
+use rustc_span::Span;
+
+pub(crate) struct OptionAndThenSome;
+impl BindInsteadOfMap for OptionAndThenSome {
+    const TYPE_NAME: &'static str = "Option";
+    const TYPE_QPATH: &'static [&'static str] = &paths::OPTION;
+
+    const BAD_METHOD_NAME: &'static str = "and_then";
+    const BAD_VARIANT_NAME: &'static str = "Some";
+    const BAD_VARIANT_QPATH: &'static [&'static str] = &paths::OPTION_SOME;
+
+    const GOOD_METHOD_NAME: &'static str = "map";
+}
+
+pub(crate) struct ResultAndThenOk;
+impl BindInsteadOfMap for ResultAndThenOk {
+    const TYPE_NAME: &'static str = "Result";
+    const TYPE_QPATH: &'static [&'static str] = &paths::RESULT;
+
+    const BAD_METHOD_NAME: &'static str = "and_then";
+    const BAD_VARIANT_NAME: &'static str = "Ok";
+    const BAD_VARIANT_QPATH: &'static [&'static str] = &paths::RESULT_OK;
+
+    const GOOD_METHOD_NAME: &'static str = "map";
+}
+
+pub(crate) struct ResultOrElseErrInfo;
+impl BindInsteadOfMap for ResultOrElseErrInfo {
+    const TYPE_NAME: &'static str = "Result";
+    const TYPE_QPATH: &'static [&'static str] = &paths::RESULT;
+
+    const BAD_METHOD_NAME: &'static str = "or_else";
+    const BAD_VARIANT_NAME: &'static str = "Err";
+    const BAD_VARIANT_QPATH: &'static [&'static str] = &paths::RESULT_ERR;
+
+    const GOOD_METHOD_NAME: &'static str = "map_err";
+}
+
+pub(crate) trait BindInsteadOfMap {
+    const TYPE_NAME: &'static str;
+    const TYPE_QPATH: &'static [&'static str];
+
+    const BAD_METHOD_NAME: &'static str;
+    const BAD_VARIANT_NAME: &'static str;
+    const BAD_VARIANT_QPATH: &'static [&'static str];
+
+    const GOOD_METHOD_NAME: &'static str;
+
+    fn no_op_msg() -> String {
+        format!(
+            "using `{}.{}({})`, which is a no-op",
+            Self::TYPE_NAME,
+            Self::BAD_METHOD_NAME,
+            Self::BAD_VARIANT_NAME
+        )
+    }
+
+    fn lint_msg() -> String {
+        format!(
+            "using `{}.{}(|x| {}(y))`, which is more succinctly expressed as `{}(|x| y)`",
+            Self::TYPE_NAME,
+            Self::BAD_METHOD_NAME,
+            Self::BAD_VARIANT_NAME,
+            Self::GOOD_METHOD_NAME
+        )
+    }
+
+    fn lint_closure_autofixable(
+        cx: &LateContext<'_, '_>,
+        expr: &hir::Expr<'_>,
+        args: &[hir::Expr<'_>],
+        closure_expr: &hir::Expr<'_>,
+        closure_args_span: Span,
+    ) -> bool {
+        if_chain! {
+            if let hir::ExprKind::Call(ref some_expr, ref some_args) = closure_expr.kind;
+            if let hir::ExprKind::Path(ref qpath) = some_expr.kind;
+            if match_qpath(qpath, Self::BAD_VARIANT_QPATH);
+            if some_args.len() == 1;
+            then {
+                let inner_expr = &some_args[0];
+
+                if contains_return(inner_expr) {
+                    return false;
+                }
+
+                let some_inner_snip = if inner_expr.span.from_expansion() {
+                    snippet_with_macro_callsite(cx, inner_expr.span, "_")
+                } else {
+                    snippet(cx, inner_expr.span, "_")
+                };
+
+                let closure_args_snip = snippet(cx, closure_args_span, "..");
+                let option_snip = snippet(cx, args[0].span, "..");
+                let note = format!("{}.{}({} {})", option_snip, Self::GOOD_METHOD_NAME, closure_args_snip, some_inner_snip);
+                span_lint_and_sugg(
+                    cx,
+                    BIND_INSTEAD_OF_MAP,
+                    expr.span,
+                    Self::lint_msg().as_ref(),
+                    "try this",
+                    note,
+                    Applicability::MachineApplicable,
+                );
+                true
+            } else {
+                false
+            }
+        }
+    }
+
+    fn lint_closure(cx: &LateContext<'_, '_>, expr: &hir::Expr<'_>, closure_expr: &hir::Expr<'_>) {
+        let mut suggs = Vec::new();
+        let can_sugg = find_all_ret_expressions(cx, closure_expr, |ret_expr| {
+            if_chain! {
+                if !in_macro(ret_expr.span);
+                if let hir::ExprKind::Call(ref func_path, ref args) = ret_expr.kind;
+                if let hir::ExprKind::Path(ref qpath) = func_path.kind;
+                if match_qpath(qpath, Self::BAD_VARIANT_QPATH);
+                if args.len() == 1;
+                if !contains_return(&args[0]);
+                then {
+                    suggs.push((ret_expr.span, args[0].span.source_callsite()));
+                    true
+                } else {
+                    false
+                }
+            }
+        });
+
+        if can_sugg {
+            span_lint_and_then(cx, BIND_INSTEAD_OF_MAP, expr.span, Self::lint_msg().as_ref(), |diag| {
+                multispan_sugg_with_applicability(
+                    diag,
+                    "try this",
+                    Applicability::MachineApplicable,
+                    std::iter::once((*method_calls(expr, 1).2.get(0).unwrap(), Self::GOOD_METHOD_NAME.into())).chain(
+                        suggs
+                            .into_iter()
+                            .map(|(span1, span2)| (span1, snippet(cx, span2, "_").into())),
+                    ),
+                )
+            });
+        }
+    }
+
+    /// Lint use of `_.and_then(|x| Some(y))` for `Option`s
+    fn lint(cx: &LateContext<'_, '_>, expr: &hir::Expr<'_>, args: &[hir::Expr<'_>]) {
+        if !match_type(cx, cx.tables.expr_ty(&args[0]), Self::TYPE_QPATH) {
+            return;
+        }
+
+        match args[1].kind {
+            hir::ExprKind::Closure(_, _, body_id, closure_args_span, _) => {
+                let closure_body = cx.tcx.hir().body(body_id);
+                let closure_expr = remove_blocks(&closure_body.value);
+
+                if !Self::lint_closure_autofixable(cx, expr, args, closure_expr, closure_args_span) {
+                    Self::lint_closure(cx, expr, closure_expr);
+                }
+            },
+            // `_.and_then(Some)` case, which is no-op.
+            hir::ExprKind::Path(ref qpath) if match_qpath(qpath, Self::BAD_VARIANT_QPATH) => {
+                span_lint_and_sugg(
+                    cx,
+                    BIND_INSTEAD_OF_MAP,
+                    expr.span,
+                    Self::no_op_msg().as_ref(),
+                    "use the expression directly",
+                    snippet(cx, args[0].span, "..").into(),
+                    Applicability::MachineApplicable,
+                );
+            },
+            _ => {},
+        }
+    }
+}
+
+/// returns `true` if expr contains match expr desugared from try
+fn contains_try(expr: &hir::Expr<'_>) -> bool {
+    struct TryFinder {
+        found: bool,
+    }
+
+    impl<'hir> intravisit::Visitor<'hir> for TryFinder {
+        type Map = Map<'hir>;
+
+        fn nested_visit_map(&mut self) -> intravisit::NestedVisitorMap<Self::Map> {
+            intravisit::NestedVisitorMap::None
+        }
+
+        fn visit_expr(&mut self, expr: &'hir hir::Expr<'hir>) {
+            if self.found {
+                return;
+            }
+            match expr.kind {
+                hir::ExprKind::Match(_, _, hir::MatchSource::TryDesugar) => self.found = true,
+                _ => intravisit::walk_expr(self, expr),
+            }
+        }
+    }
+
+    let mut visitor = TryFinder { found: false };
+    visitor.visit_expr(expr);
+    visitor.found
+}
+
+fn find_all_ret_expressions<'hir, F>(_cx: &LateContext<'_, '_>, expr: &'hir hir::Expr<'hir>, callback: F) -> bool
+where
+    F: FnMut(&'hir hir::Expr<'hir>) -> bool,
+{
+    struct RetFinder<F> {
+        in_stmt: bool,
+        failed: bool,
+        cb: F,
+    }
+
+    struct WithStmtGuarg<'a, F> {
+        val: &'a mut RetFinder<F>,
+        prev_in_stmt: bool,
+    }
+
+    impl<F> RetFinder<F> {
+        fn inside_stmt(&mut self, in_stmt: bool) -> WithStmtGuarg<'_, F> {
+            let prev_in_stmt = std::mem::replace(&mut self.in_stmt, in_stmt);
+            WithStmtGuarg {
+                val: self,
+                prev_in_stmt,
+            }
+        }
+    }
+
+    impl<F> std::ops::Deref for WithStmtGuarg<'_, F> {
+        type Target = RetFinder<F>;
+
+        fn deref(&self) -> &Self::Target {
+            self.val
+        }
+    }
+
+    impl<F> std::ops::DerefMut for WithStmtGuarg<'_, F> {
+        fn deref_mut(&mut self) -> &mut Self::Target {
+            self.val
+        }
+    }
+
+    impl<F> Drop for WithStmtGuarg<'_, F> {
+        fn drop(&mut self) {
+            self.val.in_stmt = self.prev_in_stmt;
+        }
+    }
+
+    impl<'hir, F: FnMut(&'hir hir::Expr<'hir>) -> bool> intravisit::Visitor<'hir> for RetFinder<F> {
+        type Map = Map<'hir>;
+
+        fn nested_visit_map(&mut self) -> intravisit::NestedVisitorMap<Self::Map> {
+            intravisit::NestedVisitorMap::None
+        }
+
+        fn visit_stmt(&mut self, stmt: &'hir hir::Stmt<'_>) {
+            intravisit::walk_stmt(&mut *self.inside_stmt(true), stmt)
+        }
+
+        fn visit_expr(&mut self, expr: &'hir hir::Expr<'_>) {
+            if self.failed {
+                return;
+            }
+            if self.in_stmt {
+                match expr.kind {
+                    hir::ExprKind::Ret(Some(expr)) => self.inside_stmt(false).visit_expr(expr),
+                    _ => intravisit::walk_expr(self, expr),
+                }
+            } else {
+                match expr.kind {
+                    hir::ExprKind::Match(cond, arms, _) => {
+                        self.inside_stmt(true).visit_expr(cond);
+                        for arm in arms {
+                            self.visit_expr(arm.body);
+                        }
+                    },
+                    hir::ExprKind::Block(..) => intravisit::walk_expr(self, expr),
+                    hir::ExprKind::Ret(Some(expr)) => self.visit_expr(expr),
+                    _ => self.failed |= !(self.cb)(expr),
+                }
+            }
+        }
+    }
+
+    !contains_try(expr) && {
+        let mut ret_finder = RetFinder {
+            in_stmt: false,
+            failed: false,
+            cb: callback,
+        };
+        ret_finder.visit_expr(expr);
+        !ret_finder.failed
+    }
+}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index e6094edc5d7..626427c15ec 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1,3 +1,4 @@
+mod bind_instead_of_map;
 mod inefficient_to_string;
 mod manual_saturating_arithmetic;
 mod option_map_unwrap_or;
@@ -7,6 +8,7 @@ use std::borrow::Cow;
 use std::fmt;
 use std::iter;
 
+use bind_instead_of_map::BindInsteadOfMap;
 use if_chain::if_chain;
 use rustc_ast::ast;
 use rustc_errors::Applicability;
@@ -306,27 +308,34 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for usage of `_.and_then(|x| Some(y))`.
+    /// **What it does:** Checks for usage of `_.and_then(|x| Some(y))`, `_.and_then(|x| Ok(y))` or
+    /// `_.or_else(|x| Err(y))`.
     ///
     /// **Why is this bad?** Readability, this can be written more concisely as
-    /// `_.map(|x| y)`.
+    /// `_.map(|x| y)` or `_.map_err(|x| y)`.
     ///
     /// **Known problems:** None
     ///
     /// **Example:**
     ///
     /// ```rust
-    /// let x = Some("foo");
-    /// let _ = x.and_then(|s| Some(s.len()));
+    /// # fn opt() -> Option<&'static str> { Some("42") }
+    /// # fn res() -> Result<&'static str, &'static str> { Ok("42") }
+    /// let _ = opt().and_then(|s| Some(s.len()));
+    /// let _ = res().and_then(|s| if s.len() == 42 { Ok(10) } else { Ok(20) });
+    /// let _ = res().or_else(|s| if s.len() == 42 { Err(10) } else { Err(20) });
     /// ```
     ///
     /// The correct use would be:
     ///
     /// ```rust
-    /// let x = Some("foo");
-    /// let _ = x.map(|s| s.len());
+    /// # fn opt() -> Option<&'static str> { Some("42") }
+    /// # fn res() -> Result<&'static str, &'static str> { Ok("42") }
+    /// let _ = opt().map(|s| s.len());
+    /// let _ = res().map(|s| if s.len() == 42 { 10 } else { 20 });
+    /// let _ = res().map_err(|s| if s.len() == 42 { 10 } else { 20 });
     /// ```
-    pub OPTION_AND_THEN_SOME,
+    pub BIND_INSTEAD_OF_MAP,
     complexity,
     "using `Option.and_then(|x| Some(y))`, which is more succinctly expressed as `map(|x| y)`"
 }
@@ -1243,7 +1252,7 @@ declare_lint_pass!(Methods => [
     MAP_UNWRAP_OR,
     RESULT_MAP_OR_INTO_OPTION,
     OPTION_MAP_OR_NONE,
-    OPTION_AND_THEN_SOME,
+    BIND_INSTEAD_OF_MAP,
     OR_FUN_CALL,
     EXPECT_FUN_CALL,
     CHARS_NEXT_CMP,
@@ -1302,7 +1311,13 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Methods {
             ["unwrap_or", "map"] => option_map_unwrap_or::lint(cx, expr, arg_lists[1], arg_lists[0], method_spans[1]),
             ["unwrap_or_else", "map"] => lint_map_unwrap_or_else(cx, expr, arg_lists[1], arg_lists[0]),
             ["map_or", ..] => lint_map_or_none(cx, expr, arg_lists[0]),
-            ["and_then", ..] => lint_option_and_then_some(cx, expr, arg_lists[0]),
+            ["and_then", ..] => {
+                bind_instead_of_map::OptionAndThenSome::lint(cx, expr, arg_lists[0]);
+                bind_instead_of_map::ResultAndThenOk::lint(cx, expr, arg_lists[0]);
+            },
+            ["or_else", ..] => {
+                bind_instead_of_map::ResultOrElseErrInfo::lint(cx, expr, arg_lists[0]);
+            },
             ["next", "filter"] => lint_filter_next(cx, expr, arg_lists[1]),
             ["next", "skip_while"] => lint_skip_while_next(cx, expr, arg_lists[1]),
             ["map", "filter"] => lint_filter_map(cx, expr, arg_lists[1], arg_lists[0]),
@@ -2601,73 +2616,6 @@ fn lint_map_or_none<'a, 'tcx>(
     );
 }
 
-/// Lint use of `_.and_then(|x| Some(y))` for `Option`s
-fn lint_option_and_then_some(cx: &LateContext<'_, '_>, expr: &hir::Expr<'_>, args: &[hir::Expr<'_>]) {
-    const LINT_MSG: &str = "using `Option.and_then(|x| Some(y))`, which is more succinctly expressed as `map(|x| y)`";
-    const NO_OP_MSG: &str = "using `Option.and_then(Some)`, which is a no-op";
-
-    let ty = cx.tables.expr_ty(&args[0]);
-    if !is_type_diagnostic_item(cx, ty, sym!(option_type)) {
-        return;
-    }
-
-    match args[1].kind {
-        hir::ExprKind::Closure(_, _, body_id, closure_args_span, _) => {
-            let closure_body = cx.tcx.hir().body(body_id);
-            let closure_expr = remove_blocks(&closure_body.value);
-            if_chain! {
-                if let hir::ExprKind::Call(ref some_expr, ref some_args) = closure_expr.kind;
-                if let hir::ExprKind::Path(ref qpath) = some_expr.kind;
-                if match_qpath(qpath, &paths::OPTION_SOME);
-                if some_args.len() == 1;
-                then {
-                    let inner_expr = &some_args[0];
-
-                    if contains_return(inner_expr) {
-                        return;
-                    }
-
-                    let some_inner_snip = if inner_expr.span.from_expansion() {
-                        snippet_with_macro_callsite(cx, inner_expr.span, "_")
-                    } else {
-                        snippet(cx, inner_expr.span, "_")
-                    };
-
-                    let closure_args_snip = snippet(cx, closure_args_span, "..");
-                    let option_snip = snippet(cx, args[0].span, "..");
-                    let note = format!("{}.map({} {})", option_snip, closure_args_snip, some_inner_snip);
-                    span_lint_and_sugg(
-                        cx,
-                        OPTION_AND_THEN_SOME,
-                        expr.span,
-                        LINT_MSG,
-                        "try this",
-                        note,
-                        Applicability::MachineApplicable,
-                    );
-                }
-            }
-        },
-        // `_.and_then(Some)` case, which is no-op.
-        hir::ExprKind::Path(ref qpath) => {
-            if match_qpath(qpath, &paths::OPTION_SOME) {
-                let option_snip = snippet(cx, args[0].span, "..");
-                let note = format!("{}", option_snip);
-                span_lint_and_sugg(
-                    cx,
-                    OPTION_AND_THEN_SOME,
-                    expr.span,
-                    NO_OP_MSG,
-                    "use the expression directly",
-                    note,
-                    Applicability::MachineApplicable,
-                );
-            }
-        },
-        _ => {},
-    }
-}
-
 /// lint use of `filter().next()` for `Iterators`
 fn lint_filter_next<'a, 'tcx>(
     cx: &LateContext<'a, 'tcx>,
diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs
index f50adbc48ab..6ed9ff22e46 100644
--- a/clippy_lints/src/types.rs
+++ b/clippy_lints/src/types.rs
@@ -2230,7 +2230,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for ImplicitHasher {
             );
 
             if !vis.suggestions.is_empty() {
-                multispan_sugg(diag, "...and use generic constructor".into(), vis.suggestions);
+                multispan_sugg(diag, "...and use generic constructor", vis.suggestions);
             }
         }
 
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index e5e3bf453a0..5b4e2906b5f 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -66,6 +66,13 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
         deprecation: None,
         module: "bit_mask",
     },
+    Lint {
+        name: "bind_instead_of_map",
+        group: "complexity",
+        desc: "using `Option.and_then(|x| Some(y))`, which is more succinctly expressed as `map(|x| y)`",
+        deprecation: None,
+        module: "methods",
+    },
     Lint {
         name: "blacklisted_name",
         group: "style",
@@ -1578,13 +1585,6 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
         deprecation: None,
         module: "eq_op",
     },
-    Lint {
-        name: "option_and_then_some",
-        group: "complexity",
-        desc: "using `Option.and_then(|x| Some(y))`, which is more succinctly expressed as `map(|x| y)`",
-        deprecation: None,
-        module: "methods",
-    },
     Lint {
         name: "option_as_ref_deref",
         group: "complexity",
diff --git a/tests/ui/bind_instead_of_map.fixed b/tests/ui/bind_instead_of_map.fixed
new file mode 100644
index 00000000000..5815550d7a6
--- /dev/null
+++ b/tests/ui/bind_instead_of_map.fixed
@@ -0,0 +1,25 @@
+// run-rustfix
+#![deny(clippy::bind_instead_of_map)]
+
+// need a main anyway, use it get rid of unused warnings too
+pub fn main() {
+    let x = Some(5);
+    // the easiest cases
+    let _ = x;
+    let _ = x.map(|o| o + 1);
+    // and an easy counter-example
+    let _ = x.and_then(|o| if o < 32 { Some(o) } else { None });
+
+    // Different type
+    let x: Result<u32, &str> = Ok(1);
+    let _ = x;
+}
+
+pub fn foo() -> Option<String> {
+    let x = Some(String::from("hello"));
+    Some("hello".to_owned()).and_then(|s| Some(format!("{}{}", s, x?)))
+}
+
+pub fn example2(x: bool) -> Option<&'static str> {
+    Some("a").and_then(|s| Some(if x { s } else { return None }))
+}
diff --git a/tests/ui/bind_instead_of_map.rs b/tests/ui/bind_instead_of_map.rs
new file mode 100644
index 00000000000..623b100a4ce
--- /dev/null
+++ b/tests/ui/bind_instead_of_map.rs
@@ -0,0 +1,25 @@
+// run-rustfix
+#![deny(clippy::bind_instead_of_map)]
+
+// need a main anyway, use it get rid of unused warnings too
+pub fn main() {
+    let x = Some(5);
+    // the easiest cases
+    let _ = x.and_then(Some);
+    let _ = x.and_then(|o| Some(o + 1));
+    // and an easy counter-example
+    let _ = x.and_then(|o| if o < 32 { Some(o) } else { None });
+
+    // Different type
+    let x: Result<u32, &str> = Ok(1);
+    let _ = x.and_then(Ok);
+}
+
+pub fn foo() -> Option<String> {
+    let x = Some(String::from("hello"));
+    Some("hello".to_owned()).and_then(|s| Some(format!("{}{}", s, x?)))
+}
+
+pub fn example2(x: bool) -> Option<&'static str> {
+    Some("a").and_then(|s| Some(if x { s } else { return None }))
+}
diff --git a/tests/ui/bind_instead_of_map.stderr b/tests/ui/bind_instead_of_map.stderr
new file mode 100644
index 00000000000..24c6b7f9ef3
--- /dev/null
+++ b/tests/ui/bind_instead_of_map.stderr
@@ -0,0 +1,26 @@
+error: using `Option.and_then(Some)`, which is a no-op
+  --> $DIR/bind_instead_of_map.rs:8:13
+   |
+LL |     let _ = x.and_then(Some);
+   |             ^^^^^^^^^^^^^^^^ help: use the expression directly: `x`
+   |
+note: the lint level is defined here
+  --> $DIR/bind_instead_of_map.rs:2:9
+   |
+LL | #![deny(clippy::bind_instead_of_map)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: using `Option.and_then(|x| Some(y))`, which is more succinctly expressed as `map(|x| y)`
+  --> $DIR/bind_instead_of_map.rs:9:13
+   |
+LL |     let _ = x.and_then(|o| Some(o + 1));
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `x.map(|o| o + 1)`
+
+error: using `Result.and_then(Ok)`, which is a no-op
+  --> $DIR/bind_instead_of_map.rs:15:13
+   |
+LL |     let _ = x.and_then(Ok);
+   |             ^^^^^^^^^^^^^^ help: use the expression directly: `x`
+
+error: aborting due to 3 previous errors
+
diff --git a/tests/ui/bind_instead_of_map_multipart.rs b/tests/ui/bind_instead_of_map_multipart.rs
new file mode 100644
index 00000000000..91d9d11e3c1
--- /dev/null
+++ b/tests/ui/bind_instead_of_map_multipart.rs
@@ -0,0 +1,61 @@
+#![deny(clippy::bind_instead_of_map)]
+#![allow(clippy::blocks_in_if_conditions)]
+
+pub fn main() {
+    let _ = Some("42").and_then(|s| if s.len() < 42 { Some(0) } else { Some(s.len()) });
+    let _ = Some("42").and_then(|s| if s.len() < 42 { None } else { Some(s.len()) });
+
+    let _ = Ok::<_, ()>("42").and_then(|s| if s.len() < 42 { Ok(0) } else { Ok(s.len()) });
+    let _ = Ok::<_, ()>("42").and_then(|s| if s.len() < 42 { Err(()) } else { Ok(s.len()) });
+
+    let _ = Err::<(), _>("42").or_else(|s| if s.len() < 42 { Err(s.len() + 20) } else { Err(s.len()) });
+    let _ = Err::<(), _>("42").or_else(|s| if s.len() < 42 { Ok(()) } else { Err(s.len()) });
+
+    hard_example();
+    macro_example();
+}
+
+fn hard_example() {
+    Some("42").and_then(|s| {
+        if {
+            if s == "43" {
+                return Some(43);
+            }
+            s == "42"
+        } {
+            return Some(45);
+        }
+        match s.len() {
+            10 => Some(2),
+            20 => {
+                if foo() {
+                    return {
+                        if foo() {
+                            return Some(20);
+                        }
+                        println!("foo");
+                        Some(3)
+                    };
+                }
+                Some(20)
+            },
+            40 => Some(30),
+            _ => Some(1),
+        }
+    });
+}
+
+fn foo() -> bool {
+    true
+}
+
+macro_rules! m {
+    () => {
+        Some(10)
+    };
+}
+
+fn macro_example() {
+    let _ = Some("").and_then(|s| if s.len() == 20 { m!() } else { Some(20) });
+    let _ = Some("").and_then(|s| if s.len() == 20 { Some(m!()) } else { Some(Some(20)) });
+}
diff --git a/tests/ui/bind_instead_of_map_multipart.stderr b/tests/ui/bind_instead_of_map_multipart.stderr
new file mode 100644
index 00000000000..50ce2f4051e
--- /dev/null
+++ b/tests/ui/bind_instead_of_map_multipart.stderr
@@ -0,0 +1,73 @@
+error: using `Option.and_then(|x| Some(y))`, which is more succinctly expressed as `map(|x| y)`
+  --> $DIR/bind_instead_of_map_multipart.rs:5:13
+   |
+LL |     let _ = Some("42").and_then(|s| if s.len() < 42 { Some(0) } else { Some(s.len()) });
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: the lint level is defined here
+  --> $DIR/bind_instead_of_map_multipart.rs:1:9
+   |
+LL | #![deny(clippy::bind_instead_of_map)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+help: try this
+   |
+LL |     let _ = Some("42").map(|s| if s.len() < 42 { 0 } else { s.len() });
+   |                        ^^^                       ^          ^^^^^^^
+
+error: using `Result.and_then(|x| Ok(y))`, which is more succinctly expressed as `map(|x| y)`
+  --> $DIR/bind_instead_of_map_multipart.rs:8:13
+   |
+LL |     let _ = Ok::<_, ()>("42").and_then(|s| if s.len() < 42 { Ok(0) } else { Ok(s.len()) });
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: try this
+   |
+LL |     let _ = Ok::<_, ()>("42").map(|s| if s.len() < 42 { 0 } else { s.len() });
+   |                               ^^^                       ^          ^^^^^^^
+
+error: using `Result.or_else(|x| Err(y))`, which is more succinctly expressed as `map_err(|x| y)`
+  --> $DIR/bind_instead_of_map_multipart.rs:11:13
+   |
+LL |     let _ = Err::<(), _>("42").or_else(|s| if s.len() < 42 { Err(s.len() + 20) } else { Err(s.len()) });
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: try this
+   |
+LL |     let _ = Err::<(), _>("42").map_err(|s| if s.len() < 42 { s.len() + 20 } else { s.len() });
+   |                                ^^^^^^^                       ^^^^^^^^^^^^          ^^^^^^^
+
+error: using `Option.and_then(|x| Some(y))`, which is more succinctly expressed as `map(|x| y)`
+  --> $DIR/bind_instead_of_map_multipart.rs:19:5
+   |
+LL | /     Some("42").and_then(|s| {
+LL | |         if {
+LL | |             if s == "43" {
+LL | |                 return Some(43);
+...  |
+LL | |         }
+LL | |     });
+   | |______^
+   |
+help: try this
+   |
+LL |     Some("42").map(|s| {
+LL |         if {
+LL |             if s == "43" {
+LL |                 return 43;
+LL |             }
+LL |             s == "42"
+ ...
+
+error: using `Option.and_then(|x| Some(y))`, which is more succinctly expressed as `map(|x| y)`
+  --> $DIR/bind_instead_of_map_multipart.rs:60:13
+   |
+LL |     let _ = Some("").and_then(|s| if s.len() == 20 { Some(m!()) } else { Some(Some(20)) });
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: try this
+   |
+LL |     let _ = Some("").map(|s| if s.len() == 20 { m!() } else { Some(20) });
+   |                      ^^^                        ^^^^          ^^^^^^^^
+
+error: aborting due to 5 previous errors
+
diff --git a/tests/ui/blocks_in_if_conditions.fixed b/tests/ui/blocks_in_if_conditions.fixed
index 9040552cefc..14562c4d32c 100644
--- a/tests/ui/blocks_in_if_conditions.fixed
+++ b/tests/ui/blocks_in_if_conditions.fixed
@@ -63,10 +63,10 @@ fn block_in_assert() {
     let opt = Some(42);
     assert!(opt
         .as_ref()
-        .and_then(|val| {
+        .map(|val| {
             let mut v = val * 2;
             v -= 1;
-            Some(v * 3)
+            v * 3
         })
         .is_some());
 }
diff --git a/tests/ui/blocks_in_if_conditions.rs b/tests/ui/blocks_in_if_conditions.rs
index 2fe409b22d3..bda87650f6d 100644
--- a/tests/ui/blocks_in_if_conditions.rs
+++ b/tests/ui/blocks_in_if_conditions.rs
@@ -63,10 +63,10 @@ fn block_in_assert() {
     let opt = Some(42);
     assert!(opt
         .as_ref()
-        .and_then(|val| {
+        .map(|val| {
             let mut v = val * 2;
             v -= 1;
-            Some(v * 3)
+            v * 3
         })
         .is_some());
 }
diff --git a/tests/ui/option_and_then_some.fixed b/tests/ui/option_and_then_some.fixed
deleted file mode 100644
index 035bc1e5465..00000000000
--- a/tests/ui/option_and_then_some.fixed
+++ /dev/null
@@ -1,25 +0,0 @@
-// run-rustfix
-#![deny(clippy::option_and_then_some)]
-
-// need a main anyway, use it get rid of unused warnings too
-pub fn main() {
-    let x = Some(5);
-    // the easiest cases
-    let _ = x;
-    let _ = x.map(|o| o + 1);
-    // and an easy counter-example
-    let _ = x.and_then(|o| if o < 32 { Some(o) } else { None });
-
-    // Different type
-    let x: Result<u32, &str> = Ok(1);
-    let _ = x.and_then(Ok);
-}
-
-pub fn foo() -> Option<String> {
-    let x = Some(String::from("hello"));
-    Some("hello".to_owned()).and_then(|s| Some(format!("{}{}", s, x?)))
-}
-
-pub fn example2(x: bool) -> Option<&'static str> {
-    Some("a").and_then(|s| Some(if x { s } else { return None }))
-}
diff --git a/tests/ui/option_and_then_some.rs b/tests/ui/option_and_then_some.rs
deleted file mode 100644
index d49da7813c6..00000000000
--- a/tests/ui/option_and_then_some.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-// run-rustfix
-#![deny(clippy::option_and_then_some)]
-
-// need a main anyway, use it get rid of unused warnings too
-pub fn main() {
-    let x = Some(5);
-    // the easiest cases
-    let _ = x.and_then(Some);
-    let _ = x.and_then(|o| Some(o + 1));
-    // and an easy counter-example
-    let _ = x.and_then(|o| if o < 32 { Some(o) } else { None });
-
-    // Different type
-    let x: Result<u32, &str> = Ok(1);
-    let _ = x.and_then(Ok);
-}
-
-pub fn foo() -> Option<String> {
-    let x = Some(String::from("hello"));
-    Some("hello".to_owned()).and_then(|s| Some(format!("{}{}", s, x?)))
-}
-
-pub fn example2(x: bool) -> Option<&'static str> {
-    Some("a").and_then(|s| Some(if x { s } else { return None }))
-}
diff --git a/tests/ui/option_and_then_some.stderr b/tests/ui/option_and_then_some.stderr
deleted file mode 100644
index 47825491765..00000000000
--- a/tests/ui/option_and_then_some.stderr
+++ /dev/null
@@ -1,20 +0,0 @@
-error: using `Option.and_then(Some)`, which is a no-op
-  --> $DIR/option_and_then_some.rs:8:13
-   |
-LL |     let _ = x.and_then(Some);
-   |             ^^^^^^^^^^^^^^^^ help: use the expression directly: `x`
-   |
-note: the lint level is defined here
-  --> $DIR/option_and_then_some.rs:2:9
-   |
-LL | #![deny(clippy::option_and_then_some)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: using `Option.and_then(|x| Some(y))`, which is more succinctly expressed as `map(|x| y)`
-  --> $DIR/option_and_then_some.rs:9:13
-   |
-LL |     let _ = x.and_then(|o| Some(o + 1));
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `x.map(|o| o + 1)`
-
-error: aborting due to 2 previous errors
-
diff --git a/tests/ui/option_map_or_none.fixed b/tests/ui/option_map_or_none.fixed
index decbae4e5af..d80c3c7c1b7 100644
--- a/tests/ui/option_map_or_none.fixed
+++ b/tests/ui/option_map_or_none.fixed
@@ -1,6 +1,6 @@
 // run-rustfix
 
-#![allow(clippy::option_and_then_some)]
+#![allow(clippy::bind_instead_of_map)]
 
 fn main() {
     let opt = Some(1);
diff --git a/tests/ui/option_map_or_none.rs b/tests/ui/option_map_or_none.rs
index 0f1d2218d5d..629842419e5 100644
--- a/tests/ui/option_map_or_none.rs
+++ b/tests/ui/option_map_or_none.rs
@@ -1,6 +1,6 @@
 // run-rustfix
 
-#![allow(clippy::option_and_then_some)]
+#![allow(clippy::bind_instead_of_map)]
 
 fn main() {
     let opt = Some(1);
-- 
cgit 1.4.1-3-g733a5


From 1b3dc5f79b98ba92c0b6fa98e62c8f331faa8ed6 Mon Sep 17 00:00:00 2001
From: Rahul Butani <rr.butani@gmail.com>
Date: Sun, 17 May 2020 22:21:02 -0500
Subject: Add to the list of words clippy::doc_markdown ignores

---
 clippy_lints/src/utils/conf.rs | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 57b9eafd14d..9e8e0ff30ec 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -120,10 +120,12 @@ define_Conf! {
         "GPLv2", "GPLv3",
         "GitHub", "GitLab",
         "IPv4", "IPv6",
-        "JavaScript",
+        "ClojureScript", "CoffeeScript", "JavaScript", "PureScript", "TypeScript",
         "NaN", "NaNs",
         "OAuth",
-        "OpenGL", "OpenSSH", "OpenSSL", "OpenStreetMap",
+        "OCaml",
+        "OpenGL", "OpenMP", "OpenSSH", "OpenSSL", "OpenStreetMap",
+        "TensorFlow",
         "TrueType",
         "iOS", "macOS",
         "TeX", "LaTeX", "BibTeX", "BibLaTeX",
-- 
cgit 1.4.1-3-g733a5


From f28f1f15da825bcf5cf78413f464dfea0bc553e5 Mon Sep 17 00:00:00 2001
From: flip1995 <hello@philkrones.com>
Date: Wed, 20 May 2020 13:32:53 +0200
Subject: Fix dogfood fallout

---
 clippy_lints/src/utils/inspector.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/inspector.rs b/clippy_lints/src/utils/inspector.rs
index 748c11fac64..9b672b9ec22 100644
--- a/clippy_lints/src/utils/inspector.rs
+++ b/clippy_lints/src/utils/inspector.rs
@@ -289,21 +289,21 @@ fn print_expr(cx: &LateContext<'_, '_>, expr: &hir::Expr<'_>, indent: usize) {
             println!("{}operands:", ind);
             for op in asm.operands {
                 match op {
-                    hir::InlineAsmOperand::In { expr, .. } => print_expr(cx, expr, indent + 1),
+                    hir::InlineAsmOperand::In { expr, .. }
+                    | hir::InlineAsmOperand::InOut { expr, .. }
+                    | hir::InlineAsmOperand::Const { expr }
+                    | hir::InlineAsmOperand::Sym { expr } => print_expr(cx, expr, indent + 1),
                     hir::InlineAsmOperand::Out { expr, .. } => {
                         if let Some(expr) = expr {
                             print_expr(cx, expr, indent + 1);
                         }
                     },
-                    hir::InlineAsmOperand::InOut { expr, .. } => print_expr(cx, expr, indent + 1),
                     hir::InlineAsmOperand::SplitInOut { in_expr, out_expr, .. } => {
                         print_expr(cx, in_expr, indent + 1);
                         if let Some(out_expr) = out_expr {
                             print_expr(cx, out_expr, indent + 1);
                         }
                     },
-                    hir::InlineAsmOperand::Const { expr } => print_expr(cx, expr, indent + 1),
-                    hir::InlineAsmOperand::Sym { expr } => print_expr(cx, expr, indent + 1),
                 }
             }
         },
-- 
cgit 1.4.1-3-g733a5


From ecd0a67b01e13d7a80d2f64bbfa5da1e568367e5 Mon Sep 17 00:00:00 2001
From: Elichai Turkel <elichai.turkel@gmail.com>
Date: Wed, 20 May 2020 13:23:51 +0300
Subject: Make match_wild_err_arm pedantic, and update help messages

---
 clippy_lints/src/lib.rs            | 3 +--
 clippy_lints/src/matches.rs        | 6 +++---
 src/lintlist/mod.rs                | 2 +-
 tests/ui/match_wild_err_arm.stderr | 8 ++++----
 4 files changed, 9 insertions(+), 10 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 4d4fff883b3..057d39d4c82 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1141,6 +1141,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&match_on_vec_items::MATCH_ON_VEC_ITEMS),
         LintId::of(&matches::MATCH_BOOL),
         LintId::of(&matches::MATCH_WILDCARD_FOR_SINGLE_VARIANTS),
+        LintId::of(&matches::MATCH_WILD_ERR_ARM),
         LintId::of(&matches::SINGLE_MATCH_ELSE),
         LintId::of(&methods::FILTER_MAP),
         LintId::of(&methods::FILTER_MAP_NEXT),
@@ -1285,7 +1286,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&matches::MATCH_OVERLAPPING_ARM),
         LintId::of(&matches::MATCH_REF_PATS),
         LintId::of(&matches::MATCH_SINGLE_BINDING),
-        LintId::of(&matches::MATCH_WILD_ERR_ARM),
         LintId::of(&matches::SINGLE_MATCH),
         LintId::of(&matches::WILDCARD_IN_OR_PATTERNS),
         LintId::of(&mem_discriminant::MEM_DISCRIMINANT_NON_ENUM),
@@ -1476,7 +1476,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&matches::INFALLIBLE_DESTRUCTURING_MATCH),
         LintId::of(&matches::MATCH_OVERLAPPING_ARM),
         LintId::of(&matches::MATCH_REF_PATS),
-        LintId::of(&matches::MATCH_WILD_ERR_ARM),
         LintId::of(&matches::SINGLE_MATCH),
         LintId::of(&mem_replace::MEM_REPLACE_OPTION_WITH_NONE),
         LintId::of(&mem_replace::MEM_REPLACE_WITH_DEFAULT),
diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index 4106e5013b9..94380acfcfd 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -168,7 +168,7 @@ declare_clippy_lint! {
     /// **What it does:** Checks for arm which matches all errors with `Err(_)`
     /// and take drastic actions like `panic!`.
     ///
-    /// **Why is this bad?** It is generally a bad practice, just like
+    /// **Why is this bad?** It is generally a bad practice, similar to
     /// catching all exceptions in java with `catch(Exception)`
     ///
     /// **Known problems:** None.
@@ -182,7 +182,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     pub MATCH_WILD_ERR_ARM,
-    style,
+    pedantic,
     "a `match` with `Err(_)` arm and take drastic actions"
 }
 
@@ -711,7 +711,7 @@ fn check_wild_err_arm(cx: &LateContext<'_, '_>, ex: &Expr<'_>, arms: &[Arm<'_>])
                                 arm.pat.span,
                                 &format!("`Err({})` matches all errors", &ident_bind_name),
                                 None,
-                                "match each error separately or use the error output",
+                                "match each error separately or use the error output, or use `.except(msg)` if the error case is unreachable",
                             );
                         }
                     }
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index 0bf46491d31..8211a57b564 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -1195,7 +1195,7 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
     },
     Lint {
         name: "match_wild_err_arm",
-        group: "style",
+        group: "pedantic",
         desc: "a `match` with `Err(_)` arm and take drastic actions",
         deprecation: None,
         module: "matches",
diff --git a/tests/ui/match_wild_err_arm.stderr b/tests/ui/match_wild_err_arm.stderr
index 20d4c933418..6a2a02987de 100644
--- a/tests/ui/match_wild_err_arm.stderr
+++ b/tests/ui/match_wild_err_arm.stderr
@@ -5,7 +5,7 @@ LL |         Err(_) => panic!("err"),
    |         ^^^^^^
    |
    = note: `-D clippy::match-wild-err-arm` implied by `-D warnings`
-   = note: match each error separately or use the error output
+   = note: match each error separately or use the error output, or use `.except(msg)` if the error case is unreachable
 
 error: `Err(_)` matches all errors
   --> $DIR/match_wild_err_arm.rs:17:9
@@ -13,7 +13,7 @@ error: `Err(_)` matches all errors
 LL |         Err(_) => panic!(),
    |         ^^^^^^
    |
-   = note: match each error separately or use the error output
+   = note: match each error separately or use the error output, or use `.except(msg)` if the error case is unreachable
 
 error: `Err(_)` matches all errors
   --> $DIR/match_wild_err_arm.rs:23:9
@@ -21,7 +21,7 @@ error: `Err(_)` matches all errors
 LL |         Err(_) => {
    |         ^^^^^^
    |
-   = note: match each error separately or use the error output
+   = note: match each error separately or use the error output, or use `.except(msg)` if the error case is unreachable
 
 error: `Err(_e)` matches all errors
   --> $DIR/match_wild_err_arm.rs:31:9
@@ -29,7 +29,7 @@ error: `Err(_e)` matches all errors
 LL |         Err(_e) => panic!(),
    |         ^^^^^^^
    |
-   = note: match each error separately or use the error output
+   = note: match each error separately or use the error output, or use `.except(msg)` if the error case is unreachable
 
 error: aborting due to 4 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From bc93f7052e4a76d62e2aa5f11649e662cb46c7ce Mon Sep 17 00:00:00 2001
From: Eduardo Broto <ebroto@tutanota.com>
Date: Mon, 18 May 2020 20:56:33 +0200
Subject: Add test for cargo_common_metadata

Fix missing `authors` entry in the provided example
---
 clippy_lints/src/cargo_common_metadata.rs              |  1 +
 tests/ui-cargo/cargo_common_metadata/fail/Cargo.toml   |  3 +++
 tests/ui-cargo/cargo_common_metadata/fail/src/main.rs  |  3 +++
 .../cargo_common_metadata/fail/src/main.stderr         | 18 ++++++++++++++++++
 tests/ui-cargo/cargo_common_metadata/pass/Cargo.toml   | 10 ++++++++++
 tests/ui-cargo/cargo_common_metadata/pass/src/main.rs  |  3 +++
 6 files changed, 38 insertions(+)
 create mode 100644 tests/ui-cargo/cargo_common_metadata/fail/Cargo.toml
 create mode 100644 tests/ui-cargo/cargo_common_metadata/fail/src/main.rs
 create mode 100644 tests/ui-cargo/cargo_common_metadata/fail/src/main.stderr
 create mode 100644 tests/ui-cargo/cargo_common_metadata/pass/Cargo.toml
 create mode 100644 tests/ui-cargo/cargo_common_metadata/pass/src/main.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/cargo_common_metadata.rs b/clippy_lints/src/cargo_common_metadata.rs
index 782da249808..16b46423c8f 100644
--- a/clippy_lints/src/cargo_common_metadata.rs
+++ b/clippy_lints/src/cargo_common_metadata.rs
@@ -23,6 +23,7 @@ declare_clippy_lint! {
     /// [package]
     /// name = "clippy"
     /// version = "0.0.212"
+    /// authors = ["Someone <someone@rust-lang.org>"]
     /// description = "A bunch of helpful lints to avoid common pitfalls in Rust"
     /// repository = "https://github.com/rust-lang/rust-clippy"
     /// readme = "README.md"
diff --git a/tests/ui-cargo/cargo_common_metadata/fail/Cargo.toml b/tests/ui-cargo/cargo_common_metadata/fail/Cargo.toml
new file mode 100644
index 00000000000..8346bf05778
--- /dev/null
+++ b/tests/ui-cargo/cargo_common_metadata/fail/Cargo.toml
@@ -0,0 +1,3 @@
+[package]
+name = "cargo_common_metadata"
+version = "0.1.0"
diff --git a/tests/ui-cargo/cargo_common_metadata/fail/src/main.rs b/tests/ui-cargo/cargo_common_metadata/fail/src/main.rs
new file mode 100644
index 00000000000..c67166fc4b0
--- /dev/null
+++ b/tests/ui-cargo/cargo_common_metadata/fail/src/main.rs
@@ -0,0 +1,3 @@
+#![warn(clippy::cargo_common_metadata)]
+
+fn main() {}
diff --git a/tests/ui-cargo/cargo_common_metadata/fail/src/main.stderr b/tests/ui-cargo/cargo_common_metadata/fail/src/main.stderr
new file mode 100644
index 00000000000..c8ae6c820df
--- /dev/null
+++ b/tests/ui-cargo/cargo_common_metadata/fail/src/main.stderr
@@ -0,0 +1,18 @@
+error: package `cargo_common_metadata` is missing `package.authors` metadata
+   |
+   = note: `-D clippy::cargo-common-metadata` implied by `-D warnings`
+
+error: package `cargo_common_metadata` is missing `package.description` metadata
+
+error: package `cargo_common_metadata` is missing `either package.license or package.license_file` metadata
+
+error: package `cargo_common_metadata` is missing `package.repository` metadata
+
+error: package `cargo_common_metadata` is missing `package.readme` metadata
+
+error: package `cargo_common_metadata` is missing `package.keywords` metadata
+
+error: package `cargo_common_metadata` is missing `package.categories` metadata
+
+error: aborting due to 7 previous errors
+
diff --git a/tests/ui-cargo/cargo_common_metadata/pass/Cargo.toml b/tests/ui-cargo/cargo_common_metadata/pass/Cargo.toml
new file mode 100644
index 00000000000..f99c126fabf
--- /dev/null
+++ b/tests/ui-cargo/cargo_common_metadata/pass/Cargo.toml
@@ -0,0 +1,10 @@
+[package]
+name = "cargo_common_metadata"
+version = "0.1.0"
+authors = ["Random person from the Internet <someone@someplace.org>"]
+description = "A test package for the cargo_common_metadata lint"
+repository = "https://github.com/someone/cargo_common_metadata"
+readme = "README.md"
+license = "MIT OR Apache-2.0"
+keywords = ["metadata", "lint", "clippy"]
+categories = ["development-tools::testing"]
diff --git a/tests/ui-cargo/cargo_common_metadata/pass/src/main.rs b/tests/ui-cargo/cargo_common_metadata/pass/src/main.rs
new file mode 100644
index 00000000000..c67166fc4b0
--- /dev/null
+++ b/tests/ui-cargo/cargo_common_metadata/pass/src/main.rs
@@ -0,0 +1,3 @@
+#![warn(clippy::cargo_common_metadata)]
+
+fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 7a0eccbd8a719af00b027b0ea85c576d9cbed750 Mon Sep 17 00:00:00 2001
From: Eduardo Broto <ebroto@tutanota.com>
Date: Mon, 18 May 2020 20:58:02 +0200
Subject: Add test for multiple_crate_versions

Make the output of the lint deterministic by sorting the versions
---
 clippy_lints/src/multiple_crate_versions.rs                 | 4 +++-
 tests/ui-cargo/multiple_crate_versions/fail/Cargo.toml      | 7 +++++++
 tests/ui-cargo/multiple_crate_versions/fail/src/main.rs     | 3 +++
 tests/ui-cargo/multiple_crate_versions/fail/src/main.stderr | 6 ++++++
 tests/ui-cargo/multiple_crate_versions/pass/Cargo.toml      | 7 +++++++
 tests/ui-cargo/multiple_crate_versions/pass/src/main.rs     | 3 +++
 6 files changed, 29 insertions(+), 1 deletion(-)
 create mode 100644 tests/ui-cargo/multiple_crate_versions/fail/Cargo.toml
 create mode 100644 tests/ui-cargo/multiple_crate_versions/fail/src/main.rs
 create mode 100644 tests/ui-cargo/multiple_crate_versions/fail/src/main.stderr
 create mode 100644 tests/ui-cargo/multiple_crate_versions/pass/Cargo.toml
 create mode 100644 tests/ui-cargo/multiple_crate_versions/pass/src/main.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/multiple_crate_versions.rs b/clippy_lints/src/multiple_crate_versions.rs
index ed85d0315bd..c4decfc9401 100644
--- a/clippy_lints/src/multiple_crate_versions.rs
+++ b/clippy_lints/src/multiple_crate_versions.rs
@@ -54,7 +54,9 @@ impl LateLintPass<'_, '_> for MultipleCrateVersions {
             let group: Vec<cargo_metadata::Package> = group.collect();
 
             if group.len() > 1 {
-                let versions = group.into_iter().map(|p| p.version).join(", ");
+                let mut versions: Vec<_> = group.into_iter().map(|p| p.version).collect();
+                versions.sort();
+                let versions = versions.iter().join(", ");
 
                 span_lint(
                     cx,
diff --git a/tests/ui-cargo/multiple_crate_versions/fail/Cargo.toml b/tests/ui-cargo/multiple_crate_versions/fail/Cargo.toml
new file mode 100644
index 00000000000..05ffde839dc
--- /dev/null
+++ b/tests/ui-cargo/multiple_crate_versions/fail/Cargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "multiple_crate_versions"
+version = "0.1.0"
+
+[dependencies]
+ctrlc = "=3.1.0"
+ansi_term = "=0.11.0"
diff --git a/tests/ui-cargo/multiple_crate_versions/fail/src/main.rs b/tests/ui-cargo/multiple_crate_versions/fail/src/main.rs
new file mode 100644
index 00000000000..4bc61dd6299
--- /dev/null
+++ b/tests/ui-cargo/multiple_crate_versions/fail/src/main.rs
@@ -0,0 +1,3 @@
+#![warn(clippy::multiple_crate_versions)]
+
+fn main() {}
diff --git a/tests/ui-cargo/multiple_crate_versions/fail/src/main.stderr b/tests/ui-cargo/multiple_crate_versions/fail/src/main.stderr
new file mode 100644
index 00000000000..4f668599be9
--- /dev/null
+++ b/tests/ui-cargo/multiple_crate_versions/fail/src/main.stderr
@@ -0,0 +1,6 @@
+error: multiple versions for dependency `winapi`: 0.2.8, 0.3.8
+   |
+   = note: `-D clippy::multiple-crate-versions` implied by `-D warnings`
+
+error: aborting due to previous error
+
diff --git a/tests/ui-cargo/multiple_crate_versions/pass/Cargo.toml b/tests/ui-cargo/multiple_crate_versions/pass/Cargo.toml
new file mode 100644
index 00000000000..cad32b9233f
--- /dev/null
+++ b/tests/ui-cargo/multiple_crate_versions/pass/Cargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "cargo_common_metadata"
+version = "0.1.0"
+
+[dependencies]
+regex = "1.3.7"
+serde = "1.0.110"
diff --git a/tests/ui-cargo/multiple_crate_versions/pass/src/main.rs b/tests/ui-cargo/multiple_crate_versions/pass/src/main.rs
new file mode 100644
index 00000000000..4bc61dd6299
--- /dev/null
+++ b/tests/ui-cargo/multiple_crate_versions/pass/src/main.rs
@@ -0,0 +1,3 @@
+#![warn(clippy::multiple_crate_versions)]
+
+fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 6b3cf63bf568cab4f8e05ea483ad97d5ea0e2eec Mon Sep 17 00:00:00 2001
From: flip1995 <hello@philkrones.com>
Date: Fri, 22 May 2020 14:45:51 +0200
Subject: Fix dogfood fallout

---
 clippy_lints/src/methods/mod.rs | 19 ++++++++-----------
 1 file changed, 8 insertions(+), 11 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 810a226b50d..32b3b7f7947 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1496,17 +1496,14 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Methods {
             if let ty::Opaque(def_id, _) = ret_ty.kind {
                 // one of the associated types must be Self
                 for predicate in cx.tcx.predicates_of(def_id).predicates {
-                    match predicate.0.kind() {
-                        ty::PredicateKind::Projection(poly_projection_predicate) => {
-                            let binder = poly_projection_predicate.ty();
-                            let associated_type = binder.skip_binder();
-
-                            // walk the associated type and check for Self
-                            if contains_self_ty(associated_type) {
-                                return;
-                            }
-                        },
-                        _ => {},
+                    if let ty::PredicateKind::Projection(poly_projection_predicate) = predicate.0.kind() {
+                        let binder = poly_projection_predicate.ty();
+                        let associated_type = binder.skip_binder();
+
+                        // walk the associated type and check for Self
+                        if contains_self_ty(associated_type) {
+                            return;
+                        }
                     }
                 }
             }
-- 
cgit 1.4.1-3-g733a5


From a578bed69ac2a9b33fcb871f9ad7dbf02355cb82 Mon Sep 17 00:00:00 2001
From: Andy Russell <arussell123@gmail.com>
Date: Mon, 18 May 2020 18:35:49 -0400
Subject: new_without_default: do not suggest deriving

---
 clippy_lints/src/new_without_default.rs | 118 +++++++-------------------------
 tests/ui/new_without_default.rs         |  11 +++
 tests/ui/new_without_default.stderr     |  35 ++++++++--
 3 files changed, 64 insertions(+), 100 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/new_without_default.rs b/clippy_lints/src/new_without_default.rs
index a599667b8d8..3b88e4c4cb1 100644
--- a/clippy_lints/src/new_without_default.rs
+++ b/clippy_lints/src/new_without_default.rs
@@ -1,27 +1,20 @@
 use crate::utils::paths;
 use crate::utils::sugg::DiagnosticBuilderExt;
-use crate::utils::{get_trait_def_id, implements_trait, return_ty, same_tys, span_lint_hir_and_then};
+use crate::utils::{get_trait_def_id, return_ty, same_tys, span_lint_hir_and_then};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
-use rustc_hir::def_id::DefId;
 use rustc_hir::HirIdSet;
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_middle::ty::{self, Ty};
+use rustc_middle::ty::Ty;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::source_map::Span;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for types with a `fn new() -> Self` method and no
     /// implementation of
     /// [`Default`](https://doc.rust-lang.org/std/default/trait.Default.html).
     ///
-    /// It detects both the case when a manual
-    /// [`Default`](https://doc.rust-lang.org/std/default/trait.Default.html)
-    /// implementation is required and also when it can be created with
-    /// `#[derive(Default)]`
-    ///
     /// **Why is this bad?** The user might expect to be able to use
     /// [`Default`](https://doc.rust-lang.org/std/default/trait.Default.html) as the
     /// type can be constructed without arguments.
@@ -40,46 +33,17 @@ declare_clippy_lint! {
     /// }
     /// ```
     ///
-    /// Instead, use:
+    /// To fix the lint, and a `Default` implementation that delegates to `new`:
     ///
     /// ```ignore
     /// struct Foo(Bar);
     ///
     /// impl Default for Foo {
     ///     fn default() -> Self {
-    ///         Foo(Bar::new())
+    ///         Foo::new()
     ///     }
     /// }
     /// ```
-    ///
-    /// Or, if
-    /// [`Default`](https://doc.rust-lang.org/std/default/trait.Default.html)
-    /// can be derived by `#[derive(Default)]`:
-    ///
-    /// ```rust
-    /// struct Foo;
-    ///
-    /// impl Foo {
-    ///     fn new() -> Self {
-    ///         Foo
-    ///     }
-    /// }
-    /// ```
-    ///
-    /// Instead, use:
-    ///
-    /// ```rust
-    /// #[derive(Default)]
-    /// struct Foo;
-    ///
-    /// impl Foo {
-    ///     fn new() -> Self {
-    ///         Foo
-    ///     }
-    /// }
-    /// ```
-    ///
-    /// You can also have `new()` call `Default::default()`.
     pub NEW_WITHOUT_DEFAULT,
     style,
     "`fn new() -> Self` method without `Default` implementation"
@@ -158,46 +122,25 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NewWithoutDefault {
                                         }
                                     }
 
-                                    if let Some(sp) = can_derive_default(self_ty, cx, default_trait_id) {
-                                        span_lint_hir_and_then(
-                                            cx,
-                                            NEW_WITHOUT_DEFAULT,
-                                            id,
-                                            impl_item.span,
-                                            &format!(
-                                                "you should consider deriving a `Default` implementation for `{}`",
-                                                self_ty
-                                            ),
-                                            |diag| {
-                                                diag.suggest_item_with_attr(
-                                                    cx,
-                                                    sp,
-                                                    "try this",
-                                                    "#[derive(Default)]",
-                                                    Applicability::MaybeIncorrect,
-                                                );
-                                            });
-                                    } else {
-                                        span_lint_hir_and_then(
-                                            cx,
-                                            NEW_WITHOUT_DEFAULT,
-                                            id,
-                                            impl_item.span,
-                                            &format!(
-                                                "you should consider adding a `Default` implementation for `{}`",
-                                                self_ty
-                                            ),
-                                            |diag| {
-                                                diag.suggest_prepend_item(
-                                                    cx,
-                                                    item.span,
-                                                    "try this",
-                                                    &create_new_without_default_suggest_msg(self_ty),
-                                                    Applicability::MaybeIncorrect,
-                                                );
-                                            },
-                                        );
-                                    }
+                                    span_lint_hir_and_then(
+                                        cx,
+                                        NEW_WITHOUT_DEFAULT,
+                                        id,
+                                        impl_item.span,
+                                        &format!(
+                                            "you should consider adding a `Default` implementation for `{}`",
+                                            self_ty
+                                        ),
+                                        |diag| {
+                                            diag.suggest_prepend_item(
+                                                cx,
+                                                item.span,
+                                                "try this",
+                                                &create_new_without_default_suggest_msg(self_ty),
+                                                Applicability::MaybeIncorrect,
+                                            );
+                                        },
+                                    );
                                 }
                             }
                         }
@@ -217,18 +160,3 @@ fn create_new_without_default_suggest_msg(ty: Ty<'_>) -> String {
     }}
 }}", ty)
 }
-
-fn can_derive_default<'t, 'c>(ty: Ty<'t>, cx: &LateContext<'c, 't>, default_trait_id: DefId) -> Option<Span> {
-    match ty.kind {
-        ty::Adt(adt_def, substs) if adt_def.is_struct() => {
-            for field in adt_def.all_fields() {
-                let f_ty = field.ty(cx.tcx, substs);
-                if !implements_trait(cx, f_ty, default_trait_id, &[]) {
-                    return None;
-                }
-            }
-            Some(cx.tcx.def_span(adt_def.did))
-        },
-        _ => None,
-    }
-}
diff --git a/tests/ui/new_without_default.rs b/tests/ui/new_without_default.rs
index 781ea7bb152..3b6041823d8 100644
--- a/tests/ui/new_without_default.rs
+++ b/tests/ui/new_without_default.rs
@@ -148,4 +148,15 @@ impl AllowDerive {
     }
 }
 
+pub struct NewNotEqualToDerive {
+    foo: i32,
+}
+
+impl NewNotEqualToDerive {
+    // This `new` implementation is not equal to a derived `Default`, so do not suggest deriving.
+    pub fn new() -> Self {
+        NewNotEqualToDerive { foo: 1 }
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/new_without_default.stderr b/tests/ui/new_without_default.stderr
index 5e485d40663..e529e441eb7 100644
--- a/tests/ui/new_without_default.stderr
+++ b/tests/ui/new_without_default.stderr
@@ -1,4 +1,4 @@
-error: you should consider deriving a `Default` implementation for `Foo`
+error: you should consider adding a `Default` implementation for `Foo`
   --> $DIR/new_without_default.rs:8:5
    |
 LL | /     pub fn new() -> Foo {
@@ -9,10 +9,14 @@ LL | |     }
    = note: `-D clippy::new-without-default` implied by `-D warnings`
 help: try this
    |
-LL | #[derive(Default)]
+LL | impl Default for Foo {
+LL |     fn default() -> Self {
+LL |         Self::new()
+LL |     }
+LL | }
    |
 
-error: you should consider deriving a `Default` implementation for `Bar`
+error: you should consider adding a `Default` implementation for `Bar`
   --> $DIR/new_without_default.rs:16:5
    |
 LL | /     pub fn new() -> Self {
@@ -22,7 +26,11 @@ LL | |     }
    |
 help: try this
    |
-LL | #[derive(Default)]
+LL | impl Default for Bar {
+LL |     fn default() -> Self {
+LL |         Self::new()
+LL |     }
+LL | }
    |
 
 error: you should consider adding a `Default` implementation for `LtKo<'c>`
@@ -42,5 +50,22 @@ LL |     }
 LL | }
    |
 
-error: aborting due to 3 previous errors
+error: you should consider adding a `Default` implementation for `NewNotEqualToDerive`
+  --> $DIR/new_without_default.rs:157:5
+   |
+LL | /     pub fn new() -> Self {
+LL | |         NewNotEqualToDerive { foo: 1 }
+LL | |     }
+   | |_____^
+   |
+help: try this
+   |
+LL | impl Default for NewNotEqualToDerive {
+LL |     fn default() -> Self {
+LL |         Self::new()
+LL |     }
+LL | }
+   |
+
+error: aborting due to 4 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From a709559705db19785b29ce4a9044d7aebaefec31 Mon Sep 17 00:00:00 2001
From: Nick Torres <nickrtorres@icloud.com>
Date: Sat, 23 May 2020 16:14:38 -0700
Subject: Clarify the documentation of the `unnecessary_mut_passed` lint

---
 clippy_lints/src/mut_reference.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/mut_reference.rs b/clippy_lints/src/mut_reference.rs
index e5680482e5b..67a1ac78a67 100644
--- a/clippy_lints/src/mut_reference.rs
+++ b/clippy_lints/src/mut_reference.rs
@@ -6,7 +6,7 @@ use rustc_middle::ty::{self, Ty};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
-    /// **What it does:** Detects giving a mutable reference to a function that only
+    /// **What it does:** Detects passing a mutable reference to a function that only
     /// requires an immutable reference.
     ///
     /// **Why is this bad?** The immutable reference rules out all other references
-- 
cgit 1.4.1-3-g733a5


From 8642fc97dd1a9b4f0291726c47ec97d15599d74d Mon Sep 17 00:00:00 2001
From: Eduardo Broto <ebroto@tutanota.com>
Date: Fri, 22 May 2020 22:39:19 +0200
Subject: multiple_crate_versions: skip dev and build deps

---
 clippy_lints/src/multiple_crate_versions.rs        | 59 +++++++++++++++++-----
 .../5041_allow_dev_build/Cargo.toml                | 17 +++++++
 .../5041_allow_dev_build/src/main.rs               |  4 ++
 3 files changed, 66 insertions(+), 14 deletions(-)
 create mode 100644 tests/ui-cargo/multiple_crate_versions/5041_allow_dev_build/Cargo.toml
 create mode 100644 tests/ui-cargo/multiple_crate_versions/5041_allow_dev_build/src/main.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/multiple_crate_versions.rs b/clippy_lints/src/multiple_crate_versions.rs
index c4decfc9401..b24ec897ef5 100644
--- a/clippy_lints/src/multiple_crate_versions.rs
+++ b/clippy_lints/src/multiple_crate_versions.rs
@@ -1,11 +1,14 @@
 //! lint on multiple versions of a crate being used
 
 use crate::utils::{run_lints, span_lint};
+use rustc_hir::def_id::LOCAL_CRATE;
 use rustc_hir::{Crate, CRATE_HIR_ID};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::DUMMY_SP;
 
+use cargo_metadata::{DependencyKind, MetadataCommand, Node, Package, PackageId};
+use if_chain::if_chain;
 use itertools::Itertools;
 
 declare_clippy_lint! {
@@ -34,37 +37,65 @@ declare_clippy_lint! {
 declare_lint_pass!(MultipleCrateVersions => [MULTIPLE_CRATE_VERSIONS]);
 
 impl LateLintPass<'_, '_> for MultipleCrateVersions {
+    #[allow(clippy::find_map)]
     fn check_crate(&mut self, cx: &LateContext<'_, '_>, _: &Crate<'_>) {
         if !run_lints(cx, &[MULTIPLE_CRATE_VERSIONS], CRATE_HIR_ID) {
             return;
         }
 
-        let metadata = if let Ok(metadata) = cargo_metadata::MetadataCommand::new().exec() {
+        let metadata = if let Ok(metadata) = MetadataCommand::new().exec() {
             metadata
         } else {
             span_lint(cx, MULTIPLE_CRATE_VERSIONS, DUMMY_SP, "could not read cargo metadata");
-
             return;
         };
 
+        let local_name = cx.tcx.crate_name(LOCAL_CRATE).as_str();
         let mut packages = metadata.packages;
         packages.sort_by(|a, b| a.name.cmp(&b.name));
 
-        for (name, group) in &packages.into_iter().group_by(|p| p.name.clone()) {
-            let group: Vec<cargo_metadata::Package> = group.collect();
+        if_chain! {
+            if let Some(resolve) = &metadata.resolve;
+            if let Some(local_id) = packages.iter().find(|p| p.name == *local_name).map(|p| &p.id);
+            then {
+                for (name, group) in &packages.iter().group_by(|p| p.name.clone()) {
+                    let group: Vec<&Package> = group.collect();
+
+                    if group.len() <= 1 {
+                        continue;
+                    }
 
-            if group.len() > 1 {
-                let mut versions: Vec<_> = group.into_iter().map(|p| p.version).collect();
-                versions.sort();
-                let versions = versions.iter().join(", ");
+                    if group.iter().all(|p| is_normal_dep(&resolve.nodes, local_id, &p.id)) {
+                        let mut versions: Vec<_> = group.into_iter().map(|p| &p.version).collect();
+                        versions.sort();
+                        let versions = versions.iter().join(", ");
 
-                span_lint(
-                    cx,
-                    MULTIPLE_CRATE_VERSIONS,
-                    DUMMY_SP,
-                    &format!("multiple versions for dependency `{}`: {}", name, versions),
-                );
+                        span_lint(
+                            cx,
+                            MULTIPLE_CRATE_VERSIONS,
+                            DUMMY_SP,
+                            &format!("multiple versions for dependency `{}`: {}", name, versions),
+                        );
+                    }
+                }
             }
         }
     }
 }
+
+fn is_normal_dep(nodes: &[Node], local_id: &PackageId, dep_id: &PackageId) -> bool {
+    fn depends_on(node: &Node, dep_id: &PackageId) -> bool {
+        node.deps.iter().any(|dep| {
+            dep.pkg == *dep_id
+                && dep
+                    .dep_kinds
+                    .iter()
+                    .any(|info| matches!(info.kind, DependencyKind::Normal))
+        })
+    }
+
+    nodes
+        .iter()
+        .filter(|node| depends_on(node, dep_id))
+        .any(|node| node.id == *local_id || is_normal_dep(nodes, local_id, &node.id))
+}
diff --git a/tests/ui-cargo/multiple_crate_versions/5041_allow_dev_build/Cargo.toml b/tests/ui-cargo/multiple_crate_versions/5041_allow_dev_build/Cargo.toml
new file mode 100644
index 00000000000..72731fbc75d
--- /dev/null
+++ b/tests/ui-cargo/multiple_crate_versions/5041_allow_dev_build/Cargo.toml
@@ -0,0 +1,17 @@
+# Should not lint for dev or build dependencies. See issue 5041.
+
+[package]
+name = "multiple_crate_versions"
+version = "0.1.0"
+publish = false
+
+# One of the versions of winapi is only a dev dependency: allowed
+[dependencies]
+ctrlc = "=3.1.0"
+[dev-dependencies]
+ansi_term = "=0.11.0"
+
+# Both versions of winapi are a build dependency: allowed
+[build-dependencies]
+ctrlc = "=3.1.0"
+ansi_term = "=0.11.0"
diff --git a/tests/ui-cargo/multiple_crate_versions/5041_allow_dev_build/src/main.rs b/tests/ui-cargo/multiple_crate_versions/5041_allow_dev_build/src/main.rs
new file mode 100644
index 00000000000..1b2d3ec9459
--- /dev/null
+++ b/tests/ui-cargo/multiple_crate_versions/5041_allow_dev_build/src/main.rs
@@ -0,0 +1,4 @@
+// compile-flags: --crate-name=multiple_crate_versions
+#![warn(clippy::multiple_crate_versions)]
+
+fn main() {}
-- 
cgit 1.4.1-3-g733a5


From ec0a00e53980619a6313ff4f01099a1aebcfd9e6 Mon Sep 17 00:00:00 2001
From: Eduardo Broto <ebroto@tutanota.com>
Date: Sun, 24 May 2020 21:17:54 +0200
Subject: Use find_map instead of find() + map()

---
 clippy_lints/src/multiple_crate_versions.rs | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/multiple_crate_versions.rs b/clippy_lints/src/multiple_crate_versions.rs
index b24ec897ef5..b6770804e18 100644
--- a/clippy_lints/src/multiple_crate_versions.rs
+++ b/clippy_lints/src/multiple_crate_versions.rs
@@ -37,7 +37,6 @@ declare_clippy_lint! {
 declare_lint_pass!(MultipleCrateVersions => [MULTIPLE_CRATE_VERSIONS]);
 
 impl LateLintPass<'_, '_> for MultipleCrateVersions {
-    #[allow(clippy::find_map)]
     fn check_crate(&mut self, cx: &LateContext<'_, '_>, _: &Crate<'_>) {
         if !run_lints(cx, &[MULTIPLE_CRATE_VERSIONS], CRATE_HIR_ID) {
             return;
@@ -56,7 +55,9 @@ impl LateLintPass<'_, '_> for MultipleCrateVersions {
 
         if_chain! {
             if let Some(resolve) = &metadata.resolve;
-            if let Some(local_id) = packages.iter().find(|p| p.name == *local_name).map(|p| &p.id);
+            if let Some(local_id) = packages
+                .iter()
+                .find_map(|p| if p.name == *local_name { Some(&p.id) } else { None });
             then {
                 for (name, group) in &packages.iter().group_by(|p| p.name.clone()) {
                     let group: Vec<&Package> = group.collect();
-- 
cgit 1.4.1-3-g733a5


From 4f8909fad986dda68a9dcd172eaa362b6fce105b Mon Sep 17 00:00:00 2001
From: ThibsG <Thibs@debian.com>
Date: Sat, 9 May 2020 21:28:31 +0200
Subject: Extend `useless_conversion` lint with TryFrom

---
 clippy_lints/src/useless_conversion.rs | 47 ++++++++++++++++++++++++++--------
 clippy_lints/src/utils/paths.rs        |  1 +
 tests/ui/useless_conversion.stderr     | 20 +++++++--------
 tests/ui/useless_conversion_try.rs     | 25 ++++++++++++++++++
 tests/ui/useless_conversion_try.stderr | 39 ++++++++++++++++++++++++++++
 5 files changed, 112 insertions(+), 20 deletions(-)
 create mode 100644 tests/ui/useless_conversion_try.rs
 create mode 100644 tests/ui/useless_conversion_try.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/useless_conversion.rs b/clippy_lints/src/useless_conversion.rs
index 95921518986..0b080d9be2c 100644
--- a/clippy_lints/src/useless_conversion.rs
+++ b/clippy_lints/src/useless_conversion.rs
@@ -1,13 +1,16 @@
 use crate::utils::{
-    match_def_path, match_trait_method, paths, same_tys, snippet, snippet_with_macro_callsite, span_lint_and_sugg,
+    is_type_diagnostic_item, match_def_path, match_trait_method, paths, same_tys, snippet, snippet_with_macro_callsite,
+    span_lint_and_help, span_lint_and_sugg,
 };
+use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, HirId, MatchSource};
 use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for `Into`/`From`/`IntoIter` calls that useless converts
+    /// **What it does:** Checks for `Into`, `From`, `TryFrom`,`IntoIter` calls that useless converts
     /// to the same type as caller.
     ///
     /// **Why is this bad?** Redundant code.
@@ -26,7 +29,7 @@ declare_clippy_lint! {
     /// ```
     pub USELESS_CONVERSION,
     complexity,
-    "calls to `Into`/`From`/`IntoIter` that performs useless conversions to the same type"
+    "calls to `Into`, `From`, `TryFrom`, `IntoIter` that performs useless conversions to the same type"
 }
 
 #[derive(Default)]
@@ -68,7 +71,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UselessConversion {
                             cx,
                             USELESS_CONVERSION,
                             e.span,
-                            "useless conversion",
+                            "Useless conversion to the same type",
                             "consider removing `.into()`",
                             sugg,
                             Applicability::MachineApplicable, // snippet
@@ -84,7 +87,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UselessConversion {
                             cx,
                             USELESS_CONVERSION,
                             e.span,
-                            "useless conversion",
+                            "Useless conversion to the same type",
                             "consider removing `.into_iter()`",
                             sugg,
                             Applicability::MachineApplicable, // snippet
@@ -94,11 +97,35 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UselessConversion {
             },
 
             ExprKind::Call(ref path, ref args) => {
-                if let ExprKind::Path(ref qpath) = path.kind {
-                    if let Some(def_id) = cx.tables.qpath_res(qpath, path.hir_id).opt_def_id() {
+                if_chain! {
+                    if args.len() == 1;
+                    if let ExprKind::Path(ref qpath) = path.kind;
+                    if let Some(def_id) = cx.tables.qpath_res(qpath, path.hir_id).opt_def_id();
+                    let a = cx.tables.expr_ty(e);
+                    let b = cx.tables.expr_ty(&args[0]);
+
+                    then {
+                        if_chain! {
+                            if match_def_path(cx, def_id, &paths::TRY_FROM);
+                            if is_type_diagnostic_item(cx, a, sym!(result_type));
+                            if let ty::Adt(_, substs) = a.kind;
+                            if let Some(a_type) = substs.types().nth(0);
+                            if same_tys(cx, a_type, b);
+
+                            then {
+                                let hint = format!("consider removing `{}()`", snippet(cx, path.span, "TryFrom::try_from"));
+                                span_lint_and_help(
+                                    cx,
+                                    USELESS_CONVERSION,
+                                    e.span,
+                                    "Useless conversion to the same type",
+                                    None,
+                                    &hint,
+                                );
+                            }
+                        }
+
                         if match_def_path(cx, def_id, &paths::FROM_FROM) {
-                            let a = cx.tables.expr_ty(e);
-                            let b = cx.tables.expr_ty(&args[0]);
                             if same_tys(cx, a, b) {
                                 let sugg = snippet(cx, args[0].span.source_callsite(), "<expr>").into_owned();
                                 let sugg_msg =
@@ -107,7 +134,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UselessConversion {
                                     cx,
                                     USELESS_CONVERSION,
                                     e.span,
-                                    "useless conversion",
+                                    "Useless conversion to the same type",
                                     &sugg_msg,
                                     sugg,
                                     Applicability::MachineApplicable, // snippet
diff --git a/clippy_lints/src/utils/paths.rs b/clippy_lints/src/utils/paths.rs
index b3ad2ad9d99..e00d726282a 100644
--- a/clippy_lints/src/utils/paths.rs
+++ b/clippy_lints/src/utils/paths.rs
@@ -128,6 +128,7 @@ pub const TO_OWNED_METHOD: [&str; 4] = ["alloc", "borrow", "ToOwned", "to_owned"
 pub const TO_STRING: [&str; 3] = ["alloc", "string", "ToString"];
 pub const TO_STRING_METHOD: [&str; 4] = ["alloc", "string", "ToString", "to_string"];
 pub const TRANSMUTE: [&str; 4] = ["core", "intrinsics", "", "transmute"];
+pub const TRY_FROM: [&str; 4] = ["core", "convert", "TryFrom", "try_from"];
 pub const TRY_FROM_ERROR: [&str; 4] = ["std", "ops", "Try", "from_error"];
 pub const TRY_INTO_RESULT: [&str; 4] = ["std", "ops", "Try", "into_result"];
 pub const VEC: [&str; 3] = ["alloc", "vec", "Vec"];
diff --git a/tests/ui/useless_conversion.stderr b/tests/ui/useless_conversion.stderr
index 7df3507edfd..0b2947f7d62 100644
--- a/tests/ui/useless_conversion.stderr
+++ b/tests/ui/useless_conversion.stderr
@@ -1,4 +1,4 @@
-error: useless conversion
+error: Useless conversion to the same type
   --> $DIR/useless_conversion.rs:6:13
    |
 LL |     let _ = T::from(val);
@@ -10,55 +10,55 @@ note: the lint level is defined here
 LL | #![deny(clippy::useless_conversion)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: useless conversion
+error: Useless conversion to the same type
   --> $DIR/useless_conversion.rs:7:5
    |
 LL |     val.into()
    |     ^^^^^^^^^^ help: consider removing `.into()`: `val`
 
-error: useless conversion
+error: Useless conversion to the same type
   --> $DIR/useless_conversion.rs:19:22
    |
 LL |         let _: i32 = 0i32.into();
    |                      ^^^^^^^^^^^ help: consider removing `.into()`: `0i32`
 
-error: useless conversion
+error: Useless conversion to the same type
   --> $DIR/useless_conversion.rs:51:21
    |
 LL |     let _: String = "foo".to_string().into();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into()`: `"foo".to_string()`
 
-error: useless conversion
+error: Useless conversion to the same type
   --> $DIR/useless_conversion.rs:52:21
    |
 LL |     let _: String = From::from("foo".to_string());
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `From::from()`: `"foo".to_string()`
 
-error: useless conversion
+error: Useless conversion to the same type
   --> $DIR/useless_conversion.rs:53:13
    |
 LL |     let _ = String::from("foo".to_string());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `String::from()`: `"foo".to_string()`
 
-error: useless conversion
+error: Useless conversion to the same type
   --> $DIR/useless_conversion.rs:54:13
    |
 LL |     let _ = String::from(format!("A: {:04}", 123));
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `String::from()`: `format!("A: {:04}", 123)`
 
-error: useless conversion
+error: Useless conversion to the same type
   --> $DIR/useless_conversion.rs:55:13
    |
 LL |     let _ = "".lines().into_iter();
    |             ^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `"".lines()`
 
-error: useless conversion
+error: Useless conversion to the same type
   --> $DIR/useless_conversion.rs:56:13
    |
 LL |     let _ = vec![1, 2, 3].into_iter().into_iter();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `vec![1, 2, 3].into_iter()`
 
-error: useless conversion
+error: Useless conversion to the same type
   --> $DIR/useless_conversion.rs:57:21
    |
 LL |     let _: String = format!("Hello {}", "world").into();
diff --git a/tests/ui/useless_conversion_try.rs b/tests/ui/useless_conversion_try.rs
new file mode 100644
index 00000000000..abf0c891b52
--- /dev/null
+++ b/tests/ui/useless_conversion_try.rs
@@ -0,0 +1,25 @@
+#![deny(clippy::useless_conversion)]
+
+use std::convert::TryFrom;
+
+fn test_generic<T: Copy>(val: T) -> T {
+    T::try_from(val).unwrap()
+}
+
+fn test_generic2<T: Copy + Into<i32> + Into<U>, U: From<T>>(val: T) {
+    let _ = U::try_from(val).unwrap();
+}
+
+fn main() {
+    test_generic(10i32);
+    test_generic2::<i32, i32>(10i32);
+
+    let _: String = TryFrom::try_from("foo").unwrap();
+    let _ = String::try_from("foo").unwrap();
+    #[allow(clippy::useless_conversion)]
+    let _ = String::try_from("foo").unwrap();
+
+    let _: String = TryFrom::try_from("foo".to_string()).unwrap();
+    let _ = String::try_from("foo".to_string()).unwrap();
+    let _ = String::try_from(format!("A: {:04}", 123)).unwrap();
+}
diff --git a/tests/ui/useless_conversion_try.stderr b/tests/ui/useless_conversion_try.stderr
new file mode 100644
index 00000000000..b3cb01fbe32
--- /dev/null
+++ b/tests/ui/useless_conversion_try.stderr
@@ -0,0 +1,39 @@
+error: Useless conversion to the same type
+  --> $DIR/useless_conversion_try.rs:6:5
+   |
+LL |     T::try_from(val).unwrap()
+   |     ^^^^^^^^^^^^^^^^
+   |
+note: the lint level is defined here
+  --> $DIR/useless_conversion_try.rs:1:9
+   |
+LL | #![deny(clippy::useless_conversion)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   = help: consider removing `T::try_from()`
+
+error: Useless conversion to the same type
+  --> $DIR/useless_conversion_try.rs:22:21
+   |
+LL |     let _: String = TryFrom::try_from("foo".to_string()).unwrap();
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider removing `TryFrom::try_from()`
+
+error: Useless conversion to the same type
+  --> $DIR/useless_conversion_try.rs:23:13
+   |
+LL |     let _ = String::try_from("foo".to_string()).unwrap();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider removing `String::try_from()`
+
+error: Useless conversion to the same type
+  --> $DIR/useless_conversion_try.rs:24:13
+   |
+LL |     let _ = String::try_from(format!("A: {:04}", 123)).unwrap();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider removing `String::try_from()`
+
+error: aborting due to 4 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 705bfdcc467c0ddd7eb61d3adb24809b27bae891 Mon Sep 17 00:00:00 2001
From: ThibsG <Thibs@debian.com>
Date: Fri, 22 May 2020 11:46:17 +0200
Subject: Extend `useless_conversion` lint with TryInto

---
 clippy_lints/src/useless_conversion.rs | 38 +++++++++++++++++++++++++++-------
 clippy_lints/src/utils/paths.rs        |  1 +
 src/lintlist/mod.rs                    |  2 +-
 tests/ui/useless_conversion_try.rs     | 17 +++++++++++----
 tests/ui/useless_conversion_try.stderr | 38 +++++++++++++++++++++++++++-------
 5 files changed, 77 insertions(+), 19 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/useless_conversion.rs b/clippy_lints/src/useless_conversion.rs
index 0b080d9be2c..1645c5777b2 100644
--- a/clippy_lints/src/useless_conversion.rs
+++ b/clippy_lints/src/useless_conversion.rs
@@ -10,8 +10,8 @@ use rustc_middle::ty;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for `Into`, `From`, `TryFrom`,`IntoIter` calls that useless converts
-    /// to the same type as caller.
+    /// **What it does:** Checks for `Into`, `TryInto`, `From`, `TryFrom`,`IntoIter` calls
+    /// that useless converts to the same type as caller.
     ///
     /// **Why is this bad?** Redundant code.
     ///
@@ -29,7 +29,7 @@ declare_clippy_lint! {
     /// ```
     pub USELESS_CONVERSION,
     complexity,
-    "calls to `Into`, `From`, `TryFrom`, `IntoIter` that performs useless conversions to the same type"
+    "calls to `Into`, `TryInto`, `From`, `TryFrom`, `IntoIter` that performs useless conversions to the same type"
 }
 
 #[derive(Default)]
@@ -39,6 +39,7 @@ pub struct UselessConversion {
 
 impl_lint_pass!(UselessConversion => [USELESS_CONVERSION]);
 
+#[allow(clippy::too_many_lines)]
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UselessConversion {
     fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr<'_>) {
         if e.span.from_expansion() {
@@ -66,7 +67,6 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UselessConversion {
                     let b = cx.tables.expr_ty(&args[0]);
                     if same_tys(cx, a, b) {
                         let sugg = snippet_with_macro_callsite(cx, args[0].span, "<expr>").to_string();
-
                         span_lint_and_sugg(
                             cx,
                             USELESS_CONVERSION,
@@ -94,6 +94,27 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UselessConversion {
                         );
                     }
                 }
+                if match_trait_method(cx, e, &paths::TRY_INTO_TRAIT) && &*name.ident.as_str() == "try_into" {
+                    if_chain! {
+                        let a = cx.tables.expr_ty(e);
+                        let b = cx.tables.expr_ty(&args[0]);
+                        if is_type_diagnostic_item(cx, a, sym!(result_type));
+                        if let ty::Adt(_, substs) = a.kind;
+                        if let Some(a_type) = substs.types().next();
+                        if same_tys(cx, a_type, b);
+
+                        then {
+                            span_lint_and_help(
+                                cx,
+                                USELESS_CONVERSION,
+                                e.span,
+                                "Useless conversion to the same type",
+                                None,
+                                "consider removing `.try_into()`",
+                            );
+                        }
+                    }
+                }
             },
 
             ExprKind::Call(ref path, ref args) => {
@@ -109,7 +130,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UselessConversion {
                             if match_def_path(cx, def_id, &paths::TRY_FROM);
                             if is_type_diagnostic_item(cx, a, sym!(result_type));
                             if let ty::Adt(_, substs) = a.kind;
-                            if let Some(a_type) = substs.types().nth(0);
+                            if let Some(a_type) = substs.types().next();
                             if same_tys(cx, a_type, b);
 
                             then {
@@ -125,8 +146,11 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UselessConversion {
                             }
                         }
 
-                        if match_def_path(cx, def_id, &paths::FROM_FROM) {
-                            if same_tys(cx, a, b) {
+                        if_chain! {
+                            if match_def_path(cx, def_id, &paths::FROM_FROM);
+                            if same_tys(cx, a, b);
+
+                            then {
                                 let sugg = snippet(cx, args[0].span.source_callsite(), "<expr>").into_owned();
                                 let sugg_msg =
                                     format!("consider removing `{}()`", snippet(cx, path.span, "From::from"));
diff --git a/clippy_lints/src/utils/paths.rs b/clippy_lints/src/utils/paths.rs
index e00d726282a..779da7e6bf2 100644
--- a/clippy_lints/src/utils/paths.rs
+++ b/clippy_lints/src/utils/paths.rs
@@ -131,6 +131,7 @@ pub const TRANSMUTE: [&str; 4] = ["core", "intrinsics", "", "transmute"];
 pub const TRY_FROM: [&str; 4] = ["core", "convert", "TryFrom", "try_from"];
 pub const TRY_FROM_ERROR: [&str; 4] = ["std", "ops", "Try", "from_error"];
 pub const TRY_INTO_RESULT: [&str; 4] = ["std", "ops", "Try", "into_result"];
+pub const TRY_INTO_TRAIT: [&str; 3] = ["core", "convert", "TryInto"];
 pub const VEC: [&str; 3] = ["alloc", "vec", "Vec"];
 pub const VEC_AS_MUT_SLICE: [&str; 4] = ["alloc", "vec", "Vec", "as_mut_slice"];
 pub const VEC_AS_SLICE: [&str; 4] = ["alloc", "vec", "Vec", "as_slice"];
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index 8211a57b564..f63301c7db0 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -2421,7 +2421,7 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
     Lint {
         name: "useless_conversion",
         group: "complexity",
-        desc: "calls to `Into`/`From`/`IntoIter` that performs useless conversions to the same type",
+        desc: "calls to `Into`, `TryInto`, `From`, `TryFrom`, `IntoIter` that performs useless conversions to the same type",
         deprecation: None,
         module: "useless_conversion",
     },
diff --git a/tests/ui/useless_conversion_try.rs b/tests/ui/useless_conversion_try.rs
index abf0c891b52..ab4f960edb7 100644
--- a/tests/ui/useless_conversion_try.rs
+++ b/tests/ui/useless_conversion_try.rs
@@ -1,12 +1,16 @@
 #![deny(clippy::useless_conversion)]
 
-use std::convert::TryFrom;
+use std::convert::{TryFrom, TryInto};
 
 fn test_generic<T: Copy>(val: T) -> T {
-    T::try_from(val).unwrap()
+    let _ = T::try_from(val).unwrap();
+    val.try_into().unwrap()
 }
 
 fn test_generic2<T: Copy + Into<i32> + Into<U>, U: From<T>>(val: T) {
+    // ok
+    let _: i32 = val.try_into().unwrap();
+    let _: U = val.try_into().unwrap();
     let _ = U::try_from(val).unwrap();
 }
 
@@ -14,12 +18,17 @@ fn main() {
     test_generic(10i32);
     test_generic2::<i32, i32>(10i32);
 
+    let _: String = "foo".try_into().unwrap();
     let _: String = TryFrom::try_from("foo").unwrap();
     let _ = String::try_from("foo").unwrap();
     #[allow(clippy::useless_conversion)]
-    let _ = String::try_from("foo").unwrap();
-
+    {
+        let _ = String::try_from("foo").unwrap();
+        let _: String = "foo".try_into().unwrap();
+    }
+    let _: String = "foo".to_string().try_into().unwrap();
     let _: String = TryFrom::try_from("foo".to_string()).unwrap();
     let _ = String::try_from("foo".to_string()).unwrap();
     let _ = String::try_from(format!("A: {:04}", 123)).unwrap();
+    let _: String = format!("Hello {}", "world").try_into().unwrap();
 }
diff --git a/tests/ui/useless_conversion_try.stderr b/tests/ui/useless_conversion_try.stderr
index b3cb01fbe32..5afb5dc45d3 100644
--- a/tests/ui/useless_conversion_try.stderr
+++ b/tests/ui/useless_conversion_try.stderr
@@ -1,8 +1,8 @@
 error: Useless conversion to the same type
-  --> $DIR/useless_conversion_try.rs:6:5
+  --> $DIR/useless_conversion_try.rs:6:13
    |
-LL |     T::try_from(val).unwrap()
-   |     ^^^^^^^^^^^^^^^^
+LL |     let _ = T::try_from(val).unwrap();
+   |             ^^^^^^^^^^^^^^^^
    |
 note: the lint level is defined here
   --> $DIR/useless_conversion_try.rs:1:9
@@ -12,7 +12,23 @@ LL | #![deny(clippy::useless_conversion)]
    = help: consider removing `T::try_from()`
 
 error: Useless conversion to the same type
-  --> $DIR/useless_conversion_try.rs:22:21
+  --> $DIR/useless_conversion_try.rs:7:5
+   |
+LL |     val.try_into().unwrap()
+   |     ^^^^^^^^^^^^^^
+   |
+   = help: consider removing `.try_into()`
+
+error: Useless conversion to the same type
+  --> $DIR/useless_conversion_try.rs:29:21
+   |
+LL |     let _: String = "foo".to_string().try_into().unwrap();
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider removing `.try_into()`
+
+error: Useless conversion to the same type
+  --> $DIR/useless_conversion_try.rs:30:21
    |
 LL |     let _: String = TryFrom::try_from("foo".to_string()).unwrap();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -20,7 +36,7 @@ LL |     let _: String = TryFrom::try_from("foo".to_string()).unwrap();
    = help: consider removing `TryFrom::try_from()`
 
 error: Useless conversion to the same type
-  --> $DIR/useless_conversion_try.rs:23:13
+  --> $DIR/useless_conversion_try.rs:31:13
    |
 LL |     let _ = String::try_from("foo".to_string()).unwrap();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -28,12 +44,20 @@ LL |     let _ = String::try_from("foo".to_string()).unwrap();
    = help: consider removing `String::try_from()`
 
 error: Useless conversion to the same type
-  --> $DIR/useless_conversion_try.rs:24:13
+  --> $DIR/useless_conversion_try.rs:32:13
    |
 LL |     let _ = String::try_from(format!("A: {:04}", 123)).unwrap();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: consider removing `String::try_from()`
 
-error: aborting due to 4 previous errors
+error: Useless conversion to the same type
+  --> $DIR/useless_conversion_try.rs:33:21
+   |
+LL |     let _: String = format!("Hello {}", "world").try_into().unwrap();
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider removing `.try_into()`
+
+error: aborting due to 7 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 60d38ee1dde4344daa5fdf716eef78b45f483c7e Mon Sep 17 00:00:00 2001
From: Eduardo Broto <ebroto@tutanota.com>
Date: Sat, 23 May 2020 22:07:03 +0200
Subject: reversed_empty_ranges: add suggestion for &slice[N..N]

---
 clippy_lints/src/ranges.rs                      | 30 ++++++++++++++++++-------
 tests/ui/reversed_empty_ranges_fixable.fixed    |  7 +++++-
 tests/ui/reversed_empty_ranges_fixable.rs       |  7 +++++-
 tests/ui/reversed_empty_ranges_fixable.stderr   | 16 ++++++++-----
 tests/ui/reversed_empty_ranges_unfixable.rs     |  1 -
 tests/ui/reversed_empty_ranges_unfixable.stderr | 10 ++-------
 6 files changed, 47 insertions(+), 24 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/ranges.rs b/clippy_lints/src/ranges.rs
index 83c6faac041..1eb26d97ed4 100644
--- a/clippy_lints/src/ranges.rs
+++ b/clippy_lints/src/ranges.rs
@@ -241,14 +241,14 @@ fn check_inclusive_range_minus_one(cx: &LateContext<'_, '_>, expr: &Expr<'_>) {
 }
 
 fn check_reversed_empty_range(cx: &LateContext<'_, '_>, expr: &Expr<'_>) {
-    fn inside_indexing_expr(cx: &LateContext<'_, '_>, expr: &Expr<'_>) -> bool {
-        matches!(
-            get_parent_expr(cx, expr),
-            Some(Expr {
+    fn inside_indexing_expr<'a>(cx: &'a LateContext<'_, '_>, expr: &Expr<'_>) -> Option<&'a Expr<'a>> {
+        match get_parent_expr(cx, expr) {
+            parent_expr @ Some(Expr {
                 kind: ExprKind::Index(..),
                 ..
-            })
-        )
+            }) => parent_expr,
+            _ => None,
+        }
     }
 
     fn is_empty_range(limits: RangeLimits, ordering: Ordering) -> bool {
@@ -267,18 +267,32 @@ fn check_reversed_empty_range(cx: &LateContext<'_, '_>, expr: &Expr<'_>) {
         if let Some(ordering) = Constant::partial_cmp(cx.tcx, ty, &start_idx, &end_idx);
         if is_empty_range(limits, ordering);
         then {
-            if inside_indexing_expr(cx, expr) {
+            if let Some(parent_expr) = inside_indexing_expr(cx, expr) {
                 let (reason, outcome) = if ordering == Ordering::Equal {
                     ("empty", "always yield an empty slice")
                 } else {
                     ("reversed", "panic at run-time")
                 };
 
-                span_lint(
+                span_lint_and_then(
                     cx,
                     REVERSED_EMPTY_RANGES,
                     expr.span,
                     &format!("this range is {} and using it to index a slice will {}", reason, outcome),
+                    |diag| {
+                        if_chain! {
+                            if ordering == Ordering::Equal;
+                            if let ty::Slice(slice_ty) = cx.tables.expr_ty(parent_expr).kind;
+                            then {
+                                diag.span_suggestion(
+                                    parent_expr.span,
+                                    "if you want an empty slice, use",
+                                    format!("[] as &[{}]", slice_ty),
+                                    Applicability::MaybeIncorrect
+                                );
+                            }
+                        }
+                    }
                 );
             } else {
                 span_lint_and_then(
diff --git a/tests/ui/reversed_empty_ranges_fixable.fixed b/tests/ui/reversed_empty_ranges_fixable.fixed
index ee2cbc3cf54..332c0427ef6 100644
--- a/tests/ui/reversed_empty_ranges_fixable.fixed
+++ b/tests/ui/reversed_empty_ranges_fixable.fixed
@@ -4,18 +4,23 @@
 const ANSWER: i32 = 42;
 
 fn main() {
+    let arr = [1, 2, 3, 4, 5];
+
+    // These should be linted:
+
     (21..=42).rev().for_each(|x| println!("{}", x));
     let _ = (21..ANSWER).rev().filter(|x| x % 2 == 0).take(10).collect::<Vec<_>>();
 
     for _ in (-42..=-21).rev() {}
     for _ in (21u32..42u32).rev() {}
 
+    let _ = &[] as &[i32];
+
     // These should be ignored as they are not empty ranges:
 
     (21..=42).for_each(|x| println!("{}", x));
     (21..42).for_each(|x| println!("{}", x));
 
-    let arr = [1, 2, 3, 4, 5];
     let _ = &arr[1..=3];
     let _ = &arr[1..3];
 
diff --git a/tests/ui/reversed_empty_ranges_fixable.rs b/tests/ui/reversed_empty_ranges_fixable.rs
index 6ed5ca6daa0..901ec8bcc09 100644
--- a/tests/ui/reversed_empty_ranges_fixable.rs
+++ b/tests/ui/reversed_empty_ranges_fixable.rs
@@ -4,18 +4,23 @@
 const ANSWER: i32 = 42;
 
 fn main() {
+    let arr = [1, 2, 3, 4, 5];
+
+    // These should be linted:
+
     (42..=21).for_each(|x| println!("{}", x));
     let _ = (ANSWER..21).filter(|x| x % 2 == 0).take(10).collect::<Vec<_>>();
 
     for _ in -21..=-42 {}
     for _ in 42u32..21u32 {}
 
+    let _ = &arr[3..3];
+
     // These should be ignored as they are not empty ranges:
 
     (21..=42).for_each(|x| println!("{}", x));
     (21..42).for_each(|x| println!("{}", x));
 
-    let arr = [1, 2, 3, 4, 5];
     let _ = &arr[1..=3];
     let _ = &arr[1..3];
 
diff --git a/tests/ui/reversed_empty_ranges_fixable.stderr b/tests/ui/reversed_empty_ranges_fixable.stderr
index 97933b8ff85..9a646fd9939 100644
--- a/tests/ui/reversed_empty_ranges_fixable.stderr
+++ b/tests/ui/reversed_empty_ranges_fixable.stderr
@@ -1,5 +1,5 @@
 error: this range is empty so it will yield no values
-  --> $DIR/reversed_empty_ranges_fixable.rs:7:5
+  --> $DIR/reversed_empty_ranges_fixable.rs:11:5
    |
 LL |     (42..=21).for_each(|x| println!("{}", x));
    |     ^^^^^^^^^
@@ -11,7 +11,7 @@ LL |     (21..=42).rev().for_each(|x| println!("{}", x));
    |     ^^^^^^^^^^^^^^^
 
 error: this range is empty so it will yield no values
-  --> $DIR/reversed_empty_ranges_fixable.rs:8:13
+  --> $DIR/reversed_empty_ranges_fixable.rs:12:13
    |
 LL |     let _ = (ANSWER..21).filter(|x| x % 2 == 0).take(10).collect::<Vec<_>>();
    |             ^^^^^^^^^^^^
@@ -22,7 +22,7 @@ LL |     let _ = (21..ANSWER).rev().filter(|x| x % 2 == 0).take(10).collect::<Ve
    |             ^^^^^^^^^^^^^^^^^^
 
 error: this range is empty so it will yield no values
-  --> $DIR/reversed_empty_ranges_fixable.rs:10:14
+  --> $DIR/reversed_empty_ranges_fixable.rs:14:14
    |
 LL |     for _ in -21..=-42 {}
    |              ^^^^^^^^^
@@ -33,7 +33,7 @@ LL |     for _ in (-42..=-21).rev() {}
    |              ^^^^^^^^^^^^^^^^^
 
 error: this range is empty so it will yield no values
-  --> $DIR/reversed_empty_ranges_fixable.rs:11:14
+  --> $DIR/reversed_empty_ranges_fixable.rs:15:14
    |
 LL |     for _ in 42u32..21u32 {}
    |              ^^^^^^^^^^^^
@@ -43,5 +43,11 @@ help: consider using the following if you are attempting to iterate over this ra
 LL |     for _ in (21u32..42u32).rev() {}
    |              ^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 4 previous errors
+error: this range is empty and using it to index a slice will always yield an empty slice
+  --> $DIR/reversed_empty_ranges_fixable.rs:17:18
+   |
+LL |     let _ = &arr[3..3];
+   |              ----^^^^- help: if you want an empty slice, use: `[] as &[i32]`
+
+error: aborting due to 5 previous errors
 
diff --git a/tests/ui/reversed_empty_ranges_unfixable.rs b/tests/ui/reversed_empty_ranges_unfixable.rs
index c9ca4c47668..561a35625f0 100644
--- a/tests/ui/reversed_empty_ranges_unfixable.rs
+++ b/tests/ui/reversed_empty_ranges_unfixable.rs
@@ -9,7 +9,6 @@ fn main() {
     let arr = [1, 2, 3, 4, 5];
     let _ = &arr[3usize..=1usize];
     let _ = &arr[SOME_NUM..1];
-    let _ = &arr[3..3];
 
     for _ in ANSWER..ANSWER {}
 }
diff --git a/tests/ui/reversed_empty_ranges_unfixable.stderr b/tests/ui/reversed_empty_ranges_unfixable.stderr
index 12e5483ecdf..240188cbb46 100644
--- a/tests/ui/reversed_empty_ranges_unfixable.stderr
+++ b/tests/ui/reversed_empty_ranges_unfixable.stderr
@@ -18,17 +18,11 @@ error: this range is reversed and using it to index a slice will panic at run-ti
 LL |     let _ = &arr[SOME_NUM..1];
    |                  ^^^^^^^^^^^
 
-error: this range is empty and using it to index a slice will always yield an empty slice
-  --> $DIR/reversed_empty_ranges_unfixable.rs:12:18
-   |
-LL |     let _ = &arr[3..3];
-   |                  ^^^^
-
 error: this range is empty so it will yield no values
-  --> $DIR/reversed_empty_ranges_unfixable.rs:14:14
+  --> $DIR/reversed_empty_ranges_unfixable.rs:13:14
    |
 LL |     for _ in ANSWER..ANSWER {}
    |              ^^^^^^^^^^^^^^
 
-error: aborting due to 5 previous errors
+error: aborting due to 4 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 566377f6272b0a3b9fa65dabe1f39ee82be80d4e Mon Sep 17 00:00:00 2001
From: Jeremy Stucki <stucki.jeremy@gmail.com>
Date: Wed, 21 Aug 2019 21:19:28 +0200
Subject: Ignore calls to 'len'

---
 clippy_lints/src/methods/mod.rs | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 32b3b7f7947..c82cf57a4b1 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1614,6 +1614,21 @@ fn lint_or_fun_call<'a, 'tcx>(
         or_has_args: bool,
         span: Span,
     ) {
+        if let hir::ExprKind::MethodCall(ref path, _, ref args) = &arg.node {
+            if path.ident.as_str() == "len" {
+                let ty = walk_ptrs_ty(cx.tables.expr_ty(&args[0]));
+
+                match ty.sty {
+                    ty::Slice(_) | ty::Array(_, _) => return,
+                    _ => (),
+                }
+
+                if match_type(cx, ty, &paths::VEC) {
+                    return;
+                }
+            }
+        }
+
         // (path, fn_has_argument, methods, suffix)
         let know_types: &[(&[_], _, &[_], _)] = &[
             (&paths::BTREEMAP_ENTRY, false, &["or_insert"], "with"),
-- 
cgit 1.4.1-3-g733a5


From bcfeb4de1589c19a7b21f04fec284e6045c0aa7a Mon Sep 17 00:00:00 2001
From: Jeremy Stucki <dev@jeremystucki.ch>
Date: Mon, 25 May 2020 21:23:39 +0200
Subject: Fix build

---
 clippy_lints/src/methods/mod.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index c82cf57a4b1..52ca962e7ef 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1614,11 +1614,11 @@ fn lint_or_fun_call<'a, 'tcx>(
         or_has_args: bool,
         span: Span,
     ) {
-        if let hir::ExprKind::MethodCall(ref path, _, ref args) = &arg.node {
+        if let hir::ExprKind::MethodCall(ref path, _, ref args) = &arg.kind {
             if path.ident.as_str() == "len" {
                 let ty = walk_ptrs_ty(cx.tables.expr_ty(&args[0]));
 
-                match ty.sty {
+                match ty.kind {
                     ty::Slice(_) | ty::Array(_, _) => return,
                     _ => (),
                 }
-- 
cgit 1.4.1-3-g733a5


From a1824e187cb6d17e48e2ff039810551540a9b826 Mon Sep 17 00:00:00 2001
From: Eduardo Broto <ebroto@tutanota.com>
Date: Mon, 25 May 2020 23:09:06 +0200
Subject: ptr_arg: honor `allow` attr on arguments

---
 clippy_lints/src/ptr.rs        | 10 +++++++++-
 clippy_lints/src/utils/sugg.rs |  2 +-
 tests/ui/ptr_arg.rs            | 32 +++++++++++++++++++++++++++++++-
 3 files changed, 41 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs
index 2cdf9671419..4eac571f966 100644
--- a/clippy_lints/src/ptr.rs
+++ b/clippy_lints/src/ptr.rs
@@ -2,7 +2,7 @@
 
 use crate::utils::ptr::get_spans;
 use crate::utils::{
-    is_type_diagnostic_item, match_qpath, match_type, paths, snippet_opt, span_lint, span_lint_and_sugg,
+    is_allowed, is_type_diagnostic_item, match_qpath, match_type, paths, snippet_opt, span_lint, span_lint_and_sugg,
     span_lint_and_then, walk_ptrs_hir_ty,
 };
 use if_chain::if_chain;
@@ -150,8 +150,16 @@ fn check_fn(cx: &LateContext<'_, '_>, decl: &FnDecl<'_>, fn_id: HirId, opt_body_
     let fn_def_id = cx.tcx.hir().local_def_id(fn_id);
     let sig = cx.tcx.fn_sig(fn_def_id);
     let fn_ty = sig.skip_binder();
+    let body = opt_body_id.map(|id| cx.tcx.hir().body(id));
 
     for (idx, (arg, ty)) in decl.inputs.iter().zip(fn_ty.inputs()).enumerate() {
+        // Honor the allow attribute on parameters. See issue 5644.
+        if let Some(body) = &body {
+            if is_allowed(cx, PTR_ARG, body.params[idx].hir_id) {
+                continue;
+            }
+        }
+
         if let ty::Ref(_, ty, Mutability::Not) = ty.kind {
             if is_type_diagnostic_item(cx, ty, sym!(vec_type)) {
                 let mut ty_snippet = None;
diff --git a/clippy_lints/src/utils/sugg.rs b/clippy_lints/src/utils/sugg.rs
index 4ebe2e2852f..73758b7eeb7 100644
--- a/clippy_lints/src/utils/sugg.rs
+++ b/clippy_lints/src/utils/sugg.rs
@@ -530,7 +530,7 @@ pub trait DiagnosticBuilderExt<'a, T: LintContext> {
 
     /// Suggest to add an item before another.
     ///
-    /// The item should not be indented (expect for inner indentation).
+    /// The item should not be indented (except for inner indentation).
     ///
     /// # Example
     ///
diff --git a/tests/ui/ptr_arg.rs b/tests/ui/ptr_arg.rs
index 30f39e9b063..541225e6351 100644
--- a/tests/ui/ptr_arg.rs
+++ b/tests/ui/ptr_arg.rs
@@ -71,7 +71,6 @@ fn false_positive_capacity_too(x: &String) -> String {
 #[allow(dead_code)]
 fn test_cow_with_ref(c: &Cow<[i32]>) {}
 
-#[allow(dead_code)]
 fn test_cow(c: Cow<[i32]>) {
     let _c = c;
 }
@@ -84,3 +83,34 @@ trait Foo2 {
 impl Foo2 for String {
     fn do_string(&self) {}
 }
+
+// Check that the allow attribute on parameters is honored
+mod issue_5644 {
+    use std::borrow::Cow;
+
+    fn allowed(
+        #[allow(clippy::ptr_arg)] _v: &Vec<u32>,
+        #[allow(clippy::ptr_arg)] _s: &String,
+        #[allow(clippy::ptr_arg)] _c: &Cow<[i32]>,
+    ) {
+    }
+
+    struct S {}
+    impl S {
+        fn allowed(
+            #[allow(clippy::ptr_arg)] _v: &Vec<u32>,
+            #[allow(clippy::ptr_arg)] _s: &String,
+            #[allow(clippy::ptr_arg)] _c: &Cow<[i32]>,
+        ) {
+        }
+    }
+
+    trait T {
+        fn allowed(
+            #[allow(clippy::ptr_arg)] _v: &Vec<u32>,
+            #[allow(clippy::ptr_arg)] _s: &String,
+            #[allow(clippy::ptr_arg)] _c: &Cow<[i32]>,
+        ) {
+        }
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 67167be1679c60eefa2c314c5e4a2b673d5eef11 Mon Sep 17 00:00:00 2001
From: Philipp Hansch <dev@phansch.net>
Date: Sun, 17 May 2020 18:14:43 +0200
Subject: Make empty_line_after_outer_attr an early lint

---
 clippy_lints/Cargo.toml                          |  4 ++
 clippy_lints/src/attrs.rs                        | 75 ++++++++++++++----------
 tests/compile-test.rs                            |  2 +-
 tests/ui/auxiliary/proc_macro_attr.rs            | 37 ++++++++++++
 tests/ui/empty_line_after_outer_attribute.rs     | 19 +++++-
 tests/ui/empty_line_after_outer_attribute.stderr | 12 ++--
 6 files changed, 109 insertions(+), 40 deletions(-)
 create mode 100644 tests/ui/auxiliary/proc_macro_attr.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/Cargo.toml b/clippy_lints/Cargo.toml
index 1c0be727834..043a79f2001 100644
--- a/clippy_lints/Cargo.toml
+++ b/clippy_lints/Cargo.toml
@@ -33,5 +33,9 @@ semver = "0.9.0"
 # see <https://github.com/rust-lang/rust/pull/63587#issuecomment-522343864>
 url = { version =  "2.1.0", features = ["serde"] }
 
+[dev-dependencies]
+quote = "*"
+syn = { version = "*", features = ["full"] }
+
 [features]
 deny-warnings = []
diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs
index 64abc9fdc71..41f125d4839 100644
--- a/clippy_lints/src/attrs.rs
+++ b/clippy_lints/src/attrs.rs
@@ -248,7 +248,6 @@ declare_lint_pass!(Attributes => [
     INLINE_ALWAYS,
     DEPRECATED_SEMVER,
     USELESS_ATTRIBUTE,
-    EMPTY_LINE_AFTER_OUTER_ATTR,
     UNKNOWN_CLIPPY_LINTS,
 ]);
 
@@ -480,36 +479,6 @@ fn check_attrs(cx: &LateContext<'_, '_>, span: Span, name: Name, attrs: &[Attrib
     }
 
     for attr in attrs {
-        let attr_item = if let AttrKind::Normal(ref attr) = attr.kind {
-            attr
-        } else {
-            continue;
-        };
-
-        if attr.style == AttrStyle::Outer {
-            if attr_item.args.inner_tokens().is_empty() || !is_present_in_source(cx, attr.span) {
-                return;
-            }
-
-            let begin_of_attr_to_item = Span::new(attr.span.lo(), span.lo(), span.ctxt());
-            let end_of_attr_to_item = Span::new(attr.span.hi(), span.lo(), span.ctxt());
-
-            if let Some(snippet) = snippet_opt(cx, end_of_attr_to_item) {
-                let lines = snippet.split('\n').collect::<Vec<_>>();
-                let lines = without_block_comments(lines);
-
-                if lines.iter().filter(|l| l.trim().is_empty()).count() > 2 {
-                    span_lint(
-                        cx,
-                        EMPTY_LINE_AFTER_OUTER_ATTR,
-                        begin_of_attr_to_item,
-                        "Found an empty line after an outer attribute. \
-                         Perhaps you forgot to add a `!` to make it an inner attribute?",
-                    );
-                }
-            }
-        }
-
         if let Some(values) = attr.meta_item_list() {
             if values.len() != 1 || !attr.check_name(sym!(inline)) {
                 continue;
@@ -551,15 +520,57 @@ fn is_word(nmi: &NestedMetaItem, expected: Symbol) -> bool {
     }
 }
 
-declare_lint_pass!(EarlyAttributes => [DEPRECATED_CFG_ATTR, MISMATCHED_TARGET_OS]);
+declare_lint_pass!(EarlyAttributes => [
+    DEPRECATED_CFG_ATTR,
+    MISMATCHED_TARGET_OS,
+    EMPTY_LINE_AFTER_OUTER_ATTR,
+]);
 
 impl EarlyLintPass for EarlyAttributes {
+    fn check_item(&mut self, cx: &EarlyContext<'_>, item: &rustc_ast::ast::Item) {
+        check_empty_line_after_outer_attr(cx, item);
+    }
+
     fn check_attribute(&mut self, cx: &EarlyContext<'_>, attr: &Attribute) {
         check_deprecated_cfg_attr(cx, attr);
         check_mismatched_target_os(cx, attr);
     }
 }
 
+fn check_empty_line_after_outer_attr(cx: &EarlyContext<'_>, item: &rustc_ast::ast::Item) {
+    for attr in &item.attrs {
+        let attr_item = if let AttrKind::Normal(ref attr) = attr.kind {
+            attr
+        } else {
+            return;
+        };
+
+        if attr.style == AttrStyle::Outer {
+            if attr_item.args.inner_tokens().is_empty() || !is_present_in_source(cx, attr.span) {
+                return;
+            }
+
+            let begin_of_attr_to_item = Span::new(attr.span.lo(), item.span.lo(), item.span.ctxt());
+            let end_of_attr_to_item = Span::new(attr.span.hi(), item.span.lo(), item.span.ctxt());
+
+            if let Some(snippet) = snippet_opt(cx, end_of_attr_to_item) {
+                let lines = snippet.split('\n').collect::<Vec<_>>();
+                let lines = without_block_comments(lines);
+
+                if lines.iter().filter(|l| l.trim().is_empty()).count() > 2 {
+                    span_lint(
+                        cx,
+                        EMPTY_LINE_AFTER_OUTER_ATTR,
+                        begin_of_attr_to_item,
+                        "Found an empty line after an outer attribute. \
+                        Perhaps you forgot to add a `!` to make it an inner attribute?",
+                    );
+                }
+            }
+        }
+    }
+}
+
 fn check_deprecated_cfg_attr(cx: &EarlyContext<'_>, attr: &Attribute) {
     if_chain! {
         // check cfg_attr
diff --git a/tests/compile-test.rs b/tests/compile-test.rs
index a5de8429390..2758b9a7e76 100644
--- a/tests/compile-test.rs
+++ b/tests/compile-test.rs
@@ -38,7 +38,7 @@ fn clippy_driver_path() -> PathBuf {
 //        as what we manually pass to `cargo` invocation
 fn third_party_crates() -> String {
     use std::collections::HashMap;
-    static CRATES: &[&str] = &["serde", "serde_derive", "regex", "clippy_lints"];
+    static CRATES: &[&str] = &["serde", "serde_derive", "regex", "clippy_lints", "syn", "quote"];
     let dep_dir = cargo::TARGET_LIB.join("deps");
     let mut crates: HashMap<&str, PathBuf> = HashMap::with_capacity(CRATES.len());
     for entry in fs::read_dir(dep_dir).unwrap() {
diff --git a/tests/ui/auxiliary/proc_macro_attr.rs b/tests/ui/auxiliary/proc_macro_attr.rs
new file mode 100644
index 00000000000..e6626d57a77
--- /dev/null
+++ b/tests/ui/auxiliary/proc_macro_attr.rs
@@ -0,0 +1,37 @@
+// no-prefer-dynamic
+
+#![crate_type = "proc-macro"]
+#![feature(repr128, proc_macro_hygiene, proc_macro_quote)]
+#![allow(clippy::useless_conversion)]
+
+extern crate proc_macro;
+extern crate quote;
+extern crate syn;
+
+use proc_macro::TokenStream;
+use quote::{quote, quote_spanned};
+use syn::parse_macro_input;
+use syn::{parse_quote, ItemTrait, TraitItem};
+
+#[proc_macro_attribute]
+pub fn fake_async_trait(_args: TokenStream, input: TokenStream) -> TokenStream {
+    let mut item = parse_macro_input!(input as ItemTrait);
+    for inner in &mut item.items {
+        if let TraitItem::Method(method) = inner {
+            let sig = &method.sig;
+            let block = &mut method.default;
+            if let Some(block) = block {
+                let brace = block.brace_token;
+
+                let my_block = quote_spanned!( brace.span => {
+                    // Should not trigger `empty_line_after_outer_attr`
+                    #[crate_type = "lib"]
+                    #sig #block
+                    Vec::new()
+                });
+                *block = parse_quote!(#my_block);
+            }
+        }
+    }
+    TokenStream::from(quote!(#item))
+}
diff --git a/tests/ui/empty_line_after_outer_attribute.rs b/tests/ui/empty_line_after_outer_attribute.rs
index 5343dff9da1..3e92bca986a 100644
--- a/tests/ui/empty_line_after_outer_attribute.rs
+++ b/tests/ui/empty_line_after_outer_attribute.rs
@@ -1,8 +1,12 @@
+// aux-build:proc_macro_attr.rs
 #![warn(clippy::empty_line_after_outer_attr)]
 #![allow(clippy::assertions_on_constants)]
 #![feature(custom_inner_attributes)]
 #![rustfmt::skip]
 
+#[macro_use]
+extern crate proc_macro_attr;
+
 // This should produce a warning
 #[crate_type = "lib"]
 
@@ -93,4 +97,17 @@ pub struct S;
 /* test */
 pub struct T;
 
-fn main() { }
+// This should not produce a warning
+// See https://github.com/rust-lang/rust-clippy/issues/5567
+#[fake_async_trait]
+pub trait Bazz {
+    fn foo() -> Vec<u8> {
+        let _i = "";
+
+
+
+        vec![]
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/empty_line_after_outer_attribute.stderr b/tests/ui/empty_line_after_outer_attribute.stderr
index d8c9786541f..bf753a732f0 100644
--- a/tests/ui/empty_line_after_outer_attribute.stderr
+++ b/tests/ui/empty_line_after_outer_attribute.stderr
@@ -1,5 +1,5 @@
 error: Found an empty line after an outer attribute. Perhaps you forgot to add a `!` to make it an inner attribute?
-  --> $DIR/empty_line_after_outer_attribute.rs:7:1
+  --> $DIR/empty_line_after_outer_attribute.rs:11:1
    |
 LL | / #[crate_type = "lib"]
 LL | |
@@ -10,7 +10,7 @@ LL | | fn with_one_newline_and_comment() { assert!(true) }
    = note: `-D clippy::empty-line-after-outer-attr` implied by `-D warnings`
 
 error: Found an empty line after an outer attribute. Perhaps you forgot to add a `!` to make it an inner attribute?
-  --> $DIR/empty_line_after_outer_attribute.rs:19:1
+  --> $DIR/empty_line_after_outer_attribute.rs:23:1
    |
 LL | / #[crate_type = "lib"]
 LL | |
@@ -18,7 +18,7 @@ LL | | fn with_one_newline() { assert!(true) }
    | |_
 
 error: Found an empty line after an outer attribute. Perhaps you forgot to add a `!` to make it an inner attribute?
-  --> $DIR/empty_line_after_outer_attribute.rs:24:1
+  --> $DIR/empty_line_after_outer_attribute.rs:28:1
    |
 LL | / #[crate_type = "lib"]
 LL | |
@@ -27,7 +27,7 @@ LL | | fn with_two_newlines() { assert!(true) }
    | |_
 
 error: Found an empty line after an outer attribute. Perhaps you forgot to add a `!` to make it an inner attribute?
-  --> $DIR/empty_line_after_outer_attribute.rs:31:1
+  --> $DIR/empty_line_after_outer_attribute.rs:35:1
    |
 LL | / #[crate_type = "lib"]
 LL | |
@@ -35,7 +35,7 @@ LL | | enum Baz {
    | |_
 
 error: Found an empty line after an outer attribute. Perhaps you forgot to add a `!` to make it an inner attribute?
-  --> $DIR/empty_line_after_outer_attribute.rs:39:1
+  --> $DIR/empty_line_after_outer_attribute.rs:43:1
    |
 LL | / #[crate_type = "lib"]
 LL | |
@@ -43,7 +43,7 @@ LL | | struct Foo {
    | |_
 
 error: Found an empty line after an outer attribute. Perhaps you forgot to add a `!` to make it an inner attribute?
-  --> $DIR/empty_line_after_outer_attribute.rs:47:1
+  --> $DIR/empty_line_after_outer_attribute.rs:51:1
    |
 LL | / #[crate_type = "lib"]
 LL | |
-- 
cgit 1.4.1-3-g733a5


From 1801841ae554a7778666c4c1085393b32eccf74d Mon Sep 17 00:00:00 2001
From: ThibsG <Thibs@debian.com>
Date: Tue, 26 May 2020 18:40:42 +0200
Subject: Add test cases for broader coverage

---
 clippy_lints/src/useless_conversion.rs | 10 +++++-----
 tests/ui/useless_conversion.stderr     | 20 ++++++++++----------
 tests/ui/useless_conversion_try.rs     |  8 ++++++++
 tests/ui/useless_conversion_try.stderr | 32 ++++++++++++++++++++++++--------
 4 files changed, 47 insertions(+), 23 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/useless_conversion.rs b/clippy_lints/src/useless_conversion.rs
index 1645c5777b2..7fa97b24699 100644
--- a/clippy_lints/src/useless_conversion.rs
+++ b/clippy_lints/src/useless_conversion.rs
@@ -71,7 +71,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UselessConversion {
                             cx,
                             USELESS_CONVERSION,
                             e.span,
-                            "Useless conversion to the same type",
+                            "useless conversion to the same type",
                             "consider removing `.into()`",
                             sugg,
                             Applicability::MachineApplicable, // snippet
@@ -87,7 +87,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UselessConversion {
                             cx,
                             USELESS_CONVERSION,
                             e.span,
-                            "Useless conversion to the same type",
+                            "useless conversion to the same type",
                             "consider removing `.into_iter()`",
                             sugg,
                             Applicability::MachineApplicable, // snippet
@@ -108,7 +108,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UselessConversion {
                                 cx,
                                 USELESS_CONVERSION,
                                 e.span,
-                                "Useless conversion to the same type",
+                                "useless conversion to the same type",
                                 None,
                                 "consider removing `.try_into()`",
                             );
@@ -139,7 +139,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UselessConversion {
                                     cx,
                                     USELESS_CONVERSION,
                                     e.span,
-                                    "Useless conversion to the same type",
+                                    "useless conversion to the same type",
                                     None,
                                     &hint,
                                 );
@@ -158,7 +158,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UselessConversion {
                                     cx,
                                     USELESS_CONVERSION,
                                     e.span,
-                                    "Useless conversion to the same type",
+                                    "useless conversion to the same type",
                                     &sugg_msg,
                                     sugg,
                                     Applicability::MachineApplicable, // snippet
diff --git a/tests/ui/useless_conversion.stderr b/tests/ui/useless_conversion.stderr
index 0b2947f7d62..84ec5370278 100644
--- a/tests/ui/useless_conversion.stderr
+++ b/tests/ui/useless_conversion.stderr
@@ -1,4 +1,4 @@
-error: Useless conversion to the same type
+error: useless conversion to the same type
   --> $DIR/useless_conversion.rs:6:13
    |
 LL |     let _ = T::from(val);
@@ -10,55 +10,55 @@ note: the lint level is defined here
 LL | #![deny(clippy::useless_conversion)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: Useless conversion to the same type
+error: useless conversion to the same type
   --> $DIR/useless_conversion.rs:7:5
    |
 LL |     val.into()
    |     ^^^^^^^^^^ help: consider removing `.into()`: `val`
 
-error: Useless conversion to the same type
+error: useless conversion to the same type
   --> $DIR/useless_conversion.rs:19:22
    |
 LL |         let _: i32 = 0i32.into();
    |                      ^^^^^^^^^^^ help: consider removing `.into()`: `0i32`
 
-error: Useless conversion to the same type
+error: useless conversion to the same type
   --> $DIR/useless_conversion.rs:51:21
    |
 LL |     let _: String = "foo".to_string().into();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into()`: `"foo".to_string()`
 
-error: Useless conversion to the same type
+error: useless conversion to the same type
   --> $DIR/useless_conversion.rs:52:21
    |
 LL |     let _: String = From::from("foo".to_string());
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `From::from()`: `"foo".to_string()`
 
-error: Useless conversion to the same type
+error: useless conversion to the same type
   --> $DIR/useless_conversion.rs:53:13
    |
 LL |     let _ = String::from("foo".to_string());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `String::from()`: `"foo".to_string()`
 
-error: Useless conversion to the same type
+error: useless conversion to the same type
   --> $DIR/useless_conversion.rs:54:13
    |
 LL |     let _ = String::from(format!("A: {:04}", 123));
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `String::from()`: `format!("A: {:04}", 123)`
 
-error: Useless conversion to the same type
+error: useless conversion to the same type
   --> $DIR/useless_conversion.rs:55:13
    |
 LL |     let _ = "".lines().into_iter();
    |             ^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `"".lines()`
 
-error: Useless conversion to the same type
+error: useless conversion to the same type
   --> $DIR/useless_conversion.rs:56:13
    |
 LL |     let _ = vec![1, 2, 3].into_iter().into_iter();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `vec![1, 2, 3].into_iter()`
 
-error: Useless conversion to the same type
+error: useless conversion to the same type
   --> $DIR/useless_conversion.rs:57:21
    |
 LL |     let _: String = format!("Hello {}", "world").into();
diff --git a/tests/ui/useless_conversion_try.rs b/tests/ui/useless_conversion_try.rs
index ab4f960edb7..3787ea99144 100644
--- a/tests/ui/useless_conversion_try.rs
+++ b/tests/ui/useless_conversion_try.rs
@@ -31,4 +31,12 @@ fn main() {
     let _ = String::try_from("foo".to_string()).unwrap();
     let _ = String::try_from(format!("A: {:04}", 123)).unwrap();
     let _: String = format!("Hello {}", "world").try_into().unwrap();
+    let _: String = "".to_owned().try_into().unwrap();
+    let _: String = match String::from("_").try_into() {
+        Ok(a) => a,
+        Err(_) => "".into(),
+    };
+    // FIXME this is a false negative
+    #[allow(clippy::cmp_owned)]
+    if String::from("a") == TryInto::<String>::try_into(String::from("a")).unwrap() {}
 }
diff --git a/tests/ui/useless_conversion_try.stderr b/tests/ui/useless_conversion_try.stderr
index 5afb5dc45d3..b765727c168 100644
--- a/tests/ui/useless_conversion_try.stderr
+++ b/tests/ui/useless_conversion_try.stderr
@@ -1,4 +1,4 @@
-error: Useless conversion to the same type
+error: useless conversion to the same type
   --> $DIR/useless_conversion_try.rs:6:13
    |
 LL |     let _ = T::try_from(val).unwrap();
@@ -11,7 +11,7 @@ LL | #![deny(clippy::useless_conversion)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
    = help: consider removing `T::try_from()`
 
-error: Useless conversion to the same type
+error: useless conversion to the same type
   --> $DIR/useless_conversion_try.rs:7:5
    |
 LL |     val.try_into().unwrap()
@@ -19,7 +19,7 @@ LL |     val.try_into().unwrap()
    |
    = help: consider removing `.try_into()`
 
-error: Useless conversion to the same type
+error: useless conversion to the same type
   --> $DIR/useless_conversion_try.rs:29:21
    |
 LL |     let _: String = "foo".to_string().try_into().unwrap();
@@ -27,7 +27,7 @@ LL |     let _: String = "foo".to_string().try_into().unwrap();
    |
    = help: consider removing `.try_into()`
 
-error: Useless conversion to the same type
+error: useless conversion to the same type
   --> $DIR/useless_conversion_try.rs:30:21
    |
 LL |     let _: String = TryFrom::try_from("foo".to_string()).unwrap();
@@ -35,7 +35,7 @@ LL |     let _: String = TryFrom::try_from("foo".to_string()).unwrap();
    |
    = help: consider removing `TryFrom::try_from()`
 
-error: Useless conversion to the same type
+error: useless conversion to the same type
   --> $DIR/useless_conversion_try.rs:31:13
    |
 LL |     let _ = String::try_from("foo".to_string()).unwrap();
@@ -43,7 +43,7 @@ LL |     let _ = String::try_from("foo".to_string()).unwrap();
    |
    = help: consider removing `String::try_from()`
 
-error: Useless conversion to the same type
+error: useless conversion to the same type
   --> $DIR/useless_conversion_try.rs:32:13
    |
 LL |     let _ = String::try_from(format!("A: {:04}", 123)).unwrap();
@@ -51,7 +51,7 @@ LL |     let _ = String::try_from(format!("A: {:04}", 123)).unwrap();
    |
    = help: consider removing `String::try_from()`
 
-error: Useless conversion to the same type
+error: useless conversion to the same type
   --> $DIR/useless_conversion_try.rs:33:21
    |
 LL |     let _: String = format!("Hello {}", "world").try_into().unwrap();
@@ -59,5 +59,21 @@ LL |     let _: String = format!("Hello {}", "world").try_into().unwrap();
    |
    = help: consider removing `.try_into()`
 
-error: aborting due to 7 previous errors
+error: useless conversion to the same type
+  --> $DIR/useless_conversion_try.rs:34:21
+   |
+LL |     let _: String = "".to_owned().try_into().unwrap();
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider removing `.try_into()`
+
+error: useless conversion to the same type
+  --> $DIR/useless_conversion_try.rs:35:27
+   |
+LL |     let _: String = match String::from("_").try_into() {
+   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider removing `.try_into()`
+
+error: aborting due to 9 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 7fd3bd0f57e11a65641501d6a898328ecb83ca77 Mon Sep 17 00:00:00 2001
From: flip1995 <hello@philkrones.com>
Date: Fri, 24 Apr 2020 00:14:03 +0200
Subject: Register redundant_field_names and non_expressive_names as early
 passes

---
 clippy_lints/src/lib.rs | 12 ++++++------
 src/driver.rs           |  2 +-
 2 files changed, 7 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 057d39d4c82..902f3d56c1e 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -346,13 +346,8 @@ mod reexport {
 /// level (i.e `#![cfg_attr(...)]`) will still be expanded even when using a pre-expansion pass.
 ///
 /// Used in `./src/driver.rs`.
-pub fn register_pre_expansion_lints(store: &mut rustc_lint::LintStore, conf: &Conf) {
+pub fn register_pre_expansion_lints(store: &mut rustc_lint::LintStore) {
     store.register_pre_expansion_pass(|| box write::Write::default());
-    store.register_pre_expansion_pass(|| box redundant_field_names::RedundantFieldNames);
-    let single_char_binding_names_threshold = conf.single_char_binding_names_threshold;
-    store.register_pre_expansion_pass(move || box non_expressive_names::NonExpressiveNames {
-        single_char_binding_names_threshold,
-    });
     store.register_pre_expansion_pass(|| box attrs::EarlyAttributes);
     store.register_pre_expansion_pass(|| box dbg_macro::DbgMacro);
 }
@@ -1066,6 +1061,11 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box match_on_vec_items::MatchOnVecItems);
     store.register_early_pass(|| box manual_non_exhaustive::ManualNonExhaustive);
     store.register_late_pass(|| box manual_async_fn::ManualAsyncFn);
+    store.register_early_pass(|| box redundant_field_names::RedundantFieldNames);
+    let single_char_binding_names_threshold = conf.single_char_binding_names_threshold;
+    store.register_early_pass(move || box non_expressive_names::NonExpressiveNames {
+        single_char_binding_names_threshold,
+    });
 
     store.register_group(true, "clippy::restriction", Some("clippy_restriction"), vec![
         LintId::of(&arithmetic::FLOAT_ARITHMETIC),
diff --git a/src/driver.rs b/src/driver.rs
index d3a7e24937f..70c47b42682 100644
--- a/src/driver.rs
+++ b/src/driver.rs
@@ -79,7 +79,7 @@ impl rustc_driver::Callbacks for ClippyCallbacks {
 
             let conf = clippy_lints::read_conf(&[], &sess);
             clippy_lints::register_plugins(&mut lint_store, &sess, &conf);
-            clippy_lints::register_pre_expansion_lints(&mut lint_store, &conf);
+            clippy_lints::register_pre_expansion_lints(&mut lint_store);
             clippy_lints::register_renamed(&mut lint_store);
         }));
 
-- 
cgit 1.4.1-3-g733a5


From 8e22d15055231fc0df4a07d57cd883fd89d8131b Mon Sep 17 00:00:00 2001
From: flip1995 <hello@philkrones.com>
Date: Tue, 12 May 2020 16:26:55 +0200
Subject: Fix fallout in redundant_field_names

---
 clippy_lints/src/redundant_field_names.rs | 4 ++++
 1 file changed, 4 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/redundant_field_names.rs b/clippy_lints/src/redundant_field_names.rs
index b12c3c344ef..2a81170e49e 100644
--- a/clippy_lints/src/redundant_field_names.rs
+++ b/clippy_lints/src/redundant_field_names.rs
@@ -2,6 +2,7 @@ use crate::utils::span_lint_and_sugg;
 use rustc_ast::ast::{Expr, ExprKind};
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass};
+use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
@@ -36,6 +37,9 @@ declare_lint_pass!(RedundantFieldNames => [REDUNDANT_FIELD_NAMES]);
 
 impl EarlyLintPass for RedundantFieldNames {
     fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
+        if in_external_macro(cx.sess, expr.span) {
+            return;
+        }
         if let ExprKind::Struct(_, ref fields, _) = expr.kind {
             for field in fields {
                 if field.is_shorthand {
-- 
cgit 1.4.1-3-g733a5


From 04db13eb564f6e3264a0d376ef95365b1de44797 Mon Sep 17 00:00:00 2001
From: flip1995 <hello@philkrones.com>
Date: Tue, 12 May 2020 16:50:00 +0200
Subject: Fix fallout in similar_names

---
 clippy_lints/src/non_expressive_names.rs | 9 +++++++++
 1 file changed, 9 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/non_expressive_names.rs b/clippy_lints/src/non_expressive_names.rs
index 2b51b732075..5328773a738 100644
--- a/clippy_lints/src/non_expressive_names.rs
+++ b/clippy_lints/src/non_expressive_names.rs
@@ -5,6 +5,7 @@ use rustc_ast::ast::{
 use rustc_ast::attr;
 use rustc_ast::visit::{walk_block, walk_expr, walk_pat, Visitor};
 use rustc_lint::{EarlyContext, EarlyLintPass};
+use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::Span;
 use rustc_span::symbol::{Ident, SymbolStr};
@@ -354,12 +355,20 @@ impl<'a, 'tcx> Visitor<'tcx> for SimilarNamesLocalVisitor<'a, 'tcx> {
 
 impl EarlyLintPass for NonExpressiveNames {
     fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {
+        if in_external_macro(cx.sess, item.span) {
+            return;
+        }
+
         if let ItemKind::Fn(_, ref sig, _, Some(ref blk)) = item.kind {
             do_check(self, cx, &item.attrs, &sig.decl, blk);
         }
     }
 
     fn check_impl_item(&mut self, cx: &EarlyContext<'_>, item: &AssocItem) {
+        if in_external_macro(cx.sess, item.span) {
+            return;
+        }
+
         if let AssocItemKind::Fn(_, ref sig, _, Some(ref blk)) = item.kind {
             do_check(self, cx, &item.attrs, &sig.decl, blk);
         }
-- 
cgit 1.4.1-3-g733a5


From 416182347589e9503408136747593ff95fb9dd13 Mon Sep 17 00:00:00 2001
From: Eduardo Broto <ebroto@tutanota.com>
Date: Wed, 27 May 2020 00:06:50 +0200
Subject: Avoid triggering similar names on code from expansion

---
 clippy_lints/src/new_without_default.rs  | 10 +++++-----
 clippy_lints/src/non_expressive_names.rs |  6 +++++-
 2 files changed, 10 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/new_without_default.rs b/clippy_lints/src/new_without_default.rs
index 3b88e4c4cb1..e556e5d59c1 100644
--- a/clippy_lints/src/new_without_default.rs
+++ b/clippy_lints/src/new_without_default.rs
@@ -90,8 +90,8 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NewWithoutDefault {
                             return;
                         }
                         if sig.decl.inputs.is_empty() && name == sym!(new) && cx.access_levels.is_reachable(id) {
-                            let self_did = cx.tcx.hir().local_def_id(cx.tcx.hir().get_parent_item(id));
-                            let self_ty = cx.tcx.type_of(self_did);
+                            let self_def_id = cx.tcx.hir().local_def_id(cx.tcx.hir().get_parent_item(id));
+                            let self_ty = cx.tcx.type_of(self_def_id);
                             if_chain! {
                                 if same_tys(cx, self_ty, return_ty(cx, id));
                                 if let Some(default_trait_id) = get_trait_def_id(cx, &paths::DEFAULT_TRAIT);
@@ -112,10 +112,10 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NewWithoutDefault {
                                     // generics
                                     if_chain! {
                                         if let Some(ref impling_types) = self.impling_types;
-                                        if let Some(self_def) = cx.tcx.type_of(self_did).ty_adt_def();
-                                        if let Some(self_def_id) = self_def.did.as_local();
+                                        if let Some(self_def) = cx.tcx.type_of(self_def_id).ty_adt_def();
+                                        if let Some(self_local_did) = self_def.did.as_local();
                                         then {
-                                            let self_id = cx.tcx.hir().local_def_id_to_hir_id(self_def_id);
+                                            let self_id = cx.tcx.hir().local_def_id_to_hir_id(self_local_did);
                                             if impling_types.contains(&self_id) {
                                                 return;
                                             }
diff --git a/clippy_lints/src/non_expressive_names.rs b/clippy_lints/src/non_expressive_names.rs
index 5328773a738..5f14fe97afe 100644
--- a/clippy_lints/src/non_expressive_names.rs
+++ b/clippy_lints/src/non_expressive_names.rs
@@ -132,7 +132,11 @@ struct SimilarNamesNameVisitor<'a, 'tcx, 'b>(&'b mut SimilarNamesLocalVisitor<'a
 impl<'a, 'tcx, 'b> Visitor<'tcx> for SimilarNamesNameVisitor<'a, 'tcx, 'b> {
     fn visit_pat(&mut self, pat: &'tcx Pat) {
         match pat.kind {
-            PatKind::Ident(_, ident, _) => self.check_ident(ident),
+            PatKind::Ident(_, ident, _) => {
+                if !pat.span.from_expansion() {
+                    self.check_ident(ident);
+                }
+            },
             PatKind::Struct(_, ref fields, _) => {
                 for field in fields {
                     if !field.is_shorthand {
-- 
cgit 1.4.1-3-g733a5


From 64a05f56c33d4754808ef85e634f72a9053c56fd Mon Sep 17 00:00:00 2001
From: Eduardo Broto <ebroto@tutanota.com>
Date: Thu, 28 May 2020 00:36:15 +0200
Subject: len_zero: skip ranges if feature `range_is_empty` is not enabled

---
 clippy_lints/src/len_zero.rs    | 17 ++++++++++++++++-
 tests/ui/len_zero.fixed         |  8 ++++++++
 tests/ui/len_zero.rs            |  8 ++++++++
 tests/ui/len_zero_ranges.fixed  | 14 ++++++++++++++
 tests/ui/len_zero_ranges.rs     | 14 ++++++++++++++
 tests/ui/len_zero_ranges.stderr | 10 ++++++++++
 6 files changed, 70 insertions(+), 1 deletion(-)
 create mode 100644 tests/ui/len_zero_ranges.fixed
 create mode 100644 tests/ui/len_zero_ranges.rs
 create mode 100644 tests/ui/len_zero_ranges.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/len_zero.rs b/clippy_lints/src/len_zero.rs
index 2ec0b5a8d6f..f5bfede75a7 100644
--- a/clippy_lints/src/len_zero.rs
+++ b/clippy_lints/src/len_zero.rs
@@ -1,4 +1,4 @@
-use crate::utils::{get_item_name, snippet_with_applicability, span_lint, span_lint_and_sugg, walk_ptrs_ty};
+use crate::utils::{get_item_name, higher, snippet_with_applicability, span_lint, span_lint_and_sugg, walk_ptrs_ty};
 use rustc_ast::ast::LitKind;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Applicability;
@@ -259,6 +259,17 @@ fn check_len(
 
 /// Checks if this type has an `is_empty` method.
 fn has_is_empty(cx: &LateContext<'_, '_>, expr: &Expr<'_>) -> bool {
+    /// Special case ranges until `range_is_empty` is stabilized. See issue 3807.
+    fn should_skip_range(cx: &LateContext<'_, '_>, expr: &Expr<'_>) -> bool {
+        higher::range(cx, expr).map_or(false, |_| {
+            !cx.tcx
+                .features()
+                .declared_lib_features
+                .iter()
+                .any(|(name, _)| name.as_str() == "range_is_empty")
+        })
+    }
+
     /// Gets an `AssocItem` and return true if it matches `is_empty(self)`.
     fn is_is_empty(cx: &LateContext<'_, '_>, item: &ty::AssocItem) -> bool {
         if let ty::AssocKind::Fn = item.kind {
@@ -284,6 +295,10 @@ fn has_is_empty(cx: &LateContext<'_, '_>, expr: &Expr<'_>) -> bool {
         })
     }
 
+    if should_skip_range(cx, expr) {
+        return false;
+    }
+
     let ty = &walk_ptrs_ty(cx.tables.expr_ty(expr));
     match ty.kind {
         ty::Dynamic(ref tt, ..) => {
diff --git a/tests/ui/len_zero.fixed b/tests/ui/len_zero.fixed
index 624e5ef8fcf..a29b832eb60 100644
--- a/tests/ui/len_zero.fixed
+++ b/tests/ui/len_zero.fixed
@@ -141,3 +141,11 @@ fn main() {
 fn test_slice(b: &[u8]) {
     if !b.is_empty() {}
 }
+
+mod issue_3807 {
+    // Avoid suggesting changes to ranges if the user did not enable `range_is_empty`.
+    // See https://github.com/rust-lang/rust/issues/48111#issuecomment-445132965
+    fn no_suggestion() {
+        let _ = (0..42).len() == 0;
+    }
+}
diff --git a/tests/ui/len_zero.rs b/tests/ui/len_zero.rs
index 7fba971cfd8..8fd0093f4fd 100644
--- a/tests/ui/len_zero.rs
+++ b/tests/ui/len_zero.rs
@@ -141,3 +141,11 @@ fn main() {
 fn test_slice(b: &[u8]) {
     if b.len() != 0 {}
 }
+
+mod issue_3807 {
+    // Avoid suggesting changes to ranges if the user did not enable `range_is_empty`.
+    // See https://github.com/rust-lang/rust/issues/48111#issuecomment-445132965
+    fn no_suggestion() {
+        let _ = (0..42).len() == 0;
+    }
+}
diff --git a/tests/ui/len_zero_ranges.fixed b/tests/ui/len_zero_ranges.fixed
new file mode 100644
index 00000000000..7da26f8ff4d
--- /dev/null
+++ b/tests/ui/len_zero_ranges.fixed
@@ -0,0 +1,14 @@
+// run-rustfix
+
+#![feature(range_is_empty)]
+#![warn(clippy::len_zero)]
+#![allow(unused)]
+
+mod issue_3807 {
+    // With the feature enabled, `is_empty` should be suggested
+    fn suggestion_is_fine() {
+        let _ = (0..42).is_empty();
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/len_zero_ranges.rs b/tests/ui/len_zero_ranges.rs
new file mode 100644
index 00000000000..be7b4244bc0
--- /dev/null
+++ b/tests/ui/len_zero_ranges.rs
@@ -0,0 +1,14 @@
+// run-rustfix
+
+#![feature(range_is_empty)]
+#![warn(clippy::len_zero)]
+#![allow(unused)]
+
+mod issue_3807 {
+    // With the feature enabled, `is_empty` should be suggested
+    fn suggestion_is_fine() {
+        let _ = (0..42).len() == 0;
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/len_zero_ranges.stderr b/tests/ui/len_zero_ranges.stderr
new file mode 100644
index 00000000000..6e5fa41fb08
--- /dev/null
+++ b/tests/ui/len_zero_ranges.stderr
@@ -0,0 +1,10 @@
+error: length comparison to zero
+  --> $DIR/len_zero_ranges.rs:10:17
+   |
+LL |         let _ = (0..42).len() == 0;
+   |                 ^^^^^^^^^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `(0..42).is_empty()`
+   |
+   = note: `-D clippy::len-zero` implied by `-D warnings`
+
+error: aborting due to previous error
+
-- 
cgit 1.4.1-3-g733a5


From 5faab874f9f8655c8f284944b5acdede5c088af4 Mon Sep 17 00:00:00 2001
From: Tim Nielens <tim.nielens@gmail.com>
Date: Sat, 23 May 2020 00:07:09 +0200
Subject: new lint: vec_resize_to_zero

---
 CHANGELOG.md                           |  1 +
 clippy_lints/src/lib.rs                |  5 +++
 clippy_lints/src/utils/paths.rs        |  1 +
 clippy_lints/src/vec_resize_to_zero.rs | 59 ++++++++++++++++++++++++++++++++++
 src/lintlist/mod.rs                    |  7 ++++
 tests/ui/vec_resize_to_zero.rs         | 15 +++++++++
 tests/ui/vec_resize_to_zero.stderr     | 13 ++++++++
 7 files changed, 101 insertions(+)
 create mode 100644 clippy_lints/src/vec_resize_to_zero.rs
 create mode 100644 tests/ui/vec_resize_to_zero.rs
 create mode 100644 tests/ui/vec_resize_to_zero.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 2ac9057199f..f7dae3dcfff 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1630,6 +1630,7 @@ Released 2018-09-13
 [`useless_transmute`]: https://rust-lang.github.io/rust-clippy/master/index.html#useless_transmute
 [`useless_vec`]: https://rust-lang.github.io/rust-clippy/master/index.html#useless_vec
 [`vec_box`]: https://rust-lang.github.io/rust-clippy/master/index.html#vec_box
+[`vec_resize_to_zero`]: https://rust-lang.github.io/rust-clippy/master/index.html#vec_resize_to_zero
 [`verbose_bit_mask`]: https://rust-lang.github.io/rust-clippy/master/index.html#verbose_bit_mask
 [`verbose_file_reads`]: https://rust-lang.github.io/rust-clippy/master/index.html#verbose_file_reads
 [`vtable_address_comparisons`]: https://rust-lang.github.io/rust-clippy/master/index.html#vtable_address_comparisons
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 902f3d56c1e..4f0ecab393d 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -325,6 +325,7 @@ mod unwrap;
 mod use_self;
 mod useless_conversion;
 mod vec;
+mod vec_resize_to_zero;
 mod verbose_file_reads;
 mod wildcard_dependencies;
 mod wildcard_imports;
@@ -847,6 +848,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &utils::internal_lints::OUTER_EXPN_EXPN_DATA,
         &utils::internal_lints::PRODUCE_ICE,
         &vec::USELESS_VEC,
+        &vec_resize_to_zero::VEC_RESIZE_TO_ZERO,
         &verbose_file_reads::VERBOSE_FILE_READS,
         &wildcard_dependencies::WILDCARD_DEPENDENCIES,
         &wildcard_imports::ENUM_GLOB_USE,
@@ -1062,6 +1064,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_early_pass(|| box manual_non_exhaustive::ManualNonExhaustive);
     store.register_late_pass(|| box manual_async_fn::ManualAsyncFn);
     store.register_early_pass(|| box redundant_field_names::RedundantFieldNames);
+    store.register_late_pass(|| box vec_resize_to_zero::VecResizeToZero);
     let single_char_binding_names_threshold = conf.single_char_binding_names_threshold;
     store.register_early_pass(move || box non_expressive_names::NonExpressiveNames {
         single_char_binding_names_threshold,
@@ -1430,6 +1433,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&unwrap::UNNECESSARY_UNWRAP),
         LintId::of(&useless_conversion::USELESS_CONVERSION),
         LintId::of(&vec::USELESS_VEC),
+        LintId::of(&vec_resize_to_zero::VEC_RESIZE_TO_ZERO),
         LintId::of(&write::PRINTLN_EMPTY_STRING),
         LintId::of(&write::PRINT_LITERAL),
         LintId::of(&write::PRINT_WITH_NEWLINE),
@@ -1677,6 +1681,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&unnamed_address::VTABLE_ADDRESS_COMPARISONS),
         LintId::of(&unused_io_amount::UNUSED_IO_AMOUNT),
         LintId::of(&unwrap::PANICKING_UNWRAP),
+        LintId::of(&vec_resize_to_zero::VEC_RESIZE_TO_ZERO),
     ]);
 
     store.register_group(true, "clippy::perf", Some("clippy_perf"), vec![
diff --git a/clippy_lints/src/utils/paths.rs b/clippy_lints/src/utils/paths.rs
index 779da7e6bf2..3b7e9739211 100644
--- a/clippy_lints/src/utils/paths.rs
+++ b/clippy_lints/src/utils/paths.rs
@@ -138,5 +138,6 @@ pub const VEC_AS_SLICE: [&str; 4] = ["alloc", "vec", "Vec", "as_slice"];
 pub const VEC_DEQUE: [&str; 4] = ["alloc", "collections", "vec_deque", "VecDeque"];
 pub const VEC_FROM_ELEM: [&str; 3] = ["alloc", "vec", "from_elem"];
 pub const VEC_NEW: [&str; 4] = ["alloc", "vec", "Vec", "new"];
+pub const VEC_RESIZE: [&str; 4] = ["alloc", "vec", "Vec", "resize"];
 pub const WEAK_ARC: [&str; 3] = ["alloc", "sync", "Weak"];
 pub const WEAK_RC: [&str; 3] = ["alloc", "rc", "Weak"];
diff --git a/clippy_lints/src/vec_resize_to_zero.rs b/clippy_lints/src/vec_resize_to_zero.rs
new file mode 100644
index 00000000000..86cbfa8203d
--- /dev/null
+++ b/clippy_lints/src/vec_resize_to_zero.rs
@@ -0,0 +1,59 @@
+use crate::utils::span_lint_and_then;
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::source_map::Spanned;
+
+use crate::utils::{match_def_path, paths};
+use rustc_ast::ast::LitKind;
+use rustc_hir as hir;
+
+declare_clippy_lint! {
+    /// **What it does:** Finds occurences of `Vec::resize(0, an_int)`
+    ///
+    /// **Why is this bad?** This is probably an argument inversion mistake.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// ```rust
+    /// vec!(1, 2, 3, 4, 5).resize(0, 5)
+    /// ```
+    pub VEC_RESIZE_TO_ZERO,
+    correctness,
+    "emptying a vector with `resize(0, an_int)` instead of `clear()` is probably an argument inversion mistake"
+}
+
+declare_lint_pass!(VecResizeToZero => [VEC_RESIZE_TO_ZERO]);
+
+impl<'a, 'tcx> LateLintPass<'a, 'tcx> for VecResizeToZero {
+    fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr<'_>) {
+        if_chain! {
+            if let hir::ExprKind::MethodCall(path_segment, _, ref args) = expr.kind;
+            if let Some(method_def_id) = cx.tables.type_dependent_def_id(expr.hir_id);
+            if match_def_path(cx, method_def_id, &paths::VEC_RESIZE) && args.len() == 3;
+            if let ExprKind::Lit(Spanned { node: LitKind::Int(0, _), .. }) = args[1].kind;
+            if let ExprKind::Lit(Spanned { node: LitKind::Int(..), .. }) = args[2].kind;
+            then {
+                let method_call_span = expr.span.with_lo(path_segment.ident.span.lo());
+                span_lint_and_then(
+                    cx,
+                    VEC_RESIZE_TO_ZERO,
+                    expr.span,
+                    "emptying a vector with `resize`",
+                    |db| {
+                        db.help("the arguments may be inverted...");
+                        db.span_suggestion(
+                            method_call_span,
+                            "...or you can empty the vector with",
+                            "clear()".to_string(),
+                            Applicability::MaybeIncorrect,
+                        );
+                    },
+                );
+            }
+        }
+    }
+}
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index f63301c7db0..1e94ca00c14 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -2460,6 +2460,13 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
         deprecation: None,
         module: "types",
     },
+    Lint {
+        name: "vec_resize_to_zero",
+        group: "correctness",
+        desc: "emptying a vector with `resize(0, an_int)` instead of `clear()` is probably an argument inversion mistake",
+        deprecation: None,
+        module: "vec_resize_to_zero",
+    },
     Lint {
         name: "verbose_bit_mask",
         group: "style",
diff --git a/tests/ui/vec_resize_to_zero.rs b/tests/ui/vec_resize_to_zero.rs
new file mode 100644
index 00000000000..0263e2f5f20
--- /dev/null
+++ b/tests/ui/vec_resize_to_zero.rs
@@ -0,0 +1,15 @@
+#![warn(clippy::vec_resize_to_zero)]
+
+fn main() {
+    // applicable here
+    vec![1, 2, 3, 4, 5].resize(0, 5);
+
+    // not applicable
+    vec![1, 2, 3, 4, 5].resize(2, 5);
+
+    // applicable here, but only implemented for integer litterals for now
+    vec!["foo", "bar", "baz"].resize(0, "bar");
+
+    // not applicable
+    vec!["foo", "bar", "baz"].resize(2, "bar")
+}
diff --git a/tests/ui/vec_resize_to_zero.stderr b/tests/ui/vec_resize_to_zero.stderr
new file mode 100644
index 00000000000..feb846298c6
--- /dev/null
+++ b/tests/ui/vec_resize_to_zero.stderr
@@ -0,0 +1,13 @@
+error: emptying a vector with `resize`
+  --> $DIR/vec_resize_to_zero.rs:5:5
+   |
+LL |     vec![1, 2, 3, 4, 5].resize(0, 5);
+   |     ^^^^^^^^^^^^^^^^^^^^------------
+   |                         |
+   |                         help: ...or you can empty the vector with: `clear()`
+   |
+   = note: `-D clippy::vec-resize-to-zero` implied by `-D warnings`
+   = help: the arguments may be inverted...
+
+error: aborting due to previous error
+
-- 
cgit 1.4.1-3-g733a5


From 37381d33a4761a064311dd95fbc54b5da6ad3766 Mon Sep 17 00:00:00 2001
From: flip1995 <hello@philkrones.com>
Date: Sun, 31 May 2020 14:05:57 +0200
Subject: Fix sync fallout

---
 clippy_lints/src/needless_pass_by_value.rs |  8 +-------
 clippy_lints/src/write.rs                  | 13 ++++++-------
 tests/compile-test.rs                      |  7 ++++---
 3 files changed, 11 insertions(+), 17 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/needless_pass_by_value.rs b/clippy_lints/src/needless_pass_by_value.rs
index 218b0d27f74..9c508fc0e4a 100644
--- a/clippy_lints/src/needless_pass_by_value.rs
+++ b/clippy_lints/src/needless_pass_by_value.rs
@@ -173,13 +173,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NeedlessPassByValue {
                     !preds.is_empty() && {
                         let ty_empty_region = cx.tcx.mk_imm_ref(cx.tcx.lifetimes.re_root_empty, ty);
                         preds.iter().all(|t| {
-                            let ty_params = &t
-                                .skip_binder()
-                                .trait_ref
-                                .substs
-                                .iter()
-                                .skip(1)
-                                .collect::<Vec<_>>();
+                            let ty_params = &t.skip_binder().trait_ref.substs.iter().skip(1).collect::<Vec<_>>();
                             implements_trait(cx, ty_empty_region, t.def_id(), ty_params)
                         })
                     },
diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs
index dfa6223f1b9..5f794598052 100644
--- a/clippy_lints/src/write.rs
+++ b/clippy_lints/src/write.rs
@@ -279,13 +279,12 @@ impl EarlyLintPass for Write {
             if let (Some(fmt_str), expr) = self.check_tts(cx, &mac.args.inner_tokens(), true) {
                 if fmt_str.symbol == Symbol::intern("") {
                     let mut applicability = Applicability::MachineApplicable;
-                    let suggestion = expr.map_or_else(
-                        move || {
-                            applicability = Applicability::HasPlaceholders;
-                            Cow::Borrowed("v")
-                        },
-                        move |expr| snippet_with_applicability(cx, expr.span, "v", &mut applicability),
-                    );
+                    let suggestion = if let Some(e) = expr {
+                        snippet_with_applicability(cx, e.span, "v", &mut applicability)
+                    } else {
+                        applicability = Applicability::HasPlaceholders;
+                        Cow::Borrowed("v")
+                    };
 
                     span_lint_and_sugg(
                         cx,
diff --git a/tests/compile-test.rs b/tests/compile-test.rs
index 1c4914a470c..7bd5f09f333 100644
--- a/tests/compile-test.rs
+++ b/tests/compile-test.rs
@@ -153,9 +153,6 @@ fn run_ui_toml(config: &mut compiletest::Config) {
 }
 
 fn run_ui_cargo(config: &mut compiletest::Config) {
-    if cargo::is_rustc_test_suite() {
-        return;
-    }
     fn run_tests(
         config: &compiletest::Config,
         filter: &Option<String>,
@@ -216,6 +213,10 @@ fn run_ui_cargo(config: &mut compiletest::Config) {
         Ok(result)
     }
 
+    if cargo::is_rustc_test_suite() {
+        return;
+    }
+
     config.mode = TestMode::Ui;
     config.src_base = Path::new("tests").join("ui-cargo").canonicalize().unwrap();
 
-- 
cgit 1.4.1-3-g733a5


From 0bcfae92f80d31cad4e5fb687da8033a38d06a32 Mon Sep 17 00:00:00 2001
From: djugei <ddjugei@gmail.com>
Date: Sun, 31 May 2020 15:41:33 +0200
Subject: moved cast_ptr_alignment to pedantic and expanded documentation

---
 clippy_lints/src/types.rs | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs
index 6ed9ff22e46..3ac99e24684 100644
--- a/clippy_lints/src/types.rs
+++ b/clippy_lints/src/types.rs
@@ -974,7 +974,8 @@ declare_clippy_lint! {
     /// behavior.
     ///
     /// **Known problems:** Using `std::ptr::read_unaligned` and `std::ptr::write_unaligned` or similar
-    /// on the resulting pointer is fine.
+    /// on the resulting pointer is fine. Is over-zealous: Casts with manual alignment checks or casts like
+    /// u64-> u8 -> u16 can be fine. Miri is able to do a more in-depth analysis.
     ///
     /// **Example:**
     /// ```rust
@@ -982,7 +983,7 @@ declare_clippy_lint! {
     /// let _ = (&mut 1u8 as *mut u8) as *mut u16;
     /// ```
     pub CAST_PTR_ALIGNMENT,
-    correctness,
+    pedantic,
     "cast from a pointer to a more-strictly-aligned pointer"
 }
 
-- 
cgit 1.4.1-3-g733a5


From 18b5ceed7991e3d8616b74b42de26330ca4c40db Mon Sep 17 00:00:00 2001
From: djugei <ddjugei@gmail.com>
Date: Sun, 31 May 2020 16:00:29 +0200
Subject: ran update_lints

---
 clippy_lints/src/lib.rs | 3 +--
 src/lintlist/mod.rs     | 2 +-
 2 files changed, 2 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 902f3d56c1e..6475fa67d25 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1164,6 +1164,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&types::CAST_POSSIBLE_TRUNCATION),
         LintId::of(&types::CAST_POSSIBLE_WRAP),
         LintId::of(&types::CAST_PRECISION_LOSS),
+        LintId::of(&types::CAST_PTR_ALIGNMENT),
         LintId::of(&types::CAST_SIGN_LOSS),
         LintId::of(&types::IMPLICIT_HASHER),
         LintId::of(&types::INVALID_UPCAST_COMPARISONS),
@@ -1410,7 +1411,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&types::ABSURD_EXTREME_COMPARISONS),
         LintId::of(&types::BORROWED_BOX),
         LintId::of(&types::BOX_VEC),
-        LintId::of(&types::CAST_PTR_ALIGNMENT),
         LintId::of(&types::CAST_REF_TO_MUT),
         LintId::of(&types::CHAR_LIT_AS_U8),
         LintId::of(&types::FN_TO_NUMERIC_CAST),
@@ -1669,7 +1669,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&transmute::WRONG_TRANSMUTE),
         LintId::of(&transmuting_null::TRANSMUTING_NULL),
         LintId::of(&types::ABSURD_EXTREME_COMPARISONS),
-        LintId::of(&types::CAST_PTR_ALIGNMENT),
         LintId::of(&types::CAST_REF_TO_MUT),
         LintId::of(&types::UNIT_CMP),
         LintId::of(&unicode::ZERO_WIDTH_SPACE),
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index f63301c7db0..b9c84654593 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -166,7 +166,7 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
     },
     Lint {
         name: "cast_ptr_alignment",
-        group: "correctness",
+        group: "pedantic",
         desc: "cast from a pointer to a more-strictly-aligned pointer",
         deprecation: None,
         module: "types",
-- 
cgit 1.4.1-3-g733a5


From 0ab823c509897ce2f516feb760fe1bf02cf77443 Mon Sep 17 00:00:00 2001
From: flip1995 <hello@philkrones.com>
Date: Mon, 26 Aug 2019 18:34:30 +0200
Subject: Rework suggestion generation of `unit_arg` lint

---
 clippy_lints/src/types.rs | 42 +++++++++++++++++++++++++++++++++---------
 1 file changed, 33 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs
index 3ac99e24684..8fcca4b7bb9 100644
--- a/clippy_lints/src/types.rs
+++ b/clippy_lints/src/types.rs
@@ -779,6 +779,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnitArg {
 
         match expr.kind {
             ExprKind::Call(_, args) | ExprKind::MethodCall(_, _, args) => {
+                let mut args_to_recover = vec![];
                 for arg in args {
                     if is_unit(cx.tables.expr_ty(arg)) && !is_unit_literal(arg) {
                         if let ExprKind::Match(.., match_source) = &arg.kind {
@@ -787,17 +788,40 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnitArg {
                             }
                         }
 
-                        span_lint_and_sugg(
-                            cx,
-                            UNIT_ARG,
-                            arg.span,
-                            "passing a unit value to a function",
-                            "if you intended to pass a unit value, use a unit literal instead",
-                            "()".to_string(),
-                            Applicability::MaybeIncorrect,
-                        );
+                        args_to_recover.push(arg);
                     }
                 }
+                if !args_to_recover.is_empty() {
+                    let mut applicability = Applicability::MachineApplicable;
+                    span_lint_and_then(cx, UNIT_ARG, expr.span, "passing a unit value to a function", |db| {
+                        db.span_suggestion(
+                            expr.span.with_hi(expr.span.lo()),
+                            "move the expressions in front of the call...",
+                            format!(
+                                "{} ",
+                                args_to_recover
+                                    .iter()
+                                    .map(|arg| {
+                                        format!(
+                                            "{};",
+                                            snippet_with_applicability(cx, arg.span, "..", &mut applicability)
+                                        )
+                                    })
+                                    .collect::<Vec<String>>()
+                                    .join(" ")
+                            ),
+                            applicability,
+                        );
+                        db.multipart_suggestion(
+                            "...and use unit literals instead",
+                            args_to_recover
+                                .iter()
+                                .map(|arg| (arg.span, "()".to_string()))
+                                .collect::<Vec<_>>(),
+                            applicability,
+                        );
+                    });
+                }
             },
             _ => (),
         }
-- 
cgit 1.4.1-3-g733a5


From a1a1a4b82a35b810570dbf7d2ee7f00896bee232 Mon Sep 17 00:00:00 2001
From: flip1995 <hello@philkrones.com>
Date: Mon, 26 Aug 2019 21:43:29 +0200
Subject: Use multiple span_suggestions instead of multipart_suggestion

multipart suggestions aren't autofixable by rustfix yet
---
 clippy_lints/src/types.rs | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs
index 8fcca4b7bb9..3fbea77757d 100644
--- a/clippy_lints/src/types.rs
+++ b/clippy_lints/src/types.rs
@@ -812,14 +812,14 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnitArg {
                             ),
                             applicability,
                         );
-                        db.multipart_suggestion(
-                            "...and use unit literals instead",
-                            args_to_recover
-                                .iter()
-                                .map(|arg| (arg.span, "()".to_string()))
-                                .collect::<Vec<_>>(),
-                            applicability,
-                        );
+                        for arg in args_to_recover {
+                            db.span_suggestion(
+                                arg.span,
+                                "...and use unit literals instead",
+                                "()".to_string(),
+                                applicability,
+                            );
+                        }
                     });
                 }
             },
-- 
cgit 1.4.1-3-g733a5


From 0f69cafc2dd77d573e24870887a4a13cfe50515a Mon Sep 17 00:00:00 2001
From: flip1995 <hello@philkrones.com>
Date: Mon, 17 Feb 2020 18:10:59 +0100
Subject: Rework suggestion generation and use multipart_suggestion again

---
 clippy_lints/src/types.rs | 55 ++++++++++++++++++++++++++++-------------------
 1 file changed, 33 insertions(+), 22 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs
index 3fbea77757d..c95bd5d72bc 100644
--- a/clippy_lints/src/types.rs
+++ b/clippy_lints/src/types.rs
@@ -794,32 +794,43 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnitArg {
                 if !args_to_recover.is_empty() {
                     let mut applicability = Applicability::MachineApplicable;
                     span_lint_and_then(cx, UNIT_ARG, expr.span, "passing a unit value to a function", |db| {
+                        let sugg = args_to_recover
+                            .iter()
+                            .enumerate()
+                            .map(|(i, arg)| {
+                                let indent = if i == 0 {
+                                    0
+                                } else {
+                                    indent_of(cx, expr.span).unwrap_or(0)
+                                };
+                                format!(
+                                    "{}{};",
+                                    " ".repeat(indent),
+                                    snippet_block_with_applicability(
+                                        cx,
+                                        arg.span,
+                                        "..",
+                                        Some(expr.span),
+                                        &mut applicability
+                                    )
+                                )
+                            })
+                            .collect::<Vec<String>>()
+                            .join("\n");
                         db.span_suggestion(
                             expr.span.with_hi(expr.span.lo()),
-                            "move the expressions in front of the call...",
-                            format!(
-                                "{} ",
-                                args_to_recover
-                                    .iter()
-                                    .map(|arg| {
-                                        format!(
-                                            "{};",
-                                            snippet_with_applicability(cx, arg.span, "..", &mut applicability)
-                                        )
-                                    })
-                                    .collect::<Vec<String>>()
-                                    .join(" ")
-                            ),
+                            &format!("{}move the expressions in front of the call...", or),
+                            format!("{}\n", sugg),
+                            applicability,
+                        );
+                        db.multipart_suggestion(
+                            "...and use unit literals instead",
+                            args_to_recover
+                                .iter()
+                                .map(|arg| (arg.span, "()".to_string()))
+                                .collect::<Vec<_>>(),
                             applicability,
                         );
-                        for arg in args_to_recover {
-                            db.span_suggestion(
-                                arg.span,
-                                "...and use unit literals instead",
-                                "()".to_string(),
-                                applicability,
-                            );
-                        }
                     });
                 }
             },
-- 
cgit 1.4.1-3-g733a5


From f9c325f5b657e0c37ba2016a51cddbeab7f7693f Mon Sep 17 00:00:00 2001
From: flip1995 <hello@philkrones.com>
Date: Mon, 17 Feb 2020 18:11:50 +0100
Subject: Suggest to remove the semicolon of the last stmt in a block

---
 clippy_lints/src/types.rs | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs
index c95bd5d72bc..51d7d9b3ab7 100644
--- a/clippy_lints/src/types.rs
+++ b/clippy_lints/src/types.rs
@@ -794,6 +794,36 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnitArg {
                 if !args_to_recover.is_empty() {
                     let mut applicability = Applicability::MachineApplicable;
                     span_lint_and_then(cx, UNIT_ARG, expr.span, "passing a unit value to a function", |db| {
+                        let mut or = "";
+                        args_to_recover
+                            .iter()
+                            .filter_map(|arg| {
+                                if_chain! {
+                                    if let ExprKind::Block(block, _) = arg.kind;
+                                    if block.expr.is_none();
+                                    if let Some(last_stmt) = block.stmts.iter().last();
+                                    if let StmtKind::Semi(last_expr) = last_stmt.kind;
+                                    if let Some(snip) = snippet_opt(cx, last_expr.span);
+                                    then {
+                                        Some((
+                                            last_stmt.span,
+                                            snip,
+                                        ))
+                                    }
+                                    else {
+                                        None
+                                    }
+                                }
+                            })
+                            .for_each(|(span, sugg)| {
+                                db.span_suggestion(
+                                    span,
+                                    "remove the semicolon from the last statement in the block",
+                                    sugg,
+                                    Applicability::MaybeIncorrect,
+                                );
+                                or = "or ";
+                            });
                         let sugg = args_to_recover
                             .iter()
                             .enumerate()
-- 
cgit 1.4.1-3-g733a5


From 4c9cefa12232aa0224b1680f51654fe10f5cf3b7 Mon Sep 17 00:00:00 2001
From: flip1995 <hello@philkrones.com>
Date: Tue, 18 Feb 2020 09:51:52 +0100
Subject: Move linting out in its own function

---
 clippy_lints/src/types.rs | 171 ++++++++++++++++++++++++----------------------
 1 file changed, 91 insertions(+), 80 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs
index 51d7d9b3ab7..6866635b904 100644
--- a/clippy_lints/src/types.rs
+++ b/clippy_lints/src/types.rs
@@ -779,89 +779,22 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnitArg {
 
         match expr.kind {
             ExprKind::Call(_, args) | ExprKind::MethodCall(_, _, args) => {
-                let mut args_to_recover = vec![];
-                for arg in args {
-                    if is_unit(cx.tables.expr_ty(arg)) && !is_unit_literal(arg) {
-                        if let ExprKind::Match(.., match_source) = &arg.kind {
-                            if *match_source == MatchSource::TryDesugar {
-                                continue;
+                let args_to_recover = args
+                    .iter()
+                    .filter(|arg| {
+                        if is_unit(cx.tables.expr_ty(arg)) && !is_unit_literal(arg) {
+                            if let ExprKind::Match(.., MatchSource::TryDesugar) = &arg.kind {
+                                false
+                            } else {
+                                true
                             }
+                        } else {
+                            false
                         }
-
-                        args_to_recover.push(arg);
-                    }
-                }
+                    })
+                    .collect::<Vec<_>>();
                 if !args_to_recover.is_empty() {
-                    let mut applicability = Applicability::MachineApplicable;
-                    span_lint_and_then(cx, UNIT_ARG, expr.span, "passing a unit value to a function", |db| {
-                        let mut or = "";
-                        args_to_recover
-                            .iter()
-                            .filter_map(|arg| {
-                                if_chain! {
-                                    if let ExprKind::Block(block, _) = arg.kind;
-                                    if block.expr.is_none();
-                                    if let Some(last_stmt) = block.stmts.iter().last();
-                                    if let StmtKind::Semi(last_expr) = last_stmt.kind;
-                                    if let Some(snip) = snippet_opt(cx, last_expr.span);
-                                    then {
-                                        Some((
-                                            last_stmt.span,
-                                            snip,
-                                        ))
-                                    }
-                                    else {
-                                        None
-                                    }
-                                }
-                            })
-                            .for_each(|(span, sugg)| {
-                                db.span_suggestion(
-                                    span,
-                                    "remove the semicolon from the last statement in the block",
-                                    sugg,
-                                    Applicability::MaybeIncorrect,
-                                );
-                                or = "or ";
-                            });
-                        let sugg = args_to_recover
-                            .iter()
-                            .enumerate()
-                            .map(|(i, arg)| {
-                                let indent = if i == 0 {
-                                    0
-                                } else {
-                                    indent_of(cx, expr.span).unwrap_or(0)
-                                };
-                                format!(
-                                    "{}{};",
-                                    " ".repeat(indent),
-                                    snippet_block_with_applicability(
-                                        cx,
-                                        arg.span,
-                                        "..",
-                                        Some(expr.span),
-                                        &mut applicability
-                                    )
-                                )
-                            })
-                            .collect::<Vec<String>>()
-                            .join("\n");
-                        db.span_suggestion(
-                            expr.span.with_hi(expr.span.lo()),
-                            &format!("{}move the expressions in front of the call...", or),
-                            format!("{}\n", sugg),
-                            applicability,
-                        );
-                        db.multipart_suggestion(
-                            "...and use unit literals instead",
-                            args_to_recover
-                                .iter()
-                                .map(|arg| (arg.span, "()".to_string()))
-                                .collect::<Vec<_>>(),
-                            applicability,
-                        );
-                    });
+                    lint_unit_args(cx, expr, &args_to_recover);
                 }
             },
             _ => (),
@@ -869,6 +802,84 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnitArg {
     }
 }
 
+fn lint_unit_args(cx: &LateContext<'_, '_>, expr: &Expr<'_>, args_to_recover: &[&Expr<'_>]) {
+    let mut applicability = Applicability::MachineApplicable;
+    let (singular, plural) = if args_to_recover.len() > 1 {
+        ("", "s")
+    } else {
+        ("a ", "")
+    };
+    span_lint_and_then(
+        cx,
+        UNIT_ARG,
+        expr.span,
+        &format!("passing {}unit value{} to a function", singular, plural),
+        |db| {
+            let mut or = "";
+            args_to_recover
+                .iter()
+                .filter_map(|arg| {
+                    if_chain! {
+                        if let ExprKind::Block(block, _) = arg.kind;
+                        if block.expr.is_none();
+                        if let Some(last_stmt) = block.stmts.iter().last();
+                        if let StmtKind::Semi(last_expr) = last_stmt.kind;
+                        if let Some(snip) = snippet_opt(cx, last_expr.span);
+                        then {
+                            Some((
+                                last_stmt.span,
+                                snip,
+                            ))
+                        }
+                        else {
+                            None
+                        }
+                    }
+                })
+                .for_each(|(span, sugg)| {
+                    db.span_suggestion(
+                        span,
+                        "remove the semicolon from the last statement in the block",
+                        sugg,
+                        Applicability::MaybeIncorrect,
+                    );
+                    or = "or ";
+                });
+            let sugg = args_to_recover
+                .iter()
+                .enumerate()
+                .map(|(i, arg)| {
+                    let indent = if i == 0 {
+                        0
+                    } else {
+                        indent_of(cx, expr.span).unwrap_or(0)
+                    };
+                    format!(
+                        "{}{};",
+                        " ".repeat(indent),
+                        snippet_block_with_applicability(cx, arg.span, "..", Some(expr.span), &mut applicability)
+                    )
+                })
+                .collect::<Vec<String>>()
+                .join("\n");
+            db.span_suggestion(
+                expr.span.with_hi(expr.span.lo()),
+                &format!("{}move the expression{} in front of the call...", or, plural),
+                format!("{}\n", sugg),
+                applicability,
+            );
+            db.multipart_suggestion(
+                &format!("...and use {}unit literal{} instead", singular, plural),
+                args_to_recover
+                    .iter()
+                    .map(|arg| (arg.span, "()".to_string()))
+                    .collect::<Vec<_>>(),
+                applicability,
+            );
+        },
+    );
+}
+
 fn is_questionmark_desugar_marked_call(expr: &Expr<'_>) -> bool {
     use rustc_span::hygiene::DesugaringKind;
     if let ExprKind::Call(ref callee, _) = expr.kind {
-- 
cgit 1.4.1-3-g733a5


From a9cde3a804808e82402888a20878053404a8eded Mon Sep 17 00:00:00 2001
From: flip1995 <hello@philkrones.com>
Date: Sun, 31 May 2020 18:45:16 +0200
Subject: Don't suggest to move empty blocks

---
 clippy_lints/src/types.rs | 43 ++++++++++++++++++++++++++++++-------------
 1 file changed, 30 insertions(+), 13 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs
index 6866635b904..5ca30d598eb 100644
--- a/clippy_lints/src/types.rs
+++ b/clippy_lints/src/types.rs
@@ -10,7 +10,7 @@ use rustc_errors::{Applicability, DiagnosticBuilder};
 use rustc_hir as hir;
 use rustc_hir::intravisit::{walk_body, walk_expr, walk_ty, FnKind, NestedVisitorMap, Visitor};
 use rustc_hir::{
-    BinOpKind, Body, Expr, ExprKind, FnDecl, FnRetTy, FnSig, GenericArg, GenericParamKind, HirId, ImplItem,
+    BinOpKind, Block, Body, Expr, ExprKind, FnDecl, FnRetTy, FnSig, GenericArg, GenericParamKind, HirId, ImplItem,
     ImplItemKind, Item, ItemKind, Lifetime, Local, MatchSource, MutTy, Mutability, QPath, Stmt, StmtKind, TraitFn,
     TraitItem, TraitItemKind, TyKind, UnOp,
 };
@@ -29,10 +29,10 @@ use rustc_typeck::hir_ty_to_ty;
 use crate::consts::{constant, Constant};
 use crate::utils::paths;
 use crate::utils::{
-    clip, comparisons, differing_macro_contexts, higher, in_constant, int_bits, is_type_diagnostic_item,
+    clip, comparisons, differing_macro_contexts, higher, in_constant, indent_of, int_bits, is_type_diagnostic_item,
     last_path_segment, match_def_path, match_path, method_chain_args, multispan_sugg, numeric_literal::NumericLiteral,
-    qpath_res, same_tys, sext, snippet, snippet_opt, snippet_with_applicability, snippet_with_macro_callsite,
-    span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then, unsext,
+    qpath_res, same_tys, sext, snippet, snippet_block_with_applicability, snippet_opt, snippet_with_applicability,
+    snippet_with_macro_callsite, span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then, unsext,
 };
 
 declare_clippy_lint! {
@@ -847,6 +847,7 @@ fn lint_unit_args(cx: &LateContext<'_, '_>, expr: &Expr<'_>, args_to_recover: &[
                 });
             let sugg = args_to_recover
                 .iter()
+                .filter(|arg| !is_empty_block(arg))
                 .enumerate()
                 .map(|(i, arg)| {
                     let indent = if i == 0 {
@@ -860,16 +861,20 @@ fn lint_unit_args(cx: &LateContext<'_, '_>, expr: &Expr<'_>, args_to_recover: &[
                         snippet_block_with_applicability(cx, arg.span, "..", Some(expr.span), &mut applicability)
                     )
                 })
-                .collect::<Vec<String>>()
-                .join("\n");
-            db.span_suggestion(
-                expr.span.with_hi(expr.span.lo()),
-                &format!("{}move the expression{} in front of the call...", or, plural),
-                format!("{}\n", sugg),
-                applicability,
-            );
+                .collect::<Vec<String>>();
+            let mut and = "";
+            if !sugg.is_empty() {
+                let plural = if sugg.len() > 1 { "s" } else { "" };
+                db.span_suggestion(
+                    expr.span.with_hi(expr.span.lo()),
+                    &format!("{}move the expression{} in front of the call...", or, plural),
+                    format!("{}\n", sugg.join("\n")),
+                    applicability,
+                );
+                and = "...and "
+            }
             db.multipart_suggestion(
-                &format!("...and use {}unit literal{} instead", singular, plural),
+                &format!("{}use {}unit literal{} instead", and, singular, plural),
                 args_to_recover
                     .iter()
                     .map(|arg| (arg.span, "()".to_string()))
@@ -880,6 +885,18 @@ fn lint_unit_args(cx: &LateContext<'_, '_>, expr: &Expr<'_>, args_to_recover: &[
     );
 }
 
+fn is_empty_block(expr: &Expr<'_>) -> bool {
+    matches!(
+        expr.kind,
+        ExprKind::Block(
+            Block {
+                stmts: &[], expr: None, ..
+            },
+            _,
+        )
+    )
+}
+
 fn is_questionmark_desugar_marked_call(expr: &Expr<'_>) -> bool {
     use rustc_span::hygiene::DesugaringKind;
     if let ExprKind::Call(ref callee, _) = expr.kind {
-- 
cgit 1.4.1-3-g733a5


From 7e843515d9525b6389c3fc1bcfa6ae046c1351dc Mon Sep 17 00:00:00 2001
From: JarredAllen <jarredallen73@gmail.com>
Date: Thu, 14 May 2020 15:06:05 -0700
Subject: Created lint

---
 CHANGELOG.md                            |  1 +
 clippy_lints/src/lib.rs                 |  4 ++++
 clippy_lints/src/sort_by_key_reverse.rs | 28 ++++++++++++++++++++++++++++
 src/lintlist/mod.rs                     |  7 +++++++
 tests/ui/sort_by_key_reverse.rs         |  5 +++++
 5 files changed, 45 insertions(+)
 create mode 100644 clippy_lints/src/sort_by_key_reverse.rs
 create mode 100644 tests/ui/sort_by_key_reverse.rs

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index f7dae3dcfff..c00f84bdb85 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1555,6 +1555,7 @@ Released 2018-09-13
 [`single_match_else`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_match_else
 [`skip_while_next`]: https://rust-lang.github.io/rust-clippy/master/index.html#skip_while_next
 [`slow_vector_initialization`]: https://rust-lang.github.io/rust-clippy/master/index.html#slow_vector_initialization
+[`sort_by_key_reverse`]: https://rust-lang.github.io/rust-clippy/master/index.html#sort_by_key_reverse
 [`str_to_string`]: https://rust-lang.github.io/rust-clippy/master/index.html#str_to_string
 [`string_add`]: https://rust-lang.github.io/rust-clippy/master/index.html#string_add
 [`string_add_assign`]: https://rust-lang.github.io/rust-clippy/master/index.html#string_add_assign
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 38cfa212d9f..f51855badff 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -304,6 +304,7 @@ mod serde_api;
 mod shadow;
 mod single_component_path_imports;
 mod slow_vector_initialization;
+mod sort_by_key_reverse;
 mod strings;
 mod suspicious_trait_impl;
 mod swap;
@@ -779,6 +780,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &shadow::SHADOW_UNRELATED,
         &single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS,
         &slow_vector_initialization::SLOW_VECTOR_INITIALIZATION,
+        &sort_by_key_reverse::SORT_BY_KEY_REVERSE,
         &strings::STRING_ADD,
         &strings::STRING_ADD_ASSIGN,
         &strings::STRING_LIT_AS_BYTES,
@@ -1391,6 +1393,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&serde_api::SERDE_API_MISUSE),
         LintId::of(&single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS),
         LintId::of(&slow_vector_initialization::SLOW_VECTOR_INITIALIZATION),
+        LintId::of(&sort_by_key_reverse::SORT_BY_KEY_REVERSE),
         LintId::of(&strings::STRING_LIT_AS_BYTES),
         LintId::of(&suspicious_trait_impl::SUSPICIOUS_ARITHMETIC_IMPL),
         LintId::of(&suspicious_trait_impl::SUSPICIOUS_OP_ASSIGN_IMPL),
@@ -1592,6 +1595,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&ranges::RANGE_ZIP_WITH_LEN),
         LintId::of(&reference::DEREF_ADDROF),
         LintId::of(&reference::REF_IN_DEREF),
+        LintId::of(&sort_by_key_reverse::SORT_BY_KEY_REVERSE),
         LintId::of(&swap::MANUAL_SWAP),
         LintId::of(&temporary_assignment::TEMPORARY_ASSIGNMENT),
         LintId::of(&transmute::CROSSPOINTER_TRANSMUTE),
diff --git a/clippy_lints/src/sort_by_key_reverse.rs b/clippy_lints/src/sort_by_key_reverse.rs
new file mode 100644
index 00000000000..65830afd0f8
--- /dev/null
+++ b/clippy_lints/src/sort_by_key_reverse.rs
@@ -0,0 +1,28 @@
+use rustc_lint::{LateLintPass, LateContext};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_hir::*;
+
+declare_clippy_lint! {
+    /// **What it does:**
+    ///
+    /// **Why is this bad?**
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// // example code where clippy issues a warning
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// // example code which does not raise clippy warning
+    /// ```
+    pub SORT_BY_KEY_REVERSE,
+    complexity,
+    "default lint description"
+}
+
+declare_lint_pass!(SortByKeyReverse => [SORT_BY_KEY_REVERSE]);
+
+impl LateLintPass<'_, '_> for SortByKeyReverse {}
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index 69578732898..1b82f34c863 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -1984,6 +1984,13 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
         deprecation: None,
         module: "slow_vector_initialization",
     },
+    Lint {
+        name: "sort_by_key_reverse",
+        group: "complexity",
+        desc: "default lint description",
+        deprecation: None,
+        module: "sort_by_key_reverse",
+    },
     Lint {
         name: "string_add",
         group: "restriction",
diff --git a/tests/ui/sort_by_key_reverse.rs b/tests/ui/sort_by_key_reverse.rs
new file mode 100644
index 00000000000..2338dc6e594
--- /dev/null
+++ b/tests/ui/sort_by_key_reverse.rs
@@ -0,0 +1,5 @@
+#![warn(clippy::sort_by_key_reverse)]
+
+fn main() {
+    // test code goes here
+}
-- 
cgit 1.4.1-3-g733a5


From 24847ea53e332853597aca2c7dfe48a9f3be1de8 Mon Sep 17 00:00:00 2001
From: JarredAllen <jarredallen73@gmail.com>
Date: Sat, 16 May 2020 13:50:33 -0700
Subject: Attempted start at sort_by_key_reverse lint

---
 clippy_lints/src/sort_by_key_reverse.rs | 71 +++++++++++++++++++++++++++++++--
 src/lintlist/mod.rs                     |  2 +-
 tests/ui/sort_by_key_reverse.fixed      |  0
 tests/ui/sort_by_key_reverse.rs         |  3 +-
 tests/ui/sort_by_key_reverse.stderr     |  0
 5 files changed, 70 insertions(+), 6 deletions(-)
 create mode 100644 tests/ui/sort_by_key_reverse.fixed
 create mode 100644 tests/ui/sort_by_key_reverse.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/sort_by_key_reverse.rs b/clippy_lints/src/sort_by_key_reverse.rs
index 65830afd0f8..7d7097a8125 100644
--- a/clippy_lints/src/sort_by_key_reverse.rs
+++ b/clippy_lints/src/sort_by_key_reverse.rs
@@ -1,28 +1,91 @@
+use crate::utils::{match_type, span_lint_and_sugg};
+use crate::utils::paths;
+use crate::utils::sugg::Sugg;
+use if_chain::if_chain;
+use rustc_errors::Applicability;
 use rustc_lint::{LateLintPass, LateContext};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_hir::*;
 
 declare_clippy_lint! {
     /// **What it does:**
+    /// Detects when people use `Vec::sort_by` and pass in a function
+    /// which compares the second argument to the first.
     ///
     /// **Why is this bad?**
+    /// It is more clear to use `Vec::sort_by_key` and `std::cmp::Reverse`
     ///
     /// **Known problems:** None.
     ///
     /// **Example:**
     ///
     /// ```rust
-    /// // example code where clippy issues a warning
+    /// vec.sort_by(|a, b| b.foo().cmp(&a.foo()));
     /// ```
     /// Use instead:
     /// ```rust
-    /// // example code which does not raise clippy warning
+    /// vec.sort_by_key(|e| Reverse(e.foo()));
     /// ```
     pub SORT_BY_KEY_REVERSE,
     complexity,
-    "default lint description"
+    "Use of `Vec::sort_by` when `Vec::sort_by_key` would be clearer"
 }
 
 declare_lint_pass!(SortByKeyReverse => [SORT_BY_KEY_REVERSE]);
 
-impl LateLintPass<'_, '_> for SortByKeyReverse {}
+struct LintTrigger {
+    vec_name: String,
+    closure_arg: String,
+    closure_reverse_body: String,
+    unstable: bool,
+}
+
+fn detect_lint(cx: &LateContext<'_, '_>, expr: &Expr<'_>) -> Option<LintTrigger> {
+    if_chain! {
+        if let ExprKind::MethodCall(name_ident, _, args) = &expr.kind;
+        if let name = name_ident.ident.name.to_ident_string();
+        if name == "sort_by" || name == "sort_unstable_by";
+        if let [vec, Expr { kind: ExprKind::Closure(_, closure_decl, closure_body_id, _, _), .. }] = args;
+        if closure_decl.inputs.len() == 2;
+        if match_type(cx, &cx.tables.expr_ty(vec), &paths::VEC);
+        then {
+            let vec_name = Sugg::hir(cx, &args[0], "..").to_string();
+            let unstable = name == "sort_unstable_by";
+            Some(LintTrigger { vec_name, unstable, closure_arg: "e".to_string(), closure_reverse_body: "e".to_string() })
+        } else {
+            None
+        }
+    }
+}
+
+impl LateLintPass<'_, '_> for SortByKeyReverse {
+    fn check_expr(&mut self, cx: &LateContext<'_, '_>, expr: &Expr<'_>) {
+        println!("{:?}", expr);
+        span_lint_and_sugg(
+            cx,
+            SORT_BY_KEY_REVERSE,
+            expr.span,
+            "use Vec::sort_by_key here instead",
+            "try",
+            String::from("being a better person"),
+            Applicability::MachineApplicable,
+        );
+        if let Some(trigger) = detect_lint(cx, expr) {
+            span_lint_and_sugg(
+                cx,
+                SORT_BY_KEY_REVERSE,
+                expr.span,
+                "use Vec::sort_by_key here instead",
+                "try",
+                format!(
+                    "{}.sort{}_by_key(|{}| Reverse({}))",
+                    trigger.vec_name,
+                    if trigger.unstable { "_unstable" } else { "" },
+                    trigger.closure_arg,
+                    trigger.closure_reverse_body,
+                ),
+                Applicability::MachineApplicable,
+            );
+        }
+    }
+}
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index 1b82f34c863..b5d9ef0110e 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -1987,7 +1987,7 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
     Lint {
         name: "sort_by_key_reverse",
         group: "complexity",
-        desc: "default lint description",
+        desc: "Use of `Vec::sort_by` when `Vec::sort_by_key` would be clearer",
         deprecation: None,
         module: "sort_by_key_reverse",
     },
diff --git a/tests/ui/sort_by_key_reverse.fixed b/tests/ui/sort_by_key_reverse.fixed
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/tests/ui/sort_by_key_reverse.rs b/tests/ui/sort_by_key_reverse.rs
index 2338dc6e594..c0350f243c7 100644
--- a/tests/ui/sort_by_key_reverse.rs
+++ b/tests/ui/sort_by_key_reverse.rs
@@ -1,5 +1,6 @@
 #![warn(clippy::sort_by_key_reverse)]
 
 fn main() {
-    // test code goes here
+    let mut vec = vec![3, 6, 1, 2, 5];
+    vec.sort_by(|a, b| b.cmp(a));
 }
diff --git a/tests/ui/sort_by_key_reverse.stderr b/tests/ui/sort_by_key_reverse.stderr
new file mode 100644
index 00000000000..e69de29bb2d
-- 
cgit 1.4.1-3-g733a5


From 8590ab4d46de4eb43e7ebd42cb2f13b0064573e6 Mon Sep 17 00:00:00 2001
From: JarredAllen <jarredallen73@gmail.com>
Date: Mon, 18 May 2020 21:48:35 -0700
Subject: More progress towards sort_by_key_reverse lint

---
 clippy_lints/src/lib.rs                 |   1 +
 clippy_lints/src/sort_by_key_reverse.rs | 131 +++++++++++++++++++++++++++-----
 tests/ui/sort_by_key_reverse.fixed      |   9 +++
 tests/ui/sort_by_key_reverse.rs         |   5 +-
 tests/ui/sort_by_key_reverse.stderr     |  22 ++++++
 5 files changed, 149 insertions(+), 19 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index f51855badff..e7a4c1ecaa9 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -998,6 +998,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box ptr_offset_with_cast::PtrOffsetWithCast);
     store.register_late_pass(|| box redundant_clone::RedundantClone);
     store.register_late_pass(|| box slow_vector_initialization::SlowVectorInit);
+    store.register_late_pass(|| box sort_by_key_reverse::SortByKeyReverse);
     store.register_late_pass(|| box types::RefToMut);
     store.register_late_pass(|| box assertions_on_constants::AssertionsOnConstants);
     store.register_late_pass(|| box missing_const_for_fn::MissingConstForFn);
diff --git a/clippy_lints/src/sort_by_key_reverse.rs b/clippy_lints/src/sort_by_key_reverse.rs
index 7d7097a8125..d70391999a0 100644
--- a/clippy_lints/src/sort_by_key_reverse.rs
+++ b/clippy_lints/src/sort_by_key_reverse.rs
@@ -1,11 +1,12 @@
-use crate::utils::{match_type, span_lint_and_sugg};
+use crate::utils;
 use crate::utils::paths;
 use crate::utils::sugg::Sugg;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
-use rustc_lint::{LateLintPass, LateContext};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_hir::*;
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::symbol::Ident;
 
 declare_clippy_lint! {
     /// **What it does:**
@@ -40,18 +41,122 @@ struct LintTrigger {
     unstable: bool,
 }
 
+/// Detect if the two expressions are mirrored (identical, except one
+/// contains a and the other replaces it with b)
+fn mirrored_exprs(cx: &LateContext<'_, '_>, a_expr: &Expr<'_>, a_ident: &Ident, b_expr: &Expr<'_>, b_ident: &Ident) -> bool {
+    match (&a_expr.kind, &b_expr.kind) {
+        // Two boxes with mirrored contents
+        (ExprKind::Box(left_expr), ExprKind::Box(right_expr)) => mirrored_exprs(cx, left_expr, a_ident, right_expr, b_ident),
+        // Two arrays with mirrored contents
+        (ExprKind::Array(left_exprs), ExprKind::Array(right_exprs))
+            => left_exprs.iter().zip(right_exprs.iter()).all(|(left, right)| mirrored_exprs(cx, left, a_ident, right, b_ident)),
+        // The two exprs are function calls.
+        // Check to see that the function itself and its arguments are mirrored
+        (ExprKind::Call(left_expr, left_args), ExprKind::Call(right_expr, right_args))
+            => mirrored_exprs(cx, left_expr, a_ident, right_expr, b_ident)
+                && left_args.iter().zip(right_args.iter()).all(|(left, right)| mirrored_exprs(cx, left, a_ident, right, b_ident)),
+        // The two exprs are method calls.
+        // Check to see that the function is the same and the arguments are mirrored
+        // This is enough because the receiver of the method is listed in the arguments
+        (ExprKind::MethodCall(left_segment, _, left_args), ExprKind::MethodCall(right_segment, _, right_args))
+            => left_segment.ident == right_segment.ident
+                && left_args.iter().zip(right_args.iter()).all(|(left, right)| mirrored_exprs(cx, left, a_ident, right, b_ident)),
+        // Two tuples with mirrored contents
+        (ExprKind::Tup(left_exprs), ExprKind::Tup(right_exprs))
+            => left_exprs.iter().zip(right_exprs.iter()).all(|(left, right)| mirrored_exprs(cx, left, a_ident, right, b_ident)),
+        // Two binary ops, which are the same operation and which have mirrored arguments
+        (ExprKind::Binary(left_op, left_left, left_right), ExprKind::Binary(right_op, right_left, right_right))
+            => left_op.node == right_op.node
+                && mirrored_exprs(cx, left_left, a_ident, right_left, b_ident)
+                && mirrored_exprs(cx, left_right, a_ident, right_right, b_ident),
+        // Two unary ops, which are the same operation and which have the same argument
+        (ExprKind::Unary(left_op, left_expr), ExprKind::Unary(right_op, right_expr))
+            => left_op == right_op && mirrored_exprs(cx, left_expr, a_ident, right_expr, b_ident),
+        // The two exprs are literals of some kind
+        (ExprKind::Lit(left_lit), ExprKind::Lit(right_lit)) => left_lit.node == right_lit.node,
+        (ExprKind::Cast(left_expr, _), ExprKind::Cast(right_expr, _))
+            => mirrored_exprs(cx, left_expr, a_ident, right_expr, b_ident),
+        (ExprKind::DropTemps(left), ExprKind::DropTemps(right)) => mirrored_exprs(cx, left, a_ident, right, b_ident),
+        (ExprKind::Block(left, _), ExprKind::Block(right, _)) => mirrored_blocks(cx, left, a_ident, right, b_ident),
+        (ExprKind::Field(left_expr, left_ident), ExprKind::Field(right_expr, right_ident))
+            => left_ident.name == right_ident.name && mirrored_exprs(cx, left_expr, a_ident, right_expr, right_ident),
+        // The two exprs are `a` and `b`, directly
+        (ExprKind::Path(QPath::Resolved(_, Path { segments: &[PathSegment { ident: left_ident, .. }], ..  },)),
+         ExprKind::Path(QPath::Resolved(_, Path { segments: &[PathSegment { ident: right_ident, .. }], ..  },)),
+        ) => &left_ident == a_ident && &right_ident == b_ident,
+        // The two exprs are Paths to the same name (which is neither a nor b)
+        (ExprKind::Path(QPath::Resolved(_, Path { segments: left_segments, .. })),
+         ExprKind::Path(QPath::Resolved(_, Path { segments: right_segments, .. })))
+            => left_segments.iter().zip(right_segments.iter()).all(|(left, right)| left.ident == right.ident)
+                && left_segments.iter().all(|seg| &seg.ident != a_ident && &seg.ident != b_ident),
+        // Matching expressions, but one or both is borrowed
+        (ExprKind::AddrOf(left_kind, Mutability::Not, left_expr), ExprKind::AddrOf(right_kind, Mutability::Not, right_expr))
+            => left_kind == right_kind && mirrored_exprs(cx, left_expr, a_ident, right_expr, b_ident),
+        (_, ExprKind::AddrOf(_, Mutability::Not, right_expr))
+            => mirrored_exprs(cx, a_expr, a_ident, right_expr, b_ident),
+        (ExprKind::AddrOf(_, Mutability::Not, left_expr), _)
+            => mirrored_exprs(cx, left_expr, a_ident, b_expr, b_ident),
+        // _ => false,
+        (left, right) => {
+            println!("{:?}\n{:?}", left, right);
+            false
+        },
+    }
+}
+
+/// Detect if the two blocks are mirrored (identical, except one
+/// contains a and the other replaces it with b)
+fn mirrored_blocks(cx: &LateContext<'_, '_>, a_block: &Block<'_>, a_ident: &Ident, b_block: &Block<'_>, b_ident: &Ident) -> bool {
+    match (a_block, b_block) {
+        (Block { stmts: left_stmts, expr: left_expr, .. },
+         Block { stmts: right_stmts, expr: right_expr, .. })
+            => left_stmts.iter().zip(right_stmts.iter()).all(|(left, right)| match (&left.kind, &right.kind) {
+                (StmtKind::Expr(left_expr), StmtKind::Expr(right_expr)) => mirrored_exprs(cx, left_expr, a_ident, right_expr, b_ident),
+                (StmtKind::Semi(left_expr), StmtKind::Semi(right_expr)) => mirrored_exprs(cx, left_expr, a_ident, right_expr, b_ident),
+                (StmtKind::Item(left_item), StmtKind::Item(right_item)) => left_item.id == right_item.id,
+                (StmtKind::Local(left), StmtKind::Local(right)) => mirrored_locals(cx, left, a_ident, right, b_ident),
+                _ => false,
+            }) && match (left_expr, right_expr) {
+                (None, None) => true,
+                (Some(left), Some(right)) => mirrored_exprs(cx, left, a_ident, right, b_ident),
+                _ => false,
+            },
+    }
+}
+
+/// Check that the two "Local"s (let statements) are equal
+fn mirrored_locals(cx: &LateContext<'_, '_>, a_local: &Local<'_>, a_ident: &Ident, b_local: &Local<'_>, b_ident: &Ident) -> bool {
+    match (a_local, b_local) {
+        (Local { pat: left_pat, init: left_expr, .. }, Local { pat: right_pat, init: right_expr, .. })
+            => match (left_expr, right_expr) {
+                (None, None) => true,
+                (Some(left), Some(right)) => mirrored_exprs(cx, left, a_ident, right, b_ident),
+                _ => false,
+            },
+    }
+}
+
 fn detect_lint(cx: &LateContext<'_, '_>, expr: &Expr<'_>) -> Option<LintTrigger> {
     if_chain! {
         if let ExprKind::MethodCall(name_ident, _, args) = &expr.kind;
         if let name = name_ident.ident.name.to_ident_string();
         if name == "sort_by" || name == "sort_unstable_by";
-        if let [vec, Expr { kind: ExprKind::Closure(_, closure_decl, closure_body_id, _, _), .. }] = args;
-        if closure_decl.inputs.len() == 2;
-        if match_type(cx, &cx.tables.expr_ty(vec), &paths::VEC);
+        if let [vec, Expr { kind: ExprKind::Closure(_, _, closure_body_id, _, _), .. }] = args;
+        if utils::match_type(cx, &cx.tables.expr_ty(vec), &paths::VEC);
+        if let closure_body = cx.tcx.hir().body(*closure_body_id);
+        if let &[
+            Param { pat: Pat { kind: PatKind::Binding(_, _, a_ident, _), .. }, ..},
+            Param { pat: Pat { kind: PatKind::Binding(_, _, b_ident, _), .. }, .. }
+        ] = &closure_body.params;
+        if let ExprKind::MethodCall(method_path, _, [ref b_expr, ref a_expr]) = &closure_body.value.kind;
+        if method_path.ident.name.to_ident_string() == "cmp";
+        if mirrored_exprs(&cx, &a_expr, &a_ident, &b_expr, &b_ident);
         then {
             let vec_name = Sugg::hir(cx, &args[0], "..").to_string();
             let unstable = name == "sort_unstable_by";
-            Some(LintTrigger { vec_name, unstable, closure_arg: "e".to_string(), closure_reverse_body: "e".to_string() })
+            let closure_arg = a_ident.name.to_ident_string();
+            let closure_reverse_body = Sugg::hir(cx, &a_expr, "..").to_string();
+            Some(LintTrigger { vec_name, unstable, closure_arg, closure_reverse_body })
         } else {
             None
         }
@@ -60,18 +165,8 @@ fn detect_lint(cx: &LateContext<'_, '_>, expr: &Expr<'_>) -> Option<LintTrigger>
 
 impl LateLintPass<'_, '_> for SortByKeyReverse {
     fn check_expr(&mut self, cx: &LateContext<'_, '_>, expr: &Expr<'_>) {
-        println!("{:?}", expr);
-        span_lint_and_sugg(
-            cx,
-            SORT_BY_KEY_REVERSE,
-            expr.span,
-            "use Vec::sort_by_key here instead",
-            "try",
-            String::from("being a better person"),
-            Applicability::MachineApplicable,
-        );
         if let Some(trigger) = detect_lint(cx, expr) {
-            span_lint_and_sugg(
+            utils::span_lint_and_sugg(
                 cx,
                 SORT_BY_KEY_REVERSE,
                 expr.span,
diff --git a/tests/ui/sort_by_key_reverse.fixed b/tests/ui/sort_by_key_reverse.fixed
index e69de29bb2d..4b18a073e1a 100644
--- a/tests/ui/sort_by_key_reverse.fixed
+++ b/tests/ui/sort_by_key_reverse.fixed
@@ -0,0 +1,9 @@
+// run-rustfix
+#![warn(clippy::sort_by_key_reverse)]
+
+fn main() {
+    let mut vec: Vec<isize> = vec![3, 6, 1, 2, 5];
+    vec.sort_by_key(|a| Reverse(a));
+    vec.sort_by_key(|a| Reverse(&(a+5).abs()));
+    vec.sort_by_key(|a| Reverse(&-a));
+}
diff --git a/tests/ui/sort_by_key_reverse.rs b/tests/ui/sort_by_key_reverse.rs
index c0350f243c7..f4fb70b7b1d 100644
--- a/tests/ui/sort_by_key_reverse.rs
+++ b/tests/ui/sort_by_key_reverse.rs
@@ -1,6 +1,9 @@
+// run-rustfix
 #![warn(clippy::sort_by_key_reverse)]
 
 fn main() {
-    let mut vec = vec![3, 6, 1, 2, 5];
+    let mut vec: Vec<isize> = vec![3, 6, 1, 2, 5];
     vec.sort_by(|a, b| b.cmp(a));
+    vec.sort_by(|a, b| (b + 5).abs().cmp(&(a+5).abs()));
+    vec.sort_by(|a, b| (-b).cmp(&-a));
 }
diff --git a/tests/ui/sort_by_key_reverse.stderr b/tests/ui/sort_by_key_reverse.stderr
index e69de29bb2d..36a28c04b1c 100644
--- a/tests/ui/sort_by_key_reverse.stderr
+++ b/tests/ui/sort_by_key_reverse.stderr
@@ -0,0 +1,22 @@
+error: use Vec::sort_by_key here instead
+  --> $DIR/sort_by_key_reverse.rs:6:5
+   |
+LL |     vec.sort_by(|a, b| b.cmp(a));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_by_key(|a| Reverse(a))`
+   |
+   = note: `-D clippy::sort-by-key-reverse` implied by `-D warnings`
+
+error: use Vec::sort_by_key here instead
+  --> $DIR/sort_by_key_reverse.rs:7:5
+   |
+LL |     vec.sort_by(|a, b| (b + 5).abs().cmp(&(a+5).abs()));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_by_key(|a| Reverse(&(a+5).abs()))`
+
+error: use Vec::sort_by_key here instead
+  --> $DIR/sort_by_key_reverse.rs:8:5
+   |
+LL |     vec.sort_by(|a, b| (-b).cmp(&-a));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_by_key(|a| Reverse(&-a))`
+
+error: aborting due to 3 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 943cb94dce8fca6f3a3f7f011a2a2f9f0a665b97 Mon Sep 17 00:00:00 2001
From: JarredAllen <jarredallen73@gmail.com>
Date: Tue, 19 May 2020 22:57:27 -0700
Subject: Passes all tests now!

---
 clippy_lints/src/sort_by_key_reverse.rs | 72 ++++++++++-----------------------
 tests/ui/sort_by_key_reverse.fixed      | 12 ++++--
 tests/ui/sort_by_key_reverse.rs         |  8 +++-
 tests/ui/sort_by_key_reverse.stderr     | 14 +++----
 4 files changed, 45 insertions(+), 61 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/sort_by_key_reverse.rs b/clippy_lints/src/sort_by_key_reverse.rs
index d70391999a0..31629a1dbc1 100644
--- a/clippy_lints/src/sort_by_key_reverse.rs
+++ b/clippy_lints/src/sort_by_key_reverse.rs
@@ -53,8 +53,12 @@ fn mirrored_exprs(cx: &LateContext<'_, '_>, a_expr: &Expr<'_>, a_ident: &Ident,
         // The two exprs are function calls.
         // Check to see that the function itself and its arguments are mirrored
         (ExprKind::Call(left_expr, left_args), ExprKind::Call(right_expr, right_args))
-            => mirrored_exprs(cx, left_expr, a_ident, right_expr, b_ident)
-                && left_args.iter().zip(right_args.iter()).all(|(left, right)| mirrored_exprs(cx, left, a_ident, right, b_ident)),
+            => {
+                // println!("{:?}\n{:?}\n", left_expr, left_args);
+                // println!("{:?}\n{:?}\n", right_expr, right_args);
+                mirrored_exprs(cx, left_expr, a_ident, right_expr, b_ident)
+                && left_args.iter().zip(right_args.iter()).all(|(left, right)| mirrored_exprs(cx, left, a_ident, right, b_ident))
+            },
         // The two exprs are method calls.
         // Check to see that the function is the same and the arguments are mirrored
         // This is enough because the receiver of the method is listed in the arguments
@@ -74,21 +78,17 @@ fn mirrored_exprs(cx: &LateContext<'_, '_>, a_expr: &Expr<'_>, a_ident: &Ident,
             => left_op == right_op && mirrored_exprs(cx, left_expr, a_ident, right_expr, b_ident),
         // The two exprs are literals of some kind
         (ExprKind::Lit(left_lit), ExprKind::Lit(right_lit)) => left_lit.node == right_lit.node,
-        (ExprKind::Cast(left_expr, _), ExprKind::Cast(right_expr, _))
+        (ExprKind::Cast(left_expr, left_ty), ExprKind::Cast(right_expr, right_ty))
             => mirrored_exprs(cx, left_expr, a_ident, right_expr, b_ident),
         (ExprKind::DropTemps(left), ExprKind::DropTemps(right)) => mirrored_exprs(cx, left, a_ident, right, b_ident),
-        (ExprKind::Block(left, _), ExprKind::Block(right, _)) => mirrored_blocks(cx, left, a_ident, right, b_ident),
         (ExprKind::Field(left_expr, left_ident), ExprKind::Field(right_expr, right_ident))
             => left_ident.name == right_ident.name && mirrored_exprs(cx, left_expr, a_ident, right_expr, right_ident),
-        // The two exprs are `a` and `b`, directly
-        (ExprKind::Path(QPath::Resolved(_, Path { segments: &[PathSegment { ident: left_ident, .. }], ..  },)),
-         ExprKind::Path(QPath::Resolved(_, Path { segments: &[PathSegment { ident: right_ident, .. }], ..  },)),
-        ) => &left_ident == a_ident && &right_ident == b_ident,
-        // The two exprs are Paths to the same name (which is neither a nor b)
+        // Two paths: either one is a and the other is b, or they're identical to each other
         (ExprKind::Path(QPath::Resolved(_, Path { segments: left_segments, .. })),
          ExprKind::Path(QPath::Resolved(_, Path { segments: right_segments, .. })))
-            => left_segments.iter().zip(right_segments.iter()).all(|(left, right)| left.ident == right.ident)
-                && left_segments.iter().all(|seg| &seg.ident != a_ident && &seg.ident != b_ident),
+            => (left_segments.iter().zip(right_segments.iter()).all(|(left, right)| left.ident == right.ident)
+                 && left_segments.iter().all(|seg| &seg.ident != a_ident && &seg.ident != b_ident))
+                || (left_segments.len() == 1 && &left_segments[0].ident == a_ident && right_segments.len() == 1 && &right_segments[0].ident == b_ident),
         // Matching expressions, but one or both is borrowed
         (ExprKind::AddrOf(left_kind, Mutability::Not, left_expr), ExprKind::AddrOf(right_kind, Mutability::Not, right_expr))
             => left_kind == right_kind && mirrored_exprs(cx, left_expr, a_ident, right_expr, b_ident),
@@ -96,43 +96,11 @@ fn mirrored_exprs(cx: &LateContext<'_, '_>, a_expr: &Expr<'_>, a_ident: &Ident,
             => mirrored_exprs(cx, a_expr, a_ident, right_expr, b_ident),
         (ExprKind::AddrOf(_, Mutability::Not, left_expr), _)
             => mirrored_exprs(cx, left_expr, a_ident, b_expr, b_ident),
-        // _ => false,
-        (left, right) => {
-            println!("{:?}\n{:?}", left, right);
-            false
-        },
-    }
-}
-
-/// Detect if the two blocks are mirrored (identical, except one
-/// contains a and the other replaces it with b)
-fn mirrored_blocks(cx: &LateContext<'_, '_>, a_block: &Block<'_>, a_ident: &Ident, b_block: &Block<'_>, b_ident: &Ident) -> bool {
-    match (a_block, b_block) {
-        (Block { stmts: left_stmts, expr: left_expr, .. },
-         Block { stmts: right_stmts, expr: right_expr, .. })
-            => left_stmts.iter().zip(right_stmts.iter()).all(|(left, right)| match (&left.kind, &right.kind) {
-                (StmtKind::Expr(left_expr), StmtKind::Expr(right_expr)) => mirrored_exprs(cx, left_expr, a_ident, right_expr, b_ident),
-                (StmtKind::Semi(left_expr), StmtKind::Semi(right_expr)) => mirrored_exprs(cx, left_expr, a_ident, right_expr, b_ident),
-                (StmtKind::Item(left_item), StmtKind::Item(right_item)) => left_item.id == right_item.id,
-                (StmtKind::Local(left), StmtKind::Local(right)) => mirrored_locals(cx, left, a_ident, right, b_ident),
-                _ => false,
-            }) && match (left_expr, right_expr) {
-                (None, None) => true,
-                (Some(left), Some(right)) => mirrored_exprs(cx, left, a_ident, right, b_ident),
-                _ => false,
-            },
-    }
-}
-
-/// Check that the two "Local"s (let statements) are equal
-fn mirrored_locals(cx: &LateContext<'_, '_>, a_local: &Local<'_>, a_ident: &Ident, b_local: &Local<'_>, b_ident: &Ident) -> bool {
-    match (a_local, b_local) {
-        (Local { pat: left_pat, init: left_expr, .. }, Local { pat: right_pat, init: right_expr, .. })
-            => match (left_expr, right_expr) {
-                (None, None) => true,
-                (Some(left), Some(right)) => mirrored_exprs(cx, left, a_ident, right, b_ident),
-                _ => false,
-            },
+        _ => false,
+        // (left, right) => {
+            // println!("{:?}\n{:?}", left, right);
+            // false
+        // },
     }
 }
 
@@ -154,8 +122,12 @@ fn detect_lint(cx: &LateContext<'_, '_>, expr: &Expr<'_>) -> Option<LintTrigger>
         then {
             let vec_name = Sugg::hir(cx, &args[0], "..").to_string();
             let unstable = name == "sort_unstable_by";
-            let closure_arg = a_ident.name.to_ident_string();
-            let closure_reverse_body = Sugg::hir(cx, &a_expr, "..").to_string();
+            let closure_arg = format!("&{}", b_ident.name.to_ident_string());
+            let closure_reverse_body = Sugg::hir(cx, &b_expr, "..").to_string();
+            // Get rid of parentheses, because they aren't needed anymore
+            // while closure_reverse_body.chars().next() == Some('(') && closure_reverse_body.chars().last() == Some(')') {
+                // closure_reverse_body = String::from(&closure_reverse_body[1..closure_reverse_body.len()-1]);
+            // }
             Some(LintTrigger { vec_name, unstable, closure_arg, closure_reverse_body })
         } else {
             None
diff --git a/tests/ui/sort_by_key_reverse.fixed b/tests/ui/sort_by_key_reverse.fixed
index 4b18a073e1a..d536dc385d5 100644
--- a/tests/ui/sort_by_key_reverse.fixed
+++ b/tests/ui/sort_by_key_reverse.fixed
@@ -1,9 +1,15 @@
 // run-rustfix
 #![warn(clippy::sort_by_key_reverse)]
 
+use std::cmp::Reverse;
+
+fn id(x: isize) -> isize {
+    x
+}
+
 fn main() {
     let mut vec: Vec<isize> = vec![3, 6, 1, 2, 5];
-    vec.sort_by_key(|a| Reverse(a));
-    vec.sort_by_key(|a| Reverse(&(a+5).abs()));
-    vec.sort_by_key(|a| Reverse(&-a));
+    vec.sort_by_key(|&b| Reverse(b));
+    vec.sort_by_key(|&b| Reverse((b + 5).abs()));
+    vec.sort_by_key(|&b| Reverse(id(-b)));
 }
diff --git a/tests/ui/sort_by_key_reverse.rs b/tests/ui/sort_by_key_reverse.rs
index f4fb70b7b1d..9c42d401755 100644
--- a/tests/ui/sort_by_key_reverse.rs
+++ b/tests/ui/sort_by_key_reverse.rs
@@ -1,9 +1,15 @@
 // run-rustfix
 #![warn(clippy::sort_by_key_reverse)]
 
+use std::cmp::Reverse;
+
+fn id(x: isize) -> isize {
+    x
+}
+
 fn main() {
     let mut vec: Vec<isize> = vec![3, 6, 1, 2, 5];
     vec.sort_by(|a, b| b.cmp(a));
     vec.sort_by(|a, b| (b + 5).abs().cmp(&(a+5).abs()));
-    vec.sort_by(|a, b| (-b).cmp(&-a));
+    vec.sort_by(|a, b| id(-b).cmp(&id(-a)));
 }
diff --git a/tests/ui/sort_by_key_reverse.stderr b/tests/ui/sort_by_key_reverse.stderr
index 36a28c04b1c..3d26ddae78a 100644
--- a/tests/ui/sort_by_key_reverse.stderr
+++ b/tests/ui/sort_by_key_reverse.stderr
@@ -1,22 +1,22 @@
 error: use Vec::sort_by_key here instead
-  --> $DIR/sort_by_key_reverse.rs:6:5
+  --> $DIR/sort_by_key_reverse.rs:12:5
    |
 LL |     vec.sort_by(|a, b| b.cmp(a));
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_by_key(|a| Reverse(a))`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_by_key(|&b| Reverse(b))`
    |
    = note: `-D clippy::sort-by-key-reverse` implied by `-D warnings`
 
 error: use Vec::sort_by_key here instead
-  --> $DIR/sort_by_key_reverse.rs:7:5
+  --> $DIR/sort_by_key_reverse.rs:13:5
    |
 LL |     vec.sort_by(|a, b| (b + 5).abs().cmp(&(a+5).abs()));
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_by_key(|a| Reverse(&(a+5).abs()))`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_by_key(|&b| Reverse((b + 5).abs()))`
 
 error: use Vec::sort_by_key here instead
-  --> $DIR/sort_by_key_reverse.rs:8:5
+  --> $DIR/sort_by_key_reverse.rs:14:5
    |
-LL |     vec.sort_by(|a, b| (-b).cmp(&-a));
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_by_key(|a| Reverse(&-a))`
+LL |     vec.sort_by(|a, b| id(-b).cmp(&id(-a)));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_by_key(|&b| Reverse(id(-b)))`
 
 error: aborting due to 3 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 955a25ee7db234a8ab697176a433070702aabe59 Mon Sep 17 00:00:00 2001
From: JarredAllen <jarredallen73@gmail.com>
Date: Wed, 20 May 2020 09:23:00 -0700
Subject: Added negative test cases and ran cargo dev fmt

---
 clippy_lints/src/sort_by_key_reverse.rs | 125 +++++++++++++++++++++-----------
 tests/ui/sort_by_key_reverse.fixed      |   7 ++
 tests/ui/sort_by_key_reverse.rs         |   9 ++-
 tests/ui/sort_by_key_reverse.stderr     |   4 +-
 4 files changed, 100 insertions(+), 45 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/sort_by_key_reverse.rs b/clippy_lints/src/sort_by_key_reverse.rs
index 31629a1dbc1..ea850955db1 100644
--- a/clippy_lints/src/sort_by_key_reverse.rs
+++ b/clippy_lints/src/sort_by_key_reverse.rs
@@ -3,7 +3,7 @@ use crate::utils::paths;
 use crate::utils::sugg::Sugg;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
-use rustc_hir::*;
+use rustc_hir::{Expr, ExprKind, Mutability, Param, Pat, PatKind, Path, QPath};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::symbol::Ident;
@@ -43,64 +43,105 @@ struct LintTrigger {
 
 /// Detect if the two expressions are mirrored (identical, except one
 /// contains a and the other replaces it with b)
-fn mirrored_exprs(cx: &LateContext<'_, '_>, a_expr: &Expr<'_>, a_ident: &Ident, b_expr: &Expr<'_>, b_ident: &Ident) -> bool {
+fn mirrored_exprs(
+    cx: &LateContext<'_, '_>,
+    a_expr: &Expr<'_>,
+    a_ident: &Ident,
+    b_expr: &Expr<'_>,
+    b_ident: &Ident,
+) -> bool {
     match (&a_expr.kind, &b_expr.kind) {
         // Two boxes with mirrored contents
-        (ExprKind::Box(left_expr), ExprKind::Box(right_expr)) => mirrored_exprs(cx, left_expr, a_ident, right_expr, b_ident),
+        (ExprKind::Box(left_expr), ExprKind::Box(right_expr)) => {
+            mirrored_exprs(cx, left_expr, a_ident, right_expr, b_ident)
+        },
         // Two arrays with mirrored contents
-        (ExprKind::Array(left_exprs), ExprKind::Array(right_exprs))
-            => left_exprs.iter().zip(right_exprs.iter()).all(|(left, right)| mirrored_exprs(cx, left, a_ident, right, b_ident)),
+        (ExprKind::Array(left_exprs), ExprKind::Array(right_exprs)) => left_exprs
+            .iter()
+            .zip(right_exprs.iter())
+            .all(|(left, right)| mirrored_exprs(cx, left, a_ident, right, b_ident)),
         // The two exprs are function calls.
         // Check to see that the function itself and its arguments are mirrored
-        (ExprKind::Call(left_expr, left_args), ExprKind::Call(right_expr, right_args))
-            => {
-                // println!("{:?}\n{:?}\n", left_expr, left_args);
-                // println!("{:?}\n{:?}\n", right_expr, right_args);
-                mirrored_exprs(cx, left_expr, a_ident, right_expr, b_ident)
-                && left_args.iter().zip(right_args.iter()).all(|(left, right)| mirrored_exprs(cx, left, a_ident, right, b_ident))
-            },
+        (ExprKind::Call(left_expr, left_args), ExprKind::Call(right_expr, right_args)) => {
+            mirrored_exprs(cx, left_expr, a_ident, right_expr, b_ident)
+                && left_args
+                    .iter()
+                    .zip(right_args.iter())
+                    .all(|(left, right)| mirrored_exprs(cx, left, a_ident, right, b_ident))
+        },
         // The two exprs are method calls.
         // Check to see that the function is the same and the arguments are mirrored
         // This is enough because the receiver of the method is listed in the arguments
-        (ExprKind::MethodCall(left_segment, _, left_args), ExprKind::MethodCall(right_segment, _, right_args))
-            => left_segment.ident == right_segment.ident
-                && left_args.iter().zip(right_args.iter()).all(|(left, right)| mirrored_exprs(cx, left, a_ident, right, b_ident)),
+        (ExprKind::MethodCall(left_segment, _, left_args), ExprKind::MethodCall(right_segment, _, right_args)) => {
+            left_segment.ident == right_segment.ident
+                && left_args
+                    .iter()
+                    .zip(right_args.iter())
+                    .all(|(left, right)| mirrored_exprs(cx, left, a_ident, right, b_ident))
+        },
         // Two tuples with mirrored contents
-        (ExprKind::Tup(left_exprs), ExprKind::Tup(right_exprs))
-            => left_exprs.iter().zip(right_exprs.iter()).all(|(left, right)| mirrored_exprs(cx, left, a_ident, right, b_ident)),
+        (ExprKind::Tup(left_exprs), ExprKind::Tup(right_exprs)) => left_exprs
+            .iter()
+            .zip(right_exprs.iter())
+            .all(|(left, right)| mirrored_exprs(cx, left, a_ident, right, b_ident)),
         // Two binary ops, which are the same operation and which have mirrored arguments
-        (ExprKind::Binary(left_op, left_left, left_right), ExprKind::Binary(right_op, right_left, right_right))
-            => left_op.node == right_op.node
+        (ExprKind::Binary(left_op, left_left, left_right), ExprKind::Binary(right_op, right_left, right_right)) => {
+            left_op.node == right_op.node
                 && mirrored_exprs(cx, left_left, a_ident, right_left, b_ident)
-                && mirrored_exprs(cx, left_right, a_ident, right_right, b_ident),
+                && mirrored_exprs(cx, left_right, a_ident, right_right, b_ident)
+        },
         // Two unary ops, which are the same operation and which have the same argument
-        (ExprKind::Unary(left_op, left_expr), ExprKind::Unary(right_op, right_expr))
-            => left_op == right_op && mirrored_exprs(cx, left_expr, a_ident, right_expr, b_ident),
+        (ExprKind::Unary(left_op, left_expr), ExprKind::Unary(right_op, right_expr)) => {
+            left_op == right_op && mirrored_exprs(cx, left_expr, a_ident, right_expr, b_ident)
+        },
         // The two exprs are literals of some kind
         (ExprKind::Lit(left_lit), ExprKind::Lit(right_lit)) => left_lit.node == right_lit.node,
-        (ExprKind::Cast(left_expr, left_ty), ExprKind::Cast(right_expr, right_ty))
-            => mirrored_exprs(cx, left_expr, a_ident, right_expr, b_ident),
-        (ExprKind::DropTemps(left), ExprKind::DropTemps(right)) => mirrored_exprs(cx, left, a_ident, right, b_ident),
-        (ExprKind::Field(left_expr, left_ident), ExprKind::Field(right_expr, right_ident))
-            => left_ident.name == right_ident.name && mirrored_exprs(cx, left_expr, a_ident, right_expr, right_ident),
+        (ExprKind::Cast(left, _), ExprKind::Cast(right, _)) => mirrored_exprs(cx, left, a_ident, right, b_ident),
+        (ExprKind::DropTemps(left_block), ExprKind::DropTemps(right_block)) => {
+            mirrored_exprs(cx, left_block, a_ident, right_block, b_ident)
+        },
+        (ExprKind::Field(left_expr, left_ident), ExprKind::Field(right_expr, right_ident)) => {
+            left_ident.name == right_ident.name && mirrored_exprs(cx, left_expr, a_ident, right_expr, right_ident)
+        },
         // Two paths: either one is a and the other is b, or they're identical to each other
-        (ExprKind::Path(QPath::Resolved(_, Path { segments: left_segments, .. })),
-         ExprKind::Path(QPath::Resolved(_, Path { segments: right_segments, .. })))
-            => (left_segments.iter().zip(right_segments.iter()).all(|(left, right)| left.ident == right.ident)
-                 && left_segments.iter().all(|seg| &seg.ident != a_ident && &seg.ident != b_ident))
-                || (left_segments.len() == 1 && &left_segments[0].ident == a_ident && right_segments.len() == 1 && &right_segments[0].ident == b_ident),
+        (
+            ExprKind::Path(QPath::Resolved(
+                _,
+                Path {
+                    segments: left_segments,
+                    ..
+                },
+            )),
+            ExprKind::Path(QPath::Resolved(
+                _,
+                Path {
+                    segments: right_segments,
+                    ..
+                },
+            )),
+        ) => {
+            (left_segments
+                .iter()
+                .zip(right_segments.iter())
+                .all(|(left, right)| left.ident == right.ident)
+                && left_segments
+                    .iter()
+                    .all(|seg| &seg.ident != a_ident && &seg.ident != b_ident))
+                || (left_segments.len() == 1
+                    && &left_segments[0].ident == a_ident
+                    && right_segments.len() == 1
+                    && &right_segments[0].ident == b_ident)
+        },
         // Matching expressions, but one or both is borrowed
-        (ExprKind::AddrOf(left_kind, Mutability::Not, left_expr), ExprKind::AddrOf(right_kind, Mutability::Not, right_expr))
-            => left_kind == right_kind && mirrored_exprs(cx, left_expr, a_ident, right_expr, b_ident),
-        (_, ExprKind::AddrOf(_, Mutability::Not, right_expr))
-            => mirrored_exprs(cx, a_expr, a_ident, right_expr, b_ident),
-        (ExprKind::AddrOf(_, Mutability::Not, left_expr), _)
-            => mirrored_exprs(cx, left_expr, a_ident, b_expr, b_ident),
+        (
+            ExprKind::AddrOf(left_kind, Mutability::Not, left_expr),
+            ExprKind::AddrOf(right_kind, Mutability::Not, right_expr),
+        ) => left_kind == right_kind && mirrored_exprs(cx, left_expr, a_ident, right_expr, b_ident),
+        (_, ExprKind::AddrOf(_, Mutability::Not, right_expr)) => {
+            mirrored_exprs(cx, a_expr, a_ident, right_expr, b_ident)
+        },
+        (ExprKind::AddrOf(_, Mutability::Not, left_expr), _) => mirrored_exprs(cx, left_expr, a_ident, b_expr, b_ident),
         _ => false,
-        // (left, right) => {
-            // println!("{:?}\n{:?}", left, right);
-            // false
-        // },
     }
 }
 
diff --git a/tests/ui/sort_by_key_reverse.fixed b/tests/ui/sort_by_key_reverse.fixed
index d536dc385d5..722675a6b71 100644
--- a/tests/ui/sort_by_key_reverse.fixed
+++ b/tests/ui/sort_by_key_reverse.fixed
@@ -12,4 +12,11 @@ fn main() {
     vec.sort_by_key(|&b| Reverse(b));
     vec.sort_by_key(|&b| Reverse((b + 5).abs()));
     vec.sort_by_key(|&b| Reverse(id(-b)));
+    // Negative examples (shouldn't be changed)
+    let c = &7;
+    vec.sort_by(|a, b| (b - a).cmp(&(a - b)));
+    vec.sort_by(|_, b| b.cmp(&5));
+    vec.sort_by(|_, b| b.cmp(c));
+    vec.sort_by(|a, _| a.cmp(c));
+    vec.sort_by(|a, b| a.cmp(b));
 }
diff --git a/tests/ui/sort_by_key_reverse.rs b/tests/ui/sort_by_key_reverse.rs
index 9c42d401755..601621ffa9f 100644
--- a/tests/ui/sort_by_key_reverse.rs
+++ b/tests/ui/sort_by_key_reverse.rs
@@ -10,6 +10,13 @@ fn id(x: isize) -> isize {
 fn main() {
     let mut vec: Vec<isize> = vec![3, 6, 1, 2, 5];
     vec.sort_by(|a, b| b.cmp(a));
-    vec.sort_by(|a, b| (b + 5).abs().cmp(&(a+5).abs()));
+    vec.sort_by(|a, b| (b + 5).abs().cmp(&(a + 5).abs()));
     vec.sort_by(|a, b| id(-b).cmp(&id(-a)));
+    // Negative examples (shouldn't be changed)
+    let c = &7;
+    vec.sort_by(|a, b| (b - a).cmp(&(a - b)));
+    vec.sort_by(|_, b| b.cmp(&5));
+    vec.sort_by(|_, b| b.cmp(c));
+    vec.sort_by(|a, _| a.cmp(c));
+    vec.sort_by(|a, b| a.cmp(b));
 }
diff --git a/tests/ui/sort_by_key_reverse.stderr b/tests/ui/sort_by_key_reverse.stderr
index 3d26ddae78a..b757c8a6176 100644
--- a/tests/ui/sort_by_key_reverse.stderr
+++ b/tests/ui/sort_by_key_reverse.stderr
@@ -9,8 +9,8 @@ LL |     vec.sort_by(|a, b| b.cmp(a));
 error: use Vec::sort_by_key here instead
   --> $DIR/sort_by_key_reverse.rs:13:5
    |
-LL |     vec.sort_by(|a, b| (b + 5).abs().cmp(&(a+5).abs()));
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_by_key(|&b| Reverse((b + 5).abs()))`
+LL |     vec.sort_by(|a, b| (b + 5).abs().cmp(&(a + 5).abs()));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_by_key(|&b| Reverse((b + 5).abs()))`
 
 error: use Vec::sort_by_key here instead
   --> $DIR/sort_by_key_reverse.rs:14:5
-- 
cgit 1.4.1-3-g733a5


From 059e8edd15401d5544260e4058731dc8818578d5 Mon Sep 17 00:00:00 2001
From: JarredAllen <jarredallen73@gmail.com>
Date: Sun, 24 May 2020 19:45:41 -0700
Subject: Detect also a non-reversed comparison

---
 clippy_lints/src/lib.rs                 |  10 +-
 clippy_lints/src/sort_by_key.rs         | 207 ++++++++++++++++++++++++++++++++
 clippy_lints/src/sort_by_key_reverse.rs | 199 ------------------------------
 tests/ui/sort_by_key.fixed              |  26 ++++
 tests/ui/sort_by_key.rs                 |  26 ++++
 tests/ui/sort_by_key.stderr             |  48 ++++++++
 tests/ui/sort_by_key_reverse.fixed      |  22 ----
 tests/ui/sort_by_key_reverse.rs         |  22 ----
 tests/ui/sort_by_key_reverse.stderr     |  22 ----
 9 files changed, 312 insertions(+), 270 deletions(-)
 create mode 100644 clippy_lints/src/sort_by_key.rs
 delete mode 100644 clippy_lints/src/sort_by_key_reverse.rs
 create mode 100644 tests/ui/sort_by_key.fixed
 create mode 100644 tests/ui/sort_by_key.rs
 create mode 100644 tests/ui/sort_by_key.stderr
 delete mode 100644 tests/ui/sort_by_key_reverse.fixed
 delete mode 100644 tests/ui/sort_by_key_reverse.rs
 delete mode 100644 tests/ui/sort_by_key_reverse.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index e7a4c1ecaa9..9e826316f21 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -304,7 +304,7 @@ mod serde_api;
 mod shadow;
 mod single_component_path_imports;
 mod slow_vector_initialization;
-mod sort_by_key_reverse;
+mod sort_by_key;
 mod strings;
 mod suspicious_trait_impl;
 mod swap;
@@ -780,7 +780,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &shadow::SHADOW_UNRELATED,
         &single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS,
         &slow_vector_initialization::SLOW_VECTOR_INITIALIZATION,
-        &sort_by_key_reverse::SORT_BY_KEY_REVERSE,
+        &sort_by_key::SORT_BY_KEY,
         &strings::STRING_ADD,
         &strings::STRING_ADD_ASSIGN,
         &strings::STRING_LIT_AS_BYTES,
@@ -998,7 +998,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box ptr_offset_with_cast::PtrOffsetWithCast);
     store.register_late_pass(|| box redundant_clone::RedundantClone);
     store.register_late_pass(|| box slow_vector_initialization::SlowVectorInit);
-    store.register_late_pass(|| box sort_by_key_reverse::SortByKeyReverse);
+    store.register_late_pass(|| box sort_by_key::SortByKey);
     store.register_late_pass(|| box types::RefToMut);
     store.register_late_pass(|| box assertions_on_constants::AssertionsOnConstants);
     store.register_late_pass(|| box missing_const_for_fn::MissingConstForFn);
@@ -1394,7 +1394,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&serde_api::SERDE_API_MISUSE),
         LintId::of(&single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS),
         LintId::of(&slow_vector_initialization::SLOW_VECTOR_INITIALIZATION),
-        LintId::of(&sort_by_key_reverse::SORT_BY_KEY_REVERSE),
+        LintId::of(&sort_by_key::SORT_BY_KEY),
         LintId::of(&strings::STRING_LIT_AS_BYTES),
         LintId::of(&suspicious_trait_impl::SUSPICIOUS_ARITHMETIC_IMPL),
         LintId::of(&suspicious_trait_impl::SUSPICIOUS_OP_ASSIGN_IMPL),
@@ -1596,7 +1596,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&ranges::RANGE_ZIP_WITH_LEN),
         LintId::of(&reference::DEREF_ADDROF),
         LintId::of(&reference::REF_IN_DEREF),
-        LintId::of(&sort_by_key_reverse::SORT_BY_KEY_REVERSE),
+        LintId::of(&sort_by_key::SORT_BY_KEY),
         LintId::of(&swap::MANUAL_SWAP),
         LintId::of(&temporary_assignment::TEMPORARY_ASSIGNMENT),
         LintId::of(&transmute::CROSSPOINTER_TRANSMUTE),
diff --git a/clippy_lints/src/sort_by_key.rs b/clippy_lints/src/sort_by_key.rs
new file mode 100644
index 00000000000..109845a28f4
--- /dev/null
+++ b/clippy_lints/src/sort_by_key.rs
@@ -0,0 +1,207 @@
+use crate::utils;
+use crate::utils::paths;
+use crate::utils::sugg::Sugg;
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind, Mutability, Param, Pat, PatKind, Path, QPath};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::symbol::Ident;
+
+declare_clippy_lint! {
+    /// **What it does:**
+    /// Detects when people use `Vec::sort_by` and pass in a function
+    /// which compares the two arguments, either directly or indirectly.
+    ///
+    /// **Why is this bad?**
+    /// It is more clear to use `Vec::sort_by_key` (or
+    /// `Vec::sort_by_key` and `std::cmp::Reverse` if necessary) than
+    /// using 
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// vec.sort_by(|a, b| a.foo().cmp(b.foo()));
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// vec.sort_by_key(|a| a.foo());
+    /// ```
+    pub SORT_BY_KEY,
+    complexity,
+    "Use of `Vec::sort_by` when `Vec::sort_by_key` would be clearer"
+}
+
+declare_lint_pass!(SortByKey => [SORT_BY_KEY]);
+
+struct LintTrigger {
+    vec_name: String,
+    closure_arg: String,
+    closure_body: String,
+    unstable: bool,
+}
+
+/// Detect if the two expressions are mirrored (identical, except one
+/// contains a and the other replaces it with b)
+fn mirrored_exprs(
+    cx: &LateContext<'_, '_>,
+    a_expr: &Expr<'_>,
+    a_ident: &Ident,
+    b_expr: &Expr<'_>,
+    b_ident: &Ident,
+) -> bool {
+    match (&a_expr.kind, &b_expr.kind) {
+        // Two boxes with mirrored contents
+        (ExprKind::Box(left_expr), ExprKind::Box(right_expr)) => {
+            mirrored_exprs(cx, left_expr, a_ident, right_expr, b_ident)
+        },
+        // Two arrays with mirrored contents
+        (ExprKind::Array(left_exprs), ExprKind::Array(right_exprs)) => left_exprs
+            .iter()
+            .zip(right_exprs.iter())
+            .all(|(left, right)| mirrored_exprs(cx, left, a_ident, right, b_ident)),
+        // The two exprs are function calls.
+        // Check to see that the function itself and its arguments are mirrored
+        (ExprKind::Call(left_expr, left_args), ExprKind::Call(right_expr, right_args)) => {
+            mirrored_exprs(cx, left_expr, a_ident, right_expr, b_ident)
+                && left_args
+                    .iter()
+                    .zip(right_args.iter())
+                    .all(|(left, right)| mirrored_exprs(cx, left, a_ident, right, b_ident))
+        },
+        // The two exprs are method calls.
+        // Check to see that the function is the same and the arguments are mirrored
+        // This is enough because the receiver of the method is listed in the arguments
+        (ExprKind::MethodCall(left_segment, _, left_args), ExprKind::MethodCall(right_segment, _, right_args)) => {
+            left_segment.ident == right_segment.ident
+                && left_args
+                    .iter()
+                    .zip(right_args.iter())
+                    .all(|(left, right)| mirrored_exprs(cx, left, a_ident, right, b_ident))
+        },
+        // Two tuples with mirrored contents
+        (ExprKind::Tup(left_exprs), ExprKind::Tup(right_exprs)) => left_exprs
+            .iter()
+            .zip(right_exprs.iter())
+            .all(|(left, right)| mirrored_exprs(cx, left, a_ident, right, b_ident)),
+        // Two binary ops, which are the same operation and which have mirrored arguments
+        (ExprKind::Binary(left_op, left_left, left_right), ExprKind::Binary(right_op, right_left, right_right)) => {
+            left_op.node == right_op.node
+                && mirrored_exprs(cx, left_left, a_ident, right_left, b_ident)
+                && mirrored_exprs(cx, left_right, a_ident, right_right, b_ident)
+        },
+        // Two unary ops, which are the same operation and which have the same argument
+        (ExprKind::Unary(left_op, left_expr), ExprKind::Unary(right_op, right_expr)) => {
+            left_op == right_op && mirrored_exprs(cx, left_expr, a_ident, right_expr, b_ident)
+        },
+        // The two exprs are literals of some kind
+        (ExprKind::Lit(left_lit), ExprKind::Lit(right_lit)) => left_lit.node == right_lit.node,
+        (ExprKind::Cast(left, _), ExprKind::Cast(right, _)) => mirrored_exprs(cx, left, a_ident, right, b_ident),
+        (ExprKind::DropTemps(left_block), ExprKind::DropTemps(right_block)) => {
+            mirrored_exprs(cx, left_block, a_ident, right_block, b_ident)
+        },
+        (ExprKind::Field(left_expr, left_ident), ExprKind::Field(right_expr, right_ident)) => {
+            left_ident.name == right_ident.name && mirrored_exprs(cx, left_expr, a_ident, right_expr, right_ident)
+        },
+        // Two paths: either one is a and the other is b, or they're identical to each other
+        (
+            ExprKind::Path(QPath::Resolved(
+                _,
+                Path {
+                    segments: left_segments,
+                    ..
+                },
+            )),
+            ExprKind::Path(QPath::Resolved(
+                _,
+                Path {
+                    segments: right_segments,
+                    ..
+                },
+            )),
+        ) => {
+            (left_segments
+                .iter()
+                .zip(right_segments.iter())
+                .all(|(left, right)| left.ident == right.ident)
+                && left_segments
+                    .iter()
+                    .all(|seg| &seg.ident != a_ident && &seg.ident != b_ident))
+                || (left_segments.len() == 1
+                    && &left_segments[0].ident == a_ident
+                    && right_segments.len() == 1
+                    && &right_segments[0].ident == b_ident)
+        },
+        // Matching expressions, but one or both is borrowed
+        (
+            ExprKind::AddrOf(left_kind, Mutability::Not, left_expr),
+            ExprKind::AddrOf(right_kind, Mutability::Not, right_expr),
+        ) => left_kind == right_kind && mirrored_exprs(cx, left_expr, a_ident, right_expr, b_ident),
+        (_, ExprKind::AddrOf(_, Mutability::Not, right_expr)) => {
+            mirrored_exprs(cx, a_expr, a_ident, right_expr, b_ident)
+        },
+        (ExprKind::AddrOf(_, Mutability::Not, left_expr), _) => mirrored_exprs(cx, left_expr, a_ident, b_expr, b_ident),
+        _ => false,
+    }
+}
+
+fn detect_lint(cx: &LateContext<'_, '_>, expr: &Expr<'_>) -> Option<LintTrigger> {
+    if_chain! {
+        if let ExprKind::MethodCall(name_ident, _, args) = &expr.kind;
+        if let name = name_ident.ident.name.to_ident_string();
+        if name == "sort_by" || name == "sort_unstable_by";
+        if let [vec, Expr { kind: ExprKind::Closure(_, _, closure_body_id, _, _), .. }] = args;
+        if utils::match_type(cx, &cx.tables.expr_ty(vec), &paths::VEC);
+        if let closure_body = cx.tcx.hir().body(*closure_body_id);
+        if let &[
+            Param { pat: Pat { kind: PatKind::Binding(_, _, left_ident, _), .. }, ..},
+            Param { pat: Pat { kind: PatKind::Binding(_, _, right_ident, _), .. }, .. }
+        ] = &closure_body.params;
+        if let ExprKind::MethodCall(method_path, _, [ref left_expr, ref right_expr]) = &closure_body.value.kind;
+        if method_path.ident.name.to_ident_string() == "cmp";
+        then {
+            let (closure_body, closure_arg) = if mirrored_exprs(
+                &cx,
+                &left_expr,
+                &left_ident,
+                &right_expr,
+                &right_ident
+            ) {
+                (Sugg::hir(cx, &left_expr, "..").to_string(), left_ident.name.to_string())
+            } else if mirrored_exprs(&cx, &left_expr, &right_ident, &right_expr, &left_ident) {
+                (format!("Reverse({})", Sugg::hir(cx, &left_expr, "..").to_string()), right_ident.name.to_string())
+            } else {
+                return None;
+            };
+            let vec_name = Sugg::hir(cx, &args[0], "..").to_string();
+            let unstable = name == "sort_unstable_by";
+            Some(LintTrigger { vec_name, unstable, closure_arg, closure_body })
+        } else {
+            None
+        }
+    }
+}
+
+impl LateLintPass<'_, '_> for SortByKey {
+    fn check_expr(&mut self, cx: &LateContext<'_, '_>, expr: &Expr<'_>) {
+        if let Some(trigger) = detect_lint(cx, expr) {
+            utils::span_lint_and_sugg(
+                cx,
+                SORT_BY_KEY,
+                expr.span,
+                "use Vec::sort_by_key here instead",
+                "try",
+                format!(
+                    "{}.sort{}_by_key(|&{}| {})",
+                    trigger.vec_name,
+                    if trigger.unstable { "_unstable" } else { "" },
+                    trigger.closure_arg,
+                    trigger.closure_body,
+                ),
+                Applicability::MachineApplicable,
+            );
+        }
+    }
+}
diff --git a/clippy_lints/src/sort_by_key_reverse.rs b/clippy_lints/src/sort_by_key_reverse.rs
deleted file mode 100644
index ea850955db1..00000000000
--- a/clippy_lints/src/sort_by_key_reverse.rs
+++ /dev/null
@@ -1,199 +0,0 @@
-use crate::utils;
-use crate::utils::paths;
-use crate::utils::sugg::Sugg;
-use if_chain::if_chain;
-use rustc_errors::Applicability;
-use rustc_hir::{Expr, ExprKind, Mutability, Param, Pat, PatKind, Path, QPath};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::symbol::Ident;
-
-declare_clippy_lint! {
-    /// **What it does:**
-    /// Detects when people use `Vec::sort_by` and pass in a function
-    /// which compares the second argument to the first.
-    ///
-    /// **Why is this bad?**
-    /// It is more clear to use `Vec::sort_by_key` and `std::cmp::Reverse`
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
-    /// ```rust
-    /// vec.sort_by(|a, b| b.foo().cmp(&a.foo()));
-    /// ```
-    /// Use instead:
-    /// ```rust
-    /// vec.sort_by_key(|e| Reverse(e.foo()));
-    /// ```
-    pub SORT_BY_KEY_REVERSE,
-    complexity,
-    "Use of `Vec::sort_by` when `Vec::sort_by_key` would be clearer"
-}
-
-declare_lint_pass!(SortByKeyReverse => [SORT_BY_KEY_REVERSE]);
-
-struct LintTrigger {
-    vec_name: String,
-    closure_arg: String,
-    closure_reverse_body: String,
-    unstable: bool,
-}
-
-/// Detect if the two expressions are mirrored (identical, except one
-/// contains a and the other replaces it with b)
-fn mirrored_exprs(
-    cx: &LateContext<'_, '_>,
-    a_expr: &Expr<'_>,
-    a_ident: &Ident,
-    b_expr: &Expr<'_>,
-    b_ident: &Ident,
-) -> bool {
-    match (&a_expr.kind, &b_expr.kind) {
-        // Two boxes with mirrored contents
-        (ExprKind::Box(left_expr), ExprKind::Box(right_expr)) => {
-            mirrored_exprs(cx, left_expr, a_ident, right_expr, b_ident)
-        },
-        // Two arrays with mirrored contents
-        (ExprKind::Array(left_exprs), ExprKind::Array(right_exprs)) => left_exprs
-            .iter()
-            .zip(right_exprs.iter())
-            .all(|(left, right)| mirrored_exprs(cx, left, a_ident, right, b_ident)),
-        // The two exprs are function calls.
-        // Check to see that the function itself and its arguments are mirrored
-        (ExprKind::Call(left_expr, left_args), ExprKind::Call(right_expr, right_args)) => {
-            mirrored_exprs(cx, left_expr, a_ident, right_expr, b_ident)
-                && left_args
-                    .iter()
-                    .zip(right_args.iter())
-                    .all(|(left, right)| mirrored_exprs(cx, left, a_ident, right, b_ident))
-        },
-        // The two exprs are method calls.
-        // Check to see that the function is the same and the arguments are mirrored
-        // This is enough because the receiver of the method is listed in the arguments
-        (ExprKind::MethodCall(left_segment, _, left_args), ExprKind::MethodCall(right_segment, _, right_args)) => {
-            left_segment.ident == right_segment.ident
-                && left_args
-                    .iter()
-                    .zip(right_args.iter())
-                    .all(|(left, right)| mirrored_exprs(cx, left, a_ident, right, b_ident))
-        },
-        // Two tuples with mirrored contents
-        (ExprKind::Tup(left_exprs), ExprKind::Tup(right_exprs)) => left_exprs
-            .iter()
-            .zip(right_exprs.iter())
-            .all(|(left, right)| mirrored_exprs(cx, left, a_ident, right, b_ident)),
-        // Two binary ops, which are the same operation and which have mirrored arguments
-        (ExprKind::Binary(left_op, left_left, left_right), ExprKind::Binary(right_op, right_left, right_right)) => {
-            left_op.node == right_op.node
-                && mirrored_exprs(cx, left_left, a_ident, right_left, b_ident)
-                && mirrored_exprs(cx, left_right, a_ident, right_right, b_ident)
-        },
-        // Two unary ops, which are the same operation and which have the same argument
-        (ExprKind::Unary(left_op, left_expr), ExprKind::Unary(right_op, right_expr)) => {
-            left_op == right_op && mirrored_exprs(cx, left_expr, a_ident, right_expr, b_ident)
-        },
-        // The two exprs are literals of some kind
-        (ExprKind::Lit(left_lit), ExprKind::Lit(right_lit)) => left_lit.node == right_lit.node,
-        (ExprKind::Cast(left, _), ExprKind::Cast(right, _)) => mirrored_exprs(cx, left, a_ident, right, b_ident),
-        (ExprKind::DropTemps(left_block), ExprKind::DropTemps(right_block)) => {
-            mirrored_exprs(cx, left_block, a_ident, right_block, b_ident)
-        },
-        (ExprKind::Field(left_expr, left_ident), ExprKind::Field(right_expr, right_ident)) => {
-            left_ident.name == right_ident.name && mirrored_exprs(cx, left_expr, a_ident, right_expr, right_ident)
-        },
-        // Two paths: either one is a and the other is b, or they're identical to each other
-        (
-            ExprKind::Path(QPath::Resolved(
-                _,
-                Path {
-                    segments: left_segments,
-                    ..
-                },
-            )),
-            ExprKind::Path(QPath::Resolved(
-                _,
-                Path {
-                    segments: right_segments,
-                    ..
-                },
-            )),
-        ) => {
-            (left_segments
-                .iter()
-                .zip(right_segments.iter())
-                .all(|(left, right)| left.ident == right.ident)
-                && left_segments
-                    .iter()
-                    .all(|seg| &seg.ident != a_ident && &seg.ident != b_ident))
-                || (left_segments.len() == 1
-                    && &left_segments[0].ident == a_ident
-                    && right_segments.len() == 1
-                    && &right_segments[0].ident == b_ident)
-        },
-        // Matching expressions, but one or both is borrowed
-        (
-            ExprKind::AddrOf(left_kind, Mutability::Not, left_expr),
-            ExprKind::AddrOf(right_kind, Mutability::Not, right_expr),
-        ) => left_kind == right_kind && mirrored_exprs(cx, left_expr, a_ident, right_expr, b_ident),
-        (_, ExprKind::AddrOf(_, Mutability::Not, right_expr)) => {
-            mirrored_exprs(cx, a_expr, a_ident, right_expr, b_ident)
-        },
-        (ExprKind::AddrOf(_, Mutability::Not, left_expr), _) => mirrored_exprs(cx, left_expr, a_ident, b_expr, b_ident),
-        _ => false,
-    }
-}
-
-fn detect_lint(cx: &LateContext<'_, '_>, expr: &Expr<'_>) -> Option<LintTrigger> {
-    if_chain! {
-        if let ExprKind::MethodCall(name_ident, _, args) = &expr.kind;
-        if let name = name_ident.ident.name.to_ident_string();
-        if name == "sort_by" || name == "sort_unstable_by";
-        if let [vec, Expr { kind: ExprKind::Closure(_, _, closure_body_id, _, _), .. }] = args;
-        if utils::match_type(cx, &cx.tables.expr_ty(vec), &paths::VEC);
-        if let closure_body = cx.tcx.hir().body(*closure_body_id);
-        if let &[
-            Param { pat: Pat { kind: PatKind::Binding(_, _, a_ident, _), .. }, ..},
-            Param { pat: Pat { kind: PatKind::Binding(_, _, b_ident, _), .. }, .. }
-        ] = &closure_body.params;
-        if let ExprKind::MethodCall(method_path, _, [ref b_expr, ref a_expr]) = &closure_body.value.kind;
-        if method_path.ident.name.to_ident_string() == "cmp";
-        if mirrored_exprs(&cx, &a_expr, &a_ident, &b_expr, &b_ident);
-        then {
-            let vec_name = Sugg::hir(cx, &args[0], "..").to_string();
-            let unstable = name == "sort_unstable_by";
-            let closure_arg = format!("&{}", b_ident.name.to_ident_string());
-            let closure_reverse_body = Sugg::hir(cx, &b_expr, "..").to_string();
-            // Get rid of parentheses, because they aren't needed anymore
-            // while closure_reverse_body.chars().next() == Some('(') && closure_reverse_body.chars().last() == Some(')') {
-                // closure_reverse_body = String::from(&closure_reverse_body[1..closure_reverse_body.len()-1]);
-            // }
-            Some(LintTrigger { vec_name, unstable, closure_arg, closure_reverse_body })
-        } else {
-            None
-        }
-    }
-}
-
-impl LateLintPass<'_, '_> for SortByKeyReverse {
-    fn check_expr(&mut self, cx: &LateContext<'_, '_>, expr: &Expr<'_>) {
-        if let Some(trigger) = detect_lint(cx, expr) {
-            utils::span_lint_and_sugg(
-                cx,
-                SORT_BY_KEY_REVERSE,
-                expr.span,
-                "use Vec::sort_by_key here instead",
-                "try",
-                format!(
-                    "{}.sort{}_by_key(|{}| Reverse({}))",
-                    trigger.vec_name,
-                    if trigger.unstable { "_unstable" } else { "" },
-                    trigger.closure_arg,
-                    trigger.closure_reverse_body,
-                ),
-                Applicability::MachineApplicable,
-            );
-        }
-    }
-}
diff --git a/tests/ui/sort_by_key.fixed b/tests/ui/sort_by_key.fixed
new file mode 100644
index 00000000000..f6535c8d8f5
--- /dev/null
+++ b/tests/ui/sort_by_key.fixed
@@ -0,0 +1,26 @@
+// run-rustfix
+#![warn(clippy::sort_by_key)]
+
+use std::cmp::Reverse;
+
+fn id(x: isize) -> isize {
+    x
+}
+
+fn main() {
+    let mut vec: Vec<isize> = vec![3, 6, 1, 2, 5];
+    // Forward examples
+    vec.sort_by_key(|&a| a);
+    vec.sort_by_key(|&a| (a + 5).abs());
+    vec.sort_by_key(|&a| id(-a));
+    // Reverse examples
+    vec.sort_by_key(|&b| Reverse(b));
+    vec.sort_by_key(|&b| Reverse((b + 5).abs()));
+    vec.sort_by_key(|&b| Reverse(id(-b)));
+    // Negative examples (shouldn't be changed)
+    let c = &7;
+    vec.sort_by(|a, b| (b - a).cmp(&(a - b)));
+    vec.sort_by(|_, b| b.cmp(&5));
+    vec.sort_by(|_, b| b.cmp(c));
+    vec.sort_by(|a, _| a.cmp(c));
+}
diff --git a/tests/ui/sort_by_key.rs b/tests/ui/sort_by_key.rs
new file mode 100644
index 00000000000..953c573d406
--- /dev/null
+++ b/tests/ui/sort_by_key.rs
@@ -0,0 +1,26 @@
+// run-rustfix
+#![warn(clippy::sort_by_key_reverse)]
+
+use std::cmp::Reverse;
+
+fn id(x: isize) -> isize {
+    x
+}
+
+fn main() {
+    let mut vec: Vec<isize> = vec![3, 6, 1, 2, 5];
+    // Forward examples
+    vec.sort_by(|a, b| a.cmp(b));
+    vec.sort_by(|a, b| (a + 5).abs().cmp(&(b + 5).abs()));
+    vec.sort_by(|a, b| id(-a).cmp(&id(-b)));
+    // Reverse examples
+    vec.sort_by(|a, b| b.cmp(a));
+    vec.sort_by(|a, b| (b + 5).abs().cmp(&(a + 5).abs()));
+    vec.sort_by(|a, b| id(-b).cmp(&id(-a)));
+    // Negative examples (shouldn't be changed)
+    let c = &7;
+    vec.sort_by(|a, b| (b - a).cmp(&(a - b)));
+    vec.sort_by(|_, b| b.cmp(&5));
+    vec.sort_by(|_, b| b.cmp(c));
+    vec.sort_by(|a, _| a.cmp(c));
+}
diff --git a/tests/ui/sort_by_key.stderr b/tests/ui/sort_by_key.stderr
new file mode 100644
index 00000000000..fa6a9a0fb10
--- /dev/null
+++ b/tests/ui/sort_by_key.stderr
@@ -0,0 +1,48 @@
+error: use Vec::sort_by_key here instead
+  --> $DIR/sort_by_key.rs:13:5
+   |
+LL |     vec.sort_by(|a, b| a.cmp(b));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_by_key(|&a| a)`
+   |
+   = note: `-D clippy::sort-by-key` implied by `-D warnings`
+
+error: use Vec::sort_by_key here instead
+  --> $DIR/sort_by_key.rs:14:5
+   |
+LL |     vec.sort_by(|a, b| (a + 5).abs().cmp(&(b + 5).abs()));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_by_key(|&a| (a + 5).abs())`
+
+error: use Vec::sort_by_key here instead
+  --> $DIR/sort_by_key.rs:15:5
+   |
+LL |     vec.sort_by(|a, b| id(-a).cmp(&id(-b)));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_by_key(|&a| id(-a))`
+
+error: use Vec::sort_by_key here instead
+  --> $DIR/sort_by_key.rs:17:5
+   |
+LL |     vec.sort_by(|a, b| b.cmp(a));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_by_key(|&b| Reverse(b))`
+
+error: use Vec::sort_by_key here instead
+  --> $DIR/sort_by_key.rs:18:5
+   |
+LL |     vec.sort_by(|a, b| (b + 5).abs().cmp(&(a + 5).abs()));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_by_key(|&b| Reverse((b + 5).abs()))`
+
+error: use Vec::sort_by_key here instead
+  --> $DIR/sort_by_key.rs:19:5
+   |
+LL |     vec.sort_by(|a, b| id(-b).cmp(&id(-a)));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_by_key(|&b| Reverse(id(-b)))`
+
+error: unknown clippy lint: clippy::sort_by_key_reverse
+  --> $DIR/sort_by_key.rs:2:9
+   |
+LL | #![warn(clippy::sort_by_key_reverse)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: did you mean: `clippy::sort_by_key`
+   |
+   = note: `-D clippy::unknown-clippy-lints` implied by `-D warnings`
+
+error: aborting due to 7 previous errors
+
diff --git a/tests/ui/sort_by_key_reverse.fixed b/tests/ui/sort_by_key_reverse.fixed
deleted file mode 100644
index 722675a6b71..00000000000
--- a/tests/ui/sort_by_key_reverse.fixed
+++ /dev/null
@@ -1,22 +0,0 @@
-// run-rustfix
-#![warn(clippy::sort_by_key_reverse)]
-
-use std::cmp::Reverse;
-
-fn id(x: isize) -> isize {
-    x
-}
-
-fn main() {
-    let mut vec: Vec<isize> = vec![3, 6, 1, 2, 5];
-    vec.sort_by_key(|&b| Reverse(b));
-    vec.sort_by_key(|&b| Reverse((b + 5).abs()));
-    vec.sort_by_key(|&b| Reverse(id(-b)));
-    // Negative examples (shouldn't be changed)
-    let c = &7;
-    vec.sort_by(|a, b| (b - a).cmp(&(a - b)));
-    vec.sort_by(|_, b| b.cmp(&5));
-    vec.sort_by(|_, b| b.cmp(c));
-    vec.sort_by(|a, _| a.cmp(c));
-    vec.sort_by(|a, b| a.cmp(b));
-}
diff --git a/tests/ui/sort_by_key_reverse.rs b/tests/ui/sort_by_key_reverse.rs
deleted file mode 100644
index 601621ffa9f..00000000000
--- a/tests/ui/sort_by_key_reverse.rs
+++ /dev/null
@@ -1,22 +0,0 @@
-// run-rustfix
-#![warn(clippy::sort_by_key_reverse)]
-
-use std::cmp::Reverse;
-
-fn id(x: isize) -> isize {
-    x
-}
-
-fn main() {
-    let mut vec: Vec<isize> = vec![3, 6, 1, 2, 5];
-    vec.sort_by(|a, b| b.cmp(a));
-    vec.sort_by(|a, b| (b + 5).abs().cmp(&(a + 5).abs()));
-    vec.sort_by(|a, b| id(-b).cmp(&id(-a)));
-    // Negative examples (shouldn't be changed)
-    let c = &7;
-    vec.sort_by(|a, b| (b - a).cmp(&(a - b)));
-    vec.sort_by(|_, b| b.cmp(&5));
-    vec.sort_by(|_, b| b.cmp(c));
-    vec.sort_by(|a, _| a.cmp(c));
-    vec.sort_by(|a, b| a.cmp(b));
-}
diff --git a/tests/ui/sort_by_key_reverse.stderr b/tests/ui/sort_by_key_reverse.stderr
deleted file mode 100644
index b757c8a6176..00000000000
--- a/tests/ui/sort_by_key_reverse.stderr
+++ /dev/null
@@ -1,22 +0,0 @@
-error: use Vec::sort_by_key here instead
-  --> $DIR/sort_by_key_reverse.rs:12:5
-   |
-LL |     vec.sort_by(|a, b| b.cmp(a));
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_by_key(|&b| Reverse(b))`
-   |
-   = note: `-D clippy::sort-by-key-reverse` implied by `-D warnings`
-
-error: use Vec::sort_by_key here instead
-  --> $DIR/sort_by_key_reverse.rs:13:5
-   |
-LL |     vec.sort_by(|a, b| (b + 5).abs().cmp(&(a + 5).abs()));
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_by_key(|&b| Reverse((b + 5).abs()))`
-
-error: use Vec::sort_by_key here instead
-  --> $DIR/sort_by_key_reverse.rs:14:5
-   |
-LL |     vec.sort_by(|a, b| id(-b).cmp(&id(-a)));
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_by_key(|&b| Reverse(id(-b)))`
-
-error: aborting due to 3 previous errors
-
-- 
cgit 1.4.1-3-g733a5


From 07886a97640b89f72b70805f519bd9d42d7d1c4e Mon Sep 17 00:00:00 2001
From: JarredAllen <jarredallen73@gmail.com>
Date: Sun, 24 May 2020 20:05:58 -0700
Subject: Detect also when  works

---
 clippy_lints/src/sort_by_key.rs | 49 +++++++++++++++++++++++++++++++++++------
 tests/ui/sort_by_key.fixed      |  2 +-
 tests/ui/sort_by_key.stderr     |  4 ++--
 3 files changed, 45 insertions(+), 10 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/sort_by_key.rs b/clippy_lints/src/sort_by_key.rs
index 109845a28f4..f720d14473a 100644
--- a/clippy_lints/src/sort_by_key.rs
+++ b/clippy_lints/src/sort_by_key.rs
@@ -3,7 +3,7 @@ use crate::utils::paths;
 use crate::utils::sugg::Sugg;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
-use rustc_hir::{Expr, ExprKind, Mutability, Param, Pat, PatKind, Path, QPath};
+use rustc_hir::{Expr, ExprKind, Mutability, Param, Pat, PatKind, Path, PathSegment, QPath};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::symbol::Ident;
@@ -16,7 +16,7 @@ declare_clippy_lint! {
     /// **Why is this bad?**
     /// It is more clear to use `Vec::sort_by_key` (or
     /// `Vec::sort_by_key` and `std::cmp::Reverse` if necessary) than
-    /// using 
+    /// using
     ///
     /// **Known problems:** None.
     ///
@@ -36,7 +36,17 @@ declare_clippy_lint! {
 
 declare_lint_pass!(SortByKey => [SORT_BY_KEY]);
 
-struct LintTrigger {
+enum LintTrigger {
+    Sort(SortDetection),
+    SortByKey(SortByKeyDetection),
+}
+
+struct SortDetection {
+    vec_name: String,
+    unstable: bool,
+}
+
+struct SortByKeyDetection {
     vec_name: String,
     closure_arg: String,
     closure_body: String,
@@ -177,7 +187,18 @@ fn detect_lint(cx: &LateContext<'_, '_>, expr: &Expr<'_>) -> Option<LintTrigger>
             };
             let vec_name = Sugg::hir(cx, &args[0], "..").to_string();
             let unstable = name == "sort_unstable_by";
-            Some(LintTrigger { vec_name, unstable, closure_arg, closure_body })
+            if_chain! {
+                if let ExprKind::Path(QPath::Resolved(_, Path {
+                    segments: [PathSegment { ident: left_name, .. }], ..
+                })) = &left_expr.kind;
+                if left_name == left_ident;
+                then {
+                    Some(LintTrigger::Sort(SortDetection { vec_name, unstable }))
+                }
+                else {
+                    Some(LintTrigger::SortByKey(SortByKeyDetection { vec_name, unstable, closure_arg, closure_body }))
+                }
+            }
         } else {
             None
         }
@@ -186,8 +207,8 @@ fn detect_lint(cx: &LateContext<'_, '_>, expr: &Expr<'_>) -> Option<LintTrigger>
 
 impl LateLintPass<'_, '_> for SortByKey {
     fn check_expr(&mut self, cx: &LateContext<'_, '_>, expr: &Expr<'_>) {
-        if let Some(trigger) = detect_lint(cx, expr) {
-            utils::span_lint_and_sugg(
+        match detect_lint(cx, expr) {
+            Some(LintTrigger::SortByKey(trigger)) => utils::span_lint_and_sugg(
                 cx,
                 SORT_BY_KEY,
                 expr.span,
@@ -201,7 +222,21 @@ impl LateLintPass<'_, '_> for SortByKey {
                     trigger.closure_body,
                 ),
                 Applicability::MachineApplicable,
-            );
+            ),
+            Some(LintTrigger::Sort(trigger)) => utils::span_lint_and_sugg(
+                cx,
+                SORT_BY_KEY,
+                expr.span,
+                "use Vec::sort here instead",
+                "try",
+                format!(
+                    "{}.sort{}()",
+                    trigger.vec_name,
+                    if trigger.unstable { "_unstable" } else { "" },
+                ),
+                Applicability::MachineApplicable,
+            ),
+            None => {},
         }
     }
 }
diff --git a/tests/ui/sort_by_key.fixed b/tests/ui/sort_by_key.fixed
index f6535c8d8f5..bb88df1a56c 100644
--- a/tests/ui/sort_by_key.fixed
+++ b/tests/ui/sort_by_key.fixed
@@ -10,7 +10,7 @@ fn id(x: isize) -> isize {
 fn main() {
     let mut vec: Vec<isize> = vec![3, 6, 1, 2, 5];
     // Forward examples
-    vec.sort_by_key(|&a| a);
+    vec.sort();
     vec.sort_by_key(|&a| (a + 5).abs());
     vec.sort_by_key(|&a| id(-a));
     // Reverse examples
diff --git a/tests/ui/sort_by_key.stderr b/tests/ui/sort_by_key.stderr
index fa6a9a0fb10..291fd5500f7 100644
--- a/tests/ui/sort_by_key.stderr
+++ b/tests/ui/sort_by_key.stderr
@@ -1,8 +1,8 @@
-error: use Vec::sort_by_key here instead
+error: use Vec::sort here instead
   --> $DIR/sort_by_key.rs:13:5
    |
 LL |     vec.sort_by(|a, b| a.cmp(b));
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_by_key(|&a| a)`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort()`
    |
    = note: `-D clippy::sort-by-key` implied by `-D warnings`
 
-- 
cgit 1.4.1-3-g733a5


From 015ab9f9259d58a48c171276f6e7190528f1a9ad Mon Sep 17 00:00:00 2001
From: JarredAllen <jarredallen73@gmail.com>
Date: Thu, 28 May 2020 18:18:25 -0700
Subject: Renamed to

---
 clippy_lints/src/lib.rs                 |  10 +-
 clippy_lints/src/sort_by_key.rs         | 242 --------------------------------
 clippy_lints/src/unnecessary_sort_by.rs | 242 ++++++++++++++++++++++++++++++++
 tests/ui/sort_by_key.fixed              |  26 ----
 tests/ui/sort_by_key.rs                 |  26 ----
 tests/ui/sort_by_key.stderr             |  48 -------
 tests/ui/unnecessary_sort_by.fixed      |  26 ++++
 tests/ui/unnecessary_sort_by.rs         |  26 ++++
 tests/ui/unnecessary_sort_by.stderr     |  48 +++++++
 9 files changed, 347 insertions(+), 347 deletions(-)
 delete mode 100644 clippy_lints/src/sort_by_key.rs
 create mode 100644 clippy_lints/src/unnecessary_sort_by.rs
 delete mode 100644 tests/ui/sort_by_key.fixed
 delete mode 100644 tests/ui/sort_by_key.rs
 delete mode 100644 tests/ui/sort_by_key.stderr
 create mode 100644 tests/ui/unnecessary_sort_by.fixed
 create mode 100644 tests/ui/unnecessary_sort_by.rs
 create mode 100644 tests/ui/unnecessary_sort_by.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 9e826316f21..46df743b5bf 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -304,7 +304,7 @@ mod serde_api;
 mod shadow;
 mod single_component_path_imports;
 mod slow_vector_initialization;
-mod sort_by_key;
+mod unnecessary_sort_by;
 mod strings;
 mod suspicious_trait_impl;
 mod swap;
@@ -780,7 +780,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &shadow::SHADOW_UNRELATED,
         &single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS,
         &slow_vector_initialization::SLOW_VECTOR_INITIALIZATION,
-        &sort_by_key::SORT_BY_KEY,
+        &unnecessary_sort_by::UNNECESSARY_SORT_BY,
         &strings::STRING_ADD,
         &strings::STRING_ADD_ASSIGN,
         &strings::STRING_LIT_AS_BYTES,
@@ -998,7 +998,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box ptr_offset_with_cast::PtrOffsetWithCast);
     store.register_late_pass(|| box redundant_clone::RedundantClone);
     store.register_late_pass(|| box slow_vector_initialization::SlowVectorInit);
-    store.register_late_pass(|| box sort_by_key::SortByKey);
+    store.register_late_pass(|| box unnecessary_sort_by::UnnecessarySortBy);
     store.register_late_pass(|| box types::RefToMut);
     store.register_late_pass(|| box assertions_on_constants::AssertionsOnConstants);
     store.register_late_pass(|| box missing_const_for_fn::MissingConstForFn);
@@ -1394,7 +1394,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&serde_api::SERDE_API_MISUSE),
         LintId::of(&single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS),
         LintId::of(&slow_vector_initialization::SLOW_VECTOR_INITIALIZATION),
-        LintId::of(&sort_by_key::SORT_BY_KEY),
+        LintId::of(&unnecessary_sort_by::UNNECESSARY_SORT_BY),
         LintId::of(&strings::STRING_LIT_AS_BYTES),
         LintId::of(&suspicious_trait_impl::SUSPICIOUS_ARITHMETIC_IMPL),
         LintId::of(&suspicious_trait_impl::SUSPICIOUS_OP_ASSIGN_IMPL),
@@ -1596,7 +1596,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&ranges::RANGE_ZIP_WITH_LEN),
         LintId::of(&reference::DEREF_ADDROF),
         LintId::of(&reference::REF_IN_DEREF),
-        LintId::of(&sort_by_key::SORT_BY_KEY),
+        LintId::of(&unnecessary_sort_by::UNNECESSARY_SORT_BY),
         LintId::of(&swap::MANUAL_SWAP),
         LintId::of(&temporary_assignment::TEMPORARY_ASSIGNMENT),
         LintId::of(&transmute::CROSSPOINTER_TRANSMUTE),
diff --git a/clippy_lints/src/sort_by_key.rs b/clippy_lints/src/sort_by_key.rs
deleted file mode 100644
index f720d14473a..00000000000
--- a/clippy_lints/src/sort_by_key.rs
+++ /dev/null
@@ -1,242 +0,0 @@
-use crate::utils;
-use crate::utils::paths;
-use crate::utils::sugg::Sugg;
-use if_chain::if_chain;
-use rustc_errors::Applicability;
-use rustc_hir::{Expr, ExprKind, Mutability, Param, Pat, PatKind, Path, PathSegment, QPath};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::symbol::Ident;
-
-declare_clippy_lint! {
-    /// **What it does:**
-    /// Detects when people use `Vec::sort_by` and pass in a function
-    /// which compares the two arguments, either directly or indirectly.
-    ///
-    /// **Why is this bad?**
-    /// It is more clear to use `Vec::sort_by_key` (or
-    /// `Vec::sort_by_key` and `std::cmp::Reverse` if necessary) than
-    /// using
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
-    /// ```rust
-    /// vec.sort_by(|a, b| a.foo().cmp(b.foo()));
-    /// ```
-    /// Use instead:
-    /// ```rust
-    /// vec.sort_by_key(|a| a.foo());
-    /// ```
-    pub SORT_BY_KEY,
-    complexity,
-    "Use of `Vec::sort_by` when `Vec::sort_by_key` would be clearer"
-}
-
-declare_lint_pass!(SortByKey => [SORT_BY_KEY]);
-
-enum LintTrigger {
-    Sort(SortDetection),
-    SortByKey(SortByKeyDetection),
-}
-
-struct SortDetection {
-    vec_name: String,
-    unstable: bool,
-}
-
-struct SortByKeyDetection {
-    vec_name: String,
-    closure_arg: String,
-    closure_body: String,
-    unstable: bool,
-}
-
-/// Detect if the two expressions are mirrored (identical, except one
-/// contains a and the other replaces it with b)
-fn mirrored_exprs(
-    cx: &LateContext<'_, '_>,
-    a_expr: &Expr<'_>,
-    a_ident: &Ident,
-    b_expr: &Expr<'_>,
-    b_ident: &Ident,
-) -> bool {
-    match (&a_expr.kind, &b_expr.kind) {
-        // Two boxes with mirrored contents
-        (ExprKind::Box(left_expr), ExprKind::Box(right_expr)) => {
-            mirrored_exprs(cx, left_expr, a_ident, right_expr, b_ident)
-        },
-        // Two arrays with mirrored contents
-        (ExprKind::Array(left_exprs), ExprKind::Array(right_exprs)) => left_exprs
-            .iter()
-            .zip(right_exprs.iter())
-            .all(|(left, right)| mirrored_exprs(cx, left, a_ident, right, b_ident)),
-        // The two exprs are function calls.
-        // Check to see that the function itself and its arguments are mirrored
-        (ExprKind::Call(left_expr, left_args), ExprKind::Call(right_expr, right_args)) => {
-            mirrored_exprs(cx, left_expr, a_ident, right_expr, b_ident)
-                && left_args
-                    .iter()
-                    .zip(right_args.iter())
-                    .all(|(left, right)| mirrored_exprs(cx, left, a_ident, right, b_ident))
-        },
-        // The two exprs are method calls.
-        // Check to see that the function is the same and the arguments are mirrored
-        // This is enough because the receiver of the method is listed in the arguments
-        (ExprKind::MethodCall(left_segment, _, left_args), ExprKind::MethodCall(right_segment, _, right_args)) => {
-            left_segment.ident == right_segment.ident
-                && left_args
-                    .iter()
-                    .zip(right_args.iter())
-                    .all(|(left, right)| mirrored_exprs(cx, left, a_ident, right, b_ident))
-        },
-        // Two tuples with mirrored contents
-        (ExprKind::Tup(left_exprs), ExprKind::Tup(right_exprs)) => left_exprs
-            .iter()
-            .zip(right_exprs.iter())
-            .all(|(left, right)| mirrored_exprs(cx, left, a_ident, right, b_ident)),
-        // Two binary ops, which are the same operation and which have mirrored arguments
-        (ExprKind::Binary(left_op, left_left, left_right), ExprKind::Binary(right_op, right_left, right_right)) => {
-            left_op.node == right_op.node
-                && mirrored_exprs(cx, left_left, a_ident, right_left, b_ident)
-                && mirrored_exprs(cx, left_right, a_ident, right_right, b_ident)
-        },
-        // Two unary ops, which are the same operation and which have the same argument
-        (ExprKind::Unary(left_op, left_expr), ExprKind::Unary(right_op, right_expr)) => {
-            left_op == right_op && mirrored_exprs(cx, left_expr, a_ident, right_expr, b_ident)
-        },
-        // The two exprs are literals of some kind
-        (ExprKind::Lit(left_lit), ExprKind::Lit(right_lit)) => left_lit.node == right_lit.node,
-        (ExprKind::Cast(left, _), ExprKind::Cast(right, _)) => mirrored_exprs(cx, left, a_ident, right, b_ident),
-        (ExprKind::DropTemps(left_block), ExprKind::DropTemps(right_block)) => {
-            mirrored_exprs(cx, left_block, a_ident, right_block, b_ident)
-        },
-        (ExprKind::Field(left_expr, left_ident), ExprKind::Field(right_expr, right_ident)) => {
-            left_ident.name == right_ident.name && mirrored_exprs(cx, left_expr, a_ident, right_expr, right_ident)
-        },
-        // Two paths: either one is a and the other is b, or they're identical to each other
-        (
-            ExprKind::Path(QPath::Resolved(
-                _,
-                Path {
-                    segments: left_segments,
-                    ..
-                },
-            )),
-            ExprKind::Path(QPath::Resolved(
-                _,
-                Path {
-                    segments: right_segments,
-                    ..
-                },
-            )),
-        ) => {
-            (left_segments
-                .iter()
-                .zip(right_segments.iter())
-                .all(|(left, right)| left.ident == right.ident)
-                && left_segments
-                    .iter()
-                    .all(|seg| &seg.ident != a_ident && &seg.ident != b_ident))
-                || (left_segments.len() == 1
-                    && &left_segments[0].ident == a_ident
-                    && right_segments.len() == 1
-                    && &right_segments[0].ident == b_ident)
-        },
-        // Matching expressions, but one or both is borrowed
-        (
-            ExprKind::AddrOf(left_kind, Mutability::Not, left_expr),
-            ExprKind::AddrOf(right_kind, Mutability::Not, right_expr),
-        ) => left_kind == right_kind && mirrored_exprs(cx, left_expr, a_ident, right_expr, b_ident),
-        (_, ExprKind::AddrOf(_, Mutability::Not, right_expr)) => {
-            mirrored_exprs(cx, a_expr, a_ident, right_expr, b_ident)
-        },
-        (ExprKind::AddrOf(_, Mutability::Not, left_expr), _) => mirrored_exprs(cx, left_expr, a_ident, b_expr, b_ident),
-        _ => false,
-    }
-}
-
-fn detect_lint(cx: &LateContext<'_, '_>, expr: &Expr<'_>) -> Option<LintTrigger> {
-    if_chain! {
-        if let ExprKind::MethodCall(name_ident, _, args) = &expr.kind;
-        if let name = name_ident.ident.name.to_ident_string();
-        if name == "sort_by" || name == "sort_unstable_by";
-        if let [vec, Expr { kind: ExprKind::Closure(_, _, closure_body_id, _, _), .. }] = args;
-        if utils::match_type(cx, &cx.tables.expr_ty(vec), &paths::VEC);
-        if let closure_body = cx.tcx.hir().body(*closure_body_id);
-        if let &[
-            Param { pat: Pat { kind: PatKind::Binding(_, _, left_ident, _), .. }, ..},
-            Param { pat: Pat { kind: PatKind::Binding(_, _, right_ident, _), .. }, .. }
-        ] = &closure_body.params;
-        if let ExprKind::MethodCall(method_path, _, [ref left_expr, ref right_expr]) = &closure_body.value.kind;
-        if method_path.ident.name.to_ident_string() == "cmp";
-        then {
-            let (closure_body, closure_arg) = if mirrored_exprs(
-                &cx,
-                &left_expr,
-                &left_ident,
-                &right_expr,
-                &right_ident
-            ) {
-                (Sugg::hir(cx, &left_expr, "..").to_string(), left_ident.name.to_string())
-            } else if mirrored_exprs(&cx, &left_expr, &right_ident, &right_expr, &left_ident) {
-                (format!("Reverse({})", Sugg::hir(cx, &left_expr, "..").to_string()), right_ident.name.to_string())
-            } else {
-                return None;
-            };
-            let vec_name = Sugg::hir(cx, &args[0], "..").to_string();
-            let unstable = name == "sort_unstable_by";
-            if_chain! {
-                if let ExprKind::Path(QPath::Resolved(_, Path {
-                    segments: [PathSegment { ident: left_name, .. }], ..
-                })) = &left_expr.kind;
-                if left_name == left_ident;
-                then {
-                    Some(LintTrigger::Sort(SortDetection { vec_name, unstable }))
-                }
-                else {
-                    Some(LintTrigger::SortByKey(SortByKeyDetection { vec_name, unstable, closure_arg, closure_body }))
-                }
-            }
-        } else {
-            None
-        }
-    }
-}
-
-impl LateLintPass<'_, '_> for SortByKey {
-    fn check_expr(&mut self, cx: &LateContext<'_, '_>, expr: &Expr<'_>) {
-        match detect_lint(cx, expr) {
-            Some(LintTrigger::SortByKey(trigger)) => utils::span_lint_and_sugg(
-                cx,
-                SORT_BY_KEY,
-                expr.span,
-                "use Vec::sort_by_key here instead",
-                "try",
-                format!(
-                    "{}.sort{}_by_key(|&{}| {})",
-                    trigger.vec_name,
-                    if trigger.unstable { "_unstable" } else { "" },
-                    trigger.closure_arg,
-                    trigger.closure_body,
-                ),
-                Applicability::MachineApplicable,
-            ),
-            Some(LintTrigger::Sort(trigger)) => utils::span_lint_and_sugg(
-                cx,
-                SORT_BY_KEY,
-                expr.span,
-                "use Vec::sort here instead",
-                "try",
-                format!(
-                    "{}.sort{}()",
-                    trigger.vec_name,
-                    if trigger.unstable { "_unstable" } else { "" },
-                ),
-                Applicability::MachineApplicable,
-            ),
-            None => {},
-        }
-    }
-}
diff --git a/clippy_lints/src/unnecessary_sort_by.rs b/clippy_lints/src/unnecessary_sort_by.rs
new file mode 100644
index 00000000000..c0858ec4c88
--- /dev/null
+++ b/clippy_lints/src/unnecessary_sort_by.rs
@@ -0,0 +1,242 @@
+use crate::utils;
+use crate::utils::paths;
+use crate::utils::sugg::Sugg;
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind, Mutability, Param, Pat, PatKind, Path, PathSegment, QPath};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::symbol::Ident;
+
+declare_clippy_lint! {
+    /// **What it does:**
+    /// Detects when people use `Vec::sort_by` and pass in a function
+    /// which compares the two arguments, either directly or indirectly.
+    ///
+    /// **Why is this bad?**
+    /// It is more clear to use `Vec::sort_by_key` (or `Vec::sort` if
+    /// possible) than to use `Vec::sort_by` and and a more complicated
+    /// closure.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// vec.sort_by(|a, b| a.foo().cmp(b.foo()));
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// vec.sort_by_key(|a| a.foo());
+    /// ```
+    pub UNNECESSARY_SORT_BY,
+    complexity,
+    "Use of `Vec::sort_by` when `Vec::sort_by_key` or `Vec::sort` would be clearer"
+}
+
+declare_lint_pass!(UnnecessarySortBy => [UNNECESSARY_SORT_BY]);
+
+enum LintTrigger {
+    Sort(SortDetection),
+    SortByKey(SortByKeyDetection),
+}
+
+struct SortDetection {
+    vec_name: String,
+    unstable: bool,
+}
+
+struct SortByKeyDetection {
+    vec_name: String,
+    closure_arg: String,
+    closure_body: String,
+    unstable: bool,
+}
+
+/// Detect if the two expressions are mirrored (identical, except one
+/// contains a and the other replaces it with b)
+fn mirrored_exprs(
+    cx: &LateContext<'_, '_>,
+    a_expr: &Expr<'_>,
+    a_ident: &Ident,
+    b_expr: &Expr<'_>,
+    b_ident: &Ident,
+) -> bool {
+    match (&a_expr.kind, &b_expr.kind) {
+        // Two boxes with mirrored contents
+        (ExprKind::Box(left_expr), ExprKind::Box(right_expr)) => {
+            mirrored_exprs(cx, left_expr, a_ident, right_expr, b_ident)
+        },
+        // Two arrays with mirrored contents
+        (ExprKind::Array(left_exprs), ExprKind::Array(right_exprs)) => left_exprs
+            .iter()
+            .zip(right_exprs.iter())
+            .all(|(left, right)| mirrored_exprs(cx, left, a_ident, right, b_ident)),
+        // The two exprs are function calls.
+        // Check to see that the function itself and its arguments are mirrored
+        (ExprKind::Call(left_expr, left_args), ExprKind::Call(right_expr, right_args)) => {
+            mirrored_exprs(cx, left_expr, a_ident, right_expr, b_ident)
+                && left_args
+                    .iter()
+                    .zip(right_args.iter())
+                    .all(|(left, right)| mirrored_exprs(cx, left, a_ident, right, b_ident))
+        },
+        // The two exprs are method calls.
+        // Check to see that the function is the same and the arguments are mirrored
+        // This is enough because the receiver of the method is listed in the arguments
+        (ExprKind::MethodCall(left_segment, _, left_args), ExprKind::MethodCall(right_segment, _, right_args)) => {
+            left_segment.ident == right_segment.ident
+                && left_args
+                    .iter()
+                    .zip(right_args.iter())
+                    .all(|(left, right)| mirrored_exprs(cx, left, a_ident, right, b_ident))
+        },
+        // Two tuples with mirrored contents
+        (ExprKind::Tup(left_exprs), ExprKind::Tup(right_exprs)) => left_exprs
+            .iter()
+            .zip(right_exprs.iter())
+            .all(|(left, right)| mirrored_exprs(cx, left, a_ident, right, b_ident)),
+        // Two binary ops, which are the same operation and which have mirrored arguments
+        (ExprKind::Binary(left_op, left_left, left_right), ExprKind::Binary(right_op, right_left, right_right)) => {
+            left_op.node == right_op.node
+                && mirrored_exprs(cx, left_left, a_ident, right_left, b_ident)
+                && mirrored_exprs(cx, left_right, a_ident, right_right, b_ident)
+        },
+        // Two unary ops, which are the same operation and which have the same argument
+        (ExprKind::Unary(left_op, left_expr), ExprKind::Unary(right_op, right_expr)) => {
+            left_op == right_op && mirrored_exprs(cx, left_expr, a_ident, right_expr, b_ident)
+        },
+        // The two exprs are literals of some kind
+        (ExprKind::Lit(left_lit), ExprKind::Lit(right_lit)) => left_lit.node == right_lit.node,
+        (ExprKind::Cast(left, _), ExprKind::Cast(right, _)) => mirrored_exprs(cx, left, a_ident, right, b_ident),
+        (ExprKind::DropTemps(left_block), ExprKind::DropTemps(right_block)) => {
+            mirrored_exprs(cx, left_block, a_ident, right_block, b_ident)
+        },
+        (ExprKind::Field(left_expr, left_ident), ExprKind::Field(right_expr, right_ident)) => {
+            left_ident.name == right_ident.name && mirrored_exprs(cx, left_expr, a_ident, right_expr, right_ident)
+        },
+        // Two paths: either one is a and the other is b, or they're identical to each other
+        (
+            ExprKind::Path(QPath::Resolved(
+                _,
+                Path {
+                    segments: left_segments,
+                    ..
+                },
+            )),
+            ExprKind::Path(QPath::Resolved(
+                _,
+                Path {
+                    segments: right_segments,
+                    ..
+                },
+            )),
+        ) => {
+            (left_segments
+                .iter()
+                .zip(right_segments.iter())
+                .all(|(left, right)| left.ident == right.ident)
+                && left_segments
+                    .iter()
+                    .all(|seg| &seg.ident != a_ident && &seg.ident != b_ident))
+                || (left_segments.len() == 1
+                    && &left_segments[0].ident == a_ident
+                    && right_segments.len() == 1
+                    && &right_segments[0].ident == b_ident)
+        },
+        // Matching expressions, but one or both is borrowed
+        (
+            ExprKind::AddrOf(left_kind, Mutability::Not, left_expr),
+            ExprKind::AddrOf(right_kind, Mutability::Not, right_expr),
+        ) => left_kind == right_kind && mirrored_exprs(cx, left_expr, a_ident, right_expr, b_ident),
+        (_, ExprKind::AddrOf(_, Mutability::Not, right_expr)) => {
+            mirrored_exprs(cx, a_expr, a_ident, right_expr, b_ident)
+        },
+        (ExprKind::AddrOf(_, Mutability::Not, left_expr), _) => mirrored_exprs(cx, left_expr, a_ident, b_expr, b_ident),
+        _ => false,
+    }
+}
+
+fn detect_lint(cx: &LateContext<'_, '_>, expr: &Expr<'_>) -> Option<LintTrigger> {
+    if_chain! {
+        if let ExprKind::MethodCall(name_ident, _, args) = &expr.kind;
+        if let name = name_ident.ident.name.to_ident_string();
+        if name == "sort_by" || name == "sort_unstable_by";
+        if let [vec, Expr { kind: ExprKind::Closure(_, _, closure_body_id, _, _), .. }] = args;
+        if utils::match_type(cx, &cx.tables.expr_ty(vec), &paths::VEC);
+        if let closure_body = cx.tcx.hir().body(*closure_body_id);
+        if let &[
+            Param { pat: Pat { kind: PatKind::Binding(_, _, left_ident, _), .. }, ..},
+            Param { pat: Pat { kind: PatKind::Binding(_, _, right_ident, _), .. }, .. }
+        ] = &closure_body.params;
+        if let ExprKind::MethodCall(method_path, _, [ref left_expr, ref right_expr]) = &closure_body.value.kind;
+        if method_path.ident.name.to_ident_string() == "cmp";
+        then {
+            let (closure_body, closure_arg) = if mirrored_exprs(
+                &cx,
+                &left_expr,
+                &left_ident,
+                &right_expr,
+                &right_ident
+            ) {
+                (Sugg::hir(cx, &left_expr, "..").to_string(), left_ident.name.to_string())
+            } else if mirrored_exprs(&cx, &left_expr, &right_ident, &right_expr, &left_ident) {
+                (format!("Reverse({})", Sugg::hir(cx, &left_expr, "..").to_string()), right_ident.name.to_string())
+            } else {
+                return None;
+            };
+            let vec_name = Sugg::hir(cx, &args[0], "..").to_string();
+            let unstable = name == "sort_unstable_by";
+            if_chain! {
+                if let ExprKind::Path(QPath::Resolved(_, Path {
+                    segments: [PathSegment { ident: left_name, .. }], ..
+                })) = &left_expr.kind;
+                if left_name == left_ident;
+                then {
+                    Some(LintTrigger::Sort(SortDetection { vec_name, unstable }))
+                }
+                else {
+                    Some(LintTrigger::SortByKey(SortByKeyDetection { vec_name, unstable, closure_arg, closure_body }))
+                }
+            }
+        } else {
+            None
+        }
+    }
+}
+
+impl LateLintPass<'_, '_> for UnnecessarySortBy {
+    fn check_expr(&mut self, cx: &LateContext<'_, '_>, expr: &Expr<'_>) {
+        match detect_lint(cx, expr) {
+            Some(LintTrigger::SortByKey(trigger)) => utils::span_lint_and_sugg(
+                cx,
+                UNNECESSARY_SORT_BY,
+                expr.span,
+                "use Vec::sort_by_key here instead",
+                "try",
+                format!(
+                    "{}.sort{}_by_key(|&{}| {})",
+                    trigger.vec_name,
+                    if trigger.unstable { "_unstable" } else { "" },
+                    trigger.closure_arg,
+                    trigger.closure_body,
+                ),
+                Applicability::MachineApplicable,
+            ),
+            Some(LintTrigger::Sort(trigger)) => utils::span_lint_and_sugg(
+                cx,
+                UNNECESSARY_SORT_BY,
+                expr.span,
+                "use Vec::sort here instead",
+                "try",
+                format!(
+                    "{}.sort{}()",
+                    trigger.vec_name,
+                    if trigger.unstable { "_unstable" } else { "" },
+                ),
+                Applicability::MachineApplicable,
+            ),
+            None => {},
+        }
+    }
+}
diff --git a/tests/ui/sort_by_key.fixed b/tests/ui/sort_by_key.fixed
deleted file mode 100644
index bb88df1a56c..00000000000
--- a/tests/ui/sort_by_key.fixed
+++ /dev/null
@@ -1,26 +0,0 @@
-// run-rustfix
-#![warn(clippy::sort_by_key)]
-
-use std::cmp::Reverse;
-
-fn id(x: isize) -> isize {
-    x
-}
-
-fn main() {
-    let mut vec: Vec<isize> = vec![3, 6, 1, 2, 5];
-    // Forward examples
-    vec.sort();
-    vec.sort_by_key(|&a| (a + 5).abs());
-    vec.sort_by_key(|&a| id(-a));
-    // Reverse examples
-    vec.sort_by_key(|&b| Reverse(b));
-    vec.sort_by_key(|&b| Reverse((b + 5).abs()));
-    vec.sort_by_key(|&b| Reverse(id(-b)));
-    // Negative examples (shouldn't be changed)
-    let c = &7;
-    vec.sort_by(|a, b| (b - a).cmp(&(a - b)));
-    vec.sort_by(|_, b| b.cmp(&5));
-    vec.sort_by(|_, b| b.cmp(c));
-    vec.sort_by(|a, _| a.cmp(c));
-}
diff --git a/tests/ui/sort_by_key.rs b/tests/ui/sort_by_key.rs
deleted file mode 100644
index 953c573d406..00000000000
--- a/tests/ui/sort_by_key.rs
+++ /dev/null
@@ -1,26 +0,0 @@
-// run-rustfix
-#![warn(clippy::sort_by_key_reverse)]
-
-use std::cmp::Reverse;
-
-fn id(x: isize) -> isize {
-    x
-}
-
-fn main() {
-    let mut vec: Vec<isize> = vec![3, 6, 1, 2, 5];
-    // Forward examples
-    vec.sort_by(|a, b| a.cmp(b));
-    vec.sort_by(|a, b| (a + 5).abs().cmp(&(b + 5).abs()));
-    vec.sort_by(|a, b| id(-a).cmp(&id(-b)));
-    // Reverse examples
-    vec.sort_by(|a, b| b.cmp(a));
-    vec.sort_by(|a, b| (b + 5).abs().cmp(&(a + 5).abs()));
-    vec.sort_by(|a, b| id(-b).cmp(&id(-a)));
-    // Negative examples (shouldn't be changed)
-    let c = &7;
-    vec.sort_by(|a, b| (b - a).cmp(&(a - b)));
-    vec.sort_by(|_, b| b.cmp(&5));
-    vec.sort_by(|_, b| b.cmp(c));
-    vec.sort_by(|a, _| a.cmp(c));
-}
diff --git a/tests/ui/sort_by_key.stderr b/tests/ui/sort_by_key.stderr
deleted file mode 100644
index 291fd5500f7..00000000000
--- a/tests/ui/sort_by_key.stderr
+++ /dev/null
@@ -1,48 +0,0 @@
-error: use Vec::sort here instead
-  --> $DIR/sort_by_key.rs:13:5
-   |
-LL |     vec.sort_by(|a, b| a.cmp(b));
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort()`
-   |
-   = note: `-D clippy::sort-by-key` implied by `-D warnings`
-
-error: use Vec::sort_by_key here instead
-  --> $DIR/sort_by_key.rs:14:5
-   |
-LL |     vec.sort_by(|a, b| (a + 5).abs().cmp(&(b + 5).abs()));
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_by_key(|&a| (a + 5).abs())`
-
-error: use Vec::sort_by_key here instead
-  --> $DIR/sort_by_key.rs:15:5
-   |
-LL |     vec.sort_by(|a, b| id(-a).cmp(&id(-b)));
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_by_key(|&a| id(-a))`
-
-error: use Vec::sort_by_key here instead
-  --> $DIR/sort_by_key.rs:17:5
-   |
-LL |     vec.sort_by(|a, b| b.cmp(a));
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_by_key(|&b| Reverse(b))`
-
-error: use Vec::sort_by_key here instead
-  --> $DIR/sort_by_key.rs:18:5
-   |
-LL |     vec.sort_by(|a, b| (b + 5).abs().cmp(&(a + 5).abs()));
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_by_key(|&b| Reverse((b + 5).abs()))`
-
-error: use Vec::sort_by_key here instead
-  --> $DIR/sort_by_key.rs:19:5
-   |
-LL |     vec.sort_by(|a, b| id(-b).cmp(&id(-a)));
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_by_key(|&b| Reverse(id(-b)))`
-
-error: unknown clippy lint: clippy::sort_by_key_reverse
-  --> $DIR/sort_by_key.rs:2:9
-   |
-LL | #![warn(clippy::sort_by_key_reverse)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: did you mean: `clippy::sort_by_key`
-   |
-   = note: `-D clippy::unknown-clippy-lints` implied by `-D warnings`
-
-error: aborting due to 7 previous errors
-
diff --git a/tests/ui/unnecessary_sort_by.fixed b/tests/ui/unnecessary_sort_by.fixed
new file mode 100644
index 00000000000..bb88df1a56c
--- /dev/null
+++ b/tests/ui/unnecessary_sort_by.fixed
@@ -0,0 +1,26 @@
+// run-rustfix
+#![warn(clippy::sort_by_key)]
+
+use std::cmp::Reverse;
+
+fn id(x: isize) -> isize {
+    x
+}
+
+fn main() {
+    let mut vec: Vec<isize> = vec![3, 6, 1, 2, 5];
+    // Forward examples
+    vec.sort();
+    vec.sort_by_key(|&a| (a + 5).abs());
+    vec.sort_by_key(|&a| id(-a));
+    // Reverse examples
+    vec.sort_by_key(|&b| Reverse(b));
+    vec.sort_by_key(|&b| Reverse((b + 5).abs()));
+    vec.sort_by_key(|&b| Reverse(id(-b)));
+    // Negative examples (shouldn't be changed)
+    let c = &7;
+    vec.sort_by(|a, b| (b - a).cmp(&(a - b)));
+    vec.sort_by(|_, b| b.cmp(&5));
+    vec.sort_by(|_, b| b.cmp(c));
+    vec.sort_by(|a, _| a.cmp(c));
+}
diff --git a/tests/ui/unnecessary_sort_by.rs b/tests/ui/unnecessary_sort_by.rs
new file mode 100644
index 00000000000..953c573d406
--- /dev/null
+++ b/tests/ui/unnecessary_sort_by.rs
@@ -0,0 +1,26 @@
+// run-rustfix
+#![warn(clippy::sort_by_key_reverse)]
+
+use std::cmp::Reverse;
+
+fn id(x: isize) -> isize {
+    x
+}
+
+fn main() {
+    let mut vec: Vec<isize> = vec![3, 6, 1, 2, 5];
+    // Forward examples
+    vec.sort_by(|a, b| a.cmp(b));
+    vec.sort_by(|a, b| (a + 5).abs().cmp(&(b + 5).abs()));
+    vec.sort_by(|a, b| id(-a).cmp(&id(-b)));
+    // Reverse examples
+    vec.sort_by(|a, b| b.cmp(a));
+    vec.sort_by(|a, b| (b + 5).abs().cmp(&(a + 5).abs()));
+    vec.sort_by(|a, b| id(-b).cmp(&id(-a)));
+    // Negative examples (shouldn't be changed)
+    let c = &7;
+    vec.sort_by(|a, b| (b - a).cmp(&(a - b)));
+    vec.sort_by(|_, b| b.cmp(&5));
+    vec.sort_by(|_, b| b.cmp(c));
+    vec.sort_by(|a, _| a.cmp(c));
+}
diff --git a/tests/ui/unnecessary_sort_by.stderr b/tests/ui/unnecessary_sort_by.stderr
new file mode 100644
index 00000000000..291fd5500f7
--- /dev/null
+++ b/tests/ui/unnecessary_sort_by.stderr
@@ -0,0 +1,48 @@
+error: use Vec::sort here instead
+  --> $DIR/sort_by_key.rs:13:5
+   |
+LL |     vec.sort_by(|a, b| a.cmp(b));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort()`
+   |
+   = note: `-D clippy::sort-by-key` implied by `-D warnings`
+
+error: use Vec::sort_by_key here instead
+  --> $DIR/sort_by_key.rs:14:5
+   |
+LL |     vec.sort_by(|a, b| (a + 5).abs().cmp(&(b + 5).abs()));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_by_key(|&a| (a + 5).abs())`
+
+error: use Vec::sort_by_key here instead
+  --> $DIR/sort_by_key.rs:15:5
+   |
+LL |     vec.sort_by(|a, b| id(-a).cmp(&id(-b)));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_by_key(|&a| id(-a))`
+
+error: use Vec::sort_by_key here instead
+  --> $DIR/sort_by_key.rs:17:5
+   |
+LL |     vec.sort_by(|a, b| b.cmp(a));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_by_key(|&b| Reverse(b))`
+
+error: use Vec::sort_by_key here instead
+  --> $DIR/sort_by_key.rs:18:5
+   |
+LL |     vec.sort_by(|a, b| (b + 5).abs().cmp(&(a + 5).abs()));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_by_key(|&b| Reverse((b + 5).abs()))`
+
+error: use Vec::sort_by_key here instead
+  --> $DIR/sort_by_key.rs:19:5
+   |
+LL |     vec.sort_by(|a, b| id(-b).cmp(&id(-a)));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_by_key(|&b| Reverse(id(-b)))`
+
+error: unknown clippy lint: clippy::sort_by_key_reverse
+  --> $DIR/sort_by_key.rs:2:9
+   |
+LL | #![warn(clippy::sort_by_key_reverse)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: did you mean: `clippy::sort_by_key`
+   |
+   = note: `-D clippy::unknown-clippy-lints` implied by `-D warnings`
+
+error: aborting due to 7 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 20cb512e81ad03a014b40c377a01fdebaea66963 Mon Sep 17 00:00:00 2001
From: JarredAllen <jarredallen73@gmail.com>
Date: Sun, 31 May 2020 12:06:32 -0700
Subject: Updated test cases and formatted

---
 clippy_lints/src/lib.rs             |  2 +-
 tests/ui/unnecessary_sort_by.fixed  |  1 -
 tests/ui/unnecessary_sort_by.rs     |  1 -
 tests/ui/unnecessary_sort_by.stderr | 24 ++++++++----------------
 4 files changed, 9 insertions(+), 19 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 46df743b5bf..fd832d11577 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -304,7 +304,6 @@ mod serde_api;
 mod shadow;
 mod single_component_path_imports;
 mod slow_vector_initialization;
-mod unnecessary_sort_by;
 mod strings;
 mod suspicious_trait_impl;
 mod swap;
@@ -319,6 +318,7 @@ mod try_err;
 mod types;
 mod unicode;
 mod unnamed_address;
+mod unnecessary_sort_by;
 mod unsafe_removed_from_name;
 mod unused_io_amount;
 mod unused_self;
diff --git a/tests/ui/unnecessary_sort_by.fixed b/tests/ui/unnecessary_sort_by.fixed
index bb88df1a56c..4521ae38d49 100644
--- a/tests/ui/unnecessary_sort_by.fixed
+++ b/tests/ui/unnecessary_sort_by.fixed
@@ -1,5 +1,4 @@
 // run-rustfix
-#![warn(clippy::sort_by_key)]
 
 use std::cmp::Reverse;
 
diff --git a/tests/ui/unnecessary_sort_by.rs b/tests/ui/unnecessary_sort_by.rs
index 953c573d406..fdb5a823369 100644
--- a/tests/ui/unnecessary_sort_by.rs
+++ b/tests/ui/unnecessary_sort_by.rs
@@ -1,5 +1,4 @@
 // run-rustfix
-#![warn(clippy::sort_by_key_reverse)]
 
 use std::cmp::Reverse;
 
diff --git a/tests/ui/unnecessary_sort_by.stderr b/tests/ui/unnecessary_sort_by.stderr
index 291fd5500f7..b6365c1709d 100644
--- a/tests/ui/unnecessary_sort_by.stderr
+++ b/tests/ui/unnecessary_sort_by.stderr
@@ -1,48 +1,40 @@
 error: use Vec::sort here instead
-  --> $DIR/sort_by_key.rs:13:5
+  --> $DIR/unnecessary_sort_by.rs:12:5
    |
 LL |     vec.sort_by(|a, b| a.cmp(b));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort()`
    |
-   = note: `-D clippy::sort-by-key` implied by `-D warnings`
+   = note: `-D clippy::unnecessary-sort-by` implied by `-D warnings`
 
 error: use Vec::sort_by_key here instead
-  --> $DIR/sort_by_key.rs:14:5
+  --> $DIR/unnecessary_sort_by.rs:13:5
    |
 LL |     vec.sort_by(|a, b| (a + 5).abs().cmp(&(b + 5).abs()));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_by_key(|&a| (a + 5).abs())`
 
 error: use Vec::sort_by_key here instead
-  --> $DIR/sort_by_key.rs:15:5
+  --> $DIR/unnecessary_sort_by.rs:14:5
    |
 LL |     vec.sort_by(|a, b| id(-a).cmp(&id(-b)));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_by_key(|&a| id(-a))`
 
 error: use Vec::sort_by_key here instead
-  --> $DIR/sort_by_key.rs:17:5
+  --> $DIR/unnecessary_sort_by.rs:16:5
    |
 LL |     vec.sort_by(|a, b| b.cmp(a));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_by_key(|&b| Reverse(b))`
 
 error: use Vec::sort_by_key here instead
-  --> $DIR/sort_by_key.rs:18:5
+  --> $DIR/unnecessary_sort_by.rs:17:5
    |
 LL |     vec.sort_by(|a, b| (b + 5).abs().cmp(&(a + 5).abs()));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_by_key(|&b| Reverse((b + 5).abs()))`
 
 error: use Vec::sort_by_key here instead
-  --> $DIR/sort_by_key.rs:19:5
+  --> $DIR/unnecessary_sort_by.rs:18:5
    |
 LL |     vec.sort_by(|a, b| id(-b).cmp(&id(-a)));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_by_key(|&b| Reverse(id(-b)))`
 
-error: unknown clippy lint: clippy::sort_by_key_reverse
-  --> $DIR/sort_by_key.rs:2:9
-   |
-LL | #![warn(clippy::sort_by_key_reverse)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: did you mean: `clippy::sort_by_key`
-   |
-   = note: `-D clippy::unknown-clippy-lints` implied by `-D warnings`
-
-error: aborting due to 7 previous errors
+error: aborting due to 6 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 32fde0b5116b3a1115d11c49a9bf2af2ebdd5773 Mon Sep 17 00:00:00 2001
From: Ericko Samudera <ericko.samudera@gmail.com>
Date: Mon, 25 May 2020 23:22:01 +0700
Subject: New lint: iter_next_slice

---
 CHANGELOG.md                          |  1 +
 clippy_lints/src/lib.rs               |  3 ++
 clippy_lints/src/loops.rs             | 26 +++++------
 clippy_lints/src/methods/mod.rs       | 84 ++++++++++++++++++++++++++++++++++-
 clippy_lints/src/needless_continue.rs |  2 +-
 src/lintlist/mod.rs                   |  7 +++
 tests/ui/into_iter_on_ref.fixed       |  2 +
 tests/ui/into_iter_on_ref.rs          |  2 +
 tests/ui/into_iter_on_ref.stderr      |  8 +++-
 tests/ui/iter_next_slice.fixed        | 24 ++++++++++
 tests/ui/iter_next_slice.rs           | 24 ++++++++++
 tests/ui/iter_next_slice.stderr       | 28 ++++++++++++
 tests/ui/needless_collect.fixed       |  2 +-
 tests/ui/needless_collect.stderr      | 16 +++----
 14 files changed, 204 insertions(+), 25 deletions(-)
 create mode 100644 tests/ui/iter_next_slice.fixed
 create mode 100644 tests/ui/iter_next_slice.rs
 create mode 100644 tests/ui/iter_next_slice.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 2ac9057199f..714e25a32ea 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1401,6 +1401,7 @@ Released 2018-09-13
 [`items_after_statements`]: https://rust-lang.github.io/rust-clippy/master/index.html#items_after_statements
 [`iter_cloned_collect`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_cloned_collect
 [`iter_next_loop`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_next_loop
+[`iter_next_slice`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_next_slice
 [`iter_nth`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_nth
 [`iter_nth_zero`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_nth_zero
 [`iter_skip_next`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_skip_next
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 057d39d4c82..7c16dbd8f26 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -669,6 +669,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &methods::INTO_ITER_ON_REF,
         &methods::ITERATOR_STEP_BY_ZERO,
         &methods::ITER_CLONED_COLLECT,
+        &methods::ITER_NEXT_SLICE,
         &methods::ITER_NTH,
         &methods::ITER_NTH_ZERO,
         &methods::ITER_SKIP_NEXT,
@@ -1303,6 +1304,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&methods::INTO_ITER_ON_REF),
         LintId::of(&methods::ITERATOR_STEP_BY_ZERO),
         LintId::of(&methods::ITER_CLONED_COLLECT),
+        LintId::of(&methods::ITER_NEXT_SLICE),
         LintId::of(&methods::ITER_NTH),
         LintId::of(&methods::ITER_NTH_ZERO),
         LintId::of(&methods::ITER_SKIP_NEXT),
@@ -1483,6 +1485,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&methods::CHARS_NEXT_CMP),
         LintId::of(&methods::INTO_ITER_ON_REF),
         LintId::of(&methods::ITER_CLONED_COLLECT),
+        LintId::of(&methods::ITER_NEXT_SLICE),
         LintId::of(&methods::ITER_NTH_ZERO),
         LintId::of(&methods::ITER_SKIP_NEXT),
         LintId::of(&methods::MANUAL_SATURATING_ARITHMETIC),
diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 38a5829b3f7..dbe41823a9c 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -27,7 +27,7 @@ use rustc_middle::middle::region;
 use rustc_middle::ty::{self, Ty};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
-use rustc_span::BytePos;
+use rustc_span::symbol::Symbol;
 use rustc_typeck::expr_use_visitor::{ConsumeMode, Delegate, ExprUseVisitor, Place, PlaceBase};
 use std::iter::{once, Iterator};
 use std::mem;
@@ -2381,32 +2381,32 @@ fn check_needless_collect<'a, 'tcx>(expr: &'tcx Expr<'_>, cx: &LateContext<'a, '
                 match_type(cx, ty, &paths::BTREEMAP) ||
                 is_type_diagnostic_item(cx, ty, sym!(hashmap_type)) {
                 if method.ident.name == sym!(len) {
-                    let span = shorten_needless_collect_span(expr);
+                    let span = shorten_span(expr, sym!(collect));
                     span_lint_and_sugg(
                         cx,
                         NEEDLESS_COLLECT,
                         span,
                         NEEDLESS_COLLECT_MSG,
                         "replace with",
-                        ".count()".to_string(),
+                        "count()".to_string(),
                         Applicability::MachineApplicable,
                     );
                 }
                 if method.ident.name == sym!(is_empty) {
-                    let span = shorten_needless_collect_span(expr);
+                    let span = shorten_span(expr, sym!(iter));
                     span_lint_and_sugg(
                         cx,
                         NEEDLESS_COLLECT,
                         span,
                         NEEDLESS_COLLECT_MSG,
                         "replace with",
-                        ".next().is_none()".to_string(),
+                        "get(0).is_none()".to_string(),
                         Applicability::MachineApplicable,
                     );
                 }
                 if method.ident.name == sym!(contains) {
                     let contains_arg = snippet(cx, args[1].span, "??");
-                    let span = shorten_needless_collect_span(expr);
+                    let span = shorten_span(expr, sym!(collect));
                     span_lint_and_then(
                         cx,
                         NEEDLESS_COLLECT,
@@ -2422,7 +2422,7 @@ fn check_needless_collect<'a, 'tcx>(expr: &'tcx Expr<'_>, cx: &LateContext<'a, '
                                 span,
                                 "replace with",
                                 format!(
-                                    ".any(|{}| x == {})",
+                                    "any(|{}| x == {})",
                                     arg, pred
                                 ),
                                 Applicability::MachineApplicable,
@@ -2435,13 +2435,13 @@ fn check_needless_collect<'a, 'tcx>(expr: &'tcx Expr<'_>, cx: &LateContext<'a, '
     }
 }
 
-fn shorten_needless_collect_span(expr: &Expr<'_>) -> Span {
-    if_chain! {
-        if let ExprKind::MethodCall(_, _, ref args) = expr.kind;
-        if let ExprKind::MethodCall(_, ref span, _) = args[0].kind;
-        then {
-            return expr.span.with_lo(span.lo() - BytePos(1));
+fn shorten_span(expr: &Expr<'_>, target_fn_name: Symbol) -> Span {
+    let mut current_expr = expr;
+    while let ExprKind::MethodCall(ref path, ref span, ref args) = current_expr.kind {
+        if path.ident.name == target_fn_name {
+            return expr.span.with_lo(span.lo());
         }
+        current_expr = &args[0];
     }
     unreachable!()
 }
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 32b3b7f7947..7cb04d4d81c 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -26,7 +26,7 @@ use rustc_span::symbol::{sym, SymbolStr};
 use crate::consts::{constant, Constant};
 use crate::utils::usage::mutated_variables;
 use crate::utils::{
-    get_arg_name, get_parent_expr, get_trait_def_id, has_iter_method, implements_trait, in_macro, is_copy,
+    get_arg_name, get_parent_expr, get_trait_def_id, has_iter_method, higher, implements_trait, in_macro, is_copy,
     is_ctor_or_promotable_const_function, is_expn_of, is_type_diagnostic_item, iter_input_pats, last_path_segment,
     match_def_path, match_qpath, match_trait_method, match_type, match_var, method_calls, method_chain_args, paths,
     remove_blocks, return_ty, same_tys, single_segment_path, snippet, snippet_with_applicability,
@@ -1242,6 +1242,32 @@ declare_clippy_lint! {
     "using `as_ref().map(Deref::deref)`, which is more succinctly expressed as `as_deref()`"
 }
 
+declare_clippy_lint! {
+    /// **What it does:** Checks for usage of `iter().next()` on a Slice or an Array
+    ///
+    /// **Why is this bad?** These can be shortened into `.get()`
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// ```rust
+    /// # let a = [1, 2, 3];
+    /// # let b = vec![1, 2, 3];
+    /// a[2..].iter().next();
+    /// b.iter().next();
+    /// ```
+    /// should be written as:
+    /// ```rust
+    /// # let a = [1, 2, 3];
+    /// # let b = vec![1, 2, 3];
+    /// a.get(2);
+    /// b.get(0);
+    /// ```
+    pub ITER_NEXT_SLICE,
+    style,
+    "using `.iter().next()` on a sliced array, which can be shortened to just `.get()`"
+}
+
 declare_lint_pass!(Methods => [
     UNWRAP_USED,
     EXPECT_USED,
@@ -1273,6 +1299,7 @@ declare_lint_pass!(Methods => [
     FIND_MAP,
     MAP_FLATTEN,
     ITERATOR_STEP_BY_ZERO,
+    ITER_NEXT_SLICE,
     ITER_NTH,
     ITER_NTH_ZERO,
     ITER_SKIP_NEXT,
@@ -1320,6 +1347,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Methods {
             },
             ["next", "filter"] => lint_filter_next(cx, expr, arg_lists[1]),
             ["next", "skip_while"] => lint_skip_while_next(cx, expr, arg_lists[1]),
+            ["next", "iter"] => lint_iter_next(cx, expr, arg_lists[1]),
             ["map", "filter"] => lint_filter_map(cx, expr, arg_lists[1], arg_lists[0]),
             ["map", "filter_map"] => lint_filter_map_map(cx, expr, arg_lists[1], arg_lists[0]),
             ["next", "filter_map"] => lint_filter_map_next(cx, expr, arg_lists[1]),
@@ -2184,6 +2212,60 @@ fn lint_step_by<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &hir::Expr<'_>, args
     }
 }
 
+fn lint_iter_next<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &'tcx hir::Expr<'_>, iter_args: &'tcx [hir::Expr<'_>]) {
+    let caller_expr = &iter_args[0];
+
+    // Skip lint if the `iter().next()` expression is a for loop argument,
+    // since it is already covered by `&loops::ITER_NEXT_LOOP`
+    let mut parent_expr_opt = get_parent_expr(cx, expr);
+    while let Some(parent_expr) = parent_expr_opt {
+        if higher::for_loop(parent_expr).is_some() {
+            return;
+        }
+        parent_expr_opt = get_parent_expr(cx, parent_expr);
+    }
+
+    if derefs_to_slice(cx, caller_expr, cx.tables.expr_ty(caller_expr)).is_some() {
+        // caller is a Slice
+        if_chain! {
+            if let hir::ExprKind::Index(ref caller_var, ref index_expr) = &caller_expr.kind;
+            if let Some(higher::Range { start: Some(start_expr), end: None, limits: ast::RangeLimits::HalfOpen })
+                = higher::range(cx, index_expr);
+            if let hir::ExprKind::Lit(ref start_lit) = &start_expr.kind;
+            if let ast::LitKind::Int(start_idx, _) = start_lit.node;
+            then {
+                let mut applicability = Applicability::MachineApplicable;
+                span_lint_and_sugg(
+                    cx,
+                    ITER_NEXT_SLICE,
+                    expr.span,
+                    "Using `.iter().next()` on a Slice without end index.",
+                    "try calling",
+                    format!("{}.get({})", snippet_with_applicability(cx, caller_var.span, "..", &mut applicability), start_idx),
+                    applicability,
+                );
+            }
+        }
+    } else if is_type_diagnostic_item(cx, cx.tables.expr_ty(caller_expr), sym!(vec_type))
+        || matches!(&walk_ptrs_ty(cx.tables.expr_ty(caller_expr)).kind, ty::Array(_, _))
+    {
+        // caller is a Vec or an Array
+        let mut applicability = Applicability::MachineApplicable;
+        span_lint_and_sugg(
+            cx,
+            ITER_NEXT_SLICE,
+            expr.span,
+            "Using `.iter().next()` on an array",
+            "try calling",
+            format!(
+                "{}.get(0)",
+                snippet_with_applicability(cx, caller_expr.span, "..", &mut applicability)
+            ),
+            applicability,
+        );
+    }
+}
+
 fn lint_iter_nth<'a, 'tcx>(
     cx: &LateContext<'a, 'tcx>,
     expr: &hir::Expr<'_>,
diff --git a/clippy_lints/src/needless_continue.rs b/clippy_lints/src/needless_continue.rs
index 28183810df4..a971d041ca6 100644
--- a/clippy_lints/src/needless_continue.rs
+++ b/clippy_lints/src/needless_continue.rs
@@ -424,7 +424,7 @@ fn erode_from_back(s: &str) -> String {
 }
 
 fn span_of_first_expr_in_block(block: &ast::Block) -> Option<Span> {
-    block.stmts.iter().next().map(|stmt| stmt.span)
+    block.stmts.get(0).map(|stmt| stmt.span)
 }
 
 #[cfg(test)]
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index 8211a57b564..79da1f3702e 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -934,6 +934,13 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
         deprecation: None,
         module: "loops",
     },
+    Lint {
+        name: "iter_next_slice",
+        group: "style",
+        desc: "using `.iter().next()` on a sliced array, which can be shortened to just `.get()`",
+        deprecation: None,
+        module: "methods",
+    },
     Lint {
         name: "iter_nth",
         group: "perf",
diff --git a/tests/ui/into_iter_on_ref.fixed b/tests/ui/into_iter_on_ref.fixed
index c30d23de3f8..7f92d0dbdc9 100644
--- a/tests/ui/into_iter_on_ref.fixed
+++ b/tests/ui/into_iter_on_ref.fixed
@@ -40,4 +40,6 @@ fn main() {
     let _ = (&HashSet::<i32>::new()).iter(); //~ WARN equivalent to .iter()
     let _ = std::path::Path::new("12/34").iter(); //~ WARN equivalent to .iter()
     let _ = std::path::PathBuf::from("12/34").iter(); //~ ERROR equivalent to .iter()
+
+    let _ = (&[1, 2, 3]).iter().next(); //~ WARN equivalent to .iter()
 }
diff --git a/tests/ui/into_iter_on_ref.rs b/tests/ui/into_iter_on_ref.rs
index 94bc1689619..416056d3fdb 100644
--- a/tests/ui/into_iter_on_ref.rs
+++ b/tests/ui/into_iter_on_ref.rs
@@ -40,4 +40,6 @@ fn main() {
     let _ = (&HashSet::<i32>::new()).into_iter(); //~ WARN equivalent to .iter()
     let _ = std::path::Path::new("12/34").into_iter(); //~ WARN equivalent to .iter()
     let _ = std::path::PathBuf::from("12/34").into_iter(); //~ ERROR equivalent to .iter()
+
+    let _ = (&[1, 2, 3]).into_iter().next(); //~ WARN equivalent to .iter()
 }
diff --git a/tests/ui/into_iter_on_ref.stderr b/tests/ui/into_iter_on_ref.stderr
index 80e2d104f82..1cd6400b019 100644
--- a/tests/ui/into_iter_on_ref.stderr
+++ b/tests/ui/into_iter_on_ref.stderr
@@ -156,5 +156,11 @@ error: this `.into_iter()` call is equivalent to `.iter()` and will not move the
 LL |     let _ = std::path::PathBuf::from("12/34").into_iter(); //~ ERROR equivalent to .iter()
    |                                               ^^^^^^^^^ help: call directly: `iter`
 
-error: aborting due to 26 previous errors
+error: this `.into_iter()` call is equivalent to `.iter()` and will not move the `array`
+  --> $DIR/into_iter_on_ref.rs:44:26
+   |
+LL |     let _ = (&[1, 2, 3]).into_iter().next(); //~ WARN equivalent to .iter()
+   |                          ^^^^^^^^^ help: call directly: `iter`
+
+error: aborting due to 27 previous errors
 
diff --git a/tests/ui/iter_next_slice.fixed b/tests/ui/iter_next_slice.fixed
new file mode 100644
index 00000000000..79c1db87ac3
--- /dev/null
+++ b/tests/ui/iter_next_slice.fixed
@@ -0,0 +1,24 @@
+// run-rustfix
+#![warn(clippy::iter_next_slice)]
+
+fn main() {
+    // test code goes here
+    let s = [1, 2, 3];
+    let v = vec![1, 2, 3];
+
+    s.get(0);
+    // Should be replaced by s.get(0)
+
+    s.get(2);
+    // Should be replaced by s.get(2)
+
+    v.get(5);
+    // Should be replaced by v.get(5)
+
+    v.get(0);
+    // Should be replaced by v.get(0)
+
+    let o = Some(5);
+    o.iter().next();
+    // Shouldn't be linted since this is not a Slice or an Array
+}
diff --git a/tests/ui/iter_next_slice.rs b/tests/ui/iter_next_slice.rs
new file mode 100644
index 00000000000..ef9a55f3d99
--- /dev/null
+++ b/tests/ui/iter_next_slice.rs
@@ -0,0 +1,24 @@
+// run-rustfix
+#![warn(clippy::iter_next_slice)]
+
+fn main() {
+    // test code goes here
+    let s = [1, 2, 3];
+    let v = vec![1, 2, 3];
+
+    s.iter().next();
+    // Should be replaced by s.get(0)
+
+    s[2..].iter().next();
+    // Should be replaced by s.get(2)
+
+    v[5..].iter().next();
+    // Should be replaced by v.get(5)
+
+    v.iter().next();
+    // Should be replaced by v.get(0)
+
+    let o = Some(5);
+    o.iter().next();
+    // Shouldn't be linted since this is not a Slice or an Array
+}
diff --git a/tests/ui/iter_next_slice.stderr b/tests/ui/iter_next_slice.stderr
new file mode 100644
index 00000000000..bbf61df0cda
--- /dev/null
+++ b/tests/ui/iter_next_slice.stderr
@@ -0,0 +1,28 @@
+error: Using `.iter().next()` on an array
+  --> $DIR/iter_next_slice.rs:9:5
+   |
+LL |     s.iter().next();
+   |     ^^^^^^^^^^^^^^^ help: try calling: `s.get(0)`
+   |
+   = note: `-D clippy::iter-next-slice` implied by `-D warnings`
+
+error: Using `.iter().next()` on a Slice without end index.
+  --> $DIR/iter_next_slice.rs:12:5
+   |
+LL |     s[2..].iter().next();
+   |     ^^^^^^^^^^^^^^^^^^^^ help: try calling: `s.get(2)`
+
+error: Using `.iter().next()` on a Slice without end index.
+  --> $DIR/iter_next_slice.rs:15:5
+   |
+LL |     v[5..].iter().next();
+   |     ^^^^^^^^^^^^^^^^^^^^ help: try calling: `v.get(5)`
+
+error: Using `.iter().next()` on an array
+  --> $DIR/iter_next_slice.rs:18:5
+   |
+LL |     v.iter().next();
+   |     ^^^^^^^^^^^^^^^ help: try calling: `v.get(0)`
+
+error: aborting due to 4 previous errors
+
diff --git a/tests/ui/needless_collect.fixed b/tests/ui/needless_collect.fixed
index b4227eaf2f8..be37dc16b9a 100644
--- a/tests/ui/needless_collect.fixed
+++ b/tests/ui/needless_collect.fixed
@@ -9,7 +9,7 @@ use std::collections::{BTreeSet, HashMap, HashSet};
 fn main() {
     let sample = [1; 5];
     let len = sample.iter().count();
-    if sample.iter().next().is_none() {
+    if sample.get(0).is_none() {
         // Empty
     }
     sample.iter().cloned().any(|x| x == 1);
diff --git a/tests/ui/needless_collect.stderr b/tests/ui/needless_collect.stderr
index 8884c8e1612..9113aad90dd 100644
--- a/tests/ui/needless_collect.stderr
+++ b/tests/ui/needless_collect.stderr
@@ -1,28 +1,28 @@
 error: avoid using `collect()` when not needed
-  --> $DIR/needless_collect.rs:11:28
+  --> $DIR/needless_collect.rs:11:29
    |
 LL |     let len = sample.iter().collect::<Vec<_>>().len();
-   |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `.count()`
+   |                             ^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `count()`
    |
    = note: `-D clippy::needless-collect` implied by `-D warnings`
 
 error: avoid using `collect()` when not needed
-  --> $DIR/needless_collect.rs:12:21
+  --> $DIR/needless_collect.rs:12:15
    |
 LL |     if sample.iter().collect::<Vec<_>>().is_empty() {
-   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `.next().is_none()`
+   |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `get(0).is_none()`
 
 error: avoid using `collect()` when not needed
-  --> $DIR/needless_collect.rs:15:27
+  --> $DIR/needless_collect.rs:15:28
    |
 LL |     sample.iter().cloned().collect::<Vec<_>>().contains(&1);
-   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `.any(|x| x == 1)`
+   |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `any(|x| x == 1)`
 
 error: avoid using `collect()` when not needed
-  --> $DIR/needless_collect.rs:16:34
+  --> $DIR/needless_collect.rs:16:35
    |
 LL |     sample.iter().map(|x| (x, x)).collect::<HashMap<_, _>>().len();
-   |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `.count()`
+   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `count()`
 
 error: aborting due to 4 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 9a5baed482b68e0d9806e19eb9e8676d7ff3e1c2 Mon Sep 17 00:00:00 2001
From: JarredAllen <jarredallen73@gmail.com>
Date: Sun, 31 May 2020 15:09:12 -0700
Subject: Implement suggestions from phansch

---
 clippy_lints/src/unnecessary_sort_by.rs | 41 ++++++++++++++++++++++++++-------
 tests/ui/unnecessary_sort_by.fixed      |  7 +++---
 tests/ui/unnecessary_sort_by.rs         |  7 +++---
 tests/ui/unnecessary_sort_by.stderr     | 26 +++++++++++++--------
 4 files changed, 57 insertions(+), 24 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unnecessary_sort_by.rs b/clippy_lints/src/unnecessary_sort_by.rs
index c0858ec4c88..33d8331c292 100644
--- a/clippy_lints/src/unnecessary_sort_by.rs
+++ b/clippy_lints/src/unnecessary_sort_by.rs
@@ -18,15 +18,25 @@ declare_clippy_lint! {
     /// possible) than to use `Vec::sort_by` and and a more complicated
     /// closure.
     ///
-    /// **Known problems:** None.
+    /// **Known problems:**
+    /// If the suggested `Vec::sort_by_key` uses Reverse and it isn't
+    /// imported by a use statement in the current frame, then a `use`
+    /// statement that imports it will need to be added (which this lint
+    /// can't do).
     ///
     /// **Example:**
     ///
     /// ```rust
-    /// vec.sort_by(|a, b| a.foo().cmp(b.foo()));
+    /// # struct A;
+    /// # impl A { fn foo(&self) {} }
+    /// # let mut vec: Vec<A> = Vec::new();
+    /// vec.sort_by(|a, b| a.foo().cmp(&b.foo()));
     /// ```
     /// Use instead:
     /// ```rust
+    /// # struct A;
+    /// # impl A { fn foo(&self) {} }
+    /// # let mut vec: Vec<A> = Vec::new();
     /// vec.sort_by_key(|a| a.foo());
     /// ```
     pub UNNECESSARY_SORT_BY,
@@ -50,6 +60,7 @@ struct SortByKeyDetection {
     vec_name: String,
     closure_arg: String,
     closure_body: String,
+    reverse: bool,
     unstable: bool,
 }
 
@@ -172,16 +183,16 @@ fn detect_lint(cx: &LateContext<'_, '_>, expr: &Expr<'_>) -> Option<LintTrigger>
         if let ExprKind::MethodCall(method_path, _, [ref left_expr, ref right_expr]) = &closure_body.value.kind;
         if method_path.ident.name.to_ident_string() == "cmp";
         then {
-            let (closure_body, closure_arg) = if mirrored_exprs(
+            let (closure_body, closure_arg, reverse) = if mirrored_exprs(
                 &cx,
                 &left_expr,
                 &left_ident,
                 &right_expr,
                 &right_ident
             ) {
-                (Sugg::hir(cx, &left_expr, "..").to_string(), left_ident.name.to_string())
+                (Sugg::hir(cx, &left_expr, "..").to_string(), left_ident.name.to_string(), false)
             } else if mirrored_exprs(&cx, &left_expr, &right_ident, &right_expr, &left_ident) {
-                (format!("Reverse({})", Sugg::hir(cx, &left_expr, "..").to_string()), right_ident.name.to_string())
+                (Sugg::hir(cx, &left_expr, "..").to_string(), right_ident.name.to_string(), true)
             } else {
                 return None;
             };
@@ -196,7 +207,13 @@ fn detect_lint(cx: &LateContext<'_, '_>, expr: &Expr<'_>) -> Option<LintTrigger>
                     Some(LintTrigger::Sort(SortDetection { vec_name, unstable }))
                 }
                 else {
-                    Some(LintTrigger::SortByKey(SortByKeyDetection { vec_name, unstable, closure_arg, closure_body }))
+                    Some(LintTrigger::SortByKey(SortByKeyDetection {
+                        vec_name,
+                        unstable,
+                        closure_arg,
+                        closure_body,
+                        reverse
+                    }))
                 }
             }
         } else {
@@ -219,9 +236,17 @@ impl LateLintPass<'_, '_> for UnnecessarySortBy {
                     trigger.vec_name,
                     if trigger.unstable { "_unstable" } else { "" },
                     trigger.closure_arg,
-                    trigger.closure_body,
+                    if trigger.reverse {
+                        format!("Reverse({})", trigger.closure_body)
+                    } else {
+                        trigger.closure_body.to_string()
+                    },
                 ),
-                Applicability::MachineApplicable,
+                if trigger.reverse {
+                    Applicability::MaybeIncorrect
+                } else {
+                    Applicability::MachineApplicable
+                },
             ),
             Some(LintTrigger::Sort(trigger)) => utils::span_lint_and_sugg(
                 cx,
diff --git a/tests/ui/unnecessary_sort_by.fixed b/tests/ui/unnecessary_sort_by.fixed
index 4521ae38d49..779fd57707a 100644
--- a/tests/ui/unnecessary_sort_by.fixed
+++ b/tests/ui/unnecessary_sort_by.fixed
@@ -10,16 +10,17 @@ fn main() {
     let mut vec: Vec<isize> = vec![3, 6, 1, 2, 5];
     // Forward examples
     vec.sort();
+    vec.sort_unstable();
     vec.sort_by_key(|&a| (a + 5).abs());
-    vec.sort_by_key(|&a| id(-a));
+    vec.sort_unstable_by_key(|&a| id(-a));
     // Reverse examples
     vec.sort_by_key(|&b| Reverse(b));
     vec.sort_by_key(|&b| Reverse((b + 5).abs()));
-    vec.sort_by_key(|&b| Reverse(id(-b)));
+    vec.sort_unstable_by_key(|&b| Reverse(id(-b)));
     // Negative examples (shouldn't be changed)
     let c = &7;
     vec.sort_by(|a, b| (b - a).cmp(&(a - b)));
     vec.sort_by(|_, b| b.cmp(&5));
     vec.sort_by(|_, b| b.cmp(c));
-    vec.sort_by(|a, _| a.cmp(c));
+    vec.sort_unstable_by(|a, _| a.cmp(c));
 }
diff --git a/tests/ui/unnecessary_sort_by.rs b/tests/ui/unnecessary_sort_by.rs
index fdb5a823369..0485a5630af 100644
--- a/tests/ui/unnecessary_sort_by.rs
+++ b/tests/ui/unnecessary_sort_by.rs
@@ -10,16 +10,17 @@ fn main() {
     let mut vec: Vec<isize> = vec![3, 6, 1, 2, 5];
     // Forward examples
     vec.sort_by(|a, b| a.cmp(b));
+    vec.sort_unstable_by(|a, b| a.cmp(b));
     vec.sort_by(|a, b| (a + 5).abs().cmp(&(b + 5).abs()));
-    vec.sort_by(|a, b| id(-a).cmp(&id(-b)));
+    vec.sort_unstable_by(|a, b| id(-a).cmp(&id(-b)));
     // Reverse examples
     vec.sort_by(|a, b| b.cmp(a));
     vec.sort_by(|a, b| (b + 5).abs().cmp(&(a + 5).abs()));
-    vec.sort_by(|a, b| id(-b).cmp(&id(-a)));
+    vec.sort_unstable_by(|a, b| id(-b).cmp(&id(-a)));
     // Negative examples (shouldn't be changed)
     let c = &7;
     vec.sort_by(|a, b| (b - a).cmp(&(a - b)));
     vec.sort_by(|_, b| b.cmp(&5));
     vec.sort_by(|_, b| b.cmp(c));
-    vec.sort_by(|a, _| a.cmp(c));
+    vec.sort_unstable_by(|a, _| a.cmp(c));
 }
diff --git a/tests/ui/unnecessary_sort_by.stderr b/tests/ui/unnecessary_sort_by.stderr
index b6365c1709d..903b6e5099c 100644
--- a/tests/ui/unnecessary_sort_by.stderr
+++ b/tests/ui/unnecessary_sort_by.stderr
@@ -6,35 +6,41 @@ LL |     vec.sort_by(|a, b| a.cmp(b));
    |
    = note: `-D clippy::unnecessary-sort-by` implied by `-D warnings`
 
-error: use Vec::sort_by_key here instead
+error: use Vec::sort here instead
   --> $DIR/unnecessary_sort_by.rs:13:5
    |
+LL |     vec.sort_unstable_by(|a, b| a.cmp(b));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_unstable()`
+
+error: use Vec::sort_by_key here instead
+  --> $DIR/unnecessary_sort_by.rs:14:5
+   |
 LL |     vec.sort_by(|a, b| (a + 5).abs().cmp(&(b + 5).abs()));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_by_key(|&a| (a + 5).abs())`
 
 error: use Vec::sort_by_key here instead
-  --> $DIR/unnecessary_sort_by.rs:14:5
+  --> $DIR/unnecessary_sort_by.rs:15:5
    |
-LL |     vec.sort_by(|a, b| id(-a).cmp(&id(-b)));
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_by_key(|&a| id(-a))`
+LL |     vec.sort_unstable_by(|a, b| id(-a).cmp(&id(-b)));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_unstable_by_key(|&a| id(-a))`
 
 error: use Vec::sort_by_key here instead
-  --> $DIR/unnecessary_sort_by.rs:16:5
+  --> $DIR/unnecessary_sort_by.rs:17:5
    |
 LL |     vec.sort_by(|a, b| b.cmp(a));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_by_key(|&b| Reverse(b))`
 
 error: use Vec::sort_by_key here instead
-  --> $DIR/unnecessary_sort_by.rs:17:5
+  --> $DIR/unnecessary_sort_by.rs:18:5
    |
 LL |     vec.sort_by(|a, b| (b + 5).abs().cmp(&(a + 5).abs()));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_by_key(|&b| Reverse((b + 5).abs()))`
 
 error: use Vec::sort_by_key here instead
-  --> $DIR/unnecessary_sort_by.rs:18:5
+  --> $DIR/unnecessary_sort_by.rs:19:5
    |
-LL |     vec.sort_by(|a, b| id(-b).cmp(&id(-a)));
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_by_key(|&b| Reverse(id(-b)))`
+LL |     vec.sort_unstable_by(|a, b| id(-b).cmp(&id(-a)));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_unstable_by_key(|&b| Reverse(id(-b)))`
 
-error: aborting due to 6 previous errors
+error: aborting due to 7 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From b89880a30ce4dd7887614f305a565b6779dc4825 Mon Sep 17 00:00:00 2001
From: JarredAllen <jarredallen73@gmail.com>
Date: Sun, 31 May 2020 15:19:31 -0700
Subject: Ran update_lints

---
 CHANGELOG.md            |  2 +-
 clippy_lints/src/lib.rs |  6 +++---
 src/lintlist/mod.rs     | 14 +++++++-------
 3 files changed, 11 insertions(+), 11 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index c00f84bdb85..086a1141be5 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1555,7 +1555,6 @@ Released 2018-09-13
 [`single_match_else`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_match_else
 [`skip_while_next`]: https://rust-lang.github.io/rust-clippy/master/index.html#skip_while_next
 [`slow_vector_initialization`]: https://rust-lang.github.io/rust-clippy/master/index.html#slow_vector_initialization
-[`sort_by_key_reverse`]: https://rust-lang.github.io/rust-clippy/master/index.html#sort_by_key_reverse
 [`str_to_string`]: https://rust-lang.github.io/rust-clippy/master/index.html#str_to_string
 [`string_add`]: https://rust-lang.github.io/rust-clippy/master/index.html#string_add
 [`string_add_assign`]: https://rust-lang.github.io/rust-clippy/master/index.html#string_add_assign
@@ -1602,6 +1601,7 @@ Released 2018-09-13
 [`unnecessary_fold`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_fold
 [`unnecessary_mut_passed`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_mut_passed
 [`unnecessary_operation`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_operation
+[`unnecessary_sort_by`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_sort_by
 [`unnecessary_unwrap`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_unwrap
 [`unneeded_field_pattern`]: https://rust-lang.github.io/rust-clippy/master/index.html#unneeded_field_pattern
 [`unneeded_wildcard_pattern`]: https://rust-lang.github.io/rust-clippy/master/index.html#unneeded_wildcard_pattern
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index fd832d11577..03addf1f4a4 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -780,7 +780,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &shadow::SHADOW_UNRELATED,
         &single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS,
         &slow_vector_initialization::SLOW_VECTOR_INITIALIZATION,
-        &unnecessary_sort_by::UNNECESSARY_SORT_BY,
         &strings::STRING_ADD,
         &strings::STRING_ADD_ASSIGN,
         &strings::STRING_LIT_AS_BYTES,
@@ -835,6 +834,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &unicode::ZERO_WIDTH_SPACE,
         &unnamed_address::FN_ADDRESS_COMPARISONS,
         &unnamed_address::VTABLE_ADDRESS_COMPARISONS,
+        &unnecessary_sort_by::UNNECESSARY_SORT_BY,
         &unsafe_removed_from_name::UNSAFE_REMOVED_FROM_NAME,
         &unused_io_amount::UNUSED_IO_AMOUNT,
         &unused_self::UNUSED_SELF,
@@ -1394,7 +1394,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&serde_api::SERDE_API_MISUSE),
         LintId::of(&single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS),
         LintId::of(&slow_vector_initialization::SLOW_VECTOR_INITIALIZATION),
-        LintId::of(&unnecessary_sort_by::UNNECESSARY_SORT_BY),
         LintId::of(&strings::STRING_LIT_AS_BYTES),
         LintId::of(&suspicious_trait_impl::SUSPICIOUS_ARITHMETIC_IMPL),
         LintId::of(&suspicious_trait_impl::SUSPICIOUS_OP_ASSIGN_IMPL),
@@ -1431,6 +1430,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&unicode::ZERO_WIDTH_SPACE),
         LintId::of(&unnamed_address::FN_ADDRESS_COMPARISONS),
         LintId::of(&unnamed_address::VTABLE_ADDRESS_COMPARISONS),
+        LintId::of(&unnecessary_sort_by::UNNECESSARY_SORT_BY),
         LintId::of(&unsafe_removed_from_name::UNSAFE_REMOVED_FROM_NAME),
         LintId::of(&unused_io_amount::UNUSED_IO_AMOUNT),
         LintId::of(&unwrap::PANICKING_UNWRAP),
@@ -1596,7 +1596,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&ranges::RANGE_ZIP_WITH_LEN),
         LintId::of(&reference::DEREF_ADDROF),
         LintId::of(&reference::REF_IN_DEREF),
-        LintId::of(&unnecessary_sort_by::UNNECESSARY_SORT_BY),
         LintId::of(&swap::MANUAL_SWAP),
         LintId::of(&temporary_assignment::TEMPORARY_ASSIGNMENT),
         LintId::of(&transmute::CROSSPOINTER_TRANSMUTE),
@@ -1613,6 +1612,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&types::UNIT_ARG),
         LintId::of(&types::UNNECESSARY_CAST),
         LintId::of(&types::VEC_BOX),
+        LintId::of(&unnecessary_sort_by::UNNECESSARY_SORT_BY),
         LintId::of(&unwrap::UNNECESSARY_UNWRAP),
         LintId::of(&useless_conversion::USELESS_CONVERSION),
         LintId::of(&zero_div_zero::ZERO_DIVIDED_BY_ZERO),
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index b5d9ef0110e..ab9542a7b9c 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -1984,13 +1984,6 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
         deprecation: None,
         module: "slow_vector_initialization",
     },
-    Lint {
-        name: "sort_by_key_reverse",
-        group: "complexity",
-        desc: "Use of `Vec::sort_by` when `Vec::sort_by_key` would be clearer",
-        deprecation: None,
-        module: "sort_by_key_reverse",
-    },
     Lint {
         name: "string_add",
         group: "restriction",
@@ -2299,6 +2292,13 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
         deprecation: None,
         module: "no_effect",
     },
+    Lint {
+        name: "unnecessary_sort_by",
+        group: "complexity",
+        desc: "Use of `Vec::sort_by` when `Vec::sort_by_key` or `Vec::sort` would be clearer",
+        deprecation: None,
+        module: "unnecessary_sort_by",
+    },
     Lint {
         name: "unnecessary_unwrap",
         group: "complexity",
-- 
cgit 1.4.1-3-g733a5


From 61587c9a294a423fb9eb9d57c5856c9e83e22d42 Mon Sep 17 00:00:00 2001
From: ThibsG <Thibs@debian.com>
Date: Wed, 27 May 2020 16:24:53 +0200
Subject: Fix some code examples in doc

---
 clippy_lints/src/assign_ops.rs            |  4 ++++
 clippy_lints/src/double_parens.rs         | 18 +++++++++++++++--
 clippy_lints/src/drop_bounds.rs           |  4 ++++
 clippy_lints/src/duration_subsec.rs       |  6 ++++++
 clippy_lints/src/enum_variants.rs         | 32 ++++++++++++++++++++++++++-----
 clippy_lints/src/eq_op.rs                 |  4 ++++
 clippy_lints/src/escape.rs                |  7 +++++++
 clippy_lints/src/eta_reduction.rs         |  4 ++++
 clippy_lints/src/eval_order_dependence.rs |  6 ++++++
 9 files changed, 78 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/assign_ops.rs b/clippy_lints/src/assign_ops.rs
index 05e2650d0b7..13e61fe98ba 100644
--- a/clippy_lints/src/assign_ops.rs
+++ b/clippy_lints/src/assign_ops.rs
@@ -24,7 +24,11 @@ declare_clippy_lint! {
     /// let mut a = 5;
     /// let b = 0;
     /// // ...
+    /// // Bad
     /// a = a + b;
+    ///
+    /// // Good
+    /// a += b;
     /// ```
     pub ASSIGN_OP_PATTERN,
     style,
diff --git a/clippy_lints/src/double_parens.rs b/clippy_lints/src/double_parens.rs
index 7f2ff8b9b26..05517f6f9f0 100644
--- a/clippy_lints/src/double_parens.rs
+++ b/clippy_lints/src/double_parens.rs
@@ -13,10 +13,24 @@ declare_clippy_lint! {
     ///
     /// **Example:**
     /// ```rust
+    /// // Bad
+    /// fn simple_double_parens() -> i32 {
+    ///     ((0))
+    /// }
+    ///
+    /// // Good
+    /// fn simple_no_parens() -> i32 {
+    ///     0
+    /// }
+    ///
+    /// // or
+    ///
     /// # fn foo(bar: usize) {}
-    /// ((0));
+    /// // Bad
     /// foo((0));
-    /// ((1, 2));
+    ///
+    /// // Good
+    /// foo(0);
     /// ```
     pub DOUBLE_PARENS,
     complexity,
diff --git a/clippy_lints/src/drop_bounds.rs b/clippy_lints/src/drop_bounds.rs
index f4966808279..4ef963ac314 100644
--- a/clippy_lints/src/drop_bounds.rs
+++ b/clippy_lints/src/drop_bounds.rs
@@ -27,6 +27,10 @@ declare_clippy_lint! {
     /// ```rust
     /// fn foo<T: Drop>() {}
     /// ```
+    /// Could be written as:
+    /// ```rust
+    /// fn foo() {}
+    /// ```
     pub DROP_BOUNDS,
     correctness,
     "Bounds of the form `T: Drop` are useless"
diff --git a/clippy_lints/src/duration_subsec.rs b/clippy_lints/src/duration_subsec.rs
index b35a8facf8b..afefa250638 100644
--- a/clippy_lints/src/duration_subsec.rs
+++ b/clippy_lints/src/duration_subsec.rs
@@ -22,8 +22,14 @@ declare_clippy_lint! {
     /// ```rust
     /// # use std::time::Duration;
     /// let dur = Duration::new(5, 0);
+    ///
+    /// // Bad
     /// let _micros = dur.subsec_nanos() / 1_000;
     /// let _millis = dur.subsec_nanos() / 1_000_000;
+    ///
+    /// // Good
+    /// let _micros = dur.subsec_micros();
+    /// let _millis = dur.subsec_millis();
     /// ```
     pub DURATION_SUBSEC,
     complexity,
diff --git a/clippy_lints/src/enum_variants.rs b/clippy_lints/src/enum_variants.rs
index a5871cf0cd4..cb0fd59a2d4 100644
--- a/clippy_lints/src/enum_variants.rs
+++ b/clippy_lints/src/enum_variants.rs
@@ -25,31 +25,47 @@ declare_clippy_lint! {
     ///     BattenbergCake,
     /// }
     /// ```
+    /// Could be written as:
+    /// ```rust
+    /// enum Cake {
+    ///     BlackForest,
+    ///     Hummingbird,
+    ///     Battenberg,
+    /// }
+    /// ```
     pub ENUM_VARIANT_NAMES,
     style,
     "enums where all variants share a prefix/postfix"
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Detects enumeration variants that are prefixed or suffixed
-    /// by the same characters.
+    /// **What it does:** Detects public enumeration variants that are
+    /// prefixed or suffixed by the same characters.
     ///
-    /// **Why is this bad?** Enumeration variant names should specify their variant,
+    /// **Why is this bad?** Public enumeration variant names should specify their variant,
     /// not repeat the enumeration name.
     ///
     /// **Known problems:** None.
     ///
     /// **Example:**
     /// ```rust
-    /// enum Cake {
+    /// pub enum Cake {
     ///     BlackForestCake,
     ///     HummingbirdCake,
     ///     BattenbergCake,
     /// }
     /// ```
+    /// Could be written as:
+    /// ```rust
+    /// pub enum Cake {
+    ///     BlackForest,
+    ///     Hummingbird,
+    ///     Battenberg,
+    /// }
+    /// ```
     pub PUB_ENUM_VARIANT_NAMES,
     pedantic,
-    "enums where all variants share a prefix/postfix"
+    "public enums where all variants share a prefix/postfix"
 }
 
 declare_clippy_lint! {
@@ -66,6 +82,12 @@ declare_clippy_lint! {
     ///     struct BlackForestCake;
     /// }
     /// ```
+    /// Could be written as:
+    /// ```rust
+    /// mod cake {
+    ///     struct BlackForest;
+    /// }
+    /// ```
     pub MODULE_NAME_REPETITIONS,
     pedantic,
     "type names prefixed/postfixed with their containing module's name"
diff --git a/clippy_lints/src/eq_op.rs b/clippy_lints/src/eq_op.rs
index 4e1c1f13140..d7819d737ea 100644
--- a/clippy_lints/src/eq_op.rs
+++ b/clippy_lints/src/eq_op.rs
@@ -39,7 +39,11 @@ declare_clippy_lint! {
     ///
     /// **Example:**
     /// ```ignore
+    /// // Bad
     /// &x == y
+    ///
+    /// // Good
+    /// x == *y
     /// ```
     pub OP_REF,
     style,
diff --git a/clippy_lints/src/escape.rs b/clippy_lints/src/escape.rs
index 1ec60a0e6e6..7227683aa5a 100644
--- a/clippy_lints/src/escape.rs
+++ b/clippy_lints/src/escape.rs
@@ -28,9 +28,16 @@ declare_clippy_lint! {
     /// **Example:**
     /// ```rust
     /// # fn foo(bar: usize) {}
+    ///
+    /// // Bad
     /// let x = Box::new(1);
     /// foo(*x);
     /// println!("{}", *x);
+    ///
+    /// // Good
+    /// let x = 1;
+    /// foo(x);
+    /// println!("{}", x);
     /// ```
     pub BOXED_LOCAL,
     perf,
diff --git a/clippy_lints/src/eta_reduction.rs b/clippy_lints/src/eta_reduction.rs
index e3e1136b676..5f0cd1ec72c 100644
--- a/clippy_lints/src/eta_reduction.rs
+++ b/clippy_lints/src/eta_reduction.rs
@@ -26,7 +26,11 @@ declare_clippy_lint! {
     ///
     /// **Example:**
     /// ```rust,ignore
+    /// // Bad
     /// xs.map(|x| foo(x))
+    ///
+    /// // Good
+    /// foo(xs)
     /// ```
     /// where `foo(_)` is a plain function that takes the exact argument type of
     /// `x`.
diff --git a/clippy_lints/src/eval_order_dependence.rs b/clippy_lints/src/eval_order_dependence.rs
index 5206266ccf2..37e24ff34f7 100644
--- a/clippy_lints/src/eval_order_dependence.rs
+++ b/clippy_lints/src/eval_order_dependence.rs
@@ -21,11 +21,17 @@ declare_clippy_lint! {
     /// **Example:**
     /// ```rust
     /// let mut x = 0;
+    ///
+    /// // Bad
     /// let a = {
     ///     x = 1;
     ///     1
     /// } + x;
     /// // Unclear whether a is 1 or 2.
+    ///
+    /// // Good
+    /// x = 1;
+    /// let a = 1 + x;
     /// ```
     pub EVAL_ORDER_DEPENDENCE,
     complexity,
-- 
cgit 1.4.1-3-g733a5


From 262c9dc025042646610df879dd9708eea625534d Mon Sep 17 00:00:00 2001
From: ThibsG <Thibs@debian.com>
Date: Fri, 29 May 2020 18:15:42 +0200
Subject: Fix more code examples

---
 clippy_lints/src/fallible_impl_from.rs        | 15 +++++++++++++--
 clippy_lints/src/floating_point_arithmetic.rs |  2 --
 clippy_lints/src/format.rs                    |  6 +++++-
 clippy_lints/src/functions.rs                 | 14 ++++++++++----
 clippy_lints/src/implicit_saturating_sub.rs   |  7 -------
 clippy_lints/src/int_plus_one.rs              |  1 -
 clippy_lints/src/integer_division.rs          | 11 +++++++----
 clippy_lints/src/items_after_statements.rs    | 16 ++++++++++++++++
 8 files changed, 51 insertions(+), 21 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/fallible_impl_from.rs b/clippy_lints/src/fallible_impl_from.rs
index 17639cc2a06..575462f25e6 100644
--- a/clippy_lints/src/fallible_impl_from.rs
+++ b/clippy_lints/src/fallible_impl_from.rs
@@ -18,13 +18,24 @@ declare_clippy_lint! {
     /// **Known problems:** None.
     ///
     /// **Example:**
-    /// ```rust
+    /// ```rust,ignore
     /// struct Foo(i32);
+    ///
+    /// // Bad
     /// impl From<String> for Foo {
     ///     fn from(s: String) -> Self {
     ///         Foo(s.parse().unwrap())
     ///     }
     /// }
+    ///
+    /// // Good
+    /// use std::convert::TryFrom;
+    /// impl TryFrom<String> for Foo {
+    ///     type Error = ();
+    ///     fn try_from(s: String) -> Result<Self, Self::Error> {
+    ///         s.parse()
+    ///     }
+    /// }
     /// ```
     pub FALLIBLE_IMPL_FROM,
     nursery,
@@ -120,7 +131,7 @@ fn lint_impl_body<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, impl_span: Span, impl_it
                         move |diag| {
                             diag.help(
                                 "`From` is intended for infallible conversions only. \
-                                 Use `TryFrom` if there's a possibility for the conversion to fail.");
+                                Use `TryFrom` if there's a possibility for the conversion to fail.");
                             diag.span_note(fpu.result, "potential failure(s)");
                         });
                 }
diff --git a/clippy_lints/src/floating_point_arithmetic.rs b/clippy_lints/src/floating_point_arithmetic.rs
index 86317fb8bd5..3a912d92837 100644
--- a/clippy_lints/src/floating_point_arithmetic.rs
+++ b/clippy_lints/src/floating_point_arithmetic.rs
@@ -28,7 +28,6 @@ declare_clippy_lint! {
     /// **Example:**
     ///
     /// ```rust
-    ///
     /// let a = 3f32;
     /// let _ = a.powf(1.0 / 3.0);
     /// let _ = (1.0 + a).ln();
@@ -38,7 +37,6 @@ declare_clippy_lint! {
     /// is better expressed as
     ///
     /// ```rust
-    ///
     /// let a = 3f32;
     /// let _ = a.cbrt();
     /// let _ = a.ln_1p();
diff --git a/clippy_lints/src/format.rs b/clippy_lints/src/format.rs
index 5b092526ce4..1530538aa7d 100644
--- a/clippy_lints/src/format.rs
+++ b/clippy_lints/src/format.rs
@@ -25,9 +25,13 @@ declare_clippy_lint! {
     ///
     /// **Examples:**
     /// ```rust
+    ///
+    /// // Bad
     /// # let foo = "foo";
-    /// format!("foo");
     /// format!("{}", foo);
+    ///
+    /// // Good
+    /// format!("foo");
     /// ```
     pub USELESS_FORMAT,
     complexity,
diff --git a/clippy_lints/src/functions.rs b/clippy_lints/src/functions.rs
index c24a24733d7..9b5f1dee7f4 100644
--- a/clippy_lints/src/functions.rs
+++ b/clippy_lints/src/functions.rs
@@ -49,11 +49,11 @@ declare_clippy_lint! {
     /// **Known problems:** None.
     ///
     /// **Example:**
-    /// ``` rust
+    /// ```rust
     /// fn im_too_long() {
-    /// println!("");
+    ///     println!("");
     /// // ... 100 more LoC
-    /// println!("");
+    ///     println!("");
     /// }
     /// ```
     pub TOO_MANY_LINES,
@@ -79,10 +79,16 @@ declare_clippy_lint! {
     /// `some_argument.get_raw_ptr()`).
     ///
     /// **Example:**
-    /// ```rust
+    /// ```rust,ignore
+    /// // Bad
     /// pub fn foo(x: *const u8) {
     ///     println!("{}", unsafe { *x });
     /// }
+    ///
+    /// // Good
+    /// pub unsafe fn foo(x: *const u8) {
+    ///     println!("{}", unsafe { *x });
+    /// }
     /// ```
     pub NOT_UNSAFE_PTR_ARG_DEREF,
     correctness,
diff --git a/clippy_lints/src/implicit_saturating_sub.rs b/clippy_lints/src/implicit_saturating_sub.rs
index 155a93de4fa..fdaf37e5e08 100644
--- a/clippy_lints/src/implicit_saturating_sub.rs
+++ b/clippy_lints/src/implicit_saturating_sub.rs
@@ -25,13 +25,6 @@ declare_clippy_lint! {
     /// if i != 0 {
     ///     i -= 1;
     /// }
-    /// ```
-    /// Use instead:
-    /// ```rust
-    /// let end: u32 = 10;
-    /// let start: u32 = 5;
-    ///
-    /// let mut i: u32 = end - start;
     ///
     /// // Good
     /// i = i.saturating_sub(1);
diff --git a/clippy_lints/src/int_plus_one.rs b/clippy_lints/src/int_plus_one.rs
index d5dbd495680..e91fb0c2f27 100644
--- a/clippy_lints/src/int_plus_one.rs
+++ b/clippy_lints/src/int_plus_one.rs
@@ -10,7 +10,6 @@ use crate::utils::{snippet_opt, span_lint_and_sugg};
 declare_clippy_lint! {
     /// **What it does:** Checks for usage of `x >= y + 1` or `x - 1 >= y` (and `<=`) in a block
     ///
-    ///
     /// **Why is this bad?** Readability -- better to use `> y` instead of `>= y + 1`.
     ///
     /// **Known problems:** None.
diff --git a/clippy_lints/src/integer_division.rs b/clippy_lints/src/integer_division.rs
index fe34d33fe65..d537ef3f323 100644
--- a/clippy_lints/src/integer_division.rs
+++ b/clippy_lints/src/integer_division.rs
@@ -15,10 +15,13 @@ declare_clippy_lint! {
     ///
     /// **Example:**
     /// ```rust
-    /// fn main() {
-    ///     let x = 3 / 2;
-    ///     println!("{}", x);
-    /// }
+    /// // Bad
+    /// let x = 3 / 2;
+    /// println!("{}", x);
+    ///
+    /// // Good
+    /// let x = 3f32 / 2f32;
+    /// println!("{}", x);
     /// ```
     pub INTEGER_DIVISION,
     restriction,
diff --git a/clippy_lints/src/items_after_statements.rs b/clippy_lints/src/items_after_statements.rs
index e7062b7c16b..c8576bcfcb4 100644
--- a/clippy_lints/src/items_after_statements.rs
+++ b/clippy_lints/src/items_after_statements.rs
@@ -16,6 +16,7 @@ declare_clippy_lint! {
     ///
     /// **Example:**
     /// ```rust
+    /// // Bad
     /// fn foo() {
     ///     println!("cake");
     /// }
@@ -28,6 +29,21 @@ declare_clippy_lint! {
     ///     foo(); // prints "foo"
     /// }
     /// ```
+    ///
+    /// ```rust
+    /// // Good
+    /// fn foo() {
+    ///     println!("cake");
+    /// }
+    ///
+    /// fn main() {
+    ///     fn foo() {
+    ///         println!("foo");
+    ///     }
+    ///     foo(); // prints "foo"
+    ///     foo(); // prints "foo"
+    /// }
+    /// ```
     pub ITEMS_AFTER_STATEMENTS,
     pedantic,
     "blocks where an item comes after a statement"
-- 
cgit 1.4.1-3-g733a5


From 19339334cb4e9c6db5a1f7dced38edcb16707bc7 Mon Sep 17 00:00:00 2001
From: ThibsG <Thibs@debian.com>
Date: Sun, 31 May 2020 11:38:48 +0200
Subject: Give more corrected code examples in doc

---
 clippy_lints/src/literal_representation.rs        | 12 +++++++
 clippy_lints/src/matches.rs                       | 44 ++++++++++++++++++++---
 clippy_lints/src/misc.rs                          | 31 ++++++++++++++--
 clippy_lints/src/misc_early.rs                    | 34 ++++++++++++++----
 clippy_lints/src/mut_reference.rs                 |  4 +++
 clippy_lints/src/mutex_atomic.rs                  | 12 ++++++-
 clippy_lints/src/needless_bool.rs                 |  3 +-
 clippy_lints/src/needless_borrow.rs               |  8 +++--
 clippy_lints/src/needless_pass_by_value.rs        |  3 +-
 clippy_lints/src/needless_update.rs               | 10 ++++++
 clippy_lints/src/ptr.rs                           | 23 +++++++-----
 clippy_lints/src/question_mark.rs                 |  2 +-
 clippy_lints/src/reference.rs                     |  5 +++
 clippy_lints/src/regex.rs                         | 12 ++++---
 clippy_lints/src/shadow.rs                        | 10 ++++++
 clippy_lints/src/single_component_path_imports.rs |  4 +--
 clippy_lints/src/slow_vector_initialization.rs    |  8 ++++-
 clippy_lints/src/strings.rs                       |  8 +++++
 18 files changed, 195 insertions(+), 38 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/literal_representation.rs b/clippy_lints/src/literal_representation.rs
index ec7c4531ed7..7ba43562d7d 100644
--- a/clippy_lints/src/literal_representation.rs
+++ b/clippy_lints/src/literal_representation.rs
@@ -24,7 +24,11 @@ declare_clippy_lint! {
     /// **Example:**
     ///
     /// ```rust
+    /// // Bad
     /// let x: u64 = 61864918973511;
+    ///
+    /// // Good
+    /// let x: u64 = 61_864_918_973_511;
     /// ```
     pub UNREADABLE_LITERAL,
     pedantic,
@@ -44,7 +48,11 @@ declare_clippy_lint! {
     /// **Example:**
     ///
     /// ```rust
+    /// // Probably mistyped
     /// 2_32;
+    ///
+    /// // Good
+    /// 2_i32;
     /// ```
     pub MISTYPED_LITERAL_SUFFIXES,
     correctness,
@@ -63,7 +71,11 @@ declare_clippy_lint! {
     /// **Example:**
     ///
     /// ```rust
+    /// // Bad
     /// let x: u64 = 618_64_9189_73_511;
+    ///
+    /// // Good
+    /// let x: u64 = 61_864_918_973_511;
     /// ```
     pub INCONSISTENT_DIGIT_GROUPING,
     style,
diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index 94380acfcfd..146212cb2c7 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -36,10 +36,17 @@ declare_clippy_lint! {
     /// ```rust
     /// # fn bar(stool: &str) {}
     /// # let x = Some("abc");
+    ///
+    /// // Bad
     /// match x {
     ///     Some(ref foo) => bar(foo),
     ///     _ => (),
     /// }
+    ///
+    /// // Good
+    /// if let Some(ref foo) = x {
+    ///     bar(foo);
+    /// }
     /// ```
     pub SINGLE_MATCH,
     style,
@@ -97,11 +104,19 @@ declare_clippy_lint! {
     ///
     /// **Example:**
     /// ```rust,ignore
+    /// // Bad
     /// match x {
     ///     &A(ref y) => foo(y),
     ///     &B => bar(),
     ///     _ => frob(&x),
     /// }
+    ///
+    /// // Good
+    /// match *x {
+    ///     A(ref y) => foo(y),
+    ///     B => bar(),
+    ///     _ => frob(x),
+    /// }
     /// ```
     pub MATCH_REF_PATS,
     style,
@@ -197,10 +212,15 @@ declare_clippy_lint! {
     /// **Example:**
     /// ```rust
     /// let x: Option<()> = None;
+    ///
+    /// // Bad
     /// let r: Option<&()> = match x {
     ///     None => None,
     ///     Some(ref v) => Some(v),
     /// };
+    ///
+    /// // Good
+    /// let r: Option<&()> = x.as_ref();
     /// ```
     pub MATCH_AS_REF,
     complexity,
@@ -219,10 +239,18 @@ declare_clippy_lint! {
     /// ```rust
     /// # enum Foo { A(usize), B(usize) }
     /// # let x = Foo::B(1);
+    ///
+    /// // Bad
     /// match x {
     ///     Foo::A(_) => {},
     ///     _ => {},
     /// }
+    ///
+    /// // Good
+    /// match x {
+    ///     Foo::A(_) => {},
+    ///     Foo::B(_) => {},
+    /// }
     /// ```
     pub WILDCARD_ENUM_MATCH_ARM,
     restriction,
@@ -242,16 +270,15 @@ declare_clippy_lint! {
     /// ```rust
     /// # enum Foo { A, B, C }
     /// # let x = Foo::B;
+    ///
+    /// // Bad
     /// match x {
     ///     Foo::A => {},
     ///     Foo::B => {},
     ///     _ => {},
     /// }
-    /// ```
-    /// Use instead:
-    /// ```rust
-    /// # enum Foo { A, B, C }
-    /// # let x = Foo::B;
+    ///
+    /// // Good
     /// match x {
     ///     Foo::A => {},
     ///     Foo::B => {},
@@ -273,10 +300,17 @@ declare_clippy_lint! {
     ///
     /// **Example:**
     /// ```rust
+    /// // Bad
     /// match "foo" {
     ///     "a" => {},
     ///     "bar" | _ => {},
     /// }
+    ///
+    /// // Good
+    /// match "foo" {
+    ///     "a" => {},
+    ///     _ => {},
+    /// }
     /// ```
     pub WILDCARD_IN_OR_PATTERNS,
     complexity,
diff --git a/clippy_lints/src/misc.rs b/clippy_lints/src/misc.rs
index e1d524c2231..a3b7134a376 100644
--- a/clippy_lints/src/misc.rs
+++ b/clippy_lints/src/misc.rs
@@ -38,10 +38,16 @@ declare_clippy_lint! {
     /// dereferences, e.g., changing `*x` to `x` within the function.
     ///
     /// **Example:**
-    /// ```rust
+    /// ```rust,ignore
+    /// // Bad
     /// fn foo(ref x: u8) -> bool {
     ///     true
     /// }
+    ///
+    /// // Good
+    /// fn foo(x: &u8) -> bool {
+    ///     true
+    /// }
     /// ```
     pub TOPLEVEL_REF_ARG,
     style,
@@ -60,7 +66,11 @@ declare_clippy_lint! {
     /// ```rust
     /// # let x = 1.0;
     ///
+    /// // Bad
     /// if x == f32::NAN { }
+    ///
+    /// // Good
+    /// if x.is_nan() { }
     /// ```
     pub CMP_NAN,
     correctness,
@@ -83,8 +93,15 @@ declare_clippy_lint! {
     /// ```rust
     /// let x = 1.2331f64;
     /// let y = 1.2332f64;
+    /// 
+    /// // Bad
     /// if y == 1.23f64 { }
     /// if y != x {} // where both are floats
+    ///
+    /// // Good
+    /// let error = 0.01f64; // Use an epsilon for comparison
+    /// if (y - 1.23f64).abs() < error { }
+    /// if (y - x).abs() > error { }
     /// ```
     pub FLOAT_CMP,
     correctness,
@@ -191,7 +208,11 @@ declare_clippy_lint! {
     /// **Example:**
     ///
     /// ```rust
+    /// // Bad
     /// let a = 0 as *const u32;
+    ///
+    /// // Good
+    /// let a = std::ptr::null::<u32>();
     /// ```
     pub ZERO_PTR,
     style,
@@ -214,7 +235,13 @@ declare_clippy_lint! {
     /// ```rust
     /// let x: f64 = 1.0;
     /// const ONE: f64 = 1.00;
-    /// x == ONE;  // where both are floats
+    ///
+    /// // Bad
+    /// if x == ONE { }  // where both are floats
+    ///
+    /// // Good
+    /// let error = 0.1f64; // Use an epsilon for comparison
+    /// if (x - ONE).abs() < error { }
     /// ```
     pub FLOAT_CMP_CONST,
     restriction,
diff --git a/clippy_lints/src/misc_early.rs b/clippy_lints/src/misc_early.rs
index 552222eba2e..ad39e59d067 100644
--- a/clippy_lints/src/misc_early.rs
+++ b/clippy_lints/src/misc_early.rs
@@ -59,7 +59,11 @@ declare_clippy_lint! {
     ///
     /// **Example:**
     /// ```rust
+    /// // Bad
     /// fn foo(a: i32, _a: i32) {}
+    ///
+    /// // Good
+    /// fn bar(a: i32, _b: i32) {}
     /// ```
     pub DUPLICATE_UNDERSCORE_ARGUMENT,
     style,
@@ -77,7 +81,11 @@ declare_clippy_lint! {
     ///
     /// **Example:**
     /// ```rust,ignore
-    /// (|| 42)()
+    /// // Bad
+    /// let a = (|| 42)()
+    ///
+    /// // Good
+    /// let a = 42
     /// ```
     pub REDUNDANT_CLOSURE_CALL,
     complexity,
@@ -112,7 +120,11 @@ declare_clippy_lint! {
     ///
     /// **Example:**
     /// ```rust
+    /// // Bad
     /// let y = 0x1a9BAcD;
+    ///
+    /// // Good
+    /// let y = 0x1A9BACD;
     /// ```
     pub MIXED_CASE_HEX_LITERALS,
     style,
@@ -129,7 +141,11 @@ declare_clippy_lint! {
     ///
     /// **Example:**
     /// ```rust
+    /// // Bad
     /// let y = 123832i32;
+    ///
+    /// // Good
+    /// let y = 123832_i32;
     /// ```
     pub UNSEPARATED_LITERAL_SUFFIX,
     pedantic,
@@ -207,9 +223,16 @@ declare_clippy_lint! {
     /// ```rust
     /// # let v = Some("abc");
     ///
+    /// // Bad
+    /// match v {
+    ///     Some(x) => (),
+    ///     y @ _ => (),
+    /// }
+    ///
+    /// // Good
     /// match v {
     ///     Some(x) => (),
-    ///     y @ _ => (), // easier written as `y`,
+    ///     y => (),
     /// }
     /// ```
     pub REDUNDANT_PATTERN,
@@ -235,16 +258,13 @@ declare_clippy_lint! {
     /// # struct TupleStruct(u32, u32, u32);
     /// # let t = TupleStruct(1, 2, 3);
     ///
+    /// // Bad
     /// match t {
     ///     TupleStruct(0, .., _) => (),
     ///     _ => (),
     /// }
-    /// ```
-    /// can be written as
-    /// ```rust
-    /// # struct TupleStruct(u32, u32, u32);
-    /// # let t = TupleStruct(1, 2, 3);
     ///
+    /// // Good
     /// match t {
     ///     TupleStruct(0, ..) => (),
     ///     _ => (),
diff --git a/clippy_lints/src/mut_reference.rs b/clippy_lints/src/mut_reference.rs
index 67a1ac78a67..58a8e1a1064 100644
--- a/clippy_lints/src/mut_reference.rs
+++ b/clippy_lints/src/mut_reference.rs
@@ -16,7 +16,11 @@ declare_clippy_lint! {
     ///
     /// **Example:**
     /// ```ignore
+    /// // Bad
     /// my_vec.push(&mut value)
+    ///
+    /// // Good
+    /// my_vec.push(&value)
     /// ```
     pub UNNECESSARY_MUT_PASSED,
     style,
diff --git a/clippy_lints/src/mutex_atomic.rs b/clippy_lints/src/mutex_atomic.rs
index 4e1a8be4892..78b15afc5a7 100644
--- a/clippy_lints/src/mutex_atomic.rs
+++ b/clippy_lints/src/mutex_atomic.rs
@@ -22,9 +22,15 @@ declare_clippy_lint! {
     ///
     /// **Example:**
     /// ```rust
+    /// # let y = true;
+    ///
+    /// // Bad
     /// # use std::sync::Mutex;
-    /// # let y = 1;
     /// let x = Mutex::new(&y);
+    ///
+    /// // Good
+    /// # use std::sync::atomic::AtomicBool;
+    /// let x = AtomicBool::new(y);
     /// ```
     pub MUTEX_ATOMIC,
     perf,
@@ -46,6 +52,10 @@ declare_clippy_lint! {
     /// ```rust
     /// # use std::sync::Mutex;
     /// let x = Mutex::new(0usize);
+    ///
+    /// // Good
+    /// # use std::sync::atomic::AtomicUsize;
+    /// let x = AtomicUsize::new(0usize);
     /// ```
     pub MUTEX_INTEGER,
     nursery,
diff --git a/clippy_lints/src/needless_bool.rs b/clippy_lints/src/needless_bool.rs
index efa77db822d..15b129fa098 100644
--- a/clippy_lints/src/needless_bool.rs
+++ b/clippy_lints/src/needless_bool.rs
@@ -15,8 +15,7 @@ use rustc_span::Span;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for expressions of the form `if c { true } else {
-    /// false }`
-    /// (or vice versa) and suggest using the condition directly.
+    /// false }` (or vice versa) and suggests using the condition directly.
     ///
     /// **Why is this bad?** Redundant code.
     ///
diff --git a/clippy_lints/src/needless_borrow.rs b/clippy_lints/src/needless_borrow.rs
index 9ee875d7516..5880d1d6102 100644
--- a/clippy_lints/src/needless_borrow.rs
+++ b/clippy_lints/src/needless_borrow.rs
@@ -18,12 +18,16 @@ declare_clippy_lint! {
     /// **Why is this bad?** Suggests that the receiver of the expression borrows
     /// the expression.
     ///
+    /// **Known problems:** None.
+    ///
     /// **Example:**
     /// ```rust
+    /// // Bad
     /// let x: &i32 = &&&&&&5;
-    /// ```
     ///
-    /// **Known problems:** None.
+    /// // Good
+    /// let x: &i32 = &5;
+    /// ```
     pub NEEDLESS_BORROW,
     nursery,
     "taking a reference that is going to be automatically dereferenced"
diff --git a/clippy_lints/src/needless_pass_by_value.rs b/clippy_lints/src/needless_pass_by_value.rs
index 9c508fc0e4a..fbdf927b824 100644
--- a/clippy_lints/src/needless_pass_by_value.rs
+++ b/clippy_lints/src/needless_pass_by_value.rs
@@ -40,9 +40,8 @@ declare_clippy_lint! {
     ///     assert_eq!(v.len(), 42);
     /// }
     /// ```
-    ///
+    /// should be
     /// ```rust
-    /// // should be
     /// fn foo(v: &[i32]) {
     ///     assert_eq!(v.len(), 42);
     /// }
diff --git a/clippy_lints/src/needless_update.rs b/clippy_lints/src/needless_update.rs
index 4b2586877e5..d866bab2f64 100644
--- a/clippy_lints/src/needless_update.rs
+++ b/clippy_lints/src/needless_update.rs
@@ -21,6 +21,16 @@ declare_clippy_lint! {
     /// #     z: i32,
     /// # }
     /// # let zero_point = Point { x: 0, y: 0, z: 0 };
+    ///
+    /// // Bad
+    /// Point {
+    ///     x: 1,
+    ///     y: 1,
+    ///     z: 1,
+    ///     ..zero_point
+    /// };
+    ///
+    /// // Ok
     /// Point {
     ///     x: 1,
     ///     y: 1,
diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs
index 4eac571f966..c77b44e0c99 100644
--- a/clippy_lints/src/ptr.rs
+++ b/clippy_lints/src/ptr.rs
@@ -47,7 +47,11 @@ declare_clippy_lint! {
     ///
     /// **Example:**
     /// ```ignore
+    /// // Bad
     /// fn foo(&Vec<u32>) { .. }
+    ///
+    /// // Good
+    /// fn foo(&[u32]) { .. }
     /// ```
     pub PTR_ARG,
     style,
@@ -65,9 +69,15 @@ declare_clippy_lint! {
     ///
     /// **Example:**
     /// ```ignore
+    /// // Bad
     /// if x == ptr::null {
     ///     ..
     /// }
+    ///
+    /// // Good
+    /// if x.is_null() {
+    ///     ..
+    /// }
     /// ```
     pub CMP_NULL,
     style,
@@ -76,19 +86,16 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// **What it does:** This lint checks for functions that take immutable
-    /// references and return
-    /// mutable ones.
+    /// references and return mutable ones.
     ///
     /// **Why is this bad?** This is trivially unsound, as one can create two
-    /// mutable references
-    /// from the same (immutable!) source. This
-    /// [error](https://github.com/rust-lang/rust/issues/39465)
+    /// mutable references from the same (immutable!) source.
+    /// This [error](https://github.com/rust-lang/rust/issues/39465)
     /// actually lead to an interim Rust release 1.15.1.
     ///
     /// **Known problems:** To be on the conservative side, if there's at least one
-    /// mutable reference
-    /// with the output lifetime, this lint will not trigger. In practice, this
-    /// case is unlikely anyway.
+    /// mutable reference with the output lifetime, this lint will not trigger.
+    /// In practice, this case is unlikely anyway.
     ///
     /// **Example:**
     /// ```ignore
diff --git a/clippy_lints/src/question_mark.rs b/clippy_lints/src/question_mark.rs
index ea654467b86..e4361b00fb4 100644
--- a/clippy_lints/src/question_mark.rs
+++ b/clippy_lints/src/question_mark.rs
@@ -88,7 +88,7 @@ impl QuestionMark {
                         replacement_str,
                         applicability,
                     )
-               }
+                }
             }
         }
     }
diff --git a/clippy_lints/src/reference.rs b/clippy_lints/src/reference.rs
index d5797468e9d..fe457aad50e 100644
--- a/clippy_lints/src/reference.rs
+++ b/clippy_lints/src/reference.rs
@@ -16,8 +16,13 @@ declare_clippy_lint! {
     ///
     /// **Example:**
     /// ```rust,ignore
+    /// // Bad
     /// let a = f(*&mut b);
     /// let c = *&d;
+    ///
+    /// // Good
+    /// let a = f(b);
+    /// let c = d;
     /// ```
     pub DEREF_ADDROF,
     complexity,
diff --git a/clippy_lints/src/regex.rs b/clippy_lints/src/regex.rs
index 30084e3e1ff..a2c35c42673 100644
--- a/clippy_lints/src/regex.rs
+++ b/clippy_lints/src/regex.rs
@@ -86,11 +86,13 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Regex {
             if let Some(span) = is_expn_of(expr.span, "regex");
             then {
                 if !self.spans.contains(&span) {
-                    span_lint(cx,
-                              REGEX_MACRO,
-                              span,
-                              "`regex!(_)` found. \
-                              Please use `Regex::new(_)`, which is faster for now.");
+                    span_lint(
+                        cx,
+                        REGEX_MACRO,
+                        span,
+                        "`regex!(_)` found. \
+                        Please use `Regex::new(_)`, which is faster for now."
+                    );
                     self.spans.insert(span);
                 }
                 self.last = Some(block.hir_id);
diff --git a/clippy_lints/src/shadow.rs b/clippy_lints/src/shadow.rs
index 11360b0ef84..68c36f91891 100644
--- a/clippy_lints/src/shadow.rs
+++ b/clippy_lints/src/shadow.rs
@@ -25,7 +25,12 @@ declare_clippy_lint! {
     /// **Example:**
     /// ```rust
     /// # let x = 1;
+    ///
+    /// // Bad
     /// let x = &x;
+    ///
+    /// // Good
+    /// let y = &x; // use different variable name
     /// ```
     pub SHADOW_SAME,
     restriction,
@@ -77,7 +82,12 @@ declare_clippy_lint! {
     /// # let y = 1;
     /// # let z = 2;
     /// let x = y;
+    ///
+    /// // Bad
     /// let x = z; // shadows the earlier binding
+    ///
+    /// // Good
+    /// let w = z; // use different variable name
     /// ```
     pub SHADOW_UNRELATED,
     pedantic,
diff --git a/clippy_lints/src/single_component_path_imports.rs b/clippy_lints/src/single_component_path_imports.rs
index 8d767a7fec8..2e853e8301d 100644
--- a/clippy_lints/src/single_component_path_imports.rs
+++ b/clippy_lints/src/single_component_path_imports.rs
@@ -16,7 +16,7 @@ declare_clippy_lint! {
     ///
     /// **Example:**
     ///
-    /// ```rust, ignore
+    /// ```rust,ignore
     /// use regex;
     ///
     /// fn main() {
@@ -24,7 +24,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     /// Better as
-    /// ```rust, ignore
+    /// ```rust,ignore
     /// fn main() {
     ///     regex::Regex::new(r"^\d{4}-\d{2}-\d{2}$").unwrap();
     /// }
diff --git a/clippy_lints/src/slow_vector_initialization.rs b/clippy_lints/src/slow_vector_initialization.rs
index fb3706be1c2..a7c4f2c2291 100644
--- a/clippy_lints/src/slow_vector_initialization.rs
+++ b/clippy_lints/src/slow_vector_initialization.rs
@@ -22,11 +22,17 @@ declare_clippy_lint! {
     /// ```rust
     /// # use core::iter::repeat;
     /// # let len = 4;
+    ///
+    /// // Bad
     /// let mut vec1 = Vec::with_capacity(len);
     /// vec1.resize(len, 0);
     ///
     /// let mut vec2 = Vec::with_capacity(len);
-    /// vec2.extend(repeat(0).take(len))
+    /// vec2.extend(repeat(0).take(len));
+    ///
+    /// // Good
+    /// let mut vec1 = vec![0; len];
+    /// let mut vec2 = vec![0; len];
     /// ```
     pub SLOW_VECTOR_INITIALIZATION,
     perf,
diff --git a/clippy_lints/src/strings.rs b/clippy_lints/src/strings.rs
index 2c51271e312..f84566ef707 100644
--- a/clippy_lints/src/strings.rs
+++ b/clippy_lints/src/strings.rs
@@ -24,6 +24,10 @@ declare_clippy_lint! {
     /// ```rust
     /// let mut x = "Hello".to_owned();
     /// x = x + ", World";
+    ///
+    /// // More readable
+    /// x += ", World";
+    /// x.push_str(", World");
     /// ```
     pub STRING_ADD_ASSIGN,
     pedantic,
@@ -69,7 +73,11 @@ declare_clippy_lint! {
     ///
     /// **Example:**
     /// ```rust
+    /// // Bad
     /// let bs = "a byte string".as_bytes();
+    ///
+    /// // Good
+    /// let bs = b"a byte string";
     /// ```
     pub STRING_LIT_AS_BYTES,
     style,
-- 
cgit 1.4.1-3-g733a5


From 9893254dff38c2644612c8465ae9abfa553f4ea3 Mon Sep 17 00:00:00 2001
From: ThibsG <Thibs@debian.com>
Date: Sun, 31 May 2020 12:08:41 +0200
Subject: Add more corrected code for doc

---
 clippy_lints/src/methods/mod.rs        | 65 ++++++++++++++++++++++++++--------
 clippy_lints/src/misc.rs               |  2 +-
 clippy_lints/src/vec.rs                | 10 ++++--
 clippy_lints/src/verbose_file_reads.rs |  1 +
 clippy_lints/src/wildcard_imports.rs   | 12 +++++--
 clippy_lints/src/write.rs              | 22 ++++++++++--
 clippy_lints/src/zero_div_zero.rs      |  6 +++-
 src/lintlist/mod.rs                    |  2 +-
 8 files changed, 95 insertions(+), 25 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 52ca962e7ef..fbc29efdeb2 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -218,7 +218,12 @@ declare_clippy_lint! {
     /// **Example:**
     /// ```rust
     /// # let x = Ok::<_, ()>(());
-    /// x.ok().expect("why did I do this again?")
+    ///
+    /// // Bad
+    /// x.ok().expect("why did I do this again?");
+    ///
+    /// // Good
+    /// x.expect("why did I do this again?");
     /// ```
     pub OK_EXPECT,
     style,
@@ -273,8 +278,12 @@ declare_clippy_lint! {
     /// **Example:**
     /// ```rust
     /// # let opt = Some(1);
-    /// opt.map_or(None, |a| Some(a + 1))
-    /// # ;
+    ///
+    /// // Bad
+    /// opt.map_or(None, |a| Some(a + 1));
+    ///
+    /// // Good
+    /// opt.and_then(|a| Some(a + 1));
     /// ```
     pub OPTION_MAP_OR_NONE,
     style,
@@ -390,14 +399,19 @@ declare_clippy_lint! {
     /// **What it does:** Checks for usage of `_.map(_).flatten(_)`,
     ///
     /// **Why is this bad?** Readability, this can be written more concisely as a
-    /// single method call.
+    /// single method call using `_.flat_map(_)`
     ///
     /// **Known problems:**
     ///
     /// **Example:**
     /// ```rust
     /// let vec = vec![vec![1]];
+    ///
+    /// // Bad
     /// vec.iter().map(|x| x.iter()).flatten();
+    ///
+    /// // Good
+    /// vec.iter().flat_map(|x| x.iter());
     /// ```
     pub MAP_FLATTEN,
     pedantic,
@@ -417,7 +431,12 @@ declare_clippy_lint! {
     /// **Example:**
     /// ```rust
     /// let vec = vec![1];
+    ///
+    /// // Bad
     /// vec.iter().filter(|x| **x == 0).map(|x| *x * 2);
+    ///
+    /// // Good
+    /// vec.iter().filter_map(|x| Some(*x * 2));
     /// ```
     pub FILTER_MAP,
     pedantic,
@@ -634,7 +653,12 @@ declare_clippy_lint! {
     /// ```rust
     /// # use std::rc::Rc;
     /// let x = Rc::new(1);
+    ///
+    /// // Bad
     /// x.clone();
+    ///
+    /// // Good
+    /// Rc::clone(&x);
     /// ```
     pub CLONE_ON_REF_PTR,
     restriction,
@@ -741,7 +765,12 @@ declare_clippy_lint! {
     /// **Known problems:** Does not catch multi-byte unicode characters.
     ///
     /// **Example:**
-    /// `_.split("x")` could be `_.split('x')`
+    /// ```rust,ignore
+    /// // Bad
+    /// _.split("x");
+    ///
+    /// // Good
+    /// _.split('x');
     pub SINGLE_CHAR_PATTERN,
     perf,
     "using a single-character str where a char could be used, e.g., `_.split(\"x\")`"
@@ -964,8 +993,8 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for usage of `.chars().last()` or
-    /// `.chars().next_back()` on a `str` to check if it ends with a given char.
+    /// **What it does:** Checks for usage of `_.chars().last()` or
+    /// `_.chars().next_back()` on a `str` to check if it ends with a given char.
     ///
     /// **Why is this bad?** Readability, this can be written more concisely as
     /// `_.ends_with(_)`.
@@ -975,8 +1004,12 @@ declare_clippy_lint! {
     /// **Example:**
     /// ```rust
     /// # let name = "_";
-    /// name.chars().last() == Some('_') || name.chars().next_back() == Some('-')
-    /// # ;
+    ///
+    /// // Bad
+    /// name.chars().last() == Some('_') || name.chars().next_back() == Some('-');
+    ///
+    /// // Good
+    /// name.ends_with('_') || name.ends_with('-');
     /// ```
     pub CHARS_LAST_CMP,
     style,
@@ -1044,17 +1077,15 @@ declare_clippy_lint! {
     /// **Example:**
     /// ```rust
     /// let _ = (0..3).filter_map(|x| if x > 2 { Some(x) } else { None });
-    /// ```
-    /// As there is no transformation of the argument this could be written as:
-    /// ```rust
+    ///
+    /// // As there is no transformation of the argument this could be written as:
     /// let _ = (0..3).filter(|&x| x > 2);
     /// ```
     ///
     /// ```rust
     /// let _ = (0..4).filter_map(|x| Some(x + 1));
-    /// ```
-    /// As there is no conditional check on the argument this could be written as:
-    /// ```rust
+    ///
+    /// // As there is no conditional check on the argument this could be written as:
     /// let _ = (0..4).map(|x| x + 1);
     /// ```
     pub UNNECESSARY_FILTER_MAP,
@@ -1075,7 +1106,11 @@ declare_clippy_lint! {
     /// **Example:**
     ///
     /// ```rust
+    /// // Bad
     /// let _ = (&vec![3, 4, 5]).into_iter();
+    ///
+    /// // Good
+    /// let _ = (&vec![3, 4, 5]).iter();
     /// ```
     pub INTO_ITER_ON_REF,
     style,
diff --git a/clippy_lints/src/misc.rs b/clippy_lints/src/misc.rs
index a3b7134a376..51282ab93ef 100644
--- a/clippy_lints/src/misc.rs
+++ b/clippy_lints/src/misc.rs
@@ -93,7 +93,7 @@ declare_clippy_lint! {
     /// ```rust
     /// let x = 1.2331f64;
     /// let y = 1.2332f64;
-    /// 
+    ///
     /// // Bad
     /// if y == 1.23f64 { }
     /// if y != x {} // where both are floats
diff --git a/clippy_lints/src/vec.rs b/clippy_lints/src/vec.rs
index 1174f421577..a8d4c7620b1 100644
--- a/clippy_lints/src/vec.rs
+++ b/clippy_lints/src/vec.rs
@@ -17,8 +17,14 @@ declare_clippy_lint! {
     /// **Known problems:** None.
     ///
     /// **Example:**
-    /// ```rust,ignore
-    /// foo(&vec![1, 2])
+    /// ```rust
+    /// # fn foo(my_vec: &[u8]) {}
+    ///
+    /// // Bad
+    /// foo(&vec![1, 2]);
+    ///
+    /// // Good
+    /// foo(&[1, 2]);
     /// ```
     pub USELESS_VEC,
     perf,
diff --git a/clippy_lints/src/verbose_file_reads.rs b/clippy_lints/src/verbose_file_reads.rs
index 4d8d4438d88..7247518e19b 100644
--- a/clippy_lints/src/verbose_file_reads.rs
+++ b/clippy_lints/src/verbose_file_reads.rs
@@ -9,6 +9,7 @@ declare_clippy_lint! {
     ///
     /// **Why is this bad?** `fs::{read, read_to_string}` provide the same functionality when `buf` is empty with fewer imports and no intermediate values.
     /// See also: [fs::read docs](https://doc.rust-lang.org/std/fs/fn.read.html), [fs::read_to_string docs](https://doc.rust-lang.org/std/fs/fn.read_to_string.html)
+    ///
     /// **Known problems:** None.
     ///
     /// **Example:**
diff --git a/clippy_lints/src/wildcard_imports.rs b/clippy_lints/src/wildcard_imports.rs
index 32d9a45c37d..b637253bd02 100644
--- a/clippy_lints/src/wildcard_imports.rs
+++ b/clippy_lints/src/wildcard_imports.rs
@@ -19,8 +19,14 @@ declare_clippy_lint! {
     /// still around.
     ///
     /// **Example:**
-    /// ```rust
+    /// ```rust,ignore
+    /// // Bad
     /// use std::cmp::Ordering::*;
+    /// foo(Less);
+    ///
+    /// // Good
+    /// use std::cmp::Ordering;
+    /// foo(Ordering::Less)
     /// ```
     pub ENUM_GLOB_USE,
     pedantic,
@@ -60,15 +66,15 @@ declare_clippy_lint! {
     ///
     /// **Example:**
     ///
-    /// Bad:
     /// ```rust,ignore
+    /// // Bad
     /// use crate1::*;
     ///
     /// foo();
     /// ```
     ///
-    /// Good:
     /// ```rust,ignore
+    /// // Good
     /// use crate1::foo;
     ///
     /// foo();
diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs
index 5f794598052..22ce484b24e 100644
--- a/clippy_lints/src/write.rs
+++ b/clippy_lints/src/write.rs
@@ -23,7 +23,11 @@ declare_clippy_lint! {
     ///
     /// **Example:**
     /// ```rust
+    /// // Bad
     /// println!("");
+    ///
+    /// // Good
+    /// println!();
     /// ```
     pub PRINTLN_EMPTY_STRING,
     style,
@@ -32,8 +36,7 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// **What it does:** This lint warns when you use `print!()` with a format
-    /// string that
-    /// ends in a newline.
+    /// string that ends in a newline.
     ///
     /// **Why is this bad?** You should use `println!()` instead, which appends the
     /// newline.
@@ -125,7 +128,12 @@ declare_clippy_lint! {
     /// ```rust
     /// # use std::fmt::Write;
     /// # let mut buf = String::new();
+    ///
+    /// // Bad
     /// writeln!(buf, "");
+    ///
+    /// // Good
+    /// writeln!(buf);
     /// ```
     pub WRITELN_EMPTY_STRING,
     style,
@@ -147,7 +155,12 @@ declare_clippy_lint! {
     /// # use std::fmt::Write;
     /// # let mut buf = String::new();
     /// # let name = "World";
+    ///
+    /// // Bad
     /// write!(buf, "Hello {}!\n", name);
+    ///
+    /// // Good
+    /// writeln!(buf, "Hello {}!", name);
     /// ```
     pub WRITE_WITH_NEWLINE,
     style,
@@ -168,7 +181,12 @@ declare_clippy_lint! {
     /// ```rust
     /// # use std::fmt::Write;
     /// # let mut buf = String::new();
+    ///
+    /// // Bad
     /// writeln!(buf, "{}", "foo");
+    ///
+    /// // Good
+    /// writeln!(buf, "foo");
     /// ```
     pub WRITE_LITERAL,
     style,
diff --git a/clippy_lints/src/zero_div_zero.rs b/clippy_lints/src/zero_div_zero.rs
index fb4700d8743..0820385e01b 100644
--- a/clippy_lints/src/zero_div_zero.rs
+++ b/clippy_lints/src/zero_div_zero.rs
@@ -14,7 +14,11 @@ declare_clippy_lint! {
     ///
     /// **Example:**
     /// ```rust
-    /// 0.0f32 / 0.0;
+    /// // Bad
+    /// let nan = 0.0f32 / 0.0;
+    ///
+    /// // Good
+    /// let nan = f32::NAN;
     /// ```
     pub ZERO_DIVIDED_BY_ZERO,
     complexity,
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index ab9542a7b9c..6b6e2c7324c 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -1735,7 +1735,7 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
     Lint {
         name: "pub_enum_variant_names",
         group: "pedantic",
-        desc: "enums where all variants share a prefix/postfix",
+        desc: "public enums where all variants share a prefix/postfix",
         deprecation: None,
         module: "enum_variants",
     },
-- 
cgit 1.4.1-3-g733a5


From 137a3b4d3242cfe331f8f9b87c51ac0c431fe160 Mon Sep 17 00:00:00 2001
From: ThibsG <Thibs@debian.com>
Date: Mon, 1 Jun 2020 10:16:01 +0200
Subject: Corrected doc PR fixes

---
 clippy_lints/src/drop_bounds.rs           |  2 +-
 clippy_lints/src/eta_reduction.rs         |  2 +-
 clippy_lints/src/eval_order_dependence.rs |  7 +++++--
 clippy_lints/src/fallible_impl_from.rs    | 12 ++++++++++--
 clippy_lints/src/functions.rs             |  2 +-
 clippy_lints/src/methods/mod.rs           |  6 +++++-
 6 files changed, 23 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/drop_bounds.rs b/clippy_lints/src/drop_bounds.rs
index 4ef963ac314..5a7f759486e 100644
--- a/clippy_lints/src/drop_bounds.rs
+++ b/clippy_lints/src/drop_bounds.rs
@@ -29,7 +29,7 @@ declare_clippy_lint! {
     /// ```
     /// Could be written as:
     /// ```rust
-    /// fn foo() {}
+    /// fn foo<T>() {}
     /// ```
     pub DROP_BOUNDS,
     correctness,
diff --git a/clippy_lints/src/eta_reduction.rs b/clippy_lints/src/eta_reduction.rs
index 5f0cd1ec72c..d093025fd3d 100644
--- a/clippy_lints/src/eta_reduction.rs
+++ b/clippy_lints/src/eta_reduction.rs
@@ -30,7 +30,7 @@ declare_clippy_lint! {
     /// xs.map(|x| foo(x))
     ///
     /// // Good
-    /// foo(xs)
+    /// xs.map(foo)
     /// ```
     /// where `foo(_)` is a plain function that takes the exact argument type of
     /// `x`.
diff --git a/clippy_lints/src/eval_order_dependence.rs b/clippy_lints/src/eval_order_dependence.rs
index 37e24ff34f7..74144fb299d 100644
--- a/clippy_lints/src/eval_order_dependence.rs
+++ b/clippy_lints/src/eval_order_dependence.rs
@@ -30,8 +30,11 @@ declare_clippy_lint! {
     /// // Unclear whether a is 1 or 2.
     ///
     /// // Good
-    /// x = 1;
-    /// let a = 1 + x;
+    /// let tmp = {
+    ///     x = 1;
+    ///     1
+    /// };
+    /// let a = tmp + x;
     /// ```
     pub EVAL_ORDER_DEPENDENCE,
     complexity,
diff --git a/clippy_lints/src/fallible_impl_from.rs b/clippy_lints/src/fallible_impl_from.rs
index 575462f25e6..92812816461 100644
--- a/clippy_lints/src/fallible_impl_from.rs
+++ b/clippy_lints/src/fallible_impl_from.rs
@@ -18,7 +18,7 @@ declare_clippy_lint! {
     /// **Known problems:** None.
     ///
     /// **Example:**
-    /// ```rust,ignore
+    /// ```rust
     /// struct Foo(i32);
     ///
     /// // Bad
@@ -27,13 +27,21 @@ declare_clippy_lint! {
     ///         Foo(s.parse().unwrap())
     ///     }
     /// }
+    /// ```
     ///
+    /// ```rust
     /// // Good
+    /// struct Foo(i32);
+    ///
     /// use std::convert::TryFrom;
     /// impl TryFrom<String> for Foo {
     ///     type Error = ();
     ///     fn try_from(s: String) -> Result<Self, Self::Error> {
-    ///         s.parse()
+    ///         if let Ok(parsed) = s.parse() {
+    ///             Ok(Foo(parsed))
+    ///         } else {
+    ///             Err(())
+    ///         }
     ///     }
     /// }
     /// ```
diff --git a/clippy_lints/src/functions.rs b/clippy_lints/src/functions.rs
index 9b5f1dee7f4..325b6cf32a3 100644
--- a/clippy_lints/src/functions.rs
+++ b/clippy_lints/src/functions.rs
@@ -52,7 +52,7 @@ declare_clippy_lint! {
     /// ```rust
     /// fn im_too_long() {
     ///     println!("");
-    /// // ... 100 more LoC
+    ///     // ... 100 more LoC
     ///     println!("");
     /// }
     /// ```
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index fbc29efdeb2..a8d5c10d5da 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -436,7 +436,11 @@ declare_clippy_lint! {
     /// vec.iter().filter(|x| **x == 0).map(|x| *x * 2);
     ///
     /// // Good
-    /// vec.iter().filter_map(|x| Some(*x * 2));
+    /// vec.iter().filter_map(|x| if *x == 0 {
+    ///     Some(*x * 2)
+    /// } else {
+    ///     None
+    /// });
     /// ```
     pub FILTER_MAP,
     pedantic,
-- 
cgit 1.4.1-3-g733a5


From fbf0b84b32aab798258838d5e932dbc56c4a1813 Mon Sep 17 00:00:00 2001
From: Lzu Tao <taolzu@gmail.com>
Date: Tue, 2 Jun 2020 21:42:33 +0700
Subject: Make use of slice pattern

---
 clippy_lints/src/utils/mod.rs | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index 6c1488664bf..7e07e7751e3 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -165,8 +165,8 @@ pub fn match_trait_method(cx: &LateContext<'_, '_>, expr: &Expr<'_>, path: &[&st
 /// Checks if an expression references a variable of the given name.
 pub fn match_var(expr: &Expr<'_>, var: Name) -> bool {
     if let ExprKind::Path(QPath::Resolved(None, ref path)) = expr.kind {
-        if path.segments.len() == 1 && path.segments[0].ident.name == var {
-            return true;
+        if let [p] = path.segments {
+            return p.ident.name == var;
         }
     }
     false
@@ -181,8 +181,7 @@ pub fn last_path_segment<'tcx>(path: &QPath<'tcx>) -> &'tcx PathSegment<'tcx> {
 
 pub fn single_segment_path<'tcx>(path: &QPath<'tcx>) -> Option<&'tcx PathSegment<'tcx>> {
     match *path {
-        QPath::Resolved(_, ref path) if path.segments.len() == 1 => Some(&path.segments[0]),
-        QPath::Resolved(..) => None,
+        QPath::Resolved(_, ref path) => path.segments.get(0),
         QPath::TypeRelative(_, ref seg) => Some(seg),
     }
 }
@@ -201,9 +200,12 @@ pub fn match_qpath(path: &QPath<'_>, segments: &[&str]) -> bool {
         QPath::Resolved(_, ref path) => match_path(path, segments),
         QPath::TypeRelative(ref ty, ref segment) => match ty.kind {
             TyKind::Path(ref inner_path) => {
-                !segments.is_empty()
-                    && match_qpath(inner_path, &segments[..(segments.len() - 1)])
-                    && segment.ident.name.as_str() == segments[segments.len() - 1]
+                if let [prefix @ .., end] = segments {
+                    if match_qpath(inner_path, prefix) {
+                        return segment.ident.name.as_str() == *end;
+                    }
+                }
+                false
             },
             _ => false,
         },
-- 
cgit 1.4.1-3-g733a5


From b39fd5f62f80cb9bb47ac44d7100f694e0c7301c Mon Sep 17 00:00:00 2001
From: Lzu Tao <taolzu@gmail.com>
Date: Wed, 3 Jun 2020 09:04:24 +0700
Subject: Fix false negative of checked_conversion lint

---
 clippy_lints/src/checked_conversions.rs |  78 +++++++++++------------
 tests/ui/checked_conversions.fixed      | 106 ++++++++++++--------------------
 tests/ui/checked_conversions.rs         | 106 ++++++++++++--------------------
 tests/ui/checked_conversions.stderr     |  98 +++++++++++++++++++++--------
 tests/ui/checked_conversions.stdout     |   0
 5 files changed, 188 insertions(+), 200 deletions(-)
 delete mode 100644 tests/ui/checked_conversions.stdout

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/checked_conversions.rs b/clippy_lints/src/checked_conversions.rs
index d9776dd50a8..e845ef99c7c 100644
--- a/clippy_lints/src/checked_conversions.rs
+++ b/clippy_lints/src/checked_conversions.rs
@@ -58,24 +58,18 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for CheckedConversions {
             }
         };
 
-        if_chain! {
-            if let Some(cv) = result;
-            if let Some(to_type) = cv.to_type;
-
-            then {
+        if let Some(cv) = result {
+            if let Some(to_type) = cv.to_type {
                 let mut applicability = Applicability::MachineApplicable;
-                let snippet = snippet_with_applicability(cx, cv.expr_to_cast.span, "_", &mut
-                                applicability);
+                let snippet = snippet_with_applicability(cx, cv.expr_to_cast.span, "_", &mut applicability);
                 span_lint_and_sugg(
                     cx,
                     CHECKED_CONVERSIONS,
                     item.span,
                     "Checked cast can be simplified.",
                     "try",
-                    format!("{}::try_from({}).is_ok()",
-                            to_type,
-                            snippet),
-                    applicability
+                    format!("{}::try_from({}).is_ok()", to_type, snippet),
+                    applicability,
                 );
             }
         }
@@ -184,7 +178,7 @@ fn check_upper_bound<'tcx>(expr: &'tcx Expr<'tcx>) -> Option<Conversion<'tcx>> {
     if_chain! {
          if let ExprKind::Binary(ref op, ref left, ref right) = &expr.kind;
          if let Some((candidate, check)) = normalize_le_ge(op, left, right);
-         if let Some((from, to)) = get_types_from_cast(check, MAX_VALUE, INTS);
+         if let Some((from, to)) = get_types_from_cast(check, INTS, "max_value", "MAX");
 
          then {
              Conversion::try_new(candidate, from, to)
@@ -224,7 +218,7 @@ fn check_lower_bound_zero<'a>(candidate: &'a Expr<'_>, check: &'a Expr<'_>) -> O
 
 /// Check for `expr >= (to_type::MIN as from_type)`
 fn check_lower_bound_min<'a>(candidate: &'a Expr<'_>, check: &'a Expr<'_>) -> Option<Conversion<'a>> {
-    if let Some((from, to)) = get_types_from_cast(check, MIN_VALUE, SINTS) {
+    if let Some((from, to)) = get_types_from_cast(check, SINTS, "min_value", "MIN") {
         Conversion::try_new(candidate, from, to)
     } else {
         None
@@ -232,10 +226,16 @@ fn check_lower_bound_min<'a>(candidate: &'a Expr<'_>, check: &'a Expr<'_>) -> Op
 }
 
 /// Tries to extract the from- and to-type from a cast expression
-fn get_types_from_cast<'a>(expr: &'a Expr<'_>, func: &'a str, types: &'a [&str]) -> Option<(&'a str, &'a str)> {
-    // `to_type::maxmin_value() as from_type`
+fn get_types_from_cast<'a>(
+    expr: &'a Expr<'_>,
+    types: &'a [&str],
+    func: &'a str,
+    assoc_const: &'a str,
+) -> Option<(&'a str, &'a str)> {
+    // `to_type::max_value() as from_type`
+    // or `to_type::MAX as from_type`
     let call_from_cast: Option<(&Expr<'_>, &str)> = if_chain! {
-        // to_type::maxmin_value(), from_type
+        // to_type::max_value(), from_type
         if let ExprKind::Cast(ref limit, ref from_type) = &expr.kind;
         if let TyKind::Path(ref from_type_path) = &from_type.kind;
         if let Some(from_sym) = int_ty_to_sym(from_type_path);
@@ -247,17 +247,17 @@ fn get_types_from_cast<'a>(expr: &'a Expr<'_>, func: &'a str, types: &'a [&str])
         }
     };
 
-    // `from_type::from(to_type::maxmin_value())`
+    // `from_type::from(to_type::max_value())`
     let limit_from: Option<(&Expr<'_>, &str)> = call_from_cast.or_else(|| {
         if_chain! {
-            // `from_type::from, to_type::maxmin_value()`
+            // `from_type::from, to_type::max_value()`
             if let ExprKind::Call(ref from_func, ref args) = &expr.kind;
-            // `to_type::maxmin_value()`
+            // `to_type::max_value()`
             if args.len() == 1;
             if let limit = &args[0];
             // `from_type::from`
             if let ExprKind::Path(ref path) = &from_func.kind;
-            if let Some(from_sym) = get_implementing_type(path, INTS, FROM);
+            if let Some(from_sym) = get_implementing_type(path, INTS, "from");
 
             then {
                 Some((limit, from_sym))
@@ -268,22 +268,26 @@ fn get_types_from_cast<'a>(expr: &'a Expr<'_>, func: &'a str, types: &'a [&str])
     });
 
     if let Some((limit, from_type)) = limit_from {
-        if_chain! {
-            if let ExprKind::Call(ref fun_name, _) = &limit.kind;
-            // `to_type, maxmin_value`
-            if let ExprKind::Path(ref path) = &fun_name.kind;
-            // `to_type`
-            if let Some(to_type) = get_implementing_type(path, types, func);
-
-            then {
-                Some((from_type, to_type))
-            } else {
-                None
-            }
+        match limit.kind {
+            // `from_type::from(_)`
+            ExprKind::Call(path, _) => {
+                if let ExprKind::Path(ref path) = path.kind {
+                    // `to_type`
+                    if let Some(to_type) = get_implementing_type(path, types, func) {
+                        return Some((from_type, to_type));
+                    }
+                }
+            },
+            // `to_type::MAX`
+            ExprKind::Path(ref path) => {
+                if let Some(to_type) = get_implementing_type(path, types, assoc_const) {
+                    return Some((from_type, to_type));
+                }
+            },
+            _ => {},
         }
-    } else {
-        None
-    }
+    };
+    None
 }
 
 /// Gets the type which implements the called function
@@ -336,10 +340,6 @@ fn normalize_le_ge<'a>(op: &BinOp, left: &'a Expr<'a>, right: &'a Expr<'a>) -> O
 }
 
 // Constants
-const FROM: &str = "from";
-const MAX_VALUE: &str = "max_value";
-const MIN_VALUE: &str = "min_value";
-
 const UINTS: &[&str] = &["u8", "u16", "u32", "u64", "usize"];
 const SINTS: &[&str] = &["i8", "i16", "i32", "i64", "isize"];
 const INTS: &[&str] = &["u8", "u16", "u32", "u64", "usize", "i8", "i16", "i32", "i64", "isize"];
diff --git a/tests/ui/checked_conversions.fixed b/tests/ui/checked_conversions.fixed
index 7febd6f3761..12290db3dcf 100644
--- a/tests/ui/checked_conversions.fixed
+++ b/tests/ui/checked_conversions.fixed
@@ -1,106 +1,76 @@
 // run-rustfix
 
+#![allow(
+    clippy::cast_lossless,
+    // Int::max_value will be deprecated in the future
+    deprecated,
+)]
 #![warn(clippy::checked_conversions)]
-#![allow(clippy::cast_lossless)]
-#![allow(dead_code)]
+
 use std::convert::TryFrom;
 
 // Positive tests
 
 // Signed to unsigned
 
-fn i64_to_u32(value: i64) -> Option<u32> {
-    if u32::try_from(value).is_ok() {
-        Some(value as u32)
-    } else {
-        None
-    }
+pub fn i64_to_u32(value: i64) {
+    let _ = u32::try_from(value).is_ok();
+    let _ = u32::try_from(value).is_ok();
 }
 
-fn i64_to_u16(value: i64) -> Option<u16> {
-    if u16::try_from(value).is_ok() {
-        Some(value as u16)
-    } else {
-        None
-    }
+pub fn i64_to_u16(value: i64) {
+    let _ = u16::try_from(value).is_ok();
+    let _ = u16::try_from(value).is_ok();
 }
 
-fn isize_to_u8(value: isize) -> Option<u8> {
-    if u8::try_from(value).is_ok() {
-        Some(value as u8)
-    } else {
-        None
-    }
+pub fn isize_to_u8(value: isize) {
+    let _ = u8::try_from(value).is_ok();
+    let _ = u8::try_from(value).is_ok();
 }
 
 // Signed to signed
 
-fn i64_to_i32(value: i64) -> Option<i32> {
-    if i32::try_from(value).is_ok() {
-        Some(value as i32)
-    } else {
-        None
-    }
+pub fn i64_to_i32(value: i64) {
+    let _ = i32::try_from(value).is_ok();
+    let _ = i32::try_from(value).is_ok();
 }
 
-fn i64_to_i16(value: i64) -> Option<i16> {
-    if i16::try_from(value).is_ok() {
-        Some(value as i16)
-    } else {
-        None
-    }
+pub fn i64_to_i16(value: i64) {
+    let _ = i16::try_from(value).is_ok();
+    let _ = i16::try_from(value).is_ok();
 }
 
 // Unsigned to X
 
-fn u32_to_i32(value: u32) -> Option<i32> {
-    if i32::try_from(value).is_ok() {
-        Some(value as i32)
-    } else {
-        None
-    }
+pub fn u32_to_i32(value: u32) {
+    let _ = i32::try_from(value).is_ok();
+    let _ = i32::try_from(value).is_ok();
 }
 
-fn usize_to_isize(value: usize) -> isize {
-    if isize::try_from(value).is_ok() && value as i32 == 5 {
-        5
-    } else {
-        1
-    }
+pub fn usize_to_isize(value: usize) {
+    let _ = isize::try_from(value).is_ok() && value as i32 == 5;
+    let _ = isize::try_from(value).is_ok() && value as i32 == 5;
 }
 
-fn u32_to_u16(value: u32) -> isize {
-    if u16::try_from(value).is_ok() && value as i32 == 5 {
-        5
-    } else {
-        1
-    }
+pub fn u32_to_u16(value: u32) {
+    let _ = u16::try_from(value).is_ok() && value as i32 == 5;
+    let _ = u16::try_from(value).is_ok() && value as i32 == 5;
 }
 
 // Negative tests
 
-fn no_i64_to_i32(value: i64) -> Option<i32> {
-    if value <= (i32::max_value() as i64) && value >= 0 {
-        Some(value as i32)
-    } else {
-        None
-    }
+pub fn no_i64_to_i32(value: i64) {
+    let _ = value <= (i32::max_value() as i64) && value >= 0;
+    let _ = value <= (i32::MAX as i64) && value >= 0;
 }
 
-fn no_isize_to_u8(value: isize) -> Option<u8> {
-    if value <= (u8::max_value() as isize) && value >= (u8::min_value() as isize) {
-        Some(value as u8)
-    } else {
-        None
-    }
+pub fn no_isize_to_u8(value: isize) {
+    let _ = value <= (u8::max_value() as isize) && value >= (u8::min_value() as isize);
+    let _ = value <= (u8::MAX as isize) && value >= (u8::MIN as isize);
 }
 
-fn i8_to_u8(value: i8) -> Option<u8> {
-    if value >= 0 {
-        Some(value as u8)
-    } else {
-        None
-    }
+pub fn i8_to_u8(value: i8) {
+    let _ = value >= 0;
 }
 
 fn main() {}
diff --git a/tests/ui/checked_conversions.rs b/tests/ui/checked_conversions.rs
index a643354e243..895a301e821 100644
--- a/tests/ui/checked_conversions.rs
+++ b/tests/ui/checked_conversions.rs
@@ -1,106 +1,76 @@
 // run-rustfix
 
+#![allow(
+    clippy::cast_lossless,
+    // Int::max_value will be deprecated in the future
+    deprecated,
+)]
 #![warn(clippy::checked_conversions)]
-#![allow(clippy::cast_lossless)]
-#![allow(dead_code)]
+
 use std::convert::TryFrom;
 
 // Positive tests
 
 // Signed to unsigned
 
-fn i64_to_u32(value: i64) -> Option<u32> {
-    if value <= (u32::max_value() as i64) && value >= 0 {
-        Some(value as u32)
-    } else {
-        None
-    }
+pub fn i64_to_u32(value: i64) {
+    let _ = value <= (u32::max_value() as i64) && value >= 0;
+    let _ = value <= (u32::MAX as i64) && value >= 0;
 }
 
-fn i64_to_u16(value: i64) -> Option<u16> {
-    if value <= i64::from(u16::max_value()) && value >= 0 {
-        Some(value as u16)
-    } else {
-        None
-    }
+pub fn i64_to_u16(value: i64) {
+    let _ = value <= i64::from(u16::max_value()) && value >= 0;
+    let _ = value <= i64::from(u16::MAX) && value >= 0;
 }
 
-fn isize_to_u8(value: isize) -> Option<u8> {
-    if value <= (u8::max_value() as isize) && value >= 0 {
-        Some(value as u8)
-    } else {
-        None
-    }
+pub fn isize_to_u8(value: isize) {
+    let _ = value <= (u8::max_value() as isize) && value >= 0;
+    let _ = value <= (u8::MAX as isize) && value >= 0;
 }
 
 // Signed to signed
 
-fn i64_to_i32(value: i64) -> Option<i32> {
-    if value <= (i32::max_value() as i64) && value >= (i32::min_value() as i64) {
-        Some(value as i32)
-    } else {
-        None
-    }
+pub fn i64_to_i32(value: i64) {
+    let _ = value <= (i32::max_value() as i64) && value >= (i32::min_value() as i64);
+    let _ = value <= (i32::MAX as i64) && value >= (i32::MIN as i64);
 }
 
-fn i64_to_i16(value: i64) -> Option<i16> {
-    if value <= i64::from(i16::max_value()) && value >= i64::from(i16::min_value()) {
-        Some(value as i16)
-    } else {
-        None
-    }
+pub fn i64_to_i16(value: i64) {
+    let _ = value <= i64::from(i16::max_value()) && value >= i64::from(i16::min_value());
+    let _ = value <= i64::from(i16::MAX) && value >= i64::from(i16::MIN);
 }
 
 // Unsigned to X
 
-fn u32_to_i32(value: u32) -> Option<i32> {
-    if value <= i32::max_value() as u32 {
-        Some(value as i32)
-    } else {
-        None
-    }
+pub fn u32_to_i32(value: u32) {
+    let _ = value <= i32::max_value() as u32;
+    let _ = value <= i32::MAX as u32;
 }
 
-fn usize_to_isize(value: usize) -> isize {
-    if value <= isize::max_value() as usize && value as i32 == 5 {
-        5
-    } else {
-        1
-    }
+pub fn usize_to_isize(value: usize) {
+    let _ = value <= isize::max_value() as usize && value as i32 == 5;
+    let _ = value <= isize::MAX as usize && value as i32 == 5;
 }
 
-fn u32_to_u16(value: u32) -> isize {
-    if value <= u16::max_value() as u32 && value as i32 == 5 {
-        5
-    } else {
-        1
-    }
+pub fn u32_to_u16(value: u32) {
+    let _ = value <= u16::max_value() as u32 && value as i32 == 5;
+    let _ = value <= u16::MAX as u32 && value as i32 == 5;
 }
 
 // Negative tests
 
-fn no_i64_to_i32(value: i64) -> Option<i32> {
-    if value <= (i32::max_value() as i64) && value >= 0 {
-        Some(value as i32)
-    } else {
-        None
-    }
+pub fn no_i64_to_i32(value: i64) {
+    let _ = value <= (i32::max_value() as i64) && value >= 0;
+    let _ = value <= (i32::MAX as i64) && value >= 0;
 }
 
-fn no_isize_to_u8(value: isize) -> Option<u8> {
-    if value <= (u8::max_value() as isize) && value >= (u8::min_value() as isize) {
-        Some(value as u8)
-    } else {
-        None
-    }
+pub fn no_isize_to_u8(value: isize) {
+    let _ = value <= (u8::max_value() as isize) && value >= (u8::min_value() as isize);
+    let _ = value <= (u8::MAX as isize) && value >= (u8::MIN as isize);
 }
 
-fn i8_to_u8(value: i8) -> Option<u8> {
-    if value >= 0 {
-        Some(value as u8)
-    } else {
-        None
-    }
+pub fn i8_to_u8(value: i8) {
+    let _ = value >= 0;
 }
 
 fn main() {}
diff --git a/tests/ui/checked_conversions.stderr b/tests/ui/checked_conversions.stderr
index f678f009621..648ba3ccd01 100644
--- a/tests/ui/checked_conversions.stderr
+++ b/tests/ui/checked_conversions.stderr
@@ -1,52 +1,100 @@
 error: Checked cast can be simplified.
-  --> $DIR/checked_conversions.rs:13:8
+  --> $DIR/checked_conversions.rs:17:13
    |
-LL |     if value <= (u32::max_value() as i64) && value >= 0 {
-   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u32::try_from(value).is_ok()`
+LL |     let _ = value <= (u32::max_value() as i64) && value >= 0;
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u32::try_from(value).is_ok()`
    |
    = note: `-D clippy::checked-conversions` implied by `-D warnings`
 
 error: Checked cast can be simplified.
-  --> $DIR/checked_conversions.rs:21:8
+  --> $DIR/checked_conversions.rs:18:13
    |
-LL |     if value <= i64::from(u16::max_value()) && value >= 0 {
-   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u16::try_from(value).is_ok()`
+LL |     let _ = value <= (u32::MAX as i64) && value >= 0;
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u32::try_from(value).is_ok()`
 
 error: Checked cast can be simplified.
-  --> $DIR/checked_conversions.rs:29:8
+  --> $DIR/checked_conversions.rs:22:13
    |
-LL |     if value <= (u8::max_value() as isize) && value >= 0 {
-   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u8::try_from(value).is_ok()`
+LL |     let _ = value <= i64::from(u16::max_value()) && value >= 0;
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u16::try_from(value).is_ok()`
 
 error: Checked cast can be simplified.
-  --> $DIR/checked_conversions.rs:39:8
+  --> $DIR/checked_conversions.rs:23:13
    |
-LL |     if value <= (i32::max_value() as i64) && value >= (i32::min_value() as i64) {
-   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `i32::try_from(value).is_ok()`
+LL |     let _ = value <= i64::from(u16::MAX) && value >= 0;
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u16::try_from(value).is_ok()`
 
 error: Checked cast can be simplified.
-  --> $DIR/checked_conversions.rs:47:8
+  --> $DIR/checked_conversions.rs:27:13
    |
-LL |     if value <= i64::from(i16::max_value()) && value >= i64::from(i16::min_value()) {
-   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `i16::try_from(value).is_ok()`
+LL |     let _ = value <= (u8::max_value() as isize) && value >= 0;
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u8::try_from(value).is_ok()`
 
 error: Checked cast can be simplified.
-  --> $DIR/checked_conversions.rs:57:8
+  --> $DIR/checked_conversions.rs:28:13
    |
-LL |     if value <= i32::max_value() as u32 {
-   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `i32::try_from(value).is_ok()`
+LL |     let _ = value <= (u8::MAX as isize) && value >= 0;
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u8::try_from(value).is_ok()`
 
 error: Checked cast can be simplified.
-  --> $DIR/checked_conversions.rs:65:8
+  --> $DIR/checked_conversions.rs:34:13
    |
-LL |     if value <= isize::max_value() as usize && value as i32 == 5 {
-   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `isize::try_from(value).is_ok()`
+LL |     let _ = value <= (i32::max_value() as i64) && value >= (i32::min_value() as i64);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `i32::try_from(value).is_ok()`
 
 error: Checked cast can be simplified.
-  --> $DIR/checked_conversions.rs:73:8
+  --> $DIR/checked_conversions.rs:35:13
    |
-LL |     if value <= u16::max_value() as u32 && value as i32 == 5 {
-   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u16::try_from(value).is_ok()`
+LL |     let _ = value <= (i32::MAX as i64) && value >= (i32::MIN as i64);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `i32::try_from(value).is_ok()`
 
-error: aborting due to 8 previous errors
+error: Checked cast can be simplified.
+  --> $DIR/checked_conversions.rs:39:13
+   |
+LL |     let _ = value <= i64::from(i16::max_value()) && value >= i64::from(i16::min_value());
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `i16::try_from(value).is_ok()`
+
+error: Checked cast can be simplified.
+  --> $DIR/checked_conversions.rs:40:13
+   |
+LL |     let _ = value <= i64::from(i16::MAX) && value >= i64::from(i16::MIN);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `i16::try_from(value).is_ok()`
+
+error: Checked cast can be simplified.
+  --> $DIR/checked_conversions.rs:46:13
+   |
+LL |     let _ = value <= i32::max_value() as u32;
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `i32::try_from(value).is_ok()`
+
+error: Checked cast can be simplified.
+  --> $DIR/checked_conversions.rs:47:13
+   |
+LL |     let _ = value <= i32::MAX as u32;
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `i32::try_from(value).is_ok()`
+
+error: Checked cast can be simplified.
+  --> $DIR/checked_conversions.rs:51:13
+   |
+LL |     let _ = value <= isize::max_value() as usize && value as i32 == 5;
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `isize::try_from(value).is_ok()`
+
+error: Checked cast can be simplified.
+  --> $DIR/checked_conversions.rs:52:13
+   |
+LL |     let _ = value <= isize::MAX as usize && value as i32 == 5;
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `isize::try_from(value).is_ok()`
+
+error: Checked cast can be simplified.
+  --> $DIR/checked_conversions.rs:56:13
+   |
+LL |     let _ = value <= u16::max_value() as u32 && value as i32 == 5;
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u16::try_from(value).is_ok()`
+
+error: Checked cast can be simplified.
+  --> $DIR/checked_conversions.rs:57:13
+   |
+LL |     let _ = value <= u16::MAX as u32 && value as i32 == 5;
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u16::try_from(value).is_ok()`
+
+error: aborting due to 16 previous errors
 
diff --git a/tests/ui/checked_conversions.stdout b/tests/ui/checked_conversions.stdout
deleted file mode 100644
index e69de29bb2d..00000000000
-- 
cgit 1.4.1-3-g733a5


From 7654125d27d95d5c329e554115b510efc1ab1e60 Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Thu, 4 Jun 2020 03:34:22 +0200
Subject: match_wildcard_for_single_variants: remove empty line at start of
 lint example.

See https://rust-lang.github.io/rust-clippy/master/index.html#match_wildcard_for_single_variants

changelog: none
---
 clippy_lints/src/matches.rs | 1 -
 1 file changed, 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index 146212cb2c7..6d7af45a472 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -270,7 +270,6 @@ declare_clippy_lint! {
     /// ```rust
     /// # enum Foo { A, B, C }
     /// # let x = Foo::B;
-    ///
     /// // Bad
     /// match x {
     ///     Foo::A => {},
-- 
cgit 1.4.1-3-g733a5


From 413713c8848ec94d5f1709a41537c300da398806 Mon Sep 17 00:00:00 2001
From: Eduardo Broto <ebroto@tutanota.com>
Date: Fri, 5 Jun 2020 22:28:58 +0200
Subject: Add error info when cargo metadata fails to run

---
 clippy_lints/src/cargo_common_metadata.rs   | 13 ++-----------
 clippy_lints/src/multiple_crate_versions.rs | 10 ++--------
 clippy_lints/src/utils/mod.rs               | 18 ++++++++++++++++++
 clippy_lints/src/wildcard_dependencies.rs   |  7 +------
 4 files changed, 23 insertions(+), 25 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/cargo_common_metadata.rs b/clippy_lints/src/cargo_common_metadata.rs
index 16b46423c8f..c40a387d297 100644
--- a/clippy_lints/src/cargo_common_metadata.rs
+++ b/clippy_lints/src/cargo_common_metadata.rs
@@ -36,13 +36,9 @@ declare_clippy_lint! {
     "common metadata is defined in `Cargo.toml`"
 }
 
-fn warning(cx: &LateContext<'_, '_>, message: &str) {
-    span_lint(cx, CARGO_COMMON_METADATA, DUMMY_SP, message);
-}
-
 fn missing_warning(cx: &LateContext<'_, '_>, package: &cargo_metadata::Package, field: &str) {
     let message = format!("package `{}` is missing `{}` metadata", package.name, field);
-    warning(cx, &message);
+    span_lint(cx, CARGO_COMMON_METADATA, DUMMY_SP, &message);
 }
 
 fn is_empty_str(value: &Option<String>) -> bool {
@@ -66,12 +62,7 @@ impl LateLintPass<'_, '_> for CargoCommonMetadata {
             return;
         }
 
-        let metadata = if let Ok(metadata) = cargo_metadata::MetadataCommand::new().no_deps().exec() {
-            metadata
-        } else {
-            warning(cx, "could not read cargo metadata");
-            return;
-        };
+        let metadata = unwrap_cargo_metadata!(cx, CARGO_COMMON_METADATA, false);
 
         for package in metadata.packages {
             if is_empty_vec(&package.authors) {
diff --git a/clippy_lints/src/multiple_crate_versions.rs b/clippy_lints/src/multiple_crate_versions.rs
index b6770804e18..6c42014b4c8 100644
--- a/clippy_lints/src/multiple_crate_versions.rs
+++ b/clippy_lints/src/multiple_crate_versions.rs
@@ -7,7 +7,7 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::DUMMY_SP;
 
-use cargo_metadata::{DependencyKind, MetadataCommand, Node, Package, PackageId};
+use cargo_metadata::{DependencyKind, Node, Package, PackageId};
 use if_chain::if_chain;
 use itertools::Itertools;
 
@@ -42,13 +42,7 @@ impl LateLintPass<'_, '_> for MultipleCrateVersions {
             return;
         }
 
-        let metadata = if let Ok(metadata) = MetadataCommand::new().exec() {
-            metadata
-        } else {
-            span_lint(cx, MULTIPLE_CRATE_VERSIONS, DUMMY_SP, "could not read cargo metadata");
-            return;
-        };
-
+        let metadata = unwrap_cargo_metadata!(cx, MULTIPLE_CRATE_VERSIONS, true);
         let local_name = cx.tcx.crate_name(LOCAL_CRATE).as_str();
         let mut packages = metadata.packages;
         packages.sort_by(|a, b| a.name.cmp(&b.name));
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index 7e07e7751e3..2cdb6486fcb 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -1405,6 +1405,24 @@ pub fn run_lints(cx: &LateContext<'_, '_>, lints: &[&'static Lint], id: HirId) -
     })
 }
 
+#[macro_export]
+macro_rules! unwrap_cargo_metadata {
+    ($cx: ident, $lint: ident, $deps: expr) => {{
+        let mut command = cargo_metadata::MetadataCommand::new();
+        if !$deps {
+            command.no_deps();
+        }
+
+        match command.exec() {
+            Ok(metadata) => metadata,
+            Err(err) => {
+                span_lint($cx, $lint, DUMMY_SP, &format!("could not read cargo metadata: {}", err));
+                return;
+            },
+        }
+    }};
+}
+
 #[cfg(test)]
 mod test {
     use super::{trim_multiline, without_block_comments};
diff --git a/clippy_lints/src/wildcard_dependencies.rs b/clippy_lints/src/wildcard_dependencies.rs
index d8d48eb1535..511518082be 100644
--- a/clippy_lints/src/wildcard_dependencies.rs
+++ b/clippy_lints/src/wildcard_dependencies.rs
@@ -34,12 +34,7 @@ impl LateLintPass<'_, '_> for WildcardDependencies {
             return;
         }
 
-        let metadata = if let Ok(metadata) = cargo_metadata::MetadataCommand::new().no_deps().exec() {
-            metadata
-        } else {
-            span_lint(cx, WILDCARD_DEPENDENCIES, DUMMY_SP, "could not read cargo metadata");
-            return;
-        };
+        let metadata = unwrap_cargo_metadata!(cx, WILDCARD_DEPENDENCIES, false);
 
         for dep in &metadata.packages[0].dependencies {
             // VersionReq::any() does not work
-- 
cgit 1.4.1-3-g733a5


From 623faac84ec56fa545163ab81d7e3b759a392353 Mon Sep 17 00:00:00 2001
From: Philipp Hansch <dev@phansch.net>
Date: Sat, 6 Jun 2020 11:50:59 +0200
Subject: Cleanup: Use rustc's `same_types` instead of our `same_tys`

---
 clippy_lints/src/copies.rs              | 14 +++++---------
 clippy_lints/src/loops.rs               |  8 ++++----
 clippy_lints/src/methods/mod.rs         | 12 ++++++------
 clippy_lints/src/new_without_default.rs |  6 +++---
 clippy_lints/src/types.rs               |  6 +++---
 clippy_lints/src/useless_conversion.rs  | 14 +++++++-------
 clippy_lints/src/utils/mod.rs           | 16 +---------------
 7 files changed, 29 insertions(+), 47 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/copies.rs b/clippy_lints/src/copies.rs
index 66722786eab..b6d50bdfa14 100644
--- a/clippy_lints/src/copies.rs
+++ b/clippy_lints/src/copies.rs
@@ -1,9 +1,9 @@
-use crate::utils::{get_parent_expr, higher, if_sequence, same_tys, snippet, span_lint_and_note, span_lint_and_then};
+use crate::utils::{get_parent_expr, higher, if_sequence, snippet, span_lint_and_note, span_lint_and_then};
 use crate::utils::{SpanlessEq, SpanlessHash};
 use rustc_data_structures::fx::FxHashMap;
 use rustc_hir::{Arm, Block, Expr, ExprKind, MatchSource, Pat, PatKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty::Ty;
+use rustc_middle::ty::{Ty, TyS};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::symbol::Symbol;
 use std::collections::hash_map::Entry;
@@ -242,15 +242,11 @@ fn lint_same_fns_in_if_cond(cx: &LateContext<'_, '_>, conds: &[&Expr<'_>]) {
 
 /// Implementation of `MATCH_SAME_ARMS`.
 fn lint_match_arms<'tcx>(cx: &LateContext<'_, 'tcx>, expr: &Expr<'_>) {
-    fn same_bindings<'tcx>(
-        cx: &LateContext<'_, 'tcx>,
-        lhs: &FxHashMap<Symbol, Ty<'tcx>>,
-        rhs: &FxHashMap<Symbol, Ty<'tcx>>,
-    ) -> bool {
+    fn same_bindings<'tcx>(lhs: &FxHashMap<Symbol, Ty<'tcx>>, rhs: &FxHashMap<Symbol, Ty<'tcx>>) -> bool {
         lhs.len() == rhs.len()
             && lhs
                 .iter()
-                .all(|(name, l_ty)| rhs.get(name).map_or(false, |r_ty| same_tys(cx, l_ty, r_ty)))
+                .all(|(name, l_ty)| rhs.get(name).map_or(false, |r_ty| TyS::same_type(l_ty, r_ty)))
     }
 
     if let ExprKind::Match(_, ref arms, MatchSource::Normal) = expr.kind {
@@ -269,7 +265,7 @@ fn lint_match_arms<'tcx>(cx: &LateContext<'_, 'tcx>, expr: &Expr<'_>) {
             (min_index..=max_index).all(|index| arms[index].guard.is_none()) &&
                 SpanlessEq::new(cx).eq_expr(&lhs.body, &rhs.body) &&
                 // all patterns should have the same bindings
-                same_bindings(cx, &bindings(cx, &lhs.pat), &bindings(cx, &rhs.pat))
+                same_bindings(&bindings(cx, &lhs.pat), &bindings(cx, &rhs.pat))
         };
 
         let indexed_arms: Vec<(usize, &Arm<'_>)> = arms.iter().enumerate().collect();
diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index dbe41823a9c..57c62d73964 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -8,7 +8,7 @@ use crate::utils::{
     multispan_sugg, snippet, snippet_opt, snippet_with_applicability, span_lint, span_lint_and_help,
     span_lint_and_sugg, span_lint_and_then, SpanlessEq,
 };
-use crate::utils::{is_type_diagnostic_item, qpath_res, same_tys, sugg};
+use crate::utils::{is_type_diagnostic_item, qpath_res, sugg};
 use if_chain::if_chain;
 use rustc_ast::ast;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
@@ -24,7 +24,7 @@ use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::hir::map::Map;
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::middle::region;
-use rustc_middle::ty::{self, Ty};
+use rustc_middle::ty::{self, Ty, TyS};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
 use rustc_span::symbol::Symbol;
@@ -1256,7 +1256,7 @@ fn check_for_loop_arg(cx: &LateContext<'_, '_>, pat: &Pat<'_>, arg: &Expr<'_>, e
             } else if method_name == "into_iter" && match_trait_method(cx, arg, &paths::INTO_ITERATOR) {
                 let receiver_ty = cx.tables.expr_ty(&args[0]);
                 let receiver_ty_adjusted = cx.tables.expr_ty_adjusted(&args[0]);
-                if same_tys(cx, receiver_ty, receiver_ty_adjusted) {
+                if TyS::same_type(receiver_ty, receiver_ty_adjusted) {
                     let mut applicability = Applicability::MachineApplicable;
                     let object = snippet_with_applicability(cx, args[0].span, "_", &mut applicability);
                     span_lint_and_sugg(
@@ -1277,7 +1277,7 @@ fn check_for_loop_arg(cx: &LateContext<'_, '_>, pat: &Pat<'_>, arg: &Expr<'_>, e
                             mutbl: Mutability::Not,
                         },
                     );
-                    if same_tys(cx, receiver_ty_adjusted, ref_receiver_ty) {
+                    if TyS::same_type(receiver_ty_adjusted, ref_receiver_ty) {
                         lint_iter_method(cx, args, arg, method_name)
                     }
                 }
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index a9c0ff24fa6..78d69690c2d 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -18,7 +18,7 @@ use rustc_lint::{LateContext, LateLintPass, Lint, LintContext};
 use rustc_middle::hir::map::Map;
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::subst::GenericArgKind;
-use rustc_middle::ty::{self, Ty};
+use rustc_middle::ty::{self, Ty, TyS};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
 use rustc_span::symbol::{sym, SymbolStr};
@@ -29,9 +29,9 @@ use crate::utils::{
     get_arg_name, get_parent_expr, get_trait_def_id, has_iter_method, higher, implements_trait, in_macro, is_copy,
     is_ctor_or_promotable_const_function, is_expn_of, is_type_diagnostic_item, iter_input_pats, last_path_segment,
     match_def_path, match_qpath, match_trait_method, match_type, match_var, method_calls, method_chain_args, paths,
-    remove_blocks, return_ty, same_tys, single_segment_path, snippet, snippet_with_applicability,
-    snippet_with_macro_callsite, span_lint, span_lint_and_help, span_lint_and_note, span_lint_and_sugg,
-    span_lint_and_then, sugg, walk_ptrs_ty, walk_ptrs_ty_depth, SpanlessEq,
+    remove_blocks, return_ty, single_segment_path, snippet, snippet_with_applicability, snippet_with_macro_callsite,
+    span_lint, span_lint_and_help, span_lint_and_note, span_lint_and_sugg, span_lint_and_then, sugg, walk_ptrs_ty,
+    walk_ptrs_ty_depth, SpanlessEq,
 };
 
 declare_clippy_lint! {
@@ -1548,7 +1548,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Methods {
 
             let contains_self_ty = |ty: Ty<'tcx>| {
                 ty.walk().any(|inner| match inner.unpack() {
-                    GenericArgKind::Type(inner_ty) => same_tys(cx, self_ty, inner_ty),
+                    GenericArgKind::Type(inner_ty) => TyS::same_type(self_ty, inner_ty),
 
                     GenericArgKind::Lifetime(_) | GenericArgKind::Const(_) => false,
                 })
@@ -1575,7 +1575,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Methods {
                 }
             }
 
-            if name == "new" && !same_tys(cx, ret_ty, self_ty) {
+            if name == "new" && !TyS::same_type(ret_ty, self_ty) {
                 span_lint(
                     cx,
                     NEW_RET_NO_SELF,
diff --git a/clippy_lints/src/new_without_default.rs b/clippy_lints/src/new_without_default.rs
index e556e5d59c1..dd236535c18 100644
--- a/clippy_lints/src/new_without_default.rs
+++ b/clippy_lints/src/new_without_default.rs
@@ -1,13 +1,13 @@
 use crate::utils::paths;
 use crate::utils::sugg::DiagnosticBuilderExt;
-use crate::utils::{get_trait_def_id, return_ty, same_tys, span_lint_hir_and_then};
+use crate::utils::{get_trait_def_id, return_ty, span_lint_hir_and_then};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_hir::HirIdSet;
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_middle::ty::Ty;
+use rustc_middle::ty::{Ty, TyS};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 
 declare_clippy_lint! {
@@ -93,7 +93,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NewWithoutDefault {
                             let self_def_id = cx.tcx.hir().local_def_id(cx.tcx.hir().get_parent_item(id));
                             let self_ty = cx.tcx.type_of(self_def_id);
                             if_chain! {
-                                if same_tys(cx, self_ty, return_ty(cx, id));
+                                if TyS::same_type(self_ty, return_ty(cx, id));
                                 if let Some(default_trait_id) = get_trait_def_id(cx, &paths::DEFAULT_TRAIT);
                                 then {
                                     if self.impling_types.is_none() {
diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs
index 5ca30d598eb..bc5fe44b30f 100644
--- a/clippy_lints/src/types.rs
+++ b/clippy_lints/src/types.rs
@@ -17,7 +17,7 @@ use rustc_hir::{
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::hir::map::Map;
 use rustc_middle::lint::in_external_macro;
-use rustc_middle::ty::{self, InferTy, Ty, TyCtxt, TypeckTables};
+use rustc_middle::ty::{self, InferTy, Ty, TyCtxt, TyS, TypeckTables};
 use rustc_session::{declare_lint_pass, declare_tool_lint, impl_lint_pass};
 use rustc_span::hygiene::{ExpnKind, MacroKind};
 use rustc_span::source_map::Span;
@@ -31,7 +31,7 @@ use crate::utils::paths;
 use crate::utils::{
     clip, comparisons, differing_macro_contexts, higher, in_constant, indent_of, int_bits, is_type_diagnostic_item,
     last_path_segment, match_def_path, match_path, method_chain_args, multispan_sugg, numeric_literal::NumericLiteral,
-    qpath_res, same_tys, sext, snippet, snippet_block_with_applicability, snippet_opt, snippet_with_applicability,
+    qpath_res, sext, snippet, snippet_block_with_applicability, snippet_opt, snippet_with_applicability,
     snippet_with_macro_callsite, span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then, unsext,
 };
 
@@ -2556,7 +2556,7 @@ impl<'a, 'b, 'tcx> Visitor<'tcx> for ImplicitHasherConstructorVisitor<'a, 'b, 't
             if let ExprKind::Path(QPath::TypeRelative(ref ty, ref method)) = fun.kind;
             if let TyKind::Path(QPath::Resolved(None, ty_path)) = ty.kind;
             then {
-                if !same_tys(self.cx, self.target.ty(), self.body.expr_ty(e)) {
+                if !TyS::same_type(self.target.ty(), self.body.expr_ty(e)) {
                     return;
                 }
 
diff --git a/clippy_lints/src/useless_conversion.rs b/clippy_lints/src/useless_conversion.rs
index 7fa97b24699..141035a980a 100644
--- a/clippy_lints/src/useless_conversion.rs
+++ b/clippy_lints/src/useless_conversion.rs
@@ -1,12 +1,12 @@
 use crate::utils::{
-    is_type_diagnostic_item, match_def_path, match_trait_method, paths, same_tys, snippet, snippet_with_macro_callsite,
+    is_type_diagnostic_item, match_def_path, match_trait_method, paths, snippet, snippet_with_macro_callsite,
     span_lint_and_help, span_lint_and_sugg,
 };
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, HirId, MatchSource};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty;
+use rustc_middle::ty::{self, TyS};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 
 declare_clippy_lint! {
@@ -65,7 +65,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UselessConversion {
                 if match_trait_method(cx, e, &paths::INTO) && &*name.ident.as_str() == "into" {
                     let a = cx.tables.expr_ty(e);
                     let b = cx.tables.expr_ty(&args[0]);
-                    if same_tys(cx, a, b) {
+                    if TyS::same_type(a, b) {
                         let sugg = snippet_with_macro_callsite(cx, args[0].span, "<expr>").to_string();
                         span_lint_and_sugg(
                             cx,
@@ -81,7 +81,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UselessConversion {
                 if match_trait_method(cx, e, &paths::INTO_ITERATOR) && &*name.ident.as_str() == "into_iter" {
                     let a = cx.tables.expr_ty(e);
                     let b = cx.tables.expr_ty(&args[0]);
-                    if same_tys(cx, a, b) {
+                    if TyS::same_type(a, b) {
                         let sugg = snippet(cx, args[0].span, "<expr>").into_owned();
                         span_lint_and_sugg(
                             cx,
@@ -101,7 +101,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UselessConversion {
                         if is_type_diagnostic_item(cx, a, sym!(result_type));
                         if let ty::Adt(_, substs) = a.kind;
                         if let Some(a_type) = substs.types().next();
-                        if same_tys(cx, a_type, b);
+                        if TyS::same_type(a_type, b);
 
                         then {
                             span_lint_and_help(
@@ -131,7 +131,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UselessConversion {
                             if is_type_diagnostic_item(cx, a, sym!(result_type));
                             if let ty::Adt(_, substs) = a.kind;
                             if let Some(a_type) = substs.types().next();
-                            if same_tys(cx, a_type, b);
+                            if TyS::same_type(a_type, b);
 
                             then {
                                 let hint = format!("consider removing `{}()`", snippet(cx, path.span, "TryFrom::try_from"));
@@ -148,7 +148,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UselessConversion {
 
                         if_chain! {
                             if match_def_path(cx, def_id, &paths::FROM_FROM);
-                            if same_tys(cx, a, b);
+                            if TyS::same_type(a, b);
 
                             then {
                                 let sugg = snippet(cx, args[0].span.source_callsite(), "<expr>").into_owned();
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index 2cdb6486fcb..9a6750c51ab 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -40,7 +40,7 @@ use rustc_hir::{
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::{LateContext, Level, Lint, LintContext};
 use rustc_middle::hir::map::Map;
-use rustc_middle::ty::{self, layout::IntegerExt, subst::GenericArg, Binder, Ty, TyCtxt, TypeFoldable};
+use rustc_middle::ty::{self, layout::IntegerExt, subst::GenericArg, Ty, TyCtxt, TypeFoldable};
 use rustc_span::hygiene::{ExpnKind, MacroKind};
 use rustc_span::source_map::original_sp;
 use rustc_span::symbol::{self, kw, Symbol};
@@ -879,20 +879,6 @@ pub fn return_ty<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, fn_item: hir::HirId) -> T
     cx.tcx.erase_late_bound_regions(&ret_ty)
 }
 
-/// Checks if two types are the same.
-///
-/// This discards any lifetime annotations, too.
-//
-// FIXME: this works correctly for lifetimes bounds (`for <'a> Foo<'a>` ==
-// `for <'b> Foo<'b>`, but not for type parameters).
-pub fn same_tys<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, a: Ty<'tcx>, b: Ty<'tcx>) -> bool {
-    let a = cx.tcx.erase_late_bound_regions(&Binder::bind(a));
-    let b = cx.tcx.erase_late_bound_regions(&Binder::bind(b));
-    cx.tcx
-        .infer_ctxt()
-        .enter(|infcx| infcx.can_eq(cx.param_env, a, b).is_ok())
-}
-
 /// Returns `true` if the given type is an `unsafe` function.
 pub fn type_is_unsafe_function<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, ty: Ty<'tcx>) -> bool {
     match ty.kind {
-- 
cgit 1.4.1-3-g733a5


From dc13016ac2df1ce2663660389409b15eb2cf7e40 Mon Sep 17 00:00:00 2001
From: Eduardo Broto <ebroto@tutanota.com>
Date: Wed, 3 Jun 2020 01:13:57 +0200
Subject: Make let_and_return a late lint pass

---
 clippy_lints/src/let_and_return.rs | 82 ++++++++++++++++++++++++++++++++++++++
 clippy_lints/src/lib.rs            |  8 ++--
 clippy_lints/src/returns.rs        | 82 ++------------------------------------
 src/lintlist/mod.rs                |  2 +-
 4 files changed, 91 insertions(+), 83 deletions(-)
 create mode 100644 clippy_lints/src/let_and_return.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/let_and_return.rs b/clippy_lints/src/let_and_return.rs
new file mode 100644
index 00000000000..8b877f696af
--- /dev/null
+++ b/clippy_lints/src/let_and_return.rs
@@ -0,0 +1,82 @@
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir::{Block, ExprKind, PatKind, StmtKind};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_middle::lint::in_external_macro;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+use crate::utils::{in_macro, match_qpath, snippet_opt, span_lint_and_then};
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for `let`-bindings, which are subsequently
+    /// returned.
+    ///
+    /// **Why is this bad?** It is just extraneous code. Remove it to make your code
+    /// more rusty.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// ```rust
+    /// fn foo() -> String {
+    ///     let x = String::new();
+    ///     x
+    /// }
+    /// ```
+    /// instead, use
+    /// ```
+    /// fn foo() -> String {
+    ///     String::new()
+    /// }
+    /// ```
+    pub LET_AND_RETURN,
+    style,
+    "creating a let-binding and then immediately returning it like `let x = expr; x` at the end of a block"
+}
+
+declare_lint_pass!(LetReturn => [LET_AND_RETURN]);
+
+impl<'a, 'tcx> LateLintPass<'a, 'tcx> for LetReturn {
+    fn check_block(&mut self, cx: &LateContext<'a, 'tcx>, block: &'tcx Block<'_>) {
+        // we need both a let-binding stmt and an expr
+        if_chain! {
+            if let Some(retexpr) = block.expr;
+            if let Some(stmt) = block.stmts.iter().last();
+            if let StmtKind::Local(local) = &stmt.kind;
+            if local.ty.is_none();
+            if local.attrs.is_empty();
+            if let Some(initexpr) = &local.init;
+            if let PatKind::Binding(.., ident, _) = local.pat.kind;
+            if let ExprKind::Path(qpath) = &retexpr.kind;
+            if match_qpath(qpath, &[&*ident.name.as_str()]);
+            if !in_external_macro(cx.sess(), initexpr.span);
+            if !in_external_macro(cx.sess(), retexpr.span);
+            if !in_external_macro(cx.sess(), local.span);
+            if !in_macro(local.span);
+            then {
+                span_lint_and_then(
+                    cx,
+                    LET_AND_RETURN,
+                    retexpr.span,
+                    "returning the result of a `let` binding from a block",
+                    |err| {
+                        err.span_label(local.span, "unnecessary `let` binding");
+
+                        if let Some(snippet) = snippet_opt(cx, initexpr.span) {
+                            err.multipart_suggestion(
+                                "return the expression directly",
+                                vec![
+                                    (local.span, String::new()),
+                                    (retexpr.span, snippet),
+                                ],
+                                Applicability::MachineApplicable,
+                            );
+                        } else {
+                            err.span_help(initexpr.span, "this expression can be directly returned");
+                        }
+                    },
+                );
+            }
+        }
+    }
+}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 6f8923b2660..6bc9e23bac5 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -239,6 +239,7 @@ mod large_const_arrays;
 mod large_enum_variant;
 mod large_stack_arrays;
 mod len_zero;
+mod let_and_return;
 mod let_if_seq;
 mod let_underscore;
 mod lifetimes;
@@ -596,6 +597,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &large_stack_arrays::LARGE_STACK_ARRAYS,
         &len_zero::LEN_WITHOUT_IS_EMPTY,
         &len_zero::LEN_ZERO,
+        &let_and_return::LET_AND_RETURN,
         &let_if_seq::USELESS_LET_IF_SEQ,
         &let_underscore::LET_UNDERSCORE_LOCK,
         &let_underscore::LET_UNDERSCORE_MUST_USE,
@@ -772,7 +774,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &regex::INVALID_REGEX,
         &regex::REGEX_MACRO,
         &regex::TRIVIAL_REGEX,
-        &returns::LET_AND_RETURN,
         &returns::NEEDLESS_RETURN,
         &returns::UNUSED_UNIT,
         &serde_api::SERDE_API_MISUSE,
@@ -1022,6 +1023,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_early_pass(|| box formatting::Formatting);
     store.register_early_pass(|| box misc_early::MiscEarlyLints);
     store.register_early_pass(|| box returns::Return);
+    store.register_late_pass(|| box let_and_return::LetReturn);
     store.register_early_pass(|| box collapsible_if::CollapsibleIf);
     store.register_early_pass(|| box items_after_statements::ItemsAfterStatements);
     store.register_early_pass(|| box precedence::Precedence);
@@ -1265,6 +1267,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&large_enum_variant::LARGE_ENUM_VARIANT),
         LintId::of(&len_zero::LEN_WITHOUT_IS_EMPTY),
         LintId::of(&len_zero::LEN_ZERO),
+        LintId::of(&let_and_return::LET_AND_RETURN),
         LintId::of(&let_underscore::LET_UNDERSCORE_LOCK),
         LintId::of(&lifetimes::EXTRA_UNUSED_LIFETIMES),
         LintId::of(&lifetimes::NEEDLESS_LIFETIMES),
@@ -1390,7 +1393,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&regex::INVALID_REGEX),
         LintId::of(&regex::REGEX_MACRO),
         LintId::of(&regex::TRIVIAL_REGEX),
-        LintId::of(&returns::LET_AND_RETURN),
         LintId::of(&returns::NEEDLESS_RETURN),
         LintId::of(&returns::UNUSED_UNIT),
         LintId::of(&serde_api::SERDE_API_MISUSE),
@@ -1474,6 +1476,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&inherent_to_string::INHERENT_TO_STRING),
         LintId::of(&len_zero::LEN_WITHOUT_IS_EMPTY),
         LintId::of(&len_zero::LEN_ZERO),
+        LintId::of(&let_and_return::LET_AND_RETURN),
         LintId::of(&literal_representation::INCONSISTENT_DIGIT_GROUPING),
         LintId::of(&loops::EMPTY_LOOP),
         LintId::of(&loops::FOR_KV_MAP),
@@ -1526,7 +1529,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&redundant_static_lifetimes::REDUNDANT_STATIC_LIFETIMES),
         LintId::of(&regex::REGEX_MACRO),
         LintId::of(&regex::TRIVIAL_REGEX),
-        LintId::of(&returns::LET_AND_RETURN),
         LintId::of(&returns::NEEDLESS_RETURN),
         LintId::of(&returns::UNUSED_UNIT),
         LintId::of(&single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS),
diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
index 35464f629c3..3c939744173 100644
--- a/clippy_lints/src/returns.rs
+++ b/clippy_lints/src/returns.rs
@@ -8,7 +8,7 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
 use rustc_span::BytePos;
 
-use crate::utils::{in_macro, match_path_ast, snippet_opt, span_lint_and_sugg, span_lint_and_then};
+use crate::utils::{snippet_opt, span_lint_and_sugg, span_lint_and_then};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for return statements at the end of a block.
@@ -36,33 +36,6 @@ declare_clippy_lint! {
     "using a return statement like `return expr;` where an expression would suffice"
 }
 
-declare_clippy_lint! {
-    /// **What it does:** Checks for `let`-bindings, which are subsequently
-    /// returned.
-    ///
-    /// **Why is this bad?** It is just extraneous code. Remove it to make your code
-    /// more rusty.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    /// ```rust
-    /// fn foo() -> String {
-    ///     let x = String::new();
-    ///     x
-    /// }
-    /// ```
-    /// instead, use
-    /// ```
-    /// fn foo() -> String {
-    ///     String::new()
-    /// }
-    /// ```
-    pub LET_AND_RETURN,
-    style,
-    "creating a let-binding and then immediately returning it like `let x = expr; x` at the end of a block"
-}
-
 declare_clippy_lint! {
     /// **What it does:** Checks for unit (`()`) expressions that can be removed.
     ///
@@ -90,7 +63,7 @@ enum RetReplacement {
     Block,
 }
 
-declare_lint_pass!(Return => [NEEDLESS_RETURN, LET_AND_RETURN, UNUSED_UNIT]);
+declare_lint_pass!(Return => [NEEDLESS_RETURN, UNUSED_UNIT]);
 
 impl Return {
     // Check the final stmt or expr in a block for unnecessary return.
@@ -105,7 +78,7 @@ impl Return {
         }
     }
 
-    // Check a the final expression in a block if it's a return.
+    // Check the final expression in a block if it's a return.
     fn check_final_expr(
         &mut self,
         cx: &EarlyContext<'_>,
@@ -186,54 +159,6 @@ impl Return {
             },
         }
     }
-
-    // Check for "let x = EXPR; x"
-    fn check_let_return(cx: &EarlyContext<'_>, block: &ast::Block) {
-        let mut it = block.stmts.iter();
-
-        // we need both a let-binding stmt and an expr
-        if_chain! {
-            if let Some(retexpr) = it.next_back();
-            if let ast::StmtKind::Expr(ref retexpr) = retexpr.kind;
-            if let Some(stmt) = it.next_back();
-            if let ast::StmtKind::Local(ref local) = stmt.kind;
-            // don't lint in the presence of type inference
-            if local.ty.is_none();
-            if local.attrs.is_empty();
-            if let Some(ref initexpr) = local.init;
-            if let ast::PatKind::Ident(_, ident, _) = local.pat.kind;
-            if let ast::ExprKind::Path(_, ref path) = retexpr.kind;
-            if match_path_ast(path, &[&*ident.name.as_str()]);
-            if !in_external_macro(cx.sess(), initexpr.span);
-            if !in_external_macro(cx.sess(), retexpr.span);
-            if !in_external_macro(cx.sess(), local.span);
-            if !in_macro(local.span);
-            then {
-                span_lint_and_then(
-                    cx,
-                    LET_AND_RETURN,
-                    retexpr.span,
-                    "returning the result of a `let` binding from a block",
-                    |err| {
-                        err.span_label(local.span, "unnecessary `let` binding");
-
-                        if let Some(snippet) = snippet_opt(cx, initexpr.span) {
-                            err.multipart_suggestion(
-                                "return the expression directly",
-                                vec![
-                                    (local.span, String::new()),
-                                    (retexpr.span, snippet),
-                                ],
-                                Applicability::MachineApplicable,
-                            );
-                        } else {
-                            err.span_help(initexpr.span, "this expression can be directly returned");
-                        }
-                    },
-                );
-            }
-        }
-    }
 }
 
 impl EarlyLintPass for Return {
@@ -254,7 +179,6 @@ impl EarlyLintPass for Return {
     }
 
     fn check_block(&mut self, cx: &EarlyContext<'_>, block: &ast::Block) {
-        Self::check_let_return(cx, block);
         if_chain! {
             if let Some(ref stmt) = block.stmts.last();
             if let ast::StmtKind::Expr(ref expr) = stmt.kind;
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index d5d07ccb2eb..bb191f9be92 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -1023,7 +1023,7 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
         group: "style",
         desc: "creating a let-binding and then immediately returning it like `let x = expr; x` at the end of a block",
         deprecation: None,
-        module: "returns",
+        module: "let_and_return",
     },
     Lint {
         name: "let_underscore_lock",
-- 
cgit 1.4.1-3-g733a5


From dac8a3c1ca19d2b5934ecbe2ed79ae6c156fd885 Mon Sep 17 00:00:00 2001
From: Eduardo Broto <ebroto@tutanota.com>
Date: Sun, 7 Jun 2020 00:30:39 +0200
Subject: let_and_return: do not lint if last statement borrows

---
 clippy_lints/src/let_and_return.rs | 61 +++++++++++++++++++++++++++++++++-
 clippy_lints/src/utils/mod.rs      |  2 +-
 tests/ui/let_and_return.rs         | 68 ++++++++++++++++++++++++++++++++++++++
 3 files changed, 129 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/let_and_return.rs b/clippy_lints/src/let_and_return.rs
index 8b877f696af..6d3fb317bcf 100644
--- a/clippy_lints/src/let_and_return.rs
+++ b/clippy_lints/src/let_and_return.rs
@@ -1,8 +1,12 @@
 use if_chain::if_chain;
 use rustc_errors::Applicability;
-use rustc_hir::{Block, ExprKind, PatKind, StmtKind};
+use rustc_hir::def_id::DefId;
+use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
+use rustc_hir::{Block, Expr, ExprKind, PatKind, StmtKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_middle::hir::map::Map;
 use rustc_middle::lint::in_external_macro;
+use rustc_middle::ty::subst::GenericArgKind;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 use crate::utils::{in_macro, match_qpath, snippet_opt, span_lint_and_then};
@@ -49,6 +53,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for LetReturn {
             if let PatKind::Binding(.., ident, _) = local.pat.kind;
             if let ExprKind::Path(qpath) = &retexpr.kind;
             if match_qpath(qpath, &[&*ident.name.as_str()]);
+            if !last_statement_borrows(cx, initexpr);
             if !in_external_macro(cx.sess(), initexpr.span);
             if !in_external_macro(cx.sess(), retexpr.span);
             if !in_external_macro(cx.sess(), local.span);
@@ -80,3 +85,57 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for LetReturn {
         }
     }
 }
+
+fn last_statement_borrows<'tcx>(cx: &LateContext<'_, 'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
+    let mut visitor = BorrowVisitor { cx, borrows: false };
+    walk_expr(&mut visitor, expr);
+    visitor.borrows
+}
+
+struct BorrowVisitor<'a, 'tcx> {
+    cx: &'a LateContext<'a, 'tcx>,
+    borrows: bool,
+}
+
+impl BorrowVisitor<'_, '_> {
+    fn fn_def_id(&self, expr: &Expr<'_>) -> Option<DefId> {
+        match &expr.kind {
+            ExprKind::MethodCall(..) => self.cx.tables.type_dependent_def_id(expr.hir_id),
+            ExprKind::Call(
+                Expr {
+                    kind: ExprKind::Path(qpath),
+                    ..
+                },
+                ..,
+            ) => self.cx.tables.qpath_res(qpath, expr.hir_id).opt_def_id(),
+            _ => None,
+        }
+    }
+}
+
+impl<'tcx> Visitor<'tcx> for BorrowVisitor<'_, 'tcx> {
+    type Map = Map<'tcx>;
+
+    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
+        if self.borrows {
+            return;
+        }
+
+        if let Some(def_id) = self.fn_def_id(expr) {
+            self.borrows = self
+                .cx
+                .tcx
+                .fn_sig(def_id)
+                .output()
+                .skip_binder()
+                .walk()
+                .any(|arg| matches!(arg.unpack(), GenericArgKind::Lifetime(_)));
+        }
+
+        walk_expr(self, expr);
+    }
+
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::None
+    }
+}
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index 06638e7187b..39410acea4e 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -400,7 +400,7 @@ pub fn method_calls<'tcx>(
 /// Matches an `Expr` against a chain of methods, and return the matched `Expr`s.
 ///
 /// For example, if `expr` represents the `.baz()` in `foo.bar().baz()`,
-/// `matched_method_chain(expr, &["bar", "baz"])` will return a `Vec`
+/// `method_chain_args(expr, &["bar", "baz"])` will return a `Vec`
 /// containing the `Expr`s for
 /// `.bar()` and `.baz()`
 pub fn method_chain_args<'a>(expr: &'a Expr<'_>, methods: &[&str]) -> Option<Vec<&'a [Expr<'a>]>> {
diff --git a/tests/ui/let_and_return.rs b/tests/ui/let_and_return.rs
index 23645d48fe7..09614b8c1ad 100644
--- a/tests/ui/let_and_return.rs
+++ b/tests/ui/let_and_return.rs
@@ -67,4 +67,72 @@ macro_rules! tuple_encode {
 
 tuple_encode!(T0, T1, T2, T3, T4, T5, T6, T7);
 
+mod no_lint_if_stmt_borrows {
+    mod issue_3792 {
+        use std::io::{self, BufRead, Stdin};
+
+        fn read_line() -> String {
+            let stdin = io::stdin();
+            let line = stdin.lock().lines().next().unwrap().unwrap();
+            line
+        }
+    }
+
+    mod issue_3324 {
+        use std::cell::RefCell;
+        use std::rc::{Rc, Weak};
+
+        fn test(value: Weak<RefCell<Bar>>) -> u32 {
+            let value = value.upgrade().unwrap();
+            let ret = value.borrow().baz();
+            ret
+        }
+
+        struct Bar {}
+
+        impl Bar {
+            fn new() -> Self {
+                Bar {}
+            }
+            fn baz(&self) -> u32 {
+                0
+            }
+        }
+
+        fn main() {
+            let a = Rc::new(RefCell::new(Bar::new()));
+            let b = Rc::downgrade(&a);
+            test(b);
+        }
+    }
+
+    mod free_function {
+        struct Inner;
+
+        struct Foo<'a> {
+            inner: &'a Inner,
+        }
+
+        impl Drop for Foo<'_> {
+            fn drop(&mut self) {}
+        }
+
+        impl Foo<'_> {
+            fn value(&self) -> i32 {
+                42
+            }
+        }
+
+        fn some_foo(inner: &Inner) -> Foo<'_> {
+            Foo { inner }
+        }
+
+        fn test() -> i32 {
+            let x = Inner {};
+            let value = some_foo(&x).value();
+            value
+        }
+    }
+}
+
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From ebfc1da07d2cd1cba87a3df79c5ffbfc0d25618c Mon Sep 17 00:00:00 2001
From: Eduardo Broto <ebroto@tutanota.com>
Date: Sun, 7 Jun 2020 20:38:28 +0200
Subject: reversed_empty_ranges: don't lint N..N except in for loop arg

---
 clippy_lints/src/ranges.rs                      | 62 ++++++++++++-------------
 tests/ui/reversed_empty_ranges_fixable.fixed    |  8 ++--
 tests/ui/reversed_empty_ranges_fixable.rs       |  8 ++--
 tests/ui/reversed_empty_ranges_fixable.stderr   | 16 ++-----
 tests/ui/reversed_empty_ranges_unfixable.rs     |  5 +-
 tests/ui/reversed_empty_ranges_unfixable.stderr | 18 +++----
 6 files changed, 51 insertions(+), 66 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/ranges.rs b/clippy_lints/src/ranges.rs
index 1eb26d97ed4..45de4d29375 100644
--- a/clippy_lints/src/ranges.rs
+++ b/clippy_lints/src/ranges.rs
@@ -241,14 +241,26 @@ fn check_inclusive_range_minus_one(cx: &LateContext<'_, '_>, expr: &Expr<'_>) {
 }
 
 fn check_reversed_empty_range(cx: &LateContext<'_, '_>, expr: &Expr<'_>) {
-    fn inside_indexing_expr<'a>(cx: &'a LateContext<'_, '_>, expr: &Expr<'_>) -> Option<&'a Expr<'a>> {
-        match get_parent_expr(cx, expr) {
-            parent_expr @ Some(Expr {
+    fn inside_indexing_expr<'a>(cx: &'a LateContext<'_, '_>, expr: &Expr<'_>) -> bool {
+        matches!(
+            get_parent_expr(cx, expr),
+            Some(Expr {
                 kind: ExprKind::Index(..),
                 ..
-            }) => parent_expr,
-            _ => None,
+            })
+        )
+    }
+
+    fn is_for_loop_arg(cx: &LateContext<'_, '_>, expr: &Expr<'_>) -> bool {
+        let mut cur_expr = expr;
+        while let Some(parent_expr) = get_parent_expr(cx, cur_expr) {
+            match higher::for_loop(parent_expr) {
+                Some((_, args, _)) if args.hir_id == expr.hir_id => return true,
+                _ => cur_expr = parent_expr,
+            }
         }
+
+        false
     }
 
     fn is_empty_range(limits: RangeLimits, ordering: Ordering) -> bool {
@@ -267,34 +279,18 @@ fn check_reversed_empty_range(cx: &LateContext<'_, '_>, expr: &Expr<'_>) {
         if let Some(ordering) = Constant::partial_cmp(cx.tcx, ty, &start_idx, &end_idx);
         if is_empty_range(limits, ordering);
         then {
-            if let Some(parent_expr) = inside_indexing_expr(cx, expr) {
-                let (reason, outcome) = if ordering == Ordering::Equal {
-                    ("empty", "always yield an empty slice")
-                } else {
-                    ("reversed", "panic at run-time")
-                };
-
-                span_lint_and_then(
-                    cx,
-                    REVERSED_EMPTY_RANGES,
-                    expr.span,
-                    &format!("this range is {} and using it to index a slice will {}", reason, outcome),
-                    |diag| {
-                        if_chain! {
-                            if ordering == Ordering::Equal;
-                            if let ty::Slice(slice_ty) = cx.tables.expr_ty(parent_expr).kind;
-                            then {
-                                diag.span_suggestion(
-                                    parent_expr.span,
-                                    "if you want an empty slice, use",
-                                    format!("[] as &[{}]", slice_ty),
-                                    Applicability::MaybeIncorrect
-                                );
-                            }
-                        }
-                    }
-                );
-            } else {
+            if inside_indexing_expr(cx, expr) {
+                // Avoid linting `N..N` as it has proven to be useful, see #5689 and #5628 ...
+                if ordering != Ordering::Equal {
+                    span_lint(
+                        cx,
+                        REVERSED_EMPTY_RANGES,
+                        expr.span,
+                        "this range is reversed and using it to index a slice will panic at run-time",
+                    );
+                }
+            // ... except in for loop arguments for backwards compatibility with `reverse_range_loop`
+            } else if ordering != Ordering::Equal || is_for_loop_arg(cx, expr) {
                 span_lint_and_then(
                     cx,
                     REVERSED_EMPTY_RANGES,
diff --git a/tests/ui/reversed_empty_ranges_fixable.fixed b/tests/ui/reversed_empty_ranges_fixable.fixed
index 332c0427ef6..79e482eec30 100644
--- a/tests/ui/reversed_empty_ranges_fixable.fixed
+++ b/tests/ui/reversed_empty_ranges_fixable.fixed
@@ -4,8 +4,6 @@
 const ANSWER: i32 = 42;
 
 fn main() {
-    let arr = [1, 2, 3, 4, 5];
-
     // These should be linted:
 
     (21..=42).rev().for_each(|x| println!("{}", x));
@@ -14,16 +12,18 @@ fn main() {
     for _ in (-42..=-21).rev() {}
     for _ in (21u32..42u32).rev() {}
 
-    let _ = &[] as &[i32];
-
     // These should be ignored as they are not empty ranges:
 
     (21..=42).for_each(|x| println!("{}", x));
     (21..42).for_each(|x| println!("{}", x));
 
+    let arr = [1, 2, 3, 4, 5];
     let _ = &arr[1..=3];
     let _ = &arr[1..3];
 
     for _ in 21..=42 {}
     for _ in 21..42 {}
+
+    // This range is empty but should be ignored, see issue #5689
+    let _ = &arr[0..0];
 }
diff --git a/tests/ui/reversed_empty_ranges_fixable.rs b/tests/ui/reversed_empty_ranges_fixable.rs
index 901ec8bcc09..b2e8bf33771 100644
--- a/tests/ui/reversed_empty_ranges_fixable.rs
+++ b/tests/ui/reversed_empty_ranges_fixable.rs
@@ -4,8 +4,6 @@
 const ANSWER: i32 = 42;
 
 fn main() {
-    let arr = [1, 2, 3, 4, 5];
-
     // These should be linted:
 
     (42..=21).for_each(|x| println!("{}", x));
@@ -14,16 +12,18 @@ fn main() {
     for _ in -21..=-42 {}
     for _ in 42u32..21u32 {}
 
-    let _ = &arr[3..3];
-
     // These should be ignored as they are not empty ranges:
 
     (21..=42).for_each(|x| println!("{}", x));
     (21..42).for_each(|x| println!("{}", x));
 
+    let arr = [1, 2, 3, 4, 5];
     let _ = &arr[1..=3];
     let _ = &arr[1..3];
 
     for _ in 21..=42 {}
     for _ in 21..42 {}
+
+    // This range is empty but should be ignored, see issue #5689
+    let _ = &arr[0..0];
 }
diff --git a/tests/ui/reversed_empty_ranges_fixable.stderr b/tests/ui/reversed_empty_ranges_fixable.stderr
index 9a646fd9939..de83c4f3d63 100644
--- a/tests/ui/reversed_empty_ranges_fixable.stderr
+++ b/tests/ui/reversed_empty_ranges_fixable.stderr
@@ -1,5 +1,5 @@
 error: this range is empty so it will yield no values
-  --> $DIR/reversed_empty_ranges_fixable.rs:11:5
+  --> $DIR/reversed_empty_ranges_fixable.rs:9:5
    |
 LL |     (42..=21).for_each(|x| println!("{}", x));
    |     ^^^^^^^^^
@@ -11,7 +11,7 @@ LL |     (21..=42).rev().for_each(|x| println!("{}", x));
    |     ^^^^^^^^^^^^^^^
 
 error: this range is empty so it will yield no values
-  --> $DIR/reversed_empty_ranges_fixable.rs:12:13
+  --> $DIR/reversed_empty_ranges_fixable.rs:10:13
    |
 LL |     let _ = (ANSWER..21).filter(|x| x % 2 == 0).take(10).collect::<Vec<_>>();
    |             ^^^^^^^^^^^^
@@ -22,7 +22,7 @@ LL |     let _ = (21..ANSWER).rev().filter(|x| x % 2 == 0).take(10).collect::<Ve
    |             ^^^^^^^^^^^^^^^^^^
 
 error: this range is empty so it will yield no values
-  --> $DIR/reversed_empty_ranges_fixable.rs:14:14
+  --> $DIR/reversed_empty_ranges_fixable.rs:12:14
    |
 LL |     for _ in -21..=-42 {}
    |              ^^^^^^^^^
@@ -33,7 +33,7 @@ LL |     for _ in (-42..=-21).rev() {}
    |              ^^^^^^^^^^^^^^^^^
 
 error: this range is empty so it will yield no values
-  --> $DIR/reversed_empty_ranges_fixable.rs:15:14
+  --> $DIR/reversed_empty_ranges_fixable.rs:13:14
    |
 LL |     for _ in 42u32..21u32 {}
    |              ^^^^^^^^^^^^
@@ -43,11 +43,5 @@ help: consider using the following if you are attempting to iterate over this ra
 LL |     for _ in (21u32..42u32).rev() {}
    |              ^^^^^^^^^^^^^^^^^^^^
 
-error: this range is empty and using it to index a slice will always yield an empty slice
-  --> $DIR/reversed_empty_ranges_fixable.rs:17:18
-   |
-LL |     let _ = &arr[3..3];
-   |              ----^^^^- help: if you want an empty slice, use: `[] as &[i32]`
-
-error: aborting due to 5 previous errors
+error: aborting due to 4 previous errors
 
diff --git a/tests/ui/reversed_empty_ranges_unfixable.rs b/tests/ui/reversed_empty_ranges_unfixable.rs
index 561a35625f0..264d3d1e95a 100644
--- a/tests/ui/reversed_empty_ranges_unfixable.rs
+++ b/tests/ui/reversed_empty_ranges_unfixable.rs
@@ -4,11 +4,12 @@ const ANSWER: i32 = 42;
 const SOME_NUM: usize = 3;
 
 fn main() {
-    let _ = (42 + 10..42 + 10).map(|x| x / 2).find(|&x| x == 21);
-
     let arr = [1, 2, 3, 4, 5];
     let _ = &arr[3usize..=1usize];
     let _ = &arr[SOME_NUM..1];
 
     for _ in ANSWER..ANSWER {}
+
+    // Should not be linted, see issue #5689
+    let _ = (42 + 10..42 + 10).map(|x| x / 2).find(|&x| x == 21);
 }
diff --git a/tests/ui/reversed_empty_ranges_unfixable.stderr b/tests/ui/reversed_empty_ranges_unfixable.stderr
index 240188cbb46..f23d4eb0f9c 100644
--- a/tests/ui/reversed_empty_ranges_unfixable.stderr
+++ b/tests/ui/reversed_empty_ranges_unfixable.stderr
@@ -1,28 +1,22 @@
-error: this range is empty so it will yield no values
-  --> $DIR/reversed_empty_ranges_unfixable.rs:7:13
-   |
-LL |     let _ = (42 + 10..42 + 10).map(|x| x / 2).find(|&x| x == 21);
-   |             ^^^^^^^^^^^^^^^^^^
-   |
-   = note: `-D clippy::reversed-empty-ranges` implied by `-D warnings`
-
 error: this range is reversed and using it to index a slice will panic at run-time
-  --> $DIR/reversed_empty_ranges_unfixable.rs:10:18
+  --> $DIR/reversed_empty_ranges_unfixable.rs:8:18
    |
 LL |     let _ = &arr[3usize..=1usize];
    |                  ^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::reversed-empty-ranges` implied by `-D warnings`
 
 error: this range is reversed and using it to index a slice will panic at run-time
-  --> $DIR/reversed_empty_ranges_unfixable.rs:11:18
+  --> $DIR/reversed_empty_ranges_unfixable.rs:9:18
    |
 LL |     let _ = &arr[SOME_NUM..1];
    |                  ^^^^^^^^^^^
 
 error: this range is empty so it will yield no values
-  --> $DIR/reversed_empty_ranges_unfixable.rs:13:14
+  --> $DIR/reversed_empty_ranges_unfixable.rs:11:14
    |
 LL |     for _ in ANSWER..ANSWER {}
    |              ^^^^^^^^^^^^^^
 
-error: aborting due to 4 previous errors
+error: aborting due to 3 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 7b6dc7b33dc437a59330ef3f5426102ca60fbf51 Mon Sep 17 00:00:00 2001
From: Mazdak Farrokhzad <twingoow@gmail.com>
Date: Thu, 19 Mar 2020 14:14:52 +0100
Subject: add `unnested_or_patterns` lint

---
 CHANGELOG.md                              |   1 +
 clippy_lints/src/lib.rs                   |   7 +
 clippy_lints/src/unnested_or_patterns.rs  | 407 +++++++++++++++++++++++
 clippy_lints/src/utils/ast_utils.rs       | 525 ++++++++++++++++++++++++++++++
 clippy_lints/src/utils/hir_utils.rs       |  10 +-
 clippy_lints/src/utils/mod.rs             |   3 +-
 src/lintlist/mod.rs                       |   7 +
 tests/ui/neg_cmp_op_on_partial_ord.rs     |   1 +
 tests/ui/neg_cmp_op_on_partial_ord.stderr |   8 +-
 tests/ui/unnested_or_patterns.fixed       |  41 +++
 tests/ui/unnested_or_patterns.rs          |  41 +++
 tests/ui/unnested_or_patterns.stderr      | 267 +++++++++++++++
 tests/ui/wildcard_enum_match_arm.fixed    |   3 +-
 tests/ui/wildcard_enum_match_arm.rs       |   3 +-
 tests/ui/wildcard_enum_match_arm.stderr   |  10 +-
 15 files changed, 1314 insertions(+), 20 deletions(-)
 create mode 100644 clippy_lints/src/unnested_or_patterns.rs
 create mode 100755 clippy_lints/src/utils/ast_utils.rs
 create mode 100644 tests/ui/unnested_or_patterns.fixed
 create mode 100644 tests/ui/unnested_or_patterns.rs
 create mode 100644 tests/ui/unnested_or_patterns.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index a4a184480fb..adc945a6944 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1683,6 +1683,7 @@ Released 2018-09-13
 [`unnecessary_unwrap`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_unwrap
 [`unneeded_field_pattern`]: https://rust-lang.github.io/rust-clippy/master/index.html#unneeded_field_pattern
 [`unneeded_wildcard_pattern`]: https://rust-lang.github.io/rust-clippy/master/index.html#unneeded_wildcard_pattern
+[`unnested_or_patterns`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnested_or_patterns
 [`unreachable`]: https://rust-lang.github.io/rust-clippy/master/index.html#unreachable
 [`unreadable_literal`]: https://rust-lang.github.io/rust-clippy/master/index.html#unreadable_literal
 [`unsafe_derive_deserialize`]: https://rust-lang.github.io/rust-clippy/master/index.html#unsafe_derive_deserialize
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 6f8923b2660..9809f953d67 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1,5 +1,6 @@
 // error-pattern:cargo-clippy
 
+#![feature(bindings_after_at)]
 #![feature(box_syntax)]
 #![feature(box_patterns)]
 #![feature(or_patterns)]
@@ -12,6 +13,7 @@
 #![cfg_attr(feature = "deny-warnings", deny(warnings))]
 #![feature(crate_visibility_modifier)]
 #![feature(concat_idents)]
+#![feature(drain_filter)]
 
 // FIXME: switch to something more ergonomic here, once available.
 // (Currently there is no way to opt into sysroot crates without `extern crate`.)
@@ -319,6 +321,7 @@ mod types;
 mod unicode;
 mod unnamed_address;
 mod unnecessary_sort_by;
+mod unnested_or_patterns;
 mod unsafe_removed_from_name;
 mod unused_io_amount;
 mod unused_self;
@@ -836,6 +839,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &unnamed_address::FN_ADDRESS_COMPARISONS,
         &unnamed_address::VTABLE_ADDRESS_COMPARISONS,
         &unnecessary_sort_by::UNNECESSARY_SORT_BY,
+        &unnested_or_patterns::UNNESTED_OR_PATTERNS,
         &unsafe_removed_from_name::UNSAFE_REMOVED_FROM_NAME,
         &unused_io_amount::UNUSED_IO_AMOUNT,
         &unused_self::UNUSED_SELF,
@@ -1073,6 +1077,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_early_pass(move || box non_expressive_names::NonExpressiveNames {
         single_char_binding_names_threshold,
     });
+    store.register_early_pass(|| box unnested_or_patterns::UnnestedOrPatterns);
 
     store.register_group(true, "clippy::restriction", Some("clippy_restriction"), vec![
         LintId::of(&arithmetic::FLOAT_ARITHMETIC),
@@ -1433,6 +1438,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&unnamed_address::FN_ADDRESS_COMPARISONS),
         LintId::of(&unnamed_address::VTABLE_ADDRESS_COMPARISONS),
         LintId::of(&unnecessary_sort_by::UNNECESSARY_SORT_BY),
+        LintId::of(&unnested_or_patterns::UNNESTED_OR_PATTERNS),
         LintId::of(&unsafe_removed_from_name::UNSAFE_REMOVED_FROM_NAME),
         LintId::of(&unused_io_amount::UNUSED_IO_AMOUNT),
         LintId::of(&unwrap::PANICKING_UNWRAP),
@@ -1616,6 +1622,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&types::UNNECESSARY_CAST),
         LintId::of(&types::VEC_BOX),
         LintId::of(&unnecessary_sort_by::UNNECESSARY_SORT_BY),
+        LintId::of(&unnested_or_patterns::UNNESTED_OR_PATTERNS),
         LintId::of(&unwrap::UNNECESSARY_UNWRAP),
         LintId::of(&useless_conversion::USELESS_CONVERSION),
         LintId::of(&zero_div_zero::ZERO_DIVIDED_BY_ZERO),
diff --git a/clippy_lints/src/unnested_or_patterns.rs b/clippy_lints/src/unnested_or_patterns.rs
new file mode 100644
index 00000000000..2723af03c0b
--- /dev/null
+++ b/clippy_lints/src/unnested_or_patterns.rs
@@ -0,0 +1,407 @@
+#![allow(clippy::wildcard_imports, clippy::enum_glob_use)]
+
+use crate::utils::ast_utils::{eq_field_pat, eq_id, eq_pat, eq_path};
+use crate::utils::{over, span_lint_and_then};
+use rustc_ast::ast::{self, Pat, PatKind, PatKind::*, DUMMY_NODE_ID};
+use rustc_ast::mut_visit::*;
+use rustc_ast::ptr::P;
+use rustc_ast_pretty::pprust;
+use rustc_errors::Applicability;
+use rustc_lint::{EarlyContext, EarlyLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::DUMMY_SP;
+
+use std::cell::Cell;
+use std::mem;
+
+declare_clippy_lint! {
+    /// **What it does:**
+    ///
+    /// Checks for unnested or-patterns, e.g., `Some(0) | Some(2)` and
+    /// suggests replacing the pattern with a nested one, `Some(0 | 2)`.
+    ///
+    /// Another way to think of this is that it rewrites patterns in
+    /// *disjunctive normal form (DNF)* into *conjunctive normal form (CNF)*.
+    ///
+    /// **Why is this bad?**
+    ///
+    /// In the example above, `Some` is repeated, which unncessarily complicates the pattern.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// fn main() {
+    ///     if let Some(0) | Some(2) = Some(0) {}
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// #![feature(or_patterns)]
+    ///
+    /// fn main() {
+    ///     if let Some(0 | 2) = Some(0) {}
+    /// }
+    /// ```
+    pub UNNESTED_OR_PATTERNS,
+    complexity,
+    "unnested or-patterns, e.g., `Foo(Bar) | Foo(Baz) instead of `Foo(Bar | Baz)`"
+}
+
+declare_lint_pass!(UnnestedOrPatterns => [UNNESTED_OR_PATTERNS]);
+
+impl EarlyLintPass for UnnestedOrPatterns {
+    fn check_arm(&mut self, cx: &EarlyContext<'_>, a: &ast::Arm) {
+        lint_unnested_or_patterns(cx, &a.pat);
+    }
+
+    fn check_expr(&mut self, cx: &EarlyContext<'_>, e: &ast::Expr) {
+        if let ast::ExprKind::Let(pat, _) = &e.kind {
+            lint_unnested_or_patterns(cx, pat);
+        }
+    }
+
+    fn check_param(&mut self, cx: &EarlyContext<'_>, p: &ast::Param) {
+        lint_unnested_or_patterns(cx, &p.pat);
+    }
+
+    fn check_local(&mut self, cx: &EarlyContext<'_>, l: &ast::Local) {
+        lint_unnested_or_patterns(cx, &l.pat);
+    }
+}
+
+fn lint_unnested_or_patterns(cx: &EarlyContext<'_>, pat: &Pat) {
+    if !cx.sess.opts.unstable_features.is_nightly_build() {
+        // User cannot do `#![feature(or_patterns)]`, so bail.
+        return;
+    }
+
+    if let Ident(.., None) | Lit(_) | Wild | Path(..) | Range(..) | Rest | MacCall(_) = pat.kind {
+        // This is a leaf pattern, so cloning is unprofitable.
+        return;
+    }
+
+    let mut pat = P(pat.clone());
+
+    // Nix all the paren patterns everywhere so that they aren't in our way.
+    remove_all_parens(&mut pat);
+
+    // Transform all unnested or-patterns into nested ones, and if there were none, quit.
+    if !unnest_or_patterns(&mut pat) {
+        return;
+    }
+
+    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,
+        );
+    });
+}
+
+/// Remove all `(p)` patterns in `pat`.
+fn remove_all_parens(pat: &mut P<Pat>) {
+    struct Visitor;
+    impl MutVisitor for Visitor {
+        fn visit_pat(&mut self, pat: &mut P<Pat>) {
+            noop_visit_pat(pat, self);
+            let inner = match &mut pat.kind {
+                Paren(i) => mem::replace(&mut i.kind, Wild),
+                _ => return,
+            };
+            pat.kind = inner;
+        }
+    }
+    Visitor.visit_pat(pat);
+}
+
+/// Insert parens where necessary according to Rust's precedence rules for patterns.
+fn insert_necessary_parens(pat: &mut P<Pat>) {
+    struct Visitor;
+    impl MutVisitor for Visitor {
+        fn visit_pat(&mut self, pat: &mut P<Pat>) {
+            use ast::{BindingMode::*, Mutability::*};
+            noop_visit_pat(pat, self);
+            let target = match &mut pat.kind {
+                // `i @ a | b`, `box a | b`, and `& mut? a | b`.
+                Ident(.., Some(p)) | Box(p) | Ref(p, _) if matches!(&p.kind, Or(ps) if ps.len() > 1) => p,
+                Ref(p, Not) if matches!(p.kind, Ident(ByValue(Mut), ..)) => p, // `&(mut x)`
+                _ => return,
+            };
+            target.kind = Paren(P(take_pat(target)));
+        }
+    }
+    Visitor.visit_pat(pat);
+}
+
+/// Unnest or-patterns `p0 | ... | p1` in the pattern `pat`.
+/// For example, this would transform `Some(0) | FOO | Some(2)` into `Some(0 | 2) | FOO`.
+fn unnest_or_patterns(pat: &mut P<Pat>) -> bool {
+    struct Visitor {
+        changed: bool,
+    }
+    impl MutVisitor for Visitor {
+        fn visit_pat(&mut self, p: &mut P<Pat>) {
+            // This is a bottom up transformation, so recurse first.
+            noop_visit_pat(p, self);
+
+            // Don't have an or-pattern? Just quit early on.
+            let alternatives = match &mut p.kind {
+                Or(ps) => ps,
+                _ => return,
+            };
+
+            // Collapse or-patterns directly nested in or-patterns.
+            let mut idx = 0;
+            let mut this_level_changed = false;
+            while idx < alternatives.len() {
+                let inner = if let Or(ps) = &mut alternatives[idx].kind {
+                    mem::take(ps)
+                } else {
+                    idx += 1;
+                    continue;
+                };
+                this_level_changed = true;
+                alternatives.splice(idx..=idx, inner);
+            }
+
+            // Focus on `p_n` and then try to transform all `p_i` where `i > n`.
+            let mut focus_idx = 0;
+            while focus_idx < alternatives.len() {
+                this_level_changed |= transform_with_focus_on_idx(alternatives, focus_idx);
+                focus_idx += 1;
+            }
+            self.changed |= this_level_changed;
+
+            // Deal with `Some(Some(0)) | Some(Some(1))`.
+            if this_level_changed {
+                noop_visit_pat(p, self);
+            }
+        }
+    }
+
+    let mut visitor = Visitor { changed: false };
+    visitor.visit_pat(pat);
+    visitor.changed
+}
+
+/// Match `$scrutinee` against `$pat` and extract `$then` from it.
+/// Panics if there is no match.
+macro_rules! always_pat {
+    ($scrutinee:expr, $pat:pat => $then:expr) => {
+        match $scrutinee {
+            $pat => $then,
+            _ => unreachable!(),
+        }
+    };
+}
+
+/// Focus on `focus_idx` in `alternatives`,
+/// attempting to extend it with elements of the same constructor `C`
+/// in `alternatives[focus_idx + 1..]`.
+fn transform_with_focus_on_idx(alternatives: &mut Vec<P<Pat>>, focus_idx: usize) -> bool {
+    // Extract the kind; we'll need to make some changes in it.
+    let mut focus_kind = mem::replace(&mut alternatives[focus_idx].kind, PatKind::Wild);
+    // We'll focus on `alternatives[focus_idx]`,
+    // so we're draining from `alternatives[focus_idx + 1..]`.
+    let start = focus_idx + 1;
+
+    // We're trying to find whatever kind (~"constructor") we found in `alternatives[start..]`.
+    let changed = match &mut focus_kind {
+        // These pattern forms are "leafs" and do not have sub-patterns.
+        // Therefore they are not some form of constructor `C`,
+        // with which a pattern `C(P0)` may be formed,
+        // which we would want to join with other `C(Pj)`s.
+        Ident(.., None) | Lit(_) | Wild | Path(..) | Range(..) | Rest | MacCall(_)
+        // Dealt with elsewhere.
+        | Or(_) | Paren(_) => false,
+        // Transform `box x | ... | box y` into `box (x | y)`.
+        //
+        // The cases below until `Slice(...)` deal *singleton* products.
+        // These patterns have the shape `C(p)`, and not e.g., `C(p0, ..., pn)`.
+        Box(target) => extend_with_matching(
+            target, start, alternatives,
+            |k| matches!(k, Box(_)),
+            |k| always_pat!(k, Box(p) => p),
+        ),
+        // Transform `&m x | ... | &m y` into `&m (x, y)`.
+        Ref(target, m1) => extend_with_matching(
+            target, start, alternatives,
+            |k| matches!(k, Ref(_, m2) if m1 == m2), // Mutabilities must match.
+            |k| always_pat!(k, Ref(p, _) => p),
+        ),
+        // Transform `b @ p0 | ... b @ p1` into `b @ (p0 | p1)`.
+        Ident(b1, i1, Some(target)) => extend_with_matching(
+            target, start, alternatives,
+            // Binding names must match.
+            |k| matches!(k, Ident(b2, i2, Some(_)) if b1 == b2 && eq_id(*i1, *i2)),
+            |k| always_pat!(k, Ident(_, _, Some(p)) => p),
+        ),
+        // Transform `[pre, x, post] | ... | [pre, y, post]` into `[pre, x | y, post]`.
+        Slice(ps1) => extend_with_matching_product(
+            ps1, start, alternatives,
+            |k, ps1, idx| matches!(k, Slice(ps2) if eq_pre_post(ps1, ps2, idx)),
+            |k| always_pat!(k, Slice(ps) => ps),
+        ),
+        // Transform `(pre, x, post) | ... | (pre, y, post)` into `(pre, x | y, post]`.
+        Tuple(ps1) => extend_with_matching_product(
+            ps1, start, alternatives,
+            |k, ps1, idx| matches!(k, Tuple(ps2) if eq_pre_post(ps1, ps2, idx)),
+            |k| always_pat!(k, Tuple(ps) => ps),
+        ),
+        // Transform `S(pre, x, post) | ... | S(pre, y, post)` into `S(pre, x | y, post]`.
+        TupleStruct(path1, ps1) => extend_with_matching_product(
+            ps1, start, alternatives,
+            |k, ps1, idx| matches!(
+                k,
+                TupleStruct(path2, ps2) if eq_path(path1, path2) && eq_pre_post(ps1, ps2, idx)
+            ),
+            |k| always_pat!(k, TupleStruct(_, ps) => ps),
+        ),
+        // Transform a record pattern `S { fp_0, ..., fp_n }`.
+        Struct(path1, fps1, rest1) => extend_with_struct_pat(path1, fps1, *rest1, start, alternatives),
+    };
+
+    alternatives[focus_idx].kind = focus_kind;
+    changed
+}
+
+/// Here we focusing on a record pattern `S { fp_0, ..., fp_n }`.
+/// In particular, for a record pattern, the order in which the field patterns is irrelevant.
+/// So when we fixate on some `ident_k: pat_k`, we try to find `ident_k` in the other pattern
+/// and check that all `fp_i` where `i ∈ ((0...n) \ k)` between two patterns are equal.
+fn extend_with_struct_pat(
+    path1: &ast::Path,
+    fps1: &mut Vec<ast::FieldPat>,
+    rest1: bool,
+    start: usize,
+    alternatives: &mut Vec<P<Pat>>,
+) -> bool {
+    (0..fps1.len()).any(|idx| {
+        let pos_in_2 = Cell::new(None); // The element `k`.
+        let tail_or = drain_matching(
+            start,
+            alternatives,
+            |k| {
+                matches!(k, Struct(path2, fps2, rest2)
+                if rest1 == *rest2 // If one struct pattern has `..` so must the other.
+                && eq_path(path1, path2)
+                && fps1.len() == fps2.len()
+                && fps1.iter().enumerate().all(|(idx_1, fp1)| {
+                    if idx_1 == idx {
+                        // In the case of `k`, we merely require identical field names
+                        // so that we will transform into `ident_k: p1_k | p2_k`.
+                        let pos = fps2.iter().position(|fp2| eq_id(fp1.ident, fp2.ident));
+                        pos_in_2.set(pos);
+                        pos.is_some()
+                    } else {
+                        fps2.iter().any(|fp2| eq_field_pat(fp1, fp2))
+                    }
+                }))
+            },
+            // Extract `p2_k`.
+            |k| always_pat!(k, Struct(_, mut fps, _) => fps.swap_remove(pos_in_2.take().unwrap()).pat),
+        );
+        extend_with_tail_or(&mut fps1[idx].pat, tail_or)
+    })
+}
+
+/// Like `extend_with_matching` but for products with > 1 factor, e.g., `C(p_0, ..., p_n)`.
+/// Here, the idea is that we fixate on some `p_k` in `C`,
+/// allowing it to vary between two `targets` and `ps2` (returned by `extract`),
+/// while also requiring `ps1[..n] ~ ps2[..n]` (pre) and `ps1[n + 1..] ~ ps2[n + 1..]` (post),
+/// where `~` denotes semantic equality.
+fn extend_with_matching_product(
+    targets: &mut Vec<P<Pat>>,
+    start: usize,
+    alternatives: &mut Vec<P<Pat>>,
+    predicate: impl Fn(&PatKind, &[P<Pat>], usize) -> bool,
+    extract: impl Fn(PatKind) -> Vec<P<Pat>>,
+) -> bool {
+    (0..targets.len()).any(|idx| {
+        let tail_or = drain_matching(
+            start,
+            alternatives,
+            |k| predicate(k, targets, idx),
+            |k| extract(k).swap_remove(idx),
+        );
+        extend_with_tail_or(&mut targets[idx], tail_or)
+    })
+}
+
+/// Extract the pattern from the given one and replace it with `Wild`.
+/// This is meant for temporarily swapping out the pattern for manipulation.
+fn take_pat(from: &mut Pat) -> Pat {
+    let dummy = Pat {
+        id: DUMMY_NODE_ID,
+        kind: Wild,
+        span: DUMMY_SP,
+    };
+    mem::replace(from, dummy)
+}
+
+/// Extend `target` as an or-pattern with the alternatives
+/// in `tail_or` if there are any and return if there were.
+fn extend_with_tail_or(target: &mut Pat, tail_or: Vec<P<Pat>>) -> bool {
+    fn extend(target: &mut Pat, mut tail_or: Vec<P<Pat>>) {
+        match target {
+            // On an existing or-pattern in the target, append to it.
+            Pat { kind: Or(ps), .. } => ps.append(&mut tail_or),
+            // Otherwise convert the target to an or-pattern.
+            target => {
+                let mut init_or = vec![P(take_pat(target))];
+                init_or.append(&mut tail_or);
+                target.kind = Or(init_or);
+            },
+        }
+    }
+
+    let changed = !tail_or.is_empty();
+    if changed {
+        // Extend the target.
+        extend(target, tail_or);
+    }
+    changed
+}
+
+// Extract all inner patterns in `alternatives` matching our `predicate`.
+// Only elements beginning with `start` are considered for extraction.
+fn drain_matching(
+    start: usize,
+    alternatives: &mut Vec<P<Pat>>,
+    predicate: impl Fn(&PatKind) -> bool,
+    extract: impl Fn(PatKind) -> P<Pat>,
+) -> Vec<P<Pat>> {
+    let mut tail_or = vec![];
+    let mut idx = 0;
+    for pat in alternatives.drain_filter(|p| {
+        // Check if we should extract, but only if `idx >= start`.
+        idx += 1;
+        idx > start && predicate(&p.kind)
+    }) {
+        tail_or.push(extract(pat.into_inner().kind));
+    }
+    tail_or
+}
+
+fn extend_with_matching(
+    target: &mut Pat,
+    start: usize,
+    alternatives: &mut Vec<P<Pat>>,
+    predicate: impl Fn(&PatKind) -> bool,
+    extract: impl Fn(PatKind) -> P<Pat>,
+) -> bool {
+    extend_with_tail_or(target, drain_matching(start, alternatives, predicate, extract))
+}
+
+/// Are the patterns in `ps1` and `ps2` equal save for `ps1[idx]` compared to `ps2[idx]`?
+fn eq_pre_post(ps1: &[P<Pat>], ps2: &[P<Pat>], idx: usize) -> bool {
+    ps1[idx].is_rest() == ps2[idx].is_rest() // Avoid `[x, ..] | [x, 0]` => `[x, .. | 0]`.
+        && ps1.len() == ps2.len()
+        && over(&ps1[..idx], &ps2[..idx], |l, r| eq_pat(l, r))
+        && over(&ps1[idx + 1..], &ps2[idx + 1..], |l, r| eq_pat(l, r))
+}
diff --git a/clippy_lints/src/utils/ast_utils.rs b/clippy_lints/src/utils/ast_utils.rs
new file mode 100755
index 00000000000..69a7b6c051e
--- /dev/null
+++ b/clippy_lints/src/utils/ast_utils.rs
@@ -0,0 +1,525 @@
+//! Utilities for manipulating and extracting information from `rustc_ast::ast`.
+//!
+//! - The `eq_foobar` functions test for semantic equality but ignores `NodeId`s and `Span`s.
+
+#![allow(clippy::similar_names, clippy::wildcard_imports, clippy::enum_glob_use)]
+
+use crate::utils::{both, over};
+use rustc_ast::ast::{self, *};
+use rustc_ast::ptr::P;
+use std::mem;
+
+/// Checks if each element in the first slice is contained within the latter as per `eq_fn`.
+pub fn unordered_over<X>(left: &[X], right: &[X], mut eq_fn: impl FnMut(&X, &X) -> bool) -> bool {
+    left.len() == right.len() && left.iter().all(|l| right.iter().any(|r| eq_fn(l, r)))
+}
+
+pub fn eq_id(l: Ident, r: Ident) -> bool {
+    l.name == r.name
+}
+
+pub fn eq_pat(l: &Pat, r: &Pat) -> bool {
+    use PatKind::*;
+    match (&l.kind, &r.kind) {
+        (Paren(l), _) => eq_pat(l, r),
+        (_, Paren(r)) => eq_pat(l, r),
+        (Wild, Wild) | (Rest, Rest) => true,
+        (Lit(l), Lit(r)) => eq_expr(l, r),
+        (Ident(b1, i1, s1), Ident(b2, i2, s2)) => b1 == b2 && eq_id(*i1, *i2) && both(s1, s2, |l, r| eq_pat(l, r)),
+        (Range(lf, lt, le), Range(rf, rt, re)) => {
+            eq_expr_opt(lf, rf) && eq_expr_opt(lt, rt) && eq_range_end(&le.node, &re.node)
+        },
+        (Box(l), Box(r))
+        | (Ref(l, Mutability::Not), Ref(r, Mutability::Not))
+        | (Ref(l, Mutability::Mut), Ref(r, Mutability::Mut)) => eq_pat(l, r),
+        (Tuple(l), Tuple(r)) | (Slice(l), Slice(r)) => over(l, r, |l, r| eq_pat(l, r)),
+        (Path(lq, lp), Path(rq, rp)) => both(lq, rq, |l, r| eq_qself(l, r)) && eq_path(lp, rp),
+        (TupleStruct(lp, lfs), TupleStruct(rp, rfs)) => eq_path(lp, rp) && over(lfs, rfs, |l, r| eq_pat(l, r)),
+        (Struct(lp, lfs, lr), Struct(rp, rfs, rr)) => {
+            lr == rr && eq_path(lp, rp) && unordered_over(lfs, rfs, |lf, rf| eq_field_pat(lf, rf))
+        },
+        (Or(ls), Or(rs)) => unordered_over(ls, rs, |l, r| eq_pat(l, r)),
+        (MacCall(l), MacCall(r)) => eq_mac_call(l, r),
+        _ => false,
+    }
+}
+
+pub fn eq_range_end(l: &RangeEnd, r: &RangeEnd) -> bool {
+    match (l, r) {
+        (RangeEnd::Excluded, RangeEnd::Excluded) => true,
+        (RangeEnd::Included(l), RangeEnd::Included(r)) => {
+            matches!(l, RangeSyntax::DotDotEq) == matches!(r, RangeSyntax::DotDotEq)
+        },
+        _ => false,
+    }
+}
+
+pub fn eq_field_pat(l: &FieldPat, r: &FieldPat) -> bool {
+    l.is_placeholder == r.is_placeholder
+        && eq_id(l.ident, r.ident)
+        && eq_pat(&l.pat, &r.pat)
+        && over(&l.attrs, &r.attrs, |l, r| eq_attr(l, r))
+}
+
+pub fn eq_qself(l: &QSelf, r: &QSelf) -> bool {
+    l.position == r.position && eq_ty(&l.ty, &r.ty)
+}
+
+pub fn eq_path(l: &Path, r: &Path) -> bool {
+    over(&l.segments, &r.segments, |l, r| eq_path_seg(l, r))
+}
+
+pub fn eq_path_seg(l: &PathSegment, r: &PathSegment) -> bool {
+    eq_id(l.ident, r.ident) && both(&l.args, &r.args, |l, r| eq_generic_args(l, r))
+}
+
+pub fn eq_generic_args(l: &GenericArgs, r: &GenericArgs) -> bool {
+    match (l, r) {
+        (GenericArgs::AngleBracketed(l), GenericArgs::AngleBracketed(r)) => {
+            over(&l.args, &r.args, |l, r| eq_angle_arg(l, r))
+        },
+        (GenericArgs::Parenthesized(l), GenericArgs::Parenthesized(r)) => {
+            over(&l.inputs, &r.inputs, |l, r| eq_ty(l, r)) && eq_fn_ret_ty(&l.output, &r.output)
+        },
+        _ => false,
+    }
+}
+
+pub fn eq_angle_arg(l: &AngleBracketedArg, r: &AngleBracketedArg) -> bool {
+    match (l, r) {
+        (AngleBracketedArg::Arg(l), AngleBracketedArg::Arg(r)) => eq_generic_arg(l, r),
+        (AngleBracketedArg::Constraint(l), AngleBracketedArg::Constraint(r)) => eq_assoc_constraint(l, r),
+        _ => false,
+    }
+}
+
+pub fn eq_generic_arg(l: &GenericArg, r: &GenericArg) -> bool {
+    match (l, r) {
+        (GenericArg::Lifetime(l), GenericArg::Lifetime(r)) => eq_id(l.ident, r.ident),
+        (GenericArg::Type(l), GenericArg::Type(r)) => eq_ty(l, r),
+        (GenericArg::Const(l), GenericArg::Const(r)) => eq_expr(&l.value, &r.value),
+        _ => false,
+    }
+}
+
+pub fn eq_expr_opt(l: &Option<P<Expr>>, r: &Option<P<Expr>>) -> bool {
+    both(l, r, |l, r| eq_expr(l, r))
+}
+
+pub fn eq_expr(l: &Expr, r: &Expr) -> bool {
+    use ExprKind::*;
+    if !over(&l.attrs, &r.attrs, |l, r| eq_attr(l, r)) {
+        return false;
+    }
+    match (&l.kind, &r.kind) {
+        (Paren(l), _) => eq_expr(l, r),
+        (_, Paren(r)) => eq_expr(l, r),
+        (Err, Err) => true,
+        (Box(l), Box(r)) | (Try(l), Try(r)) | (Await(l), Await(r)) => eq_expr(l, r),
+        (Array(l), Array(r)) | (Tup(l), Tup(r)) => over(l, r, |l, r| eq_expr(l, r)),
+        (Repeat(le, ls), Repeat(re, rs)) => eq_expr(le, re) && eq_expr(&ls.value, &rs.value),
+        (Call(lc, la), Call(rc, ra)) => eq_expr(lc, rc) && over(la, ra, |l, r| eq_expr(l, r)),
+        (MethodCall(lc, la), MethodCall(rc, ra)) => eq_path_seg(lc, rc) && over(la, ra, |l, r| eq_expr(l, r)),
+        (Binary(lo, ll, lr), Binary(ro, rl, rr)) => lo.node == ro.node && eq_expr(ll, rl) && eq_expr(lr, rr),
+        (Unary(lo, l), Unary(ro, r)) => mem::discriminant(lo) == mem::discriminant(ro) && eq_expr(l, r),
+        (Lit(l), Lit(r)) => l.kind == r.kind,
+        (Cast(l, lt), Cast(r, rt)) | (Type(l, lt), Type(r, rt)) => eq_expr(l, r) && eq_ty(lt, rt),
+        (Let(lp, le), Let(rp, re)) => eq_pat(lp, rp) && eq_expr(le, re),
+        (If(lc, lt, le), If(rc, rt, re)) => eq_expr(lc, rc) && eq_block(lt, rt) && eq_expr_opt(le, re),
+        (While(lc, lt, ll), While(rc, rt, rl)) => eq_label(ll, rl) && eq_expr(lc, rc) && eq_block(lt, rt),
+        (ForLoop(lp, li, lt, ll), ForLoop(rp, ri, rt, rl)) => {
+            eq_label(ll, rl) && eq_pat(lp, rp) && eq_expr(li, ri) && eq_block(lt, rt)
+        },
+        (Loop(lt, ll), Loop(rt, rl)) => eq_label(ll, rl) && eq_block(lt, rt),
+        (Block(lb, ll), Block(rb, rl)) => eq_label(ll, rl) && eq_block(lb, rb),
+        (TryBlock(l), TryBlock(r)) => eq_block(l, r),
+        (Yield(l), Yield(r)) | (Ret(l), Ret(r)) => eq_expr_opt(l, r),
+        (Break(ll, le), Break(rl, re)) => eq_label(ll, rl) && eq_expr_opt(le, re),
+        (Continue(ll), Continue(rl)) => eq_label(ll, rl),
+        (Assign(l1, l2, _), Assign(r1, r2, _)) | (Index(l1, l2), Index(r1, r2)) => eq_expr(l1, r1) && eq_expr(l2, r2),
+        (AssignOp(lo, lp, lv), AssignOp(ro, rp, rv)) => lo.node == ro.node && eq_expr(lp, rp) && eq_expr(lv, rv),
+        (Field(lp, lf), Field(rp, rf)) => eq_id(*lf, *rf) && eq_expr(lp, rp),
+        (Match(ls, la), Match(rs, ra)) => eq_expr(ls, rs) && over(la, ra, |l, r| eq_arm(l, r)),
+        (Closure(lc, la, lm, lf, lb, _), Closure(rc, ra, rm, rf, rb, _)) => {
+            lc == rc && la.is_async() == ra.is_async() && lm == rm && eq_fn_decl(lf, rf) && eq_expr(lb, rb)
+        },
+        (Async(lc, _, lb), Async(rc, _, rb)) => lc == rc && eq_block(lb, rb),
+        (Range(lf, lt, ll), Range(rf, rt, rl)) => ll == rl && eq_expr_opt(lf, rf) && eq_expr_opt(lt, rt),
+        (AddrOf(lbk, lm, le), AddrOf(rbk, rm, re)) => lbk == rbk && lm == rm && eq_expr(le, re),
+        (Path(lq, lp), Path(rq, rp)) => both(lq, rq, |l, r| eq_qself(l, r)) && eq_path(lp, rp),
+        (MacCall(l), MacCall(r)) => eq_mac_call(l, r),
+        (Struct(lp, lfs, lb), Struct(rp, rfs, rb)) => {
+            eq_path(lp, rp) && eq_expr_opt(lb, rb) && unordered_over(lfs, rfs, |l, r| eq_field(l, r))
+        },
+        _ => false,
+    }
+}
+
+pub fn eq_field(l: &Field, r: &Field) -> bool {
+    l.is_placeholder == r.is_placeholder
+        && eq_id(l.ident, r.ident)
+        && eq_expr(&l.expr, &r.expr)
+        && over(&l.attrs, &r.attrs, |l, r| eq_attr(l, r))
+}
+
+pub fn eq_arm(l: &Arm, r: &Arm) -> bool {
+    l.is_placeholder == r.is_placeholder
+        && eq_pat(&l.pat, &r.pat)
+        && eq_expr(&l.body, &r.body)
+        && eq_expr_opt(&l.guard, &r.guard)
+        && over(&l.attrs, &r.attrs, |l, r| eq_attr(l, r))
+}
+
+pub fn eq_label(l: &Option<Label>, r: &Option<Label>) -> bool {
+    both(l, r, |l, r| eq_id(l.ident, r.ident))
+}
+
+pub fn eq_block(l: &Block, r: &Block) -> bool {
+    l.rules == r.rules && over(&l.stmts, &r.stmts, |l, r| eq_stmt(l, r))
+}
+
+pub fn eq_stmt(l: &Stmt, r: &Stmt) -> bool {
+    use StmtKind::*;
+    match (&l.kind, &r.kind) {
+        (Local(l), Local(r)) => {
+            eq_pat(&l.pat, &r.pat)
+                && both(&l.ty, &r.ty, |l, r| eq_ty(l, r))
+                && eq_expr_opt(&l.init, &r.init)
+                && over(&l.attrs, &r.attrs, |l, r| eq_attr(l, r))
+        },
+        (Item(l), Item(r)) => eq_item(l, r, eq_item_kind),
+        (Expr(l), Expr(r)) | (Semi(l), Semi(r)) => eq_expr(l, r),
+        (Empty, Empty) => true,
+        (MacCall(l), MacCall(r)) => l.1 == r.1 && eq_mac_call(&l.0, &r.0) && over(&l.2, &r.2, |l, r| eq_attr(l, r)),
+        _ => false,
+    }
+}
+
+pub fn eq_item<K>(l: &Item<K>, r: &Item<K>, mut eq_kind: impl FnMut(&K, &K) -> bool) -> bool {
+    eq_id(l.ident, r.ident)
+        && over(&l.attrs, &r.attrs, |l, r| eq_attr(l, r))
+        && eq_vis(&l.vis, &r.vis)
+        && eq_kind(&l.kind, &r.kind)
+}
+
+pub fn eq_item_kind(l: &ItemKind, r: &ItemKind) -> bool {
+    use ItemKind::*;
+    match (l, r) {
+        (ExternCrate(l), ExternCrate(r)) => l == r,
+        (Use(l), Use(r)) => eq_use_tree(l, r),
+        (Static(lt, lm, le), Static(rt, rm, re)) => lm == rm && eq_ty(lt, rt) && eq_expr_opt(le, re),
+        (Const(ld, lt, le), Const(rd, rt, re)) => eq_defaultness(*ld, *rd) && eq_ty(lt, rt) && eq_expr_opt(le, re),
+        (Fn(ld, lf, lg, lb), Fn(rd, rf, rg, rb)) => {
+            eq_defaultness(*ld, *rd) && eq_fn_sig(lf, rf) && eq_generics(lg, rg) && both(lb, rb, |l, r| eq_block(l, r))
+        },
+        (Mod(l), Mod(r)) => l.inline == r.inline && over(&l.items, &r.items, |l, r| eq_item(l, r, eq_item_kind)),
+        (ForeignMod(l), ForeignMod(r)) => {
+            both(&l.abi, &r.abi, |l, r| eq_str_lit(l, r))
+                && over(&l.items, &r.items, |l, r| eq_item(l, r, eq_foreign_item_kind))
+        },
+        (TyAlias(ld, lg, lb, lt), TyAlias(rd, rg, rb, rt)) => {
+            eq_defaultness(*ld, *rd)
+                && eq_generics(lg, rg)
+                && over(lb, rb, |l, r| eq_generic_bound(l, r))
+                && both(lt, rt, |l, r| eq_ty(l, r))
+        },
+        (Enum(le, lg), Enum(re, rg)) => {
+            over(&le.variants, &re.variants, |l, r| eq_variant(l, r)) && eq_generics(lg, rg)
+        },
+        (Struct(lv, lg), Struct(rv, rg)) | (Union(lv, lg), Union(rv, rg)) => {
+            eq_variant_data(lv, rv) && eq_generics(lg, rg)
+        },
+        (Trait(la, lu, lg, lb, li), Trait(ra, ru, rg, rb, ri)) => {
+            la == ra
+                && matches!(lu, Unsafe::No) == matches!(ru, Unsafe::No)
+                && eq_generics(lg, rg)
+                && over(lb, rb, |l, r| eq_generic_bound(l, r))
+                && over(li, ri, |l, r| eq_item(l, r, eq_assoc_item_kind))
+        },
+        (TraitAlias(lg, lb), TraitAlias(rg, rb)) => eq_generics(lg, rg) && over(lb, rb, |l, r| eq_generic_bound(l, r)),
+        (
+            Impl {
+                unsafety: lu,
+                polarity: lp,
+                defaultness: ld,
+                constness: lc,
+                generics: lg,
+                of_trait: lot,
+                self_ty: lst,
+                items: li,
+            },
+            Impl {
+                unsafety: ru,
+                polarity: rp,
+                defaultness: rd,
+                constness: rc,
+                generics: rg,
+                of_trait: rot,
+                self_ty: rst,
+                items: ri,
+            },
+        ) => {
+            matches!(lu, Unsafe::No) == matches!(ru, Unsafe::No)
+                && matches!(lp, ImplPolarity::Positive) == matches!(rp, ImplPolarity::Positive)
+                && eq_defaultness(*ld, *rd)
+                && matches!(lc, ast::Const::No) == matches!(rc, ast::Const::No)
+                && eq_generics(lg, rg)
+                && both(lot, rot, |l, r| eq_path(&l.path, &r.path))
+                && eq_ty(lst, rst)
+                && over(li, ri, |l, r| eq_item(l, r, eq_assoc_item_kind))
+        },
+        (MacCall(l), MacCall(r)) => eq_mac_call(l, r),
+        (MacroDef(l), MacroDef(r)) => l.macro_rules == r.macro_rules && eq_mac_args(&l.body, &r.body),
+        _ => false,
+    }
+}
+
+pub fn eq_foreign_item_kind(l: &ForeignItemKind, r: &ForeignItemKind) -> bool {
+    use ForeignItemKind::*;
+    match (l, r) {
+        (Static(lt, lm, le), Static(rt, rm, re)) => lm == rm && eq_ty(lt, rt) && eq_expr_opt(le, re),
+        (Fn(ld, lf, lg, lb), Fn(rd, rf, rg, rb)) => {
+            eq_defaultness(*ld, *rd) && eq_fn_sig(lf, rf) && eq_generics(lg, rg) && both(lb, rb, |l, r| eq_block(l, r))
+        },
+        (TyAlias(ld, lg, lb, lt), TyAlias(rd, rg, rb, rt)) => {
+            eq_defaultness(*ld, *rd)
+                && eq_generics(lg, rg)
+                && over(lb, rb, |l, r| eq_generic_bound(l, r))
+                && both(lt, rt, |l, r| eq_ty(l, r))
+        },
+        (MacCall(l), MacCall(r)) => eq_mac_call(l, r),
+        _ => false,
+    }
+}
+
+pub fn eq_assoc_item_kind(l: &AssocItemKind, r: &AssocItemKind) -> bool {
+    use AssocItemKind::*;
+    match (l, r) {
+        (Const(ld, lt, le), Const(rd, rt, re)) => eq_defaultness(*ld, *rd) && eq_ty(lt, rt) && eq_expr_opt(le, re),
+        (Fn(ld, lf, lg, lb), Fn(rd, rf, rg, rb)) => {
+            eq_defaultness(*ld, *rd) && eq_fn_sig(lf, rf) && eq_generics(lg, rg) && both(lb, rb, |l, r| eq_block(l, r))
+        },
+        (TyAlias(ld, lg, lb, lt), TyAlias(rd, rg, rb, rt)) => {
+            eq_defaultness(*ld, *rd)
+                && eq_generics(lg, rg)
+                && over(lb, rb, |l, r| eq_generic_bound(l, r))
+                && both(lt, rt, |l, r| eq_ty(l, r))
+        },
+        (MacCall(l), MacCall(r)) => eq_mac_call(l, r),
+        _ => false,
+    }
+}
+
+pub fn eq_variant(l: &Variant, r: &Variant) -> bool {
+    l.is_placeholder == r.is_placeholder
+        && over(&l.attrs, &r.attrs, |l, r| eq_attr(l, r))
+        && eq_vis(&l.vis, &r.vis)
+        && eq_id(l.ident, r.ident)
+        && eq_variant_data(&l.data, &r.data)
+        && both(&l.disr_expr, &r.disr_expr, |l, r| eq_expr(&l.value, &r.value))
+}
+
+pub fn eq_variant_data(l: &VariantData, r: &VariantData) -> bool {
+    use VariantData::*;
+    match (l, r) {
+        (Unit(_), Unit(_)) => true,
+        (Struct(l, _), Struct(r, _)) | (Tuple(l, _), Tuple(r, _)) => over(l, r, |l, r| eq_struct_field(l, r)),
+        _ => false,
+    }
+}
+
+pub fn eq_struct_field(l: &StructField, r: &StructField) -> bool {
+    l.is_placeholder == r.is_placeholder
+        && over(&l.attrs, &r.attrs, |l, r| eq_attr(l, r))
+        && eq_vis(&l.vis, &r.vis)
+        && both(&l.ident, &r.ident, |l, r| eq_id(*l, *r))
+        && eq_ty(&l.ty, &r.ty)
+}
+
+pub fn eq_fn_sig(l: &FnSig, r: &FnSig) -> bool {
+    eq_fn_decl(&l.decl, &r.decl) && eq_fn_header(&l.header, &r.header)
+}
+
+pub fn eq_fn_header(l: &FnHeader, r: &FnHeader) -> bool {
+    matches!(l.unsafety, Unsafe::No) == matches!(r.unsafety, Unsafe::No)
+        && l.asyncness.is_async() == r.asyncness.is_async()
+        && matches!(l.constness, Const::No) == matches!(r.constness, Const::No)
+        && eq_ext(&l.ext, &r.ext)
+}
+
+pub fn eq_generics(l: &Generics, r: &Generics) -> bool {
+    over(&l.params, &r.params, |l, r| eq_generic_param(l, r))
+        && over(&l.where_clause.predicates, &r.where_clause.predicates, |l, r| {
+            eq_where_predicate(l, r)
+        })
+}
+
+pub fn eq_where_predicate(l: &WherePredicate, r: &WherePredicate) -> bool {
+    use WherePredicate::*;
+    match (l, r) {
+        (BoundPredicate(l), BoundPredicate(r)) => {
+            over(&l.bound_generic_params, &r.bound_generic_params, |l, r| {
+                eq_generic_param(l, r)
+            }) && eq_ty(&l.bounded_ty, &r.bounded_ty)
+                && over(&l.bounds, &r.bounds, |l, r| eq_generic_bound(l, r))
+        },
+        (RegionPredicate(l), RegionPredicate(r)) => {
+            eq_id(l.lifetime.ident, r.lifetime.ident) && over(&l.bounds, &r.bounds, |l, r| eq_generic_bound(l, r))
+        },
+        (EqPredicate(l), EqPredicate(r)) => eq_ty(&l.lhs_ty, &r.lhs_ty) && eq_ty(&l.rhs_ty, &r.rhs_ty),
+        _ => false,
+    }
+}
+
+pub fn eq_use_tree(l: &UseTree, r: &UseTree) -> bool {
+    eq_path(&l.prefix, &r.prefix) && eq_use_tree_kind(&l.kind, &r.kind)
+}
+
+pub fn eq_use_tree_kind(l: &UseTreeKind, r: &UseTreeKind) -> bool {
+    use UseTreeKind::*;
+    match (l, r) {
+        (Glob, Glob) => true,
+        (Simple(l, _, _), Simple(r, _, _)) => both(l, r, |l, r| eq_id(*l, *r)),
+        (Nested(l), Nested(r)) => over(l, r, |(l, _), (r, _)| eq_use_tree(l, r)),
+        _ => false,
+    }
+}
+
+pub fn eq_defaultness(l: Defaultness, r: Defaultness) -> bool {
+    match (l, r) {
+        (Defaultness::Final, Defaultness::Final) | (Defaultness::Default(_), Defaultness::Default(_)) => true,
+        _ => false,
+    }
+}
+
+pub fn eq_vis(l: &Visibility, r: &Visibility) -> bool {
+    use VisibilityKind::*;
+    match (&l.node, &r.node) {
+        (Public, Public) | (Inherited, Inherited) | (Crate(_), Crate(_)) => true,
+        (Restricted { path: l, .. }, Restricted { path: r, .. }) => eq_path(l, r),
+        _ => false,
+    }
+}
+
+pub fn eq_fn_decl(l: &FnDecl, r: &FnDecl) -> bool {
+    eq_fn_ret_ty(&l.output, &r.output)
+        && over(&l.inputs, &r.inputs, |l, r| {
+            l.is_placeholder == r.is_placeholder
+                && eq_pat(&l.pat, &r.pat)
+                && eq_ty(&l.ty, &r.ty)
+                && over(&l.attrs, &r.attrs, |l, r| eq_attr(l, r))
+        })
+}
+
+pub fn eq_fn_ret_ty(l: &FnRetTy, r: &FnRetTy) -> bool {
+    match (l, r) {
+        (FnRetTy::Default(_), FnRetTy::Default(_)) => true,
+        (FnRetTy::Ty(l), FnRetTy::Ty(r)) => eq_ty(l, r),
+        _ => false,
+    }
+}
+
+pub fn eq_ty(l: &Ty, r: &Ty) -> bool {
+    use TyKind::*;
+    match (&l.kind, &r.kind) {
+        (Paren(l), _) => eq_ty(l, r),
+        (_, Paren(r)) => eq_ty(l, r),
+        (Never, Never) | (Infer, Infer) | (ImplicitSelf, ImplicitSelf) | (Err, Err) | (CVarArgs, CVarArgs) => true,
+        (Slice(l), Slice(r)) => eq_ty(l, r),
+        (Array(le, ls), Array(re, rs)) => eq_ty(le, re) && eq_expr(&ls.value, &rs.value),
+        (Ptr(l), Ptr(r)) => l.mutbl == r.mutbl && eq_ty(&l.ty, &r.ty),
+        (Rptr(ll, l), Rptr(rl, r)) => {
+            both(ll, rl, |l, r| eq_id(l.ident, r.ident)) && l.mutbl == r.mutbl && eq_ty(&l.ty, &r.ty)
+        },
+        (BareFn(l), BareFn(r)) => {
+            l.unsafety == r.unsafety
+                && eq_ext(&l.ext, &r.ext)
+                && over(&l.generic_params, &r.generic_params, |l, r| eq_generic_param(l, r))
+                && eq_fn_decl(&l.decl, &r.decl)
+        },
+        (Tup(l), Tup(r)) => over(l, r, |l, r| eq_ty(l, r)),
+        (Path(lq, lp), Path(rq, rp)) => both(lq, rq, |l, r| eq_qself(l, r)) && eq_path(lp, rp),
+        (TraitObject(lg, ls), TraitObject(rg, rs)) => ls == rs && over(lg, rg, |l, r| eq_generic_bound(l, r)),
+        (ImplTrait(_, lg), ImplTrait(_, rg)) => over(lg, rg, |l, r| eq_generic_bound(l, r)),
+        (Typeof(l), Typeof(r)) => eq_expr(&l.value, &r.value),
+        (MacCall(l), MacCall(r)) => eq_mac_call(l, r),
+        _ => false,
+    }
+}
+
+pub fn eq_ext(l: &Extern, r: &Extern) -> bool {
+    use Extern::*;
+    match (l, r) {
+        (None, None) | (Implicit, Implicit) => true,
+        (Explicit(l), Explicit(r)) => eq_str_lit(l, r),
+        _ => false,
+    }
+}
+
+pub fn eq_str_lit(l: &StrLit, r: &StrLit) -> bool {
+    l.style == r.style && l.symbol == r.symbol && l.suffix == r.suffix
+}
+
+pub fn eq_poly_ref_trait(l: &PolyTraitRef, r: &PolyTraitRef) -> bool {
+    eq_path(&l.trait_ref.path, &r.trait_ref.path)
+        && over(&l.bound_generic_params, &r.bound_generic_params, |l, r| {
+            eq_generic_param(l, r)
+        })
+}
+
+pub fn eq_generic_param(l: &GenericParam, r: &GenericParam) -> bool {
+    use GenericParamKind::*;
+    l.is_placeholder == r.is_placeholder
+        && eq_id(l.ident, r.ident)
+        && over(&l.bounds, &r.bounds, |l, r| eq_generic_bound(l, r))
+        && match (&l.kind, &r.kind) {
+            (Lifetime, Lifetime) => true,
+            (Type { default: l }, Type { default: r }) => both(l, r, |l, r| eq_ty(l, r)),
+            (Const { ty: l }, Const { ty: r }) => eq_ty(l, r),
+            _ => false,
+        }
+        && over(&l.attrs, &r.attrs, |l, r| eq_attr(l, r))
+}
+
+pub fn eq_generic_bound(l: &GenericBound, r: &GenericBound) -> bool {
+    use GenericBound::*;
+    match (l, r) {
+        (Trait(ptr1, tbm1), Trait(ptr2, tbm2)) => tbm1 == tbm2 && eq_poly_ref_trait(ptr1, ptr2),
+        (Outlives(l), Outlives(r)) => eq_id(l.ident, r.ident),
+        _ => false,
+    }
+}
+
+pub fn eq_assoc_constraint(l: &AssocTyConstraint, r: &AssocTyConstraint) -> bool {
+    use AssocTyConstraintKind::*;
+    eq_id(l.ident, r.ident)
+        && match (&l.kind, &r.kind) {
+            (Equality { ty: l }, Equality { ty: r }) => eq_ty(l, r),
+            (Bound { bounds: l }, Bound { bounds: r }) => over(l, r, |l, r| eq_generic_bound(l, r)),
+            _ => false,
+        }
+}
+
+pub fn eq_mac_call(l: &MacCall, r: &MacCall) -> bool {
+    eq_path(&l.path, &r.path) && eq_mac_args(&l.args, &r.args)
+}
+
+pub fn eq_attr(l: &Attribute, r: &Attribute) -> bool {
+    use AttrKind::*;
+    l.style == r.style
+        && match (&l.kind, &r.kind) {
+            (DocComment(l), DocComment(r)) => l == r,
+            (Normal(l), Normal(r)) => eq_path(&l.path, &r.path) && eq_mac_args(&l.args, &r.args),
+            _ => false,
+        }
+}
+
+pub fn eq_mac_args(l: &MacArgs, r: &MacArgs) -> bool {
+    use MacArgs::*;
+    match (l, r) {
+        (Empty, Empty) => true,
+        (Delimited(_, ld, lts), Delimited(_, rd, rts)) => ld == rd && lts.eq_unspanned(rts),
+        (Eq(_, lts), Eq(_, rts)) => lts.eq_unspanned(rts),
+        _ => false,
+    }
+}
diff --git a/clippy_lints/src/utils/hir_utils.rs b/clippy_lints/src/utils/hir_utils.rs
index 92c27e79452..f8d197c15e8 100644
--- a/clippy_lints/src/utils/hir_utils.rs
+++ b/clippy_lints/src/utils/hir_utils.rs
@@ -332,19 +332,13 @@ fn swap_binop<'a>(
 
 /// Checks if the two `Option`s are both `None` or some equal values as per
 /// `eq_fn`.
-fn both<X, F>(l: &Option<X>, r: &Option<X>, mut eq_fn: F) -> bool
-where
-    F: FnMut(&X, &X) -> bool,
-{
+pub fn both<X>(l: &Option<X>, r: &Option<X>, mut eq_fn: impl FnMut(&X, &X) -> bool) -> bool {
     l.as_ref()
         .map_or_else(|| r.is_none(), |x| r.as_ref().map_or(false, |y| eq_fn(x, y)))
 }
 
 /// Checks if two slices are equal as per `eq_fn`.
-fn over<X, F>(left: &[X], right: &[X], mut eq_fn: F) -> bool
-where
-    F: FnMut(&X, &X) -> bool,
-{
+pub fn over<X>(left: &[X], right: &[X], mut eq_fn: impl FnMut(&X, &X) -> bool) -> bool {
     left.len() == right.len() && left.iter().zip(right).all(|(x, y)| eq_fn(x, y))
 }
 
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index 06638e7187b..8f8aff622f4 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -1,6 +1,7 @@
 #[macro_use]
 pub mod sym;
 
+pub mod ast_utils;
 pub mod attrs;
 pub mod author;
 pub mod camel_case;
@@ -19,7 +20,7 @@ pub mod sugg;
 pub mod usage;
 pub use self::attrs::*;
 pub use self::diagnostics::*;
-pub use self::hir_utils::{SpanlessEq, SpanlessHash};
+pub use self::hir_utils::{both, over, SpanlessEq, SpanlessHash};
 
 use std::borrow::Cow;
 use std::mem;
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index d5d07ccb2eb..745d543a4cc 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -2327,6 +2327,13 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
         deprecation: None,
         module: "misc_early",
     },
+    Lint {
+        name: "unnested_or_patterns",
+        group: "complexity",
+        desc: "unnested or-patterns, e.g., `Foo(Bar) | Foo(Baz) instead of `Foo(Bar | Baz)`",
+        deprecation: None,
+        module: "unnested_or_patterns",
+    },
     Lint {
         name: "unreachable",
         group: "restriction",
diff --git a/tests/ui/neg_cmp_op_on_partial_ord.rs b/tests/ui/neg_cmp_op_on_partial_ord.rs
index 856a430ba2b..ca70e3b7148 100644
--- a/tests/ui/neg_cmp_op_on_partial_ord.rs
+++ b/tests/ui/neg_cmp_op_on_partial_ord.rs
@@ -4,6 +4,7 @@
 
 use std::cmp::Ordering;
 
+#[allow(clippy::unnested_or_patterns)]
 #[warn(clippy::neg_cmp_op_on_partial_ord)]
 fn main() {
     let a_value = 1.0;
diff --git a/tests/ui/neg_cmp_op_on_partial_ord.stderr b/tests/ui/neg_cmp_op_on_partial_ord.stderr
index d05fd34ce33..8c5d548222e 100644
--- a/tests/ui/neg_cmp_op_on_partial_ord.stderr
+++ b/tests/ui/neg_cmp_op_on_partial_ord.stderr
@@ -1,5 +1,5 @@
 error: The use of negated comparison operators on partially ordered types produces code that is hard to read and refactor. Please consider using the `partial_cmp` method instead, to make it clear that the two values could be incomparable.
-  --> $DIR/neg_cmp_op_on_partial_ord.rs:15:21
+  --> $DIR/neg_cmp_op_on_partial_ord.rs:16:21
    |
 LL |     let _not_less = !(a_value < another_value);
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -7,19 +7,19 @@ LL |     let _not_less = !(a_value < another_value);
    = note: `-D clippy::neg-cmp-op-on-partial-ord` implied by `-D warnings`
 
 error: The use of negated comparison operators on partially ordered types produces code that is hard to read and refactor. Please consider using the `partial_cmp` method instead, to make it clear that the two values could be incomparable.
-  --> $DIR/neg_cmp_op_on_partial_ord.rs:18:30
+  --> $DIR/neg_cmp_op_on_partial_ord.rs:19:30
    |
 LL |     let _not_less_or_equal = !(a_value <= another_value);
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: The use of negated comparison operators on partially ordered types produces code that is hard to read and refactor. Please consider using the `partial_cmp` method instead, to make it clear that the two values could be incomparable.
-  --> $DIR/neg_cmp_op_on_partial_ord.rs:21:24
+  --> $DIR/neg_cmp_op_on_partial_ord.rs:22:24
    |
 LL |     let _not_greater = !(a_value > another_value);
    |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: The use of negated comparison operators on partially ordered types produces code that is hard to read and refactor. Please consider using the `partial_cmp` method instead, to make it clear that the two values could be incomparable.
-  --> $DIR/neg_cmp_op_on_partial_ord.rs:24:33
+  --> $DIR/neg_cmp_op_on_partial_ord.rs:25:33
    |
 LL |     let _not_greater_or_equal = !(a_value >= another_value);
    |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/unnested_or_patterns.fixed b/tests/ui/unnested_or_patterns.fixed
new file mode 100644
index 00000000000..e1bd5cd5562
--- /dev/null
+++ b/tests/ui/unnested_or_patterns.fixed
@@ -0,0 +1,41 @@
+// run-rustfix
+
+#![feature(or_patterns)]
+#![feature(box_patterns)]
+#![warn(clippy::unnested_or_patterns)]
+#![allow(clippy::cognitive_complexity, clippy::match_ref_pats)]
+#![allow(unreachable_patterns, irrefutable_let_patterns, unused_variables)]
+
+fn main() {
+    if let box (0 | 2) = Box::new(0) {}
+    if let box (0 | 1 | 2 | 3 | 4) = Box::new(0) {}
+    const C0: &u8 = &1;
+    if let &(0 | 2) | C0 = &0 {}
+    if let &mut (0 | 2) = &mut 0 {}
+    if let x @ (0 | 2) = 0 {}
+    if let (0, 1 | 2 | 3) = (0, 0) {}
+    if let (1 | 2 | 3, 0) = (0, 0) {}
+    if let (x, ..) | (x, 1 | 2) = (0, 1) {}
+    if let [0 | 1] = [0] {}
+    if let [x, 0 | 1] = [0, 1] {}
+    if let [x, 0 | 1 | 2] = [0, 1] {}
+    if let [x, ..] | [x, 1 | 2] = [0, 1] {}
+    struct TS(u8, u8);
+    if let TS(0 | 1, x) = TS(0, 0) {}
+    if let TS(1 | 2 | 3, 0) = TS(0, 0) {}
+    if let TS(x, ..) | TS(x, 1 | 2) = TS(0, 0) {}
+    struct S {
+        x: u8,
+        y: u8,
+    }
+    if let S { x: 0 | 1, y } = (S { x: 0, y: 1 }) {}
+    if let S { x: 0, y, .. } | S { y, x: 1 } = (S { x: 0, y: 1 }) {}
+    if let Some(Some(0 | 1)) = None {}
+    if let Some(Some(0 | 1 | 2)) = None {}
+    if let Some(Some(0 | 1 | 2 | 3 | 4)) = None {}
+    if let Some(Some(0 | 1 | 2)) = None {}
+    if let ((0 | 1 | 2,),) = ((0,),) {}
+    if let 0 | 1 | 2 = 0 {}
+    if let box (0 | 1 | 2 | 3 | 4) = Box::new(0) {}
+    if let box box (0 | 2 | 4) = Box::new(Box::new(0)) {}
+}
diff --git a/tests/ui/unnested_or_patterns.rs b/tests/ui/unnested_or_patterns.rs
new file mode 100644
index 00000000000..d5c3c1fb74a
--- /dev/null
+++ b/tests/ui/unnested_or_patterns.rs
@@ -0,0 +1,41 @@
+// run-rustfix
+
+#![feature(or_patterns)]
+#![feature(box_patterns)]
+#![warn(clippy::unnested_or_patterns)]
+#![allow(clippy::cognitive_complexity, clippy::match_ref_pats)]
+#![allow(unreachable_patterns, irrefutable_let_patterns, unused_variables)]
+
+fn main() {
+    if let box 0 | box 2 = Box::new(0) {}
+    if let box ((0 | 1)) | box (2 | 3) | box 4 = Box::new(0) {}
+    const C0: &u8 = &1;
+    if let &0 | C0 | &2 = &0 {}
+    if let &mut 0 | &mut 2 = &mut 0 {}
+    if let x @ 0 | x @ 2 = 0 {}
+    if let (0, 1) | (0, 2) | (0, 3) = (0, 0) {}
+    if let (1, 0) | (2, 0) | (3, 0) = (0, 0) {}
+    if let (x, ..) | (x, 1) | (x, 2) = (0, 1) {}
+    if let [0] | [1] = [0] {}
+    if let [x, 0] | [x, 1] = [0, 1] {}
+    if let [x, 0] | [x, 1] | [x, 2] = [0, 1] {}
+    if let [x, ..] | [x, 1] | [x, 2] = [0, 1] {}
+    struct TS(u8, u8);
+    if let TS(0, x) | TS(1, x) = TS(0, 0) {}
+    if let TS(1, 0) | TS(2, 0) | TS(3, 0) = TS(0, 0) {}
+    if let TS(x, ..) | TS(x, 1) | TS(x, 2) = TS(0, 0) {}
+    struct S {
+        x: u8,
+        y: u8,
+    }
+    if let S { x: 0, y } | S { y, x: 1 } = (S { x: 0, y: 1 }) {}
+    if let S { x: 0, y, .. } | S { y, x: 1 } = (S { x: 0, y: 1 }) {}
+    if let Some(Some(0)) | Some(Some(1)) = None {}
+    if let Some(Some(0)) | Some(Some(1) | Some(2)) = None {}
+    if let Some(Some(0 | 1) | Some(2)) | Some(Some(3) | Some(4)) = None {}
+    if let Some(Some(0) | Some(1 | 2)) = None {}
+    if let ((0,),) | ((1,) | (2,),) = ((0,),) {}
+    if let 0 | (1 | 2) = 0 {}
+    if let box (0 | 1) | (box 2 | box (3 | 4)) = Box::new(0) {}
+    if let box box 0 | box (box 2 | box 4) = Box::new(Box::new(0)) {}
+}
diff --git a/tests/ui/unnested_or_patterns.stderr b/tests/ui/unnested_or_patterns.stderr
new file mode 100644
index 00000000000..d1efe274c99
--- /dev/null
+++ b/tests/ui/unnested_or_patterns.stderr
@@ -0,0 +1,267 @@
+error: unnested or-patterns
+  --> $DIR/unnested_or_patterns.rs:10:12
+   |
+LL |     if let box 0 | box 2 = Box::new(0) {}
+   |            ^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::unnested-or-patterns` implied by `-D warnings`
+help: nest the patterns
+   |
+LL |     if let box (0 | 2) = Box::new(0) {}
+   |            ^^^^^^^^^^^
+
+error: unnested or-patterns
+  --> $DIR/unnested_or_patterns.rs:11:12
+   |
+LL |     if let box ((0 | 1)) | box (2 | 3) | box 4 = Box::new(0) {}
+   |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: nest the patterns
+   |
+LL |     if let box (0 | 1 | 2 | 3 | 4) = Box::new(0) {}
+   |            ^^^^^^^^^^^^^^^^^^^^^^^
+
+error: unnested or-patterns
+  --> $DIR/unnested_or_patterns.rs:13:12
+   |
+LL |     if let &0 | C0 | &2 = &0 {}
+   |            ^^^^^^^^^^^^
+   |
+help: nest the patterns
+   |
+LL |     if let &(0 | 2) | C0 = &0 {}
+   |            ^^^^^^^^^^^^^
+
+error: unnested or-patterns
+  --> $DIR/unnested_or_patterns.rs:14:12
+   |
+LL |     if let &mut 0 | &mut 2 = &mut 0 {}
+   |            ^^^^^^^^^^^^^^^
+   |
+help: nest the patterns
+   |
+LL |     if let &mut (0 | 2) = &mut 0 {}
+   |            ^^^^^^^^^^^^
+
+error: unnested or-patterns
+  --> $DIR/unnested_or_patterns.rs:15:12
+   |
+LL |     if let x @ 0 | x @ 2 = 0 {}
+   |            ^^^^^^^^^^^^^
+   |
+help: nest the patterns
+   |
+LL |     if let x @ (0 | 2) = 0 {}
+   |            ^^^^^^^^^^^
+
+error: unnested or-patterns
+  --> $DIR/unnested_or_patterns.rs:16:12
+   |
+LL |     if let (0, 1) | (0, 2) | (0, 3) = (0, 0) {}
+   |            ^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: nest the patterns
+   |
+LL |     if let (0, 1 | 2 | 3) = (0, 0) {}
+   |            ^^^^^^^^^^^^^^
+
+error: unnested or-patterns
+  --> $DIR/unnested_or_patterns.rs:17:12
+   |
+LL |     if let (1, 0) | (2, 0) | (3, 0) = (0, 0) {}
+   |            ^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: nest the patterns
+   |
+LL |     if let (1 | 2 | 3, 0) = (0, 0) {}
+   |            ^^^^^^^^^^^^^^
+
+error: unnested or-patterns
+  --> $DIR/unnested_or_patterns.rs:18:12
+   |
+LL |     if let (x, ..) | (x, 1) | (x, 2) = (0, 1) {}
+   |            ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: nest the patterns
+   |
+LL |     if let (x, ..) | (x, 1 | 2) = (0, 1) {}
+   |            ^^^^^^^^^^^^^^^^^^^^
+
+error: unnested or-patterns
+  --> $DIR/unnested_or_patterns.rs:19:12
+   |
+LL |     if let [0] | [1] = [0] {}
+   |            ^^^^^^^^^
+   |
+help: nest the patterns
+   |
+LL |     if let [0 | 1] = [0] {}
+   |            ^^^^^^^
+
+error: unnested or-patterns
+  --> $DIR/unnested_or_patterns.rs:20:12
+   |
+LL |     if let [x, 0] | [x, 1] = [0, 1] {}
+   |            ^^^^^^^^^^^^^^^
+   |
+help: nest the patterns
+   |
+LL |     if let [x, 0 | 1] = [0, 1] {}
+   |            ^^^^^^^^^^
+
+error: unnested or-patterns
+  --> $DIR/unnested_or_patterns.rs:21:12
+   |
+LL |     if let [x, 0] | [x, 1] | [x, 2] = [0, 1] {}
+   |            ^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: nest the patterns
+   |
+LL |     if let [x, 0 | 1 | 2] = [0, 1] {}
+   |            ^^^^^^^^^^^^^^
+
+error: unnested or-patterns
+  --> $DIR/unnested_or_patterns.rs:22:12
+   |
+LL |     if let [x, ..] | [x, 1] | [x, 2] = [0, 1] {}
+   |            ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: nest the patterns
+   |
+LL |     if let [x, ..] | [x, 1 | 2] = [0, 1] {}
+   |            ^^^^^^^^^^^^^^^^^^^^
+
+error: unnested or-patterns
+  --> $DIR/unnested_or_patterns.rs:24:12
+   |
+LL |     if let TS(0, x) | TS(1, x) = TS(0, 0) {}
+   |            ^^^^^^^^^^^^^^^^^^^
+   |
+help: nest the patterns
+   |
+LL |     if let TS(0 | 1, x) = TS(0, 0) {}
+   |            ^^^^^^^^^^^^
+
+error: unnested or-patterns
+  --> $DIR/unnested_or_patterns.rs:25:12
+   |
+LL |     if let TS(1, 0) | TS(2, 0) | TS(3, 0) = TS(0, 0) {}
+   |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: nest the patterns
+   |
+LL |     if let TS(1 | 2 | 3, 0) = TS(0, 0) {}
+   |            ^^^^^^^^^^^^^^^^
+
+error: unnested or-patterns
+  --> $DIR/unnested_or_patterns.rs:26:12
+   |
+LL |     if let TS(x, ..) | TS(x, 1) | TS(x, 2) = TS(0, 0) {}
+   |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: nest the patterns
+   |
+LL |     if let TS(x, ..) | TS(x, 1 | 2) = TS(0, 0) {}
+   |            ^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: unnested or-patterns
+  --> $DIR/unnested_or_patterns.rs:31:12
+   |
+LL |     if let S { x: 0, y } | S { y, x: 1 } = (S { x: 0, y: 1 }) {}
+   |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: nest the patterns
+   |
+LL |     if let S { x: 0 | 1, y } = (S { x: 0, y: 1 }) {}
+   |            ^^^^^^^^^^^^^^^^^
+
+error: unnested or-patterns
+  --> $DIR/unnested_or_patterns.rs:33:12
+   |
+LL |     if let Some(Some(0)) | Some(Some(1)) = None {}
+   |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: nest the patterns
+   |
+LL |     if let Some(Some(0 | 1)) = None {}
+   |            ^^^^^^^^^^^^^^^^^
+
+error: unnested or-patterns
+  --> $DIR/unnested_or_patterns.rs:34:12
+   |
+LL |     if let Some(Some(0)) | Some(Some(1) | Some(2)) = None {}
+   |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: nest the patterns
+   |
+LL |     if let Some(Some(0 | 1 | 2)) = None {}
+   |            ^^^^^^^^^^^^^^^^^^^^^
+
+error: unnested or-patterns
+  --> $DIR/unnested_or_patterns.rs:35:12
+   |
+LL |     if let Some(Some(0 | 1) | Some(2)) | Some(Some(3) | Some(4)) = None {}
+   |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: nest the patterns
+   |
+LL |     if let Some(Some(0 | 1 | 2 | 3 | 4)) = None {}
+   |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: unnested or-patterns
+  --> $DIR/unnested_or_patterns.rs:36:12
+   |
+LL |     if let Some(Some(0) | Some(1 | 2)) = None {}
+   |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: nest the patterns
+   |
+LL |     if let Some(Some(0 | 1 | 2)) = None {}
+   |            ^^^^^^^^^^^^^^^^^^^^^
+
+error: unnested or-patterns
+  --> $DIR/unnested_or_patterns.rs:37:12
+   |
+LL |     if let ((0,),) | ((1,) | (2,),) = ((0,),) {}
+   |            ^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: nest the patterns
+   |
+LL |     if let ((0 | 1 | 2,),) = ((0,),) {}
+   |            ^^^^^^^^^^^^^^^
+
+error: unnested or-patterns
+  --> $DIR/unnested_or_patterns.rs:38:12
+   |
+LL |     if let 0 | (1 | 2) = 0 {}
+   |            ^^^^^^^^^^^
+   |
+help: nest the patterns
+   |
+LL |     if let 0 | 1 | 2 = 0 {}
+   |            ^^^^^^^^^
+
+error: unnested or-patterns
+  --> $DIR/unnested_or_patterns.rs:39:12
+   |
+LL |     if let box (0 | 1) | (box 2 | box (3 | 4)) = Box::new(0) {}
+   |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: nest the patterns
+   |
+LL |     if let box (0 | 1 | 2 | 3 | 4) = Box::new(0) {}
+   |            ^^^^^^^^^^^^^^^^^^^^^^^
+
+error: unnested or-patterns
+  --> $DIR/unnested_or_patterns.rs:40:12
+   |
+LL |     if let box box 0 | box (box 2 | box 4) = Box::new(Box::new(0)) {}
+   |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: nest the patterns
+   |
+LL |     if let box box (0 | 2 | 4) = Box::new(Box::new(0)) {}
+   |            ^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 24 previous errors
+
diff --git a/tests/ui/wildcard_enum_match_arm.fixed b/tests/ui/wildcard_enum_match_arm.fixed
index 2aa24ea1156..4f8754a9301 100644
--- a/tests/ui/wildcard_enum_match_arm.fixed
+++ b/tests/ui/wildcard_enum_match_arm.fixed
@@ -6,7 +6,8 @@
     unused_variables,
     dead_code,
     clippy::single_match,
-    clippy::wildcard_in_or_patterns
+    clippy::wildcard_in_or_patterns,
+    clippy::unnested_or_patterns
 )]
 
 use std::io::ErrorKind;
diff --git a/tests/ui/wildcard_enum_match_arm.rs b/tests/ui/wildcard_enum_match_arm.rs
index 07c93feaf28..5e66644ceca 100644
--- a/tests/ui/wildcard_enum_match_arm.rs
+++ b/tests/ui/wildcard_enum_match_arm.rs
@@ -6,7 +6,8 @@
     unused_variables,
     dead_code,
     clippy::single_match,
-    clippy::wildcard_in_or_patterns
+    clippy::wildcard_in_or_patterns,
+    clippy::unnested_or_patterns
 )]
 
 use std::io::ErrorKind;
diff --git a/tests/ui/wildcard_enum_match_arm.stderr b/tests/ui/wildcard_enum_match_arm.stderr
index 7151a5c5770..e03b3be43ed 100644
--- a/tests/ui/wildcard_enum_match_arm.stderr
+++ b/tests/ui/wildcard_enum_match_arm.stderr
@@ -1,5 +1,5 @@
 error: wildcard match will miss any future added variants
-  --> $DIR/wildcard_enum_match_arm.rs:37:9
+  --> $DIR/wildcard_enum_match_arm.rs:38:9
    |
 LL |         _ => eprintln!("Not red"),
    |         ^ help: try this: `Color::Green | Color::Blue | Color::Rgb(..) | Color::Cyan`
@@ -11,25 +11,25 @@ LL | #![deny(clippy::wildcard_enum_match_arm)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: wildcard match will miss any future added variants
-  --> $DIR/wildcard_enum_match_arm.rs:41:9
+  --> $DIR/wildcard_enum_match_arm.rs:42:9
    |
 LL |         _not_red => eprintln!("Not red"),
    |         ^^^^^^^^ help: try this: `_not_red @ Color::Green | _not_red @ Color::Blue | _not_red @ Color::Rgb(..) | _not_red @ Color::Cyan`
 
 error: wildcard match will miss any future added variants
-  --> $DIR/wildcard_enum_match_arm.rs:45:9
+  --> $DIR/wildcard_enum_match_arm.rs:46:9
    |
 LL |         not_red => format!("{:?}", not_red),
    |         ^^^^^^^ help: try this: `not_red @ Color::Green | not_red @ Color::Blue | not_red @ Color::Rgb(..) | not_red @ Color::Cyan`
 
 error: wildcard match will miss any future added variants
-  --> $DIR/wildcard_enum_match_arm.rs:61:9
+  --> $DIR/wildcard_enum_match_arm.rs:62:9
    |
 LL |         _ => "No red",
    |         ^ help: try this: `Color::Red | Color::Green | Color::Blue | Color::Rgb(..) | Color::Cyan`
 
 error: match on non-exhaustive enum doesn't explicitly match all known variants
-  --> $DIR/wildcard_enum_match_arm.rs:78:9
+  --> $DIR/wildcard_enum_match_arm.rs:79:9
    |
 LL |         _ => {},
    |         ^ help: try this: `std::io::ErrorKind::PermissionDenied | std::io::ErrorKind::ConnectionRefused | std::io::ErrorKind::ConnectionReset | std::io::ErrorKind::ConnectionAborted | std::io::ErrorKind::NotConnected | std::io::ErrorKind::AddrInUse | std::io::ErrorKind::AddrNotAvailable | std::io::ErrorKind::BrokenPipe | std::io::ErrorKind::AlreadyExists | std::io::ErrorKind::WouldBlock | std::io::ErrorKind::InvalidInput | std::io::ErrorKind::InvalidData | std::io::ErrorKind::TimedOut | std::io::ErrorKind::WriteZero | std::io::ErrorKind::Interrupted | std::io::ErrorKind::Other | std::io::ErrorKind::UnexpectedEof | _`
-- 
cgit 1.4.1-3-g733a5


From a664ce7789a54006cc6c01d8aefbfa4477c9d618 Mon Sep 17 00:00:00 2001
From: Eduardo Broto <ebroto@tutanota.com>
Date: Sun, 7 Jun 2020 21:13:13 +0200
Subject: Remove unnecessary lifetime parameter

---
 clippy_lints/src/ranges.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/ranges.rs b/clippy_lints/src/ranges.rs
index 45de4d29375..52e540d4e00 100644
--- a/clippy_lints/src/ranges.rs
+++ b/clippy_lints/src/ranges.rs
@@ -241,7 +241,7 @@ fn check_inclusive_range_minus_one(cx: &LateContext<'_, '_>, expr: &Expr<'_>) {
 }
 
 fn check_reversed_empty_range(cx: &LateContext<'_, '_>, expr: &Expr<'_>) {
-    fn inside_indexing_expr<'a>(cx: &'a LateContext<'_, '_>, expr: &Expr<'_>) -> bool {
+    fn inside_indexing_expr(cx: &LateContext<'_, '_>, expr: &Expr<'_>) -> bool {
         matches!(
             get_parent_expr(cx, expr),
             Some(Expr {
-- 
cgit 1.4.1-3-g733a5


From 78f158e80e3a2ec8022e6cd6b2f62b17b3e96b57 Mon Sep 17 00:00:00 2001
From: Mazdak Farrokhzad <twingoow@gmail.com>
Date: Sat, 28 Mar 2020 11:45:13 +0100
Subject: dogfood unnested_or_patterns

---
 clippy_lints/src/formatting.rs                     |  8 +---
 .../src/methods/manual_saturating_arithmetic.rs    |  2 +-
 clippy_lints/src/methods/mod.rs                    | 13 ++----
 clippy_lints/src/misc.rs                           | 19 ++++-----
 clippy_lints/src/no_effect.rs                      |  2 +-
 clippy_lints/src/suspicious_trait_impl.rs          |  6 +--
 clippy_lints/src/transmute.rs                      | 47 ++++++++++------------
 clippy_lints/src/unwrap.rs                         |  2 +-
 clippy_lints/src/utils/mod.rs                      |  9 ++---
 9 files changed, 44 insertions(+), 64 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/formatting.rs b/clippy_lints/src/formatting.rs
index eb4b7a826f2..156246fb8bb 100644
--- a/clippy_lints/src/formatting.rs
+++ b/clippy_lints/src/formatting.rs
@@ -112,12 +112,8 @@ declare_lint_pass!(Formatting => [
 impl EarlyLintPass for Formatting {
     fn check_block(&mut self, cx: &EarlyContext<'_>, block: &Block) {
         for w in block.stmts.windows(2) {
-            match (&w[0].kind, &w[1].kind) {
-                (&StmtKind::Expr(ref first), &StmtKind::Expr(ref second))
-                | (&StmtKind::Expr(ref first), &StmtKind::Semi(ref second)) => {
-                    check_missing_else(cx, first, second);
-                },
-                _ => (),
+            if let (StmtKind::Expr(first), StmtKind::Expr(second) | StmtKind::Semi(second)) = (&w[0].kind, &w[1].kind) {
+                check_missing_else(cx, first, second);
             }
         }
     }
diff --git a/clippy_lints/src/methods/manual_saturating_arithmetic.rs b/clippy_lints/src/methods/manual_saturating_arithmetic.rs
index aaed6d75048..4f5c06e785c 100644
--- a/clippy_lints/src/methods/manual_saturating_arithmetic.rs
+++ b/clippy_lints/src/methods/manual_saturating_arithmetic.rs
@@ -57,7 +57,7 @@ pub fn lint(cx: &LateContext<'_, '_>, expr: &hir::Expr<'_>, args: &[&[hir::Expr<
         );
     } else {
         match (mm, arith) {
-            (MinMax::Max, "add") | (MinMax::Max, "mul") | (MinMax::Min, "sub") => (),
+            (MinMax::Max, "add" | "mul") | (MinMax::Min, "sub") => (),
             _ => return,
         }
 
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 78d69690c2d..214cf0c130f 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1403,9 +1403,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Methods {
                 lint_search_is_some(cx, expr, "rposition", arg_lists[1], arg_lists[0], method_spans[1])
             },
             ["extend", ..] => lint_extend(cx, expr, arg_lists[0]),
-            ["as_ptr", "unwrap"] | ["as_ptr", "expect"] => {
-                lint_cstring_as_ptr(cx, expr, &arg_lists[1][0], &arg_lists[0][0])
-            },
+            ["as_ptr", "unwrap" | "expect"] => lint_cstring_as_ptr(cx, expr, &arg_lists[1][0], &arg_lists[0][0]),
             ["nth", "iter"] => lint_iter_nth(cx, expr, &arg_lists, false),
             ["nth", "iter_mut"] => lint_iter_nth(cx, expr, &arg_lists, true),
             ["nth", ..] => lint_iter_nth_zero(cx, expr, arg_lists[0]),
@@ -1418,12 +1416,10 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Methods {
             ["filter_map", ..] => unnecessary_filter_map::lint(cx, expr, arg_lists[0]),
             ["count", "map"] => lint_suspicious_map(cx, expr),
             ["assume_init"] => lint_maybe_uninit(cx, &arg_lists[0][0], expr),
-            ["unwrap_or", arith @ "checked_add"]
-            | ["unwrap_or", arith @ "checked_sub"]
-            | ["unwrap_or", arith @ "checked_mul"] => {
+            ["unwrap_or", arith @ ("checked_add" | "checked_sub" | "checked_mul")] => {
                 manual_saturating_arithmetic::lint(cx, expr, &arg_lists, &arith["checked_".len()..])
             },
-            ["add"] | ["offset"] | ["sub"] | ["wrapping_offset"] | ["wrapping_add"] | ["wrapping_sub"] => {
+            ["add" | "offset" | "sub" | "wrapping_offset" | "wrapping_add" | "wrapping_sub"] => {
                 check_pointer_offset(cx, expr, arg_lists[0])
             },
             ["is_file", ..] => lint_filetype_is_file(cx, expr, arg_lists[0]),
@@ -1829,8 +1825,7 @@ fn lint_expect_fun_call(
             hir::ExprKind::Call(fun, _) => {
                 if let hir::ExprKind::Path(ref p) = fun.kind {
                     match cx.tables.qpath_res(p, fun.hir_id) {
-                        hir::def::Res::Def(hir::def::DefKind::Fn, def_id)
-                        | hir::def::Res::Def(hir::def::DefKind::AssocFn, def_id) => matches!(
+                        hir::def::Res::Def(hir::def::DefKind::Fn | hir::def::DefKind::AssocFn, def_id) => matches!(
                             cx.tcx.fn_sig(def_id).output().skip_binder().kind,
                             ty::Ref(ty::ReStatic, ..)
                         ),
diff --git a/clippy_lints/src/misc.rs b/clippy_lints/src/misc.rs
index 51282ab93ef..f513161bbbc 100644
--- a/clippy_lints/src/misc.rs
+++ b/clippy_lints/src/misc.rs
@@ -275,17 +275,14 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MiscLints {
             return;
         }
         for arg in iter_input_pats(decl, body) {
-            match arg.pat.kind {
-                PatKind::Binding(BindingAnnotation::Ref, ..) | PatKind::Binding(BindingAnnotation::RefMut, ..) => {
-                    span_lint(
-                        cx,
-                        TOPLEVEL_REF_ARG,
-                        arg.pat.span,
-                        "`ref` directly on a function argument is ignored. Consider using a reference type \
-                         instead.",
-                    );
-                },
-                _ => {},
+            if let PatKind::Binding(BindingAnnotation::Ref | BindingAnnotation::RefMut, ..) = arg.pat.kind {
+                span_lint(
+                    cx,
+                    TOPLEVEL_REF_ARG,
+                    arg.pat.span,
+                    "`ref` directly on a function argument is ignored. \
+                    Consider using a reference type instead.",
+                );
             }
         }
     }
diff --git a/clippy_lints/src/no_effect.rs b/clippy_lints/src/no_effect.rs
index b8bfa676a16..2eacd3c80c4 100644
--- a/clippy_lints/src/no_effect.rs
+++ b/clippy_lints/src/no_effect.rs
@@ -147,7 +147,7 @@ fn reduce_expression<'a>(cx: &LateContext<'_, '_>, expr: &'a Expr<'a>) -> Option
             if let ExprKind::Path(ref qpath) = callee.kind {
                 let res = qpath_res(cx, qpath, callee.hir_id);
                 match res {
-                    Res::Def(DefKind::Struct, ..) | Res::Def(DefKind::Variant, ..) | Res::Def(DefKind::Ctor(..), _)
+                    Res::Def(DefKind::Struct | DefKind::Variant | DefKind::Ctor(..), ..)
                         if !has_drop(cx, cx.tables.expr_ty(expr)) =>
                     {
                         Some(args.iter().collect())
diff --git a/clippy_lints/src/suspicious_trait_impl.rs b/clippy_lints/src/suspicious_trait_impl.rs
index f1e223d9a48..a9e6fa329c0 100644
--- a/clippy_lints/src/suspicious_trait_impl.rs
+++ b/clippy_lints/src/suspicious_trait_impl.rs
@@ -71,8 +71,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for SuspiciousImpl {
                 if let hir::Node::Expr(e) = cx.tcx.hir().get(parent_expr) {
                     match e.kind {
                         hir::ExprKind::Binary(..)
-                        | hir::ExprKind::Unary(hir::UnOp::UnNot, _)
-                        | hir::ExprKind::Unary(hir::UnOp::UnNeg, _)
+                        | hir::ExprKind::Unary(hir::UnOp::UnNot | hir::UnOp::UnNeg, _)
                         | hir::ExprKind::AssignOp(..) => return,
                         _ => {},
                     }
@@ -191,8 +190,7 @@ impl<'a, 'tcx> Visitor<'tcx> for BinaryExprVisitor {
     fn visit_expr(&mut self, expr: &'tcx hir::Expr<'_>) {
         match expr.kind {
             hir::ExprKind::Binary(..)
-            | hir::ExprKind::Unary(hir::UnOp::UnNot, _)
-            | hir::ExprKind::Unary(hir::UnOp::UnNeg, _)
+            | hir::ExprKind::Unary(hir::UnOp::UnNot | hir::UnOp::UnNeg, _)
             | hir::ExprKind::AssignOp(..) => self.in_binary_expr = true,
             _ => {},
         }
diff --git a/clippy_lints/src/transmute.rs b/clippy_lints/src/transmute.rs
index e24d2c4f495..1869638f6ff 100644
--- a/clippy_lints/src/transmute.rs
+++ b/clippy_lints/src/transmute.rs
@@ -312,7 +312,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Transmute {
                         e.span,
                         &format!("transmute from a type (`{}`) to itself", from_ty),
                     ),
-                    (&ty::Ref(_, rty, rty_mutbl), &ty::RawPtr(ptr_ty)) => span_lint_and_then(
+                    (ty::Ref(_, rty, rty_mutbl), ty::RawPtr(ptr_ty)) => span_lint_and_then(
                         cx,
                         USELESS_TRANSMUTE,
                         e.span,
@@ -321,10 +321,10 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Transmute {
                             if let Some(arg) = sugg::Sugg::hir_opt(cx, &args[0]) {
                                 let rty_and_mut = ty::TypeAndMut {
                                     ty: rty,
-                                    mutbl: rty_mutbl,
+                                    mutbl: *rty_mutbl,
                                 };
 
-                                let sugg = if ptr_ty == rty_and_mut {
+                                let sugg = if *ptr_ty == rty_and_mut {
                                     arg.as_ty(to_ty)
                                 } else {
                                     arg.as_ty(cx.tcx.mk_ptr(rty_and_mut)).as_ty(to_ty)
@@ -334,7 +334,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Transmute {
                             }
                         },
                     ),
-                    (&ty::Int(_), &ty::RawPtr(_)) | (&ty::Uint(_), &ty::RawPtr(_)) => span_lint_and_then(
+                    (ty::Int(_) | ty::Uint(_), ty::RawPtr(_)) => span_lint_and_then(
                         cx,
                         USELESS_TRANSMUTE,
                         e.span,
@@ -350,16 +350,13 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Transmute {
                             }
                         },
                     ),
-                    (&ty::Float(_), &ty::Ref(..))
-                    | (&ty::Float(_), &ty::RawPtr(_))
-                    | (&ty::Char, &ty::Ref(..))
-                    | (&ty::Char, &ty::RawPtr(_)) => span_lint(
+                    (ty::Float(_) | ty::Char, ty::Ref(..) | ty::RawPtr(_)) => span_lint(
                         cx,
                         WRONG_TRANSMUTE,
                         e.span,
                         &format!("transmute from a `{}` to a pointer", from_ty),
                     ),
-                    (&ty::RawPtr(from_ptr), _) if from_ptr.ty == to_ty => span_lint(
+                    (ty::RawPtr(from_ptr), _) if from_ptr.ty == to_ty => span_lint(
                         cx,
                         CROSSPOINTER_TRANSMUTE,
                         e.span,
@@ -368,7 +365,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Transmute {
                             from_ty, to_ty
                         ),
                     ),
-                    (_, &ty::RawPtr(to_ptr)) if to_ptr.ty == from_ty => span_lint(
+                    (_, ty::RawPtr(to_ptr)) if to_ptr.ty == from_ty => span_lint(
                         cx,
                         CROSSPOINTER_TRANSMUTE,
                         e.span,
@@ -377,7 +374,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Transmute {
                             from_ty, to_ty
                         ),
                     ),
-                    (&ty::RawPtr(from_pty), &ty::Ref(_, to_ref_ty, mutbl)) => span_lint_and_then(
+                    (ty::RawPtr(from_pty), ty::Ref(_, to_ref_ty, mutbl)) => span_lint_and_then(
                         cx,
                         TRANSMUTE_PTR_TO_REF,
                         e.span,
@@ -388,13 +385,13 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Transmute {
                         ),
                         |diag| {
                             let arg = sugg::Sugg::hir(cx, &args[0], "..");
-                            let (deref, cast) = if mutbl == Mutability::Mut {
+                            let (deref, cast) = if *mutbl == Mutability::Mut {
                                 ("&mut *", "*mut")
                             } else {
                                 ("&*", "*const")
                             };
 
-                            let arg = if from_pty.ty == to_ref_ty {
+                            let arg = if from_pty.ty == *to_ref_ty {
                                 arg
                             } else {
                                 arg.as_ty(&format!("{} {}", cast, get_type_snippet(cx, qpath, to_ref_ty)))
@@ -408,7 +405,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Transmute {
                             );
                         },
                     ),
-                    (&ty::Int(ast::IntTy::I32), &ty::Char) | (&ty::Uint(ast::UintTy::U32), &ty::Char) => {
+                    (ty::Int(ast::IntTy::I32) | ty::Uint(ast::UintTy::U32), &ty::Char) => {
                         span_lint_and_then(
                             cx,
                             TRANSMUTE_INT_TO_CHAR,
@@ -430,13 +427,13 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Transmute {
                             },
                         )
                     },
-                    (&ty::Ref(_, ty_from, from_mutbl), &ty::Ref(_, ty_to, to_mutbl)) => {
+                    (ty::Ref(_, ty_from, from_mutbl), ty::Ref(_, ty_to, to_mutbl)) => {
                         if_chain! {
                             if let (&ty::Slice(slice_ty), &ty::Str) = (&ty_from.kind, &ty_to.kind);
                             if let ty::Uint(ast::UintTy::U8) = slice_ty.kind;
                             if from_mutbl == to_mutbl;
                             then {
-                                let postfix = if from_mutbl == Mutability::Mut {
+                                let postfix = if *from_mutbl == Mutability::Mut {
                                     "_mut"
                                 } else {
                                     ""
@@ -465,13 +462,13 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Transmute {
                                         |diag| if let Some(arg) = sugg::Sugg::hir_opt(cx, &args[0]) {
                                             let ty_from_and_mut = ty::TypeAndMut {
                                                 ty: ty_from,
-                                                mutbl: from_mutbl
+                                                mutbl: *from_mutbl
                                             };
-                                            let ty_to_and_mut = ty::TypeAndMut { ty: ty_to, mutbl: to_mutbl };
+                                            let ty_to_and_mut = ty::TypeAndMut { ty: ty_to, mutbl: *to_mutbl };
                                             let sugg_paren = arg
                                                 .as_ty(cx.tcx.mk_ptr(ty_from_and_mut))
                                                 .as_ty(cx.tcx.mk_ptr(ty_to_and_mut));
-                                            let sugg = if to_mutbl == Mutability::Mut {
+                                            let sugg = if *to_mutbl == Mutability::Mut {
                                                 sugg_paren.mut_addr_deref()
                                             } else {
                                                 sugg_paren.addr_deref()
@@ -488,19 +485,19 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Transmute {
                             }
                         }
                     },
-                    (&ty::RawPtr(_), &ty::RawPtr(to_ty)) => span_lint_and_then(
+                    (ty::RawPtr(_), ty::RawPtr(to_ty)) => span_lint_and_then(
                         cx,
                         TRANSMUTE_PTR_TO_PTR,
                         e.span,
                         "transmute from a pointer to a pointer",
                         |diag| {
                             if let Some(arg) = sugg::Sugg::hir_opt(cx, &args[0]) {
-                                let sugg = arg.as_ty(cx.tcx.mk_ptr(to_ty));
+                                let sugg = arg.as_ty(cx.tcx.mk_ptr(*to_ty));
                                 diag.span_suggestion(e.span, "try", sugg.to_string(), Applicability::Unspecified);
                             }
                         },
                     ),
-                    (&ty::Int(ast::IntTy::I8), &ty::Bool) | (&ty::Uint(ast::UintTy::U8), &ty::Bool) => {
+                    (ty::Int(ast::IntTy::I8) | ty::Uint(ast::UintTy::U8), ty::Bool) => {
                         span_lint_and_then(
                             cx,
                             TRANSMUTE_INT_TO_BOOL,
@@ -518,7 +515,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Transmute {
                             },
                         )
                     },
-                    (&ty::Int(_), &ty::Float(_)) | (&ty::Uint(_), &ty::Float(_)) => span_lint_and_then(
+                    (ty::Int(_) | ty::Uint(_), ty::Float(_)) => span_lint_and_then(
                         cx,
                         TRANSMUTE_INT_TO_FLOAT,
                         e.span,
@@ -541,7 +538,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Transmute {
                             );
                         },
                     ),
-                    (&ty::Float(float_ty), &ty::Int(_)) | (&ty::Float(float_ty), &ty::Uint(_)) => span_lint_and_then(
+                    (ty::Float(float_ty), ty::Int(_) | ty::Uint(_)) => span_lint_and_then(
                         cx,
                         TRANSMUTE_FLOAT_TO_INT,
                         e.span,
@@ -585,7 +582,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Transmute {
                             );
                         },
                     ),
-                    (&ty::Adt(ref from_adt, ref from_substs), &ty::Adt(ref to_adt, ref to_substs)) => {
+                    (ty::Adt(from_adt, from_substs), ty::Adt(to_adt, to_substs)) => {
                         if from_adt.did != to_adt.did ||
                                 !COLLECTIONS.iter().any(|path| match_def_path(cx, to_adt.did, path)) {
                             return;
diff --git a/clippy_lints/src/unwrap.rs b/clippy_lints/src/unwrap.rs
index 8b971e7064b..036dd16a224 100644
--- a/clippy_lints/src/unwrap.rs
+++ b/clippy_lints/src/unwrap.rs
@@ -101,7 +101,7 @@ fn collect_unwrap_info<'a, 'tcx>(
 
     if let ExprKind::Binary(op, left, right) = &expr.kind {
         match (invert, op.node) {
-            (false, BinOpKind::And) | (false, BinOpKind::BitAnd) | (true, BinOpKind::Or) | (true, BinOpKind::BitOr) => {
+            (false, BinOpKind::And | BinOpKind::BitAnd) | (true, BinOpKind::Or | BinOpKind::BitOr) => {
                 let mut unwrap_info = collect_unwrap_info(cx, left, branch, invert);
                 unwrap_info.append(&mut collect_unwrap_info(cx, right, branch, invert));
                 return unwrap_info;
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index 8f8aff622f4..7c823810265 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -1,6 +1,7 @@
 #[macro_use]
 pub mod sym;
 
+#[allow(clippy::module_name_repetitions)]
 pub mod ast_utils;
 pub mod attrs;
 pub mod author;
@@ -73,7 +74,7 @@ pub fn in_constant(cx: &LateContext<'_, '_>, id: HirId) -> bool {
     let parent_id = cx.tcx.hir().get_parent_item(id);
     match cx.tcx.hir().get(parent_id) {
         Node::Item(&Item {
-            kind: ItemKind::Const(..),
+            kind: ItemKind::Const(..) | ItemKind::Static(..),
             ..
         })
         | Node::TraitItem(&TraitItem {
@@ -84,11 +85,7 @@ pub fn in_constant(cx: &LateContext<'_, '_>, id: HirId) -> bool {
             kind: ImplItemKind::Const(..),
             ..
         })
-        | Node::AnonConst(_)
-        | Node::Item(&Item {
-            kind: ItemKind::Static(..),
-            ..
-        }) => true,
+        | Node::AnonConst(_) => true,
         Node::Item(&Item {
             kind: ItemKind::Fn(ref sig, ..),
             ..
-- 
cgit 1.4.1-3-g733a5


From ecabed67ec75ac6498c6176a7a6de3ad53b2e54b Mon Sep 17 00:00:00 2001
From: flip1995 <hello@philkrones.com>
Date: Sun, 7 Jun 2020 16:43:17 +0200
Subject: Apply self-review by Centril

---
 clippy_lints/src/unnested_or_patterns.rs | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unnested_or_patterns.rs b/clippy_lints/src/unnested_or_patterns.rs
index 2723af03c0b..8c281126c32 100644
--- a/clippy_lints/src/unnested_or_patterns.rs
+++ b/clippy_lints/src/unnested_or_patterns.rs
@@ -214,21 +214,21 @@ fn transform_with_focus_on_idx(alternatives: &mut Vec<P<Pat>>, focus_idx: usize)
     let changed = match &mut focus_kind {
         // These pattern forms are "leafs" and do not have sub-patterns.
         // Therefore they are not some form of constructor `C`,
-        // with which a pattern `C(P0)` may be formed,
-        // which we would want to join with other `C(Pj)`s.
+        // with which a pattern `C(p_0)` may be formed,
+        // which we would want to join with other `C(p_j)`s.
         Ident(.., None) | Lit(_) | Wild | Path(..) | Range(..) | Rest | MacCall(_)
         // Dealt with elsewhere.
         | Or(_) | Paren(_) => false,
         // Transform `box x | ... | box y` into `box (x | y)`.
         //
-        // The cases below until `Slice(...)` deal *singleton* products.
+        // The cases below until `Slice(...)` deal with *singleton* products.
         // These patterns have the shape `C(p)`, and not e.g., `C(p0, ..., pn)`.
         Box(target) => extend_with_matching(
             target, start, alternatives,
             |k| matches!(k, Box(_)),
             |k| always_pat!(k, Box(p) => p),
         ),
-        // Transform `&m x | ... | &m y` into `&m (x, y)`.
+        // Transform `&m x | ... | &m y` into `&m (x | y)`.
         Ref(target, m1) => extend_with_matching(
             target, start, alternatives,
             |k| matches!(k, Ref(_, m2) if m1 == m2), // Mutabilities must match.
@@ -247,13 +247,13 @@ fn transform_with_focus_on_idx(alternatives: &mut Vec<P<Pat>>, focus_idx: usize)
             |k, ps1, idx| matches!(k, Slice(ps2) if eq_pre_post(ps1, ps2, idx)),
             |k| always_pat!(k, Slice(ps) => ps),
         ),
-        // Transform `(pre, x, post) | ... | (pre, y, post)` into `(pre, x | y, post]`.
+        // Transform `(pre, x, post) | ... | (pre, y, post)` into `(pre, x | y, post)`.
         Tuple(ps1) => extend_with_matching_product(
             ps1, start, alternatives,
             |k, ps1, idx| matches!(k, Tuple(ps2) if eq_pre_post(ps1, ps2, idx)),
             |k| always_pat!(k, Tuple(ps) => ps),
         ),
-        // Transform `S(pre, x, post) | ... | S(pre, y, post)` into `S(pre, x | y, post]`.
+        // Transform `S(pre, x, post) | ... | S(pre, y, post)` into `S(pre, x | y, post)`.
         TupleStruct(path1, ps1) => extend_with_matching_product(
             ps1, start, alternatives,
             |k, ps1, idx| matches!(
-- 
cgit 1.4.1-3-g733a5


From a9ca832b11f7671f5d88f299a44415cf964304e7 Mon Sep 17 00:00:00 2001
From: flip1995 <hello@philkrones.com>
Date: Sun, 7 Jun 2020 21:33:03 +0200
Subject: Fix rebase fallout

---
 clippy_lints/src/await_holding_lock.rs | 19 +++++++------------
 clippy_lints/src/utils/ast_utils.rs    |  1 +
 2 files changed, 8 insertions(+), 12 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/await_holding_lock.rs b/clippy_lints/src/await_holding_lock.rs
index 832910763e6..a88f922d8e0 100644
--- a/clippy_lints/src/await_holding_lock.rs
+++ b/clippy_lints/src/await_holding_lock.rs
@@ -54,18 +54,13 @@ declare_lint_pass!(AwaitHoldingLock => [AWAIT_HOLDING_LOCK]);
 impl LateLintPass<'_, '_> for AwaitHoldingLock {
     fn check_body(&mut self, cx: &LateContext<'_, '_>, body: &'_ Body<'_>) {
         use AsyncGeneratorKind::{Block, Closure, Fn};
-        match body.generator_kind {
-            Some(GeneratorKind::Async(Block))
-            | Some(GeneratorKind::Async(Closure))
-            | Some(GeneratorKind::Async(Fn)) => {
-                let body_id = BodyId {
-                    hir_id: body.value.hir_id,
-                };
-                let def_id = cx.tcx.hir().body_owner_def_id(body_id);
-                let tables = cx.tcx.typeck_tables_of(def_id);
-                check_interior_types(cx, &tables.generator_interior_types, body.value.span);
-            },
-            _ => {},
+        if let Some(GeneratorKind::Async(Block | Closure | Fn)) = body.generator_kind {
+            let body_id = BodyId {
+                hir_id: body.value.hir_id,
+            };
+            let def_id = cx.tcx.hir().body_owner_def_id(body_id);
+            let tables = cx.tcx.typeck_tables_of(def_id);
+            check_interior_types(cx, &tables.generator_interior_types, body.value.span);
         }
     }
 }
diff --git a/clippy_lints/src/utils/ast_utils.rs b/clippy_lints/src/utils/ast_utils.rs
index 69a7b6c051e..dcf09da198e 100755
--- a/clippy_lints/src/utils/ast_utils.rs
+++ b/clippy_lints/src/utils/ast_utils.rs
@@ -7,6 +7,7 @@
 use crate::utils::{both, over};
 use rustc_ast::ast::{self, *};
 use rustc_ast::ptr::P;
+use rustc_span::symbol::Ident;
 use std::mem;
 
 /// Checks if each element in the first slice is contained within the latter as per `eq_fn`.
-- 
cgit 1.4.1-3-g733a5


From a4b8bb88f210de7fa2d82fe64b48331126eb7462 Mon Sep 17 00:00:00 2001
From: Devin R <devin.ragotzy@gmail.com>
Date: Wed, 26 Feb 2020 07:40:31 -0500
Subject: warn on macro_use attr

cargo dev update lints

use if_chain

clean up alot, span_lint_and_sugg

find imported macros for sugg
---
 clippy_lints/src/macro_use.rs    |  68 +++++++++++++++++++++++++++++++++------
 macro_use_import                 | Bin 0 -> 2816064 bytes
 tests/ui/macro_use_import.rs     |  12 +++++++
 tests/ui/macro_use_import.stderr |  10 ++++++
 tests/ui/macro_use_import.stdout |   0
 5 files changed, 80 insertions(+), 10 deletions(-)
 create mode 100755 macro_use_import
 create mode 100644 tests/ui/macro_use_import.rs
 create mode 100644 tests/ui/macro_use_import.stderr
 create mode 100644 tests/ui/macro_use_import.stdout

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/macro_use.rs b/clippy_lints/src/macro_use.rs
index b1345d0b751..cf526409374 100644
--- a/clippy_lints/src/macro_use.rs
+++ b/clippy_lints/src/macro_use.rs
@@ -1,10 +1,11 @@
-use crate::utils::{snippet, span_lint_and_sugg};
+use crate::utils::{snippet, span_lint_and_sugg, in_macro};
 use if_chain::if_chain;
 use rustc_ast::ast;
+use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::edition::Edition;
+use rustc_session::{impl_lint_pass, declare_tool_lint};
+use rustc_span::{edition::Edition, Span};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for `#[macro_use] use...`.
@@ -12,21 +13,27 @@ declare_clippy_lint! {
     /// **Why is this bad?** Since the Rust 2018 edition you can import
     /// macro's directly, this is considered idiomatic.
     ///
-    /// **Known problems:** This lint does not generate an auto-applicable suggestion.
+    /// **Known problems:** None.
     ///
     /// **Example:**
     /// ```rust
     /// #[macro_use]
     /// use lazy_static;
     /// ```
-    pub MACRO_USE_IMPORTS,
+    pub MACRO_USE_IMPORT,
     pedantic,
     "#[macro_use] is no longer needed"
 }
 
-declare_lint_pass!(MacroUseImports => [MACRO_USE_IMPORTS]);
+#[derive(Default)]
+pub struct MacroUseImport {
+    collected: FxHashSet<Span>,
+}
+
+impl_lint_pass!(MacroUseImport => [MACRO_USE_IMPORT]);
+
+impl EarlyLintPass for MacroUseImport {
 
-impl EarlyLintPass for MacroUseImports {
     fn check_item(&mut self, ecx: &EarlyContext<'_>, item: &ast::Item) {
         if_chain! {
             if ecx.sess.opts.edition == Edition::Edition2018;
@@ -36,18 +43,59 @@ impl EarlyLintPass for MacroUseImports {
                 .iter()
                 .find(|attr| attr.ident().map(|s| s.to_string()) == Some("macro_use".to_string()));
             then {
+                let import_path = snippet(ecx, use_tree.span, "_");
+                let mac_names = find_used_macros(ecx, &import_path);
                 let msg = "`macro_use` attributes are no longer needed in the Rust 2018 edition";
-                let help = format!("use {}::<macro name>", snippet(ecx, use_tree.span, "_"));
+                let help = format!("use {}::<macro name>", import_path);
                 span_lint_and_sugg(
                     ecx,
-                    MACRO_USE_IMPORTS,
+                    MACRO_USE_IMPORT,
                     mac_attr.span,
                     msg,
-                    "remove the attribute and import the macro directly, try",
+                    // "remove the attribute and import the macro directly, try",
+                    "",
                     help,
                     Applicability::HasPlaceholders,
                 );
             }
         }
     }
+
+    fn check_expr(&mut self, ecx: &EarlyContext<'_>, expr: &ast::Expr) {
+        if in_macro(expr.span) {
+            let name = snippet(ecx, ecx.sess.source_map().span_until_char(expr.span.source_callsite(), '!'), "_");
+            if let Some(callee) = expr.span.source_callee() {
+                if self.collected.insert(callee.def_site) {
+                    println!("EXPR {:#?}", name);
+                }
+            }
+        }
+    }
+    fn check_stmt(&mut self, ecx: &EarlyContext<'_>, stmt: &ast::Stmt) {
+        if in_macro(stmt.span) {
+            let name = snippet(ecx, ecx.sess.source_map().span_until_char(stmt.span.source_callsite(), '!'), "_");
+            if let Some(callee) = stmt.span.source_callee() {
+                println!("EXPR {:#?}", name);
+            }
+        }
+    }
+    fn check_pat(&mut self, ecx: &EarlyContext<'_>, pat: &ast::Pat) {
+        if in_macro(pat.span) {
+            let name = snippet(ecx, ecx.sess.source_map().span_until_char(pat.span.source_callsite(), '!'), "_");
+            if let Some(callee) = pat.span.source_callee() {
+                println!("EXPR {:#?}", name);
+            }
+        }
+    }
+}
+
+fn find_used_macros(ecx: &EarlyContext<'_>, path: &str) {
+    for it in ecx.krate.module.items.iter() {
+        if in_macro(it.span) {
+            // println!("{:#?}", it)
+        }
+    }
+    for x in ecx.sess.imported_macro_spans.borrow().iter() {
+        // println!("{:?}", x);
+    }
 }
diff --git a/macro_use_import b/macro_use_import
new file mode 100755
index 00000000000..61d3a827f1f
Binary files /dev/null and b/macro_use_import differ
diff --git a/tests/ui/macro_use_import.rs b/tests/ui/macro_use_import.rs
new file mode 100644
index 00000000000..6490a2107d5
--- /dev/null
+++ b/tests/ui/macro_use_import.rs
@@ -0,0 +1,12 @@
+// compile-flags: --edition 2018
+#![warn(clippy::macro_use_import)]
+
+use std::collections::HashMap;
+#[macro_use]
+use std::prelude;
+
+fn main() {
+    let _ = HashMap::<u8, u8>::new();
+    serde_if_integer128!("");
+    println!();
+}
diff --git a/tests/ui/macro_use_import.stderr b/tests/ui/macro_use_import.stderr
new file mode 100644
index 00000000000..1d86ba58441
--- /dev/null
+++ b/tests/ui/macro_use_import.stderr
@@ -0,0 +1,10 @@
+error: `macro_use` attributes are no longer needed in the Rust 2018 edition
+  --> $DIR/macro_use_import.rs:5:1
+   |
+LL | #[macro_use]
+   | ^^^^^^^^^^^^ help: remove the attribute and import the macro directly, try: `use std::prelude::<macro name>`
+   |
+   = note: `-D clippy::macro-use-import` implied by `-D warnings`
+
+error: aborting due to previous error
+
diff --git a/tests/ui/macro_use_import.stdout b/tests/ui/macro_use_import.stdout
new file mode 100644
index 00000000000..e69de29bb2d
-- 
cgit 1.4.1-3-g733a5


From ede366be637657280ca506c5bad0f41f96c47340 Mon Sep 17 00:00:00 2001
From: Devin R <devin.ragotzy@gmail.com>
Date: Wed, 4 Mar 2020 07:59:10 -0500
Subject: collected all the imports and names

how to compare macro to import path

add more imports to test
---
 clippy_lints/src/lib.rs                |   6 +-
 clippy_lints/src/macro_use.rs          | 234 ++++++++++++++++++++++++++-------
 macro_use_import                       | Bin 2816064 -> 0 bytes
 tests/ui/auxiliary/macro_use_helper.rs |  55 ++++++++
 tests/ui/macro_use_import.rs           |  12 --
 tests/ui/macro_use_import.stderr       |  10 --
 tests/ui/macro_use_imports.rs          |  37 +++++-
 7 files changed, 281 insertions(+), 73 deletions(-)
 delete mode 100755 macro_use_import
 create mode 100644 tests/ui/auxiliary/macro_use_helper.rs
 delete mode 100644 tests/ui/macro_use_import.rs
 delete mode 100644 tests/ui/macro_use_import.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index cd258c7b506..89f55986f63 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -60,6 +60,7 @@ extern crate rustc_trait_selection;
 #[allow(unused_extern_crates)]
 extern crate rustc_typeck;
 
+use rustc::session::Session;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_lint::LintId;
 use rustc_session::Session;
@@ -1060,9 +1061,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     let max_struct_bools = conf.max_struct_bools;
     store.register_early_pass(move || box excessive_bools::ExcessiveBools::new(max_struct_bools, max_fn_params_bools));
     store.register_early_pass(|| box option_env_unwrap::OptionEnvUnwrap);
-    let warn_on_all_wildcard_imports = conf.warn_on_all_wildcard_imports;
-    store.register_late_pass(move || box wildcard_imports::WildcardImports::new(warn_on_all_wildcard_imports));
-    store.register_early_pass(|| box macro_use::MacroUseImports);
+    store.register_late_pass(|| box wildcard_imports::WildcardImports);
     store.register_late_pass(|| box verbose_file_reads::VerboseFileReads);
     store.register_late_pass(|| box redundant_pub_crate::RedundantPubCrate::default());
     store.register_late_pass(|| box unnamed_address::UnnamedAddress);
@@ -1080,6 +1079,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         single_char_binding_names_threshold,
     });
     store.register_early_pass(|| box unnested_or_patterns::UnnestedOrPatterns);
+    store.register_late_pass(|| box macro_use::MacroUseImports::default());
 
     store.register_group(true, "clippy::restriction", Some("clippy_restriction"), vec![
         LintId::of(&arithmetic::FLOAT_ARITHMETIC),
diff --git a/clippy_lints/src/macro_use.rs b/clippy_lints/src/macro_use.rs
index cf526409374..4c89647a574 100644
--- a/clippy_lints/src/macro_use.rs
+++ b/clippy_lints/src/macro_use.rs
@@ -1,10 +1,12 @@
-use crate::utils::{snippet, span_lint_and_sugg, in_macro};
+use crate::utils::{in_macro, snippet, span_lint_and_sugg};
+use hir::def::{DefKind, Res};
 use if_chain::if_chain;
 use rustc_ast::ast;
-use rustc_data_structures::fx::FxHashSet;
+use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::Applicability;
-use rustc_lint::{EarlyContext, EarlyLintPass};
-use rustc_session::{impl_lint_pass, declare_tool_lint};
+use rustc_hir as hir;
+use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::{edition::Edition, Span};
 
 declare_clippy_lint! {
@@ -20,82 +22,226 @@ declare_clippy_lint! {
     /// #[macro_use]
     /// use lazy_static;
     /// ```
-    pub MACRO_USE_IMPORT,
+    pub MACRO_USE_IMPORTS,
     pedantic,
     "#[macro_use] is no longer needed"
 }
 
-#[derive(Default)]
-pub struct MacroUseImport {
-    collected: FxHashSet<Span>,
+const BRACKETS: &[char] = &['<', '>'];
+
+/// MacroRefData includes the name of the macro
+/// and the path from `SourceMap::span_to_filename`.
+#[derive(Debug, Clone)]
+pub struct MacroRefData {
+    name: String,
+    path: String,
 }
 
-impl_lint_pass!(MacroUseImport => [MACRO_USE_IMPORT]);
+impl MacroRefData {
+    pub fn new(name: String, span: Span, ecx: &LateContext<'_, '_>) -> Self {
+        let mut path = ecx.sess().source_map().span_to_filename(span).to_string();
 
-impl EarlyLintPass for MacroUseImport {
+        // std lib paths are <::std::module::file type>
+        // so remove brackets and space
+        if path.contains('<') {
+            path = path.replace(BRACKETS, "");
+        }
+        if path.contains(' ') {
+            path = path.split(' ').next().unwrap().to_string();
+        }
+        Self {
+            name: name.to_string(),
+            path,
+        }
+    }
+}
 
-    fn check_item(&mut self, ecx: &EarlyContext<'_>, item: &ast::Item) {
+#[derive(Default)]
+pub struct MacroUseImports {
+    /// the actual import path used and the span of the attribute above it.
+    imports: Vec<(String, Span)>,
+    /// the span of the macro reference and the `MacroRefData`
+    /// for the use of the macro.
+    /// TODO make this FxHashSet<Span> to guard against inserting already found macros
+    collected: FxHashMap<Span, MacroRefData>,
+    mac_refs: Vec<(Span, MacroRefData)>,
+}
+
+impl_lint_pass!(MacroUseImports => [MACRO_USE_IMPORTS]);
+
+impl<'l, 'txc> LateLintPass<'l, 'txc> for MacroUseImports {
+    fn check_item(&mut self, lcx: &LateContext<'_, '_>, item: &hir::Item<'_>) {
         if_chain! {
-            if ecx.sess.opts.edition == Edition::Edition2018;
-            if let ast::ItemKind::Use(use_tree) = &item.kind;
+            if lcx.sess().opts.edition == Edition::Edition2018;
+            if let hir::ItemKind::Use(path, _kind) = &item.kind;
             if let Some(mac_attr) = item
                 .attrs
                 .iter()
                 .find(|attr| attr.ident().map(|s| s.to_string()) == Some("macro_use".to_string()));
+            if let Res::Def(DefKind::Mod, id) = path.res;
             then {
-                let import_path = snippet(ecx, use_tree.span, "_");
-                let mac_names = find_used_macros(ecx, &import_path);
-                let msg = "`macro_use` attributes are no longer needed in the Rust 2018 edition";
-                let help = format!("use {}::<macro name>", import_path);
-                span_lint_and_sugg(
-                    ecx,
-                    MACRO_USE_IMPORT,
-                    mac_attr.span,
-                    msg,
-                    // "remove the attribute and import the macro directly, try",
-                    "",
-                    help,
-                    Applicability::HasPlaceholders,
-                );
+                // println!("{:#?}", lcx.tcx.def_path_str(id));
+                for kid in lcx.tcx.item_children(id).iter() {
+                    // println!("{:#?}", kid);
+                    if let Res::Def(DefKind::Macro(_mac_type), mac_id) = kid.res {
+                        let span = mac_attr.span.clone();
+
+                        // println!("{:#?}", lcx.tcx.def_path_str(mac_id));
+
+                        self.imports.push((lcx.tcx.def_path_str(mac_id), span));
+                    }
+                }
+            } else {
+                if in_macro(item.span) {
+                    let call_site = item.span.source_callsite();
+                    let name = snippet(lcx, lcx.sess().source_map().span_until_char(call_site, '!'), "_");
+                    if let Some(callee) = item.span.source_callee() {
+                        if !self.collected.contains_key(&call_site) {
+                            let mac = MacroRefData::new(name.to_string(), callee.def_site, lcx);
+                            self.mac_refs.push((call_site, mac.clone()));
+                            self.collected.insert(call_site, mac);
+                        }
+                    }
+                }
             }
         }
     }
+    fn check_attribute(&mut self, lcx: &LateContext<'_, '_>, attr: &ast::Attribute) {
+        if in_macro(attr.span) {
+            let call_site = attr.span.source_callsite();
+            let name = snippet(lcx, lcx.sess().source_map().span_until_char(call_site, '!'), "_");
+            if let Some(callee) = attr.span.source_callee() {
+                if !self.collected.contains_key(&call_site) {
+                    println!("{:?}\n{:#?}", call_site, attr);
+
+                    let name = if name.contains("::") {
+                        name.split("::").last().unwrap().to_string()
+                    } else {
+                        name.to_string()
+                    };
 
-    fn check_expr(&mut self, ecx: &EarlyContext<'_>, expr: &ast::Expr) {
+                    let mac = MacroRefData::new(name, callee.def_site, lcx);
+                    self.mac_refs.push((call_site, mac.clone()));
+                    self.collected.insert(call_site, mac);
+                }
+            }
+        }
+    }
+    fn check_expr(&mut self, lcx: &LateContext<'_, '_>, expr: &hir::Expr<'_>) {
         if in_macro(expr.span) {
-            let name = snippet(ecx, ecx.sess.source_map().span_until_char(expr.span.source_callsite(), '!'), "_");
+            let call_site = expr.span.source_callsite();
+            let name = snippet(lcx, lcx.sess().source_map().span_until_char(call_site, '!'), "_");
             if let Some(callee) = expr.span.source_callee() {
-                if self.collected.insert(callee.def_site) {
-                    println!("EXPR {:#?}", name);
+                if !self.collected.contains_key(&call_site) {
+                    let name = if name.contains("::") {
+                        name.split("::").last().unwrap().to_string()
+                    } else {
+                        name.to_string()
+                    };
+
+                    let mac = MacroRefData::new(name, callee.def_site, lcx);
+                    self.mac_refs.push((call_site, mac.clone()));
+                    self.collected.insert(call_site, mac);
                 }
             }
         }
     }
-    fn check_stmt(&mut self, ecx: &EarlyContext<'_>, stmt: &ast::Stmt) {
+    fn check_stmt(&mut self, lcx: &LateContext<'_, '_>, stmt: &hir::Stmt<'_>) {
         if in_macro(stmt.span) {
-            let name = snippet(ecx, ecx.sess.source_map().span_until_char(stmt.span.source_callsite(), '!'), "_");
+            let call_site = stmt.span.source_callsite();
+            let name = snippet(lcx, lcx.sess().source_map().span_until_char(call_site, '!'), "_");
             if let Some(callee) = stmt.span.source_callee() {
-                println!("EXPR {:#?}", name);
+                if !self.collected.contains_key(&call_site) {
+                    let name = if name.contains("::") {
+                        name.split("::").last().unwrap().to_string()
+                    } else {
+                        name.to_string()
+                    };
+
+                    let mac = MacroRefData::new(name, callee.def_site, lcx);
+                    self.mac_refs.push((call_site, mac.clone()));
+                    self.collected.insert(call_site, mac);
+                }
             }
         }
     }
-    fn check_pat(&mut self, ecx: &EarlyContext<'_>, pat: &ast::Pat) {
+    fn check_pat(&mut self, lcx: &LateContext<'_, '_>, pat: &hir::Pat<'_>) {
         if in_macro(pat.span) {
-            let name = snippet(ecx, ecx.sess.source_map().span_until_char(pat.span.source_callsite(), '!'), "_");
+            let call_site = pat.span.source_callsite();
+            let name = snippet(lcx, lcx.sess().source_map().span_until_char(call_site, '!'), "_");
             if let Some(callee) = pat.span.source_callee() {
-                println!("EXPR {:#?}", name);
+                if !self.collected.contains_key(&call_site) {
+                    let mac = MacroRefData::new(name.to_string(), callee.def_site, lcx);
+                    self.mac_refs.push((call_site, mac.clone()));
+                    self.collected.insert(call_site, mac);
+                }
             }
         }
     }
-}
+    fn check_ty(&mut self, lcx: &LateContext<'_, '_>, ty: &hir::Ty<'_>) {
+        if in_macro(ty.span) {
+            let call_site = ty.span.source_callsite();
+            let name = snippet(lcx, lcx.sess().source_map().span_until_char(call_site, '!'), "_");
+            if let Some(callee) = ty.span.source_callee() {
+                if !self.collected.contains_key(&call_site) {
+                    let mac = MacroRefData::new(name.to_string(), callee.def_site, lcx);
+                    self.mac_refs.push((call_site, mac.clone()));
+                    self.collected.insert(call_site, mac);
+                }
+            }
+        }
+    }
+
+    fn check_crate_post(&mut self, lcx: &LateContext<'_, '_>, _krate: &hir::Crate<'_>) {
+        for (import, span) in self.imports.iter() {
+            let matched = self
+                .mac_refs
+                .iter()
+                .find(|(_span, mac)| import.ends_with(&mac.name))
+                .is_some();
 
-fn find_used_macros(ecx: &EarlyContext<'_>, path: &str) {
-    for it in ecx.krate.module.items.iter() {
-        if in_macro(it.span) {
-            // println!("{:#?}", it)
+            if matched {
+                self.mac_refs.retain(|(_span, mac)| !import.ends_with(&mac.name));
+                let msg = "`macro_use` attributes are no longer needed in the Rust 2018 edition";
+                let help = format!("use {}", import);
+                span_lint_and_sugg(
+                    lcx,
+                    MACRO_USE_IMPORTS,
+                    *span,
+                    msg,
+                    "remove the attribute and import the macro directly, try",
+                    help,
+                    Applicability::HasPlaceholders,
+                )
+            }
+        }
+        if !self.mac_refs.is_empty() {
+            // TODO if not empty we found one we could not make a suggestion for
+            // such as std::prelude::v1 or something else I haven't thought of.
+            // println!("{:#?}", self.mac_refs);
         }
     }
-    for x in ecx.sess.imported_macro_spans.borrow().iter() {
-        // println!("{:?}", x);
+}
+
+const PRELUDE: &[&str] = &[
+    "marker", "ops", "convert", "iter", "option", "result", "borrow", "boxed", "string", "vec", "macros",
+];
+
+/// This is somewhat of a fallback for imports from `std::prelude` because they
+/// are not recognized by `LateLintPass::check_item` `lcx.tcx.item_children(id)`
+fn make_path(mac: &MacroRefData, use_path: &str) -> String {
+    let segs = mac.path.split("::").filter(|s| *s != "").collect::<Vec<_>>();
+
+    if segs.starts_with(&["std"]) && PRELUDE.iter().any(|m| segs.contains(m)) {
+        return format!(
+            "std::prelude::{} is imported by default, remove `use` statement",
+            mac.name
+        );
+    }
+
+    if use_path.split("::").count() == 1 {
+        return format!("{}::{}", use_path, mac.name);
     }
+
+    mac.path.clone()
 }
diff --git a/macro_use_import b/macro_use_import
deleted file mode 100755
index 61d3a827f1f..00000000000
Binary files a/macro_use_import and /dev/null differ
diff --git a/tests/ui/auxiliary/macro_use_helper.rs b/tests/ui/auxiliary/macro_use_helper.rs
new file mode 100644
index 00000000000..c63149a6819
--- /dev/null
+++ b/tests/ui/auxiliary/macro_use_helper.rs
@@ -0,0 +1,55 @@
+extern crate macro_rules;
+
+// STMT
+#[macro_export]
+macro_rules! pub_macro {
+    () => {
+        let _ = "hello Mr. Vonnegut";
+    };
+}
+
+pub mod inner {
+    pub use super::*;
+
+    // RE-EXPORT
+    // this will stick in `inner` module
+    pub use macro_rules::try_err;
+
+    // ITEM
+    #[macro_export]
+    macro_rules! inner_mod {
+        () => {
+            #[allow(dead_code)]
+            pub struct Tardis;
+        };
+    }
+}
+
+// EXPR
+#[macro_export]
+macro_rules! function {
+    () => {
+        if true {
+        } else {
+        }
+    };
+}
+
+// TYPE
+#[macro_export]
+macro_rules! ty_mac {
+    () => {
+        Vec<u8>
+    };
+}
+
+mod extern_exports {
+    pub(super) mod private_inner {
+        #[macro_export]
+        macro_rules! pub_in_private {
+            ($name:ident) => {
+                let $name = String::from("secrets and lies");
+            };
+        }
+    }
+}
diff --git a/tests/ui/macro_use_import.rs b/tests/ui/macro_use_import.rs
deleted file mode 100644
index 6490a2107d5..00000000000
--- a/tests/ui/macro_use_import.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-// compile-flags: --edition 2018
-#![warn(clippy::macro_use_import)]
-
-use std::collections::HashMap;
-#[macro_use]
-use std::prelude;
-
-fn main() {
-    let _ = HashMap::<u8, u8>::new();
-    serde_if_integer128!("");
-    println!();
-}
diff --git a/tests/ui/macro_use_import.stderr b/tests/ui/macro_use_import.stderr
deleted file mode 100644
index 1d86ba58441..00000000000
--- a/tests/ui/macro_use_import.stderr
+++ /dev/null
@@ -1,10 +0,0 @@
-error: `macro_use` attributes are no longer needed in the Rust 2018 edition
-  --> $DIR/macro_use_import.rs:5:1
-   |
-LL | #[macro_use]
-   | ^^^^^^^^^^^^ help: remove the attribute and import the macro directly, try: `use std::prelude::<macro name>`
-   |
-   = note: `-D clippy::macro-use-import` implied by `-D warnings`
-
-error: aborting due to previous error
-
diff --git a/tests/ui/macro_use_imports.rs b/tests/ui/macro_use_imports.rs
index 60c64ee8146..76911b0c565 100644
--- a/tests/ui/macro_use_imports.rs
+++ b/tests/ui/macro_use_imports.rs
@@ -1,11 +1,40 @@
-// edition:2018
+// compile-flags: --edition 2018
+// aux-build:macro_rules.rs
+// aux-build:macro_use_helper.rs
+
+#![allow(clippy::single_component_path_imports)]
 #![warn(clippy::macro_use_imports)]
 
-use std::collections::HashMap;
 #[macro_use]
-use std::prelude;
+extern crate macro_use_helper as mac;
+
+#[macro_use]
+extern crate clippy_mini_macro_test as mini_mac;
+
+mod a {
+    #[macro_use]
+    use std::prelude;
+    #[macro_use]
+    use mac;
+    #[macro_use]
+    use mini_mac;
+    #[macro_use]
+    use mac::inner;
+
+    #[derive(ClippyMiniMacroTest)]
+    struct Test;
+
+    fn main() {
+        pub_macro!();
+        inner_mod!();
+        pub_in_private!(_var);
+        function!();
+        let v: ty_mac!() = Vec::default();
+
+        inner::try_err!();
+    }
+}
 
 fn main() {
-    let _ = HashMap::<u8, u8>::new();
     println!();
 }
-- 
cgit 1.4.1-3-g733a5


From 8ffbf6f94d9cc77ade0596ee104f3549b8db452d Mon Sep 17 00:00:00 2001
From: Devin R <devin.ragotzy@gmail.com>
Date: Fri, 13 Mar 2020 18:54:32 -0400
Subject: use hashset not map for keeping track of seen macro refs

remove stdout, fix clippy warnings, fmtcar
---
 clippy_lints/src/macro_use.rs          | 131 ++++++++++++---------------------
 tests/ui/auxiliary/macro_use_helper.rs |   8 +-
 tests/ui/macro_use_import.stdout       |   0
 tests/ui/macro_use_imports.rs          |  14 ++--
 tests/ui/macro_use_imports.stderr      |  44 ++++++++++-
 5 files changed, 97 insertions(+), 100 deletions(-)
 delete mode 100644 tests/ui/macro_use_import.stdout

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/macro_use.rs b/clippy_lints/src/macro_use.rs
index 4c89647a574..9519fa6093b 100644
--- a/clippy_lints/src/macro_use.rs
+++ b/clippy_lints/src/macro_use.rs
@@ -2,7 +2,7 @@ use crate::utils::{in_macro, snippet, span_lint_and_sugg};
 use hir::def::{DefKind, Res};
 use if_chain::if_chain;
 use rustc_ast::ast;
-use rustc_data_structures::fx::FxHashMap;
+use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass, LintContext};
@@ -29,7 +29,7 @@ declare_clippy_lint! {
 
 const BRACKETS: &[char] = &['<', '>'];
 
-/// MacroRefData includes the name of the macro
+/// `MacroRefData` includes the name of the macro
 /// and the path from `SourceMap::span_to_filename`.
 #[derive(Debug, Clone)]
 pub struct MacroRefData {
@@ -38,11 +38,11 @@ pub struct MacroRefData {
 }
 
 impl MacroRefData {
-    pub fn new(name: String, span: Span, ecx: &LateContext<'_, '_>) -> Self {
+    pub fn new(name: &str, span: Span, ecx: &LateContext<'_, '_>) -> Self {
         let mut path = ecx.sess().source_map().span_to_filename(span).to_string();
 
         // std lib paths are <::std::module::file type>
-        // so remove brackets and space
+        // so remove brackets, space and type.
         if path.contains('<') {
             path = path.replace(BRACKETS, "");
         }
@@ -57,13 +57,12 @@ impl MacroRefData {
 }
 
 #[derive(Default)]
+#[allow(clippy::module_name_repetitions)]
 pub struct MacroUseImports {
     /// the actual import path used and the span of the attribute above it.
     imports: Vec<(String, Span)>,
-    /// the span of the macro reference and the `MacroRefData`
-    /// for the use of the macro.
-    /// TODO make this FxHashSet<Span> to guard against inserting already found macros
-    collected: FxHashMap<Span, MacroRefData>,
+    /// the span of the macro reference, kept to ensure only one reference is used per macro call.
+    collected: FxHashSet<Span>,
     mac_refs: Vec<(Span, MacroRefData)>,
 }
 
@@ -72,34 +71,28 @@ impl_lint_pass!(MacroUseImports => [MACRO_USE_IMPORTS]);
 impl<'l, 'txc> LateLintPass<'l, 'txc> for MacroUseImports {
     fn check_item(&mut self, lcx: &LateContext<'_, '_>, item: &hir::Item<'_>) {
         if_chain! {
-            if lcx.sess().opts.edition == Edition::Edition2018;
-            if let hir::ItemKind::Use(path, _kind) = &item.kind;
-            if let Some(mac_attr) = item
-                .attrs
-                .iter()
-                .find(|attr| attr.ident().map(|s| s.to_string()) == Some("macro_use".to_string()));
-            if let Res::Def(DefKind::Mod, id) = path.res;
-            then {
-                // println!("{:#?}", lcx.tcx.def_path_str(id));
-                for kid in lcx.tcx.item_children(id).iter() {
-                    // println!("{:#?}", kid);
-                    if let Res::Def(DefKind::Macro(_mac_type), mac_id) = kid.res {
-                        let span = mac_attr.span.clone();
-
-                        // println!("{:#?}", lcx.tcx.def_path_str(mac_id));
-
-                        self.imports.push((lcx.tcx.def_path_str(mac_id), span));
+                if lcx.sess().opts.edition == Edition::Edition2018;
+                if let hir::ItemKind::Use(path, _kind) = &item.kind;
+                if let Some(mac_attr) = item
+                    .attrs
+                    .iter()
+                    .find(|attr| attr.ident().map(|s| s.to_string()) == Some("macro_use".to_string()));
+                if let Res::Def(DefKind::Mod, id) = path.res;
+                then {
+                    for kid in lcx.tcx.item_children(id).iter() {
+                        if let Res::Def(DefKind::Macro(_mac_type), mac_id) = kid.res {
+                            let span = mac_attr.span;
+                            self.imports.push((lcx.tcx.def_path_str(mac_id), span));
+                        }
                     }
-                }
-            } else {
+                } else {
                 if in_macro(item.span) {
                     let call_site = item.span.source_callsite();
                     let name = snippet(lcx, lcx.sess().source_map().span_until_char(call_site, '!'), "_");
                     if let Some(callee) = item.span.source_callee() {
-                        if !self.collected.contains_key(&call_site) {
-                            let mac = MacroRefData::new(name.to_string(), callee.def_site, lcx);
-                            self.mac_refs.push((call_site, mac.clone()));
-                            self.collected.insert(call_site, mac);
+                        if !self.collected.contains(&call_site) {
+                            self.mac_refs.push((call_site, MacroRefData::new(&name, callee.def_site, lcx)));
+                            self.collected.insert(call_site);
                         }
                     }
                 }
@@ -111,18 +104,16 @@ impl<'l, 'txc> LateLintPass<'l, 'txc> for MacroUseImports {
             let call_site = attr.span.source_callsite();
             let name = snippet(lcx, lcx.sess().source_map().span_until_char(call_site, '!'), "_");
             if let Some(callee) = attr.span.source_callee() {
-                if !self.collected.contains_key(&call_site) {
-                    println!("{:?}\n{:#?}", call_site, attr);
-
+                if !self.collected.contains(&call_site) {
                     let name = if name.contains("::") {
                         name.split("::").last().unwrap().to_string()
                     } else {
                         name.to_string()
                     };
 
-                    let mac = MacroRefData::new(name, callee.def_site, lcx);
-                    self.mac_refs.push((call_site, mac.clone()));
-                    self.collected.insert(call_site, mac);
+                    self.mac_refs
+                        .push((call_site, MacroRefData::new(&name, callee.def_site, lcx)));
+                    self.collected.insert(call_site);
                 }
             }
         }
@@ -132,16 +123,16 @@ impl<'l, 'txc> LateLintPass<'l, 'txc> for MacroUseImports {
             let call_site = expr.span.source_callsite();
             let name = snippet(lcx, lcx.sess().source_map().span_until_char(call_site, '!'), "_");
             if let Some(callee) = expr.span.source_callee() {
-                if !self.collected.contains_key(&call_site) {
+                if !self.collected.contains(&call_site) {
                     let name = if name.contains("::") {
                         name.split("::").last().unwrap().to_string()
                     } else {
                         name.to_string()
                     };
 
-                    let mac = MacroRefData::new(name, callee.def_site, lcx);
-                    self.mac_refs.push((call_site, mac.clone()));
-                    self.collected.insert(call_site, mac);
+                    self.mac_refs
+                        .push((call_site, MacroRefData::new(&name, callee.def_site, lcx)));
+                    self.collected.insert(call_site);
                 }
             }
         }
@@ -151,16 +142,16 @@ impl<'l, 'txc> LateLintPass<'l, 'txc> for MacroUseImports {
             let call_site = stmt.span.source_callsite();
             let name = snippet(lcx, lcx.sess().source_map().span_until_char(call_site, '!'), "_");
             if let Some(callee) = stmt.span.source_callee() {
-                if !self.collected.contains_key(&call_site) {
+                if !self.collected.contains(&call_site) {
                     let name = if name.contains("::") {
                         name.split("::").last().unwrap().to_string()
                     } else {
                         name.to_string()
                     };
 
-                    let mac = MacroRefData::new(name, callee.def_site, lcx);
-                    self.mac_refs.push((call_site, mac.clone()));
-                    self.collected.insert(call_site, mac);
+                    self.mac_refs
+                        .push((call_site, MacroRefData::new(&name, callee.def_site, lcx)));
+                    self.collected.insert(call_site);
                 }
             }
         }
@@ -170,10 +161,10 @@ impl<'l, 'txc> LateLintPass<'l, 'txc> for MacroUseImports {
             let call_site = pat.span.source_callsite();
             let name = snippet(lcx, lcx.sess().source_map().span_until_char(call_site, '!'), "_");
             if let Some(callee) = pat.span.source_callee() {
-                if !self.collected.contains_key(&call_site) {
-                    let mac = MacroRefData::new(name.to_string(), callee.def_site, lcx);
-                    self.mac_refs.push((call_site, mac.clone()));
-                    self.collected.insert(call_site, mac);
+                if !self.collected.contains(&call_site) {
+                    self.mac_refs
+                        .push((call_site, MacroRefData::new(&name, callee.def_site, lcx)));
+                    self.collected.insert(call_site);
                 }
             }
         }
@@ -183,22 +174,18 @@ impl<'l, 'txc> LateLintPass<'l, 'txc> for MacroUseImports {
             let call_site = ty.span.source_callsite();
             let name = snippet(lcx, lcx.sess().source_map().span_until_char(call_site, '!'), "_");
             if let Some(callee) = ty.span.source_callee() {
-                if !self.collected.contains_key(&call_site) {
-                    let mac = MacroRefData::new(name.to_string(), callee.def_site, lcx);
-                    self.mac_refs.push((call_site, mac.clone()));
-                    self.collected.insert(call_site, mac);
+                if !self.collected.contains(&call_site) {
+                    self.mac_refs
+                        .push((call_site, MacroRefData::new(&name, callee.def_site, lcx)));
+                    self.collected.insert(call_site);
                 }
             }
         }
     }
 
     fn check_crate_post(&mut self, lcx: &LateContext<'_, '_>, _krate: &hir::Crate<'_>) {
-        for (import, span) in self.imports.iter() {
-            let matched = self
-                .mac_refs
-                .iter()
-                .find(|(_span, mac)| import.ends_with(&mac.name))
-                .is_some();
+        for (import, span) in &self.imports {
+            let matched = self.mac_refs.iter().any(|(_span, mac)| import.ends_with(&mac.name));
 
             if matched {
                 self.mac_refs.retain(|(_span, mac)| !import.ends_with(&mac.name));
@@ -218,30 +205,8 @@ impl<'l, 'txc> LateLintPass<'l, 'txc> for MacroUseImports {
         if !self.mac_refs.is_empty() {
             // TODO if not empty we found one we could not make a suggestion for
             // such as std::prelude::v1 or something else I haven't thought of.
-            // println!("{:#?}", self.mac_refs);
+            // If we defer the calling of span_lint_and_sugg we can make a decision about its
+            // applicability?
         }
     }
 }
-
-const PRELUDE: &[&str] = &[
-    "marker", "ops", "convert", "iter", "option", "result", "borrow", "boxed", "string", "vec", "macros",
-];
-
-/// This is somewhat of a fallback for imports from `std::prelude` because they
-/// are not recognized by `LateLintPass::check_item` `lcx.tcx.item_children(id)`
-fn make_path(mac: &MacroRefData, use_path: &str) -> String {
-    let segs = mac.path.split("::").filter(|s| *s != "").collect::<Vec<_>>();
-
-    if segs.starts_with(&["std"]) && PRELUDE.iter().any(|m| segs.contains(m)) {
-        return format!(
-            "std::prelude::{} is imported by default, remove `use` statement",
-            mac.name
-        );
-    }
-
-    if use_path.split("::").count() == 1 {
-        return format!("{}::{}", use_path, mac.name);
-    }
-
-    mac.path.clone()
-}
diff --git a/tests/ui/auxiliary/macro_use_helper.rs b/tests/ui/auxiliary/macro_use_helper.rs
index c63149a6819..7cc4e1d736a 100644
--- a/tests/ui/auxiliary/macro_use_helper.rs
+++ b/tests/ui/auxiliary/macro_use_helper.rs
@@ -17,7 +17,7 @@ pub mod inner {
 
     // ITEM
     #[macro_export]
-    macro_rules! inner_mod {
+    macro_rules! inner_mod_macro {
         () => {
             #[allow(dead_code)]
             pub struct Tardis;
@@ -27,7 +27,7 @@ pub mod inner {
 
 // EXPR
 #[macro_export]
-macro_rules! function {
+macro_rules! function_macro {
     () => {
         if true {
         } else {
@@ -37,7 +37,7 @@ macro_rules! function {
 
 // TYPE
 #[macro_export]
-macro_rules! ty_mac {
+macro_rules! ty_macro {
     () => {
         Vec<u8>
     };
@@ -46,7 +46,7 @@ macro_rules! ty_mac {
 mod extern_exports {
     pub(super) mod private_inner {
         #[macro_export]
-        macro_rules! pub_in_private {
+        macro_rules! pub_in_private_macro {
             ($name:ident) => {
                 let $name = String::from("secrets and lies");
             };
diff --git a/tests/ui/macro_use_import.stdout b/tests/ui/macro_use_import.stdout
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/tests/ui/macro_use_imports.rs b/tests/ui/macro_use_imports.rs
index 76911b0c565..bc8762df593 100644
--- a/tests/ui/macro_use_imports.rs
+++ b/tests/ui/macro_use_imports.rs
@@ -12,8 +12,6 @@ extern crate macro_use_helper as mac;
 extern crate clippy_mini_macro_test as mini_mac;
 
 mod a {
-    #[macro_use]
-    use std::prelude;
     #[macro_use]
     use mac;
     #[macro_use]
@@ -26,15 +24,13 @@ mod a {
 
     fn main() {
         pub_macro!();
-        inner_mod!();
-        pub_in_private!(_var);
-        function!();
-        let v: ty_mac!() = Vec::default();
+        inner_mod_macro!();
+        pub_in_private_macro!(_var);
+        function_macro!();
+        let v: ty_macro!() = Vec::default();
 
         inner::try_err!();
     }
 }
 
-fn main() {
-    println!();
-}
+fn main() {}
diff --git a/tests/ui/macro_use_imports.stderr b/tests/ui/macro_use_imports.stderr
index b5e3dbec572..6bcacd0be19 100644
--- a/tests/ui/macro_use_imports.stderr
+++ b/tests/ui/macro_use_imports.stderr
@@ -1,10 +1,46 @@
 error: `macro_use` attributes are no longer needed in the Rust 2018 edition
-  --> $DIR/macro_use_imports.rs:5:1
+  --> $DIR/macro_use_imports.rs:15:5
    |
-LL | #[macro_use]
-   | ^^^^^^^^^^^^ help: remove the attribute and import the macro directly, try: `use std::prelude::<macro name>`
+LL |     #[macro_use]
+   |     ^^^^^^^^^^^^ help: remove the attribute and import the macro directly, try: `use mac::pub_macro`
    |
    = note: `-D clippy::macro-use-imports` implied by `-D warnings`
 
-error: aborting due to previous error
+error: `macro_use` attributes are no longer needed in the Rust 2018 edition
+  --> $DIR/macro_use_imports.rs:15:5
+   |
+LL |     #[macro_use]
+   |     ^^^^^^^^^^^^ help: remove the attribute and import the macro directly, try: `use mac::inner_mod_macro`
+
+error: `macro_use` attributes are no longer needed in the Rust 2018 edition
+  --> $DIR/macro_use_imports.rs:15:5
+   |
+LL |     #[macro_use]
+   |     ^^^^^^^^^^^^ help: remove the attribute and import the macro directly, try: `use mac::function_macro`
+
+error: `macro_use` attributes are no longer needed in the Rust 2018 edition
+  --> $DIR/macro_use_imports.rs:15:5
+   |
+LL |     #[macro_use]
+   |     ^^^^^^^^^^^^ help: remove the attribute and import the macro directly, try: `use mac::ty_macro`
+
+error: `macro_use` attributes are no longer needed in the Rust 2018 edition
+  --> $DIR/macro_use_imports.rs:15:5
+   |
+LL |     #[macro_use]
+   |     ^^^^^^^^^^^^ help: remove the attribute and import the macro directly, try: `use mac::pub_in_private_macro`
+
+error: `macro_use` attributes are no longer needed in the Rust 2018 edition
+  --> $DIR/macro_use_imports.rs:17:5
+   |
+LL |     #[macro_use]
+   |     ^^^^^^^^^^^^ help: remove the attribute and import the macro directly, try: `use mini_mac::ClippyMiniMacroTest`
+
+error: `macro_use` attributes are no longer needed in the Rust 2018 edition
+  --> $DIR/macro_use_imports.rs:19:5
+   |
+LL |     #[macro_use]
+   |     ^^^^^^^^^^^^ help: remove the attribute and import the macro directly, try: `use mac::inner::try_err`
+
+error: aborting due to 7 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 1d9e80ad7b5b69caa8b9f9c44d47f26c4bbc4c7b Mon Sep 17 00:00:00 2001
From: Devin R <devin.ragotzy@gmail.com>
Date: Mon, 23 Mar 2020 22:13:35 -0400
Subject: remove session

---
 clippy_lints/src/lib.rs | 1 -
 1 file changed, 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 89f55986f63..991899f89bc 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -60,7 +60,6 @@ extern crate rustc_trait_selection;
 #[allow(unused_extern_crates)]
 extern crate rustc_typeck;
 
-use rustc::session::Session;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_lint::LintId;
 use rustc_session::Session;
-- 
cgit 1.4.1-3-g733a5


From 8bc106b29d3d2ee382f6dc4a2e9d6eecf534c6ed Mon Sep 17 00:00:00 2001
From: Devin R <devin.ragotzy@gmail.com>
Date: Sun, 10 May 2020 09:06:33 -0400
Subject: fix some of the review, rename, fmt, refactor

---
 clippy_lints/src/lib.rs       |   3 +-
 clippy_lints/src/macro_use.rs | 130 ++++++++++++++++++------------------------
 tests/ui/macro_use_imports.rs |   2 +-
 3 files changed, 60 insertions(+), 75 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 991899f89bc..021fbe932d8 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1060,7 +1060,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     let max_struct_bools = conf.max_struct_bools;
     store.register_early_pass(move || box excessive_bools::ExcessiveBools::new(max_struct_bools, max_fn_params_bools));
     store.register_early_pass(|| box option_env_unwrap::OptionEnvUnwrap);
-    store.register_late_pass(|| box wildcard_imports::WildcardImports);
+    let warn_on_all_wildcard_imports = conf.warn_on_all_wildcard_imports;
+    store.register_late_pass(move || box wildcard_imports::WildcardImports::new(warn_on_all_wildcard_imports));
     store.register_late_pass(|| box verbose_file_reads::VerboseFileReads);
     store.register_late_pass(|| box redundant_pub_crate::RedundantPubCrate::default());
     store.register_late_pass(|| box unnamed_address::UnnamedAddress);
diff --git a/clippy_lints/src/macro_use.rs b/clippy_lints/src/macro_use.rs
index 9519fa6093b..9c8035f54a9 100644
--- a/clippy_lints/src/macro_use.rs
+++ b/clippy_lints/src/macro_use.rs
@@ -38,8 +38,8 @@ pub struct MacroRefData {
 }
 
 impl MacroRefData {
-    pub fn new(name: &str, span: Span, ecx: &LateContext<'_, '_>) -> Self {
-        let mut path = ecx.sess().source_map().span_to_filename(span).to_string();
+    pub fn new(name: &str, callee: Span, cx: &LateContext<'_, '_>) -> Self {
+        let mut path = cx.sess().source_map().span_to_filename(callee).to_string();
 
         // std lib paths are <::std::module::file type>
         // so remove brackets, space and type.
@@ -63,15 +63,37 @@ pub struct MacroUseImports {
     imports: Vec<(String, Span)>,
     /// the span of the macro reference, kept to ensure only one reference is used per macro call.
     collected: FxHashSet<Span>,
-    mac_refs: Vec<(Span, MacroRefData)>,
+    mac_refs: Vec<MacroRefData>,
 }
 
 impl_lint_pass!(MacroUseImports => [MACRO_USE_IMPORTS]);
 
+impl MacroUseImports {
+    fn push_unique_macro(&mut self, cx: &LateContext<'_, '_>, name: &str, call_site: Span, callee: Span) {
+        if !self.collected.contains(&call_site) {
+            let name = if name.contains("::") {
+                name.split("::").last().unwrap().to_string()
+            } else {
+                name.to_string()
+            };
+
+            self.mac_refs.push(MacroRefData::new(&name, callee, cx));
+            self.collected.insert(call_site);
+        }
+    }
+
+    fn push_unique_macro_pat_ty(&mut self, cx: &LateContext<'_, '_>, name: &str, call_site: Span, callee: Span) {
+        if !self.collected.contains(&call_site) {
+            self.mac_refs.push(MacroRefData::new(&name, callee, cx));
+            self.collected.insert(call_site);
+        }
+    }
+}
+
 impl<'l, 'txc> LateLintPass<'l, 'txc> for MacroUseImports {
-    fn check_item(&mut self, lcx: &LateContext<'_, '_>, item: &hir::Item<'_>) {
+    fn check_item(&mut self, cx: &LateContext<'_, '_>, item: &hir::Item<'_>) {
         if_chain! {
-                if lcx.sess().opts.edition == Edition::Edition2018;
+                if cx.sess().opts.edition == Edition::Edition2018;
                 if let hir::ItemKind::Use(path, _kind) = &item.kind;
                 if let Some(mac_attr) = item
                     .attrs
@@ -79,126 +101,88 @@ impl<'l, 'txc> LateLintPass<'l, 'txc> for MacroUseImports {
                     .find(|attr| attr.ident().map(|s| s.to_string()) == Some("macro_use".to_string()));
                 if let Res::Def(DefKind::Mod, id) = path.res;
                 then {
-                    for kid in lcx.tcx.item_children(id).iter() {
+                    for kid in cx.tcx.item_children(id).iter() {
                         if let Res::Def(DefKind::Macro(_mac_type), mac_id) = kid.res {
                             let span = mac_attr.span;
-                            self.imports.push((lcx.tcx.def_path_str(mac_id), span));
+                            self.imports.push((cx.tcx.def_path_str(mac_id), span));
                         }
                     }
                 } else {
-                if in_macro(item.span) {
-                    let call_site = item.span.source_callsite();
-                    let name = snippet(lcx, lcx.sess().source_map().span_until_char(call_site, '!'), "_");
-                    if let Some(callee) = item.span.source_callee() {
-                        if !self.collected.contains(&call_site) {
-                            self.mac_refs.push((call_site, MacroRefData::new(&name, callee.def_site, lcx)));
-                            self.collected.insert(call_site);
+                    if in_macro(item.span) {
+                        let call_site = item.span.source_callsite();
+                        let name = snippet(cx, cx.sess().source_map().span_until_char(call_site, '!'), "_");
+                        if let Some(callee) = item.span.source_callee() {
+                            if !self.collected.contains(&call_site) {
+                                self.mac_refs.push(MacroRefData::new(&name, callee.def_site, cx));
+                                self.collected.insert(call_site);
+                            }
                         }
                     }
-                }
             }
         }
     }
-    fn check_attribute(&mut self, lcx: &LateContext<'_, '_>, attr: &ast::Attribute) {
+    fn check_attribute(&mut self, cx: &LateContext<'_, '_>, attr: &ast::Attribute) {
         if in_macro(attr.span) {
             let call_site = attr.span.source_callsite();
-            let name = snippet(lcx, lcx.sess().source_map().span_until_char(call_site, '!'), "_");
+            let name = snippet(cx, cx.sess().source_map().span_until_char(call_site, '!'), "_");
             if let Some(callee) = attr.span.source_callee() {
-                if !self.collected.contains(&call_site) {
-                    let name = if name.contains("::") {
-                        name.split("::").last().unwrap().to_string()
-                    } else {
-                        name.to_string()
-                    };
-
-                    self.mac_refs
-                        .push((call_site, MacroRefData::new(&name, callee.def_site, lcx)));
-                    self.collected.insert(call_site);
-                }
+                self.push_unique_macro(cx, &name, call_site, callee.def_site);
             }
         }
     }
-    fn check_expr(&mut self, lcx: &LateContext<'_, '_>, expr: &hir::Expr<'_>) {
+    fn check_expr(&mut self, cx: &LateContext<'_, '_>, expr: &hir::Expr<'_>) {
         if in_macro(expr.span) {
             let call_site = expr.span.source_callsite();
-            let name = snippet(lcx, lcx.sess().source_map().span_until_char(call_site, '!'), "_");
+            let name = snippet(cx, cx.sess().source_map().span_until_char(call_site, '!'), "_");
             if let Some(callee) = expr.span.source_callee() {
-                if !self.collected.contains(&call_site) {
-                    let name = if name.contains("::") {
-                        name.split("::").last().unwrap().to_string()
-                    } else {
-                        name.to_string()
-                    };
-
-                    self.mac_refs
-                        .push((call_site, MacroRefData::new(&name, callee.def_site, lcx)));
-                    self.collected.insert(call_site);
-                }
+                self.push_unique_macro(cx, &name, call_site, callee.def_site);
             }
         }
     }
-    fn check_stmt(&mut self, lcx: &LateContext<'_, '_>, stmt: &hir::Stmt<'_>) {
+    fn check_stmt(&mut self, cx: &LateContext<'_, '_>, stmt: &hir::Stmt<'_>) {
         if in_macro(stmt.span) {
             let call_site = stmt.span.source_callsite();
-            let name = snippet(lcx, lcx.sess().source_map().span_until_char(call_site, '!'), "_");
+            let name = snippet(cx, cx.sess().source_map().span_until_char(call_site, '!'), "_");
             if let Some(callee) = stmt.span.source_callee() {
-                if !self.collected.contains(&call_site) {
-                    let name = if name.contains("::") {
-                        name.split("::").last().unwrap().to_string()
-                    } else {
-                        name.to_string()
-                    };
-
-                    self.mac_refs
-                        .push((call_site, MacroRefData::new(&name, callee.def_site, lcx)));
-                    self.collected.insert(call_site);
-                }
+                self.push_unique_macro(cx, &name, call_site, callee.def_site);
             }
         }
     }
-    fn check_pat(&mut self, lcx: &LateContext<'_, '_>, pat: &hir::Pat<'_>) {
+    fn check_pat(&mut self, cx: &LateContext<'_, '_>, pat: &hir::Pat<'_>) {
         if in_macro(pat.span) {
             let call_site = pat.span.source_callsite();
-            let name = snippet(lcx, lcx.sess().source_map().span_until_char(call_site, '!'), "_");
+            let name = snippet(cx, cx.sess().source_map().span_until_char(call_site, '!'), "_");
             if let Some(callee) = pat.span.source_callee() {
-                if !self.collected.contains(&call_site) {
-                    self.mac_refs
-                        .push((call_site, MacroRefData::new(&name, callee.def_site, lcx)));
-                    self.collected.insert(call_site);
-                }
+                self.push_unique_macro_pat_ty(cx, &name, call_site, callee.def_site);
             }
         }
     }
-    fn check_ty(&mut self, lcx: &LateContext<'_, '_>, ty: &hir::Ty<'_>) {
+    fn check_ty(&mut self, cx: &LateContext<'_, '_>, ty: &hir::Ty<'_>) {
         if in_macro(ty.span) {
             let call_site = ty.span.source_callsite();
-            let name = snippet(lcx, lcx.sess().source_map().span_until_char(call_site, '!'), "_");
+            let name = snippet(cx, cx.sess().source_map().span_until_char(call_site, '!'), "_");
             if let Some(callee) = ty.span.source_callee() {
-                if !self.collected.contains(&call_site) {
-                    self.mac_refs
-                        .push((call_site, MacroRefData::new(&name, callee.def_site, lcx)));
-                    self.collected.insert(call_site);
-                }
+                self.push_unique_macro_pat_ty(cx, &name, call_site, callee.def_site);
             }
         }
     }
 
-    fn check_crate_post(&mut self, lcx: &LateContext<'_, '_>, _krate: &hir::Crate<'_>) {
+    fn check_crate_post(&mut self, cx: &LateContext<'_, '_>, _krate: &hir::Crate<'_>) {
         for (import, span) in &self.imports {
-            let matched = self.mac_refs.iter().any(|(_span, mac)| import.ends_with(&mac.name));
+            let matched = self.mac_refs.iter().any(|mac| import.ends_with(&mac.name));
 
             if matched {
-                self.mac_refs.retain(|(_span, mac)| !import.ends_with(&mac.name));
+                self.mac_refs.retain(|mac| !import.ends_with(&mac.name));
                 let msg = "`macro_use` attributes are no longer needed in the Rust 2018 edition";
                 let help = format!("use {}", import);
                 span_lint_and_sugg(
-                    lcx,
+                    cx,
                     MACRO_USE_IMPORTS,
                     *span,
                     msg,
                     "remove the attribute and import the macro directly, try",
                     help,
-                    Applicability::HasPlaceholders,
+                    Applicability::MaybeIncorrect,
                 )
             }
         }
diff --git a/tests/ui/macro_use_imports.rs b/tests/ui/macro_use_imports.rs
index bc8762df593..2d4f71e5d53 100644
--- a/tests/ui/macro_use_imports.rs
+++ b/tests/ui/macro_use_imports.rs
@@ -22,7 +22,7 @@ mod a {
     #[derive(ClippyMiniMacroTest)]
     struct Test;
 
-    fn main() {
+    fn test() {
         pub_macro!();
         inner_mod_macro!();
         pub_in_private_macro!(_var);
-- 
cgit 1.4.1-3-g733a5


From 451363dc59b3030fee82e4faf04684c068f619cc Mon Sep 17 00:00:00 2001
From: Devin R <devin.ragotzy@gmail.com>
Date: Thu, 14 May 2020 18:20:07 -0400
Subject: still working on displaying nested imports

---
 clippy_lints/src/macro_use.rs | 291 +++++++++++++++++++++++++++++++-----------
 1 file changed, 214 insertions(+), 77 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/macro_use.rs b/clippy_lints/src/macro_use.rs
index 9c8035f54a9..8dddd6d716d 100644
--- a/clippy_lints/src/macro_use.rs
+++ b/clippy_lints/src/macro_use.rs
@@ -2,7 +2,7 @@ use crate::utils::{in_macro, snippet, span_lint_and_sugg};
 use hir::def::{DefKind, Res};
 use if_chain::if_chain;
 use rustc_ast::ast;
-use rustc_data_structures::fx::FxHashSet;
+use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass, LintContext};
@@ -38,7 +38,7 @@ pub struct MacroRefData {
 }
 
 impl MacroRefData {
-    pub fn new(name: &str, callee: Span, cx: &LateContext<'_, '_>) -> Self {
+    pub fn new(name: String, callee: Span, cx: &LateContext<'_, '_>) -> Self {
         let mut path = cx.sess().source_map().span_to_filename(callee).to_string();
 
         // std lib paths are <::std::module::file type>
@@ -50,7 +50,7 @@ impl MacroRefData {
             path = path.split(' ').next().unwrap().to_string();
         }
         Self {
-            name: name.to_string(),
+            name,
             path,
         }
     }
@@ -69,23 +69,31 @@ pub struct MacroUseImports {
 impl_lint_pass!(MacroUseImports => [MACRO_USE_IMPORTS]);
 
 impl MacroUseImports {
-    fn push_unique_macro(&mut self, cx: &LateContext<'_, '_>, name: &str, call_site: Span, callee: Span) {
-        if !self.collected.contains(&call_site) {
-            let name = if name.contains("::") {
-                name.split("::").last().unwrap().to_string()
-            } else {
-                name.to_string()
-            };
-
-            self.mac_refs.push(MacroRefData::new(&name, callee, cx));
-            self.collected.insert(call_site);
+    fn push_unique_macro(&mut self, cx: &LateContext<'_, '_>, span: Span) {
+        let call_site = span.source_callsite();
+        let name = snippet(cx, cx.sess().source_map().span_until_char(call_site, '!'), "_");
+        if let Some(callee) = span.source_callee() {
+            if !self.collected.contains(&call_site) {
+                let name = if name.contains("::") {
+                    name.split("::").last().unwrap().to_string()
+                } else {
+                    name.to_string()
+                };
+    
+                self.mac_refs.push(MacroRefData::new(name, callee.def_site, cx));
+                self.collected.insert(call_site);
+            }
         }
     }
 
-    fn push_unique_macro_pat_ty(&mut self, cx: &LateContext<'_, '_>, name: &str, call_site: Span, callee: Span) {
-        if !self.collected.contains(&call_site) {
-            self.mac_refs.push(MacroRefData::new(&name, callee, cx));
-            self.collected.insert(call_site);
+    fn push_unique_macro_pat_ty(&mut self, cx: &LateContext<'_, '_>, span: Span) {
+        let call_site = span.source_callsite();
+        let name = snippet(cx, cx.sess().source_map().span_until_char(call_site, '!'), "_");
+        if let Some(callee) = span.source_callee() {
+            if !self.collected.contains(&call_site) {
+                self.mac_refs.push(MacroRefData::new(name.to_string(), callee.def_site, cx));
+                self.collected.insert(call_site);
+            }
         }
     }
 }
@@ -93,104 +101,233 @@ impl MacroUseImports {
 impl<'l, 'txc> LateLintPass<'l, 'txc> for MacroUseImports {
     fn check_item(&mut self, cx: &LateContext<'_, '_>, item: &hir::Item<'_>) {
         if_chain! {
-                if cx.sess().opts.edition == Edition::Edition2018;
-                if let hir::ItemKind::Use(path, _kind) = &item.kind;
-                if let Some(mac_attr) = item
-                    .attrs
-                    .iter()
-                    .find(|attr| attr.ident().map(|s| s.to_string()) == Some("macro_use".to_string()));
-                if let Res::Def(DefKind::Mod, id) = path.res;
-                then {
-                    for kid in cx.tcx.item_children(id).iter() {
-                        if let Res::Def(DefKind::Macro(_mac_type), mac_id) = kid.res {
-                            let span = mac_attr.span;
-                            self.imports.push((cx.tcx.def_path_str(mac_id), span));
-                        }
-                    }
-                } else {
-                    if in_macro(item.span) {
-                        let call_site = item.span.source_callsite();
-                        let name = snippet(cx, cx.sess().source_map().span_until_char(call_site, '!'), "_");
-                        if let Some(callee) = item.span.source_callee() {
-                            if !self.collected.contains(&call_site) {
-                                self.mac_refs.push(MacroRefData::new(&name, callee.def_site, cx));
-                                self.collected.insert(call_site);
-                            }
-                        }
+            if cx.sess().opts.edition == Edition::Edition2018;
+            if let hir::ItemKind::Use(path, _kind) = &item.kind;
+            if let Some(mac_attr) = item
+                .attrs
+                .iter()
+                .find(|attr| attr.ident().map(|s| s.to_string()) == Some("macro_use".to_string()));
+            if let Res::Def(DefKind::Mod, id) = path.res;
+            then {
+                for kid in cx.tcx.item_children(id).iter() {
+                    if let Res::Def(DefKind::Macro(_mac_type), mac_id) = kid.res {
+                        let span = mac_attr.span;
+                        self.imports.push((cx.tcx.def_path_str(mac_id), span));
                     }
+                }
+            } else {
+                if in_macro(item.span) {
+                    self.push_unique_macro_pat_ty(cx, item.span);
+                }
             }
         }
     }
     fn check_attribute(&mut self, cx: &LateContext<'_, '_>, attr: &ast::Attribute) {
         if in_macro(attr.span) {
-            let call_site = attr.span.source_callsite();
-            let name = snippet(cx, cx.sess().source_map().span_until_char(call_site, '!'), "_");
-            if let Some(callee) = attr.span.source_callee() {
-                self.push_unique_macro(cx, &name, call_site, callee.def_site);
-            }
+            self.push_unique_macro(cx, attr.span);
         }
     }
     fn check_expr(&mut self, cx: &LateContext<'_, '_>, expr: &hir::Expr<'_>) {
         if in_macro(expr.span) {
-            let call_site = expr.span.source_callsite();
-            let name = snippet(cx, cx.sess().source_map().span_until_char(call_site, '!'), "_");
-            if let Some(callee) = expr.span.source_callee() {
-                self.push_unique_macro(cx, &name, call_site, callee.def_site);
-            }
+            self.push_unique_macro(cx, expr.span);
         }
     }
     fn check_stmt(&mut self, cx: &LateContext<'_, '_>, stmt: &hir::Stmt<'_>) {
         if in_macro(stmt.span) {
-            let call_site = stmt.span.source_callsite();
-            let name = snippet(cx, cx.sess().source_map().span_until_char(call_site, '!'), "_");
-            if let Some(callee) = stmt.span.source_callee() {
-                self.push_unique_macro(cx, &name, call_site, callee.def_site);
-            }
+            self.push_unique_macro(cx, stmt.span);
         }
     }
     fn check_pat(&mut self, cx: &LateContext<'_, '_>, pat: &hir::Pat<'_>) {
         if in_macro(pat.span) {
-            let call_site = pat.span.source_callsite();
-            let name = snippet(cx, cx.sess().source_map().span_until_char(call_site, '!'), "_");
-            if let Some(callee) = pat.span.source_callee() {
-                self.push_unique_macro_pat_ty(cx, &name, call_site, callee.def_site);
-            }
+            self.push_unique_macro_pat_ty(cx, pat.span);
         }
     }
     fn check_ty(&mut self, cx: &LateContext<'_, '_>, ty: &hir::Ty<'_>) {
         if in_macro(ty.span) {
-            let call_site = ty.span.source_callsite();
-            let name = snippet(cx, cx.sess().source_map().span_until_char(call_site, '!'), "_");
-            if let Some(callee) = ty.span.source_callee() {
-                self.push_unique_macro_pat_ty(cx, &name, call_site, callee.def_site);
-            }
+            self.push_unique_macro_pat_ty(cx, ty.span);
         }
     }
 
     fn check_crate_post(&mut self, cx: &LateContext<'_, '_>, _krate: &hir::Crate<'_>) {
+        let mut import_map = FxHashMap::default();
         for (import, span) in &self.imports {
-            let matched = self.mac_refs.iter().any(|mac| import.ends_with(&mac.name));
+            let found_idx = self.mac_refs.iter().position(|mac| import.ends_with(&mac.name));
+            
+            if let Some(idx) = found_idx {
+                let _ = self.mac_refs.remove(idx);
+                proccess_macro_path(*span, import, &mut import_map);
+            }
+        }
+        println!("{:#?}", import_map);
+        let mut imports = vec![];
+        for (root, rest) in import_map {
+            let mut path = format!("use {}::", root);
+            let mut s = None;
+            let mut count = 1;
+            let rest_len = rest.len();
+            if rest_len > 1 {
+                path.push_str("{");
+            }
+            for m in &rest {
+                println!("{} => {:?}", root, m);
+                if count == 1 {
+                    s = Some(m.span());
+                }
+                
+                let comma = if rest_len == count { "" } else { ", " };
+                match m {
+                    ModPath::Item { item, .. } => {
+                        path.push_str(&format!("{}{}", item, comma));
+                    }
+                    ModPath::Nested { names, item, span } => {
+                        let nested = rest.iter()
+                            // filter "self" out
+                            .filter(|other_m| other_m != &m)
+                            // this matches the first path segment and filters non ModPath::Nested items
+                            .filter(|other_m| other_m.matches(0, m))
+                            .collect::<Vec<_>>();
+
+                        println!("{:#?}", nested);
+
+                        if nested.is_empty() {
+                            path.push_str(&format!("{}::{}{}", names.join("::").to_string(), item, comma))
+                        } else {
+                            // use mod_a::{mod_b::{one, two}, mod_c::item, item1, item2}
+                            let mod_path = if names.len() - 1 > 0 {
+                                ModPath::Nested { names: names.clone(), item: item.to_string(), span: *span, }
+                            } else {
+                                ModPath::Item { item: names[0].to_string(), span: *span, }
+                            };
+                            let names = recursive_path_push(mod_path, comma, &rest, String::new());
+                            path.push_str(&format!("{}::{{{}}}{}", names, item, comma))
+                        }
+                    }
+                }
+                count += 1;             
+            }
+            if rest_len > 1 {
+                path.push_str("};");
+            }
+            if let Some(span) = s {
+                imports.push((span, path))
+            }
+        }
 
-            if matched {
-                self.mac_refs.retain(|mac| !import.ends_with(&mac.name));
-                let msg = "`macro_use` attributes are no longer needed in the Rust 2018 edition";
+        if !self.mac_refs.is_empty() {
+            // TODO if not empty we found one we could not make a suggestion for
+            // such as std::prelude::v1 or something else I haven't thought of.
+            // If we defer the calling of span_lint_and_sugg we can make a decision about its
+            // applicability?
+        } else {
+            for (span, import) in imports {
                 let help = format!("use {}", import);
                 span_lint_and_sugg(
                     cx,
                     MACRO_USE_IMPORTS,
-                    *span,
-                    msg,
+                    span,
+                    "`macro_use` attributes are no longer needed in the Rust 2018 edition",
                     "remove the attribute and import the macro directly, try",
                     help,
                     Applicability::MaybeIncorrect,
                 )
             }
         }
-        if !self.mac_refs.is_empty() {
-            // TODO if not empty we found one we could not make a suggestion for
-            // such as std::prelude::v1 or something else I haven't thought of.
-            // If we defer the calling of span_lint_and_sugg we can make a decision about its
-            // applicability?
+    }
+}
+
+#[derive(Debug, PartialEq)]
+enum ModPath {
+    Item { item: String, span: Span, },
+    Nested { names: Vec<String>, item: String, span: Span, },
+}
+
+impl ModPath {
+    fn span(&self) -> Span {
+        match self {
+            Self::Item { span, .. } => *span,
+            Self::Nested { span, .. } => *span,
+        }
+    }
+
+    fn item(&self) -> &str {
+        match self {
+            Self::Item { item, .. } => item,
+            Self::Nested { item, .. } => item,
+        }
+    }
+
+    fn matches(&self, idx: usize, other: &ModPath) -> bool {
+        match (self, other) {
+            (Self::Item { item, .. }, Self::Item { item: other_item, .. }) => item == other_item,
+            (Self::Nested { names, .. }, Self::Nested { names: other_names, .. }) => {
+                match (names.get(idx), other_names.get(idx)) {
+                    (Some(seg), Some(other_seg)) => seg == other_seg,
+                    (_, _) => false,
+                }
+            }
+            (_, _) => false,
+        }
+    }
+}
+
+fn proccess_macro_path(span: Span, import: &str, import_map: &mut FxHashMap<String, Vec<ModPath>>) {
+    let mut mod_path = import.split("::").collect::<Vec<_>>();
+
+    if mod_path.len() == 2 {
+        let item_list = import_map.entry(mod_path[0].to_string())
+            .or_insert(vec![]);
+
+        if !item_list.iter().any(|mods| mods.item() == mod_path[1]) {
+            item_list.push(ModPath::Item{
+                item: mod_path[1].to_string(),
+                span,
+            });
+        }
+    } else if mod_path.len() > 2 {
+        let first = mod_path.remove(0);
+        let name = mod_path.remove(mod_path.len() - 1);
+
+        let nested = ModPath::Nested {
+            names: mod_path.into_iter().map(ToString::to_string).collect(),
+            item: name.to_string(),
+            span,
+        };
+        import_map.entry(first.to_string())
+            .or_insert(vec![])
+            .push(nested);
+    } else {
+        unreachable!("test to see if code path hit TODO REMOVE")
+    }
+}
+
+fn recursive_path_push(module: ModPath, comma: &str, rest: &[ModPath], mut path: String) -> String {
+    match &module {
+        ModPath::Item { item, .. } => {
+            path.push_str(&format!("{}{}", item, comma));
+        }
+        ModPath::Nested { names, item, span } => {
+            let nested = rest.iter()
+                // filter "self" out
+                .filter(|other_m| other_m != &&module)
+                // this matches the first path segment and filters non ModPath::Nested items
+                .filter(|other_m| other_m.matches(0, &module))
+                .collect::<Vec<_>>();
+
+            println!("{:#?}", nested);
+
+            if nested.is_empty() {
+                path.push_str(&format!("{}::{}{}", names.join("::").to_string(), item, comma))
+            } else {
+                // use mod_a::{mod_b::{one, two}, mod_c::item, item1, item2}
+                let mod_path = if names.len() - 1 > 0 {
+                    ModPath::Nested { names: names.clone(), item: item.to_string(), span: *span, }
+                } else {
+                    ModPath::Item { item: names[0].to_string(), span: *span, }
+                };
+                let names = recursive_path_push(mod_path, comma, rest, path.to_string());
+                // path.push_str(&format!("{}{}", item, comma));
+            }
         }
     }
+    path
 }
-- 
cgit 1.4.1-3-g733a5


From d4f60b5ff42a4e8b5889879664002f90dacd6c04 Mon Sep 17 00:00:00 2001
From: Devin R <devin.ragotzy@gmail.com>
Date: Fri, 15 May 2020 08:36:56 -0400
Subject: wip: of handling nested import paths for multi-macro paths

---
 clippy_lints/src/macro_use.rs          | 197 ++++++++++++++++++---------------
 tests/ui/auxiliary/macro_use_helper.rs |   5 +
 tests/ui/macro_use_imports.rs          |   4 +
 tests/ui/macro_use_imports.stderr      |  38 +------
 4 files changed, 122 insertions(+), 122 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/macro_use.rs b/clippy_lints/src/macro_use.rs
index 8dddd6d716d..1e1f27e9430 100644
--- a/clippy_lints/src/macro_use.rs
+++ b/clippy_lints/src/macro_use.rs
@@ -49,10 +49,7 @@ impl MacroRefData {
         if path.contains(' ') {
             path = path.split(' ').next().unwrap().to_string();
         }
-        Self {
-            name,
-            path,
-        }
+        Self { name, path }
     }
 }
 
@@ -79,7 +76,7 @@ impl MacroUseImports {
                 } else {
                     name.to_string()
                 };
-    
+
                 self.mac_refs.push(MacroRefData::new(name, callee.def_site, cx));
                 self.collected.insert(call_site);
             }
@@ -91,7 +88,8 @@ impl MacroUseImports {
         let name = snippet(cx, cx.sess().source_map().span_until_char(call_site, '!'), "_");
         if let Some(callee) = span.source_callee() {
             if !self.collected.contains(&call_site) {
-                self.mac_refs.push(MacroRefData::new(name.to_string(), callee.def_site, cx));
+                self.mac_refs
+                    .push(MacroRefData::new(name.to_string(), callee.def_site, cx));
                 self.collected.insert(call_site);
             }
         }
@@ -147,78 +145,123 @@ impl<'l, 'txc> LateLintPass<'l, 'txc> for MacroUseImports {
             self.push_unique_macro_pat_ty(cx, ty.span);
         }
     }
-
+    #[allow(clippy::too_many_lines)]
     fn check_crate_post(&mut self, cx: &LateContext<'_, '_>, _krate: &hir::Crate<'_>) {
         let mut import_map = FxHashMap::default();
         for (import, span) in &self.imports {
             let found_idx = self.mac_refs.iter().position(|mac| import.ends_with(&mac.name));
-            
+
             if let Some(idx) = found_idx {
                 let _ = self.mac_refs.remove(idx);
                 proccess_macro_path(*span, import, &mut import_map);
             }
         }
-        println!("{:#?}", import_map);
+        // println!("{:#?}", import_map);
         let mut imports = vec![];
         for (root, rest) in import_map {
             let mut path = format!("use {}::", root);
-            let mut s = None;
+            let mut attr_span = None;
+            // when a multiple nested paths are found one may be written to the string
+            // before it is found in this loop so we make note and skip it when this
+            // loop finds it
+            let mut found_nested = vec![];
             let mut count = 1;
             let rest_len = rest.len();
+
             if rest_len > 1 {
                 path.push_str("{");
             }
+
             for m in &rest {
-                println!("{} => {:?}", root, m);
-                if count == 1 {
-                    s = Some(m.span());
+                if attr_span.is_none() {
+                    attr_span = Some(m.span());
+                }
+                if found_nested.contains(&m) {
+                    continue;
                 }
-                
                 let comma = if rest_len == count { "" } else { ", " };
                 match m {
                     ModPath::Item { item, .. } => {
                         path.push_str(&format!("{}{}", item, comma));
-                    }
-                    ModPath::Nested { names, item, span } => {
-                        let nested = rest.iter()
+                    },
+                    ModPath::Nested { segments, item, .. } => {
+                        // do any other Nested paths match the current one
+                        let nested = rest
+                            .iter()
                             // filter "self" out
                             .filter(|other_m| other_m != &m)
+                            // filters out Nested we have previously seen
+                            .filter(|other_m| !found_nested.contains(other_m))
                             // this matches the first path segment and filters non ModPath::Nested items
                             .filter(|other_m| other_m.matches(0, m))
                             .collect::<Vec<_>>();
 
-                        println!("{:#?}", nested);
-
                         if nested.is_empty() {
-                            path.push_str(&format!("{}::{}{}", names.join("::").to_string(), item, comma))
+                            path.push_str(&format!("{}::{}{}", segments.join("::").to_string(), item, comma))
+                        // use mod_a::{mod_b::{one, two}, mod_c::item}
                         } else {
-                            // use mod_a::{mod_b::{one, two}, mod_c::item, item1, item2}
-                            let mod_path = if names.len() - 1 > 0 {
-                                ModPath::Nested { names: names.clone(), item: item.to_string(), span: *span, }
-                            } else {
-                                ModPath::Item { item: names[0].to_string(), span: *span, }
-                            };
-                            let names = recursive_path_push(mod_path, comma, &rest, String::new());
-                            path.push_str(&format!("{}::{{{}}}{}", names, item, comma))
+                            found_nested.extend(nested.iter());
+                            found_nested.push(&m);
+                            // we check each segment for matches with other import paths if
+                            // one differs we have to open a new `{}`
+                            for (idx, seg) in segments.iter().enumerate() {
+                                path.push_str(&format!("{}::", seg));
+                                if nested.iter().all(|other_m| other_m.matches(idx, &m)) {
+                                    continue;
+                                }
+
+                                path.push_str("{");
+                                let matched_seg_items = nested
+                                    .iter()
+                                    .filter(|other_m| !other_m.matches(idx, &m))
+                                    .collect::<Vec<_>>();
+                                for item in matched_seg_items {
+                                    if let ModPath::Nested { item, .. } = item {
+                                        path.push_str(&format!(
+                                            "{}{}",
+                                            item,
+                                            if nested.len() == idx + 1 { "" } else { ", " }
+                                        ));
+                                    }
+                                }
+                                path.push_str("}");
+                            }
+                            path.push_str(&format!("{{{}{}", item, comma));
+                            for (i, item) in nested.iter().enumerate() {
+                                if let ModPath::Nested { item, segments: matched_seg, .. } = item {
+                                    path.push_str(&format!(
+                                        "{}{}{}",
+                                        if matched_seg > segments {
+                                            format!("{}::", matched_seg[segments.len()..].join("::"))
+                                        } else {
+                                            String::new()
+                                        },
+                                        item,
+                                        if nested.len() == i + 1 { "" } else { ", " }
+                                    ));
+                                }
+                            }
+                            path.push_str("}");
                         }
-                    }
+                    },
                 }
-                count += 1;             
+                count += 1;
             }
             if rest_len > 1 {
                 path.push_str("};");
+            } else {
+                path.push_str(";");
             }
-            if let Some(span) = s {
+            if let Some(span) = attr_span {
                 imports.push((span, path))
+            } else {
+                unreachable!("a span must always be attached to a macro_use attribute")
             }
         }
 
-        if !self.mac_refs.is_empty() {
-            // TODO if not empty we found one we could not make a suggestion for
-            // such as std::prelude::v1 or something else I haven't thought of.
-            // If we defer the calling of span_lint_and_sugg we can make a decision about its
-            // applicability?
-        } else {
+        // If mac_refs is not empty we have encountered an import we could not handle
+        // such as `std::prelude::v1::foo` or some other macro that expands to an import.
+        if self.mac_refs.is_empty() {
             for (span, import) in imports {
                 let help = format!("use {}", import);
                 span_lint_and_sugg(
@@ -237,48 +280,56 @@ impl<'l, 'txc> LateLintPass<'l, 'txc> for MacroUseImports {
 
 #[derive(Debug, PartialEq)]
 enum ModPath {
-    Item { item: String, span: Span, },
-    Nested { names: Vec<String>, item: String, span: Span, },
+    Item {
+        item: String,
+        span: Span,
+    },
+    Nested {
+        segments: Vec<String>,
+        item: String,
+        span: Span,
+    },
 }
 
 impl ModPath {
     fn span(&self) -> Span {
         match self {
-            Self::Item { span, .. } => *span,
-            Self::Nested { span, .. } => *span,
+            Self::Item { span, .. } | Self::Nested { span, .. } => *span,
         }
     }
 
     fn item(&self) -> &str {
         match self {
-            Self::Item { item, .. } => item,
-            Self::Nested { item, .. } => item,
+            Self::Item { item, .. } | Self::Nested { item, .. } => item,
         }
     }
 
     fn matches(&self, idx: usize, other: &ModPath) -> bool {
         match (self, other) {
             (Self::Item { item, .. }, Self::Item { item: other_item, .. }) => item == other_item,
-            (Self::Nested { names, .. }, Self::Nested { names: other_names, .. }) => {
-                match (names.get(idx), other_names.get(idx)) {
-                    (Some(seg), Some(other_seg)) => seg == other_seg,
-                    (_, _) => false,
-                }
-            }
+            (
+                Self::Nested { segments, .. },
+                Self::Nested {
+                    segments: other_names, ..
+                },
+            ) => match (segments.get(idx), other_names.get(idx)) {
+                (Some(seg), Some(other_seg)) => seg == other_seg,
+                (_, _) => false,
+            },
             (_, _) => false,
         }
     }
 }
 
+#[allow(clippy::comparison_chain)]
 fn proccess_macro_path(span: Span, import: &str, import_map: &mut FxHashMap<String, Vec<ModPath>>) {
     let mut mod_path = import.split("::").collect::<Vec<_>>();
 
     if mod_path.len() == 2 {
-        let item_list = import_map.entry(mod_path[0].to_string())
-            .or_insert(vec![]);
+        let item_list = import_map.entry(mod_path[0].to_string()).or_insert_with(Vec::new);
 
         if !item_list.iter().any(|mods| mods.item() == mod_path[1]) {
-            item_list.push(ModPath::Item{
+            item_list.push(ModPath::Item {
                 item: mod_path[1].to_string(),
                 span,
             });
@@ -288,46 +339,16 @@ fn proccess_macro_path(span: Span, import: &str, import_map: &mut FxHashMap<Stri
         let name = mod_path.remove(mod_path.len() - 1);
 
         let nested = ModPath::Nested {
-            names: mod_path.into_iter().map(ToString::to_string).collect(),
+            segments: mod_path.into_iter().map(ToString::to_string).collect(),
             item: name.to_string(),
             span,
         };
-        import_map.entry(first.to_string())
-            .or_insert(vec![])
-            .push(nested);
+        // CLIPPY NOTE: this told me to use `or_insert_with(vec![])`
+        // import_map.entry(first.to_string()).or_insert(vec![]).push(nested);
+        // which failed as `vec!` is not a closure then told me to add `||` which failed
+        // with the redundant_closure lint so I finally gave up and used this.
+        import_map.entry(first.to_string()).or_insert_with(Vec::new).push(nested);
     } else {
         unreachable!("test to see if code path hit TODO REMOVE")
     }
 }
-
-fn recursive_path_push(module: ModPath, comma: &str, rest: &[ModPath], mut path: String) -> String {
-    match &module {
-        ModPath::Item { item, .. } => {
-            path.push_str(&format!("{}{}", item, comma));
-        }
-        ModPath::Nested { names, item, span } => {
-            let nested = rest.iter()
-                // filter "self" out
-                .filter(|other_m| other_m != &&module)
-                // this matches the first path segment and filters non ModPath::Nested items
-                .filter(|other_m| other_m.matches(0, &module))
-                .collect::<Vec<_>>();
-
-            println!("{:#?}", nested);
-
-            if nested.is_empty() {
-                path.push_str(&format!("{}::{}{}", names.join("::").to_string(), item, comma))
-            } else {
-                // use mod_a::{mod_b::{one, two}, mod_c::item, item1, item2}
-                let mod_path = if names.len() - 1 > 0 {
-                    ModPath::Nested { names: names.clone(), item: item.to_string(), span: *span, }
-                } else {
-                    ModPath::Item { item: names[0].to_string(), span: *span, }
-                };
-                let names = recursive_path_push(mod_path, comma, rest, path.to_string());
-                // path.push_str(&format!("{}{}", item, comma));
-            }
-        }
-    }
-    path
-}
diff --git a/tests/ui/auxiliary/macro_use_helper.rs b/tests/ui/auxiliary/macro_use_helper.rs
index 7cc4e1d736a..ecb55d8cb48 100644
--- a/tests/ui/auxiliary/macro_use_helper.rs
+++ b/tests/ui/auxiliary/macro_use_helper.rs
@@ -13,8 +13,13 @@ pub mod inner {
 
     // RE-EXPORT
     // this will stick in `inner` module
+    pub use macro_rules::foofoo;
     pub use macro_rules::try_err;
 
+    pub mod nested {
+        pub use macro_rules::string_add;
+    }
+
     // ITEM
     #[macro_export]
     macro_rules! inner_mod_macro {
diff --git a/tests/ui/macro_use_imports.rs b/tests/ui/macro_use_imports.rs
index 2d4f71e5d53..52dec0e44b3 100644
--- a/tests/ui/macro_use_imports.rs
+++ b/tests/ui/macro_use_imports.rs
@@ -18,6 +18,8 @@ mod a {
     use mini_mac;
     #[macro_use]
     use mac::inner;
+    #[macro_use]
+    use mac::inner::nested;
 
     #[derive(ClippyMiniMacroTest)]
     struct Test;
@@ -30,6 +32,8 @@ mod a {
         let v: ty_macro!() = Vec::default();
 
         inner::try_err!();
+        inner::foofoo!();
+        nested::string_add!();
     }
 }
 
diff --git a/tests/ui/macro_use_imports.stderr b/tests/ui/macro_use_imports.stderr
index 6bcacd0be19..00c76c19ea9 100644
--- a/tests/ui/macro_use_imports.stderr
+++ b/tests/ui/macro_use_imports.stderr
@@ -1,8 +1,8 @@
 error: `macro_use` attributes are no longer needed in the Rust 2018 edition
-  --> $DIR/macro_use_imports.rs:15:5
+  --> $DIR/macro_use_imports.rs:17:5
    |
 LL |     #[macro_use]
-   |     ^^^^^^^^^^^^ help: remove the attribute and import the macro directly, try: `use mac::pub_macro`
+   |     ^^^^^^^^^^^^ help: remove the attribute and import the macro directly, try: `use use mini_mac::ClippyMiniMacroTest;`
    |
    = note: `-D clippy::macro-use-imports` implied by `-D warnings`
 
@@ -10,37 +10,7 @@ error: `macro_use` attributes are no longer needed in the Rust 2018 edition
   --> $DIR/macro_use_imports.rs:15:5
    |
 LL |     #[macro_use]
-   |     ^^^^^^^^^^^^ help: remove the attribute and import the macro directly, try: `use mac::inner_mod_macro`
-
-error: `macro_use` attributes are no longer needed in the Rust 2018 edition
-  --> $DIR/macro_use_imports.rs:15:5
-   |
-LL |     #[macro_use]
-   |     ^^^^^^^^^^^^ help: remove the attribute and import the macro directly, try: `use mac::function_macro`
-
-error: `macro_use` attributes are no longer needed in the Rust 2018 edition
-  --> $DIR/macro_use_imports.rs:15:5
-   |
-LL |     #[macro_use]
-   |     ^^^^^^^^^^^^ help: remove the attribute and import the macro directly, try: `use mac::ty_macro`
-
-error: `macro_use` attributes are no longer needed in the Rust 2018 edition
-  --> $DIR/macro_use_imports.rs:15:5
-   |
-LL |     #[macro_use]
-   |     ^^^^^^^^^^^^ help: remove the attribute and import the macro directly, try: `use mac::pub_in_private_macro`
-
-error: `macro_use` attributes are no longer needed in the Rust 2018 edition
-  --> $DIR/macro_use_imports.rs:17:5
-   |
-LL |     #[macro_use]
-   |     ^^^^^^^^^^^^ help: remove the attribute and import the macro directly, try: `use mini_mac::ClippyMiniMacroTest`
-
-error: `macro_use` attributes are no longer needed in the Rust 2018 edition
-  --> $DIR/macro_use_imports.rs:19:5
-   |
-LL |     #[macro_use]
-   |     ^^^^^^^^^^^^ help: remove the attribute and import the macro directly, try: `use mac::inner::try_err`
+   |     ^^^^^^^^^^^^ help: remove the attribute and import the macro directly, try: `use use mac::{pub_macro, inner_mod_macro, function_macro, ty_macro, pub_in_private_macro, inner::{foofoo, try_err, nested::string_add}};`
 
-error: aborting due to 7 previous errors
+error: aborting due to 2 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 8c5a5a92ec6f298a067ba052a0d5b6150537c1c9 Mon Sep 17 00:00:00 2001
From: Devin R <devin.ragotzy@gmail.com>
Date: Tue, 26 May 2020 19:57:36 -0400
Subject: cleaned up import suggestion formatter, look into code reuse with
 wildcard impotrs

---
 clippy_lints/src/macro_use.rs     | 224 +++++++++-----------------------------
 tests/ui/macro_use_imports.stderr |  18 ++-
 2 files changed, 64 insertions(+), 178 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/macro_use.rs b/clippy_lints/src/macro_use.rs
index 1e1f27e9430..089ae79b02c 100644
--- a/clippy_lints/src/macro_use.rs
+++ b/clippy_lints/src/macro_use.rs
@@ -29,6 +29,12 @@ declare_clippy_lint! {
 
 const BRACKETS: &[char] = &['<', '>'];
 
+#[derive(Clone, Debug, PartialEq, Eq)]
+struct PathAndSpan {
+    path: String,
+    span: Span,
+}
+
 /// `MacroRefData` includes the name of the macro
 /// and the path from `SourceMap::span_to_filename`.
 #[derive(Debug, Clone)]
@@ -110,7 +116,8 @@ impl<'l, 'txc> LateLintPass<'l, 'txc> for MacroUseImports {
                 for kid in cx.tcx.item_children(id).iter() {
                     if let Res::Def(DefKind::Macro(_mac_type), mac_id) = kid.res {
                         let span = mac_attr.span;
-                        self.imports.push((cx.tcx.def_path_str(mac_id), span));
+                        let def_path = cx.tcx.def_path_str(mac_id);
+                        self.imports.push((def_path, span));
                     }
                 }
             } else {
@@ -147,127 +154,69 @@ impl<'l, 'txc> LateLintPass<'l, 'txc> for MacroUseImports {
     }
     #[allow(clippy::too_many_lines)]
     fn check_crate_post(&mut self, cx: &LateContext<'_, '_>, _krate: &hir::Crate<'_>) {
-        let mut import_map = FxHashMap::default();
+        let mut used = FxHashMap::default();
+        let mut check_dup = vec![];
         for (import, span) in &self.imports {
             let found_idx = self.mac_refs.iter().position(|mac| import.ends_with(&mac.name));
 
             if let Some(idx) = found_idx {
                 let _ = self.mac_refs.remove(idx);
-                proccess_macro_path(*span, import, &mut import_map);
-            }
-        }
-        // println!("{:#?}", import_map);
-        let mut imports = vec![];
-        for (root, rest) in import_map {
-            let mut path = format!("use {}::", root);
-            let mut attr_span = None;
-            // when a multiple nested paths are found one may be written to the string
-            // before it is found in this loop so we make note and skip it when this
-            // loop finds it
-            let mut found_nested = vec![];
-            let mut count = 1;
-            let rest_len = rest.len();
-
-            if rest_len > 1 {
-                path.push_str("{");
-            }
-
-            for m in &rest {
-                if attr_span.is_none() {
-                    attr_span = Some(m.span());
-                }
-                if found_nested.contains(&m) {
-                    continue;
-                }
-                let comma = if rest_len == count { "" } else { ", " };
-                match m {
-                    ModPath::Item { item, .. } => {
-                        path.push_str(&format!("{}{}", item, comma));
+                let seg = import.split("::").collect::<Vec<_>>();
+
+                match seg.as_slice() {
+                    [] => unreachable!("this should never be empty"),
+                    [_] => unreachable!("path must have two segments ?"),
+                    [root, item] => {
+                        if !check_dup.contains(&item.to_string()) {
+                            used.entry((root.to_string(), span))
+                                .or_insert(vec![])
+                                .push(item.to_string());
+                            check_dup.push(item.to_string());
+                        }
                     },
-                    ModPath::Nested { segments, item, .. } => {
-                        // do any other Nested paths match the current one
-                        let nested = rest
-                            .iter()
-                            // filter "self" out
-                            .filter(|other_m| other_m != &m)
-                            // filters out Nested we have previously seen
-                            .filter(|other_m| !found_nested.contains(other_m))
-                            // this matches the first path segment and filters non ModPath::Nested items
-                            .filter(|other_m| other_m.matches(0, m))
-                            .collect::<Vec<_>>();
-
-                        if nested.is_empty() {
-                            path.push_str(&format!("{}::{}{}", segments.join("::").to_string(), item, comma))
-                        // use mod_a::{mod_b::{one, two}, mod_c::item}
+                    [root, rest @ ..] => {
+                        if !rest.iter().all(|item| !check_dup.contains(&item.to_string())) {
+                            let mut rest = rest.to_vec();
+                            rest.sort();
+                            used.entry((root.to_string(), span))
+                                .or_insert(vec![])
+                                .push(rest.join("::"));
+                            check_dup.extend(rest.iter().map(ToString::to_string));
                         } else {
-                            found_nested.extend(nested.iter());
-                            found_nested.push(&m);
-                            // we check each segment for matches with other import paths if
-                            // one differs we have to open a new `{}`
-                            for (idx, seg) in segments.iter().enumerate() {
-                                path.push_str(&format!("{}::", seg));
-                                if nested.iter().all(|other_m| other_m.matches(idx, &m)) {
-                                    continue;
-                                }
-
-                                path.push_str("{");
-                                let matched_seg_items = nested
-                                    .iter()
-                                    .filter(|other_m| !other_m.matches(idx, &m))
-                                    .collect::<Vec<_>>();
-                                for item in matched_seg_items {
-                                    if let ModPath::Nested { item, .. } = item {
-                                        path.push_str(&format!(
-                                            "{}{}",
-                                            item,
-                                            if nested.len() == idx + 1 { "" } else { ", " }
-                                        ));
-                                    }
-                                }
-                                path.push_str("}");
-                            }
-                            path.push_str(&format!("{{{}{}", item, comma));
-                            for (i, item) in nested.iter().enumerate() {
-                                if let ModPath::Nested { item, segments: matched_seg, .. } = item {
-                                    path.push_str(&format!(
-                                        "{}{}{}",
-                                        if matched_seg > segments {
-                                            format!("{}::", matched_seg[segments.len()..].join("::"))
-                                        } else {
-                                            String::new()
-                                        },
-                                        item,
-                                        if nested.len() == i + 1 { "" } else { ", " }
-                                    ));
-                                }
-                            }
-                            path.push_str("}");
+                            let mut filtered = rest
+                                .iter()
+                                .filter(|item| !check_dup.contains(&item.to_string()))
+                                .map(ToString::to_string)
+                                .collect::<Vec<_>>();
+                            filtered.sort();
+                            used.entry((root.to_string(), span))
+                                .or_insert(vec![])
+                                .push(filtered.join("::"));
+                            check_dup.extend(filtered);
                         }
                     },
                 }
-                count += 1;
             }
-            if rest_len > 1 {
-                path.push_str("};");
-            } else {
-                path.push_str(";");
-            }
-            if let Some(span) = attr_span {
-                imports.push((span, path))
+        }
+
+        let mut suggestions = vec![];
+        for ((root, span), path) in used {
+            if path.len() == 1 {
+                suggestions.push((span, format!("{}::{}", root, path[0])))
             } else {
-                unreachable!("a span must always be attached to a macro_use attribute")
+                suggestions.push((span, format!("{}::{{{}}}", root, path.join(", "))))
             }
         }
 
         // If mac_refs is not empty we have encountered an import we could not handle
         // such as `std::prelude::v1::foo` or some other macro that expands to an import.
         if self.mac_refs.is_empty() {
-            for (span, import) in imports {
+            for (span, import) in suggestions {
                 let help = format!("use {}", import);
                 span_lint_and_sugg(
                     cx,
                     MACRO_USE_IMPORTS,
-                    span,
+                    *span,
                     "`macro_use` attributes are no longer needed in the Rust 2018 edition",
                     "remove the attribute and import the macro directly, try",
                     help,
@@ -277,78 +226,3 @@ impl<'l, 'txc> LateLintPass<'l, 'txc> for MacroUseImports {
         }
     }
 }
-
-#[derive(Debug, PartialEq)]
-enum ModPath {
-    Item {
-        item: String,
-        span: Span,
-    },
-    Nested {
-        segments: Vec<String>,
-        item: String,
-        span: Span,
-    },
-}
-
-impl ModPath {
-    fn span(&self) -> Span {
-        match self {
-            Self::Item { span, .. } | Self::Nested { span, .. } => *span,
-        }
-    }
-
-    fn item(&self) -> &str {
-        match self {
-            Self::Item { item, .. } | Self::Nested { item, .. } => item,
-        }
-    }
-
-    fn matches(&self, idx: usize, other: &ModPath) -> bool {
-        match (self, other) {
-            (Self::Item { item, .. }, Self::Item { item: other_item, .. }) => item == other_item,
-            (
-                Self::Nested { segments, .. },
-                Self::Nested {
-                    segments: other_names, ..
-                },
-            ) => match (segments.get(idx), other_names.get(idx)) {
-                (Some(seg), Some(other_seg)) => seg == other_seg,
-                (_, _) => false,
-            },
-            (_, _) => false,
-        }
-    }
-}
-
-#[allow(clippy::comparison_chain)]
-fn proccess_macro_path(span: Span, import: &str, import_map: &mut FxHashMap<String, Vec<ModPath>>) {
-    let mut mod_path = import.split("::").collect::<Vec<_>>();
-
-    if mod_path.len() == 2 {
-        let item_list = import_map.entry(mod_path[0].to_string()).or_insert_with(Vec::new);
-
-        if !item_list.iter().any(|mods| mods.item() == mod_path[1]) {
-            item_list.push(ModPath::Item {
-                item: mod_path[1].to_string(),
-                span,
-            });
-        }
-    } else if mod_path.len() > 2 {
-        let first = mod_path.remove(0);
-        let name = mod_path.remove(mod_path.len() - 1);
-
-        let nested = ModPath::Nested {
-            segments: mod_path.into_iter().map(ToString::to_string).collect(),
-            item: name.to_string(),
-            span,
-        };
-        // CLIPPY NOTE: this told me to use `or_insert_with(vec![])`
-        // import_map.entry(first.to_string()).or_insert(vec![]).push(nested);
-        // which failed as `vec!` is not a closure then told me to add `||` which failed
-        // with the redundant_closure lint so I finally gave up and used this.
-        import_map.entry(first.to_string()).or_insert_with(Vec::new).push(nested);
-    } else {
-        unreachable!("test to see if code path hit TODO REMOVE")
-    }
-}
diff --git a/tests/ui/macro_use_imports.stderr b/tests/ui/macro_use_imports.stderr
index 00c76c19ea9..83c8ebe6ab9 100644
--- a/tests/ui/macro_use_imports.stderr
+++ b/tests/ui/macro_use_imports.stderr
@@ -2,15 +2,27 @@ error: `macro_use` attributes are no longer needed in the Rust 2018 edition
   --> $DIR/macro_use_imports.rs:17:5
    |
 LL |     #[macro_use]
-   |     ^^^^^^^^^^^^ help: remove the attribute and import the macro directly, try: `use use mini_mac::ClippyMiniMacroTest;`
+   |     ^^^^^^^^^^^^ help: remove the attribute and import the macro directly, try: `use mini_mac::ClippyMiniMacroTest`
    |
    = note: `-D clippy::macro-use-imports` implied by `-D warnings`
 
+error: `macro_use` attributes are no longer needed in the Rust 2018 edition
+  --> $DIR/macro_use_imports.rs:21:5
+   |
+LL |     #[macro_use]
+   |     ^^^^^^^^^^^^ help: remove the attribute and import the macro directly, try: `use mac::inner::nested::string_add`
+
+error: `macro_use` attributes are no longer needed in the Rust 2018 edition
+  --> $DIR/macro_use_imports.rs:19:5
+   |
+LL |     #[macro_use]
+   |     ^^^^^^^^^^^^ help: remove the attribute and import the macro directly, try: `use mac::{foofoo::inner, inner::try_err}`
+
 error: `macro_use` attributes are no longer needed in the Rust 2018 edition
   --> $DIR/macro_use_imports.rs:15:5
    |
 LL |     #[macro_use]
-   |     ^^^^^^^^^^^^ help: remove the attribute and import the macro directly, try: `use use mac::{pub_macro, inner_mod_macro, function_macro, ty_macro, pub_in_private_macro, inner::{foofoo, try_err, nested::string_add}};`
+   |     ^^^^^^^^^^^^ help: remove the attribute and import the macro directly, try: `use mac::{pub_macro, inner_mod_macro, function_macro, ty_macro, pub_in_private_macro}`
 
-error: aborting due to 2 previous errors
+error: aborting due to 4 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 288df59b25c04f05d08d817727a8ac9c8d0d6648 Mon Sep 17 00:00:00 2001
From: Devin R <devin.ragotzy@gmail.com>
Date: Sun, 7 Jun 2020 16:12:35 -0400
Subject: Fix suggestion output, add run-rustfix to test file, stop sorting
 import segments duh

---
 clippy_lints/src/macro_use.rs     | 35 +++++++++++++++++----------------
 tests/ui/macro_use_imports.fixed  | 41 +++++++++++++++++++++++++++++++++++++++
 tests/ui/macro_use_imports.rs     |  1 +
 tests/ui/macro_use_imports.stderr | 16 +++++++--------
 4 files changed, 68 insertions(+), 25 deletions(-)
 create mode 100644 tests/ui/macro_use_imports.fixed

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/macro_use.rs b/clippy_lints/src/macro_use.rs
index 089ae79b02c..7e3ce07254f 100644
--- a/clippy_lints/src/macro_use.rs
+++ b/clippy_lints/src/macro_use.rs
@@ -167,32 +167,33 @@ impl<'l, 'txc> LateLintPass<'l, 'txc> for MacroUseImports {
                     [] => unreachable!("this should never be empty"),
                     [_] => unreachable!("path must have two segments ?"),
                     [root, item] => {
-                        if !check_dup.contains(&item.to_string()) {
+                        if !check_dup.contains(&(*item).to_string()) {
                             used.entry((root.to_string(), span))
-                                .or_insert(vec![])
+                                .or_insert_with(|| vec![])
                                 .push(item.to_string());
                             check_dup.push(item.to_string());
                         }
                     },
                     [root, rest @ ..] => {
-                        if !rest.iter().all(|item| !check_dup.contains(&item.to_string())) {
-                            let mut rest = rest.to_vec();
-                            rest.sort();
-                            used.entry((root.to_string(), span))
-                                .or_insert(vec![])
-                                .push(rest.join("::"));
-                            check_dup.extend(rest.iter().map(ToString::to_string));
-                        } else {
-                            let mut filtered = rest
+                        if rest.iter().all(|item| !check_dup.contains(&(*item).to_string())) {
+                            let filtered = rest
                                 .iter()
-                                .filter(|item| !check_dup.contains(&item.to_string()))
-                                .map(ToString::to_string)
+                                .filter_map(|item| if check_dup.contains(&(*item).to_string()) {
+                                    None
+                                } else {
+                                    Some(item.to_string())
+                                })
                                 .collect::<Vec<_>>();
-                            filtered.sort();
-                            used.entry((root.to_string(), span))
-                                .or_insert(vec![])
+                            used.entry(((*root).to_string(), span))
+                                .or_insert_with(|| vec![])
                                 .push(filtered.join("::"));
                             check_dup.extend(filtered);
+                        } else {
+                            let rest = rest.to_vec();
+                            used.entry((root.to_string(), span))
+                                .or_insert_with(|| vec![])
+                                .push(rest.join("::"));
+                            check_dup.extend(rest.iter().map(ToString::to_string));
                         }
                     },
                 }
@@ -212,7 +213,7 @@ impl<'l, 'txc> LateLintPass<'l, 'txc> for MacroUseImports {
         // such as `std::prelude::v1::foo` or some other macro that expands to an import.
         if self.mac_refs.is_empty() {
             for (span, import) in suggestions {
-                let help = format!("use {}", import);
+                let help = format!("use {};", import);
                 span_lint_and_sugg(
                     cx,
                     MACRO_USE_IMPORTS,
diff --git a/tests/ui/macro_use_imports.fixed b/tests/ui/macro_use_imports.fixed
new file mode 100644
index 00000000000..8034c56b59a
--- /dev/null
+++ b/tests/ui/macro_use_imports.fixed
@@ -0,0 +1,41 @@
+// compile-flags: --edition 2018
+// aux-build:macro_rules.rs
+// aux-build:macro_use_helper.rs
+// run-rustfix
+
+#![allow(clippy::single_component_path_imports)]
+#![warn(clippy::macro_use_imports)]
+
+#[macro_use]
+extern crate macro_use_helper as mac;
+
+#[macro_use]
+extern crate clippy_mini_macro_test as mini_mac;
+
+mod a {
+    use mac::{pub_macro, inner_mod_macro, function_macro, ty_macro, pub_in_private_macro};
+    use mac;
+    use mini_mac::ClippyMiniMacroTest;
+    use mini_mac;
+    use mac::{inner::foofoo, inner::try_err};
+    use mac::inner;
+    use mac::inner::nested::string_add;
+    use mac::inner::nested;
+
+    #[derive(ClippyMiniMacroTest)]
+    struct Test;
+
+    fn test() {
+        pub_macro!();
+        inner_mod_macro!();
+        pub_in_private_macro!(_var);
+        function_macro!();
+        let v: ty_macro!() = Vec::default();
+
+        inner::try_err!();
+        inner::foofoo!();
+        nested::string_add!();
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/macro_use_imports.rs b/tests/ui/macro_use_imports.rs
index 52dec0e44b3..7d415222d64 100644
--- a/tests/ui/macro_use_imports.rs
+++ b/tests/ui/macro_use_imports.rs
@@ -1,6 +1,7 @@
 // compile-flags: --edition 2018
 // aux-build:macro_rules.rs
 // aux-build:macro_use_helper.rs
+// run-rustfix
 
 #![allow(clippy::single_component_path_imports)]
 #![warn(clippy::macro_use_imports)]
diff --git a/tests/ui/macro_use_imports.stderr b/tests/ui/macro_use_imports.stderr
index 83c8ebe6ab9..6feda8a5222 100644
--- a/tests/ui/macro_use_imports.stderr
+++ b/tests/ui/macro_use_imports.stderr
@@ -1,28 +1,28 @@
 error: `macro_use` attributes are no longer needed in the Rust 2018 edition
-  --> $DIR/macro_use_imports.rs:17:5
+  --> $DIR/macro_use_imports.rs:18:5
    |
 LL |     #[macro_use]
-   |     ^^^^^^^^^^^^ help: remove the attribute and import the macro directly, try: `use mini_mac::ClippyMiniMacroTest`
+   |     ^^^^^^^^^^^^ help: remove the attribute and import the macro directly, try: `use mini_mac::ClippyMiniMacroTest;`
    |
    = note: `-D clippy::macro-use-imports` implied by `-D warnings`
 
 error: `macro_use` attributes are no longer needed in the Rust 2018 edition
-  --> $DIR/macro_use_imports.rs:21:5
+  --> $DIR/macro_use_imports.rs:20:5
    |
 LL |     #[macro_use]
-   |     ^^^^^^^^^^^^ help: remove the attribute and import the macro directly, try: `use mac::inner::nested::string_add`
+   |     ^^^^^^^^^^^^ help: remove the attribute and import the macro directly, try: `use mac::{inner::foofoo, inner::try_err};`
 
 error: `macro_use` attributes are no longer needed in the Rust 2018 edition
-  --> $DIR/macro_use_imports.rs:19:5
+  --> $DIR/macro_use_imports.rs:16:5
    |
 LL |     #[macro_use]
-   |     ^^^^^^^^^^^^ help: remove the attribute and import the macro directly, try: `use mac::{foofoo::inner, inner::try_err}`
+   |     ^^^^^^^^^^^^ help: remove the attribute and import the macro directly, try: `use mac::{pub_macro, inner_mod_macro, function_macro, ty_macro, pub_in_private_macro};`
 
 error: `macro_use` attributes are no longer needed in the Rust 2018 edition
-  --> $DIR/macro_use_imports.rs:15:5
+  --> $DIR/macro_use_imports.rs:22:5
    |
 LL |     #[macro_use]
-   |     ^^^^^^^^^^^^ help: remove the attribute and import the macro directly, try: `use mac::{pub_macro, inner_mod_macro, function_macro, ty_macro, pub_in_private_macro}`
+   |     ^^^^^^^^^^^^ help: remove the attribute and import the macro directly, try: `use mac::inner::nested::string_add;`
 
 error: aborting due to 4 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From e521a4ed3818c02a1831db570e69d056c351ee05 Mon Sep 17 00:00:00 2001
From: Devin R <devin.ragotzy@gmail.com>
Date: Sun, 7 Jun 2020 16:25:21 -0400
Subject: Add enough attrs to the test file so the fix compiles with no errors,
 fmt/`clippy`

---
 clippy_lints/src/macro_use.rs     | 29 ++++++++++++++++-------------
 tests/ui/macro_use_imports.fixed  |  2 ++
 tests/ui/macro_use_imports.rs     |  2 ++
 tests/ui/macro_use_imports.stderr | 10 +++++-----
 4 files changed, 25 insertions(+), 18 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/macro_use.rs b/clippy_lints/src/macro_use.rs
index 7e3ce07254f..b845b20d2c0 100644
--- a/clippy_lints/src/macro_use.rs
+++ b/clippy_lints/src/macro_use.rs
@@ -164,34 +164,37 @@ impl<'l, 'txc> LateLintPass<'l, 'txc> for MacroUseImports {
                 let seg = import.split("::").collect::<Vec<_>>();
 
                 match seg.as_slice() {
-                    [] => unreachable!("this should never be empty"),
-                    [_] => unreachable!("path must have two segments ?"),
+                    // an empty path is impossible
+                    // a path should always consist of 2 or more segments
+                    [] | [_] => return,
                     [root, item] => {
                         if !check_dup.contains(&(*item).to_string()) {
-                            used.entry((root.to_string(), span))
-                                .or_insert_with(|| vec![])
-                                .push(item.to_string());
-                            check_dup.push(item.to_string());
+                            used.entry(((*root).to_string(), span))
+                                .or_insert_with(Vec::new)
+                                .push((*item).to_string());
+                            check_dup.push((*item).to_string());
                         }
                     },
                     [root, rest @ ..] => {
                         if rest.iter().all(|item| !check_dup.contains(&(*item).to_string())) {
                             let filtered = rest
                                 .iter()
-                                .filter_map(|item| if check_dup.contains(&(*item).to_string()) {
-                                    None
-                                } else {
-                                    Some(item.to_string())
+                                .filter_map(|item| {
+                                    if check_dup.contains(&(*item).to_string()) {
+                                        None
+                                    } else {
+                                        Some((*item).to_string())
+                                    }
                                 })
                                 .collect::<Vec<_>>();
                             used.entry(((*root).to_string(), span))
-                                .or_insert_with(|| vec![])
+                                .or_insert_with(Vec::new)
                                 .push(filtered.join("::"));
                             check_dup.extend(filtered);
                         } else {
                             let rest = rest.to_vec();
-                            used.entry((root.to_string(), span))
-                                .or_insert_with(|| vec![])
+                            used.entry(((*root).to_string(), span))
+                                .or_insert_with(Vec::new)
                                 .push(rest.join("::"));
                             check_dup.extend(rest.iter().map(ToString::to_string));
                         }
diff --git a/tests/ui/macro_use_imports.fixed b/tests/ui/macro_use_imports.fixed
index 8034c56b59a..91e34c62160 100644
--- a/tests/ui/macro_use_imports.fixed
+++ b/tests/ui/macro_use_imports.fixed
@@ -2,7 +2,9 @@
 // aux-build:macro_rules.rs
 // aux-build:macro_use_helper.rs
 // run-rustfix
+// ignore-32bit
 
+#![allow(unused_imports, unreachable_code, unused_variables, dead_code)]
 #![allow(clippy::single_component_path_imports)]
 #![warn(clippy::macro_use_imports)]
 
diff --git a/tests/ui/macro_use_imports.rs b/tests/ui/macro_use_imports.rs
index 7d415222d64..9c3c50c5d49 100644
--- a/tests/ui/macro_use_imports.rs
+++ b/tests/ui/macro_use_imports.rs
@@ -2,7 +2,9 @@
 // aux-build:macro_rules.rs
 // aux-build:macro_use_helper.rs
 // run-rustfix
+// ignore-32bit
 
+#![allow(unused_imports, unreachable_code, unused_variables, dead_code)]
 #![allow(clippy::single_component_path_imports)]
 #![warn(clippy::macro_use_imports)]
 
diff --git a/tests/ui/macro_use_imports.stderr b/tests/ui/macro_use_imports.stderr
index 6feda8a5222..f8c86c8d917 100644
--- a/tests/ui/macro_use_imports.stderr
+++ b/tests/ui/macro_use_imports.stderr
@@ -2,7 +2,7 @@ error: `macro_use` attributes are no longer needed in the Rust 2018 edition
   --> $DIR/macro_use_imports.rs:18:5
    |
 LL |     #[macro_use]
-   |     ^^^^^^^^^^^^ help: remove the attribute and import the macro directly, try: `use mini_mac::ClippyMiniMacroTest;`
+   |     ^^^^^^^^^^^^ help: remove the attribute and import the macro directly, try: `use mac::{pub_macro, inner_mod_macro, function_macro, ty_macro, pub_in_private_macro};`
    |
    = note: `-D clippy::macro-use-imports` implied by `-D warnings`
 
@@ -10,16 +10,16 @@ error: `macro_use` attributes are no longer needed in the Rust 2018 edition
   --> $DIR/macro_use_imports.rs:20:5
    |
 LL |     #[macro_use]
-   |     ^^^^^^^^^^^^ help: remove the attribute and import the macro directly, try: `use mac::{inner::foofoo, inner::try_err};`
+   |     ^^^^^^^^^^^^ help: remove the attribute and import the macro directly, try: `use mini_mac::ClippyMiniMacroTest;`
 
 error: `macro_use` attributes are no longer needed in the Rust 2018 edition
-  --> $DIR/macro_use_imports.rs:16:5
+  --> $DIR/macro_use_imports.rs:22:5
    |
 LL |     #[macro_use]
-   |     ^^^^^^^^^^^^ help: remove the attribute and import the macro directly, try: `use mac::{pub_macro, inner_mod_macro, function_macro, ty_macro, pub_in_private_macro};`
+   |     ^^^^^^^^^^^^ help: remove the attribute and import the macro directly, try: `use mac::{inner::foofoo, inner::try_err};`
 
 error: `macro_use` attributes are no longer needed in the Rust 2018 edition
-  --> $DIR/macro_use_imports.rs:22:5
+  --> $DIR/macro_use_imports.rs:24:5
    |
 LL |     #[macro_use]
    |     ^^^^^^^^^^^^ help: remove the attribute and import the macro directly, try: `use mac::inner::nested::string_add;`
-- 
cgit 1.4.1-3-g733a5


From a083b84b783a2c9e622c9d618e751da22adaff37 Mon Sep 17 00:00:00 2001
From: Eduardo Broto <ebroto@tutanota.com>
Date: Tue, 9 Jun 2020 23:49:21 +0200
Subject: if_same_then_else: don't assume multiplication is always commutative

---
 clippy_lints/src/utils/hir_utils.rs | 13 +++++--------
 tests/ui/if_same_then_else.rs       | 12 ++++++++++++
 2 files changed, 17 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/hir_utils.rs b/clippy_lints/src/utils/hir_utils.rs
index f8d197c15e8..6846658b6e2 100644
--- a/clippy_lints/src/utils/hir_utils.rs
+++ b/clippy_lints/src/utils/hir_utils.rs
@@ -309,18 +309,15 @@ fn swap_binop<'a>(
     rhs: &'a Expr<'a>,
 ) -> Option<(BinOpKind, &'a Expr<'a>, &'a Expr<'a>)> {
     match binop {
-        BinOpKind::Add
-        | BinOpKind::Mul
-        | BinOpKind::Eq
-        | BinOpKind::Ne
-        | BinOpKind::BitAnd
-        | BinOpKind::BitXor
-        | BinOpKind::BitOr => Some((binop, rhs, lhs)),
+        BinOpKind::Add | BinOpKind::Eq | BinOpKind::Ne | BinOpKind::BitAnd | BinOpKind::BitXor | BinOpKind::BitOr => {
+            Some((binop, rhs, lhs))
+        },
         BinOpKind::Lt => Some((BinOpKind::Gt, rhs, lhs)),
         BinOpKind::Le => Some((BinOpKind::Ge, rhs, lhs)),
         BinOpKind::Ge => Some((BinOpKind::Le, rhs, lhs)),
         BinOpKind::Gt => Some((BinOpKind::Lt, rhs, lhs)),
-        BinOpKind::Shl
+        BinOpKind::Mul
+        | BinOpKind::Shl
         | BinOpKind::Shr
         | BinOpKind::Rem
         | BinOpKind::Sub
diff --git a/tests/ui/if_same_then_else.rs b/tests/ui/if_same_then_else.rs
index 6bbf79edfcf..9c5fe02f751 100644
--- a/tests/ui/if_same_then_else.rs
+++ b/tests/ui/if_same_then_else.rs
@@ -142,4 +142,16 @@ fn func() {
 
 fn f(val: &[u8]) {}
 
+mod issue_5698 {
+    fn mul_not_always_commutative(x: i32, y: i32) -> i32 {
+        if x == 42 {
+            x * y
+        } else if x == 21 {
+            y * x
+        } else {
+            0
+        }
+    }
+}
+
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 2f74283fce768a262387fe7f51e1e4ebb9b0e300 Mon Sep 17 00:00:00 2001
From: Eduardo Broto <ebroto@tutanota.com>
Date: Wed, 10 Jun 2020 00:14:02 +0200
Subject: Add a comment linking to the issue

---
 clippy_lints/src/utils/hir_utils.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/hir_utils.rs b/clippy_lints/src/utils/hir_utils.rs
index 6846658b6e2..9c2c96203c0 100644
--- a/clippy_lints/src/utils/hir_utils.rs
+++ b/clippy_lints/src/utils/hir_utils.rs
@@ -316,7 +316,7 @@ fn swap_binop<'a>(
         BinOpKind::Le => Some((BinOpKind::Ge, rhs, lhs)),
         BinOpKind::Ge => Some((BinOpKind::Le, rhs, lhs)),
         BinOpKind::Gt => Some((BinOpKind::Lt, rhs, lhs)),
-        BinOpKind::Mul
+        BinOpKind::Mul // Not always commutative, e.g. with matrices. See issue #5698
         | BinOpKind::Shl
         | BinOpKind::Shr
         | BinOpKind::Rem
-- 
cgit 1.4.1-3-g733a5


From 56f25e3e62dbdd8f84a9152bbfb73a35055363dd Mon Sep 17 00:00:00 2001
From: David Tolnay <dtolnay@gmail.com>
Date: Wed, 10 Jun 2020 19:29:11 -0700
Subject: Downgrade unnested_or_patterns to pedantic

---
 clippy_lints/src/lib.rs                  | 3 +--
 clippy_lints/src/unnested_or_patterns.rs | 2 +-
 src/lintlist/mod.rs                      | 2 +-
 3 files changed, 3 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 021fbe932d8..19e1b00050a 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1187,6 +1187,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&types::OPTION_OPTION),
         LintId::of(&unicode::NON_ASCII_LITERAL),
         LintId::of(&unicode::UNICODE_NOT_NFC),
+        LintId::of(&unnested_or_patterns::UNNESTED_OR_PATTERNS),
         LintId::of(&unused_self::UNUSED_SELF),
         LintId::of(&wildcard_imports::ENUM_GLOB_USE),
         LintId::of(&wildcard_imports::WILDCARD_IMPORTS),
@@ -1440,7 +1441,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&unnamed_address::FN_ADDRESS_COMPARISONS),
         LintId::of(&unnamed_address::VTABLE_ADDRESS_COMPARISONS),
         LintId::of(&unnecessary_sort_by::UNNECESSARY_SORT_BY),
-        LintId::of(&unnested_or_patterns::UNNESTED_OR_PATTERNS),
         LintId::of(&unsafe_removed_from_name::UNSAFE_REMOVED_FROM_NAME),
         LintId::of(&unused_io_amount::UNUSED_IO_AMOUNT),
         LintId::of(&unwrap::PANICKING_UNWRAP),
@@ -1624,7 +1624,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&types::UNNECESSARY_CAST),
         LintId::of(&types::VEC_BOX),
         LintId::of(&unnecessary_sort_by::UNNECESSARY_SORT_BY),
-        LintId::of(&unnested_or_patterns::UNNESTED_OR_PATTERNS),
         LintId::of(&unwrap::UNNECESSARY_UNWRAP),
         LintId::of(&useless_conversion::USELESS_CONVERSION),
         LintId::of(&zero_div_zero::ZERO_DIVIDED_BY_ZERO),
diff --git a/clippy_lints/src/unnested_or_patterns.rs b/clippy_lints/src/unnested_or_patterns.rs
index 8c281126c32..4d3682263f1 100644
--- a/clippy_lints/src/unnested_or_patterns.rs
+++ b/clippy_lints/src/unnested_or_patterns.rs
@@ -45,7 +45,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     pub UNNESTED_OR_PATTERNS,
-    complexity,
+    pedantic,
     "unnested or-patterns, e.g., `Foo(Bar) | Foo(Baz) instead of `Foo(Bar | Baz)`"
 }
 
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index cac3cc6bdb3..edceb755180 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -2329,7 +2329,7 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
     },
     Lint {
         name: "unnested_or_patterns",
-        group: "complexity",
+        group: "pedantic",
         desc: "unnested or-patterns, e.g., `Foo(Bar) | Foo(Baz) instead of `Foo(Bar | Baz)`",
         deprecation: None,
         module: "unnested_or_patterns",
-- 
cgit 1.4.1-3-g733a5


From b21ef2b365ef4f5c973327f3f6064b8be42d1dae Mon Sep 17 00:00:00 2001
From: Eduardo Broto <ebroto@tutanota.com>
Date: Sat, 13 Jun 2020 00:52:32 +0200
Subject: Fix ICE in consts::binop

---
 clippy_lints/src/consts.rs   |  2 +-
 tests/ui/crashes/ice-5389.rs | 13 +++++++++++++
 2 files changed, 14 insertions(+), 1 deletion(-)
 create mode 100644 tests/ui/crashes/ice-5389.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/consts.rs b/clippy_lints/src/consts.rs
index 81ddc8c0067..e3c6908b76b 100644
--- a/clippy_lints/src/consts.rs
+++ b/clippy_lints/src/consts.rs
@@ -396,7 +396,7 @@ impl<'c, 'cc> ConstEvalLateContext<'c, 'cc> {
         let l = self.expr(left)?;
         let r = self.expr(right);
         match (l, r) {
-            (Constant::Int(l), Some(Constant::Int(r))) => match self.tables.expr_ty(left).kind {
+            (Constant::Int(l), Some(Constant::Int(r))) => match self.tables.expr_ty_opt(left)?.kind {
                 ty::Int(ity) => {
                     let l = sext(self.lcx.tcx, l, ity);
                     let r = sext(self.lcx.tcx, r, ity);
diff --git a/tests/ui/crashes/ice-5389.rs b/tests/ui/crashes/ice-5389.rs
new file mode 100644
index 00000000000..de262199004
--- /dev/null
+++ b/tests/ui/crashes/ice-5389.rs
@@ -0,0 +1,13 @@
+#![allow(clippy::explicit_counter_loop)]
+
+fn main() {
+    let v = vec![1, 2, 3];
+    let mut i = 0;
+    let max_storage_size = [0; 128 * 1024];
+    for item in &v {
+        bar(i, *item);
+        i += 1;
+    }
+}
+
+fn bar(_: usize, _: u32) {}
-- 
cgit 1.4.1-3-g733a5


From dee794f4503dda6a10891b49a7cb2f8bb92e001b Mon Sep 17 00:00:00 2001
From: Bastian Kauschke <bastian_kauschke@hotmail.de>
Date: Sat, 13 Jun 2020 12:42:58 +0200
Subject: typo

---
 clippy_lints/src/new_without_default.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/new_without_default.rs b/clippy_lints/src/new_without_default.rs
index dd236535c18..42200385932 100644
--- a/clippy_lints/src/new_without_default.rs
+++ b/clippy_lints/src/new_without_default.rs
@@ -33,7 +33,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     ///
-    /// To fix the lint, and a `Default` implementation that delegates to `new`:
+    /// To fix the lint, add a `Default` implementation that delegates to `new`:
     ///
     /// ```ignore
     /// struct Foo(Bar);
-- 
cgit 1.4.1-3-g733a5


From f663a21c8f51db58ff73e2e0d9852d03e8916a5e Mon Sep 17 00:00:00 2001
From: Iain Brandram-Adams <ijijnj@gmail.com>
Date: Sun, 14 Jun 2020 01:24:36 +1200
Subject: Remove `bar` from blacklisted names

---
 clippy_lints/src/utils/conf.rs |  2 +-
 tests/ui/blacklisted_name.rs   | 23 +++++++++++++----------
 2 files changed, 14 insertions(+), 11 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 9e8e0ff30ec..418c4ded544 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -107,7 +107,7 @@ macro_rules! define_Conf {
 pub use self::helpers::Conf;
 define_Conf! {
     /// Lint: BLACKLISTED_NAME. The list of blacklisted names to lint about
-    (blacklisted_names, "blacklisted_names": Vec<String>, ["foo", "bar", "baz", "quux"].iter().map(ToString::to_string).collect()),
+    (blacklisted_names, "blacklisted_names": Vec<String>, ["foo", "baz", "quux"].iter().map(ToString::to_string).collect()),
     /// Lint: COGNITIVE_COMPLEXITY. The maximum cognitive complexity a function can have
     (cognitive_complexity_threshold, "cognitive_complexity_threshold": u64, 25),
     /// DEPRECATED LINT: CYCLOMATIC_COMPLEXITY. Use the Cognitive Complexity lint instead.
diff --git a/tests/ui/blacklisted_name.rs b/tests/ui/blacklisted_name.rs
index ca9d8d16b78..3d87eb06181 100644
--- a/tests/ui/blacklisted_name.rs
+++ b/tests/ui/blacklisted_name.rs
@@ -12,29 +12,32 @@ fn test(foo: ()) {}
 
 fn main() {
     let foo = 42;
-    let bar = 42;
     let baz = 42;
+    let quux = 42;
+    // Unlike these others, `bar` is considered an acceptable name to use.
+    // See https://github.com/rust-lang/rust-clippy/issues/5225.
 
-    let barb = 42;
-    let barbaric = 42;
+    let food = 42;
+    let foodstuffs = 42;
+    let bazaar = 42;
 
     match (42, Some(1337), Some(0)) {
-        (foo, Some(bar), baz @ Some(_)) => (),
+        (foo, Some(baz), quux @ Some(_)) => (),
         _ => (),
     }
 }
 
 fn issue_1647(mut foo: u8) {
-    let mut bar = 0;
-    if let Some(mut baz) = Some(42) {}
+    let mut baz = 0;
+    if let Some(mut quux) = Some(42) {}
 }
 
 fn issue_1647_ref() {
-    let ref bar = 0;
-    if let Some(ref baz) = Some(42) {}
+    let ref baz = 0;
+    if let Some(ref quux) = Some(42) {}
 }
 
 fn issue_1647_ref_mut() {
-    let ref mut bar = 0;
-    if let Some(ref mut baz) = Some(42) {}
+    let ref mut baz = 0;
+    if let Some(ref mut quux) = Some(42) {}
 }
-- 
cgit 1.4.1-3-g733a5


From 40ee620e51c86c72e3c2b65df71f5f0a4a79797f Mon Sep 17 00:00:00 2001
From: Teddy_Wang <wangtheo662@gmail.com>
Date: Mon, 8 Jun 2020 00:35:10 -0400
Subject: Added a lint for .map(|x| x)

---
 CHANGELOG.md                     |   1 +
 clippy_lints/src/lib.rs          |   5 ++
 clippy_lints/src/map_identity.rs | 126 +++++++++++++++++++++++++++++++++++++++
 src/lintlist/mod.rs              |   7 +++
 tests/ui/map_flatten.fixed       |   1 +
 tests/ui/map_flatten.rs          |   1 +
 tests/ui/map_flatten.stderr      |   4 +-
 tests/ui/map_identity.fixed      |  23 +++++++
 tests/ui/map_identity.rs         |  25 ++++++++
 tests/ui/map_identity.stderr     |  37 ++++++++++++
 10 files changed, 228 insertions(+), 2 deletions(-)
 create mode 100644 clippy_lints/src/map_identity.rs
 create mode 100644 tests/ui/map_identity.fixed
 create mode 100644 tests/ui/map_identity.rs
 create mode 100644 tests/ui/map_identity.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index adc945a6944..d6186c319d0 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1508,6 +1508,7 @@ Released 2018-09-13
 [`map_clone`]: https://rust-lang.github.io/rust-clippy/master/index.html#map_clone
 [`map_entry`]: https://rust-lang.github.io/rust-clippy/master/index.html#map_entry
 [`map_flatten`]: https://rust-lang.github.io/rust-clippy/master/index.html#map_flatten
+[`map_identity`]: https://rust-lang.github.io/rust-clippy/master/index.html#map_identity
 [`map_unwrap_or`]: https://rust-lang.github.io/rust-clippy/master/index.html#map_unwrap_or
 [`match_as_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#match_as_ref
 [`match_bool`]: https://rust-lang.github.io/rust-clippy/master/index.html#match_bool
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 021fbe932d8..8b5e0b84eb4 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -252,6 +252,7 @@ mod main_recursion;
 mod manual_async_fn;
 mod manual_non_exhaustive;
 mod map_clone;
+mod map_identity;
 mod map_unit_fn;
 mod match_on_vec_items;
 mod matches;
@@ -631,6 +632,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &manual_async_fn::MANUAL_ASYNC_FN,
         &manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE,
         &map_clone::MAP_CLONE,
+        &map_identity::MAP_IDENTITY,
         &map_unit_fn::OPTION_MAP_UNIT_FN,
         &map_unit_fn::RESULT_MAP_UNIT_FN,
         &match_on_vec_items::MATCH_ON_VEC_ITEMS,
@@ -1080,6 +1082,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     });
     store.register_early_pass(|| box unnested_or_patterns::UnnestedOrPatterns);
     store.register_late_pass(|| box macro_use::MacroUseImports::default());
+    store.register_late_pass(|| box map_identity::MapIdentity);
 
     store.register_group(true, "clippy::restriction", Some("clippy_restriction"), vec![
         LintId::of(&arithmetic::FLOAT_ARITHMETIC),
@@ -1295,6 +1298,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&manual_async_fn::MANUAL_ASYNC_FN),
         LintId::of(&manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE),
         LintId::of(&map_clone::MAP_CLONE),
+        LintId::of(&map_identity::MAP_IDENTITY),
         LintId::of(&map_unit_fn::OPTION_MAP_UNIT_FN),
         LintId::of(&map_unit_fn::RESULT_MAP_UNIT_FN),
         LintId::of(&matches::INFALLIBLE_DESTRUCTURING_MATCH),
@@ -1573,6 +1577,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&loops::EXPLICIT_COUNTER_LOOP),
         LintId::of(&loops::MUT_RANGE_BOUND),
         LintId::of(&loops::WHILE_LET_LOOP),
+        LintId::of(&map_identity::MAP_IDENTITY),
         LintId::of(&map_unit_fn::OPTION_MAP_UNIT_FN),
         LintId::of(&map_unit_fn::RESULT_MAP_UNIT_FN),
         LintId::of(&matches::MATCH_AS_REF),
diff --git a/clippy_lints/src/map_identity.rs b/clippy_lints/src/map_identity.rs
new file mode 100644
index 00000000000..9bc8f1bec1b
--- /dev/null
+++ b/clippy_lints/src/map_identity.rs
@@ -0,0 +1,126 @@
+use crate::utils::{
+    is_adjusted, is_type_diagnostic_item, match_path, match_trait_method, match_var, paths, remove_blocks,
+    span_lint_and_sugg,
+};
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir::{Body, Expr, ExprKind, Pat, PatKind, QPath, StmtKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for instances of `map(f)` where `f` is the identity function.
+    ///
+    /// **Why is this bad?** It can be written more concisely without the call to `map`.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// let x = [1, 2, 3];
+    /// let y: Vec<_> = x.iter().map(|x| x).map(|x| 2*x).collect();
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// let x = [1, 2, 3];
+    /// let y: Vec<_> = x.iter().map(|x| 2*x).collect();
+    /// ```
+    pub MAP_IDENTITY,
+    complexity,
+    "using iterator.map(|x| x)"
+}
+
+declare_lint_pass!(MapIdentity => [MAP_IDENTITY]);
+
+impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MapIdentity {
+    fn check_expr(&mut self, cx: &LateContext<'_, '_>, expr: &Expr<'_>) {
+        if expr.span.from_expansion() {
+            return;
+        }
+
+        if_chain! {
+            if let Some([caller, func]) = get_map_argument(cx, expr);
+            if is_expr_identity_function(cx, func);
+            then {
+                span_lint_and_sugg(
+                    cx,
+                    MAP_IDENTITY,
+                    expr.span.trim_start(caller.span).unwrap(),
+                    "unnecessary map of the identity function",
+                    "remove the call to `map`",
+                    String::new(),
+                    Applicability::MachineApplicable
+                )
+            }
+        }
+    }
+}
+
+/// Returns the arguments passed into map() if the expression is a method call to
+/// map(). Otherwise, returns None.
+fn get_map_argument<'a>(cx: &LateContext<'_, '_>, expr: &'a Expr<'a>) -> Option<&'a [Expr<'a>]> {
+    if_chain! {
+        if let ExprKind::MethodCall(ref method, _, ref args) = expr.kind;
+        if args.len() == 2 && method.ident.as_str() == "map";
+        let caller_ty = cx.tables.expr_ty(&args[0]);
+        if match_trait_method(cx, expr, &paths::ITERATOR)
+            || is_type_diagnostic_item(cx, caller_ty, sym!(result_type))
+            || is_type_diagnostic_item(cx, caller_ty, sym!(option_type));
+        then {
+            Some(args)
+        } else {
+            None
+        }
+    }
+}
+
+/// Checks if an expression represents the identity function
+/// Only examines closures and `std::convert::identity`
+fn is_expr_identity_function(cx: &LateContext<'_, '_>, expr: &Expr<'_>) -> bool {
+    match expr.kind {
+        ExprKind::Closure(_, _, body_id, _, _) => is_body_identity_function(cx, cx.tcx.hir().body(body_id)),
+        ExprKind::Path(QPath::Resolved(_, ref path)) => match_path(path, &paths::STD_CONVERT_IDENTITY),
+        _ => false,
+    }
+}
+
+/// Checks if a function's body represents the identity function
+/// Looks for bodies of the form `|x| x`, `|x| return x`, `|x| { return x }` or `|x| {
+/// return x; }`
+fn is_body_identity_function(cx: &LateContext<'_, '_>, func: &Body<'_>) -> bool {
+    let params = func.params;
+    let body = remove_blocks(&func.value);
+
+    // if there's less/more than one parameter, then it is not the identity function
+    if params.len() != 1 {
+        return false;
+    }
+
+    match body.kind {
+        ExprKind::Path(QPath::Resolved(None, _)) => match_expr_param(cx, body, params[0].pat),
+        ExprKind::Ret(Some(ref ret_val)) => match_expr_param(cx, ret_val, params[0].pat),
+        ExprKind::Block(ref block, _) => {
+            if_chain! {
+                if block.stmts.len() == 1;
+                if let StmtKind::Semi(ref expr) | StmtKind::Expr(ref expr) = block.stmts[0].kind;
+                if let ExprKind::Ret(Some(ref ret_val)) = expr.kind;
+                then {
+                    match_expr_param(cx, ret_val, params[0].pat)
+                } else {
+                    false
+                }
+            }
+        },
+        _ => false,
+    }
+}
+
+/// Returns true iff an expression returns the same thing as a parameter's pattern
+fn match_expr_param(cx: &LateContext<'_, '_>, expr: &Expr<'_>, pat: &Pat<'_>) -> bool {
+    if let PatKind::Binding(_, _, ident, _) = pat.kind {
+        match_var(expr, ident.name) && !(cx.tables.hir_owner == Some(expr.hir_id.owner) && is_adjusted(cx, expr))
+    } else {
+        false
+    }
+}
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index cac3cc6bdb3..a9cd5469048 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -1144,6 +1144,13 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
         deprecation: None,
         module: "methods",
     },
+    Lint {
+        name: "map_identity",
+        group: "complexity",
+        desc: "using iterator.map(|x| x)",
+        deprecation: None,
+        module: "map_identity",
+    },
     Lint {
         name: "map_unwrap_or",
         group: "pedantic",
diff --git a/tests/ui/map_flatten.fixed b/tests/ui/map_flatten.fixed
index 7ac368878ab..4171d80f48a 100644
--- a/tests/ui/map_flatten.fixed
+++ b/tests/ui/map_flatten.fixed
@@ -2,6 +2,7 @@
 
 #![warn(clippy::all, clippy::pedantic)]
 #![allow(clippy::missing_docs_in_private_items)]
+#![allow(clippy::map_identity)]
 
 fn main() {
     let _: Vec<_> = vec![5_i8; 6].into_iter().flat_map(|x| 0..x).collect();
diff --git a/tests/ui/map_flatten.rs b/tests/ui/map_flatten.rs
index a608601039c..16a0fd090ad 100644
--- a/tests/ui/map_flatten.rs
+++ b/tests/ui/map_flatten.rs
@@ -2,6 +2,7 @@
 
 #![warn(clippy::all, clippy::pedantic)]
 #![allow(clippy::missing_docs_in_private_items)]
+#![allow(clippy::map_identity)]
 
 fn main() {
     let _: Vec<_> = vec![5_i8; 6].into_iter().map(|x| 0..x).flatten().collect();
diff --git a/tests/ui/map_flatten.stderr b/tests/ui/map_flatten.stderr
index 3cf2abd5b6d..00bc41c15e9 100644
--- a/tests/ui/map_flatten.stderr
+++ b/tests/ui/map_flatten.stderr
@@ -1,5 +1,5 @@
 error: called `map(..).flatten()` on an `Iterator`. This is more succinctly expressed by calling `.flat_map(..)`
-  --> $DIR/map_flatten.rs:7:21
+  --> $DIR/map_flatten.rs:8:21
    |
 LL |     let _: Vec<_> = vec![5_i8; 6].into_iter().map(|x| 0..x).flatten().collect();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try using `flat_map` instead: `vec![5_i8; 6].into_iter().flat_map(|x| 0..x)`
@@ -7,7 +7,7 @@ LL |     let _: Vec<_> = vec![5_i8; 6].into_iter().map(|x| 0..x).flatten().colle
    = note: `-D clippy::map-flatten` implied by `-D warnings`
 
 error: called `map(..).flatten()` on an `Option`. This is more succinctly expressed by calling `.and_then(..)`
-  --> $DIR/map_flatten.rs:8:24
+  --> $DIR/map_flatten.rs:9:24
    |
 LL |     let _: Option<_> = (Some(Some(1))).map(|x| x).flatten();
    |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try using `and_then` instead: `(Some(Some(1))).and_then(|x| x)`
diff --git a/tests/ui/map_identity.fixed b/tests/ui/map_identity.fixed
new file mode 100644
index 00000000000..4a1452b25f3
--- /dev/null
+++ b/tests/ui/map_identity.fixed
@@ -0,0 +1,23 @@
+// run-rustfix
+#![warn(clippy::map_identity)]
+#![allow(clippy::needless_return)]
+
+fn main() {
+    let x: [u16; 3] = [1, 2, 3];
+    // should lint
+    let _: Vec<_> = x.iter().map(not_identity).collect();
+    let _: Vec<_> = x.iter().collect();
+    let _: Option<u8> = Some(3);
+    let _: Result<i8, f32> = Ok(-3);
+    // should not lint
+    let _: Vec<_> = x.iter().map(|x| 2 * x).collect();
+    let _: Vec<_> = x.iter().map(not_identity).map(|x| return x - 4).collect();
+    let _: Option<u8> = None.map(|x: u8| x - 1);
+    let _: Result<i8, f32> = Err(2.3).map(|x: i8| {
+        return x + 3;
+    });
+}
+
+fn not_identity(x: &u16) -> u16 {
+    *x
+}
diff --git a/tests/ui/map_identity.rs b/tests/ui/map_identity.rs
new file mode 100644
index 00000000000..65c7e6e1ea5
--- /dev/null
+++ b/tests/ui/map_identity.rs
@@ -0,0 +1,25 @@
+// run-rustfix
+#![warn(clippy::map_identity)]
+#![allow(clippy::needless_return)]
+
+fn main() {
+    let x: [u16; 3] = [1, 2, 3];
+    // should lint
+    let _: Vec<_> = x.iter().map(not_identity).map(|x| return x).collect();
+    let _: Vec<_> = x.iter().map(std::convert::identity).map(|y| y).collect();
+    let _: Option<u8> = Some(3).map(|x| x);
+    let _: Result<i8, f32> = Ok(-3).map(|x| {
+        return x;
+    });
+    // should not lint
+    let _: Vec<_> = x.iter().map(|x| 2 * x).collect();
+    let _: Vec<_> = x.iter().map(not_identity).map(|x| return x - 4).collect();
+    let _: Option<u8> = None.map(|x: u8| x - 1);
+    let _: Result<i8, f32> = Err(2.3).map(|x: i8| {
+        return x + 3;
+    });
+}
+
+fn not_identity(x: &u16) -> u16 {
+    *x
+}
diff --git a/tests/ui/map_identity.stderr b/tests/ui/map_identity.stderr
new file mode 100644
index 00000000000..e4a0320cbda
--- /dev/null
+++ b/tests/ui/map_identity.stderr
@@ -0,0 +1,37 @@
+error: unnecessary map of the identity function
+  --> $DIR/map_identity.rs:8:47
+   |
+LL |     let _: Vec<_> = x.iter().map(not_identity).map(|x| return x).collect();
+   |                                               ^^^^^^^^^^^^^^^^^^ help: remove the call to `map`
+   |
+   = note: `-D clippy::map-identity` implied by `-D warnings`
+
+error: unnecessary map of the identity function
+  --> $DIR/map_identity.rs:9:57
+   |
+LL |     let _: Vec<_> = x.iter().map(std::convert::identity).map(|y| y).collect();
+   |                                                         ^^^^^^^^^^^ help: remove the call to `map`
+
+error: unnecessary map of the identity function
+  --> $DIR/map_identity.rs:9:29
+   |
+LL |     let _: Vec<_> = x.iter().map(std::convert::identity).map(|y| y).collect();
+   |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove the call to `map`
+
+error: unnecessary map of the identity function
+  --> $DIR/map_identity.rs:10:32
+   |
+LL |     let _: Option<u8> = Some(3).map(|x| x);
+   |                                ^^^^^^^^^^^ help: remove the call to `map`
+
+error: unnecessary map of the identity function
+  --> $DIR/map_identity.rs:11:36
+   |
+LL |       let _: Result<i8, f32> = Ok(-3).map(|x| {
+   |  ____________________________________^
+LL | |         return x;
+LL | |     });
+   | |______^ help: remove the call to `map`
+
+error: aborting due to 5 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 454ed47acf462c847956464ac3811546b733bd5b Mon Sep 17 00:00:00 2001
From: Iain Brandram-Adams <ijijnj@gmail.com>
Date: Sun, 14 Jun 2020 12:46:56 +1200
Subject: Update comment in conf.rs

---
 clippy_lints/src/utils/conf.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 418c4ded544..c41befbf147 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -106,7 +106,7 @@ macro_rules! define_Conf {
 
 pub use self::helpers::Conf;
 define_Conf! {
-    /// Lint: BLACKLISTED_NAME. The list of blacklisted names to lint about
+    /// Lint: BLACKLISTED_NAME. The list of blacklisted names to lint about. NB: `bar` is not here since it has legitimate uses
     (blacklisted_names, "blacklisted_names": Vec<String>, ["foo", "baz", "quux"].iter().map(ToString::to_string).collect()),
     /// Lint: COGNITIVE_COMPLEXITY. The maximum cognitive complexity a function can have
     (cognitive_complexity_threshold, "cognitive_complexity_threshold": u64, 25),
-- 
cgit 1.4.1-3-g733a5


From 8a6f42a9707bbad1dad3f1511f793cd07c723bb7 Mon Sep 17 00:00:00 2001
From: Dániel Buga <bugadani@gmail.com>
Date: Sun, 14 Jun 2020 11:07:44 +0200
Subject: Fix typo in wildcard_imports

---
 clippy_lints/src/wildcard_imports.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/wildcard_imports.rs b/clippy_lints/src/wildcard_imports.rs
index b637253bd02..79f7705e281 100644
--- a/clippy_lints/src/wildcard_imports.rs
+++ b/clippy_lints/src/wildcard_imports.rs
@@ -36,7 +36,7 @@ declare_clippy_lint! {
 declare_clippy_lint! {
     /// **What it does:** Checks for wildcard imports `use _::*`.
     ///
-    /// **Why is this bad?** wildcard imports can polute the namespace. This is especially bad if
+    /// **Why is this bad?** wildcard imports can pollute the namespace. This is especially bad if
     /// you try to import something through a wildcard, that already has been imported by name from
     /// a different source:
     ///
-- 
cgit 1.4.1-3-g733a5


From 8c1ee063bb67b20ac17603d0f0025b48b958cc08 Mon Sep 17 00:00:00 2001
From: Ericko Samudera <ericko.samudera@gmail.com>
Date: Mon, 8 Jun 2020 00:44:14 +0700
Subject: mem_replace_with_uninit: suggest std::ptr::read

---
 clippy_lints/src/mem_replace.rs | 82 +++++++++++++++++++++++++++--------------
 tests/ui/repl_uninit.rs         |  6 +++
 tests/ui/repl_uninit.stderr     | 19 ++++++----
 3 files changed, 71 insertions(+), 36 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/mem_replace.rs b/clippy_lints/src/mem_replace.rs
index ab6865bf0f3..e2672e02b36 100644
--- a/clippy_lints/src/mem_replace.rs
+++ b/clippy_lints/src/mem_replace.rs
@@ -135,33 +135,59 @@ fn check_replace_option_with_none(cx: &LateContext<'_, '_>, src: &Expr<'_>, dest
     }
 }
 
-fn check_replace_with_uninit(cx: &LateContext<'_, '_>, src: &Expr<'_>, expr_span: Span) {
-    if let ExprKind::Call(ref repl_func, ref repl_args) = src.kind {
-        if_chain! {
-            if repl_args.is_empty();
-            if let ExprKind::Path(ref repl_func_qpath) = repl_func.kind;
-            if let Some(repl_def_id) = cx.tables.qpath_res(repl_func_qpath, repl_func.hir_id).opt_def_id();
-            then {
-                if cx.tcx.is_diagnostic_item(sym::mem_uninitialized, repl_def_id) {
-                    span_lint_and_help(
-                        cx,
-                        MEM_REPLACE_WITH_UNINIT,
-                        expr_span,
-                        "replacing with `mem::uninitialized()`",
-                        None,
-                        "consider using the `take_mut` crate instead",
-                    );
-                } else if cx.tcx.is_diagnostic_item(sym::mem_zeroed, repl_def_id) &&
-                        !cx.tables.expr_ty(src).is_primitive() {
-                    span_lint_and_help(
-                        cx,
-                        MEM_REPLACE_WITH_UNINIT,
-                        expr_span,
-                        "replacing with `mem::zeroed()`",
-                        None,
-                        "consider using a default value or the `take_mut` crate instead",
-                    );
-                }
+fn check_replace_with_uninit(cx: &LateContext<'_, '_>, src: &Expr<'_>, dest: &Expr<'_>, expr_span: Span) {
+    if_chain! {
+        // check if replacement is mem::MaybeUninit::uninit().assume_init()
+        if let Some(method_def_id) = cx.tables.type_dependent_def_id(src.hir_id);
+        if cx.tcx.is_diagnostic_item(sym::assume_init, method_def_id);
+        then {
+            let mut applicability = Applicability::MachineApplicable;
+            span_lint_and_sugg(
+                cx,
+                MEM_REPLACE_WITH_UNINIT,
+                expr_span,
+                "replacing with `mem::MaybeUninit::uninit().assume_init()`",
+                "consider using",
+                format!(
+                    "std::ptr::read({})",
+                    snippet_with_applicability(cx, dest.span, "", &mut applicability)
+                ),
+                applicability,
+            );
+            return;
+        }
+    }
+
+    if_chain! {
+        if let ExprKind::Call(ref repl_func, ref repl_args) = src.kind;
+        if repl_args.is_empty();
+        if let ExprKind::Path(ref repl_func_qpath) = repl_func.kind;
+        if let Some(repl_def_id) = cx.tables.qpath_res(repl_func_qpath, repl_func.hir_id).opt_def_id();
+        then {
+            if cx.tcx.is_diagnostic_item(sym::mem_uninitialized, repl_def_id) {
+                let mut applicability = Applicability::MachineApplicable;
+                span_lint_and_sugg(
+                    cx,
+                    MEM_REPLACE_WITH_UNINIT,
+                    expr_span,
+                    "replacing with `mem::uninitialized()`",
+                    "consider using",
+                    format!(
+                        "std::ptr::read({})",
+                        snippet_with_applicability(cx, dest.span, "", &mut applicability)
+                    ),
+                    applicability,
+                );
+            } else if cx.tcx.is_diagnostic_item(sym::mem_zeroed, repl_def_id) &&
+                    !cx.tables.expr_ty(src).is_primitive() {
+                span_lint_and_help(
+                    cx,
+                    MEM_REPLACE_WITH_UNINIT,
+                    expr_span,
+                    "replacing with `mem::zeroed()`",
+                    None,
+                    "consider using a default value or the `take_mut` crate instead",
+                );
             }
         }
     }
@@ -209,7 +235,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MemReplace {
             if let [dest, src] = &**func_args;
             then {
                 check_replace_option_with_none(cx, src, dest, expr.span);
-                check_replace_with_uninit(cx, src, expr.span);
+                check_replace_with_uninit(cx, src, dest, expr.span);
                 check_replace_with_default(cx, src, dest, expr.span);
             }
         }
diff --git a/tests/ui/repl_uninit.rs b/tests/ui/repl_uninit.rs
index 346972b7bb4..ad5b8e4857d 100644
--- a/tests/ui/repl_uninit.rs
+++ b/tests/ui/repl_uninit.rs
@@ -17,6 +17,12 @@ fn main() {
         std::mem::forget(mem::replace(&mut v, new_v));
     }
 
+    unsafe {
+        let taken_v = mem::replace(&mut v, mem::MaybeUninit::uninit().assume_init());
+        let new_v = might_panic(taken_v);
+        std::mem::forget(mem::replace(&mut v, new_v));
+    }
+
     unsafe {
         let taken_v = mem::replace(&mut v, mem::zeroed());
         let new_v = might_panic(taken_v);
diff --git a/tests/ui/repl_uninit.stderr b/tests/ui/repl_uninit.stderr
index c1f55d7601e..09468eeaea4 100644
--- a/tests/ui/repl_uninit.stderr
+++ b/tests/ui/repl_uninit.stderr
@@ -2,26 +2,29 @@ error: replacing with `mem::uninitialized()`
   --> $DIR/repl_uninit.rs:15:23
    |
 LL |         let taken_v = mem::replace(&mut v, mem::uninitialized());
-   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::ptr::read(&mut v)`
    |
    = note: `-D clippy::mem-replace-with-uninit` implied by `-D warnings`
-   = help: consider using the `take_mut` crate instead
 
-error: replacing with `mem::zeroed()`
+error: replacing with `mem::MaybeUninit::uninit().assume_init()`
   --> $DIR/repl_uninit.rs:21:23
    |
+LL |         let taken_v = mem::replace(&mut v, mem::MaybeUninit::uninit().assume_init());
+   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::ptr::read(&mut v)`
+
+error: replacing with `mem::zeroed()`
+  --> $DIR/repl_uninit.rs:27:23
+   |
 LL |         let taken_v = mem::replace(&mut v, mem::zeroed());
    |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: consider using a default value or the `take_mut` crate instead
 
 error: replacing with `mem::uninitialized()`
-  --> $DIR/repl_uninit.rs:33:28
+  --> $DIR/repl_uninit.rs:39:28
    |
 LL |     let taken_u = unsafe { mem::replace(uref, mem::uninitialized()) };
-   |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: consider using the `take_mut` crate instead
+   |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::ptr::read(uref)`
 
-error: aborting due to 3 previous errors
+error: aborting due to 4 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From a7743e9084f9ccd7c966f98a14fa667c694d66ab Mon Sep 17 00:00:00 2001
From: Eduardo Broto <ebroto@tutanota.com>
Date: Wed, 17 Jun 2020 00:32:47 +0200
Subject: redundant_pattern_matching: avoid non-const fn in const context

---
 clippy_lints/src/redundant_pattern_matching.rs     | 80 +++++++++++++++++-----
 tests/ui/redundant_pattern_matching.fixed          | 42 ++++++++++++
 tests/ui/redundant_pattern_matching.rs             | 42 ++++++++++++
 tests/ui/redundant_pattern_matching.stderr         | 56 +++++++--------
 .../redundant_pattern_matching_const_result.fixed  | 46 +++++++++++++
 .../ui/redundant_pattern_matching_const_result.rs  | 52 ++++++++++++++
 .../redundant_pattern_matching_const_result.stderr | 46 +++++++++++++
 7 files changed, 318 insertions(+), 46 deletions(-)
 create mode 100644 tests/ui/redundant_pattern_matching_const_result.fixed
 create mode 100644 tests/ui/redundant_pattern_matching_const_result.rs
 create mode 100644 tests/ui/redundant_pattern_matching_const_result.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/redundant_pattern_matching.rs b/clippy_lints/src/redundant_pattern_matching.rs
index 7ee298e9833..b95b12c4eb5 100644
--- a/clippy_lints/src/redundant_pattern_matching.rs
+++ b/clippy_lints/src/redundant_pattern_matching.rs
@@ -1,10 +1,13 @@
-use crate::utils::{match_qpath, match_trait_method, paths, snippet, span_lint_and_then};
+use crate::utils::{in_constant, 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, MatchSource, PatKind, QPath};
+use rustc_hir::{Arm, Expr, ExprKind, HirId, MatchSource, PatKind, QPath};
 use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty;
+use rustc_mir::const_eval::is_const_fn;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::source_map::Symbol;
 
 declare_clippy_lint! {
     /// **What it does:** Lint for redundant pattern matching over `Result` or
@@ -64,26 +67,37 @@ fn find_sugg_for_if_let<'a, 'tcx>(
     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 {
-                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;
-                }
+                find_suggestion(cx, hir_id, path)
             } else {
-                return;
+                None
             }
         },
-
-        PatKind::Path(ref path) if match_qpath(path, &paths::OPTION_NONE) => "is_none()",
-
-        _ => return,
+        PatKind::Path(ref path) => find_suggestion(cx, hir_id, path),
+        _ => None,
+    };
+    let good_method = match good_method {
+        Some(method) => method,
+        None => return,
     };
 
     // check that `while_let_on_iterator` lint does not trigger
@@ -128,6 +142,7 @@ fn find_sugg_for_match<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr<'_
     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, _),
@@ -142,6 +157,8 @@ fn find_sugg_for_match<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr<'_
                         &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
@@ -160,6 +177,8 @@ fn find_sugg_for_match<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr<'_
                         &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
@@ -188,6 +207,7 @@ fn find_sugg_for_match<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr<'_
     }
 }
 
+#[allow(clippy::too_many_arguments)]
 fn find_good_method_for_match<'a>(
     arms: &[Arm<'_>],
     path_left: &QPath<'_>,
@@ -196,6 +216,8 @@ fn find_good_method_for_match<'a>(
     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)
@@ -207,10 +229,32 @@ fn find_good_method_for_match<'a>(
 
     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)) => Some(should_be_left),
-            (LitKind::Bool(false), LitKind::Bool(true)) => Some(should_be_right),
+            (LitKind::Bool(true), LitKind::Bool(false)) if can_suggest_left() => Some(should_be_left),
+            (LitKind::Bool(false), LitKind::Bool(true)) if can_suggest_right() => 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))
+}
diff --git a/tests/ui/redundant_pattern_matching.fixed b/tests/ui/redundant_pattern_matching.fixed
index fc8cb0e747c..6ba5cfb1d71 100644
--- a/tests/ui/redundant_pattern_matching.fixed
+++ b/tests/ui/redundant_pattern_matching.fixed
@@ -1,5 +1,7 @@
 // run-rustfix
 
+#![feature(const_if_match)]
+#![feature(const_loop)]
 #![warn(clippy::all)]
 #![warn(clippy::redundant_pattern_matching)]
 #![allow(clippy::unit_arg, unused_must_use, clippy::needless_bool, deprecated)]
@@ -67,6 +69,7 @@ fn main() {
     takes_bool(x);
 
     issue5504();
+    issue5697();
 
     let _ = if gen_opt().is_some() {
         1
@@ -117,3 +120,42 @@ fn issue5504() {
     if m!().is_some() {}
     while m!().is_some() {}
 }
+
+// None of these should be linted because none of the suggested methods
+// are `const fn` without toggling a feature.
+const fn issue5697() {
+    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,
+    };
+
+    match Err::<i32, i32>(42) {
+        Ok(_) => false,
+        Err(_) => true,
+    };
+    match Some(42) {
+        Some(_) => true,
+        None => false,
+    };
+
+    match None::<()> {
+        Some(_) => false,
+        None => true,
+    };
+}
diff --git a/tests/ui/redundant_pattern_matching.rs b/tests/ui/redundant_pattern_matching.rs
index 51912dade03..17de66f9ad0 100644
--- a/tests/ui/redundant_pattern_matching.rs
+++ b/tests/ui/redundant_pattern_matching.rs
@@ -1,5 +1,7 @@
 // run-rustfix
 
+#![feature(const_if_match)]
+#![feature(const_loop)]
 #![warn(clippy::all)]
 #![warn(clippy::redundant_pattern_matching)]
 #![allow(clippy::unit_arg, unused_must_use, clippy::needless_bool, deprecated)]
@@ -88,6 +90,7 @@ fn main() {
     takes_bool(x);
 
     issue5504();
+    issue5697();
 
     let _ = if let Some(_) = gen_opt() {
         1
@@ -138,3 +141,42 @@ fn issue5504() {
     if let Some(_) = m!() {}
     while let Some(_) = m!() {}
 }
+
+// None of these should be linted because none of the suggested methods
+// are `const fn` without toggling a feature.
+const fn issue5697() {
+    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,
+    };
+
+    match Err::<i32, i32>(42) {
+        Ok(_) => false,
+        Err(_) => true,
+    };
+    match Some(42) {
+        Some(_) => true,
+        None => false,
+    };
+
+    match None::<()> {
+        Some(_) => false,
+        None => true,
+    };
+}
diff --git a/tests/ui/redundant_pattern_matching.stderr b/tests/ui/redundant_pattern_matching.stderr
index b58deb7954e..1b9a4b40a2f 100644
--- a/tests/ui/redundant_pattern_matching.stderr
+++ b/tests/ui/redundant_pattern_matching.stderr
@@ -1,5 +1,5 @@
 error: redundant pattern matching, consider using `is_ok()`
-  --> $DIR/redundant_pattern_matching.rs:8:12
+  --> $DIR/redundant_pattern_matching.rs:10:12
    |
 LL |     if let Ok(_) = Ok::<i32, i32>(42) {}
    |     -------^^^^^--------------------- help: try this: `if Ok::<i32, i32>(42).is_ok()`
@@ -7,67 +7,67 @@ LL |     if let Ok(_) = Ok::<i32, i32>(42) {}
    = note: `-D clippy::redundant-pattern-matching` implied by `-D warnings`
 
 error: redundant pattern matching, consider using `is_err()`
-  --> $DIR/redundant_pattern_matching.rs:10:12
+  --> $DIR/redundant_pattern_matching.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_none()`
-  --> $DIR/redundant_pattern_matching.rs:12:12
+  --> $DIR/redundant_pattern_matching.rs:14: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:14:12
+  --> $DIR/redundant_pattern_matching.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.rs:16:12
+  --> $DIR/redundant_pattern_matching.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.rs:22:15
+  --> $DIR/redundant_pattern_matching.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.rs:24:15
+  --> $DIR/redundant_pattern_matching.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.rs:26:15
+  --> $DIR/redundant_pattern_matching.rs:28: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:28:15
+  --> $DIR/redundant_pattern_matching.rs:30: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:30:15
+  --> $DIR/redundant_pattern_matching.rs:32: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:33:15
+  --> $DIR/redundant_pattern_matching.rs:35: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:49:5
+  --> $DIR/redundant_pattern_matching.rs:51:5
    |
 LL | /     match Ok::<i32, i32>(42) {
 LL | |         Ok(_) => true,
@@ -76,7 +76,7 @@ LL | |     };
    | |_____^ help: try this: `Ok::<i32, i32>(42).is_ok()`
 
 error: redundant pattern matching, consider using `is_err()`
-  --> $DIR/redundant_pattern_matching.rs:54:5
+  --> $DIR/redundant_pattern_matching.rs:56:5
    |
 LL | /     match Ok::<i32, i32>(42) {
 LL | |         Ok(_) => false,
@@ -85,7 +85,7 @@ LL | |     };
    | |_____^ help: try this: `Ok::<i32, i32>(42).is_err()`
 
 error: redundant pattern matching, consider using `is_err()`
-  --> $DIR/redundant_pattern_matching.rs:59:5
+  --> $DIR/redundant_pattern_matching.rs:61:5
    |
 LL | /     match Err::<i32, i32>(42) {
 LL | |         Ok(_) => false,
@@ -94,7 +94,7 @@ LL | |     };
    | |_____^ help: try this: `Err::<i32, i32>(42).is_err()`
 
 error: redundant pattern matching, consider using `is_ok()`
-  --> $DIR/redundant_pattern_matching.rs:64:5
+  --> $DIR/redundant_pattern_matching.rs:66:5
    |
 LL | /     match Err::<i32, i32>(42) {
 LL | |         Ok(_) => true,
@@ -103,7 +103,7 @@ LL | |     };
    | |_____^ help: try this: `Err::<i32, i32>(42).is_ok()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/redundant_pattern_matching.rs:69:5
+  --> $DIR/redundant_pattern_matching.rs:71:5
    |
 LL | /     match Some(42) {
 LL | |         Some(_) => true,
@@ -112,7 +112,7 @@ LL | |     };
    | |_____^ help: try this: `Some(42).is_some()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching.rs:74:5
+  --> $DIR/redundant_pattern_matching.rs:76:5
    |
 LL | /     match None::<()> {
 LL | |         Some(_) => false,
@@ -121,7 +121,7 @@ LL | |     };
    | |_____^ help: try this: `None::<()>.is_none()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching.rs:79:13
+  --> $DIR/redundant_pattern_matching.rs:81:13
    |
 LL |       let _ = match None::<()> {
    |  _____________^
@@ -131,61 +131,61 @@ LL | |     };
    | |_____^ help: try this: `None::<()>.is_none()`
 
 error: redundant pattern matching, consider using `is_ok()`
-  --> $DIR/redundant_pattern_matching.rs:84:20
+  --> $DIR/redundant_pattern_matching.rs:86: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:87:20
+  --> $DIR/redundant_pattern_matching.rs:89: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:92:20
+  --> $DIR/redundant_pattern_matching.rs:95: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:94:19
+  --> $DIR/redundant_pattern_matching.rs:97: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:96:19
+  --> $DIR/redundant_pattern_matching.rs:99:19
    |
 LL |     } else if let Ok(_) = gen_res() {
    |            -------^^^^^------------ help: try this: `if gen_res().is_ok()`
 
 error: redundant pattern matching, consider using `is_err()`
-  --> $DIR/redundant_pattern_matching.rs:98:19
+  --> $DIR/redundant_pattern_matching.rs:101: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:131:19
+  --> $DIR/redundant_pattern_matching.rs:134: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:132:16
+  --> $DIR/redundant_pattern_matching.rs:135: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:138:12
+  --> $DIR/redundant_pattern_matching.rs:141: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:139:15
+  --> $DIR/redundant_pattern_matching.rs:142:15
    |
 LL |     while let Some(_) = m!() {}
    |     ----------^^^^^^^------- help: try this: `while m!().is_some()`
diff --git a/tests/ui/redundant_pattern_matching_const_result.fixed b/tests/ui/redundant_pattern_matching_const_result.fixed
new file mode 100644
index 00000000000..c8bc5458067
--- /dev/null
+++ b/tests/ui/redundant_pattern_matching_const_result.fixed
@@ -0,0 +1,46 @@
+// run-rustfix
+
+#![feature(const_if_match)]
+#![feature(const_loop)]
+#![feature(const_result)]
+#![warn(clippy::redundant_pattern_matching)]
+#![allow(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() {}
diff --git a/tests/ui/redundant_pattern_matching_const_result.rs b/tests/ui/redundant_pattern_matching_const_result.rs
new file mode 100644
index 00000000000..75f37ec15c6
--- /dev/null
+++ b/tests/ui/redundant_pattern_matching_const_result.rs
@@ -0,0 +1,52 @@
+// run-rustfix
+
+#![feature(const_if_match)]
+#![feature(const_loop)]
+#![feature(const_result)]
+#![warn(clippy::redundant_pattern_matching)]
+#![allow(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() {}
diff --git a/tests/ui/redundant_pattern_matching_const_result.stderr b/tests/ui/redundant_pattern_matching_const_result.stderr
new file mode 100644
index 00000000000..c32292f0eee
--- /dev/null
+++ b/tests/ui/redundant_pattern_matching_const_result.stderr
@@ -0,0 +1,46 @@
+error: redundant pattern matching, consider using `is_ok()`
+  --> $DIR/redundant_pattern_matching_const_result.rs:12: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:14: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:16: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:18: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:20: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:25: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
+
-- 
cgit 1.4.1-3-g733a5


From f3a40f5eb1cedebd374ebcd52341dfec60f3ea10 Mon Sep 17 00:00:00 2001
From: sozysozbot <sozysozbot@gmail.com>
Date: Thu, 18 Jun 2020 06:50:04 +0900
Subject: Fix typo

extending it's lifetime -> extending its lifetime
---
 clippy_lints/src/let_underscore.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/let_underscore.rs b/clippy_lints/src/let_underscore.rs
index 710dec8d33f..acd628bbaca 100644
--- a/clippy_lints/src/let_underscore.rs
+++ b/clippy_lints/src/let_underscore.rs
@@ -35,7 +35,7 @@ declare_clippy_lint! {
     /// **What it does:** Checks for `let _ = sync_lock`
     ///
     /// **Why is this bad?** This statement immediately drops the lock instead of
-    /// extending it's lifetime to the end of the scope, which is often not intended.
+    /// extending its lifetime to the end of the scope, which is often not intended.
     /// To extend lock lifetime to the end of the scope, use an underscore-prefixed
     /// name instead (i.e. _lock). If you want to explicitly drop the lock,
     /// `std::mem::drop` conveys your intention better and is less error-prone.
-- 
cgit 1.4.1-3-g733a5


From 51592f8587bd5dac9cb3f34fbd5896218a814677 Mon Sep 17 00:00:00 2001
From: flip1995 <hello@philkrones.com>
Date: Tue, 23 Jun 2020 02:18:38 +0200
Subject: Fix sync fallout

---
 clippy_lints/src/escape.rs              |  2 +-
 clippy_lints/src/len_zero.rs            |  3 +-
 clippy_lints/src/loops.rs               |  6 ++--
 clippy_lints/src/types.rs               | 58 +++++++--------------------------
 clippy_lints/src/unnecessary_sort_by.rs |  5 ++-
 clippy_lints/src/utils/author.rs        |  5 ++-
 clippy_lints/src/utils/usage.rs         |  2 +-
 7 files changed, 27 insertions(+), 54 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/escape.rs b/clippy_lints/src/escape.rs
index 59af475af17..77e90eeac49 100644
--- a/clippy_lints/src/escape.rs
+++ b/clippy_lints/src/escape.rs
@@ -6,7 +6,7 @@ use rustc_middle::ty::{self, Ty};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::Span;
 use rustc_target::abi::LayoutOf;
-use rustc_typeck::expr_use_visitor::{ConsumeMode, Delegate, ExprUseVisitor, PlaceWithHirId, PlaceBase};
+use rustc_typeck::expr_use_visitor::{ConsumeMode, Delegate, ExprUseVisitor, PlaceBase, PlaceWithHirId};
 
 use crate::utils::span_lint;
 
diff --git a/clippy_lints/src/len_zero.rs b/clippy_lints/src/len_zero.rs
index 13e85fda8ff..7838e8e8ab7 100644
--- a/clippy_lints/src/len_zero.rs
+++ b/clippy_lints/src/len_zero.rs
@@ -211,7 +211,8 @@ fn check_impl_items(cx: &LateContext<'_, '_>, item: &Item<'_>, impl_items: &[Imp
 }
 
 fn check_cmp(cx: &LateContext<'_, '_>, span: Span, method: &Expr<'_>, lit: &Expr<'_>, op: &str, compare_to: u32) {
-    if let (&ExprKind::MethodCall(ref method_path, _, ref args, _), &ExprKind::Lit(ref lit)) = (&method.kind, &lit.kind) {
+    if let (&ExprKind::MethodCall(ref method_path, _, ref args, _), &ExprKind::Lit(ref lit)) = (&method.kind, &lit.kind)
+    {
         // check if we are in an is_empty() method
         if let Some(name) = get_item_name(cx, method) {
             if name.as_str() == "is_empty" {
diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 83093ec51bd..ae1aa66be5c 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -28,7 +28,7 @@ use rustc_middle::ty::{self, Ty, TyS};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
 use rustc_span::symbol::Symbol;
-use rustc_typeck::expr_use_visitor::{ConsumeMode, Delegate, ExprUseVisitor, PlaceWithHirId, PlaceBase};
+use rustc_typeck::expr_use_visitor::{ConsumeMode, Delegate, ExprUseVisitor, PlaceBase, PlaceWithHirId};
 use std::iter::{once, Iterator};
 use std::mem;
 
@@ -1580,13 +1580,13 @@ fn check_for_mutability(cx: &LateContext<'_, '_>, bound: &Expr<'_>) -> Option<Hi
     None
 }
 
-fn check_for_mutation<'a, 'tcx> (
+fn check_for_mutation<'a, 'tcx>(
     cx: &LateContext<'a, 'tcx>,
     body: &Expr<'_>,
     bound_ids: &[Option<HirId>],
 ) -> (Option<Span>, Option<Span>) {
     let mut delegate = MutatePairDelegate {
-        cx: cx,
+        cx,
         hir_id_low: bound_ids[0],
         hir_id_high: bound_ids[1],
         span_low: None,
diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs
index d59a2f1bae0..98de08f79f3 100644
--- a/clippy_lints/src/types.rs
+++ b/clippy_lints/src/types.rs
@@ -1945,16 +1945,12 @@ fn detect_extreme_expr<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr<'_
 
     let which = match (&ty.kind, cv) {
         (&ty::Bool, Constant::Bool(false)) | (&ty::Uint(_), Constant::Int(0)) => Minimum,
-        (&ty::Int(ity), Constant::Int(i))
-            if i == unsext(cx.tcx, i128::MIN >> (128 - int_bits(cx.tcx, ity)), ity) =>
-        {
+        (&ty::Int(ity), Constant::Int(i)) if i == unsext(cx.tcx, i128::MIN >> (128 - int_bits(cx.tcx, ity)), ity) => {
             Minimum
         },
 
         (&ty::Bool, Constant::Bool(true)) => Maximum,
-        (&ty::Int(ity), Constant::Int(i))
-            if i == unsext(cx.tcx, i128::MAX >> (128 - int_bits(cx.tcx, ity)), ity) =>
-        {
+        (&ty::Int(ity), Constant::Int(i)) if i == unsext(cx.tcx, i128::MAX >> (128 - int_bits(cx.tcx, ity)), ity) => {
             Maximum
         },
         (&ty::Uint(uty), Constant::Int(i)) if clip(cx.tcx, u128::MAX, uty) == i => Maximum,
@@ -2083,50 +2079,20 @@ fn numeric_cast_precast_bounds<'a>(cx: &LateContext<'_, '_>, expr: &'a Expr<'_>)
         }
         match pre_cast_ty.kind {
             ty::Int(int_ty) => Some(match int_ty {
-                IntTy::I8 => (
-                    FullInt::S(i128::from(i8::MIN)),
-                    FullInt::S(i128::from(i8::MAX)),
-                ),
-                IntTy::I16 => (
-                    FullInt::S(i128::from(i16::MIN)),
-                    FullInt::S(i128::from(i16::MAX)),
-                ),
-                IntTy::I32 => (
-                    FullInt::S(i128::from(i32::MIN)),
-                    FullInt::S(i128::from(i32::MAX)),
-                ),
-                IntTy::I64 => (
-                    FullInt::S(i128::from(i64::MIN)),
-                    FullInt::S(i128::from(i64::MAX)),
-                ),
+                IntTy::I8 => (FullInt::S(i128::from(i8::MIN)), FullInt::S(i128::from(i8::MAX))),
+                IntTy::I16 => (FullInt::S(i128::from(i16::MIN)), FullInt::S(i128::from(i16::MAX))),
+                IntTy::I32 => (FullInt::S(i128::from(i32::MIN)), FullInt::S(i128::from(i32::MAX))),
+                IntTy::I64 => (FullInt::S(i128::from(i64::MIN)), FullInt::S(i128::from(i64::MAX))),
                 IntTy::I128 => (FullInt::S(i128::MIN), FullInt::S(i128::MAX)),
-                IntTy::Isize => (
-                    FullInt::S(isize::MIN as i128),
-                    FullInt::S(isize::MAX as i128),
-                ),
+                IntTy::Isize => (FullInt::S(isize::MIN as i128), FullInt::S(isize::MAX as i128)),
             }),
             ty::Uint(uint_ty) => Some(match uint_ty {
-                UintTy::U8 => (
-                    FullInt::U(u128::from(u8::MIN)),
-                    FullInt::U(u128::from(u8::MAX)),
-                ),
-                UintTy::U16 => (
-                    FullInt::U(u128::from(u16::MIN)),
-                    FullInt::U(u128::from(u16::MAX)),
-                ),
-                UintTy::U32 => (
-                    FullInt::U(u128::from(u32::MIN)),
-                    FullInt::U(u128::from(u32::MAX)),
-                ),
-                UintTy::U64 => (
-                    FullInt::U(u128::from(u64::MIN)),
-                    FullInt::U(u128::from(u64::MAX)),
-                ),
+                UintTy::U8 => (FullInt::U(u128::from(u8::MIN)), FullInt::U(u128::from(u8::MAX))),
+                UintTy::U16 => (FullInt::U(u128::from(u16::MIN)), FullInt::U(u128::from(u16::MAX))),
+                UintTy::U32 => (FullInt::U(u128::from(u32::MIN)), FullInt::U(u128::from(u32::MAX))),
+                UintTy::U64 => (FullInt::U(u128::from(u64::MIN)), FullInt::U(u128::from(u64::MAX))),
                 UintTy::U128 => (FullInt::U(u128::MIN), FullInt::U(u128::MAX)),
-                UintTy::Usize => (
-                    FullInt::U(usize::MIN as u128),
-                    FullInt::U(usize::MAX as u128),
-                ),
+                UintTy::Usize => (FullInt::U(usize::MIN as u128), FullInt::U(usize::MAX as u128)),
             }),
             _ => None,
         }
diff --git a/clippy_lints/src/unnecessary_sort_by.rs b/clippy_lints/src/unnecessary_sort_by.rs
index e94eebb88e4..6ac6a12529c 100644
--- a/clippy_lints/src/unnecessary_sort_by.rs
+++ b/clippy_lints/src/unnecessary_sort_by.rs
@@ -95,7 +95,10 @@ fn mirrored_exprs(
         // The two exprs are method calls.
         // Check to see that the function is the same and the arguments are mirrored
         // This is enough because the receiver of the method is listed in the arguments
-        (ExprKind::MethodCall(left_segment, _, left_args, _), ExprKind::MethodCall(right_segment, _, right_args, _)) => {
+        (
+            ExprKind::MethodCall(left_segment, _, left_args, _),
+            ExprKind::MethodCall(right_segment, _, right_args, _),
+        ) => {
             left_segment.ident == right_segment.ident
                 && left_args
                     .iter()
diff --git a/clippy_lints/src/utils/author.rs b/clippy_lints/src/utils/author.rs
index 8b58bbb5e65..910b665ccb7 100644
--- a/clippy_lints/src/utils/author.rs
+++ b/clippy_lints/src/utils/author.rs
@@ -251,7 +251,10 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor {
                 }
             },
             ExprKind::MethodCall(ref _method_name, ref _generics, ref _args, ref _fn_span) => {
-                println!("MethodCall(ref method_name, ref generics, ref args, ref fn_span) = {};", current);
+                println!(
+                    "MethodCall(ref method_name, ref generics, ref args, ref fn_span) = {};",
+                    current
+                );
                 println!("    // unimplemented: `ExprKind::MethodCall` is not further destructured at the moment");
             },
             ExprKind::Tup(ref elements) => {
diff --git a/clippy_lints/src/utils/usage.rs b/clippy_lints/src/utils/usage.rs
index 6a7a1f1ceaa..0492878fc27 100644
--- a/clippy_lints/src/utils/usage.rs
+++ b/clippy_lints/src/utils/usage.rs
@@ -8,7 +8,7 @@ use rustc_lint::LateContext;
 use rustc_middle::hir::map::Map;
 use rustc_middle::ty;
 use rustc_span::symbol::{Ident, Symbol};
-use rustc_typeck::expr_use_visitor::{ConsumeMode, Delegate, ExprUseVisitor, PlaceWithHirId, PlaceBase};
+use rustc_typeck::expr_use_visitor::{ConsumeMode, Delegate, ExprUseVisitor, PlaceBase, PlaceWithHirId};
 
 /// Returns a set of mutated local variable IDs, or `None` if mutations could not be determined.
 pub fn mutated_variables<'a, 'tcx>(expr: &'tcx Expr<'_>, cx: &'a LateContext<'a, 'tcx>) -> Option<FxHashSet<HirId>> {
-- 
cgit 1.4.1-3-g733a5


From 52c486475774b7416e691323322ef1ea2db790de Mon Sep 17 00:00:00 2001
From: Michael Wright <mikerite@lavabit.com>
Date: Thu, 11 Jun 2020 20:25:14 +0200
Subject: Improve end of expression check in for loop lints

The code should to check that the current expression _is_ the end
expression; not that it's equal to it. The equality check seems very
wasteful in terms of performance.
---
 clippy_lints/src/loops.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index ae1aa66be5c..3874b040b13 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -2042,7 +2042,7 @@ impl<'a, 'tcx> Visitor<'tcx> for InitializeVisitor<'a, 'tcx> {
         if self.state == VarState::DontWarn {
             return;
         }
-        if SpanlessEq::new(self.cx).eq_expr(&expr, self.end_expr) {
+        if expr.hir_id == self.end_expr.hir_id {
             self.past_loop = true;
             return;
         }
-- 
cgit 1.4.1-3-g733a5


From ed083cc95987ef37b7ed897f632b4a7a1baaff60 Mon Sep 17 00:00:00 2001
From: flip1995 <hello@philkrones.com>
Date: Sat, 13 Jun 2020 18:22:38 +0200
Subject: Use lints in Clippy that are enabled in rustc bootstrap

---
 clippy_lints/src/lib.rs | 17 ++++++++++-------
 src/driver.rs           |  6 +++++-
 src/main.rs             |  2 ++
 3 files changed, 17 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 021fbe932d8..25c1c2d73b6 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1,19 +1,22 @@
 // error-pattern:cargo-clippy
 
 #![feature(bindings_after_at)]
-#![feature(box_syntax)]
 #![feature(box_patterns)]
+#![feature(box_syntax)]
+#![feature(concat_idents)]
+#![feature(crate_visibility_modifier)]
+#![feature(drain_filter)]
 #![feature(or_patterns)]
 #![feature(rustc_private)]
 #![feature(stmt_expr_attributes)]
-#![allow(clippy::missing_docs_in_private_items, clippy::must_use_candidate)]
 #![recursion_limit = "512"]
-#![warn(rust_2018_idioms, trivial_casts, trivial_numeric_casts)]
-#![deny(rustc::internal)]
 #![cfg_attr(feature = "deny-warnings", deny(warnings))]
-#![feature(crate_visibility_modifier)]
-#![feature(concat_idents)]
-#![feature(drain_filter)]
+#![allow(clippy::missing_docs_in_private_items, clippy::must_use_candidate)]
+#![warn(trivial_casts, trivial_numeric_casts)]
+// warn on lints, that are included in `rust-lang/rust`s bootstrap
+#![warn(rust_2018_idioms, unused_lifetimes)]
+// warn on rustc internal lints
+#![deny(rustc::internal)]
 
 // FIXME: switch to something more ergonomic here, once available.
 // (Currently there is no way to opt into sysroot crates without `extern crate`.)
diff --git a/src/driver.rs b/src/driver.rs
index 4453ae5ce44..10f56fb2070 100644
--- a/src/driver.rs
+++ b/src/driver.rs
@@ -1,5 +1,9 @@
-#![cfg_attr(feature = "deny-warnings", deny(warnings))]
 #![feature(rustc_private)]
+#![cfg_attr(feature = "deny-warnings", deny(warnings))]
+// warn on lints, that are included in `rust-lang/rust`s bootstrap
+#![warn(rust_2018_idioms, unused_lifetimes)]
+// warn on rustc internal lints
+#![deny(rustc::internal)]
 
 // FIXME: switch to something more ergonomic here, once available.
 // (Currently there is no way to opt into sysroot crates without `extern crate`.)
diff --git a/src/main.rs b/src/main.rs
index bc43a34ed5d..6739a4cf224 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,4 +1,6 @@
 #![cfg_attr(feature = "deny-warnings", deny(warnings))]
+// warn on lints, that are included in `rust-lang/rust`s bootstrap
+#![warn(rust_2018_idioms, unused_lifetimes)]
 
 use rustc_tools_util::VersionInfo;
 use std::env;
-- 
cgit 1.4.1-3-g733a5


From b886c06c1a52a57890b318cc7304f7384e696ec8 Mon Sep 17 00:00:00 2001
From: flip1995 <hello@philkrones.com>
Date: Sat, 13 Jun 2020 18:22:49 +0200
Subject: Fix fallout

---
 clippy_lints/src/loops.rs                      | 6 +++---
 clippy_lints/src/suspicious_trait_impl.rs      | 2 +-
 clippy_lints/src/trivially_copy_pass_by_ref.rs | 2 +-
 clippy_lints/src/utils/sugg.rs                 | 4 ++--
 src/driver.rs                                  | 6 ++++--
 5 files changed, 11 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index ae1aa66be5c..9020b47a146 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -1497,7 +1497,7 @@ struct MutatePairDelegate<'a, 'tcx> {
     span_high: Option<Span>,
 }
 
-impl<'a, 'tcx> Delegate<'tcx> for MutatePairDelegate<'a, 'tcx> {
+impl<'tcx> Delegate<'tcx> for MutatePairDelegate<'_, 'tcx> {
     fn consume(&mut self, _: &PlaceWithHirId<'tcx>, _: ConsumeMode) {}
 
     fn borrow(&mut self, cmt: &PlaceWithHirId<'tcx>, bk: ty::BorrowKind) {
@@ -1525,7 +1525,7 @@ impl<'a, 'tcx> Delegate<'tcx> for MutatePairDelegate<'a, 'tcx> {
     }
 }
 
-impl<'a, 'tcx> MutatePairDelegate<'a, 'tcx> {
+impl MutatePairDelegate<'_, '_> {
     fn mutation_span(&self) -> (Option<Span>, Option<Span>) {
         (self.span_low, self.span_high)
     }
@@ -2292,7 +2292,7 @@ struct HasBreakOrReturnVisitor {
     has_break_or_return: bool,
 }
 
-impl<'a, 'tcx> Visitor<'tcx> for HasBreakOrReturnVisitor {
+impl<'tcx> Visitor<'tcx> for HasBreakOrReturnVisitor {
     type Map = Map<'tcx>;
 
     fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
diff --git a/clippy_lints/src/suspicious_trait_impl.rs b/clippy_lints/src/suspicious_trait_impl.rs
index a9e6fa329c0..cf71c3144a2 100644
--- a/clippy_lints/src/suspicious_trait_impl.rs
+++ b/clippy_lints/src/suspicious_trait_impl.rs
@@ -184,7 +184,7 @@ struct BinaryExprVisitor {
     in_binary_expr: bool,
 }
 
-impl<'a, 'tcx> Visitor<'tcx> for BinaryExprVisitor {
+impl<'tcx> Visitor<'tcx> for BinaryExprVisitor {
     type Map = Map<'tcx>;
 
     fn visit_expr(&mut self, expr: &'tcx hir::Expr<'_>) {
diff --git a/clippy_lints/src/trivially_copy_pass_by_ref.rs b/clippy_lints/src/trivially_copy_pass_by_ref.rs
index 8e0cb94317a..146ac4b09d5 100644
--- a/clippy_lints/src/trivially_copy_pass_by_ref.rs
+++ b/clippy_lints/src/trivially_copy_pass_by_ref.rs
@@ -58,7 +58,7 @@ pub struct TriviallyCopyPassByRef {
     limit: u64,
 }
 
-impl<'a, 'tcx> TriviallyCopyPassByRef {
+impl<'tcx> TriviallyCopyPassByRef {
     pub fn new(limit: Option<u64>, target: &SessionConfig) -> Self {
         let limit = limit.unwrap_or_else(|| {
             let bit_width = u64::from(target.ptr_width);
diff --git a/clippy_lints/src/utils/sugg.rs b/clippy_lints/src/utils/sugg.rs
index 73758b7eeb7..e919b1522d8 100644
--- a/clippy_lints/src/utils/sugg.rs
+++ b/clippy_lints/src/utils/sugg.rs
@@ -509,7 +509,7 @@ fn indentation<T: LintContext>(cx: &T, span: Span) -> Option<String> {
 }
 
 /// Convenience extension trait for `DiagnosticBuilder`.
-pub trait DiagnosticBuilderExt<'a, T: LintContext> {
+pub trait DiagnosticBuilderExt<T: LintContext> {
     /// Suggests to add an attribute to an item.
     ///
     /// Correctly handles indentation of the attribute and item.
@@ -556,7 +556,7 @@ pub trait DiagnosticBuilderExt<'a, T: LintContext> {
     fn suggest_remove_item(&mut self, cx: &T, item: Span, msg: &str, applicability: Applicability);
 }
 
-impl<'a, 'b, 'c, T: LintContext> DiagnosticBuilderExt<'c, T> for rustc_errors::DiagnosticBuilder<'b> {
+impl<T: LintContext> DiagnosticBuilderExt<T> for rustc_errors::DiagnosticBuilder<'_> {
     fn suggest_item_with_attr<D: Display + ?Sized>(
         &mut self,
         cx: &T,
diff --git a/src/driver.rs b/src/driver.rs
index 10f56fb2070..3d12436e9af 100644
--- a/src/driver.rs
+++ b/src/driver.rs
@@ -8,6 +8,8 @@
 // FIXME: switch to something more ergonomic here, once available.
 // (Currently there is no way to opt into sysroot crates without `extern crate`.)
 #[allow(unused_extern_crates)]
+extern crate rustc_data_structures;
+#[allow(unused_extern_crates)]
 extern crate rustc_driver;
 #[allow(unused_extern_crates)]
 extern crate rustc_errors;
@@ -97,7 +99,7 @@ impl rustc_driver::Callbacks for ClippyCallbacks {
 #[allow(clippy::find_map, clippy::filter_map)]
 fn describe_lints() {
     use lintlist::{Level, Lint, ALL_LINTS, LINT_LEVELS};
-    use std::collections::HashSet;
+    use rustc_data_structures::fx::FxHashSet;
 
     println!(
         "
@@ -141,7 +143,7 @@ Available lint options:
 
     let scoped = |x: &str| format!("clippy::{}", x);
 
-    let lint_groups: HashSet<_> = lints.iter().map(|lint| lint.group).collect();
+    let lint_groups: FxHashSet<_> = lints.iter().map(|lint| lint.group).collect();
 
     println!("Lint checks provided by clippy:\n");
     println!("    {}  {:7.7}  meaning", padded("name"), "default");
-- 
cgit 1.4.1-3-g733a5


From 7374185b36d8dee6c91970a4c016d714a6e1bd39 Mon Sep 17 00:00:00 2001
From: Lzu Tao <taolzu@gmail.com>
Date: Tue, 23 Jun 2020 20:59:35 +0700
Subject: Remove unused allowed unused attributes

---
 clippy_lints/src/lib.rs | 32 +++-----------------------------
 src/driver.rs           |  5 -----
 2 files changed, 3 insertions(+), 34 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 19ad7d92c2b..501220f28e5 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -20,47 +20,25 @@
 
 // FIXME: switch to something more ergonomic here, once available.
 // (Currently there is no way to opt into sysroot crates without `extern crate`.)
-#[allow(unused_extern_crates)]
 extern crate rustc_ast;
-#[allow(unused_extern_crates)]
 extern crate rustc_ast_pretty;
-#[allow(unused_extern_crates)]
 extern crate rustc_attr;
-#[allow(unused_extern_crates)]
 extern crate rustc_data_structures;
-#[allow(unused_extern_crates)]
-extern crate rustc_driver;
-#[allow(unused_extern_crates)]
 extern crate rustc_errors;
-#[allow(unused_extern_crates)]
 extern crate rustc_hir;
-#[allow(unused_extern_crates)]
 extern crate rustc_hir_pretty;
-#[allow(unused_extern_crates)]
 extern crate rustc_index;
-#[allow(unused_extern_crates)]
 extern crate rustc_infer;
-#[allow(unused_extern_crates)]
 extern crate rustc_lexer;
-#[allow(unused_extern_crates)]
 extern crate rustc_lint;
-#[allow(unused_extern_crates)]
 extern crate rustc_middle;
-#[allow(unused_extern_crates)]
 extern crate rustc_mir;
-#[allow(unused_extern_crates)]
 extern crate rustc_parse;
-#[allow(unused_extern_crates)]
 extern crate rustc_parse_format;
-#[allow(unused_extern_crates)]
 extern crate rustc_session;
-#[allow(unused_extern_crates)]
 extern crate rustc_span;
-#[allow(unused_extern_crates)]
 extern crate rustc_target;
-#[allow(unused_extern_crates)]
 extern crate rustc_trait_selection;
-#[allow(unused_extern_crates)]
 extern crate rustc_typeck;
 
 use rustc_data_structures::fx::FxHashSet;
@@ -85,14 +63,10 @@ use rustc_session::Session;
 /// # Example
 ///
 /// ```
-/// # #![feature(rustc_private)]
-/// # #[allow(unused_extern_crates)]
-/// # extern crate rustc_middle;
-/// # #[allow(unused_extern_crates)]
-/// # extern crate rustc_session;
-/// # #[macro_use]
-/// # use clippy_lints::declare_clippy_lint;
+/// #![feature(rustc_private)]
+/// extern crate rustc_session;
 /// use rustc_session::declare_tool_lint;
+/// use clippy_lints::declare_clippy_lint;
 ///
 /// declare_clippy_lint! {
 ///     /// **What it does:** Checks for ... (describe what the lint matches).
diff --git a/src/driver.rs b/src/driver.rs
index 3fca66a5792..decd3a79cce 100644
--- a/src/driver.rs
+++ b/src/driver.rs
@@ -7,15 +7,10 @@
 
 // FIXME: switch to something more ergonomic here, once available.
 // (Currently there is no way to opt into sysroot crates without `extern crate`.)
-#[allow(unused_extern_crates)]
 extern crate rustc_data_structures;
-#[allow(unused_extern_crates)]
 extern crate rustc_driver;
-#[allow(unused_extern_crates)]
 extern crate rustc_errors;
-#[allow(unused_extern_crates)]
 extern crate rustc_interface;
-#[allow(unused_extern_crates)]
 extern crate rustc_middle;
 
 use rustc_interface::interface;
-- 
cgit 1.4.1-3-g733a5


From fb4f9a0ad7a4656beb01c85b02b3e6ef15d914ec Mon Sep 17 00:00:00 2001
From: Teddy_Wang <wangtheo662@gmail.com>
Date: Tue, 23 Jun 2020 11:40:38 -0400
Subject: Fix pattern match of ExprKind::MethodCall

---
 clippy_lints/src/map_identity.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/map_identity.rs b/clippy_lints/src/map_identity.rs
index 9bc8f1bec1b..6607a26b130 100644
--- a/clippy_lints/src/map_identity.rs
+++ b/clippy_lints/src/map_identity.rs
@@ -61,7 +61,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MapIdentity {
 /// map(). Otherwise, returns None.
 fn get_map_argument<'a>(cx: &LateContext<'_, '_>, expr: &'a Expr<'a>) -> Option<&'a [Expr<'a>]> {
     if_chain! {
-        if let ExprKind::MethodCall(ref method, _, ref args) = expr.kind;
+        if let ExprKind::MethodCall(ref method, _, ref args, _) = expr.kind;
         if args.len() == 2 && method.ident.as_str() == "map";
         let caller_ty = cx.tables.expr_ty(&args[0]);
         if match_trait_method(cx, expr, &paths::ITERATOR)
-- 
cgit 1.4.1-3-g733a5


From 5987c7d4041ce5d72c8412d2ad73fe3b63308b51 Mon Sep 17 00:00:00 2001
From: Eduardo Broto <ebroto@tutanota.com>
Date: Tue, 9 Jun 2020 22:40:43 +0200
Subject: cmp_owned: avoid FP when PartialEq is not implemented symmetrically

---
 clippy_lints/src/misc.rs         | 35 +++++++++++++++------------
 tests/ui/cmp_owned/issue_4874.rs | 51 ++++++++++++++++++++++++++++++++++++++++
 2 files changed, 71 insertions(+), 15 deletions(-)
 create mode 100644 tests/ui/cmp_owned/issue_4874.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/misc.rs b/clippy_lints/src/misc.rs
index a0947608e60..1b65a01690d 100644
--- a/clippy_lints/src/misc.rs
+++ b/clippy_lints/src/misc.rs
@@ -3,11 +3,11 @@ use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::{
-    def, BinOpKind, BindingAnnotation, Body, Expr, ExprKind, FnDecl, HirId, Mutability, PatKind, Stmt, StmtKind, Ty,
-    TyKind, UnOp,
+    self as hir, def, BinOpKind, BindingAnnotation, Body, Expr, ExprKind, FnDecl, HirId, Mutability, PatKind, Stmt,
+    StmtKind, TyKind, UnOp,
 };
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty;
+use rustc_middle::ty::{self, Ty};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::hygiene::DesugaringKind;
 use rustc_span::source_map::{ExpnKind, Span};
@@ -571,6 +571,15 @@ fn is_array(cx: &LateContext<'_, '_>, expr: &Expr<'_>) -> bool {
 }
 
 fn check_to_owned(cx: &LateContext<'_, '_>, expr: &Expr<'_>, other: &Expr<'_>) {
+    fn symmetric_partial_eq<'tcx>(cx: &LateContext<'_, 'tcx>, lhs: Ty<'tcx>, rhs: Ty<'tcx>) -> bool {
+        if let Some(trait_def_id) = cx.tcx.lang_items().eq_trait() {
+            return implements_trait(cx, lhs, trait_def_id, &[rhs.into()])
+                && implements_trait(cx, rhs, trait_def_id, &[lhs.into()]);
+        }
+
+        false
+    }
+
     let (arg_ty, snip) = match expr.kind {
         ExprKind::MethodCall(.., ref args, _) if args.len() == 1 => {
             if match_trait_method(cx, expr, &paths::TO_STRING) || match_trait_method(cx, expr, &paths::TO_OWNED) {
@@ -594,18 +603,14 @@ fn check_to_owned(cx: &LateContext<'_, '_>, expr: &Expr<'_>, other: &Expr<'_>) {
     };
 
     let other_ty = cx.tables.expr_ty_adjusted(other);
-    let partial_eq_trait_id = match cx.tcx.lang_items().eq_trait() {
-        Some(id) => id,
-        None => return,
-    };
 
-    let deref_arg_impl_partial_eq_other = arg_ty.builtin_deref(true).map_or(false, |tam| {
-        implements_trait(cx, tam.ty, partial_eq_trait_id, &[other_ty.into()])
-    });
-    let arg_impl_partial_eq_deref_other = other_ty.builtin_deref(true).map_or(false, |tam| {
-        implements_trait(cx, arg_ty, partial_eq_trait_id, &[tam.ty.into()])
-    });
-    let arg_impl_partial_eq_other = implements_trait(cx, arg_ty, partial_eq_trait_id, &[other_ty.into()]);
+    let deref_arg_impl_partial_eq_other = arg_ty
+        .builtin_deref(true)
+        .map_or(false, |tam| symmetric_partial_eq(cx, tam.ty, other_ty));
+    let arg_impl_partial_eq_deref_other = other_ty
+        .builtin_deref(true)
+        .map_or(false, |tam| symmetric_partial_eq(cx, arg_ty, tam.ty));
+    let arg_impl_partial_eq_other = symmetric_partial_eq(cx, arg_ty, other_ty);
 
     if !deref_arg_impl_partial_eq_other && !arg_impl_partial_eq_deref_other && !arg_impl_partial_eq_other {
         return;
@@ -694,7 +699,7 @@ fn non_macro_local(cx: &LateContext<'_, '_>, res: def::Res) -> bool {
     }
 }
 
-fn check_cast(cx: &LateContext<'_, '_>, span: Span, e: &Expr<'_>, ty: &Ty<'_>) {
+fn check_cast(cx: &LateContext<'_, '_>, span: Span, e: &Expr<'_>, ty: &hir::Ty<'_>) {
     if_chain! {
         if let TyKind::Ptr(ref mut_ty) = ty.kind;
         if let ExprKind::Lit(ref lit) = e.kind;
diff --git a/tests/ui/cmp_owned/issue_4874.rs b/tests/ui/cmp_owned/issue_4874.rs
new file mode 100644
index 00000000000..b29c555eb1e
--- /dev/null
+++ b/tests/ui/cmp_owned/issue_4874.rs
@@ -0,0 +1,51 @@
+#![allow(clippy::redundant_clone)] // See #5700
+
+#[derive(PartialEq)]
+struct Foo;
+
+struct Bar;
+
+impl std::fmt::Display for Bar {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "bar")
+    }
+}
+
+// NOTE: PartialEq<Bar> for T can't be implemented due to the orphan rules
+impl<T> PartialEq<T> for Bar
+where
+    T: AsRef<str> + ?Sized,
+{
+    fn eq(&self, _: &T) -> bool {
+        true
+    }
+}
+
+// NOTE: PartialEq<Bar> for Foo is not implemented
+impl PartialEq<Foo> for Bar {
+    fn eq(&self, _: &Foo) -> bool {
+        true
+    }
+}
+
+impl ToOwned for Bar {
+    type Owned = Foo;
+    fn to_owned(&self) -> Foo {
+        Foo
+    }
+}
+
+impl std::borrow::Borrow<Bar> for Foo {
+    fn borrow(&self) -> &Bar {
+        static BAR: Bar = Bar;
+        &BAR
+    }
+}
+
+fn main() {
+    let b = Bar {};
+    if "Hi" == b.to_string() {}
+
+    let f = Foo {};
+    if f == b.to_owned() {}
+}
-- 
cgit 1.4.1-3-g733a5


From b498e1d71537a79e7aff5378da625aca8b4eef96 Mon Sep 17 00:00:00 2001
From: Eduardo Broto <ebroto@tutanota.com>
Date: Sat, 13 Jun 2020 00:03:19 +0200
Subject: cmp_owned: reverse operands if necessary

---
 clippy_lints/src/misc.rs                        | 79 +++++++++++++--------
 tests/ui/cmp_owned/asymmetric_partial_eq.fixed  | 93 +++++++++++++++++++++++++
 tests/ui/cmp_owned/asymmetric_partial_eq.rs     | 93 +++++++++++++++++++++++++
 tests/ui/cmp_owned/asymmetric_partial_eq.stderr | 46 ++++++++++++
 tests/ui/cmp_owned/issue_4874.rs                | 51 --------------
 5 files changed, 282 insertions(+), 80 deletions(-)
 create mode 100644 tests/ui/cmp_owned/asymmetric_partial_eq.fixed
 create mode 100644 tests/ui/cmp_owned/asymmetric_partial_eq.rs
 create mode 100644 tests/ui/cmp_owned/asymmetric_partial_eq.stderr
 delete mode 100644 tests/ui/cmp_owned/issue_4874.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/misc.rs b/clippy_lints/src/misc.rs
index 1b65a01690d..76ffe6f6a1c 100644
--- a/clippy_lints/src/misc.rs
+++ b/clippy_lints/src/misc.rs
@@ -371,8 +371,8 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MiscLints {
                 if op.is_comparison() {
                     check_nan(cx, left, expr);
                     check_nan(cx, right, expr);
-                    check_to_owned(cx, left, right);
-                    check_to_owned(cx, right, left);
+                    check_to_owned(cx, left, right, true);
+                    check_to_owned(cx, right, left, false);
                 }
                 if (op == BinOpKind::Eq || op == BinOpKind::Ne) && (is_float(cx, left) || is_float(cx, right)) {
                     if is_allowed(cx, left) || is_allowed(cx, right) {
@@ -570,20 +570,30 @@ fn is_array(cx: &LateContext<'_, '_>, expr: &Expr<'_>) -> bool {
     matches!(&walk_ptrs_ty(cx.tables.expr_ty(expr)).kind, ty::Array(_, _))
 }
 
-fn check_to_owned(cx: &LateContext<'_, '_>, expr: &Expr<'_>, other: &Expr<'_>) {
-    fn symmetric_partial_eq<'tcx>(cx: &LateContext<'_, 'tcx>, lhs: Ty<'tcx>, rhs: Ty<'tcx>) -> bool {
-        if let Some(trait_def_id) = cx.tcx.lang_items().eq_trait() {
-            return implements_trait(cx, lhs, trait_def_id, &[rhs.into()])
-                && implements_trait(cx, rhs, trait_def_id, &[lhs.into()]);
+fn check_to_owned(cx: &LateContext<'_, '_>, expr: &Expr<'_>, other: &Expr<'_>, left: bool) {
+    #[derive(Default)]
+    struct EqImpl {
+        ty_eq_other: bool,
+        other_eq_ty: bool,
+    }
+
+    impl EqImpl {
+        fn is_implemented(&self) -> bool {
+            self.ty_eq_other || self.other_eq_ty
         }
+    }
 
-        false
+    fn symmetric_partial_eq<'tcx>(cx: &LateContext<'_, 'tcx>, ty: Ty<'tcx>, other: Ty<'tcx>) -> Option<EqImpl> {
+        cx.tcx.lang_items().eq_trait().map(|def_id| EqImpl {
+            ty_eq_other: implements_trait(cx, ty, def_id, &[other.into()]),
+            other_eq_ty: implements_trait(cx, other, def_id, &[ty.into()]),
+        })
     }
 
     let (arg_ty, snip) = match expr.kind {
         ExprKind::MethodCall(.., ref args, _) if args.len() == 1 => {
             if match_trait_method(cx, expr, &paths::TO_STRING) || match_trait_method(cx, expr, &paths::TO_OWNED) {
-                (cx.tables.expr_ty_adjusted(&args[0]), snippet(cx, args[0].span, ".."))
+                (cx.tables.expr_ty(&args[0]), snippet(cx, args[0].span, ".."))
             } else {
                 return;
             }
@@ -591,7 +601,7 @@ fn check_to_owned(cx: &LateContext<'_, '_>, expr: &Expr<'_>, other: &Expr<'_>) {
         ExprKind::Call(ref path, ref v) if v.len() == 1 => {
             if let ExprKind::Path(ref path) = path.kind {
                 if match_qpath(path, &["String", "from_str"]) || match_qpath(path, &["String", "from"]) {
-                    (cx.tables.expr_ty_adjusted(&v[0]), snippet(cx, v[0].span, ".."))
+                    (cx.tables.expr_ty(&v[0]), snippet(cx, v[0].span, ".."))
                 } else {
                     return;
                 }
@@ -602,24 +612,19 @@ fn check_to_owned(cx: &LateContext<'_, '_>, expr: &Expr<'_>, other: &Expr<'_>) {
         _ => return,
     };
 
-    let other_ty = cx.tables.expr_ty_adjusted(other);
+    let other_ty = cx.tables.expr_ty(other);
 
-    let deref_arg_impl_partial_eq_other = arg_ty
-        .builtin_deref(true)
-        .map_or(false, |tam| symmetric_partial_eq(cx, tam.ty, other_ty));
-    let arg_impl_partial_eq_deref_other = other_ty
+    let without_deref = symmetric_partial_eq(cx, arg_ty, other_ty).unwrap_or_default();
+    let with_deref = arg_ty
         .builtin_deref(true)
-        .map_or(false, |tam| symmetric_partial_eq(cx, arg_ty, tam.ty));
-    let arg_impl_partial_eq_other = symmetric_partial_eq(cx, arg_ty, other_ty);
+        .and_then(|tam| symmetric_partial_eq(cx, tam.ty, other_ty))
+        .unwrap_or_default();
 
-    if !deref_arg_impl_partial_eq_other && !arg_impl_partial_eq_deref_other && !arg_impl_partial_eq_other {
+    if !with_deref.is_implemented() && !without_deref.is_implemented() {
         return;
     }
 
-    let other_gets_derefed = match other.kind {
-        ExprKind::Unary(UnOp::UnDeref, _) => true,
-        _ => false,
-    };
+    let other_gets_derefed = matches!(other.kind, ExprKind::Unary(UnOp::UnDeref, _));
 
     let lint_span = if other_gets_derefed {
         expr.span.to(other.span)
@@ -639,18 +644,34 @@ fn check_to_owned(cx: &LateContext<'_, '_>, expr: &Expr<'_>, other: &Expr<'_>) {
                 return;
             }
 
-            let try_hint = if deref_arg_impl_partial_eq_other {
-                // suggest deref on the left
-                format!("*{}", snip)
+            let expr_snip;
+            let eq_impl;
+            if with_deref.is_implemented() {
+                expr_snip = format!("*{}", snip);
+                eq_impl = with_deref;
             } else {
-                // suggest dropping the to_owned on the left
-                snip.to_string()
+                expr_snip = snip.to_string();
+                eq_impl = without_deref;
             };
 
+            let span;
+            let hint;
+            if (eq_impl.ty_eq_other && left) || (eq_impl.other_eq_ty && !left) {
+                span = expr.span;
+                hint = expr_snip;
+            } else {
+                span = expr.span.to(other.span);
+                if eq_impl.ty_eq_other {
+                    hint = format!("{} == {}", expr_snip, snippet(cx, other.span, ".."));
+                } else {
+                    hint = format!("{} == {}", snippet(cx, other.span, ".."), expr_snip);
+                }
+            }
+
             diag.span_suggestion(
-                lint_span,
+                span,
                 "try",
-                try_hint,
+                hint,
                 Applicability::MachineApplicable, // snippet
             );
         },
diff --git a/tests/ui/cmp_owned/asymmetric_partial_eq.fixed b/tests/ui/cmp_owned/asymmetric_partial_eq.fixed
new file mode 100644
index 00000000000..3305ac9bf8b
--- /dev/null
+++ b/tests/ui/cmp_owned/asymmetric_partial_eq.fixed
@@ -0,0 +1,93 @@
+// run-rustfix
+#![allow(unused, clippy::redundant_clone)] // See #5700
+
+// Define the types in each module to avoid trait impls leaking between modules.
+macro_rules! impl_types {
+    () => {
+        #[derive(PartialEq)]
+        pub struct Owned;
+
+        pub struct Borrowed;
+
+        impl ToOwned for Borrowed {
+            type Owned = Owned;
+            fn to_owned(&self) -> Owned {
+                Owned {}
+            }
+        }
+
+        impl std::borrow::Borrow<Borrowed> for Owned {
+            fn borrow(&self) -> &Borrowed {
+                static VALUE: Borrowed = Borrowed {};
+                &VALUE
+            }
+        }
+    };
+}
+
+// Only Borrowed == Owned is implemented
+mod borrowed_eq_owned {
+    impl_types!();
+
+    impl PartialEq<Owned> for Borrowed {
+        fn eq(&self, _: &Owned) -> bool {
+            true
+        }
+    }
+
+    pub fn compare() {
+        let owned = Owned {};
+        let borrowed = Borrowed {};
+
+        if borrowed == owned {}
+        if borrowed == owned {}
+    }
+}
+
+// Only Owned == Borrowed is implemented
+mod owned_eq_borrowed {
+    impl_types!();
+
+    impl PartialEq<Borrowed> for Owned {
+        fn eq(&self, _: &Borrowed) -> bool {
+            true
+        }
+    }
+
+    fn compare() {
+        let owned = Owned {};
+        let borrowed = Borrowed {};
+
+        if owned == borrowed {}
+        if owned == borrowed {}
+    }
+}
+
+mod issue_4874 {
+    impl_types!();
+
+    // NOTE: PartialEq<Borrowed> for T can't be implemented due to the orphan rules
+    impl<T> PartialEq<T> for Borrowed
+    where
+        T: AsRef<str> + ?Sized,
+    {
+        fn eq(&self, _: &T) -> bool {
+            true
+        }
+    }
+
+    impl std::fmt::Display for Borrowed {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            write!(f, "borrowed")
+        }
+    }
+
+    fn compare() {
+        let borrowed = Borrowed {};
+
+        if borrowed == "Hi" {}
+        if borrowed == "Hi" {}
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/cmp_owned/asymmetric_partial_eq.rs b/tests/ui/cmp_owned/asymmetric_partial_eq.rs
new file mode 100644
index 00000000000..88bc2f51dd6
--- /dev/null
+++ b/tests/ui/cmp_owned/asymmetric_partial_eq.rs
@@ -0,0 +1,93 @@
+// run-rustfix
+#![allow(unused, clippy::redundant_clone)] // See #5700
+
+// Define the types in each module to avoid trait impls leaking between modules.
+macro_rules! impl_types {
+    () => {
+        #[derive(PartialEq)]
+        pub struct Owned;
+
+        pub struct Borrowed;
+
+        impl ToOwned for Borrowed {
+            type Owned = Owned;
+            fn to_owned(&self) -> Owned {
+                Owned {}
+            }
+        }
+
+        impl std::borrow::Borrow<Borrowed> for Owned {
+            fn borrow(&self) -> &Borrowed {
+                static VALUE: Borrowed = Borrowed {};
+                &VALUE
+            }
+        }
+    };
+}
+
+// Only Borrowed == Owned is implemented
+mod borrowed_eq_owned {
+    impl_types!();
+
+    impl PartialEq<Owned> for Borrowed {
+        fn eq(&self, _: &Owned) -> bool {
+            true
+        }
+    }
+
+    pub fn compare() {
+        let owned = Owned {};
+        let borrowed = Borrowed {};
+
+        if borrowed.to_owned() == owned {}
+        if owned == borrowed.to_owned() {}
+    }
+}
+
+// Only Owned == Borrowed is implemented
+mod owned_eq_borrowed {
+    impl_types!();
+
+    impl PartialEq<Borrowed> for Owned {
+        fn eq(&self, _: &Borrowed) -> bool {
+            true
+        }
+    }
+
+    fn compare() {
+        let owned = Owned {};
+        let borrowed = Borrowed {};
+
+        if owned == borrowed.to_owned() {}
+        if borrowed.to_owned() == owned {}
+    }
+}
+
+mod issue_4874 {
+    impl_types!();
+
+    // NOTE: PartialEq<Borrowed> for T can't be implemented due to the orphan rules
+    impl<T> PartialEq<T> for Borrowed
+    where
+        T: AsRef<str> + ?Sized,
+    {
+        fn eq(&self, _: &T) -> bool {
+            true
+        }
+    }
+
+    impl std::fmt::Display for Borrowed {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            write!(f, "borrowed")
+        }
+    }
+
+    fn compare() {
+        let borrowed = Borrowed {};
+
+        if "Hi" == borrowed.to_string() {}
+        if borrowed.to_string() == "Hi" {}
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/cmp_owned/asymmetric_partial_eq.stderr b/tests/ui/cmp_owned/asymmetric_partial_eq.stderr
new file mode 100644
index 00000000000..43bf8851fc6
--- /dev/null
+++ b/tests/ui/cmp_owned/asymmetric_partial_eq.stderr
@@ -0,0 +1,46 @@
+error: this creates an owned instance just for comparison
+  --> $DIR/asymmetric_partial_eq.rs:42:12
+   |
+LL |         if borrowed.to_owned() == owned {}
+   |            ^^^^^^^^^^^^^^^^^^^ help: try: `borrowed`
+   |
+   = note: `-D clippy::cmp-owned` implied by `-D warnings`
+
+error: this creates an owned instance just for comparison
+  --> $DIR/asymmetric_partial_eq.rs:43:21
+   |
+LL |         if owned == borrowed.to_owned() {}
+   |            ---------^^^^^^^^^^^^^^^^^^^
+   |            |
+   |            help: try: `borrowed == owned`
+
+error: this creates an owned instance just for comparison
+  --> $DIR/asymmetric_partial_eq.rs:61:21
+   |
+LL |         if owned == borrowed.to_owned() {}
+   |                     ^^^^^^^^^^^^^^^^^^^ help: try: `borrowed`
+
+error: this creates an owned instance just for comparison
+  --> $DIR/asymmetric_partial_eq.rs:62:12
+   |
+LL |         if borrowed.to_owned() == owned {}
+   |            ^^^^^^^^^^^^^^^^^^^---------
+   |            |
+   |            help: try: `owned == borrowed`
+
+error: this creates an owned instance just for comparison
+  --> $DIR/asymmetric_partial_eq.rs:88:20
+   |
+LL |         if "Hi" == borrowed.to_string() {}
+   |            --------^^^^^^^^^^^^^^^^^^^^
+   |            |
+   |            help: try: `borrowed == "Hi"`
+
+error: this creates an owned instance just for comparison
+  --> $DIR/asymmetric_partial_eq.rs:89:12
+   |
+LL |         if borrowed.to_string() == "Hi" {}
+   |            ^^^^^^^^^^^^^^^^^^^^ help: try: `borrowed`
+
+error: aborting due to 6 previous errors
+
diff --git a/tests/ui/cmp_owned/issue_4874.rs b/tests/ui/cmp_owned/issue_4874.rs
deleted file mode 100644
index b29c555eb1e..00000000000
--- a/tests/ui/cmp_owned/issue_4874.rs
+++ /dev/null
@@ -1,51 +0,0 @@
-#![allow(clippy::redundant_clone)] // See #5700
-
-#[derive(PartialEq)]
-struct Foo;
-
-struct Bar;
-
-impl std::fmt::Display for Bar {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "bar")
-    }
-}
-
-// NOTE: PartialEq<Bar> for T can't be implemented due to the orphan rules
-impl<T> PartialEq<T> for Bar
-where
-    T: AsRef<str> + ?Sized,
-{
-    fn eq(&self, _: &T) -> bool {
-        true
-    }
-}
-
-// NOTE: PartialEq<Bar> for Foo is not implemented
-impl PartialEq<Foo> for Bar {
-    fn eq(&self, _: &Foo) -> bool {
-        true
-    }
-}
-
-impl ToOwned for Bar {
-    type Owned = Foo;
-    fn to_owned(&self) -> Foo {
-        Foo
-    }
-}
-
-impl std::borrow::Borrow<Bar> for Foo {
-    fn borrow(&self) -> &Bar {
-        static BAR: Bar = Bar;
-        &BAR
-    }
-}
-
-fn main() {
-    let b = Bar {};
-    if "Hi" == b.to_string() {}
-
-    let f = Foo {};
-    if f == b.to_owned() {}
-}
-- 
cgit 1.4.1-3-g733a5


From 6bf5434e19ce6d2a501589d1fcbc0d1748c531a6 Mon Sep 17 00:00:00 2001
From: Tim Nielens <tim.nielens@gmail.com>
Date: Wed, 24 Jun 2020 01:01:23 +0200
Subject: copy_on_clone - add machine applicability

---
 clippy_lints/src/methods/mod.rs   |  2 +-
 tests/ui/clone_on_copy.fixed      | 40 +++++++++++++++++++++++++++
 tests/ui/clone_on_copy.rs         | 40 +++++++++++++++++++++++++++
 tests/ui/clone_on_copy.stderr     | 34 +++++++++++++++++++++++
 tests/ui/unnecessary_clone.rs     | 25 -----------------
 tests/ui/unnecessary_clone.stderr | 58 ++++++++++-----------------------------
 6 files changed, 129 insertions(+), 70 deletions(-)
 create mode 100644 tests/ui/clone_on_copy.fixed
 create mode 100644 tests/ui/clone_on_copy.rs
 create mode 100644 tests/ui/clone_on_copy.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 214cf0c130f..74fefa65612 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -2041,7 +2041,7 @@ fn lint_clone_on_copy(cx: &LateContext<'_, '_>, expr: &hir::Expr<'_>, arg: &hir:
         }
         span_lint_and_then(cx, CLONE_ON_COPY, expr.span, "using `clone` on a `Copy` type", |diag| {
             if let Some((text, snip)) = snip {
-                diag.span_suggestion(expr.span, text, snip, Applicability::Unspecified);
+                diag.span_suggestion(expr.span, text, snip, Applicability::MachineApplicable);
             }
         });
     }
diff --git a/tests/ui/clone_on_copy.fixed b/tests/ui/clone_on_copy.fixed
new file mode 100644
index 00000000000..1f0ca101757
--- /dev/null
+++ b/tests/ui/clone_on_copy.fixed
@@ -0,0 +1,40 @@
+// run-rustfix
+
+#![allow(
+    unused,
+    clippy::redundant_clone,
+    clippy::deref_addrof,
+    clippy::no_effect,
+    clippy::unnecessary_operation
+)]
+
+use std::cell::RefCell;
+use std::rc::{self, Rc};
+use std::sync::{self, Arc};
+
+fn main() {}
+
+fn is_ascii(ch: char) -> bool {
+    ch.is_ascii()
+}
+
+fn clone_on_copy() {
+    42;
+
+    vec![1].clone(); // ok, not a Copy type
+    Some(vec![1]).clone(); // ok, not a Copy type
+    *(&42);
+
+    let rc = RefCell::new(0);
+    *rc.borrow();
+
+    // Issue #4348
+    let mut x = 43;
+    let _ = &x.clone(); // ok, getting a ref
+    'a'.clone().make_ascii_uppercase(); // ok, clone and then mutate
+    is_ascii('z');
+
+    // Issue #5436
+    let mut vec = Vec::new();
+    vec.push(42);
+}
diff --git a/tests/ui/clone_on_copy.rs b/tests/ui/clone_on_copy.rs
new file mode 100644
index 00000000000..ca39a654b4f
--- /dev/null
+++ b/tests/ui/clone_on_copy.rs
@@ -0,0 +1,40 @@
+// run-rustfix
+
+#![allow(
+    unused,
+    clippy::redundant_clone,
+    clippy::deref_addrof,
+    clippy::no_effect,
+    clippy::unnecessary_operation
+)]
+
+use std::cell::RefCell;
+use std::rc::{self, Rc};
+use std::sync::{self, Arc};
+
+fn main() {}
+
+fn is_ascii(ch: char) -> bool {
+    ch.is_ascii()
+}
+
+fn clone_on_copy() {
+    42.clone();
+
+    vec![1].clone(); // ok, not a Copy type
+    Some(vec![1]).clone(); // ok, not a Copy type
+    (&42).clone();
+
+    let rc = RefCell::new(0);
+    rc.borrow().clone();
+
+    // Issue #4348
+    let mut x = 43;
+    let _ = &x.clone(); // ok, getting a ref
+    'a'.clone().make_ascii_uppercase(); // ok, clone and then mutate
+    is_ascii('z'.clone());
+
+    // Issue #5436
+    let mut vec = Vec::new();
+    vec.push(42.clone());
+}
diff --git a/tests/ui/clone_on_copy.stderr b/tests/ui/clone_on_copy.stderr
new file mode 100644
index 00000000000..ec2faf4ab40
--- /dev/null
+++ b/tests/ui/clone_on_copy.stderr
@@ -0,0 +1,34 @@
+error: using `clone` on a `Copy` type
+  --> $DIR/clone_on_copy.rs:22:5
+   |
+LL |     42.clone();
+   |     ^^^^^^^^^^ help: try removing the `clone` call: `42`
+   |
+   = note: `-D clippy::clone-on-copy` implied by `-D warnings`
+
+error: using `clone` on a `Copy` type
+  --> $DIR/clone_on_copy.rs:26:5
+   |
+LL |     (&42).clone();
+   |     ^^^^^^^^^^^^^ help: try dereferencing it: `*(&42)`
+
+error: using `clone` on a `Copy` type
+  --> $DIR/clone_on_copy.rs:29:5
+   |
+LL |     rc.borrow().clone();
+   |     ^^^^^^^^^^^^^^^^^^^ help: try dereferencing it: `*rc.borrow()`
+
+error: using `clone` on a `Copy` type
+  --> $DIR/clone_on_copy.rs:35:14
+   |
+LL |     is_ascii('z'.clone());
+   |              ^^^^^^^^^^^ help: try removing the `clone` call: `'z'`
+
+error: using `clone` on a `Copy` type
+  --> $DIR/clone_on_copy.rs:39:14
+   |
+LL |     vec.push(42.clone());
+   |              ^^^^^^^^^^ help: try removing the `clone` call: `42`
+
+error: aborting due to 5 previous errors
+
diff --git a/tests/ui/unnecessary_clone.rs b/tests/ui/unnecessary_clone.rs
index f1cc5b564c1..2c9d4d39e6c 100644
--- a/tests/ui/unnecessary_clone.rs
+++ b/tests/ui/unnecessary_clone.rs
@@ -13,31 +13,6 @@ impl SomeTrait for SomeImpl {}
 
 fn main() {}
 
-fn is_ascii(ch: char) -> bool {
-    ch.is_ascii()
-}
-
-fn clone_on_copy() {
-    42.clone();
-
-    vec![1].clone(); // ok, not a Copy type
-    Some(vec![1]).clone(); // ok, not a Copy type
-    (&42).clone();
-
-    let rc = RefCell::new(0);
-    rc.borrow().clone();
-
-    // Issue #4348
-    let mut x = 43;
-    let _ = &x.clone(); // ok, getting a ref
-    'a'.clone().make_ascii_uppercase(); // ok, clone and then mutate
-    is_ascii('z'.clone());
-
-    // Issue #5436
-    let mut vec = Vec::new();
-    vec.push(42.clone());
-}
-
 fn clone_on_ref_ptr() {
     let rc = Rc::new(true);
     let arc = Arc::new(true);
diff --git a/tests/ui/unnecessary_clone.stderr b/tests/ui/unnecessary_clone.stderr
index 6176a2bc464..113fab69009 100644
--- a/tests/ui/unnecessary_clone.stderr
+++ b/tests/ui/unnecessary_clone.stderr
@@ -1,37 +1,5 @@
-error: using `clone` on a `Copy` type
-  --> $DIR/unnecessary_clone.rs:21:5
-   |
-LL |     42.clone();
-   |     ^^^^^^^^^^ help: try removing the `clone` call: `42`
-   |
-   = note: `-D clippy::clone-on-copy` implied by `-D warnings`
-
-error: using `clone` on a `Copy` type
-  --> $DIR/unnecessary_clone.rs:25:5
-   |
-LL |     (&42).clone();
-   |     ^^^^^^^^^^^^^ help: try dereferencing it: `*(&42)`
-
-error: using `clone` on a `Copy` type
-  --> $DIR/unnecessary_clone.rs:28:5
-   |
-LL |     rc.borrow().clone();
-   |     ^^^^^^^^^^^^^^^^^^^ help: try dereferencing it: `*rc.borrow()`
-
-error: using `clone` on a `Copy` type
-  --> $DIR/unnecessary_clone.rs:34:14
-   |
-LL |     is_ascii('z'.clone());
-   |              ^^^^^^^^^^^ help: try removing the `clone` call: `'z'`
-
-error: using `clone` on a `Copy` type
-  --> $DIR/unnecessary_clone.rs:38:14
-   |
-LL |     vec.push(42.clone());
-   |              ^^^^^^^^^^ help: try removing the `clone` call: `42`
-
 error: using `.clone()` on a ref-counted pointer
-  --> $DIR/unnecessary_clone.rs:48:5
+  --> $DIR/unnecessary_clone.rs:23:5
    |
 LL |     rc.clone();
    |     ^^^^^^^^^^ help: try this: `Rc::<bool>::clone(&rc)`
@@ -39,43 +7,45 @@ LL |     rc.clone();
    = note: `-D clippy::clone-on-ref-ptr` implied by `-D warnings`
 
 error: using `.clone()` on a ref-counted pointer
-  --> $DIR/unnecessary_clone.rs:51:5
+  --> $DIR/unnecessary_clone.rs:26:5
    |
 LL |     arc.clone();
    |     ^^^^^^^^^^^ help: try this: `Arc::<bool>::clone(&arc)`
 
 error: using `.clone()` on a ref-counted pointer
-  --> $DIR/unnecessary_clone.rs:54:5
+  --> $DIR/unnecessary_clone.rs:29:5
    |
 LL |     rcweak.clone();
    |     ^^^^^^^^^^^^^^ help: try this: `Weak::<bool>::clone(&rcweak)`
 
 error: using `.clone()` on a ref-counted pointer
-  --> $DIR/unnecessary_clone.rs:57:5
+  --> $DIR/unnecessary_clone.rs:32:5
    |
 LL |     arc_weak.clone();
    |     ^^^^^^^^^^^^^^^^ help: try this: `Weak::<bool>::clone(&arc_weak)`
 
 error: using `.clone()` on a ref-counted pointer
-  --> $DIR/unnecessary_clone.rs:61:33
+  --> $DIR/unnecessary_clone.rs:36:33
    |
 LL |     let _: Arc<dyn SomeTrait> = x.clone();
    |                                 ^^^^^^^^^ help: try this: `Arc::<SomeImpl>::clone(&x)`
 
 error: using `clone` on a `Copy` type
-  --> $DIR/unnecessary_clone.rs:65:5
+  --> $DIR/unnecessary_clone.rs:40:5
    |
 LL |     t.clone();
    |     ^^^^^^^^^ help: try removing the `clone` call: `t`
+   |
+   = note: `-D clippy::clone-on-copy` implied by `-D warnings`
 
 error: using `clone` on a `Copy` type
-  --> $DIR/unnecessary_clone.rs:67:5
+  --> $DIR/unnecessary_clone.rs:42:5
    |
 LL |     Some(t).clone();
    |     ^^^^^^^^^^^^^^^ help: try removing the `clone` call: `Some(t)`
 
 error: using `clone` on a double-reference; this will copy the reference instead of cloning the inner type
-  --> $DIR/unnecessary_clone.rs:73:22
+  --> $DIR/unnecessary_clone.rs:48:22
    |
 LL |     let z: &Vec<_> = y.clone();
    |                      ^^^^^^^^^
@@ -91,13 +61,13 @@ LL |     let z: &Vec<_> = <&std::vec::Vec<i32>>::clone(y);
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: using `clone` on a `Copy` type
-  --> $DIR/unnecessary_clone.rs:109:20
+  --> $DIR/unnecessary_clone.rs:84:20
    |
 LL |         let _: E = a.clone();
    |                    ^^^^^^^^^ help: try dereferencing it: `*****a`
 
 error: using `clone` on a double-reference; this will copy the reference instead of cloning the inner type
-  --> $DIR/unnecessary_clone.rs:114:22
+  --> $DIR/unnecessary_clone.rs:89:22
    |
 LL |         let _ = &mut encoded.clone();
    |                      ^^^^^^^^^^^^^^^
@@ -112,7 +82,7 @@ LL |         let _ = &mut <&[u8]>::clone(encoded);
    |                      ^^^^^^^^^^^^^^^^^^^^^^^
 
 error: using `clone` on a double-reference; this will copy the reference instead of cloning the inner type
-  --> $DIR/unnecessary_clone.rs:115:18
+  --> $DIR/unnecessary_clone.rs:90:18
    |
 LL |         let _ = &encoded.clone();
    |                  ^^^^^^^^^^^^^^^
@@ -126,5 +96,5 @@ help: or try being explicit if you are sure, that you want to clone a reference
 LL |         let _ = &<&[u8]>::clone(encoded);
    |                  ^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 16 previous errors
+error: aborting due to 11 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From fa0f1d3e5353df04e3d2e68e65810ca1a231c220 Mon Sep 17 00:00:00 2001
From: "Carol (Nichols || Goulding)" <carol.nichols@gmail.com>
Date: Thu, 25 Jun 2020 11:25:21 -0400
Subject: Change a noun to a verb to make the sentence complete

---
 clippy_lints/src/await_holding_lock.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/await_holding_lock.rs b/clippy_lints/src/await_holding_lock.rs
index a88f922d8e0..8f7e06b32ff 100644
--- a/clippy_lints/src/await_holding_lock.rs
+++ b/clippy_lints/src/await_holding_lock.rs
@@ -11,7 +11,7 @@ declare_clippy_lint! {
     /// non-async-aware MutexGuard.
     ///
     /// **Why is this bad?** The Mutex types found in syd::sync and parking_lot
-    /// are not designed to operator in an async context across await points.
+    /// are not designed to operate in an async context across await points.
     ///
     /// There are two potential solutions. One is to use an asynx-aware Mutex
     /// type. Many asynchronous foundation crates provide such a Mutex type. The
-- 
cgit 1.4.1-3-g733a5


From 814349f9418b3d247e2e3cc952877e510f824fdd Mon Sep 17 00:00:00 2001
From: Eduardo Broto <ebroto@tutanota.com>
Date: Fri, 26 Jun 2020 10:52:14 +0200
Subject: Lint enabling the whole restriction group

---
 CHANGELOG.md              |  1 +
 clippy_lints/src/attrs.rs | 95 +++++++++++++++++++++++++++++++++--------------
 clippy_lints/src/lib.rs   |  3 ++
 src/lintlist/mod.rs       |  7 ++++
 tests/ui/attrs.rs         |  6 +++
 tests/ui/attrs.stderr     | 33 ++++++++++++++--
 6 files changed, 113 insertions(+), 32 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index d6186c319d0..b88044d6ce8 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1352,6 +1352,7 @@ Released 2018-09-13
 [`bad_bit_mask`]: https://rust-lang.github.io/rust-clippy/master/index.html#bad_bit_mask
 [`bind_instead_of_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#bind_instead_of_map
 [`blacklisted_name`]: https://rust-lang.github.io/rust-clippy/master/index.html#blacklisted_name
+[`blanket_clippy_restriction_lints`]: https://rust-lang.github.io/rust-clippy/master/index.html#blanket_clippy_restriction_lints
 [`blocks_in_if_conditions`]: https://rust-lang.github.io/rust-clippy/master/index.html#blocks_in_if_conditions
 [`bool_comparison`]: https://rust-lang.github.io/rust-clippy/master/index.html#bool_comparison
 [`borrow_interior_mutable_const`]: https://rust-lang.github.io/rust-clippy/master/index.html#borrow_interior_mutable_const
diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs
index 41f125d4839..dd4dffda0f9 100644
--- a/clippy_lints/src/attrs.rs
+++ b/clippy_lints/src/attrs.rs
@@ -2,8 +2,8 @@
 
 use crate::reexport::Name;
 use crate::utils::{
-    first_line_of_span, is_present_in_source, match_def_path, paths, snippet_opt, span_lint, span_lint_and_sugg,
-    span_lint_and_then, without_block_comments,
+    first_line_of_span, is_present_in_source, match_def_path, paths, snippet_opt, span_lint, span_lint_and_help,
+    span_lint_and_sugg, span_lint_and_then, without_block_comments,
 };
 use if_chain::if_chain;
 use rustc_ast::ast::{AttrKind, AttrStyle, Attribute, Lit, LitKind, MetaItemKind, NestedMetaItem};
@@ -17,7 +17,7 @@ use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
-use rustc_span::symbol::Symbol;
+use rustc_span::symbol::{Symbol, SymbolStr};
 use semver::Version;
 
 static UNIX_SYSTEMS: &[&str] = &[
@@ -182,6 +182,29 @@ declare_clippy_lint! {
     "unknown_lints for scoped Clippy lints"
 }
 
+declare_clippy_lint! {
+    /// **What it does:** Checks for `warn`/`deny`/`forbid` attributes targeting the whole clippy::restriction category.
+    ///
+    /// **Why is this bad?** Restriction lints sometimes are in contrast with other lints or even go against idiomatic rust.
+    /// These lints should only be enabled on a lint-by-lint basis and with careful consideration.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// Bad:
+    /// ```rust
+    /// #![deny(clippy::restriction)]
+    /// ```
+    ///
+    /// Good:
+    /// ```rust
+    /// #![deny(clippy::as_conversions)]
+    /// ```
+    pub BLANKET_CLIPPY_RESTRICTION_LINTS,
+    correctness,
+    "enabling the complete restriction group"
+}
+
 declare_clippy_lint! {
     /// **What it does:** Checks for `#[cfg_attr(rustfmt, rustfmt_skip)]` and suggests to replace it
     /// with `#[rustfmt::skip]`.
@@ -249,15 +272,17 @@ declare_lint_pass!(Attributes => [
     DEPRECATED_SEMVER,
     USELESS_ATTRIBUTE,
     UNKNOWN_CLIPPY_LINTS,
+    BLANKET_CLIPPY_RESTRICTION_LINTS,
 ]);
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Attributes {
     fn check_attribute(&mut self, cx: &LateContext<'a, 'tcx>, attr: &'tcx Attribute) {
         if let Some(items) = &attr.meta_item_list() {
             if let Some(ident) = attr.ident() {
-                match &*ident.as_str() {
+                let ident = &*ident.as_str();
+                match ident {
                     "allow" | "warn" | "deny" | "forbid" => {
-                        check_clippy_lint_names(cx, items);
+                        check_clippy_lint_names(cx, ident, items);
                     },
                     _ => {},
                 }
@@ -363,38 +388,43 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Attributes {
     }
 }
 
-#[allow(clippy::single_match_else)]
-fn check_clippy_lint_names(cx: &LateContext<'_, '_>, items: &[NestedMetaItem]) {
-    let lint_store = cx.lints();
-    for lint in items {
+fn check_clippy_lint_names(cx: &LateContext<'_, '_>, ident: &str, items: &[NestedMetaItem]) {
+    fn extract_name(lint: &NestedMetaItem) -> Option<SymbolStr> {
         if_chain! {
             if let Some(meta_item) = lint.meta_item();
             if meta_item.path.segments.len() > 1;
             if let tool_name = meta_item.path.segments[0].ident;
             if tool_name.as_str() == "clippy";
-            let name = meta_item.path.segments.last().unwrap().ident.name;
-            if let CheckLintNameResult::Tool(Err((None, _))) = lint_store.check_lint_name(
-                &name.as_str(),
-                Some(tool_name.name),
-            );
+            let lint_name = meta_item.path.segments.last().unwrap().ident.name;
             then {
+                return Some(lint_name.as_str());
+            }
+        }
+        None
+    }
+
+    let lint_store = cx.lints();
+    for lint in items {
+        if let Some(lint_name) = extract_name(lint) {
+            if let CheckLintNameResult::Tool(Err((None, _))) =
+                lint_store.check_lint_name(&lint_name, Some(sym!(clippy)))
+            {
                 span_lint_and_then(
                     cx,
                     UNKNOWN_CLIPPY_LINTS,
                     lint.span(),
-                    &format!("unknown clippy lint: clippy::{}", name),
+                    &format!("unknown clippy lint: clippy::{}", lint_name),
                     |diag| {
-                        let name_lower = name.as_str().to_lowercase();
-                        let symbols = lint_store.get_lints().iter().map(
-                            |l| Symbol::intern(&l.name_lower())
-                        ).collect::<Vec<_>>();
-                        let sugg = find_best_match_for_name(
-                            symbols.iter(),
-                            &format!("clippy::{}", name_lower),
-                            None,
-                        );
-                        if name.as_str().chars().any(char::is_uppercase)
-                            && lint_store.find_lints(&format!("clippy::{}", name_lower)).is_ok() {
+                        let name_lower = lint_name.to_lowercase();
+                        let symbols = lint_store
+                            .get_lints()
+                            .iter()
+                            .map(|l| Symbol::intern(&l.name_lower()))
+                            .collect::<Vec<_>>();
+                        let sugg = find_best_match_for_name(symbols.iter(), &format!("clippy::{}", name_lower), None);
+                        if lint_name.chars().any(char::is_uppercase)
+                            && lint_store.find_lints(&format!("clippy::{}", name_lower)).is_ok()
+                        {
                             diag.span_suggestion(
                                 lint.span(),
                                 "lowercase the lint name",
@@ -409,10 +439,19 @@ fn check_clippy_lint_names(cx: &LateContext<'_, '_>, items: &[NestedMetaItem]) {
                                 Applicability::MachineApplicable,
                             );
                         }
-                    }
+                    },
+                );
+            } else if lint_name == "restriction" && ident != "allow" {
+                span_lint_and_help(
+                    cx,
+                    BLANKET_CLIPPY_RESTRICTION_LINTS,
+                    lint.span(),
+                    "restriction lints are not meant to be all enabled",
+                    None,
+                    "try enabling only the lints you really need",
                 );
             }
-        };
+        }
     }
 }
 
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 756b6b9a8a4..24eb492ee72 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -474,6 +474,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &assign_ops::ASSIGN_OP_PATTERN,
         &assign_ops::MISREFACTORED_ASSIGN_OP,
         &atomic_ordering::INVALID_ATOMIC_ORDERING,
+        &attrs::BLANKET_CLIPPY_RESTRICTION_LINTS,
         &attrs::DEPRECATED_CFG_ATTR,
         &attrs::DEPRECATED_SEMVER,
         &attrs::EMPTY_LINE_AFTER_OUTER_ATTR,
@@ -1189,6 +1190,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&assign_ops::ASSIGN_OP_PATTERN),
         LintId::of(&assign_ops::MISREFACTORED_ASSIGN_OP),
         LintId::of(&atomic_ordering::INVALID_ATOMIC_ORDERING),
+        LintId::of(&attrs::BLANKET_CLIPPY_RESTRICTION_LINTS),
         LintId::of(&attrs::DEPRECATED_CFG_ATTR),
         LintId::of(&attrs::DEPRECATED_SEMVER),
         LintId::of(&attrs::MISMATCHED_TARGET_OS),
@@ -1614,6 +1616,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_group(true, "clippy::correctness", Some("clippy_correctness"), vec![
         LintId::of(&approx_const::APPROX_CONSTANT),
         LintId::of(&atomic_ordering::INVALID_ATOMIC_ORDERING),
+        LintId::of(&attrs::BLANKET_CLIPPY_RESTRICTION_LINTS),
         LintId::of(&attrs::DEPRECATED_SEMVER),
         LintId::of(&attrs::MISMATCHED_TARGET_OS),
         LintId::of(&attrs::USELESS_ATTRIBUTE),
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index 5a43a1a07d2..8d27e6282f1 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -80,6 +80,13 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
         deprecation: None,
         module: "blacklisted_name",
     },
+    Lint {
+        name: "blanket_clippy_restriction_lints",
+        group: "correctness",
+        desc: "enabling the complete restriction group",
+        deprecation: None,
+        module: "attrs",
+    },
     Lint {
         name: "blocks_in_if_conditions",
         group: "style",
diff --git a/tests/ui/attrs.rs b/tests/ui/attrs.rs
index 91b65a43be7..908d063729f 100644
--- a/tests/ui/attrs.rs
+++ b/tests/ui/attrs.rs
@@ -1,5 +1,11 @@
 #![warn(clippy::inline_always, clippy::deprecated_semver)]
 #![allow(clippy::assertions_on_constants)]
+// Test that the whole restriction group is not enabled
+#![warn(clippy::restriction)]
+#![deny(clippy::restriction)]
+#![forbid(clippy::restriction)]
+#![allow(clippy::missing_docs_in_private_items, clippy::panic, clippy::unreachable)]
+
 #[inline(always)]
 fn test_attr_lint() {
     assert!(true)
diff --git a/tests/ui/attrs.stderr b/tests/ui/attrs.stderr
index 39ddf6f226d..adceb4b6369 100644
--- a/tests/ui/attrs.stderr
+++ b/tests/ui/attrs.stderr
@@ -1,5 +1,5 @@
 error: you have declared `#[inline(always)]` on `test_attr_lint`. This is usually a bad idea
-  --> $DIR/attrs.rs:3:1
+  --> $DIR/attrs.rs:9:1
    |
 LL | #[inline(always)]
    | ^^^^^^^^^^^^^^^^^
@@ -7,7 +7,7 @@ LL | #[inline(always)]
    = note: `-D clippy::inline-always` implied by `-D warnings`
 
 error: the since field must contain a semver-compliant version
-  --> $DIR/attrs.rs:23:14
+  --> $DIR/attrs.rs:29:14
    |
 LL | #[deprecated(since = "forever")]
    |              ^^^^^^^^^^^^^^^^^
@@ -15,10 +15,35 @@ LL | #[deprecated(since = "forever")]
    = note: `-D clippy::deprecated-semver` implied by `-D warnings`
 
 error: the since field must contain a semver-compliant version
-  --> $DIR/attrs.rs:26:14
+  --> $DIR/attrs.rs:32:14
    |
 LL | #[deprecated(since = "1")]
    |              ^^^^^^^^^^^
 
-error: aborting due to 3 previous errors
+error: restriction lints are not meant to be all enabled
+  --> $DIR/attrs.rs:4:9
+   |
+LL | #![warn(clippy::restriction)]
+   |         ^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `#[deny(clippy::blanket_clippy_restriction_lints)]` on by default
+   = help: try enabling only the lints you really need
+
+error: restriction lints are not meant to be all enabled
+  --> $DIR/attrs.rs:5:9
+   |
+LL | #![deny(clippy::restriction)]
+   |         ^^^^^^^^^^^^^^^^^^^
+   |
+   = help: try enabling only the lints you really need
+
+error: restriction lints are not meant to be all enabled
+  --> $DIR/attrs.rs:6:11
+   |
+LL | #![forbid(clippy::restriction)]
+   |           ^^^^^^^^^^^^^^^^^^^
+   |
+   = help: try enabling only the lints you really need
+
+error: aborting due to 6 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From c5d8f530e0625f14c5b4bedebdf0dc53064310c9 Mon Sep 17 00:00:00 2001
From: Eduardo Broto <ebroto@tutanota.com>
Date: Sat, 27 Jun 2020 21:49:34 +0200
Subject: Move blanket_clippy_restriction_lints to "style"

---
 clippy_lints/src/attrs.rs | 2 +-
 clippy_lints/src/lib.rs   | 2 +-
 src/lintlist/mod.rs       | 2 +-
 tests/ui/attrs.stderr     | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs
index dd4dffda0f9..bb9d8be5dae 100644
--- a/clippy_lints/src/attrs.rs
+++ b/clippy_lints/src/attrs.rs
@@ -201,7 +201,7 @@ declare_clippy_lint! {
     /// #![deny(clippy::as_conversions)]
     /// ```
     pub BLANKET_CLIPPY_RESTRICTION_LINTS,
-    correctness,
+    style,
     "enabling the complete restriction group"
 }
 
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 24eb492ee72..50116a95612 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1443,6 +1443,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_group(true, "clippy::style", Some("clippy_style"), vec![
         LintId::of(&assertions_on_constants::ASSERTIONS_ON_CONSTANTS),
         LintId::of(&assign_ops::ASSIGN_OP_PATTERN),
+        LintId::of(&attrs::BLANKET_CLIPPY_RESTRICTION_LINTS),
         LintId::of(&attrs::UNKNOWN_CLIPPY_LINTS),
         LintId::of(&bit_mask::VERBOSE_BIT_MASK),
         LintId::of(&blacklisted_name::BLACKLISTED_NAME),
@@ -1616,7 +1617,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_group(true, "clippy::correctness", Some("clippy_correctness"), vec![
         LintId::of(&approx_const::APPROX_CONSTANT),
         LintId::of(&atomic_ordering::INVALID_ATOMIC_ORDERING),
-        LintId::of(&attrs::BLANKET_CLIPPY_RESTRICTION_LINTS),
         LintId::of(&attrs::DEPRECATED_SEMVER),
         LintId::of(&attrs::MISMATCHED_TARGET_OS),
         LintId::of(&attrs::USELESS_ATTRIBUTE),
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index 8d27e6282f1..5119fb40337 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -82,7 +82,7 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
     },
     Lint {
         name: "blanket_clippy_restriction_lints",
-        group: "correctness",
+        group: "style",
         desc: "enabling the complete restriction group",
         deprecation: None,
         module: "attrs",
diff --git a/tests/ui/attrs.stderr b/tests/ui/attrs.stderr
index adceb4b6369..ef4b89eaa6d 100644
--- a/tests/ui/attrs.stderr
+++ b/tests/ui/attrs.stderr
@@ -26,7 +26,7 @@ error: restriction lints are not meant to be all enabled
 LL | #![warn(clippy::restriction)]
    |         ^^^^^^^^^^^^^^^^^^^
    |
-   = note: `#[deny(clippy::blanket_clippy_restriction_lints)]` on by default
+   = note: `-D clippy::blanket-clippy-restriction-lints` implied by `-D warnings`
    = help: try enabling only the lints you really need
 
 error: restriction lints are not meant to be all enabled
-- 
cgit 1.4.1-3-g733a5


From bff6c435ef597071410af5d136916231f310c64c Mon Sep 17 00:00:00 2001
From: Eduardo Broto <ebroto@tutanota.com>
Date: Wed, 1 Jul 2020 00:15:21 +0200
Subject: Require `or_patterns` to suggest nesting them

---
 clippy_lints/src/unnested_or_patterns.rs | 4 ++--
 tests/ui/unnested_or_patterns3.rs        | 6 ++++++
 2 files changed, 8 insertions(+), 2 deletions(-)
 create mode 100644 tests/ui/unnested_or_patterns3.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unnested_or_patterns.rs b/clippy_lints/src/unnested_or_patterns.rs
index 4d3682263f1..169a486d1eb 100644
--- a/clippy_lints/src/unnested_or_patterns.rs
+++ b/clippy_lints/src/unnested_or_patterns.rs
@@ -72,8 +72,8 @@ impl EarlyLintPass for UnnestedOrPatterns {
 }
 
 fn lint_unnested_or_patterns(cx: &EarlyContext<'_>, pat: &Pat) {
-    if !cx.sess.opts.unstable_features.is_nightly_build() {
-        // User cannot do `#![feature(or_patterns)]`, so bail.
+    if !cx.sess.features_untracked().or_patterns {
+        // Do not suggest nesting the patterns if the feature `or_patterns` is not enabled.
         return;
     }
 
diff --git a/tests/ui/unnested_or_patterns3.rs b/tests/ui/unnested_or_patterns3.rs
new file mode 100644
index 00000000000..6bd35057bfa
--- /dev/null
+++ b/tests/ui/unnested_or_patterns3.rs
@@ -0,0 +1,6 @@
+#![warn(clippy::unnested_or_patterns)]
+
+// Test that `unnested_or_patterns` does not trigger without enabling `or_patterns`
+fn main() {
+    if let (0, 1) | (0, 2) | (0, 3) = (0, 0) {}
+}
-- 
cgit 1.4.1-3-g733a5


From d347d0cf59d0a502361db873d900f4587c6e34de Mon Sep 17 00:00:00 2001
From: Philipp Hansch <dev@phansch.net>
Date: Wed, 1 Jul 2020 12:36:36 +0200
Subject: Deprecate regex_macro lint

---
 clippy_lints/src/deprecated_lints.rs | 10 ++++++-
 clippy_lints/src/lib.rs              |  9 +++---
 clippy_lints/src/regex.rs            | 57 ++----------------------------------
 clippy_lints/src/utils/paths.rs      |  1 -
 src/lintlist/mod.rs                  |  7 -----
 tests/ui/deprecated.rs               |  1 +
 tests/ui/deprecated.stderr           |  8 ++++-
 tests/ui/regex.rs                    |  2 +-
 8 files changed, 26 insertions(+), 69 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/deprecated_lints.rs b/clippy_lints/src/deprecated_lints.rs
index 6e8ca647dd7..818d8188a78 100644
--- a/clippy_lints/src/deprecated_lints.rs
+++ b/clippy_lints/src/deprecated_lints.rs
@@ -153,5 +153,13 @@ declare_deprecated_lint! {
     ///
     /// **Deprecation reason:** Associated-constants are now preferred.
     pub REPLACE_CONSTS,
-    "associated-constants `MIN`/`MAX` of integers are prefer to `{min,max}_value()` and module constants"
+    "associated-constants `MIN`/`MAX` of integers are prefered to `{min,max}_value()` and module constants"
+}
+
+declare_deprecated_lint! {
+    /// **What it does:** Nothing. This lint has been deprecated.
+    ///
+    /// **Deprecation reason:** The regex! macro does not exist anymore.
+    pub REGEX_MACRO,
+    "the regex! macro has been removed from the regex crate in 2018"
 }
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 50116a95612..d31a597b66a 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -460,7 +460,11 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     );
     store.register_removed(
         "clippy::replace_consts",
-        "associated-constants `MIN`/`MAX` of integers are prefer to `{min,max}_value()` and module constants",
+        "associated-constants `MIN`/`MAX` of integers are prefered to `{min,max}_value()` and module constants",
+    );
+    store.register_removed(
+        "clippy::regex_macro",
+        "the regex! macro has been removed from the regex crate in 2018",
     );
     // end deprecated lints, do not remove this comment, it’s used in `update_lints`
 
@@ -755,7 +759,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &reference::DEREF_ADDROF,
         &reference::REF_IN_DEREF,
         &regex::INVALID_REGEX,
-        &regex::REGEX_MACRO,
         &regex::TRIVIAL_REGEX,
         &returns::NEEDLESS_RETURN,
         &returns::UNUSED_UNIT,
@@ -1380,7 +1383,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&reference::DEREF_ADDROF),
         LintId::of(&reference::REF_IN_DEREF),
         LintId::of(&regex::INVALID_REGEX),
-        LintId::of(&regex::REGEX_MACRO),
         LintId::of(&regex::TRIVIAL_REGEX),
         LintId::of(&returns::NEEDLESS_RETURN),
         LintId::of(&returns::UNUSED_UNIT),
@@ -1517,7 +1519,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&redundant_field_names::REDUNDANT_FIELD_NAMES),
         LintId::of(&redundant_pattern_matching::REDUNDANT_PATTERN_MATCHING),
         LintId::of(&redundant_static_lifetimes::REDUNDANT_STATIC_LIFETIMES),
-        LintId::of(&regex::REGEX_MACRO),
         LintId::of(&regex::TRIVIAL_REGEX),
         LintId::of(&returns::NEEDLESS_RETURN),
         LintId::of(&returns::UNUSED_UNIT),
diff --git a/clippy_lints/src/regex.rs b/clippy_lints/src/regex.rs
index 9c54c3cbac0..7405edbcd19 100644
--- a/clippy_lints/src/regex.rs
+++ b/clippy_lints/src/regex.rs
@@ -1,9 +1,9 @@
 use crate::consts::{constant, Constant};
-use crate::utils::{is_expn_of, match_def_path, match_type, paths, span_lint, span_lint_and_help};
+use crate::utils::{match_def_path, paths, span_lint, span_lint_and_help};
 use if_chain::if_chain;
 use rustc_ast::ast::{LitKind, StrStyle};
 use rustc_data_structures::fx::FxHashSet;
-use rustc_hir::{Block, BorrowKind, Crate, Expr, ExprKind, HirId};
+use rustc_hir::{BorrowKind, Expr, ExprKind, HirId};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::{BytePos, Span};
@@ -46,66 +46,15 @@ declare_clippy_lint! {
     "trivial regular expressions"
 }
 
-declare_clippy_lint! {
-    /// **What it does:** Checks for usage of `regex!(_)` which (as of now) is
-    /// usually slower than `Regex::new(_)` unless called in a loop (which is a bad
-    /// idea anyway).
-    ///
-    /// **Why is this bad?** Performance, at least for now. The macro version is
-    /// likely to catch up long-term, but for now the dynamic version is faster.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    /// ```ignore
-    /// regex!("foo|bar")
-    /// ```
-    pub REGEX_MACRO,
-    style,
-    "use of `regex!(_)` instead of `Regex::new(_)`"
-}
-
 #[derive(Clone, Default)]
 pub struct Regex {
     spans: FxHashSet<Span>,
     last: Option<HirId>,
 }
 
-impl_lint_pass!(Regex => [INVALID_REGEX, REGEX_MACRO, TRIVIAL_REGEX]);
+impl_lint_pass!(Regex => [INVALID_REGEX, TRIVIAL_REGEX]);
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Regex {
-    fn check_crate(&mut self, _: &LateContext<'a, 'tcx>, _: &'tcx Crate<'_>) {
-        self.spans.clear();
-    }
-
-    fn check_block(&mut self, cx: &LateContext<'a, 'tcx>, block: &'tcx Block<'_>) {
-        if_chain! {
-            if self.last.is_none();
-            if let Some(ref expr) = block.expr;
-            if match_type(cx, cx.tables().expr_ty(expr), &paths::REGEX);
-            if let Some(span) = is_expn_of(expr.span, "regex");
-            then {
-                if !self.spans.contains(&span) {
-                    span_lint(
-                        cx,
-                        REGEX_MACRO,
-                        span,
-                        "`regex!(_)` found. \
-                        Please use `Regex::new(_)`, which is faster for now."
-                    );
-                    self.spans.insert(span);
-                }
-                self.last = Some(block.hir_id);
-            }
-        }
-    }
-
-    fn check_block_post(&mut self, _: &LateContext<'a, 'tcx>, block: &'tcx Block<'_>) {
-        if self.last.map_or(false, |id| block.hir_id == id) {
-            self.last = None;
-        }
-    }
-
     fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr<'_>) {
         if_chain! {
             if let ExprKind::Call(ref fun, ref args) = expr.kind;
diff --git a/clippy_lints/src/utils/paths.rs b/clippy_lints/src/utils/paths.rs
index 3b7e9739211..4c3462802e9 100644
--- a/clippy_lints/src/utils/paths.rs
+++ b/clippy_lints/src/utils/paths.rs
@@ -98,7 +98,6 @@ pub const RANGE_TO_STD: [&str; 3] = ["std", "ops", "RangeTo"];
 pub const RC: [&str; 3] = ["alloc", "rc", "Rc"];
 pub const RC_PTR_EQ: [&str; 4] = ["alloc", "rc", "Rc", "ptr_eq"];
 pub const RECEIVER: [&str; 4] = ["std", "sync", "mpsc", "Receiver"];
-pub const REGEX: [&str; 3] = ["regex", "re_unicode", "Regex"];
 pub const REGEX_BUILDER_NEW: [&str; 5] = ["regex", "re_builder", "unicode", "RegexBuilder", "new"];
 pub const REGEX_BYTES_BUILDER_NEW: [&str; 5] = ["regex", "re_builder", "bytes", "RegexBuilder", "new"];
 pub const REGEX_BYTES_NEW: [&str; 4] = ["regex", "re_bytes", "Regex", "new"];
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index 5119fb40337..a2998d74130 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -1865,13 +1865,6 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
         deprecation: None,
         module: "reference",
     },
-    Lint {
-        name: "regex_macro",
-        group: "style",
-        desc: "use of `regex!(_)` instead of `Regex::new(_)`",
-        deprecation: None,
-        module: "regex",
-    },
     Lint {
         name: "rest_pat_in_fully_bound_structs",
         group: "restriction",
diff --git a/tests/ui/deprecated.rs b/tests/ui/deprecated.rs
index 188a641aa1a..3eefb232780 100644
--- a/tests/ui/deprecated.rs
+++ b/tests/ui/deprecated.rs
@@ -7,5 +7,6 @@
 #[warn(clippy::invalid_ref)]
 #[warn(clippy::into_iter_on_array)]
 #[warn(clippy::unused_label)]
+#[warn(clippy::regex_macro)]
 
 fn main() {}
diff --git a/tests/ui/deprecated.stderr b/tests/ui/deprecated.stderr
index a4efe3d15a9..a80e2bf31fe 100644
--- a/tests/ui/deprecated.stderr
+++ b/tests/ui/deprecated.stderr
@@ -54,11 +54,17 @@ error: lint `clippy::unused_label` has been removed: `this lint has been uplifte
 LL | #[warn(clippy::unused_label)]
    |        ^^^^^^^^^^^^^^^^^^^^
 
+error: lint `clippy::regex_macro` has been removed: `the regex! macro has been removed from the regex crate in 2018`
+  --> $DIR/deprecated.rs:10:8
+   |
+LL | #[warn(clippy::regex_macro)]
+   |        ^^^^^^^^^^^^^^^^^^^
+
 error: lint `clippy::str_to_string` has been removed: `using `str::to_string` is common even today and specialization will likely happen soon`
   --> $DIR/deprecated.rs:1:8
    |
 LL | #[warn(clippy::str_to_string)]
    |        ^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 10 previous errors
+error: aborting due to 11 previous errors
 
diff --git a/tests/ui/regex.rs b/tests/ui/regex.rs
index b523fa5b711..9767e5bf76a 100644
--- a/tests/ui/regex.rs
+++ b/tests/ui/regex.rs
@@ -1,5 +1,5 @@
 #![allow(unused)]
-#![warn(clippy::invalid_regex, clippy::trivial_regex, clippy::regex_macro)]
+#![warn(clippy::invalid_regex, clippy::trivial_regex)]
 
 extern crate regex;
 
-- 
cgit 1.4.1-3-g733a5


From 754bfb1dc89ed9a98b2f1b7d77b035e809b14031 Mon Sep 17 00:00:00 2001
From: ThibsG <Thibs@debian.com>
Date: Sun, 28 Jun 2020 12:14:04 +0200
Subject: Add configurable threshold for `type_repetition_in_bounds` lint

---
 clippy_lints/src/lib.rs                             |  5 +++--
 clippy_lints/src/trait_bounds.rs                    | 18 +++++++++++++++---
 clippy_lints/src/utils/conf.rs                      |  2 ++
 .../toml_unknown_key/conf_unknown_key.stderr        |  2 +-
 tests/ui/type_repetition_in_bounds.rs               | 21 ++++++++++++++++++++-
 tests/ui/type_repetition_in_bounds.stderr           | 18 +++++++++++++-----
 6 files changed, 54 insertions(+), 12 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index d31a597b66a..38f8d007c72 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -996,7 +996,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box checked_conversions::CheckedConversions);
     store.register_late_pass(|| box integer_division::IntegerDivision);
     store.register_late_pass(|| box inherent_to_string::InherentToString);
-    store.register_late_pass(|| box trait_bounds::TraitBounds);
+    let max_trait_bounds = conf.max_trait_bounds;
+    store.register_late_pass(move || box trait_bounds::TraitBounds::new(max_trait_bounds));
     store.register_late_pass(|| box comparison_chain::ComparisonChain);
     store.register_late_pass(|| box mut_key::MutableKeyType);
     store.register_late_pass(|| box modulo_arithmetic::ModuloArithmetic);
@@ -1033,7 +1034,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     let array_size_threshold = conf.array_size_threshold;
     store.register_late_pass(move || box large_stack_arrays::LargeStackArrays::new(array_size_threshold));
     store.register_late_pass(move || box large_const_arrays::LargeConstArrays::new(array_size_threshold));
-    store.register_late_pass(move || box floating_point_arithmetic::FloatingPointArithmetic);
+    store.register_late_pass(|| box floating_point_arithmetic::FloatingPointArithmetic);
     store.register_early_pass(|| box as_conversions::AsConversions);
     store.register_early_pass(|| box utils::internal_lints::ProduceIce);
     store.register_late_pass(|| box let_underscore::LetUnderscore);
diff --git a/clippy_lints/src/trait_bounds.rs b/clippy_lints/src/trait_bounds.rs
index 9eb2079c3ca..650edbb4b11 100644
--- a/clippy_lints/src/trait_bounds.rs
+++ b/clippy_lints/src/trait_bounds.rs
@@ -5,9 +5,6 @@ use rustc_hir::{GenericBound, Generics, WherePredicate};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 
-#[derive(Copy, Clone)]
-pub struct TraitBounds;
-
 declare_clippy_lint! {
     /// **What it does:** This lint warns about unnecessary type repetitions in trait bounds
     ///
@@ -29,6 +26,18 @@ declare_clippy_lint! {
     "Types are repeated unnecessary in trait bounds use `+` instead of using `T: _, T: _`"
 }
 
+#[derive(Copy, Clone)]
+pub struct TraitBounds {
+    max_trait_bounds: u64,
+}
+
+impl TraitBounds {
+    #[must_use]
+    pub fn new(max_trait_bounds: u64) -> Self {
+        Self { max_trait_bounds }
+    }
+}
+
 impl_lint_pass!(TraitBounds => [TYPE_REPETITION_IN_BOUNDS]);
 
 impl<'tcx> LateLintPass<'tcx> for TraitBounds {
@@ -45,6 +54,9 @@ impl<'tcx> LateLintPass<'tcx> for TraitBounds {
         let mut applicability = Applicability::MaybeIncorrect;
         for bound in gen.where_clause.predicates {
             if let WherePredicate::BoundPredicate(ref p) = bound {
+                if p.bounds.len() as u64 > self.max_trait_bounds {
+                    return;
+                }
                 let h = hash(&p.bounded_ty);
                 if let Some(ref v) = map.insert(h, p.bounds.iter().collect::<Vec<_>>()) {
                     let mut hint_string = format!(
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index c41befbf147..de425211e38 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -156,6 +156,8 @@ define_Conf! {
     (array_size_threshold, "array_size_threshold": u64, 512_000),
     /// Lint: VEC_BOX. The size of the boxed type in bytes, where boxing in a `Vec` is allowed
     (vec_box_size_threshold, "vec_box_size_threshold": u64, 4096),
+    /// Lint: TYPE_REPETITION_IN_BOUNDS. The maximum number of bounds a trait can have to be linted
+    (max_trait_bounds, "max_trait_bounds": u64, 3),
     /// Lint: STRUCT_EXCESSIVE_BOOLS. The maximum number of bools a struct can have
     (max_struct_bools, "max_struct_bools": u64, 3),
     /// Lint: FN_PARAMS_EXCESSIVE_BOOLS. The maximum number of bools function parameters can have
diff --git a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
index 53970af4107..6fbba01416a 100644
--- a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
+++ b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
@@ -1,4 +1,4 @@
-error: error reading Clippy's configuration file `$DIR/clippy.toml`: unknown field `foobar`, expected one of `blacklisted-names`, `cognitive-complexity-threshold`, `cyclomatic-complexity-threshold`, `doc-valid-idents`, `too-many-arguments-threshold`, `type-complexity-threshold`, `single-char-binding-names-threshold`, `too-large-for-stack`, `enum-variant-name-threshold`, `enum-variant-size-threshold`, `verbose-bit-mask-threshold`, `literal-representation-threshold`, `trivial-copy-size-limit`, `too-many-lines-threshold`, `array-size-threshold`, `vec-box-size-threshold`, `max-struct-bools`, `max-fn-params-bools`, `warn-on-all-wildcard-imports`, `third-party` at line 5 column 1
+error: error reading Clippy's configuration file `$DIR/clippy.toml`: unknown field `foobar`, expected one of `blacklisted-names`, `cognitive-complexity-threshold`, `cyclomatic-complexity-threshold`, `doc-valid-idents`, `too-many-arguments-threshold`, `type-complexity-threshold`, `single-char-binding-names-threshold`, `too-large-for-stack`, `enum-variant-name-threshold`, `enum-variant-size-threshold`, `verbose-bit-mask-threshold`, `literal-representation-threshold`, `trivial-copy-size-limit`, `too-many-lines-threshold`, `array-size-threshold`, `vec-box-size-threshold`, `max-trait-bounds`, `max-struct-bools`, `max-fn-params-bools`, `warn-on-all-wildcard-imports`, `third-party` at line 5 column 1
 
 error: aborting due to previous error
 
diff --git a/tests/ui/type_repetition_in_bounds.rs b/tests/ui/type_repetition_in_bounds.rs
index 8b538be762b..60b994548b5 100644
--- a/tests/ui/type_repetition_in_bounds.rs
+++ b/tests/ui/type_repetition_in_bounds.rs
@@ -1,4 +1,6 @@
-#[deny(clippy::type_repetition_in_bounds)]
+#![deny(clippy::type_repetition_in_bounds)]
+
+use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Sub, SubAssign};
 
 pub fn foo<T>(_t: T)
 where
@@ -16,4 +18,21 @@ where
     unimplemented!();
 }
 
+trait LintBounds
+where
+    Self: Clone,
+    Self: Copy + Default + Ord,
+    Self: Add<Output = Self> + AddAssign + Sub<Output = Self> + SubAssign,
+    Self: Mul<Output = Self> + MulAssign + Div<Output = Self> + DivAssign,
+{
+}
+
+trait LotsOfBounds
+where
+    Self: Clone + Copy + Default + Ord,
+    Self: Add<Output = Self> + AddAssign + Sub<Output = Self> + SubAssign,
+    Self: Mul<Output = Self> + MulAssign + Div<Output = Self> + DivAssign,
+{
+}
+
 fn main() {}
diff --git a/tests/ui/type_repetition_in_bounds.stderr b/tests/ui/type_repetition_in_bounds.stderr
index 4264e2e10bf..6a1073a23f6 100644
--- a/tests/ui/type_repetition_in_bounds.stderr
+++ b/tests/ui/type_repetition_in_bounds.stderr
@@ -1,15 +1,23 @@
 error: this type has already been used as a bound predicate
-  --> $DIR/type_repetition_in_bounds.rs:6:5
+  --> $DIR/type_repetition_in_bounds.rs:8:5
    |
 LL |     T: Clone,
    |     ^^^^^^^^
    |
 note: the lint level is defined here
-  --> $DIR/type_repetition_in_bounds.rs:1:8
+  --> $DIR/type_repetition_in_bounds.rs:1:9
    |
-LL | #[deny(clippy::type_repetition_in_bounds)]
-   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL | #![deny(clippy::type_repetition_in_bounds)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    = help: consider combining the bounds: `T: Copy + Clone`
 
-error: aborting due to previous error
+error: this type has already been used as a bound predicate
+  --> $DIR/type_repetition_in_bounds.rs:24:5
+   |
+LL |     Self: Copy + Default + Ord,
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider combining the bounds: `Self: Clone + Copy + Default + Ord`
+
+error: aborting due to 2 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From d5a8f03a350e8a392f0aa1c05707b503f549e90b Mon Sep 17 00:00:00 2001
From: ThibsG <Thibs@debian.com>
Date: Fri, 3 Jul 2020 10:29:14 +0200
Subject: Take generic args into account for bounded type

---
 clippy_lints/src/utils/hir_utils.rs       | 19 ++++++++++++-------
 tests/ui/type_repetition_in_bounds.rs     | 15 +++++++++++++++
 tests/ui/type_repetition_in_bounds.stderr |  2 +-
 3 files changed, 28 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/hir_utils.rs b/clippy_lints/src/utils/hir_utils.rs
index ae58f0a1521..34341594c19 100644
--- a/clippy_lints/src/utils/hir_utils.rs
+++ b/clippy_lints/src/utils/hir_utils.rs
@@ -703,6 +703,7 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> {
                     }
                     for segment in path.segments {
                         segment.ident.name.hash(&mut self.s);
+                        self.hash_generic_args(segment.generic_args().args);
                     }
                 },
                 QPath::TypeRelative(ref ty, ref segment) => {
@@ -711,13 +712,7 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> {
                 },
             },
             TyKind::OpaqueDef(_, arg_list) => {
-                for arg in *arg_list {
-                    match arg {
-                        GenericArg::Lifetime(ref l) => self.hash_lifetime(l),
-                        GenericArg::Type(ref ty) => self.hash_ty(&ty),
-                        GenericArg::Const(ref ca) => self.hash_body(ca.value.body),
-                    }
-                }
+                self.hash_generic_args(arg_list);
             },
             TyKind::TraitObject(_, lifetime) => {
                 self.hash_lifetime(lifetime);
@@ -735,4 +730,14 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> {
         self.hash_expr(&self.cx.tcx.hir().body(body_id).value);
         self.maybe_typeck_tables = old_maybe_typeck_tables;
     }
+
+    fn hash_generic_args(&mut self, arg_list: &[GenericArg<'_>]) {
+        for arg in arg_list {
+            match arg {
+                GenericArg::Lifetime(ref l) => self.hash_lifetime(l),
+                GenericArg::Type(ref ty) => self.hash_ty(&ty),
+                GenericArg::Const(ref ca) => self.hash_body(ca.value.body),
+            }
+        }
+    }
 }
diff --git a/tests/ui/type_repetition_in_bounds.rs b/tests/ui/type_repetition_in_bounds.rs
index 60b994548b5..9f1700567d1 100644
--- a/tests/ui/type_repetition_in_bounds.rs
+++ b/tests/ui/type_repetition_in_bounds.rs
@@ -18,6 +18,7 @@ where
     unimplemented!();
 }
 
+// Threshold test (see #4380)
 trait LintBounds
 where
     Self: Clone,
@@ -35,4 +36,18 @@ where
 {
 }
 
+// Generic distinction (see #4323)
+pub struct Foo<A>(A);
+pub struct Bar<A, B> {
+    a: Foo<A>,
+    b: Foo<B>,
+}
+
+impl<A, B> Unpin for Bar<A, B>
+where
+    Foo<A>: Unpin,
+    Foo<B>: Unpin,
+{
+}
+
 fn main() {}
diff --git a/tests/ui/type_repetition_in_bounds.stderr b/tests/ui/type_repetition_in_bounds.stderr
index 6a1073a23f6..148c19c7d07 100644
--- a/tests/ui/type_repetition_in_bounds.stderr
+++ b/tests/ui/type_repetition_in_bounds.stderr
@@ -12,7 +12,7 @@ LL | #![deny(clippy::type_repetition_in_bounds)]
    = help: consider combining the bounds: `T: Copy + Clone`
 
 error: this type has already been used as a bound predicate
-  --> $DIR/type_repetition_in_bounds.rs:24:5
+  --> $DIR/type_repetition_in_bounds.rs:25:5
    |
 LL |     Self: Copy + Default + Ord,
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From 2d5930a3da7048d784489f28b44a769880b6ceff Mon Sep 17 00:00:00 2001
From: ThibsG <Thibs@debian.com>
Date: Fri, 3 Jul 2020 11:48:28 +0200
Subject: Don't lint for predicates generated in macros

---
 clippy_lints/src/trait_bounds.rs      | 15 +++++++++-----
 tests/ui/type_repetition_in_bounds.rs | 37 ++++++++++++++++++++++++++---------
 2 files changed, 38 insertions(+), 14 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/trait_bounds.rs b/clippy_lints/src/trait_bounds.rs
index 650edbb4b11..0ef70311fb1 100644
--- a/clippy_lints/src/trait_bounds.rs
+++ b/clippy_lints/src/trait_bounds.rs
@@ -1,4 +1,5 @@
 use crate::utils::{in_macro, snippet, snippet_with_applicability, span_lint_and_help, SpanlessHash};
+use if_chain::if_chain;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::Applicability;
 use rustc_hir::{GenericBound, Generics, WherePredicate};
@@ -11,6 +12,8 @@ declare_clippy_lint! {
     /// **Why is this bad?** Repeating the type for every bound makes the code
     /// less readable than combining the bounds
     ///
+    /// **Known problems:** None.
+    ///
     /// **Example:**
     /// ```rust
     /// pub fn foo<T>(t: T) where T: Copy, T: Clone {}
@@ -53,12 +56,14 @@ impl<'tcx> LateLintPass<'tcx> for TraitBounds {
         let mut map = FxHashMap::default();
         let mut applicability = Applicability::MaybeIncorrect;
         for bound in gen.where_clause.predicates {
-            if let WherePredicate::BoundPredicate(ref p) = bound {
-                if p.bounds.len() as u64 > self.max_trait_bounds {
-                    return;
-                }
+            if_chain! {
+                if let WherePredicate::BoundPredicate(ref p) = bound;
+                if p.bounds.len() as u64 <= self.max_trait_bounds;
+                if !in_macro(p.span);
                 let h = hash(&p.bounded_ty);
-                if let Some(ref v) = map.insert(h, p.bounds.iter().collect::<Vec<_>>()) {
+                if let Some(ref v) = map.insert(h, p.bounds.iter().collect::<Vec<_>>());
+
+                then {
                     let mut hint_string = format!(
                         "consider combining the bounds: `{}:",
                         snippet(cx, p.bounded_ty.span, "_")
diff --git a/tests/ui/type_repetition_in_bounds.rs b/tests/ui/type_repetition_in_bounds.rs
index 9f1700567d1..766190f2099 100644
--- a/tests/ui/type_repetition_in_bounds.rs
+++ b/tests/ui/type_repetition_in_bounds.rs
@@ -37,17 +37,36 @@ where
 }
 
 // Generic distinction (see #4323)
-pub struct Foo<A>(A);
-pub struct Bar<A, B> {
-    a: Foo<A>,
-    b: Foo<B>,
+mod issue4323 {
+    pub struct Foo<A>(A);
+    pub struct Bar<A, B> {
+        a: Foo<A>,
+        b: Foo<B>,
+    }
+
+    impl<A, B> Unpin for Bar<A, B>
+    where
+        Foo<A>: Unpin,
+        Foo<B>: Unpin,
+    {
+    }
 }
 
-impl<A, B> Unpin for Bar<A, B>
-where
-    Foo<A>: Unpin,
-    Foo<B>: Unpin,
-{
+// Extern macros shouldn't lint (see #4326)
+extern crate serde;
+mod issue4326 {
+    use serde::{Deserialize, Serialize};
+
+    trait Foo {}
+    impl Foo for String {}
+
+    #[derive(Debug, Serialize, Deserialize)]
+    struct Bar<S>
+    where
+        S: Foo,
+    {
+        foo: S,
+    }
 }
 
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From c3c402783f1d12852982f9dc734cc4c07b9fce33 Mon Sep 17 00:00:00 2001
From: Robert Sedlacek <rs@474.at>
Date: Mon, 4 Nov 2019 19:39:03 +0100
Subject: Added restriction lint: pattern-type-mismatch

---
 CHANGELOG.md                                       |   1 +
 clippy_lints/src/lib.rs                            |   4 +
 clippy_lints/src/pattern_type_mismatch.rs          | 276 +++++++++++++++++++++
 src/lintlist/mod.rs                                |   7 +
 tests/ui/pattern_type_mismatch/mutability.rs       |  40 +++
 tests/ui/pattern_type_mismatch/mutability.stderr   |  19 ++
 .../pattern_type_mismatch/pattern_alternatives.rs  |  24 ++
 .../pattern_alternatives.stderr                    |  27 ++
 tests/ui/pattern_type_mismatch/pattern_structs.rs  |  45 ++++
 .../pattern_type_mismatch/pattern_structs.stderr   |  67 +++++
 tests/ui/pattern_type_mismatch/pattern_tuples.rs   |  57 +++++
 .../ui/pattern_type_mismatch/pattern_tuples.stderr |  83 +++++++
 tests/ui/pattern_type_mismatch/syntax.rs           | 146 +++++++++++
 tests/ui/pattern_type_mismatch/syntax.stderr       |  78 ++++++
 14 files changed, 874 insertions(+)
 create mode 100644 clippy_lints/src/pattern_type_mismatch.rs
 create mode 100644 tests/ui/pattern_type_mismatch/mutability.rs
 create mode 100644 tests/ui/pattern_type_mismatch/mutability.stderr
 create mode 100644 tests/ui/pattern_type_mismatch/pattern_alternatives.rs
 create mode 100644 tests/ui/pattern_type_mismatch/pattern_alternatives.stderr
 create mode 100644 tests/ui/pattern_type_mismatch/pattern_structs.rs
 create mode 100644 tests/ui/pattern_type_mismatch/pattern_structs.stderr
 create mode 100644 tests/ui/pattern_type_mismatch/pattern_tuples.rs
 create mode 100644 tests/ui/pattern_type_mismatch/pattern_tuples.stderr
 create mode 100644 tests/ui/pattern_type_mismatch/syntax.rs
 create mode 100644 tests/ui/pattern_type_mismatch/syntax.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index b88044d6ce8..ed8f16e65bb 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1588,6 +1588,7 @@ Released 2018-09-13
 [`panicking_unwrap`]: https://rust-lang.github.io/rust-clippy/master/index.html#panicking_unwrap
 [`partialeq_ne_impl`]: https://rust-lang.github.io/rust-clippy/master/index.html#partialeq_ne_impl
 [`path_buf_push_overwrite`]: https://rust-lang.github.io/rust-clippy/master/index.html#path_buf_push_overwrite
+[`pattern_type_mismatch`]: https://rust-lang.github.io/rust-clippy/master/index.html#pattern_type_mismatch
 [`possible_missing_comma`]: https://rust-lang.github.io/rust-clippy/master/index.html#possible_missing_comma
 [`precedence`]: https://rust-lang.github.io/rust-clippy/master/index.html#precedence
 [`print_literal`]: https://rust-lang.github.io/rust-clippy/master/index.html#print_literal
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index d31a597b66a..4890349999f 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -268,6 +268,7 @@ mod overflow_check_conditional;
 mod panic_unimplemented;
 mod partialeq_ne_impl;
 mod path_buf_push_overwrite;
+pub mod pattern_type_mismatch;
 mod precedence;
 mod ptr;
 mod ptr_offset_with_cast;
@@ -741,6 +742,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &panic_unimplemented::UNREACHABLE,
         &partialeq_ne_impl::PARTIALEQ_NE_IMPL,
         &path_buf_push_overwrite::PATH_BUF_PUSH_OVERWRITE,
+        &pattern_type_mismatch::PATTERN_TYPE_MISMATCH,
         &precedence::PRECEDENCE,
         &ptr::CMP_NULL,
         &ptr::MUT_FROM_REF,
@@ -1064,6 +1066,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_early_pass(|| box unnested_or_patterns::UnnestedOrPatterns);
     store.register_late_pass(|| box macro_use::MacroUseImports::default());
     store.register_late_pass(|| box map_identity::MapIdentity);
+    store.register_late_pass(|| box pattern_type_mismatch::PatternTypeMismatch);
 
     store.register_group(true, "clippy::restriction", Some("clippy_restriction"), vec![
         LintId::of(&arithmetic::FLOAT_ARITHMETIC),
@@ -1097,6 +1100,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&panic_unimplemented::TODO),
         LintId::of(&panic_unimplemented::UNIMPLEMENTED),
         LintId::of(&panic_unimplemented::UNREACHABLE),
+        LintId::of(&pattern_type_mismatch::PATTERN_TYPE_MISMATCH),
         LintId::of(&shadow::SHADOW_REUSE),
         LintId::of(&shadow::SHADOW_SAME),
         LintId::of(&strings::STRING_ADD),
diff --git a/clippy_lints/src/pattern_type_mismatch.rs b/clippy_lints/src/pattern_type_mismatch.rs
new file mode 100644
index 00000000000..a07279c92b0
--- /dev/null
+++ b/clippy_lints/src/pattern_type_mismatch.rs
@@ -0,0 +1,276 @@
+use crate::utils::{last_path_segment, span_help_and_lint};
+use rustc::lint::in_external_macro;
+use rustc::ty::subst::SubstsRef;
+use rustc::ty::{AdtDef, FieldDef, Ty, TyKind, VariantDef};
+use rustc_hir::{
+    intravisit, Body, Expr, ExprKind, FieldPat, FnDecl, HirId, LocalSource, MatchSource, Mutability, Pat, PatKind,
+    QPath, Stmt, StmtKind,
+};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::source_map::Span;
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for patterns that aren't exact representations of the types
+    /// they are applied to.
+    ///
+    /// **Why is this bad?** It isn't bad in general. But in some contexts it can be desirable
+    /// because it increases ownership hints in the code, and will guard against some changes
+    /// in ownership.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust,ignore
+    /// // Bad
+    /// let value = &Some(Box::new(23));
+    /// match value {
+    ///     Some(inner) => println!("{}", inner),
+    ///     None => println!("none"),
+    /// }
+    ///
+    /// // Good
+    /// let value = &Some(Box::new(23));
+    /// match *value {
+    ///     Some(ref inner) => println!("{}", inner),
+    ///     None => println!("none"),
+    /// }
+    /// ```
+    pub PATTERN_TYPE_MISMATCH,
+    restriction,
+    "type of pattern does not match the expression type"
+}
+
+declare_lint_pass!(PatternTypeMismatch => [PATTERN_TYPE_MISMATCH]);
+
+impl<'a, 'tcx> LateLintPass<'a, 'tcx> for PatternTypeMismatch {
+    fn check_stmt(&mut self, cx: &LateContext<'a, 'tcx>, stmt: &'tcx Stmt<'_>) {
+        if let StmtKind::Local(ref local) = stmt.kind {
+            if let Some(init) = &local.init {
+                if let Some(init_ty) = cx.tables.node_type_opt(init.hir_id) {
+                    let pat = &local.pat;
+                    if in_external_macro(cx.sess(), pat.span) {
+                        return;
+                    }
+                    let deref_possible = match local.source {
+                        LocalSource::Normal => DerefPossible::Possible,
+                        _ => DerefPossible::Impossible,
+                    };
+                    apply_lint(cx, pat, init_ty, deref_possible);
+                }
+            }
+        }
+    }
+
+    fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr<'_>) {
+        if let ExprKind::Match(ref expr, arms, source) = expr.kind {
+            match source {
+                MatchSource::Normal | MatchSource::IfLetDesugar { .. } | MatchSource::WhileLetDesugar => {
+                    if let Some(expr_ty) = cx.tables.node_type_opt(expr.hir_id) {
+                        'pattern_checks: for arm in arms {
+                            let pat = &arm.pat;
+                            if in_external_macro(cx.sess(), pat.span) {
+                                continue 'pattern_checks;
+                            }
+                            if apply_lint(cx, pat, expr_ty, DerefPossible::Possible) {
+                                break 'pattern_checks;
+                            }
+                        }
+                    }
+                },
+                _ => (),
+            }
+        }
+    }
+
+    fn check_fn(
+        &mut self,
+        cx: &LateContext<'a, 'tcx>,
+        _: intravisit::FnKind<'tcx>,
+        _: &'tcx FnDecl<'_>,
+        body: &'tcx Body<'_>,
+        _: Span,
+        hir_id: HirId,
+    ) {
+        if let Some(fn_sig) = cx.tables.liberated_fn_sigs().get(hir_id) {
+            for (param, ty) in body.params.iter().zip(fn_sig.inputs().iter()) {
+                apply_lint(cx, &param.pat, ty, DerefPossible::Impossible);
+            }
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy)]
+enum DerefPossible {
+    Possible,
+    Impossible,
+}
+
+fn apply_lint<'a, 'tcx>(
+    cx: &LateContext<'a, 'tcx>,
+    pat: &Pat<'_>,
+    expr_ty: Ty<'tcx>,
+    deref_possible: DerefPossible,
+) -> bool {
+    let maybe_mismatch = find_first_mismatch(cx, pat, expr_ty, Level::Top);
+    if let Some((span, mutability, level)) = maybe_mismatch {
+        span_help_and_lint(
+            cx,
+            PATTERN_TYPE_MISMATCH,
+            span,
+            "type of pattern does not match the expression type",
+            &format!(
+                "{}explicitly match against a `{}` pattern and adjust the enclosed variable bindings",
+                match (deref_possible, level) {
+                    (DerefPossible::Possible, Level::Top) => "use `*` to dereference the match expression or ",
+                    _ => "",
+                },
+                match mutability {
+                    Mutability::Mut => "&mut _",
+                    Mutability::Not => "&_",
+                },
+            ),
+        );
+        true
+    } else {
+        false
+    }
+}
+
+#[derive(Debug, Copy, Clone)]
+enum Level {
+    Top,
+    Lower,
+}
+
+#[allow(rustc::usage_of_ty_tykind)]
+fn find_first_mismatch<'a, 'tcx>(
+    cx: &LateContext<'a, 'tcx>,
+    pat: &Pat<'_>,
+    ty: Ty<'tcx>,
+    level: Level,
+) -> Option<(Span, Mutability, Level)> {
+    if let PatKind::Ref(ref sub_pat, _) = pat.kind {
+        if let TyKind::Ref(_, sub_ty, _) = ty.kind {
+            return find_first_mismatch(cx, sub_pat, sub_ty, Level::Lower);
+        }
+    }
+
+    if let TyKind::Ref(_, _, mutability) = ty.kind {
+        if is_non_ref_pattern(&pat.kind) {
+            return Some((pat.span, mutability, level));
+        }
+    }
+
+    if let PatKind::Struct(ref qpath, ref field_pats, _) = pat.kind {
+        if let TyKind::Adt(ref adt_def, ref substs_ref) = ty.kind {
+            if let Some(variant) = get_variant(adt_def, qpath) {
+                let field_defs = &variant.fields;
+                return find_first_mismatch_in_struct(cx, field_pats, field_defs, substs_ref);
+            }
+        }
+    }
+
+    if let PatKind::TupleStruct(ref qpath, ref pats, _) = pat.kind {
+        if let TyKind::Adt(ref adt_def, ref substs_ref) = ty.kind {
+            if let Some(variant) = get_variant(adt_def, qpath) {
+                let field_defs = &variant.fields;
+                let ty_iter = field_defs.iter().map(|field_def| field_def.ty(cx.tcx, substs_ref));
+                return find_first_mismatch_in_tuple(cx, pats, ty_iter);
+            }
+        }
+    }
+
+    if let PatKind::Tuple(ref pats, _) = pat.kind {
+        if let TyKind::Tuple(..) = ty.kind {
+            return find_first_mismatch_in_tuple(cx, pats, ty.tuple_fields());
+        }
+    }
+
+    if let PatKind::Or(sub_pats) = pat.kind {
+        for pat in sub_pats {
+            let maybe_mismatch = find_first_mismatch(cx, pat, ty, level);
+            if let Some(mismatch) = maybe_mismatch {
+                return Some(mismatch);
+            }
+        }
+    }
+
+    None
+}
+
+fn get_variant<'a>(adt_def: &'a AdtDef, qpath: &QPath<'_>) -> Option<&'a VariantDef> {
+    if adt_def.is_struct() {
+        if let Some(variant) = adt_def.variants.iter().next() {
+            return Some(variant);
+        }
+    }
+
+    if adt_def.is_enum() {
+        let pat_ident = last_path_segment(qpath).ident;
+        for variant in &adt_def.variants {
+            if variant.ident == pat_ident {
+                return Some(variant);
+            }
+        }
+    }
+
+    None
+}
+
+fn find_first_mismatch_in_tuple<'a, 'tcx, I>(
+    cx: &LateContext<'a, 'tcx>,
+    pats: &[&Pat<'_>],
+    ty_iter_src: I,
+) -> Option<(Span, Mutability, Level)>
+where
+    I: IntoIterator<Item = Ty<'tcx>>,
+{
+    let mut field_tys = ty_iter_src.into_iter();
+    'fields: for pat in pats {
+        let field_ty = if let Some(ty) = field_tys.next() {
+            ty
+        } else {
+            break 'fields;
+        };
+
+        let maybe_mismatch = find_first_mismatch(cx, pat, field_ty, Level::Lower);
+        if let Some(mismatch) = maybe_mismatch {
+            return Some(mismatch);
+        }
+    }
+
+    None
+}
+
+fn find_first_mismatch_in_struct<'a, 'tcx>(
+    cx: &LateContext<'a, 'tcx>,
+    field_pats: &[FieldPat<'_>],
+    field_defs: &[FieldDef],
+    substs_ref: SubstsRef<'tcx>,
+) -> Option<(Span, Mutability, Level)> {
+    for field_pat in field_pats {
+        'definitions: for field_def in field_defs {
+            if field_pat.ident == field_def.ident {
+                let field_ty = field_def.ty(cx.tcx, substs_ref);
+                let pat = &field_pat.pat;
+                let maybe_mismatch = find_first_mismatch(cx, pat, field_ty, Level::Lower);
+                if let Some(mismatch) = maybe_mismatch {
+                    return Some(mismatch);
+                }
+                break 'definitions;
+            }
+        }
+    }
+
+    None
+}
+
+fn is_non_ref_pattern(pat_kind: &PatKind<'_>) -> bool {
+    match pat_kind {
+        PatKind::Struct(..) | PatKind::Tuple(..) | PatKind::TupleStruct(..) | PatKind::Path(..) => true,
+        PatKind::Or(sub_pats) => sub_pats.iter().any(|pat| is_non_ref_pattern(&pat.kind)),
+        _ => false,
+    }
+}
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index a2998d74130..6402efc2521 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -1697,6 +1697,13 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
         deprecation: None,
         module: "path_buf_push_overwrite",
     },
+    Lint {
+        name: "pattern_type_mismatch",
+        group: "restriction",
+        desc: "type of pattern does not match the expression type",
+        deprecation: None,
+        module: "pattern_type_mismatch",
+    },
     Lint {
         name: "possible_missing_comma",
         group: "correctness",
diff --git a/tests/ui/pattern_type_mismatch/mutability.rs b/tests/ui/pattern_type_mismatch/mutability.rs
new file mode 100644
index 00000000000..9b4f2f1f579
--- /dev/null
+++ b/tests/ui/pattern_type_mismatch/mutability.rs
@@ -0,0 +1,40 @@
+#![allow(clippy::all)]
+#![warn(clippy::pattern_type_mismatch)]
+
+fn main() {}
+
+fn should_lint() {
+    let value = &Some(23);
+    match value {
+        Some(_) => (),
+        _ => (),
+    }
+
+    let value = &mut Some(23);
+    match value {
+        Some(_) => (),
+        _ => (),
+    }
+}
+
+fn should_not_lint() {
+    let value = &Some(23);
+    match value {
+        &Some(_) => (),
+        _ => (),
+    }
+    match *value {
+        Some(_) => (),
+        _ => (),
+    }
+
+    let value = &mut Some(23);
+    match value {
+        &mut Some(_) => (),
+        _ => (),
+    }
+    match *value {
+        Some(_) => (),
+        _ => (),
+    }
+}
diff --git a/tests/ui/pattern_type_mismatch/mutability.stderr b/tests/ui/pattern_type_mismatch/mutability.stderr
new file mode 100644
index 00000000000..3421d568365
--- /dev/null
+++ b/tests/ui/pattern_type_mismatch/mutability.stderr
@@ -0,0 +1,19 @@
+error: type of pattern does not match the expression type
+  --> $DIR/mutability.rs:9:9
+   |
+LL |         Some(_) => (),
+   |         ^^^^^^^
+   |
+   = note: `-D clippy::pattern-type-mismatch` implied by `-D warnings`
+   = help: use `*` to dereference the match expression or explicitly match against a `&_` pattern and adjust the enclosed variable bindings
+
+error: type of pattern does not match the expression type
+  --> $DIR/mutability.rs:15:9
+   |
+LL |         Some(_) => (),
+   |         ^^^^^^^
+   |
+   = help: use `*` to dereference the match expression or explicitly match against a `&mut _` pattern and adjust the enclosed variable bindings
+
+error: aborting due to 2 previous errors
+
diff --git a/tests/ui/pattern_type_mismatch/pattern_alternatives.rs b/tests/ui/pattern_type_mismatch/pattern_alternatives.rs
new file mode 100644
index 00000000000..065ea9fb9b5
--- /dev/null
+++ b/tests/ui/pattern_type_mismatch/pattern_alternatives.rs
@@ -0,0 +1,24 @@
+#![allow(clippy::all)]
+#![warn(clippy::pattern_type_mismatch)]
+
+fn main() {}
+
+fn alternatives() {
+    enum Value<'a> {
+        Unused,
+        A(&'a Option<i32>),
+        B,
+    }
+    let ref_value = &Value::A(&Some(23));
+
+    // not ok
+    if let Value::B | Value::A(_) = ref_value {}
+    if let &Value::B | &Value::A(Some(_)) = ref_value {}
+    if let Value::B | Value::A(Some(_)) = *ref_value {}
+
+    // ok
+    if let &Value::B | &Value::A(_) = ref_value {}
+    if let Value::B | Value::A(_) = *ref_value {}
+    if let &Value::B | &Value::A(&Some(_)) = ref_value {}
+    if let Value::B | Value::A(&Some(_)) = *ref_value {}
+}
diff --git a/tests/ui/pattern_type_mismatch/pattern_alternatives.stderr b/tests/ui/pattern_type_mismatch/pattern_alternatives.stderr
new file mode 100644
index 00000000000..d285c93782c
--- /dev/null
+++ b/tests/ui/pattern_type_mismatch/pattern_alternatives.stderr
@@ -0,0 +1,27 @@
+error: type of pattern does not match the expression type
+  --> $DIR/pattern_alternatives.rs:15:12
+   |
+LL |     if let Value::B | Value::A(_) = ref_value {}
+   |            ^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::pattern-type-mismatch` implied by `-D warnings`
+   = help: use `*` to dereference the match expression or explicitly match against a `&_` pattern and adjust the enclosed variable bindings
+
+error: type of pattern does not match the expression type
+  --> $DIR/pattern_alternatives.rs:16:34
+   |
+LL |     if let &Value::B | &Value::A(Some(_)) = ref_value {}
+   |                                  ^^^^^^^
+   |
+   = help: explicitly match against a `&_` pattern and adjust the enclosed variable bindings
+
+error: type of pattern does not match the expression type
+  --> $DIR/pattern_alternatives.rs:17:32
+   |
+LL |     if let Value::B | Value::A(Some(_)) = *ref_value {}
+   |                                ^^^^^^^
+   |
+   = help: explicitly match against a `&_` pattern and adjust the enclosed variable bindings
+
+error: aborting due to 3 previous errors
+
diff --git a/tests/ui/pattern_type_mismatch/pattern_structs.rs b/tests/ui/pattern_type_mismatch/pattern_structs.rs
new file mode 100644
index 00000000000..417b1c107c5
--- /dev/null
+++ b/tests/ui/pattern_type_mismatch/pattern_structs.rs
@@ -0,0 +1,45 @@
+#![allow(clippy::all)]
+#![warn(clippy::pattern_type_mismatch)]
+
+fn main() {}
+
+fn struct_types() {
+    struct Struct<'a> {
+        ref_inner: &'a Option<i32>,
+    }
+    let ref_value = &Struct { ref_inner: &Some(42) };
+
+    // not ok
+    let Struct { .. } = ref_value;
+    if let &Struct { ref_inner: Some(_) } = ref_value {}
+    if let Struct { ref_inner: Some(_) } = *ref_value {}
+
+    // ok
+    let &Struct { .. } = ref_value;
+    let Struct { .. } = *ref_value;
+    if let &Struct { ref_inner: &Some(_) } = ref_value {}
+    if let Struct { ref_inner: &Some(_) } = *ref_value {}
+}
+
+fn struct_enum_variants() {
+    enum StructEnum<'a> {
+        Empty,
+        Var { inner_ref: &'a Option<i32> },
+    }
+    let ref_value = &StructEnum::Var { inner_ref: &Some(42) };
+
+    // not ok
+    if let StructEnum::Var { .. } = ref_value {}
+    if let StructEnum::Var { inner_ref: Some(_) } = ref_value {}
+    if let &StructEnum::Var { inner_ref: Some(_) } = ref_value {}
+    if let StructEnum::Var { inner_ref: Some(_) } = *ref_value {}
+    if let StructEnum::Empty = ref_value {}
+
+    // ok
+    if let &StructEnum::Var { .. } = ref_value {}
+    if let StructEnum::Var { .. } = *ref_value {}
+    if let &StructEnum::Var { inner_ref: &Some(_) } = ref_value {}
+    if let StructEnum::Var { inner_ref: &Some(_) } = *ref_value {}
+    if let &StructEnum::Empty = ref_value {}
+    if let StructEnum::Empty = *ref_value {}
+}
diff --git a/tests/ui/pattern_type_mismatch/pattern_structs.stderr b/tests/ui/pattern_type_mismatch/pattern_structs.stderr
new file mode 100644
index 00000000000..d428e85b0c9
--- /dev/null
+++ b/tests/ui/pattern_type_mismatch/pattern_structs.stderr
@@ -0,0 +1,67 @@
+error: type of pattern does not match the expression type
+  --> $DIR/pattern_structs.rs:13:9
+   |
+LL |     let Struct { .. } = ref_value;
+   |         ^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::pattern-type-mismatch` implied by `-D warnings`
+   = help: use `*` to dereference the match expression or explicitly match against a `&_` pattern and adjust the enclosed variable bindings
+
+error: type of pattern does not match the expression type
+  --> $DIR/pattern_structs.rs:14:33
+   |
+LL |     if let &Struct { ref_inner: Some(_) } = ref_value {}
+   |                                 ^^^^^^^
+   |
+   = help: explicitly match against a `&_` pattern and adjust the enclosed variable bindings
+
+error: type of pattern does not match the expression type
+  --> $DIR/pattern_structs.rs:15:32
+   |
+LL |     if let Struct { ref_inner: Some(_) } = *ref_value {}
+   |                                ^^^^^^^
+   |
+   = help: explicitly match against a `&_` pattern and adjust the enclosed variable bindings
+
+error: type of pattern does not match the expression type
+  --> $DIR/pattern_structs.rs:32:12
+   |
+LL |     if let StructEnum::Var { .. } = ref_value {}
+   |            ^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use `*` to dereference the match expression or explicitly match against a `&_` pattern and adjust the enclosed variable bindings
+
+error: type of pattern does not match the expression type
+  --> $DIR/pattern_structs.rs:33:12
+   |
+LL |     if let StructEnum::Var { inner_ref: Some(_) } = ref_value {}
+   |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use `*` to dereference the match expression or explicitly match against a `&_` pattern and adjust the enclosed variable bindings
+
+error: type of pattern does not match the expression type
+  --> $DIR/pattern_structs.rs:34:42
+   |
+LL |     if let &StructEnum::Var { inner_ref: Some(_) } = ref_value {}
+   |                                          ^^^^^^^
+   |
+   = help: explicitly match against a `&_` pattern and adjust the enclosed variable bindings
+
+error: type of pattern does not match the expression type
+  --> $DIR/pattern_structs.rs:35:41
+   |
+LL |     if let StructEnum::Var { inner_ref: Some(_) } = *ref_value {}
+   |                                         ^^^^^^^
+   |
+   = help: explicitly match against a `&_` pattern and adjust the enclosed variable bindings
+
+error: type of pattern does not match the expression type
+  --> $DIR/pattern_structs.rs:36:12
+   |
+LL |     if let StructEnum::Empty = ref_value {}
+   |            ^^^^^^^^^^^^^^^^^
+   |
+   = help: use `*` to dereference the match expression or explicitly match against a `&_` pattern and adjust the enclosed variable bindings
+
+error: aborting due to 8 previous errors
+
diff --git a/tests/ui/pattern_type_mismatch/pattern_tuples.rs b/tests/ui/pattern_type_mismatch/pattern_tuples.rs
new file mode 100644
index 00000000000..19504a051d8
--- /dev/null
+++ b/tests/ui/pattern_type_mismatch/pattern_tuples.rs
@@ -0,0 +1,57 @@
+#![allow(clippy::all)]
+#![warn(clippy::pattern_type_mismatch)]
+
+fn main() {}
+
+fn tuple_types() {
+    struct TupleStruct<'a>(&'a Option<i32>);
+    let ref_value = &TupleStruct(&Some(42));
+
+    // not ok
+    let TupleStruct(_) = ref_value;
+    if let &TupleStruct(Some(_)) = ref_value {}
+    if let TupleStruct(Some(_)) = *ref_value {}
+
+    // ok
+    let &TupleStruct(_) = ref_value;
+    let TupleStruct(_) = *ref_value;
+    if let &TupleStruct(&Some(_)) = ref_value {}
+    if let TupleStruct(&Some(_)) = *ref_value {}
+}
+
+fn tuple_enum_variants() {
+    enum TupleEnum<'a> {
+        Empty,
+        Var(&'a Option<i32>),
+    }
+    let ref_value = &TupleEnum::Var(&Some(42));
+
+    // not ok
+    if let TupleEnum::Var(_) = ref_value {}
+    if let &TupleEnum::Var(Some(_)) = ref_value {}
+    if let TupleEnum::Var(Some(_)) = *ref_value {}
+    if let TupleEnum::Empty = ref_value {}
+
+    // ok
+    if let &TupleEnum::Var(_) = ref_value {}
+    if let TupleEnum::Var(_) = *ref_value {}
+    if let &TupleEnum::Var(&Some(_)) = ref_value {}
+    if let TupleEnum::Var(&Some(_)) = *ref_value {}
+    if let &TupleEnum::Empty = ref_value {}
+    if let TupleEnum::Empty = *ref_value {}
+}
+
+fn plain_tuples() {
+    let ref_value = &(&Some(23), &Some(42));
+
+    // not ok
+    let (_a, _b) = ref_value;
+    if let &(_a, Some(_)) = ref_value {}
+    if let (_a, Some(_)) = *ref_value {}
+
+    // ok
+    let &(_a, _b) = ref_value;
+    let (_a, _b) = *ref_value;
+    if let &(_a, &Some(_)) = ref_value {}
+    if let (_a, &Some(_)) = *ref_value {}
+}
diff --git a/tests/ui/pattern_type_mismatch/pattern_tuples.stderr b/tests/ui/pattern_type_mismatch/pattern_tuples.stderr
new file mode 100644
index 00000000000..edd0074d00d
--- /dev/null
+++ b/tests/ui/pattern_type_mismatch/pattern_tuples.stderr
@@ -0,0 +1,83 @@
+error: type of pattern does not match the expression type
+  --> $DIR/pattern_tuples.rs:11:9
+   |
+LL |     let TupleStruct(_) = ref_value;
+   |         ^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::pattern-type-mismatch` implied by `-D warnings`
+   = help: use `*` to dereference the match expression or explicitly match against a `&_` pattern and adjust the enclosed variable bindings
+
+error: type of pattern does not match the expression type
+  --> $DIR/pattern_tuples.rs:12:25
+   |
+LL |     if let &TupleStruct(Some(_)) = ref_value {}
+   |                         ^^^^^^^
+   |
+   = help: explicitly match against a `&_` pattern and adjust the enclosed variable bindings
+
+error: type of pattern does not match the expression type
+  --> $DIR/pattern_tuples.rs:13:24
+   |
+LL |     if let TupleStruct(Some(_)) = *ref_value {}
+   |                        ^^^^^^^
+   |
+   = help: explicitly match against a `&_` pattern and adjust the enclosed variable bindings
+
+error: type of pattern does not match the expression type
+  --> $DIR/pattern_tuples.rs:30:12
+   |
+LL |     if let TupleEnum::Var(_) = ref_value {}
+   |            ^^^^^^^^^^^^^^^^^
+   |
+   = help: use `*` to dereference the match expression or explicitly match against a `&_` pattern and adjust the enclosed variable bindings
+
+error: type of pattern does not match the expression type
+  --> $DIR/pattern_tuples.rs:31:28
+   |
+LL |     if let &TupleEnum::Var(Some(_)) = ref_value {}
+   |                            ^^^^^^^
+   |
+   = help: explicitly match against a `&_` pattern and adjust the enclosed variable bindings
+
+error: type of pattern does not match the expression type
+  --> $DIR/pattern_tuples.rs:32:27
+   |
+LL |     if let TupleEnum::Var(Some(_)) = *ref_value {}
+   |                           ^^^^^^^
+   |
+   = help: explicitly match against a `&_` pattern and adjust the enclosed variable bindings
+
+error: type of pattern does not match the expression type
+  --> $DIR/pattern_tuples.rs:33:12
+   |
+LL |     if let TupleEnum::Empty = ref_value {}
+   |            ^^^^^^^^^^^^^^^^
+   |
+   = help: use `*` to dereference the match expression or explicitly match against a `&_` pattern and adjust the enclosed variable bindings
+
+error: type of pattern does not match the expression type
+  --> $DIR/pattern_tuples.rs:48:9
+   |
+LL |     let (_a, _b) = ref_value;
+   |         ^^^^^^^^
+   |
+   = help: use `*` to dereference the match expression or explicitly match against a `&_` pattern and adjust the enclosed variable bindings
+
+error: type of pattern does not match the expression type
+  --> $DIR/pattern_tuples.rs:49:18
+   |
+LL |     if let &(_a, Some(_)) = ref_value {}
+   |                  ^^^^^^^
+   |
+   = help: explicitly match against a `&_` pattern and adjust the enclosed variable bindings
+
+error: type of pattern does not match the expression type
+  --> $DIR/pattern_tuples.rs:50:17
+   |
+LL |     if let (_a, Some(_)) = *ref_value {}
+   |                 ^^^^^^^
+   |
+   = help: explicitly match against a `&_` pattern and adjust the enclosed variable bindings
+
+error: aborting due to 10 previous errors
+
diff --git a/tests/ui/pattern_type_mismatch/syntax.rs b/tests/ui/pattern_type_mismatch/syntax.rs
new file mode 100644
index 00000000000..e89917c41e8
--- /dev/null
+++ b/tests/ui/pattern_type_mismatch/syntax.rs
@@ -0,0 +1,146 @@
+#![allow(clippy::all)]
+#![warn(clippy::pattern_type_mismatch)]
+
+fn main() {}
+
+fn syntax_match() {
+    let ref_value = &Some(&Some(42));
+
+    // not ok
+    match ref_value {
+        Some(_) => (),
+        None => (),
+    }
+
+    // ok
+    match ref_value {
+        &Some(_) => (),
+        &None => (),
+    }
+    match *ref_value {
+        Some(_) => (),
+        None => (),
+    }
+}
+
+fn syntax_if_let() {
+    let ref_value = &Some(42);
+
+    // not ok
+    if let Some(_) = ref_value {}
+
+    // ok
+    if let &Some(_) = ref_value {}
+    if let Some(_) = *ref_value {}
+}
+
+fn syntax_while_let() {
+    let ref_value = &Some(42);
+
+    // not ok
+    while let Some(_) = ref_value {
+        break;
+    }
+
+    // ok
+    while let &Some(_) = ref_value {
+        break;
+    }
+    while let Some(_) = *ref_value {
+        break;
+    }
+}
+
+fn syntax_for() {
+    let ref_value = &Some(23);
+    let slice = &[(2, 3), (4, 2)];
+
+    // not ok
+    for (_a, _b) in slice.iter() {}
+
+    // ok
+    for &(_a, _b) in slice.iter() {}
+}
+
+fn syntax_let() {
+    let ref_value = &(2, 3);
+
+    // not ok
+    let (_n, _m) = ref_value;
+
+    // ok
+    let &(_n, _m) = ref_value;
+    let (_n, _m) = *ref_value;
+}
+
+fn syntax_fn() {
+    // not ok
+    fn foo((_a, _b): &(i32, i32)) {}
+
+    // ok
+    fn foo_ok_1(&(_a, _b): &(i32, i32)) {}
+}
+
+fn syntax_closure() {
+    fn foo<F>(f: F)
+    where
+        F: FnOnce(&(i32, i32)),
+    {
+    }
+
+    // not ok
+    foo(|(_a, _b)| ());
+
+    // ok
+    foo(|&(_a, _b)| ());
+}
+
+fn macro_with_expression() {
+    macro_rules! matching_macro {
+        ($e:expr) => {
+            $e
+        };
+    }
+    let value = &Some(23);
+
+    // not ok
+    matching_macro!(match value {
+        Some(_) => (),
+        _ => (),
+    });
+
+    // ok
+    matching_macro!(match value {
+        &Some(_) => (),
+        _ => (),
+    });
+    matching_macro!(match *value {
+        Some(_) => (),
+        _ => (),
+    });
+}
+
+fn macro_expansion() {
+    macro_rules! matching_macro {
+        ($e:expr) => {
+            // not ok
+            match $e {
+                Some(_) => (),
+                _ => (),
+            }
+
+            // ok
+            match $e {
+                &Some(_) => (),
+                _ => (),
+            }
+            match *$e {
+                Some(_) => (),
+                _ => (),
+            }
+        };
+    }
+
+    let value = &Some(23);
+    matching_macro!(value);
+}
diff --git a/tests/ui/pattern_type_mismatch/syntax.stderr b/tests/ui/pattern_type_mismatch/syntax.stderr
new file mode 100644
index 00000000000..110e8421a5e
--- /dev/null
+++ b/tests/ui/pattern_type_mismatch/syntax.stderr
@@ -0,0 +1,78 @@
+error: type of pattern does not match the expression type
+  --> $DIR/syntax.rs:11:9
+   |
+LL |         Some(_) => (),
+   |         ^^^^^^^
+   |
+   = note: `-D clippy::pattern-type-mismatch` implied by `-D warnings`
+   = help: use `*` to dereference the match expression or explicitly match against a `&_` pattern and adjust the enclosed variable bindings
+
+error: type of pattern does not match the expression type
+  --> $DIR/syntax.rs:30:12
+   |
+LL |     if let Some(_) = ref_value {}
+   |            ^^^^^^^
+   |
+   = help: use `*` to dereference the match expression or explicitly match against a `&_` pattern and adjust the enclosed variable bindings
+
+error: type of pattern does not match the expression type
+  --> $DIR/syntax.rs:41:15
+   |
+LL |     while let Some(_) = ref_value {
+   |               ^^^^^^^
+   |
+   = help: use `*` to dereference the match expression or explicitly match against a `&_` pattern and adjust the enclosed variable bindings
+
+error: type of pattern does not match the expression type
+  --> $DIR/syntax.rs:59:9
+   |
+LL |     for (_a, _b) in slice.iter() {}
+   |         ^^^^^^^^
+   |
+   = help: explicitly match against a `&_` pattern and adjust the enclosed variable bindings
+
+error: type of pattern does not match the expression type
+  --> $DIR/syntax.rs:69:9
+   |
+LL |     let (_n, _m) = ref_value;
+   |         ^^^^^^^^
+   |
+   = help: use `*` to dereference the match expression or explicitly match against a `&_` pattern and adjust the enclosed variable bindings
+
+error: type of pattern does not match the expression type
+  --> $DIR/syntax.rs:78:12
+   |
+LL |     fn foo((_a, _b): &(i32, i32)) {}
+   |            ^^^^^^^^
+   |
+   = help: explicitly match against a `&_` pattern and adjust the enclosed variable bindings
+
+error: type of pattern does not match the expression type
+  --> $DIR/syntax.rs:92:10
+   |
+LL |     foo(|(_a, _b)| ());
+   |          ^^^^^^^^
+   |
+   = help: explicitly match against a `&_` pattern and adjust the enclosed variable bindings
+
+error: type of pattern does not match the expression type
+  --> $DIR/syntax.rs:108:9
+   |
+LL |         Some(_) => (),
+   |         ^^^^^^^
+   |
+   = help: use `*` to dereference the match expression or explicitly match against a `&_` pattern and adjust the enclosed variable bindings
+
+error: type of pattern does not match the expression type
+  --> $DIR/syntax.rs:128:17
+   |
+LL |                 Some(_) => (),
+   |                 ^^^^^^^
+...
+LL |     matching_macro!(value);
+   |     ----------------------- in this macro invocation
+   |
+   = help: use `*` to dereference the match expression or explicitly match against a `&_` pattern and adjust the enclosed variable bindings
+
+error: aborting due to 9 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 55877d7b4a6a2c713412db7b30ef79b2a252956e Mon Sep 17 00:00:00 2001
From: Robert Sedlacek <rs@474.at>
Date: Sun, 9 Feb 2020 17:57:35 +0100
Subject: span_help_and_lint -> span_lint_and_help

---
 clippy_lints/src/pattern_type_mismatch.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/pattern_type_mismatch.rs b/clippy_lints/src/pattern_type_mismatch.rs
index a07279c92b0..d3f65db1916 100644
--- a/clippy_lints/src/pattern_type_mismatch.rs
+++ b/clippy_lints/src/pattern_type_mismatch.rs
@@ -1,4 +1,4 @@
-use crate::utils::{last_path_segment, span_help_and_lint};
+use crate::utils::{last_path_segment, span_lint_and_help};
 use rustc::lint::in_external_macro;
 use rustc::ty::subst::SubstsRef;
 use rustc::ty::{AdtDef, FieldDef, Ty, TyKind, VariantDef};
@@ -115,7 +115,7 @@ fn apply_lint<'a, 'tcx>(
 ) -> bool {
     let maybe_mismatch = find_first_mismatch(cx, pat, expr_ty, Level::Top);
     if let Some((span, mutability, level)) = maybe_mismatch {
-        span_help_and_lint(
+        span_lint_and_help(
             cx,
             PATTERN_TYPE_MISMATCH,
             span,
-- 
cgit 1.4.1-3-g733a5


From 6447507ab150ebd1787ca6af385db49dfdf45978 Mon Sep 17 00:00:00 2001
From: flip1995 <hello@philkrones.com>
Date: Mon, 8 Jun 2020 15:10:57 +0200
Subject: Fix rebase fallout

---
 clippy_lints/src/lib.rs                   | 2 +-
 clippy_lints/src/pattern_type_mismatch.rs | 7 ++++---
 2 files changed, 5 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 4890349999f..3d8ce10aef3 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -268,7 +268,7 @@ mod overflow_check_conditional;
 mod panic_unimplemented;
 mod partialeq_ne_impl;
 mod path_buf_push_overwrite;
-pub mod pattern_type_mismatch;
+mod pattern_type_mismatch;
 mod precedence;
 mod ptr;
 mod ptr_offset_with_cast;
diff --git a/clippy_lints/src/pattern_type_mismatch.rs b/clippy_lints/src/pattern_type_mismatch.rs
index d3f65db1916..a6079a8b5bc 100644
--- a/clippy_lints/src/pattern_type_mismatch.rs
+++ b/clippy_lints/src/pattern_type_mismatch.rs
@@ -1,12 +1,12 @@
 use crate::utils::{last_path_segment, span_lint_and_help};
-use rustc::lint::in_external_macro;
-use rustc::ty::subst::SubstsRef;
-use rustc::ty::{AdtDef, FieldDef, Ty, TyKind, VariantDef};
 use rustc_hir::{
     intravisit, Body, Expr, ExprKind, FieldPat, FnDecl, HirId, LocalSource, MatchSource, Mutability, Pat, PatKind,
     QPath, Stmt, StmtKind,
 };
 use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_middle::lint::in_external_macro;
+use rustc_middle::ty::subst::SubstsRef;
+use rustc_middle::ty::{AdtDef, FieldDef, Ty, TyKind, VariantDef};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
 
@@ -120,6 +120,7 @@ fn apply_lint<'a, 'tcx>(
             PATTERN_TYPE_MISMATCH,
             span,
             "type of pattern does not match the expression type",
+            None,
             &format!(
                 "{}explicitly match against a `{}` pattern and adjust the enclosed variable bindings",
                 match (deref_possible, level) {
-- 
cgit 1.4.1-3-g733a5


From 92ecc53691f3edd67526dca423a2b4083d12a221 Mon Sep 17 00:00:00 2001
From: Robert Sedlacek <rs@474.at>
Date: Wed, 1 Jul 2020 15:49:06 +0200
Subject: Catching up with rustc changes

---
 clippy_lints/src/pattern_type_mismatch.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/pattern_type_mismatch.rs b/clippy_lints/src/pattern_type_mismatch.rs
index a6079a8b5bc..fcc9b16068f 100644
--- a/clippy_lints/src/pattern_type_mismatch.rs
+++ b/clippy_lints/src/pattern_type_mismatch.rs
@@ -48,7 +48,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for PatternTypeMismatch {
     fn check_stmt(&mut self, cx: &LateContext<'a, 'tcx>, stmt: &'tcx Stmt<'_>) {
         if let StmtKind::Local(ref local) = stmt.kind {
             if let Some(init) = &local.init {
-                if let Some(init_ty) = cx.tables.node_type_opt(init.hir_id) {
+                if let Some(init_ty) = cx.tables().node_type_opt(init.hir_id) {
                     let pat = &local.pat;
                     if in_external_macro(cx.sess(), pat.span) {
                         return;
@@ -67,7 +67,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for PatternTypeMismatch {
         if let ExprKind::Match(ref expr, arms, source) = expr.kind {
             match source {
                 MatchSource::Normal | MatchSource::IfLetDesugar { .. } | MatchSource::WhileLetDesugar => {
-                    if let Some(expr_ty) = cx.tables.node_type_opt(expr.hir_id) {
+                    if let Some(expr_ty) = cx.tables().node_type_opt(expr.hir_id) {
                         'pattern_checks: for arm in arms {
                             let pat = &arm.pat;
                             if in_external_macro(cx.sess(), pat.span) {
@@ -93,7 +93,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for PatternTypeMismatch {
         _: Span,
         hir_id: HirId,
     ) {
-        if let Some(fn_sig) = cx.tables.liberated_fn_sigs().get(hir_id) {
+        if let Some(fn_sig) = cx.tables().liberated_fn_sigs().get(hir_id) {
             for (param, ty) in body.params.iter().zip(fn_sig.inputs().iter()) {
                 apply_lint(cx, &param.pat, ty, DerefPossible::Impossible);
             }
-- 
cgit 1.4.1-3-g733a5


From d617551a6a3830a5324898f2046b97aad8c6067a Mon Sep 17 00:00:00 2001
From: Robert Sedlacek <rs@474.at>
Date: Wed, 1 Jul 2020 15:49:46 +0200
Subject: Expanded lint documentation

---
 clippy_lints/src/pattern_type_mismatch.rs | 39 +++++++++++++++++++++++++++++++
 1 file changed, 39 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/pattern_type_mismatch.rs b/clippy_lints/src/pattern_type_mismatch.rs
index fcc9b16068f..9fa5860ba30 100644
--- a/clippy_lints/src/pattern_type_mismatch.rs
+++ b/clippy_lints/src/pattern_type_mismatch.rs
@@ -14,6 +14,22 @@ declare_clippy_lint! {
     /// **What it does:** Checks for patterns that aren't exact representations of the types
     /// they are applied to.
     ///
+    /// To satisfy this lint, you will have to adjust either the expression that is matched
+    /// against or the pattern itself, as well as the bindings that are introduced by the
+    /// adjusted patterns. For matching you will have to either dereference the expression
+    /// with the `*` operator, or amend the patterns to explicitly match against `&<pattern>`
+    /// or `&mut <pattern>` depending on the reference mutability. For the bindings you need
+    /// to use the inverse. You can leave them as plain bindings if you wish for the value
+    /// to be copied, but you must use `ref mut <variable>` or `ref <variable>` to construct
+    /// a reference into the matched structure.
+    ///
+    /// If you are looking for a way to learn about ownership semantics in more detail, it
+    /// is recommended to look at IDE options available to you to highlight types, lifetimes
+    /// and reference semantics in your code. The available tooling would expose these things
+    /// in a general way even outside of the various pattern matching mechanics. Of course
+    /// this lint can still be used to highlight areas of interest and ensure a good understanding
+    /// of ownership semantics.
+    ///
     /// **Why is this bad?** It isn't bad in general. But in some contexts it can be desirable
     /// because it increases ownership hints in the code, and will guard against some changes
     /// in ownership.
@@ -22,6 +38,10 @@ declare_clippy_lint! {
     ///
     /// **Example:**
     ///
+    /// This example shows the basic adjustments necessary to satisfy the lint. Note how
+    /// the matched expression is explicitly dereferenced with `*` and the `inner` variable
+    /// is bound to a shared borrow via `ref inner`.
+    ///
     /// ```rust,ignore
     /// // Bad
     /// let value = &Some(Box::new(23));
@@ -37,6 +57,25 @@ declare_clippy_lint! {
     ///     None => println!("none"),
     /// }
     /// ```
+    ///
+    /// The following example demonstrates one of the advantages of the more verbose style.
+    /// Note how the second version uses `ref mut a` to explicitly declare `a` a shared mutable
+    /// borrow, while `b` is simply taken by value. This ensures that the loop body cannot
+    /// accidentally modify the wrong part of the structure.
+    ///
+    /// ```rust,ignore
+    /// // Bad
+    /// let mut values = vec![(2, 3), (3, 4)];
+    /// for (a, b) in &mut values {
+    ///     *a += *b;
+    /// }
+    ///
+    /// // Good
+    /// let mut values = vec![(2, 3), (3, 4)];
+    /// for &mut (ref mut a, b) in &mut values {
+    ///     *a += b;
+    /// }
+    /// ```
     pub PATTERN_TYPE_MISMATCH,
     restriction,
     "type of pattern does not match the expression type"
-- 
cgit 1.4.1-3-g733a5


From aa4bee228f23b3e1a1d91ed3a4606af3c6b60895 Mon Sep 17 00:00:00 2001
From: Robert Sedlacek <rs@474.at>
Date: Fri, 3 Jul 2020 18:20:19 +0200
Subject: LateContext has only one lifetime parameter now

---
 clippy_lints/src/pattern_type_mismatch.rs | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/pattern_type_mismatch.rs b/clippy_lints/src/pattern_type_mismatch.rs
index 9fa5860ba30..8587a79e821 100644
--- a/clippy_lints/src/pattern_type_mismatch.rs
+++ b/clippy_lints/src/pattern_type_mismatch.rs
@@ -83,8 +83,8 @@ declare_clippy_lint! {
 
 declare_lint_pass!(PatternTypeMismatch => [PATTERN_TYPE_MISMATCH]);
 
-impl<'a, 'tcx> LateLintPass<'a, 'tcx> for PatternTypeMismatch {
-    fn check_stmt(&mut self, cx: &LateContext<'a, 'tcx>, stmt: &'tcx Stmt<'_>) {
+impl<'tcx> LateLintPass<'tcx> for PatternTypeMismatch {
+    fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) {
         if let StmtKind::Local(ref local) = stmt.kind {
             if let Some(init) = &local.init {
                 if let Some(init_ty) = cx.tables().node_type_opt(init.hir_id) {
@@ -102,7 +102,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for PatternTypeMismatch {
         }
     }
 
-    fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr<'_>) {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if let ExprKind::Match(ref expr, arms, source) = expr.kind {
             match source {
                 MatchSource::Normal | MatchSource::IfLetDesugar { .. } | MatchSource::WhileLetDesugar => {
@@ -125,7 +125,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for PatternTypeMismatch {
 
     fn check_fn(
         &mut self,
-        cx: &LateContext<'a, 'tcx>,
+        cx: &LateContext<'tcx>,
         _: intravisit::FnKind<'tcx>,
         _: &'tcx FnDecl<'_>,
         body: &'tcx Body<'_>,
@@ -146,8 +146,8 @@ enum DerefPossible {
     Impossible,
 }
 
-fn apply_lint<'a, 'tcx>(
-    cx: &LateContext<'a, 'tcx>,
+fn apply_lint<'tcx>(
+    cx: &LateContext<'tcx>,
     pat: &Pat<'_>,
     expr_ty: Ty<'tcx>,
     deref_possible: DerefPossible,
@@ -185,8 +185,8 @@ enum Level {
 }
 
 #[allow(rustc::usage_of_ty_tykind)]
-fn find_first_mismatch<'a, 'tcx>(
-    cx: &LateContext<'a, 'tcx>,
+fn find_first_mismatch<'tcx>(
+    cx: &LateContext<'tcx>,
     pat: &Pat<'_>,
     ty: Ty<'tcx>,
     level: Level,
@@ -259,8 +259,8 @@ fn get_variant<'a>(adt_def: &'a AdtDef, qpath: &QPath<'_>) -> Option<&'a Variant
     None
 }
 
-fn find_first_mismatch_in_tuple<'a, 'tcx, I>(
-    cx: &LateContext<'a, 'tcx>,
+fn find_first_mismatch_in_tuple<'tcx, I>(
+    cx: &LateContext<'tcx>,
     pats: &[&Pat<'_>],
     ty_iter_src: I,
 ) -> Option<(Span, Mutability, Level)>
@@ -284,8 +284,8 @@ where
     None
 }
 
-fn find_first_mismatch_in_struct<'a, 'tcx>(
-    cx: &LateContext<'a, 'tcx>,
+fn find_first_mismatch_in_struct<'tcx>(
+    cx: &LateContext<'tcx>,
     field_pats: &[FieldPat<'_>],
     field_defs: &[FieldDef],
     substs_ref: SubstsRef<'tcx>,
-- 
cgit 1.4.1-3-g733a5


From c0fd452840c7cc53b3396268f62ed2a0a2e8fef7 Mon Sep 17 00:00:00 2001
From: Robert Sedlacek <rs@474.at>
Date: Fri, 3 Jul 2020 18:23:36 +0200
Subject: fmt fix

---
 clippy_lints/src/pattern_type_mismatch.rs | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/pattern_type_mismatch.rs b/clippy_lints/src/pattern_type_mismatch.rs
index 8587a79e821..a49dc87c0b4 100644
--- a/clippy_lints/src/pattern_type_mismatch.rs
+++ b/clippy_lints/src/pattern_type_mismatch.rs
@@ -146,12 +146,7 @@ enum DerefPossible {
     Impossible,
 }
 
-fn apply_lint<'tcx>(
-    cx: &LateContext<'tcx>,
-    pat: &Pat<'_>,
-    expr_ty: Ty<'tcx>,
-    deref_possible: DerefPossible,
-) -> bool {
+fn apply_lint<'tcx>(cx: &LateContext<'tcx>, pat: &Pat<'_>, expr_ty: Ty<'tcx>, deref_possible: DerefPossible) -> bool {
     let maybe_mismatch = find_first_mismatch(cx, pat, expr_ty, Level::Top);
     if let Some((span, mutability, level)) = maybe_mismatch {
         span_lint_and_help(
-- 
cgit 1.4.1-3-g733a5


From bf48a2d50d82cccac58d7c4c73700eaf66926aee Mon Sep 17 00:00:00 2001
From: JarredAllen <jarredallen73@gmail.com>
Date: Thu, 5 Mar 2020 10:35:05 -0800
Subject: Lint for if let Some(x) = ... instead of Option::map_or

---
 CHANGELOG.md                           |   1 +
 clippy_lints/src/lib.rs                |   5 +
 clippy_lints/src/option_if_let_else.rs | 202 +++++++++++++++++++++++++++++++++
 src/lintlist/mod.rs                    |   7 ++
 tests/ui/option_if_let_else.fixed      |  48 ++++++++
 tests/ui/option_if_let_else.rs         |  56 +++++++++
 tests/ui/option_if_let_else.stderr     |  62 ++++++++++
 7 files changed, 381 insertions(+)
 create mode 100644 clippy_lints/src/option_if_let_else.rs
 create mode 100644 tests/ui/option_if_let_else.fixed
 create mode 100644 tests/ui/option_if_let_else.rs
 create mode 100644 tests/ui/option_if_let_else.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index ed8f16e65bb..1a081bb85fe 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1577,6 +1577,7 @@ Released 2018-09-13
 [`op_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#op_ref
 [`option_as_ref_deref`]: https://rust-lang.github.io/rust-clippy/master/index.html#option_as_ref_deref
 [`option_env_unwrap`]: https://rust-lang.github.io/rust-clippy/master/index.html#option_env_unwrap
+[`option_if_let_else`]: https://rust-lang.github.io/rust-clippy/master/index.html#option_if_let_else
 [`option_map_or_none`]: https://rust-lang.github.io/rust-clippy/master/index.html#option_map_or_none
 [`option_map_unit_fn`]: https://rust-lang.github.io/rust-clippy/master/index.html#option_map_unit_fn
 [`option_option`]: https://rust-lang.github.io/rust-clippy/master/index.html#option_option
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 1d5be893ffb..cd91e7ceb32 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -264,6 +264,7 @@ mod non_copy_const;
 mod non_expressive_names;
 mod open_options;
 mod option_env_unwrap;
+mod option_if_let_else;
 mod overflow_check_conditional;
 mod panic_unimplemented;
 mod partialeq_ne_impl;
@@ -734,6 +735,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &non_expressive_names::SIMILAR_NAMES,
         &open_options::NONSENSICAL_OPEN_OPTIONS,
         &option_env_unwrap::OPTION_ENV_UNWRAP,
+        &option_if_let_else::OPTION_IF_LET_ELSE,
         &overflow_check_conditional::OVERFLOW_CHECK_CONDITIONAL,
         &panic_unimplemented::PANIC,
         &panic_unimplemented::PANIC_PARAMS,
@@ -1052,6 +1054,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box redundant_pub_crate::RedundantPubCrate::default());
     store.register_late_pass(|| box unnamed_address::UnnamedAddress);
     store.register_late_pass(|| box dereference::Dereferencing);
+    store.register_late_pass(|| box option_if_let_else::OptionIfLetElse);
     store.register_late_pass(|| box future_not_send::FutureNotSend);
     store.register_late_pass(|| box utils::internal_lints::CollapsibleCalls);
     store.register_late_pass(|| box if_let_mutex::IfLetMutex);
@@ -1369,6 +1372,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&non_expressive_names::MANY_SINGLE_CHAR_NAMES),
         LintId::of(&open_options::NONSENSICAL_OPEN_OPTIONS),
         LintId::of(&option_env_unwrap::OPTION_ENV_UNWRAP),
+        LintId::of(&option_if_let_else::OPTION_IF_LET_ELSE),
         LintId::of(&overflow_check_conditional::OVERFLOW_CHECK_CONDITIONAL),
         LintId::of(&panic_unimplemented::PANIC_PARAMS),
         LintId::of(&partialeq_ne_impl::PARTIALEQ_NE_IMPL),
@@ -1517,6 +1521,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&new_without_default::NEW_WITHOUT_DEFAULT),
         LintId::of(&non_expressive_names::JUST_UNDERSCORES_AND_DIGITS),
         LintId::of(&non_expressive_names::MANY_SINGLE_CHAR_NAMES),
+        LintId::of(&option_if_let_else::OPTION_IF_LET_ELSE),
         LintId::of(&panic_unimplemented::PANIC_PARAMS),
         LintId::of(&ptr::CMP_NULL),
         LintId::of(&ptr::PTR_ARG),
diff --git a/clippy_lints/src/option_if_let_else.rs b/clippy_lints/src/option_if_let_else.rs
new file mode 100644
index 00000000000..f092f1297c1
--- /dev/null
+++ b/clippy_lints/src/option_if_let_else.rs
@@ -0,0 +1,202 @@
+use crate::utils::sugg::Sugg;
+use crate::utils::{match_type, paths, span_lint_and_sugg};
+use if_chain::if_chain;
+
+use rustc_errors::Applicability;
+use rustc_hir::intravisit::{NestedVisitorMap, Visitor};
+use rustc_hir::*;
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::hir::map::Map;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+use std::marker::PhantomData;
+
+declare_clippy_lint! {
+    /// **What it does:**
+    /// Lints usage of  `if let Some(v) = ... { y } else { x }` which is more
+    /// idiomatically done with `Option::map_or` (if the else bit is a simple
+    /// expression) or `Option::map_or_else` (if the else bit is a longer
+    /// block).
+    ///
+    /// **Why is this bad?**
+    /// Using the dedicated functions of the Option type is clearer and
+    /// more concise than an if let expression.
+    ///
+    /// **Known problems:**
+    /// This lint uses whether the block is just an expression or if it has
+    /// more statements to decide whether to use `Option::map_or` or
+    /// `Option::map_or_else`. If you have a single expression which calls
+    /// an expensive function, then it would be more efficient to use
+    /// `Option::map_or_else`, but this lint would suggest `Option::map_or`.
+    ///
+    /// Also, this lint uses a deliberately conservative metric for checking
+    /// if the inside of either body contains breaks or continues which will
+    /// cause it to not suggest a fix if either block contains a loop with
+    /// continues or breaks contained within the loop.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// # let optional: Option<u32> = Some(0);
+    /// let _ = if let Some(foo) = optional {
+    ///     foo
+    /// } else {
+    ///     5
+    /// };
+    /// let _ = if let Some(foo) = optional {
+    ///     foo
+    /// } else {
+    ///     let y = do_complicated_function();
+    ///     y*y
+    /// };
+    /// ```
+    ///
+    /// should be
+    ///
+    /// ```rust
+    /// # let optional: Option<u32> = Some(0);
+    /// let _ = optional.map_or(5, |foo| foo);
+    /// let _ = optional.map_or_else(||{
+    ///     let y = do_complicated_function;
+    ///     y*y
+    /// }, |foo| foo);
+    /// ```
+    pub OPTION_IF_LET_ELSE,
+    style,
+    "reimplementation of Option::map_or"
+}
+
+declare_lint_pass!(OptionIfLetElse => [OPTION_IF_LET_ELSE]);
+
+/// Returns true iff the given expression is the result of calling Result::ok
+fn is_result_ok(cx: &LateContext<'_, '_>, expr: &'_ Expr<'_>) -> bool {
+    if_chain! {
+        if let ExprKind::MethodCall(ref path, _, &[ref receiver]) = &expr.kind;
+        if path.ident.name.to_ident_string() == "ok";
+        if match_type(cx, &cx.tables.expr_ty(&receiver), &paths::RESULT);
+        then {
+            true
+        } else {
+            false
+        }
+    }
+}
+
+/// A struct containing information about occurences of the
+/// `if let Some(..) = .. else` construct that this lint detects.
+struct OptionIfLetElseOccurence {
+    option: String,
+    method_sugg: String,
+    some_expr: String,
+    none_expr: String,
+}
+
+struct ReturnBreakContinueVisitor<'tcx> {
+    seen_return_break_continue: bool,
+    phantom_data: PhantomData<&'tcx bool>,
+}
+impl<'tcx> ReturnBreakContinueVisitor<'tcx> {
+    fn new() -> ReturnBreakContinueVisitor<'tcx> {
+        ReturnBreakContinueVisitor {
+            seen_return_break_continue: false,
+            phantom_data: PhantomData,
+        }
+    }
+}
+impl<'tcx> Visitor<'tcx> for ReturnBreakContinueVisitor<'tcx> {
+    type Map = Map<'tcx>;
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::None
+    }
+
+    fn visit_expr(&mut self, ex: &'tcx Expr<'tcx>) {
+        if self.seen_return_break_continue {
+            // No need to look farther if we've already seen one of them
+            return;
+        }
+        match &ex.kind {
+            ExprKind::Ret(..) | ExprKind::Break(..) | ExprKind::Continue(..) => {
+                self.seen_return_break_continue = true;
+            },
+            // Something special could be done here to handle while or for loop
+            // desugaring, as this will detect a break if there's a while loop
+            // or a for loop inside the expression.
+            _ => {
+                rustc_hir::intravisit::walk_expr(self, ex);
+            },
+        }
+    }
+}
+
+fn contains_return_break_continue<'tcx>(expression: &'tcx Expr<'tcx>) -> bool {
+    let mut recursive_visitor: ReturnBreakContinueVisitor<'tcx> = ReturnBreakContinueVisitor::new();
+    recursive_visitor.visit_expr(expression);
+    recursive_visitor.seen_return_break_continue
+}
+
+/// If this expression is the option if let/else construct we're detecting, then
+/// this function returns an OptionIfLetElseOccurence struct with details if
+/// this construct is found, or None if this construct is not found.
+fn detect_option_if_let_else<'a>(cx: &LateContext<'_, 'a>, expr: &'a Expr<'a>) -> Option<OptionIfLetElseOccurence> {
+    //(String, String, String, String)> {
+    if_chain! {
+        if let ExprKind::Match(let_body, arms, MatchSource::IfLetDesugar{contains_else_clause: true}) = &expr.kind;
+        if arms.len() == 2;
+        if match_type(cx, &cx.tables.expr_ty(let_body), &paths::OPTION);
+        if !is_result_ok(cx, let_body); // Don't lint on Result::ok because a different lint does it already
+        if let PatKind::TupleStruct(_, &[inner_pat], _) = &arms[0].pat.kind;
+        if let PatKind::Binding(_, _, id, _) = &inner_pat.kind;
+        if !contains_return_break_continue(arms[0].body);
+        if !contains_return_break_continue(arms[1].body);
+        then {
+            let some_body = if let ExprKind::Block(Block { stmts: statements, expr: Some(expr), .. }, _)
+                = &arms[0].body.kind {
+                if let &[] = &statements {
+                    expr
+                } else {
+                    &arms[0].body
+                }
+            } else {
+                return None;
+            };
+            let (none_body, method_sugg) = if let ExprKind::Block(Block { stmts: statements, expr: Some(expr), .. }, _)
+                = &arms[1].body.kind {
+                if let &[] = &statements {
+                    (expr, "map_or")
+                } else {
+                    (&arms[1].body, "map_or_else")
+                }
+            } else {
+                return None;
+            };
+            let capture_name = id.name.to_ident_string();
+            Some(OptionIfLetElseOccurence {
+                option: format!("{}", Sugg::hir(cx, let_body, "..")),
+                method_sugg: format!("{}", method_sugg),
+                some_expr: format!("|{}| {}", capture_name, Sugg::hir(cx, some_body, "..")),
+                none_expr: format!("{}{}", if method_sugg == "map_or" { "" } else { "|| " }, Sugg::hir(cx, none_body, ".."))
+            })
+        } else {
+            None
+        }
+    }
+}
+
+impl<'a, 'tcx> LateLintPass<'a, 'tcx> for OptionIfLetElse {
+    fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr<'_>) {
+        if let Some(detection) = detect_option_if_let_else(cx, expr) {
+            span_lint_and_sugg(
+                cx,
+                OPTION_IF_LET_ELSE,
+                expr.span,
+                format!("use Option::{} instead of an if let/else", detection.method_sugg).as_str(),
+                "try",
+                format!(
+                    "{}.{}({}, {})",
+                    detection.option, detection.method_sugg, detection.none_expr, detection.some_expr
+                ),
+                Applicability::MachineApplicable,
+            );
+        }
+    }
+}
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index 6402efc2521..b499d565fa7 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -1620,6 +1620,13 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
         deprecation: None,
         module: "option_env_unwrap",
     },
+    Lint {
+        name: "option_if_let_else",
+        group: "style",
+        desc: "reimplementation of Option::map_or",
+        deprecation: None,
+        module: "option_if_let_else",
+    },
     Lint {
         name: "option_map_or_none",
         group: "style",
diff --git a/tests/ui/option_if_let_else.fixed b/tests/ui/option_if_let_else.fixed
new file mode 100644
index 00000000000..3aa895120d1
--- /dev/null
+++ b/tests/ui/option_if_let_else.fixed
@@ -0,0 +1,48 @@
+// run-rustfix
+#![warn(clippy::option_if_let_else)]
+
+fn bad1(string: Option<&str>) -> (bool, &str) {
+    string.map_or((false, "hello"), |x| (true, x))
+}
+
+fn longer_body(arg: Option<u32>) -> u32 {
+    arg.map_or(13, |x| {
+        let y = x * x;
+        y * y
+    })
+}
+
+fn test_map_or_else(arg: Option<u32>) {
+    let _ = arg.map_or_else(|| {
+        let mut y = 1;
+        y = (y + 2 / y) / 2;
+        y = (y + 2 / y) / 2;
+        y
+    }, |x| x * x * x * x);
+}
+
+fn negative_tests(arg: Option<u32>) -> u32 {
+    let _ = if let Some(13) = arg { "unlucky" } else { "lucky" };
+    for _ in 0..10 {
+        let _ = if let Some(x) = arg {
+            x
+        } else {
+            continue;
+        };
+    }
+    let _ = if let Some(x) = arg {
+        return x;
+    } else {
+        5
+    };
+    7
+}
+
+fn main() {
+    let optional = Some(5);
+    let _ = optional.map_or(5, |x| x + 2);
+    let _ = bad1(None);
+    let _ = longer_body(None);
+    test_map_or_else(None);
+    let _ = negative_tests(None);
+}
diff --git a/tests/ui/option_if_let_else.rs b/tests/ui/option_if_let_else.rs
new file mode 100644
index 00000000000..7d029b0bcf4
--- /dev/null
+++ b/tests/ui/option_if_let_else.rs
@@ -0,0 +1,56 @@
+// run-rustfix
+#![warn(clippy::option_if_let_else)]
+
+fn bad1(string: Option<&str>) -> (bool, &str) {
+    if let Some(x) = string {
+        (true, x)
+    } else {
+        (false, "hello")
+    }
+}
+
+fn longer_body(arg: Option<u32>) -> u32 {
+    if let Some(x) = arg {
+        let y = x * x;
+        y * y
+    } else {
+        13
+    }
+}
+
+fn test_map_or_else(arg: Option<u32>) {
+    let _ = if let Some(x) = arg {
+        x * x * x * x
+    } else {
+        let mut y = 1;
+        y = (y + 2 / y) / 2;
+        y = (y + 2 / y) / 2;
+        y
+    };
+}
+
+fn negative_tests(arg: Option<u32>) -> u32 {
+    let _ = if let Some(13) = arg { "unlucky" } else { "lucky" };
+    for _ in 0..10 {
+        let _ = if let Some(x) = arg {
+            x
+        } else {
+            continue;
+        };
+    }
+    let _ = if let Some(x) = arg {
+        return x;
+    } else {
+        5
+    };
+    7
+}
+
+fn main() {
+    let optional = Some(5);
+    let _ = if let Some(x) = optional { x + 2 } else { 5 };
+    let _ = bad1(None);
+    let _ = longer_body(None);
+    test_map_or_else(None);
+    let _ = negative_tests(None);
+}
diff --git a/tests/ui/option_if_let_else.stderr b/tests/ui/option_if_let_else.stderr
new file mode 100644
index 00000000000..d6cf0836733
--- /dev/null
+++ b/tests/ui/option_if_let_else.stderr
@@ -0,0 +1,62 @@
+error: use Option::map_or instead of an if let/else
+  --> $DIR/option_if_let_else.rs:5:5
+   |
+LL | /     if let Some(x) = string {
+LL | |         (true, x)
+LL | |     } else {
+LL | |         (false, "hello")
+LL | |     }
+   | |_____^ help: try: `string.map_or((false, "hello"), |x| (true, x))`
+   |
+   = note: `-D clippy::option-if-let-else` implied by `-D warnings`
+
+error: use Option::map_or instead of an if let/else
+  --> $DIR/option_if_let_else.rs:13:5
+   |
+LL | /     if let Some(x) = arg {
+LL | |         let y = x * x;
+LL | |         y * y
+LL | |     } else {
+LL | |         13
+LL | |     }
+   | |_____^
+   |
+help: try
+   |
+LL |     arg.map_or(13, |x| {
+LL |         let y = x * x;
+LL |         y * y
+LL |     })
+   |
+
+error: use Option::map_or_else instead of an if let/else
+  --> $DIR/option_if_let_else.rs:22:13
+   |
+LL |       let _ = if let Some(x) = arg {
+   |  _____________^
+LL | |         x * x * x * x
+LL | |     } else {
+LL | |         let mut y = 1;
+...  |
+LL | |         y
+LL | |     };
+   | |_____^
+   |
+help: try
+   |
+LL |     let _ = arg.map_or_else(|| {
+LL |         let mut y = 1;
+LL |         y = (y + 2 / y) / 2;
+LL |         y = (y + 2 / y) / 2;
+LL |         y
+LL |     }, |x| x * x * x * x);
+   |
+
+error: use Option::map_or instead of an if let/else
+  --> $DIR/option_if_let_else.rs:51:13
+   |
+LL |     let _ = if let Some(x) = optional { x + 2 } else { 5 };
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `optional.map_or(5, |x| x + 2)`
+
+error: aborting due to 4 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 82f8d4d6f1645dd08b107c3ead9155412637739b Mon Sep 17 00:00:00 2001
From: JarredAllen <jarredallen73@gmail.com>
Date: Sat, 25 Apr 2020 08:32:33 -0700
Subject: Stop linting on macros and correctly use braces for  constructs

---
 clippy_lints/src/option_if_let_else.rs | 23 ++++++++++++++++++++---
 tests/ui/option_if_let_else.fixed      |  7 +++++++
 tests/ui/option_if_let_else.rs         | 11 +++++++++++
 tests/ui/option_if_let_else.stderr     | 19 +++++++++++++++----
 4 files changed, 53 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/option_if_let_else.rs b/clippy_lints/src/option_if_let_else.rs
index f092f1297c1..1edec1cad6e 100644
--- a/clippy_lints/src/option_if_let_else.rs
+++ b/clippy_lints/src/option_if_let_else.rs
@@ -1,3 +1,4 @@
+use crate::utils;
 use crate::utils::sugg::Sugg;
 use crate::utils::{match_type, paths, span_lint_and_sugg};
 use if_chain::if_chain;
@@ -89,6 +90,7 @@ struct OptionIfLetElseOccurence {
     method_sugg: String,
     some_expr: String,
     none_expr: String,
+    wrap_braces: bool,
 }
 
 struct ReturnBreakContinueVisitor<'tcx> {
@@ -140,6 +142,7 @@ fn contains_return_break_continue<'tcx>(expression: &'tcx Expr<'tcx>) -> bool {
 fn detect_option_if_let_else<'a>(cx: &LateContext<'_, 'a>, expr: &'a Expr<'a>) -> Option<OptionIfLetElseOccurence> {
     //(String, String, String, String)> {
     if_chain! {
+        // if !utils::in_macro(expr.span); // Don't lint macros, because it behaves weirdly
         if let ExprKind::Match(let_body, arms, MatchSource::IfLetDesugar{contains_else_clause: true}) = &expr.kind;
         if arms.len() == 2;
         if match_type(cx, &cx.tables.expr_ty(let_body), &paths::OPTION);
@@ -170,11 +173,23 @@ fn detect_option_if_let_else<'a>(cx: &LateContext<'_, 'a>, expr: &'a Expr<'a>) -
                 return None;
             };
             let capture_name = id.name.to_ident_string();
+            let wrap_braces = utils::get_enclosing_block(cx, expr.hir_id).map_or(false, |parent| {
+                if_chain! {
+                    if let Some(Expr { kind: ExprKind::Match(condition, arms, MatchSource::IfDesugar{contains_else_clause: true}|MatchSource::IfLetDesugar{contains_else_clause: true}), .. } ) = parent.expr;
+                    if expr.hir_id == arms[1].body.hir_id;
+                    then {
+                        true
+                    } else {
+                        false
+                    }
+                }
+            });
             Some(OptionIfLetElseOccurence {
                 option: format!("{}", Sugg::hir(cx, let_body, "..")),
                 method_sugg: format!("{}", method_sugg),
                 some_expr: format!("|{}| {}", capture_name, Sugg::hir(cx, some_body, "..")),
-                none_expr: format!("{}{}", if method_sugg == "map_or" { "" } else { "|| " }, Sugg::hir(cx, none_body, ".."))
+                none_expr: format!("{}{}", if method_sugg == "map_or" { "" } else { "|| " }, Sugg::hir(cx, none_body, "..")),
+                wrap_braces,
             })
         } else {
             None
@@ -192,8 +207,10 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for OptionIfLetElse {
                 format!("use Option::{} instead of an if let/else", detection.method_sugg).as_str(),
                 "try",
                 format!(
-                    "{}.{}({}, {})",
-                    detection.option, detection.method_sugg, detection.none_expr, detection.some_expr
+                    "{}{}.{}({}, {}){}",
+                    if detection.wrap_braces { "{ " } else { "" },
+                    detection.option, detection.method_sugg, detection.none_expr, detection.some_expr,
+                    if detection.wrap_braces { " }" } else { "" },
                 ),
                 Applicability::MachineApplicable,
             );
diff --git a/tests/ui/option_if_let_else.fixed b/tests/ui/option_if_let_else.fixed
index 3aa895120d1..343e099b2b7 100644
--- a/tests/ui/option_if_let_else.fixed
+++ b/tests/ui/option_if_let_else.fixed
@@ -5,6 +5,12 @@ fn bad1(string: Option<&str>) -> (bool, &str) {
     string.map_or((false, "hello"), |x| (true, x))
 }
 
+fn bad2(string: Option<&str>) -> Option<(bool, &str)> {
+    if string.is_none() {
+        None
+    } else { string.map_or(Some((false, "")), |x| Some((true, x))) }
+}
+
 fn longer_body(arg: Option<u32>) -> u32 {
     arg.map_or(13, |x| {
         let y = x * x;
@@ -42,6 +48,7 @@ fn main() {
     let optional = Some(5);
     let _ = optional.map_or(5, |x| x + 2);
     let _ = bad1(None);
+    let _ = bad2(None);
     let _ = longer_body(None);
     test_map_or_else(None);
     let _ = negative_tests(None);
diff --git a/tests/ui/option_if_let_else.rs b/tests/ui/option_if_let_else.rs
index 7d029b0bcf4..b0c203f0637 100644
--- a/tests/ui/option_if_let_else.rs
+++ b/tests/ui/option_if_let_else.rs
@@ -9,6 +9,16 @@ fn bad1(string: Option<&str>) -> (bool, &str) {
     }
 }
 
+fn bad2(string: Option<&str>) -> Option<(bool, &str)> {
+    if string.is_none() {
+        None
+    } else if let Some(x) = string {
+        Some((true, x))
+    } else {
+        Some((false, ""))
+    }
+}
+
 fn longer_body(arg: Option<u32>) -> u32 {
     if let Some(x) = arg {
         let y = x * x;
@@ -50,6 +60,7 @@ fn main() {
     let optional = Some(5);
     let _ = if let Some(x) = optional { x + 2 } else { 5 };
     let _ = bad1(None);
+    let _ = bad2(None);
     let _ = longer_body(None);
     test_map_or_else(None);
     let _ = negative_tests(None);
diff --git a/tests/ui/option_if_let_else.stderr b/tests/ui/option_if_let_else.stderr
index d6cf0836733..656cfb2f62a 100644
--- a/tests/ui/option_if_let_else.stderr
+++ b/tests/ui/option_if_let_else.stderr
@@ -11,7 +11,18 @@ LL | |     }
    = note: `-D clippy::option-if-let-else` implied by `-D warnings`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:13:5
+  --> $DIR/option_if_let_else.rs:15:12
+   |
+LL |       } else if let Some(x) = string {
+   |  ____________^
+LL | |         Some((true, x))
+LL | |     } else {
+LL | |         Some((false, ""))
+LL | |     }
+   | |_____^ help: try: `{ string.map_or(Some((false, "")), |x| Some((true, x))) }`
+
+error: use Option::map_or instead of an if let/else
+  --> $DIR/option_if_let_else.rs:23:5
    |
 LL | /     if let Some(x) = arg {
 LL | |         let y = x * x;
@@ -30,7 +41,7 @@ LL |     })
    |
 
 error: use Option::map_or_else instead of an if let/else
-  --> $DIR/option_if_let_else.rs:22:13
+  --> $DIR/option_if_let_else.rs:32:13
    |
 LL |       let _ = if let Some(x) = arg {
    |  _____________^
@@ -53,10 +64,10 @@ LL |     }, |x| x * x * x * x);
    |
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:51:13
+  --> $DIR/option_if_let_else.rs:61:13
    |
 LL |     let _ = if let Some(x) = optional { x + 2 } else { 5 };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `optional.map_or(5, |x| x + 2)`
 
-error: aborting due to 4 previous errors
+error: aborting due to 5 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From b85796fe3613e20a4af21933783a3d993bb8d7ad Mon Sep 17 00:00:00 2001
From: JarredAllen <jarredallen73@gmail.com>
Date: Sat, 25 Apr 2020 09:08:23 -0700
Subject: Properly parenthesize to avoid operator precedence errors

---
 clippy_lints/src/option_if_let_else.rs | 25 ++++++++++++++++++++++---
 tests/ui/option_if_let_else.fixed      |  9 +++++++--
 tests/ui/option_if_let_else.rs         | 13 +++++++++++--
 tests/ui/option_if_let_else.stderr     | 16 +++++++++++++---
 4 files changed, 53 insertions(+), 10 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/option_if_let_else.rs b/clippy_lints/src/option_if_let_else.rs
index 1edec1cad6e..66971ee0262 100644
--- a/clippy_lints/src/option_if_let_else.rs
+++ b/clippy_lints/src/option_if_let_else.rs
@@ -175,7 +175,12 @@ fn detect_option_if_let_else<'a>(cx: &LateContext<'_, 'a>, expr: &'a Expr<'a>) -
             let capture_name = id.name.to_ident_string();
             let wrap_braces = utils::get_enclosing_block(cx, expr.hir_id).map_or(false, |parent| {
                 if_chain! {
-                    if let Some(Expr { kind: ExprKind::Match(condition, arms, MatchSource::IfDesugar{contains_else_clause: true}|MatchSource::IfLetDesugar{contains_else_clause: true}), .. } ) = parent.expr;
+                    if let Some(Expr { kind: ExprKind::Match(
+                                _,
+                                arms,
+                                MatchSource::IfDesugar{contains_else_clause: true}
+                                    | MatchSource::IfLetDesugar{contains_else_clause: true}),
+                                .. } ) = parent.expr;
                     if expr.hir_id == arms[1].body.hir_id;
                     then {
                         true
@@ -184,8 +189,19 @@ fn detect_option_if_let_else<'a>(cx: &LateContext<'_, 'a>, expr: &'a Expr<'a>) -
                     }
                 }
             });
+            let parens_around_option = match &let_body.kind {
+                ExprKind::Call(..)
+                        | ExprKind::MethodCall(..)
+                        | ExprKind::Loop(..)
+                        | ExprKind::Match(..)
+                        | ExprKind::Block(..)
+                        | ExprKind::Field(..)
+                        | ExprKind::Path(_)
+                    => false,
+                _ => true,
+            };
             Some(OptionIfLetElseOccurence {
-                option: format!("{}", Sugg::hir(cx, let_body, "..")),
+                option: format!("{}{}{}", if parens_around_option { "(" } else { "" }, Sugg::hir(cx, let_body, ".."), if parens_around_option { ")" } else { "" }),
                 method_sugg: format!("{}", method_sugg),
                 some_expr: format!("|{}| {}", capture_name, Sugg::hir(cx, some_body, "..")),
                 none_expr: format!("{}{}", if method_sugg == "map_or" { "" } else { "|| " }, Sugg::hir(cx, none_body, "..")),
@@ -209,7 +225,10 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for OptionIfLetElse {
                 format!(
                     "{}{}.{}({}, {}){}",
                     if detection.wrap_braces { "{ " } else { "" },
-                    detection.option, detection.method_sugg, detection.none_expr, detection.some_expr,
+                    detection.option,
+                    detection.method_sugg,
+                    detection.none_expr,
+                    detection.some_expr,
                     if detection.wrap_braces { " }" } else { "" },
                 ),
                 Applicability::MachineApplicable,
diff --git a/tests/ui/option_if_let_else.fixed b/tests/ui/option_if_let_else.fixed
index 343e099b2b7..80b162714ac 100644
--- a/tests/ui/option_if_let_else.fixed
+++ b/tests/ui/option_if_let_else.fixed
@@ -5,12 +5,16 @@ fn bad1(string: Option<&str>) -> (bool, &str) {
     string.map_or((false, "hello"), |x| (true, x))
 }
 
-fn bad2(string: Option<&str>) -> Option<(bool, &str)> {
+fn else_if_option(string: Option<&str>) -> Option<(bool, &str)> {
     if string.is_none() {
         None
     } else { string.map_or(Some((false, "")), |x| Some((true, x))) }
 }
 
+fn unop_bad(string: &Option<&str>) -> usize {
+    (*string).map_or(0, |s| s.len())
+}
+
 fn longer_body(arg: Option<u32>) -> u32 {
     arg.map_or(13, |x| {
         let y = x * x;
@@ -48,7 +52,8 @@ fn main() {
     let optional = Some(5);
     let _ = optional.map_or(5, |x| x + 2);
     let _ = bad1(None);
-    let _ = bad2(None);
+    let _ = else_if_option(None);
+    let _ = unop_bad(&None);
     let _ = longer_body(None);
     test_map_or_else(None);
     let _ = negative_tests(None);
diff --git a/tests/ui/option_if_let_else.rs b/tests/ui/option_if_let_else.rs
index b0c203f0637..7c43fbea373 100644
--- a/tests/ui/option_if_let_else.rs
+++ b/tests/ui/option_if_let_else.rs
@@ -9,7 +9,7 @@ fn bad1(string: Option<&str>) -> (bool, &str) {
     }
 }
 
-fn bad2(string: Option<&str>) -> Option<(bool, &str)> {
+fn else_if_option(string: Option<&str>) -> Option<(bool, &str)> {
     if string.is_none() {
         None
     } else if let Some(x) = string {
@@ -19,6 +19,14 @@ fn bad2(string: Option<&str>) -> Option<(bool, &str)> {
     }
 }
 
+fn unop_bad(string: &Option<&str>) -> usize {
+    if let Some(s) = *string {
+        s.len()
+    } else {
+        0
+    }
+}
+
 fn longer_body(arg: Option<u32>) -> u32 {
     if let Some(x) = arg {
         let y = x * x;
@@ -60,7 +68,8 @@ fn main() {
     let optional = Some(5);
     let _ = if let Some(x) = optional { x + 2 } else { 5 };
     let _ = bad1(None);
-    let _ = bad2(None);
+    let _ = else_if_option(None);
+    let _ = unop_bad(&None);
     let _ = longer_body(None);
     test_map_or_else(None);
     let _ = negative_tests(None);
diff --git a/tests/ui/option_if_let_else.stderr b/tests/ui/option_if_let_else.stderr
index 656cfb2f62a..b932fe59759 100644
--- a/tests/ui/option_if_let_else.stderr
+++ b/tests/ui/option_if_let_else.stderr
@@ -24,6 +24,16 @@ LL | |     }
 error: use Option::map_or instead of an if let/else
   --> $DIR/option_if_let_else.rs:23:5
    |
+LL | /     if let Some(s) = *string {
+LL | |         s.len()
+LL | |     } else {
+LL | |         0
+LL | |     }
+   | |_____^ help: try: `(*string).map_or(0, |s| s.len())`
+
+error: use Option::map_or instead of an if let/else
+  --> $DIR/option_if_let_else.rs:31:5
+   |
 LL | /     if let Some(x) = arg {
 LL | |         let y = x * x;
 LL | |         y * y
@@ -41,7 +51,7 @@ LL |     })
    |
 
 error: use Option::map_or_else instead of an if let/else
-  --> $DIR/option_if_let_else.rs:32:13
+  --> $DIR/option_if_let_else.rs:40:13
    |
 LL |       let _ = if let Some(x) = arg {
    |  _____________^
@@ -64,10 +74,10 @@ LL |     }, |x| x * x * x * x);
    |
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:61:13
+  --> $DIR/option_if_let_else.rs:69:13
    |
 LL |     let _ = if let Some(x) = optional { x + 2 } else { 5 };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `optional.map_or(5, |x| x + 2)`
 
-error: aborting due to 5 previous errors
+error: aborting due to 6 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 88c8afdddff07adeff4c87431cbe8bc630a36d68 Mon Sep 17 00:00:00 2001
From: JarredAllen <jarredallen73@gmail.com>
Date: Sat, 9 May 2020 20:20:57 -0700
Subject: Handle ref, mut, &, and &mut on the option

---
 clippy_lints/src/option_if_let_else.rs | 28 ++++++----
 tests/ui/option_if_let_else.fixed      | 20 +++++--
 tests/ui/option_if_let_else.rs         | 36 +++++++++++--
 tests/ui/option_if_let_else.stderr     | 99 +++++++++++++++++++++++++++++++---
 4 files changed, 158 insertions(+), 25 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/option_if_let_else.rs b/clippy_lints/src/option_if_let_else.rs
index 66971ee0262..4e501f4ca02 100644
--- a/clippy_lints/src/option_if_let_else.rs
+++ b/clippy_lints/src/option_if_let_else.rs
@@ -140,18 +140,24 @@ fn contains_return_break_continue<'tcx>(expression: &'tcx Expr<'tcx>) -> bool {
 /// this function returns an OptionIfLetElseOccurence struct with details if
 /// this construct is found, or None if this construct is not found.
 fn detect_option_if_let_else<'a>(cx: &LateContext<'_, 'a>, expr: &'a Expr<'a>) -> Option<OptionIfLetElseOccurence> {
-    //(String, String, String, String)> {
     if_chain! {
-        // if !utils::in_macro(expr.span); // Don't lint macros, because it behaves weirdly
+        if !utils::in_macro(expr.span); // Don't lint macros, because it behaves weirdly
         if let ExprKind::Match(let_body, arms, MatchSource::IfLetDesugar{contains_else_clause: true}) = &expr.kind;
         if arms.len() == 2;
-        if match_type(cx, &cx.tables.expr_ty(let_body), &paths::OPTION);
+        // if type_is_option(cx, &cx.tables.expr_ty(let_body).kind);
         if !is_result_ok(cx, let_body); // Don't lint on Result::ok because a different lint does it already
-        if let PatKind::TupleStruct(_, &[inner_pat], _) = &arms[0].pat.kind;
-        if let PatKind::Binding(_, _, id, _) = &inner_pat.kind;
+        if let PatKind::TupleStruct(struct_qpath, &[inner_pat], _) = &arms[0].pat.kind;
+        if utils::match_qpath(struct_qpath, &paths::OPTION_SOME);
+        if let PatKind::Binding(bind_annotation, _, id, _) = &inner_pat.kind;
         if !contains_return_break_continue(arms[0].body);
         if !contains_return_break_continue(arms[1].body);
         then {
+            let (capture_mut, capture_ref, capture_ref_mut) = match bind_annotation {
+                BindingAnnotation::Unannotated => (false, false, false),
+                BindingAnnotation::Mutable => (true, false, false),
+                BindingAnnotation::Ref => (false, true, false),
+                BindingAnnotation::RefMut => (false, false, true),
+            };
             let some_body = if let ExprKind::Block(Block { stmts: statements, expr: Some(expr), .. }, _)
                 = &arms[0].body.kind {
                 if let &[] = &statements {
@@ -189,7 +195,7 @@ fn detect_option_if_let_else<'a>(cx: &LateContext<'_, 'a>, expr: &'a Expr<'a>) -
                     }
                 }
             });
-            let parens_around_option = match &let_body.kind {
+            let (parens_around_option, as_ref, as_mut, let_body) = match &let_body.kind {
                 ExprKind::Call(..)
                         | ExprKind::MethodCall(..)
                         | ExprKind::Loop(..)
@@ -197,13 +203,15 @@ fn detect_option_if_let_else<'a>(cx: &LateContext<'_, 'a>, expr: &'a Expr<'a>) -
                         | ExprKind::Block(..)
                         | ExprKind::Field(..)
                         | ExprKind::Path(_)
-                    => false,
-                _ => true,
+                    => (false, capture_ref, capture_ref_mut, let_body),
+                ExprKind::Unary(UnOp::UnDeref, expr) => (false, capture_ref, capture_ref_mut, expr),
+                ExprKind::AddrOf(_, mutability, expr) => (false, mutability == &Mutability::Not, mutability == &Mutability::Mut, expr),
+                _ => (true, capture_ref, capture_ref_mut, let_body),
             };
             Some(OptionIfLetElseOccurence {
-                option: format!("{}{}{}", if parens_around_option { "(" } else { "" }, Sugg::hir(cx, let_body, ".."), if parens_around_option { ")" } else { "" }),
+                option: format!("{}{}{}{}", if parens_around_option { "(" } else { "" }, Sugg::hir(cx, let_body, ".."), if parens_around_option { ")" } else { "" }, if as_mut { ".as_mut()" } else if as_ref { ".as_ref()" } else { "" }),
                 method_sugg: format!("{}", method_sugg),
-                some_expr: format!("|{}| {}", capture_name, Sugg::hir(cx, some_body, "..")),
+                some_expr: format!("|{}{}{}| {}", if false { "ref " } else { "" }, if capture_mut { "mut " } else { "" }, capture_name, Sugg::hir(cx, some_body, "..")),
                 none_expr: format!("{}{}", if method_sugg == "map_or" { "" } else { "|| " }, Sugg::hir(cx, none_body, "..")),
                 wrap_braces,
             })
diff --git a/tests/ui/option_if_let_else.fixed b/tests/ui/option_if_let_else.fixed
index 80b162714ac..695a460cc4e 100644
--- a/tests/ui/option_if_let_else.fixed
+++ b/tests/ui/option_if_let_else.fixed
@@ -11,8 +11,22 @@ fn else_if_option(string: Option<&str>) -> Option<(bool, &str)> {
     } else { string.map_or(Some((false, "")), |x| Some((true, x))) }
 }
 
-fn unop_bad(string: &Option<&str>) -> usize {
-    (*string).map_or(0, |s| s.len())
+fn unop_bad(string: &Option<&str>, mut num: Option<i32>) {
+    let _ = string.map_or(0, |s| s.len());
+    let _ = num.as_ref().map_or(&0, |s| s);
+    let _ = num.as_mut().map_or(&mut 0, |s| {
+        *s += 1;
+        s
+    });
+    let _ = num.as_ref().map_or(&0, |s| s);
+    let _ = num.map_or(0, |mut s| {
+        s += 1;
+        s
+    });
+    let _ = num.as_mut().map_or(&mut 0, |s| {
+        *s += 1;
+        s
+    });
 }
 
 fn longer_body(arg: Option<u32>) -> u32 {
@@ -53,7 +67,7 @@ fn main() {
     let _ = optional.map_or(5, |x| x + 2);
     let _ = bad1(None);
     let _ = else_if_option(None);
-    let _ = unop_bad(&None);
+    unop_bad(&None, None);
     let _ = longer_body(None);
     test_map_or_else(None);
     let _ = negative_tests(None);
diff --git a/tests/ui/option_if_let_else.rs b/tests/ui/option_if_let_else.rs
index 7c43fbea373..6f9d506d347 100644
--- a/tests/ui/option_if_let_else.rs
+++ b/tests/ui/option_if_let_else.rs
@@ -19,12 +19,40 @@ fn else_if_option(string: Option<&str>) -> Option<(bool, &str)> {
     }
 }
 
-fn unop_bad(string: &Option<&str>) -> usize {
-    if let Some(s) = *string {
+fn unop_bad(string: &Option<&str>, mut num: Option<i32>) {
+    let _ = if let Some(s) = *string {
         s.len()
     } else {
         0
-    }
+    };
+    let _ = if let Some(s) = &num {
+        s
+    } else {
+        &0
+    };
+    let _ = if let Some(s) = &mut num {
+        *s += 1;
+        s
+    } else {
+        &mut 0
+    };
+    let _ = if let Some(ref s) = num {
+        s
+    } else {
+        &0
+    };
+    let _ = if let Some(mut s) = num {
+        s += 1;
+        s
+    } else {
+        0
+    };
+    let _ = if let Some(ref mut s) = num {
+        *s += 1;
+        s
+    } else {
+        &mut 0
+    };
 }
 
 fn longer_body(arg: Option<u32>) -> u32 {
@@ -69,7 +97,7 @@ fn main() {
     let _ = if let Some(x) = optional { x + 2 } else { 5 };
     let _ = bad1(None);
     let _ = else_if_option(None);
-    let _ = unop_bad(&None);
+    unop_bad(&None, None);
     let _ = longer_body(None);
     test_map_or_else(None);
     let _ = negative_tests(None);
diff --git a/tests/ui/option_if_let_else.stderr b/tests/ui/option_if_let_else.stderr
index b932fe59759..9240d3edb27 100644
--- a/tests/ui/option_if_let_else.stderr
+++ b/tests/ui/option_if_let_else.stderr
@@ -22,17 +22,100 @@ LL | |     }
    | |_____^ help: try: `{ string.map_or(Some((false, "")), |x| Some((true, x))) }`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:23:5
+  --> $DIR/option_if_let_else.rs:23:13
    |
-LL | /     if let Some(s) = *string {
+LL |       let _ = if let Some(s) = *string {
+   |  _____________^
 LL | |         s.len()
 LL | |     } else {
 LL | |         0
-LL | |     }
-   | |_____^ help: try: `(*string).map_or(0, |s| s.len())`
+LL | |     };
+   | |_____^ help: try: `string.map_or(0, |s| s.len())`
+
+error: use Option::map_or instead of an if let/else
+  --> $DIR/option_if_let_else.rs:28:13
+   |
+LL |       let _ = if let Some(s) = &num {
+   |  _____________^
+LL | |         s
+LL | |     } else {
+LL | |         &0
+LL | |     };
+   | |_____^ help: try: `num.as_ref().map_or(&0, |s| s)`
+
+error: use Option::map_or instead of an if let/else
+  --> $DIR/option_if_let_else.rs:33:13
+   |
+LL |       let _ = if let Some(s) = &mut num {
+   |  _____________^
+LL | |         *s += 1;
+LL | |         s
+LL | |     } else {
+LL | |         &mut 0
+LL | |     };
+   | |_____^
+   |
+help: try
+   |
+LL |     let _ = num.as_mut().map_or(&mut 0, |s| {
+LL |         *s += 1;
+LL |         s
+LL |     });
+   |
+
+error: use Option::map_or instead of an if let/else
+  --> $DIR/option_if_let_else.rs:39:13
+   |
+LL |       let _ = if let Some(ref s) = num {
+   |  _____________^
+LL | |         s
+LL | |     } else {
+LL | |         &0
+LL | |     };
+   | |_____^ help: try: `num.as_ref().map_or(&0, |s| s)`
+
+error: use Option::map_or instead of an if let/else
+  --> $DIR/option_if_let_else.rs:44:13
+   |
+LL |       let _ = if let Some(mut s) = num {
+   |  _____________^
+LL | |         s += 1;
+LL | |         s
+LL | |     } else {
+LL | |         0
+LL | |     };
+   | |_____^
+   |
+help: try
+   |
+LL |     let _ = num.map_or(0, |mut s| {
+LL |         s += 1;
+LL |         s
+LL |     });
+   |
+
+error: use Option::map_or instead of an if let/else
+  --> $DIR/option_if_let_else.rs:50:13
+   |
+LL |       let _ = if let Some(ref mut s) = num {
+   |  _____________^
+LL | |         *s += 1;
+LL | |         s
+LL | |     } else {
+LL | |         &mut 0
+LL | |     };
+   | |_____^
+   |
+help: try
+   |
+LL |     let _ = num.as_mut().map_or(&mut 0, |s| {
+LL |         *s += 1;
+LL |         s
+LL |     });
+   |
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:31:5
+  --> $DIR/option_if_let_else.rs:59:5
    |
 LL | /     if let Some(x) = arg {
 LL | |         let y = x * x;
@@ -51,7 +134,7 @@ LL |     })
    |
 
 error: use Option::map_or_else instead of an if let/else
-  --> $DIR/option_if_let_else.rs:40:13
+  --> $DIR/option_if_let_else.rs:68:13
    |
 LL |       let _ = if let Some(x) = arg {
    |  _____________^
@@ -74,10 +157,10 @@ LL |     }, |x| x * x * x * x);
    |
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:69:13
+  --> $DIR/option_if_let_else.rs:97:13
    |
 LL |     let _ = if let Some(x) = optional { x + 2 } else { 5 };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `optional.map_or(5, |x| x + 2)`
 
-error: aborting due to 6 previous errors
+error: aborting due to 11 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From f73b455b99694fbc5ddec38317f705f546729db2 Mon Sep 17 00:00:00 2001
From: JarredAllen <jarredallen73@gmail.com>
Date: Sat, 9 May 2020 20:44:56 -0700
Subject: Refactoring

---
 clippy_lints/src/option_if_let_else.rs | 170 ++++++++++++++++++++-------------
 tests/ui/option_if_let_else.rs         |  18 +---
 tests/ui/option_if_let_else.stderr     |  43 +++------
 3 files changed, 123 insertions(+), 108 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/option_if_let_else.rs b/clippy_lints/src/option_if_let_else.rs
index 4e501f4ca02..208aa550765 100644
--- a/clippy_lints/src/option_if_let_else.rs
+++ b/clippy_lints/src/option_if_let_else.rs
@@ -5,7 +5,7 @@ use if_chain::if_chain;
 
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{NestedVisitorMap, Visitor};
-use rustc_hir::*;
+use rustc_hir::{Arm, BindingAnnotation, Block, Expr, ExprKind, MatchSource, Mutability, PatKind, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::map::Map;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -69,17 +69,12 @@ declare_clippy_lint! {
 
 declare_lint_pass!(OptionIfLetElse => [OPTION_IF_LET_ELSE]);
 
-/// Returns true iff the given expression is the result of calling Result::ok
+/// Returns true iff the given expression is the result of calling `Result::ok`
 fn is_result_ok(cx: &LateContext<'_, '_>, expr: &'_ Expr<'_>) -> bool {
-    if_chain! {
-        if let ExprKind::MethodCall(ref path, _, &[ref receiver]) = &expr.kind;
-        if path.ident.name.to_ident_string() == "ok";
-        if match_type(cx, &cx.tables.expr_ty(&receiver), &paths::RESULT);
-        then {
-            true
-        } else {
-            false
-        }
+    if let ExprKind::MethodCall(ref path, _, &[ref receiver]) = &expr.kind {
+        path.ident.name.to_ident_string() == "ok" && match_type(cx, &cx.tables.expr_ty(&receiver), &paths::RESULT)
+    } else {
+        false
     }
 }
 
@@ -136,66 +131,108 @@ fn contains_return_break_continue<'tcx>(expression: &'tcx Expr<'tcx>) -> bool {
     recursive_visitor.seen_return_break_continue
 }
 
+/// Extracts the body of a given arm. If the arm contains only an expression,
+/// then it returns the expression. Otherwise, it returns the entire block
+fn extract_body_from_arm<'a>(arm: &'a Arm<'a>) -> Option<&'a Expr<'a>> {
+    if let ExprKind::Block(
+        Block {
+            stmts: statements,
+            expr: Some(expr),
+            ..
+        },
+        _,
+    ) = &arm.body.kind
+    {
+        if let [] = statements {
+            Some(&expr)
+        } else {
+            Some(&arm.body)
+        }
+    } else {
+        None
+    }
+}
+
+/// If this is the else body of an if/else expression, then we need to wrap
+/// it in curcly braces. Otherwise, we don't.
+fn should_wrap_in_braces(cx: &LateContext<'_, '_>, expr: &Expr<'_>) -> bool {
+    utils::get_enclosing_block(cx, expr.hir_id).map_or(false, |parent| {
+        if let Some(Expr {
+            kind:
+                ExprKind::Match(
+                    _,
+                    arms,
+                    MatchSource::IfDesugar {
+                        contains_else_clause: true,
+                    }
+                    | MatchSource::IfLetDesugar {
+                        contains_else_clause: true,
+                    },
+                ),
+            ..
+        }) = parent.expr
+        {
+            expr.hir_id == arms[1].body.hir_id
+        } else {
+            false
+        }
+    })
+}
+
+fn format_option_in_sugg(
+    cx: &LateContext<'_, '_>,
+    cond_expr: &Expr<'_>,
+    parens_around_option: bool,
+    as_ref: bool,
+    as_mut: bool,
+) -> String {
+    format!(
+        "{}{}{}{}",
+        if parens_around_option { "(" } else { "" },
+        Sugg::hir(cx, cond_expr, ".."),
+        if parens_around_option { ")" } else { "" },
+        if as_mut {
+            ".as_mut()"
+        } else if as_ref {
+            ".as_ref()"
+        } else {
+            ""
+        }
+    )
+}
+
 /// If this expression is the option if let/else construct we're detecting, then
-/// this function returns an OptionIfLetElseOccurence struct with details if
+/// this function returns an `OptionIfLetElseOccurence` struct with details if
 /// this construct is found, or None if this construct is not found.
 fn detect_option_if_let_else<'a>(cx: &LateContext<'_, 'a>, expr: &'a Expr<'a>) -> Option<OptionIfLetElseOccurence> {
     if_chain! {
         if !utils::in_macro(expr.span); // Don't lint macros, because it behaves weirdly
-        if let ExprKind::Match(let_body, arms, MatchSource::IfLetDesugar{contains_else_clause: true}) = &expr.kind;
+        if let ExprKind::Match(cond_expr, arms, MatchSource::IfLetDesugar{contains_else_clause: true}) = &expr.kind;
         if arms.len() == 2;
-        // if type_is_option(cx, &cx.tables.expr_ty(let_body).kind);
-        if !is_result_ok(cx, let_body); // Don't lint on Result::ok because a different lint does it already
+        if !is_result_ok(cx, cond_expr); // Don't lint on Result::ok because a different lint does it already
         if let PatKind::TupleStruct(struct_qpath, &[inner_pat], _) = &arms[0].pat.kind;
         if utils::match_qpath(struct_qpath, &paths::OPTION_SOME);
         if let PatKind::Binding(bind_annotation, _, id, _) = &inner_pat.kind;
         if !contains_return_break_continue(arms[0].body);
         if !contains_return_break_continue(arms[1].body);
         then {
-            let (capture_mut, capture_ref, capture_ref_mut) = match bind_annotation {
-                BindingAnnotation::Unannotated => (false, false, false),
-                BindingAnnotation::Mutable => (true, false, false),
-                BindingAnnotation::Ref => (false, true, false),
-                BindingAnnotation::RefMut => (false, false, true),
-            };
-            let some_body = if let ExprKind::Block(Block { stmts: statements, expr: Some(expr), .. }, _)
-                = &arms[0].body.kind {
-                if let &[] = &statements {
-                    expr
-                } else {
-                    &arms[0].body
-                }
-            } else {
-                return None;
-            };
-            let (none_body, method_sugg) = if let ExprKind::Block(Block { stmts: statements, expr: Some(expr), .. }, _)
-                = &arms[1].body.kind {
-                if let &[] = &statements {
-                    (expr, "map_or")
-                } else {
-                    (&arms[1].body, "map_or_else")
-                }
-            } else {
-                return None;
+            let capture_mut = if bind_annotation == &BindingAnnotation::Mutable { "mut " } else { "" };
+            let some_body = extract_body_from_arm(&arms[0])?;
+            let none_body = extract_body_from_arm(&arms[1])?;
+            let method_sugg = match &none_body.kind {
+                ExprKind::Block(..) => "map_or_else",
+                _ => "map_or",
             };
             let capture_name = id.name.to_ident_string();
-            let wrap_braces = utils::get_enclosing_block(cx, expr.hir_id).map_or(false, |parent| {
-                if_chain! {
-                    if let Some(Expr { kind: ExprKind::Match(
-                                _,
-                                arms,
-                                MatchSource::IfDesugar{contains_else_clause: true}
-                                    | MatchSource::IfLetDesugar{contains_else_clause: true}),
-                                .. } ) = parent.expr;
-                    if expr.hir_id == arms[1].body.hir_id;
-                    then {
-                        true
-                    } else {
-                        false
-                    }
-                }
-            });
-            let (parens_around_option, as_ref, as_mut, let_body) = match &let_body.kind {
+            let wrap_braces = should_wrap_in_braces(cx, expr);
+            let (as_ref, as_mut) = match &cond_expr.kind {
+                ExprKind::AddrOf(_, Mutability::Not, _) => (true, false),
+                ExprKind::AddrOf(_, Mutability::Mut, _) => (false, true),
+                _ => (bind_annotation == &BindingAnnotation::Ref, bind_annotation == &BindingAnnotation::RefMut),
+            };
+            let parens_around_option = match &cond_expr.kind {
+                // Put parens around the option expression if not doing so might
+                // mess up the order of operations.
                 ExprKind::Call(..)
                         | ExprKind::MethodCall(..)
                         | ExprKind::Loop(..)
@@ -203,15 +240,20 @@ fn detect_option_if_let_else<'a>(cx: &LateContext<'_, 'a>, expr: &'a Expr<'a>) -
                         | ExprKind::Block(..)
                         | ExprKind::Field(..)
                         | ExprKind::Path(_)
-                    => (false, capture_ref, capture_ref_mut, let_body),
-                ExprKind::Unary(UnOp::UnDeref, expr) => (false, capture_ref, capture_ref_mut, expr),
-                ExprKind::AddrOf(_, mutability, expr) => (false, mutability == &Mutability::Not, mutability == &Mutability::Mut, expr),
-                _ => (true, capture_ref, capture_ref_mut, let_body),
+                        | ExprKind::Unary(UnOp::UnDeref, _)
+                        | ExprKind::AddrOf(..)
+                    => false,
+                _ => true,
+            };
+            let cond_expr = match &cond_expr.kind {
+                // Pointer dereferencing happens automatically, so we can omit it in the suggestion
+                ExprKind::Unary(UnOp::UnDeref, expr)|ExprKind::AddrOf(_, _, expr) => expr,
+                _ => cond_expr,
             };
             Some(OptionIfLetElseOccurence {
-                option: format!("{}{}{}{}", if parens_around_option { "(" } else { "" }, Sugg::hir(cx, let_body, ".."), if parens_around_option { ")" } else { "" }, if as_mut { ".as_mut()" } else if as_ref { ".as_ref()" } else { "" }),
-                method_sugg: format!("{}", method_sugg),
-                some_expr: format!("|{}{}{}| {}", if false { "ref " } else { "" }, if capture_mut { "mut " } else { "" }, capture_name, Sugg::hir(cx, some_body, "..")),
+                option: format_option_in_sugg(cx, cond_expr, parens_around_option, as_ref, as_mut),
+                method_sugg: method_sugg.to_string(),
+                some_expr: format!("|{}{}| {}", capture_mut, capture_name, Sugg::hir(cx, some_body, "..")),
                 none_expr: format!("{}{}", if method_sugg == "map_or" { "" } else { "|| " }, Sugg::hir(cx, none_body, "..")),
                 wrap_braces,
             })
diff --git a/tests/ui/option_if_let_else.rs b/tests/ui/option_if_let_else.rs
index 6f9d506d347..dee80d26bd9 100644
--- a/tests/ui/option_if_let_else.rs
+++ b/tests/ui/option_if_let_else.rs
@@ -20,27 +20,15 @@ fn else_if_option(string: Option<&str>) -> Option<(bool, &str)> {
 }
 
 fn unop_bad(string: &Option<&str>, mut num: Option<i32>) {
-    let _ = if let Some(s) = *string {
-        s.len()
-    } else {
-        0
-    };
-    let _ = if let Some(s) = &num {
-        s
-    } else {
-        &0
-    };
+    let _ = if let Some(s) = *string { s.len() } else { 0 };
+    let _ = if let Some(s) = &num { s } else { &0 };
     let _ = if let Some(s) = &mut num {
         *s += 1;
         s
     } else {
         &mut 0
     };
-    let _ = if let Some(ref s) = num {
-        s
-    } else {
-        &0
-    };
+    let _ = if let Some(ref s) = num { s } else { &0 };
     let _ = if let Some(mut s) = num {
         s += 1;
         s
diff --git a/tests/ui/option_if_let_else.stderr b/tests/ui/option_if_let_else.stderr
index 9240d3edb27..7005850efaf 100644
--- a/tests/ui/option_if_let_else.stderr
+++ b/tests/ui/option_if_let_else.stderr
@@ -24,27 +24,17 @@ LL | |     }
 error: use Option::map_or instead of an if let/else
   --> $DIR/option_if_let_else.rs:23:13
    |
-LL |       let _ = if let Some(s) = *string {
-   |  _____________^
-LL | |         s.len()
-LL | |     } else {
-LL | |         0
-LL | |     };
-   | |_____^ help: try: `string.map_or(0, |s| s.len())`
+LL |     let _ = if let Some(s) = *string { s.len() } else { 0 };
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `string.map_or(0, |s| s.len())`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:28:13
+  --> $DIR/option_if_let_else.rs:24:13
    |
-LL |       let _ = if let Some(s) = &num {
-   |  _____________^
-LL | |         s
-LL | |     } else {
-LL | |         &0
-LL | |     };
-   | |_____^ help: try: `num.as_ref().map_or(&0, |s| s)`
+LL |     let _ = if let Some(s) = &num { s } else { &0 };
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `num.as_ref().map_or(&0, |s| s)`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:33:13
+  --> $DIR/option_if_let_else.rs:25:13
    |
 LL |       let _ = if let Some(s) = &mut num {
    |  _____________^
@@ -64,18 +54,13 @@ LL |     });
    |
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:39:13
+  --> $DIR/option_if_let_else.rs:31:13
    |
-LL |       let _ = if let Some(ref s) = num {
-   |  _____________^
-LL | |         s
-LL | |     } else {
-LL | |         &0
-LL | |     };
-   | |_____^ help: try: `num.as_ref().map_or(&0, |s| s)`
+LL |     let _ = if let Some(ref s) = num { s } else { &0 };
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `num.as_ref().map_or(&0, |s| s)`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:44:13
+  --> $DIR/option_if_let_else.rs:32:13
    |
 LL |       let _ = if let Some(mut s) = num {
    |  _____________^
@@ -95,7 +80,7 @@ LL |     });
    |
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:50:13
+  --> $DIR/option_if_let_else.rs:38:13
    |
 LL |       let _ = if let Some(ref mut s) = num {
    |  _____________^
@@ -115,7 +100,7 @@ LL |     });
    |
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:59:5
+  --> $DIR/option_if_let_else.rs:47:5
    |
 LL | /     if let Some(x) = arg {
 LL | |         let y = x * x;
@@ -134,7 +119,7 @@ LL |     })
    |
 
 error: use Option::map_or_else instead of an if let/else
-  --> $DIR/option_if_let_else.rs:68:13
+  --> $DIR/option_if_let_else.rs:56:13
    |
 LL |       let _ = if let Some(x) = arg {
    |  _____________^
@@ -157,7 +142,7 @@ LL |     }, |x| x * x * x * x);
    |
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:97:13
+  --> $DIR/option_if_let_else.rs:85:13
    |
 LL |     let _ = if let Some(x) = optional { x + 2 } else { 5 };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `optional.map_or(5, |x| x + 2)`
-- 
cgit 1.4.1-3-g733a5


From 7c4de9d3dee3a7e16118df5c1cd2080af7350d98 Mon Sep 17 00:00:00 2001
From: JarredAllen <jarredallen73@gmail.com>
Date: Mon, 11 May 2020 17:52:47 -0700
Subject: Refactoring pt. 2

---
 clippy_lints/src/option_if_let_else.rs | 33 +++++----------------------------
 1 file changed, 5 insertions(+), 28 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/option_if_let_else.rs b/clippy_lints/src/option_if_let_else.rs
index 208aa550765..6e8d7515671 100644
--- a/clippy_lints/src/option_if_let_else.rs
+++ b/clippy_lints/src/option_if_let_else.rs
@@ -179,18 +179,10 @@ fn should_wrap_in_braces(cx: &LateContext<'_, '_>, expr: &Expr<'_>) -> bool {
     })
 }
 
-fn format_option_in_sugg(
-    cx: &LateContext<'_, '_>,
-    cond_expr: &Expr<'_>,
-    parens_around_option: bool,
-    as_ref: bool,
-    as_mut: bool,
-) -> String {
+fn format_option_in_sugg(cx: &LateContext<'_, '_>, cond_expr: &Expr<'_>, as_ref: bool, as_mut: bool) -> String {
     format!(
-        "{}{}{}{}",
-        if parens_around_option { "(" } else { "" },
-        Sugg::hir(cx, cond_expr, ".."),
-        if parens_around_option { ")" } else { "" },
+        "{}{}",
+        Sugg::hir(cx, cond_expr, "..").maybe_par(),
         if as_mut {
             ".as_mut()"
         } else if as_ref {
@@ -230,28 +222,13 @@ fn detect_option_if_let_else<'a>(cx: &LateContext<'_, 'a>, expr: &'a Expr<'a>) -
                 ExprKind::AddrOf(_, Mutability::Mut, _) => (false, true),
                 _ => (bind_annotation == &BindingAnnotation::Ref, bind_annotation == &BindingAnnotation::RefMut),
             };
-            let parens_around_option = match &cond_expr.kind {
-                // Put parens around the option expression if not doing so might
-                // mess up the order of operations.
-                ExprKind::Call(..)
-                        | ExprKind::MethodCall(..)
-                        | ExprKind::Loop(..)
-                        | ExprKind::Match(..)
-                        | ExprKind::Block(..)
-                        | ExprKind::Field(..)
-                        | ExprKind::Path(_)
-                        | ExprKind::Unary(UnOp::UnDeref, _)
-                        | ExprKind::AddrOf(..)
-                    => false,
-                _ => true,
-            };
             let cond_expr = match &cond_expr.kind {
                 // Pointer dereferencing happens automatically, so we can omit it in the suggestion
-                ExprKind::Unary(UnOp::UnDeref, expr)|ExprKind::AddrOf(_, _, expr) => expr,
+                ExprKind::Unary(UnOp::UnDeref, expr) | ExprKind::AddrOf(_, _, expr) => expr,
                 _ => cond_expr,
             };
             Some(OptionIfLetElseOccurence {
-                option: format_option_in_sugg(cx, cond_expr, parens_around_option, as_ref, as_mut),
+                option: format_option_in_sugg(cx, cond_expr, as_ref, as_mut),
                 method_sugg: method_sugg.to_string(),
                 some_expr: format!("|{}{}| {}", capture_mut, capture_name, Sugg::hir(cx, some_body, "..")),
                 none_expr: format!("{}{}", if method_sugg == "map_or" { "" } else { "|| " }, Sugg::hir(cx, none_body, "..")),
-- 
cgit 1.4.1-3-g733a5


From 5e20475e47d3db1d32a7649a7c3a107caba32a14 Mon Sep 17 00:00:00 2001
From: JarredAllen <jarredallen73@gmail.com>
Date: Sun, 31 May 2020 15:34:10 -0700
Subject: Don't lint if contains a macro

---
 clippy_lints/src/option_if_let_else.rs | 28 ++++++++++++++--------------
 1 file changed, 14 insertions(+), 14 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/option_if_let_else.rs b/clippy_lints/src/option_if_let_else.rs
index 6e8d7515671..be0c44cae34 100644
--- a/clippy_lints/src/option_if_let_else.rs
+++ b/clippy_lints/src/option_if_let_else.rs
@@ -10,8 +10,6 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::map::Map;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
-use std::marker::PhantomData;
-
 declare_clippy_lint! {
     /// **What it does:**
     /// Lints usage of  `if let Some(v) = ... { y } else { x }` which is more
@@ -88,19 +86,17 @@ struct OptionIfLetElseOccurence {
     wrap_braces: bool,
 }
 
-struct ReturnBreakContinueVisitor<'tcx> {
+struct ReturnBreakContinueMacroVisitor {
     seen_return_break_continue: bool,
-    phantom_data: PhantomData<&'tcx bool>,
 }
-impl<'tcx> ReturnBreakContinueVisitor<'tcx> {
-    fn new() -> ReturnBreakContinueVisitor<'tcx> {
-        ReturnBreakContinueVisitor {
+impl ReturnBreakContinueMacroVisitor {
+    fn new() -> ReturnBreakContinueMacroVisitor {
+        ReturnBreakContinueMacroVisitor {
             seen_return_break_continue: false,
-            phantom_data: PhantomData,
         }
     }
 }
-impl<'tcx> Visitor<'tcx> for ReturnBreakContinueVisitor<'tcx> {
+impl<'tcx> Visitor<'tcx> for ReturnBreakContinueMacroVisitor {
     type Map = Map<'tcx>;
     fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
         NestedVisitorMap::None
@@ -119,14 +115,18 @@ impl<'tcx> Visitor<'tcx> for ReturnBreakContinueVisitor<'tcx> {
             // desugaring, as this will detect a break if there's a while loop
             // or a for loop inside the expression.
             _ => {
-                rustc_hir::intravisit::walk_expr(self, ex);
+                if utils::in_macro(ex.span) {
+                    self.seen_return_break_continue = true;
+                } else {
+                    rustc_hir::intravisit::walk_expr(self, ex);
+                }
             },
         }
     }
 }
 
-fn contains_return_break_continue<'tcx>(expression: &'tcx Expr<'tcx>) -> bool {
-    let mut recursive_visitor: ReturnBreakContinueVisitor<'tcx> = ReturnBreakContinueVisitor::new();
+fn contains_return_break_continue_macro(expression: &Expr<'_>) -> bool {
+    let mut recursive_visitor = ReturnBreakContinueMacroVisitor::new();
     recursive_visitor.visit_expr(expression);
     recursive_visitor.seen_return_break_continue
 }
@@ -205,8 +205,8 @@ fn detect_option_if_let_else<'a>(cx: &LateContext<'_, 'a>, expr: &'a Expr<'a>) -
         if let PatKind::TupleStruct(struct_qpath, &[inner_pat], _) = &arms[0].pat.kind;
         if utils::match_qpath(struct_qpath, &paths::OPTION_SOME);
         if let PatKind::Binding(bind_annotation, _, id, _) = &inner_pat.kind;
-        if !contains_return_break_continue(arms[0].body);
-        if !contains_return_break_continue(arms[1].body);
+        if !contains_return_break_continue_macro(arms[0].body);
+        if !contains_return_break_continue_macro(arms[1].body);
         then {
             let capture_mut = if bind_annotation == &BindingAnnotation::Mutable { "mut " } else { "" };
             let some_body = extract_body_from_arm(&arms[0])?;
-- 
cgit 1.4.1-3-g733a5


From 5150277a4f765bb113e163adc7eb495dcbb57129 Mon Sep 17 00:00:00 2001
From: JarredAllen <jarredallen73@gmail.com>
Date: Sun, 31 May 2020 15:37:21 -0700
Subject: Used clippy to clean itself

---
 clippy_lints/src/attrs.rs                          | 14 ++------
 clippy_lints/src/if_let_mutex.rs                   |  8 ++---
 clippy_lints/src/len_zero.rs                       |  8 ++---
 clippy_lints/src/literal_representation.rs         |  7 ++--
 clippy_lints/src/loops.rs                          | 26 +++-----------
 clippy_lints/src/methods/mod.rs                    |  6 +---
 clippy_lints/src/methods/unnecessary_filter_map.rs |  6 +---
 clippy_lints/src/minmax.rs                         | 21 +++++++-----
 clippy_lints/src/misc.rs                           |  8 ++---
 clippy_lints/src/option_if_let_else.rs             |  4 ++-
 clippy_lints/src/returns.rs                        |  9 ++---
 clippy_lints/src/shadow.rs                         | 10 ++----
 clippy_lints/src/types.rs                          | 12 +++----
 clippy_lints/src/use_self.rs                       |  8 ++---
 clippy_lints/src/utils/attrs.rs                    | 14 ++++----
 clippy_lints/src/utils/mod.rs                      | 40 +++++-----------------
 clippy_lints/src/utils/numeric_literal.rs          |  6 ++--
 clippy_lints/src/utils/sugg.rs                     |  8 ++---
 clippy_lints/src/write.rs                          |  6 ++--
 19 files changed, 67 insertions(+), 154 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs
index 2d0855f6895..cfad9d79f2b 100644
--- a/clippy_lints/src/attrs.rs
+++ b/clippy_lints/src/attrs.rs
@@ -481,15 +481,11 @@ fn is_relevant_trait(cx: &LateContext<'_>, item: &TraitItem<'_>) -> bool {
 }
 
 fn is_relevant_block(cx: &LateContext<'_>, tables: &ty::TypeckTables<'_>, block: &Block<'_>) -> bool {
-    if let Some(stmt) = block.stmts.first() {
-        match &stmt.kind {
+    block.stmts.first().map_or(block.expr.as_ref().map_or(false, |e| is_relevant_expr(cx, tables, e)), |stmt| match &stmt.kind {
             StmtKind::Local(_) => true,
             StmtKind::Expr(expr) | StmtKind::Semi(expr) => is_relevant_expr(cx, tables, expr),
             _ => false,
-        }
-    } else {
-        block.expr.as_ref().map_or(false, |e| is_relevant_expr(cx, tables, e))
-    }
+        })
 }
 
 fn is_relevant_expr(cx: &LateContext<'_>, tables: &ty::TypeckTables<'_>, expr: &Expr<'_>) -> bool {
@@ -499,11 +495,7 @@ fn is_relevant_expr(cx: &LateContext<'_>, tables: &ty::TypeckTables<'_>, expr: &
         ExprKind::Ret(None) | ExprKind::Break(_, None) => false,
         ExprKind::Call(path_expr, _) => {
             if let ExprKind::Path(qpath) = &path_expr.kind {
-                if let Some(fun_id) = tables.qpath_res(qpath, path_expr.hir_id).opt_def_id() {
-                    !match_def_path(cx, fun_id, &paths::BEGIN_PANIC)
-                } else {
-                    true
-                }
+                tables.qpath_res(qpath, path_expr.hir_id).opt_def_id().map_or(true, |fun_id| !match_def_path(cx, fun_id, &paths::BEGIN_PANIC))
             } else {
                 true
             }
diff --git a/clippy_lints/src/if_let_mutex.rs b/clippy_lints/src/if_let_mutex.rs
index f911cb68ea5..7e44618e90e 100644
--- a/clippy_lints/src/if_let_mutex.rs
+++ b/clippy_lints/src/if_let_mutex.rs
@@ -135,13 +135,9 @@ impl<'tcx> Visitor<'tcx> for ArmVisitor<'_, 'tcx> {
     }
 }
 
-impl<'tcx> ArmVisitor<'_, 'tcx> {
+impl<'tcx, 'l> ArmVisitor<'tcx, 'l> {
     fn same_mutex(&self, cx: &LateContext<'_>, op_mutex: &Expr<'_>) -> bool {
-        if let Some(arm_mutex) = self.found_mutex {
-            SpanlessEq::new(cx).eq_expr(op_mutex, arm_mutex)
-        } else {
-            false
-        }
+        self.found_mutex.map_or(false, |arm_mutex| SpanlessEq::new(cx).eq_expr(op_mutex, arm_mutex))
     }
 }
 
diff --git a/clippy_lints/src/len_zero.rs b/clippy_lints/src/len_zero.rs
index 26d96428771..f57fa830adc 100644
--- a/clippy_lints/src/len_zero.rs
+++ b/clippy_lints/src/len_zero.rs
@@ -303,14 +303,10 @@ fn has_is_empty(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
     let ty = &walk_ptrs_ty(cx.tables().expr_ty(expr));
     match ty.kind {
         ty::Dynamic(ref tt, ..) => {
-            if let Some(principal) = tt.principal() {
-                cx.tcx
+            tt.principal().map_or(false, |principal| cx.tcx
                     .associated_items(principal.def_id())
                     .in_definition_order()
-                    .any(|item| is_is_empty(cx, &item))
-            } else {
-                false
-            }
+                    .any(|item| is_is_empty(cx, &item)))
         },
         ty::Projection(ref proj) => has_is_empty_impl(cx, proj.item_def_id),
         ty::Adt(id, _) => has_is_empty_impl(cx, id.did),
diff --git a/clippy_lints/src/literal_representation.rs b/clippy_lints/src/literal_representation.rs
index 7ba43562d7d..ea2e23bd3a1 100644
--- a/clippy_lints/src/literal_representation.rs
+++ b/clippy_lints/src/literal_representation.rs
@@ -264,10 +264,11 @@ impl LiteralDigitGrouping {
 
         let (part, mistyped_suffixes, missing_char) = if let Some((_, exponent)) = &mut num_lit.exponent {
             (exponent, &["32", "64"][..], 'f')
-        } else if let Some(fraction) = &mut num_lit.fraction {
-            (fraction, &["32", "64"][..], 'f')
         } else {
-            (&mut num_lit.integer, &["8", "16", "32", "64"][..], 'i')
+            num_lit.fraction.as_mut().map_or(
+                (&mut num_lit.integer, &["8", "16", "32", "64"][..], 'i'),
+                |fraction| (fraction, &["32", "64"][..], 'f')
+            )
         };
 
         let mut split = part.rsplit('_');
diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index d821b513484..8d48f39a045 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -687,11 +687,7 @@ fn never_loop_expr(expr: &Expr<'_>, main_loop_id: HirId) -> NeverLoopResult {
             }
         },
         ExprKind::Break(_, ref e) | ExprKind::Ret(ref e) => {
-            if let Some(ref e) = *e {
-                combine_seq(never_loop_expr(e, main_loop_id), NeverLoopResult::AlwaysBreak)
-            } else {
-                NeverLoopResult::AlwaysBreak
-            }
+            e.as_ref().map_or(NeverLoopResult::AlwaysBreak, |e| combine_seq(never_loop_expr(e, main_loop_id), NeverLoopResult::AlwaysBreak))
         },
         ExprKind::InlineAsm(ref asm) => asm
             .operands
@@ -1882,11 +1878,7 @@ fn is_iterable_array<'tcx>(ty: Ty<'tcx>, cx: &LateContext<'tcx>) -> bool {
     // IntoIterator is currently only implemented for array sizes <= 32 in rustc
     match ty.kind {
         ty::Array(_, n) => {
-            if let Some(val) = n.try_eval_usize(cx.tcx, cx.param_env) {
-                (0..=32).contains(&val)
-            } else {
-                false
-            }
+            n.try_eval_usize(cx.tcx, cx.param_env).map_or(false, |val| (0..=32).contains(&val))
         },
         _ => false,
     }
@@ -1899,11 +1891,7 @@ fn extract_expr_from_first_stmt<'tcx>(block: &Block<'tcx>) -> Option<&'tcx Expr<
         return None;
     }
     if let StmtKind::Local(ref local) = block.stmts[0].kind {
-        if let Some(expr) = local.init {
-            Some(expr)
-        } else {
-            None
-        }
+        local.init.map(|expr| expr)
     } else {
         None
     }
@@ -2023,15 +2011,11 @@ impl<'a, 'tcx> Visitor<'tcx> for InitializeVisitor<'a, 'tcx> {
                 if let PatKind::Binding(.., ident, _) = local.pat.kind {
                     self.name = Some(ident.name);
 
-                    self.state = if let Some(ref init) = local.init {
-                        if is_integer_const(&self.cx, init, 0) {
+                    self.state = local.init.as_ref().map_or(VarState::Declared, |init| if is_integer_const(&self.cx, init, 0) {
                             VarState::Warn
                         } else {
                             VarState::Declared
-                        }
-                    } else {
-                        VarState::Declared
-                    }
+                        })
                 }
             }
         }
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 160304865c5..ddad16e163e 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -2461,11 +2461,7 @@ fn derefs_to_slice<'tcx>(
             ty::Adt(def, _) if def.is_box() => may_slice(cx, ty.boxed_ty()),
             ty::Adt(..) => is_type_diagnostic_item(cx, ty, sym!(vec_type)),
             ty::Array(_, size) => {
-                if let Some(size) = size.try_eval_usize(cx.tcx, cx.param_env) {
-                    size < 32
-                } else {
-                    false
-                }
+                size.try_eval_usize(cx.tcx, cx.param_env).map_or(false, |size| size < 32)
             },
             ty::Ref(_, inner, _) => may_slice(cx, inner),
             _ => false,
diff --git a/clippy_lints/src/methods/unnecessary_filter_map.rs b/clippy_lints/src/methods/unnecessary_filter_map.rs
index fdcba110542..97909c97fc7 100644
--- a/clippy_lints/src/methods/unnecessary_filter_map.rs
+++ b/clippy_lints/src/methods/unnecessary_filter_map.rs
@@ -78,11 +78,7 @@ fn check_expression<'tcx>(cx: &LateContext<'tcx>, arg_id: hir::HirId, expr: &'tc
             (true, true)
         },
         hir::ExprKind::Block(ref block, _) => {
-            if let Some(expr) = &block.expr {
-                check_expression(cx, arg_id, &expr)
-            } else {
-                (false, false)
-            }
+            block.expr.as_ref().map_or((false, false), |expr| check_expression(cx, arg_id, &expr))
         },
         hir::ExprKind::Match(_, arms, _) => {
             let mut found_mapping = false;
diff --git a/clippy_lints/src/minmax.rs b/clippy_lints/src/minmax.rs
index 0a2d577396a..a3d1a500aa7 100644
--- a/clippy_lints/src/minmax.rs
+++ b/clippy_lints/src/minmax.rs
@@ -86,16 +86,19 @@ fn fetch_const<'a>(cx: &LateContext<'_>, args: &'a [Expr<'a>], m: MinMax) -> Opt
     if args.len() != 2 {
         return None;
     }
-    if let Some(c) = constant_simple(cx, cx.tables(), &args[0]) {
-        if constant_simple(cx, cx.tables(), &args[1]).is_none() {
-            // otherwise ignore
-            Some((m, c, &args[1]))
+    constant_simple(cx, cx.tables, &args[0]).map_or_else(
+        || if let Some(c) = constant_simple(cx, cx.tables(), &args[1]) {
+            Some((m, c, &args[0]))
         } else {
             None
+        },
+        |c| {
+            if constant_simple(cx, cx.tables, &args[1]).is_none() {
+                // otherwise ignore
+                Some((c, &args[1]))
+            } else {
+                None
+            }
         }
-    } else if let Some(c) = constant_simple(cx, cx.tables(), &args[1]) {
-        Some((m, c, &args[0]))
-    } else {
-        None
-    }
+    ).map(|(c, arg)| (m, c, arg))
 }
diff --git a/clippy_lints/src/misc.rs b/clippy_lints/src/misc.rs
index 6a256627bd1..5b0f9d6e3ec 100644
--- a/clippy_lints/src/misc.rs
+++ b/clippy_lints/src/misc.rs
@@ -682,16 +682,12 @@ fn check_to_owned(cx: &LateContext<'_>, expr: &Expr<'_>, other: &Expr<'_>, left:
 /// `unused_variables`'s idea
 /// of what it means for an expression to be "used".
 fn is_used(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-    if let Some(parent) = get_parent_expr(cx, expr) {
-        match parent.kind {
+    get_parent_expr(cx, expr).map_or(true, |parent| match parent.kind {
             ExprKind::Assign(_, ref rhs, _) | ExprKind::AssignOp(_, _, ref rhs) => {
                 SpanlessEq::new(cx).eq_expr(rhs, expr)
             },
             _ => is_used(cx, parent),
-        }
-    } else {
-        true
-    }
+        })
 }
 
 /// Tests whether an expression is in a macro expansion (e.g., something
diff --git a/clippy_lints/src/option_if_let_else.rs b/clippy_lints/src/option_if_let_else.rs
index be0c44cae34..b6d08b8ae17 100644
--- a/clippy_lints/src/option_if_let_else.rs
+++ b/clippy_lints/src/option_if_let_else.rs
@@ -37,6 +37,7 @@ declare_clippy_lint! {
     ///
     /// ```rust
     /// # let optional: Option<u32> = Some(0);
+    /// # fn do_complicated_function() -> u32 { 5 };
     /// let _ = if let Some(foo) = optional {
     ///     foo
     /// } else {
@@ -54,9 +55,10 @@ declare_clippy_lint! {
     ///
     /// ```rust
     /// # let optional: Option<u32> = Some(0);
+    /// # fn do_complicated_function() -> u32 { 5 };
     /// let _ = optional.map_or(5, |foo| foo);
     /// let _ = optional.map_or_else(||{
-    ///     let y = do_complicated_function;
+    ///     let y = do_complicated_function();
     ///     y*y
     /// }, |foo| foo);
     /// ```
diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
index 3c939744173..4d54e3117fa 100644
--- a/clippy_lints/src/returns.rs
+++ b/clippy_lints/src/returns.rs
@@ -259,15 +259,10 @@ fn is_unit_expr(expr: &ast::Expr) -> bool {
 
 fn lint_unneeded_unit_return(cx: &EarlyContext<'_>, ty: &ast::Ty, span: Span) {
     let (ret_span, appl) = if let Ok(fn_source) = cx.sess().source_map().span_to_snippet(span.with_hi(ty.span.hi())) {
-        if let Some(rpos) = fn_source.rfind("->") {
-            #[allow(clippy::cast_possible_truncation)]
-            (
+        fn_source.rfind("->").map_or((ty.span, Applicability::MaybeIncorrect), |rpos| (
                 ty.span.with_lo(BytePos(span.lo().0 + rpos as u32)),
                 Applicability::MachineApplicable,
-            )
-        } else {
-            (ty.span, Applicability::MaybeIncorrect)
-        }
+            ))
     } else {
         (ty.span, Applicability::MaybeIncorrect)
     };
diff --git a/clippy_lints/src/shadow.rs b/clippy_lints/src/shadow.rs
index 7da47ee4ff9..de94fb87147 100644
--- a/clippy_lints/src/shadow.rs
+++ b/clippy_lints/src/shadow.rs
@@ -164,15 +164,11 @@ fn check_local<'tcx>(cx: &LateContext<'tcx>, local: &'tcx Local<'_>, bindings: &
 }
 
 fn is_binding(cx: &LateContext<'_>, pat_id: HirId) -> bool {
-    let var_ty = cx.tables().node_type_opt(pat_id);
-    if let Some(var_ty) = var_ty {
-        match var_ty.kind {
+    let var_ty = cx.tables.node_type_opt(pat_id);
+    var_ty.map_or(false, |var_ty| match var_ty.kind {
             ty::Adt(..) => false,
             _ => true,
-        }
-    } else {
-        false
-    }
+        })
 }
 
 fn check_pat<'tcx>(
diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs
index b1345f0de5e..df87c1b9802 100644
--- a/clippy_lints/src/types.rs
+++ b/clippy_lints/src/types.rs
@@ -1205,16 +1205,14 @@ fn span_lossless_lint(cx: &LateContext<'_>, expr: &Expr<'_>, op: &Expr<'_>, cast
     // has parens on the outside, they are no longer needed.
     let mut applicability = Applicability::MachineApplicable;
     let opt = snippet_opt(cx, op.span);
-    let sugg = if let Some(ref snip) = opt {
-        if should_strip_parens(op, snip) {
+    let sugg = opt.as_ref().map_or_else(|| {
+        applicability = Applicability::HasPlaceholders;
+        ".."
+    }, |snip| if should_strip_parens(op, snip) {
             &snip[1..snip.len() - 1]
         } else {
             snip.as_str()
-        }
-    } else {
-        applicability = Applicability::HasPlaceholders;
-        ".."
-    };
+        });
 
     span_lint_and_sugg(
         cx,
diff --git a/clippy_lints/src/use_self.rs b/clippy_lints/src/use_self.rs
index f85db1e2006..eac7ae2358e 100644
--- a/clippy_lints/src/use_self.rs
+++ b/clippy_lints/src/use_self.rs
@@ -167,14 +167,10 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
             if let TyKind::Path(QPath::Resolved(_, ref item_path)) = item_type.kind;
             then {
                 let parameters = &item_path.segments.last().expect(SEGMENTS_MSG).args;
-                let should_check = if let Some(ref params) = *parameters {
-                    !params.parenthesized && !params.args.iter().any(|arg| match arg {
+                let should_check = parameters.as_ref().map_or(true, |params| !params.parenthesized && !params.args.iter().any(|arg| match arg {
                         GenericArg::Lifetime(_) => true,
                         _ => false,
-                    })
-                } else {
-                    true
-                };
+                    }));
 
                 if should_check {
                     let visitor = &mut UseSelfVisitor {
diff --git a/clippy_lints/src/utils/attrs.rs b/clippy_lints/src/utils/attrs.rs
index 4dcf6c105ec..2d72f9c3fe1 100644
--- a/clippy_lints/src/utils/attrs.rs
+++ b/clippy_lints/src/utils/attrs.rs
@@ -65,8 +65,7 @@ pub fn get_attr<'a>(
         };
         let attr_segments = &attr.path.segments;
         if attr_segments.len() == 2 && attr_segments[0].ident.to_string() == "clippy" {
-            if let Some(deprecation_status) =
-                BUILTIN_ATTRIBUTES
+            BUILTIN_ATTRIBUTES
                     .iter()
                     .find_map(|(builtin_name, deprecation_status)| {
                         if *builtin_name == attr_segments[1].ident.to_string() {
@@ -74,8 +73,10 @@ pub fn get_attr<'a>(
                         } else {
                             None
                         }
-                    })
-            {
+                    }).map_or_else(|| {
+                sess.span_err(attr_segments[1].ident.span, "Usage of unknown attribute");
+                false
+            }, |deprecation_status| {
                 let mut diag = sess.struct_span_err(attr_segments[1].ident.span, "Usage of deprecated attribute");
                 match *deprecation_status {
                     DeprecationStatus::Deprecated => {
@@ -97,10 +98,7 @@ pub fn get_attr<'a>(
                         attr_segments[1].ident.to_string() == name
                     },
                 }
-            } else {
-                sess.span_err(attr_segments[1].ident.span, "Usage of unknown attribute");
-                false
-            }
+            })
         } else {
             false
         }
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index 99ba7d64331..6f23e968006 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -153,11 +153,7 @@ pub fn is_type_diagnostic_item(cx: &LateContext<'_>, ty: Ty<'_>, diag_item: Symb
 pub fn match_trait_method(cx: &LateContext<'_>, expr: &Expr<'_>, path: &[&str]) -> bool {
     let def_id = cx.tables().type_dependent_def_id(expr.hir_id).unwrap();
     let trt_id = cx.tcx.trait_of_item(def_id);
-    if let Some(trt_id) = trt_id {
-        match_def_path(cx, trt_id, path)
-    } else {
-        false
-    }
+    trt_id.map_or(false, |trt_id| match_def_path(cx, trt_id, path))
 }
 
 /// Checks if an expression references a variable of the given name.
@@ -600,21 +596,13 @@ pub fn snippet_block_with_applicability<'a, T: LintContext>(
 /// //  ^^^^^^^^^^
 /// ```
 pub fn first_line_of_span<T: LintContext>(cx: &T, span: Span) -> Span {
-    if let Some(first_char_pos) = first_char_in_first_line(cx, span) {
-        span.with_lo(first_char_pos)
-    } else {
-        span
-    }
+    first_char_in_first_line(cx, span).map_or(span, |first_char_pos| span.with_lo(first_char_pos))
 }
 
 fn first_char_in_first_line<T: LintContext>(cx: &T, span: Span) -> Option<BytePos> {
     let line_span = line_span(cx, span);
-    if let Some(snip) = snippet_opt(cx, line_span) {
-        snip.find(|c: char| !c.is_whitespace())
-            .map(|pos| line_span.lo() + BytePos::from_usize(pos))
-    } else {
-        None
-    }
+    snippet_opt(cx, line_span).and_then(|snip| snip.find(|c: char| !c.is_whitespace())
+            .map(|pos| line_span.lo() + BytePos::from_usize(pos)))
 }
 
 /// Returns the indentation of the line of a span
@@ -626,11 +614,7 @@ fn first_char_in_first_line<T: LintContext>(cx: &T, span: Span) -> Option<BytePo
 /// //          ^^ -- will return 4
 /// ```
 pub fn indent_of<T: LintContext>(cx: &T, span: Span) -> Option<usize> {
-    if let Some(snip) = snippet_opt(cx, line_span(cx, span)) {
-        snip.find(|c: char| !c.is_whitespace())
-    } else {
-        None
-    }
+    snippet_opt(cx, line_span(cx, span)).and_then(|snip| snip.find(|c: char| !c.is_whitespace()))
 }
 
 /// Extends the span to the beginning of the spans line, incl. whitespaces.
@@ -738,8 +722,7 @@ pub fn get_enclosing_block<'tcx>(cx: &LateContext<'tcx>, hir_id: HirId) -> Optio
     let enclosing_node = map
         .get_enclosing_scope(hir_id)
         .and_then(|enclosing_id| map.find(enclosing_id));
-    if let Some(node) = enclosing_node {
-        match node {
+    enclosing_node.and_then(|node| match node {
             Node::Block(block) => Some(block),
             Node::Item(&Item {
                 kind: ItemKind::Fn(_, _, eid),
@@ -753,10 +736,7 @@ pub fn get_enclosing_block<'tcx>(cx: &LateContext<'tcx>, hir_id: HirId) -> Optio
                 _ => None,
             },
             _ => None,
-        }
-    } else {
-        None
-    }
+        })
 }
 
 /// Returns the base type for HIR references and pointers.
@@ -1328,11 +1308,7 @@ pub fn is_must_use_func_call(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
         _ => None,
     };
 
-    if let Some(did) = did {
-        must_use_attr(&cx.tcx.get_attrs(did)).is_some()
-    } else {
-        false
-    }
+    did.map_or(false, |did| must_use_attr(&cx.tcx.get_attrs(did)).is_some())
 }
 
 pub fn is_no_std_crate(krate: &Crate<'_>) -> bool {
diff --git a/clippy_lints/src/utils/numeric_literal.rs b/clippy_lints/src/utils/numeric_literal.rs
index 99413153d49..7a79741b30b 100644
--- a/clippy_lints/src/utils/numeric_literal.rs
+++ b/clippy_lints/src/utils/numeric_literal.rs
@@ -200,12 +200,10 @@ impl<'a> NumericLiteral<'a> {
 
 fn split_suffix<'a>(src: &'a str, lit_kind: &LitKind) -> (&'a str, Option<&'a str>) {
     debug_assert!(lit_kind.is_numeric());
-    if let Some(suffix_length) = lit_suffix_length(lit_kind) {
+    lit_suffix_length(lit_kind).map_or((src, None), |suffix_length| {
         let (unsuffixed, suffix) = src.split_at(src.len() - suffix_length);
         (unsuffixed, Some(suffix))
-    } else {
-        (src, None)
-    }
+    })
 }
 
 fn lit_suffix_length(lit_kind: &LitKind) -> Option<usize> {
diff --git a/clippy_lints/src/utils/sugg.rs b/clippy_lints/src/utils/sugg.rs
index 8fc97f2fd64..20bea3cbabe 100644
--- a/clippy_lints/src/utils/sugg.rs
+++ b/clippy_lints/src/utils/sugg.rs
@@ -492,8 +492,7 @@ fn astbinop2assignop(op: ast::BinOp) -> AssocOp {
 /// before it on its line.
 fn indentation<T: LintContext>(cx: &T, span: Span) -> Option<String> {
     let lo = cx.sess().source_map().lookup_char_pos(span.lo());
-    if let Some(line) = lo.file.get_line(lo.line - 1 /* line numbers in `Loc` are 1-based */) {
-        if let Some((pos, _)) = line.char_indices().find(|&(_, c)| c != ' ' && c != '\t') {
+    lo.file.get_line(lo.line - 1 /* line numbers in `Loc` are 1-based */).and_then(|line| if let Some((pos, _)) = line.char_indices().find(|&(_, c)| c != ' ' && c != '\t') {
             // We can mix char and byte positions here because we only consider `[ \t]`.
             if lo.col == CharPos(pos) {
                 Some(line[..pos].into())
@@ -502,10 +501,7 @@ fn indentation<T: LintContext>(cx: &T, span: Span) -> Option<String> {
             }
         } else {
             None
-        }
-    } else {
-        None
-    }
+        })
 }
 
 /// Convenience extension trait for `DiagnosticBuilder`.
diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs
index 732f4b28e06..3b10b7b82a0 100644
--- a/clippy_lints/src/write.rs
+++ b/clippy_lints/src/write.rs
@@ -297,12 +297,10 @@ impl EarlyLintPass for Write {
             if let (Some(fmt_str), expr) = self.check_tts(cx, &mac.args.inner_tokens(), true) {
                 if fmt_str.symbol == Symbol::intern("") {
                     let mut applicability = Applicability::MachineApplicable;
-                    let suggestion = if let Some(e) = expr {
-                        snippet_with_applicability(cx, e.span, "v", &mut applicability)
-                    } else {
+                    let suggestion = expr.map_or_else(|| {
                         applicability = Applicability::HasPlaceholders;
                         Cow::Borrowed("v")
-                    };
+                    }, |e| snippet_with_applicability(cx, e.span, "v", &mut Applicability::MachineApplicable));
 
                     span_lint_and_sugg(
                         cx,
-- 
cgit 1.4.1-3-g733a5


From 93f0f5d37b45c648aebf87fe7e7379599ba3e726 Mon Sep 17 00:00:00 2001
From: JarredAllen <jarredallen73@gmail.com>
Date: Fri, 12 Jun 2020 08:32:38 -0700
Subject: Last few tweaks

---
 CHANGELOG.md                           | 1 -
 clippy_lints/src/lib.rs                | 3 +--
 clippy_lints/src/minmax.rs             | 3 +--
 clippy_lints/src/option_if_let_else.rs | 2 +-
 clippy_lints/src/returns.rs            | 9 +++++++--
 src/lintlist/mod.rs                    | 2 +-
 6 files changed, 11 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 1a081bb85fe..01c0e4b0302 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1491,7 +1491,6 @@ Released 2018-09-13
 [`large_stack_arrays`]: https://rust-lang.github.io/rust-clippy/master/index.html#large_stack_arrays
 [`len_without_is_empty`]: https://rust-lang.github.io/rust-clippy/master/index.html#len_without_is_empty
 [`len_zero`]: https://rust-lang.github.io/rust-clippy/master/index.html#len_zero
-[`let_and_return`]: https://rust-lang.github.io/rust-clippy/master/index.html#let_and_return
 [`let_underscore_lock`]: https://rust-lang.github.io/rust-clippy/master/index.html#let_underscore_lock
 [`let_underscore_must_use`]: https://rust-lang.github.io/rust-clippy/master/index.html#let_underscore_must_use
 [`let_unit_value`]: https://rust-lang.github.io/rust-clippy/master/index.html#let_unit_value
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index cd91e7ceb32..fe34e4390d6 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1161,6 +1161,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&needless_continue::NEEDLESS_CONTINUE),
         LintId::of(&needless_pass_by_value::NEEDLESS_PASS_BY_VALUE),
         LintId::of(&non_expressive_names::SIMILAR_NAMES),
+        LintId::of(&option_if_let_else::OPTION_IF_LET_ELSE),
         LintId::of(&ranges::RANGE_PLUS_ONE),
         LintId::of(&shadow::SHADOW_UNRELATED),
         LintId::of(&strings::STRING_ADD_ASSIGN),
@@ -1372,7 +1373,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&non_expressive_names::MANY_SINGLE_CHAR_NAMES),
         LintId::of(&open_options::NONSENSICAL_OPEN_OPTIONS),
         LintId::of(&option_env_unwrap::OPTION_ENV_UNWRAP),
-        LintId::of(&option_if_let_else::OPTION_IF_LET_ELSE),
         LintId::of(&overflow_check_conditional::OVERFLOW_CHECK_CONDITIONAL),
         LintId::of(&panic_unimplemented::PANIC_PARAMS),
         LintId::of(&partialeq_ne_impl::PARTIALEQ_NE_IMPL),
@@ -1521,7 +1521,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&new_without_default::NEW_WITHOUT_DEFAULT),
         LintId::of(&non_expressive_names::JUST_UNDERSCORES_AND_DIGITS),
         LintId::of(&non_expressive_names::MANY_SINGLE_CHAR_NAMES),
-        LintId::of(&option_if_let_else::OPTION_IF_LET_ELSE),
         LintId::of(&panic_unimplemented::PANIC_PARAMS),
         LintId::of(&ptr::CMP_NULL),
         LintId::of(&ptr::PTR_ARG),
diff --git a/clippy_lints/src/minmax.rs b/clippy_lints/src/minmax.rs
index a3d1a500aa7..6ec7f8cae5d 100644
--- a/clippy_lints/src/minmax.rs
+++ b/clippy_lints/src/minmax.rs
@@ -99,6 +99,5 @@ fn fetch_const<'a>(cx: &LateContext<'_>, args: &'a [Expr<'a>], m: MinMax) -> Opt
             } else {
                 None
             }
-        }
-    ).map(|(c, arg)| (m, c, arg))
+    })
 }
diff --git a/clippy_lints/src/option_if_let_else.rs b/clippy_lints/src/option_if_let_else.rs
index b6d08b8ae17..c877cc6fa8b 100644
--- a/clippy_lints/src/option_if_let_else.rs
+++ b/clippy_lints/src/option_if_let_else.rs
@@ -63,7 +63,7 @@ declare_clippy_lint! {
     /// }, |foo| foo);
     /// ```
     pub OPTION_IF_LET_ELSE,
-    style,
+    pedantic,
     "reimplementation of Option::map_or"
 }
 
diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
index 4d54e3117fa..3c939744173 100644
--- a/clippy_lints/src/returns.rs
+++ b/clippy_lints/src/returns.rs
@@ -259,10 +259,15 @@ fn is_unit_expr(expr: &ast::Expr) -> bool {
 
 fn lint_unneeded_unit_return(cx: &EarlyContext<'_>, ty: &ast::Ty, span: Span) {
     let (ret_span, appl) = if let Ok(fn_source) = cx.sess().source_map().span_to_snippet(span.with_hi(ty.span.hi())) {
-        fn_source.rfind("->").map_or((ty.span, Applicability::MaybeIncorrect), |rpos| (
+        if let Some(rpos) = fn_source.rfind("->") {
+            #[allow(clippy::cast_possible_truncation)]
+            (
                 ty.span.with_lo(BytePos(span.lo().0 + rpos as u32)),
                 Applicability::MachineApplicable,
-            ))
+            )
+        } else {
+            (ty.span, Applicability::MaybeIncorrect)
+        }
     } else {
         (ty.span, Applicability::MaybeIncorrect)
     };
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index b499d565fa7..e681f47f949 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -1622,7 +1622,7 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
     },
     Lint {
         name: "option_if_let_else",
-        group: "style",
+        group: "pedantic",
         desc: "reimplementation of Option::map_or",
         deprecation: None,
         module: "option_if_let_else",
-- 
cgit 1.4.1-3-g733a5


From ccb999851aaa4d3e9cd97110bd6523a6c3df46fd Mon Sep 17 00:00:00 2001
From: JarredAllen <jarredallen73@gmail.com>
Date: Thu, 25 Jun 2020 11:39:58 -0700
Subject: Fix compile error from library change

---
 CHANGELOG.md                           | 1 +
 clippy_lints/src/option_if_let_else.rs | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 01c0e4b0302..1a081bb85fe 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1491,6 +1491,7 @@ Released 2018-09-13
 [`large_stack_arrays`]: https://rust-lang.github.io/rust-clippy/master/index.html#large_stack_arrays
 [`len_without_is_empty`]: https://rust-lang.github.io/rust-clippy/master/index.html#len_without_is_empty
 [`len_zero`]: https://rust-lang.github.io/rust-clippy/master/index.html#len_zero
+[`let_and_return`]: https://rust-lang.github.io/rust-clippy/master/index.html#let_and_return
 [`let_underscore_lock`]: https://rust-lang.github.io/rust-clippy/master/index.html#let_underscore_lock
 [`let_underscore_must_use`]: https://rust-lang.github.io/rust-clippy/master/index.html#let_underscore_must_use
 [`let_unit_value`]: https://rust-lang.github.io/rust-clippy/master/index.html#let_unit_value
diff --git a/clippy_lints/src/option_if_let_else.rs b/clippy_lints/src/option_if_let_else.rs
index c877cc6fa8b..7e299dd5fd9 100644
--- a/clippy_lints/src/option_if_let_else.rs
+++ b/clippy_lints/src/option_if_let_else.rs
@@ -71,7 +71,7 @@ declare_lint_pass!(OptionIfLetElse => [OPTION_IF_LET_ELSE]);
 
 /// Returns true iff the given expression is the result of calling `Result::ok`
 fn is_result_ok(cx: &LateContext<'_, '_>, expr: &'_ Expr<'_>) -> bool {
-    if let ExprKind::MethodCall(ref path, _, &[ref receiver]) = &expr.kind {
+    if let ExprKind::MethodCall(ref path, _, &[ref receiver], _) = &expr.kind {
         path.ident.name.to_ident_string() == "ok" && match_type(cx, &cx.tables.expr_ty(&receiver), &paths::RESULT)
     } else {
         false
-- 
cgit 1.4.1-3-g733a5


From 6ce981225b73d6c3514b0abb759a5282521a17d9 Mon Sep 17 00:00:00 2001
From: JarredAllen <jarredallen73@gmail.com>
Date: Thu, 25 Jun 2020 11:58:47 -0700
Subject: Clean existing lint code to match new lint

---
 clippy_lints/src/attrs.rs                          | 14 +++--
 clippy_lints/src/if_let_mutex.rs                   |  5 +-
 clippy_lints/src/len_zero.rs                       | 12 ++--
 clippy_lints/src/literal_representation.rs         | 10 ++--
 clippy_lints/src/loops.rs                          | 20 ++++---
 clippy_lints/src/methods/mod.rs                    |  6 +-
 clippy_lints/src/methods/unnecessary_filter_map.rs |  7 ++-
 clippy_lints/src/minmax.rs                         |  2 +-
 clippy_lints/src/misc.rs                           |  8 +--
 clippy_lints/src/option_if_let_else.rs             |  2 +-
 clippy_lints/src/returns.rs                        | 18 +++---
 clippy_lints/src/shadow.rs                         |  6 +-
 clippy_lints/src/types.rs                          | 21 ++++---
 clippy_lints/src/use_self.rs                       |  7 ++-
 clippy_lints/src/utils/attrs.rs                    | 65 ++++++++++++----------
 clippy_lints/src/utils/mod.rs                      | 32 ++++++-----
 clippy_lints/src/utils/sugg.rs                     | 16 ++++--
 clippy_lints/src/write.rs                          | 11 ++--
 18 files changed, 147 insertions(+), 115 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs
index cfad9d79f2b..c4397560d7d 100644
--- a/clippy_lints/src/attrs.rs
+++ b/clippy_lints/src/attrs.rs
@@ -480,12 +480,15 @@ fn is_relevant_trait(cx: &LateContext<'_>, item: &TraitItem<'_>) -> bool {
     }
 }
 
-fn is_relevant_block(cx: &LateContext<'_>, tables: &ty::TypeckTables<'_>, block: &Block<'_>) -> bool {
-    block.stmts.first().map_or(block.expr.as_ref().map_or(false, |e| is_relevant_expr(cx, tables, e)), |stmt| match &stmt.kind {
+fn is_relevant_block(cx: &LateContext<'_, '_>, tables: &ty::TypeckTables<'_>, block: &Block<'_>) -> bool {
+    block.stmts.first().map_or(
+        block.expr.as_ref().map_or(false, |e| is_relevant_expr(cx, tables, e)),
+        |stmt| match &stmt.kind {
             StmtKind::Local(_) => true,
             StmtKind::Expr(expr) | StmtKind::Semi(expr) => is_relevant_expr(cx, tables, expr),
             _ => false,
-        })
+        },
+    )
 }
 
 fn is_relevant_expr(cx: &LateContext<'_>, tables: &ty::TypeckTables<'_>, expr: &Expr<'_>) -> bool {
@@ -495,7 +498,10 @@ fn is_relevant_expr(cx: &LateContext<'_>, tables: &ty::TypeckTables<'_>, expr: &
         ExprKind::Ret(None) | ExprKind::Break(_, None) => false,
         ExprKind::Call(path_expr, _) => {
             if let ExprKind::Path(qpath) = &path_expr.kind {
-                tables.qpath_res(qpath, path_expr.hir_id).opt_def_id().map_or(true, |fun_id| !match_def_path(cx, fun_id, &paths::BEGIN_PANIC))
+                tables
+                    .qpath_res(qpath, path_expr.hir_id)
+                    .opt_def_id()
+                    .map_or(true, |fun_id| !match_def_path(cx, fun_id, &paths::BEGIN_PANIC))
             } else {
                 true
             }
diff --git a/clippy_lints/src/if_let_mutex.rs b/clippy_lints/src/if_let_mutex.rs
index 7e44618e90e..5426e14ead5 100644
--- a/clippy_lints/src/if_let_mutex.rs
+++ b/clippy_lints/src/if_let_mutex.rs
@@ -136,8 +136,9 @@ impl<'tcx> Visitor<'tcx> for ArmVisitor<'_, 'tcx> {
 }
 
 impl<'tcx, 'l> ArmVisitor<'tcx, 'l> {
-    fn same_mutex(&self, cx: &LateContext<'_>, op_mutex: &Expr<'_>) -> bool {
-        self.found_mutex.map_or(false, |arm_mutex| SpanlessEq::new(cx).eq_expr(op_mutex, arm_mutex))
+    fn same_mutex(&self, cx: &LateContext<'_, '_>, op_mutex: &Expr<'_>) -> bool {
+        self.found_mutex
+            .map_or(false, |arm_mutex| SpanlessEq::new(cx).eq_expr(op_mutex, arm_mutex))
     }
 }
 
diff --git a/clippy_lints/src/len_zero.rs b/clippy_lints/src/len_zero.rs
index f57fa830adc..1b09328ceab 100644
--- a/clippy_lints/src/len_zero.rs
+++ b/clippy_lints/src/len_zero.rs
@@ -302,12 +302,12 @@ fn has_is_empty(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
 
     let ty = &walk_ptrs_ty(cx.tables().expr_ty(expr));
     match ty.kind {
-        ty::Dynamic(ref tt, ..) => {
-            tt.principal().map_or(false, |principal| cx.tcx
-                    .associated_items(principal.def_id())
-                    .in_definition_order()
-                    .any(|item| is_is_empty(cx, &item)))
-        },
+        ty::Dynamic(ref tt, ..) => tt.principal().map_or(false, |principal| {
+            cx.tcx
+                .associated_items(principal.def_id())
+                .in_definition_order()
+                .any(|item| is_is_empty(cx, &item))
+        }),
         ty::Projection(ref proj) => has_is_empty_impl(cx, proj.item_def_id),
         ty::Adt(id, _) => has_is_empty_impl(cx, id.did),
         ty::Array(..) | ty::Slice(..) | ty::Str => true,
diff --git a/clippy_lints/src/literal_representation.rs b/clippy_lints/src/literal_representation.rs
index ea2e23bd3a1..a36fdca5d5d 100644
--- a/clippy_lints/src/literal_representation.rs
+++ b/clippy_lints/src/literal_representation.rs
@@ -265,10 +265,12 @@ impl LiteralDigitGrouping {
         let (part, mistyped_suffixes, missing_char) = if let Some((_, exponent)) = &mut num_lit.exponent {
             (exponent, &["32", "64"][..], 'f')
         } else {
-            num_lit.fraction.as_mut().map_or(
-                (&mut num_lit.integer, &["8", "16", "32", "64"][..], 'i'),
-                |fraction| (fraction, &["32", "64"][..], 'f')
-            )
+            num_lit
+                .fraction
+                .as_mut()
+                .map_or((&mut num_lit.integer, &["8", "16", "32", "64"][..], 'i'), |fraction| {
+                    (fraction, &["32", "64"][..], 'f')
+                })
         };
 
         let mut split = part.rsplit('_');
diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 8d48f39a045..b803d753b6d 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -686,9 +686,9 @@ fn never_loop_expr(expr: &Expr<'_>, main_loop_id: HirId) -> NeverLoopResult {
                 NeverLoopResult::AlwaysBreak
             }
         },
-        ExprKind::Break(_, ref e) | ExprKind::Ret(ref e) => {
-            e.as_ref().map_or(NeverLoopResult::AlwaysBreak, |e| combine_seq(never_loop_expr(e, main_loop_id), NeverLoopResult::AlwaysBreak))
-        },
+        ExprKind::Break(_, ref e) | ExprKind::Ret(ref e) => e.as_ref().map_or(NeverLoopResult::AlwaysBreak, |e| {
+            combine_seq(never_loop_expr(e, main_loop_id), NeverLoopResult::AlwaysBreak)
+        }),
         ExprKind::InlineAsm(ref asm) => asm
             .operands
             .iter()
@@ -1877,9 +1877,9 @@ fn is_ref_iterable_type(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
 fn is_iterable_array<'tcx>(ty: Ty<'tcx>, cx: &LateContext<'tcx>) -> bool {
     // IntoIterator is currently only implemented for array sizes <= 32 in rustc
     match ty.kind {
-        ty::Array(_, n) => {
-            n.try_eval_usize(cx.tcx, cx.param_env).map_or(false, |val| (0..=32).contains(&val))
-        },
+        ty::Array(_, n) => n
+            .try_eval_usize(cx.tcx, cx.param_env)
+            .map_or(false, |val| (0..=32).contains(&val)),
         _ => false,
     }
 }
@@ -1891,7 +1891,7 @@ fn extract_expr_from_first_stmt<'tcx>(block: &Block<'tcx>) -> Option<&'tcx Expr<
         return None;
     }
     if let StmtKind::Local(ref local) = block.stmts[0].kind {
-        local.init.map(|expr| expr)
+        local.init //.map(|expr| expr)
     } else {
         None
     }
@@ -2011,11 +2011,13 @@ impl<'a, 'tcx> Visitor<'tcx> for InitializeVisitor<'a, 'tcx> {
                 if let PatKind::Binding(.., ident, _) = local.pat.kind {
                     self.name = Some(ident.name);
 
-                    self.state = local.init.as_ref().map_or(VarState::Declared, |init| if is_integer_const(&self.cx, init, 0) {
+                    self.state = local.init.as_ref().map_or(VarState::Declared, |init| {
+                        if is_integer_const(&self.cx, init, 0) {
                             VarState::Warn
                         } else {
                             VarState::Declared
-                        })
+                        }
+                    })
                 }
             }
         }
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index ddad16e163e..f1c8894c0ee 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -2460,9 +2460,9 @@ fn derefs_to_slice<'tcx>(
             ty::Slice(_) => true,
             ty::Adt(def, _) if def.is_box() => may_slice(cx, ty.boxed_ty()),
             ty::Adt(..) => is_type_diagnostic_item(cx, ty, sym!(vec_type)),
-            ty::Array(_, size) => {
-                size.try_eval_usize(cx.tcx, cx.param_env).map_or(false, |size| size < 32)
-            },
+            ty::Array(_, size) => size
+                .try_eval_usize(cx.tcx, cx.param_env)
+                .map_or(false, |size| size < 32),
             ty::Ref(_, inner, _) => may_slice(cx, inner),
             _ => false,
         }
diff --git a/clippy_lints/src/methods/unnecessary_filter_map.rs b/clippy_lints/src/methods/unnecessary_filter_map.rs
index 97909c97fc7..75e123eb593 100644
--- a/clippy_lints/src/methods/unnecessary_filter_map.rs
+++ b/clippy_lints/src/methods/unnecessary_filter_map.rs
@@ -77,9 +77,10 @@ fn check_expression<'tcx>(cx: &LateContext<'tcx>, arg_id: hir::HirId, expr: &'tc
             }
             (true, true)
         },
-        hir::ExprKind::Block(ref block, _) => {
-            block.expr.as_ref().map_or((false, false), |expr| check_expression(cx, arg_id, &expr))
-        },
+        hir::ExprKind::Block(ref block, _) => block
+            .expr
+            .as_ref()
+            .map_or((false, false), |expr| check_expression(cx, arg_id, &expr)),
         hir::ExprKind::Match(_, arms, _) => {
             let mut found_mapping = false;
             let mut found_filtering = false;
diff --git a/clippy_lints/src/minmax.rs b/clippy_lints/src/minmax.rs
index 6ec7f8cae5d..5eb8398d68e 100644
--- a/clippy_lints/src/minmax.rs
+++ b/clippy_lints/src/minmax.rs
@@ -53,7 +53,7 @@ impl<'tcx> LateLintPass<'tcx> for MinMaxPass {
     }
 }
 
-#[derive(PartialEq, Eq, Debug)]
+#[derive(PartialEq, Eq, Debug, Clone, Copy)]
 enum MinMax {
     Min,
     Max,
diff --git a/clippy_lints/src/misc.rs b/clippy_lints/src/misc.rs
index 5b0f9d6e3ec..3d4225f36a7 100644
--- a/clippy_lints/src/misc.rs
+++ b/clippy_lints/src/misc.rs
@@ -683,11 +683,9 @@ fn check_to_owned(cx: &LateContext<'_>, expr: &Expr<'_>, other: &Expr<'_>, left:
 /// of what it means for an expression to be "used".
 fn is_used(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
     get_parent_expr(cx, expr).map_or(true, |parent| match parent.kind {
-            ExprKind::Assign(_, ref rhs, _) | ExprKind::AssignOp(_, _, ref rhs) => {
-                SpanlessEq::new(cx).eq_expr(rhs, expr)
-            },
-            _ => is_used(cx, parent),
-        })
+        ExprKind::Assign(_, ref rhs, _) | ExprKind::AssignOp(_, _, ref rhs) => SpanlessEq::new(cx).eq_expr(rhs, expr),
+        _ => is_used(cx, parent),
+    })
 }
 
 /// Tests whether an expression is in a macro expansion (e.g., something
diff --git a/clippy_lints/src/option_if_let_else.rs b/clippy_lints/src/option_if_let_else.rs
index 7e299dd5fd9..ab9ea76a838 100644
--- a/clippy_lints/src/option_if_let_else.rs
+++ b/clippy_lints/src/option_if_let_else.rs
@@ -260,7 +260,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for OptionIfLetElse {
                     detection.some_expr,
                     if detection.wrap_braces { " }" } else { "" },
                 ),
-                Applicability::MachineApplicable,
+                Applicability::MaybeIncorrect,
             );
         }
     }
diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
index 3c939744173..faef7e724dd 100644
--- a/clippy_lints/src/returns.rs
+++ b/clippy_lints/src/returns.rs
@@ -259,15 +259,15 @@ fn is_unit_expr(expr: &ast::Expr) -> bool {
 
 fn lint_unneeded_unit_return(cx: &EarlyContext<'_>, ty: &ast::Ty, span: Span) {
     let (ret_span, appl) = if let Ok(fn_source) = cx.sess().source_map().span_to_snippet(span.with_hi(ty.span.hi())) {
-        if let Some(rpos) = fn_source.rfind("->") {
-            #[allow(clippy::cast_possible_truncation)]
-            (
-                ty.span.with_lo(BytePos(span.lo().0 + rpos as u32)),
-                Applicability::MachineApplicable,
-            )
-        } else {
-            (ty.span, Applicability::MaybeIncorrect)
-        }
+        fn_source
+            .rfind("->")
+            .map_or((ty.span, Applicability::MaybeIncorrect), |rpos| {
+                (
+                    #[allow(clippy::cast_possible_truncation)]
+                    ty.span.with_lo(BytePos(span.lo().0 + rpos as u32)),
+                    Applicability::MachineApplicable,
+                )
+            })
     } else {
         (ty.span, Applicability::MaybeIncorrect)
     };
diff --git a/clippy_lints/src/shadow.rs b/clippy_lints/src/shadow.rs
index de94fb87147..f16db2df3a9 100644
--- a/clippy_lints/src/shadow.rs
+++ b/clippy_lints/src/shadow.rs
@@ -166,9 +166,9 @@ fn check_local<'tcx>(cx: &LateContext<'tcx>, local: &'tcx Local<'_>, bindings: &
 fn is_binding(cx: &LateContext<'_>, pat_id: HirId) -> bool {
     let var_ty = cx.tables.node_type_opt(pat_id);
     var_ty.map_or(false, |var_ty| match var_ty.kind {
-            ty::Adt(..) => false,
-            _ => true,
-        })
+        ty::Adt(..) => false,
+        _ => true,
+    })
 }
 
 fn check_pat<'tcx>(
diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs
index df87c1b9802..d6f31a99bb3 100644
--- a/clippy_lints/src/types.rs
+++ b/clippy_lints/src/types.rs
@@ -1205,14 +1205,19 @@ fn span_lossless_lint(cx: &LateContext<'_>, expr: &Expr<'_>, op: &Expr<'_>, cast
     // has parens on the outside, they are no longer needed.
     let mut applicability = Applicability::MachineApplicable;
     let opt = snippet_opt(cx, op.span);
-    let sugg = opt.as_ref().map_or_else(|| {
-        applicability = Applicability::HasPlaceholders;
-        ".."
-    }, |snip| if should_strip_parens(op, snip) {
-            &snip[1..snip.len() - 1]
-        } else {
-            snip.as_str()
-        });
+    let sugg = opt.as_ref().map_or_else(
+        || {
+            applicability = Applicability::HasPlaceholders;
+            ".."
+        },
+        |snip| {
+            if should_strip_parens(op, snip) {
+                &snip[1..snip.len() - 1]
+            } else {
+                snip.as_str()
+            }
+        },
+    );
 
     span_lint_and_sugg(
         cx,
diff --git a/clippy_lints/src/use_self.rs b/clippy_lints/src/use_self.rs
index eac7ae2358e..39a8c020872 100644
--- a/clippy_lints/src/use_self.rs
+++ b/clippy_lints/src/use_self.rs
@@ -167,10 +167,13 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
             if let TyKind::Path(QPath::Resolved(_, ref item_path)) = item_type.kind;
             then {
                 let parameters = &item_path.segments.last().expect(SEGMENTS_MSG).args;
-                let should_check = parameters.as_ref().map_or(true, |params| !params.parenthesized && !params.args.iter().any(|arg| match arg {
+                let should_check = parameters.as_ref().map_or(
+                    true,
+                    |params| !params.parenthesized && !params.args.iter().any(|arg| match arg {
                         GenericArg::Lifetime(_) => true,
                         _ => false,
-                    }));
+                    })
+                );
 
                 if should_check {
                     let visitor = &mut UseSelfVisitor {
diff --git a/clippy_lints/src/utils/attrs.rs b/clippy_lints/src/utils/attrs.rs
index 2d72f9c3fe1..4bb4b087c55 100644
--- a/clippy_lints/src/utils/attrs.rs
+++ b/clippy_lints/src/utils/attrs.rs
@@ -66,39 +66,44 @@ pub fn get_attr<'a>(
         let attr_segments = &attr.path.segments;
         if attr_segments.len() == 2 && attr_segments[0].ident.to_string() == "clippy" {
             BUILTIN_ATTRIBUTES
-                    .iter()
-                    .find_map(|(builtin_name, deprecation_status)| {
-                        if *builtin_name == attr_segments[1].ident.to_string() {
-                            Some(deprecation_status)
-                        } else {
-                            None
-                        }
-                    }).map_or_else(|| {
-                sess.span_err(attr_segments[1].ident.span, "Usage of unknown attribute");
-                false
-            }, |deprecation_status| {
-                let mut diag = sess.struct_span_err(attr_segments[1].ident.span, "Usage of deprecated attribute");
-                match *deprecation_status {
-                    DeprecationStatus::Deprecated => {
-                        diag.emit();
-                        false
-                    },
-                    DeprecationStatus::Replaced(new_name) => {
-                        diag.span_suggestion(
-                            attr_segments[1].ident.span,
-                            "consider using",
-                            new_name.to_string(),
-                            Applicability::MachineApplicable,
-                        );
-                        diag.emit();
+                .iter()
+                .find_map(|(builtin_name, deprecation_status)| {
+                    if *builtin_name == attr_segments[1].ident.to_string() {
+                        Some(deprecation_status)
+                    } else {
+                        None
+                    }
+                })
+                .map_or_else(
+                    || {
+                        sess.span_err(attr_segments[1].ident.span, "Usage of unknown attribute");
                         false
                     },
-                    DeprecationStatus::None => {
-                        diag.cancel();
-                        attr_segments[1].ident.to_string() == name
+                    |deprecation_status| {
+                        let mut diag =
+                            sess.struct_span_err(attr_segments[1].ident.span, "Usage of deprecated attribute");
+                        match *deprecation_status {
+                            DeprecationStatus::Deprecated => {
+                                diag.emit();
+                                false
+                            },
+                            DeprecationStatus::Replaced(new_name) => {
+                                diag.span_suggestion(
+                                    attr_segments[1].ident.span,
+                                    "consider using",
+                                    new_name.to_string(),
+                                    Applicability::MachineApplicable,
+                                );
+                                diag.emit();
+                                false
+                            },
+                            DeprecationStatus::None => {
+                                diag.cancel();
+                                attr_segments[1].ident.to_string() == name
+                            },
+                        }
                     },
-                }
-            })
+                )
         } else {
             false
         }
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index 6f23e968006..3a3b79925ff 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -601,8 +601,10 @@ pub fn first_line_of_span<T: LintContext>(cx: &T, span: Span) -> Span {
 
 fn first_char_in_first_line<T: LintContext>(cx: &T, span: Span) -> Option<BytePos> {
     let line_span = line_span(cx, span);
-    snippet_opt(cx, line_span).and_then(|snip| snip.find(|c: char| !c.is_whitespace())
-            .map(|pos| line_span.lo() + BytePos::from_usize(pos)))
+    snippet_opt(cx, line_span).and_then(|snip| {
+        snip.find(|c: char| !c.is_whitespace())
+            .map(|pos| line_span.lo() + BytePos::from_usize(pos))
+    })
 }
 
 /// Returns the indentation of the line of a span
@@ -723,20 +725,20 @@ pub fn get_enclosing_block<'tcx>(cx: &LateContext<'tcx>, hir_id: HirId) -> Optio
         .get_enclosing_scope(hir_id)
         .and_then(|enclosing_id| map.find(enclosing_id));
     enclosing_node.and_then(|node| match node {
-            Node::Block(block) => Some(block),
-            Node::Item(&Item {
-                kind: ItemKind::Fn(_, _, eid),
-                ..
-            })
-            | Node::ImplItem(&ImplItem {
-                kind: ImplItemKind::Fn(_, eid),
-                ..
-            }) => match cx.tcx.hir().body(eid).value.kind {
-                ExprKind::Block(ref block, _) => Some(block),
-                _ => None,
-            },
-            _ => None,
+        Node::Block(block) => Some(block),
+        Node::Item(&Item {
+            kind: ItemKind::Fn(_, _, eid),
+            ..
         })
+        | Node::ImplItem(&ImplItem {
+            kind: ImplItemKind::Fn(_, eid),
+            ..
+        }) => match cx.tcx.hir().body(eid).value.kind {
+            ExprKind::Block(ref block, _) => Some(block),
+            _ => None,
+        },
+        _ => None,
+    })
 }
 
 /// Returns the base type for HIR references and pointers.
diff --git a/clippy_lints/src/utils/sugg.rs b/clippy_lints/src/utils/sugg.rs
index 20bea3cbabe..0ac7714fbeb 100644
--- a/clippy_lints/src/utils/sugg.rs
+++ b/clippy_lints/src/utils/sugg.rs
@@ -492,15 +492,19 @@ fn astbinop2assignop(op: ast::BinOp) -> AssocOp {
 /// before it on its line.
 fn indentation<T: LintContext>(cx: &T, span: Span) -> Option<String> {
     let lo = cx.sess().source_map().lookup_char_pos(span.lo());
-    lo.file.get_line(lo.line - 1 /* line numbers in `Loc` are 1-based */).and_then(|line| if let Some((pos, _)) = line.char_indices().find(|&(_, c)| c != ' ' && c != '\t') {
-            // We can mix char and byte positions here because we only consider `[ \t]`.
-            if lo.col == CharPos(pos) {
-                Some(line[..pos].into())
+    lo.file
+        .get_line(lo.line - 1 /* line numbers in `Loc` are 1-based */)
+        .and_then(|line| {
+            if let Some((pos, _)) = line.char_indices().find(|&(_, c)| c != ' ' && c != '\t') {
+                // We can mix char and byte positions here because we only consider `[ \t]`.
+                if lo.col == CharPos(pos) {
+                    Some(line[..pos].into())
+                } else {
+                    None
+                }
             } else {
                 None
             }
-        } else {
-            None
         })
 }
 
diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs
index 3b10b7b82a0..063f94582b9 100644
--- a/clippy_lints/src/write.rs
+++ b/clippy_lints/src/write.rs
@@ -297,10 +297,13 @@ impl EarlyLintPass for Write {
             if let (Some(fmt_str), expr) = self.check_tts(cx, &mac.args.inner_tokens(), true) {
                 if fmt_str.symbol == Symbol::intern("") {
                     let mut applicability = Applicability::MachineApplicable;
-                    let suggestion = expr.map_or_else(|| {
-                        applicability = Applicability::HasPlaceholders;
-                        Cow::Borrowed("v")
-                    }, |e| snippet_with_applicability(cx, e.span, "v", &mut Applicability::MachineApplicable));
+                    let suggestion = expr.map_or_else(
+                        || {
+                            applicability = Applicability::HasPlaceholders;
+                            Cow::Borrowed("v")
+                        },
+                        |e| snippet_with_applicability(cx, e.span, "v", &mut Applicability::MachineApplicable),
+                    );
 
                     span_lint_and_sugg(
                         cx,
-- 
cgit 1.4.1-3-g733a5


From 1c32263176d95ae47928d1955e44a4315ffcea2d Mon Sep 17 00:00:00 2001
From: JarredAllen <jarredallen73@gmail.com>
Date: Wed, 1 Jul 2020 11:41:11 -0700
Subject: Formatted updates to lints

---
 clippy_lints/src/minmax.rs | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/minmax.rs b/clippy_lints/src/minmax.rs
index 5eb8398d68e..2e5f5f10f4b 100644
--- a/clippy_lints/src/minmax.rs
+++ b/clippy_lints/src/minmax.rs
@@ -87,10 +87,12 @@ fn fetch_const<'a>(cx: &LateContext<'_>, args: &'a [Expr<'a>], m: MinMax) -> Opt
         return None;
     }
     constant_simple(cx, cx.tables, &args[0]).map_or_else(
-        || if let Some(c) = constant_simple(cx, cx.tables(), &args[1]) {
-            Some((m, c, &args[0]))
-        } else {
-            None
+        || {
+            if let Some(c) = constant_simple(cx, cx.tables(), &args[1]) {
+                Some((m, c, &args[0]))
+            } else {
+                None
+            }
         },
         |c| {
             if constant_simple(cx, cx.tables, &args[1]).is_none() {
@@ -99,5 +101,6 @@ fn fetch_const<'a>(cx: &LateContext<'_>, args: &'a [Expr<'a>], m: MinMax) -> Opt
             } else {
                 None
             }
-    })
+        },
+    )
 }
-- 
cgit 1.4.1-3-g733a5


From c8f700ea697f74ef8f86891b050c859cf457e3ab Mon Sep 17 00:00:00 2001
From: JarredAllen <jarredallen73@gmail.com>
Date: Fri, 3 Jul 2020 20:28:40 -0700
Subject: Fixed compile errors

---
 clippy_lints/src/attrs.rs              |  2 +-
 clippy_lints/src/if_let_mutex.rs       |  2 +-
 clippy_lints/src/minmax.rs             | 14 ++++----------
 clippy_lints/src/option_if_let_else.rs | 14 +++++++-------
 clippy_lints/src/shadow.rs             |  2 +-
 5 files changed, 14 insertions(+), 20 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs
index c4397560d7d..d68d0d8ccf5 100644
--- a/clippy_lints/src/attrs.rs
+++ b/clippy_lints/src/attrs.rs
@@ -480,7 +480,7 @@ fn is_relevant_trait(cx: &LateContext<'_>, item: &TraitItem<'_>) -> bool {
     }
 }
 
-fn is_relevant_block(cx: &LateContext<'_, '_>, tables: &ty::TypeckTables<'_>, block: &Block<'_>) -> bool {
+fn is_relevant_block(cx: &LateContext<'_>, tables: &ty::TypeckTables<'_>, block: &Block<'_>) -> bool {
     block.stmts.first().map_or(
         block.expr.as_ref().map_or(false, |e| is_relevant_expr(cx, tables, e)),
         |stmt| match &stmt.kind {
diff --git a/clippy_lints/src/if_let_mutex.rs b/clippy_lints/src/if_let_mutex.rs
index 5426e14ead5..fbd2eeacc6e 100644
--- a/clippy_lints/src/if_let_mutex.rs
+++ b/clippy_lints/src/if_let_mutex.rs
@@ -136,7 +136,7 @@ impl<'tcx> Visitor<'tcx> for ArmVisitor<'_, 'tcx> {
 }
 
 impl<'tcx, 'l> ArmVisitor<'tcx, 'l> {
-    fn same_mutex(&self, cx: &LateContext<'_, '_>, op_mutex: &Expr<'_>) -> bool {
+    fn same_mutex(&self, cx: &LateContext<'_>, op_mutex: &Expr<'_>) -> bool {
         self.found_mutex
             .map_or(false, |arm_mutex| SpanlessEq::new(cx).eq_expr(op_mutex, arm_mutex))
     }
diff --git a/clippy_lints/src/minmax.rs b/clippy_lints/src/minmax.rs
index 2e5f5f10f4b..c8aa98d3489 100644
--- a/clippy_lints/src/minmax.rs
+++ b/clippy_lints/src/minmax.rs
@@ -86,18 +86,12 @@ fn fetch_const<'a>(cx: &LateContext<'_>, args: &'a [Expr<'a>], m: MinMax) -> Opt
     if args.len() != 2 {
         return None;
     }
-    constant_simple(cx, cx.tables, &args[0]).map_or_else(
-        || {
-            if let Some(c) = constant_simple(cx, cx.tables(), &args[1]) {
-                Some((m, c, &args[0]))
-            } else {
-                None
-            }
-        },
+    constant_simple(cx, cx.tables(), &args[0]).map_or_else(
+        || constant_simple(cx, cx.tables(), &args[1]).map(|c| (m, c, &args[0])),
         |c| {
-            if constant_simple(cx, cx.tables, &args[1]).is_none() {
+            if constant_simple(cx, cx.tables(), &args[1]).is_none() {
                 // otherwise ignore
-                Some((c, &args[1]))
+                Some((m, c, &args[1]))
             } else {
                 None
             }
diff --git a/clippy_lints/src/option_if_let_else.rs b/clippy_lints/src/option_if_let_else.rs
index ab9ea76a838..8dbe58763bf 100644
--- a/clippy_lints/src/option_if_let_else.rs
+++ b/clippy_lints/src/option_if_let_else.rs
@@ -70,9 +70,9 @@ declare_clippy_lint! {
 declare_lint_pass!(OptionIfLetElse => [OPTION_IF_LET_ELSE]);
 
 /// Returns true iff the given expression is the result of calling `Result::ok`
-fn is_result_ok(cx: &LateContext<'_, '_>, expr: &'_ Expr<'_>) -> bool {
+fn is_result_ok(cx: &LateContext<'_>, expr: &'_ Expr<'_>) -> bool {
     if let ExprKind::MethodCall(ref path, _, &[ref receiver], _) = &expr.kind {
-        path.ident.name.to_ident_string() == "ok" && match_type(cx, &cx.tables.expr_ty(&receiver), &paths::RESULT)
+        path.ident.name.to_ident_string() == "ok" && match_type(cx, &cx.tables().expr_ty(&receiver), &paths::RESULT)
     } else {
         false
     }
@@ -157,7 +157,7 @@ fn extract_body_from_arm<'a>(arm: &'a Arm<'a>) -> Option<&'a Expr<'a>> {
 
 /// If this is the else body of an if/else expression, then we need to wrap
 /// it in curcly braces. Otherwise, we don't.
-fn should_wrap_in_braces(cx: &LateContext<'_, '_>, expr: &Expr<'_>) -> bool {
+fn should_wrap_in_braces(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
     utils::get_enclosing_block(cx, expr.hir_id).map_or(false, |parent| {
         if let Some(Expr {
             kind:
@@ -181,7 +181,7 @@ fn should_wrap_in_braces(cx: &LateContext<'_, '_>, expr: &Expr<'_>) -> bool {
     })
 }
 
-fn format_option_in_sugg(cx: &LateContext<'_, '_>, cond_expr: &Expr<'_>, as_ref: bool, as_mut: bool) -> String {
+fn format_option_in_sugg(cx: &LateContext<'_>, cond_expr: &Expr<'_>, as_ref: bool, as_mut: bool) -> String {
     format!(
         "{}{}",
         Sugg::hir(cx, cond_expr, "..").maybe_par(),
@@ -198,7 +198,7 @@ fn format_option_in_sugg(cx: &LateContext<'_, '_>, cond_expr: &Expr<'_>, as_ref:
 /// If this expression is the option if let/else construct we're detecting, then
 /// this function returns an `OptionIfLetElseOccurence` struct with details if
 /// this construct is found, or None if this construct is not found.
-fn detect_option_if_let_else<'a>(cx: &LateContext<'_, 'a>, expr: &'a Expr<'a>) -> Option<OptionIfLetElseOccurence> {
+fn detect_option_if_let_else(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<OptionIfLetElseOccurence> {
     if_chain! {
         if !utils::in_macro(expr.span); // Don't lint macros, because it behaves weirdly
         if let ExprKind::Match(cond_expr, arms, MatchSource::IfLetDesugar{contains_else_clause: true}) = &expr.kind;
@@ -242,8 +242,8 @@ fn detect_option_if_let_else<'a>(cx: &LateContext<'_, 'a>, expr: &'a Expr<'a>) -
     }
 }
 
-impl<'a, 'tcx> LateLintPass<'a, 'tcx> for OptionIfLetElse {
-    fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr<'_>) {
+impl<'a> LateLintPass<'a> for OptionIfLetElse {
+    fn check_expr(&mut self, cx: &LateContext<'a>, expr: &Expr<'_>) {
         if let Some(detection) = detect_option_if_let_else(cx, expr) {
             span_lint_and_sugg(
                 cx,
diff --git a/clippy_lints/src/shadow.rs b/clippy_lints/src/shadow.rs
index f16db2df3a9..4cdff63f118 100644
--- a/clippy_lints/src/shadow.rs
+++ b/clippy_lints/src/shadow.rs
@@ -164,7 +164,7 @@ fn check_local<'tcx>(cx: &LateContext<'tcx>, local: &'tcx Local<'_>, bindings: &
 }
 
 fn is_binding(cx: &LateContext<'_>, pat_id: HirId) -> bool {
-    let var_ty = cx.tables.node_type_opt(pat_id);
+    let var_ty = cx.tables().node_type_opt(pat_id);
     var_ty.map_or(false, |var_ty| match var_ty.kind {
         ty::Adt(..) => false,
         _ => true,
-- 
cgit 1.4.1-3-g733a5


From a6f1af75d71fcf8e029b78142370e7563798c503 Mon Sep 17 00:00:00 2001
From: Thiago Arrais <thiago.arrais@gmail.com>
Date: Fri, 3 Apr 2020 13:58:52 -0300
Subject: Lint for x.powi(2) => x * x

---
 clippy_lints/src/floating_point_arithmetic.rs | 27 ++++++++++++++++++++++++++-
 tests/ui/floating_point_log.fixed             | 10 +++++-----
 tests/ui/floating_point_log.rs                | 10 +++++-----
 tests/ui/floating_point_log.stderr            | 20 ++++++++++----------
 tests/ui/floating_point_powf.fixed            |  4 ++--
 tests/ui/floating_point_powf.rs               |  4 ++--
 tests/ui/floating_point_powf.stderr           |  8 ++++----
 tests/ui/floating_point_powi.fixed            | 12 ++++++++++++
 tests/ui/floating_point_powi.rs               | 12 ++++++++++++
 tests/ui/floating_point_powi.stderr           | 16 ++++++++++++++++
 10 files changed, 94 insertions(+), 29 deletions(-)
 create mode 100644 tests/ui/floating_point_powi.fixed
 create mode 100644 tests/ui/floating_point_powi.rs
 create mode 100644 tests/ui/floating_point_powi.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/floating_point_arithmetic.rs b/clippy_lints/src/floating_point_arithmetic.rs
index 4efd0689267..e3ee4296119 100644
--- a/clippy_lints/src/floating_point_arithmetic.rs
+++ b/clippy_lints/src/floating_point_arithmetic.rs
@@ -1,6 +1,6 @@
 use crate::consts::{
     constant, constant_simple, Constant,
-    Constant::{F32, F64},
+    Constant::{Int, F32, F64},
 };
 use crate::utils::{higher, numeric_literal, span_lint_and_sugg, sugg, SpanlessEq};
 use if_chain::if_chain;
@@ -293,6 +293,30 @@ fn check_powf(cx: &LateContext<'_>, expr: &Expr<'_>, args: &[Expr<'_>]) {
     }
 }
 
+fn check_powi(cx: &LateContext<'_, '_>, expr: &Expr<'_>, args: &[Expr<'_>]) {
+    // Check argument
+    if let Some((value, _)) = constant(cx, cx.tables, &args[1]) {
+        let (lint, help, suggestion) = match value {
+            Int(2) => (
+                IMPRECISE_FLOPS,
+                "square can be computed more accurately",
+                format!("{} * {}", Sugg::hir(cx, &args[0], ".."), Sugg::hir(cx, &args[0], "..")),
+            ),
+            _ => return,
+        };
+
+        span_lint_and_sugg(
+            cx,
+            lint,
+            expr.span,
+            help,
+            "consider using",
+            suggestion,
+            Applicability::MachineApplicable,
+        );
+    }
+}
+
 // TODO: Lint expressions of the form `x.exp() - y` where y > 1
 // and suggest usage of `x.exp_m1() - (y - 1)` instead
 fn check_expm1(cx: &LateContext<'_>, expr: &Expr<'_>) {
@@ -489,6 +513,7 @@ impl<'tcx> LateLintPass<'tcx> for FloatingPointArithmetic {
                     "ln" => check_ln1p(cx, expr, args),
                     "log" => check_log_base(cx, expr, args),
                     "powf" => check_powf(cx, expr, args),
+                    "powi" => check_powi(cx, expr, args),
                     _ => {},
                 }
             }
diff --git a/tests/ui/floating_point_log.fixed b/tests/ui/floating_point_log.fixed
index 42c5e5d2bae..7dc7ee94aff 100644
--- a/tests/ui/floating_point_log.fixed
+++ b/tests/ui/floating_point_log.fixed
@@ -25,11 +25,11 @@ fn check_ln1p() {
     let _ = 2.0f32.ln_1p();
     let _ = x.ln_1p();
     let _ = (x / 2.0).ln_1p();
-    let _ = x.powi(2).ln_1p();
-    let _ = (x.powi(2) / 2.0).ln_1p();
+    let _ = x.powi(3).ln_1p();
+    let _ = (x.powi(3) / 2.0).ln_1p();
     let _ = ((std::f32::consts::E - 1.0)).ln_1p();
     let _ = x.ln_1p();
-    let _ = x.powi(2).ln_1p();
+    let _ = x.powi(3).ln_1p();
     let _ = (x + 2.0).ln_1p();
     let _ = (x / 2.0).ln_1p();
     // Cases where the lint shouldn't be applied
@@ -43,9 +43,9 @@ fn check_ln1p() {
     let _ = 2.0f64.ln_1p();
     let _ = x.ln_1p();
     let _ = (x / 2.0).ln_1p();
-    let _ = x.powi(2).ln_1p();
+    let _ = x.powi(3).ln_1p();
     let _ = x.ln_1p();
-    let _ = x.powi(2).ln_1p();
+    let _ = x.powi(3).ln_1p();
     let _ = (x + 2.0).ln_1p();
     let _ = (x / 2.0).ln_1p();
     // Cases where the lint shouldn't be applied
diff --git a/tests/ui/floating_point_log.rs b/tests/ui/floating_point_log.rs
index 8be0d9ad56f..01181484e7d 100644
--- a/tests/ui/floating_point_log.rs
+++ b/tests/ui/floating_point_log.rs
@@ -25,11 +25,11 @@ fn check_ln1p() {
     let _ = (1f32 + 2.0).ln();
     let _ = (1.0 + x).ln();
     let _ = (1.0 + x / 2.0).ln();
-    let _ = (1.0 + x.powi(2)).ln();
-    let _ = (1.0 + x.powi(2) / 2.0).ln();
+    let _ = (1.0 + x.powi(3)).ln();
+    let _ = (1.0 + x.powi(3) / 2.0).ln();
     let _ = (1.0 + (std::f32::consts::E - 1.0)).ln();
     let _ = (x + 1.0).ln();
-    let _ = (x.powi(2) + 1.0).ln();
+    let _ = (x.powi(3) + 1.0).ln();
     let _ = (x + 2.0 + 1.0).ln();
     let _ = (x / 2.0 + 1.0).ln();
     // Cases where the lint shouldn't be applied
@@ -43,9 +43,9 @@ fn check_ln1p() {
     let _ = (1f64 + 2.0).ln();
     let _ = (1.0 + x).ln();
     let _ = (1.0 + x / 2.0).ln();
-    let _ = (1.0 + x.powi(2)).ln();
+    let _ = (1.0 + x.powi(3)).ln();
     let _ = (x + 1.0).ln();
-    let _ = (x.powi(2) + 1.0).ln();
+    let _ = (x.powi(3) + 1.0).ln();
     let _ = (x + 2.0 + 1.0).ln();
     let _ = (x / 2.0 + 1.0).ln();
     // Cases where the lint shouldn't be applied
diff --git a/tests/ui/floating_point_log.stderr b/tests/ui/floating_point_log.stderr
index 943fbdb0b83..900dc2b7933 100644
--- a/tests/ui/floating_point_log.stderr
+++ b/tests/ui/floating_point_log.stderr
@@ -77,14 +77,14 @@ LL |     let _ = (1.0 + x / 2.0).ln();
 error: ln(1 + x) can be computed more accurately
   --> $DIR/floating_point_log.rs:28:13
    |
-LL |     let _ = (1.0 + x.powi(2)).ln();
-   |             ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.powi(2).ln_1p()`
+LL |     let _ = (1.0 + x.powi(3)).ln();
+   |             ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.powi(3).ln_1p()`
 
 error: ln(1 + x) can be computed more accurately
   --> $DIR/floating_point_log.rs:29:13
    |
-LL |     let _ = (1.0 + x.powi(2) / 2.0).ln();
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(x.powi(2) / 2.0).ln_1p()`
+LL |     let _ = (1.0 + x.powi(3) / 2.0).ln();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(x.powi(3) / 2.0).ln_1p()`
 
 error: ln(1 + x) can be computed more accurately
   --> $DIR/floating_point_log.rs:30:13
@@ -101,8 +101,8 @@ LL |     let _ = (x + 1.0).ln();
 error: ln(1 + x) can be computed more accurately
   --> $DIR/floating_point_log.rs:32:13
    |
-LL |     let _ = (x.powi(2) + 1.0).ln();
-   |             ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.powi(2).ln_1p()`
+LL |     let _ = (x.powi(3) + 1.0).ln();
+   |             ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.powi(3).ln_1p()`
 
 error: ln(1 + x) can be computed more accurately
   --> $DIR/floating_point_log.rs:33:13
@@ -143,8 +143,8 @@ LL |     let _ = (1.0 + x / 2.0).ln();
 error: ln(1 + x) can be computed more accurately
   --> $DIR/floating_point_log.rs:46:13
    |
-LL |     let _ = (1.0 + x.powi(2)).ln();
-   |             ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.powi(2).ln_1p()`
+LL |     let _ = (1.0 + x.powi(3)).ln();
+   |             ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.powi(3).ln_1p()`
 
 error: ln(1 + x) can be computed more accurately
   --> $DIR/floating_point_log.rs:47:13
@@ -155,8 +155,8 @@ LL |     let _ = (x + 1.0).ln();
 error: ln(1 + x) can be computed more accurately
   --> $DIR/floating_point_log.rs:48:13
    |
-LL |     let _ = (x.powi(2) + 1.0).ln();
-   |             ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.powi(2).ln_1p()`
+LL |     let _ = (x.powi(3) + 1.0).ln();
+   |             ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.powi(3).ln_1p()`
 
 error: ln(1 + x) can be computed more accurately
   --> $DIR/floating_point_log.rs:49:13
diff --git a/tests/ui/floating_point_powf.fixed b/tests/ui/floating_point_powf.fixed
index 78a9d44829b..b0641a100cd 100644
--- a/tests/ui/floating_point_powf.fixed
+++ b/tests/ui/floating_point_powf.fixed
@@ -11,7 +11,7 @@ fn main() {
     let _ = (-3.1f32).exp();
     let _ = x.sqrt();
     let _ = x.cbrt();
-    let _ = x.powi(2);
+    let _ = x.powi(3);
     let _ = x.powi(-2);
     let _ = x.powi(16_777_215);
     let _ = x.powi(-16_777_215);
@@ -30,7 +30,7 @@ fn main() {
     let _ = (-3.1f64).exp();
     let _ = x.sqrt();
     let _ = x.cbrt();
-    let _ = x.powi(2);
+    let _ = x.powi(3);
     let _ = x.powi(-2);
     let _ = x.powi(-2_147_483_648);
     let _ = x.powi(2_147_483_647);
diff --git a/tests/ui/floating_point_powf.rs b/tests/ui/floating_point_powf.rs
index dbc1cac5cb4..a0a2c973900 100644
--- a/tests/ui/floating_point_powf.rs
+++ b/tests/ui/floating_point_powf.rs
@@ -11,7 +11,7 @@ fn main() {
     let _ = std::f32::consts::E.powf(-3.1);
     let _ = x.powf(1.0 / 2.0);
     let _ = x.powf(1.0 / 3.0);
-    let _ = x.powf(2.0);
+    let _ = x.powf(3.0);
     let _ = x.powf(-2.0);
     let _ = x.powf(16_777_215.0);
     let _ = x.powf(-16_777_215.0);
@@ -30,7 +30,7 @@ fn main() {
     let _ = std::f64::consts::E.powf(-3.1);
     let _ = x.powf(1.0 / 2.0);
     let _ = x.powf(1.0 / 3.0);
-    let _ = x.powf(2.0);
+    let _ = x.powf(3.0);
     let _ = x.powf(-2.0);
     let _ = x.powf(-2_147_483_648.0);
     let _ = x.powf(2_147_483_647.0);
diff --git a/tests/ui/floating_point_powf.stderr b/tests/ui/floating_point_powf.stderr
index ad5163f0079..2422eb911e9 100644
--- a/tests/ui/floating_point_powf.stderr
+++ b/tests/ui/floating_point_powf.stderr
@@ -53,8 +53,8 @@ LL |     let _ = x.powf(1.0 / 3.0);
 error: exponentiation with integer powers can be computed more efficiently
   --> $DIR/floating_point_powf.rs:14:13
    |
-LL |     let _ = x.powf(2.0);
-   |             ^^^^^^^^^^^ help: consider using: `x.powi(2)`
+LL |     let _ = x.powf(3.0);
+   |             ^^^^^^^^^^^ help: consider using: `x.powi(3)`
 
 error: exponentiation with integer powers can be computed more efficiently
   --> $DIR/floating_point_powf.rs:15:13
@@ -125,8 +125,8 @@ LL |     let _ = x.powf(1.0 / 3.0);
 error: exponentiation with integer powers can be computed more efficiently
   --> $DIR/floating_point_powf.rs:33:13
    |
-LL |     let _ = x.powf(2.0);
-   |             ^^^^^^^^^^^ help: consider using: `x.powi(2)`
+LL |     let _ = x.powf(3.0);
+   |             ^^^^^^^^^^^ help: consider using: `x.powi(3)`
 
 error: exponentiation with integer powers can be computed more efficiently
   --> $DIR/floating_point_powf.rs:34:13
diff --git a/tests/ui/floating_point_powi.fixed b/tests/ui/floating_point_powi.fixed
new file mode 100644
index 00000000000..0ce6f72535d
--- /dev/null
+++ b/tests/ui/floating_point_powi.fixed
@@ -0,0 +1,12 @@
+// run-rustfix
+#![warn(clippy::suboptimal_flops, clippy::imprecise_flops)]
+
+fn main() {
+    let one = 1;
+    let x = 3f32;
+    let _ = x * x;
+    let _ = x * x;
+    // Cases where the lint shouldn't be applied
+    let _ = x.powi(3);
+    let _ = x.powi(one + 1);
+}
diff --git a/tests/ui/floating_point_powi.rs b/tests/ui/floating_point_powi.rs
new file mode 100644
index 00000000000..c87e836bedd
--- /dev/null
+++ b/tests/ui/floating_point_powi.rs
@@ -0,0 +1,12 @@
+// run-rustfix
+#![warn(clippy::suboptimal_flops, clippy::imprecise_flops)]
+
+fn main() {
+    let one = 1;
+    let x = 3f32;
+    let _ = x.powi(2);
+    let _ = x.powi(1 + 1);
+    // Cases where the lint shouldn't be applied
+    let _ = x.powi(3);
+    let _ = x.powi(one + 1);
+}
diff --git a/tests/ui/floating_point_powi.stderr b/tests/ui/floating_point_powi.stderr
new file mode 100644
index 00000000000..ae7bbaa4473
--- /dev/null
+++ b/tests/ui/floating_point_powi.stderr
@@ -0,0 +1,16 @@
+error: square can be computed more accurately
+  --> $DIR/floating_point_powi.rs:7:13
+   |
+LL |     let _ = x.powi(2);
+   |             ^^^^^^^^^ help: consider using: `x * x`
+   |
+   = note: `-D clippy::imprecise-flops` implied by `-D warnings`
+
+error: square can be computed more accurately
+  --> $DIR/floating_point_powi.rs:8:13
+   |
+LL |     let _ = x.powi(1 + 1);
+   |             ^^^^^^^^^^^^^ help: consider using: `x * x`
+
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From f62798454c8a7f9f2c3e87e0a913b3bd79b6d2ed Mon Sep 17 00:00:00 2001
From: Thiago Arrais <thiago.arrais@gmail.com>
Date: Mon, 25 May 2020 13:54:39 -0300
Subject: Lint (x * x + y * y).sqrt() => x.hypot(y)

---
 clippy_lints/src/floating_point_arithmetic.rs | 75 ++++++++++++++++++++++++++-
 tests/ui/floating_point_hypot.fixed           | 13 +++++
 tests/ui/floating_point_hypot.rs              | 13 +++++
 tests/ui/floating_point_hypot.stderr          | 30 +++++++++++
 tests/ui/floating_point_mul_add.fixed         |  5 ++
 tests/ui/floating_point_mul_add.rs            |  5 ++
 tests/ui/floating_point_mul_add.stderr        |  8 ++-
 tests/ui/floating_point_powi.fixed            |  7 ++-
 tests/ui/floating_point_powi.rs               |  7 ++-
 tests/ui/floating_point_powi.stderr           | 20 ++++++-
 10 files changed, 177 insertions(+), 6 deletions(-)
 create mode 100644 tests/ui/floating_point_hypot.fixed
 create mode 100644 tests/ui/floating_point_hypot.rs
 create mode 100644 tests/ui/floating_point_hypot.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/floating_point_arithmetic.rs b/clippy_lints/src/floating_point_arithmetic.rs
index e3ee4296119..3b2e46a9a85 100644
--- a/clippy_lints/src/floating_point_arithmetic.rs
+++ b/clippy_lints/src/floating_point_arithmetic.rs
@@ -2,10 +2,10 @@ use crate::consts::{
     constant, constant_simple, Constant,
     Constant::{Int, F32, F64},
 };
-use crate::utils::{higher, numeric_literal, span_lint_and_sugg, sugg, SpanlessEq};
+use crate::utils::{get_parent_expr, higher, numeric_literal, span_lint_and_sugg, sugg, SpanlessEq};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
-use rustc_hir::{BinOpKind, Expr, ExprKind, UnOp};
+use rustc_hir::{BinOpKind, Expr, ExprKind, PathSegment, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -296,6 +296,17 @@ fn check_powf(cx: &LateContext<'_>, expr: &Expr<'_>, args: &[Expr<'_>]) {
 fn check_powi(cx: &LateContext<'_, '_>, expr: &Expr<'_>, args: &[Expr<'_>]) {
     // Check argument
     if let Some((value, _)) = constant(cx, cx.tables, &args[1]) {
+        // TODO: need more specific check. this is too wide. remember also to include tests
+        if let Some(parent) = get_parent_expr(cx, expr) {
+            if let Some(grandparent) = get_parent_expr(cx, parent) {
+                if let ExprKind::MethodCall(PathSegment { ident: method_name, .. }, _, args) = grandparent.kind {
+                    if method_name.as_str() == "sqrt" && detect_hypot(cx, args).is_some() {
+                        return;
+                    }
+                }
+            }
+        }
+
         let (lint, help, suggestion) = match value {
             Int(2) => (
                 IMPRECISE_FLOPS,
@@ -317,6 +328,57 @@ fn check_powi(cx: &LateContext<'_, '_>, expr: &Expr<'_>, args: &[Expr<'_>]) {
     }
 }
 
+fn detect_hypot(cx: &LateContext<'_, '_>, args: &[Expr<'_>]) -> Option<String> {
+    if let ExprKind::Binary(
+        Spanned {
+            node: BinOpKind::Add, ..
+        },
+        ref add_lhs,
+        ref add_rhs,
+    ) = args[0].kind
+    {
+        // check if expression of the form x * x + y * y
+        if_chain! {
+            if let ExprKind::Binary(Spanned { node: BinOpKind::Mul, .. }, ref lmul_lhs, ref lmul_rhs) = add_lhs.kind;
+            if let ExprKind::Binary(Spanned { node: BinOpKind::Mul, .. }, ref rmul_lhs, ref rmul_rhs) = add_rhs.kind;
+            if are_exprs_equal(cx, lmul_lhs, lmul_rhs);
+            if are_exprs_equal(cx, rmul_lhs, rmul_rhs);
+            then {
+                return Some(format!("{}.hypot({})", Sugg::hir(cx, &lmul_lhs, ".."), Sugg::hir(cx, &rmul_lhs, "..")));
+            }
+        }
+
+        // check if expression of the form x.powi(2) + y.powi(2)
+        if_chain! {
+            if let ExprKind::MethodCall(PathSegment { ident: lmethod_name, .. }, ref _lspan, ref largs) = add_lhs.kind;
+            if let ExprKind::MethodCall(PathSegment { ident: rmethod_name, .. }, ref _rspan, ref rargs) = add_rhs.kind;
+            if lmethod_name.as_str() == "powi" && rmethod_name.as_str() == "powi";
+            if let Some((lvalue, _)) = constant(cx, cx.tables, &largs[1]);
+            if let Some((rvalue, _)) = constant(cx, cx.tables, &rargs[1]);
+            if Int(2) == lvalue && Int(2) == rvalue;
+            then {
+                return Some(format!("{}.hypot({})", Sugg::hir(cx, &largs[0], ".."), Sugg::hir(cx, &rargs[0], "..")));
+            }
+        }
+    }
+
+    None
+}
+
+fn check_hypot(cx: &LateContext<'_, '_>, expr: &Expr<'_>, args: &[Expr<'_>]) {
+    if let Some(message) = detect_hypot(cx, args) {
+        span_lint_and_sugg(
+            cx,
+            IMPRECISE_FLOPS,
+            expr.span,
+            "hypotenuse can be computed more accurately",
+            "consider using",
+            message,
+            Applicability::MachineApplicable,
+        );
+    }
+}
+
 // TODO: Lint expressions of the form `x.exp() - y` where y > 1
 // and suggest usage of `x.exp_m1() - (y - 1)` instead
 fn check_expm1(cx: &LateContext<'_>, expr: &Expr<'_>) {
@@ -368,6 +430,14 @@ fn check_mul_add(cx: &LateContext<'_>, expr: &Expr<'_>) {
         rhs,
     ) = &expr.kind
     {
+        if let Some(parent) = get_parent_expr(cx, expr) {
+            if let ExprKind::MethodCall(PathSegment { ident: method_name, .. }, _, args) = parent.kind {
+                if method_name.as_str() == "sqrt" && detect_hypot(cx, args).is_some() {
+                    return;
+                }
+            }
+        }
+
         let (recv, arg1, arg2) = if let Some((inner_lhs, inner_rhs)) = is_float_mul_expr(cx, lhs) {
             (inner_lhs, inner_rhs, rhs)
         } else if let Some((inner_lhs, inner_rhs)) = is_float_mul_expr(cx, rhs) {
@@ -514,6 +584,7 @@ impl<'tcx> LateLintPass<'tcx> for FloatingPointArithmetic {
                     "log" => check_log_base(cx, expr, args),
                     "powf" => check_powf(cx, expr, args),
                     "powi" => check_powi(cx, expr, args),
+                    "sqrt" => check_hypot(cx, expr, args),
                     _ => {},
                 }
             }
diff --git a/tests/ui/floating_point_hypot.fixed b/tests/ui/floating_point_hypot.fixed
new file mode 100644
index 00000000000..f90695bc3fe
--- /dev/null
+++ b/tests/ui/floating_point_hypot.fixed
@@ -0,0 +1,13 @@
+// run-rustfix
+#![warn(clippy::suboptimal_flops, clippy::imprecise_flops)]
+
+fn main() {
+    let x = 3f32;
+    let y = 4f32;
+    let _ = x.hypot(y);
+    let _ = (x + 1f32).hypot(y);
+    let _ = x.hypot(y);
+    // Cases where the lint shouldn't be applied
+    let _ = x.mul_add(x, y * y).sqrt();
+    let _ = x.mul_add(4f32, y * y).sqrt();
+}
diff --git a/tests/ui/floating_point_hypot.rs b/tests/ui/floating_point_hypot.rs
new file mode 100644
index 00000000000..e7b048e262f
--- /dev/null
+++ b/tests/ui/floating_point_hypot.rs
@@ -0,0 +1,13 @@
+// run-rustfix
+#![warn(clippy::suboptimal_flops, clippy::imprecise_flops)]
+
+fn main() {
+    let x = 3f32;
+    let y = 4f32;
+    let _ = (x * x + y * y).sqrt();
+    let _ = ((x + 1f32) * (x + 1f32) + y * y).sqrt();
+    let _ = (x.powi(2) + y.powi(2)).sqrt();
+    // Cases where the lint shouldn't be applied
+    let _ = x.mul_add(x, y * y).sqrt();
+    let _ = (x * 4f32 + y * y).sqrt();
+}
diff --git a/tests/ui/floating_point_hypot.stderr b/tests/ui/floating_point_hypot.stderr
new file mode 100644
index 00000000000..fe1dfc7a451
--- /dev/null
+++ b/tests/ui/floating_point_hypot.stderr
@@ -0,0 +1,30 @@
+error: hypotenuse can be computed more accurately
+  --> $DIR/floating_point_hypot.rs:7:13
+   |
+LL |     let _ = (x * x + y * y).sqrt();
+   |             ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.hypot(y)`
+   |
+   = note: `-D clippy::imprecise-flops` implied by `-D warnings`
+
+error: hypotenuse can be computed more accurately
+  --> $DIR/floating_point_hypot.rs:8:13
+   |
+LL |     let _ = ((x + 1f32) * (x + 1f32) + y * y).sqrt();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(x + 1f32).hypot(y)`
+
+error: hypotenuse can be computed more accurately
+  --> $DIR/floating_point_hypot.rs:9:13
+   |
+LL |     let _ = (x.powi(2) + y.powi(2)).sqrt();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.hypot(y)`
+
+error: multiply and add expressions can be calculated more efficiently and accurately
+  --> $DIR/floating_point_hypot.rs:12:13
+   |
+LL |     let _ = (x * 4f32 + y * y).sqrt();
+   |             ^^^^^^^^^^^^^^^^^^ help: consider using: `x.mul_add(4f32, y * y)`
+   |
+   = note: `-D clippy::suboptimal-flops` implied by `-D warnings`
+
+error: aborting due to 4 previous errors
+
diff --git a/tests/ui/floating_point_mul_add.fixed b/tests/ui/floating_point_mul_add.fixed
index e343c37740d..911700bab00 100644
--- a/tests/ui/floating_point_mul_add.fixed
+++ b/tests/ui/floating_point_mul_add.fixed
@@ -18,4 +18,9 @@ fn main() {
 
     let _ = a.mul_add(b, c).mul_add(a.mul_add(b, c), a.mul_add(b, c)) + c;
     let _ = 1234.567_f64.mul_add(45.67834_f64, 0.0004_f64);
+
+    let _ = a.mul_add(a, b).sqrt();
+
+    // Cases where the lint shouldn't be applied
+    let _ = (a * a + b * b).sqrt();
 }
diff --git a/tests/ui/floating_point_mul_add.rs b/tests/ui/floating_point_mul_add.rs
index 810f929c856..d202385fc8a 100644
--- a/tests/ui/floating_point_mul_add.rs
+++ b/tests/ui/floating_point_mul_add.rs
@@ -18,4 +18,9 @@ fn main() {
 
     let _ = a.mul_add(b, c) * a.mul_add(b, c) + a.mul_add(b, c) + c;
     let _ = 1234.567_f64 * 45.67834_f64 + 0.0004_f64;
+
+    let _ = (a * a + b).sqrt();
+
+    // Cases where the lint shouldn't be applied
+    let _ = (a * a + b * b).sqrt();
 }
diff --git a/tests/ui/floating_point_mul_add.stderr b/tests/ui/floating_point_mul_add.stderr
index 2dfbf562d15..ac8d0c0cae0 100644
--- a/tests/ui/floating_point_mul_add.stderr
+++ b/tests/ui/floating_point_mul_add.stderr
@@ -54,5 +54,11 @@ error: multiply and add expressions can be calculated more efficiently and accur
 LL |     let _ = 1234.567_f64 * 45.67834_f64 + 0.0004_f64;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `1234.567_f64.mul_add(45.67834_f64, 0.0004_f64)`
 
-error: aborting due to 9 previous errors
+error: multiply and add expressions can be calculated more efficiently and accurately
+  --> $DIR/floating_point_mul_add.rs:22:13
+   |
+LL |     let _ = (a * a + b).sqrt();
+   |             ^^^^^^^^^^^ help: consider using: `a.mul_add(a, b)`
+
+error: aborting due to 10 previous errors
 
diff --git a/tests/ui/floating_point_powi.fixed b/tests/ui/floating_point_powi.fixed
index 0ce6f72535d..98766e68aaf 100644
--- a/tests/ui/floating_point_powi.fixed
+++ b/tests/ui/floating_point_powi.fixed
@@ -1,12 +1,17 @@
 // run-rustfix
-#![warn(clippy::suboptimal_flops, clippy::imprecise_flops)]
+#![warn(clippy::imprecise_flops)]
 
 fn main() {
     let one = 1;
     let x = 3f32;
     let _ = x * x;
     let _ = x * x;
+
+    let y = 4f32;
+    let _ = (x * x + y).sqrt();
+    let _ = (x + y * y).sqrt();
     // Cases where the lint shouldn't be applied
     let _ = x.powi(3);
     let _ = x.powi(one + 1);
+    let _ = x.hypot(y);
 }
diff --git a/tests/ui/floating_point_powi.rs b/tests/ui/floating_point_powi.rs
index c87e836bedd..3c4b636a3d8 100644
--- a/tests/ui/floating_point_powi.rs
+++ b/tests/ui/floating_point_powi.rs
@@ -1,12 +1,17 @@
 // run-rustfix
-#![warn(clippy::suboptimal_flops, clippy::imprecise_flops)]
+#![warn(clippy::imprecise_flops)]
 
 fn main() {
     let one = 1;
     let x = 3f32;
     let _ = x.powi(2);
     let _ = x.powi(1 + 1);
+
+    let y = 4f32;
+    let _ = (x.powi(2) + y).sqrt();
+    let _ = (x + y.powi(2)).sqrt();
     // Cases where the lint shouldn't be applied
     let _ = x.powi(3);
     let _ = x.powi(one + 1);
+    let _ = (x.powi(2) + y.powi(2)).sqrt();
 }
diff --git a/tests/ui/floating_point_powi.stderr b/tests/ui/floating_point_powi.stderr
index ae7bbaa4473..f370e24bf05 100644
--- a/tests/ui/floating_point_powi.stderr
+++ b/tests/ui/floating_point_powi.stderr
@@ -12,5 +12,23 @@ error: square can be computed more accurately
 LL |     let _ = x.powi(1 + 1);
    |             ^^^^^^^^^^^^^ help: consider using: `x * x`
 
-error: aborting due to 2 previous errors
+error: square can be computed more accurately
+  --> $DIR/floating_point_powi.rs:11:14
+   |
+LL |     let _ = (x.powi(2) + y).sqrt();
+   |              ^^^^^^^^^ help: consider using: `x * x`
+
+error: square can be computed more accurately
+  --> $DIR/floating_point_powi.rs:12:18
+   |
+LL |     let _ = (x + y.powi(2)).sqrt();
+   |                  ^^^^^^^^^ help: consider using: `y * y`
+
+error: hypotenuse can be computed more accurately
+  --> $DIR/floating_point_powi.rs:16:13
+   |
+LL |     let _ = (x.powi(2) + y.powi(2)).sqrt();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.hypot(y)`
+
+error: aborting due to 5 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 2e8a1be444afc6a9b5137d3e7e4fdcfcb1f89e0d Mon Sep 17 00:00:00 2001
From: robojumper <robojumper@gmail.com>
Date: Sun, 5 Jul 2020 22:10:59 +0200
Subject: new lint: match_like_matches_macro

---
 CHANGELOG.md                                       |   1 +
 clippy_lints/src/matches.rs                        | 395 ++++++++++++++++++++-
 clippy_lints/src/redundant_pattern_matching.rs     | 260 --------------
 src/lintlist/mod.rs                                |   9 +-
 tests/ui/find_map.rs                               |   1 +
 tests/ui/find_map.stderr                           |   2 +-
 tests/ui/match_expr_like_matches_macro.fixed       |  32 ++
 tests/ui/match_expr_like_matches_macro.rs          |  41 +++
 tests/ui/match_expr_like_matches_macro.stderr      |  42 +++
 tests/ui/neg_cmp_op_on_partial_ord.rs              |   2 +-
 tests/ui/question_mark.fixed                       |   5 +-
 tests/ui/question_mark.rs                          |   5 +-
 tests/ui/question_mark.stderr                      |  20 +-
 tests/ui/redundant_pattern_matching.fixed          |   8 +-
 tests/ui/redundant_pattern_matching.rs             |   8 +-
 tests/ui/redundant_pattern_matching.stderr         |  56 +--
 .../redundant_pattern_matching_const_result.fixed  |   2 +-
 .../ui/redundant_pattern_matching_const_result.rs  |   2 +-
 18 files changed, 563 insertions(+), 328 deletions(-)
 delete mode 100644 clippy_lints/src/redundant_pattern_matching.rs
 create mode 100644 tests/ui/match_expr_like_matches_macro.fixed
 create mode 100644 tests/ui/match_expr_like_matches_macro.rs
 create mode 100644 tests/ui/match_expr_like_matches_macro.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 1a081bb85fe..6261ca4879a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1513,6 +1513,7 @@ Released 2018-09-13
 [`map_unwrap_or`]: https://rust-lang.github.io/rust-clippy/master/index.html#map_unwrap_or
 [`match_as_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#match_as_ref
 [`match_bool`]: https://rust-lang.github.io/rust-clippy/master/index.html#match_bool
+[`match_like_matches_macro`]: https://rust-lang.github.io/rust-clippy/master/index.html#match_like_matches_macro
 [`match_on_vec_items`]: https://rust-lang.github.io/rust-clippy/master/index.html#match_on_vec_items
 [`match_overlapping_arm`]: https://rust-lang.github.io/rust-clippy/master/index.html#match_overlapping_arm
 [`match_ref_pats`]: https://rust-lang.github.io/rust-clippy/master/index.html#match_ref_pats
diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index b754a45aa40..34aa2981535 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -13,14 +13,14 @@ use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::def::CtorKind;
 use rustc_hir::{
-    Arm, BindingAnnotation, Block, BorrowKind, Expr, ExprKind, Local, MatchSource, Mutability, Node, Pat, PatKind,
-    QPath, RangeEnd,
+    Arm, BindingAnnotation, Block, BorrowKind, Expr, ExprKind, Guard, Local, MatchSource, Mutability, Node, Pat,
+    PatKind, QPath, RangeEnd,
 };
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::{self, Ty};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::source_map::Span;
+use rustc_span::source_map::{Span, Spanned};
 use std::cmp::Ordering;
 use std::collections::Bound;
 
@@ -409,6 +409,67 @@ declare_clippy_lint! {
     "a match on a struct that binds all fields but still uses the wildcard pattern"
 }
 
+declare_clippy_lint! {
+    /// **What it does:** Lint for redundant pattern matching over `Result` or
+    /// `Option`
+    ///
+    /// **Why is this bad?** It's more concise and clear to just use the proper
+    /// utility function
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// if let Ok(_) = Ok::<i32, i32>(42) {}
+    /// if let Err(_) = Err::<i32, i32>(42) {}
+    /// if let None = None::<()> {}
+    /// if let Some(_) = Some(42) {}
+    /// match Ok::<i32, i32>(42) {
+    ///     Ok(_) => true,
+    ///     Err(_) => false,
+    /// };
+    /// ```
+    ///
+    /// The more idiomatic use would be:
+    ///
+    /// ```rust
+    /// if Ok::<i32, i32>(42).is_ok() {}
+    /// if Err::<i32, i32>(42).is_err() {}
+    /// if None::<()>.is_none() {}
+    /// if Some(42).is_some() {}
+    /// Ok::<i32, i32>(42).is_ok();
+    /// ```
+    pub REDUNDANT_PATTERN_MATCHING,
+    style,
+    "use the proper utility function avoiding an `if let`"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for `match` expressions producing a `bool` that could be written using `matches!`
+    ///
+    /// **Why is this bad?** Readability and needless complexity.
+    ///
+    /// **Known problems:** This can turn an intentionally exhaustive match into a non-exhaustive one.
+    ///
+    /// **Example:**
+    /// ```rust
+    /// let x = Some(5);
+    ///
+    /// // Bad
+    /// let a = match x {
+    ///     Some(0) => true,
+    ///     _ => false,
+    /// };
+    ///
+    /// // Good
+    /// let a = matches!(x, Some(5));
+    /// ```
+    pub MATCH_LIKE_MATCHES_MACRO,
+    style,
+    "a match that could be written with the matches! macro"
+}
+
 #[derive(Default)]
 pub struct Matches {
     infallible_destructuring_match_linted: bool,
@@ -427,7 +488,9 @@ impl_lint_pass!(Matches => [
     WILDCARD_IN_OR_PATTERNS,
     MATCH_SINGLE_BINDING,
     INFALLIBLE_DESTRUCTURING_MATCH,
-    REST_PAT_IN_FULLY_BOUND_STRUCTS
+    REST_PAT_IN_FULLY_BOUND_STRUCTS,
+    REDUNDANT_PATTERN_MATCHING,
+    MATCH_LIKE_MATCHES_MACRO
 ]);
 
 impl<'tcx> LateLintPass<'tcx> for Matches {
@@ -435,6 +498,11 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
         if in_external_macro(cx.sess(), expr.span) {
             return;
         }
+
+        if !redundant_pattern_match::check(cx, expr) {
+            check_match_like_matches(cx, expr);
+        }
+
         if let ExprKind::Match(ref ex, ref arms, MatchSource::Normal) = expr.kind {
             check_single_match(cx, ex, arms, expr);
             check_match_bool(cx, ex, arms, expr);
@@ -802,13 +870,8 @@ fn check_wild_enum_match(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>])
                     // Some simple checks for exhaustive patterns.
                     // There is a room for improvements to detect more cases,
                     // but it can be more expensive to do so.
-                    let is_pattern_exhaustive = |pat: &&Pat<'_>| {
-                        if let PatKind::Wild | PatKind::Binding(.., None) = pat.kind {
-                            true
-                        } else {
-                            false
-                        }
-                    };
+                    let is_pattern_exhaustive =
+                        |pat: &&Pat<'_>| matches!(pat.kind, PatKind::Wild | PatKind::Binding(.., None));
                     if patterns.iter().all(is_pattern_exhaustive) {
                         missing_variants.retain(|e| e.ctor_def_id != Some(p.res.def_id()));
                     }
@@ -989,6 +1052,78 @@ fn check_wild_in_or_pats(cx: &LateContext<'_>, arms: &[Arm<'_>]) {
     }
 }
 
+/// Lint a `match` or `if let .. { .. } else { .. }` expr that could be replaced by `matches!`
+fn check_match_like_matches<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+    if let ExprKind::Match(ex, arms, ref match_source) = &expr.kind {
+        match match_source {
+            MatchSource::Normal => find_matches_sugg(cx, ex, arms, expr, false),
+            MatchSource::IfLetDesugar { .. } => find_matches_sugg(cx, ex, arms, expr, true),
+            _ => return,
+        }
+    }
+}
+
+/// Lint a `match` or desugared `if let` for replacement by `matches!`
+fn find_matches_sugg(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>], expr: &Expr<'_>, desugared: bool) {
+    if_chain! {
+        if arms.len() == 2;
+        if cx.tables().expr_ty(expr).is_bool();
+        if let Some(first) = find_bool_lit(&arms[0].body.kind, desugared);
+        if let Some(second) = find_bool_lit(&arms[1].body.kind, desugared);
+        if first != second;
+        then {
+            let mut applicability = Applicability::MachineApplicable;
+
+            let pat_and_guard = if let Some(Guard::If(g)) = arms[0].guard {
+                format!("{} if {}", snippet_with_applicability(cx, arms[0].pat.span, "..", &mut applicability), snippet_with_applicability(cx, g.span, "..", &mut applicability))
+            } else {
+                format!("{}", snippet_with_applicability(cx, arms[0].pat.span, "..", &mut applicability))
+            };
+            span_lint_and_sugg(
+                cx,
+                MATCH_LIKE_MATCHES_MACRO,
+                expr.span,
+                &format!("{} expression looks like `matches!` macro", if desugared { "if let .. else" } else { "match" }),
+                "try this",
+                format!(
+                    "{}matches!({}, {})",
+                    if first { "" } else { "!" },
+                    snippet_with_applicability(cx, ex.span, "..", &mut applicability),
+                    pat_and_guard,
+                ),
+                applicability,
+            )
+        }
+    }
+}
+
+/// Extract a `bool` or `{ bool }`
+fn find_bool_lit(ex: &ExprKind<'_>, desugared: bool) -> Option<bool> {
+    match ex {
+        ExprKind::Lit(Spanned {
+            node: LitKind::Bool(b), ..
+        }) => Some(*b),
+        ExprKind::Block(
+            rustc_hir::Block {
+                stmts: &[],
+                expr: Some(exp),
+                ..
+            },
+            _,
+        ) if desugared => {
+            if let ExprKind::Lit(Spanned {
+                node: LitKind::Bool(b), ..
+            }) = exp.kind
+            {
+                Some(b)
+            } else {
+                None
+            }
+        },
+        _ => None,
+    }
+}
+
 fn check_match_single_binding<'a>(cx: &LateContext<'a>, ex: &Expr<'a>, arms: &[Arm<'_>], expr: &Expr<'_>) {
     if in_macro(expr.span) || arms.len() != 1 || is_refutable(cx, arms[0].pat) {
         return;
@@ -1179,10 +1314,7 @@ fn is_unit_expr(expr: &Expr<'_>) -> bool {
 
 // Checks if arm has the form `None => None`
 fn is_none_arm(arm: &Arm<'_>) -> bool {
-    match arm.pat.kind {
-        PatKind::Path(ref path) if match_qpath(path, &paths::OPTION_NONE) => true,
-        _ => false,
-    }
+    matches!(arm.pat.kind, PatKind::Path(ref path) if match_qpath(path, &paths::OPTION_NONE))
 }
 
 // Checks if arm has the form `Some(ref v) => Some(v)` (checks for `ref` and `ref mut`)
@@ -1293,6 +1425,239 @@ where
     None
 }
 
+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 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_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<'_>) -> bool {
+        if let ExprKind::Match(op, arms, ref match_source) = &expr.kind {
+            match match_source {
+                MatchSource::Normal => find_sugg_for_match(cx, expr, op, arms),
+                MatchSource::IfLetDesugar { .. } => find_sugg_for_if_let(cx, expr, op, arms, "if"),
+                MatchSource::WhileLetDesugar => find_sugg_for_if_let(cx, expr, op, arms, "while"),
+                _ => false,
+            }
+        } else {
+            false
+        }
+    }
+
+    fn find_sugg_for_if_let<'tcx>(
+        cx: &LateContext<'tcx>,
+        expr: &'tcx Expr<'_>,
+        op: &Expr<'_>,
+        arms: &[Arm<'_>],
+        keyword: &'static str,
+    ) -> bool {
+        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)
+                } else {
+                    None
+                }
+            },
+            PatKind::Path(ref path) => find_suggestion(cx, hir_id, path),
+            _ => None,
+        };
+        let good_method = match good_method {
+            Some(method) => method,
+            None => return false,
+        };
+
+        // check that `while_let_on_iterator` lint does not trigger
+        if_chain! {
+            if keyword == "while";
+            if let ExprKind::MethodCall(method_path, _, _, _) = op.kind;
+            if method_path.ident.name == sym!(next);
+            if match_trait_method(cx, op, &paths::ITERATOR);
+            then {
+                return false;
+            }
+        }
+
+        span_lint_and_then(
+            cx,
+            REDUNDANT_PATTERN_MATCHING,
+            arms[0].pat.span,
+            &format!("redundant pattern matching, consider using `{}`", good_method),
+            |diag| {
+                // while let ... = ... { ... }
+                // ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+                let expr_span = expr.span;
+
+                // while let ... = ... { ... }
+                //                 ^^^
+                let op_span = op.span.source_callsite();
+
+                // while let ... = ... { ... }
+                // ^^^^^^^^^^^^^^^^^^^
+                let span = expr_span.until(op_span.shrink_to_hi());
+                diag.span_suggestion(
+                    span,
+                    "try this",
+                    format!("{} {}.{}", keyword, snippet(cx, op_span, "_"), good_method),
+                    Applicability::MachineApplicable, // snippet
+                );
+            },
+        );
+        true
+    }
+
+    fn find_sugg_for_match<'tcx>(
+        cx: &LateContext<'tcx>,
+        expr: &'tcx Expr<'_>,
+        op: &Expr<'_>,
+        arms: &[Arm<'_>],
+    ) -> bool {
+        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, _),
+                    PatKind::TupleStruct(ref path_right, ref patterns_right, _),
+                ) if patterns_left.len() == 1 && patterns_right.len() == 1 => {
+                    if let (PatKind::Wild, PatKind::Wild) = (&patterns_left[0].kind, &patterns_right[0].kind) {
+                        find_good_method_for_match(
+                            arms,
+                            path_left,
+                            path_right,
+                            &paths::RESULT_OK,
+                            &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
+                    }
+                },
+                (PatKind::TupleStruct(ref path_left, ref patterns, _), PatKind::Path(ref path_right))
+                | (PatKind::Path(ref path_left), PatKind::TupleStruct(ref path_right, ref patterns, _))
+                    if patterns.len() == 1 =>
+                {
+                    if let PatKind::Wild = patterns[0].kind {
+                        find_good_method_for_match(
+                            arms,
+                            path_left,
+                            path_right,
+                            &paths::OPTION_SOME,
+                            &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
+                    }
+                },
+                _ => None,
+            };
+
+            if let Some(good_method) = found_good_method {
+                span_lint_and_then(
+                    cx,
+                    REDUNDANT_PATTERN_MATCHING,
+                    expr.span,
+                    &format!("redundant pattern matching, consider using `{}`", good_method),
+                    |diag| {
+                        let span = expr.span.to(op.span);
+                        diag.span_suggestion(
+                            span,
+                            "try this",
+                            format!("{}.{}", snippet(cx, op.span, "_"), good_method),
+                            Applicability::MaybeIncorrect, // snippet
+                        );
+                    },
+                );
+                return true;
+            }
+        }
+        false
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn find_good_method_for_match<'a>(
+        arms: &[Arm<'_>],
+        path_left: &QPath<'_>,
+        path_right: &QPath<'_>,
+        expected_left: &[&str],
+        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)
+        } else if match_qpath(path_right, expected_left) && match_qpath(path_left, expected_right) {
+            (&(*arms[1].body).kind, &(*arms[0].body).kind)
+        } else {
+            return None;
+        };
+
+        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(false), LitKind::Bool(true)) if can_suggest_right() => 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]
 fn test_overlapping() {
     use rustc_span::source_map::DUMMY_SP;
diff --git a/clippy_lints/src/redundant_pattern_matching.rs b/clippy_lints/src/redundant_pattern_matching.rs
deleted file mode 100644
index d8d16efb978..00000000000
--- a/clippy_lints/src/redundant_pattern_matching.rs
+++ /dev/null
@@ -1,260 +0,0 @@
-use crate::utils::{in_constant, 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_lint::{LateContext, LateLintPass};
-use rustc_middle::ty;
-use rustc_mir::const_eval::is_const_fn;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::source_map::Symbol;
-
-declare_clippy_lint! {
-    /// **What it does:** Lint for redundant pattern matching over `Result` or
-    /// `Option`
-    ///
-    /// **Why is this bad?** It's more concise and clear to just use the proper
-    /// utility function
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
-    /// ```rust
-    /// if let Ok(_) = Ok::<i32, i32>(42) {}
-    /// if let Err(_) = Err::<i32, i32>(42) {}
-    /// if let None = None::<()> {}
-    /// if let Some(_) = Some(42) {}
-    /// match Ok::<i32, i32>(42) {
-    ///     Ok(_) => true,
-    ///     Err(_) => false,
-    /// };
-    /// ```
-    ///
-    /// The more idiomatic use would be:
-    ///
-    /// ```rust
-    /// if Ok::<i32, i32>(42).is_ok() {}
-    /// if Err::<i32, i32>(42).is_err() {}
-    /// if None::<()>.is_none() {}
-    /// if Some(42).is_some() {}
-    /// Ok::<i32, i32>(42).is_ok();
-    /// ```
-    pub REDUNDANT_PATTERN_MATCHING,
-    style,
-    "use the proper utility function avoiding an `if let`"
-}
-
-declare_lint_pass!(RedundantPatternMatching => [REDUNDANT_PATTERN_MATCHING]);
-
-impl<'tcx> LateLintPass<'tcx> for RedundantPatternMatching {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if let ExprKind::Match(op, arms, ref match_source) = &expr.kind {
-            match match_source {
-                MatchSource::Normal => find_sugg_for_match(cx, expr, op, arms),
-                MatchSource::IfLetDesugar { .. } => find_sugg_for_if_let(cx, expr, op, arms, "if"),
-                MatchSource::WhileLetDesugar => find_sugg_for_if_let(cx, expr, op, arms, "while"),
-                _ => return,
-            }
-        }
-    }
-}
-
-fn find_sugg_for_if_let<'tcx>(
-    cx: &LateContext<'tcx>,
-    expr: &'tcx Expr<'_>,
-    op: &Expr<'_>,
-    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)
-            } else {
-                None
-            }
-        },
-        PatKind::Path(ref path) => find_suggestion(cx, hir_id, path),
-        _ => None,
-    };
-    let good_method = match good_method {
-        Some(method) => method,
-        None => return,
-    };
-
-    // check that `while_let_on_iterator` lint does not trigger
-    if_chain! {
-        if keyword == "while";
-        if let ExprKind::MethodCall(method_path, _, _, _) = op.kind;
-        if method_path.ident.name == sym!(next);
-        if match_trait_method(cx, op, &paths::ITERATOR);
-        then {
-            return;
-        }
-    }
-
-    span_lint_and_then(
-        cx,
-        REDUNDANT_PATTERN_MATCHING,
-        arms[0].pat.span,
-        &format!("redundant pattern matching, consider using `{}`", good_method),
-        |diag| {
-            // while let ... = ... { ... }
-            // ^^^^^^^^^^^^^^^^^^^^^^^^^^^
-            let expr_span = expr.span;
-
-            // while let ... = ... { ... }
-            //                 ^^^
-            let op_span = op.span.source_callsite();
-
-            // while let ... = ... { ... }
-            // ^^^^^^^^^^^^^^^^^^^
-            let span = expr_span.until(op_span.shrink_to_hi());
-            diag.span_suggestion(
-                span,
-                "try this",
-                format!("{} {}.{}", keyword, snippet(cx, op_span, "_"), good_method),
-                Applicability::MachineApplicable, // snippet
-            );
-        },
-    );
-}
-
-fn find_sugg_for_match<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, op: &Expr<'_>, arms: &[Arm<'_>]) {
-    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, _),
-                PatKind::TupleStruct(ref path_right, ref patterns_right, _),
-            ) if patterns_left.len() == 1 && patterns_right.len() == 1 => {
-                if let (PatKind::Wild, PatKind::Wild) = (&patterns_left[0].kind, &patterns_right[0].kind) {
-                    find_good_method_for_match(
-                        arms,
-                        path_left,
-                        path_right,
-                        &paths::RESULT_OK,
-                        &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
-                }
-            },
-            (PatKind::TupleStruct(ref path_left, ref patterns, _), PatKind::Path(ref path_right))
-            | (PatKind::Path(ref path_left), PatKind::TupleStruct(ref path_right, ref patterns, _))
-                if patterns.len() == 1 =>
-            {
-                if let PatKind::Wild = patterns[0].kind {
-                    find_good_method_for_match(
-                        arms,
-                        path_left,
-                        path_right,
-                        &paths::OPTION_SOME,
-                        &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
-                }
-            },
-            _ => None,
-        };
-
-        if let Some(good_method) = found_good_method {
-            span_lint_and_then(
-                cx,
-                REDUNDANT_PATTERN_MATCHING,
-                expr.span,
-                &format!("redundant pattern matching, consider using `{}`", good_method),
-                |diag| {
-                    let span = expr.span.to(op.span);
-                    diag.span_suggestion(
-                        span,
-                        "try this",
-                        format!("{}.{}", snippet(cx, op.span, "_"), good_method),
-                        Applicability::MaybeIncorrect, // snippet
-                    );
-                },
-            );
-        }
-    }
-}
-
-#[allow(clippy::too_many_arguments)]
-fn find_good_method_for_match<'a>(
-    arms: &[Arm<'_>],
-    path_left: &QPath<'_>,
-    path_right: &QPath<'_>,
-    expected_left: &[&str],
-    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)
-    } else if match_qpath(path_right, expected_left) && match_qpath(path_left, expected_right) {
-        (&(*arms[1].body).kind, &(*arms[0].body).kind)
-    } else {
-        return None;
-    };
-
-    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(false), LitKind::Bool(true)) if can_suggest_right() => 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))
-}
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index e681f47f949..888b4755484 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -1179,6 +1179,13 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
         deprecation: None,
         module: "matches",
     },
+    Lint {
+        name: "match_like_matches_macro",
+        group: "style",
+        desc: "a match that could be written with the matches! macro",
+        deprecation: None,
+        module: "matches",
+    },
     Lint {
         name: "match_on_vec_items",
         group: "pedantic",
@@ -1856,7 +1863,7 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
         group: "style",
         desc: "use the proper utility function avoiding an `if let`",
         deprecation: None,
-        module: "redundant_pattern_matching",
+        module: "matches",
     },
     Lint {
         name: "redundant_pub_crate",
diff --git a/tests/ui/find_map.rs b/tests/ui/find_map.rs
index c28cca144ca..88d3b0e7490 100644
--- a/tests/ui/find_map.rs
+++ b/tests/ui/find_map.rs
@@ -19,6 +19,7 @@ fn main() {
 
     let _: Option<i32> = a.iter().find(|s| s.parse::<i32>().is_ok()).map(|s| s.parse().unwrap());
 
+    #[allow(clippy::match_like_matches_macro)]
     let _: Option<Flavor> = desserts_of_the_week
         .iter()
         .find(|dessert| match *dessert {
diff --git a/tests/ui/find_map.stderr b/tests/ui/find_map.stderr
index 92f40fe6f1f..f279850fef8 100644
--- a/tests/ui/find_map.stderr
+++ b/tests/ui/find_map.stderr
@@ -8,7 +8,7 @@ LL |     let _: Option<i32> = a.iter().find(|s| s.parse::<i32>().is_ok()).map(|s
    = help: this is more succinctly expressed by calling `.find_map(..)` instead
 
 error: called `find(p).map(q)` on an `Iterator`
-  --> $DIR/find_map.rs:22:29
+  --> $DIR/find_map.rs:23:29
    |
 LL |       let _: Option<Flavor> = desserts_of_the_week
    |  _____________________________^
diff --git a/tests/ui/match_expr_like_matches_macro.fixed b/tests/ui/match_expr_like_matches_macro.fixed
new file mode 100644
index 00000000000..2d1ac8836d6
--- /dev/null
+++ b/tests/ui/match_expr_like_matches_macro.fixed
@@ -0,0 +1,32 @@
+// run-rustfix
+
+#![warn(clippy::match_like_matches_macro)]
+
+fn main() {
+    let x = Some(5);
+
+    // Lint
+    let _y = matches!(x, Some(0));
+
+    // Turn into is_none
+    let _z = x.is_none();
+
+    // Lint
+    let _z = !matches!(x, Some(r) if r == 0);
+
+    // Lint
+    let _zz = matches!(x, Some(5));
+
+    // No lint
+    let _a = match x {
+        Some(_) => false,
+        None => false,
+    };
+
+    // No lint
+    let _a = match x {
+        Some(0) => false,
+        Some(_) => true,
+        None => false,
+    };
+}
diff --git a/tests/ui/match_expr_like_matches_macro.rs b/tests/ui/match_expr_like_matches_macro.rs
new file mode 100644
index 00000000000..376abf9244e
--- /dev/null
+++ b/tests/ui/match_expr_like_matches_macro.rs
@@ -0,0 +1,41 @@
+// run-rustfix
+
+#![warn(clippy::match_like_matches_macro)]
+
+fn main() {
+    let x = Some(5);
+
+    // Lint
+    let _y = match x {
+        Some(0) => true,
+        _ => false,
+    };
+
+    // Turn into is_none
+    let _z = match x {
+        Some(_) => false,
+        None => true,
+    };
+
+    // Lint
+    let _z = match x {
+        Some(r) if r == 0 => false,
+        _ => true,
+    };
+
+    // Lint
+    let _zz = if let Some(5) = x { true } else { false };
+
+    // No lint
+    let _a = match x {
+        Some(_) => false,
+        None => false,
+    };
+
+    // No lint
+    let _a = match x {
+        Some(0) => false,
+        Some(_) => true,
+        None => false,
+    };
+}
diff --git a/tests/ui/match_expr_like_matches_macro.stderr b/tests/ui/match_expr_like_matches_macro.stderr
new file mode 100644
index 00000000000..0b32af039a8
--- /dev/null
+++ b/tests/ui/match_expr_like_matches_macro.stderr
@@ -0,0 +1,42 @@
+error: match expression looks like `matches!` macro
+  --> $DIR/match_expr_like_matches_macro.rs:9:14
+   |
+LL |       let _y = match x {
+   |  ______________^
+LL | |         Some(0) => true,
+LL | |         _ => false,
+LL | |     };
+   | |_____^ help: try this: `matches!(x, Some(0))`
+   |
+   = note: `-D clippy::match-like-matches-macro` implied by `-D warnings`
+
+error: redundant pattern matching, consider using `is_none()`
+  --> $DIR/match_expr_like_matches_macro.rs:15:14
+   |
+LL |       let _z = match x {
+   |  ______________^
+LL | |         Some(_) => false,
+LL | |         None => true,
+LL | |     };
+   | |_____^ help: try this: `x.is_none()`
+   |
+   = note: `-D clippy::redundant-pattern-matching` implied by `-D warnings`
+
+error: match expression looks like `matches!` macro
+  --> $DIR/match_expr_like_matches_macro.rs:21:14
+   |
+LL |       let _z = match x {
+   |  ______________^
+LL | |         Some(r) if r == 0 => false,
+LL | |         _ => true,
+LL | |     };
+   | |_____^ help: try this: `!matches!(x, Some(r) if r == 0)`
+
+error: if let .. else expression looks like `matches!` macro
+  --> $DIR/match_expr_like_matches_macro.rs:27:15
+   |
+LL |     let _zz = if let Some(5) = x { true } else { false };
+   |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `matches!(x, Some(5))`
+
+error: aborting due to 4 previous errors
+
diff --git a/tests/ui/neg_cmp_op_on_partial_ord.rs b/tests/ui/neg_cmp_op_on_partial_ord.rs
index ca70e3b7148..0cee0a28fc7 100644
--- a/tests/ui/neg_cmp_op_on_partial_ord.rs
+++ b/tests/ui/neg_cmp_op_on_partial_ord.rs
@@ -4,7 +4,7 @@
 
 use std::cmp::Ordering;
 
-#[allow(clippy::unnested_or_patterns)]
+#[allow(clippy::unnested_or_patterns, clippy::match_like_matches_macro)]
 #[warn(clippy::neg_cmp_op_on_partial_ord)]
 fn main() {
     let a_value = 1.0;
diff --git a/tests/ui/question_mark.fixed b/tests/ui/question_mark.fixed
index 11dff94a288..bd13cf1bdfa 100644
--- a/tests/ui/question_mark.fixed
+++ b/tests/ui/question_mark.fixed
@@ -23,10 +23,7 @@ pub enum SeemsOption<T> {
 
 impl<T> SeemsOption<T> {
     pub fn is_none(&self) -> bool {
-        match *self {
-            SeemsOption::None => true,
-            SeemsOption::Some(_) => false,
-        }
+        matches!(*self, SeemsOption::None)
     }
 }
 
diff --git a/tests/ui/question_mark.rs b/tests/ui/question_mark.rs
index 1d0ee82b4f7..94479e68555 100644
--- a/tests/ui/question_mark.rs
+++ b/tests/ui/question_mark.rs
@@ -25,10 +25,7 @@ pub enum SeemsOption<T> {
 
 impl<T> SeemsOption<T> {
     pub fn is_none(&self) -> bool {
-        match *self {
-            SeemsOption::None => true,
-            SeemsOption::Some(_) => false,
-        }
+        matches!(*self, SeemsOption::None)
     }
 }
 
diff --git a/tests/ui/question_mark.stderr b/tests/ui/question_mark.stderr
index 502615fb175..be323035d6c 100644
--- a/tests/ui/question_mark.stderr
+++ b/tests/ui/question_mark.stderr
@@ -9,7 +9,7 @@ LL | |     }
    = note: `-D clippy::question-mark` implied by `-D warnings`
 
 error: this block may be rewritten with the `?` operator
-  --> $DIR/question_mark.rs:50:9
+  --> $DIR/question_mark.rs:47:9
    |
 LL | /         if (self.opt).is_none() {
 LL | |             return None;
@@ -17,7 +17,7 @@ LL | |         }
    | |_________^ help: replace it with: `(self.opt)?;`
 
 error: this block may be rewritten with the `?` operator
-  --> $DIR/question_mark.rs:54:9
+  --> $DIR/question_mark.rs:51:9
    |
 LL | /         if self.opt.is_none() {
 LL | |             return None
@@ -25,7 +25,7 @@ LL | |         }
    | |_________^ help: replace it with: `self.opt?;`
 
 error: this block may be rewritten with the `?` operator
-  --> $DIR/question_mark.rs:58:17
+  --> $DIR/question_mark.rs:55:17
    |
 LL |           let _ = if self.opt.is_none() {
    |  _________________^
@@ -36,7 +36,7 @@ LL | |         };
    | |_________^ help: replace it with: `Some(self.opt?)`
 
 error: this if-let-else may be rewritten with the `?` operator
-  --> $DIR/question_mark.rs:64:17
+  --> $DIR/question_mark.rs:61:17
    |
 LL |           let _ = if let Some(x) = self.opt {
    |  _________________^
@@ -47,7 +47,7 @@ LL | |         };
    | |_________^ help: replace it with: `self.opt?`
 
 error: this block may be rewritten with the `?` operator
-  --> $DIR/question_mark.rs:81:9
+  --> $DIR/question_mark.rs:78:9
    |
 LL | /         if self.opt.is_none() {
 LL | |             return None;
@@ -55,7 +55,7 @@ LL | |         }
    | |_________^ help: replace it with: `self.opt.as_ref()?;`
 
 error: this block may be rewritten with the `?` operator
-  --> $DIR/question_mark.rs:89:9
+  --> $DIR/question_mark.rs:86:9
    |
 LL | /         if self.opt.is_none() {
 LL | |             return None;
@@ -63,7 +63,7 @@ LL | |         }
    | |_________^ help: replace it with: `self.opt.as_ref()?;`
 
 error: this block may be rewritten with the `?` operator
-  --> $DIR/question_mark.rs:97:9
+  --> $DIR/question_mark.rs:94:9
    |
 LL | /         if self.opt.is_none() {
 LL | |             return None;
@@ -71,7 +71,7 @@ LL | |         }
    | |_________^ help: replace it with: `self.opt.as_ref()?;`
 
 error: this if-let-else may be rewritten with the `?` operator
-  --> $DIR/question_mark.rs:104:26
+  --> $DIR/question_mark.rs:101:26
    |
 LL |           let v: &Vec<_> = if let Some(ref v) = self.opt {
    |  __________________________^
@@ -82,7 +82,7 @@ LL | |         };
    | |_________^ help: replace it with: `self.opt.as_ref()?`
 
 error: this if-let-else may be rewritten with the `?` operator
-  --> $DIR/question_mark.rs:114:17
+  --> $DIR/question_mark.rs:111:17
    |
 LL |           let v = if let Some(v) = self.opt {
    |  _________________^
@@ -93,7 +93,7 @@ LL | |         };
    | |_________^ help: replace it with: `self.opt?`
 
 error: this block may be rewritten with the `?` operator
-  --> $DIR/question_mark.rs:129:5
+  --> $DIR/question_mark.rs:126:5
    |
 LL | /     if f().is_none() {
 LL | |         return None;
diff --git a/tests/ui/redundant_pattern_matching.fixed b/tests/ui/redundant_pattern_matching.fixed
index 8b4e2d21331..ce8582d2b22 100644
--- a/tests/ui/redundant_pattern_matching.fixed
+++ b/tests/ui/redundant_pattern_matching.fixed
@@ -2,7 +2,13 @@
 
 #![warn(clippy::all)]
 #![warn(clippy::redundant_pattern_matching)]
-#![allow(clippy::unit_arg, unused_must_use, clippy::needless_bool, deprecated)]
+#![allow(
+    clippy::unit_arg,
+    unused_must_use,
+    clippy::needless_bool,
+    clippy::match_like_matches_macro,
+    deprecated
+)]
 
 fn main() {
     if Ok::<i32, i32>(42).is_ok() {}
diff --git a/tests/ui/redundant_pattern_matching.rs b/tests/ui/redundant_pattern_matching.rs
index b0904e41b6f..a3a9aa40e3b 100644
--- a/tests/ui/redundant_pattern_matching.rs
+++ b/tests/ui/redundant_pattern_matching.rs
@@ -2,7 +2,13 @@
 
 #![warn(clippy::all)]
 #![warn(clippy::redundant_pattern_matching)]
-#![allow(clippy::unit_arg, unused_must_use, clippy::needless_bool, deprecated)]
+#![allow(
+    clippy::unit_arg,
+    unused_must_use,
+    clippy::needless_bool,
+    clippy::match_like_matches_macro,
+    deprecated
+)]
 
 fn main() {
     if let Ok(_) = Ok::<i32, i32>(42) {}
diff --git a/tests/ui/redundant_pattern_matching.stderr b/tests/ui/redundant_pattern_matching.stderr
index 51a6f4350d3..25d1476062e 100644
--- a/tests/ui/redundant_pattern_matching.stderr
+++ b/tests/ui/redundant_pattern_matching.stderr
@@ -1,5 +1,5 @@
 error: redundant pattern matching, consider using `is_ok()`
-  --> $DIR/redundant_pattern_matching.rs:8:12
+  --> $DIR/redundant_pattern_matching.rs:14:12
    |
 LL |     if let Ok(_) = Ok::<i32, i32>(42) {}
    |     -------^^^^^--------------------- help: try this: `if Ok::<i32, i32>(42).is_ok()`
@@ -7,67 +7,67 @@ LL |     if let Ok(_) = Ok::<i32, i32>(42) {}
    = note: `-D clippy::redundant-pattern-matching` implied by `-D warnings`
 
 error: redundant pattern matching, consider using `is_err()`
-  --> $DIR/redundant_pattern_matching.rs:10:12
+  --> $DIR/redundant_pattern_matching.rs:16: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_none()`
-  --> $DIR/redundant_pattern_matching.rs:12:12
+  --> $DIR/redundant_pattern_matching.rs:18: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:14:12
+  --> $DIR/redundant_pattern_matching.rs:20: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:16:12
+  --> $DIR/redundant_pattern_matching.rs:22: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:22:15
+  --> $DIR/redundant_pattern_matching.rs:28: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:24:15
+  --> $DIR/redundant_pattern_matching.rs:30: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:26:15
+  --> $DIR/redundant_pattern_matching.rs:32: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:28:15
+  --> $DIR/redundant_pattern_matching.rs:34: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:30:15
+  --> $DIR/redundant_pattern_matching.rs:36: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:33:15
+  --> $DIR/redundant_pattern_matching.rs:39: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:49:5
+  --> $DIR/redundant_pattern_matching.rs:55:5
    |
 LL | /     match Ok::<i32, i32>(42) {
 LL | |         Ok(_) => true,
@@ -76,7 +76,7 @@ LL | |     };
    | |_____^ help: try this: `Ok::<i32, i32>(42).is_ok()`
 
 error: redundant pattern matching, consider using `is_err()`
-  --> $DIR/redundant_pattern_matching.rs:54:5
+  --> $DIR/redundant_pattern_matching.rs:60:5
    |
 LL | /     match Ok::<i32, i32>(42) {
 LL | |         Ok(_) => false,
@@ -85,7 +85,7 @@ LL | |     };
    | |_____^ help: try this: `Ok::<i32, i32>(42).is_err()`
 
 error: redundant pattern matching, consider using `is_err()`
-  --> $DIR/redundant_pattern_matching.rs:59:5
+  --> $DIR/redundant_pattern_matching.rs:65:5
    |
 LL | /     match Err::<i32, i32>(42) {
 LL | |         Ok(_) => false,
@@ -94,7 +94,7 @@ LL | |     };
    | |_____^ help: try this: `Err::<i32, i32>(42).is_err()`
 
 error: redundant pattern matching, consider using `is_ok()`
-  --> $DIR/redundant_pattern_matching.rs:64:5
+  --> $DIR/redundant_pattern_matching.rs:70:5
    |
 LL | /     match Err::<i32, i32>(42) {
 LL | |         Ok(_) => true,
@@ -103,7 +103,7 @@ LL | |     };
    | |_____^ help: try this: `Err::<i32, i32>(42).is_ok()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/redundant_pattern_matching.rs:69:5
+  --> $DIR/redundant_pattern_matching.rs:75:5
    |
 LL | /     match Some(42) {
 LL | |         Some(_) => true,
@@ -112,7 +112,7 @@ LL | |     };
    | |_____^ help: try this: `Some(42).is_some()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching.rs:74:5
+  --> $DIR/redundant_pattern_matching.rs:80:5
    |
 LL | /     match None::<()> {
 LL | |         Some(_) => false,
@@ -121,7 +121,7 @@ LL | |     };
    | |_____^ help: try this: `None::<()>.is_none()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching.rs:79:13
+  --> $DIR/redundant_pattern_matching.rs:85:13
    |
 LL |       let _ = match None::<()> {
    |  _____________^
@@ -131,61 +131,61 @@ LL | |     };
    | |_____^ help: try this: `None::<()>.is_none()`
 
 error: redundant pattern matching, consider using `is_ok()`
-  --> $DIR/redundant_pattern_matching.rs:84:20
+  --> $DIR/redundant_pattern_matching.rs:90: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:87:20
+  --> $DIR/redundant_pattern_matching.rs:93: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:93:20
+  --> $DIR/redundant_pattern_matching.rs:99: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:95:19
+  --> $DIR/redundant_pattern_matching.rs:101: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:97:19
+  --> $DIR/redundant_pattern_matching.rs:103:19
    |
 LL |     } else if let Ok(_) = gen_res() {
    |            -------^^^^^------------ help: try this: `if gen_res().is_ok()`
 
 error: redundant pattern matching, consider using `is_err()`
-  --> $DIR/redundant_pattern_matching.rs:99:19
+  --> $DIR/redundant_pattern_matching.rs:105: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:132:19
+  --> $DIR/redundant_pattern_matching.rs:138: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:133:16
+  --> $DIR/redundant_pattern_matching.rs:139: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:139:12
+  --> $DIR/redundant_pattern_matching.rs:145: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:140:15
+  --> $DIR/redundant_pattern_matching.rs:146:15
    |
 LL |     while let Some(_) = m!() {}
    |     ----------^^^^^^^------- help: try this: `while m!().is_some()`
diff --git a/tests/ui/redundant_pattern_matching_const_result.fixed b/tests/ui/redundant_pattern_matching_const_result.fixed
index 8a81e92f04a..de3fe00d5fa 100644
--- a/tests/ui/redundant_pattern_matching_const_result.fixed
+++ b/tests/ui/redundant_pattern_matching_const_result.fixed
@@ -2,7 +2,7 @@
 
 #![feature(const_result)]
 #![warn(clippy::redundant_pattern_matching)]
-#![allow(unused)]
+#![allow(clippy::match_like_matches_macro, unused)]
 
 // Test that results are linted with the feature enabled.
 
diff --git a/tests/ui/redundant_pattern_matching_const_result.rs b/tests/ui/redundant_pattern_matching_const_result.rs
index 1cd515441d1..b77969d53d9 100644
--- a/tests/ui/redundant_pattern_matching_const_result.rs
+++ b/tests/ui/redundant_pattern_matching_const_result.rs
@@ -2,7 +2,7 @@
 
 #![feature(const_result)]
 #![warn(clippy::redundant_pattern_matching)]
-#![allow(unused)]
+#![allow(clippy::match_like_matches_macro, unused)]
 
 // Test that results are linted with the feature enabled.
 
-- 
cgit 1.4.1-3-g733a5


From 0c8afa39ce8b2e7f0f9be7fc33fe3993d9bc3c53 Mon Sep 17 00:00:00 2001
From: Thiago Arrais <thiago.arrais@gmail.com>
Date: Mon, 1 Jun 2020 18:32:52 -0300
Subject: Lint x.log(b) / y.log(b) => x.log(y)

---
 clippy_lints/src/floating_point_arithmetic.rs | 65 ++++++++++++++++++++++-----
 tests/ui/floating_point_logbase.fixed         | 16 +++++++
 tests/ui/floating_point_logbase.rs            | 16 +++++++
 tests/ui/floating_point_logbase.stderr        | 28 ++++++++++++
 4 files changed, 115 insertions(+), 10 deletions(-)
 create mode 100644 tests/ui/floating_point_logbase.fixed
 create mode 100644 tests/ui/floating_point_logbase.rs
 create mode 100644 tests/ui/floating_point_logbase.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/floating_point_arithmetic.rs b/clippy_lints/src/floating_point_arithmetic.rs
index 3b2e46a9a85..9f241c2c3a2 100644
--- a/clippy_lints/src/floating_point_arithmetic.rs
+++ b/clippy_lints/src/floating_point_arithmetic.rs
@@ -293,13 +293,13 @@ fn check_powf(cx: &LateContext<'_>, expr: &Expr<'_>, args: &[Expr<'_>]) {
     }
 }
 
-fn check_powi(cx: &LateContext<'_, '_>, expr: &Expr<'_>, args: &[Expr<'_>]) {
+fn check_powi(cx: &LateContext<'_>, expr: &Expr<'_>, args: &[Expr<'_>]) {
     // Check argument
-    if let Some((value, _)) = constant(cx, cx.tables, &args[1]) {
+    if let Some((value, _)) = constant(cx, cx.tables(), &args[1]) {
         // TODO: need more specific check. this is too wide. remember also to include tests
         if let Some(parent) = get_parent_expr(cx, expr) {
             if let Some(grandparent) = get_parent_expr(cx, parent) {
-                if let ExprKind::MethodCall(PathSegment { ident: method_name, .. }, _, args) = grandparent.kind {
+                if let ExprKind::MethodCall(PathSegment { ident: method_name, .. }, _, args, _) = grandparent.kind {
                     if method_name.as_str() == "sqrt" && detect_hypot(cx, args).is_some() {
                         return;
                     }
@@ -328,7 +328,7 @@ fn check_powi(cx: &LateContext<'_, '_>, expr: &Expr<'_>, args: &[Expr<'_>]) {
     }
 }
 
-fn detect_hypot(cx: &LateContext<'_, '_>, args: &[Expr<'_>]) -> Option<String> {
+fn detect_hypot(cx: &LateContext<'_>, args: &[Expr<'_>]) -> Option<String> {
     if let ExprKind::Binary(
         Spanned {
             node: BinOpKind::Add, ..
@@ -350,11 +350,11 @@ fn detect_hypot(cx: &LateContext<'_, '_>, args: &[Expr<'_>]) -> Option<String> {
 
         // check if expression of the form x.powi(2) + y.powi(2)
         if_chain! {
-            if let ExprKind::MethodCall(PathSegment { ident: lmethod_name, .. }, ref _lspan, ref largs) = add_lhs.kind;
-            if let ExprKind::MethodCall(PathSegment { ident: rmethod_name, .. }, ref _rspan, ref rargs) = add_rhs.kind;
+            if let ExprKind::MethodCall(PathSegment { ident: lmethod_name, .. }, ref _lspan, ref largs, _) = add_lhs.kind;
+            if let ExprKind::MethodCall(PathSegment { ident: rmethod_name, .. }, ref _rspan, ref rargs, _) = add_rhs.kind;
             if lmethod_name.as_str() == "powi" && rmethod_name.as_str() == "powi";
-            if let Some((lvalue, _)) = constant(cx, cx.tables, &largs[1]);
-            if let Some((rvalue, _)) = constant(cx, cx.tables, &rargs[1]);
+            if let Some((lvalue, _)) = constant(cx, cx.tables(), &largs[1]);
+            if let Some((rvalue, _)) = constant(cx, cx.tables(), &rargs[1]);
             if Int(2) == lvalue && Int(2) == rvalue;
             then {
                 return Some(format!("{}.hypot({})", Sugg::hir(cx, &largs[0], ".."), Sugg::hir(cx, &rargs[0], "..")));
@@ -365,7 +365,7 @@ fn detect_hypot(cx: &LateContext<'_, '_>, args: &[Expr<'_>]) -> Option<String> {
     None
 }
 
-fn check_hypot(cx: &LateContext<'_, '_>, expr: &Expr<'_>, args: &[Expr<'_>]) {
+fn check_hypot(cx: &LateContext<'_>, expr: &Expr<'_>, args: &[Expr<'_>]) {
     if let Some(message) = detect_hypot(cx, args) {
         span_lint_and_sugg(
             cx,
@@ -431,7 +431,7 @@ fn check_mul_add(cx: &LateContext<'_>, expr: &Expr<'_>) {
     ) = &expr.kind
     {
         if let Some(parent) = get_parent_expr(cx, expr) {
-            if let ExprKind::MethodCall(PathSegment { ident: method_name, .. }, _, args) = parent.kind {
+            if let ExprKind::MethodCall(PathSegment { ident: method_name, .. }, _, args, _) = parent.kind {
                 if method_name.as_str() == "sqrt" && detect_hypot(cx, args).is_some() {
                     return;
                 }
@@ -573,6 +573,50 @@ fn check_custom_abs(cx: &LateContext<'_>, expr: &Expr<'_>) {
     }
 }
 
+fn are_same_base_logs(cx: &LateContext<'_>, expr_a: &Expr<'_>, expr_b: &Expr<'_>) -> bool {
+    if_chain! {
+        if let ExprKind::MethodCall(PathSegment { ident: method_name_a, .. }, _, ref args_a, _) = expr_a.kind;
+        if let ExprKind::MethodCall(PathSegment { ident: method_name_b, .. }, _, ref args_b, _) = expr_b.kind;
+        then {
+            return method_name_a.as_str() == method_name_b.as_str() &&
+                args_a.len() == args_b.len() &&
+                (
+                    ["ln", "log2", "log10"].contains(&&*method_name_a.as_str()) ||
+                    method_name_a.as_str() == "log" && args_a.len() == 2 && are_exprs_equal(cx, &args_a[1], &args_b[1])
+                );
+        }
+    }
+
+    false
+}
+
+fn check_log_division(cx: &LateContext<'_>, expr: &Expr<'_>) {
+    // check if expression of the form x.logN() / y.logN()
+    if_chain! {
+        if let ExprKind::Binary(
+            Spanned {
+                node: BinOpKind::Div, ..
+            },
+            lhs,
+            rhs,
+        ) = &expr.kind;
+        if are_same_base_logs(cx, lhs, rhs);
+        if let ExprKind::MethodCall(_, _, ref largs, _) = lhs.kind;
+        if let ExprKind::MethodCall(_, _, ref rargs, _) = rhs.kind;
+        then {
+            span_lint_and_sugg(
+                cx,
+                SUBOPTIMAL_FLOPS,
+                expr.span,
+                "division of logarithms can be calculated more efficiently and accurately",
+                "consider using",
+                format!("{}.log({})", Sugg::hir(cx, &largs[0], ".."), Sugg::hir(cx, &rargs[0], ".."),),
+                Applicability::MachineApplicable,
+            );
+        }
+    }
+}
+
 impl<'tcx> LateLintPass<'tcx> for FloatingPointArithmetic {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if let ExprKind::MethodCall(ref path, _, args, _) = &expr.kind {
@@ -592,6 +636,7 @@ impl<'tcx> LateLintPass<'tcx> for FloatingPointArithmetic {
             check_expm1(cx, expr);
             check_mul_add(cx, expr);
             check_custom_abs(cx, expr);
+            check_log_division(cx, expr);
         }
     }
 }
diff --git a/tests/ui/floating_point_logbase.fixed b/tests/ui/floating_point_logbase.fixed
new file mode 100644
index 00000000000..13962a272d4
--- /dev/null
+++ b/tests/ui/floating_point_logbase.fixed
@@ -0,0 +1,16 @@
+// run-rustfix
+#![warn(clippy::suboptimal_flops)]
+
+fn main() {
+    let x = 3f32;
+    let y = 5f32;
+    let _ = x.log(y);
+    let _ = x.log(y);
+    let _ = x.log(y);
+    let _ = x.log(y);
+    // Cases where the lint shouldn't be applied
+    let _ = x.ln() / y.powf(3.2);
+    let _ = x.powf(3.2) / y.powf(3.2);
+    let _ = x.powf(3.2) / y.ln();
+    let _ = x.log(5f32) / y.log(7f32);
+}
diff --git a/tests/ui/floating_point_logbase.rs b/tests/ui/floating_point_logbase.rs
new file mode 100644
index 00000000000..26bc20d5370
--- /dev/null
+++ b/tests/ui/floating_point_logbase.rs
@@ -0,0 +1,16 @@
+// run-rustfix
+#![warn(clippy::suboptimal_flops)]
+
+fn main() {
+    let x = 3f32;
+    let y = 5f32;
+    let _ = x.ln() / y.ln();
+    let _ = x.log2() / y.log2();
+    let _ = x.log10() / y.log10();
+    let _ = x.log(5f32) / y.log(5f32);
+    // Cases where the lint shouldn't be applied
+    let _ = x.ln() / y.powf(3.2);
+    let _ = x.powf(3.2) / y.powf(3.2);
+    let _ = x.powf(3.2) / y.ln();
+    let _ = x.log(5f32) / y.log(7f32);
+}
diff --git a/tests/ui/floating_point_logbase.stderr b/tests/ui/floating_point_logbase.stderr
new file mode 100644
index 00000000000..fa956b9139e
--- /dev/null
+++ b/tests/ui/floating_point_logbase.stderr
@@ -0,0 +1,28 @@
+error: division of logarithms can be calculated more efficiently and accurately
+  --> $DIR/floating_point_logbase.rs:7:13
+   |
+LL |     let _ = x.ln() / y.ln();
+   |             ^^^^^^^^^^^^^^^ help: consider using: `x.log(y)`
+   |
+   = note: `-D clippy::suboptimal-flops` implied by `-D warnings`
+
+error: division of logarithms can be calculated more efficiently and accurately
+  --> $DIR/floating_point_logbase.rs:8:13
+   |
+LL |     let _ = x.log2() / y.log2();
+   |             ^^^^^^^^^^^^^^^^^^^ help: consider using: `x.log(y)`
+
+error: division of logarithms can be calculated more efficiently and accurately
+  --> $DIR/floating_point_logbase.rs:9:13
+   |
+LL |     let _ = x.log10() / y.log10();
+   |             ^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.log(y)`
+
+error: division of logarithms can be calculated more efficiently and accurately
+  --> $DIR/floating_point_logbase.rs:10:13
+   |
+LL |     let _ = x.log(5f32) / y.log(5f32);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.log(y)`
+
+error: aborting due to 4 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 1740dda76386aff7205b2a709a32c95e8cbc0d57 Mon Sep 17 00:00:00 2001
From: robojumper <robojumper@gmail.com>
Date: Sun, 5 Jul 2020 22:11:19 +0200
Subject: fix match_like_matches_macro in clippy

---
 clippy_lints/src/assign_ops.rs            |  1 +
 clippy_lints/src/comparison_chain.rs      |  5 +----
 clippy_lints/src/eq_op.rs                 | 30 +++++++++++++++---------------
 clippy_lints/src/escape.rs                |  5 +----
 clippy_lints/src/eta_reduction.rs         |  5 +----
 clippy_lints/src/formatting.rs            | 12 ++----------
 clippy_lints/src/functions.rs             |  8 +-------
 clippy_lints/src/lib.rs                   | 11 ++++++-----
 clippy_lints/src/lifetimes.rs             | 16 ++++++++--------
 clippy_lints/src/loops.rs                 | 10 ++--------
 clippy_lints/src/methods/mod.rs           | 16 +++++-----------
 clippy_lints/src/misc.rs                  |  7 +------
 clippy_lints/src/misc_early.rs            | 18 ++++++------------
 clippy_lints/src/missing_inline.rs        |  9 +++++----
 clippy_lints/src/new_without_default.rs   | 10 ++++++----
 clippy_lints/src/non_copy_const.rs        |  8 ++++----
 clippy_lints/src/precedence.rs            | 10 ++--------
 clippy_lints/src/regex.rs                 |  7 +------
 clippy_lints/src/shadow.rs                |  5 +----
 clippy_lints/src/temporary_assignment.rs  |  8 +-------
 clippy_lints/src/types.rs                 | 29 ++++++++---------------------
 clippy_lints/src/unnamed_address.rs       | 14 +++++---------
 clippy_lints/src/use_self.rs              |  6 ++----
 clippy_lints/src/utils/ast_utils.rs       |  5 +----
 clippy_lints/src/utils/mod.rs             | 11 ++---------
 clippy_lints/src/utils/numeric_literal.rs |  2 +-
 src/driver.rs                             |  9 ++-------
 27 files changed, 91 insertions(+), 186 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/assign_ops.rs b/clippy_lints/src/assign_ops.rs
index bc6e868823f..3d48bf739eb 100644
--- a/clippy_lints/src/assign_ops.rs
+++ b/clippy_lints/src/assign_ops.rs
@@ -237,6 +237,7 @@ fn is_commutative(op: hir::BinOpKind) -> bool {
     use rustc_hir::BinOpKind::{
         Add, And, BitAnd, BitOr, BitXor, Div, Eq, Ge, Gt, Le, Lt, Mul, Ne, Or, Rem, Shl, Shr, Sub,
     };
+    #[allow(clippy::match_like_matches_macro)]
     match op {
         Add | Mul | And | Or | BitXor | BitAnd | BitOr | Eq | Ne => true,
         Sub | Div | Rem | Shl | Shr | Lt | Le | Ge | Gt => false,
diff --git a/clippy_lints/src/comparison_chain.rs b/clippy_lints/src/comparison_chain.rs
index 26476af4cb6..25ccabc1c88 100644
--- a/clippy_lints/src/comparison_chain.rs
+++ b/clippy_lints/src/comparison_chain.rs
@@ -122,8 +122,5 @@ impl<'tcx> LateLintPass<'tcx> for ComparisonChain {
 }
 
 fn kind_is_cmp(kind: BinOpKind) -> bool {
-    match kind {
-        BinOpKind::Lt | BinOpKind::Gt | BinOpKind::Eq => true,
-        _ => false,
-    }
+    matches!(kind, BinOpKind::Lt | BinOpKind::Gt | BinOpKind::Eq)
 }
diff --git a/clippy_lints/src/eq_op.rs b/clippy_lints/src/eq_op.rs
index ca921dcfdfe..7839908fe4c 100644
--- a/clippy_lints/src/eq_op.rs
+++ b/clippy_lints/src/eq_op.rs
@@ -214,20 +214,20 @@ impl<'tcx> LateLintPass<'tcx> for EqOp {
 }
 
 fn is_valid_operator(op: BinOp) -> bool {
-    match op.node {
+    matches!(
+        op.node,
         BinOpKind::Sub
-        | BinOpKind::Div
-        | BinOpKind::Eq
-        | BinOpKind::Lt
-        | BinOpKind::Le
-        | BinOpKind::Gt
-        | BinOpKind::Ge
-        | BinOpKind::Ne
-        | BinOpKind::And
-        | BinOpKind::Or
-        | BinOpKind::BitXor
-        | BinOpKind::BitAnd
-        | BinOpKind::BitOr => true,
-        _ => false,
-    }
+            | BinOpKind::Div
+            | BinOpKind::Eq
+            | BinOpKind::Lt
+            | BinOpKind::Le
+            | BinOpKind::Gt
+            | BinOpKind::Ge
+            | BinOpKind::Ne
+            | BinOpKind::And
+            | BinOpKind::Or
+            | BinOpKind::BitXor
+            | BinOpKind::BitAnd
+            | BinOpKind::BitOr
+    )
 }
diff --git a/clippy_lints/src/escape.rs b/clippy_lints/src/escape.rs
index d40cdfcca9f..32fc01149d8 100644
--- a/clippy_lints/src/escape.rs
+++ b/clippy_lints/src/escape.rs
@@ -105,10 +105,7 @@ fn is_argument(map: rustc_middle::hir::map::Map<'_>, id: HirId) -> bool {
         _ => return false,
     }
 
-    match map.find(map.get_parent_node(id)) {
-        Some(Node::Param(_)) => true,
-        _ => false,
-    }
+    matches!(map.find(map.get_parent_node(id)), Some(Node::Param(_)))
 }
 
 impl<'a, 'tcx> Delegate<'tcx> for EscapeDelegate<'a, 'tcx> {
diff --git a/clippy_lints/src/eta_reduction.rs b/clippy_lints/src/eta_reduction.rs
index ceed6a74c4f..fb26b9fc27d 100644
--- a/clippy_lints/src/eta_reduction.rs
+++ b/clippy_lints/src/eta_reduction.rs
@@ -175,10 +175,7 @@ fn get_ufcs_type_name(cx: &LateContext<'_>, method_def_id: def_id::DefId, self_a
 fn match_borrow_depth(lhs: Ty<'_>, rhs: Ty<'_>) -> bool {
     match (&lhs.kind, &rhs.kind) {
         (ty::Ref(_, t1, mut1), ty::Ref(_, t2, mut2)) => mut1 == mut2 && match_borrow_depth(&t1, &t2),
-        (l, r) => match (l, r) {
-            (ty::Ref(_, _, _), _) | (_, ty::Ref(_, _, _)) => false,
-            (_, _) => true,
-        },
+        (l, r) => !matches!((l, r), (ty::Ref(_, _, _), _) | (_, ty::Ref(_, _, _))),
     }
 }
 
diff --git a/clippy_lints/src/formatting.rs b/clippy_lints/src/formatting.rs
index 156246fb8bb..1bd16e6cce5 100644
--- a/clippy_lints/src/formatting.rs
+++ b/clippy_lints/src/formatting.rs
@@ -305,18 +305,10 @@ fn check_missing_else(cx: &EarlyContext<'_>, first: &Expr, second: &Expr) {
 }
 
 fn is_block(expr: &Expr) -> bool {
-    if let ExprKind::Block(..) = expr.kind {
-        true
-    } else {
-        false
-    }
+    matches!(expr.kind, ExprKind::Block(..))
 }
 
 /// Check if the expression is an `if` or `if let`
 fn is_if(expr: &Expr) -> bool {
-    if let ExprKind::If(..) = expr.kind {
-        true
-    } else {
-        false
-    }
+    matches!(expr.kind, ExprKind::If(..))
 }
diff --git a/clippy_lints/src/functions.rs b/clippy_lints/src/functions.rs
index 3f030dd8422..63133a4872a 100644
--- a/clippy_lints/src/functions.rs
+++ b/clippy_lints/src/functions.rs
@@ -645,13 +645,7 @@ fn is_mutated_static(cx: &LateContext<'_>, e: &hir::Expr<'_>) -> bool {
     use hir::ExprKind::{Field, Index, Path};
 
     match e.kind {
-        Path(ref qpath) => {
-            if let Res::Local(_) = qpath_res(cx, qpath, e.hir_id) {
-                false
-            } else {
-                true
-            }
-        },
+        Path(ref qpath) => !matches!(qpath_res(cx, qpath, e.hir_id), Res::Local(_)),
         Field(ref inner, _) | Index(ref inner, _) => is_mutated_static(cx, inner),
         _ => false,
     }
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index fe34e4390d6..c4f1af8f4e4 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -277,7 +277,6 @@ mod question_mark;
 mod ranges;
 mod redundant_clone;
 mod redundant_field_names;
-mod redundant_pattern_matching;
 mod redundant_pub_crate;
 mod redundant_static_lifetimes;
 mod reference;
@@ -623,11 +622,13 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &matches::INFALLIBLE_DESTRUCTURING_MATCH,
         &matches::MATCH_AS_REF,
         &matches::MATCH_BOOL,
+        &matches::MATCH_LIKE_MATCHES_MACRO,
         &matches::MATCH_OVERLAPPING_ARM,
         &matches::MATCH_REF_PATS,
         &matches::MATCH_SINGLE_BINDING,
         &matches::MATCH_WILDCARD_FOR_SINGLE_VARIANTS,
         &matches::MATCH_WILD_ERR_ARM,
+        &matches::REDUNDANT_PATTERN_MATCHING,
         &matches::REST_PAT_IN_FULLY_BOUND_STRUCTS,
         &matches::SINGLE_MATCH,
         &matches::SINGLE_MATCH_ELSE,
@@ -757,7 +758,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &ranges::REVERSED_EMPTY_RANGES,
         &redundant_clone::REDUNDANT_CLONE,
         &redundant_field_names::REDUNDANT_FIELD_NAMES,
-        &redundant_pattern_matching::REDUNDANT_PATTERN_MATCHING,
         &redundant_pub_crate::REDUNDANT_PUB_CRATE,
         &redundant_static_lifetimes::REDUNDANT_STATIC_LIFETIMES,
         &reference::DEREF_ADDROF,
@@ -956,7 +956,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box missing_doc::MissingDoc::new());
     store.register_late_pass(|| box missing_inline::MissingInline);
     store.register_late_pass(|| box if_let_some_result::OkIfLet);
-    store.register_late_pass(|| box redundant_pattern_matching::RedundantPatternMatching);
     store.register_late_pass(|| box partialeq_ne_impl::PartialEqNeImpl);
     store.register_late_pass(|| box unused_io_amount::UnusedIoAmount);
     let enum_variant_size_threshold = conf.enum_variant_size_threshold;
@@ -1295,9 +1294,11 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&map_unit_fn::RESULT_MAP_UNIT_FN),
         LintId::of(&matches::INFALLIBLE_DESTRUCTURING_MATCH),
         LintId::of(&matches::MATCH_AS_REF),
+        LintId::of(&matches::MATCH_LIKE_MATCHES_MACRO),
         LintId::of(&matches::MATCH_OVERLAPPING_ARM),
         LintId::of(&matches::MATCH_REF_PATS),
         LintId::of(&matches::MATCH_SINGLE_BINDING),
+        LintId::of(&matches::REDUNDANT_PATTERN_MATCHING),
         LintId::of(&matches::SINGLE_MATCH),
         LintId::of(&matches::WILDCARD_IN_OR_PATTERNS),
         LintId::of(&mem_discriminant::MEM_DISCRIMINANT_NON_ENUM),
@@ -1387,7 +1388,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&ranges::REVERSED_EMPTY_RANGES),
         LintId::of(&redundant_clone::REDUNDANT_CLONE),
         LintId::of(&redundant_field_names::REDUNDANT_FIELD_NAMES),
-        LintId::of(&redundant_pattern_matching::REDUNDANT_PATTERN_MATCHING),
         LintId::of(&redundant_static_lifetimes::REDUNDANT_STATIC_LIFETIMES),
         LintId::of(&reference::DEREF_ADDROF),
         LintId::of(&reference::REF_IN_DEREF),
@@ -1488,8 +1488,10 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE),
         LintId::of(&map_clone::MAP_CLONE),
         LintId::of(&matches::INFALLIBLE_DESTRUCTURING_MATCH),
+        LintId::of(&matches::MATCH_LIKE_MATCHES_MACRO),
         LintId::of(&matches::MATCH_OVERLAPPING_ARM),
         LintId::of(&matches::MATCH_REF_PATS),
+        LintId::of(&matches::REDUNDANT_PATTERN_MATCHING),
         LintId::of(&matches::SINGLE_MATCH),
         LintId::of(&mem_replace::MEM_REPLACE_OPTION_WITH_NONE),
         LintId::of(&mem_replace::MEM_REPLACE_WITH_DEFAULT),
@@ -1526,7 +1528,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&ptr::PTR_ARG),
         LintId::of(&question_mark::QUESTION_MARK),
         LintId::of(&redundant_field_names::REDUNDANT_FIELD_NAMES),
-        LintId::of(&redundant_pattern_matching::REDUNDANT_PATTERN_MATCHING),
         LintId::of(&redundant_static_lifetimes::REDUNDANT_STATIC_LIFETIMES),
         LintId::of(&regex::TRIVIAL_REGEX),
         LintId::of(&returns::NEEDLESS_RETURN),
diff --git a/clippy_lints/src/lifetimes.rs b/clippy_lints/src/lifetimes.rs
index a79f94855bd..168f9f953e4 100644
--- a/clippy_lints/src/lifetimes.rs
+++ b/clippy_lints/src/lifetimes.rs
@@ -129,10 +129,10 @@ fn check_fn_inner<'tcx>(
     }
 
     let mut bounds_lts = Vec::new();
-    let types = generics.params.iter().filter(|param| match param.kind {
-        GenericParamKind::Type { .. } => true,
-        _ => false,
-    });
+    let types = generics
+        .params
+        .iter()
+        .filter(|param| matches!(param.kind, GenericParamKind::Type { .. }));
     for typ in types {
         for bound in typ.bounds {
             let mut visitor = RefVisitor::new(cx);
@@ -337,10 +337,10 @@ impl<'a, 'tcx> RefVisitor<'a, 'tcx> {
     fn collect_anonymous_lifetimes(&mut self, qpath: &QPath<'_>, ty: &Ty<'_>) {
         if let Some(ref last_path_segment) = last_path_segment(qpath).args {
             if !last_path_segment.parenthesized
-                && !last_path_segment.args.iter().any(|arg| match arg {
-                    GenericArg::Lifetime(_) => true,
-                    _ => false,
-                })
+                && !last_path_segment
+                    .args
+                    .iter()
+                    .any(|arg| matches!(arg, GenericArg::Lifetime(_)))
             {
                 let hir_id = ty.hir_id;
                 match self.cx.qpath_res(qpath, hir_id) {
diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index b803d753b6d..396bb659109 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -2091,17 +2091,11 @@ fn var_def_id(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<HirId> {
 }
 
 fn is_loop(expr: &Expr<'_>) -> bool {
-    match expr.kind {
-        ExprKind::Loop(..) => true,
-        _ => false,
-    }
+    matches!(expr.kind, ExprKind::Loop(..))
 }
 
 fn is_conditional(expr: &Expr<'_>) -> bool {
-    match expr.kind {
-        ExprKind::Match(..) => true,
-        _ => false,
-    }
+    matches!(expr.kind, ExprKind::Match(..))
 }
 
 fn is_nested(cx: &LateContext<'_>, match_expr: &Expr<'_>, iter_expr: &Expr<'_>) -> bool {
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index f1c8894c0ee..4c595029ff7 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1844,10 +1844,10 @@ fn lint_expect_fun_call(
                         ty::Ref(ty::ReStatic, ..)
                     )
                 }),
-            hir::ExprKind::Path(ref p) => match cx.qpath_res(p, arg.hir_id) {
-                hir::def::Res::Def(hir::def::DefKind::Const | hir::def::DefKind::Static, _) => true,
-                _ => false,
-            },
+            hir::ExprKind::Path(ref p) => matches!(
+                cx.qpath_res(p, arg.hir_id),
+                hir::def::Res::Def(hir::def::DefKind::Const | hir::def::DefKind::Static, _)
+            ),
             _ => false,
         }
     }
@@ -2028,13 +2028,7 @@ fn lint_clone_on_copy(cx: &LateContext<'_>, expr: &hir::Expr<'_>, arg: &hir::Exp
                     .tables()
                     .expr_adjustments(arg)
                     .iter()
-                    .filter(|adj| {
-                        if let ty::adjustment::Adjust::Deref(_) = adj.kind {
-                            true
-                        } else {
-                            false
-                        }
-                    })
+                    .filter(|adj| matches!(adj.kind, ty::adjustment::Adjust::Deref(_)))
                     .count();
                 let derefs: String = iter::repeat('*').take(deref_count).collect();
                 snip = Some(("try dereferencing it", format!("{}{}", derefs, snippet)));
diff --git a/clippy_lints/src/misc.rs b/clippy_lints/src/misc.rs
index 3d4225f36a7..400f4b609af 100644
--- a/clippy_lints/src/misc.rs
+++ b/clippy_lints/src/misc.rs
@@ -694,12 +694,7 @@ fn in_attributes_expansion(expr: &Expr<'_>) -> bool {
     use rustc_span::hygiene::MacroKind;
     if expr.span.from_expansion() {
         let data = expr.span.ctxt().outer_expn_data();
-
-        if let ExpnKind::Macro(MacroKind::Attr, _) = data.kind {
-            true
-        } else {
-            false
-        }
+        matches!(data.kind, ExpnKind::Macro(MacroKind::Attr, _))
     } else {
         false
     }
diff --git a/clippy_lints/src/misc_early.rs b/clippy_lints/src/misc_early.rs
index ad39e59d067..b84a1a3fe24 100644
--- a/clippy_lints/src/misc_early.rs
+++ b/clippy_lints/src/misc_early.rs
@@ -641,28 +641,22 @@ fn check_unneeded_wildcard_pattern(cx: &EarlyContext<'_>, pat: &Pat) {
             );
         }
 
-        #[allow(clippy::trivially_copy_pass_by_ref)]
-        fn is_wild<P: std::ops::Deref<Target = Pat>>(pat: &&P) -> bool {
-            if let PatKind::Wild = pat.kind {
-                true
-            } else {
-                false
-            }
-        }
-
         if let Some(rest_index) = patterns.iter().position(|pat| pat.is_rest()) {
             if let Some((left_index, left_pat)) = patterns[..rest_index]
                 .iter()
                 .rev()
-                .take_while(is_wild)
+                .take_while(|pat| matches!(pat.kind, PatKind::Wild))
                 .enumerate()
                 .last()
             {
                 span_lint(cx, left_pat.span.until(patterns[rest_index].span), left_index == 0);
             }
 
-            if let Some((right_index, right_pat)) =
-                patterns[rest_index + 1..].iter().take_while(is_wild).enumerate().last()
+            if let Some((right_index, right_pat)) = patterns[rest_index + 1..]
+                .iter()
+                .take_while(|pat| matches!(pat.kind, PatKind::Wild))
+                .enumerate()
+                .last()
             {
                 span_lint(
                     cx,
diff --git a/clippy_lints/src/missing_inline.rs b/clippy_lints/src/missing_inline.rs
index bf80b62afe6..9c962673537 100644
--- a/clippy_lints/src/missing_inline.rs
+++ b/clippy_lints/src/missing_inline.rs
@@ -71,10 +71,11 @@ fn check_missing_inline_attrs(cx: &LateContext<'_>, attrs: &[ast::Attribute], sp
 fn is_executable(cx: &LateContext<'_>) -> bool {
     use rustc_session::config::CrateType;
 
-    cx.tcx.sess.crate_types().iter().any(|t: &CrateType| match t {
-        CrateType::Executable => true,
-        _ => false,
-    })
+    cx.tcx
+        .sess
+        .crate_types()
+        .iter()
+        .any(|t: &CrateType| matches!(t, CrateType::Executable))
 }
 
 declare_lint_pass!(MissingInline => [MISSING_INLINE_IN_PUBLIC_ITEMS]);
diff --git a/clippy_lints/src/new_without_default.rs b/clippy_lints/src/new_without_default.rs
index 2597f5f6f17..621ebdef2f0 100644
--- a/clippy_lints/src/new_without_default.rs
+++ b/clippy_lints/src/new_without_default.rs
@@ -80,10 +80,12 @@ impl<'tcx> LateLintPass<'tcx> for NewWithoutDefault {
                             // can't be implemented for unsafe new
                             return;
                         }
-                        if impl_item.generics.params.iter().any(|gen| match gen.kind {
-                            hir::GenericParamKind::Type { .. } => true,
-                            _ => false,
-                        }) {
+                        if impl_item
+                            .generics
+                            .params
+                            .iter()
+                            .any(|gen| matches!(gen.kind, hir::GenericParamKind::Type { .. }))
+                        {
                             // when the result of `new()` depends on a type parameter we should not require
                             // an
                             // impl of `Default`
diff --git a/clippy_lints/src/non_copy_const.rs b/clippy_lints/src/non_copy_const.rs
index c11a2ff9ee0..a3521c31a6b 100644
--- a/clippy_lints/src/non_copy_const.rs
+++ b/clippy_lints/src/non_copy_const.rs
@@ -238,10 +238,10 @@ impl<'tcx> LateLintPass<'tcx> for NonCopyConst {
 
             let ty = if needs_check_adjustment {
                 let adjustments = cx.tables().expr_adjustments(dereferenced_expr);
-                if let Some(i) = adjustments.iter().position(|adj| match adj.kind {
-                    Adjust::Borrow(_) | Adjust::Deref(_) => true,
-                    _ => false,
-                }) {
+                if let Some(i) = adjustments
+                    .iter()
+                    .position(|adj| matches!(adj.kind, Adjust::Borrow(_) | Adjust::Deref(_)))
+                {
                     if i == 0 {
                         cx.tables().expr_ty(dereferenced_expr)
                     } else {
diff --git a/clippy_lints/src/precedence.rs b/clippy_lints/src/precedence.rs
index 7dce23dd223..04be96aa64c 100644
--- a/clippy_lints/src/precedence.rs
+++ b/clippy_lints/src/precedence.rs
@@ -148,17 +148,11 @@ fn is_arith_expr(expr: &Expr) -> bool {
 #[must_use]
 fn is_bit_op(op: BinOpKind) -> bool {
     use rustc_ast::ast::BinOpKind::{BitAnd, BitOr, BitXor, Shl, Shr};
-    match op {
-        BitXor | BitAnd | BitOr | Shl | Shr => true,
-        _ => false,
-    }
+    matches!(op, BitXor | BitAnd | BitOr | Shl | Shr)
 }
 
 #[must_use]
 fn is_arith_op(op: BinOpKind) -> bool {
     use rustc_ast::ast::BinOpKind::{Add, Div, Mul, Rem, Sub};
-    match op {
-        Add | Sub | Mul | Div | Rem => true,
-        _ => false,
-    }
+    matches!(op, Add | Sub | Mul | Div | Rem)
 }
diff --git a/clippy_lints/src/regex.rs b/clippy_lints/src/regex.rs
index d8c8eff2c85..f204a0ffb2c 100644
--- a/clippy_lints/src/regex.rs
+++ b/clippy_lints/src/regex.rs
@@ -99,12 +99,7 @@ fn is_trivial_regex(s: &regex_syntax::hir::Hir) -> Option<&'static str> {
     use regex_syntax::hir::Anchor::{EndText, StartText};
     use regex_syntax::hir::HirKind::{Alternation, Anchor, Concat, Empty, Literal};
 
-    let is_literal = |e: &[regex_syntax::hir::Hir]| {
-        e.iter().all(|e| match *e.kind() {
-            Literal(_) => true,
-            _ => false,
-        })
-    };
+    let is_literal = |e: &[regex_syntax::hir::Hir]| e.iter().all(|e| matches!(*e.kind(), Literal(_)));
 
     match *s.kind() {
         Empty | Anchor(_) => Some("the regex is unlikely to be useful as it is"),
diff --git a/clippy_lints/src/shadow.rs b/clippy_lints/src/shadow.rs
index 4cdff63f118..194786c5c41 100644
--- a/clippy_lints/src/shadow.rs
+++ b/clippy_lints/src/shadow.rs
@@ -165,10 +165,7 @@ fn check_local<'tcx>(cx: &LateContext<'tcx>, local: &'tcx Local<'_>, bindings: &
 
 fn is_binding(cx: &LateContext<'_>, pat_id: HirId) -> bool {
     let var_ty = cx.tables().node_type_opt(pat_id);
-    var_ty.map_or(false, |var_ty| match var_ty.kind {
-        ty::Adt(..) => false,
-        _ => true,
-    })
+    var_ty.map_or(false, |var_ty| !matches!(var_ty.kind, ty::Adt(..)))
 }
 
 fn check_pat<'tcx>(
diff --git a/clippy_lints/src/temporary_assignment.rs b/clippy_lints/src/temporary_assignment.rs
index 509bbfd27c1..1aeff1baa36 100644
--- a/clippy_lints/src/temporary_assignment.rs
+++ b/clippy_lints/src/temporary_assignment.rs
@@ -25,13 +25,7 @@ declare_clippy_lint! {
 fn is_temporary(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
     match &expr.kind {
         ExprKind::Struct(..) | ExprKind::Tup(..) => true,
-        ExprKind::Path(qpath) => {
-            if let Res::Def(DefKind::Const, ..) = cx.qpath_res(qpath, expr.hir_id) {
-                true
-            } else {
-                false
-            }
-        },
+        ExprKind::Path(qpath) => matches!(cx.qpath_res(qpath, expr.hir_id), Res::Def(DefKind::Const, ..)),
         _ => false,
     }
 }
diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs
index d6f31a99bb3..71207caecf5 100644
--- a/clippy_lints/src/types.rs
+++ b/clippy_lints/src/types.rs
@@ -775,11 +775,7 @@ impl<'tcx> LateLintPass<'tcx> for UnitArg {
                     .iter()
                     .filter(|arg| {
                         if is_unit(cx.tables().expr_ty(arg)) && !is_unit_literal(arg) {
-                            if let ExprKind::Match(.., MatchSource::TryDesugar) = &arg.kind {
-                                false
-                            } else {
-                                true
-                            }
+                            !matches!(&arg.kind, ExprKind::Match(.., MatchSource::TryDesugar))
                         } else {
                             false
                         }
@@ -899,17 +895,11 @@ fn is_questionmark_desugar_marked_call(expr: &Expr<'_>) -> bool {
 }
 
 fn is_unit(ty: Ty<'_>) -> bool {
-    match ty.kind {
-        ty::Tuple(slice) if slice.is_empty() => true,
-        _ => false,
-    }
+    matches!(ty.kind, ty::Tuple(slice) if slice.is_empty())
 }
 
 fn is_unit_literal(expr: &Expr<'_>) -> bool {
-    match expr.kind {
-        ExprKind::Tup(ref slice) if slice.is_empty() => true,
-        _ => false,
-    }
+    matches!(expr.kind, ExprKind::Tup(ref slice) if slice.is_empty())
 }
 
 declare_clippy_lint! {
@@ -1154,10 +1144,7 @@ fn int_ty_to_nbits(typ: Ty<'_>, tcx: TyCtxt<'_>) -> u64 {
 }
 
 fn is_isize_or_usize(typ: Ty<'_>) -> bool {
-    match typ.kind {
-        ty::Int(IntTy::Isize) | ty::Uint(UintTy::Usize) => true,
-        _ => false,
-    }
+    matches!(typ.kind, ty::Int(IntTy::Isize) | ty::Uint(UintTy::Usize))
 }
 
 fn span_precision_loss_lint(cx: &LateContext<'_>, expr: &Expr<'_>, cast_from: Ty<'_>, cast_to_f64: bool) {
@@ -1737,10 +1724,10 @@ impl<'tcx> Visitor<'tcx> for TypeComplexityVisitor {
 
             TyKind::TraitObject(ref param_bounds, _) => {
                 let has_lifetime_parameters = param_bounds.iter().any(|bound| {
-                    bound.bound_generic_params.iter().any(|gen| match gen.kind {
-                        GenericParamKind::Lifetime { .. } => true,
-                        _ => false,
-                    })
+                    bound
+                        .bound_generic_params
+                        .iter()
+                        .any(|gen| matches!(gen.kind, GenericParamKind::Lifetime { .. }))
                 });
                 if has_lifetime_parameters {
                     // complex trait bounds like A<'a, 'b>
diff --git a/clippy_lints/src/unnamed_address.rs b/clippy_lints/src/unnamed_address.rs
index b9aa202b328..25d136e564d 100644
--- a/clippy_lints/src/unnamed_address.rs
+++ b/clippy_lints/src/unnamed_address.rs
@@ -58,10 +58,10 @@ declare_lint_pass!(UnnamedAddress => [FN_ADDRESS_COMPARISONS, VTABLE_ADDRESS_COM
 impl LateLintPass<'_> for UnnamedAddress {
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
         fn is_comparison(binop: BinOpKind) -> bool {
-            match binop {
-                BinOpKind::Eq | BinOpKind::Lt | BinOpKind::Le | BinOpKind::Ne | BinOpKind::Ge | BinOpKind::Gt => true,
-                _ => false,
-            }
+            matches!(
+                binop,
+                BinOpKind::Eq | BinOpKind::Lt | BinOpKind::Le | BinOpKind::Ne | BinOpKind::Ge | BinOpKind::Gt
+            )
         }
 
         fn is_trait_ptr(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
@@ -72,11 +72,7 @@ impl LateLintPass<'_> for UnnamedAddress {
         }
 
         fn is_fn_def(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-            if let ty::FnDef(..) = cx.tables().expr_ty(expr).kind {
-                true
-            } else {
-                false
-            }
+            matches!(cx.tables().expr_ty(expr).kind, ty::FnDef(..))
         }
 
         if_chain! {
diff --git a/clippy_lints/src/use_self.rs b/clippy_lints/src/use_self.rs
index 39a8c020872..776c6bc57ca 100644
--- a/clippy_lints/src/use_self.rs
+++ b/clippy_lints/src/use_self.rs
@@ -169,10 +169,8 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
                 let parameters = &item_path.segments.last().expect(SEGMENTS_MSG).args;
                 let should_check = parameters.as_ref().map_or(
                     true,
-                    |params| !params.parenthesized && !params.args.iter().any(|arg| match arg {
-                        GenericArg::Lifetime(_) => true,
-                        _ => false,
-                    })
+                    |params| !params.parenthesized
+                        &&!params.args.iter().any(|arg| matches!(arg, GenericArg::Lifetime(_)))
                 );
 
                 if should_check {
diff --git a/clippy_lints/src/utils/ast_utils.rs b/clippy_lints/src/utils/ast_utils.rs
index e19a79dd8da..58c1103da9f 100755
--- a/clippy_lints/src/utils/ast_utils.rs
+++ b/clippy_lints/src/utils/ast_utils.rs
@@ -387,10 +387,7 @@ pub fn eq_use_tree_kind(l: &UseTreeKind, r: &UseTreeKind) -> bool {
 }
 
 pub fn eq_defaultness(l: Defaultness, r: Defaultness) -> bool {
-    match (l, r) {
-        (Defaultness::Final, Defaultness::Final) | (Defaultness::Default(_), Defaultness::Default(_)) => true,
-        _ => false,
-    }
+    matches!((l, r), (Defaultness::Final, Defaultness::Final) | (Defaultness::Default(_), Defaultness::Default(_)))
 }
 
 pub fn eq_vis(l: &Visibility, r: &Visibility) -> bool {
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index 3a3b79925ff..0b4cba3fc42 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -102,11 +102,7 @@ pub fn in_constant(cx: &LateContext<'_>, id: HirId) -> bool {
 #[must_use]
 pub fn in_macro(span: Span) -> bool {
     if span.from_expansion() {
-        if let ExpnKind::Desugaring(..) = span.ctxt().outer_expn_data().kind {
-            false
-        } else {
-            true
-        }
+        !matches!(span.ctxt().outer_expn_data().kind, ExpnKind::Desugaring(..))
     } else {
         false
     }
@@ -127,10 +123,7 @@ pub fn is_present_in_source<T: LintContext>(cx: &T, span: Span) -> bool {
 
 /// Checks if given pattern is a wildcard (`_`)
 pub fn is_wild<'tcx>(pat: &impl std::ops::Deref<Target = Pat<'tcx>>) -> bool {
-    match pat.kind {
-        PatKind::Wild => true,
-        _ => false,
-    }
+    matches!(pat.kind, PatKind::Wild)
 }
 
 /// Checks if type is struct, enum or union type with the given def path.
diff --git a/clippy_lints/src/utils/numeric_literal.rs b/clippy_lints/src/utils/numeric_literal.rs
index 7a79741b30b..87cb454f654 100644
--- a/clippy_lints/src/utils/numeric_literal.rs
+++ b/clippy_lints/src/utils/numeric_literal.rs
@@ -51,7 +51,7 @@ impl<'a> NumericLiteral<'a> {
     pub fn from_lit_kind(src: &'a str, lit_kind: &LitKind) -> Option<NumericLiteral<'a>> {
         if lit_kind.is_numeric() && src.chars().next().map_or(false, |c| c.is_digit(10)) {
             let (unsuffixed, suffix) = split_suffix(&src, lit_kind);
-            let float = if let LitKind::Float(..) = lit_kind { true } else { false };
+            let float = matches!(lit_kind, LitKind::Float(..));
             Some(NumericLiteral::new(unsuffixed, suffix, float))
         } else {
             None
diff --git a/src/driver.rs b/src/driver.rs
index decd3a79cce..47315fa64cd 100644
--- a/src/driver.rs
+++ b/src/driver.rs
@@ -382,13 +382,8 @@ pub fn main() {
 
         let should_describe_lints = || {
             let args: Vec<_> = env::args().collect();
-            args.windows(2).any(|args| {
-                args[1] == "help"
-                    && match args[0].as_str() {
-                        "-W" | "-A" | "-D" | "-F" => true,
-                        _ => false,
-                    }
-            })
+            args.windows(2)
+                .any(|args| args[1] == "help" && matches!(args[0].as_str(), "-W" | "-A" | "-D" | "-F"))
         };
 
         if !wrapper_mode && should_describe_lints() {
-- 
cgit 1.4.1-3-g733a5


From 076ec872ce122403f3c75f20c773c64b194a5891 Mon Sep 17 00:00:00 2001
From: Thiago Arrais <thiago.arrais@gmail.com>
Date: Wed, 10 Jun 2020 13:52:00 -0300
Subject: Lint for to_radians and to_degrees

---
 clippy_lints/src/floating_point_arithmetic.rs | 64 ++++++++++++++++++++++++++-
 tests/ui/floating_point_rad.fixed             | 13 ++++++
 tests/ui/floating_point_rad.rs                | 13 ++++++
 tests/ui/floating_point_rad.stderr            | 16 +++++++
 4 files changed, 104 insertions(+), 2 deletions(-)
 create mode 100644 tests/ui/floating_point_rad.fixed
 create mode 100644 tests/ui/floating_point_rad.rs
 create mode 100644 tests/ui/floating_point_rad.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/floating_point_arithmetic.rs b/clippy_lints/src/floating_point_arithmetic.rs
index 9f241c2c3a2..d88e47f396c 100644
--- a/clippy_lints/src/floating_point_arithmetic.rs
+++ b/clippy_lints/src/floating_point_arithmetic.rs
@@ -350,8 +350,18 @@ fn detect_hypot(cx: &LateContext<'_>, args: &[Expr<'_>]) -> Option<String> {
 
         // check if expression of the form x.powi(2) + y.powi(2)
         if_chain! {
-            if let ExprKind::MethodCall(PathSegment { ident: lmethod_name, .. }, ref _lspan, ref largs, _) = add_lhs.kind;
-            if let ExprKind::MethodCall(PathSegment { ident: rmethod_name, .. }, ref _rspan, ref rargs, _) = add_rhs.kind;
+            if let ExprKind::MethodCall(
+                PathSegment { ident: lmethod_name, .. },
+                ref _lspan,
+                ref largs,
+                _
+            ) = add_lhs.kind;
+            if let ExprKind::MethodCall(
+                PathSegment { ident: rmethod_name, .. },
+                ref _rspan,
+                ref rargs,
+                _
+            ) = add_rhs.kind;
             if lmethod_name.as_str() == "powi" && rmethod_name.as_str() == "powi";
             if let Some((lvalue, _)) = constant(cx, cx.tables(), &largs[1]);
             if let Some((rvalue, _)) = constant(cx, cx.tables(), &rargs[1]);
@@ -617,6 +627,55 @@ fn check_log_division(cx: &LateContext<'_>, expr: &Expr<'_>) {
     }
 }
 
+fn check_radians(cx: &LateContext<'_>, expr: &Expr<'_>) {
+    if_chain! {
+        if let ExprKind::Binary(
+            Spanned {
+                node: BinOpKind::Div, ..
+            },
+            div_lhs,
+            div_rhs,
+        ) = &expr.kind;
+        if let ExprKind::Binary(
+            Spanned {
+                node: BinOpKind::Mul, ..
+            },
+            mul_lhs,
+            mul_rhs,
+        ) = &div_lhs.kind;
+        if let Some((rvalue, _)) = constant(cx, cx.tables(), div_rhs);
+        if let Some((lvalue, _)) = constant(cx, cx.tables(), mul_rhs);
+        then {
+            if (F32(f32_consts::PI) == rvalue || F64(f64_consts::PI) == rvalue) &&
+               (F32(180_f32) == lvalue || F64(180_f64) == lvalue)
+            {
+                span_lint_and_sugg(
+                    cx,
+                    IMPRECISE_FLOPS,
+                    expr.span,
+                    "conversion to degrees can be done more accurately",
+                    "consider using",
+                    format!("{}.to_degrees()", Sugg::hir(cx, &mul_lhs, "..")),
+                    Applicability::MachineApplicable,
+                );
+            } else if
+                (F32(180_f32) == rvalue || F64(180_f64) == rvalue) &&
+                (F32(f32_consts::PI) == lvalue || F64(f64_consts::PI) == lvalue)
+            {
+                span_lint_and_sugg(
+                    cx,
+                    IMPRECISE_FLOPS,
+                    expr.span,
+                    "conversion to radians can be done more accurately",
+                    "consider using",
+                    format!("{}.to_radians()", Sugg::hir(cx, &mul_lhs, "..")),
+                    Applicability::MachineApplicable,
+                );
+            }
+        }
+    }
+}
+
 impl<'tcx> LateLintPass<'tcx> for FloatingPointArithmetic {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if let ExprKind::MethodCall(ref path, _, args, _) = &expr.kind {
@@ -637,6 +696,7 @@ impl<'tcx> LateLintPass<'tcx> for FloatingPointArithmetic {
             check_mul_add(cx, expr);
             check_custom_abs(cx, expr);
             check_log_division(cx, expr);
+            check_radians(cx, expr);
         }
     }
 }
diff --git a/tests/ui/floating_point_rad.fixed b/tests/ui/floating_point_rad.fixed
new file mode 100644
index 00000000000..64461417a6a
--- /dev/null
+++ b/tests/ui/floating_point_rad.fixed
@@ -0,0 +1,13 @@
+// run-rustfix
+#![warn(clippy::imprecise_flops)]
+
+fn main() {
+    let x = 3f32;
+    let _ = x.to_degrees();
+    let _ = x.to_radians();
+    // Cases where the lint shouldn't be applied
+    let _ = x * 90f32 / std::f32::consts::PI;
+    let _ = x * std::f32::consts::PI / 90f32;
+    let _ = x * 180f32 / std::f32::consts::E;
+    let _ = x * std::f32::consts::E / 180f32;
+}
diff --git a/tests/ui/floating_point_rad.rs b/tests/ui/floating_point_rad.rs
new file mode 100644
index 00000000000..9046f184b3e
--- /dev/null
+++ b/tests/ui/floating_point_rad.rs
@@ -0,0 +1,13 @@
+// run-rustfix
+#![warn(clippy::imprecise_flops)]
+
+fn main() {
+    let x = 3f32;
+    let _ = x * 180f32 / std::f32::consts::PI;
+    let _ = x * std::f32::consts::PI / 180f32;
+    // Cases where the lint shouldn't be applied
+    let _ = x * 90f32 / std::f32::consts::PI;
+    let _ = x * std::f32::consts::PI / 90f32;
+    let _ = x * 180f32 / std::f32::consts::E;
+    let _ = x * std::f32::consts::E / 180f32;
+}
diff --git a/tests/ui/floating_point_rad.stderr b/tests/ui/floating_point_rad.stderr
new file mode 100644
index 00000000000..81e81821513
--- /dev/null
+++ b/tests/ui/floating_point_rad.stderr
@@ -0,0 +1,16 @@
+error: conversion to degrees can be done more accurately
+  --> $DIR/floating_point_rad.rs:6:13
+   |
+LL |     let _ = x * 180f32 / std::f32::consts::PI;
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.to_degrees()`
+   |
+   = note: `-D clippy::imprecise-flops` implied by `-D warnings`
+
+error: conversion to radians can be done more accurately
+  --> $DIR/floating_point_rad.rs:7:13
+   |
+LL |     let _ = x * std::f32::consts::PI / 180f32;
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.to_radians()`
+
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From f5596826fa59035e6c57d8968df0d61f69c2537b Mon Sep 17 00:00:00 2001
From: Thiago Arrais <thiago.arrais@gmail.com>
Date: Mon, 15 Jun 2020 13:55:12 -0300
Subject: Better copy for lint message

Since x.log(y) is actually implemented as x.ln() / y.ln()
---
 clippy_lints/src/floating_point_arithmetic.rs | 2 +-
 tests/ui/floating_point_logbase.stderr        | 8 ++++----
 2 files changed, 5 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/floating_point_arithmetic.rs b/clippy_lints/src/floating_point_arithmetic.rs
index d88e47f396c..b1e258f4b16 100644
--- a/clippy_lints/src/floating_point_arithmetic.rs
+++ b/clippy_lints/src/floating_point_arithmetic.rs
@@ -618,7 +618,7 @@ fn check_log_division(cx: &LateContext<'_>, expr: &Expr<'_>) {
                 cx,
                 SUBOPTIMAL_FLOPS,
                 expr.span,
-                "division of logarithms can be calculated more efficiently and accurately",
+                "log base can be expressed more clearly",
                 "consider using",
                 format!("{}.log({})", Sugg::hir(cx, &largs[0], ".."), Sugg::hir(cx, &rargs[0], ".."),),
                 Applicability::MachineApplicable,
diff --git a/tests/ui/floating_point_logbase.stderr b/tests/ui/floating_point_logbase.stderr
index fa956b9139e..78354c2f62d 100644
--- a/tests/ui/floating_point_logbase.stderr
+++ b/tests/ui/floating_point_logbase.stderr
@@ -1,4 +1,4 @@
-error: division of logarithms can be calculated more efficiently and accurately
+error: log base can be expressed more clearly
   --> $DIR/floating_point_logbase.rs:7:13
    |
 LL |     let _ = x.ln() / y.ln();
@@ -6,19 +6,19 @@ LL |     let _ = x.ln() / y.ln();
    |
    = note: `-D clippy::suboptimal-flops` implied by `-D warnings`
 
-error: division of logarithms can be calculated more efficiently and accurately
+error: log base can be expressed more clearly
   --> $DIR/floating_point_logbase.rs:8:13
    |
 LL |     let _ = x.log2() / y.log2();
    |             ^^^^^^^^^^^^^^^^^^^ help: consider using: `x.log(y)`
 
-error: division of logarithms can be calculated more efficiently and accurately
+error: log base can be expressed more clearly
   --> $DIR/floating_point_logbase.rs:9:13
    |
 LL |     let _ = x.log10() / y.log10();
    |             ^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.log(y)`
 
-error: division of logarithms can be calculated more efficiently and accurately
+error: log base can be expressed more clearly
   --> $DIR/floating_point_logbase.rs:10:13
    |
 LL |     let _ = x.log(5f32) / y.log(5f32);
-- 
cgit 1.4.1-3-g733a5


From db7bc6b3bd0e58c8fbf7507713a4214299f39c36 Mon Sep 17 00:00:00 2001
From: Thiago Arrais <thiago.arrais@gmail.com>
Date: Mon, 15 Jun 2020 13:59:44 -0300
Subject: Place radian lints under suboptimal_flops

---
 clippy_lints/src/floating_point_arithmetic.rs | 4 ++--
 tests/ui/floating_point_rad.fixed             | 2 +-
 tests/ui/floating_point_rad.rs                | 2 +-
 tests/ui/floating_point_rad.stderr            | 2 +-
 4 files changed, 5 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/floating_point_arithmetic.rs b/clippy_lints/src/floating_point_arithmetic.rs
index b1e258f4b16..beb0b234408 100644
--- a/clippy_lints/src/floating_point_arithmetic.rs
+++ b/clippy_lints/src/floating_point_arithmetic.rs
@@ -651,7 +651,7 @@ fn check_radians(cx: &LateContext<'_>, expr: &Expr<'_>) {
             {
                 span_lint_and_sugg(
                     cx,
-                    IMPRECISE_FLOPS,
+                    SUBOPTIMAL_FLOPS,
                     expr.span,
                     "conversion to degrees can be done more accurately",
                     "consider using",
@@ -664,7 +664,7 @@ fn check_radians(cx: &LateContext<'_>, expr: &Expr<'_>) {
             {
                 span_lint_and_sugg(
                     cx,
-                    IMPRECISE_FLOPS,
+                    SUBOPTIMAL_FLOPS,
                     expr.span,
                     "conversion to radians can be done more accurately",
                     "consider using",
diff --git a/tests/ui/floating_point_rad.fixed b/tests/ui/floating_point_rad.fixed
index 64461417a6a..92480c5db8b 100644
--- a/tests/ui/floating_point_rad.fixed
+++ b/tests/ui/floating_point_rad.fixed
@@ -1,5 +1,5 @@
 // run-rustfix
-#![warn(clippy::imprecise_flops)]
+#![warn(clippy::suboptimal_flops)]
 
 fn main() {
     let x = 3f32;
diff --git a/tests/ui/floating_point_rad.rs b/tests/ui/floating_point_rad.rs
index 9046f184b3e..062e7c3fdc1 100644
--- a/tests/ui/floating_point_rad.rs
+++ b/tests/ui/floating_point_rad.rs
@@ -1,5 +1,5 @@
 // run-rustfix
-#![warn(clippy::imprecise_flops)]
+#![warn(clippy::suboptimal_flops)]
 
 fn main() {
     let x = 3f32;
diff --git a/tests/ui/floating_point_rad.stderr b/tests/ui/floating_point_rad.stderr
index 81e81821513..a6ffdca64ee 100644
--- a/tests/ui/floating_point_rad.stderr
+++ b/tests/ui/floating_point_rad.stderr
@@ -4,7 +4,7 @@ error: conversion to degrees can be done more accurately
 LL |     let _ = x * 180f32 / std::f32::consts::PI;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.to_degrees()`
    |
-   = note: `-D clippy::imprecise-flops` implied by `-D warnings`
+   = note: `-D clippy::suboptimal-flops` implied by `-D warnings`
 
 error: conversion to radians can be done more accurately
   --> $DIR/floating_point_rad.rs:7:13
-- 
cgit 1.4.1-3-g733a5


From 6be9491eace540d341f3b8dbf775a10e25f6431a Mon Sep 17 00:00:00 2001
From: Thiago Arrais <thiago.arrais@gmail.com>
Date: Mon, 22 Jun 2020 14:16:27 -0300
Subject: Reclassify powi(2) lint under suboptimal_flops

---
 clippy_lints/src/floating_point_arithmetic.rs | 69 +++++++++++++++++----------
 tests/ui/floating_point_powi.fixed            | 10 ++--
 tests/ui/floating_point_powi.rs               |  4 +-
 tests/ui/floating_point_powi.stderr           | 38 ++++++++-------
 4 files changed, 75 insertions(+), 46 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/floating_point_arithmetic.rs b/clippy_lints/src/floating_point_arithmetic.rs
index beb0b234408..11bd0ae23aa 100644
--- a/clippy_lints/src/floating_point_arithmetic.rs
+++ b/clippy_lints/src/floating_point_arithmetic.rs
@@ -294,37 +294,56 @@ fn check_powf(cx: &LateContext<'_>, expr: &Expr<'_>, args: &[Expr<'_>]) {
 }
 
 fn check_powi(cx: &LateContext<'_>, expr: &Expr<'_>, args: &[Expr<'_>]) {
-    // Check argument
     if let Some((value, _)) = constant(cx, cx.tables(), &args[1]) {
-        // TODO: need more specific check. this is too wide. remember also to include tests
-        if let Some(parent) = get_parent_expr(cx, expr) {
-            if let Some(grandparent) = get_parent_expr(cx, parent) {
-                if let ExprKind::MethodCall(PathSegment { ident: method_name, .. }, _, args, _) = grandparent.kind {
-                    if method_name.as_str() == "sqrt" && detect_hypot(cx, args).is_some() {
-                        return;
+        if value == Int(2) {
+            if let Some(parent) = get_parent_expr(cx, expr) {
+                if let Some(grandparent) = get_parent_expr(cx, parent) {
+                    if let ExprKind::MethodCall(PathSegment { ident: method_name, .. }, _, args, _) = grandparent.kind {
+                        if method_name.as_str() == "sqrt" && detect_hypot(cx, args).is_some() {
+                            return;
+                        }
                     }
                 }
+
+                if let ExprKind::Binary(
+                    Spanned {
+                        node: BinOpKind::Add, ..
+                    },
+                    ref lhs,
+                    ref rhs,
+                ) = parent.kind
+                {
+                    let other_addend = if lhs.hir_id == expr.hir_id { rhs } else { lhs };
+
+                    span_lint_and_sugg(
+                        cx,
+                        SUBOPTIMAL_FLOPS,
+                        parent.span,
+                        "square can be computed more efficiently",
+                        "consider using",
+                        format!(
+                            "{}.mul_add({}, {})",
+                            Sugg::hir(cx, &args[0], ".."),
+                            Sugg::hir(cx, &args[0], ".."),
+                            Sugg::hir(cx, &other_addend, ".."),
+                        ),
+                        Applicability::MachineApplicable,
+                    );
+
+                    return;
+                }
             }
-        }
 
-        let (lint, help, suggestion) = match value {
-            Int(2) => (
-                IMPRECISE_FLOPS,
-                "square can be computed more accurately",
+            span_lint_and_sugg(
+                cx,
+                SUBOPTIMAL_FLOPS,
+                expr.span,
+                "square can be computed more efficiently",
+                "consider using",
                 format!("{} * {}", Sugg::hir(cx, &args[0], ".."), Sugg::hir(cx, &args[0], "..")),
-            ),
-            _ => return,
-        };
-
-        span_lint_and_sugg(
-            cx,
-            lint,
-            expr.span,
-            help,
-            "consider using",
-            suggestion,
-            Applicability::MachineApplicable,
-        );
+                Applicability::MachineApplicable,
+            );
+        }
     }
 }
 
diff --git a/tests/ui/floating_point_powi.fixed b/tests/ui/floating_point_powi.fixed
index 98766e68aaf..56762400593 100644
--- a/tests/ui/floating_point_powi.fixed
+++ b/tests/ui/floating_point_powi.fixed
@@ -1,5 +1,5 @@
 // run-rustfix
-#![warn(clippy::imprecise_flops)]
+#![warn(clippy::suboptimal_flops)]
 
 fn main() {
     let one = 1;
@@ -8,10 +8,12 @@ fn main() {
     let _ = x * x;
 
     let y = 4f32;
-    let _ = (x * x + y).sqrt();
-    let _ = (x + y * y).sqrt();
+    let _ = x.mul_add(x, y);
+    let _ = y.mul_add(y, x);
+    let _ = x.mul_add(x, y).sqrt();
+    let _ = y.mul_add(y, x).sqrt();
     // Cases where the lint shouldn't be applied
     let _ = x.powi(3);
     let _ = x.powi(one + 1);
-    let _ = x.hypot(y);
+    let _ = (x.powi(2) + y.powi(2)).sqrt();
 }
diff --git a/tests/ui/floating_point_powi.rs b/tests/ui/floating_point_powi.rs
index 3c4b636a3d8..1f800e4628d 100644
--- a/tests/ui/floating_point_powi.rs
+++ b/tests/ui/floating_point_powi.rs
@@ -1,5 +1,5 @@
 // run-rustfix
-#![warn(clippy::imprecise_flops)]
+#![warn(clippy::suboptimal_flops)]
 
 fn main() {
     let one = 1;
@@ -8,6 +8,8 @@ fn main() {
     let _ = x.powi(1 + 1);
 
     let y = 4f32;
+    let _ = x.powi(2) + y;
+    let _ = x + y.powi(2);
     let _ = (x.powi(2) + y).sqrt();
     let _ = (x + y.powi(2)).sqrt();
     // Cases where the lint shouldn't be applied
diff --git a/tests/ui/floating_point_powi.stderr b/tests/ui/floating_point_powi.stderr
index f370e24bf05..d5a5f1bcca1 100644
--- a/tests/ui/floating_point_powi.stderr
+++ b/tests/ui/floating_point_powi.stderr
@@ -1,34 +1,40 @@
-error: square can be computed more accurately
+error: square can be computed more efficiently
   --> $DIR/floating_point_powi.rs:7:13
    |
 LL |     let _ = x.powi(2);
    |             ^^^^^^^^^ help: consider using: `x * x`
    |
-   = note: `-D clippy::imprecise-flops` implied by `-D warnings`
+   = note: `-D clippy::suboptimal-flops` implied by `-D warnings`
 
-error: square can be computed more accurately
+error: square can be computed more efficiently
   --> $DIR/floating_point_powi.rs:8:13
    |
 LL |     let _ = x.powi(1 + 1);
    |             ^^^^^^^^^^^^^ help: consider using: `x * x`
 
-error: square can be computed more accurately
-  --> $DIR/floating_point_powi.rs:11:14
+error: square can be computed more efficiently
+  --> $DIR/floating_point_powi.rs:11:13
    |
-LL |     let _ = (x.powi(2) + y).sqrt();
-   |              ^^^^^^^^^ help: consider using: `x * x`
+LL |     let _ = x.powi(2) + y;
+   |             ^^^^^^^^^^^^^ help: consider using: `x.mul_add(x, y)`
 
-error: square can be computed more accurately
-  --> $DIR/floating_point_powi.rs:12:18
+error: square can be computed more efficiently
+  --> $DIR/floating_point_powi.rs:12:13
    |
-LL |     let _ = (x + y.powi(2)).sqrt();
-   |                  ^^^^^^^^^ help: consider using: `y * y`
+LL |     let _ = x + y.powi(2);
+   |             ^^^^^^^^^^^^^ help: consider using: `y.mul_add(y, x)`
+
+error: square can be computed more efficiently
+  --> $DIR/floating_point_powi.rs:13:13
+   |
+LL |     let _ = (x.powi(2) + y).sqrt();
+   |             ^^^^^^^^^^^^^^^ help: consider using: `x.mul_add(x, y)`
 
-error: hypotenuse can be computed more accurately
-  --> $DIR/floating_point_powi.rs:16:13
+error: square can be computed more efficiently
+  --> $DIR/floating_point_powi.rs:14:13
    |
-LL |     let _ = (x.powi(2) + y.powi(2)).sqrt();
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.hypot(y)`
+LL |     let _ = (x + y.powi(2)).sqrt();
+   |             ^^^^^^^^^^^^^^^ help: consider using: `y.mul_add(y, x)`
 
-error: aborting due to 5 previous errors
+error: aborting due to 6 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 3065201eb3a0c4976de7ef5b5b924afde1b18325 Mon Sep 17 00:00:00 2001
From: Thiago Arrais <thiago.arrais@gmail.com>
Date: Mon, 6 Jul 2020 13:14:52 -0300
Subject: Includes TODO for constants equivalent to π/180
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 clippy_lints/src/floating_point_arithmetic.rs | 1 +
 1 file changed, 1 insertion(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/floating_point_arithmetic.rs b/clippy_lints/src/floating_point_arithmetic.rs
index 11bd0ae23aa..3087d6a940a 100644
--- a/clippy_lints/src/floating_point_arithmetic.rs
+++ b/clippy_lints/src/floating_point_arithmetic.rs
@@ -665,6 +665,7 @@ fn check_radians(cx: &LateContext<'_>, expr: &Expr<'_>) {
         if let Some((rvalue, _)) = constant(cx, cx.tables(), div_rhs);
         if let Some((lvalue, _)) = constant(cx, cx.tables(), mul_rhs);
         then {
+            // TODO: also check for constant values near PI/180 or 180/PI
             if (F32(f32_consts::PI) == rvalue || F64(f64_consts::PI) == rvalue) &&
                (F32(180_f32) == lvalue || F64(180_f64) == lvalue)
             {
-- 
cgit 1.4.1-3-g733a5


From 5307cb5614e7498f069bb634ab293e176e63c67f Mon Sep 17 00:00:00 2001
From: Takayuki Nakata <f.seasons017@gmail.com>
Date: Sat, 4 Jul 2020 22:50:03 +0900
Subject: Add a lint for `.repeat(1)`

fix #3028.
---
 CHANGELOG.md                    |   1 +
 clippy_lints/src/lib.rs         |   5 ++
 clippy_lints/src/repeat_once.rs | 126 ++++++++++++++++++++++++++++++++++++++++
 src/lintlist/mod.rs             |   7 +++
 tests/ui/repeat_once.fixed      |  16 +++++
 tests/ui/repeat_once.rs         |  16 +++++
 tests/ui/repeat_once.stderr     |  40 +++++++++++++
 7 files changed, 211 insertions(+)
 create mode 100644 clippy_lints/src/repeat_once.rs
 create mode 100644 tests/ui/repeat_once.fixed
 create mode 100644 tests/ui/repeat_once.rs
 create mode 100644 tests/ui/repeat_once.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 1a081bb85fe..c5bbaac0df6 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1616,6 +1616,7 @@ Released 2018-09-13
 [`redundant_static_lifetimes`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_static_lifetimes
 [`ref_in_deref`]: https://rust-lang.github.io/rust-clippy/master/index.html#ref_in_deref
 [`regex_macro`]: https://rust-lang.github.io/rust-clippy/master/index.html#regex_macro
+[`repeat_once`]: https://rust-lang.github.io/rust-clippy/master/index.html#repeat_once
 [`replace_consts`]: https://rust-lang.github.io/rust-clippy/master/index.html#replace_consts
 [`rest_pat_in_fully_bound_structs`]: https://rust-lang.github.io/rust-clippy/master/index.html#rest_pat_in_fully_bound_structs
 [`result_map_or_into_option`]: https://rust-lang.github.io/rust-clippy/master/index.html#result_map_or_into_option
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index fe34e4390d6..0f362dbf86b 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -282,6 +282,7 @@ mod redundant_pub_crate;
 mod redundant_static_lifetimes;
 mod reference;
 mod regex;
+mod repeat_once;
 mod returns;
 mod serde_api;
 mod shadow;
@@ -764,6 +765,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &reference::REF_IN_DEREF,
         &regex::INVALID_REGEX,
         &regex::TRIVIAL_REGEX,
+        &repeat_once::REPEAT_ONCE,
         &returns::NEEDLESS_RETURN,
         &returns::UNUSED_UNIT,
         &serde_api::SERDE_API_MISUSE,
@@ -1071,6 +1073,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box macro_use::MacroUseImports::default());
     store.register_late_pass(|| box map_identity::MapIdentity);
     store.register_late_pass(|| box pattern_type_mismatch::PatternTypeMismatch);
+    store.register_late_pass(|| box repeat_once::RepeatOnce);
 
     store.register_group(true, "clippy::restriction", Some("clippy_restriction"), vec![
         LintId::of(&arithmetic::FLOAT_ARITHMETIC),
@@ -1393,6 +1396,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&reference::REF_IN_DEREF),
         LintId::of(&regex::INVALID_REGEX),
         LintId::of(&regex::TRIVIAL_REGEX),
+        LintId::of(&repeat_once::REPEAT_ONCE),
         LintId::of(&returns::NEEDLESS_RETURN),
         LintId::of(&returns::UNUSED_UNIT),
         LintId::of(&serde_api::SERDE_API_MISUSE),
@@ -1602,6 +1606,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&ranges::RANGE_ZIP_WITH_LEN),
         LintId::of(&reference::DEREF_ADDROF),
         LintId::of(&reference::REF_IN_DEREF),
+        LintId::of(&repeat_once::REPEAT_ONCE),
         LintId::of(&swap::MANUAL_SWAP),
         LintId::of(&temporary_assignment::TEMPORARY_ASSIGNMENT),
         LintId::of(&transmute::CROSSPOINTER_TRANSMUTE),
diff --git a/clippy_lints/src/repeat_once.rs b/clippy_lints/src/repeat_once.rs
new file mode 100644
index 00000000000..af3c948ec82
--- /dev/null
+++ b/clippy_lints/src/repeat_once.rs
@@ -0,0 +1,126 @@
+use crate::consts::{miri_to_const, Constant};
+use crate::utils::{in_macro, is_type_diagnostic_item, snippet, span_lint_and_sugg, walk_ptrs_ty};
+use if_chain::if_chain;
+use rustc_ast::ast::LitKind;
+use rustc_errors::Applicability;
+use rustc_hir::def::{DefKind, Res};
+use rustc_hir::{Expr, ExprKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::{self, Ty};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for usage of `.repeat(1)` and suggest the following method for each types.
+    /// - `.to_string()` for `str`
+    /// - `.clone()` for `String`
+    /// - `.to_vec()` for `slice`
+    ///
+    /// **Why is this bad?** For example, `String.repeat(1)` is equivalent to `.clone()`. If cloning the string is the intention behind thi, `clone()` should be used.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// fn main() {
+    ///     let x = String::from("hello world").repeat(1);
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// fn main() {
+    ///     let x = String::from("hello world").clone();
+    /// }
+    /// ```
+    pub REPEAT_ONCE,
+    complexity,
+    "using `.repeat(1)` instead of `String.clone()`, `str.to_string()` or `slice.to_vec()` "
+}
+
+declare_lint_pass!(RepeatOnce => [REPEAT_ONCE]);
+
+impl<'tcx> LateLintPass<'tcx> for RepeatOnce {
+    fn check_expr(&mut self, cx: &LateContext<'_>, expr: &'tcx Expr<'_>) {
+        if_chain! {
+            if let ExprKind::MethodCall(ref path, _, ref args, _) = expr.kind;
+            if path.ident.name == sym!(repeat);
+            if is_once(cx, &args[1]) && !in_macro(args[0].span);
+            then {
+                let ty = walk_ptrs_ty(cx.tables().expr_ty(&args[0]));
+                if is_str(ty){
+                    span_lint_and_sugg(
+                        cx,
+                        REPEAT_ONCE,
+                        expr.span,
+                        "calling `repeat(1)` on str",
+                        "consider using `.to_string()` instead",
+                        format!("{}.to_string()", snippet(cx, args[0].span, r#""...""#)),
+                        Applicability::MachineApplicable,
+                    );
+                } else if is_slice(ty) {
+                    span_lint_and_sugg(
+                        cx,
+                        REPEAT_ONCE,
+                        expr.span,
+                        "calling `repeat(1)` on slice",
+                        "consider using `.to_vec()` instead",
+                        format!("{}.to_vec()", snippet(cx, args[0].span, r#""...""#)),
+                        Applicability::MachineApplicable,
+                    );
+                } else if is_type_diagnostic_item(cx, ty, sym!(string_type)) {
+                    span_lint_and_sugg(
+                        cx,
+                        REPEAT_ONCE,
+                        expr.span,
+                        "calling `repeat(1)` on a string literal",
+                        "consider using `.clone()` instead",
+                        format!("{}.clone()", snippet(cx, args[0].span, r#""...""#)),
+                        Applicability::MachineApplicable,
+                    );
+                }
+            }
+        }
+    }
+}
+
+fn is_once<'tcx>(cx: &LateContext<'_>, expr: &'tcx Expr<'_>) -> bool {
+    match expr.kind {
+        ExprKind::Lit(ref lit) => {
+            if let LitKind::Int(ref lit_content, _) = lit.node {
+                *lit_content == 1
+            } else {
+                false
+            }
+        },
+        ExprKind::Path(rustc_hir::QPath::Resolved(None, path)) => {
+            if let Res::Def(DefKind::Const, def_id) = path.res {
+                let ty = cx.tcx.type_of(def_id);
+                let con = cx
+                    .tcx
+                    .const_eval_poly(def_id)
+                    .ok()
+                    .map(|val| rustc_middle::ty::Const::from_value(cx.tcx, val, ty))
+                    .unwrap();
+                let con = miri_to_const(con);
+                con == Some(Constant::Int(1))
+            } else {
+                false
+            }
+        },
+        _ => false,
+    }
+}
+
+fn is_str(ty: Ty<'_>) -> bool {
+    match ty.kind {
+        ty::Str => true,
+        _ => false,
+    }
+}
+
+fn is_slice(ty: Ty<'_>) -> bool {
+    match ty.kind {
+        ty::Slice(..) | ty::Array(..) => true,
+        _ => false,
+    }
+}
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index e681f47f949..078924d3f9b 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -1879,6 +1879,13 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
         deprecation: None,
         module: "reference",
     },
+    Lint {
+        name: "repeat_once",
+        group: "complexity",
+        desc: "using `.repeat(1)` instead of `String.clone()`, `str.to_string()` or `slice.to_vec()` ",
+        deprecation: None,
+        module: "repeat_once",
+    },
     Lint {
         name: "rest_pat_in_fully_bound_structs",
         group: "restriction",
diff --git a/tests/ui/repeat_once.fixed b/tests/ui/repeat_once.fixed
new file mode 100644
index 00000000000..a637c22fbcd
--- /dev/null
+++ b/tests/ui/repeat_once.fixed
@@ -0,0 +1,16 @@
+// run-rustfix
+#![warn(clippy::repeat_once)]
+#[allow(unused, clippy::many_single_char_names, clippy::redundant_clone)]
+fn main() {
+    const N: usize = 1;
+    let s = "str";
+    let string = "String".to_string();
+    let slice = [1; 5];
+
+    let a = [1; 5].to_vec();
+    let b = slice.to_vec();
+    let c = "hello".to_string();
+    let d = "hi".to_string();
+    let e = s.to_string();
+    let f = string.clone();
+}
diff --git a/tests/ui/repeat_once.rs b/tests/ui/repeat_once.rs
new file mode 100644
index 00000000000..d99ca1b5b55
--- /dev/null
+++ b/tests/ui/repeat_once.rs
@@ -0,0 +1,16 @@
+// run-rustfix
+#![warn(clippy::repeat_once)]
+#[allow(unused, clippy::many_single_char_names, clippy::redundant_clone)]
+fn main() {
+    const N: usize = 1;
+    let s = "str";
+    let string = "String".to_string();
+    let slice = [1; 5];
+
+    let a = [1; 5].repeat(1);
+    let b = slice.repeat(1);
+    let c = "hello".repeat(N);
+    let d = "hi".repeat(1);
+    let e = s.repeat(1);
+    let f = string.repeat(1);
+}
diff --git a/tests/ui/repeat_once.stderr b/tests/ui/repeat_once.stderr
new file mode 100644
index 00000000000..915eea3bfc6
--- /dev/null
+++ b/tests/ui/repeat_once.stderr
@@ -0,0 +1,40 @@
+error: calling `repeat(1)` on slice
+  --> $DIR/repeat_once.rs:10:13
+   |
+LL |     let a = [1; 5].repeat(1);
+   |             ^^^^^^^^^^^^^^^^ help: consider using `.to_vec()` instead: `[1; 5].to_vec()`
+   |
+   = note: `-D clippy::repeat-once` implied by `-D warnings`
+
+error: calling `repeat(1)` on slice
+  --> $DIR/repeat_once.rs:11:13
+   |
+LL |     let b = slice.repeat(1);
+   |             ^^^^^^^^^^^^^^^ help: consider using `.to_vec()` instead: `slice.to_vec()`
+
+error: calling `repeat(1)` on str
+  --> $DIR/repeat_once.rs:12:13
+   |
+LL |     let c = "hello".repeat(N);
+   |             ^^^^^^^^^^^^^^^^^ help: consider using `.to_string()` instead: `"hello".to_string()`
+
+error: calling `repeat(1)` on str
+  --> $DIR/repeat_once.rs:13:13
+   |
+LL |     let d = "hi".repeat(1);
+   |             ^^^^^^^^^^^^^^ help: consider using `.to_string()` instead: `"hi".to_string()`
+
+error: calling `repeat(1)` on str
+  --> $DIR/repeat_once.rs:14:13
+   |
+LL |     let e = s.repeat(1);
+   |             ^^^^^^^^^^^ help: consider using `.to_string()` instead: `s.to_string()`
+
+error: calling `repeat(1)` on a string literal
+  --> $DIR/repeat_once.rs:15:13
+   |
+LL |     let f = string.repeat(1);
+   |             ^^^^^^^^^^^^^^^^ help: consider using `.clone()` instead: `string.clone()`
+
+error: aborting due to 6 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 37d75da266443dd4253ceedebd692ba77dd72e03 Mon Sep 17 00:00:00 2001
From: robojumper <robojumper@gmail.com>
Date: Wed, 8 Jul 2020 18:04:51 +0200
Subject: make match_like_matches_macro only apply to matches with a wildcard

---
 clippy_lints/src/assign_ops.rs                |  1 -
 clippy_lints/src/matches.rs                   | 41 +++++++++++++--------------
 tests/ui/match_expr_like_matches_macro.fixed  | 14 +++++----
 tests/ui/match_expr_like_matches_macro.rs     | 17 +++++++----
 tests/ui/match_expr_like_matches_macro.stderr | 28 ++++++++++++------
 tests/ui/question_mark.fixed                  |  5 +++-
 tests/ui/question_mark.rs                     |  5 +++-
 tests/ui/question_mark.stderr                 | 20 ++++++-------
 8 files changed, 77 insertions(+), 54 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/assign_ops.rs b/clippy_lints/src/assign_ops.rs
index 3d48bf739eb..bc6e868823f 100644
--- a/clippy_lints/src/assign_ops.rs
+++ b/clippy_lints/src/assign_ops.rs
@@ -237,7 +237,6 @@ fn is_commutative(op: hir::BinOpKind) -> bool {
     use rustc_hir::BinOpKind::{
         Add, And, BitAnd, BitOr, BitXor, Div, Eq, Ge, Gt, Le, Lt, Mul, Ne, Or, Rem, Shl, Shr, Sub,
     };
-    #[allow(clippy::match_like_matches_macro)]
     match op {
         Add | Mul | And | Or | BitXor | BitAnd | BitOr | Eq | Ne => true,
         Sub | Div | Rem | Shl | Shr | Lt | Le | Ge | Gt => false,
diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index 34aa2981535..aeabb99a30d 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -446,11 +446,12 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for `match` expressions producing a `bool` that could be written using `matches!`
+    /// **What it does:** Checks for `match`  or `if let` expressions producing a
+    /// `bool` that could be written using `matches!`
     ///
     /// **Why is this bad?** Readability and needless complexity.
     ///
-    /// **Known problems:** This can turn an intentionally exhaustive match into a non-exhaustive one.
+    /// **Known problems:** None
     ///
     /// **Example:**
     /// ```rust
@@ -462,8 +463,14 @@ declare_clippy_lint! {
     ///     _ => false,
     /// };
     ///
+    /// let a = if let Some(0) = x {
+    ///     true
+    /// } else {
+    ///     false
+    /// };
+    ///
     /// // Good
-    /// let a = matches!(x, Some(5));
+    /// let a = matches!(x, Some(0));
     /// ```
     pub MATCH_LIKE_MATCHES_MACRO,
     style,
@@ -499,9 +506,8 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
             return;
         }
 
-        if !redundant_pattern_match::check(cx, expr) {
-            check_match_like_matches(cx, expr);
-        }
+        redundant_pattern_match::check(cx, expr);
+        check_match_like_matches(cx, expr);
 
         if let ExprKind::Match(ref ex, ref arms, MatchSource::Normal) = expr.kind {
             check_single_match(cx, ex, arms, expr);
@@ -1068,6 +1074,7 @@ fn find_matches_sugg(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>], expr
     if_chain! {
         if arms.len() == 2;
         if cx.tables().expr_ty(expr).is_bool();
+        if is_wild(&arms[1].pat);
         if let Some(first) = find_bool_lit(&arms[0].body.kind, desugared);
         if let Some(second) = find_bool_lit(&arms[1].body.kind, desugared);
         if first != second;
@@ -1437,16 +1444,14 @@ mod redundant_pattern_match {
     use rustc_mir::const_eval::is_const_fn;
     use rustc_span::source_map::Symbol;
 
-    pub fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> bool {
+    pub fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if let ExprKind::Match(op, arms, ref match_source) = &expr.kind {
             match match_source {
                 MatchSource::Normal => find_sugg_for_match(cx, expr, op, arms),
                 MatchSource::IfLetDesugar { .. } => find_sugg_for_if_let(cx, expr, op, arms, "if"),
                 MatchSource::WhileLetDesugar => find_sugg_for_if_let(cx, expr, op, arms, "while"),
-                _ => false,
+                _ => {},
             }
-        } else {
-            false
         }
     }
 
@@ -1456,7 +1461,7 @@ mod redundant_pattern_match {
         op: &Expr<'_>,
         arms: &[Arm<'_>],
         keyword: &'static str,
-    ) -> bool {
+    ) {
         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()");
@@ -1487,7 +1492,7 @@ mod redundant_pattern_match {
         };
         let good_method = match good_method {
             Some(method) => method,
-            None => return false,
+            None => return,
         };
 
         // check that `while_let_on_iterator` lint does not trigger
@@ -1497,7 +1502,7 @@ mod redundant_pattern_match {
             if method_path.ident.name == sym!(next);
             if match_trait_method(cx, op, &paths::ITERATOR);
             then {
-                return false;
+                return;
             }
         }
 
@@ -1526,15 +1531,9 @@ mod redundant_pattern_match {
                 );
             },
         );
-        true
     }
 
-    fn find_sugg_for_match<'tcx>(
-        cx: &LateContext<'tcx>,
-        expr: &'tcx Expr<'_>,
-        op: &Expr<'_>,
-        arms: &[Arm<'_>],
-    ) -> bool {
+    fn find_sugg_for_match<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, op: &Expr<'_>, arms: &[Arm<'_>]) {
         if arms.len() == 2 {
             let node_pair = (&arms[0].pat.kind, &arms[1].pat.kind);
 
@@ -1599,10 +1598,8 @@ mod redundant_pattern_match {
                         );
                     },
                 );
-                return true;
             }
         }
-        false
     }
 
     #[allow(clippy::too_many_arguments)]
diff --git a/tests/ui/match_expr_like_matches_macro.fixed b/tests/ui/match_expr_like_matches_macro.fixed
index 2d1ac8836d6..f3e19092480 100644
--- a/tests/ui/match_expr_like_matches_macro.fixed
+++ b/tests/ui/match_expr_like_matches_macro.fixed
@@ -1,6 +1,7 @@
 // run-rustfix
 
 #![warn(clippy::match_like_matches_macro)]
+#![allow(unreachable_patterns)]
 
 fn main() {
     let x = Some(5);
@@ -8,25 +9,28 @@ fn main() {
     // Lint
     let _y = matches!(x, Some(0));
 
+    // Lint
+    let _w = matches!(x, Some(_));
+
     // Turn into is_none
     let _z = x.is_none();
 
     // Lint
-    let _z = !matches!(x, Some(r) if r == 0);
+    let _zz = !matches!(x, Some(r) if r == 0);
 
     // Lint
-    let _zz = matches!(x, Some(5));
+    let _zzz = matches!(x, Some(5));
 
     // No lint
     let _a = match x {
         Some(_) => false,
-        None => false,
+        _ => false,
     };
 
     // No lint
-    let _a = match x {
+    let _ab = match x {
         Some(0) => false,
-        Some(_) => true,
+        _ => true,
         None => false,
     };
 }
diff --git a/tests/ui/match_expr_like_matches_macro.rs b/tests/ui/match_expr_like_matches_macro.rs
index 376abf9244e..fbae7c18b92 100644
--- a/tests/ui/match_expr_like_matches_macro.rs
+++ b/tests/ui/match_expr_like_matches_macro.rs
@@ -1,6 +1,7 @@
 // run-rustfix
 
 #![warn(clippy::match_like_matches_macro)]
+#![allow(unreachable_patterns)]
 
 fn main() {
     let x = Some(5);
@@ -11,6 +12,12 @@ fn main() {
         _ => false,
     };
 
+    // Lint
+    let _w = match x {
+        Some(_) => true,
+        _ => false,
+    };
+
     // Turn into is_none
     let _z = match x {
         Some(_) => false,
@@ -18,24 +25,24 @@ fn main() {
     };
 
     // Lint
-    let _z = match x {
+    let _zz = match x {
         Some(r) if r == 0 => false,
         _ => true,
     };
 
     // Lint
-    let _zz = if let Some(5) = x { true } else { false };
+    let _zzz = if let Some(5) = x { true } else { false };
 
     // No lint
     let _a = match x {
         Some(_) => false,
-        None => false,
+        _ => false,
     };
 
     // No lint
-    let _a = match x {
+    let _ab = match x {
         Some(0) => false,
-        Some(_) => true,
+        _ => true,
         None => false,
     };
 }
diff --git a/tests/ui/match_expr_like_matches_macro.stderr b/tests/ui/match_expr_like_matches_macro.stderr
index 0b32af039a8..4668f8565a6 100644
--- a/tests/ui/match_expr_like_matches_macro.stderr
+++ b/tests/ui/match_expr_like_matches_macro.stderr
@@ -1,5 +1,5 @@
 error: match expression looks like `matches!` macro
-  --> $DIR/match_expr_like_matches_macro.rs:9:14
+  --> $DIR/match_expr_like_matches_macro.rs:10:14
    |
 LL |       let _y = match x {
    |  ______________^
@@ -10,8 +10,18 @@ LL | |     };
    |
    = note: `-D clippy::match-like-matches-macro` implied by `-D warnings`
 
+error: match expression looks like `matches!` macro
+  --> $DIR/match_expr_like_matches_macro.rs:16:14
+   |
+LL |       let _w = match x {
+   |  ______________^
+LL | |         Some(_) => true,
+LL | |         _ => false,
+LL | |     };
+   | |_____^ help: try this: `matches!(x, Some(_))`
+
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/match_expr_like_matches_macro.rs:15:14
+  --> $DIR/match_expr_like_matches_macro.rs:22:14
    |
 LL |       let _z = match x {
    |  ______________^
@@ -23,20 +33,20 @@ LL | |     };
    = note: `-D clippy::redundant-pattern-matching` implied by `-D warnings`
 
 error: match expression looks like `matches!` macro
-  --> $DIR/match_expr_like_matches_macro.rs:21:14
+  --> $DIR/match_expr_like_matches_macro.rs:28:15
    |
-LL |       let _z = match x {
-   |  ______________^
+LL |       let _zz = match x {
+   |  _______________^
 LL | |         Some(r) if r == 0 => false,
 LL | |         _ => true,
 LL | |     };
    | |_____^ help: try this: `!matches!(x, Some(r) if r == 0)`
 
 error: if let .. else expression looks like `matches!` macro
-  --> $DIR/match_expr_like_matches_macro.rs:27:15
+  --> $DIR/match_expr_like_matches_macro.rs:34:16
    |
-LL |     let _zz = if let Some(5) = x { true } else { false };
-   |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `matches!(x, Some(5))`
+LL |     let _zzz = if let Some(5) = x { true } else { false };
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `matches!(x, Some(5))`
 
-error: aborting due to 4 previous errors
+error: aborting due to 5 previous errors
 
diff --git a/tests/ui/question_mark.fixed b/tests/ui/question_mark.fixed
index bd13cf1bdfa..11dff94a288 100644
--- a/tests/ui/question_mark.fixed
+++ b/tests/ui/question_mark.fixed
@@ -23,7 +23,10 @@ pub enum SeemsOption<T> {
 
 impl<T> SeemsOption<T> {
     pub fn is_none(&self) -> bool {
-        matches!(*self, SeemsOption::None)
+        match *self {
+            SeemsOption::None => true,
+            SeemsOption::Some(_) => false,
+        }
     }
 }
 
diff --git a/tests/ui/question_mark.rs b/tests/ui/question_mark.rs
index 94479e68555..1d0ee82b4f7 100644
--- a/tests/ui/question_mark.rs
+++ b/tests/ui/question_mark.rs
@@ -25,7 +25,10 @@ pub enum SeemsOption<T> {
 
 impl<T> SeemsOption<T> {
     pub fn is_none(&self) -> bool {
-        matches!(*self, SeemsOption::None)
+        match *self {
+            SeemsOption::None => true,
+            SeemsOption::Some(_) => false,
+        }
     }
 }
 
diff --git a/tests/ui/question_mark.stderr b/tests/ui/question_mark.stderr
index be323035d6c..502615fb175 100644
--- a/tests/ui/question_mark.stderr
+++ b/tests/ui/question_mark.stderr
@@ -9,7 +9,7 @@ LL | |     }
    = note: `-D clippy::question-mark` implied by `-D warnings`
 
 error: this block may be rewritten with the `?` operator
-  --> $DIR/question_mark.rs:47:9
+  --> $DIR/question_mark.rs:50:9
    |
 LL | /         if (self.opt).is_none() {
 LL | |             return None;
@@ -17,7 +17,7 @@ LL | |         }
    | |_________^ help: replace it with: `(self.opt)?;`
 
 error: this block may be rewritten with the `?` operator
-  --> $DIR/question_mark.rs:51:9
+  --> $DIR/question_mark.rs:54:9
    |
 LL | /         if self.opt.is_none() {
 LL | |             return None
@@ -25,7 +25,7 @@ LL | |         }
    | |_________^ help: replace it with: `self.opt?;`
 
 error: this block may be rewritten with the `?` operator
-  --> $DIR/question_mark.rs:55:17
+  --> $DIR/question_mark.rs:58:17
    |
 LL |           let _ = if self.opt.is_none() {
    |  _________________^
@@ -36,7 +36,7 @@ LL | |         };
    | |_________^ help: replace it with: `Some(self.opt?)`
 
 error: this if-let-else may be rewritten with the `?` operator
-  --> $DIR/question_mark.rs:61:17
+  --> $DIR/question_mark.rs:64:17
    |
 LL |           let _ = if let Some(x) = self.opt {
    |  _________________^
@@ -47,7 +47,7 @@ LL | |         };
    | |_________^ help: replace it with: `self.opt?`
 
 error: this block may be rewritten with the `?` operator
-  --> $DIR/question_mark.rs:78:9
+  --> $DIR/question_mark.rs:81:9
    |
 LL | /         if self.opt.is_none() {
 LL | |             return None;
@@ -55,7 +55,7 @@ LL | |         }
    | |_________^ help: replace it with: `self.opt.as_ref()?;`
 
 error: this block may be rewritten with the `?` operator
-  --> $DIR/question_mark.rs:86:9
+  --> $DIR/question_mark.rs:89:9
    |
 LL | /         if self.opt.is_none() {
 LL | |             return None;
@@ -63,7 +63,7 @@ LL | |         }
    | |_________^ help: replace it with: `self.opt.as_ref()?;`
 
 error: this block may be rewritten with the `?` operator
-  --> $DIR/question_mark.rs:94:9
+  --> $DIR/question_mark.rs:97:9
    |
 LL | /         if self.opt.is_none() {
 LL | |             return None;
@@ -71,7 +71,7 @@ LL | |         }
    | |_________^ help: replace it with: `self.opt.as_ref()?;`
 
 error: this if-let-else may be rewritten with the `?` operator
-  --> $DIR/question_mark.rs:101:26
+  --> $DIR/question_mark.rs:104:26
    |
 LL |           let v: &Vec<_> = if let Some(ref v) = self.opt {
    |  __________________________^
@@ -82,7 +82,7 @@ LL | |         };
    | |_________^ help: replace it with: `self.opt.as_ref()?`
 
 error: this if-let-else may be rewritten with the `?` operator
-  --> $DIR/question_mark.rs:111:17
+  --> $DIR/question_mark.rs:114:17
    |
 LL |           let v = if let Some(v) = self.opt {
    |  _________________^
@@ -93,7 +93,7 @@ LL | |         };
    | |_________^ help: replace it with: `self.opt?`
 
 error: this block may be rewritten with the `?` operator
-  --> $DIR/question_mark.rs:126:5
+  --> $DIR/question_mark.rs:129:5
    |
 LL | /     if f().is_none() {
 LL | |         return None;
-- 
cgit 1.4.1-3-g733a5


From db1c946aaa02e1192d271dbcfe4598d726806108 Mon Sep 17 00:00:00 2001
From: Eduardo Broto <ebroto@tutanota.com>
Date: Tue, 30 Jun 2020 21:48:34 +0200
Subject: unnecessary_sort_by: avoid linting if key borrows

---
 clippy_lints/src/let_and_return.rs      | 21 ++-------------
 clippy_lints/src/unnecessary_sort_by.rs | 48 ++++++++++++++++++++-------------
 clippy_lints/src/utils/mod.rs           | 15 +++++++++++
 tests/ui/unnecessary_sort_by.fixed      | 46 ++++++++++++++++++++++++++++---
 tests/ui/unnecessary_sort_by.rs         | 46 ++++++++++++++++++++++++++++---
 5 files changed, 131 insertions(+), 45 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/let_and_return.rs b/clippy_lints/src/let_and_return.rs
index ddc41f89f8d..fa560ffb980 100644
--- a/clippy_lints/src/let_and_return.rs
+++ b/clippy_lints/src/let_and_return.rs
@@ -1,6 +1,5 @@
 use if_chain::if_chain;
 use rustc_errors::Applicability;
-use rustc_hir::def_id::DefId;
 use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
 use rustc_hir::{Block, Expr, ExprKind, PatKind, StmtKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
@@ -9,7 +8,7 @@ use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::subst::GenericArgKind;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
-use crate::utils::{in_macro, match_qpath, snippet_opt, span_lint_and_then};
+use crate::utils::{fn_def_id, in_macro, match_qpath, snippet_opt, span_lint_and_then};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for `let`-bindings, which are subsequently
@@ -97,22 +96,6 @@ struct BorrowVisitor<'a, 'tcx> {
     borrows: bool,
 }
 
-impl BorrowVisitor<'_, '_> {
-    fn fn_def_id(&self, expr: &Expr<'_>) -> Option<DefId> {
-        match &expr.kind {
-            ExprKind::MethodCall(..) => self.cx.tables().type_dependent_def_id(expr.hir_id),
-            ExprKind::Call(
-                Expr {
-                    kind: ExprKind::Path(qpath),
-                    ..
-                },
-                ..,
-            ) => self.cx.qpath_res(qpath, expr.hir_id).opt_def_id(),
-            _ => None,
-        }
-    }
-}
-
 impl<'tcx> Visitor<'tcx> for BorrowVisitor<'_, 'tcx> {
     type Map = Map<'tcx>;
 
@@ -121,7 +104,7 @@ impl<'tcx> Visitor<'tcx> for BorrowVisitor<'_, 'tcx> {
             return;
         }
 
-        if let Some(def_id) = self.fn_def_id(expr) {
+        if let Some(def_id) = fn_def_id(self.cx, expr) {
             self.borrows = self
                 .cx
                 .tcx
diff --git a/clippy_lints/src/unnecessary_sort_by.rs b/clippy_lints/src/unnecessary_sort_by.rs
index d940776817c..91c1789a2ff 100644
--- a/clippy_lints/src/unnecessary_sort_by.rs
+++ b/clippy_lints/src/unnecessary_sort_by.rs
@@ -5,24 +5,23 @@ use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, Mutability, Param, Pat, PatKind, Path, PathSegment, QPath};
 use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::{self, subst::GenericArgKind};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::symbol::Ident;
 
 declare_clippy_lint! {
     /// **What it does:**
-    /// Detects when people use `Vec::sort_by` and pass in a function
+    /// Detects uses of `Vec::sort_by` passing in a closure
     /// which compares the two arguments, either directly or indirectly.
     ///
     /// **Why is this bad?**
     /// It is more clear to use `Vec::sort_by_key` (or `Vec::sort` if
-    /// possible) than to use `Vec::sort_by` and and a more complicated
+    /// possible) than to use `Vec::sort_by` and a more complicated
     /// closure.
     ///
     /// **Known problems:**
-    /// If the suggested `Vec::sort_by_key` uses Reverse and it isn't
-    /// imported by a use statement in the current frame, then a `use`
-    /// statement that imports it will need to be added (which this lint
-    /// can't do).
+    /// If the suggested `Vec::sort_by_key` uses Reverse and it isn't already
+    /// imported by a use statement, then it will need to be added manually.
     ///
     /// **Example:**
     ///
@@ -201,28 +200,41 @@ fn detect_lint(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<LintTrigger> {
             };
             let vec_name = Sugg::hir(cx, &args[0], "..").to_string();
             let unstable = name == "sort_unstable_by";
+
             if_chain! {
                 if let ExprKind::Path(QPath::Resolved(_, Path {
                     segments: [PathSegment { ident: left_name, .. }], ..
                 })) = &left_expr.kind;
                 if left_name == left_ident;
                 then {
-                    Some(LintTrigger::Sort(SortDetection { vec_name, unstable }))
-                }
-                else {
-                    Some(LintTrigger::SortByKey(SortByKeyDetection {
-                        vec_name,
-                        unstable,
-                        closure_arg,
-                        closure_body,
-                        reverse
-                    }))
+                    return Some(LintTrigger::Sort(SortDetection { vec_name, unstable }))
+                } else {
+                    if !key_returns_borrow(cx, left_expr) {
+                        return Some(LintTrigger::SortByKey(SortByKeyDetection {
+                            vec_name,
+                            unstable,
+                            closure_arg,
+                            closure_body,
+                            reverse
+                        }))
+                    }
                 }
             }
-        } else {
-            None
         }
     }
+
+    None
+}
+
+fn key_returns_borrow(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+    if let Some(def_id) = utils::fn_def_id(cx, expr) {
+        let output = cx.tcx.fn_sig(def_id).output();
+        let ty = output.skip_binder();
+        return matches!(ty.kind, ty::Ref(..))
+            || ty.walk().any(|arg| matches!(arg.unpack(), GenericArgKind::Lifetime(_)));
+    }
+
+    false
 }
 
 impl LateLintPass<'_> for UnnecessarySortBy {
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index 3a3b79925ff..93075b9f0b5 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -1363,6 +1363,21 @@ pub fn fn_has_unsatisfiable_preds(cx: &LateContext<'_>, did: DefId) -> bool {
     )
 }
 
+/// Returns the `DefId` of the callee if the given expression is a function or method call.
+pub fn fn_def_id(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<DefId> {
+    match &expr.kind {
+        ExprKind::MethodCall(..) => cx.tables().type_dependent_def_id(expr.hir_id),
+        ExprKind::Call(
+            Expr {
+                kind: ExprKind::Path(qpath),
+                ..
+            },
+            ..,
+        ) => cx.tables().qpath_res(qpath, expr.hir_id).opt_def_id(),
+        _ => None,
+    }
+}
+
 pub fn run_lints(cx: &LateContext<'_>, lints: &[&'static Lint], id: HirId) -> bool {
     lints.iter().any(|lint| {
         matches!(
diff --git a/tests/ui/unnecessary_sort_by.fixed b/tests/ui/unnecessary_sort_by.fixed
index 779fd57707a..c017d1cf9a4 100644
--- a/tests/ui/unnecessary_sort_by.fixed
+++ b/tests/ui/unnecessary_sort_by.fixed
@@ -2,11 +2,11 @@
 
 use std::cmp::Reverse;
 
-fn id(x: isize) -> isize {
-    x
-}
+fn unnecessary_sort_by() {
+    fn id(x: isize) -> isize {
+        x
+    }
 
-fn main() {
     let mut vec: Vec<isize> = vec![3, 6, 1, 2, 5];
     // Forward examples
     vec.sort();
@@ -24,3 +24,41 @@ fn main() {
     vec.sort_by(|_, b| b.cmp(c));
     vec.sort_unstable_by(|a, _| a.cmp(c));
 }
+
+// Should not be linted to avoid hitting https://github.com/rust-lang/rust/issues/34162
+mod issue_5754 {
+    struct Test(String);
+
+    #[derive(PartialOrd, Ord, PartialEq, Eq)]
+    struct Wrapper<'a>(&'a str);
+
+    impl Test {
+        fn name(&self) -> &str {
+            &self.0
+        }
+
+        fn wrapped(&self) -> Wrapper<'_> {
+            Wrapper(&self.0)
+        }
+    }
+
+    pub fn test() {
+        let mut args: Vec<Test> = vec![];
+
+        // Forward
+        args.sort_by(|a, b| a.name().cmp(b.name()));
+        args.sort_by(|a, b| a.wrapped().cmp(&b.wrapped()));
+        args.sort_unstable_by(|a, b| a.name().cmp(b.name()));
+        args.sort_unstable_by(|a, b| a.wrapped().cmp(&b.wrapped()));
+        // Reverse
+        args.sort_by(|a, b| b.name().cmp(a.name()));
+        args.sort_by(|a, b| b.wrapped().cmp(&a.wrapped()));
+        args.sort_unstable_by(|a, b| b.name().cmp(a.name()));
+        args.sort_unstable_by(|a, b| b.wrapped().cmp(&a.wrapped()));
+    }
+}
+
+fn main() {
+    unnecessary_sort_by();
+    issue_5754::test();
+}
diff --git a/tests/ui/unnecessary_sort_by.rs b/tests/ui/unnecessary_sort_by.rs
index 0485a5630af..1929c72b2f2 100644
--- a/tests/ui/unnecessary_sort_by.rs
+++ b/tests/ui/unnecessary_sort_by.rs
@@ -2,11 +2,11 @@
 
 use std::cmp::Reverse;
 
-fn id(x: isize) -> isize {
-    x
-}
+fn unnecessary_sort_by() {
+    fn id(x: isize) -> isize {
+        x
+    }
 
-fn main() {
     let mut vec: Vec<isize> = vec![3, 6, 1, 2, 5];
     // Forward examples
     vec.sort_by(|a, b| a.cmp(b));
@@ -24,3 +24,41 @@ fn main() {
     vec.sort_by(|_, b| b.cmp(c));
     vec.sort_unstable_by(|a, _| a.cmp(c));
 }
+
+// Should not be linted to avoid hitting https://github.com/rust-lang/rust/issues/34162
+mod issue_5754 {
+    struct Test(String);
+
+    #[derive(PartialOrd, Ord, PartialEq, Eq)]
+    struct Wrapper<'a>(&'a str);
+
+    impl Test {
+        fn name(&self) -> &str {
+            &self.0
+        }
+
+        fn wrapped(&self) -> Wrapper<'_> {
+            Wrapper(&self.0)
+        }
+    }
+
+    pub fn test() {
+        let mut args: Vec<Test> = vec![];
+
+        // Forward
+        args.sort_by(|a, b| a.name().cmp(b.name()));
+        args.sort_by(|a, b| a.wrapped().cmp(&b.wrapped()));
+        args.sort_unstable_by(|a, b| a.name().cmp(b.name()));
+        args.sort_unstable_by(|a, b| a.wrapped().cmp(&b.wrapped()));
+        // Reverse
+        args.sort_by(|a, b| b.name().cmp(a.name()));
+        args.sort_by(|a, b| b.wrapped().cmp(&a.wrapped()));
+        args.sort_unstable_by(|a, b| b.name().cmp(a.name()));
+        args.sort_unstable_by(|a, b| b.wrapped().cmp(&a.wrapped()));
+    }
+}
+
+fn main() {
+    unnecessary_sort_by();
+    issue_5754::test();
+}
-- 
cgit 1.4.1-3-g733a5


From dac19e3afccc63ff976bcf0a5ee385bdd0e075d5 Mon Sep 17 00:00:00 2001
From: Tim Nielens <tim.nielens@gmail.com>
Date: Tue, 7 Jul 2020 00:35:51 +0200
Subject: single_match_else - single expr/stmt else block corner case

---
 clippy_lints/src/matches.rs       | 20 +++++++++------
 tests/ui/single_match_else.rs     | 51 +++++++++++++++++++++++++++++++++++++++
 tests/ui/single_match_else.stderr | 44 +++++++++++++++++++++++++++++++--
 3 files changed, 106 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index b754a45aa40..a6cc1097441 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -530,16 +530,22 @@ fn check_single_match(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>], exp
             // the lint noisy in unnecessary situations
             return;
         }
-        let els = remove_blocks(&arms[1].body);
-        let els = if is_unit_expr(els) {
+        let els = arms[1].body;
+        let els = if is_unit_expr(remove_blocks(els)) {
             None
-        } else if let ExprKind::Block(_, _) = els.kind {
-            // matches with blocks that contain statements are prettier as `if let + else`
-            Some(els)
+        } else if let ExprKind::Block(Block { stmts, expr: block_expr, .. }, _) = els.kind {
+            if stmts.len() == 1 && block_expr.is_none() || stmts.is_empty() && block_expr.is_some() {
+                // single statement/expr "else" block, don't lint
+                return;
+            } else {
+                // block with 2+ statements or 1 expr and 1+ statement
+                Some(els)
+            }
         } else {
-            // allow match arms with just expressions
-            return;
+            // not a block, don't lint
+            return; 
         };
+
         let ty = cx.tables().expr_ty(ex);
         if ty.kind != ty::Bool || is_allowed(cx, MATCH_BOOL, ex.hir_id) {
             check_single_match_single_pattern(cx, ex, arms, expr, els);
diff --git a/tests/ui/single_match_else.rs b/tests/ui/single_match_else.rs
index 34193be0b75..b624a41a29b 100644
--- a/tests/ui/single_match_else.rs
+++ b/tests/ui/single_match_else.rs
@@ -1,4 +1,6 @@
 #![warn(clippy::single_match_else)]
+#![allow(clippy::needless_return)]
+#![allow(clippy::no_effect)]
 
 enum ExprNode {
     ExprAddrOf,
@@ -30,6 +32,55 @@ macro_rules! unwrap_addr {
     };
 }
 
+#[rustfmt::skip]
 fn main() {
     unwrap_addr!(ExprNode::Unicorns);
+
+    //
+    // don't lint single exprs/statements
+    //
+
+    // don't lint here
+    match Some(1) {
+        Some(a) => println!("${:?}", a),
+        None => return,
+    }
+
+    // don't lint here
+    match Some(1) {
+        Some(a) => println!("${:?}", a),
+        None => {
+            return
+        },
+    }
+
+    // don't lint here
+    match Some(1) {
+        Some(a) => println!("${:?}", a),
+        None => {
+            return;
+        },
+    }
+
+    //
+    // lint multiple exprs/statements "else" blocks
+    //
+
+    // lint here
+    match Some(1) {
+        Some(a) => println!("${:?}", a),
+        None => {
+            println!("else block");
+            return
+        },
+    }
+
+    // lint here
+    match Some(1) {
+        Some(a) => println!("${:?}", a),
+        None => {
+            println!("else block");
+            return;
+        },
+    }
 }
diff --git a/tests/ui/single_match_else.stderr b/tests/ui/single_match_else.stderr
index 59861d46eb3..3a07c2ec542 100644
--- a/tests/ui/single_match_else.stderr
+++ b/tests/ui/single_match_else.stderr
@@ -1,5 +1,5 @@
 error: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
-  --> $DIR/single_match_else.rs:12:5
+  --> $DIR/single_match_else.rs:14:5
    |
 LL | /     match ExprNode::Butterflies {
 LL | |         ExprNode::ExprAddrOf => Some(&NODE),
@@ -19,5 +19,45 @@ LL |         None
 LL |     }
    |
 
-error: aborting due to previous error
+error: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
+  --> $DIR/single_match_else.rs:70:5
+   |
+LL | /     match Some(1) {
+LL | |         Some(a) => println!("${:?}", a),
+LL | |         None => {
+LL | |             println!("else block");
+LL | |             return
+LL | |         },
+LL | |     }
+   | |_____^
+   |
+help: try this
+   |
+LL |     if let Some(a) = Some(1) { println!("${:?}", a) } else {
+LL |         println!("else block");
+LL |         return
+LL |     }
+   |
+
+error: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
+  --> $DIR/single_match_else.rs:79:5
+   |
+LL | /     match Some(1) {
+LL | |         Some(a) => println!("${:?}", a),
+LL | |         None => {
+LL | |             println!("else block");
+LL | |             return;
+LL | |         },
+LL | |     }
+   | |_____^
+   |
+help: try this
+   |
+LL |     if let Some(a) = Some(1) { println!("${:?}", a) } else {
+LL |         println!("else block");
+LL |         return;
+LL |     }
+   |
+
+error: aborting due to 3 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 298a1fa3bd8ec04350b1bff6a6d92e34abf2e198 Mon Sep 17 00:00:00 2001
From: Christian Duerr <contact@christianduerr.com>
Date: Fri, 26 Jun 2020 17:03:10 +0200
Subject: Move range_minus_one to pedantic

This moves the range_minus_one lint to the pedantic category, so there
will not be any warnings emitted by default. This should work around
problems where the suggestion is impossible to resolve due to the range
consumer only accepting a specific range implementation, rather than the
`RangeBounds` trait (see #3307).

While it is possible to work around this by extracting the boundary into
a variable, I don't think clippy should encourage people to disable or
work around lints, but instead the lints should be fixable. So hopefully
this will help until a proper implementation checks what the range is
used for.
---
 clippy_lints/src/ranges.rs | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/ranges.rs b/clippy_lints/src/ranges.rs
index c164ec9aaf1..dd608de5723 100644
--- a/clippy_lints/src/ranges.rs
+++ b/clippy_lints/src/ranges.rs
@@ -52,6 +52,11 @@ declare_clippy_lint! {
     /// exclusive ranges, because they essentially add an extra branch that
     /// LLVM may fail to hoist out of the loop.
     ///
+    /// This will cause a warning that cannot be fixed if the consumer of the
+    /// range only accepts a specific range type, instead of the generic
+    /// `RangeBounds` trait
+    /// ([#3307](https://github.com/rust-lang/rust-clippy/issues/3307)).
+    ///
     /// **Example:**
     /// ```rust,ignore
     /// for x..(y+1) { .. }
@@ -72,7 +77,10 @@ declare_clippy_lint! {
     /// **Why is this bad?** The code is more readable with an exclusive range
     /// like `x..y`.
     ///
-    /// **Known problems:** None.
+    /// **Known problems:** This will cause a warning that cannot be fixed if
+    /// the consumer of the range only accepts a specific range type, instead of
+    /// the generic `RangeBounds` trait
+    /// ([#3307](https://github.com/rust-lang/rust-clippy/issues/3307)).
     ///
     /// **Example:**
     /// ```rust,ignore
@@ -83,7 +91,7 @@ declare_clippy_lint! {
     /// for x..y { .. }
     /// ```
     pub RANGE_MINUS_ONE,
-    complexity,
+    pedantic,
     "`x..=(y-1)` reads better as `x..y`"
 }
 
-- 
cgit 1.4.1-3-g733a5


From ba2a85dadc61bbfeb483ca0d05ddfda213da1329 Mon Sep 17 00:00:00 2001
From: Christian Duerr <contact@christianduerr.com>
Date: Fri, 3 Jul 2020 21:09:32 +0200
Subject: Run update_lints

---
 clippy_lints/src/lib.rs | 3 +--
 src/lintlist/mod.rs     | 2 +-
 2 files changed, 2 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index fe34e4390d6..4d9776018cf 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1162,6 +1162,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&needless_pass_by_value::NEEDLESS_PASS_BY_VALUE),
         LintId::of(&non_expressive_names::SIMILAR_NAMES),
         LintId::of(&option_if_let_else::OPTION_IF_LET_ELSE),
+        LintId::of(&ranges::RANGE_MINUS_ONE),
         LintId::of(&ranges::RANGE_PLUS_ONE),
         LintId::of(&shadow::SHADOW_UNRELATED),
         LintId::of(&strings::STRING_ADD_ASSIGN),
@@ -1382,7 +1383,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&ptr::PTR_ARG),
         LintId::of(&ptr_offset_with_cast::PTR_OFFSET_WITH_CAST),
         LintId::of(&question_mark::QUESTION_MARK),
-        LintId::of(&ranges::RANGE_MINUS_ONE),
         LintId::of(&ranges::RANGE_ZIP_WITH_LEN),
         LintId::of(&ranges::REVERSED_EMPTY_RANGES),
         LintId::of(&redundant_clone::REDUNDANT_CLONE),
@@ -1598,7 +1598,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&partialeq_ne_impl::PARTIALEQ_NE_IMPL),
         LintId::of(&precedence::PRECEDENCE),
         LintId::of(&ptr_offset_with_cast::PTR_OFFSET_WITH_CAST),
-        LintId::of(&ranges::RANGE_MINUS_ONE),
         LintId::of(&ranges::RANGE_ZIP_WITH_LEN),
         LintId::of(&reference::DEREF_ADDROF),
         LintId::of(&reference::REF_IN_DEREF),
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index e681f47f949..c20793ecd3e 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -1783,7 +1783,7 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
     },
     Lint {
         name: "range_minus_one",
-        group: "complexity",
+        group: "pedantic",
         desc: "`x..=(y-1)` reads better as `x..y`",
         deprecation: None,
         module: "ranges",
-- 
cgit 1.4.1-3-g733a5


From 780a4c87de88d7f747c7847b71c90c8268fe4b66 Mon Sep 17 00:00:00 2001
From: Takayuki Nakata <f.seasons017@gmail.com>
Date: Fri, 10 Jul 2020 23:53:15 +0900
Subject: Fix typo

---
 clippy_lints/src/repeat_once.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/repeat_once.rs b/clippy_lints/src/repeat_once.rs
index af3c948ec82..436374d7c54 100644
--- a/clippy_lints/src/repeat_once.rs
+++ b/clippy_lints/src/repeat_once.rs
@@ -15,7 +15,7 @@ declare_clippy_lint! {
     /// - `.clone()` for `String`
     /// - `.to_vec()` for `slice`
     ///
-    /// **Why is this bad?** For example, `String.repeat(1)` is equivalent to `.clone()`. If cloning the string is the intention behind thi, `clone()` should be used.
+    /// **Why is this bad?** For example, `String.repeat(1)` is equivalent to `.clone()`. If cloning the string is the intention behind this, `clone()` should be used.
     ///
     /// **Known problems:** None.
     ///
-- 
cgit 1.4.1-3-g733a5


From 1b3bc16533a3e701616648920603c10674eb653b Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Sat, 11 Jul 2020 12:28:21 +0200
Subject: Fix out of bounds access by checking length equality BEFORE accessing
 by index.

Fixes #5780
---
 clippy_lints/src/unnested_or_patterns.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unnested_or_patterns.rs b/clippy_lints/src/unnested_or_patterns.rs
index 169a486d1eb..502bf0c4279 100644
--- a/clippy_lints/src/unnested_or_patterns.rs
+++ b/clippy_lints/src/unnested_or_patterns.rs
@@ -400,8 +400,8 @@ fn extend_with_matching(
 
 /// Are the patterns in `ps1` and `ps2` equal save for `ps1[idx]` compared to `ps2[idx]`?
 fn eq_pre_post(ps1: &[P<Pat>], ps2: &[P<Pat>], idx: usize) -> bool {
-    ps1[idx].is_rest() == ps2[idx].is_rest() // Avoid `[x, ..] | [x, 0]` => `[x, .. | 0]`.
-        && ps1.len() == ps2.len()
+    ps1.len() == ps2.len()
+        && ps1[idx].is_rest() == ps2[idx].is_rest() // Avoid `[x, ..] | [x, 0]` => `[x, .. | 0]`.
         && over(&ps1[..idx], &ps2[..idx], |l, r| eq_pat(l, r))
         && over(&ps1[idx + 1..], &ps2[idx + 1..], |l, r| eq_pat(l, r))
 }
-- 
cgit 1.4.1-3-g733a5


From f2419b9d6299fb07a1163b47dc273f64e0444a6c Mon Sep 17 00:00:00 2001
From: Takayuki Nakata <f.seasons017@gmail.com>
Date: Tue, 14 Jul 2020 00:11:10 +0900
Subject: Refactoring to use `constant_context

Use `constant_context`, `.is_str()` and `builtin_index()` to simplify.
---
 clippy_lints/src/repeat_once.rs | 54 ++++-------------------------------------
 1 file changed, 5 insertions(+), 49 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/repeat_once.rs b/clippy_lints/src/repeat_once.rs
index 436374d7c54..3a0b3b1c257 100644
--- a/clippy_lints/src/repeat_once.rs
+++ b/clippy_lints/src/repeat_once.rs
@@ -1,12 +1,9 @@
-use crate::consts::{miri_to_const, Constant};
+use crate::consts::{constant_context, Constant};
 use crate::utils::{in_macro, is_type_diagnostic_item, snippet, span_lint_and_sugg, walk_ptrs_ty};
 use if_chain::if_chain;
-use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
-use rustc_hir::def::{DefKind, Res};
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty::{self, Ty};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
@@ -44,10 +41,11 @@ impl<'tcx> LateLintPass<'tcx> for RepeatOnce {
         if_chain! {
             if let ExprKind::MethodCall(ref path, _, ref args, _) = expr.kind;
             if path.ident.name == sym!(repeat);
-            if is_once(cx, &args[1]) && !in_macro(args[0].span);
+            if let Some(Constant::Int(1)) = constant_context(cx, cx.tables()).expr(&args[1]);
+            if !in_macro(args[0].span);
             then {
                 let ty = walk_ptrs_ty(cx.tables().expr_ty(&args[0]));
-                if is_str(ty){
+                if ty.is_str() {
                     span_lint_and_sugg(
                         cx,
                         REPEAT_ONCE,
@@ -57,7 +55,7 @@ impl<'tcx> LateLintPass<'tcx> for RepeatOnce {
                         format!("{}.to_string()", snippet(cx, args[0].span, r#""...""#)),
                         Applicability::MachineApplicable,
                     );
-                } else if is_slice(ty) {
+                } else if let Some(_) = ty.builtin_index() {
                     span_lint_and_sugg(
                         cx,
                         REPEAT_ONCE,
@@ -82,45 +80,3 @@ impl<'tcx> LateLintPass<'tcx> for RepeatOnce {
         }
     }
 }
-
-fn is_once<'tcx>(cx: &LateContext<'_>, expr: &'tcx Expr<'_>) -> bool {
-    match expr.kind {
-        ExprKind::Lit(ref lit) => {
-            if let LitKind::Int(ref lit_content, _) = lit.node {
-                *lit_content == 1
-            } else {
-                false
-            }
-        },
-        ExprKind::Path(rustc_hir::QPath::Resolved(None, path)) => {
-            if let Res::Def(DefKind::Const, def_id) = path.res {
-                let ty = cx.tcx.type_of(def_id);
-                let con = cx
-                    .tcx
-                    .const_eval_poly(def_id)
-                    .ok()
-                    .map(|val| rustc_middle::ty::Const::from_value(cx.tcx, val, ty))
-                    .unwrap();
-                let con = miri_to_const(con);
-                con == Some(Constant::Int(1))
-            } else {
-                false
-            }
-        },
-        _ => false,
-    }
-}
-
-fn is_str(ty: Ty<'_>) -> bool {
-    match ty.kind {
-        ty::Str => true,
-        _ => false,
-    }
-}
-
-fn is_slice(ty: Ty<'_>) -> bool {
-    match ty.kind {
-        ty::Slice(..) | ty::Array(..) => true,
-        _ => false,
-    }
-}
-- 
cgit 1.4.1-3-g733a5


From ff796b6d7082d5b5c073797aba17f454eebe3359 Mon Sep 17 00:00:00 2001
From: bjorn3 <bjorn3@users.noreply.github.com>
Date: Fri, 19 Jun 2020 11:44:03 +0200
Subject: Rename collapsable_if fix suggestion to "collapse nested if block"

The name "try" is confusing when shown as quick fix by rust-analyzer
---
 clippy_lints/src/collapsible_if.rs  |  4 ++--
 tests/ui/collapsible_else_if.stderr | 14 +++++++-------
 tests/ui/collapsible_if.stderr      | 14 +++++++-------
 3 files changed, 16 insertions(+), 16 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/collapsible_if.rs b/clippy_lints/src/collapsible_if.rs
index 8090f4673aa..42bff564de0 100644
--- a/clippy_lints/src/collapsible_if.rs
+++ b/clippy_lints/src/collapsible_if.rs
@@ -115,7 +115,7 @@ fn check_collapsible_maybe_if_let(cx: &EarlyContext<'_>, else_: &ast::Expr) {
                 COLLAPSIBLE_IF,
                 block.span,
                 "this `else { if .. }` block can be collapsed",
-                "try",
+                "collapse nested if block",
                 snippet_block_with_applicability(cx, else_.span, "..", Some(block.span), &mut applicability).into_owned(),
                 applicability,
             );
@@ -142,7 +142,7 @@ fn check_collapsible_no_if_let(cx: &EarlyContext<'_>, expr: &ast::Expr, check: &
                 let rhs = Sugg::ast(cx, check_inner, "..");
                 diag.span_suggestion(
                     expr.span,
-                    "try",
+                    "collapse nested if block",
                     format!(
                         "if {} {}",
                         lhs.and(&rhs),
diff --git a/tests/ui/collapsible_else_if.stderr b/tests/ui/collapsible_else_if.stderr
index 28048999e8e..3d1c458879e 100644
--- a/tests/ui/collapsible_else_if.stderr
+++ b/tests/ui/collapsible_else_if.stderr
@@ -10,7 +10,7 @@ LL | |     }
    | |_____^
    |
    = note: `-D clippy::collapsible-if` implied by `-D warnings`
-help: try
+help: collapse nested if block
    |
 LL |     } else if y == "world" {
 LL |         println!("world!")
@@ -28,7 +28,7 @@ LL | |         }
 LL | |     }
    | |_____^
    |
-help: try
+help: collapse nested if block
    |
 LL |     } else if let Some(42) = Some(42) {
 LL |         println!("world!")
@@ -48,7 +48,7 @@ LL | |         }
 LL | |     }
    | |_____^
    |
-help: try
+help: collapse nested if block
    |
 LL |     } else if y == "world" {
 LL |         println!("world")
@@ -71,7 +71,7 @@ LL | |         }
 LL | |     }
    | |_____^
    |
-help: try
+help: collapse nested if block
    |
 LL |     } else if let Some(42) = Some(42) {
 LL |         println!("world")
@@ -94,7 +94,7 @@ LL | |         }
 LL | |     }
    | |_____^
    |
-help: try
+help: collapse nested if block
    |
 LL |     } else if let Some(42) = Some(42) {
 LL |         println!("world")
@@ -117,7 +117,7 @@ LL | |         }
 LL | |     }
    | |_____^
    |
-help: try
+help: collapse nested if block
    |
 LL |     } else if x == "hello" {
 LL |         println!("world")
@@ -140,7 +140,7 @@ LL | |         }
 LL | |     }
    | |_____^
    |
-help: try
+help: collapse nested if block
    |
 LL |     } else if let Some(42) = Some(42) {
 LL |         println!("world")
diff --git a/tests/ui/collapsible_if.stderr b/tests/ui/collapsible_if.stderr
index 6440ff41be8..f56dd65b9dd 100644
--- a/tests/ui/collapsible_if.stderr
+++ b/tests/ui/collapsible_if.stderr
@@ -9,7 +9,7 @@ LL | |     }
    | |_____^
    |
    = note: `-D clippy::collapsible-if` implied by `-D warnings`
-help: try
+help: collapse nested if block
    |
 LL |     if x == "hello" && y == "world" {
 LL |         println!("Hello world!");
@@ -26,7 +26,7 @@ LL | |         }
 LL | |     }
    | |_____^
    |
-help: try
+help: collapse nested if block
    |
 LL |     if (x == "hello" || x == "world") && (y == "world" || y == "hello") {
 LL |         println!("Hello world!");
@@ -43,7 +43,7 @@ LL | |         }
 LL | |     }
    | |_____^
    |
-help: try
+help: collapse nested if block
    |
 LL |     if x == "hello" && x == "world" && (y == "world" || y == "hello") {
 LL |         println!("Hello world!");
@@ -60,7 +60,7 @@ LL | |         }
 LL | |     }
    | |_____^
    |
-help: try
+help: collapse nested if block
    |
 LL |     if (x == "hello" || x == "world") && y == "world" && y == "hello" {
 LL |         println!("Hello world!");
@@ -77,7 +77,7 @@ LL | |         }
 LL | |     }
    | |_____^
    |
-help: try
+help: collapse nested if block
    |
 LL |     if x == "hello" && x == "world" && y == "world" && y == "hello" {
 LL |         println!("Hello world!");
@@ -94,7 +94,7 @@ LL | |         }
 LL | |     }
    | |_____^
    |
-help: try
+help: collapse nested if block
    |
 LL |     if 42 == 1337 && 'a' != 'A' {
 LL |         println!("world!")
@@ -111,7 +111,7 @@ LL | |         }
 LL | |     }
    | |_____^
    |
-help: try
+help: collapse nested if block
    |
 LL |     if x == "hello" && y == "world" { // Collapsible
 LL |         println!("Hello world!");
-- 
cgit 1.4.1-3-g733a5


From 201999ccfd18a9debe1f186f30f40659ebc6b933 Mon Sep 17 00:00:00 2001
From: Brian Warner <warner@lothar.com>
Date: Mon, 13 Jul 2020 10:33:25 -0700
Subject: improve advice in iter_nth_zero

The "use .next()" replacement advice is on the last line of the code snippet,
where it is vulnerable to truncation. Display that advice at the beginning
instead.

closes #5783
---
 clippy_lints/src/methods/mod.rs |  4 ++--
 tests/ui/iter_nth_zero.stderr   | 12 ++++++------
 2 files changed, 8 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 4c595029ff7..565a08f1292 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -2348,8 +2348,8 @@ fn lint_iter_nth_zero<'tcx>(cx: &LateContext<'tcx>, expr: &hir::Expr<'_>, nth_ar
                 cx,
                 ITER_NTH_ZERO,
                 expr.span,
-                "called `.nth(0)` on a `std::iter::Iterator`",
-                "try calling",
+                "called `.nth(0)` on a `std::iter::Iterator`, when `.next()` is equivalent",
+                "try calling .next() instead of .nth(0)",
                 format!("{}.next()", snippet_with_applicability(cx, nth_args[0].span, "..", &mut applicability)),
                 applicability,
             );
diff --git a/tests/ui/iter_nth_zero.stderr b/tests/ui/iter_nth_zero.stderr
index 2b20a4ceb4a..6c4200a7905 100644
--- a/tests/ui/iter_nth_zero.stderr
+++ b/tests/ui/iter_nth_zero.stderr
@@ -1,22 +1,22 @@
-error: called `.nth(0)` on a `std::iter::Iterator`
+error: called `.nth(0)` on a `std::iter::Iterator`, when `.next()` is equivalent
   --> $DIR/iter_nth_zero.rs:20:14
    |
 LL |     let _x = s.iter().nth(0);
-   |              ^^^^^^^^^^^^^^^ help: try calling: `s.iter().next()`
+   |              ^^^^^^^^^^^^^^^ help: try calling .next() instead of .nth(0): `s.iter().next()`
    |
    = note: `-D clippy::iter-nth-zero` implied by `-D warnings`
 
-error: called `.nth(0)` on a `std::iter::Iterator`
+error: called `.nth(0)` on a `std::iter::Iterator`, when `.next()` is equivalent
   --> $DIR/iter_nth_zero.rs:25:14
    |
 LL |     let _y = iter.nth(0);
-   |              ^^^^^^^^^^^ help: try calling: `iter.next()`
+   |              ^^^^^^^^^^^ help: try calling .next() instead of .nth(0): `iter.next()`
 
-error: called `.nth(0)` on a `std::iter::Iterator`
+error: called `.nth(0)` on a `std::iter::Iterator`, when `.next()` is equivalent
   --> $DIR/iter_nth_zero.rs:30:22
    |
 LL |     let _unwrapped = iter2.nth(0).unwrap();
-   |                      ^^^^^^^^^^^^ help: try calling: `iter2.next()`
+   |                      ^^^^^^^^^^^^ help: try calling .next() instead of .nth(0): `iter2.next()`
 
 error: aborting due to 3 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From b4091032abbadf586ea8c77bc547ec2ac403ef0a Mon Sep 17 00:00:00 2001
From: Takayuki Nakata <f.seasons017@gmail.com>
Date: Tue, 14 Jul 2020 08:08:13 +0900
Subject: Use `.is_some()` not `Some(_)`

---
 clippy_lints/src/repeat_once.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/repeat_once.rs b/clippy_lints/src/repeat_once.rs
index 3a0b3b1c257..a3af369e41e 100644
--- a/clippy_lints/src/repeat_once.rs
+++ b/clippy_lints/src/repeat_once.rs
@@ -55,7 +55,7 @@ impl<'tcx> LateLintPass<'tcx> for RepeatOnce {
                         format!("{}.to_string()", snippet(cx, args[0].span, r#""...""#)),
                         Applicability::MachineApplicable,
                     );
-                } else if let Some(_) = ty.builtin_index() {
+                } else if ty.builtin_index().is_some() {
                     span_lint_and_sugg(
                         cx,
                         REPEAT_ONCE,
-- 
cgit 1.4.1-3-g733a5


From 126790999a128a880ca276c49afd2927a66ffbbe Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Mon, 30 Mar 2020 11:02:14 +0200
Subject: new lint: Returning unit from closures expecting Ord

This lint catches cases where the last statement of a closure expecting
an instance of Ord has a trailing semi-colon. It compiles since the
closure ends up return () which also implements Ord but causes
unexpected results in cases such as sort_by_key.

Fixes #5080

reprise: rebase, update and address all concerns
---
 CHANGELOG.md                                  |   1 +
 clippy_lints/src/lib.rs                       |   5 +
 clippy_lints/src/unit_return_expecting_ord.rs | 177 ++++++++++++++++++++++++++
 src/lintlist/mod.rs                           |   7 +
 tests/ui/unit_return_expecting_ord.rs         |  36 ++++++
 tests/ui/unit_return_expecting_ord.stderr     |  39 ++++++
 6 files changed, 265 insertions(+)
 create mode 100644 clippy_lints/src/unit_return_expecting_ord.rs
 create mode 100644 tests/ui/unit_return_expecting_ord.rs
 create mode 100644 tests/ui/unit_return_expecting_ord.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5d08b44ba40..1c927b5f83a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1679,6 +1679,7 @@ Released 2018-09-13
 [`uninit_assumed_init`]: https://rust-lang.github.io/rust-clippy/master/index.html#uninit_assumed_init
 [`unit_arg`]: https://rust-lang.github.io/rust-clippy/master/index.html#unit_arg
 [`unit_cmp`]: https://rust-lang.github.io/rust-clippy/master/index.html#unit_cmp
+[`unit_return_expecting_ord`]: https://rust-lang.github.io/rust-clippy/master/index.html#unit_return_expecting_ord
 [`unknown_clippy_lints`]: https://rust-lang.github.io/rust-clippy/master/index.html#unknown_clippy_lints
 [`unnecessary_cast`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_cast
 [`unnecessary_filter_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_filter_map
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 32e79317f82..7a4ca3902b3 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -300,6 +300,7 @@ mod trivially_copy_pass_by_ref;
 mod try_err;
 mod types;
 mod unicode;
+mod unit_return_expecting_ord;
 mod unnamed_address;
 mod unnecessary_sort_by;
 mod unnested_or_patterns;
@@ -826,6 +827,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &unicode::NON_ASCII_LITERAL,
         &unicode::UNICODE_NOT_NFC,
         &unicode::ZERO_WIDTH_SPACE,
+        &unit_return_expecting_ord::UNIT_RETURN_EXPECTING_ORD,
         &unnamed_address::FN_ADDRESS_COMPARISONS,
         &unnamed_address::VTABLE_ADDRESS_COMPARISONS,
         &unnecessary_sort_by::UNNECESSARY_SORT_BY,
@@ -891,6 +893,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box attrs::Attributes);
     store.register_late_pass(|| box blocks_in_if_conditions::BlocksInIfConditions);
     store.register_late_pass(|| box unicode::Unicode);
+    store.register_late_pass(|| box unit_return_expecting_ord::UnitReturnExpectingOrd);
     store.register_late_pass(|| box strings::StringAdd);
     store.register_late_pass(|| box implicit_return::ImplicitReturn);
     store.register_late_pass(|| box implicit_saturating_sub::ImplicitSaturatingSub);
@@ -1436,6 +1439,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&types::UNNECESSARY_CAST),
         LintId::of(&types::VEC_BOX),
         LintId::of(&unicode::ZERO_WIDTH_SPACE),
+        LintId::of(&unit_return_expecting_ord::UNIT_RETURN_EXPECTING_ORD),
         LintId::of(&unnamed_address::FN_ADDRESS_COMPARISONS),
         LintId::of(&unnamed_address::VTABLE_ADDRESS_COMPARISONS),
         LintId::of(&unnecessary_sort_by::UNNECESSARY_SORT_BY),
@@ -1692,6 +1696,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&types::CAST_REF_TO_MUT),
         LintId::of(&types::UNIT_CMP),
         LintId::of(&unicode::ZERO_WIDTH_SPACE),
+        LintId::of(&unit_return_expecting_ord::UNIT_RETURN_EXPECTING_ORD),
         LintId::of(&unnamed_address::FN_ADDRESS_COMPARISONS),
         LintId::of(&unnamed_address::VTABLE_ADDRESS_COMPARISONS),
         LintId::of(&unused_io_amount::UNUSED_IO_AMOUNT),
diff --git a/clippy_lints/src/unit_return_expecting_ord.rs b/clippy_lints/src/unit_return_expecting_ord.rs
new file mode 100644
index 00000000000..fceb885516b
--- /dev/null
+++ b/clippy_lints/src/unit_return_expecting_ord.rs
@@ -0,0 +1,177 @@
+use crate::utils::{get_trait_def_id, paths, span_lint, span_lint_and_help};
+use if_chain::if_chain;
+use rustc_hir::def_id::DefId;
+use rustc_hir::{Expr, ExprKind, StmtKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty;
+use rustc_middle::ty::{GenericPredicates, PredicateKind, ProjectionPredicate, TraitPredicate};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::{BytePos, Span};
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for functions that expect closures of type
+    /// Fn(...) -> Ord where the implemented closure returns the unit type.
+    /// The lint also suggests to remove the semi-colon at the end of the statement if present.
+    ///
+    /// **Why is this bad?** Likely, returning the unit type is unintentional, and
+    /// could simply be caused by an extra semi-colon. Since () implements Ord
+    /// it doesn't cause a compilation error.
+    /// This is the same reasoning behind the unit_cmp lint.
+    ///
+    /// **Known problems:** If returning unit is intentional, then there is no
+    /// way of specifying this without triggering needless_return lint
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// let mut twins = vec!((1,1), (2,2));
+    /// twins.sort_by_key(|x| { x.1; });
+    /// ```
+    pub UNIT_RETURN_EXPECTING_ORD,
+    correctness,
+    "fn arguments of type Fn(...) -> Ord returning the unit type ()."
+}
+
+declare_lint_pass!(UnitReturnExpectingOrd => [UNIT_RETURN_EXPECTING_ORD]);
+
+fn get_trait_predicates_for_trait_id<'tcx>(
+    cx: &LateContext<'tcx>,
+    generics: GenericPredicates<'tcx>,
+    trait_id: Option<DefId>,
+) -> Vec<TraitPredicate<'tcx>> {
+    let mut preds = Vec::new();
+    for (pred, _) in generics.predicates {
+        if_chain! {
+            if let PredicateKind::Trait(poly_trait_pred, _) = pred.kind();
+            let trait_pred = cx.tcx.erase_late_bound_regions(&poly_trait_pred);
+            if let Some(trait_def_id) = trait_id;
+            if trait_def_id == trait_pred.trait_ref.def_id;
+            then {
+                preds.push(trait_pred);
+            }
+        }
+    }
+    preds
+}
+
+fn get_projection_pred<'tcx>(
+    cx: &LateContext<'tcx>,
+    generics: GenericPredicates<'tcx>,
+    pred: TraitPredicate<'tcx>,
+) -> Option<ProjectionPredicate<'tcx>> {
+    generics.predicates.iter().find_map(|(proj_pred, _)| {
+        if let PredicateKind::Projection(proj_pred) = proj_pred.kind() {
+            let projection_pred = cx.tcx.erase_late_bound_regions(proj_pred);
+            if projection_pred.projection_ty.substs == pred.trait_ref.substs {
+                return Some(projection_pred);
+            }
+        }
+        None
+    })
+}
+
+fn get_args_to_check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> Vec<(usize, String)> {
+    let mut args_to_check = Vec::new();
+    if let Some(def_id) = cx.tables().type_dependent_def_id(expr.hir_id) {
+        let fn_sig = cx.tcx.fn_sig(def_id);
+        let generics = cx.tcx.predicates_of(def_id);
+        let fn_mut_preds = get_trait_predicates_for_trait_id(cx, generics, cx.tcx.lang_items().fn_mut_trait());
+        let ord_preds = get_trait_predicates_for_trait_id(cx, generics, get_trait_def_id(cx, &paths::ORD));
+        let partial_ord_preds =
+            get_trait_predicates_for_trait_id(cx, generics, cx.tcx.lang_items().partial_ord_trait());
+        // Trying to call erase_late_bound_regions on fn_sig.inputs() gives the following error
+        // The trait `rustc::ty::TypeFoldable<'_>` is not implemented for `&[&rustc::ty::TyS<'_>]`
+        let inputs_output = cx.tcx.erase_late_bound_regions(&fn_sig.inputs_and_output());
+        inputs_output
+            .iter()
+            .rev()
+            .skip(1)
+            .rev()
+            .enumerate()
+            .for_each(|(i, inp)| {
+                for trait_pred in &fn_mut_preds {
+                    if_chain! {
+                        if trait_pred.self_ty() == inp;
+                        if let Some(return_ty_pred) = get_projection_pred(cx, generics, *trait_pred);
+                        then {
+                            if ord_preds.iter().any(|ord| ord.self_ty() == return_ty_pred.ty) {
+                                args_to_check.push((i, "Ord".to_string()));
+                            } else if partial_ord_preds.iter().any(|pord| pord.self_ty() == return_ty_pred.ty) {
+                                args_to_check.push((i, "PartialOrd".to_string()));
+                            }
+                        }
+                    }
+                }
+            });
+    }
+    args_to_check
+}
+
+fn check_arg<'tcx>(cx: &LateContext<'tcx>, arg: &'tcx Expr<'tcx>) -> Option<(Span, Option<Span>)> {
+    if_chain! {
+        if let ExprKind::Closure(_, _fn_decl, body_id, span, _) = arg.kind;
+        if let ty::Closure(_def_id, substs) = &cx.tables().node_type(arg.hir_id).kind;
+        let ret_ty = substs.as_closure().sig().output();
+        let ty = cx.tcx.erase_late_bound_regions(&ret_ty);
+        if ty.is_unit();
+        then {
+            if_chain! {
+                let body = cx.tcx.hir().body(body_id);
+                if let ExprKind::Block(block, _) = body.value.kind;
+                if block.expr.is_none();
+                if let Some(stmt) = block.stmts.last();
+                if let StmtKind::Semi(_) = stmt.kind;
+                then {
+                    let data = stmt.span.data();
+                    // Make a span out of the semicolon for the help message
+                    Some((span, Some(Span::new(data.hi-BytePos(1), data.hi, data.ctxt))))
+                } else {
+                    Some((span, None))
+                }
+            }
+        } else {
+            None
+        }
+    }
+}
+
+impl<'tcx> LateLintPass<'tcx> for UnitReturnExpectingOrd {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
+        if let ExprKind::MethodCall(_, _, ref args, _) = expr.kind {
+            let arg_indices = get_args_to_check(cx, expr);
+            for (i, trait_name) in arg_indices {
+                if i < args.len() {
+                    match check_arg(cx, &args[i]) {
+                        Some((span, None)) => {
+                            span_lint(
+                                cx,
+                                UNIT_RETURN_EXPECTING_ORD,
+                                span,
+                                &format!(
+                                    "this closure returns \
+                                   the unit type which also implements {}",
+                                    trait_name
+                                ),
+                            );
+                        },
+                        Some((span, Some(last_semi))) => {
+                            span_lint_and_help(
+                                cx,
+                                UNIT_RETURN_EXPECTING_ORD,
+                                span,
+                                &format!(
+                                    "this closure returns \
+                                   the unit type which also implements {}",
+                                    trait_name
+                                ),
+                                Some(last_semi),
+                                &"probably caused by this trailing semicolon".to_string(),
+                            );
+                        },
+                        None => {},
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index b89a8712862..96b004904aa 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -2292,6 +2292,13 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
         deprecation: None,
         module: "types",
     },
+    Lint {
+        name: "unit_return_expecting_ord",
+        group: "correctness",
+        desc: "fn arguments of type Fn(...) -> Ord returning the unit type ().",
+        deprecation: None,
+        module: "unit_return_expecting_ord",
+    },
     Lint {
         name: "unknown_clippy_lints",
         group: "style",
diff --git a/tests/ui/unit_return_expecting_ord.rs b/tests/ui/unit_return_expecting_ord.rs
new file mode 100644
index 00000000000..bdb4710cc69
--- /dev/null
+++ b/tests/ui/unit_return_expecting_ord.rs
@@ -0,0 +1,36 @@
+#![warn(clippy::unit_return_expecting_ord)]
+#![allow(clippy::needless_return)]
+#![allow(clippy::unused_unit)]
+#![feature(is_sorted)]
+
+struct Struct {
+    field: isize,
+}
+
+fn double(i: isize) -> isize {
+    i * 2
+}
+
+fn unit(_i: isize) {}
+
+fn main() {
+    let mut structs = vec![Struct { field: 2 }, Struct { field: 1 }];
+    structs.sort_by_key(|s| {
+        double(s.field);
+    });
+    structs.sort_by_key(|s| double(s.field));
+    structs.is_sorted_by_key(|s| {
+        double(s.field);
+    });
+    structs.is_sorted_by_key(|s| {
+        if s.field > 0 {
+            ()
+        } else {
+            return ();
+        }
+    });
+    structs.sort_by_key(|s| {
+        return double(s.field);
+    });
+    structs.sort_by_key(|s| unit(s.field));
+}
diff --git a/tests/ui/unit_return_expecting_ord.stderr b/tests/ui/unit_return_expecting_ord.stderr
new file mode 100644
index 00000000000..e63d5874609
--- /dev/null
+++ b/tests/ui/unit_return_expecting_ord.stderr
@@ -0,0 +1,39 @@
+error: this closure returns the unit type which also implements Ord
+  --> $DIR/unit_return_expecting_ord.rs:18:25
+   |
+LL |     structs.sort_by_key(|s| {
+   |                         ^^^
+   |
+   = note: `-D clippy::unit-return-expecting-ord` implied by `-D warnings`
+help: probably caused by this trailing semicolon
+  --> $DIR/unit_return_expecting_ord.rs:19:24
+   |
+LL |         double(s.field);
+   |                        ^
+
+error: this closure returns the unit type which also implements PartialOrd
+  --> $DIR/unit_return_expecting_ord.rs:22:30
+   |
+LL |     structs.is_sorted_by_key(|s| {
+   |                              ^^^
+   |
+help: probably caused by this trailing semicolon
+  --> $DIR/unit_return_expecting_ord.rs:23:24
+   |
+LL |         double(s.field);
+   |                        ^
+
+error: this closure returns the unit type which also implements PartialOrd
+  --> $DIR/unit_return_expecting_ord.rs:25:30
+   |
+LL |     structs.is_sorted_by_key(|s| {
+   |                              ^^^
+
+error: this closure returns the unit type which also implements Ord
+  --> $DIR/unit_return_expecting_ord.rs:35:25
+   |
+LL |     structs.sort_by_key(|s| unit(s.field));
+   |                         ^^^
+
+error: aborting due to 4 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From e83b3eb9930ab527451edaaa6f524acd26c1bf1c Mon Sep 17 00:00:00 2001
From: Brian Warner <warner@lothar.com>
Date: Tue, 14 Jul 2020 09:20:19 -0700
Subject: formatting nits

---
 clippy_lints/src/methods/mod.rs | 2 +-
 tests/ui/iter_nth_zero.stderr   | 6 +++---
 2 files changed, 4 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 565a08f1292..69e985cc0a4 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -2349,7 +2349,7 @@ fn lint_iter_nth_zero<'tcx>(cx: &LateContext<'tcx>, expr: &hir::Expr<'_>, nth_ar
                 ITER_NTH_ZERO,
                 expr.span,
                 "called `.nth(0)` on a `std::iter::Iterator`, when `.next()` is equivalent",
-                "try calling .next() instead of .nth(0)",
+                "try calling `.next()` instead of `.nth(0)`",
                 format!("{}.next()", snippet_with_applicability(cx, nth_args[0].span, "..", &mut applicability)),
                 applicability,
             );
diff --git a/tests/ui/iter_nth_zero.stderr b/tests/ui/iter_nth_zero.stderr
index 6c4200a7905..29c56f3a94f 100644
--- a/tests/ui/iter_nth_zero.stderr
+++ b/tests/ui/iter_nth_zero.stderr
@@ -2,7 +2,7 @@ error: called `.nth(0)` on a `std::iter::Iterator`, when `.next()` is equivalent
   --> $DIR/iter_nth_zero.rs:20:14
    |
 LL |     let _x = s.iter().nth(0);
-   |              ^^^^^^^^^^^^^^^ help: try calling .next() instead of .nth(0): `s.iter().next()`
+   |              ^^^^^^^^^^^^^^^ help: try calling `.next()` instead of `.nth(0)`: `s.iter().next()`
    |
    = note: `-D clippy::iter-nth-zero` implied by `-D warnings`
 
@@ -10,13 +10,13 @@ error: called `.nth(0)` on a `std::iter::Iterator`, when `.next()` is equivalent
   --> $DIR/iter_nth_zero.rs:25:14
    |
 LL |     let _y = iter.nth(0);
-   |              ^^^^^^^^^^^ help: try calling .next() instead of .nth(0): `iter.next()`
+   |              ^^^^^^^^^^^ help: try calling `.next()` instead of `.nth(0)`: `iter.next()`
 
 error: called `.nth(0)` on a `std::iter::Iterator`, when `.next()` is equivalent
   --> $DIR/iter_nth_zero.rs:30:22
    |
 LL |     let _unwrapped = iter2.nth(0).unwrap();
-   |                      ^^^^^^^^^^^^ help: try calling .next() instead of .nth(0): `iter2.next()`
+   |                      ^^^^^^^^^^^^ help: try calling `.next()` instead of `.nth(0)`: `iter2.next()`
 
 error: aborting due to 3 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From a0640457a912720a5473d7feff40576a2f97df1e Mon Sep 17 00:00:00 2001
From: Leo Meira Vital <leo.vital@nubank.com.br>
Date: Mon, 13 Jul 2020 01:57:19 -0300
Subject: Removing snippet from SHADOW_UNRELATED message.

---
 clippy_lints/src/shadow.rs | 6 +-----
 tests/ui/shadow.stderr     | 2 +-
 2 files changed, 2 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/shadow.rs b/clippy_lints/src/shadow.rs
index 194786c5c41..fab13c8c124 100644
--- a/clippy_lints/src/shadow.rs
+++ b/clippy_lints/src/shadow.rs
@@ -295,11 +295,7 @@ fn lint_shadow<'tcx>(
                 cx,
                 SHADOW_UNRELATED,
                 pattern_span,
-                &format!(
-                    "`{}` is shadowed by `{}`",
-                    snippet(cx, pattern_span, "_"),
-                    snippet(cx, expr.span, "..")
-                ),
+                &format!("`{}` is being shadowed", snippet(cx, pattern_span, "_")),
                 |diag| {
                     diag.span_note(expr.span, "initialization happens here");
                     diag.span_note(prev_span, "previous binding is here");
diff --git a/tests/ui/shadow.stderr b/tests/ui/shadow.stderr
index 7fa58cf7649..8a831375b41 100644
--- a/tests/ui/shadow.stderr
+++ b/tests/ui/shadow.stderr
@@ -104,7 +104,7 @@ note: previous binding is here
 LL |     let x = (1, x);
    |         ^
 
-error: `x` is shadowed by `y`
+error: `x` is being shadowed
   --> $DIR/shadow.rs:34:9
    |
 LL |     let x = y;
-- 
cgit 1.4.1-3-g733a5


From 70a41a92815a79c88dd9a2e8aa02503a3b95eae8 Mon Sep 17 00:00:00 2001
From: JarredAllen <jarredallen73@gmail.com>
Date: Thu, 16 Jul 2020 16:51:12 -0700
Subject: Enable detecting multiple-argument panics

---
 clippy_lints/src/panic_unimplemented.rs |  9 ++---
 tests/ui/panicking_macros.rs            |  8 +++++
 tests/ui/panicking_macros.stderr        | 62 ++++++++++++++++++++++++++++++---
 3 files changed, 69 insertions(+), 10 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/panic_unimplemented.rs b/clippy_lints/src/panic_unimplemented.rs
index 10f4694640e..9944b4096ba 100644
--- a/clippy_lints/src/panic_unimplemented.rs
+++ b/clippy_lints/src/panic_unimplemented.rs
@@ -96,23 +96,20 @@ impl<'tcx> LateLintPass<'tcx> for PanicUnimplemented {
         if_chain! {
             if let ExprKind::Block(ref block, _) = expr.kind;
             if let Some(ref ex) = block.expr;
-            if let Some(params) = match_function_call(cx, ex, &paths::BEGIN_PANIC);
-            if params.len() == 1;
+            if let Some(params) = match_function_call(cx, ex, &paths::BEGIN_PANIC)
+                .or(match_function_call(cx, ex, &paths::BEGIN_PANIC_FMT));
             then {
+                let span = get_outer_span(expr);
                 if is_expn_of(expr.span, "unimplemented").is_some() {
-                    let span = get_outer_span(expr);
                     span_lint(cx, UNIMPLEMENTED, span,
                               "`unimplemented` should not be present in production code");
                 } else if is_expn_of(expr.span, "todo").is_some() {
-                    let span = get_outer_span(expr);
                     span_lint(cx, TODO, span,
                               "`todo` should not be present in production code");
                 } else if is_expn_of(expr.span, "unreachable").is_some() {
-                    let span = get_outer_span(expr);
                     span_lint(cx, UNREACHABLE, span,
                               "`unreachable` should not be present in production code");
                 } else if is_expn_of(expr.span, "panic").is_some() {
-                    let span = get_outer_span(expr);
                     span_lint(cx, PANIC, span,
                               "`panic` should not be present in production code");
                     match_panic(params, expr, cx);
diff --git a/tests/ui/panicking_macros.rs b/tests/ui/panicking_macros.rs
index dabb695368d..f91ccfaed74 100644
--- a/tests/ui/panicking_macros.rs
+++ b/tests/ui/panicking_macros.rs
@@ -4,24 +4,32 @@
 fn panic() {
     let a = 2;
     panic!();
+    panic!("message");
+    panic!("{} {}", "panic with", "multiple arguments");
     let b = a + 2;
 }
 
 fn todo() {
     let a = 2;
     todo!();
+    todo!("message");
+    todo!("{} {}", "panic with", "multiple arguments");
     let b = a + 2;
 }
 
 fn unimplemented() {
     let a = 2;
     unimplemented!();
+    unimplemented!("message");
+    unimplemented!("{} {}", "panic with", "multiple arguments");
     let b = a + 2;
 }
 
 fn unreachable() {
     let a = 2;
     unreachable!();
+    unreachable!("message");
+    unreachable!("{} {}", "panic with", "multiple arguments");
     let b = a + 2;
 }
 
diff --git a/tests/ui/panicking_macros.stderr b/tests/ui/panicking_macros.stderr
index 72319bc7e45..37c11d72a57 100644
--- a/tests/ui/panicking_macros.stderr
+++ b/tests/ui/panicking_macros.stderr
@@ -6,29 +6,83 @@ LL |     panic!();
    |
    = note: `-D clippy::panic` implied by `-D warnings`
 
+error: `panic` should not be present in production code
+  --> $DIR/panicking_macros.rs:7:5
+   |
+LL |     panic!("message");
+   |     ^^^^^^^^^^^^^^^^^^
+   |
+   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: `panic` should not be present in production code
+  --> $DIR/panicking_macros.rs:8:5
+   |
+LL |     panic!("{} {}", "panic with", "multiple arguments");
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+
 error: `todo` should not be present in production code
-  --> $DIR/panicking_macros.rs:12:5
+  --> $DIR/panicking_macros.rs:14:5
    |
 LL |     todo!();
    |     ^^^^^^^^
    |
    = note: `-D clippy::todo` implied by `-D warnings`
 
+error: `todo` should not be present in production code
+  --> $DIR/panicking_macros.rs:15:5
+   |
+LL |     todo!("message");
+   |     ^^^^^^^^^^^^^^^^^
+
+error: `todo` should not be present in production code
+  --> $DIR/panicking_macros.rs:16:5
+   |
+LL |     todo!("{} {}", "panic with", "multiple arguments");
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
 error: `unimplemented` should not be present in production code
-  --> $DIR/panicking_macros.rs:18:5
+  --> $DIR/panicking_macros.rs:22:5
    |
 LL |     unimplemented!();
    |     ^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::unimplemented` implied by `-D warnings`
 
-error: `unreachable` should not be present in production code
+error: `unimplemented` should not be present in production code
+  --> $DIR/panicking_macros.rs:23:5
+   |
+LL |     unimplemented!("message");
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: `unimplemented` should not be present in production code
   --> $DIR/panicking_macros.rs:24:5
    |
+LL |     unimplemented!("{} {}", "panic with", "multiple arguments");
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: `unreachable` should not be present in production code
+  --> $DIR/panicking_macros.rs:30:5
+   |
 LL |     unreachable!();
    |     ^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::unreachable` implied by `-D warnings`
 
-error: aborting due to 4 previous errors
+error: `unreachable` should not be present in production code
+  --> $DIR/panicking_macros.rs:31:5
+   |
+LL |     unreachable!("message");
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: `unreachable` should not be present in production code
+  --> $DIR/panicking_macros.rs:32:5
+   |
+LL |     unreachable!("{} {}", "panic with", "multiple arguments");
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 12 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 07867fde592babd74ee9934726c4c7010dee149b Mon Sep 17 00:00:00 2001
From: JarredAllen <jarredallen73@gmail.com>
Date: Thu, 16 Jul 2020 16:58:21 -0700
Subject: Clean up dogfood fallout

---
 clippy_lints/src/panic_unimplemented.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/panic_unimplemented.rs b/clippy_lints/src/panic_unimplemented.rs
index 9944b4096ba..6379dffd22e 100644
--- a/clippy_lints/src/panic_unimplemented.rs
+++ b/clippy_lints/src/panic_unimplemented.rs
@@ -97,7 +97,7 @@ impl<'tcx> LateLintPass<'tcx> for PanicUnimplemented {
             if let ExprKind::Block(ref block, _) = expr.kind;
             if let Some(ref ex) = block.expr;
             if let Some(params) = match_function_call(cx, ex, &paths::BEGIN_PANIC)
-                .or(match_function_call(cx, ex, &paths::BEGIN_PANIC_FMT));
+                .or_else(|| match_function_call(cx, ex, &paths::BEGIN_PANIC_FMT));
             then {
                 let span = get_outer_span(expr);
                 if is_expn_of(expr.span, "unimplemented").is_some() {
-- 
cgit 1.4.1-3-g733a5


From 3618b97f59d9696c3e5ef83948269d0d7abfdc5b Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Fri, 17 Jul 2020 01:58:41 +0200
Subject: fix typos (found by codespell)

---
 clippy_lints/src/deprecated_lints.rs      | 2 +-
 clippy_lints/src/dereference.rs           | 2 +-
 clippy_lints/src/inherent_impl.rs         | 2 +-
 clippy_lints/src/lib.rs                   | 2 +-
 clippy_lints/src/missing_const_for_fn.rs  | 2 +-
 clippy_lints/src/modulo_arithmetic.rs     | 2 +-
 clippy_lints/src/option_if_let_else.rs    | 2 +-
 clippy_lints/src/utils/numeric_literal.rs | 2 +-
 tests/ui/manual_async_fn.fixed            | 2 +-
 tests/ui/manual_async_fn.rs               | 2 +-
 tests/ui/manual_async_fn.stderr           | 2 +-
 tests/ui/never_loop.rs                    | 2 +-
 tests/ui/precedence.fixed                 | 2 +-
 tests/ui/precedence.rs                    | 2 +-
 tests/ui/vec_resize_to_zero.rs            | 2 +-
 15 files changed, 15 insertions(+), 15 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/deprecated_lints.rs b/clippy_lints/src/deprecated_lints.rs
index 818d8188a78..c17a0e83330 100644
--- a/clippy_lints/src/deprecated_lints.rs
+++ b/clippy_lints/src/deprecated_lints.rs
@@ -153,7 +153,7 @@ declare_deprecated_lint! {
     ///
     /// **Deprecation reason:** Associated-constants are now preferred.
     pub REPLACE_CONSTS,
-    "associated-constants `MIN`/`MAX` of integers are prefered to `{min,max}_value()` and module constants"
+    "associated-constants `MIN`/`MAX` of integers are preferred to `{min,max}_value()` and module constants"
 }
 
 declare_deprecated_lint! {
diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index 323cad7fa1a..7a3f35aca0a 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -10,7 +10,7 @@ use rustc_span::source_map::Span;
 declare_clippy_lint! {
     /// **What it does:** Checks for explicit `deref()` or `deref_mut()` method calls.
     ///
-    /// **Why is this bad?** Derefencing by `&*x` or `&mut *x` is clearer and more concise,
+    /// **Why is this bad?** Dereferencing by `&*x` or `&mut *x` is clearer and more concise,
     /// when not part of a method chain.
     ///
     /// **Example:**
diff --git a/clippy_lints/src/inherent_impl.rs b/clippy_lints/src/inherent_impl.rs
index bd7ca038839..9fb10c7f627 100644
--- a/clippy_lints/src/inherent_impl.rs
+++ b/clippy_lints/src/inherent_impl.rs
@@ -55,7 +55,7 @@ impl<'tcx> LateLintPass<'tcx> for MultipleInherentImpl {
             ..
         } = item.kind
         {
-            // Remember for each inherent implementation encoutered its span and generics
+            // Remember for each inherent implementation encountered its span and generics
             // but filter out implementations that have generic params (type or lifetime)
             // or are derived from a macro
             if !in_macro(item.span) && generics.params.is_empty() {
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 7a4ca3902b3..823afdfd289 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -463,7 +463,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     );
     store.register_removed(
         "clippy::replace_consts",
-        "associated-constants `MIN`/`MAX` of integers are prefered to `{min,max}_value()` and module constants",
+        "associated-constants `MIN`/`MAX` of integers are preferred to `{min,max}_value()` and module constants",
     );
     store.register_removed(
         "clippy::regex_macro",
diff --git a/clippy_lints/src/missing_const_for_fn.rs b/clippy_lints/src/missing_const_for_fn.rs
index bdce1bf1521..1ad184dfc46 100644
--- a/clippy_lints/src/missing_const_for_fn.rs
+++ b/clippy_lints/src/missing_const_for_fn.rs
@@ -131,7 +131,7 @@ impl<'tcx> LateLintPass<'tcx> for MissingConstForFn {
 /// Returns true if any of the method parameters is a type that implements `Drop`. The method
 /// can't be made const then, because `drop` can't be const-evaluated.
 fn method_accepts_dropable(cx: &LateContext<'_>, param_tys: &[hir::Ty<'_>]) -> bool {
-    // If any of the params are dropable, return true
+    // If any of the params are droppable, return true
     param_tys.iter().any(|hir_ty| {
         let ty_ty = hir_ty_to_ty(cx.tcx, hir_ty);
         has_drop(cx, ty_ty)
diff --git a/clippy_lints/src/modulo_arithmetic.rs b/clippy_lints/src/modulo_arithmetic.rs
index 59ccc6333fd..5041af750ce 100644
--- a/clippy_lints/src/modulo_arithmetic.rs
+++ b/clippy_lints/src/modulo_arithmetic.rs
@@ -8,7 +8,7 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use std::fmt::Display;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for modulo arithemtic.
+    /// **What it does:** Checks for modulo arithmetic.
     ///
     /// **Why is this bad?** The results of modulo (%) operation might differ
     /// depending on the language, when negative numbers are involved.
diff --git a/clippy_lints/src/option_if_let_else.rs b/clippy_lints/src/option_if_let_else.rs
index 8dbe58763bf..9922d906118 100644
--- a/clippy_lints/src/option_if_let_else.rs
+++ b/clippy_lints/src/option_if_let_else.rs
@@ -78,7 +78,7 @@ fn is_result_ok(cx: &LateContext<'_>, expr: &'_ Expr<'_>) -> bool {
     }
 }
 
-/// A struct containing information about occurences of the
+/// A struct containing information about occurrences of the
 /// `if let Some(..) = .. else` construct that this lint detects.
 struct OptionIfLetElseOccurence {
     option: String,
diff --git a/clippy_lints/src/utils/numeric_literal.rs b/clippy_lints/src/utils/numeric_literal.rs
index 87cb454f654..5e8800d38eb 100644
--- a/clippy_lints/src/utils/numeric_literal.rs
+++ b/clippy_lints/src/utils/numeric_literal.rs
@@ -36,7 +36,7 @@ pub struct NumericLiteral<'a> {
     pub integer: &'a str,
     /// The fraction part of the number.
     pub fraction: Option<&'a str>,
-    /// The character used as exponent seperator (b'e' or b'E') and the exponent part.
+    /// The character used as exponent separator (b'e' or b'E') and the exponent part.
     pub exponent: Option<(char, &'a str)>,
 
     /// The type suffix, including preceding underscore if present.
diff --git a/tests/ui/manual_async_fn.fixed b/tests/ui/manual_async_fn.fixed
index 6bb1032a172..27222cc0869 100644
--- a/tests/ui/manual_async_fn.fixed
+++ b/tests/ui/manual_async_fn.fixed
@@ -30,7 +30,7 @@ async fn already_async() -> impl Future<Output = i32> {
 struct S {}
 impl S {
     async fn inh_fut() -> i32 {
-        // NOTE: this code is here just to check that the identation is correct in the suggested fix
+        // NOTE: this code is here just to check that the indentation is correct in the suggested fix
         let a = 42;
         let b = 21;
         if a < b {
diff --git a/tests/ui/manual_async_fn.rs b/tests/ui/manual_async_fn.rs
index d50c919188b..6a0f1b26c88 100644
--- a/tests/ui/manual_async_fn.rs
+++ b/tests/ui/manual_async_fn.rs
@@ -37,7 +37,7 @@ struct S {}
 impl S {
     fn inh_fut() -> impl Future<Output = i32> {
         async {
-            // NOTE: this code is here just to check that the identation is correct in the suggested fix
+            // NOTE: this code is here just to check that the indentation is correct in the suggested fix
             let a = 42;
             let b = 21;
             if a < b {
diff --git a/tests/ui/manual_async_fn.stderr b/tests/ui/manual_async_fn.stderr
index f278ee41aa3..a1904c904d0 100644
--- a/tests/ui/manual_async_fn.stderr
+++ b/tests/ui/manual_async_fn.stderr
@@ -57,7 +57,7 @@ LL |     async fn inh_fut() -> i32 {
 help: move the body of the async block to the enclosing function
    |
 LL |     fn inh_fut() -> impl Future<Output = i32> {
-LL |         // NOTE: this code is here just to check that the identation is correct in the suggested fix
+LL |         // NOTE: this code is here just to check that the indentation is correct in the suggested fix
 LL |         let a = 42;
 LL |         let b = 21;
 LL |         if a < b {
diff --git a/tests/ui/never_loop.rs b/tests/ui/never_loop.rs
index cbc4ca39161..2770eb2b2ab 100644
--- a/tests/ui/never_loop.rs
+++ b/tests/ui/never_loop.rs
@@ -166,7 +166,7 @@ pub fn test14() {
     }
 }
 
-// Issue #1991: the outter loop should not warn.
+// Issue #1991: the outer loop should not warn.
 pub fn test15() {
     'label: loop {
         while false {
diff --git a/tests/ui/precedence.fixed b/tests/ui/precedence.fixed
index 17b1f1bd0bf..4d284ae1319 100644
--- a/tests/ui/precedence.fixed
+++ b/tests/ui/precedence.fixed
@@ -32,7 +32,7 @@ fn main() {
     let _ = -(1i32.abs());
     let _ = -(1f32.abs());
 
-    // Odd functions shoud not trigger an error
+    // Odd functions should not trigger an error
     let _ = -1f64.asin();
     let _ = -1f64.asinh();
     let _ = -1f64.atan();
diff --git a/tests/ui/precedence.rs b/tests/ui/precedence.rs
index 2d0891fd3c2..2d08e82f349 100644
--- a/tests/ui/precedence.rs
+++ b/tests/ui/precedence.rs
@@ -32,7 +32,7 @@ fn main() {
     let _ = -(1i32.abs());
     let _ = -(1f32.abs());
 
-    // Odd functions shoud not trigger an error
+    // Odd functions should not trigger an error
     let _ = -1f64.asin();
     let _ = -1f64.asinh();
     let _ = -1f64.atan();
diff --git a/tests/ui/vec_resize_to_zero.rs b/tests/ui/vec_resize_to_zero.rs
index 0263e2f5f20..7ed27439ec6 100644
--- a/tests/ui/vec_resize_to_zero.rs
+++ b/tests/ui/vec_resize_to_zero.rs
@@ -7,7 +7,7 @@ fn main() {
     // not applicable
     vec![1, 2, 3, 4, 5].resize(2, 5);
 
-    // applicable here, but only implemented for integer litterals for now
+    // applicable here, but only implemented for integer literals for now
     vec!["foo", "bar", "baz"].resize(0, "bar");
 
     // not applicable
-- 
cgit 1.4.1-3-g733a5


From e5105e82d31b254a81f38fbf38a8043ba41bee3a Mon Sep 17 00:00:00 2001
From: Takayuki Nakata <f.seasons017@gmail.com>
Date: Fri, 17 Jul 2020 22:51:57 +0900
Subject: Fix typo

---
 clippy_lints/src/vec_resize_to_zero.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/vec_resize_to_zero.rs b/clippy_lints/src/vec_resize_to_zero.rs
index cc5e21a7ca6..7f90aedf161 100644
--- a/clippy_lints/src/vec_resize_to_zero.rs
+++ b/clippy_lints/src/vec_resize_to_zero.rs
@@ -11,7 +11,7 @@ use rustc_ast::ast::LitKind;
 use rustc_hir as hir;
 
 declare_clippy_lint! {
-    /// **What it does:** Finds occurences of `Vec::resize(0, an_int)`
+    /// **What it does:** Finds occurrences of `Vec::resize(0, an_int)`
     ///
     /// **Why is this bad?** This is probably an argument inversion mistake.
     ///
-- 
cgit 1.4.1-3-g733a5


From e85b590936863e88da4ccd73af9f5da0787b9609 Mon Sep 17 00:00:00 2001
From: JarredAllen <jarredallen73@gmail.com>
Date: Fri, 17 Jul 2020 10:40:01 -0700
Subject: Fix bug in lint

---
 clippy_lints/src/matches.rs | 14 +++++++++++---
 1 file changed, 11 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index bd474c20807..fe00a48adef 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -1512,6 +1512,10 @@ mod redundant_pattern_match {
             }
         }
 
+        let result_expr = match &op.kind {
+            ExprKind::AddrOf(_, _, borrowed) => borrowed,
+            _ => op,
+        };
         span_lint_and_then(
             cx,
             REDUNDANT_PATTERN_MATCHING,
@@ -1524,7 +1528,7 @@ mod redundant_pattern_match {
 
                 // while let ... = ... { ... }
                 //                 ^^^
-                let op_span = op.span.source_callsite();
+                let op_span = result_expr.span.source_callsite();
 
                 // while let ... = ... { ... }
                 // ^^^^^^^^^^^^^^^^^^^
@@ -1589,17 +1593,21 @@ mod redundant_pattern_match {
             };
 
             if let Some(good_method) = found_good_method {
+                let span = expr.span.to(op.span);
+                let result_expr = match &op.kind {
+                    ExprKind::AddrOf(_, _, borrowed) => borrowed,
+                    _ => op,
+                };
                 span_lint_and_then(
                     cx,
                     REDUNDANT_PATTERN_MATCHING,
                     expr.span,
                     &format!("redundant pattern matching, consider using `{}`", good_method),
                     |diag| {
-                        let span = expr.span.to(op.span);
                         diag.span_suggestion(
                             span,
                             "try this",
-                            format!("{}.{}", snippet(cx, op.span, "_"), good_method),
+                            format!("{}.{}", snippet(cx, result_expr.span, "_"), good_method),
                             Applicability::MaybeIncorrect, // snippet
                         );
                     },
-- 
cgit 1.4.1-3-g733a5


From 3d3a13d8719893972e2146cde86672151e7d5476 Mon Sep 17 00:00:00 2001
From: flip1995 <hello@philkrones.com>
Date: Fri, 17 Jul 2020 21:39:05 +0200
Subject: Fix sync fallout (fmt)

---
 clippy_lints/src/non_expressive_names.rs | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/non_expressive_names.rs b/clippy_lints/src/non_expressive_names.rs
index 1d4772bb3d6..48ab98418e4 100644
--- a/clippy_lints/src/non_expressive_names.rs
+++ b/clippy_lints/src/non_expressive_names.rs
@@ -218,12 +218,16 @@ impl<'a, 'tcx, 'b> SimilarNamesNameVisitor<'a, 'tcx, 'b> {
             let mut split_at = None;
             match existing_name.len.cmp(&count) {
                 Ordering::Greater => {
-                    if existing_name.len - count != 1 || levenstein_not_1(&interned_name, &existing_name.interned.as_str()) {
+                    if existing_name.len - count != 1
+                        || levenstein_not_1(&interned_name, &existing_name.interned.as_str())
+                    {
                         continue;
                     }
                 },
                 Ordering::Less => {
-                    if count - existing_name.len != 1 || levenstein_not_1(&existing_name.interned.as_str(), &interned_name) {
+                    if count - existing_name.len != 1
+                        || levenstein_not_1(&existing_name.interned.as_str(), &interned_name)
+                    {
                         continue;
                     }
                 },
-- 
cgit 1.4.1-3-g733a5


From 442c8ae23b90874485468b3becfc011f8c9d40bb Mon Sep 17 00:00:00 2001
From: ThibsG <Thibs@debian.com>
Date: Sat, 18 Jul 2020 23:59:34 +0200
Subject: Fix FP for `suspicious_arithmetic_impl` from `suspicious_trait_impl`
 lint

---
 clippy_lints/src/suspicious_trait_impl.rs | 37 ++++++++++++++-----------------
 tests/ui/suspicious_arithmetic_impl.rs    | 30 +++++++++++++++++++++++++
 2 files changed, 47 insertions(+), 20 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/suspicious_trait_impl.rs b/clippy_lints/src/suspicious_trait_impl.rs
index 6d1d083fa8d..502fffc5e6c 100644
--- a/clippy_lints/src/suspicious_trait_impl.rs
+++ b/clippy_lints/src/suspicious_trait_impl.rs
@@ -64,26 +64,22 @@ impl<'tcx> LateLintPass<'tcx> for SuspiciousImpl {
                 | hir::BinOpKind::Gt => return,
                 _ => {},
             }
-            // Check if the binary expression is part of another bi/unary expression
-            // or operator assignment as a child node
-            let mut parent_expr = cx.tcx.hir().get_parent_node(expr.hir_id);
-            while parent_expr != hir::CRATE_HIR_ID {
-                if let hir::Node::Expr(e) = cx.tcx.hir().get(parent_expr) {
-                    match e.kind {
-                        hir::ExprKind::Binary(..)
-                        | hir::ExprKind::Unary(hir::UnOp::UnNot | hir::UnOp::UnNeg, _)
-                        | hir::ExprKind::AssignOp(..) => return,
-                        _ => {},
+
+            // Check for more than one binary operation in the implemented function
+            // Linting when multiple operations are involved can result in false positives
+            if_chain! {
+                let parent_fn = cx.tcx.hir().get_parent_item(expr.hir_id);
+                if let hir::Node::ImplItem(impl_item) = cx.tcx.hir().get(parent_fn);
+                if let hir::ImplItemKind::Fn(_, body_id) = impl_item.kind;
+                let body = cx.tcx.hir().body(body_id);
+                let mut visitor = BinaryExprVisitor { nb_binops: 0 };
+
+                then {
+                    walk_expr(&mut visitor, &body.value);
+                    if visitor.nb_binops > 1 {
+                        return;
                     }
                 }
-                parent_expr = cx.tcx.hir().get_parent_node(parent_expr);
-            }
-            // as a parent node
-            let mut visitor = BinaryExprVisitor { in_binary_expr: false };
-            walk_expr(&mut visitor, expr);
-
-            if visitor.in_binary_expr {
-                return;
             }
 
             if let Some(impl_trait) = check_binop(
@@ -181,7 +177,7 @@ fn check_binop(
 }
 
 struct BinaryExprVisitor {
-    in_binary_expr: bool,
+    nb_binops: u32,
 }
 
 impl<'tcx> Visitor<'tcx> for BinaryExprVisitor {
@@ -191,12 +187,13 @@ impl<'tcx> Visitor<'tcx> for BinaryExprVisitor {
         match expr.kind {
             hir::ExprKind::Binary(..)
             | hir::ExprKind::Unary(hir::UnOp::UnNot | hir::UnOp::UnNeg, _)
-            | hir::ExprKind::AssignOp(..) => self.in_binary_expr = true,
+            | hir::ExprKind::AssignOp(..) => self.nb_binops += 1,
             _ => {},
         }
 
         walk_expr(self, expr);
     }
+
     fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
         NestedVisitorMap::None
     }
diff --git a/tests/ui/suspicious_arithmetic_impl.rs b/tests/ui/suspicious_arithmetic_impl.rs
index 1f5b9811887..60c2f3ec9b6 100644
--- a/tests/ui/suspicious_arithmetic_impl.rs
+++ b/tests/ui/suspicious_arithmetic_impl.rs
@@ -88,3 +88,33 @@ fn main() {}
 fn do_nothing(x: u32) -> u32 {
     x
 }
+
+struct MultipleBinops(u32);
+
+impl Add for MultipleBinops {
+    type Output = MultipleBinops;
+
+    // OK: multiple Binops in `add` impl
+    fn add(self, other: Self) -> Self::Output {
+        let mut result = self.0 + other.0;
+        if result >= u32::max_value() {
+            result -= u32::max_value();
+        }
+        MultipleBinops(result)
+    }
+}
+
+impl Mul for MultipleBinops {
+    type Output = MultipleBinops;
+
+    // OK: multiple Binops in `mul` impl
+    fn mul(self, other: Self) -> Self::Output {
+        let mut result: u32 = 0;
+        let size = std::cmp::max(self.0, other.0) as usize;
+        let mut v = vec![0; size + 1];
+        for i in 0..size + 1 {
+            result *= i as u32;
+        }
+        MultipleBinops(result)
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From c720d823e1e633cccfd24e1df76cc04a628e83b0 Mon Sep 17 00:00:00 2001
From: Tim Nielens <tim.nielens@gmail.com>
Date: Tue, 14 Jul 2020 20:27:25 +0200
Subject: redundant_closure_call - don't lint when used more than once

---
 clippy_lints/src/misc_early.rs         | 40 +++++++++++++++++++++++++++-------
 tests/ui/redundant_closure_call.rs     | 15 +++++++++----
 tests/ui/redundant_closure_call.stderr | 14 ++++--------
 3 files changed, 47 insertions(+), 22 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/misc_early.rs b/clippy_lints/src/misc_early.rs
index b84a1a3fe24..125df226ceb 100644
--- a/clippy_lints/src/misc_early.rs
+++ b/clippy_lints/src/misc_early.rs
@@ -14,6 +14,7 @@ use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
+use rustc_span::symbol::Ident;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for structure field patterns bound to wildcards.
@@ -493,6 +494,29 @@ impl EarlyLintPass for MiscEarlyLints {
     }
 
     fn check_block(&mut self, cx: &EarlyContext<'_>, block: &Block) {
+        fn count_closure_usage(block: &Block, ident: &Ident) -> usize {
+            struct ClosureUsageCount<'ast> {
+                ident: &'ast Ident,
+                count: usize,
+            };
+            impl<'ast> Visitor<'ast> for ClosureUsageCount<'ast> {
+                fn visit_expr(&mut self, expr: &'ast Expr) {
+                    if_chain! {
+                        if let ExprKind::Call(ref closure, _) = expr.kind;
+                        if let ExprKind::Path(_, ref path) = closure.kind;
+                        if self.ident == &path.segments[0].ident;
+                        then {
+                            self.count += 1;
+                        }
+                    }
+                    walk_expr(self, expr);
+                }
+            }
+            let mut closure_usage_count = ClosureUsageCount { ident, count: 0 };
+            closure_usage_count.visit_block(block);
+            closure_usage_count.count
+        }
+
         for w in block.stmts.windows(2) {
             if_chain! {
                 if let StmtKind::Local(ref local) = w[0].kind;
@@ -503,15 +527,15 @@ impl EarlyLintPass for MiscEarlyLints {
                 if let ExprKind::Assign(_, ref call, _) = second.kind;
                 if let ExprKind::Call(ref closure, _) = call.kind;
                 if let ExprKind::Path(_, ref path) = closure.kind;
+                if ident == path.segments[0].ident;
+                if  count_closure_usage(block, &ident) == 1;
                 then {
-                    if ident == path.segments[0].ident {
-                        span_lint(
-                            cx,
-                            REDUNDANT_CLOSURE_CALL,
-                            second.span,
-                            "Closure called just once immediately after it was declared",
-                        );
-                    }
+                    span_lint(
+                        cx,
+                        REDUNDANT_CLOSURE_CALL,
+                        second.span,
+                        "Closure called just once immediately after it was declared",
+                    );
                 }
             }
         }
diff --git a/tests/ui/redundant_closure_call.rs b/tests/ui/redundant_closure_call.rs
index bacd67db7c3..0f2ba4a075d 100644
--- a/tests/ui/redundant_closure_call.rs
+++ b/tests/ui/redundant_closure_call.rs
@@ -8,14 +8,21 @@ fn main() {
 
     k = (|a, b| a * b)(1, 5);
 
-    let closure = || 32;
-    i = closure();
-
+    // don't lint here, the closure is used more than once
     let closure = |i| i + 1;
     i = closure(3);
-
     i = closure(4);
 
+    // lint here
+    let redun_closure = || 1;
+    i = redun_closure();
+
+    // the lint is applicable here but the lint doesn't support redefinition
+    let redefined_closure = || 1;
+    i = redefined_closure();
+    let redefined_closure = || 2;
+    i = redefined_closure();
+
     #[allow(clippy::needless_return)]
     (|| return 2)();
     (|| -> Option<i32> { None? })();
diff --git a/tests/ui/redundant_closure_call.stderr b/tests/ui/redundant_closure_call.stderr
index 68c1416bb6b..d5e0664319b 100644
--- a/tests/ui/redundant_closure_call.stderr
+++ b/tests/ui/redundant_closure_call.stderr
@@ -1,17 +1,11 @@
 error: Closure called just once immediately after it was declared
-  --> $DIR/redundant_closure_call.rs:12:5
+  --> $DIR/redundant_closure_call.rs:18:5
    |
-LL |     i = closure();
-   |     ^^^^^^^^^^^^^
+LL |     i = redun_closure();
+   |     ^^^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::redundant-closure-call` implied by `-D warnings`
 
-error: Closure called just once immediately after it was declared
-  --> $DIR/redundant_closure_call.rs:15:5
-   |
-LL |     i = closure(3);
-   |     ^^^^^^^^^^^^^^
-
 error: Try not to call a closure in the expression where it is declared.
   --> $DIR/redundant_closure_call.rs:7:17
    |
@@ -24,5 +18,5 @@ error: Try not to call a closure in the expression where it is declared.
 LL |     k = (|a, b| a * b)(1, 5);
    |         ^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 4 previous errors
+error: aborting due to 3 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 0fecaf1abcbe8d4ba1a9c532b69aab6fab3097c8 Mon Sep 17 00:00:00 2001
From: Tim Nielens <tim.nielens@gmail.com>
Date: Sun, 19 Jul 2020 00:33:54 +0200
Subject: redundant_closure_call - extract lint from misc_early.rs, adapt to
 LatePass

---
 clippy_lints/src/lib.rs                      |   9 +-
 clippy_lints/src/misc_early.rs               | 132 +----------------------
 clippy_lints/src/redundant_closure_call.rs   | 151 +++++++++++++++++++++++++++
 src/lintlist/mod.rs                          |   2 +-
 tests/ui/redundant_closure_call.rs           |  30 ------
 tests/ui/redundant_closure_call.stderr       |  22 ----
 tests/ui/redundant_closure_call_early.rs     |  19 ++++
 tests/ui/redundant_closure_call_early.stderr |  16 +++
 tests/ui/redundant_closure_call_late.rs      |  22 ++++
 tests/ui/redundant_closure_call_late.stderr  |  10 ++
 10 files changed, 229 insertions(+), 184 deletions(-)
 create mode 100644 clippy_lints/src/redundant_closure_call.rs
 delete mode 100644 tests/ui/redundant_closure_call.rs
 delete mode 100644 tests/ui/redundant_closure_call.stderr
 create mode 100644 tests/ui/redundant_closure_call_early.rs
 create mode 100644 tests/ui/redundant_closure_call_early.stderr
 create mode 100644 tests/ui/redundant_closure_call_late.rs
 create mode 100644 tests/ui/redundant_closure_call_late.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 823afdfd289..f371942dbee 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -276,6 +276,7 @@ mod ptr_offset_with_cast;
 mod question_mark;
 mod ranges;
 mod redundant_clone;
+mod redundant_closure_call;
 mod redundant_field_names;
 mod redundant_pub_crate;
 mod redundant_static_lifetimes;
@@ -702,7 +703,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &misc_early::DOUBLE_NEG,
         &misc_early::DUPLICATE_UNDERSCORE_ARGUMENT,
         &misc_early::MIXED_CASE_HEX_LITERALS,
-        &misc_early::REDUNDANT_CLOSURE_CALL,
         &misc_early::REDUNDANT_PATTERN,
         &misc_early::UNNEEDED_FIELD_PATTERN,
         &misc_early::UNNEEDED_WILDCARD_PATTERN,
@@ -759,6 +759,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &ranges::RANGE_ZIP_WITH_LEN,
         &ranges::REVERSED_EMPTY_RANGES,
         &redundant_clone::REDUNDANT_CLONE,
+        &redundant_closure_call::REDUNDANT_CLOSURE_CALL,
         &redundant_field_names::REDUNDANT_FIELD_NAMES,
         &redundant_pub_crate::REDUNDANT_PUB_CRATE,
         &redundant_static_lifetimes::REDUNDANT_STATIC_LIFETIMES,
@@ -1018,6 +1019,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_early_pass(|| box int_plus_one::IntPlusOne);
     store.register_early_pass(|| box formatting::Formatting);
     store.register_early_pass(|| box misc_early::MiscEarlyLints);
+    store.register_early_pass(|| box redundant_closure_call::RedundantClosureCall);
+    store.register_late_pass(|| box redundant_closure_call::RedundantClosureCall);
     store.register_early_pass(|| box returns::Return);
     store.register_late_pass(|| box let_and_return::LetReturn);
     store.register_early_pass(|| box collapsible_if::CollapsibleIf);
@@ -1359,7 +1362,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&misc_early::DOUBLE_NEG),
         LintId::of(&misc_early::DUPLICATE_UNDERSCORE_ARGUMENT),
         LintId::of(&misc_early::MIXED_CASE_HEX_LITERALS),
-        LintId::of(&misc_early::REDUNDANT_CLOSURE_CALL),
         LintId::of(&misc_early::REDUNDANT_PATTERN),
         LintId::of(&misc_early::UNNEEDED_WILDCARD_PATTERN),
         LintId::of(&misc_early::ZERO_PREFIXED_LITERAL),
@@ -1393,6 +1395,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&ranges::RANGE_ZIP_WITH_LEN),
         LintId::of(&ranges::REVERSED_EMPTY_RANGES),
         LintId::of(&redundant_clone::REDUNDANT_CLONE),
+        LintId::of(&redundant_closure_call::REDUNDANT_CLOSURE_CALL),
         LintId::of(&redundant_field_names::REDUNDANT_FIELD_NAMES),
         LintId::of(&redundant_static_lifetimes::REDUNDANT_STATIC_LIFETIMES),
         LintId::of(&reference::DEREF_ADDROF),
@@ -1593,7 +1596,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&methods::UNNECESSARY_FILTER_MAP),
         LintId::of(&methods::USELESS_ASREF),
         LintId::of(&misc::SHORT_CIRCUIT_STATEMENT),
-        LintId::of(&misc_early::REDUNDANT_CLOSURE_CALL),
         LintId::of(&misc_early::UNNEEDED_WILDCARD_PATTERN),
         LintId::of(&misc_early::ZERO_PREFIXED_LITERAL),
         LintId::of(&needless_bool::BOOL_COMPARISON),
@@ -1608,6 +1610,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&precedence::PRECEDENCE),
         LintId::of(&ptr_offset_with_cast::PTR_OFFSET_WITH_CAST),
         LintId::of(&ranges::RANGE_ZIP_WITH_LEN),
+        LintId::of(&redundant_closure_call::REDUNDANT_CLOSURE_CALL),
         LintId::of(&reference::DEREF_ADDROF),
         LintId::of(&reference::REF_IN_DEREF),
         LintId::of(&repeat_once::REPEAT_ONCE),
diff --git a/clippy_lints/src/misc_early.rs b/clippy_lints/src/misc_early.rs
index 125df226ceb..29aba7c1218 100644
--- a/clippy_lints/src/misc_early.rs
+++ b/clippy_lints/src/misc_early.rs
@@ -1,20 +1,15 @@
-use crate::utils::{
-    constants, snippet_opt, snippet_with_applicability, span_lint, span_lint_and_help, span_lint_and_sugg,
-    span_lint_and_then,
-};
-use if_chain::if_chain;
+use crate::utils::{constants, snippet_opt, span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then};
 use rustc_ast::ast::{
-    BindingMode, Block, Expr, ExprKind, GenericParamKind, Generics, Lit, LitFloatType, LitIntType, LitKind, Mutability,
-    NodeId, Pat, PatKind, StmtKind, UnOp,
+    BindingMode, Expr, ExprKind, GenericParamKind, Generics, Lit, LitFloatType, LitIntType, LitKind, Mutability,
+    NodeId, Pat, PatKind, UnOp,
 };
-use rustc_ast::visit::{walk_expr, FnKind, Visitor};
+use rustc_ast::visit::FnKind;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
-use rustc_span::symbol::Ident;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for structure field patterns bound to wildcards.
@@ -71,28 +66,6 @@ declare_clippy_lint! {
     "function arguments having names which only differ by an underscore"
 }
 
-declare_clippy_lint! {
-    /// **What it does:** Detects closures called in the same expression where they
-    /// are defined.
-    ///
-    /// **Why is this bad?** It is unnecessarily adding to the expression's
-    /// complexity.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    /// ```rust,ignore
-    /// // Bad
-    /// let a = (|| 42)()
-    ///
-    /// // Good
-    /// let a = 42
-    /// ```
-    pub REDUNDANT_CLOSURE_CALL,
-    complexity,
-    "throwaway closures called in the expression they are defined"
-}
-
 declare_clippy_lint! {
     /// **What it does:** Detects expressions of the form `--x`.
     ///
@@ -279,7 +252,6 @@ declare_clippy_lint! {
 declare_lint_pass!(MiscEarlyLints => [
     UNNEEDED_FIELD_PATTERN,
     DUPLICATE_UNDERSCORE_ARGUMENT,
-    REDUNDANT_CLOSURE_CALL,
     DOUBLE_NEG,
     MIXED_CASE_HEX_LITERALS,
     UNSEPARATED_LITERAL_SUFFIX,
@@ -289,30 +261,6 @@ declare_lint_pass!(MiscEarlyLints => [
     UNNEEDED_WILDCARD_PATTERN,
 ]);
 
-// Used to find `return` statements or equivalents e.g., `?`
-struct ReturnVisitor {
-    found_return: bool,
-}
-
-impl ReturnVisitor {
-    #[must_use]
-    fn new() -> Self {
-        Self { found_return: false }
-    }
-}
-
-impl<'ast> Visitor<'ast> for ReturnVisitor {
-    fn visit_expr(&mut self, ex: &'ast Expr) {
-        if let ExprKind::Ret(_) = ex.kind {
-            self.found_return = true;
-        } else if let ExprKind::Try(_) = ex.kind {
-            self.found_return = true;
-        }
-
-        walk_expr(self, ex)
-    }
-}
-
 impl EarlyLintPass for MiscEarlyLints {
     fn check_generics(&mut self, cx: &EarlyContext<'_>, gen: &Generics) {
         for param in &gen.params {
@@ -454,30 +402,6 @@ impl EarlyLintPass for MiscEarlyLints {
             return;
         }
         match expr.kind {
-            ExprKind::Call(ref paren, _) => {
-                if let ExprKind::Paren(ref closure) = paren.kind {
-                    if let ExprKind::Closure(_, _, _, ref decl, ref block, _) = closure.kind {
-                        let mut visitor = ReturnVisitor::new();
-                        visitor.visit_expr(block);
-                        if !visitor.found_return {
-                            span_lint_and_then(
-                                cx,
-                                REDUNDANT_CLOSURE_CALL,
-                                expr.span,
-                                "Try not to call a closure in the expression where it is declared.",
-                                |diag| {
-                                    if decl.inputs.is_empty() {
-                                        let mut app = Applicability::MachineApplicable;
-                                        let hint =
-                                            snippet_with_applicability(cx, block.span, "..", &mut app).into_owned();
-                                        diag.span_suggestion(expr.span, "Try doing something like: ", hint, app);
-                                    }
-                                },
-                            );
-                        }
-                    }
-                }
-            },
             ExprKind::Unary(UnOp::Neg, ref inner) => {
                 if let ExprKind::Unary(UnOp::Neg, _) = inner.kind {
                     span_lint(
@@ -492,54 +416,6 @@ impl EarlyLintPass for MiscEarlyLints {
             _ => (),
         }
     }
-
-    fn check_block(&mut self, cx: &EarlyContext<'_>, block: &Block) {
-        fn count_closure_usage(block: &Block, ident: &Ident) -> usize {
-            struct ClosureUsageCount<'ast> {
-                ident: &'ast Ident,
-                count: usize,
-            };
-            impl<'ast> Visitor<'ast> for ClosureUsageCount<'ast> {
-                fn visit_expr(&mut self, expr: &'ast Expr) {
-                    if_chain! {
-                        if let ExprKind::Call(ref closure, _) = expr.kind;
-                        if let ExprKind::Path(_, ref path) = closure.kind;
-                        if self.ident == &path.segments[0].ident;
-                        then {
-                            self.count += 1;
-                        }
-                    }
-                    walk_expr(self, expr);
-                }
-            }
-            let mut closure_usage_count = ClosureUsageCount { ident, count: 0 };
-            closure_usage_count.visit_block(block);
-            closure_usage_count.count
-        }
-
-        for w in block.stmts.windows(2) {
-            if_chain! {
-                if let StmtKind::Local(ref local) = w[0].kind;
-                if let Option::Some(ref t) = local.init;
-                if let ExprKind::Closure(..) = t.kind;
-                if let PatKind::Ident(_, ident, _) = local.pat.kind;
-                if let StmtKind::Semi(ref second) = w[1].kind;
-                if let ExprKind::Assign(_, ref call, _) = second.kind;
-                if let ExprKind::Call(ref closure, _) = call.kind;
-                if let ExprKind::Path(_, ref path) = closure.kind;
-                if ident == path.segments[0].ident;
-                if  count_closure_usage(block, &ident) == 1;
-                then {
-                    span_lint(
-                        cx,
-                        REDUNDANT_CLOSURE_CALL,
-                        second.span,
-                        "Closure called just once immediately after it was declared",
-                    );
-                }
-            }
-        }
-    }
 }
 
 impl MiscEarlyLints {
diff --git a/clippy_lints/src/redundant_closure_call.rs b/clippy_lints/src/redundant_closure_call.rs
new file mode 100644
index 00000000000..391d70af159
--- /dev/null
+++ b/clippy_lints/src/redundant_closure_call.rs
@@ -0,0 +1,151 @@
+use crate::utils::{snippet_with_applicability, span_lint, span_lint_and_then};
+use if_chain::if_chain;
+use rustc_ast::ast;
+use rustc_ast::visit as ast_visit;
+use rustc_ast::visit::Visitor as AstVisitor;
+use rustc_errors::Applicability;
+use rustc_hir as hir;
+use rustc_hir::intravisit as hir_visit;
+use rustc_hir::intravisit::Visitor as HirVisitor;
+use rustc_lint::{EarlyContext, EarlyLintPass, LateContext, LateLintPass, LintContext};
+use rustc_middle::hir::map::Map;
+use rustc_middle::lint::in_external_macro;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::symbol::Ident;
+
+declare_clippy_lint! {
+    /// **What it does:** Detects closures called in the same expression where they
+    /// are defined.
+    ///
+    /// **Why is this bad?** It is unnecessarily adding to the expression's
+    /// complexity.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// ```rust,ignore
+    /// // Bad
+    /// let a = (|| 42)()
+    ///
+    /// // Good
+    /// let a = 42
+    /// ```
+    pub REDUNDANT_CLOSURE_CALL,
+    complexity,
+    "throwaway closures called in the expression they are defined"
+}
+
+declare_lint_pass!(RedundantClosureCall => [REDUNDANT_CLOSURE_CALL]);
+
+// Used to find `return` statements or equivalents e.g., `?`
+struct ReturnVisitor {
+    found_return: bool,
+}
+
+impl ReturnVisitor {
+    #[must_use]
+    fn new() -> Self {
+        Self { found_return: false }
+    }
+}
+
+impl<'ast> ast_visit::Visitor<'ast> for ReturnVisitor {
+    fn visit_expr(&mut self, ex: &'ast ast::Expr) {
+        if let ast::ExprKind::Ret(_) = ex.kind {
+            self.found_return = true;
+        } else if let ast::ExprKind::Try(_) = ex.kind {
+            self.found_return = true;
+        }
+
+        ast_visit::walk_expr(self, ex)
+    }
+}
+
+impl EarlyLintPass for RedundantClosureCall {
+    fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &ast::Expr) {
+        if in_external_macro(cx.sess(), expr.span) {
+            return;
+        }
+        if_chain! {
+            if let ast::ExprKind::Call(ref paren, _) = expr.kind;
+            if let ast::ExprKind::Paren(ref closure) = paren.kind;
+            if let ast::ExprKind::Closure(_, _, _, ref decl, ref block, _) = closure.kind;
+            then {
+                let mut visitor = ReturnVisitor::new();
+                visitor.visit_expr(block);
+                if !visitor.found_return {
+                    span_lint_and_then(
+                        cx,
+                        REDUNDANT_CLOSURE_CALL,
+                        expr.span,
+                        "Try not to call a closure in the expression where it is declared.",
+                        |diag| {
+                            if decl.inputs.is_empty() {
+                                let mut app = Applicability::MachineApplicable;
+                                let hint =
+                                    snippet_with_applicability(cx, block.span, "..", &mut app).into_owned();
+                                diag.span_suggestion(expr.span, "Try doing something like: ", hint, app);
+                            }
+                        },
+                    );
+                }
+            }
+        }
+    }
+}
+
+impl<'tcx> LateLintPass<'tcx> for RedundantClosureCall {
+    fn check_block(&mut self, cx: &LateContext<'tcx>, block: &'tcx hir::Block<'_>) {
+        fn count_closure_usage<'tcx>(block: &'tcx hir::Block<'_>, ident: &'tcx Ident) -> usize {
+            struct ClosureUsageCount<'tcx> {
+                ident: &'tcx Ident,
+                count: usize,
+            };
+            impl<'tcx> hir_visit::Visitor<'tcx> for ClosureUsageCount<'tcx> {
+                type Map = Map<'tcx>;
+
+                fn visit_expr(&mut self, expr: &'tcx hir::Expr<'tcx>) {
+                    if_chain! {
+                        if let hir::ExprKind::Call(ref closure, _) = expr.kind;
+                        if let hir::ExprKind::Path(hir::QPath::Resolved(_, ref path)) = closure.kind;
+                        if self.ident == &path.segments[0].ident;
+                        then {
+                            self.count += 1;
+                        }
+                    }
+                    hir_visit::walk_expr(self, expr);
+                }
+
+                fn nested_visit_map(&mut self) -> hir_visit::NestedVisitorMap<Self::Map> {
+                    hir_visit::NestedVisitorMap::None
+                }
+            };
+            let mut closure_usage_count = ClosureUsageCount { ident, count: 0 };
+            closure_usage_count.visit_block(block);
+            closure_usage_count.count
+        }
+
+        for w in block.stmts.windows(2) {
+            if_chain! {
+                if let hir::StmtKind::Local(ref local) = w[0].kind;
+                if let Option::Some(ref t) = local.init;
+                if let hir::ExprKind::Closure(..) = t.kind;
+                if let hir::PatKind::Binding(_, _, ident, _) = local.pat.kind;
+                if let hir::StmtKind::Semi(ref second) = w[1].kind;
+                if let hir::ExprKind::Assign(_, ref call, _) = second.kind;
+                if let hir::ExprKind::Call(ref closure, _) = call.kind;
+                if let hir::ExprKind::Path(hir::QPath::Resolved(_, ref path)) = closure.kind;
+                if ident == path.segments[0].ident;
+                if  count_closure_usage(block, &ident) == 1;
+                then {
+                    span_lint(
+                        cx,
+                        REDUNDANT_CLOSURE_CALL,
+                        second.span,
+                        "Closure called just once immediately after it was declared",
+                    );
+                }
+            }
+        }
+    }
+}
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index 96b004904aa..1879aae77fb 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -1835,7 +1835,7 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
         group: "complexity",
         desc: "throwaway closures called in the expression they are defined",
         deprecation: None,
-        module: "misc_early",
+        module: "redundant_closure_call",
     },
     Lint {
         name: "redundant_closure_for_method_calls",
diff --git a/tests/ui/redundant_closure_call.rs b/tests/ui/redundant_closure_call.rs
deleted file mode 100644
index 0f2ba4a075d..00000000000
--- a/tests/ui/redundant_closure_call.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-// non rustfixable, see redundant_closure_call_fixable.rs
-
-#![warn(clippy::redundant_closure_call)]
-
-fn main() {
-    let mut i = 1;
-    let mut k = (|m| m + 1)(i);
-
-    k = (|a, b| a * b)(1, 5);
-
-    // don't lint here, the closure is used more than once
-    let closure = |i| i + 1;
-    i = closure(3);
-    i = closure(4);
-
-    // lint here
-    let redun_closure = || 1;
-    i = redun_closure();
-
-    // the lint is applicable here but the lint doesn't support redefinition
-    let redefined_closure = || 1;
-    i = redefined_closure();
-    let redefined_closure = || 2;
-    i = redefined_closure();
-
-    #[allow(clippy::needless_return)]
-    (|| return 2)();
-    (|| -> Option<i32> { None? })();
-    (|| -> Result<i32, i32> { Err(2)? })();
-}
diff --git a/tests/ui/redundant_closure_call.stderr b/tests/ui/redundant_closure_call.stderr
deleted file mode 100644
index d5e0664319b..00000000000
--- a/tests/ui/redundant_closure_call.stderr
+++ /dev/null
@@ -1,22 +0,0 @@
-error: Closure called just once immediately after it was declared
-  --> $DIR/redundant_closure_call.rs:18:5
-   |
-LL |     i = redun_closure();
-   |     ^^^^^^^^^^^^^^^^^^^
-   |
-   = note: `-D clippy::redundant-closure-call` implied by `-D warnings`
-
-error: Try not to call a closure in the expression where it is declared.
-  --> $DIR/redundant_closure_call.rs:7:17
-   |
-LL |     let mut k = (|m| m + 1)(i);
-   |                 ^^^^^^^^^^^^^^
-
-error: Try not to call a closure in the expression where it is declared.
-  --> $DIR/redundant_closure_call.rs:9:9
-   |
-LL |     k = (|a, b| a * b)(1, 5);
-   |         ^^^^^^^^^^^^^^^^^^^^
-
-error: aborting due to 3 previous errors
-
diff --git a/tests/ui/redundant_closure_call_early.rs b/tests/ui/redundant_closure_call_early.rs
new file mode 100644
index 00000000000..3dd365620cc
--- /dev/null
+++ b/tests/ui/redundant_closure_call_early.rs
@@ -0,0 +1,19 @@
+// non rustfixable, see redundant_closure_call_fixable.rs
+
+#![warn(clippy::redundant_closure_call)]
+
+fn main() {
+    let mut i = 1;
+
+    // lint here
+    let mut k = (|m| m + 1)(i);
+
+    // lint here
+    k = (|a, b| a * b)(1, 5);
+
+    // don't lint these
+    #[allow(clippy::needless_return)]
+    (|| return 2)();
+    (|| -> Option<i32> { None? })();
+    (|| -> Result<i32, i32> { Err(2)? })();
+}
diff --git a/tests/ui/redundant_closure_call_early.stderr b/tests/ui/redundant_closure_call_early.stderr
new file mode 100644
index 00000000000..0ac97ae25d0
--- /dev/null
+++ b/tests/ui/redundant_closure_call_early.stderr
@@ -0,0 +1,16 @@
+error: Try not to call a closure in the expression where it is declared.
+  --> $DIR/redundant_closure_call_early.rs:9:17
+   |
+LL |     let mut k = (|m| m + 1)(i);
+   |                 ^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::redundant-closure-call` implied by `-D warnings`
+
+error: Try not to call a closure in the expression where it is declared.
+  --> $DIR/redundant_closure_call_early.rs:12:9
+   |
+LL |     k = (|a, b| a * b)(1, 5);
+   |         ^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 2 previous errors
+
diff --git a/tests/ui/redundant_closure_call_late.rs b/tests/ui/redundant_closure_call_late.rs
new file mode 100644
index 00000000000..21ee58e5b44
--- /dev/null
+++ b/tests/ui/redundant_closure_call_late.rs
@@ -0,0 +1,22 @@
+// non rustfixable, see redundant_closure_call_fixable.rs
+
+#![warn(clippy::redundant_closure_call)]
+
+fn main() {
+    let mut i = 1;
+
+    // don't lint here, the closure is used more than once
+    let closure = |i| i + 1;
+    i = closure(3);
+    i = closure(4);
+
+    // lint here
+    let redun_closure = || 1;
+    i = redun_closure();
+
+    // the lint is applicable here but the lint doesn't support redefinition
+    let redefined_closure = || 1;
+    i = redefined_closure();
+    let redefined_closure = || 2;
+    i = redefined_closure();
+}
diff --git a/tests/ui/redundant_closure_call_late.stderr b/tests/ui/redundant_closure_call_late.stderr
new file mode 100644
index 00000000000..0aebc3c419e
--- /dev/null
+++ b/tests/ui/redundant_closure_call_late.stderr
@@ -0,0 +1,10 @@
+error: Closure called just once immediately after it was declared
+  --> $DIR/redundant_closure_call_late.rs:15:5
+   |
+LL |     i = redun_closure();
+   |     ^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::redundant-closure-call` implied by `-D warnings`
+
+error: aborting due to previous error
+
-- 
cgit 1.4.1-3-g733a5


From 9603d9652b9d172842c77f566121437768bc962f Mon Sep 17 00:00:00 2001
From: Tim Nielens <tim.nielens@gmail.com>
Date: Sun, 19 Jul 2020 11:47:32 +0200
Subject: redundant_closure_call - add support for shadowed closures

---
 clippy_lints/src/redundant_closure_call.rs  | 12 ++++++------
 tests/ui/redundant_closure_call_late.rs     | 15 ++++++++++-----
 tests/ui/redundant_closure_call_late.stderr | 14 +++++++++++++-
 3 files changed, 29 insertions(+), 12 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/redundant_closure_call.rs b/clippy_lints/src/redundant_closure_call.rs
index 391d70af159..9477e79f567 100644
--- a/clippy_lints/src/redundant_closure_call.rs
+++ b/clippy_lints/src/redundant_closure_call.rs
@@ -11,7 +11,6 @@ use rustc_lint::{EarlyContext, EarlyLintPass, LateContext, LateLintPass, LintCon
 use rustc_middle::hir::map::Map;
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::symbol::Ident;
 
 declare_clippy_lint! {
     /// **What it does:** Detects closures called in the same expression where they
@@ -96,9 +95,9 @@ impl EarlyLintPass for RedundantClosureCall {
 
 impl<'tcx> LateLintPass<'tcx> for RedundantClosureCall {
     fn check_block(&mut self, cx: &LateContext<'tcx>, block: &'tcx hir::Block<'_>) {
-        fn count_closure_usage<'tcx>(block: &'tcx hir::Block<'_>, ident: &'tcx Ident) -> usize {
+        fn count_closure_usage<'tcx>(block: &'tcx hir::Block<'_>, path: &'tcx hir::Path<'tcx>) -> usize {
             struct ClosureUsageCount<'tcx> {
-                ident: &'tcx Ident,
+                path: &'tcx hir::Path<'tcx>,
                 count: usize,
             };
             impl<'tcx> hir_visit::Visitor<'tcx> for ClosureUsageCount<'tcx> {
@@ -108,7 +107,8 @@ impl<'tcx> LateLintPass<'tcx> for RedundantClosureCall {
                     if_chain! {
                         if let hir::ExprKind::Call(ref closure, _) = expr.kind;
                         if let hir::ExprKind::Path(hir::QPath::Resolved(_, ref path)) = closure.kind;
-                        if self.ident == &path.segments[0].ident;
+                        if self.path.segments[0].ident == path.segments[0].ident
+                            && self.path.res == path.res;
                         then {
                             self.count += 1;
                         }
@@ -120,7 +120,7 @@ impl<'tcx> LateLintPass<'tcx> for RedundantClosureCall {
                     hir_visit::NestedVisitorMap::None
                 }
             };
-            let mut closure_usage_count = ClosureUsageCount { ident, count: 0 };
+            let mut closure_usage_count = ClosureUsageCount { path, count: 0 };
             closure_usage_count.visit_block(block);
             closure_usage_count.count
         }
@@ -136,7 +136,7 @@ impl<'tcx> LateLintPass<'tcx> for RedundantClosureCall {
                 if let hir::ExprKind::Call(ref closure, _) = call.kind;
                 if let hir::ExprKind::Path(hir::QPath::Resolved(_, ref path)) = closure.kind;
                 if ident == path.segments[0].ident;
-                if  count_closure_usage(block, &ident) == 1;
+                if  count_closure_usage(block, path) == 1;
                 then {
                     span_lint(
                         cx,
diff --git a/tests/ui/redundant_closure_call_late.rs b/tests/ui/redundant_closure_call_late.rs
index 21ee58e5b44..e29a1dce0c7 100644
--- a/tests/ui/redundant_closure_call_late.rs
+++ b/tests/ui/redundant_closure_call_late.rs
@@ -14,9 +14,14 @@ fn main() {
     let redun_closure = || 1;
     i = redun_closure();
 
-    // the lint is applicable here but the lint doesn't support redefinition
-    let redefined_closure = || 1;
-    i = redefined_closure();
-    let redefined_closure = || 2;
-    i = redefined_closure();
+    // shadowed closures are supported, lint here
+    let shadowed_closure = || 1;
+    i = shadowed_closure();
+    let shadowed_closure = || 2;
+    i = shadowed_closure();
+
+    // don't lint here
+    let shadowed_closure = || 2;
+    i = shadowed_closure();
+    i = shadowed_closure();
 }
diff --git a/tests/ui/redundant_closure_call_late.stderr b/tests/ui/redundant_closure_call_late.stderr
index 0aebc3c419e..0e000fee85a 100644
--- a/tests/ui/redundant_closure_call_late.stderr
+++ b/tests/ui/redundant_closure_call_late.stderr
@@ -6,5 +6,17 @@ LL |     i = redun_closure();
    |
    = note: `-D clippy::redundant-closure-call` implied by `-D warnings`
 
-error: aborting due to previous error
+error: Closure called just once immediately after it was declared
+  --> $DIR/redundant_closure_call_late.rs:19:5
+   |
+LL |     i = shadowed_closure();
+   |     ^^^^^^^^^^^^^^^^^^^^^^
+
+error: Closure called just once immediately after it was declared
+  --> $DIR/redundant_closure_call_late.rs:21:5
+   |
+LL |     i = shadowed_closure();
+   |     ^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 3 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 1ac8b85c9fd38ff0a14061cae0b4d31e9bfafd56 Mon Sep 17 00:00:00 2001
From: Tim Nielens <tim.nielens@gmail.com>
Date: Mon, 20 Jul 2020 00:36:31 +0200
Subject: redundant_closure_call - pr review

---
 clippy_lints/src/redundant_closure_call.rs     | 8 ++++----
 tests/ui/redundant_closure_call_early.stderr   | 4 ++--
 tests/ui/redundant_closure_call_fixable.stderr | 4 ++--
 tests/ui/redundant_closure_call_late.stderr    | 6 +++---
 4 files changed, 11 insertions(+), 11 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/redundant_closure_call.rs b/clippy_lints/src/redundant_closure_call.rs
index 9477e79f567..8aa478ea2d6 100644
--- a/clippy_lints/src/redundant_closure_call.rs
+++ b/clippy_lints/src/redundant_closure_call.rs
@@ -77,13 +77,13 @@ impl EarlyLintPass for RedundantClosureCall {
                         cx,
                         REDUNDANT_CLOSURE_CALL,
                         expr.span,
-                        "Try not to call a closure in the expression where it is declared.",
+                        "try not to call a closure in the expression where it is declared.",
                         |diag| {
                             if decl.inputs.is_empty() {
                                 let mut app = Applicability::MachineApplicable;
                                 let hint =
                                     snippet_with_applicability(cx, block.span, "..", &mut app).into_owned();
-                                diag.span_suggestion(expr.span, "Try doing something like: ", hint, app);
+                                diag.span_suggestion(expr.span, "try doing something like", hint, app);
                             }
                         },
                     );
@@ -136,13 +136,13 @@ impl<'tcx> LateLintPass<'tcx> for RedundantClosureCall {
                 if let hir::ExprKind::Call(ref closure, _) = call.kind;
                 if let hir::ExprKind::Path(hir::QPath::Resolved(_, ref path)) = closure.kind;
                 if ident == path.segments[0].ident;
-                if  count_closure_usage(block, path) == 1;
+                if count_closure_usage(block, path) == 1;
                 then {
                     span_lint(
                         cx,
                         REDUNDANT_CLOSURE_CALL,
                         second.span,
-                        "Closure called just once immediately after it was declared",
+                        "closure called just once immediately after it was declared",
                     );
                 }
             }
diff --git a/tests/ui/redundant_closure_call_early.stderr b/tests/ui/redundant_closure_call_early.stderr
index 0ac97ae25d0..79f27663461 100644
--- a/tests/ui/redundant_closure_call_early.stderr
+++ b/tests/ui/redundant_closure_call_early.stderr
@@ -1,4 +1,4 @@
-error: Try not to call a closure in the expression where it is declared.
+error: try not to call a closure in the expression where it is declared.
   --> $DIR/redundant_closure_call_early.rs:9:17
    |
 LL |     let mut k = (|m| m + 1)(i);
@@ -6,7 +6,7 @@ LL |     let mut k = (|m| m + 1)(i);
    |
    = note: `-D clippy::redundant-closure-call` implied by `-D warnings`
 
-error: Try not to call a closure in the expression where it is declared.
+error: try not to call a closure in the expression where it is declared.
   --> $DIR/redundant_closure_call_early.rs:12:9
    |
 LL |     k = (|a, b| a * b)(1, 5);
diff --git a/tests/ui/redundant_closure_call_fixable.stderr b/tests/ui/redundant_closure_call_fixable.stderr
index e7737f9dd85..644161d9f5d 100644
--- a/tests/ui/redundant_closure_call_fixable.stderr
+++ b/tests/ui/redundant_closure_call_fixable.stderr
@@ -1,8 +1,8 @@
-error: Try not to call a closure in the expression where it is declared.
+error: try not to call a closure in the expression where it is declared.
   --> $DIR/redundant_closure_call_fixable.rs:7:13
    |
 LL |     let a = (|| 42)();
-   |             ^^^^^^^^^ help: Try doing something like: : `42`
+   |             ^^^^^^^^^ help: try doing something like: `42`
    |
    = note: `-D clippy::redundant-closure-call` implied by `-D warnings`
 
diff --git a/tests/ui/redundant_closure_call_late.stderr b/tests/ui/redundant_closure_call_late.stderr
index 0e000fee85a..7c8865f1bd3 100644
--- a/tests/ui/redundant_closure_call_late.stderr
+++ b/tests/ui/redundant_closure_call_late.stderr
@@ -1,4 +1,4 @@
-error: Closure called just once immediately after it was declared
+error: closure called just once immediately after it was declared
   --> $DIR/redundant_closure_call_late.rs:15:5
    |
 LL |     i = redun_closure();
@@ -6,13 +6,13 @@ LL |     i = redun_closure();
    |
    = note: `-D clippy::redundant-closure-call` implied by `-D warnings`
 
-error: Closure called just once immediately after it was declared
+error: closure called just once immediately after it was declared
   --> $DIR/redundant_closure_call_late.rs:19:5
    |
 LL |     i = shadowed_closure();
    |     ^^^^^^^^^^^^^^^^^^^^^^
 
-error: Closure called just once immediately after it was declared
+error: closure called just once immediately after it was declared
   --> $DIR/redundant_closure_call_late.rs:21:5
    |
 LL |     i = shadowed_closure();
-- 
cgit 1.4.1-3-g733a5


From a5cdd4aeb11fad6b0bf73d342398700a27c4484b Mon Sep 17 00:00:00 2001
From: Tomasz Miąsko <tomasz.miasko@gmail.com>
Date: Mon, 20 Jul 2020 00:00:00 +0000
Subject: Ignore not really redundant clones of ManuallyDrop

"Redundant" clones of `ManuallyDrop` are sometimes used for the side effect of
invoking the clone, without running the drop implementation of the inner type.
In other words, they aren't really redundant. For example, futures-rs crate:

```rust
#[allow(clippy::redundant_clone)] // The clone here isn't actually redundant.
unsafe fn increase_refcount<T: ArcWake>(data: *const ()) {
    // Retain Arc, but don't touch refcount by wrapping in ManuallyDrop
    let arc = mem::ManuallyDrop::new(Arc::<T>::from_raw(data as *const T));
    // Now increase refcount, but don't drop new refcount either
    let _arc_clone: mem::ManuallyDrop<_> = arc.clone();
}
```

Ignore redundant clone lint for ManuallyDrop.
---
 clippy_lints/src/redundant_clone.rs |  6 ++++++
 clippy_lints/src/utils/paths.rs     |  1 +
 tests/ui/redundant_clone.fixed      | 15 +++++++++++++++
 tests/ui/redundant_clone.rs         | 15 +++++++++++++++
 tests/ui/redundant_clone.stderr     | 20 ++++++++++----------
 5 files changed, 47 insertions(+), 10 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/redundant_clone.rs b/clippy_lints/src/redundant_clone.rs
index fda7480194d..7932be0d4b1 100644
--- a/clippy_lints/src/redundant_clone.rs
+++ b/clippy_lints/src/redundant_clone.rs
@@ -124,6 +124,12 @@ impl<'tcx> LateLintPass<'tcx> for RedundantClone {
                 continue;
             }
 
+            if let ty::Adt(ref def, _) = arg_ty.kind {
+                if match_def_path(cx, def.did, &paths::MEM_MANUALLY_DROP) {
+                    continue;
+                }
+            }
+
             // `{ cloned = &arg; clone(move cloned); }` or `{ cloned = &arg; to_path_buf(cloned); }`
             let (cloned, cannot_move_out) = unwrap_or_continue!(find_stmt_assigns_to(cx, mir, arg, from_borrow, bb));
 
diff --git a/clippy_lints/src/utils/paths.rs b/clippy_lints/src/utils/paths.rs
index 4c3462802e9..a515ee29c82 100644
--- a/clippy_lints/src/utils/paths.rs
+++ b/clippy_lints/src/utils/paths.rs
@@ -59,6 +59,7 @@ pub const LINKED_LIST: [&str; 4] = ["alloc", "collections", "linked_list", "Link
 pub const LINT: [&str; 3] = ["rustc_session", "lint", "Lint"];
 pub const MEM_DISCRIMINANT: [&str; 3] = ["core", "mem", "discriminant"];
 pub const MEM_FORGET: [&str; 3] = ["core", "mem", "forget"];
+pub const MEM_MANUALLY_DROP: [&str; 4] = ["core", "mem", "manually_drop", "ManuallyDrop"];
 pub const MEM_MAYBEUNINIT: [&str; 4] = ["core", "mem", "maybe_uninit", "MaybeUninit"];
 pub const MEM_MAYBEUNINIT_UNINIT: [&str; 5] = ["core", "mem", "maybe_uninit", "MaybeUninit", "uninit"];
 pub const MEM_REPLACE: [&str; 3] = ["core", "mem", "replace"];
diff --git a/tests/ui/redundant_clone.fixed b/tests/ui/redundant_clone.fixed
index 764c10a6d39..cdeefda4c23 100644
--- a/tests/ui/redundant_clone.fixed
+++ b/tests/ui/redundant_clone.fixed
@@ -52,6 +52,7 @@ fn main() {
     borrower_propagation();
     not_consumed();
     issue_5405();
+    manually_drop();
 }
 
 #[derive(Clone)]
@@ -170,3 +171,17 @@ fn issue_5405() {
     let c: [usize; 2] = [2, 3];
     let _d: usize = c[1].clone();
 }
+
+fn manually_drop() {
+    use std::mem::ManuallyDrop;
+    use std::sync::Arc;
+
+    let a = ManuallyDrop::new(Arc::new("Hello!".to_owned()));
+    let _ = a.clone(); // OK
+
+    let p: *const String = Arc::into_raw(ManuallyDrop::into_inner(a));
+    unsafe {
+        Arc::from_raw(p);
+        Arc::from_raw(p);
+    }
+}
diff --git a/tests/ui/redundant_clone.rs b/tests/ui/redundant_clone.rs
index 839747b131d..acb7ffb305f 100644
--- a/tests/ui/redundant_clone.rs
+++ b/tests/ui/redundant_clone.rs
@@ -52,6 +52,7 @@ fn main() {
     borrower_propagation();
     not_consumed();
     issue_5405();
+    manually_drop();
 }
 
 #[derive(Clone)]
@@ -170,3 +171,17 @@ fn issue_5405() {
     let c: [usize; 2] = [2, 3];
     let _d: usize = c[1].clone();
 }
+
+fn manually_drop() {
+    use std::mem::ManuallyDrop;
+    use std::sync::Arc;
+
+    let a = ManuallyDrop::new(Arc::new("Hello!".to_owned()));
+    let _ = a.clone(); // OK
+
+    let p: *const String = Arc::into_raw(ManuallyDrop::into_inner(a));
+    unsafe {
+        Arc::from_raw(p);
+        Arc::from_raw(p);
+    }
+}
diff --git a/tests/ui/redundant_clone.stderr b/tests/ui/redundant_clone.stderr
index eced198283c..89b39254299 100644
--- a/tests/ui/redundant_clone.stderr
+++ b/tests/ui/redundant_clone.stderr
@@ -108,61 +108,61 @@ LL |     let _t = tup.0.clone();
    |              ^^^^^
 
 error: redundant clone
-  --> $DIR/redundant_clone.rs:61:22
+  --> $DIR/redundant_clone.rs:62:22
    |
 LL |         (a.clone(), a.clone())
    |                      ^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> $DIR/redundant_clone.rs:61:21
+  --> $DIR/redundant_clone.rs:62:21
    |
 LL |         (a.clone(), a.clone())
    |                     ^
 
 error: redundant clone
-  --> $DIR/redundant_clone.rs:121:15
+  --> $DIR/redundant_clone.rs:122:15
    |
 LL |     let _s = s.clone();
    |               ^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> $DIR/redundant_clone.rs:121:14
+  --> $DIR/redundant_clone.rs:122:14
    |
 LL |     let _s = s.clone();
    |              ^
 
 error: redundant clone
-  --> $DIR/redundant_clone.rs:122:15
+  --> $DIR/redundant_clone.rs:123:15
    |
 LL |     let _t = t.clone();
    |               ^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> $DIR/redundant_clone.rs:122:14
+  --> $DIR/redundant_clone.rs:123:14
    |
 LL |     let _t = t.clone();
    |              ^
 
 error: redundant clone
-  --> $DIR/redundant_clone.rs:132:19
+  --> $DIR/redundant_clone.rs:133:19
    |
 LL |         let _f = f.clone();
    |                   ^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> $DIR/redundant_clone.rs:132:18
+  --> $DIR/redundant_clone.rs:133:18
    |
 LL |         let _f = f.clone();
    |                  ^
 
 error: redundant clone
-  --> $DIR/redundant_clone.rs:144:14
+  --> $DIR/redundant_clone.rs:145:14
    |
 LL |     let y = x.clone().join("matthias");
    |              ^^^^^^^^ help: remove this
    |
 note: cloned value is neither consumed nor mutated
-  --> $DIR/redundant_clone.rs:144:13
+  --> $DIR/redundant_clone.rs:145:13
    |
 LL |     let y = x.clone().join("matthias");
    |             ^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From 142a273441d1cf2039bd2857ee57cfa402e2a3f7 Mon Sep 17 00:00:00 2001
From: Yuki Okushi <huyuumi.dev@gmail.com>
Date: Wed, 22 Jul 2020 05:23:55 +0900
Subject: Use `(std::)f64::EPSILON` in the examples as suggested in the lints

---
 clippy_lints/src/misc.rs | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/misc.rs b/clippy_lints/src/misc.rs
index fc10e5077b8..26a1c32b6b3 100644
--- a/clippy_lints/src/misc.rs
+++ b/clippy_lints/src/misc.rs
@@ -99,7 +99,9 @@ declare_clippy_lint! {
     /// if y != x {} // where both are floats
     ///
     /// // Good
-    /// let error = 0.01f64; // Use an epsilon for comparison
+    /// let error = f64::EPSILON; // Use an epsilon for comparison
+    /// // Or, if Rust <= 1.42, use `std::f64::EPSILON` constant instead.
+    /// // let error = std::f64::EPSILON;
     /// if (y - 1.23f64).abs() < error { }
     /// if (y - x).abs() > error { }
     /// ```
@@ -237,10 +239,12 @@ declare_clippy_lint! {
     /// const ONE: f64 = 1.00;
     ///
     /// // Bad
-    /// if x == ONE { }  // where both are floats
+    /// if x == ONE { } // where both are floats
     ///
     /// // Good
-    /// let error = 0.1f64; // Use an epsilon for comparison
+    /// let error = f64::EPSILON; // Use an epsilon for comparison
+    /// // Or, if Rust <= 1.42, use `std::f64::EPSILON` constant instead.
+    /// // let error = std::f64::EPSILON;
     /// if (x - ONE).abs() < error { }
     /// ```
     pub FLOAT_CMP_CONST,
-- 
cgit 1.4.1-3-g733a5


From b375f1dd20bf07175ec06d13e1e9dc8b20287cd3 Mon Sep 17 00:00:00 2001
From: Dmitry Murzin <diralik@yandex.ru>
Date: Sat, 25 Jul 2020 17:09:44 +0300
Subject: Add suggestion for `iter_skip_next` lint

---
 clippy_lints/src/methods/mod.rs | 24 ++++++++++++++----------
 tests/ui/iter_skip_next.fixed   | 22 ++++++++++++++++++++++
 tests/ui/iter_skip_next.rs      |  8 ++++----
 tests/ui/iter_skip_next.stderr  | 23 ++++++++---------------
 4 files changed, 48 insertions(+), 29 deletions(-)
 create mode 100644 tests/ui/iter_skip_next.fixed

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 97cc58023f5..56686f6d24f 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1408,7 +1408,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             ["nth", "iter_mut"] => lint_iter_nth(cx, expr, &arg_lists, true),
             ["nth", ..] => lint_iter_nth_zero(cx, expr, arg_lists[0]),
             ["step_by", ..] => lint_step_by(cx, expr, arg_lists[0]),
-            ["next", "skip"] => lint_iter_skip_next(cx, expr),
+            ["next", "skip"] => lint_iter_skip_next(cx, expr, arg_lists[1]),
             ["collect", "cloned"] => lint_iter_cloned_collect(cx, expr, arg_lists[1]),
             ["as_ref"] => lint_asref(cx, expr, "as_ref", arg_lists[0]),
             ["as_mut"] => lint_asref(cx, expr, "as_mut", arg_lists[0]),
@@ -2436,17 +2436,21 @@ fn lint_get_unwrap<'tcx>(cx: &LateContext<'tcx>, expr: &hir::Expr<'_>, get_args:
     );
 }
 
-fn lint_iter_skip_next(cx: &LateContext<'_>, expr: &hir::Expr<'_>) {
+fn lint_iter_skip_next(cx: &LateContext<'_>, expr: &hir::Expr<'_>, skip_args: &[hir::Expr<'_>]) {
     // lint if caller of skip is an Iterator
     if match_trait_method(cx, expr, &paths::ITERATOR) {
-        span_lint_and_help(
-            cx,
-            ITER_SKIP_NEXT,
-            expr.span,
-            "called `skip(x).next()` on an iterator",
-            None,
-            "this is more succinctly expressed by calling `nth(x)`",
-        );
+        if let [caller, n] = skip_args {
+            let hint = format!(".nth({})", snippet(cx, n.span, ".."));
+            span_lint_and_sugg(
+                cx,
+                ITER_SKIP_NEXT,
+                expr.span.trim_start(caller.span).unwrap(),
+                "called `skip(x).next()` on an iterator",
+                "use `nth` instead",
+                hint,
+                Applicability::MachineApplicable,
+            );
+        }
     }
 }
 
diff --git a/tests/ui/iter_skip_next.fixed b/tests/ui/iter_skip_next.fixed
new file mode 100644
index 00000000000..928b6acb951
--- /dev/null
+++ b/tests/ui/iter_skip_next.fixed
@@ -0,0 +1,22 @@
+// run-rustfix
+// aux-build:option_helpers.rs
+
+#![warn(clippy::iter_skip_next)]
+#![allow(clippy::blacklisted_name)]
+#![allow(clippy::iter_nth)]
+
+extern crate option_helpers;
+
+use option_helpers::IteratorFalsePositives;
+
+/// Checks implementation of `ITER_SKIP_NEXT` lint
+fn main() {
+    let some_vec = vec![0, 1, 2, 3];
+    let _ = some_vec.iter().nth(42);
+    let _ = some_vec.iter().cycle().nth(42);
+    let _ = (1..10).nth(10);
+    let _ = &some_vec[..].iter().nth(3);
+    let foo = IteratorFalsePositives { foo: 0 };
+    let _ = foo.skip(42).next();
+    let _ = foo.filter().skip(42).next();
+}
diff --git a/tests/ui/iter_skip_next.rs b/tests/ui/iter_skip_next.rs
index a65ca3bbb13..7075e2598eb 100644
--- a/tests/ui/iter_skip_next.rs
+++ b/tests/ui/iter_skip_next.rs
@@ -1,15 +1,17 @@
+// run-rustfix
 // aux-build:option_helpers.rs
 
 #![warn(clippy::iter_skip_next)]
 #![allow(clippy::blacklisted_name)]
+#![allow(clippy::iter_nth)]
 
 extern crate option_helpers;
 
 use option_helpers::IteratorFalsePositives;
 
 /// Checks implementation of `ITER_SKIP_NEXT` lint
-fn iter_skip_next() {
-    let mut some_vec = vec![0, 1, 2, 3];
+fn main() {
+    let some_vec = vec![0, 1, 2, 3];
     let _ = some_vec.iter().skip(42).next();
     let _ = some_vec.iter().cycle().skip(42).next();
     let _ = (1..10).skip(10).next();
@@ -18,5 +20,3 @@ fn iter_skip_next() {
     let _ = foo.skip(42).next();
     let _ = foo.filter().skip(42).next();
 }
-
-fn main() {}
diff --git a/tests/ui/iter_skip_next.stderr b/tests/ui/iter_skip_next.stderr
index 5709f335529..feedc2f288a 100644
--- a/tests/ui/iter_skip_next.stderr
+++ b/tests/ui/iter_skip_next.stderr
@@ -1,35 +1,28 @@
 error: called `skip(x).next()` on an iterator
-  --> $DIR/iter_skip_next.rs:13:13
+  --> $DIR/iter_skip_next.rs:15:28
    |
 LL |     let _ = some_vec.iter().skip(42).next();
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                            ^^^^^^^^^^^^^^^^ help: use `nth` instead: `.nth(42)`
    |
    = note: `-D clippy::iter-skip-next` implied by `-D warnings`
-   = help: this is more succinctly expressed by calling `nth(x)`
 
 error: called `skip(x).next()` on an iterator
-  --> $DIR/iter_skip_next.rs:14:13
+  --> $DIR/iter_skip_next.rs:16:36
    |
 LL |     let _ = some_vec.iter().cycle().skip(42).next();
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: this is more succinctly expressed by calling `nth(x)`
+   |                                    ^^^^^^^^^^^^^^^^ help: use `nth` instead: `.nth(42)`
 
 error: called `skip(x).next()` on an iterator
-  --> $DIR/iter_skip_next.rs:15:13
+  --> $DIR/iter_skip_next.rs:17:20
    |
 LL |     let _ = (1..10).skip(10).next();
-   |             ^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: this is more succinctly expressed by calling `nth(x)`
+   |                    ^^^^^^^^^^^^^^^^ help: use `nth` instead: `.nth(10)`
 
 error: called `skip(x).next()` on an iterator
-  --> $DIR/iter_skip_next.rs:16:14
+  --> $DIR/iter_skip_next.rs:18:33
    |
 LL |     let _ = &some_vec[..].iter().skip(3).next();
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: this is more succinctly expressed by calling `nth(x)`
+   |                                 ^^^^^^^^^^^^^^^ help: use `nth` instead: `.nth(3)`
 
 error: aborting due to 4 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From c81bbd05b95ae03da9af4e7e25e3784edd039465 Mon Sep 17 00:00:00 2001
From: Takayuki Nakata <f.seasons017@gmail.com>
Date: Sat, 25 Jul 2020 23:58:22 +0900
Subject: Fix FP `useless_conversion`

Fix #5833.
---
 clippy_lints/src/useless_conversion.rs | 11 +++++++++--
 tests/ui/useless_conversion.fixed      |  9 +++++++++
 tests/ui/useless_conversion.rs         |  9 +++++++++
 tests/ui/useless_conversion.stderr     | 14 +++++++-------
 4 files changed, 34 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/useless_conversion.rs b/clippy_lints/src/useless_conversion.rs
index a48ad3185e9..1bf37632e32 100644
--- a/clippy_lints/src/useless_conversion.rs
+++ b/clippy_lints/src/useless_conversion.rs
@@ -1,6 +1,6 @@
 use crate::utils::{
-    is_type_diagnostic_item, match_def_path, match_trait_method, paths, snippet, snippet_with_macro_callsite,
-    span_lint_and_help, span_lint_and_sugg,
+    get_parent_expr, is_type_diagnostic_item, match_def_path, match_trait_method, paths, snippet,
+    snippet_with_macro_callsite, span_lint_and_help, span_lint_and_sugg,
 };
 use if_chain::if_chain;
 use rustc_errors::Applicability;
@@ -79,6 +79,13 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
                     }
                 }
                 if match_trait_method(cx, e, &paths::INTO_ITERATOR) && &*name.ident.as_str() == "into_iter" {
+                    if let Some(parent_expr) = get_parent_expr(cx, e) {
+                        if let ExprKind::MethodCall(ref parent_name, ..) = parent_expr.kind {
+                            if &*parent_name.ident.as_str() != "into_iter" {
+                                return;
+                            }
+                        }
+                    }
                     let a = cx.typeck_results().expr_ty(e);
                     let b = cx.typeck_results().expr_ty(&args[0]);
                     if TyS::same_type(a, b) {
diff --git a/tests/ui/useless_conversion.fixed b/tests/ui/useless_conversion.fixed
index fdd4bc581f3..813cdaecaa9 100644
--- a/tests/ui/useless_conversion.fixed
+++ b/tests/ui/useless_conversion.fixed
@@ -32,11 +32,20 @@ fn test_issue_3913() -> Result<(), std::io::Error> {
     Ok(())
 }
 
+fn test_issue_5833() -> Result<(), ()> {
+    let text = "foo\r\nbar\n\nbaz\n";
+    let lines = text.lines();
+    if Some("ok") == lines.into_iter().next() {}
+
+    Ok(())
+}
+
 fn main() {
     test_generic(10i32);
     test_generic2::<i32, i32>(10i32);
     test_questionmark().unwrap();
     test_issue_3913().unwrap();
+    test_issue_5833().unwrap();
 
     let _: String = "foo".into();
     let _: String = From::from("foo");
diff --git a/tests/ui/useless_conversion.rs b/tests/ui/useless_conversion.rs
index 4cae745e7c0..540fea23b36 100644
--- a/tests/ui/useless_conversion.rs
+++ b/tests/ui/useless_conversion.rs
@@ -32,11 +32,20 @@ fn test_issue_3913() -> Result<(), std::io::Error> {
     Ok(())
 }
 
+fn test_issue_5833() -> Result<(), ()> {
+    let text = "foo\r\nbar\n\nbaz\n";
+    let lines = text.lines();
+    if Some("ok") == lines.into_iter().next() {}
+
+    Ok(())
+}
+
 fn main() {
     test_generic(10i32);
     test_generic2::<i32, i32>(10i32);
     test_questionmark().unwrap();
     test_issue_3913().unwrap();
+    test_issue_5833().unwrap();
 
     let _: String = "foo".into();
     let _: String = From::from("foo");
diff --git a/tests/ui/useless_conversion.stderr b/tests/ui/useless_conversion.stderr
index 84ec5370278..b958b035452 100644
--- a/tests/ui/useless_conversion.stderr
+++ b/tests/ui/useless_conversion.stderr
@@ -23,43 +23,43 @@ LL |         let _: i32 = 0i32.into();
    |                      ^^^^^^^^^^^ help: consider removing `.into()`: `0i32`
 
 error: useless conversion to the same type
-  --> $DIR/useless_conversion.rs:51:21
+  --> $DIR/useless_conversion.rs:60:21
    |
 LL |     let _: String = "foo".to_string().into();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into()`: `"foo".to_string()`
 
 error: useless conversion to the same type
-  --> $DIR/useless_conversion.rs:52:21
+  --> $DIR/useless_conversion.rs:61:21
    |
 LL |     let _: String = From::from("foo".to_string());
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `From::from()`: `"foo".to_string()`
 
 error: useless conversion to the same type
-  --> $DIR/useless_conversion.rs:53:13
+  --> $DIR/useless_conversion.rs:62:13
    |
 LL |     let _ = String::from("foo".to_string());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `String::from()`: `"foo".to_string()`
 
 error: useless conversion to the same type
-  --> $DIR/useless_conversion.rs:54:13
+  --> $DIR/useless_conversion.rs:63:13
    |
 LL |     let _ = String::from(format!("A: {:04}", 123));
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `String::from()`: `format!("A: {:04}", 123)`
 
 error: useless conversion to the same type
-  --> $DIR/useless_conversion.rs:55:13
+  --> $DIR/useless_conversion.rs:64:13
    |
 LL |     let _ = "".lines().into_iter();
    |             ^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `"".lines()`
 
 error: useless conversion to the same type
-  --> $DIR/useless_conversion.rs:56:13
+  --> $DIR/useless_conversion.rs:65:13
    |
 LL |     let _ = vec![1, 2, 3].into_iter().into_iter();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `vec![1, 2, 3].into_iter()`
 
 error: useless conversion to the same type
-  --> $DIR/useless_conversion.rs:57:21
+  --> $DIR/useless_conversion.rs:66:21
    |
 LL |     let _: String = format!("Hello {}", "world").into();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into()`: `format!("Hello {}", "world")`
-- 
cgit 1.4.1-3-g733a5


From 5a644964fc05752a1283dab238b81de7583f7d03 Mon Sep 17 00:00:00 2001
From: Ryan1729 <Ryan1729@gmail.com>
Date: Sun, 26 Jul 2020 20:40:57 -0600
Subject: run cargo dev new_lint

specifically:
cargo dev new_lint --name derive_ord_xor_partial_ord --category correctness --pass late
---
 CHANGELOG.md                                   |  1 +
 clippy_lints/src/derive_ord_xor_partial_ord.rs | 28 ++++++++++++++++++++++++++
 clippy_lints/src/lib.rs                        |  4 ++++
 src/lintlist/mod.rs                            |  7 +++++++
 tests/ui/derive_ord_xor_partial_ord.rs         |  5 +++++
 5 files changed, 45 insertions(+)
 create mode 100644 clippy_lints/src/derive_ord_xor_partial_ord.rs
 create mode 100644 tests/ui/derive_ord_xor_partial_ord.rs

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 776b04295f9..a1780725044 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1454,6 +1454,7 @@ Released 2018-09-13
 [`deprecated_semver`]: https://rust-lang.github.io/rust-clippy/master/index.html#deprecated_semver
 [`deref_addrof`]: https://rust-lang.github.io/rust-clippy/master/index.html#deref_addrof
 [`derive_hash_xor_eq`]: https://rust-lang.github.io/rust-clippy/master/index.html#derive_hash_xor_eq
+[`derive_ord_xor_partial_ord`]: https://rust-lang.github.io/rust-clippy/master/index.html#derive_ord_xor_partial_ord
 [`diverging_sub_expression`]: https://rust-lang.github.io/rust-clippy/master/index.html#diverging_sub_expression
 [`doc_markdown`]: https://rust-lang.github.io/rust-clippy/master/index.html#doc_markdown
 [`double_comparisons`]: https://rust-lang.github.io/rust-clippy/master/index.html#double_comparisons
diff --git a/clippy_lints/src/derive_ord_xor_partial_ord.rs b/clippy_lints/src/derive_ord_xor_partial_ord.rs
new file mode 100644
index 00000000000..7913aab6f24
--- /dev/null
+++ b/clippy_lints/src/derive_ord_xor_partial_ord.rs
@@ -0,0 +1,28 @@
+use rustc_lint::{LateLintPass, LateContext};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_hir::*;
+
+declare_clippy_lint! {
+    /// **What it does:**
+    ///
+    /// **Why is this bad?**
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// // example code where clippy issues a warning
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// // example code which does not raise clippy warning
+    /// ```
+    pub DERIVE_ORD_XOR_PARTIAL_ORD,
+    correctness,
+    "default lint description"
+}
+
+declare_lint_pass!(DeriveOrdXorPartialOrd => [DERIVE_ORD_XOR_PARTIAL_ORD]);
+
+impl LateLintPass<'_, '_> for DeriveOrdXorPartialOrd {}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index f371942dbee..6d6dd06cc21 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -173,6 +173,7 @@ mod dbg_macro;
 mod default_trait_access;
 mod dereference;
 mod derive;
+mod derive_ord_xor_partial_ord;
 mod doc;
 mod double_comparison;
 mod double_parens;
@@ -515,6 +516,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &derive::DERIVE_HASH_XOR_EQ,
         &derive::EXPL_IMPL_CLONE_ON_COPY,
         &derive::UNSAFE_DERIVE_DESERIALIZE,
+        &derive_ord_xor_partial_ord::DERIVE_ORD_XOR_PARTIAL_ORD,
         &doc::DOC_MARKDOWN,
         &doc::MISSING_ERRORS_DOC,
         &doc::MISSING_SAFETY_DOC,
@@ -1230,6 +1232,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&copies::IFS_SAME_COND),
         LintId::of(&copies::IF_SAME_THEN_ELSE),
         LintId::of(&derive::DERIVE_HASH_XOR_EQ),
+        LintId::of(&derive_ord_xor_partial_ord::DERIVE_ORD_XOR_PARTIAL_ORD),
         LintId::of(&doc::MISSING_SAFETY_DOC),
         LintId::of(&doc::NEEDLESS_DOCTEST_MAIN),
         LintId::of(&double_comparison::DOUBLE_COMPARISONS),
@@ -1648,6 +1651,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&copies::IFS_SAME_COND),
         LintId::of(&copies::IF_SAME_THEN_ELSE),
         LintId::of(&derive::DERIVE_HASH_XOR_EQ),
+        LintId::of(&derive_ord_xor_partial_ord::DERIVE_ORD_XOR_PARTIAL_ORD),
         LintId::of(&drop_bounds::DROP_BOUNDS),
         LintId::of(&drop_forget_ref::DROP_COPY),
         LintId::of(&drop_forget_ref::DROP_REF),
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index 1879aae77fb..00d3df8f94f 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -360,6 +360,13 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
         deprecation: None,
         module: "derive",
     },
+    Lint {
+        name: "derive_ord_xor_partial_ord",
+        group: "correctness",
+        desc: "default lint description",
+        deprecation: None,
+        module: "derive_ord_xor_partial_ord",
+    },
     Lint {
         name: "diverging_sub_expression",
         group: "complexity",
diff --git a/tests/ui/derive_ord_xor_partial_ord.rs b/tests/ui/derive_ord_xor_partial_ord.rs
new file mode 100644
index 00000000000..63687e7b3db
--- /dev/null
+++ b/tests/ui/derive_ord_xor_partial_ord.rs
@@ -0,0 +1,5 @@
+#![warn(clippy::derive_ord_xor_partial_ord)]
+
+fn main() {
+    // test code goes here
+}
-- 
cgit 1.4.1-3-g733a5


From fc20ee63a105c0df78113126e8749f5958d7dc47 Mon Sep 17 00:00:00 2001
From: Ryan1729 <Ryan1729@gmail.com>
Date: Sun, 26 Jul 2020 20:54:04 -0600
Subject: move derive_ord_xor_partial_ord into derive mod so we can reuse
 derive_hash_xor_partial_eq code later

---
 clippy_lints/src/derive.rs                     | 23 ++++++++++++++++++++-
 clippy_lints/src/derive_ord_xor_partial_ord.rs | 28 --------------------------
 clippy_lints/src/lib.rs                        |  7 +++----
 src/lintlist/mod.rs                            |  2 +-
 4 files changed, 26 insertions(+), 34 deletions(-)
 delete mode 100644 clippy_lints/src/derive_ord_xor_partial_ord.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/derive.rs b/clippy_lints/src/derive.rs
index 59c62f1ae94..627475ee1d9 100644
--- a/clippy_lints/src/derive.rs
+++ b/clippy_lints/src/derive.rs
@@ -43,6 +43,27 @@ declare_clippy_lint! {
     "deriving `Hash` but implementing `PartialEq` explicitly"
 }
 
+declare_clippy_lint! {
+    /// **What it does:**
+    ///
+    /// **Why is this bad?**
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// // example code where clippy issues a warning
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// // example code which does not raise clippy warning
+    /// ```
+    pub DERIVE_ORD_XOR_PARTIAL_ORD,
+    correctness,
+    "default lint description"
+}
+
 declare_clippy_lint! {
     /// **What it does:** Checks for explicit `Clone` implementations for `Copy`
     /// types.
@@ -103,7 +124,7 @@ declare_clippy_lint! {
     "deriving `serde::Deserialize` on a type that has methods using `unsafe`"
 }
 
-declare_lint_pass!(Derive => [EXPL_IMPL_CLONE_ON_COPY, DERIVE_HASH_XOR_EQ, UNSAFE_DERIVE_DESERIALIZE]);
+declare_lint_pass!(Derive => [EXPL_IMPL_CLONE_ON_COPY, DERIVE_HASH_XOR_EQ, DERIVE_ORD_XOR_PARTIAL_ORD, UNSAFE_DERIVE_DESERIALIZE]);
 
 impl<'tcx> LateLintPass<'tcx> for Derive {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
diff --git a/clippy_lints/src/derive_ord_xor_partial_ord.rs b/clippy_lints/src/derive_ord_xor_partial_ord.rs
deleted file mode 100644
index 7913aab6f24..00000000000
--- a/clippy_lints/src/derive_ord_xor_partial_ord.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-use rustc_lint::{LateLintPass, LateContext};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_hir::*;
-
-declare_clippy_lint! {
-    /// **What it does:**
-    ///
-    /// **Why is this bad?**
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
-    /// ```rust
-    /// // example code where clippy issues a warning
-    /// ```
-    /// Use instead:
-    /// ```rust
-    /// // example code which does not raise clippy warning
-    /// ```
-    pub DERIVE_ORD_XOR_PARTIAL_ORD,
-    correctness,
-    "default lint description"
-}
-
-declare_lint_pass!(DeriveOrdXorPartialOrd => [DERIVE_ORD_XOR_PARTIAL_ORD]);
-
-impl LateLintPass<'_, '_> for DeriveOrdXorPartialOrd {}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 6d6dd06cc21..996aad31d3e 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -173,7 +173,6 @@ mod dbg_macro;
 mod default_trait_access;
 mod dereference;
 mod derive;
-mod derive_ord_xor_partial_ord;
 mod doc;
 mod double_comparison;
 mod double_parens;
@@ -514,9 +513,9 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &default_trait_access::DEFAULT_TRAIT_ACCESS,
         &dereference::EXPLICIT_DEREF_METHODS,
         &derive::DERIVE_HASH_XOR_EQ,
+        &derive::DERIVE_ORD_XOR_PARTIAL_ORD,
         &derive::EXPL_IMPL_CLONE_ON_COPY,
         &derive::UNSAFE_DERIVE_DESERIALIZE,
-        &derive_ord_xor_partial_ord::DERIVE_ORD_XOR_PARTIAL_ORD,
         &doc::DOC_MARKDOWN,
         &doc::MISSING_ERRORS_DOC,
         &doc::MISSING_SAFETY_DOC,
@@ -1232,7 +1231,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&copies::IFS_SAME_COND),
         LintId::of(&copies::IF_SAME_THEN_ELSE),
         LintId::of(&derive::DERIVE_HASH_XOR_EQ),
-        LintId::of(&derive_ord_xor_partial_ord::DERIVE_ORD_XOR_PARTIAL_ORD),
+        LintId::of(&derive::DERIVE_ORD_XOR_PARTIAL_ORD),
         LintId::of(&doc::MISSING_SAFETY_DOC),
         LintId::of(&doc::NEEDLESS_DOCTEST_MAIN),
         LintId::of(&double_comparison::DOUBLE_COMPARISONS),
@@ -1651,7 +1650,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&copies::IFS_SAME_COND),
         LintId::of(&copies::IF_SAME_THEN_ELSE),
         LintId::of(&derive::DERIVE_HASH_XOR_EQ),
-        LintId::of(&derive_ord_xor_partial_ord::DERIVE_ORD_XOR_PARTIAL_ORD),
+        LintId::of(&derive::DERIVE_ORD_XOR_PARTIAL_ORD),
         LintId::of(&drop_bounds::DROP_BOUNDS),
         LintId::of(&drop_forget_ref::DROP_COPY),
         LintId::of(&drop_forget_ref::DROP_REF),
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index 00d3df8f94f..011504710e1 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -365,7 +365,7 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
         group: "correctness",
         desc: "default lint description",
         deprecation: None,
-        module: "derive_ord_xor_partial_ord",
+        module: "derive",
     },
     Lint {
         name: "diverging_sub_expression",
-- 
cgit 1.4.1-3-g733a5


From 068acbd27b19a4a7be3a9d00954ecfad8a0e6553 Mon Sep 17 00:00:00 2001
From: Ryan1729 <Ryan1729@gmail.com>
Date: Sun, 26 Jul 2020 22:04:46 -0600
Subject: initial implementation based on code for `derive_hash_xor_partial_eq`
 which is showing one error when there should be four

---
 clippy_lints/src/derive.rs | 55 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 55 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/derive.rs b/clippy_lints/src/derive.rs
index 627475ee1d9..4f69c2d7af7 100644
--- a/clippy_lints/src/derive.rs
+++ b/clippy_lints/src/derive.rs
@@ -137,6 +137,7 @@ impl<'tcx> LateLintPass<'tcx> for Derive {
             let is_automatically_derived = is_automatically_derived(&*item.attrs);
 
             check_hash_peq(cx, item.span, trait_ref, ty, is_automatically_derived);
+            check_ord_pord(cx, item.span, trait_ref, ty, is_automatically_derived);
 
             if is_automatically_derived {
                 check_unsafe_derive_deserialize(cx, item, trait_ref, ty);
@@ -201,6 +202,60 @@ fn check_hash_peq<'tcx>(
     }
 }
 
+/// Implementation of the `DERIVE_ORD_XOR_PARTIAL_ORD` lint.
+fn check_ord_pord<'tcx>(
+    cx: &LateContext<'tcx>,
+    span: Span,
+    trait_ref: &TraitRef<'_>,
+    ty: Ty<'tcx>,
+    ord_is_automatically_derived: bool,
+) {
+    if_chain! {
+        if match_path(&trait_ref.path, &paths::ORD);
+        if let Some(pord_trait_def_id) = cx.tcx.lang_items().partial_ord_trait();
+        if let Some(def_id) = &trait_ref.trait_def_id();
+        if !def_id.is_local();
+        then {
+            // Look for the PartialOrd implementations for `ty`
+            cx.tcx.for_each_relevant_impl(pord_trait_def_id, ty, |impl_id| {
+                let pord_is_automatically_derived = is_automatically_derived(&cx.tcx.get_attrs(impl_id));
+
+                if pord_is_automatically_derived == ord_is_automatically_derived {
+                    return;
+                }
+
+                let trait_ref = cx.tcx.impl_trait_ref(impl_id).expect("must be a trait implementation");
+
+                // Only care about `impl PartialOrd<Foo> for Foo`
+                // For `impl PartialOrd<B> for A, input_types is [A, B]
+                if trait_ref.substs.type_at(1) == ty {
+                    let mess = if pord_is_automatically_derived {
+                        "you are implementing `Ord` explicitly but have derived `PartialOrd`"
+                    } else {
+                        "you are deriving `Ord` but have implemented `PartialOrd` explicitly"
+                    };
+
+                    span_lint_and_then(
+                        cx,
+                        DERIVE_ORD_XOR_PARTIAL_ORD,
+                        span,
+                        mess,
+                        |diag| {
+                            if let Some(local_def_id) = impl_id.as_local() {
+                                let hir_id = cx.tcx.hir().as_local_hir_id(local_def_id);
+                                diag.span_note(
+                                    cx.tcx.hir().span(hir_id),
+                                    "`PartialOrd` implemented here"
+                                );
+                            }
+                        }
+                    );
+                }
+            });
+        }
+    }
+}
+
 /// Implementation of the `EXPL_IMPL_CLONE_ON_COPY` lint.
 fn check_copy_clone<'tcx>(cx: &LateContext<'tcx>, item: &Item<'_>, trait_ref: &TraitRef<'_>, ty: Ty<'tcx>) {
     if match_path(&trait_ref.path, &paths::CLONE_TRAIT) {
-- 
cgit 1.4.1-3-g733a5


From a8d6eda93049f0077c1515bec35fe0359ea43f96 Mon Sep 17 00:00:00 2001
From: Ryan1729 <Ryan1729@gmail.com>
Date: Sun, 26 Jul 2020 23:04:04 -0600
Subject: use get_trait_def_id to check for Ord trait

---
 clippy_lints/src/derive.rs | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/derive.rs b/clippy_lints/src/derive.rs
index 4f69c2d7af7..04395621e9e 100644
--- a/clippy_lints/src/derive.rs
+++ b/clippy_lints/src/derive.rs
@@ -1,6 +1,6 @@
 use crate::utils::paths;
 use crate::utils::{
-    is_automatically_derived, is_copy, match_path, span_lint_and_help, span_lint_and_note, span_lint_and_then,
+    get_trait_def_id, is_automatically_derived, is_copy, match_path, span_lint_and_help, span_lint_and_note, span_lint_and_then,
 };
 use if_chain::if_chain;
 use rustc_hir::def_id::DefId;
@@ -211,9 +211,10 @@ fn check_ord_pord<'tcx>(
     ord_is_automatically_derived: bool,
 ) {
     if_chain! {
-        if match_path(&trait_ref.path, &paths::ORD);
+        if let Some(ord_trait_def_id) = get_trait_def_id(cx, &paths::ORD);
         if let Some(pord_trait_def_id) = cx.tcx.lang_items().partial_ord_trait();
         if let Some(def_id) = &trait_ref.trait_def_id();
+        if *def_id == ord_trait_def_id;
         if !def_id.is_local();
         then {
             // Look for the PartialOrd implementations for `ty`
-- 
cgit 1.4.1-3-g733a5


From 7dc974815ec8736f026dc10a070137e0d4601d52 Mon Sep 17 00:00:00 2001
From: Ryan1729 <Ryan1729@gmail.com>
Date: Sun, 26 Jul 2020 23:06:36 -0600
Subject: remove is_local check since getting the def_id directly makes it
 unnecessary

---
 clippy_lints/src/derive.rs | 1 -
 1 file changed, 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/derive.rs b/clippy_lints/src/derive.rs
index 04395621e9e..ab001f7773e 100644
--- a/clippy_lints/src/derive.rs
+++ b/clippy_lints/src/derive.rs
@@ -215,7 +215,6 @@ fn check_ord_pord<'tcx>(
         if let Some(pord_trait_def_id) = cx.tcx.lang_items().partial_ord_trait();
         if let Some(def_id) = &trait_ref.trait_def_id();
         if *def_id == ord_trait_def_id;
-        if !def_id.is_local();
         then {
             // Look for the PartialOrd implementations for `ty`
             cx.tcx.for_each_relevant_impl(pord_trait_def_id, ty, |impl_id| {
-- 
cgit 1.4.1-3-g733a5


From 431924ccf69bc4d4f0597f12749e8b1bcb285710 Mon Sep 17 00:00:00 2001
From: Ryan1729 <Ryan1729@gmail.com>
Date: Sun, 26 Jul 2020 23:15:36 -0600
Subject: add description for derive_ord_xor_partial_ord

---
 clippy_lints/src/derive.rs | 42 ++++++++++++++++++++++++++++++++++++------
 1 file changed, 36 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/derive.rs b/clippy_lints/src/derive.rs
index ab001f7773e..84566252abd 100644
--- a/clippy_lints/src/derive.rs
+++ b/clippy_lints/src/derive.rs
@@ -44,20 +44,50 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:**
+    /// **What it does:** Checks for deriving `Ord` but implementing `PartialOrd`
+    /// explicitly or vice versa.
+    ///
+    /// **Why is this bad?** The implementation of these traits must agree (for
+    /// example for use with `sort`) so it’s probably a bad idea to use a
+    /// default-generated `Ord` implementation with an explicitly defined
+    /// `PartialOrd`. In particular, the following must hold for any type
+    /// implementing `Ord`:
     ///
-    /// **Why is this bad?**
+    /// ```text
+    /// k1.cmp(&k2) == k1.partial_cmp(&k2).unwrap()
+    /// ```
     ///
     /// **Known problems:** None.
     ///
     /// **Example:**
     ///
-    /// ```rust
-    /// // example code where clippy issues a warning
+    /// ```rust,ignore
+    /// #[derive(Ord, PartialEq, Eq)]
+    /// struct Foo;
+    ///
+    /// impl PartialOrd for Foo {
+    ///     ...
+    /// }
     /// ```
     /// Use instead:
-    /// ```rust
-    /// // example code which does not raise clippy warning
+    /// ```rust,ignore
+    /// #[derive(PartialEq, Eq)]
+    /// struct Foo;
+    ///
+    /// impl PartialOrd for Foo {
+    ///     fn partial_cmp(&self, other: &Foo) -> Option<Ordering> {
+    ///        Some(self.cmp(other))
+    ///     }
+    /// }
+    ///
+    /// impl Ord for Foo {
+    ///     ...
+    /// }
+    /// ```
+    /// or, if you don't need a custom ordering:
+    /// ```rust,ignore
+    /// #[derive(Ord, PartialOrd, PartialEq, Eq)]
+    /// struct Foo;
     /// ```
     pub DERIVE_ORD_XOR_PARTIAL_ORD,
     correctness,
-- 
cgit 1.4.1-3-g733a5


From 668b7474b47791c8c9af10130356b681b3bf3a84 Mon Sep 17 00:00:00 2001
From: Ryan1729 <Ryan1729@gmail.com>
Date: Sun, 26 Jul 2020 23:30:00 -0600
Subject: run cargo dev fmt and fix overly long line

---
 clippy_lints/src/derive.rs             | 10 ++++++++--
 tests/ui/derive_ord_xor_partial_ord.rs |  2 +-
 2 files changed, 9 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/derive.rs b/clippy_lints/src/derive.rs
index 84566252abd..16a6f0c20e1 100644
--- a/clippy_lints/src/derive.rs
+++ b/clippy_lints/src/derive.rs
@@ -1,6 +1,7 @@
 use crate::utils::paths;
 use crate::utils::{
-    get_trait_def_id, is_automatically_derived, is_copy, match_path, span_lint_and_help, span_lint_and_note, span_lint_and_then,
+    get_trait_def_id, is_automatically_derived, is_copy, match_path, span_lint_and_help, span_lint_and_note,
+    span_lint_and_then,
 };
 use if_chain::if_chain;
 use rustc_hir::def_id::DefId;
@@ -154,7 +155,12 @@ declare_clippy_lint! {
     "deriving `serde::Deserialize` on a type that has methods using `unsafe`"
 }
 
-declare_lint_pass!(Derive => [EXPL_IMPL_CLONE_ON_COPY, DERIVE_HASH_XOR_EQ, DERIVE_ORD_XOR_PARTIAL_ORD, UNSAFE_DERIVE_DESERIALIZE]);
+declare_lint_pass!(Derive => [
+    EXPL_IMPL_CLONE_ON_COPY,
+    DERIVE_HASH_XOR_EQ,
+    DERIVE_ORD_XOR_PARTIAL_ORD,
+    UNSAFE_DERIVE_DESERIALIZE
+]);
 
 impl<'tcx> LateLintPass<'tcx> for Derive {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
diff --git a/tests/ui/derive_ord_xor_partial_ord.rs b/tests/ui/derive_ord_xor_partial_ord.rs
index 15f66b7a9c5..b82dc518a3b 100644
--- a/tests/ui/derive_ord_xor_partial_ord.rs
+++ b/tests/ui/derive_ord_xor_partial_ord.rs
@@ -65,4 +65,4 @@ mod use_ord {
     }
 }
 
-fn main() {}
\ No newline at end of file
+fn main() {}
-- 
cgit 1.4.1-3-g733a5


From ca03f2b650a022d06df6c02c8947a74944815381 Mon Sep 17 00:00:00 2001
From: Ryan1729 <Ryan1729@gmail.com>
Date: Mon, 27 Jul 2020 00:21:11 -0600
Subject: s/pord/partial_ord/ to fix dogfood failure

---
 clippy_lints/src/derive.rs | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/derive.rs b/clippy_lints/src/derive.rs
index 16a6f0c20e1..820ce85cff2 100644
--- a/clippy_lints/src/derive.rs
+++ b/clippy_lints/src/derive.rs
@@ -173,7 +173,7 @@ impl<'tcx> LateLintPass<'tcx> for Derive {
             let is_automatically_derived = is_automatically_derived(&*item.attrs);
 
             check_hash_peq(cx, item.span, trait_ref, ty, is_automatically_derived);
-            check_ord_pord(cx, item.span, trait_ref, ty, is_automatically_derived);
+            check_ord_partial_ord(cx, item.span, trait_ref, ty, is_automatically_derived);
 
             if is_automatically_derived {
                 check_unsafe_derive_deserialize(cx, item, trait_ref, ty);
@@ -239,7 +239,7 @@ fn check_hash_peq<'tcx>(
 }
 
 /// Implementation of the `DERIVE_ORD_XOR_PARTIAL_ORD` lint.
-fn check_ord_pord<'tcx>(
+fn check_ord_partial_ord<'tcx>(
     cx: &LateContext<'tcx>,
     span: Span,
     trait_ref: &TraitRef<'_>,
@@ -248,15 +248,15 @@ fn check_ord_pord<'tcx>(
 ) {
     if_chain! {
         if let Some(ord_trait_def_id) = get_trait_def_id(cx, &paths::ORD);
-        if let Some(pord_trait_def_id) = cx.tcx.lang_items().partial_ord_trait();
+        if let Some(partial_ord_trait_def_id) = cx.tcx.lang_items().partial_ord_trait();
         if let Some(def_id) = &trait_ref.trait_def_id();
         if *def_id == ord_trait_def_id;
         then {
             // Look for the PartialOrd implementations for `ty`
-            cx.tcx.for_each_relevant_impl(pord_trait_def_id, ty, |impl_id| {
-                let pord_is_automatically_derived = is_automatically_derived(&cx.tcx.get_attrs(impl_id));
+            cx.tcx.for_each_relevant_impl(partial_ord_trait_def_id, ty, |impl_id| {
+                let partial_ord_is_automatically_derived = is_automatically_derived(&cx.tcx.get_attrs(impl_id));
 
-                if pord_is_automatically_derived == ord_is_automatically_derived {
+                if partial_ord_is_automatically_derived == ord_is_automatically_derived {
                     return;
                 }
 
@@ -265,7 +265,7 @@ fn check_ord_pord<'tcx>(
                 // Only care about `impl PartialOrd<Foo> for Foo`
                 // For `impl PartialOrd<B> for A, input_types is [A, B]
                 if trait_ref.substs.type_at(1) == ty {
-                    let mess = if pord_is_automatically_derived {
+                    let mess = if partial_ord_is_automatically_derived {
                         "you are implementing `Ord` explicitly but have derived `PartialOrd`"
                     } else {
                         "you are deriving `Ord` but have implemented `PartialOrd` explicitly"
-- 
cgit 1.4.1-3-g733a5


From 12a6eee045f30785a1eb7572a4cfea3c5cec8a4c Mon Sep 17 00:00:00 2001
From: Ryan1729 <Ryan1729@gmail.com>
Date: Mon, 27 Jul 2020 00:22:39 -0600
Subject: fill in lint description for DERIVE_ORD_XOR_PARTIAL_ORD

---
 clippy_lints/src/derive.rs | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/derive.rs b/clippy_lints/src/derive.rs
index 820ce85cff2..cdb748de0c0 100644
--- a/clippy_lints/src/derive.rs
+++ b/clippy_lints/src/derive.rs
@@ -1,7 +1,6 @@
 use crate::utils::paths;
 use crate::utils::{
-    get_trait_def_id, is_automatically_derived, is_copy, match_path, span_lint_and_help, span_lint_and_note,
-    span_lint_and_then,
+    get_trait_def_id, is_automatically_derived, is_copy, match_path, span_lint_and_help, span_lint_and_note, span_lint_and_then,
 };
 use if_chain::if_chain;
 use rustc_hir::def_id::DefId;
@@ -92,7 +91,7 @@ declare_clippy_lint! {
     /// ```
     pub DERIVE_ORD_XOR_PARTIAL_ORD,
     correctness,
-    "default lint description"
+    "deriving `Ord` but implementing `PartialOrd` explicitly"
 }
 
 declare_clippy_lint! {
-- 
cgit 1.4.1-3-g733a5


From 94b10a6e5ab003a03b6c7b60ffe5a3b366e0529a Mon Sep 17 00:00:00 2001
From: Ryan1729 <Ryan1729@gmail.com>
Date: Mon, 27 Jul 2020 00:31:09 -0600
Subject: run cargo dev update_lints

---
 clippy_lints/src/derive.rs | 3 ++-
 src/lintlist/mod.rs        | 2 +-
 2 files changed, 3 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/derive.rs b/clippy_lints/src/derive.rs
index cdb748de0c0..08d8100a885 100644
--- a/clippy_lints/src/derive.rs
+++ b/clippy_lints/src/derive.rs
@@ -1,6 +1,7 @@
 use crate::utils::paths;
 use crate::utils::{
-    get_trait_def_id, is_automatically_derived, is_copy, match_path, span_lint_and_help, span_lint_and_note, span_lint_and_then,
+    get_trait_def_id, is_automatically_derived, is_copy, match_path, span_lint_and_help, span_lint_and_note,
+    span_lint_and_then,
 };
 use if_chain::if_chain;
 use rustc_hir::def_id::DefId;
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index 011504710e1..119908b3cc4 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -363,7 +363,7 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
     Lint {
         name: "derive_ord_xor_partial_ord",
         group: "correctness",
-        desc: "default lint description",
+        desc: "deriving `Ord` but implementing `PartialOrd` explicitly",
         deprecation: None,
         module: "derive",
     },
-- 
cgit 1.4.1-3-g733a5


From 3a9ccffed8c5329e3fda67c2e310086ba261e15f Mon Sep 17 00:00:00 2001
From: Takayuki Nakata <f.seasons017@gmail.com>
Date: Mon, 27 Jul 2020 22:27:54 +0900
Subject: `chmod` 644 `clippy_lints/src/utils/ast_utils.rs`

---
 clippy_lints/src/utils/ast_utils.rs | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 mode change 100755 => 100644 clippy_lints/src/utils/ast_utils.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/ast_utils.rs b/clippy_lints/src/utils/ast_utils.rs
old mode 100755
new mode 100644
-- 
cgit 1.4.1-3-g733a5


From 94c50bc8c913ef58eba0f4f10b682dcf6d6e0991 Mon Sep 17 00:00:00 2001
From: Christoph Walcher <christoph-wa@gmx.de>
Date: Tue, 28 Jul 2020 16:23:47 +0200
Subject: Lint duplicate methods of trait bounds

Fixes #5777
---
 CHANGELOG.md                                |  1 +
 clippy_lints/src/lib.rs                     |  2 +
 clippy_lints/src/trait_bounds.rs            | 94 ++++++++++++++++++++++++++++-
 src/lintlist/mod.rs                         |  7 +++
 tests/ui/trait_duplication_in_bounds.rs     | 31 ++++++++++
 tests/ui/trait_duplication_in_bounds.stderr | 23 +++++++
 6 files changed, 156 insertions(+), 2 deletions(-)
 create mode 100644 tests/ui/trait_duplication_in_bounds.rs
 create mode 100644 tests/ui/trait_duplication_in_bounds.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 776b04295f9..0ca4d88ed38 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1723,6 +1723,7 @@ Released 2018-09-13
 [`too_many_arguments`]: https://rust-lang.github.io/rust-clippy/master/index.html#too_many_arguments
 [`too_many_lines`]: https://rust-lang.github.io/rust-clippy/master/index.html#too_many_lines
 [`toplevel_ref_arg`]: https://rust-lang.github.io/rust-clippy/master/index.html#toplevel_ref_arg
+[`trait_duplication_in_bounds`]: https://rust-lang.github.io/rust-clippy/master/index.html#trait_duplication_in_bounds
 [`transmute_bytes_to_str`]: https://rust-lang.github.io/rust-clippy/master/index.html#transmute_bytes_to_str
 [`transmute_float_to_int`]: https://rust-lang.github.io/rust-clippy/master/index.html#transmute_float_to_int
 [`transmute_int_to_bool`]: https://rust-lang.github.io/rust-clippy/master/index.html#transmute_int_to_bool
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index f371942dbee..07ef087c2b0 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -786,6 +786,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &tabs_in_doc_comments::TABS_IN_DOC_COMMENTS,
         &temporary_assignment::TEMPORARY_ASSIGNMENT,
         &to_digit_is_some::TO_DIGIT_IS_SOME,
+        &trait_bounds::TRAIT_DUPLICATION_IN_BOUNDS,
         &trait_bounds::TYPE_REPETITION_IN_BOUNDS,
         &transmute::CROSSPOINTER_TRANSMUTE,
         &transmute::TRANSMUTE_BYTES_TO_STR,
@@ -1174,6 +1175,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&ranges::RANGE_PLUS_ONE),
         LintId::of(&shadow::SHADOW_UNRELATED),
         LintId::of(&strings::STRING_ADD_ASSIGN),
+        LintId::of(&trait_bounds::TRAIT_DUPLICATION_IN_BOUNDS),
         LintId::of(&trait_bounds::TYPE_REPETITION_IN_BOUNDS),
         LintId::of(&trivially_copy_pass_by_ref::TRIVIALLY_COPY_PASS_BY_REF),
         LintId::of(&types::CAST_LOSSLESS),
diff --git a/clippy_lints/src/trait_bounds.rs b/clippy_lints/src/trait_bounds.rs
index 0ef70311fb1..6bfdac37180 100644
--- a/clippy_lints/src/trait_bounds.rs
+++ b/clippy_lints/src/trait_bounds.rs
@@ -2,9 +2,10 @@ use crate::utils::{in_macro, snippet, snippet_with_applicability, span_lint_and_
 use if_chain::if_chain;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::Applicability;
-use rustc_hir::{GenericBound, Generics, WherePredicate};
+use rustc_hir::{def::Res, GenericBound, Generics, ParamName, Path, QPath, TyKind, WherePredicate};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::Span;
 
 declare_clippy_lint! {
     /// **What it does:** This lint warns about unnecessary type repetitions in trait bounds
@@ -29,6 +30,35 @@ declare_clippy_lint! {
     "Types are repeated unnecessary in trait bounds use `+` instead of using `T: _, T: _`"
 }
 
+declare_clippy_lint! {
+    /// **What it does:** Checks for cases where generics are being used and multiple
+    /// syntax specifications for trait bounds are used simultaneously.
+    ///
+    /// **Why is this bad?** Duplicate bounds makes the code
+    /// less readable than specifing them only once.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// ```rust
+    /// fn func<T: Clone + Default>(arg: T) where T: Clone + Default {}
+    /// ```
+    ///
+    /// Could be written as:
+    ///
+    /// ```rust
+    /// fn func<T: Clone + Default>(arg: T) {}
+    /// ```
+    /// or
+    ///  ///
+    /// ```rust
+    /// fn func<T>(arg: T) where T: Clone + Default {}
+    /// ```
+    pub TRAIT_DUPLICATION_IN_BOUNDS,
+    pedantic,
+    "Check if the same trait bounds are specifed twice during a function declaration"
+}
+
 #[derive(Copy, Clone)]
 pub struct TraitBounds {
     max_trait_bounds: u64,
@@ -41,10 +71,25 @@ impl TraitBounds {
     }
 }
 
-impl_lint_pass!(TraitBounds => [TYPE_REPETITION_IN_BOUNDS]);
+impl_lint_pass!(TraitBounds => [TYPE_REPETITION_IN_BOUNDS, TRAIT_DUPLICATION_IN_BOUNDS]);
 
 impl<'tcx> LateLintPass<'tcx> for TraitBounds {
     fn check_generics(&mut self, cx: &LateContext<'tcx>, gen: &'tcx Generics<'_>) {
+        self.check_type_repetition(cx, gen);
+        check_trait_bound_duplication(cx, gen);
+    }
+}
+
+fn get_trait_res_span_from_bound(bound: &GenericBound<'_>) -> Option<(Res, Span)> {
+    if let GenericBound::Trait(t, _) = bound {
+        Some((t.trait_ref.path.res, t.span))
+    } else {
+        None
+    }
+}
+
+impl TraitBounds {
+    fn check_type_repetition(self, cx: &LateContext<'_>, gen: &'_ Generics<'_>) {
         if in_macro(gen.span) {
             return;
         }
@@ -101,3 +146,48 @@ impl<'tcx> LateLintPass<'tcx> for TraitBounds {
         }
     }
 }
+
+fn check_trait_bound_duplication(cx: &LateContext<'_>, gen: &'_ Generics<'_>) {
+    if in_macro(gen.span) {
+        return;
+    }
+
+    let mut map = FxHashMap::default();
+    for param in gen.params {
+        if let ParamName::Plain(ref ident) = param.name {
+            let res = param
+                .bounds
+                .iter()
+                .filter_map(get_trait_res_span_from_bound)
+                .collect::<Vec<_>>();
+            map.insert(*ident, res);
+        }
+    }
+
+    for predicate in gen.where_clause.predicates {
+        if_chain! {
+            if let WherePredicate::BoundPredicate(ref bound_predicate) = predicate;
+            if !in_macro(bound_predicate.span);
+            if let TyKind::Path(ref path) = bound_predicate.bounded_ty.kind;
+            if let QPath::Resolved(_, Path { ref segments, .. }) = path;
+            if let Some(segment) = segments.first();
+            if let Some(trait_resolutions_direct) = map.get(&segment.ident);
+            then {
+                for (res_where, _) in bound_predicate.bounds.iter().filter_map(get_trait_res_span_from_bound) {
+                    if let Some((_, span_direct)) = trait_resolutions_direct
+                                                .iter()
+                                                .find(|(res_direct, _)| *res_direct == res_where) {
+                        span_lint_and_help(
+                            cx,
+                            TRAIT_DUPLICATION_IN_BOUNDS,
+                            *span_direct,
+                            "this trait bound is already specified in the where clause",
+                            None,
+                            "consider removing this trait bound",
+                        );
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index 1879aae77fb..9fb3dfc96ec 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -2166,6 +2166,13 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
         deprecation: None,
         module: "misc",
     },
+    Lint {
+        name: "trait_duplication_in_bounds",
+        group: "pedantic",
+        desc: "Check if the same trait bounds are specifed twice during a function declaration",
+        deprecation: None,
+        module: "trait_bounds",
+    },
     Lint {
         name: "transmute_bytes_to_str",
         group: "complexity",
diff --git a/tests/ui/trait_duplication_in_bounds.rs b/tests/ui/trait_duplication_in_bounds.rs
new file mode 100644
index 00000000000..cb2b0054e35
--- /dev/null
+++ b/tests/ui/trait_duplication_in_bounds.rs
@@ -0,0 +1,31 @@
+#![deny(clippy::trait_duplication_in_bounds)]
+
+use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Sub, SubAssign};
+
+fn bad_foo<T: Clone + Default, Z: Copy>(arg0: T, arg1: Z)
+where
+    T: Clone,
+    T: Default,
+{
+    unimplemented!();
+}
+
+fn good_bar<T: Clone + Default>(arg: T) {
+    unimplemented!();
+}
+
+fn good_foo<T>(arg: T)
+where
+    T: Clone + Default,
+{
+    unimplemented!();
+}
+
+fn good_foobar<T: Default>(arg: T)
+where
+    T: Clone,
+{
+    unimplemented!();
+}
+
+fn main() {}
diff --git a/tests/ui/trait_duplication_in_bounds.stderr b/tests/ui/trait_duplication_in_bounds.stderr
new file mode 100644
index 00000000000..027e1c75204
--- /dev/null
+++ b/tests/ui/trait_duplication_in_bounds.stderr
@@ -0,0 +1,23 @@
+error: this trait bound is already specified in the where clause
+  --> $DIR/trait_duplication_in_bounds.rs:5:15
+   |
+LL | fn bad_foo<T: Clone + Default, Z: Copy>(arg0: T, arg1: Z)
+   |               ^^^^^
+   |
+note: the lint level is defined here
+  --> $DIR/trait_duplication_in_bounds.rs:1:9
+   |
+LL | #![deny(clippy::trait_duplication_in_bounds)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   = help: consider removing this trait bound
+
+error: this trait bound is already specified in the where clause
+  --> $DIR/trait_duplication_in_bounds.rs:5:23
+   |
+LL | fn bad_foo<T: Clone + Default, Z: Copy>(arg0: T, arg1: Z)
+   |                       ^^^^^^^
+   |
+   = help: consider removing this trait bound
+
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 2b7fde6a4b18ee837342f5b50a4c4941e919177f Mon Sep 17 00:00:00 2001
From: Christoph Walcher <christoph-wa@gmx.de>
Date: Wed, 29 Jul 2020 16:10:15 +0200
Subject: typo fix

---
 clippy_lints/src/trait_bounds.rs | 2 +-
 src/lintlist/mod.rs              | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/trait_bounds.rs b/clippy_lints/src/trait_bounds.rs
index 6bfdac37180..10811374875 100644
--- a/clippy_lints/src/trait_bounds.rs
+++ b/clippy_lints/src/trait_bounds.rs
@@ -56,7 +56,7 @@ declare_clippy_lint! {
     /// ```
     pub TRAIT_DUPLICATION_IN_BOUNDS,
     pedantic,
-    "Check if the same trait bounds are specifed twice during a function declaration"
+    "Check if the same trait bounds are specified twice during a function declaration"
 }
 
 #[derive(Copy, Clone)]
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index 9fb3dfc96ec..197eab759f1 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -2169,7 +2169,7 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
     Lint {
         name: "trait_duplication_in_bounds",
         group: "pedantic",
-        desc: "Check if the same trait bounds are specifed twice during a function declaration",
+        desc: "Check if the same trait bounds are specified twice during a function declaration",
         deprecation: None,
         module: "trait_bounds",
     },
-- 
cgit 1.4.1-3-g733a5


From a427c99f3d2a0b2c55d19af73bcad81f1dc761ab Mon Sep 17 00:00:00 2001
From: Dmitry Murzin <diralik@yandex.ru>
Date: Sat, 25 Jul 2020 20:04:59 +0300
Subject: Handle mapping to Option in `map_flatten` lint

---
 clippy_lints/src/methods/mod.rs | 26 ++++++++++++++++++++++----
 tests/ui/map_flatten.fixed      |  1 +
 tests/ui/map_flatten.rs         |  1 +
 tests/ui/map_flatten.stderr     | 16 +++++++++++-----
 4 files changed, 35 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 9edcdd979ff..3f62a3cab1c 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -2569,17 +2569,35 @@ fn lint_ok_expect(cx: &LateContext<'_>, expr: &hir::Expr<'_>, ok_args: &[hir::Ex
 fn lint_map_flatten<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, map_args: &'tcx [hir::Expr<'_>]) {
     // lint if caller of `.map().flatten()` is an Iterator
     if match_trait_method(cx, expr, &paths::ITERATOR) {
-        let msg = "called `map(..).flatten()` on an `Iterator`. \
-                    This is more succinctly expressed by calling `.flat_map(..)`";
+        let map_closure_ty = cx.typeck_results().expr_ty(&map_args[1]);
+        let is_map_to_option = if let ty::Closure(_def_id, substs) = map_closure_ty.kind {
+            let map_closure_return_ty = cx.tcx.erase_late_bound_regions(&substs.as_closure().sig().output());
+            is_type_diagnostic_item(cx, map_closure_return_ty, sym!(option_type))
+        } else {
+            false
+        };
+
+        let method_to_use = if is_map_to_option {
+            // `(...).map(...)` has type `impl Iterator<Item=Option<...>>
+            "filter_map"
+        } else {
+            // `(...).map(...)` has type `impl Iterator<Item=impl Iterator<...>>
+            "flat_map"
+        };
+        let msg = &format!(
+            "called `map(..).flatten()` on an `Iterator`. \
+                   This is more succinctly expressed by calling `.{}(..)`",
+            method_to_use
+        );
         let self_snippet = snippet(cx, map_args[0].span, "..");
         let func_snippet = snippet(cx, map_args[1].span, "..");
-        let hint = format!("{0}.flat_map({1})", self_snippet, func_snippet);
+        let hint = format!("{0}.{1}({2})", self_snippet, method_to_use, func_snippet);
         span_lint_and_sugg(
             cx,
             MAP_FLATTEN,
             expr.span,
             msg,
-            "try using `flat_map` instead",
+            &format!("try using `{}` instead", method_to_use),
             hint,
             Applicability::MachineApplicable,
         );
diff --git a/tests/ui/map_flatten.fixed b/tests/ui/map_flatten.fixed
index 4171d80f48a..684a28aebcb 100644
--- a/tests/ui/map_flatten.fixed
+++ b/tests/ui/map_flatten.fixed
@@ -5,6 +5,7 @@
 #![allow(clippy::map_identity)]
 
 fn main() {
+    let _: Vec<_> = vec![5_i8; 6].into_iter().filter_map(|x| x.checked_add(1)).collect();
     let _: Vec<_> = vec![5_i8; 6].into_iter().flat_map(|x| 0..x).collect();
     let _: Option<_> = (Some(Some(1))).and_then(|x| x);
 }
diff --git a/tests/ui/map_flatten.rs b/tests/ui/map_flatten.rs
index 16a0fd090ad..05789ee5232 100644
--- a/tests/ui/map_flatten.rs
+++ b/tests/ui/map_flatten.rs
@@ -5,6 +5,7 @@
 #![allow(clippy::map_identity)]
 
 fn main() {
+    let _: Vec<_> = vec![5_i8; 6].into_iter().map(|x| x.checked_add(1)).flatten().collect();
     let _: Vec<_> = vec![5_i8; 6].into_iter().map(|x| 0..x).flatten().collect();
     let _: Option<_> = (Some(Some(1))).map(|x| x).flatten();
 }
diff --git a/tests/ui/map_flatten.stderr b/tests/ui/map_flatten.stderr
index 00bc41c15e9..d2d15362a6c 100644
--- a/tests/ui/map_flatten.stderr
+++ b/tests/ui/map_flatten.stderr
@@ -1,16 +1,22 @@
-error: called `map(..).flatten()` on an `Iterator`. This is more succinctly expressed by calling `.flat_map(..)`
+error: called `map(..).flatten()` on an `Iterator`. This is more succinctly expressed by calling `.filter_map(..)`
   --> $DIR/map_flatten.rs:8:21
    |
-LL |     let _: Vec<_> = vec![5_i8; 6].into_iter().map(|x| 0..x).flatten().collect();
-   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try using `flat_map` instead: `vec![5_i8; 6].into_iter().flat_map(|x| 0..x)`
+LL |     let _: Vec<_> = vec![5_i8; 6].into_iter().map(|x| x.checked_add(1)).flatten().collect();
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try using `filter_map` instead: `vec![5_i8; 6].into_iter().filter_map(|x| x.checked_add(1))`
    |
    = note: `-D clippy::map-flatten` implied by `-D warnings`
 
+error: called `map(..).flatten()` on an `Iterator`. This is more succinctly expressed by calling `.flat_map(..)`
+  --> $DIR/map_flatten.rs:9:21
+   |
+LL |     let _: Vec<_> = vec![5_i8; 6].into_iter().map(|x| 0..x).flatten().collect();
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try using `flat_map` instead: `vec![5_i8; 6].into_iter().flat_map(|x| 0..x)`
+
 error: called `map(..).flatten()` on an `Option`. This is more succinctly expressed by calling `.and_then(..)`
-  --> $DIR/map_flatten.rs:9:24
+  --> $DIR/map_flatten.rs:10:24
    |
 LL |     let _: Option<_> = (Some(Some(1))).map(|x| x).flatten();
    |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try using `and_then` instead: `(Some(Some(1))).and_then(|x| x)`
 
-error: aborting due to 2 previous errors
+error: aborting due to 3 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From d4ba561aafb501972f581c1f8e6d1885959f9306 Mon Sep 17 00:00:00 2001
From: Dmitry Murzin <diralik@yandex.ru>
Date: Thu, 30 Jul 2020 22:20:31 +0300
Subject: Review fixes

---
 clippy_lints/src/methods/mod.rs | 36 ++++++++++++++++--------------------
 tests/ui/map_flatten.fixed      | 13 +++++++++++++
 tests/ui/map_flatten.rs         | 13 +++++++++++++
 tests/ui/map_flatten.stderr     | 40 +++++++++++++++++++++++++++++-----------
 4 files changed, 71 insertions(+), 31 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 3f62a3cab1c..9217324b18c 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -2570,11 +2570,16 @@ fn lint_map_flatten<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, map
     // lint if caller of `.map().flatten()` is an Iterator
     if match_trait_method(cx, expr, &paths::ITERATOR) {
         let map_closure_ty = cx.typeck_results().expr_ty(&map_args[1]);
-        let is_map_to_option = if let ty::Closure(_def_id, substs) = map_closure_ty.kind {
-            let map_closure_return_ty = cx.tcx.erase_late_bound_regions(&substs.as_closure().sig().output());
-            is_type_diagnostic_item(cx, map_closure_return_ty, sym!(option_type))
-        } else {
-            false
+        let is_map_to_option = match map_closure_ty.kind {
+            ty::Closure(_, _) | ty::FnDef(_, _) | ty::FnPtr(_) => {
+                let map_closure_sig = match map_closure_ty.kind {
+                    ty::Closure(_, substs) => substs.as_closure().sig(),
+                    _ => map_closure_ty.fn_sig(cx.tcx),
+                };
+                let map_closure_return_ty = cx.tcx.erase_late_bound_regions(&map_closure_sig.output());
+                is_type_diagnostic_item(cx, map_closure_return_ty, sym!(option_type))
+            },
+            _ => false,
         };
 
         let method_to_use = if is_map_to_option {
@@ -2584,19 +2589,13 @@ fn lint_map_flatten<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, map
             // `(...).map(...)` has type `impl Iterator<Item=impl Iterator<...>>
             "flat_map"
         };
-        let msg = &format!(
-            "called `map(..).flatten()` on an `Iterator`. \
-                   This is more succinctly expressed by calling `.{}(..)`",
-            method_to_use
-        );
-        let self_snippet = snippet(cx, map_args[0].span, "..");
         let func_snippet = snippet(cx, map_args[1].span, "..");
-        let hint = format!("{0}.{1}({2})", self_snippet, method_to_use, func_snippet);
+        let hint = format!(".{0}({1})", method_to_use, func_snippet);
         span_lint_and_sugg(
             cx,
             MAP_FLATTEN,
-            expr.span,
-            msg,
+            expr.span.with_lo(map_args[0].span.hi()),
+            "called `map(..).flatten()` on an `Iterator`",
             &format!("try using `{}` instead", method_to_use),
             hint,
             Applicability::MachineApplicable,
@@ -2605,16 +2604,13 @@ fn lint_map_flatten<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, map
 
     // lint if caller of `.map().flatten()` is an Option
     if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&map_args[0]), sym!(option_type)) {
-        let msg = "called `map(..).flatten()` on an `Option`. \
-                    This is more succinctly expressed by calling `.and_then(..)`";
-        let self_snippet = snippet(cx, map_args[0].span, "..");
         let func_snippet = snippet(cx, map_args[1].span, "..");
-        let hint = format!("{0}.and_then({1})", self_snippet, func_snippet);
+        let hint = format!(".and_then({})", func_snippet);
         span_lint_and_sugg(
             cx,
             MAP_FLATTEN,
-            expr.span,
-            msg,
+            expr.span.with_lo(map_args[0].span.hi()),
+            "called `map(..).flatten()` on an `Option`",
             "try using `and_then` instead",
             hint,
             Applicability::MachineApplicable,
diff --git a/tests/ui/map_flatten.fixed b/tests/ui/map_flatten.fixed
index 684a28aebcb..a5fdf7df613 100644
--- a/tests/ui/map_flatten.fixed
+++ b/tests/ui/map_flatten.fixed
@@ -5,7 +5,20 @@
 #![allow(clippy::map_identity)]
 
 fn main() {
+    // mapping to Option on Iterator
+    fn option_id(x: i8) -> Option<i8> {
+        Some(x)
+    }
+    let option_id_ref: fn(i8) -> Option<i8> = option_id;
+    let option_id_closure = |x| Some(x);
+    let _: Vec<_> = vec![5_i8; 6].into_iter().filter_map(option_id).collect();
+    let _: Vec<_> = vec![5_i8; 6].into_iter().filter_map(option_id_ref).collect();
+    let _: Vec<_> = vec![5_i8; 6].into_iter().filter_map(option_id_closure).collect();
     let _: Vec<_> = vec![5_i8; 6].into_iter().filter_map(|x| x.checked_add(1)).collect();
+
+    // mapping to Iterator on Iterator
     let _: Vec<_> = vec![5_i8; 6].into_iter().flat_map(|x| 0..x).collect();
+
+    // mapping to Option on Option
     let _: Option<_> = (Some(Some(1))).and_then(|x| x);
 }
diff --git a/tests/ui/map_flatten.rs b/tests/ui/map_flatten.rs
index 05789ee5232..abbc4e16e56 100644
--- a/tests/ui/map_flatten.rs
+++ b/tests/ui/map_flatten.rs
@@ -5,7 +5,20 @@
 #![allow(clippy::map_identity)]
 
 fn main() {
+    // mapping to Option on Iterator
+    fn option_id(x: i8) -> Option<i8> {
+        Some(x)
+    }
+    let option_id_ref: fn(i8) -> Option<i8> = option_id;
+    let option_id_closure = |x| Some(x);
+    let _: Vec<_> = vec![5_i8; 6].into_iter().map(option_id).flatten().collect();
+    let _: Vec<_> = vec![5_i8; 6].into_iter().map(option_id_ref).flatten().collect();
+    let _: Vec<_> = vec![5_i8; 6].into_iter().map(option_id_closure).flatten().collect();
     let _: Vec<_> = vec![5_i8; 6].into_iter().map(|x| x.checked_add(1)).flatten().collect();
+
+    // mapping to Iterator on Iterator
     let _: Vec<_> = vec![5_i8; 6].into_iter().map(|x| 0..x).flatten().collect();
+
+    // mapping to Option on Option
     let _: Option<_> = (Some(Some(1))).map(|x| x).flatten();
 }
diff --git a/tests/ui/map_flatten.stderr b/tests/ui/map_flatten.stderr
index d2d15362a6c..b6479cd69ea 100644
--- a/tests/ui/map_flatten.stderr
+++ b/tests/ui/map_flatten.stderr
@@ -1,22 +1,40 @@
-error: called `map(..).flatten()` on an `Iterator`. This is more succinctly expressed by calling `.filter_map(..)`
-  --> $DIR/map_flatten.rs:8:21
+error: called `map(..).flatten()` on an `Iterator`
+  --> $DIR/map_flatten.rs:14:46
    |
-LL |     let _: Vec<_> = vec![5_i8; 6].into_iter().map(|x| x.checked_add(1)).flatten().collect();
-   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try using `filter_map` instead: `vec![5_i8; 6].into_iter().filter_map(|x| x.checked_add(1))`
+LL |     let _: Vec<_> = vec![5_i8; 6].into_iter().map(option_id).flatten().collect();
+   |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try using `filter_map` instead: `.filter_map(option_id)`
    |
    = note: `-D clippy::map-flatten` implied by `-D warnings`
 
-error: called `map(..).flatten()` on an `Iterator`. This is more succinctly expressed by calling `.flat_map(..)`
-  --> $DIR/map_flatten.rs:9:21
+error: called `map(..).flatten()` on an `Iterator`
+  --> $DIR/map_flatten.rs:15:46
+   |
+LL |     let _: Vec<_> = vec![5_i8; 6].into_iter().map(option_id_ref).flatten().collect();
+   |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try using `filter_map` instead: `.filter_map(option_id_ref)`
+
+error: called `map(..).flatten()` on an `Iterator`
+  --> $DIR/map_flatten.rs:16:46
+   |
+LL |     let _: Vec<_> = vec![5_i8; 6].into_iter().map(option_id_closure).flatten().collect();
+   |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try using `filter_map` instead: `.filter_map(option_id_closure)`
+
+error: called `map(..).flatten()` on an `Iterator`
+  --> $DIR/map_flatten.rs:17:46
+   |
+LL |     let _: Vec<_> = vec![5_i8; 6].into_iter().map(|x| x.checked_add(1)).flatten().collect();
+   |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try using `filter_map` instead: `.filter_map(|x| x.checked_add(1))`
+
+error: called `map(..).flatten()` on an `Iterator`
+  --> $DIR/map_flatten.rs:20:46
    |
 LL |     let _: Vec<_> = vec![5_i8; 6].into_iter().map(|x| 0..x).flatten().collect();
-   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try using `flat_map` instead: `vec![5_i8; 6].into_iter().flat_map(|x| 0..x)`
+   |                                              ^^^^^^^^^^^^^^^^^^^^^^^^ help: try using `flat_map` instead: `.flat_map(|x| 0..x)`
 
-error: called `map(..).flatten()` on an `Option`. This is more succinctly expressed by calling `.and_then(..)`
-  --> $DIR/map_flatten.rs:10:24
+error: called `map(..).flatten()` on an `Option`
+  --> $DIR/map_flatten.rs:23:39
    |
 LL |     let _: Option<_> = (Some(Some(1))).map(|x| x).flatten();
-   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try using `and_then` instead: `(Some(Some(1))).and_then(|x| x)`
+   |                                       ^^^^^^^^^^^^^^^^^^^^^ help: try using `and_then` instead: `.and_then(|x| x)`
 
-error: aborting due to 3 previous errors
+error: aborting due to 6 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From cb00cdf0d77e6a21cd64558f1e373e696f31d301 Mon Sep 17 00:00:00 2001
From: Philipp Hansch <dev@phansch.net>
Date: Sun, 2 Aug 2020 11:25:03 +0200
Subject: Remove old Symbol reexport

I couldn't really tell what it was meant to improve. It seems more clear
without the renaming to `Name`?
---
 clippy_lints/src/attrs.rs     |  3 +--
 clippy_lints/src/lib.rs       |  4 ----
 clippy_lints/src/lifetimes.rs |  7 +++----
 clippy_lints/src/loops.rs     | 17 ++++++++---------
 clippy_lints/src/shadow.rs    | 18 +++++++++---------
 clippy_lints/src/utils/mod.rs | 15 +++++++--------
 6 files changed, 28 insertions(+), 36 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs
index c29432bf933..ed02763397a 100644
--- a/clippy_lints/src/attrs.rs
+++ b/clippy_lints/src/attrs.rs
@@ -1,6 +1,5 @@
 //! checks for attributes
 
-use crate::reexport::Name;
 use crate::utils::{
     first_line_of_span, is_present_in_source, match_def_path, paths, snippet_opt, span_lint, span_lint_and_help,
     span_lint_and_sugg, span_lint_and_then, without_block_comments,
@@ -514,7 +513,7 @@ fn is_relevant_expr(cx: &LateContext<'_>, tables: &ty::TypeckTables<'_>, expr: &
     }
 }
 
-fn check_attrs(cx: &LateContext<'_>, span: Span, name: Name, attrs: &[Attribute]) {
+fn check_attrs(cx: &LateContext<'_>, span: Span, name: Symbol, attrs: &[Attribute]) {
     if span.from_expansion() {
         return;
     }
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 7a4ca3902b3..b336de37c61 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -321,10 +321,6 @@ mod zero_div_zero;
 
 pub use crate::utils::conf::Conf;
 
-mod reexport {
-    pub use rustc_span::Symbol as Name;
-}
-
 /// Register all pre expansion lints
 ///
 /// Pre-expansion lints run before any macro expansion has happened.
diff --git a/clippy_lints/src/lifetimes.rs b/clippy_lints/src/lifetimes.rs
index 168f9f953e4..1b3639a02a0 100644
--- a/clippy_lints/src/lifetimes.rs
+++ b/clippy_lints/src/lifetimes.rs
@@ -13,9 +13,8 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::map::Map;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
-use rustc_span::symbol::kw;
+use rustc_span::symbol::{Symbol, kw};
 
-use crate::reexport::Name;
 use crate::utils::{in_macro, last_path_segment, span_lint, trait_ref_of_method};
 
 declare_clippy_lint! {
@@ -113,7 +112,7 @@ impl<'tcx> LateLintPass<'tcx> for Lifetimes {
 enum RefLt {
     Unnamed,
     Static,
-    Named(Name),
+    Named(Symbol),
 }
 
 fn check_fn_inner<'tcx>(
@@ -456,7 +455,7 @@ fn has_where_lifetimes<'tcx>(cx: &LateContext<'tcx>, where_clause: &'tcx WhereCl
 }
 
 struct LifetimeChecker {
-    map: FxHashMap<Name, Span>,
+    map: FxHashMap<Symbol, Span>,
 }
 
 impl<'tcx> Visitor<'tcx> for LifetimeChecker {
diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 396bb659109..d0d6c2e04a0 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -1,5 +1,4 @@
 use crate::consts::constant;
-use crate::reexport::Name;
 use crate::utils::paths;
 use crate::utils::usage::{is_unused, mutated_variables};
 use crate::utils::{
@@ -1184,7 +1183,7 @@ fn check_for_loop_range<'tcx>(
     }
 }
 
-fn is_len_call(expr: &Expr<'_>, var: Name) -> bool {
+fn is_len_call(expr: &Expr<'_>, var: Symbol) -> bool {
     if_chain! {
         if let ExprKind::MethodCall(ref method, _, ref len_args, _) = expr.kind;
         if len_args.len() == 1;
@@ -1632,15 +1631,15 @@ struct VarVisitor<'a, 'tcx> {
     /// var name to look for as index
     var: HirId,
     /// indexed variables that are used mutably
-    indexed_mut: FxHashSet<Name>,
+    indexed_mut: FxHashSet<Symbol>,
     /// indirectly indexed variables (`v[(i + 4) % N]`), the extend is `None` for global
-    indexed_indirectly: FxHashMap<Name, Option<region::Scope>>,
+    indexed_indirectly: FxHashMap<Symbol, Option<region::Scope>>,
     /// subset of `indexed` of vars that are indexed directly: `v[i]`
     /// this will not contain cases like `v[calc_index(i)]` or `v[(i + 4) % N]`
-    indexed_directly: FxHashMap<Name, (Option<region::Scope>, Ty<'tcx>)>,
+    indexed_directly: FxHashMap<Symbol, (Option<region::Scope>, Ty<'tcx>)>,
     /// Any names that are used outside an index operation.
     /// Used to detect things like `&mut vec` used together with `vec[i]`
-    referenced: FxHashSet<Name>,
+    referenced: FxHashSet<Symbol>,
     /// has the loop variable been used in expressions other than the index of
     /// an index op?
     nonindex: bool,
@@ -1996,7 +1995,7 @@ struct InitializeVisitor<'a, 'tcx> {
     end_expr: &'tcx Expr<'tcx>, // the for loop. Stop scanning here.
     var_id: HirId,
     state: VarState,
-    name: Option<Name>,
+    name: Option<Symbol>,
     depth: u32, // depth of conditional expressions
     past_loop: bool,
 }
@@ -2159,7 +2158,7 @@ use self::Nesting::{LookFurther, RuledOut, Unknown};
 
 struct LoopNestVisitor {
     hir_id: HirId,
-    iterator: Name,
+    iterator: Symbol,
     nesting: Nesting,
 }
 
@@ -2210,7 +2209,7 @@ impl<'tcx> Visitor<'tcx> for LoopNestVisitor {
     }
 }
 
-fn path_name(e: &Expr<'_>) -> Option<Name> {
+fn path_name(e: &Expr<'_>) -> Option<Symbol> {
     if let ExprKind::Path(QPath::Resolved(_, ref path)) = e.kind {
         let segments = &path.segments;
         if segments.len() == 1 {
diff --git a/clippy_lints/src/shadow.rs b/clippy_lints/src/shadow.rs
index fab13c8c124..97bd52e517c 100644
--- a/clippy_lints/src/shadow.rs
+++ b/clippy_lints/src/shadow.rs
@@ -1,4 +1,3 @@
-use crate::reexport::Name;
 use crate::utils::{contains_name, higher, iter_input_pats, snippet, span_lint_and_then};
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::{
@@ -10,6 +9,7 @@ use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
+use rustc_span::symbol::Symbol;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for bindings that shadow other bindings already in
@@ -123,7 +123,7 @@ fn check_fn<'tcx>(cx: &LateContext<'tcx>, decl: &'tcx FnDecl<'_>, body: &'tcx Bo
     check_expr(cx, &body.value, &mut bindings);
 }
 
-fn check_block<'tcx>(cx: &LateContext<'tcx>, block: &'tcx Block<'_>, bindings: &mut Vec<(Name, Span)>) {
+fn check_block<'tcx>(cx: &LateContext<'tcx>, block: &'tcx Block<'_>, bindings: &mut Vec<(Symbol, Span)>) {
     let len = bindings.len();
     for stmt in block.stmts {
         match stmt.kind {
@@ -138,7 +138,7 @@ fn check_block<'tcx>(cx: &LateContext<'tcx>, block: &'tcx Block<'_>, bindings: &
     bindings.truncate(len);
 }
 
-fn check_local<'tcx>(cx: &LateContext<'tcx>, local: &'tcx Local<'_>, bindings: &mut Vec<(Name, Span)>) {
+fn check_local<'tcx>(cx: &LateContext<'tcx>, local: &'tcx Local<'_>, bindings: &mut Vec<(Symbol, Span)>) {
     if in_external_macro(cx.sess(), local.span) {
         return;
     }
@@ -173,7 +173,7 @@ fn check_pat<'tcx>(
     pat: &'tcx Pat<'_>,
     init: Option<&'tcx Expr<'_>>,
     span: Span,
-    bindings: &mut Vec<(Name, Span)>,
+    bindings: &mut Vec<(Symbol, Span)>,
 ) {
     // TODO: match more stuff / destructuring
     match pat.kind {
@@ -254,7 +254,7 @@ fn check_pat<'tcx>(
 
 fn lint_shadow<'tcx>(
     cx: &LateContext<'tcx>,
-    name: Name,
+    name: Symbol,
     span: Span,
     pattern_span: Span,
     init: Option<&'tcx Expr<'_>>,
@@ -315,7 +315,7 @@ fn lint_shadow<'tcx>(
     }
 }
 
-fn check_expr<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, bindings: &mut Vec<(Name, Span)>) {
+fn check_expr<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, bindings: &mut Vec<(Symbol, Span)>) {
     if in_external_macro(cx.sess(), expr.span) {
         return;
     }
@@ -351,7 +351,7 @@ fn check_expr<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, bindings: &mut
     }
 }
 
-fn check_ty<'tcx>(cx: &LateContext<'tcx>, ty: &'tcx Ty<'_>, bindings: &mut Vec<(Name, Span)>) {
+fn check_ty<'tcx>(cx: &LateContext<'tcx>, ty: &'tcx Ty<'_>, bindings: &mut Vec<(Symbol, Span)>) {
     match ty.kind {
         TyKind::Slice(ref sty) => check_ty(cx, sty, bindings),
         TyKind::Array(ref fty, ref anon_const) => {
@@ -371,7 +371,7 @@ fn check_ty<'tcx>(cx: &LateContext<'tcx>, ty: &'tcx Ty<'_>, bindings: &mut Vec<(
     }
 }
 
-fn is_self_shadow(name: Name, expr: &Expr<'_>) -> bool {
+fn is_self_shadow(name: Symbol, expr: &Expr<'_>) -> bool {
     match expr.kind {
         ExprKind::Box(ref inner) | ExprKind::AddrOf(_, _, ref inner) => is_self_shadow(name, inner),
         ExprKind::Block(ref block, _) => {
@@ -383,6 +383,6 @@ fn is_self_shadow(name: Name, expr: &Expr<'_>) -> bool {
     }
 }
 
-fn path_eq_name(name: Name, path: &Path<'_>) -> bool {
+fn path_eq_name(name: Symbol, path: &Path<'_>) -> bool {
     !path.is_global() && path.segments.len() == 1 && path.segments[0].ident.as_str() == name.as_str()
 }
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index 4b7a1c2b537..39317ecc82e 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -52,7 +52,6 @@ use rustc_trait_selection::traits::query::normalize::AtExt;
 use smallvec::SmallVec;
 
 use crate::consts::{constant, Constant};
-use crate::reexport::Name;
 
 /// Returns `true` if the two spans come from differing expansions (i.e., one is
 /// from a macro and one isn't).
@@ -150,7 +149,7 @@ pub fn match_trait_method(cx: &LateContext<'_>, expr: &Expr<'_>, path: &[&str])
 }
 
 /// Checks if an expression references a variable of the given name.
-pub fn match_var(expr: &Expr<'_>, var: Name) -> bool {
+pub fn match_var(expr: &Expr<'_>, var: Symbol) -> bool {
     if let ExprKind::Path(QPath::Resolved(None, ref path)) = expr.kind {
         if let [p] = path.segments {
             return p.ident.name == var;
@@ -422,7 +421,7 @@ pub fn is_entrypoint_fn(cx: &LateContext<'_>, def_id: DefId) -> bool {
 }
 
 /// Gets the name of the item the expression is in, if available.
-pub fn get_item_name(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<Name> {
+pub fn get_item_name(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<Symbol> {
     let parent_id = cx.tcx.hir().get_parent_item(expr.hir_id);
     match cx.tcx.hir().find(parent_id) {
         Some(
@@ -435,7 +434,7 @@ pub fn get_item_name(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<Name> {
 }
 
 /// Gets the name of a `Pat`, if any.
-pub fn get_pat_name(pat: &Pat<'_>) -> Option<Name> {
+pub fn get_pat_name(pat: &Pat<'_>) -> Option<Symbol> {
     match pat.kind {
         PatKind::Binding(.., ref spname, _) => Some(spname.name),
         PatKind::Path(ref qpath) => single_segment_path(qpath).map(|ps| ps.ident.name),
@@ -445,14 +444,14 @@ pub fn get_pat_name(pat: &Pat<'_>) -> Option<Name> {
 }
 
 struct ContainsName {
-    name: Name,
+    name: Symbol,
     result: bool,
 }
 
 impl<'tcx> Visitor<'tcx> for ContainsName {
     type Map = Map<'tcx>;
 
-    fn visit_name(&mut self, _: Span, name: Name) {
+    fn visit_name(&mut self, _: Span, name: Symbol) {
         if self.name == name {
             self.result = true;
         }
@@ -463,7 +462,7 @@ impl<'tcx> Visitor<'tcx> for ContainsName {
 }
 
 /// Checks if an `Expr` contains a certain name.
-pub fn contains_name(name: Name, expr: &Expr<'_>) -> bool {
+pub fn contains_name(name: Symbol, expr: &Expr<'_>) -> bool {
     let mut cn = ContainsName { name, result: false };
     cn.visit_expr(expr);
     cn.result
@@ -1029,7 +1028,7 @@ pub fn is_allowed(cx: &LateContext<'_>, lint: &'static Lint, id: HirId) -> bool
     cx.tcx.lint_level_at_node(lint, id).0 == Level::Allow
 }
 
-pub fn get_arg_name(pat: &Pat<'_>) -> Option<Name> {
+pub fn get_arg_name(pat: &Pat<'_>) -> Option<Symbol> {
     match pat.kind {
         PatKind::Binding(.., ident, None) => Some(ident.name),
         PatKind::Ref(ref subpat, _) => get_arg_name(subpat),
-- 
cgit 1.4.1-3-g733a5


From bb6e857980748b000ba3b88d125c6b29aced0693 Mon Sep 17 00:00:00 2001
From: Philipp Hansch <dev@phansch.net>
Date: Sun, 2 Aug 2020 14:22:54 +0200
Subject: fmt

---
 clippy_lints/src/lifetimes.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lifetimes.rs b/clippy_lints/src/lifetimes.rs
index 1b3639a02a0..4df6827d77f 100644
--- a/clippy_lints/src/lifetimes.rs
+++ b/clippy_lints/src/lifetimes.rs
@@ -13,7 +13,7 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::map::Map;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
-use rustc_span::symbol::{Symbol, kw};
+use rustc_span::symbol::{kw, Symbol};
 
 use crate::utils::{in_macro, last_path_segment, span_lint, trait_ref_of_method};
 
-- 
cgit 1.4.1-3-g733a5


From e336fe80d2f991a170b98190683039035b53c6ba Mon Sep 17 00:00:00 2001
From: Eduardo Broto <ebroto@tutanota.com>
Date: Mon, 3 Aug 2020 00:36:28 +0200
Subject: manual_async_fn: take input lifetimes into account

The anonymous future returned from an `async fn` captures all input
lifetimes. This was not being taken into account.

See https://github.com/rust-lang/rfcs/blob/master/text/2394-async_await.md#lifetime-capture-in-the-anonymous-future
---
 clippy_lints/src/manual_async_fn.rs | 63 ++++++++++++++++++++++++++++++-------
 tests/ui/await_holding_lock.rs      |  1 +
 tests/ui/await_holding_lock.stderr  |  4 +--
 tests/ui/manual_async_fn.fixed      | 40 ++++++++++++++++++++---
 tests/ui/manual_async_fn.rs         | 48 +++++++++++++++++++++++-----
 tests/ui/manual_async_fn.stderr     | 30 +++++++++---------
 6 files changed, 146 insertions(+), 40 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_async_fn.rs b/clippy_lints/src/manual_async_fn.rs
index c19fb148cda..864d1ea87f5 100644
--- a/clippy_lints/src/manual_async_fn.rs
+++ b/clippy_lints/src/manual_async_fn.rs
@@ -4,8 +4,8 @@ use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::{
-    AsyncGeneratorKind, Block, Body, Expr, ExprKind, FnDecl, FnRetTy, GeneratorKind, GenericBound, HirId, IsAsync,
-    ItemKind, TraitRef, Ty, TyKind, TypeBindingKind,
+    AsyncGeneratorKind, Block, Body, Expr, ExprKind, FnDecl, FnRetTy, GeneratorKind, GenericArg, GenericBound, HirId,
+    IsAsync, ItemKind, LifetimeName, TraitRef, Ty, TyKind, TypeBindingKind,
 };
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -27,8 +27,6 @@ declare_clippy_lint! {
     /// ```
     /// Use instead:
     /// ```rust
-    /// use std::future::Future;
-    ///
     /// async fn foo() -> i32 { 42 }
     /// ```
     pub MANUAL_ASYNC_FN,
@@ -53,8 +51,9 @@ impl<'tcx> LateLintPass<'tcx> for ManualAsyncFn {
             if let IsAsync::NotAsync = header.asyncness;
             // Check that this function returns `impl Future`
             if let FnRetTy::Return(ret_ty) = decl.output;
-            if let Some(trait_ref) = future_trait_ref(cx, ret_ty);
+            if let Some((trait_ref, output_lifetimes)) = future_trait_ref(cx, ret_ty);
             if let Some(output) = future_output_ty(trait_ref);
+            if captures_all_lifetimes(decl.inputs, &output_lifetimes);
             // Check that the body of the function consists of one async block
             if let ExprKind::Block(block, _) = body.value.kind;
             if block.stmts.is_empty();
@@ -97,16 +96,35 @@ impl<'tcx> LateLintPass<'tcx> for ManualAsyncFn {
     }
 }
 
-fn future_trait_ref<'tcx>(cx: &LateContext<'tcx>, ty: &'tcx Ty<'tcx>) -> Option<&'tcx TraitRef<'tcx>> {
+fn future_trait_ref<'tcx>(
+    cx: &LateContext<'tcx>,
+    ty: &'tcx Ty<'tcx>,
+) -> Option<(&'tcx TraitRef<'tcx>, Vec<LifetimeName>)> {
     if_chain! {
-        if let TyKind::OpaqueDef(item_id, _) = ty.kind;
+        if let TyKind::OpaqueDef(item_id, bounds) = ty.kind;
         let item = cx.tcx.hir().item(item_id.id);
         if let ItemKind::OpaqueTy(opaque) = &item.kind;
-        if opaque.bounds.len() == 1;
-        if let GenericBound::Trait(poly, _) = &opaque.bounds[0];
-        if poly.trait_ref.trait_def_id() == cx.tcx.lang_items().future_trait();
+        if let Some(trait_ref) = opaque.bounds.iter().find_map(|bound| {
+            if let GenericBound::Trait(poly, _) = bound {
+                Some(&poly.trait_ref)
+            } else {
+                None
+            }
+        });
+        if trait_ref.trait_def_id() == cx.tcx.lang_items().future_trait();
         then {
-            return Some(&poly.trait_ref);
+            let output_lifetimes = bounds
+                .iter()
+                .filter_map(|bound| {
+                    if let GenericArg::Lifetime(lt) = bound {
+                        Some(lt.name)
+                    } else {
+                        None
+                    }
+                })
+                .collect();
+
+            return Some((trait_ref, output_lifetimes));
         }
     }
 
@@ -129,6 +147,29 @@ fn future_output_ty<'tcx>(trait_ref: &'tcx TraitRef<'tcx>) -> Option<&'tcx Ty<'t
     None
 }
 
+fn captures_all_lifetimes(inputs: &[Ty<'_>], output_lifetimes: &[LifetimeName]) -> bool {
+    let input_lifetimes: Vec<LifetimeName> = inputs
+        .iter()
+        .filter_map(|ty| {
+            if let TyKind::Rptr(lt, _) = ty.kind {
+                Some(lt.name)
+            } else {
+                None
+            }
+        })
+        .collect();
+
+    // The lint should trigger in one of these cases:
+    // - There are no input lifetimes
+    // - There's only one output lifetime bound using `+ '_`
+    // - All input lifetimes are explicitly bound to the output
+    input_lifetimes.is_empty()
+        || (output_lifetimes.len() == 1 && matches!(output_lifetimes[0], LifetimeName::Underscore))
+        || input_lifetimes
+            .iter()
+            .all(|in_lt| output_lifetimes.iter().any(|out_lt| in_lt == out_lt))
+}
+
 fn desugared_async_block<'tcx>(cx: &LateContext<'tcx>, block: &'tcx Block<'tcx>) -> Option<&'tcx Body<'tcx>> {
     if_chain! {
         if let Some(block_expr) = block.expr;
diff --git a/tests/ui/await_holding_lock.rs b/tests/ui/await_holding_lock.rs
index 5c1fdd83efb..0458950edee 100644
--- a/tests/ui/await_holding_lock.rs
+++ b/tests/ui/await_holding_lock.rs
@@ -47,6 +47,7 @@ async fn not_good(x: &Mutex<u32>) -> u32 {
     first + second + third
 }
 
+#[allow(clippy::manual_async_fn)]
 fn block_bad(x: &Mutex<u32>) -> impl std::future::Future<Output = u32> + '_ {
     async move {
         let guard = x.lock().unwrap();
diff --git a/tests/ui/await_holding_lock.stderr b/tests/ui/await_holding_lock.stderr
index 8c47cb37d8c..21bf49d16f0 100644
--- a/tests/ui/await_holding_lock.stderr
+++ b/tests/ui/await_holding_lock.stderr
@@ -46,13 +46,13 @@ LL | |     };
    | |_____^
 
 error: this MutexGuard is held across an 'await' point. Consider using an async-aware Mutex type or ensuring the MutexGuard is dropped before calling await.
-  --> $DIR/await_holding_lock.rs:52:13
+  --> $DIR/await_holding_lock.rs:53:13
    |
 LL |         let guard = x.lock().unwrap();
    |             ^^^^^
    |
 note: these are all the await points this lock is held through
-  --> $DIR/await_holding_lock.rs:52:9
+  --> $DIR/await_holding_lock.rs:53:9
    |
 LL | /         let guard = x.lock().unwrap();
 LL | |         baz().await
diff --git a/tests/ui/manual_async_fn.fixed b/tests/ui/manual_async_fn.fixed
index 27222cc0869..4f551690c43 100644
--- a/tests/ui/manual_async_fn.fixed
+++ b/tests/ui/manual_async_fn.fixed
@@ -43,10 +43,6 @@ impl S {
         42
     }
 
-    async fn meth_fut(&self) -> i32 { 42 }
-
-    async fn empty_fut(&self)  {}
-
     // should be ignored
     fn not_fut(&self) -> i32 {
         42
@@ -64,4 +60,40 @@ impl S {
     }
 }
 
+// Tests related to lifetime capture
+
+async fn elided(_: &i32) -> i32 { 42 }
+
+// should be ignored
+fn elided_not_bound(_: &i32) -> impl Future<Output = i32> {
+    async { 42 }
+}
+
+async fn explicit<'a, 'b>(_: &'a i32, _: &'b i32) -> i32 { 42 }
+
+// should be ignored
+#[allow(clippy::needless_lifetimes)]
+fn explicit_not_bound<'a, 'b>(_: &'a i32, _: &'b i32) -> impl Future<Output = i32> {
+    async { 42 }
+}
+
+// should be ignored
+mod issue_5765 {
+    use std::future::Future;
+
+    struct A;
+    impl A {
+        fn f(&self) -> impl Future<Output = ()> {
+            async {}
+        }
+    }
+
+    fn test() {
+        let _future = {
+            let a = A;
+            a.f()
+        };
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/manual_async_fn.rs b/tests/ui/manual_async_fn.rs
index 6a0f1b26c88..6ed60309947 100644
--- a/tests/ui/manual_async_fn.rs
+++ b/tests/ui/manual_async_fn.rs
@@ -51,14 +51,6 @@ impl S {
         }
     }
 
-    fn meth_fut(&self) -> impl Future<Output = i32> {
-        async { 42 }
-    }
-
-    fn empty_fut(&self) -> impl Future<Output = ()> {
-        async {}
-    }
-
     // should be ignored
     fn not_fut(&self) -> i32 {
         42
@@ -76,4 +68,44 @@ impl S {
     }
 }
 
+// Tests related to lifetime capture
+
+fn elided(_: &i32) -> impl Future<Output = i32> + '_ {
+    async { 42 }
+}
+
+// should be ignored
+fn elided_not_bound(_: &i32) -> impl Future<Output = i32> {
+    async { 42 }
+}
+
+fn explicit<'a, 'b>(_: &'a i32, _: &'b i32) -> impl Future<Output = i32> + 'a + 'b {
+    async { 42 }
+}
+
+// should be ignored
+#[allow(clippy::needless_lifetimes)]
+fn explicit_not_bound<'a, 'b>(_: &'a i32, _: &'b i32) -> impl Future<Output = i32> {
+    async { 42 }
+}
+
+// should be ignored
+mod issue_5765 {
+    use std::future::Future;
+
+    struct A;
+    impl A {
+        fn f(&self) -> impl Future<Output = ()> {
+            async {}
+        }
+    }
+
+    fn test() {
+        let _future = {
+            let a = A;
+            a.f()
+        };
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/manual_async_fn.stderr b/tests/ui/manual_async_fn.stderr
index a1904c904d0..ccd82867427 100644
--- a/tests/ui/manual_async_fn.stderr
+++ b/tests/ui/manual_async_fn.stderr
@@ -65,34 +65,34 @@ LL |             let c = 21;
  ...
 
 error: this function can be simplified using the `async fn` syntax
-  --> $DIR/manual_async_fn.rs:54:5
+  --> $DIR/manual_async_fn.rs:73:1
    |
-LL |     fn meth_fut(&self) -> impl Future<Output = i32> {
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL | fn elided(_: &i32) -> impl Future<Output = i32> + '_ {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: make the function `async` and return the output of the future directly
    |
-LL |     async fn meth_fut(&self) -> i32 {
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL | async fn elided(_: &i32) -> i32 {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 help: move the body of the async block to the enclosing function
    |
-LL |     fn meth_fut(&self) -> impl Future<Output = i32> { 42 }
-   |                                                     ^^^^^^
+LL | fn elided(_: &i32) -> impl Future<Output = i32> + '_ { 42 }
+   |                                                      ^^^^^^
 
 error: this function can be simplified using the `async fn` syntax
-  --> $DIR/manual_async_fn.rs:58:5
+  --> $DIR/manual_async_fn.rs:82:1
    |
-LL |     fn empty_fut(&self) -> impl Future<Output = ()> {
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL | fn explicit<'a, 'b>(_: &'a i32, _: &'b i32) -> impl Future<Output = i32> + 'a + 'b {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-help: make the function `async` and remove the return type
+help: make the function `async` and return the output of the future directly
    |
-LL |     async fn empty_fut(&self)  {
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
+LL | async fn explicit<'a, 'b>(_: &'a i32, _: &'b i32) -> i32 {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 help: move the body of the async block to the enclosing function
    |
-LL |     fn empty_fut(&self) -> impl Future<Output = ()> {}
-   |                                                     ^^
+LL | fn explicit<'a, 'b>(_: &'a i32, _: &'b i32) -> impl Future<Output = i32> + 'a + 'b { 42 }
+   |                                                                                    ^^^^^^
 
 error: aborting due to 6 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 3ee61373fe056efb46b6b1b243b31cec0d7e6099 Mon Sep 17 00:00:00 2001
From: JarredAllen <jarredallen73@gmail.com>
Date: Wed, 22 Jul 2020 22:46:23 -0700
Subject: Write the lint and write tests

---
 clippy_lints/src/loops.rs        | 107 ++++++++++++++++++++++++++++++++++++---
 tests/ui/needless_collect.fixed  |  11 ++++
 tests/ui/needless_collect.rs     |  18 ++++---
 tests/ui/needless_collect.stderr |  17 +++++--
 4 files changed, 137 insertions(+), 16 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 7e3876ff49b..231c440463d 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -1,14 +1,15 @@
 use crate::consts::constant;
 use crate::reexport::Name;
 use crate::utils::paths;
+use crate::utils::sugg::Sugg;
 use crate::utils::usage::{is_unused, mutated_variables};
 use crate::utils::{
     get_enclosing_block, get_parent_expr, get_trait_def_id, has_iter_method, higher, implements_trait,
-    is_integer_const, is_no_std_crate, is_refutable, last_path_segment, match_trait_method, match_type, match_var,
-    multispan_sugg, snippet, snippet_opt, snippet_with_applicability, span_lint, span_lint_and_help,
-    span_lint_and_sugg, span_lint_and_then, SpanlessEq,
+    is_integer_const, is_no_std_crate, is_refutable, is_type_diagnostic_item, last_path_segment, match_path,
+    match_trait_method, match_type, match_var, multispan_sugg, qpath_res, snippet, snippet_opt,
+    snippet_with_applicability, span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then, sugg,
+    SpanlessEq,
 };
-use crate::utils::{is_type_diagnostic_item, qpath_res, sugg};
 use if_chain::if_chain;
 use rustc_ast::ast;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
@@ -17,7 +18,7 @@ use rustc_hir::def::{DefKind, Res};
 use rustc_hir::intravisit::{walk_block, walk_expr, walk_pat, walk_stmt, NestedVisitorMap, Visitor};
 use rustc_hir::{
     def_id, BinOpKind, BindingAnnotation, Block, BorrowKind, Expr, ExprKind, GenericArg, HirId, InlineAsmOperand,
-    LoopSource, MatchSource, Mutability, Node, Pat, PatKind, QPath, Stmt, StmtKind,
+    Local, LoopSource, MatchSource, Mutability, Node, Pat, PatKind, QPath, Stmt, StmtKind,
 };
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::{LateContext, LateLintPass, LintContext};
@@ -27,7 +28,7 @@ use rustc_middle::middle::region;
 use rustc_middle::ty::{self, Ty, TyS};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
-use rustc_span::symbol::Symbol;
+use rustc_span::symbol::{Ident, Symbol};
 use rustc_typeck::expr_use_visitor::{ConsumeMode, Delegate, ExprUseVisitor, PlaceBase, PlaceWithHirId};
 use std::iter::{once, Iterator};
 use std::mem;
@@ -2358,6 +2359,7 @@ impl<'a, 'tcx> Visitor<'tcx> for VarCollectorVisitor<'a, 'tcx> {
 const NEEDLESS_COLLECT_MSG: &str = "avoid using `collect()` when not needed";
 
 fn check_needless_collect<'tcx>(expr: &'tcx Expr<'_>, cx: &LateContext<'tcx>) {
+    // Check for direct, immediate usage
     if_chain! {
         if let ExprKind::MethodCall(ref method, _, ref args, _) = expr.kind;
         if let ExprKind::MethodCall(ref chain_method, _, _, _) = args[0].kind;
@@ -2423,6 +2425,99 @@ fn check_needless_collect<'tcx>(expr: &'tcx Expr<'_>, cx: &LateContext<'tcx>) {
             }
         }
     }
+    // Check for collecting it and then turning it back into an iterator later
+    if let ExprKind::Block(ref block, _) = expr.kind {
+        for ref stmt in block.stmts {
+            if_chain! {
+                // TODO also work for assignments to an existing variable
+                if let StmtKind::Local(
+                    Local { pat: Pat { kind: PatKind::Binding(_, _, ident, .. ), .. },
+                    init: Some(ref init_expr), .. }
+                ) = stmt.kind;
+                if let ExprKind::MethodCall(ref method_name, _, &[ref iter_source], ..) = init_expr.kind;
+                if method_name.ident.name == sym!(collect) && match_trait_method(cx, &init_expr, &paths::ITERATOR);
+                if let Some(ref generic_args) = method_name.args;
+                if let Some(GenericArg::Type(ref ty)) = generic_args.args.get(0);
+                if let ty = cx.typeck_results().node_type(ty.hir_id);
+                if is_type_diagnostic_item(cx, ty, sym!(vec_type)) ||
+                    is_type_diagnostic_item(cx, ty, sym!(vecdeque_type)) ||
+                    match_type(cx, ty, &paths::LINKED_LIST);
+                if let Some(iter_calls) = detect_iter_and_into_iters(block, *ident);
+                if iter_calls.len() == 1;
+                then {
+                    // Suggest replacing iter_call with iter_replacement, and removing stmt
+                    span_lint_and_then(
+                        cx,
+                        NEEDLESS_COLLECT,
+                        stmt.span,
+                        NEEDLESS_COLLECT_MSG,
+                        |diag| {
+                            let iter_replacement = Sugg::hir(cx, iter_source, "..").to_string();
+                            diag.multipart_suggestion(
+                                "Use the original Iterator instead of collecting it and then producing a new one",
+                                vec![
+                                    (stmt.span, String::new()),
+                                    (iter_calls[0].span, iter_replacement)
+                                ],
+                                Applicability::MaybeIncorrect,
+                            );
+                        },
+                    );
+                }
+            }
+        }
+    }
+}
+
+struct IntoIterVisitor<'tcx> {
+    iters: Vec<&'tcx Expr<'tcx>>,
+    seen_other: bool,
+    target: String,
+}
+impl<'tcx> Visitor<'tcx> for IntoIterVisitor<'tcx> {
+    fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) {
+        match &expr.kind {
+            ExprKind::MethodCall(
+                method_name,
+                _,
+                &[Expr {
+                    kind: ExprKind::Path(QPath::Resolved(_, ref path)),
+                    ..
+                }],
+                _,
+            ) if match_path(path, &[&self.target]) => {
+                // TODO Check what method is being called, if it's called on target, and act
+                // accordingly
+                if method_name.ident.name == sym!(into_iter) {
+                    self.iters.push(expr);
+                } else {
+                    self.seen_other = true;
+                }
+            },
+            _ => walk_expr(self, expr),
+        }
+    }
+
+    type Map = Map<'tcx>;
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::None
+    }
+}
+
+/// Detect the occurences of calls to `iter` or `into_iter` for the
+/// given identifier
+fn detect_iter_and_into_iters<'tcx>(block: &'tcx Block<'tcx>, identifier: Ident) -> Option<Vec<&'tcx Expr<'tcx>>> {
+    let mut visitor = IntoIterVisitor {
+        iters: Vec::new(),
+        target: identifier.name.to_ident_string(),
+        seen_other: false,
+    };
+    visitor.visit_block(block);
+    if visitor.seen_other {
+        None
+    } else {
+        Some(visitor.iters)
+    }
 }
 
 fn shorten_span(expr: &Expr<'_>, target_fn_name: Symbol) -> Span {
diff --git a/tests/ui/needless_collect.fixed b/tests/ui/needless_collect.fixed
index be37dc16b9a..60a3e206283 100644
--- a/tests/ui/needless_collect.fixed
+++ b/tests/ui/needless_collect.fixed
@@ -18,4 +18,15 @@ fn main() {
     sample.iter().collect::<HashSet<_>>().len();
     // Neither should this
     sample.iter().collect::<BTreeSet<_>>().len();
+    let indirect_positive = sample.iter().collect::<Vec<_>>();
+    indirect_positive
+        .into_iter()
+        .map(|x| (x, x + 1))
+        .collect::<HashMap<_, _>>();
+    let indirect_negative = sample.iter().collect::<Vec<_>>();
+    indirect_negative.len();
+    indirect_negative
+        .iter()
+        .map(|x| (*x, *x + 1))
+        .collect::<HashMap<_, _>>();
 }
diff --git a/tests/ui/needless_collect.rs b/tests/ui/needless_collect.rs
index 1577e7a46ed..33a1ea36095 100644
--- a/tests/ui/needless_collect.rs
+++ b/tests/ui/needless_collect.rs
@@ -8,9 +8,6 @@ use std::collections::{BTreeSet, HashMap, HashSet};
 #[allow(unused_variables, clippy::iter_cloned_collect)]
 fn main() {
     let sample = [1; 5];
-    let indirect_with_into_iter = sample.iter().collect::<Vec<_>>();
-    let indirect_with_iter = sample.iter().collect::<Vec<_>>();;
-    let indirect_negative = sample.iter().collect::<Vec<_>>();;
     let len = sample.iter().collect::<Vec<_>>().len();
     if sample.iter().collect::<Vec<_>>().is_empty() {
         // Empty
@@ -21,8 +18,15 @@ fn main() {
     sample.iter().collect::<HashSet<_>>().len();
     // Neither should this
     sample.iter().collect::<BTreeSet<_>>().len();
-    indirect_with_into_iter.into_iter().map(|x| (x, x+1)).collect::<HashMap<_, _>>();
-    indirect_with_iter.iter().map(|x| (x, x+1)).collect::<HashMap<_, _>>();
-    indirect_negative.iter().map(|x| (x, x+1)).collect::<HashMap<_, _>>();
-    indirect_negative.iter().map(|x| (x, x+1)).collect::<HashMap<_, _>>();
+    let indirect_positive = sample.iter().collect::<Vec<_>>();
+    indirect_positive
+        .into_iter()
+        .map(|x| (x, x + 1))
+        .collect::<HashMap<_, _>>();
+    let indirect_negative = sample.iter().collect::<Vec<_>>();
+    indirect_negative.len();
+    indirect_negative
+        .iter()
+        .map(|x| (*x, *x + 1))
+        .collect::<HashMap<_, _>>();
 }
diff --git a/tests/ui/needless_collect.stderr b/tests/ui/needless_collect.stderr
index 9113aad90dd..bb67bfa83e9 100644
--- a/tests/ui/needless_collect.stderr
+++ b/tests/ui/needless_collect.stderr
@@ -1,10 +1,21 @@
+error: avoid using `collect()` when not needed
+  --> $DIR/needless_collect.rs:21:5
+   |
+LL |     let indirect_positive = sample.iter().collect::<Vec<_>>();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::needless-collect` implied by `-D warnings`
+help: Use the original Iterator instead of collecting it and then producing a new one
+   |
+LL |     
+LL |     sample.iter()
+   |
+
 error: avoid using `collect()` when not needed
   --> $DIR/needless_collect.rs:11:29
    |
 LL |     let len = sample.iter().collect::<Vec<_>>().len();
    |                             ^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `count()`
-   |
-   = note: `-D clippy::needless-collect` implied by `-D warnings`
 
 error: avoid using `collect()` when not needed
   --> $DIR/needless_collect.rs:12:15
@@ -24,5 +35,5 @@ error: avoid using `collect()` when not needed
 LL |     sample.iter().map(|x| (x, x)).collect::<HashMap<_, _>>().len();
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `count()`
 
-error: aborting due to 4 previous errors
+error: aborting due to 5 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 3657c92ac978f69667b9c8bb46e51bc602b3d7ee Mon Sep 17 00:00:00 2001
From: JarredAllen <jarredallen73@gmail.com>
Date: Thu, 23 Jul 2020 09:14:10 -0700
Subject: Check for other things which can be used indirectly

---
 clippy_lints/src/loops.rs | 94 +++++++++++++++++++++++++++++++----------------
 1 file changed, 62 insertions(+), 32 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 231c440463d..11a9b1e531c 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -2429,7 +2429,6 @@ fn check_needless_collect<'tcx>(expr: &'tcx Expr<'_>, cx: &LateContext<'tcx>) {
     if let ExprKind::Block(ref block, _) = expr.kind {
         for ref stmt in block.stmts {
             if_chain! {
-                // TODO also work for assignments to an existing variable
                 if let StmtKind::Local(
                     Local { pat: Pat { kind: PatKind::Binding(_, _, ident, .. ), .. },
                     init: Some(ref init_expr), .. }
@@ -2446,21 +2445,22 @@ fn check_needless_collect<'tcx>(expr: &'tcx Expr<'_>, cx: &LateContext<'tcx>) {
                 if iter_calls.len() == 1;
                 then {
                     // Suggest replacing iter_call with iter_replacement, and removing stmt
+                    let iter_call = &iter_calls[0];
                     span_lint_and_then(
                         cx,
                         NEEDLESS_COLLECT,
-                        stmt.span,
+                        stmt.span.until(iter_call.span),
                         NEEDLESS_COLLECT_MSG,
                         |diag| {
-                            let iter_replacement = Sugg::hir(cx, iter_source, "..").to_string();
+                            let iter_replacement = format!("{}{}", Sugg::hir(cx, iter_source, ".."), iter_call.get_iter_method(cx));
                             diag.multipart_suggestion(
-                                "Use the original Iterator instead of collecting it and then producing a new one",
+                                iter_call.get_suggestion_text(),
                                 vec![
                                     (stmt.span, String::new()),
-                                    (iter_calls[0].span, iter_replacement)
+                                    (iter_call.span, iter_replacement)
                                 ],
-                                Applicability::MaybeIncorrect,
-                            );
+                                Applicability::MachineApplicable,// MaybeIncorrect,
+                            ).emit();
                         },
                     );
                 }
@@ -2469,32 +2469,62 @@ fn check_needless_collect<'tcx>(expr: &'tcx Expr<'_>, cx: &LateContext<'tcx>) {
     }
 }
 
-struct IntoIterVisitor<'tcx> {
-    iters: Vec<&'tcx Expr<'tcx>>,
+struct IterFunction {
+    func: IterFunctionKind,
+    span: Span,
+}
+impl IterFunction {
+    fn get_iter_method(&self, cx: &LateContext<'_>) -> String {
+        match &self.func {
+            IterFunctionKind::IntoIter => String::new(),
+            IterFunctionKind::Len => String::from(".count()"),
+            IterFunctionKind::IsEmpty => String::from(".next().is_none()"),
+            IterFunctionKind::Contains(span) => format!(".any(|x| x == {})", snippet(cx, *span, "..")),
+        }
+    }
+    fn get_suggestion_text(&self) -> &'static str {
+        match &self.func {
+            IterFunctionKind::IntoIter => "Use the original Iterator instead of collecting it and then producing a new one",
+            IterFunctionKind::Len => "Take the original Iterator's count instead of collecting it and finding the length",
+            IterFunctionKind::IsEmpty => "Check if the original Iterator has anything instead of collecting it and seeing if it's empty",
+            IterFunctionKind::Contains(_) => "Check if the original Iterator contains an element instead of collecting then checking",
+        }
+    }
+}
+enum IterFunctionKind {
+    IntoIter,
+    Len,
+    IsEmpty,
+    Contains(Span),
+}
+
+struct IterFunctionVisitor {
+    uses: Vec<IterFunction>,
     seen_other: bool,
     target: String,
 }
-impl<'tcx> Visitor<'tcx> for IntoIterVisitor<'tcx> {
+impl<'tcx> Visitor<'tcx> for IterFunctionVisitor {
     fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) {
-        match &expr.kind {
-            ExprKind::MethodCall(
-                method_name,
-                _,
-                &[Expr {
-                    kind: ExprKind::Path(QPath::Resolved(_, ref path)),
-                    ..
-                }],
-                _,
-            ) if match_path(path, &[&self.target]) => {
-                // TODO Check what method is being called, if it's called on target, and act
-                // accordingly
-                if method_name.ident.name == sym!(into_iter) {
-                    self.iters.push(expr);
-                } else {
-                    self.seen_other = true;
+        if_chain! {
+            if let ExprKind::MethodCall(method_name, _, ref args, _) = &expr.kind;
+            if let Some(Expr { kind: ExprKind::Path(QPath::Resolved(_, ref path)), .. }) = args.get(0);
+            if match_path(path, &[&self.target]);
+            then {
+                let into_iter = sym!(into_iter);
+                let len = sym!(len);
+                let is_empty = sym!(is_empty);
+                let contains = sym!(contains);
+                match method_name.ident.name {
+                    name if name == into_iter => self.uses.push(IterFunction { func: IterFunctionKind::IntoIter, span: expr.span }),
+                    name if name == len => self.uses.push(IterFunction { func: IterFunctionKind::Len, span: expr.span }),
+                    name if name == is_empty => self.uses.push(IterFunction { func: IterFunctionKind::IsEmpty, span: expr.span }),
+                    name if name == contains => self.uses.push(IterFunction { func: IterFunctionKind::Contains(args[1].span), span: expr.span }),
+                    _ => self.seen_other = true,
                 }
-            },
-            _ => walk_expr(self, expr),
+            }
+            else {
+                walk_expr(self, expr);
+            }
         }
     }
 
@@ -2506,9 +2536,9 @@ impl<'tcx> Visitor<'tcx> for IntoIterVisitor<'tcx> {
 
 /// Detect the occurences of calls to `iter` or `into_iter` for the
 /// given identifier
-fn detect_iter_and_into_iters<'tcx>(block: &'tcx Block<'tcx>, identifier: Ident) -> Option<Vec<&'tcx Expr<'tcx>>> {
-    let mut visitor = IntoIterVisitor {
-        iters: Vec::new(),
+fn detect_iter_and_into_iters<'tcx>(block: &'tcx Block<'tcx>, identifier: Ident) -> Option<Vec<IterFunction>> {
+    let mut visitor = IterFunctionVisitor {
+        uses: Vec::new(),
         target: identifier.name.to_ident_string(),
         seen_other: false,
     };
@@ -2516,7 +2546,7 @@ fn detect_iter_and_into_iters<'tcx>(block: &'tcx Block<'tcx>, identifier: Ident)
     if visitor.seen_other {
         None
     } else {
-        Some(visitor.iters)
+        Some(visitor.uses)
     }
 }
 
-- 
cgit 1.4.1-3-g733a5


From a84948329459e650af4eb2f8cff8f55282316ea5 Mon Sep 17 00:00:00 2001
From: JarredAllen <jarredallen73@gmail.com>
Date: Thu, 23 Jul 2020 09:44:44 -0700
Subject: Fix formatting and dogfood fallout

---
 clippy_lints/src/loops.rs                 | 43 ++++++++++++++++++++++++-------
 tests/ui/needless_collect_indirect.fixed  |  6 +----
 tests/ui/needless_collect_indirect.rs     |  6 +----
 tests/ui/needless_collect_indirect.stderr | 12 ++++-----
 4 files changed, 41 insertions(+), 26 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 11a9b1e531c..2181304f006 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -2359,7 +2359,10 @@ impl<'a, 'tcx> Visitor<'tcx> for VarCollectorVisitor<'a, 'tcx> {
 const NEEDLESS_COLLECT_MSG: &str = "avoid using `collect()` when not needed";
 
 fn check_needless_collect<'tcx>(expr: &'tcx Expr<'_>, cx: &LateContext<'tcx>) {
-    // Check for direct, immediate usage
+    check_needless_collect_direct_usage(expr, cx);
+    check_needless_collect_indirect_usage(expr, cx);
+}
+fn check_needless_collect_direct_usage<'tcx>(expr: &'tcx Expr<'_>, cx: &LateContext<'tcx>) {
     if_chain! {
         if let ExprKind::MethodCall(ref method, _, ref args, _) = expr.kind;
         if let ExprKind::MethodCall(ref chain_method, _, _, _) = args[0].kind;
@@ -2425,7 +2428,9 @@ fn check_needless_collect<'tcx>(expr: &'tcx Expr<'_>, cx: &LateContext<'tcx>) {
             }
         }
     }
-    // Check for collecting it and then turning it back into an iterator later
+}
+
+fn check_needless_collect_indirect_usage<'tcx>(expr: &'tcx Expr<'_>, cx: &LateContext<'tcx>) {
     if let ExprKind::Block(ref block, _) = expr.kind {
         for ref stmt in block.stmts {
             if_chain! {
@@ -2484,10 +2489,18 @@ impl IterFunction {
     }
     fn get_suggestion_text(&self) -> &'static str {
         match &self.func {
-            IterFunctionKind::IntoIter => "Use the original Iterator instead of collecting it and then producing a new one",
-            IterFunctionKind::Len => "Take the original Iterator's count instead of collecting it and finding the length",
-            IterFunctionKind::IsEmpty => "Check if the original Iterator has anything instead of collecting it and seeing if it's empty",
-            IterFunctionKind::Contains(_) => "Check if the original Iterator contains an element instead of collecting then checking",
+            IterFunctionKind::IntoIter => {
+                "Use the original Iterator instead of collecting it and then producing a new one"
+            },
+            IterFunctionKind::Len => {
+                "Take the original Iterator's count instead of collecting it and finding the length"
+            },
+            IterFunctionKind::IsEmpty => {
+                "Check if the original Iterator has anything instead of collecting it and seeing if it's empty"
+            },
+            IterFunctionKind::Contains(_) => {
+                "Check if the original Iterator contains an element instead of collecting then checking"
+            },
         }
     }
 }
@@ -2505,6 +2518,8 @@ struct IterFunctionVisitor {
 }
 impl<'tcx> Visitor<'tcx> for IterFunctionVisitor {
     fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) {
+        // TODO Check if the target identifier is being used in something other
+        // than a function call
         if_chain! {
             if let ExprKind::MethodCall(method_name, _, ref args, _) = &expr.kind;
             if let Some(Expr { kind: ExprKind::Path(QPath::Resolved(_, ref path)), .. }) = args.get(0);
@@ -2515,10 +2530,18 @@ impl<'tcx> Visitor<'tcx> for IterFunctionVisitor {
                 let is_empty = sym!(is_empty);
                 let contains = sym!(contains);
                 match method_name.ident.name {
-                    name if name == into_iter => self.uses.push(IterFunction { func: IterFunctionKind::IntoIter, span: expr.span }),
-                    name if name == len => self.uses.push(IterFunction { func: IterFunctionKind::Len, span: expr.span }),
-                    name if name == is_empty => self.uses.push(IterFunction { func: IterFunctionKind::IsEmpty, span: expr.span }),
-                    name if name == contains => self.uses.push(IterFunction { func: IterFunctionKind::Contains(args[1].span), span: expr.span }),
+                    name if name == into_iter => self.uses.push(
+                        IterFunction { func: IterFunctionKind::IntoIter, span: expr.span }
+                    ),
+                    name if name == len => self.uses.push(
+                        IterFunction { func: IterFunctionKind::Len, span: expr.span }
+                    ),
+                    name if name == is_empty => self.uses.push(
+                        IterFunction { func: IterFunctionKind::IsEmpty, span: expr.span }
+                    ),
+                    name if name == contains => self.uses.push(
+                        IterFunction { func: IterFunctionKind::Contains(args[1].span), span: expr.span }
+                    ),
                     _ => self.seen_other = true,
                 }
             }
diff --git a/tests/ui/needless_collect_indirect.fixed b/tests/ui/needless_collect_indirect.fixed
index 136af42a9fe..163eaf965dd 100644
--- a/tests/ui/needless_collect_indirect.fixed
+++ b/tests/ui/needless_collect_indirect.fixed
@@ -1,16 +1,12 @@
 // run-rustfix
 
 #[allow(unused)]
-
 use std::collections::{HashMap, VecDeque};
 
 fn main() {
     let sample = [1; 5];
     let indirect_iter = sample.iter().collect::<Vec<_>>();
-    indirect_iter
-        .into_iter()
-        .map(|x| (x, x + 1))
-        .collect::<HashMap<_, _>>();
+    indirect_iter.into_iter().map(|x| (x, x + 1)).collect::<HashMap<_, _>>();
     let indirect_len = sample.iter().collect::<VecDeque<_>>();
     indirect_len.len();
     let indirect_empty = sample.iter().collect::<VecDeque<_>>();
diff --git a/tests/ui/needless_collect_indirect.rs b/tests/ui/needless_collect_indirect.rs
index 136af42a9fe..163eaf965dd 100644
--- a/tests/ui/needless_collect_indirect.rs
+++ b/tests/ui/needless_collect_indirect.rs
@@ -1,16 +1,12 @@
 // run-rustfix
 
 #[allow(unused)]
-
 use std::collections::{HashMap, VecDeque};
 
 fn main() {
     let sample = [1; 5];
     let indirect_iter = sample.iter().collect::<Vec<_>>();
-    indirect_iter
-        .into_iter()
-        .map(|x| (x, x + 1))
-        .collect::<HashMap<_, _>>();
+    indirect_iter.into_iter().map(|x| (x, x + 1)).collect::<HashMap<_, _>>();
     let indirect_len = sample.iter().collect::<VecDeque<_>>();
     indirect_len.len();
     let indirect_empty = sample.iter().collect::<VecDeque<_>>();
diff --git a/tests/ui/needless_collect_indirect.stderr b/tests/ui/needless_collect_indirect.stderr
index 5058c171ac2..700c73b0b22 100644
--- a/tests/ui/needless_collect_indirect.stderr
+++ b/tests/ui/needless_collect_indirect.stderr
@@ -1,19 +1,19 @@
 error: avoid using `collect()` when not needed
-  --> $DIR/needless_collect_indirect.rs:9:5
+  --> $DIR/needless_collect_indirect.rs:8:5
    |
 LL | /     let indirect_iter = sample.iter().collect::<Vec<_>>();
-LL | |     indirect_iter
+LL | |     indirect_iter.into_iter().map(|x| (x, x + 1)).collect::<HashMap<_, _>>();
    | |____^
    |
    = note: `-D clippy::needless-collect` implied by `-D warnings`
 help: Use the original Iterator instead of collecting it and then producing a new one
    |
 LL |     
-LL |     sample.iter()
+LL |     sample.iter().map(|x| (x, x + 1)).collect::<HashMap<_, _>>();
    |
 
 error: avoid using `collect()` when not needed
-  --> $DIR/needless_collect_indirect.rs:14:5
+  --> $DIR/needless_collect_indirect.rs:10:5
    |
 LL | /     let indirect_len = sample.iter().collect::<VecDeque<_>>();
 LL | |     indirect_len.len();
@@ -26,7 +26,7 @@ LL |     sample.iter().count();
    |
 
 error: avoid using `collect()` when not needed
-  --> $DIR/needless_collect_indirect.rs:16:5
+  --> $DIR/needless_collect_indirect.rs:12:5
    |
 LL | /     let indirect_empty = sample.iter().collect::<VecDeque<_>>();
 LL | |     indirect_empty.is_empty();
@@ -39,7 +39,7 @@ LL |     sample.iter().next().is_none();
    |
 
 error: avoid using `collect()` when not needed
-  --> $DIR/needless_collect_indirect.rs:18:5
+  --> $DIR/needless_collect_indirect.rs:14:5
    |
 LL | /     let indirect_contains = sample.iter().collect::<VecDeque<_>>();
 LL | |     indirect_contains.contains(&&5);
-- 
cgit 1.4.1-3-g733a5


From bb2c14e92b5a0eafe9c9f43f3a02e33b544b3f91 Mon Sep 17 00:00:00 2001
From: JarredAllen <jarredallen73@gmail.com>
Date: Thu, 23 Jul 2020 10:07:51 -0700
Subject: Fix a bug causing it to be too trigger-happy

---
 clippy_lints/src/loops.rs | 28 ++++++++++++++++++----------
 1 file changed, 18 insertions(+), 10 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 2181304f006..c931c212735 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -5,10 +5,9 @@ use crate::utils::sugg::Sugg;
 use crate::utils::usage::{is_unused, mutated_variables};
 use crate::utils::{
     get_enclosing_block, get_parent_expr, get_trait_def_id, has_iter_method, higher, implements_trait,
-    is_integer_const, is_no_std_crate, is_refutable, is_type_diagnostic_item, last_path_segment, match_path,
-    match_trait_method, match_type, match_var, multispan_sugg, qpath_res, snippet, snippet_opt,
-    snippet_with_applicability, span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then, sugg,
-    SpanlessEq,
+    is_integer_const, is_no_std_crate, is_refutable, is_type_diagnostic_item, last_path_segment, match_trait_method,
+    match_type, match_var, multispan_sugg, qpath_res, snippet, snippet_opt, snippet_with_applicability, span_lint,
+    span_lint_and_help, span_lint_and_sugg, span_lint_and_then, sugg, SpanlessEq,
 };
 use if_chain::if_chain;
 use rustc_ast::ast;
@@ -2514,16 +2513,16 @@ enum IterFunctionKind {
 struct IterFunctionVisitor {
     uses: Vec<IterFunction>,
     seen_other: bool,
-    target: String,
+    target: Ident,
 }
 impl<'tcx> Visitor<'tcx> for IterFunctionVisitor {
     fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) {
-        // TODO Check if the target identifier is being used in something other
-        // than a function call
+        // Check function calls on our collection
         if_chain! {
             if let ExprKind::MethodCall(method_name, _, ref args, _) = &expr.kind;
             if let Some(Expr { kind: ExprKind::Path(QPath::Resolved(_, ref path)), .. }) = args.get(0);
-            if match_path(path, &[&self.target]);
+            if let &[name] = &path.segments;
+            if name.ident == self.target;
             then {
                 let into_iter = sym!(into_iter);
                 let len = sym!(len);
@@ -2544,8 +2543,17 @@ impl<'tcx> Visitor<'tcx> for IterFunctionVisitor {
                     ),
                     _ => self.seen_other = true,
                 }
+                return
             }
-            else {
+        }
+        // Check if the collection is used for anything else
+        if_chain! {
+            if let Expr { kind: ExprKind::Path(QPath::Resolved(_, ref path)), .. } = expr;
+            if let &[name] = &path.segments;
+            if name.ident == self.target;
+            then {
+                self.seen_other = true;
+            } else {
                 walk_expr(self, expr);
             }
         }
@@ -2562,7 +2570,7 @@ impl<'tcx> Visitor<'tcx> for IterFunctionVisitor {
 fn detect_iter_and_into_iters<'tcx>(block: &'tcx Block<'tcx>, identifier: Ident) -> Option<Vec<IterFunction>> {
     let mut visitor = IterFunctionVisitor {
         uses: Vec::new(),
-        target: identifier.name.to_ident_string(),
+        target: identifier,
         seen_other: false,
     };
     visitor.visit_block(block);
-- 
cgit 1.4.1-3-g733a5


From 5e10b039a3f215b48a54ce7dd38f95115f92e55a Mon Sep 17 00:00:00 2001
From: JarredAllen <jarredallen73@gmail.com>
Date: Sun, 2 Aug 2020 21:46:18 -0700
Subject: Implement review suggestions

---
 clippy_lints/src/loops.rs                 |  7 +++----
 tests/ui/needless_collect_indirect.fixed  | 22 ----------------------
 tests/ui/needless_collect_indirect.rs     |  3 ---
 tests/ui/needless_collect_indirect.stderr |  8 ++++----
 4 files changed, 7 insertions(+), 33 deletions(-)
 delete mode 100644 tests/ui/needless_collect_indirect.fixed

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index c931c212735..e9ce804320f 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -27,7 +27,7 @@ use rustc_middle::middle::region;
 use rustc_middle::ty::{self, Ty, TyS};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
-use rustc_span::symbol::{Ident, Symbol};
+use rustc_span::symbol::{sym, Ident, Symbol};
 use rustc_typeck::expr_use_visitor::{ConsumeMode, Delegate, ExprUseVisitor, PlaceBase, PlaceWithHirId};
 use std::iter::{once, Iterator};
 use std::mem;
@@ -2442,7 +2442,7 @@ fn check_needless_collect_indirect_usage<'tcx>(expr: &'tcx Expr<'_>, cx: &LateCo
                 if let Some(ref generic_args) = method_name.args;
                 if let Some(GenericArg::Type(ref ty)) = generic_args.args.get(0);
                 if let ty = cx.typeck_results().node_type(ty.hir_id);
-                if is_type_diagnostic_item(cx, ty, sym!(vec_type)) ||
+                if is_type_diagnostic_item(cx, ty, sym::vec_type) ||
                     is_type_diagnostic_item(cx, ty, sym!(vecdeque_type)) ||
                     match_type(cx, ty, &paths::LINKED_LIST);
                 if let Some(iter_calls) = detect_iter_and_into_iters(block, *ident);
@@ -2524,12 +2524,11 @@ impl<'tcx> Visitor<'tcx> for IterFunctionVisitor {
             if let &[name] = &path.segments;
             if name.ident == self.target;
             then {
-                let into_iter = sym!(into_iter);
                 let len = sym!(len);
                 let is_empty = sym!(is_empty);
                 let contains = sym!(contains);
                 match method_name.ident.name {
-                    name if name == into_iter => self.uses.push(
+                    sym::into_iter => self.uses.push(
                         IterFunction { func: IterFunctionKind::IntoIter, span: expr.span }
                     ),
                     name if name == len => self.uses.push(
diff --git a/tests/ui/needless_collect_indirect.fixed b/tests/ui/needless_collect_indirect.fixed
deleted file mode 100644
index 163eaf965dd..00000000000
--- a/tests/ui/needless_collect_indirect.fixed
+++ /dev/null
@@ -1,22 +0,0 @@
-// run-rustfix
-
-#[allow(unused)]
-use std::collections::{HashMap, VecDeque};
-
-fn main() {
-    let sample = [1; 5];
-    let indirect_iter = sample.iter().collect::<Vec<_>>();
-    indirect_iter.into_iter().map(|x| (x, x + 1)).collect::<HashMap<_, _>>();
-    let indirect_len = sample.iter().collect::<VecDeque<_>>();
-    indirect_len.len();
-    let indirect_empty = sample.iter().collect::<VecDeque<_>>();
-    indirect_empty.is_empty();
-    let indirect_contains = sample.iter().collect::<VecDeque<_>>();
-    indirect_contains.contains(&&5);
-    let indirect_negative = sample.iter().collect::<Vec<_>>();
-    indirect_negative.len();
-    indirect_negative
-        .into_iter()
-        .map(|x| (*x, *x + 1))
-        .collect::<HashMap<_, _>>();
-}
diff --git a/tests/ui/needless_collect_indirect.rs b/tests/ui/needless_collect_indirect.rs
index 163eaf965dd..4cf03e82035 100644
--- a/tests/ui/needless_collect_indirect.rs
+++ b/tests/ui/needless_collect_indirect.rs
@@ -1,6 +1,3 @@
-// run-rustfix
-
-#[allow(unused)]
 use std::collections::{HashMap, VecDeque};
 
 fn main() {
diff --git a/tests/ui/needless_collect_indirect.stderr b/tests/ui/needless_collect_indirect.stderr
index 700c73b0b22..0c1e61d7496 100644
--- a/tests/ui/needless_collect_indirect.stderr
+++ b/tests/ui/needless_collect_indirect.stderr
@@ -1,5 +1,5 @@
 error: avoid using `collect()` when not needed
-  --> $DIR/needless_collect_indirect.rs:8:5
+  --> $DIR/needless_collect_indirect.rs:5:5
    |
 LL | /     let indirect_iter = sample.iter().collect::<Vec<_>>();
 LL | |     indirect_iter.into_iter().map(|x| (x, x + 1)).collect::<HashMap<_, _>>();
@@ -13,7 +13,7 @@ LL |     sample.iter().map(|x| (x, x + 1)).collect::<HashMap<_, _>>();
    |
 
 error: avoid using `collect()` when not needed
-  --> $DIR/needless_collect_indirect.rs:10:5
+  --> $DIR/needless_collect_indirect.rs:7:5
    |
 LL | /     let indirect_len = sample.iter().collect::<VecDeque<_>>();
 LL | |     indirect_len.len();
@@ -26,7 +26,7 @@ LL |     sample.iter().count();
    |
 
 error: avoid using `collect()` when not needed
-  --> $DIR/needless_collect_indirect.rs:12:5
+  --> $DIR/needless_collect_indirect.rs:9:5
    |
 LL | /     let indirect_empty = sample.iter().collect::<VecDeque<_>>();
 LL | |     indirect_empty.is_empty();
@@ -39,7 +39,7 @@ LL |     sample.iter().next().is_none();
    |
 
 error: avoid using `collect()` when not needed
-  --> $DIR/needless_collect_indirect.rs:14:5
+  --> $DIR/needless_collect_indirect.rs:11:5
    |
 LL | /     let indirect_contains = sample.iter().collect::<VecDeque<_>>();
 LL | |     indirect_contains.contains(&&5);
-- 
cgit 1.4.1-3-g733a5


From e521c67e5f29ddd84e0ce744dfc27a836d349514 Mon Sep 17 00:00:00 2001
From: Christoph Walcher <christoph-wa@gmx.de>
Date: Mon, 3 Aug 2020 12:32:23 +0200
Subject: early return on empty parameters/where clause

---
 clippy_lints/src/trait_bounds.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/trait_bounds.rs b/clippy_lints/src/trait_bounds.rs
index 10811374875..06631f89f27 100644
--- a/clippy_lints/src/trait_bounds.rs
+++ b/clippy_lints/src/trait_bounds.rs
@@ -148,7 +148,7 @@ impl TraitBounds {
 }
 
 fn check_trait_bound_duplication(cx: &LateContext<'_>, gen: &'_ Generics<'_>) {
-    if in_macro(gen.span) {
+    if in_macro(gen.span) || gen.params.is_empty() || gen.where_clause.predicates.is_empty() {
         return;
     }
 
-- 
cgit 1.4.1-3-g733a5


From 25abd7ae76e2a708dda5487119c20af3be64edb7 Mon Sep 17 00:00:00 2001
From: JarredAllen <jarredallen73@gmail.com>
Date: Wed, 8 Jul 2020 20:29:56 -0700
Subject: Create stable_sort_primitive lint

---
 CHANGELOG.md                              |   1 +
 clippy_lints/src/lib.rs                   |   5 ++
 clippy_lints/src/stable_sort_primitive.rs | 130 ++++++++++++++++++++++++++++++
 clippy_lints/src/utils/mod.rs             |  30 +++++++
 src/lintlist/mod.rs                       |   7 ++
 tests/ui/stable_sort_primitive.fixed      |  32 ++++++++
 tests/ui/stable_sort_primitive.rs         |  32 ++++++++
 tests/ui/stable_sort_primitive.stderr     |  46 +++++++++++
 tests/ui/unnecessary_sort_by.fixed        |   2 +
 tests/ui/unnecessary_sort_by.rs           |   2 +
 tests/ui/unnecessary_sort_by.stderr       |  14 ++--
 11 files changed, 294 insertions(+), 7 deletions(-)
 create mode 100644 clippy_lints/src/stable_sort_primitive.rs
 create mode 100644 tests/ui/stable_sort_primitive.fixed
 create mode 100644 tests/ui/stable_sort_primitive.rs
 create mode 100644 tests/ui/stable_sort_primitive.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 776b04295f9..43a32e828d8 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1701,6 +1701,7 @@ Released 2018-09-13
 [`single_match_else`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_match_else
 [`skip_while_next`]: https://rust-lang.github.io/rust-clippy/master/index.html#skip_while_next
 [`slow_vector_initialization`]: https://rust-lang.github.io/rust-clippy/master/index.html#slow_vector_initialization
+[`stable_sort_primitive`]: https://rust-lang.github.io/rust-clippy/master/index.html#stable_sort_primitive
 [`str_to_string`]: https://rust-lang.github.io/rust-clippy/master/index.html#str_to_string
 [`string_add`]: https://rust-lang.github.io/rust-clippy/master/index.html#string_add
 [`string_add_assign`]: https://rust-lang.github.io/rust-clippy/master/index.html#string_add_assign
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index f371942dbee..9fc07e07fd3 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -288,6 +288,7 @@ mod serde_api;
 mod shadow;
 mod single_component_path_imports;
 mod slow_vector_initialization;
+mod stable_sort_primitive;
 mod strings;
 mod suspicious_trait_impl;
 mod swap;
@@ -776,6 +777,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &shadow::SHADOW_UNRELATED,
         &single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS,
         &slow_vector_initialization::SLOW_VECTOR_INITIALIZATION,
+        &stable_sort_primitive::STABLE_SORT_PRIMITIVE,
         &strings::STRING_ADD,
         &strings::STRING_ADD_ASSIGN,
         &strings::STRING_LIT_AS_BYTES,
@@ -1078,6 +1080,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box macro_use::MacroUseImports::default());
     store.register_late_pass(|| box map_identity::MapIdentity);
     store.register_late_pass(|| box pattern_type_mismatch::PatternTypeMismatch);
+    store.register_late_pass(|| box stable_sort_primitive::StableSortPrimitive);
     store.register_late_pass(|| box repeat_once::RepeatOnce);
 
     store.register_group(true, "clippy::restriction", Some("clippy_restriction"), vec![
@@ -1408,6 +1411,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&serde_api::SERDE_API_MISUSE),
         LintId::of(&single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS),
         LintId::of(&slow_vector_initialization::SLOW_VECTOR_INITIALIZATION),
+        LintId::of(&stable_sort_primitive::STABLE_SORT_PRIMITIVE),
         LintId::of(&strings::STRING_LIT_AS_BYTES),
         LintId::of(&suspicious_trait_impl::SUSPICIOUS_ARITHMETIC_IMPL),
         LintId::of(&suspicious_trait_impl::SUSPICIOUS_OP_ASSIGN_IMPL),
@@ -1723,6 +1727,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&mutex_atomic::MUTEX_ATOMIC),
         LintId::of(&redundant_clone::REDUNDANT_CLONE),
         LintId::of(&slow_vector_initialization::SLOW_VECTOR_INITIALIZATION),
+        LintId::of(&stable_sort_primitive::STABLE_SORT_PRIMITIVE),
         LintId::of(&types::BOX_VEC),
         LintId::of(&types::REDUNDANT_ALLOCATION),
         LintId::of(&vec::USELESS_VEC),
diff --git a/clippy_lints/src/stable_sort_primitive.rs b/clippy_lints/src/stable_sort_primitive.rs
new file mode 100644
index 00000000000..c48da004a60
--- /dev/null
+++ b/clippy_lints/src/stable_sort_primitive.rs
@@ -0,0 +1,130 @@
+use crate::utils::{is_slice_of_primitives, span_lint_and_sugg, sugg::Sugg};
+
+use if_chain::if_chain;
+
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// **What it does:**
+    /// When sorting primitive values (integers, bools, chars, as well
+    /// as arrays, slices, and tuples of such items), it is better to
+    /// use an unstable sort than a stable sort.
+    ///
+    /// **Why is this bad?**
+    /// Using a stable sort consumes more memory and cpu cycles. Because
+    /// values which compare equal are identical, preserving their
+    /// relative order (the guarantee that a stable sort provides) means
+    /// nothing, while the extra costs still apply.
+    ///
+    /// **Known problems:**
+    /// None
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// let mut vec = vec![2, 1, 3];
+    /// vec.sort();
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// let mut vec = vec![2, 1, 3];
+    /// vec.sort_unstable();
+    /// ```
+    pub STABLE_SORT_PRIMITIVE,
+    perf,
+    "use of sort() when sort_unstable() is equivalent"
+}
+
+declare_lint_pass!(StableSortPrimitive => [STABLE_SORT_PRIMITIVE]);
+
+/// The three "kinds" of sorts
+enum SortingKind {
+    Vanilla,
+    // The other kinds of lint are currently commented out because they
+    // can map distinct values to equal ones. If the key function is
+    // provably one-to-one, or if the Cmp function conserves equality,
+    // then they could be linted on, but I don't know if we can check
+    // for that.
+
+    // ByKey,
+    // ByCmp,
+}
+impl SortingKind {
+    /// The name of the stable version of this kind of sort
+    fn stable_name(&self) -> &str {
+        match self {
+            SortingKind::Vanilla => "sort",
+            // SortingKind::ByKey => "sort_by_key",
+            // SortingKind::ByCmp => "sort_by",
+        }
+    }
+    /// The name of the unstable version of this kind of sort
+    fn unstable_name(&self) -> &str {
+        match self {
+            SortingKind::Vanilla => "sort_unstable",
+            // SortingKind::ByKey => "sort_unstable_by_key",
+            // SortingKind::ByCmp => "sort_unstable_by",
+        }
+    }
+    /// Takes the name of a function call and returns the kind of sort
+    /// that corresponds to that function name (or None if it isn't)
+    fn from_stable_name(name: &str) -> Option<SortingKind> {
+        match name {
+            "sort" => Some(SortingKind::Vanilla),
+            // "sort_by" => Some(SortingKind::ByCmp),
+            // "sort_by_key" => Some(SortingKind::ByKey),
+            _ => None,
+        }
+    }
+}
+
+/// A detected instance of this lint
+struct LintDetection {
+    slice_name: String,
+    method: SortingKind,
+    method_args: String,
+}
+
+fn detect_stable_sort_primitive(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<LintDetection> {
+    if_chain! {
+        if let ExprKind::MethodCall(method_name, _, args, _) = &expr.kind;
+        if let Some(slice) = &args.get(0);
+        if let Some(method) = SortingKind::from_stable_name(&method_name.ident.name.as_str());
+        if is_slice_of_primitives(cx, slice);
+        then {
+            let args_str = args.iter().skip(1).map(|arg| Sugg::hir(cx, arg, "..").to_string()).collect::<Vec<String>>().join(", ");
+            Some(LintDetection { slice_name: Sugg::hir(cx, slice, "..").to_string(), method, method_args: args_str })
+        } else {
+            None
+        }
+    }
+}
+
+impl LateLintPass<'_> for StableSortPrimitive {
+    fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
+        if let Some(detection) = detect_stable_sort_primitive(cx, expr) {
+            span_lint_and_sugg(
+                cx,
+                STABLE_SORT_PRIMITIVE,
+                expr.span,
+                format!(
+                    "Use {} instead of {}",
+                    detection.method.unstable_name(),
+                    detection.method.stable_name()
+                )
+                .as_str(),
+                "try",
+                format!(
+                    "{}.{}({})",
+                    detection.slice_name,
+                    detection.method.unstable_name(),
+                    detection.method_args
+                ),
+                Applicability::MachineApplicable,
+            );
+        }
+    }
+}
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index 655b1133cf7..c75f8042907 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -1378,6 +1378,36 @@ pub fn run_lints(cx: &LateContext<'_>, lints: &[&'static Lint], id: HirId) -> bo
     })
 }
 
+/// Returns true iff the given type is a primitive (a bool or char, any integer or floating-point
+/// number type, a str, or an array, slice, or tuple of those types).
+pub fn is_recursively_primitive_type(ty: Ty<'_>) -> bool {
+    match ty.kind {
+        ty::Bool | ty::Char | ty::Int(_) | ty::Uint(_) | ty::Float(_) | ty::Str => true,
+        ty::Ref(_, inner, _) if inner.kind == ty::Str => true,
+        ty::Array(inner_type, _) | ty::Slice(inner_type) => is_recursively_primitive_type(inner_type),
+        ty::Tuple(inner_types) => inner_types.types().all(is_recursively_primitive_type),
+        _ => false,
+    }
+}
+
+/// Returns true iff the given expression is a slice of primitives (as defined in the
+/// `is_recursively_primitive_type` function).
+pub fn is_slice_of_primitives(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+    let expr_type = cx.typeck_results().expr_ty_adjusted(expr);
+    match expr_type.kind {
+        ty::Slice(ref element_type)
+        | ty::Ref(
+            _,
+            ty::TyS {
+                kind: ty::Slice(ref element_type),
+                ..
+            },
+            _,
+        ) => is_recursively_primitive_type(element_type),
+        _ => false,
+    }
+}
+
 #[macro_export]
 macro_rules! unwrap_cargo_metadata {
     ($cx: ident, $lint: ident, $deps: expr) => {{
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index 1879aae77fb..41d06a67881 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -2026,6 +2026,13 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
         deprecation: None,
         module: "slow_vector_initialization",
     },
+    Lint {
+        name: "stable_sort_primitive",
+        group: "perf",
+        desc: "use of sort() when sort_unstable() is equivalent",
+        deprecation: None,
+        module: "stable_sort_primitive",
+    },
     Lint {
         name: "string_add",
         group: "restriction",
diff --git a/tests/ui/stable_sort_primitive.fixed b/tests/ui/stable_sort_primitive.fixed
new file mode 100644
index 00000000000..8f8f5665931
--- /dev/null
+++ b/tests/ui/stable_sort_primitive.fixed
@@ -0,0 +1,32 @@
+// run-rustfix
+#![warn(clippy::stable_sort_primitive)]
+
+fn main() {
+    // positive examples
+    let mut vec = vec![1, 3, 2];
+    vec.sort_unstable();
+    let mut vec = vec![false, false, true];
+    vec.sort_unstable();
+    let mut vec = vec!['a', 'A', 'c'];
+    vec.sort_unstable();
+    let mut vec = vec!["ab", "cd", "ab", "bc"];
+    vec.sort_unstable();
+    let mut vec = vec![(2, 1), (1, 2), (2, 5)];
+    vec.sort_unstable();
+    let mut vec = vec![[2, 1], [1, 2], [2, 5]];
+    vec.sort_unstable();
+    let mut arr = [1, 3, 2];
+    arr.sort_unstable();
+    // Negative examples: behavior changes if made unstable
+    let mut vec = vec![1, 3, 2];
+    vec.sort_by_key(|i| i / 2);
+    vec.sort_by(|a, b| (a + b).cmp(&b));
+    // negative examples - Not of a primitive type
+    let mut vec_of_complex = vec![String::from("hello"), String::from("world!")];
+    vec_of_complex.sort();
+    vec_of_complex.sort_by_key(String::len);
+    let mut vec = vec![(String::from("hello"), String::from("world"))];
+    vec.sort();
+    let mut vec = vec![[String::from("hello"), String::from("world")]];
+    vec.sort();
+}
diff --git a/tests/ui/stable_sort_primitive.rs b/tests/ui/stable_sort_primitive.rs
new file mode 100644
index 00000000000..f9bd9779067
--- /dev/null
+++ b/tests/ui/stable_sort_primitive.rs
@@ -0,0 +1,32 @@
+// run-rustfix
+#![warn(clippy::stable_sort_primitive)]
+
+fn main() {
+    // positive examples
+    let mut vec = vec![1, 3, 2];
+    vec.sort();
+    let mut vec = vec![false, false, true];
+    vec.sort();
+    let mut vec = vec!['a', 'A', 'c'];
+    vec.sort();
+    let mut vec = vec!["ab", "cd", "ab", "bc"];
+    vec.sort();
+    let mut vec = vec![(2, 1), (1, 2), (2, 5)];
+    vec.sort();
+    let mut vec = vec![[2, 1], [1, 2], [2, 5]];
+    vec.sort();
+    let mut arr = [1, 3, 2];
+    arr.sort();
+    // Negative examples: behavior changes if made unstable
+    let mut vec = vec![1, 3, 2];
+    vec.sort_by_key(|i| i / 2);
+    vec.sort_by(|a, b| (a + b).cmp(&b));
+    // negative examples - Not of a primitive type
+    let mut vec_of_complex = vec![String::from("hello"), String::from("world!")];
+    vec_of_complex.sort();
+    vec_of_complex.sort_by_key(String::len);
+    let mut vec = vec![(String::from("hello"), String::from("world"))];
+    vec.sort();
+    let mut vec = vec![[String::from("hello"), String::from("world")]];
+    vec.sort();
+}
diff --git a/tests/ui/stable_sort_primitive.stderr b/tests/ui/stable_sort_primitive.stderr
new file mode 100644
index 00000000000..b0b729ede48
--- /dev/null
+++ b/tests/ui/stable_sort_primitive.stderr
@@ -0,0 +1,46 @@
+error: Use sort_unstable instead of sort
+  --> $DIR/stable_sort_primitive.rs:7:5
+   |
+LL |     vec.sort();
+   |     ^^^^^^^^^^ help: try: `vec.sort_unstable()`
+   |
+   = note: `-D clippy::stable-sort-primitive` implied by `-D warnings`
+
+error: Use sort_unstable instead of sort
+  --> $DIR/stable_sort_primitive.rs:9:5
+   |
+LL |     vec.sort();
+   |     ^^^^^^^^^^ help: try: `vec.sort_unstable()`
+
+error: Use sort_unstable instead of sort
+  --> $DIR/stable_sort_primitive.rs:11:5
+   |
+LL |     vec.sort();
+   |     ^^^^^^^^^^ help: try: `vec.sort_unstable()`
+
+error: Use sort_unstable instead of sort
+  --> $DIR/stable_sort_primitive.rs:13:5
+   |
+LL |     vec.sort();
+   |     ^^^^^^^^^^ help: try: `vec.sort_unstable()`
+
+error: Use sort_unstable instead of sort
+  --> $DIR/stable_sort_primitive.rs:15:5
+   |
+LL |     vec.sort();
+   |     ^^^^^^^^^^ help: try: `vec.sort_unstable()`
+
+error: Use sort_unstable instead of sort
+  --> $DIR/stable_sort_primitive.rs:17:5
+   |
+LL |     vec.sort();
+   |     ^^^^^^^^^^ help: try: `vec.sort_unstable()`
+
+error: Use sort_unstable instead of sort
+  --> $DIR/stable_sort_primitive.rs:19:5
+   |
+LL |     arr.sort();
+   |     ^^^^^^^^^^ help: try: `arr.sort_unstable()`
+
+error: aborting due to 7 previous errors
+
diff --git a/tests/ui/unnecessary_sort_by.fixed b/tests/ui/unnecessary_sort_by.fixed
index c017d1cf9a4..31c2ba0f9c5 100644
--- a/tests/ui/unnecessary_sort_by.fixed
+++ b/tests/ui/unnecessary_sort_by.fixed
@@ -1,5 +1,7 @@
 // run-rustfix
 
+#![allow(clippy::stable_sort_primitive)]
+
 use std::cmp::Reverse;
 
 fn unnecessary_sort_by() {
diff --git a/tests/ui/unnecessary_sort_by.rs b/tests/ui/unnecessary_sort_by.rs
index 1929c72b2f2..a3c8ae468ed 100644
--- a/tests/ui/unnecessary_sort_by.rs
+++ b/tests/ui/unnecessary_sort_by.rs
@@ -1,5 +1,7 @@
 // run-rustfix
 
+#![allow(clippy::stable_sort_primitive)]
+
 use std::cmp::Reverse;
 
 fn unnecessary_sort_by() {
diff --git a/tests/ui/unnecessary_sort_by.stderr b/tests/ui/unnecessary_sort_by.stderr
index 903b6e5099c..70c6cf0a3b6 100644
--- a/tests/ui/unnecessary_sort_by.stderr
+++ b/tests/ui/unnecessary_sort_by.stderr
@@ -1,5 +1,5 @@
 error: use Vec::sort here instead
-  --> $DIR/unnecessary_sort_by.rs:12:5
+  --> $DIR/unnecessary_sort_by.rs:14:5
    |
 LL |     vec.sort_by(|a, b| a.cmp(b));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort()`
@@ -7,37 +7,37 @@ LL |     vec.sort_by(|a, b| a.cmp(b));
    = note: `-D clippy::unnecessary-sort-by` implied by `-D warnings`
 
 error: use Vec::sort here instead
-  --> $DIR/unnecessary_sort_by.rs:13:5
+  --> $DIR/unnecessary_sort_by.rs:15:5
    |
 LL |     vec.sort_unstable_by(|a, b| a.cmp(b));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_unstable()`
 
 error: use Vec::sort_by_key here instead
-  --> $DIR/unnecessary_sort_by.rs:14:5
+  --> $DIR/unnecessary_sort_by.rs:16:5
    |
 LL |     vec.sort_by(|a, b| (a + 5).abs().cmp(&(b + 5).abs()));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_by_key(|&a| (a + 5).abs())`
 
 error: use Vec::sort_by_key here instead
-  --> $DIR/unnecessary_sort_by.rs:15:5
+  --> $DIR/unnecessary_sort_by.rs:17:5
    |
 LL |     vec.sort_unstable_by(|a, b| id(-a).cmp(&id(-b)));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_unstable_by_key(|&a| id(-a))`
 
 error: use Vec::sort_by_key here instead
-  --> $DIR/unnecessary_sort_by.rs:17:5
+  --> $DIR/unnecessary_sort_by.rs:19:5
    |
 LL |     vec.sort_by(|a, b| b.cmp(a));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_by_key(|&b| Reverse(b))`
 
 error: use Vec::sort_by_key here instead
-  --> $DIR/unnecessary_sort_by.rs:18:5
+  --> $DIR/unnecessary_sort_by.rs:20:5
    |
 LL |     vec.sort_by(|a, b| (b + 5).abs().cmp(&(a + 5).abs()));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_by_key(|&b| Reverse((b + 5).abs()))`
 
 error: use Vec::sort_by_key here instead
-  --> $DIR/unnecessary_sort_by.rs:19:5
+  --> $DIR/unnecessary_sort_by.rs:21:5
    |
 LL |     vec.sort_unstable_by(|a, b| id(-b).cmp(&id(-a)));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_unstable_by_key(|&b| Reverse(id(-b)))`
-- 
cgit 1.4.1-3-g733a5


From e9677105bf85a2b0c57e8d67d2ed22a286333033 Mon Sep 17 00:00:00 2001
From: Tomasz Miąsko <tomasz.miasko@gmail.com>
Date: Sun, 2 Aug 2020 00:00:00 +0000
Subject: try_err: Consider Try impl for Poll when generating suggestions

There are two different implementation of Try trait for Poll type;
Poll<Result<T, E>> and Poll<Option<Result<T, E>>>. Take them into
account when generating suggestions.

For example, for Err(e)? suggest either return Poll::Ready(Err(e)) or
return Poll::Ready(Some(Err(e))) as appropriate.
---
 clippy_lints/src/try_err.rs     | 112 +++++++++++++++++++++++++++++++---------
 clippy_lints/src/utils/paths.rs |   2 +-
 tests/ui/try_err.fixed          |  21 ++++++++
 tests/ui/try_err.rs             |  21 ++++++++
 tests/ui/try_err.stderr         |  30 ++++++++---
 5 files changed, 155 insertions(+), 31 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/try_err.rs b/clippy_lints/src/try_err.rs
index d3b351f30ef..3bd73d9f21a 100644
--- a/clippy_lints/src/try_err.rs
+++ b/clippy_lints/src/try_err.rs
@@ -1,10 +1,13 @@
-use crate::utils::{match_qpath, paths, snippet, snippet_with_macro_callsite, span_lint_and_sugg};
+use crate::utils::{
+    is_type_diagnostic_item, match_def_path, match_qpath, paths, snippet, snippet_with_macro_callsite,
+    span_lint_and_sugg,
+};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
-use rustc_hir::{Arm, Expr, ExprKind, MatchSource};
+use rustc_hir::{Expr, ExprKind, MatchSource};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::lint::in_external_macro;
-use rustc_middle::ty::Ty;
+use rustc_middle::ty::{self, Ty};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
@@ -65,19 +68,39 @@ impl<'tcx> LateLintPass<'tcx> for TryErr {
             if let Some(ref err_arg) = err_args.get(0);
             if let ExprKind::Path(ref err_fun_path) = err_fun.kind;
             if match_qpath(err_fun_path, &paths::RESULT_ERR);
-            if let Some(return_type) = find_err_return_type(cx, &expr.kind);
-
+            if let Some(return_ty) = find_return_type(cx, &expr.kind);
             then {
-                let err_type = cx.typeck_results().expr_ty(err_arg);
+                let prefix;
+                let suffix;
+                let err_ty;
+
+                if let Some(ty) = result_error_type(cx, return_ty) {
+                    prefix = "Err(";
+                    suffix = ")";
+                    err_ty = ty;
+                } else if let Some(ty) = poll_result_error_type(cx, return_ty) {
+                    prefix = "Poll::Ready(Err(";
+                    suffix = "))";
+                    err_ty = ty;
+                } else if let Some(ty) = poll_option_result_error_type(cx, return_ty) {
+                    prefix = "Poll::Ready(Some(Err(";
+                    suffix = ")))";
+                    err_ty = ty;
+                } else {
+                    return;
+                };
+
+                let expr_err_ty = cx.typeck_results().expr_ty(err_arg);
+
                 let origin_snippet = if err_arg.span.from_expansion() {
                     snippet_with_macro_callsite(cx, err_arg.span, "_")
                 } else {
                     snippet(cx, err_arg.span, "_")
                 };
-                let suggestion = if err_type == return_type {
-                    format!("return Err({})", origin_snippet)
+                let suggestion = if err_ty == expr_err_ty {
+                    format!("return {}{}{}", prefix, origin_snippet, suffix)
                 } else {
-                    format!("return Err({}.into())", origin_snippet)
+                    format!("return {}{}.into(){}", prefix, origin_snippet, suffix)
                 };
 
                 span_lint_and_sugg(
@@ -94,27 +117,68 @@ impl<'tcx> LateLintPass<'tcx> for TryErr {
     }
 }
 
-// In order to determine whether to suggest `.into()` or not, we need to find the error type the
-// function returns. To do that, we look for the From::from call (see tree above), and capture
-// its output type.
-fn find_err_return_type<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx ExprKind<'_>) -> Option<Ty<'tcx>> {
+/// Finds function return type by examining return expressions in match arms.
+fn find_return_type<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx ExprKind<'_>) -> Option<Ty<'tcx>> {
     if let ExprKind::Match(_, ref arms, MatchSource::TryDesugar) = expr {
-        arms.iter().find_map(|ty| find_err_return_type_arm(cx, ty))
-    } else {
-        None
+        for arm in arms.iter() {
+            if let ExprKind::Ret(Some(ref ret)) = arm.body.kind {
+                return Some(cx.typeck_results().expr_ty(ret));
+            }
+        }
     }
+    None
 }
 
-// Check for From::from in one of the match arms.
-fn find_err_return_type_arm<'tcx>(cx: &LateContext<'tcx>, arm: &'tcx Arm<'_>) -> Option<Ty<'tcx>> {
+/// Extracts the error type from Result<T, E>.
+fn result_error_type<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Option<Ty<'tcx>> {
     if_chain! {
-        if let ExprKind::Ret(Some(ref err_ret)) = arm.body.kind;
-        if let ExprKind::Call(ref from_error_path, ref from_error_args) = err_ret.kind;
-        if let ExprKind::Path(ref from_error_fn) = from_error_path.kind;
-        if match_qpath(from_error_fn, &paths::TRY_FROM_ERROR);
-        if let Some(from_error_arg) = from_error_args.get(0);
+        if let ty::Adt(_, subst) = ty.kind;
+        if is_type_diagnostic_item(cx, ty, sym!(result_type));
+        let err_ty = subst.type_at(1);
+        then {
+            Some(err_ty)
+        } else {
+            None
+        }
+    }
+}
+
+/// Extracts the error type from Poll<Result<T, E>>.
+fn poll_result_error_type<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Option<Ty<'tcx>> {
+    if_chain! {
+        if let ty::Adt(def, subst) = ty.kind;
+        if match_def_path(cx, def.did, &paths::POLL);
+        let ready_ty = subst.type_at(0);
+
+        if let ty::Adt(ready_def, ready_subst) = ready_ty.kind;
+        if cx.tcx.is_diagnostic_item(sym!(result_type), ready_def.did);
+        let err_ty = ready_subst.type_at(1);
+
+        then {
+            Some(err_ty)
+        } else {
+            None
+        }
+    }
+}
+
+/// Extracts the error type from Poll<Option<Result<T, E>>>.
+fn poll_option_result_error_type<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Option<Ty<'tcx>> {
+    if_chain! {
+        if let ty::Adt(def, subst) = ty.kind;
+        if match_def_path(cx, def.did, &paths::POLL);
+        let ready_ty = subst.type_at(0);
+
+        if let ty::Adt(ready_def, ready_subst) = ready_ty.kind;
+        if cx.tcx.is_diagnostic_item(sym!(option_type), ready_def.did);
+        let some_ty = ready_subst.type_at(0);
+
+        if let ty::Adt(some_def, some_subst) = some_ty.kind;
+        if cx.tcx.is_diagnostic_item(sym!(result_type), some_def.did);
+        let err_ty = some_subst.type_at(1);
+
         then {
-            Some(cx.typeck_results().expr_ty(from_error_arg))
+            Some(err_ty)
         } else {
             None
         }
diff --git a/clippy_lints/src/utils/paths.rs b/clippy_lints/src/utils/paths.rs
index a515ee29c82..923b319d777 100644
--- a/clippy_lints/src/utils/paths.rs
+++ b/clippy_lints/src/utils/paths.rs
@@ -80,6 +80,7 @@ pub const PATH: [&str; 3] = ["std", "path", "Path"];
 pub const PATH_BUF: [&str; 3] = ["std", "path", "PathBuf"];
 pub const PATH_BUF_AS_PATH: [&str; 4] = ["std", "path", "PathBuf", "as_path"];
 pub const PATH_TO_PATH_BUF: [&str; 4] = ["std", "path", "Path", "to_path_buf"];
+pub const POLL: [&str; 4] = ["core", "task", "poll", "Poll"];
 pub const PTR_EQ: [&str; 3] = ["core", "ptr", "eq"];
 pub const PTR_NULL: [&str; 2] = ["ptr", "null"];
 pub const PTR_NULL_MUT: [&str; 2] = ["ptr", "null_mut"];
@@ -129,7 +130,6 @@ pub const TO_STRING: [&str; 3] = ["alloc", "string", "ToString"];
 pub const TO_STRING_METHOD: [&str; 4] = ["alloc", "string", "ToString", "to_string"];
 pub const TRANSMUTE: [&str; 4] = ["core", "intrinsics", "", "transmute"];
 pub const TRY_FROM: [&str; 4] = ["core", "convert", "TryFrom", "try_from"];
-pub const TRY_FROM_ERROR: [&str; 4] = ["std", "ops", "Try", "from_error"];
 pub const TRY_INTO_RESULT: [&str; 4] = ["std", "ops", "Try", "into_result"];
 pub const TRY_INTO_TRAIT: [&str; 3] = ["core", "convert", "TryInto"];
 pub const VEC: [&str; 3] = ["alloc", "vec", "Vec"];
diff --git a/tests/ui/try_err.fixed b/tests/ui/try_err.fixed
index 29d9139d3e3..9e77dcd8731 100644
--- a/tests/ui/try_err.fixed
+++ b/tests/ui/try_err.fixed
@@ -6,6 +6,9 @@
 #[macro_use]
 extern crate macro_rules;
 
+use std::io;
+use std::task::Poll;
+
 // Tests that a simple case works
 // Should flag `Err(err)?`
 pub fn basic_test() -> Result<i32, i32> {
@@ -104,3 +107,21 @@ pub fn macro_inside(fail: bool) -> Result<i32, String> {
     }
     Ok(0)
 }
+
+pub fn poll_write(n: usize) -> Poll<io::Result<usize>> {
+    if n == 0 {
+        return Poll::Ready(Err(io::ErrorKind::WriteZero.into()))
+    } else if n == 1 {
+        return Poll::Ready(Err(io::Error::new(io::ErrorKind::InvalidInput, "error")))
+    };
+
+    Poll::Ready(Ok(n))
+}
+
+pub fn poll_next(ready: bool) -> Poll<Option<io::Result<()>>> {
+    if !ready {
+        return Poll::Ready(Some(Err(io::ErrorKind::NotFound.into())))
+    }
+
+    Poll::Ready(None)
+}
diff --git a/tests/ui/try_err.rs b/tests/ui/try_err.rs
index 5e85d091a2a..41bcb0a189e 100644
--- a/tests/ui/try_err.rs
+++ b/tests/ui/try_err.rs
@@ -6,6 +6,9 @@
 #[macro_use]
 extern crate macro_rules;
 
+use std::io;
+use std::task::Poll;
+
 // Tests that a simple case works
 // Should flag `Err(err)?`
 pub fn basic_test() -> Result<i32, i32> {
@@ -104,3 +107,21 @@ pub fn macro_inside(fail: bool) -> Result<i32, String> {
     }
     Ok(0)
 }
+
+pub fn poll_write(n: usize) -> Poll<io::Result<usize>> {
+    if n == 0 {
+        Err(io::ErrorKind::WriteZero)?
+    } else if n == 1 {
+        Err(io::Error::new(io::ErrorKind::InvalidInput, "error"))?
+    };
+
+    Poll::Ready(Ok(n))
+}
+
+pub fn poll_next(ready: bool) -> Poll<Option<io::Result<()>>> {
+    if !ready {
+        Err(io::ErrorKind::NotFound)?
+    }
+
+    Poll::Ready(None)
+}
diff --git a/tests/ui/try_err.stderr b/tests/ui/try_err.stderr
index 21e9d4048a5..3f1cbc17e72 100644
--- a/tests/ui/try_err.stderr
+++ b/tests/ui/try_err.stderr
@@ -1,5 +1,5 @@
 error: returning an `Err(_)` with the `?` operator
-  --> $DIR/try_err.rs:15:9
+  --> $DIR/try_err.rs:18:9
    |
 LL |         Err(err)?;
    |         ^^^^^^^^^ help: try this: `return Err(err)`
@@ -11,28 +11,46 @@ LL | #![deny(clippy::try_err)]
    |         ^^^^^^^^^^^^^^^
 
 error: returning an `Err(_)` with the `?` operator
-  --> $DIR/try_err.rs:25:9
+  --> $DIR/try_err.rs:28:9
    |
 LL |         Err(err)?;
    |         ^^^^^^^^^ help: try this: `return Err(err.into())`
 
 error: returning an `Err(_)` with the `?` operator
-  --> $DIR/try_err.rs:45:17
+  --> $DIR/try_err.rs:48:17
    |
 LL |                 Err(err)?;
    |                 ^^^^^^^^^ help: try this: `return Err(err)`
 
 error: returning an `Err(_)` with the `?` operator
-  --> $DIR/try_err.rs:64:17
+  --> $DIR/try_err.rs:67:17
    |
 LL |                 Err(err)?;
    |                 ^^^^^^^^^ help: try this: `return Err(err.into())`
 
 error: returning an `Err(_)` with the `?` operator
-  --> $DIR/try_err.rs:103:9
+  --> $DIR/try_err.rs:106:9
    |
 LL |         Err(foo!())?;
    |         ^^^^^^^^^^^^ help: try this: `return Err(foo!())`
 
-error: aborting due to 5 previous errors
+error: returning an `Err(_)` with the `?` operator
+  --> $DIR/try_err.rs:113:9
+   |
+LL |         Err(io::ErrorKind::WriteZero)?
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `return Poll::Ready(Err(io::ErrorKind::WriteZero.into()))`
+
+error: returning an `Err(_)` with the `?` operator
+  --> $DIR/try_err.rs:115:9
+   |
+LL |         Err(io::Error::new(io::ErrorKind::InvalidInput, "error"))?
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `return Poll::Ready(Err(io::Error::new(io::ErrorKind::InvalidInput, "error")))`
+
+error: returning an `Err(_)` with the `?` operator
+  --> $DIR/try_err.rs:123:9
+   |
+LL |         Err(io::ErrorKind::NotFound)?
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `return Poll::Ready(Some(Err(io::ErrorKind::NotFound.into())))`
+
+error: aborting due to 8 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 0ccdf2913a335c4f0b34098f84baeeb3fc852255 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Mon, 3 Aug 2020 16:23:20 -0500
Subject: Remove obsolete known problems unnecessary_fold

---
 clippy_lints/src/methods/mod.rs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 9edcdd979ff..ff8da6b4015 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1052,8 +1052,7 @@ declare_clippy_lint! {
     ///
     /// **Why is this bad?** Readability.
     ///
-    /// **Known problems:** False positive in pattern guards. Will be resolved once
-    /// non-lexical lifetimes are stable.
+    /// **Known problems:** None.
     ///
     /// **Example:**
     /// ```rust
-- 
cgit 1.4.1-3-g733a5


From 542740c2eceff2369b2ac44e891a37313dd1785c Mon Sep 17 00:00:00 2001
From: JarredAllen <jarredallen73@gmail.com>
Date: Tue, 4 Aug 2020 17:53:29 -0700
Subject: Run cargo dev fmt

---
 clippy_lints/src/stable_sort_primitive.rs | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/stable_sort_primitive.rs b/clippy_lints/src/stable_sort_primitive.rs
index c48da004a60..cd7056620a2 100644
--- a/clippy_lints/src/stable_sort_primitive.rs
+++ b/clippy_lints/src/stable_sort_primitive.rs
@@ -43,30 +43,30 @@ declare_lint_pass!(StableSortPrimitive => [STABLE_SORT_PRIMITIVE]);
 /// The three "kinds" of sorts
 enum SortingKind {
     Vanilla,
-    // The other kinds of lint are currently commented out because they
-    // can map distinct values to equal ones. If the key function is
-    // provably one-to-one, or if the Cmp function conserves equality,
-    // then they could be linted on, but I don't know if we can check
-    // for that.
+    /* The other kinds of lint are currently commented out because they
+     * can map distinct values to equal ones. If the key function is
+     * provably one-to-one, or if the Cmp function conserves equality,
+     * then they could be linted on, but I don't know if we can check
+     * for that. */
 
-    // ByKey,
-    // ByCmp,
+    /* ByKey,
+     * ByCmp, */
 }
 impl SortingKind {
     /// The name of the stable version of this kind of sort
     fn stable_name(&self) -> &str {
         match self {
             SortingKind::Vanilla => "sort",
-            // SortingKind::ByKey => "sort_by_key",
-            // SortingKind::ByCmp => "sort_by",
+            /* SortingKind::ByKey => "sort_by_key",
+             * SortingKind::ByCmp => "sort_by", */
         }
     }
     /// The name of the unstable version of this kind of sort
     fn unstable_name(&self) -> &str {
         match self {
             SortingKind::Vanilla => "sort_unstable",
-            // SortingKind::ByKey => "sort_unstable_by_key",
-            // SortingKind::ByCmp => "sort_unstable_by",
+            /* SortingKind::ByKey => "sort_unstable_by_key",
+             * SortingKind::ByCmp => "sort_unstable_by", */
         }
     }
     /// Takes the name of a function call and returns the kind of sort
-- 
cgit 1.4.1-3-g733a5


From 1e8ada3cab5470a4f2070c0aa9d1a94922476621 Mon Sep 17 00:00:00 2001
From: Takayuki Nakata <f.seasons017@gmail.com>
Date: Sat, 18 Jul 2020 23:28:31 +0900
Subject: Add lint `same_item_push`

---
 CHANGELOG.md                   |   1 +
 clippy_lints/src/lib.rs        |   3 +
 clippy_lints/src/loops.rs      | 265 +++++++++++++++++++++++++++++++++++++++++
 src/lintlist/mod.rs            |   7 ++
 tests/ui/same_item_push.rs     |  77 ++++++++++++
 tests/ui/same_item_push.stderr |  35 ++++++
 6 files changed, 388 insertions(+)
 create mode 100644 tests/ui/same_item_push.rs
 create mode 100644 tests/ui/same_item_push.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 43d83d978b8..fbc783f1c2c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1687,6 +1687,7 @@ Released 2018-09-13
 [`result_map_unit_fn`]: https://rust-lang.github.io/rust-clippy/master/index.html#result_map_unit_fn
 [`reversed_empty_ranges`]: https://rust-lang.github.io/rust-clippy/master/index.html#reversed_empty_ranges
 [`same_functions_in_if_condition`]: https://rust-lang.github.io/rust-clippy/master/index.html#same_functions_in_if_condition
+[`same_item_push`]: https://rust-lang.github.io/rust-clippy/master/index.html#same_item_push
 [`search_is_some`]: https://rust-lang.github.io/rust-clippy/master/index.html#search_is_some
 [`serde_api_misuse`]: https://rust-lang.github.io/rust-clippy/master/index.html#serde_api_misuse
 [`shadow_reuse`]: https://rust-lang.github.io/rust-clippy/master/index.html#shadow_reuse
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 26aff6af8cd..2bd5ae0ed98 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -610,6 +610,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &loops::WHILE_IMMUTABLE_CONDITION,
         &loops::WHILE_LET_LOOP,
         &loops::WHILE_LET_ON_ITERATOR,
+        &loops::SAME_ITEM_PUSH,
         &macro_use::MACRO_USE_IMPORTS,
         &main_recursion::MAIN_RECURSION,
         &manual_async_fn::MANUAL_ASYNC_FN,
@@ -1405,6 +1406,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&repeat_once::REPEAT_ONCE),
         LintId::of(&returns::NEEDLESS_RETURN),
         LintId::of(&returns::UNUSED_UNIT),
+        LintId::of(&loops::SAME_ITEM_PUSH),
         LintId::of(&serde_api::SERDE_API_MISUSE),
         LintId::of(&single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS),
         LintId::of(&slow_vector_initialization::SLOW_VECTOR_INITIALIZATION),
@@ -1543,6 +1545,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&regex::TRIVIAL_REGEX),
         LintId::of(&returns::NEEDLESS_RETURN),
         LintId::of(&returns::UNUSED_UNIT),
+        LintId::of(&loops::SAME_ITEM_PUSH),
         LintId::of(&single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS),
         LintId::of(&strings::STRING_LIT_AS_BYTES),
         LintId::of(&tabs_in_doc_comments::TABS_IN_DOC_COMMENTS),
diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 6359c20040c..48891a59c00 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -419,6 +419,39 @@ declare_clippy_lint! {
     "variables used within while expression are not mutated in the body"
 }
 
+declare_clippy_lint! {
+    /// **What it does:** Checks whether a for loop is being used to push a constant
+    /// value into a Vec.
+    ///
+    /// **Why is this bad?** This kind of operation can be expressed more succinctly with
+    /// `vec![item;SIZE]` or `vec.resize(NEW_SIZE, item)` and using these alternatives may also
+    /// have better performance.
+    /// **Known problems:** None
+    ///
+    /// **Example:**
+    /// ```rust
+    /// let item1 = 2;
+    /// let item2 = 3;
+    /// let mut vec: Vec<u8> = Vec::new();
+    /// for _ in 0..20 {
+    ///    vec.push(item1);
+    /// }
+    /// for _ in 0..30 {
+    ///     vec.push(item2);
+    /// }
+    /// ```
+    /// could be written as
+    /// ```rust
+    /// let item1 = 2;
+    /// let item2 = 3;
+    /// let mut vec: Vec<u8> = vec![item1; 20];
+    /// vec.resize(20 + 30, item2);
+    /// ```
+    pub SAME_ITEM_PUSH,
+    style,
+    "the same item is pushed inside of a for loop"
+}
+
 declare_lint_pass!(Loops => [
     MANUAL_MEMCPY,
     NEEDLESS_RANGE_LOOP,
@@ -435,6 +468,7 @@ declare_lint_pass!(Loops => [
     NEVER_LOOP,
     MUT_RANGE_BOUND,
     WHILE_IMMUTABLE_CONDITION,
+    SAME_ITEM_PUSH,
 ]);
 
 impl<'tcx> LateLintPass<'tcx> for Loops {
@@ -740,6 +774,7 @@ fn check_for_loop<'tcx>(
     check_for_loop_over_map_kv(cx, pat, arg, body, expr);
     check_for_mut_range_bound(cx, arg, body);
     detect_manual_memcpy(cx, pat, arg, body, expr);
+    detect_same_item_push(cx, pat, arg, body, expr);
 }
 
 fn same_var<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, var: HirId) -> bool {
@@ -1016,6 +1051,236 @@ fn detect_manual_memcpy<'tcx>(
     }
 }
 
+// Delegate that traverses expression and detects mutable variables being used
+struct UsesMutableDelegate {
+    found_mutable: bool,
+}
+
+impl<'tcx> Delegate<'tcx> for UsesMutableDelegate {
+    fn consume(&mut self, _: &PlaceWithHirId<'tcx>, _: ConsumeMode) {}
+
+    fn borrow(&mut self, _: &PlaceWithHirId<'tcx>, bk: ty::BorrowKind) {
+        // Mutable variable is found
+        if let ty::BorrowKind::MutBorrow = bk {
+            self.found_mutable = true;
+        }
+    }
+
+    fn mutate(&mut self, _: &PlaceWithHirId<'tcx>) {}
+}
+
+// Uses UsesMutableDelegate to find mutable variables in an expression expr
+fn has_mutable_variables<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> bool {
+    let mut delegate = UsesMutableDelegate { found_mutable: false };
+    let def_id = expr.hir_id.owner.to_def_id();
+    cx.tcx.infer_ctxt().enter(|infcx| {
+        ExprUseVisitor::new(
+            &mut delegate,
+            &infcx,
+            def_id.expect_local(),
+            cx.param_env,
+            cx.tables(),
+        ).walk_expr(expr);
+    });
+
+    delegate.found_mutable
+}
+
+// Scans for the usage of the for loop pattern
+struct ForPatternVisitor<'a, 'tcx> {
+    found_pattern: bool,
+    // Pattern that we are searching for
+    for_pattern: &'a Pat<'tcx>,
+    cx: &'a LateContext<'tcx>,
+}
+
+impl<'a, 'tcx> Visitor<'tcx> for ForPatternVisitor<'a, 'tcx> {
+    type Map = Map<'tcx>;
+
+    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
+        // Recursively explore an expression until a ExprKind::Path is found
+        match &expr.kind {
+            ExprKind::Array(expr_list) | ExprKind::MethodCall(_, _, expr_list, _) | ExprKind::Tup(expr_list) => {
+                for expr in *expr_list {
+                    self.visit_expr(expr)
+                }
+            },
+            ExprKind::Binary(_, lhs_expr, rhs_expr) => {
+                self.visit_expr(lhs_expr);
+                self.visit_expr(rhs_expr);
+            },
+            ExprKind::Box(expr)
+            | ExprKind::Unary(_, expr)
+            | ExprKind::Cast(expr, _)
+            | ExprKind::Type(expr, _)
+            | ExprKind::AddrOf(_, _, expr)
+            | ExprKind::Struct(_, _, Some(expr)) => self.visit_expr(expr),
+            _ => {
+                // Exploration cannot continue ... calculate the hir_id of the current
+                // expr assuming it is a Path
+                if let Some(hir_id) = var_def_id(self.cx, &expr) {
+                    // Pattern is found
+                    if hir_id == self.for_pattern.hir_id {
+                        self.found_pattern = true;
+                    }
+                    // If the for loop pattern is a tuple, determine whether the current
+                    // expr is inside that tuple pattern
+                    if let PatKind::Tuple(pat_list, _) = &self.for_pattern.kind {
+                        let hir_id_list: Vec<HirId> = pat_list.iter().map(|p| p.hir_id).collect();
+                        if hir_id_list.contains(&hir_id) {
+                            self.found_pattern = true;
+                        }
+                    }
+                }
+            },
+        }
+    }
+
+    // This is triggered by walk_expr() for the case of vec.push(pat)
+    fn visit_qpath(&mut self, qpath: &'tcx QPath<'_>, _: HirId, _: Span) {
+        if_chain! {
+            if let QPath::Resolved(_, path) = qpath;
+            if let Res::Local(hir_id) = &path.res;
+            then {
+                if *hir_id == self.for_pattern.hir_id{
+                    self.found_pattern = true;
+                }
+
+                if let PatKind::Tuple(pat_list, _) = &self.for_pattern.kind {
+                    let hir_id_list: Vec<HirId> = pat_list.iter().map(|p| p.hir_id).collect();
+                    if hir_id_list.contains(&hir_id) {
+                        self.found_pattern = true;
+                    }
+                }
+            }
+        }
+    }
+
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::None
+    }
+}
+
+// Scans the body of the for loop and determines whether lint should be given
+struct SameItemPushVisitor<'a, 'tcx> {
+    should_lint: bool,
+    // this field holds the last vec push operation visited, which should be the only push seen
+    vec_push: Option<(&'tcx Expr<'tcx>, &'tcx Expr<'tcx>)>,
+    cx: &'a LateContext<'tcx>,
+}
+
+impl<'a, 'tcx> Visitor<'tcx> for SameItemPushVisitor<'a, 'tcx> {
+    type Map = Map<'tcx>;
+
+    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
+        match &expr.kind {
+            // Non-determinism may occur ... don't give a lint
+            ExprKind::Loop(_, _, _) | ExprKind::Match(_, _, _) => self.should_lint = false,
+            ExprKind::Block(block, _) => self.visit_block(block),
+            _ => {},
+        }
+    }
+
+    fn visit_block(&mut self, b: &'tcx Block<'_>) {
+        for stmt in b.stmts.iter() {
+            self.visit_stmt(stmt);
+        }
+    }
+
+    fn visit_stmt(&mut self, s: &'tcx Stmt<'_>) {
+        let vec_push_option = get_vec_push(self.cx, s);
+        if vec_push_option.is_none() {
+            // Current statement is not a push so visit inside
+            match &s.kind {
+                StmtKind::Expr(expr) | StmtKind::Semi(expr) => self.visit_expr(&expr),
+                _ => {},
+            }
+        } else {
+            // Current statement is a push ...check whether another
+            // push had been previously done
+            if self.vec_push.is_none() {
+                self.vec_push = vec_push_option;
+            } else {
+                // There are multiple pushes ... don't lint
+                self.should_lint = false;
+            }
+        }
+    }
+
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::None
+    }
+}
+
+// Given some statement, determine if that statement is a push on a Vec. If it is, return
+// the Vec being pushed into and the item being pushed
+fn get_vec_push<'tcx>(cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) -> Option<(&'tcx Expr<'tcx>, &'tcx Expr<'tcx>)> {
+    if_chain! {
+            // Extract method being called
+            if let StmtKind::Semi(semi_stmt) = &stmt.kind;
+            if let ExprKind::MethodCall(path, _, args, _) = &semi_stmt.kind;
+            // Figure out the parameters for the method call
+            if let Some(self_expr) = args.get(0);
+            if let Some(pushed_item) = args.get(1);
+            // Check that the method being called is push() on a Vec
+            if match_type(cx, cx.tables().expr_ty(self_expr), &paths::VEC);
+            if path.ident.name.as_str() == "push";
+            then {
+                return Some((self_expr, pushed_item))
+            }
+    }
+    None
+}
+
+/// Detects for loop pushing the same item into a Vec
+fn detect_same_item_push<'tcx>(
+    cx: &LateContext<'tcx>,
+    pat: &'tcx Pat<'_>,
+    _: &'tcx Expr<'_>,
+    body: &'tcx Expr<'_>,
+    _: &'tcx Expr<'_>,
+) {
+    // Determine whether it is safe to lint the body
+    let mut same_item_push_visitor = SameItemPushVisitor {
+        should_lint: true,
+        vec_push: None,
+        cx,
+    };
+    walk_expr(&mut same_item_push_visitor, body);
+    if same_item_push_visitor.should_lint {
+        if let Some((vec, pushed_item)) = same_item_push_visitor.vec_push {
+            // Make sure that the push does not involve possibly mutating values
+            if !has_mutable_variables(cx, pushed_item) {
+                // Walk through the expression being pushed and make sure that it
+                // does not contain the for loop pattern
+                let mut for_pat_visitor = ForPatternVisitor {
+                    found_pattern: false,
+                    for_pattern: pat,
+                    cx,
+                };
+                walk_expr(&mut for_pat_visitor, pushed_item);
+
+                if !for_pat_visitor.found_pattern {
+                    let vec_str = snippet(cx, vec.span, "");
+                    let item_str = snippet(cx, pushed_item.span, "");
+
+                    span_lint_and_help(
+                        cx,
+                        SAME_ITEM_PUSH,
+                        vec.span,
+                        "it looks like the same item is being pushed into this Vec",
+                        None, 
+                        &format!(
+                            "try using vec![{};SIZE] or {}.resize(NEW_SIZE, {})",
+                            item_str, vec_str, item_str
+                        ),
+                    )
+                }
+            }
+        }
+    }
+}
+
 /// Checks for looping over a range and then indexing a sequence with it.
 /// The iteratee must be a range literal.
 #[allow(clippy::too_many_lines)]
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index a08d7da6dcb..1b10226c930 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -1935,6 +1935,13 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
         deprecation: None,
         module: "copies",
     },
+    Lint {
+        name: "same_item_push",
+        group: "style",
+        desc: "default lint description",
+        deprecation: None,
+        module: "same_item_push",
+    },
     Lint {
         name: "search_is_some",
         group: "complexity",
diff --git a/tests/ui/same_item_push.rs b/tests/ui/same_item_push.rs
new file mode 100644
index 00000000000..e3a5a647f76
--- /dev/null
+++ b/tests/ui/same_item_push.rs
@@ -0,0 +1,77 @@
+#![warn(clippy::same_item_push)]
+
+fn mutate_increment(x: &mut u8) -> u8 {
+    *x += 1;
+    *x
+}
+
+fn increment(x: u8) -> u8 {
+    x + 1
+}
+
+fn main() {
+    // Test for basic case
+    let mut spaces = Vec::with_capacity(10);
+    for _ in 0..10 {
+        spaces.push(vec![b' ']);
+    }
+
+    let mut vec2: Vec<u8> = Vec::new();
+    let item = 2;
+    for _ in 5..=20 {
+        vec2.push(item);
+    }
+
+    let mut vec3: Vec<u8> = Vec::new();
+    for _ in 0..15 {
+        let item = 2;
+        vec3.push(item);
+    }
+
+    let mut vec4: Vec<u8> = Vec::new();
+    for _ in 0..15 {
+        vec4.push(13);
+    }
+
+    // Suggestion should not be given as pushed variable can mutate
+    let mut vec5: Vec<u8> = Vec::new();
+    let mut item: u8 = 2;
+    for _ in 0..30 {
+        vec5.push(mutate_increment(&mut item));
+    }
+
+    let mut vec6: Vec<u8> = Vec::new();
+    let mut item: u8 = 2;
+    let mut item2 = &mut mutate_increment(&mut item);
+    for _ in 0..30 {
+        vec6.push(mutate_increment(item2));
+    }
+
+    let mut vec7: Vec<usize> = Vec::new();
+    for (a, b) in [0, 1, 4, 9, 16].iter().enumerate() {
+        vec7.push(a);
+    }
+
+    let mut vec8: Vec<u8> = Vec::new();
+    for i in 0..30 {
+        vec8.push(increment(i));
+    }
+
+    let mut vec9: Vec<u8> = Vec::new();
+    for i in 0..30 {
+        vec9.push(i + i * i);
+    }
+
+    // Suggestion should not be given as there are multiple pushes that are not the same
+    let mut vec10: Vec<u8> = Vec::new();
+    let item: u8 = 2;
+    for _ in 0..30 {
+        vec10.push(item);
+        vec10.push(item * 2);
+    }
+
+    // Suggestion should not be given as Vec is not involved
+    for _ in 0..5 {
+        println!("Same Item Push");
+    }
+}
diff --git a/tests/ui/same_item_push.stderr b/tests/ui/same_item_push.stderr
new file mode 100644
index 00000000000..559cc450b9d
--- /dev/null
+++ b/tests/ui/same_item_push.stderr
@@ -0,0 +1,35 @@
+error: it looks like the same item is being pushed into this Vec
+  --> $DIR/same_item_push.rs:16:9
+   |
+LL |         spaces.push(vec![b' ']);
+   |         ^^^^^^
+   |
+   = note: `-D clippy::same-item-push` implied by `-D warnings`
+   = help: try using vec![<[_]>::into_vec(box [$($x),+]);SIZE] or spaces.resize(NEW_SIZE, <[_]>::into_vec(box [$($x),+]))
+
+error: it looks like the same item is being pushed into this Vec
+  --> $DIR/same_item_push.rs:22:9
+   |
+LL |         vec2.push(item);
+   |         ^^^^
+   |
+   = help: try using vec![item;SIZE] or vec2.resize(NEW_SIZE, item)
+
+error: it looks like the same item is being pushed into this Vec
+  --> $DIR/same_item_push.rs:28:9
+   |
+LL |         vec3.push(item);
+   |         ^^^^
+   |
+   = help: try using vec![item;SIZE] or vec3.resize(NEW_SIZE, item)
+
+error: it looks like the same item is being pushed into this Vec
+  --> $DIR/same_item_push.rs:33:9
+   |
+LL |         vec4.push(13);
+   |         ^^^^
+   |
+   = help: try using vec![13;SIZE] or vec4.resize(NEW_SIZE, 13)
+
+error: aborting due to 4 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 161f47510076d36722546c3541a546f9b724fadd Mon Sep 17 00:00:00 2001
From: Takayuki Nakata <f.seasons017@gmail.com>
Date: Sun, 19 Jul 2020 23:43:35 +0900
Subject: Add test case for `same_item_push`

---
 clippy_lints/src/loops.rs  |  1 +
 tests/ui/same_item_push.rs | 12 ++++++++++++
 2 files changed, 13 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 48891a59c00..1c2f1225497 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -1114,6 +1114,7 @@ impl<'a, 'tcx> Visitor<'tcx> for ForPatternVisitor<'a, 'tcx> {
             | ExprKind::Cast(expr, _)
             | ExprKind::Type(expr, _)
             | ExprKind::AddrOf(_, _, expr)
+            | ExprKind::Field(expr, _)
             | ExprKind::Struct(_, _, Some(expr)) => self.visit_expr(expr),
             _ => {
                 // Exploration cannot continue ... calculate the hir_id of the current
diff --git a/tests/ui/same_item_push.rs b/tests/ui/same_item_push.rs
index e3a5a647f76..4bb5e73ff0d 100644
--- a/tests/ui/same_item_push.rs
+++ b/tests/ui/same_item_push.rs
@@ -74,4 +74,16 @@ fn main() {
     for _ in 0..5 {
         println!("Same Item Push");
     }
+
+    struct A {
+        kind: u32,
+    }
+    let mut vec_a: Vec<A> = Vec::new();
+    for i in 0..30 {
+        vec_a.push(A{kind: i});
+    }
+    let mut vec12: Vec<u8> = Vec::new();
+    for a in vec_a {
+        vec12.push(2u8.pow(a.kind));
+    }
 }
-- 
cgit 1.4.1-3-g733a5


From 2beb9090d1b9adb2b0930da511bf1750e570905b Mon Sep 17 00:00:00 2001
From: Takayuki Nakata <f.seasons017@gmail.com>
Date: Mon, 20 Jul 2020 22:40:31 +0900
Subject: Rename TypeckTables to TypeckResults

---
 clippy_lints/src/loops.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 1c2f1225497..766c68df623 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -1079,7 +1079,7 @@ fn has_mutable_variables<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) ->
             &infcx,
             def_id.expect_local(),
             cx.param_env,
-            cx.tables(),
+            cx.typeck_results(),
         ).walk_expr(expr);
     });
 
@@ -1224,7 +1224,7 @@ fn get_vec_push<'tcx>(cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) -> Option<(&
             if let Some(self_expr) = args.get(0);
             if let Some(pushed_item) = args.get(1);
             // Check that the method being called is push() on a Vec
-            if match_type(cx, cx.tables().expr_ty(self_expr), &paths::VEC);
+            if match_type(cx, cx.typeck_results().expr_ty(self_expr), &paths::VEC);
             if path.ident.name.as_str() == "push";
             then {
                 return Some((self_expr, pushed_item))
-- 
cgit 1.4.1-3-g733a5


From 1543e117cc7459bef2b57389503f0f526a903f45 Mon Sep 17 00:00:00 2001
From: Takayuki Nakata <f.seasons017@gmail.com>
Date: Mon, 20 Jul 2020 22:52:30 +0900
Subject: cargo dev update_lints

---
 clippy_lints/src/lib.rs | 6 +++---
 src/lintlist/mod.rs     | 4 ++--
 2 files changed, 5 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 2bd5ae0ed98..308868fc90a 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -607,10 +607,10 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &loops::NEEDLESS_COLLECT,
         &loops::NEEDLESS_RANGE_LOOP,
         &loops::NEVER_LOOP,
+        &loops::SAME_ITEM_PUSH,
         &loops::WHILE_IMMUTABLE_CONDITION,
         &loops::WHILE_LET_LOOP,
         &loops::WHILE_LET_ON_ITERATOR,
-        &loops::SAME_ITEM_PUSH,
         &macro_use::MACRO_USE_IMPORTS,
         &main_recursion::MAIN_RECURSION,
         &manual_async_fn::MANUAL_ASYNC_FN,
@@ -1293,6 +1293,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&loops::NEEDLESS_COLLECT),
         LintId::of(&loops::NEEDLESS_RANGE_LOOP),
         LintId::of(&loops::NEVER_LOOP),
+        LintId::of(&loops::SAME_ITEM_PUSH),
         LintId::of(&loops::WHILE_IMMUTABLE_CONDITION),
         LintId::of(&loops::WHILE_LET_LOOP),
         LintId::of(&loops::WHILE_LET_ON_ITERATOR),
@@ -1406,7 +1407,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&repeat_once::REPEAT_ONCE),
         LintId::of(&returns::NEEDLESS_RETURN),
         LintId::of(&returns::UNUSED_UNIT),
-        LintId::of(&loops::SAME_ITEM_PUSH),
         LintId::of(&serde_api::SERDE_API_MISUSE),
         LintId::of(&single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS),
         LintId::of(&slow_vector_initialization::SLOW_VECTOR_INITIALIZATION),
@@ -1495,6 +1495,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&loops::EMPTY_LOOP),
         LintId::of(&loops::FOR_KV_MAP),
         LintId::of(&loops::NEEDLESS_RANGE_LOOP),
+        LintId::of(&loops::SAME_ITEM_PUSH),
         LintId::of(&loops::WHILE_LET_ON_ITERATOR),
         LintId::of(&main_recursion::MAIN_RECURSION),
         LintId::of(&manual_async_fn::MANUAL_ASYNC_FN),
@@ -1545,7 +1546,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&regex::TRIVIAL_REGEX),
         LintId::of(&returns::NEEDLESS_RETURN),
         LintId::of(&returns::UNUSED_UNIT),
-        LintId::of(&loops::SAME_ITEM_PUSH),
         LintId::of(&single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS),
         LintId::of(&strings::STRING_LIT_AS_BYTES),
         LintId::of(&tabs_in_doc_comments::TABS_IN_DOC_COMMENTS),
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index 1b10226c930..1f79e44049f 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -1938,9 +1938,9 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
     Lint {
         name: "same_item_push",
         group: "style",
-        desc: "default lint description",
+        desc: "the same item is pushed inside of a for loop",
         deprecation: None,
-        module: "same_item_push",
+        module: "loops",
     },
     Lint {
         name: "search_is_some",
-- 
cgit 1.4.1-3-g733a5


From 14a4e3bcc8082b0323886ae15365ea2424b512cf Mon Sep 17 00:00:00 2001
From: Takayuki Nakata <f.seasons017@gmail.com>
Date: Tue, 21 Jul 2020 08:15:13 +0900
Subject: Fix a lint message

---
 clippy_lints/src/loops.rs      | 11 ++++++-----
 tests/ui/same_item_push.stderr |  2 +-
 2 files changed, 7 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 766c68df623..8ca67cae0e9 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -3,9 +3,10 @@ use crate::utils::paths;
 use crate::utils::sugg::Sugg;
 use crate::utils::usage::{is_unused, mutated_variables};
 use crate::utils::{
-    get_enclosing_block, get_parent_expr, get_trait_def_id, has_iter_method, higher, implements_trait,
-    is_integer_const, is_no_std_crate, is_refutable, is_type_diagnostic_item, last_path_segment, match_trait_method,
-    match_type, match_var, multispan_sugg, qpath_res, snippet, snippet_opt, snippet_with_applicability, span_lint,
+    get_enclosing_block, get_parent_expr, get_trait_def_id, has_iter_method, higher,
+    implements_trait, is_integer_const, is_no_std_crate, is_refutable, is_type_diagnostic_item,
+    last_path_segment, match_trait_method, match_type, match_var, multispan_sugg, qpath_res,
+    snippet, snippet_opt, snippet_with_applicability, snippet_with_macro_callsite, span_lint,
     span_lint_and_help, span_lint_and_sugg, span_lint_and_then, sugg, SpanlessEq,
 };
 use if_chain::if_chain;
@@ -1262,8 +1263,8 @@ fn detect_same_item_push<'tcx>(
                 walk_expr(&mut for_pat_visitor, pushed_item);
 
                 if !for_pat_visitor.found_pattern {
-                    let vec_str = snippet(cx, vec.span, "");
-                    let item_str = snippet(cx, pushed_item.span, "");
+                    let vec_str = snippet_with_macro_callsite(cx, vec.span, "");
+                    let item_str = snippet_with_macro_callsite(cx, pushed_item.span, "");
 
                     span_lint_and_help(
                         cx,
diff --git a/tests/ui/same_item_push.stderr b/tests/ui/same_item_push.stderr
index 559cc450b9d..ddc5d48cd41 100644
--- a/tests/ui/same_item_push.stderr
+++ b/tests/ui/same_item_push.stderr
@@ -5,7 +5,7 @@ LL |         spaces.push(vec![b' ']);
    |         ^^^^^^
    |
    = note: `-D clippy::same-item-push` implied by `-D warnings`
-   = help: try using vec![<[_]>::into_vec(box [$($x),+]);SIZE] or spaces.resize(NEW_SIZE, <[_]>::into_vec(box [$($x),+]))
+   = help: try using vec![vec![b' '];SIZE] or spaces.resize(NEW_SIZE, vec![b' '])
 
 error: it looks like the same item is being pushed into this Vec
   --> $DIR/same_item_push.rs:22:9
-- 
cgit 1.4.1-3-g733a5


From b7ceb4d3d7ed3ea7039caf803073e86ad3643e21 Mon Sep 17 00:00:00 2001
From: Takayuki Nakata <f.seasons017@gmail.com>
Date: Tue, 21 Jul 2020 08:25:11 +0900
Subject: rustfmt

---
 clippy_lints/src/loops.rs  | 5 +++--
 tests/ui/same_item_push.rs | 2 +-
 2 files changed, 4 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 8ca67cae0e9..3a1fbc4bfed 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -1081,7 +1081,8 @@ fn has_mutable_variables<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) ->
             def_id.expect_local(),
             cx.param_env,
             cx.typeck_results(),
-        ).walk_expr(expr);
+        )
+        .walk_expr(expr);
     });
 
     delegate.found_mutable
@@ -1271,7 +1272,7 @@ fn detect_same_item_push<'tcx>(
                         SAME_ITEM_PUSH,
                         vec.span,
                         "it looks like the same item is being pushed into this Vec",
-                        None, 
+                        None,
                         &format!(
                             "try using vec![{};SIZE] or {}.resize(NEW_SIZE, {})",
                             item_str, vec_str, item_str
diff --git a/tests/ui/same_item_push.rs b/tests/ui/same_item_push.rs
index 4bb5e73ff0d..ff1088f86f6 100644
--- a/tests/ui/same_item_push.rs
+++ b/tests/ui/same_item_push.rs
@@ -80,7 +80,7 @@ fn main() {
     }
     let mut vec_a: Vec<A> = Vec::new();
     for i in 0..30 {
-        vec_a.push(A{kind: i});
+        vec_a.push(A { kind: i });
     }
     let mut vec12: Vec<u8> = Vec::new();
     for a in vec_a {
-- 
cgit 1.4.1-3-g733a5


From 228f668282daab05ec20adbbdeb227e923d10864 Mon Sep 17 00:00:00 2001
From: Takayuki Nakata <f.seasons017@gmail.com>
Date: Wed, 22 Jul 2020 22:11:31 +0900
Subject: Use `mutated_variables`

---
 clippy_lints/src/loops.rs | 38 +-------------------------------------
 1 file changed, 1 insertion(+), 37 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 3a1fbc4bfed..86952c10dfc 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -1052,42 +1052,6 @@ fn detect_manual_memcpy<'tcx>(
     }
 }
 
-// Delegate that traverses expression and detects mutable variables being used
-struct UsesMutableDelegate {
-    found_mutable: bool,
-}
-
-impl<'tcx> Delegate<'tcx> for UsesMutableDelegate {
-    fn consume(&mut self, _: &PlaceWithHirId<'tcx>, _: ConsumeMode) {}
-
-    fn borrow(&mut self, _: &PlaceWithHirId<'tcx>, bk: ty::BorrowKind) {
-        // Mutable variable is found
-        if let ty::BorrowKind::MutBorrow = bk {
-            self.found_mutable = true;
-        }
-    }
-
-    fn mutate(&mut self, _: &PlaceWithHirId<'tcx>) {}
-}
-
-// Uses UsesMutableDelegate to find mutable variables in an expression expr
-fn has_mutable_variables<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> bool {
-    let mut delegate = UsesMutableDelegate { found_mutable: false };
-    let def_id = expr.hir_id.owner.to_def_id();
-    cx.tcx.infer_ctxt().enter(|infcx| {
-        ExprUseVisitor::new(
-            &mut delegate,
-            &infcx,
-            def_id.expect_local(),
-            cx.param_env,
-            cx.typeck_results(),
-        )
-        .walk_expr(expr);
-    });
-
-    delegate.found_mutable
-}
-
 // Scans for the usage of the for loop pattern
 struct ForPatternVisitor<'a, 'tcx> {
     found_pattern: bool,
@@ -1253,7 +1217,7 @@ fn detect_same_item_push<'tcx>(
     if same_item_push_visitor.should_lint {
         if let Some((vec, pushed_item)) = same_item_push_visitor.vec_push {
             // Make sure that the push does not involve possibly mutating values
-            if !has_mutable_variables(cx, pushed_item) {
+            if mutated_variables(pushed_item, cx).map_or(false, |mutvars| mutvars.is_empty()) {
                 // Walk through the expression being pushed and make sure that it
                 // does not contain the for loop pattern
                 let mut for_pat_visitor = ForPatternVisitor {
-- 
cgit 1.4.1-3-g733a5


From e48685edef9889d7c0ae391cf050f878d228ae25 Mon Sep 17 00:00:00 2001
From: Takayuki Nakata <f.seasons017@gmail.com>
Date: Wed, 22 Jul 2020 23:22:17 +0900
Subject: Just check if it contains `_` in `for pat`

---
 clippy_lints/src/loops.rs | 87 +----------------------------------------------
 1 file changed, 1 insertion(+), 86 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 86952c10dfc..3104f0c137e 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -1052,82 +1052,6 @@ fn detect_manual_memcpy<'tcx>(
     }
 }
 
-// Scans for the usage of the for loop pattern
-struct ForPatternVisitor<'a, 'tcx> {
-    found_pattern: bool,
-    // Pattern that we are searching for
-    for_pattern: &'a Pat<'tcx>,
-    cx: &'a LateContext<'tcx>,
-}
-
-impl<'a, 'tcx> Visitor<'tcx> for ForPatternVisitor<'a, 'tcx> {
-    type Map = Map<'tcx>;
-
-    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
-        // Recursively explore an expression until a ExprKind::Path is found
-        match &expr.kind {
-            ExprKind::Array(expr_list) | ExprKind::MethodCall(_, _, expr_list, _) | ExprKind::Tup(expr_list) => {
-                for expr in *expr_list {
-                    self.visit_expr(expr)
-                }
-            },
-            ExprKind::Binary(_, lhs_expr, rhs_expr) => {
-                self.visit_expr(lhs_expr);
-                self.visit_expr(rhs_expr);
-            },
-            ExprKind::Box(expr)
-            | ExprKind::Unary(_, expr)
-            | ExprKind::Cast(expr, _)
-            | ExprKind::Type(expr, _)
-            | ExprKind::AddrOf(_, _, expr)
-            | ExprKind::Field(expr, _)
-            | ExprKind::Struct(_, _, Some(expr)) => self.visit_expr(expr),
-            _ => {
-                // Exploration cannot continue ... calculate the hir_id of the current
-                // expr assuming it is a Path
-                if let Some(hir_id) = var_def_id(self.cx, &expr) {
-                    // Pattern is found
-                    if hir_id == self.for_pattern.hir_id {
-                        self.found_pattern = true;
-                    }
-                    // If the for loop pattern is a tuple, determine whether the current
-                    // expr is inside that tuple pattern
-                    if let PatKind::Tuple(pat_list, _) = &self.for_pattern.kind {
-                        let hir_id_list: Vec<HirId> = pat_list.iter().map(|p| p.hir_id).collect();
-                        if hir_id_list.contains(&hir_id) {
-                            self.found_pattern = true;
-                        }
-                    }
-                }
-            },
-        }
-    }
-
-    // This is triggered by walk_expr() for the case of vec.push(pat)
-    fn visit_qpath(&mut self, qpath: &'tcx QPath<'_>, _: HirId, _: Span) {
-        if_chain! {
-            if let QPath::Resolved(_, path) = qpath;
-            if let Res::Local(hir_id) = &path.res;
-            then {
-                if *hir_id == self.for_pattern.hir_id{
-                    self.found_pattern = true;
-                }
-
-                if let PatKind::Tuple(pat_list, _) = &self.for_pattern.kind {
-                    let hir_id_list: Vec<HirId> = pat_list.iter().map(|p| p.hir_id).collect();
-                    if hir_id_list.contains(&hir_id) {
-                        self.found_pattern = true;
-                    }
-                }
-            }
-        }
-    }
-
-    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-        NestedVisitorMap::None
-    }
-}
-
 // Scans the body of the for loop and determines whether lint should be given
 struct SameItemPushVisitor<'a, 'tcx> {
     should_lint: bool,
@@ -1218,16 +1142,7 @@ fn detect_same_item_push<'tcx>(
         if let Some((vec, pushed_item)) = same_item_push_visitor.vec_push {
             // Make sure that the push does not involve possibly mutating values
             if mutated_variables(pushed_item, cx).map_or(false, |mutvars| mutvars.is_empty()) {
-                // Walk through the expression being pushed and make sure that it
-                // does not contain the for loop pattern
-                let mut for_pat_visitor = ForPatternVisitor {
-                    found_pattern: false,
-                    for_pattern: pat,
-                    cx,
-                };
-                walk_expr(&mut for_pat_visitor, pushed_item);
-
-                if !for_pat_visitor.found_pattern {
+                if let PatKind::Wild = pat.kind {
                     let vec_str = snippet_with_macro_callsite(cx, vec.span, "");
                     let item_str = snippet_with_macro_callsite(cx, pushed_item.span, "");
 
-- 
cgit 1.4.1-3-g733a5


From 610d4e3c8b1bfa27e059043554f4156fe1254142 Mon Sep 17 00:00:00 2001
From: Takayuki Nakata <f.seasons017@gmail.com>
Date: Wed, 5 Aug 2020 23:10:30 +0900
Subject: rustfmt

---
 clippy_lints/src/loops.rs | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 3104f0c137e..5c918ff648f 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -3,11 +3,11 @@ use crate::utils::paths;
 use crate::utils::sugg::Sugg;
 use crate::utils::usage::{is_unused, mutated_variables};
 use crate::utils::{
-    get_enclosing_block, get_parent_expr, get_trait_def_id, has_iter_method, higher,
-    implements_trait, is_integer_const, is_no_std_crate, is_refutable, is_type_diagnostic_item,
-    last_path_segment, match_trait_method, match_type, match_var, multispan_sugg, qpath_res,
-    snippet, snippet_opt, snippet_with_applicability, snippet_with_macro_callsite, span_lint,
-    span_lint_and_help, span_lint_and_sugg, span_lint_and_then, sugg, SpanlessEq,
+    get_enclosing_block, get_parent_expr, get_trait_def_id, has_iter_method, higher, implements_trait,
+    is_integer_const, is_no_std_crate, is_refutable, is_type_diagnostic_item, last_path_segment, match_trait_method,
+    match_type, match_var, multispan_sugg, qpath_res, snippet, snippet_opt, snippet_with_applicability,
+    snippet_with_macro_callsite, span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then, sugg,
+    SpanlessEq,
 };
 use if_chain::if_chain;
 use rustc_ast::ast;
-- 
cgit 1.4.1-3-g733a5


From 50a86d492718f2ad5e653575d19324205fa007f1 Mon Sep 17 00:00:00 2001
From: Eduardo Broto <ebroto@tutanota.com>
Date: Thu, 6 Aug 2020 00:40:11 +0200
Subject: enable #[allow(clippy::unsafe_derive_deserialize)]

---
 clippy_lints/src/derive.rs            |  8 +++++---
 tests/ui/unsafe_derive_deserialize.rs | 10 ++++++++++
 2 files changed, 15 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/derive.rs b/clippy_lints/src/derive.rs
index 08d8100a885..80a06758982 100644
--- a/clippy_lints/src/derive.rs
+++ b/clippy_lints/src/derive.rs
@@ -1,7 +1,7 @@
 use crate::utils::paths;
 use crate::utils::{
-    get_trait_def_id, is_automatically_derived, is_copy, match_path, span_lint_and_help, span_lint_and_note,
-    span_lint_and_then,
+    get_trait_def_id, is_allowed, is_automatically_derived, is_copy, match_path, span_lint_and_help,
+    span_lint_and_note, span_lint_and_then,
 };
 use if_chain::if_chain;
 use rustc_hir::def_id::DefId;
@@ -354,7 +354,9 @@ fn check_unsafe_derive_deserialize<'tcx>(
     if_chain! {
         if match_path(&trait_ref.path, &paths::SERDE_DESERIALIZE);
         if let ty::Adt(def, _) = ty.kind;
-        if def.did.is_local();
+        if let Some(local_def_id) = def.did.as_local();
+        let adt_hir_id = cx.tcx.hir().as_local_hir_id(local_def_id);
+        if !is_allowed(cx, UNSAFE_DERIVE_DESERIALIZE, adt_hir_id);
         if cx.tcx.inherent_impls(def.did)
             .iter()
             .map(|imp_did| item_from_def_id(cx, *imp_did))
diff --git a/tests/ui/unsafe_derive_deserialize.rs b/tests/ui/unsafe_derive_deserialize.rs
index 7bee9c499e1..690d705573d 100644
--- a/tests/ui/unsafe_derive_deserialize.rs
+++ b/tests/ui/unsafe_derive_deserialize.rs
@@ -57,4 +57,14 @@ impl E {
 #[derive(Deserialize)]
 pub struct F {}
 
+// Check that we honor the `allow` attribute on the ADT
+#[allow(clippy::unsafe_derive_deserialize)]
+#[derive(Deserialize)]
+pub struct G {}
+impl G {
+    pub fn unsafe_block(&self) {
+        unsafe {}
+    }
+}
+
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 0abc4833e5dc8ec4da48d5b25e1d0df81cceec4d Mon Sep 17 00:00:00 2001
From: Christoph Walcher <christoph-wa@gmx.de>
Date: Thu, 6 Aug 2020 02:42:40 +0200
Subject: Lint .min(x).max(y) with x < y

Fixes #5854
---
 clippy_lints/src/minmax.rs | 52 +++++++++++++++++++++++++++++-----------------
 tests/ui/min_max.rs        | 14 +++++++++++++
 tests/ui/min_max.stderr    | 32 +++++++++++++++++++++++++++-
 3 files changed, 78 insertions(+), 20 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/minmax.rs b/clippy_lints/src/minmax.rs
index dae39aaf5e2..1f798fd1120 100644
--- a/clippy_lints/src/minmax.rs
+++ b/clippy_lints/src/minmax.rs
@@ -18,6 +18,10 @@ declare_clippy_lint! {
     /// ```ignore
     /// min(0, max(100, x))
     /// ```
+    /// or
+    /// ```ignore
+    /// x.max(100).min(0)
+    /// ```
     /// It will always be equal to `0`. Probably the author meant to clamp the value
     /// between 0 and 100, but has erroneously swapped `min` and `max`.
     pub MIN_MAX,
@@ -60,25 +64,35 @@ enum MinMax {
 }
 
 fn min_max<'a>(cx: &LateContext<'_>, expr: &'a Expr<'a>) -> Option<(MinMax, Constant, &'a Expr<'a>)> {
-    if let ExprKind::Call(ref path, ref args) = expr.kind {
-        if let ExprKind::Path(ref qpath) = path.kind {
-            cx.typeck_results()
-                .qpath_res(qpath, path.hir_id)
-                .opt_def_id()
-                .and_then(|def_id| {
-                    if match_def_path(cx, def_id, &paths::CMP_MIN) {
-                        fetch_const(cx, args, MinMax::Min)
-                    } else if match_def_path(cx, def_id, &paths::CMP_MAX) {
-                        fetch_const(cx, args, MinMax::Max)
-                    } else {
-                        None
-                    }
-                })
-        } else {
-            None
-        }
-    } else {
-        None
+    match expr.kind {
+        ExprKind::Call(ref path, ref args) => {
+            if let ExprKind::Path(ref qpath) = path.kind {
+                cx.typeck_results()
+                    .qpath_res(qpath, path.hir_id)
+                    .opt_def_id()
+                    .and_then(|def_id| {
+                        if match_def_path(cx, def_id, &paths::CMP_MIN) {
+                            fetch_const(cx, args, MinMax::Min)
+                        } else if match_def_path(cx, def_id, &paths::CMP_MAX) {
+                            fetch_const(cx, args, MinMax::Max)
+                        } else {
+                            None
+                        }
+                    })
+            } else {
+                None
+            }
+        },
+        ExprKind::MethodCall(ref path, _, ref args, _) => {
+            if path.ident.as_str() == sym!(max).as_str() {
+                fetch_const(cx, args, MinMax::Max)
+            } else if path.ident.as_str() == sym!(min).as_str() {
+                fetch_const(cx, args, MinMax::Min)
+            } else {
+                None
+            }
+        },
+        _ => None,
     }
 }
 
diff --git a/tests/ui/min_max.rs b/tests/ui/min_max.rs
index 8307d4b3019..90ec5676493 100644
--- a/tests/ui/min_max.rs
+++ b/tests/ui/min_max.rs
@@ -30,4 +30,18 @@ fn main() {
     max(min(s, "Apple"), "Zoo");
 
     max("Apple", min(s, "Zoo")); // ok
+
+    x.min(1).max(3);
+    x.max(3).min(1);
+
+    x.max(1).min(3); // ok
+    x.min(3).max(1); // ok
+
+    max(x.min(1), 3);
+    min(x.max(1), 3); // ok
+
+    s.max("Zoo").min("Apple");
+    s.min("Apple").max("Zoo");
+
+    s.min("Zoo").max("Apple"); // ok
 }
diff --git a/tests/ui/min_max.stderr b/tests/ui/min_max.stderr
index b552c137f7c..653946dc025 100644
--- a/tests/ui/min_max.stderr
+++ b/tests/ui/min_max.stderr
@@ -42,5 +42,35 @@ error: this `min`/`max` combination leads to constant result
 LL |     max(min(s, "Apple"), "Zoo");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 7 previous errors
+error: this `min`/`max` combination leads to constant result
+  --> $DIR/min_max.rs:34:5
+   |
+LL |     x.min(1).max(3);
+   |     ^^^^^^^^^^^^^^^
+
+error: this `min`/`max` combination leads to constant result
+  --> $DIR/min_max.rs:35:5
+   |
+LL |     x.max(3).min(1);
+   |     ^^^^^^^^^^^^^^^
+
+error: this `min`/`max` combination leads to constant result
+  --> $DIR/min_max.rs:40:5
+   |
+LL |     max(x.min(1), 3);
+   |     ^^^^^^^^^^^^^^^^
+
+error: this `min`/`max` combination leads to constant result
+  --> $DIR/min_max.rs:43:5
+   |
+LL |     s.max("Zoo").min("Apple");
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: this `min`/`max` combination leads to constant result
+  --> $DIR/min_max.rs:44:5
+   |
+LL |     s.min("Apple").max("Zoo");
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 12 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From e0a4988fcc716e349fd801d98182c0d984a2ee3f Mon Sep 17 00:00:00 2001
From: Christoph Walcher <christoph-wa@gmx.de>
Date: Tue, 4 Aug 2020 20:23:14 +0200
Subject: Lint against `Self` as an arbitrary self type

Fixes #5861
---
 CHANGELOG.md                              |  1 +
 clippy_lints/src/lib.rs                   |  5 +++
 clippy_lints/src/needless_fn_self_type.rs | 64 +++++++++++++++++++++++++++++++
 clippy_lints/src/trait_bounds.rs          |  2 +-
 src/lintlist/mod.rs                       |  7 ++++
 tests/ui/needless_fn_self_type.rs         | 26 +++++++++++++
 tests/ui/needless_fn_self_type.stderr     | 11 ++++++
 7 files changed, 115 insertions(+), 1 deletion(-)
 create mode 100644 clippy_lints/src/needless_fn_self_type.rs
 create mode 100644 tests/ui/needless_fn_self_type.rs
 create mode 100644 tests/ui/needless_fn_self_type.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index bfe896d5efa..179ecee03da 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1622,6 +1622,7 @@ Released 2018-09-13
 [`needless_collect`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_collect
 [`needless_continue`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_continue
 [`needless_doctest_main`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_doctest_main
+[`needless_fn_self_type`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_fn_self_type
 [`needless_lifetimes`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_lifetimes
 [`needless_pass_by_value`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_pass_by_value
 [`needless_range_loop`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_range_loop
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 81864340f1a..80c85e70e89 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -254,6 +254,7 @@ mod needless_bool;
 mod needless_borrow;
 mod needless_borrowed_ref;
 mod needless_continue;
+mod needless_fn_self_type;
 mod needless_pass_by_value;
 mod needless_update;
 mod neg_cmp_op_on_partial_ord;
@@ -722,6 +723,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &needless_borrow::NEEDLESS_BORROW,
         &needless_borrowed_ref::NEEDLESS_BORROWED_REFERENCE,
         &needless_continue::NEEDLESS_CONTINUE,
+        &needless_fn_self_type::NEEDLESS_FN_SELF_TYPE,
         &needless_pass_by_value::NEEDLESS_PASS_BY_VALUE,
         &needless_update::NEEDLESS_UPDATE,
         &neg_cmp_op_on_partial_ord::NEG_CMP_OP_ON_PARTIAL_ORD,
@@ -1027,6 +1029,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_early_pass(|| box items_after_statements::ItemsAfterStatements);
     store.register_early_pass(|| box precedence::Precedence);
     store.register_early_pass(|| box needless_continue::NeedlessContinue);
+    store.register_early_pass(|| box needless_fn_self_type::NeedlessFnSelfType);
     store.register_early_pass(|| box redundant_static_lifetimes::RedundantStaticLifetimes);
     store.register_late_pass(|| box cargo_common_metadata::CargoCommonMetadata);
     store.register_late_pass(|| box multiple_crate_versions::MultipleCrateVersions);
@@ -1374,6 +1377,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&needless_bool::BOOL_COMPARISON),
         LintId::of(&needless_bool::NEEDLESS_BOOL),
         LintId::of(&needless_borrowed_ref::NEEDLESS_BORROWED_REFERENCE),
+        LintId::of(&needless_fn_self_type::NEEDLESS_FN_SELF_TYPE),
         LintId::of(&needless_update::NEEDLESS_UPDATE),
         LintId::of(&neg_cmp_op_on_partial_ord::NEG_CMP_OP_ON_PARTIAL_ORD),
         LintId::of(&neg_multiply::NEG_MULTIPLY),
@@ -1534,6 +1538,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&misc_early::MIXED_CASE_HEX_LITERALS),
         LintId::of(&misc_early::REDUNDANT_PATTERN),
         LintId::of(&mut_reference::UNNECESSARY_MUT_PASSED),
+        LintId::of(&needless_fn_self_type::NEEDLESS_FN_SELF_TYPE),
         LintId::of(&neg_multiply::NEG_MULTIPLY),
         LintId::of(&new_without_default::NEW_WITHOUT_DEFAULT),
         LintId::of(&non_expressive_names::JUST_UNDERSCORES_AND_DIGITS),
diff --git a/clippy_lints/src/needless_fn_self_type.rs b/clippy_lints/src/needless_fn_self_type.rs
new file mode 100644
index 00000000000..050a03467fb
--- /dev/null
+++ b/clippy_lints/src/needless_fn_self_type.rs
@@ -0,0 +1,64 @@
+use crate::utils::span_lint_and_help;
+use if_chain::if_chain;
+use rustc_ast::ast::{Param, TyKind};
+use rustc_lint::{EarlyContext, EarlyLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// **What it does:** The lint checks for `self` fn fn parameters that explicitly
+    /// specify the `Self`-type explicitly
+    /// **Why is this bad?** Increases the amount and decreases the readability of code
+    ///
+    /// **Known problems:** None
+    ///
+    /// **Example:**
+    /// ```rust
+    /// impl ValType {
+    ///     pub fn bytes(self: Self) -> usize {
+    ///         match self {
+    ///             Self::I32 | Self::F32 => 4,
+    ///             Self::I64 | Self::F64 => 8,
+    ///         }
+    ///     }
+    /// }
+    /// ```
+    ///
+    /// Could be rewritten as
+    ///
+    /// ```rust
+    /// impl ValType {
+    ///     pub fn bytes(self) -> usize {
+    ///         match self {
+    ///             Self::I32 | Self::F32 => 4,
+    ///             Self::I64 | Self::F64 => 8,
+    ///         }
+    ///     }
+    /// }
+    /// ```
+    pub NEEDLESS_FN_SELF_TYPE,
+    style,
+    "type of `self` parameter is already by default `Self`"
+}
+
+declare_lint_pass!(NeedlessFnSelfType => [NEEDLESS_FN_SELF_TYPE]);
+
+impl EarlyLintPass for NeedlessFnSelfType {
+    fn check_param(&mut self, cx: &EarlyContext<'_>, p: &Param) {
+        if_chain! {
+            if p.is_self();
+            if let TyKind::Path(None, path) = &p.ty.kind;
+            if let Some(segment) = path.segments.first();
+            if segment.ident.as_str() == sym!(Self).as_str();
+            then {
+                span_lint_and_help(
+                    cx,
+                    NEEDLESS_FN_SELF_TYPE,
+                    p.ty.span,
+                    "the type of the `self` parameter is already by default `Self`",
+                    None,
+                    "consider removing the type specification",
+                );
+            }
+        }
+    }
+}
diff --git a/clippy_lints/src/trait_bounds.rs b/clippy_lints/src/trait_bounds.rs
index 06631f89f27..d4acf8df46d 100644
--- a/clippy_lints/src/trait_bounds.rs
+++ b/clippy_lints/src/trait_bounds.rs
@@ -50,7 +50,7 @@ declare_clippy_lint! {
     /// fn func<T: Clone + Default>(arg: T) {}
     /// ```
     /// or
-    ///  ///
+    ///
     /// ```rust
     /// fn func<T>(arg: T) where T: Clone + Default {}
     /// ```
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index b64c6e54409..a20e410f79b 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -1501,6 +1501,13 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
         deprecation: None,
         module: "doc",
     },
+    Lint {
+        name: "needless_fn_self_type",
+        group: "style",
+        desc: "type of `self` parameter is already by default `Self`",
+        deprecation: None,
+        module: "needless_fn_self_type",
+    },
     Lint {
         name: "needless_lifetimes",
         group: "complexity",
diff --git a/tests/ui/needless_fn_self_type.rs b/tests/ui/needless_fn_self_type.rs
new file mode 100644
index 00000000000..12bb84582ff
--- /dev/null
+++ b/tests/ui/needless_fn_self_type.rs
@@ -0,0 +1,26 @@
+#![warn(clippy::style, clippy::needless_fn_self_type)]
+
+pub enum ValType {
+    I32,
+    I64,
+    F32,
+    F64,
+}
+
+impl ValType {
+    pub fn bytes_bad(self: Self) -> usize {
+        match self {
+            Self::I32 | Self::F32 => 4,
+            Self::I64 | Self::F64 => 8,
+        }
+    }
+
+    pub fn bytes_good(self) -> usize {
+        match self {
+            Self::I32 | Self::F32 => 4,
+            Self::I64 | Self::F64 => 8,
+        }
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/needless_fn_self_type.stderr b/tests/ui/needless_fn_self_type.stderr
new file mode 100644
index 00000000000..703705c7842
--- /dev/null
+++ b/tests/ui/needless_fn_self_type.stderr
@@ -0,0 +1,11 @@
+error: the type of the `self` parameter is already by default `Self`
+  --> $DIR/needless_fn_self_type.rs:11:28
+   |
+LL |     pub fn bytes_bad(self: Self) -> usize {
+   |                            ^^^^
+   |
+   = note: `-D clippy::needless-fn-self-type` implied by `-D warnings`
+   = help: consider removing the type specification
+
+error: aborting due to previous error
+
-- 
cgit 1.4.1-3-g733a5


From 737f62cb6eaa5eca23701dbbe8d63465e1c4843b Mon Sep 17 00:00:00 2001
From: Christoph Walcher <christoph-wa@gmx.de>
Date: Tue, 4 Aug 2020 21:07:35 +0200
Subject: fix doc

---
 clippy_lints/src/needless_fn_self_type.rs | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/needless_fn_self_type.rs b/clippy_lints/src/needless_fn_self_type.rs
index 050a03467fb..b71f2fbbd46 100644
--- a/clippy_lints/src/needless_fn_self_type.rs
+++ b/clippy_lints/src/needless_fn_self_type.rs
@@ -13,6 +13,13 @@ declare_clippy_lint! {
     ///
     /// **Example:**
     /// ```rust
+    /// enum ValType {
+    ///     I32,
+    ///     I64,
+    ///     F32,
+    ///     F64,
+    /// }
+    ///
     /// impl ValType {
     ///     pub fn bytes(self: Self) -> usize {
     ///         match self {
@@ -26,6 +33,13 @@ declare_clippy_lint! {
     /// Could be rewritten as
     ///
     /// ```rust
+    /// enum ValType {
+    ///     I32,
+    ///     I64,
+    ///     F32,
+    ///     F64,
+    /// }
+    ///
     /// impl ValType {
     ///     pub fn bytes(self) -> usize {
     ///         match self {
-- 
cgit 1.4.1-3-g733a5


From d635b76eaf3435f9bdce1dcbdd315b0e770493f0 Mon Sep 17 00:00:00 2001
From: Christoph Walcher <christoph-wa@gmx.de>
Date: Wed, 5 Aug 2020 02:59:30 +0200
Subject: adopt comments from review

---
 CHANGELOG.md                                     |   2 +-
 clippy_lints/src/lib.rs                          |  10 +-
 clippy_lints/src/needless_arbitrary_self_type.rs | 114 +++++++++++++++++++++++
 clippy_lints/src/needless_fn_self_type.rs        |  78 ----------------
 src/lintlist/mod.rs                              |  14 +--
 tests/ui/needless_arbitrary_self_type.rs         |  58 ++++++++++++
 tests/ui/needless_arbitrary_self_type.stderr     |  46 +++++++++
 tests/ui/needless_fn_self_type.rs                |  26 ------
 tests/ui/needless_fn_self_type.stderr            |  11 ---
 9 files changed, 231 insertions(+), 128 deletions(-)
 create mode 100644 clippy_lints/src/needless_arbitrary_self_type.rs
 delete mode 100644 clippy_lints/src/needless_fn_self_type.rs
 create mode 100644 tests/ui/needless_arbitrary_self_type.rs
 create mode 100644 tests/ui/needless_arbitrary_self_type.stderr
 delete mode 100644 tests/ui/needless_fn_self_type.rs
 delete mode 100644 tests/ui/needless_fn_self_type.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 179ecee03da..3f470f601ef 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1616,13 +1616,13 @@ Released 2018-09-13
 [`mutex_atomic`]: https://rust-lang.github.io/rust-clippy/master/index.html#mutex_atomic
 [`mutex_integer`]: https://rust-lang.github.io/rust-clippy/master/index.html#mutex_integer
 [`naive_bytecount`]: https://rust-lang.github.io/rust-clippy/master/index.html#naive_bytecount
+[`needless_arbitrary_self_type`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_arbitrary_self_type
 [`needless_bool`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_bool
 [`needless_borrow`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow
 [`needless_borrowed_reference`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrowed_reference
 [`needless_collect`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_collect
 [`needless_continue`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_continue
 [`needless_doctest_main`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_doctest_main
-[`needless_fn_self_type`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_fn_self_type
 [`needless_lifetimes`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_lifetimes
 [`needless_pass_by_value`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_pass_by_value
 [`needless_range_loop`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_range_loop
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 80c85e70e89..3c39de1abf1 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -250,11 +250,11 @@ mod mut_mut;
 mod mut_reference;
 mod mutable_debug_assertion;
 mod mutex_atomic;
+mod needless_arbitrary_self_type;
 mod needless_bool;
 mod needless_borrow;
 mod needless_borrowed_ref;
 mod needless_continue;
-mod needless_fn_self_type;
 mod needless_pass_by_value;
 mod needless_update;
 mod neg_cmp_op_on_partial_ord;
@@ -718,12 +718,12 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &mutable_debug_assertion::DEBUG_ASSERT_WITH_MUT_CALL,
         &mutex_atomic::MUTEX_ATOMIC,
         &mutex_atomic::MUTEX_INTEGER,
+        &needless_arbitrary_self_type::NEEDLESS_ARBITRARY_SELF_TYPE,
         &needless_bool::BOOL_COMPARISON,
         &needless_bool::NEEDLESS_BOOL,
         &needless_borrow::NEEDLESS_BORROW,
         &needless_borrowed_ref::NEEDLESS_BORROWED_REFERENCE,
         &needless_continue::NEEDLESS_CONTINUE,
-        &needless_fn_self_type::NEEDLESS_FN_SELF_TYPE,
         &needless_pass_by_value::NEEDLESS_PASS_BY_VALUE,
         &needless_update::NEEDLESS_UPDATE,
         &neg_cmp_op_on_partial_ord::NEG_CMP_OP_ON_PARTIAL_ORD,
@@ -1029,7 +1029,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_early_pass(|| box items_after_statements::ItemsAfterStatements);
     store.register_early_pass(|| box precedence::Precedence);
     store.register_early_pass(|| box needless_continue::NeedlessContinue);
-    store.register_early_pass(|| box needless_fn_self_type::NeedlessFnSelfType);
+    store.register_early_pass(|| box needless_arbitrary_self_type::NeedlessArbitrarySelfType);
     store.register_early_pass(|| box redundant_static_lifetimes::RedundantStaticLifetimes);
     store.register_late_pass(|| box cargo_common_metadata::CargoCommonMetadata);
     store.register_late_pass(|| box multiple_crate_versions::MultipleCrateVersions);
@@ -1374,10 +1374,10 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&mut_key::MUTABLE_KEY_TYPE),
         LintId::of(&mut_reference::UNNECESSARY_MUT_PASSED),
         LintId::of(&mutex_atomic::MUTEX_ATOMIC),
+        LintId::of(&needless_arbitrary_self_type::NEEDLESS_ARBITRARY_SELF_TYPE),
         LintId::of(&needless_bool::BOOL_COMPARISON),
         LintId::of(&needless_bool::NEEDLESS_BOOL),
         LintId::of(&needless_borrowed_ref::NEEDLESS_BORROWED_REFERENCE),
-        LintId::of(&needless_fn_self_type::NEEDLESS_FN_SELF_TYPE),
         LintId::of(&needless_update::NEEDLESS_UPDATE),
         LintId::of(&neg_cmp_op_on_partial_ord::NEG_CMP_OP_ON_PARTIAL_ORD),
         LintId::of(&neg_multiply::NEG_MULTIPLY),
@@ -1538,7 +1538,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&misc_early::MIXED_CASE_HEX_LITERALS),
         LintId::of(&misc_early::REDUNDANT_PATTERN),
         LintId::of(&mut_reference::UNNECESSARY_MUT_PASSED),
-        LintId::of(&needless_fn_self_type::NEEDLESS_FN_SELF_TYPE),
         LintId::of(&neg_multiply::NEG_MULTIPLY),
         LintId::of(&new_without_default::NEW_WITHOUT_DEFAULT),
         LintId::of(&non_expressive_names::JUST_UNDERSCORES_AND_DIGITS),
@@ -1607,6 +1606,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&misc::SHORT_CIRCUIT_STATEMENT),
         LintId::of(&misc_early::UNNEEDED_WILDCARD_PATTERN),
         LintId::of(&misc_early::ZERO_PREFIXED_LITERAL),
+        LintId::of(&needless_arbitrary_self_type::NEEDLESS_ARBITRARY_SELF_TYPE),
         LintId::of(&needless_bool::BOOL_COMPARISON),
         LintId::of(&needless_bool::NEEDLESS_BOOL),
         LintId::of(&needless_borrowed_ref::NEEDLESS_BORROWED_REFERENCE),
diff --git a/clippy_lints/src/needless_arbitrary_self_type.rs b/clippy_lints/src/needless_arbitrary_self_type.rs
new file mode 100644
index 00000000000..1b23ecd9ad2
--- /dev/null
+++ b/clippy_lints/src/needless_arbitrary_self_type.rs
@@ -0,0 +1,114 @@
+use crate::utils::span_lint_and_sugg;
+use if_chain::if_chain;
+use rustc_ast::ast::{BindingMode, Lifetime, Mutability, Param, PatKind, Path, TyKind};
+use rustc_errors::Applicability;
+use rustc_lint::{EarlyContext, EarlyLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::symbol::kw;
+use rustc_span::Span;
+
+declare_clippy_lint! {
+    /// **What it does:** The lint checks for `self` in fn parameters that
+    /// specify the `Self`-type explicitly
+    /// **Why is this bad?** Increases the amount and decreases the readability of code
+    ///
+    /// **Known problems:** None
+    ///
+    /// **Example:**
+    /// ```rust
+    /// enum ValType {
+    ///     I32,
+    ///     I64,
+    ///     F32,
+    ///     F64,
+    /// }
+    ///
+    /// impl ValType {
+    ///     pub fn bytes(self: Self) -> usize {
+    ///         match self {
+    ///             Self::I32 | Self::F32 => 4,
+    ///             Self::I64 | Self::F64 => 8,
+    ///         }
+    ///     }
+    /// }
+    /// ```
+    ///
+    /// Could be rewritten as
+    ///
+    /// ```rust
+    /// enum ValType {
+    ///     I32,
+    ///     I64,
+    ///     F32,
+    ///     F64,
+    /// }
+    ///
+    /// impl ValType {
+    ///     pub fn bytes(self) -> usize {
+    ///         match self {
+    ///             Self::I32 | Self::F32 => 4,
+    ///             Self::I64 | Self::F64 => 8,
+    ///         }
+    ///     }
+    /// }
+    /// ```
+    pub NEEDLESS_ARBITRARY_SELF_TYPE,
+    complexity,
+    "type of `self` parameter is already by default `Self`"
+}
+
+declare_lint_pass!(NeedlessArbitrarySelfType => [NEEDLESS_ARBITRARY_SELF_TYPE]);
+
+enum Mode {
+    Ref(Option<Lifetime>),
+    Value,
+}
+
+fn check_param_inner(cx: &EarlyContext<'_>, path: &Path, span: Span, binding_mode: &Mode, mutbl: Mutability) {
+    if_chain! {
+        if let [segment] = &path.segments[..];
+        if segment.ident.name == kw::SelfUpper;
+        then {
+            let self_param = match (binding_mode, mutbl) {
+                (Mode::Ref(None), Mutability::Mut) => "&mut self".to_string(),
+                (Mode::Ref(Some(lifetime)), Mutability::Mut) => format!("&{} mut self", &lifetime.ident.name),
+                (Mode::Ref(None), Mutability::Not) => "&self".to_string(),
+                (Mode::Ref(Some(lifetime)), Mutability::Not) => format!("&{} self", &lifetime.ident.name),
+                (Mode::Value, Mutability::Mut) => "mut self".to_string(),
+                (Mode::Value, Mutability::Not) => "self".to_string(),
+            };
+
+            span_lint_and_sugg(
+                cx,
+                NEEDLESS_ARBITRARY_SELF_TYPE,
+                span,
+                "the type of the `self` parameter is arbitrary",
+                "consider to change this parameter to",
+                self_param,
+                Applicability::MachineApplicable,
+            )
+        }
+    }
+}
+
+impl EarlyLintPass for NeedlessArbitrarySelfType {
+    fn check_param(&mut self, cx: &EarlyContext<'_>, p: &Param) {
+        if !p.is_self() {
+            return;
+        }
+
+        match &p.ty.kind {
+            TyKind::Path(None, path) => {
+                if let PatKind::Ident(BindingMode::ByValue(mutbl), _, _) = p.pat.kind {
+                    check_param_inner(cx, path, p.span.to(p.ty.span), &Mode::Value, mutbl)
+                }
+            },
+            TyKind::Rptr(lifetime, mut_ty) => {
+                if let TyKind::Path(None, path) = &mut_ty.ty.kind {
+                    check_param_inner(cx, path, p.span.to(p.ty.span), &Mode::Ref(*lifetime), mut_ty.mutbl)
+                }
+            },
+            _ => {},
+        }
+    }
+}
diff --git a/clippy_lints/src/needless_fn_self_type.rs b/clippy_lints/src/needless_fn_self_type.rs
deleted file mode 100644
index b71f2fbbd46..00000000000
--- a/clippy_lints/src/needless_fn_self_type.rs
+++ /dev/null
@@ -1,78 +0,0 @@
-use crate::utils::span_lint_and_help;
-use if_chain::if_chain;
-use rustc_ast::ast::{Param, TyKind};
-use rustc_lint::{EarlyContext, EarlyLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-
-declare_clippy_lint! {
-    /// **What it does:** The lint checks for `self` fn fn parameters that explicitly
-    /// specify the `Self`-type explicitly
-    /// **Why is this bad?** Increases the amount and decreases the readability of code
-    ///
-    /// **Known problems:** None
-    ///
-    /// **Example:**
-    /// ```rust
-    /// enum ValType {
-    ///     I32,
-    ///     I64,
-    ///     F32,
-    ///     F64,
-    /// }
-    ///
-    /// impl ValType {
-    ///     pub fn bytes(self: Self) -> usize {
-    ///         match self {
-    ///             Self::I32 | Self::F32 => 4,
-    ///             Self::I64 | Self::F64 => 8,
-    ///         }
-    ///     }
-    /// }
-    /// ```
-    ///
-    /// Could be rewritten as
-    ///
-    /// ```rust
-    /// enum ValType {
-    ///     I32,
-    ///     I64,
-    ///     F32,
-    ///     F64,
-    /// }
-    ///
-    /// impl ValType {
-    ///     pub fn bytes(self) -> usize {
-    ///         match self {
-    ///             Self::I32 | Self::F32 => 4,
-    ///             Self::I64 | Self::F64 => 8,
-    ///         }
-    ///     }
-    /// }
-    /// ```
-    pub NEEDLESS_FN_SELF_TYPE,
-    style,
-    "type of `self` parameter is already by default `Self`"
-}
-
-declare_lint_pass!(NeedlessFnSelfType => [NEEDLESS_FN_SELF_TYPE]);
-
-impl EarlyLintPass for NeedlessFnSelfType {
-    fn check_param(&mut self, cx: &EarlyContext<'_>, p: &Param) {
-        if_chain! {
-            if p.is_self();
-            if let TyKind::Path(None, path) = &p.ty.kind;
-            if let Some(segment) = path.segments.first();
-            if segment.ident.as_str() == sym!(Self).as_str();
-            then {
-                span_lint_and_help(
-                    cx,
-                    NEEDLESS_FN_SELF_TYPE,
-                    p.ty.span,
-                    "the type of the `self` parameter is already by default `Self`",
-                    None,
-                    "consider removing the type specification",
-                );
-            }
-        }
-    }
-}
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index a20e410f79b..91761e8a86d 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -1459,6 +1459,13 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
         deprecation: None,
         module: "bytecount",
     },
+    Lint {
+        name: "needless_arbitrary_self_type",
+        group: "complexity",
+        desc: "type of `self` parameter is already by default `Self`",
+        deprecation: None,
+        module: "needless_arbitrary_self_type",
+    },
     Lint {
         name: "needless_bool",
         group: "complexity",
@@ -1501,13 +1508,6 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
         deprecation: None,
         module: "doc",
     },
-    Lint {
-        name: "needless_fn_self_type",
-        group: "style",
-        desc: "type of `self` parameter is already by default `Self`",
-        deprecation: None,
-        module: "needless_fn_self_type",
-    },
     Lint {
         name: "needless_lifetimes",
         group: "complexity",
diff --git a/tests/ui/needless_arbitrary_self_type.rs b/tests/ui/needless_arbitrary_self_type.rs
new file mode 100644
index 00000000000..da4bbcf4a7d
--- /dev/null
+++ b/tests/ui/needless_arbitrary_self_type.rs
@@ -0,0 +1,58 @@
+#![warn(clippy::needless_arbitrary_self_type)]
+
+pub enum ValType {
+    A,
+    B,
+}
+
+impl ValType {
+    pub fn bad(self: Self) {
+        unimplemented!();
+    }
+
+    pub fn good(self) {
+        unimplemented!();
+    }
+
+    pub fn mut_bad(mut self: Self) {
+        unimplemented!();
+    }
+
+    pub fn mut_good(mut self) {
+        unimplemented!();
+    }
+
+    pub fn ref_bad(self: &Self) {
+        unimplemented!();
+    }
+
+    pub fn ref_bad_with_lifetime<'a>(self: &'a Self) {
+        unimplemented!();
+    }
+
+    pub fn ref_good(&self) {
+        unimplemented!();
+    }
+
+    pub fn mut_ref_bad(self: &mut Self) {
+        unimplemented!();
+    }
+
+    pub fn mut_ref_bad_with_lifetime<'a>(self: &'a mut Self) {
+        unimplemented!();
+    }
+
+    pub fn mut_ref_good(&mut self) {
+        unimplemented!();
+    }
+
+    pub fn mut_ref_mut_bad(mut self: &mut Self) {
+        unimplemented!();
+    }
+
+    pub fn mut_ref_mut_ref_good(self: &&mut &mut Self) {
+        unimplemented!();
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/needless_arbitrary_self_type.stderr b/tests/ui/needless_arbitrary_self_type.stderr
new file mode 100644
index 00000000000..ee803b24071
--- /dev/null
+++ b/tests/ui/needless_arbitrary_self_type.stderr
@@ -0,0 +1,46 @@
+error: the type of the `self` parameter is arbitrary
+  --> $DIR/needless_arbitrary_self_type.rs:9:16
+   |
+LL |     pub fn bad(self: Self) {
+   |                ^^^^^^^^^^ help: consider to change this parameter to: `self`
+   |
+   = note: `-D clippy::needless-arbitrary-self-type` implied by `-D warnings`
+
+error: the type of the `self` parameter is arbitrary
+  --> $DIR/needless_arbitrary_self_type.rs:17:20
+   |
+LL |     pub fn mut_bad(mut self: Self) {
+   |                    ^^^^^^^^^^^^^^ help: consider to change this parameter to: `mut self`
+
+error: the type of the `self` parameter is arbitrary
+  --> $DIR/needless_arbitrary_self_type.rs:25:20
+   |
+LL |     pub fn ref_bad(self: &Self) {
+   |                    ^^^^^^^^^^^ help: consider to change this parameter to: `&self`
+
+error: the type of the `self` parameter is arbitrary
+  --> $DIR/needless_arbitrary_self_type.rs:29:38
+   |
+LL |     pub fn ref_bad_with_lifetime<'a>(self: &'a Self) {
+   |                                      ^^^^^^^^^^^^^^ help: consider to change this parameter to: `&'a self`
+
+error: the type of the `self` parameter is arbitrary
+  --> $DIR/needless_arbitrary_self_type.rs:37:24
+   |
+LL |     pub fn mut_ref_bad(self: &mut Self) {
+   |                        ^^^^^^^^^^^^^^^ help: consider to change this parameter to: `&mut self`
+
+error: the type of the `self` parameter is arbitrary
+  --> $DIR/needless_arbitrary_self_type.rs:41:42
+   |
+LL |     pub fn mut_ref_bad_with_lifetime<'a>(self: &'a mut Self) {
+   |                                          ^^^^^^^^^^^^^^^^^^ help: consider to change this parameter to: `&'a mut self`
+
+error: the type of the `self` parameter is arbitrary
+  --> $DIR/needless_arbitrary_self_type.rs:49:28
+   |
+LL |     pub fn mut_ref_mut_bad(mut self: &mut Self) {
+   |                            ^^^^^^^^^^^^^^^^^^^ help: consider to change this parameter to: `&mut self`
+
+error: aborting due to 7 previous errors
+
diff --git a/tests/ui/needless_fn_self_type.rs b/tests/ui/needless_fn_self_type.rs
deleted file mode 100644
index 12bb84582ff..00000000000
--- a/tests/ui/needless_fn_self_type.rs
+++ /dev/null
@@ -1,26 +0,0 @@
-#![warn(clippy::style, clippy::needless_fn_self_type)]
-
-pub enum ValType {
-    I32,
-    I64,
-    F32,
-    F64,
-}
-
-impl ValType {
-    pub fn bytes_bad(self: Self) -> usize {
-        match self {
-            Self::I32 | Self::F32 => 4,
-            Self::I64 | Self::F64 => 8,
-        }
-    }
-
-    pub fn bytes_good(self) -> usize {
-        match self {
-            Self::I32 | Self::F32 => 4,
-            Self::I64 | Self::F64 => 8,
-        }
-    }
-}
-
-fn main() {}
diff --git a/tests/ui/needless_fn_self_type.stderr b/tests/ui/needless_fn_self_type.stderr
deleted file mode 100644
index 703705c7842..00000000000
--- a/tests/ui/needless_fn_self_type.stderr
+++ /dev/null
@@ -1,11 +0,0 @@
-error: the type of the `self` parameter is already by default `Self`
-  --> $DIR/needless_fn_self_type.rs:11:28
-   |
-LL |     pub fn bytes_bad(self: Self) -> usize {
-   |                            ^^^^
-   |
-   = note: `-D clippy::needless-fn-self-type` implied by `-D warnings`
-   = help: consider removing the type specification
-
-error: aborting due to previous error
-
-- 
cgit 1.4.1-3-g733a5


From e03f73e627721c35459886781af281632cac299d Mon Sep 17 00:00:00 2001
From: Christoph Walcher <christoph-wa@gmx.de>
Date: Wed, 5 Aug 2020 23:38:55 +0200
Subject: fix nits

---
 clippy_lints/src/needless_arbitrary_self_type.rs |  2 +-
 tests/ui/needless_arbitrary_self_type.fixed      | 12 ++++++++++--
 tests/ui/needless_arbitrary_self_type.rs         | 12 ++++++++++--
 tests/ui/needless_arbitrary_self_type.stderr     | 22 +++++++++++-----------
 4 files changed, 32 insertions(+), 16 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/needless_arbitrary_self_type.rs b/clippy_lints/src/needless_arbitrary_self_type.rs
index 1b23ecd9ad2..4590128bedc 100644
--- a/clippy_lints/src/needless_arbitrary_self_type.rs
+++ b/clippy_lints/src/needless_arbitrary_self_type.rs
@@ -82,7 +82,7 @@ fn check_param_inner(cx: &EarlyContext<'_>, path: &Path, span: Span, binding_mod
                 cx,
                 NEEDLESS_ARBITRARY_SELF_TYPE,
                 span,
-                "the type of the `self` parameter is arbitrary",
+                "the type of the `self` parameter does not need to be arbitrary",
                 "consider to change this parameter to",
                 self_param,
                 Applicability::MachineApplicable,
diff --git a/tests/ui/needless_arbitrary_self_type.fixed b/tests/ui/needless_arbitrary_self_type.fixed
index 642e48fd131..bc770d8bf68 100644
--- a/tests/ui/needless_arbitrary_self_type.fixed
+++ b/tests/ui/needless_arbitrary_self_type.fixed
@@ -29,11 +29,15 @@ impl ValType {
         unimplemented!();
     }
 
+    pub fn ref_good(&self) {
+        unimplemented!();
+    }
+
     pub fn ref_bad_with_lifetime<'a>(&'a self) {
         unimplemented!();
     }
 
-    pub fn ref_good(&self) {
+    pub fn ref_good_with_lifetime<'a>(&'a self) {
         unimplemented!();
     }
 
@@ -41,11 +45,15 @@ impl ValType {
         unimplemented!();
     }
 
+    pub fn mut_ref_good(&mut self) {
+        unimplemented!();
+    }
+
     pub fn mut_ref_bad_with_lifetime<'a>(&'a mut self) {
         unimplemented!();
     }
 
-    pub fn mut_ref_good(&mut self) {
+    pub fn mut_ref_good_with_lifetime<'a>(&'a mut self) {
         unimplemented!();
     }
 
diff --git a/tests/ui/needless_arbitrary_self_type.rs b/tests/ui/needless_arbitrary_self_type.rs
index 178abc341a8..9074920b204 100644
--- a/tests/ui/needless_arbitrary_self_type.rs
+++ b/tests/ui/needless_arbitrary_self_type.rs
@@ -29,11 +29,15 @@ impl ValType {
         unimplemented!();
     }
 
+    pub fn ref_good(&self) {
+        unimplemented!();
+    }
+
     pub fn ref_bad_with_lifetime<'a>(self: &'a Self) {
         unimplemented!();
     }
 
-    pub fn ref_good(&self) {
+    pub fn ref_good_with_lifetime<'a>(&'a self) {
         unimplemented!();
     }
 
@@ -41,11 +45,15 @@ impl ValType {
         unimplemented!();
     }
 
+    pub fn mut_ref_good(&mut self) {
+        unimplemented!();
+    }
+
     pub fn mut_ref_bad_with_lifetime<'a>(self: &'a mut Self) {
         unimplemented!();
     }
 
-    pub fn mut_ref_good(&mut self) {
+    pub fn mut_ref_good_with_lifetime<'a>(&'a mut self) {
         unimplemented!();
     }
 
diff --git a/tests/ui/needless_arbitrary_self_type.stderr b/tests/ui/needless_arbitrary_self_type.stderr
index fc21d3d0afd..227c6d73b62 100644
--- a/tests/ui/needless_arbitrary_self_type.stderr
+++ b/tests/ui/needless_arbitrary_self_type.stderr
@@ -1,4 +1,4 @@
-error: the type of the `self` parameter is arbitrary
+error: the type of the `self` parameter does not need to be arbitrary
   --> $DIR/needless_arbitrary_self_type.rs:12:16
    |
 LL |     pub fn bad(self: Self) {
@@ -6,38 +6,38 @@ LL |     pub fn bad(self: Self) {
    |
    = note: `-D clippy::needless-arbitrary-self-type` implied by `-D warnings`
 
-error: the type of the `self` parameter is arbitrary
+error: the type of the `self` parameter does not need to be arbitrary
   --> $DIR/needless_arbitrary_self_type.rs:20:20
    |
 LL |     pub fn mut_bad(mut self: Self) {
    |                    ^^^^^^^^^^^^^^ help: consider to change this parameter to: `mut self`
 
-error: the type of the `self` parameter is arbitrary
+error: the type of the `self` parameter does not need to be arbitrary
   --> $DIR/needless_arbitrary_self_type.rs:28:20
    |
 LL |     pub fn ref_bad(self: &Self) {
    |                    ^^^^^^^^^^^ help: consider to change this parameter to: `&self`
 
-error: the type of the `self` parameter is arbitrary
-  --> $DIR/needless_arbitrary_self_type.rs:32:38
+error: the type of the `self` parameter does not need to be arbitrary
+  --> $DIR/needless_arbitrary_self_type.rs:36:38
    |
 LL |     pub fn ref_bad_with_lifetime<'a>(self: &'a Self) {
    |                                      ^^^^^^^^^^^^^^ help: consider to change this parameter to: `&'a self`
 
-error: the type of the `self` parameter is arbitrary
-  --> $DIR/needless_arbitrary_self_type.rs:40:24
+error: the type of the `self` parameter does not need to be arbitrary
+  --> $DIR/needless_arbitrary_self_type.rs:44:24
    |
 LL |     pub fn mut_ref_bad(self: &mut Self) {
    |                        ^^^^^^^^^^^^^^^ help: consider to change this parameter to: `&mut self`
 
-error: the type of the `self` parameter is arbitrary
-  --> $DIR/needless_arbitrary_self_type.rs:44:42
+error: the type of the `self` parameter does not need to be arbitrary
+  --> $DIR/needless_arbitrary_self_type.rs:52:42
    |
 LL |     pub fn mut_ref_bad_with_lifetime<'a>(self: &'a mut Self) {
    |                                          ^^^^^^^^^^^^^^^^^^ help: consider to change this parameter to: `&'a mut self`
 
-error: the type of the `self` parameter is arbitrary
-  --> $DIR/needless_arbitrary_self_type.rs:52:28
+error: the type of the `self` parameter does not need to be arbitrary
+  --> $DIR/needless_arbitrary_self_type.rs:60:28
    |
 LL |     pub fn mut_ref_mut_bad(mut self: &mut Self) {
    |                            ^^^^^^^^^^^^^^^^^^^ help: consider to change this parameter to: `&mut self`
-- 
cgit 1.4.1-3-g733a5


From bfe610cc8d7d380cfaf83f03629a23747fc54fad Mon Sep 17 00:00:00 2001
From: Christoph Walcher <christoph-wa@gmx.de>
Date: Fri, 7 Aug 2020 18:03:12 +0200
Subject: ignore mutable self reference parameters

---
 clippy_lints/src/needless_arbitrary_self_type.rs | 8 ++++++--
 tests/ui/needless_arbitrary_self_type.fixed      | 2 +-
 tests/ui/needless_arbitrary_self_type.rs         | 2 +-
 tests/ui/needless_arbitrary_self_type.stderr     | 8 +-------
 4 files changed, 9 insertions(+), 11 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/needless_arbitrary_self_type.rs b/clippy_lints/src/needless_arbitrary_self_type.rs
index 4590128bedc..38bdd0f7ed2 100644
--- a/clippy_lints/src/needless_arbitrary_self_type.rs
+++ b/clippy_lints/src/needless_arbitrary_self_type.rs
@@ -104,8 +104,12 @@ impl EarlyLintPass for NeedlessArbitrarySelfType {
                 }
             },
             TyKind::Rptr(lifetime, mut_ty) => {
-                if let TyKind::Path(None, path) = &mut_ty.ty.kind {
-                    check_param_inner(cx, path, p.span.to(p.ty.span), &Mode::Ref(*lifetime), mut_ty.mutbl)
+                if_chain! {
+                if let TyKind::Path(None, path) = &mut_ty.ty.kind;
+                if let PatKind::Ident(BindingMode::ByValue(Mutability::Not), _, _) = p.pat.kind;
+                    then {
+                        check_param_inner(cx, path, p.span.to(p.ty.span), &Mode::Ref(*lifetime), mut_ty.mutbl)
+                    }
                 }
             },
             _ => {},
diff --git a/tests/ui/needless_arbitrary_self_type.fixed b/tests/ui/needless_arbitrary_self_type.fixed
index bc770d8bf68..9da21eb6b29 100644
--- a/tests/ui/needless_arbitrary_self_type.fixed
+++ b/tests/ui/needless_arbitrary_self_type.fixed
@@ -57,7 +57,7 @@ impl ValType {
         unimplemented!();
     }
 
-    pub fn mut_ref_mut_bad(&mut self) {
+    pub fn mut_ref_mut_good(mut self: &mut Self) {
         unimplemented!();
     }
 
diff --git a/tests/ui/needless_arbitrary_self_type.rs b/tests/ui/needless_arbitrary_self_type.rs
index 9074920b204..17aeaaf97ac 100644
--- a/tests/ui/needless_arbitrary_self_type.rs
+++ b/tests/ui/needless_arbitrary_self_type.rs
@@ -57,7 +57,7 @@ impl ValType {
         unimplemented!();
     }
 
-    pub fn mut_ref_mut_bad(mut self: &mut Self) {
+    pub fn mut_ref_mut_good(mut self: &mut Self) {
         unimplemented!();
     }
 
diff --git a/tests/ui/needless_arbitrary_self_type.stderr b/tests/ui/needless_arbitrary_self_type.stderr
index 227c6d73b62..f4c645d35c8 100644
--- a/tests/ui/needless_arbitrary_self_type.stderr
+++ b/tests/ui/needless_arbitrary_self_type.stderr
@@ -36,11 +36,5 @@ error: the type of the `self` parameter does not need to be arbitrary
 LL |     pub fn mut_ref_bad_with_lifetime<'a>(self: &'a mut Self) {
    |                                          ^^^^^^^^^^^^^^^^^^ help: consider to change this parameter to: `&'a mut self`
 
-error: the type of the `self` parameter does not need to be arbitrary
-  --> $DIR/needless_arbitrary_self_type.rs:60:28
-   |
-LL |     pub fn mut_ref_mut_bad(mut self: &mut Self) {
-   |                            ^^^^^^^^^^^^^^^^^^^ help: consider to change this parameter to: `&mut self`
-
-error: aborting due to 7 previous errors
+error: aborting due to 6 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 87e740921abd4132152f090545fa4c9ed9fa0d6d Mon Sep 17 00:00:00 2001
From: Christoph Walcher <christoph-wa@gmx.de>
Date: Fri, 7 Aug 2020 17:55:25 +0200
Subject: check impl Ord / is_float

---
 clippy_lints/src/minmax.rs | 23 ++++++++++++++++-------
 tests/ui/min_max.rs        | 18 ++++++++++++++++++
 tests/ui/min_max.stderr    | 32 +++++++++++++++++++-------------
 3 files changed, 53 insertions(+), 20 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/minmax.rs b/clippy_lints/src/minmax.rs
index 1f798fd1120..004dd50a31b 100644
--- a/clippy_lints/src/minmax.rs
+++ b/clippy_lints/src/minmax.rs
@@ -1,5 +1,6 @@
 use crate::consts::{constant_simple, Constant};
-use crate::utils::{match_def_path, paths, span_lint};
+use crate::utils::{match_def_path, match_trait_method, paths, span_lint};
+use if_chain::if_chain;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -84,12 +85,20 @@ fn min_max<'a>(cx: &LateContext<'_>, expr: &'a Expr<'a>) -> Option<(MinMax, Cons
             }
         },
         ExprKind::MethodCall(ref path, _, ref args, _) => {
-            if path.ident.as_str() == sym!(max).as_str() {
-                fetch_const(cx, args, MinMax::Max)
-            } else if path.ident.as_str() == sym!(min).as_str() {
-                fetch_const(cx, args, MinMax::Min)
-            } else {
-                None
+            if_chain! {
+                if let [obj, _] = args;
+                if cx.typeck_results().expr_ty(obj).is_floating_point() || match_trait_method(cx, expr, &paths::ORD);
+                then {
+                    if path.ident.as_str() == sym!(max).as_str() {
+                        fetch_const(cx, args, MinMax::Max)
+                    } else if path.ident.as_str() == sym!(min).as_str() {
+                        fetch_const(cx, args, MinMax::Min)
+                    } else {
+                        None
+                    }
+                } else {
+                    None
+                }
             }
         },
         _ => None,
diff --git a/tests/ui/min_max.rs b/tests/ui/min_max.rs
index 90ec5676493..f7ed72a11cf 100644
--- a/tests/ui/min_max.rs
+++ b/tests/ui/min_max.rs
@@ -6,6 +6,18 @@ use std::cmp::{max, min};
 
 const LARGE: usize = 3;
 
+struct NotOrd(u64);
+
+impl NotOrd {
+    fn min(self, x: u64) -> NotOrd {
+        NotOrd(x)
+    }
+
+    fn max(self, x: u64) -> NotOrd {
+        NotOrd(x)
+    }
+}
+
 fn main() {
     let x;
     x = 2usize;
@@ -31,11 +43,14 @@ fn main() {
 
     max("Apple", min(s, "Zoo")); // ok
 
+    let f = 3f32;
     x.min(1).max(3);
     x.max(3).min(1);
+    f.max(3f32).min(1f32);
 
     x.max(1).min(3); // ok
     x.min(3).max(1); // ok
+    f.min(3f32).max(1f32); // ok
 
     max(x.min(1), 3);
     min(x.max(1), 3); // ok
@@ -44,4 +59,7 @@ fn main() {
     s.min("Apple").max("Zoo");
 
     s.min("Zoo").max("Apple"); // ok
+
+    let not_ord = NotOrd(1);
+    not_ord.min(1).max(3); // ok
 }
diff --git a/tests/ui/min_max.stderr b/tests/ui/min_max.stderr
index 653946dc025..9f8e26fa406 100644
--- a/tests/ui/min_max.stderr
+++ b/tests/ui/min_max.stderr
@@ -1,5 +1,5 @@
 error: this `min`/`max` combination leads to constant result
-  --> $DIR/min_max.rs:12:5
+  --> $DIR/min_max.rs:24:5
    |
 LL |     min(1, max(3, x));
    |     ^^^^^^^^^^^^^^^^^
@@ -7,70 +7,76 @@ LL |     min(1, max(3, x));
    = note: `-D clippy::min-max` implied by `-D warnings`
 
 error: this `min`/`max` combination leads to constant result
-  --> $DIR/min_max.rs:13:5
+  --> $DIR/min_max.rs:25:5
    |
 LL |     min(max(3, x), 1);
    |     ^^^^^^^^^^^^^^^^^
 
 error: this `min`/`max` combination leads to constant result
-  --> $DIR/min_max.rs:14:5
+  --> $DIR/min_max.rs:26:5
    |
 LL |     max(min(x, 1), 3);
    |     ^^^^^^^^^^^^^^^^^
 
 error: this `min`/`max` combination leads to constant result
-  --> $DIR/min_max.rs:15:5
+  --> $DIR/min_max.rs:27:5
    |
 LL |     max(3, min(x, 1));
    |     ^^^^^^^^^^^^^^^^^
 
 error: this `min`/`max` combination leads to constant result
-  --> $DIR/min_max.rs:17:5
+  --> $DIR/min_max.rs:29:5
    |
 LL |     my_max(3, my_min(x, 1));
    |     ^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this `min`/`max` combination leads to constant result
-  --> $DIR/min_max.rs:29:5
+  --> $DIR/min_max.rs:41:5
    |
 LL |     min("Apple", max("Zoo", s));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this `min`/`max` combination leads to constant result
-  --> $DIR/min_max.rs:30:5
+  --> $DIR/min_max.rs:42:5
    |
 LL |     max(min(s, "Apple"), "Zoo");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this `min`/`max` combination leads to constant result
-  --> $DIR/min_max.rs:34:5
+  --> $DIR/min_max.rs:47:5
    |
 LL |     x.min(1).max(3);
    |     ^^^^^^^^^^^^^^^
 
 error: this `min`/`max` combination leads to constant result
-  --> $DIR/min_max.rs:35:5
+  --> $DIR/min_max.rs:48:5
    |
 LL |     x.max(3).min(1);
    |     ^^^^^^^^^^^^^^^
 
 error: this `min`/`max` combination leads to constant result
-  --> $DIR/min_max.rs:40:5
+  --> $DIR/min_max.rs:49:5
+   |
+LL |     f.max(3f32).min(1f32);
+   |     ^^^^^^^^^^^^^^^^^^^^^
+
+error: this `min`/`max` combination leads to constant result
+  --> $DIR/min_max.rs:55:5
    |
 LL |     max(x.min(1), 3);
    |     ^^^^^^^^^^^^^^^^
 
 error: this `min`/`max` combination leads to constant result
-  --> $DIR/min_max.rs:43:5
+  --> $DIR/min_max.rs:58:5
    |
 LL |     s.max("Zoo").min("Apple");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this `min`/`max` combination leads to constant result
-  --> $DIR/min_max.rs:44:5
+  --> $DIR/min_max.rs:59:5
    |
 LL |     s.min("Apple").max("Zoo");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 12 previous errors
+error: aborting due to 13 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 888657e09a2133fc105382136f61915086144e3f Mon Sep 17 00:00:00 2001
From: Eduardo Broto <ebroto@tutanota.com>
Date: Sat, 8 Aug 2020 18:13:43 +0200
Subject: Fix ICE in `loops` module

---
 clippy_lints/src/loops.rs        | 20 ++++++++++----------
 tests/ui/crashes/ice-5872.rs     |  5 +++++
 tests/ui/crashes/ice-5872.stderr | 10 ++++++++++
 tests/ui/needless_collect.fixed  |  4 ++--
 tests/ui/needless_collect.rs     |  2 +-
 tests/ui/needless_collect.stderr |  4 ++--
 6 files changed, 30 insertions(+), 15 deletions(-)
 create mode 100644 tests/ui/crashes/ice-5872.rs
 create mode 100644 tests/ui/crashes/ice-5872.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 6359c20040c..1729fea7bc8 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -2374,7 +2374,7 @@ fn check_needless_collect_direct_usage<'tcx>(expr: &'tcx Expr<'_>, cx: &LateCont
                 match_type(cx, ty, &paths::BTREEMAP) ||
                 is_type_diagnostic_item(cx, ty, sym!(hashmap_type)) {
                 if method.ident.name == sym!(len) {
-                    let span = shorten_span(expr, sym!(collect));
+                    let span = shorten_needless_collect_span(expr);
                     span_lint_and_sugg(
                         cx,
                         NEEDLESS_COLLECT,
@@ -2386,20 +2386,20 @@ fn check_needless_collect_direct_usage<'tcx>(expr: &'tcx Expr<'_>, cx: &LateCont
                     );
                 }
                 if method.ident.name == sym!(is_empty) {
-                    let span = shorten_span(expr, sym!(iter));
+                    let span = shorten_needless_collect_span(expr);
                     span_lint_and_sugg(
                         cx,
                         NEEDLESS_COLLECT,
                         span,
                         NEEDLESS_COLLECT_MSG,
                         "replace with",
-                        "get(0).is_none()".to_string(),
+                        "next().is_none()".to_string(),
                         Applicability::MachineApplicable,
                     );
                 }
                 if method.ident.name == sym!(contains) {
                     let contains_arg = snippet(cx, args[1].span, "??");
-                    let span = shorten_span(expr, sym!(collect));
+                    let span = shorten_needless_collect_span(expr);
                     span_lint_and_then(
                         cx,
                         NEEDLESS_COLLECT,
@@ -2579,13 +2579,13 @@ fn detect_iter_and_into_iters<'tcx>(block: &'tcx Block<'tcx>, identifier: Ident)
     }
 }
 
-fn shorten_span(expr: &Expr<'_>, target_fn_name: Symbol) -> Span {
-    let mut current_expr = expr;
-    while let ExprKind::MethodCall(ref path, ref span, ref args, _) = current_expr.kind {
-        if path.ident.name == target_fn_name {
+fn shorten_needless_collect_span(expr: &Expr<'_>) -> Span {
+    if_chain! {
+        if let ExprKind::MethodCall(.., args, _) = &expr.kind;
+        if let ExprKind::MethodCall(_, span, ..) = &args[0].kind;
+        then {
             return expr.span.with_lo(span.lo());
         }
-        current_expr = &args[0];
     }
-    unreachable!()
+    unreachable!();
 }
diff --git a/tests/ui/crashes/ice-5872.rs b/tests/ui/crashes/ice-5872.rs
new file mode 100644
index 00000000000..68afa8f8c3a
--- /dev/null
+++ b/tests/ui/crashes/ice-5872.rs
@@ -0,0 +1,5 @@
+#![warn(clippy::needless_collect)]
+
+fn main() {
+    let _ = vec![1, 2, 3].into_iter().collect::<Vec<_>>().is_empty();
+}
diff --git a/tests/ui/crashes/ice-5872.stderr b/tests/ui/crashes/ice-5872.stderr
new file mode 100644
index 00000000000..a60ca345cf7
--- /dev/null
+++ b/tests/ui/crashes/ice-5872.stderr
@@ -0,0 +1,10 @@
+error: avoid using `collect()` when not needed
+  --> $DIR/ice-5872.rs:4:39
+   |
+LL |     let _ = vec![1, 2, 3].into_iter().collect::<Vec<_>>().is_empty();
+   |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `next().is_none()`
+   |
+   = note: `-D clippy::needless-collect` implied by `-D warnings`
+
+error: aborting due to previous error
+
diff --git a/tests/ui/needless_collect.fixed b/tests/ui/needless_collect.fixed
index be37dc16b9a..7f2fcf02f6b 100644
--- a/tests/ui/needless_collect.fixed
+++ b/tests/ui/needless_collect.fixed
@@ -5,11 +5,11 @@
 use std::collections::{BTreeSet, HashMap, HashSet};
 
 #[warn(clippy::needless_collect)]
-#[allow(unused_variables, clippy::iter_cloned_collect)]
+#[allow(unused_variables, clippy::iter_cloned_collect, clippy::iter_next_slice)]
 fn main() {
     let sample = [1; 5];
     let len = sample.iter().count();
-    if sample.get(0).is_none() {
+    if sample.iter().next().is_none() {
         // Empty
     }
     sample.iter().cloned().any(|x| x == 1);
diff --git a/tests/ui/needless_collect.rs b/tests/ui/needless_collect.rs
index 7ee603afeb0..788a9eb3264 100644
--- a/tests/ui/needless_collect.rs
+++ b/tests/ui/needless_collect.rs
@@ -5,7 +5,7 @@
 use std::collections::{BTreeSet, HashMap, HashSet};
 
 #[warn(clippy::needless_collect)]
-#[allow(unused_variables, clippy::iter_cloned_collect)]
+#[allow(unused_variables, clippy::iter_cloned_collect, clippy::iter_next_slice)]
 fn main() {
     let sample = [1; 5];
     let len = sample.iter().collect::<Vec<_>>().len();
diff --git a/tests/ui/needless_collect.stderr b/tests/ui/needless_collect.stderr
index 9113aad90dd..2a9539d5975 100644
--- a/tests/ui/needless_collect.stderr
+++ b/tests/ui/needless_collect.stderr
@@ -7,10 +7,10 @@ LL |     let len = sample.iter().collect::<Vec<_>>().len();
    = note: `-D clippy::needless-collect` implied by `-D warnings`
 
 error: avoid using `collect()` when not needed
-  --> $DIR/needless_collect.rs:12:15
+  --> $DIR/needless_collect.rs:12:22
    |
 LL |     if sample.iter().collect::<Vec<_>>().is_empty() {
-   |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `get(0).is_none()`
+   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `next().is_none()`
 
 error: avoid using `collect()` when not needed
   --> $DIR/needless_collect.rs:15:28
-- 
cgit 1.4.1-3-g733a5


From fd87cdb357b801b1fab465f0be595386a3f84134 Mon Sep 17 00:00:00 2001
From: flip1995 <hello@philkrones.com>
Date: Sat, 8 Aug 2020 19:20:34 +0200
Subject: Run fmt

---
 clippy_lints/src/functions.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/functions.rs b/clippy_lints/src/functions.rs
index 6a141f1fc78..28b276967bc 100644
--- a/clippy_lints/src/functions.rs
+++ b/clippy_lints/src/functions.rs
@@ -294,7 +294,8 @@ impl<'tcx> LateLintPass<'tcx> for Functions {
                 let body = cx.tcx.hir().body(eid);
                 Self::check_raw_ptr(cx, sig.header.unsafety, &sig.decl, body, item.hir_id);
 
-                if attr.is_none() && cx.access_levels.is_exported(item.hir_id) && !is_proc_macro(cx.sess(), &item.attrs) {
+                if attr.is_none() && cx.access_levels.is_exported(item.hir_id) && !is_proc_macro(cx.sess(), &item.attrs)
+                {
                     check_must_use_candidate(
                         cx,
                         &sig.decl,
-- 
cgit 1.4.1-3-g733a5


From a77e881ec9f324cdc544150f897d8b34281f92e4 Mon Sep 17 00:00:00 2001
From: Tim Nielens <tim.nielens@gmail.com>
Date: Wed, 17 Jun 2020 01:16:34 +0200
Subject: should_impl_trait - ignore methods with lifetime params

---
 clippy_lints/src/methods/mod.rs | 11 ++++++++++-
 tests/ui/methods.rs             |  5 +++++
 tests/ui/methods.stderr         | 26 +++++++++++++-------------
 3 files changed, 28 insertions(+), 14 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 570ae66d595..3009aa3a64e 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1497,11 +1497,20 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
                 if cx.access_levels.is_exported(impl_item.hir_id) {
                 // check missing trait implementations
                     for &(method_name, n_args, fn_header, self_kind, out_type, trait_name) in &TRAIT_METHODS {
+                        let no_lifetime_params = || {
+                            impl_item.generics.params.iter().filter(|p| match p.kind {
+                               hir::GenericParamKind::Lifetime { .. } => true,
+                               _ => false,
+                            }).count() == 0
+                        };
                         if name == method_name &&
                             sig.decl.inputs.len() == n_args &&
                             out_type.matches(cx, &sig.decl.output) &&
                             self_kind.matches(cx, self_ty, first_arg_ty) &&
-                            fn_header_equals(*fn_header, sig.header) {
+                            fn_header_equals(*fn_header, sig.header) &&
+                            // ignore methods with lifetime params, risk of false positive
+                            no_lifetime_params()
+                             {
                             span_lint(cx, SHOULD_IMPLEMENT_TRAIT, impl_item.span, &format!(
                                 "defining a method called `{}` on this type; consider implementing \
                                 the `{}` trait or choosing a less ambiguous name", name, trait_name));
diff --git a/tests/ui/methods.rs b/tests/ui/methods.rs
index 7880cf36415..3b267b0dab2 100644
--- a/tests/ui/methods.rs
+++ b/tests/ui/methods.rs
@@ -10,6 +10,7 @@
     clippy::non_ascii_literal,
     clippy::new_without_default,
     clippy::needless_pass_by_value,
+    clippy::needless_lifetimes,
     clippy::print_stdout,
     clippy::must_use_candidate,
     clippy::use_self,
@@ -82,6 +83,10 @@ impl T {
     fn new(self) -> Self {
         unimplemented!();
     }
+
+    pub fn next<'b>(&'b mut self) -> Option<&'b mut T> {
+        unimplemented!();
+    }
 }
 
 pub struct T1;
diff --git a/tests/ui/methods.stderr b/tests/ui/methods.stderr
index 01cf487ac14..9b8ecaed692 100644
--- a/tests/ui/methods.stderr
+++ b/tests/ui/methods.stderr
@@ -1,5 +1,5 @@
 error: defining a method called `add` on this type; consider implementing the `std::ops::Add` trait or choosing a less ambiguous name
-  --> $DIR/methods.rs:39:5
+  --> $DIR/methods.rs:40:5
    |
 LL | /     pub fn add(self, other: T) -> T {
 LL | |         self
@@ -9,7 +9,7 @@ LL | |     }
    = note: `-D clippy::should-implement-trait` implied by `-D warnings`
 
 error: methods called `new` usually return `Self`
-  --> $DIR/methods.rs:169:5
+  --> $DIR/methods.rs:174:5
    |
 LL | /     fn new() -> i32 {
 LL | |         0
@@ -19,7 +19,7 @@ LL | |     }
    = note: `-D clippy::new-ret-no-self` implied by `-D warnings`
 
 error: called `filter(p).next()` on an `Iterator`. This is more succinctly expressed by calling `.find(p)` instead.
-  --> $DIR/methods.rs:188:13
+  --> $DIR/methods.rs:193:13
    |
 LL |     let _ = v.iter().filter(|&x| *x < 0).next();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -28,7 +28,7 @@ LL |     let _ = v.iter().filter(|&x| *x < 0).next();
    = note: replace `filter(|&x| *x < 0).next()` with `find(|&x| *x < 0)`
 
 error: called `filter(p).next()` on an `Iterator`. This is more succinctly expressed by calling `.find(p)` instead.
-  --> $DIR/methods.rs:191:13
+  --> $DIR/methods.rs:196:13
    |
 LL |       let _ = v.iter().filter(|&x| {
    |  _____________^
@@ -38,7 +38,7 @@ LL | |                    ).next();
    | |___________________________^
 
 error: called `is_some()` after searching an `Iterator` with find. This is more succinctly expressed by calling `any()`.
-  --> $DIR/methods.rs:208:22
+  --> $DIR/methods.rs:213:22
    |
 LL |     let _ = v.iter().find(|&x| *x < 0).is_some();
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `any(|x| *x < 0)`
@@ -46,25 +46,25 @@ LL |     let _ = v.iter().find(|&x| *x < 0).is_some();
    = note: `-D clippy::search-is-some` implied by `-D warnings`
 
 error: called `is_some()` after searching an `Iterator` with find. This is more succinctly expressed by calling `any()`.
-  --> $DIR/methods.rs:209:20
+  --> $DIR/methods.rs:214:20
    |
 LL |     let _ = (0..1).find(|x| **y == *x).is_some(); // one dereference less
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `any(|x| **y == x)`
 
 error: called `is_some()` after searching an `Iterator` with find. This is more succinctly expressed by calling `any()`.
-  --> $DIR/methods.rs:210:20
+  --> $DIR/methods.rs:215:20
    |
 LL |     let _ = (0..1).find(|x| *x == 0).is_some();
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `any(|x| x == 0)`
 
 error: called `is_some()` after searching an `Iterator` with find. This is more succinctly expressed by calling `any()`.
-  --> $DIR/methods.rs:211:22
+  --> $DIR/methods.rs:216:22
    |
 LL |     let _ = v.iter().find(|x| **x == 0).is_some();
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `any(|x| *x == 0)`
 
 error: called `is_some()` after searching an `Iterator` with find. This is more succinctly expressed by calling `any()`.
-  --> $DIR/methods.rs:214:13
+  --> $DIR/methods.rs:219:13
    |
 LL |       let _ = v.iter().find(|&x| {
    |  _____________^
@@ -74,13 +74,13 @@ LL | |                    ).is_some();
    | |______________________________^
 
 error: called `is_some()` after searching an `Iterator` with position. This is more succinctly expressed by calling `any()`.
-  --> $DIR/methods.rs:220:22
+  --> $DIR/methods.rs:225:22
    |
 LL |     let _ = v.iter().position(|&x| x < 0).is_some();
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `any(|&x| x < 0)`
 
 error: called `is_some()` after searching an `Iterator` with position. This is more succinctly expressed by calling `any()`.
-  --> $DIR/methods.rs:223:13
+  --> $DIR/methods.rs:228:13
    |
 LL |       let _ = v.iter().position(|&x| {
    |  _____________^
@@ -90,13 +90,13 @@ LL | |                    ).is_some();
    | |______________________________^
 
 error: called `is_some()` after searching an `Iterator` with rposition. This is more succinctly expressed by calling `any()`.
-  --> $DIR/methods.rs:229:22
+  --> $DIR/methods.rs:234:22
    |
 LL |     let _ = v.iter().rposition(|&x| x < 0).is_some();
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `any(|&x| x < 0)`
 
 error: called `is_some()` after searching an `Iterator` with rposition. This is more succinctly expressed by calling `any()`.
-  --> $DIR/methods.rs:232:13
+  --> $DIR/methods.rs:237:13
    |
 LL |       let _ = v.iter().rposition(|&x| {
    |  _____________^
-- 
cgit 1.4.1-3-g733a5


From 2bc0ecd44b4d09476eade641e02451d949a1c8e2 Mon Sep 17 00:00:00 2001
From: Tim Nielens <tim.nielens@gmail.com>
Date: Fri, 19 Jun 2020 22:12:51 +0200
Subject: should_implement_trait - add test cases for every checked trait
 method

---
 clippy_lints/src/methods/mod.rs |   1 +
 tests/ui/methods.rs             | 146 ++++++++++++++++++++--
 tests/ui/methods.stderr         | 264 +++++++++++++++++++++++++++++++++++++---
 3 files changed, 386 insertions(+), 25 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 3009aa3a64e..c225a3bd359 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3424,6 +3424,7 @@ const TRAIT_METHODS: [(&str, usize, &hir::FnHeader, SelfKind, OutType, &str); 30
     ("borrow_mut", 1, &FN_HEADER, SelfKind::RefMut, OutType::Ref, "std::borrow::BorrowMut"),
     ("clone", 1, &FN_HEADER, SelfKind::Ref, OutType::Any, "std::clone::Clone"),
     ("cmp", 2, &FN_HEADER, SelfKind::Ref, OutType::Any, "std::cmp::Ord"),
+    // FIXME: default doesn't work
     ("default", 0, &FN_HEADER, SelfKind::No, OutType::Any, "std::default::Default"),
     ("deref", 1, &FN_HEADER, SelfKind::Ref, OutType::Ref, "std::ops::Deref"),
     ("deref_mut", 1, &FN_HEADER, SelfKind::RefMut, OutType::Ref, "std::ops::DerefMut"),
diff --git a/tests/ui/methods.rs b/tests/ui/methods.rs
index 3b267b0dab2..adf81607440 100644
--- a/tests/ui/methods.rs
+++ b/tests/ui/methods.rs
@@ -37,9 +37,136 @@ use option_helpers::IteratorFalsePositives;
 pub struct T;
 
 impl T {
+    // *******************************************
+    // complete trait method list, should lint all
+    // *******************************************
     pub fn add(self, other: T) -> T {
-        self
+        unimplemented!()
+    }
+
+    pub fn as_mut(&mut self) -> &mut T {
+        unimplemented!()
+    }
+
+    pub fn as_ref(&self) -> &T {
+        unimplemented!()
+    }
+
+    pub fn bitand(self, rhs: T) -> T {
+        unimplemented!()
+    }
+
+    pub fn bitor(self, rhs: Self) -> Self {
+        unimplemented!()
+    }
+
+    pub fn bitxor(self, rhs: Self) -> Self {
+        unimplemented!()
+    }
+
+    pub fn borrow(&self) -> &str {
+        unimplemented!()
+    }
+
+    pub fn borrow_mut(&mut self) -> &mut str {
+        unimplemented!()
+    }
+
+    pub fn clone(&self) -> Self {
+        unimplemented!()
+    }
+
+    pub fn cmp(&self, other: &Self) -> Self {
+        unimplemented!()
+    }
+
+    pub fn default() -> Self {
+        unimplemented!()
+    }
+
+    pub fn deref(&self) -> &Self {
+        unimplemented!()
+    }
+
+    pub fn deref_mut(&mut self) -> &mut Self {
+        unimplemented!()
+    }
+
+    pub fn div(self, rhs: Self) -> Self {
+        unimplemented!()
+    }
+
+    pub fn drop(&mut self) {
+        unimplemented!()
+    }
+
+    pub fn eq(&self, other: &Self) -> bool {
+        unimplemented!()
+    }
+
+    pub fn from_iter<T>(iter: T) -> Self {
+        unimplemented!()
+    }
+
+    pub fn from_str(s: &str) -> Result<Self, Self> {
+        unimplemented!()
+    }
+
+    pub fn hash(&self, state: &mut T) {
+        unimplemented!()
+    }
+
+    pub fn index(&self, index: usize) -> &Self {
+        unimplemented!()
+    }
+
+    pub fn index_mut(&mut self, index: usize) -> &mut Self {
+        unimplemented!()
+    }
+
+    pub fn into_iter(self) -> Self {
+        unimplemented!()
+    }
+
+    pub fn mul(self, rhs: Self) -> Self {
+        unimplemented!()
+    }
+
+    pub fn neg(self) -> Self {
+        unimplemented!()
+    }
+
+    pub fn next(&mut self) -> Option<Self> {
+        unimplemented!()
+    }
+
+    pub fn not(self) -> Self {
+        unimplemented!()
+    }
+
+    pub fn rem(self, rhs: Self) -> Self {
+        unimplemented!()
+    }
+
+    pub fn shl(self, rhs: Self) -> Self {
+        unimplemented!()
+    }
+
+    pub fn shr(self, rhs: Self) -> Self {
+        unimplemented!()
+    }
+
+    pub fn sub(self, rhs: Self) -> Self {
+        unimplemented!()
     }
+    // *****************
+    // complete list end
+    // *****************
+}
+
+pub struct T1;
+impl T1 {
+    // corner cases: should not lint
 
     // no error, not public interface
     pub(crate) fn drop(&mut self) {}
@@ -50,22 +177,22 @@ impl T {
     }
 
     // no error, private function
-    fn eq(&self, other: T) -> bool {
+    fn eq(&self, other: Self) -> bool {
         true
     }
 
     // No error; self is a ref.
-    fn sub(&self, other: T) -> &T {
+    fn sub(&self, other: Self) -> &Self {
         self
     }
 
     // No error; different number of arguments.
-    fn div(self) -> T {
+    fn div(self) -> Self {
         self
     }
 
     // No error; wrong return type.
-    fn rem(self, other: T) {}
+    fn rem(self, other: Self) {}
 
     // Fine
     fn into_u32(self) -> u32 {
@@ -89,16 +216,15 @@ impl T {
     }
 }
 
-pub struct T1;
-
-impl T1 {
+pub struct T2;
+impl T2 {
     // Shouldn't trigger lint as it is unsafe.
-    pub unsafe fn add(self, rhs: T1) -> T1 {
+    pub unsafe fn add(self, rhs: Self) -> Self {
         self
     }
 
     // Should not trigger lint since this is an async function.
-    pub async fn next(&mut self) -> Option<T1> {
+    pub async fn next(&mut self) -> Option<Self> {
         None
     }
 }
diff --git a/tests/ui/methods.stderr b/tests/ui/methods.stderr
index 9b8ecaed692..5105fff8f5b 100644
--- a/tests/ui/methods.stderr
+++ b/tests/ui/methods.stderr
@@ -1,15 +1,249 @@
 error: defining a method called `add` on this type; consider implementing the `std::ops::Add` trait or choosing a less ambiguous name
-  --> $DIR/methods.rs:40:5
+  --> $DIR/methods.rs:43:5
    |
 LL | /     pub fn add(self, other: T) -> T {
-LL | |         self
+LL | |         unimplemented!()
 LL | |     }
    | |_____^
    |
    = note: `-D clippy::should-implement-trait` implied by `-D warnings`
 
+error: defining a method called `as_mut` on this type; consider implementing the `std::convert::AsMut` trait or choosing a less ambiguous name
+  --> $DIR/methods.rs:47:5
+   |
+LL | /     pub fn as_mut(&mut self) -> &mut T {
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+
+error: defining a method called `as_ref` on this type; consider implementing the `std::convert::AsRef` trait or choosing a less ambiguous name
+  --> $DIR/methods.rs:51:5
+   |
+LL | /     pub fn as_ref(&self) -> &T {
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+
+error: defining a method called `bitand` on this type; consider implementing the `std::ops::BitAnd` trait or choosing a less ambiguous name
+  --> $DIR/methods.rs:55:5
+   |
+LL | /     pub fn bitand(self, rhs: T) -> T {
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+
+error: defining a method called `bitor` on this type; consider implementing the `std::ops::BitOr` trait or choosing a less ambiguous name
+  --> $DIR/methods.rs:59:5
+   |
+LL | /     pub fn bitor(self, rhs: Self) -> Self {
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+
+error: defining a method called `bitxor` on this type; consider implementing the `std::ops::BitXor` trait or choosing a less ambiguous name
+  --> $DIR/methods.rs:63:5
+   |
+LL | /     pub fn bitxor(self, rhs: Self) -> Self {
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+
+error: defining a method called `borrow` on this type; consider implementing the `std::borrow::Borrow` trait or choosing a less ambiguous name
+  --> $DIR/methods.rs:67:5
+   |
+LL | /     pub fn borrow(&self) -> &str {
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+
+error: defining a method called `borrow_mut` on this type; consider implementing the `std::borrow::BorrowMut` trait or choosing a less ambiguous name
+  --> $DIR/methods.rs:71:5
+   |
+LL | /     pub fn borrow_mut(&mut self) -> &mut str {
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+
+error: defining a method called `clone` on this type; consider implementing the `std::clone::Clone` trait or choosing a less ambiguous name
+  --> $DIR/methods.rs:75:5
+   |
+LL | /     pub fn clone(&self) -> Self {
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+
+error: defining a method called `cmp` on this type; consider implementing the `std::cmp::Ord` trait or choosing a less ambiguous name
+  --> $DIR/methods.rs:79:5
+   |
+LL | /     pub fn cmp(&self, other: &Self) -> Self {
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+
+error: defining a method called `deref` on this type; consider implementing the `std::ops::Deref` trait or choosing a less ambiguous name
+  --> $DIR/methods.rs:87:5
+   |
+LL | /     pub fn deref(&self) -> &Self {
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+
+error: defining a method called `deref_mut` on this type; consider implementing the `std::ops::DerefMut` trait or choosing a less ambiguous name
+  --> $DIR/methods.rs:91:5
+   |
+LL | /     pub fn deref_mut(&mut self) -> &mut Self {
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+
+error: defining a method called `div` on this type; consider implementing the `std::ops::Div` trait or choosing a less ambiguous name
+  --> $DIR/methods.rs:95:5
+   |
+LL | /     pub fn div(self, rhs: Self) -> Self {
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+
+error: defining a method called `drop` on this type; consider implementing the `std::ops::Drop` trait or choosing a less ambiguous name
+  --> $DIR/methods.rs:99:5
+   |
+LL | /     pub fn drop(&mut self) {
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+
+error: defining a method called `eq` on this type; consider implementing the `std::cmp::PartialEq` trait or choosing a less ambiguous name
+  --> $DIR/methods.rs:103:5
+   |
+LL | /     pub fn eq(&self, other: &Self) -> bool {
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+
+error: defining a method called `from_iter` on this type; consider implementing the `std::iter::FromIterator` trait or choosing a less ambiguous name
+  --> $DIR/methods.rs:107:5
+   |
+LL | /     pub fn from_iter<T>(iter: T) -> Self {
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+
+error: defining a method called `from_str` on this type; consider implementing the `std::str::FromStr` trait or choosing a less ambiguous name
+  --> $DIR/methods.rs:111:5
+   |
+LL | /     pub fn from_str(s: &str) -> Result<Self, Self> {
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+
+error: docs for function returning `Result` missing `# Errors` section
+  --> $DIR/methods.rs:111:5
+   |
+LL | /     pub fn from_str(s: &str) -> Result<Self, Self> {
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+   = note: `-D clippy::missing-errors-doc` implied by `-D warnings`
+
+error: defining a method called `hash` on this type; consider implementing the `std::hash::Hash` trait or choosing a less ambiguous name
+  --> $DIR/methods.rs:115:5
+   |
+LL | /     pub fn hash(&self, state: &mut T) {
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+
+error: defining a method called `index` on this type; consider implementing the `std::ops::Index` trait or choosing a less ambiguous name
+  --> $DIR/methods.rs:119:5
+   |
+LL | /     pub fn index(&self, index: usize) -> &Self {
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+
+error: defining a method called `index_mut` on this type; consider implementing the `std::ops::IndexMut` trait or choosing a less ambiguous name
+  --> $DIR/methods.rs:123:5
+   |
+LL | /     pub fn index_mut(&mut self, index: usize) -> &mut Self {
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+
+error: defining a method called `into_iter` on this type; consider implementing the `std::iter::IntoIterator` trait or choosing a less ambiguous name
+  --> $DIR/methods.rs:127:5
+   |
+LL | /     pub fn into_iter(self) -> Self {
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+
+error: defining a method called `mul` on this type; consider implementing the `std::ops::Mul` trait or choosing a less ambiguous name
+  --> $DIR/methods.rs:131:5
+   |
+LL | /     pub fn mul(self, rhs: Self) -> Self {
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+
+error: defining a method called `neg` on this type; consider implementing the `std::ops::Neg` trait or choosing a less ambiguous name
+  --> $DIR/methods.rs:135:5
+   |
+LL | /     pub fn neg(self) -> Self {
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+
+error: defining a method called `next` on this type; consider implementing the `std::iter::Iterator` trait or choosing a less ambiguous name
+  --> $DIR/methods.rs:139:5
+   |
+LL | /     pub fn next(&mut self) -> Option<Self> {
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+
+error: defining a method called `not` on this type; consider implementing the `std::ops::Not` trait or choosing a less ambiguous name
+  --> $DIR/methods.rs:143:5
+   |
+LL | /     pub fn not(self) -> Self {
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+
+error: defining a method called `rem` on this type; consider implementing the `std::ops::Rem` trait or choosing a less ambiguous name
+  --> $DIR/methods.rs:147:5
+   |
+LL | /     pub fn rem(self, rhs: Self) -> Self {
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+
+error: defining a method called `shl` on this type; consider implementing the `std::ops::Shl` trait or choosing a less ambiguous name
+  --> $DIR/methods.rs:151:5
+   |
+LL | /     pub fn shl(self, rhs: Self) -> Self {
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+
+error: defining a method called `shr` on this type; consider implementing the `std::ops::Shr` trait or choosing a less ambiguous name
+  --> $DIR/methods.rs:155:5
+   |
+LL | /     pub fn shr(self, rhs: Self) -> Self {
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+
+error: defining a method called `sub` on this type; consider implementing the `std::ops::Sub` trait or choosing a less ambiguous name
+  --> $DIR/methods.rs:159:5
+   |
+LL | /     pub fn sub(self, rhs: Self) -> Self {
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+
 error: methods called `new` usually return `Self`
-  --> $DIR/methods.rs:174:5
+  --> $DIR/methods.rs:300:5
    |
 LL | /     fn new() -> i32 {
 LL | |         0
@@ -19,7 +253,7 @@ LL | |     }
    = note: `-D clippy::new-ret-no-self` implied by `-D warnings`
 
 error: called `filter(p).next()` on an `Iterator`. This is more succinctly expressed by calling `.find(p)` instead.
-  --> $DIR/methods.rs:193:13
+  --> $DIR/methods.rs:319:13
    |
 LL |     let _ = v.iter().filter(|&x| *x < 0).next();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -28,7 +262,7 @@ LL |     let _ = v.iter().filter(|&x| *x < 0).next();
    = note: replace `filter(|&x| *x < 0).next()` with `find(|&x| *x < 0)`
 
 error: called `filter(p).next()` on an `Iterator`. This is more succinctly expressed by calling `.find(p)` instead.
-  --> $DIR/methods.rs:196:13
+  --> $DIR/methods.rs:322:13
    |
 LL |       let _ = v.iter().filter(|&x| {
    |  _____________^
@@ -38,7 +272,7 @@ LL | |                    ).next();
    | |___________________________^
 
 error: called `is_some()` after searching an `Iterator` with find. This is more succinctly expressed by calling `any()`.
-  --> $DIR/methods.rs:213:22
+  --> $DIR/methods.rs:339:22
    |
 LL |     let _ = v.iter().find(|&x| *x < 0).is_some();
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `any(|x| *x < 0)`
@@ -46,25 +280,25 @@ LL |     let _ = v.iter().find(|&x| *x < 0).is_some();
    = note: `-D clippy::search-is-some` implied by `-D warnings`
 
 error: called `is_some()` after searching an `Iterator` with find. This is more succinctly expressed by calling `any()`.
-  --> $DIR/methods.rs:214:20
+  --> $DIR/methods.rs:340:20
    |
 LL |     let _ = (0..1).find(|x| **y == *x).is_some(); // one dereference less
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `any(|x| **y == x)`
 
 error: called `is_some()` after searching an `Iterator` with find. This is more succinctly expressed by calling `any()`.
-  --> $DIR/methods.rs:215:20
+  --> $DIR/methods.rs:341:20
    |
 LL |     let _ = (0..1).find(|x| *x == 0).is_some();
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `any(|x| x == 0)`
 
 error: called `is_some()` after searching an `Iterator` with find. This is more succinctly expressed by calling `any()`.
-  --> $DIR/methods.rs:216:22
+  --> $DIR/methods.rs:342:22
    |
 LL |     let _ = v.iter().find(|x| **x == 0).is_some();
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `any(|x| *x == 0)`
 
 error: called `is_some()` after searching an `Iterator` with find. This is more succinctly expressed by calling `any()`.
-  --> $DIR/methods.rs:219:13
+  --> $DIR/methods.rs:345:13
    |
 LL |       let _ = v.iter().find(|&x| {
    |  _____________^
@@ -74,13 +308,13 @@ LL | |                    ).is_some();
    | |______________________________^
 
 error: called `is_some()` after searching an `Iterator` with position. This is more succinctly expressed by calling `any()`.
-  --> $DIR/methods.rs:225:22
+  --> $DIR/methods.rs:351:22
    |
 LL |     let _ = v.iter().position(|&x| x < 0).is_some();
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `any(|&x| x < 0)`
 
 error: called `is_some()` after searching an `Iterator` with position. This is more succinctly expressed by calling `any()`.
-  --> $DIR/methods.rs:228:13
+  --> $DIR/methods.rs:354:13
    |
 LL |       let _ = v.iter().position(|&x| {
    |  _____________^
@@ -90,13 +324,13 @@ LL | |                    ).is_some();
    | |______________________________^
 
 error: called `is_some()` after searching an `Iterator` with rposition. This is more succinctly expressed by calling `any()`.
-  --> $DIR/methods.rs:234:22
+  --> $DIR/methods.rs:360:22
    |
 LL |     let _ = v.iter().rposition(|&x| x < 0).is_some();
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `any(|&x| x < 0)`
 
 error: called `is_some()` after searching an `Iterator` with rposition. This is more succinctly expressed by calling `any()`.
-  --> $DIR/methods.rs:237:13
+  --> $DIR/methods.rs:363:13
    |
 LL |       let _ = v.iter().rposition(|&x| {
    |  _____________^
@@ -105,5 +339,5 @@ LL | |                                }
 LL | |                    ).is_some();
    | |______________________________^
 
-error: aborting due to 13 previous errors
+error: aborting due to 42 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From e6b2254f9e55743dbace44cc73c6447b6bda58e5 Mon Sep 17 00:00:00 2001
From: Tim Nielens <tim.nielens@gmail.com>
Date: Sun, 21 Jun 2020 00:12:09 +0200
Subject: should_implement_trait - pr remarks

---
 clippy_lints/src/methods/mod.rs | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index c225a3bd359..a75989e3f13 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1498,10 +1498,10 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
                 // check missing trait implementations
                     for &(method_name, n_args, fn_header, self_kind, out_type, trait_name) in &TRAIT_METHODS {
                         let no_lifetime_params = || {
-                            impl_item.generics.params.iter().filter(|p| match p.kind {
-                               hir::GenericParamKind::Lifetime { .. } => true,
-                               _ => false,
-                            }).count() == 0
+                            !impl_item.generics.params.iter()
+                                .any(|p| matches!(
+                                    p.kind,
+                                    hir::GenericParamKind::Lifetime { .. }))
                         };
                         if name == method_name &&
                             sig.decl.inputs.len() == n_args &&
@@ -1510,7 +1510,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
                             fn_header_equals(*fn_header, sig.header) &&
                             // ignore methods with lifetime params, risk of false positive
                             no_lifetime_params()
-                             {
+                        {
                             span_lint(cx, SHOULD_IMPLEMENT_TRAIT, impl_item.span, &format!(
                                 "defining a method called `{}` on this type; consider implementing \
                                 the `{}` trait or choosing a less ambiguous name", name, trait_name));
-- 
cgit 1.4.1-3-g733a5


From 7cc1a2ed879e45605a53b802cfa5291c9a51284c Mon Sep 17 00:00:00 2001
From: Tim Nielens <tim.nielens@gmail.com>
Date: Tue, 23 Jun 2020 21:27:48 +0200
Subject: should_implement_trait - filter on explicit lifetime param only

---
 clippy_lints/src/methods/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index a75989e3f13..bad1bb7224e 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1501,7 +1501,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
                             !impl_item.generics.params.iter()
                                 .any(|p| matches!(
                                     p.kind,
-                                    hir::GenericParamKind::Lifetime { .. }))
+                                    hir::GenericParamKind::Lifetime { kind: hir::LifetimeParamKind::Explicit }))
                         };
                         if name == method_name &&
                             sig.decl.inputs.len() == n_args &&
-- 
cgit 1.4.1-3-g733a5


From 166c520e9a8b1a45819255e75dee737136aa6ec8 Mon Sep 17 00:00:00 2001
From: Tim Nielens <tim.nielens@gmail.com>
Date: Thu, 30 Jul 2020 01:41:12 +0200
Subject: should_impl_trait - pr comments

---
 clippy_lints/src/methods/mod.rs                 | 150 ++++++++-----
 tests/ui/methods.rs                             | 197 +----------------
 tests/ui/methods.stderr                         | 270 ++----------------------
 tests/ui/should_impl_trait/corner_cases.rs      |  83 ++++++++
 tests/ui/should_impl_trait/method_list_1.rs     |  87 ++++++++
 tests/ui/should_impl_trait/method_list_1.stderr | 143 +++++++++++++
 tests/ui/should_impl_trait/method_list_2.rs     |  88 ++++++++
 tests/ui/should_impl_trait/method_list_2.stderr | 153 ++++++++++++++
 8 files changed, 670 insertions(+), 501 deletions(-)
 create mode 100644 tests/ui/should_impl_trait/corner_cases.rs
 create mode 100644 tests/ui/should_impl_trait/method_list_1.rs
 create mode 100644 tests/ui/should_impl_trait/method_list_1.stderr
 create mode 100644 tests/ui/should_impl_trait/method_list_2.rs
 create mode 100644 tests/ui/should_impl_trait/method_list_2.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index bad1bb7224e..a549c3b78ef 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1495,25 +1495,31 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
 
             then {
                 if cx.access_levels.is_exported(impl_item.hir_id) {
-                // check missing trait implementations
-                    for &(method_name, n_args, fn_header, self_kind, out_type, trait_name) in &TRAIT_METHODS {
-                        let no_lifetime_params = || {
-                            !impl_item.generics.params.iter()
-                                .any(|p| matches!(
-                                    p.kind,
-                                    hir::GenericParamKind::Lifetime { kind: hir::LifetimeParamKind::Explicit }))
-                        };
-                        if name == method_name &&
-                            sig.decl.inputs.len() == n_args &&
-                            out_type.matches(cx, &sig.decl.output) &&
-                            self_kind.matches(cx, self_ty, first_arg_ty) &&
-                            fn_header_equals(*fn_header, sig.header) &&
-                            // ignore methods with lifetime params, risk of false positive
-                            no_lifetime_params()
+                    // check missing trait implementations
+                    for method_config in &TRAIT_METHODS {
+                        if name == method_config.method_name &&
+                            sig.decl.inputs.len() == method_config.param_count &&
+                            method_config.output_type.matches(cx, &sig.decl.output) &&
+                            method_config.self_kind.matches(cx, self_ty, first_arg_ty) &&
+                            fn_header_equals(*method_config.fn_header, sig.header) &&
+                            method_config.lifetime_param_cond(&impl_item)
                         {
-                            span_lint(cx, SHOULD_IMPLEMENT_TRAIT, impl_item.span, &format!(
-                                "defining a method called `{}` on this type; consider implementing \
-                                the `{}` trait or choosing a less ambiguous name", name, trait_name));
+                            span_lint_and_help(
+                                cx,
+                                SHOULD_IMPLEMENT_TRAIT,
+                                impl_item.span,
+                                &format!(
+                                    "method `{}` can be confused for the standard trait method `{}::{}`",
+                                    method_config.method_name,
+                                    method_config.trait_name,
+                                    method_config.method_name
+                                ),
+                                None,
+                                &format!(
+                                    "consider implementing the trait `{}` or choosing a less ambiguous method name",
+                                    method_config.trait_name
+                                )
+                            );
                         }
                     }
                 }
@@ -3412,39 +3418,85 @@ const FN_HEADER: hir::FnHeader = hir::FnHeader {
     abi: rustc_target::spec::abi::Abi::Rust,
 };
 
+struct ShouldImplTraitCase {
+    trait_name: &'static str,
+    method_name: &'static str,
+    param_count: usize,
+    fn_header: &'static hir::FnHeader,
+    // implicit self kind expected (none, self, &self, ...)
+    self_kind: SelfKind,
+    // checks against the output type
+    output_type: OutType,
+    // certain methods with explicit lifetimes can't implement the equivalent trait method
+    lint_explicit_lifetime: bool,
+}
+impl ShouldImplTraitCase {
+    const fn new(
+        trait_name: &'static str,
+        method_name: &'static str,
+        param_count: usize,
+        fn_header: &'static hir::FnHeader,
+        self_kind: SelfKind,
+        output_type: OutType,
+        lint_explicit_lifetime: bool,
+    ) -> ShouldImplTraitCase {
+        ShouldImplTraitCase {
+            trait_name,
+            method_name,
+            param_count,
+            fn_header,
+            self_kind,
+            output_type,
+            lint_explicit_lifetime,
+        }
+    }
+
+    fn lifetime_param_cond(&self, impl_item: &hir::ImplItem<'_>) -> bool {
+        self.lint_explicit_lifetime
+            || !impl_item.generics.params.iter().any(|p| {
+                matches!(
+                    p.kind,
+                    hir::GenericParamKind::Lifetime {
+                        kind: hir::LifetimeParamKind::Explicit
+                    }
+                )
+            })
+    }
+}
+
 #[rustfmt::skip]
-const TRAIT_METHODS: [(&str, usize, &hir::FnHeader, SelfKind, OutType, &str); 30] = [
-    ("add", 2, &FN_HEADER, SelfKind::Value, OutType::Any, "std::ops::Add"),
-    ("as_mut", 1, &FN_HEADER, SelfKind::RefMut, OutType::Ref, "std::convert::AsMut"),
-    ("as_ref", 1, &FN_HEADER, SelfKind::Ref, OutType::Ref, "std::convert::AsRef"),
-    ("bitand", 2, &FN_HEADER, SelfKind::Value, OutType::Any, "std::ops::BitAnd"),
-    ("bitor", 2, &FN_HEADER, SelfKind::Value, OutType::Any, "std::ops::BitOr"),
-    ("bitxor", 2, &FN_HEADER, SelfKind::Value, OutType::Any, "std::ops::BitXor"),
-    ("borrow", 1, &FN_HEADER, SelfKind::Ref, OutType::Ref, "std::borrow::Borrow"),
-    ("borrow_mut", 1, &FN_HEADER, SelfKind::RefMut, OutType::Ref, "std::borrow::BorrowMut"),
-    ("clone", 1, &FN_HEADER, SelfKind::Ref, OutType::Any, "std::clone::Clone"),
-    ("cmp", 2, &FN_HEADER, SelfKind::Ref, OutType::Any, "std::cmp::Ord"),
+const TRAIT_METHODS: [ShouldImplTraitCase; 30] = [
+    ShouldImplTraitCase::new("std::ops::Add", "add",  2,  &FN_HEADER,  SelfKind::Value,  OutType::Any, true),
+    ShouldImplTraitCase::new("std::convert::AsMut", "as_mut",  1,  &FN_HEADER,  SelfKind::RefMut,  OutType::Ref, true),
+    ShouldImplTraitCase::new("std::convert::AsRef", "as_ref",  1,  &FN_HEADER,  SelfKind::Ref,  OutType::Ref, true),
+    ShouldImplTraitCase::new("std::ops::BitAnd", "bitand",  2,  &FN_HEADER,  SelfKind::Value,  OutType::Any, true),
+    ShouldImplTraitCase::new("std::ops::BitOr", "bitor",  2,  &FN_HEADER,  SelfKind::Value,  OutType::Any, true),
+    ShouldImplTraitCase::new("std::ops::BitXor", "bitxor",  2,  &FN_HEADER,  SelfKind::Value,  OutType::Any, true),
+    ShouldImplTraitCase::new("std::borrow::Borrow", "borrow",  1,  &FN_HEADER,  SelfKind::Ref,  OutType::Ref, true),
+    ShouldImplTraitCase::new("std::borrow::BorrowMut", "borrow_mut",  1,  &FN_HEADER,  SelfKind::RefMut,  OutType::Ref, true),
+    ShouldImplTraitCase::new("std::clone::Clone", "clone",  1,  &FN_HEADER,  SelfKind::Ref,  OutType::Any, true),
+    ShouldImplTraitCase::new("std::cmp::Ord", "cmp",  2,  &FN_HEADER,  SelfKind::Ref,  OutType::Any, true),
     // FIXME: default doesn't work
-    ("default", 0, &FN_HEADER, SelfKind::No, OutType::Any, "std::default::Default"),
-    ("deref", 1, &FN_HEADER, SelfKind::Ref, OutType::Ref, "std::ops::Deref"),
-    ("deref_mut", 1, &FN_HEADER, SelfKind::RefMut, OutType::Ref, "std::ops::DerefMut"),
-    ("div", 2, &FN_HEADER, SelfKind::Value, OutType::Any, "std::ops::Div"),
-    ("drop", 1, &FN_HEADER, SelfKind::RefMut, OutType::Unit, "std::ops::Drop"),
-    ("eq", 2, &FN_HEADER, SelfKind::Ref, OutType::Bool, "std::cmp::PartialEq"),
-    ("from_iter", 1, &FN_HEADER, SelfKind::No, OutType::Any, "std::iter::FromIterator"),
-    ("from_str", 1, &FN_HEADER, SelfKind::No, OutType::Any, "std::str::FromStr"),
-    ("hash", 2, &FN_HEADER, SelfKind::Ref, OutType::Unit, "std::hash::Hash"),
-    ("index", 2, &FN_HEADER, SelfKind::Ref, OutType::Ref, "std::ops::Index"),
-    ("index_mut", 2, &FN_HEADER, SelfKind::RefMut, OutType::Ref, "std::ops::IndexMut"),
-    ("into_iter", 1, &FN_HEADER, SelfKind::Value, OutType::Any, "std::iter::IntoIterator"),
-    ("mul", 2, &FN_HEADER, SelfKind::Value, OutType::Any, "std::ops::Mul"),
-    ("neg", 1, &FN_HEADER, SelfKind::Value, OutType::Any, "std::ops::Neg"),
-    ("next", 1, &FN_HEADER, SelfKind::RefMut, OutType::Any, "std::iter::Iterator"),
-    ("not", 1, &FN_HEADER, SelfKind::Value, OutType::Any, "std::ops::Not"),
-    ("rem", 2, &FN_HEADER, SelfKind::Value, OutType::Any, "std::ops::Rem"),
-    ("shl", 2, &FN_HEADER, SelfKind::Value, OutType::Any, "std::ops::Shl"),
-    ("shr", 2, &FN_HEADER, SelfKind::Value, OutType::Any, "std::ops::Shr"),
-    ("sub", 2, &FN_HEADER, SelfKind::Value, OutType::Any, "std::ops::Sub"),
+    ShouldImplTraitCase::new("std::default::Default", "default",  0,  &FN_HEADER,  SelfKind::No,  OutType::Any, true),
+    ShouldImplTraitCase::new("std::ops::Deref", "deref",  1,  &FN_HEADER,  SelfKind::Ref,  OutType::Ref, true),
+    ShouldImplTraitCase::new("std::ops::DerefMut", "deref_mut",  1,  &FN_HEADER,  SelfKind::RefMut,  OutType::Ref, true),
+    ShouldImplTraitCase::new("std::ops::Div", "div",  2,  &FN_HEADER,  SelfKind::Value,  OutType::Any, true),
+    ShouldImplTraitCase::new("std::ops::Drop", "drop",  1,  &FN_HEADER,  SelfKind::RefMut,  OutType::Unit, true),
+    ShouldImplTraitCase::new("std::cmp::PartialEq", "eq",  2,  &FN_HEADER,  SelfKind::Ref,  OutType::Bool, true),
+    ShouldImplTraitCase::new("std::iter::FromIterator", "from_iter",  1,  &FN_HEADER,  SelfKind::No,  OutType::Any, true),
+    ShouldImplTraitCase::new("std::str::FromStr", "from_str",  1,  &FN_HEADER,  SelfKind::No,  OutType::Any, true),
+    ShouldImplTraitCase::new("std::hash::Hash", "hash",  2,  &FN_HEADER,  SelfKind::Ref,  OutType::Unit, true),
+    ShouldImplTraitCase::new("std::ops::Index", "index",  2,  &FN_HEADER,  SelfKind::Ref,  OutType::Ref, true),
+    ShouldImplTraitCase::new("std::ops::IndexMut", "index_mut",  2,  &FN_HEADER,  SelfKind::RefMut,  OutType::Ref, true),
+    ShouldImplTraitCase::new("std::iter::IntoIterator", "into_iter",  1,  &FN_HEADER,  SelfKind::Value,  OutType::Any, true),
+    ShouldImplTraitCase::new("std::ops::Mul", "mul",  2,  &FN_HEADER,  SelfKind::Value,  OutType::Any, true),
+    ShouldImplTraitCase::new("std::ops::Neg", "neg",  1,  &FN_HEADER,  SelfKind::Value,  OutType::Any, true),
+    ShouldImplTraitCase::new("std::iter::Iterator", "next",  1,  &FN_HEADER,  SelfKind::RefMut,  OutType::Any, false),
+    ShouldImplTraitCase::new("std::ops::Not", "not",  1,  &FN_HEADER,  SelfKind::Value,  OutType::Any, true),
+    ShouldImplTraitCase::new("std::ops::Rem", "rem",  2,  &FN_HEADER,  SelfKind::Value,  OutType::Any, true),
+    ShouldImplTraitCase::new("std::ops::Shl", "shl",  2,  &FN_HEADER,  SelfKind::Value,  OutType::Any, true),
+    ShouldImplTraitCase::new("std::ops::Shr", "shr",  2,  &FN_HEADER,  SelfKind::Value,  OutType::Any, true),
+    ShouldImplTraitCase::new("std::ops::Sub", "sub",  2,  &FN_HEADER,  SelfKind::Value,  OutType::Any, true),
 ];
 
 #[rustfmt::skip]
diff --git a/tests/ui/methods.rs b/tests/ui/methods.rs
index adf81607440..80dd2f744b3 100644
--- a/tests/ui/methods.rs
+++ b/tests/ui/methods.rs
@@ -34,201 +34,6 @@ use std::sync::{self, Arc};
 
 use option_helpers::IteratorFalsePositives;
 
-pub struct T;
-
-impl T {
-    // *******************************************
-    // complete trait method list, should lint all
-    // *******************************************
-    pub fn add(self, other: T) -> T {
-        unimplemented!()
-    }
-
-    pub fn as_mut(&mut self) -> &mut T {
-        unimplemented!()
-    }
-
-    pub fn as_ref(&self) -> &T {
-        unimplemented!()
-    }
-
-    pub fn bitand(self, rhs: T) -> T {
-        unimplemented!()
-    }
-
-    pub fn bitor(self, rhs: Self) -> Self {
-        unimplemented!()
-    }
-
-    pub fn bitxor(self, rhs: Self) -> Self {
-        unimplemented!()
-    }
-
-    pub fn borrow(&self) -> &str {
-        unimplemented!()
-    }
-
-    pub fn borrow_mut(&mut self) -> &mut str {
-        unimplemented!()
-    }
-
-    pub fn clone(&self) -> Self {
-        unimplemented!()
-    }
-
-    pub fn cmp(&self, other: &Self) -> Self {
-        unimplemented!()
-    }
-
-    pub fn default() -> Self {
-        unimplemented!()
-    }
-
-    pub fn deref(&self) -> &Self {
-        unimplemented!()
-    }
-
-    pub fn deref_mut(&mut self) -> &mut Self {
-        unimplemented!()
-    }
-
-    pub fn div(self, rhs: Self) -> Self {
-        unimplemented!()
-    }
-
-    pub fn drop(&mut self) {
-        unimplemented!()
-    }
-
-    pub fn eq(&self, other: &Self) -> bool {
-        unimplemented!()
-    }
-
-    pub fn from_iter<T>(iter: T) -> Self {
-        unimplemented!()
-    }
-
-    pub fn from_str(s: &str) -> Result<Self, Self> {
-        unimplemented!()
-    }
-
-    pub fn hash(&self, state: &mut T) {
-        unimplemented!()
-    }
-
-    pub fn index(&self, index: usize) -> &Self {
-        unimplemented!()
-    }
-
-    pub fn index_mut(&mut self, index: usize) -> &mut Self {
-        unimplemented!()
-    }
-
-    pub fn into_iter(self) -> Self {
-        unimplemented!()
-    }
-
-    pub fn mul(self, rhs: Self) -> Self {
-        unimplemented!()
-    }
-
-    pub fn neg(self) -> Self {
-        unimplemented!()
-    }
-
-    pub fn next(&mut self) -> Option<Self> {
-        unimplemented!()
-    }
-
-    pub fn not(self) -> Self {
-        unimplemented!()
-    }
-
-    pub fn rem(self, rhs: Self) -> Self {
-        unimplemented!()
-    }
-
-    pub fn shl(self, rhs: Self) -> Self {
-        unimplemented!()
-    }
-
-    pub fn shr(self, rhs: Self) -> Self {
-        unimplemented!()
-    }
-
-    pub fn sub(self, rhs: Self) -> Self {
-        unimplemented!()
-    }
-    // *****************
-    // complete list end
-    // *****************
-}
-
-pub struct T1;
-impl T1 {
-    // corner cases: should not lint
-
-    // no error, not public interface
-    pub(crate) fn drop(&mut self) {}
-
-    // no error, private function
-    fn neg(self) -> Self {
-        self
-    }
-
-    // no error, private function
-    fn eq(&self, other: Self) -> bool {
-        true
-    }
-
-    // No error; self is a ref.
-    fn sub(&self, other: Self) -> &Self {
-        self
-    }
-
-    // No error; different number of arguments.
-    fn div(self) -> Self {
-        self
-    }
-
-    // No error; wrong return type.
-    fn rem(self, other: Self) {}
-
-    // Fine
-    fn into_u32(self) -> u32 {
-        0
-    }
-
-    fn into_u16(&self) -> u16 {
-        0
-    }
-
-    fn to_something(self) -> u32 {
-        0
-    }
-
-    fn new(self) -> Self {
-        unimplemented!();
-    }
-
-    pub fn next<'b>(&'b mut self) -> Option<&'b mut T> {
-        unimplemented!();
-    }
-}
-
-pub struct T2;
-impl T2 {
-    // Shouldn't trigger lint as it is unsafe.
-    pub unsafe fn add(self, rhs: Self) -> Self {
-        self
-    }
-
-    // Should not trigger lint since this is an async function.
-    pub async fn next(&mut self) -> Option<Self> {
-        None
-    }
-}
-
 struct Lt<'a> {
     foo: &'a u32,
 }
@@ -302,6 +107,8 @@ impl BadNew {
     }
 }
 
+struct T;
+
 impl Mul<T> for T {
     type Output = T;
     // No error, obviously.
diff --git a/tests/ui/methods.stderr b/tests/ui/methods.stderr
index 5105fff8f5b..2a0a43e83a6 100644
--- a/tests/ui/methods.stderr
+++ b/tests/ui/methods.stderr
@@ -1,249 +1,5 @@
-error: defining a method called `add` on this type; consider implementing the `std::ops::Add` trait or choosing a less ambiguous name
-  --> $DIR/methods.rs:43:5
-   |
-LL | /     pub fn add(self, other: T) -> T {
-LL | |         unimplemented!()
-LL | |     }
-   | |_____^
-   |
-   = note: `-D clippy::should-implement-trait` implied by `-D warnings`
-
-error: defining a method called `as_mut` on this type; consider implementing the `std::convert::AsMut` trait or choosing a less ambiguous name
-  --> $DIR/methods.rs:47:5
-   |
-LL | /     pub fn as_mut(&mut self) -> &mut T {
-LL | |         unimplemented!()
-LL | |     }
-   | |_____^
-
-error: defining a method called `as_ref` on this type; consider implementing the `std::convert::AsRef` trait or choosing a less ambiguous name
-  --> $DIR/methods.rs:51:5
-   |
-LL | /     pub fn as_ref(&self) -> &T {
-LL | |         unimplemented!()
-LL | |     }
-   | |_____^
-
-error: defining a method called `bitand` on this type; consider implementing the `std::ops::BitAnd` trait or choosing a less ambiguous name
-  --> $DIR/methods.rs:55:5
-   |
-LL | /     pub fn bitand(self, rhs: T) -> T {
-LL | |         unimplemented!()
-LL | |     }
-   | |_____^
-
-error: defining a method called `bitor` on this type; consider implementing the `std::ops::BitOr` trait or choosing a less ambiguous name
-  --> $DIR/methods.rs:59:5
-   |
-LL | /     pub fn bitor(self, rhs: Self) -> Self {
-LL | |         unimplemented!()
-LL | |     }
-   | |_____^
-
-error: defining a method called `bitxor` on this type; consider implementing the `std::ops::BitXor` trait or choosing a less ambiguous name
-  --> $DIR/methods.rs:63:5
-   |
-LL | /     pub fn bitxor(self, rhs: Self) -> Self {
-LL | |         unimplemented!()
-LL | |     }
-   | |_____^
-
-error: defining a method called `borrow` on this type; consider implementing the `std::borrow::Borrow` trait or choosing a less ambiguous name
-  --> $DIR/methods.rs:67:5
-   |
-LL | /     pub fn borrow(&self) -> &str {
-LL | |         unimplemented!()
-LL | |     }
-   | |_____^
-
-error: defining a method called `borrow_mut` on this type; consider implementing the `std::borrow::BorrowMut` trait or choosing a less ambiguous name
-  --> $DIR/methods.rs:71:5
-   |
-LL | /     pub fn borrow_mut(&mut self) -> &mut str {
-LL | |         unimplemented!()
-LL | |     }
-   | |_____^
-
-error: defining a method called `clone` on this type; consider implementing the `std::clone::Clone` trait or choosing a less ambiguous name
-  --> $DIR/methods.rs:75:5
-   |
-LL | /     pub fn clone(&self) -> Self {
-LL | |         unimplemented!()
-LL | |     }
-   | |_____^
-
-error: defining a method called `cmp` on this type; consider implementing the `std::cmp::Ord` trait or choosing a less ambiguous name
-  --> $DIR/methods.rs:79:5
-   |
-LL | /     pub fn cmp(&self, other: &Self) -> Self {
-LL | |         unimplemented!()
-LL | |     }
-   | |_____^
-
-error: defining a method called `deref` on this type; consider implementing the `std::ops::Deref` trait or choosing a less ambiguous name
-  --> $DIR/methods.rs:87:5
-   |
-LL | /     pub fn deref(&self) -> &Self {
-LL | |         unimplemented!()
-LL | |     }
-   | |_____^
-
-error: defining a method called `deref_mut` on this type; consider implementing the `std::ops::DerefMut` trait or choosing a less ambiguous name
-  --> $DIR/methods.rs:91:5
-   |
-LL | /     pub fn deref_mut(&mut self) -> &mut Self {
-LL | |         unimplemented!()
-LL | |     }
-   | |_____^
-
-error: defining a method called `div` on this type; consider implementing the `std::ops::Div` trait or choosing a less ambiguous name
-  --> $DIR/methods.rs:95:5
-   |
-LL | /     pub fn div(self, rhs: Self) -> Self {
-LL | |         unimplemented!()
-LL | |     }
-   | |_____^
-
-error: defining a method called `drop` on this type; consider implementing the `std::ops::Drop` trait or choosing a less ambiguous name
-  --> $DIR/methods.rs:99:5
-   |
-LL | /     pub fn drop(&mut self) {
-LL | |         unimplemented!()
-LL | |     }
-   | |_____^
-
-error: defining a method called `eq` on this type; consider implementing the `std::cmp::PartialEq` trait or choosing a less ambiguous name
-  --> $DIR/methods.rs:103:5
-   |
-LL | /     pub fn eq(&self, other: &Self) -> bool {
-LL | |         unimplemented!()
-LL | |     }
-   | |_____^
-
-error: defining a method called `from_iter` on this type; consider implementing the `std::iter::FromIterator` trait or choosing a less ambiguous name
-  --> $DIR/methods.rs:107:5
-   |
-LL | /     pub fn from_iter<T>(iter: T) -> Self {
-LL | |         unimplemented!()
-LL | |     }
-   | |_____^
-
-error: defining a method called `from_str` on this type; consider implementing the `std::str::FromStr` trait or choosing a less ambiguous name
-  --> $DIR/methods.rs:111:5
-   |
-LL | /     pub fn from_str(s: &str) -> Result<Self, Self> {
-LL | |         unimplemented!()
-LL | |     }
-   | |_____^
-
-error: docs for function returning `Result` missing `# Errors` section
-  --> $DIR/methods.rs:111:5
-   |
-LL | /     pub fn from_str(s: &str) -> Result<Self, Self> {
-LL | |         unimplemented!()
-LL | |     }
-   | |_____^
-   |
-   = note: `-D clippy::missing-errors-doc` implied by `-D warnings`
-
-error: defining a method called `hash` on this type; consider implementing the `std::hash::Hash` trait or choosing a less ambiguous name
-  --> $DIR/methods.rs:115:5
-   |
-LL | /     pub fn hash(&self, state: &mut T) {
-LL | |         unimplemented!()
-LL | |     }
-   | |_____^
-
-error: defining a method called `index` on this type; consider implementing the `std::ops::Index` trait or choosing a less ambiguous name
-  --> $DIR/methods.rs:119:5
-   |
-LL | /     pub fn index(&self, index: usize) -> &Self {
-LL | |         unimplemented!()
-LL | |     }
-   | |_____^
-
-error: defining a method called `index_mut` on this type; consider implementing the `std::ops::IndexMut` trait or choosing a less ambiguous name
-  --> $DIR/methods.rs:123:5
-   |
-LL | /     pub fn index_mut(&mut self, index: usize) -> &mut Self {
-LL | |         unimplemented!()
-LL | |     }
-   | |_____^
-
-error: defining a method called `into_iter` on this type; consider implementing the `std::iter::IntoIterator` trait or choosing a less ambiguous name
-  --> $DIR/methods.rs:127:5
-   |
-LL | /     pub fn into_iter(self) -> Self {
-LL | |         unimplemented!()
-LL | |     }
-   | |_____^
-
-error: defining a method called `mul` on this type; consider implementing the `std::ops::Mul` trait or choosing a less ambiguous name
-  --> $DIR/methods.rs:131:5
-   |
-LL | /     pub fn mul(self, rhs: Self) -> Self {
-LL | |         unimplemented!()
-LL | |     }
-   | |_____^
-
-error: defining a method called `neg` on this type; consider implementing the `std::ops::Neg` trait or choosing a less ambiguous name
-  --> $DIR/methods.rs:135:5
-   |
-LL | /     pub fn neg(self) -> Self {
-LL | |         unimplemented!()
-LL | |     }
-   | |_____^
-
-error: defining a method called `next` on this type; consider implementing the `std::iter::Iterator` trait or choosing a less ambiguous name
-  --> $DIR/methods.rs:139:5
-   |
-LL | /     pub fn next(&mut self) -> Option<Self> {
-LL | |         unimplemented!()
-LL | |     }
-   | |_____^
-
-error: defining a method called `not` on this type; consider implementing the `std::ops::Not` trait or choosing a less ambiguous name
-  --> $DIR/methods.rs:143:5
-   |
-LL | /     pub fn not(self) -> Self {
-LL | |         unimplemented!()
-LL | |     }
-   | |_____^
-
-error: defining a method called `rem` on this type; consider implementing the `std::ops::Rem` trait or choosing a less ambiguous name
-  --> $DIR/methods.rs:147:5
-   |
-LL | /     pub fn rem(self, rhs: Self) -> Self {
-LL | |         unimplemented!()
-LL | |     }
-   | |_____^
-
-error: defining a method called `shl` on this type; consider implementing the `std::ops::Shl` trait or choosing a less ambiguous name
-  --> $DIR/methods.rs:151:5
-   |
-LL | /     pub fn shl(self, rhs: Self) -> Self {
-LL | |         unimplemented!()
-LL | |     }
-   | |_____^
-
-error: defining a method called `shr` on this type; consider implementing the `std::ops::Shr` trait or choosing a less ambiguous name
-  --> $DIR/methods.rs:155:5
-   |
-LL | /     pub fn shr(self, rhs: Self) -> Self {
-LL | |         unimplemented!()
-LL | |     }
-   | |_____^
-
-error: defining a method called `sub` on this type; consider implementing the `std::ops::Sub` trait or choosing a less ambiguous name
-  --> $DIR/methods.rs:159:5
-   |
-LL | /     pub fn sub(self, rhs: Self) -> Self {
-LL | |         unimplemented!()
-LL | |     }
-   | |_____^
-
 error: methods called `new` usually return `Self`
-  --> $DIR/methods.rs:300:5
+  --> $DIR/methods.rs:105:5
    |
 LL | /     fn new() -> i32 {
 LL | |         0
@@ -253,7 +9,7 @@ LL | |     }
    = note: `-D clippy::new-ret-no-self` implied by `-D warnings`
 
 error: called `filter(p).next()` on an `Iterator`. This is more succinctly expressed by calling `.find(p)` instead.
-  --> $DIR/methods.rs:319:13
+  --> $DIR/methods.rs:126:13
    |
 LL |     let _ = v.iter().filter(|&x| *x < 0).next();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -262,7 +18,7 @@ LL |     let _ = v.iter().filter(|&x| *x < 0).next();
    = note: replace `filter(|&x| *x < 0).next()` with `find(|&x| *x < 0)`
 
 error: called `filter(p).next()` on an `Iterator`. This is more succinctly expressed by calling `.find(p)` instead.
-  --> $DIR/methods.rs:322:13
+  --> $DIR/methods.rs:129:13
    |
 LL |       let _ = v.iter().filter(|&x| {
    |  _____________^
@@ -272,7 +28,7 @@ LL | |                    ).next();
    | |___________________________^
 
 error: called `is_some()` after searching an `Iterator` with find. This is more succinctly expressed by calling `any()`.
-  --> $DIR/methods.rs:339:22
+  --> $DIR/methods.rs:146:22
    |
 LL |     let _ = v.iter().find(|&x| *x < 0).is_some();
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `any(|x| *x < 0)`
@@ -280,25 +36,25 @@ LL |     let _ = v.iter().find(|&x| *x < 0).is_some();
    = note: `-D clippy::search-is-some` implied by `-D warnings`
 
 error: called `is_some()` after searching an `Iterator` with find. This is more succinctly expressed by calling `any()`.
-  --> $DIR/methods.rs:340:20
+  --> $DIR/methods.rs:147:20
    |
 LL |     let _ = (0..1).find(|x| **y == *x).is_some(); // one dereference less
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `any(|x| **y == x)`
 
 error: called `is_some()` after searching an `Iterator` with find. This is more succinctly expressed by calling `any()`.
-  --> $DIR/methods.rs:341:20
+  --> $DIR/methods.rs:148:20
    |
 LL |     let _ = (0..1).find(|x| *x == 0).is_some();
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `any(|x| x == 0)`
 
 error: called `is_some()` after searching an `Iterator` with find. This is more succinctly expressed by calling `any()`.
-  --> $DIR/methods.rs:342:22
+  --> $DIR/methods.rs:149:22
    |
 LL |     let _ = v.iter().find(|x| **x == 0).is_some();
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `any(|x| *x == 0)`
 
 error: called `is_some()` after searching an `Iterator` with find. This is more succinctly expressed by calling `any()`.
-  --> $DIR/methods.rs:345:13
+  --> $DIR/methods.rs:152:13
    |
 LL |       let _ = v.iter().find(|&x| {
    |  _____________^
@@ -308,13 +64,13 @@ LL | |                    ).is_some();
    | |______________________________^
 
 error: called `is_some()` after searching an `Iterator` with position. This is more succinctly expressed by calling `any()`.
-  --> $DIR/methods.rs:351:22
+  --> $DIR/methods.rs:158:22
    |
 LL |     let _ = v.iter().position(|&x| x < 0).is_some();
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `any(|&x| x < 0)`
 
 error: called `is_some()` after searching an `Iterator` with position. This is more succinctly expressed by calling `any()`.
-  --> $DIR/methods.rs:354:13
+  --> $DIR/methods.rs:161:13
    |
 LL |       let _ = v.iter().position(|&x| {
    |  _____________^
@@ -324,13 +80,13 @@ LL | |                    ).is_some();
    | |______________________________^
 
 error: called `is_some()` after searching an `Iterator` with rposition. This is more succinctly expressed by calling `any()`.
-  --> $DIR/methods.rs:360:22
+  --> $DIR/methods.rs:167:22
    |
 LL |     let _ = v.iter().rposition(|&x| x < 0).is_some();
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `any(|&x| x < 0)`
 
 error: called `is_some()` after searching an `Iterator` with rposition. This is more succinctly expressed by calling `any()`.
-  --> $DIR/methods.rs:363:13
+  --> $DIR/methods.rs:170:13
    |
 LL |       let _ = v.iter().rposition(|&x| {
    |  _____________^
@@ -339,5 +95,5 @@ LL | |                                }
 LL | |                    ).is_some();
    | |______________________________^
 
-error: aborting due to 42 previous errors
+error: aborting due to 12 previous errors
 
diff --git a/tests/ui/should_impl_trait/corner_cases.rs b/tests/ui/should_impl_trait/corner_cases.rs
new file mode 100644
index 00000000000..6c5ffe6aba8
--- /dev/null
+++ b/tests/ui/should_impl_trait/corner_cases.rs
@@ -0,0 +1,83 @@
+// edition:2018
+
+#![warn(clippy::all, clippy::pedantic)]
+#![allow(
+    clippy::missing_errors_doc,
+    clippy::needless_pass_by_value,
+    clippy::must_use_candidate,
+    clippy::unused_self,
+    clippy::needless_lifetimes,
+    clippy::missing_safety_doc,
+    clippy::wrong_self_convention
+)]
+
+use std::ops::Mul;
+use std::rc::{self, Rc};
+use std::sync::{self, Arc};
+
+fn main() {}
+
+pub struct T1;
+impl T1 {
+    // corner cases: should not lint
+
+    // no error, not public interface
+    pub(crate) fn drop(&mut self) {}
+
+    // no error, private function
+    fn neg(self) -> Self {
+        self
+    }
+
+    // no error, private function
+    fn eq(&self, other: Self) -> bool {
+        true
+    }
+
+    // No error; self is a ref.
+    fn sub(&self, other: Self) -> &Self {
+        self
+    }
+
+    // No error; different number of arguments.
+    fn div(self) -> Self {
+        self
+    }
+
+    // No error; wrong return type.
+    fn rem(self, other: Self) {}
+
+    // Fine
+    fn into_u32(self) -> u32 {
+        0
+    }
+
+    fn into_u16(&self) -> u16 {
+        0
+    }
+
+    fn to_something(self) -> u32 {
+        0
+    }
+
+    fn new(self) -> Self {
+        unimplemented!();
+    }
+
+    pub fn next<'b>(&'b mut self) -> Option<&'b mut T1> {
+        unimplemented!();
+    }
+}
+
+pub struct T2;
+impl T2 {
+    // Shouldn't trigger lint as it is unsafe.
+    pub unsafe fn add(self, rhs: Self) -> Self {
+        self
+    }
+
+    // Should not trigger lint since this is an async function.
+    pub async fn next(&mut self) -> Option<Self> {
+        None
+    }
+}
diff --git a/tests/ui/should_impl_trait/method_list_1.rs b/tests/ui/should_impl_trait/method_list_1.rs
new file mode 100644
index 00000000000..f8d248fc98d
--- /dev/null
+++ b/tests/ui/should_impl_trait/method_list_1.rs
@@ -0,0 +1,87 @@
+// edition:2018
+
+#![warn(clippy::all, clippy::pedantic)]
+#![allow(
+    clippy::missing_errors_doc,
+    clippy::needless_pass_by_value,
+    clippy::must_use_candidate,
+    clippy::unused_self,
+    clippy::needless_lifetimes,
+    clippy::missing_safety_doc,
+    clippy::wrong_self_convention
+)]
+
+use std::ops::Mul;
+use std::rc::{self, Rc};
+use std::sync::{self, Arc};
+
+fn main() {}
+pub struct T;
+
+impl T {
+    // *****************************************
+    // trait method list part 1, should lint all
+    // *****************************************
+    pub fn add(self, other: T) -> T {
+        unimplemented!()
+    }
+
+    pub fn as_mut(&mut self) -> &mut T {
+        unimplemented!()
+    }
+
+    pub fn as_ref(&self) -> &T {
+        unimplemented!()
+    }
+
+    pub fn bitand(self, rhs: T) -> T {
+        unimplemented!()
+    }
+
+    pub fn bitor(self, rhs: Self) -> Self {
+        unimplemented!()
+    }
+
+    pub fn bitxor(self, rhs: Self) -> Self {
+        unimplemented!()
+    }
+
+    pub fn borrow(&self) -> &str {
+        unimplemented!()
+    }
+
+    pub fn borrow_mut(&mut self) -> &mut str {
+        unimplemented!()
+    }
+
+    pub fn clone(&self) -> Self {
+        unimplemented!()
+    }
+
+    pub fn cmp(&self, other: &Self) -> Self {
+        unimplemented!()
+    }
+
+    pub fn default() -> Self {
+        unimplemented!()
+    }
+
+    pub fn deref(&self) -> &Self {
+        unimplemented!()
+    }
+
+    pub fn deref_mut(&mut self) -> &mut Self {
+        unimplemented!()
+    }
+
+    pub fn div(self, rhs: Self) -> Self {
+        unimplemented!()
+    }
+
+    pub fn drop(&mut self) {
+        unimplemented!()
+    }
+    // **********
+    // part 1 end
+    // **********
+}
diff --git a/tests/ui/should_impl_trait/method_list_1.stderr b/tests/ui/should_impl_trait/method_list_1.stderr
new file mode 100644
index 00000000000..2b7d4628c3f
--- /dev/null
+++ b/tests/ui/should_impl_trait/method_list_1.stderr
@@ -0,0 +1,143 @@
+error: method `add` can be confused for the standard trait method `std::ops::Add::add`
+  --> $DIR/method_list_1.rs:25:5
+   |
+LL | /     pub fn add(self, other: T) -> T {
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+   = note: `-D clippy::should-implement-trait` implied by `-D warnings`
+   = help: consider implementing the trait `std::ops::Add` or choosing a less ambiguous method name
+
+error: method `as_mut` can be confused for the standard trait method `std::convert::AsMut::as_mut`
+  --> $DIR/method_list_1.rs:29:5
+   |
+LL | /     pub fn as_mut(&mut self) -> &mut T {
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+   = help: consider implementing the trait `std::convert::AsMut` or choosing a less ambiguous method name
+
+error: method `as_ref` can be confused for the standard trait method `std::convert::AsRef::as_ref`
+  --> $DIR/method_list_1.rs:33:5
+   |
+LL | /     pub fn as_ref(&self) -> &T {
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+   = help: consider implementing the trait `std::convert::AsRef` or choosing a less ambiguous method name
+
+error: method `bitand` can be confused for the standard trait method `std::ops::BitAnd::bitand`
+  --> $DIR/method_list_1.rs:37:5
+   |
+LL | /     pub fn bitand(self, rhs: T) -> T {
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+   = help: consider implementing the trait `std::ops::BitAnd` or choosing a less ambiguous method name
+
+error: method `bitor` can be confused for the standard trait method `std::ops::BitOr::bitor`
+  --> $DIR/method_list_1.rs:41:5
+   |
+LL | /     pub fn bitor(self, rhs: Self) -> Self {
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+   = help: consider implementing the trait `std::ops::BitOr` or choosing a less ambiguous method name
+
+error: method `bitxor` can be confused for the standard trait method `std::ops::BitXor::bitxor`
+  --> $DIR/method_list_1.rs:45:5
+   |
+LL | /     pub fn bitxor(self, rhs: Self) -> Self {
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+   = help: consider implementing the trait `std::ops::BitXor` or choosing a less ambiguous method name
+
+error: method `borrow` can be confused for the standard trait method `std::borrow::Borrow::borrow`
+  --> $DIR/method_list_1.rs:49:5
+   |
+LL | /     pub fn borrow(&self) -> &str {
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+   = help: consider implementing the trait `std::borrow::Borrow` or choosing a less ambiguous method name
+
+error: method `borrow_mut` can be confused for the standard trait method `std::borrow::BorrowMut::borrow_mut`
+  --> $DIR/method_list_1.rs:53:5
+   |
+LL | /     pub fn borrow_mut(&mut self) -> &mut str {
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+   = help: consider implementing the trait `std::borrow::BorrowMut` or choosing a less ambiguous method name
+
+error: method `clone` can be confused for the standard trait method `std::clone::Clone::clone`
+  --> $DIR/method_list_1.rs:57:5
+   |
+LL | /     pub fn clone(&self) -> Self {
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+   = help: consider implementing the trait `std::clone::Clone` or choosing a less ambiguous method name
+
+error: method `cmp` can be confused for the standard trait method `std::cmp::Ord::cmp`
+  --> $DIR/method_list_1.rs:61:5
+   |
+LL | /     pub fn cmp(&self, other: &Self) -> Self {
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+   = help: consider implementing the trait `std::cmp::Ord` or choosing a less ambiguous method name
+
+error: method `deref` can be confused for the standard trait method `std::ops::Deref::deref`
+  --> $DIR/method_list_1.rs:69:5
+   |
+LL | /     pub fn deref(&self) -> &Self {
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+   = help: consider implementing the trait `std::ops::Deref` or choosing a less ambiguous method name
+
+error: method `deref_mut` can be confused for the standard trait method `std::ops::DerefMut::deref_mut`
+  --> $DIR/method_list_1.rs:73:5
+   |
+LL | /     pub fn deref_mut(&mut self) -> &mut Self {
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+   = help: consider implementing the trait `std::ops::DerefMut` or choosing a less ambiguous method name
+
+error: method `div` can be confused for the standard trait method `std::ops::Div::div`
+  --> $DIR/method_list_1.rs:77:5
+   |
+LL | /     pub fn div(self, rhs: Self) -> Self {
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+   = help: consider implementing the trait `std::ops::Div` or choosing a less ambiguous method name
+
+error: method `drop` can be confused for the standard trait method `std::ops::Drop::drop`
+  --> $DIR/method_list_1.rs:81:5
+   |
+LL | /     pub fn drop(&mut self) {
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+   = help: consider implementing the trait `std::ops::Drop` or choosing a less ambiguous method name
+
+error: aborting due to 14 previous errors
+
diff --git a/tests/ui/should_impl_trait/method_list_2.rs b/tests/ui/should_impl_trait/method_list_2.rs
new file mode 100644
index 00000000000..ed5e0d384bf
--- /dev/null
+++ b/tests/ui/should_impl_trait/method_list_2.rs
@@ -0,0 +1,88 @@
+// edition:2018
+
+#![warn(clippy::all, clippy::pedantic)]
+#![allow(
+    clippy::missing_errors_doc,
+    clippy::needless_pass_by_value,
+    clippy::must_use_candidate,
+    clippy::unused_self,
+    clippy::needless_lifetimes,
+    clippy::missing_safety_doc,
+    clippy::wrong_self_convention
+)]
+
+use std::ops::Mul;
+use std::rc::{self, Rc};
+use std::sync::{self, Arc};
+
+fn main() {}
+pub struct T;
+
+impl T {
+    // *****************************************
+    // trait method list part 2, should lint all
+    // *****************************************
+
+    pub fn eq(&self, other: &Self) -> bool {
+        unimplemented!()
+    }
+
+    pub fn from_iter<T>(iter: T) -> Self {
+        unimplemented!()
+    }
+
+    pub fn from_str(s: &str) -> Result<Self, Self> {
+        unimplemented!()
+    }
+
+    pub fn hash(&self, state: &mut T) {
+        unimplemented!()
+    }
+
+    pub fn index(&self, index: usize) -> &Self {
+        unimplemented!()
+    }
+
+    pub fn index_mut(&mut self, index: usize) -> &mut Self {
+        unimplemented!()
+    }
+
+    pub fn into_iter(self) -> Self {
+        unimplemented!()
+    }
+
+    pub fn mul(self, rhs: Self) -> Self {
+        unimplemented!()
+    }
+
+    pub fn neg(self) -> Self {
+        unimplemented!()
+    }
+
+    pub fn next(&mut self) -> Option<Self> {
+        unimplemented!()
+    }
+
+    pub fn not(self) -> Self {
+        unimplemented!()
+    }
+
+    pub fn rem(self, rhs: Self) -> Self {
+        unimplemented!()
+    }
+
+    pub fn shl(self, rhs: Self) -> Self {
+        unimplemented!()
+    }
+
+    pub fn shr(self, rhs: Self) -> Self {
+        unimplemented!()
+    }
+
+    pub fn sub(self, rhs: Self) -> Self {
+        unimplemented!()
+    }
+    // **********
+    // part 2 end
+    // **********
+}
diff --git a/tests/ui/should_impl_trait/method_list_2.stderr b/tests/ui/should_impl_trait/method_list_2.stderr
new file mode 100644
index 00000000000..b6fd4356956
--- /dev/null
+++ b/tests/ui/should_impl_trait/method_list_2.stderr
@@ -0,0 +1,153 @@
+error: method `eq` can be confused for the standard trait method `std::cmp::PartialEq::eq`
+  --> $DIR/method_list_2.rs:26:5
+   |
+LL | /     pub fn eq(&self, other: &Self) -> bool {
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+   = note: `-D clippy::should-implement-trait` implied by `-D warnings`
+   = help: consider implementing the trait `std::cmp::PartialEq` or choosing a less ambiguous method name
+
+error: method `from_iter` can be confused for the standard trait method `std::iter::FromIterator::from_iter`
+  --> $DIR/method_list_2.rs:30:5
+   |
+LL | /     pub fn from_iter<T>(iter: T) -> Self {
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+   = help: consider implementing the trait `std::iter::FromIterator` or choosing a less ambiguous method name
+
+error: method `from_str` can be confused for the standard trait method `std::str::FromStr::from_str`
+  --> $DIR/method_list_2.rs:34:5
+   |
+LL | /     pub fn from_str(s: &str) -> Result<Self, Self> {
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+   = help: consider implementing the trait `std::str::FromStr` or choosing a less ambiguous method name
+
+error: method `hash` can be confused for the standard trait method `std::hash::Hash::hash`
+  --> $DIR/method_list_2.rs:38:5
+   |
+LL | /     pub fn hash(&self, state: &mut T) {
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+   = help: consider implementing the trait `std::hash::Hash` or choosing a less ambiguous method name
+
+error: method `index` can be confused for the standard trait method `std::ops::Index::index`
+  --> $DIR/method_list_2.rs:42:5
+   |
+LL | /     pub fn index(&self, index: usize) -> &Self {
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+   = help: consider implementing the trait `std::ops::Index` or choosing a less ambiguous method name
+
+error: method `index_mut` can be confused for the standard trait method `std::ops::IndexMut::index_mut`
+  --> $DIR/method_list_2.rs:46:5
+   |
+LL | /     pub fn index_mut(&mut self, index: usize) -> &mut Self {
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+   = help: consider implementing the trait `std::ops::IndexMut` or choosing a less ambiguous method name
+
+error: method `into_iter` can be confused for the standard trait method `std::iter::IntoIterator::into_iter`
+  --> $DIR/method_list_2.rs:50:5
+   |
+LL | /     pub fn into_iter(self) -> Self {
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+   = help: consider implementing the trait `std::iter::IntoIterator` or choosing a less ambiguous method name
+
+error: method `mul` can be confused for the standard trait method `std::ops::Mul::mul`
+  --> $DIR/method_list_2.rs:54:5
+   |
+LL | /     pub fn mul(self, rhs: Self) -> Self {
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+   = help: consider implementing the trait `std::ops::Mul` or choosing a less ambiguous method name
+
+error: method `neg` can be confused for the standard trait method `std::ops::Neg::neg`
+  --> $DIR/method_list_2.rs:58:5
+   |
+LL | /     pub fn neg(self) -> Self {
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+   = help: consider implementing the trait `std::ops::Neg` or choosing a less ambiguous method name
+
+error: method `next` can be confused for the standard trait method `std::iter::Iterator::next`
+  --> $DIR/method_list_2.rs:62:5
+   |
+LL | /     pub fn next(&mut self) -> Option<Self> {
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+   = help: consider implementing the trait `std::iter::Iterator` or choosing a less ambiguous method name
+
+error: method `not` can be confused for the standard trait method `std::ops::Not::not`
+  --> $DIR/method_list_2.rs:66:5
+   |
+LL | /     pub fn not(self) -> Self {
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+   = help: consider implementing the trait `std::ops::Not` or choosing a less ambiguous method name
+
+error: method `rem` can be confused for the standard trait method `std::ops::Rem::rem`
+  --> $DIR/method_list_2.rs:70:5
+   |
+LL | /     pub fn rem(self, rhs: Self) -> Self {
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+   = help: consider implementing the trait `std::ops::Rem` or choosing a less ambiguous method name
+
+error: method `shl` can be confused for the standard trait method `std::ops::Shl::shl`
+  --> $DIR/method_list_2.rs:74:5
+   |
+LL | /     pub fn shl(self, rhs: Self) -> Self {
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+   = help: consider implementing the trait `std::ops::Shl` or choosing a less ambiguous method name
+
+error: method `shr` can be confused for the standard trait method `std::ops::Shr::shr`
+  --> $DIR/method_list_2.rs:78:5
+   |
+LL | /     pub fn shr(self, rhs: Self) -> Self {
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+   = help: consider implementing the trait `std::ops::Shr` or choosing a less ambiguous method name
+
+error: method `sub` can be confused for the standard trait method `std::ops::Sub::sub`
+  --> $DIR/method_list_2.rs:82:5
+   |
+LL | /     pub fn sub(self, rhs: Self) -> Self {
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+   = help: consider implementing the trait `std::ops::Sub` or choosing a less ambiguous method name
+
+error: aborting due to 15 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From f9ba829f6701ae03a5c226044dbbde13ce87e123 Mon Sep 17 00:00:00 2001
From: Tim Nielens <tim.nielens@gmail.com>
Date: Sun, 9 Aug 2020 15:35:41 +0200
Subject: should_impl_trait - self linting

---
 clippy_lints/src/methods/mod.rs | 67 +++++++++++++++++++++--------------------
 1 file changed, 34 insertions(+), 33 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index a549c3b78ef..07e55ab0762 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1470,6 +1470,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
         }
     }
 
+    #[allow(clippy::too_many_lines)]
     fn check_impl_item(&mut self, cx: &LateContext<'tcx>, impl_item: &'tcx hir::ImplItem<'_>) {
         if in_external_macro(cx.sess(), impl_item.span) {
             return;
@@ -1501,7 +1502,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
                             sig.decl.inputs.len() == method_config.param_count &&
                             method_config.output_type.matches(cx, &sig.decl.output) &&
                             method_config.self_kind.matches(cx, self_ty, first_arg_ty) &&
-                            fn_header_equals(*method_config.fn_header, sig.header) &&
+                            fn_header_equals(method_config.fn_header, sig.header) &&
                             method_config.lifetime_param_cond(&impl_item)
                         {
                             span_lint_and_help(
@@ -3422,7 +3423,7 @@ struct ShouldImplTraitCase {
     trait_name: &'static str,
     method_name: &'static str,
     param_count: usize,
-    fn_header: &'static hir::FnHeader,
+    fn_header: hir::FnHeader,
     // implicit self kind expected (none, self, &self, ...)
     self_kind: SelfKind,
     // checks against the output type
@@ -3435,7 +3436,7 @@ impl ShouldImplTraitCase {
         trait_name: &'static str,
         method_name: &'static str,
         param_count: usize,
-        fn_header: &'static hir::FnHeader,
+        fn_header: hir::FnHeader,
         self_kind: SelfKind,
         output_type: OutType,
         lint_explicit_lifetime: bool,
@@ -3466,37 +3467,37 @@ impl ShouldImplTraitCase {
 
 #[rustfmt::skip]
 const TRAIT_METHODS: [ShouldImplTraitCase; 30] = [
-    ShouldImplTraitCase::new("std::ops::Add", "add",  2,  &FN_HEADER,  SelfKind::Value,  OutType::Any, true),
-    ShouldImplTraitCase::new("std::convert::AsMut", "as_mut",  1,  &FN_HEADER,  SelfKind::RefMut,  OutType::Ref, true),
-    ShouldImplTraitCase::new("std::convert::AsRef", "as_ref",  1,  &FN_HEADER,  SelfKind::Ref,  OutType::Ref, true),
-    ShouldImplTraitCase::new("std::ops::BitAnd", "bitand",  2,  &FN_HEADER,  SelfKind::Value,  OutType::Any, true),
-    ShouldImplTraitCase::new("std::ops::BitOr", "bitor",  2,  &FN_HEADER,  SelfKind::Value,  OutType::Any, true),
-    ShouldImplTraitCase::new("std::ops::BitXor", "bitxor",  2,  &FN_HEADER,  SelfKind::Value,  OutType::Any, true),
-    ShouldImplTraitCase::new("std::borrow::Borrow", "borrow",  1,  &FN_HEADER,  SelfKind::Ref,  OutType::Ref, true),
-    ShouldImplTraitCase::new("std::borrow::BorrowMut", "borrow_mut",  1,  &FN_HEADER,  SelfKind::RefMut,  OutType::Ref, true),
-    ShouldImplTraitCase::new("std::clone::Clone", "clone",  1,  &FN_HEADER,  SelfKind::Ref,  OutType::Any, true),
-    ShouldImplTraitCase::new("std::cmp::Ord", "cmp",  2,  &FN_HEADER,  SelfKind::Ref,  OutType::Any, true),
+    ShouldImplTraitCase::new("std::ops::Add", "add",  2,  FN_HEADER,  SelfKind::Value,  OutType::Any, true),
+    ShouldImplTraitCase::new("std::convert::AsMut", "as_mut",  1,  FN_HEADER,  SelfKind::RefMut,  OutType::Ref, true),
+    ShouldImplTraitCase::new("std::convert::AsRef", "as_ref",  1,  FN_HEADER,  SelfKind::Ref,  OutType::Ref, true),
+    ShouldImplTraitCase::new("std::ops::BitAnd", "bitand",  2,  FN_HEADER,  SelfKind::Value,  OutType::Any, true),
+    ShouldImplTraitCase::new("std::ops::BitOr", "bitor",  2,  FN_HEADER,  SelfKind::Value,  OutType::Any, true),
+    ShouldImplTraitCase::new("std::ops::BitXor", "bitxor",  2,  FN_HEADER,  SelfKind::Value,  OutType::Any, true),
+    ShouldImplTraitCase::new("std::borrow::Borrow", "borrow",  1,  FN_HEADER,  SelfKind::Ref,  OutType::Ref, true),
+    ShouldImplTraitCase::new("std::borrow::BorrowMut", "borrow_mut",  1,  FN_HEADER,  SelfKind::RefMut,  OutType::Ref, true),
+    ShouldImplTraitCase::new("std::clone::Clone", "clone",  1,  FN_HEADER,  SelfKind::Ref,  OutType::Any, true),
+    ShouldImplTraitCase::new("std::cmp::Ord", "cmp",  2,  FN_HEADER,  SelfKind::Ref,  OutType::Any, true),
     // FIXME: default doesn't work
-    ShouldImplTraitCase::new("std::default::Default", "default",  0,  &FN_HEADER,  SelfKind::No,  OutType::Any, true),
-    ShouldImplTraitCase::new("std::ops::Deref", "deref",  1,  &FN_HEADER,  SelfKind::Ref,  OutType::Ref, true),
-    ShouldImplTraitCase::new("std::ops::DerefMut", "deref_mut",  1,  &FN_HEADER,  SelfKind::RefMut,  OutType::Ref, true),
-    ShouldImplTraitCase::new("std::ops::Div", "div",  2,  &FN_HEADER,  SelfKind::Value,  OutType::Any, true),
-    ShouldImplTraitCase::new("std::ops::Drop", "drop",  1,  &FN_HEADER,  SelfKind::RefMut,  OutType::Unit, true),
-    ShouldImplTraitCase::new("std::cmp::PartialEq", "eq",  2,  &FN_HEADER,  SelfKind::Ref,  OutType::Bool, true),
-    ShouldImplTraitCase::new("std::iter::FromIterator", "from_iter",  1,  &FN_HEADER,  SelfKind::No,  OutType::Any, true),
-    ShouldImplTraitCase::new("std::str::FromStr", "from_str",  1,  &FN_HEADER,  SelfKind::No,  OutType::Any, true),
-    ShouldImplTraitCase::new("std::hash::Hash", "hash",  2,  &FN_HEADER,  SelfKind::Ref,  OutType::Unit, true),
-    ShouldImplTraitCase::new("std::ops::Index", "index",  2,  &FN_HEADER,  SelfKind::Ref,  OutType::Ref, true),
-    ShouldImplTraitCase::new("std::ops::IndexMut", "index_mut",  2,  &FN_HEADER,  SelfKind::RefMut,  OutType::Ref, true),
-    ShouldImplTraitCase::new("std::iter::IntoIterator", "into_iter",  1,  &FN_HEADER,  SelfKind::Value,  OutType::Any, true),
-    ShouldImplTraitCase::new("std::ops::Mul", "mul",  2,  &FN_HEADER,  SelfKind::Value,  OutType::Any, true),
-    ShouldImplTraitCase::new("std::ops::Neg", "neg",  1,  &FN_HEADER,  SelfKind::Value,  OutType::Any, true),
-    ShouldImplTraitCase::new("std::iter::Iterator", "next",  1,  &FN_HEADER,  SelfKind::RefMut,  OutType::Any, false),
-    ShouldImplTraitCase::new("std::ops::Not", "not",  1,  &FN_HEADER,  SelfKind::Value,  OutType::Any, true),
-    ShouldImplTraitCase::new("std::ops::Rem", "rem",  2,  &FN_HEADER,  SelfKind::Value,  OutType::Any, true),
-    ShouldImplTraitCase::new("std::ops::Shl", "shl",  2,  &FN_HEADER,  SelfKind::Value,  OutType::Any, true),
-    ShouldImplTraitCase::new("std::ops::Shr", "shr",  2,  &FN_HEADER,  SelfKind::Value,  OutType::Any, true),
-    ShouldImplTraitCase::new("std::ops::Sub", "sub",  2,  &FN_HEADER,  SelfKind::Value,  OutType::Any, true),
+    ShouldImplTraitCase::new("std::default::Default", "default",  0,  FN_HEADER,  SelfKind::No,  OutType::Any, true),
+    ShouldImplTraitCase::new("std::ops::Deref", "deref",  1,  FN_HEADER,  SelfKind::Ref,  OutType::Ref, true),
+    ShouldImplTraitCase::new("std::ops::DerefMut", "deref_mut",  1,  FN_HEADER,  SelfKind::RefMut,  OutType::Ref, true),
+    ShouldImplTraitCase::new("std::ops::Div", "div",  2,  FN_HEADER,  SelfKind::Value,  OutType::Any, true),
+    ShouldImplTraitCase::new("std::ops::Drop", "drop",  1,  FN_HEADER,  SelfKind::RefMut,  OutType::Unit, true),
+    ShouldImplTraitCase::new("std::cmp::PartialEq", "eq",  2,  FN_HEADER,  SelfKind::Ref,  OutType::Bool, true),
+    ShouldImplTraitCase::new("std::iter::FromIterator", "from_iter",  1,  FN_HEADER,  SelfKind::No,  OutType::Any, true),
+    ShouldImplTraitCase::new("std::str::FromStr", "from_str",  1,  FN_HEADER,  SelfKind::No,  OutType::Any, true),
+    ShouldImplTraitCase::new("std::hash::Hash", "hash",  2,  FN_HEADER,  SelfKind::Ref,  OutType::Unit, true),
+    ShouldImplTraitCase::new("std::ops::Index", "index",  2,  FN_HEADER,  SelfKind::Ref,  OutType::Ref, true),
+    ShouldImplTraitCase::new("std::ops::IndexMut", "index_mut",  2,  FN_HEADER,  SelfKind::RefMut,  OutType::Ref, true),
+    ShouldImplTraitCase::new("std::iter::IntoIterator", "into_iter",  1,  FN_HEADER,  SelfKind::Value,  OutType::Any, true),
+    ShouldImplTraitCase::new("std::ops::Mul", "mul",  2,  FN_HEADER,  SelfKind::Value,  OutType::Any, true),
+    ShouldImplTraitCase::new("std::ops::Neg", "neg",  1,  FN_HEADER,  SelfKind::Value,  OutType::Any, true),
+    ShouldImplTraitCase::new("std::iter::Iterator", "next",  1,  FN_HEADER,  SelfKind::RefMut,  OutType::Any, false),
+    ShouldImplTraitCase::new("std::ops::Not", "not",  1,  FN_HEADER,  SelfKind::Value,  OutType::Any, true),
+    ShouldImplTraitCase::new("std::ops::Rem", "rem",  2,  FN_HEADER,  SelfKind::Value,  OutType::Any, true),
+    ShouldImplTraitCase::new("std::ops::Shl", "shl",  2,  FN_HEADER,  SelfKind::Value,  OutType::Any, true),
+    ShouldImplTraitCase::new("std::ops::Shr", "shr",  2,  FN_HEADER,  SelfKind::Value,  OutType::Any, true),
+    ShouldImplTraitCase::new("std::ops::Sub", "sub",  2,  FN_HEADER,  SelfKind::Value,  OutType::Any, true),
 ];
 
 #[rustfmt::skip]
-- 
cgit 1.4.1-3-g733a5


From 3e3e50bf0fa6282c7265e34589170033c2301edd Mon Sep 17 00:00:00 2001
From: Ryan Wiedemann <Ryan1729@gmail.com>
Date: Mon, 10 Aug 2020 08:50:20 -0600
Subject: Add example of false positive to PTR_ARG docs.

Fixes #214
---
 clippy_lints/src/ptr.rs | 17 +++++++++++++++--
 1 file changed, 15 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs
index 7b6bd69ffca..33c1bbd488a 100644
--- a/clippy_lints/src/ptr.rs
+++ b/clippy_lints/src/ptr.rs
@@ -36,14 +36,27 @@ declare_clippy_lint! {
     /// argument may also fail to compile if you change the argument. Applying
     /// this lint on them will fix the problem, but they may be in other crates.
     ///
+    /// One notable example of a function that may cause issues, and which cannot
+    /// easily be changed due to beinng in the standard library is `Vec::contains`.
+    /// when called on a `Vec<Vec<T>>`. If a `&Vec` is passed to that method then
+    /// it will compile, but if a `&[T]` is passed then it will not compile.
+    ///
+    /// ```ignore
+    /// fn cannot_take_a_slice(v: &Vec<u8>) -> bool {
+    ///     let vec_of_vecs: Vec<Vec<u8>> = some_other_fn();
+    ///
+    ///     vec_of_vecs.contains(v)
+    /// }
+    /// ```
+    ///
     /// Also there may be `fn(&Vec)`-typed references pointing to your function.
     /// If you have them, you will get a compiler error after applying this lint's
     /// suggestions. You then have the choice to undo your changes or change the
     /// type of the reference.
     ///
     /// Note that if the function is part of your public interface, there may be
-    /// other crates referencing it you may not be aware. Carefully deprecate the
-    /// function before applying the lint suggestions in this case.
+    /// other crates referencing it, of which you may not be aware. Carefully 
+    /// deprecate the function before applying the lint suggestions in this case.
     ///
     /// **Example:**
     /// ```ignore
-- 
cgit 1.4.1-3-g733a5


From fbf637d12c95528846bfa65ce67bd652f2affb43 Mon Sep 17 00:00:00 2001
From: Ryan Wiedemann <Ryan1729@gmail.com>
Date: Mon, 10 Aug 2020 09:19:40 -0600
Subject: formatting

---
 clippy_lints/src/ptr.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs
index 33c1bbd488a..7f58a381adc 100644
--- a/clippy_lints/src/ptr.rs
+++ b/clippy_lints/src/ptr.rs
@@ -55,7 +55,7 @@ declare_clippy_lint! {
     /// type of the reference.
     ///
     /// Note that if the function is part of your public interface, there may be
-    /// other crates referencing it, of which you may not be aware. Carefully 
+    /// other crates referencing it, of which you may not be aware. Carefully
     /// deprecate the function before applying the lint suggestions in this case.
     ///
     /// **Example:**
-- 
cgit 1.4.1-3-g733a5


From e57aafe33f338208e612ecb816a948d28f2c3741 Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Thu, 23 Jul 2020 15:06:33 +0200
Subject: too-many-lines: make lint adhere to lint message convention

---
 clippy_lints/src/functions.rs                | 2 +-
 tests/ui-toml/functions_maxlines/test.stderr | 4 ++--
 tests/ui/functions_maxlines.stderr           | 2 +-
 3 files changed, 4 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/functions.rs b/clippy_lints/src/functions.rs
index 28b276967bc..ac1c7aa9bbb 100644
--- a/clippy_lints/src/functions.rs
+++ b/clippy_lints/src/functions.rs
@@ -374,7 +374,7 @@ impl<'tcx> Functions {
         }
 
         if line_count > self.max_lines {
-            span_lint(cx, TOO_MANY_LINES, span, "This function has a large number of lines.")
+            span_lint(cx, TOO_MANY_LINES, span, "this function has a large number of lines")
         }
     }
 
diff --git a/tests/ui-toml/functions_maxlines/test.stderr b/tests/ui-toml/functions_maxlines/test.stderr
index 4b77ac551e7..fb12257021a 100644
--- a/tests/ui-toml/functions_maxlines/test.stderr
+++ b/tests/ui-toml/functions_maxlines/test.stderr
@@ -1,4 +1,4 @@
-error: This function has a large number of lines.
+error: this function has a large number of lines
   --> $DIR/test.rs:18:1
    |
 LL | / fn too_many_lines() {
@@ -9,7 +9,7 @@ LL | | }
    |
    = note: `-D clippy::too-many-lines` implied by `-D warnings`
 
-error: This function has a large number of lines.
+error: this function has a large number of lines
   --> $DIR/test.rs:38:1
    |
 LL | / fn comment_before_code() {
diff --git a/tests/ui/functions_maxlines.stderr b/tests/ui/functions_maxlines.stderr
index 9b0e7550cc3..c640c82d6d7 100644
--- a/tests/ui/functions_maxlines.stderr
+++ b/tests/ui/functions_maxlines.stderr
@@ -1,4 +1,4 @@
-error: This function has a large number of lines.
+error: this function has a large number of lines
   --> $DIR/functions_maxlines.rs:58:1
    |
 LL | / fn bad_lines() {
-- 
cgit 1.4.1-3-g733a5


From 0876f17d77e8747f4cba889bd29fb64a0dc1a63f Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Thu, 23 Jul 2020 15:14:12 +0200
Subject: bool-comparison: make lint adhere to lint message convention

---
 clippy_lints/src/needless_bool.rs | 2 +-
 tests/ui/bool_comparison.stderr   | 8 ++++----
 2 files changed, 5 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/needless_bool.rs b/clippy_lints/src/needless_bool.rs
index 8e44f2ec240..dc5aa669139 100644
--- a/clippy_lints/src/needless_bool.rs
+++ b/clippy_lints/src/needless_bool.rs
@@ -243,7 +243,7 @@ fn check_comparison<'a, 'tcx>(
                         cx,
                         BOOL_COMPARISON,
                         e.span,
-                        "This comparison might be written more concisely",
+                        "this comparison might be written more concisely",
                         "try simplifying it as shown",
                         format!(
                             "{} != {}",
diff --git a/tests/ui/bool_comparison.stderr b/tests/ui/bool_comparison.stderr
index eeb1f20ee89..55d94b8257d 100644
--- a/tests/ui/bool_comparison.stderr
+++ b/tests/ui/bool_comparison.stderr
@@ -84,25 +84,25 @@ error: order comparisons between booleans can be simplified
 LL |     if x > y {
    |        ^^^^^ help: try simplifying it as shown: `x & !y`
 
-error: This comparison might be written more concisely
+error: this comparison might be written more concisely
   --> $DIR/bool_comparison.rs:120:8
    |
 LL |     if a == !b {};
    |        ^^^^^^^ help: try simplifying it as shown: `a != b`
 
-error: This comparison might be written more concisely
+error: this comparison might be written more concisely
   --> $DIR/bool_comparison.rs:121:8
    |
 LL |     if !a == b {};
    |        ^^^^^^^ help: try simplifying it as shown: `a != b`
 
-error: This comparison might be written more concisely
+error: this comparison might be written more concisely
   --> $DIR/bool_comparison.rs:125:8
    |
 LL |     if b == !a {};
    |        ^^^^^^^ help: try simplifying it as shown: `b != a`
 
-error: This comparison might be written more concisely
+error: this comparison might be written more concisely
   --> $DIR/bool_comparison.rs:126:8
    |
 LL |     if !b == a {};
-- 
cgit 1.4.1-3-g733a5


From fd379a889e25c94c0568fe6fc08d0783bcbc3dd7 Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Thu, 23 Jul 2020 15:16:10 +0200
Subject: builtin-type-shadow: make lint adhere to lint message convention

---
 clippy_lints/src/misc_early.rs      | 2 +-
 tests/ui/builtin-type-shadow.stderr | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/misc_early.rs b/clippy_lints/src/misc_early.rs
index 29aba7c1218..38b11c5e733 100644
--- a/clippy_lints/src/misc_early.rs
+++ b/clippy_lints/src/misc_early.rs
@@ -271,7 +271,7 @@ impl EarlyLintPass for MiscEarlyLints {
                         cx,
                         BUILTIN_TYPE_SHADOW,
                         param.ident.span,
-                        &format!("This generic shadows the built-in type `{}`", name),
+                        &format!("this generic shadows the built-in type `{}`", name),
                     );
                 }
             }
diff --git a/tests/ui/builtin-type-shadow.stderr b/tests/ui/builtin-type-shadow.stderr
index bc785b075e0..f42b246afd2 100644
--- a/tests/ui/builtin-type-shadow.stderr
+++ b/tests/ui/builtin-type-shadow.stderr
@@ -1,4 +1,4 @@
-error: This generic shadows the built-in type `u32`
+error: this generic shadows the built-in type `u32`
   --> $DIR/builtin-type-shadow.rs:4:8
    |
 LL | fn foo<u32>(a: u32) -> u32 {
-- 
cgit 1.4.1-3-g733a5


From 40416c0fa8409da63fb27f065e82cabb51ec17d3 Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Thu, 23 Jul 2020 15:18:13 +0200
Subject: naive_bytecount: make lint adhere to lint message convention

---
 clippy_lints/src/bytecount.rs |  4 ++--
 tests/ui/bytecount.stderr     | 12 ++++++------
 2 files changed, 8 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/bytecount.rs b/clippy_lints/src/bytecount.rs
index dde799fcae4..cdb49d777d8 100644
--- a/clippy_lints/src/bytecount.rs
+++ b/clippy_lints/src/bytecount.rs
@@ -82,8 +82,8 @@ impl<'tcx> LateLintPass<'tcx> for ByteCount {
                             cx,
                             NAIVE_BYTECOUNT,
                             expr.span,
-                            "You appear to be counting bytes the naive way",
-                            "Consider using the bytecount crate",
+                            "you appear to be counting bytes the naive way",
+                            "consider using the bytecount crate",
                             format!("bytecount::count({}, {})",
                                     snippet_with_applicability(cx, haystack.span, "..", &mut applicability),
                                     snippet_with_applicability(cx, needle.span, "..", &mut applicability)),
diff --git a/tests/ui/bytecount.stderr b/tests/ui/bytecount.stderr
index 436f5d86a06..1dc37fc8b25 100644
--- a/tests/ui/bytecount.stderr
+++ b/tests/ui/bytecount.stderr
@@ -1,8 +1,8 @@
-error: You appear to be counting bytes the naive way
+error: you appear to be counting bytes the naive way
   --> $DIR/bytecount.rs:5:13
    |
 LL |     let _ = x.iter().filter(|&&a| a == 0).count(); // naive byte count
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Consider using the bytecount crate: `bytecount::count(x, 0)`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using the bytecount crate: `bytecount::count(x, 0)`
    |
 note: the lint level is defined here
   --> $DIR/bytecount.rs:1:8
@@ -10,17 +10,17 @@ note: the lint level is defined here
 LL | #[deny(clippy::naive_bytecount)]
    |        ^^^^^^^^^^^^^^^^^^^^^^^
 
-error: You appear to be counting bytes the naive way
+error: you appear to be counting bytes the naive way
   --> $DIR/bytecount.rs:7:13
    |
 LL |     let _ = (&x[..]).iter().filter(|&a| *a == 0).count(); // naive byte count
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Consider using the bytecount crate: `bytecount::count((&x[..]), 0)`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using the bytecount crate: `bytecount::count((&x[..]), 0)`
 
-error: You appear to be counting bytes the naive way
+error: you appear to be counting bytes the naive way
   --> $DIR/bytecount.rs:19:13
    |
 LL |     let _ = x.iter().filter(|a| b + 1 == **a).count(); // naive byte count
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Consider using the bytecount crate: `bytecount::count(x, b + 1)`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using the bytecount crate: `bytecount::count(x, b + 1)`
 
 error: aborting due to 3 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 5d66bd7bb3fd701d70ec11217e3f89fabe5cb0a7 Mon Sep 17 00:00:00 2001
From: Eduardo Broto <ebroto@tutanota.com>
Date: Mon, 10 Aug 2020 23:38:58 +0200
Subject: Avoid or_fun_call for const_fn with no args

---
 clippy_lints/src/utils/mod.rs | 9 +++++++++
 tests/ui/or_fun_call.fixed    | 8 ++++++++
 tests/ui/or_fun_call.rs       | 8 ++++++++
 3 files changed, 25 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index 9f967d59c8b..223628cc610 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -43,6 +43,7 @@ use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::{LateContext, Level, Lint, LintContext};
 use rustc_middle::hir::map::Map;
 use rustc_middle::ty::{self, layout::IntegerExt, subst::GenericArg, Ty, TyCtxt, TypeFoldable};
+use rustc_mir::const_eval;
 use rustc_span::hygiene::{ExpnKind, MacroKind};
 use rustc_span::source_map::original_sp;
 use rustc_span::symbol::{self, kw, Symbol};
@@ -868,11 +869,19 @@ pub fn is_copy<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
 
 /// Checks if an expression is constructing a tuple-like enum variant or struct
 pub fn is_ctor_or_promotable_const_function(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+    fn has_no_arguments(cx: &LateContext<'_>, def_id: DefId) -> bool {
+        cx.tcx.fn_sig(def_id).skip_binder().inputs().is_empty()
+    }
+
     if let ExprKind::Call(ref fun, _) = expr.kind {
         if let ExprKind::Path(ref qp) = fun.kind {
             let res = cx.qpath_res(qp, fun.hir_id);
             return match res {
                 def::Res::Def(DefKind::Variant | DefKind::Ctor(..), ..) => true,
+                // FIXME: check the constness of the arguments, see https://github.com/rust-lang/rust-clippy/pull/5682#issuecomment-638681210
+                def::Res::Def(DefKind::Fn, def_id) if has_no_arguments(cx, def_id) => {
+                    const_eval::is_const_fn(cx.tcx, def_id)
+                },
                 def::Res::Def(_, def_id) => cx.tcx.is_promotable_const_fn(def_id),
                 _ => false,
             };
diff --git a/tests/ui/or_fun_call.fixed b/tests/ui/or_fun_call.fixed
index 2045ffdb5f0..67faa8bd4a0 100644
--- a/tests/ui/or_fun_call.fixed
+++ b/tests/ui/or_fun_call.fixed
@@ -116,4 +116,12 @@ fn f() -> Option<()> {
     Some(())
 }
 
+// Issue 5886 - const fn (with no arguments)
+pub fn skip_const_fn_with_no_args() {
+    const fn foo() -> Option<i32> {
+        Some(42)
+    }
+    let _ = None.or(foo());
+}
+
 fn main() {}
diff --git a/tests/ui/or_fun_call.rs b/tests/ui/or_fun_call.rs
index 522f31b72d0..9867e2eedcf 100644
--- a/tests/ui/or_fun_call.rs
+++ b/tests/ui/or_fun_call.rs
@@ -116,4 +116,12 @@ fn f() -> Option<()> {
     Some(())
 }
 
+// Issue 5886 - const fn (with no arguments)
+pub fn skip_const_fn_with_no_args() {
+    const fn foo() -> Option<i32> {
+        Some(42)
+    }
+    let _ = None.or(foo());
+}
+
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 9b7ab1d38b13ad8af555793cdf7ce08c12c22595 Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Thu, 23 Jul 2020 16:58:20 +0200
Subject: checked-conversions: make lint adhere to lint message convention

---
 clippy_lints/src/checked_conversions.rs |  2 +-
 tests/ui/checked_conversions.stderr     | 32 ++++++++++++++++----------------
 2 files changed, 17 insertions(+), 17 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/checked_conversions.rs b/clippy_lints/src/checked_conversions.rs
index 841902943f0..28c1a54d2c5 100644
--- a/clippy_lints/src/checked_conversions.rs
+++ b/clippy_lints/src/checked_conversions.rs
@@ -66,7 +66,7 @@ impl<'tcx> LateLintPass<'tcx> for CheckedConversions {
                     cx,
                     CHECKED_CONVERSIONS,
                     item.span,
-                    "Checked cast can be simplified.",
+                    "checked cast can be simplified",
                     "try",
                     format!("{}::try_from({}).is_ok()", to_type, snippet),
                     applicability,
diff --git a/tests/ui/checked_conversions.stderr b/tests/ui/checked_conversions.stderr
index 648ba3ccd01..18518def0ac 100644
--- a/tests/ui/checked_conversions.stderr
+++ b/tests/ui/checked_conversions.stderr
@@ -1,4 +1,4 @@
-error: Checked cast can be simplified.
+error: checked cast can be simplified
   --> $DIR/checked_conversions.rs:17:13
    |
 LL |     let _ = value <= (u32::max_value() as i64) && value >= 0;
@@ -6,91 +6,91 @@ LL |     let _ = value <= (u32::max_value() as i64) && value >= 0;
    |
    = note: `-D clippy::checked-conversions` implied by `-D warnings`
 
-error: Checked cast can be simplified.
+error: checked cast can be simplified
   --> $DIR/checked_conversions.rs:18:13
    |
 LL |     let _ = value <= (u32::MAX as i64) && value >= 0;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u32::try_from(value).is_ok()`
 
-error: Checked cast can be simplified.
+error: checked cast can be simplified
   --> $DIR/checked_conversions.rs:22:13
    |
 LL |     let _ = value <= i64::from(u16::max_value()) && value >= 0;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u16::try_from(value).is_ok()`
 
-error: Checked cast can be simplified.
+error: checked cast can be simplified
   --> $DIR/checked_conversions.rs:23:13
    |
 LL |     let _ = value <= i64::from(u16::MAX) && value >= 0;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u16::try_from(value).is_ok()`
 
-error: Checked cast can be simplified.
+error: checked cast can be simplified
   --> $DIR/checked_conversions.rs:27:13
    |
 LL |     let _ = value <= (u8::max_value() as isize) && value >= 0;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u8::try_from(value).is_ok()`
 
-error: Checked cast can be simplified.
+error: checked cast can be simplified
   --> $DIR/checked_conversions.rs:28:13
    |
 LL |     let _ = value <= (u8::MAX as isize) && value >= 0;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u8::try_from(value).is_ok()`
 
-error: Checked cast can be simplified.
+error: checked cast can be simplified
   --> $DIR/checked_conversions.rs:34:13
    |
 LL |     let _ = value <= (i32::max_value() as i64) && value >= (i32::min_value() as i64);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `i32::try_from(value).is_ok()`
 
-error: Checked cast can be simplified.
+error: checked cast can be simplified
   --> $DIR/checked_conversions.rs:35:13
    |
 LL |     let _ = value <= (i32::MAX as i64) && value >= (i32::MIN as i64);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `i32::try_from(value).is_ok()`
 
-error: Checked cast can be simplified.
+error: checked cast can be simplified
   --> $DIR/checked_conversions.rs:39:13
    |
 LL |     let _ = value <= i64::from(i16::max_value()) && value >= i64::from(i16::min_value());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `i16::try_from(value).is_ok()`
 
-error: Checked cast can be simplified.
+error: checked cast can be simplified
   --> $DIR/checked_conversions.rs:40:13
    |
 LL |     let _ = value <= i64::from(i16::MAX) && value >= i64::from(i16::MIN);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `i16::try_from(value).is_ok()`
 
-error: Checked cast can be simplified.
+error: checked cast can be simplified
   --> $DIR/checked_conversions.rs:46:13
    |
 LL |     let _ = value <= i32::max_value() as u32;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `i32::try_from(value).is_ok()`
 
-error: Checked cast can be simplified.
+error: checked cast can be simplified
   --> $DIR/checked_conversions.rs:47:13
    |
 LL |     let _ = value <= i32::MAX as u32;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `i32::try_from(value).is_ok()`
 
-error: Checked cast can be simplified.
+error: checked cast can be simplified
   --> $DIR/checked_conversions.rs:51:13
    |
 LL |     let _ = value <= isize::max_value() as usize && value as i32 == 5;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `isize::try_from(value).is_ok()`
 
-error: Checked cast can be simplified.
+error: checked cast can be simplified
   --> $DIR/checked_conversions.rs:52:13
    |
 LL |     let _ = value <= isize::MAX as usize && value as i32 == 5;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `isize::try_from(value).is_ok()`
 
-error: Checked cast can be simplified.
+error: checked cast can be simplified
   --> $DIR/checked_conversions.rs:56:13
    |
 LL |     let _ = value <= u16::max_value() as u32 && value as i32 == 5;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u16::try_from(value).is_ok()`
 
-error: Checked cast can be simplified.
+error: checked cast can be simplified
   --> $DIR/checked_conversions.rs:57:13
    |
 LL |     let _ = value <= u16::MAX as u32 && value as i32 == 5;
-- 
cgit 1.4.1-3-g733a5


From 8679dd375b928a3a5d8420401ed80057eea6f198 Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Thu, 23 Jul 2020 17:06:29 +0200
Subject: unnecessary_unwrap, panicking_unwrap: make lints adhere to lint
 message convention

---
 clippy_lints/src/unwrap.rs                         |  6 ++--
 .../ui/checked_unwrap/complex_conditionals.stderr  | 40 +++++++++++-----------
 .../complex_conditionals_nested.stderr             |  4 +--
 tests/ui/checked_unwrap/simple_conditionals.stderr | 26 +++++++-------
 4 files changed, 38 insertions(+), 38 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unwrap.rs b/clippy_lints/src/unwrap.rs
index f2bbde28c2a..fd755dcc790 100644
--- a/clippy_lints/src/unwrap.rs
+++ b/clippy_lints/src/unwrap.rs
@@ -181,8 +181,8 @@ impl<'a, 'tcx> Visitor<'tcx> for UnwrappableVariablesVisitor<'a, 'tcx> {
                             self.cx,
                             UNNECESSARY_UNWRAP,
                             expr.span,
-                            &format!("You checked before that `{}()` cannot fail. \
-                            Instead of checking and unwrapping, it's better to use `if let` or `match`.",
+                            &format!("you checked before that `{}()` cannot fail. \
+                            Instead of checking and unwrapping, it's better to use `if let` or `match`",
                             method_name.ident.name),
                             |diag| { diag.span_label(unwrappable.check.span, "the check is happening here"); },
                         );
@@ -191,7 +191,7 @@ impl<'a, 'tcx> Visitor<'tcx> for UnwrappableVariablesVisitor<'a, 'tcx> {
                             self.cx,
                             PANICKING_UNWRAP,
                             expr.span,
-                            &format!("This call to `{}()` will always panic.",
+                            &format!("this call to `{}()` will always panic",
                             method_name.ident.name),
                             |diag| { diag.span_label(unwrappable.check.span, "because of this check"); },
                         );
diff --git a/tests/ui/checked_unwrap/complex_conditionals.stderr b/tests/ui/checked_unwrap/complex_conditionals.stderr
index dc666bab460..5b62dca629f 100644
--- a/tests/ui/checked_unwrap/complex_conditionals.stderr
+++ b/tests/ui/checked_unwrap/complex_conditionals.stderr
@@ -1,4 +1,4 @@
-error: You checked before that `unwrap()` cannot fail. Instead of checking and unwrapping, it's better to use `if let` or `match`.
+error: you checked before that `unwrap()` cannot fail. Instead of checking and unwrapping, it's better to use `if let` or `match`
   --> $DIR/complex_conditionals.rs:8:9
    |
 LL |     if x.is_ok() && y.is_err() {
@@ -12,7 +12,7 @@ note: the lint level is defined here
 LL | #![deny(clippy::panicking_unwrap, clippy::unnecessary_unwrap)]
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: This call to `unwrap_err()` will always panic.
+error: this call to `unwrap_err()` will always panic
   --> $DIR/complex_conditionals.rs:9:9
    |
 LL |     if x.is_ok() && y.is_err() {
@@ -27,7 +27,7 @@ note: the lint level is defined here
 LL | #![deny(clippy::panicking_unwrap, clippy::unnecessary_unwrap)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: This call to `unwrap()` will always panic.
+error: this call to `unwrap()` will always panic
   --> $DIR/complex_conditionals.rs:10:9
    |
 LL |     if x.is_ok() && y.is_err() {
@@ -36,7 +36,7 @@ LL |     if x.is_ok() && y.is_err() {
 LL |         y.unwrap(); // will panic
    |         ^^^^^^^^^^
 
-error: You checked before that `unwrap_err()` cannot fail. Instead of checking and unwrapping, it's better to use `if let` or `match`.
+error: you checked before that `unwrap_err()` cannot fail. Instead of checking and unwrapping, it's better to use `if let` or `match`
   --> $DIR/complex_conditionals.rs:11:9
    |
 LL |     if x.is_ok() && y.is_err() {
@@ -45,7 +45,7 @@ LL |     if x.is_ok() && y.is_err() {
 LL |         y.unwrap_err(); // unnecessary
    |         ^^^^^^^^^^^^^^
 
-error: This call to `unwrap()` will always panic.
+error: this call to `unwrap()` will always panic
   --> $DIR/complex_conditionals.rs:25:9
    |
 LL |     if x.is_ok() || y.is_ok() {
@@ -54,7 +54,7 @@ LL |     if x.is_ok() || y.is_ok() {
 LL |         x.unwrap(); // will panic
    |         ^^^^^^^^^^
 
-error: You checked before that `unwrap_err()` cannot fail. Instead of checking and unwrapping, it's better to use `if let` or `match`.
+error: you checked before that `unwrap_err()` cannot fail. Instead of checking and unwrapping, it's better to use `if let` or `match`
   --> $DIR/complex_conditionals.rs:26:9
    |
 LL |     if x.is_ok() || y.is_ok() {
@@ -63,7 +63,7 @@ LL |     if x.is_ok() || y.is_ok() {
 LL |         x.unwrap_err(); // unnecessary
    |         ^^^^^^^^^^^^^^
 
-error: This call to `unwrap()` will always panic.
+error: this call to `unwrap()` will always panic
   --> $DIR/complex_conditionals.rs:27:9
    |
 LL |     if x.is_ok() || y.is_ok() {
@@ -72,7 +72,7 @@ LL |     if x.is_ok() || y.is_ok() {
 LL |         y.unwrap(); // will panic
    |         ^^^^^^^^^^
 
-error: You checked before that `unwrap_err()` cannot fail. Instead of checking and unwrapping, it's better to use `if let` or `match`.
+error: you checked before that `unwrap_err()` cannot fail. Instead of checking and unwrapping, it's better to use `if let` or `match`
   --> $DIR/complex_conditionals.rs:28:9
    |
 LL |     if x.is_ok() || y.is_ok() {
@@ -81,7 +81,7 @@ LL |     if x.is_ok() || y.is_ok() {
 LL |         y.unwrap_err(); // unnecessary
    |         ^^^^^^^^^^^^^^
 
-error: You checked before that `unwrap()` cannot fail. Instead of checking and unwrapping, it's better to use `if let` or `match`.
+error: you checked before that `unwrap()` cannot fail. Instead of checking and unwrapping, it's better to use `if let` or `match`
   --> $DIR/complex_conditionals.rs:32:9
    |
 LL |     if x.is_ok() && !(y.is_ok() || z.is_err()) {
@@ -89,7 +89,7 @@ LL |     if x.is_ok() && !(y.is_ok() || z.is_err()) {
 LL |         x.unwrap(); // unnecessary
    |         ^^^^^^^^^^
 
-error: This call to `unwrap_err()` will always panic.
+error: this call to `unwrap_err()` will always panic
   --> $DIR/complex_conditionals.rs:33:9
    |
 LL |     if x.is_ok() && !(y.is_ok() || z.is_err()) {
@@ -98,7 +98,7 @@ LL |         x.unwrap(); // unnecessary
 LL |         x.unwrap_err(); // will panic
    |         ^^^^^^^^^^^^^^
 
-error: This call to `unwrap()` will always panic.
+error: this call to `unwrap()` will always panic
   --> $DIR/complex_conditionals.rs:34:9
    |
 LL |     if x.is_ok() && !(y.is_ok() || z.is_err()) {
@@ -107,7 +107,7 @@ LL |     if x.is_ok() && !(y.is_ok() || z.is_err()) {
 LL |         y.unwrap(); // will panic
    |         ^^^^^^^^^^
 
-error: You checked before that `unwrap_err()` cannot fail. Instead of checking and unwrapping, it's better to use `if let` or `match`.
+error: you checked before that `unwrap_err()` cannot fail. Instead of checking and unwrapping, it's better to use `if let` or `match`
   --> $DIR/complex_conditionals.rs:35:9
    |
 LL |     if x.is_ok() && !(y.is_ok() || z.is_err()) {
@@ -116,7 +116,7 @@ LL |     if x.is_ok() && !(y.is_ok() || z.is_err()) {
 LL |         y.unwrap_err(); // unnecessary
    |         ^^^^^^^^^^^^^^
 
-error: You checked before that `unwrap()` cannot fail. Instead of checking and unwrapping, it's better to use `if let` or `match`.
+error: you checked before that `unwrap()` cannot fail. Instead of checking and unwrapping, it's better to use `if let` or `match`
   --> $DIR/complex_conditionals.rs:36:9
    |
 LL |     if x.is_ok() && !(y.is_ok() || z.is_err()) {
@@ -125,7 +125,7 @@ LL |     if x.is_ok() && !(y.is_ok() || z.is_err()) {
 LL |         z.unwrap(); // unnecessary
    |         ^^^^^^^^^^
 
-error: This call to `unwrap_err()` will always panic.
+error: this call to `unwrap_err()` will always panic
   --> $DIR/complex_conditionals.rs:37:9
    |
 LL |     if x.is_ok() && !(y.is_ok() || z.is_err()) {
@@ -134,7 +134,7 @@ LL |     if x.is_ok() && !(y.is_ok() || z.is_err()) {
 LL |         z.unwrap_err(); // will panic
    |         ^^^^^^^^^^^^^^
 
-error: This call to `unwrap()` will always panic.
+error: this call to `unwrap()` will always panic
   --> $DIR/complex_conditionals.rs:45:9
    |
 LL |     if x.is_ok() || !(y.is_ok() && z.is_err()) {
@@ -143,7 +143,7 @@ LL |     if x.is_ok() || !(y.is_ok() && z.is_err()) {
 LL |         x.unwrap(); // will panic
    |         ^^^^^^^^^^
 
-error: You checked before that `unwrap_err()` cannot fail. Instead of checking and unwrapping, it's better to use `if let` or `match`.
+error: you checked before that `unwrap_err()` cannot fail. Instead of checking and unwrapping, it's better to use `if let` or `match`
   --> $DIR/complex_conditionals.rs:46:9
    |
 LL |     if x.is_ok() || !(y.is_ok() && z.is_err()) {
@@ -152,7 +152,7 @@ LL |     if x.is_ok() || !(y.is_ok() && z.is_err()) {
 LL |         x.unwrap_err(); // unnecessary
    |         ^^^^^^^^^^^^^^
 
-error: You checked before that `unwrap()` cannot fail. Instead of checking and unwrapping, it's better to use `if let` or `match`.
+error: you checked before that `unwrap()` cannot fail. Instead of checking and unwrapping, it's better to use `if let` or `match`
   --> $DIR/complex_conditionals.rs:47:9
    |
 LL |     if x.is_ok() || !(y.is_ok() && z.is_err()) {
@@ -161,7 +161,7 @@ LL |     if x.is_ok() || !(y.is_ok() && z.is_err()) {
 LL |         y.unwrap(); // unnecessary
    |         ^^^^^^^^^^
 
-error: This call to `unwrap_err()` will always panic.
+error: this call to `unwrap_err()` will always panic
   --> $DIR/complex_conditionals.rs:48:9
    |
 LL |     if x.is_ok() || !(y.is_ok() && z.is_err()) {
@@ -170,7 +170,7 @@ LL |     if x.is_ok() || !(y.is_ok() && z.is_err()) {
 LL |         y.unwrap_err(); // will panic
    |         ^^^^^^^^^^^^^^
 
-error: This call to `unwrap()` will always panic.
+error: this call to `unwrap()` will always panic
   --> $DIR/complex_conditionals.rs:49:9
    |
 LL |     if x.is_ok() || !(y.is_ok() && z.is_err()) {
@@ -179,7 +179,7 @@ LL |     if x.is_ok() || !(y.is_ok() && z.is_err()) {
 LL |         z.unwrap(); // will panic
    |         ^^^^^^^^^^
 
-error: You checked before that `unwrap_err()` cannot fail. Instead of checking and unwrapping, it's better to use `if let` or `match`.
+error: you checked before that `unwrap_err()` cannot fail. Instead of checking and unwrapping, it's better to use `if let` or `match`
   --> $DIR/complex_conditionals.rs:50:9
    |
 LL |     if x.is_ok() || !(y.is_ok() && z.is_err()) {
diff --git a/tests/ui/checked_unwrap/complex_conditionals_nested.stderr b/tests/ui/checked_unwrap/complex_conditionals_nested.stderr
index e4d085470c3..46ffc16c23e 100644
--- a/tests/ui/checked_unwrap/complex_conditionals_nested.stderr
+++ b/tests/ui/checked_unwrap/complex_conditionals_nested.stderr
@@ -1,4 +1,4 @@
-error: You checked before that `unwrap()` cannot fail. Instead of checking and unwrapping, it's better to use `if let` or `match`.
+error: you checked before that `unwrap()` cannot fail. Instead of checking and unwrapping, it's better to use `if let` or `match`
   --> $DIR/complex_conditionals_nested.rs:8:13
    |
 LL |         if x.is_some() {
@@ -12,7 +12,7 @@ note: the lint level is defined here
 LL | #![deny(clippy::panicking_unwrap, clippy::unnecessary_unwrap)]
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: This call to `unwrap()` will always panic.
+error: this call to `unwrap()` will always panic
   --> $DIR/complex_conditionals_nested.rs:10:13
    |
 LL |         if x.is_some() {
diff --git a/tests/ui/checked_unwrap/simple_conditionals.stderr b/tests/ui/checked_unwrap/simple_conditionals.stderr
index 4013d1ed667..bf4b6c93098 100644
--- a/tests/ui/checked_unwrap/simple_conditionals.stderr
+++ b/tests/ui/checked_unwrap/simple_conditionals.stderr
@@ -1,4 +1,4 @@
-error: You checked before that `unwrap()` cannot fail. Instead of checking and unwrapping, it's better to use `if let` or `match`.
+error: you checked before that `unwrap()` cannot fail. Instead of checking and unwrapping, it's better to use `if let` or `match`
   --> $DIR/simple_conditionals.rs:39:9
    |
 LL |     if x.is_some() {
@@ -12,7 +12,7 @@ note: the lint level is defined here
 LL | #![deny(clippy::panicking_unwrap, clippy::unnecessary_unwrap)]
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: This call to `unwrap()` will always panic.
+error: this call to `unwrap()` will always panic
   --> $DIR/simple_conditionals.rs:41:9
    |
 LL |     if x.is_some() {
@@ -27,7 +27,7 @@ note: the lint level is defined here
 LL | #![deny(clippy::panicking_unwrap, clippy::unnecessary_unwrap)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: This call to `unwrap()` will always panic.
+error: this call to `unwrap()` will always panic
   --> $DIR/simple_conditionals.rs:44:9
    |
 LL |     if x.is_none() {
@@ -35,7 +35,7 @@ LL |     if x.is_none() {
 LL |         x.unwrap(); // will panic
    |         ^^^^^^^^^^
 
-error: You checked before that `unwrap()` cannot fail. Instead of checking and unwrapping, it's better to use `if let` or `match`.
+error: you checked before that `unwrap()` cannot fail. Instead of checking and unwrapping, it's better to use `if let` or `match`
   --> $DIR/simple_conditionals.rs:46:9
    |
 LL |     if x.is_none() {
@@ -44,7 +44,7 @@ LL |     if x.is_none() {
 LL |         x.unwrap(); // unnecessary
    |         ^^^^^^^^^^
 
-error: You checked before that `unwrap()` cannot fail. Instead of checking and unwrapping, it's better to use `if let` or `match`.
+error: you checked before that `unwrap()` cannot fail. Instead of checking and unwrapping, it's better to use `if let` or `match`
   --> $DIR/simple_conditionals.rs:7:13
    |
 LL |         if $a.is_some() {
@@ -57,7 +57,7 @@ LL |     m!(x);
    |
    = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: You checked before that `unwrap()` cannot fail. Instead of checking and unwrapping, it's better to use `if let` or `match`.
+error: you checked before that `unwrap()` cannot fail. Instead of checking and unwrapping, it's better to use `if let` or `match`
   --> $DIR/simple_conditionals.rs:54:9
    |
 LL |     if x.is_ok() {
@@ -65,7 +65,7 @@ LL |     if x.is_ok() {
 LL |         x.unwrap(); // unnecessary
    |         ^^^^^^^^^^
 
-error: This call to `unwrap_err()` will always panic.
+error: this call to `unwrap_err()` will always panic
   --> $DIR/simple_conditionals.rs:55:9
    |
 LL |     if x.is_ok() {
@@ -74,7 +74,7 @@ LL |         x.unwrap(); // unnecessary
 LL |         x.unwrap_err(); // will panic
    |         ^^^^^^^^^^^^^^
 
-error: This call to `unwrap()` will always panic.
+error: this call to `unwrap()` will always panic
   --> $DIR/simple_conditionals.rs:57:9
    |
 LL |     if x.is_ok() {
@@ -83,7 +83,7 @@ LL |     if x.is_ok() {
 LL |         x.unwrap(); // will panic
    |         ^^^^^^^^^^
 
-error: You checked before that `unwrap_err()` cannot fail. Instead of checking and unwrapping, it's better to use `if let` or `match`.
+error: you checked before that `unwrap_err()` cannot fail. Instead of checking and unwrapping, it's better to use `if let` or `match`
   --> $DIR/simple_conditionals.rs:58:9
    |
 LL |     if x.is_ok() {
@@ -92,7 +92,7 @@ LL |     if x.is_ok() {
 LL |         x.unwrap_err(); // unnecessary
    |         ^^^^^^^^^^^^^^
 
-error: This call to `unwrap()` will always panic.
+error: this call to `unwrap()` will always panic
   --> $DIR/simple_conditionals.rs:61:9
    |
 LL |     if x.is_err() {
@@ -100,7 +100,7 @@ LL |     if x.is_err() {
 LL |         x.unwrap(); // will panic
    |         ^^^^^^^^^^
 
-error: You checked before that `unwrap_err()` cannot fail. Instead of checking and unwrapping, it's better to use `if let` or `match`.
+error: you checked before that `unwrap_err()` cannot fail. Instead of checking and unwrapping, it's better to use `if let` or `match`
   --> $DIR/simple_conditionals.rs:62:9
    |
 LL |     if x.is_err() {
@@ -109,7 +109,7 @@ LL |         x.unwrap(); // will panic
 LL |         x.unwrap_err(); // unnecessary
    |         ^^^^^^^^^^^^^^
 
-error: You checked before that `unwrap()` cannot fail. Instead of checking and unwrapping, it's better to use `if let` or `match`.
+error: you checked before that `unwrap()` cannot fail. Instead of checking and unwrapping, it's better to use `if let` or `match`
   --> $DIR/simple_conditionals.rs:64:9
    |
 LL |     if x.is_err() {
@@ -118,7 +118,7 @@ LL |     if x.is_err() {
 LL |         x.unwrap(); // unnecessary
    |         ^^^^^^^^^^
 
-error: This call to `unwrap_err()` will always panic.
+error: this call to `unwrap_err()` will always panic
   --> $DIR/simple_conditionals.rs:65:9
    |
 LL |     if x.is_err() {
-- 
cgit 1.4.1-3-g733a5


From 3d592b515492c8d054583078163c1986c44e222a Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Thu, 23 Jul 2020 19:21:31 +0200
Subject: cmp_null: make lint adhere to lint message convention

---
 clippy_lints/src/ptr.rs  | 2 +-
 tests/ui/cmp_null.stderr | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs
index 7b6bd69ffca..460d631fab0 100644
--- a/clippy_lints/src/ptr.rs
+++ b/clippy_lints/src/ptr.rs
@@ -145,7 +145,7 @@ impl<'tcx> LateLintPass<'tcx> for Ptr {
                     cx,
                     CMP_NULL,
                     expr.span,
-                    "Comparing with null is better expressed by the `.is_null()` method",
+                    "comparing with null is better expressed by the `.is_null()` method",
                 );
             }
         }
diff --git a/tests/ui/cmp_null.stderr b/tests/ui/cmp_null.stderr
index b563a2ebec2..a1f4c70fb27 100644
--- a/tests/ui/cmp_null.stderr
+++ b/tests/ui/cmp_null.stderr
@@ -1,4 +1,4 @@
-error: Comparing with null is better expressed by the `.is_null()` method
+error: comparing with null is better expressed by the `.is_null()` method
   --> $DIR/cmp_null.rs:9:8
    |
 LL |     if p == ptr::null() {
@@ -6,7 +6,7 @@ LL |     if p == ptr::null() {
    |
    = note: `-D clippy::cmp-null` implied by `-D warnings`
 
-error: Comparing with null is better expressed by the `.is_null()` method
+error: comparing with null is better expressed by the `.is_null()` method
   --> $DIR/cmp_null.rs:14:8
    |
 LL |     if m == ptr::null_mut() {
-- 
cgit 1.4.1-3-g733a5


From 6b0a6a70f8dfa743707c440fdf908b9aceb1b8ae Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Thu, 23 Jul 2020 19:39:35 +0200
Subject: default-trait-access: make lint adhere to lint message convention

---
 clippy_lints/src/default_trait_access.rs |  2 +-
 tests/ui/default_trait_access.stderr     | 16 ++++++++--------
 2 files changed, 9 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/default_trait_access.rs b/clippy_lints/src/default_trait_access.rs
index ea244768129..874e19d9e9f 100644
--- a/clippy_lints/src/default_trait_access.rs
+++ b/clippy_lints/src/default_trait_access.rs
@@ -61,7 +61,7 @@ impl<'tcx> LateLintPass<'tcx> for DefaultTraitAccess {
                                 cx,
                                 DEFAULT_TRAIT_ACCESS,
                                 expr.span,
-                                &format!("Calling `{}` is more clear than this expression", replacement),
+                                &format!("calling `{}` is more clear than this expression", replacement),
                                 "try",
                                 replacement,
                                 Applicability::Unspecified, // First resolve the TODO above
diff --git a/tests/ui/default_trait_access.stderr b/tests/ui/default_trait_access.stderr
index 453760c6b92..26b2057548b 100644
--- a/tests/ui/default_trait_access.stderr
+++ b/tests/ui/default_trait_access.stderr
@@ -1,4 +1,4 @@
-error: Calling `std::string::String::default()` is more clear than this expression
+error: calling `std::string::String::default()` is more clear than this expression
   --> $DIR/default_trait_access.rs:8:22
    |
 LL |     let s1: String = Default::default();
@@ -6,43 +6,43 @@ LL |     let s1: String = Default::default();
    |
    = note: `-D clippy::default-trait-access` implied by `-D warnings`
 
-error: Calling `std::string::String::default()` is more clear than this expression
+error: calling `std::string::String::default()` is more clear than this expression
   --> $DIR/default_trait_access.rs:12:22
    |
 LL |     let s3: String = D2::default();
    |                      ^^^^^^^^^^^^^ help: try: `std::string::String::default()`
 
-error: Calling `std::string::String::default()` is more clear than this expression
+error: calling `std::string::String::default()` is more clear than this expression
   --> $DIR/default_trait_access.rs:14:22
    |
 LL |     let s4: String = std::default::Default::default();
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::string::String::default()`
 
-error: Calling `std::string::String::default()` is more clear than this expression
+error: calling `std::string::String::default()` is more clear than this expression
   --> $DIR/default_trait_access.rs:18:22
    |
 LL |     let s6: String = default::Default::default();
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::string::String::default()`
 
-error: Calling `GenericDerivedDefault<std::string::String>::default()` is more clear than this expression
+error: calling `GenericDerivedDefault<std::string::String>::default()` is more clear than this expression
   --> $DIR/default_trait_access.rs:28:46
    |
 LL |     let s11: GenericDerivedDefault<String> = Default::default();
    |                                              ^^^^^^^^^^^^^^^^^^ help: try: `GenericDerivedDefault<std::string::String>::default()`
 
-error: Calling `TupleDerivedDefault::default()` is more clear than this expression
+error: calling `TupleDerivedDefault::default()` is more clear than this expression
   --> $DIR/default_trait_access.rs:34:36
    |
 LL |     let s14: TupleDerivedDefault = Default::default();
    |                                    ^^^^^^^^^^^^^^^^^^ help: try: `TupleDerivedDefault::default()`
 
-error: Calling `ArrayDerivedDefault::default()` is more clear than this expression
+error: calling `ArrayDerivedDefault::default()` is more clear than this expression
   --> $DIR/default_trait_access.rs:36:36
    |
 LL |     let s15: ArrayDerivedDefault = Default::default();
    |                                    ^^^^^^^^^^^^^^^^^^ help: try: `ArrayDerivedDefault::default()`
 
-error: Calling `TupleStructDerivedDefault::default()` is more clear than this expression
+error: calling `TupleStructDerivedDefault::default()` is more clear than this expression
   --> $DIR/default_trait_access.rs:40:42
    |
 LL |     let s17: TupleStructDerivedDefault = Default::default();
-- 
cgit 1.4.1-3-g733a5


From ba7a01a6a8709eaff32f88d47382c940b24a3c9e Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Thu, 23 Jul 2020 19:50:28 +0200
Subject: double-comparisons: make lint adhere to lint message convention

---
 clippy_lints/src/double_comparison.rs |  2 +-
 tests/ui/double_comparison.stderr     | 16 ++++++++--------
 2 files changed, 9 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/double_comparison.rs b/clippy_lints/src/double_comparison.rs
index 5d16192b754..bae7c4647d4 100644
--- a/clippy_lints/src/double_comparison.rs
+++ b/clippy_lints/src/double_comparison.rs
@@ -60,7 +60,7 @@ impl<'tcx> DoubleComparisons {
                     cx,
                     DOUBLE_COMPARISONS,
                     span,
-                    "This binary expression can be simplified",
+                    "this binary expression can be simplified",
                     "try",
                     sugg,
                     applicability,
diff --git a/tests/ui/double_comparison.stderr b/tests/ui/double_comparison.stderr
index 5dcda7b3af4..05ef4e25f7f 100644
--- a/tests/ui/double_comparison.stderr
+++ b/tests/ui/double_comparison.stderr
@@ -1,4 +1,4 @@
-error: This binary expression can be simplified
+error: this binary expression can be simplified
   --> $DIR/double_comparison.rs:6:8
    |
 LL |     if x == y || x < y {
@@ -6,43 +6,43 @@ LL |     if x == y || x < y {
    |
    = note: `-D clippy::double-comparisons` implied by `-D warnings`
 
-error: This binary expression can be simplified
+error: this binary expression can be simplified
   --> $DIR/double_comparison.rs:9:8
    |
 LL |     if x < y || x == y {
    |        ^^^^^^^^^^^^^^^ help: try: `x <= y`
 
-error: This binary expression can be simplified
+error: this binary expression can be simplified
   --> $DIR/double_comparison.rs:12:8
    |
 LL |     if x == y || x > y {
    |        ^^^^^^^^^^^^^^^ help: try: `x >= y`
 
-error: This binary expression can be simplified
+error: this binary expression can be simplified
   --> $DIR/double_comparison.rs:15:8
    |
 LL |     if x > y || x == y {
    |        ^^^^^^^^^^^^^^^ help: try: `x >= y`
 
-error: This binary expression can be simplified
+error: this binary expression can be simplified
   --> $DIR/double_comparison.rs:18:8
    |
 LL |     if x < y || x > y {
    |        ^^^^^^^^^^^^^^ help: try: `x != y`
 
-error: This binary expression can be simplified
+error: this binary expression can be simplified
   --> $DIR/double_comparison.rs:21:8
    |
 LL |     if x > y || x < y {
    |        ^^^^^^^^^^^^^^ help: try: `x != y`
 
-error: This binary expression can be simplified
+error: this binary expression can be simplified
   --> $DIR/double_comparison.rs:24:8
    |
 LL |     if x <= y && x >= y {
    |        ^^^^^^^^^^^^^^^^ help: try: `x == y`
 
-error: This binary expression can be simplified
+error: this binary expression can be simplified
   --> $DIR/double_comparison.rs:27:8
    |
 LL |     if x >= y && x <= y {
-- 
cgit 1.4.1-3-g733a5


From 590b91d8d4250bd6e30e2396a36c54cdbae3780f Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Thu, 23 Jul 2020 19:56:01 +0200
Subject: double-parens: make lint adhere to lint message convention and do
 minor refactoring

---
 clippy_lints/src/double_parens.rs | 23 +++++------------------
 tests/ui/double_parens.stderr     | 12 ++++++------
 2 files changed, 11 insertions(+), 24 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/double_parens.rs b/clippy_lints/src/double_parens.rs
index 1eb380a22cc..abbcaf43f41 100644
--- a/clippy_lints/src/double_parens.rs
+++ b/clippy_lints/src/double_parens.rs
@@ -45,15 +45,12 @@ impl EarlyLintPass for DoubleParens {
             return;
         }
 
+        let msg: &str = "consider removing unnecessary double parentheses";
+
         match expr.kind {
             ExprKind::Paren(ref in_paren) => match in_paren.kind {
                 ExprKind::Paren(_) | ExprKind::Tup(_) => {
-                    span_lint(
-                        cx,
-                        DOUBLE_PARENS,
-                        expr.span,
-                        "Consider removing unnecessary double parentheses",
-                    );
+                    span_lint(cx, DOUBLE_PARENS, expr.span, &msg);
                 },
                 _ => {},
             },
@@ -61,12 +58,7 @@ impl EarlyLintPass for DoubleParens {
                 if params.len() == 1 {
                     let param = &params[0];
                     if let ExprKind::Paren(_) = param.kind {
-                        span_lint(
-                            cx,
-                            DOUBLE_PARENS,
-                            param.span,
-                            "Consider removing unnecessary double parentheses",
-                        );
+                        span_lint(cx, DOUBLE_PARENS, param.span, &msg);
                     }
                 }
             },
@@ -74,12 +66,7 @@ impl EarlyLintPass for DoubleParens {
                 if params.len() == 2 {
                     let param = &params[1];
                     if let ExprKind::Paren(_) = param.kind {
-                        span_lint(
-                            cx,
-                            DOUBLE_PARENS,
-                            param.span,
-                            "Consider removing unnecessary double parentheses",
-                        );
+                        span_lint(cx, DOUBLE_PARENS, param.span, &msg);
                     }
                 }
             },
diff --git a/tests/ui/double_parens.stderr b/tests/ui/double_parens.stderr
index 0e4c9b5682d..40fcad2ab1d 100644
--- a/tests/ui/double_parens.stderr
+++ b/tests/ui/double_parens.stderr
@@ -1,4 +1,4 @@
-error: Consider removing unnecessary double parentheses
+error: consider removing unnecessary double parentheses
   --> $DIR/double_parens.rs:15:5
    |
 LL |     ((0))
@@ -6,31 +6,31 @@ LL |     ((0))
    |
    = note: `-D clippy::double-parens` implied by `-D warnings`
 
-error: Consider removing unnecessary double parentheses
+error: consider removing unnecessary double parentheses
   --> $DIR/double_parens.rs:19:14
    |
 LL |     dummy_fn((0));
    |              ^^^
 
-error: Consider removing unnecessary double parentheses
+error: consider removing unnecessary double parentheses
   --> $DIR/double_parens.rs:23:20
    |
 LL |     x.dummy_method((0));
    |                    ^^^
 
-error: Consider removing unnecessary double parentheses
+error: consider removing unnecessary double parentheses
   --> $DIR/double_parens.rs:27:5
    |
 LL |     ((1, 2))
    |     ^^^^^^^^
 
-error: Consider removing unnecessary double parentheses
+error: consider removing unnecessary double parentheses
   --> $DIR/double_parens.rs:31:5
    |
 LL |     (())
    |     ^^^^
 
-error: Consider removing unnecessary double parentheses
+error: consider removing unnecessary double parentheses
   --> $DIR/double_parens.rs:53:16
    |
 LL |     assert_eq!(((1, 2)), (1, 2), "Error");
-- 
cgit 1.4.1-3-g733a5


From 0db5cb13934bff7a561dde2e13c3455120dc1bd4 Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Thu, 23 Jul 2020 20:05:42 +0200
Subject: drop_bounds: make lint adhere to lint message convention

---
 clippy_lints/src/drop_bounds.rs | 6 +++---
 tests/ui/drop_bounds.stderr     | 4 ++--
 2 files changed, 5 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/drop_bounds.rs b/clippy_lints/src/drop_bounds.rs
index 4afbd1ed0e5..ec3b6afa630 100644
--- a/clippy_lints/src/drop_bounds.rs
+++ b/clippy_lints/src/drop_bounds.rs
@@ -33,11 +33,11 @@ declare_clippy_lint! {
     /// ```
     pub DROP_BOUNDS,
     correctness,
-    "Bounds of the form `T: Drop` are useless"
+    "bounds of the form `T: Drop` are useless"
 }
 
-const DROP_BOUNDS_SUMMARY: &str = "Bounds of the form `T: Drop` are useless. \
-                                   Use `std::mem::needs_drop` to detect if a type has drop glue.";
+const DROP_BOUNDS_SUMMARY: &str = "bounds of the form `T: Drop` are useless, \
+                                   use `std::mem::needs_drop` to detect if a type has drop glue";
 
 declare_lint_pass!(DropBounds => [DROP_BOUNDS]);
 
diff --git a/tests/ui/drop_bounds.stderr b/tests/ui/drop_bounds.stderr
index 5d360ef30a1..8208c0ed7e3 100644
--- a/tests/ui/drop_bounds.stderr
+++ b/tests/ui/drop_bounds.stderr
@@ -1,4 +1,4 @@
-error: Bounds of the form `T: Drop` are useless. Use `std::mem::needs_drop` to detect if a type has drop glue.
+error: bounds of the form `T: Drop` are useless, use `std::mem::needs_drop` to detect if a type has drop glue
   --> $DIR/drop_bounds.rs:2:11
    |
 LL | fn foo<T: Drop>() {}
@@ -6,7 +6,7 @@ LL | fn foo<T: Drop>() {}
    |
    = note: `#[deny(clippy::drop_bounds)]` on by default
 
-error: Bounds of the form `T: Drop` are useless. Use `std::mem::needs_drop` to detect if a type has drop glue.
+error: bounds of the form `T: Drop` are useless, use `std::mem::needs_drop` to detect if a type has drop glue
   --> $DIR/drop_bounds.rs:5:8
    |
 LL |     T: Drop,
-- 
cgit 1.4.1-3-g733a5


From 2792260636f720a44921c5f6571535e887aa6047 Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Thu, 23 Jul 2020 22:40:50 +0200
Subject: empty-liner-after-outer-attr: make lint adhere to lint message
 convention

---
 clippy_lints/src/attrs.rs                        |  2 +-
 tests/ui/empty_line_after_outer_attribute.stderr | 12 ++++++------
 2 files changed, 7 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs
index 3ce110e8e0f..376ac55f9c9 100644
--- a/clippy_lints/src/attrs.rs
+++ b/clippy_lints/src/attrs.rs
@@ -605,7 +605,7 @@ fn check_empty_line_after_outer_attr(cx: &EarlyContext<'_>, item: &rustc_ast::as
                         cx,
                         EMPTY_LINE_AFTER_OUTER_ATTR,
                         begin_of_attr_to_item,
-                        "Found an empty line after an outer attribute. \
+                        "found an empty line after an outer attribute. \
                         Perhaps you forgot to add a `!` to make it an inner attribute?",
                     );
                 }
diff --git a/tests/ui/empty_line_after_outer_attribute.stderr b/tests/ui/empty_line_after_outer_attribute.stderr
index bf753a732f0..594fca44a32 100644
--- a/tests/ui/empty_line_after_outer_attribute.stderr
+++ b/tests/ui/empty_line_after_outer_attribute.stderr
@@ -1,4 +1,4 @@
-error: Found an empty line after an outer attribute. Perhaps you forgot to add a `!` to make it an inner attribute?
+error: found an empty line after an outer attribute. Perhaps you forgot to add a `!` to make it an inner attribute?
   --> $DIR/empty_line_after_outer_attribute.rs:11:1
    |
 LL | / #[crate_type = "lib"]
@@ -9,7 +9,7 @@ LL | | fn with_one_newline_and_comment() { assert!(true) }
    |
    = note: `-D clippy::empty-line-after-outer-attr` implied by `-D warnings`
 
-error: Found an empty line after an outer attribute. Perhaps you forgot to add a `!` to make it an inner attribute?
+error: found an empty line after an outer attribute. Perhaps you forgot to add a `!` to make it an inner attribute?
   --> $DIR/empty_line_after_outer_attribute.rs:23:1
    |
 LL | / #[crate_type = "lib"]
@@ -17,7 +17,7 @@ LL | |
 LL | | fn with_one_newline() { assert!(true) }
    | |_
 
-error: Found an empty line after an outer attribute. Perhaps you forgot to add a `!` to make it an inner attribute?
+error: found an empty line after an outer attribute. Perhaps you forgot to add a `!` to make it an inner attribute?
   --> $DIR/empty_line_after_outer_attribute.rs:28:1
    |
 LL | / #[crate_type = "lib"]
@@ -26,7 +26,7 @@ LL | |
 LL | | fn with_two_newlines() { assert!(true) }
    | |_
 
-error: Found an empty line after an outer attribute. Perhaps you forgot to add a `!` to make it an inner attribute?
+error: found an empty line after an outer attribute. Perhaps you forgot to add a `!` to make it an inner attribute?
   --> $DIR/empty_line_after_outer_attribute.rs:35:1
    |
 LL | / #[crate_type = "lib"]
@@ -34,7 +34,7 @@ LL | |
 LL | | enum Baz {
    | |_
 
-error: Found an empty line after an outer attribute. Perhaps you forgot to add a `!` to make it an inner attribute?
+error: found an empty line after an outer attribute. Perhaps you forgot to add a `!` to make it an inner attribute?
   --> $DIR/empty_line_after_outer_attribute.rs:43:1
    |
 LL | / #[crate_type = "lib"]
@@ -42,7 +42,7 @@ LL | |
 LL | | struct Foo {
    | |_
 
-error: Found an empty line after an outer attribute. Perhaps you forgot to add a `!` to make it an inner attribute?
+error: found an empty line after an outer attribute. Perhaps you forgot to add a `!` to make it an inner attribute?
   --> $DIR/empty_line_after_outer_attribute.rs:51:1
    |
 LL | / #[crate_type = "lib"]
-- 
cgit 1.4.1-3-g733a5


From 4418ff122fdc65d642dd4adb709634c4f879171e Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Thu, 23 Jul 2020 23:31:33 +0200
Subject: unneeded-field-pattern: make lint adhere to lint message convention

---
 clippy_lints/src/misc_early.rs         | 10 +++++-----
 tests/ui/unneeded_field_pattern.stderr |  8 ++++----
 2 files changed, 9 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/misc_early.rs b/clippy_lints/src/misc_early.rs
index 38b11c5e733..02789735c17 100644
--- a/clippy_lints/src/misc_early.rs
+++ b/clippy_lints/src/misc_early.rs
@@ -298,9 +298,9 @@ impl EarlyLintPass for MiscEarlyLints {
                     cx,
                     UNNEEDED_FIELD_PATTERN,
                     pat.span,
-                    "All the struct fields are matched to a wildcard pattern, consider using `..`.",
+                    "all the struct fields are matched to a wildcard pattern, consider using `..`",
                     None,
-                    &format!("Try with `{} {{ .. }}` instead", type_name),
+                    &format!("try with `{} {{ .. }}` instead", type_name),
                 );
                 return;
             }
@@ -313,7 +313,7 @@ impl EarlyLintPass for MiscEarlyLints {
                                 cx,
                                 UNNEEDED_FIELD_PATTERN,
                                 field.span,
-                                "You matched a field with a wildcard pattern. Consider using `..` instead",
+                                "you matched a field with a wildcard pattern, consider using `..` instead",
                             );
                         } else {
                             let mut normal = vec![];
@@ -333,10 +333,10 @@ impl EarlyLintPass for MiscEarlyLints {
                                 cx,
                                 UNNEEDED_FIELD_PATTERN,
                                 field.span,
-                                "You matched a field with a wildcard pattern. Consider using `..` \
+                                "you matched a field with a wildcard pattern, consider using `..` \
                                  instead",
                                 None,
-                                &format!("Try with `{} {{ {}, .. }}`", type_name, normal[..].join(", ")),
+                                &format!("try with `{} {{ {}, .. }}`", type_name, normal[..].join(", ")),
                             );
                         }
                     }
diff --git a/tests/ui/unneeded_field_pattern.stderr b/tests/ui/unneeded_field_pattern.stderr
index e7b92ce1e19..b8d3c294532 100644
--- a/tests/ui/unneeded_field_pattern.stderr
+++ b/tests/ui/unneeded_field_pattern.stderr
@@ -1,19 +1,19 @@
-error: You matched a field with a wildcard pattern. Consider using `..` instead
+error: you matched a field with a wildcard pattern, consider using `..` instead
   --> $DIR/unneeded_field_pattern.rs:14:15
    |
 LL |         Foo { a: _, b: 0, .. } => {},
    |               ^^^^
    |
    = note: `-D clippy::unneeded-field-pattern` implied by `-D warnings`
-   = help: Try with `Foo { b: 0, .. }`
+   = help: try with `Foo { b: 0, .. }`
 
-error: All the struct fields are matched to a wildcard pattern, consider using `..`.
+error: all the struct fields are matched to a wildcard pattern, consider using `..`
   --> $DIR/unneeded_field_pattern.rs:16:9
    |
 LL |         Foo { a: _, b: _, c: _ } => {},
    |         ^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: Try with `Foo { .. }` instead
+   = help: try with `Foo { .. }` instead
 
 error: aborting due to 2 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From b36a6c9594ffb7e225a3d8872d8de2889ea0bac1 Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Thu, 23 Jul 2020 23:36:20 +0200
Subject: ref_in_deref: make lint adhere to lint message convention

---
 clippy_lints/src/reference.rs   | 2 +-
 tests/ui/unnecessary_ref.stderr | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/reference.rs b/clippy_lints/src/reference.rs
index fe457aad50e..3fda00403c6 100644
--- a/clippy_lints/src/reference.rs
+++ b/clippy_lints/src/reference.rs
@@ -92,7 +92,7 @@ impl EarlyLintPass for RefInDeref {
                     cx,
                     REF_IN_DEREF,
                     object.span,
-                    "Creating a reference that is immediately dereferenced.",
+                    "creating a reference that is immediately dereferenced",
                     "try this",
                     snippet_with_applicability(cx, inner.span, "_", &mut applicability).to_string(),
                     applicability,
diff --git a/tests/ui/unnecessary_ref.stderr b/tests/ui/unnecessary_ref.stderr
index 34ba167a947..d0a0f219097 100644
--- a/tests/ui/unnecessary_ref.stderr
+++ b/tests/ui/unnecessary_ref.stderr
@@ -1,4 +1,4 @@
-error: Creating a reference that is immediately dereferenced.
+error: creating a reference that is immediately dereferenced
   --> $DIR/unnecessary_ref.rs:13:17
    |
 LL |     let inner = (&outer).inner;
-- 
cgit 1.4.1-3-g733a5


From 7954c22a99275a8b7be79c14d2bb882750de53ea Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Thu, 23 Jul 2020 23:37:16 +0200
Subject: unknown: make lint adhere to lint message convention

---
 clippy_lints/src/utils/attrs.rs   | 2 +-
 tests/ui/unknown_attribute.stderr | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/attrs.rs b/clippy_lints/src/utils/attrs.rs
index 407527251da..234ae37612b 100644
--- a/clippy_lints/src/utils/attrs.rs
+++ b/clippy_lints/src/utils/attrs.rs
@@ -75,7 +75,7 @@ pub fn get_attr<'a>(
                 })
                 .map_or_else(
                     || {
-                        sess.span_err(attr_segments[1].ident.span, "Usage of unknown attribute");
+                        sess.span_err(attr_segments[1].ident.span, "usage of unknown attribute");
                         false
                     },
                     |deprecation_status| {
diff --git a/tests/ui/unknown_attribute.stderr b/tests/ui/unknown_attribute.stderr
index 47e37aed246..618c5980d64 100644
--- a/tests/ui/unknown_attribute.stderr
+++ b/tests/ui/unknown_attribute.stderr
@@ -1,4 +1,4 @@
-error: Usage of unknown attribute
+error: usage of unknown attribute
   --> $DIR/unknown_attribute.rs:1:11
    |
 LL | #[clippy::unknown]
-- 
cgit 1.4.1-3-g733a5


From fe37ddbd11dd3f2cb2e529846492b312e44ed1b9 Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Thu, 23 Jul 2020 23:45:24 +0200
Subject: suspicious-arithmetic-impl: make lint adhere to lint message
 convention

---
 clippy_lints/src/suspicious_trait_impl.rs  | 4 ++--
 tests/ui/suspicious_arithmetic_impl.stderr | 6 +++---
 2 files changed, 5 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/suspicious_trait_impl.rs b/clippy_lints/src/suspicious_trait_impl.rs
index 502fffc5e6c..4e335a0222f 100644
--- a/clippy_lints/src/suspicious_trait_impl.rs
+++ b/clippy_lints/src/suspicious_trait_impl.rs
@@ -98,7 +98,7 @@ impl<'tcx> LateLintPass<'tcx> for SuspiciousImpl {
                     cx,
                     SUSPICIOUS_ARITHMETIC_IMPL,
                     binop.span,
-                    &format!(r#"Suspicious use of binary operator in `{}` impl"#, impl_trait),
+                    &format!("suspicious use of binary operator in `{}` impl", impl_trait),
                 );
             }
 
@@ -135,7 +135,7 @@ impl<'tcx> LateLintPass<'tcx> for SuspiciousImpl {
                     cx,
                     SUSPICIOUS_OP_ASSIGN_IMPL,
                     binop.span,
-                    &format!(r#"Suspicious use of binary operator in `{}` impl"#, impl_trait),
+                    &format!("suspicious use of binary operator in `{}` impl", impl_trait),
                 );
             }
         }
diff --git a/tests/ui/suspicious_arithmetic_impl.stderr b/tests/ui/suspicious_arithmetic_impl.stderr
index 7e42d72c30b..23d47e3f1ff 100644
--- a/tests/ui/suspicious_arithmetic_impl.stderr
+++ b/tests/ui/suspicious_arithmetic_impl.stderr
@@ -1,4 +1,4 @@
-error: Suspicious use of binary operator in `Add` impl
+error: suspicious use of binary operator in `Add` impl
   --> $DIR/suspicious_arithmetic_impl.rs:11:20
    |
 LL |         Foo(self.0 - other.0)
@@ -6,7 +6,7 @@ LL |         Foo(self.0 - other.0)
    |
    = note: `-D clippy::suspicious-arithmetic-impl` implied by `-D warnings`
 
-error: Suspicious use of binary operator in `AddAssign` impl
+error: suspicious use of binary operator in `AddAssign` impl
   --> $DIR/suspicious_arithmetic_impl.rs:17:23
    |
 LL |         *self = *self - other;
@@ -14,7 +14,7 @@ LL |         *self = *self - other;
    |
    = note: `#[deny(clippy::suspicious_op_assign_impl)]` on by default
 
-error: Suspicious use of binary operator in `MulAssign` impl
+error: suspicious use of binary operator in `MulAssign` impl
   --> $DIR/suspicious_arithmetic_impl.rs:30:16
    |
 LL |         self.0 /= other.0;
-- 
cgit 1.4.1-3-g733a5


From 5d69ca5e114a1e44be08c835394b82ffc9cc7f14 Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Thu, 23 Jul 2020 23:46:52 +0200
Subject: also change "deprecated-attribute" message

---
 clippy_lints/src/utils/attrs.rs      | 2 +-
 tests/ui/renamed_builtin_attr.stderr | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/attrs.rs b/clippy_lints/src/utils/attrs.rs
index 234ae37612b..a3975683cb3 100644
--- a/clippy_lints/src/utils/attrs.rs
+++ b/clippy_lints/src/utils/attrs.rs
@@ -80,7 +80,7 @@ pub fn get_attr<'a>(
                     },
                     |deprecation_status| {
                         let mut diag =
-                            sess.struct_span_err(attr_segments[1].ident.span, "Usage of deprecated attribute");
+                            sess.struct_span_err(attr_segments[1].ident.span, "usage of deprecated attribute");
                         match *deprecation_status {
                             DeprecationStatus::Deprecated => {
                                 diag.emit();
diff --git a/tests/ui/renamed_builtin_attr.stderr b/tests/ui/renamed_builtin_attr.stderr
index a399ff52fb8..88046762483 100644
--- a/tests/ui/renamed_builtin_attr.stderr
+++ b/tests/ui/renamed_builtin_attr.stderr
@@ -1,4 +1,4 @@
-error: Usage of deprecated attribute
+error: usage of deprecated attribute
   --> $DIR/renamed_builtin_attr.rs:3:11
    |
 LL | #[clippy::cyclomatic_complexity = "1"]
-- 
cgit 1.4.1-3-g733a5


From 3e1e0c9bdb582b15c7804e354085b17f8b6c62d5 Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Thu, 23 Jul 2020 23:54:34 +0200
Subject: redundant-static-lifetimes: make lint adhere to lint message
 convention

---
 clippy_lints/src/redundant_static_lifetimes.rs     |  4 +--
 tests/ui/redundant_static_lifetimes.stderr         | 32 +++++++++++-----------
 .../ui/redundant_static_lifetimes_multiple.stderr  | 20 +++++++-------
 3 files changed, 28 insertions(+), 28 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/redundant_static_lifetimes.rs b/clippy_lints/src/redundant_static_lifetimes.rs
index c6f57298c26..7bbcc67aa2d 100644
--- a/clippy_lints/src/redundant_static_lifetimes.rs
+++ b/clippy_lints/src/redundant_static_lifetimes.rs
@@ -86,13 +86,13 @@ impl EarlyLintPass for RedundantStaticLifetimes {
     fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {
         if !item.span.from_expansion() {
             if let ItemKind::Const(_, ref var_type, _) = item.kind {
-                self.visit_type(var_type, cx, "Constants have by default a `'static` lifetime");
+                self.visit_type(var_type, cx, "constants have by default a `'static` lifetime");
                 // Don't check associated consts because `'static` cannot be elided on those (issue
                 // #2438)
             }
 
             if let ItemKind::Static(ref var_type, _, _) = item.kind {
-                self.visit_type(var_type, cx, "Statics have by default a `'static` lifetime");
+                self.visit_type(var_type, cx, "statics have by default a `'static` lifetime");
             }
         }
     }
diff --git a/tests/ui/redundant_static_lifetimes.stderr b/tests/ui/redundant_static_lifetimes.stderr
index 3c3d2eacd8d..649831f9c06 100644
--- a/tests/ui/redundant_static_lifetimes.stderr
+++ b/tests/ui/redundant_static_lifetimes.stderr
@@ -1,4 +1,4 @@
-error: Constants have by default a `'static` lifetime
+error: constants have by default a `'static` lifetime
   --> $DIR/redundant_static_lifetimes.rs:8:17
    |
 LL | const VAR_ONE: &'static str = "Test constant #1"; // ERROR Consider removing 'static.
@@ -6,91 +6,91 @@ LL | const VAR_ONE: &'static str = "Test constant #1"; // ERROR Consider removin
    |
    = note: `-D clippy::redundant-static-lifetimes` implied by `-D warnings`
 
-error: Constants have by default a `'static` lifetime
+error: constants have by default a `'static` lifetime
   --> $DIR/redundant_static_lifetimes.rs:12:21
    |
 LL | const VAR_THREE: &[&'static str] = &["one", "two"]; // ERROR Consider removing 'static
    |                    -^^^^^^^---- help: consider removing `'static`: `&str`
 
-error: Constants have by default a `'static` lifetime
+error: constants have by default a `'static` lifetime
   --> $DIR/redundant_static_lifetimes.rs:14:32
    |
 LL | const VAR_FOUR: (&str, (&str, &'static str), &'static str) = ("on", ("th", "th"), "on"); // ERROR Consider removing 'static
    |                               -^^^^^^^---- help: consider removing `'static`: `&str`
 
-error: Constants have by default a `'static` lifetime
+error: constants have by default a `'static` lifetime
   --> $DIR/redundant_static_lifetimes.rs:14:47
    |
 LL | const VAR_FOUR: (&str, (&str, &'static str), &'static str) = ("on", ("th", "th"), "on"); // ERROR Consider removing 'static
    |                                              -^^^^^^^---- help: consider removing `'static`: `&str`
 
-error: Constants have by default a `'static` lifetime
+error: constants have by default a `'static` lifetime
   --> $DIR/redundant_static_lifetimes.rs:16:17
    |
 LL | const VAR_SIX: &'static u8 = &5;
    |                -^^^^^^^--- help: consider removing `'static`: `&u8`
 
-error: Constants have by default a `'static` lifetime
+error: constants have by default a `'static` lifetime
   --> $DIR/redundant_static_lifetimes.rs:18:20
    |
 LL | const VAR_HEIGHT: &'static Foo = &Foo {};
    |                   -^^^^^^^---- help: consider removing `'static`: `&Foo`
 
-error: Constants have by default a `'static` lifetime
+error: constants have by default a `'static` lifetime
   --> $DIR/redundant_static_lifetimes.rs:20:19
    |
 LL | const VAR_SLICE: &'static [u8] = b"Test constant #1"; // ERROR Consider removing 'static.
    |                  -^^^^^^^----- help: consider removing `'static`: `&[u8]`
 
-error: Constants have by default a `'static` lifetime
+error: constants have by default a `'static` lifetime
   --> $DIR/redundant_static_lifetimes.rs:22:19
    |
 LL | const VAR_TUPLE: &'static (u8, u8) = &(1, 2); // ERROR Consider removing 'static.
    |                  -^^^^^^^--------- help: consider removing `'static`: `&(u8, u8)`
 
-error: Constants have by default a `'static` lifetime
+error: constants have by default a `'static` lifetime
   --> $DIR/redundant_static_lifetimes.rs:24:19
    |
 LL | const VAR_ARRAY: &'static [u8; 1] = b"T"; // ERROR Consider removing 'static.
    |                  -^^^^^^^-------- help: consider removing `'static`: `&[u8; 1]`
 
-error: Statics have by default a `'static` lifetime
+error: statics have by default a `'static` lifetime
   --> $DIR/redundant_static_lifetimes.rs:26:25
    |
 LL | static STATIC_VAR_ONE: &'static str = "Test static #1"; // ERROR Consider removing 'static.
    |                        -^^^^^^^---- help: consider removing `'static`: `&str`
 
-error: Statics have by default a `'static` lifetime
+error: statics have by default a `'static` lifetime
   --> $DIR/redundant_static_lifetimes.rs:30:29
    |
 LL | static STATIC_VAR_THREE: &[&'static str] = &["one", "two"]; // ERROR Consider removing 'static
    |                            -^^^^^^^---- help: consider removing `'static`: `&str`
 
-error: Statics have by default a `'static` lifetime
+error: statics have by default a `'static` lifetime
   --> $DIR/redundant_static_lifetimes.rs:32:25
    |
 LL | static STATIC_VAR_SIX: &'static u8 = &5;
    |                        -^^^^^^^--- help: consider removing `'static`: `&u8`
 
-error: Statics have by default a `'static` lifetime
+error: statics have by default a `'static` lifetime
   --> $DIR/redundant_static_lifetimes.rs:34:28
    |
 LL | static STATIC_VAR_HEIGHT: &'static Foo = &Foo {};
    |                           -^^^^^^^---- help: consider removing `'static`: `&Foo`
 
-error: Statics have by default a `'static` lifetime
+error: statics have by default a `'static` lifetime
   --> $DIR/redundant_static_lifetimes.rs:36:27
    |
 LL | static STATIC_VAR_SLICE: &'static [u8] = b"Test static #3"; // ERROR Consider removing 'static.
    |                          -^^^^^^^----- help: consider removing `'static`: `&[u8]`
 
-error: Statics have by default a `'static` lifetime
+error: statics have by default a `'static` lifetime
   --> $DIR/redundant_static_lifetimes.rs:38:27
    |
 LL | static STATIC_VAR_TUPLE: &'static (u8, u8) = &(1, 2); // ERROR Consider removing 'static.
    |                          -^^^^^^^--------- help: consider removing `'static`: `&(u8, u8)`
 
-error: Statics have by default a `'static` lifetime
+error: statics have by default a `'static` lifetime
   --> $DIR/redundant_static_lifetimes.rs:40:27
    |
 LL | static STATIC_VAR_ARRAY: &'static [u8; 1] = b"T"; // ERROR Consider removing 'static.
diff --git a/tests/ui/redundant_static_lifetimes_multiple.stderr b/tests/ui/redundant_static_lifetimes_multiple.stderr
index afc853dcfce..cc7e55a757a 100644
--- a/tests/ui/redundant_static_lifetimes_multiple.stderr
+++ b/tests/ui/redundant_static_lifetimes_multiple.stderr
@@ -1,4 +1,4 @@
-error: Constants have by default a `'static` lifetime
+error: constants have by default a `'static` lifetime
   --> $DIR/redundant_static_lifetimes_multiple.rs:3:18
    |
 LL | const VAR_FIVE: &'static [&[&'static str]] = &[&["test"], &["other one"]]; // ERROR Consider removing 'static
@@ -6,55 +6,55 @@ LL | const VAR_FIVE: &'static [&[&'static str]] = &[&["test"], &["other one"]];
    |
    = note: `-D clippy::redundant-static-lifetimes` implied by `-D warnings`
 
-error: Constants have by default a `'static` lifetime
+error: constants have by default a `'static` lifetime
   --> $DIR/redundant_static_lifetimes_multiple.rs:3:30
    |
 LL | const VAR_FIVE: &'static [&[&'static str]] = &[&["test"], &["other one"]]; // ERROR Consider removing 'static
    |                             -^^^^^^^---- help: consider removing `'static`: `&str`
 
-error: Constants have by default a `'static` lifetime
+error: constants have by default a `'static` lifetime
   --> $DIR/redundant_static_lifetimes_multiple.rs:5:29
    |
 LL | const VAR_SEVEN: &[&(&str, &'static [&'static str])] = &[&("one", &["other one"])];
    |                            -^^^^^^^--------------- help: consider removing `'static`: `&[&'static str]`
 
-error: Constants have by default a `'static` lifetime
+error: constants have by default a `'static` lifetime
   --> $DIR/redundant_static_lifetimes_multiple.rs:5:39
    |
 LL | const VAR_SEVEN: &[&(&str, &'static [&'static str])] = &[&("one", &["other one"])];
    |                                      -^^^^^^^---- help: consider removing `'static`: `&str`
 
-error: Statics have by default a `'static` lifetime
+error: statics have by default a `'static` lifetime
   --> $DIR/redundant_static_lifetimes_multiple.rs:7:40
    |
 LL | static STATIC_VAR_FOUR: (&str, (&str, &'static str), &'static str) = ("on", ("th", "th"), "on"); // ERROR Consider removing 'static
    |                                       -^^^^^^^---- help: consider removing `'static`: `&str`
 
-error: Statics have by default a `'static` lifetime
+error: statics have by default a `'static` lifetime
   --> $DIR/redundant_static_lifetimes_multiple.rs:7:55
    |
 LL | static STATIC_VAR_FOUR: (&str, (&str, &'static str), &'static str) = ("on", ("th", "th"), "on"); // ERROR Consider removing 'static
    |                                                      -^^^^^^^---- help: consider removing `'static`: `&str`
 
-error: Statics have by default a `'static` lifetime
+error: statics have by default a `'static` lifetime
   --> $DIR/redundant_static_lifetimes_multiple.rs:9:26
    |
 LL | static STATIC_VAR_FIVE: &'static [&[&'static str]] = &[&["test"], &["other one"]]; // ERROR Consider removing 'static
    |                         -^^^^^^^------------------ help: consider removing `'static`: `&[&[&'static str]]`
 
-error: Statics have by default a `'static` lifetime
+error: statics have by default a `'static` lifetime
   --> $DIR/redundant_static_lifetimes_multiple.rs:9:38
    |
 LL | static STATIC_VAR_FIVE: &'static [&[&'static str]] = &[&["test"], &["other one"]]; // ERROR Consider removing 'static
    |                                     -^^^^^^^---- help: consider removing `'static`: `&str`
 
-error: Statics have by default a `'static` lifetime
+error: statics have by default a `'static` lifetime
   --> $DIR/redundant_static_lifetimes_multiple.rs:11:37
    |
 LL | static STATIC_VAR_SEVEN: &[&(&str, &'static [&'static str])] = &[&("one", &["other one"])];
    |                                    -^^^^^^^--------------- help: consider removing `'static`: `&[&'static str]`
 
-error: Statics have by default a `'static` lifetime
+error: statics have by default a `'static` lifetime
   --> $DIR/redundant_static_lifetimes_multiple.rs:11:47
    |
 LL | static STATIC_VAR_SEVEN: &[&(&str, &'static [&'static str])] = &[&("one", &["other one"])];
-- 
cgit 1.4.1-3-g733a5


From 81f77a411e844ca553ba93adcc8be617d372ac30 Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Fri, 24 Jul 2020 00:12:21 +0200
Subject: range-zip-with-len: make lint adhere to lint message convention

---
 clippy_lints/src/ranges.rs | 2 +-
 tests/ui/range.stderr      | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/ranges.rs b/clippy_lints/src/ranges.rs
index 4c1f2e8e01a..f88075798ca 100644
--- a/clippy_lints/src/ranges.rs
+++ b/clippy_lints/src/ranges.rs
@@ -160,7 +160,7 @@ impl<'tcx> LateLintPass<'tcx> for Ranges {
                          span_lint(cx,
                                    RANGE_ZIP_WITH_LEN,
                                    expr.span,
-                                   &format!("It is more idiomatic to use `{}.iter().enumerate()`",
+                                   &format!("it is more idiomatic to use `{}.iter().enumerate()`",
                                             snippet(cx, iter_args[0].span, "_")));
                     }
                 }
diff --git a/tests/ui/range.stderr b/tests/ui/range.stderr
index d53c1edecac..dcb5061371f 100644
--- a/tests/ui/range.stderr
+++ b/tests/ui/range.stderr
@@ -1,4 +1,4 @@
-error: It is more idiomatic to use `v1.iter().enumerate()`
+error: it is more idiomatic to use `v1.iter().enumerate()`
   --> $DIR/range.rs:5:14
    |
 LL |     let _x = v1.iter().zip(0..v1.len());
-- 
cgit 1.4.1-3-g733a5


From 9178363574625a6185ea779c4a231b8f18205261 Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Fri, 24 Jul 2020 00:16:28 +0200
Subject: path-buf-push-overwrite: make lint adhere to lint message convention

---
 clippy_lints/src/path_buf_push_overwrite.rs | 2 +-
 tests/ui/path_buf_push_overwrite.stderr     | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/path_buf_push_overwrite.rs b/clippy_lints/src/path_buf_push_overwrite.rs
index 66a145a7f14..b8583402928 100644
--- a/clippy_lints/src/path_buf_push_overwrite.rs
+++ b/clippy_lints/src/path_buf_push_overwrite.rs
@@ -60,7 +60,7 @@ impl<'tcx> LateLintPass<'tcx> for PathBufPushOverwrite {
                     cx,
                     PATH_BUF_PUSH_OVERWRITE,
                     lit.span,
-                    "Calling `push` with '/' or '\\' (file system root) will overwrite the previous path definition",
+                    "calling `push` with '/' or '\\' (file system root) will overwrite the previous path definition",
                     "try",
                     format!("\"{}\"", pushed_path_lit.trim_start_matches(|c| c == '/' || c == '\\')),
                     Applicability::MachineApplicable,
diff --git a/tests/ui/path_buf_push_overwrite.stderr b/tests/ui/path_buf_push_overwrite.stderr
index 09b18d71baf..bb8dce2bbba 100644
--- a/tests/ui/path_buf_push_overwrite.stderr
+++ b/tests/ui/path_buf_push_overwrite.stderr
@@ -1,4 +1,4 @@
-error: Calling `push` with '/' or '/' (file system root) will overwrite the previous path definition
+error: calling `push` with '/' or '/' (file system root) will overwrite the previous path definition
   --> $DIR/path_buf_push_overwrite.rs:7:12
    |
 LL |     x.push("/bar");
-- 
cgit 1.4.1-3-g733a5


From e519bb3c850199d03eed7f2bd29637b3d5479551 Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Fri, 24 Jul 2020 00:18:34 +0200
Subject: overflow-check-conditional: make lint adhere to lint message
 convention

---
 clippy_lints/src/overflow_check_conditional.rs |  8 ++++----
 tests/ui/overflow_check_conditional.stderr     | 16 ++++++++--------
 2 files changed, 12 insertions(+), 12 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/overflow_check_conditional.rs b/clippy_lints/src/overflow_check_conditional.rs
index 4d4a9676654..3c041bac234 100644
--- a/clippy_lints/src/overflow_check_conditional.rs
+++ b/clippy_lints/src/overflow_check_conditional.rs
@@ -42,13 +42,13 @@ impl<'tcx> LateLintPass<'tcx> for OverflowCheckConditional {
                 if let BinOpKind::Lt = op.node {
                     if let BinOpKind::Add = op2.node {
                         span_lint(cx, OVERFLOW_CHECK_CONDITIONAL, expr.span,
-                            "You are trying to use classic C overflow conditions that will fail in Rust.");
+                            "you are trying to use classic C overflow conditions that will fail in Rust");
                     }
                 }
                 if let BinOpKind::Gt = op.node {
                     if let BinOpKind::Sub = op2.node {
                         span_lint(cx, OVERFLOW_CHECK_CONDITIONAL, expr.span,
-                            "You are trying to use classic C underflow conditions that will fail in Rust.");
+                            "you are trying to use classic C underflow conditions that will fail in Rust");
                     }
                 }
             }
@@ -67,13 +67,13 @@ impl<'tcx> LateLintPass<'tcx> for OverflowCheckConditional {
                 if let BinOpKind::Gt = op.node {
                     if let BinOpKind::Add = op2.node {
                         span_lint(cx, OVERFLOW_CHECK_CONDITIONAL, expr.span,
-                            "You are trying to use classic C overflow conditions that will fail in Rust.");
+                            "you are trying to use classic C overflow conditions that will fail in Rust");
                     }
                 }
                 if let BinOpKind::Lt = op.node {
                     if let BinOpKind::Sub = op2.node {
                         span_lint(cx, OVERFLOW_CHECK_CONDITIONAL, expr.span,
-                            "You are trying to use classic C underflow conditions that will fail in Rust.");
+                            "you are trying to use classic C underflow conditions that will fail in Rust");
                     }
                 }
             }
diff --git a/tests/ui/overflow_check_conditional.stderr b/tests/ui/overflow_check_conditional.stderr
index ad66135d326..19e843c2c0a 100644
--- a/tests/ui/overflow_check_conditional.stderr
+++ b/tests/ui/overflow_check_conditional.stderr
@@ -1,4 +1,4 @@
-error: You are trying to use classic C overflow conditions that will fail in Rust.
+error: you are trying to use classic C overflow conditions that will fail in Rust
   --> $DIR/overflow_check_conditional.rs:8:8
    |
 LL |     if a + b < a {}
@@ -6,43 +6,43 @@ LL |     if a + b < a {}
    |
    = note: `-D clippy::overflow-check-conditional` implied by `-D warnings`
 
-error: You are trying to use classic C overflow conditions that will fail in Rust.
+error: you are trying to use classic C overflow conditions that will fail in Rust
   --> $DIR/overflow_check_conditional.rs:9:8
    |
 LL |     if a > a + b {}
    |        ^^^^^^^^^
 
-error: You are trying to use classic C overflow conditions that will fail in Rust.
+error: you are trying to use classic C overflow conditions that will fail in Rust
   --> $DIR/overflow_check_conditional.rs:10:8
    |
 LL |     if a + b < b {}
    |        ^^^^^^^^^
 
-error: You are trying to use classic C overflow conditions that will fail in Rust.
+error: you are trying to use classic C overflow conditions that will fail in Rust
   --> $DIR/overflow_check_conditional.rs:11:8
    |
 LL |     if b > a + b {}
    |        ^^^^^^^^^
 
-error: You are trying to use classic C underflow conditions that will fail in Rust.
+error: you are trying to use classic C underflow conditions that will fail in Rust
   --> $DIR/overflow_check_conditional.rs:12:8
    |
 LL |     if a - b > b {}
    |        ^^^^^^^^^
 
-error: You are trying to use classic C underflow conditions that will fail in Rust.
+error: you are trying to use classic C underflow conditions that will fail in Rust
   --> $DIR/overflow_check_conditional.rs:13:8
    |
 LL |     if b < a - b {}
    |        ^^^^^^^^^
 
-error: You are trying to use classic C underflow conditions that will fail in Rust.
+error: you are trying to use classic C underflow conditions that will fail in Rust
   --> $DIR/overflow_check_conditional.rs:14:8
    |
 LL |     if a - b > a {}
    |        ^^^^^^^^^
 
-error: You are trying to use classic C underflow conditions that will fail in Rust.
+error: you are trying to use classic C underflow conditions that will fail in Rust
   --> $DIR/overflow_check_conditional.rs:15:8
    |
 LL |     if a < a - b {}
-- 
cgit 1.4.1-3-g733a5


From 178da9b2ef9e8c94ab0fbe7812e11445664f67b0 Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Fri, 24 Jul 2020 00:24:11 +0200
Subject: neg-multiply: make lint adhere to lint message convention

---
 clippy_lints/src/neg_multiply.rs | 2 +-
 tests/ui/neg_multiply.stderr     | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/neg_multiply.rs b/clippy_lints/src/neg_multiply.rs
index 6b6c950e0ab..aa550510867 100644
--- a/clippy_lints/src/neg_multiply.rs
+++ b/clippy_lints/src/neg_multiply.rs
@@ -47,7 +47,7 @@ fn check_mul(cx: &LateContext<'_>, span: Span, lit: &Expr<'_>, exp: &Expr<'_>) {
         if let Constant::Int(1) = consts::lit_to_constant(&l.node, cx.typeck_results().expr_ty_opt(lit));
         if cx.typeck_results().expr_ty(exp).is_integral();
         then {
-            span_lint(cx, NEG_MULTIPLY, span, "Negation by multiplying with `-1`");
+            span_lint(cx, NEG_MULTIPLY, span, "negation by multiplying with `-1`");
         }
     }
 }
diff --git a/tests/ui/neg_multiply.stderr b/tests/ui/neg_multiply.stderr
index f08bbd6a12c..ad677f6d6fb 100644
--- a/tests/ui/neg_multiply.stderr
+++ b/tests/ui/neg_multiply.stderr
@@ -1,4 +1,4 @@
-error: Negation by multiplying with `-1`
+error: negation by multiplying with `-1`
   --> $DIR/neg_multiply.rs:27:5
    |
 LL |     x * -1;
@@ -6,7 +6,7 @@ LL |     x * -1;
    |
    = note: `-D clippy::neg-multiply` implied by `-D warnings`
 
-error: Negation by multiplying with `-1`
+error: negation by multiplying with `-1`
   --> $DIR/neg_multiply.rs:29:5
    |
 LL |     -1 * x;
-- 
cgit 1.4.1-3-g733a5


From dabf9891954aa0d0c59b230ab0e7afcfd4142be0 Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Tue, 28 Jul 2020 12:13:22 +0200
Subject: neg-cmp-op-on-partial-ord: make lint adhere to lint message
 convention

---
 clippy_lints/src/neg_cmp_op_on_partial_ord.rs | 2 +-
 tests/ui/neg_cmp_op_on_partial_ord.stderr     | 8 ++++----
 2 files changed, 5 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/neg_cmp_op_on_partial_ord.rs b/clippy_lints/src/neg_cmp_op_on_partial_ord.rs
index 95613a1b82e..0f5d5ce3495 100644
--- a/clippy_lints/src/neg_cmp_op_on_partial_ord.rs
+++ b/clippy_lints/src/neg_cmp_op_on_partial_ord.rs
@@ -79,7 +79,7 @@ impl<'tcx> LateLintPass<'tcx> for NoNegCompOpForPartialOrd {
                         cx,
                         NEG_CMP_OP_ON_PARTIAL_ORD,
                         expr.span,
-                        "The use of negated comparison operators on partially ordered \
+                        "the use of negated comparison operators on partially ordered \
                         types produces code that is hard to read and refactor. Please \
                         consider using the `partial_cmp` method instead, to make it \
                         clear that the two values could be incomparable."
diff --git a/tests/ui/neg_cmp_op_on_partial_ord.stderr b/tests/ui/neg_cmp_op_on_partial_ord.stderr
index 8c5d548222e..193d9f9bcea 100644
--- a/tests/ui/neg_cmp_op_on_partial_ord.stderr
+++ b/tests/ui/neg_cmp_op_on_partial_ord.stderr
@@ -1,4 +1,4 @@
-error: The use of negated comparison operators on partially ordered types produces code that is hard to read and refactor. Please consider using the `partial_cmp` method instead, to make it clear that the two values could be incomparable.
+error: the use of negated comparison operators on partially ordered types produces code that is hard to read and refactor. Please consider using the `partial_cmp` method instead, to make it clear that the two values could be incomparable.
   --> $DIR/neg_cmp_op_on_partial_ord.rs:16:21
    |
 LL |     let _not_less = !(a_value < another_value);
@@ -6,19 +6,19 @@ LL |     let _not_less = !(a_value < another_value);
    |
    = note: `-D clippy::neg-cmp-op-on-partial-ord` implied by `-D warnings`
 
-error: The use of negated comparison operators on partially ordered types produces code that is hard to read and refactor. Please consider using the `partial_cmp` method instead, to make it clear that the two values could be incomparable.
+error: the use of negated comparison operators on partially ordered types produces code that is hard to read and refactor. Please consider using the `partial_cmp` method instead, to make it clear that the two values could be incomparable.
   --> $DIR/neg_cmp_op_on_partial_ord.rs:19:30
    |
 LL |     let _not_less_or_equal = !(a_value <= another_value);
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: The use of negated comparison operators on partially ordered types produces code that is hard to read and refactor. Please consider using the `partial_cmp` method instead, to make it clear that the two values could be incomparable.
+error: the use of negated comparison operators on partially ordered types produces code that is hard to read and refactor. Please consider using the `partial_cmp` method instead, to make it clear that the two values could be incomparable.
   --> $DIR/neg_cmp_op_on_partial_ord.rs:22:24
    |
 LL |     let _not_greater = !(a_value > another_value);
    |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: The use of negated comparison operators on partially ordered types produces code that is hard to read and refactor. Please consider using the `partial_cmp` method instead, to make it clear that the two values could be incomparable.
+error: the use of negated comparison operators on partially ordered types produces code that is hard to read and refactor. Please consider using the `partial_cmp` method instead, to make it clear that the two values could be incomparable.
   --> $DIR/neg_cmp_op_on_partial_ord.rs:25:33
    |
 LL |     let _not_greater_or_equal = !(a_value >= another_value);
-- 
cgit 1.4.1-3-g733a5


From c514ff0c93264e3cebd5eda9caf0b99fc8fd0daa Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Mon, 10 Aug 2020 23:50:40 +0200
Subject: Update clippy_lints/src/neg_cmp_op_on_partial_ord.rs

Co-authored-by: Jane Lusby <jlusby42@gmail.com>
---
 clippy_lints/src/neg_cmp_op_on_partial_ord.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/neg_cmp_op_on_partial_ord.rs b/clippy_lints/src/neg_cmp_op_on_partial_ord.rs
index 0f5d5ce3495..4fb899125e8 100644
--- a/clippy_lints/src/neg_cmp_op_on_partial_ord.rs
+++ b/clippy_lints/src/neg_cmp_op_on_partial_ord.rs
@@ -80,9 +80,9 @@ impl<'tcx> LateLintPass<'tcx> for NoNegCompOpForPartialOrd {
                         NEG_CMP_OP_ON_PARTIAL_ORD,
                         expr.span,
                         "the use of negated comparison operators on partially ordered \
-                        types produces code that is hard to read and refactor. Please \
+                        types produces code that is hard to read and refactor, please \
                         consider using the `partial_cmp` method instead, to make it \
-                        clear that the two values could be incomparable."
+                        clear that the two values could be incomparable"
                     )
                 }
             }
-- 
cgit 1.4.1-3-g733a5


From 1b46e485b28613426f7bebccc009effad50fcaf7 Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Mon, 10 Aug 2020 23:50:52 +0200
Subject: Update clippy_lints/src/unwrap.rs

Co-authored-by: Jane Lusby <jlusby42@gmail.com>
---
 clippy_lints/src/unwrap.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unwrap.rs b/clippy_lints/src/unwrap.rs
index fd755dcc790..ea4b8172c9c 100644
--- a/clippy_lints/src/unwrap.rs
+++ b/clippy_lints/src/unwrap.rs
@@ -181,8 +181,8 @@ impl<'a, 'tcx> Visitor<'tcx> for UnwrappableVariablesVisitor<'a, 'tcx> {
                             self.cx,
                             UNNECESSARY_UNWRAP,
                             expr.span,
-                            &format!("you checked before that `{}()` cannot fail. \
-                            Instead of checking and unwrapping, it's better to use `if let` or `match`",
+                            &format!("you checked before that `{}()` cannot fail, \
+                            instead of checking and unwrapping, it's better to use `if let` or `match`",
                             method_name.ident.name),
                             |diag| { diag.span_label(unwrappable.check.span, "the check is happening here"); },
                         );
-- 
cgit 1.4.1-3-g733a5


From b8713e3854cb90b974eceaa1d50484831591619c Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Tue, 11 Aug 2020 12:35:55 +0200
Subject: unnecessary-mut-passed: make lint message say if fn is a function or
 a method.

---
 clippy_lints/src/mut_reference.rs | 13 ++++++++++---
 tests/ui/mut_reference.stderr     |  6 +++---
 2 files changed, 13 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/mut_reference.rs b/clippy_lints/src/mut_reference.rs
index b8dc5081632..be3ae7ab380 100644
--- a/clippy_lints/src/mut_reference.rs
+++ b/clippy_lints/src/mut_reference.rs
@@ -39,6 +39,7 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryMutPassed {
                         arguments,
                         cx.typeck_results().expr_ty(fn_expr),
                         &rustc_hir_pretty::to_string(rustc_hir_pretty::NO_ANN, |s| s.print_qpath(path, false)),
+                        "function",
                     );
                 }
             },
@@ -46,14 +47,20 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryMutPassed {
                 let def_id = cx.typeck_results().type_dependent_def_id(e.hir_id).unwrap();
                 let substs = cx.typeck_results().node_substs(e.hir_id);
                 let method_type = cx.tcx.type_of(def_id).subst(cx.tcx, substs);
-                check_arguments(cx, arguments, method_type, &path.ident.as_str())
+                check_arguments(cx, arguments, method_type, &path.ident.as_str(), "method")
             },
             _ => (),
         }
     }
 }
 
-fn check_arguments<'tcx>(cx: &LateContext<'tcx>, arguments: &[Expr<'_>], type_definition: Ty<'tcx>, name: &str) {
+fn check_arguments<'tcx>(
+    cx: &LateContext<'tcx>,
+    arguments: &[Expr<'_>],
+    type_definition: Ty<'tcx>,
+    name: &str,
+    fn_kind: &str,
+) {
     match type_definition.kind {
         ty::FnDef(..) | ty::FnPtr(_) => {
             let parameters = type_definition.fn_sig(cx.tcx).skip_binder().inputs();
@@ -68,7 +75,7 @@ fn check_arguments<'tcx>(cx: &LateContext<'tcx>, arguments: &[Expr<'_>], type_de
                                 cx,
                                 UNNECESSARY_MUT_PASSED,
                                 argument.span,
-                                &format!("The function/method `{}` doesn't need a mutable reference", name),
+                                &format!("the {} `{}` doesn't need a mutable reference", fn_kind, name),
                             );
                         }
                     },
diff --git a/tests/ui/mut_reference.stderr b/tests/ui/mut_reference.stderr
index fa8c82ae0f3..062d30b262c 100644
--- a/tests/ui/mut_reference.stderr
+++ b/tests/ui/mut_reference.stderr
@@ -1,4 +1,4 @@
-error: The function/method `takes_an_immutable_reference` doesn't need a mutable reference
+error: the function `takes_an_immutable_reference` doesn't need a mutable reference
   --> $DIR/mut_reference.rs:17:34
    |
 LL |     takes_an_immutable_reference(&mut 42);
@@ -6,13 +6,13 @@ LL |     takes_an_immutable_reference(&mut 42);
    |
    = note: `-D clippy::unnecessary-mut-passed` implied by `-D warnings`
 
-error: The function/method `as_ptr` doesn't need a mutable reference
+error: the function `as_ptr` doesn't need a mutable reference
   --> $DIR/mut_reference.rs:19:12
    |
 LL |     as_ptr(&mut 42);
    |            ^^^^^^^
 
-error: The function/method `takes_an_immutable_reference` doesn't need a mutable reference
+error: the method `takes_an_immutable_reference` doesn't need a mutable reference
   --> $DIR/mut_reference.rs:23:44
    |
 LL |     my_struct.takes_an_immutable_reference(&mut 42);
-- 
cgit 1.4.1-3-g733a5


From 9311c11d7c01d64d22dc7914e9dff4c5167adb49 Mon Sep 17 00:00:00 2001
From: flip1995 <hello@philkrones.com>
Date: Tue, 11 Aug 2020 13:57:32 +0200
Subject: Fix sync fallout

---
 clippy_lints/src/transmute.rs                      | 12 +++---
 tests/compile-test.rs                              |  7 ++--
 tests/ui/transmutes_expressible_as_ptr_casts.fixed | 38 +++++++------------
 tests/ui/transmutes_expressible_as_ptr_casts.rs    | 38 +++++++------------
 .../ui/transmutes_expressible_as_ptr_casts.stderr  | 44 +++++++++++-----------
 5 files changed, 59 insertions(+), 80 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/transmute.rs b/clippy_lints/src/transmute.rs
index f077c146183..7b5e92eb5ee 100644
--- a/clippy_lints/src/transmute.rs
+++ b/clippy_lints/src/transmute.rs
@@ -61,12 +61,14 @@ declare_clippy_lint! {
     ///
     /// **Example:**
     ///
-    /// ```rust,ignore
-    /// core::intrinsics::transmute::<*const [i32], *const [u16]>(p)
+    /// ```rust
+    /// # let p: *const [i32] = &[];
+    /// unsafe { std::mem::transmute::<*const [i32], *const [u16]>(p) };
     /// ```
     /// Use instead:
     /// ```rust
-    /// p as *const [u16]
+    /// # let p: *const [i32] = &[];
+    /// p as *const [u16];
     /// ```
     pub TRANSMUTES_EXPRESSIBLE_AS_PTR_CASTS,
     complexity,
@@ -704,14 +706,14 @@ fn can_be_expressed_as_pointer_cast<'tcx>(
     from_ty: Ty<'tcx>,
     to_ty: Ty<'tcx>,
 ) -> bool {
-    use CastKind::*;
+    use CastKind::{AddrPtrCast, ArrayPtrCast, FnPtrAddrCast, FnPtrPtrCast, PtrAddrCast, PtrPtrCast};
     matches!(
         check_cast(cx, e, from_ty, to_ty),
         Some(PtrPtrCast | PtrAddrCast | AddrPtrCast | ArrayPtrCast | FnPtrPtrCast | FnPtrAddrCast)
     )
 }
 
-/// If a cast from from_ty to to_ty is valid, returns an Ok containing the kind of
+/// If a cast from `from_ty` to `to_ty` is valid, returns an Ok containing the kind of
 /// the cast. In certain cases, including some invalid casts from array references
 /// to pointers, this may cause additional errors to be emitted and/or ICE error
 /// messages. This function will panic if that occurs.
diff --git a/tests/compile-test.rs b/tests/compile-test.rs
index 26a47d23706..e662d608edf 100644
--- a/tests/compile-test.rs
+++ b/tests/compile-test.rs
@@ -147,9 +147,6 @@ fn run_ui_toml(config: &mut compiletest::Config) {
 }
 
 fn run_ui_cargo(config: &mut compiletest::Config) {
-    if cargo::is_rustc_test_suite() {
-        return;
-    }
     fn run_tests(
         config: &compiletest::Config,
         filter: &Option<String>,
@@ -217,6 +214,10 @@ fn run_ui_cargo(config: &mut compiletest::Config) {
         Ok(result)
     }
 
+    if cargo::is_rustc_test_suite() {
+        return;
+    }
+
     config.mode = TestMode::Ui;
     config.src_base = Path::new("tests").join("ui-cargo").canonicalize().unwrap();
 
diff --git a/tests/ui/transmutes_expressible_as_ptr_casts.fixed b/tests/ui/transmutes_expressible_as_ptr_casts.fixed
index 98288dde6d8..b6f1e83181c 100644
--- a/tests/ui/transmutes_expressible_as_ptr_casts.fixed
+++ b/tests/ui/transmutes_expressible_as_ptr_casts.fixed
@@ -9,60 +9,48 @@
 
 use std::mem::{size_of, transmute};
 
-// rustc_typeck::check::cast contains documentation about when a cast `e as U` is 
+// rustc_typeck::check::cast contains documentation about when a cast `e as U` is
 // valid, which we quote from below.
 fn main() {
     // We should see an error message for each transmute, and no error messages for
     // the casts, since the casts are the recommended fixes.
 
     // e is an integer and U is *U_0, while U_0: Sized; addr-ptr-cast
-    let _ptr_i32_transmute = unsafe {
-        usize::MAX as *const i32
-    };
+    let _ptr_i32_transmute = unsafe { usize::MAX as *const i32 };
     let ptr_i32 = usize::MAX as *const i32;
 
     // e has type *T, U is *U_0, and either U_0: Sized ...
-    let _ptr_i8_transmute = unsafe {
-        ptr_i32 as *const i8
-    };
+    let _ptr_i8_transmute = unsafe { ptr_i32 as *const i8 };
     let _ptr_i8 = ptr_i32 as *const i8;
 
-    let slice_ptr = &[0,1,2,3] as *const [i32];
+    let slice_ptr = &[0, 1, 2, 3] as *const [i32];
 
     // ... or pointer_kind(T) = pointer_kind(U_0); ptr-ptr-cast
-    let _ptr_to_unsized_transmute = unsafe {
-        slice_ptr as *const [u16]
-    };
+    let _ptr_to_unsized_transmute = unsafe { slice_ptr as *const [u16] };
     let _ptr_to_unsized = slice_ptr as *const [u16];
     // TODO: We could try testing vtable casts here too, but maybe
     // we should wait until std::raw::TraitObject is stabilized?
 
     // e has type *T and U is a numeric type, while T: Sized; ptr-addr-cast
-    let _usize_from_int_ptr_transmute = unsafe {
-        ptr_i32 as usize
-    };
+    let _usize_from_int_ptr_transmute = unsafe { ptr_i32 as usize };
     let _usize_from_int_ptr = ptr_i32 as usize;
 
-    let array_ref: &[i32; 4] = &[1,2,3,4];
+    let array_ref: &[i32; 4] = &[1, 2, 3, 4];
 
     // e has type &[T; n] and U is *const T; array-ptr-cast
-    let _array_ptr_transmute = unsafe {
-        array_ref as *const [i32; 4]
-    };
+    let _array_ptr_transmute = unsafe { array_ref as *const [i32; 4] };
     let _array_ptr = array_ref as *const [i32; 4];
 
-    fn foo(_: usize) -> u8 { 42 }
+    fn foo(_: usize) -> u8 {
+        42
+    }
 
     // e is a function pointer type and U has type *T, while T: Sized; fptr-ptr-cast
-    let _usize_ptr_transmute = unsafe {
-        foo as *const usize
-    };
+    let _usize_ptr_transmute = unsafe { foo as *const usize };
     let _usize_ptr_transmute = foo as *const usize;
 
     // e is a function pointer type and U is an integer; fptr-addr-cast
-    let _usize_from_fn_ptr_transmute = unsafe {
-        foo as usize
-    };
+    let _usize_from_fn_ptr_transmute = unsafe { foo as usize };
     let _usize_from_fn_ptr = foo as *const usize;
 }
 
diff --git a/tests/ui/transmutes_expressible_as_ptr_casts.rs b/tests/ui/transmutes_expressible_as_ptr_casts.rs
index fd5055c08f6..0205d1ece60 100644
--- a/tests/ui/transmutes_expressible_as_ptr_casts.rs
+++ b/tests/ui/transmutes_expressible_as_ptr_casts.rs
@@ -9,60 +9,48 @@
 
 use std::mem::{size_of, transmute};
 
-// rustc_typeck::check::cast contains documentation about when a cast `e as U` is 
+// rustc_typeck::check::cast contains documentation about when a cast `e as U` is
 // valid, which we quote from below.
 fn main() {
     // We should see an error message for each transmute, and no error messages for
     // the casts, since the casts are the recommended fixes.
 
     // e is an integer and U is *U_0, while U_0: Sized; addr-ptr-cast
-    let _ptr_i32_transmute = unsafe {
-        transmute::<usize, *const i32>(usize::MAX)
-    };
+    let _ptr_i32_transmute = unsafe { transmute::<usize, *const i32>(usize::MAX) };
     let ptr_i32 = usize::MAX as *const i32;
 
     // e has type *T, U is *U_0, and either U_0: Sized ...
-    let _ptr_i8_transmute = unsafe {
-        transmute::<*const i32, *const i8>(ptr_i32)
-    };
+    let _ptr_i8_transmute = unsafe { transmute::<*const i32, *const i8>(ptr_i32) };
     let _ptr_i8 = ptr_i32 as *const i8;
 
-    let slice_ptr = &[0,1,2,3] as *const [i32];
+    let slice_ptr = &[0, 1, 2, 3] as *const [i32];
 
     // ... or pointer_kind(T) = pointer_kind(U_0); ptr-ptr-cast
-    let _ptr_to_unsized_transmute = unsafe {
-        transmute::<*const [i32], *const [u16]>(slice_ptr)
-    };
+    let _ptr_to_unsized_transmute = unsafe { transmute::<*const [i32], *const [u16]>(slice_ptr) };
     let _ptr_to_unsized = slice_ptr as *const [u16];
     // TODO: We could try testing vtable casts here too, but maybe
     // we should wait until std::raw::TraitObject is stabilized?
 
     // e has type *T and U is a numeric type, while T: Sized; ptr-addr-cast
-    let _usize_from_int_ptr_transmute = unsafe {
-        transmute::<*const i32, usize>(ptr_i32)
-    };
+    let _usize_from_int_ptr_transmute = unsafe { transmute::<*const i32, usize>(ptr_i32) };
     let _usize_from_int_ptr = ptr_i32 as usize;
 
-    let array_ref: &[i32; 4] = &[1,2,3,4];
+    let array_ref: &[i32; 4] = &[1, 2, 3, 4];
 
     // e has type &[T; n] and U is *const T; array-ptr-cast
-    let _array_ptr_transmute = unsafe {
-        transmute::<&[i32; 4], *const [i32; 4]>(array_ref)
-    };
+    let _array_ptr_transmute = unsafe { transmute::<&[i32; 4], *const [i32; 4]>(array_ref) };
     let _array_ptr = array_ref as *const [i32; 4];
 
-    fn foo(_: usize) -> u8 { 42 }
+    fn foo(_: usize) -> u8 {
+        42
+    }
 
     // e is a function pointer type and U has type *T, while T: Sized; fptr-ptr-cast
-    let _usize_ptr_transmute = unsafe {
-        transmute::<fn(usize) -> u8, *const usize>(foo)
-    };
+    let _usize_ptr_transmute = unsafe { transmute::<fn(usize) -> u8, *const usize>(foo) };
     let _usize_ptr_transmute = foo as *const usize;
 
     // e is a function pointer type and U is an integer; fptr-addr-cast
-    let _usize_from_fn_ptr_transmute = unsafe {
-        transmute::<fn(usize) -> u8, usize>(foo)
-    };
+    let _usize_from_fn_ptr_transmute = unsafe { transmute::<fn(usize) -> u8, usize>(foo) };
     let _usize_from_fn_ptr = foo as *const usize;
 }
 
diff --git a/tests/ui/transmutes_expressible_as_ptr_casts.stderr b/tests/ui/transmutes_expressible_as_ptr_casts.stderr
index 46597acc6c0..1157b179317 100644
--- a/tests/ui/transmutes_expressible_as_ptr_casts.stderr
+++ b/tests/ui/transmutes_expressible_as_ptr_casts.stderr
@@ -1,53 +1,53 @@
 error: transmute from an integer to a pointer
-  --> $DIR/transmutes_expressible_as_ptr_casts.rs:20:9
+  --> $DIR/transmutes_expressible_as_ptr_casts.rs:19:39
    |
-LL |         transmute::<usize, *const i32>(usize::MAX)
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `usize::MAX as *const i32`
+LL |     let _ptr_i32_transmute = unsafe { transmute::<usize, *const i32>(usize::MAX) };
+   |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `usize::MAX as *const i32`
    |
    = note: `-D clippy::useless-transmute` implied by `-D warnings`
 
 error: transmute from a pointer to a pointer
-  --> $DIR/transmutes_expressible_as_ptr_casts.rs:26:9
+  --> $DIR/transmutes_expressible_as_ptr_casts.rs:23:38
    |
-LL |         transmute::<*const i32, *const i8>(ptr_i32)
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `ptr_i32 as *const i8`
+LL |     let _ptr_i8_transmute = unsafe { transmute::<*const i32, *const i8>(ptr_i32) };
+   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `ptr_i32 as *const i8`
    |
    = note: `-D clippy::transmute-ptr-to-ptr` implied by `-D warnings`
 
 error: transmute from a pointer to a pointer
-  --> $DIR/transmutes_expressible_as_ptr_casts.rs:34:9
+  --> $DIR/transmutes_expressible_as_ptr_casts.rs:29:46
    |
-LL |         transmute::<*const [i32], *const [u16]>(slice_ptr)
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `slice_ptr as *const [u16]`
+LL |     let _ptr_to_unsized_transmute = unsafe { transmute::<*const [i32], *const [u16]>(slice_ptr) };
+   |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `slice_ptr as *const [u16]`
 
 error: transmute from `*const i32` to `usize` which could be expressed as a pointer cast instead
-  --> $DIR/transmutes_expressible_as_ptr_casts.rs:42:9
+  --> $DIR/transmutes_expressible_as_ptr_casts.rs:35:50
    |
-LL |         transmute::<*const i32, usize>(ptr_i32)
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `ptr_i32 as usize`
+LL |     let _usize_from_int_ptr_transmute = unsafe { transmute::<*const i32, usize>(ptr_i32) };
+   |                                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `ptr_i32 as usize`
    |
    = note: `-D clippy::transmutes-expressible-as-ptr-casts` implied by `-D warnings`
 
 error: transmute from a reference to a pointer
-  --> $DIR/transmutes_expressible_as_ptr_casts.rs:50:9
+  --> $DIR/transmutes_expressible_as_ptr_casts.rs:41:41
    |
-LL |         transmute::<&[i32; 4], *const [i32; 4]>(array_ref)
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `array_ref as *const [i32; 4]`
+LL |     let _array_ptr_transmute = unsafe { transmute::<&[i32; 4], *const [i32; 4]>(array_ref) };
+   |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `array_ref as *const [i32; 4]`
 
 error: transmute from `fn(usize) -> u8 {main::foo}` to `*const usize` which could be expressed as a pointer cast instead
-  --> $DIR/transmutes_expressible_as_ptr_casts.rs:58:9
+  --> $DIR/transmutes_expressible_as_ptr_casts.rs:49:41
    |
-LL |         transmute::<fn(usize) -> u8, *const usize>(foo)
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `foo as *const usize`
+LL |     let _usize_ptr_transmute = unsafe { transmute::<fn(usize) -> u8, *const usize>(foo) };
+   |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `foo as *const usize`
 
 error: transmute from `fn(usize) -> u8 {main::foo}` to `usize` which could be expressed as a pointer cast instead
-  --> $DIR/transmutes_expressible_as_ptr_casts.rs:64:9
+  --> $DIR/transmutes_expressible_as_ptr_casts.rs:53:49
    |
-LL |         transmute::<fn(usize) -> u8, usize>(foo)
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `foo as usize`
+LL |     let _usize_from_fn_ptr_transmute = unsafe { transmute::<fn(usize) -> u8, usize>(foo) };
+   |                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `foo as usize`
 
 error: transmute from a reference to a pointer
-  --> $DIR/transmutes_expressible_as_ptr_casts.rs:77:14
+  --> $DIR/transmutes_expressible_as_ptr_casts.rs:65:14
    |
 LL |     unsafe { transmute::<&[i32; 1], *const u8>(in_param) }
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `in_param as *const [i32; 1] as *const u8`
-- 
cgit 1.4.1-3-g733a5


From c0a9d64818d7076b72fd6c3a9e6172eca659034b Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Tue, 11 Aug 2020 11:50:26 +0200
Subject: stable-sort-primitive: make lint adhere to lint message convention

---
 clippy_lints/src/stable_sort_primitive.rs |  6 +++---
 tests/ui/stable_sort_primitive.stderr     | 14 +++++++-------
 2 files changed, 10 insertions(+), 10 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/stable_sort_primitive.rs b/clippy_lints/src/stable_sort_primitive.rs
index cd7056620a2..22c49a20451 100644
--- a/clippy_lints/src/stable_sort_primitive.rs
+++ b/clippy_lints/src/stable_sort_primitive.rs
@@ -111,9 +111,9 @@ impl LateLintPass<'_> for StableSortPrimitive {
                 STABLE_SORT_PRIMITIVE,
                 expr.span,
                 format!(
-                    "Use {} instead of {}",
-                    detection.method.unstable_name(),
-                    detection.method.stable_name()
+                    "used {} instead of {}",
+                    detection.method.stable_name(),
+                    detection.method.unstable_name()
                 )
                 .as_str(),
                 "try",
diff --git a/tests/ui/stable_sort_primitive.stderr b/tests/ui/stable_sort_primitive.stderr
index b0b729ede48..b73012a4691 100644
--- a/tests/ui/stable_sort_primitive.stderr
+++ b/tests/ui/stable_sort_primitive.stderr
@@ -1,4 +1,4 @@
-error: Use sort_unstable instead of sort
+error: used sort instead of sort_unstable
   --> $DIR/stable_sort_primitive.rs:7:5
    |
 LL |     vec.sort();
@@ -6,37 +6,37 @@ LL |     vec.sort();
    |
    = note: `-D clippy::stable-sort-primitive` implied by `-D warnings`
 
-error: Use sort_unstable instead of sort
+error: used sort instead of sort_unstable
   --> $DIR/stable_sort_primitive.rs:9:5
    |
 LL |     vec.sort();
    |     ^^^^^^^^^^ help: try: `vec.sort_unstable()`
 
-error: Use sort_unstable instead of sort
+error: used sort instead of sort_unstable
   --> $DIR/stable_sort_primitive.rs:11:5
    |
 LL |     vec.sort();
    |     ^^^^^^^^^^ help: try: `vec.sort_unstable()`
 
-error: Use sort_unstable instead of sort
+error: used sort instead of sort_unstable
   --> $DIR/stable_sort_primitive.rs:13:5
    |
 LL |     vec.sort();
    |     ^^^^^^^^^^ help: try: `vec.sort_unstable()`
 
-error: Use sort_unstable instead of sort
+error: used sort instead of sort_unstable
   --> $DIR/stable_sort_primitive.rs:15:5
    |
 LL |     vec.sort();
    |     ^^^^^^^^^^ help: try: `vec.sort_unstable()`
 
-error: Use sort_unstable instead of sort
+error: used sort instead of sort_unstable
   --> $DIR/stable_sort_primitive.rs:17:5
    |
 LL |     vec.sort();
    |     ^^^^^^^^^^ help: try: `vec.sort_unstable()`
 
-error: Use sort_unstable instead of sort
+error: used sort instead of sort_unstable
   --> $DIR/stable_sort_primitive.rs:19:5
    |
 LL |     arr.sort();
-- 
cgit 1.4.1-3-g733a5


From ac194cafc124276d4614bf023ca7ea6e9be9c6ed Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Tue, 11 Aug 2020 11:53:21 +0200
Subject: map_clone: make lint adhere to lint message convention

---
 clippy_lints/src/map_clone.rs | 12 ++++++------
 tests/ui/map_clone.stderr     | 24 ++++++++++++------------
 2 files changed, 18 insertions(+), 18 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/map_clone.rs b/clippy_lints/src/map_clone.rs
index 641e6a17043..1cd5b201292 100644
--- a/clippy_lints/src/map_clone.rs
+++ b/clippy_lints/src/map_clone.rs
@@ -111,8 +111,8 @@ fn lint_needless_cloning(cx: &LateContext<'_>, root: Span, receiver: Span) {
         cx,
         MAP_CLONE,
         root.trim_start(receiver).unwrap(),
-        "You are needlessly cloning iterator elements",
-        "Remove the `map` call",
+        "you are needlessly cloning iterator elements",
+        "remove the `map` call",
         String::new(),
         Applicability::MachineApplicable,
     )
@@ -125,8 +125,8 @@ fn lint(cx: &LateContext<'_>, replace: Span, root: Span, copied: bool) {
             cx,
             MAP_CLONE,
             replace,
-            "You are using an explicit closure for copying elements",
-            "Consider calling the dedicated `copied` method",
+            "you are using an explicit closure for copying elements",
+            "consider calling the dedicated `copied` method",
             format!(
                 "{}.copied()",
                 snippet_with_applicability(cx, root, "..", &mut applicability)
@@ -138,8 +138,8 @@ fn lint(cx: &LateContext<'_>, replace: Span, root: Span, copied: bool) {
             cx,
             MAP_CLONE,
             replace,
-            "You are using an explicit closure for cloning elements",
-            "Consider calling the dedicated `cloned` method",
+            "you are using an explicit closure for cloning elements",
+            "consider calling the dedicated `cloned` method",
             format!(
                 "{}.cloned()",
                 snippet_with_applicability(cx, root, "..", &mut applicability)
diff --git a/tests/ui/map_clone.stderr b/tests/ui/map_clone.stderr
index 9eec6928e8c..4f43cff5024 100644
--- a/tests/ui/map_clone.stderr
+++ b/tests/ui/map_clone.stderr
@@ -1,40 +1,40 @@
-error: You are using an explicit closure for copying elements
+error: you are using an explicit closure for copying elements
   --> $DIR/map_clone.rs:10:22
    |
 LL |     let _: Vec<i8> = vec![5_i8; 6].iter().map(|x| *x).collect();
-   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Consider calling the dedicated `copied` method: `vec![5_i8; 6].iter().copied()`
+   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling the dedicated `copied` method: `vec![5_i8; 6].iter().copied()`
    |
    = note: `-D clippy::map-clone` implied by `-D warnings`
 
-error: You are using an explicit closure for cloning elements
+error: you are using an explicit closure for cloning elements
   --> $DIR/map_clone.rs:11:26
    |
 LL |     let _: Vec<String> = vec![String::new()].iter().map(|x| x.clone()).collect();
-   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Consider calling the dedicated `cloned` method: `vec![String::new()].iter().cloned()`
+   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling the dedicated `cloned` method: `vec![String::new()].iter().cloned()`
 
-error: You are using an explicit closure for copying elements
+error: you are using an explicit closure for copying elements
   --> $DIR/map_clone.rs:12:23
    |
 LL |     let _: Vec<u32> = vec![42, 43].iter().map(|&x| x).collect();
-   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Consider calling the dedicated `copied` method: `vec![42, 43].iter().copied()`
+   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling the dedicated `copied` method: `vec![42, 43].iter().copied()`
 
-error: You are using an explicit closure for copying elements
+error: you are using an explicit closure for copying elements
   --> $DIR/map_clone.rs:14:26
    |
 LL |     let _: Option<u64> = Some(&16).map(|b| *b);
-   |                          ^^^^^^^^^^^^^^^^^^^^^ help: Consider calling the dedicated `copied` method: `Some(&16).copied()`
+   |                          ^^^^^^^^^^^^^^^^^^^^^ help: consider calling the dedicated `copied` method: `Some(&16).copied()`
 
-error: You are using an explicit closure for copying elements
+error: you are using an explicit closure for copying elements
   --> $DIR/map_clone.rs:15:25
    |
 LL |     let _: Option<u8> = Some(&1).map(|x| x.clone());
-   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Consider calling the dedicated `copied` method: `Some(&1).copied()`
+   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling the dedicated `copied` method: `Some(&1).copied()`
 
-error: You are needlessly cloning iterator elements
+error: you are needlessly cloning iterator elements
   --> $DIR/map_clone.rs:26:29
    |
 LL |     let _ = std::env::args().map(|v| v.clone());
-   |                             ^^^^^^^^^^^^^^^^^^^ help: Remove the `map` call
+   |                             ^^^^^^^^^^^^^^^^^^^ help: remove the `map` call
 
 error: aborting due to 6 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 04867e004ebc0f2edf66d0a457e785848451f13a Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Tue, 11 Aug 2020 12:10:42 +0200
Subject: mutex-atomic: make lint adhere to lint message convention

---
 clippy_lints/src/mutex_atomic.rs |  4 ++--
 tests/ui/mutex_atomic.stderr     | 14 +++++++-------
 2 files changed, 9 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/mutex_atomic.rs b/clippy_lints/src/mutex_atomic.rs
index 568898aa5c9..21efee71269 100644
--- a/clippy_lints/src/mutex_atomic.rs
+++ b/clippy_lints/src/mutex_atomic.rs
@@ -72,8 +72,8 @@ impl<'tcx> LateLintPass<'tcx> for Mutex {
                 let mutex_param = subst.type_at(0);
                 if let Some(atomic_name) = get_atomic_name(mutex_param) {
                     let msg = format!(
-                        "Consider using an `{}` instead of a `Mutex` here. If you just want the locking \
-                         behavior and not the internal type, consider using `Mutex<()>`.",
+                        "consider using an `{}` instead of a `Mutex` here; if you just want the locking \
+                         behavior and not the internal type, consider using `Mutex<()>`",
                         atomic_name
                     );
                     match mutex_param.kind {
diff --git a/tests/ui/mutex_atomic.stderr b/tests/ui/mutex_atomic.stderr
index 7dac0865855..a3511ba708a 100644
--- a/tests/ui/mutex_atomic.stderr
+++ b/tests/ui/mutex_atomic.stderr
@@ -1,4 +1,4 @@
-error: Consider using an `AtomicBool` instead of a `Mutex` here. If you just want the locking behavior and not the internal type, consider using `Mutex<()>`.
+error: consider using an `AtomicBool` instead of a `Mutex` here; if you just want the locking behavior and not the internal type, consider using `Mutex<()>`
   --> $DIR/mutex_atomic.rs:6:5
    |
 LL |     Mutex::new(true);
@@ -6,31 +6,31 @@ LL |     Mutex::new(true);
    |
    = note: `-D clippy::mutex-atomic` implied by `-D warnings`
 
-error: Consider using an `AtomicUsize` instead of a `Mutex` here. If you just want the locking behavior and not the internal type, consider using `Mutex<()>`.
+error: consider using an `AtomicUsize` instead of a `Mutex` here; if you just want the locking behavior and not the internal type, consider using `Mutex<()>`
   --> $DIR/mutex_atomic.rs:7:5
    |
 LL |     Mutex::new(5usize);
    |     ^^^^^^^^^^^^^^^^^^
 
-error: Consider using an `AtomicIsize` instead of a `Mutex` here. If you just want the locking behavior and not the internal type, consider using `Mutex<()>`.
+error: consider using an `AtomicIsize` instead of a `Mutex` here; if you just want the locking behavior and not the internal type, consider using `Mutex<()>`
   --> $DIR/mutex_atomic.rs:8:5
    |
 LL |     Mutex::new(9isize);
    |     ^^^^^^^^^^^^^^^^^^
 
-error: Consider using an `AtomicPtr` instead of a `Mutex` here. If you just want the locking behavior and not the internal type, consider using `Mutex<()>`.
+error: consider using an `AtomicPtr` instead of a `Mutex` here; if you just want the locking behavior and not the internal type, consider using `Mutex<()>`
   --> $DIR/mutex_atomic.rs:10:5
    |
 LL |     Mutex::new(&x as *const u32);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: Consider using an `AtomicPtr` instead of a `Mutex` here. If you just want the locking behavior and not the internal type, consider using `Mutex<()>`.
+error: consider using an `AtomicPtr` instead of a `Mutex` here; if you just want the locking behavior and not the internal type, consider using `Mutex<()>`
   --> $DIR/mutex_atomic.rs:11:5
    |
 LL |     Mutex::new(&mut x as *mut u32);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: Consider using an `AtomicUsize` instead of a `Mutex` here. If you just want the locking behavior and not the internal type, consider using `Mutex<()>`.
+error: consider using an `AtomicUsize` instead of a `Mutex` here; if you just want the locking behavior and not the internal type, consider using `Mutex<()>`
   --> $DIR/mutex_atomic.rs:12:5
    |
 LL |     Mutex::new(0u32);
@@ -38,7 +38,7 @@ LL |     Mutex::new(0u32);
    |
    = note: `-D clippy::mutex-integer` implied by `-D warnings`
 
-error: Consider using an `AtomicIsize` instead of a `Mutex` here. If you just want the locking behavior and not the internal type, consider using `Mutex<()>`.
+error: consider using an `AtomicIsize` instead of a `Mutex` here; if you just want the locking behavior and not the internal type, consider using `Mutex<()>`
   --> $DIR/mutex_atomic.rs:13:5
    |
 LL |     Mutex::new(0i32);
-- 
cgit 1.4.1-3-g733a5


From 6af297f80e59050c87078f1ba6f05c97d6f90fd7 Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Tue, 11 Aug 2020 12:42:50 +0200
Subject: iter-next-slice: make lint adhere to lint message convention

---
 clippy_lints/src/methods/mod.rs | 4 ++--
 tests/ui/iter_next_slice.stderr | 8 ++++----
 2 files changed, 6 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 570ae66d595..f4eb9c4516f 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -2280,7 +2280,7 @@ fn lint_iter_next<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, iter_
                     cx,
                     ITER_NEXT_SLICE,
                     expr.span,
-                    "Using `.iter().next()` on a Slice without end index.",
+                    "using `.iter().next()` on a Slice without end index",
                     "try calling",
                     format!("{}.get({})", snippet_with_applicability(cx, caller_var.span, "..", &mut applicability), start_idx),
                     applicability,
@@ -2299,7 +2299,7 @@ fn lint_iter_next<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, iter_
             cx,
             ITER_NEXT_SLICE,
             expr.span,
-            "Using `.iter().next()` on an array",
+            "using `.iter().next()` on an array",
             "try calling",
             format!(
                 "{}.get(0)",
diff --git a/tests/ui/iter_next_slice.stderr b/tests/ui/iter_next_slice.stderr
index bbf61df0cda..8c10a252ee0 100644
--- a/tests/ui/iter_next_slice.stderr
+++ b/tests/ui/iter_next_slice.stderr
@@ -1,4 +1,4 @@
-error: Using `.iter().next()` on an array
+error: using `.iter().next()` on an array
   --> $DIR/iter_next_slice.rs:9:5
    |
 LL |     s.iter().next();
@@ -6,19 +6,19 @@ LL |     s.iter().next();
    |
    = note: `-D clippy::iter-next-slice` implied by `-D warnings`
 
-error: Using `.iter().next()` on a Slice without end index.
+error: using `.iter().next()` on a Slice without end index
   --> $DIR/iter_next_slice.rs:12:5
    |
 LL |     s[2..].iter().next();
    |     ^^^^^^^^^^^^^^^^^^^^ help: try calling: `s.get(2)`
 
-error: Using `.iter().next()` on a Slice without end index.
+error: using `.iter().next()` on a Slice without end index
   --> $DIR/iter_next_slice.rs:15:5
    |
 LL |     v[5..].iter().next();
    |     ^^^^^^^^^^^^^^^^^^^^ help: try calling: `v.get(5)`
 
-error: Using `.iter().next()` on an array
+error: using `.iter().next()` on an array
   --> $DIR/iter_next_slice.rs:18:5
    |
 LL |     v.iter().next();
-- 
cgit 1.4.1-3-g733a5


From f171f89aed11043e459c3baab305e7f859debb94 Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Tue, 11 Aug 2020 15:14:32 +0200
Subject: int_plus_one: make lint adhere to lint message convention

---
 clippy_lints/src/int_plus_one.rs | 6 +++---
 tests/ui/int_plus_one.stderr     | 8 ++++----
 2 files changed, 7 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/int_plus_one.rs b/clippy_lints/src/int_plus_one.rs
index e91fb0c2f27..c629ee05ab9 100644
--- a/clippy_lints/src/int_plus_one.rs
+++ b/clippy_lints/src/int_plus_one.rs
@@ -152,7 +152,7 @@ impl IntPlusOne {
             cx,
             INT_PLUS_ONE,
             block.span,
-            "Unnecessary `>= y + 1` or `x - 1 >=`",
+            "unnecessary `>= y + 1` or `x - 1 >=`",
             "change it to",
             recommendation,
             Applicability::MachineApplicable, // snippet
@@ -163,8 +163,8 @@ impl IntPlusOne {
 impl EarlyLintPass for IntPlusOne {
     fn check_expr(&mut self, cx: &EarlyContext<'_>, item: &Expr) {
         if let ExprKind::Binary(ref kind, ref lhs, ref rhs) = item.kind {
-            if let Some(ref rec) = Self::check_binop(cx, kind.node, lhs, rhs) {
-                Self::emit_warning(cx, item, rec.clone());
+            if let Some(rec) = Self::check_binop(cx, kind.node, lhs, rhs) {
+                Self::emit_warning(cx, item, rec);
             }
         }
     }
diff --git a/tests/ui/int_plus_one.stderr b/tests/ui/int_plus_one.stderr
index 29a6914761c..c5b020ba8ce 100644
--- a/tests/ui/int_plus_one.stderr
+++ b/tests/ui/int_plus_one.stderr
@@ -1,4 +1,4 @@
-error: Unnecessary `>= y + 1` or `x - 1 >=`
+error: unnecessary `>= y + 1` or `x - 1 >=`
   --> $DIR/int_plus_one.rs:9:13
    |
 LL |     let _ = x >= y + 1;
@@ -6,19 +6,19 @@ LL |     let _ = x >= y + 1;
    |
    = note: `-D clippy::int-plus-one` implied by `-D warnings`
 
-error: Unnecessary `>= y + 1` or `x - 1 >=`
+error: unnecessary `>= y + 1` or `x - 1 >=`
   --> $DIR/int_plus_one.rs:10:13
    |
 LL |     let _ = y + 1 <= x;
    |             ^^^^^^^^^^ help: change it to: `y < x`
 
-error: Unnecessary `>= y + 1` or `x - 1 >=`
+error: unnecessary `>= y + 1` or `x - 1 >=`
   --> $DIR/int_plus_one.rs:12:13
    |
 LL |     let _ = x - 1 >= y;
    |             ^^^^^^^^^^ help: change it to: `x > y`
 
-error: Unnecessary `>= y + 1` or `x - 1 >=`
+error: unnecessary `>= y + 1` or `x - 1 >=`
   --> $DIR/int_plus_one.rs:13:13
    |
 LL |     let _ = y <= x - 1;
-- 
cgit 1.4.1-3-g733a5


From bdf4dc3abd9a49f699d9de209a1f4d55ce770191 Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Tue, 11 Aug 2020 15:22:59 +0200
Subject: implicit-saturating-sub: make lint adhere to lint message convention

---
 clippy_lints/src/implicit_saturating_sub.rs |  4 +--
 tests/ui/implicit_saturating_sub.stderr     | 46 ++++++++++++++---------------
 2 files changed, 25 insertions(+), 25 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/implicit_saturating_sub.rs b/clippy_lints/src/implicit_saturating_sub.rs
index 5f931a0adde..b57fe8dc426 100644
--- a/clippy_lints/src/implicit_saturating_sub.rs
+++ b/clippy_lints/src/implicit_saturating_sub.rs
@@ -158,9 +158,9 @@ fn print_lint_and_sugg(cx: &LateContext<'_>, var_name: &str, expr: &Expr<'_>) {
         cx,
         IMPLICIT_SATURATING_SUB,
         expr.span,
-        "Implicitly performing saturating subtraction",
+        "implicitly performing saturating subtraction",
         "try",
-        format!("{} = {}.saturating_sub({});", var_name, var_name, 1.to_string()),
+        format!("{} = {}.saturating_sub({});", var_name, var_name, '1'),
         Applicability::MachineApplicable,
     );
 }
diff --git a/tests/ui/implicit_saturating_sub.stderr b/tests/ui/implicit_saturating_sub.stderr
index 2eb2023b3b9..5bb9a606422 100644
--- a/tests/ui/implicit_saturating_sub.stderr
+++ b/tests/ui/implicit_saturating_sub.stderr
@@ -1,4 +1,4 @@
-error: Implicitly performing saturating subtraction
+error: implicitly performing saturating subtraction
   --> $DIR/implicit_saturating_sub.rs:13:5
    |
 LL | /     if u_8 > 0 {
@@ -8,7 +8,7 @@ LL | |     }
    |
    = note: `-D clippy::implicit-saturating-sub` implied by `-D warnings`
 
-error: Implicitly performing saturating subtraction
+error: implicitly performing saturating subtraction
   --> $DIR/implicit_saturating_sub.rs:20:13
    |
 LL | /             if u_8 > 0 {
@@ -16,7 +16,7 @@ LL | |                 u_8 -= 1;
 LL | |             }
    | |_____________^ help: try: `u_8 = u_8.saturating_sub(1);`
 
-error: Implicitly performing saturating subtraction
+error: implicitly performing saturating subtraction
   --> $DIR/implicit_saturating_sub.rs:34:5
    |
 LL | /     if u_16 > 0 {
@@ -24,7 +24,7 @@ LL | |         u_16 -= 1;
 LL | |     }
    | |_____^ help: try: `u_16 = u_16.saturating_sub(1);`
 
-error: Implicitly performing saturating subtraction
+error: implicitly performing saturating subtraction
   --> $DIR/implicit_saturating_sub.rs:44:5
    |
 LL | /     if u_32 != 0 {
@@ -32,7 +32,7 @@ LL | |         u_32 -= 1;
 LL | |     }
    | |_____^ help: try: `u_32 = u_32.saturating_sub(1);`
 
-error: Implicitly performing saturating subtraction
+error: implicitly performing saturating subtraction
   --> $DIR/implicit_saturating_sub.rs:65:5
    |
 LL | /     if u_64 > 0 {
@@ -40,7 +40,7 @@ LL | |         u_64 -= 1;
 LL | |     }
    | |_____^ help: try: `u_64 = u_64.saturating_sub(1);`
 
-error: Implicitly performing saturating subtraction
+error: implicitly performing saturating subtraction
   --> $DIR/implicit_saturating_sub.rs:70:5
    |
 LL | /     if 0 < u_64 {
@@ -48,7 +48,7 @@ LL | |         u_64 -= 1;
 LL | |     }
    | |_____^ help: try: `u_64 = u_64.saturating_sub(1);`
 
-error: Implicitly performing saturating subtraction
+error: implicitly performing saturating subtraction
   --> $DIR/implicit_saturating_sub.rs:75:5
    |
 LL | /     if 0 != u_64 {
@@ -56,7 +56,7 @@ LL | |         u_64 -= 1;
 LL | |     }
    | |_____^ help: try: `u_64 = u_64.saturating_sub(1);`
 
-error: Implicitly performing saturating subtraction
+error: implicitly performing saturating subtraction
   --> $DIR/implicit_saturating_sub.rs:96:5
    |
 LL | /     if u_usize > 0 {
@@ -64,7 +64,7 @@ LL | |         u_usize -= 1;
 LL | |     }
    | |_____^ help: try: `u_usize = u_usize.saturating_sub(1);`
 
-error: Implicitly performing saturating subtraction
+error: implicitly performing saturating subtraction
   --> $DIR/implicit_saturating_sub.rs:108:5
    |
 LL | /     if i_8 > i8::MIN {
@@ -72,7 +72,7 @@ LL | |         i_8 -= 1;
 LL | |     }
    | |_____^ help: try: `i_8 = i_8.saturating_sub(1);`
 
-error: Implicitly performing saturating subtraction
+error: implicitly performing saturating subtraction
   --> $DIR/implicit_saturating_sub.rs:113:5
    |
 LL | /     if i_8 > i8::MIN {
@@ -80,7 +80,7 @@ LL | |         i_8 -= 1;
 LL | |     }
    | |_____^ help: try: `i_8 = i_8.saturating_sub(1);`
 
-error: Implicitly performing saturating subtraction
+error: implicitly performing saturating subtraction
   --> $DIR/implicit_saturating_sub.rs:118:5
    |
 LL | /     if i_8 != i8::MIN {
@@ -88,7 +88,7 @@ LL | |         i_8 -= 1;
 LL | |     }
    | |_____^ help: try: `i_8 = i_8.saturating_sub(1);`
 
-error: Implicitly performing saturating subtraction
+error: implicitly performing saturating subtraction
   --> $DIR/implicit_saturating_sub.rs:123:5
    |
 LL | /     if i_8 != i8::MIN {
@@ -96,7 +96,7 @@ LL | |         i_8 -= 1;
 LL | |     }
    | |_____^ help: try: `i_8 = i_8.saturating_sub(1);`
 
-error: Implicitly performing saturating subtraction
+error: implicitly performing saturating subtraction
   --> $DIR/implicit_saturating_sub.rs:133:5
    |
 LL | /     if i_16 > i16::MIN {
@@ -104,7 +104,7 @@ LL | |         i_16 -= 1;
 LL | |     }
    | |_____^ help: try: `i_16 = i_16.saturating_sub(1);`
 
-error: Implicitly performing saturating subtraction
+error: implicitly performing saturating subtraction
   --> $DIR/implicit_saturating_sub.rs:138:5
    |
 LL | /     if i_16 > i16::MIN {
@@ -112,7 +112,7 @@ LL | |         i_16 -= 1;
 LL | |     }
    | |_____^ help: try: `i_16 = i_16.saturating_sub(1);`
 
-error: Implicitly performing saturating subtraction
+error: implicitly performing saturating subtraction
   --> $DIR/implicit_saturating_sub.rs:143:5
    |
 LL | /     if i_16 != i16::MIN {
@@ -120,7 +120,7 @@ LL | |         i_16 -= 1;
 LL | |     }
    | |_____^ help: try: `i_16 = i_16.saturating_sub(1);`
 
-error: Implicitly performing saturating subtraction
+error: implicitly performing saturating subtraction
   --> $DIR/implicit_saturating_sub.rs:148:5
    |
 LL | /     if i_16 != i16::MIN {
@@ -128,7 +128,7 @@ LL | |         i_16 -= 1;
 LL | |     }
    | |_____^ help: try: `i_16 = i_16.saturating_sub(1);`
 
-error: Implicitly performing saturating subtraction
+error: implicitly performing saturating subtraction
   --> $DIR/implicit_saturating_sub.rs:158:5
    |
 LL | /     if i_32 > i32::MIN {
@@ -136,7 +136,7 @@ LL | |         i_32 -= 1;
 LL | |     }
    | |_____^ help: try: `i_32 = i_32.saturating_sub(1);`
 
-error: Implicitly performing saturating subtraction
+error: implicitly performing saturating subtraction
   --> $DIR/implicit_saturating_sub.rs:163:5
    |
 LL | /     if i_32 > i32::MIN {
@@ -144,7 +144,7 @@ LL | |         i_32 -= 1;
 LL | |     }
    | |_____^ help: try: `i_32 = i_32.saturating_sub(1);`
 
-error: Implicitly performing saturating subtraction
+error: implicitly performing saturating subtraction
   --> $DIR/implicit_saturating_sub.rs:168:5
    |
 LL | /     if i_32 != i32::MIN {
@@ -152,7 +152,7 @@ LL | |         i_32 -= 1;
 LL | |     }
    | |_____^ help: try: `i_32 = i_32.saturating_sub(1);`
 
-error: Implicitly performing saturating subtraction
+error: implicitly performing saturating subtraction
   --> $DIR/implicit_saturating_sub.rs:173:5
    |
 LL | /     if i_32 != i32::MIN {
@@ -160,7 +160,7 @@ LL | |         i_32 -= 1;
 LL | |     }
    | |_____^ help: try: `i_32 = i_32.saturating_sub(1);`
 
-error: Implicitly performing saturating subtraction
+error: implicitly performing saturating subtraction
   --> $DIR/implicit_saturating_sub.rs:183:5
    |
 LL | /     if i64::MIN < i_64 {
@@ -168,7 +168,7 @@ LL | |         i_64 -= 1;
 LL | |     }
    | |_____^ help: try: `i_64 = i_64.saturating_sub(1);`
 
-error: Implicitly performing saturating subtraction
+error: implicitly performing saturating subtraction
   --> $DIR/implicit_saturating_sub.rs:188:5
    |
 LL | /     if i64::MIN != i_64 {
@@ -176,7 +176,7 @@ LL | |         i_64 -= 1;
 LL | |     }
    | |_____^ help: try: `i_64 = i_64.saturating_sub(1);`
 
-error: Implicitly performing saturating subtraction
+error: implicitly performing saturating subtraction
   --> $DIR/implicit_saturating_sub.rs:193:5
    |
 LL | /     if i64::MIN < i_64 {
-- 
cgit 1.4.1-3-g733a5


From 1f17c3b02bce95c7c95a320e9e6e8e88b216d235 Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Tue, 11 Aug 2020 15:28:51 +0200
Subject: multiple_inherent_impl: make lint adhere to lint message convention

---
 clippy_lints/src/inherent_impl.rs | 4 ++--
 tests/ui/impl.stderr              | 8 ++++----
 2 files changed, 6 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/inherent_impl.rs b/clippy_lints/src/inherent_impl.rs
index 9fb10c7f627..4e6bb604785 100644
--- a/clippy_lints/src/inherent_impl.rs
+++ b/clippy_lints/src/inherent_impl.rs
@@ -81,9 +81,9 @@ impl<'tcx> LateLintPass<'tcx> for MultipleInherentImpl {
                             cx,
                             MULTIPLE_INHERENT_IMPL,
                             *additional_span,
-                            "Multiple implementations of this structure",
+                            "multiple implementations of this structure",
                             |diag| {
-                                diag.span_note(*initial_span, "First implementation here");
+                                diag.span_note(*initial_span, "first implementation here");
                             },
                         )
                     })
diff --git a/tests/ui/impl.stderr b/tests/ui/impl.stderr
index 585d32845d2..aab688cc2d8 100644
--- a/tests/ui/impl.stderr
+++ b/tests/ui/impl.stderr
@@ -1,4 +1,4 @@
-error: Multiple implementations of this structure
+error: multiple implementations of this structure
   --> $DIR/impl.rs:10:1
    |
 LL | / impl MyStruct {
@@ -7,7 +7,7 @@ LL | | }
    | |_^
    |
    = note: `-D clippy::multiple-inherent-impl` implied by `-D warnings`
-note: First implementation here
+note: first implementation here
   --> $DIR/impl.rs:6:1
    |
 LL | / impl MyStruct {
@@ -15,7 +15,7 @@ LL | |     fn first() {}
 LL | | }
    | |_^
 
-error: Multiple implementations of this structure
+error: multiple implementations of this structure
   --> $DIR/impl.rs:24:5
    |
 LL | /     impl super::MyStruct {
@@ -23,7 +23,7 @@ LL | |         fn third() {}
 LL | |     }
    | |_____^
    |
-note: First implementation here
+note: first implementation here
   --> $DIR/impl.rs:6:1
    |
 LL | / impl MyStruct {
-- 
cgit 1.4.1-3-g733a5


From 423615693ba27f77f2e01a82948bbe592f48f6d0 Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Tue, 11 Aug 2020 16:28:05 +0200
Subject: pub-enum-variant-names: make lint adhere to lint message convention

---
 clippy_lints/src/enum_variants.rs |  2 +-
 tests/ui/enum_variants.stderr     | 12 ++++++------
 2 files changed, 7 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/enum_variants.rs b/clippy_lints/src/enum_variants.rs
index cb0fd59a2d4..d73d0f1752e 100644
--- a/clippy_lints/src/enum_variants.rs
+++ b/clippy_lints/src/enum_variants.rs
@@ -227,7 +227,7 @@ fn check_variant(
         cx,
         lint,
         span,
-        &format!("All variants have the same {}fix: `{}`", what, value),
+        &format!("all variants have the same {}fix: `{}`", what, value),
         None,
         &format!(
             "remove the {}fixes and use full paths to \
diff --git a/tests/ui/enum_variants.stderr b/tests/ui/enum_variants.stderr
index 2835391de7f..3aa0e4ddcfe 100644
--- a/tests/ui/enum_variants.stderr
+++ b/tests/ui/enum_variants.stderr
@@ -24,7 +24,7 @@ error: Variant name starts with the enum's name
 LL |     FoodBad,
    |     ^^^^^^^
 
-error: All variants have the same prefix: `Food`
+error: all variants have the same prefix: `Food`
   --> $DIR/enum_variants.rs:26:1
    |
 LL | / enum Food {
@@ -36,7 +36,7 @@ LL | | }
    |
    = help: remove the prefixes and use full paths to the variants instead of glob imports
 
-error: All variants have the same prefix: `CallType`
+error: all variants have the same prefix: `CallType`
   --> $DIR/enum_variants.rs:36:1
    |
 LL | / enum BadCallType {
@@ -48,7 +48,7 @@ LL | | }
    |
    = help: remove the prefixes and use full paths to the variants instead of glob imports
 
-error: All variants have the same prefix: `Constant`
+error: all variants have the same prefix: `Constant`
   --> $DIR/enum_variants.rs:48:1
    |
 LL | / enum Consts {
@@ -60,7 +60,7 @@ LL | | }
    |
    = help: remove the prefixes and use full paths to the variants instead of glob imports
 
-error: All variants have the same prefix: `With`
+error: all variants have the same prefix: `With`
   --> $DIR/enum_variants.rs:82:1
    |
 LL | / enum Seallll {
@@ -72,7 +72,7 @@ LL | | }
    |
    = help: remove the prefixes and use full paths to the variants instead of glob imports
 
-error: All variants have the same prefix: `Prefix`
+error: all variants have the same prefix: `Prefix`
   --> $DIR/enum_variants.rs:88:1
    |
 LL | / enum NonCaps {
@@ -84,7 +84,7 @@ LL | | }
    |
    = help: remove the prefixes and use full paths to the variants instead of glob imports
 
-error: All variants have the same prefix: `With`
+error: all variants have the same prefix: `With`
   --> $DIR/enum_variants.rs:94:1
    |
 LL | / pub enum PubSeall {
-- 
cgit 1.4.1-3-g733a5


From 2de290d5c5e1d2f0c0f112a51f0cba2e0cb91636 Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Tue, 11 Aug 2020 16:31:02 +0200
Subject: duration-subsec: make lint adhere to lint message convention

---
 clippy_lints/src/duration_subsec.rs |  2 +-
 tests/ui/duration_subsec.stderr     | 10 +++++-----
 2 files changed, 6 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/duration_subsec.rs b/clippy_lints/src/duration_subsec.rs
index 1dfb2eaa579..8ece44878fe 100644
--- a/clippy_lints/src/duration_subsec.rs
+++ b/clippy_lints/src/duration_subsec.rs
@@ -56,7 +56,7 @@ impl<'tcx> LateLintPass<'tcx> for DurationSubsec {
                     cx,
                     DURATION_SUBSEC,
                     expr.span,
-                    &format!("Calling `{}()` is more concise than this calculation", suggested_fn),
+                    &format!("calling `{}()` is more concise than this calculation", suggested_fn),
                     "try",
                     format!(
                         "{}.{}()",
diff --git a/tests/ui/duration_subsec.stderr b/tests/ui/duration_subsec.stderr
index bd8adc2c570..cdbeff6a037 100644
--- a/tests/ui/duration_subsec.stderr
+++ b/tests/ui/duration_subsec.stderr
@@ -1,4 +1,4 @@
-error: Calling `subsec_millis()` is more concise than this calculation
+error: calling `subsec_millis()` is more concise than this calculation
   --> $DIR/duration_subsec.rs:10:24
    |
 LL |     let bad_millis_1 = dur.subsec_micros() / 1_000;
@@ -6,25 +6,25 @@ LL |     let bad_millis_1 = dur.subsec_micros() / 1_000;
    |
    = note: `-D clippy::duration-subsec` implied by `-D warnings`
 
-error: Calling `subsec_millis()` is more concise than this calculation
+error: calling `subsec_millis()` is more concise than this calculation
   --> $DIR/duration_subsec.rs:11:24
    |
 LL |     let bad_millis_2 = dur.subsec_nanos() / 1_000_000;
    |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `dur.subsec_millis()`
 
-error: Calling `subsec_micros()` is more concise than this calculation
+error: calling `subsec_micros()` is more concise than this calculation
   --> $DIR/duration_subsec.rs:16:22
    |
 LL |     let bad_micros = dur.subsec_nanos() / 1_000;
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `dur.subsec_micros()`
 
-error: Calling `subsec_micros()` is more concise than this calculation
+error: calling `subsec_micros()` is more concise than this calculation
   --> $DIR/duration_subsec.rs:21:13
    |
 LL |     let _ = (&dur).subsec_nanos() / 1_000;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `(&dur).subsec_micros()`
 
-error: Calling `subsec_micros()` is more concise than this calculation
+error: calling `subsec_micros()` is more concise than this calculation
   --> $DIR/duration_subsec.rs:25:13
    |
 LL |     let _ = dur.subsec_nanos() / NANOS_IN_MICRO;
-- 
cgit 1.4.1-3-g733a5


From db390f5e6a2e68a0f9e0d235f2b734e907cafef9 Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Tue, 11 Aug 2020 16:35:09 +0200
Subject: enum-clike-unportable-variant: tweak message a bit (Clike -> C-like)

---
 clippy_lints/src/enum_clike.rs                |  2 +-
 tests/ui/enum_clike_unportable_variant.stderr | 18 +++++++++---------
 2 files changed, 10 insertions(+), 10 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/enum_clike.rs b/clippy_lints/src/enum_clike.rs
index 91214f277be..48caf48dbdb 100644
--- a/clippy_lints/src/enum_clike.rs
+++ b/clippy_lints/src/enum_clike.rs
@@ -72,7 +72,7 @@ impl<'tcx> LateLintPass<'tcx> for UnportableVariant {
                             cx,
                             ENUM_CLIKE_UNPORTABLE_VARIANT,
                             var.span,
-                            "Clike enum variant discriminant is not portable to 32-bit targets",
+                            "C-like enum variant discriminant is not portable to 32-bit targets",
                         );
                     };
                 }
diff --git a/tests/ui/enum_clike_unportable_variant.stderr b/tests/ui/enum_clike_unportable_variant.stderr
index 71f3f5e083e..5935eea5e03 100644
--- a/tests/ui/enum_clike_unportable_variant.stderr
+++ b/tests/ui/enum_clike_unportable_variant.stderr
@@ -1,4 +1,4 @@
-error: Clike enum variant discriminant is not portable to 32-bit targets
+error: C-like enum variant discriminant is not portable to 32-bit targets
   --> $DIR/enum_clike_unportable_variant.rs:8:5
    |
 LL |     X = 0x1_0000_0000,
@@ -6,49 +6,49 @@ LL |     X = 0x1_0000_0000,
    |
    = note: `-D clippy::enum-clike-unportable-variant` implied by `-D warnings`
 
-error: Clike enum variant discriminant is not portable to 32-bit targets
+error: C-like enum variant discriminant is not portable to 32-bit targets
   --> $DIR/enum_clike_unportable_variant.rs:15:5
    |
 LL |     X = 0x1_0000_0000,
    |     ^^^^^^^^^^^^^^^^^
 
-error: Clike enum variant discriminant is not portable to 32-bit targets
+error: C-like enum variant discriminant is not portable to 32-bit targets
   --> $DIR/enum_clike_unportable_variant.rs:18:5
    |
 LL |     A = 0xFFFF_FFFF,
    |     ^^^^^^^^^^^^^^^
 
-error: Clike enum variant discriminant is not portable to 32-bit targets
+error: C-like enum variant discriminant is not portable to 32-bit targets
   --> $DIR/enum_clike_unportable_variant.rs:25:5
    |
 LL |     Z = 0xFFFF_FFFF,
    |     ^^^^^^^^^^^^^^^
 
-error: Clike enum variant discriminant is not portable to 32-bit targets
+error: C-like enum variant discriminant is not portable to 32-bit targets
   --> $DIR/enum_clike_unportable_variant.rs:26:5
    |
 LL |     A = 0x1_0000_0000,
    |     ^^^^^^^^^^^^^^^^^
 
-error: Clike enum variant discriminant is not portable to 32-bit targets
+error: C-like enum variant discriminant is not portable to 32-bit targets
   --> $DIR/enum_clike_unportable_variant.rs:28:5
    |
 LL |     C = (i32::MIN as isize) - 1,
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: Clike enum variant discriminant is not portable to 32-bit targets
+error: C-like enum variant discriminant is not portable to 32-bit targets
   --> $DIR/enum_clike_unportable_variant.rs:34:5
    |
 LL |     Z = 0xFFFF_FFFF,
    |     ^^^^^^^^^^^^^^^
 
-error: Clike enum variant discriminant is not portable to 32-bit targets
+error: C-like enum variant discriminant is not portable to 32-bit targets
   --> $DIR/enum_clike_unportable_variant.rs:35:5
    |
 LL |     A = 0x1_0000_0000,
    |     ^^^^^^^^^^^^^^^^^
 
-error: Clike enum variant discriminant is not portable to 32-bit targets
+error: C-like enum variant discriminant is not portable to 32-bit targets
   --> $DIR/enum_clike_unportable_variant.rs:40:5
    |
 LL |     X = <usize as Trait>::Number,
-- 
cgit 1.4.1-3-g733a5


From 89591a78b83df30830bcc8f6fe57f6fe1fbf918e Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Tue, 11 Aug 2020 16:38:20 +0200
Subject: enum-variant-names: make lint adhere to lint message convention

---
 clippy_lints/src/enum_variants.rs | 4 ++--
 tests/ui/enum_variants.stderr     | 8 ++++----
 2 files changed, 6 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/enum_variants.rs b/clippy_lints/src/enum_variants.rs
index d73d0f1752e..a9294a87f15 100644
--- a/clippy_lints/src/enum_variants.rs
+++ b/clippy_lints/src/enum_variants.rs
@@ -183,10 +183,10 @@ fn check_variant(
             && name.chars().nth(item_name_chars).map_or(false, |c| !c.is_lowercase())
             && name.chars().nth(item_name_chars + 1).map_or(false, |c| !c.is_numeric())
         {
-            span_lint(cx, lint, var.span, "Variant name starts with the enum's name");
+            span_lint(cx, lint, var.span, "variant name starts with the enum's name");
         }
         if partial_rmatch(item_name, &name) == item_name_chars {
-            span_lint(cx, lint, var.span, "Variant name ends with the enum's name");
+            span_lint(cx, lint, var.span, "variant name ends with the enum's name");
         }
     }
     let first = &def.variants[0].ident.name.as_str();
diff --git a/tests/ui/enum_variants.stderr b/tests/ui/enum_variants.stderr
index 3aa0e4ddcfe..b1d481190ff 100644
--- a/tests/ui/enum_variants.stderr
+++ b/tests/ui/enum_variants.stderr
@@ -1,4 +1,4 @@
-error: Variant name ends with the enum's name
+error: variant name ends with the enum's name
   --> $DIR/enum_variants.rs:16:5
    |
 LL |     cFoo,
@@ -6,19 +6,19 @@ LL |     cFoo,
    |
    = note: `-D clippy::enum-variant-names` implied by `-D warnings`
 
-error: Variant name starts with the enum's name
+error: variant name starts with the enum's name
   --> $DIR/enum_variants.rs:27:5
    |
 LL |     FoodGood,
    |     ^^^^^^^^
 
-error: Variant name starts with the enum's name
+error: variant name starts with the enum's name
   --> $DIR/enum_variants.rs:28:5
    |
 LL |     FoodMiddle,
    |     ^^^^^^^^^^
 
-error: Variant name starts with the enum's name
+error: variant name starts with the enum's name
   --> $DIR/enum_variants.rs:29:5
    |
 LL |     FoodBad,
-- 
cgit 1.4.1-3-g733a5


From 605e027fda4420669784864940abcbabef5b0efe Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Tue, 11 Aug 2020 16:40:45 +0200
Subject: if_let_some_result: make lint adhere to lint message convention

---
 clippy_lints/src/if_let_some_result.rs | 4 ++--
 tests/ui/if_let_some_result.stderr     | 8 ++++----
 2 files changed, 6 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/if_let_some_result.rs b/clippy_lints/src/if_let_some_result.rs
index 5b22df5fe49..28b20cdeac3 100644
--- a/clippy_lints/src/if_let_some_result.rs
+++ b/clippy_lints/src/if_let_some_result.rs
@@ -61,8 +61,8 @@ impl<'tcx> LateLintPass<'tcx> for OkIfLet {
                     cx,
                     IF_LET_SOME_RESULT,
                     expr.span.with_hi(op.span.hi()),
-                    "Matching on `Some` with `ok()` is redundant",
-                    &format!("Consider matching on `Ok({})` and removing the call to `ok` instead", some_expr_string),
+                    "matching on `Some` with `ok()` is redundant",
+                    &format!("consider matching on `Ok({})` and removing the call to `ok` instead", some_expr_string),
                     sugg,
                     applicability,
                 );
diff --git a/tests/ui/if_let_some_result.stderr b/tests/ui/if_let_some_result.stderr
index 334ccb01016..6afee0f36b9 100644
--- a/tests/ui/if_let_some_result.stderr
+++ b/tests/ui/if_let_some_result.stderr
@@ -1,22 +1,22 @@
-error: Matching on `Some` with `ok()` is redundant
+error: matching on `Some` with `ok()` is redundant
   --> $DIR/if_let_some_result.rs:6:5
    |
 LL |     if let Some(y) = x.parse().ok() {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::if-let-some-result` implied by `-D warnings`
-help: Consider matching on `Ok(y)` and removing the call to `ok` instead
+help: consider matching on `Ok(y)` and removing the call to `ok` instead
    |
 LL |     if let Ok(y) = x.parse() {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: Matching on `Some` with `ok()` is redundant
+error: matching on `Some` with `ok()` is redundant
   --> $DIR/if_let_some_result.rs:24:9
    |
 LL |         if let Some(y) = x   .   parse()   .   ok   ()    {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-help: Consider matching on `Ok(y)` and removing the call to `ok` instead
+help: consider matching on `Ok(y)` and removing the call to `ok` instead
    |
 LL |         if let Ok(y) = x   .   parse()       {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From be3e695b60b07e911a88f6cb660c5617836c5365 Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Tue, 11 Aug 2020 16:43:53 +0200
Subject: if_not_else: make lint adhere to lint message convention

---
 clippy_lints/src/if_not_else.rs | 4 ++--
 clippy_lints/src/use_self.rs    | 2 +-
 src/lintlist/mod.rs             | 2 +-
 tests/ui/if_not_else.stderr     | 4 ++--
 4 files changed, 6 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/if_not_else.rs b/clippy_lints/src/if_not_else.rs
index c11e291f98e..b86d2e76656 100644
--- a/clippy_lints/src/if_not_else.rs
+++ b/clippy_lints/src/if_not_else.rs
@@ -60,7 +60,7 @@ impl EarlyLintPass for IfNotElse {
                             cx,
                             IF_NOT_ELSE,
                             item.span,
-                            "Unnecessary boolean `not` operation",
+                            "unnecessary boolean `not` operation",
                             None,
                             "remove the `!` and swap the blocks of the `if`/`else`",
                         );
@@ -70,7 +70,7 @@ impl EarlyLintPass for IfNotElse {
                             cx,
                             IF_NOT_ELSE,
                             item.span,
-                            "Unnecessary `!=` operation",
+                            "unnecessary `!=` operation",
                             None,
                             "change to `==` and swap the blocks of the `if`/`else`",
                         );
diff --git a/clippy_lints/src/use_self.rs b/clippy_lints/src/use_self.rs
index 776c6bc57ca..427a1b65773 100644
--- a/clippy_lints/src/use_self.rs
+++ b/clippy_lints/src/use_self.rs
@@ -50,7 +50,7 @@ declare_clippy_lint! {
     /// ```
     pub USE_SELF,
     nursery,
-    "Unnecessary structure name repetition whereas `Self` is applicable"
+    "unnecessary structure name repetition whereas `Self` is applicable"
 }
 
 declare_lint_pass!(UseSelf => [USE_SELF]);
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index bbb300296be..ccc9e250952 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -2498,7 +2498,7 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
     Lint {
         name: "use_self",
         group: "nursery",
-        desc: "Unnecessary structure name repetition whereas `Self` is applicable",
+        desc: "unnecessary structure name repetition whereas `Self` is applicable",
         deprecation: None,
         module: "use_self",
     },
diff --git a/tests/ui/if_not_else.stderr b/tests/ui/if_not_else.stderr
index 78bc4d4bd20..53d1b86d02a 100644
--- a/tests/ui/if_not_else.stderr
+++ b/tests/ui/if_not_else.stderr
@@ -1,4 +1,4 @@
-error: Unnecessary boolean `not` operation
+error: unnecessary boolean `not` operation
   --> $DIR/if_not_else.rs:9:5
    |
 LL | /     if !bla() {
@@ -11,7 +11,7 @@ LL | |     }
    = note: `-D clippy::if-not-else` implied by `-D warnings`
    = help: remove the `!` and swap the blocks of the `if`/`else`
 
-error: Unnecessary `!=` operation
+error: unnecessary `!=` operation
   --> $DIR/if_not_else.rs:14:5
    |
 LL | /     if 4 != 5 {
-- 
cgit 1.4.1-3-g733a5


From 8a96b9cdfe408106fff94745fee1223b2e3ddb26 Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Wed, 12 Aug 2020 14:27:06 +0200
Subject: write.rs: don't clone TokenStream

---
 clippy_lints/src/write.rs | 16 +++++-----------
 1 file changed, 5 insertions(+), 11 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs
index 063f94582b9..5f88dcb188a 100644
--- a/clippy_lints/src/write.rs
+++ b/clippy_lints/src/write.rs
@@ -237,7 +237,7 @@ impl EarlyLintPass for Write {
     fn check_mac(&mut self, cx: &EarlyContext<'_>, mac: &MacCall) {
         if mac.path == sym!(println) {
             span_lint(cx, PRINT_STDOUT, mac.span(), "use of `println!`");
-            if let (Some(fmt_str), _) = self.check_tts(cx, &mac.args.inner_tokens(), false) {
+            if let (Some(fmt_str), _) = self.check_tts(cx, mac.args.inner_tokens(), false) {
                 if fmt_str.symbol == Symbol::intern("") {
                     span_lint_and_sugg(
                         cx,
@@ -252,7 +252,7 @@ impl EarlyLintPass for Write {
             }
         } else if mac.path == sym!(print) {
             span_lint(cx, PRINT_STDOUT, mac.span(), "use of `print!`");
-            if let (Some(fmt_str), _) = self.check_tts(cx, &mac.args.inner_tokens(), false) {
+            if let (Some(fmt_str), _) = self.check_tts(cx, mac.args.inner_tokens(), false) {
                 if check_newlines(&fmt_str) {
                     span_lint_and_then(
                         cx,
@@ -273,7 +273,7 @@ impl EarlyLintPass for Write {
                 }
             }
         } else if mac.path == sym!(write) {
-            if let (Some(fmt_str), _) = self.check_tts(cx, &mac.args.inner_tokens(), true) {
+            if let (Some(fmt_str), _) = self.check_tts(cx, mac.args.inner_tokens(), true) {
                 if check_newlines(&fmt_str) {
                     span_lint_and_then(
                         cx,
@@ -294,7 +294,7 @@ impl EarlyLintPass for Write {
                 }
             }
         } else if mac.path == sym!(writeln) {
-            if let (Some(fmt_str), expr) = self.check_tts(cx, &mac.args.inner_tokens(), true) {
+            if let (Some(fmt_str), expr) = self.check_tts(cx, mac.args.inner_tokens(), true) {
                 if fmt_str.symbol == Symbol::intern("") {
                     let mut applicability = Applicability::MachineApplicable;
                     let suggestion = expr.map_or_else(
@@ -364,17 +364,11 @@ impl Write {
     /// (Some("string to write: {}"), Some(buf))
     /// ```
     #[allow(clippy::too_many_lines)]
-    fn check_tts<'a>(
-        &self,
-        cx: &EarlyContext<'a>,
-        tts: &TokenStream,
-        is_write: bool,
-    ) -> (Option<StrLit>, Option<Expr>) {
+    fn check_tts<'a>(&self, cx: &EarlyContext<'a>, tts: TokenStream, is_write: bool) -> (Option<StrLit>, Option<Expr>) {
         use rustc_parse_format::{
             AlignUnknown, ArgumentImplicitlyIs, ArgumentIs, ArgumentNamed, CountImplied, FormatSpec, ParseMode, Parser,
             Piece,
         };
-        let tts = tts.clone();
 
         let mut parser = parser::Parser::new(&cx.sess.parse_sess, tts, false, None);
         let mut expr: Option<Expr> = None;
-- 
cgit 1.4.1-3-g733a5


From 7d2e42daec1a56ad8f70a2b146bd842e98e0430d Mon Sep 17 00:00:00 2001
From: Ryan Wiedemann <Ryan1729@gmail.com>
Date: Wed, 12 Aug 2020 08:54:32 -0600
Subject: fix typo pointed out in review comment

Co-authored-by: Philipp Krones <hello@philkrones.com>
---
 clippy_lints/src/ptr.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs
index 7f58a381adc..31da45f6b8a 100644
--- a/clippy_lints/src/ptr.rs
+++ b/clippy_lints/src/ptr.rs
@@ -37,7 +37,7 @@ declare_clippy_lint! {
     /// this lint on them will fix the problem, but they may be in other crates.
     ///
     /// One notable example of a function that may cause issues, and which cannot
-    /// easily be changed due to beinng in the standard library is `Vec::contains`.
+    /// easily be changed due to being in the standard library is `Vec::contains`.
     /// when called on a `Vec<Vec<T>>`. If a `&Vec` is passed to that method then
     /// it will compile, but if a `&[T]` is passed then it will not compile.
     ///
-- 
cgit 1.4.1-3-g733a5


From 0fc61becb5f1b9a183311c8b053d996b8695a071 Mon Sep 17 00:00:00 2001
From: Ryan Wiedemann <Ryan1729@gmail.com>
Date: Mon, 10 Aug 2020 07:30:55 -0600
Subject: Add the other overloadable operations to suspicious_arithmetic_impl

In #2268 I idly mused that the other user-overloadable operations could be added to this lint. Knowing that the lint was arguably incomplete was gnawing at the back of my mind, so I figured that I might as well make this PR, particularly given the change needed was so small.
---
 clippy_lints/src/suspicious_trait_impl.rs | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/suspicious_trait_impl.rs b/clippy_lints/src/suspicious_trait_impl.rs
index 4e335a0222f..e026f27d9a7 100644
--- a/clippy_lints/src/suspicious_trait_impl.rs
+++ b/clippy_lints/src/suspicious_trait_impl.rs
@@ -86,12 +86,18 @@ impl<'tcx> LateLintPass<'tcx> for SuspiciousImpl {
                 cx,
                 expr,
                 binop.node,
-                &["Add", "Sub", "Mul", "Div"],
+                &["Add", "Sub", "Mul", "Div", "Rem", "BitAnd", "BitOr", "BitXor", "Shl", "Shr"],
                 &[
                     hir::BinOpKind::Add,
                     hir::BinOpKind::Sub,
                     hir::BinOpKind::Mul,
                     hir::BinOpKind::Div,
+                    hir::BinOpKind::Rem,
+                    hir::BinOpKind::BitAnd,
+                    hir::BinOpKind::BitOr,
+                    hir::BinOpKind::BitXor,
+                    hir::BinOpKind::Shl,
+                    hir::BinOpKind::Shr,
                 ],
             ) {
                 span_lint(
-- 
cgit 1.4.1-3-g733a5


From 616682deb72aa3760b1af3c701090e894f227ac7 Mon Sep 17 00:00:00 2001
From: Ryan Wiedemann <Ryan1729@gmail.com>
Date: Mon, 10 Aug 2020 09:18:16 -0600
Subject: formatting

---
 clippy_lints/src/suspicious_trait_impl.rs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/suspicious_trait_impl.rs b/clippy_lints/src/suspicious_trait_impl.rs
index e026f27d9a7..596d4eb6141 100644
--- a/clippy_lints/src/suspicious_trait_impl.rs
+++ b/clippy_lints/src/suspicious_trait_impl.rs
@@ -86,7 +86,9 @@ impl<'tcx> LateLintPass<'tcx> for SuspiciousImpl {
                 cx,
                 expr,
                 binop.node,
-                &["Add", "Sub", "Mul", "Div", "Rem", "BitAnd", "BitOr", "BitXor", "Shl", "Shr"],
+                &[
+                    "Add", "Sub", "Mul", "Div", "Rem", "BitAnd", "BitOr", "BitXor", "Shl", "Shr"
+                ],
                 &[
                     hir::BinOpKind::Add,
                     hir::BinOpKind::Sub,
-- 
cgit 1.4.1-3-g733a5


From c70581732de89a1b4f064818edeca9a18913ded2 Mon Sep 17 00:00:00 2001
From: Ryan Wiedemann <Ryan1729@gmail.com>
Date: Mon, 10 Aug 2020 09:21:20 -0600
Subject: trailing comma

Should have actually ran rustfmt on it, rather than attempting to fix it manually
---
 clippy_lints/src/suspicious_trait_impl.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/suspicious_trait_impl.rs b/clippy_lints/src/suspicious_trait_impl.rs
index 596d4eb6141..3a688a7bbef 100644
--- a/clippy_lints/src/suspicious_trait_impl.rs
+++ b/clippy_lints/src/suspicious_trait_impl.rs
@@ -87,7 +87,7 @@ impl<'tcx> LateLintPass<'tcx> for SuspiciousImpl {
                 expr,
                 binop.node,
                 &[
-                    "Add", "Sub", "Mul", "Div", "Rem", "BitAnd", "BitOr", "BitXor", "Shl", "Shr"
+                    "Add", "Sub", "Mul", "Div", "Rem", "BitAnd", "BitOr", "BitXor", "Shl", "Shr",
                 ],
                 &[
                     hir::BinOpKind::Add,
-- 
cgit 1.4.1-3-g733a5


From 480ccc3dbec4440bea0aa1f47d2ad21ebcdd578e Mon Sep 17 00:00:00 2001
From: JarredAllen <jarredallen73@gmail.com>
Date: Tue, 11 Aug 2020 18:01:10 -0700
Subject: Change Rc<Box<T>> recommendation to be Rc<T> instead of Box<T>

---
 clippy_lints/src/types.rs            | 15 +++++++++++++--
 tests/ui/redundant_allocation.fixed  |  2 +-
 tests/ui/redundant_allocation.stderr |  2 +-
 3 files changed, 15 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs
index c3dea447521..78cebc30472 100644
--- a/clippy_lints/src/types.rs
+++ b/clippy_lints/src/types.rs
@@ -353,14 +353,25 @@ impl Types {
                             );
                             return; // don't recurse into the type
                         }
-                        if let Some(span) = match_type_parameter(cx, qpath, &paths::BOX) {
+                        if match_type_parameter(cx, qpath, &paths::BOX).is_some() {
+                            let box_ty = match &last_path_segment(qpath).args.unwrap().args[0] {
+                                GenericArg::Type(ty) => match &ty.kind {
+                                    TyKind::Path(qpath) => qpath,
+                                    _ => panic!("Box that isn't a type"),
+                                },
+                                _ => panic!("Rc without type argument"),
+                            };
+                            let inner_span = match &last_path_segment(&box_ty).args.unwrap().args[0] {
+                                GenericArg::Type(ty) => ty.span,
+                                _ => panic!("Box without type argument"),
+                            };
                             span_lint_and_sugg(
                                 cx,
                                 REDUNDANT_ALLOCATION,
                                 hir_ty.span,
                                 "usage of `Rc<Box<T>>`",
                                 "try",
-                                snippet(cx, span, "..").to_string(),
+                                format!("Rc<{}>", snippet(cx, inner_span, "..")),
                                 Applicability::MachineApplicable,
                             );
                             return; // don't recurse into the type
diff --git a/tests/ui/redundant_allocation.fixed b/tests/ui/redundant_allocation.fixed
index 26635833458..6514fd6d1ac 100644
--- a/tests/ui/redundant_allocation.fixed
+++ b/tests/ui/redundant_allocation.fixed
@@ -33,7 +33,7 @@ pub fn test5(a: Rc<bool>) {}
 
 // Rc<Box<T>>
 
-pub fn test6(a: Box<bool>) {}
+pub fn test6(a: Rc<bool>) {}
 
 // Box<&T>
 
diff --git a/tests/ui/redundant_allocation.stderr b/tests/ui/redundant_allocation.stderr
index eaa57ce3024..92e4f67f5db 100644
--- a/tests/ui/redundant_allocation.stderr
+++ b/tests/ui/redundant_allocation.stderr
@@ -28,7 +28,7 @@ error: usage of `Rc<Box<T>>`
   --> $DIR/redundant_allocation.rs:36:17
    |
 LL | pub fn test6(a: Rc<Box<bool>>) {}
-   |                 ^^^^^^^^^^^^^ help: try: `Box<bool>`
+   |                 ^^^^^^^^^^^^^ help: try: `Rc<bool>`
 
 error: usage of `Box<&T>`
   --> $DIR/redundant_allocation.rs:40:22
-- 
cgit 1.4.1-3-g733a5


From 5634c8da02862653be557c6ab1242a6c9ce86ce8 Mon Sep 17 00:00:00 2001
From: ThibsG <Thibs@debian.com>
Date: Wed, 12 Aug 2020 21:37:27 +0200
Subject: Fix: keep parenthesis for suggestion in `useless_conversion` lint

---
 clippy_lints/src/useless_conversion.rs | 5 +++--
 tests/ui/useless_conversion.fixed      | 5 +++++
 tests/ui/useless_conversion.rs         | 5 +++++
 tests/ui/useless_conversion.stderr     | 8 +++++++-
 4 files changed, 20 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/useless_conversion.rs b/clippy_lints/src/useless_conversion.rs
index 1bf37632e32..4ab2b5e796d 100644
--- a/clippy_lints/src/useless_conversion.rs
+++ b/clippy_lints/src/useless_conversion.rs
@@ -1,3 +1,4 @@
+use crate::utils::sugg::Sugg;
 use crate::utils::{
     get_parent_expr, is_type_diagnostic_item, match_def_path, match_trait_method, paths, snippet,
     snippet_with_macro_callsite, span_lint_and_help, span_lint_and_sugg,
@@ -158,7 +159,7 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
                             if TyS::same_type(a, b);
 
                             then {
-                                let sugg = snippet(cx, args[0].span.source_callsite(), "<expr>").into_owned();
+                                let sugg = Sugg::hir_with_macro_callsite(cx, &args[0], "<expr>").maybe_par();
                                 let sugg_msg =
                                     format!("consider removing `{}()`", snippet(cx, path.span, "From::from"));
                                 span_lint_and_sugg(
@@ -167,7 +168,7 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
                                     e.span,
                                     "useless conversion to the same type",
                                     &sugg_msg,
-                                    sugg,
+                                    sugg.to_string(),
                                     Applicability::MachineApplicable, // snippet
                                 );
                             }
diff --git a/tests/ui/useless_conversion.fixed b/tests/ui/useless_conversion.fixed
index 813cdaecaa9..8a9b0cd3cf0 100644
--- a/tests/ui/useless_conversion.fixed
+++ b/tests/ui/useless_conversion.fixed
@@ -64,4 +64,9 @@ fn main() {
     let _ = "".lines();
     let _ = vec![1, 2, 3].into_iter();
     let _: String = format!("Hello {}", "world");
+
+    // keep parenthesis around `a + b` for suggestion (see #4750)
+    let a: i32 = 1;
+    let b: i32 = 1;
+    let _ = (a + b) * 3;
 }
diff --git a/tests/ui/useless_conversion.rs b/tests/ui/useless_conversion.rs
index 540fea23b36..4faa1572973 100644
--- a/tests/ui/useless_conversion.rs
+++ b/tests/ui/useless_conversion.rs
@@ -64,4 +64,9 @@ fn main() {
     let _ = "".lines().into_iter();
     let _ = vec![1, 2, 3].into_iter().into_iter();
     let _: String = format!("Hello {}", "world").into();
+
+    // keep parenthesis around `a + b` for suggestion (see #4750)
+    let a: i32 = 1;
+    let b: i32 = 1;
+    let _ = i32::from(a + b) * 3;
 }
diff --git a/tests/ui/useless_conversion.stderr b/tests/ui/useless_conversion.stderr
index b958b035452..f1e880d2696 100644
--- a/tests/ui/useless_conversion.stderr
+++ b/tests/ui/useless_conversion.stderr
@@ -64,5 +64,11 @@ error: useless conversion to the same type
 LL |     let _: String = format!("Hello {}", "world").into();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into()`: `format!("Hello {}", "world")`
 
-error: aborting due to 10 previous errors
+error: useless conversion to the same type
+  --> $DIR/useless_conversion.rs:71:13
+   |
+LL |     let _ = i32::from(a + b) * 3;
+   |             ^^^^^^^^^^^^^^^^ help: consider removing `i32::from()`: `(a + b)`
+
+error: aborting due to 11 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 4e28d99f413572087a74e1a70b17f051a08d3821 Mon Sep 17 00:00:00 2001
From: JarredAllen <jarredallen73@gmail.com>
Date: Wed, 12 Aug 2020 13:24:55 -0700
Subject: Replace panics with early returns

---
 clippy_lints/src/types.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs
index 78cebc30472..e0204273197 100644
--- a/clippy_lints/src/types.rs
+++ b/clippy_lints/src/types.rs
@@ -357,13 +357,13 @@ impl Types {
                             let box_ty = match &last_path_segment(qpath).args.unwrap().args[0] {
                                 GenericArg::Type(ty) => match &ty.kind {
                                     TyKind::Path(qpath) => qpath,
-                                    _ => panic!("Box that isn't a type"),
+                                    _ => return,
                                 },
-                                _ => panic!("Rc without type argument"),
+                                _ => return,
                             };
                             let inner_span = match &last_path_segment(&box_ty).args.unwrap().args[0] {
                                 GenericArg::Type(ty) => ty.span,
-                                _ => panic!("Box without type argument"),
+                                _ => return,
                             };
                             span_lint_and_sugg(
                                 cx,
-- 
cgit 1.4.1-3-g733a5


From 48a142559de48ff38326e8276ffdfce9ef3b5c95 Mon Sep 17 00:00:00 2001
From: Erich Gubler <erichdongubler@gmail.com>
Date: Thu, 13 Aug 2020 13:52:21 -0600
Subject: docs: typo in `temporary_cstring_as_ptr`: s/point/&s

---
 clippy_lints/src/methods/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index f4eb9c4516f..b6266ef2ba1 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -799,7 +799,7 @@ declare_clippy_lint! {
     ///     call_some_ffi_func(c_str);
     /// }
     /// ```
-    /// Here `c_str` point to a freed address. The correct use would be:
+    /// Here `c_str` points to a freed address. The correct use would be:
     /// ```rust
     /// # use std::ffi::CString;
     /// # fn call_some_ffi_func(_: *const i8) {}
-- 
cgit 1.4.1-3-g733a5


From 8514b8407ac83dc02532c82c9188c49967d9a5d6 Mon Sep 17 00:00:00 2001
From: Christoph Walcher <christoph-wa@gmx.de>
Date: Fri, 14 Aug 2020 14:13:35 +0200
Subject: appreciative too_large_for_stack in useless `vec!`

Fixes: #5847
---
 clippy_lints/src/lib.rs        |  2 +-
 clippy_lints/src/utils/conf.rs |  2 +-
 clippy_lints/src/vec.rs        | 97 ++++++++++++++++++++++++++----------------
 tests/ui/vec.fixed             |  7 +++
 tests/ui/vec.rs                |  7 +++
 5 files changed, 76 insertions(+), 39 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 6ad525d7620..4a4445200a1 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -930,11 +930,11 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(move || box cognitive_complexity::CognitiveComplexity::new(cognitive_complexity_threshold));
     let too_large_for_stack = conf.too_large_for_stack;
     store.register_late_pass(move || box escape::BoxedLocal{too_large_for_stack});
+    store.register_late_pass(move || box vec::UselessVec{too_large_for_stack});
     store.register_late_pass(|| box panic_unimplemented::PanicUnimplemented);
     store.register_late_pass(|| box strings::StringLitAsBytes);
     store.register_late_pass(|| box derive::Derive);
     store.register_late_pass(|| box types::CharLitAsU8);
-    store.register_late_pass(|| box vec::UselessVec);
     store.register_late_pass(|| box drop_bounds::DropBounds);
     store.register_late_pass(|| box get_last_with_len::GetLastWithLen);
     store.register_late_pass(|| box drop_forget_ref::DropForgetRef);
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index ba3492a6fff..292dbd7ad6b 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -138,7 +138,7 @@ define_Conf! {
     (type_complexity_threshold, "type_complexity_threshold": u64, 250),
     /// Lint: MANY_SINGLE_CHAR_NAMES. The maximum number of single char bindings a scope may have
     (single_char_binding_names_threshold, "single_char_binding_names_threshold": u64, 4),
-    /// Lint: BOXED_LOCAL. The maximum size of objects (in bytes) that will be linted. Larger objects are ok on the heap
+    /// Lint: BOXED_LOCAL, USELESS_VEC. The maximum size of objects (in bytes) that will be linted. Larger objects are ok on the heap
     (too_large_for_stack, "too_large_for_stack": u64, 200),
     /// Lint: ENUM_VARIANT_NAMES. The minimum number of enum variants for the lints about variant names to trigger
     (enum_variant_name_threshold, "enum_variant_name_threshold": u64, 3),
diff --git a/clippy_lints/src/vec.rs b/clippy_lints/src/vec.rs
index f2e76442a19..84e907d7125 100644
--- a/clippy_lints/src/vec.rs
+++ b/clippy_lints/src/vec.rs
@@ -1,13 +1,20 @@
-use crate::consts::constant;
+use crate::consts::{constant, Constant};
+use crate::rustc_target::abi::LayoutOf;
 use crate::utils::{higher, is_copy, snippet_with_applicability, span_lint_and_sugg};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{BorrowKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{self, Ty};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::Span;
 
+#[allow(clippy::module_name_repetitions)]
+#[derive(Copy, Clone)]
+pub struct UselessVec {
+    pub too_large_for_stack: u64,
+}
+
 declare_clippy_lint! {
     /// **What it does:** Checks for usage of `&vec![..]` when using `&[..]` would
     /// be possible.
@@ -31,7 +38,7 @@ declare_clippy_lint! {
     "useless `vec!`"
 }
 
-declare_lint_pass!(UselessVec => [USELESS_VEC]);
+impl_lint_pass!(UselessVec => [USELESS_VEC]);
 
 impl<'tcx> LateLintPass<'tcx> for UselessVec {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
@@ -42,7 +49,7 @@ impl<'tcx> LateLintPass<'tcx> for UselessVec {
             if let ExprKind::AddrOf(BorrowKind::Ref, _, ref addressee) = expr.kind;
             if let Some(vec_args) = higher::vec_macro(cx, addressee);
             then {
-                check_vec_macro(cx, &vec_args, expr.span);
+                self.check_vec_macro(cx, &vec_args, expr.span);
             }
         }
 
@@ -60,46 +67,62 @@ impl<'tcx> LateLintPass<'tcx> for UselessVec {
                     .ctxt()
                     .outer_expn_data()
                     .call_site;
-                check_vec_macro(cx, &vec_args, span);
+                self.check_vec_macro(cx, &vec_args, span);
             }
         }
     }
 }
 
-fn check_vec_macro<'tcx>(cx: &LateContext<'tcx>, vec_args: &higher::VecArgs<'tcx>, span: Span) {
-    let mut applicability = Applicability::MachineApplicable;
-    let snippet = match *vec_args {
-        higher::VecArgs::Repeat(elem, len) => {
-            if constant(cx, cx.typeck_results(), len).is_some() {
-                format!(
-                    "&[{}; {}]",
-                    snippet_with_applicability(cx, elem.span, "elem", &mut applicability),
-                    snippet_with_applicability(cx, len.span, "len", &mut applicability)
-                )
-            } else {
-                return;
-            }
-        },
-        higher::VecArgs::Vec(args) => {
-            if let Some(last) = args.iter().last() {
-                let span = args[0].span.to(last.span);
+impl UselessVec {
+    fn check_vec_macro<'tcx>(self, cx: &LateContext<'tcx>, vec_args: &higher::VecArgs<'tcx>, span: Span) {
+        let mut applicability = Applicability::MachineApplicable;
+        let snippet = match *vec_args {
+            higher::VecArgs::Repeat(elem, len) => {
+                if let Some((Constant::Int(len_constant), _)) = constant(cx, cx.typeck_results(), len) {
+                    #[allow(clippy::cast_possible_truncation)]
+                    if len_constant as u64 * size_of(cx, elem) > self.too_large_for_stack {
+                        return;
+                    }
 
-                format!("&[{}]", snippet_with_applicability(cx, span, "..", &mut applicability))
-            } else {
-                "&[]".into()
-            }
-        },
-    };
+                    format!(
+                        "&[{}; {}]",
+                        snippet_with_applicability(cx, elem.span, "elem", &mut applicability),
+                        snippet_with_applicability(cx, len.span, "len", &mut applicability)
+                    )
+                } else {
+                    return;
+                }
+            },
+            higher::VecArgs::Vec(args) => {
+                if let Some(last) = args.iter().last() {
+                    #[allow(clippy::cast_possible_truncation)]
+                    if args.len() as u64 * size_of(cx, last) > self.too_large_for_stack {
+                        return;
+                    }
+                    let span = args[0].span.to(last.span);
+
+                    format!("&[{}]", snippet_with_applicability(cx, span, "..", &mut applicability))
+                } else {
+                    "&[]".into()
+                }
+            },
+        };
+
+        span_lint_and_sugg(
+            cx,
+            USELESS_VEC,
+            span,
+            "useless use of `vec!`",
+            "you can use a slice directly",
+            snippet,
+            applicability,
+        );
+    }
+}
 
-    span_lint_and_sugg(
-        cx,
-        USELESS_VEC,
-        span,
-        "useless use of `vec!`",
-        "you can use a slice directly",
-        snippet,
-        applicability,
-    );
+fn size_of(cx: &LateContext<'_>, expr: &Expr<'_>) -> u64 {
+    let ty = cx.typeck_results().expr_ty_adjusted(expr);
+    cx.layout_of(ty).map_or(0, |l| l.size.bytes())
 }
 
 /// Returns the item type of the vector (i.e., the `T` in `Vec<T>`).
diff --git a/tests/ui/vec.fixed b/tests/ui/vec.fixed
index e73a791891f..85677159620 100644
--- a/tests/ui/vec.fixed
+++ b/tests/ui/vec.fixed
@@ -52,4 +52,11 @@ fn main() {
     for a in vec![NonCopy, NonCopy] {
         println!("{:?}", a);
     }
+
+    on_vec(&vec![1; 201]); // Ok, size of `vec` higher than `too_large_for_stack`
+
+    // Ok
+    for a in vec![1; 201] {
+        println!("{:?}", a);
+    }
 }
diff --git a/tests/ui/vec.rs b/tests/ui/vec.rs
index 3eb960f53d7..03b8ee81665 100644
--- a/tests/ui/vec.rs
+++ b/tests/ui/vec.rs
@@ -52,4 +52,11 @@ fn main() {
     for a in vec![NonCopy, NonCopy] {
         println!("{:?}", a);
     }
+
+    on_vec(&vec![1; 201]); // Ok, size of `vec` higher than `too_large_for_stack`
+
+    // Ok
+    for a in vec![1; 201] {
+        println!("{:?}", a);
+    }
 }
-- 
cgit 1.4.1-3-g733a5


From 8e549978e58fe724c4637ab71808ff8785743c61 Mon Sep 17 00:00:00 2001
From: chansuke <chansuke@georepublic.de>
Date: Wed, 22 Jul 2020 21:44:53 +0900
Subject: Don't use `to_string` in impl Display

---
 CHANGELOG.md                             |   1 +
 clippy_lints/src/lib.rs                  |   5 ++
 clippy_lints/src/to_string_in_display.rs | 100 +++++++++++++++++++++++++++++++
 src/lintlist/mod.rs                      |   7 +++
 tests/ui/to_string_in_display.rs         |  55 +++++++++++++++++
 tests/ui/to_string_in_display.stderr     |  10 ++++
 6 files changed, 178 insertions(+)
 create mode 100644 clippy_lints/src/to_string_in_display.rs
 create mode 100644 tests/ui/to_string_in_display.rs
 create mode 100644 tests/ui/to_string_in_display.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5e9ed54c848..71433773254 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1723,6 +1723,7 @@ Released 2018-09-13
 [`temporary_assignment`]: https://rust-lang.github.io/rust-clippy/master/index.html#temporary_assignment
 [`temporary_cstring_as_ptr`]: https://rust-lang.github.io/rust-clippy/master/index.html#temporary_cstring_as_ptr
 [`to_digit_is_some`]: https://rust-lang.github.io/rust-clippy/master/index.html#to_digit_is_some
+[`to_string_in_display`]: https://rust-lang.github.io/rust-clippy/master/index.html#to_string_in_display
 [`todo`]: https://rust-lang.github.io/rust-clippy/master/index.html#todo
 [`too_many_arguments`]: https://rust-lang.github.io/rust-clippy/master/index.html#too_many_arguments
 [`too_many_lines`]: https://rust-lang.github.io/rust-clippy/master/index.html#too_many_lines
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 6ad525d7620..7ae185103a3 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -296,6 +296,7 @@ mod swap;
 mod tabs_in_doc_comments;
 mod temporary_assignment;
 mod to_digit_is_some;
+mod to_string_in_display;
 mod trait_bounds;
 mod transmute;
 mod transmuting_null;
@@ -788,6 +789,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &tabs_in_doc_comments::TABS_IN_DOC_COMMENTS,
         &temporary_assignment::TEMPORARY_ASSIGNMENT,
         &to_digit_is_some::TO_DIGIT_IS_SOME,
+        &to_string_in_display::TO_STRING_IN_DISPLAY,
         &trait_bounds::TRAIT_DUPLICATION_IN_BOUNDS,
         &trait_bounds::TYPE_REPETITION_IN_BOUNDS,
         &transmute::CROSSPOINTER_TRANSMUTE,
@@ -1017,6 +1019,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_early_pass(|| box reference::DerefAddrOf);
     store.register_early_pass(|| box reference::RefInDeref);
     store.register_early_pass(|| box double_parens::DoubleParens);
+    store.register_late_pass(|| box to_string_in_display::ToStringInDisplay::new());
     store.register_early_pass(|| box unsafe_removed_from_name::UnsafeNameRemoval);
     store.register_early_pass(|| box if_not_else::IfNotElse);
     store.register_early_pass(|| box else_if_without_else::ElseIfWithoutElse);
@@ -1427,6 +1430,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&tabs_in_doc_comments::TABS_IN_DOC_COMMENTS),
         LintId::of(&temporary_assignment::TEMPORARY_ASSIGNMENT),
         LintId::of(&to_digit_is_some::TO_DIGIT_IS_SOME),
+        LintId::of(&to_string_in_display::TO_STRING_IN_DISPLAY),
         LintId::of(&transmute::CROSSPOINTER_TRANSMUTE),
         LintId::of(&transmute::TRANSMUTES_EXPRESSIBLE_AS_PTR_CASTS),
         LintId::of(&transmute::TRANSMUTE_BYTES_TO_STR),
@@ -1708,6 +1712,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&suspicious_trait_impl::SUSPICIOUS_ARITHMETIC_IMPL),
         LintId::of(&suspicious_trait_impl::SUSPICIOUS_OP_ASSIGN_IMPL),
         LintId::of(&swap::ALMOST_SWAPPED),
+        LintId::of(&to_string_in_display::TO_STRING_IN_DISPLAY),
         LintId::of(&transmute::UNSOUND_COLLECTION_TRANSMUTE),
         LintId::of(&transmute::WRONG_TRANSMUTE),
         LintId::of(&transmuting_null::TRANSMUTING_NULL),
diff --git a/clippy_lints/src/to_string_in_display.rs b/clippy_lints/src/to_string_in_display.rs
new file mode 100644
index 00000000000..11bdd27d9b1
--- /dev/null
+++ b/clippy_lints/src/to_string_in_display.rs
@@ -0,0 +1,100 @@
+use crate::utils::{match_def_path, match_trait_method, paths, span_lint};
+use if_chain::if_chain;
+use rustc_hir::{Expr, ExprKind, Item, ItemKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for uses of `to_string()` in `Display` traits.
+    ///
+    /// **Why is this bad?** Usually `to_string` is implemented indirectly
+    /// via `Display`. Hence using it while implementing `Display` would
+    /// lead to infinite recursion.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// use std::fmt;
+    ///
+    /// struct Structure(i32);
+    /// impl fmt::Display for Structure {
+    ///     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    ///         write!(f, "{}", self.to_string())
+    ///     }
+    /// }
+    ///
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// use std::fmt;
+    ///
+    /// struct Structure(i32);
+    /// impl fmt::Display for Structure {
+    ///     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    ///         write!(f, "{}", self.0)
+    ///     }
+    /// }
+    /// ```
+    pub TO_STRING_IN_DISPLAY,
+    correctness,
+    "to_string method used while implementing Display trait"
+}
+
+#[derive(Default)]
+pub struct ToStringInDisplay {
+    in_display_impl: bool,
+}
+
+impl ToStringInDisplay {
+    pub fn new() -> Self {
+        Self { in_display_impl: false }
+    }
+}
+
+impl_lint_pass!(ToStringInDisplay => [TO_STRING_IN_DISPLAY]);
+
+impl LateLintPass<'_> for ToStringInDisplay {
+    fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
+        if is_display_impl(cx, item) {
+            self.in_display_impl = true;
+        }
+    }
+
+    fn check_item_post(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
+        if is_display_impl(cx, item) {
+            self.in_display_impl = false;
+        }
+    }
+
+    fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
+        if_chain! {
+            if let ExprKind::MethodCall(ref path, _, _, _) = expr.kind;
+            if path.ident.name == sym!(to_string);
+            if match_trait_method(cx, expr, &paths::TO_STRING);
+            if self.in_display_impl;
+
+            then {
+                span_lint(
+                    cx,
+                    TO_STRING_IN_DISPLAY,
+                    expr.span,
+                    "Using to_string in fmt::Display implementation might lead to infinite recursion",
+                );
+            }
+        }
+    }
+}
+
+fn is_display_impl(cx: &LateContext<'_>, item: &Item<'_>) -> bool {
+    if_chain! {
+        if let ItemKind::Impl { of_trait: Some(trait_ref), .. } = &item.kind;
+        if let Some(did) = trait_ref.trait_def_id();
+        then {
+            match_def_path(cx, did, &paths::DISPLAY_TRAIT)
+        } else {
+            false
+        }
+    }
+}
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index ccc9e250952..46827084a60 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -2166,6 +2166,13 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
         deprecation: None,
         module: "to_digit_is_some",
     },
+    Lint {
+        name: "to_string_in_display",
+        group: "correctness",
+        desc: "to_string method used while implementing Display trait",
+        deprecation: None,
+        module: "to_string_in_display",
+    },
     Lint {
         name: "todo",
         group: "restriction",
diff --git a/tests/ui/to_string_in_display.rs b/tests/ui/to_string_in_display.rs
new file mode 100644
index 00000000000..3b46324704e
--- /dev/null
+++ b/tests/ui/to_string_in_display.rs
@@ -0,0 +1,55 @@
+#![warn(clippy::to_string_in_display)]
+#![allow(clippy::inherent_to_string_shadow_display)]
+
+use std::fmt;
+
+struct A;
+impl A {
+    fn fmt(&self) {
+        self.to_string();
+    }
+}
+
+trait B {
+    fn fmt(&self) {}
+}
+
+impl B for A {
+    fn fmt(&self) {
+        self.to_string();
+    }
+}
+
+impl fmt::Display for A {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}", self.to_string())
+    }
+}
+
+fn fmt(a: A) {
+    a.to_string();
+}
+
+struct C;
+
+impl C {
+    fn to_string(&self) -> String {
+        String::from("I am C")
+    }
+}
+
+impl fmt::Display for C {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}", self.to_string())
+    }
+}
+
+fn main() {
+    let a = A;
+    a.to_string();
+    a.fmt();
+    fmt(a);
+
+    let c = C;
+    c.to_string();
+}
diff --git a/tests/ui/to_string_in_display.stderr b/tests/ui/to_string_in_display.stderr
new file mode 100644
index 00000000000..cbc0a41036b
--- /dev/null
+++ b/tests/ui/to_string_in_display.stderr
@@ -0,0 +1,10 @@
+error: Using to_string in fmt::Display implementation might lead to infinite recursion
+  --> $DIR/to_string_in_display.rs:25:25
+   |
+LL |         write!(f, "{}", self.to_string())
+   |                         ^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::to-string-in-display` implied by `-D warnings`
+
+error: aborting due to previous error
+
-- 
cgit 1.4.1-3-g733a5


From f98ffa271d0112d04b482e1d61228d99bf006ccf Mon Sep 17 00:00:00 2001
From: Takayuki Nakata <f.seasons017@gmail.com>
Date: Fri, 14 Aug 2020 22:54:12 +0900
Subject: Fix FP for `same_item_push`

Don't emit a lint when `pushed_item` was declared as mutable variable.
---
 clippy_lints/src/loops.rs  | 35 ++++++++++++++++++++++++++++++-----
 tests/ui/same_item_push.rs |  8 ++++++++
 2 files changed, 38 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 8352a8a3d2c..f7db2563d2b 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -1141,11 +1141,36 @@ fn detect_same_item_push<'tcx>(
     if same_item_push_visitor.should_lint {
         if let Some((vec, pushed_item)) = same_item_push_visitor.vec_push {
             // Make sure that the push does not involve possibly mutating values
-            if mutated_variables(pushed_item, cx).map_or(false, |mutvars| mutvars.is_empty()) {
-                if let PatKind::Wild = pat.kind {
-                    let vec_str = snippet_with_macro_callsite(cx, vec.span, "");
-                    let item_str = snippet_with_macro_callsite(cx, pushed_item.span, "");
-
+            if let PatKind::Wild = pat.kind {
+                let vec_str = snippet_with_macro_callsite(cx, vec.span, "");
+                let item_str = snippet_with_macro_callsite(cx, pushed_item.span, "");
+                if let ExprKind::Path(ref qpath) = pushed_item.kind {
+                    if let Res::Local(hir_id) = qpath_res(cx, qpath, pushed_item.hir_id) {
+                        let node = cx.tcx.hir().get(hir_id);
+                        if_chain! {
+                            if let Node::Binding(pat) = node;
+                            if let PatKind::Binding(bind_ann, ..) = pat.kind;
+                            then {
+                                match bind_ann {
+                                    BindingAnnotation::RefMut | BindingAnnotation::Mutable => {},
+                                    _ => {
+                                        span_lint_and_help(
+                                            cx,
+                                            SAME_ITEM_PUSH,
+                                            vec.span,
+                                            "it looks like the same item is being pushed into this Vec",
+                                            None,
+                                            &format!(
+                                                "try using vec![{};SIZE] or {}.resize(NEW_SIZE, {})",
+                                                item_str, vec_str, item_str
+                                            ),
+                                        )
+                                    }
+                                }
+                            }
+                        }
+                    }
+                } else if mutated_variables(pushed_item, cx).map_or(false, |mutvars| mutvars.is_empty()) {
                     span_lint_and_help(
                         cx,
                         SAME_ITEM_PUSH,
diff --git a/tests/ui/same_item_push.rs b/tests/ui/same_item_push.rs
index ff1088f86f6..bfe27e02044 100644
--- a/tests/ui/same_item_push.rs
+++ b/tests/ui/same_item_push.rs
@@ -86,4 +86,12 @@ fn main() {
     for a in vec_a {
         vec12.push(2u8.pow(a.kind));
     }
+
+    // Fix #5902
+    let mut vec13: Vec<u8> = Vec::new();
+    let mut item = 0;
+    for _ in 0..10 {
+        vec13.push(item);
+        item += 10;
+    }
 }
-- 
cgit 1.4.1-3-g733a5


From 72d2c2eab42fe8c7247e4a45b01a6e7411898443 Mon Sep 17 00:00:00 2001
From: Christoph Walcher <christoph-wa@gmx.de>
Date: Sun, 9 Aug 2020 17:47:11 +0200
Subject: Lint `push_str` with a single-character string literal

Fixes #5875
---
 CHANGELOG.md                             |  1 +
 clippy_lints/src/lib.rs                  |  5 +++
 clippy_lints/src/single_char_push_str.rs | 62 ++++++++++++++++++++++++++++++++
 clippy_lints/src/utils/paths.rs          |  1 +
 src/lintlist/mod.rs                      |  7 ++++
 tests/ui/single_char_push_str.fixed      | 10 ++++++
 tests/ui/single_char_push_str.rs         | 10 ++++++
 tests/ui/single_char_push_str.stderr     | 16 +++++++++
 8 files changed, 112 insertions(+)
 create mode 100644 clippy_lints/src/single_char_push_str.rs
 create mode 100644 tests/ui/single_char_push_str.fixed
 create mode 100644 tests/ui/single_char_push_str.rs
 create mode 100644 tests/ui/single_char_push_str.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5e9ed54c848..3b9cbbf0dcd 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1699,6 +1699,7 @@ Released 2018-09-13
 [`should_implement_trait`]: https://rust-lang.github.io/rust-clippy/master/index.html#should_implement_trait
 [`similar_names`]: https://rust-lang.github.io/rust-clippy/master/index.html#similar_names
 [`single_char_pattern`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_char_pattern
+[`single_char_push_str`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_char_push_str
 [`single_component_path_imports`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_component_path_imports
 [`single_match`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_match
 [`single_match_else`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_match_else
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 6ad525d7620..4f261ba932e 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -287,6 +287,7 @@ mod repeat_once;
 mod returns;
 mod serde_api;
 mod shadow;
+mod single_char_push_str;
 mod single_component_path_imports;
 mod slow_vector_initialization;
 mod stable_sort_primitive;
@@ -775,6 +776,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &shadow::SHADOW_REUSE,
         &shadow::SHADOW_SAME,
         &shadow::SHADOW_UNRELATED,
+        &single_char_push_str::SINGLE_CHAR_PUSH_STR,
         &single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS,
         &slow_vector_initialization::SLOW_VECTOR_INITIALIZATION,
         &stable_sort_primitive::STABLE_SORT_PRIMITIVE,
@@ -932,6 +934,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(move || box escape::BoxedLocal{too_large_for_stack});
     store.register_late_pass(|| box panic_unimplemented::PanicUnimplemented);
     store.register_late_pass(|| box strings::StringLitAsBytes);
+    store.register_late_pass(|| box single_char_push_str::SingleCharPushStrPass);
     store.register_late_pass(|| box derive::Derive);
     store.register_late_pass(|| box types::CharLitAsU8);
     store.register_late_pass(|| box vec::UselessVec);
@@ -1416,6 +1419,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&returns::NEEDLESS_RETURN),
         LintId::of(&returns::UNUSED_UNIT),
         LintId::of(&serde_api::SERDE_API_MISUSE),
+        LintId::of(&single_char_push_str::SINGLE_CHAR_PUSH_STR),
         LintId::of(&single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS),
         LintId::of(&slow_vector_initialization::SLOW_VECTOR_INITIALIZATION),
         LintId::of(&stable_sort_primitive::STABLE_SORT_PRIMITIVE),
@@ -1556,6 +1560,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&regex::TRIVIAL_REGEX),
         LintId::of(&returns::NEEDLESS_RETURN),
         LintId::of(&returns::UNUSED_UNIT),
+        LintId::of(&single_char_push_str::SINGLE_CHAR_PUSH_STR),
         LintId::of(&single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS),
         LintId::of(&strings::STRING_LIT_AS_BYTES),
         LintId::of(&tabs_in_doc_comments::TABS_IN_DOC_COMMENTS),
diff --git a/clippy_lints/src/single_char_push_str.rs b/clippy_lints/src/single_char_push_str.rs
new file mode 100644
index 00000000000..68bbef7261a
--- /dev/null
+++ b/clippy_lints/src/single_char_push_str.rs
@@ -0,0 +1,62 @@
+use crate::utils::{match_def_path, paths, snippet_with_applicability, span_lint_and_sugg};
+use if_chain::if_chain;
+use rustc_ast::ast::LitKind;
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// **What it does:** Warns when using push_str with a single-character string literal,
+    /// and push with a char would work fine.
+    ///
+    /// **Why is this bad?** This is in all probability not the intended outcome. At
+    /// the least it hurts readability of the code.
+    ///
+    /// **Known problems:** None
+    ///
+    /// **Example:**
+    /// ```
+    /// let mut string = String::new();
+    /// string.push_str("R");
+    /// ```
+    /// Could be written as
+    /// ```
+    /// let mut string = String::new();
+    /// string.push('R');
+    /// ```
+    pub SINGLE_CHAR_PUSH_STR,
+    style,
+    "`push_str()` used with a single-character string literal as parameter"
+}
+
+declare_lint_pass!(SingleCharPushStrPass => [SINGLE_CHAR_PUSH_STR]);
+
+impl<'tcx> LateLintPass<'tcx> for SingleCharPushStrPass {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        if_chain! {
+            if let ExprKind::MethodCall(_, _, ref args, _) = expr.kind;
+            if let [base_string, extension_string] = args;
+            if let Some(fn_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
+            if match_def_path(cx, fn_def_id, &paths::PUSH_STR);
+            if let ExprKind::Lit(ref lit) = extension_string.kind;
+            if let LitKind::Str(symbol,_) = lit.node;
+            let extension_string_val = symbol.as_str().to_string();
+            if extension_string_val.len() == 1;
+            then {
+                let mut applicability = Applicability::MachineApplicable;
+                let base_string_snippet = snippet_with_applicability(cx, base_string.span, "_", &mut applicability);
+                let sugg = format!("{}.push({:?})", base_string_snippet, extension_string_val.chars().next().unwrap());
+                span_lint_and_sugg(
+                    cx,
+                    SINGLE_CHAR_PUSH_STR,
+                    expr.span,
+                    "calling `push_str()` using a single-character string literal",
+                    "consider using `push` with a character literal",
+                    sugg,
+                    applicability
+                );
+            }
+        }
+    }
+}
diff --git a/clippy_lints/src/utils/paths.rs b/clippy_lints/src/utils/paths.rs
index 923b319d777..ffab0395120 100644
--- a/clippy_lints/src/utils/paths.rs
+++ b/clippy_lints/src/utils/paths.rs
@@ -84,6 +84,7 @@ pub const POLL: [&str; 4] = ["core", "task", "poll", "Poll"];
 pub const PTR_EQ: [&str; 3] = ["core", "ptr", "eq"];
 pub const PTR_NULL: [&str; 2] = ["ptr", "null"];
 pub const PTR_NULL_MUT: [&str; 2] = ["ptr", "null_mut"];
+pub const PUSH_STR: [&str; 4] = ["alloc", "string", "String", "push_str"];
 pub const RANGE: [&str; 3] = ["core", "ops", "Range"];
 pub const RANGE_ARGUMENT_TRAIT: [&str; 3] = ["core", "ops", "RangeBounds"];
 pub const RANGE_FROM: [&str; 3] = ["core", "ops", "RangeFrom"];
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index ccc9e250952..000ab8b8f36 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -2012,6 +2012,13 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
         deprecation: None,
         module: "methods",
     },
+    Lint {
+        name: "single_char_push_str",
+        group: "style",
+        desc: "`push_str()` used with a single-character string literal as parameter",
+        deprecation: None,
+        module: "single_char_push_str",
+    },
     Lint {
         name: "single_component_path_imports",
         group: "style",
diff --git a/tests/ui/single_char_push_str.fixed b/tests/ui/single_char_push_str.fixed
new file mode 100644
index 00000000000..49607c49218
--- /dev/null
+++ b/tests/ui/single_char_push_str.fixed
@@ -0,0 +1,10 @@
+// run-rustfix
+#![warn(clippy::single_char_push_str)]
+
+fn main() {
+    let mut string = String::new();
+    string.push('R');
+    string.push('\'');
+
+    string.push('u');
+}
diff --git a/tests/ui/single_char_push_str.rs b/tests/ui/single_char_push_str.rs
new file mode 100644
index 00000000000..bbeebd027b1
--- /dev/null
+++ b/tests/ui/single_char_push_str.rs
@@ -0,0 +1,10 @@
+// run-rustfix
+#![warn(clippy::single_char_push_str)]
+
+fn main() {
+    let mut string = String::new();
+    string.push_str("R");
+    string.push_str("'");
+
+    string.push('u');
+}
diff --git a/tests/ui/single_char_push_str.stderr b/tests/ui/single_char_push_str.stderr
new file mode 100644
index 00000000000..453ec2d42f1
--- /dev/null
+++ b/tests/ui/single_char_push_str.stderr
@@ -0,0 +1,16 @@
+error: calling `push_str()` using a single-character string literal
+  --> $DIR/single_char_push_str.rs:6:5
+   |
+LL |     string.push_str("R");
+   |     ^^^^^^^^^^^^^^^^^^^^ help: consider using `push` with a character literal: `string.push('R')`
+   |
+   = note: `-D clippy::single-char-push-str` implied by `-D warnings`
+
+error: calling `push_str()` using a single-character string literal
+  --> $DIR/single_char_push_str.rs:7:5
+   |
+LL |     string.push_str("'");
+   |     ^^^^^^^^^^^^^^^^^^^^ help: consider using `push` with a character literal: `string.push('/'')`
+
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From ae56e988a2ae7b59c684cbbc5c326cb8097b3688 Mon Sep 17 00:00:00 2001
From: Christoph Walcher <christoph-wa@gmx.de>
Date: Fri, 14 Aug 2020 12:52:19 +0200
Subject: Merge lint with `single_char_pattern`

---
 clippy_lints/src/lib.rs                  |  8 ++-
 clippy_lints/src/methods/mod.rs          | 89 +++++++++++++++++++++++++++-----
 clippy_lints/src/single_char_push_str.rs | 62 ----------------------
 src/lintlist/mod.rs                      |  2 +-
 tests/ui/single_char_push_str.fixed      |  5 ++
 tests/ui/single_char_push_str.rs         |  5 ++
 tests/ui/single_char_push_str.stderr     | 20 ++++++-
 7 files changed, 108 insertions(+), 83 deletions(-)
 delete mode 100644 clippy_lints/src/single_char_push_str.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 4f261ba932e..5e4a4a4f49c 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -287,7 +287,6 @@ mod repeat_once;
 mod returns;
 mod serde_api;
 mod shadow;
-mod single_char_push_str;
 mod single_component_path_imports;
 mod slow_vector_initialization;
 mod stable_sort_primitive;
@@ -678,6 +677,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &methods::SEARCH_IS_SOME,
         &methods::SHOULD_IMPLEMENT_TRAIT,
         &methods::SINGLE_CHAR_PATTERN,
+        &methods::SINGLE_CHAR_PUSH_STR,
         &methods::SKIP_WHILE_NEXT,
         &methods::STRING_EXTEND_CHARS,
         &methods::SUSPICIOUS_MAP,
@@ -776,7 +776,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &shadow::SHADOW_REUSE,
         &shadow::SHADOW_SAME,
         &shadow::SHADOW_UNRELATED,
-        &single_char_push_str::SINGLE_CHAR_PUSH_STR,
         &single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS,
         &slow_vector_initialization::SLOW_VECTOR_INITIALIZATION,
         &stable_sort_primitive::STABLE_SORT_PRIMITIVE,
@@ -934,7 +933,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(move || box escape::BoxedLocal{too_large_for_stack});
     store.register_late_pass(|| box panic_unimplemented::PanicUnimplemented);
     store.register_late_pass(|| box strings::StringLitAsBytes);
-    store.register_late_pass(|| box single_char_push_str::SingleCharPushStrPass);
     store.register_late_pass(|| box derive::Derive);
     store.register_late_pass(|| box types::CharLitAsU8);
     store.register_late_pass(|| box vec::UselessVec);
@@ -1352,6 +1350,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&methods::SEARCH_IS_SOME),
         LintId::of(&methods::SHOULD_IMPLEMENT_TRAIT),
         LintId::of(&methods::SINGLE_CHAR_PATTERN),
+        LintId::of(&methods::SINGLE_CHAR_PUSH_STR),
         LintId::of(&methods::SKIP_WHILE_NEXT),
         LintId::of(&methods::STRING_EXTEND_CHARS),
         LintId::of(&methods::SUSPICIOUS_MAP),
@@ -1419,7 +1418,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&returns::NEEDLESS_RETURN),
         LintId::of(&returns::UNUSED_UNIT),
         LintId::of(&serde_api::SERDE_API_MISUSE),
-        LintId::of(&single_char_push_str::SINGLE_CHAR_PUSH_STR),
         LintId::of(&single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS),
         LintId::of(&slow_vector_initialization::SLOW_VECTOR_INITIALIZATION),
         LintId::of(&stable_sort_primitive::STABLE_SORT_PRIMITIVE),
@@ -1536,6 +1534,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&methods::OPTION_MAP_OR_NONE),
         LintId::of(&methods::RESULT_MAP_OR_INTO_OPTION),
         LintId::of(&methods::SHOULD_IMPLEMENT_TRAIT),
+        LintId::of(&methods::SINGLE_CHAR_PUSH_STR),
         LintId::of(&methods::STRING_EXTEND_CHARS),
         LintId::of(&methods::UNNECESSARY_FOLD),
         LintId::of(&methods::WRONG_SELF_CONVENTION),
@@ -1560,7 +1559,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&regex::TRIVIAL_REGEX),
         LintId::of(&returns::NEEDLESS_RETURN),
         LintId::of(&returns::UNUSED_UNIT),
-        LintId::of(&single_char_push_str::SINGLE_CHAR_PUSH_STR),
         LintId::of(&single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS),
         LintId::of(&strings::STRING_LIT_AS_BYTES),
         LintId::of(&tabs_in_doc_comments::TABS_IN_DOC_COMMENTS),
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index b6266ef2ba1..2986a5a5944 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1306,6 +1306,29 @@ declare_clippy_lint! {
     "using `.iter().next()` on a sliced array, which can be shortened to just `.get()`"
 }
 
+declare_clippy_lint! {
+    /// **What it does:** Warns when using push_str with a single-character string literal,
+    /// and push with a char would work fine.
+    ///
+    /// **Why is this bad?** it's less clear that we are pushing a single character
+    ///
+    /// **Known problems:** None
+    ///
+    /// **Example:**
+    /// ```
+    /// let mut string = String::new();
+    /// string.push_str("R");
+    /// ```
+    /// Could be written as
+    /// ```
+    /// let mut string = String::new();
+    /// string.push('R');
+    /// ```
+    pub SINGLE_CHAR_PUSH_STR,
+    style,
+    "`push_str()` used with a single-character string literal as parameter"
+}
+
 declare_lint_pass!(Methods => [
     UNWRAP_USED,
     EXPECT_USED,
@@ -1327,6 +1350,7 @@ declare_lint_pass!(Methods => [
     INEFFICIENT_TO_STRING,
     NEW_RET_NO_SELF,
     SINGLE_CHAR_PATTERN,
+    SINGLE_CHAR_PUSH_STR,
     SEARCH_IS_SOME,
     TEMPORARY_CSTRING_AS_PTR,
     FILTER_NEXT,
@@ -1441,6 +1465,12 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
                     inefficient_to_string::lint(cx, expr, &args[0], self_ty);
                 }
 
+                if let Some(fn_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id) {
+                    if match_def_path(cx, fn_def_id, &paths::PUSH_STR) {
+                        lint_single_char_push_string(cx, expr, args);
+                    }
+                }
+
                 match self_ty.kind {
                     ty::Ref(_, ty, _) if ty.kind == ty::Str => {
                         for &(method, pos) in &PATTERN_METHODS {
@@ -3124,15 +3154,18 @@ fn lint_chars_last_cmp_with_unwrap<'tcx>(cx: &LateContext<'tcx>, info: &BinaryEx
     }
 }
 
-/// lint for length-1 `str`s for methods in `PATTERN_METHODS`
-fn lint_single_char_pattern<'tcx>(cx: &LateContext<'tcx>, _expr: &'tcx hir::Expr<'_>, arg: &'tcx hir::Expr<'_>) {
+fn get_hint_if_single_char_arg<'tcx>(
+    cx: &LateContext<'tcx>,
+    arg: &'tcx hir::Expr<'_>,
+    applicability: &mut Applicability,
+) -> Option<String> {
     if_chain! {
         if let hir::ExprKind::Lit(lit) = &arg.kind;
         if let ast::LitKind::Str(r, style) = lit.node;
-        if r.as_str().len() == 1;
+        let string = r.as_str();
+        if string.len() == 1;
         then {
-            let mut applicability = Applicability::MachineApplicable;
-            let snip = snippet_with_applicability(cx, arg.span, "..", &mut applicability);
+            let snip = snippet_with_applicability(cx, arg.span, &string, applicability);
             let ch = if let ast::StrStyle::Raw(nhash) = style {
                 let nhash = nhash as usize;
                 // for raw string: r##"a"##
@@ -3142,19 +3175,47 @@ fn lint_single_char_pattern<'tcx>(cx: &LateContext<'tcx>, _expr: &'tcx hir::Expr
                 &snip[1..(snip.len() - 1)]
             };
             let hint = format!("'{}'", if ch == "'" { "\\'" } else { ch });
-            span_lint_and_sugg(
-                cx,
-                SINGLE_CHAR_PATTERN,
-                arg.span,
-                "single-character string constant used as pattern",
-                "try using a `char` instead",
-                hint,
-                applicability,
-            );
+            Some(hint)
+        } else {
+            None
         }
     }
 }
 
+/// lint for length-1 `str`s for methods in `PATTERN_METHODS`
+fn lint_single_char_pattern<'tcx>(cx: &LateContext<'tcx>, _expr: &'tcx hir::Expr<'_>, arg: &'tcx hir::Expr<'_>) {
+    let mut applicability = Applicability::MachineApplicable;
+    if let Some(hint) = get_hint_if_single_char_arg(cx, arg, &mut applicability) {
+        span_lint_and_sugg(
+            cx,
+            SINGLE_CHAR_PATTERN,
+            arg.span,
+            "single-character string constant used as pattern",
+            "try using a `char` instead",
+            hint,
+            applicability,
+        );
+    }
+}
+
+/// lint for length-1 `str`s as argument for `push_str`
+fn lint_single_char_push_string<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, args: &'tcx [hir::Expr<'_>]) {
+    let mut applicability = Applicability::MachineApplicable;
+    if let Some(extension_string) = get_hint_if_single_char_arg(cx, &args[1], &mut applicability) {
+        let base_string_snippet = snippet_with_applicability(cx, args[0].span, "_", &mut applicability);
+        let sugg = format!("{}.push({})", base_string_snippet, extension_string);
+        span_lint_and_sugg(
+            cx,
+            SINGLE_CHAR_PUSH_STR,
+            expr.span,
+            "calling `push_str()` using a single-character string literal",
+            "consider using `push` with a character literal",
+            sugg,
+            applicability,
+        );
+    }
+}
+
 /// Checks for the `USELESS_ASREF` lint.
 fn lint_asref(cx: &LateContext<'_>, expr: &hir::Expr<'_>, call_name: &str, as_ref_args: &[hir::Expr<'_>]) {
     // when we get here, we've already checked that the call name is "as_ref" or "as_mut"
diff --git a/clippy_lints/src/single_char_push_str.rs b/clippy_lints/src/single_char_push_str.rs
deleted file mode 100644
index 68bbef7261a..00000000000
--- a/clippy_lints/src/single_char_push_str.rs
+++ /dev/null
@@ -1,62 +0,0 @@
-use crate::utils::{match_def_path, paths, snippet_with_applicability, span_lint_and_sugg};
-use if_chain::if_chain;
-use rustc_ast::ast::LitKind;
-use rustc_errors::Applicability;
-use rustc_hir::{Expr, ExprKind};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-
-declare_clippy_lint! {
-    /// **What it does:** Warns when using push_str with a single-character string literal,
-    /// and push with a char would work fine.
-    ///
-    /// **Why is this bad?** This is in all probability not the intended outcome. At
-    /// the least it hurts readability of the code.
-    ///
-    /// **Known problems:** None
-    ///
-    /// **Example:**
-    /// ```
-    /// let mut string = String::new();
-    /// string.push_str("R");
-    /// ```
-    /// Could be written as
-    /// ```
-    /// let mut string = String::new();
-    /// string.push('R');
-    /// ```
-    pub SINGLE_CHAR_PUSH_STR,
-    style,
-    "`push_str()` used with a single-character string literal as parameter"
-}
-
-declare_lint_pass!(SingleCharPushStrPass => [SINGLE_CHAR_PUSH_STR]);
-
-impl<'tcx> LateLintPass<'tcx> for SingleCharPushStrPass {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if_chain! {
-            if let ExprKind::MethodCall(_, _, ref args, _) = expr.kind;
-            if let [base_string, extension_string] = args;
-            if let Some(fn_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
-            if match_def_path(cx, fn_def_id, &paths::PUSH_STR);
-            if let ExprKind::Lit(ref lit) = extension_string.kind;
-            if let LitKind::Str(symbol,_) = lit.node;
-            let extension_string_val = symbol.as_str().to_string();
-            if extension_string_val.len() == 1;
-            then {
-                let mut applicability = Applicability::MachineApplicable;
-                let base_string_snippet = snippet_with_applicability(cx, base_string.span, "_", &mut applicability);
-                let sugg = format!("{}.push({:?})", base_string_snippet, extension_string_val.chars().next().unwrap());
-                span_lint_and_sugg(
-                    cx,
-                    SINGLE_CHAR_PUSH_STR,
-                    expr.span,
-                    "calling `push_str()` using a single-character string literal",
-                    "consider using `push` with a character literal",
-                    sugg,
-                    applicability
-                );
-            }
-        }
-    }
-}
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index 000ab8b8f36..4fd32776874 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -2017,7 +2017,7 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
         group: "style",
         desc: "`push_str()` used with a single-character string literal as parameter",
         deprecation: None,
-        module: "single_char_push_str",
+        module: "methods",
     },
     Lint {
         name: "single_component_path_imports",
diff --git a/tests/ui/single_char_push_str.fixed b/tests/ui/single_char_push_str.fixed
index 49607c49218..0812c026a64 100644
--- a/tests/ui/single_char_push_str.fixed
+++ b/tests/ui/single_char_push_str.fixed
@@ -7,4 +7,9 @@ fn main() {
     string.push('\'');
 
     string.push('u');
+    string.push_str("st");
+    string.push_str("");
+    string.push('\x52');
+    string.push('\u{0052}');
+    string.push('a');
 }
diff --git a/tests/ui/single_char_push_str.rs b/tests/ui/single_char_push_str.rs
index bbeebd027b1..ab293bbe4ee 100644
--- a/tests/ui/single_char_push_str.rs
+++ b/tests/ui/single_char_push_str.rs
@@ -7,4 +7,9 @@ fn main() {
     string.push_str("'");
 
     string.push('u');
+    string.push_str("st");
+    string.push_str("");
+    string.push_str("\x52");
+    string.push_str("\u{0052}");
+    string.push_str(r##"a"##);
 }
diff --git a/tests/ui/single_char_push_str.stderr b/tests/ui/single_char_push_str.stderr
index 453ec2d42f1..0e9bdaa23e7 100644
--- a/tests/ui/single_char_push_str.stderr
+++ b/tests/ui/single_char_push_str.stderr
@@ -12,5 +12,23 @@ error: calling `push_str()` using a single-character string literal
 LL |     string.push_str("'");
    |     ^^^^^^^^^^^^^^^^^^^^ help: consider using `push` with a character literal: `string.push('/'')`
 
-error: aborting due to 2 previous errors
+error: calling `push_str()` using a single-character string literal
+  --> $DIR/single_char_push_str.rs:12:5
+   |
+LL |     string.push_str("/x52");
+   |     ^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `push` with a character literal: `string.push('/x52')`
+
+error: calling `push_str()` using a single-character string literal
+  --> $DIR/single_char_push_str.rs:13:5
+   |
+LL |     string.push_str("/u{0052}");
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `push` with a character literal: `string.push('/u{0052}')`
+
+error: calling `push_str()` using a single-character string literal
+  --> $DIR/single_char_push_str.rs:14:5
+   |
+LL |     string.push_str(r##"a"##);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `push` with a character literal: `string.push('a')`
+
+error: aborting due to 5 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From b381ade1795f36149e36a646cdc83ee2fff032bf Mon Sep 17 00:00:00 2001
From: Christoph Walcher <christoph-wa@gmx.de>
Date: Sat, 15 Aug 2020 01:40:47 +0200
Subject: elide lifetimes

---
 clippy_lints/src/methods/mod.rs | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 2986a5a5944..614773a7e26 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1310,7 +1310,7 @@ declare_clippy_lint! {
     /// **What it does:** Warns when using push_str with a single-character string literal,
     /// and push with a char would work fine.
     ///
-    /// **Why is this bad?** it's less clear that we are pushing a single character
+    /// **Why is this bad?** It's less clear that we are pushing a single character
     ///
     /// **Known problems:** None
     ///
@@ -3154,9 +3154,9 @@ fn lint_chars_last_cmp_with_unwrap<'tcx>(cx: &LateContext<'tcx>, info: &BinaryEx
     }
 }
 
-fn get_hint_if_single_char_arg<'tcx>(
-    cx: &LateContext<'tcx>,
-    arg: &'tcx hir::Expr<'_>,
+fn get_hint_if_single_char_arg(
+    cx: &LateContext<'_>,
+    arg: &hir::Expr<'_>,
     applicability: &mut Applicability,
 ) -> Option<String> {
     if_chain! {
@@ -3183,7 +3183,7 @@ fn get_hint_if_single_char_arg<'tcx>(
 }
 
 /// lint for length-1 `str`s for methods in `PATTERN_METHODS`
-fn lint_single_char_pattern<'tcx>(cx: &LateContext<'tcx>, _expr: &'tcx hir::Expr<'_>, arg: &'tcx hir::Expr<'_>) {
+fn lint_single_char_pattern(cx: &LateContext<'_>, _expr: &hir::Expr<'_>, arg: &hir::Expr<'_>) {
     let mut applicability = Applicability::MachineApplicable;
     if let Some(hint) = get_hint_if_single_char_arg(cx, arg, &mut applicability) {
         span_lint_and_sugg(
@@ -3199,7 +3199,7 @@ fn lint_single_char_pattern<'tcx>(cx: &LateContext<'tcx>, _expr: &'tcx hir::Expr
 }
 
 /// lint for length-1 `str`s as argument for `push_str`
-fn lint_single_char_push_string<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, args: &'tcx [hir::Expr<'_>]) {
+fn lint_single_char_push_string(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::Expr<'_>]) {
     let mut applicability = Applicability::MachineApplicable;
     if let Some(extension_string) = get_hint_if_single_char_arg(cx, &args[1], &mut applicability) {
         let base_string_snippet = snippet_with_applicability(cx, args[0].span, "_", &mut applicability);
-- 
cgit 1.4.1-3-g733a5


From 6d18fe730e88903fa881f7b753369623108a5d55 Mon Sep 17 00:00:00 2001
From: jrqc <jrqc01@hotmail.com>
Date: Wed, 12 Aug 2020 15:43:44 +0300
Subject: Make needless_return a late lint pass

---
 clippy_lints/src/lib.rs             |   8 +-
 clippy_lints/src/needless_return.rs | 166 ++++++++++++++++++++++++++++++++++++
 clippy_lints/src/returns.rs         | 141 +-----------------------------
 src/lintlist/mod.rs                 |   2 +-
 4 files changed, 175 insertions(+), 142 deletions(-)
 create mode 100644 clippy_lints/src/needless_return.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 6ad525d7620..d2f66cf9bd0 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -256,6 +256,7 @@ mod needless_borrow;
 mod needless_borrowed_ref;
 mod needless_continue;
 mod needless_pass_by_value;
+mod needless_return;
 mod needless_update;
 mod neg_cmp_op_on_partial_ord;
 mod neg_multiply;
@@ -726,6 +727,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &needless_borrowed_ref::NEEDLESS_BORROWED_REFERENCE,
         &needless_continue::NEEDLESS_CONTINUE,
         &needless_pass_by_value::NEEDLESS_PASS_BY_VALUE,
+        &needless_return::NEEDLESS_RETURN,
         &needless_update::NEEDLESS_UPDATE,
         &neg_cmp_op_on_partial_ord::NEG_CMP_OP_ON_PARTIAL_ORD,
         &neg_multiply::NEG_MULTIPLY,
@@ -769,7 +771,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &regex::INVALID_REGEX,
         &regex::TRIVIAL_REGEX,
         &repeat_once::REPEAT_ONCE,
-        &returns::NEEDLESS_RETURN,
         &returns::UNUSED_UNIT,
         &serde_api::SERDE_API_MISUSE,
         &shadow::SHADOW_REUSE,
@@ -1027,6 +1028,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box redundant_closure_call::RedundantClosureCall);
     store.register_early_pass(|| box returns::Return);
     store.register_late_pass(|| box let_and_return::LetReturn);
+    store.register_late_pass(|| box needless_return::NeedlessReturn);
     store.register_early_pass(|| box collapsible_if::CollapsibleIf);
     store.register_early_pass(|| box items_after_statements::ItemsAfterStatements);
     store.register_early_pass(|| box precedence::Precedence);
@@ -1381,6 +1383,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&needless_bool::BOOL_COMPARISON),
         LintId::of(&needless_bool::NEEDLESS_BOOL),
         LintId::of(&needless_borrowed_ref::NEEDLESS_BORROWED_REFERENCE),
+        LintId::of(&needless_return::NEEDLESS_RETURN),
         LintId::of(&needless_update::NEEDLESS_UPDATE),
         LintId::of(&neg_cmp_op_on_partial_ord::NEG_CMP_OP_ON_PARTIAL_ORD),
         LintId::of(&neg_multiply::NEG_MULTIPLY),
@@ -1413,7 +1416,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&regex::INVALID_REGEX),
         LintId::of(&regex::TRIVIAL_REGEX),
         LintId::of(&repeat_once::REPEAT_ONCE),
-        LintId::of(&returns::NEEDLESS_RETURN),
         LintId::of(&returns::UNUSED_UNIT),
         LintId::of(&serde_api::SERDE_API_MISUSE),
         LintId::of(&single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS),
@@ -1543,6 +1545,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&misc_early::MIXED_CASE_HEX_LITERALS),
         LintId::of(&misc_early::REDUNDANT_PATTERN),
         LintId::of(&mut_reference::UNNECESSARY_MUT_PASSED),
+        LintId::of(&needless_return::NEEDLESS_RETURN),
         LintId::of(&neg_multiply::NEG_MULTIPLY),
         LintId::of(&new_without_default::NEW_WITHOUT_DEFAULT),
         LintId::of(&non_expressive_names::JUST_UNDERSCORES_AND_DIGITS),
@@ -1554,7 +1557,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&redundant_field_names::REDUNDANT_FIELD_NAMES),
         LintId::of(&redundant_static_lifetimes::REDUNDANT_STATIC_LIFETIMES),
         LintId::of(&regex::TRIVIAL_REGEX),
-        LintId::of(&returns::NEEDLESS_RETURN),
         LintId::of(&returns::UNUSED_UNIT),
         LintId::of(&single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS),
         LintId::of(&strings::STRING_LIT_AS_BYTES),
diff --git a/clippy_lints/src/needless_return.rs b/clippy_lints/src/needless_return.rs
new file mode 100644
index 00000000000..a8876619ac1
--- /dev/null
+++ b/clippy_lints/src/needless_return.rs
@@ -0,0 +1,166 @@
+use rustc_lint::{LateLintPass, LateContext};
+use rustc_ast::ast::Attribute;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_errors::Applicability;
+use rustc_hir::intravisit::FnKind;
+use rustc_span::source_map::Span;
+use rustc_middle::lint::in_external_macro;
+use rustc_hir::{Block, Body, Expr, ExprKind, FnDecl, HirId, MatchSource, StmtKind};
+
+use crate::utils::{snippet_opt, span_lint_and_sugg, span_lint_and_then};
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for return statements at the end of a block.
+    ///
+    /// **Why is this bad?** Removing the `return` and semicolon will make the code
+    /// more rusty.
+    ///
+    /// **Known problems:** If the computation returning the value borrows a local
+    /// variable, removing the `return` may run afoul of the borrow checker.
+    ///
+    /// **Example:**
+    /// ```rust
+    /// fn foo(x: usize) -> usize {
+    ///     return x;
+    /// }
+    /// ```
+    /// simplify to
+    /// ```rust
+    /// fn foo(x: usize) -> usize {
+    ///     x
+    /// }
+    /// ```
+    pub NEEDLESS_RETURN,
+    style,
+    "using a return statement like `return expr;` where an expression would suffice"
+}
+
+#[derive(PartialEq, Eq, Copy, Clone)]
+enum RetReplacement {
+    Empty,
+    Block,
+}
+
+declare_lint_pass!(NeedlessReturn => [NEEDLESS_RETURN]);
+
+impl<'tcx> LateLintPass<'tcx> for NeedlessReturn {
+    fn check_fn(&mut self, cx: &LateContext<'tcx>, kind: FnKind<'tcx>, _: &'tcx FnDecl<'tcx>, body: &'tcx Body<'tcx>, _: Span, _: HirId) {
+        match kind {
+            FnKind::Closure(_) => {
+                check_final_expr(cx, &body.value, Some(body.value.span), RetReplacement::Empty)
+            }
+            FnKind::ItemFn(..) | FnKind::Method(..) => {
+                if let ExprKind::Block(ref block, _) = body.value.kind {
+                    check_block_return(cx, block)
+                }
+            }
+        }
+    }
+}
+
+fn attr_is_cfg(attr: &Attribute) -> bool {
+    attr.meta_item_list().is_some() && attr.has_name(sym!(cfg))
+}
+
+fn check_block_return(cx: &LateContext<'_>, block: &Block<'_>) {
+    if let Some(expr) = block.expr {
+        check_final_expr(cx, expr, Some(expr.span), RetReplacement::Empty);
+    } else if let Some(stmt) = block.stmts.iter().last() {
+        match stmt.kind {
+            StmtKind::Expr(ref expr) | StmtKind::Semi(ref expr) => {
+                check_final_expr(cx, expr, Some(stmt.span), RetReplacement::Empty);
+            }
+            _ => (),
+        }
+    }
+}
+
+
+fn check_final_expr(
+    cx: &LateContext<'_>,
+    expr: &Expr<'_>,
+    span: Option<Span>,
+    replacement: RetReplacement,
+) {
+    match expr.kind {
+        // simple return is always "bad"
+        ExprKind::Ret(ref inner) => {
+
+            // allow `#[cfg(a)] return a; #[cfg(b)] return b;`
+            if !expr.attrs.iter().any(attr_is_cfg) {
+                emit_return_lint(
+                    cx,
+                    span.expect("`else return` is not possible"),
+                    inner.as_ref().map(|i| i.span),
+                    replacement,
+                );
+            }
+        }
+        // a whole block? check it!
+        ExprKind::Block(ref block, _) => {
+            check_block_return(cx, block);
+        }
+        // a match expr, check all arms
+        // an if/if let expr, check both exprs
+        // note, if without else is going to be a type checking error anyways
+        // (except for unit type functions) so we don't match it
+
+        ExprKind::Match(_, ref arms, source) => {
+            match source {
+                MatchSource::Normal => {
+                    for arm in arms.iter() {
+                        check_final_expr(cx, &arm.body, Some(arm.body.span), RetReplacement::Block);
+                    }
+                }
+                MatchSource::IfDesugar { contains_else_clause: true } | MatchSource::IfLetDesugar { contains_else_clause: true } => {
+                    if let ExprKind::Block(ref ifblock, _) = arms[0].body.kind {
+                        check_block_return(cx, ifblock);
+                    }
+                    check_final_expr(cx, arms[1].body, None, RetReplacement::Empty);
+                }
+                _ => ()
+            }
+        }
+        _ => (),
+    }
+}
+
+fn emit_return_lint(cx: &LateContext<'_>, ret_span: Span, inner_span: Option<Span>, replacement: RetReplacement) {
+    match inner_span {
+        Some(inner_span) => {
+            if in_external_macro(cx.tcx.sess, inner_span) || inner_span.from_expansion() {
+                return;
+            }
+
+            span_lint_and_then(cx, NEEDLESS_RETURN, ret_span, "unneeded `return` statement", |diag| {
+                if let Some(snippet) = snippet_opt(cx, inner_span) {
+                    diag.span_suggestion(ret_span, "remove `return`", snippet, Applicability::MachineApplicable);
+                }
+            })
+        }
+        None => match replacement {
+            RetReplacement::Empty => {
+                span_lint_and_sugg(
+                    cx,
+                    NEEDLESS_RETURN,
+                    ret_span,
+                    "unneeded `return` statement",
+                    "remove `return`",
+                    String::new(),
+                    Applicability::MachineApplicable,
+                );
+            }
+            RetReplacement::Block => {
+                span_lint_and_sugg(
+                    cx,
+                    NEEDLESS_RETURN,
+                    ret_span,
+                    "unneeded `return` statement",
+                    "replace `return` with an empty block",
+                    "{}".to_string(),
+                    Applicability::MachineApplicable,
+                );
+            }
+        },
+    }
+}
diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
index 8ed20995a70..2bd0cccd39d 100644
--- a/clippy_lints/src/returns.rs
+++ b/clippy_lints/src/returns.rs
@@ -3,38 +3,11 @@ use rustc_ast::ast;
 use rustc_ast::visit::FnKind;
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
-use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
 use rustc_span::BytePos;
 
-use crate::utils::{snippet_opt, span_lint_and_sugg, span_lint_and_then};
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for return statements at the end of a block.
-    ///
-    /// **Why is this bad?** Removing the `return` and semicolon will make the code
-    /// more rusty.
-    ///
-    /// **Known problems:** If the computation returning the value borrows a local
-    /// variable, removing the `return` may run afoul of the borrow checker.
-    ///
-    /// **Example:**
-    /// ```rust
-    /// fn foo(x: usize) -> usize {
-    ///     return x;
-    /// }
-    /// ```
-    /// simplify to
-    /// ```rust
-    /// fn foo(x: usize) -> usize {
-    ///     x
-    /// }
-    /// ```
-    pub NEEDLESS_RETURN,
-    style,
-    "using a return statement like `return expr;` where an expression would suffice"
-}
+use crate::utils::{span_lint_and_sugg};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for unit (`()`) expressions that can be removed.
@@ -57,117 +30,12 @@ declare_clippy_lint! {
     "needless unit expression"
 }
 
-#[derive(PartialEq, Eq, Copy, Clone)]
-enum RetReplacement {
-    Empty,
-    Block,
-}
 
-declare_lint_pass!(Return => [NEEDLESS_RETURN, UNUSED_UNIT]);
-
-impl Return {
-    // Check the final stmt or expr in a block for unnecessary return.
-    fn check_block_return(&mut self, cx: &EarlyContext<'_>, block: &ast::Block) {
-        if let Some(stmt) = block.stmts.last() {
-            match stmt.kind {
-                ast::StmtKind::Expr(ref expr) | ast::StmtKind::Semi(ref expr) => {
-                    self.check_final_expr(cx, expr, Some(stmt.span), RetReplacement::Empty);
-                },
-                _ => (),
-            }
-        }
-    }
-
-    // Check the final expression in a block if it's a return.
-    fn check_final_expr(
-        &mut self,
-        cx: &EarlyContext<'_>,
-        expr: &ast::Expr,
-        span: Option<Span>,
-        replacement: RetReplacement,
-    ) {
-        match expr.kind {
-            // simple return is always "bad"
-            ast::ExprKind::Ret(ref inner) => {
-                // allow `#[cfg(a)] return a; #[cfg(b)] return b;`
-                if !expr.attrs.iter().any(attr_is_cfg) {
-                    Self::emit_return_lint(
-                        cx,
-                        span.expect("`else return` is not possible"),
-                        inner.as_ref().map(|i| i.span),
-                        replacement,
-                    );
-                }
-            },
-            // a whole block? check it!
-            ast::ExprKind::Block(ref block, _) => {
-                self.check_block_return(cx, block);
-            },
-            // an if/if let expr, check both exprs
-            // note, if without else is going to be a type checking error anyways
-            // (except for unit type functions) so we don't match it
-            ast::ExprKind::If(_, ref ifblock, Some(ref elsexpr)) => {
-                self.check_block_return(cx, ifblock);
-                self.check_final_expr(cx, elsexpr, None, RetReplacement::Empty);
-            },
-            // a match expr, check all arms
-            ast::ExprKind::Match(_, ref arms) => {
-                for arm in arms {
-                    self.check_final_expr(cx, &arm.body, Some(arm.body.span), RetReplacement::Block);
-                }
-            },
-            _ => (),
-        }
-    }
-
-    fn emit_return_lint(cx: &EarlyContext<'_>, ret_span: Span, inner_span: Option<Span>, replacement: RetReplacement) {
-        match inner_span {
-            Some(inner_span) => {
-                if in_external_macro(cx.sess(), inner_span) || inner_span.from_expansion() {
-                    return;
-                }
-
-                span_lint_and_then(cx, NEEDLESS_RETURN, ret_span, "unneeded `return` statement", |diag| {
-                    if let Some(snippet) = snippet_opt(cx, inner_span) {
-                        diag.span_suggestion(ret_span, "remove `return`", snippet, Applicability::MachineApplicable);
-                    }
-                })
-            },
-            None => match replacement {
-                RetReplacement::Empty => {
-                    span_lint_and_sugg(
-                        cx,
-                        NEEDLESS_RETURN,
-                        ret_span,
-                        "unneeded `return` statement",
-                        "remove `return`",
-                        String::new(),
-                        Applicability::MachineApplicable,
-                    );
-                },
-                RetReplacement::Block => {
-                    span_lint_and_sugg(
-                        cx,
-                        NEEDLESS_RETURN,
-                        ret_span,
-                        "unneeded `return` statement",
-                        "replace `return` with an empty block",
-                        "{}".to_string(),
-                        Applicability::MachineApplicable,
-                    );
-                },
-            },
-        }
-    }
-}
+declare_lint_pass!(Return => [UNUSED_UNIT]);
 
 impl EarlyLintPass for Return {
     fn check_fn(&mut self, cx: &EarlyContext<'_>, kind: FnKind<'_>, span: Span, _: ast::NodeId) {
-        match kind {
-            FnKind::Fn(.., Some(block)) => self.check_block_return(cx, block),
-            FnKind::Closure(_, body) => self.check_final_expr(cx, body, Some(body.span), RetReplacement::Empty),
-            FnKind::Fn(.., None) => {},
-        }
+
         if_chain! {
             if let ast::FnRetTy::Ty(ref ty) = kind.decl().output;
             if let ast::TyKind::Tup(ref vals) = ty.kind;
@@ -234,9 +102,6 @@ impl EarlyLintPass for Return {
     }
 }
 
-fn attr_is_cfg(attr: &ast::Attribute) -> bool {
-    attr.meta_item_list().is_some() && attr.has_name(sym!(cfg))
-}
 
 // get the def site
 #[must_use]
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index ccc9e250952..7464f1cc6de 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -1534,7 +1534,7 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
         group: "style",
         desc: "using a return statement like `return expr;` where an expression would suffice",
         deprecation: None,
-        module: "returns",
+        module: "needless_return",
     },
     Lint {
         name: "needless_update",
-- 
cgit 1.4.1-3-g733a5


From 85f4ef0fbd92453cf480af4e3f9eed877071ea2e Mon Sep 17 00:00:00 2001
From: jrqc <jrqc01@hotmail.com>
Date: Wed, 12 Aug 2020 17:14:12 +0300
Subject: Visitor added

---
 clippy_lints/src/needless_return.rs | 45 +++++++++++++++++++++++++++++++++++--
 1 file changed, 43 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/needless_return.rs b/clippy_lints/src/needless_return.rs
index a8876619ac1..861a7ec558c 100644
--- a/clippy_lints/src/needless_return.rs
+++ b/clippy_lints/src/needless_return.rs
@@ -2,12 +2,14 @@ use rustc_lint::{LateLintPass, LateContext};
 use rustc_ast::ast::Attribute;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_errors::Applicability;
-use rustc_hir::intravisit::FnKind;
+use rustc_hir::intravisit::{FnKind, walk_expr, NestedVisitorMap, Visitor};
 use rustc_span::source_map::Span;
 use rustc_middle::lint::in_external_macro;
+use rustc_middle::hir::map::Map;
+use rustc_middle::ty::subst::GenericArgKind;
 use rustc_hir::{Block, Body, Expr, ExprKind, FnDecl, HirId, MatchSource, StmtKind};
 
-use crate::utils::{snippet_opt, span_lint_and_sugg, span_lint_and_then};
+use crate::utils::{fn_def_id, snippet_opt, span_lint_and_sugg, span_lint_and_then};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for return statements at the end of a block.
@@ -164,3 +166,42 @@ fn emit_return_lint(cx: &LateContext<'_>, ret_span: Span, inner_span: Option<Spa
         },
     }
 }
+
+fn last_statement_borrows<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
+    let mut visitor = BorrowVisitor { cx, borrows: false };
+    walk_expr(&mut visitor, expr);
+    visitor.borrows
+}
+
+struct BorrowVisitor<'a, 'tcx> {
+    cx: &'a LateContext<'tcx>,
+    borrows: bool,
+}
+
+impl<'tcx> Visitor<'tcx> for BorrowVisitor<'_, 'tcx> {
+    type Map = Map<'tcx>;
+
+    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
+        if self.borrows {
+            return;
+        }
+
+        if let Some(def_id) = fn_def_id(self.cx, expr) {
+            self.borrows = self
+                .cx
+                .tcx
+                .fn_sig(def_id)
+                .output()
+                .skip_binder()
+                .walk()
+                .any(|arg| matches!(arg.unpack(), GenericArgKind::Lifetime(_)));
+        }
+
+        walk_expr(self, expr);
+    }
+
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::None
+    }
+}
+
-- 
cgit 1.4.1-3-g733a5


From 65d10c7abf4752923f040264c79433da8fc234ea Mon Sep 17 00:00:00 2001
From: jrqc <jrqc01@hotmail.com>
Date: Thu, 13 Aug 2020 15:14:08 +0300
Subject: Borrow checker added

---
 clippy_lints/src/needless_return.rs | 99 ++++++++++++++++++++++---------------
 clippy_lints/src/returns.rs         |  5 +-
 tests/ui/needless_return.fixed      | 10 ++++
 tests/ui/needless_return.rs         | 10 ++++
 4 files changed, 79 insertions(+), 45 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/needless_return.rs b/clippy_lints/src/needless_return.rs
index 861a7ec558c..ba280cd5a61 100644
--- a/clippy_lints/src/needless_return.rs
+++ b/clippy_lints/src/needless_return.rs
@@ -1,13 +1,13 @@
-use rustc_lint::{LateLintPass, LateContext};
 use rustc_ast::ast::Attribute;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_errors::Applicability;
-use rustc_hir::intravisit::{FnKind, walk_expr, NestedVisitorMap, Visitor};
-use rustc_span::source_map::Span;
-use rustc_middle::lint::in_external_macro;
+use rustc_hir::intravisit::{walk_expr, FnKind, NestedVisitorMap, Visitor};
+use rustc_hir::{Block, Body, Expr, ExprKind, FnDecl, HirId, MatchSource, StmtKind};
+use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::map::Map;
+use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::subst::GenericArgKind;
-use rustc_hir::{Block, Body, Expr, ExprKind, FnDecl, HirId, MatchSource, StmtKind};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::source_map::Span;
 
 use crate::utils::{fn_def_id, snippet_opt, span_lint_and_sugg, span_lint_and_then};
 
@@ -46,16 +46,39 @@ enum RetReplacement {
 declare_lint_pass!(NeedlessReturn => [NEEDLESS_RETURN]);
 
 impl<'tcx> LateLintPass<'tcx> for NeedlessReturn {
-    fn check_fn(&mut self, cx: &LateContext<'tcx>, kind: FnKind<'tcx>, _: &'tcx FnDecl<'tcx>, body: &'tcx Body<'tcx>, _: Span, _: HirId) {
+    fn check_fn(
+        &mut self,
+        cx: &LateContext<'tcx>,
+        kind: FnKind<'tcx>,
+        _: &'tcx FnDecl<'tcx>,
+        body: &'tcx Body<'tcx>,
+        _: Span,
+        _: HirId,
+    ) {
         match kind {
             FnKind::Closure(_) => {
-                check_final_expr(cx, &body.value, Some(body.value.span), RetReplacement::Empty)
-            }
+                if !last_statement_borrows(cx, &body.value) {
+                    check_final_expr(cx, &body.value, Some(body.value.span), RetReplacement::Empty)
+                }
+            },
             FnKind::ItemFn(..) | FnKind::Method(..) => {
                 if let ExprKind::Block(ref block, _) = body.value.kind {
-                    check_block_return(cx, block)
+                    if let Some(expr) = block.expr {
+                        if !last_statement_borrows(cx, expr) {
+                            check_final_expr(cx, expr, Some(expr.span), RetReplacement::Empty);
+                        }
+                    } else if let Some(stmt) = block.stmts.iter().last() {
+                        match stmt.kind {
+                            StmtKind::Expr(ref expr) | StmtKind::Semi(ref expr) => {
+                                if !last_statement_borrows(cx, expr) {
+                                    check_final_expr(cx, expr, Some(stmt.span), RetReplacement::Empty);
+                                }
+                            },
+                            _ => (),
+                        }
+                    }
                 }
-            }
+            },
         }
     }
 }
@@ -71,23 +94,16 @@ fn check_block_return(cx: &LateContext<'_>, block: &Block<'_>) {
         match stmt.kind {
             StmtKind::Expr(ref expr) | StmtKind::Semi(ref expr) => {
                 check_final_expr(cx, expr, Some(stmt.span), RetReplacement::Empty);
-            }
+            },
             _ => (),
         }
     }
 }
 
-
-fn check_final_expr(
-    cx: &LateContext<'_>,
-    expr: &Expr<'_>,
-    span: Option<Span>,
-    replacement: RetReplacement,
-) {
+fn check_final_expr(cx: &LateContext<'_>, expr: &Expr<'_>, span: Option<Span>, replacement: RetReplacement) {
     match expr.kind {
         // simple return is always "bad"
         ExprKind::Ret(ref inner) => {
-
             // allow `#[cfg(a)] return a; #[cfg(b)] return b;`
             if !expr.attrs.iter().any(attr_is_cfg) {
                 emit_return_lint(
@@ -97,32 +113,34 @@ fn check_final_expr(
                     replacement,
                 );
             }
-        }
+        },
         // a whole block? check it!
         ExprKind::Block(ref block, _) => {
             check_block_return(cx, block);
-        }
+        },
         // a match expr, check all arms
         // an if/if let expr, check both exprs
         // note, if without else is going to be a type checking error anyways
         // (except for unit type functions) so we don't match it
-
-        ExprKind::Match(_, ref arms, source) => {
-            match source {
-                MatchSource::Normal => {
-                    for arm in arms.iter() {
-                        check_final_expr(cx, &arm.body, Some(arm.body.span), RetReplacement::Block);
-                    }
-                }
-                MatchSource::IfDesugar { contains_else_clause: true } | MatchSource::IfLetDesugar { contains_else_clause: true } => {
-                    if let ExprKind::Block(ref ifblock, _) = arms[0].body.kind {
-                        check_block_return(cx, ifblock);
-                    }
-                    check_final_expr(cx, arms[1].body, None, RetReplacement::Empty);
+        ExprKind::Match(_, ref arms, source) => match source {
+            MatchSource::Normal => {
+                for arm in arms.iter() {
+                    check_final_expr(cx, &arm.body, Some(arm.body.span), RetReplacement::Block);
                 }
-                _ => ()
+            },
+            MatchSource::IfDesugar {
+                contains_else_clause: true,
             }
-        }
+            | MatchSource::IfLetDesugar {
+                contains_else_clause: true,
+            } => {
+                if let ExprKind::Block(ref ifblock, _) = arms[0].body.kind {
+                    check_block_return(cx, ifblock);
+                }
+                check_final_expr(cx, arms[1].body, None, RetReplacement::Empty);
+            },
+            _ => (),
+        },
         _ => (),
     }
 }
@@ -139,7 +157,7 @@ fn emit_return_lint(cx: &LateContext<'_>, ret_span: Span, inner_span: Option<Spa
                     diag.span_suggestion(ret_span, "remove `return`", snippet, Applicability::MachineApplicable);
                 }
             })
-        }
+        },
         None => match replacement {
             RetReplacement::Empty => {
                 span_lint_and_sugg(
@@ -151,7 +169,7 @@ fn emit_return_lint(cx: &LateContext<'_>, ret_span: Span, inner_span: Option<Spa
                     String::new(),
                     Applicability::MachineApplicable,
                 );
-            }
+            },
             RetReplacement::Block => {
                 span_lint_and_sugg(
                     cx,
@@ -162,7 +180,7 @@ fn emit_return_lint(cx: &LateContext<'_>, ret_span: Span, inner_span: Option<Spa
                     "{}".to_string(),
                     Applicability::MachineApplicable,
                 );
-            }
+            },
         },
     }
 }
@@ -204,4 +222,3 @@ impl<'tcx> Visitor<'tcx> for BorrowVisitor<'_, 'tcx> {
         NestedVisitorMap::None
     }
 }
-
diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
index 2bd0cccd39d..593e2f6c74b 100644
--- a/clippy_lints/src/returns.rs
+++ b/clippy_lints/src/returns.rs
@@ -7,7 +7,7 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
 use rustc_span::BytePos;
 
-use crate::utils::{span_lint_and_sugg};
+use crate::utils::span_lint_and_sugg;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for unit (`()`) expressions that can be removed.
@@ -30,12 +30,10 @@ declare_clippy_lint! {
     "needless unit expression"
 }
 
-
 declare_lint_pass!(Return => [UNUSED_UNIT]);
 
 impl EarlyLintPass for Return {
     fn check_fn(&mut self, cx: &EarlyContext<'_>, kind: FnKind<'_>, span: Span, _: ast::NodeId) {
-
         if_chain! {
             if let ast::FnRetTy::Ty(ref ty) = kind.decl().output;
             if let ast::TyKind::Tup(ref vals) = ty.kind;
@@ -102,7 +100,6 @@ impl EarlyLintPass for Return {
     }
 }
 
-
 // get the def site
 #[must_use]
 fn get_def(span: Span) -> Option<Span> {
diff --git a/tests/ui/needless_return.fixed b/tests/ui/needless_return.fixed
index ad20e238107..6b5cf2626df 100644
--- a/tests/ui/needless_return.fixed
+++ b/tests/ui/needless_return.fixed
@@ -69,6 +69,16 @@ fn test_void_match(x: u32) {
     }
 }
 
+mod no_lint_if_stmt_borrows {
+    mod issue_5858 {
+        fn read_line() -> String {
+            use std::io::BufRead;
+            let stdin = ::std::io::stdin();
+            return stdin.lock().lines().next().unwrap().unwrap();
+        }
+    }
+}
+
 fn main() {
     let _ = test_end_of_fn();
     let _ = test_no_semicolon();
diff --git a/tests/ui/needless_return.rs b/tests/ui/needless_return.rs
index af0cdfb207f..1a693c9aa53 100644
--- a/tests/ui/needless_return.rs
+++ b/tests/ui/needless_return.rs
@@ -69,6 +69,16 @@ fn test_void_match(x: u32) {
     }
 }
 
+mod no_lint_if_stmt_borrows {
+    mod issue_5858 {
+        fn read_line() -> String {
+            use std::io::BufRead;
+            let stdin = ::std::io::stdin();
+            return stdin.lock().lines().next().unwrap().unwrap();
+        }
+    }
+}
+
 fn main() {
     let _ = test_end_of_fn();
     let _ = test_no_semicolon();
-- 
cgit 1.4.1-3-g733a5


From cd6ca72e0e4040a5c3a6623c2e8533db91db6042 Mon Sep 17 00:00:00 2001
From: jrqc <jrqc01@hotmail.com>
Date: Thu, 13 Aug 2020 15:21:09 +0300
Subject: Known problems changed

---
 clippy_lints/src/needless_return.rs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/needless_return.rs b/clippy_lints/src/needless_return.rs
index ba280cd5a61..eb0bf12c0ab 100644
--- a/clippy_lints/src/needless_return.rs
+++ b/clippy_lints/src/needless_return.rs
@@ -17,8 +17,7 @@ declare_clippy_lint! {
     /// **Why is this bad?** Removing the `return` and semicolon will make the code
     /// more rusty.
     ///
-    /// **Known problems:** If the computation returning the value borrows a local
-    /// variable, removing the `return` may run afoul of the borrow checker.
+    /// **Known problems:** None.
     ///
     /// **Example:**
     /// ```rust
-- 
cgit 1.4.1-3-g733a5


From a7d5c2f967dd1f075ba5f8c4ca05c4b2ca2d22b4 Mon Sep 17 00:00:00 2001
From: jrqc <jrqc01@hotmail.com>
Date: Thu, 13 Aug 2020 19:24:34 +0300
Subject: Modifications according to the code review

---
 clippy_lints/src/let_and_return.rs  | 124 -------------
 clippy_lints/src/lib.rs             |  26 ++-
 clippy_lints/src/needless_return.rs | 223 -----------------------
 clippy_lints/src/returns.rs         | 347 +++++++++++++++++++++++++-----------
 clippy_lints/src/unused_unit.rs     | 145 +++++++++++++++
 tests/ui/needless_return.fixed      |  11 ++
 tests/ui/needless_return.rs         |  11 ++
 7 files changed, 425 insertions(+), 462 deletions(-)
 delete mode 100644 clippy_lints/src/let_and_return.rs
 delete mode 100644 clippy_lints/src/needless_return.rs
 create mode 100644 clippy_lints/src/unused_unit.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/let_and_return.rs b/clippy_lints/src/let_and_return.rs
deleted file mode 100644
index fa560ffb980..00000000000
--- a/clippy_lints/src/let_and_return.rs
+++ /dev/null
@@ -1,124 +0,0 @@
-use if_chain::if_chain;
-use rustc_errors::Applicability;
-use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
-use rustc_hir::{Block, Expr, ExprKind, PatKind, StmtKind};
-use rustc_lint::{LateContext, LateLintPass, LintContext};
-use rustc_middle::hir::map::Map;
-use rustc_middle::lint::in_external_macro;
-use rustc_middle::ty::subst::GenericArgKind;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-
-use crate::utils::{fn_def_id, in_macro, match_qpath, snippet_opt, span_lint_and_then};
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for `let`-bindings, which are subsequently
-    /// returned.
-    ///
-    /// **Why is this bad?** It is just extraneous code. Remove it to make your code
-    /// more rusty.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    /// ```rust
-    /// fn foo() -> String {
-    ///     let x = String::new();
-    ///     x
-    /// }
-    /// ```
-    /// instead, use
-    /// ```
-    /// fn foo() -> String {
-    ///     String::new()
-    /// }
-    /// ```
-    pub LET_AND_RETURN,
-    style,
-    "creating a let-binding and then immediately returning it like `let x = expr; x` at the end of a block"
-}
-
-declare_lint_pass!(LetReturn => [LET_AND_RETURN]);
-
-impl<'tcx> LateLintPass<'tcx> for LetReturn {
-    fn check_block(&mut self, cx: &LateContext<'tcx>, block: &'tcx Block<'_>) {
-        // we need both a let-binding stmt and an expr
-        if_chain! {
-            if let Some(retexpr) = block.expr;
-            if let Some(stmt) = block.stmts.iter().last();
-            if let StmtKind::Local(local) = &stmt.kind;
-            if local.ty.is_none();
-            if local.attrs.is_empty();
-            if let Some(initexpr) = &local.init;
-            if let PatKind::Binding(.., ident, _) = local.pat.kind;
-            if let ExprKind::Path(qpath) = &retexpr.kind;
-            if match_qpath(qpath, &[&*ident.name.as_str()]);
-            if !last_statement_borrows(cx, initexpr);
-            if !in_external_macro(cx.sess(), initexpr.span);
-            if !in_external_macro(cx.sess(), retexpr.span);
-            if !in_external_macro(cx.sess(), local.span);
-            if !in_macro(local.span);
-            then {
-                span_lint_and_then(
-                    cx,
-                    LET_AND_RETURN,
-                    retexpr.span,
-                    "returning the result of a `let` binding from a block",
-                    |err| {
-                        err.span_label(local.span, "unnecessary `let` binding");
-
-                        if let Some(snippet) = snippet_opt(cx, initexpr.span) {
-                            err.multipart_suggestion(
-                                "return the expression directly",
-                                vec![
-                                    (local.span, String::new()),
-                                    (retexpr.span, snippet),
-                                ],
-                                Applicability::MachineApplicable,
-                            );
-                        } else {
-                            err.span_help(initexpr.span, "this expression can be directly returned");
-                        }
-                    },
-                );
-            }
-        }
-    }
-}
-
-fn last_statement_borrows<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
-    let mut visitor = BorrowVisitor { cx, borrows: false };
-    walk_expr(&mut visitor, expr);
-    visitor.borrows
-}
-
-struct BorrowVisitor<'a, 'tcx> {
-    cx: &'a LateContext<'tcx>,
-    borrows: bool,
-}
-
-impl<'tcx> Visitor<'tcx> for BorrowVisitor<'_, 'tcx> {
-    type Map = Map<'tcx>;
-
-    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
-        if self.borrows {
-            return;
-        }
-
-        if let Some(def_id) = fn_def_id(self.cx, expr) {
-            self.borrows = self
-                .cx
-                .tcx
-                .fn_sig(def_id)
-                .output()
-                .skip_binder()
-                .walk()
-                .any(|arg| matches!(arg.unpack(), GenericArgKind::Lifetime(_)));
-        }
-
-        walk_expr(self, expr);
-    }
-
-    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-        NestedVisitorMap::None
-    }
-}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index d2f66cf9bd0..63de0f8a0c2 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -218,7 +218,6 @@ mod large_const_arrays;
 mod large_enum_variant;
 mod large_stack_arrays;
 mod len_zero;
-mod let_and_return;
 mod let_if_seq;
 mod let_underscore;
 mod lifetimes;
@@ -256,7 +255,6 @@ mod needless_borrow;
 mod needless_borrowed_ref;
 mod needless_continue;
 mod needless_pass_by_value;
-mod needless_return;
 mod needless_update;
 mod neg_cmp_op_on_partial_ord;
 mod neg_multiply;
@@ -311,6 +309,7 @@ mod unnested_or_patterns;
 mod unsafe_removed_from_name;
 mod unused_io_amount;
 mod unused_self;
+mod unused_unit;
 mod unwrap;
 mod use_self;
 mod useless_conversion;
@@ -587,7 +586,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &large_stack_arrays::LARGE_STACK_ARRAYS,
         &len_zero::LEN_WITHOUT_IS_EMPTY,
         &len_zero::LEN_ZERO,
-        &let_and_return::LET_AND_RETURN,
+        &returns::LET_AND_RETURN,
         &let_if_seq::USELESS_LET_IF_SEQ,
         &let_underscore::LET_UNDERSCORE_LOCK,
         &let_underscore::LET_UNDERSCORE_MUST_USE,
@@ -727,7 +726,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &needless_borrowed_ref::NEEDLESS_BORROWED_REFERENCE,
         &needless_continue::NEEDLESS_CONTINUE,
         &needless_pass_by_value::NEEDLESS_PASS_BY_VALUE,
-        &needless_return::NEEDLESS_RETURN,
+        &returns::NEEDLESS_RETURN,
         &needless_update::NEEDLESS_UPDATE,
         &neg_cmp_op_on_partial_ord::NEG_CMP_OP_ON_PARTIAL_ORD,
         &neg_multiply::NEG_MULTIPLY,
@@ -771,7 +770,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &regex::INVALID_REGEX,
         &regex::TRIVIAL_REGEX,
         &repeat_once::REPEAT_ONCE,
-        &returns::UNUSED_UNIT,
+        &unused_unit::UNUSED_UNIT,
         &serde_api::SERDE_API_MISUSE,
         &shadow::SHADOW_REUSE,
         &shadow::SHADOW_SAME,
@@ -1026,9 +1025,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_early_pass(|| box misc_early::MiscEarlyLints);
     store.register_early_pass(|| box redundant_closure_call::RedundantClosureCall);
     store.register_late_pass(|| box redundant_closure_call::RedundantClosureCall);
-    store.register_early_pass(|| box returns::Return);
-    store.register_late_pass(|| box let_and_return::LetReturn);
-    store.register_late_pass(|| box needless_return::NeedlessReturn);
+    store.register_early_pass(|| box unused_unit::UnusedUnit);
+    store.register_late_pass(|| box returns::Return);
     store.register_early_pass(|| box collapsible_if::CollapsibleIf);
     store.register_early_pass(|| box items_after_statements::ItemsAfterStatements);
     store.register_early_pass(|| box precedence::Precedence);
@@ -1286,7 +1284,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&large_enum_variant::LARGE_ENUM_VARIANT),
         LintId::of(&len_zero::LEN_WITHOUT_IS_EMPTY),
         LintId::of(&len_zero::LEN_ZERO),
-        LintId::of(&let_and_return::LET_AND_RETURN),
+        LintId::of(&returns::LET_AND_RETURN),
         LintId::of(&let_underscore::LET_UNDERSCORE_LOCK),
         LintId::of(&lifetimes::EXTRA_UNUSED_LIFETIMES),
         LintId::of(&lifetimes::NEEDLESS_LIFETIMES),
@@ -1383,7 +1381,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&needless_bool::BOOL_COMPARISON),
         LintId::of(&needless_bool::NEEDLESS_BOOL),
         LintId::of(&needless_borrowed_ref::NEEDLESS_BORROWED_REFERENCE),
-        LintId::of(&needless_return::NEEDLESS_RETURN),
+        LintId::of(&returns::NEEDLESS_RETURN),
         LintId::of(&needless_update::NEEDLESS_UPDATE),
         LintId::of(&neg_cmp_op_on_partial_ord::NEG_CMP_OP_ON_PARTIAL_ORD),
         LintId::of(&neg_multiply::NEG_MULTIPLY),
@@ -1416,7 +1414,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&regex::INVALID_REGEX),
         LintId::of(&regex::TRIVIAL_REGEX),
         LintId::of(&repeat_once::REPEAT_ONCE),
-        LintId::of(&returns::UNUSED_UNIT),
+        LintId::of(&unused_unit::UNUSED_UNIT),
         LintId::of(&serde_api::SERDE_API_MISUSE),
         LintId::of(&single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS),
         LintId::of(&slow_vector_initialization::SLOW_VECTOR_INITIALIZATION),
@@ -1502,7 +1500,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&inherent_to_string::INHERENT_TO_STRING),
         LintId::of(&len_zero::LEN_WITHOUT_IS_EMPTY),
         LintId::of(&len_zero::LEN_ZERO),
-        LintId::of(&let_and_return::LET_AND_RETURN),
+        LintId::of(&returns::LET_AND_RETURN),
         LintId::of(&literal_representation::INCONSISTENT_DIGIT_GROUPING),
         LintId::of(&loops::EMPTY_LOOP),
         LintId::of(&loops::FOR_KV_MAP),
@@ -1545,7 +1543,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&misc_early::MIXED_CASE_HEX_LITERALS),
         LintId::of(&misc_early::REDUNDANT_PATTERN),
         LintId::of(&mut_reference::UNNECESSARY_MUT_PASSED),
-        LintId::of(&needless_return::NEEDLESS_RETURN),
+        LintId::of(&returns::NEEDLESS_RETURN),
         LintId::of(&neg_multiply::NEG_MULTIPLY),
         LintId::of(&new_without_default::NEW_WITHOUT_DEFAULT),
         LintId::of(&non_expressive_names::JUST_UNDERSCORES_AND_DIGITS),
@@ -1557,7 +1555,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&redundant_field_names::REDUNDANT_FIELD_NAMES),
         LintId::of(&redundant_static_lifetimes::REDUNDANT_STATIC_LIFETIMES),
         LintId::of(&regex::TRIVIAL_REGEX),
-        LintId::of(&returns::UNUSED_UNIT),
+        LintId::of(&unused_unit::UNUSED_UNIT),
         LintId::of(&single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS),
         LintId::of(&strings::STRING_LIT_AS_BYTES),
         LintId::of(&tabs_in_doc_comments::TABS_IN_DOC_COMMENTS),
diff --git a/clippy_lints/src/needless_return.rs b/clippy_lints/src/needless_return.rs
deleted file mode 100644
index eb0bf12c0ab..00000000000
--- a/clippy_lints/src/needless_return.rs
+++ /dev/null
@@ -1,223 +0,0 @@
-use rustc_ast::ast::Attribute;
-use rustc_errors::Applicability;
-use rustc_hir::intravisit::{walk_expr, FnKind, NestedVisitorMap, Visitor};
-use rustc_hir::{Block, Body, Expr, ExprKind, FnDecl, HirId, MatchSource, StmtKind};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::hir::map::Map;
-use rustc_middle::lint::in_external_macro;
-use rustc_middle::ty::subst::GenericArgKind;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::source_map::Span;
-
-use crate::utils::{fn_def_id, snippet_opt, span_lint_and_sugg, span_lint_and_then};
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for return statements at the end of a block.
-    ///
-    /// **Why is this bad?** Removing the `return` and semicolon will make the code
-    /// more rusty.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    /// ```rust
-    /// fn foo(x: usize) -> usize {
-    ///     return x;
-    /// }
-    /// ```
-    /// simplify to
-    /// ```rust
-    /// fn foo(x: usize) -> usize {
-    ///     x
-    /// }
-    /// ```
-    pub NEEDLESS_RETURN,
-    style,
-    "using a return statement like `return expr;` where an expression would suffice"
-}
-
-#[derive(PartialEq, Eq, Copy, Clone)]
-enum RetReplacement {
-    Empty,
-    Block,
-}
-
-declare_lint_pass!(NeedlessReturn => [NEEDLESS_RETURN]);
-
-impl<'tcx> LateLintPass<'tcx> for NeedlessReturn {
-    fn check_fn(
-        &mut self,
-        cx: &LateContext<'tcx>,
-        kind: FnKind<'tcx>,
-        _: &'tcx FnDecl<'tcx>,
-        body: &'tcx Body<'tcx>,
-        _: Span,
-        _: HirId,
-    ) {
-        match kind {
-            FnKind::Closure(_) => {
-                if !last_statement_borrows(cx, &body.value) {
-                    check_final_expr(cx, &body.value, Some(body.value.span), RetReplacement::Empty)
-                }
-            },
-            FnKind::ItemFn(..) | FnKind::Method(..) => {
-                if let ExprKind::Block(ref block, _) = body.value.kind {
-                    if let Some(expr) = block.expr {
-                        if !last_statement_borrows(cx, expr) {
-                            check_final_expr(cx, expr, Some(expr.span), RetReplacement::Empty);
-                        }
-                    } else if let Some(stmt) = block.stmts.iter().last() {
-                        match stmt.kind {
-                            StmtKind::Expr(ref expr) | StmtKind::Semi(ref expr) => {
-                                if !last_statement_borrows(cx, expr) {
-                                    check_final_expr(cx, expr, Some(stmt.span), RetReplacement::Empty);
-                                }
-                            },
-                            _ => (),
-                        }
-                    }
-                }
-            },
-        }
-    }
-}
-
-fn attr_is_cfg(attr: &Attribute) -> bool {
-    attr.meta_item_list().is_some() && attr.has_name(sym!(cfg))
-}
-
-fn check_block_return(cx: &LateContext<'_>, block: &Block<'_>) {
-    if let Some(expr) = block.expr {
-        check_final_expr(cx, expr, Some(expr.span), RetReplacement::Empty);
-    } else if let Some(stmt) = block.stmts.iter().last() {
-        match stmt.kind {
-            StmtKind::Expr(ref expr) | StmtKind::Semi(ref expr) => {
-                check_final_expr(cx, expr, Some(stmt.span), RetReplacement::Empty);
-            },
-            _ => (),
-        }
-    }
-}
-
-fn check_final_expr(cx: &LateContext<'_>, expr: &Expr<'_>, span: Option<Span>, replacement: RetReplacement) {
-    match expr.kind {
-        // simple return is always "bad"
-        ExprKind::Ret(ref inner) => {
-            // allow `#[cfg(a)] return a; #[cfg(b)] return b;`
-            if !expr.attrs.iter().any(attr_is_cfg) {
-                emit_return_lint(
-                    cx,
-                    span.expect("`else return` is not possible"),
-                    inner.as_ref().map(|i| i.span),
-                    replacement,
-                );
-            }
-        },
-        // a whole block? check it!
-        ExprKind::Block(ref block, _) => {
-            check_block_return(cx, block);
-        },
-        // a match expr, check all arms
-        // an if/if let expr, check both exprs
-        // note, if without else is going to be a type checking error anyways
-        // (except for unit type functions) so we don't match it
-        ExprKind::Match(_, ref arms, source) => match source {
-            MatchSource::Normal => {
-                for arm in arms.iter() {
-                    check_final_expr(cx, &arm.body, Some(arm.body.span), RetReplacement::Block);
-                }
-            },
-            MatchSource::IfDesugar {
-                contains_else_clause: true,
-            }
-            | MatchSource::IfLetDesugar {
-                contains_else_clause: true,
-            } => {
-                if let ExprKind::Block(ref ifblock, _) = arms[0].body.kind {
-                    check_block_return(cx, ifblock);
-                }
-                check_final_expr(cx, arms[1].body, None, RetReplacement::Empty);
-            },
-            _ => (),
-        },
-        _ => (),
-    }
-}
-
-fn emit_return_lint(cx: &LateContext<'_>, ret_span: Span, inner_span: Option<Span>, replacement: RetReplacement) {
-    match inner_span {
-        Some(inner_span) => {
-            if in_external_macro(cx.tcx.sess, inner_span) || inner_span.from_expansion() {
-                return;
-            }
-
-            span_lint_and_then(cx, NEEDLESS_RETURN, ret_span, "unneeded `return` statement", |diag| {
-                if let Some(snippet) = snippet_opt(cx, inner_span) {
-                    diag.span_suggestion(ret_span, "remove `return`", snippet, Applicability::MachineApplicable);
-                }
-            })
-        },
-        None => match replacement {
-            RetReplacement::Empty => {
-                span_lint_and_sugg(
-                    cx,
-                    NEEDLESS_RETURN,
-                    ret_span,
-                    "unneeded `return` statement",
-                    "remove `return`",
-                    String::new(),
-                    Applicability::MachineApplicable,
-                );
-            },
-            RetReplacement::Block => {
-                span_lint_and_sugg(
-                    cx,
-                    NEEDLESS_RETURN,
-                    ret_span,
-                    "unneeded `return` statement",
-                    "replace `return` with an empty block",
-                    "{}".to_string(),
-                    Applicability::MachineApplicable,
-                );
-            },
-        },
-    }
-}
-
-fn last_statement_borrows<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
-    let mut visitor = BorrowVisitor { cx, borrows: false };
-    walk_expr(&mut visitor, expr);
-    visitor.borrows
-}
-
-struct BorrowVisitor<'a, 'tcx> {
-    cx: &'a LateContext<'tcx>,
-    borrows: bool,
-}
-
-impl<'tcx> Visitor<'tcx> for BorrowVisitor<'_, 'tcx> {
-    type Map = Map<'tcx>;
-
-    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
-        if self.borrows {
-            return;
-        }
-
-        if let Some(def_id) = fn_def_id(self.cx, expr) {
-            self.borrows = self
-                .cx
-                .tcx
-                .fn_sig(def_id)
-                .output()
-                .skip_binder()
-                .walk()
-                .any(|arg| matches!(arg.unpack(), GenericArgKind::Lifetime(_)));
-        }
-
-        walk_expr(self, expr);
-    }
-
-    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-        NestedVisitorMap::None
-    }
-}
diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
index 593e2f6c74b..4d91f9be999 100644
--- a/clippy_lints/src/returns.rs
+++ b/clippy_lints/src/returns.rs
@@ -1,145 +1,290 @@
 use if_chain::if_chain;
-use rustc_ast::ast;
-use rustc_ast::visit::FnKind;
+use rustc_ast::ast::Attribute;
 use rustc_errors::Applicability;
-use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
+use rustc_hir::intravisit::{walk_expr, FnKind, NestedVisitorMap, Visitor};
+use rustc_hir::{Block, Body, Expr, ExprKind, FnDecl, HirId, MatchSource, PatKind, StmtKind};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_middle::hir::map::Map;
+use rustc_middle::lint::in_external_macro;
+use rustc_middle::ty::subst::GenericArgKind;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
-use rustc_span::BytePos;
 
-use crate::utils::span_lint_and_sugg;
+use crate::utils::{fn_def_id, in_macro, match_qpath, snippet_opt, span_lint_and_sugg, span_lint_and_then};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for unit (`()`) expressions that can be removed.
+    /// **What it does:** Checks for `let`-bindings, which are subsequently
+    /// returned.
     ///
-    /// **Why is this bad?** Such expressions add no value, but can make the code
-    /// less readable. Depending on formatting they can make a `break` or `return`
-    /// statement look like a function call.
+    /// **Why is this bad?** It is just extraneous code. Remove it to make your code
+    /// more rusty.
     ///
-    /// **Known problems:** The lint currently misses unit return types in types,
-    /// e.g., the `F` in `fn generic_unit<F: Fn() -> ()>(f: F) { .. }`.
+    /// **Known problems:** None.
     ///
     /// **Example:**
     /// ```rust
-    /// fn return_unit() -> () {
-    ///     ()
+    /// fn foo() -> String {
+    ///     let x = String::new();
+    ///     x
     /// }
     /// ```
-    pub UNUSED_UNIT,
+    /// instead, use
+    /// ```
+    /// fn foo() -> String {
+    ///     String::new()
+    /// }
+    /// ```
+    pub LET_AND_RETURN,
     style,
-    "needless unit expression"
+    "creating a let-binding and then immediately returning it like `let x = expr; x` at the end of a block"
 }
 
-declare_lint_pass!(Return => [UNUSED_UNIT]);
+declare_clippy_lint! {
+    /// **What it does:** Checks for return statements at the end of a block.
+    ///
+    /// **Why is this bad?** Removing the `return` and semicolon will make the code
+    /// more rusty.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// ```rust
+    /// fn foo(x: usize) -> usize {
+    ///     return x;
+    /// }
+    /// ```
+    /// simplify to
+    /// ```rust
+    /// fn foo(x: usize) -> usize {
+    ///     x
+    /// }
+    /// ```
+    pub NEEDLESS_RETURN,
+    style,
+    "using a return statement like `return expr;` where an expression would suffice"
+}
 
-impl EarlyLintPass for Return {
-    fn check_fn(&mut self, cx: &EarlyContext<'_>, kind: FnKind<'_>, span: Span, _: ast::NodeId) {
-        if_chain! {
-            if let ast::FnRetTy::Ty(ref ty) = kind.decl().output;
-            if let ast::TyKind::Tup(ref vals) = ty.kind;
-            if vals.is_empty() && !ty.span.from_expansion() && get_def(span) == get_def(ty.span);
-            then {
-                lint_unneeded_unit_return(cx, ty, span);
-            }
-        }
-    }
+#[derive(PartialEq, Eq, Copy, Clone)]
+enum RetReplacement {
+    Empty,
+    Block,
+}
+
+declare_lint_pass!(Return => [LET_AND_RETURN, NEEDLESS_RETURN]);
 
-    fn check_block(&mut self, cx: &EarlyContext<'_>, block: &ast::Block) {
+impl<'tcx> LateLintPass<'tcx> for Return {
+    fn check_block(&mut self, cx: &LateContext<'tcx>, block: &'tcx Block<'_>) {
+        // we need both a let-binding stmt and an expr
         if_chain! {
-            if let Some(ref stmt) = block.stmts.last();
-            if let ast::StmtKind::Expr(ref expr) = stmt.kind;
-            if is_unit_expr(expr) && !stmt.span.from_expansion();
+            if let Some(retexpr) = block.expr;
+            if let Some(stmt) = block.stmts.iter().last();
+            if let StmtKind::Local(local) = &stmt.kind;
+            if local.ty.is_none();
+            if local.attrs.is_empty();
+            if let Some(initexpr) = &local.init;
+            if let PatKind::Binding(.., ident, _) = local.pat.kind;
+            if let ExprKind::Path(qpath) = &retexpr.kind;
+            if match_qpath(qpath, &[&*ident.name.as_str()]);
+            if !last_statement_borrows(cx, initexpr);
+            if !in_external_macro(cx.sess(), initexpr.span);
+            if !in_external_macro(cx.sess(), retexpr.span);
+            if !in_external_macro(cx.sess(), local.span);
+            if !in_macro(local.span);
             then {
-                let sp = expr.span;
-                span_lint_and_sugg(
+                span_lint_and_then(
                     cx,
-                    UNUSED_UNIT,
-                    sp,
-                    "unneeded unit expression",
-                    "remove the final `()`",
-                    String::new(),
-                    Applicability::MachineApplicable,
+                    LET_AND_RETURN,
+                    retexpr.span,
+                    "returning the result of a `let` binding from a block",
+                    |err| {
+                        err.span_label(local.span, "unnecessary `let` binding");
+
+                        if let Some(snippet) = snippet_opt(cx, initexpr.span) {
+                            err.multipart_suggestion(
+                                "return the expression directly",
+                                vec![
+                                    (local.span, String::new()),
+                                    (retexpr.span, snippet),
+                                ],
+                                Applicability::MachineApplicable,
+                            );
+                        } else {
+                            err.span_help(initexpr.span, "this expression can be directly returned");
+                        }
+                    },
                 );
             }
         }
     }
 
-    fn check_expr(&mut self, cx: &EarlyContext<'_>, e: &ast::Expr) {
-        match e.kind {
-            ast::ExprKind::Ret(Some(ref expr)) | ast::ExprKind::Break(_, Some(ref expr)) => {
-                if is_unit_expr(expr) && !expr.span.from_expansion() {
-                    span_lint_and_sugg(
-                        cx,
-                        UNUSED_UNIT,
-                        expr.span,
-                        "unneeded `()`",
-                        "remove the `()`",
-                        String::new(),
-                        Applicability::MachineApplicable,
-                    );
+    fn check_fn(
+        &mut self,
+        cx: &LateContext<'tcx>,
+        kind: FnKind<'tcx>,
+        _: &'tcx FnDecl<'tcx>,
+        body: &'tcx Body<'tcx>,
+        _: Span,
+        _: HirId,
+    ) {
+        match kind {
+            FnKind::Closure(_) => check_final_expr(cx, &body.value, Some(body.value.span), RetReplacement::Empty),
+            FnKind::ItemFn(..) | FnKind::Method(..) => {
+                if let ExprKind::Block(ref block, _) = body.value.kind {
+                    check_block_return(cx, block);
                 }
             },
-            _ => (),
         }
     }
+}
 
-    fn check_poly_trait_ref(&mut self, cx: &EarlyContext<'_>, poly: &ast::PolyTraitRef, _: &ast::TraitBoundModifier) {
-        let segments = &poly.trait_ref.path.segments;
+fn attr_is_cfg(attr: &Attribute) -> bool {
+    attr.meta_item_list().is_some() && attr.has_name(sym!(cfg))
+}
 
-        if_chain! {
-            if segments.len() == 1;
-            if ["Fn", "FnMut", "FnOnce"].contains(&&*segments[0].ident.name.as_str());
-            if let Some(args) = &segments[0].args;
-            if let ast::GenericArgs::Parenthesized(generic_args) = &**args;
-            if let ast::FnRetTy::Ty(ty) = &generic_args.output;
-            if ty.kind.is_unit();
-            then {
-                lint_unneeded_unit_return(cx, ty, generic_args.span);
-            }
+fn check_block_return<'tcx>(cx: &LateContext<'tcx>, block: &Block<'tcx>) {
+    if let Some(expr) = block.expr {
+        check_final_expr(cx, expr, Some(expr.span), RetReplacement::Empty);
+    } else if let Some(stmt) = block.stmts.iter().last() {
+        match stmt.kind {
+            StmtKind::Expr(ref expr) | StmtKind::Semi(ref expr) => {
+                check_final_expr(cx, expr, Some(stmt.span), RetReplacement::Empty);
+            },
+            _ => (),
         }
     }
 }
 
-// get the def site
-#[must_use]
-fn get_def(span: Span) -> Option<Span> {
-    if span.from_expansion() {
-        Some(span.ctxt().outer_expn_data().def_site)
-    } else {
-        None
+fn check_final_expr<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx Expr<'tcx>,
+    span: Option<Span>,
+    replacement: RetReplacement,
+) {
+    if last_statement_borrows(cx, expr) {
+        return;
     }
-}
 
-// is this expr a `()` unit?
-fn is_unit_expr(expr: &ast::Expr) -> bool {
-    if let ast::ExprKind::Tup(ref vals) = expr.kind {
-        vals.is_empty()
-    } else {
-        false
+    match expr.kind {
+        // simple return is always "bad"
+        ExprKind::Ret(ref inner) => {
+            // allow `#[cfg(a)] return a; #[cfg(b)] return b;`
+            if !expr.attrs.iter().any(attr_is_cfg) {
+                let borrows = inner.map_or(false, |inner| last_statement_borrows(cx, inner));
+                if !borrows {
+                    emit_return_lint(
+                        cx,
+                        span.expect("`else return` is not possible"),
+                        inner.as_ref().map(|i| i.span),
+                        replacement,
+                    );
+                }
+            }
+        },
+        // a whole block? check it!
+        ExprKind::Block(ref block, _) => {
+            check_block_return(cx, block);
+        },
+        // a match expr, check all arms
+        // an if/if let expr, check both exprs
+        // note, if without else is going to be a type checking error anyways
+        // (except for unit type functions) so we don't match it
+        ExprKind::Match(_, ref arms, source) => match source {
+            MatchSource::Normal => {
+                for arm in arms.iter() {
+                    check_final_expr(cx, &arm.body, Some(arm.body.span), RetReplacement::Block);
+                }
+            },
+            MatchSource::IfDesugar {
+                contains_else_clause: true,
+            }
+            | MatchSource::IfLetDesugar {
+                contains_else_clause: true,
+            } => {
+                if let ExprKind::Block(ref ifblock, _) = arms[0].body.kind {
+                    check_block_return(cx, ifblock);
+                }
+                check_final_expr(cx, arms[1].body, None, RetReplacement::Empty);
+            },
+            _ => (),
+        },
+        _ => (),
     }
 }
 
-fn lint_unneeded_unit_return(cx: &EarlyContext<'_>, ty: &ast::Ty, span: Span) {
-    let (ret_span, appl) = if let Ok(fn_source) = cx.sess().source_map().span_to_snippet(span.with_hi(ty.span.hi())) {
-        fn_source
-            .rfind("->")
-            .map_or((ty.span, Applicability::MaybeIncorrect), |rpos| {
-                (
-                    #[allow(clippy::cast_possible_truncation)]
-                    ty.span.with_lo(BytePos(span.lo().0 + rpos as u32)),
-                    Applicability::MachineApplicable,
-                )
+fn emit_return_lint(cx: &LateContext<'_>, ret_span: Span, inner_span: Option<Span>, replacement: RetReplacement) {
+    match inner_span {
+        Some(inner_span) => {
+            if in_external_macro(cx.tcx.sess, inner_span) || inner_span.from_expansion() {
+                return;
+            }
+
+            span_lint_and_then(cx, NEEDLESS_RETURN, ret_span, "unneeded `return` statement", |diag| {
+                if let Some(snippet) = snippet_opt(cx, inner_span) {
+                    diag.span_suggestion(ret_span, "remove `return`", snippet, Applicability::MachineApplicable);
+                }
             })
-    } else {
-        (ty.span, Applicability::MaybeIncorrect)
-    };
-    span_lint_and_sugg(
-        cx,
-        UNUSED_UNIT,
-        ret_span,
-        "unneeded unit return type",
-        "remove the `-> ()`",
-        String::new(),
-        appl,
-    );
+        },
+        None => match replacement {
+            RetReplacement::Empty => {
+                span_lint_and_sugg(
+                    cx,
+                    NEEDLESS_RETURN,
+                    ret_span,
+                    "unneeded `return` statement",
+                    "remove `return`",
+                    String::new(),
+                    Applicability::MachineApplicable,
+                );
+            },
+            RetReplacement::Block => {
+                span_lint_and_sugg(
+                    cx,
+                    NEEDLESS_RETURN,
+                    ret_span,
+                    "unneeded `return` statement",
+                    "replace `return` with an empty block",
+                    "{}".to_string(),
+                    Applicability::MachineApplicable,
+                );
+            },
+        },
+    }
+}
+
+fn last_statement_borrows<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
+    let mut visitor = BorrowVisitor { cx, borrows: false };
+    walk_expr(&mut visitor, expr);
+    visitor.borrows
+}
+
+struct BorrowVisitor<'a, 'tcx> {
+    cx: &'a LateContext<'tcx>,
+    borrows: bool,
+}
+
+impl<'tcx> Visitor<'tcx> for BorrowVisitor<'_, 'tcx> {
+    type Map = Map<'tcx>;
+
+    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
+        if self.borrows {
+            return;
+        }
+
+        if let Some(def_id) = fn_def_id(self.cx, expr) {
+            self.borrows = self
+                .cx
+                .tcx
+                .fn_sig(def_id)
+                .output()
+                .skip_binder()
+                .walk()
+                .any(|arg| matches!(arg.unpack(), GenericArgKind::Lifetime(_)));
+        }
+
+        walk_expr(self, expr);
+    }
+
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::None
+    }
 }
diff --git a/clippy_lints/src/unused_unit.rs b/clippy_lints/src/unused_unit.rs
new file mode 100644
index 00000000000..e322e402535
--- /dev/null
+++ b/clippy_lints/src/unused_unit.rs
@@ -0,0 +1,145 @@
+use if_chain::if_chain;
+use rustc_ast::ast;
+use rustc_ast::visit::FnKind;
+use rustc_errors::Applicability;
+use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::source_map::Span;
+use rustc_span::BytePos;
+
+use crate::utils::span_lint_and_sugg;
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for unit (`()`) expressions that can be removed.
+    ///
+    /// **Why is this bad?** Such expressions add no value, but can make the code
+    /// less readable. Depending on formatting they can make a `break` or `return`
+    /// statement look like a function call.
+    ///
+    /// **Known problems:** The lint currently misses unit return types in types,
+    /// e.g., the `F` in `fn generic_unit<F: Fn() -> ()>(f: F) { .. }`.
+    ///
+    /// **Example:**
+    /// ```rust
+    /// fn return_unit() -> () {
+    ///     ()
+    /// }
+    /// ```
+    pub UNUSED_UNIT,
+    style,
+    "needless unit expression"
+}
+
+declare_lint_pass!(UnusedUnit => [UNUSED_UNIT]);
+
+impl EarlyLintPass for UnusedUnit {
+    fn check_fn(&mut self, cx: &EarlyContext<'_>, kind: FnKind<'_>, span: Span, _: ast::NodeId) {
+        if_chain! {
+            if let ast::FnRetTy::Ty(ref ty) = kind.decl().output;
+            if let ast::TyKind::Tup(ref vals) = ty.kind;
+            if vals.is_empty() && !ty.span.from_expansion() && get_def(span) == get_def(ty.span);
+            then {
+                lint_unneeded_unit_return(cx, ty, span);
+            }
+        }
+    }
+
+    fn check_block(&mut self, cx: &EarlyContext<'_>, block: &ast::Block) {
+        if_chain! {
+            if let Some(ref stmt) = block.stmts.last();
+            if let ast::StmtKind::Expr(ref expr) = stmt.kind;
+            if is_unit_expr(expr) && !stmt.span.from_expansion();
+            then {
+                let sp = expr.span;
+                span_lint_and_sugg(
+                    cx,
+                    UNUSED_UNIT,
+                    sp,
+                    "unneeded unit expression",
+                    "remove the final `()`",
+                    String::new(),
+                    Applicability::MachineApplicable,
+                );
+            }
+        }
+    }
+
+    fn check_expr(&mut self, cx: &EarlyContext<'_>, e: &ast::Expr) {
+        match e.kind {
+            ast::ExprKind::Ret(Some(ref expr)) | ast::ExprKind::Break(_, Some(ref expr)) => {
+                if is_unit_expr(expr) && !expr.span.from_expansion() {
+                    span_lint_and_sugg(
+                        cx,
+                        UNUSED_UNIT,
+                        expr.span,
+                        "unneeded `()`",
+                        "remove the `()`",
+                        String::new(),
+                        Applicability::MachineApplicable,
+                    );
+                }
+            },
+            _ => (),
+        }
+    }
+
+    fn check_poly_trait_ref(&mut self, cx: &EarlyContext<'_>, poly: &ast::PolyTraitRef, _: &ast::TraitBoundModifier) {
+        let segments = &poly.trait_ref.path.segments;
+
+        if_chain! {
+            if segments.len() == 1;
+            if ["Fn", "FnMut", "FnOnce"].contains(&&*segments[0].ident.name.as_str());
+            if let Some(args) = &segments[0].args;
+            if let ast::GenericArgs::Parenthesized(generic_args) = &**args;
+            if let ast::FnRetTy::Ty(ty) = &generic_args.output;
+            if ty.kind.is_unit();
+            then {
+                lint_unneeded_unit_return(cx, ty, generic_args.span);
+            }
+        }
+    }
+}
+
+// get the def site
+#[must_use]
+fn get_def(span: Span) -> Option<Span> {
+    if span.from_expansion() {
+        Some(span.ctxt().outer_expn_data().def_site)
+    } else {
+        None
+    }
+}
+
+// is this expr a `()` unit?
+fn is_unit_expr(expr: &ast::Expr) -> bool {
+    if let ast::ExprKind::Tup(ref vals) = expr.kind {
+        vals.is_empty()
+    } else {
+        false
+    }
+}
+
+fn lint_unneeded_unit_return(cx: &EarlyContext<'_>, ty: &ast::Ty, span: Span) {
+    let (ret_span, appl) = if let Ok(fn_source) = cx.sess().source_map().span_to_snippet(span.with_hi(ty.span.hi())) {
+        fn_source
+            .rfind("->")
+            .map_or((ty.span, Applicability::MaybeIncorrect), |rpos| {
+                (
+                    #[allow(clippy::cast_possible_truncation)]
+                    ty.span.with_lo(BytePos(span.lo().0 + rpos as u32)),
+                    Applicability::MachineApplicable,
+                )
+            })
+    } else {
+        (ty.span, Applicability::MaybeIncorrect)
+    };
+    span_lint_and_sugg(
+        cx,
+        UNUSED_UNIT,
+        ret_span,
+        "unneeded unit return type",
+        "remove the `-> ()`",
+        String::new(),
+        appl,
+    );
+}
diff --git a/tests/ui/needless_return.fixed b/tests/ui/needless_return.fixed
index 6b5cf2626df..b795516f999 100644
--- a/tests/ui/needless_return.fixed
+++ b/tests/ui/needless_return.fixed
@@ -76,6 +76,17 @@ mod no_lint_if_stmt_borrows {
             let stdin = ::std::io::stdin();
             return stdin.lock().lines().next().unwrap().unwrap();
         }
+
+        fn read_line2(value: bool) -> String {
+            if value {
+                use std::io::BufRead;
+                let stdin = ::std::io::stdin();
+                let _a = stdin.lock().lines().next().unwrap().unwrap();
+                return String::from("test");
+            } else {
+                return String::new();
+            }
+        }
     }
 }
 
diff --git a/tests/ui/needless_return.rs b/tests/ui/needless_return.rs
index 1a693c9aa53..3547991935d 100644
--- a/tests/ui/needless_return.rs
+++ b/tests/ui/needless_return.rs
@@ -76,6 +76,17 @@ mod no_lint_if_stmt_borrows {
             let stdin = ::std::io::stdin();
             return stdin.lock().lines().next().unwrap().unwrap();
         }
+
+        fn read_line2(value: bool) -> String {
+            if value {
+                use std::io::BufRead;
+                let stdin = ::std::io::stdin();
+                let _a = stdin.lock().lines().next().unwrap().unwrap();
+                return String::from("test");
+            } else {
+                return String::new();
+            }
+        }
     }
 }
 
-- 
cgit 1.4.1-3-g733a5


From 96efaee55240a3d3428ea5fe30c884a3227dad6e Mon Sep 17 00:00:00 2001
From: jrqc <jrqc01@hotmail.com>
Date: Thu, 13 Aug 2020 19:30:49 +0300
Subject: cargo dev update_lints

---
 clippy_lints/src/lib.rs | 18 +++++++++---------
 src/lintlist/mod.rs     |  6 +++---
 2 files changed, 12 insertions(+), 12 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 63de0f8a0c2..c0b645e9311 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -586,7 +586,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &large_stack_arrays::LARGE_STACK_ARRAYS,
         &len_zero::LEN_WITHOUT_IS_EMPTY,
         &len_zero::LEN_ZERO,
-        &returns::LET_AND_RETURN,
         &let_if_seq::USELESS_LET_IF_SEQ,
         &let_underscore::LET_UNDERSCORE_LOCK,
         &let_underscore::LET_UNDERSCORE_MUST_USE,
@@ -726,7 +725,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &needless_borrowed_ref::NEEDLESS_BORROWED_REFERENCE,
         &needless_continue::NEEDLESS_CONTINUE,
         &needless_pass_by_value::NEEDLESS_PASS_BY_VALUE,
-        &returns::NEEDLESS_RETURN,
         &needless_update::NEEDLESS_UPDATE,
         &neg_cmp_op_on_partial_ord::NEG_CMP_OP_ON_PARTIAL_ORD,
         &neg_multiply::NEG_MULTIPLY,
@@ -770,7 +768,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &regex::INVALID_REGEX,
         &regex::TRIVIAL_REGEX,
         &repeat_once::REPEAT_ONCE,
-        &unused_unit::UNUSED_UNIT,
+        &returns::LET_AND_RETURN,
+        &returns::NEEDLESS_RETURN,
         &serde_api::SERDE_API_MISUSE,
         &shadow::SHADOW_REUSE,
         &shadow::SHADOW_SAME,
@@ -840,6 +839,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &unsafe_removed_from_name::UNSAFE_REMOVED_FROM_NAME,
         &unused_io_amount::UNUSED_IO_AMOUNT,
         &unused_self::UNUSED_SELF,
+        &unused_unit::UNUSED_UNIT,
         &unwrap::PANICKING_UNWRAP,
         &unwrap::UNNECESSARY_UNWRAP,
         &use_self::USE_SELF,
@@ -1284,7 +1284,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&large_enum_variant::LARGE_ENUM_VARIANT),
         LintId::of(&len_zero::LEN_WITHOUT_IS_EMPTY),
         LintId::of(&len_zero::LEN_ZERO),
-        LintId::of(&returns::LET_AND_RETURN),
         LintId::of(&let_underscore::LET_UNDERSCORE_LOCK),
         LintId::of(&lifetimes::EXTRA_UNUSED_LIFETIMES),
         LintId::of(&lifetimes::NEEDLESS_LIFETIMES),
@@ -1381,7 +1380,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&needless_bool::BOOL_COMPARISON),
         LintId::of(&needless_bool::NEEDLESS_BOOL),
         LintId::of(&needless_borrowed_ref::NEEDLESS_BORROWED_REFERENCE),
-        LintId::of(&returns::NEEDLESS_RETURN),
         LintId::of(&needless_update::NEEDLESS_UPDATE),
         LintId::of(&neg_cmp_op_on_partial_ord::NEG_CMP_OP_ON_PARTIAL_ORD),
         LintId::of(&neg_multiply::NEG_MULTIPLY),
@@ -1414,7 +1412,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&regex::INVALID_REGEX),
         LintId::of(&regex::TRIVIAL_REGEX),
         LintId::of(&repeat_once::REPEAT_ONCE),
-        LintId::of(&unused_unit::UNUSED_UNIT),
+        LintId::of(&returns::LET_AND_RETURN),
+        LintId::of(&returns::NEEDLESS_RETURN),
         LintId::of(&serde_api::SERDE_API_MISUSE),
         LintId::of(&single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS),
         LintId::of(&slow_vector_initialization::SLOW_VECTOR_INITIALIZATION),
@@ -1460,6 +1459,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&unnecessary_sort_by::UNNECESSARY_SORT_BY),
         LintId::of(&unsafe_removed_from_name::UNSAFE_REMOVED_FROM_NAME),
         LintId::of(&unused_io_amount::UNUSED_IO_AMOUNT),
+        LintId::of(&unused_unit::UNUSED_UNIT),
         LintId::of(&unwrap::PANICKING_UNWRAP),
         LintId::of(&unwrap::UNNECESSARY_UNWRAP),
         LintId::of(&useless_conversion::USELESS_CONVERSION),
@@ -1500,7 +1500,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&inherent_to_string::INHERENT_TO_STRING),
         LintId::of(&len_zero::LEN_WITHOUT_IS_EMPTY),
         LintId::of(&len_zero::LEN_ZERO),
-        LintId::of(&returns::LET_AND_RETURN),
         LintId::of(&literal_representation::INCONSISTENT_DIGIT_GROUPING),
         LintId::of(&loops::EMPTY_LOOP),
         LintId::of(&loops::FOR_KV_MAP),
@@ -1543,7 +1542,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&misc_early::MIXED_CASE_HEX_LITERALS),
         LintId::of(&misc_early::REDUNDANT_PATTERN),
         LintId::of(&mut_reference::UNNECESSARY_MUT_PASSED),
-        LintId::of(&returns::NEEDLESS_RETURN),
         LintId::of(&neg_multiply::NEG_MULTIPLY),
         LintId::of(&new_without_default::NEW_WITHOUT_DEFAULT),
         LintId::of(&non_expressive_names::JUST_UNDERSCORES_AND_DIGITS),
@@ -1555,7 +1553,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&redundant_field_names::REDUNDANT_FIELD_NAMES),
         LintId::of(&redundant_static_lifetimes::REDUNDANT_STATIC_LIFETIMES),
         LintId::of(&regex::TRIVIAL_REGEX),
-        LintId::of(&unused_unit::UNUSED_UNIT),
+        LintId::of(&returns::LET_AND_RETURN),
+        LintId::of(&returns::NEEDLESS_RETURN),
         LintId::of(&single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS),
         LintId::of(&strings::STRING_LIT_AS_BYTES),
         LintId::of(&tabs_in_doc_comments::TABS_IN_DOC_COMMENTS),
@@ -1564,6 +1563,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&types::FN_TO_NUMERIC_CAST),
         LintId::of(&types::FN_TO_NUMERIC_CAST_WITH_TRUNCATION),
         LintId::of(&unsafe_removed_from_name::UNSAFE_REMOVED_FROM_NAME),
+        LintId::of(&unused_unit::UNUSED_UNIT),
         LintId::of(&write::PRINTLN_EMPTY_STRING),
         LintId::of(&write::PRINT_LITERAL),
         LintId::of(&write::PRINT_WITH_NEWLINE),
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index 7464f1cc6de..dff6198d00d 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -1037,7 +1037,7 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
         group: "style",
         desc: "creating a let-binding and then immediately returning it like `let x = expr; x` at the end of a block",
         deprecation: None,
-        module: "let_and_return",
+        module: "returns",
     },
     Lint {
         name: "let_underscore_lock",
@@ -1534,7 +1534,7 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
         group: "style",
         desc: "using a return statement like `return expr;` where an expression would suffice",
         deprecation: None,
-        module: "needless_return",
+        module: "returns",
     },
     Lint {
         name: "needless_update",
@@ -2479,7 +2479,7 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
         group: "style",
         desc: "needless unit expression",
         deprecation: None,
-        module: "returns",
+        module: "unused_unit",
     },
     Lint {
         name: "unwrap_used",
-- 
cgit 1.4.1-3-g733a5


From baa4cb1cddc3a8ce1f47c4006e236edf082ee858 Mon Sep 17 00:00:00 2001
From: jrqc <jrqc01@hotmail.com>
Date: Fri, 14 Aug 2020 09:25:26 +0300
Subject: early return removed

---
 clippy_lints/src/returns.rs     |  4 ----
 clippy_lints/src/unused_unit.rs |  3 +--
 tests/ui/needless_return.fixed  | 30 +++++++++++++-----------------
 tests/ui/needless_return.rs     | 30 +++++++++++++-----------------
 tests/ui/needless_return.stderr | 14 +++++++++++++-
 5 files changed, 40 insertions(+), 41 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
index 4d91f9be999..3c5541e64b4 100644
--- a/clippy_lints/src/returns.rs
+++ b/clippy_lints/src/returns.rs
@@ -160,10 +160,6 @@ fn check_final_expr<'tcx>(
     span: Option<Span>,
     replacement: RetReplacement,
 ) {
-    if last_statement_borrows(cx, expr) {
-        return;
-    }
-
     match expr.kind {
         // simple return is always "bad"
         ExprKind::Ret(ref inner) => {
diff --git a/clippy_lints/src/unused_unit.rs b/clippy_lints/src/unused_unit.rs
index e322e402535..7548c6afa97 100644
--- a/clippy_lints/src/unused_unit.rs
+++ b/clippy_lints/src/unused_unit.rs
@@ -16,8 +16,7 @@ declare_clippy_lint! {
     /// less readable. Depending on formatting they can make a `break` or `return`
     /// statement look like a function call.
     ///
-    /// **Known problems:** The lint currently misses unit return types in types,
-    /// e.g., the `F` in `fn generic_unit<F: Fn() -> ()>(f: F) { .. }`.
+    /// **Known problems:** None.
     ///
     /// **Example:**
     /// ```rust
diff --git a/tests/ui/needless_return.fixed b/tests/ui/needless_return.fixed
index b795516f999..d849e093da7 100644
--- a/tests/ui/needless_return.fixed
+++ b/tests/ui/needless_return.fixed
@@ -69,24 +69,20 @@ fn test_void_match(x: u32) {
     }
 }
 
-mod no_lint_if_stmt_borrows {
-    mod issue_5858 {
-        fn read_line() -> String {
-            use std::io::BufRead;
-            let stdin = ::std::io::stdin();
-            return stdin.lock().lines().next().unwrap().unwrap();
-        }
+fn read_line() -> String {
+    use std::io::BufRead;
+    let stdin = ::std::io::stdin();
+    return stdin.lock().lines().next().unwrap().unwrap();
+}
 
-        fn read_line2(value: bool) -> String {
-            if value {
-                use std::io::BufRead;
-                let stdin = ::std::io::stdin();
-                let _a = stdin.lock().lines().next().unwrap().unwrap();
-                return String::from("test");
-            } else {
-                return String::new();
-            }
-        }
+fn borrows_but_not_last(value: bool) -> String {
+    if value {
+        use std::io::BufRead;
+        let stdin = ::std::io::stdin();
+        let _a = stdin.lock().lines().next().unwrap().unwrap();
+        String::from("test")
+    } else {
+        String::new()
     }
 }
 
diff --git a/tests/ui/needless_return.rs b/tests/ui/needless_return.rs
index 3547991935d..29f2bd1852a 100644
--- a/tests/ui/needless_return.rs
+++ b/tests/ui/needless_return.rs
@@ -69,24 +69,20 @@ fn test_void_match(x: u32) {
     }
 }
 
-mod no_lint_if_stmt_borrows {
-    mod issue_5858 {
-        fn read_line() -> String {
-            use std::io::BufRead;
-            let stdin = ::std::io::stdin();
-            return stdin.lock().lines().next().unwrap().unwrap();
-        }
+fn read_line() -> String {
+    use std::io::BufRead;
+    let stdin = ::std::io::stdin();
+    return stdin.lock().lines().next().unwrap().unwrap();
+}
 
-        fn read_line2(value: bool) -> String {
-            if value {
-                use std::io::BufRead;
-                let stdin = ::std::io::stdin();
-                let _a = stdin.lock().lines().next().unwrap().unwrap();
-                return String::from("test");
-            } else {
-                return String::new();
-            }
-        }
+fn borrows_but_not_last(value: bool) -> String {
+    if value {
+        use std::io::BufRead;
+        let stdin = ::std::io::stdin();
+        let _a = stdin.lock().lines().next().unwrap().unwrap();
+        return String::from("test");
+    } else {
+        return String::new();
     }
 }
 
diff --git a/tests/ui/needless_return.stderr b/tests/ui/needless_return.stderr
index c34eecbcbb6..f73c833a801 100644
--- a/tests/ui/needless_return.stderr
+++ b/tests/ui/needless_return.stderr
@@ -72,5 +72,17 @@ error: unneeded `return` statement
 LL |         _ => return,
    |              ^^^^^^ help: replace `return` with an empty block: `{}`
 
-error: aborting due to 12 previous errors
+error: unneeded `return` statement
+  --> $DIR/needless_return.rs:83:9
+   |
+LL |         return String::from("test");
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove `return`: `String::from("test")`
+
+error: unneeded `return` statement
+  --> $DIR/needless_return.rs:85:9
+   |
+LL |         return String::new();
+   |         ^^^^^^^^^^^^^^^^^^^^^ help: remove `return`: `String::new()`
+
+error: aborting due to 14 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 1a140dcc1c933ae84365bd1153372a7430f6f647 Mon Sep 17 00:00:00 2001
From: Eduardo Broto <ebroto@tutanota.com>
Date: Sun, 16 Aug 2020 00:25:54 +0200
Subject: Improve needless_doctest_main by using the parser

---
 clippy_lints/src/doc.rs           | 75 +++++++++++++++++++++++++++++++++++----
 tests/ui/needless_doc_main.rs     | 68 ++++++++++++++++++++++++++++++++---
 tests/ui/needless_doc_main.stderr | 12 +++++--
 3 files changed, 142 insertions(+), 13 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/doc.rs b/clippy_lints/src/doc.rs
index 6ce36fd2360..9555459e240 100644
--- a/clippy_lints/src/doc.rs
+++ b/clippy_lints/src/doc.rs
@@ -1,16 +1,22 @@
 use crate::utils::{implements_trait, is_entrypoint_fn, is_type_diagnostic_item, return_ty, span_lint};
 use if_chain::if_chain;
 use itertools::Itertools;
-use rustc_ast::ast::{AttrKind, Attribute};
+use rustc_ast::ast::{Async, AttrKind, Attribute, FnRetTy, ItemKind};
 use rustc_ast::token::CommentKind;
 use rustc_data_structures::fx::FxHashSet;
+use rustc_data_structures::sync::Lrc;
+use rustc_errors::emitter::EmitterWriter;
+use rustc_errors::Handler;
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty;
+use rustc_parse::maybe_new_parser_from_source_str;
+use rustc_session::parse::ParseSess;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::source_map::{BytePos, MultiSpan, Span};
-use rustc_span::Pos;
+use rustc_span::source_map::{BytePos, FilePathMapping, MultiSpan, SourceMap, Span};
+use rustc_span::{FileName, Pos};
+use std::io;
 use std::ops::Range;
 use url::Url;
 
@@ -431,10 +437,67 @@ fn check_doc<'a, Events: Iterator<Item = (pulldown_cmark::Event<'a>, Range<usize
     headers
 }
 
-static LEAVE_MAIN_PATTERNS: &[&str] = &["static", "fn main() {}", "extern crate", "async fn main() {"];
-
 fn check_code(cx: &LateContext<'_>, text: &str, span: Span) {
-    if text.contains("fn main() {") && !LEAVE_MAIN_PATTERNS.iter().any(|p| text.contains(p)) {
+    fn has_needless_main(code: &str) -> bool {
+        let filename = FileName::anon_source_code(code);
+
+        let sm = Lrc::new(SourceMap::new(FilePathMapping::empty()));
+        let emitter = EmitterWriter::new(box io::sink(), None, false, false, false, None, false);
+        let handler = Handler::with_emitter(false, None, box emitter);
+        let sess = ParseSess::with_span_handler(handler, sm);
+
+        let mut parser = match maybe_new_parser_from_source_str(&sess, filename, code.into()) {
+            Ok(p) => p,
+            Err(errs) => {
+                for mut err in errs {
+                    err.cancel();
+                }
+                return false;
+            },
+        };
+
+        let mut relevant_main_found = false;
+        loop {
+            match parser.parse_item() {
+                Ok(Some(item)) => match &item.kind {
+                    // Tests with one of these items are ignored
+                    ItemKind::Static(..)
+                    | ItemKind::Const(..)
+                    | ItemKind::ExternCrate(..)
+                    | ItemKind::ForeignMod(..) => return false,
+                    // We found a main function ...
+                    ItemKind::Fn(_, sig, _, Some(block)) if item.ident.name == sym!(main) => {
+                        let is_async = matches!(sig.header.asyncness, Async::Yes{..});
+                        let returns_nothing = match &sig.decl.output {
+                            FnRetTy::Default(..) => true,
+                            FnRetTy::Ty(ty) if ty.kind.is_unit() => true,
+                            _ => false,
+                        };
+
+                        if returns_nothing && !is_async && !block.stmts.is_empty() {
+                            // This main function should be linted, but only if there are no other functions
+                            relevant_main_found = true;
+                        } else {
+                            // This main function should not be linted, we're done
+                            return false;
+                        }
+                    },
+                    // Another function was found; this case is ignored too
+                    ItemKind::Fn(..) => return false,
+                    _ => {},
+                },
+                Ok(None) => break,
+                Err(mut e) => {
+                    e.cancel();
+                    return false;
+                },
+            }
+        }
+
+        relevant_main_found
+    }
+
+    if has_needless_main(text) {
         span_lint(cx, NEEDLESS_DOCTEST_MAIN, span, "needless `fn main` in doctest");
     }
 }
diff --git a/tests/ui/needless_doc_main.rs b/tests/ui/needless_doc_main.rs
index 682d7b3c4ce..883683e08a2 100644
--- a/tests/ui/needless_doc_main.rs
+++ b/tests/ui/needless_doc_main.rs
@@ -9,8 +9,14 @@
 /// }
 /// ```
 ///
-/// This should, too.
+/// With an explicit return type it should lint too
+/// ```
+/// fn main() -> () {
+///     unimplemented!();
+/// }
+/// ```
 ///
+/// This should, too.
 /// ```rust
 /// fn main() {
 ///     unimplemented!();
@@ -18,7 +24,6 @@
 /// ```
 ///
 /// This one too.
-///
 /// ```no_run
 /// fn main() {
 ///     unimplemented!();
@@ -33,6 +38,20 @@ fn bad_doctests() {}
 /// fn main(){}
 /// ```
 ///
+/// This shouldn't lint either, because main is async:
+/// ```
+/// async fn main() {
+///     assert_eq!(42, ANSWER);
+/// }
+/// ```
+///
+/// Same here, because the return type is not the unit type:
+/// ```
+/// fn main() -> Result<()> {
+///     Ok(())
+/// }
+/// ```
+///
 /// This shouldn't lint either, because there's a `static`:
 /// ```
 /// static ANSWER: i32 = 42;
@@ -42,6 +61,15 @@ fn bad_doctests() {}
 /// }
 /// ```
 ///
+/// This shouldn't lint either, because there's a `const`:
+/// ```
+/// fn main() {
+///     assert_eq!(42, ANSWER);
+/// }
+///
+/// const ANSWER: i32 = 42;
+/// ```
+///
 /// Neither should this lint because of `extern crate`:
 /// ```
 /// #![feature(test)]
@@ -51,8 +79,41 @@ fn bad_doctests() {}
 /// }
 /// ```
 ///
-/// We should not lint ignored examples:
+/// Neither should this lint because it has an extern block:
+/// ```
+/// extern {}
+/// fn main() {
+///     unimplemented!();
+/// }
+/// ```
+///
+/// This should not lint because there is another function defined:
+/// ```
+/// fn fun() {}
+///
+/// fn main() {
+///     unimplemented!();
+/// }
+/// ```
 ///
+/// We should not lint inside raw strings ...
+/// ```
+/// let string = r#"
+/// fn main() {
+///     unimplemented!();
+/// }
+/// "#;
+/// ```
+///
+/// ... or comments
+/// ```
+/// // fn main() {
+/// //     let _inception = 42;
+/// // }
+/// let _inception = 42;
+/// ```
+///
+/// We should not lint ignored examples:
 /// ```rust,ignore
 /// fn main() {
 ///     unimplemented!();
@@ -60,7 +121,6 @@ fn bad_doctests() {}
 /// ```
 ///
 /// Or even non-rust examples:
-///
 /// ```text
 /// fn main() {
 ///     is what starts the program
diff --git a/tests/ui/needless_doc_main.stderr b/tests/ui/needless_doc_main.stderr
index 65d40ee6832..05c7f9d33a7 100644
--- a/tests/ui/needless_doc_main.stderr
+++ b/tests/ui/needless_doc_main.stderr
@@ -7,16 +7,22 @@ LL | /// fn main() {
    = note: `-D clippy::needless-doctest-main` implied by `-D warnings`
 
 error: needless `fn main` in doctest
-  --> $DIR/needless_doc_main.rs:15:4
+  --> $DIR/needless_doc_main.rs:14:4
+   |
+LL | /// fn main() -> () {
+   |    ^^^^^^^^^^^^^^^^^^
+
+error: needless `fn main` in doctest
+  --> $DIR/needless_doc_main.rs:21:4
    |
 LL | /// fn main() {
    |    ^^^^^^^^^^^^
 
 error: needless `fn main` in doctest
-  --> $DIR/needless_doc_main.rs:23:4
+  --> $DIR/needless_doc_main.rs:28:4
    |
 LL | /// fn main() {
    |    ^^^^^^^^^^^^
 
-error: aborting due to 3 previous errors
+error: aborting due to 4 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From a3ea65c2d9bc52f308745ae488435388fce753a2 Mon Sep 17 00:00:00 2001
From: Dániel Buga <bugadani@gmail.com>
Date: Mon, 15 Jun 2020 11:21:56 +0200
Subject: Implement new lint

---
 CHANGELOG.md                          |   1 +
 clippy_lints/src/lib.rs               |   3 +
 clippy_lints/src/methods/mod.rs       | 130 +++++++++++++++++++++++++++++-
 src/lintlist/mod.rs                   |   7 ++
 tests/ui/unnecessary_lazy_eval.fixed  | 105 +++++++++++++++++++++++++
 tests/ui/unnecessary_lazy_eval.rs     | 105 +++++++++++++++++++++++++
 tests/ui/unnecessary_lazy_eval.stderr | 144 ++++++++++++++++++++++++++++++++++
 7 files changed, 494 insertions(+), 1 deletion(-)
 create mode 100644 tests/ui/unnecessary_lazy_eval.fixed
 create mode 100644 tests/ui/unnecessary_lazy_eval.rs
 create mode 100644 tests/ui/unnecessary_lazy_eval.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 50fe7612909..c21190e9b9c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1646,6 +1646,7 @@ Released 2018-09-13
 [`option_map_or_none`]: https://rust-lang.github.io/rust-clippy/master/index.html#option_map_or_none
 [`option_map_unit_fn`]: https://rust-lang.github.io/rust-clippy/master/index.html#option_map_unit_fn
 [`option_option`]: https://rust-lang.github.io/rust-clippy/master/index.html#option_option
+[`option_unwrap_or_else`]: https://rust-lang.github.io/rust-clippy/master/index.html#option_unwrap_or_else
 [`or_fun_call`]: https://rust-lang.github.io/rust-clippy/master/index.html#or_fun_call
 [`out_of_bounds_indexing`]: https://rust-lang.github.io/rust-clippy/master/index.html#out_of_bounds_indexing
 [`overflow_check_conditional`]: https://rust-lang.github.io/rust-clippy/master/index.html#overflow_check_conditional
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 986e9d9bee4..cb29f71387b 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -672,6 +672,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &methods::OK_EXPECT,
         &methods::OPTION_AS_REF_DEREF,
         &methods::OPTION_MAP_OR_NONE,
+        &methods::UNNECESSARY_LAZY_EVALUATION,
         &methods::OR_FUN_CALL,
         &methods::RESULT_MAP_OR_INTO_OPTION,
         &methods::SEARCH_IS_SOME,
@@ -1360,6 +1361,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&methods::UNINIT_ASSUMED_INIT),
         LintId::of(&methods::UNNECESSARY_FILTER_MAP),
         LintId::of(&methods::UNNECESSARY_FOLD),
+        LintId::of(&methods::UNNECESSARY_LAZY_EVALUATION),
         LintId::of(&methods::USELESS_ASREF),
         LintId::of(&methods::WRONG_SELF_CONVENTION),
         LintId::of(&methods::ZST_OFFSET),
@@ -1610,6 +1612,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&methods::FILTER_NEXT),
         LintId::of(&methods::FLAT_MAP_IDENTITY),
         LintId::of(&methods::OPTION_AS_REF_DEREF),
+        LintId::of(&methods::UNNECESSARY_LAZY_EVALUATION),
         LintId::of(&methods::SEARCH_IS_SOME),
         LintId::of(&methods::SKIP_WHILE_NEXT),
         LintId::of(&methods::SUSPICIOUS_MAP),
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 2330978e67f..61b7f2647ee 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1329,6 +1329,32 @@ declare_clippy_lint! {
     "`push_str()` used with a single-character string literal as parameter"
 }
 
+declare_clippy_lint! {
+    /// **What it does:** Looks for unnecessary lazily evaluated closures on `Option` and `Result`.
+    ///
+    /// **Why is this bad?** Using eager evaluation is shorter and simpler in some cases.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// // example code where clippy issues a warning
+    /// let opt: Option<u32> = None;
+    ///
+    /// opt.unwrap_or_else(|| 42);
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// let opt: Option<u32> = None;
+    ///
+    /// opt.unwrap_or(42);
+    /// ```
+    pub UNNECESSARY_LAZY_EVALUATION,
+    style,
+    "using unnecessary lazy evaluation, which can be replaced with simpler eager evaluation"
+}
+
 declare_lint_pass!(Methods => [
     UNWRAP_USED,
     EXPECT_USED,
@@ -1378,6 +1404,7 @@ declare_lint_pass!(Methods => [
     ZST_OFFSET,
     FILETYPE_IS_FILE,
     OPTION_AS_REF_DEREF,
+    UNNECESSARY_LAZY_EVALUATION,
 ]);
 
 impl<'tcx> LateLintPass<'tcx> for Methods {
@@ -1398,13 +1425,18 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             ["expect", "ok"] => lint_ok_expect(cx, expr, arg_lists[1]),
             ["expect", ..] => lint_expect(cx, expr, arg_lists[0]),
             ["unwrap_or", "map"] => option_map_unwrap_or::lint(cx, expr, arg_lists[1], arg_lists[0], method_spans[1]),
-            ["unwrap_or_else", "map"] => lint_map_unwrap_or_else(cx, expr, arg_lists[1], arg_lists[0]),
+            ["unwrap_or_else", "map"] => {
+                lint_lazy_eval(cx, expr, arg_lists[0], true, "unwrap_or");
+                lint_map_unwrap_or_else(cx, expr, arg_lists[1], arg_lists[0]);
+            },
             ["map_or", ..] => lint_map_or_none(cx, expr, arg_lists[0]),
             ["and_then", ..] => {
+                lint_lazy_eval(cx, expr, arg_lists[0], false, "and");
                 bind_instead_of_map::OptionAndThenSome::lint(cx, expr, arg_lists[0]);
                 bind_instead_of_map::ResultAndThenOk::lint(cx, expr, arg_lists[0]);
             },
             ["or_else", ..] => {
+                lint_lazy_eval(cx, expr, arg_lists[0], false, "or");
                 bind_instead_of_map::ResultOrElseErrInfo::lint(cx, expr, arg_lists[0]);
             },
             ["next", "filter"] => lint_filter_next(cx, expr, arg_lists[1]),
@@ -1448,6 +1480,9 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             ["is_file", ..] => lint_filetype_is_file(cx, expr, arg_lists[0]),
             ["map", "as_ref"] => lint_option_as_ref_deref(cx, expr, arg_lists[1], arg_lists[0], false),
             ["map", "as_mut"] => lint_option_as_ref_deref(cx, expr, arg_lists[1], arg_lists[0], true),
+            ["unwrap_or_else", ..] => lint_lazy_eval(cx, expr, arg_lists[0], true, "unwrap_or"),
+            ["get_or_insert_with", ..] => lint_lazy_eval(cx, expr, arg_lists[0], true, "get_or_insert"),
+            ["ok_or_else", ..] => lint_lazy_eval(cx, expr, arg_lists[0], true, "ok_or"),
             _ => {},
         }
 
@@ -2663,6 +2698,99 @@ fn lint_map_flatten<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, map
     }
 }
 
+/// lint use of `<fn>_else(simple closure)` for `Option`s and `Result`s that can be
+/// replaced with `<fn>(return value of simple closure)`
+fn lint_lazy_eval<'a, 'tcx>(
+    cx: &LateContext<'a, 'tcx>,
+    expr: &'tcx hir::Expr<'_>,
+    args: &'tcx [hir::Expr<'_>],
+    allow_variant_calls: bool,
+    simplify_using: &str,
+) {
+    let is_option = is_type_diagnostic_item(cx, cx.tables.expr_ty(&args[0]), sym!(option_type));
+    let is_result = is_type_diagnostic_item(cx, cx.tables.expr_ty(&args[0]), sym!(result_type));
+
+    if !is_option && !is_result {
+        return;
+    }
+
+    // Return true if the expression is an accessor of any of the arguments
+    fn expr_uses_argument(expr: &hir::Expr<'_>, params: &[hir::Param<'_>]) -> bool {
+        params.iter().any(|arg| {
+            if_chain! {
+                if let hir::PatKind::Binding(_, _, ident, _) = arg.pat.kind;
+                if let hir::ExprKind::Path(hir::QPath::Resolved(_, ref path)) = expr.kind;
+                if let [p, ..] = path.segments;
+                then {
+                    ident.name == p.ident.name
+                } else {
+                    false
+                }
+            }
+        })
+    }
+
+    fn match_any_qpath(path: &hir::QPath<'_>, paths: &[&[&str]]) -> bool {
+        paths.iter().any(|candidate| match_qpath(path, candidate))
+    }
+
+    if let hir::ExprKind::Closure(_, _, eid, _, _) = args[1].kind {
+        let body = cx.tcx.hir().body(eid);
+        let ex = &body.value;
+        let params = &body.params;
+
+        let simplify = match ex.kind {
+            // Closures returning literals can be unconditionally simplified
+            hir::ExprKind::Lit(_) => true,
+
+            // Reading fields can be simplified if the object is not an argument of the closure
+            hir::ExprKind::Field(ref object, _) => !expr_uses_argument(object, params),
+
+            // Paths can be simplified if the root is not the argument, this also covers None
+            hir::ExprKind::Path(_) => !expr_uses_argument(ex, params),
+
+            // Calls to Some, Ok, Err can be considered literals if they don't derive an argument
+            hir::ExprKind::Call(ref func, ref args) => if_chain! {
+                if allow_variant_calls; // Disable lint when rules conflict with bind_instead_of_map
+                if let hir::ExprKind::Path(ref path) = func.kind;
+                if match_any_qpath(path, &[&["Some"], &["Ok"], &["Err"]]);
+                then {
+                    !args.iter().any(|arg| expr_uses_argument(arg, params))
+                } else {
+                    false
+                }
+            },
+
+            // For anything more complex than the above, a closure is probably the right solution,
+            // or the case is handled by an other lint
+            _ => false,
+        };
+
+        if simplify {
+            let msg = if is_option {
+                "unnecessary closure used to substitute value for `Option::None`"
+            } else {
+                "unnecessary closure used to substitute value for `Result::Err`"
+            };
+
+            span_lint_and_sugg(
+                cx,
+                UNNECESSARY_LAZY_EVALUATION,
+                expr.span,
+                msg,
+                &format!("Use `{}` instead", simplify_using),
+                format!(
+                    "{0}.{1}({2})",
+                    snippet(cx, args[0].span, ".."),
+                    simplify_using,
+                    snippet(cx, ex.span, ".."),
+                ),
+                Applicability::MachineApplicable,
+            );
+        }
+    }
+}
+
 /// lint use of `map().unwrap_or_else()` for `Option`s and `Result`s
 fn lint_map_unwrap_or_else<'tcx>(
     cx: &LateContext<'tcx>,
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index 233f95deedd..1e76163f946 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -2383,6 +2383,13 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
         deprecation: None,
         module: "methods",
     },
+    Lint {
+        name: "unnecessary_lazy_eval",
+        group: "style",
+        desc: "using unnecessary lazy evaluation, which can be replaced with simpler eager evaluation",
+        deprecation: None,
+        module: "methods",
+    },
     Lint {
         name: "unnecessary_mut_passed",
         group: "style",
diff --git a/tests/ui/unnecessary_lazy_eval.fixed b/tests/ui/unnecessary_lazy_eval.fixed
new file mode 100644
index 00000000000..fcfa6dfe12d
--- /dev/null
+++ b/tests/ui/unnecessary_lazy_eval.fixed
@@ -0,0 +1,105 @@
+// run-rustfix
+#![warn(clippy::unnecessary_lazy_evaluation)]
+#![allow(clippy::redundant_closure)]
+#![allow(clippy::bind_instead_of_map)]
+
+struct Deep(Option<u32>);
+
+#[derive(Copy, Clone)]
+struct SomeStruct {
+    some_field: u32,
+}
+
+impl SomeStruct {
+    fn return_some_field(&self) -> u32 {
+        self.some_field
+    }
+}
+
+fn some_call<T: Default>() -> T {
+    T::default()
+}
+
+fn main() {
+    let astronomers_pi = 10;
+    let ext_str = SomeStruct { some_field: 10 };
+
+    // Should lint - Option
+    let mut opt = Some(42);
+    let ext_opt = Some(42);
+    let _ = opt.unwrap_or(2);
+    let _ = opt.unwrap_or(astronomers_pi);
+    let _ = opt.unwrap_or(ext_str.some_field);
+    let _ = opt.and(ext_opt);
+    let _ = opt.or(ext_opt);
+    let _ = opt.or(None);
+    let _ = opt.get_or_insert(2);
+    let _ = opt.ok_or(2);
+
+    // Cases when unwrap is not called on a simple variable
+    let _ = Some(10).unwrap_or(2);
+    let _ = Some(10).and(ext_opt);
+    let _: Option<u32> = None.or(ext_opt);
+    let _ = None.get_or_insert(2);
+    let _: Result<u32, u32> = None.ok_or(2);
+    let _: Option<u32> = None.or(None);
+
+    let mut deep = Deep(Some(42));
+    let _ = deep.0.unwrap_or(2);
+    let _ = deep.0.and(ext_opt);
+    let _ = deep.0.or(None);
+    let _ = deep.0.get_or_insert(2);
+    let _ = deep.0.ok_or(2);
+
+    // Should not lint - Option
+    let _ = opt.unwrap_or_else(|| ext_str.return_some_field());
+    let _ = opt.or_else(some_call);
+    let _ = opt.or_else(|| some_call());
+    let _: Result<u32, u32> = opt.ok_or_else(|| some_call());
+    let _: Result<u32, u32> = opt.ok_or_else(some_call);
+    let _ = deep.0.get_or_insert_with(|| some_call());
+    let _ = deep.0.or_else(some_call);
+    let _ = deep.0.or_else(|| some_call());
+
+    // These are handled by bind_instead_of_map
+    let _: Option<u32> = None.or_else(|| Some(3));
+    let _ = deep.0.or_else(|| Some(3));
+    let _ = opt.or_else(|| Some(3));
+
+    // Should lint - Result
+    let res: Result<u32, u32> = Err(5);
+    let res2: Result<u32, SomeStruct> = Err(SomeStruct { some_field: 5 });
+
+    let _ = res2.unwrap_or(2);
+    let _ = res2.unwrap_or(astronomers_pi);
+    let _ = res2.unwrap_or(ext_str.some_field);
+
+    // Should not lint - Result
+    let _ = res.unwrap_or_else(|err| err);
+    let _ = res2.unwrap_or_else(|err| err.some_field);
+    let _ = res2.unwrap_or_else(|err| err.return_some_field());
+    let _ = res2.unwrap_or_else(|_| ext_str.return_some_field());
+
+    let _: Result<u32, u32> = res.and_then(|x| Ok(x));
+    let _: Result<u32, u32> = res.and_then(|x| Err(x));
+
+    let _: Result<u32, u32> = res.or_else(|err| Ok(err));
+    let _: Result<u32, u32> = res.or_else(|err| Err(err));
+
+    // These are handled by bind_instead_of_map
+    let _: Result<u32, u32> = res.and_then(|_| Ok(2));
+    let _: Result<u32, u32> = res.and_then(|_| Ok(astronomers_pi));
+    let _: Result<u32, u32> = res.and_then(|_| Ok(ext_str.some_field));
+
+    let _: Result<u32, u32> = res.and_then(|_| Err(2));
+    let _: Result<u32, u32> = res.and_then(|_| Err(astronomers_pi));
+    let _: Result<u32, u32> = res.and_then(|_| Err(ext_str.some_field));
+
+    let _: Result<u32, u32> = res.or_else(|_| Ok(2));
+    let _: Result<u32, u32> = res.or_else(|_| Ok(astronomers_pi));
+    let _: Result<u32, u32> = res.or_else(|_| Ok(ext_str.some_field));
+
+    let _: Result<u32, u32> = res.or_else(|_| Err(2));
+    let _: Result<u32, u32> = res.or_else(|_| Err(astronomers_pi));
+    let _: Result<u32, u32> = res.or_else(|_| Err(ext_str.some_field));
+}
diff --git a/tests/ui/unnecessary_lazy_eval.rs b/tests/ui/unnecessary_lazy_eval.rs
new file mode 100644
index 00000000000..04b3c8ae1e2
--- /dev/null
+++ b/tests/ui/unnecessary_lazy_eval.rs
@@ -0,0 +1,105 @@
+// run-rustfix
+#![warn(clippy::unnecessary_lazy_eval)]
+#![allow(clippy::redundant_closure)]
+#![allow(clippy::bind_instead_of_map)]
+
+struct Deep(Option<u32>);
+
+#[derive(Copy, Clone)]
+struct SomeStruct {
+    some_field: u32,
+}
+
+impl SomeStruct {
+    fn return_some_field(&self) -> u32 {
+        self.some_field
+    }
+}
+
+fn some_call<T: Default>() -> T {
+    T::default()
+}
+
+fn main() {
+    let astronomers_pi = 10;
+    let ext_str = SomeStruct { some_field: 10 };
+
+    // Should lint - Option
+    let mut opt = Some(42);
+    let ext_opt = Some(42);
+    let _ = opt.unwrap_or_else(|| 2);
+    let _ = opt.unwrap_or_else(|| astronomers_pi);
+    let _ = opt.unwrap_or_else(|| ext_str.some_field);
+    let _ = opt.and_then(|_| ext_opt);
+    let _ = opt.or_else(|| ext_opt);
+    let _ = opt.or_else(|| None);
+    let _ = opt.get_or_insert_with(|| 2);
+    let _ = opt.ok_or_else(|| 2);
+
+    // Cases when unwrap is not called on a simple variable
+    let _ = Some(10).unwrap_or_else(|| 2);
+    let _ = Some(10).and_then(|_| ext_opt);
+    let _: Option<u32> = None.or_else(|| ext_opt);
+    let _ = None.get_or_insert_with(|| 2);
+    let _: Result<u32, u32> = None.ok_or_else(|| 2);
+    let _: Option<u32> = None.or_else(|| None);
+
+    let mut deep = Deep(Some(42));
+    let _ = deep.0.unwrap_or_else(|| 2);
+    let _ = deep.0.and_then(|_| ext_opt);
+    let _ = deep.0.or_else(|| None);
+    let _ = deep.0.get_or_insert_with(|| 2);
+    let _ = deep.0.ok_or_else(|| 2);
+
+    // Should not lint - Option
+    let _ = opt.unwrap_or_else(|| ext_str.return_some_field());
+    let _ = opt.or_else(some_call);
+    let _ = opt.or_else(|| some_call());
+    let _: Result<u32, u32> = opt.ok_or_else(|| some_call());
+    let _: Result<u32, u32> = opt.ok_or_else(some_call);
+    let _ = deep.0.get_or_insert_with(|| some_call());
+    let _ = deep.0.or_else(some_call);
+    let _ = deep.0.or_else(|| some_call());
+
+    // These are handled by bind_instead_of_map
+    let _: Option<u32> = None.or_else(|| Some(3));
+    let _ = deep.0.or_else(|| Some(3));
+    let _ = opt.or_else(|| Some(3));
+
+    // Should lint - Result
+    let res: Result<u32, u32> = Err(5);
+    let res2: Result<u32, SomeStruct> = Err(SomeStruct { some_field: 5 });
+
+    let _ = res2.unwrap_or_else(|_| 2);
+    let _ = res2.unwrap_or_else(|_| astronomers_pi);
+    let _ = res2.unwrap_or_else(|_| ext_str.some_field);
+
+    // Should not lint - Result
+    let _ = res.unwrap_or_else(|err| err);
+    let _ = res2.unwrap_or_else(|err| err.some_field);
+    let _ = res2.unwrap_or_else(|err| err.return_some_field());
+    let _ = res2.unwrap_or_else(|_| ext_str.return_some_field());
+
+    let _: Result<u32, u32> = res.and_then(|x| Ok(x));
+    let _: Result<u32, u32> = res.and_then(|x| Err(x));
+
+    let _: Result<u32, u32> = res.or_else(|err| Ok(err));
+    let _: Result<u32, u32> = res.or_else(|err| Err(err));
+
+    // These are handled by bind_instead_of_map
+    let _: Result<u32, u32> = res.and_then(|_| Ok(2));
+    let _: Result<u32, u32> = res.and_then(|_| Ok(astronomers_pi));
+    let _: Result<u32, u32> = res.and_then(|_| Ok(ext_str.some_field));
+
+    let _: Result<u32, u32> = res.and_then(|_| Err(2));
+    let _: Result<u32, u32> = res.and_then(|_| Err(astronomers_pi));
+    let _: Result<u32, u32> = res.and_then(|_| Err(ext_str.some_field));
+
+    let _: Result<u32, u32> = res.or_else(|_| Ok(2));
+    let _: Result<u32, u32> = res.or_else(|_| Ok(astronomers_pi));
+    let _: Result<u32, u32> = res.or_else(|_| Ok(ext_str.some_field));
+
+    let _: Result<u32, u32> = res.or_else(|_| Err(2));
+    let _: Result<u32, u32> = res.or_else(|_| Err(astronomers_pi));
+    let _: Result<u32, u32> = res.or_else(|_| Err(ext_str.some_field));
+}
diff --git a/tests/ui/unnecessary_lazy_eval.stderr b/tests/ui/unnecessary_lazy_eval.stderr
new file mode 100644
index 00000000000..b941bf84246
--- /dev/null
+++ b/tests/ui/unnecessary_lazy_eval.stderr
@@ -0,0 +1,144 @@
+error: unnecessary closure used to substitute value for `Option::None`
+  --> $DIR/unnecessary_lazy_eval.rs:30:13
+   |
+LL |     let _ = opt.unwrap_or_else(|| 2);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `unwrap_or` instead: `opt.unwrap_or(2)`
+   |
+   = note: `-D clippy::unnecessary-lazy-evaluation` implied by `-D warnings`
+
+error: unnecessary closure used to substitute value for `Option::None`
+  --> $DIR/unnecessary_lazy_eval.rs:31:13
+   |
+LL |     let _ = opt.unwrap_or_else(|| astronomers_pi);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `unwrap_or` instead: `opt.unwrap_or(astronomers_pi)`
+
+error: unnecessary closure used to substitute value for `Option::None`
+  --> $DIR/unnecessary_lazy_eval.rs:32:13
+   |
+LL |     let _ = opt.unwrap_or_else(|| ext_str.some_field);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `unwrap_or` instead: `opt.unwrap_or(ext_str.some_field)`
+
+error: unnecessary closure used to substitute value for `Option::None`
+  --> $DIR/unnecessary_lazy_eval.rs:33:13
+   |
+LL |     let _ = opt.and_then(|_| ext_opt);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `and` instead: `opt.and(ext_opt)`
+
+error: unnecessary closure used to substitute value for `Option::None`
+  --> $DIR/unnecessary_lazy_eval.rs:34:13
+   |
+LL |     let _ = opt.or_else(|| ext_opt);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^ help: Use `or` instead: `opt.or(ext_opt)`
+
+error: unnecessary closure used to substitute value for `Option::None`
+  --> $DIR/unnecessary_lazy_eval.rs:35:13
+   |
+LL |     let _ = opt.or_else(|| None);
+   |             ^^^^^^^^^^^^^^^^^^^^ help: Use `or` instead: `opt.or(None)`
+
+error: unnecessary closure used to substitute value for `Option::None`
+  --> $DIR/unnecessary_lazy_eval.rs:36:13
+   |
+LL |     let _ = opt.get_or_insert_with(|| 2);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `get_or_insert` instead: `opt.get_or_insert(2)`
+
+error: unnecessary closure used to substitute value for `Option::None`
+  --> $DIR/unnecessary_lazy_eval.rs:37:13
+   |
+LL |     let _ = opt.ok_or_else(|| 2);
+   |             ^^^^^^^^^^^^^^^^^^^^ help: Use `ok_or` instead: `opt.ok_or(2)`
+
+error: unnecessary closure used to substitute value for `Option::None`
+  --> $DIR/unnecessary_lazy_eval.rs:40:13
+   |
+LL |     let _ = Some(10).unwrap_or_else(|| 2);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `unwrap_or` instead: `Some(10).unwrap_or(2)`
+
+error: unnecessary closure used to substitute value for `Option::None`
+  --> $DIR/unnecessary_lazy_eval.rs:41:13
+   |
+LL |     let _ = Some(10).and_then(|_| ext_opt);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `and` instead: `Some(10).and(ext_opt)`
+
+error: unnecessary closure used to substitute value for `Option::None`
+  --> $DIR/unnecessary_lazy_eval.rs:42:26
+   |
+LL |     let _: Option<u32> = None.or_else(|| ext_opt);
+   |                          ^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `or` instead: `None.or(ext_opt)`
+
+error: unnecessary closure used to substitute value for `Option::None`
+  --> $DIR/unnecessary_lazy_eval.rs:43:13
+   |
+LL |     let _ = None.get_or_insert_with(|| 2);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `get_or_insert` instead: `None.get_or_insert(2)`
+
+error: unnecessary closure used to substitute value for `Option::None`
+  --> $DIR/unnecessary_lazy_eval.rs:44:31
+   |
+LL |     let _: Result<u32, u32> = None.ok_or_else(|| 2);
+   |                               ^^^^^^^^^^^^^^^^^^^^^ help: Use `ok_or` instead: `None.ok_or(2)`
+
+error: unnecessary closure used to substitute value for `Option::None`
+  --> $DIR/unnecessary_lazy_eval.rs:45:26
+   |
+LL |     let _: Option<u32> = None.or_else(|| None);
+   |                          ^^^^^^^^^^^^^^^^^^^^^ help: Use `or` instead: `None.or(None)`
+
+error: unnecessary closure used to substitute value for `Option::None`
+  --> $DIR/unnecessary_lazy_eval.rs:48:13
+   |
+LL |     let _ = deep.0.unwrap_or_else(|| 2);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `unwrap_or` instead: `deep.0.unwrap_or(2)`
+
+error: unnecessary closure used to substitute value for `Option::None`
+  --> $DIR/unnecessary_lazy_eval.rs:49:13
+   |
+LL |     let _ = deep.0.and_then(|_| ext_opt);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `and` instead: `deep.0.and(ext_opt)`
+
+error: unnecessary closure used to substitute value for `Option::None`
+  --> $DIR/unnecessary_lazy_eval.rs:50:13
+   |
+LL |     let _ = deep.0.or_else(|| None);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^ help: Use `or` instead: `deep.0.or(None)`
+
+error: unnecessary closure used to substitute value for `Option::None`
+  --> $DIR/unnecessary_lazy_eval.rs:51:13
+   |
+LL |     let _ = deep.0.get_or_insert_with(|| 2);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `get_or_insert` instead: `deep.0.get_or_insert(2)`
+
+error: unnecessary closure used to substitute value for `Option::None`
+  --> $DIR/unnecessary_lazy_eval.rs:52:13
+   |
+LL |     let _ = deep.0.ok_or_else(|| 2);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^ help: Use `ok_or` instead: `deep.0.ok_or(2)`
+
+error: unnecessary closure used to substitute value for `Result::Err`
+  --> $DIR/unnecessary_lazy_eval.rs:73:13
+   |
+LL |     let _ = res2.unwrap_or_else(|_| 2);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `unwrap_or` instead: `res2.unwrap_or(2)`
+
+error: unnecessary closure used to substitute value for `Result::Err`
+  --> $DIR/unnecessary_lazy_eval.rs:74:13
+   |
+LL |     let _ = res2.unwrap_or_else(|_| astronomers_pi);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `unwrap_or` instead: `res2.unwrap_or(astronomers_pi)`
+
+error: unnecessary closure used to substitute value for `Result::Err`
+  --> $DIR/unnecessary_lazy_eval.rs:75:13
+   |
+LL |     let _ = res2.unwrap_or_else(|_| ext_str.some_field);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `unwrap_or` instead: `res2.unwrap_or(ext_str.some_field)`
+
+error: unknown clippy lint: clippy::unnecessary_lazy_eval
+  --> $DIR/unnecessary_lazy_eval.rs:2:9
+   |
+LL | #![warn(clippy::unnecessary_lazy_eval)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: did you mean: `clippy::unnecessary_lazy_evaluation`
+   |
+   = note: `-D clippy::unknown-clippy-lints` implied by `-D warnings`
+
+error: aborting due to 23 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 848af393103d769458a206547ea4506fd0229304 Mon Sep 17 00:00:00 2001
From: Dániel Buga <bugadani@gmail.com>
Date: Mon, 15 Jun 2020 14:55:23 +0200
Subject: Add note to `or_fun_call`, list checked methods

---
 clippy_lints/src/methods/mod.rs | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 61b7f2647ee..c672ca41dec 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1330,11 +1330,21 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Looks for unnecessary lazily evaluated closures on `Option` and `Result`.
+    /// **What it does:** As the counterpart to `or_fun_call`, this lint looks for unnecessary
+    /// lazily evaluated closures on `Option` and `Result`.
+    ///
+    /// This lint suggests changing the following functions, when eager evaluation results in
+    /// simpler code:
+    ///  - `unwrap_or_else` to `unwrap_or`
+    ///  - `and_then` to `and`
+    ///  - `or_else` to `or`
+    ///  - `get_or_insert_with` to `get_or_insert`
+    ///  - `ok_or_else` to `ok_or`
     ///
     /// **Why is this bad?** Using eager evaluation is shorter and simpler in some cases.
     ///
-    /// **Known problems:** None.
+    /// **Known problems:** It is possible, but not recommended for `Deref` and `Index` to have
+    /// side effects. Eagerly evaluating them can change the semantics of the program.
     ///
     /// **Example:**
     ///
-- 
cgit 1.4.1-3-g733a5


From a7cc5d40683b9351c35a627b05886f43fdec684f Mon Sep 17 00:00:00 2001
From: Dániel Buga <bugadani@gmail.com>
Date: Mon, 15 Jun 2020 15:26:02 +0200
Subject: Also simplify if the closure body is an index expression

---
 clippy_lints/src/methods/mod.rs       | 10 ++++++
 tests/ui/unnecessary_lazy_eval.fixed  | 60 +++++++++++++++++--------------
 tests/ui/unnecessary_lazy_eval.rs     | 60 +++++++++++++++++--------------
 tests/ui/unnecessary_lazy_eval.stderr | 68 ++++++++++++++++++++---------------
 4 files changed, 116 insertions(+), 82 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index c672ca41dec..ed8eaba75d1 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -2753,6 +2753,16 @@ fn lint_lazy_eval<'a, 'tcx>(
             // Closures returning literals can be unconditionally simplified
             hir::ExprKind::Lit(_) => true,
 
+            hir::ExprKind::Index(ref object, ref index) => {
+                // arguments are not being indexed into
+                if !expr_uses_argument(object, params) {
+                    // arguments are not used as index
+                    !expr_uses_argument(index, params)
+                } else {
+                    false
+                }
+            },
+
             // Reading fields can be simplified if the object is not an argument of the closure
             hir::ExprKind::Field(ref object, _) => !expr_uses_argument(object, params),
 
diff --git a/tests/ui/unnecessary_lazy_eval.fixed b/tests/ui/unnecessary_lazy_eval.fixed
index fcfa6dfe12d..c806cf8dce4 100644
--- a/tests/ui/unnecessary_lazy_eval.fixed
+++ b/tests/ui/unnecessary_lazy_eval.fixed
@@ -3,15 +3,15 @@
 #![allow(clippy::redundant_closure)]
 #![allow(clippy::bind_instead_of_map)]
 
-struct Deep(Option<u32>);
+struct Deep(Option<usize>);
 
 #[derive(Copy, Clone)]
 struct SomeStruct {
-    some_field: u32,
+    some_field: usize,
 }
 
 impl SomeStruct {
-    fn return_some_field(&self) -> u32 {
+    fn return_some_field(&self) -> usize {
         self.some_field
     }
 }
@@ -22,6 +22,7 @@ fn some_call<T: Default>() -> T {
 
 fn main() {
     let astronomers_pi = 10;
+    let ext_arr: [usize; 1] = [2];
     let ext_str = SomeStruct { some_field: 10 };
 
     // Should lint - Option
@@ -30,19 +31,21 @@ fn main() {
     let _ = opt.unwrap_or(2);
     let _ = opt.unwrap_or(astronomers_pi);
     let _ = opt.unwrap_or(ext_str.some_field);
+    let _ = opt.unwrap_or(ext_arr[0]);
     let _ = opt.and(ext_opt);
     let _ = opt.or(ext_opt);
     let _ = opt.or(None);
     let _ = opt.get_or_insert(2);
     let _ = opt.ok_or(2);
+    let _ = opt.ok_or(ext_arr[0]);
 
     // Cases when unwrap is not called on a simple variable
     let _ = Some(10).unwrap_or(2);
     let _ = Some(10).and(ext_opt);
-    let _: Option<u32> = None.or(ext_opt);
+    let _: Option<usize> = None.or(ext_opt);
     let _ = None.get_or_insert(2);
-    let _: Result<u32, u32> = None.ok_or(2);
-    let _: Option<u32> = None.or(None);
+    let _: Result<usize, usize> = None.ok_or(2);
+    let _: Option<usize> = None.or(None);
 
     let mut deep = Deep(Some(42));
     let _ = deep.0.unwrap_or(2);
@@ -55,20 +58,22 @@ fn main() {
     let _ = opt.unwrap_or_else(|| ext_str.return_some_field());
     let _ = opt.or_else(some_call);
     let _ = opt.or_else(|| some_call());
-    let _: Result<u32, u32> = opt.ok_or_else(|| some_call());
-    let _: Result<u32, u32> = opt.ok_or_else(some_call);
+    let _: Result<usize, usize> = opt.ok_or_else(|| some_call());
+    let _: Result<usize, usize> = opt.ok_or_else(some_call);
     let _ = deep.0.get_or_insert_with(|| some_call());
     let _ = deep.0.or_else(some_call);
     let _ = deep.0.or_else(|| some_call());
 
     // These are handled by bind_instead_of_map
-    let _: Option<u32> = None.or_else(|| Some(3));
+    let _ = Some(10).and_then(|idx| Some(ext_arr[idx]));
+    let _ = Some(10).and_then(|idx| Some(idx));
+    let _: Option<usize> = None.or_else(|| Some(3));
     let _ = deep.0.or_else(|| Some(3));
     let _ = opt.or_else(|| Some(3));
 
     // Should lint - Result
-    let res: Result<u32, u32> = Err(5);
-    let res2: Result<u32, SomeStruct> = Err(SomeStruct { some_field: 5 });
+    let res: Result<usize, usize> = Err(5);
+    let res2: Result<usize, SomeStruct> = Err(SomeStruct { some_field: 5 });
 
     let _ = res2.unwrap_or(2);
     let _ = res2.unwrap_or(astronomers_pi);
@@ -76,30 +81,31 @@ fn main() {
 
     // Should not lint - Result
     let _ = res.unwrap_or_else(|err| err);
+    let _ = res.unwrap_or_else(|err| ext_arr[err]);
     let _ = res2.unwrap_or_else(|err| err.some_field);
     let _ = res2.unwrap_or_else(|err| err.return_some_field());
     let _ = res2.unwrap_or_else(|_| ext_str.return_some_field());
 
-    let _: Result<u32, u32> = res.and_then(|x| Ok(x));
-    let _: Result<u32, u32> = res.and_then(|x| Err(x));
+    let _: Result<usize, usize> = res.and_then(|x| Ok(x));
+    let _: Result<usize, usize> = res.and_then(|x| Err(x));
 
-    let _: Result<u32, u32> = res.or_else(|err| Ok(err));
-    let _: Result<u32, u32> = res.or_else(|err| Err(err));
+    let _: Result<usize, usize> = res.or_else(|err| Ok(err));
+    let _: Result<usize, usize> = res.or_else(|err| Err(err));
 
     // These are handled by bind_instead_of_map
-    let _: Result<u32, u32> = res.and_then(|_| Ok(2));
-    let _: Result<u32, u32> = res.and_then(|_| Ok(astronomers_pi));
-    let _: Result<u32, u32> = res.and_then(|_| Ok(ext_str.some_field));
+    let _: Result<usize, usize> = res.and_then(|_| Ok(2));
+    let _: Result<usize, usize> = res.and_then(|_| Ok(astronomers_pi));
+    let _: Result<usize, usize> = res.and_then(|_| Ok(ext_str.some_field));
 
-    let _: Result<u32, u32> = res.and_then(|_| Err(2));
-    let _: Result<u32, u32> = res.and_then(|_| Err(astronomers_pi));
-    let _: Result<u32, u32> = res.and_then(|_| Err(ext_str.some_field));
+    let _: Result<usize, usize> = res.and_then(|_| Err(2));
+    let _: Result<usize, usize> = res.and_then(|_| Err(astronomers_pi));
+    let _: Result<usize, usize> = res.and_then(|_| Err(ext_str.some_field));
 
-    let _: Result<u32, u32> = res.or_else(|_| Ok(2));
-    let _: Result<u32, u32> = res.or_else(|_| Ok(astronomers_pi));
-    let _: Result<u32, u32> = res.or_else(|_| Ok(ext_str.some_field));
+    let _: Result<usize, usize> = res.or_else(|_| Ok(2));
+    let _: Result<usize, usize> = res.or_else(|_| Ok(astronomers_pi));
+    let _: Result<usize, usize> = res.or_else(|_| Ok(ext_str.some_field));
 
-    let _: Result<u32, u32> = res.or_else(|_| Err(2));
-    let _: Result<u32, u32> = res.or_else(|_| Err(astronomers_pi));
-    let _: Result<u32, u32> = res.or_else(|_| Err(ext_str.some_field));
+    let _: Result<usize, usize> = res.or_else(|_| Err(2));
+    let _: Result<usize, usize> = res.or_else(|_| Err(astronomers_pi));
+    let _: Result<usize, usize> = res.or_else(|_| Err(ext_str.some_field));
 }
diff --git a/tests/ui/unnecessary_lazy_eval.rs b/tests/ui/unnecessary_lazy_eval.rs
index 04b3c8ae1e2..dfc6d3ba573 100644
--- a/tests/ui/unnecessary_lazy_eval.rs
+++ b/tests/ui/unnecessary_lazy_eval.rs
@@ -3,15 +3,15 @@
 #![allow(clippy::redundant_closure)]
 #![allow(clippy::bind_instead_of_map)]
 
-struct Deep(Option<u32>);
+struct Deep(Option<usize>);
 
 #[derive(Copy, Clone)]
 struct SomeStruct {
-    some_field: u32,
+    some_field: usize,
 }
 
 impl SomeStruct {
-    fn return_some_field(&self) -> u32 {
+    fn return_some_field(&self) -> usize {
         self.some_field
     }
 }
@@ -22,6 +22,7 @@ fn some_call<T: Default>() -> T {
 
 fn main() {
     let astronomers_pi = 10;
+    let ext_arr: [usize; 1] = [2];
     let ext_str = SomeStruct { some_field: 10 };
 
     // Should lint - Option
@@ -30,19 +31,21 @@ fn main() {
     let _ = opt.unwrap_or_else(|| 2);
     let _ = opt.unwrap_or_else(|| astronomers_pi);
     let _ = opt.unwrap_or_else(|| ext_str.some_field);
+    let _ = opt.unwrap_or_else(|| ext_arr[0]);
     let _ = opt.and_then(|_| ext_opt);
     let _ = opt.or_else(|| ext_opt);
     let _ = opt.or_else(|| None);
     let _ = opt.get_or_insert_with(|| 2);
     let _ = opt.ok_or_else(|| 2);
+    let _ = opt.ok_or_else(|| ext_arr[0]);
 
     // Cases when unwrap is not called on a simple variable
     let _ = Some(10).unwrap_or_else(|| 2);
     let _ = Some(10).and_then(|_| ext_opt);
-    let _: Option<u32> = None.or_else(|| ext_opt);
+    let _: Option<usize> = None.or_else(|| ext_opt);
     let _ = None.get_or_insert_with(|| 2);
-    let _: Result<u32, u32> = None.ok_or_else(|| 2);
-    let _: Option<u32> = None.or_else(|| None);
+    let _: Result<usize, usize> = None.ok_or_else(|| 2);
+    let _: Option<usize> = None.or_else(|| None);
 
     let mut deep = Deep(Some(42));
     let _ = deep.0.unwrap_or_else(|| 2);
@@ -55,20 +58,22 @@ fn main() {
     let _ = opt.unwrap_or_else(|| ext_str.return_some_field());
     let _ = opt.or_else(some_call);
     let _ = opt.or_else(|| some_call());
-    let _: Result<u32, u32> = opt.ok_or_else(|| some_call());
-    let _: Result<u32, u32> = opt.ok_or_else(some_call);
+    let _: Result<usize, usize> = opt.ok_or_else(|| some_call());
+    let _: Result<usize, usize> = opt.ok_or_else(some_call);
     let _ = deep.0.get_or_insert_with(|| some_call());
     let _ = deep.0.or_else(some_call);
     let _ = deep.0.or_else(|| some_call());
 
     // These are handled by bind_instead_of_map
-    let _: Option<u32> = None.or_else(|| Some(3));
+    let _ = Some(10).and_then(|idx| Some(ext_arr[idx]));
+    let _ = Some(10).and_then(|idx| Some(idx));
+    let _: Option<usize> = None.or_else(|| Some(3));
     let _ = deep.0.or_else(|| Some(3));
     let _ = opt.or_else(|| Some(3));
 
     // Should lint - Result
-    let res: Result<u32, u32> = Err(5);
-    let res2: Result<u32, SomeStruct> = Err(SomeStruct { some_field: 5 });
+    let res: Result<usize, usize> = Err(5);
+    let res2: Result<usize, SomeStruct> = Err(SomeStruct { some_field: 5 });
 
     let _ = res2.unwrap_or_else(|_| 2);
     let _ = res2.unwrap_or_else(|_| astronomers_pi);
@@ -76,30 +81,31 @@ fn main() {
 
     // Should not lint - Result
     let _ = res.unwrap_or_else(|err| err);
+    let _ = res.unwrap_or_else(|err| ext_arr[err]);
     let _ = res2.unwrap_or_else(|err| err.some_field);
     let _ = res2.unwrap_or_else(|err| err.return_some_field());
     let _ = res2.unwrap_or_else(|_| ext_str.return_some_field());
 
-    let _: Result<u32, u32> = res.and_then(|x| Ok(x));
-    let _: Result<u32, u32> = res.and_then(|x| Err(x));
+    let _: Result<usize, usize> = res.and_then(|x| Ok(x));
+    let _: Result<usize, usize> = res.and_then(|x| Err(x));
 
-    let _: Result<u32, u32> = res.or_else(|err| Ok(err));
-    let _: Result<u32, u32> = res.or_else(|err| Err(err));
+    let _: Result<usize, usize> = res.or_else(|err| Ok(err));
+    let _: Result<usize, usize> = res.or_else(|err| Err(err));
 
     // These are handled by bind_instead_of_map
-    let _: Result<u32, u32> = res.and_then(|_| Ok(2));
-    let _: Result<u32, u32> = res.and_then(|_| Ok(astronomers_pi));
-    let _: Result<u32, u32> = res.and_then(|_| Ok(ext_str.some_field));
+    let _: Result<usize, usize> = res.and_then(|_| Ok(2));
+    let _: Result<usize, usize> = res.and_then(|_| Ok(astronomers_pi));
+    let _: Result<usize, usize> = res.and_then(|_| Ok(ext_str.some_field));
 
-    let _: Result<u32, u32> = res.and_then(|_| Err(2));
-    let _: Result<u32, u32> = res.and_then(|_| Err(astronomers_pi));
-    let _: Result<u32, u32> = res.and_then(|_| Err(ext_str.some_field));
+    let _: Result<usize, usize> = res.and_then(|_| Err(2));
+    let _: Result<usize, usize> = res.and_then(|_| Err(astronomers_pi));
+    let _: Result<usize, usize> = res.and_then(|_| Err(ext_str.some_field));
 
-    let _: Result<u32, u32> = res.or_else(|_| Ok(2));
-    let _: Result<u32, u32> = res.or_else(|_| Ok(astronomers_pi));
-    let _: Result<u32, u32> = res.or_else(|_| Ok(ext_str.some_field));
+    let _: Result<usize, usize> = res.or_else(|_| Ok(2));
+    let _: Result<usize, usize> = res.or_else(|_| Ok(astronomers_pi));
+    let _: Result<usize, usize> = res.or_else(|_| Ok(ext_str.some_field));
 
-    let _: Result<u32, u32> = res.or_else(|_| Err(2));
-    let _: Result<u32, u32> = res.or_else(|_| Err(astronomers_pi));
-    let _: Result<u32, u32> = res.or_else(|_| Err(ext_str.some_field));
+    let _: Result<usize, usize> = res.or_else(|_| Err(2));
+    let _: Result<usize, usize> = res.or_else(|_| Err(astronomers_pi));
+    let _: Result<usize, usize> = res.or_else(|_| Err(ext_str.some_field));
 }
diff --git a/tests/ui/unnecessary_lazy_eval.stderr b/tests/ui/unnecessary_lazy_eval.stderr
index b941bf84246..15591817540 100644
--- a/tests/ui/unnecessary_lazy_eval.stderr
+++ b/tests/ui/unnecessary_lazy_eval.stderr
@@ -1,5 +1,5 @@
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:30:13
+  --> $DIR/unnecessary_lazy_eval.rs:31:13
    |
 LL |     let _ = opt.unwrap_or_else(|| 2);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `unwrap_or` instead: `opt.unwrap_or(2)`
@@ -7,43 +7,49 @@ LL |     let _ = opt.unwrap_or_else(|| 2);
    = note: `-D clippy::unnecessary-lazy-evaluation` implied by `-D warnings`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:31:13
+  --> $DIR/unnecessary_lazy_eval.rs:32:13
    |
 LL |     let _ = opt.unwrap_or_else(|| astronomers_pi);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `unwrap_or` instead: `opt.unwrap_or(astronomers_pi)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:32:13
+  --> $DIR/unnecessary_lazy_eval.rs:33:13
    |
 LL |     let _ = opt.unwrap_or_else(|| ext_str.some_field);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `unwrap_or` instead: `opt.unwrap_or(ext_str.some_field)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:33:13
+  --> $DIR/unnecessary_lazy_eval.rs:34:13
+   |
+LL |     let _ = opt.unwrap_or_else(|| ext_arr[0]);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `unwrap_or` instead: `opt.unwrap_or(ext_arr[0])`
+
+error: unnecessary closure used to substitute value for `Option::None`
+  --> $DIR/unnecessary_lazy_eval.rs:35:13
    |
 LL |     let _ = opt.and_then(|_| ext_opt);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `and` instead: `opt.and(ext_opt)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:34:13
+  --> $DIR/unnecessary_lazy_eval.rs:36:13
    |
 LL |     let _ = opt.or_else(|| ext_opt);
    |             ^^^^^^^^^^^^^^^^^^^^^^^ help: Use `or` instead: `opt.or(ext_opt)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:35:13
+  --> $DIR/unnecessary_lazy_eval.rs:37:13
    |
 LL |     let _ = opt.or_else(|| None);
    |             ^^^^^^^^^^^^^^^^^^^^ help: Use `or` instead: `opt.or(None)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:36:13
+  --> $DIR/unnecessary_lazy_eval.rs:38:13
    |
 LL |     let _ = opt.get_or_insert_with(|| 2);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `get_or_insert` instead: `opt.get_or_insert(2)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:37:13
+  --> $DIR/unnecessary_lazy_eval.rs:39:13
    |
 LL |     let _ = opt.ok_or_else(|| 2);
    |             ^^^^^^^^^^^^^^^^^^^^ help: Use `ok_or` instead: `opt.ok_or(2)`
@@ -51,83 +57,89 @@ LL |     let _ = opt.ok_or_else(|| 2);
 error: unnecessary closure used to substitute value for `Option::None`
   --> $DIR/unnecessary_lazy_eval.rs:40:13
    |
+LL |     let _ = opt.ok_or_else(|| ext_arr[0]);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `ok_or` instead: `opt.ok_or(ext_arr[0])`
+
+error: unnecessary closure used to substitute value for `Option::None`
+  --> $DIR/unnecessary_lazy_eval.rs:43:13
+   |
 LL |     let _ = Some(10).unwrap_or_else(|| 2);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `unwrap_or` instead: `Some(10).unwrap_or(2)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:41:13
+  --> $DIR/unnecessary_lazy_eval.rs:44:13
    |
 LL |     let _ = Some(10).and_then(|_| ext_opt);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `and` instead: `Some(10).and(ext_opt)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:42:26
+  --> $DIR/unnecessary_lazy_eval.rs:45:28
    |
-LL |     let _: Option<u32> = None.or_else(|| ext_opt);
-   |                          ^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `or` instead: `None.or(ext_opt)`
+LL |     let _: Option<usize> = None.or_else(|| ext_opt);
+   |                            ^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `or` instead: `None.or(ext_opt)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:43:13
+  --> $DIR/unnecessary_lazy_eval.rs:46:13
    |
 LL |     let _ = None.get_or_insert_with(|| 2);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `get_or_insert` instead: `None.get_or_insert(2)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:44:31
+  --> $DIR/unnecessary_lazy_eval.rs:47:35
    |
-LL |     let _: Result<u32, u32> = None.ok_or_else(|| 2);
-   |                               ^^^^^^^^^^^^^^^^^^^^^ help: Use `ok_or` instead: `None.ok_or(2)`
+LL |     let _: Result<usize, usize> = None.ok_or_else(|| 2);
+   |                                   ^^^^^^^^^^^^^^^^^^^^^ help: Use `ok_or` instead: `None.ok_or(2)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:45:26
+  --> $DIR/unnecessary_lazy_eval.rs:48:28
    |
-LL |     let _: Option<u32> = None.or_else(|| None);
-   |                          ^^^^^^^^^^^^^^^^^^^^^ help: Use `or` instead: `None.or(None)`
+LL |     let _: Option<usize> = None.or_else(|| None);
+   |                            ^^^^^^^^^^^^^^^^^^^^^ help: Use `or` instead: `None.or(None)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:48:13
+  --> $DIR/unnecessary_lazy_eval.rs:51:13
    |
 LL |     let _ = deep.0.unwrap_or_else(|| 2);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `unwrap_or` instead: `deep.0.unwrap_or(2)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:49:13
+  --> $DIR/unnecessary_lazy_eval.rs:52:13
    |
 LL |     let _ = deep.0.and_then(|_| ext_opt);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `and` instead: `deep.0.and(ext_opt)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:50:13
+  --> $DIR/unnecessary_lazy_eval.rs:53:13
    |
 LL |     let _ = deep.0.or_else(|| None);
    |             ^^^^^^^^^^^^^^^^^^^^^^^ help: Use `or` instead: `deep.0.or(None)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:51:13
+  --> $DIR/unnecessary_lazy_eval.rs:54:13
    |
 LL |     let _ = deep.0.get_or_insert_with(|| 2);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `get_or_insert` instead: `deep.0.get_or_insert(2)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:52:13
+  --> $DIR/unnecessary_lazy_eval.rs:55:13
    |
 LL |     let _ = deep.0.ok_or_else(|| 2);
    |             ^^^^^^^^^^^^^^^^^^^^^^^ help: Use `ok_or` instead: `deep.0.ok_or(2)`
 
 error: unnecessary closure used to substitute value for `Result::Err`
-  --> $DIR/unnecessary_lazy_eval.rs:73:13
+  --> $DIR/unnecessary_lazy_eval.rs:78:13
    |
 LL |     let _ = res2.unwrap_or_else(|_| 2);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `unwrap_or` instead: `res2.unwrap_or(2)`
 
 error: unnecessary closure used to substitute value for `Result::Err`
-  --> $DIR/unnecessary_lazy_eval.rs:74:13
+  --> $DIR/unnecessary_lazy_eval.rs:79:13
    |
 LL |     let _ = res2.unwrap_or_else(|_| astronomers_pi);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `unwrap_or` instead: `res2.unwrap_or(astronomers_pi)`
 
 error: unnecessary closure used to substitute value for `Result::Err`
-  --> $DIR/unnecessary_lazy_eval.rs:75:13
+  --> $DIR/unnecessary_lazy_eval.rs:80:13
    |
 LL |     let _ = res2.unwrap_or_else(|_| ext_str.some_field);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `unwrap_or` instead: `res2.unwrap_or(ext_str.some_field)`
@@ -140,5 +152,5 @@ LL | #![warn(clippy::unnecessary_lazy_eval)]
    |
    = note: `-D clippy::unknown-clippy-lints` implied by `-D warnings`
 
-error: aborting due to 23 previous errors
+error: aborting due to 25 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From d7220dbd9143422a5b3a1ebf4dd46b708f83f1d3 Mon Sep 17 00:00:00 2001
From: Dániel Buga <bugadani@gmail.com>
Date: Mon, 15 Jun 2020 15:22:22 +0200
Subject: Run cargo dev update_lints

---
 CHANGELOG.md            | 2 +-
 clippy_lints/src/lib.rs | 4 ++--
 src/lintlist/mod.rs     | 2 +-
 3 files changed, 4 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 54489751014..675dfd420a7 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1754,7 +1754,7 @@ Released 2018-09-13
 [`unnecessary_cast`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_cast
 [`unnecessary_filter_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_filter_map
 [`unnecessary_fold`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_fold
-[`unnecessary_lazy_eval`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_lazy_eval
+[`unnecessary_lazy_evaluation`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_lazy_evaluation
 [`unnecessary_mut_passed`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_mut_passed
 [`unnecessary_operation`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_operation
 [`unnecessary_sort_by`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_sort_by
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index cb29f71387b..ae7045884f7 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -672,7 +672,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &methods::OK_EXPECT,
         &methods::OPTION_AS_REF_DEREF,
         &methods::OPTION_MAP_OR_NONE,
-        &methods::UNNECESSARY_LAZY_EVALUATION,
         &methods::OR_FUN_CALL,
         &methods::RESULT_MAP_OR_INTO_OPTION,
         &methods::SEARCH_IS_SOME,
@@ -686,6 +685,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &methods::UNINIT_ASSUMED_INIT,
         &methods::UNNECESSARY_FILTER_MAP,
         &methods::UNNECESSARY_FOLD,
+        &methods::UNNECESSARY_LAZY_EVALUATION,
         &methods::UNWRAP_USED,
         &methods::USELESS_ASREF,
         &methods::WRONG_PUB_SELF_CONVENTION,
@@ -1542,6 +1542,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&methods::SINGLE_CHAR_PUSH_STR),
         LintId::of(&methods::STRING_EXTEND_CHARS),
         LintId::of(&methods::UNNECESSARY_FOLD),
+        LintId::of(&methods::UNNECESSARY_LAZY_EVALUATION),
         LintId::of(&methods::WRONG_SELF_CONVENTION),
         LintId::of(&misc::TOPLEVEL_REF_ARG),
         LintId::of(&misc::ZERO_PTR),
@@ -1612,7 +1613,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&methods::FILTER_NEXT),
         LintId::of(&methods::FLAT_MAP_IDENTITY),
         LintId::of(&methods::OPTION_AS_REF_DEREF),
-        LintId::of(&methods::UNNECESSARY_LAZY_EVALUATION),
         LintId::of(&methods::SEARCH_IS_SOME),
         LintId::of(&methods::SKIP_WHILE_NEXT),
         LintId::of(&methods::SUSPICIOUS_MAP),
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index 1e76163f946..2a66d3495ed 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -2384,7 +2384,7 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
         module: "methods",
     },
     Lint {
-        name: "unnecessary_lazy_eval",
+        name: "unnecessary_lazy_evaluation",
         group: "style",
         desc: "using unnecessary lazy evaluation, which can be replaced with simpler eager evaluation",
         deprecation: None,
-- 
cgit 1.4.1-3-g733a5


From 75637c1edac6db37b3c8aa17ef6b5a91db699a00 Mon Sep 17 00:00:00 2001
From: Dániel Buga <bugadani@gmail.com>
Date: Mon, 15 Jun 2020 20:01:18 +0200
Subject: Catch function calls in argument lists, add tests that tuples don't
 get linted

---
 clippy_lints/src/methods/mod.rs       | 25 ++++++++++--------
 tests/ui/unnecessary_lazy_eval.fixed  |  8 +++++-
 tests/ui/unnecessary_lazy_eval.rs     |  8 +++++-
 tests/ui/unnecessary_lazy_eval.stderr | 48 +++++++++++++++++------------------
 4 files changed, 52 insertions(+), 37 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index ed8eaba75d1..463ef48f62c 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -2744,12 +2744,8 @@ fn lint_lazy_eval<'a, 'tcx>(
         paths.iter().any(|candidate| match_qpath(path, candidate))
     }
 
-    if let hir::ExprKind::Closure(_, _, eid, _, _) = args[1].kind {
-        let body = cx.tcx.hir().body(eid);
-        let ex = &body.value;
-        let params = &body.params;
-
-        let simplify = match ex.kind {
+    fn can_simplify(expr: &hir::Expr<'_>, params: &[hir::Param<'_>], variant_calls: bool) -> bool {
+        match expr.kind {
             // Closures returning literals can be unconditionally simplified
             hir::ExprKind::Lit(_) => true,
 
@@ -2767,15 +2763,16 @@ fn lint_lazy_eval<'a, 'tcx>(
             hir::ExprKind::Field(ref object, _) => !expr_uses_argument(object, params),
 
             // Paths can be simplified if the root is not the argument, this also covers None
-            hir::ExprKind::Path(_) => !expr_uses_argument(ex, params),
+            hir::ExprKind::Path(_) => !expr_uses_argument(expr, params),
 
             // Calls to Some, Ok, Err can be considered literals if they don't derive an argument
             hir::ExprKind::Call(ref func, ref args) => if_chain! {
-                if allow_variant_calls; // Disable lint when rules conflict with bind_instead_of_map
+                if variant_calls; // Disable lint when rules conflict with bind_instead_of_map
                 if let hir::ExprKind::Path(ref path) = func.kind;
                 if match_any_qpath(path, &[&["Some"], &["Ok"], &["Err"]]);
                 then {
-                    !args.iter().any(|arg| expr_uses_argument(arg, params))
+                    // Recursively check all arguments
+                    args.iter().all(|arg| can_simplify(arg, params, variant_calls))
                 } else {
                     false
                 }
@@ -2784,9 +2781,15 @@ fn lint_lazy_eval<'a, 'tcx>(
             // For anything more complex than the above, a closure is probably the right solution,
             // or the case is handled by an other lint
             _ => false,
-        };
+        }
+    }
+
+    if let hir::ExprKind::Closure(_, _, eid, _, _) = args[1].kind {
+        let body = cx.tcx.hir().body(eid);
+        let ex = &body.value;
+        let params = &body.params;
 
-        if simplify {
+        if can_simplify(ex, params, allow_variant_calls) {
             let msg = if is_option {
                 "unnecessary closure used to substitute value for `Option::None`"
             } else {
diff --git a/tests/ui/unnecessary_lazy_eval.fixed b/tests/ui/unnecessary_lazy_eval.fixed
index c806cf8dce4..7f9d90a8569 100644
--- a/tests/ui/unnecessary_lazy_eval.fixed
+++ b/tests/ui/unnecessary_lazy_eval.fixed
@@ -25,9 +25,12 @@ fn main() {
     let ext_arr: [usize; 1] = [2];
     let ext_str = SomeStruct { some_field: 10 };
 
-    // Should lint - Option
     let mut opt = Some(42);
     let ext_opt = Some(42);
+    let nested_opt = Some(Some(42));
+    let nested_tuple_opt = Some(Some((42, 43)));
+
+    // Should lint - Option
     let _ = opt.unwrap_or(2);
     let _ = opt.unwrap_or(astronomers_pi);
     let _ = opt.unwrap_or(ext_str.some_field);
@@ -56,6 +59,9 @@ fn main() {
 
     // Should not lint - Option
     let _ = opt.unwrap_or_else(|| ext_str.return_some_field());
+    let _ = nested_opt.unwrap_or_else(|| Some(some_call()));
+    let _ = nested_tuple_opt.unwrap_or_else(|| Some((1, 2)));
+    let _ = nested_tuple_opt.unwrap_or_else(|| Some((some_call(), some_call())));
     let _ = opt.or_else(some_call);
     let _ = opt.or_else(|| some_call());
     let _: Result<usize, usize> = opt.ok_or_else(|| some_call());
diff --git a/tests/ui/unnecessary_lazy_eval.rs b/tests/ui/unnecessary_lazy_eval.rs
index dfc6d3ba573..ca8238d6dcf 100644
--- a/tests/ui/unnecessary_lazy_eval.rs
+++ b/tests/ui/unnecessary_lazy_eval.rs
@@ -25,9 +25,12 @@ fn main() {
     let ext_arr: [usize; 1] = [2];
     let ext_str = SomeStruct { some_field: 10 };
 
-    // Should lint - Option
     let mut opt = Some(42);
     let ext_opt = Some(42);
+    let nested_opt = Some(Some(42));
+    let nested_tuple_opt = Some(Some((42, 43)));
+
+    // Should lint - Option
     let _ = opt.unwrap_or_else(|| 2);
     let _ = opt.unwrap_or_else(|| astronomers_pi);
     let _ = opt.unwrap_or_else(|| ext_str.some_field);
@@ -56,6 +59,9 @@ fn main() {
 
     // Should not lint - Option
     let _ = opt.unwrap_or_else(|| ext_str.return_some_field());
+    let _ = nested_opt.unwrap_or_else(|| Some(some_call()));
+    let _ = nested_tuple_opt.unwrap_or_else(|| Some((1, 2)));
+    let _ = nested_tuple_opt.unwrap_or_else(|| Some((some_call(), some_call())));
     let _ = opt.or_else(some_call);
     let _ = opt.or_else(|| some_call());
     let _: Result<usize, usize> = opt.ok_or_else(|| some_call());
diff --git a/tests/ui/unnecessary_lazy_eval.stderr b/tests/ui/unnecessary_lazy_eval.stderr
index 15591817540..b8ec654e5c7 100644
--- a/tests/ui/unnecessary_lazy_eval.stderr
+++ b/tests/ui/unnecessary_lazy_eval.stderr
@@ -1,5 +1,5 @@
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:31:13
+  --> $DIR/unnecessary_lazy_eval.rs:34:13
    |
 LL |     let _ = opt.unwrap_or_else(|| 2);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `unwrap_or` instead: `opt.unwrap_or(2)`
@@ -7,139 +7,139 @@ LL |     let _ = opt.unwrap_or_else(|| 2);
    = note: `-D clippy::unnecessary-lazy-evaluation` implied by `-D warnings`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:32:13
+  --> $DIR/unnecessary_lazy_eval.rs:35:13
    |
 LL |     let _ = opt.unwrap_or_else(|| astronomers_pi);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `unwrap_or` instead: `opt.unwrap_or(astronomers_pi)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:33:13
+  --> $DIR/unnecessary_lazy_eval.rs:36:13
    |
 LL |     let _ = opt.unwrap_or_else(|| ext_str.some_field);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `unwrap_or` instead: `opt.unwrap_or(ext_str.some_field)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:34:13
+  --> $DIR/unnecessary_lazy_eval.rs:37:13
    |
 LL |     let _ = opt.unwrap_or_else(|| ext_arr[0]);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `unwrap_or` instead: `opt.unwrap_or(ext_arr[0])`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:35:13
+  --> $DIR/unnecessary_lazy_eval.rs:38:13
    |
 LL |     let _ = opt.and_then(|_| ext_opt);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `and` instead: `opt.and(ext_opt)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:36:13
+  --> $DIR/unnecessary_lazy_eval.rs:39:13
    |
 LL |     let _ = opt.or_else(|| ext_opt);
    |             ^^^^^^^^^^^^^^^^^^^^^^^ help: Use `or` instead: `opt.or(ext_opt)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:37:13
+  --> $DIR/unnecessary_lazy_eval.rs:40:13
    |
 LL |     let _ = opt.or_else(|| None);
    |             ^^^^^^^^^^^^^^^^^^^^ help: Use `or` instead: `opt.or(None)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:38:13
+  --> $DIR/unnecessary_lazy_eval.rs:41:13
    |
 LL |     let _ = opt.get_or_insert_with(|| 2);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `get_or_insert` instead: `opt.get_or_insert(2)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:39:13
+  --> $DIR/unnecessary_lazy_eval.rs:42:13
    |
 LL |     let _ = opt.ok_or_else(|| 2);
    |             ^^^^^^^^^^^^^^^^^^^^ help: Use `ok_or` instead: `opt.ok_or(2)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:40:13
+  --> $DIR/unnecessary_lazy_eval.rs:43:13
    |
 LL |     let _ = opt.ok_or_else(|| ext_arr[0]);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `ok_or` instead: `opt.ok_or(ext_arr[0])`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:43:13
+  --> $DIR/unnecessary_lazy_eval.rs:46:13
    |
 LL |     let _ = Some(10).unwrap_or_else(|| 2);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `unwrap_or` instead: `Some(10).unwrap_or(2)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:44:13
+  --> $DIR/unnecessary_lazy_eval.rs:47:13
    |
 LL |     let _ = Some(10).and_then(|_| ext_opt);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `and` instead: `Some(10).and(ext_opt)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:45:28
+  --> $DIR/unnecessary_lazy_eval.rs:48:28
    |
 LL |     let _: Option<usize> = None.or_else(|| ext_opt);
    |                            ^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `or` instead: `None.or(ext_opt)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:46:13
+  --> $DIR/unnecessary_lazy_eval.rs:49:13
    |
 LL |     let _ = None.get_or_insert_with(|| 2);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `get_or_insert` instead: `None.get_or_insert(2)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:47:35
+  --> $DIR/unnecessary_lazy_eval.rs:50:35
    |
 LL |     let _: Result<usize, usize> = None.ok_or_else(|| 2);
    |                                   ^^^^^^^^^^^^^^^^^^^^^ help: Use `ok_or` instead: `None.ok_or(2)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:48:28
+  --> $DIR/unnecessary_lazy_eval.rs:51:28
    |
 LL |     let _: Option<usize> = None.or_else(|| None);
    |                            ^^^^^^^^^^^^^^^^^^^^^ help: Use `or` instead: `None.or(None)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:51:13
+  --> $DIR/unnecessary_lazy_eval.rs:54:13
    |
 LL |     let _ = deep.0.unwrap_or_else(|| 2);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `unwrap_or` instead: `deep.0.unwrap_or(2)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:52:13
+  --> $DIR/unnecessary_lazy_eval.rs:55:13
    |
 LL |     let _ = deep.0.and_then(|_| ext_opt);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `and` instead: `deep.0.and(ext_opt)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:53:13
+  --> $DIR/unnecessary_lazy_eval.rs:56:13
    |
 LL |     let _ = deep.0.or_else(|| None);
    |             ^^^^^^^^^^^^^^^^^^^^^^^ help: Use `or` instead: `deep.0.or(None)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:54:13
+  --> $DIR/unnecessary_lazy_eval.rs:57:13
    |
 LL |     let _ = deep.0.get_or_insert_with(|| 2);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `get_or_insert` instead: `deep.0.get_or_insert(2)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:55:13
+  --> $DIR/unnecessary_lazy_eval.rs:58:13
    |
 LL |     let _ = deep.0.ok_or_else(|| 2);
    |             ^^^^^^^^^^^^^^^^^^^^^^^ help: Use `ok_or` instead: `deep.0.ok_or(2)`
 
 error: unnecessary closure used to substitute value for `Result::Err`
-  --> $DIR/unnecessary_lazy_eval.rs:78:13
+  --> $DIR/unnecessary_lazy_eval.rs:84:13
    |
 LL |     let _ = res2.unwrap_or_else(|_| 2);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `unwrap_or` instead: `res2.unwrap_or(2)`
 
 error: unnecessary closure used to substitute value for `Result::Err`
-  --> $DIR/unnecessary_lazy_eval.rs:79:13
+  --> $DIR/unnecessary_lazy_eval.rs:85:13
    |
 LL |     let _ = res2.unwrap_or_else(|_| astronomers_pi);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `unwrap_or` instead: `res2.unwrap_or(astronomers_pi)`
 
 error: unnecessary closure used to substitute value for `Result::Err`
-  --> $DIR/unnecessary_lazy_eval.rs:80:13
+  --> $DIR/unnecessary_lazy_eval.rs:86:13
    |
 LL |     let _ = res2.unwrap_or_else(|_| ext_str.some_field);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `unwrap_or` instead: `res2.unwrap_or(ext_str.some_field)`
-- 
cgit 1.4.1-3-g733a5


From a7083eea1c8821ff187218f55a1ac17b0f2c0fcb Mon Sep 17 00:00:00 2001
From: Dániel Buga <bugadani@gmail.com>
Date: Sun, 26 Jul 2020 20:18:12 +0200
Subject: Removed the extra lifetime parameter

---
 clippy_lints/src/methods/mod.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 463ef48f62c..6693c358a02 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -2710,8 +2710,8 @@ fn lint_map_flatten<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, map
 
 /// lint use of `<fn>_else(simple closure)` for `Option`s and `Result`s that can be
 /// replaced with `<fn>(return value of simple closure)`
-fn lint_lazy_eval<'a, 'tcx>(
-    cx: &LateContext<'a, 'tcx>,
+fn lint_lazy_eval<'tcx>(
+    cx: &LateContext<'tcx>,
     expr: &'tcx hir::Expr<'_>,
     args: &'tcx [hir::Expr<'_>],
     allow_variant_calls: bool,
-- 
cgit 1.4.1-3-g733a5


From 94cf90e5a56bbd9adbf6d6181d046ede9b96a7d8 Mon Sep 17 00:00:00 2001
From: Dániel Buga <bugadani@gmail.com>
Date: Sun, 26 Jul 2020 20:52:00 +0200
Subject: Apply suggested change

Co-authored-by: Philipp Krones <hello@philkrones.com>
---
 clippy_lints/src/methods/mod.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 6693c358a02..4578c228107 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -2717,8 +2717,8 @@ fn lint_lazy_eval<'tcx>(
     allow_variant_calls: bool,
     simplify_using: &str,
 ) {
-    let is_option = is_type_diagnostic_item(cx, cx.tables.expr_ty(&args[0]), sym!(option_type));
-    let is_result = is_type_diagnostic_item(cx, cx.tables.expr_ty(&args[0]), sym!(result_type));
+    let is_option = is_type_diagnostic_item(cx, cx.tables().expr_ty(&args[0]), sym!(option_type));
+    let is_result = is_type_diagnostic_item(cx, cx.tables().expr_ty(&args[0]), sym!(result_type));
 
     if !is_option && !is_result {
         return;
-- 
cgit 1.4.1-3-g733a5


From 9c41822d34c69dbfded4d9d8b4b8962564be80f1 Mon Sep 17 00:00:00 2001
From: Dániel Buga <bugadani@gmail.com>
Date: Sun, 26 Jul 2020 21:08:07 +0200
Subject: Apply suggested change

Co-authored-by: Philipp Krones <hello@philkrones.com>
---
 clippy_lints/src/methods/mod.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 4578c228107..70a6b1f5021 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -2717,8 +2717,8 @@ fn lint_lazy_eval<'tcx>(
     allow_variant_calls: bool,
     simplify_using: &str,
 ) {
-    let is_option = is_type_diagnostic_item(cx, cx.tables().expr_ty(&args[0]), sym!(option_type));
-    let is_result = is_type_diagnostic_item(cx, cx.tables().expr_ty(&args[0]), sym!(result_type));
+    let is_option = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&args[0]), sym!(option_type));
+    let is_result = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&args[0]), sym!(result_type));
 
     if !is_option && !is_result {
         return;
-- 
cgit 1.4.1-3-g733a5


From d8f0a14da1b79f409bb9fb4493dc001986a72ae0 Mon Sep 17 00:00:00 2001
From: Hactar <6060305+HactarCE@users.noreply.github.com>
Date: Sun, 16 Aug 2020 14:43:34 -0400
Subject: Fix typo in description of unnecessary_mut_passed

---
 clippy_lints/src/mut_reference.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/mut_reference.rs b/clippy_lints/src/mut_reference.rs
index be3ae7ab380..c506440ed79 100644
--- a/clippy_lints/src/mut_reference.rs
+++ b/clippy_lints/src/mut_reference.rs
@@ -9,8 +9,8 @@ declare_clippy_lint! {
     /// **What it does:** Detects passing a mutable reference to a function that only
     /// requires an immutable reference.
     ///
-    /// **Why is this bad?** The immutable reference rules out all other references
-    /// to the value. Also the code misleads about the intent of the call site.
+    /// **Why is this bad?** The mutable reference rules out all other references to
+    /// the value. Also the code misleads about the intent of the call site.
     ///
     /// **Known problems:** None.
     ///
-- 
cgit 1.4.1-3-g733a5


From d71b418ac511ee604af9320e401a7ff3fd115482 Mon Sep 17 00:00:00 2001
From: Dániel Buga <bugadani@gmail.com>
Date: Sun, 16 Aug 2020 20:47:50 +0200
Subject: Moved to submodule, don't trigger if map_unwrap_or does

---
 clippy_lints/src/methods/mod.rs                   | 136 +++-------------------
 clippy_lints/src/methods/unnecessary_lazy_eval.rs | 113 ++++++++++++++++++
 2 files changed, 132 insertions(+), 117 deletions(-)
 create mode 100644 clippy_lints/src/methods/unnecessary_lazy_eval.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 70a6b1f5021..bfc89a74742 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3,6 +3,7 @@ mod inefficient_to_string;
 mod manual_saturating_arithmetic;
 mod option_map_unwrap_or;
 mod unnecessary_filter_map;
+mod unnecessary_lazy_eval;
 
 use std::borrow::Cow;
 use std::fmt;
@@ -1436,17 +1437,18 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             ["expect", ..] => lint_expect(cx, expr, arg_lists[0]),
             ["unwrap_or", "map"] => option_map_unwrap_or::lint(cx, expr, arg_lists[1], arg_lists[0], method_spans[1]),
             ["unwrap_or_else", "map"] => {
-                lint_lazy_eval(cx, expr, arg_lists[0], true, "unwrap_or");
-                lint_map_unwrap_or_else(cx, expr, arg_lists[1], arg_lists[0]);
+                if !lint_map_unwrap_or_else(cx, expr, arg_lists[1], arg_lists[0]) {
+                    unnecessary_lazy_eval::lint(cx, expr, arg_lists[0], true, "unwrap_or");
+                }
             },
             ["map_or", ..] => lint_map_or_none(cx, expr, arg_lists[0]),
             ["and_then", ..] => {
-                lint_lazy_eval(cx, expr, arg_lists[0], false, "and");
+                unnecessary_lazy_eval::lint(cx, expr, arg_lists[0], false, "and");
                 bind_instead_of_map::OptionAndThenSome::lint(cx, expr, arg_lists[0]);
                 bind_instead_of_map::ResultAndThenOk::lint(cx, expr, arg_lists[0]);
             },
             ["or_else", ..] => {
-                lint_lazy_eval(cx, expr, arg_lists[0], false, "or");
+                unnecessary_lazy_eval::lint(cx, expr, arg_lists[0], false, "or");
                 bind_instead_of_map::ResultOrElseErrInfo::lint(cx, expr, arg_lists[0]);
             },
             ["next", "filter"] => lint_filter_next(cx, expr, arg_lists[1]),
@@ -1490,9 +1492,9 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             ["is_file", ..] => lint_filetype_is_file(cx, expr, arg_lists[0]),
             ["map", "as_ref"] => lint_option_as_ref_deref(cx, expr, arg_lists[1], arg_lists[0], false),
             ["map", "as_mut"] => lint_option_as_ref_deref(cx, expr, arg_lists[1], arg_lists[0], true),
-            ["unwrap_or_else", ..] => lint_lazy_eval(cx, expr, arg_lists[0], true, "unwrap_or"),
-            ["get_or_insert_with", ..] => lint_lazy_eval(cx, expr, arg_lists[0], true, "get_or_insert"),
-            ["ok_or_else", ..] => lint_lazy_eval(cx, expr, arg_lists[0], true, "ok_or"),
+            ["unwrap_or_else", ..] => unnecessary_lazy_eval::lint(cx, expr, arg_lists[0], true, "unwrap_or"),
+            ["get_or_insert_with", ..] => unnecessary_lazy_eval::lint(cx, expr, arg_lists[0], true, "get_or_insert"),
+            ["ok_or_else", ..] => unnecessary_lazy_eval::lint(cx, expr, arg_lists[0], true, "ok_or"),
             _ => {},
         }
 
@@ -2708,119 +2710,13 @@ fn lint_map_flatten<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, map
     }
 }
 
-/// lint use of `<fn>_else(simple closure)` for `Option`s and `Result`s that can be
-/// replaced with `<fn>(return value of simple closure)`
-fn lint_lazy_eval<'tcx>(
-    cx: &LateContext<'tcx>,
-    expr: &'tcx hir::Expr<'_>,
-    args: &'tcx [hir::Expr<'_>],
-    allow_variant_calls: bool,
-    simplify_using: &str,
-) {
-    let is_option = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&args[0]), sym!(option_type));
-    let is_result = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&args[0]), sym!(result_type));
-
-    if !is_option && !is_result {
-        return;
-    }
-
-    // Return true if the expression is an accessor of any of the arguments
-    fn expr_uses_argument(expr: &hir::Expr<'_>, params: &[hir::Param<'_>]) -> bool {
-        params.iter().any(|arg| {
-            if_chain! {
-                if let hir::PatKind::Binding(_, _, ident, _) = arg.pat.kind;
-                if let hir::ExprKind::Path(hir::QPath::Resolved(_, ref path)) = expr.kind;
-                if let [p, ..] = path.segments;
-                then {
-                    ident.name == p.ident.name
-                } else {
-                    false
-                }
-            }
-        })
-    }
-
-    fn match_any_qpath(path: &hir::QPath<'_>, paths: &[&[&str]]) -> bool {
-        paths.iter().any(|candidate| match_qpath(path, candidate))
-    }
-
-    fn can_simplify(expr: &hir::Expr<'_>, params: &[hir::Param<'_>], variant_calls: bool) -> bool {
-        match expr.kind {
-            // Closures returning literals can be unconditionally simplified
-            hir::ExprKind::Lit(_) => true,
-
-            hir::ExprKind::Index(ref object, ref index) => {
-                // arguments are not being indexed into
-                if !expr_uses_argument(object, params) {
-                    // arguments are not used as index
-                    !expr_uses_argument(index, params)
-                } else {
-                    false
-                }
-            },
-
-            // Reading fields can be simplified if the object is not an argument of the closure
-            hir::ExprKind::Field(ref object, _) => !expr_uses_argument(object, params),
-
-            // Paths can be simplified if the root is not the argument, this also covers None
-            hir::ExprKind::Path(_) => !expr_uses_argument(expr, params),
-
-            // Calls to Some, Ok, Err can be considered literals if they don't derive an argument
-            hir::ExprKind::Call(ref func, ref args) => if_chain! {
-                if variant_calls; // Disable lint when rules conflict with bind_instead_of_map
-                if let hir::ExprKind::Path(ref path) = func.kind;
-                if match_any_qpath(path, &[&["Some"], &["Ok"], &["Err"]]);
-                then {
-                    // Recursively check all arguments
-                    args.iter().all(|arg| can_simplify(arg, params, variant_calls))
-                } else {
-                    false
-                }
-            },
-
-            // For anything more complex than the above, a closure is probably the right solution,
-            // or the case is handled by an other lint
-            _ => false,
-        }
-    }
-
-    if let hir::ExprKind::Closure(_, _, eid, _, _) = args[1].kind {
-        let body = cx.tcx.hir().body(eid);
-        let ex = &body.value;
-        let params = &body.params;
-
-        if can_simplify(ex, params, allow_variant_calls) {
-            let msg = if is_option {
-                "unnecessary closure used to substitute value for `Option::None`"
-            } else {
-                "unnecessary closure used to substitute value for `Result::Err`"
-            };
-
-            span_lint_and_sugg(
-                cx,
-                UNNECESSARY_LAZY_EVALUATION,
-                expr.span,
-                msg,
-                &format!("Use `{}` instead", simplify_using),
-                format!(
-                    "{0}.{1}({2})",
-                    snippet(cx, args[0].span, ".."),
-                    simplify_using,
-                    snippet(cx, ex.span, ".."),
-                ),
-                Applicability::MachineApplicable,
-            );
-        }
-    }
-}
-
 /// lint use of `map().unwrap_or_else()` for `Option`s and `Result`s
 fn lint_map_unwrap_or_else<'tcx>(
     cx: &LateContext<'tcx>,
     expr: &'tcx hir::Expr<'_>,
     map_args: &'tcx [hir::Expr<'_>],
     unwrap_args: &'tcx [hir::Expr<'_>],
-) {
+) -> bool {
     // lint if the caller of `map()` is an `Option`
     let is_option = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&map_args[0]), sym!(option_type));
     let is_result = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&map_args[0]), sym!(result_type));
@@ -2832,10 +2728,10 @@ fn lint_map_unwrap_or_else<'tcx>(
         let unwrap_mutated_vars = mutated_variables(&unwrap_args[1], cx);
         if let (Some(map_mutated_vars), Some(unwrap_mutated_vars)) = (map_mutated_vars, unwrap_mutated_vars) {
             if map_mutated_vars.intersection(&unwrap_mutated_vars).next().is_some() {
-                return;
+                return false;
             }
         } else {
-            return;
+            return false;
         }
 
         // lint message
@@ -2865,9 +2761,15 @@ fn lint_map_unwrap_or_else<'tcx>(
                     map_snippet, unwrap_snippet,
                 ),
             );
+            true
         } else if same_span && multiline {
             span_lint(cx, MAP_UNWRAP_OR, expr.span, msg);
-        };
+            true
+        } else {
+            false
+        }
+    } else {
+        false
     }
 }
 
diff --git a/clippy_lints/src/methods/unnecessary_lazy_eval.rs b/clippy_lints/src/methods/unnecessary_lazy_eval.rs
new file mode 100644
index 00000000000..0dbedc4919c
--- /dev/null
+++ b/clippy_lints/src/methods/unnecessary_lazy_eval.rs
@@ -0,0 +1,113 @@
+use crate::utils::{match_qpath, span_lint_and_sugg, snippet, is_type_diagnostic_item};
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir as hir;
+use rustc_lint::LateContext;
+
+use super::UNNECESSARY_LAZY_EVALUATION;
+
+/// lint use of `<fn>_else(simple closure)` for `Option`s and `Result`s that can be
+/// replaced with `<fn>(return value of simple closure)`
+pub(super) fn lint<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx hir::Expr<'_>,
+    args: &'tcx [hir::Expr<'_>],
+    allow_variant_calls: bool,
+    simplify_using: &str,
+) {
+    let is_option = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&args[0]), sym!(option_type));
+    let is_result = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&args[0]), sym!(result_type));
+
+    if !is_option && !is_result {
+        return;
+    }
+
+    // Return true if the expression is an accessor of any of the arguments
+    fn expr_uses_argument(expr: &hir::Expr<'_>, params: &[hir::Param<'_>]) -> bool {
+        params.iter().any(|arg| {
+            if_chain! {
+                if let hir::PatKind::Binding(_, _, ident, _) = arg.pat.kind;
+                if let hir::ExprKind::Path(hir::QPath::Resolved(_, ref path)) = expr.kind;
+                if let [p, ..] = path.segments;
+                then {
+                    ident.name == p.ident.name
+                } else {
+                    false
+                }
+            }
+        })
+    }
+
+    fn match_any_qpath(path: &hir::QPath<'_>, paths: &[&[&str]]) -> bool {
+        paths.iter().any(|candidate| match_qpath(path, candidate))
+    }
+
+    fn can_simplify(expr: &hir::Expr<'_>, params: &[hir::Param<'_>], variant_calls: bool) -> bool {
+        match expr.kind {
+            // Closures returning literals can be unconditionally simplified
+            hir::ExprKind::Lit(_) => true,
+
+            hir::ExprKind::Index(ref object, ref index) => {
+                // arguments are not being indexed into
+                if !expr_uses_argument(object, params) {
+                    // arguments are not used as index
+                    !expr_uses_argument(index, params)
+                } else {
+                    false
+                }
+            },
+
+            // Reading fields can be simplified if the object is not an argument of the closure
+            hir::ExprKind::Field(ref object, _) => !expr_uses_argument(object, params),
+
+            // Paths can be simplified if the root is not the argument, this also covers None
+            hir::ExprKind::Path(_) => !expr_uses_argument(expr, params),
+
+            // Calls to Some, Ok, Err can be considered literals if they don't derive an argument
+            hir::ExprKind::Call(ref func, ref args) => if_chain! {
+                if variant_calls; // Disable lint when rules conflict with bind_instead_of_map
+                if let hir::ExprKind::Path(ref path) = func.kind;
+                if match_any_qpath(path, &[&["Some"], &["Ok"], &["Err"]]);
+                then {
+                    // Recursively check all arguments
+                    args.iter().all(|arg| can_simplify(arg, params, variant_calls))
+                } else {
+                    false
+                }
+            },
+
+            // For anything more complex than the above, a closure is probably the right solution,
+            // or the case is handled by an other lint
+            _ => false,
+        }
+    }
+
+    if let hir::ExprKind::Closure(_, _, eid, _, _) = args[1].kind {
+        let body = cx.tcx.hir().body(eid);
+        let ex = &body.value;
+        let params = &body.params;
+
+        if can_simplify(ex, params, allow_variant_calls) {
+            let msg = if is_option {
+                "unnecessary closure used to substitute value for `Option::None`"
+            } else {
+                "unnecessary closure used to substitute value for `Result::Err`"
+            };
+
+            span_lint_and_sugg(
+                cx,
+                UNNECESSARY_LAZY_EVALUATION,
+                expr.span,
+                msg,
+                &format!("Use `{}` instead", simplify_using),
+                format!(
+                    "{0}.{1}({2})",
+                    snippet(cx, args[0].span, ".."),
+                    simplify_using,
+                    snippet(cx, ex.span, ".."),
+                ),
+                Applicability::MachineApplicable,
+            );
+        }
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 8a14c115369f163e7f96544df48b26376a06a3fb Mon Sep 17 00:00:00 2001
From: Dániel Buga <bugadani@gmail.com>
Date: Sun, 16 Aug 2020 20:50:30 +0200
Subject: Cleanup, explain return value

---
 clippy_lints/src/methods/mod.rs | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index bfc89a74742..c2b2cb98012 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -2711,6 +2711,7 @@ fn lint_map_flatten<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, map
 }
 
 /// lint use of `map().unwrap_or_else()` for `Option`s and `Result`s
+/// Return true if lint triggered
 fn lint_map_unwrap_or_else<'tcx>(
     cx: &LateContext<'tcx>,
     expr: &'tcx hir::Expr<'_>,
@@ -2761,16 +2762,14 @@ fn lint_map_unwrap_or_else<'tcx>(
                     map_snippet, unwrap_snippet,
                 ),
             );
-            true
+            return true;
         } else if same_span && multiline {
             span_lint(cx, MAP_UNWRAP_OR, expr.span, msg);
-            true
-        } else {
-            false
+            return true;
         }
-    } else {
-        false
     }
+
+    false
 }
 
 /// lint use of `_.map_or(None, _)` for `Option`s and `Result`s
-- 
cgit 1.4.1-3-g733a5


From 3b52d7f780f2023d6596fe73c0a71f663b26bc33 Mon Sep 17 00:00:00 2001
From: Dániel Buga <bugadani@gmail.com>
Date: Sun, 16 Aug 2020 20:51:16 +0200
Subject: run cargo dev fmt

---
 clippy_lints/src/methods/unnecessary_lazy_eval.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/unnecessary_lazy_eval.rs b/clippy_lints/src/methods/unnecessary_lazy_eval.rs
index 0dbedc4919c..b44089f7bfc 100644
--- a/clippy_lints/src/methods/unnecessary_lazy_eval.rs
+++ b/clippy_lints/src/methods/unnecessary_lazy_eval.rs
@@ -1,4 +1,4 @@
-use crate::utils::{match_qpath, span_lint_and_sugg, snippet, is_type_diagnostic_item};
+use crate::utils::{is_type_diagnostic_item, match_qpath, snippet, span_lint_and_sugg};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
-- 
cgit 1.4.1-3-g733a5


From b7ee8685ac83e0f3f32ac5ab5d597d5451d07057 Mon Sep 17 00:00:00 2001
From: Dániel Buga <bugadani@gmail.com>
Date: Sun, 16 Aug 2020 21:04:02 +0200
Subject: Fix dogfooding test errors

---
 clippy_lints/src/methods/unnecessary_lazy_eval.rs | 172 +++++++++++-----------
 1 file changed, 85 insertions(+), 87 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/unnecessary_lazy_eval.rs b/clippy_lints/src/methods/unnecessary_lazy_eval.rs
index b44089f7bfc..a3e7e9971f8 100644
--- a/clippy_lints/src/methods/unnecessary_lazy_eval.rs
+++ b/clippy_lints/src/methods/unnecessary_lazy_eval.rs
@@ -6,6 +6,66 @@ use rustc_lint::LateContext;
 
 use super::UNNECESSARY_LAZY_EVALUATION;
 
+// Return true if the expression is an accessor of any of the arguments
+fn expr_uses_argument(expr: &hir::Expr<'_>, params: &[hir::Param<'_>]) -> bool {
+    params.iter().any(|arg| {
+        if_chain! {
+            if let hir::PatKind::Binding(_, _, ident, _) = arg.pat.kind;
+            if let hir::ExprKind::Path(hir::QPath::Resolved(_, ref path)) = expr.kind;
+            if let [p, ..] = path.segments;
+            then {
+                ident.name == p.ident.name
+            } else {
+                false
+            }
+        }
+    })
+}
+
+fn match_any_qpath(path: &hir::QPath<'_>, paths: &[&[&str]]) -> bool {
+    paths.iter().any(|candidate| match_qpath(path, candidate))
+}
+
+fn can_simplify(expr: &hir::Expr<'_>, params: &[hir::Param<'_>], variant_calls: bool) -> bool {
+    match expr.kind {
+        // Closures returning literals can be unconditionally simplified
+        hir::ExprKind::Lit(_) => true,
+
+        hir::ExprKind::Index(ref object, ref index) => {
+            // arguments are not being indexed into
+            if expr_uses_argument(object, params) {
+                false
+            } else {
+                // arguments are not used as index
+                !expr_uses_argument(index, params)
+            }
+        },
+
+        // Reading fields can be simplified if the object is not an argument of the closure
+        hir::ExprKind::Field(ref object, _) => !expr_uses_argument(object, params),
+
+        // Paths can be simplified if the root is not the argument, this also covers None
+        hir::ExprKind::Path(_) => !expr_uses_argument(expr, params),
+
+        // Calls to Some, Ok, Err can be considered literals if they don't derive an argument
+        hir::ExprKind::Call(ref func, ref args) => if_chain! {
+            if variant_calls; // Disable lint when rules conflict with bind_instead_of_map
+            if let hir::ExprKind::Path(ref path) = func.kind;
+            if match_any_qpath(path, &[&["Some"], &["Ok"], &["Err"]]);
+            then {
+                // Recursively check all arguments
+                args.iter().all(|arg| can_simplify(arg, params, variant_calls))
+            } else {
+                false
+            }
+        },
+
+        // For anything more complex than the above, a closure is probably the right solution,
+        // or the case is handled by an other lint
+        _ => false,
+    }
+}
+
 /// lint use of `<fn>_else(simple closure)` for `Option`s and `Result`s that can be
 /// replaced with `<fn>(return value of simple closure)`
 pub(super) fn lint<'tcx>(
@@ -18,96 +78,34 @@ pub(super) fn lint<'tcx>(
     let is_option = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&args[0]), sym!(option_type));
     let is_result = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&args[0]), sym!(result_type));
 
-    if !is_option && !is_result {
-        return;
-    }
-
-    // Return true if the expression is an accessor of any of the arguments
-    fn expr_uses_argument(expr: &hir::Expr<'_>, params: &[hir::Param<'_>]) -> bool {
-        params.iter().any(|arg| {
-            if_chain! {
-                if let hir::PatKind::Binding(_, _, ident, _) = arg.pat.kind;
-                if let hir::ExprKind::Path(hir::QPath::Resolved(_, ref path)) = expr.kind;
-                if let [p, ..] = path.segments;
-                then {
-                    ident.name == p.ident.name
-                } else {
-                    false
-                }
-            }
-        })
-    }
+    if is_option || is_result {
+        if let hir::ExprKind::Closure(_, _, eid, _, _) = args[1].kind {
+            let body = cx.tcx.hir().body(eid);
+            let ex = &body.value;
+            let params = &body.params;
 
-    fn match_any_qpath(path: &hir::QPath<'_>, paths: &[&[&str]]) -> bool {
-        paths.iter().any(|candidate| match_qpath(path, candidate))
-    }
-
-    fn can_simplify(expr: &hir::Expr<'_>, params: &[hir::Param<'_>], variant_calls: bool) -> bool {
-        match expr.kind {
-            // Closures returning literals can be unconditionally simplified
-            hir::ExprKind::Lit(_) => true,
-
-            hir::ExprKind::Index(ref object, ref index) => {
-                // arguments are not being indexed into
-                if !expr_uses_argument(object, params) {
-                    // arguments are not used as index
-                    !expr_uses_argument(index, params)
+            if can_simplify(ex, params, allow_variant_calls) {
+                let msg = if is_option {
+                    "unnecessary closure used to substitute value for `Option::None`"
                 } else {
-                    false
-                }
-            },
-
-            // Reading fields can be simplified if the object is not an argument of the closure
-            hir::ExprKind::Field(ref object, _) => !expr_uses_argument(object, params),
-
-            // Paths can be simplified if the root is not the argument, this also covers None
-            hir::ExprKind::Path(_) => !expr_uses_argument(expr, params),
+                    "unnecessary closure used to substitute value for `Result::Err`"
+                };
 
-            // Calls to Some, Ok, Err can be considered literals if they don't derive an argument
-            hir::ExprKind::Call(ref func, ref args) => if_chain! {
-                if variant_calls; // Disable lint when rules conflict with bind_instead_of_map
-                if let hir::ExprKind::Path(ref path) = func.kind;
-                if match_any_qpath(path, &[&["Some"], &["Ok"], &["Err"]]);
-                then {
-                    // Recursively check all arguments
-                    args.iter().all(|arg| can_simplify(arg, params, variant_calls))
-                } else {
-                    false
-                }
-            },
-
-            // For anything more complex than the above, a closure is probably the right solution,
-            // or the case is handled by an other lint
-            _ => false,
-        }
-    }
-
-    if let hir::ExprKind::Closure(_, _, eid, _, _) = args[1].kind {
-        let body = cx.tcx.hir().body(eid);
-        let ex = &body.value;
-        let params = &body.params;
-
-        if can_simplify(ex, params, allow_variant_calls) {
-            let msg = if is_option {
-                "unnecessary closure used to substitute value for `Option::None`"
-            } else {
-                "unnecessary closure used to substitute value for `Result::Err`"
-            };
-
-            span_lint_and_sugg(
-                cx,
-                UNNECESSARY_LAZY_EVALUATION,
-                expr.span,
-                msg,
-                &format!("Use `{}` instead", simplify_using),
-                format!(
-                    "{0}.{1}({2})",
-                    snippet(cx, args[0].span, ".."),
-                    simplify_using,
-                    snippet(cx, ex.span, ".."),
-                ),
-                Applicability::MachineApplicable,
-            );
+                span_lint_and_sugg(
+                    cx,
+                    UNNECESSARY_LAZY_EVALUATION,
+                    expr.span,
+                    msg,
+                    &format!("Use `{}` instead", simplify_using),
+                    format!(
+                        "{0}.{1}({2})",
+                        snippet(cx, args[0].span, ".."),
+                        simplify_using,
+                        snippet(cx, ex.span, ".."),
+                    ),
+                    Applicability::MachineApplicable,
+                );
+            }
         }
     }
 }
-- 
cgit 1.4.1-3-g733a5


From fc1e07e0c1803edb3ade2db2f46034cf227642c9 Mon Sep 17 00:00:00 2001
From: Dániel Buga <bugadani@gmail.com>
Date: Sun, 16 Aug 2020 22:16:39 +0200
Subject: Rename lint to use plural form

---
 CHANGELOG.md                                      | 2 +-
 clippy_lints/src/lib.rs                           | 6 +++---
 clippy_lints/src/methods/mod.rs                   | 4 ++--
 clippy_lints/src/methods/unnecessary_lazy_eval.rs | 4 ++--
 src/lintlist/mod.rs                               | 2 +-
 tests/ui/unnecessary_lazy_eval.fixed              | 2 +-
 tests/ui/unnecessary_lazy_eval.rs                 | 2 +-
 tests/ui/unnecessary_lazy_eval.stderr             | 2 +-
 8 files changed, 12 insertions(+), 12 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 675dfd420a7..f662de122f9 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1754,7 +1754,7 @@ Released 2018-09-13
 [`unnecessary_cast`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_cast
 [`unnecessary_filter_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_filter_map
 [`unnecessary_fold`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_fold
-[`unnecessary_lazy_evaluation`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_lazy_evaluation
+[`unnecessary_lazy_evaluations`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_lazy_evaluations
 [`unnecessary_mut_passed`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_mut_passed
 [`unnecessary_operation`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_operation
 [`unnecessary_sort_by`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_sort_by
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index ae7045884f7..17501e8e6da 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -685,7 +685,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &methods::UNINIT_ASSUMED_INIT,
         &methods::UNNECESSARY_FILTER_MAP,
         &methods::UNNECESSARY_FOLD,
-        &methods::UNNECESSARY_LAZY_EVALUATION,
+        &methods::UNNECESSARY_LAZY_EVALUATIONS,
         &methods::UNWRAP_USED,
         &methods::USELESS_ASREF,
         &methods::WRONG_PUB_SELF_CONVENTION,
@@ -1361,7 +1361,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&methods::UNINIT_ASSUMED_INIT),
         LintId::of(&methods::UNNECESSARY_FILTER_MAP),
         LintId::of(&methods::UNNECESSARY_FOLD),
-        LintId::of(&methods::UNNECESSARY_LAZY_EVALUATION),
+        LintId::of(&methods::UNNECESSARY_LAZY_EVALUATIONS),
         LintId::of(&methods::USELESS_ASREF),
         LintId::of(&methods::WRONG_SELF_CONVENTION),
         LintId::of(&methods::ZST_OFFSET),
@@ -1542,7 +1542,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&methods::SINGLE_CHAR_PUSH_STR),
         LintId::of(&methods::STRING_EXTEND_CHARS),
         LintId::of(&methods::UNNECESSARY_FOLD),
-        LintId::of(&methods::UNNECESSARY_LAZY_EVALUATION),
+        LintId::of(&methods::UNNECESSARY_LAZY_EVALUATIONS),
         LintId::of(&methods::WRONG_SELF_CONVENTION),
         LintId::of(&misc::TOPLEVEL_REF_ARG),
         LintId::of(&misc::ZERO_PTR),
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index c2b2cb98012..0f50a4c813a 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1361,7 +1361,7 @@ declare_clippy_lint! {
     ///
     /// opt.unwrap_or(42);
     /// ```
-    pub UNNECESSARY_LAZY_EVALUATION,
+    pub UNNECESSARY_LAZY_EVALUATIONS,
     style,
     "using unnecessary lazy evaluation, which can be replaced with simpler eager evaluation"
 }
@@ -1415,7 +1415,7 @@ declare_lint_pass!(Methods => [
     ZST_OFFSET,
     FILETYPE_IS_FILE,
     OPTION_AS_REF_DEREF,
-    UNNECESSARY_LAZY_EVALUATION,
+    UNNECESSARY_LAZY_EVALUATIONS,
 ]);
 
 impl<'tcx> LateLintPass<'tcx> for Methods {
diff --git a/clippy_lints/src/methods/unnecessary_lazy_eval.rs b/clippy_lints/src/methods/unnecessary_lazy_eval.rs
index a3e7e9971f8..31517659c34 100644
--- a/clippy_lints/src/methods/unnecessary_lazy_eval.rs
+++ b/clippy_lints/src/methods/unnecessary_lazy_eval.rs
@@ -4,7 +4,7 @@ use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
 
-use super::UNNECESSARY_LAZY_EVALUATION;
+use super::UNNECESSARY_LAZY_EVALUATIONS;
 
 // Return true if the expression is an accessor of any of the arguments
 fn expr_uses_argument(expr: &hir::Expr<'_>, params: &[hir::Param<'_>]) -> bool {
@@ -93,7 +93,7 @@ pub(super) fn lint<'tcx>(
 
                 span_lint_and_sugg(
                     cx,
-                    UNNECESSARY_LAZY_EVALUATION,
+                    UNNECESSARY_LAZY_EVALUATIONS,
                     expr.span,
                     msg,
                     &format!("Use `{}` instead", simplify_using),
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index 2a66d3495ed..3229c8da507 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -2384,7 +2384,7 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
         module: "methods",
     },
     Lint {
-        name: "unnecessary_lazy_evaluation",
+        name: "unnecessary_lazy_evaluations",
         group: "style",
         desc: "using unnecessary lazy evaluation, which can be replaced with simpler eager evaluation",
         deprecation: None,
diff --git a/tests/ui/unnecessary_lazy_eval.fixed b/tests/ui/unnecessary_lazy_eval.fixed
index 7f9d90a8569..fa66e68794e 100644
--- a/tests/ui/unnecessary_lazy_eval.fixed
+++ b/tests/ui/unnecessary_lazy_eval.fixed
@@ -1,5 +1,5 @@
 // run-rustfix
-#![warn(clippy::unnecessary_lazy_evaluation)]
+#![warn(clippy::unnecessary_lazy_evaluations)]
 #![allow(clippy::redundant_closure)]
 #![allow(clippy::bind_instead_of_map)]
 
diff --git a/tests/ui/unnecessary_lazy_eval.rs b/tests/ui/unnecessary_lazy_eval.rs
index fd8f8ed0329..04f47d1aa29 100644
--- a/tests/ui/unnecessary_lazy_eval.rs
+++ b/tests/ui/unnecessary_lazy_eval.rs
@@ -1,5 +1,5 @@
 // run-rustfix
-#![warn(clippy::unnecessary_lazy_evaluation)]
+#![warn(clippy::unnecessary_lazy_evaluations)]
 #![allow(clippy::redundant_closure)]
 #![allow(clippy::bind_instead_of_map)]
 
diff --git a/tests/ui/unnecessary_lazy_eval.stderr b/tests/ui/unnecessary_lazy_eval.stderr
index e86b7ed6253..5c1b2eb1f14 100644
--- a/tests/ui/unnecessary_lazy_eval.stderr
+++ b/tests/ui/unnecessary_lazy_eval.stderr
@@ -4,7 +4,7 @@ error: unnecessary closure used to substitute value for `Option::None`
 LL |     let _ = opt.unwrap_or_else(|| 2);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `unwrap_or` instead: `opt.unwrap_or(2)`
    |
-   = note: `-D clippy::unnecessary-lazy-evaluation` implied by `-D warnings`
+   = note: `-D clippy::unnecessary-lazy-evaluations` implied by `-D warnings`
 
 error: unnecessary closure used to substitute value for `Option::None`
   --> $DIR/unnecessary_lazy_eval.rs:35:13
-- 
cgit 1.4.1-3-g733a5


From 6afa4ef60f973218c901d0f802d586fe6c43017d Mon Sep 17 00:00:00 2001
From: Tomasz Miąsko <tomasz.miasko@gmail.com>
Date: Sun, 16 Aug 2020 00:00:00 +0000
Subject: Introduce function for comparing expression values

Introduce `eq_expr_value(cx, a, b)` as a shortcut for
`SpanlessEq::new(cx).ignore_fn().eq_expr(cx, a, b)`.

No functional changes intended.
---
 clippy_lints/src/assign_ops.rs                | 14 ++++++--------
 clippy_lints/src/booleans.rs                  | 10 +++++-----
 clippy_lints/src/copies.rs                    |  7 +++----
 clippy_lints/src/double_comparison.rs         |  5 ++---
 clippy_lints/src/eq_op.rs                     |  4 ++--
 clippy_lints/src/floating_point_arithmetic.rs | 24 ++++++++++--------------
 clippy_lints/src/question_mark.rs             |  6 +++---
 clippy_lints/src/swap.rs                      | 14 +++++++-------
 clippy_lints/src/utils/hir_utils.rs           |  5 +++++
 clippy_lints/src/utils/internal_lints.rs      |  3 +--
 clippy_lints/src/utils/mod.rs                 |  2 +-
 11 files changed, 45 insertions(+), 49 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/assign_ops.rs b/clippy_lints/src/assign_ops.rs
index dab1e96e282..b3185b88840 100644
--- a/clippy_lints/src/assign_ops.rs
+++ b/clippy_lints/src/assign_ops.rs
@@ -1,5 +1,5 @@
 use crate::utils::{
-    get_trait_def_id, implements_trait, snippet_opt, span_lint_and_then, trait_ref_of_method, SpanlessEq,
+    eq_expr_value, get_trait_def_id, implements_trait, snippet_opt, span_lint_and_then, trait_ref_of_method,
 };
 use crate::utils::{higher, sugg};
 use if_chain::if_chain;
@@ -70,11 +70,11 @@ impl<'tcx> LateLintPass<'tcx> for AssignOps {
                         return;
                     }
                     // lhs op= l op r
-                    if SpanlessEq::new(cx).ignore_fn().eq_expr(lhs, l) {
+                    if eq_expr_value(cx, lhs, l) {
                         lint_misrefactored_assign_op(cx, expr, *op, rhs, lhs, r);
                     }
                     // lhs op= l commutative_op r
-                    if is_commutative(op.node) && SpanlessEq::new(cx).ignore_fn().eq_expr(lhs, r) {
+                    if is_commutative(op.node) && eq_expr_value(cx, lhs, r) {
                         lint_misrefactored_assign_op(cx, expr, *op, rhs, lhs, l);
                     }
                 }
@@ -161,14 +161,12 @@ impl<'tcx> LateLintPass<'tcx> for AssignOps {
 
                     if visitor.counter == 1 {
                         // a = a op b
-                        if SpanlessEq::new(cx).ignore_fn().eq_expr(assignee, l) {
+                        if eq_expr_value(cx, assignee, l) {
                             lint(assignee, r);
                         }
                         // a = b commutative_op a
                         // Limited to primitive type as these ops are know to be commutative
-                        if SpanlessEq::new(cx).ignore_fn().eq_expr(assignee, r)
-                            && cx.typeck_results().expr_ty(assignee).is_primitive_ty()
-                        {
+                        if eq_expr_value(cx, assignee, r) && cx.typeck_results().expr_ty(assignee).is_primitive_ty() {
                             match op.node {
                                 hir::BinOpKind::Add
                                 | hir::BinOpKind::Mul
@@ -253,7 +251,7 @@ impl<'a, 'tcx> Visitor<'tcx> for ExprVisitor<'a, 'tcx> {
     type Map = Map<'tcx>;
 
     fn visit_expr(&mut self, expr: &'tcx hir::Expr<'_>) {
-        if SpanlessEq::new(self.cx).ignore_fn().eq_expr(self.assignee, expr) {
+        if eq_expr_value(self.cx, self.assignee, expr) {
             self.counter += 1;
         }
 
diff --git a/clippy_lints/src/booleans.rs b/clippy_lints/src/booleans.rs
index 18529f2113e..280a2c7fe67 100644
--- a/clippy_lints/src/booleans.rs
+++ b/clippy_lints/src/booleans.rs
@@ -1,6 +1,6 @@
 use crate::utils::{
-    get_trait_def_id, implements_trait, in_macro, is_type_diagnostic_item, paths, snippet_opt, span_lint_and_sugg,
-    span_lint_and_then, SpanlessEq,
+    eq_expr_value, get_trait_def_id, implements_trait, in_macro, is_type_diagnostic_item, paths, snippet_opt,
+    span_lint_and_sugg, span_lint_and_then,
 };
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
@@ -128,7 +128,7 @@ impl<'a, 'tcx, 'v> Hir2Qmm<'a, 'tcx, 'v> {
             }
         }
         for (n, expr) in self.terminals.iter().enumerate() {
-            if SpanlessEq::new(self.cx).ignore_fn().eq_expr(e, expr) {
+            if eq_expr_value(self.cx, e, expr) {
                 #[allow(clippy::cast_possible_truncation)]
                 return Ok(Bool::Term(n as u8));
             }
@@ -138,8 +138,8 @@ impl<'a, 'tcx, 'v> Hir2Qmm<'a, 'tcx, 'v> {
                 if implements_ord(self.cx, e_lhs);
                 if let ExprKind::Binary(expr_binop, expr_lhs, expr_rhs) = &expr.kind;
                 if negate(e_binop.node) == Some(expr_binop.node);
-                if SpanlessEq::new(self.cx).ignore_fn().eq_expr(e_lhs, expr_lhs);
-                if SpanlessEq::new(self.cx).ignore_fn().eq_expr(e_rhs, expr_rhs);
+                if eq_expr_value(self.cx, e_lhs, expr_lhs);
+                if eq_expr_value(self.cx, e_rhs, expr_rhs);
                 then {
                     #[allow(clippy::cast_possible_truncation)]
                     return Ok(Bool::Not(Box::new(Bool::Term(n as u8))));
diff --git a/clippy_lints/src/copies.rs b/clippy_lints/src/copies.rs
index 1f8bff8d71e..10a64769585 100644
--- a/clippy_lints/src/copies.rs
+++ b/clippy_lints/src/copies.rs
@@ -1,5 +1,5 @@
+use crate::utils::{eq_expr_value, SpanlessEq, SpanlessHash};
 use crate::utils::{get_parent_expr, higher, if_sequence, snippet, span_lint_and_note, span_lint_and_then};
-use crate::utils::{SpanlessEq, SpanlessHash};
 use rustc_data_structures::fx::FxHashMap;
 use rustc_hir::{Arm, Block, Expr, ExprKind, MatchSource, Pat, PatKind};
 use rustc_lint::{LateContext, LateLintPass};
@@ -197,8 +197,7 @@ fn lint_same_cond(cx: &LateContext<'_>, conds: &[&Expr<'_>]) {
         h.finish()
     };
 
-    let eq: &dyn Fn(&&Expr<'_>, &&Expr<'_>) -> bool =
-        &|&lhs, &rhs| -> bool { SpanlessEq::new(cx).ignore_fn().eq_expr(lhs, rhs) };
+    let eq: &dyn Fn(&&Expr<'_>, &&Expr<'_>) -> bool = &|&lhs, &rhs| -> bool { eq_expr_value(cx, lhs, rhs) };
 
     for (i, j) in search_same(conds, hash, eq) {
         span_lint_and_note(
@@ -222,7 +221,7 @@ fn lint_same_fns_in_if_cond(cx: &LateContext<'_>, conds: &[&Expr<'_>]) {
 
     let eq: &dyn Fn(&&Expr<'_>, &&Expr<'_>) -> bool = &|&lhs, &rhs| -> bool {
         // Do not spawn warning if `IFS_SAME_COND` already produced it.
-        if SpanlessEq::new(cx).ignore_fn().eq_expr(lhs, rhs) {
+        if eq_expr_value(cx, lhs, rhs) {
             return false;
         }
         SpanlessEq::new(cx).eq_expr(lhs, rhs)
diff --git a/clippy_lints/src/double_comparison.rs b/clippy_lints/src/double_comparison.rs
index bae7c4647d4..19f56195ec1 100644
--- a/clippy_lints/src/double_comparison.rs
+++ b/clippy_lints/src/double_comparison.rs
@@ -6,7 +6,7 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
 
-use crate::utils::{snippet_with_applicability, span_lint_and_sugg, SpanlessEq};
+use crate::utils::{eq_expr_value, snippet_with_applicability, span_lint_and_sugg};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for double comparisons that could be simplified to a single expression.
@@ -46,8 +46,7 @@ impl<'tcx> DoubleComparisons {
             },
             _ => return,
         };
-        let mut spanless_eq = SpanlessEq::new(cx).ignore_fn();
-        if !(spanless_eq.eq_expr(&llhs, &rlhs) && spanless_eq.eq_expr(&lrhs, &rrhs)) {
+        if !(eq_expr_value(cx, &llhs, &rlhs) && eq_expr_value(cx, &lrhs, &rrhs)) {
             return;
         }
         macro_rules! lint_double_comparison {
diff --git a/clippy_lints/src/eq_op.rs b/clippy_lints/src/eq_op.rs
index 140cd21c34e..e16ec783fab 100644
--- a/clippy_lints/src/eq_op.rs
+++ b/clippy_lints/src/eq_op.rs
@@ -1,5 +1,5 @@
 use crate::utils::{
-    implements_trait, in_macro, is_copy, multispan_sugg, snippet, span_lint, span_lint_and_then, SpanlessEq,
+    eq_expr_value, implements_trait, in_macro, is_copy, multispan_sugg, snippet, span_lint, span_lint_and_then,
 };
 use rustc_errors::Applicability;
 use rustc_hir::{BinOp, BinOpKind, BorrowKind, Expr, ExprKind};
@@ -69,7 +69,7 @@ impl<'tcx> LateLintPass<'tcx> for EqOp {
             if macro_with_not_op(&left.kind) || macro_with_not_op(&right.kind) {
                 return;
             }
-            if is_valid_operator(op) && SpanlessEq::new(cx).ignore_fn().eq_expr(left, right) {
+            if is_valid_operator(op) && eq_expr_value(cx, left, right) {
                 span_lint(
                     cx,
                     EQ_OP,
diff --git a/clippy_lints/src/floating_point_arithmetic.rs b/clippy_lints/src/floating_point_arithmetic.rs
index 93f6ec92ec7..1b02cee126d 100644
--- a/clippy_lints/src/floating_point_arithmetic.rs
+++ b/clippy_lints/src/floating_point_arithmetic.rs
@@ -2,7 +2,7 @@ use crate::consts::{
     constant, constant_simple, Constant,
     Constant::{Int, F32, F64},
 };
-use crate::utils::{get_parent_expr, higher, numeric_literal, span_lint_and_sugg, sugg, SpanlessEq};
+use crate::utils::{eq_expr_value, get_parent_expr, higher, numeric_literal, span_lint_and_sugg, sugg};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind, PathSegment, UnOp};
@@ -363,8 +363,8 @@ fn detect_hypot(cx: &LateContext<'_>, args: &[Expr<'_>]) -> Option<String> {
         if_chain! {
             if let ExprKind::Binary(Spanned { node: BinOpKind::Mul, .. }, ref lmul_lhs, ref lmul_rhs) = add_lhs.kind;
             if let ExprKind::Binary(Spanned { node: BinOpKind::Mul, .. }, ref rmul_lhs, ref rmul_rhs) = add_rhs.kind;
-            if are_exprs_equal(cx, lmul_lhs, lmul_rhs);
-            if are_exprs_equal(cx, rmul_lhs, rmul_rhs);
+            if eq_expr_value(cx, lmul_lhs, lmul_rhs);
+            if eq_expr_value(cx, rmul_lhs, rmul_rhs);
             then {
                 return Some(format!("{}.hypot({})", Sugg::hir(cx, &lmul_lhs, ".."), Sugg::hir(cx, &rmul_lhs, "..")));
             }
@@ -502,8 +502,8 @@ fn check_mul_add(cx: &LateContext<'_>, expr: &Expr<'_>) {
 fn is_testing_positive(cx: &LateContext<'_>, expr: &Expr<'_>, test: &Expr<'_>) -> bool {
     if let ExprKind::Binary(Spanned { node: op, .. }, left, right) = expr.kind {
         match op {
-            BinOpKind::Gt | BinOpKind::Ge => is_zero(cx, right) && are_exprs_equal(cx, left, test),
-            BinOpKind::Lt | BinOpKind::Le => is_zero(cx, left) && are_exprs_equal(cx, right, test),
+            BinOpKind::Gt | BinOpKind::Ge => is_zero(cx, right) && eq_expr_value(cx, left, test),
+            BinOpKind::Lt | BinOpKind::Le => is_zero(cx, left) && eq_expr_value(cx, right, test),
             _ => false,
         }
     } else {
@@ -515,8 +515,8 @@ fn is_testing_positive(cx: &LateContext<'_>, expr: &Expr<'_>, test: &Expr<'_>) -
 fn is_testing_negative(cx: &LateContext<'_>, expr: &Expr<'_>, test: &Expr<'_>) -> bool {
     if let ExprKind::Binary(Spanned { node: op, .. }, left, right) = expr.kind {
         match op {
-            BinOpKind::Gt | BinOpKind::Ge => is_zero(cx, left) && are_exprs_equal(cx, right, test),
-            BinOpKind::Lt | BinOpKind::Le => is_zero(cx, right) && are_exprs_equal(cx, left, test),
+            BinOpKind::Gt | BinOpKind::Ge => is_zero(cx, left) && eq_expr_value(cx, right, test),
+            BinOpKind::Lt | BinOpKind::Le => is_zero(cx, right) && eq_expr_value(cx, left, test),
             _ => false,
         }
     } else {
@@ -524,10 +524,6 @@ fn is_testing_negative(cx: &LateContext<'_>, expr: &Expr<'_>, test: &Expr<'_>) -
     }
 }
 
-fn are_exprs_equal(cx: &LateContext<'_>, expr1: &Expr<'_>, expr2: &Expr<'_>) -> bool {
-    SpanlessEq::new(cx).ignore_fn().eq_expr(expr1, expr2)
-}
-
 /// Returns true iff expr is some zero literal
 fn is_zero(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
     match constant_simple(cx, cx.typeck_results(), expr) {
@@ -546,12 +542,12 @@ fn is_zero(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
 /// returns None.
 fn are_negated<'a>(cx: &LateContext<'_>, expr1: &'a Expr<'a>, expr2: &'a Expr<'a>) -> Option<(bool, &'a Expr<'a>)> {
     if let ExprKind::Unary(UnOp::UnNeg, expr1_negated) = &expr1.kind {
-        if are_exprs_equal(cx, expr1_negated, expr2) {
+        if eq_expr_value(cx, expr1_negated, expr2) {
             return Some((false, expr2));
         }
     }
     if let ExprKind::Unary(UnOp::UnNeg, expr2_negated) = &expr2.kind {
-        if are_exprs_equal(cx, expr1, expr2_negated) {
+        if eq_expr_value(cx, expr1, expr2_negated) {
             return Some((true, expr1));
         }
     }
@@ -614,7 +610,7 @@ fn are_same_base_logs(cx: &LateContext<'_>, expr_a: &Expr<'_>, expr_b: &Expr<'_>
                 args_a.len() == args_b.len() &&
                 (
                     ["ln", "log2", "log10"].contains(&&*method_name_a.as_str()) ||
-                    method_name_a.as_str() == "log" && args_a.len() == 2 && are_exprs_equal(cx, &args_a[1], &args_b[1])
+                    method_name_a.as_str() == "log" && args_a.len() == 2 && eq_expr_value(cx, &args_a[1], &args_b[1])
                 );
         }
     }
diff --git a/clippy_lints/src/question_mark.rs b/clippy_lints/src/question_mark.rs
index fb12c565afd..dbc676ae224 100644
--- a/clippy_lints/src/question_mark.rs
+++ b/clippy_lints/src/question_mark.rs
@@ -7,8 +7,8 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 use crate::utils::sugg::Sugg;
 use crate::utils::{
-    higher, is_type_diagnostic_item, match_def_path, match_qpath, paths, snippet_with_applicability,
-    span_lint_and_sugg, SpanlessEq,
+    eq_expr_value, higher, is_type_diagnostic_item, match_def_path, match_qpath, paths, snippet_with_applicability,
+    span_lint_and_sugg,
 };
 
 declare_clippy_lint! {
@@ -65,7 +65,7 @@ impl QuestionMark {
                         if let ExprKind::Block(block, None) = &else_.kind;
                         if block.stmts.is_empty();
                         if let Some(block_expr) = &block.expr;
-                        if SpanlessEq::new(cx).ignore_fn().eq_expr(subject, block_expr);
+                        if eq_expr_value(cx, subject, block_expr);
                         then {
                             replacement = Some(format!("Some({}?)", receiver_str));
                         }
diff --git a/clippy_lints/src/swap.rs b/clippy_lints/src/swap.rs
index 754f87e6b55..cc39f060fc7 100644
--- a/clippy_lints/src/swap.rs
+++ b/clippy_lints/src/swap.rs
@@ -1,7 +1,7 @@
 use crate::utils::sugg::Sugg;
 use crate::utils::{
-    differing_macro_contexts, is_type_diagnostic_item, snippet_with_applicability, span_lint_and_then, walk_ptrs_ty,
-    SpanlessEq,
+    differing_macro_contexts, eq_expr_value, is_type_diagnostic_item, snippet_with_applicability, span_lint_and_then,
+    walk_ptrs_ty,
 };
 use if_chain::if_chain;
 use rustc_errors::Applicability;
@@ -92,8 +92,8 @@ fn check_manual_swap(cx: &LateContext<'_>, block: &Block<'_>) {
             if rhs2.segments.len() == 1;
 
             if ident.as_str() == rhs2.segments[0].ident.as_str();
-            if SpanlessEq::new(cx).ignore_fn().eq_expr(tmp_init, lhs1);
-            if SpanlessEq::new(cx).ignore_fn().eq_expr(rhs1, lhs2);
+            if eq_expr_value(cx, tmp_init, lhs1);
+            if eq_expr_value(cx, rhs1, lhs2);
             then {
                 if let ExprKind::Field(ref lhs1, _) = lhs1.kind {
                     if let ExprKind::Field(ref lhs2, _) = lhs2.kind {
@@ -193,7 +193,7 @@ enum Slice<'a> {
 fn check_for_slice<'a>(cx: &LateContext<'_>, lhs1: &'a Expr<'_>, lhs2: &'a Expr<'_>) -> Slice<'a> {
     if let ExprKind::Index(ref lhs1, ref idx1) = lhs1.kind {
         if let ExprKind::Index(ref lhs2, ref idx2) = lhs2.kind {
-            if SpanlessEq::new(cx).ignore_fn().eq_expr(lhs1, lhs2) {
+            if eq_expr_value(cx, lhs1, lhs2) {
                 let ty = walk_ptrs_ty(cx.typeck_results().expr_ty(lhs1));
 
                 if matches!(ty.kind, ty::Slice(_))
@@ -221,8 +221,8 @@ fn check_suspicious_swap(cx: &LateContext<'_>, block: &Block<'_>) {
             if !differing_macro_contexts(first.span, second.span);
             if let ExprKind::Assign(ref lhs0, ref rhs0, _) = first.kind;
             if let ExprKind::Assign(ref lhs1, ref rhs1, _) = second.kind;
-            if SpanlessEq::new(cx).ignore_fn().eq_expr(lhs0, rhs1);
-            if SpanlessEq::new(cx).ignore_fn().eq_expr(lhs1, rhs0);
+            if eq_expr_value(cx, lhs0, rhs1);
+            if eq_expr_value(cx, lhs1, rhs0);
             then {
                 let lhs0 = Sugg::hir_opt(cx, lhs0);
                 let rhs0 = Sugg::hir_opt(cx, rhs0);
diff --git a/clippy_lints/src/utils/hir_utils.rs b/clippy_lints/src/utils/hir_utils.rs
index 28fb6ed12a0..785c409260e 100644
--- a/clippy_lints/src/utils/hir_utils.rs
+++ b/clippy_lints/src/utils/hir_utils.rs
@@ -340,6 +340,11 @@ pub fn over<X>(left: &[X], right: &[X], mut eq_fn: impl FnMut(&X, &X) -> bool) -
     left.len() == right.len() && left.iter().zip(right).all(|(x, y)| eq_fn(x, y))
 }
 
+/// Checks if two expressions evaluate to the same value, and don't contain any side effects.
+pub fn eq_expr_value(cx: &LateContext<'_>, left: &Expr<'_>, right: &Expr<'_>) -> bool {
+    SpanlessEq::new(cx).ignore_fn().eq_expr(left, right)
+}
+
 /// Type used to hash an ast element. This is different from the `Hash` trait
 /// on ast types as this
 /// trait would consider IDs and spans.
diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs
index 6c235679914..0b8d0bd9e11 100644
--- a/clippy_lints/src/utils/internal_lints.rs
+++ b/clippy_lints/src/utils/internal_lints.rs
@@ -1,7 +1,6 @@
-use crate::utils::SpanlessEq;
 use crate::utils::{
     is_expn_of, match_def_path, match_qpath, match_type, method_calls, paths, run_lints, snippet, span_lint,
-    span_lint_and_help, span_lint_and_sugg, walk_ptrs_ty,
+    span_lint_and_help, span_lint_and_sugg, walk_ptrs_ty, SpanlessEq,
 };
 use if_chain::if_chain;
 use rustc_ast::ast::{Crate as AstCrate, ItemKind, LitKind, NodeId};
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index 223628cc610..530552f7940 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -21,7 +21,7 @@ pub mod sugg;
 pub mod usage;
 pub use self::attrs::*;
 pub use self::diagnostics::*;
-pub use self::hir_utils::{both, over, SpanlessEq, SpanlessHash};
+pub use self::hir_utils::{both, eq_expr_value, over, SpanlessEq, SpanlessHash};
 
 use std::borrow::Cow;
 use std::mem;
-- 
cgit 1.4.1-3-g733a5


From 9b800b1e929d6023e1813b2b189336a4bddcffd7 Mon Sep 17 00:00:00 2001
From: Tomasz Miąsko <tomasz.miasko@gmail.com>
Date: Sun, 16 Aug 2020 00:00:00 +0000
Subject: Rename SpanlessEq::ignore_fn to deny_side_effects

No functional changes intended.
---
 clippy_lints/src/utils/hir_utils.rs      | 19 +++++++++----------
 clippy_lints/src/utils/internal_lints.rs |  2 +-
 2 files changed, 10 insertions(+), 11 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/hir_utils.rs b/clippy_lints/src/utils/hir_utils.rs
index 785c409260e..1014546ff89 100644
--- a/clippy_lints/src/utils/hir_utils.rs
+++ b/clippy_lints/src/utils/hir_utils.rs
@@ -23,9 +23,7 @@ pub struct SpanlessEq<'a, 'tcx> {
     /// Context used to evaluate constant expressions.
     cx: &'a LateContext<'tcx>,
     maybe_typeck_results: Option<&'tcx TypeckResults<'tcx>>,
-    /// If is true, never consider as equal expressions containing function
-    /// calls.
-    ignore_fn: bool,
+    allow_side_effects: bool,
 }
 
 impl<'a, 'tcx> SpanlessEq<'a, 'tcx> {
@@ -33,13 +31,14 @@ impl<'a, 'tcx> SpanlessEq<'a, 'tcx> {
         Self {
             cx,
             maybe_typeck_results: cx.maybe_typeck_results(),
-            ignore_fn: false,
+            allow_side_effects: true,
         }
     }
 
-    pub fn ignore_fn(self) -> Self {
+    /// Consider expressions containing potential side effects as not equal.
+    pub fn deny_side_effects(self) -> Self {
         Self {
-            ignore_fn: true,
+            allow_side_effects: false,
             ..self
         }
     }
@@ -67,7 +66,7 @@ impl<'a, 'tcx> SpanlessEq<'a, 'tcx> {
 
     #[allow(clippy::similar_names)]
     pub fn eq_expr(&mut self, left: &Expr<'_>, right: &Expr<'_>) -> bool {
-        if self.ignore_fn && differing_macro_contexts(left.span, right.span) {
+        if !self.allow_side_effects && differing_macro_contexts(left.span, right.span) {
             return false;
         }
 
@@ -108,7 +107,7 @@ impl<'a, 'tcx> SpanlessEq<'a, 'tcx> {
             },
             (&ExprKind::Box(ref l), &ExprKind::Box(ref r)) => self.eq_expr(l, r),
             (&ExprKind::Call(l_fun, l_args), &ExprKind::Call(r_fun, r_args)) => {
-                !self.ignore_fn && self.eq_expr(l_fun, r_fun) && self.eq_exprs(l_args, r_args)
+                self.allow_side_effects && self.eq_expr(l_fun, r_fun) && self.eq_exprs(l_args, r_args)
             },
             (&ExprKind::Cast(ref lx, ref lt), &ExprKind::Cast(ref rx, ref rt))
             | (&ExprKind::Type(ref lx, ref lt), &ExprKind::Type(ref rx, ref rt)) => {
@@ -134,7 +133,7 @@ impl<'a, 'tcx> SpanlessEq<'a, 'tcx> {
                     })
             },
             (&ExprKind::MethodCall(l_path, _, l_args, _), &ExprKind::MethodCall(r_path, _, r_args, _)) => {
-                !self.ignore_fn && self.eq_path_segment(l_path, r_path) && self.eq_exprs(l_args, r_args)
+                self.allow_side_effects && self.eq_path_segment(l_path, r_path) && self.eq_exprs(l_args, r_args)
             },
             (&ExprKind::Repeat(ref le, ref ll_id), &ExprKind::Repeat(ref re, ref rl_id)) => {
                 let mut celcx = constant_context(self.cx, self.cx.tcx.typeck_body(ll_id.body));
@@ -342,7 +341,7 @@ pub fn over<X>(left: &[X], right: &[X], mut eq_fn: impl FnMut(&X, &X) -> bool) -
 
 /// Checks if two expressions evaluate to the same value, and don't contain any side effects.
 pub fn eq_expr_value(cx: &LateContext<'_>, left: &Expr<'_>, right: &Expr<'_>) -> bool {
-    SpanlessEq::new(cx).ignore_fn().eq_expr(left, right)
+    SpanlessEq::new(cx).deny_side_effects().eq_expr(left, right)
 }
 
 /// Type used to hash an ast element. This is different from the `Hash` trait
diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs
index 0b8d0bd9e11..8fa5d22210a 100644
--- a/clippy_lints/src/utils/internal_lints.rs
+++ b/clippy_lints/src/utils/internal_lints.rs
@@ -492,7 +492,7 @@ impl<'tcx> LateLintPass<'tcx> for CollapsibleCalls {
             if let StmtKind::Semi(only_expr) = &stmts[0].kind;
             if let ExprKind::MethodCall(ref ps, _, ref span_call_args, _) = &only_expr.kind;
             let and_then_snippets = get_and_then_snippets(cx, and_then_args);
-            let mut sle = SpanlessEq::new(cx).ignore_fn();
+            let mut sle = SpanlessEq::new(cx).deny_side_effects();
             then {
                 match &*ps.ident.as_str() {
                     "span_suggestion" if sle.eq_expr(&and_then_args[2], &span_call_args[1]) => {
-- 
cgit 1.4.1-3-g733a5


From d1dbf7913ad83954337e94b094f22f1d9d8b83f3 Mon Sep 17 00:00:00 2001
From: Tomasz Miąsko <tomasz.miasko@gmail.com>
Date: Sun, 16 Aug 2020 00:00:00 +0000
Subject: Expresions with Assign / AssignOp have side effects

---
 clippy_lints/src/utils/hir_utils.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/hir_utils.rs b/clippy_lints/src/utils/hir_utils.rs
index 1014546ff89..cacc9f8d6f2 100644
--- a/clippy_lints/src/utils/hir_utils.rs
+++ b/clippy_lints/src/utils/hir_utils.rs
@@ -89,10 +89,10 @@ impl<'a, 'tcx> SpanlessEq<'a, 'tcx> {
                 both(&li.label, &ri.label, |l, r| l.ident.as_str() == r.ident.as_str())
             },
             (&ExprKind::Assign(ref ll, ref lr, _), &ExprKind::Assign(ref rl, ref rr, _)) => {
-                self.eq_expr(ll, rl) && self.eq_expr(lr, rr)
+                self.allow_side_effects && self.eq_expr(ll, rl) && self.eq_expr(lr, rr)
             },
             (&ExprKind::AssignOp(ref lo, ref ll, ref lr), &ExprKind::AssignOp(ref ro, ref rl, ref rr)) => {
-                lo.node == ro.node && self.eq_expr(ll, rl) && self.eq_expr(lr, rr)
+                self.allow_side_effects && lo.node == ro.node && self.eq_expr(ll, rl) && self.eq_expr(lr, rr)
             },
             (&ExprKind::Block(ref l, _), &ExprKind::Block(ref r, _)) => self.eq_block(l, r),
             (&ExprKind::Binary(l_op, ref ll, ref lr), &ExprKind::Binary(r_op, ref rl, ref rr)) => {
-- 
cgit 1.4.1-3-g733a5


From 4f4abf4e0640edbb1614f3dcb8ff62e8afc54801 Mon Sep 17 00:00:00 2001
From: Tomasz Miąsko <tomasz.miasko@gmail.com>
Date: Sun, 16 Aug 2020 00:00:00 +0000
Subject: Warn about explicit self-assignment

Warn about assignments where left-hand side place expression is the same
as right-hand side value expression. For example, warn about assignment in:

```rust
pub struct Event {
    id: usize,
    x: i32,
    y: i32,
}

pub fn copy_position(a: &mut Event, b: &Event) {
    a.x = b.x;
    a.y = a.y;
}
```
---
 CHANGELOG.md                        |  1 +
 clippy_lints/src/lib.rs             |  5 +++
 clippy_lints/src/self_assignment.rs | 51 +++++++++++++++++++++++++++
 src/lintlist/mod.rs                 |  7 ++++
 tests/ui/self_assignment.rs         | 67 +++++++++++++++++++++++++++++++++++
 tests/ui/self_assignment.stderr     | 70 +++++++++++++++++++++++++++++++++++++
 6 files changed, 201 insertions(+)
 create mode 100644 clippy_lints/src/self_assignment.rs
 create mode 100644 tests/ui/self_assignment.rs
 create mode 100644 tests/ui/self_assignment.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index f662de122f9..5ce63c0a157 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1690,6 +1690,7 @@ Released 2018-09-13
 [`same_functions_in_if_condition`]: https://rust-lang.github.io/rust-clippy/master/index.html#same_functions_in_if_condition
 [`same_item_push`]: https://rust-lang.github.io/rust-clippy/master/index.html#same_item_push
 [`search_is_some`]: https://rust-lang.github.io/rust-clippy/master/index.html#search_is_some
+[`self_assignment`]: https://rust-lang.github.io/rust-clippy/master/index.html#self_assignment
 [`serde_api_misuse`]: https://rust-lang.github.io/rust-clippy/master/index.html#serde_api_misuse
 [`shadow_reuse`]: https://rust-lang.github.io/rust-clippy/master/index.html#shadow_reuse
 [`shadow_same`]: https://rust-lang.github.io/rust-clippy/master/index.html#shadow_same
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 17501e8e6da..87c297e72eb 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -284,6 +284,7 @@ mod reference;
 mod regex;
 mod repeat_once;
 mod returns;
+mod self_assignment;
 mod serde_api;
 mod shadow;
 mod single_component_path_imports;
@@ -773,6 +774,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &repeat_once::REPEAT_ONCE,
         &returns::LET_AND_RETURN,
         &returns::NEEDLESS_RETURN,
+        &self_assignment::SELF_ASSIGNMENT,
         &serde_api::SERDE_API_MISUSE,
         &shadow::SHADOW_REUSE,
         &shadow::SHADOW_SAME,
@@ -1090,6 +1092,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box pattern_type_mismatch::PatternTypeMismatch);
     store.register_late_pass(|| box stable_sort_primitive::StableSortPrimitive);
     store.register_late_pass(|| box repeat_once::RepeatOnce);
+    store.register_late_pass(|| box self_assignment::SelfAssignment);
 
     store.register_group(true, "clippy::restriction", Some("clippy_restriction"), vec![
         LintId::of(&arithmetic::FLOAT_ARITHMETIC),
@@ -1421,6 +1424,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&repeat_once::REPEAT_ONCE),
         LintId::of(&returns::LET_AND_RETURN),
         LintId::of(&returns::NEEDLESS_RETURN),
+        LintId::of(&self_assignment::SELF_ASSIGNMENT),
         LintId::of(&serde_api::SERDE_API_MISUSE),
         LintId::of(&single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS),
         LintId::of(&slow_vector_initialization::SLOW_VECTOR_INITIALIZATION),
@@ -1714,6 +1718,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&ptr::MUT_FROM_REF),
         LintId::of(&ranges::REVERSED_EMPTY_RANGES),
         LintId::of(&regex::INVALID_REGEX),
+        LintId::of(&self_assignment::SELF_ASSIGNMENT),
         LintId::of(&serde_api::SERDE_API_MISUSE),
         LintId::of(&suspicious_trait_impl::SUSPICIOUS_ARITHMETIC_IMPL),
         LintId::of(&suspicious_trait_impl::SUSPICIOUS_OP_ASSIGN_IMPL),
diff --git a/clippy_lints/src/self_assignment.rs b/clippy_lints/src/self_assignment.rs
new file mode 100644
index 00000000000..e096c9aebc1
--- /dev/null
+++ b/clippy_lints/src/self_assignment.rs
@@ -0,0 +1,51 @@
+use crate::utils::{eq_expr_value, snippet, span_lint};
+use rustc_hir::{Expr, ExprKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for explicit self-assignments.
+    ///
+    /// **Why is this bad?** Self-assignments are redundant and unlikely to be
+    /// intentional.
+    ///
+    /// **Known problems:** If expression contains any deref coercions or
+    /// indexing operations they are assumed not to have any side effects.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// struct Event {
+    ///     id: usize,
+    ///     x: i32,
+    ///     y: i32,
+    /// }
+    ///
+    /// fn copy_position(a: &mut Event, b: &Event) {
+    ///     a.x = b.x;
+    ///     a.y = a.y;
+    /// }
+    /// ```
+    pub SELF_ASSIGNMENT,
+    correctness,
+    "explicit self-assignment"
+}
+
+declare_lint_pass!(SelfAssignment => [SELF_ASSIGNMENT]);
+
+impl<'tcx> LateLintPass<'tcx> for SelfAssignment {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        if let ExprKind::Assign(lhs, rhs, _) = &expr.kind {
+            if eq_expr_value(cx, lhs, rhs) {
+                let lhs = snippet(cx, lhs.span, "<lhs>");
+                let rhs = snippet(cx, rhs.span, "<rhs>");
+                span_lint(
+                    cx,
+                    SELF_ASSIGNMENT,
+                    expr.span,
+                    &format!("self-assignment of `{}` to `{}`", rhs, lhs),
+                );
+            }
+        }
+    }
+}
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index 3229c8da507..bf58c117aaa 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -1956,6 +1956,13 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
         deprecation: None,
         module: "methods",
     },
+    Lint {
+        name: "self_assignment",
+        group: "correctness",
+        desc: "explicit self-assignment",
+        deprecation: None,
+        module: "self_assignment",
+    },
     Lint {
         name: "serde_api_misuse",
         group: "correctness",
diff --git a/tests/ui/self_assignment.rs b/tests/ui/self_assignment.rs
new file mode 100644
index 00000000000..a7cbb9cd78b
--- /dev/null
+++ b/tests/ui/self_assignment.rs
@@ -0,0 +1,67 @@
+#![warn(clippy::self_assignment)]
+
+pub struct S<'a> {
+    a: i32,
+    b: [i32; 10],
+    c: Vec<Vec<i32>>,
+    e: &'a mut i32,
+    f: &'a mut i32,
+}
+
+pub fn positives(mut a: usize, b: &mut u32, mut s: S) {
+    a = a;
+    *b = *b;
+    s = s;
+    s.a = s.a;
+    s.b[10] = s.b[5 + 5];
+    s.c[0][1] = s.c[0][1];
+    s.b[a] = s.b[a];
+    *s.e = *s.e;
+    s.b[a + 10] = s.b[10 + a];
+
+    let mut t = (0, 1);
+    t.1 = t.1;
+    t.0 = (t.0);
+}
+
+pub fn negatives_not_equal(mut a: usize, b: &mut usize, mut s: S) {
+    dbg!(&a);
+    a = *b;
+    dbg!(&a);
+    s.b[1] += s.b[1];
+    s.b[1] = s.b[2];
+    s.c[1][0] = s.c[0][1];
+    s.b[a] = s.b[*b];
+    s.b[a + 10] = s.b[a + 11];
+    *s.e = *s.f;
+
+    let mut t = (0, 1);
+    t.0 = t.1;
+}
+
+#[allow(clippy::eval_order_dependence)]
+pub fn negatives_side_effects() {
+    let mut v = vec![1, 2, 3, 4, 5];
+    let mut i = 0;
+    v[{
+        i += 1;
+        i
+    }] = v[{
+        i += 1;
+        i
+    }];
+
+    fn next(n: &mut usize) -> usize {
+        let v = *n;
+        *n += 1;
+        v
+    }
+
+    let mut w = vec![1, 2, 3, 4, 5];
+    let mut i = 0;
+    let i = &mut i;
+    w[next(i)] = w[next(i)];
+    w[next(i)] = w[next(i)];
+}
+
+fn main() {}
diff --git a/tests/ui/self_assignment.stderr b/tests/ui/self_assignment.stderr
new file mode 100644
index 00000000000..826e0d0ba88
--- /dev/null
+++ b/tests/ui/self_assignment.stderr
@@ -0,0 +1,70 @@
+error: self-assignment of `a` to `a`
+  --> $DIR/self_assignment.rs:12:5
+   |
+LL |     a = a;
+   |     ^^^^^
+   |
+   = note: `-D clippy::self-assignment` implied by `-D warnings`
+
+error: self-assignment of `*b` to `*b`
+  --> $DIR/self_assignment.rs:13:5
+   |
+LL |     *b = *b;
+   |     ^^^^^^^
+
+error: self-assignment of `s` to `s`
+  --> $DIR/self_assignment.rs:14:5
+   |
+LL |     s = s;
+   |     ^^^^^
+
+error: self-assignment of `s.a` to `s.a`
+  --> $DIR/self_assignment.rs:15:5
+   |
+LL |     s.a = s.a;
+   |     ^^^^^^^^^
+
+error: self-assignment of `s.b[5 + 5]` to `s.b[10]`
+  --> $DIR/self_assignment.rs:16:5
+   |
+LL |     s.b[10] = s.b[5 + 5];
+   |     ^^^^^^^^^^^^^^^^^^^^
+
+error: self-assignment of `s.c[0][1]` to `s.c[0][1]`
+  --> $DIR/self_assignment.rs:17:5
+   |
+LL |     s.c[0][1] = s.c[0][1];
+   |     ^^^^^^^^^^^^^^^^^^^^^
+
+error: self-assignment of `s.b[a]` to `s.b[a]`
+  --> $DIR/self_assignment.rs:18:5
+   |
+LL |     s.b[a] = s.b[a];
+   |     ^^^^^^^^^^^^^^^
+
+error: self-assignment of `*s.e` to `*s.e`
+  --> $DIR/self_assignment.rs:19:5
+   |
+LL |     *s.e = *s.e;
+   |     ^^^^^^^^^^^
+
+error: self-assignment of `s.b[10 + a]` to `s.b[a + 10]`
+  --> $DIR/self_assignment.rs:20:5
+   |
+LL |     s.b[a + 10] = s.b[10 + a];
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: self-assignment of `t.1` to `t.1`
+  --> $DIR/self_assignment.rs:23:5
+   |
+LL |     t.1 = t.1;
+   |     ^^^^^^^^^
+
+error: self-assignment of `(t.0)` to `t.0`
+  --> $DIR/self_assignment.rs:24:5
+   |
+LL |     t.0 = (t.0);
+   |     ^^^^^^^^^^^
+
+error: aborting due to 11 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 99ba290a14c6654164cea8339b827d8da0ff600d Mon Sep 17 00:00:00 2001
From: Takayuki Nakata <f.seasons017@gmail.com>
Date: Mon, 17 Aug 2020 08:36:02 +0900
Subject: Improve code style

---
 clippy_lints/src/loops.rs | 39 +++++++++++++++++----------------------
 1 file changed, 17 insertions(+), 22 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index f7db2563d2b..df06031d999 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -1145,29 +1145,24 @@ fn detect_same_item_push<'tcx>(
                 let vec_str = snippet_with_macro_callsite(cx, vec.span, "");
                 let item_str = snippet_with_macro_callsite(cx, pushed_item.span, "");
                 if let ExprKind::Path(ref qpath) = pushed_item.kind {
-                    if let Res::Local(hir_id) = qpath_res(cx, qpath, pushed_item.hir_id) {
+                    if_chain! {
+                        if let Res::Local(hir_id) = qpath_res(cx, qpath, pushed_item.hir_id);
                         let node = cx.tcx.hir().get(hir_id);
-                        if_chain! {
-                            if let Node::Binding(pat) = node;
-                            if let PatKind::Binding(bind_ann, ..) = pat.kind;
-                            then {
-                                match bind_ann {
-                                    BindingAnnotation::RefMut | BindingAnnotation::Mutable => {},
-                                    _ => {
-                                        span_lint_and_help(
-                                            cx,
-                                            SAME_ITEM_PUSH,
-                                            vec.span,
-                                            "it looks like the same item is being pushed into this Vec",
-                                            None,
-                                            &format!(
-                                                "try using vec![{};SIZE] or {}.resize(NEW_SIZE, {})",
-                                                item_str, vec_str, item_str
-                                            ),
-                                        )
-                                    }
-                                }
-                            }
+                        if let Node::Binding(pat) = node;
+                        if let PatKind::Binding(bind_ann, ..) = pat.kind;
+                        if !matches!(bind_ann, BindingAnnotation::RefMut | BindingAnnotation::Mutable);
+                        then {
+                            span_lint_and_help(
+                                cx,
+                                SAME_ITEM_PUSH,
+                                vec.span,
+                                "it looks like the same item is being pushed into this Vec",
+                                None,
+                                &format!(
+                                    "try using vec![{};SIZE] or {}.resize(NEW_SIZE, {})",
+                                    item_str, vec_str, item_str
+                                ),
+                            )
                         }
                     }
                 } else if mutated_variables(pushed_item, cx).map_or(false, |mutvars| mutvars.is_empty()) {
-- 
cgit 1.4.1-3-g733a5


From df4d42fc2debf7a7d43226c79480c71037be42b8 Mon Sep 17 00:00:00 2001
From: Eduardo Broto <ebroto@tutanota.com>
Date: Tue, 18 Aug 2020 01:00:11 +0200
Subject: transmute: avoid suggesting from/to bits in const

---
 clippy_lints/src/transmute.rs          | 10 +++++--
 tests/ui/transmute.rs                  | 15 ++++++++--
 tests/ui/transmute.stderr              | 52 +++++++++++++++++-----------------
 tests/ui/transmute_float_to_int.rs     | 11 ++++++-
 tests/ui/transmute_float_to_int.stderr | 12 ++++----
 5 files changed, 61 insertions(+), 39 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/transmute.rs b/clippy_lints/src/transmute.rs
index 28fd55f6ff0..1d238b242b0 100644
--- a/clippy_lints/src/transmute.rs
+++ b/clippy_lints/src/transmute.rs
@@ -1,5 +1,5 @@
 use crate::utils::{
-    is_normalizable, last_path_segment, match_def_path, paths, snippet, span_lint, span_lint_and_sugg,
+    in_constant, is_normalizable, last_path_segment, match_def_path, paths, snippet, span_lint, span_lint_and_sugg,
     span_lint_and_then, sugg,
 };
 use if_chain::if_chain;
@@ -331,6 +331,10 @@ impl<'tcx> LateLintPass<'tcx> for Transmute {
             if let Some(def_id) = cx.qpath_res(qpath, path_expr.hir_id).opt_def_id();
             if match_def_path(cx, def_id, &paths::TRANSMUTE);
             then {
+                // Avoid suggesting f32::(from|to)_bits in const contexts.
+                // See https://github.com/rust-lang/rust/issues/73736 for progress on making them `const fn`.
+                let const_context = in_constant(cx, e.hir_id);
+
                 let from_ty = cx.typeck_results().expr_ty(&args[0]);
                 let to_ty = cx.typeck_results().expr_ty(e);
 
@@ -544,7 +548,7 @@ impl<'tcx> LateLintPass<'tcx> for Transmute {
                             },
                         )
                     },
-                    (ty::Int(_) | ty::Uint(_), ty::Float(_)) => span_lint_and_then(
+                    (ty::Int(_) | ty::Uint(_), ty::Float(_)) if !const_context => span_lint_and_then(
                         cx,
                         TRANSMUTE_INT_TO_FLOAT,
                         e.span,
@@ -567,7 +571,7 @@ impl<'tcx> LateLintPass<'tcx> for Transmute {
                             );
                         },
                     ),
-                    (ty::Float(float_ty), ty::Int(_) | ty::Uint(_)) => span_lint_and_then(
+                    (ty::Float(float_ty), ty::Int(_) | ty::Uint(_)) if !const_context => span_lint_and_then(
                         cx,
                         TRANSMUTE_FLOAT_TO_INT,
                         e.span,
diff --git a/tests/ui/transmute.rs b/tests/ui/transmute.rs
index bb853d23704..7caad34edb3 100644
--- a/tests/ui/transmute.rs
+++ b/tests/ui/transmute.rs
@@ -1,3 +1,4 @@
+#![feature(const_fn_transmute)]
 #![allow(dead_code)]
 
 extern crate core;
@@ -81,9 +82,17 @@ fn int_to_bool() {
 }
 
 #[warn(clippy::transmute_int_to_float)]
-fn int_to_float() {
-    let _: f32 = unsafe { std::mem::transmute(0_u32) };
-    let _: f32 = unsafe { std::mem::transmute(0_i32) };
+mod int_to_float {
+    fn test() {
+        let _: f32 = unsafe { std::mem::transmute(0_u32) };
+        let _: f32 = unsafe { std::mem::transmute(0_i32) };
+    }
+
+    // See issue #5747
+    const VALUE: f32 = unsafe { std::mem::transmute(0_u32) };
+    const fn from_bits(v: u32) -> f32 {
+        unsafe { std::mem::transmute(v) }
+    }
 }
 
 fn bytes_to_str(b: &[u8], mb: &mut [u8]) {
diff --git a/tests/ui/transmute.stderr b/tests/ui/transmute.stderr
index 8582080498f..d817c08b52f 100644
--- a/tests/ui/transmute.stderr
+++ b/tests/ui/transmute.stderr
@@ -1,5 +1,5 @@
 error: transmute from a type (`&T`) to itself
-  --> $DIR/transmute.rs:19:20
+  --> $DIR/transmute.rs:20:20
    |
 LL |     let _: &'a T = core::intrinsics::transmute(t);
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -7,67 +7,67 @@ LL |     let _: &'a T = core::intrinsics::transmute(t);
    = note: `-D clippy::useless-transmute` implied by `-D warnings`
 
 error: transmute from a reference to a pointer
-  --> $DIR/transmute.rs:23:23
+  --> $DIR/transmute.rs:24:23
    |
 LL |     let _: *const T = core::intrinsics::transmute(t);
    |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `t as *const T`
 
 error: transmute from a reference to a pointer
-  --> $DIR/transmute.rs:25:21
+  --> $DIR/transmute.rs:26:21
    |
 LL |     let _: *mut T = core::intrinsics::transmute(t);
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `t as *const T as *mut T`
 
 error: transmute from a reference to a pointer
-  --> $DIR/transmute.rs:27:23
+  --> $DIR/transmute.rs:28:23
    |
 LL |     let _: *const U = core::intrinsics::transmute(t);
    |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `t as *const T as *const U`
 
 error: transmute from a type (`std::vec::Vec<i32>`) to itself
-  --> $DIR/transmute.rs:33:27
+  --> $DIR/transmute.rs:34:27
    |
 LL |         let _: Vec<i32> = core::intrinsics::transmute(my_vec());
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: transmute from a type (`std::vec::Vec<i32>`) to itself
-  --> $DIR/transmute.rs:35:27
+  --> $DIR/transmute.rs:36:27
    |
 LL |         let _: Vec<i32> = core::mem::transmute(my_vec());
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: transmute from a type (`std::vec::Vec<i32>`) to itself
-  --> $DIR/transmute.rs:37:27
+  --> $DIR/transmute.rs:38:27
    |
 LL |         let _: Vec<i32> = std::intrinsics::transmute(my_vec());
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: transmute from a type (`std::vec::Vec<i32>`) to itself
-  --> $DIR/transmute.rs:39:27
+  --> $DIR/transmute.rs:40:27
    |
 LL |         let _: Vec<i32> = std::mem::transmute(my_vec());
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: transmute from a type (`std::vec::Vec<i32>`) to itself
-  --> $DIR/transmute.rs:41:27
+  --> $DIR/transmute.rs:42:27
    |
 LL |         let _: Vec<i32> = my_transmute(my_vec());
    |                           ^^^^^^^^^^^^^^^^^^^^^^
 
 error: transmute from an integer to a pointer
-  --> $DIR/transmute.rs:43:31
+  --> $DIR/transmute.rs:44:31
    |
 LL |         let _: *const usize = std::mem::transmute(5_isize);
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `5_isize as *const usize`
 
 error: transmute from an integer to a pointer
-  --> $DIR/transmute.rs:47:31
+  --> $DIR/transmute.rs:48:31
    |
 LL |         let _: *const usize = std::mem::transmute(1 + 1usize);
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `(1 + 1usize) as *const usize`
 
 error: transmute from a type (`*const Usize`) to the type that it points to (`Usize`)
-  --> $DIR/transmute.rs:62:24
+  --> $DIR/transmute.rs:63:24
    |
 LL |         let _: Usize = core::intrinsics::transmute(int_const_ptr);
    |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -75,25 +75,25 @@ LL |         let _: Usize = core::intrinsics::transmute(int_const_ptr);
    = note: `-D clippy::crosspointer-transmute` implied by `-D warnings`
 
 error: transmute from a type (`*mut Usize`) to the type that it points to (`Usize`)
-  --> $DIR/transmute.rs:64:24
+  --> $DIR/transmute.rs:65:24
    |
 LL |         let _: Usize = core::intrinsics::transmute(int_mut_ptr);
    |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: transmute from a type (`Usize`) to a pointer to that type (`*const Usize`)
-  --> $DIR/transmute.rs:66:31
+  --> $DIR/transmute.rs:67:31
    |
 LL |         let _: *const Usize = core::intrinsics::transmute(my_int());
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: transmute from a type (`Usize`) to a pointer to that type (`*mut Usize`)
-  --> $DIR/transmute.rs:68:29
+  --> $DIR/transmute.rs:69:29
    |
 LL |         let _: *mut Usize = core::intrinsics::transmute(my_int());
    |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: transmute from a `u32` to a `char`
-  --> $DIR/transmute.rs:74:28
+  --> $DIR/transmute.rs:75:28
    |
 LL |     let _: char = unsafe { std::mem::transmute(0_u32) };
    |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::char::from_u32(0_u32).unwrap()`
@@ -101,13 +101,13 @@ LL |     let _: char = unsafe { std::mem::transmute(0_u32) };
    = note: `-D clippy::transmute-int-to-char` implied by `-D warnings`
 
 error: transmute from a `i32` to a `char`
-  --> $DIR/transmute.rs:75:28
+  --> $DIR/transmute.rs:76:28
    |
 LL |     let _: char = unsafe { std::mem::transmute(0_i32) };
    |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::char::from_u32(0_i32 as u32).unwrap()`
 
 error: transmute from a `u8` to a `bool`
-  --> $DIR/transmute.rs:80:28
+  --> $DIR/transmute.rs:81:28
    |
 LL |     let _: bool = unsafe { std::mem::transmute(0_u8) };
    |                            ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `0_u8 != 0`
@@ -115,21 +115,21 @@ LL |     let _: bool = unsafe { std::mem::transmute(0_u8) };
    = note: `-D clippy::transmute-int-to-bool` implied by `-D warnings`
 
 error: transmute from a `u32` to a `f32`
-  --> $DIR/transmute.rs:85:27
+  --> $DIR/transmute.rs:87:31
    |
-LL |     let _: f32 = unsafe { std::mem::transmute(0_u32) };
-   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `f32::from_bits(0_u32)`
+LL |         let _: f32 = unsafe { std::mem::transmute(0_u32) };
+   |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `f32::from_bits(0_u32)`
    |
    = note: `-D clippy::transmute-int-to-float` implied by `-D warnings`
 
 error: transmute from a `i32` to a `f32`
-  --> $DIR/transmute.rs:86:27
+  --> $DIR/transmute.rs:88:31
    |
-LL |     let _: f32 = unsafe { std::mem::transmute(0_i32) };
-   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `f32::from_bits(0_i32 as u32)`
+LL |         let _: f32 = unsafe { std::mem::transmute(0_i32) };
+   |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `f32::from_bits(0_i32 as u32)`
 
 error: transmute from a `&[u8]` to a `&str`
-  --> $DIR/transmute.rs:90:28
+  --> $DIR/transmute.rs:99:28
    |
 LL |     let _: &str = unsafe { std::mem::transmute(b) };
    |                            ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::str::from_utf8(b).unwrap()`
@@ -137,7 +137,7 @@ LL |     let _: &str = unsafe { std::mem::transmute(b) };
    = note: `-D clippy::transmute-bytes-to-str` implied by `-D warnings`
 
 error: transmute from a `&mut [u8]` to a `&mut str`
-  --> $DIR/transmute.rs:91:32
+  --> $DIR/transmute.rs:100:32
    |
 LL |     let _: &mut str = unsafe { std::mem::transmute(mb) };
    |                                ^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::str::from_utf8_mut(mb).unwrap()`
diff --git a/tests/ui/transmute_float_to_int.rs b/tests/ui/transmute_float_to_int.rs
index ce942751ada..8173944d959 100644
--- a/tests/ui/transmute_float_to_int.rs
+++ b/tests/ui/transmute_float_to_int.rs
@@ -1,4 +1,5 @@
-#[warn(clippy::transmute_float_to_int)]
+#![feature(const_fn_transmute)]
+#![warn(clippy::transmute_float_to_int)]
 
 fn float_to_int() {
     let _: u32 = unsafe { std::mem::transmute(1f32) };
@@ -9,4 +10,12 @@ fn float_to_int() {
     let _: u64 = unsafe { std::mem::transmute(-1.0) };
 }
 
+mod issue_5747 {
+    const VALUE: u32 = unsafe { std::mem::transmute(1f32) };
+
+    const fn to_bits(v: f32) -> u32 {
+        unsafe { std::mem::transmute(v) }
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/transmute_float_to_int.stderr b/tests/ui/transmute_float_to_int.stderr
index eb786bb39f9..5a40cf381d6 100644
--- a/tests/ui/transmute_float_to_int.stderr
+++ b/tests/ui/transmute_float_to_int.stderr
@@ -1,5 +1,5 @@
 error: transmute from a `f32` to a `u32`
-  --> $DIR/transmute_float_to_int.rs:4:27
+  --> $DIR/transmute_float_to_int.rs:5:27
    |
 LL |     let _: u32 = unsafe { std::mem::transmute(1f32) };
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `1f32.to_bits()`
@@ -7,31 +7,31 @@ LL |     let _: u32 = unsafe { std::mem::transmute(1f32) };
    = note: `-D clippy::transmute-float-to-int` implied by `-D warnings`
 
 error: transmute from a `f32` to a `i32`
-  --> $DIR/transmute_float_to_int.rs:5:27
+  --> $DIR/transmute_float_to_int.rs:6:27
    |
 LL |     let _: i32 = unsafe { std::mem::transmute(1f32) };
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `1f32.to_bits() as i32`
 
 error: transmute from a `f64` to a `u64`
-  --> $DIR/transmute_float_to_int.rs:6:27
+  --> $DIR/transmute_float_to_int.rs:7:27
    |
 LL |     let _: u64 = unsafe { std::mem::transmute(1f64) };
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `1f64.to_bits()`
 
 error: transmute from a `f64` to a `i64`
-  --> $DIR/transmute_float_to_int.rs:7:27
+  --> $DIR/transmute_float_to_int.rs:8:27
    |
 LL |     let _: i64 = unsafe { std::mem::transmute(1f64) };
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `1f64.to_bits() as i64`
 
 error: transmute from a `f64` to a `u64`
-  --> $DIR/transmute_float_to_int.rs:8:27
+  --> $DIR/transmute_float_to_int.rs:9:27
    |
 LL |     let _: u64 = unsafe { std::mem::transmute(1.0) };
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `1.0f64.to_bits()`
 
 error: transmute from a `f64` to a `u64`
-  --> $DIR/transmute_float_to_int.rs:9:27
+  --> $DIR/transmute_float_to_int.rs:10:27
    |
 LL |     let _: u64 = unsafe { std::mem::transmute(-1.0) };
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(-1.0f64).to_bits()`
-- 
cgit 1.4.1-3-g733a5


From 6a12bae1941bdef7c2716ffefed5594e5d7e9f8e Mon Sep 17 00:00:00 2001
From: Eduardo Broto <ebroto@tutanota.com>
Date: Tue, 18 Aug 2020 22:19:30 +0200
Subject: no from/to bits in const: add tests cases for f64

---
 clippy_lints/src/transmute.rs      |  2 +-
 tests/ui/transmute.rs              | 17 +++++++++++++----
 tests/ui/transmute.stderr          | 18 +++++++++++++++---
 tests/ui/transmute_float_to_int.rs |  9 +++++++--
 4 files changed, 36 insertions(+), 10 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/transmute.rs b/clippy_lints/src/transmute.rs
index 1d238b242b0..50d9c93f9d4 100644
--- a/clippy_lints/src/transmute.rs
+++ b/clippy_lints/src/transmute.rs
@@ -331,7 +331,7 @@ impl<'tcx> LateLintPass<'tcx> for Transmute {
             if let Some(def_id) = cx.qpath_res(qpath, path_expr.hir_id).opt_def_id();
             if match_def_path(cx, def_id, &paths::TRANSMUTE);
             then {
-                // Avoid suggesting f32::(from|to)_bits in const contexts.
+                // Avoid suggesting from/to bits in const contexts.
                 // See https://github.com/rust-lang/rust/issues/73736 for progress on making them `const fn`.
                 let const_context = in_constant(cx, e.hir_id);
 
diff --git a/tests/ui/transmute.rs b/tests/ui/transmute.rs
index 7caad34edb3..9f1948359e7 100644
--- a/tests/ui/transmute.rs
+++ b/tests/ui/transmute.rs
@@ -86,12 +86,21 @@ mod int_to_float {
     fn test() {
         let _: f32 = unsafe { std::mem::transmute(0_u32) };
         let _: f32 = unsafe { std::mem::transmute(0_i32) };
+        let _: f64 = unsafe { std::mem::transmute(0_u64) };
+        let _: f64 = unsafe { std::mem::transmute(0_i64) };
     }
 
-    // See issue #5747
-    const VALUE: f32 = unsafe { std::mem::transmute(0_u32) };
-    const fn from_bits(v: u32) -> f32 {
-        unsafe { std::mem::transmute(v) }
+    mod issue_5747 {
+        const VALUE32: f32 = unsafe { std::mem::transmute(0_u32) };
+        const VALUE64: f64 = unsafe { std::mem::transmute(0_i64) };
+
+        const fn from_bits_32(v: i32) -> f32 {
+            unsafe { std::mem::transmute(v) }
+        }
+
+        const fn from_bits_64(v: u64) -> f64 {
+            unsafe { std::mem::transmute(v) }
+        }
     }
 }
 
diff --git a/tests/ui/transmute.stderr b/tests/ui/transmute.stderr
index d817c08b52f..ad9953d12bc 100644
--- a/tests/ui/transmute.stderr
+++ b/tests/ui/transmute.stderr
@@ -128,8 +128,20 @@ error: transmute from a `i32` to a `f32`
 LL |         let _: f32 = unsafe { std::mem::transmute(0_i32) };
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `f32::from_bits(0_i32 as u32)`
 
+error: transmute from a `u64` to a `f64`
+  --> $DIR/transmute.rs:89:31
+   |
+LL |         let _: f64 = unsafe { std::mem::transmute(0_u64) };
+   |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `f64::from_bits(0_u64)`
+
+error: transmute from a `i64` to a `f64`
+  --> $DIR/transmute.rs:90:31
+   |
+LL |         let _: f64 = unsafe { std::mem::transmute(0_i64) };
+   |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `f64::from_bits(0_i64 as u64)`
+
 error: transmute from a `&[u8]` to a `&str`
-  --> $DIR/transmute.rs:99:28
+  --> $DIR/transmute.rs:108:28
    |
 LL |     let _: &str = unsafe { std::mem::transmute(b) };
    |                            ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::str::from_utf8(b).unwrap()`
@@ -137,10 +149,10 @@ LL |     let _: &str = unsafe { std::mem::transmute(b) };
    = note: `-D clippy::transmute-bytes-to-str` implied by `-D warnings`
 
 error: transmute from a `&mut [u8]` to a `&mut str`
-  --> $DIR/transmute.rs:100:32
+  --> $DIR/transmute.rs:109:32
    |
 LL |     let _: &mut str = unsafe { std::mem::transmute(mb) };
    |                                ^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::str::from_utf8_mut(mb).unwrap()`
 
-error: aborting due to 22 previous errors
+error: aborting due to 24 previous errors
 
diff --git a/tests/ui/transmute_float_to_int.rs b/tests/ui/transmute_float_to_int.rs
index 8173944d959..1040fee4b34 100644
--- a/tests/ui/transmute_float_to_int.rs
+++ b/tests/ui/transmute_float_to_int.rs
@@ -11,9 +11,14 @@ fn float_to_int() {
 }
 
 mod issue_5747 {
-    const VALUE: u32 = unsafe { std::mem::transmute(1f32) };
+    const VALUE32: i32 = unsafe { std::mem::transmute(1f32) };
+    const VALUE64: u64 = unsafe { std::mem::transmute(1f64) };
 
-    const fn to_bits(v: f32) -> u32 {
+    const fn to_bits_32(v: f32) -> u32 {
+        unsafe { std::mem::transmute(v) }
+    }
+
+    const fn to_bits_64(v: f64) -> i64 {
         unsafe { std::mem::transmute(v) }
     }
 }
-- 
cgit 1.4.1-3-g733a5


From 902b28275ef6e06826f269bdf2459c4ba4562145 Mon Sep 17 00:00:00 2001
From: Takayuki Nakata <f.seasons017@gmail.com>
Date: Wed, 19 Aug 2020 22:31:34 +0900
Subject: Improve lint message in `to_string_in_display`

---
 clippy_lints/src/to_string_in_display.rs | 4 ++--
 src/lintlist/mod.rs                      | 2 +-
 tests/ui/to_string_in_display.stderr     | 2 +-
 3 files changed, 4 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/to_string_in_display.rs b/clippy_lints/src/to_string_in_display.rs
index 11bdd27d9b1..4b6a0a6a0c9 100644
--- a/clippy_lints/src/to_string_in_display.rs
+++ b/clippy_lints/src/to_string_in_display.rs
@@ -39,7 +39,7 @@ declare_clippy_lint! {
     /// ```
     pub TO_STRING_IN_DISPLAY,
     correctness,
-    "to_string method used while implementing Display trait"
+    "`to_string` method used while implementing `Display` trait"
 }
 
 #[derive(Default)]
@@ -80,7 +80,7 @@ impl LateLintPass<'_> for ToStringInDisplay {
                     cx,
                     TO_STRING_IN_DISPLAY,
                     expr.span,
-                    "Using to_string in fmt::Display implementation might lead to infinite recursion",
+                    "using `to_string` in `fmt::Display` implementation might lead to infinite recursion",
                 );
             }
         }
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index bf58c117aaa..c50c6b900ae 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -2183,7 +2183,7 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
     Lint {
         name: "to_string_in_display",
         group: "correctness",
-        desc: "to_string method used while implementing Display trait",
+        desc: "`to_string` method used while implementing `Display` trait",
         deprecation: None,
         module: "to_string_in_display",
     },
diff --git a/tests/ui/to_string_in_display.stderr b/tests/ui/to_string_in_display.stderr
index cbc0a41036b..5f26ef413e2 100644
--- a/tests/ui/to_string_in_display.stderr
+++ b/tests/ui/to_string_in_display.stderr
@@ -1,4 +1,4 @@
-error: Using to_string in fmt::Display implementation might lead to infinite recursion
+error: using `to_string` in `fmt::Display` implementation might lead to infinite recursion
   --> $DIR/to_string_in_display.rs:25:25
    |
 LL |         write!(f, "{}", self.to_string())
-- 
cgit 1.4.1-3-g733a5


From c236c0fb5694948353b5fcbe46010cf04d5a7107 Mon Sep 17 00:00:00 2001
From: Michael Wright <mikerite@lavabit.com>
Date: Thu, 20 Aug 2020 06:34:48 +0200
Subject: Fix false positive in `PRECEDENCE` lint

Extend the lint to handle chains of methods combined with unary negation.

Closes #5924
---
 clippy_lints/src/precedence.rs | 59 +++++++++++++++++++++---------------------
 tests/ui/precedence.fixed      |  8 ++++++
 tests/ui/precedence.rs         |  8 ++++++
 tests/ui/precedence.stderr     | 20 +++++++++++++-
 4 files changed, 65 insertions(+), 30 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/precedence.rs b/clippy_lints/src/precedence.rs
index 4797771e7bd..c9d18c3cb72 100644
--- a/clippy_lints/src/precedence.rs
+++ b/clippy_lints/src/precedence.rs
@@ -1,4 +1,5 @@
 use crate::utils::{snippet_with_applicability, span_lint_and_sugg};
+use if_chain::if_chain;
 use rustc_ast::ast::{BinOpKind, Expr, ExprKind, LitKind, UnOp};
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass};
@@ -102,36 +103,36 @@ impl EarlyLintPass for Precedence {
             }
         }
 
-        if let ExprKind::Unary(UnOp::Neg, ref rhs) = expr.kind {
-            if let ExprKind::MethodCall(ref path_segment, ref args, _) = rhs.kind {
+        if let ExprKind::Unary(UnOp::Neg, operand) = &expr.kind {
+            let mut arg = operand;
+
+            let mut all_odd = true;
+            while let ExprKind::MethodCall(path_segment, args, _) = &arg.kind {
                 let path_segment_str = path_segment.ident.name.as_str();
-                if let Some(slf) = args.first() {
-                    if let ExprKind::Lit(ref lit) = slf.kind {
-                        match lit.kind {
-                            LitKind::Int(..) | LitKind::Float(..) => {
-                                if ALLOWED_ODD_FUNCTIONS
-                                    .iter()
-                                    .any(|odd_function| **odd_function == *path_segment_str)
-                                {
-                                    return;
-                                }
-                                let mut applicability = Applicability::MachineApplicable;
-                                span_lint_and_sugg(
-                                    cx,
-                                    PRECEDENCE,
-                                    expr.span,
-                                    "unary minus has lower precedence than method call",
-                                    "consider adding parentheses to clarify your intent",
-                                    format!(
-                                        "-({})",
-                                        snippet_with_applicability(cx, rhs.span, "..", &mut applicability)
-                                    ),
-                                    applicability,
-                                );
-                            },
-                            _ => (),
-                        }
-                    }
+                all_odd &= ALLOWED_ODD_FUNCTIONS
+                    .iter()
+                    .any(|odd_function| **odd_function == *path_segment_str);
+                arg = args.first().expect("A method always has a receiver.");
+            }
+
+            if_chain! {
+                if !all_odd;
+                if let ExprKind::Lit(lit) = &arg.kind;
+                if let LitKind::Int(..) | LitKind::Float(..) = &lit.kind;
+                then {
+                    let mut applicability = Applicability::MachineApplicable;
+                    span_lint_and_sugg(
+                        cx,
+                        PRECEDENCE,
+                        expr.span,
+                        "unary minus has lower precedence than method call",
+                        "consider adding parentheses to clarify your intent",
+                        format!(
+                            "-({})",
+                            snippet_with_applicability(cx, operand.span, "..", &mut applicability)
+                        ),
+                        applicability,
+                    );
                 }
             }
         }
diff --git a/tests/ui/precedence.fixed b/tests/ui/precedence.fixed
index 4d284ae1319..163bd044c17 100644
--- a/tests/ui/precedence.fixed
+++ b/tests/ui/precedence.fixed
@@ -48,6 +48,14 @@ fn main() {
     let _ = -1f64.to_degrees();
     let _ = -1f64.to_radians();
 
+    // Chains containing any non-odd function should trigger (issue #5924)
+    let _ = -(1.0_f64.cos().cos());
+    let _ = -(1.0_f64.cos().sin());
+    let _ = -(1.0_f64.sin().cos());
+
+    // Chains of odd functions shouldn't trigger
+    let _ = -1f64.sin().sin();
+
     let b = 3;
     trip!(b * 8);
 }
diff --git a/tests/ui/precedence.rs b/tests/ui/precedence.rs
index 2d08e82f349..8c849e3209b 100644
--- a/tests/ui/precedence.rs
+++ b/tests/ui/precedence.rs
@@ -48,6 +48,14 @@ fn main() {
     let _ = -1f64.to_degrees();
     let _ = -1f64.to_radians();
 
+    // Chains containing any non-odd function should trigger (issue #5924)
+    let _ = -1.0_f64.cos().cos();
+    let _ = -1.0_f64.cos().sin();
+    let _ = -1.0_f64.sin().cos();
+
+    // Chains of odd functions shouldn't trigger
+    let _ = -1f64.sin().sin();
+
     let b = 3;
     trip!(b * 8);
 }
diff --git a/tests/ui/precedence.stderr b/tests/ui/precedence.stderr
index a2ed5392bfc..03d585b3975 100644
--- a/tests/ui/precedence.stderr
+++ b/tests/ui/precedence.stderr
@@ -54,5 +54,23 @@ error: unary minus has lower precedence than method call
 LL |     -1f32.abs();
    |     ^^^^^^^^^^^ help: consider adding parentheses to clarify your intent: `-(1f32.abs())`
 
-error: aborting due to 9 previous errors
+error: unary minus has lower precedence than method call
+  --> $DIR/precedence.rs:52:13
+   |
+LL |     let _ = -1.0_f64.cos().cos();
+   |             ^^^^^^^^^^^^^^^^^^^^ help: consider adding parentheses to clarify your intent: `-(1.0_f64.cos().cos())`
+
+error: unary minus has lower precedence than method call
+  --> $DIR/precedence.rs:53:13
+   |
+LL |     let _ = -1.0_f64.cos().sin();
+   |             ^^^^^^^^^^^^^^^^^^^^ help: consider adding parentheses to clarify your intent: `-(1.0_f64.cos().sin())`
+
+error: unary minus has lower precedence than method call
+  --> $DIR/precedence.rs:54:13
+   |
+LL |     let _ = -1.0_f64.sin().cos();
+   |             ^^^^^^^^^^^^^^^^^^^^ help: consider adding parentheses to clarify your intent: `-(1.0_f64.sin().cos())`
+
+error: aborting due to 12 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 2ecc2ac864739cff6aed2609021e2467dedb117a Mon Sep 17 00:00:00 2001
From: Tim Nielens <tim.nielens@gmail.com>
Date: Fri, 21 Aug 2020 00:07:56 +0200
Subject: unit-arg - improve suggestion

---
 clippy_lints/src/types.rs             |  88 +++++++++++++++------------
 tests/ui/unit_arg.rs                  |   7 ++-
 tests/ui/unit_arg.stderr              | 111 ++++++++++++++++------------------
 tests/ui/unit_arg_empty_blocks.stderr |  21 ++-----
 4 files changed, 115 insertions(+), 112 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs
index 7e9190bef5e..3f5b3a5bcd5 100644
--- a/clippy_lints/src/types.rs
+++ b/clippy_lints/src/types.rs
@@ -11,8 +11,8 @@ use rustc_hir as hir;
 use rustc_hir::intravisit::{walk_body, walk_expr, walk_ty, FnKind, NestedVisitorMap, Visitor};
 use rustc_hir::{
     BinOpKind, Block, Body, Expr, ExprKind, FnDecl, FnRetTy, FnSig, GenericArg, GenericParamKind, HirId, ImplItem,
-    ImplItemKind, Item, ItemKind, Lifetime, Local, MatchSource, MutTy, Mutability, QPath, Stmt, StmtKind, TraitFn,
-    TraitItem, TraitItemKind, TyKind, UnOp,
+    ImplItemKind, Item, ItemKind, Lifetime, Local, MatchSource, MutTy, Mutability, Node, QPath, Stmt, StmtKind,
+    TraitFn, TraitItem, TraitItemKind, TyKind, UnOp,
 };
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::hir::map::Map;
@@ -29,10 +29,10 @@ use rustc_typeck::hir_ty_to_ty;
 use crate::consts::{constant, Constant};
 use crate::utils::paths;
 use crate::utils::{
-    clip, comparisons, differing_macro_contexts, higher, in_constant, indent_of, int_bits, is_type_diagnostic_item,
+    clip, comparisons, differing_macro_contexts, higher, in_constant, int_bits, is_type_diagnostic_item,
     last_path_segment, match_def_path, match_path, method_chain_args, multispan_sugg, numeric_literal::NumericLiteral,
-    qpath_res, sext, snippet, snippet_block_with_applicability, snippet_opt, snippet_with_applicability,
-    snippet_with_macro_callsite, span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then, unsext,
+    qpath_res, sext, snippet, snippet_opt, snippet_with_applicability, snippet_with_macro_callsite, span_lint,
+    span_lint_and_help, span_lint_and_sugg, span_lint_and_then, unsext,
 };
 
 declare_clippy_lint! {
@@ -844,43 +844,54 @@ fn lint_unit_args(cx: &LateContext<'_>, expr: &Expr<'_>, args_to_recover: &[&Exp
                         Applicability::MaybeIncorrect,
                     );
                     or = "or ";
+                    applicability = Applicability::MaybeIncorrect;
                 });
-            let sugg = args_to_recover
+
+            let arg_snippets: Vec<String> = args_to_recover
+                .iter()
+                .filter_map(|arg| snippet_opt(cx, arg.span))
+                .collect();
+            let arg_snippets_without_empty_blocks: Vec<String> = args_to_recover
                 .iter()
                 .filter(|arg| !is_empty_block(arg))
-                .enumerate()
-                .map(|(i, arg)| {
-                    let indent = if i == 0 {
-                        0
-                    } else {
-                        indent_of(cx, expr.span).unwrap_or(0)
-                    };
-                    format!(
-                        "{}{};",
-                        " ".repeat(indent),
-                        snippet_block_with_applicability(cx, arg.span, "..", Some(expr.span), &mut applicability)
-                    )
-                })
-                .collect::<Vec<String>>();
-            let mut and = "";
-            if !sugg.is_empty() {
-                let plural = if sugg.len() > 1 { "s" } else { "" };
-                db.span_suggestion(
-                    expr.span.with_hi(expr.span.lo()),
-                    &format!("{}move the expression{} in front of the call...", or, plural),
-                    format!("{}\n", sugg.join("\n")),
-                    applicability,
-                );
-                and = "...and "
+                .filter_map(|arg| snippet_opt(cx, arg.span))
+                .collect();
+
+            if let Some(mut sugg) = snippet_opt(cx, expr.span) {
+                arg_snippets.iter().for_each(|arg| {
+                    sugg = sugg.replacen(arg, "()", 1);
+                });
+                sugg = format!("{}{}{}", arg_snippets_without_empty_blocks.join("; "), "; ", sugg);
+                let parent_node = cx.tcx.hir().find(cx.tcx.hir().get_parent_node(expr.hir_id));
+                if !matches!(parent_node, Some(Node::Block(_))) && !matches!(parent_node, Some(Node::Stmt(_))) {
+                    // expr is not in a block statement or result expression position, wrap in a block
+                    sugg = format!("{{ {} }}", sugg);
+                }
+
+                if arg_snippets_without_empty_blocks.is_empty() {
+                    db.multipart_suggestion(
+                        &format!("use {}unit literal{} instead", singular, plural),
+                        args_to_recover
+                            .iter()
+                            .map(|arg| (arg.span, "()".to_string()))
+                            .collect::<Vec<_>>(),
+                        applicability,
+                    );
+                } else {
+                    let plural = arg_snippets_without_empty_blocks.len() > 1;
+                    let empty_or_s = if plural { "s" } else { "" };
+                    let it_or_them = if plural { "them" } else { "it" };
+                    db.span_suggestion(
+                        expr.span,
+                        &format!(
+                            "{}move the expression{} in front of the call and replace {} with the unit literal `()`",
+                            or, empty_or_s, it_or_them
+                        ),
+                        sugg,
+                        applicability,
+                    );
+                }
             }
-            db.multipart_suggestion(
-                &format!("{}use {}unit literal{} instead", and, singular, plural),
-                args_to_recover
-                    .iter()
-                    .map(|arg| (arg.span, "()".to_string()))
-                    .collect::<Vec<_>>(),
-                applicability,
-            );
         },
     );
 }
@@ -2055,6 +2066,7 @@ impl PartialOrd for FullInt {
         })
     }
 }
+
 impl Ord for FullInt {
     #[must_use]
     fn cmp(&self, other: &Self) -> Ordering {
diff --git a/tests/ui/unit_arg.rs b/tests/ui/unit_arg.rs
index 2992abae775..2e2bd054e42 100644
--- a/tests/ui/unit_arg.rs
+++ b/tests/ui/unit_arg.rs
@@ -1,5 +1,5 @@
 #![warn(clippy::unit_arg)]
-#![allow(clippy::no_effect, unused_must_use, unused_variables)]
+#![allow(clippy::no_effect, unused_must_use, unused_variables, clippy::unused_unit)]
 
 use std::fmt::Debug;
 
@@ -47,6 +47,11 @@ fn bad() {
             foo(3);
         },
     );
+    // here Some(foo(2)) isn't the top level statement expression, wrap the suggestion in a block
+    None.or(Some(foo(2)));
+    // in this case, the suggestion can be inlined, no need for a surrounding block
+    // foo(()); foo(()) instead of { foo(()); foo(()) }
+    foo(foo(()))
 }
 
 fn ok() {
diff --git a/tests/ui/unit_arg.stderr b/tests/ui/unit_arg.stderr
index 56f6a855dfa..2a0cc1f18e2 100644
--- a/tests/ui/unit_arg.stderr
+++ b/tests/ui/unit_arg.stderr
@@ -11,16 +11,12 @@ help: remove the semicolon from the last statement in the block
    |
 LL |         1
    |
-help: or move the expression in front of the call...
+help: or move the expression in front of the call and replace it with the unit literal `()`
    |
 LL |     {
 LL |         1;
-LL |     };
+LL |     }; foo(());
    |
-help: ...and use a unit literal instead
-   |
-LL |     foo(());
-   |         ^^
 
 error: passing a unit value to a function
   --> $DIR/unit_arg.rs:26:5
@@ -28,14 +24,10 @@ error: passing a unit value to a function
 LL |     foo(foo(1));
    |     ^^^^^^^^^^^
    |
-help: move the expression in front of the call...
-   |
-LL |     foo(1);
+help: move the expression in front of the call and replace it with the unit literal `()`
    |
-help: ...and use a unit literal instead
-   |
-LL |     foo(());
-   |         ^^
+LL |     foo(1); foo(());
+   |     ^^^^^^^^^^^^^^^
 
 error: passing a unit value to a function
   --> $DIR/unit_arg.rs:27:5
@@ -50,17 +42,13 @@ help: remove the semicolon from the last statement in the block
    |
 LL |         foo(2)
    |
-help: or move the expression in front of the call...
+help: or move the expression in front of the call and replace it with the unit literal `()`
    |
 LL |     {
 LL |         foo(1);
 LL |         foo(2);
-LL |     };
-   |
-help: ...and use a unit literal instead
+LL |     }; foo(());
    |
-LL |     foo(());
-   |         ^^
 
 error: passing a unit value to a function
   --> $DIR/unit_arg.rs:32:5
@@ -74,16 +62,12 @@ help: remove the semicolon from the last statement in the block
    |
 LL |         1
    |
-help: or move the expression in front of the call...
+help: or move the expression in front of the call and replace it with the unit literal `()`
    |
 LL |     {
 LL |         1;
-LL |     };
+LL |     }; b.bar(());
    |
-help: ...and use a unit literal instead
-   |
-LL |     b.bar(());
-   |           ^^
 
 error: passing unit values to a function
   --> $DIR/unit_arg.rs:35:5
@@ -91,15 +75,10 @@ error: passing unit values to a function
 LL |     taking_multiple_units(foo(0), foo(1));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-help: move the expressions in front of the call...
-   |
-LL |     foo(0);
-LL |     foo(1);
-   |
-help: ...and use unit literals instead
+help: move the expressions in front of the call and replace them with the unit literal `()`
    |
-LL |     taking_multiple_units((), ());
-   |                           ^^  ^^
+LL |     foo(0); foo(1); taking_multiple_units((), ());
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: passing unit values to a function
   --> $DIR/unit_arg.rs:36:5
@@ -114,18 +93,13 @@ help: remove the semicolon from the last statement in the block
    |
 LL |         foo(2)
    |
-help: or move the expressions in front of the call...
+help: or move the expressions in front of the call and replace them with the unit literal `()`
    |
-LL |     foo(0);
-LL |     {
+LL |     foo(0); {
 LL |         foo(1);
 LL |         foo(2);
-LL |     };
-   |
-help: ...and use unit literals instead
+LL |     }; taking_multiple_units((), ());
    |
-LL |     taking_multiple_units((), ());
-   |                           ^^  ^^
 
 error: passing unit values to a function
   --> $DIR/unit_arg.rs:40:5
@@ -147,35 +121,56 @@ help: remove the semicolon from the last statement in the block
    |
 LL |             foo(3)
    |
-help: or move the expressions in front of the call...
+help: or move the expressions in front of the call and replace them with the unit literal `()`
    |
 LL |     {
-LL |         foo(0);
-LL |         foo(1);
-LL |     };
-LL |     {
-LL |         foo(2);
+LL |             foo(0);
+LL |             foo(1);
+LL |         }; {
+LL |             foo(2);
+LL |             foo(3);
  ...
-help: ...and use unit literals instead
+
+error: use of `or` followed by a function call
+  --> $DIR/unit_arg.rs:51:10
    |
-LL |         (),
-LL |         (),
+LL |     None.or(Some(foo(2)));
+   |          ^^^^^^^^^^^^^^^^ help: try this: `or_else(|| Some(foo(2)))`
    |
+   = note: `-D clippy::or-fun-call` implied by `-D warnings`
 
 error: passing a unit value to a function
-  --> $DIR/unit_arg.rs:82:5
+  --> $DIR/unit_arg.rs:51:13
    |
-LL |     Some(foo(1))
+LL |     None.or(Some(foo(2)));
+   |             ^^^^^^^^^^^^
+   |
+help: move the expression in front of the call and replace it with the unit literal `()`
+   |
+LL |     None.or({ foo(2); Some(()) });
+   |             ^^^^^^^^^^^^^^^^^^^^
+
+error: passing a unit value to a function
+  --> $DIR/unit_arg.rs:54:5
+   |
+LL |     foo(foo(()))
    |     ^^^^^^^^^^^^
    |
-help: move the expression in front of the call...
+help: move the expression in front of the call and replace it with the unit literal `()`
+   |
+LL |     foo(()); foo(())
+   |
+
+error: passing a unit value to a function
+  --> $DIR/unit_arg.rs:87:5
+   |
+LL |     Some(foo(1))
+   |     ^^^^^^^^^^^^
    |
-LL |     foo(1);
+help: move the expression in front of the call and replace it with the unit literal `()`
    |
-help: ...and use a unit literal instead
+LL |     foo(1); Some(())
    |
-LL |     Some(())
-   |          ^^
 
-error: aborting due to 8 previous errors
+error: aborting due to 11 previous errors
 
diff --git a/tests/ui/unit_arg_empty_blocks.stderr b/tests/ui/unit_arg_empty_blocks.stderr
index bb58483584b..4cbbc8b8cd4 100644
--- a/tests/ui/unit_arg_empty_blocks.stderr
+++ b/tests/ui/unit_arg_empty_blocks.stderr
@@ -22,14 +22,10 @@ error: passing unit values to a function
 LL |     taking_two_units({}, foo(0));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-help: move the expression in front of the call...
+help: move the expression in front of the call and replace it with the unit literal `()`
    |
-LL |     foo(0);
-   |
-help: ...and use unit literals instead
-   |
-LL |     taking_two_units((), ());
-   |                      ^^  ^^
+LL |     foo(0); taking_two_units((), ());
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: passing unit values to a function
   --> $DIR/unit_arg_empty_blocks.rs:18:5
@@ -37,15 +33,10 @@ error: passing unit values to a function
 LL |     taking_three_units({}, foo(0), foo(1));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-help: move the expressions in front of the call...
-   |
-LL |     foo(0);
-LL |     foo(1);
-   |
-help: ...and use unit literals instead
+help: move the expressions in front of the call and replace them with the unit literal `()`
    |
-LL |     taking_three_units((), (), ());
-   |                        ^^  ^^  ^^
+LL |     foo(0); foo(1); taking_three_units((), (), ());
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to 4 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 11efd75aeb8637bd5444104a57f1051b86c0d62b Mon Sep 17 00:00:00 2001
From: Michael Wright <mikerite@lavabit.com>
Date: Fri, 21 Aug 2020 07:23:04 +0200
Subject: Fix false negative in `option_as_ref_deref`

---
 clippy_lints/src/methods/mod.rs     | 7 ++++++-
 tests/ui/option_as_ref_deref.fixed  | 3 +++
 tests/ui/option_as_ref_deref.rs     | 3 +++
 tests/ui/option_as_ref_deref.stderr | 8 +++++++-
 4 files changed, 19 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 2498c48f067..22942d9fb0c 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3421,7 +3421,12 @@ fn lint_option_as_ref_deref<'tcx>(
     ];
 
     let is_deref = match map_args[1].kind {
-        hir::ExprKind::Path(ref expr_qpath) => deref_aliases.iter().any(|path| match_qpath(expr_qpath, path)),
+        hir::ExprKind::Path(ref expr_qpath) => cx
+            .qpath_res(expr_qpath, map_args[1].hir_id)
+            .opt_def_id()
+            .map_or(false, |fun_def_id| {
+                deref_aliases.iter().any(|path| match_def_path(cx, fun_def_id, path))
+            }),
         hir::ExprKind::Closure(_, _, body_id, _, _) => {
             let closure_body = cx.tcx.hir().body(body_id);
             let closure_expr = remove_blocks(&closure_body.value);
diff --git a/tests/ui/option_as_ref_deref.fixed b/tests/ui/option_as_ref_deref.fixed
index 076692e6445..07d7f0b45b0 100644
--- a/tests/ui/option_as_ref_deref.fixed
+++ b/tests/ui/option_as_ref_deref.fixed
@@ -38,4 +38,7 @@ fn main() {
 
     let _ = opt.as_deref();
     let _ = opt.as_deref_mut();
+
+    // Issue #5927
+    let _ = opt.as_deref();
 }
diff --git a/tests/ui/option_as_ref_deref.rs b/tests/ui/option_as_ref_deref.rs
index 3bf5f715f83..6ae059c9425 100644
--- a/tests/ui/option_as_ref_deref.rs
+++ b/tests/ui/option_as_ref_deref.rs
@@ -41,4 +41,7 @@ fn main() {
 
     let _ = opt.as_ref().map(|x| &**x);
     let _ = opt.as_mut().map(|x| &mut **x);
+
+    // Issue #5927
+    let _ = opt.as_ref().map(std::ops::Deref::deref);
 }
diff --git a/tests/ui/option_as_ref_deref.stderr b/tests/ui/option_as_ref_deref.stderr
index a106582a633..62f28232475 100644
--- a/tests/ui/option_as_ref_deref.stderr
+++ b/tests/ui/option_as_ref_deref.stderr
@@ -100,5 +100,11 @@ error: called `.as_mut().map(|x| &mut **x)` on an Option value. This can be done
 LL |     let _ = opt.as_mut().map(|x| &mut **x);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try using as_deref_mut instead: `opt.as_deref_mut()`
 
-error: aborting due to 16 previous errors
+error: called `.as_ref().map(std::ops::Deref::deref)` on an Option value. This can be done more directly by calling `opt.as_deref()` instead
+  --> $DIR/option_as_ref_deref.rs:46:13
+   |
+LL |     let _ = opt.as_ref().map(std::ops::Deref::deref);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try using as_deref instead: `opt.as_deref()`
+
+error: aborting due to 17 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 146e352db4eade947f6f358cd38c308e95783d7b Mon Sep 17 00:00:00 2001
From: Eduardo Broto <ebroto@tutanota.com>
Date: Sat, 22 Aug 2020 00:59:42 +0200
Subject: run cargo dev fmt

---
 clippy_lints/src/unnested_or_patterns.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unnested_or_patterns.rs b/clippy_lints/src/unnested_or_patterns.rs
index 0dca6a5da0c..7f4f16f8faf 100644
--- a/clippy_lints/src/unnested_or_patterns.rs
+++ b/clippy_lints/src/unnested_or_patterns.rs
@@ -340,7 +340,7 @@ fn take_pat(from: &mut Pat) -> Pat {
         id: DUMMY_NODE_ID,
         kind: Wild,
         span: DUMMY_SP,
-        tokens: None
+        tokens: None,
     };
     mem::replace(from, dummy)
 }
-- 
cgit 1.4.1-3-g733a5


From 191b6c798fa40334ec8898d07b4d28fd76743120 Mon Sep 17 00:00:00 2001
From: ThibsG <Thibs@debian.com>
Date: Sat, 22 Aug 2020 10:35:18 +0200
Subject: Don't lint if it has always inline attribute

---
 clippy_lints/src/trivially_copy_pass_by_ref.rs |  9 +++++++--
 tests/ui/trivially_copy_pass_by_ref.rs         | 18 ++++++++++++++++++
 tests/ui/trivially_copy_pass_by_ref.stderr     | 14 +++++++++++++-
 3 files changed, 38 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/trivially_copy_pass_by_ref.rs b/clippy_lints/src/trivially_copy_pass_by_ref.rs
index 7948d99162b..92f42168a1e 100644
--- a/clippy_lints/src/trivially_copy_pass_by_ref.rs
+++ b/clippy_lints/src/trivially_copy_pass_by_ref.rs
@@ -2,6 +2,7 @@ use std::cmp;
 
 use crate::utils::{is_copy, is_self_ty, snippet, span_lint_and_sugg};
 use if_chain::if_chain;
+use rustc_ast::attr;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_hir::intravisit::FnKind;
@@ -155,8 +156,12 @@ impl<'tcx> LateLintPass<'tcx> for TriviallyCopyPassByRef {
                     return;
                 }
                 for a in attrs {
-                    if a.meta_item_list().is_some() && a.has_name(sym!(proc_macro_derive)) {
-                        return;
+                    if let Some(meta_items) = a.meta_item_list() {
+                        if a.has_name(sym!(proc_macro_derive))
+                            || (a.has_name(sym!(inline)) && attr::list_contains_name(&meta_items, sym!(always)))
+                        {
+                            return;
+                        }
                     }
                 }
             },
diff --git a/tests/ui/trivially_copy_pass_by_ref.rs b/tests/ui/trivially_copy_pass_by_ref.rs
index 316426f1cf1..e7e0a31febc 100644
--- a/tests/ui/trivially_copy_pass_by_ref.rs
+++ b/tests/ui/trivially_copy_pass_by_ref.rs
@@ -97,6 +97,24 @@ mod issue3992 {
     pub fn c(d: &u16) {}
 }
 
+mod issue5876 {
+    // Don't lint here as it is always inlined
+    #[inline(always)]
+    fn foo_always(x: &i32) {
+        println!("{}", x);
+    }
+
+    #[inline(never)]
+    fn foo_never(x: &i32) {
+        println!("{}", x);
+    }
+
+    #[inline]
+    fn foo(x: &i32) {
+        println!("{}", x);
+    }
+}
+
 fn main() {
     let (mut foo, bar) = (Foo(0), Bar([0; 24]));
     let (mut a, b, c, x, y, z) = (0, 0, Bar([0; 24]), 0, Foo(0), 0);
diff --git a/tests/ui/trivially_copy_pass_by_ref.stderr b/tests/ui/trivially_copy_pass_by_ref.stderr
index be0914e4a79..ccc3cdb2b74 100644
--- a/tests/ui/trivially_copy_pass_by_ref.stderr
+++ b/tests/ui/trivially_copy_pass_by_ref.stderr
@@ -94,5 +94,17 @@ error: this argument (N byte) is passed by reference, but would be more efficien
 LL |     fn trait_method2(&self, _color: &Color);
    |                                     ^^^^^^ help: consider passing by value instead: `Color`
 
-error: aborting due to 15 previous errors
+error: this argument (N byte) is passed by reference, but would be more efficient if passed by value (limit: N byte)
+  --> $DIR/trivially_copy_pass_by_ref.rs:108:21
+   |
+LL |     fn foo_never(x: &i32) {
+   |                     ^^^^ help: consider passing by value instead: `i32`
+
+error: this argument (N byte) is passed by reference, but would be more efficient if passed by value (limit: N byte)
+  --> $DIR/trivially_copy_pass_by_ref.rs:113:15
+   |
+LL |     fn foo(x: &i32) {
+   |               ^^^^ help: consider passing by value instead: `i32`
+
+error: aborting due to 17 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 5b07b9ed61d1979320e9e63219b5d0d6f4b350f7 Mon Sep 17 00:00:00 2001
From: Christian Stefanescu <chris@0chris.com>
Date: Thu, 20 Aug 2020 22:49:39 +0200
Subject: Widen understanding of prelude import

Prelude imports are exempt from wildcard import warnings. Until now only
imports of the form

```
use ...::prelude::*;
```

were considered. This change makes it so that the segment `prelude` can
show up anywhere, for instance:

```
use ...::prelude::v1::*;
```

Fixes #5917
---
 clippy_lints/src/wildcard_imports.rs          | 7 ++-----
 tests/ui/auxiliary/wildcard_imports_helper.rs | 6 ++++++
 tests/ui/wildcard_imports.rs                  | 2 ++
 3 files changed, 10 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/wildcard_imports.rs b/clippy_lints/src/wildcard_imports.rs
index e7eb7c2e980..717741129a8 100644
--- a/clippy_lints/src/wildcard_imports.rs
+++ b/clippy_lints/src/wildcard_imports.rs
@@ -195,13 +195,10 @@ impl WildcardImports {
     }
 }
 
-// Allow "...prelude::*" imports.
+// Allow "...prelude::..::*" imports.
 // Many crates have a prelude, and it is imported as a glob by design.
 fn is_prelude_import(segments: &[PathSegment<'_>]) -> bool {
-    segments
-        .iter()
-        .last()
-        .map_or(false, |ps| ps.ident.as_str() == "prelude")
+    segments.iter().filter(|ps| ps.ident.as_str() == "prelude").count() > 0
 }
 
 // Allow "super::*" imports in tests.
diff --git a/tests/ui/auxiliary/wildcard_imports_helper.rs b/tests/ui/auxiliary/wildcard_imports_helper.rs
index 414477aedd7..d75cdd625f9 100644
--- a/tests/ui/auxiliary/wildcard_imports_helper.rs
+++ b/tests/ui/auxiliary/wildcard_imports_helper.rs
@@ -19,3 +19,9 @@ mod extern_exports {
         A,
     }
 }
+
+pub mod prelude {
+    pub mod v1 {
+        pub struct PreludeModAnywhere;
+    }
+}
diff --git a/tests/ui/wildcard_imports.rs b/tests/ui/wildcard_imports.rs
index 3ad1a29aeba..1f261159f4a 100644
--- a/tests/ui/wildcard_imports.rs
+++ b/tests/ui/wildcard_imports.rs
@@ -20,6 +20,7 @@ use wildcard_imports_helper::inner::inner_for_self_import::*;
 use wildcard_imports_helper::*;
 
 use std::io::prelude::*;
+use wildcard_imports_helper::prelude::v1::*;
 
 struct ReadFoo;
 
@@ -75,6 +76,7 @@ fn main() {
     let _ = A;
     let _ = inner_struct_mod::C;
     let _ = ExternA;
+    let _ = PreludeModAnywhere;
 
     double_struct_import_test!();
     double_struct_import_test!();
-- 
cgit 1.4.1-3-g733a5


From e615a26ae4fe293cda83961470907e78e4b2ee75 Mon Sep 17 00:00:00 2001
From: Christian Stefanescu <chris@0chris.com>
Date: Fri, 21 Aug 2020 14:03:42 +0200
Subject: Use more elegant way to check for prelude string

---
 clippy_lints/src/wildcard_imports.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/wildcard_imports.rs b/clippy_lints/src/wildcard_imports.rs
index 717741129a8..5683a71efea 100644
--- a/clippy_lints/src/wildcard_imports.rs
+++ b/clippy_lints/src/wildcard_imports.rs
@@ -198,7 +198,7 @@ impl WildcardImports {
 // Allow "...prelude::..::*" imports.
 // Many crates have a prelude, and it is imported as a glob by design.
 fn is_prelude_import(segments: &[PathSegment<'_>]) -> bool {
-    segments.iter().filter(|ps| ps.ident.as_str() == "prelude").count() > 0
+    segments.iter().any(|ps| ps.ident.as_str() == "prelude")
 }
 
 // Allow "super::*" imports in tests.
-- 
cgit 1.4.1-3-g733a5


From e8d33d73dc3f9d0daf9b3affe65a2431f5a3e13a Mon Sep 17 00:00:00 2001
From: Michael Wright <mikerite@lavabit.com>
Date: Sun, 23 Aug 2020 07:50:59 +0200
Subject: Fix `let_and_return` bad suggestion

Add a cast to the suggestion when the return expression has adjustments.
These adjustments are lost when the suggestion is applied.

This is similar to the problem in issue #4437.

Closes #5729
---
 clippy_lints/src/returns.rs    |  5 ++++-
 tests/ui/let_and_return.rs     | 21 +++++++++++++++++++++
 tests/ui/let_and_return.stderr | 16 +++++++++++++++-
 3 files changed, 40 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
index 3c5541e64b4..a6e4252a0c8 100644
--- a/clippy_lints/src/returns.rs
+++ b/clippy_lints/src/returns.rs
@@ -99,7 +99,10 @@ impl<'tcx> LateLintPass<'tcx> for Return {
                     |err| {
                         err.span_label(local.span, "unnecessary `let` binding");
 
-                        if let Some(snippet) = snippet_opt(cx, initexpr.span) {
+                        if let Some(mut snippet) = snippet_opt(cx, initexpr.span) {
+                            if !cx.typeck_results().expr_adjustments(&retexpr).is_empty() {
+                                snippet.push_str(" as _");
+                            }
                             err.multipart_suggestion(
                                 "return the expression directly",
                                 vec![
diff --git a/tests/ui/let_and_return.rs b/tests/ui/let_and_return.rs
index 09614b8c1ad..73e550b3df8 100644
--- a/tests/ui/let_and_return.rs
+++ b/tests/ui/let_and_return.rs
@@ -135,4 +135,25 @@ mod no_lint_if_stmt_borrows {
     }
 }
 
+mod issue_5729 {
+    use std::sync::Arc;
+
+    trait Foo {}
+
+    trait FooStorage {
+        fn foo_cloned(&self) -> Arc<dyn Foo>;
+    }
+
+    struct FooStorageImpl<T: Foo> {
+        foo: Arc<T>,
+    }
+
+    impl<T: Foo + 'static> FooStorage for FooStorageImpl<T> {
+        fn foo_cloned(&self) -> Arc<dyn Foo> {
+            let clone = Arc::clone(&self.foo);
+            clone
+        }
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/let_and_return.stderr b/tests/ui/let_and_return.stderr
index eacf948b392..fe878e5f206 100644
--- a/tests/ui/let_and_return.stderr
+++ b/tests/ui/let_and_return.stderr
@@ -27,5 +27,19 @@ LL |
 LL |         5
    |
 
-error: aborting due to 2 previous errors
+error: returning the result of a `let` binding from a block
+  --> $DIR/let_and_return.rs:154:13
+   |
+LL |             let clone = Arc::clone(&self.foo);
+   |             ---------------------------------- unnecessary `let` binding
+LL |             clone
+   |             ^^^^^
+   |
+help: return the expression directly
+   |
+LL |             
+LL |             Arc::clone(&self.foo) as _
+   |
+
+error: aborting due to 3 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 8776db9f6d5163ca40232336dc51ad77eeb2b5e5 Mon Sep 17 00:00:00 2001
From: Eduardo Broto <ebroto@tutanota.com>
Date: Sun, 23 Aug 2020 12:05:34 +0200
Subject: Fix ICE in `repeat_once` lint

---
 clippy_lints/src/repeat_once.rs | 14 +++++++-------
 tests/ui/crashes/ice-5944.rs    | 13 +++++++++++++
 2 files changed, 20 insertions(+), 7 deletions(-)
 create mode 100644 tests/ui/crashes/ice-5944.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/repeat_once.rs b/clippy_lints/src/repeat_once.rs
index 77c206002ea..c0890018d46 100644
--- a/clippy_lints/src/repeat_once.rs
+++ b/clippy_lints/src/repeat_once.rs
@@ -39,12 +39,12 @@ declare_lint_pass!(RepeatOnce => [REPEAT_ONCE]);
 impl<'tcx> LateLintPass<'tcx> for RepeatOnce {
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &'tcx Expr<'_>) {
         if_chain! {
-            if let ExprKind::MethodCall(ref path, _, ref args, _) = expr.kind;
+            if let ExprKind::MethodCall(path, _, [receiver, count], _) = &expr.kind;
             if path.ident.name == sym!(repeat);
-            if let Some(Constant::Int(1)) = constant_context(cx, cx.typeck_results()).expr(&args[1]);
-            if !in_macro(args[0].span);
+            if let Some(Constant::Int(1)) = constant_context(cx, cx.typeck_results()).expr(&count);
+            if !in_macro(receiver.span);
             then {
-                let ty = walk_ptrs_ty(cx.typeck_results().expr_ty(&args[0]));
+                let ty = walk_ptrs_ty(cx.typeck_results().expr_ty(&receiver));
                 if ty.is_str() {
                     span_lint_and_sugg(
                         cx,
@@ -52,7 +52,7 @@ impl<'tcx> LateLintPass<'tcx> for RepeatOnce {
                         expr.span,
                         "calling `repeat(1)` on str",
                         "consider using `.to_string()` instead",
-                        format!("{}.to_string()", snippet(cx, args[0].span, r#""...""#)),
+                        format!("{}.to_string()", snippet(cx, receiver.span, r#""...""#)),
                         Applicability::MachineApplicable,
                     );
                 } else if ty.builtin_index().is_some() {
@@ -62,7 +62,7 @@ impl<'tcx> LateLintPass<'tcx> for RepeatOnce {
                         expr.span,
                         "calling `repeat(1)` on slice",
                         "consider using `.to_vec()` instead",
-                        format!("{}.to_vec()", snippet(cx, args[0].span, r#""...""#)),
+                        format!("{}.to_vec()", snippet(cx, receiver.span, r#""...""#)),
                         Applicability::MachineApplicable,
                     );
                 } else if is_type_diagnostic_item(cx, ty, sym!(string_type)) {
@@ -72,7 +72,7 @@ impl<'tcx> LateLintPass<'tcx> for RepeatOnce {
                         expr.span,
                         "calling `repeat(1)` on a string literal",
                         "consider using `.clone()` instead",
-                        format!("{}.clone()", snippet(cx, args[0].span, r#""...""#)),
+                        format!("{}.clone()", snippet(cx, receiver.span, r#""...""#)),
                         Applicability::MachineApplicable,
                     );
                 }
diff --git a/tests/ui/crashes/ice-5944.rs b/tests/ui/crashes/ice-5944.rs
new file mode 100644
index 00000000000..5caf29c6197
--- /dev/null
+++ b/tests/ui/crashes/ice-5944.rs
@@ -0,0 +1,13 @@
+#![warn(clippy::repeat_once)]
+
+trait Repeat {
+    fn repeat(&self) {}
+}
+
+impl Repeat for usize {
+    fn repeat(&self) {}
+}
+
+fn main() {
+    let _ = 42.repeat();
+}
-- 
cgit 1.4.1-3-g733a5


From 91b200c62b7c464cb890c68230ab2d74605a60d0 Mon Sep 17 00:00:00 2001
From: rail <12975677+rail-rain@users.noreply.github.com>
Date: Sun, 23 Aug 2020 22:16:24 +1200
Subject: Fix fp in `borrow_interior_mutable_const`

Fix false positive when referencing a field behind a pointer.
---
 clippy_lints/src/non_copy_const.rs            | 15 +++++++++++-
 tests/ui/borrow_interior_mutable_const.rs     | 35 ++++++++++++++++++++++++++-
 tests/ui/borrow_interior_mutable_const.stderr | 32 ++++++++++++------------
 3 files changed, 64 insertions(+), 18 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/non_copy_const.rs b/clippy_lints/src/non_copy_const.rs
index 031d69e86a1..f1df634701d 100644
--- a/clippy_lints/src/non_copy_const.rs
+++ b/clippy_lints/src/non_copy_const.rs
@@ -211,8 +211,21 @@ impl<'tcx> LateLintPass<'tcx> for NonCopyConst {
                             needs_check_adjustment = false;
                         },
                         ExprKind::Field(..) => {
-                            dereferenced_expr = parent_expr;
                             needs_check_adjustment = true;
+
+                            // Check whether implicit dereferences happened;
+                            // if so, no need to go further up
+                            // because of the same reason as the `ExprKind::Unary` case.
+                            if cx
+                                .typeck_results()
+                                .expr_adjustments(dereferenced_expr)
+                                .iter()
+                                .any(|adj| matches!(adj.kind, Adjust::Deref(_)))
+                            {
+                                break;
+                            }
+
+                            dereferenced_expr = parent_expr;
                         },
                         ExprKind::Index(e, _) if ptr::eq(&**e, cur_expr) => {
                             // `e[i]` => desugared to `*Index::index(&e, i)`,
diff --git a/tests/ui/borrow_interior_mutable_const.rs b/tests/ui/borrow_interior_mutable_const.rs
index fef9f4f39f8..310769cd002 100644
--- a/tests/ui/borrow_interior_mutable_const.rs
+++ b/tests/ui/borrow_interior_mutable_const.rs
@@ -2,7 +2,7 @@
 #![allow(clippy::declare_interior_mutable_const, clippy::ref_in_deref)]
 
 use std::borrow::Cow;
-use std::cell::Cell;
+use std::cell::{Cell, UnsafeCell};
 use std::fmt::Display;
 use std::sync::atomic::{AtomicUsize, Ordering};
 use std::sync::Once;
@@ -30,6 +30,37 @@ impl Trait<u32> for u64 {
     const ATOMIC: AtomicUsize = AtomicUsize::new(9);
 }
 
+// This is just a pointer that can be safely dereferended,
+// it's semantically the same as `&'static T`;
+// but it isn't allowed make a static reference from an arbitrary integer value at the moment.
+// For more information, please see the issue #5918.
+pub struct StaticRef<T> {
+    ptr: *const T,
+}
+
+impl<T> StaticRef<T> {
+    /// Create a new `StaticRef` from a raw pointer
+    ///
+    /// ## Safety
+    ///
+    /// Callers must pass in a reference to statically allocated memory which
+    /// does not overlap with other values.
+    pub const unsafe fn new(ptr: *const T) -> StaticRef<T> {
+        StaticRef { ptr }
+    }
+}
+
+impl<T> std::ops::Deref for StaticRef<T> {
+    type Target = T;
+
+    fn deref(&self) -> &'static T {
+        unsafe { &*self.ptr }
+    }
+}
+
+// use a tuple to make sure referencing a field behind a pointer isn't linted.
+const CELL_REF: StaticRef<(UnsafeCell<u32>,)> = unsafe { StaticRef::new(std::ptr::null()) };
+
 fn main() {
     ATOMIC.store(1, Ordering::SeqCst); //~ ERROR interior mutability
     assert_eq!(ATOMIC.load(Ordering::SeqCst), 5); //~ ERROR interior mutability
@@ -82,4 +113,6 @@ fn main() {
     assert_eq!(u64::ATOMIC.load(Ordering::SeqCst), 9); //~ ERROR interior mutability
 
     assert_eq!(NO_ANN.to_string(), "70"); // should never lint this.
+
+    let _ = &CELL_REF.0;
 }
diff --git a/tests/ui/borrow_interior_mutable_const.stderr b/tests/ui/borrow_interior_mutable_const.stderr
index dc738064a17..1e0b3e4d20a 100644
--- a/tests/ui/borrow_interior_mutable_const.stderr
+++ b/tests/ui/borrow_interior_mutable_const.stderr
@@ -1,5 +1,5 @@
 error: a `const` item with interior mutability should not be borrowed
-  --> $DIR/borrow_interior_mutable_const.rs:34:5
+  --> $DIR/borrow_interior_mutable_const.rs:65:5
    |
 LL |     ATOMIC.store(1, Ordering::SeqCst); //~ ERROR interior mutability
    |     ^^^^^^
@@ -8,7 +8,7 @@ LL |     ATOMIC.store(1, Ordering::SeqCst); //~ ERROR interior mutability
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> $DIR/borrow_interior_mutable_const.rs:35:16
+  --> $DIR/borrow_interior_mutable_const.rs:66:16
    |
 LL |     assert_eq!(ATOMIC.load(Ordering::SeqCst), 5); //~ ERROR interior mutability
    |                ^^^^^^
@@ -16,7 +16,7 @@ LL |     assert_eq!(ATOMIC.load(Ordering::SeqCst), 5); //~ ERROR interior mutabi
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> $DIR/borrow_interior_mutable_const.rs:38:22
+  --> $DIR/borrow_interior_mutable_const.rs:69:22
    |
 LL |     let _once_ref = &ONCE_INIT; //~ ERROR interior mutability
    |                      ^^^^^^^^^
@@ -24,7 +24,7 @@ LL |     let _once_ref = &ONCE_INIT; //~ ERROR interior mutability
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> $DIR/borrow_interior_mutable_const.rs:39:25
+  --> $DIR/borrow_interior_mutable_const.rs:70:25
    |
 LL |     let _once_ref_2 = &&ONCE_INIT; //~ ERROR interior mutability
    |                         ^^^^^^^^^
@@ -32,7 +32,7 @@ LL |     let _once_ref_2 = &&ONCE_INIT; //~ ERROR interior mutability
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> $DIR/borrow_interior_mutable_const.rs:40:27
+  --> $DIR/borrow_interior_mutable_const.rs:71:27
    |
 LL |     let _once_ref_4 = &&&&ONCE_INIT; //~ ERROR interior mutability
    |                           ^^^^^^^^^
@@ -40,7 +40,7 @@ LL |     let _once_ref_4 = &&&&ONCE_INIT; //~ ERROR interior mutability
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> $DIR/borrow_interior_mutable_const.rs:41:26
+  --> $DIR/borrow_interior_mutable_const.rs:72:26
    |
 LL |     let _once_mut = &mut ONCE_INIT; //~ ERROR interior mutability
    |                          ^^^^^^^^^
@@ -48,7 +48,7 @@ LL |     let _once_mut = &mut ONCE_INIT; //~ ERROR interior mutability
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> $DIR/borrow_interior_mutable_const.rs:52:14
+  --> $DIR/borrow_interior_mutable_const.rs:83:14
    |
 LL |     let _ = &ATOMIC_TUPLE; //~ ERROR interior mutability
    |              ^^^^^^^^^^^^
@@ -56,7 +56,7 @@ LL |     let _ = &ATOMIC_TUPLE; //~ ERROR interior mutability
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> $DIR/borrow_interior_mutable_const.rs:53:14
+  --> $DIR/borrow_interior_mutable_const.rs:84:14
    |
 LL |     let _ = &ATOMIC_TUPLE.0; //~ ERROR interior mutability
    |              ^^^^^^^^^^^^
@@ -64,7 +64,7 @@ LL |     let _ = &ATOMIC_TUPLE.0; //~ ERROR interior mutability
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> $DIR/borrow_interior_mutable_const.rs:54:19
+  --> $DIR/borrow_interior_mutable_const.rs:85:19
    |
 LL |     let _ = &(&&&&ATOMIC_TUPLE).0; //~ ERROR interior mutability
    |                   ^^^^^^^^^^^^
@@ -72,7 +72,7 @@ LL |     let _ = &(&&&&ATOMIC_TUPLE).0; //~ ERROR interior mutability
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> $DIR/borrow_interior_mutable_const.rs:55:14
+  --> $DIR/borrow_interior_mutable_const.rs:86:14
    |
 LL |     let _ = &ATOMIC_TUPLE.0[0]; //~ ERROR interior mutability
    |              ^^^^^^^^^^^^
@@ -80,7 +80,7 @@ LL |     let _ = &ATOMIC_TUPLE.0[0]; //~ ERROR interior mutability
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> $DIR/borrow_interior_mutable_const.rs:56:13
+  --> $DIR/borrow_interior_mutable_const.rs:87:13
    |
 LL |     let _ = ATOMIC_TUPLE.0[0].load(Ordering::SeqCst); //~ ERROR interior mutability
    |             ^^^^^^^^^^^^
@@ -88,7 +88,7 @@ LL |     let _ = ATOMIC_TUPLE.0[0].load(Ordering::SeqCst); //~ ERROR interior mu
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> $DIR/borrow_interior_mutable_const.rs:62:13
+  --> $DIR/borrow_interior_mutable_const.rs:93:13
    |
 LL |     let _ = ATOMIC_TUPLE.0[0]; //~ ERROR interior mutability
    |             ^^^^^^^^^^^^
@@ -96,7 +96,7 @@ LL |     let _ = ATOMIC_TUPLE.0[0]; //~ ERROR interior mutability
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> $DIR/borrow_interior_mutable_const.rs:67:5
+  --> $DIR/borrow_interior_mutable_const.rs:98:5
    |
 LL |     CELL.set(2); //~ ERROR interior mutability
    |     ^^^^
@@ -104,7 +104,7 @@ LL |     CELL.set(2); //~ ERROR interior mutability
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> $DIR/borrow_interior_mutable_const.rs:68:16
+  --> $DIR/borrow_interior_mutable_const.rs:99:16
    |
 LL |     assert_eq!(CELL.get(), 6); //~ ERROR interior mutability
    |                ^^^^
@@ -112,7 +112,7 @@ LL |     assert_eq!(CELL.get(), 6); //~ ERROR interior mutability
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> $DIR/borrow_interior_mutable_const.rs:81:5
+  --> $DIR/borrow_interior_mutable_const.rs:112:5
    |
 LL |     u64::ATOMIC.store(5, Ordering::SeqCst); //~ ERROR interior mutability
    |     ^^^^^^^^^^^
@@ -120,7 +120,7 @@ LL |     u64::ATOMIC.store(5, Ordering::SeqCst); //~ ERROR interior mutability
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> $DIR/borrow_interior_mutable_const.rs:82:16
+  --> $DIR/borrow_interior_mutable_const.rs:113:16
    |
 LL |     assert_eq!(u64::ATOMIC.load(Ordering::SeqCst), 9); //~ ERROR interior mutability
    |                ^^^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From b2c226679251bb795d786d7cdd11d2e2c9d0e685 Mon Sep 17 00:00:00 2001
From: Takayuki Nakata <f.seasons017@gmail.com>
Date: Tue, 18 Aug 2020 23:00:21 +0900
Subject: Fix FP for `redundant_closure_call`

Visit the nested things like function body when checking closure call.
---
 clippy_lints/src/redundant_closure_call.rs | 17 +++++++++++------
 tests/ui/redundant_closure_call_late.rs    | 12 ++++++++++++
 2 files changed, 23 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/redundant_closure_call.rs b/clippy_lints/src/redundant_closure_call.rs
index 8aa478ea2d6..d8fad217e5a 100644
--- a/clippy_lints/src/redundant_closure_call.rs
+++ b/clippy_lints/src/redundant_closure_call.rs
@@ -95,12 +95,17 @@ impl EarlyLintPass for RedundantClosureCall {
 
 impl<'tcx> LateLintPass<'tcx> for RedundantClosureCall {
     fn check_block(&mut self, cx: &LateContext<'tcx>, block: &'tcx hir::Block<'_>) {
-        fn count_closure_usage<'tcx>(block: &'tcx hir::Block<'_>, path: &'tcx hir::Path<'tcx>) -> usize {
-            struct ClosureUsageCount<'tcx> {
+        fn count_closure_usage<'a, 'tcx>(
+            cx: &'a LateContext<'tcx>,
+            block: &'tcx hir::Block<'_>,
+            path: &'tcx hir::Path<'tcx>,
+        ) -> usize {
+            struct ClosureUsageCount<'a, 'tcx> {
+                cx: &'a LateContext<'tcx>,
                 path: &'tcx hir::Path<'tcx>,
                 count: usize,
             };
-            impl<'tcx> hir_visit::Visitor<'tcx> for ClosureUsageCount<'tcx> {
+            impl<'a, 'tcx> hir_visit::Visitor<'tcx> for ClosureUsageCount<'a, 'tcx> {
                 type Map = Map<'tcx>;
 
                 fn visit_expr(&mut self, expr: &'tcx hir::Expr<'tcx>) {
@@ -117,10 +122,10 @@ impl<'tcx> LateLintPass<'tcx> for RedundantClosureCall {
                 }
 
                 fn nested_visit_map(&mut self) -> hir_visit::NestedVisitorMap<Self::Map> {
-                    hir_visit::NestedVisitorMap::None
+                    hir_visit::NestedVisitorMap::OnlyBodies(self.cx.tcx.hir())
                 }
             };
-            let mut closure_usage_count = ClosureUsageCount { path, count: 0 };
+            let mut closure_usage_count = ClosureUsageCount { cx, path, count: 0 };
             closure_usage_count.visit_block(block);
             closure_usage_count.count
         }
@@ -136,7 +141,7 @@ impl<'tcx> LateLintPass<'tcx> for RedundantClosureCall {
                 if let hir::ExprKind::Call(ref closure, _) = call.kind;
                 if let hir::ExprKind::Path(hir::QPath::Resolved(_, ref path)) = closure.kind;
                 if ident == path.segments[0].ident;
-                if count_closure_usage(block, path) == 1;
+                if count_closure_usage(cx, block, path) == 1;
                 then {
                     span_lint(
                         cx,
diff --git a/tests/ui/redundant_closure_call_late.rs b/tests/ui/redundant_closure_call_late.rs
index e29a1dce0c7..1f4864b7289 100644
--- a/tests/ui/redundant_closure_call_late.rs
+++ b/tests/ui/redundant_closure_call_late.rs
@@ -24,4 +24,16 @@ fn main() {
     let shadowed_closure = || 2;
     i = shadowed_closure();
     i = shadowed_closure();
+
+    // Fix FP in #5916
+    let mut x;
+    let create = || 2 * 2;
+    x = create();
+    fun(move || {
+        x = create();
+    })
+}
+
+fn fun<T: 'static + FnMut()>(mut f: T) {
+    f();
 }
-- 
cgit 1.4.1-3-g733a5


From 9fe0ac36a53dfba14f5f33f5bab2fd243fb2c18e Mon Sep 17 00:00:00 2001
From: Takayuki Nakata <f.seasons017@gmail.com>
Date: Mon, 24 Aug 2020 10:11:53 +0900
Subject: Avoid period in lint message according to convention

---
 clippy_lints/src/redundant_closure_call.rs     | 2 +-
 tests/ui/redundant_closure_call_early.stderr   | 4 ++--
 tests/ui/redundant_closure_call_fixable.stderr | 2 +-
 3 files changed, 4 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/redundant_closure_call.rs b/clippy_lints/src/redundant_closure_call.rs
index d8fad217e5a..49cb2ffc4e3 100644
--- a/clippy_lints/src/redundant_closure_call.rs
+++ b/clippy_lints/src/redundant_closure_call.rs
@@ -77,7 +77,7 @@ impl EarlyLintPass for RedundantClosureCall {
                         cx,
                         REDUNDANT_CLOSURE_CALL,
                         expr.span,
-                        "try not to call a closure in the expression where it is declared.",
+                        "try not to call a closure in the expression where it is declared",
                         |diag| {
                             if decl.inputs.is_empty() {
                                 let mut app = Applicability::MachineApplicable;
diff --git a/tests/ui/redundant_closure_call_early.stderr b/tests/ui/redundant_closure_call_early.stderr
index 79f27663461..2735e41738f 100644
--- a/tests/ui/redundant_closure_call_early.stderr
+++ b/tests/ui/redundant_closure_call_early.stderr
@@ -1,4 +1,4 @@
-error: try not to call a closure in the expression where it is declared.
+error: try not to call a closure in the expression where it is declared
   --> $DIR/redundant_closure_call_early.rs:9:17
    |
 LL |     let mut k = (|m| m + 1)(i);
@@ -6,7 +6,7 @@ LL |     let mut k = (|m| m + 1)(i);
    |
    = note: `-D clippy::redundant-closure-call` implied by `-D warnings`
 
-error: try not to call a closure in the expression where it is declared.
+error: try not to call a closure in the expression where it is declared
   --> $DIR/redundant_closure_call_early.rs:12:9
    |
 LL |     k = (|a, b| a * b)(1, 5);
diff --git a/tests/ui/redundant_closure_call_fixable.stderr b/tests/ui/redundant_closure_call_fixable.stderr
index 644161d9f5d..afd704ef12a 100644
--- a/tests/ui/redundant_closure_call_fixable.stderr
+++ b/tests/ui/redundant_closure_call_fixable.stderr
@@ -1,4 +1,4 @@
-error: try not to call a closure in the expression where it is declared.
+error: try not to call a closure in the expression where it is declared
   --> $DIR/redundant_closure_call_fixable.rs:7:13
    |
 LL |     let a = (|| 42)();
-- 
cgit 1.4.1-3-g733a5


From 3d820f71fe820c0bb7a1204e28ce549407a937cc Mon Sep 17 00:00:00 2001
From: ThibsG <Thibs@debian.com>
Date: Mon, 24 Aug 2020 14:01:27 +0200
Subject: Fix incorrect suggestion when `clone_on_ref_ptr` is triggered in
 macros

---
 clippy_lints/src/methods/mod.rs   | 13 +++++++------
 tests/ui/unnecessary_clone.rs     | 18 ++++++++++++++++++
 tests/ui/unnecessary_clone.stderr |  8 +++++++-
 3 files changed, 32 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 22942d9fb0c..4f0a533592c 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -2150,18 +2150,19 @@ fn lint_clone_on_ref_ptr(cx: &LateContext<'_>, expr: &hir::Expr<'_>, arg: &hir::
             return;
         };
 
+        let snippet = if in_macro(arg.span) {
+            snippet_with_macro_callsite(cx, arg.span, "_")
+        } else {
+            snippet(cx, arg.span, "_")
+        };
+
         span_lint_and_sugg(
             cx,
             CLONE_ON_REF_PTR,
             expr.span,
             "using `.clone()` on a ref-counted pointer",
             "try this",
-            format!(
-                "{}::<{}>::clone(&{})",
-                caller_type,
-                subst.type_at(0),
-                snippet(cx, arg.span, "_")
-            ),
+            format!("{}::<{}>::clone(&{})", caller_type, subst.type_at(0), snippet),
             Applicability::Unspecified, // Sometimes unnecessary ::<_> after Rc/Arc/Weak
         );
     }
diff --git a/tests/ui/unnecessary_clone.rs b/tests/ui/unnecessary_clone.rs
index 2c9d4d39e6c..e785ac02feb 100644
--- a/tests/ui/unnecessary_clone.rs
+++ b/tests/ui/unnecessary_clone.rs
@@ -90,3 +90,21 @@ mod many_derefs {
         let _ = &encoded.clone();
     }
 }
+
+mod issue2076 {
+    use std::rc::Rc;
+
+    macro_rules! try_opt {
+        ($expr: expr) => {
+            match $expr {
+                Some(value) => value,
+                None => return None,
+            }
+        };
+    }
+
+    fn func() -> Option<Rc<u8>> {
+        let rc = Rc::new(42);
+        Some(try_opt!(Some(rc)).clone())
+    }
+}
diff --git a/tests/ui/unnecessary_clone.stderr b/tests/ui/unnecessary_clone.stderr
index 113fab69009..5ffa6c4fd06 100644
--- a/tests/ui/unnecessary_clone.stderr
+++ b/tests/ui/unnecessary_clone.stderr
@@ -96,5 +96,11 @@ help: or try being explicit if you are sure, that you want to clone a reference
 LL |         let _ = &<&[u8]>::clone(encoded);
    |                  ^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 11 previous errors
+error: using `.clone()` on a ref-counted pointer
+  --> $DIR/unnecessary_clone.rs:108:14
+   |
+LL |         Some(try_opt!(Some(rc)).clone())
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `Rc::<u8>::clone(&try_opt!(Some(rc)))`
+
+error: aborting due to 12 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 680c68153bced747c90947e0265c92076edcb838 Mon Sep 17 00:00:00 2001
From: Bastian <bastian@cmbt.de>
Date: Mon, 24 Aug 2020 16:31:51 +0200
Subject: Added a lint which corrects expressions like (a - b) < f32::EPSILON

---
 CHANGELOG.md                                   |   1 +
 clippy_lints/src/float_equality_without_abs.rs | 112 +++++++++++++++++++++++++
 clippy_lints/src/lib.rs                        |   5 ++
 src/lintlist/mod.rs                            |   7 ++
 tests/ui/float_equality_without_abs.rs         |  31 +++++++
 tests/ui/float_equality_without_abs.stderr     |  70 ++++++++++++++++
 6 files changed, 226 insertions(+)
 create mode 100644 clippy_lints/src/float_equality_without_abs.rs
 create mode 100644 tests/ui/float_equality_without_abs.rs
 create mode 100644 tests/ui/float_equality_without_abs.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5ce63c0a157..a5da0f7b767 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1498,6 +1498,7 @@ Released 2018-09-13
 [`float_arithmetic`]: https://rust-lang.github.io/rust-clippy/master/index.html#float_arithmetic
 [`float_cmp`]: https://rust-lang.github.io/rust-clippy/master/index.html#float_cmp
 [`float_cmp_const`]: https://rust-lang.github.io/rust-clippy/master/index.html#float_cmp_const
+[`float_equality_without_abs`]: https://rust-lang.github.io/rust-clippy/master/index.html#float_equality_without_abs
 [`fn_address_comparisons`]: https://rust-lang.github.io/rust-clippy/master/index.html#fn_address_comparisons
 [`fn_params_excessive_bools`]: https://rust-lang.github.io/rust-clippy/master/index.html#fn_params_excessive_bools
 [`fn_to_numeric_cast`]: https://rust-lang.github.io/rust-clippy/master/index.html#fn_to_numeric_cast
diff --git a/clippy_lints/src/float_equality_without_abs.rs b/clippy_lints/src/float_equality_without_abs.rs
new file mode 100644
index 00000000000..c8e53ce6f95
--- /dev/null
+++ b/clippy_lints/src/float_equality_without_abs.rs
@@ -0,0 +1,112 @@
+use crate::utils::{match_qpath, snippet, span_lint_and_sugg};
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir::{BinOpKind, Expr, ExprKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::source_map::Spanned;
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for statements of the form `(a - b) < f32::EPSILON` or
+     /// `(a - b) < f64::EPSILON`. Notes the missing `.abs()`.
+     ///
+     /// **Why is this bad?** The code without `.abs()` is more likely to have a bug.
+     ///
+     /// **Known problems:** If the user can ensure that b is larger than a, the `.abs()` is
+     /// technically unneccessary. However, it will make the code more robust and doesn't have any
+     /// large performance implications. If the abs call was deliberately left out for performance
+     /// reasons, it is probably better to state this explicitly in the code, which then can be done
+     /// with an allow.
+     ///
+     /// **Example:**
+     ///
+     /// ```rust
+     /// pub fn is_roughly_equal(a: f32, b: f32) -> bool {
+     ///     (a - b) < f32::EPSILON
+     /// }
+     /// ```
+     /// Use instead:
+     /// ```rust
+     /// pub fn is_roughly_equal(a: f32, b: f32) -> bool {
+     ///     (a - b).abs() < f32::EPSILON
+     /// }
+     /// ```
+    pub FLOAT_EQUALITY_WITHOUT_ABS,
+    correctness,
+    "float equality check without `.abs()`"
+}
+
+declare_lint_pass!(FloatEqualityWithoutAbs => [FLOAT_EQUALITY_WITHOUT_ABS]);
+
+impl<'tcx> LateLintPass<'tcx> for FloatEqualityWithoutAbs {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        let lhs;
+        let rhs;
+
+        // check if expr is a binary expression with a lt or gt operator
+        if let ExprKind::Binary(op, ref left, ref right) = expr.kind {
+            match op.node {
+                BinOpKind::Lt => {
+                    lhs = left;
+                    rhs = right;
+                },
+                BinOpKind::Gt => {
+                    lhs = right;
+                    rhs = left;
+                },
+                _ => return,
+            };
+        } else {
+            return;
+        }
+
+        if_chain! {
+
+            // left hand side is a substraction
+            if let ExprKind::Binary(
+                Spanned {
+                    node: BinOpKind::Sub,
+                    ..
+                },
+                val_l,
+                val_r,
+            ) = lhs.kind;
+
+            // right hand side matches either f32::EPSILON or f64::EPSILON
+            if let ExprKind::Path(ref epsilon_path) = rhs.kind;
+            if match_qpath(epsilon_path, &["f32", "EPSILON"]) || match_qpath(epsilon_path, &["f64", "EPSILON"]);
+
+            // values of the substractions on the left hand side are of the type float
+            let t_val_l = cx.typeck_results().expr_ty(val_l);
+            let t_val_r = cx.typeck_results().expr_ty(val_r);
+            if let ty::Float(_) = t_val_l.kind;
+            if let ty::Float(_) = t_val_r.kind;
+
+            then {
+                // get the snippet string
+                let lhs_string = snippet(
+                    cx,
+                    lhs.span,
+                    "(...)",
+                );
+                // format the suggestion
+                let suggestion = if lhs_string.starts_with('(') {
+                    format!("{}.abs()", lhs_string)
+                } else {
+                    format!("({}).abs()", lhs_string)
+                };
+                // spans the lint
+                span_lint_and_sugg(
+                    cx,
+                    FLOAT_EQUALITY_WITHOUT_ABS,
+                    expr.span,
+                    "float equality check without `.abs()`",
+                    "add `.abs()`",
+                    suggestion,
+                    Applicability::MaybeIncorrect,
+                );
+            }
+        }
+    }
+}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index d45394ab8d2..f78de7a175f 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -193,6 +193,7 @@ mod excessive_bools;
 mod exit;
 mod explicit_write;
 mod fallible_impl_from;
+mod float_equality_without_abs;
 mod float_literal;
 mod floating_point_arithmetic;
 mod format;
@@ -549,6 +550,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &exit::EXIT,
         &explicit_write::EXPLICIT_WRITE,
         &fallible_impl_from::FALLIBLE_IMPL_FROM,
+        &float_equality_without_abs::FLOAT_EQUALITY_WITHOUT_ABS,
         &float_literal::EXCESSIVE_PRECISION,
         &float_literal::LOSSY_FLOAT_LITERAL,
         &floating_point_arithmetic::IMPRECISE_FLOPS,
@@ -1093,6 +1095,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box stable_sort_primitive::StableSortPrimitive);
     store.register_late_pass(|| box repeat_once::RepeatOnce);
     store.register_late_pass(|| box self_assignment::SelfAssignment);
+    store.register_late_pass(|| box float_equality_without_abs::FloatEqualityWithoutAbs);
 
     store.register_group(true, "clippy::restriction", Some("clippy_restriction"), vec![
         LintId::of(&arithmetic::FLOAT_ARITHMETIC),
@@ -1268,6 +1271,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&eval_order_dependence::DIVERGING_SUB_EXPRESSION),
         LintId::of(&eval_order_dependence::EVAL_ORDER_DEPENDENCE),
         LintId::of(&explicit_write::EXPLICIT_WRITE),
+        LintId::of(&float_equality_without_abs::FLOAT_EQUALITY_WITHOUT_ABS),
         LintId::of(&float_literal::EXCESSIVE_PRECISION),
         LintId::of(&format::USELESS_FORMAT),
         LintId::of(&formatting::POSSIBLE_MISSING_COMMA),
@@ -1686,6 +1690,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&enum_clike::ENUM_CLIKE_UNPORTABLE_VARIANT),
         LintId::of(&eq_op::EQ_OP),
         LintId::of(&erasing_op::ERASING_OP),
+        LintId::of(&float_equality_without_abs::FLOAT_EQUALITY_WITHOUT_ABS),
         LintId::of(&formatting::POSSIBLE_MISSING_COMMA),
         LintId::of(&functions::NOT_UNSAFE_PTR_ARG_DEREF),
         LintId::of(&if_let_mutex::IF_LET_MUTEX),
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index c50c6b900ae..eadd2621a40 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -661,6 +661,13 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
         deprecation: None,
         module: "misc",
     },
+    Lint {
+        name: "float_equality_without_abs",
+        group: "correctness",
+        desc: "float equality check without `.abs()`",
+        deprecation: None,
+        module: "float_equality_without_abs",
+    },
     Lint {
         name: "fn_address_comparisons",
         group: "correctness",
diff --git a/tests/ui/float_equality_without_abs.rs b/tests/ui/float_equality_without_abs.rs
new file mode 100644
index 00000000000..d40fa00c315
--- /dev/null
+++ b/tests/ui/float_equality_without_abs.rs
@@ -0,0 +1,31 @@
+#![warn(clippy::float_equality_without_abs)]
+
+pub fn is_roughly_equal(a: f32, b: f32) -> bool {
+    (a - b) < f32::EPSILON
+}
+
+pub fn main() {
+    // all errors
+    is_roughly_equal(1.0, 2.0);
+    let a = 0.05;
+    let b = 0.0500001;
+
+    let _ = (a - b) < f32::EPSILON;
+    let _ = a - b < f32::EPSILON;
+    let _ = a - b.abs() < f32::EPSILON;
+    let _ = (a as f64 - b as f64) < f64::EPSILON;
+    let _ = 1.0 - 2.0 < f32::EPSILON;
+
+    let _ = f32::EPSILON > (a - b);
+    let _ = f32::EPSILON > a - b;
+    let _ = f32::EPSILON > a - b.abs();
+    let _ = f64::EPSILON > (a as f64 - b as f64);
+    let _ = f32::EPSILON > 1.0 - 2.0;
+
+    // those are correct
+    let _ = (a - b).abs() < f32::EPSILON;
+    let _ = (a as f64 - b as f64).abs() < f64::EPSILON;
+
+    let _ = f32::EPSILON > (a - b).abs();
+    let _ = f64::EPSILON > (a as f64 - b as f64).abs();
+}
diff --git a/tests/ui/float_equality_without_abs.stderr b/tests/ui/float_equality_without_abs.stderr
new file mode 100644
index 00000000000..74b9078afe8
--- /dev/null
+++ b/tests/ui/float_equality_without_abs.stderr
@@ -0,0 +1,70 @@
+error: float equality check without `.abs()`
+  --> $DIR/float_equality_without_abs.rs:4:5
+   |
+LL |     (a - b) < f32::EPSILON
+   |     ^^^^^^^^^^^^^^^^^^^^^^ help: add `.abs()`: `(a - b).abs()`
+   |
+   = note: `-D clippy::float-equality-without-abs` implied by `-D warnings`
+
+error: float equality check without `.abs()`
+  --> $DIR/float_equality_without_abs.rs:13:13
+   |
+LL |     let _ = (a - b) < f32::EPSILON;
+   |             ^^^^^^^^^^^^^^^^^^^^^^ help: add `.abs()`: `(a - b).abs()`
+
+error: float equality check without `.abs()`
+  --> $DIR/float_equality_without_abs.rs:14:13
+   |
+LL |     let _ = a - b < f32::EPSILON;
+   |             ^^^^^^^^^^^^^^^^^^^^ help: add `.abs()`: `(a - b).abs()`
+
+error: float equality check without `.abs()`
+  --> $DIR/float_equality_without_abs.rs:15:13
+   |
+LL |     let _ = a - b.abs() < f32::EPSILON;
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: add `.abs()`: `(a - b.abs()).abs()`
+
+error: float equality check without `.abs()`
+  --> $DIR/float_equality_without_abs.rs:16:13
+   |
+LL |     let _ = (a as f64 - b as f64) < f64::EPSILON;
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: add `.abs()`: `(a as f64 - b as f64).abs()`
+
+error: float equality check without `.abs()`
+  --> $DIR/float_equality_without_abs.rs:17:13
+   |
+LL |     let _ = 1.0 - 2.0 < f32::EPSILON;
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^ help: add `.abs()`: `(1.0 - 2.0).abs()`
+
+error: float equality check without `.abs()`
+  --> $DIR/float_equality_without_abs.rs:19:13
+   |
+LL |     let _ = f32::EPSILON > (a - b);
+   |             ^^^^^^^^^^^^^^^^^^^^^^ help: add `.abs()`: `(a - b).abs()`
+
+error: float equality check without `.abs()`
+  --> $DIR/float_equality_without_abs.rs:20:13
+   |
+LL |     let _ = f32::EPSILON > a - b;
+   |             ^^^^^^^^^^^^^^^^^^^^ help: add `.abs()`: `(a - b).abs()`
+
+error: float equality check without `.abs()`
+  --> $DIR/float_equality_without_abs.rs:21:13
+   |
+LL |     let _ = f32::EPSILON > a - b.abs();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: add `.abs()`: `(a - b.abs()).abs()`
+
+error: float equality check without `.abs()`
+  --> $DIR/float_equality_without_abs.rs:22:13
+   |
+LL |     let _ = f64::EPSILON > (a as f64 - b as f64);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: add `.abs()`: `(a as f64 - b as f64).abs()`
+
+error: float equality check without `.abs()`
+  --> $DIR/float_equality_without_abs.rs:23:13
+   |
+LL |     let _ = f32::EPSILON > 1.0 - 2.0;
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^ help: add `.abs()`: `(1.0 - 2.0).abs()`
+
+error: aborting due to 11 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From e9964f2e8a1903d46e576f67122e234f719a90f0 Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Fri, 21 Aug 2020 02:03:57 +0200
Subject: stable_sort_primitive: print the type that is being sorted in the
 lint message

---
 clippy_lints/src/stable_sort_primitive.rs | 10 ++++++----
 clippy_lints/src/utils/mod.rs             | 27 +++++++++++++++++++++++----
 tests/ui/stable_sort_primitive.stderr     | 14 +++++++-------
 3 files changed, 36 insertions(+), 15 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/stable_sort_primitive.rs b/clippy_lints/src/stable_sort_primitive.rs
index 22c49a20451..99e4b293ac6 100644
--- a/clippy_lints/src/stable_sort_primitive.rs
+++ b/clippy_lints/src/stable_sort_primitive.rs
@@ -86,6 +86,7 @@ struct LintDetection {
     slice_name: String,
     method: SortingKind,
     method_args: String,
+    slice_type: String,
 }
 
 fn detect_stable_sort_primitive(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<LintDetection> {
@@ -93,10 +94,10 @@ fn detect_stable_sort_primitive(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option
         if let ExprKind::MethodCall(method_name, _, args, _) = &expr.kind;
         if let Some(slice) = &args.get(0);
         if let Some(method) = SortingKind::from_stable_name(&method_name.ident.name.as_str());
-        if is_slice_of_primitives(cx, slice);
+        if let Some(slice_type) = is_slice_of_primitives(cx, slice);
         then {
             let args_str = args.iter().skip(1).map(|arg| Sugg::hir(cx, arg, "..").to_string()).collect::<Vec<String>>().join(", ");
-            Some(LintDetection { slice_name: Sugg::hir(cx, slice, "..").to_string(), method, method_args: args_str })
+            Some(LintDetection { slice_name: Sugg::hir(cx, slice, "..").to_string(), method, method_args: args_str, slice_type })
         } else {
             None
         }
@@ -111,9 +112,10 @@ impl LateLintPass<'_> for StableSortPrimitive {
                 STABLE_SORT_PRIMITIVE,
                 expr.span,
                 format!(
-                    "used {} instead of {}",
+                    "used {} instead of {} to sort primitive type `{}`",
                     detection.method.stable_name(),
-                    detection.method.unstable_name()
+                    detection.method.unstable_name(),
+                    detection.slice_type,
                 )
                 .as_str(),
                 "try",
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index 2aef995cec4..25301d6dede 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -1409,11 +1409,13 @@ pub fn is_recursively_primitive_type(ty: Ty<'_>) -> bool {
     }
 }
 
-/// Returns true iff the given expression is a slice of primitives (as defined in the
-/// `is_recursively_primitive_type` function).
-pub fn is_slice_of_primitives(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+/// Returns Option<String> where String is a textual representation of the type encapsulated in the
+/// slice iff the given expression is a slice of primitives (as defined in the
+/// `is_recursively_primitive_type` function) and None otherwise.
+pub fn is_slice_of_primitives(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<String> {
     let expr_type = cx.typeck_results().expr_ty_adjusted(expr);
-    match expr_type.kind {
+    let expr_kind = &expr_type.kind;
+    let is_primitive = match expr_kind {
         ty::Slice(ref element_type)
         | ty::Ref(
             _,
@@ -1424,7 +1426,24 @@ pub fn is_slice_of_primitives(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
             _,
         ) => is_recursively_primitive_type(element_type),
         _ => false,
+    };
+
+    if is_primitive {
+        // if we have wrappers like Array, Slice or Tuple, print these
+        // and get the type enclosed in the slice ref
+        match expr_type.peel_refs().walk().nth(1).unwrap().expect_ty().kind {
+            ty::Slice(..) => return Some("slice".into()),
+            ty::Array(..) => return Some("array".into()),
+            ty::Tuple(..) => return Some("tuple".into()),
+            _ => {
+                // is_recursively_primitive_type() should have taken care
+                // of the rest and we can rely on the type that is found
+                let refs_peeled = expr_type.peel_refs();
+                return Some(refs_peeled.walk().last().unwrap().to_string());
+            },
+        }
     }
+    None
 }
 
 #[macro_export]
diff --git a/tests/ui/stable_sort_primitive.stderr b/tests/ui/stable_sort_primitive.stderr
index b73012a4691..780389f32bc 100644
--- a/tests/ui/stable_sort_primitive.stderr
+++ b/tests/ui/stable_sort_primitive.stderr
@@ -1,4 +1,4 @@
-error: used sort instead of sort_unstable
+error: used sort instead of sort_unstable to sort primitive type `i32`
   --> $DIR/stable_sort_primitive.rs:7:5
    |
 LL |     vec.sort();
@@ -6,37 +6,37 @@ LL |     vec.sort();
    |
    = note: `-D clippy::stable-sort-primitive` implied by `-D warnings`
 
-error: used sort instead of sort_unstable
+error: used sort instead of sort_unstable to sort primitive type `bool`
   --> $DIR/stable_sort_primitive.rs:9:5
    |
 LL |     vec.sort();
    |     ^^^^^^^^^^ help: try: `vec.sort_unstable()`
 
-error: used sort instead of sort_unstable
+error: used sort instead of sort_unstable to sort primitive type `char`
   --> $DIR/stable_sort_primitive.rs:11:5
    |
 LL |     vec.sort();
    |     ^^^^^^^^^^ help: try: `vec.sort_unstable()`
 
-error: used sort instead of sort_unstable
+error: used sort instead of sort_unstable to sort primitive type `str`
   --> $DIR/stable_sort_primitive.rs:13:5
    |
 LL |     vec.sort();
    |     ^^^^^^^^^^ help: try: `vec.sort_unstable()`
 
-error: used sort instead of sort_unstable
+error: used sort instead of sort_unstable to sort primitive type `tuple`
   --> $DIR/stable_sort_primitive.rs:15:5
    |
 LL |     vec.sort();
    |     ^^^^^^^^^^ help: try: `vec.sort_unstable()`
 
-error: used sort instead of sort_unstable
+error: used sort instead of sort_unstable to sort primitive type `array`
   --> $DIR/stable_sort_primitive.rs:17:5
    |
 LL |     vec.sort();
    |     ^^^^^^^^^^ help: try: `vec.sort_unstable()`
 
-error: used sort instead of sort_unstable
+error: used sort instead of sort_unstable to sort primitive type `i32`
   --> $DIR/stable_sort_primitive.rs:19:5
    |
 LL |     arr.sort();
-- 
cgit 1.4.1-3-g733a5


From 179df0bd15f9f866b4b3e275ed97aa8168a5b702 Mon Sep 17 00:00:00 2001
From: Bastian <bastian@cmbt.de>
Date: Tue, 25 Aug 2020 13:41:39 +0200
Subject: Added F32::EPSILON and F64::EPSILON to paths.rs

---
 clippy_lints/src/float_equality_without_abs.rs | 4 ++--
 clippy_lints/src/utils/paths.rs                | 2 ++
 2 files changed, 4 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/float_equality_without_abs.rs b/clippy_lints/src/float_equality_without_abs.rs
index c8e53ce6f95..dc1c3bfc9ff 100644
--- a/clippy_lints/src/float_equality_without_abs.rs
+++ b/clippy_lints/src/float_equality_without_abs.rs
@@ -1,4 +1,4 @@
-use crate::utils::{match_qpath, snippet, span_lint_and_sugg};
+use crate::utils::{match_qpath, paths, snippet, span_lint_and_sugg};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind};
@@ -75,7 +75,7 @@ impl<'tcx> LateLintPass<'tcx> for FloatEqualityWithoutAbs {
 
             // right hand side matches either f32::EPSILON or f64::EPSILON
             if let ExprKind::Path(ref epsilon_path) = rhs.kind;
-            if match_qpath(epsilon_path, &["f32", "EPSILON"]) || match_qpath(epsilon_path, &["f64", "EPSILON"]);
+            if match_qpath(epsilon_path, &paths::F32_EPSILON) || match_qpath(epsilon_path, &paths::F64_EPSILON);
 
             // values of the substractions on the left hand side are of the type float
             let t_val_l = cx.typeck_results().expr_ty(val_l);
diff --git a/clippy_lints/src/utils/paths.rs b/clippy_lints/src/utils/paths.rs
index b6a1e0a6aa9..d44854aefe9 100644
--- a/clippy_lints/src/utils/paths.rs
+++ b/clippy_lints/src/utils/paths.rs
@@ -35,6 +35,8 @@ pub const DROP_TRAIT: [&str; 4] = ["core", "ops", "drop", "Drop"];
 pub const DURATION: [&str; 3] = ["core", "time", "Duration"];
 pub const EARLY_CONTEXT: [&str; 4] = ["rustc", "lint", "context", "EarlyContext"];
 pub const EXIT: [&str; 3] = ["std", "process", "exit"];
+pub const F32_EPSILON: [&str; 2] = ["f32", "EPSILON"];
+pub const F64_EPSILON: [&str; 2] = ["f64", "EPSILON"];
 pub const FILE: [&str; 3] = ["std", "fs", "File"];
 pub const FILE_TYPE: [&str; 3] = ["std", "fs", "FileType"];
 pub const FMT_ARGUMENTS_NEW_V1: [&str; 4] = ["core", "fmt", "Arguments", "new_v1"];
-- 
cgit 1.4.1-3-g733a5


From 3b1e5d6ff79f93e0215c6fb4c802167834ea4e15 Mon Sep 17 00:00:00 2001
From: Scott McMurray <scottmcm@users.noreply.github.com>
Date: Tue, 25 Aug 2020 12:05:02 -0700
Subject: Re-enable len_zero for ranges now that `is_empty` is stable on them

---
 clippy_lints/src/len_zero.rs    | 17 +----------------
 tests/ui/len_zero.fixed         |  8 --------
 tests/ui/len_zero.rs            |  8 --------
 tests/ui/len_zero_ranges.fixed  | 10 ++++++----
 tests/ui/len_zero_ranges.rs     | 10 ++++++----
 tests/ui/len_zero_ranges.stderr | 10 ++++++++--
 6 files changed, 21 insertions(+), 42 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/len_zero.rs b/clippy_lints/src/len_zero.rs
index e5daa30f8ca..b691d363d2f 100644
--- a/clippy_lints/src/len_zero.rs
+++ b/clippy_lints/src/len_zero.rs
@@ -1,4 +1,4 @@
-use crate::utils::{get_item_name, higher, snippet_with_applicability, span_lint, span_lint_and_sugg, walk_ptrs_ty};
+use crate::utils::{get_item_name, snippet_with_applicability, span_lint, span_lint_and_sugg, walk_ptrs_ty};
 use rustc_ast::ast::LitKind;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Applicability;
@@ -260,17 +260,6 @@ fn check_len(
 
 /// Checks if this type has an `is_empty` method.
 fn has_is_empty(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-    /// Special case ranges until `range_is_empty` is stabilized. See issue 3807.
-    fn should_skip_range(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-        higher::range(expr).map_or(false, |_| {
-            !cx.tcx
-                .features()
-                .declared_lib_features
-                .iter()
-                .any(|(name, _)| name.as_str() == "range_is_empty")
-        })
-    }
-
     /// Gets an `AssocItem` and return true if it matches `is_empty(self)`.
     fn is_is_empty(cx: &LateContext<'_>, item: &ty::AssocItem) -> bool {
         if let ty::AssocKind::Fn = item.kind {
@@ -296,10 +285,6 @@ fn has_is_empty(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
         })
     }
 
-    if should_skip_range(cx, expr) {
-        return false;
-    }
-
     let ty = &walk_ptrs_ty(cx.typeck_results().expr_ty(expr));
     match ty.kind {
         ty::Dynamic(ref tt, ..) => tt.principal().map_or(false, |principal| {
diff --git a/tests/ui/len_zero.fixed b/tests/ui/len_zero.fixed
index d81676a3d9f..1f3b8ac99b1 100644
--- a/tests/ui/len_zero.fixed
+++ b/tests/ui/len_zero.fixed
@@ -141,11 +141,3 @@ fn main() {
 fn test_slice(b: &[u8]) {
     if !b.is_empty() {}
 }
-
-mod issue_3807 {
-    // Avoid suggesting changes to ranges if the user did not enable `range_is_empty`.
-    // See https://github.com/rust-lang/rust/issues/48111#issuecomment-445132965
-    fn no_suggestion() {
-        let _ = (0..42).len() == 0;
-    }
-}
diff --git a/tests/ui/len_zero.rs b/tests/ui/len_zero.rs
index ecdba921a5d..dc21de0001b 100644
--- a/tests/ui/len_zero.rs
+++ b/tests/ui/len_zero.rs
@@ -141,11 +141,3 @@ fn main() {
 fn test_slice(b: &[u8]) {
     if b.len() != 0 {}
 }
-
-mod issue_3807 {
-    // Avoid suggesting changes to ranges if the user did not enable `range_is_empty`.
-    // See https://github.com/rust-lang/rust/issues/48111#issuecomment-445132965
-    fn no_suggestion() {
-        let _ = (0..42).len() == 0;
-    }
-}
diff --git a/tests/ui/len_zero_ranges.fixed b/tests/ui/len_zero_ranges.fixed
index eee3db9b7d4..79781766242 100644
--- a/tests/ui/len_zero_ranges.fixed
+++ b/tests/ui/len_zero_ranges.fixed
@@ -1,15 +1,17 @@
 // run-rustfix
 
-#![feature(range_is_empty)]
 #![warn(clippy::len_zero)]
 #![allow(unused)]
-#![allow(stable_features)] // TODO: https://github.com/rust-lang/rust-clippy/issues/5956
 
+// Now that `Range(Inclusive)::is_empty` is stable (1.47), we can always suggest this
 mod issue_3807 {
-    // With the feature enabled, `is_empty` should be suggested
-    fn suggestion_is_fine() {
+    fn suggestion_is_fine_range() {
         let _ = (0..42).is_empty();
     }
+
+    fn suggestion_is_fine_range_inclusive() {
+        let _ = (0_u8..=42).is_empty();
+    }
 }
 
 fn main() {}
diff --git a/tests/ui/len_zero_ranges.rs b/tests/ui/len_zero_ranges.rs
index be2e0f38fd1..a0eb51cc976 100644
--- a/tests/ui/len_zero_ranges.rs
+++ b/tests/ui/len_zero_ranges.rs
@@ -1,15 +1,17 @@
 // run-rustfix
 
-#![feature(range_is_empty)]
 #![warn(clippy::len_zero)]
 #![allow(unused)]
-#![allow(stable_features)] // TODO: https://github.com/rust-lang/rust-clippy/issues/5956
 
+// Now that `Range(Inclusive)::is_empty` is stable (1.47), we can always suggest this
 mod issue_3807 {
-    // With the feature enabled, `is_empty` should be suggested
-    fn suggestion_is_fine() {
+    fn suggestion_is_fine_range() {
         let _ = (0..42).len() == 0;
     }
+
+    fn suggestion_is_fine_range_inclusive() {
+        let _ = (0_u8..=42).len() == 0;
+    }
 }
 
 fn main() {}
diff --git a/tests/ui/len_zero_ranges.stderr b/tests/ui/len_zero_ranges.stderr
index acb85f7100a..d0defb5a79e 100644
--- a/tests/ui/len_zero_ranges.stderr
+++ b/tests/ui/len_zero_ranges.stderr
@@ -1,10 +1,16 @@
 error: length comparison to zero
-  --> $DIR/len_zero_ranges.rs:11:17
+  --> $DIR/len_zero_ranges.rs:9:17
    |
 LL |         let _ = (0..42).len() == 0;
    |                 ^^^^^^^^^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `(0..42).is_empty()`
    |
    = note: `-D clippy::len-zero` implied by `-D warnings`
 
-error: aborting due to previous error
+error: length comparison to zero
+  --> $DIR/len_zero_ranges.rs:13:17
+   |
+LL |         let _ = (0_u8..=42).len() == 0;
+   |                 ^^^^^^^^^^^^^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `(0_u8..=42).is_empty()`
+
+error: aborting due to 2 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 370fc45a0a2af502d43f0e1831def314e0580a92 Mon Sep 17 00:00:00 2001
From: Thibaud <ThibsG@users.noreply.github.com>
Date: Tue, 25 Aug 2020 22:20:35 +0200
Subject: Update clippy_lints/src/methods/mod.rs

Co-authored-by: Eduardo Broto <ebroto@tutanota.com>
---
 clippy_lints/src/methods/mod.rs | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 4f0a533592c..1ef54d285f6 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -2150,11 +2150,7 @@ fn lint_clone_on_ref_ptr(cx: &LateContext<'_>, expr: &hir::Expr<'_>, arg: &hir::
             return;
         };
 
-        let snippet = if in_macro(arg.span) {
-            snippet_with_macro_callsite(cx, arg.span, "_")
-        } else {
-            snippet(cx, arg.span, "_")
-        };
+        let snippet = snippet_with_macro_callsite(cx, arg.span, "_");
 
         span_lint_and_sugg(
             cx,
-- 
cgit 1.4.1-3-g733a5


From 9d18c24b56b6079fc0b66d93b8679c760cd364fb Mon Sep 17 00:00:00 2001
From: Hirochika Matsumoto <matsujika@gmail.com>
Date: Wed, 26 Aug 2020 16:03:35 +0900
Subject: Fix typo

---
 clippy_lints/src/utils/mod.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index 25301d6dede..e6be5c4588f 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -574,7 +574,7 @@ pub fn snippet_block<'a, T: LintContext>(
 }
 
 /// Same as `snippet_block`, but adapts the applicability level by the rules of
-/// `snippet_with_applicabiliy`.
+/// `snippet_with_applicability`.
 pub fn snippet_block_with_applicability<'a, T: LintContext>(
     cx: &T,
     span: Span,
@@ -1304,7 +1304,7 @@ pub fn is_must_use_ty<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
     }
 }
 
-// check if expr is calling method or function with #[must_use] attribyte
+// check if expr is calling method or function with #[must_use] attribute
 pub fn is_must_use_func_call(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
     let did = match expr.kind {
         ExprKind::Call(ref path, _) => if_chain! {
-- 
cgit 1.4.1-3-g733a5


From 2d853148d72d49956052cf1cdb5f3be18c85a9fc Mon Sep 17 00:00:00 2001
From: Bastian <bastian@cmbt.de>
Date: Wed, 26 Aug 2020 16:39:30 +0200
Subject: Changed the location of the suggestion as well as the way the
 suggestion is assembled

---
 clippy_lints/src/float_equality_without_abs.rs | 30 ++++++++----------
 tests/ui/float_equality_without_abs.stderr     | 44 +++++++++++++++++++-------
 2 files changed, 47 insertions(+), 27 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/float_equality_without_abs.rs b/clippy_lints/src/float_equality_without_abs.rs
index dc1c3bfc9ff..9ac5a45eb45 100644
--- a/clippy_lints/src/float_equality_without_abs.rs
+++ b/clippy_lints/src/float_equality_without_abs.rs
@@ -1,5 +1,6 @@
-use crate::utils::{match_qpath, paths, snippet, span_lint_and_sugg};
+use crate::utils::{match_qpath, paths, span_lint_and_then, sugg};
 use if_chain::if_chain;
+use rustc_ast::util::parser::AssocOp;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
@@ -84,27 +85,24 @@ impl<'tcx> LateLintPass<'tcx> for FloatEqualityWithoutAbs {
             if let ty::Float(_) = t_val_r.kind;
 
             then {
-                // get the snippet string
-                let lhs_string = snippet(
-                    cx,
-                    lhs.span,
-                    "(...)",
-                );
+                let sug_l = sugg::Sugg::hir(cx, &val_l, "..");
+                let sug_r = sugg::Sugg::hir(cx, &val_r, "..");
                 // format the suggestion
-                let suggestion = if lhs_string.starts_with('(') {
-                    format!("{}.abs()", lhs_string)
-                } else {
-                    format!("({}).abs()", lhs_string)
-                };
+                let suggestion = format!("{}.abs()", sugg::make_assoc(AssocOp::Subtract, &sug_l, &sug_r).maybe_par());
                 // spans the lint
-                span_lint_and_sugg(
+                span_lint_and_then(
                     cx,
                     FLOAT_EQUALITY_WITHOUT_ABS,
                     expr.span,
                     "float equality check without `.abs()`",
-                    "add `.abs()`",
-                    suggestion,
-                    Applicability::MaybeIncorrect,
+                    | diag | {
+                        diag.span_suggestion(
+                            lhs.span,
+                            "add `.abs()`",
+                            suggestion,
+                            Applicability::MaybeIncorrect,
+                        );
+                    }
                 );
             }
         }
diff --git a/tests/ui/float_equality_without_abs.stderr b/tests/ui/float_equality_without_abs.stderr
index 74b9078afe8..b34c8159da0 100644
--- a/tests/ui/float_equality_without_abs.stderr
+++ b/tests/ui/float_equality_without_abs.stderr
@@ -2,7 +2,9 @@ error: float equality check without `.abs()`
   --> $DIR/float_equality_without_abs.rs:4:5
    |
 LL |     (a - b) < f32::EPSILON
-   |     ^^^^^^^^^^^^^^^^^^^^^^ help: add `.abs()`: `(a - b).abs()`
+   |     -------^^^^^^^^^^^^^^^
+   |     |
+   |     help: add `.abs()`: `(a - b).abs()`
    |
    = note: `-D clippy::float-equality-without-abs` implied by `-D warnings`
 
@@ -10,61 +12,81 @@ error: float equality check without `.abs()`
   --> $DIR/float_equality_without_abs.rs:13:13
    |
 LL |     let _ = (a - b) < f32::EPSILON;
-   |             ^^^^^^^^^^^^^^^^^^^^^^ help: add `.abs()`: `(a - b).abs()`
+   |             -------^^^^^^^^^^^^^^^
+   |             |
+   |             help: add `.abs()`: `(a - b).abs()`
 
 error: float equality check without `.abs()`
   --> $DIR/float_equality_without_abs.rs:14:13
    |
 LL |     let _ = a - b < f32::EPSILON;
-   |             ^^^^^^^^^^^^^^^^^^^^ help: add `.abs()`: `(a - b).abs()`
+   |             -----^^^^^^^^^^^^^^^
+   |             |
+   |             help: add `.abs()`: `(a - b).abs()`
 
 error: float equality check without `.abs()`
   --> $DIR/float_equality_without_abs.rs:15:13
    |
 LL |     let _ = a - b.abs() < f32::EPSILON;
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: add `.abs()`: `(a - b.abs()).abs()`
+   |             -----------^^^^^^^^^^^^^^^
+   |             |
+   |             help: add `.abs()`: `(a - b.abs()).abs()`
 
 error: float equality check without `.abs()`
   --> $DIR/float_equality_without_abs.rs:16:13
    |
 LL |     let _ = (a as f64 - b as f64) < f64::EPSILON;
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: add `.abs()`: `(a as f64 - b as f64).abs()`
+   |             ---------------------^^^^^^^^^^^^^^^
+   |             |
+   |             help: add `.abs()`: `(a as f64 - b as f64).abs()`
 
 error: float equality check without `.abs()`
   --> $DIR/float_equality_without_abs.rs:17:13
    |
 LL |     let _ = 1.0 - 2.0 < f32::EPSILON;
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^ help: add `.abs()`: `(1.0 - 2.0).abs()`
+   |             ---------^^^^^^^^^^^^^^^
+   |             |
+   |             help: add `.abs()`: `(1.0 - 2.0).abs()`
 
 error: float equality check without `.abs()`
   --> $DIR/float_equality_without_abs.rs:19:13
    |
 LL |     let _ = f32::EPSILON > (a - b);
-   |             ^^^^^^^^^^^^^^^^^^^^^^ help: add `.abs()`: `(a - b).abs()`
+   |             ^^^^^^^^^^^^^^^-------
+   |                            |
+   |                            help: add `.abs()`: `(a - b).abs()`
 
 error: float equality check without `.abs()`
   --> $DIR/float_equality_without_abs.rs:20:13
    |
 LL |     let _ = f32::EPSILON > a - b;
-   |             ^^^^^^^^^^^^^^^^^^^^ help: add `.abs()`: `(a - b).abs()`
+   |             ^^^^^^^^^^^^^^^-----
+   |                            |
+   |                            help: add `.abs()`: `(a - b).abs()`
 
 error: float equality check without `.abs()`
   --> $DIR/float_equality_without_abs.rs:21:13
    |
 LL |     let _ = f32::EPSILON > a - b.abs();
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: add `.abs()`: `(a - b.abs()).abs()`
+   |             ^^^^^^^^^^^^^^^-----------
+   |                            |
+   |                            help: add `.abs()`: `(a - b.abs()).abs()`
 
 error: float equality check without `.abs()`
   --> $DIR/float_equality_without_abs.rs:22:13
    |
 LL |     let _ = f64::EPSILON > (a as f64 - b as f64);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: add `.abs()`: `(a as f64 - b as f64).abs()`
+   |             ^^^^^^^^^^^^^^^---------------------
+   |                            |
+   |                            help: add `.abs()`: `(a as f64 - b as f64).abs()`
 
 error: float equality check without `.abs()`
   --> $DIR/float_equality_without_abs.rs:23:13
    |
 LL |     let _ = f32::EPSILON > 1.0 - 2.0;
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^ help: add `.abs()`: `(1.0 - 2.0).abs()`
+   |             ^^^^^^^^^^^^^^^---------
+   |                            |
+   |                            help: add `.abs()`: `(1.0 - 2.0).abs()`
 
 error: aborting due to 11 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From edc05da57d4ad5ab19b5ca64e80e359e487ab2d0 Mon Sep 17 00:00:00 2001
From: rail <12975677+rail-rain@users.noreply.github.com>
Date: Thu, 27 Aug 2020 10:23:21 +1200
Subject: Fix the wrong use of `snippet_with_applicability`

This includes a workaround of the issue #5822,
the cause of this little mistake.
---
 clippy_lints/src/write.rs | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs
index 5f88dcb188a..e653240d049 100644
--- a/clippy_lints/src/write.rs
+++ b/clippy_lints/src/write.rs
@@ -297,13 +297,14 @@ impl EarlyLintPass for Write {
             if let (Some(fmt_str), expr) = self.check_tts(cx, mac.args.inner_tokens(), true) {
                 if fmt_str.symbol == Symbol::intern("") {
                     let mut applicability = Applicability::MachineApplicable;
-                    let suggestion = expr.map_or_else(
-                        || {
-                            applicability = Applicability::HasPlaceholders;
-                            Cow::Borrowed("v")
-                        },
-                        |e| snippet_with_applicability(cx, e.span, "v", &mut Applicability::MachineApplicable),
-                    );
+                    // FIXME: remove this `#[allow(...)]` once the issue #5822 gets fixed
+                    #[allow(clippy::option_if_let_else)]
+                    let suggestion = if let Some(e) = expr {
+                        snippet_with_applicability(cx, e.span, "v", &mut applicability)
+                    } else {
+                        applicability = Applicability::HasPlaceholders;
+                        Cow::Borrowed("v")
+                    };
 
                     span_lint_and_sugg(
                         cx,
-- 
cgit 1.4.1-3-g733a5


From 91024f1fdee2d2c2febfc7c76127d68d2b6e629e Mon Sep 17 00:00:00 2001
From: Jane Lusby <jlusby@yaah.dev>
Date: Wed, 26 Aug 2020 16:31:49 -0700
Subject: Add new lint to prevent usage of unwrap in fns that return result

---
 CHANGELOG.md                         |   1 +
 clippy_lints/src/lib.rs              |   4 +
 clippy_lints/src/unwrap_in_result.rs | 140 +++++++++++++++++++++++++++++++++++
 src/lintlist/mod.rs                  |   7 ++
 tests/ui/unwrap_in_result.rs         |  44 +++++++++++
 tests/ui/unwrap_in_result.stderr     |  41 ++++++++++
 6 files changed, 237 insertions(+)
 create mode 100644 clippy_lints/src/unwrap_in_result.rs
 create mode 100644 tests/ui/unwrap_in_result.rs
 create mode 100644 tests/ui/unwrap_in_result.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index a5da0f7b767..137b561028a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1778,6 +1778,7 @@ Released 2018-09-13
 [`unused_label`]: https://rust-lang.github.io/rust-clippy/master/index.html#unused_label
 [`unused_self`]: https://rust-lang.github.io/rust-clippy/master/index.html#unused_self
 [`unused_unit`]: https://rust-lang.github.io/rust-clippy/master/index.html#unused_unit
+[`unwrap_in_result`]: https://rust-lang.github.io/rust-clippy/master/index.html#unwrap_in_result
 [`unwrap_used`]: https://rust-lang.github.io/rust-clippy/master/index.html#unwrap_used
 [`use_debug`]: https://rust-lang.github.io/rust-clippy/master/index.html#use_debug
 [`use_self`]: https://rust-lang.github.io/rust-clippy/master/index.html#use_self
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index f78de7a175f..577ce6523b4 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -314,6 +314,7 @@ mod unused_io_amount;
 mod unused_self;
 mod unused_unit;
 mod unwrap;
+mod unwrap_in_result;
 mod use_self;
 mod useless_conversion;
 mod vec;
@@ -850,6 +851,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &unused_unit::UNUSED_UNIT,
         &unwrap::PANICKING_UNWRAP,
         &unwrap::UNNECESSARY_UNWRAP,
+        &unwrap_in_result::UNWRAP_IN_RESULT,
         &use_self::USE_SELF,
         &useless_conversion::USELESS_CONVERSION,
         &utils::internal_lints::CLIPPY_LINTS_INTERNAL,
@@ -1094,6 +1096,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box pattern_type_mismatch::PatternTypeMismatch);
     store.register_late_pass(|| box stable_sort_primitive::StableSortPrimitive);
     store.register_late_pass(|| box repeat_once::RepeatOnce);
+    store.register_late_pass(|| box unwrap_in_result::UnwrapInResult);
     store.register_late_pass(|| box self_assignment::SelfAssignment);
     store.register_late_pass(|| box float_equality_without_abs::FloatEqualityWithoutAbs);
 
@@ -1133,6 +1136,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&shadow::SHADOW_REUSE),
         LintId::of(&shadow::SHADOW_SAME),
         LintId::of(&strings::STRING_ADD),
+        LintId::of(&unwrap_in_result::UNWRAP_IN_RESULT),
         LintId::of(&verbose_file_reads::VERBOSE_FILE_READS),
         LintId::of(&write::PRINT_STDOUT),
         LintId::of(&write::USE_DEBUG),
diff --git a/clippy_lints/src/unwrap_in_result.rs b/clippy_lints/src/unwrap_in_result.rs
new file mode 100644
index 00000000000..1c7e62ecd3d
--- /dev/null
+++ b/clippy_lints/src/unwrap_in_result.rs
@@ -0,0 +1,140 @@
+use crate::utils::{is_type_diagnostic_item, method_chain_args, return_ty, span_lint_and_then, walk_ptrs_ty};
+use if_chain::if_chain;
+use rustc_hir as hir;
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::hir::map::Map;
+use rustc_middle::ty;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::Span;
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for functions of type Result that contain `expect()` or `unwrap()`
+    ///
+    /// **Why is this bad?** These functions promote recoverable errors to non-recoverable errors which may be undesirable in code bases which wish to avoid panics.
+    ///
+    /// **Known problems:** This can cause false positives in functions that handle both recoverable and non recoverable errors.
+    ///
+    /// **Example:**
+    /// Before:
+    /// ```rust
+    /// fn divisible_by_3(i_str: String) -> Result<(), String> {
+    ///     let i = i_str
+    ///         .parse::<i32>()
+    ///         .expect("cannot divide the input by three");
+    ///
+    ///     if i % 3 != 0 {
+    ///         Err("Number is not divisible by 3")?
+    ///     }
+    ///
+    ///     Ok(())
+    /// }
+    /// ```
+    ///
+    /// After:
+    /// ```rust
+    /// fn divisible_by_3(i_str: String) -> Result<(), String> {
+    ///     let i = i_str
+    ///         .parse::<i32>()
+    ///         .map_err(|e| format!("cannot divide the input by three: {}", e))?;
+    ///
+    ///     if i % 3 != 0 {
+    ///         Err("Number is not divisible by 3")?
+    ///     }
+    ///
+    ///     Ok(())
+    /// }
+    /// ```
+    pub UNWRAP_IN_RESULT,
+    restriction,
+    "functions of type `Result<..>` or `Option`<...> that contain `expect()` or `unwrap()`"
+}
+
+declare_lint_pass!(UnwrapInResult=> [UNWRAP_IN_RESULT]);
+
+impl<'tcx> LateLintPass<'tcx> for UnwrapInResult {
+    fn check_impl_item(&mut self, cx: &LateContext<'tcx>, impl_item: &'tcx hir::ImplItem<'_>) {
+        if_chain! {
+            // first check if it's a method or function
+            if let hir::ImplItemKind::Fn(ref _signature, _) = impl_item.kind;
+            // checking if its return type is `result` or `option`
+            if is_type_diagnostic_item(cx, return_ty(cx, impl_item.hir_id), sym!(result_type))
+                || is_type_diagnostic_item(cx, return_ty(cx, impl_item.hir_id), sym!(option_type));
+            then {
+                lint_impl_body(cx, impl_item.span, impl_item);
+            }
+        }
+    }
+}
+
+use rustc_hir::intravisit::{self, NestedVisitorMap, Visitor};
+use rustc_hir::{Expr, ImplItemKind};
+
+struct FindExpectUnwrap<'a, 'tcx> {
+    lcx: &'a LateContext<'tcx>,
+    typeck_results: &'tcx ty::TypeckResults<'tcx>,
+    result: Vec<Span>,
+}
+
+impl<'a, 'tcx> Visitor<'tcx> for FindExpectUnwrap<'a, 'tcx> {
+    type Map = Map<'tcx>;
+
+    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
+        // check for `expect`
+        if let Some(arglists) = method_chain_args(expr, &["expect"]) {
+            let reciever_ty = walk_ptrs_ty(self.typeck_results.expr_ty(&arglists[0][0]));
+            if is_type_diagnostic_item(self.lcx, reciever_ty, sym!(option_type))
+                || is_type_diagnostic_item(self.lcx, reciever_ty, sym!(result_type))
+            {
+                self.result.push(expr.span);
+            }
+        }
+
+        // check for `unwrap`
+        if let Some(arglists) = method_chain_args(expr, &["unwrap"]) {
+            let reciever_ty = walk_ptrs_ty(self.typeck_results.expr_ty(&arglists[0][0]));
+            if is_type_diagnostic_item(self.lcx, reciever_ty, sym!(option_type))
+                || is_type_diagnostic_item(self.lcx, reciever_ty, sym!(result_type))
+            {
+                self.result.push(expr.span);
+            }
+        }
+
+        // and check sub-expressions
+        intravisit::walk_expr(self, expr);
+    }
+
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::None
+    }
+}
+
+fn lint_impl_body<'tcx>(cx: &LateContext<'tcx>, impl_span: Span, impl_item: &'tcx hir::ImplItem<'_>) {
+    if_chain! {
+
+        if let ImplItemKind::Fn(_, body_id) = impl_item.kind;
+        then {
+            let body = cx.tcx.hir().body(body_id);
+            let impl_item_def_id = cx.tcx.hir().local_def_id(impl_item.hir_id);
+            let mut fpu = FindExpectUnwrap {
+                lcx: cx,
+                typeck_results: cx.tcx.typeck(impl_item_def_id),
+                result: Vec::new(),
+            };
+            fpu.visit_expr(&body.value);
+
+            // if we've found one, lint
+            if  !fpu.result.is_empty()  {
+                span_lint_and_then(
+                    cx,
+                    UNWRAP_IN_RESULT,
+                    impl_span,
+                    "used unwrap or expect in a function that returns result or option",
+                    move |diag| {
+                        diag.help(
+                            "unwrap and expect should not be used in a function that returns result or option" );
+                        diag.span_note(fpu.result, "potential non-recoverable error(s)");
+                    });
+            }
+        }
+    }
+}
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index eadd2621a40..687fac7baa8 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -2516,6 +2516,13 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
         deprecation: None,
         module: "unused_unit",
     },
+    Lint {
+        name: "unwrap_in_result",
+        group: "restriction",
+        desc: "functions of type `Result<..>` or `Option`<...> that contain `expect()` or `unwrap()`",
+        deprecation: None,
+        module: "unwrap_in_result",
+    },
     Lint {
         name: "unwrap_used",
         group: "restriction",
diff --git a/tests/ui/unwrap_in_result.rs b/tests/ui/unwrap_in_result.rs
new file mode 100644
index 00000000000..2aa842adc85
--- /dev/null
+++ b/tests/ui/unwrap_in_result.rs
@@ -0,0 +1,44 @@
+#![warn(clippy::unwrap_in_result)]
+
+struct A;
+
+impl A {
+    // should not be detected
+    fn good_divisible_by_3(i_str: String) -> Result<bool, String> {
+        // checks whether a string represents a number divisible by 3
+        let i_result = i_str.parse::<i32>();
+        match i_result {
+            Err(_e) => Err("Not a number".to_string()),
+            Ok(i) => {
+                if i % 3 == 0 {
+                    return Ok(true);
+                }
+                Err("Number is not divisible by 3".to_string())
+            },
+        }
+    }
+
+    // should be detected
+    fn bad_divisible_by_3(i_str: String) -> Result<bool, String> {
+        // checks whether a string represents a number divisible by 3
+        let i = i_str.parse::<i32>().unwrap();
+        if i % 3 == 0 {
+            Ok(true)
+        } else {
+            Err("Number is not divisible by 3".to_string())
+        }
+    }
+
+    fn example_option_expect(i_str: String) -> Option<bool> {
+        let i = i_str.parse::<i32>().expect("not a number");
+        if i % 3 == 0 {
+            return Some(true);
+        }
+        None
+    }
+}
+
+fn main() {
+    A::bad_divisible_by_3("3".to_string());
+    A::good_divisible_by_3("3".to_string());
+}
diff --git a/tests/ui/unwrap_in_result.stderr b/tests/ui/unwrap_in_result.stderr
new file mode 100644
index 00000000000..56bc2f2d1c0
--- /dev/null
+++ b/tests/ui/unwrap_in_result.stderr
@@ -0,0 +1,41 @@
+error: used unwrap or expect in a function that returns result or option
+  --> $DIR/unwrap_in_result.rs:22:5
+   |
+LL | /     fn bad_divisible_by_3(i_str: String) -> Result<bool, String> {
+LL | |         // checks whether a string represents a number divisible by 3
+LL | |         let i = i_str.parse::<i32>().unwrap();
+LL | |         if i % 3 == 0 {
+...  |
+LL | |         }
+LL | |     }
+   | |_____^
+   |
+   = note: `-D clippy::unwrap-in-result` implied by `-D warnings`
+   = help: unwrap and expect should not be used in a function that returns result or option
+note: potential non-recoverable error(s)
+  --> $DIR/unwrap_in_result.rs:24:17
+   |
+LL |         let i = i_str.parse::<i32>().unwrap();
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: used unwrap or expect in a function that returns result or option
+  --> $DIR/unwrap_in_result.rs:32:5
+   |
+LL | /     fn example_option_expect(i_str: String) -> Option<bool> {
+LL | |         let i = i_str.parse::<i32>().expect("not a number");
+LL | |         if i % 3 == 0 {
+LL | |             return Some(true);
+LL | |         }
+LL | |         None
+LL | |     }
+   | |_____^
+   |
+   = help: unwrap and expect should not be used in a function that returns result or option
+note: potential non-recoverable error(s)
+  --> $DIR/unwrap_in_result.rs:33:17
+   |
+LL |         let i = i_str.parse::<i32>().expect("not a number");
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 04bff17668be1305d9efe235665a32727ff3e0b5 Mon Sep 17 00:00:00 2001
From: Takayuki Nakata <f.seasons017@gmail.com>
Date: Thu, 27 Aug 2020 23:37:47 +0900
Subject: Fix FP in `to_string_in_display`

Don't emit a lint when `.to_string()` on anything that is not `self`
---
 clippy_lints/src/to_string_in_display.rs | 32 +++++++++++++++++++++++++++-----
 tests/ui/to_string_in_display.rs         | 14 ++++++++++++++
 2 files changed, 41 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/to_string_in_display.rs b/clippy_lints/src/to_string_in_display.rs
index 4b6a0a6a0c9..006d7a3a12d 100644
--- a/clippy_lints/src/to_string_in_display.rs
+++ b/clippy_lints/src/to_string_in_display.rs
@@ -1,6 +1,7 @@
-use crate::utils::{match_def_path, match_trait_method, paths, span_lint};
+use crate::utils::{match_def_path, match_trait_method, paths, qpath_res, span_lint};
 use if_chain::if_chain;
-use rustc_hir::{Expr, ExprKind, Item, ItemKind};
+use rustc_hir::def::Res;
+use rustc_hir::{Expr, ExprKind, HirId, ImplItem, ImplItemKind, Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 
@@ -45,11 +46,15 @@ declare_clippy_lint! {
 #[derive(Default)]
 pub struct ToStringInDisplay {
     in_display_impl: bool,
+    self_hir_id: Option<HirId>,
 }
 
 impl ToStringInDisplay {
     pub fn new() -> Self {
-        Self { in_display_impl: false }
+        Self {
+            in_display_impl: false,
+            self_hir_id: None,
+        }
     }
 }
 
@@ -65,16 +70,33 @@ impl LateLintPass<'_> for ToStringInDisplay {
     fn check_item_post(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
         if is_display_impl(cx, item) {
             self.in_display_impl = false;
+            self.self_hir_id = None;
+        }
+    }
+
+    fn check_impl_item(&mut self, cx: &LateContext<'_>, impl_item: &ImplItem<'_>) {
+        if_chain! {
+            if self.in_display_impl;
+            if let ImplItemKind::Fn(.., body_id) = &impl_item.kind;
+            let body = cx.tcx.hir().body(*body_id);
+            if !body.params.is_empty();
+            then {
+                let self_param = &body.params[0];
+                self.self_hir_id = Some(self_param.pat.hir_id);
+            }
         }
     }
 
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
         if_chain! {
-            if let ExprKind::MethodCall(ref path, _, _, _) = expr.kind;
+            if let ExprKind::MethodCall(ref path, _, args, _) = expr.kind;
             if path.ident.name == sym!(to_string);
             if match_trait_method(cx, expr, &paths::TO_STRING);
             if self.in_display_impl;
-
+            if let ExprKind::Path(ref qpath) = args[0].kind;
+            if let Res::Local(hir_id) = qpath_res(cx, qpath, args[0].hir_id);
+            if let Some(self_hir_id) = self.self_hir_id;
+            if hir_id == self_hir_id;
             then {
                 span_lint(
                     cx,
diff --git a/tests/ui/to_string_in_display.rs b/tests/ui/to_string_in_display.rs
index 3b46324704e..eb8105c6b6d 100644
--- a/tests/ui/to_string_in_display.rs
+++ b/tests/ui/to_string_in_display.rs
@@ -44,6 +44,20 @@ impl fmt::Display for C {
     }
 }
 
+enum D {
+    E(String),
+    F,
+}
+
+impl std::fmt::Display for D {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match &self {
+            Self::E(string) => write!(f, "E {}", string.to_string()),
+            Self::F => write!(f, "F"),
+        }
+    }
+}
+
 fn main() {
     let a = A;
     a.to_string();
-- 
cgit 1.4.1-3-g733a5


From 2a3ee5fa854b49530008582900c6ea7fac120d1c Mon Sep 17 00:00:00 2001
From: ThibsG <Thibs@debian.com>
Date: Tue, 7 Jul 2020 22:47:32 +0200
Subject: Fix FP in `new_ret_no_self`: trigger in trait def instead of impl
 block

---
 clippy_lints/src/methods/mod.rs |  58 ++++++++++++++++--
 tests/ui/new_ret_no_self.rs     | 130 ++++++++++++++++++++++++++++++++++++++++
 tests/ui/new_ret_no_self.stderr |  30 +++++++++-
 3 files changed, 212 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 1ef54d285f6..8e91cbb3cdf 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -15,6 +15,7 @@ use rustc_ast::ast;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_hir::intravisit::{self, Visitor};
+use rustc_hir::{FnRetTy, FnSig, TraitItem, TraitItemKind};
 use rustc_lint::{LateContext, LateLintPass, Lint, LintContext};
 use rustc_middle::hir::map::Map;
 use rustc_middle::lint::in_external_macro;
@@ -28,11 +29,11 @@ use crate::consts::{constant, Constant};
 use crate::utils::usage::mutated_variables;
 use crate::utils::{
     get_arg_name, get_parent_expr, get_trait_def_id, has_iter_method, higher, implements_trait, in_macro, is_copy,
-    is_ctor_or_promotable_const_function, is_expn_of, is_type_diagnostic_item, iter_input_pats, last_path_segment,
-    match_def_path, match_qpath, match_trait_method, match_type, match_var, method_calls, method_chain_args, paths,
-    remove_blocks, return_ty, single_segment_path, snippet, snippet_with_applicability, snippet_with_macro_callsite,
-    span_lint, span_lint_and_help, span_lint_and_note, span_lint_and_sugg, span_lint_and_then, sugg, walk_ptrs_ty,
-    walk_ptrs_ty_depth, SpanlessEq,
+    is_ctor_or_promotable_const_function, is_expn_of, is_self_ty, is_type_diagnostic_item, iter_input_pats,
+    last_path_segment, match_def_path, match_qpath, match_trait_method, match_type, match_var, method_calls,
+    method_chain_args, paths, remove_blocks, return_ty, single_segment_path, snippet, snippet_with_applicability,
+    snippet_with_macro_callsite, span_lint, span_lint_and_help, span_lint_and_note, span_lint_and_sugg,
+    span_lint_and_then, sugg, walk_ptrs_ty, walk_ptrs_ty_depth, SpanlessEq,
 };
 
 declare_clippy_lint! {
@@ -1631,6 +1632,11 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             }
         }
 
+        // if this impl block implements a trait, lint in trait definition instead
+        if let hir::ItemKind::Impl { of_trait: Some(_), .. } = item.kind {
+            return;
+        }
+
         if let hir::ImplItemKind::Fn(_, _) = impl_item.kind {
             let ret_ty = return_ty(cx, impl_item.hir_id);
 
@@ -1670,6 +1676,48 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             }
         }
     }
+
+    fn check_trait_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx TraitItem<'_>) {
+        if_chain! {
+            if !in_external_macro(cx.tcx.sess, item.span);
+            if !item.span.from_expansion();
+            if item.ident.name == sym!(new);
+            if let TraitItemKind::Fn(FnSig { decl, .. }, _) = &item.kind;
+            if let FnRetTy::Return(ret_ty) = &decl.output;
+
+            then {
+                let mut visitor = HasSelfVisitor { has_self_ty: false };
+                visitor.visit_ty(ret_ty);
+                if !visitor.has_self_ty {
+                    span_lint(
+                        cx,
+                        NEW_RET_NO_SELF,
+                        item.span,
+                        "methods called `new` usually return `Self`",
+                    );
+                }
+            }
+        }
+    }
+}
+
+struct HasSelfVisitor {
+    pub has_self_ty: bool,
+}
+
+impl<'tcx> intravisit::Visitor<'tcx> for HasSelfVisitor {
+    type Map = Map<'tcx>;
+
+    fn visit_ty(&mut self, ty: &'tcx hir::Ty<'_>) {
+        if is_self_ty(ty) {
+            self.has_self_ty = true;
+        } else {
+            intravisit::walk_ty(self, ty);
+        }
+    }
+    fn nested_visit_map(&mut self) -> intravisit::NestedVisitorMap<Self::Map> {
+        intravisit::NestedVisitorMap::None
+    }
 }
 
 /// Checks for the `OR_FUN_CALL` lint.
diff --git a/tests/ui/new_ret_no_self.rs b/tests/ui/new_ret_no_self.rs
index 2c2d1e27589..e98360ea691 100644
--- a/tests/ui/new_ret_no_self.rs
+++ b/tests/ui/new_ret_no_self.rs
@@ -210,3 +210,133 @@ impl<'a> WithLifetime<'a> {
         unimplemented!();
     }
 }
+
+mod issue5435 {
+    struct V;
+
+    pub trait TraitRetSelf {
+        // should not trigger lint
+        fn new() -> Self;
+    }
+
+    pub trait TraitRet {
+        // should trigger lint as we are in trait definition
+        fn new() -> String;
+    }
+    pub struct StructRet;
+    impl TraitRet for StructRet {
+        // should not trigger lint as we are in the impl block
+        fn new() -> String {
+            unimplemented!();
+        }
+    }
+
+    pub trait TraitRet2 {
+        // should trigger lint
+        fn new(_: String) -> String;
+    }
+
+    trait TupleReturnerOk {
+        // should not trigger lint
+        fn new() -> (Self, u32)
+        where
+            Self: Sized,
+        {
+            unimplemented!();
+        }
+    }
+
+    trait TupleReturnerOk2 {
+        // should not trigger lint (it doesn't matter which element in the tuple is Self)
+        fn new() -> (u32, Self)
+        where
+            Self: Sized,
+        {
+            unimplemented!();
+        }
+    }
+
+    trait TupleReturnerOk3 {
+        // should not trigger lint (tuple can contain multiple Self)
+        fn new() -> (Self, Self)
+        where
+            Self: Sized,
+        {
+            unimplemented!();
+        }
+    }
+
+    trait TupleReturnerBad {
+        // should trigger lint
+        fn new() -> (u32, u32) {
+            unimplemented!();
+        }
+    }
+
+    trait MutPointerReturnerOk {
+        // should not trigger lint
+        fn new() -> *mut Self
+        where
+            Self: Sized,
+        {
+            unimplemented!();
+        }
+    }
+
+    trait MutPointerReturnerOk2 {
+        // should not trigger lint
+        fn new() -> *const Self
+        where
+            Self: Sized,
+        {
+            unimplemented!();
+        }
+    }
+
+    trait MutPointerReturnerBad {
+        // should trigger lint
+        fn new() -> *mut V {
+            unimplemented!();
+        }
+    }
+
+    trait GenericReturnerOk {
+        // should not trigger lint
+        fn new() -> Option<Self>
+        where
+            Self: Sized,
+        {
+            unimplemented!();
+        }
+    }
+
+    trait NestedReturnerOk {
+        // should not trigger lint
+        fn new() -> (Option<Self>, u32)
+        where
+            Self: Sized,
+        {
+            unimplemented!();
+        }
+    }
+
+    trait NestedReturnerOk2 {
+        // should not trigger lint
+        fn new() -> ((Self, u32), u32)
+        where
+            Self: Sized,
+        {
+            unimplemented!();
+        }
+    }
+
+    trait NestedReturnerOk3 {
+        // should not trigger lint
+        fn new() -> Option<(Self, u32)>
+        where
+            Self: Sized,
+        {
+            unimplemented!();
+        }
+    }
+}
diff --git a/tests/ui/new_ret_no_self.stderr b/tests/ui/new_ret_no_self.stderr
index dd5a24bcbe7..8217bc6187f 100644
--- a/tests/ui/new_ret_no_self.stderr
+++ b/tests/ui/new_ret_no_self.stderr
@@ -48,5 +48,33 @@ LL | |         unimplemented!();
 LL | |     }
    | |_____^
 
-error: aborting due to 6 previous errors
+error: methods called `new` usually return `Self`
+  --> $DIR/new_ret_no_self.rs:224:9
+   |
+LL |         fn new() -> String;
+   |         ^^^^^^^^^^^^^^^^^^^
+
+error: methods called `new` usually return `Self`
+  --> $DIR/new_ret_no_self.rs:236:9
+   |
+LL |         fn new(_: String) -> String;
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: methods called `new` usually return `Self`
+  --> $DIR/new_ret_no_self.rs:271:9
+   |
+LL | /         fn new() -> (u32, u32) {
+LL | |             unimplemented!();
+LL | |         }
+   | |_________^
+
+error: methods called `new` usually return `Self`
+  --> $DIR/new_ret_no_self.rs:298:9
+   |
+LL | /         fn new() -> *mut V {
+LL | |             unimplemented!();
+LL | |         }
+   | |_________^
+
+error: aborting due to 10 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 3cb75c2e5cdd4f450f2974c5e052d569674d95fd Mon Sep 17 00:00:00 2001
From: ThibsG <Thibs@debian.com>
Date: Tue, 25 Aug 2020 09:16:08 +0200
Subject: Remove expansion restriction + fix doc and tests naming

---
 clippy_lints/src/methods/mod.rs | 34 ++++++++++++++++++++++++----------
 tests/ui/new_ret_no_self.rs     |  6 +++---
 2 files changed, 27 insertions(+), 13 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 8e91cbb3cdf..2388310628f 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -725,6 +725,7 @@ declare_clippy_lint! {
     /// **Known problems:** None.
     ///
     /// **Example:**
+    /// In an impl block:
     /// ```rust
     /// # struct Foo;
     /// # struct NotAFoo;
@@ -737,25 +738,40 @@ declare_clippy_lint! {
     ///
     /// ```rust
     /// # struct Foo;
-    /// # struct FooError;
+    /// struct Bar(Foo);
     /// impl Foo {
-    ///     // Good. Return type contains `Self`
-    ///     fn new() -> Result<Foo, FooError> {
-    ///         # Ok(Foo)
+    ///     // Bad. The type name must contain `Self`
+    ///     fn new() -> Bar {
+    /// # Bar(Foo)
     ///     }
     /// }
     /// ```
     ///
     /// ```rust
     /// # struct Foo;
-    /// struct Bar(Foo);
+    /// # struct FooError;
     /// impl Foo {
-    ///     // Bad. The type name must contain `Self`.
-    ///     fn new() -> Bar {
-    ///         # Bar(Foo)
+    ///     // Good. Return type contains `Self`
+    ///     fn new() -> Result<Foo, FooError> {
+    /// # Ok(Foo)
     ///     }
     /// }
     /// ```
+    ///
+    /// Or in a trait definition:
+    /// ```rust
+    /// pub trait Trait {
+    ///     // Bad. The type name must contain `Self`
+    ///     fn new();
+    /// }
+    /// ```
+    ///
+    /// ```rust
+    /// pub trait Trait {
+    ///     // Good. Return type contains `Self`
+    ///     fn new() -> Self;
+    /// }
+    /// ```
     pub NEW_RET_NO_SELF,
     style,
     "not returning type containing `Self` in a `new` method"
@@ -1679,8 +1695,6 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
 
     fn check_trait_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx TraitItem<'_>) {
         if_chain! {
-            if !in_external_macro(cx.tcx.sess, item.span);
-            if !item.span.from_expansion();
             if item.ident.name == sym!(new);
             if let TraitItemKind::Fn(FnSig { decl, .. }, _) = &item.kind;
             if let FnRetTy::Return(ret_ty) = &decl.output;
diff --git a/tests/ui/new_ret_no_self.rs b/tests/ui/new_ret_no_self.rs
index e98360ea691..e82873629a5 100644
--- a/tests/ui/new_ret_no_self.rs
+++ b/tests/ui/new_ret_no_self.rs
@@ -137,9 +137,9 @@ impl MutPointerReturnerOk {
     }
 }
 
-struct MutPointerReturnerOk2;
+struct ConstPointerReturnerOk2;
 
-impl MutPointerReturnerOk2 {
+impl ConstPointerReturnerOk2 {
     // should not trigger lint
     pub fn new() -> *const Self {
         unimplemented!();
@@ -283,7 +283,7 @@ mod issue5435 {
         }
     }
 
-    trait MutPointerReturnerOk2 {
+    trait ConstPointerReturnerOk2 {
         // should not trigger lint
         fn new() -> *const Self
         where
-- 
cgit 1.4.1-3-g733a5


From 504612622f2801b43dbe3e6788d2404d394376df Mon Sep 17 00:00:00 2001
From: ThibsG <Thibs@debian.com>
Date: Thu, 27 Aug 2020 18:24:59 +0200
Subject: Merge logic of looking for `Self` type

---
 clippy_lints/src/methods/mod.rs | 62 +++++++++++------------------------------
 clippy_lints/src/utils/mod.rs   | 11 +++++++-
 2 files changed, 26 insertions(+), 47 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 2388310628f..63e0c183113 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -15,12 +15,11 @@ use rustc_ast::ast;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_hir::intravisit::{self, Visitor};
-use rustc_hir::{FnRetTy, FnSig, TraitItem, TraitItemKind};
+use rustc_hir::{TraitItem, TraitItemKind};
 use rustc_lint::{LateContext, LateLintPass, Lint, LintContext};
 use rustc_middle::hir::map::Map;
 use rustc_middle::lint::in_external_macro;
-use rustc_middle::ty::subst::GenericArgKind;
-use rustc_middle::ty::{self, Ty, TyS};
+use rustc_middle::ty::{self, TraitRef, Ty, TyS};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
 use rustc_span::symbol::{sym, SymbolStr};
@@ -28,8 +27,8 @@ use rustc_span::symbol::{sym, SymbolStr};
 use crate::consts::{constant, Constant};
 use crate::utils::usage::mutated_variables;
 use crate::utils::{
-    get_arg_name, get_parent_expr, get_trait_def_id, has_iter_method, higher, implements_trait, in_macro, is_copy,
-    is_ctor_or_promotable_const_function, is_expn_of, is_self_ty, is_type_diagnostic_item, iter_input_pats,
+    contains_ty, get_arg_name, get_parent_expr, get_trait_def_id, has_iter_method, higher, implements_trait, in_macro,
+    is_copy, is_ctor_or_promotable_const_function, is_expn_of, is_type_diagnostic_item, iter_input_pats,
     last_path_segment, match_def_path, match_qpath, match_trait_method, match_type, match_var, method_calls,
     method_chain_args, paths, remove_blocks, return_ty, single_segment_path, snippet, snippet_with_applicability,
     snippet_with_macro_callsite, span_lint, span_lint_and_help, span_lint_and_note, span_lint_and_sugg,
@@ -1656,16 +1655,8 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
         if let hir::ImplItemKind::Fn(_, _) = impl_item.kind {
             let ret_ty = return_ty(cx, impl_item.hir_id);
 
-            let contains_self_ty = |ty: Ty<'tcx>| {
-                ty.walk().any(|inner| match inner.unpack() {
-                    GenericArgKind::Type(inner_ty) => TyS::same_type(self_ty, inner_ty),
-
-                    GenericArgKind::Lifetime(_) | GenericArgKind::Const(_) => false,
-                })
-            };
-
             // walk the return type and check for Self (this does not check associated types)
-            if contains_self_ty(ret_ty) {
+            if contains_ty(ret_ty, self_ty) {
                 return;
             }
 
@@ -1675,7 +1666,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
                 for &(predicate, _span) in cx.tcx.predicates_of(def_id).predicates {
                     if let ty::PredicateAtom::Projection(projection_predicate) = predicate.skip_binders() {
                         // walk the associated type and check for Self
-                        if contains_self_ty(projection_predicate.ty) {
+                        if contains_ty(projection_predicate.ty, self_ty) {
                             return;
                         }
                     }
@@ -1696,44 +1687,23 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
     fn check_trait_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx TraitItem<'_>) {
         if_chain! {
             if item.ident.name == sym!(new);
-            if let TraitItemKind::Fn(FnSig { decl, .. }, _) = &item.kind;
-            if let FnRetTy::Return(ret_ty) = &decl.output;
+            if let TraitItemKind::Fn(_, _) = item.kind;
+            let ret_ty = return_ty(cx, item.hir_id);
+            let self_ty = TraitRef::identity(cx.tcx, item.hir_id.owner.to_def_id()).self_ty();
+            if !contains_ty(ret_ty, self_ty);
 
             then {
-                let mut visitor = HasSelfVisitor { has_self_ty: false };
-                visitor.visit_ty(ret_ty);
-                if !visitor.has_self_ty {
-                    span_lint(
-                        cx,
-                        NEW_RET_NO_SELF,
-                        item.span,
-                        "methods called `new` usually return `Self`",
-                    );
-                }
+                span_lint(
+                    cx,
+                    NEW_RET_NO_SELF,
+                    item.span,
+                    "methods called `new` usually return `Self`",
+                );
             }
         }
     }
 }
 
-struct HasSelfVisitor {
-    pub has_self_ty: bool,
-}
-
-impl<'tcx> intravisit::Visitor<'tcx> for HasSelfVisitor {
-    type Map = Map<'tcx>;
-
-    fn visit_ty(&mut self, ty: &'tcx hir::Ty<'_>) {
-        if is_self_ty(ty) {
-            self.has_self_ty = true;
-        } else {
-            intravisit::walk_ty(self, ty);
-        }
-    }
-    fn nested_visit_map(&mut self) -> intravisit::NestedVisitorMap<Self::Map> {
-        intravisit::NestedVisitorMap::None
-    }
-}
-
 /// Checks for the `OR_FUN_CALL` lint.
 #[allow(clippy::too_many_lines)]
 fn lint_or_fun_call<'tcx>(
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index e6be5c4588f..07ec59f452a 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -42,7 +42,8 @@ use rustc_hir::{
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::{LateContext, Level, Lint, LintContext};
 use rustc_middle::hir::map::Map;
-use rustc_middle::ty::{self, layout::IntegerExt, subst::GenericArg, Ty, TyCtxt, TypeFoldable};
+use rustc_middle::ty::subst::{GenericArg, GenericArgKind};
+use rustc_middle::ty::{self, layout::IntegerExt, Ty, TyCtxt, TypeFoldable};
 use rustc_mir::const_eval;
 use rustc_span::hygiene::{ExpnKind, MacroKind};
 use rustc_span::source_map::original_sp;
@@ -866,6 +867,14 @@ pub fn return_ty<'tcx>(cx: &LateContext<'tcx>, fn_item: hir::HirId) -> Ty<'tcx>
     cx.tcx.erase_late_bound_regions(&ret_ty)
 }
 
+/// Walk into `ty` and returns `true` if any inner type is the same as `other_ty`
+pub fn contains_ty<'tcx>(ty: Ty<'tcx>, other_ty: Ty<'tcx>) -> bool {
+    ty.walk().any(|inner| match inner.unpack() {
+        GenericArgKind::Type(inner_ty) => ty::TyS::same_type(other_ty, inner_ty),
+        GenericArgKind::Lifetime(_) | GenericArgKind::Const(_) => false,
+    })
+}
+
 /// Returns `true` if the given type is an `unsafe` function.
 pub fn type_is_unsafe_function<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
     match ty.kind {
-- 
cgit 1.4.1-3-g733a5


From f3ccbef2af24d5d83f82f1fb50bd97a9b75e609f Mon Sep 17 00:00:00 2001
From: Tim Nielens <tim.nielens@gmail.com>
Date: Thu, 27 Aug 2020 01:40:02 +0200
Subject: unit-arg - pr comments

---
 clippy_lints/src/types.rs             | 41 +++++++++++++-----
 clippy_lints/src/utils/mod.rs         |  2 +-
 tests/ui/unit_arg.rs                  |  8 +++-
 tests/ui/unit_arg.stderr              | 79 +++++++++++++++++++----------------
 tests/ui/unit_arg_empty_blocks.stderr | 11 +++--
 5 files changed, 88 insertions(+), 53 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs
index 3f5b3a5bcd5..16e48d91916 100644
--- a/clippy_lints/src/types.rs
+++ b/clippy_lints/src/types.rs
@@ -29,10 +29,10 @@ use rustc_typeck::hir_ty_to_ty;
 use crate::consts::{constant, Constant};
 use crate::utils::paths;
 use crate::utils::{
-    clip, comparisons, differing_macro_contexts, higher, in_constant, int_bits, is_type_diagnostic_item,
+    clip, comparisons, differing_macro_contexts, higher, in_constant, indent_of, int_bits, is_type_diagnostic_item,
     last_path_segment, match_def_path, match_path, method_chain_args, multispan_sugg, numeric_literal::NumericLiteral,
     qpath_res, sext, snippet, snippet_opt, snippet_with_applicability, snippet_with_macro_callsite, span_lint,
-    span_lint_and_help, span_lint_and_sugg, span_lint_and_then, unsext,
+    span_lint_and_help, span_lint_and_sugg, span_lint_and_then, trim_multiline, unsext,
 };
 
 declare_clippy_lint! {
@@ -802,6 +802,7 @@ impl<'tcx> LateLintPass<'tcx> for UnitArg {
     }
 }
 
+#[allow(clippy::too_many_lines)]
 fn lint_unit_args(cx: &LateContext<'_>, expr: &Expr<'_>, args_to_recover: &[&Expr<'_>]) {
     let mut applicability = Applicability::MachineApplicable;
     let (singular, plural) = if args_to_recover.len() > 1 {
@@ -856,18 +857,38 @@ fn lint_unit_args(cx: &LateContext<'_>, expr: &Expr<'_>, args_to_recover: &[&Exp
                 .filter(|arg| !is_empty_block(arg))
                 .filter_map(|arg| snippet_opt(cx, arg.span))
                 .collect();
+            let indent = indent_of(cx, expr.span).unwrap_or(0);
 
-            if let Some(mut sugg) = snippet_opt(cx, expr.span) {
-                arg_snippets.iter().for_each(|arg| {
-                    sugg = sugg.replacen(arg, "()", 1);
-                });
-                sugg = format!("{}{}{}", arg_snippets_without_empty_blocks.join("; "), "; ", sugg);
+            if let Some(expr_str) = snippet_opt(cx, expr.span) {
+                let expr_with_replacements = arg_snippets
+                    .iter()
+                    .fold(expr_str, |acc, arg| acc.replacen(arg, "()", 1));
+
+                // expr is not in a block statement or result expression position, wrap in a block
                 let parent_node = cx.tcx.hir().find(cx.tcx.hir().get_parent_node(expr.hir_id));
-                if !matches!(parent_node, Some(Node::Block(_))) && !matches!(parent_node, Some(Node::Stmt(_))) {
-                    // expr is not in a block statement or result expression position, wrap in a block
-                    sugg = format!("{{ {} }}", sugg);
+                let wrap_in_block =
+                    !matches!(parent_node, Some(Node::Block(_))) && !matches!(parent_node, Some(Node::Stmt(_)));
+
+                let stmts_indent = if wrap_in_block { indent + 4 } else { indent };
+                let mut stmts_and_call = arg_snippets_without_empty_blocks.clone();
+                stmts_and_call.push(expr_with_replacements);
+                let mut stmts_and_call_str = stmts_and_call
+                    .into_iter()
+                    .enumerate()
+                    .map(|(i, v)| {
+                        let with_indent_prefix = if i > 0 { " ".repeat(stmts_indent) + &v } else { v };
+                        trim_multiline(with_indent_prefix.into(), true, Some(stmts_indent)).into_owned()
+                    })
+                    .collect::<Vec<String>>()
+                    .join(";\n");
+
+                if wrap_in_block {
+                    stmts_and_call_str = " ".repeat(stmts_indent) + &stmts_and_call_str;
+                    stmts_and_call_str = format!("{{\n{}\n{}}}", &stmts_and_call_str, " ".repeat(indent));
                 }
 
+                let sugg = stmts_and_call_str;
+
                 if arg_snippets_without_empty_blocks.is_empty() {
                     db.multipart_suggestion(
                         &format!("use {}unit literal{} instead", singular, plural),
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index 2aef995cec4..d20b33c4a1d 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -662,7 +662,7 @@ pub fn expr_block<'a, T: LintContext>(
 
 /// Trim indentation from a multiline string with possibility of ignoring the
 /// first line.
-fn trim_multiline(s: Cow<'_, str>, ignore_first: bool, indent: Option<usize>) -> Cow<'_, str> {
+pub fn trim_multiline(s: Cow<'_, str>, ignore_first: bool, indent: Option<usize>) -> Cow<'_, str> {
     let s_space = trim_multiline_inner(s, ignore_first, indent, ' ');
     let s_tab = trim_multiline_inner(s_space, ignore_first, indent, '\t');
     trim_multiline_inner(s_tab, ignore_first, indent, ' ')
diff --git a/tests/ui/unit_arg.rs b/tests/ui/unit_arg.rs
index 2e2bd054e42..fec115ff29d 100644
--- a/tests/ui/unit_arg.rs
+++ b/tests/ui/unit_arg.rs
@@ -1,5 +1,11 @@
 #![warn(clippy::unit_arg)]
-#![allow(clippy::no_effect, unused_must_use, unused_variables, clippy::unused_unit)]
+#![allow(
+    clippy::no_effect,
+    unused_must_use,
+    unused_variables,
+    clippy::unused_unit,
+    clippy::or_fun_call
+)]
 
 use std::fmt::Debug;
 
diff --git a/tests/ui/unit_arg.stderr b/tests/ui/unit_arg.stderr
index 2a0cc1f18e2..90fee3aab23 100644
--- a/tests/ui/unit_arg.stderr
+++ b/tests/ui/unit_arg.stderr
@@ -1,5 +1,5 @@
 error: passing a unit value to a function
-  --> $DIR/unit_arg.rs:23:5
+  --> $DIR/unit_arg.rs:29:5
    |
 LL | /     foo({
 LL | |         1;
@@ -15,22 +15,24 @@ help: or move the expression in front of the call and replace it with the unit l
    |
 LL |     {
 LL |         1;
-LL |     }; foo(());
+LL |     };
+LL |     foo(());
    |
 
 error: passing a unit value to a function
-  --> $DIR/unit_arg.rs:26:5
+  --> $DIR/unit_arg.rs:32:5
    |
 LL |     foo(foo(1));
    |     ^^^^^^^^^^^
    |
 help: move the expression in front of the call and replace it with the unit literal `()`
    |
-LL |     foo(1); foo(());
-   |     ^^^^^^^^^^^^^^^
+LL |     foo(1);
+LL |     foo(());
+   |
 
 error: passing a unit value to a function
-  --> $DIR/unit_arg.rs:27:5
+  --> $DIR/unit_arg.rs:33:5
    |
 LL | /     foo({
 LL | |         foo(1);
@@ -47,11 +49,12 @@ help: or move the expression in front of the call and replace it with the unit l
 LL |     {
 LL |         foo(1);
 LL |         foo(2);
-LL |     }; foo(());
+LL |     };
+LL |     foo(());
    |
 
 error: passing a unit value to a function
-  --> $DIR/unit_arg.rs:32:5
+  --> $DIR/unit_arg.rs:38:5
    |
 LL | /     b.bar({
 LL | |         1;
@@ -66,22 +69,25 @@ help: or move the expression in front of the call and replace it with the unit l
    |
 LL |     {
 LL |         1;
-LL |     }; b.bar(());
+LL |     };
+LL |     b.bar(());
    |
 
 error: passing unit values to a function
-  --> $DIR/unit_arg.rs:35:5
+  --> $DIR/unit_arg.rs:41:5
    |
 LL |     taking_multiple_units(foo(0), foo(1));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: move the expressions in front of the call and replace them with the unit literal `()`
    |
-LL |     foo(0); foo(1); taking_multiple_units((), ());
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |     foo(0);
+LL |     foo(1);
+LL |     taking_multiple_units((), ());
+   |
 
 error: passing unit values to a function
-  --> $DIR/unit_arg.rs:36:5
+  --> $DIR/unit_arg.rs:42:5
    |
 LL | /     taking_multiple_units(foo(0), {
 LL | |         foo(1);
@@ -95,14 +101,16 @@ LL |         foo(2)
    |
 help: or move the expressions in front of the call and replace them with the unit literal `()`
    |
-LL |     foo(0); {
+LL |     foo(0);
+LL |     {
 LL |         foo(1);
 LL |         foo(2);
-LL |     }; taking_multiple_units((), ());
+LL |     };
+LL |     taking_multiple_units((), ());
    |
 
 error: passing unit values to a function
-  --> $DIR/unit_arg.rs:40:5
+  --> $DIR/unit_arg.rs:46:5
    |
 LL | /     taking_multiple_units(
 LL | |         {
@@ -124,53 +132,50 @@ LL |             foo(3)
 help: or move the expressions in front of the call and replace them with the unit literal `()`
    |
 LL |     {
-LL |             foo(0);
-LL |             foo(1);
-LL |         }; {
-LL |             foo(2);
-LL |             foo(3);
+LL |         foo(0);
+LL |         foo(1);
+LL |     };
+LL |     {
+LL |         foo(2);
  ...
 
-error: use of `or` followed by a function call
-  --> $DIR/unit_arg.rs:51:10
-   |
-LL |     None.or(Some(foo(2)));
-   |          ^^^^^^^^^^^^^^^^ help: try this: `or_else(|| Some(foo(2)))`
-   |
-   = note: `-D clippy::or-fun-call` implied by `-D warnings`
-
 error: passing a unit value to a function
-  --> $DIR/unit_arg.rs:51:13
+  --> $DIR/unit_arg.rs:57:13
    |
 LL |     None.or(Some(foo(2)));
    |             ^^^^^^^^^^^^
    |
 help: move the expression in front of the call and replace it with the unit literal `()`
    |
-LL |     None.or({ foo(2); Some(()) });
-   |             ^^^^^^^^^^^^^^^^^^^^
+LL |     None.or({
+LL |         foo(2);
+LL |         Some(())
+LL |     });
+   |
 
 error: passing a unit value to a function
-  --> $DIR/unit_arg.rs:54:5
+  --> $DIR/unit_arg.rs:60:5
    |
 LL |     foo(foo(()))
    |     ^^^^^^^^^^^^
    |
 help: move the expression in front of the call and replace it with the unit literal `()`
    |
-LL |     foo(()); foo(())
+LL |     foo(());
+LL |     foo(())
    |
 
 error: passing a unit value to a function
-  --> $DIR/unit_arg.rs:87:5
+  --> $DIR/unit_arg.rs:93:5
    |
 LL |     Some(foo(1))
    |     ^^^^^^^^^^^^
    |
 help: move the expression in front of the call and replace it with the unit literal `()`
    |
-LL |     foo(1); Some(())
+LL |     foo(1);
+LL |     Some(())
    |
 
-error: aborting due to 11 previous errors
+error: aborting due to 10 previous errors
 
diff --git a/tests/ui/unit_arg_empty_blocks.stderr b/tests/ui/unit_arg_empty_blocks.stderr
index 4cbbc8b8cd4..456b12a2c6b 100644
--- a/tests/ui/unit_arg_empty_blocks.stderr
+++ b/tests/ui/unit_arg_empty_blocks.stderr
@@ -24,8 +24,9 @@ LL |     taking_two_units({}, foo(0));
    |
 help: move the expression in front of the call and replace it with the unit literal `()`
    |
-LL |     foo(0); taking_two_units((), ());
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |     foo(0);
+LL |     taking_two_units((), ());
+   |
 
 error: passing unit values to a function
   --> $DIR/unit_arg_empty_blocks.rs:18:5
@@ -35,8 +36,10 @@ LL |     taking_three_units({}, foo(0), foo(1));
    |
 help: move the expressions in front of the call and replace them with the unit literal `()`
    |
-LL |     foo(0); foo(1); taking_three_units((), (), ());
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |     foo(0);
+LL |     foo(1);
+LL |     taking_three_units((), (), ());
+   |
 
 error: aborting due to 4 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 459969f88ff95c94b7b34043a7f0e13de91de4f8 Mon Sep 17 00:00:00 2001
From: Vali Schneider <eval@fb.com>
Date: Thu, 27 Aug 2020 16:18:05 -0700
Subject: added restriction lint that prohibits the usage of unimplemented,
 unreachable or panic in a function of type result or option

---
 CHANGELOG.md                        |   1 +
 clippy_lints/src/lib.rs             |   5 ++
 clippy_lints/src/panic_in_result.rs | 100 ++++++++++++++++++++++++++++++++++
 src/lintlist/mod.rs                 |   7 +++
 tests/ui/panic_in_result.rs         |  62 +++++++++++++++++++++
 tests/ui/panic_in_result.stderr     | 105 ++++++++++++++++++++++++++++++++++++
 6 files changed, 280 insertions(+)
 create mode 100644 clippy_lints/src/panic_in_result.rs
 create mode 100644 tests/ui/panic_in_result.rs
 create mode 100644 tests/ui/panic_in_result.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 137b561028a..7af3b666cca 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1651,6 +1651,7 @@ Released 2018-09-13
 [`out_of_bounds_indexing`]: https://rust-lang.github.io/rust-clippy/master/index.html#out_of_bounds_indexing
 [`overflow_check_conditional`]: https://rust-lang.github.io/rust-clippy/master/index.html#overflow_check_conditional
 [`panic`]: https://rust-lang.github.io/rust-clippy/master/index.html#panic
+[`panic_in_result`]: https://rust-lang.github.io/rust-clippy/master/index.html#panic_in_result
 [`panic_params`]: https://rust-lang.github.io/rust-clippy/master/index.html#panic_params
 [`panicking_unwrap`]: https://rust-lang.github.io/rust-clippy/master/index.html#panicking_unwrap
 [`partialeq_ne_impl`]: https://rust-lang.github.io/rust-clippy/master/index.html#partialeq_ne_impl
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 577ce6523b4..b70d126af5b 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -267,6 +267,7 @@ mod open_options;
 mod option_env_unwrap;
 mod option_if_let_else;
 mod overflow_check_conditional;
+mod panic_in_result;
 mod panic_unimplemented;
 mod partialeq_ne_impl;
 mod path_buf_push_overwrite;
@@ -747,6 +748,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &option_env_unwrap::OPTION_ENV_UNWRAP,
         &option_if_let_else::OPTION_IF_LET_ELSE,
         &overflow_check_conditional::OVERFLOW_CHECK_CONDITIONAL,
+        &panic_in_result::PANIC_IN_RESULT,
         &panic_unimplemented::PANIC,
         &panic_unimplemented::PANIC_PARAMS,
         &panic_unimplemented::TODO,
@@ -1086,6 +1088,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box manual_async_fn::ManualAsyncFn);
     store.register_early_pass(|| box redundant_field_names::RedundantFieldNames);
     store.register_late_pass(|| box vec_resize_to_zero::VecResizeToZero);
+    store.register_late_pass(|| box panic_in_result::PanicInResult);
+
     let single_char_binding_names_threshold = conf.single_char_binding_names_threshold;
     store.register_early_pass(move || box non_expressive_names::NonExpressiveNames {
         single_char_binding_names_threshold,
@@ -1128,6 +1132,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&missing_doc::MISSING_DOCS_IN_PRIVATE_ITEMS),
         LintId::of(&missing_inline::MISSING_INLINE_IN_PUBLIC_ITEMS),
         LintId::of(&modulo_arithmetic::MODULO_ARITHMETIC),
+        LintId::of(&panic_in_result::PANIC_IN_RESULT),
         LintId::of(&panic_unimplemented::PANIC),
         LintId::of(&panic_unimplemented::TODO),
         LintId::of(&panic_unimplemented::UNIMPLEMENTED),
diff --git a/clippy_lints/src/panic_in_result.rs b/clippy_lints/src/panic_in_result.rs
new file mode 100644
index 00000000000..3a71a0db6fe
--- /dev/null
+++ b/clippy_lints/src/panic_in_result.rs
@@ -0,0 +1,100 @@
+use crate::utils::{is_expn_of, is_type_diagnostic_item, return_ty, span_lint_and_then};
+use if_chain::if_chain;
+use rustc_hir as hir;
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::hir::map::Map;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::Span;
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for usage of `panic!`, `unimplemented!` or `unreachable!` in a function of type result/option.
+    ///
+    /// **Why is this bad?** For some codebases,
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// fn option_with_panic() -> Option<bool> // should emit lint
+    /// {
+    ///     panic!("error");
+    /// }
+    /// ```
+
+    pub PANIC_IN_RESULT,
+    restriction,
+    "functions of type `Result<..>` / `Option`<...> that contain `panic!()` or `unreachable()` or `unimplemented()` "
+}
+
+declare_lint_pass!(PanicInResult => [PANIC_IN_RESULT]);
+
+impl<'tcx> LateLintPass<'tcx> for PanicInResult {
+    fn check_impl_item(&mut self, cx: &LateContext<'tcx>, impl_item: &'tcx hir::ImplItem<'_>) {
+        if_chain! {
+            // first check if it's a method or function
+            if let hir::ImplItemKind::Fn(ref _signature, _) = impl_item.kind;
+            // checking if its return type is `result` or `option`
+            if is_type_diagnostic_item(cx, return_ty(cx, impl_item.hir_id), sym!(result_type))
+                || is_type_diagnostic_item(cx, return_ty(cx, impl_item.hir_id), sym!(option_type));
+            then {
+                lint_impl_body(cx, impl_item.span, impl_item);
+            }
+        }
+    }
+}
+
+use rustc_hir::intravisit::{self, NestedVisitorMap, Visitor};
+use rustc_hir::{Expr, ImplItemKind};
+
+struct FindPanicUnimplementedUnreachable {
+    result: Vec<Span>,
+}
+
+impl<'tcx> Visitor<'tcx> for FindPanicUnimplementedUnreachable {
+    type Map = Map<'tcx>;
+
+    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
+        if is_expn_of(expr.span, "unimplemented").is_some() {
+            self.result.push(expr.span);
+        } else if is_expn_of(expr.span, "unreachable").is_some() {
+            self.result.push(expr.span);
+        } else if is_expn_of(expr.span, "panic").is_some() {
+            self.result.push(expr.span);
+        }
+
+        // and check sub-expressions
+        intravisit::walk_expr(self, expr);
+    }
+
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::None
+    }
+}
+
+fn lint_impl_body<'tcx>(cx: &LateContext<'tcx>, impl_span: Span, impl_item: &'tcx hir::ImplItem<'_>) {
+    if_chain! {
+        if let ImplItemKind::Fn(_, body_id) = impl_item.kind;
+        then {
+            let body = cx.tcx.hir().body(body_id);
+            let mut fpu = FindPanicUnimplementedUnreachable {
+                result: Vec::new(),
+            };
+            fpu.visit_expr(&body.value);
+
+            // if we've found one, lint
+            if  !fpu.result.is_empty()  {
+                span_lint_and_then(
+                    cx,
+                    PANIC_IN_RESULT,
+                    impl_span,
+                    "used unimplemented, unreachable or panic in a function that returns result or option",
+                    move |diag| {
+                        diag.help(
+                            "unimplemented, unreachable or panic should not be used in a function that returns result or option" );
+                        diag.span_note(fpu.result, "will cause the application to crash.");
+                    });
+            }
+        }
+    }
+}
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index 687fac7baa8..ad57146048e 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -1704,6 +1704,13 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
         deprecation: None,
         module: "panic_unimplemented",
     },
+    Lint {
+        name: "panic_in_result",
+        group: "restriction",
+        desc: "default lint description",
+        deprecation: None,
+        module: "panic_in_result",
+    },
     Lint {
         name: "panic_params",
         group: "style",
diff --git a/tests/ui/panic_in_result.rs b/tests/ui/panic_in_result.rs
new file mode 100644
index 00000000000..21e9efca87b
--- /dev/null
+++ b/tests/ui/panic_in_result.rs
@@ -0,0 +1,62 @@
+#![warn(clippy::panic_in_result)]
+
+struct A;
+
+impl A {
+    fn result_with_panic() -> Result<bool, String> // should emit lint
+    {
+        panic!("error");
+    }
+
+    fn result_with_unimplemented() -> Result<bool, String> // should emit lint
+    {
+        unimplemented!();
+    }
+
+    fn result_with_unreachable() -> Result<bool, String> // should emit lint
+    {
+        unreachable!();
+    }
+
+    fn option_with_unreachable() -> Option<bool> // should emit lint
+    {
+        unreachable!();
+    }
+
+    fn option_with_unimplemented() -> Option<bool> // should emit lint
+    {
+        unimplemented!();
+    }
+
+    fn option_with_panic() -> Option<bool> // should emit lint
+    {
+        panic!("error");
+    }
+
+    fn other_with_panic() // should not emit lint
+    {
+        panic!("");
+    }
+
+    fn other_with_unreachable() // should not emit lint
+    {
+        unreachable!();
+    }
+
+    fn other_with_unimplemented() // should not emit lint
+    {
+        unimplemented!();
+    }
+
+    fn result_without_banned_functions() -> Result<bool, String> // should not emit lint
+    {
+        Ok(true)
+    }
+
+    fn option_without_banned_functions() -> Option<bool> // should not emit lint
+    {
+        Some(true)
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/panic_in_result.stderr b/tests/ui/panic_in_result.stderr
new file mode 100644
index 00000000000..74273bd9abb
--- /dev/null
+++ b/tests/ui/panic_in_result.stderr
@@ -0,0 +1,105 @@
+error: used unimplemented, unreachable or panic in a function that returns result or option
+  --> $DIR/panic_in_result.rs:6:5
+   |
+LL | /     fn result_with_panic() -> Result<bool, String> // should emit lint
+LL | |     {
+LL | |         panic!("error");
+LL | |     }
+   | |_____^
+   |
+   = note: `-D clippy::panic-in-result` implied by `-D warnings`
+   = help: unimplemented, unreachable or panic should not be used in a function that returns result or option
+note: will cause the application to crash.
+  --> $DIR/panic_in_result.rs:8:9
+   |
+LL |         panic!("error");
+   |         ^^^^^^^^^^^^^^^^
+   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: used unimplemented, unreachable or panic in a function that returns result or option
+  --> $DIR/panic_in_result.rs:11:5
+   |
+LL | /     fn result_with_unimplemented() -> Result<bool, String> // should emit lint
+LL | |     {
+LL | |         unimplemented!();
+LL | |     }
+   | |_____^
+   |
+   = help: unimplemented, unreachable or panic should not be used in a function that returns result or option
+note: will cause the application to crash.
+  --> $DIR/panic_in_result.rs:13:9
+   |
+LL |         unimplemented!();
+   |         ^^^^^^^^^^^^^^^^^
+   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: used unimplemented, unreachable or panic in a function that returns result or option
+  --> $DIR/panic_in_result.rs:16:5
+   |
+LL | /     fn result_with_unreachable() -> Result<bool, String> // should emit lint
+LL | |     {
+LL | |         unreachable!();
+LL | |     }
+   | |_____^
+   |
+   = help: unimplemented, unreachable or panic should not be used in a function that returns result or option
+note: will cause the application to crash.
+  --> $DIR/panic_in_result.rs:18:9
+   |
+LL |         unreachable!();
+   |         ^^^^^^^^^^^^^^^
+   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: used unimplemented, unreachable or panic in a function that returns result or option
+  --> $DIR/panic_in_result.rs:21:5
+   |
+LL | /     fn option_with_unreachable() -> Option<bool> // should emit lint
+LL | |     {
+LL | |         unreachable!();
+LL | |     }
+   | |_____^
+   |
+   = help: unimplemented, unreachable or panic should not be used in a function that returns result or option
+note: will cause the application to crash.
+  --> $DIR/panic_in_result.rs:23:9
+   |
+LL |         unreachable!();
+   |         ^^^^^^^^^^^^^^^
+   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: used unimplemented, unreachable or panic in a function that returns result or option
+  --> $DIR/panic_in_result.rs:26:5
+   |
+LL | /     fn option_with_unimplemented() -> Option<bool> // should emit lint
+LL | |     {
+LL | |         unimplemented!();
+LL | |     }
+   | |_____^
+   |
+   = help: unimplemented, unreachable or panic should not be used in a function that returns result or option
+note: will cause the application to crash.
+  --> $DIR/panic_in_result.rs:28:9
+   |
+LL |         unimplemented!();
+   |         ^^^^^^^^^^^^^^^^^
+   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: used unimplemented, unreachable or panic in a function that returns result or option
+  --> $DIR/panic_in_result.rs:31:5
+   |
+LL | /     fn option_with_panic() -> Option<bool> // should emit lint
+LL | |     {
+LL | |         panic!("error");
+LL | |     }
+   | |_____^
+   |
+   = help: unimplemented, unreachable or panic should not be used in a function that returns result or option
+note: will cause the application to crash.
+  --> $DIR/panic_in_result.rs:33:9
+   |
+LL |         panic!("error");
+   |         ^^^^^^^^^^^^^^^^
+   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: aborting due to 6 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From ceab1a9167655eba9f9556f8766f8702e49dfef3 Mon Sep 17 00:00:00 2001
From: Vali Schneider <eval@fb.com>
Date: Thu, 27 Aug 2020 16:19:24 -0700
Subject: removed unnecessary comment

---
 clippy_lints/src/panic_in_result.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/panic_in_result.rs b/clippy_lints/src/panic_in_result.rs
index 3a71a0db6fe..4e08c991bd0 100644
--- a/clippy_lints/src/panic_in_result.rs
+++ b/clippy_lints/src/panic_in_result.rs
@@ -16,7 +16,7 @@ declare_clippy_lint! {
     /// **Example:**
     ///
     /// ```rust
-    /// fn option_with_panic() -> Option<bool> // should emit lint
+    /// fn option_with_panic() -> Option<bool>
     /// {
     ///     panic!("error");
     /// }
-- 
cgit 1.4.1-3-g733a5


From 8462cce96081b87eba7a5bc89130a1a09fe1f6d0 Mon Sep 17 00:00:00 2001
From: Vali Schneider <eval@fb.com>
Date: Thu, 27 Aug 2020 16:22:37 -0700
Subject: edited documentation

---
 clippy_lints/src/panic_in_result.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/panic_in_result.rs b/clippy_lints/src/panic_in_result.rs
index 4e08c991bd0..239b4bdbdb1 100644
--- a/clippy_lints/src/panic_in_result.rs
+++ b/clippy_lints/src/panic_in_result.rs
@@ -9,7 +9,7 @@ use rustc_span::Span;
 declare_clippy_lint! {
     /// **What it does:** Checks for usage of `panic!`, `unimplemented!` or `unreachable!` in a function of type result/option.
     ///
-    /// **Why is this bad?** For some codebases,
+    /// **Why is this bad?** For some codebases, it is desirable for functions of type option/result to return an error instead of crashing. Hence unimplemented, panic and unreachable should be avoided.
     ///
     /// **Known problems:** None.
     ///
-- 
cgit 1.4.1-3-g733a5


From b006522393a3c3c2656e1ccdfbb0076ff1bd7e99 Mon Sep 17 00:00:00 2001
From: Vali Schneider <eval@fb.com>
Date: Thu, 27 Aug 2020 16:55:23 -0700
Subject: added lint for todo and removed option

---
 clippy_lints/src/panic_in_result.rs | 26 ++++++++--------
 src/lintlist/mod.rs                 |  2 +-
 tests/ui/panic_in_result.rs         | 22 ++++----------
 tests/ui/panic_in_result.stderr     | 60 ++++++++-----------------------------
 4 files changed, 32 insertions(+), 78 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/panic_in_result.rs b/clippy_lints/src/panic_in_result.rs
index 239b4bdbdb1..2901f393fc6 100644
--- a/clippy_lints/src/panic_in_result.rs
+++ b/clippy_lints/src/panic_in_result.rs
@@ -7,16 +7,16 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::Span;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for usage of `panic!`, `unimplemented!` or `unreachable!` in a function of type result/option.
+    /// **What it does:** Checks for usage of `panic!`, `unimplemented!`, `todo!` or `unreachable!` in a function of type result.
     ///
-    /// **Why is this bad?** For some codebases, it is desirable for functions of type option/result to return an error instead of crashing. Hence unimplemented, panic and unreachable should be avoided.
+    /// **Why is this bad?** For some codebases, it is desirable for functions of type result to return an error instead of crashing. Hence unimplemented, panic and unreachable should be avoided.
     ///
     /// **Known problems:** None.
     ///
     /// **Example:**
     ///
     /// ```rust
-    /// fn option_with_panic() -> Option<bool>
+    /// fn result_with_panic() -> Result<bool, String>
     /// {
     ///     panic!("error");
     /// }
@@ -24,7 +24,7 @@ declare_clippy_lint! {
 
     pub PANIC_IN_RESULT,
     restriction,
-    "functions of type `Result<..>` / `Option`<...> that contain `panic!()` or `unreachable()` or `unimplemented()` "
+    "functions of type `Result<..>` that contain `panic!()`, `todo!()` or `unreachable()` or `unimplemented()` "
 }
 
 declare_lint_pass!(PanicInResult => [PANIC_IN_RESULT]);
@@ -35,8 +35,7 @@ impl<'tcx> LateLintPass<'tcx> for PanicInResult {
             // first check if it's a method or function
             if let hir::ImplItemKind::Fn(ref _signature, _) = impl_item.kind;
             // checking if its return type is `result` or `option`
-            if is_type_diagnostic_item(cx, return_ty(cx, impl_item.hir_id), sym!(result_type))
-                || is_type_diagnostic_item(cx, return_ty(cx, impl_item.hir_id), sym!(option_type));
+            if is_type_diagnostic_item(cx, return_ty(cx, impl_item.hir_id), sym!(result_type));
             then {
                 lint_impl_body(cx, impl_item.span, impl_item);
             }
@@ -55,14 +54,13 @@ impl<'tcx> Visitor<'tcx> for FindPanicUnimplementedUnreachable {
     type Map = Map<'tcx>;
 
     fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
-        if is_expn_of(expr.span, "unimplemented").is_some() {
-            self.result.push(expr.span);
-        } else if is_expn_of(expr.span, "unreachable").is_some() {
-            self.result.push(expr.span);
-        } else if is_expn_of(expr.span, "panic").is_some() {
+        if is_expn_of(expr.span, "unimplemented").is_some()
+            || is_expn_of(expr.span, "unreachable").is_some()
+            || is_expn_of(expr.span, "panic").is_some()
+            || is_expn_of(expr.span, "todo").is_some()
+        {
             self.result.push(expr.span);
         }
-
         // and check sub-expressions
         intravisit::walk_expr(self, expr);
     }
@@ -88,10 +86,10 @@ fn lint_impl_body<'tcx>(cx: &LateContext<'tcx>, impl_span: Span, impl_item: &'tc
                     cx,
                     PANIC_IN_RESULT,
                     impl_span,
-                    "used unimplemented, unreachable or panic in a function that returns result or option",
+                    "used unimplemented, unreachable, todo or panic in a function that returns result",
                     move |diag| {
                         diag.help(
-                            "unimplemented, unreachable or panic should not be used in a function that returns result or option" );
+                            "unimplemented, unreachable, todo or panic should not be used in a function that returns result" );
                         diag.span_note(fpu.result, "will cause the application to crash.");
                     });
             }
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index b4f20ca7f14..1f56c56f081 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -1707,7 +1707,7 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
     Lint {
         name: "panic_in_result",
         group: "restriction",
-        desc: "functions of type `Result<..>` / `Option`<...> that contain `panic!()` or `unreachable()` or `unimplemented()` ",
+        desc: "functions of type `Result<..>` that contain `panic!()`, `todo!()` or `unreachable()` or `unimplemented()` ",
         deprecation: None,
         module: "panic_in_result",
     },
diff --git a/tests/ui/panic_in_result.rs b/tests/ui/panic_in_result.rs
index 21e9efca87b..056778995a4 100644
--- a/tests/ui/panic_in_result.rs
+++ b/tests/ui/panic_in_result.rs
@@ -18,19 +18,9 @@ impl A {
         unreachable!();
     }
 
-    fn option_with_unreachable() -> Option<bool> // should emit lint
+    fn result_with_todo() -> Result<bool, String> // should emit lint
     {
-        unreachable!();
-    }
-
-    fn option_with_unimplemented() -> Option<bool> // should emit lint
-    {
-        unimplemented!();
-    }
-
-    fn option_with_panic() -> Option<bool> // should emit lint
-    {
-        panic!("error");
+        todo!("Finish this");
     }
 
     fn other_with_panic() // should not emit lint
@@ -48,14 +38,14 @@ impl A {
         unimplemented!();
     }
 
-    fn result_without_banned_functions() -> Result<bool, String> // should not emit lint
+    fn other_with_todo() // should not emit lint
     {
-        Ok(true)
+        todo!("finish this")
     }
 
-    fn option_without_banned_functions() -> Option<bool> // should not emit lint
+    fn result_without_banned_functions() -> Result<bool, String> // should not emit lint
     {
-        Some(true)
+        Ok(true)
     }
 }
 
diff --git a/tests/ui/panic_in_result.stderr b/tests/ui/panic_in_result.stderr
index 74273bd9abb..3b9ac69f20d 100644
--- a/tests/ui/panic_in_result.stderr
+++ b/tests/ui/panic_in_result.stderr
@@ -1,4 +1,4 @@
-error: used unimplemented, unreachable or panic in a function that returns result or option
+error: used unimplemented, unreachable, todo or panic in a function that returns result
   --> $DIR/panic_in_result.rs:6:5
    |
 LL | /     fn result_with_panic() -> Result<bool, String> // should emit lint
@@ -8,7 +8,7 @@ LL | |     }
    | |_____^
    |
    = note: `-D clippy::panic-in-result` implied by `-D warnings`
-   = help: unimplemented, unreachable or panic should not be used in a function that returns result or option
+   = help: unimplemented, unreachable, todo or panic should not be used in a function that returns result
 note: will cause the application to crash.
   --> $DIR/panic_in_result.rs:8:9
    |
@@ -16,7 +16,7 @@ LL |         panic!("error");
    |         ^^^^^^^^^^^^^^^^
    = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: used unimplemented, unreachable or panic in a function that returns result or option
+error: used unimplemented, unreachable, todo or panic in a function that returns result
   --> $DIR/panic_in_result.rs:11:5
    |
 LL | /     fn result_with_unimplemented() -> Result<bool, String> // should emit lint
@@ -25,7 +25,7 @@ LL | |         unimplemented!();
 LL | |     }
    | |_____^
    |
-   = help: unimplemented, unreachable or panic should not be used in a function that returns result or option
+   = help: unimplemented, unreachable, todo or panic should not be used in a function that returns result
 note: will cause the application to crash.
   --> $DIR/panic_in_result.rs:13:9
    |
@@ -33,7 +33,7 @@ LL |         unimplemented!();
    |         ^^^^^^^^^^^^^^^^^
    = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: used unimplemented, unreachable or panic in a function that returns result or option
+error: used unimplemented, unreachable, todo or panic in a function that returns result
   --> $DIR/panic_in_result.rs:16:5
    |
 LL | /     fn result_with_unreachable() -> Result<bool, String> // should emit lint
@@ -42,7 +42,7 @@ LL | |         unreachable!();
 LL | |     }
    | |_____^
    |
-   = help: unimplemented, unreachable or panic should not be used in a function that returns result or option
+   = help: unimplemented, unreachable, todo or panic should not be used in a function that returns result
 note: will cause the application to crash.
   --> $DIR/panic_in_result.rs:18:9
    |
@@ -50,56 +50,22 @@ LL |         unreachable!();
    |         ^^^^^^^^^^^^^^^
    = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: used unimplemented, unreachable or panic in a function that returns result or option
+error: used unimplemented, unreachable, todo or panic in a function that returns result
   --> $DIR/panic_in_result.rs:21:5
    |
-LL | /     fn option_with_unreachable() -> Option<bool> // should emit lint
+LL | /     fn result_with_todo() -> Result<bool, String> // should emit lint
 LL | |     {
-LL | |         unreachable!();
+LL | |         todo!("Finish this");
 LL | |     }
    | |_____^
    |
-   = help: unimplemented, unreachable or panic should not be used in a function that returns result or option
+   = help: unimplemented, unreachable, todo or panic should not be used in a function that returns result
 note: will cause the application to crash.
   --> $DIR/panic_in_result.rs:23:9
    |
-LL |         unreachable!();
-   |         ^^^^^^^^^^^^^^^
-   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
-
-error: used unimplemented, unreachable or panic in a function that returns result or option
-  --> $DIR/panic_in_result.rs:26:5
-   |
-LL | /     fn option_with_unimplemented() -> Option<bool> // should emit lint
-LL | |     {
-LL | |         unimplemented!();
-LL | |     }
-   | |_____^
-   |
-   = help: unimplemented, unreachable or panic should not be used in a function that returns result or option
-note: will cause the application to crash.
-  --> $DIR/panic_in_result.rs:28:9
-   |
-LL |         unimplemented!();
-   |         ^^^^^^^^^^^^^^^^^
-   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
-
-error: used unimplemented, unreachable or panic in a function that returns result or option
-  --> $DIR/panic_in_result.rs:31:5
-   |
-LL | /     fn option_with_panic() -> Option<bool> // should emit lint
-LL | |     {
-LL | |         panic!("error");
-LL | |     }
-   | |_____^
-   |
-   = help: unimplemented, unreachable or panic should not be used in a function that returns result or option
-note: will cause the application to crash.
-  --> $DIR/panic_in_result.rs:33:9
-   |
-LL |         panic!("error");
-   |         ^^^^^^^^^^^^^^^^
+LL |         todo!("Finish this");
+   |         ^^^^^^^^^^^^^^^^^^^^^
    = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to 6 previous errors
+error: aborting due to 4 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From e8be047c5b2d5b1522a16b4b52cc7acfa4581ca3 Mon Sep 17 00:00:00 2001
From: Thibaud <ThibsG@users.noreply.github.com>
Date: Fri, 28 Aug 2020 09:31:12 +0200
Subject: Update clippy_lints/src/utils/mod.rs

Co-authored-by: Eduardo Broto <ebroto@tutanota.com>
---
 clippy_lints/src/utils/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index 07ec59f452a..d9598c4abbd 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -868,7 +868,7 @@ pub fn return_ty<'tcx>(cx: &LateContext<'tcx>, fn_item: hir::HirId) -> Ty<'tcx>
 }
 
 /// Walk into `ty` and returns `true` if any inner type is the same as `other_ty`
-pub fn contains_ty<'tcx>(ty: Ty<'tcx>, other_ty: Ty<'tcx>) -> bool {
+pub fn contains_ty(ty: Ty<'_>, other_ty: Ty<'_>) -> bool {
     ty.walk().any(|inner| match inner.unpack() {
         GenericArgKind::Type(inner_ty) => ty::TyS::same_type(other_ty, inner_ty),
         GenericArgKind::Lifetime(_) | GenericArgKind::Const(_) => false,
-- 
cgit 1.4.1-3-g733a5


From ffaadae8e48699f115eafd2853c252f546a69a28 Mon Sep 17 00:00:00 2001
From: Thibaud <ThibsG@users.noreply.github.com>
Date: Fri, 28 Aug 2020 09:31:29 +0200
Subject: Update clippy_lints/src/utils/mod.rs

Co-authored-by: Eduardo Broto <ebroto@tutanota.com>
---
 clippy_lints/src/utils/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index d9598c4abbd..82005257115 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -867,7 +867,7 @@ pub fn return_ty<'tcx>(cx: &LateContext<'tcx>, fn_item: hir::HirId) -> Ty<'tcx>
     cx.tcx.erase_late_bound_regions(&ret_ty)
 }
 
-/// Walk into `ty` and returns `true` if any inner type is the same as `other_ty`
+/// Walks into `ty` and returns `true` if any inner type is the same as `other_ty`
 pub fn contains_ty(ty: Ty<'_>, other_ty: Ty<'_>) -> bool {
     ty.walk().any(|inner| match inner.unpack() {
         GenericArgKind::Type(inner_ty) => ty::TyS::same_type(other_ty, inner_ty),
-- 
cgit 1.4.1-3-g733a5


From 73b1ee1a614aaad7dd43958280ff4a444c8b737e Mon Sep 17 00:00:00 2001
From: Thibaud <ThibsG@users.noreply.github.com>
Date: Fri, 28 Aug 2020 09:33:05 +0200
Subject: Update clippy_lints/src/methods/mod.rs

Co-authored-by: Eduardo Broto <ebroto@tutanota.com>
---
 clippy_lints/src/methods/mod.rs | 1 +
 1 file changed, 1 insertion(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 63e0c183113..9996df69470 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1686,6 +1686,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
 
     fn check_trait_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx TraitItem<'_>) {
         if_chain! {
+            if !in_external_macro(cx.tcx.sess, item.span);
             if item.ident.name == sym!(new);
             if let TraitItemKind::Fn(_, _) = item.kind;
             let ret_ty = return_ty(cx, item.hir_id);
-- 
cgit 1.4.1-3-g733a5


From 5574182b4d2d08c848a88a1ac5633fc194e0465e Mon Sep 17 00:00:00 2001
From: Hirochika Matsumoto <matsujika@gmail.com>
Date: Fri, 28 Aug 2020 18:40:22 +0900
Subject: Add a new lint to prevent `create_dir` from being used

---
 CHANGELOG.md                   |  1 +
 clippy_lints/src/create_dir.rs | 50 ++++++++++++++++++++++++++++++++++++++++++
 clippy_lints/src/lib.rs        |  4 ++++
 src/lintlist/mod.rs            |  7 ++++++
 tests/ui/create_dir.fixed      | 13 +++++++++++
 tests/ui/create_dir.rs         | 13 +++++++++++
 tests/ui/create_dir.stderr     | 16 ++++++++++++++
 7 files changed, 104 insertions(+)
 create mode 100644 clippy_lints/src/create_dir.rs
 create mode 100644 tests/ui/create_dir.fixed
 create mode 100644 tests/ui/create_dir.rs
 create mode 100644 tests/ui/create_dir.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 137b561028a..b37273af44d 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1444,6 +1444,7 @@ Released 2018-09-13
 [`collapsible_if`]: https://rust-lang.github.io/rust-clippy/master/index.html#collapsible_if
 [`comparison_chain`]: https://rust-lang.github.io/rust-clippy/master/index.html#comparison_chain
 [`copy_iterator`]: https://rust-lang.github.io/rust-clippy/master/index.html#copy_iterator
+[`create_dir`]: https://rust-lang.github.io/rust-clippy/master/index.html#create_dir
 [`crosspointer_transmute`]: https://rust-lang.github.io/rust-clippy/master/index.html#crosspointer_transmute
 [`dbg_macro`]: https://rust-lang.github.io/rust-clippy/master/index.html#dbg_macro
 [`debug_assert_with_mut_call`]: https://rust-lang.github.io/rust-clippy/master/index.html#debug_assert_with_mut_call
diff --git a/clippy_lints/src/create_dir.rs b/clippy_lints/src/create_dir.rs
new file mode 100644
index 00000000000..229536bd673
--- /dev/null
+++ b/clippy_lints/src/create_dir.rs
@@ -0,0 +1,50 @@
+use crate::utils::{match_qpath, snippet, span_lint_and_sugg};
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir::*;
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// **What it does:** Checks usage of `std::fs::create_dir` and suggest using `std::fs::create_dir_all` instead.
+    ///
+    /// **Why is this bad?** Sometimes `std::fs::crate_dir` is mistakenly chosen over `std::fs::create_dir_all`.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// std::fs::create_dir("foo")
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// std::fs::create_dir_all("foo")
+    /// ```
+    pub CREATE_DIR,
+    restriction,
+    "calling `std::fs::create_dir` instead of `std::fs::create_dir_all`"
+}
+
+declare_lint_pass!(CreateDir => [CREATE_DIR]);
+
+impl LateLintPass<'_> for CreateDir {
+    fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
+        if_chain! {
+            if let ExprKind::Call(ref func, ref args) = expr.kind;
+            if let ExprKind::Path(ref path) = func.kind;
+            if match_qpath(path, &["std", "fs", "create_dir"]);
+            then {
+                span_lint_and_sugg(
+                    cx,
+                    CREATE_DIR,
+                    expr.span,
+                    "calling `std::fs::create_dir` where there may be a better way",
+                    "consider calling `std::fs::create_dir_all` instead",
+                    format!("std::fs::create_dir_all({})", snippet(cx, args[0].span, "..")),
+                    Applicability::MachineApplicable,
+                )
+            }
+        }
+    }
+}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 577ce6523b4..7943be34c62 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -169,6 +169,7 @@ mod collapsible_if;
 mod comparison_chain;
 mod copies;
 mod copy_iterator;
+mod create_dir;
 mod dbg_macro;
 mod default_trait_access;
 mod dereference;
@@ -511,6 +512,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &copies::MATCH_SAME_ARMS,
         &copies::SAME_FUNCTIONS_IN_IF_CONDITION,
         &copy_iterator::COPY_ITERATOR,
+        &create_dir::CREATE_DIR,
         &dbg_macro::DBG_MACRO,
         &default_trait_access::DEFAULT_TRAIT_ACCESS,
         &dereference::EXPLICIT_DEREF_METHODS,
@@ -1042,6 +1044,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_early_pass(|| box items_after_statements::ItemsAfterStatements);
     store.register_early_pass(|| box precedence::Precedence);
     store.register_early_pass(|| box needless_continue::NeedlessContinue);
+    store.register_late_pass(|| box create_dir::CreateDir);
     store.register_early_pass(|| box needless_arbitrary_self_type::NeedlessArbitrarySelfType);
     store.register_early_pass(|| box redundant_static_lifetimes::RedundantStaticLifetimes);
     store.register_late_pass(|| box cargo_common_metadata::CargoCommonMetadata);
@@ -1104,6 +1107,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&arithmetic::FLOAT_ARITHMETIC),
         LintId::of(&arithmetic::INTEGER_ARITHMETIC),
         LintId::of(&as_conversions::AS_CONVERSIONS),
+        LintId::of(&create_dir::CREATE_DIR),
         LintId::of(&dbg_macro::DBG_MACRO),
         LintId::of(&else_if_without_else::ELSE_IF_WITHOUT_ELSE),
         LintId::of(&exit::EXIT),
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index 687fac7baa8..e5134510922 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -290,6 +290,13 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
         deprecation: None,
         module: "copy_iterator",
     },
+    Lint {
+        name: "create_dir",
+        group: "restriction",
+        desc: "calling `std::fs::create_dir` instead of `std::fs::create_dir_all`",
+        deprecation: None,
+        module: "create_dir",
+    },
     Lint {
         name: "crosspointer_transmute",
         group: "complexity",
diff --git a/tests/ui/create_dir.fixed b/tests/ui/create_dir.fixed
new file mode 100644
index 00000000000..50f31f0c9c5
--- /dev/null
+++ b/tests/ui/create_dir.fixed
@@ -0,0 +1,13 @@
+// run-rustfix
+#![allow(unused_must_use)]
+#![warn(clippy::create_dir)]
+
+fn not_create_dir() {}
+
+fn main() {
+    std::fs::create_dir_all("foo");
+    std::fs::create_dir_all("bar").unwrap();
+
+    not_create_dir();
+    std::fs::create_dir_all("foobar");
+}
diff --git a/tests/ui/create_dir.rs b/tests/ui/create_dir.rs
new file mode 100644
index 00000000000..00ef37f413f
--- /dev/null
+++ b/tests/ui/create_dir.rs
@@ -0,0 +1,13 @@
+// run-rustfix
+#![allow(unused_must_use)]
+#![warn(clippy::create_dir)]
+
+fn not_create_dir() {}
+
+fn main() {
+    std::fs::create_dir("foo");
+    std::fs::create_dir("bar").unwrap();
+
+    not_create_dir();
+    std::fs::create_dir_all("foobar");
+}
diff --git a/tests/ui/create_dir.stderr b/tests/ui/create_dir.stderr
new file mode 100644
index 00000000000..3ae4680d929
--- /dev/null
+++ b/tests/ui/create_dir.stderr
@@ -0,0 +1,16 @@
+error: calling `std::fs::create_dir` where there may be a better way
+  --> $DIR/create_dir.rs:8:5
+   |
+LL |     std::fs::create_dir("foo");
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `std::fs::create_dir_all` instead: `std::fs::create_dir_all("foo")`
+   |
+   = note: `-D clippy::create-dir` implied by `-D warnings`
+
+error: calling `std::fs::create_dir` where there may be a better way
+  --> $DIR/create_dir.rs:9:5
+   |
+LL |     std::fs::create_dir("bar").unwrap();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `std::fs::create_dir_all` instead: `std::fs::create_dir_all("bar")`
+
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 607905d126c55422668007737c22d7a7a89c0d57 Mon Sep 17 00:00:00 2001
From: Hirochika Matsumoto <matsujika@gmail.com>
Date: Fri, 28 Aug 2020 18:53:15 +0900
Subject: Add STD_FS_CREATE_DIR into paths

---
 clippy_lints/src/create_dir.rs  | 4 ++--
 clippy_lints/src/utils/paths.rs | 1 +
 2 files changed, 3 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/create_dir.rs b/clippy_lints/src/create_dir.rs
index 229536bd673..7ba6facda6a 100644
--- a/clippy_lints/src/create_dir.rs
+++ b/clippy_lints/src/create_dir.rs
@@ -1,4 +1,4 @@
-use crate::utils::{match_qpath, snippet, span_lint_and_sugg};
+use crate::utils::{match_qpath, paths, snippet, span_lint_and_sugg};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::*;
@@ -33,7 +33,7 @@ impl LateLintPass<'_> for CreateDir {
         if_chain! {
             if let ExprKind::Call(ref func, ref args) = expr.kind;
             if let ExprKind::Path(ref path) = func.kind;
-            if match_qpath(path, &["std", "fs", "create_dir"]);
+            if match_qpath(path, &paths::STD_FS_CREATE_DIR);
             then {
                 span_lint_and_sugg(
                     cx,
diff --git a/clippy_lints/src/utils/paths.rs b/clippy_lints/src/utils/paths.rs
index d44854aefe9..65320d6a0e0 100644
--- a/clippy_lints/src/utils/paths.rs
+++ b/clippy_lints/src/utils/paths.rs
@@ -110,6 +110,7 @@ pub const SLICE_ITER: [&str; 3] = ["core", "slice", "Iter"];
 pub const STDERR: [&str; 4] = ["std", "io", "stdio", "stderr"];
 pub const STDOUT: [&str; 4] = ["std", "io", "stdio", "stdout"];
 pub const STD_CONVERT_IDENTITY: [&str; 3] = ["std", "convert", "identity"];
+pub const STD_FS_CREATE_DIR: [&str; 3] = ["std", "fs", "create_dir"];
 pub const STD_MEM_TRANSMUTE: [&str; 3] = ["std", "mem", "transmute"];
 pub const STD_PTR_NULL: [&str; 3] = ["std", "ptr", "null"];
 pub const STRING_AS_MUT_STR: [&str; 4] = ["alloc", "string", "String", "as_mut_str"];
-- 
cgit 1.4.1-3-g733a5


From 34e302e67c08c9b97d58d062ea83cc1fd860c56e Mon Sep 17 00:00:00 2001
From: Hirochika Matsumoto <matsujika@gmail.com>
Date: Fri, 28 Aug 2020 19:35:04 +0900
Subject: Fix clippy error

---
 clippy_lints/src/create_dir.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/create_dir.rs b/clippy_lints/src/create_dir.rs
index 7ba6facda6a..4fede8857c7 100644
--- a/clippy_lints/src/create_dir.rs
+++ b/clippy_lints/src/create_dir.rs
@@ -1,7 +1,7 @@
 use crate::utils::{match_qpath, paths, snippet, span_lint_and_sugg};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
-use rustc_hir::*;
+use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
-- 
cgit 1.4.1-3-g733a5


From eebd2483654456e332d7cf53218b56b9cbd6f2f5 Mon Sep 17 00:00:00 2001
From: Hirochika Matsumoto <matsujika@gmail.com>
Date: Fri, 28 Aug 2020 19:56:03 +0900
Subject: Fix errors

---
 clippy_lints/src/create_dir.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/create_dir.rs b/clippy_lints/src/create_dir.rs
index 4fede8857c7..bf47c1f84a2 100644
--- a/clippy_lints/src/create_dir.rs
+++ b/clippy_lints/src/create_dir.rs
@@ -15,11 +15,11 @@ declare_clippy_lint! {
     /// **Example:**
     ///
     /// ```rust
-    /// std::fs::create_dir("foo")
+    /// std::fs::create_dir("foo");
     /// ```
     /// Use instead:
     /// ```rust
-    /// std::fs::create_dir_all("foo")
+    /// std::fs::create_dir_all("foo");
     /// ```
     pub CREATE_DIR,
     restriction,
-- 
cgit 1.4.1-3-g733a5


From 7a66e6502dc3c7085b3f4078c01d4957d96175ed Mon Sep 17 00:00:00 2001
From: Eduardo Broto <ebroto@tutanota.com>
Date: Sat, 29 Aug 2020 01:18:42 +0200
Subject: or_fn_call: ignore nullary associated const fns

---
 clippy_lints/src/utils/mod.rs |  2 +-
 tests/ui/or_fun_call.fixed    | 17 +++++++++++------
 tests/ui/or_fun_call.rs       | 17 +++++++++++------
 tests/ui/or_fun_call.stderr   | 20 ++++----------------
 4 files changed, 27 insertions(+), 29 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index 82005257115..fe2ee093157 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -899,7 +899,7 @@ pub fn is_ctor_or_promotable_const_function(cx: &LateContext<'_>, expr: &Expr<'_
             return match res {
                 def::Res::Def(DefKind::Variant | DefKind::Ctor(..), ..) => true,
                 // FIXME: check the constness of the arguments, see https://github.com/rust-lang/rust-clippy/pull/5682#issuecomment-638681210
-                def::Res::Def(DefKind::Fn, def_id) if has_no_arguments(cx, def_id) => {
+                def::Res::Def(DefKind::Fn | DefKind::AssocFn, def_id) if has_no_arguments(cx, def_id) => {
                     const_eval::is_const_fn(cx.tcx, def_id)
                 },
                 def::Res::Def(_, def_id) => cx.tcx.is_promotable_const_fn(def_id),
diff --git a/tests/ui/or_fun_call.fixed b/tests/ui/or_fun_call.fixed
index 67faa8bd4a0..5fb568672d3 100644
--- a/tests/ui/or_fun_call.fixed
+++ b/tests/ui/or_fun_call.fixed
@@ -58,12 +58,6 @@ fn or_fun_call() {
     let without_default = Some(Foo);
     without_default.unwrap_or_else(Foo::new);
 
-    let mut map = HashMap::<u64, String>::new();
-    map.entry(42).or_insert_with(String::new);
-
-    let mut btree = BTreeMap::<u64, String>::new();
-    btree.entry(42).or_insert_with(String::new);
-
     let stringy = Some(String::from(""));
     let _ = stringy.unwrap_or_else(|| "".to_owned());
 
@@ -122,6 +116,17 @@ pub fn skip_const_fn_with_no_args() {
         Some(42)
     }
     let _ = None.or(foo());
+
+    // See issue #5693.
+    let mut map = std::collections::HashMap::new();
+    map.insert(1, vec![1]);
+    map.entry(1).or_insert(vec![]);
+
+    let mut map = HashMap::<u64, String>::new();
+    map.entry(42).or_insert(String::new());
+
+    let mut btree = BTreeMap::<u64, String>::new();
+    btree.entry(42).or_insert(String::new());
 }
 
 fn main() {}
diff --git a/tests/ui/or_fun_call.rs b/tests/ui/or_fun_call.rs
index 9867e2eedcf..737b0f7e55b 100644
--- a/tests/ui/or_fun_call.rs
+++ b/tests/ui/or_fun_call.rs
@@ -58,12 +58,6 @@ fn or_fun_call() {
     let without_default = Some(Foo);
     without_default.unwrap_or(Foo::new());
 
-    let mut map = HashMap::<u64, String>::new();
-    map.entry(42).or_insert(String::new());
-
-    let mut btree = BTreeMap::<u64, String>::new();
-    btree.entry(42).or_insert(String::new());
-
     let stringy = Some(String::from(""));
     let _ = stringy.unwrap_or("".to_owned());
 
@@ -122,6 +116,17 @@ pub fn skip_const_fn_with_no_args() {
         Some(42)
     }
     let _ = None.or(foo());
+
+    // See issue #5693.
+    let mut map = std::collections::HashMap::new();
+    map.insert(1, vec![1]);
+    map.entry(1).or_insert(vec![]);
+
+    let mut map = HashMap::<u64, String>::new();
+    map.entry(42).or_insert(String::new());
+
+    let mut btree = BTreeMap::<u64, String>::new();
+    btree.entry(42).or_insert(String::new());
 }
 
 fn main() {}
diff --git a/tests/ui/or_fun_call.stderr b/tests/ui/or_fun_call.stderr
index bc5978b538f..b8a436993f3 100644
--- a/tests/ui/or_fun_call.stderr
+++ b/tests/ui/or_fun_call.stderr
@@ -60,35 +60,23 @@ error: use of `unwrap_or` followed by a function call
 LL |     without_default.unwrap_or(Foo::new());
    |                     ^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(Foo::new)`
 
-error: use of `or_insert` followed by a function call
-  --> $DIR/or_fun_call.rs:62:19
-   |
-LL |     map.entry(42).or_insert(String::new());
-   |                   ^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `or_insert_with(String::new)`
-
-error: use of `or_insert` followed by a function call
-  --> $DIR/or_fun_call.rs:65:21
-   |
-LL |     btree.entry(42).or_insert(String::new());
-   |                     ^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `or_insert_with(String::new)`
-
 error: use of `unwrap_or` followed by a function call
-  --> $DIR/or_fun_call.rs:68:21
+  --> $DIR/or_fun_call.rs:62:21
    |
 LL |     let _ = stringy.unwrap_or("".to_owned());
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|| "".to_owned())`
 
 error: use of `or` followed by a function call
-  --> $DIR/or_fun_call.rs:93:35
+  --> $DIR/or_fun_call.rs:87:35
    |
 LL |     let _ = Some("a".to_string()).or(Some("b".to_string()));
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `or_else(|| Some("b".to_string()))`
 
 error: use of `or` followed by a function call
-  --> $DIR/or_fun_call.rs:97:10
+  --> $DIR/or_fun_call.rs:91:10
    |
 LL |         .or(Some(Bar(b, Duration::from_secs(2))));
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `or_else(|| Some(Bar(b, Duration::from_secs(2))))`
 
-error: aborting due to 15 previous errors
+error: aborting due to 13 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 5b7590f841974255f74c64d573189aecc7a30b2e Mon Sep 17 00:00:00 2001
From: Hirochika Matsumoto <matsujika@gmail.com>
Date: Sat, 29 Aug 2020 14:20:01 +0900
Subject: Downgrade applicability of `create_dir`

---
 clippy_lints/src/create_dir.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/create_dir.rs b/clippy_lints/src/create_dir.rs
index bf47c1f84a2..1042eb45524 100644
--- a/clippy_lints/src/create_dir.rs
+++ b/clippy_lints/src/create_dir.rs
@@ -42,7 +42,7 @@ impl LateLintPass<'_> for CreateDir {
                     "calling `std::fs::create_dir` where there may be a better way",
                     "consider calling `std::fs::create_dir_all` instead",
                     format!("std::fs::create_dir_all({})", snippet(cx, args[0].span, "..")),
-                    Applicability::MachineApplicable,
+                    Applicability::MaybeIncorrect,
                 )
             }
         }
-- 
cgit 1.4.1-3-g733a5


From 4972989b616cbf96c015cd9fdf1f4b4464ecaace Mon Sep 17 00:00:00 2001
From: Kyle Huey <khuey@kylehuey.com>
Date: Fri, 14 Aug 2020 17:30:48 -0700
Subject: Add a lint for an async block/closure that yields a type that is
 itself awaitable.

This catches bugs of the form

tokio::spawn(async move {
    let f = some_async_thing();
    f // Oh no I forgot to await f so that work will never complete.
});
---
 CHANGELOG.md                           |  1 +
 clippy_lints/src/async_yields_async.rs | 88 +++++++++++++++++++++++++++++++
 clippy_lints/src/lib.rs                |  5 ++
 src/lintlist/mod.rs                    |  7 +++
 tests/ui/async_yields_async.fixed      | 61 +++++++++++++++++++++
 tests/ui/async_yields_async.rs         | 61 +++++++++++++++++++++
 tests/ui/async_yields_async.stderr     | 96 ++++++++++++++++++++++++++++++++++
 7 files changed, 319 insertions(+)
 create mode 100644 clippy_lints/src/async_yields_async.rs
 create mode 100644 tests/ui/async_yields_async.fixed
 create mode 100644 tests/ui/async_yields_async.rs
 create mode 100644 tests/ui/async_yields_async.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 34d48821023..99a8b1a6293 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1512,6 +1512,7 @@ Released 2018-09-13
 [`assertions_on_constants`]: https://rust-lang.github.io/rust-clippy/master/index.html#assertions_on_constants
 [`assign_op_pattern`]: https://rust-lang.github.io/rust-clippy/master/index.html#assign_op_pattern
 [`assign_ops`]: https://rust-lang.github.io/rust-clippy/master/index.html#assign_ops
+[`async_yields_async`]: https://rust-lang.github.io/rust-clippy/master/index.html#async_yields_async
 [`await_holding_lock`]: https://rust-lang.github.io/rust-clippy/master/index.html#await_holding_lock
 [`bad_bit_mask`]: https://rust-lang.github.io/rust-clippy/master/index.html#bad_bit_mask
 [`bind_instead_of_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#bind_instead_of_map
diff --git a/clippy_lints/src/async_yields_async.rs b/clippy_lints/src/async_yields_async.rs
new file mode 100644
index 00000000000..ae347fcd3e8
--- /dev/null
+++ b/clippy_lints/src/async_yields_async.rs
@@ -0,0 +1,88 @@
+use crate::utils::{implements_trait, snippet, span_lint_and_then};
+use rustc_errors::Applicability;
+use rustc_hir::{AsyncGeneratorKind, Body, BodyId, ExprKind, GeneratorKind, QPath};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// **What it does:**
+    /// Checks for async blocks that yield values of types that can themselves
+    /// be awaited.
+    ///
+    /// **Why is this bad?**
+    /// An await is likely missing.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// async fn foo() {}
+    ///
+    /// fn bar() {
+    ///   let x = async {
+    ///     foo()
+    ///   };
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// async fn foo() {}
+    ///
+    /// fn bar() {
+    ///   let x = async {
+    ///     foo().await
+    ///   };
+    /// }
+    /// ```
+    pub ASYNC_YIELDS_ASYNC,
+    correctness,
+    "async blocks that return a type that can be awaited"
+}
+
+declare_lint_pass!(AsyncYieldsAsync => [ASYNC_YIELDS_ASYNC]);
+
+impl<'tcx> LateLintPass<'tcx> for AsyncYieldsAsync {
+    fn check_body(&mut self, cx: &LateContext<'tcx>, body: &'tcx Body<'_>) {
+        use AsyncGeneratorKind::{Block, Closure};
+        // For functions, with explicitly defined types, don't warn.
+        // XXXkhuey maybe we should?
+        if let Some(GeneratorKind::Async(Block | Closure)) = body.generator_kind {
+            if let Some(future_trait_def_id) = cx.tcx.lang_items().future_trait() {
+                let body_id = BodyId {
+                    hir_id: body.value.hir_id,
+                };
+                let def_id = cx.tcx.hir().body_owner_def_id(body_id);
+                let typeck_results = cx.tcx.typeck(def_id);
+                let expr_ty = typeck_results.expr_ty(&body.value);
+
+                if implements_trait(cx, expr_ty, future_trait_def_id, &[]) {
+                    let return_expr_span = match &body.value.kind {
+                        // XXXkhuey there has to be a better way.
+                        ExprKind::Block(block, _) => block.expr.map(|e| e.span),
+                        ExprKind::Path(QPath::Resolved(_, path)) => Some(path.span),
+                        _ => None,
+                    };
+                    if let Some(return_expr_span) = return_expr_span {
+                        span_lint_and_then(
+                            cx,
+                            ASYNC_YIELDS_ASYNC,
+                            return_expr_span,
+                            "an async construct yields a type which is itself awaitable",
+                            |db| {
+                                db.span_label(body.value.span, "outer async construct");
+                                db.span_label(return_expr_span, "awaitable value not awaited");
+                                db.span_suggestion(
+                                    return_expr_span,
+                                    "consider awaiting this value",
+                                    format!("{}.await", snippet(cx, return_expr_span, "..")),
+                                    Applicability::MaybeIncorrect,
+                                );
+                            },
+                        );
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 577ce6523b4..0eb1d331366 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -154,6 +154,7 @@ mod arithmetic;
 mod as_conversions;
 mod assertions_on_constants;
 mod assign_ops;
+mod async_yields_async;
 mod atomic_ordering;
 mod attrs;
 mod await_holding_lock;
@@ -483,6 +484,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &assertions_on_constants::ASSERTIONS_ON_CONSTANTS,
         &assign_ops::ASSIGN_OP_PATTERN,
         &assign_ops::MISREFACTORED_ASSIGN_OP,
+        &async_yields_async::ASYNC_YIELDS_ASYNC,
         &atomic_ordering::INVALID_ATOMIC_ORDERING,
         &attrs::BLANKET_CLIPPY_RESTRICTION_LINTS,
         &attrs::DEPRECATED_CFG_ATTR,
@@ -1099,6 +1101,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box unwrap_in_result::UnwrapInResult);
     store.register_late_pass(|| box self_assignment::SelfAssignment);
     store.register_late_pass(|| box float_equality_without_abs::FloatEqualityWithoutAbs);
+    store.register_late_pass(|| box async_yields_async::AsyncYieldsAsync);
 
     store.register_group(true, "clippy::restriction", Some("clippy_restriction"), vec![
         LintId::of(&arithmetic::FLOAT_ARITHMETIC),
@@ -1232,6 +1235,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&assertions_on_constants::ASSERTIONS_ON_CONSTANTS),
         LintId::of(&assign_ops::ASSIGN_OP_PATTERN),
         LintId::of(&assign_ops::MISREFACTORED_ASSIGN_OP),
+        LintId::of(&async_yields_async::ASYNC_YIELDS_ASYNC),
         LintId::of(&atomic_ordering::INVALID_ATOMIC_ORDERING),
         LintId::of(&attrs::BLANKET_CLIPPY_RESTRICTION_LINTS),
         LintId::of(&attrs::DEPRECATED_CFG_ATTR),
@@ -1675,6 +1679,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
 
     store.register_group(true, "clippy::correctness", Some("clippy_correctness"), vec![
         LintId::of(&approx_const::APPROX_CONSTANT),
+        LintId::of(&async_yields_async::ASYNC_YIELDS_ASYNC),
         LintId::of(&atomic_ordering::INVALID_ATOMIC_ORDERING),
         LintId::of(&attrs::DEPRECATED_SEMVER),
         LintId::of(&attrs::MISMATCHED_TARGET_OS),
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index 687fac7baa8..dff19ef440f 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -52,6 +52,13 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
         deprecation: None,
         module: "assign_ops",
     },
+    Lint {
+        name: "async_yields_async",
+        group: "correctness",
+        desc: "async blocks that return a type that can be awaited",
+        deprecation: None,
+        module: "async_yields_async",
+    },
     Lint {
         name: "await_holding_lock",
         group: "pedantic",
diff --git a/tests/ui/async_yields_async.fixed b/tests/ui/async_yields_async.fixed
new file mode 100644
index 00000000000..cadc6494c76
--- /dev/null
+++ b/tests/ui/async_yields_async.fixed
@@ -0,0 +1,61 @@
+// run-rustfix
+// edition:2018
+
+#![feature(async_closure)]
+#![warn(clippy::async_yields_async)]
+
+use core::future::Future;
+use core::pin::Pin;
+use core::task::{Context, Poll};
+
+struct CustomFutureType;
+
+impl Future for CustomFutureType {
+    type Output = u8;
+
+    fn poll(self: Pin<&mut Self>, _: &mut Context) -> Poll<Self::Output> {
+        Poll::Ready(3)
+    }
+}
+
+fn custom_future_type_ctor() -> CustomFutureType {
+    CustomFutureType
+}
+
+#[rustfmt::skip]
+fn main() {
+    let _f = {
+        3
+    };
+    let _g = async {
+        3
+    };
+    let _h = async {
+        async {
+            3
+        }.await
+    };
+    let _i = async {
+        CustomFutureType.await
+    };
+    let _i = async || {
+        3
+    };
+    let _j = async || {
+        async {
+            3
+        }.await
+    };
+    let _k = async || {
+        CustomFutureType.await
+    };
+    let _l = async || CustomFutureType.await;
+    let _m = async || {
+        println!("I'm bored");
+        // Some more stuff
+
+        // Finally something to await
+        CustomFutureType.await
+    };
+    let _n = async || custom_future_type_ctor();
+}
diff --git a/tests/ui/async_yields_async.rs b/tests/ui/async_yields_async.rs
new file mode 100644
index 00000000000..898fe1a9561
--- /dev/null
+++ b/tests/ui/async_yields_async.rs
@@ -0,0 +1,61 @@
+// run-rustfix
+// edition:2018
+
+#![feature(async_closure)]
+#![warn(clippy::async_yields_async)]
+
+use core::future::Future;
+use core::pin::Pin;
+use core::task::{Context, Poll};
+
+struct CustomFutureType;
+
+impl Future for CustomFutureType {
+    type Output = u8;
+
+    fn poll(self: Pin<&mut Self>, _: &mut Context) -> Poll<Self::Output> {
+        Poll::Ready(3)
+    }
+}
+
+fn custom_future_type_ctor() -> CustomFutureType {
+    CustomFutureType
+}
+
+#[rustfmt::skip]
+fn main() {
+    let _f = {
+        3
+    };
+    let _g = async {
+        3
+    };
+    let _h = async {
+        async {
+            3
+        }
+    };
+    let _i = async {
+        CustomFutureType
+    };
+    let _i = async || {
+        3
+    };
+    let _j = async || {
+        async {
+            3
+        }
+    };
+    let _k = async || {
+        CustomFutureType
+    };
+    let _l = async || CustomFutureType;
+    let _m = async || {
+        println!("I'm bored");
+        // Some more stuff
+
+        // Finally something to await
+        CustomFutureType
+    };
+    let _n = async || custom_future_type_ctor();
+}
diff --git a/tests/ui/async_yields_async.stderr b/tests/ui/async_yields_async.stderr
new file mode 100644
index 00000000000..112984cdccb
--- /dev/null
+++ b/tests/ui/async_yields_async.stderr
@@ -0,0 +1,96 @@
+error: an async construct yields a type which is itself awaitable
+  --> $DIR/async_yields_async.rs:34:9
+   |
+LL |        let _h = async {
+   |   ____________________-
+LL |  |         async {
+   |  |_________^
+LL | ||             3
+LL | ||         }
+   | ||_________^ awaitable value not awaited
+LL |  |     };
+   |  |_____- outer async construct
+   |
+   = note: `-D clippy::async-yields-async` implied by `-D warnings`
+help: consider awaiting this value
+   |
+LL |         async {
+LL |             3
+LL |         }.await
+   |
+
+error: an async construct yields a type which is itself awaitable
+  --> $DIR/async_yields_async.rs:39:9
+   |
+LL |       let _i = async {
+   |  ____________________-
+LL | |         CustomFutureType
+   | |         ^^^^^^^^^^^^^^^^
+   | |         |
+   | |         awaitable value not awaited
+   | |         help: consider awaiting this value: `CustomFutureType.await`
+LL | |     };
+   | |_____- outer async construct
+
+error: an async construct yields a type which is itself awaitable
+  --> $DIR/async_yields_async.rs:45:9
+   |
+LL |        let _j = async || {
+   |   _______________________-
+LL |  |         async {
+   |  |_________^
+LL | ||             3
+LL | ||         }
+   | ||_________^ awaitable value not awaited
+LL |  |     };
+   |  |_____- outer async construct
+   |
+help: consider awaiting this value
+   |
+LL |         async {
+LL |             3
+LL |         }.await
+   |
+
+error: an async construct yields a type which is itself awaitable
+  --> $DIR/async_yields_async.rs:50:9
+   |
+LL |       let _k = async || {
+   |  _______________________-
+LL | |         CustomFutureType
+   | |         ^^^^^^^^^^^^^^^^
+   | |         |
+   | |         awaitable value not awaited
+   | |         help: consider awaiting this value: `CustomFutureType.await`
+LL | |     };
+   | |_____- outer async construct
+
+error: an async construct yields a type which is itself awaitable
+  --> $DIR/async_yields_async.rs:52:23
+   |
+LL |     let _l = async || CustomFutureType;
+   |                       ^^^^^^^^^^^^^^^^
+   |                       |
+   |                       outer async construct
+   |                       awaitable value not awaited
+   |                       help: consider awaiting this value: `CustomFutureType.await`
+
+error: an async construct yields a type which is itself awaitable
+  --> $DIR/async_yields_async.rs:58:9
+   |
+LL |       let _m = async || {
+   |  _______________________-
+LL | |         println!("I'm bored");
+LL | |         // Some more stuff
+LL | |
+LL | |         // Finally something to await
+LL | |         CustomFutureType
+   | |         ^^^^^^^^^^^^^^^^
+   | |         |
+   | |         awaitable value not awaited
+   | |         help: consider awaiting this value: `CustomFutureType.await`
+LL | |     };
+   | |_____- outer async construct
+
+error: aborting due to 6 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 04912ca115ff153a97d80b604435b10dcb155dd0 Mon Sep 17 00:00:00 2001
From: Kyle Huey <khuey@kylehuey.com>
Date: Sat, 22 Aug 2020 21:40:01 -0700
Subject: Formatting changes requested by ThibsG.

---
 clippy_lints/src/async_yields_async.rs | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/async_yields_async.rs b/clippy_lints/src/async_yields_async.rs
index ae347fcd3e8..88d9d3b5a26 100644
--- a/clippy_lints/src/async_yields_async.rs
+++ b/clippy_lints/src/async_yields_async.rs
@@ -5,12 +5,10 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
-    /// **What it does:**
-    /// Checks for async blocks that yield values of types that can themselves
-    /// be awaited.
+    /// **What it does:** Checks for async blocks that yield values of types
+    /// that can themselves be awaited.
     ///
-    /// **Why is this bad?**
-    /// An await is likely missing.
+    /// **Why is this bad?** An await is likely missing.
     ///
     /// **Known problems:** None.
     ///
-- 
cgit 1.4.1-3-g733a5


From a424a2c1676a29c147252873037e8943d54941d3 Mon Sep 17 00:00:00 2001
From: Vali Schneider <eval@fb.com>
Date: Sat, 29 Aug 2020 16:17:53 -0700
Subject: changed check_impl_item to check_fn and added a few more test cases

---
 clippy_lints/src/panic_in_result.rs | 69 ++++++++++++++++++-------------------
 tests/ui/panic_in_result.rs         | 20 ++++++++++-
 tests/ui/panic_in_result.stderr     | 60 +++++++++++++++++++++++++-------
 3 files changed, 99 insertions(+), 50 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/panic_in_result.rs b/clippy_lints/src/panic_in_result.rs
index 2901f393fc6..11fefc12316 100644
--- a/clippy_lints/src/panic_in_result.rs
+++ b/clippy_lints/src/panic_in_result.rs
@@ -1,6 +1,8 @@
 use crate::utils::{is_expn_of, is_type_diagnostic_item, return_ty, span_lint_and_then};
 use if_chain::if_chain;
 use rustc_hir as hir;
+use rustc_hir::intravisit::{self, FnKind, NestedVisitorMap, Visitor};
+use rustc_hir::Expr;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::map::Map;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -21,7 +23,6 @@ declare_clippy_lint! {
     ///     panic!("error");
     /// }
     /// ```
-
     pub PANIC_IN_RESULT,
     restriction,
     "functions of type `Result<..>` that contain `panic!()`, `todo!()` or `unreachable()` or `unimplemented()` "
@@ -30,22 +31,26 @@ declare_clippy_lint! {
 declare_lint_pass!(PanicInResult => [PANIC_IN_RESULT]);
 
 impl<'tcx> LateLintPass<'tcx> for PanicInResult {
-    fn check_impl_item(&mut self, cx: &LateContext<'tcx>, impl_item: &'tcx hir::ImplItem<'_>) {
+    /*
+    fn check_fn(
+        &mut self,
+        cx: &LateContext<'tcx>,
+        _: FnKind<'tcx>,
+        _: &'tcx hir::FnDecl<'tcx>,
+        body: &'tcx hir::Body<'tcx>,
+        span: Span,
+        hir_id: hir::HirId,
+    ) {
         if_chain! {
-            // first check if it's a method or function
-            if let hir::ImplItemKind::Fn(ref _signature, _) = impl_item.kind;
-            // checking if its return type is `result` or `option`
-            if is_type_diagnostic_item(cx, return_ty(cx, impl_item.hir_id), sym!(result_type));
-            then {
-                lint_impl_body(cx, impl_item.span, impl_item);
+            if is_type_diagnostic_item(cx, return_ty(cx, hir_id), sym!(result_type));
+            then
+            {
+                lint_impl_body(cx, span, body);
             }
         }
-    }
+    }*/
 }
 
-use rustc_hir::intravisit::{self, NestedVisitorMap, Visitor};
-use rustc_hir::{Expr, ImplItemKind};
-
 struct FindPanicUnimplementedUnreachable {
     result: Vec<Span>,
 }
@@ -70,29 +75,21 @@ impl<'tcx> Visitor<'tcx> for FindPanicUnimplementedUnreachable {
     }
 }
 
-fn lint_impl_body<'tcx>(cx: &LateContext<'tcx>, impl_span: Span, impl_item: &'tcx hir::ImplItem<'_>) {
-    if_chain! {
-        if let ImplItemKind::Fn(_, body_id) = impl_item.kind;
-        then {
-            let body = cx.tcx.hir().body(body_id);
-            let mut fpu = FindPanicUnimplementedUnreachable {
-                result: Vec::new(),
-            };
-            fpu.visit_expr(&body.value);
-
-            // if we've found one, lint
-            if  !fpu.result.is_empty()  {
-                span_lint_and_then(
-                    cx,
-                    PANIC_IN_RESULT,
-                    impl_span,
-                    "used unimplemented, unreachable, todo or panic in a function that returns result",
-                    move |diag| {
-                        diag.help(
-                            "unimplemented, unreachable, todo or panic should not be used in a function that returns result" );
-                        diag.span_note(fpu.result, "will cause the application to crash.");
-                    });
-            }
-        }
+fn lint_impl_body<'tcx>(cx: &LateContext<'tcx>, impl_span: Span, body: &'tcx hir::Body<'tcx>) {
+    let mut panics = FindPanicUnimplementedUnreachable { result: Vec::new() };
+    panics.visit_expr(&body.value);
+    if !panics.result.is_empty() {
+        span_lint_and_then(
+            cx,
+            PANIC_IN_RESULT,
+            impl_span,
+            "used `unimplemented!()`, `unreachable!()`, `todo!()` or `panic!()` in a function that returns `Result`",
+            move |diag| {
+                diag.help(
+                    "`unimplemented!()`, `unreachable!()`, `todo!()` or `panic!()` should not be used in a function that returns `Result` as `Result` is expected to return an error instead of crashing",
+                );
+                diag.span_note(panics.result, "return Err() instead of panicking");
+            },
+        );
     }
 }
diff --git a/tests/ui/panic_in_result.rs b/tests/ui/panic_in_result.rs
index 056778995a4..f6fb2f1ab61 100644
--- a/tests/ui/panic_in_result.rs
+++ b/tests/ui/panic_in_result.rs
@@ -49,4 +49,22 @@ impl A {
     }
 }
 
-fn main() {}
+fn function_result_with_panic() -> Result<bool, String> // should emit lint
+{
+    panic!("error");
+}
+
+fn todo() {
+    println!("something");
+}
+
+fn function_result_with_custom_todo() -> Result<bool, String> // should not emit lint
+{
+    todo();
+    Ok(true)
+}
+
+fn main() -> Result<(), String> {
+    todo!("finish main method");
+    Ok(())
+}
diff --git a/tests/ui/panic_in_result.stderr b/tests/ui/panic_in_result.stderr
index 3b9ac69f20d..9faedf82986 100644
--- a/tests/ui/panic_in_result.stderr
+++ b/tests/ui/panic_in_result.stderr
@@ -1,4 +1,4 @@
-error: used unimplemented, unreachable, todo or panic in a function that returns result
+error: used `unimplemented!()`, `unreachable!()`, `todo!()` or `panic!()` in a function that returns `Result`
   --> $DIR/panic_in_result.rs:6:5
    |
 LL | /     fn result_with_panic() -> Result<bool, String> // should emit lint
@@ -8,15 +8,15 @@ LL | |     }
    | |_____^
    |
    = note: `-D clippy::panic-in-result` implied by `-D warnings`
-   = help: unimplemented, unreachable, todo or panic should not be used in a function that returns result
-note: will cause the application to crash.
+   = help: `unimplemented!()`, `unreachable!()`, `todo!()` or `panic!()` should not be used in a function that returns `Result` as `Result` is expected to return an error instead of crashing
+note: return Err() instead of panicking
   --> $DIR/panic_in_result.rs:8:9
    |
 LL |         panic!("error");
    |         ^^^^^^^^^^^^^^^^
    = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: used unimplemented, unreachable, todo or panic in a function that returns result
+error: used `unimplemented!()`, `unreachable!()`, `todo!()` or `panic!()` in a function that returns `Result`
   --> $DIR/panic_in_result.rs:11:5
    |
 LL | /     fn result_with_unimplemented() -> Result<bool, String> // should emit lint
@@ -25,15 +25,15 @@ LL | |         unimplemented!();
 LL | |     }
    | |_____^
    |
-   = help: unimplemented, unreachable, todo or panic should not be used in a function that returns result
-note: will cause the application to crash.
+   = help: `unimplemented!()`, `unreachable!()`, `todo!()` or `panic!()` should not be used in a function that returns `Result` as `Result` is expected to return an error instead of crashing
+note: return Err() instead of panicking
   --> $DIR/panic_in_result.rs:13:9
    |
 LL |         unimplemented!();
    |         ^^^^^^^^^^^^^^^^^
    = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: used unimplemented, unreachable, todo or panic in a function that returns result
+error: used `unimplemented!()`, `unreachable!()`, `todo!()` or `panic!()` in a function that returns `Result`
   --> $DIR/panic_in_result.rs:16:5
    |
 LL | /     fn result_with_unreachable() -> Result<bool, String> // should emit lint
@@ -42,15 +42,15 @@ LL | |         unreachable!();
 LL | |     }
    | |_____^
    |
-   = help: unimplemented, unreachable, todo or panic should not be used in a function that returns result
-note: will cause the application to crash.
+   = help: `unimplemented!()`, `unreachable!()`, `todo!()` or `panic!()` should not be used in a function that returns `Result` as `Result` is expected to return an error instead of crashing
+note: return Err() instead of panicking
   --> $DIR/panic_in_result.rs:18:9
    |
 LL |         unreachable!();
    |         ^^^^^^^^^^^^^^^
    = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: used unimplemented, unreachable, todo or panic in a function that returns result
+error: used `unimplemented!()`, `unreachable!()`, `todo!()` or `panic!()` in a function that returns `Result`
   --> $DIR/panic_in_result.rs:21:5
    |
 LL | /     fn result_with_todo() -> Result<bool, String> // should emit lint
@@ -59,13 +59,47 @@ LL | |         todo!("Finish this");
 LL | |     }
    | |_____^
    |
-   = help: unimplemented, unreachable, todo or panic should not be used in a function that returns result
-note: will cause the application to crash.
+   = help: `unimplemented!()`, `unreachable!()`, `todo!()` or `panic!()` should not be used in a function that returns `Result` as `Result` is expected to return an error instead of crashing
+note: return Err() instead of panicking
   --> $DIR/panic_in_result.rs:23:9
    |
 LL |         todo!("Finish this");
    |         ^^^^^^^^^^^^^^^^^^^^^
    = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to 4 previous errors
+error: used `unimplemented!()`, `unreachable!()`, `todo!()` or `panic!()` in a function that returns `Result`
+  --> $DIR/panic_in_result.rs:52:1
+   |
+LL | / fn function_result_with_panic() -> Result<bool, String> // should emit lint
+LL | | {
+LL | |     panic!("error");
+LL | | }
+   | |_^
+   |
+   = help: `unimplemented!()`, `unreachable!()`, `todo!()` or `panic!()` should not be used in a function that returns `Result` as `Result` is expected to return an error instead of crashing
+note: return Err() instead of panicking
+  --> $DIR/panic_in_result.rs:54:5
+   |
+LL |     panic!("error");
+   |     ^^^^^^^^^^^^^^^^
+   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: used `unimplemented!()`, `unreachable!()`, `todo!()` or `panic!()` in a function that returns `Result`
+  --> $DIR/panic_in_result.rs:67:1
+   |
+LL | / fn main() -> Result<(), String> {
+LL | |     todo!("finish main method");
+LL | |     Ok(())
+LL | | }
+   | |_^
+   |
+   = help: `unimplemented!()`, `unreachable!()`, `todo!()` or `panic!()` should not be used in a function that returns `Result` as `Result` is expected to return an error instead of crashing
+note: return Err() instead of panicking
+  --> $DIR/panic_in_result.rs:68:5
+   |
+LL |     todo!("finish main method");
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: aborting due to 6 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 73a3288282e733bfc5893e9920d29f1de5a21591 Mon Sep 17 00:00:00 2001
From: Vali Schneider <eval@fb.com>
Date: Sat, 29 Aug 2020 16:22:15 -0700
Subject: uncommented fn

---
 clippy_lints/src/panic_in_result.rs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/panic_in_result.rs b/clippy_lints/src/panic_in_result.rs
index 11fefc12316..8ba365cb00c 100644
--- a/clippy_lints/src/panic_in_result.rs
+++ b/clippy_lints/src/panic_in_result.rs
@@ -31,7 +31,6 @@ declare_clippy_lint! {
 declare_lint_pass!(PanicInResult => [PANIC_IN_RESULT]);
 
 impl<'tcx> LateLintPass<'tcx> for PanicInResult {
-    /*
     fn check_fn(
         &mut self,
         cx: &LateContext<'tcx>,
@@ -48,7 +47,7 @@ impl<'tcx> LateLintPass<'tcx> for PanicInResult {
                 lint_impl_body(cx, span, body);
             }
         }
-    }*/
+    }
 }
 
 struct FindPanicUnimplementedUnreachable {
-- 
cgit 1.4.1-3-g733a5


From 17b2ba5ded12f59dba63ece659b5cd714b763800 Mon Sep 17 00:00:00 2001
From: Camelid <37223377+camelid@users.noreply.github.com>
Date: Sun, 30 Aug 2020 11:24:15 -0700
Subject: Syntax-highlight `single_char_push_str` lint

---
 clippy_lints/src/methods/mod.rs | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 9996df69470..7c4a78cbdcd 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1324,20 +1324,20 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Warns when using push_str with a single-character string literal,
-    /// and push with a char would work fine.
+    /// **What it does:** Warns when using `push_str` with a single-character string literal,
+    /// and `push` with a `char` would work fine.
     ///
-    /// **Why is this bad?** It's less clear that we are pushing a single character
+    /// **Why is this bad?** It's less clear that we are pushing a single character.
     ///
     /// **Known problems:** None
     ///
     /// **Example:**
-    /// ```
+    /// ```rust
     /// let mut string = String::new();
     /// string.push_str("R");
     /// ```
     /// Could be written as
-    /// ```
+    /// ```rust
     /// let mut string = String::new();
     /// string.push('R');
     /// ```
-- 
cgit 1.4.1-3-g733a5


From 451ef7880392f3f06088ff7a7b957e3485f4bc6c Mon Sep 17 00:00:00 2001
From: Hirochika Matsumoto <matsujika@gmail.com>
Date: Mon, 31 Aug 2020 22:40:47 +0900
Subject: Use `match_def_path` instead of `match_qpath`

---
 clippy_lints/src/create_dir.rs | 5 +++--
 tests/ui/create_dir.fixed      | 6 ++++--
 tests/ui/create_dir.rs         | 6 ++++--
 tests/ui/create_dir.stderr     | 4 ++--
 4 files changed, 13 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/create_dir.rs b/clippy_lints/src/create_dir.rs
index 1042eb45524..f80a0efa7a5 100644
--- a/clippy_lints/src/create_dir.rs
+++ b/clippy_lints/src/create_dir.rs
@@ -1,4 +1,4 @@
-use crate::utils::{match_qpath, paths, snippet, span_lint_and_sugg};
+use crate::utils::{match_def_path, paths, snippet, span_lint_and_sugg};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
@@ -33,7 +33,8 @@ impl LateLintPass<'_> for CreateDir {
         if_chain! {
             if let ExprKind::Call(ref func, ref args) = expr.kind;
             if let ExprKind::Path(ref path) = func.kind;
-            if match_qpath(path, &paths::STD_FS_CREATE_DIR);
+            if let Some(def_id) = cx.qpath_res(path, func.hir_id).opt_def_id();
+            if match_def_path(cx, def_id, &paths::STD_FS_CREATE_DIR);
             then {
                 span_lint_and_sugg(
                     cx,
diff --git a/tests/ui/create_dir.fixed b/tests/ui/create_dir.fixed
index 50f31f0c9c5..0e28f87e33d 100644
--- a/tests/ui/create_dir.fixed
+++ b/tests/ui/create_dir.fixed
@@ -2,12 +2,14 @@
 #![allow(unused_must_use)]
 #![warn(clippy::create_dir)]
 
-fn not_create_dir() {}
+fn create_dir() {}
 
 fn main() {
+    // Should be warned
     std::fs::create_dir_all("foo");
     std::fs::create_dir_all("bar").unwrap();
 
-    not_create_dir();
+    // Shouldn't be warned
+    create_dir();
     std::fs::create_dir_all("foobar");
 }
diff --git a/tests/ui/create_dir.rs b/tests/ui/create_dir.rs
index 00ef37f413f..1f226298c0d 100644
--- a/tests/ui/create_dir.rs
+++ b/tests/ui/create_dir.rs
@@ -2,12 +2,14 @@
 #![allow(unused_must_use)]
 #![warn(clippy::create_dir)]
 
-fn not_create_dir() {}
+fn create_dir() {}
 
 fn main() {
+    // Should be warned
     std::fs::create_dir("foo");
     std::fs::create_dir("bar").unwrap();
 
-    not_create_dir();
+    // Shouldn't be warned
+    create_dir();
     std::fs::create_dir_all("foobar");
 }
diff --git a/tests/ui/create_dir.stderr b/tests/ui/create_dir.stderr
index 3ae4680d929..0c97bdd0f7a 100644
--- a/tests/ui/create_dir.stderr
+++ b/tests/ui/create_dir.stderr
@@ -1,5 +1,5 @@
 error: calling `std::fs::create_dir` where there may be a better way
-  --> $DIR/create_dir.rs:8:5
+  --> $DIR/create_dir.rs:9:5
    |
 LL |     std::fs::create_dir("foo");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `std::fs::create_dir_all` instead: `std::fs::create_dir_all("foo")`
@@ -7,7 +7,7 @@ LL |     std::fs::create_dir("foo");
    = note: `-D clippy::create-dir` implied by `-D warnings`
 
 error: calling `std::fs::create_dir` where there may be a better way
-  --> $DIR/create_dir.rs:9:5
+  --> $DIR/create_dir.rs:10:5
    |
 LL |     std::fs::create_dir("bar").unwrap();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `std::fs::create_dir_all` instead: `std::fs::create_dir_all("bar")`
-- 
cgit 1.4.1-3-g733a5


From 001f9e45f24c5617d816e7d9dfbca4dc1a694dd9 Mon Sep 17 00:00:00 2001
From: Takayuki Nakata <f.seasons017@gmail.com>
Date: Tue, 1 Sep 2020 00:05:53 +0900
Subject: Fix the wrong suggestion when using macro in `collapsible_if`

---
 clippy_lints/src/utils/sugg.rs |  6 +++++-
 tests/ui/collapsible_if.fixed  |  3 +++
 tests/ui/collapsible_if.rs     |  5 +++++
 tests/ui/collapsible_if.stderr | 10 +++++++++-
 4 files changed, 22 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/sugg.rs b/clippy_lints/src/utils/sugg.rs
index 2955f8d8e59..811fde388d1 100644
--- a/clippy_lints/src/utils/sugg.rs
+++ b/clippy_lints/src/utils/sugg.rs
@@ -132,7 +132,11 @@ impl<'a> Sugg<'a> {
     pub fn ast(cx: &EarlyContext<'_>, expr: &ast::Expr, default: &'a str) -> Self {
         use rustc_ast::ast::RangeLimits;
 
-        let snippet = snippet(cx, expr.span, default);
+        let snippet = if expr.span.from_expansion() {
+            snippet_with_macro_callsite(cx, expr.span, default)
+        } else {
+            snippet(cx, expr.span, default)
+        };
 
         match expr.kind {
             ast::ExprKind::AddrOf(..)
diff --git a/tests/ui/collapsible_if.fixed b/tests/ui/collapsible_if.fixed
index 561283fc8e7..efd4187947b 100644
--- a/tests/ui/collapsible_if.fixed
+++ b/tests/ui/collapsible_if.fixed
@@ -135,4 +135,7 @@ fn main() {
             if truth() {}
         }
     }
+
+    // Fix #5962
+    if matches!(true, true) && matches!(true, true) {}
 }
diff --git a/tests/ui/collapsible_if.rs b/tests/ui/collapsible_if.rs
index dc9d9b451c0..657f32d38a3 100644
--- a/tests/ui/collapsible_if.rs
+++ b/tests/ui/collapsible_if.rs
@@ -149,4 +149,9 @@ fn main() {
             if truth() {}
         }
     }
+
+    // Fix #5962
+    if matches!(true, true) {
+        if matches!(true, true) {}
+    }
 }
diff --git a/tests/ui/collapsible_if.stderr b/tests/ui/collapsible_if.stderr
index f56dd65b9dd..acd1ec3f2ca 100644
--- a/tests/ui/collapsible_if.stderr
+++ b/tests/ui/collapsible_if.stderr
@@ -118,5 +118,13 @@ LL |         println!("Hello world!");
 LL |     }
    |
 
-error: aborting due to 7 previous errors
+error: this `if` statement can be collapsed
+  --> $DIR/collapsible_if.rs:154:5
+   |
+LL | /     if matches!(true, true) {
+LL | |         if matches!(true, true) {}
+LL | |     }
+   | |_____^ help: collapse nested if block: `if matches!(true, true) && matches!(true, true) {}`
+
+error: aborting due to 8 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 8b0aa6a00b19b8e47a72157ec8e8f9e9060cb2fb Mon Sep 17 00:00:00 2001
From: Taiki Endo <te316e89@gmail.com>
Date: Tue, 1 Sep 2020 00:31:53 +0900
Subject: default_trait_access: Fix wrong suggestion

---
 clippy_lints/src/default_trait_access.rs |   4 +-
 tests/ui/default_trait_access.fixed      | 106 +++++++++++++++++++++++++++++++
 tests/ui/default_trait_access.rs         |   5 +-
 tests/ui/default_trait_access.stderr     |  26 ++++----
 4 files changed, 127 insertions(+), 14 deletions(-)
 create mode 100644 tests/ui/default_trait_access.fixed

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/default_trait_access.rs b/clippy_lints/src/default_trait_access.rs
index 067ea903bdd..0b0a1307876 100644
--- a/clippy_lints/src/default_trait_access.rs
+++ b/clippy_lints/src/default_trait_access.rs
@@ -55,8 +55,8 @@ impl<'tcx> LateLintPass<'tcx> for DefaultTraitAccess {
                         // TODO: Work out a way to put "whatever the imported way of referencing
                         // this type in this file" rather than a fully-qualified type.
                         let expr_ty = cx.typeck_results().expr_ty(expr);
-                        if let ty::Adt(..) = expr_ty.kind {
-                            let replacement = format!("{}::default()", expr_ty);
+                        if let ty::Adt(def, ..) = expr_ty.kind {
+                            let replacement = format!("{}::default()", cx.tcx.def_path_str(def.did));
                             span_lint_and_sugg(
                                 cx,
                                 DEFAULT_TRAIT_ACCESS,
diff --git a/tests/ui/default_trait_access.fixed b/tests/ui/default_trait_access.fixed
new file mode 100644
index 00000000000..d05567a3f82
--- /dev/null
+++ b/tests/ui/default_trait_access.fixed
@@ -0,0 +1,106 @@
+// run-rustfix
+
+#![allow(unused_imports)]
+#![deny(clippy::default_trait_access)]
+
+use std::default;
+use std::default::Default as D2;
+use std::string;
+
+fn main() {
+    let s1: String = std::string::String::default();
+
+    let s2 = String::default();
+
+    let s3: String = std::string::String::default();
+
+    let s4: String = std::string::String::default();
+
+    let s5 = string::String::default();
+
+    let s6: String = std::string::String::default();
+
+    let s7 = std::string::String::default();
+
+    let s8: String = DefaultFactory::make_t_badly();
+
+    let s9: String = DefaultFactory::make_t_nicely();
+
+    let s10 = DerivedDefault::default();
+
+    let s11: GenericDerivedDefault<String> = GenericDerivedDefault::default();
+
+    let s12 = GenericDerivedDefault::<String>::default();
+
+    let s13 = TupleDerivedDefault::default();
+
+    let s14: TupleDerivedDefault = TupleDerivedDefault::default();
+
+    let s15: ArrayDerivedDefault = ArrayDerivedDefault::default();
+
+    let s16 = ArrayDerivedDefault::default();
+
+    let s17: TupleStructDerivedDefault = TupleStructDerivedDefault::default();
+
+    let s18 = TupleStructDerivedDefault::default();
+
+    let s19 = <DerivedDefault as Default>::default();
+
+    println!(
+        "[{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}] [{:?}] [{:?}] [{:?}] [{:?}] [{:?}] [{:?}] [{:?}] [{:?}] [{:?}], [{:?}]",
+        s1,
+        s2,
+        s3,
+        s4,
+        s5,
+        s6,
+        s7,
+        s8,
+        s9,
+        s10,
+        s11,
+        s12,
+        s13,
+        s14,
+        s15,
+        s16,
+        s17,
+        s18,
+        s19,
+    );
+}
+
+struct DefaultFactory;
+
+impl DefaultFactory {
+    pub fn make_t_badly<T: Default>() -> T {
+        Default::default()
+    }
+
+    pub fn make_t_nicely<T: Default>() -> T {
+        T::default()
+    }
+}
+
+#[derive(Debug, Default)]
+struct DerivedDefault {
+    pub s: String,
+}
+
+#[derive(Debug, Default)]
+struct GenericDerivedDefault<T: Default + std::fmt::Debug> {
+    pub s: T,
+}
+
+#[derive(Debug, Default)]
+struct TupleDerivedDefault {
+    pub s: (String, String),
+}
+
+#[derive(Debug, Default)]
+struct ArrayDerivedDefault {
+    pub s: [String; 10],
+}
+
+#[derive(Debug, Default)]
+struct TupleStructDerivedDefault(String);
diff --git a/tests/ui/default_trait_access.rs b/tests/ui/default_trait_access.rs
index 2f1490a7036..447e70c0bbb 100644
--- a/tests/ui/default_trait_access.rs
+++ b/tests/ui/default_trait_access.rs
@@ -1,4 +1,7 @@
-#![warn(clippy::default_trait_access)]
+// run-rustfix
+
+#![allow(unused_imports)]
+#![deny(clippy::default_trait_access)]
 
 use std::default;
 use std::default::Default as D2;
diff --git a/tests/ui/default_trait_access.stderr b/tests/ui/default_trait_access.stderr
index 26b2057548b..df8a5b94ddc 100644
--- a/tests/ui/default_trait_access.stderr
+++ b/tests/ui/default_trait_access.stderr
@@ -1,49 +1,53 @@
 error: calling `std::string::String::default()` is more clear than this expression
-  --> $DIR/default_trait_access.rs:8:22
+  --> $DIR/default_trait_access.rs:11:22
    |
 LL |     let s1: String = Default::default();
    |                      ^^^^^^^^^^^^^^^^^^ help: try: `std::string::String::default()`
    |
-   = note: `-D clippy::default-trait-access` implied by `-D warnings`
+note: the lint level is defined here
+  --> $DIR/default_trait_access.rs:4:9
+   |
+LL | #![deny(clippy::default_trait_access)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: calling `std::string::String::default()` is more clear than this expression
-  --> $DIR/default_trait_access.rs:12:22
+  --> $DIR/default_trait_access.rs:15:22
    |
 LL |     let s3: String = D2::default();
    |                      ^^^^^^^^^^^^^ help: try: `std::string::String::default()`
 
 error: calling `std::string::String::default()` is more clear than this expression
-  --> $DIR/default_trait_access.rs:14:22
+  --> $DIR/default_trait_access.rs:17:22
    |
 LL |     let s4: String = std::default::Default::default();
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::string::String::default()`
 
 error: calling `std::string::String::default()` is more clear than this expression
-  --> $DIR/default_trait_access.rs:18:22
+  --> $DIR/default_trait_access.rs:21:22
    |
 LL |     let s6: String = default::Default::default();
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::string::String::default()`
 
-error: calling `GenericDerivedDefault<std::string::String>::default()` is more clear than this expression
-  --> $DIR/default_trait_access.rs:28:46
+error: calling `GenericDerivedDefault::default()` is more clear than this expression
+  --> $DIR/default_trait_access.rs:31:46
    |
 LL |     let s11: GenericDerivedDefault<String> = Default::default();
-   |                                              ^^^^^^^^^^^^^^^^^^ help: try: `GenericDerivedDefault<std::string::String>::default()`
+   |                                              ^^^^^^^^^^^^^^^^^^ help: try: `GenericDerivedDefault::default()`
 
 error: calling `TupleDerivedDefault::default()` is more clear than this expression
-  --> $DIR/default_trait_access.rs:34:36
+  --> $DIR/default_trait_access.rs:37:36
    |
 LL |     let s14: TupleDerivedDefault = Default::default();
    |                                    ^^^^^^^^^^^^^^^^^^ help: try: `TupleDerivedDefault::default()`
 
 error: calling `ArrayDerivedDefault::default()` is more clear than this expression
-  --> $DIR/default_trait_access.rs:36:36
+  --> $DIR/default_trait_access.rs:39:36
    |
 LL |     let s15: ArrayDerivedDefault = Default::default();
    |                                    ^^^^^^^^^^^^^^^^^^ help: try: `ArrayDerivedDefault::default()`
 
 error: calling `TupleStructDerivedDefault::default()` is more clear than this expression
-  --> $DIR/default_trait_access.rs:40:42
+  --> $DIR/default_trait_access.rs:43:42
    |
 LL |     let s17: TupleStructDerivedDefault = Default::default();
    |                                          ^^^^^^^^^^^^^^^^^^ help: try: `TupleStructDerivedDefault::default()`
-- 
cgit 1.4.1-3-g733a5


From f9fcbbea03edb735c22311522b55d7b854bd6ac0 Mon Sep 17 00:00:00 2001
From: Vali Schneider <eval@fb.com>
Date: Mon, 31 Aug 2020 13:32:05 -0700
Subject: fixed bug

---
 clippy_lints/src/panic_in_result.rs | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/panic_in_result.rs b/clippy_lints/src/panic_in_result.rs
index 8ba365cb00c..8b8e211cb72 100644
--- a/clippy_lints/src/panic_in_result.rs
+++ b/clippy_lints/src/panic_in_result.rs
@@ -34,12 +34,15 @@ impl<'tcx> LateLintPass<'tcx> for PanicInResult {
     fn check_fn(
         &mut self,
         cx: &LateContext<'tcx>,
-        _: FnKind<'tcx>,
+        fn_kind: FnKind<'tcx>,
         _: &'tcx hir::FnDecl<'tcx>,
         body: &'tcx hir::Body<'tcx>,
         span: Span,
         hir_id: hir::HirId,
     ) {
+        if let FnKind::Closure(_) = fn_kind {
+            return;
+        }
         if_chain! {
             if is_type_diagnostic_item(cx, return_ty(cx, hir_id), sym!(result_type));
             then
-- 
cgit 1.4.1-3-g733a5


From afeb917fca7eaa5b44acd29a60f687024c0ebeac Mon Sep 17 00:00:00 2001
From: rail <12975677+rail-rain@users.noreply.github.com>
Date: Tue, 1 Sep 2020 11:21:48 +1200
Subject: Fix a fp in `transmute_ptr_to_ptr`

Avoid firing the lint when `transmute` in const contexts
as dereferencing raw pointers in consts is unstable. cc #5959
---
 clippy_lints/src/transmute.rs    | 6 ++++--
 tests/ui/transmute_ptr_to_ptr.rs | 8 ++++++++
 2 files changed, 12 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/transmute.rs b/clippy_lints/src/transmute.rs
index 50d9c93f9d4..789d124eae2 100644
--- a/clippy_lints/src/transmute.rs
+++ b/clippy_lints/src/transmute.rs
@@ -331,8 +331,9 @@ impl<'tcx> LateLintPass<'tcx> for Transmute {
             if let Some(def_id) = cx.qpath_res(qpath, path_expr.hir_id).opt_def_id();
             if match_def_path(cx, def_id, &paths::TRANSMUTE);
             then {
-                // Avoid suggesting from/to bits in const contexts.
+                // Avoid suggesting from/to bits and dereferencing raw pointers in const contexts.
                 // See https://github.com/rust-lang/rust/issues/73736 for progress on making them `const fn`.
+                // And see https://github.com/rust-lang/rust/issues/51911 for dereferencing raw pointers.
                 let const_context = in_constant(cx, e.hir_id);
 
                 let from_ty = cx.typeck_results().expr_ty(&args[0]);
@@ -486,7 +487,8 @@ impl<'tcx> LateLintPass<'tcx> for Transmute {
                                     Applicability::Unspecified,
                                 );
                             } else {
-                                if cx.tcx.erase_regions(&from_ty) != cx.tcx.erase_regions(&to_ty) {
+                                if (cx.tcx.erase_regions(&from_ty) != cx.tcx.erase_regions(&to_ty))
+                                    && !const_context {
                                     span_lint_and_then(
                                         cx,
                                         TRANSMUTE_PTR_TO_PTR,
diff --git a/tests/ui/transmute_ptr_to_ptr.rs b/tests/ui/transmute_ptr_to_ptr.rs
index 0d8a322f2b2..26b03bdc740 100644
--- a/tests/ui/transmute_ptr_to_ptr.rs
+++ b/tests/ui/transmute_ptr_to_ptr.rs
@@ -51,4 +51,12 @@ fn transmute_ptr_to_ptr() {
     let _: &GenericParam<&LifetimeParam<'static>> = unsafe { std::mem::transmute(&GenericParam { t: &lp }) };
 }
 
+// dereferencing raw pointers in const contexts, should not lint as it's unstable (issue 5959)
+const _: &() = {
+    struct ZST;
+    let zst = &ZST;
+
+    unsafe { std::mem::transmute::<&'static ZST, &'static ()>(zst) }
+};
+
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 2e4b4cebbbb37efa5dc69dd2616f3b7a288b92aa Mon Sep 17 00:00:00 2001
From: Taiki Endo <te316e89@gmail.com>
Date: Tue, 1 Sep 2020 12:09:32 +0900
Subject: useless_attribute: Permit wildcard_imports and enum_glob_use

---
 clippy_lints/src/attrs.rs         | 38 ++++++++++++++++++++++----------------
 tests/ui/useless_attribute.fixed  |  8 ++++++++
 tests/ui/useless_attribute.rs     |  8 ++++++++
 tests/ui/useless_attribute.stderr |  2 +-
 4 files changed, 39 insertions(+), 17 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs
index cfcc1b3c5f3..c8f153e7201 100644
--- a/clippy_lints/src/attrs.rs
+++ b/clippy_lints/src/attrs.rs
@@ -71,8 +71,9 @@ declare_clippy_lint! {
     /// **What it does:** Checks for `extern crate` and `use` items annotated with
     /// lint attributes.
     ///
-    /// This lint permits `#[allow(unused_imports)]`, `#[allow(deprecated)]` and
-    /// `#[allow(unreachable_pub)]` on `use` items and `#[allow(unused_imports)]` on
+    /// This lint permits `#[allow(unused_imports)]`, `#[allow(deprecated)]`,
+    /// `#[allow(unreachable_pub)]`, `#[allow(clippy::wildcard_imports)]` and
+    /// `#[allow(clippy::enum_glob_use)]` on `use` items and `#[allow(unused_imports)]` on
     /// `extern crate` items with a `#[macro_use]` attribute.
     ///
     /// **Why is this bad?** Lint attributes have no effect on crate imports. Most
@@ -318,7 +319,8 @@ impl<'tcx> LateLintPass<'tcx> for Attributes {
                         if let Some(ident) = attr.ident() {
                             match &*ident.as_str() {
                                 "allow" | "warn" | "deny" | "forbid" => {
-                                    // permit `unused_imports`, `deprecated` and `unreachable_pub` for `use` items
+                                    // permit `unused_imports`, `deprecated`, `unreachable_pub`,
+                                    // `clippy::wildcard_imports`, and `clippy::enum_glob_use` for `use` items
                                     // and `unused_imports` for `extern crate` items with `macro_use`
                                     for lint in lint_list {
                                         match item.kind {
@@ -327,6 +329,9 @@ impl<'tcx> LateLintPass<'tcx> for Attributes {
                                                     || is_word(lint, sym!(deprecated))
                                                     || is_word(lint, sym!(unreachable_pub))
                                                     || is_word(lint, sym!(unused))
+                                                    || extract_clippy_lint(lint)
+                                                        .map_or(false, |s| s == "wildcard_imports")
+                                                    || extract_clippy_lint(lint).map_or(false, |s| s == "enum_glob_use")
                                                 {
                                                     return;
                                                 }
@@ -387,24 +392,25 @@ impl<'tcx> LateLintPass<'tcx> for Attributes {
     }
 }
 
-fn check_clippy_lint_names(cx: &LateContext<'_>, ident: &str, items: &[NestedMetaItem]) {
-    fn extract_name(lint: &NestedMetaItem) -> Option<SymbolStr> {
-        if_chain! {
-            if let Some(meta_item) = lint.meta_item();
-            if meta_item.path.segments.len() > 1;
-            if let tool_name = meta_item.path.segments[0].ident;
-            if tool_name.as_str() == "clippy";
-            let lint_name = meta_item.path.segments.last().unwrap().ident.name;
-            then {
-                return Some(lint_name.as_str());
-            }
+/// Returns the lint name if it is clippy lint.
+fn extract_clippy_lint(lint: &NestedMetaItem) -> Option<SymbolStr> {
+    if_chain! {
+        if let Some(meta_item) = lint.meta_item();
+        if meta_item.path.segments.len() > 1;
+        if let tool_name = meta_item.path.segments[0].ident;
+        if tool_name.as_str() == "clippy";
+        let lint_name = meta_item.path.segments.last().unwrap().ident.name;
+        then {
+            return Some(lint_name.as_str());
         }
-        None
     }
+    None
+}
 
+fn check_clippy_lint_names(cx: &LateContext<'_>, ident: &str, items: &[NestedMetaItem]) {
     let lint_store = cx.lints();
     for lint in items {
-        if let Some(lint_name) = extract_name(lint) {
+        if let Some(lint_name) = extract_clippy_lint(lint) {
             if let CheckLintNameResult::Tool(Err((None, _))) =
                 lint_store.check_lint_name(&lint_name, Some(sym!(clippy)))
             {
diff --git a/tests/ui/useless_attribute.fixed b/tests/ui/useless_attribute.fixed
index b222e2f7976..a5fcde768f1 100644
--- a/tests/ui/useless_attribute.fixed
+++ b/tests/ui/useless_attribute.fixed
@@ -49,6 +49,14 @@ mod a {
     pub use self::b::C;
 }
 
+// don't lint on clippy::wildcard_imports for `use` items
+#[allow(clippy::wildcard_imports)]
+pub use std::io::prelude::*;
+
+// don't lint on clippy::enum_glob_use for `use` items
+#[allow(clippy::enum_glob_use)]
+pub use std::cmp::Ordering::*;
+
 fn test_indented_attr() {
     #![allow(clippy::almost_swapped)]
     use std::collections::HashSet;
diff --git a/tests/ui/useless_attribute.rs b/tests/ui/useless_attribute.rs
index 3422eace4ab..0396d39e3d5 100644
--- a/tests/ui/useless_attribute.rs
+++ b/tests/ui/useless_attribute.rs
@@ -49,6 +49,14 @@ mod a {
     pub use self::b::C;
 }
 
+// don't lint on clippy::wildcard_imports for `use` items
+#[allow(clippy::wildcard_imports)]
+pub use std::io::prelude::*;
+
+// don't lint on clippy::enum_glob_use for `use` items
+#[allow(clippy::enum_glob_use)]
+pub use std::cmp::Ordering::*;
+
 fn test_indented_attr() {
     #[allow(clippy::almost_swapped)]
     use std::collections::HashSet;
diff --git a/tests/ui/useless_attribute.stderr b/tests/ui/useless_attribute.stderr
index 57ba976730c..d0194e4bbbe 100644
--- a/tests/ui/useless_attribute.stderr
+++ b/tests/ui/useless_attribute.stderr
@@ -13,7 +13,7 @@ LL | #[cfg_attr(feature = "cargo-clippy", allow(dead_code))]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: if you just forgot a `!`, use: `#![cfg_attr(feature = "cargo-clippy", allow(dead_code)`
 
 error: useless lint attribute
-  --> $DIR/useless_attribute.rs:53:5
+  --> $DIR/useless_attribute.rs:61:5
    |
 LL |     #[allow(clippy::almost_swapped)]
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: if you just forgot a `!`, use: `#![allow(clippy::almost_swapped)]`
-- 
cgit 1.4.1-3-g733a5


From b30422114e6bb7235398f21fe13ffa09429b7d0f Mon Sep 17 00:00:00 2001
From: Koxiaet <38139193+Koxiaet@users.noreply.github.com>
Date: Tue, 1 Sep 2020 14:05:19 +0100
Subject: Allow GraphQL in doc without backticks

---
 clippy_lints/src/utils/conf.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 292dbd7ad6b..9c5a12ea9c8 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -122,7 +122,7 @@ define_Conf! {
         "IPv4", "IPv6",
         "ClojureScript", "CoffeeScript", "JavaScript", "PureScript", "TypeScript",
         "NaN", "NaNs",
-        "OAuth",
+        "OAuth", "GraphQL",
         "OCaml",
         "OpenGL", "OpenMP", "OpenSSH", "OpenSSL", "OpenStreetMap",
         "TensorFlow",
-- 
cgit 1.4.1-3-g733a5


From aa7ffa5257667edb284de16b529df3d4111d70ab Mon Sep 17 00:00:00 2001
From: Takayuki Nakata <f.seasons017@gmail.com>
Date: Tue, 1 Sep 2020 22:39:09 +0900
Subject: Fix FP in `same_item_push`

Don't emit a lint when the pushed item doesn't have Clone trait
---
 clippy_lints/src/loops.rs  | 78 +++++++++++++++++++++++++---------------------
 tests/ui/same_item_push.rs |  6 ++++
 2 files changed, 49 insertions(+), 35 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index c95e43a9430..25345f8fa31 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -1140,43 +1140,51 @@ fn detect_same_item_push<'tcx>(
     walk_expr(&mut same_item_push_visitor, body);
     if same_item_push_visitor.should_lint {
         if let Some((vec, pushed_item)) = same_item_push_visitor.vec_push {
-            // Make sure that the push does not involve possibly mutating values
-            if let PatKind::Wild = pat.kind {
-                let vec_str = snippet_with_macro_callsite(cx, vec.span, "");
-                let item_str = snippet_with_macro_callsite(cx, pushed_item.span, "");
-                if let ExprKind::Path(ref qpath) = pushed_item.kind {
-                    if_chain! {
-                        if let Res::Local(hir_id) = qpath_res(cx, qpath, pushed_item.hir_id);
-                        let node = cx.tcx.hir().get(hir_id);
-                        if let Node::Binding(pat) = node;
-                        if let PatKind::Binding(bind_ann, ..) = pat.kind;
-                        if !matches!(bind_ann, BindingAnnotation::RefMut | BindingAnnotation::Mutable);
-                        then {
-                            span_lint_and_help(
-                                cx,
-                                SAME_ITEM_PUSH,
-                                vec.span,
-                                "it looks like the same item is being pushed into this Vec",
-                                None,
-                                &format!(
-                                    "try using vec![{};SIZE] or {}.resize(NEW_SIZE, {})",
-                                    item_str, vec_str, item_str
-                                ),
-                            )
+            let ty = cx.typeck_results().expr_ty(pushed_item);
+            if cx
+                .tcx
+                .lang_items()
+                .clone_trait()
+                .map_or(false, |id| implements_trait(cx, ty, id, &[]))
+            {
+                // Make sure that the push does not involve possibly mutating values
+                if let PatKind::Wild = pat.kind {
+                    let vec_str = snippet_with_macro_callsite(cx, vec.span, "");
+                    let item_str = snippet_with_macro_callsite(cx, pushed_item.span, "");
+                    if let ExprKind::Path(ref qpath) = pushed_item.kind {
+                        if_chain! {
+                            if let Res::Local(hir_id) = qpath_res(cx, qpath, pushed_item.hir_id);
+                            let node = cx.tcx.hir().get(hir_id);
+                            if let Node::Binding(pat) = node;
+                            if let PatKind::Binding(bind_ann, ..) = pat.kind;
+                            if !matches!(bind_ann, BindingAnnotation::RefMut | BindingAnnotation::Mutable);
+                            then {
+                                span_lint_and_help(
+                                    cx,
+                                    SAME_ITEM_PUSH,
+                                    vec.span,
+                                    "it looks like the same item is being pushed into this Vec",
+                                    None,
+                                    &format!(
+                                        "try using vec![{};SIZE] or {}.resize(NEW_SIZE, {})",
+                                        item_str, vec_str, item_str
+                                    ),
+                                )
+                            }
                         }
+                    } else if mutated_variables(pushed_item, cx).map_or(false, |mutvars| mutvars.is_empty()) {
+                        span_lint_and_help(
+                            cx,
+                            SAME_ITEM_PUSH,
+                            vec.span,
+                            "it looks like the same item is being pushed into this Vec",
+                            None,
+                            &format!(
+                                "try using vec![{};SIZE] or {}.resize(NEW_SIZE, {})",
+                                item_str, vec_str, item_str
+                            ),
+                        )
                     }
-                } else if mutated_variables(pushed_item, cx).map_or(false, |mutvars| mutvars.is_empty()) {
-                    span_lint_and_help(
-                        cx,
-                        SAME_ITEM_PUSH,
-                        vec.span,
-                        "it looks like the same item is being pushed into this Vec",
-                        None,
-                        &format!(
-                            "try using vec![{};SIZE] or {}.resize(NEW_SIZE, {})",
-                            item_str, vec_str, item_str
-                        ),
-                    )
                 }
             }
         }
diff --git a/tests/ui/same_item_push.rs b/tests/ui/same_item_push.rs
index bfe27e02044..0903a873826 100644
--- a/tests/ui/same_item_push.rs
+++ b/tests/ui/same_item_push.rs
@@ -94,4 +94,10 @@ fn main() {
         vec13.push(item);
         item += 10;
     }
+
+    // Fix #5979
+    let mut vec14: Vec<std::fs::File> = Vec::new();
+    for _ in 0..10 {
+        vec14.push(std::fs::File::open("foobar").unwrap());
+    }
 }
-- 
cgit 1.4.1-3-g733a5


From e49a29933be3bd988ccb75b053f480d9c99a7ff5 Mon Sep 17 00:00:00 2001
From: Ricky <Ricky@Hosfelt.io>
Date: Tue, 1 Sep 2020 16:26:59 -0400
Subject: Working map_err_ignore lint

---
 clippy_lints/src/lib.rs            |   5 ++
 clippy_lints/src/map_err_ignore.rs | 108 +++++++++++++++++++++++++++++++++++++
 2 files changed, 113 insertions(+)
 create mode 100644 clippy_lints/src/map_err_ignore.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 0eb1d331366..8e80779377b 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -230,6 +230,7 @@ mod main_recursion;
 mod manual_async_fn;
 mod manual_non_exhaustive;
 mod map_clone;
+mod map_err_ignore;
 mod map_identity;
 mod map_unit_fn;
 mod match_on_vec_items;
@@ -624,6 +625,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &manual_async_fn::MANUAL_ASYNC_FN,
         &manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE,
         &map_clone::MAP_CLONE,
+        &map_err_ignore::MAP_ERR_IGNORE,
         &map_identity::MAP_IDENTITY,
         &map_unit_fn::OPTION_MAP_UNIT_FN,
         &map_unit_fn::RESULT_MAP_UNIT_FN,
@@ -916,6 +918,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box implicit_saturating_sub::ImplicitSaturatingSub);
     store.register_late_pass(|| box methods::Methods);
     store.register_late_pass(|| box map_clone::MapClone);
+    store.register_late_pass(|| box map_err_ignore::MapErrIgnore);
     store.register_late_pass(|| box shadow::Shadow);
     store.register_late_pass(|| box types::LetUnitValue);
     store.register_late_pass(|| box types::UnitCmp);
@@ -1327,6 +1330,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&manual_async_fn::MANUAL_ASYNC_FN),
         LintId::of(&manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE),
         LintId::of(&map_clone::MAP_CLONE),
+        LintId::of(&map_err_ignore::MAP_ERR_IGNORE),
         LintId::of(&map_identity::MAP_IDENTITY),
         LintId::of(&map_unit_fn::OPTION_MAP_UNIT_FN),
         LintId::of(&map_unit_fn::RESULT_MAP_UNIT_FN),
@@ -1534,6 +1538,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&manual_async_fn::MANUAL_ASYNC_FN),
         LintId::of(&manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE),
         LintId::of(&map_clone::MAP_CLONE),
+        LintId::of(&map_err_ignore::MAP_ERR_IGNORE), 
         LintId::of(&matches::INFALLIBLE_DESTRUCTURING_MATCH),
         LintId::of(&matches::MATCH_LIKE_MATCHES_MACRO),
         LintId::of(&matches::MATCH_OVERLAPPING_ARM),
diff --git a/clippy_lints/src/map_err_ignore.rs b/clippy_lints/src/map_err_ignore.rs
new file mode 100644
index 00000000000..c63c201a9f3
--- /dev/null
+++ b/clippy_lints/src/map_err_ignore.rs
@@ -0,0 +1,108 @@
+use crate::utils::span_lint_and_sugg;
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind, CaptureBy, PatKind, QPath};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for instances of `map_err(|_| Some::Enum)`
+    ///
+    /// **Why is this bad?** This map_err throws away the original error rather than allowing the enum to bubble the original error
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// enum Errors {
+    ///    Ignore
+    ///}
+    ///fn main() -> Result<(), Errors> {
+    ///    
+    ///    let x = u32::try_from(-123_i32);
+    ///
+    ///    println!("{:?}", x.map_err(|_| Errors::Ignore));
+    ///
+    ///    Ok(())
+    ///}
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// enum Errors {
+    ///    WithContext(TryFromIntError)
+    ///}
+    ///fn main() -> Result<(), Errors> {
+    ///    
+    ///    let x = u32::try_from(-123_i32);
+    ///
+    ///    println!("{:?}", x.map_err(|e| Errors::WithContext(e)));
+    ///
+    ///    Ok(())
+    ///}
+    /// ```
+    pub MAP_ERR_IGNORE,
+    style,
+    "`map_err` should not ignore the original error"
+}
+
+declare_lint_pass!(MapErrIgnore => [MAP_ERR_IGNORE]);
+
+impl<'tcx> LateLintPass<'tcx> for MapErrIgnore {
+    // do not try to lint if this is from a macro or desugaring 
+    fn check_expr(&mut self, cx: &LateContext<'_>, e: &Expr<'_>) {
+        if e.span.from_expansion() {
+            return;
+        }
+
+        // check if this is a method call (e.g. x.foo())
+        if let ExprKind::MethodCall(ref method, _t_span, ref args, _) = e.kind {
+            // only work if the method name is `map_err` and there are only 2 arguments (e.g. x.map_err(|_|[1] Enum::Variant[2]))
+            if method.ident.as_str() == "map_err" && args.len() == 2 {
+                // make sure the first argument is a closure, and grab the CaptureRef, body_id, and body_span fields
+                if let ExprKind::Closure(capture, _, body_id, body_span, _) = args[1].kind {  
+                    // check if this is by Reference (meaning there's no move statement)
+                    if capture == CaptureBy::Ref { 
+                        // Get the closure body to check the parameters and values 
+                        let closure_body = cx.tcx.hir().body(body_id);
+                        // make sure there's only one parameter (`|_|`)
+                        if closure_body.params.len() == 1 {          
+                            // make sure that parameter is the wild token (`_`)                  
+                            if let PatKind::Wild = closure_body.params[0].pat.kind {
+                                // Check the value of the closure to see if we can build the enum we are throwing away the error for
+                                // make sure this is a Path
+                                if let ExprKind::Path(q_path) = &closure_body.value.kind {
+                                    // this should be a resolved path, only keep the path field
+                                    if let QPath::Resolved(_, path) = q_path {
+                                        // finally get the idents for each path segment collect them as a string and join them with the path separator ("::"")
+                                        let closure_fold: String = path.segments.iter().map(|x| x.ident.as_str().to_string()).collect::<Vec<String>>().join("::");
+                                        //Span the body of the closure (the |...| bit) and suggest the fix by taking the error and encapsulating it in the enum 
+                                        span_lint_and_sugg(
+                                            cx,
+                                            MAP_ERR_IGNORE,
+                                            body_span,
+                                            "`map_err` has thrown away the original error",
+                                            "Allow the error enum to encapsulate the original error",
+                                            format!("|e| {}(e)", closure_fold),
+                                            Applicability::HasPlaceholders,
+                                        ); 
+                                    }
+                                } else {
+                                    //If we cannot build the enum in a human readable way just suggest not throwing way the error
+                                    span_lint_and_sugg(
+                                        cx,
+                                        MAP_ERR_IGNORE,
+                                        body_span,
+                                        "`map_err` has thrown away the original error",
+                                        "Allow the error enum to encapsulate the original error",
+                                        "|e|".to_string(),
+                                        Applicability::HasPlaceholders,
+                                    ); 
+                                }
+                            }
+                        }
+                    }  
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
-- 
cgit 1.4.1-3-g733a5


From 202a80c927412a548180eca5990ee764d76ed643 Mon Sep 17 00:00:00 2001
From: Ricky <Ricky@Hosfelt.io>
Date: Tue, 1 Sep 2020 16:59:37 -0400
Subject: Added tests for map_err, ignored map_err lint on drop_ref tests

---
 clippy_lints/src/map_err_ignore.rs | 49 ++++++++++++++++++++++----------------
 tests/ui/drop_ref.rs               |  1 +
 tests/ui/drop_ref.stderr           | 36 ++++++++++++++--------------
 tests/ui/map_err.rs                | 24 +++++++++++++++++++
 tests/ui/map_err.stderr            | 10 ++++++++
 5 files changed, 82 insertions(+), 38 deletions(-)
 create mode 100644 tests/ui/map_err.rs
 create mode 100644 tests/ui/map_err.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/map_err_ignore.rs b/clippy_lints/src/map_err_ignore.rs
index c63c201a9f3..43bfcf0b8f1 100644
--- a/clippy_lints/src/map_err_ignore.rs
+++ b/clippy_lints/src/map_err_ignore.rs
@@ -1,6 +1,6 @@
 use crate::utils::span_lint_and_sugg;
 use rustc_errors::Applicability;
-use rustc_hir::{Expr, ExprKind, CaptureBy, PatKind, QPath};
+use rustc_hir::{CaptureBy, Expr, ExprKind, PatKind, QPath};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
@@ -18,7 +18,7 @@ declare_clippy_lint! {
     ///    Ignore
     ///}
     ///fn main() -> Result<(), Errors> {
-    ///    
+    ///
     ///    let x = u32::try_from(-123_i32);
     ///
     ///    println!("{:?}", x.map_err(|_| Errors::Ignore));
@@ -32,7 +32,7 @@ declare_clippy_lint! {
     ///    WithContext(TryFromIntError)
     ///}
     ///fn main() -> Result<(), Errors> {
-    ///    
+    ///
     ///    let x = u32::try_from(-123_i32);
     ///
     ///    println!("{:?}", x.map_err(|e| Errors::WithContext(e)));
@@ -48,7 +48,7 @@ declare_clippy_lint! {
 declare_lint_pass!(MapErrIgnore => [MAP_ERR_IGNORE]);
 
 impl<'tcx> LateLintPass<'tcx> for MapErrIgnore {
-    // do not try to lint if this is from a macro or desugaring 
+    // do not try to lint if this is from a macro or desugaring
     fn check_expr(&mut self, cx: &LateContext<'_>, e: &Expr<'_>) {
         if e.span.from_expansion() {
             return;
@@ -56,26 +56,34 @@ impl<'tcx> LateLintPass<'tcx> for MapErrIgnore {
 
         // check if this is a method call (e.g. x.foo())
         if let ExprKind::MethodCall(ref method, _t_span, ref args, _) = e.kind {
-            // only work if the method name is `map_err` and there are only 2 arguments (e.g. x.map_err(|_|[1] Enum::Variant[2]))
+            // only work if the method name is `map_err` and there are only 2 arguments (e.g. x.map_err(|_|[1]
+            // Enum::Variant[2]))
             if method.ident.as_str() == "map_err" && args.len() == 2 {
                 // make sure the first argument is a closure, and grab the CaptureRef, body_id, and body_span fields
-                if let ExprKind::Closure(capture, _, body_id, body_span, _) = args[1].kind {  
+                if let ExprKind::Closure(capture, _, body_id, body_span, _) = args[1].kind {
                     // check if this is by Reference (meaning there's no move statement)
-                    if capture == CaptureBy::Ref { 
-                        // Get the closure body to check the parameters and values 
+                    if capture == CaptureBy::Ref {
+                        // Get the closure body to check the parameters and values
                         let closure_body = cx.tcx.hir().body(body_id);
                         // make sure there's only one parameter (`|_|`)
-                        if closure_body.params.len() == 1 {          
-                            // make sure that parameter is the wild token (`_`)                  
+                        if closure_body.params.len() == 1 {
+                            // make sure that parameter is the wild token (`_`)
                             if let PatKind::Wild = closure_body.params[0].pat.kind {
-                                // Check the value of the closure to see if we can build the enum we are throwing away the error for
-                                // make sure this is a Path
+                                // Check the value of the closure to see if we can build the enum we are throwing away
+                                // the error for make sure this is a Path
                                 if let ExprKind::Path(q_path) = &closure_body.value.kind {
                                     // this should be a resolved path, only keep the path field
                                     if let QPath::Resolved(_, path) = q_path {
-                                        // finally get the idents for each path segment collect them as a string and join them with the path separator ("::"")
-                                        let closure_fold: String = path.segments.iter().map(|x| x.ident.as_str().to_string()).collect::<Vec<String>>().join("::");
-                                        //Span the body of the closure (the |...| bit) and suggest the fix by taking the error and encapsulating it in the enum 
+                                        // finally get the idents for each path segment collect them as a string and
+                                        // join them with the path separator ("::"")
+                                        let closure_fold: String = path
+                                            .segments
+                                            .iter()
+                                            .map(|x| x.ident.as_str().to_string())
+                                            .collect::<Vec<String>>()
+                                            .join("::");
+                                        //Span the body of the closure (the |...| bit) and suggest the fix by taking
+                                        // the error and encapsulating it in the enum
                                         span_lint_and_sugg(
                                             cx,
                                             MAP_ERR_IGNORE,
@@ -84,10 +92,11 @@ impl<'tcx> LateLintPass<'tcx> for MapErrIgnore {
                                             "Allow the error enum to encapsulate the original error",
                                             format!("|e| {}(e)", closure_fold),
                                             Applicability::HasPlaceholders,
-                                        ); 
+                                        );
                                     }
                                 } else {
-                                    //If we cannot build the enum in a human readable way just suggest not throwing way the error
+                                    //If we cannot build the enum in a human readable way just suggest not throwing way
+                                    // the error
                                     span_lint_and_sugg(
                                         cx,
                                         MAP_ERR_IGNORE,
@@ -96,13 +105,13 @@ impl<'tcx> LateLintPass<'tcx> for MapErrIgnore {
                                         "Allow the error enum to encapsulate the original error",
                                         "|e|".to_string(),
                                         Applicability::HasPlaceholders,
-                                    ); 
+                                    );
                                 }
                             }
                         }
-                    }  
+                    }
                 }
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/tests/ui/drop_ref.rs b/tests/ui/drop_ref.rs
index 9181d789d4f..6b5bcdaa78e 100644
--- a/tests/ui/drop_ref.rs
+++ b/tests/ui/drop_ref.rs
@@ -1,5 +1,6 @@
 #![warn(clippy::drop_ref)]
 #![allow(clippy::toplevel_ref_arg)]
+#![allow(clippy::map_err_ignore)]
 
 use std::mem::drop;
 
diff --git a/tests/ui/drop_ref.stderr b/tests/ui/drop_ref.stderr
index 35ae88b78a4..7974bf56d44 100644
--- a/tests/ui/drop_ref.stderr
+++ b/tests/ui/drop_ref.stderr
@@ -1,108 +1,108 @@
 error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing.
-  --> $DIR/drop_ref.rs:9:5
+  --> $DIR/drop_ref.rs:10:5
    |
 LL |     drop(&SomeStruct);
    |     ^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::drop-ref` implied by `-D warnings`
 note: argument has type `&SomeStruct`
-  --> $DIR/drop_ref.rs:9:10
+  --> $DIR/drop_ref.rs:10:10
    |
 LL |     drop(&SomeStruct);
    |          ^^^^^^^^^^^
 
 error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing.
-  --> $DIR/drop_ref.rs:12:5
+  --> $DIR/drop_ref.rs:13:5
    |
 LL |     drop(&owned1);
    |     ^^^^^^^^^^^^^
    |
 note: argument has type `&SomeStruct`
-  --> $DIR/drop_ref.rs:12:10
+  --> $DIR/drop_ref.rs:13:10
    |
 LL |     drop(&owned1);
    |          ^^^^^^^
 
 error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing.
-  --> $DIR/drop_ref.rs:13:5
+  --> $DIR/drop_ref.rs:14:5
    |
 LL |     drop(&&owned1);
    |     ^^^^^^^^^^^^^^
    |
 note: argument has type `&&SomeStruct`
-  --> $DIR/drop_ref.rs:13:10
+  --> $DIR/drop_ref.rs:14:10
    |
 LL |     drop(&&owned1);
    |          ^^^^^^^^
 
 error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing.
-  --> $DIR/drop_ref.rs:14:5
+  --> $DIR/drop_ref.rs:15:5
    |
 LL |     drop(&mut owned1);
    |     ^^^^^^^^^^^^^^^^^
    |
 note: argument has type `&mut SomeStruct`
-  --> $DIR/drop_ref.rs:14:10
+  --> $DIR/drop_ref.rs:15:10
    |
 LL |     drop(&mut owned1);
    |          ^^^^^^^^^^^
 
 error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing.
-  --> $DIR/drop_ref.rs:18:5
+  --> $DIR/drop_ref.rs:19:5
    |
 LL |     drop(reference1);
    |     ^^^^^^^^^^^^^^^^
    |
 note: argument has type `&SomeStruct`
-  --> $DIR/drop_ref.rs:18:10
+  --> $DIR/drop_ref.rs:19:10
    |
 LL |     drop(reference1);
    |          ^^^^^^^^^^
 
 error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing.
-  --> $DIR/drop_ref.rs:21:5
+  --> $DIR/drop_ref.rs:22:5
    |
 LL |     drop(reference2);
    |     ^^^^^^^^^^^^^^^^
    |
 note: argument has type `&mut SomeStruct`
-  --> $DIR/drop_ref.rs:21:10
+  --> $DIR/drop_ref.rs:22:10
    |
 LL |     drop(reference2);
    |          ^^^^^^^^^^
 
 error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing.
-  --> $DIR/drop_ref.rs:24:5
+  --> $DIR/drop_ref.rs:25:5
    |
 LL |     drop(reference3);
    |     ^^^^^^^^^^^^^^^^
    |
 note: argument has type `&SomeStruct`
-  --> $DIR/drop_ref.rs:24:10
+  --> $DIR/drop_ref.rs:25:10
    |
 LL |     drop(reference3);
    |          ^^^^^^^^^^
 
 error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing.
-  --> $DIR/drop_ref.rs:29:5
+  --> $DIR/drop_ref.rs:30:5
    |
 LL |     drop(&val);
    |     ^^^^^^^^^^
    |
 note: argument has type `&T`
-  --> $DIR/drop_ref.rs:29:10
+  --> $DIR/drop_ref.rs:30:10
    |
 LL |     drop(&val);
    |          ^^^^
 
 error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing.
-  --> $DIR/drop_ref.rs:37:5
+  --> $DIR/drop_ref.rs:38:5
    |
 LL |     std::mem::drop(&SomeStruct);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: argument has type `&SomeStruct`
-  --> $DIR/drop_ref.rs:37:20
+  --> $DIR/drop_ref.rs:38:20
    |
 LL |     std::mem::drop(&SomeStruct);
    |                    ^^^^^^^^^^^
diff --git a/tests/ui/map_err.rs b/tests/ui/map_err.rs
new file mode 100644
index 00000000000..f3a74ad95cd
--- /dev/null
+++ b/tests/ui/map_err.rs
@@ -0,0 +1,24 @@
+use std::convert::TryFrom;
+use std::error::Error;
+use std::fmt;
+
+#[derive(Debug)]
+enum Errors {
+    Ignored,
+}
+
+impl Error for Errors {}
+
+impl fmt::Display for Errors {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "Error")
+    }
+}
+
+fn main() -> Result<(), Errors> {
+    let x = u32::try_from(-123_i32);
+
+    println!("{:?}", x.map_err(|_| Errors::Ignored));
+
+    Ok(())
+}
diff --git a/tests/ui/map_err.stderr b/tests/ui/map_err.stderr
new file mode 100644
index 00000000000..8cd37d8c025
--- /dev/null
+++ b/tests/ui/map_err.stderr
@@ -0,0 +1,10 @@
+error: `map_err` has thrown away the original error
+  --> $DIR/map_err.rs:21:32
+   |
+LL |     println!("{:?}", x.map_err(|_| Errors::Ignored));
+   |                                ^^^ help: Allow the error enum to encapsulate the original error: `|e| Errors::Ignored(e)`
+   |
+   = note: `-D clippy::map-err-ignore` implied by `-D warnings`
+
+error: aborting due to previous error
+
-- 
cgit 1.4.1-3-g733a5


From 337729137bdec31b55665653ef0cf7dc124b0eaa Mon Sep 17 00:00:00 2001
From: Ricky <Ricky@Hosfelt.io>
Date: Tue, 1 Sep 2020 17:05:40 -0400
Subject: Ran cargo dev update_lints

---
 CHANGELOG.md            | 1 +
 clippy_lints/src/lib.rs | 2 +-
 src/lintlist/mod.rs     | 7 +++++++
 3 files changed, 9 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 99a8b1a6293..dfe45a46f09 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1675,6 +1675,7 @@ Released 2018-09-13
 [`many_single_char_names`]: https://rust-lang.github.io/rust-clippy/master/index.html#many_single_char_names
 [`map_clone`]: https://rust-lang.github.io/rust-clippy/master/index.html#map_clone
 [`map_entry`]: https://rust-lang.github.io/rust-clippy/master/index.html#map_entry
+[`map_err_ignore`]: https://rust-lang.github.io/rust-clippy/master/index.html#map_err_ignore
 [`map_flatten`]: https://rust-lang.github.io/rust-clippy/master/index.html#map_flatten
 [`map_identity`]: https://rust-lang.github.io/rust-clippy/master/index.html#map_identity
 [`map_unwrap_or`]: https://rust-lang.github.io/rust-clippy/master/index.html#map_unwrap_or
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 8e80779377b..3794cae091a 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1538,7 +1538,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&manual_async_fn::MANUAL_ASYNC_FN),
         LintId::of(&manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE),
         LintId::of(&map_clone::MAP_CLONE),
-        LintId::of(&map_err_ignore::MAP_ERR_IGNORE), 
+        LintId::of(&map_err_ignore::MAP_ERR_IGNORE),
         LintId::of(&matches::INFALLIBLE_DESTRUCTURING_MATCH),
         LintId::of(&matches::MATCH_LIKE_MATCHES_MACRO),
         LintId::of(&matches::MATCH_OVERLAPPING_ARM),
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index dff19ef440f..6725c97f793 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -1165,6 +1165,13 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
         deprecation: None,
         module: "entry",
     },
+    Lint {
+        name: "map_err_ignore",
+        group: "style",
+        desc: "`map_err` should not ignore the original error",
+        deprecation: None,
+        module: "map_err_ignore",
+    },
     Lint {
         name: "map_flatten",
         group: "pedantic",
-- 
cgit 1.4.1-3-g733a5


From a5754a1fad6eeb765bc825dcc657134985576787 Mon Sep 17 00:00:00 2001
From: Eduardo Broto <ebroto@tutanota.com>
Date: Wed, 2 Sep 2020 08:57:00 +0200
Subject: Run cargo dev fmt

---
 clippy_lints/src/utils/ast_utils.rs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/ast_utils.rs b/clippy_lints/src/utils/ast_utils.rs
index 3c3f8b26e3a..fa8dd210eba 100644
--- a/clippy_lints/src/utils/ast_utils.rs
+++ b/clippy_lints/src/utils/ast_utils.rs
@@ -191,7 +191,9 @@ pub fn eq_stmt(l: &Stmt, r: &Stmt) -> bool {
         (Item(l), Item(r)) => eq_item(l, r, eq_item_kind),
         (Expr(l), Expr(r)) | (Semi(l), Semi(r)) => eq_expr(l, r),
         (Empty, Empty) => true,
-        (MacCall(l), MacCall(r)) => l.style == r.style && eq_mac_call(&l.mac, &r.mac) && over(&l.attrs, &r.attrs, |l, r| eq_attr(l, r)),
+        (MacCall(l), MacCall(r)) => {
+            l.style == r.style && eq_mac_call(&l.mac, &r.mac) && over(&l.attrs, &r.attrs, |l, r| eq_attr(l, r))
+        },
         _ => false,
     }
 }
-- 
cgit 1.4.1-3-g733a5


From b220ddf146f4c11011b2e1b7f37ecb8e5485555b Mon Sep 17 00:00:00 2001
From: Tim Nielens <tim.nielens@gmail.com>
Date: Wed, 2 Sep 2020 23:30:40 +0200
Subject: unit-arg - pr remarks

---
 clippy_lints/src/types.rs     | 82 +++++++++++++++++++++---------------
 clippy_lints/src/utils/mod.rs | 96 ++++++++++++++++++++++++-------------------
 2 files changed, 103 insertions(+), 75 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs
index 16e48d91916..e83d491fac3 100644
--- a/clippy_lints/src/types.rs
+++ b/clippy_lints/src/types.rs
@@ -31,8 +31,8 @@ use crate::utils::paths;
 use crate::utils::{
     clip, comparisons, differing_macro_contexts, higher, in_constant, indent_of, int_bits, is_type_diagnostic_item,
     last_path_segment, match_def_path, match_path, method_chain_args, multispan_sugg, numeric_literal::NumericLiteral,
-    qpath_res, sext, snippet, snippet_opt, snippet_with_applicability, snippet_with_macro_callsite, span_lint,
-    span_lint_and_help, span_lint_and_sugg, span_lint_and_then, trim_multiline, unsext,
+    qpath_res, reindent_multiline, sext, snippet, snippet_opt, snippet_with_applicability, snippet_with_macro_callsite,
+    span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then, unsext,
 };
 
 declare_clippy_lint! {
@@ -802,7 +802,45 @@ impl<'tcx> LateLintPass<'tcx> for UnitArg {
     }
 }
 
-#[allow(clippy::too_many_lines)]
+fn fmt_stmts_and_call(
+    cx: &LateContext<'_>,
+    call_expr: &Expr<'_>,
+    call_snippet: &str,
+    args_snippets: &[impl AsRef<str>],
+    non_empty_block_args_snippets: &[impl AsRef<str>],
+) -> String {
+    let call_expr_indent = indent_of(cx, call_expr.span).unwrap_or(0);
+    let call_snippet_with_replacements = args_snippets
+        .iter()
+        .fold(call_snippet.to_owned(), |acc, arg| acc.replacen(arg.as_ref(), "()", 1));
+
+    let mut stmts_and_call = non_empty_block_args_snippets
+        .iter()
+        .map(|it| it.as_ref().to_owned())
+        .collect::<Vec<_>>();
+    stmts_and_call.push(call_snippet_with_replacements);
+    stmts_and_call = stmts_and_call
+        .into_iter()
+        .map(|v| reindent_multiline(v.into(), true, Some(call_expr_indent)).into_owned())
+        .collect();
+
+    let mut stmts_and_call_snippet = stmts_and_call.join(&format!("{}{}", ";\n", " ".repeat(call_expr_indent)));
+    // expr is not in a block statement or result expression position, wrap in a block
+    let parent_node = cx.tcx.hir().find(cx.tcx.hir().get_parent_node(call_expr.hir_id));
+    if !matches!(parent_node, Some(Node::Block(_))) && !matches!(parent_node, Some(Node::Stmt(_))) {
+        let block_indent = call_expr_indent + 4;
+        stmts_and_call_snippet =
+            reindent_multiline(stmts_and_call_snippet.into(), true, Some(block_indent)).into_owned();
+        stmts_and_call_snippet = format!(
+            "{{\n{}{}\n{}}}",
+            " ".repeat(block_indent),
+            &stmts_and_call_snippet,
+            " ".repeat(call_expr_indent)
+        );
+    }
+    stmts_and_call_snippet
+}
+
 fn lint_unit_args(cx: &LateContext<'_>, expr: &Expr<'_>, args_to_recover: &[&Expr<'_>]) {
     let mut applicability = Applicability::MachineApplicable;
     let (singular, plural) = if args_to_recover.len() > 1 {
@@ -857,37 +895,15 @@ fn lint_unit_args(cx: &LateContext<'_>, expr: &Expr<'_>, args_to_recover: &[&Exp
                 .filter(|arg| !is_empty_block(arg))
                 .filter_map(|arg| snippet_opt(cx, arg.span))
                 .collect();
-            let indent = indent_of(cx, expr.span).unwrap_or(0);
-
-            if let Some(expr_str) = snippet_opt(cx, expr.span) {
-                let expr_with_replacements = arg_snippets
-                    .iter()
-                    .fold(expr_str, |acc, arg| acc.replacen(arg, "()", 1));
-
-                // expr is not in a block statement or result expression position, wrap in a block
-                let parent_node = cx.tcx.hir().find(cx.tcx.hir().get_parent_node(expr.hir_id));
-                let wrap_in_block =
-                    !matches!(parent_node, Some(Node::Block(_))) && !matches!(parent_node, Some(Node::Stmt(_)));
-
-                let stmts_indent = if wrap_in_block { indent + 4 } else { indent };
-                let mut stmts_and_call = arg_snippets_without_empty_blocks.clone();
-                stmts_and_call.push(expr_with_replacements);
-                let mut stmts_and_call_str = stmts_and_call
-                    .into_iter()
-                    .enumerate()
-                    .map(|(i, v)| {
-                        let with_indent_prefix = if i > 0 { " ".repeat(stmts_indent) + &v } else { v };
-                        trim_multiline(with_indent_prefix.into(), true, Some(stmts_indent)).into_owned()
-                    })
-                    .collect::<Vec<String>>()
-                    .join(";\n");
-
-                if wrap_in_block {
-                    stmts_and_call_str = " ".repeat(stmts_indent) + &stmts_and_call_str;
-                    stmts_and_call_str = format!("{{\n{}\n{}}}", &stmts_and_call_str, " ".repeat(indent));
-                }
 
-                let sugg = stmts_and_call_str;
+            if let Some(call_snippet) = snippet_opt(cx, expr.span) {
+                let sugg = fmt_stmts_and_call(
+                    cx,
+                    expr,
+                    &call_snippet,
+                    &arg_snippets,
+                    &arg_snippets_without_empty_blocks,
+                );
 
                 if arg_snippets_without_empty_blocks.is_empty() {
                     db.multipart_suggestion(
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index 4ce4cdeefb4..f394b980127 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -19,6 +19,7 @@ pub mod paths;
 pub mod ptr;
 pub mod sugg;
 pub mod usage;
+
 pub use self::attrs::*;
 pub use self::diagnostics::*;
 pub use self::hir_utils::{both, eq_expr_value, over, SpanlessEq, SpanlessHash};
@@ -108,6 +109,7 @@ pub fn in_macro(span: Span) -> bool {
         false
     }
 }
+
 // If the snippet is empty, it's an attribute that was inserted during macro
 // expansion and we want to ignore those, because they could come from external
 // sources that the user has no control over.
@@ -571,7 +573,7 @@ pub fn snippet_block<'a, T: LintContext>(
 ) -> Cow<'a, str> {
     let snip = snippet(cx, span, default);
     let indent = indent_relative_to.and_then(|s| indent_of(cx, s));
-    trim_multiline(snip, true, indent)
+    reindent_multiline(snip, true, indent)
 }
 
 /// Same as `snippet_block`, but adapts the applicability level by the rules of
@@ -585,7 +587,7 @@ pub fn snippet_block_with_applicability<'a, T: LintContext>(
 ) -> Cow<'a, str> {
     let snip = snippet_with_applicability(cx, span, default, applicability);
     let indent = indent_relative_to.and_then(|s| indent_of(cx, s));
-    trim_multiline(snip, true, indent)
+    reindent_multiline(snip, true, indent)
 }
 
 /// Returns a new Span that extends the original Span to the first non-whitespace char of the first
@@ -661,16 +663,16 @@ pub fn expr_block<'a, T: LintContext>(
     }
 }
 
-/// Trim indentation from a multiline string with possibility of ignoring the
-/// first line.
-pub fn trim_multiline(s: Cow<'_, str>, ignore_first: bool, indent: Option<usize>) -> Cow<'_, str> {
-    let s_space = trim_multiline_inner(s, ignore_first, indent, ' ');
-    let s_tab = trim_multiline_inner(s_space, ignore_first, indent, '\t');
-    trim_multiline_inner(s_tab, ignore_first, indent, ' ')
+/// Reindent a multiline string with possibility of ignoring the first line.
+#[allow(clippy::needless_pass_by_value)]
+pub fn reindent_multiline(s: Cow<'_, str>, ignore_first: bool, indent: Option<usize>) -> Cow<'_, str> {
+    let s_space = reindent_multiline_inner(&s, ignore_first, indent, ' ');
+    let s_tab = reindent_multiline_inner(&s_space, ignore_first, indent, '\t');
+    reindent_multiline_inner(&s_tab, ignore_first, indent, ' ').into()
 }
 
-fn trim_multiline_inner(s: Cow<'_, str>, ignore_first: bool, indent: Option<usize>, ch: char) -> Cow<'_, str> {
-    let mut x = s
+fn reindent_multiline_inner(s: &str, ignore_first: bool, indent: Option<usize>, ch: char) -> String {
+    let x = s
         .lines()
         .skip(ignore_first as usize)
         .filter_map(|l| {
@@ -683,26 +685,20 @@ fn trim_multiline_inner(s: Cow<'_, str>, ignore_first: bool, indent: Option<usiz
         })
         .min()
         .unwrap_or(0);
-    if let Some(indent) = indent {
-        x = x.saturating_sub(indent);
-    }
-    if x > 0 {
-        Cow::Owned(
-            s.lines()
-                .enumerate()
-                .map(|(i, l)| {
-                    if (ignore_first && i == 0) || l.is_empty() {
-                        l
-                    } else {
-                        l.split_at(x).1
-                    }
-                })
-                .collect::<Vec<_>>()
-                .join("\n"),
-        )
-    } else {
-        s
-    }
+    let indent = indent.unwrap_or(0);
+    s.lines()
+        .enumerate()
+        .map(|(i, l)| {
+            if (ignore_first && i == 0) || l.is_empty() {
+                l.to_owned()
+            } else if x > indent {
+                l.split_at(x - indent).1.to_owned()
+            } else {
+                " ".repeat(indent - x) + l
+            }
+        })
+        .collect::<Vec<String>>()
+        .join("\n")
 }
 
 /// Gets the parent expression, if any –- this is useful to constrain a lint.
@@ -1475,26 +1471,26 @@ macro_rules! unwrap_cargo_metadata {
 
 #[cfg(test)]
 mod test {
-    use super::{trim_multiline, without_block_comments};
+    use super::{reindent_multiline, without_block_comments};
 
     #[test]
-    fn test_trim_multiline_single_line() {
-        assert_eq!("", trim_multiline("".into(), false, None));
-        assert_eq!("...", trim_multiline("...".into(), false, None));
-        assert_eq!("...", trim_multiline("    ...".into(), false, None));
-        assert_eq!("...", trim_multiline("\t...".into(), false, None));
-        assert_eq!("...", trim_multiline("\t\t...".into(), false, None));
+    fn test_reindent_multiline_single_line() {
+        assert_eq!("", reindent_multiline("".into(), false, None));
+        assert_eq!("...", reindent_multiline("...".into(), false, None));
+        assert_eq!("...", reindent_multiline("    ...".into(), false, None));
+        assert_eq!("...", reindent_multiline("\t...".into(), false, None));
+        assert_eq!("...", reindent_multiline("\t\t...".into(), false, None));
     }
 
     #[test]
     #[rustfmt::skip]
-    fn test_trim_multiline_block() {
+    fn test_reindent_multiline_block() {
         assert_eq!("\
     if x {
         y
     } else {
         z
-    }", trim_multiline("    if x {
+    }", reindent_multiline("    if x {
             y
         } else {
             z
@@ -1504,7 +1500,7 @@ mod test {
     \ty
     } else {
     \tz
-    }", trim_multiline("    if x {
+    }", reindent_multiline("    if x {
         \ty
         } else {
         \tz
@@ -1513,14 +1509,14 @@ mod test {
 
     #[test]
     #[rustfmt::skip]
-    fn test_trim_multiline_empty_line() {
+    fn test_reindent_multiline_empty_line() {
         assert_eq!("\
     if x {
         y
 
     } else {
         z
-    }", trim_multiline("    if x {
+    }", reindent_multiline("    if x {
             y
 
         } else {
@@ -1528,6 +1524,22 @@ mod test {
         }".into(), false, None));
     }
 
+    #[test]
+    #[rustfmt::skip]
+    fn test_reindent_multiline_lines_deeper() {
+        assert_eq!("\
+        if x {
+            y
+        } else {
+            z
+        }", reindent_multiline("\
+    if x {
+        y
+    } else {
+        z
+    }".into(), true, Some(8)));
+    }
+
     #[test]
     fn test_without_block_comments_lines_without_block_comments() {
         let result = without_block_comments(vec!["/*", "", "*/"]);
-- 
cgit 1.4.1-3-g733a5


From 2387f68e437bf2ff5f117f63936257ce64052cfa Mon Sep 17 00:00:00 2001
From: Ricky <Ricky@Hosfelt.io>
Date: Wed, 2 Sep 2020 19:21:34 -0400
Subject: Removed map_err suggestion in lint, and updated lint documentation
 example

---
 clippy_lints/src/map_err_ignore.rs | 117 ++++++++++++++++++-------------------
 tests/ui/map_err.stderr            |   5 +-
 2 files changed, 60 insertions(+), 62 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/map_err_ignore.rs b/clippy_lints/src/map_err_ignore.rs
index 43bfcf0b8f1..9211113ed04 100644
--- a/clippy_lints/src/map_err_ignore.rs
+++ b/clippy_lints/src/map_err_ignore.rs
@@ -1,6 +1,6 @@
-use crate::utils::span_lint_and_sugg;
-use rustc_errors::Applicability;
-use rustc_hir::{CaptureBy, Expr, ExprKind, PatKind, QPath};
+use crate::utils::span_lint_and_help;
+
+use rustc_hir::{CaptureBy, Expr, ExprKind, PatKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
@@ -12,33 +12,58 @@ declare_clippy_lint! {
     /// **Known problems:** None.
     ///
     /// **Example:**
-    ///
+    /// Before:
     /// ```rust
+    /// use std::convert::TryFrom;
+    ///
+    /// #[derive(Debug)]
     /// enum Errors {
-    ///    Ignore
-    ///}
-    ///fn main() -> Result<(), Errors> {
+    ///     Ignored
+    /// }
     ///
-    ///    let x = u32::try_from(-123_i32);
+    /// fn divisible_by_3(inp: i32) -> Result<u32, Errors> {
+    ///     let i = u32::try_from(inp).map_err(|_| Errors::Ignored)?;
     ///
-    ///    println!("{:?}", x.map_err(|_| Errors::Ignore));
+    ///     Ok(i)
+    /// }
+    ///  ```
     ///
-    ///    Ok(())
-    ///}
-    /// ```
-    /// Use instead:
-    /// ```rust
-    /// enum Errors {
-    ///    WithContext(TryFromIntError)
-    ///}
-    ///fn main() -> Result<(), Errors> {
+    ///  After:
+    ///  ```rust
+    /// use std::convert::TryFrom;
+    /// use std::num::TryFromIntError;
+    /// use std::fmt;
+    /// use std::error::Error;
+    ///
+    /// #[derive(Debug)]
+    /// enum ParseError {
+    ///     Indivisible {
+    ///         source: TryFromIntError,
+    ///         input: String,
+    ///     }
+    /// }
+    ///
+    /// impl fmt::Display for ParseError {
+    ///     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    ///         match &self {
+    ///             ParseError::Indivisible{source: _, input} => write!(f, "Error: {}", input)
+    ///         }
+    ///     }
+    /// }
+    ///
+    /// impl Error for ParseError {}
     ///
-    ///    let x = u32::try_from(-123_i32);
+    /// impl ParseError {
+    ///     fn new(source: TryFromIntError, input: String) -> ParseError {
+    ///         ParseError::Indivisible{source, input}
+    ///     }
+    /// }
     ///
-    ///    println!("{:?}", x.map_err(|e| Errors::WithContext(e)));
+    /// fn divisible_by_3(inp: i32) -> Result<u32, ParseError> {
+    ///     let i = u32::try_from(inp).map_err(|e| ParseError::new(e, e.to_string()))?;
     ///
-    ///    Ok(())
-    ///}
+    ///     Ok(i)
+    /// }
     /// ```
     pub MAP_ERR_IGNORE,
     style,
@@ -69,44 +94,16 @@ impl<'tcx> LateLintPass<'tcx> for MapErrIgnore {
                         if closure_body.params.len() == 1 {
                             // make sure that parameter is the wild token (`_`)
                             if let PatKind::Wild = closure_body.params[0].pat.kind {
-                                // Check the value of the closure to see if we can build the enum we are throwing away
-                                // the error for make sure this is a Path
-                                if let ExprKind::Path(q_path) = &closure_body.value.kind {
-                                    // this should be a resolved path, only keep the path field
-                                    if let QPath::Resolved(_, path) = q_path {
-                                        // finally get the idents for each path segment collect them as a string and
-                                        // join them with the path separator ("::"")
-                                        let closure_fold: String = path
-                                            .segments
-                                            .iter()
-                                            .map(|x| x.ident.as_str().to_string())
-                                            .collect::<Vec<String>>()
-                                            .join("::");
-                                        //Span the body of the closure (the |...| bit) and suggest the fix by taking
-                                        // the error and encapsulating it in the enum
-                                        span_lint_and_sugg(
-                                            cx,
-                                            MAP_ERR_IGNORE,
-                                            body_span,
-                                            "`map_err` has thrown away the original error",
-                                            "Allow the error enum to encapsulate the original error",
-                                            format!("|e| {}(e)", closure_fold),
-                                            Applicability::HasPlaceholders,
-                                        );
-                                    }
-                                } else {
-                                    //If we cannot build the enum in a human readable way just suggest not throwing way
-                                    // the error
-                                    span_lint_and_sugg(
-                                        cx,
-                                        MAP_ERR_IGNORE,
-                                        body_span,
-                                        "`map_err` has thrown away the original error",
-                                        "Allow the error enum to encapsulate the original error",
-                                        "|e|".to_string(),
-                                        Applicability::HasPlaceholders,
-                                    );
-                                }
+                                // span the area of the closure capture and warn that the
+                                // original error will be thrown away
+                                span_lint_and_help(
+                                    cx,
+                                    MAP_ERR_IGNORE,
+                                    body_span,
+                                    "`map_else(|_|...` ignores the original error",
+                                    None,
+                                    "Consider wrapping the error in an enum variant",
+                                );
                             }
                         }
                     }
diff --git a/tests/ui/map_err.stderr b/tests/ui/map_err.stderr
index 8cd37d8c025..7a269ab95ab 100644
--- a/tests/ui/map_err.stderr
+++ b/tests/ui/map_err.stderr
@@ -1,10 +1,11 @@
-error: `map_err` has thrown away the original error
+error: `map_else(|_|...` ignores the original error
   --> $DIR/map_err.rs:21:32
    |
 LL |     println!("{:?}", x.map_err(|_| Errors::Ignored));
-   |                                ^^^ help: Allow the error enum to encapsulate the original error: `|e| Errors::Ignored(e)`
+   |                                ^^^
    |
    = note: `-D clippy::map-err-ignore` implied by `-D warnings`
+   = help: Consider wrapping the error in an enum variant
 
 error: aborting due to previous error
 
-- 
cgit 1.4.1-3-g733a5


From cf1cc7c449e881f0ac5d8474209222bc269df250 Mon Sep 17 00:00:00 2001
From: Michael Wright <mikerite@lavabit.com>
Date: Fri, 4 Sep 2020 05:15:31 +0200
Subject: Simplify `clippy::default_trait_access`

Remove repeated matching on the same QPath.
---
 clippy_lints/src/default_trait_access.rs | 46 +++++++++++---------------------
 1 file changed, 16 insertions(+), 30 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/default_trait_access.rs b/clippy_lints/src/default_trait_access.rs
index 0b0a1307876..320a2a257bd 100644
--- a/clippy_lints/src/default_trait_access.rs
+++ b/clippy_lints/src/default_trait_access.rs
@@ -38,37 +38,23 @@ impl<'tcx> LateLintPass<'tcx> for DefaultTraitAccess {
             if let ExprKind::Path(ref qpath) = path.kind;
             if let Some(def_id) = cx.qpath_res(qpath, path.hir_id).opt_def_id();
             if match_def_path(cx, def_id, &paths::DEFAULT_TRAIT_METHOD);
+            // Detect and ignore <Foo as Default>::default() because these calls do explicitly name the type.
+            if let QPath::Resolved(None, _path) = qpath;
             then {
-                match qpath {
-                    QPath::Resolved(..) => {
-                        if_chain! {
-                            // Detect and ignore <Foo as Default>::default() because these calls do
-                            // explicitly name the type.
-                            if let ExprKind::Call(ref method, ref _args) = expr.kind;
-                            if let ExprKind::Path(ref p) = method.kind;
-                            if let QPath::Resolved(Some(_ty), _path) = p;
-                            then {
-                                return;
-                            }
-                        }
-
-                        // TODO: Work out a way to put "whatever the imported way of referencing
-                        // this type in this file" rather than a fully-qualified type.
-                        let expr_ty = cx.typeck_results().expr_ty(expr);
-                        if let ty::Adt(def, ..) = expr_ty.kind {
-                            let replacement = format!("{}::default()", cx.tcx.def_path_str(def.did));
-                            span_lint_and_sugg(
-                                cx,
-                                DEFAULT_TRAIT_ACCESS,
-                                expr.span,
-                                &format!("calling `{}` is more clear than this expression", replacement),
-                                "try",
-                                replacement,
-                                Applicability::Unspecified, // First resolve the TODO above
-                            );
-                         }
-                    },
-                    QPath::TypeRelative(..) | QPath::LangItem(..) => {},
+                let expr_ty = cx.typeck_results().expr_ty(expr);
+                if let ty::Adt(def, ..) = expr_ty.kind {
+                    // TODO: Work out a way to put "whatever the imported way of referencing
+                    // this type in this file" rather than a fully-qualified type.
+                    let replacement = format!("{}::default()", cx.tcx.def_path_str(def.did));
+                    span_lint_and_sugg(
+                        cx,
+                        DEFAULT_TRAIT_ACCESS,
+                        expr.span,
+                        &format!("calling `{}` is more clear than this expression", replacement),
+                        "try",
+                        replacement,
+                        Applicability::Unspecified, // First resolve the TODO above
+                    );
                 }
             }
         }
-- 
cgit 1.4.1-3-g733a5


From 7bcf40a13d90952d9a59ed547832155439e3bcf7 Mon Sep 17 00:00:00 2001
From: Eduardo Broto <ebroto@tutanota.com>
Date: Fri, 4 Sep 2020 23:30:06 +0200
Subject: Fix fallout from rustup

---
 clippy_lints/src/default_trait_access.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/default_trait_access.rs b/clippy_lints/src/default_trait_access.rs
index 320a2a257bd..3048436d9a7 100644
--- a/clippy_lints/src/default_trait_access.rs
+++ b/clippy_lints/src/default_trait_access.rs
@@ -42,7 +42,7 @@ impl<'tcx> LateLintPass<'tcx> for DefaultTraitAccess {
             if let QPath::Resolved(None, _path) = qpath;
             then {
                 let expr_ty = cx.typeck_results().expr_ty(expr);
-                if let ty::Adt(def, ..) = expr_ty.kind {
+                if let ty::Adt(def, ..) = expr_ty.kind() {
                     // TODO: Work out a way to put "whatever the imported way of referencing
                     // this type in this file" rather than a fully-qualified type.
                     let replacement = format!("{}::default()", cx.tcx.def_path_str(def.did));
-- 
cgit 1.4.1-3-g733a5


From 2905fff93659d17f1c6b1cf270b5731e04ebe46d Mon Sep 17 00:00:00 2001
From: Eduardo Broto <ebroto@tutanota.com>
Date: Fri, 4 Sep 2020 23:30:55 +0200
Subject: Run cargo dev fmt

---
 clippy_lints/src/utils/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index 96e9d0f32f8..bea0a4d2459 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -1432,7 +1432,7 @@ pub fn is_slice_of_primitives(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<S
             } else {
                 unreachable!()
             }
-        }
+        },
         _ => false,
     };
 
-- 
cgit 1.4.1-3-g733a5


From c31d4730b0d40c62934839405d0c25e2ffa3fad1 Mon Sep 17 00:00:00 2001
From: Jane Lusby <jlusby@yaah.dev>
Date: Fri, 4 Sep 2020 15:55:13 -0700
Subject: update example to be more idiomatic

---
 clippy_lints/src/map_err_ignore.rs | 87 ++++++++++++++++++++++++++------------
 1 file changed, 60 insertions(+), 27 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/map_err_ignore.rs b/clippy_lints/src/map_err_ignore.rs
index 9211113ed04..649de4133e0 100644
--- a/clippy_lints/src/map_err_ignore.rs
+++ b/clippy_lints/src/map_err_ignore.rs
@@ -14,55 +14,88 @@ declare_clippy_lint! {
     /// **Example:**
     /// Before:
     /// ```rust
-    /// use std::convert::TryFrom;
+    /// use std::fmt;
     ///
     /// #[derive(Debug)]
-    /// enum Errors {
-    ///     Ignored
+    /// enum Error {
+    ///     Indivisible,
+    ///     Remainder(u8),
+    /// }
+    ///
+    /// impl fmt::Display for Error {
+    ///     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    ///         match self {
+    ///             Error::Indivisible => write!(f, "could not divide input by three"),
+    ///             Error::Remainder(remainder) => write!(
+    ///                 f,
+    ///                 "input is not divisible by three, remainder = {}",
+    ///                 remainder
+    ///             ),
+    ///         }
+    ///     }
     /// }
     ///
-    /// fn divisible_by_3(inp: i32) -> Result<u32, Errors> {
-    ///     let i = u32::try_from(inp).map_err(|_| Errors::Ignored)?;
+    /// impl std::error::Error for Error {}
     ///
-    ///     Ok(i)
+    /// fn divisible_by_3(input: &str) -> Result<(), Error> {
+    ///     input
+    ///         .parse::<i32>()
+    ///         .map_err(|_| Error::Indivisible)
+    ///         .map(|v| v % 3)
+    ///         .and_then(|remainder| {
+    ///             if remainder == 0 {
+    ///                 Ok(())
+    ///             } else {
+    ///                 Err(Error::Remainder(remainder as u8))
+    ///             }
+    ///         })
     /// }
     ///  ```
     ///
     ///  After:
     ///  ```rust
-    /// use std::convert::TryFrom;
-    /// use std::num::TryFromIntError;
-    /// use std::fmt;
-    /// use std::error::Error;
+    /// use std::{fmt, num::ParseIntError};
     ///
     /// #[derive(Debug)]
-    /// enum ParseError {
-    ///     Indivisible {
-    ///         source: TryFromIntError,
-    ///         input: String,
-    ///     }
+    /// enum Error {
+    ///     Indivisible(ParseIntError),
+    ///     Remainder(u8),
     /// }
     ///
-    /// impl fmt::Display for ParseError {
+    /// impl fmt::Display for Error {
     ///     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-    ///         match &self {
-    ///             ParseError::Indivisible{source: _, input} => write!(f, "Error: {}", input)
+    ///         match self {
+    ///             Error::Indivisible(_) => write!(f, "could not divide input by three"),
+    ///             Error::Remainder(remainder) => write!(
+    ///                 f,
+    ///                 "input is not divisible by three, remainder = {}",
+    ///                 remainder
+    ///             ),
     ///         }
     ///     }
     /// }
     ///
-    /// impl Error for ParseError {}
-    ///
-    /// impl ParseError {
-    ///     fn new(source: TryFromIntError, input: String) -> ParseError {
-    ///         ParseError::Indivisible{source, input}
+    /// impl std::error::Error for Error {
+    ///     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+    ///         match self {
+    ///             Error::Indivisible(source) => Some(source),
+    ///             _ => None,
+    ///         }
     ///     }
     /// }
     ///
-    /// fn divisible_by_3(inp: i32) -> Result<u32, ParseError> {
-    ///     let i = u32::try_from(inp).map_err(|e| ParseError::new(e, e.to_string()))?;
-    ///
-    ///     Ok(i)
+    /// fn divisible_by_3(input: &str) -> Result<(), Error> {
+    ///     input
+    ///         .parse::<i32>()
+    ///         .map_err(Error::Indivisible)
+    ///         .map(|v| v % 3)
+    ///         .and_then(|remainder| {
+    ///             if remainder == 0 {
+    ///                 Ok(())
+    ///             } else {
+    ///                 Err(Error::Remainder(remainder as u8))
+    ///             }
+    ///         })
     /// }
     /// ```
     pub MAP_ERR_IGNORE,
-- 
cgit 1.4.1-3-g733a5


From 04ba07bdc3c82aa17297e3e91fdc884983be7cad Mon Sep 17 00:00:00 2001
From: Ryan1729 <Ryan1729@gmail.com>
Date: Fri, 4 Sep 2020 19:26:35 -0600
Subject: add line_count and max_lines to too_many_lines lint message

---
 clippy_lints/src/functions.rs | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/functions.rs b/clippy_lints/src/functions.rs
index 89fde1d509d..50b39cf4ea7 100644
--- a/clippy_lints/src/functions.rs
+++ b/clippy_lints/src/functions.rs
@@ -374,7 +374,12 @@ impl<'tcx> Functions {
         }
 
         if line_count > self.max_lines {
-            span_lint(cx, TOO_MANY_LINES, span, "this function has a large number of lines")
+            span_lint(
+                cx,
+                TOO_MANY_LINES,
+                span,
+                &format!("this function has too many lines ({}/{})", line_count, self.max_lines),
+            )
         }
     }
 
-- 
cgit 1.4.1-3-g733a5


From 96b31a5b36ed06b6781804d3384a3a84a52b8ce6 Mon Sep 17 00:00:00 2001
From: Takayuki Nakata <f.seasons017@gmail.com>
Date: Sun, 6 Sep 2020 00:02:35 +0900
Subject: Fix FP when coercion kicks in

---
 clippy_lints/src/loops.rs  |  3 ++-
 tests/ui/same_item_push.rs | 11 +++++++++++
 2 files changed, 13 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 25345f8fa31..b65ae15edcd 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -1140,7 +1140,8 @@ fn detect_same_item_push<'tcx>(
     walk_expr(&mut same_item_push_visitor, body);
     if same_item_push_visitor.should_lint {
         if let Some((vec, pushed_item)) = same_item_push_visitor.vec_push {
-            let ty = cx.typeck_results().expr_ty(pushed_item);
+            let vec_ty = cx.typeck_results().expr_ty(vec);
+            let ty = vec_ty.walk().nth(1).unwrap().expect_ty();
             if cx
                 .tcx
                 .lang_items()
diff --git a/tests/ui/same_item_push.rs b/tests/ui/same_item_push.rs
index 0903a873826..0928820892b 100644
--- a/tests/ui/same_item_push.rs
+++ b/tests/ui/same_item_push.rs
@@ -100,4 +100,15 @@ fn main() {
     for _ in 0..10 {
         vec14.push(std::fs::File::open("foobar").unwrap());
     }
+    // Fix #5979
+    #[derive(Clone)]
+    struct S {}
+
+    trait T {}
+    impl T for S {}
+
+    let mut vec15: Vec<Box<dyn T>> = Vec::new();
+    for _ in 0..10 {
+        vec15.push(Box::new(S {}));
+    }
 }
-- 
cgit 1.4.1-3-g733a5


From 390a13b06c79d4177b829097b06453e38188081f Mon Sep 17 00:00:00 2001
From: Tim Nielens <tim.nielens@gmail.com>
Date: Thu, 27 Aug 2020 23:22:32 +0200
Subject: needless-lifetime - fix nested elision site FPs

---
 clippy_lints/src/lifetimes.rs      | 69 +++++++++++++++++++++++++++++++++++---
 clippy_lints/src/utils/paths.rs    |  3 ++
 tests/ui/needless_lifetimes.rs     | 32 ++++++++++++++++++
 tests/ui/needless_lifetimes.stderr |  8 +----
 4 files changed, 101 insertions(+), 11 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lifetimes.rs b/clippy_lints/src/lifetimes.rs
index 4df6827d77f..ab6e34d201c 100644
--- a/clippy_lints/src/lifetimes.rs
+++ b/clippy_lints/src/lifetimes.rs
@@ -1,13 +1,14 @@
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::intravisit::{
-    walk_fn_decl, walk_generic_param, walk_generics, walk_param_bound, walk_ty, NestedVisitorMap, Visitor,
+    walk_fn_decl, walk_generic_param, walk_generics, walk_param_bound, walk_trait_ref, walk_ty, NestedVisitorMap,
+    Visitor,
 };
 use rustc_hir::FnRetTy::Return;
 use rustc_hir::{
     BodyId, FnDecl, GenericArg, GenericBound, GenericParam, GenericParamKind, Generics, ImplItem, ImplItemKind, Item,
-    ItemKind, Lifetime, LifetimeName, ParamName, QPath, TraitBoundModifier, TraitFn, TraitItem, TraitItemKind, Ty,
-    TyKind, WhereClause, WherePredicate,
+    ItemKind, Lifetime, LifetimeName, ParamName, QPath, TraitBoundModifier, TraitFn, TraitItem, TraitItemKind,
+    TraitRef, Ty, TyKind, WhereClause, WherePredicate,
 };
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::map::Map;
@@ -15,7 +16,8 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
 use rustc_span::symbol::{kw, Symbol};
 
-use crate::utils::{in_macro, last_path_segment, span_lint, trait_ref_of_method};
+use crate::utils::paths;
+use crate::utils::{get_trait_def_id, in_macro, last_path_segment, span_lint, trait_ref_of_method};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for lifetime annotations which can be removed by
@@ -127,6 +129,14 @@ fn check_fn_inner<'tcx>(
         return;
     }
 
+    // fn pointers and closure trait bounds are also lifetime elision sites. This lint does not
+    // support nested elision sites in a fn item.
+    if FnPointerOrClosureTraitBoundFinder::find_in_generics(cx, generics)
+        || FnPointerOrClosureTraitBoundFinder::find_in_fn_decl(cx, decl)
+    {
+        return;
+    }
+
     let mut bounds_lts = Vec::new();
     let types = generics
         .params
@@ -523,3 +533,54 @@ impl<'tcx> Visitor<'tcx> for BodyLifetimeChecker {
         NestedVisitorMap::None
     }
 }
+
+const CLOSURE_TRAIT_BOUNDS: [&[&str]; 3] = [&paths::FN, &paths::FN_MUT, &paths::FN_ONCE];
+
+struct FnPointerOrClosureTraitBoundFinder<'a, 'tcx> {
+    cx: &'a LateContext<'tcx>,
+    found: bool,
+}
+
+impl<'a, 'tcx> FnPointerOrClosureTraitBoundFinder<'a, 'tcx> {
+    fn find_in_generics(cx: &'a LateContext<'tcx>, generics: &'tcx Generics<'tcx>) -> bool {
+        let mut finder = Self { cx, found: false };
+        finder.visit_generics(generics);
+        finder.found
+    }
+
+    fn find_in_fn_decl(cx: &'a LateContext<'tcx>, generics: &'tcx FnDecl<'tcx>) -> bool {
+        let mut finder = Self { cx, found: false };
+        finder.visit_fn_decl(generics);
+        finder.found
+    }
+}
+
+impl<'a, 'tcx> Visitor<'tcx> for FnPointerOrClosureTraitBoundFinder<'a, 'tcx> {
+    type Map = Map<'tcx>;
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::None
+    }
+
+    fn visit_trait_ref(&mut self, tref: &'tcx TraitRef<'tcx>) {
+        if CLOSURE_TRAIT_BOUNDS
+            .iter()
+            .any(|trait_path| tref.trait_def_id() == get_trait_def_id(self.cx, trait_path))
+        {
+            self.found = true;
+        }
+        walk_trait_ref(self, tref);
+    }
+
+    fn visit_ty(&mut self, ty: &'tcx Ty<'tcx>) {
+        match ty.kind {
+            TyKind::BareFn(..) => self.found = true,
+            TyKind::OpaqueDef(item_id, _) => {
+                let map = self.cx.tcx.hir();
+                let item = map.expect_item(item_id.id);
+                self.visit_item(item);
+            },
+            _ => (),
+        }
+        walk_ty(self, ty);
+    }
+}
diff --git a/clippy_lints/src/utils/paths.rs b/clippy_lints/src/utils/paths.rs
index d44854aefe9..9837759fd5e 100644
--- a/clippy_lints/src/utils/paths.rs
+++ b/clippy_lints/src/utils/paths.rs
@@ -42,6 +42,9 @@ pub const FILE_TYPE: [&str; 3] = ["std", "fs", "FileType"];
 pub const FMT_ARGUMENTS_NEW_V1: [&str; 4] = ["core", "fmt", "Arguments", "new_v1"];
 pub const FMT_ARGUMENTS_NEW_V1_FORMATTED: [&str; 4] = ["core", "fmt", "Arguments", "new_v1_formatted"];
 pub const FMT_ARGUMENTV1_NEW: [&str; 4] = ["core", "fmt", "ArgumentV1", "new"];
+pub const FN: [&str; 3] = ["core", "ops", "Fn"];
+pub const FN_MUT: [&str; 3] = ["core", "ops", "FnMut"];
+pub const FN_ONCE: [&str; 3] = ["core", "ops", "FnOnce"];
 pub const FROM_FROM: [&str; 4] = ["core", "convert", "From", "from"];
 pub const FROM_TRAIT: [&str; 3] = ["core", "convert", "From"];
 pub const FUTURE_FROM_GENERATOR: [&str; 3] = ["core", "future", "from_generator"];
diff --git a/tests/ui/needless_lifetimes.rs b/tests/ui/needless_lifetimes.rs
index 913cd004f19..bc725a645ac 100644
--- a/tests/ui/needless_lifetimes.rs
+++ b/tests/ui/needless_lifetimes.rs
@@ -259,4 +259,36 @@ mod issue4291 {
     }
 }
 
+mod nested_elision_sites {
+    // Don't lint these cases, they cause FPs.
+    // The lint does not support nested elision sites.
+
+    fn nested_fn_trait_bound<'a>(i: &'a i32) -> impl Fn() -> &'a i32 {
+        move || i
+    }
+
+    fn nested_fn_mut_trait_bound<'a>(i: &'a i32) -> impl FnMut() -> &'a i32 {
+        move || i
+    }
+
+    fn nested_fn_once_trait_bound<'a>(i: &'a i32) -> impl FnOnce() -> &'a i32 {
+        move || i
+    }
+
+    fn nested_generic_fn_trait_bound<'a, T: Fn() -> &'a i32>(f: T) -> &'a i32 {
+        f()
+    }
+
+    fn nested_where_clause_fn_trait_bound<'a, T>(f: T) -> &'a i32
+    where
+        T: Fn() -> &'a i32,
+    {
+        f()
+    }
+
+    fn nested_pointer_fn<'a>(_: &'a i32) -> fn(&'a i32) -> &'a i32 {
+        |i| i
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/needless_lifetimes.stderr b/tests/ui/needless_lifetimes.stderr
index d3a360ed8b5..b1943bf9d70 100644
--- a/tests/ui/needless_lifetimes.stderr
+++ b/tests/ui/needless_lifetimes.stderr
@@ -36,12 +36,6 @@ error: explicit lifetimes given in parameter types where they could be elided (o
 LL | fn lifetime_param_2<'a, 'b>(_x: Ref<'a>, _y: &'b u8) {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
-  --> $DIR/needless_lifetimes.rs:86:1
-   |
-LL | fn fn_bound_2<'a, F, I>(_m: Lt<'a, I>, _f: F) -> Lt<'a, I>
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
 error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
   --> $DIR/needless_lifetimes.rs:120:5
    |
@@ -102,5 +96,5 @@ error: explicit lifetimes given in parameter types where they could be elided (o
 LL |         fn needless_lt<'a>(_x: &'a u8) {}
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 17 previous errors
+error: aborting due to 16 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 9fa9208bd5c3725f98dd88f761956c01ce5fd527 Mon Sep 17 00:00:00 2001
From: Eduardo Broto <ebroto@tutanota.com>
Date: Fri, 4 Sep 2020 11:56:54 +0200
Subject: Restrict unnecessary_sort_by to non-ref copy types

---
 clippy_lints/src/unnecessary_sort_by.rs | 13 ++++++++--
 tests/ui/unnecessary_sort_by.fixed      | 42 +++++++++++++++++++++++++++++----
 tests/ui/unnecessary_sort_by.rs         | 42 +++++++++++++++++++++++++++++----
 3 files changed, 87 insertions(+), 10 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unnecessary_sort_by.rs b/clippy_lints/src/unnecessary_sort_by.rs
index 8b00d29acb5..9b6a9075a29 100644
--- a/clippy_lints/src/unnecessary_sort_by.rs
+++ b/clippy_lints/src/unnecessary_sort_by.rs
@@ -1,5 +1,4 @@
 use crate::utils;
-use crate::utils::paths;
 use crate::utils::sugg::Sugg;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
@@ -171,12 +170,22 @@ fn mirrored_exprs(
 }
 
 fn detect_lint(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<LintTrigger> {
+    // NOTE: Vectors of references are not supported. In order to avoid hitting https://github.com/rust-lang/rust/issues/34162,
+    // (different unnamed lifetimes for closure arg and return type) we need to make sure the suggested
+    // closure parameter is not a reference in case we suggest `Reverse`. Trying to destructure more
+    // than one level of references would add some extra complexity as we would have to compensate
+    // in the closure body.
+
     if_chain! {
         if let ExprKind::MethodCall(name_ident, _, args, _) = &expr.kind;
         if let name = name_ident.ident.name.to_ident_string();
         if name == "sort_by" || name == "sort_unstable_by";
         if let [vec, Expr { kind: ExprKind::Closure(_, _, closure_body_id, _, _), .. }] = args;
-        if utils::match_type(cx, &cx.typeck_results().expr_ty(vec), &paths::VEC);
+        let vec_ty = cx.typeck_results().expr_ty(vec);
+        if utils::is_type_diagnostic_item(cx, vec_ty, sym!(vec_type));
+        let ty = vec_ty.walk().nth(1).unwrap().expect_ty(); // T in Vec<T>
+        if !matches!(&ty.kind(), ty::Ref(..));
+        if utils::is_copy(cx, ty);
         if let closure_body = cx.tcx.hir().body(*closure_body_id);
         if let &[
             Param { pat: Pat { kind: PatKind::Binding(_, _, left_ident, _), .. }, ..},
diff --git a/tests/ui/unnecessary_sort_by.fixed b/tests/ui/unnecessary_sort_by.fixed
index 31c2ba0f9c5..ad0d0387db0 100644
--- a/tests/ui/unnecessary_sort_by.fixed
+++ b/tests/ui/unnecessary_sort_by.fixed
@@ -25,17 +25,25 @@ fn unnecessary_sort_by() {
     vec.sort_by(|_, b| b.cmp(&5));
     vec.sort_by(|_, b| b.cmp(c));
     vec.sort_unstable_by(|a, _| a.cmp(c));
+
+    // Ignore vectors of references
+    let mut vec: Vec<&&&isize> = vec![&&&3, &&&6, &&&1, &&&2, &&&5];
+    vec.sort_by(|a, b| (***a).abs().cmp(&(***b).abs()));
+    vec.sort_unstable_by(|a, b| (***a).abs().cmp(&(***b).abs()));
+    vec.sort_by(|a, b| b.cmp(a));
+    vec.sort_unstable_by(|a, b| b.cmp(a));
 }
 
-// Should not be linted to avoid hitting https://github.com/rust-lang/rust/issues/34162
+// Do not suggest returning a reference to the closure parameter of `Vec::sort_by_key`
 mod issue_5754 {
-    struct Test(String);
+    #[derive(Clone, Copy)]
+    struct Test(usize);
 
     #[derive(PartialOrd, Ord, PartialEq, Eq)]
-    struct Wrapper<'a>(&'a str);
+    struct Wrapper<'a>(&'a usize);
 
     impl Test {
-        fn name(&self) -> &str {
+        fn name(&self) -> &usize {
             &self.0
         }
 
@@ -60,7 +68,33 @@ mod issue_5754 {
     }
 }
 
+// `Vec::sort_by_key` closure parameter is `F: FnMut(&T) -> K`
+// The suggestion is destructuring T and we know T is not a reference, so test that non-Copy T are
+// not linted.
+mod issue_6001 {
+    struct Test(String);
+
+    impl Test {
+        // Return an owned type so that we don't hit the fix for 5754
+        fn name(&self) -> String {
+            self.0.clone()
+        }
+    }
+
+    pub fn test() {
+        let mut args: Vec<Test> = vec![];
+
+        // Forward
+        args.sort_by(|a, b| a.name().cmp(&b.name()));
+        args.sort_unstable_by(|a, b| a.name().cmp(&b.name()));
+        // Reverse
+        args.sort_by(|a, b| b.name().cmp(&a.name()));
+        args.sort_unstable_by(|a, b| b.name().cmp(&a.name()));
+    }
+}
+
 fn main() {
     unnecessary_sort_by();
     issue_5754::test();
+    issue_6001::test();
 }
diff --git a/tests/ui/unnecessary_sort_by.rs b/tests/ui/unnecessary_sort_by.rs
index a3c8ae468ed..9746f6e6849 100644
--- a/tests/ui/unnecessary_sort_by.rs
+++ b/tests/ui/unnecessary_sort_by.rs
@@ -25,17 +25,25 @@ fn unnecessary_sort_by() {
     vec.sort_by(|_, b| b.cmp(&5));
     vec.sort_by(|_, b| b.cmp(c));
     vec.sort_unstable_by(|a, _| a.cmp(c));
+
+    // Ignore vectors of references
+    let mut vec: Vec<&&&isize> = vec![&&&3, &&&6, &&&1, &&&2, &&&5];
+    vec.sort_by(|a, b| (***a).abs().cmp(&(***b).abs()));
+    vec.sort_unstable_by(|a, b| (***a).abs().cmp(&(***b).abs()));
+    vec.sort_by(|a, b| b.cmp(a));
+    vec.sort_unstable_by(|a, b| b.cmp(a));
 }
 
-// Should not be linted to avoid hitting https://github.com/rust-lang/rust/issues/34162
+// Do not suggest returning a reference to the closure parameter of `Vec::sort_by_key`
 mod issue_5754 {
-    struct Test(String);
+    #[derive(Clone, Copy)]
+    struct Test(usize);
 
     #[derive(PartialOrd, Ord, PartialEq, Eq)]
-    struct Wrapper<'a>(&'a str);
+    struct Wrapper<'a>(&'a usize);
 
     impl Test {
-        fn name(&self) -> &str {
+        fn name(&self) -> &usize {
             &self.0
         }
 
@@ -60,7 +68,33 @@ mod issue_5754 {
     }
 }
 
+// `Vec::sort_by_key` closure parameter is `F: FnMut(&T) -> K`
+// The suggestion is destructuring T and we know T is not a reference, so test that non-Copy T are
+// not linted.
+mod issue_6001 {
+    struct Test(String);
+
+    impl Test {
+        // Return an owned type so that we don't hit the fix for 5754
+        fn name(&self) -> String {
+            self.0.clone()
+        }
+    }
+
+    pub fn test() {
+        let mut args: Vec<Test> = vec![];
+
+        // Forward
+        args.sort_by(|a, b| a.name().cmp(&b.name()));
+        args.sort_unstable_by(|a, b| a.name().cmp(&b.name()));
+        // Reverse
+        args.sort_by(|a, b| b.name().cmp(&a.name()));
+        args.sort_unstable_by(|a, b| b.name().cmp(&a.name()));
+    }
+}
+
 fn main() {
     unnecessary_sort_by();
     issue_5754::test();
+    issue_6001::test();
 }
-- 
cgit 1.4.1-3-g733a5


From 3d30ef7818b9ed562f2c48f3d6d15d90253ae732 Mon Sep 17 00:00:00 2001
From: Takayuki Nakata <f.seasons017@gmail.com>
Date: Mon, 7 Sep 2020 22:17:31 +0900
Subject: Restrict `same_item_push` to suppress false positives

It emits a lint when the pushed item is a literal, a constant and an immutable binding that are initialized with those.
---
 clippy_lints/src/loops.rs      | 83 ++++++++++++++++++++++++++++++++----------
 tests/ui/same_item_push.rs     | 13 +++++++
 tests/ui/same_item_push.stderr | 34 ++++++++++-------
 3 files changed, 97 insertions(+), 33 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index f13e369907b..f417e3a0caf 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -1153,27 +1153,70 @@ fn detect_same_item_push<'tcx>(
                     let vec_str = snippet_with_macro_callsite(cx, vec.span, "");
                     let item_str = snippet_with_macro_callsite(cx, pushed_item.span, "");
                     if let ExprKind::Path(ref qpath) = pushed_item.kind {
-                        if_chain! {
-                            if let Res::Local(hir_id) = qpath_res(cx, qpath, pushed_item.hir_id);
-                            let node = cx.tcx.hir().get(hir_id);
-                            if let Node::Binding(pat) = node;
-                            if let PatKind::Binding(bind_ann, ..) = pat.kind;
-                            if !matches!(bind_ann, BindingAnnotation::RefMut | BindingAnnotation::Mutable);
-                            then {
-                                span_lint_and_help(
-                                    cx,
-                                    SAME_ITEM_PUSH,
-                                    vec.span,
-                                    "it looks like the same item is being pushed into this Vec",
-                                    None,
-                                    &format!(
-                                        "try using vec![{};SIZE] or {}.resize(NEW_SIZE, {})",
-                                        item_str, vec_str, item_str
-                                    ),
-                                )
-                            }
+                        match qpath_res(cx, qpath, pushed_item.hir_id) {
+                            // immutable bindings that are initialized with literal or constant
+                            Res::Local(hir_id) => {
+                                if_chain! {
+                                    let node = cx.tcx.hir().get(hir_id);
+                                    if let Node::Binding(pat) = node;
+                                    if let PatKind::Binding(bind_ann, ..) = pat.kind;
+                                    if !matches!(bind_ann, BindingAnnotation::RefMut | BindingAnnotation::Mutable);
+                                    let parent_node = cx.tcx.hir().get_parent_node(hir_id);
+                                    if let Some(Node::Local(parent_let_expr)) = cx.tcx.hir().find(parent_node);
+                                    if let rustc_hir::Local { init: Some(init), .. } = parent_let_expr;
+                                    then {
+                                        match init.kind {
+                                            // immutable bindings that are initialized with literal
+                                            ExprKind::Lit(..) => {
+                                                span_lint_and_help(
+                                                    cx,
+                                                    SAME_ITEM_PUSH,
+                                                    vec.span,
+                                                    "it looks like the same item is being pushed into this Vec",
+                                                    None,
+                                                    &format!(
+                                                        "try using vec![{};SIZE] or {}.resize(NEW_SIZE, {})",
+                                                        item_str, vec_str, item_str
+                                                    ),
+                                                )
+                                            },
+                                            // immutable bindings that are initialized with constant
+                                            ExprKind::Path(ref path) => {
+                                                if let Res::Def(DefKind::Const, ..) = qpath_res(cx, path, init.hir_id) {
+                                                    span_lint_and_help(
+                                                        cx,
+                                                        SAME_ITEM_PUSH,
+                                                        vec.span,
+                                                        "it looks like the same item is being pushed into this Vec",
+                                                        None,
+                                                        &format!(
+                                                            "try using vec![{};SIZE] or {}.resize(NEW_SIZE, {})",
+                                                            item_str, vec_str, item_str
+                                                        ),
+                                                    )
+                                                }
+                                            }
+                                            _ => {},
+                                        }
+                                    }
+                                }
+                            },
+                            // constant
+                            Res::Def(DefKind::Const, ..) => span_lint_and_help(
+                                cx,
+                                SAME_ITEM_PUSH,
+                                vec.span,
+                                "it looks like the same item is being pushed into this Vec",
+                                None,
+                                &format!(
+                                    "try using vec![{};SIZE] or {}.resize(NEW_SIZE, {})",
+                                    item_str, vec_str, item_str
+                                ),
+                            ),
+                            _ => {},
                         }
-                    } else if mutated_variables(pushed_item, cx).map_or(false, |mutvars| mutvars.is_empty()) {
+                    } else if let ExprKind::Lit(..) = pushed_item.kind {
+                        // literal
                         span_lint_and_help(
                             cx,
                             SAME_ITEM_PUSH,
diff --git a/tests/ui/same_item_push.rs b/tests/ui/same_item_push.rs
index 0928820892b..bd4792c4a76 100644
--- a/tests/ui/same_item_push.rs
+++ b/tests/ui/same_item_push.rs
@@ -1,5 +1,7 @@
 #![warn(clippy::same_item_push)]
 
+const VALUE: u8 = 7;
+
 fn mutate_increment(x: &mut u8) -> u8 {
     *x += 1;
     *x
@@ -111,4 +113,15 @@ fn main() {
     for _ in 0..10 {
         vec15.push(Box::new(S {}));
     }
+
+    let mut vec16 = Vec::new();
+    for _ in 0..20 {
+        vec16.push(VALUE);
+    }
+
+    let mut vec17 = Vec::new();
+    let item = VALUE;
+    for _ in 0..20 {
+        vec17.push(item);
+    }
 }
diff --git a/tests/ui/same_item_push.stderr b/tests/ui/same_item_push.stderr
index ddc5d48cd41..4896479791a 100644
--- a/tests/ui/same_item_push.stderr
+++ b/tests/ui/same_item_push.stderr
@@ -1,22 +1,14 @@
 error: it looks like the same item is being pushed into this Vec
-  --> $DIR/same_item_push.rs:16:9
-   |
-LL |         spaces.push(vec![b' ']);
-   |         ^^^^^^
-   |
-   = note: `-D clippy::same-item-push` implied by `-D warnings`
-   = help: try using vec![vec![b' '];SIZE] or spaces.resize(NEW_SIZE, vec![b' '])
-
-error: it looks like the same item is being pushed into this Vec
-  --> $DIR/same_item_push.rs:22:9
+  --> $DIR/same_item_push.rs:24:9
    |
 LL |         vec2.push(item);
    |         ^^^^
    |
+   = note: `-D clippy::same-item-push` implied by `-D warnings`
    = help: try using vec![item;SIZE] or vec2.resize(NEW_SIZE, item)
 
 error: it looks like the same item is being pushed into this Vec
-  --> $DIR/same_item_push.rs:28:9
+  --> $DIR/same_item_push.rs:30:9
    |
 LL |         vec3.push(item);
    |         ^^^^
@@ -24,12 +16,28 @@ LL |         vec3.push(item);
    = help: try using vec![item;SIZE] or vec3.resize(NEW_SIZE, item)
 
 error: it looks like the same item is being pushed into this Vec
-  --> $DIR/same_item_push.rs:33:9
+  --> $DIR/same_item_push.rs:35:9
    |
 LL |         vec4.push(13);
    |         ^^^^
    |
    = help: try using vec![13;SIZE] or vec4.resize(NEW_SIZE, 13)
 
-error: aborting due to 4 previous errors
+error: it looks like the same item is being pushed into this Vec
+  --> $DIR/same_item_push.rs:119:9
+   |
+LL |         vec16.push(VALUE);
+   |         ^^^^^
+   |
+   = help: try using vec![VALUE;SIZE] or vec16.resize(NEW_SIZE, VALUE)
+
+error: it looks like the same item is being pushed into this Vec
+  --> $DIR/same_item_push.rs:125:9
+   |
+LL |         vec17.push(item);
+   |         ^^^^^
+   |
+   = help: try using vec![item;SIZE] or vec17.resize(NEW_SIZE, item)
+
+error: aborting due to 5 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 619ca76731e7209288fd3ebf1ae243c050486c12 Mon Sep 17 00:00:00 2001
From: Takayuki Nakata <f.seasons017@gmail.com>
Date: Tue, 8 Sep 2020 08:25:31 +0900
Subject: Refactoring: use inner function

---
 clippy_lints/src/loops.rs | 69 +++++++++++++++--------------------------------
 1 file changed, 21 insertions(+), 48 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index f417e3a0caf..c27acdd2236 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -1150,8 +1150,6 @@ fn detect_same_item_push<'tcx>(
             {
                 // Make sure that the push does not involve possibly mutating values
                 if let PatKind::Wild = pat.kind {
-                    let vec_str = snippet_with_macro_callsite(cx, vec.span, "");
-                    let item_str = snippet_with_macro_callsite(cx, pushed_item.span, "");
                     if let ExprKind::Path(ref qpath) = pushed_item.kind {
                         match qpath_res(cx, qpath, pushed_item.hir_id) {
                             // immutable bindings that are initialized with literal or constant
@@ -1167,33 +1165,11 @@ fn detect_same_item_push<'tcx>(
                                     then {
                                         match init.kind {
                                             // immutable bindings that are initialized with literal
-                                            ExprKind::Lit(..) => {
-                                                span_lint_and_help(
-                                                    cx,
-                                                    SAME_ITEM_PUSH,
-                                                    vec.span,
-                                                    "it looks like the same item is being pushed into this Vec",
-                                                    None,
-                                                    &format!(
-                                                        "try using vec![{};SIZE] or {}.resize(NEW_SIZE, {})",
-                                                        item_str, vec_str, item_str
-                                                    ),
-                                                )
-                                            },
+                                            ExprKind::Lit(..) => emit_lint(cx, vec, pushed_item),
                                             // immutable bindings that are initialized with constant
                                             ExprKind::Path(ref path) => {
                                                 if let Res::Def(DefKind::Const, ..) = qpath_res(cx, path, init.hir_id) {
-                                                    span_lint_and_help(
-                                                        cx,
-                                                        SAME_ITEM_PUSH,
-                                                        vec.span,
-                                                        "it looks like the same item is being pushed into this Vec",
-                                                        None,
-                                                        &format!(
-                                                            "try using vec![{};SIZE] or {}.resize(NEW_SIZE, {})",
-                                                            item_str, vec_str, item_str
-                                                        ),
-                                                    )
+                                                    emit_lint(cx, vec, pushed_item);
                                                 }
                                             }
                                             _ => {},
@@ -1202,37 +1178,34 @@ fn detect_same_item_push<'tcx>(
                                 }
                             },
                             // constant
-                            Res::Def(DefKind::Const, ..) => span_lint_and_help(
-                                cx,
-                                SAME_ITEM_PUSH,
-                                vec.span,
-                                "it looks like the same item is being pushed into this Vec",
-                                None,
-                                &format!(
-                                    "try using vec![{};SIZE] or {}.resize(NEW_SIZE, {})",
-                                    item_str, vec_str, item_str
-                                ),
-                            ),
+                            Res::Def(DefKind::Const, ..) => emit_lint(cx, vec, pushed_item),
                             _ => {},
                         }
                     } else if let ExprKind::Lit(..) = pushed_item.kind {
                         // literal
-                        span_lint_and_help(
-                            cx,
-                            SAME_ITEM_PUSH,
-                            vec.span,
-                            "it looks like the same item is being pushed into this Vec",
-                            None,
-                            &format!(
-                                "try using vec![{};SIZE] or {}.resize(NEW_SIZE, {})",
-                                item_str, vec_str, item_str
-                            ),
-                        )
+                        emit_lint(cx, vec, pushed_item);
                     }
                 }
             }
         }
     }
+
+    fn emit_lint(cx: &LateContext<'_>, vec: &Expr<'_>, pushed_item: &Expr<'_>) {
+        let vec_str = snippet_with_macro_callsite(cx, vec.span, "");
+        let item_str = snippet_with_macro_callsite(cx, pushed_item.span, "");
+
+        span_lint_and_help(
+            cx,
+            SAME_ITEM_PUSH,
+            vec.span,
+            "it looks like the same item is being pushed into this Vec",
+            None,
+            &format!(
+                "try using vec![{};SIZE] or {}.resize(NEW_SIZE, {})",
+                item_str, vec_str, item_str
+            ),
+        )
+    }
 }
 
 /// Checks for looping over a range and then indexing a sequence with it.
-- 
cgit 1.4.1-3-g733a5


From 5d085ad011a602e004e7d33fa0b9074c7dab36fc Mon Sep 17 00:00:00 2001
From: Takayuki Nakata <f.seasons017@gmail.com>
Date: Tue, 8 Sep 2020 08:34:51 +0900
Subject: Some refactoring

---
 clippy_lints/src/loops.rs | 17 ++++++++++-------
 1 file changed, 10 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index c27acdd2236..c59185bd7bd 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -1131,6 +1131,10 @@ fn detect_same_item_push<'tcx>(
     body: &'tcx Expr<'_>,
     _: &'tcx Expr<'_>,
 ) {
+    if !matches!(pat.kind, PatKind::Wild) {
+        return;
+    }
+
     // Determine whether it is safe to lint the body
     let mut same_item_push_visitor = SameItemPushVisitor {
         should_lint: true,
@@ -1149,8 +1153,8 @@ fn detect_same_item_push<'tcx>(
                 .map_or(false, |id| implements_trait(cx, ty, id, &[]))
             {
                 // Make sure that the push does not involve possibly mutating values
-                if let PatKind::Wild = pat.kind {
-                    if let ExprKind::Path(ref qpath) = pushed_item.kind {
+                match pushed_item.kind {
+                    ExprKind::Path(ref qpath) => {
                         match qpath_res(cx, qpath, pushed_item.hir_id) {
                             // immutable bindings that are initialized with literal or constant
                             Res::Local(hir_id) => {
@@ -1161,7 +1165,7 @@ fn detect_same_item_push<'tcx>(
                                     if !matches!(bind_ann, BindingAnnotation::RefMut | BindingAnnotation::Mutable);
                                     let parent_node = cx.tcx.hir().get_parent_node(hir_id);
                                     if let Some(Node::Local(parent_let_expr)) = cx.tcx.hir().find(parent_node);
-                                    if let rustc_hir::Local { init: Some(init), .. } = parent_let_expr;
+                                    if let Some(init) = parent_let_expr.init;
                                     then {
                                         match init.kind {
                                             // immutable bindings that are initialized with literal
@@ -1181,10 +1185,9 @@ fn detect_same_item_push<'tcx>(
                             Res::Def(DefKind::Const, ..) => emit_lint(cx, vec, pushed_item),
                             _ => {},
                         }
-                    } else if let ExprKind::Lit(..) = pushed_item.kind {
-                        // literal
-                        emit_lint(cx, vec, pushed_item);
-                    }
+                    },
+                    ExprKind::Lit(..) => emit_lint(cx, vec, pushed_item),
+                    _ => {},
                 }
             }
         }
-- 
cgit 1.4.1-3-g733a5


From a60e5de90c7370d4fb3e6561d3cb55495cda2e2a Mon Sep 17 00:00:00 2001
From: Tim Nielens <tim.nielens@gmail.com>
Date: Tue, 8 Sep 2020 02:39:39 +0200
Subject: needless-lifetime / nested elision sites / PR remarks

---
 clippy_lints/src/lifetimes.rs                      | 222 +++++++--------------
 tests/ui/crashes/ice-2774.stderr                   |  10 +
 .../crashes/needless_lifetimes_impl_trait.stderr   |  14 ++
 tests/ui/needless_lifetimes.stderr                 |   8 +-
 4 files changed, 102 insertions(+), 152 deletions(-)
 create mode 100644 tests/ui/crashes/ice-2774.stderr
 create mode 100644 tests/ui/crashes/needless_lifetimes_impl_trait.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lifetimes.rs b/clippy_lints/src/lifetimes.rs
index ab6e34d201c..1d17fbd3725 100644
--- a/clippy_lints/src/lifetimes.rs
+++ b/clippy_lints/src/lifetimes.rs
@@ -1,23 +1,22 @@
+use crate::utils::paths;
+use crate::utils::{get_trait_def_id, in_macro, span_lint, trait_ref_of_method};
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
-use rustc_hir::def::{DefKind, Res};
 use rustc_hir::intravisit::{
-    walk_fn_decl, walk_generic_param, walk_generics, walk_param_bound, walk_trait_ref, walk_ty, NestedVisitorMap,
-    Visitor,
+    walk_fn_decl, walk_generic_param, walk_generics, walk_item, walk_param_bound, walk_poly_trait_ref, walk_ty,
+    NestedVisitorMap, Visitor,
 };
 use rustc_hir::FnRetTy::Return;
 use rustc_hir::{
-    BodyId, FnDecl, GenericArg, GenericBound, GenericParam, GenericParamKind, Generics, ImplItem, ImplItemKind, Item,
-    ItemKind, Lifetime, LifetimeName, ParamName, QPath, TraitBoundModifier, TraitFn, TraitItem, TraitItemKind,
-    TraitRef, Ty, TyKind, WhereClause, WherePredicate,
+    BareFnTy, BodyId, FnDecl, GenericArg, GenericBound, GenericParam, GenericParamKind, Generics, ImplItem,
+    ImplItemKind, Item, ItemKind, Lifetime, LifetimeName, ParamName, PolyTraitRef, TraitBoundModifier, TraitFn,
+    TraitItem, TraitItemKind, Ty, TyKind, WhereClause, WherePredicate,
 };
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::map::Map;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
 use rustc_span::symbol::{kw, Symbol};
-
-use crate::utils::paths;
-use crate::utils::{get_trait_def_id, in_macro, last_path_segment, span_lint, trait_ref_of_method};
+use std::iter::FromIterator;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for lifetime annotations which can be removed by
@@ -110,7 +109,7 @@ impl<'tcx> LateLintPass<'tcx> for Lifetimes {
 }
 
 /// The lifetime of a &-reference.
-#[derive(PartialEq, Eq, Hash, Debug)]
+#[derive(PartialEq, Eq, Hash, Debug, Clone)]
 enum RefLt {
     Unnamed,
     Static,
@@ -129,15 +128,6 @@ fn check_fn_inner<'tcx>(
         return;
     }
 
-    // fn pointers and closure trait bounds are also lifetime elision sites. This lint does not
-    // support nested elision sites in a fn item.
-    if FnPointerOrClosureTraitBoundFinder::find_in_generics(cx, generics)
-        || FnPointerOrClosureTraitBoundFinder::find_in_fn_decl(cx, decl)
-    {
-        return;
-    }
-
-    let mut bounds_lts = Vec::new();
     let types = generics
         .params
         .iter()
@@ -166,13 +156,12 @@ fn check_fn_inner<'tcx>(
                         if bound.name != LifetimeName::Static && !bound.is_elided() {
                             return;
                         }
-                        bounds_lts.push(bound);
                     }
                 }
             }
         }
     }
-    if could_use_elision(cx, decl, body, &generics.params, bounds_lts) {
+    if could_use_elision(cx, decl, body, &generics.params) {
         span_lint(
             cx,
             NEEDLESS_LIFETIMES,
@@ -191,7 +180,6 @@ fn could_use_elision<'tcx>(
     func: &'tcx FnDecl<'_>,
     body: Option<BodyId>,
     named_generics: &'tcx [GenericParam<'_>],
-    bounds_lts: Vec<&'tcx Lifetime>,
 ) -> bool {
     // There are two scenarios where elision works:
     // * no output references, all input references have different LT
@@ -214,15 +202,31 @@ fn could_use_elision<'tcx>(
     if let Return(ref ty) = func.output {
         output_visitor.visit_ty(ty);
     }
+    for lt in named_generics {
+        input_visitor.visit_generic_param(lt)
+    }
 
-    let input_lts = match input_visitor.into_vec() {
-        Some(lts) => lts_from_bounds(lts, bounds_lts.into_iter()),
-        None => return false,
-    };
-    let output_lts = match output_visitor.into_vec() {
-        Some(val) => val,
-        None => return false,
-    };
+    if input_visitor.abort() || output_visitor.abort() {
+        return false;
+    }
+
+    if allowed_lts
+        .intersection(&FxHashSet::from_iter(
+            input_visitor
+                .nested_elision_site_lts
+                .iter()
+                .chain(output_visitor.nested_elision_site_lts.iter())
+                .cloned()
+                .filter(|v| matches!(v, RefLt::Named(_))),
+        ))
+        .next()
+        .is_some()
+    {
+        return false;
+    }
+
+    let input_lts = input_visitor.lts;
+    let output_lts = output_visitor.lts;
 
     if let Some(body_id) = body {
         let mut checker = BodyLifetimeChecker {
@@ -287,27 +291,20 @@ fn allowed_lts_from(named_generics: &[GenericParam<'_>]) -> FxHashSet<RefLt> {
     allowed_lts
 }
 
-fn lts_from_bounds<'a, T: Iterator<Item = &'a Lifetime>>(mut vec: Vec<RefLt>, bounds_lts: T) -> Vec<RefLt> {
-    for lt in bounds_lts {
-        if lt.name != LifetimeName::Static {
-            vec.push(RefLt::Named(lt.name.ident().name));
-        }
-    }
-
-    vec
-}
-
 /// Number of unique lifetimes in the given vector.
 #[must_use]
 fn unique_lifetimes(lts: &[RefLt]) -> usize {
     lts.iter().collect::<FxHashSet<_>>().len()
 }
 
+const CLOSURE_TRAIT_BOUNDS: [&[&str]; 3] = [&paths::FN, &paths::FN_MUT, &paths::FN_ONCE];
+
 /// A visitor usable for `rustc_front::visit::walk_ty()`.
 struct RefVisitor<'a, 'tcx> {
     cx: &'a LateContext<'tcx>,
     lts: Vec<RefLt>,
-    abort: bool,
+    nested_elision_site_lts: Vec<RefLt>,
+    unelided_trait_object_lifetime: bool,
 }
 
 impl<'a, 'tcx> RefVisitor<'a, 'tcx> {
@@ -315,7 +312,8 @@ impl<'a, 'tcx> RefVisitor<'a, 'tcx> {
         Self {
             cx,
             lts: Vec::new(),
-            abort: false,
+            nested_elision_site_lts: Vec::new(),
+            unelided_trait_object_lifetime: false,
         }
     }
 
@@ -335,40 +333,16 @@ impl<'a, 'tcx> RefVisitor<'a, 'tcx> {
         }
     }
 
-    fn into_vec(self) -> Option<Vec<RefLt>> {
-        if self.abort {
-            None
-        } else {
-            Some(self.lts)
-        }
+    fn all_lts(&self) -> Vec<RefLt> {
+        self.lts
+            .iter()
+            .chain(self.nested_elision_site_lts.iter())
+            .cloned()
+            .collect::<Vec<_>>()
     }
 
-    fn collect_anonymous_lifetimes(&mut self, qpath: &QPath<'_>, ty: &Ty<'_>) {
-        if let Some(ref last_path_segment) = last_path_segment(qpath).args {
-            if !last_path_segment.parenthesized
-                && !last_path_segment
-                    .args
-                    .iter()
-                    .any(|arg| matches!(arg, GenericArg::Lifetime(_)))
-            {
-                let hir_id = ty.hir_id;
-                match self.cx.qpath_res(qpath, hir_id) {
-                    Res::Def(DefKind::TyAlias | DefKind::Struct, def_id) => {
-                        let generics = self.cx.tcx.generics_of(def_id);
-                        for _ in generics.params.as_slice() {
-                            self.record(&None);
-                        }
-                    },
-                    Res::Def(DefKind::Trait, def_id) => {
-                        let trait_def = self.cx.tcx.trait_def(def_id);
-                        for _ in &self.cx.tcx.generics_of(trait_def.def_id).params {
-                            self.record(&None);
-                        }
-                    },
-                    _ => (),
-                }
-            }
-        }
+    fn abort(&self) -> bool {
+        self.unelided_trait_object_lifetime
     }
 }
 
@@ -380,30 +354,36 @@ impl<'a, 'tcx> Visitor<'tcx> for RefVisitor<'a, 'tcx> {
         self.record(&Some(*lifetime));
     }
 
+    fn visit_poly_trait_ref(&mut self, poly_tref: &'tcx PolyTraitRef<'tcx>, tbm: TraitBoundModifier) {
+        let trait_ref = &poly_tref.trait_ref;
+        if CLOSURE_TRAIT_BOUNDS
+            .iter()
+            .any(|trait_path| trait_ref.trait_def_id() == get_trait_def_id(self.cx, trait_path))
+        {
+            let mut sub_visitor = RefVisitor::new(self.cx);
+            sub_visitor.visit_trait_ref(trait_ref);
+            self.nested_elision_site_lts.append(&mut sub_visitor.all_lts());
+        } else {
+            walk_poly_trait_ref(self, poly_tref, tbm);
+        }
+    }
+
     fn visit_ty(&mut self, ty: &'tcx Ty<'_>) {
         match ty.kind {
-            TyKind::Rptr(ref lt, _) if lt.is_elided() => {
-                self.record(&None);
-            },
-            TyKind::Path(ref path) => {
-                self.collect_anonymous_lifetimes(path, ty);
-            },
             TyKind::OpaqueDef(item, _) => {
                 let map = self.cx.tcx.hir();
-                if let ItemKind::OpaqueTy(ref exist_ty) = map.expect_item(item.id).kind {
-                    for bound in exist_ty.bounds {
-                        if let GenericBound::Outlives(_) = *bound {
-                            self.record(&None);
-                        }
-                    }
-                } else {
-                    unreachable!()
-                }
+                let item = map.expect_item(item.id);
+                walk_item(self, item);
                 walk_ty(self, ty);
             },
+            TyKind::BareFn(&BareFnTy { decl, .. }) => {
+                let mut sub_visitor = RefVisitor::new(self.cx);
+                sub_visitor.visit_fn_decl(decl);
+                self.nested_elision_site_lts.append(&mut sub_visitor.all_lts());
+            },
             TyKind::TraitObject(bounds, ref lt) => {
                 if !lt.is_elided() {
-                    self.abort = true;
+                    self.unelided_trait_object_lifetime = true;
                 }
                 for bound in bounds {
                     self.visit_poly_trait_ref(bound, TraitBoundModifier::None);
@@ -440,16 +420,7 @@ fn has_where_lifetimes<'tcx>(cx: &LateContext<'tcx>, where_clause: &'tcx WhereCl
                     walk_param_bound(&mut visitor, bound);
                 }
                 // and check that all lifetimes are allowed
-                match visitor.into_vec() {
-                    None => return false,
-                    Some(lts) => {
-                        for lt in lts {
-                            if !allowed_lts.contains(&lt) {
-                                return true;
-                            }
-                        }
-                    },
-                }
+                return visitor.all_lts().iter().any(|it| !allowed_lts.contains(it));
             },
             WherePredicate::EqPredicate(ref pred) => {
                 let mut visitor = RefVisitor::new(cx);
@@ -533,54 +504,3 @@ impl<'tcx> Visitor<'tcx> for BodyLifetimeChecker {
         NestedVisitorMap::None
     }
 }
-
-const CLOSURE_TRAIT_BOUNDS: [&[&str]; 3] = [&paths::FN, &paths::FN_MUT, &paths::FN_ONCE];
-
-struct FnPointerOrClosureTraitBoundFinder<'a, 'tcx> {
-    cx: &'a LateContext<'tcx>,
-    found: bool,
-}
-
-impl<'a, 'tcx> FnPointerOrClosureTraitBoundFinder<'a, 'tcx> {
-    fn find_in_generics(cx: &'a LateContext<'tcx>, generics: &'tcx Generics<'tcx>) -> bool {
-        let mut finder = Self { cx, found: false };
-        finder.visit_generics(generics);
-        finder.found
-    }
-
-    fn find_in_fn_decl(cx: &'a LateContext<'tcx>, generics: &'tcx FnDecl<'tcx>) -> bool {
-        let mut finder = Self { cx, found: false };
-        finder.visit_fn_decl(generics);
-        finder.found
-    }
-}
-
-impl<'a, 'tcx> Visitor<'tcx> for FnPointerOrClosureTraitBoundFinder<'a, 'tcx> {
-    type Map = Map<'tcx>;
-    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-        NestedVisitorMap::None
-    }
-
-    fn visit_trait_ref(&mut self, tref: &'tcx TraitRef<'tcx>) {
-        if CLOSURE_TRAIT_BOUNDS
-            .iter()
-            .any(|trait_path| tref.trait_def_id() == get_trait_def_id(self.cx, trait_path))
-        {
-            self.found = true;
-        }
-        walk_trait_ref(self, tref);
-    }
-
-    fn visit_ty(&mut self, ty: &'tcx Ty<'tcx>) {
-        match ty.kind {
-            TyKind::BareFn(..) => self.found = true,
-            TyKind::OpaqueDef(item_id, _) => {
-                let map = self.cx.tcx.hir();
-                let item = map.expect_item(item_id.id);
-                self.visit_item(item);
-            },
-            _ => (),
-        }
-        walk_ty(self, ty);
-    }
-}
diff --git a/tests/ui/crashes/ice-2774.stderr b/tests/ui/crashes/ice-2774.stderr
new file mode 100644
index 00000000000..fd502cba73a
--- /dev/null
+++ b/tests/ui/crashes/ice-2774.stderr
@@ -0,0 +1,10 @@
+error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+  --> $DIR/ice-2774.rs:17:1
+   |
+LL | pub fn add_barfoos_to_foos<'a>(bars: &HashSet<&'a Bar>) {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::needless-lifetimes` implied by `-D warnings`
+
+error: aborting due to previous error
+
diff --git a/tests/ui/crashes/needless_lifetimes_impl_trait.stderr b/tests/ui/crashes/needless_lifetimes_impl_trait.stderr
new file mode 100644
index 00000000000..02b86397ed5
--- /dev/null
+++ b/tests/ui/crashes/needless_lifetimes_impl_trait.stderr
@@ -0,0 +1,14 @@
+error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+  --> $DIR/needless_lifetimes_impl_trait.rs:17:5
+   |
+LL |     fn baz<'a>(&'a self) -> impl Foo + 'a {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: the lint level is defined here
+  --> $DIR/needless_lifetimes_impl_trait.rs:3:9
+   |
+LL | #![deny(clippy::needless_lifetimes)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to previous error
+
diff --git a/tests/ui/needless_lifetimes.stderr b/tests/ui/needless_lifetimes.stderr
index b1943bf9d70..d3a360ed8b5 100644
--- a/tests/ui/needless_lifetimes.stderr
+++ b/tests/ui/needless_lifetimes.stderr
@@ -36,6 +36,12 @@ error: explicit lifetimes given in parameter types where they could be elided (o
 LL | fn lifetime_param_2<'a, 'b>(_x: Ref<'a>, _y: &'b u8) {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
+error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+  --> $DIR/needless_lifetimes.rs:86:1
+   |
+LL | fn fn_bound_2<'a, F, I>(_m: Lt<'a, I>, _f: F) -> Lt<'a, I>
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
 error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
   --> $DIR/needless_lifetimes.rs:120:5
    |
@@ -96,5 +102,5 @@ error: explicit lifetimes given in parameter types where they could be elided (o
 LL |         fn needless_lt<'a>(_x: &'a u8) {}
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 16 previous errors
+error: aborting due to 17 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 1d8ae3aa12567b8461436ac10ba9fc4da55adb29 Mon Sep 17 00:00:00 2001
From: Takayuki Nakata <f.seasons017@gmail.com>
Date: Tue, 8 Sep 2020 23:12:04 +0900
Subject: Address `items_after_statement`

---
 clippy_lints/src/loops.rs | 34 +++++++++++++++++-----------------
 1 file changed, 17 insertions(+), 17 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index c59185bd7bd..6c54c07869a 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -1131,6 +1131,23 @@ fn detect_same_item_push<'tcx>(
     body: &'tcx Expr<'_>,
     _: &'tcx Expr<'_>,
 ) {
+    fn emit_lint(cx: &LateContext<'_>, vec: &Expr<'_>, pushed_item: &Expr<'_>) {
+        let vec_str = snippet_with_macro_callsite(cx, vec.span, "");
+        let item_str = snippet_with_macro_callsite(cx, pushed_item.span, "");
+
+        span_lint_and_help(
+            cx,
+            SAME_ITEM_PUSH,
+            vec.span,
+            "it looks like the same item is being pushed into this Vec",
+            None,
+            &format!(
+                "try using vec![{};SIZE] or {}.resize(NEW_SIZE, {})",
+                item_str, vec_str, item_str
+            ),
+        )
+    }
+
     if !matches!(pat.kind, PatKind::Wild) {
         return;
     }
@@ -1192,23 +1209,6 @@ fn detect_same_item_push<'tcx>(
             }
         }
     }
-
-    fn emit_lint(cx: &LateContext<'_>, vec: &Expr<'_>, pushed_item: &Expr<'_>) {
-        let vec_str = snippet_with_macro_callsite(cx, vec.span, "");
-        let item_str = snippet_with_macro_callsite(cx, pushed_item.span, "");
-
-        span_lint_and_help(
-            cx,
-            SAME_ITEM_PUSH,
-            vec.span,
-            "it looks like the same item is being pushed into this Vec",
-            None,
-            &format!(
-                "try using vec![{};SIZE] or {}.resize(NEW_SIZE, {})",
-                item_str, vec_str, item_str
-            ),
-        )
-    }
 }
 
 /// Checks for looping over a range and then indexing a sequence with it.
-- 
cgit 1.4.1-3-g733a5


From a899ad2e125e8dd3a0a339df1f8457ef8cab3cc7 Mon Sep 17 00:00:00 2001
From: Hirochika Matsumoto <matsujika@gmail.com>
Date: Tue, 8 Sep 2020 23:35:19 +0900
Subject: Change suggestion to `create_dir_all({})` from
 `std::fs::create_dir_all({})`

---
 clippy_lints/src/create_dir.rs | 2 +-
 tests/ui/create_dir.fixed      | 6 ++++--
 tests/ui/create_dir.rs         | 2 ++
 tests/ui/create_dir.stderr     | 8 ++++----
 4 files changed, 11 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/create_dir.rs b/clippy_lints/src/create_dir.rs
index f80a0efa7a5..4002fb655a5 100644
--- a/clippy_lints/src/create_dir.rs
+++ b/clippy_lints/src/create_dir.rs
@@ -42,7 +42,7 @@ impl LateLintPass<'_> for CreateDir {
                     expr.span,
                     "calling `std::fs::create_dir` where there may be a better way",
                     "consider calling `std::fs::create_dir_all` instead",
-                    format!("std::fs::create_dir_all({})", snippet(cx, args[0].span, "..")),
+                    format!("create_dir_all({})", snippet(cx, args[0].span, "..")),
                     Applicability::MaybeIncorrect,
                 )
             }
diff --git a/tests/ui/create_dir.fixed b/tests/ui/create_dir.fixed
index 0e28f87e33d..8ed53a56ac0 100644
--- a/tests/ui/create_dir.fixed
+++ b/tests/ui/create_dir.fixed
@@ -2,12 +2,14 @@
 #![allow(unused_must_use)]
 #![warn(clippy::create_dir)]
 
+use std::fs::create_dir_all;
+
 fn create_dir() {}
 
 fn main() {
     // Should be warned
-    std::fs::create_dir_all("foo");
-    std::fs::create_dir_all("bar").unwrap();
+    create_dir_all("foo");
+    create_dir_all("bar").unwrap();
 
     // Shouldn't be warned
     create_dir();
diff --git a/tests/ui/create_dir.rs b/tests/ui/create_dir.rs
index 1f226298c0d..19c8fc24ba2 100644
--- a/tests/ui/create_dir.rs
+++ b/tests/ui/create_dir.rs
@@ -2,6 +2,8 @@
 #![allow(unused_must_use)]
 #![warn(clippy::create_dir)]
 
+use std::fs::create_dir_all;
+
 fn create_dir() {}
 
 fn main() {
diff --git a/tests/ui/create_dir.stderr b/tests/ui/create_dir.stderr
index 0c97bdd0f7a..67298fc4709 100644
--- a/tests/ui/create_dir.stderr
+++ b/tests/ui/create_dir.stderr
@@ -1,16 +1,16 @@
 error: calling `std::fs::create_dir` where there may be a better way
-  --> $DIR/create_dir.rs:9:5
+  --> $DIR/create_dir.rs:11:5
    |
 LL |     std::fs::create_dir("foo");
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `std::fs::create_dir_all` instead: `std::fs::create_dir_all("foo")`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `std::fs::create_dir_all` instead: `create_dir_all("foo")`
    |
    = note: `-D clippy::create-dir` implied by `-D warnings`
 
 error: calling `std::fs::create_dir` where there may be a better way
-  --> $DIR/create_dir.rs:10:5
+  --> $DIR/create_dir.rs:12:5
    |
 LL |     std::fs::create_dir("bar").unwrap();
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `std::fs::create_dir_all` instead: `std::fs::create_dir_all("bar")`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `std::fs::create_dir_all` instead: `create_dir_all("bar")`
 
 error: aborting due to 2 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 4f1c4a99d4d98f1acea3c9c7cc55355aa46119aa Mon Sep 17 00:00:00 2001
From: Ricky <Ricky@Hosfelt.io>
Date: Tue, 8 Sep 2020 12:05:18 -0400
Subject: Fixed typo in lint and test

---
 clippy_lints/src/map_err_ignore.rs | 4 ++--
 tests/ui/map_err.stderr            | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/map_err_ignore.rs b/clippy_lints/src/map_err_ignore.rs
index 649de4133e0..fa59b6ec370 100644
--- a/clippy_lints/src/map_err_ignore.rs
+++ b/clippy_lints/src/map_err_ignore.rs
@@ -7,7 +7,7 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 declare_clippy_lint! {
     /// **What it does:** Checks for instances of `map_err(|_| Some::Enum)`
     ///
-    /// **Why is this bad?** This map_err throws away the original error rather than allowing the enum to bubble the original error
+    /// **Why is this bad?** This map_err throws away the original error rather than allowing the enum to contain and report the cause of the error
     ///
     /// **Known problems:** None.
     ///
@@ -133,7 +133,7 @@ impl<'tcx> LateLintPass<'tcx> for MapErrIgnore {
                                     cx,
                                     MAP_ERR_IGNORE,
                                     body_span,
-                                    "`map_else(|_|...` ignores the original error",
+                                    "`map_err(|_|...` ignores the original error",
                                     None,
                                     "Consider wrapping the error in an enum variant",
                                 );
diff --git a/tests/ui/map_err.stderr b/tests/ui/map_err.stderr
index 7a269ab95ab..e4e6a289ba0 100644
--- a/tests/ui/map_err.stderr
+++ b/tests/ui/map_err.stderr
@@ -1,4 +1,4 @@
-error: `map_else(|_|...` ignores the original error
+error: `map_err(|_|...` ignores the original error
   --> $DIR/map_err.rs:21:32
    |
 LL |     println!("{:?}", x.map_err(|_| Errors::Ignored));
-- 
cgit 1.4.1-3-g733a5


From d719b485434eac557e65bf55cca79e63f7b83d5b Mon Sep 17 00:00:00 2001
From: Ricky <Ricky@Hosfelt.io>
Date: Tue, 8 Sep 2020 19:37:14 -0400
Subject: Move map_err_ignore from style to pedantic

---
 clippy_lints/src/lib.rs            | 3 +--
 clippy_lints/src/map_err_ignore.rs | 2 +-
 src/lintlist/mod.rs                | 2 +-
 tests/ui/map_err.rs                | 1 +
 tests/ui/map_err.stderr            | 2 +-
 5 files changed, 5 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 3794cae091a..797ab62cb54 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1179,6 +1179,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&loops::EXPLICIT_INTO_ITER_LOOP),
         LintId::of(&loops::EXPLICIT_ITER_LOOP),
         LintId::of(&macro_use::MACRO_USE_IMPORTS),
+        LintId::of(&map_err_ignore::MAP_ERR_IGNORE),
         LintId::of(&match_on_vec_items::MATCH_ON_VEC_ITEMS),
         LintId::of(&matches::MATCH_BOOL),
         LintId::of(&matches::MATCH_WILDCARD_FOR_SINGLE_VARIANTS),
@@ -1330,7 +1331,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&manual_async_fn::MANUAL_ASYNC_FN),
         LintId::of(&manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE),
         LintId::of(&map_clone::MAP_CLONE),
-        LintId::of(&map_err_ignore::MAP_ERR_IGNORE),
         LintId::of(&map_identity::MAP_IDENTITY),
         LintId::of(&map_unit_fn::OPTION_MAP_UNIT_FN),
         LintId::of(&map_unit_fn::RESULT_MAP_UNIT_FN),
@@ -1538,7 +1538,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&manual_async_fn::MANUAL_ASYNC_FN),
         LintId::of(&manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE),
         LintId::of(&map_clone::MAP_CLONE),
-        LintId::of(&map_err_ignore::MAP_ERR_IGNORE),
         LintId::of(&matches::INFALLIBLE_DESTRUCTURING_MATCH),
         LintId::of(&matches::MATCH_LIKE_MATCHES_MACRO),
         LintId::of(&matches::MATCH_OVERLAPPING_ARM),
diff --git a/clippy_lints/src/map_err_ignore.rs b/clippy_lints/src/map_err_ignore.rs
index fa59b6ec370..5298e16a04d 100644
--- a/clippy_lints/src/map_err_ignore.rs
+++ b/clippy_lints/src/map_err_ignore.rs
@@ -99,7 +99,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     pub MAP_ERR_IGNORE,
-    style,
+    pedantic,
     "`map_err` should not ignore the original error"
 }
 
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index 6725c97f793..5105e953162 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -1167,7 +1167,7 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
     },
     Lint {
         name: "map_err_ignore",
-        group: "style",
+        group: "pedantic",
         desc: "`map_err` should not ignore the original error",
         deprecation: None,
         module: "map_err_ignore",
diff --git a/tests/ui/map_err.rs b/tests/ui/map_err.rs
index f3a74ad95cd..617b6422872 100644
--- a/tests/ui/map_err.rs
+++ b/tests/ui/map_err.rs
@@ -1,3 +1,4 @@
+#![warn(clippy::map_err_ignore)]
 use std::convert::TryFrom;
 use std::error::Error;
 use std::fmt;
diff --git a/tests/ui/map_err.stderr b/tests/ui/map_err.stderr
index e4e6a289ba0..7273f460380 100644
--- a/tests/ui/map_err.stderr
+++ b/tests/ui/map_err.stderr
@@ -1,5 +1,5 @@
 error: `map_err(|_|...` ignores the original error
-  --> $DIR/map_err.rs:21:32
+  --> $DIR/map_err.rs:22:32
    |
 LL |     println!("{:?}", x.map_err(|_| Errors::Ignored));
    |                                ^^^
-- 
cgit 1.4.1-3-g733a5


From d712d7f700977240ad9bd731fc3f76e05cc1c900 Mon Sep 17 00:00:00 2001
From: rail <12975677+rail-rain@users.noreply.github.com>
Date: Wed, 9 Sep 2020 14:18:19 +1200
Subject: Improve "known problems" of `interior_mutable_key`

* Remove the mention to `Rc` and `Arc` as these are `Freeze`
  so the lint correctly handles already.

* Instead, explain what could cause a false positive,
  and mention `bytes` as an example.
---
 clippy_lints/src/mut_key.rs | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/mut_key.rs b/clippy_lints/src/mut_key.rs
index 7423107e8f9..fa3a99dad9d 100644
--- a/clippy_lints/src/mut_key.rs
+++ b/clippy_lints/src/mut_key.rs
@@ -12,8 +12,10 @@ declare_clippy_lint! {
     /// `BtreeSet` rely on either the hash or the order of keys be unchanging,
     /// so having types with interior mutability is a bad idea.
     ///
-    /// **Known problems:** We don't currently account for `Rc` or `Arc`, so
-    /// this may yield false positives.
+    /// **Known problems:** It's correct to use a struct, that contains interior mutability,
+    /// as a key; when its `Hash` implementation doesn't access any these interior mutable types.
+    /// However, this lint is unable to recognise it so cause a false positive.
+    /// `bytes` ctate is a great example of this.
     ///
     /// **Example:**
     /// ```rust
-- 
cgit 1.4.1-3-g733a5


From 4db10297c1dcd2fc368bd61a24aa0291a6b6c61a Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Wed, 9 Sep 2020 16:53:45 +0200
Subject: link to the Box docs in related lint documentation.

---
 clippy_lints/src/types.rs | 3 +++
 1 file changed, 3 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs
index c82deaa43b2..550ae2927a8 100644
--- a/clippy_lints/src/types.rs
+++ b/clippy_lints/src/types.rs
@@ -37,6 +37,7 @@ use crate::utils::{
 
 declare_clippy_lint! {
     /// **What it does:** Checks for use of `Box<Vec<_>>` anywhere in the code.
+    /// Check the [Box documentation](https://doc.rust-lang.org/std/boxed/index.html) for more information.
     ///
     /// **Why is this bad?** `Vec` already keeps its contents in a separate area on
     /// the heap. So if you `Box` it, you just add another level of indirection
@@ -65,6 +66,7 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// **What it does:** Checks for use of `Vec<Box<T>>` where T: Sized anywhere in the code.
+    /// Check the [Box documentation](https://doc.rust-lang.org/std/boxed/index.html) for more information.
     ///
     /// **Why is this bad?** `Vec` already keeps its contents in a separate area on
     /// the heap. So if you `Box` its contents, you just add another level of indirection.
@@ -167,6 +169,7 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// **What it does:** Checks for use of `&Box<T>` anywhere in the code.
+    /// Check the [Box documentation](https://doc.rust-lang.org/std/boxed/index.html) for more information.
     ///
     /// **Why is this bad?** Any `&Box<T>` can also be a `&T`, which is more
     /// general.
-- 
cgit 1.4.1-3-g733a5


From de195f2d3d3a2039cb8c4141aa37d060780beaa7 Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Wed, 9 Sep 2020 17:59:13 +0200
Subject: print the unit type `()` in related lint messages.

---
 clippy_lints/src/map_unit_fn.rs              |  6 ++---
 tests/ui/option_map_unit_fn_fixable.stderr   | 36 ++++++++++++++--------------
 tests/ui/result_map_unit_fn_fixable.stderr   | 34 +++++++++++++-------------
 tests/ui/result_map_unit_fn_unfixable.stderr | 12 +++++-----
 4 files changed, 44 insertions(+), 44 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/map_unit_fn.rs b/clippy_lints/src/map_unit_fn.rs
index 1f9ae8c931a..076ef235b8b 100644
--- a/clippy_lints/src/map_unit_fn.rs
+++ b/clippy_lints/src/map_unit_fn.rs
@@ -9,7 +9,7 @@ use rustc_span::source_map::Span;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for usage of `option.map(f)` where f is a function
-    /// or closure that returns the unit type.
+    /// or closure that returns the unit type `()`.
     ///
     /// **Why is this bad?** Readability, this can be written more clearly with
     /// an if let statement
@@ -51,7 +51,7 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// **What it does:** Checks for usage of `result.map(f)` where f is a function
-    /// or closure that returns the unit type.
+    /// or closure that returns the unit type `()`.
     ///
     /// **Why is this bad?** Readability, this can be written more clearly with
     /// an if let statement
@@ -197,7 +197,7 @@ fn let_binding_name(cx: &LateContext<'_>, var_arg: &hir::Expr<'_>) -> String {
 #[must_use]
 fn suggestion_msg(function_type: &str, map_type: &str) -> String {
     format!(
-        "called `map(f)` on an `{0}` value where `f` is a {1} that returns the unit type",
+        "called `map(f)` on an `{0}` value where `f` is a {1} that returns the unit type `()`",
         map_type, function_type
     )
 }
diff --git a/tests/ui/option_map_unit_fn_fixable.stderr b/tests/ui/option_map_unit_fn_fixable.stderr
index 1312c70b6d5..d7d45ef9b0b 100644
--- a/tests/ui/option_map_unit_fn_fixable.stderr
+++ b/tests/ui/option_map_unit_fn_fixable.stderr
@@ -1,4 +1,4 @@
-error: called `map(f)` on an `Option` value where `f` is a function that returns the unit type
+error: called `map(f)` on an `Option` value where `f` is a function that returns the unit type `()`
   --> $DIR/option_map_unit_fn_fixable.rs:38:5
    |
 LL |     x.field.map(do_nothing);
@@ -8,7 +8,7 @@ LL |     x.field.map(do_nothing);
    |
    = note: `-D clippy::option-map-unit-fn` implied by `-D warnings`
 
-error: called `map(f)` on an `Option` value where `f` is a function that returns the unit type
+error: called `map(f)` on an `Option` value where `f` is a function that returns the unit type `()`
   --> $DIR/option_map_unit_fn_fixable.rs:40:5
    |
 LL |     x.field.map(do_nothing);
@@ -16,7 +16,7 @@ LL |     x.field.map(do_nothing);
    |     |
    |     help: try this: `if let Some(x_field) = x.field { do_nothing(x_field) }`
 
-error: called `map(f)` on an `Option` value where `f` is a function that returns the unit type
+error: called `map(f)` on an `Option` value where `f` is a function that returns the unit type `()`
   --> $DIR/option_map_unit_fn_fixable.rs:42:5
    |
 LL |     x.field.map(diverge);
@@ -24,7 +24,7 @@ LL |     x.field.map(diverge);
    |     |
    |     help: try this: `if let Some(x_field) = x.field { diverge(x_field) }`
 
-error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type
+error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
   --> $DIR/option_map_unit_fn_fixable.rs:48:5
    |
 LL |     x.field.map(|value| x.do_option_nothing(value + captured));
@@ -32,7 +32,7 @@ LL |     x.field.map(|value| x.do_option_nothing(value + captured));
    |     |
    |     help: try this: `if let Some(value) = x.field { x.do_option_nothing(value + captured) }`
 
-error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type
+error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
   --> $DIR/option_map_unit_fn_fixable.rs:50:5
    |
 LL |     x.field.map(|value| { x.do_option_plus_one(value + captured); });
@@ -40,7 +40,7 @@ LL |     x.field.map(|value| { x.do_option_plus_one(value + captured); });
    |     |
    |     help: try this: `if let Some(value) = x.field { x.do_option_plus_one(value + captured); }`
 
-error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type
+error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
   --> $DIR/option_map_unit_fn_fixable.rs:53:5
    |
 LL |     x.field.map(|value| do_nothing(value + captured));
@@ -48,7 +48,7 @@ LL |     x.field.map(|value| do_nothing(value + captured));
    |     |
    |     help: try this: `if let Some(value) = x.field { do_nothing(value + captured) }`
 
-error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type
+error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
   --> $DIR/option_map_unit_fn_fixable.rs:55:5
    |
 LL |     x.field.map(|value| { do_nothing(value + captured) });
@@ -56,7 +56,7 @@ LL |     x.field.map(|value| { do_nothing(value + captured) });
    |     |
    |     help: try this: `if let Some(value) = x.field { do_nothing(value + captured) }`
 
-error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type
+error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
   --> $DIR/option_map_unit_fn_fixable.rs:57:5
    |
 LL |     x.field.map(|value| { do_nothing(value + captured); });
@@ -64,7 +64,7 @@ LL |     x.field.map(|value| { do_nothing(value + captured); });
    |     |
    |     help: try this: `if let Some(value) = x.field { do_nothing(value + captured); }`
 
-error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type
+error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
   --> $DIR/option_map_unit_fn_fixable.rs:59:5
    |
 LL |     x.field.map(|value| { { do_nothing(value + captured); } });
@@ -72,7 +72,7 @@ LL |     x.field.map(|value| { { do_nothing(value + captured); } });
    |     |
    |     help: try this: `if let Some(value) = x.field { do_nothing(value + captured); }`
 
-error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type
+error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
   --> $DIR/option_map_unit_fn_fixable.rs:62:5
    |
 LL |     x.field.map(|value| diverge(value + captured));
@@ -80,7 +80,7 @@ LL |     x.field.map(|value| diverge(value + captured));
    |     |
    |     help: try this: `if let Some(value) = x.field { diverge(value + captured) }`
 
-error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type
+error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
   --> $DIR/option_map_unit_fn_fixable.rs:64:5
    |
 LL |     x.field.map(|value| { diverge(value + captured) });
@@ -88,7 +88,7 @@ LL |     x.field.map(|value| { diverge(value + captured) });
    |     |
    |     help: try this: `if let Some(value) = x.field { diverge(value + captured) }`
 
-error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type
+error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
   --> $DIR/option_map_unit_fn_fixable.rs:66:5
    |
 LL |     x.field.map(|value| { diverge(value + captured); });
@@ -96,7 +96,7 @@ LL |     x.field.map(|value| { diverge(value + captured); });
    |     |
    |     help: try this: `if let Some(value) = x.field { diverge(value + captured); }`
 
-error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type
+error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
   --> $DIR/option_map_unit_fn_fixable.rs:68:5
    |
 LL |     x.field.map(|value| { { diverge(value + captured); } });
@@ -104,7 +104,7 @@ LL |     x.field.map(|value| { { diverge(value + captured); } });
    |     |
    |     help: try this: `if let Some(value) = x.field { diverge(value + captured); }`
 
-error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type
+error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
   --> $DIR/option_map_unit_fn_fixable.rs:73:5
    |
 LL |     x.field.map(|value| { let y = plus_one(value + captured); });
@@ -112,7 +112,7 @@ LL |     x.field.map(|value| { let y = plus_one(value + captured); });
    |     |
    |     help: try this: `if let Some(value) = x.field { let y = plus_one(value + captured); }`
 
-error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type
+error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
   --> $DIR/option_map_unit_fn_fixable.rs:75:5
    |
 LL |     x.field.map(|value| { plus_one(value + captured); });
@@ -120,7 +120,7 @@ LL |     x.field.map(|value| { plus_one(value + captured); });
    |     |
    |     help: try this: `if let Some(value) = x.field { plus_one(value + captured); }`
 
-error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type
+error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
   --> $DIR/option_map_unit_fn_fixable.rs:77:5
    |
 LL |     x.field.map(|value| { { plus_one(value + captured); } });
@@ -128,7 +128,7 @@ LL |     x.field.map(|value| { { plus_one(value + captured); } });
    |     |
    |     help: try this: `if let Some(value) = x.field { plus_one(value + captured); }`
 
-error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type
+error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
   --> $DIR/option_map_unit_fn_fixable.rs:80:5
    |
 LL |     x.field.map(|ref value| { do_nothing(value + captured) });
@@ -136,7 +136,7 @@ LL |     x.field.map(|ref value| { do_nothing(value + captured) });
    |     |
    |     help: try this: `if let Some(ref value) = x.field { do_nothing(value + captured) }`
 
-error: called `map(f)` on an `Option` value where `f` is a function that returns the unit type
+error: called `map(f)` on an `Option` value where `f` is a function that returns the unit type `()`
   --> $DIR/option_map_unit_fn_fixable.rs:82:5
    |
 LL |     option().map(do_nothing);}
diff --git a/tests/ui/result_map_unit_fn_fixable.stderr b/tests/ui/result_map_unit_fn_fixable.stderr
index 467e00263cd..4f3a8c6b792 100644
--- a/tests/ui/result_map_unit_fn_fixable.stderr
+++ b/tests/ui/result_map_unit_fn_fixable.stderr
@@ -1,4 +1,4 @@
-error: called `map(f)` on an `Result` value where `f` is a function that returns the unit type
+error: called `map(f)` on an `Result` value where `f` is a function that returns the unit type `()`
   --> $DIR/result_map_unit_fn_fixable.rs:35:5
    |
 LL |     x.field.map(do_nothing);
@@ -8,7 +8,7 @@ LL |     x.field.map(do_nothing);
    |
    = note: `-D clippy::result-map-unit-fn` implied by `-D warnings`
 
-error: called `map(f)` on an `Result` value where `f` is a function that returns the unit type
+error: called `map(f)` on an `Result` value where `f` is a function that returns the unit type `()`
   --> $DIR/result_map_unit_fn_fixable.rs:37:5
    |
 LL |     x.field.map(do_nothing);
@@ -16,7 +16,7 @@ LL |     x.field.map(do_nothing);
    |     |
    |     help: try this: `if let Ok(x_field) = x.field { do_nothing(x_field) }`
 
-error: called `map(f)` on an `Result` value where `f` is a function that returns the unit type
+error: called `map(f)` on an `Result` value where `f` is a function that returns the unit type `()`
   --> $DIR/result_map_unit_fn_fixable.rs:39:5
    |
 LL |     x.field.map(diverge);
@@ -24,7 +24,7 @@ LL |     x.field.map(diverge);
    |     |
    |     help: try this: `if let Ok(x_field) = x.field { diverge(x_field) }`
 
-error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type
+error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type `()`
   --> $DIR/result_map_unit_fn_fixable.rs:45:5
    |
 LL |     x.field.map(|value| x.do_result_nothing(value + captured));
@@ -32,7 +32,7 @@ LL |     x.field.map(|value| x.do_result_nothing(value + captured));
    |     |
    |     help: try this: `if let Ok(value) = x.field { x.do_result_nothing(value + captured) }`
 
-error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type
+error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type `()`
   --> $DIR/result_map_unit_fn_fixable.rs:47:5
    |
 LL |     x.field.map(|value| { x.do_result_plus_one(value + captured); });
@@ -40,7 +40,7 @@ LL |     x.field.map(|value| { x.do_result_plus_one(value + captured); });
    |     |
    |     help: try this: `if let Ok(value) = x.field { x.do_result_plus_one(value + captured); }`
 
-error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type
+error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type `()`
   --> $DIR/result_map_unit_fn_fixable.rs:50:5
    |
 LL |     x.field.map(|value| do_nothing(value + captured));
@@ -48,7 +48,7 @@ LL |     x.field.map(|value| do_nothing(value + captured));
    |     |
    |     help: try this: `if let Ok(value) = x.field { do_nothing(value + captured) }`
 
-error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type
+error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type `()`
   --> $DIR/result_map_unit_fn_fixable.rs:52:5
    |
 LL |     x.field.map(|value| { do_nothing(value + captured) });
@@ -56,7 +56,7 @@ LL |     x.field.map(|value| { do_nothing(value + captured) });
    |     |
    |     help: try this: `if let Ok(value) = x.field { do_nothing(value + captured) }`
 
-error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type
+error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type `()`
   --> $DIR/result_map_unit_fn_fixable.rs:54:5
    |
 LL |     x.field.map(|value| { do_nothing(value + captured); });
@@ -64,7 +64,7 @@ LL |     x.field.map(|value| { do_nothing(value + captured); });
    |     |
    |     help: try this: `if let Ok(value) = x.field { do_nothing(value + captured); }`
 
-error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type
+error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type `()`
   --> $DIR/result_map_unit_fn_fixable.rs:56:5
    |
 LL |     x.field.map(|value| { { do_nothing(value + captured); } });
@@ -72,7 +72,7 @@ LL |     x.field.map(|value| { { do_nothing(value + captured); } });
    |     |
    |     help: try this: `if let Ok(value) = x.field { do_nothing(value + captured); }`
 
-error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type
+error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type `()`
   --> $DIR/result_map_unit_fn_fixable.rs:59:5
    |
 LL |     x.field.map(|value| diverge(value + captured));
@@ -80,7 +80,7 @@ LL |     x.field.map(|value| diverge(value + captured));
    |     |
    |     help: try this: `if let Ok(value) = x.field { diverge(value + captured) }`
 
-error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type
+error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type `()`
   --> $DIR/result_map_unit_fn_fixable.rs:61:5
    |
 LL |     x.field.map(|value| { diverge(value + captured) });
@@ -88,7 +88,7 @@ LL |     x.field.map(|value| { diverge(value + captured) });
    |     |
    |     help: try this: `if let Ok(value) = x.field { diverge(value + captured) }`
 
-error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type
+error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type `()`
   --> $DIR/result_map_unit_fn_fixable.rs:63:5
    |
 LL |     x.field.map(|value| { diverge(value + captured); });
@@ -96,7 +96,7 @@ LL |     x.field.map(|value| { diverge(value + captured); });
    |     |
    |     help: try this: `if let Ok(value) = x.field { diverge(value + captured); }`
 
-error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type
+error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type `()`
   --> $DIR/result_map_unit_fn_fixable.rs:65:5
    |
 LL |     x.field.map(|value| { { diverge(value + captured); } });
@@ -104,7 +104,7 @@ LL |     x.field.map(|value| { { diverge(value + captured); } });
    |     |
    |     help: try this: `if let Ok(value) = x.field { diverge(value + captured); }`
 
-error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type
+error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type `()`
   --> $DIR/result_map_unit_fn_fixable.rs:70:5
    |
 LL |     x.field.map(|value| { let y = plus_one(value + captured); });
@@ -112,7 +112,7 @@ LL |     x.field.map(|value| { let y = plus_one(value + captured); });
    |     |
    |     help: try this: `if let Ok(value) = x.field { let y = plus_one(value + captured); }`
 
-error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type
+error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type `()`
   --> $DIR/result_map_unit_fn_fixable.rs:72:5
    |
 LL |     x.field.map(|value| { plus_one(value + captured); });
@@ -120,7 +120,7 @@ LL |     x.field.map(|value| { plus_one(value + captured); });
    |     |
    |     help: try this: `if let Ok(value) = x.field { plus_one(value + captured); }`
 
-error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type
+error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type `()`
   --> $DIR/result_map_unit_fn_fixable.rs:74:5
    |
 LL |     x.field.map(|value| { { plus_one(value + captured); } });
@@ -128,7 +128,7 @@ LL |     x.field.map(|value| { { plus_one(value + captured); } });
    |     |
    |     help: try this: `if let Ok(value) = x.field { plus_one(value + captured); }`
 
-error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type
+error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type `()`
   --> $DIR/result_map_unit_fn_fixable.rs:77:5
    |
 LL |     x.field.map(|ref value| { do_nothing(value + captured) });
diff --git a/tests/ui/result_map_unit_fn_unfixable.stderr b/tests/ui/result_map_unit_fn_unfixable.stderr
index b23cc608621..88e4efdb0f0 100644
--- a/tests/ui/result_map_unit_fn_unfixable.stderr
+++ b/tests/ui/result_map_unit_fn_unfixable.stderr
@@ -1,4 +1,4 @@
-error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type
+error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type `()`
   --> $DIR/result_map_unit_fn_unfixable.rs:23:5
    |
 LL |     x.field.map(|value| { do_nothing(value); do_nothing(value) });
@@ -8,7 +8,7 @@ LL |     x.field.map(|value| { do_nothing(value); do_nothing(value) });
    |
    = note: `-D clippy::result-map-unit-fn` implied by `-D warnings`
 
-error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type
+error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type `()`
   --> $DIR/result_map_unit_fn_unfixable.rs:25:5
    |
 LL |     x.field.map(|value| if value > 0 { do_nothing(value); do_nothing(value) });
@@ -16,7 +16,7 @@ LL |     x.field.map(|value| if value > 0 { do_nothing(value); do_nothing(value)
    |     |
    |     help: try this: `if let Ok(value) = x.field { ... }`
 
-error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type
+error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type `()`
   --> $DIR/result_map_unit_fn_unfixable.rs:29:5
    |
 LL |        x.field.map(|value| {
@@ -30,7 +30,7 @@ LL | ||     });
    | |_______|
    | 
 
-error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type
+error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type `()`
   --> $DIR/result_map_unit_fn_unfixable.rs:33:5
    |
 LL |     x.field.map(|value| { do_nothing(value); do_nothing(value); });
@@ -38,7 +38,7 @@ LL |     x.field.map(|value| { do_nothing(value); do_nothing(value); });
    |     |
    |     help: try this: `if let Ok(value) = x.field { ... }`
 
-error: called `map(f)` on an `Result` value where `f` is a function that returns the unit type
+error: called `map(f)` on an `Result` value where `f` is a function that returns the unit type `()`
   --> $DIR/result_map_unit_fn_unfixable.rs:37:5
    |
 LL |     "12".parse::<i32>().map(diverge);
@@ -46,7 +46,7 @@ LL |     "12".parse::<i32>().map(diverge);
    |     |
    |     help: try this: `if let Ok(a) = "12".parse::<i32>() { diverge(a) }`
 
-error: called `map(f)` on an `Result` value where `f` is a function that returns the unit type
+error: called `map(f)` on an `Result` value where `f` is a function that returns the unit type `()`
   --> $DIR/result_map_unit_fn_unfixable.rs:43:5
    |
 LL |     y.map(do_nothing);
-- 
cgit 1.4.1-3-g733a5


From 3550568a548091ec4ae738827b50a84e9ddf0b8f Mon Sep 17 00:00:00 2001
From: Vali Schneider <eval@fb.com>
Date: Wed, 9 Sep 2020 14:02:34 -0700
Subject: removing if chain and renaming lint

---
 CHANGELOG.md                           |   2 +-
 clippy_lints/src/lib.rs                |   8 +--
 clippy_lints/src/panic_in_result.rs    |  97 ------------------------------
 clippy_lints/src/panic_in_result_fn.rs |  90 ++++++++++++++++++++++++++++
 src/lintlist/mod.rs                    |   4 +-
 tests/ui/panic_in_result.rs            |  70 ----------------------
 tests/ui/panic_in_result.stderr        | 105 ---------------------------------
 tests/ui/panic_in_result_fn.rs         |  70 ++++++++++++++++++++++
 tests/ui/panic_in_result_fn.stderr     | 105 +++++++++++++++++++++++++++++++++
 9 files changed, 272 insertions(+), 279 deletions(-)
 delete mode 100644 clippy_lints/src/panic_in_result.rs
 create mode 100644 clippy_lints/src/panic_in_result_fn.rs
 delete mode 100644 tests/ui/panic_in_result.rs
 delete mode 100644 tests/ui/panic_in_result.stderr
 create mode 100644 tests/ui/panic_in_result_fn.rs
 create mode 100644 tests/ui/panic_in_result_fn.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 7af3b666cca..d4f0ff4ba78 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1651,7 +1651,7 @@ Released 2018-09-13
 [`out_of_bounds_indexing`]: https://rust-lang.github.io/rust-clippy/master/index.html#out_of_bounds_indexing
 [`overflow_check_conditional`]: https://rust-lang.github.io/rust-clippy/master/index.html#overflow_check_conditional
 [`panic`]: https://rust-lang.github.io/rust-clippy/master/index.html#panic
-[`panic_in_result`]: https://rust-lang.github.io/rust-clippy/master/index.html#panic_in_result
+[`panic_in_result_fn`]: https://rust-lang.github.io/rust-clippy/master/index.html#panic_in_result
 [`panic_params`]: https://rust-lang.github.io/rust-clippy/master/index.html#panic_params
 [`panicking_unwrap`]: https://rust-lang.github.io/rust-clippy/master/index.html#panicking_unwrap
 [`partialeq_ne_impl`]: https://rust-lang.github.io/rust-clippy/master/index.html#partialeq_ne_impl
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index b70d126af5b..dbe17e6bbfe 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -267,7 +267,7 @@ mod open_options;
 mod option_env_unwrap;
 mod option_if_let_else;
 mod overflow_check_conditional;
-mod panic_in_result;
+mod panic_in_result_fn;
 mod panic_unimplemented;
 mod partialeq_ne_impl;
 mod path_buf_push_overwrite;
@@ -748,7 +748,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &option_env_unwrap::OPTION_ENV_UNWRAP,
         &option_if_let_else::OPTION_IF_LET_ELSE,
         &overflow_check_conditional::OVERFLOW_CHECK_CONDITIONAL,
-        &panic_in_result::PANIC_IN_RESULT,
+        &panic_in_result_fn::PANIC_IN_RESULT_FN,
         &panic_unimplemented::PANIC,
         &panic_unimplemented::PANIC_PARAMS,
         &panic_unimplemented::TODO,
@@ -1088,7 +1088,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box manual_async_fn::ManualAsyncFn);
     store.register_early_pass(|| box redundant_field_names::RedundantFieldNames);
     store.register_late_pass(|| box vec_resize_to_zero::VecResizeToZero);
-    store.register_late_pass(|| box panic_in_result::PanicInResult);
+    store.register_late_pass(|| box panic_in_result_fn::PanicInResultFn);
 
     let single_char_binding_names_threshold = conf.single_char_binding_names_threshold;
     store.register_early_pass(move || box non_expressive_names::NonExpressiveNames {
@@ -1132,7 +1132,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&missing_doc::MISSING_DOCS_IN_PRIVATE_ITEMS),
         LintId::of(&missing_inline::MISSING_INLINE_IN_PUBLIC_ITEMS),
         LintId::of(&modulo_arithmetic::MODULO_ARITHMETIC),
-        LintId::of(&panic_in_result::PANIC_IN_RESULT),
+        LintId::of(&panic_in_result_fn::PANIC_IN_RESULT_FN),
         LintId::of(&panic_unimplemented::PANIC),
         LintId::of(&panic_unimplemented::TODO),
         LintId::of(&panic_unimplemented::UNIMPLEMENTED),
diff --git a/clippy_lints/src/panic_in_result.rs b/clippy_lints/src/panic_in_result.rs
deleted file mode 100644
index 8b8e211cb72..00000000000
--- a/clippy_lints/src/panic_in_result.rs
+++ /dev/null
@@ -1,97 +0,0 @@
-use crate::utils::{is_expn_of, is_type_diagnostic_item, return_ty, span_lint_and_then};
-use if_chain::if_chain;
-use rustc_hir as hir;
-use rustc_hir::intravisit::{self, FnKind, NestedVisitorMap, Visitor};
-use rustc_hir::Expr;
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::hir::map::Map;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::Span;
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for usage of `panic!`, `unimplemented!`, `todo!` or `unreachable!` in a function of type result.
-    ///
-    /// **Why is this bad?** For some codebases, it is desirable for functions of type result to return an error instead of crashing. Hence unimplemented, panic and unreachable should be avoided.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
-    /// ```rust
-    /// fn result_with_panic() -> Result<bool, String>
-    /// {
-    ///     panic!("error");
-    /// }
-    /// ```
-    pub PANIC_IN_RESULT,
-    restriction,
-    "functions of type `Result<..>` that contain `panic!()`, `todo!()` or `unreachable()` or `unimplemented()` "
-}
-
-declare_lint_pass!(PanicInResult => [PANIC_IN_RESULT]);
-
-impl<'tcx> LateLintPass<'tcx> for PanicInResult {
-    fn check_fn(
-        &mut self,
-        cx: &LateContext<'tcx>,
-        fn_kind: FnKind<'tcx>,
-        _: &'tcx hir::FnDecl<'tcx>,
-        body: &'tcx hir::Body<'tcx>,
-        span: Span,
-        hir_id: hir::HirId,
-    ) {
-        if let FnKind::Closure(_) = fn_kind {
-            return;
-        }
-        if_chain! {
-            if is_type_diagnostic_item(cx, return_ty(cx, hir_id), sym!(result_type));
-            then
-            {
-                lint_impl_body(cx, span, body);
-            }
-        }
-    }
-}
-
-struct FindPanicUnimplementedUnreachable {
-    result: Vec<Span>,
-}
-
-impl<'tcx> Visitor<'tcx> for FindPanicUnimplementedUnreachable {
-    type Map = Map<'tcx>;
-
-    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
-        if is_expn_of(expr.span, "unimplemented").is_some()
-            || is_expn_of(expr.span, "unreachable").is_some()
-            || is_expn_of(expr.span, "panic").is_some()
-            || is_expn_of(expr.span, "todo").is_some()
-        {
-            self.result.push(expr.span);
-        }
-        // and check sub-expressions
-        intravisit::walk_expr(self, expr);
-    }
-
-    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-        NestedVisitorMap::None
-    }
-}
-
-fn lint_impl_body<'tcx>(cx: &LateContext<'tcx>, impl_span: Span, body: &'tcx hir::Body<'tcx>) {
-    let mut panics = FindPanicUnimplementedUnreachable { result: Vec::new() };
-    panics.visit_expr(&body.value);
-    if !panics.result.is_empty() {
-        span_lint_and_then(
-            cx,
-            PANIC_IN_RESULT,
-            impl_span,
-            "used `unimplemented!()`, `unreachable!()`, `todo!()` or `panic!()` in a function that returns `Result`",
-            move |diag| {
-                diag.help(
-                    "`unimplemented!()`, `unreachable!()`, `todo!()` or `panic!()` should not be used in a function that returns `Result` as `Result` is expected to return an error instead of crashing",
-                );
-                diag.span_note(panics.result, "return Err() instead of panicking");
-            },
-        );
-    }
-}
diff --git a/clippy_lints/src/panic_in_result_fn.rs b/clippy_lints/src/panic_in_result_fn.rs
new file mode 100644
index 00000000000..4077aba6ef1
--- /dev/null
+++ b/clippy_lints/src/panic_in_result_fn.rs
@@ -0,0 +1,90 @@
+use crate::utils::{is_expn_of, is_type_diagnostic_item, return_ty, span_lint_and_then};
+use rustc_hir as hir;
+use rustc_hir::intravisit::{self, FnKind, NestedVisitorMap, Visitor};
+use rustc_hir::Expr;
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::hir::map::Map;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::Span;
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for usage of `panic!`, `unimplemented!`, `todo!` or `unreachable!` in a function of type result.
+    ///
+    /// **Why is this bad?** For some codebases, it is desirable for functions of type result to return an error instead of crashing. Hence unimplemented, panic and unreachable should be avoided.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// fn result_with_panic() -> Result<bool, String>
+    /// {
+    ///     panic!("error");
+    /// }
+    /// ```
+    pub PANIC_IN_RESULT_FN,
+    restriction,
+    "functions of type `Result<..>` that contain `panic!()`, `todo!()` or `unreachable()` or `unimplemented()` "
+}
+
+declare_lint_pass!(PanicInResultFn  => [PANIC_IN_RESULT_FN]);
+
+impl<'tcx> LateLintPass<'tcx> for PanicInResultFn {
+    fn check_fn(
+        &mut self,
+        cx: &LateContext<'tcx>,
+        fn_kind: FnKind<'tcx>,
+        _: &'tcx hir::FnDecl<'tcx>,
+        body: &'tcx hir::Body<'tcx>,
+        span: Span,
+        hir_id: hir::HirId,
+    ) {
+        if !matches!(fn_kind, FnKind::Closure(_))
+            && is_type_diagnostic_item(cx, return_ty(cx, hir_id), sym!(result_type))
+        {
+            lint_impl_body(cx, span, body);
+        }
+    }
+}
+
+struct FindPanicUnimplementedUnreachable {
+    result: Vec<Span>,
+}
+
+impl<'tcx> Visitor<'tcx> for FindPanicUnimplementedUnreachable {
+    type Map = Map<'tcx>;
+
+    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
+        if ["unimplemented", "unreachable", "panic", "todo"]
+            .iter()
+            .any(|fun| is_expn_of(expr.span, fun).is_some())
+        {
+            self.result.push(expr.span);
+        }
+        // and check sub-expressions
+        intravisit::walk_expr(self, expr);
+    }
+
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::None
+    }
+}
+
+fn lint_impl_body<'tcx>(cx: &LateContext<'tcx>, impl_span: Span, body: &'tcx hir::Body<'tcx>) {
+    let mut panics = FindPanicUnimplementedUnreachable { result: Vec::new() };
+    panics.visit_expr(&body.value);
+    if !panics.result.is_empty() {
+        span_lint_and_then(
+            cx,
+            PANIC_IN_RESULT_FN,
+            impl_span,
+            "used `unimplemented!()`, `unreachable!()`, `todo!()` or `panic!()` in a function that returns `Result`",
+            move |diag| {
+                diag.help(
+                    "`unimplemented!()`, `unreachable!()`, `todo!()` or `panic!()` should not be used in a function that returns `Result` as `Result` is expected to return an error instead of crashing",
+                );
+                diag.span_note(panics.result, "return Err() instead of panicking");
+            },
+        );
+    }
+}
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index 1f56c56f081..4d6c45761e6 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -1705,11 +1705,11 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
         module: "panic_unimplemented",
     },
     Lint {
-        name: "panic_in_result",
+        name: "panic_in_result_fn",
         group: "restriction",
         desc: "functions of type `Result<..>` that contain `panic!()`, `todo!()` or `unreachable()` or `unimplemented()` ",
         deprecation: None,
-        module: "panic_in_result",
+        module: "panic_in_result_fn",
     },
     Lint {
         name: "panic_params",
diff --git a/tests/ui/panic_in_result.rs b/tests/ui/panic_in_result.rs
deleted file mode 100644
index f6fb2f1ab61..00000000000
--- a/tests/ui/panic_in_result.rs
+++ /dev/null
@@ -1,70 +0,0 @@
-#![warn(clippy::panic_in_result)]
-
-struct A;
-
-impl A {
-    fn result_with_panic() -> Result<bool, String> // should emit lint
-    {
-        panic!("error");
-    }
-
-    fn result_with_unimplemented() -> Result<bool, String> // should emit lint
-    {
-        unimplemented!();
-    }
-
-    fn result_with_unreachable() -> Result<bool, String> // should emit lint
-    {
-        unreachable!();
-    }
-
-    fn result_with_todo() -> Result<bool, String> // should emit lint
-    {
-        todo!("Finish this");
-    }
-
-    fn other_with_panic() // should not emit lint
-    {
-        panic!("");
-    }
-
-    fn other_with_unreachable() // should not emit lint
-    {
-        unreachable!();
-    }
-
-    fn other_with_unimplemented() // should not emit lint
-    {
-        unimplemented!();
-    }
-
-    fn other_with_todo() // should not emit lint
-    {
-        todo!("finish this")
-    }
-
-    fn result_without_banned_functions() -> Result<bool, String> // should not emit lint
-    {
-        Ok(true)
-    }
-}
-
-fn function_result_with_panic() -> Result<bool, String> // should emit lint
-{
-    panic!("error");
-}
-
-fn todo() {
-    println!("something");
-}
-
-fn function_result_with_custom_todo() -> Result<bool, String> // should not emit lint
-{
-    todo();
-    Ok(true)
-}
-
-fn main() -> Result<(), String> {
-    todo!("finish main method");
-    Ok(())
-}
diff --git a/tests/ui/panic_in_result.stderr b/tests/ui/panic_in_result.stderr
deleted file mode 100644
index 9faedf82986..00000000000
--- a/tests/ui/panic_in_result.stderr
+++ /dev/null
@@ -1,105 +0,0 @@
-error: used `unimplemented!()`, `unreachable!()`, `todo!()` or `panic!()` in a function that returns `Result`
-  --> $DIR/panic_in_result.rs:6:5
-   |
-LL | /     fn result_with_panic() -> Result<bool, String> // should emit lint
-LL | |     {
-LL | |         panic!("error");
-LL | |     }
-   | |_____^
-   |
-   = note: `-D clippy::panic-in-result` implied by `-D warnings`
-   = help: `unimplemented!()`, `unreachable!()`, `todo!()` or `panic!()` should not be used in a function that returns `Result` as `Result` is expected to return an error instead of crashing
-note: return Err() instead of panicking
-  --> $DIR/panic_in_result.rs:8:9
-   |
-LL |         panic!("error");
-   |         ^^^^^^^^^^^^^^^^
-   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
-
-error: used `unimplemented!()`, `unreachable!()`, `todo!()` or `panic!()` in a function that returns `Result`
-  --> $DIR/panic_in_result.rs:11:5
-   |
-LL | /     fn result_with_unimplemented() -> Result<bool, String> // should emit lint
-LL | |     {
-LL | |         unimplemented!();
-LL | |     }
-   | |_____^
-   |
-   = help: `unimplemented!()`, `unreachable!()`, `todo!()` or `panic!()` should not be used in a function that returns `Result` as `Result` is expected to return an error instead of crashing
-note: return Err() instead of panicking
-  --> $DIR/panic_in_result.rs:13:9
-   |
-LL |         unimplemented!();
-   |         ^^^^^^^^^^^^^^^^^
-   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
-
-error: used `unimplemented!()`, `unreachable!()`, `todo!()` or `panic!()` in a function that returns `Result`
-  --> $DIR/panic_in_result.rs:16:5
-   |
-LL | /     fn result_with_unreachable() -> Result<bool, String> // should emit lint
-LL | |     {
-LL | |         unreachable!();
-LL | |     }
-   | |_____^
-   |
-   = help: `unimplemented!()`, `unreachable!()`, `todo!()` or `panic!()` should not be used in a function that returns `Result` as `Result` is expected to return an error instead of crashing
-note: return Err() instead of panicking
-  --> $DIR/panic_in_result.rs:18:9
-   |
-LL |         unreachable!();
-   |         ^^^^^^^^^^^^^^^
-   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
-
-error: used `unimplemented!()`, `unreachable!()`, `todo!()` or `panic!()` in a function that returns `Result`
-  --> $DIR/panic_in_result.rs:21:5
-   |
-LL | /     fn result_with_todo() -> Result<bool, String> // should emit lint
-LL | |     {
-LL | |         todo!("Finish this");
-LL | |     }
-   | |_____^
-   |
-   = help: `unimplemented!()`, `unreachable!()`, `todo!()` or `panic!()` should not be used in a function that returns `Result` as `Result` is expected to return an error instead of crashing
-note: return Err() instead of panicking
-  --> $DIR/panic_in_result.rs:23:9
-   |
-LL |         todo!("Finish this");
-   |         ^^^^^^^^^^^^^^^^^^^^^
-   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
-
-error: used `unimplemented!()`, `unreachable!()`, `todo!()` or `panic!()` in a function that returns `Result`
-  --> $DIR/panic_in_result.rs:52:1
-   |
-LL | / fn function_result_with_panic() -> Result<bool, String> // should emit lint
-LL | | {
-LL | |     panic!("error");
-LL | | }
-   | |_^
-   |
-   = help: `unimplemented!()`, `unreachable!()`, `todo!()` or `panic!()` should not be used in a function that returns `Result` as `Result` is expected to return an error instead of crashing
-note: return Err() instead of panicking
-  --> $DIR/panic_in_result.rs:54:5
-   |
-LL |     panic!("error");
-   |     ^^^^^^^^^^^^^^^^
-   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
-
-error: used `unimplemented!()`, `unreachable!()`, `todo!()` or `panic!()` in a function that returns `Result`
-  --> $DIR/panic_in_result.rs:67:1
-   |
-LL | / fn main() -> Result<(), String> {
-LL | |     todo!("finish main method");
-LL | |     Ok(())
-LL | | }
-   | |_^
-   |
-   = help: `unimplemented!()`, `unreachable!()`, `todo!()` or `panic!()` should not be used in a function that returns `Result` as `Result` is expected to return an error instead of crashing
-note: return Err() instead of panicking
-  --> $DIR/panic_in_result.rs:68:5
-   |
-LL |     todo!("finish main method");
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
-
-error: aborting due to 6 previous errors
-
diff --git a/tests/ui/panic_in_result_fn.rs b/tests/ui/panic_in_result_fn.rs
new file mode 100644
index 00000000000..287726f7a2d
--- /dev/null
+++ b/tests/ui/panic_in_result_fn.rs
@@ -0,0 +1,70 @@
+#![warn(clippy::panic_in_result_fn)]
+
+struct A;
+
+impl A {
+    fn result_with_panic() -> Result<bool, String> // should emit lint
+    {
+        panic!("error");
+    }
+
+    fn result_with_unimplemented() -> Result<bool, String> // should emit lint
+    {
+        unimplemented!();
+    }
+
+    fn result_with_unreachable() -> Result<bool, String> // should emit lint
+    {
+        unreachable!();
+    }
+
+    fn result_with_todo() -> Result<bool, String> // should emit lint
+    {
+        todo!("Finish this");
+    }
+
+    fn other_with_panic() // should not emit lint
+    {
+        panic!("");
+    }
+
+    fn other_with_unreachable() // should not emit lint
+    {
+        unreachable!();
+    }
+
+    fn other_with_unimplemented() // should not emit lint
+    {
+        unimplemented!();
+    }
+
+    fn other_with_todo() // should not emit lint
+    {
+        todo!("finish this")
+    }
+
+    fn result_without_banned_functions() -> Result<bool, String> // should not emit lint
+    {
+        Ok(true)
+    }
+}
+
+fn function_result_with_panic() -> Result<bool, String> // should emit lint
+{
+    panic!("error");
+}
+
+fn todo() {
+    println!("something");
+}
+
+fn function_result_with_custom_todo() -> Result<bool, String> // should not emit lint
+{
+    todo();
+    Ok(true)
+}
+
+fn main() -> Result<(), String> {
+    todo!("finish main method");
+    Ok(())
+}
diff --git a/tests/ui/panic_in_result_fn.stderr b/tests/ui/panic_in_result_fn.stderr
new file mode 100644
index 00000000000..c6936fd8692
--- /dev/null
+++ b/tests/ui/panic_in_result_fn.stderr
@@ -0,0 +1,105 @@
+error: used `unimplemented!()`, `unreachable!()`, `todo!()` or `panic!()` in a function that returns `Result`
+  --> $DIR/panic_in_result_fn.rs:6:5
+   |
+LL | /     fn result_with_panic() -> Result<bool, String> // should emit lint
+LL | |     {
+LL | |         panic!("error");
+LL | |     }
+   | |_____^
+   |
+   = note: `-D clippy::panic-in-result-fn` implied by `-D warnings`
+   = help: `unimplemented!()`, `unreachable!()`, `todo!()` or `panic!()` should not be used in a function that returns `Result` as `Result` is expected to return an error instead of crashing
+note: return Err() instead of panicking
+  --> $DIR/panic_in_result_fn.rs:8:9
+   |
+LL |         panic!("error");
+   |         ^^^^^^^^^^^^^^^^
+   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: used `unimplemented!()`, `unreachable!()`, `todo!()` or `panic!()` in a function that returns `Result`
+  --> $DIR/panic_in_result_fn.rs:11:5
+   |
+LL | /     fn result_with_unimplemented() -> Result<bool, String> // should emit lint
+LL | |     {
+LL | |         unimplemented!();
+LL | |     }
+   | |_____^
+   |
+   = help: `unimplemented!()`, `unreachable!()`, `todo!()` or `panic!()` should not be used in a function that returns `Result` as `Result` is expected to return an error instead of crashing
+note: return Err() instead of panicking
+  --> $DIR/panic_in_result_fn.rs:13:9
+   |
+LL |         unimplemented!();
+   |         ^^^^^^^^^^^^^^^^^
+   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: used `unimplemented!()`, `unreachable!()`, `todo!()` or `panic!()` in a function that returns `Result`
+  --> $DIR/panic_in_result_fn.rs:16:5
+   |
+LL | /     fn result_with_unreachable() -> Result<bool, String> // should emit lint
+LL | |     {
+LL | |         unreachable!();
+LL | |     }
+   | |_____^
+   |
+   = help: `unimplemented!()`, `unreachable!()`, `todo!()` or `panic!()` should not be used in a function that returns `Result` as `Result` is expected to return an error instead of crashing
+note: return Err() instead of panicking
+  --> $DIR/panic_in_result_fn.rs:18:9
+   |
+LL |         unreachable!();
+   |         ^^^^^^^^^^^^^^^
+   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: used `unimplemented!()`, `unreachable!()`, `todo!()` or `panic!()` in a function that returns `Result`
+  --> $DIR/panic_in_result_fn.rs:21:5
+   |
+LL | /     fn result_with_todo() -> Result<bool, String> // should emit lint
+LL | |     {
+LL | |         todo!("Finish this");
+LL | |     }
+   | |_____^
+   |
+   = help: `unimplemented!()`, `unreachable!()`, `todo!()` or `panic!()` should not be used in a function that returns `Result` as `Result` is expected to return an error instead of crashing
+note: return Err() instead of panicking
+  --> $DIR/panic_in_result_fn.rs:23:9
+   |
+LL |         todo!("Finish this");
+   |         ^^^^^^^^^^^^^^^^^^^^^
+   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: used `unimplemented!()`, `unreachable!()`, `todo!()` or `panic!()` in a function that returns `Result`
+  --> $DIR/panic_in_result_fn.rs:52:1
+   |
+LL | / fn function_result_with_panic() -> Result<bool, String> // should emit lint
+LL | | {
+LL | |     panic!("error");
+LL | | }
+   | |_^
+   |
+   = help: `unimplemented!()`, `unreachable!()`, `todo!()` or `panic!()` should not be used in a function that returns `Result` as `Result` is expected to return an error instead of crashing
+note: return Err() instead of panicking
+  --> $DIR/panic_in_result_fn.rs:54:5
+   |
+LL |     panic!("error");
+   |     ^^^^^^^^^^^^^^^^
+   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: used `unimplemented!()`, `unreachable!()`, `todo!()` or `panic!()` in a function that returns `Result`
+  --> $DIR/panic_in_result_fn.rs:67:1
+   |
+LL | / fn main() -> Result<(), String> {
+LL | |     todo!("finish main method");
+LL | |     Ok(())
+LL | | }
+   | |_^
+   |
+   = help: `unimplemented!()`, `unreachable!()`, `todo!()` or `panic!()` should not be used in a function that returns `Result` as `Result` is expected to return an error instead of crashing
+note: return Err() instead of panicking
+  --> $DIR/panic_in_result_fn.rs:68:5
+   |
+LL |     todo!("finish main method");
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: aborting due to 6 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 6211599ccafee5b2429bfb1bbeb48ead32a48484 Mon Sep 17 00:00:00 2001
From: Thom Chiovoloni <chiovolonit@gmail.com>
Date: Wed, 9 Sep 2020 14:00:31 -0700
Subject: Extend invalid_atomic_ordering to detect misuse of
 compare_exchange{,_weak}

---
 clippy_lints/src/atomic_ordering.rs      |  82 +++++++++-
 tests/ui/atomic_ordering_exchange.rs     |  84 ++++++++++
 tests/ui/atomic_ordering_exchange.stderr | 259 +++++++++++++++++++++++++++++++
 3 files changed, 423 insertions(+), 2 deletions(-)
 create mode 100644 tests/ui/atomic_ordering_exchange.rs
 create mode 100644 tests/ui/atomic_ordering_exchange.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/atomic_ordering.rs b/clippy_lints/src/atomic_ordering.rs
index 2d964ac2b9f..748f45f47c2 100644
--- a/clippy_lints/src/atomic_ordering.rs
+++ b/clippy_lints/src/atomic_ordering.rs
@@ -8,7 +8,7 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for usage of invalid atomic
-    /// ordering in atomic loads/stores and memory fences.
+    /// ordering in atomic loads/stores/exchanges and memory fences
     ///
     /// **Why is this bad?** Using an invalid atomic ordering
     /// will cause a panic at run-time.
@@ -29,10 +29,13 @@ declare_clippy_lint! {
     ///
     /// atomic::fence(Ordering::Relaxed);
     /// atomic::compiler_fence(Ordering::Relaxed);
+    ///
+    /// let _ = x.compare_exchange(false, false, Ordering::Relaxed, Ordering::SeqCst);
+    /// let _ = x.compare_exchange_weak(false, true, Ordering::SeqCst, Ordering::Release);
     /// ```
     pub INVALID_ATOMIC_ORDERING,
     correctness,
-    "usage of invalid atomic ordering in atomic loads/stores and memory fences"
+    "usage of invalid atomic ordering in atomic loads/stores/exchanges ane memory fences"
 }
 
 declare_lint_pass!(AtomicOrdering => [INVALID_ATOMIC_ORDERING]);
@@ -127,9 +130,84 @@ fn check_memory_fence(cx: &LateContext<'_>, expr: &Expr<'_>) {
     }
 }
 
+fn opt_ordering_defid(cx: &LateContext<'_>, ord_arg: &Expr<'_>) -> Option<DefId> {
+    if let ExprKind::Path(ref ord_qpath) = ord_arg.kind {
+        cx.qpath_res(ord_qpath, ord_arg.hir_id).opt_def_id()
+    } else {
+        None
+    }
+}
+fn check_atomic_compare_exchange(cx: &LateContext<'_>, expr: &Expr<'_>) {
+    if_chain! {
+        if let ExprKind::MethodCall(ref method_path, _, args, _) = &expr.kind;
+        let method = method_path.ident.name.as_str();
+        if type_is_atomic(cx, &args[0]);
+        if method == "compare_exchange" || method == "compare_exchange_weak";
+        let failure_order_arg = &args[4];
+        if let Some(fail_ordering_def_id) = opt_ordering_defid(cx, failure_order_arg);
+        then {
+            // Helper type holding on to some checking and error reporting data. Has
+            // - (success ordering name,
+            // - list of failure orderings forbidden by the success order,
+            // - suggestion message)
+            type OrdLintInfo = (&'static str, &'static [&'static str], &'static str);
+            let relaxed: OrdLintInfo = ("Relaxed", &["SeqCst", "Acquire"], "ordering mode `Relaxed`");
+            let acquire: OrdLintInfo = ("Acquire", &["SeqCst"], "ordering modes `Acquire` or `Relaxed`");
+            let seq_cst: OrdLintInfo = ("SeqCst", &[], "ordering modes `Acquire`, `SeqCst` or `Relaxed`");
+            let release = ("Release", relaxed.1, relaxed.2);
+            let acqrel = ("AcqRel", acquire.1, acquire.2);
+            let search = [relaxed, acquire, seq_cst, release, acqrel];
+
+            let success_lint_info = opt_ordering_defid(cx, &args[3])
+                .and_then(|success_ord_def_id| -> Option<OrdLintInfo> {
+                    search
+                        .iter()
+                        .find(|(ordering, ..)| {
+                            match_def_path(cx, success_ord_def_id,
+                                &["core", "sync", "atomic", "Ordering", ordering])
+                        })
+                        .copied()
+                });
+
+            if match_ordering_def_path(cx, fail_ordering_def_id, &["Release", "AcqRel"]) {
+                // If we don't know the success order is, use what we'd suggest
+                // if it were maximally permissive.
+                let suggested = success_lint_info.unwrap_or(seq_cst).2;
+                span_lint_and_help(
+                    cx,
+                    INVALID_ATOMIC_ORDERING,
+                    failure_order_arg.span,
+                    &format!(
+                        "{}'s failure ordering may not be `Release` or `AcqRel`",
+                        method,
+                    ),
+                    None,
+                    &format!("consider using {} instead", suggested),
+                );
+            } else if let Some((success_ord_name, bad_ords_given_success, suggested)) = success_lint_info {
+                if match_ordering_def_path(cx, fail_ordering_def_id, bad_ords_given_success) {
+                    span_lint_and_help(
+                        cx,
+                        INVALID_ATOMIC_ORDERING,
+                        failure_order_arg.span,
+                        &format!(
+                            "{}'s failure ordering may not stronger than the success ordering of `{}`",
+                            method,
+                            success_ord_name,
+                        ),
+                        None,
+                        &format!("consider using {} instead", suggested),
+                    );
+                }
+            }
+        }
+    }
+}
+
 impl<'tcx> LateLintPass<'tcx> for AtomicOrdering {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         check_atomic_load_store(cx, expr);
         check_memory_fence(cx, expr);
+        check_atomic_compare_exchange(cx, expr);
     }
 }
diff --git a/tests/ui/atomic_ordering_exchange.rs b/tests/ui/atomic_ordering_exchange.rs
new file mode 100644
index 00000000000..2f60a98f037
--- /dev/null
+++ b/tests/ui/atomic_ordering_exchange.rs
@@ -0,0 +1,84 @@
+#![warn(clippy::invalid_atomic_ordering)]
+
+use std::sync::atomic::{AtomicUsize, Ordering};
+
+fn main() {
+    // `compare_exchange` (not weak) testing
+    let x = AtomicUsize::new(0);
+
+    // Allowed ordering combos
+    let _ = x.compare_exchange(0, 0, Ordering::Relaxed, Ordering::Relaxed);
+    let _ = x.compare_exchange(0, 0, Ordering::Acquire, Ordering::Acquire);
+    let _ = x.compare_exchange(0, 0, Ordering::Acquire, Ordering::Relaxed);
+    let _ = x.compare_exchange(0, 0, Ordering::Release, Ordering::Relaxed);
+    let _ = x.compare_exchange(0, 0, Ordering::AcqRel, Ordering::Acquire);
+    let _ = x.compare_exchange(0, 0, Ordering::AcqRel, Ordering::Relaxed);
+    let _ = x.compare_exchange(0, 0, Ordering::SeqCst, Ordering::Relaxed);
+    let _ = x.compare_exchange(0, 0, Ordering::SeqCst, Ordering::Acquire);
+    let _ = x.compare_exchange(0, 0, Ordering::SeqCst, Ordering::SeqCst);
+
+    // AcqRel is always forbidden as a failure ordering
+    let _ = x.compare_exchange(0, 0, Ordering::Relaxed, Ordering::AcqRel);
+    let _ = x.compare_exchange(0, 0, Ordering::Acquire, Ordering::AcqRel);
+    let _ = x.compare_exchange(0, 0, Ordering::Release, Ordering::AcqRel);
+    let _ = x.compare_exchange(0, 0, Ordering::AcqRel, Ordering::AcqRel);
+    let _ = x.compare_exchange(0, 0, Ordering::SeqCst, Ordering::AcqRel);
+
+    // Release is always forbidden as a failure ordering
+    let _ = x.compare_exchange(0, 0, Ordering::Relaxed, Ordering::Release);
+    let _ = x.compare_exchange(0, 0, Ordering::Acquire, Ordering::Release);
+    let _ = x.compare_exchange(0, 0, Ordering::Release, Ordering::Release);
+    let _ = x.compare_exchange(0, 0, Ordering::AcqRel, Ordering::Release);
+    let _ = x.compare_exchange(0, 0, Ordering::SeqCst, Ordering::Release);
+
+    // Release success order forbids failure order of Acquire or SeqCst
+    let _ = x.compare_exchange(0, 0, Ordering::Release, Ordering::Acquire);
+    let _ = x.compare_exchange(0, 0, Ordering::Release, Ordering::SeqCst);
+
+    // Relaxed success order also forbids failure order of Acquire or SeqCst
+    let _ = x.compare_exchange(0, 0, Ordering::Relaxed, Ordering::SeqCst);
+    let _ = x.compare_exchange(0, 0, Ordering::Relaxed, Ordering::Acquire);
+
+    // Acquire/AcqRel forbids failure order of SeqCst
+    let _ = x.compare_exchange(0, 0, Ordering::Acquire, Ordering::SeqCst);
+    let _ = x.compare_exchange(0, 0, Ordering::AcqRel, Ordering::SeqCst);
+
+    // compare_exchange_weak tests
+
+    // Allowed ordering combos
+    let _ = x.compare_exchange_weak(0, 0, Ordering::Relaxed, Ordering::Relaxed);
+    let _ = x.compare_exchange_weak(0, 0, Ordering::Acquire, Ordering::Acquire);
+    let _ = x.compare_exchange_weak(0, 0, Ordering::Acquire, Ordering::Relaxed);
+    let _ = x.compare_exchange_weak(0, 0, Ordering::Release, Ordering::Relaxed);
+    let _ = x.compare_exchange_weak(0, 0, Ordering::AcqRel, Ordering::Acquire);
+    let _ = x.compare_exchange_weak(0, 0, Ordering::AcqRel, Ordering::Relaxed);
+    let _ = x.compare_exchange_weak(0, 0, Ordering::SeqCst, Ordering::Relaxed);
+    let _ = x.compare_exchange_weak(0, 0, Ordering::SeqCst, Ordering::Acquire);
+    let _ = x.compare_exchange_weak(0, 0, Ordering::SeqCst, Ordering::SeqCst);
+
+    // AcqRel is always forbidden as a failure ordering
+    let _ = x.compare_exchange_weak(0, 0, Ordering::Relaxed, Ordering::AcqRel);
+    let _ = x.compare_exchange_weak(0, 0, Ordering::Acquire, Ordering::AcqRel);
+    let _ = x.compare_exchange_weak(0, 0, Ordering::Release, Ordering::AcqRel);
+    let _ = x.compare_exchange_weak(0, 0, Ordering::AcqRel, Ordering::AcqRel);
+    let _ = x.compare_exchange_weak(0, 0, Ordering::SeqCst, Ordering::AcqRel);
+
+    // Release is always forbidden as a failure ordering
+    let _ = x.compare_exchange_weak(0, 0, Ordering::Relaxed, Ordering::Release);
+    let _ = x.compare_exchange_weak(0, 0, Ordering::Acquire, Ordering::Release);
+    let _ = x.compare_exchange_weak(0, 0, Ordering::Release, Ordering::Release);
+    let _ = x.compare_exchange_weak(0, 0, Ordering::AcqRel, Ordering::Release);
+    let _ = x.compare_exchange_weak(0, 0, Ordering::SeqCst, Ordering::Release);
+
+    // Release success order forbids failure order of Acquire or SeqCst
+    let _ = x.compare_exchange_weak(0, 0, Ordering::Release, Ordering::Acquire);
+    let _ = x.compare_exchange_weak(0, 0, Ordering::Release, Ordering::SeqCst);
+
+    // Relaxed success order also forbids failure order of Acquire or SeqCst
+    let _ = x.compare_exchange_weak(0, 0, Ordering::Relaxed, Ordering::SeqCst);
+    let _ = x.compare_exchange_weak(0, 0, Ordering::Relaxed, Ordering::Acquire);
+
+    // Acquire/AcqRel forbids failure order of SeqCst
+    let _ = x.compare_exchange_weak(0, 0, Ordering::Acquire, Ordering::SeqCst);
+    let _ = x.compare_exchange_weak(0, 0, Ordering::AcqRel, Ordering::SeqCst);
+}
diff --git a/tests/ui/atomic_ordering_exchange.stderr b/tests/ui/atomic_ordering_exchange.stderr
new file mode 100644
index 00000000000..26ec15be518
--- /dev/null
+++ b/tests/ui/atomic_ordering_exchange.stderr
@@ -0,0 +1,259 @@
+error: compare_exchange's failure ordering may not be `Release` or `AcqRel`
+  --> $DIR/atomic_ordering_exchange.rs:21:57
+   |
+LL |     let _ = x.compare_exchange(0, 0, Ordering::Relaxed, Ordering::AcqRel);
+   |                                                         ^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::invalid-atomic-ordering` implied by `-D warnings`
+   = help: consider using ordering mode `Relaxed` instead
+
+error: compare_exchange's failure ordering may not be `Release` or `AcqRel`
+  --> $DIR/atomic_ordering_exchange.rs:22:57
+   |
+LL |     let _ = x.compare_exchange(0, 0, Ordering::Acquire, Ordering::AcqRel);
+   |                                                         ^^^^^^^^^^^^^^^^
+   |
+   = help: consider using ordering modes `Acquire` or `Relaxed` instead
+
+error: compare_exchange's failure ordering may not be `Release` or `AcqRel`
+  --> $DIR/atomic_ordering_exchange.rs:23:57
+   |
+LL |     let _ = x.compare_exchange(0, 0, Ordering::Release, Ordering::AcqRel);
+   |                                                         ^^^^^^^^^^^^^^^^
+   |
+   = help: consider using ordering mode `Relaxed` instead
+
+error: compare_exchange's failure ordering may not be `Release` or `AcqRel`
+  --> $DIR/atomic_ordering_exchange.rs:24:56
+   |
+LL |     let _ = x.compare_exchange(0, 0, Ordering::AcqRel, Ordering::AcqRel);
+   |                                                        ^^^^^^^^^^^^^^^^
+   |
+   = help: consider using ordering modes `Acquire` or `Relaxed` instead
+
+error: compare_exchange's failure ordering may not be `Release` or `AcqRel`
+  --> $DIR/atomic_ordering_exchange.rs:25:56
+   |
+LL |     let _ = x.compare_exchange(0, 0, Ordering::SeqCst, Ordering::AcqRel);
+   |                                                        ^^^^^^^^^^^^^^^^
+   |
+   = help: consider using ordering modes `Acquire`, `SeqCst` or `Relaxed` instead
+
+error: compare_exchange's failure ordering may not be `Release` or `AcqRel`
+  --> $DIR/atomic_ordering_exchange.rs:28:57
+   |
+LL |     let _ = x.compare_exchange(0, 0, Ordering::Relaxed, Ordering::Release);
+   |                                                         ^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using ordering mode `Relaxed` instead
+
+error: compare_exchange's failure ordering may not be `Release` or `AcqRel`
+  --> $DIR/atomic_ordering_exchange.rs:29:57
+   |
+LL |     let _ = x.compare_exchange(0, 0, Ordering::Acquire, Ordering::Release);
+   |                                                         ^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using ordering modes `Acquire` or `Relaxed` instead
+
+error: compare_exchange's failure ordering may not be `Release` or `AcqRel`
+  --> $DIR/atomic_ordering_exchange.rs:30:57
+   |
+LL |     let _ = x.compare_exchange(0, 0, Ordering::Release, Ordering::Release);
+   |                                                         ^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using ordering mode `Relaxed` instead
+
+error: compare_exchange's failure ordering may not be `Release` or `AcqRel`
+  --> $DIR/atomic_ordering_exchange.rs:31:56
+   |
+LL |     let _ = x.compare_exchange(0, 0, Ordering::AcqRel, Ordering::Release);
+   |                                                        ^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using ordering modes `Acquire` or `Relaxed` instead
+
+error: compare_exchange's failure ordering may not be `Release` or `AcqRel`
+  --> $DIR/atomic_ordering_exchange.rs:32:56
+   |
+LL |     let _ = x.compare_exchange(0, 0, Ordering::SeqCst, Ordering::Release);
+   |                                                        ^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using ordering modes `Acquire`, `SeqCst` or `Relaxed` instead
+
+error: compare_exchange's failure ordering may not stronger than the success ordering of `Release`
+  --> $DIR/atomic_ordering_exchange.rs:35:57
+   |
+LL |     let _ = x.compare_exchange(0, 0, Ordering::Release, Ordering::Acquire);
+   |                                                         ^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using ordering mode `Relaxed` instead
+
+error: compare_exchange's failure ordering may not stronger than the success ordering of `Release`
+  --> $DIR/atomic_ordering_exchange.rs:36:57
+   |
+LL |     let _ = x.compare_exchange(0, 0, Ordering::Release, Ordering::SeqCst);
+   |                                                         ^^^^^^^^^^^^^^^^
+   |
+   = help: consider using ordering mode `Relaxed` instead
+
+error: compare_exchange's failure ordering may not stronger than the success ordering of `Relaxed`
+  --> $DIR/atomic_ordering_exchange.rs:39:57
+   |
+LL |     let _ = x.compare_exchange(0, 0, Ordering::Relaxed, Ordering::SeqCst);
+   |                                                         ^^^^^^^^^^^^^^^^
+   |
+   = help: consider using ordering mode `Relaxed` instead
+
+error: compare_exchange's failure ordering may not stronger than the success ordering of `Relaxed`
+  --> $DIR/atomic_ordering_exchange.rs:40:57
+   |
+LL |     let _ = x.compare_exchange(0, 0, Ordering::Relaxed, Ordering::Acquire);
+   |                                                         ^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using ordering mode `Relaxed` instead
+
+error: compare_exchange's failure ordering may not stronger than the success ordering of `Acquire`
+  --> $DIR/atomic_ordering_exchange.rs:43:57
+   |
+LL |     let _ = x.compare_exchange(0, 0, Ordering::Acquire, Ordering::SeqCst);
+   |                                                         ^^^^^^^^^^^^^^^^
+   |
+   = help: consider using ordering modes `Acquire` or `Relaxed` instead
+
+error: compare_exchange's failure ordering may not stronger than the success ordering of `AcqRel`
+  --> $DIR/atomic_ordering_exchange.rs:44:56
+   |
+LL |     let _ = x.compare_exchange(0, 0, Ordering::AcqRel, Ordering::SeqCst);
+   |                                                        ^^^^^^^^^^^^^^^^
+   |
+   = help: consider using ordering modes `Acquire` or `Relaxed` instead
+
+error: compare_exchange_weak's failure ordering may not be `Release` or `AcqRel`
+  --> $DIR/atomic_ordering_exchange.rs:60:62
+   |
+LL |     let _ = x.compare_exchange_weak(0, 0, Ordering::Relaxed, Ordering::AcqRel);
+   |                                                              ^^^^^^^^^^^^^^^^
+   |
+   = help: consider using ordering mode `Relaxed` instead
+
+error: compare_exchange_weak's failure ordering may not be `Release` or `AcqRel`
+  --> $DIR/atomic_ordering_exchange.rs:61:62
+   |
+LL |     let _ = x.compare_exchange_weak(0, 0, Ordering::Acquire, Ordering::AcqRel);
+   |                                                              ^^^^^^^^^^^^^^^^
+   |
+   = help: consider using ordering modes `Acquire` or `Relaxed` instead
+
+error: compare_exchange_weak's failure ordering may not be `Release` or `AcqRel`
+  --> $DIR/atomic_ordering_exchange.rs:62:62
+   |
+LL |     let _ = x.compare_exchange_weak(0, 0, Ordering::Release, Ordering::AcqRel);
+   |                                                              ^^^^^^^^^^^^^^^^
+   |
+   = help: consider using ordering mode `Relaxed` instead
+
+error: compare_exchange_weak's failure ordering may not be `Release` or `AcqRel`
+  --> $DIR/atomic_ordering_exchange.rs:63:61
+   |
+LL |     let _ = x.compare_exchange_weak(0, 0, Ordering::AcqRel, Ordering::AcqRel);
+   |                                                             ^^^^^^^^^^^^^^^^
+   |
+   = help: consider using ordering modes `Acquire` or `Relaxed` instead
+
+error: compare_exchange_weak's failure ordering may not be `Release` or `AcqRel`
+  --> $DIR/atomic_ordering_exchange.rs:64:61
+   |
+LL |     let _ = x.compare_exchange_weak(0, 0, Ordering::SeqCst, Ordering::AcqRel);
+   |                                                             ^^^^^^^^^^^^^^^^
+   |
+   = help: consider using ordering modes `Acquire`, `SeqCst` or `Relaxed` instead
+
+error: compare_exchange_weak's failure ordering may not be `Release` or `AcqRel`
+  --> $DIR/atomic_ordering_exchange.rs:67:62
+   |
+LL |     let _ = x.compare_exchange_weak(0, 0, Ordering::Relaxed, Ordering::Release);
+   |                                                              ^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using ordering mode `Relaxed` instead
+
+error: compare_exchange_weak's failure ordering may not be `Release` or `AcqRel`
+  --> $DIR/atomic_ordering_exchange.rs:68:62
+   |
+LL |     let _ = x.compare_exchange_weak(0, 0, Ordering::Acquire, Ordering::Release);
+   |                                                              ^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using ordering modes `Acquire` or `Relaxed` instead
+
+error: compare_exchange_weak's failure ordering may not be `Release` or `AcqRel`
+  --> $DIR/atomic_ordering_exchange.rs:69:62
+   |
+LL |     let _ = x.compare_exchange_weak(0, 0, Ordering::Release, Ordering::Release);
+   |                                                              ^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using ordering mode `Relaxed` instead
+
+error: compare_exchange_weak's failure ordering may not be `Release` or `AcqRel`
+  --> $DIR/atomic_ordering_exchange.rs:70:61
+   |
+LL |     let _ = x.compare_exchange_weak(0, 0, Ordering::AcqRel, Ordering::Release);
+   |                                                             ^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using ordering modes `Acquire` or `Relaxed` instead
+
+error: compare_exchange_weak's failure ordering may not be `Release` or `AcqRel`
+  --> $DIR/atomic_ordering_exchange.rs:71:61
+   |
+LL |     let _ = x.compare_exchange_weak(0, 0, Ordering::SeqCst, Ordering::Release);
+   |                                                             ^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using ordering modes `Acquire`, `SeqCst` or `Relaxed` instead
+
+error: compare_exchange_weak's failure ordering may not stronger than the success ordering of `Release`
+  --> $DIR/atomic_ordering_exchange.rs:74:62
+   |
+LL |     let _ = x.compare_exchange_weak(0, 0, Ordering::Release, Ordering::Acquire);
+   |                                                              ^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using ordering mode `Relaxed` instead
+
+error: compare_exchange_weak's failure ordering may not stronger than the success ordering of `Release`
+  --> $DIR/atomic_ordering_exchange.rs:75:62
+   |
+LL |     let _ = x.compare_exchange_weak(0, 0, Ordering::Release, Ordering::SeqCst);
+   |                                                              ^^^^^^^^^^^^^^^^
+   |
+   = help: consider using ordering mode `Relaxed` instead
+
+error: compare_exchange_weak's failure ordering may not stronger than the success ordering of `Relaxed`
+  --> $DIR/atomic_ordering_exchange.rs:78:62
+   |
+LL |     let _ = x.compare_exchange_weak(0, 0, Ordering::Relaxed, Ordering::SeqCst);
+   |                                                              ^^^^^^^^^^^^^^^^
+   |
+   = help: consider using ordering mode `Relaxed` instead
+
+error: compare_exchange_weak's failure ordering may not stronger than the success ordering of `Relaxed`
+  --> $DIR/atomic_ordering_exchange.rs:79:62
+   |
+LL |     let _ = x.compare_exchange_weak(0, 0, Ordering::Relaxed, Ordering::Acquire);
+   |                                                              ^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using ordering mode `Relaxed` instead
+
+error: compare_exchange_weak's failure ordering may not stronger than the success ordering of `Acquire`
+  --> $DIR/atomic_ordering_exchange.rs:82:62
+   |
+LL |     let _ = x.compare_exchange_weak(0, 0, Ordering::Acquire, Ordering::SeqCst);
+   |                                                              ^^^^^^^^^^^^^^^^
+   |
+   = help: consider using ordering modes `Acquire` or `Relaxed` instead
+
+error: compare_exchange_weak's failure ordering may not stronger than the success ordering of `AcqRel`
+  --> $DIR/atomic_ordering_exchange.rs:83:61
+   |
+LL |     let _ = x.compare_exchange_weak(0, 0, Ordering::AcqRel, Ordering::SeqCst);
+   |                                                             ^^^^^^^^^^^^^^^^
+   |
+   = help: consider using ordering modes `Acquire` or `Relaxed` instead
+
+error: aborting due to 32 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 61671a2268903e1b5c28fcb3c713c27e84ea3e9b Mon Sep 17 00:00:00 2001
From: Thom Chiovoloni <chiovolonit@gmail.com>
Date: Wed, 9 Sep 2020 14:12:14 -0700
Subject: Detect fetch_update misuse in invalid_atomic_ordering too

---
 clippy_lints/src/atomic_ordering.rs          |  16 +++-
 src/lintlist/mod.rs                          |   2 +-
 tests/ui/atomic_ordering_fetch_update.rs     |  45 +++++++++
 tests/ui/atomic_ordering_fetch_update.stderr | 131 +++++++++++++++++++++++++++
 4 files changed, 188 insertions(+), 6 deletions(-)
 create mode 100644 tests/ui/atomic_ordering_fetch_update.rs
 create mode 100644 tests/ui/atomic_ordering_fetch_update.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/atomic_ordering.rs b/clippy_lints/src/atomic_ordering.rs
index 748f45f47c2..ff2c281ec9d 100644
--- a/clippy_lints/src/atomic_ordering.rs
+++ b/clippy_lints/src/atomic_ordering.rs
@@ -8,7 +8,8 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for usage of invalid atomic
-    /// ordering in atomic loads/stores/exchanges and memory fences
+    /// ordering in atomic loads/stores/exchanges/updates and
+    /// memory fences.
     ///
     /// **Why is this bad?** Using an invalid atomic ordering
     /// will cause a panic at run-time.
@@ -32,10 +33,11 @@ declare_clippy_lint! {
     ///
     /// let _ = x.compare_exchange(false, false, Ordering::Relaxed, Ordering::SeqCst);
     /// let _ = x.compare_exchange_weak(false, true, Ordering::SeqCst, Ordering::Release);
+    /// let _ = x.fetch_update(Ordering::AcqRel, Ordering::AcqRel, |val| Some(val ^ val));
     /// ```
     pub INVALID_ATOMIC_ORDERING,
     correctness,
-    "usage of invalid atomic ordering in atomic loads/stores/exchanges ane memory fences"
+    "usage of invalid atomic ordering in atomic operations and memory fences"
 }
 
 declare_lint_pass!(AtomicOrdering => [INVALID_ATOMIC_ORDERING]);
@@ -142,8 +144,12 @@ fn check_atomic_compare_exchange(cx: &LateContext<'_>, expr: &Expr<'_>) {
         if let ExprKind::MethodCall(ref method_path, _, args, _) = &expr.kind;
         let method = method_path.ident.name.as_str();
         if type_is_atomic(cx, &args[0]);
-        if method == "compare_exchange" || method == "compare_exchange_weak";
-        let failure_order_arg = &args[4];
+        if method == "compare_exchange" || method == "compare_exchange_weak" || method == "fetch_update";
+        let (success_order_arg, failure_order_arg) = if method == "fetch_update" {
+            (&args[1], &args[2])
+        } else {
+            (&args[3], &args[4])
+        };
         if let Some(fail_ordering_def_id) = opt_ordering_defid(cx, failure_order_arg);
         then {
             // Helper type holding on to some checking and error reporting data. Has
@@ -158,7 +164,7 @@ fn check_atomic_compare_exchange(cx: &LateContext<'_>, expr: &Expr<'_>) {
             let acqrel = ("AcqRel", acquire.1, acquire.2);
             let search = [relaxed, acquire, seq_cst, release, acqrel];
 
-            let success_lint_info = opt_ordering_defid(cx, &args[3])
+            let success_lint_info = opt_ordering_defid(cx, success_order_arg)
                 .and_then(|success_ord_def_id| -> Option<OrdLintInfo> {
                     search
                         .iter()
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index dff19ef440f..5dead1b9b69 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -923,7 +923,7 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
     Lint {
         name: "invalid_atomic_ordering",
         group: "correctness",
-        desc: "usage of invalid atomic ordering in atomic loads/stores and memory fences",
+        desc: "usage of invalid atomic ordering in atomic operations and memory fences",
         deprecation: None,
         module: "atomic_ordering",
     },
diff --git a/tests/ui/atomic_ordering_fetch_update.rs b/tests/ui/atomic_ordering_fetch_update.rs
new file mode 100644
index 00000000000..550bdb001e4
--- /dev/null
+++ b/tests/ui/atomic_ordering_fetch_update.rs
@@ -0,0 +1,45 @@
+#![warn(clippy::invalid_atomic_ordering)]
+
+use std::sync::atomic::{AtomicIsize, Ordering};
+
+fn main() {
+    // `fetch_update` testing
+    let x = AtomicIsize::new(0);
+
+    // Allowed ordering combos
+    let _ = x.fetch_update(Ordering::Relaxed, Ordering::Relaxed, |old| Some(old + 1));
+    let _ = x.fetch_update(Ordering::Acquire, Ordering::Acquire, |old| Some(old + 1));
+    let _ = x.fetch_update(Ordering::Acquire, Ordering::Relaxed, |old| Some(old + 1));
+    let _ = x.fetch_update(Ordering::Release, Ordering::Relaxed, |old| Some(old + 1));
+    let _ = x.fetch_update(Ordering::AcqRel, Ordering::Acquire, |old| Some(old + 1));
+    let _ = x.fetch_update(Ordering::AcqRel, Ordering::Relaxed, |old| Some(old + 1));
+    let _ = x.fetch_update(Ordering::SeqCst, Ordering::Relaxed, |old| Some(old + 1));
+    let _ = x.fetch_update(Ordering::SeqCst, Ordering::Acquire, |old| Some(old + 1));
+    let _ = x.fetch_update(Ordering::SeqCst, Ordering::SeqCst, |old| Some(old + 1));
+
+    // AcqRel is always forbidden as a failure ordering
+    let _ = x.fetch_update(Ordering::Relaxed, Ordering::AcqRel, |old| Some(old + 1));
+    let _ = x.fetch_update(Ordering::Acquire, Ordering::AcqRel, |old| Some(old + 1));
+    let _ = x.fetch_update(Ordering::Release, Ordering::AcqRel, |old| Some(old + 1));
+    let _ = x.fetch_update(Ordering::AcqRel, Ordering::AcqRel, |old| Some(old + 1));
+    let _ = x.fetch_update(Ordering::SeqCst, Ordering::AcqRel, |old| Some(old + 1));
+
+    // Release is always forbidden as a failure ordering
+    let _ = x.fetch_update(Ordering::Relaxed, Ordering::Release, |old| Some(old + 1));
+    let _ = x.fetch_update(Ordering::Acquire, Ordering::Release, |old| Some(old + 1));
+    let _ = x.fetch_update(Ordering::Release, Ordering::Release, |old| Some(old + 1));
+    let _ = x.fetch_update(Ordering::AcqRel, Ordering::Release, |old| Some(old + 1));
+    let _ = x.fetch_update(Ordering::SeqCst, Ordering::Release, |old| Some(old + 1));
+
+    // Release success order forbids failure order of Acquire or SeqCst
+    let _ = x.fetch_update(Ordering::Release, Ordering::Acquire, |old| Some(old + 1));
+    let _ = x.fetch_update(Ordering::Release, Ordering::SeqCst, |old| Some(old + 1));
+
+    // Relaxed success order also forbids failure order of Acquire or SeqCst
+    let _ = x.fetch_update(Ordering::Relaxed, Ordering::SeqCst, |old| Some(old + 1));
+    let _ = x.fetch_update(Ordering::Relaxed, Ordering::Acquire, |old| Some(old + 1));
+
+    // Acquire/AcqRel forbids failure order of SeqCst
+    let _ = x.fetch_update(Ordering::Acquire, Ordering::SeqCst, |old| Some(old + 1));
+    let _ = x.fetch_update(Ordering::AcqRel, Ordering::SeqCst, |old| Some(old + 1));
+}
diff --git a/tests/ui/atomic_ordering_fetch_update.stderr b/tests/ui/atomic_ordering_fetch_update.stderr
new file mode 100644
index 00000000000..362e104a244
--- /dev/null
+++ b/tests/ui/atomic_ordering_fetch_update.stderr
@@ -0,0 +1,131 @@
+error: fetch_update's failure ordering may not be `Release` or `AcqRel`
+  --> $DIR/atomic_ordering_fetch_update.rs:21:47
+   |
+LL |     let _ = x.fetch_update(Ordering::Relaxed, Ordering::AcqRel, |old| Some(old + 1));
+   |                                               ^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::invalid-atomic-ordering` implied by `-D warnings`
+   = help: consider using ordering mode `Relaxed` instead
+
+error: fetch_update's failure ordering may not be `Release` or `AcqRel`
+  --> $DIR/atomic_ordering_fetch_update.rs:22:47
+   |
+LL |     let _ = x.fetch_update(Ordering::Acquire, Ordering::AcqRel, |old| Some(old + 1));
+   |                                               ^^^^^^^^^^^^^^^^
+   |
+   = help: consider using ordering modes `Acquire` or `Relaxed` instead
+
+error: fetch_update's failure ordering may not be `Release` or `AcqRel`
+  --> $DIR/atomic_ordering_fetch_update.rs:23:47
+   |
+LL |     let _ = x.fetch_update(Ordering::Release, Ordering::AcqRel, |old| Some(old + 1));
+   |                                               ^^^^^^^^^^^^^^^^
+   |
+   = help: consider using ordering mode `Relaxed` instead
+
+error: fetch_update's failure ordering may not be `Release` or `AcqRel`
+  --> $DIR/atomic_ordering_fetch_update.rs:24:46
+   |
+LL |     let _ = x.fetch_update(Ordering::AcqRel, Ordering::AcqRel, |old| Some(old + 1));
+   |                                              ^^^^^^^^^^^^^^^^
+   |
+   = help: consider using ordering modes `Acquire` or `Relaxed` instead
+
+error: fetch_update's failure ordering may not be `Release` or `AcqRel`
+  --> $DIR/atomic_ordering_fetch_update.rs:25:46
+   |
+LL |     let _ = x.fetch_update(Ordering::SeqCst, Ordering::AcqRel, |old| Some(old + 1));
+   |                                              ^^^^^^^^^^^^^^^^
+   |
+   = help: consider using ordering modes `Acquire`, `SeqCst` or `Relaxed` instead
+
+error: fetch_update's failure ordering may not be `Release` or `AcqRel`
+  --> $DIR/atomic_ordering_fetch_update.rs:28:47
+   |
+LL |     let _ = x.fetch_update(Ordering::Relaxed, Ordering::Release, |old| Some(old + 1));
+   |                                               ^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using ordering mode `Relaxed` instead
+
+error: fetch_update's failure ordering may not be `Release` or `AcqRel`
+  --> $DIR/atomic_ordering_fetch_update.rs:29:47
+   |
+LL |     let _ = x.fetch_update(Ordering::Acquire, Ordering::Release, |old| Some(old + 1));
+   |                                               ^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using ordering modes `Acquire` or `Relaxed` instead
+
+error: fetch_update's failure ordering may not be `Release` or `AcqRel`
+  --> $DIR/atomic_ordering_fetch_update.rs:30:47
+   |
+LL |     let _ = x.fetch_update(Ordering::Release, Ordering::Release, |old| Some(old + 1));
+   |                                               ^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using ordering mode `Relaxed` instead
+
+error: fetch_update's failure ordering may not be `Release` or `AcqRel`
+  --> $DIR/atomic_ordering_fetch_update.rs:31:46
+   |
+LL |     let _ = x.fetch_update(Ordering::AcqRel, Ordering::Release, |old| Some(old + 1));
+   |                                              ^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using ordering modes `Acquire` or `Relaxed` instead
+
+error: fetch_update's failure ordering may not be `Release` or `AcqRel`
+  --> $DIR/atomic_ordering_fetch_update.rs:32:46
+   |
+LL |     let _ = x.fetch_update(Ordering::SeqCst, Ordering::Release, |old| Some(old + 1));
+   |                                              ^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using ordering modes `Acquire`, `SeqCst` or `Relaxed` instead
+
+error: fetch_update's failure ordering may not stronger than the success ordering of `Release`
+  --> $DIR/atomic_ordering_fetch_update.rs:35:47
+   |
+LL |     let _ = x.fetch_update(Ordering::Release, Ordering::Acquire, |old| Some(old + 1));
+   |                                               ^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using ordering mode `Relaxed` instead
+
+error: fetch_update's failure ordering may not stronger than the success ordering of `Release`
+  --> $DIR/atomic_ordering_fetch_update.rs:36:47
+   |
+LL |     let _ = x.fetch_update(Ordering::Release, Ordering::SeqCst, |old| Some(old + 1));
+   |                                               ^^^^^^^^^^^^^^^^
+   |
+   = help: consider using ordering mode `Relaxed` instead
+
+error: fetch_update's failure ordering may not stronger than the success ordering of `Relaxed`
+  --> $DIR/atomic_ordering_fetch_update.rs:39:47
+   |
+LL |     let _ = x.fetch_update(Ordering::Relaxed, Ordering::SeqCst, |old| Some(old + 1));
+   |                                               ^^^^^^^^^^^^^^^^
+   |
+   = help: consider using ordering mode `Relaxed` instead
+
+error: fetch_update's failure ordering may not stronger than the success ordering of `Relaxed`
+  --> $DIR/atomic_ordering_fetch_update.rs:40:47
+   |
+LL |     let _ = x.fetch_update(Ordering::Relaxed, Ordering::Acquire, |old| Some(old + 1));
+   |                                               ^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using ordering mode `Relaxed` instead
+
+error: fetch_update's failure ordering may not stronger than the success ordering of `Acquire`
+  --> $DIR/atomic_ordering_fetch_update.rs:43:47
+   |
+LL |     let _ = x.fetch_update(Ordering::Acquire, Ordering::SeqCst, |old| Some(old + 1));
+   |                                               ^^^^^^^^^^^^^^^^
+   |
+   = help: consider using ordering modes `Acquire` or `Relaxed` instead
+
+error: fetch_update's failure ordering may not stronger than the success ordering of `AcqRel`
+  --> $DIR/atomic_ordering_fetch_update.rs:44:46
+   |
+LL |     let _ = x.fetch_update(Ordering::AcqRel, Ordering::SeqCst, |old| Some(old + 1));
+   |                                              ^^^^^^^^^^^^^^^^
+   |
+   = help: consider using ordering modes `Acquire` or `Relaxed` instead
+
+error: aborting due to 16 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From b65745545f410b31c5ecdd33a8299a65da578af2 Mon Sep 17 00:00:00 2001
From: Thom Chiovoloni <chiovolonit@gmail.com>
Date: Wed, 9 Sep 2020 14:40:43 -0700
Subject: Use AtomicU8 in ordering example so all operations can be
 demonstrated

---
 clippy_lints/src/atomic_ordering.rs | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/atomic_ordering.rs b/clippy_lints/src/atomic_ordering.rs
index ff2c281ec9d..d4e070b0c24 100644
--- a/clippy_lints/src/atomic_ordering.rs
+++ b/clippy_lints/src/atomic_ordering.rs
@@ -18,22 +18,22 @@ declare_clippy_lint! {
     ///
     /// **Example:**
     /// ```rust,no_run
-    /// # use std::sync::atomic::{self, AtomicBool, Ordering};
+    /// # use std::sync::atomic::{self, AtomicU8, Ordering};
     ///
-    /// let x = AtomicBool::new(true);
+    /// let x = AtomicU8::new(0);
     ///
     /// let _ = x.load(Ordering::Release);
     /// let _ = x.load(Ordering::AcqRel);
     ///
-    /// x.store(false, Ordering::Acquire);
-    /// x.store(false, Ordering::AcqRel);
+    /// x.store(1, Ordering::Acquire);
+    /// x.store(2, Ordering::AcqRel);
     ///
     /// atomic::fence(Ordering::Relaxed);
     /// atomic::compiler_fence(Ordering::Relaxed);
     ///
-    /// let _ = x.compare_exchange(false, false, Ordering::Relaxed, Ordering::SeqCst);
-    /// let _ = x.compare_exchange_weak(false, true, Ordering::SeqCst, Ordering::Release);
-    /// let _ = x.fetch_update(Ordering::AcqRel, Ordering::AcqRel, |val| Some(val ^ val));
+    /// let _ = x.compare_exchange(1, 2, Ordering::Relaxed, Ordering::SeqCst);
+    /// let _ = x.compare_exchange_weak(2, 3, Ordering::SeqCst, Ordering::Release);
+    /// let _ = x.fetch_update(Ordering::AcqRel, Ordering::AcqRel, |val| Some(val + val));
     /// ```
     pub INVALID_ATOMIC_ORDERING,
     correctness,
-- 
cgit 1.4.1-3-g733a5


From 4b5326b0d62104801f0b33c4d8f3749d93eebc02 Mon Sep 17 00:00:00 2001
From: Thom Chiovoloni <chiovolonit@gmail.com>
Date: Wed, 9 Sep 2020 23:12:57 -0700
Subject: Address small review comments

---
 clippy_lints/src/atomic_ordering.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/atomic_ordering.rs b/clippy_lints/src/atomic_ordering.rs
index d4e070b0c24..614e33a06da 100644
--- a/clippy_lints/src/atomic_ordering.rs
+++ b/clippy_lints/src/atomic_ordering.rs
@@ -139,6 +139,7 @@ fn opt_ordering_defid(cx: &LateContext<'_>, ord_arg: &Expr<'_>) -> Option<DefId>
         None
     }
 }
+
 fn check_atomic_compare_exchange(cx: &LateContext<'_>, expr: &Expr<'_>) {
     if_chain! {
         if let ExprKind::MethodCall(ref method_path, _, args, _) = &expr.kind;
@@ -197,7 +198,7 @@ fn check_atomic_compare_exchange(cx: &LateContext<'_>, expr: &Expr<'_>) {
                         INVALID_ATOMIC_ORDERING,
                         failure_order_arg.span,
                         &format!(
-                            "{}'s failure ordering may not stronger than the success ordering of `{}`",
+                            "{}'s failure ordering may not be stronger than the success ordering of `{}`",
                             method,
                             success_ord_name,
                         ),
-- 
cgit 1.4.1-3-g733a5


From f3489d4a5ed944b3f62238c13cda6097dfbed0c8 Mon Sep 17 00:00:00 2001
From: rail <12975677+rail-rain@users.noreply.github.com>
Date: Wed, 9 Sep 2020 11:04:29 +1200
Subject: fix some use of `snippet` in `types.rs`

---
 clippy_lints/src/types.rs | 30 ++++++++++++++++++++----------
 1 file changed, 20 insertions(+), 10 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs
index 6c6188d61ad..b6d405cca77 100644
--- a/clippy_lints/src/types.rs
+++ b/clippy_lints/src/types.rs
@@ -321,14 +321,15 @@ impl Types {
                 if let Some(def_id) = res.opt_def_id() {
                     if Some(def_id) == cx.tcx.lang_items().owned_box() {
                         if let Some(span) = match_borrows_parameter(cx, qpath) {
+                            let mut applicability = Applicability::MachineApplicable;
                             span_lint_and_sugg(
                                 cx,
                                 REDUNDANT_ALLOCATION,
                                 hir_ty.span,
                                 "usage of `Box<&T>`",
                                 "try",
-                                snippet(cx, span, "..").to_string(),
-                                Applicability::MachineApplicable,
+                                snippet_with_applicability(cx, span, "..", &mut applicability).to_string(),
+                                applicability,
                             );
                             return; // don't recurse into the type
                         }
@@ -345,14 +346,15 @@ impl Types {
                         }
                     } else if cx.tcx.is_diagnostic_item(sym::Rc, def_id) {
                         if let Some(span) = match_type_parameter(cx, qpath, &paths::RC) {
+                            let mut applicability = Applicability::MachineApplicable;
                             span_lint_and_sugg(
                                 cx,
                                 REDUNDANT_ALLOCATION,
                                 hir_ty.span,
                                 "usage of `Rc<Rc<T>>`",
                                 "try",
-                                snippet(cx, span, "..").to_string(),
-                                Applicability::MachineApplicable,
+                                snippet_with_applicability(cx, span, "..", &mut applicability).to_string(),
+                                applicability,
                             );
                             return; // don't recurse into the type
                         }
@@ -368,26 +370,31 @@ impl Types {
                                 GenericArg::Type(ty) => ty.span,
                                 _ => return,
                             };
+                            let mut applicability = Applicability::MachineApplicable;
                             span_lint_and_sugg(
                                 cx,
                                 REDUNDANT_ALLOCATION,
                                 hir_ty.span,
                                 "usage of `Rc<Box<T>>`",
                                 "try",
-                                format!("Rc<{}>", snippet(cx, inner_span, "..")),
-                                Applicability::MachineApplicable,
+                                format!(
+                                    "Rc<{}>",
+                                    snippet_with_applicability(cx, inner_span, "..", &mut applicability)
+                                ),
+                                applicability,
                             );
                             return; // don't recurse into the type
                         }
                         if let Some(span) = match_borrows_parameter(cx, qpath) {
+                            let mut applicability = Applicability::MachineApplicable;
                             span_lint_and_sugg(
                                 cx,
                                 REDUNDANT_ALLOCATION,
                                 hir_ty.span,
                                 "usage of `Rc<&T>`",
                                 "try",
-                                snippet(cx, span, "..").to_string(),
-                                Applicability::MachineApplicable,
+                                snippet_with_applicability(cx, span, "..", &mut applicability).to_string(),
+                                applicability,
                             );
                             return; // don't recurse into the type
                         }
@@ -546,7 +553,6 @@ impl Types {
                             // details.
                             return;
                         }
-                        let mut applicability = Applicability::MachineApplicable;
                         span_lint_and_sugg(
                             cx,
                             BORROWED_BOX,
@@ -556,8 +562,12 @@ impl Types {
                             format!(
                                 "&{}{}",
                                 ltopt,
-                                &snippet_with_applicability(cx, inner.span, "..", &mut applicability)
+                                &snippet(cx, inner.span, "..")
                             ),
+                            // To make this `MachineApplicable`, at least one needs to check if it isn't a trait item
+                            // because the trait impls of it will break otherwise;
+                            // and there may be other cases that result in invalid code.
+                            // For example, type coercion doesn't work nicely.
                             Applicability::Unspecified,
                         );
                         return; // don't recurse into the type
-- 
cgit 1.4.1-3-g733a5


From 2d56512580919483268c3e3bf2e028c8614805f2 Mon Sep 17 00:00:00 2001
From: flip1995 <hello@philkrones.com>
Date: Thu, 10 Sep 2020 14:18:05 +0200
Subject: Cleanup of rustup

---
 clippy_lints/src/temporary_assignment.rs | 9 +++------
 tests/ui/temporary_assignment.rs         | 6 ------
 tests/ui/temporary_assignment.stderr     | 8 ++++----
 3 files changed, 7 insertions(+), 16 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/temporary_assignment.rs b/clippy_lints/src/temporary_assignment.rs
index 2b6ddadd4c1..fb891866364 100644
--- a/clippy_lints/src/temporary_assignment.rs
+++ b/clippy_lints/src/temporary_assignment.rs
@@ -21,11 +21,8 @@ declare_clippy_lint! {
     "assignments to temporaries"
 }
 
-fn is_temporary(_cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-    match &expr.kind {
-        ExprKind::Struct(..) | ExprKind::Tup(..) => true,
-        _ => false,
-    }
+fn is_temporary(expr: &Expr<'_>) -> bool {
+    matches!(&expr.kind, ExprKind::Struct(..) | ExprKind::Tup(..))
 }
 
 declare_lint_pass!(TemporaryAssignment => [TEMPORARY_ASSIGNMENT]);
@@ -37,7 +34,7 @@ impl<'tcx> LateLintPass<'tcx> for TemporaryAssignment {
             while let ExprKind::Field(f, _) | ExprKind::Index(f, _) = &base.kind {
                 base = f;
             }
-            if is_temporary(cx, base) && !is_adjusted(cx, base) {
+            if is_temporary(base) && !is_adjusted(cx, base) {
                 span_lint(cx, TEMPORARY_ASSIGNMENT, expr.span, "assignment to temporary");
             }
         }
diff --git a/tests/ui/temporary_assignment.rs b/tests/ui/temporary_assignment.rs
index d6f56d40c5d..ac4c1bc6597 100644
--- a/tests/ui/temporary_assignment.rs
+++ b/tests/ui/temporary_assignment.rs
@@ -1,5 +1,4 @@
 #![warn(clippy::temporary_assignment)]
-#![allow(const_item_mutation)]
 
 use std::ops::{Deref, DerefMut};
 
@@ -54,11 +53,6 @@ fn main() {
     ArrayStruct { array: [0] }.array[0] = 1;
     (0, 0).0 = 1;
 
-    A.0 = 2;
-    B.field = 2;
-    C.structure.field = 2;
-    D.array[0] = 2;
-
     // no error
     s.field = 1;
     t.0 = 1;
diff --git a/tests/ui/temporary_assignment.stderr b/tests/ui/temporary_assignment.stderr
index 4cc32c79f05..7d79901a28d 100644
--- a/tests/ui/temporary_assignment.stderr
+++ b/tests/ui/temporary_assignment.stderr
@@ -1,5 +1,5 @@
 error: assignment to temporary
-  --> $DIR/temporary_assignment.rs:48:5
+  --> $DIR/temporary_assignment.rs:47:5
    |
 LL |     Struct { field: 0 }.field = 1;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -7,7 +7,7 @@ LL |     Struct { field: 0 }.field = 1;
    = note: `-D clippy::temporary-assignment` implied by `-D warnings`
 
 error: assignment to temporary
-  --> $DIR/temporary_assignment.rs:49:5
+  --> $DIR/temporary_assignment.rs:48:5
    |
 LL | /     MultiStruct {
 LL | |         structure: Struct { field: 0 },
@@ -17,13 +17,13 @@ LL | |     .field = 1;
    | |______________^
 
 error: assignment to temporary
-  --> $DIR/temporary_assignment.rs:54:5
+  --> $DIR/temporary_assignment.rs:53:5
    |
 LL |     ArrayStruct { array: [0] }.array[0] = 1;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: assignment to temporary
-  --> $DIR/temporary_assignment.rs:55:5
+  --> $DIR/temporary_assignment.rs:54:5
    |
 LL |     (0, 0).0 = 1;
    |     ^^^^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From f1775f05b7a20c83dd018bc716e1eb5578cfceb0 Mon Sep 17 00:00:00 2001
From: Takayuki Nakata <f.seasons017@gmail.com>
Date: Thu, 10 Sep 2020 22:39:08 +0900
Subject: Fix typo

---
 clippy_lints/src/await_holding_lock.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/await_holding_lock.rs b/clippy_lints/src/await_holding_lock.rs
index f18e7e5d997..367534499fd 100644
--- a/clippy_lints/src/await_holding_lock.rs
+++ b/clippy_lints/src/await_holding_lock.rs
@@ -10,7 +10,7 @@ declare_clippy_lint! {
     /// **What it does:** Checks for calls to await while holding a
     /// non-async-aware MutexGuard.
     ///
-    /// **Why is this bad?** The Mutex types found in syd::sync and parking_lot
+    /// **Why is this bad?** The Mutex types found in std::sync and parking_lot
     /// are not designed to operate in an async context across await points.
     ///
     /// There are two potential solutions. One is to use an asynx-aware Mutex
-- 
cgit 1.4.1-3-g733a5


From 36a864854f41dfd25c45fa4881812bd005bd5054 Mon Sep 17 00:00:00 2001
From: Philipp Krones <hello@philkrones.com>
Date: Thu, 10 Sep 2020 17:08:10 +0200
Subject: Fix spelling of "Known problems section" of `interior_mutable_key`

---
 clippy_lints/src/mut_key.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/mut_key.rs b/clippy_lints/src/mut_key.rs
index fa3a99dad9d..0826ad0ab55 100644
--- a/clippy_lints/src/mut_key.rs
+++ b/clippy_lints/src/mut_key.rs
@@ -12,10 +12,10 @@ declare_clippy_lint! {
     /// `BtreeSet` rely on either the hash or the order of keys be unchanging,
     /// so having types with interior mutability is a bad idea.
     ///
-    /// **Known problems:** It's correct to use a struct, that contains interior mutability,
-    /// as a key; when its `Hash` implementation doesn't access any these interior mutable types.
-    /// However, this lint is unable to recognise it so cause a false positive.
-    /// `bytes` ctate is a great example of this.
+    /// **Known problems:** It's correct to use a struct, that contains interior mutability
+    /// as a key, when its `Hash` implementation doesn't access any of the interior mutable types.
+    /// However, this lint is unable to recognize this, so it causes a false positive in theses cases.
+    /// The `bytes` crate is a great example of this.
     ///
     /// **Example:**
     /// ```rust
-- 
cgit 1.4.1-3-g733a5


From 09f7a377a663043c6f63ded70436ac0969e4abc7 Mon Sep 17 00:00:00 2001
From: Thom Chiovoloni <chiovolonit@gmail.com>
Date: Thu, 10 Sep 2020 14:50:10 -0700
Subject: Add comments to the invalid_atomic_ordering example

---
 clippy_lints/src/atomic_ordering.rs | 15 ++++++++++++---
 1 file changed, 12 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/atomic_ordering.rs b/clippy_lints/src/atomic_ordering.rs
index 614e33a06da..703d8a6f62b 100644
--- a/clippy_lints/src/atomic_ordering.rs
+++ b/clippy_lints/src/atomic_ordering.rs
@@ -22,18 +22,27 @@ declare_clippy_lint! {
     ///
     /// let x = AtomicU8::new(0);
     ///
+    /// // Bad: `Release` and `AcqRel` cannot be used for `load`.
     /// let _ = x.load(Ordering::Release);
     /// let _ = x.load(Ordering::AcqRel);
     ///
+    /// // Bad: `Acquire` and `AcqRel` cannot be used for `store`.
     /// x.store(1, Ordering::Acquire);
     /// x.store(2, Ordering::AcqRel);
     ///
+    /// // Bad: `Relaxed` cannot be used as a fence's ordering.
     /// atomic::fence(Ordering::Relaxed);
     /// atomic::compiler_fence(Ordering::Relaxed);
     ///
-    /// let _ = x.compare_exchange(1, 2, Ordering::Relaxed, Ordering::SeqCst);
-    /// let _ = x.compare_exchange_weak(2, 3, Ordering::SeqCst, Ordering::Release);
-    /// let _ = x.fetch_update(Ordering::AcqRel, Ordering::AcqRel, |val| Some(val + val));
+    /// // Bad: `Release` and `AcqRel` are both always invalid
+    /// // for the failure ordering (the last arg).
+    /// let _ = x.compare_exchange(1, 2, Ordering::SeqCst, Ordering::Release);
+    /// let _ = x.compare_exchange_weak(2, 3, Ordering::AcqRel, Ordering::AcqRel);
+    ///
+    /// // Bad: The failure ordering is not allowed to be
+    /// // stronger than the success order, and `SeqCst` is
+    /// // stronger than `Relaxed`.
+    /// let _ = x.fetch_update(Ordering::Relaxed, Ordering::SeqCst, |val| Some(val + val));
     /// ```
     pub INVALID_ATOMIC_ORDERING,
     correctness,
-- 
cgit 1.4.1-3-g733a5


From 2487f8f461134f93459415642f730ac6c4a2d659 Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Fri, 11 Sep 2020 16:52:25 +0200
Subject: into_iter_on_ref: rephrase lint message: will not move the x -> will
 not consume the x

imo that's a bit clearer.
---
 clippy_lints/src/methods/mod.rs  |  2 +-
 tests/ui/into_iter_on_ref.stderr | 54 ++++++++++++++++++++--------------------
 2 files changed, 28 insertions(+), 28 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index ba69c8266b1..98e027b6d22 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3374,7 +3374,7 @@ fn lint_into_iter(cx: &LateContext<'_>, expr: &hir::Expr<'_>, self_ref_ty: Ty<'_
             INTO_ITER_ON_REF,
             method_span,
             &format!(
-                "this `.into_iter()` call is equivalent to `.{}()` and will not move the `{}`",
+                "this `.into_iter()` call is equivalent to `.{}()` and will not consume the `{}`",
                 method_name, kind,
             ),
             "call directly",
diff --git a/tests/ui/into_iter_on_ref.stderr b/tests/ui/into_iter_on_ref.stderr
index 1cd6400b019..28003b365bb 100644
--- a/tests/ui/into_iter_on_ref.stderr
+++ b/tests/ui/into_iter_on_ref.stderr
@@ -1,4 +1,4 @@
-error: this `.into_iter()` call is equivalent to `.iter()` and will not move the `Vec`
+error: this `.into_iter()` call is equivalent to `.iter()` and will not consume the `Vec`
   --> $DIR/into_iter_on_ref.rs:14:30
    |
 LL |     let _ = (&vec![1, 2, 3]).into_iter(); //~ WARN equivalent to .iter()
@@ -6,157 +6,157 @@ LL |     let _ = (&vec![1, 2, 3]).into_iter(); //~ WARN equivalent to .iter()
    |
    = note: `-D clippy::into-iter-on-ref` implied by `-D warnings`
 
-error: this `.into_iter()` call is equivalent to `.iter()` and will not move the `slice`
+error: this `.into_iter()` call is equivalent to `.iter()` and will not consume the `slice`
   --> $DIR/into_iter_on_ref.rs:15:46
    |
 LL |     let _ = vec![1, 2, 3].into_boxed_slice().into_iter(); //~ WARN equivalent to .iter()
    |                                              ^^^^^^^^^ help: call directly: `iter`
 
-error: this `.into_iter()` call is equivalent to `.iter()` and will not move the `slice`
+error: this `.into_iter()` call is equivalent to `.iter()` and will not consume the `slice`
   --> $DIR/into_iter_on_ref.rs:16:41
    |
 LL |     let _ = std::rc::Rc::from(&[X][..]).into_iter(); //~ WARN equivalent to .iter()
    |                                         ^^^^^^^^^ help: call directly: `iter`
 
-error: this `.into_iter()` call is equivalent to `.iter()` and will not move the `slice`
+error: this `.into_iter()` call is equivalent to `.iter()` and will not consume the `slice`
   --> $DIR/into_iter_on_ref.rs:17:44
    |
 LL |     let _ = std::sync::Arc::from(&[X][..]).into_iter(); //~ WARN equivalent to .iter()
    |                                            ^^^^^^^^^ help: call directly: `iter`
 
-error: this `.into_iter()` call is equivalent to `.iter()` and will not move the `array`
+error: this `.into_iter()` call is equivalent to `.iter()` and will not consume the `array`
   --> $DIR/into_iter_on_ref.rs:19:32
    |
 LL |     let _ = (&&&&&&&[1, 2, 3]).into_iter(); //~ ERROR equivalent to .iter()
    |                                ^^^^^^^^^ help: call directly: `iter`
 
-error: this `.into_iter()` call is equivalent to `.iter()` and will not move the `array`
+error: this `.into_iter()` call is equivalent to `.iter()` and will not consume the `array`
   --> $DIR/into_iter_on_ref.rs:20:36
    |
 LL |     let _ = (&&&&mut &&&[1, 2, 3]).into_iter(); //~ ERROR equivalent to .iter()
    |                                    ^^^^^^^^^ help: call directly: `iter`
 
-error: this `.into_iter()` call is equivalent to `.iter_mut()` and will not move the `array`
+error: this `.into_iter()` call is equivalent to `.iter_mut()` and will not consume the `array`
   --> $DIR/into_iter_on_ref.rs:21:40
    |
 LL |     let _ = (&mut &mut &mut [1, 2, 3]).into_iter(); //~ ERROR equivalent to .iter_mut()
    |                                        ^^^^^^^^^ help: call directly: `iter_mut`
 
-error: this `.into_iter()` call is equivalent to `.iter()` and will not move the `Option`
+error: this `.into_iter()` call is equivalent to `.iter()` and will not consume the `Option`
   --> $DIR/into_iter_on_ref.rs:23:24
    |
 LL |     let _ = (&Some(4)).into_iter(); //~ WARN equivalent to .iter()
    |                        ^^^^^^^^^ help: call directly: `iter`
 
-error: this `.into_iter()` call is equivalent to `.iter_mut()` and will not move the `Option`
+error: this `.into_iter()` call is equivalent to `.iter_mut()` and will not consume the `Option`
   --> $DIR/into_iter_on_ref.rs:24:28
    |
 LL |     let _ = (&mut Some(5)).into_iter(); //~ WARN equivalent to .iter_mut()
    |                            ^^^^^^^^^ help: call directly: `iter_mut`
 
-error: this `.into_iter()` call is equivalent to `.iter()` and will not move the `Result`
+error: this `.into_iter()` call is equivalent to `.iter()` and will not consume the `Result`
   --> $DIR/into_iter_on_ref.rs:25:32
    |
 LL |     let _ = (&Ok::<_, i32>(6)).into_iter(); //~ WARN equivalent to .iter()
    |                                ^^^^^^^^^ help: call directly: `iter`
 
-error: this `.into_iter()` call is equivalent to `.iter_mut()` and will not move the `Result`
+error: this `.into_iter()` call is equivalent to `.iter_mut()` and will not consume the `Result`
   --> $DIR/into_iter_on_ref.rs:26:37
    |
 LL |     let _ = (&mut Err::<i32, _>(7)).into_iter(); //~ WARN equivalent to .iter_mut()
    |                                     ^^^^^^^^^ help: call directly: `iter_mut`
 
-error: this `.into_iter()` call is equivalent to `.iter()` and will not move the `Vec`
+error: this `.into_iter()` call is equivalent to `.iter()` and will not consume the `Vec`
   --> $DIR/into_iter_on_ref.rs:27:34
    |
 LL |     let _ = (&Vec::<i32>::new()).into_iter(); //~ WARN equivalent to .iter()
    |                                  ^^^^^^^^^ help: call directly: `iter`
 
-error: this `.into_iter()` call is equivalent to `.iter_mut()` and will not move the `Vec`
+error: this `.into_iter()` call is equivalent to `.iter_mut()` and will not consume the `Vec`
   --> $DIR/into_iter_on_ref.rs:28:38
    |
 LL |     let _ = (&mut Vec::<i32>::new()).into_iter(); //~ WARN equivalent to .iter_mut()
    |                                      ^^^^^^^^^ help: call directly: `iter_mut`
 
-error: this `.into_iter()` call is equivalent to `.iter()` and will not move the `BTreeMap`
+error: this `.into_iter()` call is equivalent to `.iter()` and will not consume the `BTreeMap`
   --> $DIR/into_iter_on_ref.rs:29:44
    |
 LL |     let _ = (&BTreeMap::<i32, u64>::new()).into_iter(); //~ WARN equivalent to .iter()
    |                                            ^^^^^^^^^ help: call directly: `iter`
 
-error: this `.into_iter()` call is equivalent to `.iter_mut()` and will not move the `BTreeMap`
+error: this `.into_iter()` call is equivalent to `.iter_mut()` and will not consume the `BTreeMap`
   --> $DIR/into_iter_on_ref.rs:30:48
    |
 LL |     let _ = (&mut BTreeMap::<i32, u64>::new()).into_iter(); //~ WARN equivalent to .iter_mut()
    |                                                ^^^^^^^^^ help: call directly: `iter_mut`
 
-error: this `.into_iter()` call is equivalent to `.iter()` and will not move the `VecDeque`
+error: this `.into_iter()` call is equivalent to `.iter()` and will not consume the `VecDeque`
   --> $DIR/into_iter_on_ref.rs:31:39
    |
 LL |     let _ = (&VecDeque::<i32>::new()).into_iter(); //~ WARN equivalent to .iter()
    |                                       ^^^^^^^^^ help: call directly: `iter`
 
-error: this `.into_iter()` call is equivalent to `.iter_mut()` and will not move the `VecDeque`
+error: this `.into_iter()` call is equivalent to `.iter_mut()` and will not consume the `VecDeque`
   --> $DIR/into_iter_on_ref.rs:32:43
    |
 LL |     let _ = (&mut VecDeque::<i32>::new()).into_iter(); //~ WARN equivalent to .iter_mut()
    |                                           ^^^^^^^^^ help: call directly: `iter_mut`
 
-error: this `.into_iter()` call is equivalent to `.iter()` and will not move the `LinkedList`
+error: this `.into_iter()` call is equivalent to `.iter()` and will not consume the `LinkedList`
   --> $DIR/into_iter_on_ref.rs:33:41
    |
 LL |     let _ = (&LinkedList::<i32>::new()).into_iter(); //~ WARN equivalent to .iter()
    |                                         ^^^^^^^^^ help: call directly: `iter`
 
-error: this `.into_iter()` call is equivalent to `.iter_mut()` and will not move the `LinkedList`
+error: this `.into_iter()` call is equivalent to `.iter_mut()` and will not consume the `LinkedList`
   --> $DIR/into_iter_on_ref.rs:34:45
    |
 LL |     let _ = (&mut LinkedList::<i32>::new()).into_iter(); //~ WARN equivalent to .iter_mut()
    |                                             ^^^^^^^^^ help: call directly: `iter_mut`
 
-error: this `.into_iter()` call is equivalent to `.iter()` and will not move the `HashMap`
+error: this `.into_iter()` call is equivalent to `.iter()` and will not consume the `HashMap`
   --> $DIR/into_iter_on_ref.rs:35:43
    |
 LL |     let _ = (&HashMap::<i32, u64>::new()).into_iter(); //~ WARN equivalent to .iter()
    |                                           ^^^^^^^^^ help: call directly: `iter`
 
-error: this `.into_iter()` call is equivalent to `.iter_mut()` and will not move the `HashMap`
+error: this `.into_iter()` call is equivalent to `.iter_mut()` and will not consume the `HashMap`
   --> $DIR/into_iter_on_ref.rs:36:47
    |
 LL |     let _ = (&mut HashMap::<i32, u64>::new()).into_iter(); //~ WARN equivalent to .iter_mut()
    |                                               ^^^^^^^^^ help: call directly: `iter_mut`
 
-error: this `.into_iter()` call is equivalent to `.iter()` and will not move the `BTreeSet`
+error: this `.into_iter()` call is equivalent to `.iter()` and will not consume the `BTreeSet`
   --> $DIR/into_iter_on_ref.rs:38:39
    |
 LL |     let _ = (&BTreeSet::<i32>::new()).into_iter(); //~ WARN equivalent to .iter()
    |                                       ^^^^^^^^^ help: call directly: `iter`
 
-error: this `.into_iter()` call is equivalent to `.iter()` and will not move the `BinaryHeap`
+error: this `.into_iter()` call is equivalent to `.iter()` and will not consume the `BinaryHeap`
   --> $DIR/into_iter_on_ref.rs:39:41
    |
 LL |     let _ = (&BinaryHeap::<i32>::new()).into_iter(); //~ WARN equivalent to .iter()
    |                                         ^^^^^^^^^ help: call directly: `iter`
 
-error: this `.into_iter()` call is equivalent to `.iter()` and will not move the `HashSet`
+error: this `.into_iter()` call is equivalent to `.iter()` and will not consume the `HashSet`
   --> $DIR/into_iter_on_ref.rs:40:38
    |
 LL |     let _ = (&HashSet::<i32>::new()).into_iter(); //~ WARN equivalent to .iter()
    |                                      ^^^^^^^^^ help: call directly: `iter`
 
-error: this `.into_iter()` call is equivalent to `.iter()` and will not move the `Path`
+error: this `.into_iter()` call is equivalent to `.iter()` and will not consume the `Path`
   --> $DIR/into_iter_on_ref.rs:41:43
    |
 LL |     let _ = std::path::Path::new("12/34").into_iter(); //~ WARN equivalent to .iter()
    |                                           ^^^^^^^^^ help: call directly: `iter`
 
-error: this `.into_iter()` call is equivalent to `.iter()` and will not move the `PathBuf`
+error: this `.into_iter()` call is equivalent to `.iter()` and will not consume the `PathBuf`
   --> $DIR/into_iter_on_ref.rs:42:47
    |
 LL |     let _ = std::path::PathBuf::from("12/34").into_iter(); //~ ERROR equivalent to .iter()
    |                                               ^^^^^^^^^ help: call directly: `iter`
 
-error: this `.into_iter()` call is equivalent to `.iter()` and will not move the `array`
+error: this `.into_iter()` call is equivalent to `.iter()` and will not consume the `array`
   --> $DIR/into_iter_on_ref.rs:44:26
    |
 LL |     let _ = (&[1, 2, 3]).into_iter().next(); //~ WARN equivalent to .iter()
-- 
cgit 1.4.1-3-g733a5


From 7ba1a8fec42ca11c169bcff3650f9c1e108b6743 Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Sun, 13 Sep 2020 12:42:14 +0200
Subject: useless_conversion: show type in error message.

changelog: useless_conversion: show type in error message.
---
 clippy_lints/src/useless_conversion.rs | 10 +++++-----
 tests/ui/useless_conversion.stderr     | 22 +++++++++++-----------
 tests/ui/useless_conversion_try.stderr | 18 +++++++++---------
 3 files changed, 25 insertions(+), 25 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/useless_conversion.rs b/clippy_lints/src/useless_conversion.rs
index 615440e15f3..4e4a206a583 100644
--- a/clippy_lints/src/useless_conversion.rs
+++ b/clippy_lints/src/useless_conversion.rs
@@ -72,7 +72,7 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
                             cx,
                             USELESS_CONVERSION,
                             e.span,
-                            "useless conversion to the same type",
+                            &format!("useless conversion to the same type: `{}`", b),
                             "consider removing `.into()`",
                             sugg,
                             Applicability::MachineApplicable, // snippet
@@ -95,7 +95,7 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
                             cx,
                             USELESS_CONVERSION,
                             e.span,
-                            "useless conversion to the same type",
+                            &format!("useless conversion to the same type: `{}`", b),
                             "consider removing `.into_iter()`",
                             sugg,
                             Applicability::MachineApplicable, // snippet
@@ -116,7 +116,7 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
                                 cx,
                                 USELESS_CONVERSION,
                                 e.span,
-                                "useless conversion to the same type",
+                                &format!("useless conversion to the same type: `{}`", b),
                                 None,
                                 "consider removing `.try_into()`",
                             );
@@ -147,7 +147,7 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
                                     cx,
                                     USELESS_CONVERSION,
                                     e.span,
-                                    "useless conversion to the same type",
+                                    &format!("useless conversion to the same type: `{}`", b),
                                     None,
                                     &hint,
                                 );
@@ -166,7 +166,7 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
                                     cx,
                                     USELESS_CONVERSION,
                                     e.span,
-                                    "useless conversion to the same type",
+                                    &format!("useless conversion to the same type: `{}`", b),
                                     &sugg_msg,
                                     sugg.to_string(),
                                     Applicability::MachineApplicable, // snippet
diff --git a/tests/ui/useless_conversion.stderr b/tests/ui/useless_conversion.stderr
index f1e880d2696..11c6efb25cc 100644
--- a/tests/ui/useless_conversion.stderr
+++ b/tests/ui/useless_conversion.stderr
@@ -1,4 +1,4 @@
-error: useless conversion to the same type
+error: useless conversion to the same type: `T`
   --> $DIR/useless_conversion.rs:6:13
    |
 LL |     let _ = T::from(val);
@@ -10,61 +10,61 @@ note: the lint level is defined here
 LL | #![deny(clippy::useless_conversion)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: useless conversion to the same type
+error: useless conversion to the same type: `T`
   --> $DIR/useless_conversion.rs:7:5
    |
 LL |     val.into()
    |     ^^^^^^^^^^ help: consider removing `.into()`: `val`
 
-error: useless conversion to the same type
+error: useless conversion to the same type: `i32`
   --> $DIR/useless_conversion.rs:19:22
    |
 LL |         let _: i32 = 0i32.into();
    |                      ^^^^^^^^^^^ help: consider removing `.into()`: `0i32`
 
-error: useless conversion to the same type
+error: useless conversion to the same type: `std::string::String`
   --> $DIR/useless_conversion.rs:60:21
    |
 LL |     let _: String = "foo".to_string().into();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into()`: `"foo".to_string()`
 
-error: useless conversion to the same type
+error: useless conversion to the same type: `std::string::String`
   --> $DIR/useless_conversion.rs:61:21
    |
 LL |     let _: String = From::from("foo".to_string());
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `From::from()`: `"foo".to_string()`
 
-error: useless conversion to the same type
+error: useless conversion to the same type: `std::string::String`
   --> $DIR/useless_conversion.rs:62:13
    |
 LL |     let _ = String::from("foo".to_string());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `String::from()`: `"foo".to_string()`
 
-error: useless conversion to the same type
+error: useless conversion to the same type: `std::string::String`
   --> $DIR/useless_conversion.rs:63:13
    |
 LL |     let _ = String::from(format!("A: {:04}", 123));
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `String::from()`: `format!("A: {:04}", 123)`
 
-error: useless conversion to the same type
+error: useless conversion to the same type: `std::str::Lines`
   --> $DIR/useless_conversion.rs:64:13
    |
 LL |     let _ = "".lines().into_iter();
    |             ^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `"".lines()`
 
-error: useless conversion to the same type
+error: useless conversion to the same type: `std::vec::IntoIter<i32>`
   --> $DIR/useless_conversion.rs:65:13
    |
 LL |     let _ = vec![1, 2, 3].into_iter().into_iter();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `vec![1, 2, 3].into_iter()`
 
-error: useless conversion to the same type
+error: useless conversion to the same type: `std::string::String`
   --> $DIR/useless_conversion.rs:66:21
    |
 LL |     let _: String = format!("Hello {}", "world").into();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into()`: `format!("Hello {}", "world")`
 
-error: useless conversion to the same type
+error: useless conversion to the same type: `i32`
   --> $DIR/useless_conversion.rs:71:13
    |
 LL |     let _ = i32::from(a + b) * 3;
diff --git a/tests/ui/useless_conversion_try.stderr b/tests/ui/useless_conversion_try.stderr
index b765727c168..2e0d9129bfb 100644
--- a/tests/ui/useless_conversion_try.stderr
+++ b/tests/ui/useless_conversion_try.stderr
@@ -1,4 +1,4 @@
-error: useless conversion to the same type
+error: useless conversion to the same type: `T`
   --> $DIR/useless_conversion_try.rs:6:13
    |
 LL |     let _ = T::try_from(val).unwrap();
@@ -11,7 +11,7 @@ LL | #![deny(clippy::useless_conversion)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
    = help: consider removing `T::try_from()`
 
-error: useless conversion to the same type
+error: useless conversion to the same type: `T`
   --> $DIR/useless_conversion_try.rs:7:5
    |
 LL |     val.try_into().unwrap()
@@ -19,7 +19,7 @@ LL |     val.try_into().unwrap()
    |
    = help: consider removing `.try_into()`
 
-error: useless conversion to the same type
+error: useless conversion to the same type: `std::string::String`
   --> $DIR/useless_conversion_try.rs:29:21
    |
 LL |     let _: String = "foo".to_string().try_into().unwrap();
@@ -27,7 +27,7 @@ LL |     let _: String = "foo".to_string().try_into().unwrap();
    |
    = help: consider removing `.try_into()`
 
-error: useless conversion to the same type
+error: useless conversion to the same type: `std::string::String`
   --> $DIR/useless_conversion_try.rs:30:21
    |
 LL |     let _: String = TryFrom::try_from("foo".to_string()).unwrap();
@@ -35,7 +35,7 @@ LL |     let _: String = TryFrom::try_from("foo".to_string()).unwrap();
    |
    = help: consider removing `TryFrom::try_from()`
 
-error: useless conversion to the same type
+error: useless conversion to the same type: `std::string::String`
   --> $DIR/useless_conversion_try.rs:31:13
    |
 LL |     let _ = String::try_from("foo".to_string()).unwrap();
@@ -43,7 +43,7 @@ LL |     let _ = String::try_from("foo".to_string()).unwrap();
    |
    = help: consider removing `String::try_from()`
 
-error: useless conversion to the same type
+error: useless conversion to the same type: `std::string::String`
   --> $DIR/useless_conversion_try.rs:32:13
    |
 LL |     let _ = String::try_from(format!("A: {:04}", 123)).unwrap();
@@ -51,7 +51,7 @@ LL |     let _ = String::try_from(format!("A: {:04}", 123)).unwrap();
    |
    = help: consider removing `String::try_from()`
 
-error: useless conversion to the same type
+error: useless conversion to the same type: `std::string::String`
   --> $DIR/useless_conversion_try.rs:33:21
    |
 LL |     let _: String = format!("Hello {}", "world").try_into().unwrap();
@@ -59,7 +59,7 @@ LL |     let _: String = format!("Hello {}", "world").try_into().unwrap();
    |
    = help: consider removing `.try_into()`
 
-error: useless conversion to the same type
+error: useless conversion to the same type: `std::string::String`
   --> $DIR/useless_conversion_try.rs:34:21
    |
 LL |     let _: String = "".to_owned().try_into().unwrap();
@@ -67,7 +67,7 @@ LL |     let _: String = "".to_owned().try_into().unwrap();
    |
    = help: consider removing `.try_into()`
 
-error: useless conversion to the same type
+error: useless conversion to the same type: `std::string::String`
   --> $DIR/useless_conversion_try.rs:35:27
    |
 LL |     let _: String = match String::from("_").try_into() {
-- 
cgit 1.4.1-3-g733a5


From 9ff7e5d98413d10dd74e3b9509c7a58f6dd6818b Mon Sep 17 00:00:00 2001
From: Takayuki Nakata <f.seasons017@gmail.com>
Date: Sun, 13 Sep 2020 23:23:16 +0900
Subject: Downgrade `verbose_bit_mask` to pedantic

---
 clippy_lints/src/bit_mask.rs   | 2 +-
 clippy_lints/src/lib.rs        | 3 +--
 src/lintlist/mod.rs            | 2 +-
 tests/ui/trailing_zeros.rs     | 1 +
 tests/ui/trailing_zeros.stderr | 4 ++--
 5 files changed, 6 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/bit_mask.rs b/clippy_lints/src/bit_mask.rs
index 81a34021e8a..a4ee54076ee 100644
--- a/clippy_lints/src/bit_mask.rs
+++ b/clippy_lints/src/bit_mask.rs
@@ -90,7 +90,7 @@ declare_clippy_lint! {
     /// if x & 0b1111 == 0 { }
     /// ```
     pub VERBOSE_BIT_MASK,
-    style,
+    pedantic,
     "expressions where a bit mask is less readable than the corresponding method call"
 }
 
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 1795fd10fa1..c017c5cb5d0 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1157,6 +1157,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_group(true, "clippy::pedantic", Some("clippy_pedantic"), vec![
         LintId::of(&attrs::INLINE_ALWAYS),
         LintId::of(&await_holding_lock::AWAIT_HOLDING_LOCK),
+        LintId::of(&bit_mask::VERBOSE_BIT_MASK),
         LintId::of(&checked_conversions::CHECKED_CONVERSIONS),
         LintId::of(&copies::MATCH_SAME_ARMS),
         LintId::of(&copies::SAME_FUNCTIONS_IN_IF_CONDITION),
@@ -1254,7 +1255,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&attrs::USELESS_ATTRIBUTE),
         LintId::of(&bit_mask::BAD_BIT_MASK),
         LintId::of(&bit_mask::INEFFECTIVE_BIT_MASK),
-        LintId::of(&bit_mask::VERBOSE_BIT_MASK),
         LintId::of(&blacklisted_name::BLACKLISTED_NAME),
         LintId::of(&blocks_in_if_conditions::BLOCKS_IN_IF_CONDITIONS),
         LintId::of(&booleans::LOGIC_BUG),
@@ -1512,7 +1512,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&assign_ops::ASSIGN_OP_PATTERN),
         LintId::of(&attrs::BLANKET_CLIPPY_RESTRICTION_LINTS),
         LintId::of(&attrs::UNKNOWN_CLIPPY_LINTS),
-        LintId::of(&bit_mask::VERBOSE_BIT_MASK),
         LintId::of(&blacklisted_name::BLACKLISTED_NAME),
         LintId::of(&blocks_in_if_conditions::BLOCKS_IN_IF_CONDITIONS),
         LintId::of(&collapsible_if::COLLAPSIBLE_IF),
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index 04d486438b1..a7d38c93433 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -2637,7 +2637,7 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
     },
     Lint {
         name: "verbose_bit_mask",
-        group: "style",
+        group: "pedantic",
         desc: "expressions where a bit mask is less readable than the corresponding method call",
         deprecation: None,
         module: "bit_mask",
diff --git a/tests/ui/trailing_zeros.rs b/tests/ui/trailing_zeros.rs
index 1cef8c2cfc9..fbdc977b769 100644
--- a/tests/ui/trailing_zeros.rs
+++ b/tests/ui/trailing_zeros.rs
@@ -1,4 +1,5 @@
 #![allow(unused_parens)]
+#![warn(clippy::verbose_bit_mask)]
 
 fn main() {
     let x: i32 = 42;
diff --git a/tests/ui/trailing_zeros.stderr b/tests/ui/trailing_zeros.stderr
index 320d9cc3f64..79855111830 100644
--- a/tests/ui/trailing_zeros.stderr
+++ b/tests/ui/trailing_zeros.stderr
@@ -1,5 +1,5 @@
 error: bit mask could be simplified with a call to `trailing_zeros`
-  --> $DIR/trailing_zeros.rs:5:13
+  --> $DIR/trailing_zeros.rs:6:13
    |
 LL |     let _ = (x & 0b1111 == 0); // suggest trailing_zeros
    |             ^^^^^^^^^^^^^^^^^ help: try: `x.trailing_zeros() >= 4`
@@ -7,7 +7,7 @@ LL |     let _ = (x & 0b1111 == 0); // suggest trailing_zeros
    = note: `-D clippy::verbose-bit-mask` implied by `-D warnings`
 
 error: bit mask could be simplified with a call to `trailing_zeros`
-  --> $DIR/trailing_zeros.rs:6:13
+  --> $DIR/trailing_zeros.rs:7:13
    |
 LL |     let _ = x & 0b1_1111 == 0; // suggest trailing_zeros
    |             ^^^^^^^^^^^^^^^^^ help: try: `x.trailing_zeros() >= 5`
-- 
cgit 1.4.1-3-g733a5


From d1f0f04a488d027fdf91e08cdf25df00fb677205 Mon Sep 17 00:00:00 2001
From: Michael Wright <mikerite@lavabit.com>
Date: Mon, 14 Sep 2020 06:11:35 +0200
Subject: New lint: `manual-strip`

Add a new lint, `manual-strip`, that suggests using the `str::strip_prefix`
and `str::strip_suffix` methods introduced in Rust 1.45 when the same
functionality is performed 'manually'.

Closes #5734
---
 CHANGELOG.md                     |   1 +
 clippy_lints/src/lib.rs          |   5 +
 clippy_lints/src/manual_strip.rs | 246 +++++++++++++++++++++++++++++++++++++++
 clippy_lints/src/utils/paths.rs  |   3 +
 src/lintlist/mod.rs              |   7 ++
 tests/ui/manual_strip.rs         |  59 ++++++++++
 tests/ui/manual_strip.stderr     | 132 +++++++++++++++++++++
 7 files changed, 453 insertions(+)
 create mode 100644 clippy_lints/src/manual_strip.rs
 create mode 100644 tests/ui/manual_strip.rs
 create mode 100644 tests/ui/manual_strip.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 285a2ff8060..a6fafdf5357 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1672,6 +1672,7 @@ Released 2018-09-13
 [`manual_memcpy`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_memcpy
 [`manual_non_exhaustive`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_non_exhaustive
 [`manual_saturating_arithmetic`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_saturating_arithmetic
+[`manual_strip`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_strip
 [`manual_swap`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_swap
 [`many_single_char_names`]: https://rust-lang.github.io/rust-clippy/master/index.html#many_single_char_names
 [`map_clone`]: https://rust-lang.github.io/rust-clippy/master/index.html#map_clone
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index c017c5cb5d0..38ddc69c8cb 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -230,6 +230,7 @@ mod macro_use;
 mod main_recursion;
 mod manual_async_fn;
 mod manual_non_exhaustive;
+mod manual_strip;
 mod map_clone;
 mod map_identity;
 mod map_unit_fn;
@@ -626,6 +627,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &main_recursion::MAIN_RECURSION,
         &manual_async_fn::MANUAL_ASYNC_FN,
         &manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE,
+        &manual_strip::MANUAL_STRIP,
         &map_clone::MAP_CLONE,
         &map_identity::MAP_IDENTITY,
         &map_unit_fn::OPTION_MAP_UNIT_FN,
@@ -1109,6 +1111,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box self_assignment::SelfAssignment);
     store.register_late_pass(|| box float_equality_without_abs::FloatEqualityWithoutAbs);
     store.register_late_pass(|| box async_yields_async::AsyncYieldsAsync);
+    store.register_late_pass(|| box manual_strip::ManualStrip);
 
     store.register_group(true, "clippy::restriction", Some("clippy_restriction"), vec![
         LintId::of(&arithmetic::FLOAT_ARITHMETIC),
@@ -1335,6 +1338,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&main_recursion::MAIN_RECURSION),
         LintId::of(&manual_async_fn::MANUAL_ASYNC_FN),
         LintId::of(&manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE),
+        LintId::of(&manual_strip::MANUAL_STRIP),
         LintId::of(&map_clone::MAP_CLONE),
         LintId::of(&map_identity::MAP_IDENTITY),
         LintId::of(&map_unit_fn::OPTION_MAP_UNIT_FN),
@@ -1626,6 +1630,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&loops::EXPLICIT_COUNTER_LOOP),
         LintId::of(&loops::MUT_RANGE_BOUND),
         LintId::of(&loops::WHILE_LET_LOOP),
+        LintId::of(&manual_strip::MANUAL_STRIP),
         LintId::of(&map_identity::MAP_IDENTITY),
         LintId::of(&map_unit_fn::OPTION_MAP_UNIT_FN),
         LintId::of(&map_unit_fn::RESULT_MAP_UNIT_FN),
diff --git a/clippy_lints/src/manual_strip.rs b/clippy_lints/src/manual_strip.rs
new file mode 100644
index 00000000000..127938aecd6
--- /dev/null
+++ b/clippy_lints/src/manual_strip.rs
@@ -0,0 +1,246 @@
+use crate::consts::{constant, Constant};
+use crate::utils::usage::mutated_variables;
+use crate::utils::{
+    eq_expr_value, higher, match_def_path, multispan_sugg, paths, qpath_res, snippet, span_lint_and_then,
+};
+
+use if_chain::if_chain;
+use rustc_ast::ast::LitKind;
+use rustc_hir::def::Res;
+use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
+use rustc_hir::BinOpKind;
+use rustc_hir::{BorrowKind, Expr, ExprKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::hir::map::Map;
+use rustc_middle::ty;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::source_map::Spanned;
+use rustc_span::Span;
+
+declare_clippy_lint! {
+    /// **What it does:**
+    /// Suggests using `strip_{prefix,suffix}` over `str::{starts,ends}_with` and slicing using
+    /// the pattern's length.
+    ///
+    /// **Why is this bad?**
+    /// Using `str:strip_{prefix,suffix}` is safer and may have better performance as there is no
+    /// slicing which may panic and the compiler does not need to insert this panic code. It is
+    /// also sometimes more readable as it removes the need for duplicating or storing the pattern
+    /// used by `str::{starts,ends}_with` and in the slicing.
+    ///
+    /// **Known problems:**
+    /// None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// let s = "hello, world!";
+    /// if s.starts_with("hello, ") {
+    ///     assert_eq!(s["hello, ".len()..].to_uppercase(), "WORLD!");
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// let s = "hello, world!";
+    /// if let Some(end) = s.strip_prefix("hello, ") {
+    ///     assert_eq!(end.to_uppercase(), "WORLD!");
+    /// }
+    /// ```
+    pub MANUAL_STRIP,
+    complexity,
+    "suggests using `strip_{prefix,suffix}` over `str::{starts,ends}_with` and slicing"
+}
+
+declare_lint_pass!(ManualStrip => [MANUAL_STRIP]);
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+enum StripKind {
+    Prefix,
+    Suffix,
+}
+
+impl<'tcx> LateLintPass<'tcx> for ManualStrip {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        if_chain! {
+            if let Some((cond, then, _)) = higher::if_block(&expr);
+            if let ExprKind::MethodCall(_, _, [target_arg, pattern], _) = cond.kind;
+            if let Some(method_def_id) = cx.typeck_results().type_dependent_def_id(cond.hir_id);
+            if let ExprKind::Path(target_path) = &target_arg.kind;
+            then {
+                let strip_kind = if match_def_path(cx, method_def_id, &paths::STR_STARTS_WITH) {
+                    StripKind::Prefix
+                } else if match_def_path(cx, method_def_id, &paths::STR_ENDS_WITH) {
+                    StripKind::Suffix
+                } else {
+                    return;
+                };
+                let target_res = qpath_res(cx, &target_path, target_arg.hir_id);
+                if target_res == Res::Err {
+                    return;
+                };
+
+                if_chain! {
+                    if let Res::Local(hir_id) = target_res;
+                    if let Some(used_mutably) = mutated_variables(then, cx);
+                    if used_mutably.contains(&hir_id);
+                    then {
+                        return;
+                    }
+                }
+
+                let strippings = find_stripping(cx, strip_kind, target_res, pattern, then);
+                if !strippings.is_empty() {
+
+                    let kind_word = match strip_kind {
+                        StripKind::Prefix => "prefix",
+                        StripKind::Suffix => "suffix",
+                    };
+
+                    let test_span = expr.span.until(then.span);
+                    span_lint_and_then(cx, MANUAL_STRIP, strippings[0], &format!("stripping a {} manually", kind_word), |diag| {
+                        diag.span_note(test_span, &format!("the {} was tested here", kind_word));
+                        multispan_sugg(
+                            diag,
+                            &format!("try using the `strip_{}` method", kind_word),
+                            vec![(test_span,
+                                  format!("if let Some(<stripped>) = {}.strip_{}({}) ",
+                                          snippet(cx, target_arg.span, ".."),
+                                          kind_word,
+                                          snippet(cx, pattern.span, "..")))]
+                            .into_iter().chain(strippings.into_iter().map(|span| (span, "<stripped>".into()))),
+                        )
+                    });
+                }
+            }
+        }
+    }
+}
+
+// Returns `Some(arg)` if `expr` matches `arg.len()` and `None` otherwise.
+fn len_arg<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<&'tcx Expr<'tcx>> {
+    if_chain! {
+        if let ExprKind::MethodCall(_, _, [arg], _) = expr.kind;
+        if let Some(method_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
+        if match_def_path(cx, method_def_id, &paths::STR_LEN);
+        then {
+            Some(arg)
+        }
+        else {
+            None
+        }
+    }
+}
+
+// Returns the length of the `expr` if it's a constant string or char.
+fn constant_length(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<u128> {
+    let (value, _) = constant(cx, cx.typeck_results(), expr)?;
+    match value {
+        Constant::Str(value) => Some(value.len() as u128),
+        Constant::Char(value) => Some(value.len_utf8() as u128),
+        _ => None,
+    }
+}
+
+// Tests if `expr` equals the length of the pattern.
+fn eq_pattern_length<'tcx>(cx: &LateContext<'tcx>, pattern: &Expr<'_>, expr: &'tcx Expr<'_>) -> bool {
+    if let ExprKind::Lit(Spanned {
+        node: LitKind::Int(n, _),
+        ..
+    }) = expr.kind
+    {
+        constant_length(cx, pattern).map_or(false, |length| length == n)
+    } else {
+        len_arg(cx, expr).map_or(false, |arg| eq_expr_value(cx, pattern, arg))
+    }
+}
+
+// Tests if `expr` is a `&str`.
+fn is_ref_str(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+    match cx.typeck_results().expr_ty_adjusted(&expr).kind() {
+        ty::Ref(_, ty, _) => ty.is_str(),
+        _ => false,
+    }
+}
+
+// Removes the outer `AddrOf` expression if needed.
+fn peel_ref<'a>(expr: &'a Expr<'_>) -> &'a Expr<'a> {
+    if let ExprKind::AddrOf(BorrowKind::Ref, _, unref) = &expr.kind {
+        unref
+    } else {
+        expr
+    }
+}
+
+// Find expressions where `target` is stripped using the length of `pattern`.
+// We'll suggest replacing these expressions with the result of the `strip_{prefix,suffix}`
+// method.
+fn find_stripping<'tcx>(
+    cx: &LateContext<'tcx>,
+    strip_kind: StripKind,
+    target: Res,
+    pattern: &'tcx Expr<'_>,
+    expr: &'tcx Expr<'_>,
+) -> Vec<Span> {
+    struct StrippingFinder<'a, 'tcx> {
+        cx: &'a LateContext<'tcx>,
+        strip_kind: StripKind,
+        target: Res,
+        pattern: &'tcx Expr<'tcx>,
+        results: Vec<Span>,
+    }
+
+    impl<'a, 'tcx> Visitor<'tcx> for StrippingFinder<'a, 'tcx> {
+        type Map = Map<'tcx>;
+        fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+            NestedVisitorMap::None
+        }
+
+        fn visit_expr(&mut self, ex: &'tcx Expr<'_>) {
+            if_chain! {
+                if is_ref_str(self.cx, ex);
+                let unref = peel_ref(ex);
+                if let ExprKind::Index(indexed, index) = &unref.kind;
+                if let Some(range) = higher::range(index);
+                if let higher::Range { start, end, .. } = range;
+                if let ExprKind::Path(path) = &indexed.kind;
+                if qpath_res(self.cx, path, ex.hir_id) == self.target;
+                then {
+                    match (self.strip_kind, start, end) {
+                        (StripKind::Prefix, Some(start), None) => {
+                            if eq_pattern_length(self.cx, self.pattern, start) {
+                                self.results.push(ex.span);
+                                return;
+                            }
+                        },
+                        (StripKind::Suffix, None, Some(end)) => {
+                            if_chain! {
+                                if let ExprKind::Binary(Spanned { node: BinOpKind::Sub, .. }, left, right) = end.kind;
+                                if let Some(left_arg) = len_arg(self.cx, left);
+                                if let ExprKind::Path(left_path) = &left_arg.kind;
+                                if qpath_res(self.cx, left_path, left_arg.hir_id) == self.target;
+                                if eq_pattern_length(self.cx, self.pattern, right);
+                                then {
+                                    self.results.push(ex.span);
+                                    return;
+                                }
+                            }
+                        },
+                        _ => {}
+                    }
+                }
+            }
+
+            walk_expr(self, ex);
+        }
+    }
+
+    let mut finder = StrippingFinder {
+        cx,
+        strip_kind,
+        target,
+        pattern,
+        results: vec![],
+    };
+    walk_expr(&mut finder, expr);
+    finder.results
+}
diff --git a/clippy_lints/src/utils/paths.rs b/clippy_lints/src/utils/paths.rs
index 65320d6a0e0..f0f7719e2fd 100644
--- a/clippy_lints/src/utils/paths.rs
+++ b/clippy_lints/src/utils/paths.rs
@@ -115,6 +115,9 @@ pub const STD_MEM_TRANSMUTE: [&str; 3] = ["std", "mem", "transmute"];
 pub const STD_PTR_NULL: [&str; 3] = ["std", "ptr", "null"];
 pub const STRING_AS_MUT_STR: [&str; 4] = ["alloc", "string", "String", "as_mut_str"];
 pub const STRING_AS_STR: [&str; 4] = ["alloc", "string", "String", "as_str"];
+pub const STR_ENDS_WITH: [&str; 4] = ["core", "str", "<impl str>", "ends_with"];
+pub const STR_LEN: [&str; 4] = ["core", "str", "<impl str>", "len"];
+pub const STR_STARTS_WITH: [&str; 4] = ["core", "str", "<impl str>", "starts_with"];
 pub const SYNTAX_CONTEXT: [&str; 3] = ["rustc_span", "hygiene", "SyntaxContext"];
 pub const TO_OWNED: [&str; 3] = ["alloc", "borrow", "ToOwned"];
 pub const TO_OWNED_METHOD: [&str; 4] = ["alloc", "borrow", "ToOwned", "to_owned"];
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index a7d38c93433..8bceef80abf 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -1144,6 +1144,13 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
         deprecation: None,
         module: "methods",
     },
+    Lint {
+        name: "manual_strip",
+        group: "complexity",
+        desc: "suggests using `strip_{prefix,suffix}` over `str::{starts,ends}_with` and slicing",
+        deprecation: None,
+        module: "manual_strip",
+    },
     Lint {
         name: "manual_swap",
         group: "complexity",
diff --git a/tests/ui/manual_strip.rs b/tests/ui/manual_strip.rs
new file mode 100644
index 00000000000..d1b4772c7de
--- /dev/null
+++ b/tests/ui/manual_strip.rs
@@ -0,0 +1,59 @@
+#![warn(clippy::manual_strip)]
+
+fn main() {
+    let s = "abc";
+
+    if s.starts_with("ab") {
+        str::to_string(&s["ab".len()..]);
+        s["ab".len()..].to_string();
+
+        str::to_string(&s[2..]);
+        s[2..].to_string();
+    }
+
+    if s.ends_with("bc") {
+        str::to_string(&s[..s.len() - "bc".len()]);
+        s[..s.len() - "bc".len()].to_string();
+
+        str::to_string(&s[..s.len() - 2]);
+        s[..s.len() - 2].to_string();
+    }
+
+    // Character patterns
+    if s.starts_with('a') {
+        str::to_string(&s[1..]);
+        s[1..].to_string();
+    }
+
+    // Variable prefix
+    let prefix = "ab";
+    if s.starts_with(prefix) {
+        str::to_string(&s[prefix.len()..]);
+    }
+
+    // Constant prefix
+    const PREFIX: &str = "ab";
+    if s.starts_with(PREFIX) {
+        str::to_string(&s[PREFIX.len()..]);
+        str::to_string(&s[2..]);
+    }
+
+    // Constant target
+    const TARGET: &str = "abc";
+    if TARGET.starts_with(prefix) {
+        str::to_string(&TARGET[prefix.len()..]);
+    }
+
+    // String target - not mutated.
+    let s1: String = "abc".into();
+    if s1.starts_with("ab") {
+        s1[2..].to_uppercase();
+    }
+
+    // String target - mutated. (Don't lint.)
+    let mut s2: String = "abc".into();
+    if s2.starts_with("ab") {
+        s2.push('d');
+        s2[2..].to_uppercase();
+    }
+}
diff --git a/tests/ui/manual_strip.stderr b/tests/ui/manual_strip.stderr
new file mode 100644
index 00000000000..1352a8713d4
--- /dev/null
+++ b/tests/ui/manual_strip.stderr
@@ -0,0 +1,132 @@
+error: stripping a prefix manually
+  --> $DIR/manual_strip.rs:7:24
+   |
+LL |         str::to_string(&s["ab".len()..]);
+   |                        ^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::manual-strip` implied by `-D warnings`
+note: the prefix was tested here
+  --> $DIR/manual_strip.rs:6:5
+   |
+LL |     if s.starts_with("ab") {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^
+help: try using the `strip_prefix` method
+   |
+LL |     if let Some(<stripped>) = s.strip_prefix("ab") {
+LL |         str::to_string(<stripped>);
+LL |         <stripped>.to_string();
+LL | 
+LL |         str::to_string(<stripped>);
+LL |         <stripped>.to_string();
+   |
+
+error: stripping a suffix manually
+  --> $DIR/manual_strip.rs:15:24
+   |
+LL |         str::to_string(&s[..s.len() - "bc".len()]);
+   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: the suffix was tested here
+  --> $DIR/manual_strip.rs:14:5
+   |
+LL |     if s.ends_with("bc") {
+   |     ^^^^^^^^^^^^^^^^^^^^^
+help: try using the `strip_suffix` method
+   |
+LL |     if let Some(<stripped>) = s.strip_suffix("bc") {
+LL |         str::to_string(<stripped>);
+LL |         <stripped>.to_string();
+LL | 
+LL |         str::to_string(<stripped>);
+LL |         <stripped>.to_string();
+   |
+
+error: stripping a prefix manually
+  --> $DIR/manual_strip.rs:24:24
+   |
+LL |         str::to_string(&s[1..]);
+   |                        ^^^^^^^
+   |
+note: the prefix was tested here
+  --> $DIR/manual_strip.rs:23:5
+   |
+LL |     if s.starts_with('a') {
+   |     ^^^^^^^^^^^^^^^^^^^^^^
+help: try using the `strip_prefix` method
+   |
+LL |     if let Some(<stripped>) = s.strip_prefix('a') {
+LL |         str::to_string(<stripped>);
+LL |         <stripped>.to_string();
+   |
+
+error: stripping a prefix manually
+  --> $DIR/manual_strip.rs:31:24
+   |
+LL |         str::to_string(&s[prefix.len()..]);
+   |                        ^^^^^^^^^^^^^^^^^^
+   |
+note: the prefix was tested here
+  --> $DIR/manual_strip.rs:30:5
+   |
+LL |     if s.starts_with(prefix) {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
+help: try using the `strip_prefix` method
+   |
+LL |     if let Some(<stripped>) = s.strip_prefix(prefix) {
+LL |         str::to_string(<stripped>);
+   |
+
+error: stripping a prefix manually
+  --> $DIR/manual_strip.rs:37:24
+   |
+LL |         str::to_string(&s[PREFIX.len()..]);
+   |                        ^^^^^^^^^^^^^^^^^^
+   |
+note: the prefix was tested here
+  --> $DIR/manual_strip.rs:36:5
+   |
+LL |     if s.starts_with(PREFIX) {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
+help: try using the `strip_prefix` method
+   |
+LL |     if let Some(<stripped>) = s.strip_prefix(PREFIX) {
+LL |         str::to_string(<stripped>);
+LL |         str::to_string(<stripped>);
+   |
+
+error: stripping a prefix manually
+  --> $DIR/manual_strip.rs:44:24
+   |
+LL |         str::to_string(&TARGET[prefix.len()..]);
+   |                        ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: the prefix was tested here
+  --> $DIR/manual_strip.rs:43:5
+   |
+LL |     if TARGET.starts_with(prefix) {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+help: try using the `strip_prefix` method
+   |
+LL |     if let Some(<stripped>) = TARGET.strip_prefix(prefix) {
+LL |         str::to_string(<stripped>);
+   |
+
+error: stripping a prefix manually
+  --> $DIR/manual_strip.rs:50:9
+   |
+LL |         s1[2..].to_uppercase();
+   |         ^^^^^^^
+   |
+note: the prefix was tested here
+  --> $DIR/manual_strip.rs:49:5
+   |
+LL |     if s1.starts_with("ab") {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^
+help: try using the `strip_prefix` method
+   |
+LL |     if let Some(<stripped>) = s1.strip_prefix("ab") {
+LL |         <stripped>.to_uppercase();
+   |
+
+error: aborting due to 7 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 15244a88df5cfd475df010ad945474c658749192 Mon Sep 17 00:00:00 2001
From: Michael Wright <mikerite@lavabit.com>
Date: Mon, 14 Sep 2020 06:11:35 +0200
Subject: Fix `manual-strip` dogfood errors

---
 clippy_lints/src/doc.rs             | 2 +-
 clippy_lints/src/loops.rs           | 8 +++-----
 clippy_lints/src/misc_early.rs      | 6 +++---
 clippy_lints/src/redundant_clone.rs | 5 ++---
 tests/ui/let_if_seq.rs              | 1 +
 tests/ui/let_if_seq.stderr          | 8 ++++----
 6 files changed, 14 insertions(+), 16 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/doc.rs b/clippy_lints/src/doc.rs
index 50121a054c7..62bb70af06e 100644
--- a/clippy_lints/src/doc.rs
+++ b/clippy_lints/src/doc.rs
@@ -534,7 +534,7 @@ fn check_word(cx: &LateContext<'_>, word: &str, span: Span) {
             return false;
         }
 
-        let s = if s.ends_with('s') { &s[..s.len() - 1] } else { s };
+        let s = s.strip_suffix('s').unwrap_or(s);
 
         s.chars().all(char::is_alphanumeric)
             && s.chars().filter(|&c| c.is_uppercase()).take(2).count() > 1
diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 6c54c07869a..8f5675a61b9 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -2601,11 +2601,9 @@ fn check_needless_collect_direct_usage<'tcx>(expr: &'tcx Expr<'_>, cx: &LateCont
                         span,
                         NEEDLESS_COLLECT_MSG,
                         |diag| {
-                            let (arg, pred) = if contains_arg.starts_with('&') {
-                                ("x", &contains_arg[1..])
-                            } else {
-                                ("&x", &*contains_arg)
-                            };
+                            let (arg, pred) = contains_arg
+                                    .strip_prefix('&')
+                                    .map_or(("&x", &*contains_arg), |s| ("x", s));
                             diag.span_suggestion(
                                 span,
                                 "replace with",
diff --git a/clippy_lints/src/misc_early.rs b/clippy_lints/src/misc_early.rs
index 02789735c17..9cb1cfb915d 100644
--- a/clippy_lints/src/misc_early.rs
+++ b/clippy_lints/src/misc_early.rs
@@ -377,8 +377,8 @@ impl EarlyLintPass for MiscEarlyLints {
             if let PatKind::Ident(_, ident, None) = arg.pat.kind {
                 let arg_name = ident.to_string();
 
-                if arg_name.starts_with('_') {
-                    if let Some(correspondence) = registered_names.get(&arg_name[1..]) {
+                if let Some(arg_name) = arg_name.strip_prefix('_') {
+                    if let Some(correspondence) = registered_names.get(arg_name) {
                         span_lint(
                             cx,
                             DUPLICATE_UNDERSCORE_ARGUMENT,
@@ -386,7 +386,7 @@ impl EarlyLintPass for MiscEarlyLints {
                             &format!(
                                 "`{}` already exists, having another argument having almost the same \
                                  name makes code comprehension and documentation more difficult",
-                                arg_name[1..].to_owned()
+                                arg_name
                             ),
                         );
                     }
diff --git a/clippy_lints/src/redundant_clone.rs b/clippy_lints/src/redundant_clone.rs
index 57a45e628db..1a7f36fbdad 100644
--- a/clippy_lints/src/redundant_clone.rs
+++ b/clippy_lints/src/redundant_clone.rs
@@ -239,10 +239,9 @@ impl<'tcx> LateLintPass<'tcx> for RedundantClone {
                         );
                         let mut app = Applicability::MaybeIncorrect;
 
-                        let mut call_snip = &snip[dot + 1..];
+                        let call_snip = &snip[dot + 1..];
                         // Machine applicable when `call_snip` looks like `foobar()`
-                        if call_snip.ends_with("()") {
-                            call_snip = call_snip[..call_snip.len()-2].trim();
+                        if let Some(call_snip) = call_snip.strip_suffix("()").map(str::trim) {
                             if call_snip.as_bytes().iter().all(|b| b.is_ascii_alphabetic() || *b == b'_') {
                                 app = Applicability::MachineApplicable;
                             }
diff --git a/tests/ui/let_if_seq.rs b/tests/ui/let_if_seq.rs
index 802beeb4be6..32a67f181df 100644
--- a/tests/ui/let_if_seq.rs
+++ b/tests/ui/let_if_seq.rs
@@ -33,6 +33,7 @@ fn issue985_alt() -> i32 {
     x
 }
 
+#[allow(clippy::manual_strip)]
 fn issue975() -> String {
     let mut udn = "dummy".to_string();
     if udn.starts_with("uuid:") {
diff --git a/tests/ui/let_if_seq.stderr b/tests/ui/let_if_seq.stderr
index c53a63a541b..7de560c7348 100644
--- a/tests/ui/let_if_seq.stderr
+++ b/tests/ui/let_if_seq.stderr
@@ -1,5 +1,5 @@
 error: `if _ { .. } else { .. }` is an expression
-  --> $DIR/let_if_seq.rs:63:5
+  --> $DIR/let_if_seq.rs:64:5
    |
 LL | /     let mut foo = 0;
 LL | |     if f() {
@@ -11,7 +11,7 @@ LL | |     }
    = note: you might not need `mut` at all
 
 error: `if _ { .. } else { .. }` is an expression
-  --> $DIR/let_if_seq.rs:68:5
+  --> $DIR/let_if_seq.rs:69:5
    |
 LL | /     let mut bar = 0;
 LL | |     if f() {
@@ -25,7 +25,7 @@ LL | |     }
    = note: you might not need `mut` at all
 
 error: `if _ { .. } else { .. }` is an expression
-  --> $DIR/let_if_seq.rs:76:5
+  --> $DIR/let_if_seq.rs:77:5
    |
 LL | /     let quz;
 LL | |     if f() {
@@ -36,7 +36,7 @@ LL | |     }
    | |_____^ help: it is more idiomatic to write: `let quz = if f() { 42 } else { 0 };`
 
 error: `if _ { .. } else { .. }` is an expression
-  --> $DIR/let_if_seq.rs:105:5
+  --> $DIR/let_if_seq.rs:106:5
    |
 LL | /     let mut baz = 0;
 LL | |     if f() {
-- 
cgit 1.4.1-3-g733a5


From 1b5317f68b2b55803d5051e9945f9a33817fccef Mon Sep 17 00:00:00 2001
From: Robin Schoonover <robin@cornhooves.org>
Date: Sun, 13 Sep 2020 21:52:25 -0600
Subject: Add rc_buffer lint for Rc<String> and other buffer types

---
 CHANGELOG.md                    |  1 +
 clippy_lints/src/lib.rs         |  2 +
 clippy_lints/src/types.rs       | 84 ++++++++++++++++++++++++++++++++++++++++-
 clippy_lints/src/utils/paths.rs |  1 +
 src/lintlist/mod.rs             |  7 ++++
 tests/ui/rc_buffer.rs           | 13 +++++++
 tests/ui/rc_buffer.stderr       | 28 ++++++++++++++
 7 files changed, 135 insertions(+), 1 deletion(-)
 create mode 100644 tests/ui/rc_buffer.rs
 create mode 100644 tests/ui/rc_buffer.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 285a2ff8060..8922f5e7027 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1775,6 +1775,7 @@ Released 2018-09-13
 [`range_plus_one`]: https://rust-lang.github.io/rust-clippy/master/index.html#range_plus_one
 [`range_step_by_zero`]: https://rust-lang.github.io/rust-clippy/master/index.html#range_step_by_zero
 [`range_zip_with_len`]: https://rust-lang.github.io/rust-clippy/master/index.html#range_zip_with_len
+[`rc_buffer`]: https://rust-lang.github.io/rust-clippy/master/index.html#rc_buffer
 [`redundant_allocation`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_allocation
 [`redundant_clone`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_clone
 [`redundant_closure`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_closure
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index c017c5cb5d0..239eeb10bb4 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -837,6 +837,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &types::LET_UNIT_VALUE,
         &types::LINKEDLIST,
         &types::OPTION_OPTION,
+        &types::RC_BUFFER,
         &types::REDUNDANT_ALLOCATION,
         &types::TYPE_COMPLEXITY,
         &types::UNIT_ARG,
@@ -1804,6 +1805,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&path_buf_push_overwrite::PATH_BUF_PUSH_OVERWRITE),
         LintId::of(&redundant_pub_crate::REDUNDANT_PUB_CRATE),
         LintId::of(&transmute::USELESS_TRANSMUTE),
+        LintId::of(&types::RC_BUFFER),
         LintId::of(&use_self::USE_SELF),
     ]);
 }
diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs
index b6d405cca77..5f3a2e0b6d4 100644
--- a/clippy_lints/src/types.rs
+++ b/clippy_lints/src/types.rs
@@ -215,11 +215,41 @@ declare_clippy_lint! {
     "redundant allocation"
 }
 
+declare_clippy_lint! {
+    /// **What it does:** Checks for Rc<T> and Arc<T> when T is a mutable buffer type such as String or Vec
+    ///
+    /// **Why is this bad?** Expressions such as Rc<String> have no advantage over Rc<str>, since
+    /// it is larger and involves an extra level of indirection, and doesn't implement Borrow<str>.
+    ///
+    /// While mutating a buffer type would still be possible with Rc::get_mut(), it only
+    /// works if there are no additional references yet, which defeats the purpose of
+    /// enclosing it in a shared ownership type. Instead, additionally wrapping the inner
+    /// type with an interior mutable container (such as RefCell or Mutex) would normally
+    /// be used.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// ```rust,ignore
+    /// # use std::rc::Rc;
+    /// fn foo(interned: Rc<String>) { ... }
+    /// ```
+    ///
+    /// Better:
+    ///
+    /// ```rust,ignore
+    /// fn foo(interned: Rc<str>) { ... }
+    /// ```
+    pub RC_BUFFER,
+    nursery,
+    "shared ownership of a buffer type"
+}
+
 pub struct Types {
     vec_box_size_threshold: u64,
 }
 
-impl_lint_pass!(Types => [BOX_VEC, VEC_BOX, OPTION_OPTION, LINKEDLIST, BORROWED_BOX, REDUNDANT_ALLOCATION]);
+impl_lint_pass!(Types => [BOX_VEC, VEC_BOX, OPTION_OPTION, LINKEDLIST, BORROWED_BOX, REDUNDANT_ALLOCATION, RC_BUFFER]);
 
 impl<'tcx> LateLintPass<'tcx> for Types {
     fn check_fn(&mut self, cx: &LateContext<'_>, _: FnKind<'_>, decl: &FnDecl<'_>, _: &Body<'_>, _: Span, id: HirId) {
@@ -272,6 +302,19 @@ fn match_type_parameter(cx: &LateContext<'_>, qpath: &QPath<'_>, path: &[&str])
     None
 }
 
+fn match_buffer_type(cx: &LateContext<'_>, qpath: &QPath<'_>) -> Option<&'static str> {
+    if match_type_parameter(cx, qpath, &paths::STRING).is_some() {
+        return Some("str");
+    }
+    if match_type_parameter(cx, qpath, &paths::OS_STRING).is_some() {
+        return Some("std::ffi::OsStr");
+    }
+    if match_type_parameter(cx, qpath, &paths::PATH_BUF).is_some() {
+        return Some("std::path::Path");
+    }
+    None
+}
+
 fn match_borrows_parameter(_cx: &LateContext<'_>, qpath: &QPath<'_>) -> Option<Span> {
     let last = last_path_segment(qpath);
     if_chain! {
@@ -385,6 +428,45 @@ impl Types {
                             );
                             return; // don't recurse into the type
                         }
+                        if let Some(alternate) = match_buffer_type(cx, qpath) {
+                            span_lint_and_sugg(
+                                cx,
+                                RC_BUFFER,
+                                hir_ty.span,
+                                "usage of `Rc<T>` when T is a buffer type",
+                                "try",
+                                format!("Rc<{}>", alternate),
+                                Applicability::MachineApplicable,
+                            );
+                            return; // don't recurse into the type
+                        }
+                        if match_type_parameter(cx, qpath, &paths::VEC).is_some() {
+                            let vec_ty = match &last_path_segment(qpath).args.unwrap().args[0] {
+                                GenericArg::Type(ty) => match &ty.kind {
+                                    TyKind::Path(qpath) => qpath,
+                                    _ => return,
+                                },
+                                _ => return,
+                            };
+                            let inner_span = match &last_path_segment(&vec_ty).args.unwrap().args[0] {
+                                GenericArg::Type(ty) => ty.span,
+                                _ => return,
+                            };
+                            let mut applicability = Applicability::MachineApplicable;
+                            span_lint_and_sugg(
+                                cx,
+                                RC_BUFFER,
+                                hir_ty.span,
+                                "usage of `Rc<T>` when T is a buffer type",
+                                "try",
+                                format!(
+                                    "Rc<[{}]>",
+                                    snippet_with_applicability(cx, inner_span, "..", &mut applicability)
+                                ),
+                                Applicability::MachineApplicable,
+                            );
+                            return; // don't recurse into the type
+                        }
                         if let Some(span) = match_borrows_parameter(cx, qpath) {
                             let mut applicability = Applicability::MachineApplicable;
                             span_lint_and_sugg(
diff --git a/clippy_lints/src/utils/paths.rs b/clippy_lints/src/utils/paths.rs
index 65320d6a0e0..2df11d2efcf 100644
--- a/clippy_lints/src/utils/paths.rs
+++ b/clippy_lints/src/utils/paths.rs
@@ -113,6 +113,7 @@ pub const STD_CONVERT_IDENTITY: [&str; 3] = ["std", "convert", "identity"];
 pub const STD_FS_CREATE_DIR: [&str; 3] = ["std", "fs", "create_dir"];
 pub const STD_MEM_TRANSMUTE: [&str; 3] = ["std", "mem", "transmute"];
 pub const STD_PTR_NULL: [&str; 3] = ["std", "ptr", "null"];
+pub const STRING: [&str; 3] = ["alloc", "string", "String"];
 pub const STRING_AS_MUT_STR: [&str; 4] = ["alloc", "string", "String", "as_mut_str"];
 pub const STRING_AS_STR: [&str; 4] = ["alloc", "string", "String", "as_str"];
 pub const SYNTAX_CONTEXT: [&str; 3] = ["rustc_span", "hygiene", "SyntaxContext"];
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index a7d38c93433..d0c6a1d63d9 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -1851,6 +1851,13 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
         deprecation: None,
         module: "ranges",
     },
+    Lint {
+        name: "rc_buffer",
+        group: "nursery",
+        desc: "shared ownership of a buffer type",
+        deprecation: None,
+        module: "types",
+    },
     Lint {
         name: "redundant_allocation",
         group: "perf",
diff --git a/tests/ui/rc_buffer.rs b/tests/ui/rc_buffer.rs
new file mode 100644
index 00000000000..c8c2bec67ee
--- /dev/null
+++ b/tests/ui/rc_buffer.rs
@@ -0,0 +1,13 @@
+use std::ffi::OsString;
+use std::path::PathBuf;
+use std::rc::Rc;
+
+#[warn(clippy::rc_buffer)]
+struct S {
+    a: Rc<String>,
+    b: Rc<PathBuf>,
+    c: Rc<Vec<u8>>,
+    d: Rc<OsString>,
+}
+
+fn main() {}
diff --git a/tests/ui/rc_buffer.stderr b/tests/ui/rc_buffer.stderr
new file mode 100644
index 00000000000..641a13a2251
--- /dev/null
+++ b/tests/ui/rc_buffer.stderr
@@ -0,0 +1,28 @@
+error: usage of `Rc<T>` when T is a buffer type
+  --> $DIR/rc_buffer.rs:7:8
+   |
+LL |     a: Rc<String>,
+   |        ^^^^^^^^^^ help: try: `Rc<str>`
+   |
+   = note: `-D clippy::rc-buffer` implied by `-D warnings`
+
+error: usage of `Rc<T>` when T is a buffer type
+  --> $DIR/rc_buffer.rs:8:8
+   |
+LL |     b: Rc<PathBuf>,
+   |        ^^^^^^^^^^^ help: try: `Rc<std::path::Path>`
+
+error: usage of `Rc<T>` when T is a buffer type
+  --> $DIR/rc_buffer.rs:9:8
+   |
+LL |     c: Rc<Vec<u8>>,
+   |        ^^^^^^^^^^^ help: try: `Rc<[u8]>`
+
+error: usage of `Rc<T>` when T is a buffer type
+  --> $DIR/rc_buffer.rs:10:8
+   |
+LL |     d: Rc<OsString>,
+   |        ^^^^^^^^^^^^ help: try: `Rc<std::ffi::OsStr>`
+
+error: aborting due to 4 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 2dd7175d60e070c7ee2b4609bdb17eae16e381f0 Mon Sep 17 00:00:00 2001
From: Robin Schoonover <robin@cornhooves.org>
Date: Sun, 13 Sep 2020 22:17:10 -0600
Subject: Apply rc_buffer lint to Arc<T>

---
 clippy_lints/src/types.rs     | 40 ++++++++++++++++++++++++++++++++++++++++
 tests/ui/rc_buffer_arc.rs     | 13 +++++++++++++
 tests/ui/rc_buffer_arc.stderr | 28 ++++++++++++++++++++++++++++
 3 files changed, 81 insertions(+)
 create mode 100644 tests/ui/rc_buffer_arc.rs
 create mode 100644 tests/ui/rc_buffer_arc.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs
index 5f3a2e0b6d4..da04d07885b 100644
--- a/clippy_lints/src/types.rs
+++ b/clippy_lints/src/types.rs
@@ -480,6 +480,46 @@ impl Types {
                             );
                             return; // don't recurse into the type
                         }
+                    } else if cx.tcx.is_diagnostic_item(sym::Arc, def_id) {
+                        if let Some(alternate) = match_buffer_type(cx, qpath) {
+                            span_lint_and_sugg(
+                                cx,
+                                RC_BUFFER,
+                                hir_ty.span,
+                                "usage of `Arc<T>` when T is a buffer type",
+                                "try",
+                                format!("Arc<{}>", alternate),
+                                Applicability::MachineApplicable,
+                            );
+                            return; // don't recurse into the type
+                        }
+                        if match_type_parameter(cx, qpath, &paths::VEC).is_some() {
+                            let vec_ty = match &last_path_segment(qpath).args.unwrap().args[0] {
+                                GenericArg::Type(ty) => match &ty.kind {
+                                    TyKind::Path(qpath) => qpath,
+                                    _ => return,
+                                },
+                                _ => return,
+                            };
+                            let inner_span = match &last_path_segment(&vec_ty).args.unwrap().args[0] {
+                                GenericArg::Type(ty) => ty.span,
+                                _ => return,
+                            };
+                            let mut applicability = Applicability::MachineApplicable;
+                            span_lint_and_sugg(
+                                cx,
+                                RC_BUFFER,
+                                hir_ty.span,
+                                "usage of `Arc<T>` when T is a buffer type",
+                                "try",
+                                format!(
+                                    "Arc<[{}]>",
+                                    snippet_with_applicability(cx, inner_span, "..", &mut applicability)
+                                ),
+                                Applicability::MachineApplicable,
+                            );
+                            return; // don't recurse into the type
+                        }
                     } else if cx.tcx.is_diagnostic_item(sym!(vec_type), def_id) {
                         if_chain! {
                             // Get the _ part of Vec<_>
diff --git a/tests/ui/rc_buffer_arc.rs b/tests/ui/rc_buffer_arc.rs
new file mode 100644
index 00000000000..a878b0ab336
--- /dev/null
+++ b/tests/ui/rc_buffer_arc.rs
@@ -0,0 +1,13 @@
+use std::ffi::OsString;
+use std::path::PathBuf;
+use std::sync::Arc;
+
+#[warn(clippy::rc_buffer)]
+struct S {
+    a: Arc<String>,
+    b: Arc<PathBuf>,
+    c: Arc<Vec<u8>>,
+    d: Arc<OsString>,
+}
+
+fn main() {}
diff --git a/tests/ui/rc_buffer_arc.stderr b/tests/ui/rc_buffer_arc.stderr
new file mode 100644
index 00000000000..c4b01621046
--- /dev/null
+++ b/tests/ui/rc_buffer_arc.stderr
@@ -0,0 +1,28 @@
+error: usage of `Arc<T>` when T is a buffer type
+  --> $DIR/rc_buffer_arc.rs:7:8
+   |
+LL |     a: Arc<String>,
+   |        ^^^^^^^^^^^ help: try: `Arc<str>`
+   |
+   = note: `-D clippy::rc-buffer` implied by `-D warnings`
+
+error: usage of `Arc<T>` when T is a buffer type
+  --> $DIR/rc_buffer_arc.rs:8:8
+   |
+LL |     b: Arc<PathBuf>,
+   |        ^^^^^^^^^^^^ help: try: `Arc<std::path::Path>`
+
+error: usage of `Arc<T>` when T is a buffer type
+  --> $DIR/rc_buffer_arc.rs:9:8
+   |
+LL |     c: Arc<Vec<u8>>,
+   |        ^^^^^^^^^^^^ help: try: `Arc<[u8]>`
+
+error: usage of `Arc<T>` when T is a buffer type
+  --> $DIR/rc_buffer_arc.rs:10:8
+   |
+LL |     d: Arc<OsString>,
+   |        ^^^^^^^^^^^^^ help: try: `Arc<std::ffi::OsStr>`
+
+error: aborting due to 4 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 4d73ccaa9419b393b9c94f977ec0e158897feeb3 Mon Sep 17 00:00:00 2001
From: Haraman Johal <haraman.johal@oxfordni.com>
Date: Tue, 15 Sep 2020 00:20:31 +0100
Subject: clarify margin of error in wording of float comparison operator lint
 messages

---
 clippy_lints/src/misc.rs        |  6 +++---
 tests/ui/float_cmp.stderr       | 22 +++++++++++-----------
 tests/ui/float_cmp_const.stderr | 30 +++++++++++++++---------------
 3 files changed, 29 insertions(+), 29 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/misc.rs b/clippy_lints/src/misc.rs
index d4a50dd9013..81e6214f143 100644
--- a/clippy_lints/src/misc.rs
+++ b/clippy_lints/src/misc.rs
@@ -411,16 +411,16 @@ impl<'tcx> LateLintPass<'tcx> for MiscLints {
                         if !is_comparing_arrays {
                             diag.span_suggestion(
                                 expr.span,
-                                "consider comparing them within some error",
+                                "consider comparing them within some margin of error",
                                 format!(
-                                    "({}).abs() {} error",
+                                    "({}).abs() {} error_margin",
                                     lhs - rhs,
                                     if op == BinOpKind::Eq { '<' } else { '>' }
                                 ),
                                 Applicability::HasPlaceholders, // snippet
                             );
                         }
-                        diag.note("`f32::EPSILON` and `f64::EPSILON` are available for the `error`");
+                        diag.note("`f32::EPSILON` and `f64::EPSILON` are available for the `error_margin`");
                     });
                 } else if op == BinOpKind::Rem && is_integer_const(cx, right, 1) {
                     span_lint(cx, MODULO_ONE, expr.span, "any number modulo 1 will be 0");
diff --git a/tests/ui/float_cmp.stderr b/tests/ui/float_cmp.stderr
index 2d454e8e70d..f7c380fc915 100644
--- a/tests/ui/float_cmp.stderr
+++ b/tests/ui/float_cmp.stderr
@@ -2,34 +2,34 @@ error: strict comparison of `f32` or `f64`
   --> $DIR/float_cmp.rs:65:5
    |
 LL |     ONE as f64 != 2.0;
-   |     ^^^^^^^^^^^^^^^^^ help: consider comparing them within some error: `(ONE as f64 - 2.0).abs() > error`
+   |     ^^^^^^^^^^^^^^^^^ help: consider comparing them within some margin of error: `(ONE as f64 - 2.0).abs() > error_margin`
    |
    = note: `-D clippy::float-cmp` implied by `-D warnings`
-   = note: `f32::EPSILON` and `f64::EPSILON` are available for the `error`
+   = note: `f32::EPSILON` and `f64::EPSILON` are available for the `error_margin`
 
 error: strict comparison of `f32` or `f64`
   --> $DIR/float_cmp.rs:70:5
    |
 LL |     x == 1.0;
-   |     ^^^^^^^^ help: consider comparing them within some error: `(x - 1.0).abs() < error`
+   |     ^^^^^^^^ help: consider comparing them within some margin of error: `(x - 1.0).abs() < error_margin`
    |
-   = note: `f32::EPSILON` and `f64::EPSILON` are available for the `error`
+   = note: `f32::EPSILON` and `f64::EPSILON` are available for the `error_margin`
 
 error: strict comparison of `f32` or `f64`
   --> $DIR/float_cmp.rs:73:5
    |
 LL |     twice(x) != twice(ONE as f64);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider comparing them within some error: `(twice(x) - twice(ONE as f64)).abs() > error`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider comparing them within some margin of error: `(twice(x) - twice(ONE as f64)).abs() > error_margin`
    |
-   = note: `f32::EPSILON` and `f64::EPSILON` are available for the `error`
+   = note: `f32::EPSILON` and `f64::EPSILON` are available for the `error_margin`
 
 error: strict comparison of `f32` or `f64`
   --> $DIR/float_cmp.rs:93:5
    |
 LL |     NON_ZERO_ARRAY[i] == NON_ZERO_ARRAY[j];
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider comparing them within some error: `(NON_ZERO_ARRAY[i] - NON_ZERO_ARRAY[j]).abs() < error`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider comparing them within some margin of error: `(NON_ZERO_ARRAY[i] - NON_ZERO_ARRAY[j]).abs() < error_margin`
    |
-   = note: `f32::EPSILON` and `f64::EPSILON` are available for the `error`
+   = note: `f32::EPSILON` and `f64::EPSILON` are available for the `error_margin`
 
 error: strict comparison of `f32` or `f64` arrays
   --> $DIR/float_cmp.rs:98:5
@@ -37,15 +37,15 @@ error: strict comparison of `f32` or `f64` arrays
 LL |     a1 == a2;
    |     ^^^^^^^^
    |
-   = note: `f32::EPSILON` and `f64::EPSILON` are available for the `error`
+   = note: `f32::EPSILON` and `f64::EPSILON` are available for the `error_margin`
 
 error: strict comparison of `f32` or `f64`
   --> $DIR/float_cmp.rs:99:5
    |
 LL |     a1[0] == a2[0];
-   |     ^^^^^^^^^^^^^^ help: consider comparing them within some error: `(a1[0] - a2[0]).abs() < error`
+   |     ^^^^^^^^^^^^^^ help: consider comparing them within some margin of error: `(a1[0] - a2[0]).abs() < error_margin`
    |
-   = note: `f32::EPSILON` and `f64::EPSILON` are available for the `error`
+   = note: `f32::EPSILON` and `f64::EPSILON` are available for the `error_margin`
 
 error: aborting due to 6 previous errors
 
diff --git a/tests/ui/float_cmp_const.stderr b/tests/ui/float_cmp_const.stderr
index 19dc4a284b7..5d0455363e8 100644
--- a/tests/ui/float_cmp_const.stderr
+++ b/tests/ui/float_cmp_const.stderr
@@ -2,58 +2,58 @@ error: strict comparison of `f32` or `f64` constant
   --> $DIR/float_cmp_const.rs:20:5
    |
 LL |     1f32 == ONE;
-   |     ^^^^^^^^^^^ help: consider comparing them within some error: `(1f32 - ONE).abs() < error`
+   |     ^^^^^^^^^^^ help: consider comparing them within some margin of error: `(1f32 - ONE).abs() < error_margin`
    |
    = note: `-D clippy::float-cmp-const` implied by `-D warnings`
-   = note: `f32::EPSILON` and `f64::EPSILON` are available for the `error`
+   = note: `f32::EPSILON` and `f64::EPSILON` are available for the `error_margin`
 
 error: strict comparison of `f32` or `f64` constant
   --> $DIR/float_cmp_const.rs:21:5
    |
 LL |     TWO == ONE;
-   |     ^^^^^^^^^^ help: consider comparing them within some error: `(TWO - ONE).abs() < error`
+   |     ^^^^^^^^^^ help: consider comparing them within some margin of error: `(TWO - ONE).abs() < error_margin`
    |
-   = note: `f32::EPSILON` and `f64::EPSILON` are available for the `error`
+   = note: `f32::EPSILON` and `f64::EPSILON` are available for the `error_margin`
 
 error: strict comparison of `f32` or `f64` constant
   --> $DIR/float_cmp_const.rs:22:5
    |
 LL |     TWO != ONE;
-   |     ^^^^^^^^^^ help: consider comparing them within some error: `(TWO - ONE).abs() > error`
+   |     ^^^^^^^^^^ help: consider comparing them within some margin of error: `(TWO - ONE).abs() > error_margin`
    |
-   = note: `f32::EPSILON` and `f64::EPSILON` are available for the `error`
+   = note: `f32::EPSILON` and `f64::EPSILON` are available for the `error_margin`
 
 error: strict comparison of `f32` or `f64` constant
   --> $DIR/float_cmp_const.rs:23:5
    |
 LL |     ONE + ONE == TWO;
-   |     ^^^^^^^^^^^^^^^^ help: consider comparing them within some error: `(ONE + ONE - TWO).abs() < error`
+   |     ^^^^^^^^^^^^^^^^ help: consider comparing them within some margin of error: `(ONE + ONE - TWO).abs() < error_margin`
    |
-   = note: `f32::EPSILON` and `f64::EPSILON` are available for the `error`
+   = note: `f32::EPSILON` and `f64::EPSILON` are available for the `error_margin`
 
 error: strict comparison of `f32` or `f64` constant
   --> $DIR/float_cmp_const.rs:25:5
    |
 LL |     x as f32 == ONE;
-   |     ^^^^^^^^^^^^^^^ help: consider comparing them within some error: `(x as f32 - ONE).abs() < error`
+   |     ^^^^^^^^^^^^^^^ help: consider comparing them within some margin of error: `(x as f32 - ONE).abs() < error_margin`
    |
-   = note: `f32::EPSILON` and `f64::EPSILON` are available for the `error`
+   = note: `f32::EPSILON` and `f64::EPSILON` are available for the `error_margin`
 
 error: strict comparison of `f32` or `f64` constant
   --> $DIR/float_cmp_const.rs:28:5
    |
 LL |     v == ONE;
-   |     ^^^^^^^^ help: consider comparing them within some error: `(v - ONE).abs() < error`
+   |     ^^^^^^^^ help: consider comparing them within some margin of error: `(v - ONE).abs() < error_margin`
    |
-   = note: `f32::EPSILON` and `f64::EPSILON` are available for the `error`
+   = note: `f32::EPSILON` and `f64::EPSILON` are available for the `error_margin`
 
 error: strict comparison of `f32` or `f64` constant
   --> $DIR/float_cmp_const.rs:29:5
    |
 LL |     v != ONE;
-   |     ^^^^^^^^ help: consider comparing them within some error: `(v - ONE).abs() > error`
+   |     ^^^^^^^^ help: consider comparing them within some margin of error: `(v - ONE).abs() > error_margin`
    |
-   = note: `f32::EPSILON` and `f64::EPSILON` are available for the `error`
+   = note: `f32::EPSILON` and `f64::EPSILON` are available for the `error_margin`
 
 error: strict comparison of `f32` or `f64` constant arrays
   --> $DIR/float_cmp_const.rs:61:5
@@ -61,7 +61,7 @@ error: strict comparison of `f32` or `f64` constant arrays
 LL |     NON_ZERO_ARRAY == NON_ZERO_ARRAY2;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = note: `f32::EPSILON` and `f64::EPSILON` are available for the `error`
+   = note: `f32::EPSILON` and `f64::EPSILON` are available for the `error_margin`
 
 error: aborting due to 8 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From fd151f5135def6ffae7530f17ff0c458239f209d Mon Sep 17 00:00:00 2001
From: Takayuki Nakata <f.seasons017@gmail.com>
Date: Tue, 15 Sep 2020 08:51:52 +0900
Subject: Remove an extra blank line in `shadow_same`

---
 clippy_lints/src/shadow.rs | 1 -
 1 file changed, 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/shadow.rs b/clippy_lints/src/shadow.rs
index 087d50c90e6..ef4a54735a4 100644
--- a/clippy_lints/src/shadow.rs
+++ b/clippy_lints/src/shadow.rs
@@ -25,7 +25,6 @@ declare_clippy_lint! {
     /// **Example:**
     /// ```rust
     /// # let x = 1;
-    ///
     /// // Bad
     /// let x = &x;
     ///
-- 
cgit 1.4.1-3-g733a5


From 8afa7ed6aec37c5423cffe12dbc854c954799fb3 Mon Sep 17 00:00:00 2001
From: Eduardo Broto <ebroto@tutanota.com>
Date: Sun, 6 Sep 2020 23:32:48 +0200
Subject: Add internal lint MatchTypeOnDiagItem

---
 clippy_lints/src/lib.rs                  |   3 +
 clippy_lints/src/utils/internal_lints.rs | 115 ++++++++++++++++++++++++++++++-
 clippy_lints/src/utils/mod.rs            |   5 ++
 tests/ui/match_type_on_diag_item.rs      |  50 ++++++++++++++
 tests/ui/match_type_on_diag_item.stderr  |  33 +++++++++
 5 files changed, 203 insertions(+), 3 deletions(-)
 create mode 100644 tests/ui/match_type_on_diag_item.rs
 create mode 100644 tests/ui/match_type_on_diag_item.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 44afd7e82fe..b60a80e07d7 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -867,6 +867,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &utils::internal_lints::COMPILER_LINT_FUNCTIONS,
         &utils::internal_lints::DEFAULT_LINT,
         &utils::internal_lints::LINT_WITHOUT_LINT_PASS,
+        &utils::internal_lints::MATCH_TYPE_ON_DIAGNOSTIC_ITEM,
         &utils::internal_lints::OUTER_EXPN_EXPN_DATA,
         &utils::internal_lints::PRODUCE_ICE,
         &vec::USELESS_VEC,
@@ -1112,6 +1113,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box self_assignment::SelfAssignment);
     store.register_late_pass(|| box float_equality_without_abs::FloatEqualityWithoutAbs);
     store.register_late_pass(|| box async_yields_async::AsyncYieldsAsync);
+    store.register_late_pass(|| box utils::internal_lints::MatchTypeOnDiagItem);
 
     store.register_group(true, "clippy::restriction", Some("clippy_restriction"), vec![
         LintId::of(&arithmetic::FLOAT_ARITHMETIC),
@@ -1240,6 +1242,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&utils::internal_lints::COMPILER_LINT_FUNCTIONS),
         LintId::of(&utils::internal_lints::DEFAULT_LINT),
         LintId::of(&utils::internal_lints::LINT_WITHOUT_LINT_PASS),
+        LintId::of(&utils::internal_lints::MATCH_TYPE_ON_DIAGNOSTIC_ITEM),
         LintId::of(&utils::internal_lints::OUTER_EXPN_EXPN_DATA),
         LintId::of(&utils::internal_lints::PRODUCE_ICE),
     ]);
diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs
index 8fa5d22210a..5beb4be5b29 100644
--- a/clippy_lints/src/utils/internal_lints.rs
+++ b/clippy_lints/src/utils/internal_lints.rs
@@ -1,6 +1,6 @@
 use crate::utils::{
-    is_expn_of, match_def_path, match_qpath, match_type, method_calls, paths, run_lints, snippet, span_lint,
-    span_lint_and_help, span_lint_and_sugg, walk_ptrs_ty, SpanlessEq,
+    is_expn_of, match_def_path, match_qpath, match_type, method_calls, path_to_res, paths, qpath_res, run_lints,
+    snippet, span_lint, span_lint_and_help, span_lint_and_sugg, walk_ptrs_ty, SpanlessEq,
 };
 use if_chain::if_chain;
 use rustc_ast::ast::{Crate as AstCrate, ItemKind, LitKind, NodeId};
@@ -11,7 +11,7 @@ use rustc_hir as hir;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::hir_id::CRATE_HIR_ID;
 use rustc_hir::intravisit::{NestedVisitorMap, Visitor};
-use rustc_hir::{Crate, Expr, ExprKind, HirId, Item, MutTy, Mutability, Path, StmtKind, Ty, TyKind};
+use rustc_hir::{Crate, Expr, ExprKind, HirId, Item, MutTy, Mutability, Node, Path, StmtKind, Ty, TyKind};
 use rustc_lint::{EarlyContext, EarlyLintPass, LateContext, LateLintPass};
 use rustc_middle::hir::map::Map;
 use rustc_session::{declare_lint_pass, declare_tool_lint, impl_lint_pass};
@@ -206,6 +206,29 @@ declare_clippy_lint! {
     "found collapsible `span_lint_and_then` calls"
 }
 
+declare_clippy_lint! {
+    /// **What it does:** Checks for calls to `utils::match_type()` on a type diagnostic item
+    /// and suggests to use `utils::is_type_diagnostic_item()` instead.
+    ///
+    /// **Why is this bad?** `utils::is_type_diagnostic_item()` does not require hardcoded paths.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// Bad:
+    /// ```rust,ignore
+    /// utils::match_type(cx, ty, &paths::VEC)
+    /// ```
+    ///
+    /// Good:
+    /// ```rust,ignore
+    /// utils::is_type_diagnostic_item(cx, ty, sym!(vec_type))
+    /// ```
+    pub MATCH_TYPE_ON_DIAGNOSTIC_ITEM,
+    internal,
+    "using `utils::match_type()` instead of `utils::is_type_diagnostic_item()`"
+}
+
 declare_lint_pass!(ClippyLintsInternal => [CLIPPY_LINTS_INTERNAL]);
 
 impl EarlyLintPass for ClippyLintsInternal {
@@ -652,3 +675,89 @@ fn suggest_note(
         Applicability::MachineApplicable,
     );
 }
+
+declare_lint_pass!(MatchTypeOnDiagItem => [MATCH_TYPE_ON_DIAGNOSTIC_ITEM]);
+
+impl<'tcx> LateLintPass<'tcx> for MatchTypeOnDiagItem {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
+        if !run_lints(cx, &[MATCH_TYPE_ON_DIAGNOSTIC_ITEM], expr.hir_id) {
+            return;
+        }
+
+        if_chain! {
+            // Check if this is a call to utils::match_type()
+            if let ExprKind::Call(fn_path, [context, ty, ty_path]) = expr.kind;
+            if let ExprKind::Path(fn_qpath) = &fn_path.kind;
+            if match_qpath(&fn_qpath, &["utils", "match_type"]);
+            // Extract the path to the matched type
+            if let Some(segments) = path_to_matched_type(cx, ty_path);
+            let segments: Vec<&str> = segments.iter().map(|sym| &**sym).collect();
+            if let Some(ty_did) = path_to_res(cx, &segments[..]).and_then(|res| res.opt_def_id());
+            // Check if the matched type is a diagnostic item
+            let diag_items = cx.tcx.diagnostic_items(ty_did.krate);
+            if let Some(item_name) = diag_items.iter().find_map(|(k, v)| if *v == ty_did { Some(k) } else { None });
+            then {
+                let cx_snippet = snippet(cx, context.span, "_");
+                let ty_snippet = snippet(cx, ty.span, "_");
+
+                span_lint_and_sugg(
+                    cx,
+                    MATCH_TYPE_ON_DIAGNOSTIC_ITEM,
+                    expr.span,
+                    "usage of `utils::match_type() on a type diagnostic item`",
+                    "try",
+                    format!("utils::is_type_diagnostic_item({}, {}, sym!({}))", cx_snippet, ty_snippet, item_name),
+                    Applicability::MaybeIncorrect,
+                );
+            }
+        }
+    }
+}
+
+fn path_to_matched_type(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> Option<Vec<SymbolStr>> {
+    use rustc_hir::ItemKind;
+
+    match &expr.kind {
+        ExprKind::AddrOf(.., expr) => return path_to_matched_type(cx, expr),
+        ExprKind::Path(qpath) => match qpath_res(cx, qpath, expr.hir_id) {
+            Res::Local(hir_id) => {
+                let parent_id = cx.tcx.hir().get_parent_node(hir_id);
+                if let Some(Node::Local(local)) = cx.tcx.hir().find(parent_id) {
+                    if let Some(init) = local.init {
+                        return path_to_matched_type(cx, init);
+                    }
+                }
+            },
+            Res::Def(DefKind::Const | DefKind::Static, def_id) => {
+                if let Some(Node::Item(item)) = cx.tcx.hir().get_if_local(def_id) {
+                    if let ItemKind::Const(.., body_id) | ItemKind::Static(.., body_id) = item.kind {
+                        let body = cx.tcx.hir().body(body_id);
+                        return path_to_matched_type(cx, &body.value);
+                    }
+                }
+            },
+            _ => {},
+        },
+        ExprKind::Array(exprs) => {
+            let segments: Vec<SymbolStr> = exprs
+                .iter()
+                .filter_map(|expr| {
+                    if let ExprKind::Lit(lit) = &expr.kind {
+                        if let LitKind::Str(sym, _) = lit.node {
+                            return Some(sym.as_str());
+                        }
+                    }
+
+                    None
+                })
+                .collect();
+
+            if segments.len() == exprs.len() {
+                return Some(segments);
+            }
+        },
+        _ => {},
+    }
+
+    None
+}
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index 3ebbfed6456..8db7e693e62 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -130,6 +130,9 @@ pub fn is_wild<'tcx>(pat: &impl std::ops::Deref<Target = Pat<'tcx>>) -> bool {
 }
 
 /// Checks if type is struct, enum or union type with the given def path.
+///
+/// If the type is a diagnostic item, use `is_type_diagnostic_item` instead.
+/// If you change the signature, remember to update the internal lint `MatchTypeOnDiagItem`
 pub fn match_type(cx: &LateContext<'_>, ty: Ty<'_>, path: &[&str]) -> bool {
     match ty.kind() {
         ty::Adt(adt, _) => match_def_path(cx, adt.did, path),
@@ -138,6 +141,8 @@ pub fn match_type(cx: &LateContext<'_>, ty: Ty<'_>, path: &[&str]) -> bool {
 }
 
 /// Checks if the type is equal to a diagnostic item
+///
+/// If you change the signature, remember to update the internal lint `MatchTypeOnDiagItem`
 pub fn is_type_diagnostic_item(cx: &LateContext<'_>, ty: Ty<'_>, diag_item: Symbol) -> bool {
     match ty.kind() {
         ty::Adt(adt, _) => cx.tcx.is_diagnostic_item(diag_item, adt.did),
diff --git a/tests/ui/match_type_on_diag_item.rs b/tests/ui/match_type_on_diag_item.rs
new file mode 100644
index 00000000000..fe950b0aa7c
--- /dev/null
+++ b/tests/ui/match_type_on_diag_item.rs
@@ -0,0 +1,50 @@
+#![deny(clippy::internal)]
+#![feature(rustc_private)]
+
+extern crate rustc_hir;
+extern crate rustc_lint;
+extern crate rustc_middle;
+#[macro_use]
+extern crate rustc_session;
+use rustc_hir::Expr;
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::Ty;
+
+mod paths {
+    pub const VEC: [&str; 3] = ["alloc", "vec", "Vec"];
+}
+
+mod utils {
+    use super::*;
+
+    pub fn match_type(_cx: &LateContext<'_>, _ty: Ty<'_>, _path: &[&str]) -> bool {
+        false
+    }
+}
+
+use utils::match_type;
+
+declare_lint! {
+    pub TEST_LINT,
+    Warn,
+    ""
+}
+
+declare_lint_pass!(Pass => [TEST_LINT]);
+
+static OPTION: [&str; 3] = ["core", "option", "Option"];
+
+impl<'tcx> LateLintPass<'tcx> for Pass {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr) {
+        let ty = cx.typeck_results().expr_ty(expr);
+
+        let _ = match_type(cx, ty, &paths::VEC);
+        let _ = match_type(cx, ty, &OPTION);
+        let _ = match_type(cx, ty, &["core", "result", "Result"]);
+
+        let rc_path = &["alloc", "rc", "Rc"];
+        let _ = utils::match_type(cx, ty, rc_path);
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/match_type_on_diag_item.stderr b/tests/ui/match_type_on_diag_item.stderr
new file mode 100644
index 00000000000..c89137eb758
--- /dev/null
+++ b/tests/ui/match_type_on_diag_item.stderr
@@ -0,0 +1,33 @@
+error: usage of `utils::match_type() on a type diagnostic item`
+  --> $DIR/match_type_on_diag_item.rs:41:17
+   |
+LL |         let _ = match_type(cx, ty, &paths::VEC);
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `utils::is_type_diagnostic_item(cx, ty, sym!(vec_type))`
+   |
+note: the lint level is defined here
+  --> $DIR/match_type_on_diag_item.rs:1:9
+   |
+LL | #![deny(clippy::internal)]
+   |         ^^^^^^^^^^^^^^^^
+   = note: `#[deny(clippy::match_type_on_diagnostic_item)]` implied by `#[deny(clippy::internal)]`
+
+error: usage of `utils::match_type() on a type diagnostic item`
+  --> $DIR/match_type_on_diag_item.rs:42:17
+   |
+LL |         let _ = match_type(cx, ty, &OPTION);
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `utils::is_type_diagnostic_item(cx, ty, sym!(option_type))`
+
+error: usage of `utils::match_type() on a type diagnostic item`
+  --> $DIR/match_type_on_diag_item.rs:43:17
+   |
+LL |         let _ = match_type(cx, ty, &["core", "result", "Result"]);
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `utils::is_type_diagnostic_item(cx, ty, sym!(result_type))`
+
+error: usage of `utils::match_type() on a type diagnostic item`
+  --> $DIR/match_type_on_diag_item.rs:46:17
+   |
+LL |         let _ = utils::match_type(cx, ty, rc_path);
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `utils::is_type_diagnostic_item(cx, ty, sym!(Rc))`
+
+error: aborting due to 4 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 332c2dcb4dfe5151d7c8d44cdf96c4abd06db593 Mon Sep 17 00:00:00 2001
From: Eduardo Broto <ebroto@tutanota.com>
Date: Sun, 6 Sep 2020 23:48:04 +0200
Subject: Fix dogfood after MatchTypeOnDiagItem

---
 clippy_lints/src/loops.rs              | 2 +-
 clippy_lints/src/methods/mod.rs        | 2 +-
 clippy_lints/src/option_if_let_else.rs | 4 ++--
 3 files changed, 4 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 6c54c07869a..3d2fd0eee85 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -1114,7 +1114,7 @@ fn get_vec_push<'tcx>(cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) -> Option<(&
             if let Some(self_expr) = args.get(0);
             if let Some(pushed_item) = args.get(1);
             // Check that the method being called is push() on a Vec
-            if match_type(cx, cx.typeck_results().expr_ty(self_expr), &paths::VEC);
+            if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(self_expr), sym!(vec_type));
             if path.ident.name.as_str() == "push";
             then {
                 return Some((self_expr, pushed_item))
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 98e027b6d22..de966cccd11 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1808,7 +1808,7 @@ fn lint_or_fun_call<'tcx>(
                     _ => (),
                 }
 
-                if match_type(cx, ty, &paths::VEC) {
+                if is_type_diagnostic_item(cx, ty, sym!(vec_type)) {
                     return;
                 }
             }
diff --git a/clippy_lints/src/option_if_let_else.rs b/clippy_lints/src/option_if_let_else.rs
index 9494efe736c..60e5e7bfed3 100644
--- a/clippy_lints/src/option_if_let_else.rs
+++ b/clippy_lints/src/option_if_let_else.rs
@@ -1,6 +1,6 @@
 use crate::utils;
 use crate::utils::sugg::Sugg;
-use crate::utils::{match_type, paths, span_lint_and_sugg};
+use crate::utils::{is_type_diagnostic_item, paths, span_lint_and_sugg};
 use if_chain::if_chain;
 
 use rustc_errors::Applicability;
@@ -73,7 +73,7 @@ declare_lint_pass!(OptionIfLetElse => [OPTION_IF_LET_ELSE]);
 fn is_result_ok(cx: &LateContext<'_>, expr: &'_ Expr<'_>) -> bool {
     if let ExprKind::MethodCall(ref path, _, &[ref receiver], _) = &expr.kind {
         path.ident.name.to_ident_string() == "ok"
-            && match_type(cx, &cx.typeck_results().expr_ty(&receiver), &paths::RESULT)
+            && is_type_diagnostic_item(cx, &cx.typeck_results().expr_ty(&receiver), sym!(result_type))
     } else {
         false
     }
-- 
cgit 1.4.1-3-g733a5


From c86a7e5f38e54f4404cc71874316eb0b4dba200b Mon Sep 17 00:00:00 2001
From: Eduardo Broto <ebroto@tutanota.com>
Date: Sun, 6 Sep 2020 23:57:24 +0200
Subject: Misc doc updates

---
 clippy_lints/src/utils/diagnostics.rs | 9 +++++++++
 doc/common_tools_writing_lints.md     | 2 +-
 2 files changed, 10 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/diagnostics.rs b/clippy_lints/src/utils/diagnostics.rs
index e4e65b5f4d4..0a58231558e 100644
--- a/clippy_lints/src/utils/diagnostics.rs
+++ b/clippy_lints/src/utils/diagnostics.rs
@@ -51,6 +51,8 @@ pub fn span_lint<T: LintContext>(cx: &T, lint: &'static Lint, sp: impl Into<Mult
 ///
 /// The `help` message can be optionally attached to a `Span`.
 ///
+/// If you change the signature, remember to update the internal lint `CollapsibleCalls`
+///
 /// # Example
 ///
 /// ```ignore
@@ -87,6 +89,8 @@ pub fn span_lint_and_help<'a, T: LintContext>(
 /// The `note` message is presented separately from the main lint message
 /// and is attached to a specific span:
 ///
+/// If you change the signature, remember to update the internal lint `CollapsibleCalls`
+///
 /// # Example
 ///
 /// ```ignore
@@ -126,6 +130,7 @@ pub fn span_lint_and_note<'a, T: LintContext>(
 /// Like `span_lint` but allows to add notes, help and suggestions using a closure.
 ///
 /// If you need to customize your lint output a lot, use this function.
+/// If you change the signature, remember to update the internal lint `CollapsibleCalls`
 pub fn span_lint_and_then<'a, T: LintContext, F>(cx: &'a T, lint: &'static Lint, sp: Span, msg: &str, f: F)
 where
     F: for<'b> FnOnce(&mut DiagnosticBuilder<'b>),
@@ -168,6 +173,10 @@ pub fn span_lint_hir_and_then(
 /// In the example below, `help` is `"try"` and `sugg` is the suggested replacement `".any(|x| x >
 /// 2)"`.
 ///
+/// If you change the signature, remember to update the internal lint `CollapsibleCalls`
+///
+/// # Example
+///
 /// ```ignore
 /// error: This `.fold` can be more succinctly expressed as `.any`
 /// --> $DIR/methods.rs:390:13
diff --git a/doc/common_tools_writing_lints.md b/doc/common_tools_writing_lints.md
index 9dd4c8a5f7a..53c3d084dbc 100644
--- a/doc/common_tools_writing_lints.md
+++ b/doc/common_tools_writing_lints.md
@@ -60,7 +60,7 @@ impl LateLintPass<'_> for MyStructLint {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
         if_chain! {
             // Check our expr is calling a method
-            if let hir::ExprKind::MethodCall(path, _, _args) = &expr.kind;
+            if let hir::ExprKind::MethodCall(path, _, _args, _) = &expr.kind;
             // Check the name of this method is `some_method`
             if path.ident.name == sym!(some_method);
             then {
-- 
cgit 1.4.1-3-g733a5


From d0b5663d30457d1a9ec4f98eb9baff7123b77172 Mon Sep 17 00:00:00 2001
From: Eduardo Broto <ebroto@tutanota.com>
Date: Tue, 15 Sep 2020 10:31:50 +0200
Subject: Fix usage of backquotes in suggestion

---
 clippy_lints/src/utils/internal_lints.rs | 2 +-
 tests/ui/match_type_on_diag_item.stderr  | 8 ++++----
 2 files changed, 5 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs
index 5beb4be5b29..f201494a024 100644
--- a/clippy_lints/src/utils/internal_lints.rs
+++ b/clippy_lints/src/utils/internal_lints.rs
@@ -704,7 +704,7 @@ impl<'tcx> LateLintPass<'tcx> for MatchTypeOnDiagItem {
                     cx,
                     MATCH_TYPE_ON_DIAGNOSTIC_ITEM,
                     expr.span,
-                    "usage of `utils::match_type() on a type diagnostic item`",
+                    "usage of `utils::match_type()` on a type diagnostic item",
                     "try",
                     format!("utils::is_type_diagnostic_item({}, {}, sym!({}))", cx_snippet, ty_snippet, item_name),
                     Applicability::MaybeIncorrect,
diff --git a/tests/ui/match_type_on_diag_item.stderr b/tests/ui/match_type_on_diag_item.stderr
index c89137eb758..5e5fe9e3a3e 100644
--- a/tests/ui/match_type_on_diag_item.stderr
+++ b/tests/ui/match_type_on_diag_item.stderr
@@ -1,4 +1,4 @@
-error: usage of `utils::match_type() on a type diagnostic item`
+error: usage of `utils::match_type()` on a type diagnostic item
   --> $DIR/match_type_on_diag_item.rs:41:17
    |
 LL |         let _ = match_type(cx, ty, &paths::VEC);
@@ -11,19 +11,19 @@ LL | #![deny(clippy::internal)]
    |         ^^^^^^^^^^^^^^^^
    = note: `#[deny(clippy::match_type_on_diagnostic_item)]` implied by `#[deny(clippy::internal)]`
 
-error: usage of `utils::match_type() on a type diagnostic item`
+error: usage of `utils::match_type()` on a type diagnostic item
   --> $DIR/match_type_on_diag_item.rs:42:17
    |
 LL |         let _ = match_type(cx, ty, &OPTION);
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `utils::is_type_diagnostic_item(cx, ty, sym!(option_type))`
 
-error: usage of `utils::match_type() on a type diagnostic item`
+error: usage of `utils::match_type()` on a type diagnostic item
   --> $DIR/match_type_on_diag_item.rs:43:17
    |
 LL |         let _ = match_type(cx, ty, &["core", "result", "Result"]);
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `utils::is_type_diagnostic_item(cx, ty, sym!(result_type))`
 
-error: usage of `utils::match_type() on a type diagnostic item`
+error: usage of `utils::match_type()` on a type diagnostic item
   --> $DIR/match_type_on_diag_item.rs:46:17
    |
 LL |         let _ = utils::match_type(cx, ty, rc_path);
-- 
cgit 1.4.1-3-g733a5


From 44eb66d947191be51f0a7b7d35c05936a4142a97 Mon Sep 17 00:00:00 2001
From: Takayuki Nakata <f.seasons017@gmail.com>
Date: Wed, 16 Sep 2020 00:25:00 +0900
Subject: Add note to `shadow_unrelated`

This lint can be disabled at function level.
---
 clippy_lints/src/shadow.rs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/shadow.rs b/clippy_lints/src/shadow.rs
index ef4a54735a4..225fe58906f 100644
--- a/clippy_lints/src/shadow.rs
+++ b/clippy_lints/src/shadow.rs
@@ -74,7 +74,9 @@ declare_clippy_lint! {
     /// names to bindings or introducing more scopes to contain the bindings.
     ///
     /// **Known problems:** This lint, as the other shadowing related lints,
-    /// currently only catches very simple patterns.
+    /// currently only catches very simple patterns. Note that
+    /// `allow`/`warn`/`deny`/`forbid` attributes only work on the function level
+    /// for this lint.
     ///
     /// **Example:**
     /// ```rust
-- 
cgit 1.4.1-3-g733a5


From 16b6cebaa67655a793d90d296c03e2c5496ec4ce Mon Sep 17 00:00:00 2001
From: Haraman Johal <haraman.johal@oxfordni.com>
Date: Tue, 15 Sep 2020 17:29:41 +0100
Subject: update lint docs

---
 clippy_lints/src/misc.rs | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/misc.rs b/clippy_lints/src/misc.rs
index 81e6214f143..67a3685fd0d 100644
--- a/clippy_lints/src/misc.rs
+++ b/clippy_lints/src/misc.rs
@@ -99,11 +99,11 @@ declare_clippy_lint! {
     /// if y != x {} // where both are floats
     ///
     /// // Good
-    /// let error = f64::EPSILON; // Use an epsilon for comparison
+    /// let error_margin = f64::EPSILON; // Use an epsilon for comparison
     /// // Or, if Rust <= 1.42, use `std::f64::EPSILON` constant instead.
-    /// // let error = std::f64::EPSILON;
-    /// if (y - 1.23f64).abs() < error { }
-    /// if (y - x).abs() > error { }
+    /// // let error_margin = std::f64::EPSILON;
+    /// if (y - 1.23f64).abs() < error_margin { }
+    /// if (y - x).abs() > error_margin { }
     /// ```
     pub FLOAT_CMP,
     correctness,
@@ -242,10 +242,10 @@ declare_clippy_lint! {
     /// if x == ONE { } // where both are floats
     ///
     /// // Good
-    /// let error = f64::EPSILON; // Use an epsilon for comparison
+    /// let error_margin = f64::EPSILON; // Use an epsilon for comparison
     /// // Or, if Rust <= 1.42, use `std::f64::EPSILON` constant instead.
-    /// // let error = std::f64::EPSILON;
-    /// if (x - ONE).abs() < error { }
+    /// // let error_margin = std::f64::EPSILON;
+    /// if (x - ONE).abs() < error_margin { }
     /// ```
     pub FLOAT_CMP_CONST,
     restriction,
-- 
cgit 1.4.1-3-g733a5


From 79a0e5110a0168945d43e334e6dc0d12e0bc1487 Mon Sep 17 00:00:00 2001
From: Michael Wright <mikerite@lavabit.com>
Date: Tue, 15 Sep 2020 21:25:03 +0200
Subject: manual-strip: Fix formatting

---
 clippy_lints/src/manual_strip.rs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_strip.rs b/clippy_lints/src/manual_strip.rs
index 127938aecd6..4afb0ab3bad 100644
--- a/clippy_lints/src/manual_strip.rs
+++ b/clippy_lints/src/manual_strip.rs
@@ -124,8 +124,7 @@ fn len_arg<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<&'tcx E
         if match_def_path(cx, method_def_id, &paths::STR_LEN);
         then {
             Some(arg)
-        }
-        else {
+        } else {
             None
         }
     }
-- 
cgit 1.4.1-3-g733a5


From 6ba36bcfd3802d9520d0ac48dabfe6dc06d8dc82 Mon Sep 17 00:00:00 2001
From: Tim Nielens <tim.nielens@gmail.com>
Date: Sat, 22 Aug 2020 00:43:04 +0200
Subject: option_if_let_else - distinguish pure from impure else expressions

---
 clippy_lints/src/methods/bind_instead_of_map.rs   |  21 ++--
 clippy_lints/src/methods/mod.rs                   |  66 ++++-------
 clippy_lints/src/methods/unnecessary_lazy_eval.rs |  76 ++-----------
 clippy_lints/src/option_if_let_else.rs            |  33 +++---
 clippy_lints/src/utils/eager_or_lazy.rs           | 128 ++++++++++++++++++++++
 clippy_lints/src/utils/mod.rs                     |   1 +
 clippy_lints/src/utils/sugg.rs                    |   2 +-
 clippy_lints/src/utils/usage.rs                   |  66 +++++++++++
 tests/ui/option_if_let_else.fixed                 |  10 ++
 tests/ui/option_if_let_else.rs                    |  15 +++
 tests/ui/option_if_let_else.stderr                |  36 ++++--
 tests/ui/unnecessary_lazy_eval.fixed              |  42 +++----
 tests/ui/unnecessary_lazy_eval.rs                 |  26 +++--
 tests/ui/unnecessary_lazy_eval.stderr             | 112 +++++++++++++------
 14 files changed, 420 insertions(+), 214 deletions(-)
 create mode 100644 clippy_lints/src/utils/eager_or_lazy.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/bind_instead_of_map.rs b/clippy_lints/src/methods/bind_instead_of_map.rs
index 498f12518f8..ae37942e55a 100644
--- a/clippy_lints/src/methods/bind_instead_of_map.rs
+++ b/clippy_lints/src/methods/bind_instead_of_map.rs
@@ -12,6 +12,7 @@ use rustc_middle::hir::map::Map;
 use rustc_span::Span;
 
 pub(crate) struct OptionAndThenSome;
+
 impl BindInsteadOfMap for OptionAndThenSome {
     const TYPE_NAME: &'static str = "Option";
     const TYPE_QPATH: &'static [&'static str] = &paths::OPTION;
@@ -24,6 +25,7 @@ impl BindInsteadOfMap for OptionAndThenSome {
 }
 
 pub(crate) struct ResultAndThenOk;
+
 impl BindInsteadOfMap for ResultAndThenOk {
     const TYPE_NAME: &'static str = "Result";
     const TYPE_QPATH: &'static [&'static str] = &paths::RESULT;
@@ -36,6 +38,7 @@ impl BindInsteadOfMap for ResultAndThenOk {
 }
 
 pub(crate) struct ResultOrElseErrInfo;
+
 impl BindInsteadOfMap for ResultOrElseErrInfo {
     const TYPE_NAME: &'static str = "Result";
     const TYPE_QPATH: &'static [&'static str] = &paths::RESULT;
@@ -120,9 +123,9 @@ pub(crate) trait BindInsteadOfMap {
         }
     }
 
-    fn lint_closure(cx: &LateContext<'_>, expr: &hir::Expr<'_>, closure_expr: &hir::Expr<'_>) {
+    fn lint_closure(cx: &LateContext<'_>, expr: &hir::Expr<'_>, closure_expr: &hir::Expr<'_>) -> bool {
         let mut suggs = Vec::new();
-        let can_sugg = find_all_ret_expressions(cx, closure_expr, |ret_expr| {
+        let can_sugg: bool = find_all_ret_expressions(cx, closure_expr, |ret_expr| {
             if_chain! {
                 if !in_macro(ret_expr.span);
                 if let hir::ExprKind::Call(ref func_path, ref args) = ret_expr.kind;
@@ -153,12 +156,13 @@ pub(crate) trait BindInsteadOfMap {
                 )
             });
         }
+        can_sugg
     }
 
     /// Lint use of `_.and_then(|x| Some(y))` for `Option`s
-    fn lint(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::Expr<'_>]) {
+    fn lint(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::Expr<'_>]) -> bool {
         if !match_type(cx, cx.typeck_results().expr_ty(&args[0]), Self::TYPE_QPATH) {
-            return;
+            return false;
         }
 
         match args[1].kind {
@@ -166,8 +170,10 @@ pub(crate) trait BindInsteadOfMap {
                 let closure_body = cx.tcx.hir().body(body_id);
                 let closure_expr = remove_blocks(&closure_body.value);
 
-                if !Self::lint_closure_autofixable(cx, expr, args, closure_expr, closure_args_span) {
-                    Self::lint_closure(cx, expr, closure_expr);
+                if Self::lint_closure_autofixable(cx, expr, args, closure_expr, closure_args_span) {
+                    true
+                } else {
+                    Self::lint_closure(cx, expr, closure_expr)
                 }
             },
             // `_.and_then(Some)` case, which is no-op.
@@ -181,8 +187,9 @@ pub(crate) trait BindInsteadOfMap {
                     snippet(cx, args[0].span, "..").into(),
                     Applicability::MachineApplicable,
                 );
+                true
             },
-            _ => {},
+            _ => false,
         }
     }
 }
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 98e027b6d22..914f9f94e77 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -25,14 +25,15 @@ use rustc_span::source_map::Span;
 use rustc_span::symbol::{sym, SymbolStr};
 
 use crate::consts::{constant, Constant};
+use crate::utils::eager_or_lazy::is_lazyness_candidate;
 use crate::utils::usage::mutated_variables;
 use crate::utils::{
     contains_ty, get_arg_name, get_parent_expr, get_trait_def_id, has_iter_method, higher, implements_trait, in_macro,
-    is_copy, is_ctor_or_promotable_const_function, is_expn_of, is_type_diagnostic_item, iter_input_pats,
-    last_path_segment, match_def_path, match_qpath, match_trait_method, match_type, match_var, method_calls,
-    method_chain_args, paths, remove_blocks, return_ty, single_segment_path, snippet, snippet_with_applicability,
-    snippet_with_macro_callsite, span_lint, span_lint_and_help, span_lint_and_note, span_lint_and_sugg,
-    span_lint_and_then, sugg, walk_ptrs_ty, walk_ptrs_ty_depth, SpanlessEq,
+    is_copy, is_expn_of, is_type_diagnostic_item, iter_input_pats, last_path_segment, match_def_path, match_qpath,
+    match_trait_method, match_type, match_var, method_calls, method_chain_args, paths, remove_blocks, return_ty,
+    single_segment_path, snippet, snippet_with_applicability, snippet_with_macro_callsite, span_lint,
+    span_lint_and_help, span_lint_and_note, span_lint_and_sugg, span_lint_and_then, sugg, walk_ptrs_ty,
+    walk_ptrs_ty_depth, SpanlessEq,
 };
 
 declare_clippy_lint! {
@@ -1454,18 +1455,21 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             ["unwrap_or", "map"] => option_map_unwrap_or::lint(cx, expr, arg_lists[1], arg_lists[0], method_spans[1]),
             ["unwrap_or_else", "map"] => {
                 if !lint_map_unwrap_or_else(cx, expr, arg_lists[1], arg_lists[0]) {
-                    unnecessary_lazy_eval::lint(cx, expr, arg_lists[0], true, "unwrap_or");
+                    unnecessary_lazy_eval::lint(cx, expr, arg_lists[0], "unwrap_or");
                 }
             },
             ["map_or", ..] => lint_map_or_none(cx, expr, arg_lists[0]),
             ["and_then", ..] => {
-                unnecessary_lazy_eval::lint(cx, expr, arg_lists[0], false, "and");
-                bind_instead_of_map::OptionAndThenSome::lint(cx, expr, arg_lists[0]);
-                bind_instead_of_map::ResultAndThenOk::lint(cx, expr, arg_lists[0]);
+                let biom_option_linted = bind_instead_of_map::OptionAndThenSome::lint(cx, expr, arg_lists[0]);
+                let biom_result_linted = bind_instead_of_map::ResultAndThenOk::lint(cx, expr, arg_lists[0]);
+                if !biom_option_linted && !biom_result_linted {
+                    unnecessary_lazy_eval::lint(cx, expr, arg_lists[0], "and");
+                }
             },
             ["or_else", ..] => {
-                unnecessary_lazy_eval::lint(cx, expr, arg_lists[0], false, "or");
-                bind_instead_of_map::ResultOrElseErrInfo::lint(cx, expr, arg_lists[0]);
+                if !bind_instead_of_map::ResultOrElseErrInfo::lint(cx, expr, arg_lists[0]) {
+                    unnecessary_lazy_eval::lint(cx, expr, arg_lists[0], "or");
+                }
             },
             ["next", "filter"] => lint_filter_next(cx, expr, arg_lists[1]),
             ["next", "skip_while"] => lint_skip_while_next(cx, expr, arg_lists[1]),
@@ -1508,9 +1512,9 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             ["is_file", ..] => lint_filetype_is_file(cx, expr, arg_lists[0]),
             ["map", "as_ref"] => lint_option_as_ref_deref(cx, expr, arg_lists[1], arg_lists[0], false),
             ["map", "as_mut"] => lint_option_as_ref_deref(cx, expr, arg_lists[1], arg_lists[0], true),
-            ["unwrap_or_else", ..] => unnecessary_lazy_eval::lint(cx, expr, arg_lists[0], true, "unwrap_or"),
-            ["get_or_insert_with", ..] => unnecessary_lazy_eval::lint(cx, expr, arg_lists[0], true, "get_or_insert"),
-            ["ok_or_else", ..] => unnecessary_lazy_eval::lint(cx, expr, arg_lists[0], true, "ok_or"),
+            ["unwrap_or_else", ..] => unnecessary_lazy_eval::lint(cx, expr, arg_lists[0], "unwrap_or"),
+            ["get_or_insert_with", ..] => unnecessary_lazy_eval::lint(cx, expr, arg_lists[0], "get_or_insert"),
+            ["ok_or_else", ..] => unnecessary_lazy_eval::lint(cx, expr, arg_lists[0], "ok_or"),
             _ => {},
         }
 
@@ -1714,37 +1718,6 @@ fn lint_or_fun_call<'tcx>(
     name: &str,
     args: &'tcx [hir::Expr<'_>],
 ) {
-    // Searches an expression for method calls or function calls that aren't ctors
-    struct FunCallFinder<'a, 'tcx> {
-        cx: &'a LateContext<'tcx>,
-        found: bool,
-    }
-
-    impl<'a, 'tcx> intravisit::Visitor<'tcx> for FunCallFinder<'a, 'tcx> {
-        type Map = Map<'tcx>;
-
-        fn visit_expr(&mut self, expr: &'tcx hir::Expr<'_>) {
-            let call_found = match &expr.kind {
-                // ignore enum and struct constructors
-                hir::ExprKind::Call(..) => !is_ctor_or_promotable_const_function(self.cx, expr),
-                hir::ExprKind::MethodCall(..) => true,
-                _ => false,
-            };
-
-            if call_found {
-                self.found |= true;
-            }
-
-            if !self.found {
-                intravisit::walk_expr(self, expr);
-            }
-        }
-
-        fn nested_visit_map(&mut self) -> intravisit::NestedVisitorMap<Self::Map> {
-            intravisit::NestedVisitorMap::None
-        }
-    }
-
     /// Checks for `unwrap_or(T::new())` or `unwrap_or(T::default())`.
     fn check_unwrap_or_default(
         cx: &LateContext<'_>,
@@ -1825,8 +1798,7 @@ fn lint_or_fun_call<'tcx>(
         if_chain! {
             if know_types.iter().any(|k| k.2.contains(&name));
 
-            let mut finder = FunCallFinder { cx: &cx, found: false };
-            if { finder.visit_expr(&arg); finder.found };
+            if is_lazyness_candidate(cx, arg);
             if !contains_return(&arg);
 
             let self_ty = cx.typeck_results().expr_ty(self_expr);
diff --git a/clippy_lints/src/methods/unnecessary_lazy_eval.rs b/clippy_lints/src/methods/unnecessary_lazy_eval.rs
index 31517659c34..08b3eab9b7c 100644
--- a/clippy_lints/src/methods/unnecessary_lazy_eval.rs
+++ b/clippy_lints/src/methods/unnecessary_lazy_eval.rs
@@ -1,78 +1,17 @@
-use crate::utils::{is_type_diagnostic_item, match_qpath, snippet, span_lint_and_sugg};
-use if_chain::if_chain;
+use crate::utils::{eager_or_lazy, usage};
+use crate::utils::{is_type_diagnostic_item, snippet, span_lint_and_sugg};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
 
 use super::UNNECESSARY_LAZY_EVALUATIONS;
 
-// Return true if the expression is an accessor of any of the arguments
-fn expr_uses_argument(expr: &hir::Expr<'_>, params: &[hir::Param<'_>]) -> bool {
-    params.iter().any(|arg| {
-        if_chain! {
-            if let hir::PatKind::Binding(_, _, ident, _) = arg.pat.kind;
-            if let hir::ExprKind::Path(hir::QPath::Resolved(_, ref path)) = expr.kind;
-            if let [p, ..] = path.segments;
-            then {
-                ident.name == p.ident.name
-            } else {
-                false
-            }
-        }
-    })
-}
-
-fn match_any_qpath(path: &hir::QPath<'_>, paths: &[&[&str]]) -> bool {
-    paths.iter().any(|candidate| match_qpath(path, candidate))
-}
-
-fn can_simplify(expr: &hir::Expr<'_>, params: &[hir::Param<'_>], variant_calls: bool) -> bool {
-    match expr.kind {
-        // Closures returning literals can be unconditionally simplified
-        hir::ExprKind::Lit(_) => true,
-
-        hir::ExprKind::Index(ref object, ref index) => {
-            // arguments are not being indexed into
-            if expr_uses_argument(object, params) {
-                false
-            } else {
-                // arguments are not used as index
-                !expr_uses_argument(index, params)
-            }
-        },
-
-        // Reading fields can be simplified if the object is not an argument of the closure
-        hir::ExprKind::Field(ref object, _) => !expr_uses_argument(object, params),
-
-        // Paths can be simplified if the root is not the argument, this also covers None
-        hir::ExprKind::Path(_) => !expr_uses_argument(expr, params),
-
-        // Calls to Some, Ok, Err can be considered literals if they don't derive an argument
-        hir::ExprKind::Call(ref func, ref args) => if_chain! {
-            if variant_calls; // Disable lint when rules conflict with bind_instead_of_map
-            if let hir::ExprKind::Path(ref path) = func.kind;
-            if match_any_qpath(path, &[&["Some"], &["Ok"], &["Err"]]);
-            then {
-                // Recursively check all arguments
-                args.iter().all(|arg| can_simplify(arg, params, variant_calls))
-            } else {
-                false
-            }
-        },
-
-        // For anything more complex than the above, a closure is probably the right solution,
-        // or the case is handled by an other lint
-        _ => false,
-    }
-}
-
 /// lint use of `<fn>_else(simple closure)` for `Option`s and `Result`s that can be
 /// replaced with `<fn>(return value of simple closure)`
 pub(super) fn lint<'tcx>(
     cx: &LateContext<'tcx>,
     expr: &'tcx hir::Expr<'_>,
     args: &'tcx [hir::Expr<'_>],
-    allow_variant_calls: bool,
     simplify_using: &str,
 ) {
     let is_option = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&args[0]), sym!(option_type));
@@ -81,10 +20,13 @@ pub(super) fn lint<'tcx>(
     if is_option || is_result {
         if let hir::ExprKind::Closure(_, _, eid, _, _) = args[1].kind {
             let body = cx.tcx.hir().body(eid);
-            let ex = &body.value;
-            let params = &body.params;
+            let body_expr = &body.value;
+
+            if usage::BindingUsageFinder::are_params_used(cx, body) {
+                return;
+            }
 
-            if can_simplify(ex, params, allow_variant_calls) {
+            if eager_or_lazy::is_eagerness_candidate(cx, body_expr) {
                 let msg = if is_option {
                     "unnecessary closure used to substitute value for `Option::None`"
                 } else {
@@ -101,7 +43,7 @@ pub(super) fn lint<'tcx>(
                         "{0}.{1}({2})",
                         snippet(cx, args[0].span, ".."),
                         simplify_using,
-                        snippet(cx, ex.span, ".."),
+                        snippet(cx, body_expr.span, ".."),
                     ),
                     Applicability::MachineApplicable,
                 );
diff --git a/clippy_lints/src/option_if_let_else.rs b/clippy_lints/src/option_if_let_else.rs
index 9494efe736c..5e2652b48cb 100644
--- a/clippy_lints/src/option_if_let_else.rs
+++ b/clippy_lints/src/option_if_let_else.rs
@@ -1,4 +1,5 @@
 use crate::utils;
+use crate::utils::eager_or_lazy;
 use crate::utils::sugg::Sugg;
 use crate::utils::{match_type, paths, span_lint_and_sugg};
 use if_chain::if_chain;
@@ -13,22 +14,16 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 declare_clippy_lint! {
     /// **What it does:**
     /// Lints usage of  `if let Some(v) = ... { y } else { x }` which is more
-    /// idiomatically done with `Option::map_or` (if the else bit is a simple
-    /// expression) or `Option::map_or_else` (if the else bit is a longer
-    /// block).
+    /// idiomatically done with `Option::map_or` (if the else bit is a pure
+    /// expression) or `Option::map_or_else` (if the else bit is an impure
+    /// expresion).
     ///
     /// **Why is this bad?**
     /// Using the dedicated functions of the Option type is clearer and
     /// more concise than an if let expression.
     ///
     /// **Known problems:**
-    /// This lint uses whether the block is just an expression or if it has
-    /// more statements to decide whether to use `Option::map_or` or
-    /// `Option::map_or_else`. If you have a single expression which calls
-    /// an expensive function, then it would be more efficient to use
-    /// `Option::map_or_else`, but this lint would suggest `Option::map_or`.
-    ///
-    /// Also, this lint uses a deliberately conservative metric for checking
+    /// This lint uses a deliberately conservative metric for checking
     /// if the inside of either body contains breaks or continues which will
     /// cause it to not suggest a fix if either block contains a loop with
     /// continues or breaks contained within the loop.
@@ -92,6 +87,7 @@ struct OptionIfLetElseOccurence {
 struct ReturnBreakContinueMacroVisitor {
     seen_return_break_continue: bool,
 }
+
 impl ReturnBreakContinueMacroVisitor {
     fn new() -> ReturnBreakContinueMacroVisitor {
         ReturnBreakContinueMacroVisitor {
@@ -99,6 +95,7 @@ impl ReturnBreakContinueMacroVisitor {
         }
     }
 }
+
 impl<'tcx> Visitor<'tcx> for ReturnBreakContinueMacroVisitor {
     type Map = Map<'tcx>;
     fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
@@ -157,7 +154,7 @@ fn extract_body_from_arm<'a>(arm: &'a Arm<'a>) -> Option<&'a Expr<'a>> {
 }
 
 /// If this is the else body of an if/else expression, then we need to wrap
-/// it in curcly braces. Otherwise, we don't.
+/// it in curly braces. Otherwise, we don't.
 fn should_wrap_in_braces(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
     utils::get_enclosing_block(cx, expr.hir_id).map_or(false, |parent| {
         if let Some(Expr {
@@ -199,7 +196,10 @@ fn format_option_in_sugg(cx: &LateContext<'_>, cond_expr: &Expr<'_>, as_ref: boo
 /// If this expression is the option if let/else construct we're detecting, then
 /// this function returns an `OptionIfLetElseOccurence` struct with details if
 /// this construct is found, or None if this construct is not found.
-fn detect_option_if_let_else(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<OptionIfLetElseOccurence> {
+fn detect_option_if_let_else<'tcx>(
+    cx: &'_ LateContext<'tcx>,
+    expr: &'_ Expr<'tcx>,
+) -> Option<OptionIfLetElseOccurence> {
     if_chain! {
         if !utils::in_macro(expr.span); // Don't lint macros, because it behaves weirdly
         if let ExprKind::Match(cond_expr, arms, MatchSource::IfLetDesugar{contains_else_clause: true}) = &expr.kind;
@@ -214,10 +214,7 @@ fn detect_option_if_let_else(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<Op
             let capture_mut = if bind_annotation == &BindingAnnotation::Mutable { "mut " } else { "" };
             let some_body = extract_body_from_arm(&arms[0])?;
             let none_body = extract_body_from_arm(&arms[1])?;
-            let method_sugg = match &none_body.kind {
-                ExprKind::Block(..) => "map_or_else",
-                _ => "map_or",
-            };
+            let method_sugg = if eager_or_lazy::is_eagerness_candidate(cx, none_body) { "map_or" } else { "map_or_else" };
             let capture_name = id.name.to_ident_string();
             let wrap_braces = should_wrap_in_braces(cx, expr);
             let (as_ref, as_mut) = match &cond_expr.kind {
@@ -243,8 +240,8 @@ fn detect_option_if_let_else(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<Op
     }
 }
 
-impl<'a> LateLintPass<'a> for OptionIfLetElse {
-    fn check_expr(&mut self, cx: &LateContext<'a>, expr: &Expr<'_>) {
+impl<'tcx> LateLintPass<'tcx> for OptionIfLetElse {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &Expr<'tcx>) {
         if let Some(detection) = detect_option_if_let_else(cx, expr) {
             span_lint_and_sugg(
                 cx,
diff --git a/clippy_lints/src/utils/eager_or_lazy.rs b/clippy_lints/src/utils/eager_or_lazy.rs
new file mode 100644
index 00000000000..6938d9971d9
--- /dev/null
+++ b/clippy_lints/src/utils/eager_or_lazy.rs
@@ -0,0 +1,128 @@
+//! Utilities for evaluating whether eagerly evaluated expressions can be made lazy and vice versa.
+//!
+//! Things to consider:
+//!  - has the expression side-effects?
+//!  - is the expression computationally expensive?
+//!
+//! See lints:
+//!  - unnecessary-lazy-evaluations
+//!  - or-fun-call
+//!  - option-if-let-else
+
+use crate::utils::is_ctor_or_promotable_const_function;
+use rustc_hir::def::{DefKind, Res};
+
+use rustc_hir::intravisit;
+use rustc_hir::intravisit::{NestedVisitorMap, Visitor};
+
+use rustc_hir::{Block, Expr, ExprKind, Path, QPath};
+use rustc_lint::LateContext;
+use rustc_middle::hir::map::Map;
+
+/// Is the expr pure (is it free from side-effects)?
+/// This function is named so to stress that it isn't exhaustive and returns FNs.
+fn identify_some_pure_patterns(expr: &Expr<'_>) -> bool {
+    match expr.kind {
+        ExprKind::Lit(..) | ExprKind::Path(..) | ExprKind::Field(..) => true,
+        ExprKind::AddrOf(_, _, addr_of_expr) => identify_some_pure_patterns(addr_of_expr),
+        ExprKind::Tup(tup_exprs) => tup_exprs.iter().all(|expr| identify_some_pure_patterns(expr)),
+        ExprKind::Struct(_, fields, expr) => {
+            fields.iter().all(|f| identify_some_pure_patterns(f.expr))
+                && expr.map_or(true, |e| identify_some_pure_patterns(e))
+        },
+        ExprKind::Call(
+            &Expr {
+                kind:
+                    ExprKind::Path(QPath::Resolved(
+                        _,
+                        Path {
+                            res: Res::Def(DefKind::Ctor(..) | DefKind::Variant, ..),
+                            ..
+                        },
+                    )),
+                ..
+            },
+            args,
+        ) => args.iter().all(|expr| identify_some_pure_patterns(expr)),
+        ExprKind::Block(
+            &Block {
+                stmts,
+                expr: Some(expr),
+                ..
+            },
+            _,
+        ) => stmts.is_empty() && identify_some_pure_patterns(expr),
+        ExprKind::Box(..)
+        | ExprKind::Array(..)
+        | ExprKind::Call(..)
+        | ExprKind::MethodCall(..)
+        | ExprKind::Binary(..)
+        | ExprKind::Unary(..)
+        | ExprKind::Cast(..)
+        | ExprKind::Type(..)
+        | ExprKind::DropTemps(..)
+        | ExprKind::Loop(..)
+        | ExprKind::Match(..)
+        | ExprKind::Closure(..)
+        | ExprKind::Block(..)
+        | ExprKind::Assign(..)
+        | ExprKind::AssignOp(..)
+        | ExprKind::Index(..)
+        | ExprKind::Break(..)
+        | ExprKind::Continue(..)
+        | ExprKind::Ret(..)
+        | ExprKind::InlineAsm(..)
+        | ExprKind::LlvmInlineAsm(..)
+        | ExprKind::Repeat(..)
+        | ExprKind::Yield(..)
+        | ExprKind::Err => false,
+    }
+}
+
+/// Identify some potentially computationally expensive patterns.
+/// This function is named so to stress that its implementation is non-exhaustive.
+/// It returns FNs and FPs.
+fn identify_some_potentially_expensive_patterns<'a, 'tcx>(cx: &'a LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
+    // Searches an expression for method calls or function calls that aren't ctors
+    struct FunCallFinder<'a, 'tcx> {
+        cx: &'a LateContext<'tcx>,
+        found: bool,
+    }
+
+    impl<'a, 'tcx> intravisit::Visitor<'tcx> for FunCallFinder<'a, 'tcx> {
+        type Map = Map<'tcx>;
+
+        fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) {
+            let call_found = match &expr.kind {
+                // ignore enum and struct constructors
+                ExprKind::Call(..) => !is_ctor_or_promotable_const_function(self.cx, expr),
+                ExprKind::MethodCall(..) => true,
+                _ => false,
+            };
+
+            if call_found {
+                self.found |= true;
+            }
+
+            if !self.found {
+                intravisit::walk_expr(self, expr);
+            }
+        }
+
+        fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+            NestedVisitorMap::None
+        }
+    }
+
+    let mut finder = FunCallFinder { cx, found: false };
+    finder.visit_expr(expr);
+    finder.found
+}
+
+pub fn is_eagerness_candidate<'a, 'tcx>(cx: &'a LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
+    !identify_some_potentially_expensive_patterns(cx, expr) && identify_some_pure_patterns(expr)
+}
+
+pub fn is_lazyness_candidate<'a, 'tcx>(cx: &'a LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
+    identify_some_potentially_expensive_patterns(cx, expr)
+}
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index 3ebbfed6456..7efeef62690 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -10,6 +10,7 @@ pub mod comparisons;
 pub mod conf;
 pub mod constants;
 mod diagnostics;
+pub mod eager_or_lazy;
 pub mod higher;
 mod hir_utils;
 pub mod inspector;
diff --git a/clippy_lints/src/utils/sugg.rs b/clippy_lints/src/utils/sugg.rs
index 811fde388d1..ec8b7e59b59 100644
--- a/clippy_lints/src/utils/sugg.rs
+++ b/clippy_lints/src/utils/sugg.rs
@@ -49,7 +49,7 @@ impl<'a> Sugg<'a> {
     /// Convenience function around `hir_opt` for suggestions with a default
     /// text.
     pub fn hir(cx: &LateContext<'_>, expr: &hir::Expr<'_>, default: &'a str) -> Self {
-        Self::hir_opt(cx, expr).unwrap_or_else(|| Sugg::NonParen(Cow::Borrowed(default)))
+        Self::hir_opt(cx, expr).unwrap_or(Sugg::NonParen(Cow::Borrowed(default)))
     }
 
     /// Same as `hir`, but it adapts the applicability level by following rules:
diff --git a/clippy_lints/src/utils/usage.rs b/clippy_lints/src/utils/usage.rs
index 4a64b935ac9..ea1dc3be29b 100644
--- a/clippy_lints/src/utils/usage.rs
+++ b/clippy_lints/src/utils/usage.rs
@@ -1,6 +1,8 @@
 use crate::utils::match_var;
 use rustc_data_structures::fx::FxHashSet;
+use rustc_hir as hir;
 use rustc_hir::def::Res;
+use rustc_hir::intravisit;
 use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
 use rustc_hir::{Expr, HirId, Path};
 use rustc_infer::infer::TyCtxtInferExt;
@@ -108,3 +110,67 @@ pub fn is_unused<'tcx>(ident: &'tcx Ident, body: &'tcx Expr<'_>) -> bool {
     walk_expr(&mut visitor, body);
     !visitor.used
 }
+
+pub struct ParamBindingIdCollector {
+    binding_hir_ids: Vec<hir::HirId>,
+}
+impl<'tcx> ParamBindingIdCollector {
+    fn collect_binding_hir_ids(body: &'tcx hir::Body<'tcx>) -> Vec<hir::HirId> {
+        let mut finder = ParamBindingIdCollector {
+            binding_hir_ids: Vec::new(),
+        };
+        finder.visit_body(body);
+        finder.binding_hir_ids
+    }
+}
+impl<'tcx> intravisit::Visitor<'tcx> for ParamBindingIdCollector {
+    type Map = Map<'tcx>;
+
+    fn visit_param(&mut self, param: &'tcx hir::Param<'tcx>) {
+        if let hir::PatKind::Binding(_, hir_id, ..) = param.pat.kind {
+            self.binding_hir_ids.push(hir_id);
+        }
+    }
+
+    fn nested_visit_map(&mut self) -> intravisit::NestedVisitorMap<Self::Map> {
+        intravisit::NestedVisitorMap::None
+    }
+}
+
+pub struct BindingUsageFinder<'a, 'tcx> {
+    cx: &'a LateContext<'tcx>,
+    binding_ids: Vec<hir::HirId>,
+    usage_found: bool,
+}
+impl<'a, 'tcx> BindingUsageFinder<'a, 'tcx> {
+    pub fn are_params_used(cx: &'a LateContext<'tcx>, body: &'tcx hir::Body<'tcx>) -> bool {
+        let mut finder = BindingUsageFinder {
+            cx,
+            binding_ids: ParamBindingIdCollector::collect_binding_hir_ids(body),
+            usage_found: false,
+        };
+        finder.visit_body(body);
+        finder.usage_found
+    }
+}
+impl<'a, 'tcx> intravisit::Visitor<'tcx> for BindingUsageFinder<'a, 'tcx> {
+    type Map = Map<'tcx>;
+
+    fn visit_expr(&mut self, expr: &'tcx hir::Expr<'tcx>) {
+        if !self.usage_found {
+            intravisit::walk_expr(self, expr);
+        }
+    }
+
+    fn visit_path(&mut self, path: &'tcx hir::Path<'tcx>, _: hir::HirId) {
+        if let hir::def::Res::Local(id) = path.res {
+            if self.binding_ids.contains(&id) {
+                self.usage_found = true;
+            }
+        }
+    }
+
+    fn nested_visit_map(&mut self) -> intravisit::NestedVisitorMap<Self::Map> {
+        intravisit::NestedVisitorMap::OnlyBodies(self.cx.tcx.hir())
+    }
+}
diff --git a/tests/ui/option_if_let_else.fixed b/tests/ui/option_if_let_else.fixed
index 695a460cc4e..a7fb00a2705 100644
--- a/tests/ui/option_if_let_else.fixed
+++ b/tests/ui/option_if_let_else.fixed
@@ -1,5 +1,6 @@
 // run-rustfix
 #![warn(clippy::option_if_let_else)]
+#![allow(clippy::redundant_closure)]
 
 fn bad1(string: Option<&str>) -> (bool, &str) {
     string.map_or((false, "hello"), |x| (true, x))
@@ -36,6 +37,14 @@ fn longer_body(arg: Option<u32>) -> u32 {
     })
 }
 
+fn impure_else(arg: Option<i32>) {
+    let side_effect = || {
+        println!("return 1");
+        1
+    };
+    let _ = arg.map_or_else(|| side_effect(), |x| x);
+}
+
 fn test_map_or_else(arg: Option<u32>) {
     let _ = arg.map_or_else(|| {
         let mut y = 1;
@@ -71,4 +80,5 @@ fn main() {
     let _ = longer_body(None);
     test_map_or_else(None);
     let _ = negative_tests(None);
+    let _ = impure_else(None);
 }
diff --git a/tests/ui/option_if_let_else.rs b/tests/ui/option_if_let_else.rs
index dee80d26bd9..895fd86321f 100644
--- a/tests/ui/option_if_let_else.rs
+++ b/tests/ui/option_if_let_else.rs
@@ -1,5 +1,6 @@
 // run-rustfix
 #![warn(clippy::option_if_let_else)]
+#![allow(clippy::redundant_closure)]
 
 fn bad1(string: Option<&str>) -> (bool, &str) {
     if let Some(x) = string {
@@ -52,6 +53,19 @@ fn longer_body(arg: Option<u32>) -> u32 {
     }
 }
 
+fn impure_else(arg: Option<i32>) {
+    let side_effect = || {
+        println!("return 1");
+        1
+    };
+    let _ = if let Some(x) = arg {
+        x
+    } else {
+        // map_or_else must be suggested
+        side_effect()
+    };
+}
+
 fn test_map_or_else(arg: Option<u32>) {
     let _ = if let Some(x) = arg {
         x * x * x * x
@@ -89,4 +103,5 @@ fn main() {
     let _ = longer_body(None);
     test_map_or_else(None);
     let _ = negative_tests(None);
+    let _ = impure_else(None);
 }
diff --git a/tests/ui/option_if_let_else.stderr b/tests/ui/option_if_let_else.stderr
index 7005850efaf..b69fe767682 100644
--- a/tests/ui/option_if_let_else.stderr
+++ b/tests/ui/option_if_let_else.stderr
@@ -1,5 +1,5 @@
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:5:5
+  --> $DIR/option_if_let_else.rs:6:5
    |
 LL | /     if let Some(x) = string {
 LL | |         (true, x)
@@ -11,7 +11,7 @@ LL | |     }
    = note: `-D clippy::option-if-let-else` implied by `-D warnings`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:15:12
+  --> $DIR/option_if_let_else.rs:16:12
    |
 LL |       } else if let Some(x) = string {
    |  ____________^
@@ -22,19 +22,19 @@ LL | |     }
    | |_____^ help: try: `{ string.map_or(Some((false, "")), |x| Some((true, x))) }`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:23:13
+  --> $DIR/option_if_let_else.rs:24:13
    |
 LL |     let _ = if let Some(s) = *string { s.len() } else { 0 };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `string.map_or(0, |s| s.len())`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:24:13
+  --> $DIR/option_if_let_else.rs:25:13
    |
 LL |     let _ = if let Some(s) = &num { s } else { &0 };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `num.as_ref().map_or(&0, |s| s)`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:25:13
+  --> $DIR/option_if_let_else.rs:26:13
    |
 LL |       let _ = if let Some(s) = &mut num {
    |  _____________^
@@ -54,13 +54,13 @@ LL |     });
    |
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:31:13
+  --> $DIR/option_if_let_else.rs:32:13
    |
 LL |     let _ = if let Some(ref s) = num { s } else { &0 };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `num.as_ref().map_or(&0, |s| s)`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:32:13
+  --> $DIR/option_if_let_else.rs:33:13
    |
 LL |       let _ = if let Some(mut s) = num {
    |  _____________^
@@ -80,7 +80,7 @@ LL |     });
    |
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:38:13
+  --> $DIR/option_if_let_else.rs:39:13
    |
 LL |       let _ = if let Some(ref mut s) = num {
    |  _____________^
@@ -100,7 +100,7 @@ LL |     });
    |
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:47:5
+  --> $DIR/option_if_let_else.rs:48:5
    |
 LL | /     if let Some(x) = arg {
 LL | |         let y = x * x;
@@ -119,7 +119,19 @@ LL |     })
    |
 
 error: use Option::map_or_else instead of an if let/else
-  --> $DIR/option_if_let_else.rs:56:13
+  --> $DIR/option_if_let_else.rs:61:13
+   |
+LL |       let _ = if let Some(x) = arg {
+   |  _____________^
+LL | |         x
+LL | |     } else {
+LL | |         // map_or_else must be suggested
+LL | |         side_effect()
+LL | |     };
+   | |_____^ help: try: `arg.map_or_else(|| side_effect(), |x| x)`
+
+error: use Option::map_or_else instead of an if let/else
+  --> $DIR/option_if_let_else.rs:70:13
    |
 LL |       let _ = if let Some(x) = arg {
    |  _____________^
@@ -142,10 +154,10 @@ LL |     }, |x| x * x * x * x);
    |
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:85:13
+  --> $DIR/option_if_let_else.rs:99:13
    |
 LL |     let _ = if let Some(x) = optional { x + 2 } else { 5 };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `optional.map_or(5, |x| x + 2)`
 
-error: aborting due to 11 previous errors
+error: aborting due to 12 previous errors
 
diff --git a/tests/ui/unnecessary_lazy_eval.fixed b/tests/ui/unnecessary_lazy_eval.fixed
index fa66e68794e..4980c111499 100644
--- a/tests/ui/unnecessary_lazy_eval.fixed
+++ b/tests/ui/unnecessary_lazy_eval.fixed
@@ -2,6 +2,7 @@
 #![warn(clippy::unnecessary_lazy_evaluations)]
 #![allow(clippy::redundant_closure)]
 #![allow(clippy::bind_instead_of_map)]
+#![allow(clippy::map_identity)]
 
 struct Deep(Option<usize>);
 
@@ -34,13 +35,13 @@ fn main() {
     let _ = opt.unwrap_or(2);
     let _ = opt.unwrap_or(astronomers_pi);
     let _ = opt.unwrap_or(ext_str.some_field);
-    let _ = opt.unwrap_or(ext_arr[0]);
+    let _ = opt.unwrap_or_else(|| ext_arr[0]);
     let _ = opt.and(ext_opt);
     let _ = opt.or(ext_opt);
     let _ = opt.or(None);
     let _ = opt.get_or_insert(2);
     let _ = opt.ok_or(2);
-    let _ = opt.ok_or(ext_arr[0]);
+    let _ = nested_tuple_opt.unwrap_or(Some((1, 2)));
 
     // Cases when unwrap is not called on a simple variable
     let _ = Some(10).unwrap_or(2);
@@ -60,7 +61,6 @@ fn main() {
     // Should not lint - Option
     let _ = opt.unwrap_or_else(|| ext_str.return_some_field());
     let _ = nested_opt.unwrap_or_else(|| Some(some_call()));
-    let _ = nested_tuple_opt.unwrap_or_else(|| Some((1, 2)));
     let _ = nested_tuple_opt.unwrap_or_else(|| Some((some_call(), some_call())));
     let _ = opt.or_else(some_call);
     let _ = opt.or_else(|| some_call());
@@ -69,13 +69,16 @@ fn main() {
     let _ = deep.0.get_or_insert_with(|| some_call());
     let _ = deep.0.or_else(some_call);
     let _ = deep.0.or_else(|| some_call());
+    let _ = opt.ok_or_else(|| ext_arr[0]);
 
-    // These are handled by bind_instead_of_map
+    // should not lint, bind_instead_of_map takes priority
     let _ = Some(10).and_then(|idx| Some(ext_arr[idx]));
     let _ = Some(10).and_then(|idx| Some(idx));
-    let _: Option<usize> = None.or_else(|| Some(3));
-    let _ = deep.0.or_else(|| Some(3));
-    let _ = opt.or_else(|| Some(3));
+
+    // should lint, bind_instead_of_map doesn't apply
+    let _: Option<usize> = None.or(Some(3));
+    let _ = deep.0.or(Some(3));
+    let _ = opt.or(Some(3));
 
     // Should lint - Result
     let res: Result<usize, usize> = Err(5);
@@ -92,26 +95,27 @@ fn main() {
     let _ = res2.unwrap_or_else(|err| err.return_some_field());
     let _ = res2.unwrap_or_else(|_| ext_str.return_some_field());
 
+    // should not lint, bind_instead_of_map takes priority
     let _: Result<usize, usize> = res.and_then(|x| Ok(x));
-    let _: Result<usize, usize> = res.and_then(|x| Err(x));
-
-    let _: Result<usize, usize> = res.or_else(|err| Ok(err));
     let _: Result<usize, usize> = res.or_else(|err| Err(err));
 
-    // These are handled by bind_instead_of_map
     let _: Result<usize, usize> = res.and_then(|_| Ok(2));
     let _: Result<usize, usize> = res.and_then(|_| Ok(astronomers_pi));
     let _: Result<usize, usize> = res.and_then(|_| Ok(ext_str.some_field));
 
-    let _: Result<usize, usize> = res.and_then(|_| Err(2));
-    let _: Result<usize, usize> = res.and_then(|_| Err(astronomers_pi));
-    let _: Result<usize, usize> = res.and_then(|_| Err(ext_str.some_field));
-
-    let _: Result<usize, usize> = res.or_else(|_| Ok(2));
-    let _: Result<usize, usize> = res.or_else(|_| Ok(astronomers_pi));
-    let _: Result<usize, usize> = res.or_else(|_| Ok(ext_str.some_field));
-
     let _: Result<usize, usize> = res.or_else(|_| Err(2));
     let _: Result<usize, usize> = res.or_else(|_| Err(astronomers_pi));
     let _: Result<usize, usize> = res.or_else(|_| Err(ext_str.some_field));
+
+    // should lint, bind_instead_of_map doesn't apply
+    let _: Result<usize, usize> = res.and_then(|x| Err(x));
+    let _: Result<usize, usize> = res.or_else(|err| Ok(err));
+
+    let _: Result<usize, usize> = res.and(Err(2));
+    let _: Result<usize, usize> = res.and(Err(astronomers_pi));
+    let _: Result<usize, usize> = res.and(Err(ext_str.some_field));
+
+    let _: Result<usize, usize> = res.or(Ok(2));
+    let _: Result<usize, usize> = res.or(Ok(astronomers_pi));
+    let _: Result<usize, usize> = res.or(Ok(ext_str.some_field));
 }
diff --git a/tests/ui/unnecessary_lazy_eval.rs b/tests/ui/unnecessary_lazy_eval.rs
index 04f47d1aa29..0b270939ec2 100644
--- a/tests/ui/unnecessary_lazy_eval.rs
+++ b/tests/ui/unnecessary_lazy_eval.rs
@@ -2,6 +2,7 @@
 #![warn(clippy::unnecessary_lazy_evaluations)]
 #![allow(clippy::redundant_closure)]
 #![allow(clippy::bind_instead_of_map)]
+#![allow(clippy::map_identity)]
 
 struct Deep(Option<usize>);
 
@@ -40,7 +41,7 @@ fn main() {
     let _ = opt.or_else(|| None);
     let _ = opt.get_or_insert_with(|| 2);
     let _ = opt.ok_or_else(|| 2);
-    let _ = opt.ok_or_else(|| ext_arr[0]);
+    let _ = nested_tuple_opt.unwrap_or_else(|| Some((1, 2)));
 
     // Cases when unwrap is not called on a simple variable
     let _ = Some(10).unwrap_or_else(|| 2);
@@ -60,7 +61,6 @@ fn main() {
     // Should not lint - Option
     let _ = opt.unwrap_or_else(|| ext_str.return_some_field());
     let _ = nested_opt.unwrap_or_else(|| Some(some_call()));
-    let _ = nested_tuple_opt.unwrap_or_else(|| Some((1, 2)));
     let _ = nested_tuple_opt.unwrap_or_else(|| Some((some_call(), some_call())));
     let _ = opt.or_else(some_call);
     let _ = opt.or_else(|| some_call());
@@ -69,10 +69,13 @@ fn main() {
     let _ = deep.0.get_or_insert_with(|| some_call());
     let _ = deep.0.or_else(some_call);
     let _ = deep.0.or_else(|| some_call());
+    let _ = opt.ok_or_else(|| ext_arr[0]);
 
-    // These are handled by bind_instead_of_map
+    // should not lint, bind_instead_of_map takes priority
     let _ = Some(10).and_then(|idx| Some(ext_arr[idx]));
     let _ = Some(10).and_then(|idx| Some(idx));
+
+    // should lint, bind_instead_of_map doesn't apply
     let _: Option<usize> = None.or_else(|| Some(3));
     let _ = deep.0.or_else(|| Some(3));
     let _ = opt.or_else(|| Some(3));
@@ -92,17 +95,22 @@ fn main() {
     let _ = res2.unwrap_or_else(|err| err.return_some_field());
     let _ = res2.unwrap_or_else(|_| ext_str.return_some_field());
 
+    // should not lint, bind_instead_of_map takes priority
     let _: Result<usize, usize> = res.and_then(|x| Ok(x));
-    let _: Result<usize, usize> = res.and_then(|x| Err(x));
-
-    let _: Result<usize, usize> = res.or_else(|err| Ok(err));
     let _: Result<usize, usize> = res.or_else(|err| Err(err));
 
-    // These are handled by bind_instead_of_map
     let _: Result<usize, usize> = res.and_then(|_| Ok(2));
     let _: Result<usize, usize> = res.and_then(|_| Ok(astronomers_pi));
     let _: Result<usize, usize> = res.and_then(|_| Ok(ext_str.some_field));
 
+    let _: Result<usize, usize> = res.or_else(|_| Err(2));
+    let _: Result<usize, usize> = res.or_else(|_| Err(astronomers_pi));
+    let _: Result<usize, usize> = res.or_else(|_| Err(ext_str.some_field));
+
+    // should lint, bind_instead_of_map doesn't apply
+    let _: Result<usize, usize> = res.and_then(|x| Err(x));
+    let _: Result<usize, usize> = res.or_else(|err| Ok(err));
+
     let _: Result<usize, usize> = res.and_then(|_| Err(2));
     let _: Result<usize, usize> = res.and_then(|_| Err(astronomers_pi));
     let _: Result<usize, usize> = res.and_then(|_| Err(ext_str.some_field));
@@ -110,8 +118,4 @@ fn main() {
     let _: Result<usize, usize> = res.or_else(|_| Ok(2));
     let _: Result<usize, usize> = res.or_else(|_| Ok(astronomers_pi));
     let _: Result<usize, usize> = res.or_else(|_| Ok(ext_str.some_field));
-
-    let _: Result<usize, usize> = res.or_else(|_| Err(2));
-    let _: Result<usize, usize> = res.or_else(|_| Err(astronomers_pi));
-    let _: Result<usize, usize> = res.or_else(|_| Err(ext_str.some_field));
 }
diff --git a/tests/ui/unnecessary_lazy_eval.stderr b/tests/ui/unnecessary_lazy_eval.stderr
index 5c1b2eb1f14..1cf7ac46346 100644
--- a/tests/ui/unnecessary_lazy_eval.stderr
+++ b/tests/ui/unnecessary_lazy_eval.stderr
@@ -1,5 +1,5 @@
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:34:13
+  --> $DIR/unnecessary_lazy_eval.rs:35:13
    |
 LL |     let _ = opt.unwrap_or_else(|| 2);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `unwrap_or` instead: `opt.unwrap_or(2)`
@@ -7,142 +7,190 @@ LL |     let _ = opt.unwrap_or_else(|| 2);
    = note: `-D clippy::unnecessary-lazy-evaluations` implied by `-D warnings`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:35:13
+  --> $DIR/unnecessary_lazy_eval.rs:36:13
    |
 LL |     let _ = opt.unwrap_or_else(|| astronomers_pi);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `unwrap_or` instead: `opt.unwrap_or(astronomers_pi)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:36:13
+  --> $DIR/unnecessary_lazy_eval.rs:37:13
    |
 LL |     let _ = opt.unwrap_or_else(|| ext_str.some_field);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `unwrap_or` instead: `opt.unwrap_or(ext_str.some_field)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:37:13
-   |
-LL |     let _ = opt.unwrap_or_else(|| ext_arr[0]);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `unwrap_or` instead: `opt.unwrap_or(ext_arr[0])`
-
-error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:38:13
+  --> $DIR/unnecessary_lazy_eval.rs:39:13
    |
 LL |     let _ = opt.and_then(|_| ext_opt);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `and` instead: `opt.and(ext_opt)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:39:13
+  --> $DIR/unnecessary_lazy_eval.rs:40:13
    |
 LL |     let _ = opt.or_else(|| ext_opt);
    |             ^^^^^^^^^^^^^^^^^^^^^^^ help: Use `or` instead: `opt.or(ext_opt)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:40:13
+  --> $DIR/unnecessary_lazy_eval.rs:41:13
    |
 LL |     let _ = opt.or_else(|| None);
    |             ^^^^^^^^^^^^^^^^^^^^ help: Use `or` instead: `opt.or(None)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:41:13
+  --> $DIR/unnecessary_lazy_eval.rs:42:13
    |
 LL |     let _ = opt.get_or_insert_with(|| 2);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `get_or_insert` instead: `opt.get_or_insert(2)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:42:13
+  --> $DIR/unnecessary_lazy_eval.rs:43:13
    |
 LL |     let _ = opt.ok_or_else(|| 2);
    |             ^^^^^^^^^^^^^^^^^^^^ help: Use `ok_or` instead: `opt.ok_or(2)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:43:13
+  --> $DIR/unnecessary_lazy_eval.rs:44:13
    |
-LL |     let _ = opt.ok_or_else(|| ext_arr[0]);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `ok_or` instead: `opt.ok_or(ext_arr[0])`
+LL |     let _ = nested_tuple_opt.unwrap_or_else(|| Some((1, 2)));
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `unwrap_or` instead: `nested_tuple_opt.unwrap_or(Some((1, 2)))`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:46:13
+  --> $DIR/unnecessary_lazy_eval.rs:47:13
    |
 LL |     let _ = Some(10).unwrap_or_else(|| 2);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `unwrap_or` instead: `Some(10).unwrap_or(2)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:47:13
+  --> $DIR/unnecessary_lazy_eval.rs:48:13
    |
 LL |     let _ = Some(10).and_then(|_| ext_opt);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `and` instead: `Some(10).and(ext_opt)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:48:28
+  --> $DIR/unnecessary_lazy_eval.rs:49:28
    |
 LL |     let _: Option<usize> = None.or_else(|| ext_opt);
    |                            ^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `or` instead: `None.or(ext_opt)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:49:13
+  --> $DIR/unnecessary_lazy_eval.rs:50:13
    |
 LL |     let _ = None.get_or_insert_with(|| 2);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `get_or_insert` instead: `None.get_or_insert(2)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:50:35
+  --> $DIR/unnecessary_lazy_eval.rs:51:35
    |
 LL |     let _: Result<usize, usize> = None.ok_or_else(|| 2);
    |                                   ^^^^^^^^^^^^^^^^^^^^^ help: Use `ok_or` instead: `None.ok_or(2)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:51:28
+  --> $DIR/unnecessary_lazy_eval.rs:52:28
    |
 LL |     let _: Option<usize> = None.or_else(|| None);
    |                            ^^^^^^^^^^^^^^^^^^^^^ help: Use `or` instead: `None.or(None)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:54:13
+  --> $DIR/unnecessary_lazy_eval.rs:55:13
    |
 LL |     let _ = deep.0.unwrap_or_else(|| 2);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `unwrap_or` instead: `deep.0.unwrap_or(2)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:55:13
+  --> $DIR/unnecessary_lazy_eval.rs:56:13
    |
 LL |     let _ = deep.0.and_then(|_| ext_opt);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `and` instead: `deep.0.and(ext_opt)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:56:13
+  --> $DIR/unnecessary_lazy_eval.rs:57:13
    |
 LL |     let _ = deep.0.or_else(|| None);
    |             ^^^^^^^^^^^^^^^^^^^^^^^ help: Use `or` instead: `deep.0.or(None)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:57:13
+  --> $DIR/unnecessary_lazy_eval.rs:58:13
    |
 LL |     let _ = deep.0.get_or_insert_with(|| 2);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `get_or_insert` instead: `deep.0.get_or_insert(2)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:58:13
+  --> $DIR/unnecessary_lazy_eval.rs:59:13
    |
 LL |     let _ = deep.0.ok_or_else(|| 2);
    |             ^^^^^^^^^^^^^^^^^^^^^^^ help: Use `ok_or` instead: `deep.0.ok_or(2)`
 
+error: unnecessary closure used to substitute value for `Option::None`
+  --> $DIR/unnecessary_lazy_eval.rs:79:28
+   |
+LL |     let _: Option<usize> = None.or_else(|| Some(3));
+   |                            ^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `or` instead: `None.or(Some(3))`
+
+error: unnecessary closure used to substitute value for `Option::None`
+  --> $DIR/unnecessary_lazy_eval.rs:80:13
+   |
+LL |     let _ = deep.0.or_else(|| Some(3));
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `or` instead: `deep.0.or(Some(3))`
+
+error: unnecessary closure used to substitute value for `Option::None`
+  --> $DIR/unnecessary_lazy_eval.rs:81:13
+   |
+LL |     let _ = opt.or_else(|| Some(3));
+   |             ^^^^^^^^^^^^^^^^^^^^^^^ help: Use `or` instead: `opt.or(Some(3))`
+
 error: unnecessary closure used to substitute value for `Result::Err`
-  --> $DIR/unnecessary_lazy_eval.rs:84:13
+  --> $DIR/unnecessary_lazy_eval.rs:87:13
    |
 LL |     let _ = res2.unwrap_or_else(|_| 2);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `unwrap_or` instead: `res2.unwrap_or(2)`
 
 error: unnecessary closure used to substitute value for `Result::Err`
-  --> $DIR/unnecessary_lazy_eval.rs:85:13
+  --> $DIR/unnecessary_lazy_eval.rs:88:13
    |
 LL |     let _ = res2.unwrap_or_else(|_| astronomers_pi);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `unwrap_or` instead: `res2.unwrap_or(astronomers_pi)`
 
 error: unnecessary closure used to substitute value for `Result::Err`
-  --> $DIR/unnecessary_lazy_eval.rs:86:13
+  --> $DIR/unnecessary_lazy_eval.rs:89:13
    |
 LL |     let _ = res2.unwrap_or_else(|_| ext_str.some_field);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `unwrap_or` instead: `res2.unwrap_or(ext_str.some_field)`
 
-error: aborting due to 24 previous errors
+error: unnecessary closure used to substitute value for `Result::Err`
+  --> $DIR/unnecessary_lazy_eval.rs:114:35
+   |
+LL |     let _: Result<usize, usize> = res.and_then(|_| Err(2));
+   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `and` instead: `res.and(Err(2))`
+
+error: unnecessary closure used to substitute value for `Result::Err`
+  --> $DIR/unnecessary_lazy_eval.rs:115:35
+   |
+LL |     let _: Result<usize, usize> = res.and_then(|_| Err(astronomers_pi));
+   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `and` instead: `res.and(Err(astronomers_pi))`
+
+error: unnecessary closure used to substitute value for `Result::Err`
+  --> $DIR/unnecessary_lazy_eval.rs:116:35
+   |
+LL |     let _: Result<usize, usize> = res.and_then(|_| Err(ext_str.some_field));
+   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `and` instead: `res.and(Err(ext_str.some_field))`
+
+error: unnecessary closure used to substitute value for `Result::Err`
+  --> $DIR/unnecessary_lazy_eval.rs:118:35
+   |
+LL |     let _: Result<usize, usize> = res.or_else(|_| Ok(2));
+   |                                   ^^^^^^^^^^^^^^^^^^^^^^ help: Use `or` instead: `res.or(Ok(2))`
+
+error: unnecessary closure used to substitute value for `Result::Err`
+  --> $DIR/unnecessary_lazy_eval.rs:119:35
+   |
+LL |     let _: Result<usize, usize> = res.or_else(|_| Ok(astronomers_pi));
+   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `or` instead: `res.or(Ok(astronomers_pi))`
+
+error: unnecessary closure used to substitute value for `Result::Err`
+  --> $DIR/unnecessary_lazy_eval.rs:120:35
+   |
+LL |     let _: Result<usize, usize> = res.or_else(|_| Ok(ext_str.some_field));
+   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `or` instead: `res.or(Ok(ext_str.some_field))`
+
+error: aborting due to 32 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 0261e341fd435f0b42954510fb436cb0b289cdac Mon Sep 17 00:00:00 2001
From: Andy Russell <arussell123@gmail.com>
Date: Mon, 14 Sep 2020 14:58:39 -0400
Subject: {print,write}-with-newline: do not suggest empty format string

---
 clippy_lints/src/write.rs          |  6 +++++-
 tests/ui/print_with_newline.rs     |  1 +
 tests/ui/print_with_newline.stderr | 23 +++++++++++++++++------
 tests/ui/write_with_newline.rs     |  1 +
 tests/ui/write_with_newline.stderr | 23 +++++++++++++++++------
 5 files changed, 41 insertions(+), 13 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs
index e653240d049..fac63bcb993 100644
--- a/clippy_lints/src/write.rs
+++ b/clippy_lints/src/write.rs
@@ -322,11 +322,15 @@ impl EarlyLintPass for Write {
 }
 
 /// Given a format string that ends in a newline and its span, calculates the span of the
-/// newline.
+/// newline, or the format string itself if the format string consists solely of a newline.
 fn newline_span(fmtstr: &StrLit) -> Span {
     let sp = fmtstr.span;
     let contents = &fmtstr.symbol.as_str();
 
+    if *contents == r"\n" {
+        return sp;
+    }
+
     let newline_sp_hi = sp.hi()
         - match fmtstr.style {
             StrStyle::Cooked => BytePos(1),
diff --git a/tests/ui/print_with_newline.rs b/tests/ui/print_with_newline.rs
index 3f710540e90..a43a1fc4f52 100644
--- a/tests/ui/print_with_newline.rs
+++ b/tests/ui/print_with_newline.rs
@@ -9,6 +9,7 @@ fn main() {
     print!("Hello {}\n", "world");
     print!("Hello {} {}\n", "world", "#2");
     print!("{}\n", 1265);
+    print!("\n");
 
     // these are all fine
     print!("");
diff --git a/tests/ui/print_with_newline.stderr b/tests/ui/print_with_newline.stderr
index 05fe88915d6..54b3ad75b31 100644
--- a/tests/ui/print_with_newline.stderr
+++ b/tests/ui/print_with_newline.stderr
@@ -44,7 +44,18 @@ LL |     println!("{}", 1265);
    |     ^^^^^^^    --
 
 error: using `print!()` with a format string that ends in a single newline
-  --> $DIR/print_with_newline.rs:30:5
+  --> $DIR/print_with_newline.rs:12:5
+   |
+LL |     print!("/n");
+   |     ^^^^^^^^^^^^
+   |
+help: use `println!` instead
+   |
+LL |     println!();
+   |     ^^^^^^^ --
+
+error: using `print!()` with a format string that ends in a single newline
+  --> $DIR/print_with_newline.rs:31:5
    |
 LL |     print!("//n"); // should fail
    |     ^^^^^^^^^^^^^^
@@ -55,7 +66,7 @@ LL |     println!("/"); // should fail
    |     ^^^^^^^    --
 
 error: using `print!()` with a format string that ends in a single newline
-  --> $DIR/print_with_newline.rs:37:5
+  --> $DIR/print_with_newline.rs:38:5
    |
 LL | /     print!(
 LL | |         "
@@ -70,7 +81,7 @@ LL |         ""
    |
 
 error: using `print!()` with a format string that ends in a single newline
-  --> $DIR/print_with_newline.rs:41:5
+  --> $DIR/print_with_newline.rs:42:5
    |
 LL | /     print!(
 LL | |         r"
@@ -85,7 +96,7 @@ LL |         r""
    |
 
 error: using `print!()` with a format string that ends in a single newline
-  --> $DIR/print_with_newline.rs:49:5
+  --> $DIR/print_with_newline.rs:50:5
    |
 LL |     print!("/r/n"); //~ ERROR
    |     ^^^^^^^^^^^^^^^
@@ -96,7 +107,7 @@ LL |     println!("/r"); //~ ERROR
    |     ^^^^^^^     --
 
 error: using `print!()` with a format string that ends in a single newline
-  --> $DIR/print_with_newline.rs:50:5
+  --> $DIR/print_with_newline.rs:51:5
    |
 LL |     print!("foo/rbar/n") // ~ ERROR
    |     ^^^^^^^^^^^^^^^^^^^^
@@ -106,5 +117,5 @@ help: use `println!` instead
 LL |     println!("foo/rbar") // ~ ERROR
    |     ^^^^^^^          --
 
-error: aborting due to 9 previous errors
+error: aborting due to 10 previous errors
 
diff --git a/tests/ui/write_with_newline.rs b/tests/ui/write_with_newline.rs
index 93afd73d111..1c1b1b58402 100644
--- a/tests/ui/write_with_newline.rs
+++ b/tests/ui/write_with_newline.rs
@@ -14,6 +14,7 @@ fn main() {
     write!(&mut v, "Hello {}\n", "world");
     write!(&mut v, "Hello {} {}\n", "world", "#2");
     write!(&mut v, "{}\n", 1265);
+    write!(&mut v, "\n");
 
     // These should be fine
     write!(&mut v, "");
diff --git a/tests/ui/write_with_newline.stderr b/tests/ui/write_with_newline.stderr
index 2473329ca72..a14e86122ee 100644
--- a/tests/ui/write_with_newline.stderr
+++ b/tests/ui/write_with_newline.stderr
@@ -44,7 +44,18 @@ LL |     writeln!(&mut v, "{}", 1265);
    |     ^^^^^^^            --
 
 error: using `write!()` with a format string that ends in a single newline
-  --> $DIR/write_with_newline.rs:35:5
+  --> $DIR/write_with_newline.rs:17:5
+   |
+LL |     write!(&mut v, "/n");
+   |     ^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `writeln!()` instead
+   |
+LL |     writeln!(&mut v, );
+   |     ^^^^^^^         --
+
+error: using `write!()` with a format string that ends in a single newline
+  --> $DIR/write_with_newline.rs:36:5
    |
 LL |     write!(&mut v, "//n"); // should fail
    |     ^^^^^^^^^^^^^^^^^^^^^^
@@ -55,7 +66,7 @@ LL |     writeln!(&mut v, "/"); // should fail
    |     ^^^^^^^            --
 
 error: using `write!()` with a format string that ends in a single newline
-  --> $DIR/write_with_newline.rs:42:5
+  --> $DIR/write_with_newline.rs:43:5
    |
 LL | /     write!(
 LL | |         &mut v,
@@ -72,7 +83,7 @@ LL |         ""
    |
 
 error: using `write!()` with a format string that ends in a single newline
-  --> $DIR/write_with_newline.rs:47:5
+  --> $DIR/write_with_newline.rs:48:5
    |
 LL | /     write!(
 LL | |         &mut v,
@@ -89,7 +100,7 @@ LL |         r""
    |
 
 error: using `write!()` with a format string that ends in a single newline
-  --> $DIR/write_with_newline.rs:56:5
+  --> $DIR/write_with_newline.rs:57:5
    |
 LL |     write!(&mut v, "/r/n"); //~ ERROR
    |     ^^^^^^^^^^^^^^^^^^^^^^^
@@ -100,7 +111,7 @@ LL |     writeln!(&mut v, "/r"); //~ ERROR
    |     ^^^^^^^             --
 
 error: using `write!()` with a format string that ends in a single newline
-  --> $DIR/write_with_newline.rs:57:5
+  --> $DIR/write_with_newline.rs:58:5
    |
 LL |     write!(&mut v, "foo/rbar/n");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -110,5 +121,5 @@ help: use `writeln!()` instead
 LL |     writeln!(&mut v, "foo/rbar");
    |     ^^^^^^^                  --
 
-error: aborting due to 9 previous errors
+error: aborting due to 10 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 2ce2d6b40e85bf543b3a9e38cd08c7065b357807 Mon Sep 17 00:00:00 2001
From: rail <12975677+rail-rain@users.noreply.github.com>
Date: Fri, 11 Sep 2020 14:41:54 +1200
Subject: fix a FP in `indexing_slicing`

treat refs to arrays the same as arrays
in `indexing_slicing` and `out_of_bounds_indexing`
---
 clippy_lints/src/indexing_slicing.rs   |  2 +-
 tests/ui/indexing_slicing_index.rs     |  3 ++-
 tests/ui/indexing_slicing_index.stderr | 20 ++++++--------------
 tests/ui/indexing_slicing_slice.stderr | 26 +++++++-------------------
 4 files changed, 16 insertions(+), 35 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/indexing_slicing.rs b/clippy_lints/src/indexing_slicing.rs
index a28eda8be15..741195f3b10 100644
--- a/clippy_lints/src/indexing_slicing.rs
+++ b/clippy_lints/src/indexing_slicing.rs
@@ -88,7 +88,7 @@ declare_lint_pass!(IndexingSlicing => [INDEXING_SLICING, OUT_OF_BOUNDS_INDEXING]
 impl<'tcx> LateLintPass<'tcx> for IndexingSlicing {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if let ExprKind::Index(ref array, ref index) = &expr.kind {
-            let ty = cx.typeck_results().expr_ty(array);
+            let ty = cx.typeck_results().expr_ty(array).peel_refs();
             if let Some(range) = higher::range(index) {
                 // Ranged indexes, i.e., &x[n..m], &x[n..], &x[..n] and &x[..]
                 if let ty::Array(_, s) = ty.kind() {
diff --git a/tests/ui/indexing_slicing_index.rs b/tests/ui/indexing_slicing_index.rs
index 000d5269930..ca8ca53c80c 100644
--- a/tests/ui/indexing_slicing_index.rs
+++ b/tests/ui/indexing_slicing_index.rs
@@ -15,7 +15,8 @@ fn main() {
     x[3]; // Ok, should not produce stderr.
 
     let y = &x;
-    y[0];
+    y[0]; // Ok, referencing shouldn't affect this lint. See the issue 6021
+    y[4]; // Ok, rustc will handle references too.
 
     let v = vec![0; 5];
     v[0];
diff --git a/tests/ui/indexing_slicing_index.stderr b/tests/ui/indexing_slicing_index.stderr
index 2b3f9be2dfb..2f6c9e2f4e5 100644
--- a/tests/ui/indexing_slicing_index.stderr
+++ b/tests/ui/indexing_slicing_index.stderr
@@ -8,15 +8,7 @@ LL |     x[index];
    = help: Consider using `.get(n)` or `.get_mut(n)` instead
 
 error: indexing may panic.
-  --> $DIR/indexing_slicing_index.rs:18:5
-   |
-LL |     y[0];
-   |     ^^^^
-   |
-   = help: Consider using `.get(n)` or `.get_mut(n)` instead
-
-error: indexing may panic.
-  --> $DIR/indexing_slicing_index.rs:21:5
+  --> $DIR/indexing_slicing_index.rs:22:5
    |
 LL |     v[0];
    |     ^^^^
@@ -24,7 +16,7 @@ LL |     v[0];
    = help: Consider using `.get(n)` or `.get_mut(n)` instead
 
 error: indexing may panic.
-  --> $DIR/indexing_slicing_index.rs:22:5
+  --> $DIR/indexing_slicing_index.rs:23:5
    |
 LL |     v[10];
    |     ^^^^^
@@ -32,7 +24,7 @@ LL |     v[10];
    = help: Consider using `.get(n)` or `.get_mut(n)` instead
 
 error: indexing may panic.
-  --> $DIR/indexing_slicing_index.rs:23:5
+  --> $DIR/indexing_slicing_index.rs:24:5
    |
 LL |     v[1 << 3];
    |     ^^^^^^^^^
@@ -40,7 +32,7 @@ LL |     v[1 << 3];
    = help: Consider using `.get(n)` or `.get_mut(n)` instead
 
 error: indexing may panic.
-  --> $DIR/indexing_slicing_index.rs:29:5
+  --> $DIR/indexing_slicing_index.rs:30:5
    |
 LL |     v[N];
    |     ^^^^
@@ -48,12 +40,12 @@ LL |     v[N];
    = help: Consider using `.get(n)` or `.get_mut(n)` instead
 
 error: indexing may panic.
-  --> $DIR/indexing_slicing_index.rs:30:5
+  --> $DIR/indexing_slicing_index.rs:31:5
    |
 LL |     v[M];
    |     ^^^^
    |
    = help: Consider using `.get(n)` or `.get_mut(n)` instead
 
-error: aborting due to 7 previous errors
+error: aborting due to 6 previous errors
 
diff --git a/tests/ui/indexing_slicing_slice.stderr b/tests/ui/indexing_slicing_slice.stderr
index ec6c157ac1a..2231deee833 100644
--- a/tests/ui/indexing_slicing_slice.stderr
+++ b/tests/ui/indexing_slicing_slice.stderr
@@ -71,29 +71,17 @@ LL |     &x[1..][..5];
    |
    = help: Consider using `.get(..n)`or `.get_mut(..n)` instead
 
-error: slicing may panic.
-  --> $DIR/indexing_slicing_slice.rs:24:6
-   |
-LL |     &y[1..2];
-   |      ^^^^^^^
-   |
-   = help: Consider using `.get(n..m)` or `.get_mut(n..m)` instead
-
-error: slicing may panic.
-  --> $DIR/indexing_slicing_slice.rs:25:6
+error: range is out of bounds
+  --> $DIR/indexing_slicing_slice.rs:25:12
    |
 LL |     &y[0..=4];
-   |      ^^^^^^^^
-   |
-   = help: Consider using `.get(n..m)` or `.get_mut(n..m)` instead
+   |            ^
 
-error: slicing may panic.
-  --> $DIR/indexing_slicing_slice.rs:26:6
+error: range is out of bounds
+  --> $DIR/indexing_slicing_slice.rs:26:11
    |
 LL |     &y[..=4];
-   |      ^^^^^^^
-   |
-   = help: Consider using `.get(..n)`or `.get_mut(..n)` instead
+   |           ^
 
 error: slicing may panic.
   --> $DIR/indexing_slicing_slice.rs:31:6
@@ -133,5 +121,5 @@ LL |     &v[..100];
    |
    = help: Consider using `.get(..n)`or `.get_mut(..n)` instead
 
-error: aborting due to 17 previous errors
+error: aborting due to 16 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From ce064722469672a504d8a1720ab4d2f681c21610 Mon Sep 17 00:00:00 2001
From: rail <12975677+rail-rain@users.noreply.github.com>
Date: Fri, 11 Sep 2020 15:06:49 +1200
Subject: replace `walk_ptrs_ty` with `peel_refs`

---
 clippy_lints/src/bytecount.rs               |  7 +++----
 clippy_lints/src/duration_subsec.rs         |  4 ++--
 clippy_lints/src/entry.rs                   |  4 ++--
 clippy_lints/src/fallible_impl_from.rs      |  6 ++----
 clippy_lints/src/format.rs                  |  4 ++--
 clippy_lints/src/inherent_to_string.rs      |  4 ++--
 clippy_lints/src/len_zero.rs                |  4 ++--
 clippy_lints/src/match_on_vec_items.rs      |  5 ++---
 clippy_lints/src/matches.rs                 |  4 ++--
 clippy_lints/src/methods/mod.rs             | 22 +++++++++++-----------
 clippy_lints/src/misc.rs                    |  6 +++---
 clippy_lints/src/mut_key.rs                 |  4 ++--
 clippy_lints/src/open_options.rs            |  6 +++---
 clippy_lints/src/path_buf_push_overwrite.rs |  4 ++--
 clippy_lints/src/repeat_once.rs             |  4 ++--
 clippy_lints/src/strings.rs                 |  4 ++--
 clippy_lints/src/swap.rs                    |  3 +--
 clippy_lints/src/unwrap_in_result.rs        |  6 +++---
 clippy_lints/src/utils/internal_lints.rs    |  6 +++---
 clippy_lints/src/utils/mod.rs               |  8 --------
 20 files changed, 51 insertions(+), 64 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/bytecount.rs b/clippy_lints/src/bytecount.rs
index 189c07427ae..d7d02ebf985 100644
--- a/clippy_lints/src/bytecount.rs
+++ b/clippy_lints/src/bytecount.rs
@@ -1,6 +1,5 @@
 use crate::utils::{
-    contains_name, get_pat_name, match_type, paths, single_segment_path, snippet_with_applicability,
-    span_lint_and_sugg, walk_ptrs_ty,
+    contains_name, get_pat_name, match_type, paths, single_segment_path, snippet_with_applicability, span_lint_and_sugg,
 };
 use if_chain::if_chain;
 use rustc_ast::ast::UintTy;
@@ -53,7 +52,7 @@ impl<'tcx> LateLintPass<'tcx> for ByteCount {
                     if let ExprKind::Binary(ref op, ref l, ref r) = body.value.kind;
                     if op.node == BinOpKind::Eq;
                     if match_type(cx,
-                               walk_ptrs_ty(cx.typeck_results().expr_ty(&filter_args[0])),
+                               cx.typeck_results().expr_ty(&filter_args[0]).peel_refs(),
                                &paths::SLICE_ITER);
                     then {
                         let needle = match get_path_name(l) {
@@ -63,7 +62,7 @@ impl<'tcx> LateLintPass<'tcx> for ByteCount {
                                 _ => { return; }
                             }
                         };
-                        if ty::Uint(UintTy::U8) != *walk_ptrs_ty(cx.typeck_results().expr_ty(needle)).kind() {
+                        if ty::Uint(UintTy::U8) != *cx.typeck_results().expr_ty(needle).peel_refs().kind() {
                             return;
                         }
                         let haystack = if let ExprKind::MethodCall(ref path, _, ref args, _) =
diff --git a/clippy_lints/src/duration_subsec.rs b/clippy_lints/src/duration_subsec.rs
index 8ece44878fe..c0529a34cc4 100644
--- a/clippy_lints/src/duration_subsec.rs
+++ b/clippy_lints/src/duration_subsec.rs
@@ -7,7 +7,7 @@ use rustc_span::source_map::Spanned;
 
 use crate::consts::{constant, Constant};
 use crate::utils::paths;
-use crate::utils::{match_type, snippet_with_applicability, span_lint_and_sugg, walk_ptrs_ty};
+use crate::utils::{match_type, snippet_with_applicability, span_lint_and_sugg};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for calculation of subsecond microseconds or milliseconds
@@ -43,7 +43,7 @@ impl<'tcx> LateLintPass<'tcx> for DurationSubsec {
         if_chain! {
             if let ExprKind::Binary(Spanned { node: BinOpKind::Div, .. }, ref left, ref right) = expr.kind;
             if let ExprKind::MethodCall(ref method_path, _ , ref args, _) = left.kind;
-            if match_type(cx, walk_ptrs_ty(cx.typeck_results().expr_ty(&args[0])), &paths::DURATION);
+            if match_type(cx, cx.typeck_results().expr_ty(&args[0]).peel_refs(), &paths::DURATION);
             if let Some((Constant::Int(divisor), _)) = constant(cx, cx.typeck_results(), right);
             then {
                 let suggested_fn = match (method_path.ident.as_str().as_ref(), divisor) {
diff --git a/clippy_lints/src/entry.rs b/clippy_lints/src/entry.rs
index d616502a82a..35a5d00f4aa 100644
--- a/clippy_lints/src/entry.rs
+++ b/clippy_lints/src/entry.rs
@@ -1,6 +1,6 @@
 use crate::utils::SpanlessEq;
 use crate::utils::{get_item_name, higher, is_type_diagnostic_item, match_type, paths, snippet, snippet_opt};
-use crate::utils::{snippet_with_applicability, span_lint_and_then, walk_ptrs_ty};
+use crate::utils::{snippet_with_applicability, span_lint_and_then};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
@@ -106,7 +106,7 @@ fn check_cond<'a>(cx: &LateContext<'_>, check: &'a Expr<'a>) -> Option<(&'static
         if let ExprKind::AddrOf(BorrowKind::Ref, _, ref key) = params[1].kind;
         then {
             let map = &params[0];
-            let obj_ty = walk_ptrs_ty(cx.typeck_results().expr_ty(map));
+            let obj_ty = cx.typeck_results().expr_ty(map).peel_refs();
 
             return if match_type(cx, obj_ty, &paths::BTREEMAP) {
                 Some(("BTreeMap", map, key))
diff --git a/clippy_lints/src/fallible_impl_from.rs b/clippy_lints/src/fallible_impl_from.rs
index 000762334f6..a9e05fddbe7 100644
--- a/clippy_lints/src/fallible_impl_from.rs
+++ b/clippy_lints/src/fallible_impl_from.rs
@@ -1,7 +1,5 @@
 use crate::utils::paths::{BEGIN_PANIC, BEGIN_PANIC_FMT, FROM_TRAIT};
-use crate::utils::{
-    is_expn_of, is_type_diagnostic_item, match_def_path, method_chain_args, span_lint_and_then, walk_ptrs_ty,
-};
+use crate::utils::{is_expn_of, is_type_diagnostic_item, match_def_path, method_chain_args, span_lint_and_then};
 use if_chain::if_chain;
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass};
@@ -96,7 +94,7 @@ fn lint_impl_body<'tcx>(cx: &LateContext<'tcx>, impl_span: Span, impl_items: &[h
 
             // check for `unwrap`
             if let Some(arglists) = method_chain_args(expr, &["unwrap"]) {
-                let reciever_ty = walk_ptrs_ty(self.typeck_results.expr_ty(&arglists[0][0]));
+                let reciever_ty = self.typeck_results.expr_ty(&arglists[0][0]).peel_refs();
                 if is_type_diagnostic_item(self.lcx, reciever_ty, sym!(option_type))
                     || is_type_diagnostic_item(self.lcx, reciever_ty, sym!(result_type))
                 {
diff --git a/clippy_lints/src/format.rs b/clippy_lints/src/format.rs
index 8bd85af8768..d6541010bca 100644
--- a/clippy_lints/src/format.rs
+++ b/clippy_lints/src/format.rs
@@ -1,7 +1,7 @@
 use crate::utils::paths;
 use crate::utils::{
     is_expn_of, is_type_diagnostic_item, last_path_segment, match_def_path, match_function_call, snippet,
-    span_lint_and_then, walk_ptrs_ty,
+    span_lint_and_then,
 };
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
@@ -90,7 +90,7 @@ fn on_argumentv1_new<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, arms: &
         if let PatKind::Tuple(ref pats, None) = arms[0].pat.kind;
         if pats.len() == 1;
         then {
-            let ty = walk_ptrs_ty(cx.typeck_results().pat_ty(&pats[0]));
+            let ty = cx.typeck_results().pat_ty(&pats[0]).peel_refs();
             if *ty.kind() != rustc_middle::ty::Str && !is_type_diagnostic_item(cx, ty, sym!(string_type)) {
                 return None;
             }
diff --git a/clippy_lints/src/inherent_to_string.rs b/clippy_lints/src/inherent_to_string.rs
index f330fa8fab8..0877b44d901 100644
--- a/clippy_lints/src/inherent_to_string.rs
+++ b/clippy_lints/src/inherent_to_string.rs
@@ -5,7 +5,7 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 use crate::utils::{
     get_trait_def_id, implements_trait, is_type_diagnostic_item, paths, return_ty, span_lint_and_help,
-    trait_ref_of_method, walk_ptrs_ty,
+    trait_ref_of_method,
 };
 
 declare_clippy_lint! {
@@ -125,7 +125,7 @@ fn show_lint(cx: &LateContext<'_>, item: &ImplItem<'_>) {
     // Get the real type of 'self'
     let fn_def_id = cx.tcx.hir().local_def_id(item.hir_id);
     let self_type = cx.tcx.fn_sig(fn_def_id).input(0);
-    let self_type = walk_ptrs_ty(self_type.skip_binder());
+    let self_type = self_type.skip_binder().peel_refs();
 
     // Emit either a warning or an error
     if implements_trait(cx, self_type, display_trait_id, &[]) {
diff --git a/clippy_lints/src/len_zero.rs b/clippy_lints/src/len_zero.rs
index 42a98dc963d..c9c4891bb08 100644
--- a/clippy_lints/src/len_zero.rs
+++ b/clippy_lints/src/len_zero.rs
@@ -1,4 +1,4 @@
-use crate::utils::{get_item_name, snippet_with_applicability, span_lint, span_lint_and_sugg, walk_ptrs_ty};
+use crate::utils::{get_item_name, snippet_with_applicability, span_lint, span_lint_and_sugg};
 use rustc_ast::ast::LitKind;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Applicability;
@@ -285,7 +285,7 @@ fn has_is_empty(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
         })
     }
 
-    let ty = &walk_ptrs_ty(cx.typeck_results().expr_ty(expr));
+    let ty = &cx.typeck_results().expr_ty(expr).peel_refs();
     match ty.kind() {
         ty::Dynamic(ref tt, ..) => tt.principal().map_or(false, |principal| {
             cx.tcx
diff --git a/clippy_lints/src/match_on_vec_items.rs b/clippy_lints/src/match_on_vec_items.rs
index 57966452253..331b6c6c34a 100644
--- a/clippy_lints/src/match_on_vec_items.rs
+++ b/clippy_lints/src/match_on_vec_items.rs
@@ -1,4 +1,3 @@
-use crate::utils::walk_ptrs_ty;
 use crate::utils::{is_type_diagnostic_item, is_type_lang_item, snippet, span_lint_and_sugg};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
@@ -90,12 +89,12 @@ fn is_vec_indexing<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> Opti
 
 fn is_vector(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
     let ty = cx.typeck_results().expr_ty(expr);
-    let ty = walk_ptrs_ty(ty);
+    let ty = ty.peel_refs();
     is_type_diagnostic_item(cx, ty, sym!(vec_type))
 }
 
 fn is_full_range(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
     let ty = cx.typeck_results().expr_ty(expr);
-    let ty = walk_ptrs_ty(ty);
+    let ty = ty.peel_refs();
     is_type_lang_item(cx, ty, LangItem::RangeFull)
 }
diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index 7ba7397c29c..11380f83316 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -6,7 +6,7 @@ use crate::utils::{
     expr_block, get_arg_name, get_parent_expr, in_macro, indent_of, is_allowed, is_expn_of, is_refutable,
     is_type_diagnostic_item, is_wild, match_qpath, match_type, match_var, multispan_sugg, remove_blocks, snippet,
     snippet_block, snippet_with_applicability, span_lint_and_help, span_lint_and_note, span_lint_and_sugg,
-    span_lint_and_then, walk_ptrs_ty,
+    span_lint_and_then,
 };
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
@@ -794,7 +794,7 @@ fn check_overlapping_arms<'tcx>(cx: &LateContext<'tcx>, ex: &'tcx Expr<'_>, arms
 }
 
 fn check_wild_err_arm(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>]) {
-    let ex_ty = walk_ptrs_ty(cx.typeck_results().expr_ty(ex));
+    let ex_ty = cx.typeck_results().expr_ty(ex).peel_refs();
     if is_type_diagnostic_item(cx, ex_ty, sym!(result_type)) {
         for arm in arms {
             if let PatKind::TupleStruct(ref path, ref inner, _) = arm.pat.kind {
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 184aee95efa..dadd0f8ebb7 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -32,8 +32,8 @@ use crate::utils::{
     is_copy, is_expn_of, is_type_diagnostic_item, iter_input_pats, last_path_segment, match_def_path, match_qpath,
     match_trait_method, match_type, match_var, method_calls, method_chain_args, paths, remove_blocks, return_ty,
     single_segment_path, snippet, snippet_with_applicability, snippet_with_macro_callsite, span_lint,
-    span_lint_and_help, span_lint_and_note, span_lint_and_sugg, span_lint_and_then, sugg, walk_ptrs_ty,
-    walk_ptrs_ty_depth, SpanlessEq,
+    span_lint_and_help, span_lint_and_note, span_lint_and_sugg, span_lint_and_then, sugg, walk_ptrs_ty_depth,
+    SpanlessEq,
 };
 
 declare_clippy_lint! {
@@ -1774,7 +1774,7 @@ fn lint_or_fun_call<'tcx>(
     ) {
         if let hir::ExprKind::MethodCall(ref path, _, ref args, _) = &arg.kind {
             if path.ident.as_str() == "len" {
-                let ty = walk_ptrs_ty(cx.typeck_results().expr_ty(&args[0]));
+                let ty = cx.typeck_results().expr_ty(&args[0]).peel_refs();
 
                 match ty.kind() {
                     ty::Slice(_) | ty::Array(_, _) => return,
@@ -1881,7 +1881,7 @@ fn lint_expect_fun_call(
                         && (method_name.ident.name == sym!(as_str) || method_name.ident.name == sym!(as_ref))
                         && {
                             let arg_type = cx.typeck_results().expr_ty(&call_args[0]);
-                            let base_type = walk_ptrs_ty(arg_type);
+                            let base_type = arg_type.peel_refs();
                             *base_type.kind() == ty::Str || is_type_diagnostic_item(cx, base_type, sym!(string_type))
                         }
                     {
@@ -2142,7 +2142,7 @@ fn lint_clone_on_copy(cx: &LateContext<'_>, expr: &hir::Expr<'_>, arg: &hir::Exp
 }
 
 fn lint_clone_on_ref_ptr(cx: &LateContext<'_>, expr: &hir::Expr<'_>, arg: &hir::Expr<'_>) {
-    let obj_ty = walk_ptrs_ty(cx.typeck_results().expr_ty(arg));
+    let obj_ty = cx.typeck_results().expr_ty(arg).peel_refs();
 
     if let ty::Adt(_, subst) = obj_ty.kind() {
         let caller_type = if is_type_diagnostic_item(cx, obj_ty, sym::Rc) {
@@ -2173,7 +2173,7 @@ fn lint_string_extend(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::E
     let arg = &args[1];
     if let Some(arglists) = method_chain_args(arg, &["chars"]) {
         let target = &arglists[0][0];
-        let self_ty = walk_ptrs_ty(cx.typeck_results().expr_ty(target));
+        let self_ty = cx.typeck_results().expr_ty(target).peel_refs();
         let ref_str = if *self_ty.kind() == ty::Str {
             ""
         } else if is_type_diagnostic_item(cx, self_ty, sym!(string_type)) {
@@ -2201,7 +2201,7 @@ fn lint_string_extend(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::E
 }
 
 fn lint_extend(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::Expr<'_>]) {
-    let obj_ty = walk_ptrs_ty(cx.typeck_results().expr_ty(&args[0]));
+    let obj_ty = cx.typeck_results().expr_ty(&args[0]).peel_refs();
     if is_type_diagnostic_item(cx, obj_ty, sym!(string_type)) {
         lint_string_extend(cx, expr, args);
     }
@@ -2384,7 +2384,7 @@ fn lint_iter_next<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, iter_
         }
     } else if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(caller_expr), sym!(vec_type))
         || matches!(
-            &walk_ptrs_ty(cx.typeck_results().expr_ty(caller_expr)).kind(),
+            &cx.typeck_results().expr_ty(caller_expr).peel_refs().kind(),
             ty::Array(_, _)
         )
     {
@@ -2587,7 +2587,7 @@ fn derefs_to_slice<'tcx>(
 
 /// lint use of `unwrap()` for `Option`s and `Result`s
 fn lint_unwrap(cx: &LateContext<'_>, expr: &hir::Expr<'_>, unwrap_args: &[hir::Expr<'_>]) {
-    let obj_ty = walk_ptrs_ty(cx.typeck_results().expr_ty(&unwrap_args[0]));
+    let obj_ty = cx.typeck_results().expr_ty(&unwrap_args[0]).peel_refs();
 
     let mess = if is_type_diagnostic_item(cx, obj_ty, sym!(option_type)) {
         Some((UNWRAP_USED, "an Option", "None"))
@@ -2615,7 +2615,7 @@ fn lint_unwrap(cx: &LateContext<'_>, expr: &hir::Expr<'_>, unwrap_args: &[hir::E
 
 /// lint use of `expect()` for `Option`s and `Result`s
 fn lint_expect(cx: &LateContext<'_>, expr: &hir::Expr<'_>, expect_args: &[hir::Expr<'_>]) {
-    let obj_ty = walk_ptrs_ty(cx.typeck_results().expr_ty(&expect_args[0]));
+    let obj_ty = cx.typeck_results().expr_ty(&expect_args[0]).peel_refs();
 
     let mess = if is_type_diagnostic_item(cx, obj_ty, sym!(option_type)) {
         Some((EXPECT_USED, "an Option", "None"))
@@ -3134,7 +3134,7 @@ fn lint_chars_cmp(
         if segment.ident.name == sym!(Some);
         then {
             let mut applicability = Applicability::MachineApplicable;
-            let self_ty = walk_ptrs_ty(cx.typeck_results().expr_ty_adjusted(&args[0][0]));
+            let self_ty = cx.typeck_results().expr_ty_adjusted(&args[0][0]).peel_refs();
 
             if *self_ty.kind() != ty::Str {
                 return false;
diff --git a/clippy_lints/src/misc.rs b/clippy_lints/src/misc.rs
index 67a3685fd0d..909e79f661a 100644
--- a/clippy_lints/src/misc.rs
+++ b/clippy_lints/src/misc.rs
@@ -17,7 +17,7 @@ use crate::utils::sugg::Sugg;
 use crate::utils::{
     get_item_name, get_parent_expr, higher, implements_trait, in_constant, is_integer_const, iter_input_pats,
     last_path_segment, match_qpath, match_trait_method, paths, snippet, snippet_opt, span_lint, span_lint_and_sugg,
-    span_lint_and_then, span_lint_hir_and_then, walk_ptrs_ty, SpanlessEq,
+    span_lint_and_then, span_lint_hir_and_then, SpanlessEq,
 };
 
 declare_clippy_lint! {
@@ -561,7 +561,7 @@ fn is_signum(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
 }
 
 fn is_float(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-    let value = &walk_ptrs_ty(cx.typeck_results().expr_ty(expr)).kind();
+    let value = &cx.typeck_results().expr_ty(expr).peel_refs().kind();
 
     if let ty::Array(arr_ty, _) = value {
         return matches!(arr_ty.kind(), ty::Float(_));
@@ -571,7 +571,7 @@ fn is_float(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
 }
 
 fn is_array(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-    matches!(&walk_ptrs_ty(cx.typeck_results().expr_ty(expr)).kind(), ty::Array(_, _))
+    matches!(&cx.typeck_results().expr_ty(expr).peel_refs().kind(), ty::Array(_, _))
 }
 
 fn check_to_owned(cx: &LateContext<'_>, expr: &Expr<'_>, other: &Expr<'_>, left: bool) {
diff --git a/clippy_lints/src/mut_key.rs b/clippy_lints/src/mut_key.rs
index 0826ad0ab55..8a2dbdc50ea 100644
--- a/clippy_lints/src/mut_key.rs
+++ b/clippy_lints/src/mut_key.rs
@@ -1,4 +1,4 @@
-use crate::utils::{match_def_path, paths, span_lint, trait_ref_of_method, walk_ptrs_ty};
+use crate::utils::{match_def_path, paths, span_lint, trait_ref_of_method};
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{Adt, Array, RawPtr, Ref, Slice, Tuple, Ty, TypeAndMut};
@@ -98,7 +98,7 @@ fn check_sig<'tcx>(cx: &LateContext<'tcx>, item_hir_id: hir::HirId, decl: &hir::
 // We want to lint 1. sets or maps with 2. not immutable key types and 3. no unerased
 // generics (because the compiler cannot ensure immutability for unknown types).
 fn check_ty<'tcx>(cx: &LateContext<'tcx>, span: Span, ty: Ty<'tcx>) {
-    let ty = walk_ptrs_ty(ty);
+    let ty = ty.peel_refs();
     if let Adt(def, substs) = ty.kind() {
         if [&paths::HASHMAP, &paths::BTREEMAP, &paths::HASHSET, &paths::BTREESET]
             .iter()
diff --git a/clippy_lints/src/open_options.rs b/clippy_lints/src/open_options.rs
index e99d0317ba2..73a99a3a2f8 100644
--- a/clippy_lints/src/open_options.rs
+++ b/clippy_lints/src/open_options.rs
@@ -1,4 +1,4 @@
-use crate::utils::{match_type, paths, span_lint, walk_ptrs_ty};
+use crate::utils::{match_type, paths, span_lint};
 use rustc_ast::ast::LitKind;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
@@ -30,7 +30,7 @@ declare_lint_pass!(OpenOptions => [NONSENSICAL_OPEN_OPTIONS]);
 impl<'tcx> LateLintPass<'tcx> for OpenOptions {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
         if let ExprKind::MethodCall(ref path, _, ref arguments, _) = e.kind {
-            let obj_ty = walk_ptrs_ty(cx.typeck_results().expr_ty(&arguments[0]));
+            let obj_ty = cx.typeck_results().expr_ty(&arguments[0]).peel_refs();
             if path.ident.name == sym!(open) && match_type(cx, obj_ty, &paths::OPEN_OPTIONS) {
                 let mut options = Vec::new();
                 get_open_options(cx, &arguments[0], &mut options);
@@ -58,7 +58,7 @@ enum OpenOption {
 
 fn get_open_options(cx: &LateContext<'_>, argument: &Expr<'_>, options: &mut Vec<(OpenOption, Argument)>) {
     if let ExprKind::MethodCall(ref path, _, ref arguments, _) = argument.kind {
-        let obj_ty = walk_ptrs_ty(cx.typeck_results().expr_ty(&arguments[0]));
+        let obj_ty = cx.typeck_results().expr_ty(&arguments[0]).peel_refs();
 
         // Only proceed if this is a call on some object of type std::fs::OpenOptions
         if match_type(cx, obj_ty, &paths::OPEN_OPTIONS) && arguments.len() >= 2 {
diff --git a/clippy_lints/src/path_buf_push_overwrite.rs b/clippy_lints/src/path_buf_push_overwrite.rs
index b8583402928..6eeb031d383 100644
--- a/clippy_lints/src/path_buf_push_overwrite.rs
+++ b/clippy_lints/src/path_buf_push_overwrite.rs
@@ -1,4 +1,4 @@
-use crate::utils::{match_type, paths, span_lint_and_sugg, walk_ptrs_ty};
+use crate::utils::{match_type, paths, span_lint_and_sugg};
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
@@ -46,7 +46,7 @@ impl<'tcx> LateLintPass<'tcx> for PathBufPushOverwrite {
             if let ExprKind::MethodCall(ref path, _, ref args, _) = expr.kind;
             if path.ident.name == sym!(push);
             if args.len() == 2;
-            if match_type(cx, walk_ptrs_ty(cx.typeck_results().expr_ty(&args[0])), &paths::PATH_BUF);
+            if match_type(cx, cx.typeck_results().expr_ty(&args[0]).peel_refs(), &paths::PATH_BUF);
             if let Some(get_index_arg) = args.get(1);
             if let ExprKind::Lit(ref lit) = get_index_arg.kind;
             if let LitKind::Str(ref path_lit, _) = lit.node;
diff --git a/clippy_lints/src/repeat_once.rs b/clippy_lints/src/repeat_once.rs
index c0890018d46..ae601353009 100644
--- a/clippy_lints/src/repeat_once.rs
+++ b/clippy_lints/src/repeat_once.rs
@@ -1,5 +1,5 @@
 use crate::consts::{constant_context, Constant};
-use crate::utils::{in_macro, is_type_diagnostic_item, snippet, span_lint_and_sugg, walk_ptrs_ty};
+use crate::utils::{in_macro, is_type_diagnostic_item, snippet, span_lint_and_sugg};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
@@ -44,7 +44,7 @@ impl<'tcx> LateLintPass<'tcx> for RepeatOnce {
             if let Some(Constant::Int(1)) = constant_context(cx, cx.typeck_results()).expr(&count);
             if !in_macro(receiver.span);
             then {
-                let ty = walk_ptrs_ty(cx.typeck_results().expr_ty(&receiver));
+                let ty = cx.typeck_results().expr_ty(&receiver).peel_refs();
                 if ty.is_str() {
                     span_lint_and_sugg(
                         cx,
diff --git a/clippy_lints/src/strings.rs b/clippy_lints/src/strings.rs
index 7a659bf779c..15b66684eab 100644
--- a/clippy_lints/src/strings.rs
+++ b/clippy_lints/src/strings.rs
@@ -8,7 +8,7 @@ use rustc_span::source_map::Spanned;
 use if_chain::if_chain;
 
 use crate::utils::SpanlessEq;
-use crate::utils::{get_parent_expr, is_allowed, is_type_diagnostic_item, span_lint, span_lint_and_sugg, walk_ptrs_ty};
+use crate::utils::{get_parent_expr, is_allowed, is_type_diagnostic_item, span_lint, span_lint_and_sugg};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for string appends of the form `x = x + y` (without
@@ -134,7 +134,7 @@ impl<'tcx> LateLintPass<'tcx> for StringAdd {
 }
 
 fn is_string(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
-    is_type_diagnostic_item(cx, walk_ptrs_ty(cx.typeck_results().expr_ty(e)), sym!(string_type))
+    is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(e).peel_refs(), sym!(string_type))
 }
 
 fn is_add(cx: &LateContext<'_>, src: &Expr<'_>, target: &Expr<'_>) -> bool {
diff --git a/clippy_lints/src/swap.rs b/clippy_lints/src/swap.rs
index 47a73ca9a24..54b38d9f4ce 100644
--- a/clippy_lints/src/swap.rs
+++ b/clippy_lints/src/swap.rs
@@ -1,7 +1,6 @@
 use crate::utils::sugg::Sugg;
 use crate::utils::{
     differing_macro_contexts, eq_expr_value, is_type_diagnostic_item, snippet_with_applicability, span_lint_and_then,
-    walk_ptrs_ty,
 };
 use if_chain::if_chain;
 use rustc_errors::Applicability;
@@ -194,7 +193,7 @@ fn check_for_slice<'a>(cx: &LateContext<'_>, lhs1: &'a Expr<'_>, lhs2: &'a Expr<
     if let ExprKind::Index(ref lhs1, ref idx1) = lhs1.kind {
         if let ExprKind::Index(ref lhs2, ref idx2) = lhs2.kind {
             if eq_expr_value(cx, lhs1, lhs2) {
-                let ty = walk_ptrs_ty(cx.typeck_results().expr_ty(lhs1));
+                let ty = cx.typeck_results().expr_ty(lhs1).peel_refs();
 
                 if matches!(ty.kind(), ty::Slice(_))
                     || matches!(ty.kind(), ty::Array(_, _))
diff --git a/clippy_lints/src/unwrap_in_result.rs b/clippy_lints/src/unwrap_in_result.rs
index 1c7e62ecd3d..0f8797243ec 100644
--- a/clippy_lints/src/unwrap_in_result.rs
+++ b/clippy_lints/src/unwrap_in_result.rs
@@ -1,4 +1,4 @@
-use crate::utils::{is_type_diagnostic_item, method_chain_args, return_ty, span_lint_and_then, walk_ptrs_ty};
+use crate::utils::{is_type_diagnostic_item, method_chain_args, return_ty, span_lint_and_then};
 use if_chain::if_chain;
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass};
@@ -81,7 +81,7 @@ impl<'a, 'tcx> Visitor<'tcx> for FindExpectUnwrap<'a, 'tcx> {
     fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
         // check for `expect`
         if let Some(arglists) = method_chain_args(expr, &["expect"]) {
-            let reciever_ty = walk_ptrs_ty(self.typeck_results.expr_ty(&arglists[0][0]));
+            let reciever_ty = self.typeck_results.expr_ty(&arglists[0][0]).peel_refs();
             if is_type_diagnostic_item(self.lcx, reciever_ty, sym!(option_type))
                 || is_type_diagnostic_item(self.lcx, reciever_ty, sym!(result_type))
             {
@@ -91,7 +91,7 @@ impl<'a, 'tcx> Visitor<'tcx> for FindExpectUnwrap<'a, 'tcx> {
 
         // check for `unwrap`
         if let Some(arglists) = method_chain_args(expr, &["unwrap"]) {
-            let reciever_ty = walk_ptrs_ty(self.typeck_results.expr_ty(&arglists[0][0]));
+            let reciever_ty = self.typeck_results.expr_ty(&arglists[0][0]).peel_refs();
             if is_type_diagnostic_item(self.lcx, reciever_ty, sym!(option_type))
                 || is_type_diagnostic_item(self.lcx, reciever_ty, sym!(result_type))
             {
diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs
index f201494a024..bfe426a25eb 100644
--- a/clippy_lints/src/utils/internal_lints.rs
+++ b/clippy_lints/src/utils/internal_lints.rs
@@ -1,6 +1,6 @@
 use crate::utils::{
     is_expn_of, match_def_path, match_qpath, match_type, method_calls, path_to_res, paths, qpath_res, run_lints,
-    snippet, span_lint, span_lint_and_help, span_lint_and_sugg, walk_ptrs_ty, SpanlessEq,
+    snippet, span_lint, span_lint_and_help, span_lint_and_sugg, SpanlessEq,
 };
 use if_chain::if_chain;
 use rustc_ast::ast::{Crate as AstCrate, ItemKind, LitKind, NodeId};
@@ -427,7 +427,7 @@ impl<'tcx> LateLintPass<'tcx> for CompilerLintFunctions {
             if let ExprKind::MethodCall(ref path, _, ref args, _) = expr.kind;
             let fn_name = path.ident;
             if let Some(sugg) = self.map.get(&*fn_name.as_str());
-            let ty = walk_ptrs_ty(cx.typeck_results().expr_ty(&args[0]));
+            let ty = cx.typeck_results().expr_ty(&args[0]).peel_refs();
             if match_type(cx, ty, &paths::EARLY_CONTEXT)
                 || match_type(cx, ty, &paths::LATE_CONTEXT);
             then {
@@ -460,7 +460,7 @@ impl<'tcx> LateLintPass<'tcx> for OuterExpnDataPass {
             let args = arg_lists[1];
             if args.len() == 1;
             let self_arg = &args[0];
-            let self_ty = walk_ptrs_ty(cx.typeck_results().expr_ty(self_arg));
+            let self_ty = cx.typeck_results().expr_ty(self_arg).peel_refs();
             if match_type(cx, self_ty, &paths::SYNTAX_CONTEXT);
             then {
                 span_lint_and_sugg(
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index 95eedf88178..ea52741b7cc 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -754,14 +754,6 @@ pub fn walk_ptrs_hir_ty<'tcx>(ty: &'tcx hir::Ty<'tcx>) -> &'tcx hir::Ty<'tcx> {
     }
 }
 
-/// Returns the base type for references and raw pointers.
-pub fn walk_ptrs_ty(ty: Ty<'_>) -> Ty<'_> {
-    match ty.kind() {
-        ty::Ref(_, ty, _) => walk_ptrs_ty(ty),
-        _ => ty,
-    }
-}
-
 /// Returns the base type for references and raw pointers, and count reference
 /// depth.
 pub fn walk_ptrs_ty_depth(ty: Ty<'_>) -> (Ty<'_>, usize) {
-- 
cgit 1.4.1-3-g733a5


From 27200855c34445bdf50185fbaed12b5c0d60eb9b Mon Sep 17 00:00:00 2001
From: Robin Schoonover <robin@cornhooves.org>
Date: Wed, 16 Sep 2020 17:19:35 -0600
Subject: Move rc_buffer lint into perf category

---
 clippy_lints/src/lib.rs   | 3 ++-
 clippy_lints/src/types.rs | 2 +-
 src/lintlist/mod.rs       | 2 +-
 3 files changed, 4 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 239eeb10bb4..06f41be8a2a 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1480,6 +1480,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&types::CHAR_LIT_AS_U8),
         LintId::of(&types::FN_TO_NUMERIC_CAST),
         LintId::of(&types::FN_TO_NUMERIC_CAST_WITH_TRUNCATION),
+        LintId::of(&types::RC_BUFFER),
         LintId::of(&types::REDUNDANT_ALLOCATION),
         LintId::of(&types::TYPE_COMPLEXITY),
         LintId::of(&types::UNIT_ARG),
@@ -1780,6 +1781,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&slow_vector_initialization::SLOW_VECTOR_INITIALIZATION),
         LintId::of(&stable_sort_primitive::STABLE_SORT_PRIMITIVE),
         LintId::of(&types::BOX_VEC),
+        LintId::of(&types::RC_BUFFER),
         LintId::of(&types::REDUNDANT_ALLOCATION),
         LintId::of(&vec::USELESS_VEC),
     ]);
@@ -1805,7 +1807,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&path_buf_push_overwrite::PATH_BUF_PUSH_OVERWRITE),
         LintId::of(&redundant_pub_crate::REDUNDANT_PUB_CRATE),
         LintId::of(&transmute::USELESS_TRANSMUTE),
-        LintId::of(&types::RC_BUFFER),
         LintId::of(&use_self::USE_SELF),
     ]);
 }
diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs
index da04d07885b..a29a199b8c3 100644
--- a/clippy_lints/src/types.rs
+++ b/clippy_lints/src/types.rs
@@ -241,7 +241,7 @@ declare_clippy_lint! {
     /// fn foo(interned: Rc<str>) { ... }
     /// ```
     pub RC_BUFFER,
-    nursery,
+    perf,
     "shared ownership of a buffer type"
 }
 
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index d0c6a1d63d9..e5563151b48 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -1853,7 +1853,7 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
     },
     Lint {
         name: "rc_buffer",
-        group: "nursery",
+        group: "perf",
         desc: "shared ownership of a buffer type",
         deprecation: None,
         module: "types",
-- 
cgit 1.4.1-3-g733a5


From d655c0a938c16d30ae6824713165c749eff7210f Mon Sep 17 00:00:00 2001
From: rail <12975677+rail-rain@users.noreply.github.com>
Date: Tue, 25 Aug 2020 15:13:40 +1200
Subject: Change the criteria of `interior_mutable_const`

* stop linting associated types and generic type parameters
* start linting ones in trait impls
  whose corresponding definitions in the traits are generic
* remove the `is_copy` check
  as presumably the only purpose of it is to allow
  generics with `Copy` bounds as `Freeze` is internal
  and generics are no longer linted
* remove the term 'copy' from the tests
  as being `Copy` no longer have meaning
---
 clippy_lints/src/non_copy_const.rs             | 93 +++++++++++++++++---------
 tests/ui/borrow_interior_mutable_const.rs      | 20 +++++-
 tests/ui/borrow_interior_mutable_const.stderr  | 44 +++++++-----
 tests/ui/declare_interior_mutable_const.rs     | 62 +++++++++--------
 tests/ui/declare_interior_mutable_const.stderr | 62 ++++++-----------
 5 files changed, 156 insertions(+), 125 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/non_copy_const.rs b/clippy_lints/src/non_copy_const.rs
index 73eabd4207e..28c68a2b68c 100644
--- a/clippy_lints/src/non_copy_const.rs
+++ b/clippy_lints/src/non_copy_const.rs
@@ -6,14 +6,17 @@ use std::ptr;
 
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::{Expr, ExprKind, ImplItem, ImplItemKind, Item, ItemKind, Node, TraitItem, TraitItemKind, UnOp};
+use rustc_infer::traits::specialization_graph;
 use rustc_lint::{LateContext, LateLintPass, Lint};
 use rustc_middle::ty::adjustment::Adjust;
-use rustc_middle::ty::{Ty, TypeFlags};
+use rustc_middle::ty::fold::TypeFoldable as _;
+use rustc_middle::ty::{AssocKind, Ty, TypeFlags};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::{InnerSpan, Span, DUMMY_SP};
 use rustc_typeck::hir_ty_to_ty;
 
-use crate::utils::{in_constant, is_copy, qpath_res, span_lint_and_then};
+use crate::utils::{in_constant, qpath_res, span_lint_and_then};
+use if_chain::if_chain;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for declaration of `const` items which is interior
@@ -83,11 +86,10 @@ declare_clippy_lint! {
     "referencing `const` with interior mutability"
 }
 
-#[allow(dead_code)]
 #[derive(Copy, Clone)]
 enum Source {
     Item { item: Span },
-    Assoc { item: Span, ty: Span },
+    Assoc { item: Span },
     Expr { expr: Span },
 }
 
@@ -110,10 +112,15 @@ impl Source {
 }
 
 fn verify_ty_bound<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>, source: Source) {
-    if ty.is_freeze(cx.tcx.at(DUMMY_SP), cx.param_env) || is_copy(cx, ty) {
-        // An `UnsafeCell` is `!Copy`, and an `UnsafeCell` is also the only type which
-        // is `!Freeze`, thus if our type is `Copy` we can be sure it must be `Freeze`
-        // as well.
+    // Ignore types whose layout is unknown since `is_freeze` reports every generic types as `!Freeze`,
+    // making it indistinguishable from `UnsafeCell`. i.e. it isn't a tool to prove a type is
+    // 'unfrozen'. However, this code causes a false negative in which
+    // a type contains a layout-unknown type, but also a unsafe cell like `const CELL: Cell<T>`.
+    // Yet, it's better than `ty.has_type_flags(TypeFlags::HAS_TY_PARAM | TypeFlags::HAS_PROJECTION)`
+    // since it works when a pointer indirection involves (`Cell<*const T>`).
+    // Making up a `ParamEnv` where every generic params and assoc types are `Freeze`is another option;
+    // but I'm not sure whether it's a decent way, if possible.
+    if cx.tcx.layout_of(cx.param_env.and(ty)).is_err() || ty.is_freeze(cx.tcx.at(DUMMY_SP), cx.param_env) {
         return;
     }
 
@@ -127,11 +134,7 @@ fn verify_ty_bound<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>, source: Source) {
                 let const_kw_span = span.from_inner(InnerSpan::new(0, 5));
                 diag.span_label(const_kw_span, "make this a static item (maybe with lazy_static)");
             },
-            Source::Assoc { ty: ty_span, .. } => {
-                if ty.flags().intersects(TypeFlags::HAS_FREE_LOCAL_NAMES) {
-                    diag.span_label(ty_span, &format!("consider requiring `{}` to be `Copy`", ty));
-                }
-            },
+            Source::Assoc { .. } => (),
             Source::Expr { .. } => {
                 diag.help("assign this const to a local or static variable, and use the variable here");
             },
@@ -152,14 +155,10 @@ impl<'tcx> LateLintPass<'tcx> for NonCopyConst {
     fn check_trait_item(&mut self, cx: &LateContext<'tcx>, trait_item: &'tcx TraitItem<'_>) {
         if let TraitItemKind::Const(hir_ty, ..) = &trait_item.kind {
             let ty = hir_ty_to_ty(cx.tcx, hir_ty);
-            verify_ty_bound(
-                cx,
-                ty,
-                Source::Assoc {
-                    ty: hir_ty.span,
-                    item: trait_item.span,
-                },
-            );
+            // Normalize assoc types because ones originated from generic params
+            // bounded other traits could have their bound.
+            let normalized = cx.tcx.normalize_erasing_regions(cx.param_env, ty);
+            verify_ty_bound(cx, normalized, Source::Assoc { item: trait_item.span });
         }
     }
 
@@ -167,17 +166,47 @@ impl<'tcx> LateLintPass<'tcx> for NonCopyConst {
         if let ImplItemKind::Const(hir_ty, ..) = &impl_item.kind {
             let item_hir_id = cx.tcx.hir().get_parent_node(impl_item.hir_id);
             let item = cx.tcx.hir().expect_item(item_hir_id);
-            // Ensure the impl is an inherent impl.
-            if let ItemKind::Impl { of_trait: None, .. } = item.kind {
-                let ty = hir_ty_to_ty(cx.tcx, hir_ty);
-                verify_ty_bound(
-                    cx,
-                    ty,
-                    Source::Assoc {
-                        ty: hir_ty.span,
-                        item: impl_item.span,
-                    },
-                );
+
+            match &item.kind {
+                ItemKind::Impl {
+                    of_trait: Some(of_trait_ref),
+                    ..
+                } => {
+                    if_chain! {
+                        // Lint a trait impl item only when the definition is a generic type,
+                        // assuming a assoc const is not meant to be a interior mutable type.
+                        if let Some(of_trait_def_id) = of_trait_ref.trait_def_id();
+                        if let Some(of_assoc_item) = specialization_graph::Node::Trait(of_trait_def_id)
+                            .item(cx.tcx, impl_item.ident, AssocKind::Const, of_trait_def_id);
+                        if cx.tcx
+                            // Normalize assoc types because ones originated from generic params
+                            // bounded other traits could have their bound at the trait defs;
+                            // and, in that case, the definition is *not* generic.
+                            .normalize_erasing_regions(
+                                cx.tcx.param_env(of_trait_def_id),
+                                cx.tcx.type_of(of_assoc_item.def_id),
+                            )
+                            .has_type_flags(TypeFlags::HAS_PROJECTION | TypeFlags::HAS_TY_PARAM);
+                        then {
+                            let ty = hir_ty_to_ty(cx.tcx, hir_ty);
+                            let normalized = cx.tcx.normalize_erasing_regions(cx.param_env, ty);
+                            verify_ty_bound(
+                                cx,
+                                normalized,
+                                Source::Assoc {
+                                    item: impl_item.span,
+                                },
+                            );
+                        }
+                    }
+                },
+                ItemKind::Impl { of_trait: None, .. } => {
+                    let ty = hir_ty_to_ty(cx.tcx, hir_ty);
+                    // Normalize assoc types originated from generic params.
+                    let normalized = cx.tcx.normalize_erasing_regions(cx.param_env, ty);
+                    verify_ty_bound(cx, normalized, Source::Assoc { item: impl_item.span });
+                },
+                _ => (),
             }
         }
     }
diff --git a/tests/ui/borrow_interior_mutable_const.rs b/tests/ui/borrow_interior_mutable_const.rs
index 39f87510548..9fcc9ece49b 100644
--- a/tests/ui/borrow_interior_mutable_const.rs
+++ b/tests/ui/borrow_interior_mutable_const.rs
@@ -19,16 +19,30 @@ const NO_ANN: &dyn Display = &70;
 static STATIC_TUPLE: (AtomicUsize, String) = (ATOMIC, STRING);
 const ONCE_INIT: Once = Once::new();
 
-trait Trait<T>: Copy {
-    type NonCopyType;
+trait Trait<T> {
+    type AssocType;
 
     const ATOMIC: AtomicUsize;
+    const INPUT: T;
+    const ASSOC: Self::AssocType;
+
+    fn function() {
+        let _ = &Self::INPUT;
+        let _ = &Self::ASSOC;
+    }
 }
 
 impl Trait<u32> for u64 {
-    type NonCopyType = u16;
+    type AssocType = AtomicUsize;
 
     const ATOMIC: AtomicUsize = AtomicUsize::new(9);
+    const INPUT: u32 = 10;
+    const ASSOC: Self::AssocType = AtomicUsize::new(11);
+
+    fn function() {
+        let _ = &Self::INPUT;
+        let _ = &Self::ASSOC; //~ ERROR interior mutability
+    }
 }
 
 // This is just a pointer that can be safely dereferended,
diff --git a/tests/ui/borrow_interior_mutable_const.stderr b/tests/ui/borrow_interior_mutable_const.stderr
index 5800af7e960..ed726a6b46e 100644
--- a/tests/ui/borrow_interior_mutable_const.stderr
+++ b/tests/ui/borrow_interior_mutable_const.stderr
@@ -1,14 +1,22 @@
 error: a `const` item with interior mutability should not be borrowed
-  --> $DIR/borrow_interior_mutable_const.rs:66:5
+  --> $DIR/borrow_interior_mutable_const.rs:44:18
+   |
+LL |         let _ = &Self::ASSOC; //~ ERROR interior mutability
+   |                  ^^^^^^^^^^^
+   |
+   = note: `-D clippy::borrow-interior-mutable-const` implied by `-D warnings`
+   = help: assign this const to a local or static variable, and use the variable here
+
+error: a `const` item with interior mutability should not be borrowed
+  --> $DIR/borrow_interior_mutable_const.rs:80:5
    |
 LL |     ATOMIC.store(1, Ordering::SeqCst); //~ ERROR interior mutability
    |     ^^^^^^
    |
-   = note: `-D clippy::borrow-interior-mutable-const` implied by `-D warnings`
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> $DIR/borrow_interior_mutable_const.rs:67:16
+  --> $DIR/borrow_interior_mutable_const.rs:81:16
    |
 LL |     assert_eq!(ATOMIC.load(Ordering::SeqCst), 5); //~ ERROR interior mutability
    |                ^^^^^^
@@ -16,7 +24,7 @@ LL |     assert_eq!(ATOMIC.load(Ordering::SeqCst), 5); //~ ERROR interior mutabi
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> $DIR/borrow_interior_mutable_const.rs:70:22
+  --> $DIR/borrow_interior_mutable_const.rs:84:22
    |
 LL |     let _once_ref = &ONCE_INIT; //~ ERROR interior mutability
    |                      ^^^^^^^^^
@@ -24,7 +32,7 @@ LL |     let _once_ref = &ONCE_INIT; //~ ERROR interior mutability
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> $DIR/borrow_interior_mutable_const.rs:71:25
+  --> $DIR/borrow_interior_mutable_const.rs:85:25
    |
 LL |     let _once_ref_2 = &&ONCE_INIT; //~ ERROR interior mutability
    |                         ^^^^^^^^^
@@ -32,7 +40,7 @@ LL |     let _once_ref_2 = &&ONCE_INIT; //~ ERROR interior mutability
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> $DIR/borrow_interior_mutable_const.rs:72:27
+  --> $DIR/borrow_interior_mutable_const.rs:86:27
    |
 LL |     let _once_ref_4 = &&&&ONCE_INIT; //~ ERROR interior mutability
    |                           ^^^^^^^^^
@@ -40,7 +48,7 @@ LL |     let _once_ref_4 = &&&&ONCE_INIT; //~ ERROR interior mutability
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> $DIR/borrow_interior_mutable_const.rs:73:26
+  --> $DIR/borrow_interior_mutable_const.rs:87:26
    |
 LL |     let _once_mut = &mut ONCE_INIT; //~ ERROR interior mutability
    |                          ^^^^^^^^^
@@ -48,7 +56,7 @@ LL |     let _once_mut = &mut ONCE_INIT; //~ ERROR interior mutability
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> $DIR/borrow_interior_mutable_const.rs:84:14
+  --> $DIR/borrow_interior_mutable_const.rs:98:14
    |
 LL |     let _ = &ATOMIC_TUPLE; //~ ERROR interior mutability
    |              ^^^^^^^^^^^^
@@ -56,7 +64,7 @@ LL |     let _ = &ATOMIC_TUPLE; //~ ERROR interior mutability
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> $DIR/borrow_interior_mutable_const.rs:85:14
+  --> $DIR/borrow_interior_mutable_const.rs:99:14
    |
 LL |     let _ = &ATOMIC_TUPLE.0; //~ ERROR interior mutability
    |              ^^^^^^^^^^^^
@@ -64,7 +72,7 @@ LL |     let _ = &ATOMIC_TUPLE.0; //~ ERROR interior mutability
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> $DIR/borrow_interior_mutable_const.rs:86:19
+  --> $DIR/borrow_interior_mutable_const.rs:100:19
    |
 LL |     let _ = &(&&&&ATOMIC_TUPLE).0; //~ ERROR interior mutability
    |                   ^^^^^^^^^^^^
@@ -72,7 +80,7 @@ LL |     let _ = &(&&&&ATOMIC_TUPLE).0; //~ ERROR interior mutability
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> $DIR/borrow_interior_mutable_const.rs:87:14
+  --> $DIR/borrow_interior_mutable_const.rs:101:14
    |
 LL |     let _ = &ATOMIC_TUPLE.0[0]; //~ ERROR interior mutability
    |              ^^^^^^^^^^^^
@@ -80,7 +88,7 @@ LL |     let _ = &ATOMIC_TUPLE.0[0]; //~ ERROR interior mutability
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> $DIR/borrow_interior_mutable_const.rs:88:13
+  --> $DIR/borrow_interior_mutable_const.rs:102:13
    |
 LL |     let _ = ATOMIC_TUPLE.0[0].load(Ordering::SeqCst); //~ ERROR interior mutability
    |             ^^^^^^^^^^^^
@@ -88,7 +96,7 @@ LL |     let _ = ATOMIC_TUPLE.0[0].load(Ordering::SeqCst); //~ ERROR interior mu
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> $DIR/borrow_interior_mutable_const.rs:94:13
+  --> $DIR/borrow_interior_mutable_const.rs:108:13
    |
 LL |     let _ = ATOMIC_TUPLE.0[0]; //~ ERROR interior mutability
    |             ^^^^^^^^^^^^
@@ -96,7 +104,7 @@ LL |     let _ = ATOMIC_TUPLE.0[0]; //~ ERROR interior mutability
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> $DIR/borrow_interior_mutable_const.rs:99:5
+  --> $DIR/borrow_interior_mutable_const.rs:113:5
    |
 LL |     CELL.set(2); //~ ERROR interior mutability
    |     ^^^^
@@ -104,7 +112,7 @@ LL |     CELL.set(2); //~ ERROR interior mutability
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> $DIR/borrow_interior_mutable_const.rs:100:16
+  --> $DIR/borrow_interior_mutable_const.rs:114:16
    |
 LL |     assert_eq!(CELL.get(), 6); //~ ERROR interior mutability
    |                ^^^^
@@ -112,7 +120,7 @@ LL |     assert_eq!(CELL.get(), 6); //~ ERROR interior mutability
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> $DIR/borrow_interior_mutable_const.rs:113:5
+  --> $DIR/borrow_interior_mutable_const.rs:127:5
    |
 LL |     u64::ATOMIC.store(5, Ordering::SeqCst); //~ ERROR interior mutability
    |     ^^^^^^^^^^^
@@ -120,12 +128,12 @@ LL |     u64::ATOMIC.store(5, Ordering::SeqCst); //~ ERROR interior mutability
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> $DIR/borrow_interior_mutable_const.rs:114:16
+  --> $DIR/borrow_interior_mutable_const.rs:128:16
    |
 LL |     assert_eq!(u64::ATOMIC.load(Ordering::SeqCst), 9); //~ ERROR interior mutability
    |                ^^^^^^^^^^^
    |
    = help: assign this const to a local or static variable, and use the variable here
 
-error: aborting due to 16 previous errors
+error: aborting due to 17 previous errors
 
diff --git a/tests/ui/declare_interior_mutable_const.rs b/tests/ui/declare_interior_mutable_const.rs
index b4003ed8932..7471b360540 100644
--- a/tests/ui/declare_interior_mutable_const.rs
+++ b/tests/ui/declare_interior_mutable_const.rs
@@ -34,60 +34,64 @@ static STATIC_TUPLE: (AtomicUsize, String) = (ATOMIC, STRING);
 #[allow(clippy::declare_interior_mutable_const)]
 const ONCE_INIT: Once = Once::new();
 
-trait Trait<T>: Copy {
-    type NonCopyType;
+struct Wrapper<T>(T);
+
+trait Trait<T: Trait2<AssocType5 = AtomicUsize>> {
+    type AssocType;
+    type AssocType2;
+    type AssocType3;
 
     const ATOMIC: AtomicUsize; //~ ERROR interior mutable
     const INTEGER: u64;
     const STRING: String;
-    const SELF: Self; // (no error)
+    const SELF: Self;
     const INPUT: T;
-    //~^ ERROR interior mutable
-    //~| HELP consider requiring `T` to be `Copy`
-    const ASSOC: Self::NonCopyType;
-    //~^ ERROR interior mutable
-    //~| HELP consider requiring `<Self as Trait<T>>::NonCopyType` to be `Copy`
+    const INPUT_ASSOC: T::AssocType4;
+    const INPUT_ASSOC_2: T::AssocType5; //~ ERROR interior mutable
+    const ASSOC: Self::AssocType;
+    const ASSOC_2: Self::AssocType2;
+    const WRAPPED_ASSOC_2: Wrapper<Self::AssocType2>;
+    const WRAPPED_ASSOC_3: Wrapper<Self::AssocType3>;
 
     const AN_INPUT: T = Self::INPUT;
-    //~^ ERROR interior mutable
-    //~| ERROR consider requiring `T` to be `Copy`
-    declare_const!(ANOTHER_INPUT: T = Self::INPUT); //~ ERROR interior mutable
+    declare_const!(ANOTHER_INPUT: T = Self::INPUT);
+    declare_const!(ANOTHER_ATOMIC: AtomicUsize = Self::ATOMIC); //~ ERROR interior mutable
 }
 
 trait Trait2 {
-    type CopyType: Copy;
+    type AssocType4;
+    type AssocType5;
 
     const SELF_2: Self;
-    //~^ ERROR interior mutable
-    //~| HELP consider requiring `Self` to be `Copy`
-    const ASSOC_2: Self::CopyType; // (no error)
+    const ASSOC_4: Self::AssocType4;
 }
 
-// we don't lint impl of traits, because an impl has no power to change the interface.
-impl Trait<u32> for u64 {
-    type NonCopyType = u16;
+impl<T: Trait2<AssocType5 = AtomicUsize>> Trait<T> for u64 {
+    type AssocType = u16;
+    type AssocType2 = AtomicUsize;
+    type AssocType3 = T;
 
     const ATOMIC: AtomicUsize = AtomicUsize::new(9);
     const INTEGER: u64 = 10;
     const STRING: String = String::new();
     const SELF: Self = 11;
-    const INPUT: u32 = 12;
-    const ASSOC: Self::NonCopyType = 13;
+    const INPUT: T = T::SELF_2;
+    const INPUT_ASSOC: T::AssocType4 = T::ASSOC_4;
+    const INPUT_ASSOC_2: T::AssocType5 = AtomicUsize::new(16);
+    const ASSOC: Self::AssocType = 13;
+    const ASSOC_2: Self::AssocType2 = AtomicUsize::new(15); //~ ERROR interior mutable
+    const WRAPPED_ASSOC_2: Wrapper<Self::AssocType2> = Wrapper(AtomicUsize::new(16)); //~ ERROR interior mutable
+    const WRAPPED_ASSOC_3: Wrapper<Self::AssocType3> = Wrapper(T::SELF_2);
 }
 
 struct Local<T, U>(T, U);
 
-impl<T: Trait2 + Trait<u32>, U: Trait2> Local<T, U> {
-    const ASSOC_3: AtomicUsize = AtomicUsize::new(14); //~ ERROR interior mutable
+impl<T: Trait<U>, U: Trait2<AssocType5 = AtomicUsize>> Local<T, U> {
+    const ASSOC_5: AtomicUsize = AtomicUsize::new(14); //~ ERROR interior mutable
     const COW: Cow<'static, str> = Cow::Borrowed("tuvwxy");
-    const T_SELF: T = T::SELF_2;
     const U_SELF: U = U::SELF_2;
-    //~^ ERROR interior mutable
-    //~| HELP consider requiring `U` to be `Copy`
-    const T_ASSOC: T::NonCopyType = T::ASSOC;
-    //~^ ERROR interior mutable
-    //~| HELP consider requiring `<T as Trait<u32>>::NonCopyType` to be `Copy`
-    const U_ASSOC: U::CopyType = U::ASSOC_2;
+    const T_ASSOC: T::AssocType = T::ASSOC;
+    const U_ASSOC: U::AssocType5 = AtomicUsize::new(17); //~ ERROR interior mutable
 }
 
 fn main() {}
diff --git a/tests/ui/declare_interior_mutable_const.stderr b/tests/ui/declare_interior_mutable_const.stderr
index 6a9a57361f9..0fcb726db46 100644
--- a/tests/ui/declare_interior_mutable_const.stderr
+++ b/tests/ui/declare_interior_mutable_const.stderr
@@ -36,34 +36,16 @@ LL | declare_const!(_ONCE: Once = Once::new()); //~ ERROR interior mutable
    = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: a `const` item should never be interior mutable
-  --> $DIR/declare_interior_mutable_const.rs:40:5
+  --> $DIR/declare_interior_mutable_const.rs:44:5
    |
 LL |     const ATOMIC: AtomicUsize; //~ ERROR interior mutable
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: a `const` item should never be interior mutable
-  --> $DIR/declare_interior_mutable_const.rs:44:5
-   |
-LL |     const INPUT: T;
-   |     ^^^^^^^^^^^^^-^
-   |                  |
-   |                  consider requiring `T` to be `Copy`
-
-error: a `const` item should never be interior mutable
-  --> $DIR/declare_interior_mutable_const.rs:47:5
+  --> $DIR/declare_interior_mutable_const.rs:50:5
    |
-LL |     const ASSOC: Self::NonCopyType;
-   |     ^^^^^^^^^^^^^-----------------^
-   |                  |
-   |                  consider requiring `<Self as Trait<T>>::NonCopyType` to be `Copy`
-
-error: a `const` item should never be interior mutable
-  --> $DIR/declare_interior_mutable_const.rs:51:5
-   |
-LL |     const AN_INPUT: T = Self::INPUT;
-   |     ^^^^^^^^^^^^^^^^-^^^^^^^^^^^^^^^
-   |                     |
-   |                     consider requiring `T` to be `Copy`
+LL |     const INPUT_ASSOC_2: T::AssocType5; //~ ERROR interior mutable
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: a `const` item should never be interior mutable
   --> $DIR/declare_interior_mutable_const.rs:16:9
@@ -71,40 +53,34 @@ error: a `const` item should never be interior mutable
 LL |         const $name: $ty = $e;
    |         ^^^^^^^^^^^^^^^^^^^^^^
 ...
-LL |     declare_const!(ANOTHER_INPUT: T = Self::INPUT); //~ ERROR interior mutable
-   |     ----------------------------------------------- in this macro invocation
+LL |     declare_const!(ANOTHER_ATOMIC: AtomicUsize = Self::ATOMIC); //~ ERROR interior mutable
+   |     ----------------------------------------------------------- in this macro invocation
    |
    = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: a `const` item should never be interior mutable
-  --> $DIR/declare_interior_mutable_const.rs:60:5
+  --> $DIR/declare_interior_mutable_const.rs:82:5
    |
-LL |     const SELF_2: Self;
-   |     ^^^^^^^^^^^^^^----^
-   |                   |
-   |                   consider requiring `Self` to be `Copy`
+LL |     const ASSOC_2: Self::AssocType2 = AtomicUsize::new(15); //~ ERROR interior mutable
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: a `const` item should never be interior mutable
-  --> $DIR/declare_interior_mutable_const.rs:81:5
+  --> $DIR/declare_interior_mutable_const.rs:83:5
    |
-LL |     const ASSOC_3: AtomicUsize = AtomicUsize::new(14); //~ ERROR interior mutable
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |     const WRAPPED_ASSOC_2: Wrapper<Self::AssocType2> = Wrapper(AtomicUsize::new(16)); //~ ERROR interior mutable
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: a `const` item should never be interior mutable
-  --> $DIR/declare_interior_mutable_const.rs:84:5
+  --> $DIR/declare_interior_mutable_const.rs:90:5
    |
-LL |     const U_SELF: U = U::SELF_2;
-   |     ^^^^^^^^^^^^^^-^^^^^^^^^^^^^
-   |                   |
-   |                   consider requiring `U` to be `Copy`
+LL |     const ASSOC_5: AtomicUsize = AtomicUsize::new(14); //~ ERROR interior mutable
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: a `const` item should never be interior mutable
-  --> $DIR/declare_interior_mutable_const.rs:87:5
+  --> $DIR/declare_interior_mutable_const.rs:94:5
    |
-LL |     const T_ASSOC: T::NonCopyType = T::ASSOC;
-   |     ^^^^^^^^^^^^^^^--------------^^^^^^^^^^^^
-   |                    |
-   |                    consider requiring `<T as Trait<u32>>::NonCopyType` to be `Copy`
+LL |     const U_ASSOC: U::AssocType5 = AtomicUsize::new(17); //~ ERROR interior mutable
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 13 previous errors
+error: aborting due to 11 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 2fc9064921ce0afd2c07c5b576f95c7adf731541 Mon Sep 17 00:00:00 2001
From: rail <12975677+rail-rain@users.noreply.github.com>
Date: Thu, 17 Sep 2020 19:37:42 +1200
Subject: rewrite the test and fix a minor fp

* rewrite the test for `declare_interior_mutable_const from scratch`

* fix a minor false positive where `Cell<"const T>` gets linted twice
---
 clippy_lints/src/non_copy_const.rs             |  24 ++--
 tests/ui/declare_interior_mutable_const.rs     | 159 ++++++++++++++++++-------
 tests/ui/declare_interior_mutable_const.stderr |  58 +++++----
 3 files changed, 166 insertions(+), 75 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/non_copy_const.rs b/clippy_lints/src/non_copy_const.rs
index 28c68a2b68c..bb44eeb6adc 100644
--- a/clippy_lints/src/non_copy_const.rs
+++ b/clippy_lints/src/non_copy_const.rs
@@ -9,8 +9,7 @@ use rustc_hir::{Expr, ExprKind, ImplItem, ImplItemKind, Item, ItemKind, Node, Tr
 use rustc_infer::traits::specialization_graph;
 use rustc_lint::{LateContext, LateLintPass, Lint};
 use rustc_middle::ty::adjustment::Adjust;
-use rustc_middle::ty::fold::TypeFoldable as _;
-use rustc_middle::ty::{AssocKind, Ty, TypeFlags};
+use rustc_middle::ty::{AssocKind, Ty};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::{InnerSpan, Span, DUMMY_SP};
 use rustc_typeck::hir_ty_to_ty;
@@ -178,15 +177,18 @@ impl<'tcx> LateLintPass<'tcx> for NonCopyConst {
                         if let Some(of_trait_def_id) = of_trait_ref.trait_def_id();
                         if let Some(of_assoc_item) = specialization_graph::Node::Trait(of_trait_def_id)
                             .item(cx.tcx, impl_item.ident, AssocKind::Const, of_trait_def_id);
-                        if cx.tcx
-                            // Normalize assoc types because ones originated from generic params
-                            // bounded other traits could have their bound at the trait defs;
-                            // and, in that case, the definition is *not* generic.
-                            .normalize_erasing_regions(
-                                cx.tcx.param_env(of_trait_def_id),
-                                cx.tcx.type_of(of_assoc_item.def_id),
-                            )
-                            .has_type_flags(TypeFlags::HAS_PROJECTION | TypeFlags::HAS_TY_PARAM);
+                        if cx
+                            .tcx
+                            .layout_of(cx.tcx.param_env(of_trait_def_id).and(
+                                // Normalize assoc types because ones originated from generic params
+                                // bounded other traits could have their bound at the trait defs;
+                                // and, in that case, the definition is *not* generic.
+                                cx.tcx.normalize_erasing_regions(
+                                    cx.tcx.param_env(of_trait_def_id),
+                                    cx.tcx.type_of(of_assoc_item.def_id),
+                                ),
+                            ))
+                            .is_err();
                         then {
                             let ty = hir_ty_to_ty(cx.tcx, hir_ty);
                             let normalized = cx.tcx.normalize_erasing_regions(cx.param_env, ty);
diff --git a/tests/ui/declare_interior_mutable_const.rs b/tests/ui/declare_interior_mutable_const.rs
index 7471b360540..646d3ec8b47 100644
--- a/tests/ui/declare_interior_mutable_const.rs
+++ b/tests/ui/declare_interior_mutable_const.rs
@@ -34,64 +34,135 @@ static STATIC_TUPLE: (AtomicUsize, String) = (ATOMIC, STRING);
 #[allow(clippy::declare_interior_mutable_const)]
 const ONCE_INIT: Once = Once::new();
 
-struct Wrapper<T>(T);
-
-trait Trait<T: Trait2<AssocType5 = AtomicUsize>> {
-    type AssocType;
-    type AssocType2;
-    type AssocType3;
-
+// a constant whose type is a concrete type should be linted at the definition site.
+trait ConcreteTypes {
     const ATOMIC: AtomicUsize; //~ ERROR interior mutable
     const INTEGER: u64;
     const STRING: String;
-    const SELF: Self;
-    const INPUT: T;
-    const INPUT_ASSOC: T::AssocType4;
-    const INPUT_ASSOC_2: T::AssocType5; //~ ERROR interior mutable
-    const ASSOC: Self::AssocType;
-    const ASSOC_2: Self::AssocType2;
-    const WRAPPED_ASSOC_2: Wrapper<Self::AssocType2>;
-    const WRAPPED_ASSOC_3: Wrapper<Self::AssocType3>;
-
-    const AN_INPUT: T = Self::INPUT;
-    declare_const!(ANOTHER_INPUT: T = Self::INPUT);
     declare_const!(ANOTHER_ATOMIC: AtomicUsize = Self::ATOMIC); //~ ERROR interior mutable
 }
 
-trait Trait2 {
-    type AssocType4;
-    type AssocType5;
+impl ConcreteTypes for u64 {
+    const ATOMIC: AtomicUsize = AtomicUsize::new(9);
+    const INTEGER: u64 = 10;
+    const STRING: String = String::new();
+}
 
-    const SELF_2: Self;
-    const ASSOC_4: Self::AssocType4;
+// a helper trait used below
+trait ConstDefault {
+    const DEFAULT: Self;
 }
 
-impl<T: Trait2<AssocType5 = AtomicUsize>> Trait<T> for u64 {
-    type AssocType = u16;
-    type AssocType2 = AtomicUsize;
-    type AssocType3 = T;
+// a constant whose type is a generic type should be linted at the implementation site.
+trait GenericTypes<T, U> {
+    const TO_REMAIN_GENERIC: T;
+    const TO_BE_CONCRETE: U;
 
-    const ATOMIC: AtomicUsize = AtomicUsize::new(9);
-    const INTEGER: u64 = 10;
-    const STRING: String = String::new();
-    const SELF: Self = 11;
-    const INPUT: T = T::SELF_2;
-    const INPUT_ASSOC: T::AssocType4 = T::ASSOC_4;
-    const INPUT_ASSOC_2: T::AssocType5 = AtomicUsize::new(16);
-    const ASSOC: Self::AssocType = 13;
-    const ASSOC_2: Self::AssocType2 = AtomicUsize::new(15); //~ ERROR interior mutable
-    const WRAPPED_ASSOC_2: Wrapper<Self::AssocType2> = Wrapper(AtomicUsize::new(16)); //~ ERROR interior mutable
-    const WRAPPED_ASSOC_3: Wrapper<Self::AssocType3> = Wrapper(T::SELF_2);
+    const HAVING_DEFAULT: T = Self::TO_REMAIN_GENERIC;
+    declare_const!(IN_MACRO: T = Self::TO_REMAIN_GENERIC);
+}
+
+impl<T: ConstDefault> GenericTypes<T, AtomicUsize> for u64 {
+    const TO_REMAIN_GENERIC: T = T::DEFAULT;
+    const TO_BE_CONCRETE: AtomicUsize = AtomicUsize::new(11); //~ ERROR interior mutable
+}
+
+// a helper type used below
+struct Wrapper<T>(T);
+
+// a constant whose type is an associated type should be linted at the implementation site, too.
+trait AssocTypes {
+    type ToBeFrozen;
+    type ToBeUnfrozen;
+    type ToBeGenericParam;
+
+    const TO_BE_FROZEN: Self::ToBeFrozen;
+    const TO_BE_UNFROZEN: Self::ToBeUnfrozen;
+    const WRAPPED_TO_BE_UNFROZEN: Wrapper<Self::ToBeUnfrozen>;
+    // to ensure it can handle things when a generic type remains after normalization.
+    const WRAPPED_TO_BE_GENERIC_PARAM: Wrapper<Self::ToBeGenericParam>;
+}
+
+impl<T: ConstDefault> AssocTypes for Vec<T> {
+    type ToBeFrozen = u16;
+    type ToBeUnfrozen = AtomicUsize;
+    type ToBeGenericParam = T;
+
+    const TO_BE_FROZEN: Self::ToBeFrozen = 12;
+    const TO_BE_UNFROZEN: Self::ToBeUnfrozen = AtomicUsize::new(13); //~ ERROR interior mutable
+    const WRAPPED_TO_BE_UNFROZEN: Wrapper<Self::ToBeUnfrozen> = Wrapper(AtomicUsize::new(14)); //~ ERROR interior mutable
+    const WRAPPED_TO_BE_GENERIC_PARAM: Wrapper<Self::ToBeGenericParam> = Wrapper(T::DEFAULT);
 }
 
-struct Local<T, U>(T, U);
+// a helper trait used below
+trait AssocTypesHelper {
+    type NotToBeBounded;
+    type ToBeBounded;
 
-impl<T: Trait<U>, U: Trait2<AssocType5 = AtomicUsize>> Local<T, U> {
-    const ASSOC_5: AtomicUsize = AtomicUsize::new(14); //~ ERROR interior mutable
+    const NOT_TO_BE_BOUNDED: Self::NotToBeBounded;
+}
+
+// a constant whose type is an assoc type originated from a generic param bounded at the definition
+// site should be linted at there.
+trait AssocTypesFromGenericParam<T>
+where
+    T: AssocTypesHelper<ToBeBounded = AtomicUsize>,
+{
+    const NOT_BOUNDED: T::NotToBeBounded;
+    const BOUNDED: T::ToBeBounded; //~ ERROR interior mutable
+}
+
+impl<T> AssocTypesFromGenericParam<T> for u64
+where
+    T: AssocTypesHelper<ToBeBounded = AtomicUsize>,
+{
+    // an associated type could remain unknown in a trait impl.
+    const NOT_BOUNDED: T::NotToBeBounded = T::NOT_TO_BE_BOUNDED;
+    const BOUNDED: T::ToBeBounded = AtomicUsize::new(15);
+}
+
+trait SelfType {
+    const SELF: Self;
+}
+
+impl SelfType for u64 {
+    const SELF: Self = 16;
+}
+
+impl SelfType for AtomicUsize {
+    // this (interior mutable `Self` const) exists in `parking_lot`.
+    // `const_trait_impl` will replace it in the future, hopefully.
+    const SELF: Self = AtomicUsize::new(17); //~ ERROR interior mutable
+}
+
+// Even though a constant contains a generic type, if it also have a interior mutable type,
+// it should be linted at the definition site.
+trait BothOfCellAndGeneric<T> {
+    // this is a false negative in the current implementation.
+    const DIRECT: Cell<T>;
+    const INDIRECT: Cell<*const T>; //~ ERROR interior mutable
+}
+
+impl<T: ConstDefault> BothOfCellAndGeneric<T> for u64 {
+    const DIRECT: Cell<T> = Cell::new(T::DEFAULT);
+    const INDIRECT: Cell<*const T> = Cell::new(std::ptr::null());
+}
+
+struct Local<T>(T);
+
+// a constant in an inherent impl are essentially the same as a normal const item
+// except there can be a generic or associated type.
+impl<T> Local<T>
+where
+    T: ConstDefault + AssocTypesHelper<ToBeBounded = AtomicUsize>,
+{
+    const ATOMIC: AtomicUsize = AtomicUsize::new(18); //~ ERROR interior mutable
     const COW: Cow<'static, str> = Cow::Borrowed("tuvwxy");
-    const U_SELF: U = U::SELF_2;
-    const T_ASSOC: T::AssocType = T::ASSOC;
-    const U_ASSOC: U::AssocType5 = AtomicUsize::new(17); //~ ERROR interior mutable
+
+    const GENERIC_TYPE: T = T::DEFAULT;
+
+    const ASSOC_TYPE: T::NotToBeBounded = T::NOT_TO_BE_BOUNDED;
+    const BOUNDED_ASSOC_TYPE: T::ToBeBounded = AtomicUsize::new(19); //~ ERROR interior mutable
 }
 
 fn main() {}
diff --git a/tests/ui/declare_interior_mutable_const.stderr b/tests/ui/declare_interior_mutable_const.stderr
index 0fcb726db46..0a0b818b8b7 100644
--- a/tests/ui/declare_interior_mutable_const.stderr
+++ b/tests/ui/declare_interior_mutable_const.stderr
@@ -36,17 +36,11 @@ LL | declare_const!(_ONCE: Once = Once::new()); //~ ERROR interior mutable
    = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: a `const` item should never be interior mutable
-  --> $DIR/declare_interior_mutable_const.rs:44:5
+  --> $DIR/declare_interior_mutable_const.rs:39:5
    |
 LL |     const ATOMIC: AtomicUsize; //~ ERROR interior mutable
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: a `const` item should never be interior mutable
-  --> $DIR/declare_interior_mutable_const.rs:50:5
-   |
-LL |     const INPUT_ASSOC_2: T::AssocType5; //~ ERROR interior mutable
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
 error: a `const` item should never be interior mutable
   --> $DIR/declare_interior_mutable_const.rs:16:9
    |
@@ -59,28 +53,52 @@ LL |     declare_const!(ANOTHER_ATOMIC: AtomicUsize = Self::ATOMIC); //~ ERROR i
    = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: a `const` item should never be interior mutable
-  --> $DIR/declare_interior_mutable_const.rs:82:5
+  --> $DIR/declare_interior_mutable_const.rs:67:5
+   |
+LL |     const TO_BE_CONCRETE: AtomicUsize = AtomicUsize::new(11); //~ ERROR interior mutable
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: a `const` item should never be interior mutable
+  --> $DIR/declare_interior_mutable_const.rs:92:5
+   |
+LL |     const TO_BE_UNFROZEN: Self::ToBeUnfrozen = AtomicUsize::new(13); //~ ERROR interior mutable
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: a `const` item should never be interior mutable
+  --> $DIR/declare_interior_mutable_const.rs:93:5
+   |
+LL |     const WRAPPED_TO_BE_UNFROZEN: Wrapper<Self::ToBeUnfrozen> = Wrapper(AtomicUsize::new(14)); //~ ERROR interior mutable
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: a `const` item should never be interior mutable
+  --> $DIR/declare_interior_mutable_const.rs:112:5
+   |
+LL |     const BOUNDED: T::ToBeBounded; //~ ERROR interior mutable
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: a `const` item should never be interior mutable
+  --> $DIR/declare_interior_mutable_const.rs:135:5
    |
-LL |     const ASSOC_2: Self::AssocType2 = AtomicUsize::new(15); //~ ERROR interior mutable
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |     const SELF: Self = AtomicUsize::new(17); //~ ERROR interior mutable
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: a `const` item should never be interior mutable
-  --> $DIR/declare_interior_mutable_const.rs:83:5
+  --> $DIR/declare_interior_mutable_const.rs:143:5
    |
-LL |     const WRAPPED_ASSOC_2: Wrapper<Self::AssocType2> = Wrapper(AtomicUsize::new(16)); //~ ERROR interior mutable
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |     const INDIRECT: Cell<*const T>; //~ ERROR interior mutable
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: a `const` item should never be interior mutable
-  --> $DIR/declare_interior_mutable_const.rs:90:5
+  --> $DIR/declare_interior_mutable_const.rs:159:5
    |
-LL |     const ASSOC_5: AtomicUsize = AtomicUsize::new(14); //~ ERROR interior mutable
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |     const ATOMIC: AtomicUsize = AtomicUsize::new(18); //~ ERROR interior mutable
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: a `const` item should never be interior mutable
-  --> $DIR/declare_interior_mutable_const.rs:94:5
+  --> $DIR/declare_interior_mutable_const.rs:165:5
    |
-LL |     const U_ASSOC: U::AssocType5 = AtomicUsize::new(17); //~ ERROR interior mutable
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |     const BOUNDED_ASSOC_TYPE: T::ToBeBounded = AtomicUsize::new(19); //~ ERROR interior mutable
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 11 previous errors
+error: aborting due to 14 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From d4f158fa5cd5f4ae1cc690b37b0a8850cb013b69 Mon Sep 17 00:00:00 2001
From: Aleksei Latyshev <alex_700_95@mail.ru>
Date: Sun, 20 Sep 2020 12:38:23 +0300
Subject: Forbid redundant_pattern_matching triggering in macros

- remove ice-2636 test
---
 clippy_lints/src/matches.rs                |  2 +-
 tests/ui/crashes/ice-2636.rs               | 22 ----------------------
 tests/ui/crashes/ice-2636.stderr           | 17 -----------------
 tests/ui/redundant_pattern_matching.fixed  | 12 ++++++++++++
 tests/ui/redundant_pattern_matching.rs     | 12 ++++++++++++
 tests/ui/redundant_pattern_matching.stderr | 24 ++++++++++++------------
 6 files changed, 37 insertions(+), 52 deletions(-)
 delete mode 100644 tests/ui/crashes/ice-2636.rs
 delete mode 100644 tests/ui/crashes/ice-2636.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index 6f47687c410..b1a4e06d4c3 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -502,7 +502,7 @@ impl_lint_pass!(Matches => [
 
 impl<'tcx> LateLintPass<'tcx> for Matches {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if in_external_macro(cx.sess(), expr.span) {
+        if in_external_macro(cx.sess(), expr.span) || in_macro(expr.span) {
             return;
         }
 
diff --git a/tests/ui/crashes/ice-2636.rs b/tests/ui/crashes/ice-2636.rs
deleted file mode 100644
index e0b58157590..00000000000
--- a/tests/ui/crashes/ice-2636.rs
+++ /dev/null
@@ -1,22 +0,0 @@
-#![allow(dead_code)]
-
-enum Foo {
-    A,
-    B,
-    C,
-}
-
-macro_rules! test_hash {
-    ($foo:expr, $($t:ident => $ord:expr),+ ) => {
-        use self::Foo::*;
-        match $foo {
-            $ ( & $t => $ord,
-            )*
-        };
-    };
-}
-
-fn main() {
-    let a = Foo::A;
-    test_hash!(&a, A => 0, B => 1, C => 2);
-}
diff --git a/tests/ui/crashes/ice-2636.stderr b/tests/ui/crashes/ice-2636.stderr
deleted file mode 100644
index 53799b4fbf1..00000000000
--- a/tests/ui/crashes/ice-2636.stderr
+++ /dev/null
@@ -1,17 +0,0 @@
-error: you don't need to add `&` to both the expression and the patterns
-  --> $DIR/ice-2636.rs:12:9
-   |
-LL | /         match $foo {
-LL | |             $ ( & $t => $ord,
-LL | |             )*
-LL | |         };
-   | |_________^
-...
-LL |       test_hash!(&a, A => 0, B => 1, C => 2);
-   |       --------------------------------------- in this macro invocation
-   |
-   = note: `-D clippy::match-ref-pats` implied by `-D warnings`
-   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
-
-error: aborting due to previous error
-
diff --git a/tests/ui/redundant_pattern_matching.fixed b/tests/ui/redundant_pattern_matching.fixed
index 17d908336d5..fe8f62503b7 100644
--- a/tests/ui/redundant_pattern_matching.fixed
+++ b/tests/ui/redundant_pattern_matching.fixed
@@ -42,6 +42,7 @@ fn main() {
 
     issue5504();
     issue6067();
+    issue6065();
 
     let _ = if gen_res().is_ok() {
         1
@@ -79,6 +80,17 @@ fn issue5504() {
     while m!().is_some() {}
 }
 
+fn issue6065() {
+    macro_rules! if_let_in_macro {
+        ($pat:pat, $x:expr) => {
+            if let Some($pat) = $x {}
+        };
+    }
+
+    // shouldn't be linted
+    if_let_in_macro!(_, Some(42));
+}
+
 // 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_ok` and `is_err` of `Result` were stabilized as const,
 // so the following should be linted.
diff --git a/tests/ui/redundant_pattern_matching.rs b/tests/ui/redundant_pattern_matching.rs
index d57fbb14ae4..09426a6e590 100644
--- a/tests/ui/redundant_pattern_matching.rs
+++ b/tests/ui/redundant_pattern_matching.rs
@@ -54,6 +54,7 @@ fn main() {
 
     issue5504();
     issue6067();
+    issue6065();
 
     let _ = if let Ok(_) = gen_res() {
         1
@@ -91,6 +92,17 @@ fn issue5504() {
     while let Some(_) = m!() {}
 }
 
+fn issue6065() {
+    macro_rules! if_let_in_macro {
+        ($pat:pat, $x:expr) => {
+            if let Some($pat) = $x {}
+        };
+    }
+
+    // shouldn't be linted
+    if_let_in_macro!(_, Some(42));
+}
+
 // 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_ok` and `is_err` of `Result` were stabilized as const,
 // so the following should be linted.
diff --git a/tests/ui/redundant_pattern_matching.stderr b/tests/ui/redundant_pattern_matching.stderr
index 955900f3e6c..3473ceea00e 100644
--- a/tests/ui/redundant_pattern_matching.stderr
+++ b/tests/ui/redundant_pattern_matching.stderr
@@ -73,67 +73,67 @@ 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_ok()`
-  --> $DIR/redundant_pattern_matching.rs:58:20
+  --> $DIR/redundant_pattern_matching.rs:59:20
    |
 LL |     let _ = if let Ok(_) = gen_res() {
    |             -------^^^^^------------ help: try this: `if gen_res().is_ok()`
 
 error: redundant pattern matching, consider using `is_err()`
-  --> $DIR/redundant_pattern_matching.rs:60:19
+  --> $DIR/redundant_pattern_matching.rs:61: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:83:19
+  --> $DIR/redundant_pattern_matching.rs:84: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:84:16
+  --> $DIR/redundant_pattern_matching.rs:85: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:90:12
+  --> $DIR/redundant_pattern_matching.rs:91: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:91:15
+  --> $DIR/redundant_pattern_matching.rs:92:15
    |
 LL |     while let Some(_) = m!() {}
    |     ----------^^^^^^^------- help: try this: `while m!().is_some()`
 
 error: redundant pattern matching, consider using `is_ok()`
-  --> $DIR/redundant_pattern_matching.rs:98:12
+  --> $DIR/redundant_pattern_matching.rs:110: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
+  --> $DIR/redundant_pattern_matching.rs:112: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
+  --> $DIR/redundant_pattern_matching.rs:114: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
+  --> $DIR/redundant_pattern_matching.rs:116: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
+  --> $DIR/redundant_pattern_matching.rs:118:5
    |
 LL | /     match Ok::<i32, i32>(42) {
 LL | |         Ok(_) => true,
@@ -142,7 +142,7 @@ 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
+  --> $DIR/redundant_pattern_matching.rs:123:5
    |
 LL | /     match Err::<i32, i32>(42) {
 LL | |         Ok(_) => false,
-- 
cgit 1.4.1-3-g733a5


From 5e393c7747d081c45414060f81016e9ea3cb961f Mon Sep 17 00:00:00 2001
From: rail <12975677+rail-rain@users.noreply.github.com>
Date: Wed, 10 Jun 2020 14:05:32 +1200
Subject: Fix a FP in `explicit_counter_loop`

Fix a false positive in `explicit_counter_loop` where the loop counter is used after incremented,
adjust the test so that counters are incremented at the end of the loop
and add the test for this false positive.
---
 clippy_lints/src/loops.rs         |  6 +++++-
 tests/ui/explicit_counter_loop.rs | 29 +++++++++++++++++++++--------
 2 files changed, 26 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 3410341a1e3..7f998c63f49 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -2134,7 +2134,7 @@ enum VarState {
     DontWarn,
 }
 
-/// Scan a for loop for variables that are incremented exactly once.
+/// Scan a for loop for variables that are incremented exactly once and not used after that.
 struct IncrementVisitor<'a, 'tcx> {
     cx: &'a LateContext<'tcx>,          // context reference
     states: FxHashMap<HirId, VarState>, // incremented variables
@@ -2154,6 +2154,10 @@ impl<'a, 'tcx> Visitor<'tcx> for IncrementVisitor<'a, 'tcx> {
         if let Some(def_id) = var_def_id(self.cx, expr) {
             if let Some(parent) = get_parent_expr(self.cx, expr) {
                 let state = self.states.entry(def_id).or_insert(VarState::Initial);
+                if *state == VarState::IncrOnce {
+                    *state = VarState::DontWarn;
+                    return;
+                }
 
                 match parent.kind {
                     ExprKind::AssignOp(op, ref lhs, ref rhs) => {
diff --git a/tests/ui/explicit_counter_loop.rs b/tests/ui/explicit_counter_loop.rs
index aa6ef162fe4..81d8221bd13 100644
--- a/tests/ui/explicit_counter_loop.rs
+++ b/tests/ui/explicit_counter_loop.rs
@@ -38,54 +38,54 @@ mod issue_1219 {
         let text = "banana";
         let mut count = 0;
         for ch in text.chars() {
+            println!("{}", count);
             if ch == 'a' {
                 continue;
             }
             count += 1;
-            println!("{}", count);
         }
 
         // should not trigger the lint because the count is conditional
         let text = "banana";
         let mut count = 0;
         for ch in text.chars() {
+            println!("{}", count);
             if ch == 'a' {
                 count += 1;
             }
-            println!("{}", count);
         }
 
         // should trigger the lint because the count is not conditional
         let text = "banana";
         let mut count = 0;
         for ch in text.chars() {
+            println!("{}", count);
             count += 1;
             if ch == 'a' {
                 continue;
             }
-            println!("{}", count);
         }
 
         // should trigger the lint because the count is not conditional
         let text = "banana";
         let mut count = 0;
         for ch in text.chars() {
+            println!("{}", count);
             count += 1;
             for i in 0..2 {
                 let _ = 123;
             }
-            println!("{}", count);
         }
 
         // should not trigger the lint because the count is incremented multiple times
         let text = "banana";
         let mut count = 0;
         for ch in text.chars() {
+            println!("{}", count);
             count += 1;
             for i in 0..2 {
                 count += 1;
             }
-            println!("{}", count);
         }
     }
 }
@@ -96,30 +96,30 @@ mod issue_3308 {
         let mut skips = 0;
         let erasures = vec![];
         for i in 0..10 {
+            println!("{}", skips);
             while erasures.contains(&(i + skips)) {
                 skips += 1;
             }
-            println!("{}", skips);
         }
 
         // should not trigger the lint because the count is incremented multiple times
         let mut skips = 0;
         for i in 0..10 {
+            println!("{}", skips);
             let mut j = 0;
             while j < 5 {
                 skips += 1;
                 j += 1;
             }
-            println!("{}", skips);
         }
 
         // should not trigger the lint because the count is incremented multiple times
         let mut skips = 0;
         for i in 0..10 {
+            println!("{}", skips);
             for j in 0..5 {
                 skips += 1;
             }
-            println!("{}", skips);
         }
     }
 }
@@ -145,3 +145,16 @@ mod issue_4732 {
         let _closure = || println!("index: {}", index);
     }
 }
+
+mod issue_4677 {
+    pub fn test() {
+        let slice = &[1, 2, 3];
+
+        // should not trigger the lint because the count is used after incremented
+        let mut count = 0;
+        for _i in slice {
+            count += 1;
+            println!("{}", count);
+        }
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 3e294b22a43be349262405715cf4885296c284ba Mon Sep 17 00:00:00 2001
From: Eduardo Broto <ebroto@tutanota.com>
Date: Wed, 23 Sep 2020 00:34:56 +0200
Subject: Revert "or_fn_call: ignore nullary associated const fns"

This reverts commit 7a66e6502dc3c7085b3f4078c01d4957d96175ed.
---
 clippy_lints/src/utils/mod.rs |  2 +-
 tests/ui/or_fun_call.fixed    | 17 ++++++-----------
 tests/ui/or_fun_call.rs       | 17 ++++++-----------
 tests/ui/or_fun_call.stderr   | 20 ++++++++++++++++----
 4 files changed, 29 insertions(+), 27 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index ea52741b7cc..3a005e2513e 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -893,7 +893,7 @@ pub fn is_ctor_or_promotable_const_function(cx: &LateContext<'_>, expr: &Expr<'_
             return match res {
                 def::Res::Def(DefKind::Variant | DefKind::Ctor(..), ..) => true,
                 // FIXME: check the constness of the arguments, see https://github.com/rust-lang/rust-clippy/pull/5682#issuecomment-638681210
-                def::Res::Def(DefKind::Fn | DefKind::AssocFn, def_id) if has_no_arguments(cx, def_id) => {
+                def::Res::Def(DefKind::Fn, def_id) if has_no_arguments(cx, def_id) => {
                     const_eval::is_const_fn(cx.tcx, def_id)
                 },
                 def::Res::Def(_, def_id) => cx.tcx.is_promotable_const_fn(def_id),
diff --git a/tests/ui/or_fun_call.fixed b/tests/ui/or_fun_call.fixed
index 5fb568672d3..67faa8bd4a0 100644
--- a/tests/ui/or_fun_call.fixed
+++ b/tests/ui/or_fun_call.fixed
@@ -58,6 +58,12 @@ fn or_fun_call() {
     let without_default = Some(Foo);
     without_default.unwrap_or_else(Foo::new);
 
+    let mut map = HashMap::<u64, String>::new();
+    map.entry(42).or_insert_with(String::new);
+
+    let mut btree = BTreeMap::<u64, String>::new();
+    btree.entry(42).or_insert_with(String::new);
+
     let stringy = Some(String::from(""));
     let _ = stringy.unwrap_or_else(|| "".to_owned());
 
@@ -116,17 +122,6 @@ pub fn skip_const_fn_with_no_args() {
         Some(42)
     }
     let _ = None.or(foo());
-
-    // See issue #5693.
-    let mut map = std::collections::HashMap::new();
-    map.insert(1, vec![1]);
-    map.entry(1).or_insert(vec![]);
-
-    let mut map = HashMap::<u64, String>::new();
-    map.entry(42).or_insert(String::new());
-
-    let mut btree = BTreeMap::<u64, String>::new();
-    btree.entry(42).or_insert(String::new());
 }
 
 fn main() {}
diff --git a/tests/ui/or_fun_call.rs b/tests/ui/or_fun_call.rs
index 737b0f7e55b..9867e2eedcf 100644
--- a/tests/ui/or_fun_call.rs
+++ b/tests/ui/or_fun_call.rs
@@ -58,6 +58,12 @@ fn or_fun_call() {
     let without_default = Some(Foo);
     without_default.unwrap_or(Foo::new());
 
+    let mut map = HashMap::<u64, String>::new();
+    map.entry(42).or_insert(String::new());
+
+    let mut btree = BTreeMap::<u64, String>::new();
+    btree.entry(42).or_insert(String::new());
+
     let stringy = Some(String::from(""));
     let _ = stringy.unwrap_or("".to_owned());
 
@@ -116,17 +122,6 @@ pub fn skip_const_fn_with_no_args() {
         Some(42)
     }
     let _ = None.or(foo());
-
-    // See issue #5693.
-    let mut map = std::collections::HashMap::new();
-    map.insert(1, vec![1]);
-    map.entry(1).or_insert(vec![]);
-
-    let mut map = HashMap::<u64, String>::new();
-    map.entry(42).or_insert(String::new());
-
-    let mut btree = BTreeMap::<u64, String>::new();
-    btree.entry(42).or_insert(String::new());
 }
 
 fn main() {}
diff --git a/tests/ui/or_fun_call.stderr b/tests/ui/or_fun_call.stderr
index b8a436993f3..bc5978b538f 100644
--- a/tests/ui/or_fun_call.stderr
+++ b/tests/ui/or_fun_call.stderr
@@ -60,23 +60,35 @@ error: use of `unwrap_or` followed by a function call
 LL |     without_default.unwrap_or(Foo::new());
    |                     ^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(Foo::new)`
 
+error: use of `or_insert` followed by a function call
+  --> $DIR/or_fun_call.rs:62:19
+   |
+LL |     map.entry(42).or_insert(String::new());
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `or_insert_with(String::new)`
+
+error: use of `or_insert` followed by a function call
+  --> $DIR/or_fun_call.rs:65:21
+   |
+LL |     btree.entry(42).or_insert(String::new());
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `or_insert_with(String::new)`
+
 error: use of `unwrap_or` followed by a function call
-  --> $DIR/or_fun_call.rs:62:21
+  --> $DIR/or_fun_call.rs:68:21
    |
 LL |     let _ = stringy.unwrap_or("".to_owned());
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|| "".to_owned())`
 
 error: use of `or` followed by a function call
-  --> $DIR/or_fun_call.rs:87:35
+  --> $DIR/or_fun_call.rs:93:35
    |
 LL |     let _ = Some("a".to_string()).or(Some("b".to_string()));
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `or_else(|| Some("b".to_string()))`
 
 error: use of `or` followed by a function call
-  --> $DIR/or_fun_call.rs:91:10
+  --> $DIR/or_fun_call.rs:97:10
    |
 LL |         .or(Some(Bar(b, Duration::from_secs(2))));
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `or_else(|| Some(Bar(b, Duration::from_secs(2))))`
 
-error: aborting due to 13 previous errors
+error: aborting due to 15 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From ce83d8d4d1b28e73888a616d3ffbf19c6a620588 Mon Sep 17 00:00:00 2001
From: Eduardo Broto <ebroto@tutanota.com>
Date: Wed, 23 Sep 2020 00:39:00 +0200
Subject: Revert "Avoid or_fun_call for const_fn with no args"

This reverts commit 5d66bd7bb3fd701d70ec11217e3f89fabe5cb0a7.
---
 clippy_lints/src/utils/mod.rs | 9 ---------
 tests/ui/or_fun_call.fixed    | 8 --------
 tests/ui/or_fun_call.rs       | 8 --------
 3 files changed, 25 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index 3a005e2513e..92cb31fcf85 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -46,7 +46,6 @@ use rustc_lint::{LateContext, Level, Lint, LintContext};
 use rustc_middle::hir::map::Map;
 use rustc_middle::ty::subst::{GenericArg, GenericArgKind};
 use rustc_middle::ty::{self, layout::IntegerExt, Ty, TyCtxt, TypeFoldable};
-use rustc_mir::const_eval;
 use rustc_span::hygiene::{ExpnKind, MacroKind};
 use rustc_span::source_map::original_sp;
 use rustc_span::symbol::{self, kw, Symbol};
@@ -883,19 +882,11 @@ pub fn is_copy<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
 
 /// Checks if an expression is constructing a tuple-like enum variant or struct
 pub fn is_ctor_or_promotable_const_function(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-    fn has_no_arguments(cx: &LateContext<'_>, def_id: DefId) -> bool {
-        cx.tcx.fn_sig(def_id).skip_binder().inputs().is_empty()
-    }
-
     if let ExprKind::Call(ref fun, _) = expr.kind {
         if let ExprKind::Path(ref qp) = fun.kind {
             let res = cx.qpath_res(qp, fun.hir_id);
             return match res {
                 def::Res::Def(DefKind::Variant | DefKind::Ctor(..), ..) => true,
-                // FIXME: check the constness of the arguments, see https://github.com/rust-lang/rust-clippy/pull/5682#issuecomment-638681210
-                def::Res::Def(DefKind::Fn, def_id) if has_no_arguments(cx, def_id) => {
-                    const_eval::is_const_fn(cx.tcx, def_id)
-                },
                 def::Res::Def(_, def_id) => cx.tcx.is_promotable_const_fn(def_id),
                 _ => false,
             };
diff --git a/tests/ui/or_fun_call.fixed b/tests/ui/or_fun_call.fixed
index 67faa8bd4a0..2045ffdb5f0 100644
--- a/tests/ui/or_fun_call.fixed
+++ b/tests/ui/or_fun_call.fixed
@@ -116,12 +116,4 @@ fn f() -> Option<()> {
     Some(())
 }
 
-// Issue 5886 - const fn (with no arguments)
-pub fn skip_const_fn_with_no_args() {
-    const fn foo() -> Option<i32> {
-        Some(42)
-    }
-    let _ = None.or(foo());
-}
-
 fn main() {}
diff --git a/tests/ui/or_fun_call.rs b/tests/ui/or_fun_call.rs
index 9867e2eedcf..522f31b72d0 100644
--- a/tests/ui/or_fun_call.rs
+++ b/tests/ui/or_fun_call.rs
@@ -116,12 +116,4 @@ fn f() -> Option<()> {
     Some(())
 }
 
-// Issue 5886 - const fn (with no arguments)
-pub fn skip_const_fn_with_no_args() {
-    const fn foo() -> Option<i32> {
-        Some(42)
-    }
-    let _ = None.or(foo());
-}
-
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 6c056d346562eebf8535e2a4415c353a911b6280 Mon Sep 17 00:00:00 2001
From: Robin Schoonover <robin@cornhooves.org>
Date: Tue, 22 Sep 2020 20:34:38 -0600
Subject: Satisfy rc_buffer lint in Constant::Binary byte string by copying
 data

We can avoid the data copy again by fixing rustc_ast::ast::LitKind
later.
---
 clippy_lints/src/consts.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/consts.rs b/clippy_lints/src/consts.rs
index 3ee022e4e68..0000d39263e 100644
--- a/clippy_lints/src/consts.rs
+++ b/clippy_lints/src/consts.rs
@@ -21,7 +21,7 @@ pub enum Constant {
     /// A `String` (e.g., "abc").
     Str(String),
     /// A binary string (e.g., `b"abc"`).
-    Binary(Lrc<Vec<u8>>),
+    Binary(Lrc<[u8]>),
     /// A single `char` (e.g., `'a'`).
     Char(char),
     /// An integer's bit representation.
@@ -155,7 +155,7 @@ pub fn lit_to_constant(lit: &LitKind, ty: Option<Ty<'_>>) -> Constant {
     match *lit {
         LitKind::Str(ref is, _) => Constant::Str(is.to_string()),
         LitKind::Byte(b) => Constant::Int(u128::from(b)),
-        LitKind::ByteStr(ref s) => Constant::Binary(Lrc::clone(s)),
+        LitKind::ByteStr(ref s) => Constant::Binary(Lrc::from(s.as_slice())),
         LitKind::Char(c) => Constant::Char(c),
         LitKind::Int(n, _) => Constant::Int(n),
         LitKind::Float(ref is, LitFloatType::Suffixed(fty)) => match fty {
-- 
cgit 1.4.1-3-g733a5


From 9365660a2fc57210996df733efe468019c671b2f Mon Sep 17 00:00:00 2001
From: Eduardo Broto <ebroto@tutanota.com>
Date: Wed, 23 Sep 2020 23:33:50 +0200
Subject: unnecessary sort by: avoid dereferencing closure param

---
 clippy_lints/src/unnecessary_sort_by.rs | 58 ++++++++++++---------------------
 tests/ui/unnecessary_sort_by.fixed      | 30 ++++++++---------
 tests/ui/unnecessary_sort_by.rs         | 10 +++---
 tests/ui/unnecessary_sort_by.stderr     | 52 ++++++++++++++++++++++-------
 4 files changed, 81 insertions(+), 69 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unnecessary_sort_by.rs b/clippy_lints/src/unnecessary_sort_by.rs
index 9b6a9075a29..1307237dbc7 100644
--- a/clippy_lints/src/unnecessary_sort_by.rs
+++ b/clippy_lints/src/unnecessary_sort_by.rs
@@ -170,22 +170,12 @@ fn mirrored_exprs(
 }
 
 fn detect_lint(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<LintTrigger> {
-    // NOTE: Vectors of references are not supported. In order to avoid hitting https://github.com/rust-lang/rust/issues/34162,
-    // (different unnamed lifetimes for closure arg and return type) we need to make sure the suggested
-    // closure parameter is not a reference in case we suggest `Reverse`. Trying to destructure more
-    // than one level of references would add some extra complexity as we would have to compensate
-    // in the closure body.
-
     if_chain! {
         if let ExprKind::MethodCall(name_ident, _, args, _) = &expr.kind;
         if let name = name_ident.ident.name.to_ident_string();
         if name == "sort_by" || name == "sort_unstable_by";
         if let [vec, Expr { kind: ExprKind::Closure(_, _, closure_body_id, _, _), .. }] = args;
-        let vec_ty = cx.typeck_results().expr_ty(vec);
-        if utils::is_type_diagnostic_item(cx, vec_ty, sym!(vec_type));
-        let ty = vec_ty.walk().nth(1).unwrap().expect_ty(); // T in Vec<T>
-        if !matches!(&ty.kind(), ty::Ref(..));
-        if utils::is_copy(cx, ty);
+        if utils::is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(vec), sym!(vec_type));
         if let closure_body = cx.tcx.hir().body(*closure_body_id);
         if let &[
             Param { pat: Pat { kind: PatKind::Binding(_, _, left_ident, _), .. }, ..},
@@ -210,40 +200,32 @@ fn detect_lint(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<LintTrigger> {
             let vec_name = Sugg::hir(cx, &args[0], "..").to_string();
             let unstable = name == "sort_unstable_by";
 
-            if_chain! {
-                if let ExprKind::Path(QPath::Resolved(_, Path {
-                    segments: [PathSegment { ident: left_name, .. }], ..
-                })) = &left_expr.kind;
-                if left_name == left_ident;
-                then {
-                    return Some(LintTrigger::Sort(SortDetection { vec_name, unstable }))
-                } else {
-                    if !key_returns_borrow(cx, left_expr) {
-                        return Some(LintTrigger::SortByKey(SortByKeyDetection {
-                            vec_name,
-                            unstable,
-                            closure_arg,
-                            closure_body,
-                            reverse
-                        }))
-                    }
+            if let ExprKind::Path(QPath::Resolved(_, Path {
+                segments: [PathSegment { ident: left_name, .. }], ..
+            })) = &left_expr.kind {
+                if left_name == left_ident {
+                    return Some(LintTrigger::Sort(SortDetection { vec_name, unstable }));
                 }
             }
+
+            if !expr_borrows(cx, left_expr) {
+                return Some(LintTrigger::SortByKey(SortByKeyDetection {
+                    vec_name,
+                    unstable,
+                    closure_arg,
+                    closure_body,
+                    reverse
+                }));
+            }
         }
     }
 
     None
 }
 
-fn key_returns_borrow(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-    if let Some(def_id) = utils::fn_def_id(cx, expr) {
-        let output = cx.tcx.fn_sig(def_id).output();
-        let ty = output.skip_binder();
-        return matches!(ty.kind(), ty::Ref(..))
-            || ty.walk().any(|arg| matches!(arg.unpack(), GenericArgKind::Lifetime(_)));
-    }
-
-    false
+fn expr_borrows(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+    let ty = cx.typeck_results().expr_ty(expr);
+    matches!(ty.kind(), ty::Ref(..)) || ty.walk().any(|arg| matches!(arg.unpack(), GenericArgKind::Lifetime(_)))
 }
 
 impl LateLintPass<'_> for UnnecessarySortBy {
@@ -256,7 +238,7 @@ impl LateLintPass<'_> for UnnecessarySortBy {
                 "use Vec::sort_by_key here instead",
                 "try",
                 format!(
-                    "{}.sort{}_by_key(|&{}| {})",
+                    "{}.sort{}_by_key(|{}| {})",
                     trigger.vec_name,
                     if trigger.unstable { "_unstable" } else { "" },
                     trigger.closure_arg,
diff --git a/tests/ui/unnecessary_sort_by.fixed b/tests/ui/unnecessary_sort_by.fixed
index ad0d0387db0..b45b27d8f23 100644
--- a/tests/ui/unnecessary_sort_by.fixed
+++ b/tests/ui/unnecessary_sort_by.fixed
@@ -13,12 +13,12 @@ fn unnecessary_sort_by() {
     // Forward examples
     vec.sort();
     vec.sort_unstable();
-    vec.sort_by_key(|&a| (a + 5).abs());
-    vec.sort_unstable_by_key(|&a| id(-a));
+    vec.sort_by_key(|a| (a + 5).abs());
+    vec.sort_unstable_by_key(|a| id(-a));
     // Reverse examples
-    vec.sort_by_key(|&b| Reverse(b));
-    vec.sort_by_key(|&b| Reverse((b + 5).abs()));
-    vec.sort_unstable_by_key(|&b| Reverse(id(-b)));
+    vec.sort_by(|a, b| b.cmp(a)); // not linted to avoid suggesting `Reverse(b)` which would borrow
+    vec.sort_by_key(|b| Reverse((b + 5).abs()));
+    vec.sort_unstable_by_key(|b| Reverse(id(-b)));
     // Negative examples (shouldn't be changed)
     let c = &7;
     vec.sort_by(|a, b| (b - a).cmp(&(a - b)));
@@ -26,10 +26,11 @@ fn unnecessary_sort_by() {
     vec.sort_by(|_, b| b.cmp(c));
     vec.sort_unstable_by(|a, _| a.cmp(c));
 
-    // Ignore vectors of references
+    // Vectors of references are fine as long as the resulting key does not borrow
     let mut vec: Vec<&&&isize> = vec![&&&3, &&&6, &&&1, &&&2, &&&5];
-    vec.sort_by(|a, b| (***a).abs().cmp(&(***b).abs()));
-    vec.sort_unstable_by(|a, b| (***a).abs().cmp(&(***b).abs()));
+    vec.sort_by_key(|a| (***a).abs());
+    vec.sort_unstable_by_key(|a| (***a).abs());
+    // `Reverse(b)` would borrow in the following cases, don't lint
     vec.sort_by(|a, b| b.cmp(a));
     vec.sort_unstable_by(|a, b| b.cmp(a));
 }
@@ -68,10 +69,9 @@ mod issue_5754 {
     }
 }
 
-// `Vec::sort_by_key` closure parameter is `F: FnMut(&T) -> K`
-// The suggestion is destructuring T and we know T is not a reference, so test that non-Copy T are
-// not linted.
+// The closure parameter is not dereferenced anymore, so non-Copy types can be linted
 mod issue_6001 {
+    use super::*;
     struct Test(String);
 
     impl Test {
@@ -85,11 +85,11 @@ mod issue_6001 {
         let mut args: Vec<Test> = vec![];
 
         // Forward
-        args.sort_by(|a, b| a.name().cmp(&b.name()));
-        args.sort_unstable_by(|a, b| a.name().cmp(&b.name()));
+        args.sort_by_key(|a| a.name());
+        args.sort_unstable_by_key(|a| a.name());
         // Reverse
-        args.sort_by(|a, b| b.name().cmp(&a.name()));
-        args.sort_unstable_by(|a, b| b.name().cmp(&a.name()));
+        args.sort_by_key(|b| Reverse(b.name()));
+        args.sort_unstable_by_key(|b| Reverse(b.name()));
     }
 }
 
diff --git a/tests/ui/unnecessary_sort_by.rs b/tests/ui/unnecessary_sort_by.rs
index 9746f6e6849..be2abe7f701 100644
--- a/tests/ui/unnecessary_sort_by.rs
+++ b/tests/ui/unnecessary_sort_by.rs
@@ -16,7 +16,7 @@ fn unnecessary_sort_by() {
     vec.sort_by(|a, b| (a + 5).abs().cmp(&(b + 5).abs()));
     vec.sort_unstable_by(|a, b| id(-a).cmp(&id(-b)));
     // Reverse examples
-    vec.sort_by(|a, b| b.cmp(a));
+    vec.sort_by(|a, b| b.cmp(a)); // not linted to avoid suggesting `Reverse(b)` which would borrow
     vec.sort_by(|a, b| (b + 5).abs().cmp(&(a + 5).abs()));
     vec.sort_unstable_by(|a, b| id(-b).cmp(&id(-a)));
     // Negative examples (shouldn't be changed)
@@ -26,10 +26,11 @@ fn unnecessary_sort_by() {
     vec.sort_by(|_, b| b.cmp(c));
     vec.sort_unstable_by(|a, _| a.cmp(c));
 
-    // Ignore vectors of references
+    // Vectors of references are fine as long as the resulting key does not borrow
     let mut vec: Vec<&&&isize> = vec![&&&3, &&&6, &&&1, &&&2, &&&5];
     vec.sort_by(|a, b| (***a).abs().cmp(&(***b).abs()));
     vec.sort_unstable_by(|a, b| (***a).abs().cmp(&(***b).abs()));
+    // `Reverse(b)` would borrow in the following cases, don't lint
     vec.sort_by(|a, b| b.cmp(a));
     vec.sort_unstable_by(|a, b| b.cmp(a));
 }
@@ -68,10 +69,9 @@ mod issue_5754 {
     }
 }
 
-// `Vec::sort_by_key` closure parameter is `F: FnMut(&T) -> K`
-// The suggestion is destructuring T and we know T is not a reference, so test that non-Copy T are
-// not linted.
+// The closure parameter is not dereferenced anymore, so non-Copy types can be linted
 mod issue_6001 {
+    use super::*;
     struct Test(String);
 
     impl Test {
diff --git a/tests/ui/unnecessary_sort_by.stderr b/tests/ui/unnecessary_sort_by.stderr
index 70c6cf0a3b6..50607933e18 100644
--- a/tests/ui/unnecessary_sort_by.stderr
+++ b/tests/ui/unnecessary_sort_by.stderr
@@ -16,31 +16,61 @@ error: use Vec::sort_by_key here instead
   --> $DIR/unnecessary_sort_by.rs:16:5
    |
 LL |     vec.sort_by(|a, b| (a + 5).abs().cmp(&(b + 5).abs()));
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_by_key(|&a| (a + 5).abs())`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_by_key(|a| (a + 5).abs())`
 
 error: use Vec::sort_by_key here instead
   --> $DIR/unnecessary_sort_by.rs:17:5
    |
 LL |     vec.sort_unstable_by(|a, b| id(-a).cmp(&id(-b)));
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_unstable_by_key(|&a| id(-a))`
-
-error: use Vec::sort_by_key here instead
-  --> $DIR/unnecessary_sort_by.rs:19:5
-   |
-LL |     vec.sort_by(|a, b| b.cmp(a));
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_by_key(|&b| Reverse(b))`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_unstable_by_key(|a| id(-a))`
 
 error: use Vec::sort_by_key here instead
   --> $DIR/unnecessary_sort_by.rs:20:5
    |
 LL |     vec.sort_by(|a, b| (b + 5).abs().cmp(&(a + 5).abs()));
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_by_key(|&b| Reverse((b + 5).abs()))`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_by_key(|b| Reverse((b + 5).abs()))`
 
 error: use Vec::sort_by_key here instead
   --> $DIR/unnecessary_sort_by.rs:21:5
    |
 LL |     vec.sort_unstable_by(|a, b| id(-b).cmp(&id(-a)));
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_unstable_by_key(|&b| Reverse(id(-b)))`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_unstable_by_key(|b| Reverse(id(-b)))`
+
+error: use Vec::sort_by_key here instead
+  --> $DIR/unnecessary_sort_by.rs:31:5
+   |
+LL |     vec.sort_by(|a, b| (***a).abs().cmp(&(***b).abs()));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_by_key(|a| (***a).abs())`
+
+error: use Vec::sort_by_key here instead
+  --> $DIR/unnecessary_sort_by.rs:32:5
+   |
+LL |     vec.sort_unstable_by(|a, b| (***a).abs().cmp(&(***b).abs()));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_unstable_by_key(|a| (***a).abs())`
+
+error: use Vec::sort_by_key here instead
+  --> $DIR/unnecessary_sort_by.rs:88:9
+   |
+LL |         args.sort_by(|a, b| a.name().cmp(&b.name()));
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `args.sort_by_key(|a| a.name())`
+
+error: use Vec::sort_by_key here instead
+  --> $DIR/unnecessary_sort_by.rs:89:9
+   |
+LL |         args.sort_unstable_by(|a, b| a.name().cmp(&b.name()));
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `args.sort_unstable_by_key(|a| a.name())`
+
+error: use Vec::sort_by_key here instead
+  --> $DIR/unnecessary_sort_by.rs:91:9
+   |
+LL |         args.sort_by(|a, b| b.name().cmp(&a.name()));
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `args.sort_by_key(|b| Reverse(b.name()))`
+
+error: use Vec::sort_by_key here instead
+  --> $DIR/unnecessary_sort_by.rs:92:9
+   |
+LL |         args.sort_unstable_by(|a, b| b.name().cmp(&a.name()));
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `args.sort_unstable_by_key(|b| Reverse(b.name()))`
 
-error: aborting due to 7 previous errors
+error: aborting due to 12 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 2892a2b0f578edd290b3be6f5e5c3280bc160f24 Mon Sep 17 00:00:00 2001
From: Takayuki Nakata <f.seasons017@gmail.com>
Date: Thu, 24 Sep 2020 23:22:54 +0900
Subject: Fix FP in `print_stdout`

This lint shouldn't be emitted in `build.rs` as `println!` and `print!` are used for the build script.
---
 clippy_lints/src/write.rs | 23 ++++++++++++++++++++---
 tests/ui/build.rs         | 10 ++++++++++
 tests/ui/build.stderr     |  0
 3 files changed, 30 insertions(+), 3 deletions(-)
 create mode 100644 tests/ui/build.rs
 create mode 100644 tests/ui/build.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs
index fac63bcb993..780d474ee96 100644
--- a/clippy_lints/src/write.rs
+++ b/clippy_lints/src/write.rs
@@ -2,6 +2,7 @@ use std::borrow::Cow;
 use std::ops::Range;
 
 use crate::utils::{snippet_with_applicability, span_lint, span_lint_and_sugg, span_lint_and_then};
+use if_chain::if_chain;
 use rustc_ast::ast::{Expr, ExprKind, Item, ItemKind, MacCall, StrLit, StrStyle};
 use rustc_ast::token;
 use rustc_ast::tokenstream::TokenStream;
@@ -11,7 +12,7 @@ use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_parse::parser;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::symbol::Symbol;
-use rustc_span::{BytePos, Span};
+use rustc_span::{BytePos, FileName, Span};
 
 declare_clippy_lint! {
     /// **What it does:** This lint warns when you use `println!("")` to
@@ -236,7 +237,15 @@ impl EarlyLintPass for Write {
 
     fn check_mac(&mut self, cx: &EarlyContext<'_>, mac: &MacCall) {
         if mac.path == sym!(println) {
-            span_lint(cx, PRINT_STDOUT, mac.span(), "use of `println!`");
+            let filename = cx.sess.source_map().span_to_filename(mac.span());
+            if_chain! {
+                if let FileName::Real(filename) = filename;
+                if let Some(filename) = filename.local_path().file_name();
+                if filename != "build.rs";
+                then {
+                    span_lint(cx, PRINT_STDOUT, mac.span(), "use of `println!`");
+                }
+            }
             if let (Some(fmt_str), _) = self.check_tts(cx, mac.args.inner_tokens(), false) {
                 if fmt_str.symbol == Symbol::intern("") {
                     span_lint_and_sugg(
@@ -251,7 +260,15 @@ impl EarlyLintPass for Write {
                 }
             }
         } else if mac.path == sym!(print) {
-            span_lint(cx, PRINT_STDOUT, mac.span(), "use of `print!`");
+            if_chain! {
+                let filename = cx.sess.source_map().span_to_filename(mac.span());
+                if let FileName::Real(filename) = filename;
+                if let Some(filename) = filename.local_path().file_name();
+                if filename != "build.rs";
+                then {
+                    span_lint(cx, PRINT_STDOUT, mac.span(), "use of `print!`");
+                }
+            }
             if let (Some(fmt_str), _) = self.check_tts(cx, mac.args.inner_tokens(), false) {
                 if check_newlines(&fmt_str) {
                     span_lint_and_then(
diff --git a/tests/ui/build.rs b/tests/ui/build.rs
new file mode 100644
index 00000000000..2d43d452a4f
--- /dev/null
+++ b/tests/ui/build.rs
@@ -0,0 +1,10 @@
+#![warn(clippy::print_stdout)]
+
+fn main() {
+    // Fix #6041
+    //
+    // The `print_stdout` shouldn't be linted in `build.rs`
+    // as these methods are used for the build script.
+    println!("Hello");
+    print!("Hello");
+}
diff --git a/tests/ui/build.stderr b/tests/ui/build.stderr
new file mode 100644
index 00000000000..e69de29bb2d
-- 
cgit 1.4.1-3-g733a5


From dc89bb1135afc31fc9ee2272e627192c04354d22 Mon Sep 17 00:00:00 2001
From: rail <12975677+rail-rain@users.noreply.github.com>
Date: Wed, 10 Jun 2020 14:21:58 +1200
Subject: Use if_chain in Increment/InitializeVisitor

---
 clippy_lints/src/loops.rs | 43 +++++++++++++++++++++++--------------------
 1 file changed, 23 insertions(+), 20 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 7f998c63f49..9f3be26e672 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -2162,15 +2162,16 @@ impl<'a, 'tcx> Visitor<'tcx> for IncrementVisitor<'a, 'tcx> {
                 match parent.kind {
                     ExprKind::AssignOp(op, ref lhs, ref rhs) => {
                         if lhs.hir_id == expr.hir_id {
-                            if op.node == BinOpKind::Add && is_integer_const(self.cx, rhs, 1) {
-                                *state = match *state {
-                                    VarState::Initial if self.depth == 0 => VarState::IncrOnce,
-                                    _ => VarState::DontWarn,
-                                };
+                            *state = if op.node == BinOpKind::Add
+                                && is_integer_const(self.cx, rhs, 1)
+                                && *state == VarState::Initial
+                                && self.depth == 0
+                            {
+                                VarState::IncrOnce
                             } else {
-                                // Assigned some other value
-                                *state = VarState::DontWarn;
-                            }
+                                // Assigned some other value or assigned multiple times
+                                VarState::DontWarn
+                            };
                         }
                     },
                     ExprKind::Assign(ref lhs, _, _) if lhs.hir_id == expr.hir_id => *state = VarState::DontWarn,
@@ -2212,18 +2213,20 @@ impl<'a, 'tcx> Visitor<'tcx> for InitializeVisitor<'a, 'tcx> {
 
     fn visit_stmt(&mut self, stmt: &'tcx Stmt<'_>) {
         // Look for declarations of the variable
-        if let StmtKind::Local(ref local) = stmt.kind {
-            if local.pat.hir_id == self.var_id {
-                if let PatKind::Binding(.., ident, _) = local.pat.kind {
-                    self.name = Some(ident.name);
-
-                    self.state = local.init.as_ref().map_or(VarState::Declared, |init| {
-                        if is_integer_const(&self.cx, init, 0) {
-                            VarState::Warn
-                        } else {
-                            VarState::Declared
-                        }
-                    })
+        if_chain! {
+            if let StmtKind::Local(ref local) = stmt.kind;
+            if local.pat.hir_id == self.var_id;
+            if let PatKind::Binding(.., ident, _) = local.pat.kind;
+            then {
+                self.name = Some(ident.name);
+                self.state = if_chain! {
+                    if let Some(ref init) = local.init;
+                    if is_integer_const(&self.cx, init, 0);
+                    then {
+                        VarState::Warn
+                    } else {
+                        VarState::Declared
+                    }
                 }
             }
         }
-- 
cgit 1.4.1-3-g733a5


From 116f30dc33d9e3744f257f2f7f5467acfbff178b Mon Sep 17 00:00:00 2001
From: rail <12975677+rail-rain@users.noreply.github.com>
Date: Wed, 10 Jun 2020 14:25:06 +1200
Subject: Use else blocks instead of return statements in
 Increment/InitializeVisitor

---
 clippy_lints/src/loops.rs | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 9f3be26e672..a59d3ef8708 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -2181,16 +2181,17 @@ impl<'a, 'tcx> Visitor<'tcx> for IncrementVisitor<'a, 'tcx> {
                     _ => (),
                 }
             }
+
+            walk_expr(self, expr);
         } else if is_loop(expr) || is_conditional(expr) {
             self.depth += 1;
             walk_expr(self, expr);
             self.depth -= 1;
-            return;
         } else if let ExprKind::Continue(_) = expr.kind {
             self.done = true;
-            return;
+        } else {
+            walk_expr(self, expr);
         }
-        walk_expr(self, expr);
     }
     fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
         NestedVisitorMap::None
@@ -2272,16 +2273,16 @@ impl<'a, 'tcx> Visitor<'tcx> for InitializeVisitor<'a, 'tcx> {
                 self.state = VarState::DontWarn;
                 return;
             }
+            walk_expr(self, expr);
         } else if !self.past_loop && is_loop(expr) {
             self.state = VarState::DontWarn;
-            return;
         } else if is_conditional(expr) {
             self.depth += 1;
             walk_expr(self, expr);
             self.depth -= 1;
-            return;
+        } else {
+            walk_expr(self, expr);
         }
-        walk_expr(self, expr);
     }
 
     fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-- 
cgit 1.4.1-3-g733a5


From b2d5b89a1de15df9052fdf44d01b174add82837f Mon Sep 17 00:00:00 2001
From: rail <12975677+rail-rain@users.noreply.github.com>
Date: Wed, 10 Jun 2020 14:41:09 +1200
Subject: Check if it's after the loop earlier

---
 clippy_lints/src/loops.rs | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index a59d3ef8708..20e75546d71 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -2250,6 +2250,11 @@ impl<'a, 'tcx> Visitor<'tcx> for InitializeVisitor<'a, 'tcx> {
 
         // If node is the desired variable, see how it's used
         if var_def_id(self.cx, expr) == Some(self.var_id) {
+            if self.past_loop {
+                self.state = VarState::DontWarn;
+                return;
+            }
+
             if let Some(parent) = get_parent_expr(self.cx, expr) {
                 match parent.kind {
                     ExprKind::AssignOp(_, ref lhs, _) if lhs.hir_id == expr.hir_id => {
@@ -2269,10 +2274,6 @@ impl<'a, 'tcx> Visitor<'tcx> for InitializeVisitor<'a, 'tcx> {
                 }
             }
 
-            if self.past_loop {
-                self.state = VarState::DontWarn;
-                return;
-            }
             walk_expr(self, expr);
         } else if !self.past_loop && is_loop(expr) {
             self.state = VarState::DontWarn;
-- 
cgit 1.4.1-3-g733a5


From 31cb1109648bf4242cab47571343578244e7fb9d Mon Sep 17 00:00:00 2001
From: rail <12975677+rail-rain@users.noreply.github.com>
Date: Wed, 10 Jun 2020 14:48:26 +1200
Subject: add concinient methods to Increment/InitializeVisitor

---
 clippy_lints/src/loops.rs | 63 +++++++++++++++++++++++++++++++++--------------
 1 file changed, 44 insertions(+), 19 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 20e75546d71..61f0059cca4 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -1536,31 +1536,17 @@ fn check_for_loop_explicit_counter<'tcx>(
     expr: &'tcx Expr<'_>,
 ) {
     // Look for variables that are incremented once per loop iteration.
-    let mut visitor = IncrementVisitor {
-        cx,
-        states: FxHashMap::default(),
-        depth: 0,
-        done: false,
-    };
+    let mut visitor = IncrementVisitor::new(cx);
     walk_expr(&mut visitor, body);
 
     // For each candidate, check the parent block to see if
     // it's initialized to zero at the start of the loop.
     if let Some(block) = get_enclosing_block(&cx, expr.hir_id) {
-        for (id, _) in visitor.states.iter().filter(|&(_, v)| *v == VarState::IncrOnce) {
-            let mut visitor2 = InitializeVisitor {
-                cx,
-                end_expr: expr,
-                var_id: *id,
-                state: VarState::IncrOnce,
-                name: None,
-                depth: 0,
-                past_loop: false,
-            };
+        for id in visitor.into_results() {
+            let mut visitor2 = InitializeVisitor::new(cx, expr, id);
             walk_block(&mut visitor2, block);
 
-            if visitor2.state == VarState::Warn {
-                if let Some(name) = visitor2.name {
+            if let Some(name) = visitor2.get_result() {
                     let mut applicability = Applicability::MachineApplicable;
 
                     // for some reason this is the only way to get the `Span`
@@ -1585,7 +1571,6 @@ fn check_for_loop_explicit_counter<'tcx>(
                         ),
                         applicability,
                     );
-                }
             }
         }
     }
@@ -2142,6 +2127,24 @@ struct IncrementVisitor<'a, 'tcx> {
     done: bool,
 }
 
+impl<'a, 'tcx> IncrementVisitor<'a, 'tcx> {
+    fn new(cx: &'a LateContext<'a, 'tcx>) -> Self {
+        Self {
+            cx,
+            states: FxHashMap::default(),
+            depth: 0,
+            done: false,
+        }
+    }
+
+    fn into_results(self) -> impl Iterator<Item = HirId> {
+        self.states
+            .into_iter()
+            .filter(|(_, state)| *state == VarState::IncrOnce)
+            .map(|(id, _)| id)
+    }
+}
+
 impl<'a, 'tcx> Visitor<'tcx> for IncrementVisitor<'a, 'tcx> {
     type Map = Map<'tcx>;
 
@@ -2209,6 +2212,28 @@ struct InitializeVisitor<'a, 'tcx> {
     past_loop: bool,
 }
 
+impl<'a, 'tcx> InitializeVisitor<'a, 'tcx> {
+    fn new(cx: &'a LateContext<'a, 'tcx>, end_expr: &'tcx Expr<'tcx>, var_id: HirId) -> Self {
+        Self {
+            cx,
+            end_expr,
+            var_id,
+            state: VarState::IncrOnce,
+            name: None,
+            depth: 0,
+            past_loop: false,
+        }
+    }
+
+    fn get_result(&self) -> Option<Name> {
+        if self.state == VarState::Warn {
+            self.name
+        } else {
+            None
+        }
+    }
+}
+
 impl<'a, 'tcx> Visitor<'tcx> for InitializeVisitor<'a, 'tcx> {
     type Map = Map<'tcx>;
 
-- 
cgit 1.4.1-3-g733a5


From c599e2fcfaaedb12b560f4136bab3d0b450acf8f Mon Sep 17 00:00:00 2001
From: rail <12975677+rail-rain@users.noreply.github.com>
Date: Wed, 10 Jun 2020 15:05:51 +1200
Subject: Split VarState

---
 clippy_lints/src/loops.rs | 87 ++++++++++++++++++++++++++---------------------
 1 file changed, 48 insertions(+), 39 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 61f0059cca4..2b7830e7cad 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -2107,23 +2107,18 @@ fn is_simple_break_expr(expr: &Expr<'_>) -> bool {
     }
 }
 
-// To trigger the EXPLICIT_COUNTER_LOOP lint, a variable must be
-// incremented exactly once in the loop body, and initialized to zero
-// at the start of the loop.
 #[derive(Debug, PartialEq)]
-enum VarState {
+enum IncrementVisitorVarState {
     Initial,  // Not examined yet
     IncrOnce, // Incremented exactly once, may be a loop counter
-    Declared, // Declared but not (yet) initialized to zero
-    Warn,
     DontWarn,
 }
 
 /// Scan a for loop for variables that are incremented exactly once and not used after that.
 struct IncrementVisitor<'a, 'tcx> {
-    cx: &'a LateContext<'tcx>,          // context reference
-    states: FxHashMap<HirId, VarState>, // incremented variables
-    depth: u32,                         // depth of conditional expressions
+    cx: &'a LateContext<'tcx>,                          // context reference
+    states: FxHashMap<HirId, IncrementVisitorVarState>, // incremented variables
+    depth: u32,                                         // depth of conditional expressions
     done: bool,
 }
 
@@ -2140,7 +2135,7 @@ impl<'a, 'tcx> IncrementVisitor<'a, 'tcx> {
     fn into_results(self) -> impl Iterator<Item = HirId> {
         self.states
             .into_iter()
-            .filter(|(_, state)| *state == VarState::IncrOnce)
+            .filter(|(_, state)| *state == IncrementVisitorVarState::IncrOnce)
             .map(|(id, _)| id)
     }
 }
@@ -2156,9 +2151,9 @@ impl<'a, 'tcx> Visitor<'tcx> for IncrementVisitor<'a, 'tcx> {
         // If node is a variable
         if let Some(def_id) = var_def_id(self.cx, expr) {
             if let Some(parent) = get_parent_expr(self.cx, expr) {
-                let state = self.states.entry(def_id).or_insert(VarState::Initial);
-                if *state == VarState::IncrOnce {
-                    *state = VarState::DontWarn;
+                let state = self.states.entry(def_id).or_insert(IncrementVisitorVarState::Initial);
+                if *state == IncrementVisitorVarState::IncrOnce {
+                    *state = IncrementVisitorVarState::DontWarn;
                     return;
                 }
 
@@ -2167,19 +2162,21 @@ impl<'a, 'tcx> Visitor<'tcx> for IncrementVisitor<'a, 'tcx> {
                         if lhs.hir_id == expr.hir_id {
                             *state = if op.node == BinOpKind::Add
                                 && is_integer_const(self.cx, rhs, 1)
-                                && *state == VarState::Initial
+                                && *state == IncrementVisitorVarState::Initial
                                 && self.depth == 0
                             {
-                                VarState::IncrOnce
+                                IncrementVisitorVarState::IncrOnce
                             } else {
                                 // Assigned some other value or assigned multiple times
-                                VarState::DontWarn
+                                IncrementVisitorVarState::DontWarn
                             };
                         }
                     },
-                    ExprKind::Assign(ref lhs, _, _) if lhs.hir_id == expr.hir_id => *state = VarState::DontWarn,
+                    ExprKind::Assign(ref lhs, _, _) if lhs.hir_id == expr.hir_id => {
+                        *state = IncrementVisitorVarState::DontWarn
+                    },
                     ExprKind::AddrOf(BorrowKind::Ref, mutability, _) if mutability == Mutability::Mut => {
-                        *state = VarState::DontWarn
+                        *state = IncrementVisitorVarState::DontWarn
                     },
                     _ => (),
                 }
@@ -2201,13 +2198,20 @@ impl<'a, 'tcx> Visitor<'tcx> for IncrementVisitor<'a, 'tcx> {
     }
 }
 
-/// Checks whether a variable is initialized to zero at the start of a loop.
+enum InitializeVisitorState {
+    Initial,          // Not examined yet
+    Declared(Symbol), // Declared but not (yet) initialized
+    Initialized { name: Symbol },
+    DontWarn,
+}
+
+/// Checks whether a variable is initialized to zero at the start of a loop and not modified
+/// and used after the loop.
 struct InitializeVisitor<'a, 'tcx> {
     cx: &'a LateContext<'tcx>,  // context reference
     end_expr: &'tcx Expr<'tcx>, // the for loop. Stop scanning here.
     var_id: HirId,
-    state: VarState,
-    name: Option<Symbol>,
+    state: InitializeVisitorState,
     depth: u32, // depth of conditional expressions
     past_loop: bool,
 }
@@ -2218,16 +2222,15 @@ impl<'a, 'tcx> InitializeVisitor<'a, 'tcx> {
             cx,
             end_expr,
             var_id,
-            state: VarState::IncrOnce,
-            name: None,
+            state: InitializeVisitorState::Initial,
             depth: 0,
             past_loop: false,
         }
     }
 
     fn get_result(&self) -> Option<Name> {
-        if self.state == VarState::Warn {
-            self.name
+        if let InitializeVisitorState::Initialized { name } = self.state {
+            Some(name)
         } else {
             None
         }
@@ -2244,23 +2247,24 @@ impl<'a, 'tcx> Visitor<'tcx> for InitializeVisitor<'a, 'tcx> {
             if local.pat.hir_id == self.var_id;
             if let PatKind::Binding(.., ident, _) = local.pat.kind;
             then {
-                self.name = Some(ident.name);
                 self.state = if_chain! {
                     if let Some(ref init) = local.init;
                     if is_integer_const(&self.cx, init, 0);
                     then {
-                        VarState::Warn
-                    } else {
-                        VarState::Declared
+                    InitializeVisitorState::Initialized {
+                        name: ident.name
                     }
+                } else {
+                    InitializeVisitorState::Declared(ident.name)
                 }
             }
         }
+        }
         walk_stmt(self, stmt);
     }
 
     fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
-        if self.state == VarState::DontWarn {
+        if matches!(self.state, InitializeVisitorState::DontWarn) {
             return;
         }
         if expr.hir_id == self.end_expr.hir_id {
@@ -2269,31 +2273,36 @@ impl<'a, 'tcx> Visitor<'tcx> for InitializeVisitor<'a, 'tcx> {
         }
         // No need to visit expressions before the variable is
         // declared
-        if self.state == VarState::IncrOnce {
+        if matches!(self.state, InitializeVisitorState::Initial) {
             return;
         }
 
         // If node is the desired variable, see how it's used
         if var_def_id(self.cx, expr) == Some(self.var_id) {
             if self.past_loop {
-                self.state = VarState::DontWarn;
+                self.state = InitializeVisitorState::DontWarn;
                 return;
             }
 
             if let Some(parent) = get_parent_expr(self.cx, expr) {
                 match parent.kind {
                     ExprKind::AssignOp(_, ref lhs, _) if lhs.hir_id == expr.hir_id => {
-                        self.state = VarState::DontWarn;
+                        self.state = InitializeVisitorState::DontWarn;
                     },
                     ExprKind::Assign(ref lhs, ref rhs, _) if lhs.hir_id == expr.hir_id => {
-                        self.state = if is_integer_const(&self.cx, rhs, 0) && self.depth == 0 {
-                            VarState::Warn
-                        } else {
-                            VarState::DontWarn
+                        self.state = if_chain! {
+                            if is_integer_const(&self.cx, rhs, 0) && self.depth == 0;
+                            if let InitializeVisitorState::Declared(name)
+                                | InitializeVisitorState::Initialized { name, ..} = self.state;
+                            then {
+                                InitializeVisitorState::Initialized { name }
+                            } else {
+                                InitializeVisitorState::DontWarn
+                            }
                         }
                     },
                     ExprKind::AddrOf(BorrowKind::Ref, mutability, _) if mutability == Mutability::Mut => {
-                        self.state = VarState::DontWarn
+                        self.state = InitializeVisitorState::DontWarn
                     },
                     _ => (),
                 }
@@ -2301,7 +2310,7 @@ impl<'a, 'tcx> Visitor<'tcx> for InitializeVisitor<'a, 'tcx> {
 
             walk_expr(self, expr);
         } else if !self.past_loop && is_loop(expr) {
-            self.state = VarState::DontWarn;
+            self.state = InitializeVisitorState::DontWarn;
         } else if is_conditional(expr) {
             self.depth += 1;
             walk_expr(self, expr);
-- 
cgit 1.4.1-3-g733a5


From 13c207d3756754c54a6b20d852087616d5abfbf4 Mon Sep 17 00:00:00 2001
From: rail <12975677+rail-rain@users.noreply.github.com>
Date: Wed, 10 Jun 2020 15:14:57 +1200
Subject: Generalise `InitializeVisitor`

---
 clippy_lints/src/loops.rs     | 36 ++++++++++++++++++++----------------
 clippy_lints/src/utils/mod.rs |  2 +-
 2 files changed, 21 insertions(+), 17 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 2b7830e7cad..bf067c70a7e 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -1528,6 +1528,9 @@ fn check_arg_type(cx: &LateContext<'_>, pat: &Pat<'_>, arg: &Expr<'_>) {
     }
 }
 
+// To trigger the EXPLICIT_COUNTER_LOOP lint, a variable must be
+// incremented exactly once in the loop body, and initialized to zero
+// at the start of the loop.
 fn check_for_loop_explicit_counter<'tcx>(
     cx: &LateContext<'tcx>,
     pat: &'tcx Pat<'_>,
@@ -1546,7 +1549,10 @@ fn check_for_loop_explicit_counter<'tcx>(
             let mut visitor2 = InitializeVisitor::new(cx, expr, id);
             walk_block(&mut visitor2, block);
 
-            if let Some(name) = visitor2.get_result() {
+            if_chain! {
+                if let Some((name, initializer)) = visitor2.get_result();
+                if is_integer_const(cx, initializer, 0);
+                then {
                     let mut applicability = Applicability::MachineApplicable;
 
                     // for some reason this is the only way to get the `Span`
@@ -1571,6 +1577,7 @@ fn check_for_loop_explicit_counter<'tcx>(
                         ),
                         applicability,
                     );
+                }
             }
         }
     }
@@ -2198,20 +2205,20 @@ impl<'a, 'tcx> Visitor<'tcx> for IncrementVisitor<'a, 'tcx> {
     }
 }
 
-enum InitializeVisitorState {
+enum InitializeVisitorState<'hir> {
     Initial,          // Not examined yet
     Declared(Symbol), // Declared but not (yet) initialized
-    Initialized { name: Symbol },
+    Initialized { name: Symbol, initializer: &'hir Expr<'hir> },
     DontWarn,
 }
 
-/// Checks whether a variable is initialized to zero at the start of a loop and not modified
+/// Checks whether a variable is initialized at the start of a loop and not modified
 /// and used after the loop.
 struct InitializeVisitor<'a, 'tcx> {
     cx: &'a LateContext<'tcx>,  // context reference
     end_expr: &'tcx Expr<'tcx>, // the for loop. Stop scanning here.
     var_id: HirId,
-    state: InitializeVisitorState,
+    state: InitializeVisitorState<'tcx>,
     depth: u32, // depth of conditional expressions
     past_loop: bool,
 }
@@ -2228,9 +2235,9 @@ impl<'a, 'tcx> InitializeVisitor<'a, 'tcx> {
         }
     }
 
-    fn get_result(&self) -> Option<Name> {
-        if let InitializeVisitorState::Initialized { name } = self.state {
-            Some(name)
+    fn get_result(&self) -> Option<(Name, &'tcx Expr<'tcx>)> {
+        if let InitializeVisitorState::Initialized { name, initializer } = self.state {
+            Some((name, initializer))
         } else {
             None
         }
@@ -2247,19 +2254,16 @@ impl<'a, 'tcx> Visitor<'tcx> for InitializeVisitor<'a, 'tcx> {
             if local.pat.hir_id == self.var_id;
             if let PatKind::Binding(.., ident, _) = local.pat.kind;
             then {
-                self.state = if_chain! {
-                    if let Some(ref init) = local.init;
-                    if is_integer_const(&self.cx, init, 0);
-                    then {
+                self.state = if let Some(ref init) = local.init {
                     InitializeVisitorState::Initialized {
-                        name: ident.name
+                        initializer: init,
+                        name: ident.name,
                     }
                 } else {
                     InitializeVisitorState::Declared(ident.name)
                 }
             }
         }
-        }
         walk_stmt(self, stmt);
     }
 
@@ -2291,11 +2295,11 @@ impl<'a, 'tcx> Visitor<'tcx> for InitializeVisitor<'a, 'tcx> {
                     },
                     ExprKind::Assign(ref lhs, ref rhs, _) if lhs.hir_id == expr.hir_id => {
                         self.state = if_chain! {
-                            if is_integer_const(&self.cx, rhs, 0) && self.depth == 0;
+                            if self.depth == 0;
                             if let InitializeVisitorState::Declared(name)
                                 | InitializeVisitorState::Initialized { name, ..} = self.state;
                             then {
-                                InitializeVisitorState::Initialized { name }
+                                InitializeVisitorState::Initialized { initializer: rhs, name }
                             } else {
                                 InitializeVisitorState::DontWarn
                             }
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index 92cb31fcf85..a0ddcce111e 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -707,7 +707,7 @@ fn reindent_multiline_inner(s: &str, ignore_first: bool, indent: Option<usize>,
 }
 
 /// Gets the parent expression, if any –- this is useful to constrain a lint.
-pub fn get_parent_expr<'c>(cx: &'c LateContext<'_>, e: &Expr<'_>) -> Option<&'c Expr<'c>> {
+pub fn get_parent_expr<'tcx>(cx: &LateContext<'tcx>, e: &Expr<'_>) -> Option<&'tcx Expr<'tcx>> {
     let map = &cx.tcx.hir();
     let hir_id = e.hir_id;
     let parent_id = map.get_parent_node(hir_id);
-- 
cgit 1.4.1-3-g733a5


From 9573a0d378033a81e55ca834a5d305d3cf2be24d Mon Sep 17 00:00:00 2001
From: rail <12975677+rail-rain@users.noreply.github.com>
Date: Wed, 10 Jun 2020 15:15:20 +1200
Subject: Rename variables

---
 clippy_lints/src/loops.rs | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index bf067c70a7e..1c316c00f43 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -1539,18 +1539,18 @@ fn check_for_loop_explicit_counter<'tcx>(
     expr: &'tcx Expr<'_>,
 ) {
     // Look for variables that are incremented once per loop iteration.
-    let mut visitor = IncrementVisitor::new(cx);
-    walk_expr(&mut visitor, body);
+    let mut increment_visitor = IncrementVisitor::new(cx);
+    walk_expr(&mut increment_visitor, body);
 
     // For each candidate, check the parent block to see if
     // it's initialized to zero at the start of the loop.
     if let Some(block) = get_enclosing_block(&cx, expr.hir_id) {
-        for id in visitor.into_results() {
-            let mut visitor2 = InitializeVisitor::new(cx, expr, id);
-            walk_block(&mut visitor2, block);
+        for id in increment_visitor.into_results() {
+            let mut initialize_visitor = InitializeVisitor::new(cx, expr, id);
+            walk_block(&mut initialize_visitor, block);
 
             if_chain! {
-                if let Some((name, initializer)) = visitor2.get_result();
+                if let Some((name, initializer)) = initialize_visitor.get_result();
                 if is_integer_const(cx, initializer, 0);
                 then {
                     let mut applicability = Applicability::MachineApplicable;
-- 
cgit 1.4.1-3-g733a5


From 1026b42f0694eb9239b5cebe80be743d5ded0da5 Mon Sep 17 00:00:00 2001
From: rail <12975677+rail-rain@users.noreply.github.com>
Date: Wed, 10 Jun 2020 15:32:24 +1200
Subject: Rename a struct and variables

---
 clippy_lints/src/loops.rs | 65 ++++++++++++++++++++++++-----------------------
 1 file changed, 33 insertions(+), 32 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 1c316c00f43..d9896f7fd6b 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -820,9 +820,9 @@ impl Offset {
     }
 }
 
-struct FixedOffsetVar<'hir> {
-    var: &'hir Expr<'hir>,
-    offset: Offset,
+struct IndexExpr<'hir> {
+    base: &'hir Expr<'hir>,
+    idx_offset: Offset,
 }
 
 fn is_slice_like<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'_>) -> bool {
@@ -845,14 +845,14 @@ fn fetch_cloned_expr<'tcx>(expr: &'tcx Expr<'tcx>) -> &'tcx Expr<'tcx> {
     }
 }
 
-fn get_offset<'tcx>(cx: &LateContext<'tcx>, idx: &Expr<'_>, var: HirId) -> Option<Offset> {
-    fn extract_offset<'tcx>(cx: &LateContext<'tcx>, e: &Expr<'_>, var: HirId) -> Option<String> {
+fn get_offset<'tcx>(cx: &LateContext<'tcx>, idx: &Expr<'_>, start: HirId) -> Option<Offset> {
+    fn extract_offset<'tcx>(cx: &LateContext<'tcx>, e: &Expr<'_>, start: HirId) -> Option<String> {
         match &e.kind {
             ExprKind::Lit(l) => match l.node {
                 ast::LitKind::Int(x, _ty) => Some(x.to_string()),
                 _ => None,
             },
-            ExprKind::Path(..) if !same_var(cx, e, var) => Some(snippet_opt(cx, e.span).unwrap_or_else(|| "??".into())),
+            ExprKind::Path(..) if !same_var(cx, e, start) => Some(snippet_opt(cx, e.span).unwrap_or_else(|| "??".into())),
             _ => None,
         }
     }
@@ -860,20 +860,20 @@ fn get_offset<'tcx>(cx: &LateContext<'tcx>, idx: &Expr<'_>, var: HirId) -> Optio
     match idx.kind {
         ExprKind::Binary(op, lhs, rhs) => match op.node {
             BinOpKind::Add => {
-                let offset_opt = if same_var(cx, lhs, var) {
-                    extract_offset(cx, rhs, var)
-                } else if same_var(cx, rhs, var) {
-                    extract_offset(cx, lhs, var)
+                let offset_opt = if same_var(cx, lhs, start) {
+                    extract_offset(cx, rhs, start)
+                } else if same_var(cx, rhs, start) {
+                    extract_offset(cx, lhs, start)
                 } else {
                     None
                 };
 
                 offset_opt.map(Offset::positive)
             },
-            BinOpKind::Sub if same_var(cx, lhs, var) => extract_offset(cx, rhs, var).map(Offset::negative),
+            BinOpKind::Sub if same_var(cx, lhs, start) => extract_offset(cx, rhs, start).map(Offset::negative),
             _ => None,
         },
-        ExprKind::Path(..) if same_var(cx, idx, var) => Some(Offset::positive("0".into())),
+        ExprKind::Path(..) if same_var(cx, idx, start) => Some(Offset::positive("0".into())),
         _ => None,
     }
 }
@@ -916,8 +916,8 @@ fn build_manual_memcpy_suggestion<'tcx>(
     start: &Expr<'_>,
     end: &Expr<'_>,
     limits: ast::RangeLimits,
-    dst_var: FixedOffsetVar<'_>,
-    src_var: FixedOffsetVar<'_>,
+    dst: IndexExpr<'_>,
+    src: IndexExpr<'_>,
 ) -> String {
     fn print_sum(arg1: &str, arg2: &Offset) -> String {
         match (arg1, &arg2.value[..], arg2.sign) {
@@ -944,13 +944,13 @@ fn build_manual_memcpy_suggestion<'tcx>(
         }
     }
 
-    let print_limit = |end: &Expr<'_>, offset: Offset, var: &Expr<'_>| {
+    let print_limit = |end: &Expr<'_>, offset: Offset, base: &Expr<'_>| {
         if_chain! {
             if let ExprKind::MethodCall(method, _, len_args, _) = end.kind;
             if method.ident.name == sym!(len);
             if len_args.len() == 1;
             if let Some(arg) = len_args.get(0);
-            if var_def_id(cx, arg) == var_def_id(cx, var);
+            if var_def_id(cx, arg) == var_def_id(cx, base);
             then {
                 match offset.sign {
                     OffsetSign::Negative => format!("({} - {})", snippet(cx, end.span, "<src>.len()"), offset.value),
@@ -971,25 +971,26 @@ fn build_manual_memcpy_suggestion<'tcx>(
     };
 
     let start_str = snippet(cx, start.span, "").to_string();
-    let dst_offset = print_offset(&start_str, &dst_var.offset);
-    let dst_limit = print_limit(end, dst_var.offset, dst_var.var);
-    let src_offset = print_offset(&start_str, &src_var.offset);
-    let src_limit = print_limit(end, src_var.offset, src_var.var);
+    let dst_offset = print_offset(&start_str, &dst.idx_offset);
+    let dst_limit = print_limit(end, dst.idx_offset, dst.base);
+    let src_offset = print_offset(&start_str, &src.idx_offset);
+    let src_limit = print_limit(end, src.idx_offset, src.base);
 
-    let dst_var_name = snippet_opt(cx, dst_var.var.span).unwrap_or_else(|| "???".into());
-    let src_var_name = snippet_opt(cx, src_var.var.span).unwrap_or_else(|| "???".into());
+    let dst_base_str = snippet_opt(cx, dst.base.span).unwrap_or_else(|| "???".into());
+    let src_base_str = snippet_opt(cx, src.base.span).unwrap_or_else(|| "???".into());
 
     let dst = if dst_offset == "" && dst_limit == "" {
-        dst_var_name
+        dst_base_str
     } else {
-        format!("{}[{}..{}]", dst_var_name, dst_offset, dst_limit)
+        format!("{}[{}..{}]", dst_base_str, dst_offset, dst_limit)
     };
 
     format!(
         "{}.clone_from_slice(&{}[{}..{}])",
-        dst, src_var_name, src_offset, src_limit
+        dst, src_base_str, src_offset, src_limit
     )
 }
+
 /// Checks for for loops that sequentially copy items from one slice-like
 /// object to another.
 fn detect_manual_memcpy<'tcx>(
@@ -1014,18 +1015,18 @@ fn detect_manual_memcpy<'tcx>(
                     o.and_then(|(lhs, rhs)| {
                         let rhs = fetch_cloned_expr(rhs);
                         if_chain! {
-                            if let ExprKind::Index(seqexpr_left, idx_left) = lhs.kind;
-                            if let ExprKind::Index(seqexpr_right, idx_right) = rhs.kind;
-                            if is_slice_like(cx, cx.typeck_results().expr_ty(seqexpr_left))
-                                && is_slice_like(cx, cx.typeck_results().expr_ty(seqexpr_right));
+                            if let ExprKind::Index(base_left, idx_left) = lhs.kind;
+                            if let ExprKind::Index(base_right, idx_right) = rhs.kind;
+                            if is_slice_like(cx, cx.typeck_results().expr_ty(base_left))
+                                && is_slice_like(cx, cx.typeck_results().expr_ty(base_right));
                             if let Some(offset_left) = get_offset(cx, &idx_left, canonical_id);
                             if let Some(offset_right) = get_offset(cx, &idx_right, canonical_id);
 
                             // Source and destination must be different
-                            if var_def_id(cx, seqexpr_left) != var_def_id(cx, seqexpr_right);
+                            if var_def_id(cx, base_left) != var_def_id(cx, base_right);
                             then {
-                                Some((FixedOffsetVar { var: seqexpr_left, offset: offset_left },
-                                    FixedOffsetVar { var: seqexpr_right, offset: offset_right }))
+                                Some((IndexExpr { base: base_left, idx_offset: offset_left },
+                                    IndexExpr { base: base_right, idx_offset: offset_right }))
                             } else {
                                 None
                             }
-- 
cgit 1.4.1-3-g733a5


From b4b4da162f19e9a4c63854a2b5a6167b83f9d8b9 Mon Sep 17 00:00:00 2001
From: rail <12975677+rail-rain@users.noreply.github.com>
Date: Wed, 10 Jun 2020 15:51:23 +1200
Subject: Introduce Start and StartKind

---
 clippy_lints/src/loops.rs | 67 +++++++++++++++++++++++++++++++++++++----------
 1 file changed, 53 insertions(+), 14 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index d9896f7fd6b..157dff59d44 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -818,13 +818,29 @@ impl Offset {
             sign: OffsetSign::Positive,
         }
     }
+
+    fn empty() -> Self {
+        Self::positive("0".into())
+    }
+}
+
+#[derive(Debug, Clone, Copy)]
+enum StartKind<'hir> {
+    Range,
+    Counter { initializer: &'hir Expr<'hir> },
 }
 
 struct IndexExpr<'hir> {
     base: &'hir Expr<'hir>,
+    idx: StartKind<'hir>,
     idx_offset: Offset,
 }
 
+struct Start<'hir> {
+    id: HirId,
+    kind: StartKind<'hir>,
+}
+
 fn is_slice_like<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'_>) -> bool {
     let is_slice = match ty.kind() {
         ty::Ref(_, subty, _) => is_slice_like(cx, subty),
@@ -845,14 +861,32 @@ fn fetch_cloned_expr<'tcx>(expr: &'tcx Expr<'tcx>) -> &'tcx Expr<'tcx> {
     }
 }
 
-fn get_offset<'tcx>(cx: &LateContext<'tcx>, idx: &Expr<'_>, start: HirId) -> Option<Offset> {
-    fn extract_offset<'tcx>(cx: &LateContext<'tcx>, e: &Expr<'_>, start: HirId) -> Option<String> {
+fn get_offset<'tcx>(
+    cx: &LateContext<'tcx>,
+    idx: &Expr<'_>,
+    starts: &[Start<'tcx>],
+) -> Option<(StartKind<'tcx>, Offset)> {
+    fn extract_start<'tcx>(
+        cx: &LateContext<'tcx>,
+        expr: &Expr<'_>,
+        starts: &[Start<'tcx>],
+    ) -> Option<StartKind<'tcx>> {
+        starts.iter().find(|var| same_var(cx, expr, var.id)).map(|v| v.kind)
+    }
+
+    fn extract_offset<'tcx>(
+        cx: &LateContext<'tcx>,
+        e: &Expr<'_>,
+        starts: &[Start<'tcx>],
+    ) -> Option<String> {
         match &e.kind {
             ExprKind::Lit(l) => match l.node {
                 ast::LitKind::Int(x, _ty) => Some(x.to_string()),
                 _ => None,
             },
-            ExprKind::Path(..) if !same_var(cx, e, start) => Some(snippet_opt(cx, e.span).unwrap_or_else(|| "??".into())),
+            ExprKind::Path(..) if extract_start(cx, e, starts).is_none() => {
+                Some(snippet_opt(cx, e.span).unwrap_or_else(|| "??".into()))
+            },
             _ => None,
         }
     }
@@ -860,20 +894,21 @@ fn get_offset<'tcx>(cx: &LateContext<'tcx>, idx: &Expr<'_>, start: HirId) -> Opt
     match idx.kind {
         ExprKind::Binary(op, lhs, rhs) => match op.node {
             BinOpKind::Add => {
-                let offset_opt = if same_var(cx, lhs, start) {
-                    extract_offset(cx, rhs, start)
-                } else if same_var(cx, rhs, start) {
-                    extract_offset(cx, lhs, start)
+                let offset_opt = if let Some(s) = extract_start(cx, lhs, starts) {
+                    extract_offset(cx, rhs, starts).map(|o| (s, o))
+                } else if let Some(s) = extract_start(cx, rhs, starts) {
+                    extract_offset(cx, lhs, starts).map(|o| (s, o))
                 } else {
                     None
                 };
 
-                offset_opt.map(Offset::positive)
+                offset_opt.map(|(s, o)| (s, Offset::positive(o)))
             },
-            BinOpKind::Sub if same_var(cx, lhs, start) => extract_offset(cx, rhs, start).map(Offset::negative),
+            BinOpKind::Sub => extract_start(cx, lhs, starts)
+                .and_then(|s| extract_offset(cx, rhs, starts).map(|o| (s, Offset::negative(o)))),
             _ => None,
         },
-        ExprKind::Path(..) if same_var(cx, idx, start) => Some(Offset::positive("0".into())),
+        ExprKind::Path(..) => extract_start(cx, idx, starts).map(|s| (s, Offset::empty())),
         _ => None,
     }
 }
@@ -1008,6 +1043,10 @@ fn detect_manual_memcpy<'tcx>(
     {
         // the var must be a single name
         if let PatKind::Binding(_, canonical_id, _, _) = pat.kind {
+            let mut starts = vec![Start {
+                id: canonical_id,
+                kind: StartKind::Range,
+            }];
             // The only statements in the for loops can be indexed assignments from
             // indexed retrievals.
             let big_sugg = get_assignments(body)
@@ -1019,14 +1058,14 @@ fn detect_manual_memcpy<'tcx>(
                             if let ExprKind::Index(base_right, idx_right) = rhs.kind;
                             if is_slice_like(cx, cx.typeck_results().expr_ty(base_left))
                                 && is_slice_like(cx, cx.typeck_results().expr_ty(base_right));
-                            if let Some(offset_left) = get_offset(cx, &idx_left, canonical_id);
-                            if let Some(offset_right) = get_offset(cx, &idx_right, canonical_id);
+                            if let Some((start_left, offset_left)) = get_offset(cx, &idx_left, &starts);
+                            if let Some((start_right, offset_right)) = get_offset(cx, &idx_right, &starts);
 
                             // Source and destination must be different
                             if var_def_id(cx, base_left) != var_def_id(cx, base_right);
                             then {
-                                Some((IndexExpr { base: base_left, idx_offset: offset_left },
-                                    IndexExpr { base: base_right, idx_offset: offset_right }))
+                                Some((IndexExpr { base: base_left, idx: start_left, idx_offset: offset_left },
+                                    IndexExpr { base: base_right, idx: start_right, idx_offset: offset_right }))
                             } else {
                                 None
                             }
-- 
cgit 1.4.1-3-g733a5


From 720f19f2ec4282f636889b35beabf31272e3b1b2 Mon Sep 17 00:00:00 2001
From: rail <12975677+rail-rain@users.noreply.github.com>
Date: Wed, 10 Jun 2020 15:58:12 +1200
Subject: Implement detecting `manual_memcpy` with loop counters

---
 clippy_lints/src/loops.rs | 90 ++++++++++++++++++++++++++++++++++-------------
 1 file changed, 66 insertions(+), 24 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 157dff59d44..c036d63c335 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -913,37 +913,62 @@ fn get_offset<'tcx>(
     }
 }
 
-fn get_assignments<'tcx>(body: &'tcx Expr<'tcx>) -> impl Iterator<Item = Option<(&'tcx Expr<'tcx>, &'tcx Expr<'tcx>)>> {
-    fn get_assignment<'tcx>(e: &'tcx Expr<'tcx>) -> Option<(&'tcx Expr<'tcx>, &'tcx Expr<'tcx>)> {
-        if let ExprKind::Assign(lhs, rhs, _) = e.kind {
-            Some((lhs, rhs))
-        } else {
-            None
-        }
+fn get_assignment<'tcx>(e: &'tcx Expr<'tcx>) -> Option<(&'tcx Expr<'tcx>, &'tcx Expr<'tcx>)> {
+    if let ExprKind::Assign(lhs, rhs, _) = e.kind {
+        Some((lhs, rhs))
+    } else {
+        None
     }
+}
 
-    // This is one of few ways to return different iterators
-    // derived from: https://stackoverflow.com/questions/29760668/conditionally-iterate-over-one-of-several-possible-iterators/52064434#52064434
-    let mut iter_a = None;
-    let mut iter_b = None;
+fn get_assignments<'a: 'c, 'tcx: 'c, 'c>(
+    cx: &'a LateContext<'a, 'tcx>,
+    stmts: &'tcx [Stmt<'tcx>],
+    expr: Option<&'tcx Expr<'tcx>>,
+    loop_counters: &'c [Start<'tcx>],
+) -> impl Iterator<Item = Option<(&'tcx Expr<'tcx>, &'tcx Expr<'tcx>)>> + 'c {
+    stmts
+        .iter()
+        .filter_map(move |stmt| match stmt.kind {
+            StmtKind::Local(..) | StmtKind::Item(..) => None,
+            StmtKind::Expr(e) | StmtKind::Semi(e) => if_chain! {
+                if let ExprKind::AssignOp(_, var, _) = e.kind;
+                // skip StartKind::Range
+                if loop_counters.iter().skip(1).any(|counter| Some(counter.id) == var_def_id(cx, var));
+                then { None } else { Some(e) }
+            },
+        })
+        .chain(expr.into_iter())
+        .map(get_assignment)
+}
 
-    if let ExprKind::Block(b, _) = body.kind {
-        let Block { stmts, expr, .. } = *b;
+fn get_loop_counters<'a, 'tcx>(
+    cx: &'a LateContext<'a, 'tcx>,
+    body: &'tcx Block<'tcx>,
+    expr: &'tcx Expr<'_>,
+) -> Option<impl Iterator<Item = Start<'tcx>> + 'a> {
+    // Look for variables that are incremented once per loop iteration.
+    let mut increment_visitor = IncrementVisitor::new(cx);
+    walk_block(&mut increment_visitor, body);
 
-        iter_a = stmts
-            .iter()
-            .filter_map(|stmt| match stmt.kind {
-                StmtKind::Local(..) | StmtKind::Item(..) => None,
-                StmtKind::Expr(e) | StmtKind::Semi(e) => Some(e),
+    // For each candidate, check the parent block to see if
+    // it's initialized to zero at the start of the loop.
+    if let Some(block) = get_enclosing_block(&cx, expr.hir_id) {
+        increment_visitor
+            .into_results()
+            .filter_map(move |var_id| {
+                let mut initialize_visitor = InitializeVisitor::new(cx, expr, var_id);
+                walk_block(&mut initialize_visitor, block);
+
+                initialize_visitor.get_result().map(|(_, initializer)| Start {
+                    id: var_id,
+                    kind: StartKind::Counter { initializer },
+                })
             })
-            .chain(expr.into_iter())
-            .map(get_assignment)
             .into()
     } else {
-        iter_b = Some(get_assignment(body))
+        None
     }
-
-    iter_a.into_iter().flatten().chain(iter_b.into_iter())
 }
 
 fn build_manual_memcpy_suggestion<'tcx>(
@@ -1047,9 +1072,26 @@ fn detect_manual_memcpy<'tcx>(
                 id: canonical_id,
                 kind: StartKind::Range,
             }];
+
+            // This is one of few ways to return different iterators
+            // derived from: https://stackoverflow.com/questions/29760668/conditionally-iterate-over-one-of-several-possible-iterators/52064434#52064434
+            let mut iter_a = None;
+            let mut iter_b = None;
+
+            if let ExprKind::Block(block, _) = body.kind {
+                if let Some(loop_counters) = get_loop_counters(cx, block, expr) {
+                    starts.extend(loop_counters);
+                }
+                iter_a = Some(get_assignments(cx, block.stmts, block.expr, &starts));
+            } else {
+                iter_b = Some(get_assignment(body));
+            }
+
             // The only statements in the for loops can be indexed assignments from
             // indexed retrievals.
-            let big_sugg = get_assignments(body)
+            let assignments = iter_a.into_iter().flatten().chain(iter_b.into_iter());
+
+            let big_sugg = assignments
                 .map(|o| {
                     o.and_then(|(lhs, rhs)| {
                         let rhs = fetch_cloned_expr(rhs);
-- 
cgit 1.4.1-3-g733a5


From de56279cd9047832216e1d1c06dc45375bf01b31 Mon Sep 17 00:00:00 2001
From: rail <12975677+rail-rain@users.noreply.github.com>
Date: Thu, 11 Jun 2020 11:06:13 +1200
Subject: Implement building the `manual_memcpy` sugggestion with loop counters

---
 clippy_lints/src/loops.rs      | 185 +++++++++++++++++++++++++++++++----------
 clippy_lints/src/utils/sugg.rs |  78 +++++++++++++++--
 2 files changed, 213 insertions(+), 50 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index c036d63c335..bd2ae47b723 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -800,19 +800,19 @@ enum OffsetSign {
 }
 
 struct Offset {
-    value: String,
+    value: MinifyingSugg<'static>,
     sign: OffsetSign,
 }
 
 impl Offset {
-    fn negative(value: String) -> Self {
+    fn negative(value: MinifyingSugg<'static>) -> Self {
         Self {
             value,
             sign: OffsetSign::Negative,
         }
     }
 
-    fn positive(value: String) -> Self {
+    fn positive(value: MinifyingSugg<'static>) -> Self {
         Self {
             value,
             sign: OffsetSign::Positive,
@@ -820,7 +820,88 @@ impl Offset {
     }
 
     fn empty() -> Self {
-        Self::positive("0".into())
+        Self::positive(MinifyingSugg::non_paren("0"))
+    }
+}
+
+fn apply_offset(lhs: &MinifyingSugg<'static>, rhs: &Offset) -> MinifyingSugg<'static> {
+    match rhs.sign {
+        OffsetSign::Positive => lhs + &rhs.value,
+        OffsetSign::Negative => lhs - &rhs.value,
+    }
+}
+
+#[derive(Clone)]
+struct MinifyingSugg<'a>(sugg::Sugg<'a>);
+
+impl std::fmt::Display for MinifyingSugg<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
+        std::fmt::Display::fmt(&self.0, f)
+    }
+}
+
+impl<'a> MinifyingSugg<'a> {
+    fn as_str(&self) -> &str {
+        let sugg::Sugg::NonParen(s) | sugg::Sugg::MaybeParen(s) | sugg::Sugg::BinOp(_, s) = &self.0;
+        s.as_ref()
+    }
+
+    fn hir(cx: &LateContext<'_, '_>, expr: &Expr<'_>, default: &'a str) -> Self {
+        Self(sugg::Sugg::hir(cx, expr, default))
+    }
+
+    fn maybe_par(self) -> Self {
+        Self(self.0.maybe_par())
+    }
+
+    fn non_paren(str: impl Into<std::borrow::Cow<'a, str>>) -> Self {
+        Self(sugg::Sugg::NonParen(str.into()))
+    }
+}
+
+impl std::ops::Add for &MinifyingSugg<'static> {
+    type Output = MinifyingSugg<'static>;
+    fn add(self, rhs: &MinifyingSugg<'static>) -> MinifyingSugg<'static> {
+        match (self.as_str(), rhs.as_str()) {
+            ("0", _) => rhs.clone(),
+            (_, "0") => self.clone(),
+            (_, _) => MinifyingSugg(&self.0 + &rhs.0),
+        }
+    }
+}
+
+impl std::ops::Sub for &MinifyingSugg<'static> {
+    type Output = MinifyingSugg<'static>;
+    fn sub(self, rhs: &MinifyingSugg<'static>) -> MinifyingSugg<'static> {
+        match (self.as_str(), rhs.as_str()) {
+            (_, "0") => self.clone(),
+            ("0", _) => MinifyingSugg(sugg::make_unop("-", rhs.0.clone())),
+            (x, y) if x == y => MinifyingSugg::non_paren("0"),
+            (_, _) => MinifyingSugg(&self.0 - &rhs.0),
+        }
+    }
+}
+
+impl std::ops::Add<&MinifyingSugg<'static>> for MinifyingSugg<'static> {
+    type Output = MinifyingSugg<'static>;
+    fn add(self, rhs: &MinifyingSugg<'static>) -> MinifyingSugg<'static> {
+        match (self.as_str(), rhs.as_str()) {
+            ("0", _) => rhs.clone(),
+            (_, "0") => self,
+            (_, _) => MinifyingSugg(self.0 + &rhs.0),
+        }
+    }
+}
+
+impl std::ops::Sub<&MinifyingSugg<'static>> for MinifyingSugg<'static> {
+    type Output = MinifyingSugg<'static>;
+    fn sub(self, rhs: &MinifyingSugg<'static>) -> MinifyingSugg<'static> {
+        match (self.as_str(), rhs.as_str()) {
+            (_, "0") => self,
+            ("0", _) => MinifyingSugg(sugg::make_unop("-", rhs.0.clone())),
+            (x, y) if x == y => MinifyingSugg::non_paren("0"),
+            (_, _) => MinifyingSugg(self.0 - &rhs.0),
+        }
     }
 }
 
@@ -878,14 +959,15 @@ fn get_offset<'tcx>(
         cx: &LateContext<'tcx>,
         e: &Expr<'_>,
         starts: &[Start<'tcx>],
-    ) -> Option<String> {
+    ) -> Option<MinifyingSugg<'static>> {
         match &e.kind {
             ExprKind::Lit(l) => match l.node {
-                ast::LitKind::Int(x, _ty) => Some(x.to_string()),
+                ast::LitKind::Int(x, _ty) => Some(MinifyingSugg::non_paren(x.to_string())),
                 _ => None,
             },
             ExprKind::Path(..) if extract_start(cx, e, starts).is_none() => {
-                Some(snippet_opt(cx, e.span).unwrap_or_else(|| "??".into()))
+                // `e` is always non paren as it's a `Path`
+                Some(MinifyingSugg::non_paren(snippet(cx, e.span, "???")))
             },
             _ => None,
         }
@@ -979,32 +1061,15 @@ fn build_manual_memcpy_suggestion<'tcx>(
     dst: IndexExpr<'_>,
     src: IndexExpr<'_>,
 ) -> String {
-    fn print_sum(arg1: &str, arg2: &Offset) -> String {
-        match (arg1, &arg2.value[..], arg2.sign) {
-            ("0", "0", _) => "0".into(),
-            ("0", x, OffsetSign::Positive) | (x, "0", _) => x.into(),
-            ("0", x, OffsetSign::Negative) => format!("-{}", x),
-            (x, y, OffsetSign::Positive) => format!("({} + {})", x, y),
-            (x, y, OffsetSign::Negative) => {
-                if x == y {
-                    "0".into()
-                } else {
-                    format!("({} - {})", x, y)
-                }
-            },
-        }
-    }
-
-    fn print_offset(start_str: &str, inline_offset: &Offset) -> String {
-        let offset = print_sum(start_str, inline_offset);
+    fn print_offset(offset: MinifyingSugg<'static>) -> MinifyingSugg<'static> {
         if offset.as_str() == "0" {
-            "".into()
+            MinifyingSugg::non_paren("")
         } else {
             offset
         }
     }
 
-    let print_limit = |end: &Expr<'_>, offset: Offset, base: &Expr<'_>| {
+    let print_limit = |end: &Expr<'_>, end_str: &str, base: &Expr<'_>, sugg: MinifyingSugg<'static>| -> MinifyingSugg<'static> {
         if_chain! {
             if let ExprKind::MethodCall(method, _, len_args, _) = end.kind;
             if method.ident.name == sym!(len);
@@ -1012,42 +1077,72 @@ fn build_manual_memcpy_suggestion<'tcx>(
             if let Some(arg) = len_args.get(0);
             if var_def_id(cx, arg) == var_def_id(cx, base);
             then {
-                match offset.sign {
-                    OffsetSign::Negative => format!("({} - {})", snippet(cx, end.span, "<src>.len()"), offset.value),
-                    OffsetSign::Positive => "".into(),
+                if sugg.as_str() == end_str {
+                    MinifyingSugg::non_paren("")
+                } else {
+                    sugg
                 }
             } else {
-                let end_str = match limits {
+                match limits {
                     ast::RangeLimits::Closed => {
-                        let end = sugg::Sugg::hir(cx, end, "<count>");
-                        format!("{}", end + sugg::ONE)
+                        sugg + &MinifyingSugg::non_paren("1")
                     },
-                    ast::RangeLimits::HalfOpen => format!("{}", snippet(cx, end.span, "..")),
-                };
-
-                print_sum(&end_str, &offset)
+                    ast::RangeLimits::HalfOpen => sugg,
+                }
             }
         }
     };
 
-    let start_str = snippet(cx, start.span, "").to_string();
-    let dst_offset = print_offset(&start_str, &dst.idx_offset);
-    let dst_limit = print_limit(end, dst.idx_offset, dst.base);
-    let src_offset = print_offset(&start_str, &src.idx_offset);
-    let src_limit = print_limit(end, src.idx_offset, src.base);
+    let start_str = MinifyingSugg::hir(cx, start, "");
+    let end_str = MinifyingSugg::hir(cx, end, "");
+
+    let print_offset_and_limit = |idx_expr: &IndexExpr<'_>| match idx_expr.idx {
+        StartKind::Range => (
+            print_offset(apply_offset(&start_str, &idx_expr.idx_offset)),
+            print_limit(
+                end,
+                end_str.as_str(),
+                idx_expr.base,
+                apply_offset(&end_str, &idx_expr.idx_offset),
+            ),
+        ),
+        StartKind::Counter { initializer } => {
+            let counter_start = MinifyingSugg::hir(cx, initializer, "");
+            (
+                print_offset(apply_offset(&counter_start, &idx_expr.idx_offset)),
+                print_limit(
+                    end,
+                    end_str.as_str(),
+                    idx_expr.base,
+                    apply_offset(&end_str, &idx_expr.idx_offset) + &counter_start - &start_str,
+                ),
+            )
+        },
+    };
+
+    let (dst_offset, dst_limit) = print_offset_and_limit(&dst);
+    let (src_offset, src_limit) = print_offset_and_limit(&src);
 
     let dst_base_str = snippet_opt(cx, dst.base.span).unwrap_or_else(|| "???".into());
     let src_base_str = snippet_opt(cx, src.base.span).unwrap_or_else(|| "???".into());
 
-    let dst = if dst_offset == "" && dst_limit == "" {
+    let dst = if dst_offset.as_str() == "" && dst_limit.as_str() == "" {
         dst_base_str
     } else {
-        format!("{}[{}..{}]", dst_base_str, dst_offset, dst_limit)
+        format!(
+            "{}[{}..{}]",
+            dst_base_str,
+            dst_offset.maybe_par(),
+            dst_limit.maybe_par()
+        )
     };
 
     format!(
         "{}.clone_from_slice(&{}[{}..{}])",
-        dst, src_base_str, src_offset, src_limit
+        dst,
+        src_base_str,
+        src_offset.maybe_par(),
+        src_limit.maybe_par()
     )
 }
 
diff --git a/clippy_lints/src/utils/sugg.rs b/clippy_lints/src/utils/sugg.rs
index ec8b7e59b59..50d48650a09 100644
--- a/clippy_lints/src/utils/sugg.rs
+++ b/clippy_lints/src/utils/sugg.rs
@@ -36,6 +36,46 @@ impl Display for Sugg<'_> {
     }
 }
 
+// It's impossible to derive Clone due to the lack of the impl Clone for AssocOp
+impl Clone for Sugg<'_> {
+    fn clone(&self) -> Self {
+        /// manually cloning AssocOp
+        fn clone_assoc_op(this: &AssocOp) -> AssocOp {
+            match this {
+                AssocOp::Add => AssocOp::Add,
+                AssocOp::Subtract => AssocOp::Subtract,
+                AssocOp::Multiply => AssocOp::Multiply,
+                AssocOp::Divide => AssocOp::Divide,
+                AssocOp::Modulus => AssocOp::Modulus,
+                AssocOp::LAnd => AssocOp::LAnd,
+                AssocOp::LOr => AssocOp::LOr,
+                AssocOp::BitXor => AssocOp::BitXor,
+                AssocOp::BitAnd => AssocOp::BitAnd,
+                AssocOp::BitOr => AssocOp::BitOr,
+                AssocOp::ShiftLeft => AssocOp::ShiftLeft,
+                AssocOp::ShiftRight => AssocOp::ShiftRight,
+                AssocOp::Equal => AssocOp::Equal,
+                AssocOp::Less => AssocOp::Less,
+                AssocOp::LessEqual => AssocOp::LessEqual,
+                AssocOp::NotEqual => AssocOp::NotEqual,
+                AssocOp::Greater => AssocOp::Greater,
+                AssocOp::GreaterEqual => AssocOp::GreaterEqual,
+                AssocOp::Assign => AssocOp::Assign,
+                AssocOp::AssignOp(t) => AssocOp::AssignOp(*t),
+                AssocOp::As => AssocOp::As,
+                AssocOp::DotDot => AssocOp::DotDot,
+                AssocOp::DotDotEq => AssocOp::DotDotEq,
+                AssocOp::Colon => AssocOp::Colon,
+            }
+        }
+        match self {
+            Sugg::NonParen(x) => Sugg::NonParen(x.clone()),
+            Sugg::MaybeParen(x) => Sugg::MaybeParen(x.clone()),
+            Sugg::BinOp(op, x) => Sugg::BinOp(clone_assoc_op(op), x.clone()),
+        }
+    }
+}
+
 #[allow(clippy::wrong_self_convention)] // ok, because of the function `as_ty` method
 impl<'a> Sugg<'a> {
     /// Prepare a suggestion from an expression.
@@ -267,21 +307,49 @@ impl<'a> Sugg<'a> {
     }
 }
 
-impl<'a, 'b> std::ops::Add<Sugg<'b>> for Sugg<'a> {
+impl std::ops::Add for Sugg<'_> {
     type Output = Sugg<'static>;
-    fn add(self, rhs: Sugg<'b>) -> Sugg<'static> {
+    fn add(self, rhs: Sugg<'_>) -> Sugg<'static> {
         make_binop(ast::BinOpKind::Add, &self, &rhs)
     }
 }
 
-impl<'a, 'b> std::ops::Sub<Sugg<'b>> for Sugg<'a> {
+impl std::ops::Sub for Sugg<'_> {
     type Output = Sugg<'static>;
-    fn sub(self, rhs: Sugg<'b>) -> Sugg<'static> {
+    fn sub(self, rhs: Sugg<'_>) -> Sugg<'static> {
         make_binop(ast::BinOpKind::Sub, &self, &rhs)
     }
 }
 
-impl<'a> std::ops::Not for Sugg<'a> {
+impl std::ops::Add<&Sugg<'_>> for Sugg<'_> {
+    type Output = Sugg<'static>;
+    fn add(self, rhs: &Sugg<'_>) -> Sugg<'static> {
+        make_binop(ast::BinOpKind::Add, &self, rhs)
+    }
+}
+
+impl std::ops::Sub<&Sugg<'_>> for Sugg<'_> {
+    type Output = Sugg<'static>;
+    fn sub(self, rhs: &Sugg<'_>) -> Sugg<'static> {
+        make_binop(ast::BinOpKind::Sub, &self, rhs)
+    }
+}
+
+impl std::ops::Add for &Sugg<'_> {
+    type Output = Sugg<'static>;
+    fn add(self, rhs: &Sugg<'_>) -> Sugg<'static> {
+        make_binop(ast::BinOpKind::Add, self, rhs)
+    }
+}
+
+impl std::ops::Sub for &Sugg<'_> {
+    type Output = Sugg<'static>;
+    fn sub(self, rhs: &Sugg<'_>) -> Sugg<'static> {
+        make_binop(ast::BinOpKind::Sub, self, rhs)
+    }
+}
+
+impl std::ops::Not for Sugg<'_> {
     type Output = Sugg<'static>;
     fn not(self) -> Sugg<'static> {
         make_unop("!", self)
-- 
cgit 1.4.1-3-g733a5


From 8da6cfd17b7707d678d01a6688572169015ea83e Mon Sep 17 00:00:00 2001
From: rail <12975677+rail-rain@users.noreply.github.com>
Date: Thu, 11 Jun 2020 12:11:06 +1200
Subject: fmt

---
 clippy_lints/src/loops.rs | 41 +++++++++++++++++++++--------------------
 1 file changed, 21 insertions(+), 20 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index bd2ae47b723..2aee3b93e82 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -1069,29 +1069,30 @@ fn build_manual_memcpy_suggestion<'tcx>(
         }
     }
 
-    let print_limit = |end: &Expr<'_>, end_str: &str, base: &Expr<'_>, sugg: MinifyingSugg<'static>| -> MinifyingSugg<'static> {
-        if_chain! {
-            if let ExprKind::MethodCall(method, _, len_args, _) = end.kind;
-            if method.ident.name == sym!(len);
-            if len_args.len() == 1;
-            if let Some(arg) = len_args.get(0);
-            if var_def_id(cx, arg) == var_def_id(cx, base);
-            then {
-                if sugg.as_str() == end_str {
-                    MinifyingSugg::non_paren("")
+    let print_limit =
+        |end: &Expr<'_>, end_str: &str, base: &Expr<'_>, sugg: MinifyingSugg<'static>| -> MinifyingSugg<'static> {
+            if_chain! {
+                if let ExprKind::MethodCall(method, _, len_args, _) = end.kind;
+                if method.ident.name == sym!(len);
+                if len_args.len() == 1;
+                if let Some(arg) = len_args.get(0);
+                if var_def_id(cx, arg) == var_def_id(cx, base);
+                then {
+                    if sugg.as_str() == end_str {
+                        MinifyingSugg::non_paren("")
+                    } else {
+                        sugg
+                    }
                 } else {
-                    sugg
-                }
-            } else {
-                match limits {
-                    ast::RangeLimits::Closed => {
-                        sugg + &MinifyingSugg::non_paren("1")
-                    },
-                    ast::RangeLimits::HalfOpen => sugg,
+                    match limits {
+                        ast::RangeLimits::Closed => {
+                            sugg + &MinifyingSugg::non_paren("1")
+                        },
+                        ast::RangeLimits::HalfOpen => sugg,
+                    }
                 }
             }
-        }
-    };
+        };
 
     let start_str = MinifyingSugg::hir(cx, start, "");
     let end_str = MinifyingSugg::hir(cx, end, "");
-- 
cgit 1.4.1-3-g733a5


From d9a88be0b05c2cfec0679caf428d129c9d46256d Mon Sep 17 00:00:00 2001
From: rail <12975677+rail-rain@users.noreply.github.com>
Date: Thu, 18 Jun 2020 10:24:12 +1200
Subject: Rename `get_offset` and its private items

---
 clippy_lints/src/loops.rs | 31 ++++++++++++++++---------------
 1 file changed, 16 insertions(+), 15 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 2aee3b93e82..98c411f5ae6 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -942,20 +942,20 @@ fn fetch_cloned_expr<'tcx>(expr: &'tcx Expr<'tcx>) -> &'tcx Expr<'tcx> {
     }
 }
 
-fn get_offset<'tcx>(
+fn get_details_from_idx<'tcx>(
     cx: &LateContext<'tcx>,
     idx: &Expr<'_>,
     starts: &[Start<'tcx>],
 ) -> Option<(StartKind<'tcx>, Offset)> {
-    fn extract_start<'tcx>(
+    fn get_start<'tcx>(
         cx: &LateContext<'tcx>,
-        expr: &Expr<'_>,
+        e: &Expr<'_>,
         starts: &[Start<'tcx>],
     ) -> Option<StartKind<'tcx>> {
-        starts.iter().find(|var| same_var(cx, expr, var.id)).map(|v| v.kind)
+        starts.iter().find(|var| same_var(cx, e, var.id)).map(|v| v.kind)
     }
 
-    fn extract_offset<'tcx>(
+    fn get_offset<'tcx>(
         cx: &LateContext<'tcx>,
         e: &Expr<'_>,
         starts: &[Start<'tcx>],
@@ -965,7 +965,7 @@ fn get_offset<'tcx>(
                 ast::LitKind::Int(x, _ty) => Some(MinifyingSugg::non_paren(x.to_string())),
                 _ => None,
             },
-            ExprKind::Path(..) if extract_start(cx, e, starts).is_none() => {
+            ExprKind::Path(..) if get_start(cx, e, starts).is_none() => {
                 // `e` is always non paren as it's a `Path`
                 Some(MinifyingSugg::non_paren(snippet(cx, e.span, "???")))
             },
@@ -976,21 +976,22 @@ fn get_offset<'tcx>(
     match idx.kind {
         ExprKind::Binary(op, lhs, rhs) => match op.node {
             BinOpKind::Add => {
-                let offset_opt = if let Some(s) = extract_start(cx, lhs, starts) {
-                    extract_offset(cx, rhs, starts).map(|o| (s, o))
-                } else if let Some(s) = extract_start(cx, rhs, starts) {
-                    extract_offset(cx, lhs, starts).map(|o| (s, o))
+                let offset_opt = if let Some(s) = get_start(cx, lhs, starts) {
+                    get_offset(cx, rhs, starts).map(|o| (s, o))
+                } else if let Some(s) = get_start(cx, rhs, starts) {
+                    get_offset(cx, lhs, starts).map(|o| (s, o))
                 } else {
                     None
                 };
 
                 offset_opt.map(|(s, o)| (s, Offset::positive(o)))
             },
-            BinOpKind::Sub => extract_start(cx, lhs, starts)
-                .and_then(|s| extract_offset(cx, rhs, starts).map(|o| (s, Offset::negative(o)))),
+            BinOpKind::Sub => {
+                get_start(cx, lhs, starts).and_then(|s| get_offset(cx, rhs, starts).map(|o| (s, Offset::negative(o))))
+            },
             _ => None,
         },
-        ExprKind::Path(..) => extract_start(cx, idx, starts).map(|s| (s, Offset::empty())),
+        ExprKind::Path(..) => get_start(cx, idx, starts).map(|s| (s, Offset::empty())),
         _ => None,
     }
 }
@@ -1196,8 +1197,8 @@ fn detect_manual_memcpy<'tcx>(
                             if let ExprKind::Index(base_right, idx_right) = rhs.kind;
                             if is_slice_like(cx, cx.typeck_results().expr_ty(base_left))
                                 && is_slice_like(cx, cx.typeck_results().expr_ty(base_right));
-                            if let Some((start_left, offset_left)) = get_offset(cx, &idx_left, &starts);
-                            if let Some((start_right, offset_right)) = get_offset(cx, &idx_right, &starts);
+                            if let Some((start_left, offset_left)) = get_details_from_idx(cx, &idx_left, &starts);
+                            if let Some((start_right, offset_right)) = get_details_from_idx(cx, &idx_right, &starts);
 
                             // Source and destination must be different
                             if var_def_id(cx, base_left) != var_def_id(cx, base_right);
-- 
cgit 1.4.1-3-g733a5


From eb3ffe6ed2999e9d3385be0ff981e30082ea0d2c Mon Sep 17 00:00:00 2001
From: rail <12975677+rail-rain@users.noreply.github.com>
Date: Tue, 23 Jun 2020 18:51:05 +1200
Subject: make use of macros in operator overloading

---
 clippy_lints/src/utils/sugg.rs | 55 +++++++++++++++++++++++-------------------
 1 file changed, 30 insertions(+), 25 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/sugg.rs b/clippy_lints/src/utils/sugg.rs
index 50d48650a09..aada4122e78 100644
--- a/clippy_lints/src/utils/sugg.rs
+++ b/clippy_lints/src/utils/sugg.rs
@@ -13,6 +13,7 @@ use rustc_span::{BytePos, Pos};
 use std::borrow::Cow;
 use std::convert::TryInto;
 use std::fmt::Display;
+use std::ops::{Add, Sub, Not};
 
 /// A helper type to build suggestion correctly handling parenthesis.
 pub enum Sugg<'a> {
@@ -307,49 +308,53 @@ impl<'a> Sugg<'a> {
     }
 }
 
-impl std::ops::Add for Sugg<'_> {
-    type Output = Sugg<'static>;
-    fn add(self, rhs: Sugg<'_>) -> Sugg<'static> {
-        make_binop(ast::BinOpKind::Add, &self, &rhs)
-    }
-}
+// Copied from the rust standart library, and then edited
+macro_rules! forward_binop_impls_to_ref {
+    (impl $imp:ident, $method:ident for $t:ty, type Output = $o:ty) => {
+        impl $imp<$t> for &$t {
+            type Output = $o;
 
-impl std::ops::Sub for Sugg<'_> {
-    type Output = Sugg<'static>;
-    fn sub(self, rhs: Sugg<'_>) -> Sugg<'static> {
-        make_binop(ast::BinOpKind::Sub, &self, &rhs)
-    }
-}
+            fn $method(self, other: $t) -> $o {
+                $imp::$method(self, &other)
+            }
+        }
 
-impl std::ops::Add<&Sugg<'_>> for Sugg<'_> {
-    type Output = Sugg<'static>;
-    fn add(self, rhs: &Sugg<'_>) -> Sugg<'static> {
-        make_binop(ast::BinOpKind::Add, &self, rhs)
-    }
-}
+        impl $imp<&$t> for $t {
+            type Output = $o;
 
-impl std::ops::Sub<&Sugg<'_>> for Sugg<'_> {
-    type Output = Sugg<'static>;
-    fn sub(self, rhs: &Sugg<'_>) -> Sugg<'static> {
-        make_binop(ast::BinOpKind::Sub, &self, rhs)
+            fn $method(self, other: &$t) -> $o {
+                $imp::$method(&self, other)
+            }
+        }
+
+        impl $imp for $t {
+            type Output = $o;
+
+            fn $method(self, other: $t) -> $o {
+                $imp::$method(&self, &other)
+            }
+        }
     }
 }
 
-impl std::ops::Add for &Sugg<'_> {
+impl Add for &Sugg<'_> {
     type Output = Sugg<'static>;
     fn add(self, rhs: &Sugg<'_>) -> Sugg<'static> {
         make_binop(ast::BinOpKind::Add, self, rhs)
     }
 }
 
-impl std::ops::Sub for &Sugg<'_> {
+impl Sub for &Sugg<'_> {
     type Output = Sugg<'static>;
     fn sub(self, rhs: &Sugg<'_>) -> Sugg<'static> {
         make_binop(ast::BinOpKind::Sub, self, rhs)
     }
 }
 
-impl std::ops::Not for Sugg<'_> {
+forward_binop_impls_to_ref!(impl Add, add for Sugg<'_>, type Output = Sugg<'static>);
+forward_binop_impls_to_ref!(impl Sub, sub for Sugg<'_>, type Output = Sugg<'static>);
+
+impl Not for Sugg<'_> {
     type Output = Sugg<'static>;
     fn not(self) -> Sugg<'static> {
         make_unop("!", self)
-- 
cgit 1.4.1-3-g733a5


From 10d7a18f72155f03dbd27b872a52b5dd45def8db Mon Sep 17 00:00:00 2001
From: rail <12975677+rail-rain@users.noreply.github.com>
Date: Tue, 23 Jun 2020 22:37:36 +1200
Subject: fmt

---
 clippy_lints/src/utils/sugg.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/sugg.rs b/clippy_lints/src/utils/sugg.rs
index aada4122e78..8f2aa724d20 100644
--- a/clippy_lints/src/utils/sugg.rs
+++ b/clippy_lints/src/utils/sugg.rs
@@ -13,7 +13,7 @@ use rustc_span::{BytePos, Pos};
 use std::borrow::Cow;
 use std::convert::TryInto;
 use std::fmt::Display;
-use std::ops::{Add, Sub, Not};
+use std::ops::{Add, Not, Sub};
 
 /// A helper type to build suggestion correctly handling parenthesis.
 pub enum Sugg<'a> {
@@ -334,7 +334,7 @@ macro_rules! forward_binop_impls_to_ref {
                 $imp::$method(&self, &other)
             }
         }
-    }
+    };
 }
 
 impl Add for &Sugg<'_> {
-- 
cgit 1.4.1-3-g733a5


From 44187383f4724bd7e4b2b220235e93438043947a Mon Sep 17 00:00:00 2001
From: rail <12975677+rail-rain@users.noreply.github.com>
Date: Wed, 24 Jun 2020 12:41:46 +1200
Subject: Use operator overloading instead of direct calls of `make_binop`

---
 clippy_lints/src/loops.rs      | 4 ++--
 clippy_lints/src/utils/sugg.rs | 9 ++++++++-
 2 files changed, 10 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 98c411f5ae6..5928d12f30b 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -875,7 +875,7 @@ impl std::ops::Sub for &MinifyingSugg<'static> {
     fn sub(self, rhs: &MinifyingSugg<'static>) -> MinifyingSugg<'static> {
         match (self.as_str(), rhs.as_str()) {
             (_, "0") => self.clone(),
-            ("0", _) => MinifyingSugg(sugg::make_unop("-", rhs.0.clone())),
+            ("0", _) => MinifyingSugg(-(rhs.0.clone())),
             (x, y) if x == y => MinifyingSugg::non_paren("0"),
             (_, _) => MinifyingSugg(&self.0 - &rhs.0),
         }
@@ -898,7 +898,7 @@ impl std::ops::Sub<&MinifyingSugg<'static>> for MinifyingSugg<'static> {
     fn sub(self, rhs: &MinifyingSugg<'static>) -> MinifyingSugg<'static> {
         match (self.as_str(), rhs.as_str()) {
             (_, "0") => self,
-            ("0", _) => MinifyingSugg(sugg::make_unop("-", rhs.0.clone())),
+            ("0", _) => MinifyingSugg(-(rhs.0.clone())),
             (x, y) if x == y => MinifyingSugg::non_paren("0"),
             (_, _) => MinifyingSugg(self.0 - &rhs.0),
         }
diff --git a/clippy_lints/src/utils/sugg.rs b/clippy_lints/src/utils/sugg.rs
index 8f2aa724d20..1f448f86d72 100644
--- a/clippy_lints/src/utils/sugg.rs
+++ b/clippy_lints/src/utils/sugg.rs
@@ -13,7 +13,7 @@ use rustc_span::{BytePos, Pos};
 use std::borrow::Cow;
 use std::convert::TryInto;
 use std::fmt::Display;
-use std::ops::{Add, Not, Sub};
+use std::ops::{Add, Neg, Not, Sub};
 
 /// A helper type to build suggestion correctly handling parenthesis.
 pub enum Sugg<'a> {
@@ -354,6 +354,13 @@ impl Sub for &Sugg<'_> {
 forward_binop_impls_to_ref!(impl Add, add for Sugg<'_>, type Output = Sugg<'static>);
 forward_binop_impls_to_ref!(impl Sub, sub for Sugg<'_>, type Output = Sugg<'static>);
 
+impl Neg for Sugg<'_> {
+    type Output = Sugg<'static>;
+    fn neg(self) -> Sugg<'static> {
+        make_unop("-", self)
+    }
+}
+
 impl Not for Sugg<'_> {
     type Output = Sugg<'static>;
     fn not(self) -> Sugg<'static> {
-- 
cgit 1.4.1-3-g733a5


From f410df3c4810e80b6703dcfdbc4d48f812eb4889 Mon Sep 17 00:00:00 2001
From: rail <12975677+rail-rain@users.noreply.github.com>
Date: Sat, 27 Jun 2020 18:56:38 +1200
Subject: make clippy happy (`needless_pass_by_value`, `filter_map` and
 `find_map`)

---
 clippy_lints/src/loops.rs | 25 +++++++++++++++++--------
 1 file changed, 17 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 5928d12f30b..f684e7de8f8 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -952,7 +952,13 @@ fn get_details_from_idx<'tcx>(
         e: &Expr<'_>,
         starts: &[Start<'tcx>],
     ) -> Option<StartKind<'tcx>> {
-        starts.iter().find(|var| same_var(cx, e, var.id)).map(|v| v.kind)
+        starts.iter().find_map(|start| {
+            if same_var(cx, e, start.id) {
+                Some(start.kind)
+            } else {
+                None
+            }
+        })
     }
 
     fn get_offset<'tcx>(
@@ -1059,8 +1065,8 @@ fn build_manual_memcpy_suggestion<'tcx>(
     start: &Expr<'_>,
     end: &Expr<'_>,
     limits: ast::RangeLimits,
-    dst: IndexExpr<'_>,
-    src: IndexExpr<'_>,
+    dst: &IndexExpr<'_>,
+    src: &IndexExpr<'_>,
 ) -> String {
     fn print_offset(offset: MinifyingSugg<'static>) -> MinifyingSugg<'static> {
         if offset.as_str() == "0" {
@@ -1211,7 +1217,7 @@ fn detect_manual_memcpy<'tcx>(
                         }
                     })
                 })
-                .map(|o| o.map(|(dst, src)| build_manual_memcpy_suggestion(cx, start, end, limits, dst, src)))
+                .map(|o| o.map(|(dst, src)| build_manual_memcpy_suggestion(cx, start, end, limits, &dst, &src)))
                 .collect::<Option<Vec<_>>>()
                 .filter(|v| !v.is_empty())
                 .map(|v| v.join("\n    "));
@@ -2319,10 +2325,13 @@ impl<'a, 'tcx> IncrementVisitor<'a, 'tcx> {
     }
 
     fn into_results(self) -> impl Iterator<Item = HirId> {
-        self.states
-            .into_iter()
-            .filter(|(_, state)| *state == IncrementVisitorVarState::IncrOnce)
-            .map(|(id, _)| id)
+        self.states.into_iter().filter_map(|(id, state)| {
+            if state == IncrementVisitorVarState::IncrOnce {
+                Some(id)
+            } else {
+                None
+            }
+        })
     }
 }
 
-- 
cgit 1.4.1-3-g733a5


From ce653d65a8f08d785c5061e26570b4e59372e325 Mon Sep 17 00:00:00 2001
From: rail <12975677+rail-rain@users.noreply.github.com>
Date: Wed, 1 Jul 2020 12:22:16 +1200
Subject: use `#[derive]` instead of the manual implementation

---
 clippy_lints/src/utils/sugg.rs | 41 +----------------------------------------
 1 file changed, 1 insertion(+), 40 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/sugg.rs b/clippy_lints/src/utils/sugg.rs
index 1f448f86d72..062b273c0f4 100644
--- a/clippy_lints/src/utils/sugg.rs
+++ b/clippy_lints/src/utils/sugg.rs
@@ -16,6 +16,7 @@ use std::fmt::Display;
 use std::ops::{Add, Neg, Not, Sub};
 
 /// A helper type to build suggestion correctly handling parenthesis.
+#[derive(Clone)]
 pub enum Sugg<'a> {
     /// An expression that never needs parenthesis such as `1337` or `[0; 42]`.
     NonParen(Cow<'a, str>),
@@ -37,46 +38,6 @@ impl Display for Sugg<'_> {
     }
 }
 
-// It's impossible to derive Clone due to the lack of the impl Clone for AssocOp
-impl Clone for Sugg<'_> {
-    fn clone(&self) -> Self {
-        /// manually cloning AssocOp
-        fn clone_assoc_op(this: &AssocOp) -> AssocOp {
-            match this {
-                AssocOp::Add => AssocOp::Add,
-                AssocOp::Subtract => AssocOp::Subtract,
-                AssocOp::Multiply => AssocOp::Multiply,
-                AssocOp::Divide => AssocOp::Divide,
-                AssocOp::Modulus => AssocOp::Modulus,
-                AssocOp::LAnd => AssocOp::LAnd,
-                AssocOp::LOr => AssocOp::LOr,
-                AssocOp::BitXor => AssocOp::BitXor,
-                AssocOp::BitAnd => AssocOp::BitAnd,
-                AssocOp::BitOr => AssocOp::BitOr,
-                AssocOp::ShiftLeft => AssocOp::ShiftLeft,
-                AssocOp::ShiftRight => AssocOp::ShiftRight,
-                AssocOp::Equal => AssocOp::Equal,
-                AssocOp::Less => AssocOp::Less,
-                AssocOp::LessEqual => AssocOp::LessEqual,
-                AssocOp::NotEqual => AssocOp::NotEqual,
-                AssocOp::Greater => AssocOp::Greater,
-                AssocOp::GreaterEqual => AssocOp::GreaterEqual,
-                AssocOp::Assign => AssocOp::Assign,
-                AssocOp::AssignOp(t) => AssocOp::AssignOp(*t),
-                AssocOp::As => AssocOp::As,
-                AssocOp::DotDot => AssocOp::DotDot,
-                AssocOp::DotDotEq => AssocOp::DotDotEq,
-                AssocOp::Colon => AssocOp::Colon,
-            }
-        }
-        match self {
-            Sugg::NonParen(x) => Sugg::NonParen(x.clone()),
-            Sugg::MaybeParen(x) => Sugg::MaybeParen(x.clone()),
-            Sugg::BinOp(op, x) => Sugg::BinOp(clone_assoc_op(op), x.clone()),
-        }
-    }
-}
-
 #[allow(clippy::wrong_self_convention)] // ok, because of the function `as_ty` method
 impl<'a> Sugg<'a> {
     /// Prepare a suggestion from an expression.
-- 
cgit 1.4.1-3-g733a5


From e855fe3620c0a6981a4238df548fa5c2f36a24c9 Mon Sep 17 00:00:00 2001
From: rail <12975677+rail-rain@users.noreply.github.com>
Date: Sun, 16 Aug 2020 14:01:56 +1200
Subject: Reflect the changes that has been made and fmt

---
 clippy_lints/src/loops.rs | 45 ++++++++++++++++++---------------------------
 1 file changed, 18 insertions(+), 27 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index f684e7de8f8..4ff567ffb0e 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -846,7 +846,7 @@ impl<'a> MinifyingSugg<'a> {
         s.as_ref()
     }
 
-    fn hir(cx: &LateContext<'_, '_>, expr: &Expr<'_>, default: &'a str) -> Self {
+    fn hir(cx: &LateContext<'_>, expr: &Expr<'_>, default: &'a str) -> Self {
         Self(sugg::Sugg::hir(cx, expr, default))
     }
 
@@ -947,11 +947,7 @@ fn get_details_from_idx<'tcx>(
     idx: &Expr<'_>,
     starts: &[Start<'tcx>],
 ) -> Option<(StartKind<'tcx>, Offset)> {
-    fn get_start<'tcx>(
-        cx: &LateContext<'tcx>,
-        e: &Expr<'_>,
-        starts: &[Start<'tcx>],
-    ) -> Option<StartKind<'tcx>> {
+    fn get_start<'tcx>(cx: &LateContext<'tcx>, e: &Expr<'_>, starts: &[Start<'tcx>]) -> Option<StartKind<'tcx>> {
         starts.iter().find_map(|start| {
             if same_var(cx, e, start.id) {
                 Some(start.kind)
@@ -982,13 +978,9 @@ fn get_details_from_idx<'tcx>(
     match idx.kind {
         ExprKind::Binary(op, lhs, rhs) => match op.node {
             BinOpKind::Add => {
-                let offset_opt = if let Some(s) = get_start(cx, lhs, starts) {
-                    get_offset(cx, rhs, starts).map(|o| (s, o))
-                } else if let Some(s) = get_start(cx, rhs, starts) {
-                    get_offset(cx, lhs, starts).map(|o| (s, o))
-                } else {
-                    None
-                };
+                let offset_opt = get_start(cx, lhs, starts)
+                    .and_then(|s| get_offset(cx, rhs, starts).map(|o| (s, o)))
+                    .or_else(|| get_start(cx, rhs, starts).and_then(|s| get_offset(cx, lhs, starts).map(|o| (s, o))));
 
                 offset_opt.map(|(s, o)| (s, Offset::positive(o)))
             },
@@ -1011,7 +1003,7 @@ fn get_assignment<'tcx>(e: &'tcx Expr<'tcx>) -> Option<(&'tcx Expr<'tcx>, &'tcx
 }
 
 fn get_assignments<'a: 'c, 'tcx: 'c, 'c>(
-    cx: &'a LateContext<'a, 'tcx>,
+    cx: &'a LateContext<'tcx>,
     stmts: &'tcx [Stmt<'tcx>],
     expr: Option<&'tcx Expr<'tcx>>,
     loop_counters: &'c [Start<'tcx>],
@@ -1032,7 +1024,7 @@ fn get_assignments<'a: 'c, 'tcx: 'c, 'c>(
 }
 
 fn get_loop_counters<'a, 'tcx>(
-    cx: &'a LateContext<'a, 'tcx>,
+    cx: &'a LateContext<'tcx>,
     body: &'tcx Block<'tcx>,
     expr: &'tcx Expr<'_>,
 ) -> Option<impl Iterator<Item = Start<'tcx>> + 'a> {
@@ -1042,7 +1034,7 @@ fn get_loop_counters<'a, 'tcx>(
 
     // For each candidate, check the parent block to see if
     // it's initialized to zero at the start of the loop.
-    if let Some(block) = get_enclosing_block(&cx, expr.hir_id) {
+    get_enclosing_block(&cx, expr.hir_id).and_then(|block| {
         increment_visitor
             .into_results()
             .filter_map(move |var_id| {
@@ -1055,9 +1047,7 @@ fn get_loop_counters<'a, 'tcx>(
                 })
             })
             .into()
-    } else {
-        None
-    }
+    })
 }
 
 fn build_manual_memcpy_suggestion<'tcx>(
@@ -2315,7 +2305,7 @@ struct IncrementVisitor<'a, 'tcx> {
 }
 
 impl<'a, 'tcx> IncrementVisitor<'a, 'tcx> {
-    fn new(cx: &'a LateContext<'a, 'tcx>) -> Self {
+    fn new(cx: &'a LateContext<'tcx>) -> Self {
         Self {
             cx,
             states: FxHashMap::default(),
@@ -2396,7 +2386,10 @@ impl<'a, 'tcx> Visitor<'tcx> for IncrementVisitor<'a, 'tcx> {
 enum InitializeVisitorState<'hir> {
     Initial,          // Not examined yet
     Declared(Symbol), // Declared but not (yet) initialized
-    Initialized { name: Symbol, initializer: &'hir Expr<'hir> },
+    Initialized {
+        name: Symbol,
+        initializer: &'hir Expr<'hir>,
+    },
     DontWarn,
 }
 
@@ -2412,7 +2405,7 @@ struct InitializeVisitor<'a, 'tcx> {
 }
 
 impl<'a, 'tcx> InitializeVisitor<'a, 'tcx> {
-    fn new(cx: &'a LateContext<'a, 'tcx>, end_expr: &'tcx Expr<'tcx>, var_id: HirId) -> Self {
+    fn new(cx: &'a LateContext<'tcx>, end_expr: &'tcx Expr<'tcx>, var_id: HirId) -> Self {
         Self {
             cx,
             end_expr,
@@ -2423,7 +2416,7 @@ impl<'a, 'tcx> InitializeVisitor<'a, 'tcx> {
         }
     }
 
-    fn get_result(&self) -> Option<(Name, &'tcx Expr<'tcx>)> {
+    fn get_result(&self) -> Option<(Symbol, &'tcx Expr<'tcx>)> {
         if let InitializeVisitorState::Initialized { name, initializer } = self.state {
             Some((name, initializer))
         } else {
@@ -2442,14 +2435,12 @@ impl<'a, 'tcx> Visitor<'tcx> for InitializeVisitor<'a, 'tcx> {
             if local.pat.hir_id == self.var_id;
             if let PatKind::Binding(.., ident, _) = local.pat.kind;
             then {
-                self.state = if let Some(ref init) = local.init {
+                self.state = local.init.map_or(InitializeVisitorState::Declared(ident.name), |init| {
                     InitializeVisitorState::Initialized {
                         initializer: init,
                         name: ident.name,
                     }
-                } else {
-                    InitializeVisitorState::Declared(ident.name)
-                }
+                })
             }
         }
         walk_stmt(self, stmt);
-- 
cgit 1.4.1-3-g733a5


From 5b484b405748fc8d7476f9a8d68d2e7227767271 Mon Sep 17 00:00:00 2001
From: Takayuki Nakata <f.seasons017@gmail.com>
Date: Fri, 25 Sep 2020 23:32:18 +0900
Subject: Fix the detection of build scripts

---
 clippy_lints/src/write.rs                 | 33 ++++++++++++++-----------------
 tests/ui/build.rs                         | 10 ----------
 tests/ui/build.stderr                     |  0
 tests/ui/print_stdout_build_script.rs     | 12 +++++++++++
 tests/ui/print_stdout_build_script.stderr |  0
 5 files changed, 27 insertions(+), 28 deletions(-)
 delete mode 100644 tests/ui/build.rs
 delete mode 100644 tests/ui/build.stderr
 create mode 100644 tests/ui/print_stdout_build_script.rs
 create mode 100644 tests/ui/print_stdout_build_script.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs
index 780d474ee96..0e9c7098af8 100644
--- a/clippy_lints/src/write.rs
+++ b/clippy_lints/src/write.rs
@@ -2,7 +2,6 @@ use std::borrow::Cow;
 use std::ops::Range;
 
 use crate::utils::{snippet_with_applicability, span_lint, span_lint_and_sugg, span_lint_and_then};
-use if_chain::if_chain;
 use rustc_ast::ast::{Expr, ExprKind, Item, ItemKind, MacCall, StrLit, StrStyle};
 use rustc_ast::token;
 use rustc_ast::tokenstream::TokenStream;
@@ -12,7 +11,7 @@ use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_parse::parser;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::symbol::Symbol;
-use rustc_span::{BytePos, FileName, Span};
+use rustc_span::{BytePos, Span};
 
 declare_clippy_lint! {
     /// **What it does:** This lint warns when you use `println!("")` to
@@ -236,15 +235,19 @@ impl EarlyLintPass for Write {
     }
 
     fn check_mac(&mut self, cx: &EarlyContext<'_>, mac: &MacCall) {
+        fn is_build_scripts(cx: &EarlyContext<'_>) -> bool {
+            // We could leverage the fact that Cargo sets the crate name
+            // for build scripts to `build_script_build`.
+            cx.sess
+                .opts
+                .crate_name
+                .as_ref()
+                .map_or(false, |crate_name| crate_name == "build_script_build")
+        }
+
         if mac.path == sym!(println) {
-            let filename = cx.sess.source_map().span_to_filename(mac.span());
-            if_chain! {
-                if let FileName::Real(filename) = filename;
-                if let Some(filename) = filename.local_path().file_name();
-                if filename != "build.rs";
-                then {
-                    span_lint(cx, PRINT_STDOUT, mac.span(), "use of `println!`");
-                }
+            if !is_build_scripts(cx) {
+                span_lint(cx, PRINT_STDOUT, mac.span(), "use of `println!`");
             }
             if let (Some(fmt_str), _) = self.check_tts(cx, mac.args.inner_tokens(), false) {
                 if fmt_str.symbol == Symbol::intern("") {
@@ -260,14 +263,8 @@ impl EarlyLintPass for Write {
                 }
             }
         } else if mac.path == sym!(print) {
-            if_chain! {
-                let filename = cx.sess.source_map().span_to_filename(mac.span());
-                if let FileName::Real(filename) = filename;
-                if let Some(filename) = filename.local_path().file_name();
-                if filename != "build.rs";
-                then {
-                    span_lint(cx, PRINT_STDOUT, mac.span(), "use of `print!`");
-                }
+            if !is_build_scripts(cx) {
+                span_lint(cx, PRINT_STDOUT, mac.span(), "use of `print!`");
             }
             if let (Some(fmt_str), _) = self.check_tts(cx, mac.args.inner_tokens(), false) {
                 if check_newlines(&fmt_str) {
diff --git a/tests/ui/build.rs b/tests/ui/build.rs
deleted file mode 100644
index 2d43d452a4f..00000000000
--- a/tests/ui/build.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-#![warn(clippy::print_stdout)]
-
-fn main() {
-    // Fix #6041
-    //
-    // The `print_stdout` shouldn't be linted in `build.rs`
-    // as these methods are used for the build script.
-    println!("Hello");
-    print!("Hello");
-}
diff --git a/tests/ui/build.stderr b/tests/ui/build.stderr
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/tests/ui/print_stdout_build_script.rs b/tests/ui/print_stdout_build_script.rs
new file mode 100644
index 00000000000..b84bf9124fc
--- /dev/null
+++ b/tests/ui/print_stdout_build_script.rs
@@ -0,0 +1,12 @@
+// compile-flags: --crate-name=build_script_build
+
+#![warn(clippy::print_stdout)]
+
+fn main() {
+    // Fix #6041
+    //
+    // The `print_stdout` shouldn't be linted in `build.rs`
+    // as these methods are used for the build script.
+    println!("Hello");
+    print!("Hello");
+}
diff --git a/tests/ui/print_stdout_build_script.stderr b/tests/ui/print_stdout_build_script.stderr
new file mode 100644
index 00000000000..e69de29bb2d
-- 
cgit 1.4.1-3-g733a5


From 1479c18396d764482aa0e56b372c5f57a97c102b Mon Sep 17 00:00:00 2001
From: Frank <lifrank@grinnell.edu>
Date: Thu, 24 Sep 2020 15:32:03 -0500
Subject: add disallowed_method lint

---
 CHANGELOG.md                                       |  1 +
 clippy_lints/src/disallowed_method.rs              | 75 ++++++++++++++++++++++
 clippy_lints/src/lib.rs                            |  6 ++
 clippy_lints/src/utils/conf.rs                     |  2 +
 src/lintlist/mod.rs                                |  7 ++
 tests/ui-toml/toml_disallowed_method/clippy.toml   |  1 +
 .../conf_disallowed_method.rs                      | 13 ++++
 .../conf_disallowed_method.stderr                  | 16 +++++
 tests/ui/disallowed_method.rs                      | 56 ++++++++++++++++
 tests/ui/disallowed_method.stderr                  | 22 +++++++
 10 files changed, 199 insertions(+)
 create mode 100644 clippy_lints/src/disallowed_method.rs
 create mode 100644 tests/ui-toml/toml_disallowed_method/clippy.toml
 create mode 100644 tests/ui-toml/toml_disallowed_method/conf_disallowed_method.rs
 create mode 100644 tests/ui-toml/toml_disallowed_method/conf_disallowed_method.stderr
 create mode 100644 tests/ui/disallowed_method.rs
 create mode 100644 tests/ui/disallowed_method.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index d1dfe36ffd8..575cbd60792 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1559,6 +1559,7 @@ Released 2018-09-13
 [`deref_addrof`]: https://rust-lang.github.io/rust-clippy/master/index.html#deref_addrof
 [`derive_hash_xor_eq`]: https://rust-lang.github.io/rust-clippy/master/index.html#derive_hash_xor_eq
 [`derive_ord_xor_partial_ord`]: https://rust-lang.github.io/rust-clippy/master/index.html#derive_ord_xor_partial_ord
+[`disallowed_method`]: https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_method
 [`diverging_sub_expression`]: https://rust-lang.github.io/rust-clippy/master/index.html#diverging_sub_expression
 [`doc_markdown`]: https://rust-lang.github.io/rust-clippy/master/index.html#doc_markdown
 [`double_comparisons`]: https://rust-lang.github.io/rust-clippy/master/index.html#double_comparisons
diff --git a/clippy_lints/src/disallowed_method.rs b/clippy_lints/src/disallowed_method.rs
new file mode 100644
index 00000000000..7088b2718f2
--- /dev/null
+++ b/clippy_lints/src/disallowed_method.rs
@@ -0,0 +1,75 @@
+use crate::utils::span_lint;
+
+use rustc_data_structures::fx::FxHashSet;
+use rustc_lint::{LateLintPass, LateContext};
+use rustc_session::{impl_lint_pass, declare_tool_lint};
+use rustc_hir::*;
+use rustc_span::Symbol;
+
+declare_clippy_lint! {
+    /// **What it does:** Lints for specific trait methods defined in clippy.toml
+    ///
+    /// **Why is this bad?** Some methods are undesirable in certain contexts,
+    /// and it would be beneficial to lint for them as needed.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// // example code where clippy issues a warning
+    /// foo.bad_method(); // Foo is disallowed
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// // example code which does not raise clippy warning
+    /// GoodStruct.bad_method(); // not disallowed
+    /// ```
+    pub DISALLOWED_METHOD,
+    nursery,
+    "used disallowed method call"
+}
+
+#[derive(Clone, Debug)]
+pub struct DisallowedMethod {
+    disallowed: FxHashSet<Vec<Symbol>>,
+}
+
+impl DisallowedMethod {
+    pub fn new(disallowed: FxHashSet<String>) -> Self {
+        Self {
+            disallowed: disallowed.iter()
+                .map(|s| {
+                    s.split("::").map(|seg| Symbol::intern(seg)).collect::<Vec<_>>()
+                })
+                .collect(),
+        }
+    }
+}
+
+impl_lint_pass!(DisallowedMethod => [DISALLOWED_METHOD]);
+
+impl <'tcx> LateLintPass<'tcx> for DisallowedMethod {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        if let ExprKind::MethodCall(path, _, _args, _) = &expr.kind {
+            let def_id = cx.typeck_results().type_dependent_def_id(expr.hir_id).unwrap();
+
+            let method_call = cx.get_def_path(def_id);
+            if self.disallowed.contains(&method_call) {
+                span_lint(
+                    cx,
+                    DISALLOWED_METHOD,
+                    expr.span,
+                    &format!(
+                        "Use of a disallowed method `{}`",
+                        method_call
+                            .iter()
+                            .map(|s| s.to_ident_string())
+                            .collect::<Vec<_>>()
+                            .join("::"),
+                    )
+                );
+            }
+        }
+    }
+}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 58112ac8da5..7c886ab87d0 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -175,6 +175,7 @@ mod dbg_macro;
 mod default_trait_access;
 mod dereference;
 mod derive;
+mod disallowed_method;
 mod doc;
 mod double_comparison;
 mod double_parens;
@@ -525,6 +526,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &derive::DERIVE_ORD_XOR_PARTIAL_ORD,
         &derive::EXPL_IMPL_CLONE_ON_COPY,
         &derive::UNSAFE_DERIVE_DESERIALIZE,
+        &disallowed_method::DISALLOWED_METHOD,
         &doc::DOC_MARKDOWN,
         &doc::MISSING_ERRORS_DOC,
         &doc::MISSING_SAFETY_DOC,
@@ -1118,6 +1120,9 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box async_yields_async::AsyncYieldsAsync);
     store.register_late_pass(|| box manual_strip::ManualStrip);
     store.register_late_pass(|| box utils::internal_lints::MatchTypeOnDiagItem);
+    let disallowed_methods = conf.disallowed_methods.iter().cloned().collect::<FxHashSet<_>>();
+    store.register_late_pass(move || box disallowed_method::DisallowedMethod::new(disallowed_methods.clone()));
+
 
     store.register_group(true, "clippy::restriction", Some("clippy_restriction"), vec![
         LintId::of(&arithmetic::FLOAT_ARITHMETIC),
@@ -1807,6 +1812,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_group(true, "clippy::nursery", Some("clippy_nursery"), vec![
         LintId::of(&attrs::EMPTY_LINE_AFTER_OUTER_ATTR),
         LintId::of(&cognitive_complexity::COGNITIVE_COMPLEXITY),
+        LintId::of(&disallowed_method::DISALLOWED_METHOD),
         LintId::of(&fallible_impl_from::FALLIBLE_IMPL_FROM),
         LintId::of(&floating_point_arithmetic::IMPRECISE_FLOPS),
         LintId::of(&floating_point_arithmetic::SUBOPTIMAL_FLOPS),
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 9c5a12ea9c8..07591ce2229 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -164,6 +164,8 @@ define_Conf! {
     (max_fn_params_bools, "max_fn_params_bools": u64, 3),
     /// Lint: WILDCARD_IMPORTS. Whether to allow certain wildcard imports (prelude, super in tests).
     (warn_on_all_wildcard_imports, "warn_on_all_wildcard_imports": bool, false),
+    /// Lint: DISALLOWED_METHOD. The list of blacklisted methods to lint about. NB: `bar` is not here since it has legitimate uses
+    (disallowed_methods, "disallowed_methods": Vec<String>, ["disallowed_method::Foo::bad_method", "disallowed_method::Baz::bad_method", "disallowed_method::Quux::bad_method"].iter().map(ToString::to_string).collect()),
 }
 
 impl Default for Conf {
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index 9603023ed06..a77bbcb0abe 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -381,6 +381,13 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
         deprecation: None,
         module: "derive",
     },
+    Lint {
+        name: "disallowed_method",
+        group: "nursery",
+        desc: "default lint description",
+        deprecation: None,
+        module: "disallowed_method",
+    },
     Lint {
         name: "diverging_sub_expression",
         group: "complexity",
diff --git a/tests/ui-toml/toml_disallowed_method/clippy.toml b/tests/ui-toml/toml_disallowed_method/clippy.toml
new file mode 100644
index 00000000000..a1f515e443d
--- /dev/null
+++ b/tests/ui-toml/toml_disallowed_method/clippy.toml
@@ -0,0 +1 @@
+disallowed-methods = ["core::iter::traits::iterator::Iterator::sum", "regex::re_unicode::Regex::is_match"]
diff --git a/tests/ui-toml/toml_disallowed_method/conf_disallowed_method.rs b/tests/ui-toml/toml_disallowed_method/conf_disallowed_method.rs
new file mode 100644
index 00000000000..3d3f0729abd
--- /dev/null
+++ b/tests/ui-toml/toml_disallowed_method/conf_disallowed_method.rs
@@ -0,0 +1,13 @@
+#![warn(clippy::disallowed_method)]
+
+extern crate regex;
+use regex::Regex;
+
+fn main() {
+    let a = vec![1, 2, 3, 4];
+    let re = Regex::new(r"ab.*c").unwrap();
+
+    re.is_match("abc");
+
+    a.iter().sum::<i32>();
+}
diff --git a/tests/ui-toml/toml_disallowed_method/conf_disallowed_method.stderr b/tests/ui-toml/toml_disallowed_method/conf_disallowed_method.stderr
new file mode 100644
index 00000000000..5da551cb430
--- /dev/null
+++ b/tests/ui-toml/toml_disallowed_method/conf_disallowed_method.stderr
@@ -0,0 +1,16 @@
+error: Use of a disallowed method `regex::re_unicode::Regex::is_match`
+  --> $DIR/conf_disallowed_method.rs:10:5
+   |
+LL |     re.is_match("abc");
+   |     ^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::disallowed-method` implied by `-D warnings`
+
+error: Use of a disallowed method `core::iter::traits::iterator::Iterator::sum`
+  --> $DIR/conf_disallowed_method.rs:12:5
+   |
+LL |     a.iter().sum::<i32>();
+   |     ^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 2 previous errors
+
diff --git a/tests/ui/disallowed_method.rs b/tests/ui/disallowed_method.rs
new file mode 100644
index 00000000000..a54a04b4d2c
--- /dev/null
+++ b/tests/ui/disallowed_method.rs
@@ -0,0 +1,56 @@
+#![warn(clippy::disallowed_method)]
+#![allow(clippy::no_effect, clippy::many_single_char_names)]
+
+struct ImplStruct;
+
+trait Baz {
+    fn bad_method(self);
+}
+
+impl Baz for ImplStruct {
+    fn bad_method(self) {}
+}
+
+struct Foo;
+
+impl Foo {
+    fn bad_method(self) {}
+}
+
+struct StaticStruct;
+
+trait Quux {
+    fn bad_method();
+}
+
+impl Quux for StaticStruct {
+    fn bad_method() {}
+}
+
+struct NormalStruct;
+
+impl NormalStruct {
+    fn bad_method(self) {}
+}
+
+struct AttrStruct {
+    bad_method: i32,
+}
+
+fn main() {
+    let b = ImplStruct;
+    let f = Foo;
+    let c = ImplStruct;
+    let n = NormalStruct;
+    let a = AttrStruct{ bad_method: 5 };
+
+    // lint these
+    b.bad_method();
+    c.bad_method();
+    f.bad_method();
+    // these are good
+    // good because not a method call (ExprKind => Call)
+    StaticStruct::bad_method();
+    n.bad_method();
+    a.bad_method;
+}
diff --git a/tests/ui/disallowed_method.stderr b/tests/ui/disallowed_method.stderr
new file mode 100644
index 00000000000..93dabf38cfc
--- /dev/null
+++ b/tests/ui/disallowed_method.stderr
@@ -0,0 +1,22 @@
+error: Use of a disallowed method `disallowed_method::Baz::bad_method`
+  --> $DIR/disallowed_method.rs:48:5
+   |
+LL |     b.bad_method();
+   |     ^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::disallowed-method` implied by `-D warnings`
+
+error: Use of a disallowed method `disallowed_method::Baz::bad_method`
+  --> $DIR/disallowed_method.rs:49:5
+   |
+LL |     c.bad_method();
+   |     ^^^^^^^^^^^^^^
+
+error: Use of a disallowed method `disallowed_method::Foo::bad_method`
+  --> $DIR/disallowed_method.rs:50:5
+   |
+LL |     f.bad_method();
+   |     ^^^^^^^^^^^^^^
+
+error: aborting due to 3 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 12e5637f757f4fd4cc2331619ebeca59934a910d Mon Sep 17 00:00:00 2001
From: Frank <lifrank@grinnell.edu>
Date: Thu, 24 Sep 2020 15:36:38 -0500
Subject: update unused variable

---
 clippy_lints/src/disallowed_method.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/disallowed_method.rs b/clippy_lints/src/disallowed_method.rs
index 7088b2718f2..5ecdcc0e08a 100644
--- a/clippy_lints/src/disallowed_method.rs
+++ b/clippy_lints/src/disallowed_method.rs
@@ -51,7 +51,7 @@ impl_lint_pass!(DisallowedMethod => [DISALLOWED_METHOD]);
 
 impl <'tcx> LateLintPass<'tcx> for DisallowedMethod {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if let ExprKind::MethodCall(path, _, _args, _) = &expr.kind {
+        if let ExprKind::MethodCall(_path, _, _args, _) = &expr.kind {
             let def_id = cx.typeck_results().type_dependent_def_id(expr.hir_id).unwrap();
 
             let method_call = cx.get_def_path(def_id);
-- 
cgit 1.4.1-3-g733a5


From e1b3f85e984c9d4fba3ef5360892c88990b8391d Mon Sep 17 00:00:00 2001
From: Frank <lifrank@grinnell.edu>
Date: Thu, 24 Sep 2020 16:00:46 -0500
Subject: run cargo dev fmt

---
 clippy_lints/src/disallowed_method.rs | 15 +++++++--------
 tests/ui/disallowed_method.rs         |  2 +-
 2 files changed, 8 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/disallowed_method.rs b/clippy_lints/src/disallowed_method.rs
index 5ecdcc0e08a..42fbff8ff87 100644
--- a/clippy_lints/src/disallowed_method.rs
+++ b/clippy_lints/src/disallowed_method.rs
@@ -1,9 +1,9 @@
 use crate::utils::span_lint;
 
 use rustc_data_structures::fx::FxHashSet;
-use rustc_lint::{LateLintPass, LateContext};
-use rustc_session::{impl_lint_pass, declare_tool_lint};
 use rustc_hir::*;
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::Symbol;
 
 declare_clippy_lint! {
@@ -38,10 +38,9 @@ pub struct DisallowedMethod {
 impl DisallowedMethod {
     pub fn new(disallowed: FxHashSet<String>) -> Self {
         Self {
-            disallowed: disallowed.iter()
-                .map(|s| {
-                    s.split("::").map(|seg| Symbol::intern(seg)).collect::<Vec<_>>()
-                })
+            disallowed: disallowed
+                .iter()
+                .map(|s| s.split("::").map(|seg| Symbol::intern(seg)).collect::<Vec<_>>())
                 .collect(),
         }
     }
@@ -49,7 +48,7 @@ impl DisallowedMethod {
 
 impl_lint_pass!(DisallowedMethod => [DISALLOWED_METHOD]);
 
-impl <'tcx> LateLintPass<'tcx> for DisallowedMethod {
+impl<'tcx> LateLintPass<'tcx> for DisallowedMethod {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if let ExprKind::MethodCall(_path, _, _args, _) = &expr.kind {
             let def_id = cx.typeck_results().type_dependent_def_id(expr.hir_id).unwrap();
@@ -67,7 +66,7 @@ impl <'tcx> LateLintPass<'tcx> for DisallowedMethod {
                             .map(|s| s.to_ident_string())
                             .collect::<Vec<_>>()
                             .join("::"),
-                    )
+                    ),
                 );
             }
         }
diff --git a/tests/ui/disallowed_method.rs b/tests/ui/disallowed_method.rs
index a54a04b4d2c..46c9185268c 100644
--- a/tests/ui/disallowed_method.rs
+++ b/tests/ui/disallowed_method.rs
@@ -42,7 +42,7 @@ fn main() {
     let f = Foo;
     let c = ImplStruct;
     let n = NormalStruct;
-    let a = AttrStruct{ bad_method: 5 };
+    let a = AttrStruct { bad_method: 5 };
 
     // lint these
     b.bad_method();
-- 
cgit 1.4.1-3-g733a5


From 725a0ef8b1948e459d266cd0ab33dda0c8bc3708 Mon Sep 17 00:00:00 2001
From: Frank <lifrank@grinnell.edu>
Date: Thu, 24 Sep 2020 16:26:29 -0500
Subject: change config variables to reference, remove wildcard import

---
 clippy_lints/src/disallowed_method.rs | 4 ++--
 clippy_lints/src/lib.rs               | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/disallowed_method.rs b/clippy_lints/src/disallowed_method.rs
index 42fbff8ff87..7638019340f 100644
--- a/clippy_lints/src/disallowed_method.rs
+++ b/clippy_lints/src/disallowed_method.rs
@@ -1,7 +1,7 @@
 use crate::utils::span_lint;
 
 use rustc_data_structures::fx::FxHashSet;
-use rustc_hir::*;
+use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::Symbol;
@@ -36,7 +36,7 @@ pub struct DisallowedMethod {
 }
 
 impl DisallowedMethod {
-    pub fn new(disallowed: FxHashSet<String>) -> Self {
+    pub fn new(disallowed: &FxHashSet<String>) -> Self {
         Self {
             disallowed: disallowed
                 .iter()
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 7c886ab87d0..7b6efc660af 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1121,7 +1121,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box manual_strip::ManualStrip);
     store.register_late_pass(|| box utils::internal_lints::MatchTypeOnDiagItem);
     let disallowed_methods = conf.disallowed_methods.iter().cloned().collect::<FxHashSet<_>>();
-    store.register_late_pass(move || box disallowed_method::DisallowedMethod::new(disallowed_methods.clone()));
+    store.register_late_pass(move || box disallowed_method::DisallowedMethod::new(&disallowed_methods));
 
 
     store.register_group(true, "clippy::restriction", Some("clippy_restriction"), vec![
-- 
cgit 1.4.1-3-g733a5


From 3886edb05a2b570664f7249620766582e55a74aa Mon Sep 17 00:00:00 2001
From: Frank <lifrank@grinnell.edu>
Date: Thu, 24 Sep 2020 16:43:29 -0500
Subject: fix error message

---
 clippy_lints/src/disallowed_method.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/disallowed_method.rs b/clippy_lints/src/disallowed_method.rs
index 7638019340f..eea369924a6 100644
--- a/clippy_lints/src/disallowed_method.rs
+++ b/clippy_lints/src/disallowed_method.rs
@@ -16,14 +16,14 @@ declare_clippy_lint! {
     ///
     /// **Example:**
     ///
-    /// ```rust
+    /// ```rust,ignore
     /// // example code where clippy issues a warning
     /// foo.bad_method(); // Foo is disallowed
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```rust,ignore
     /// // example code which does not raise clippy warning
-    /// GoodStruct.bad_method(); // not disallowed
+    /// goodStruct.bad_method(); // not disallowed
     /// ```
     pub DISALLOWED_METHOD,
     nursery,
-- 
cgit 1.4.1-3-g733a5


From f9da2946d81a973b3c25aa5f4739ac7e05c27278 Mon Sep 17 00:00:00 2001
From: Frank <lifrank@grinnell.edu>
Date: Fri, 25 Sep 2020 09:38:19 -0500
Subject: update error message, refactor disallowed_method

---
 clippy_lints/src/disallowed_method.rs                   | 17 ++++++++---------
 .../conf_disallowed_method.stderr                       |  4 ++--
 tests/ui/disallowed_method.stderr                       |  6 +++---
 3 files changed, 13 insertions(+), 14 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/disallowed_method.rs b/clippy_lints/src/disallowed_method.rs
index eea369924a6..603f776e688 100644
--- a/clippy_lints/src/disallowed_method.rs
+++ b/clippy_lints/src/disallowed_method.rs
@@ -27,7 +27,7 @@ declare_clippy_lint! {
     /// ```
     pub DISALLOWED_METHOD,
     nursery,
-    "used disallowed method call"
+    "use of a disallowed method call"
 }
 
 #[derive(Clone, Debug)]
@@ -55,18 +55,17 @@ impl<'tcx> LateLintPass<'tcx> for DisallowedMethod {
 
             let method_call = cx.get_def_path(def_id);
             if self.disallowed.contains(&method_call) {
+                let method = method_call
+                    .iter()
+                    .map(|s| s.to_ident_string())
+                    .collect::<Vec<_>>()
+                    .join("::");
+
                 span_lint(
                     cx,
                     DISALLOWED_METHOD,
                     expr.span,
-                    &format!(
-                        "Use of a disallowed method `{}`",
-                        method_call
-                            .iter()
-                            .map(|s| s.to_ident_string())
-                            .collect::<Vec<_>>()
-                            .join("::"),
-                    ),
+                    &format!("use of a disallowed method `{}`", method),
                 );
             }
         }
diff --git a/tests/ui-toml/toml_disallowed_method/conf_disallowed_method.stderr b/tests/ui-toml/toml_disallowed_method/conf_disallowed_method.stderr
index 5da551cb430..ed91b5a6796 100644
--- a/tests/ui-toml/toml_disallowed_method/conf_disallowed_method.stderr
+++ b/tests/ui-toml/toml_disallowed_method/conf_disallowed_method.stderr
@@ -1,4 +1,4 @@
-error: Use of a disallowed method `regex::re_unicode::Regex::is_match`
+error: use of a disallowed method `regex::re_unicode::Regex::is_match`
   --> $DIR/conf_disallowed_method.rs:10:5
    |
 LL |     re.is_match("abc");
@@ -6,7 +6,7 @@ LL |     re.is_match("abc");
    |
    = note: `-D clippy::disallowed-method` implied by `-D warnings`
 
-error: Use of a disallowed method `core::iter::traits::iterator::Iterator::sum`
+error: use of a disallowed method `core::iter::traits::iterator::Iterator::sum`
   --> $DIR/conf_disallowed_method.rs:12:5
    |
 LL |     a.iter().sum::<i32>();
diff --git a/tests/ui/disallowed_method.stderr b/tests/ui/disallowed_method.stderr
index 93dabf38cfc..40db1b946d8 100644
--- a/tests/ui/disallowed_method.stderr
+++ b/tests/ui/disallowed_method.stderr
@@ -1,4 +1,4 @@
-error: Use of a disallowed method `disallowed_method::Baz::bad_method`
+error: use of a disallowed method `disallowed_method::Baz::bad_method`
   --> $DIR/disallowed_method.rs:48:5
    |
 LL |     b.bad_method();
@@ -6,13 +6,13 @@ LL |     b.bad_method();
    |
    = note: `-D clippy::disallowed-method` implied by `-D warnings`
 
-error: Use of a disallowed method `disallowed_method::Baz::bad_method`
+error: use of a disallowed method `disallowed_method::Baz::bad_method`
   --> $DIR/disallowed_method.rs:49:5
    |
 LL |     c.bad_method();
    |     ^^^^^^^^^^^^^^
 
-error: Use of a disallowed method `disallowed_method::Foo::bad_method`
+error: use of a disallowed method `disallowed_method::Foo::bad_method`
   --> $DIR/disallowed_method.rs:50:5
    |
 LL |     f.bad_method();
-- 
cgit 1.4.1-3-g733a5


From d18653158ddde023f8165ef7ba3c607661398abf Mon Sep 17 00:00:00 2001
From: Frank <lifrank@grinnell.edu>
Date: Fri, 25 Sep 2020 11:03:45 -0500
Subject: remove useless test, update disallowed_method description

---
 clippy_lints/src/disallowed_method.rs |  4 +--
 clippy_lints/src/utils/conf.rs        |  2 +-
 tests/ui/disallowed_method.rs         | 56 -----------------------------------
 tests/ui/disallowed_method.stderr     | 22 --------------
 4 files changed, 3 insertions(+), 81 deletions(-)
 delete mode 100644 tests/ui/disallowed_method.rs
 delete mode 100644 tests/ui/disallowed_method.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/disallowed_method.rs b/clippy_lints/src/disallowed_method.rs
index 603f776e688..581c3242e37 100644
--- a/clippy_lints/src/disallowed_method.rs
+++ b/clippy_lints/src/disallowed_method.rs
@@ -18,12 +18,12 @@ declare_clippy_lint! {
     ///
     /// ```rust,ignore
     /// // example code where clippy issues a warning
-    /// foo.bad_method(); // Foo is disallowed
+    /// foo.bad_method(); // Foo::bad_method is disallowed in the configuration
     /// ```
     /// Use instead:
     /// ```rust,ignore
     /// // example code which does not raise clippy warning
-    /// goodStruct.bad_method(); // not disallowed
+    /// goodStruct.bad_method(); // GoodStruct::bad_method is not disallowed
     /// ```
     pub DISALLOWED_METHOD,
     nursery,
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 07591ce2229..03f8c5a2c07 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -165,7 +165,7 @@ define_Conf! {
     /// Lint: WILDCARD_IMPORTS. Whether to allow certain wildcard imports (prelude, super in tests).
     (warn_on_all_wildcard_imports, "warn_on_all_wildcard_imports": bool, false),
     /// Lint: DISALLOWED_METHOD. The list of blacklisted methods to lint about. NB: `bar` is not here since it has legitimate uses
-    (disallowed_methods, "disallowed_methods": Vec<String>, ["disallowed_method::Foo::bad_method", "disallowed_method::Baz::bad_method", "disallowed_method::Quux::bad_method"].iter().map(ToString::to_string).collect()),
+    (disallowed_methods, "disallowed_methods": Vec<String>, Vec::<String>::new()),
 }
 
 impl Default for Conf {
diff --git a/tests/ui/disallowed_method.rs b/tests/ui/disallowed_method.rs
deleted file mode 100644
index 46c9185268c..00000000000
--- a/tests/ui/disallowed_method.rs
+++ /dev/null
@@ -1,56 +0,0 @@
-#![warn(clippy::disallowed_method)]
-#![allow(clippy::no_effect, clippy::many_single_char_names)]
-
-struct ImplStruct;
-
-trait Baz {
-    fn bad_method(self);
-}
-
-impl Baz for ImplStruct {
-    fn bad_method(self) {}
-}
-
-struct Foo;
-
-impl Foo {
-    fn bad_method(self) {}
-}
-
-struct StaticStruct;
-
-trait Quux {
-    fn bad_method();
-}
-
-impl Quux for StaticStruct {
-    fn bad_method() {}
-}
-
-struct NormalStruct;
-
-impl NormalStruct {
-    fn bad_method(self) {}
-}
-
-struct AttrStruct {
-    bad_method: i32,
-}
-
-fn main() {
-    let b = ImplStruct;
-    let f = Foo;
-    let c = ImplStruct;
-    let n = NormalStruct;
-    let a = AttrStruct { bad_method: 5 };
-
-    // lint these
-    b.bad_method();
-    c.bad_method();
-    f.bad_method();
-    // these are good
-    // good because not a method call (ExprKind => Call)
-    StaticStruct::bad_method();
-    n.bad_method();
-    a.bad_method;
-}
diff --git a/tests/ui/disallowed_method.stderr b/tests/ui/disallowed_method.stderr
deleted file mode 100644
index 40db1b946d8..00000000000
--- a/tests/ui/disallowed_method.stderr
+++ /dev/null
@@ -1,22 +0,0 @@
-error: use of a disallowed method `disallowed_method::Baz::bad_method`
-  --> $DIR/disallowed_method.rs:48:5
-   |
-LL |     b.bad_method();
-   |     ^^^^^^^^^^^^^^
-   |
-   = note: `-D clippy::disallowed-method` implied by `-D warnings`
-
-error: use of a disallowed method `disallowed_method::Baz::bad_method`
-  --> $DIR/disallowed_method.rs:49:5
-   |
-LL |     c.bad_method();
-   |     ^^^^^^^^^^^^^^
-
-error: use of a disallowed method `disallowed_method::Foo::bad_method`
-  --> $DIR/disallowed_method.rs:50:5
-   |
-LL |     f.bad_method();
-   |     ^^^^^^^^^^^^^^
-
-error: aborting due to 3 previous errors
-
-- 
cgit 1.4.1-3-g733a5


From 83294f894d477def457d54f2391a287bcb949f06 Mon Sep 17 00:00:00 2001
From: Takayuki Nakata <f.seasons017@gmail.com>
Date: Sat, 26 Sep 2020 23:10:25 +0900
Subject: Some small fixes

---
 clippy_lints/src/write.rs                 | 9 ++++-----
 tests/ui/print_stdout_build_script.rs     | 2 +-
 tests/ui/print_stdout_build_script.stderr | 0
 3 files changed, 5 insertions(+), 6 deletions(-)
 delete mode 100644 tests/ui/print_stdout_build_script.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs
index 0e9c7098af8..d9d60fffcd7 100644
--- a/clippy_lints/src/write.rs
+++ b/clippy_lints/src/write.rs
@@ -235,9 +235,8 @@ impl EarlyLintPass for Write {
     }
 
     fn check_mac(&mut self, cx: &EarlyContext<'_>, mac: &MacCall) {
-        fn is_build_scripts(cx: &EarlyContext<'_>) -> bool {
-            // We could leverage the fact that Cargo sets the crate name
-            // for build scripts to `build_script_build`.
+        fn is_build_script(cx: &EarlyContext<'_>) -> bool {
+            // Cargo sets the crate name for build scripts to `build_script_build`
             cx.sess
                 .opts
                 .crate_name
@@ -246,7 +245,7 @@ impl EarlyLintPass for Write {
         }
 
         if mac.path == sym!(println) {
-            if !is_build_scripts(cx) {
+            if !is_build_script(cx) {
                 span_lint(cx, PRINT_STDOUT, mac.span(), "use of `println!`");
             }
             if let (Some(fmt_str), _) = self.check_tts(cx, mac.args.inner_tokens(), false) {
@@ -263,7 +262,7 @@ impl EarlyLintPass for Write {
                 }
             }
         } else if mac.path == sym!(print) {
-            if !is_build_scripts(cx) {
+            if !is_build_script(cx) {
                 span_lint(cx, PRINT_STDOUT, mac.span(), "use of `print!`");
             }
             if let (Some(fmt_str), _) = self.check_tts(cx, mac.args.inner_tokens(), false) {
diff --git a/tests/ui/print_stdout_build_script.rs b/tests/ui/print_stdout_build_script.rs
index b84bf9124fc..997ebef8a69 100644
--- a/tests/ui/print_stdout_build_script.rs
+++ b/tests/ui/print_stdout_build_script.rs
@@ -5,7 +5,7 @@
 fn main() {
     // Fix #6041
     //
-    // The `print_stdout` shouldn't be linted in `build.rs`
+    // The `print_stdout` lint shouldn't emit in `build.rs`
     // as these methods are used for the build script.
     println!("Hello");
     print!("Hello");
diff --git a/tests/ui/print_stdout_build_script.stderr b/tests/ui/print_stdout_build_script.stderr
deleted file mode 100644
index e69de29bb2d..00000000000
-- 
cgit 1.4.1-3-g733a5


From 00e641b91417a0b4489544406f60a1e2babe7c88 Mon Sep 17 00:00:00 2001
From: Jeremiah Senkpiel <fishrock123@rocketmail.com>
Date: Sat, 26 Sep 2020 17:19:12 -0700
Subject: lints: clarify rc_buffer and add caveats

This didn't display some types properly in the docs due the lack of code formatting.

Also, refs for the caveat:
https://github.com/rust-lang/rust-clippy/pull/6044#issuecomment-699559082
https://github.com/http-rs/surf/pull/242
---
 clippy_lints/src/types.rs | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs
index a29a199b8c3..17d950169fd 100644
--- a/clippy_lints/src/types.rs
+++ b/clippy_lints/src/types.rs
@@ -216,18 +216,19 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for Rc<T> and Arc<T> when T is a mutable buffer type such as String or Vec
+    /// **What it does:** Checks for `Rc<T>` and `Arc<T>` when `T` is a mutable buffer type such as `String` or `Vec`.
     ///
-    /// **Why is this bad?** Expressions such as Rc<String> have no advantage over Rc<str>, since
-    /// it is larger and involves an extra level of indirection, and doesn't implement Borrow<str>.
+    /// **Why is this bad?** Expressions such as `Rc<String>` usually have no advantage over `Rc<str>`, since
+    /// it is larger and involves an extra level of indirection, and doesn't implement `Borrow<str>`.
     ///
-    /// While mutating a buffer type would still be possible with Rc::get_mut(), it only
-    /// works if there are no additional references yet, which defeats the purpose of
+    /// While mutating a buffer type would still be possible with `Rc::get_mut()`, it only
+    /// works if there are no additional references yet, which usually defeats the purpose of
     /// enclosing it in a shared ownership type. Instead, additionally wrapping the inner
-    /// type with an interior mutable container (such as RefCell or Mutex) would normally
+    /// type with an interior mutable container (such as `RefCell` or `Mutex`) would normally
     /// be used.
     ///
-    /// **Known problems:** None.
+    /// **Known problems:** This pattern can be desirable to avoid the overhead of a `RefCell` or `Mutex` for
+    /// cases where mutation only happens before there are any additional references.
     ///
     /// **Example:**
     /// ```rust,ignore
-- 
cgit 1.4.1-3-g733a5


From 4918e7ad62259e4c35a0b9d6ac0f0e98e51ff7b1 Mon Sep 17 00:00:00 2001
From: rail <12975677+rail-rain@users.noreply.github.com>
Date: Sun, 27 Sep 2020 14:19:43 +1300
Subject: Replace `snippet_opt` + `unwrap_or_else` with `snippet`

---
 clippy_lints/src/loops.rs | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 4ff567ffb0e..647537933f7 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -5,9 +5,8 @@ use crate::utils::usage::{is_unused, mutated_variables};
 use crate::utils::{
     get_enclosing_block, get_parent_expr, get_trait_def_id, has_iter_method, higher, implements_trait,
     is_integer_const, is_no_std_crate, is_refutable, is_type_diagnostic_item, last_path_segment, match_trait_method,
-    match_type, match_var, multispan_sugg, qpath_res, snippet, snippet_opt, snippet_with_applicability,
-    snippet_with_macro_callsite, span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then, sugg,
-    SpanlessEq,
+    match_type, match_var, multispan_sugg, qpath_res, snippet, snippet_with_applicability, snippet_with_macro_callsite,
+    span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then, sugg, SpanlessEq,
 };
 use if_chain::if_chain;
 use rustc_ast::ast;
@@ -1121,8 +1120,8 @@ fn build_manual_memcpy_suggestion<'tcx>(
     let (dst_offset, dst_limit) = print_offset_and_limit(&dst);
     let (src_offset, src_limit) = print_offset_and_limit(&src);
 
-    let dst_base_str = snippet_opt(cx, dst.base.span).unwrap_or_else(|| "???".into());
-    let src_base_str = snippet_opt(cx, src.base.span).unwrap_or_else(|| "???".into());
+    let dst_base_str = snippet(cx, dst.base.span, "???");
+    let src_base_str = snippet(cx, src.base.span, "???");
 
     let dst = if dst_offset.as_str() == "" && dst_limit.as_str() == "" {
         dst_base_str
@@ -1133,6 +1132,7 @@ fn build_manual_memcpy_suggestion<'tcx>(
             dst_offset.maybe_par(),
             dst_limit.maybe_par()
         )
+        .into()
     };
 
     format!(
-- 
cgit 1.4.1-3-g733a5


From 5c71352b18ee7a48e825aefd2862b8e0d16ea45b Mon Sep 17 00:00:00 2001
From: rail <12975677+rail-rain@users.noreply.github.com>
Date: Sun, 27 Sep 2020 14:52:06 +1300
Subject: Prevent unnecessary lints from triggering

---
 clippy_lints/src/loops.rs     | 12 ++++++++----
 tests/ui/manual_memcpy.rs     |  1 -
 tests/ui/manual_memcpy.stderr | 20 ++++++++++----------
 3 files changed, 18 insertions(+), 15 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 647537933f7..f2df53aee4f 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -768,12 +768,14 @@ fn check_for_loop<'tcx>(
     body: &'tcx Expr<'_>,
     expr: &'tcx Expr<'_>,
 ) {
-    check_for_loop_range(cx, pat, arg, body, expr);
+    let is_manual_memcpy_triggered = detect_manual_memcpy(cx, pat, arg, body, expr);
+    if !is_manual_memcpy_triggered {
+        check_for_loop_range(cx, pat, arg, body, expr);
+        check_for_loop_explicit_counter(cx, pat, arg, body, expr);
+    }
     check_for_loop_arg(cx, pat, arg, expr);
-    check_for_loop_explicit_counter(cx, pat, arg, body, expr);
     check_for_loop_over_map_kv(cx, pat, arg, body, expr);
     check_for_mut_range_bound(cx, arg, body);
-    detect_manual_memcpy(cx, pat, arg, body, expr);
     detect_same_item_push(cx, pat, arg, body, expr);
 }
 
@@ -1152,7 +1154,7 @@ fn detect_manual_memcpy<'tcx>(
     arg: &'tcx Expr<'_>,
     body: &'tcx Expr<'_>,
     expr: &'tcx Expr<'_>,
-) {
+) -> bool {
     if let Some(higher::Range {
         start: Some(start),
         end: Some(end),
@@ -1222,9 +1224,11 @@ fn detect_manual_memcpy<'tcx>(
                     big_sugg,
                     Applicability::Unspecified,
                 );
+                return true;
             }
         }
     }
+    false
 }
 
 // Scans the body of the for loop and determines whether lint should be given
diff --git a/tests/ui/manual_memcpy.rs b/tests/ui/manual_memcpy.rs
index 8318fd89811..84758275dd7 100644
--- a/tests/ui/manual_memcpy.rs
+++ b/tests/ui/manual_memcpy.rs
@@ -115,7 +115,6 @@ pub fn manual_copy(src: &[i32], dst: &mut [i32], dst2: &mut [i32]) {
     }
 }
 
-#[allow(clippy::needless_range_loop, clippy::explicit_counter_loop)]
 pub fn manual_copy_with_counters(src: &[i32], dst: &mut [i32], dst2: &mut [i32]) {
     let mut count = 0;
     for i in 3..src.len() {
diff --git a/tests/ui/manual_memcpy.stderr b/tests/ui/manual_memcpy.stderr
index d189bde0508..464b18984fb 100644
--- a/tests/ui/manual_memcpy.stderr
+++ b/tests/ui/manual_memcpy.stderr
@@ -79,49 +79,49 @@ LL |     for i in 0..0 {
    |              ^^^^ help: try replacing the loop by: `dst[..0].clone_from_slice(&src[..0])`
 
 error: it looks like you're manually copying between slices
-  --> $DIR/manual_memcpy.rs:121:14
+  --> $DIR/manual_memcpy.rs:120:14
    |
 LL |     for i in 3..src.len() {
    |              ^^^^^^^^^^^^ help: try replacing the loop by: `dst[3..src.len()].clone_from_slice(&src[..(src.len() - 3)])`
 
 error: it looks like you're manually copying between slices
-  --> $DIR/manual_memcpy.rs:127:14
+  --> $DIR/manual_memcpy.rs:126:14
    |
 LL |     for i in 3..src.len() {
    |              ^^^^^^^^^^^^ help: try replacing the loop by: `dst[..(src.len() - 3)].clone_from_slice(&src[3..])`
 
 error: it looks like you're manually copying between slices
-  --> $DIR/manual_memcpy.rs:133:14
+  --> $DIR/manual_memcpy.rs:132:14
    |
 LL |     for i in 0..src.len() {
    |              ^^^^^^^^^^^^ help: try replacing the loop by: `dst[3..(src.len() + 3)].clone_from_slice(&src[..])`
 
 error: it looks like you're manually copying between slices
-  --> $DIR/manual_memcpy.rs:139:14
+  --> $DIR/manual_memcpy.rs:138:14
    |
 LL |     for i in 0..src.len() {
    |              ^^^^^^^^^^^^ help: try replacing the loop by: `dst[..src.len()].clone_from_slice(&src[3..(src.len() + 3)])`
 
 error: it looks like you're manually copying between slices
-  --> $DIR/manual_memcpy.rs:145:14
+  --> $DIR/manual_memcpy.rs:144:14
    |
 LL |     for i in 3..(3 + src.len()) {
    |              ^^^^^^^^^^^^^^^^^^ help: try replacing the loop by: `dst[3..((3 + src.len()))].clone_from_slice(&src[..((3 + src.len()) - 3)])`
 
 error: it looks like you're manually copying between slices
-  --> $DIR/manual_memcpy.rs:151:14
+  --> $DIR/manual_memcpy.rs:150:14
    |
 LL |     for i in 5..src.len() {
    |              ^^^^^^^^^^^^ help: try replacing the loop by: `dst[5..src.len()].clone_from_slice(&src[(3 - 2)..((src.len() - 2) + 3 - 5)])`
 
 error: it looks like you're manually copying between slices
-  --> $DIR/manual_memcpy.rs:157:14
+  --> $DIR/manual_memcpy.rs:156:14
    |
 LL |     for i in 3..10 {
    |              ^^^^^ help: try replacing the loop by: `dst[3..10].clone_from_slice(&src[5..(10 + 5 - 3)])`
 
 error: it looks like you're manually copying between slices
-  --> $DIR/manual_memcpy.rs:164:14
+  --> $DIR/manual_memcpy.rs:163:14
    |
 LL |     for i in 0..src.len() {
    |              ^^^^^^^^^^^^
@@ -133,13 +133,13 @@ LL |     dst2[30..(src.len() + 30)].clone_from_slice(&src[..]) {
    |
 
 error: it looks like you're manually copying between slices
-  --> $DIR/manual_memcpy.rs:174:14
+  --> $DIR/manual_memcpy.rs:173:14
    |
 LL |     for i in 0..1 << 1 {
    |              ^^^^^^^^^ help: try replacing the loop by: `dst[(0 << 1)..((1 << 1) + (0 << 1))].clone_from_slice(&src[2..((1 << 1) + 2)])`
 
 error: it looks like you're manually copying between slices
-  --> $DIR/manual_memcpy.rs:182:14
+  --> $DIR/manual_memcpy.rs:181:14
    |
 LL |     for i in 0..src.len() {
    |              ^^^^^^^^^^^^ help: try replacing the loop by: `dst[..src.len()].clone_from_slice(&src[..])`
-- 
cgit 1.4.1-3-g733a5


From 99aceebf1c7cb382e18d66914bd9f576e529aa99 Mon Sep 17 00:00:00 2001
From: rail <12975677+rail-rain@users.noreply.github.com>
Date: Sun, 27 Sep 2020 16:38:41 +1300
Subject: Use the spans of the entire `for` loops for suggestions

---
 clippy_lints/src/loops.rs     |  23 +++--
 tests/ui/manual_memcpy.stderr | 196 +++++++++++++++++++++++++++---------------
 2 files changed, 140 insertions(+), 79 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index f2df53aee4f..7c8b6f483bc 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -779,6 +779,17 @@ fn check_for_loop<'tcx>(
     detect_same_item_push(cx, pat, arg, body, expr);
 }
 
+// this function assumes the given expression is a `for` loop.
+fn get_span_of_entire_for_loop(expr: &Expr<'_>) -> Span {
+    // for some reason this is the only way to get the `Span`
+    // of the entire `for` loop
+    if let ExprKind::Match(_, arms, _) = &expr.kind {
+        arms[0].body.span
+    } else {
+        unreachable!()
+    }
+}
+
 fn same_var<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, var: HirId) -> bool {
     if_chain! {
         if let ExprKind::Path(qpath) = &expr.kind;
@@ -1138,7 +1149,7 @@ fn build_manual_memcpy_suggestion<'tcx>(
     };
 
     format!(
-        "{}.clone_from_slice(&{}[{}..{}])",
+        "{}.clone_from_slice(&{}[{}..{}]);",
         dst,
         src_base_str,
         src_offset.maybe_par(),
@@ -1218,7 +1229,7 @@ fn detect_manual_memcpy<'tcx>(
                 span_lint_and_sugg(
                     cx,
                     MANUAL_MEMCPY,
-                    expr.span,
+                    get_span_of_entire_for_loop(expr),
                     "it looks like you're manually copying between slices",
                     "try replacing the loop by",
                     big_sugg,
@@ -1734,13 +1745,7 @@ fn check_for_loop_explicit_counter<'tcx>(
                 then {
                     let mut applicability = Applicability::MachineApplicable;
 
-                    // for some reason this is the only way to get the `Span`
-                    // of the entire `for` loop
-                    let for_span = if let ExprKind::Match(_, arms, _) = &expr.kind {
-                        arms[0].body.span
-                    } else {
-                        unreachable!()
-                    };
+                    let for_span = get_span_of_entire_for_loop(expr);
 
                     span_lint_and_sugg(
                         cx,
diff --git a/tests/ui/manual_memcpy.stderr b/tests/ui/manual_memcpy.stderr
index 464b18984fb..db62ed90d97 100644
--- a/tests/ui/manual_memcpy.stderr
+++ b/tests/ui/manual_memcpy.stderr
@@ -1,148 +1,204 @@
 error: it looks like you're manually copying between slices
-  --> $DIR/manual_memcpy.rs:7:14
+  --> $DIR/manual_memcpy.rs:7:5
    |
-LL |     for i in 0..src.len() {
-   |              ^^^^^^^^^^^^ help: try replacing the loop by: `dst[..src.len()].clone_from_slice(&src[..])`
+LL | /     for i in 0..src.len() {
+LL | |         dst[i] = src[i];
+LL | |     }
+   | |_____^ help: try replacing the loop by: `dst[..src.len()].clone_from_slice(&src[..]);`
    |
    = note: `-D clippy::manual-memcpy` implied by `-D warnings`
 
 error: it looks like you're manually copying between slices
-  --> $DIR/manual_memcpy.rs:12:14
+  --> $DIR/manual_memcpy.rs:12:5
    |
-LL |     for i in 0..src.len() {
-   |              ^^^^^^^^^^^^ help: try replacing the loop by: `dst[10..(src.len() + 10)].clone_from_slice(&src[..])`
+LL | /     for i in 0..src.len() {
+LL | |         dst[i + 10] = src[i];
+LL | |     }
+   | |_____^ help: try replacing the loop by: `dst[10..(src.len() + 10)].clone_from_slice(&src[..]);`
 
 error: it looks like you're manually copying between slices
-  --> $DIR/manual_memcpy.rs:17:14
+  --> $DIR/manual_memcpy.rs:17:5
    |
-LL |     for i in 0..src.len() {
-   |              ^^^^^^^^^^^^ help: try replacing the loop by: `dst[..src.len()].clone_from_slice(&src[10..(src.len() + 10)])`
+LL | /     for i in 0..src.len() {
+LL | |         dst[i] = src[i + 10];
+LL | |     }
+   | |_____^ help: try replacing the loop by: `dst[..src.len()].clone_from_slice(&src[10..(src.len() + 10)]);`
 
 error: it looks like you're manually copying between slices
-  --> $DIR/manual_memcpy.rs:22:14
+  --> $DIR/manual_memcpy.rs:22:5
    |
-LL |     for i in 11..src.len() {
-   |              ^^^^^^^^^^^^^ help: try replacing the loop by: `dst[11..src.len()].clone_from_slice(&src[(11 - 10)..(src.len() - 10)])`
+LL | /     for i in 11..src.len() {
+LL | |         dst[i] = src[i - 10];
+LL | |     }
+   | |_____^ help: try replacing the loop by: `dst[11..src.len()].clone_from_slice(&src[(11 - 10)..(src.len() - 10)]);`
 
 error: it looks like you're manually copying between slices
-  --> $DIR/manual_memcpy.rs:27:14
+  --> $DIR/manual_memcpy.rs:27:5
    |
-LL |     for i in 0..dst.len() {
-   |              ^^^^^^^^^^^^ help: try replacing the loop by: `dst.clone_from_slice(&src[..dst.len()])`
+LL | /     for i in 0..dst.len() {
+LL | |         dst[i] = src[i];
+LL | |     }
+   | |_____^ help: try replacing the loop by: `dst.clone_from_slice(&src[..dst.len()]);`
 
 error: it looks like you're manually copying between slices
-  --> $DIR/manual_memcpy.rs:40:14
+  --> $DIR/manual_memcpy.rs:40:5
    |
-LL |     for i in 10..256 {
-   |              ^^^^^^^
+LL | /     for i in 10..256 {
+LL | |         dst[i] = src[i - 5];
+LL | |         dst2[i + 500] = src[i]
+LL | |     }
+   | |_____^
    |
 help: try replacing the loop by
    |
-LL |     for i in dst[10..256].clone_from_slice(&src[(10 - 5)..(256 - 5)])
-LL |     dst2[(10 + 500)..(256 + 500)].clone_from_slice(&src[10..256]) {
+LL |     dst[10..256].clone_from_slice(&src[(10 - 5)..(256 - 5)]);
+LL |     dst2[(10 + 500)..(256 + 500)].clone_from_slice(&src[10..256]);
    |
 
 error: it looks like you're manually copying between slices
-  --> $DIR/manual_memcpy.rs:52:14
+  --> $DIR/manual_memcpy.rs:52:5
    |
-LL |     for i in 10..LOOP_OFFSET {
-   |              ^^^^^^^^^^^^^^^ help: try replacing the loop by: `dst[(10 + LOOP_OFFSET)..(LOOP_OFFSET + LOOP_OFFSET)].clone_from_slice(&src[(10 - some_var)..(LOOP_OFFSET - some_var)])`
+LL | /     for i in 10..LOOP_OFFSET {
+LL | |         dst[i + LOOP_OFFSET] = src[i - some_var];
+LL | |     }
+   | |_____^ help: try replacing the loop by: `dst[(10 + LOOP_OFFSET)..(LOOP_OFFSET + LOOP_OFFSET)].clone_from_slice(&src[(10 - some_var)..(LOOP_OFFSET - some_var)]);`
 
 error: it looks like you're manually copying between slices
-  --> $DIR/manual_memcpy.rs:65:14
+  --> $DIR/manual_memcpy.rs:65:5
    |
-LL |     for i in 0..src_vec.len() {
-   |              ^^^^^^^^^^^^^^^^ help: try replacing the loop by: `dst_vec[..src_vec.len()].clone_from_slice(&src_vec[..])`
+LL | /     for i in 0..src_vec.len() {
+LL | |         dst_vec[i] = src_vec[i];
+LL | |     }
+   | |_____^ help: try replacing the loop by: `dst_vec[..src_vec.len()].clone_from_slice(&src_vec[..]);`
 
 error: it looks like you're manually copying between slices
-  --> $DIR/manual_memcpy.rs:94:14
+  --> $DIR/manual_memcpy.rs:94:5
    |
-LL |     for i in from..from + src.len() {
-   |              ^^^^^^^^^^^^^^^^^^^^^^ help: try replacing the loop by: `dst[from..(from + src.len())].clone_from_slice(&src[..(from + src.len() - from)])`
+LL | /     for i in from..from + src.len() {
+LL | |         dst[i] = src[i - from];
+LL | |     }
+   | |_____^ help: try replacing the loop by: `dst[from..(from + src.len())].clone_from_slice(&src[..(from + src.len() - from)]);`
 
 error: it looks like you're manually copying between slices
-  --> $DIR/manual_memcpy.rs:98:14
+  --> $DIR/manual_memcpy.rs:98:5
    |
-LL |     for i in from..from + 3 {
-   |              ^^^^^^^^^^^^^^ help: try replacing the loop by: `dst[from..(from + 3)].clone_from_slice(&src[..(from + 3 - from)])`
+LL | /     for i in from..from + 3 {
+LL | |         dst[i] = src[i - from];
+LL | |     }
+   | |_____^ help: try replacing the loop by: `dst[from..(from + 3)].clone_from_slice(&src[..(from + 3 - from)]);`
 
 error: it looks like you're manually copying between slices
-  --> $DIR/manual_memcpy.rs:103:14
+  --> $DIR/manual_memcpy.rs:103:5
    |
-LL |     for i in 0..5 {
-   |              ^^^^ help: try replacing the loop by: `dst[..5].clone_from_slice(&src[..5])`
+LL | /     for i in 0..5 {
+LL | |         dst[i - 0] = src[i];
+LL | |     }
+   | |_____^ help: try replacing the loop by: `dst[..5].clone_from_slice(&src[..5]);`
 
 error: it looks like you're manually copying between slices
-  --> $DIR/manual_memcpy.rs:108:14
+  --> $DIR/manual_memcpy.rs:108:5
    |
-LL |     for i in 0..0 {
-   |              ^^^^ help: try replacing the loop by: `dst[..0].clone_from_slice(&src[..0])`
+LL | /     for i in 0..0 {
+LL | |         dst[i] = src[i];
+LL | |     }
+   | |_____^ help: try replacing the loop by: `dst[..0].clone_from_slice(&src[..0]);`
 
 error: it looks like you're manually copying between slices
-  --> $DIR/manual_memcpy.rs:120:14
+  --> $DIR/manual_memcpy.rs:120:5
    |
-LL |     for i in 3..src.len() {
-   |              ^^^^^^^^^^^^ help: try replacing the loop by: `dst[3..src.len()].clone_from_slice(&src[..(src.len() - 3)])`
+LL | /     for i in 3..src.len() {
+LL | |         dst[i] = src[count];
+LL | |         count += 1;
+LL | |     }
+   | |_____^ help: try replacing the loop by: `dst[3..src.len()].clone_from_slice(&src[..(src.len() - 3)]);`
 
 error: it looks like you're manually copying between slices
-  --> $DIR/manual_memcpy.rs:126:14
+  --> $DIR/manual_memcpy.rs:126:5
    |
-LL |     for i in 3..src.len() {
-   |              ^^^^^^^^^^^^ help: try replacing the loop by: `dst[..(src.len() - 3)].clone_from_slice(&src[3..])`
+LL | /     for i in 3..src.len() {
+LL | |         dst[count] = src[i];
+LL | |         count += 1;
+LL | |     }
+   | |_____^ help: try replacing the loop by: `dst[..(src.len() - 3)].clone_from_slice(&src[3..]);`
 
 error: it looks like you're manually copying between slices
-  --> $DIR/manual_memcpy.rs:132:14
+  --> $DIR/manual_memcpy.rs:132:5
    |
-LL |     for i in 0..src.len() {
-   |              ^^^^^^^^^^^^ help: try replacing the loop by: `dst[3..(src.len() + 3)].clone_from_slice(&src[..])`
+LL | /     for i in 0..src.len() {
+LL | |         dst[count] = src[i];
+LL | |         count += 1;
+LL | |     }
+   | |_____^ help: try replacing the loop by: `dst[3..(src.len() + 3)].clone_from_slice(&src[..]);`
 
 error: it looks like you're manually copying between slices
-  --> $DIR/manual_memcpy.rs:138:14
+  --> $DIR/manual_memcpy.rs:138:5
    |
-LL |     for i in 0..src.len() {
-   |              ^^^^^^^^^^^^ help: try replacing the loop by: `dst[..src.len()].clone_from_slice(&src[3..(src.len() + 3)])`
+LL | /     for i in 0..src.len() {
+LL | |         dst[i] = src[count];
+LL | |         count += 1;
+LL | |     }
+   | |_____^ help: try replacing the loop by: `dst[..src.len()].clone_from_slice(&src[3..(src.len() + 3)]);`
 
 error: it looks like you're manually copying between slices
-  --> $DIR/manual_memcpy.rs:144:14
+  --> $DIR/manual_memcpy.rs:144:5
    |
-LL |     for i in 3..(3 + src.len()) {
-   |              ^^^^^^^^^^^^^^^^^^ help: try replacing the loop by: `dst[3..((3 + src.len()))].clone_from_slice(&src[..((3 + src.len()) - 3)])`
+LL | /     for i in 3..(3 + src.len()) {
+LL | |         dst[i] = src[count];
+LL | |         count += 1;
+LL | |     }
+   | |_____^ help: try replacing the loop by: `dst[3..((3 + src.len()))].clone_from_slice(&src[..((3 + src.len()) - 3)]);`
 
 error: it looks like you're manually copying between slices
-  --> $DIR/manual_memcpy.rs:150:14
+  --> $DIR/manual_memcpy.rs:150:5
    |
-LL |     for i in 5..src.len() {
-   |              ^^^^^^^^^^^^ help: try replacing the loop by: `dst[5..src.len()].clone_from_slice(&src[(3 - 2)..((src.len() - 2) + 3 - 5)])`
+LL | /     for i in 5..src.len() {
+LL | |         dst[i] = src[count - 2];
+LL | |         count += 1;
+LL | |     }
+   | |_____^ help: try replacing the loop by: `dst[5..src.len()].clone_from_slice(&src[(3 - 2)..((src.len() - 2) + 3 - 5)]);`
 
 error: it looks like you're manually copying between slices
-  --> $DIR/manual_memcpy.rs:156:14
+  --> $DIR/manual_memcpy.rs:156:5
    |
-LL |     for i in 3..10 {
-   |              ^^^^^ help: try replacing the loop by: `dst[3..10].clone_from_slice(&src[5..(10 + 5 - 3)])`
+LL | /     for i in 3..10 {
+LL | |         dst[i] = src[count];
+LL | |         count += 1;
+LL | |     }
+   | |_____^ help: try replacing the loop by: `dst[3..10].clone_from_slice(&src[5..(10 + 5 - 3)]);`
 
 error: it looks like you're manually copying between slices
-  --> $DIR/manual_memcpy.rs:163:14
+  --> $DIR/manual_memcpy.rs:163:5
    |
-LL |     for i in 0..src.len() {
-   |              ^^^^^^^^^^^^
+LL | /     for i in 0..src.len() {
+LL | |         dst[count] = src[i];
+LL | |         dst2[count2] = src[i];
+LL | |         count += 1;
+LL | |         count2 += 1;
+LL | |     }
+   | |_____^
    |
 help: try replacing the loop by
    |
-LL |     for i in dst[3..(src.len() + 3)].clone_from_slice(&src[..])
-LL |     dst2[30..(src.len() + 30)].clone_from_slice(&src[..]) {
+LL |     dst[3..(src.len() + 3)].clone_from_slice(&src[..]);
+LL |     dst2[30..(src.len() + 30)].clone_from_slice(&src[..]);
    |
 
 error: it looks like you're manually copying between slices
-  --> $DIR/manual_memcpy.rs:173:14
+  --> $DIR/manual_memcpy.rs:173:5
    |
-LL |     for i in 0..1 << 1 {
-   |              ^^^^^^^^^ help: try replacing the loop by: `dst[(0 << 1)..((1 << 1) + (0 << 1))].clone_from_slice(&src[2..((1 << 1) + 2)])`
+LL | /     for i in 0..1 << 1 {
+LL | |         dst[count] = src[i + 2];
+LL | |         count += 1;
+LL | |     }
+   | |_____^ help: try replacing the loop by: `dst[(0 << 1)..((1 << 1) + (0 << 1))].clone_from_slice(&src[2..((1 << 1) + 2)]);`
 
 error: it looks like you're manually copying between slices
-  --> $DIR/manual_memcpy.rs:181:14
+  --> $DIR/manual_memcpy.rs:181:5
    |
-LL |     for i in 0..src.len() {
-   |              ^^^^^^^^^^^^ help: try replacing the loop by: `dst[..src.len()].clone_from_slice(&src[..])`
+LL | /     for i in 0..src.len() {
+LL | |         dst[i] = src[i].clone();
+LL | |     }
+   | |_____^ help: try replacing the loop by: `dst[..src.len()].clone_from_slice(&src[..]);`
 
 error: aborting due to 22 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From cd4706413fb891ffe33ef06e0c229d97258fbfaf Mon Sep 17 00:00:00 2001
From: Eduardo Broto <ebroto@tutanota.com>
Date: Sun, 27 Sep 2020 15:17:13 +0200
Subject: Run cargo dev fmt

---
 clippy_lints/src/missing_const_for_fn.rs       |   2 +-
 clippy_lints/src/utils/mod.rs                  |   2 +-
 clippy_lints/src/utils/qualify_min_const_fn.rs | 183 ++++++++++---------------
 3 files changed, 71 insertions(+), 116 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/missing_const_for_fn.rs b/clippy_lints/src/missing_const_for_fn.rs
index e5f7cc51111..3e786da28df 100644
--- a/clippy_lints/src/missing_const_for_fn.rs
+++ b/clippy_lints/src/missing_const_for_fn.rs
@@ -1,10 +1,10 @@
+use crate::utils::qualify_min_const_fn::is_min_const_fn;
 use crate::utils::{fn_has_unsatisfiable_preds, has_drop, is_entrypoint_fn, span_lint, trait_ref_of_method};
 use rustc_hir as hir;
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::{Body, Constness, FnDecl, GenericParamKind, HirId};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::lint::in_external_macro;
-use crate::utils::qualify_min_const_fn::is_min_const_fn;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::Span;
 use rustc_typeck::hir_ty_to_ty;
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index f59ed6df1a9..dfe2aadffc0 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -18,9 +18,9 @@ pub mod internal_lints;
 pub mod numeric_literal;
 pub mod paths;
 pub mod ptr;
+pub mod qualify_min_const_fn;
 pub mod sugg;
 pub mod usage;
-pub mod qualify_min_const_fn;
 
 pub use self::attrs::*;
 pub use self::diagnostics::*;
diff --git a/clippy_lints/src/utils/qualify_min_const_fn.rs b/clippy_lints/src/utils/qualify_min_const_fn.rs
index 6809b1fa88d..c1684575930 100644
--- a/clippy_lints/src/utils/qualify_min_const_fn.rs
+++ b/clippy_lints/src/utils/qualify_min_const_fn.rs
@@ -3,7 +3,7 @@ use rustc_hir::def_id::DefId;
 use rustc_middle::mir::*;
 use rustc_middle::ty::subst::GenericArgKind;
 use rustc_middle::ty::{self, adjustment::PointerCast, Ty, TyCtxt};
-use rustc_span::symbol::{sym};
+use rustc_span::symbol::sym;
 use rustc_span::Span;
 use rustc_target::spec::abi::Abi::RustIntrinsic;
 use std::borrow::Cow;
@@ -23,15 +23,9 @@ pub fn is_min_const_fn(tcx: TyCtxt<'tcx>, def_id: DefId, body: &'a Body<'tcx>) -
                 | ty::PredicateAtom::ConstEvaluatable(..)
                 | ty::PredicateAtom::ConstEquate(..)
                 | ty::PredicateAtom::TypeWellFormedFromEnv(..) => continue,
-                ty::PredicateAtom::ObjectSafe(_) => {
-                    panic!("object safe predicate on function: {:#?}", predicate)
-                }
-                ty::PredicateAtom::ClosureKind(..) => {
-                    panic!("closure kind predicate on function: {:#?}", predicate)
-                }
-                ty::PredicateAtom::Subtype(_) => {
-                    panic!("subtype predicate on function: {:#?}", predicate)
-                }
+                ty::PredicateAtom::ObjectSafe(_) => panic!("object safe predicate on function: {:#?}", predicate),
+                ty::PredicateAtom::ClosureKind(..) => panic!("closure kind predicate on function: {:#?}", predicate),
+                ty::PredicateAtom::Subtype(_) => panic!("subtype predicate on function: {:#?}", predicate),
                 ty::PredicateAtom::Trait(pred, _) => {
                     if Some(pred.def_id()) == tcx.lang_items().sized_trait() {
                         continue;
@@ -47,12 +41,12 @@ pub fn is_min_const_fn(tcx: TyCtxt<'tcx>, def_id: DefId, body: &'a Body<'tcx>) -
                                  on const fn parameters are unstable"
                                     .into(),
                             ));
-                        }
+                        },
                         // other kinds of bounds are either tautologies
                         // or cause errors in other passes
                         _ => continue,
                     }
-                }
+                },
             }
         }
         match predicates.parent {
@@ -92,24 +86,23 @@ fn check_ty(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>, span: Span) -> McfResult {
 
         match ty.kind() {
             ty::Ref(_, _, hir::Mutability::Mut) => {
-                    return Err((span, "mutable references in const fn are unstable".into()));
-            }
+                return Err((span, "mutable references in const fn are unstable".into()));
+            },
             ty::Opaque(..) => return Err((span, "`impl Trait` in const fn is unstable".into())),
             ty::FnPtr(..) => {
-                    return Err((span, "function pointers in const fn are unstable".into()));
-            }
+                return Err((span, "function pointers in const fn are unstable".into()));
+            },
             ty::Dynamic(preds, _) => {
                 for pred in preds.iter() {
                     match pred.skip_binder() {
-                        ty::ExistentialPredicate::AutoTrait(_)
-                        | ty::ExistentialPredicate::Projection(_) => {
+                        ty::ExistentialPredicate::AutoTrait(_) | ty::ExistentialPredicate::Projection(_) => {
                             return Err((
                                 span,
                                 "trait bounds other than `Sized` \
                                  on const fn parameters are unstable"
                                     .into(),
                             ));
-                        }
+                        },
                         ty::ExistentialPredicate::Trait(trait_ref) => {
                             if Some(trait_ref.def_id) != tcx.lang_items().sized_trait() {
                                 return Err((
@@ -119,34 +112,23 @@ fn check_ty(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>, span: Span) -> McfResult {
                                         .into(),
                                 ));
                             }
-                        }
+                        },
                     }
                 }
-            }
-            _ => {}
+            },
+            _ => {},
         }
     }
     Ok(())
 }
 
-fn check_rvalue(
-    tcx: TyCtxt<'tcx>,
-    body: &Body<'tcx>,
-    def_id: DefId,
-    rvalue: &Rvalue<'tcx>,
-    span: Span,
-) -> McfResult {
+fn check_rvalue(tcx: TyCtxt<'tcx>, body: &Body<'tcx>, def_id: DefId, rvalue: &Rvalue<'tcx>, span: Span) -> McfResult {
     match rvalue {
-        Rvalue::ThreadLocalRef(_) => {
-            Err((span, "cannot access thread local storage in const fn".into()))
-        }
-        Rvalue::Repeat(operand, _) | Rvalue::Use(operand) => {
-            check_operand(tcx, operand, span, body)
-        }
-        Rvalue::Len(place)
-        | Rvalue::Discriminant(place)
-        | Rvalue::Ref(_, _, place)
-        | Rvalue::AddressOf(_, place) => check_place(tcx, *place, span,  body),
+        Rvalue::ThreadLocalRef(_) => Err((span, "cannot access thread local storage in const fn".into())),
+        Rvalue::Repeat(operand, _) | Rvalue::Use(operand) => check_operand(tcx, operand, span, body),
+        Rvalue::Len(place) | Rvalue::Discriminant(place) | Rvalue::Ref(_, _, place) | Rvalue::AddressOf(_, place) => {
+            check_place(tcx, *place, span, body)
+        },
         Rvalue::Cast(CastKind::Misc, operand, cast_ty) => {
             use rustc_middle::ty::cast::CastTy;
             let cast_in = CastTy::from_ty(operand.ty(body, tcx)).expect("bad input type for cast");
@@ -154,20 +136,16 @@ fn check_rvalue(
             match (cast_in, cast_out) {
                 (CastTy::Ptr(_) | CastTy::FnPtr, CastTy::Int(_)) => {
                     Err((span, "casting pointers to ints is unstable in const fn".into()))
-                }
+                },
                 _ => check_operand(tcx, operand, span, body),
             }
-        }
-        Rvalue::Cast(
-            CastKind::Pointer(PointerCast::MutToConstPointer | PointerCast::ArrayToPointer),
-            operand,
-            _,
-        ) => check_operand(tcx, operand, span, body),
+        },
+        Rvalue::Cast(CastKind::Pointer(PointerCast::MutToConstPointer | PointerCast::ArrayToPointer), operand, _) => {
+            check_operand(tcx, operand, span, body)
+        },
         Rvalue::Cast(
             CastKind::Pointer(
-                PointerCast::UnsafeFnPointer
-                | PointerCast::ClosureFnPointer(_)
-                | PointerCast::ReifyFnPointer,
+                PointerCast::UnsafeFnPointer | PointerCast::ClosureFnPointer(_) | PointerCast::ReifyFnPointer,
             ),
             _,
             _,
@@ -177,10 +155,7 @@ fn check_rvalue(
                 deref_ty.ty
             } else {
                 // We cannot allow this for now.
-                return Err((
-                    span,
-                    "unsizing casts are only allowed for references right now".into(),
-                ));
+                return Err((span, "unsizing casts are only allowed for references right now".into()));
             };
             let unsized_ty = tcx.struct_tail_erasing_lifetimes(pointee_ty, tcx.param_env(def_id));
             if let ty::Slice(_) | ty::Str = unsized_ty.kind() {
@@ -191,7 +166,7 @@ fn check_rvalue(
                 // We just can't allow trait objects until we have figured out trait method calls.
                 Err((span, "unsizing casts are not allowed in const fn".into()))
             }
-        }
+        },
         // binops are fine on integers
         Rvalue::BinaryOp(_, lhs, rhs) | Rvalue::CheckedBinaryOp(_, lhs, rhs) => {
             check_operand(tcx, lhs, span, body)?;
@@ -200,13 +175,14 @@ fn check_rvalue(
             if ty.is_integral() || ty.is_bool() || ty.is_char() {
                 Ok(())
             } else {
-                Err((span, "only int, `bool` and `char` operations are stable in const fn".into()))
+                Err((
+                    span,
+                    "only int, `bool` and `char` operations are stable in const fn".into(),
+                ))
             }
-        }
+        },
         Rvalue::NullaryOp(NullOp::SizeOf, _) => Ok(()),
-        Rvalue::NullaryOp(NullOp::Box, _) => {
-            Err((span, "heap allocations are not allowed in const fn".into()))
-        }
+        Rvalue::NullaryOp(NullOp::Box, _) => Err((span, "heap allocations are not allowed in const fn".into())),
         Rvalue::UnaryOp(_, operand) => {
             let ty = operand.ty(body, tcx);
             if ty.is_integral() || ty.is_bool() {
@@ -214,39 +190,30 @@ fn check_rvalue(
             } else {
                 Err((span, "only int and `bool` operations are stable in const fn".into()))
             }
-        }
+        },
         Rvalue::Aggregate(_, operands) => {
             for operand in operands {
                 check_operand(tcx, operand, span, body)?;
             }
             Ok(())
-        }
+        },
     }
 }
 
-fn check_statement(
-    tcx: TyCtxt<'tcx>,
-    body: &Body<'tcx>,
-    def_id: DefId,
-    statement: &Statement<'tcx>,
-) -> McfResult {
+fn check_statement(tcx: TyCtxt<'tcx>, body: &Body<'tcx>, def_id: DefId, statement: &Statement<'tcx>) -> McfResult {
     let span = statement.source_info.span;
     match &statement.kind {
         StatementKind::Assign(box (place, rval)) => {
-            check_place(tcx, *place, span,  body)?;
+            check_place(tcx, *place, span, body)?;
             check_rvalue(tcx, body, def_id, rval, span)
-        }
+        },
 
         StatementKind::FakeRead(_, place) => check_place(tcx, **place, span, body),
 
         // just an assignment
-        StatementKind::SetDiscriminant { place, .. } => {
-            check_place(tcx, **place, span,  body)
-        }
+        StatementKind::SetDiscriminant { place, .. } => check_place(tcx, **place, span, body),
 
-        StatementKind::LlvmInlineAsm { .. } => {
-            Err((span, "cannot use inline assembly in const fn".into()))
-        }
+        StatementKind::LlvmInlineAsm { .. } => Err((span, "cannot use inline assembly in const fn".into())),
 
         // These are all NOPs
         StatementKind::StorageLive(_)
@@ -258,12 +225,7 @@ fn check_statement(
     }
 }
 
-fn check_operand(
-    tcx: TyCtxt<'tcx>,
-    operand: &Operand<'tcx>,
-    span: Span,
-    body: &Body<'tcx>,
-) -> McfResult {
+fn check_operand(tcx: TyCtxt<'tcx>, operand: &Operand<'tcx>, span: Span, body: &Body<'tcx>) -> McfResult {
     match operand {
         Operand::Move(place) | Operand::Copy(place) => check_place(tcx, *place, span, body),
         Operand::Constant(c) => match c.check_static_ptr(tcx) {
@@ -273,12 +235,7 @@ fn check_operand(
     }
 }
 
-fn check_place(
-    tcx: TyCtxt<'tcx>,
-    place: Place<'tcx>,
-    span: Span,
-    body: &Body<'tcx>,
-) -> McfResult {
+fn check_place(tcx: TyCtxt<'tcx>, place: Place<'tcx>, span: Span, body: &Body<'tcx>) -> McfResult {
     let mut cursor = place.projection.as_ref();
     while let &[ref proj_base @ .., elem] = cursor {
         cursor = proj_base;
@@ -288,26 +245,22 @@ fn check_place(
                 if let Some(def) = base_ty.ty_adt_def() {
                     // No union field accesses in `const fn`
                     if def.is_union() {
-                            return Err((span, "accessing union fields is unstable".into()));
+                        return Err((span, "accessing union fields is unstable".into()));
                     }
                 }
-            }
+            },
             ProjectionElem::ConstantIndex { .. }
             | ProjectionElem::Downcast(..)
             | ProjectionElem::Subslice { .. }
             | ProjectionElem::Deref
-            | ProjectionElem::Index(_) => {}
+            | ProjectionElem::Index(_) => {},
         }
     }
 
     Ok(())
 }
 
-fn check_terminator(
-    tcx: TyCtxt<'tcx>,
-    body: &'a Body<'tcx>,
-    terminator: &Terminator<'tcx>,
-) -> McfResult {
+fn check_terminator(tcx: TyCtxt<'tcx>, body: &'a Body<'tcx>, terminator: &Terminator<'tcx>) -> McfResult {
     let span = terminator.source_info.span;
     match &terminator.kind {
         TerminatorKind::FalseEdge { .. }
@@ -317,20 +270,23 @@ fn check_terminator(
         | TerminatorKind::Resume
         | TerminatorKind::Unreachable => Ok(()),
 
-        TerminatorKind::Drop { place, .. } => check_place(tcx, *place, span,  body),
+        TerminatorKind::Drop { place, .. } => check_place(tcx, *place, span, body),
         TerminatorKind::DropAndReplace { place, value, .. } => {
-            check_place(tcx, *place, span,  body)?;
+            check_place(tcx, *place, span, body)?;
             check_operand(tcx, value, span, body)
-        }
+        },
 
-        TerminatorKind::SwitchInt { discr, switch_ty: _, values: _, targets: _ } => {
-            check_operand(tcx, discr, span, body)
-        }
+        TerminatorKind::SwitchInt {
+            discr,
+            switch_ty: _,
+            values: _,
+            targets: _,
+        } => check_operand(tcx, discr, span, body),
 
         TerminatorKind::Abort => Err((span, "abort is not stable in const fn".into())),
         TerminatorKind::GeneratorDrop | TerminatorKind::Yield { .. } => {
             Err((span, "const fn generators are unstable".into()))
-        }
+        },
 
         TerminatorKind::Call {
             func,
@@ -342,8 +298,7 @@ fn check_terminator(
         } => {
             let fn_ty = func.ty(body, tcx);
             if let ty::FnDef(fn_def_id, _) = *fn_ty.kind() {
-                if !rustc_mir::const_eval::is_min_const_fn(tcx, fn_def_id)
-                {
+                if !rustc_mir::const_eval::is_min_const_fn(tcx, fn_def_id) {
                     return Err((
                         span,
                         format!(
@@ -359,9 +314,7 @@ fn check_terminator(
                 // within const fns. `transmute` is allowed in all other const contexts.
                 // This won't really scale to more intrinsics or functions. Let's allow const
                 // transmutes in const fn before we add more hacks to this.
-                if tcx.fn_sig(fn_def_id).abi() == RustIntrinsic
-                    && tcx.item_name(fn_def_id) == sym::transmute
-                {
+                if tcx.fn_sig(fn_def_id).abi() == RustIntrinsic && tcx.item_name(fn_def_id) == sym::transmute {
                     return Err((
                         span,
                         "can only call `transmute` from const items, not `const fn`".into(),
@@ -377,14 +330,16 @@ fn check_terminator(
             } else {
                 Err((span, "can only call other const fns within const fn".into()))
             }
-        }
+        },
 
-        TerminatorKind::Assert { cond, expected: _, msg: _, target: _, cleanup: _ } => {
-            check_operand(tcx, cond, span, body)
-        }
+        TerminatorKind::Assert {
+            cond,
+            expected: _,
+            msg: _,
+            target: _,
+            cleanup: _,
+        } => check_operand(tcx, cond, span, body),
 
-        TerminatorKind::InlineAsm { .. } => {
-            Err((span, "cannot use inline assembly in const fn".into()))
-        }
+        TerminatorKind::InlineAsm { .. } => Err((span, "cannot use inline assembly in const fn".into())),
     }
 }
-- 
cgit 1.4.1-3-g733a5


From 8bf27c5e92af39215a3d1da992a7207dafc883e1 Mon Sep 17 00:00:00 2001
From: Eduardo Broto <ebroto@tutanota.com>
Date: Sun, 27 Sep 2020 15:20:19 +0200
Subject: Fix dogfood

---
 clippy_lints/src/utils/qualify_min_const_fn.rs | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/qualify_min_const_fn.rs b/clippy_lints/src/utils/qualify_min_const_fn.rs
index c1684575930..3773b9d9a2e 100644
--- a/clippy_lints/src/utils/qualify_min_const_fn.rs
+++ b/clippy_lints/src/utils/qualify_min_const_fn.rs
@@ -1,6 +1,9 @@
 use rustc_hir as hir;
 use rustc_hir::def_id::DefId;
-use rustc_middle::mir::*;
+use rustc_middle::mir::{
+    Body, CastKind, NullOp, Operand, Place, ProjectionElem, Rvalue, Statement, StatementKind, Terminator,
+    TerminatorKind,
+};
 use rustc_middle::ty::subst::GenericArgKind;
 use rustc_middle::ty::{self, adjustment::PointerCast, Ty, TyCtxt};
 use rustc_span::symbol::sym;
@@ -208,8 +211,7 @@ fn check_statement(tcx: TyCtxt<'tcx>, body: &Body<'tcx>, def_id: DefId, statemen
             check_rvalue(tcx, body, def_id, rval, span)
         },
 
-        StatementKind::FakeRead(_, place) => check_place(tcx, **place, span, body),
-
+        StatementKind::FakeRead(_, place) |
         // just an assignment
         StatementKind::SetDiscriminant { place, .. } => check_place(tcx, **place, span, body),
 
@@ -237,7 +239,7 @@ fn check_operand(tcx: TyCtxt<'tcx>, operand: &Operand<'tcx>, span: Span, body: &
 
 fn check_place(tcx: TyCtxt<'tcx>, place: Place<'tcx>, span: Span, body: &Body<'tcx>) -> McfResult {
     let mut cursor = place.projection.as_ref();
-    while let &[ref proj_base @ .., elem] = cursor {
+    while let [ref proj_base @ .., elem] = *cursor {
         cursor = proj_base;
         match elem {
             ProjectionElem::Field(..) => {
-- 
cgit 1.4.1-3-g733a5


From 9725f00f4dd089b875a5d5306ff906494e041f38 Mon Sep 17 00:00:00 2001
From: rail <12975677+rail-rain@users.noreply.github.com>
Date: Mon, 28 Sep 2020 02:27:55 +1300
Subject: Use the `From` trait to make `MinifyingSugg`

---
 clippy_lints/src/loops.rs      | 84 +++++++++++++++++++-----------------------
 clippy_lints/src/utils/sugg.rs |  6 ++-
 2 files changed, 42 insertions(+), 48 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 7c8b6f483bc..215700fed8c 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -817,22 +817,22 @@ struct Offset {
 }
 
 impl Offset {
-    fn negative(value: MinifyingSugg<'static>) -> Self {
+    fn negative(value: Sugg<'static>) -> Self {
         Self {
-            value,
+            value: value.into(),
             sign: OffsetSign::Negative,
         }
     }
 
-    fn positive(value: MinifyingSugg<'static>) -> Self {
+    fn positive(value: Sugg<'static>) -> Self {
         Self {
-            value,
+            value: value.into(),
             sign: OffsetSign::Positive,
         }
     }
 
     fn empty() -> Self {
-        Self::positive(MinifyingSugg::non_paren("0"))
+        Self::positive(sugg::ZERO)
     }
 }
 
@@ -844,30 +844,22 @@ fn apply_offset(lhs: &MinifyingSugg<'static>, rhs: &Offset) -> MinifyingSugg<'st
 }
 
 #[derive(Clone)]
-struct MinifyingSugg<'a>(sugg::Sugg<'a>);
-
-impl std::fmt::Display for MinifyingSugg<'_> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
-        std::fmt::Display::fmt(&self.0, f)
-    }
-}
+struct MinifyingSugg<'a>(Sugg<'a>);
 
 impl<'a> MinifyingSugg<'a> {
     fn as_str(&self) -> &str {
-        let sugg::Sugg::NonParen(s) | sugg::Sugg::MaybeParen(s) | sugg::Sugg::BinOp(_, s) = &self.0;
+        let Sugg::NonParen(s) | Sugg::MaybeParen(s) | Sugg::BinOp(_, s) = &self.0;
         s.as_ref()
     }
 
-    fn hir(cx: &LateContext<'_>, expr: &Expr<'_>, default: &'a str) -> Self {
-        Self(sugg::Sugg::hir(cx, expr, default))
-    }
-
-    fn maybe_par(self) -> Self {
-        Self(self.0.maybe_par())
+    fn into_sugg(self) -> Sugg<'a> {
+        self.0
     }
+}
 
-    fn non_paren(str: impl Into<std::borrow::Cow<'a, str>>) -> Self {
-        Self(sugg::Sugg::NonParen(str.into()))
+impl<'a> From<Sugg<'a>> for MinifyingSugg<'a> {
+    fn from(sugg: Sugg<'a>) -> Self {
+        Self(sugg)
     }
 }
 
@@ -877,7 +869,7 @@ impl std::ops::Add for &MinifyingSugg<'static> {
         match (self.as_str(), rhs.as_str()) {
             ("0", _) => rhs.clone(),
             (_, "0") => self.clone(),
-            (_, _) => MinifyingSugg(&self.0 + &rhs.0),
+            (_, _) => (&self.0 + &rhs.0).into(),
         }
     }
 }
@@ -887,9 +879,9 @@ impl std::ops::Sub for &MinifyingSugg<'static> {
     fn sub(self, rhs: &MinifyingSugg<'static>) -> MinifyingSugg<'static> {
         match (self.as_str(), rhs.as_str()) {
             (_, "0") => self.clone(),
-            ("0", _) => MinifyingSugg(-(rhs.0.clone())),
-            (x, y) if x == y => MinifyingSugg::non_paren("0"),
-            (_, _) => MinifyingSugg(&self.0 - &rhs.0),
+            ("0", _) => (-rhs.0.clone()).into(),
+            (x, y) if x == y => sugg::ZERO.into(),
+            (_, _) => (&self.0 - &rhs.0).into(),
         }
     }
 }
@@ -900,7 +892,7 @@ impl std::ops::Add<&MinifyingSugg<'static>> for MinifyingSugg<'static> {
         match (self.as_str(), rhs.as_str()) {
             ("0", _) => rhs.clone(),
             (_, "0") => self,
-            (_, _) => MinifyingSugg(self.0 + &rhs.0),
+            (_, _) => (self.0 + &rhs.0).into(),
         }
     }
 }
@@ -910,9 +902,9 @@ impl std::ops::Sub<&MinifyingSugg<'static>> for MinifyingSugg<'static> {
     fn sub(self, rhs: &MinifyingSugg<'static>) -> MinifyingSugg<'static> {
         match (self.as_str(), rhs.as_str()) {
             (_, "0") => self,
-            ("0", _) => MinifyingSugg(-(rhs.0.clone())),
-            (x, y) if x == y => MinifyingSugg::non_paren("0"),
-            (_, _) => MinifyingSugg(self.0 - &rhs.0),
+            ("0", _) => (-rhs.0.clone()).into(),
+            (x, y) if x == y => sugg::ZERO.into(),
+            (_, _) => (self.0 - &rhs.0).into(),
         }
     }
 }
@@ -969,19 +961,15 @@ fn get_details_from_idx<'tcx>(
         })
     }
 
-    fn get_offset<'tcx>(
-        cx: &LateContext<'tcx>,
-        e: &Expr<'_>,
-        starts: &[Start<'tcx>],
-    ) -> Option<MinifyingSugg<'static>> {
+    fn get_offset<'tcx>(cx: &LateContext<'tcx>, e: &Expr<'_>, starts: &[Start<'tcx>]) -> Option<Sugg<'static>> {
         match &e.kind {
             ExprKind::Lit(l) => match l.node {
-                ast::LitKind::Int(x, _ty) => Some(MinifyingSugg::non_paren(x.to_string())),
+                ast::LitKind::Int(x, _ty) => Some(Sugg::NonParen(x.to_string().into())),
                 _ => None,
             },
             ExprKind::Path(..) if get_start(cx, e, starts).is_none() => {
                 // `e` is always non paren as it's a `Path`
-                Some(MinifyingSugg::non_paren(snippet(cx, e.span, "???")))
+                Some(Sugg::NonParen(snippet(cx, e.span, "???")))
             },
             _ => None,
         }
@@ -1072,7 +1060,7 @@ fn build_manual_memcpy_suggestion<'tcx>(
 ) -> String {
     fn print_offset(offset: MinifyingSugg<'static>) -> MinifyingSugg<'static> {
         if offset.as_str() == "0" {
-            MinifyingSugg::non_paren("")
+            sugg::EMPTY.into()
         } else {
             offset
         }
@@ -1088,14 +1076,14 @@ fn build_manual_memcpy_suggestion<'tcx>(
                 if var_def_id(cx, arg) == var_def_id(cx, base);
                 then {
                     if sugg.as_str() == end_str {
-                        MinifyingSugg::non_paren("")
+                        sugg::EMPTY.into()
                     } else {
                         sugg
                     }
                 } else {
                     match limits {
                         ast::RangeLimits::Closed => {
-                            sugg + &MinifyingSugg::non_paren("1")
+                            sugg + &sugg::ONE.into()
                         },
                         ast::RangeLimits::HalfOpen => sugg,
                     }
@@ -1103,29 +1091,31 @@ fn build_manual_memcpy_suggestion<'tcx>(
             }
         };
 
-    let start_str = MinifyingSugg::hir(cx, start, "");
-    let end_str = MinifyingSugg::hir(cx, end, "");
+    let start_str = Sugg::hir(cx, start, "").into();
+    let end_str: MinifyingSugg<'_> = Sugg::hir(cx, end, "").into();
 
     let print_offset_and_limit = |idx_expr: &IndexExpr<'_>| match idx_expr.idx {
         StartKind::Range => (
-            print_offset(apply_offset(&start_str, &idx_expr.idx_offset)),
+            print_offset(apply_offset(&start_str, &idx_expr.idx_offset)).into_sugg(),
             print_limit(
                 end,
                 end_str.as_str(),
                 idx_expr.base,
                 apply_offset(&end_str, &idx_expr.idx_offset),
-            ),
+            )
+            .into_sugg(),
         ),
         StartKind::Counter { initializer } => {
-            let counter_start = MinifyingSugg::hir(cx, initializer, "");
+            let counter_start = Sugg::hir(cx, initializer, "").into();
             (
-                print_offset(apply_offset(&counter_start, &idx_expr.idx_offset)),
+                print_offset(apply_offset(&counter_start, &idx_expr.idx_offset)).into_sugg(),
                 print_limit(
                     end,
                     end_str.as_str(),
                     idx_expr.base,
                     apply_offset(&end_str, &idx_expr.idx_offset) + &counter_start - &start_str,
-                ),
+                )
+                .into_sugg(),
             )
         },
     };
@@ -1136,7 +1126,7 @@ fn build_manual_memcpy_suggestion<'tcx>(
     let dst_base_str = snippet(cx, dst.base.span, "???");
     let src_base_str = snippet(cx, src.base.span, "???");
 
-    let dst = if dst_offset.as_str() == "" && dst_limit.as_str() == "" {
+    let dst = if dst_offset == sugg::EMPTY && dst_limit == sugg::EMPTY {
         dst_base_str
     } else {
         format!(
diff --git a/clippy_lints/src/utils/sugg.rs b/clippy_lints/src/utils/sugg.rs
index 062b273c0f4..0b2cb667bf4 100644
--- a/clippy_lints/src/utils/sugg.rs
+++ b/clippy_lints/src/utils/sugg.rs
@@ -16,7 +16,7 @@ use std::fmt::Display;
 use std::ops::{Add, Neg, Not, Sub};
 
 /// A helper type to build suggestion correctly handling parenthesis.
-#[derive(Clone)]
+#[derive(Clone, PartialEq)]
 pub enum Sugg<'a> {
     /// An expression that never needs parenthesis such as `1337` or `[0; 42]`.
     NonParen(Cow<'a, str>),
@@ -27,8 +27,12 @@ pub enum Sugg<'a> {
     BinOp(AssocOp, Cow<'a, str>),
 }
 
+/// Literal constant `0`, for convenience.
+pub const ZERO: Sugg<'static> = Sugg::NonParen(Cow::Borrowed("0"));
 /// Literal constant `1`, for convenience.
 pub const ONE: Sugg<'static> = Sugg::NonParen(Cow::Borrowed("1"));
+/// a constant represents an empty string, for convenience.
+pub const EMPTY: Sugg<'static> = Sugg::NonParen(Cow::Borrowed(""));
 
 impl Display for Sugg<'_> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
-- 
cgit 1.4.1-3-g733a5


From 101e76f117eeefcd2e901bab707de199b030f201 Mon Sep 17 00:00:00 2001
From: Eduardo Broto <ebroto@tutanota.com>
Date: Mon, 28 Sep 2020 19:14:39 +0200
Subject: needless arbitrary self: handle macros

---
 clippy_lints/src/needless_arbitrary_self_type.rs   | 30 +++++++++--
 tests/ui/auxiliary/proc_macro_attr.rs              | 61 +++++++++++++++++++++-
 tests/ui/needless_arbitrary_self_type_unfixable.rs | 45 ++++++++++++++++
 .../needless_arbitrary_self_type_unfixable.stderr  | 10 ++++
 4 files changed, 139 insertions(+), 7 deletions(-)
 create mode 100644 tests/ui/needless_arbitrary_self_type_unfixable.rs
 create mode 100644 tests/ui/needless_arbitrary_self_type_unfixable.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/needless_arbitrary_self_type.rs b/clippy_lints/src/needless_arbitrary_self_type.rs
index 38bdd0f7ed2..7687962bdd9 100644
--- a/clippy_lints/src/needless_arbitrary_self_type.rs
+++ b/clippy_lints/src/needless_arbitrary_self_type.rs
@@ -1,4 +1,4 @@
-use crate::utils::span_lint_and_sugg;
+use crate::utils::{in_macro, span_lint_and_sugg};
 use if_chain::if_chain;
 use rustc_ast::ast::{BindingMode, Lifetime, Mutability, Param, PatKind, Path, TyKind};
 use rustc_errors::Applicability;
@@ -69,11 +69,30 @@ fn check_param_inner(cx: &EarlyContext<'_>, path: &Path, span: Span, binding_mod
         if let [segment] = &path.segments[..];
         if segment.ident.name == kw::SelfUpper;
         then {
+            // In case we have a named lifetime, we check if the name comes from expansion.
+            // If it does, at this point we know the rest of the parameter was written by the user,
+            // so let them decide what the name of the lifetime should be.
+            // See #6089 for more details.
+            let mut applicability = Applicability::MachineApplicable;
             let self_param = match (binding_mode, mutbl) {
                 (Mode::Ref(None), Mutability::Mut) => "&mut self".to_string(),
-                (Mode::Ref(Some(lifetime)), Mutability::Mut) => format!("&{} mut self", &lifetime.ident.name),
+                (Mode::Ref(Some(lifetime)), Mutability::Mut) => {
+                    if in_macro(lifetime.ident.span) {
+                        applicability = Applicability::HasPlaceholders;
+                        "&'_ mut self".to_string()
+                    } else {
+                        format!("&{} mut self", &lifetime.ident.name)
+                    }
+                },
                 (Mode::Ref(None), Mutability::Not) => "&self".to_string(),
-                (Mode::Ref(Some(lifetime)), Mutability::Not) => format!("&{} self", &lifetime.ident.name),
+                (Mode::Ref(Some(lifetime)), Mutability::Not) => {
+                    if in_macro(lifetime.ident.span) {
+                        applicability = Applicability::HasPlaceholders;
+                        "&'_ self".to_string()
+                    } else {
+                        format!("&{} self", &lifetime.ident.name)
+                    }
+                },
                 (Mode::Value, Mutability::Mut) => "mut self".to_string(),
                 (Mode::Value, Mutability::Not) => "self".to_string(),
             };
@@ -85,7 +104,7 @@ fn check_param_inner(cx: &EarlyContext<'_>, path: &Path, span: Span, binding_mod
                 "the type of the `self` parameter does not need to be arbitrary",
                 "consider to change this parameter to",
                 self_param,
-                Applicability::MachineApplicable,
+                applicability,
             )
         }
     }
@@ -93,7 +112,8 @@ fn check_param_inner(cx: &EarlyContext<'_>, path: &Path, span: Span, binding_mod
 
 impl EarlyLintPass for NeedlessArbitrarySelfType {
     fn check_param(&mut self, cx: &EarlyContext<'_>, p: &Param) {
-        if !p.is_self() {
+        // Bail out if the parameter it's not a receiver or was not written by the user
+        if !p.is_self() || in_macro(p.span) {
             return;
         }
 
diff --git a/tests/ui/auxiliary/proc_macro_attr.rs b/tests/ui/auxiliary/proc_macro_attr.rs
index 01796d45f13..de670cdfc31 100644
--- a/tests/ui/auxiliary/proc_macro_attr.rs
+++ b/tests/ui/auxiliary/proc_macro_attr.rs
@@ -2,7 +2,7 @@
 // no-prefer-dynamic
 
 #![crate_type = "proc-macro"]
-#![feature(repr128, proc_macro_hygiene, proc_macro_quote)]
+#![feature(repr128, proc_macro_hygiene, proc_macro_quote, box_patterns)]
 #![allow(clippy::useless_conversion)]
 
 extern crate proc_macro;
@@ -12,7 +12,11 @@ extern crate syn;
 use proc_macro::TokenStream;
 use quote::{quote, quote_spanned};
 use syn::parse_macro_input;
-use syn::{parse_quote, ItemTrait, TraitItem};
+use syn::spanned::Spanned;
+use syn::token::Star;
+use syn::{
+    parse_quote, FnArg, ImplItem, ItemImpl, ItemTrait, Lifetime, Pat, PatIdent, PatType, Signature, TraitItem, Type,
+};
 
 #[proc_macro_attribute]
 pub fn fake_async_trait(_args: TokenStream, input: TokenStream) -> TokenStream {
@@ -36,3 +40,56 @@ pub fn fake_async_trait(_args: TokenStream, input: TokenStream) -> TokenStream {
     }
     TokenStream::from(quote!(#item))
 }
+
+#[proc_macro_attribute]
+pub fn rename_my_lifetimes(_args: TokenStream, input: TokenStream) -> TokenStream {
+    fn make_name(count: usize) -> String {
+        format!("'life{}", count)
+    }
+
+    fn mut_receiver_of(sig: &mut Signature) -> Option<&mut FnArg> {
+        let arg = sig.inputs.first_mut()?;
+        if let FnArg::Typed(PatType { pat, .. }) = arg {
+            if let Pat::Ident(PatIdent { ident, .. }) = &**pat {
+                if ident == "self" {
+                    return Some(arg);
+                }
+            }
+        }
+        None
+    }
+
+    let mut elided = 0;
+    let mut item = parse_macro_input!(input as ItemImpl);
+
+    // Look for methods having arbitrary self type taken by &mut ref
+    for inner in &mut item.items {
+        if let ImplItem::Method(method) = inner {
+            if let Some(FnArg::Typed(pat_type)) = mut_receiver_of(&mut method.sig) {
+                if let box Type::Reference(reference) = &mut pat_type.ty {
+                    // Target only unnamed lifetimes
+                    let name = match &reference.lifetime {
+                        Some(lt) if lt.ident == "_" => make_name(elided),
+                        None => make_name(elided),
+                        _ => continue,
+                    };
+                    elided += 1;
+
+                    // HACK: Syn uses `Span` from the proc_macro2 crate, and does not seem to reexport it.
+                    // In order to avoid adding the dependency, get a default span from a non-existent token.
+                    // A default span is needed to mark the code as coming from expansion.
+                    let span = Star::default().span();
+
+                    // Replace old lifetime with the named one
+                    let lifetime = Lifetime::new(&name, span);
+                    reference.lifetime = Some(parse_quote!(#lifetime));
+
+                    // Add lifetime to the generics of the method
+                    method.sig.generics.params.push(parse_quote!(#lifetime));
+                }
+            }
+        }
+    }
+
+    TokenStream::from(quote!(#item))
+}
diff --git a/tests/ui/needless_arbitrary_self_type_unfixable.rs b/tests/ui/needless_arbitrary_self_type_unfixable.rs
new file mode 100644
index 00000000000..a39d96109f1
--- /dev/null
+++ b/tests/ui/needless_arbitrary_self_type_unfixable.rs
@@ -0,0 +1,45 @@
+// aux-build:proc_macro_attr.rs
+
+#![warn(clippy::needless_arbitrary_self_type)]
+
+#[macro_use]
+extern crate proc_macro_attr;
+
+mod issue_6089 {
+    // Check that we don't lint if the `self` parameter comes from expansion
+
+    macro_rules! test_from_expansion {
+        () => {
+            trait T1 {
+                fn test(self: &Self);
+            }
+
+            struct S1 {}
+
+            impl T1 for S1 {
+                fn test(self: &Self) {}
+            }
+        };
+    }
+
+    test_from_expansion!();
+
+    // If only the lifetime name comes from expansion we will lint, but the suggestion will have
+    // placeholders and will not be applied automatically, as we can't reliably know the original name.
+    // This specific case happened with async_trait.
+
+    trait T2 {
+        fn call_with_mut_self(&mut self);
+    }
+
+    struct S2 {}
+
+    // The method's signature will be expanded to:
+    //  fn call_with_mut_self<'life0>(self: &'life0 mut Self) {}
+    #[rename_my_lifetimes]
+    impl T2 for S2 {
+        fn call_with_mut_self(self: &mut Self) {}
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/needless_arbitrary_self_type_unfixable.stderr b/tests/ui/needless_arbitrary_self_type_unfixable.stderr
new file mode 100644
index 00000000000..44a0e6ddeac
--- /dev/null
+++ b/tests/ui/needless_arbitrary_self_type_unfixable.stderr
@@ -0,0 +1,10 @@
+error: the type of the `self` parameter does not need to be arbitrary
+  --> $DIR/needless_arbitrary_self_type_unfixable.rs:41:31
+   |
+LL |         fn call_with_mut_self(self: &mut Self) {}
+   |                               ^^^^^^^^^^^^^^^ help: consider to change this parameter to: `&'_ mut self`
+   |
+   = note: `-D clippy::needless-arbitrary-self-type` implied by `-D warnings`
+
+error: aborting due to previous error
+
-- 
cgit 1.4.1-3-g733a5


From aa2ac38fa7224bff68eeff8781321c9c355e5980 Mon Sep 17 00:00:00 2001
From: Tim Nielens <tim.nielens@gmail.com>
Date: Wed, 30 Sep 2020 00:08:19 +0200
Subject: needless-lifetime / add known problem item

---
 clippy_lints/src/lifetimes.rs | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lifetimes.rs b/clippy_lints/src/lifetimes.rs
index 1d17fbd3725..530968c191f 100644
--- a/clippy_lints/src/lifetimes.rs
+++ b/clippy_lints/src/lifetimes.rs
@@ -26,8 +26,11 @@ declare_clippy_lint! {
     /// complicated, while there is nothing out of the ordinary going on. Removing
     /// them leads to more readable code.
     ///
-    /// **Known problems:** Potential false negatives: we bail out if the function
-    /// has a `where` clause where lifetimes are mentioned.
+    /// **Known problems:**
+    /// - We bail out if the function has a `where` clause where lifetimes
+    /// are mentioned due to potenial false positives.
+    /// - Lifetime bounds such as `impl Foo + 'a` and `T: 'a` must be elided with the
+    /// placeholder notation `'_` because the fully elided notation leaves the type bound to `'static`.
     ///
     /// **Example:**
     /// ```rust
-- 
cgit 1.4.1-3-g733a5


From cb2be6f9dba0224c63180eada2d089100450391a Mon Sep 17 00:00:00 2001
From: Tim Nielens <tim.nielens@gmail.com>
Date: Wed, 30 Sep 2020 00:33:46 +0200
Subject: needless-lifetime / pr remarks

---
 clippy_lints/src/lifetimes.rs      |  1 +
 tests/ui/needless_lifetimes.rs     | 18 +++++++++++++++++-
 tests/ui/needless_lifetimes.stderr | 20 +++++++++++++++++++-
 3 files changed, 37 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lifetimes.rs b/clippy_lints/src/lifetimes.rs
index 530968c191f..d7043e7bd8f 100644
--- a/clippy_lints/src/lifetimes.rs
+++ b/clippy_lints/src/lifetimes.rs
@@ -383,6 +383,7 @@ impl<'a, 'tcx> Visitor<'tcx> for RefVisitor<'a, 'tcx> {
                 let mut sub_visitor = RefVisitor::new(self.cx);
                 sub_visitor.visit_fn_decl(decl);
                 self.nested_elision_site_lts.append(&mut sub_visitor.all_lts());
+                return;
             },
             TyKind::TraitObject(bounds, ref lt) => {
                 if !lt.is_elided() {
diff --git a/tests/ui/needless_lifetimes.rs b/tests/ui/needless_lifetimes.rs
index 548c5929c61..d482d466e44 100644
--- a/tests/ui/needless_lifetimes.rs
+++ b/tests/ui/needless_lifetimes.rs
@@ -336,9 +336,25 @@ mod nested_elision_sites {
         |i| i
     }
     // lint
-    fn pointer_fn_elidable<'a>(f: fn(&i32) -> &i32, i: &'a i32) -> &'a i32 {
+    fn pointer_fn_elidable<'a>(i: &'a i32, f: fn(&i32) -> &i32) -> &'a i32 {
         f(i)
     }
+
+    // don't lint
+    fn nested_fn_pointer_1<'a>(_: &'a i32) -> fn(fn(&'a i32) -> &'a i32) -> i32 {
+        |f| 42
+    }
+    fn nested_fn_pointer_2<'a>(_: &'a i32) -> impl Fn(fn(&'a i32)) {
+        |f| ()
+    }
+
+    // lint
+    fn nested_fn_pointer_3<'a>(_: &'a i32) -> fn(fn(&i32) -> &i32) -> i32 {
+        |f| 42
+    }
+    fn nested_fn_pointer_4<'a>(_: &'a i32) -> impl Fn(fn(&i32)) {
+        |f| ()
+    }
 }
 
 fn main() {}
diff --git a/tests/ui/needless_lifetimes.stderr b/tests/ui/needless_lifetimes.stderr
index ac38ab8effd..c8a2e8b81c0 100644
--- a/tests/ui/needless_lifetimes.stderr
+++ b/tests/ui/needless_lifetimes.stderr
@@ -132,5 +132,23 @@ error: explicit lifetimes given in parameter types where they could be elided (o
 LL |     fn where_clause_elidadable<'a, T>(i: &'a i32, f: T) -> &'a i32
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 22 previous errors
+error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+  --> $DIR/needless_lifetimes.rs:339:5
+   |
+LL |     fn pointer_fn_elidable<'a>(i: &'a i32, f: fn(&i32) -> &i32) -> &'a i32 {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+  --> $DIR/needless_lifetimes.rs:352:5
+   |
+LL |     fn nested_fn_pointer_3<'a>(_: &'a i32) -> fn(fn(&i32) -> &i32) -> i32 {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+  --> $DIR/needless_lifetimes.rs:355:5
+   |
+LL |     fn nested_fn_pointer_4<'a>(_: &'a i32) -> impl Fn(fn(&i32)) {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 25 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 0690f9c5d526baa593cc62b175ef5e7f2c8f4f9c Mon Sep 17 00:00:00 2001
From: Jethro Beekman <jethro@fortanix.com>
Date: Mon, 28 Sep 2020 15:30:47 +0200
Subject: Add lint for inline assembly syntax style preference

---
 CHANGELOG.md                   |   2 +
 clippy_lints/src/asm_syntax.rs | 125 +++++++++++++++++++++++++++++++++++++++++
 clippy_lints/src/lib.rs        |   7 +++
 src/lintlist/mod.rs            |  14 +++++
 tests/ui/asm_syntax.rs         |  31 ++++++++++
 tests/ui/asm_syntax.stderr     |  44 +++++++++++++++
 6 files changed, 223 insertions(+)
 create mode 100644 clippy_lints/src/asm_syntax.rs
 create mode 100644 tests/ui/asm_syntax.rs
 create mode 100644 tests/ui/asm_syntax.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 575cbd60792..0de6f4b4235 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1635,6 +1635,8 @@ Released 2018-09-13
 [`inherent_to_string`]: https://rust-lang.github.io/rust-clippy/master/index.html#inherent_to_string
 [`inherent_to_string_shadow_display`]: https://rust-lang.github.io/rust-clippy/master/index.html#inherent_to_string_shadow_display
 [`inline_always`]: https://rust-lang.github.io/rust-clippy/master/index.html#inline_always
+[`inline_asm_x86_att_syntax`]: https://rust-lang.github.io/rust-clippy/master/index.html#inline_asm_x86_att_syntax
+[`inline_asm_x86_intel_syntax`]: https://rust-lang.github.io/rust-clippy/master/index.html#inline_asm_x86_intel_syntax
 [`inline_fn_without_body`]: https://rust-lang.github.io/rust-clippy/master/index.html#inline_fn_without_body
 [`int_plus_one`]: https://rust-lang.github.io/rust-clippy/master/index.html#int_plus_one
 [`integer_arithmetic`]: https://rust-lang.github.io/rust-clippy/master/index.html#integer_arithmetic
diff --git a/clippy_lints/src/asm_syntax.rs b/clippy_lints/src/asm_syntax.rs
new file mode 100644
index 00000000000..ef1f1a14afc
--- /dev/null
+++ b/clippy_lints/src/asm_syntax.rs
@@ -0,0 +1,125 @@
+use std::fmt;
+
+use crate::utils::span_lint_and_help;
+use rustc_ast::ast::{Expr, ExprKind, InlineAsmOptions};
+use rustc_lint::{EarlyContext, EarlyLintPass, Lint};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+#[derive(Clone, Copy, PartialEq, Eq)]
+enum AsmStyle {
+    Intel,
+    Att,
+}
+
+impl fmt::Display for AsmStyle {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            AsmStyle::Intel => f.write_str("Intel"),
+            AsmStyle::Att => f.write_str("AT&T"),
+        }
+    }
+}
+
+impl std::ops::Not for AsmStyle {
+    type Output = AsmStyle;
+
+    fn not(self) -> AsmStyle {
+        match self {
+            AsmStyle::Intel => AsmStyle::Att,
+            AsmStyle::Att => AsmStyle::Intel,
+        }
+    }
+}
+
+fn check_expr_asm_syntax(lint: &'static Lint, cx: &EarlyContext<'_>, expr: &Expr, check_for: AsmStyle) {
+    if let ExprKind::InlineAsm(ref inline_asm) = expr.kind {
+        let style = if inline_asm.options.contains(InlineAsmOptions::ATT_SYNTAX) {
+            AsmStyle::Att
+        } else {
+            AsmStyle::Intel
+        };
+
+        if style == check_for {
+            span_lint_and_help(
+                cx,
+                lint,
+                expr.span,
+                &format!("{} x86 assembly syntax used", style),
+                None,
+                &format!("use {} x86 assembly syntax", !style),
+            );
+        }
+    }
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for usage of Intel x86 assembly syntax.
+    ///
+    /// **Why is this bad?** The lint has been enabled to indicate a preference
+    /// for AT&T x86 assembly syntax.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust,no_run
+    /// # #![feature(asm)]
+    /// # unsafe { let ptr = "".as_ptr();
+    /// asm!("lea {}, [{}]", lateout(reg) _, in(reg) ptr);
+    /// # }
+    /// ```
+    /// Use instead:
+    /// ```rust,no_run
+    /// # #![feature(asm)]
+    /// # unsafe { let ptr = "".as_ptr();
+    /// asm!("lea ({}), {}", in(reg) ptr, lateout(reg) _, options(att_syntax));
+    /// # }
+    /// ```
+    pub INLINE_ASM_X86_INTEL_SYNTAX,
+    restriction,
+    "prefer AT&T x86 assembly syntax"
+}
+
+declare_lint_pass!(InlineAsmX86IntelSyntax => [INLINE_ASM_X86_INTEL_SYNTAX]);
+
+impl EarlyLintPass for InlineAsmX86IntelSyntax {
+    fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
+        check_expr_asm_syntax(Self::get_lints()[0], cx, expr, AsmStyle::Intel);
+    }
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for usage of AT&T x86 assembly syntax.
+    ///
+    /// **Why is this bad?** The lint has been enabled to indicate a preference
+    /// for Intel x86 assembly syntax.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust,no_run
+    /// # #![feature(asm)]
+    /// # unsafe { let ptr = "".as_ptr();
+    /// asm!("lea ({}), {}", in(reg) ptr, lateout(reg) _, options(att_syntax));
+    /// # }
+    /// ```
+    /// Use instead:
+    /// ```rust,no_run
+    /// # #![feature(asm)]
+    /// # unsafe { let ptr = "".as_ptr();
+    /// asm!("lea {}, [{}]", lateout(reg) _, in(reg) ptr);
+    /// # }
+    /// ```
+    pub INLINE_ASM_X86_ATT_SYNTAX,
+    restriction,
+    "prefer Intel x86 assembly syntax"
+}
+
+declare_lint_pass!(InlineAsmX86AttSyntax => [INLINE_ASM_X86_ATT_SYNTAX]);
+
+impl EarlyLintPass for InlineAsmX86AttSyntax {
+    fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
+        check_expr_asm_syntax(Self::get_lints()[0], cx, expr, AsmStyle::Att);
+    }
+}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 529c2450541..10da59c7a7a 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -153,6 +153,7 @@ mod utils;
 mod approx_const;
 mod arithmetic;
 mod as_conversions;
+mod asm_syntax;
 mod assertions_on_constants;
 mod assign_ops;
 mod async_yields_async;
@@ -487,6 +488,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &arithmetic::FLOAT_ARITHMETIC,
         &arithmetic::INTEGER_ARITHMETIC,
         &as_conversions::AS_CONVERSIONS,
+        &asm_syntax::INLINE_ASM_X86_ATT_SYNTAX,
+        &asm_syntax::INLINE_ASM_X86_INTEL_SYNTAX,
         &assertions_on_constants::ASSERTIONS_ON_CONSTANTS,
         &assign_ops::ASSIGN_OP_PATTERN,
         &assign_ops::MISREFACTORED_ASSIGN_OP,
@@ -1123,12 +1126,16 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box utils::internal_lints::MatchTypeOnDiagItem);
     let disallowed_methods = conf.disallowed_methods.iter().cloned().collect::<FxHashSet<_>>();
     store.register_late_pass(move || box disallowed_method::DisallowedMethod::new(&disallowed_methods));
+    store.register_early_pass(|| box asm_syntax::InlineAsmX86AttSyntax);
+    store.register_early_pass(|| box asm_syntax::InlineAsmX86IntelSyntax);
 
 
     store.register_group(true, "clippy::restriction", Some("clippy_restriction"), vec![
         LintId::of(&arithmetic::FLOAT_ARITHMETIC),
         LintId::of(&arithmetic::INTEGER_ARITHMETIC),
         LintId::of(&as_conversions::AS_CONVERSIONS),
+        LintId::of(&asm_syntax::INLINE_ASM_X86_ATT_SYNTAX),
+        LintId::of(&asm_syntax::INLINE_ASM_X86_INTEL_SYNTAX),
         LintId::of(&create_dir::CREATE_DIR),
         LintId::of(&dbg_macro::DBG_MACRO),
         LintId::of(&else_if_without_else::ELSE_IF_WITHOUT_ELSE),
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index 76e655ad603..16ceb617965 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -899,6 +899,20 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
         deprecation: None,
         module: "attrs",
     },
+    Lint {
+        name: "inline_asm_x86_att_syntax",
+        group: "restriction",
+        desc: "prefer Intel x86 assembly syntax",
+        deprecation: None,
+        module: "asm_syntax",
+    },
+    Lint {
+        name: "inline_asm_x86_intel_syntax",
+        group: "restriction",
+        desc: "prefer AT&T x86 assembly syntax",
+        deprecation: None,
+        module: "asm_syntax",
+    },
     Lint {
         name: "inline_fn_without_body",
         group: "correctness",
diff --git a/tests/ui/asm_syntax.rs b/tests/ui/asm_syntax.rs
new file mode 100644
index 00000000000..049bfa604d5
--- /dev/null
+++ b/tests/ui/asm_syntax.rs
@@ -0,0 +1,31 @@
+#![feature(asm)]
+// only-x86 only-x86_64
+
+#[warn(clippy::inline_asm_x86_intel_syntax)]
+mod warn_intel {
+    pub(super) unsafe fn use_asm() {
+        asm!("");
+        asm!("", options());
+        asm!("", options(nostack));
+        asm!("", options(att_syntax));
+        asm!("", options(nostack, att_syntax));
+    }
+}
+
+#[warn(clippy::inline_asm_x86_att_syntax)]
+mod warn_att {
+    pub(super) unsafe fn use_asm() {
+        asm!("");
+        asm!("", options());
+        asm!("", options(nostack));
+        asm!("", options(att_syntax));
+        asm!("", options(nostack, att_syntax));
+    }
+}
+
+fn main() {
+    unsafe {
+        warn_att::use_asm();
+        warn_intel::use_asm();
+    }
+}
diff --git a/tests/ui/asm_syntax.stderr b/tests/ui/asm_syntax.stderr
new file mode 100644
index 00000000000..27b51166eac
--- /dev/null
+++ b/tests/ui/asm_syntax.stderr
@@ -0,0 +1,44 @@
+error: Intel x86 assembly syntax used
+  --> $DIR/asm_syntax.rs:7:9
+   |
+LL |         asm!("");
+   |         ^^^^^^^^^
+   |
+   = note: `-D clippy::inline-asm-x86-intel-syntax` implied by `-D warnings`
+   = help: use AT&T x86 assembly syntax
+
+error: Intel x86 assembly syntax used
+  --> $DIR/asm_syntax.rs:8:9
+   |
+LL |         asm!("", options());
+   |         ^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use AT&T x86 assembly syntax
+
+error: Intel x86 assembly syntax used
+  --> $DIR/asm_syntax.rs:9:9
+   |
+LL |         asm!("", options(nostack));
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use AT&T x86 assembly syntax
+
+error: AT&T x86 assembly syntax used
+  --> $DIR/asm_syntax.rs:21:9
+   |
+LL |         asm!("", options(att_syntax));
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::inline-asm-x86-att-syntax` implied by `-D warnings`
+   = help: use Intel x86 assembly syntax
+
+error: AT&T x86 assembly syntax used
+  --> $DIR/asm_syntax.rs:22:9
+   |
+LL |         asm!("", options(nostack, att_syntax));
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use Intel x86 assembly syntax
+
+error: aborting due to 5 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 0a91fe7016cdb48d3824c218e02eca8cfdec3854 Mon Sep 17 00:00:00 2001
From: Takayuki Nakata <f.seasons017@gmail.com>
Date: Thu, 1 Oct 2020 23:53:05 +0900
Subject: Don't emit a lint for the suggestion leading to errors in
 `needless_range_loop`

---
 clippy_lints/src/loops.rs        |  6 +++++-
 tests/ui/needless_range_loop2.rs | 14 ++++++++++++++
 2 files changed, 19 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 7f998c63f49..61b63597b16 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -3,7 +3,7 @@ use crate::utils::paths;
 use crate::utils::sugg::Sugg;
 use crate::utils::usage::{is_unused, mutated_variables};
 use crate::utils::{
-    get_enclosing_block, get_parent_expr, get_trait_def_id, has_iter_method, higher, implements_trait,
+    contains_name, get_enclosing_block, get_parent_expr, get_trait_def_id, has_iter_method, higher, implements_trait,
     is_integer_const, is_no_std_crate, is_refutable, is_type_diagnostic_item, last_path_segment, match_trait_method,
     match_type, match_var, multispan_sugg, qpath_res, snippet, snippet_opt, snippet_with_applicability,
     snippet_with_macro_callsite, span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then, sugg,
@@ -1276,6 +1276,8 @@ fn check_for_loop_range<'tcx>(
 
                 let skip = if starts_at_zero {
                     String::new()
+                } else if visitor.indexed_mut.contains(&indexed) && contains_name(indexed, start) {
+                    return;
                 } else {
                     format!(".skip({})", snippet(cx, start.span, ".."))
                 };
@@ -1302,6 +1304,8 @@ fn check_for_loop_range<'tcx>(
 
                     if is_len_call(end, indexed) || is_end_eq_array_len(cx, end, limits, indexed_ty) {
                         String::new()
+                    } else if visitor.indexed_mut.contains(&indexed) && contains_name(indexed, take_expr) {
+                        return;
                     } else {
                         match limits {
                             ast::RangeLimits::Closed => {
diff --git a/tests/ui/needless_range_loop2.rs b/tests/ui/needless_range_loop2.rs
index a82b1159161..7633316e0f8 100644
--- a/tests/ui/needless_range_loop2.rs
+++ b/tests/ui/needless_range_loop2.rs
@@ -82,6 +82,20 @@ fn main() {
     for i in 1..3 {
         println!("{}", arr[i]);
     }
+
+    // Fix #5945
+    let mut vec = vec![1, 2, 3, 4];
+    for i in 0..vec.len() - 1 {
+        vec[i] += 1;
+    }
+    let mut vec = vec![1, 2, 3, 4];
+    for i in vec.len() - 3..vec.len() {
+        vec[i] += 1;
+    }
+    let mut vec = vec![1, 2, 3, 4];
+    for i in vec.len() - 3..vec.len() - 1 {
+        vec[i] += 1;
+    }
 }
 
 mod issue2277 {
-- 
cgit 1.4.1-3-g733a5


From 388384177e89db60280dc275e4239e97e61f6a59 Mon Sep 17 00:00:00 2001
From: rail <12975677+rail-rain@users.noreply.github.com>
Date: Fri, 2 Oct 2020 13:30:50 +1300
Subject: document `MinifyingSugg` and `Offset`

...and also swap their position
---
 clippy_lints/src/loops.rs | 82 +++++++++++++++++++++++++----------------------
 1 file changed, 44 insertions(+), 38 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 215700fed8c..9a1ba4907cd 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -805,44 +805,10 @@ fn same_var<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, var: HirId) -> bool {
     }
 }
 
-#[derive(Clone, Copy)]
-enum OffsetSign {
-    Positive,
-    Negative,
-}
-
-struct Offset {
-    value: MinifyingSugg<'static>,
-    sign: OffsetSign,
-}
-
-impl Offset {
-    fn negative(value: Sugg<'static>) -> Self {
-        Self {
-            value: value.into(),
-            sign: OffsetSign::Negative,
-        }
-    }
-
-    fn positive(value: Sugg<'static>) -> Self {
-        Self {
-            value: value.into(),
-            sign: OffsetSign::Positive,
-        }
-    }
-
-    fn empty() -> Self {
-        Self::positive(sugg::ZERO)
-    }
-}
-
-fn apply_offset(lhs: &MinifyingSugg<'static>, rhs: &Offset) -> MinifyingSugg<'static> {
-    match rhs.sign {
-        OffsetSign::Positive => lhs + &rhs.value,
-        OffsetSign::Negative => lhs - &rhs.value,
-    }
-}
-
+/// a wrapper of `Sugg`. Besides what `Sugg` do, this removes unnecessary `0`;
+/// and also, it avoids subtracting a variable from the same one by replacing it with `0`.
+/// it exists for the convenience of the overloaded operators while normal functions can do the
+/// same.
 #[derive(Clone)]
 struct MinifyingSugg<'a>(Sugg<'a>);
 
@@ -909,6 +875,46 @@ impl std::ops::Sub<&MinifyingSugg<'static>> for MinifyingSugg<'static> {
     }
 }
 
+/// a wrapper around `MinifyingSugg`, which carries a operator like currying
+/// so that the suggested code become more efficient (e.g. `foo + -bar` `foo - bar`).
+struct Offset {
+    value: MinifyingSugg<'static>,
+    sign: OffsetSign,
+}
+
+#[derive(Clone, Copy)]
+enum OffsetSign {
+    Positive,
+    Negative,
+}
+
+impl Offset {
+    fn negative(value: Sugg<'static>) -> Self {
+        Self {
+            value: value.into(),
+            sign: OffsetSign::Negative,
+        }
+    }
+
+    fn positive(value: Sugg<'static>) -> Self {
+        Self {
+            value: value.into(),
+            sign: OffsetSign::Positive,
+        }
+    }
+
+    fn empty() -> Self {
+        Self::positive(sugg::ZERO)
+    }
+}
+
+fn apply_offset(lhs: &MinifyingSugg<'static>, rhs: &Offset) -> MinifyingSugg<'static> {
+    match rhs.sign {
+        OffsetSign::Positive => lhs + &rhs.value,
+        OffsetSign::Negative => lhs - &rhs.value,
+    }
+}
+
 #[derive(Debug, Clone, Copy)]
 enum StartKind<'hir> {
     Range,
-- 
cgit 1.4.1-3-g733a5


From 94d7b82340792af6e5c9b7c105dca1f2fef1b495 Mon Sep 17 00:00:00 2001
From: rail <12975677+rail-rain@users.noreply.github.com>
Date: Fri, 2 Oct 2020 14:04:46 +1300
Subject: simplify the code

---
 clippy_lints/src/loops.rs | 12 ++++--------
 1 file changed, 4 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 9a1ba4907cd..2ae5a9acb75 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -973,10 +973,7 @@ fn get_details_from_idx<'tcx>(
                 ast::LitKind::Int(x, _ty) => Some(Sugg::NonParen(x.to_string().into())),
                 _ => None,
             },
-            ExprKind::Path(..) if get_start(cx, e, starts).is_none() => {
-                // `e` is always non paren as it's a `Path`
-                Some(Sugg::NonParen(snippet(cx, e.span, "???")))
-            },
+            ExprKind::Path(..) if get_start(cx, e, starts).is_none() => Some(Sugg::hir(cx, e, "???")),
             _ => None,
         }
     }
@@ -1010,8 +1007,7 @@ fn get_assignment<'tcx>(e: &'tcx Expr<'tcx>) -> Option<(&'tcx Expr<'tcx>, &'tcx
 
 fn get_assignments<'a: 'c, 'tcx: 'c, 'c>(
     cx: &'a LateContext<'tcx>,
-    stmts: &'tcx [Stmt<'tcx>],
-    expr: Option<&'tcx Expr<'tcx>>,
+    Block { stmts, expr, .. }: &'tcx Block<'tcx>,
     loop_counters: &'c [Start<'tcx>],
 ) -> impl Iterator<Item = Option<(&'tcx Expr<'tcx>, &'tcx Expr<'tcx>)>> + 'c {
     stmts
@@ -1025,7 +1021,7 @@ fn get_assignments<'a: 'c, 'tcx: 'c, 'c>(
                 then { None } else { Some(e) }
             },
         })
-        .chain(expr.into_iter())
+        .chain((*expr).into_iter())
         .map(get_assignment)
 }
 
@@ -1184,7 +1180,7 @@ fn detect_manual_memcpy<'tcx>(
                 if let Some(loop_counters) = get_loop_counters(cx, block, expr) {
                     starts.extend(loop_counters);
                 }
-                iter_a = Some(get_assignments(cx, block.stmts, block.expr, &starts));
+                iter_a = Some(get_assignments(cx, block, &starts));
             } else {
                 iter_b = Some(get_assignment(body));
             }
-- 
cgit 1.4.1-3-g733a5


From e91202cf683b7265eec484ad311b5a9d3b56fc3e Mon Sep 17 00:00:00 2001
From: Michael Wright <mikerite@lavabit.com>
Date: Fri, 2 Oct 2020 05:43:43 +0200
Subject: Allow exponent separator

Fixes #6096
---
 clippy_lints/src/utils/numeric_literal.rs  | 19 +++++++++++--------
 tests/ui/inconsistent_digit_grouping.fixed |  4 ++++
 tests/ui/inconsistent_digit_grouping.rs    |  4 ++++
 3 files changed, 19 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/numeric_literal.rs b/clippy_lints/src/utils/numeric_literal.rs
index 5e8800d38eb..52d3c2c1daf 100644
--- a/clippy_lints/src/utils/numeric_literal.rs
+++ b/clippy_lints/src/utils/numeric_literal.rs
@@ -36,8 +36,9 @@ pub struct NumericLiteral<'a> {
     pub integer: &'a str,
     /// The fraction part of the number.
     pub fraction: Option<&'a str>,
-    /// The character used as exponent separator (b'e' or b'E') and the exponent part.
-    pub exponent: Option<(char, &'a str)>,
+    /// The exponent separator (b'e' or b'E') including preceding underscore if present
+    /// and the exponent part.
+    pub exponent: Option<(&'a str, &'a str)>,
 
     /// The type suffix, including preceding underscore if present.
     pub suffix: Option<&'a str>,
@@ -100,7 +101,7 @@ impl<'a> NumericLiteral<'a> {
         self.radix == Radix::Decimal
     }
 
-    pub fn split_digit_parts(digits: &str, float: bool) -> (&str, Option<&str>, Option<(char, &str)>) {
+    pub fn split_digit_parts(digits: &str, float: bool) -> (&str, Option<&str>, Option<(&str, &str)>) {
         let mut integer = digits;
         let mut fraction = None;
         let mut exponent = None;
@@ -113,12 +114,14 @@ impl<'a> NumericLiteral<'a> {
                         fraction = Some(&digits[i + 1..]);
                     },
                     'e' | 'E' => {
-                        if integer.len() > i {
-                            integer = &digits[..i];
+                        let exp_start = if digits[..i].ends_with('_') { i - 1 } else { i };
+
+                        if integer.len() > exp_start {
+                            integer = &digits[..exp_start];
                         } else {
-                            fraction = Some(&digits[integer.len() + 1..i]);
+                            fraction = Some(&digits[integer.len() + 1..exp_start]);
                         };
-                        exponent = Some((c, &digits[i + 1..]));
+                        exponent = Some((&digits[exp_start..=i], &digits[i + 1..]));
                         break;
                     },
                     _ => {},
@@ -153,7 +156,7 @@ impl<'a> NumericLiteral<'a> {
         }
 
         if let Some((separator, exponent)) = self.exponent {
-            output.push(separator);
+            output.push_str(separator);
             Self::group_digits(&mut output, exponent, group_size, true, false);
         }
 
diff --git a/tests/ui/inconsistent_digit_grouping.fixed b/tests/ui/inconsistent_digit_grouping.fixed
index b75f10917df..dd683e7f746 100644
--- a/tests/ui/inconsistent_digit_grouping.fixed
+++ b/tests/ui/inconsistent_digit_grouping.fixed
@@ -40,4 +40,8 @@ fn main() {
     // Ignore literals in macros
     let _ = mac1!();
     let _ = mac2!();
+
+    // Issue #6096
+    // Allow separating exponent with '_'
+    let _ = 1.025_011_10_E0;
 }
diff --git a/tests/ui/inconsistent_digit_grouping.rs b/tests/ui/inconsistent_digit_grouping.rs
index 79ce38be19b..d5d27c853c2 100644
--- a/tests/ui/inconsistent_digit_grouping.rs
+++ b/tests/ui/inconsistent_digit_grouping.rs
@@ -40,4 +40,8 @@ fn main() {
     // Ignore literals in macros
     let _ = mac1!();
     let _ = mac2!();
+
+    // Issue #6096
+    // Allow separating exponent with '_'
+    let _ = 1.025_011_10_E0;
 }
-- 
cgit 1.4.1-3-g733a5


From 1402d8ae4f0c07ac48bd8297ec07901346c32d32 Mon Sep 17 00:00:00 2001
From: rail <12975677+rail-rain@users.noreply.github.com>
Date: Fri, 2 Oct 2020 14:18:37 +1300
Subject: fix a FN where incr exprs with no semicolon at ends

---
 clippy_lints/src/loops.rs                        | 18 ++++++++++++------
 tests/ui/manual_memcpy/with_loop_counters.rs     |  7 +++++++
 tests/ui/manual_memcpy/with_loop_counters.stderr | 11 ++++++++++-
 3 files changed, 29 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 2ae5a9acb75..ea40c2af4f7 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -1014,14 +1014,20 @@ fn get_assignments<'a: 'c, 'tcx: 'c, 'c>(
         .iter()
         .filter_map(move |stmt| match stmt.kind {
             StmtKind::Local(..) | StmtKind::Item(..) => None,
-            StmtKind::Expr(e) | StmtKind::Semi(e) => if_chain! {
-                if let ExprKind::AssignOp(_, var, _) = e.kind;
-                // skip StartKind::Range
-                if loop_counters.iter().skip(1).any(|counter| Some(counter.id) == var_def_id(cx, var));
-                then { None } else { Some(e) }
-            },
+            StmtKind::Expr(e) | StmtKind::Semi(e) => Some(e),
         })
         .chain((*expr).into_iter())
+        .filter(move |e| {
+            if let ExprKind::AssignOp(_, place, _) = e.kind {
+                !loop_counters
+                    .iter()
+                    // skip StartKind::Range
+                    .skip(1)
+                    .any(|counter| same_var(cx, place, counter.id))
+            } else {
+                true
+            }
+        })
         .map(get_assignment)
 }
 
diff --git a/tests/ui/manual_memcpy/with_loop_counters.rs b/tests/ui/manual_memcpy/with_loop_counters.rs
index a49ba9eb10a..70873c9e994 100644
--- a/tests/ui/manual_memcpy/with_loop_counters.rs
+++ b/tests/ui/manual_memcpy/with_loop_counters.rs
@@ -59,6 +59,13 @@ pub fn manual_copy_with_counters(src: &[i32], dst: &mut [i32], dst2: &mut [i32])
         dst[count] = src[i + 2];
         count += 1;
     }
+
+    // make sure incrementing expressions without semicolons at the end of loops are handled correctly.
+    let mut count = 0;
+    for i in 3..src.len() {
+        dst[i] = src[count];
+        count += 1
+    }
 }
 
 fn main() {}
diff --git a/tests/ui/manual_memcpy/with_loop_counters.stderr b/tests/ui/manual_memcpy/with_loop_counters.stderr
index 24393ad9b4d..598c881b4d6 100644
--- a/tests/ui/manual_memcpy/with_loop_counters.stderr
+++ b/tests/ui/manual_memcpy/with_loop_counters.stderr
@@ -89,5 +89,14 @@ LL | |         count += 1;
 LL | |     }
    | |_____^ help: try replacing the loop by: `dst[(0 << 1)..((1 << 1) + (0 << 1))].clone_from_slice(&src[2..((1 << 1) + 2)]);`
 
-error: aborting due to 9 previous errors
+error: it looks like you're manually copying between slices
+  --> $DIR/with_loop_counters.rs:65:5
+   |
+LL | /     for i in 3..src.len() {
+LL | |         dst[i] = src[count];
+LL | |         count += 1
+LL | |     }
+   | |_____^ help: try replacing the loop by: `dst[3..src.len()].clone_from_slice(&src[..(src.len() - 3)]);`
+
+error: aborting due to 10 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 41a0ccbc57902e488e62ed8ca9a1ebb565129c09 Mon Sep 17 00:00:00 2001
From: rail <12975677+rail-rain@users.noreply.github.com>
Date: Fri, 2 Oct 2020 21:19:14 +1300
Subject: add comments around `loop_counters`

---
 clippy_lints/src/loops.rs | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index ea40c2af4f7..4f279cc5ef7 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -1005,6 +1005,10 @@ fn get_assignment<'tcx>(e: &'tcx Expr<'tcx>) -> Option<(&'tcx Expr<'tcx>, &'tcx
     }
 }
 
+/// Get assignments from the given block.
+/// The returned iterator yields `None` if no assignment expressions are there,
+/// filtering out the increments of the given whitelisted loop counters;
+/// because its job is to make sure there's nothing other than assignments and the increments.
 fn get_assignments<'a: 'c, 'tcx: 'c, 'c>(
     cx: &'a LateContext<'tcx>,
     Block { stmts, expr, .. }: &'tcx Block<'tcx>,
@@ -1021,7 +1025,8 @@ fn get_assignments<'a: 'c, 'tcx: 'c, 'c>(
             if let ExprKind::AssignOp(_, place, _) = e.kind {
                 !loop_counters
                     .iter()
-                    // skip StartKind::Range
+                    // skip the first item which should be `StartKind::Range`
+                    // this makes it possible to use the slice with `StartKind::Range` in the same iterator loop.
                     .skip(1)
                     .any(|counter| same_var(cx, place, counter.id))
             } else {
@@ -1191,11 +1196,11 @@ fn detect_manual_memcpy<'tcx>(
                 iter_b = Some(get_assignment(body));
             }
 
-            // The only statements in the for loops can be indexed assignments from
-            // indexed retrievals.
             let assignments = iter_a.into_iter().flatten().chain(iter_b.into_iter());
 
             let big_sugg = assignments
+                // The only statements in the for loops can be indexed assignments from
+                // indexed retrievals (except increments of loop counters).
                 .map(|o| {
                     o.and_then(|(lhs, rhs)| {
                         let rhs = fetch_cloned_expr(rhs);
-- 
cgit 1.4.1-3-g733a5


From 2a0e45b8dbfa9c8494371983b128b933082a9c13 Mon Sep 17 00:00:00 2001
From: rail <12975677+rail-rain@users.noreply.github.com>
Date: Fri, 2 Oct 2020 21:30:21 +1300
Subject: supress `clippy::filter_map`

---
 clippy_lints/src/loops.rs | 3 +++
 1 file changed, 3 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 4f279cc5ef7..d3a1683cc0c 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -1014,6 +1014,9 @@ fn get_assignments<'a: 'c, 'tcx: 'c, 'c>(
     Block { stmts, expr, .. }: &'tcx Block<'tcx>,
     loop_counters: &'c [Start<'tcx>],
 ) -> impl Iterator<Item = Option<(&'tcx Expr<'tcx>, &'tcx Expr<'tcx>)>> + 'c {
+    // As the `filter` and `map` below do different things, I think putting together
+    // just increases complexity. (cc #3188 and #4193)
+    #[allow(clippy::filter_map)]
     stmts
         .iter()
         .filter_map(move |stmt| match stmt.kind {
-- 
cgit 1.4.1-3-g733a5


From 515ca9312393bd00af0e867fceee9aff9b6e565d Mon Sep 17 00:00:00 2001
From: Dániel Buga <bugadani@gmail.com>
Date: Fri, 2 Oct 2020 11:54:31 +0200
Subject: Look for soft hyphens as well

---
 clippy_lints/src/unicode.rs | 14 +++++++-------
 tests/ui/unicode.rs         |  2 ++
 tests/ui/unicode.stderr     | 14 ++++++++++----
 3 files changed, 19 insertions(+), 11 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unicode.rs b/clippy_lints/src/unicode.rs
index d8c57f0e7ae..d3fe60042a8 100644
--- a/clippy_lints/src/unicode.rs
+++ b/clippy_lints/src/unicode.rs
@@ -8,18 +8,18 @@ use rustc_span::source_map::Span;
 use unicode_normalization::UnicodeNormalization;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for the Unicode zero-width space in the code.
+    /// **What it does:** Checks for invisible Unicode characters in the code.
     ///
     /// **Why is this bad?** Having an invisible character in the code makes for all
     /// sorts of April fools, but otherwise is very much frowned upon.
     ///
     /// **Known problems:** None.
     ///
-    /// **Example:** You don't see it, but there may be a zero-width space
-    /// somewhere in this text.
+    /// **Example:** You don't see it, but there may be a zero-width space or soft hyphen
+    /// some­where in this text.
     pub ZERO_WIDTH_SPACE,
     correctness,
-    "using a zero-width space in a string literal, which is confusing"
+    "using an invisible character in a string literal, which is confusing"
 }
 
 declare_clippy_lint! {
@@ -91,14 +91,14 @@ fn escape<T: Iterator<Item = char>>(s: T) -> String {
 
 fn check_str(cx: &LateContext<'_>, span: Span, id: HirId) {
     let string = snippet(cx, span, "");
-    if string.contains('\u{200B}') {
+    if let Some(invisible) = string.chars().find(|c| ['\u{200B}', '\u{ad}'].contains(&c)) {
         span_lint_and_sugg(
             cx,
             ZERO_WIDTH_SPACE,
             span,
-            "zero-width space detected",
+            &format!("invisible character detected: {:?}", invisible),
             "consider replacing the string with",
-            string.replace("\u{200B}", "\\u{200B}"),
+            string.replace("\u{200B}", "\\u{200B}").replace("\u{ad}", "\\u{AD}"),
             Applicability::MachineApplicable,
         );
     }
diff --git a/tests/ui/unicode.rs b/tests/ui/unicode.rs
index 27db9594f3b..f3fd1c57da6 100644
--- a/tests/ui/unicode.rs
+++ b/tests/ui/unicode.rs
@@ -2,6 +2,8 @@
 fn zero() {
     print!("Here >​< is a ZWS, and ​another");
     print!("This\u{200B}is\u{200B}fine");
+    print!("Here >­< is a SHY, and ­another");
+    print!("This\u{ad}is\u{ad}fine");
 }
 
 #[warn(clippy::unicode_not_nfc)]
diff --git a/tests/ui/unicode.stderr b/tests/ui/unicode.stderr
index 4575a132e5b..b0445b070fd 100644
--- a/tests/ui/unicode.stderr
+++ b/tests/ui/unicode.stderr
@@ -1,4 +1,4 @@
-error: zero-width space detected
+error: invisible character detected: '/u{200b}'
   --> $DIR/unicode.rs:3:12
    |
 LL |     print!("Here >​< is a ZWS, and ​another");
@@ -6,8 +6,14 @@ LL |     print!("Here >​< is a ZWS, and ​another");
    |
    = note: `-D clippy::zero-width-space` implied by `-D warnings`
 
+error: invisible character detected: '/u{ad}'
+  --> $DIR/unicode.rs:5:12
+   |
+LL |     print!("Here >­< is a SHY, and ­another");
+   |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider replacing the string with: `"Here >/u{AD}< is a SHY, and /u{AD}another"`
+
 error: non-NFC Unicode sequence detected
-  --> $DIR/unicode.rs:9:12
+  --> $DIR/unicode.rs:11:12
    |
 LL |     print!("̀àh?");
    |            ^^^^^ help: consider replacing the string with: `"̀àh?"`
@@ -15,12 +21,12 @@ LL |     print!("̀àh?");
    = note: `-D clippy::unicode-not-nfc` implied by `-D warnings`
 
 error: literal non-ASCII character detected
-  --> $DIR/unicode.rs:15:12
+  --> $DIR/unicode.rs:17:12
    |
 LL |     print!("Üben!");
    |            ^^^^^^^ help: consider replacing the string with: `"/u{dc}ben!"`
    |
    = note: `-D clippy::non-ascii-literal` implied by `-D warnings`
 
-error: aborting due to 3 previous errors
+error: aborting due to 4 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From b54188429409a6da5f931fa4be5df1f40b377015 Mon Sep 17 00:00:00 2001
From: rail <12975677+rail-rain@users.noreply.github.com>
Date: Fri, 2 Oct 2020 23:38:10 +1300
Subject: remove the explicit return value of `print_limit`

---
 clippy_lints/src/loops.rs | 41 ++++++++++++++++++++---------------------
 1 file changed, 20 insertions(+), 21 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index d3a1683cc0c..3e9265c1215 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -1082,30 +1082,29 @@ fn build_manual_memcpy_suggestion<'tcx>(
         }
     }
 
-    let print_limit =
-        |end: &Expr<'_>, end_str: &str, base: &Expr<'_>, sugg: MinifyingSugg<'static>| -> MinifyingSugg<'static> {
-            if_chain! {
-                if let ExprKind::MethodCall(method, _, len_args, _) = end.kind;
-                if method.ident.name == sym!(len);
-                if len_args.len() == 1;
-                if let Some(arg) = len_args.get(0);
-                if var_def_id(cx, arg) == var_def_id(cx, base);
-                then {
-                    if sugg.as_str() == end_str {
-                        sugg::EMPTY.into()
-                    } else {
-                        sugg
-                    }
+    let print_limit = |end: &Expr<'_>, end_str: &str, base: &Expr<'_>, sugg: MinifyingSugg<'static>| {
+        if_chain! {
+            if let ExprKind::MethodCall(method, _, len_args, _) = end.kind;
+            if method.ident.name == sym!(len);
+            if len_args.len() == 1;
+            if let Some(arg) = len_args.get(0);
+            if var_def_id(cx, arg) == var_def_id(cx, base);
+            then {
+                if sugg.as_str() == end_str {
+                    sugg::EMPTY.into()
                 } else {
-                    match limits {
-                        ast::RangeLimits::Closed => {
-                            sugg + &sugg::ONE.into()
-                        },
-                        ast::RangeLimits::HalfOpen => sugg,
-                    }
+                    sugg
+                }
+            } else {
+                match limits {
+                    ast::RangeLimits::Closed => {
+                        sugg + &sugg::ONE.into()
+                    },
+                    ast::RangeLimits::HalfOpen => sugg,
                 }
             }
-        };
+        }
+    };
 
     let start_str = Sugg::hir(cx, start, "").into();
     let end_str: MinifyingSugg<'_> = Sugg::hir(cx, end, "").into();
-- 
cgit 1.4.1-3-g733a5


From f302af33bc1901ddd0226c8d3a6433682a85f69b Mon Sep 17 00:00:00 2001
From: nahuakang <kangnahua@gmail.com>
Date: Fri, 2 Oct 2020 20:13:01 +0200
Subject: Add doc comment issue of #5834 to known problems of lint doc_markdown

---
 clippy_lints/src/doc.rs | 13 +++++++++++++
 1 file changed, 13 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/doc.rs b/clippy_lints/src/doc.rs
index 62bb70af06e..07f604cf714 100644
--- a/clippy_lints/src/doc.rs
+++ b/clippy_lints/src/doc.rs
@@ -32,6 +32,11 @@ declare_clippy_lint! {
     /// **Known problems:** Lots of bad docs won’t be fixed, what the lint checks
     /// for is limited, and there are still false positives.
     ///
+    /// In addition, when writing documentation comments, including `[]` brackets
+    /// inside a link text would trip the parser. Therfore, documenting link with
+    /// `[`SmallVec<[T; INLINE_CAPACITY]>`]` and then [`SmallVec<[T; INLINE_CAPACITY]>`]: SmallVec
+    /// would fail.
+    ///
     /// **Examples:**
     /// ```rust
     /// /// Do something with the foo_bar parameter. See also
@@ -39,6 +44,14 @@ declare_clippy_lint! {
     /// // ^ `foo_bar` and `that::other::module::foo` should be ticked.
     /// fn doit(foo_bar: usize) {}
     /// ```
+    ///
+    /// ```rust
+    /// // Link text with `[]` brackets should be written as following:
+    /// /// Consume the array and return the inner
+    /// /// [`SmallVec<[T; INLINE_CAPACITY]>`][SmallVec].
+    /// /// [SmallVec]: SmallVec
+    /// fn main() {}
+    /// ```
     pub DOC_MARKDOWN,
     pedantic,
     "presence of `_`, `::` or camel-case outside backticks in documentation"
-- 
cgit 1.4.1-3-g733a5


From 8b8c63f568bc838aa7997a6933a40c3ab7b91a5d Mon Sep 17 00:00:00 2001
From: Long Louis Bui <louisbui2000@gmail.com>
Date: Wed, 30 Sep 2020 12:13:12 -0700
Subject: changed non_copy_const lints to warn by default

---
 clippy_lints/src/lib.rs            |  4 ++--
 clippy_lints/src/non_copy_const.rs | 28 ++++++++++++++++++++++++----
 src/lintlist/mod.rs                |  4 ++--
 3 files changed, 28 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 10da59c7a7a..71bd7c4f82a 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1604,6 +1604,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&mut_reference::UNNECESSARY_MUT_PASSED),
         LintId::of(&neg_multiply::NEG_MULTIPLY),
         LintId::of(&new_without_default::NEW_WITHOUT_DEFAULT),
+        LintId::of(&non_copy_const::BORROW_INTERIOR_MUTABLE_CONST),
+        LintId::of(&non_copy_const::DECLARE_INTERIOR_MUTABLE_CONST),
         LintId::of(&non_expressive_names::JUST_UNDERSCORES_AND_DIGITS),
         LintId::of(&non_expressive_names::MANY_SINGLE_CHAR_NAMES),
         LintId::of(&panic_unimplemented::PANIC_PARAMS),
@@ -1760,8 +1762,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&misc::FLOAT_CMP),
         LintId::of(&misc::MODULO_ONE),
         LintId::of(&mut_key::MUTABLE_KEY_TYPE),
-        LintId::of(&non_copy_const::BORROW_INTERIOR_MUTABLE_CONST),
-        LintId::of(&non_copy_const::DECLARE_INTERIOR_MUTABLE_CONST),
         LintId::of(&open_options::NONSENSICAL_OPEN_OPTIONS),
         LintId::of(&option_env_unwrap::OPTION_ENV_UNWRAP),
         LintId::of(&ptr::MUT_FROM_REF),
diff --git a/clippy_lints/src/non_copy_const.rs b/clippy_lints/src/non_copy_const.rs
index bb44eeb6adc..7b662eae775 100644
--- a/clippy_lints/src/non_copy_const.rs
+++ b/clippy_lints/src/non_copy_const.rs
@@ -1,6 +1,6 @@
 //! Checks for uses of const which the type is not `Freeze` (`Cell`-free).
 //!
-//! This lint is **deny** by default.
+//! This lint is **warn** by default.
 
 use std::ptr;
 
@@ -17,6 +17,8 @@ use rustc_typeck::hir_ty_to_ty;
 use crate::utils::{in_constant, qpath_res, span_lint_and_then};
 use if_chain::if_chain;
 
+// FIXME: this is a correctness problem but there's no suitable
+// warn-by-default category.
 declare_clippy_lint! {
     /// **What it does:** Checks for declaration of `const` items which is interior
     /// mutable (e.g., contains a `Cell`, `Mutex`, `AtomicXxxx`, etc.).
@@ -34,6 +36,15 @@ declare_clippy_lint! {
     /// `std::sync::ONCE_INIT` constant). In this case the use of `const` is legit,
     /// and this lint should be suppressed.
     ///
+    /// When an enum has variants with interior mutability, use of its non interior mutable
+    /// variants can generate false positives. See issue
+    /// [#3962](https://github.com/rust-lang/rust-clippy/issues/3962)
+    ///
+    /// Types that have underlying or potential interior mutability trigger the lint whether
+    /// the interior mutable field is used or not. See issues
+    /// [#5812](https://github.com/rust-lang/rust-clippy/issues/5812) and
+    /// [#3825](https://github.com/rust-lang/rust-clippy/issues/3825)
+    ///
     /// **Example:**
     /// ```rust
     /// use std::sync::atomic::{AtomicUsize, Ordering::SeqCst};
@@ -49,10 +60,12 @@ declare_clippy_lint! {
     /// assert_eq!(STATIC_ATOM.load(SeqCst), 9); // use a `static` item to refer to the same instance
     /// ```
     pub DECLARE_INTERIOR_MUTABLE_CONST,
-    correctness,
+    style,
     "declaring `const` with interior mutability"
 }
 
+// FIXME: this is a correctness problem but there's no suitable
+// warn-by-default category.
 declare_clippy_lint! {
     /// **What it does:** Checks if `const` items which is interior mutable (e.g.,
     /// contains a `Cell`, `Mutex`, `AtomicXxxx`, etc.) has been borrowed directly.
@@ -64,7 +77,14 @@ declare_clippy_lint! {
     ///
     /// The `const` value should be stored inside a `static` item.
     ///
-    /// **Known problems:** None
+    /// **Known problems:** When an enum has variants with interior mutability, use of its non
+    /// interior mutable variants can generate false positives. See issue
+    /// [#3962](https://github.com/rust-lang/rust-clippy/issues/3962)
+    ///
+    /// Types that have underlying or potential interior mutability trigger the lint whether
+    /// the interior mutable field is used or not. See issues
+    /// [#5812](https://github.com/rust-lang/rust-clippy/issues/5812) and
+    /// [#3825](https://github.com/rust-lang/rust-clippy/issues/3825)
     ///
     /// **Example:**
     /// ```rust
@@ -81,7 +101,7 @@ declare_clippy_lint! {
     /// assert_eq!(STATIC_ATOM.load(SeqCst), 9); // use a `static` item to refer to the same instance
     /// ```
     pub BORROW_INTERIOR_MUTABLE_CONST,
-    correctness,
+    style,
     "referencing `const` with interior mutability"
 }
 
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index 16ceb617965..ccdfac3a34b 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -110,7 +110,7 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
     },
     Lint {
         name: "borrow_interior_mutable_const",
-        group: "correctness",
+        group: "style",
         desc: "referencing `const` with interior mutability",
         deprecation: None,
         module: "non_copy_const",
@@ -334,7 +334,7 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
     },
     Lint {
         name: "declare_interior_mutable_const",
-        group: "correctness",
+        group: "style",
         desc: "declaring `const` with interior mutability",
         deprecation: None,
         module: "non_copy_const",
-- 
cgit 1.4.1-3-g733a5


From 998bd3b6b4d168099346e460ae42897dc3667882 Mon Sep 17 00:00:00 2001
From: Dániel Buga <bugadani@gmail.com>
Date: Sat, 3 Oct 2020 00:03:33 +0200
Subject: Rename lint to invisible_characters

---
 CHANGELOG.md                |  2 +-
 clippy_lints/src/lib.rs     |  7 ++++---
 clippy_lints/src/unicode.rs | 10 +++++-----
 src/lintlist/mod.rs         | 14 +++++++-------
 tests/ui/unicode.rs         |  2 +-
 tests/ui/unicode.stderr     |  6 +++---
 6 files changed, 21 insertions(+), 20 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 0de6f4b4235..617bf32f463 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1647,6 +1647,7 @@ Released 2018-09-13
 [`invalid_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#invalid_ref
 [`invalid_regex`]: https://rust-lang.github.io/rust-clippy/master/index.html#invalid_regex
 [`invalid_upcast_comparisons`]: https://rust-lang.github.io/rust-clippy/master/index.html#invalid_upcast_comparisons
+[`invisible_characters`]: https://rust-lang.github.io/rust-clippy/master/index.html#invisible_characters
 [`items_after_statements`]: https://rust-lang.github.io/rust-clippy/master/index.html#items_after_statements
 [`iter_cloned_collect`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_cloned_collect
 [`iter_next_loop`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_next_loop
@@ -1922,6 +1923,5 @@ Released 2018-09-13
 [`zero_divided_by_zero`]: https://rust-lang.github.io/rust-clippy/master/index.html#zero_divided_by_zero
 [`zero_prefixed_literal`]: https://rust-lang.github.io/rust-clippy/master/index.html#zero_prefixed_literal
 [`zero_ptr`]: https://rust-lang.github.io/rust-clippy/master/index.html#zero_ptr
-[`zero_width_space`]: https://rust-lang.github.io/rust-clippy/master/index.html#zero_width_space
 [`zst_offset`]: https://rust-lang.github.io/rust-clippy/master/index.html#zst_offset
 <!-- end autogenerated links to lint list -->
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 10da59c7a7a..91244ec2724 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -854,9 +854,9 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &types::UNIT_CMP,
         &types::UNNECESSARY_CAST,
         &types::VEC_BOX,
+        &unicode::INVISIBLE_CHARACTERS,
         &unicode::NON_ASCII_LITERAL,
         &unicode::UNICODE_NOT_NFC,
-        &unicode::ZERO_WIDTH_SPACE,
         &unit_return_expecting_ord::UNIT_RETURN_EXPECTING_ORD,
         &unnamed_address::FN_ADDRESS_COMPARISONS,
         &unnamed_address::VTABLE_ADDRESS_COMPARISONS,
@@ -1511,7 +1511,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&types::UNIT_CMP),
         LintId::of(&types::UNNECESSARY_CAST),
         LintId::of(&types::VEC_BOX),
-        LintId::of(&unicode::ZERO_WIDTH_SPACE),
+        LintId::of(&unicode::INVISIBLE_CHARACTERS),
         LintId::of(&unit_return_expecting_ord::UNIT_RETURN_EXPECTING_ORD),
         LintId::of(&unnamed_address::FN_ADDRESS_COMPARISONS),
         LintId::of(&unnamed_address::VTABLE_ADDRESS_COMPARISONS),
@@ -1779,7 +1779,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&types::ABSURD_EXTREME_COMPARISONS),
         LintId::of(&types::CAST_REF_TO_MUT),
         LintId::of(&types::UNIT_CMP),
-        LintId::of(&unicode::ZERO_WIDTH_SPACE),
+        LintId::of(&unicode::INVISIBLE_CHARACTERS),
         LintId::of(&unit_return_expecting_ord::UNIT_RETURN_EXPECTING_ORD),
         LintId::of(&unnamed_address::FN_ADDRESS_COMPARISONS),
         LintId::of(&unnamed_address::VTABLE_ADDRESS_COMPARISONS),
@@ -1910,6 +1910,7 @@ pub fn register_renamed(ls: &mut rustc_lint::LintStore) {
     ls.register_renamed("clippy::for_loop_over_option", "clippy::for_loops_over_fallibles");
     ls.register_renamed("clippy::for_loop_over_result", "clippy::for_loops_over_fallibles");
     ls.register_renamed("clippy::identity_conversion", "clippy::useless_conversion");
+    ls.register_renamed("clippy::zero_width_space", "clippy::invisible_characters");
 }
 
 // only exists to let the dogfood integration test works.
diff --git a/clippy_lints/src/unicode.rs b/clippy_lints/src/unicode.rs
index d3fe60042a8..d6c8d317dc2 100644
--- a/clippy_lints/src/unicode.rs
+++ b/clippy_lints/src/unicode.rs
@@ -17,7 +17,7 @@ declare_clippy_lint! {
     ///
     /// **Example:** You don't see it, but there may be a zero-width space or soft hyphen
     /// some­where in this text.
-    pub ZERO_WIDTH_SPACE,
+    pub INVISIBLE_CHARACTERS,
     correctness,
     "using an invisible character in a string literal, which is confusing"
 }
@@ -63,7 +63,7 @@ declare_clippy_lint! {
     "using a Unicode literal not in NFC normal form (see [Unicode tr15](http://www.unicode.org/reports/tr15/) for further information)"
 }
 
-declare_lint_pass!(Unicode => [ZERO_WIDTH_SPACE, NON_ASCII_LITERAL, UNICODE_NOT_NFC]);
+declare_lint_pass!(Unicode => [INVISIBLE_CHARACTERS, NON_ASCII_LITERAL, UNICODE_NOT_NFC]);
 
 impl LateLintPass<'_> for Unicode {
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &'_ Expr<'_>) {
@@ -91,12 +91,12 @@ fn escape<T: Iterator<Item = char>>(s: T) -> String {
 
 fn check_str(cx: &LateContext<'_>, span: Span, id: HirId) {
     let string = snippet(cx, span, "");
-    if let Some(invisible) = string.chars().find(|c| ['\u{200B}', '\u{ad}'].contains(&c)) {
+    if string.chars().any(|c| ['\u{200B}', '\u{ad}'].contains(&c)) {
         span_lint_and_sugg(
             cx,
-            ZERO_WIDTH_SPACE,
+            INVISIBLE_CHARACTERS,
             span,
-            &format!("invisible character detected: {:?}", invisible),
+            "invisible character detected",
             "consider replacing the string with",
             string.replace("\u{200B}", "\\u{200B}").replace("\u{ad}", "\\u{AD}"),
             Applicability::MachineApplicable,
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index 3654dbc6124..e7df733d3a2 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -969,6 +969,13 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
         deprecation: None,
         module: "types",
     },
+    Lint {
+        name: "invisible_characters",
+        group: "correctness",
+        desc: "using an invisible character in a string literal, which is confusing",
+        deprecation: None,
+        module: "unicode",
+    },
     Lint {
         name: "items_after_statements",
         group: "pedantic",
@@ -2810,13 +2817,6 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
         deprecation: None,
         module: "misc",
     },
-    Lint {
-        name: "zero_width_space",
-        group: "correctness",
-        desc: "using an invisible character in a string literal, which is confusing",
-        deprecation: None,
-        module: "unicode",
-    },
     Lint {
         name: "zst_offset",
         group: "correctness",
diff --git a/tests/ui/unicode.rs b/tests/ui/unicode.rs
index f3fd1c57da6..b6944e04859 100644
--- a/tests/ui/unicode.rs
+++ b/tests/ui/unicode.rs
@@ -1,4 +1,4 @@
-#[warn(clippy::zero_width_space)]
+#[warn(clippy::invisible_characters)]
 fn zero() {
     print!("Here >​< is a ZWS, and ​another");
     print!("This\u{200B}is\u{200B}fine");
diff --git a/tests/ui/unicode.stderr b/tests/ui/unicode.stderr
index b0445b070fd..595d80ea279 100644
--- a/tests/ui/unicode.stderr
+++ b/tests/ui/unicode.stderr
@@ -1,12 +1,12 @@
-error: invisible character detected: '/u{200b}'
+error: invisible character detected
   --> $DIR/unicode.rs:3:12
    |
 LL |     print!("Here >​< is a ZWS, and ​another");
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider replacing the string with: `"Here >/u{200B}< is a ZWS, and /u{200B}another"`
    |
-   = note: `-D clippy::zero-width-space` implied by `-D warnings`
+   = note: `-D clippy::invisible-characters` implied by `-D warnings`
 
-error: invisible character detected: '/u{ad}'
+error: invisible character detected
   --> $DIR/unicode.rs:5:12
    |
 LL |     print!("Here >­< is a SHY, and ­another");
-- 
cgit 1.4.1-3-g733a5


From 572e4c4837e5f955cdc3751b9ad63f0bfb86beac Mon Sep 17 00:00:00 2001
From: Dániel Buga <bugadani@gmail.com>
Date: Sat, 3 Oct 2020 00:07:56 +0200
Subject: Add WJ

---
 clippy_lints/src/unicode.rs |  7 +++++--
 tests/ui/unicode.rs         |  2 ++
 tests/ui/unicode.stderr     | 12 +++++++++---
 3 files changed, 16 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unicode.rs b/clippy_lints/src/unicode.rs
index d6c8d317dc2..93d59cc7fcd 100644
--- a/clippy_lints/src/unicode.rs
+++ b/clippy_lints/src/unicode.rs
@@ -91,14 +91,17 @@ fn escape<T: Iterator<Item = char>>(s: T) -> String {
 
 fn check_str(cx: &LateContext<'_>, span: Span, id: HirId) {
     let string = snippet(cx, span, "");
-    if string.chars().any(|c| ['\u{200B}', '\u{ad}'].contains(&c)) {
+    if string.chars().any(|c| ['\u{200B}', '\u{ad}', '\u{2060}'].contains(&c)) {
         span_lint_and_sugg(
             cx,
             INVISIBLE_CHARACTERS,
             span,
             "invisible character detected",
             "consider replacing the string with",
-            string.replace("\u{200B}", "\\u{200B}").replace("\u{ad}", "\\u{AD}"),
+            string
+                .replace("\u{200B}", "\\u{200B}")
+                .replace("\u{ad}", "\\u{AD}")
+                .replace("\u{2060}", "\\u{2060}"),
             Applicability::MachineApplicable,
         );
     }
diff --git a/tests/ui/unicode.rs b/tests/ui/unicode.rs
index b6944e04859..1f596c312fe 100644
--- a/tests/ui/unicode.rs
+++ b/tests/ui/unicode.rs
@@ -4,6 +4,8 @@ fn zero() {
     print!("This\u{200B}is\u{200B}fine");
     print!("Here >­< is a SHY, and ­another");
     print!("This\u{ad}is\u{ad}fine");
+    print!("Here >⁠< is a WJ, and ⁠another");
+    print!("This\u{2060}is\u{2060}fine");
 }
 
 #[warn(clippy::unicode_not_nfc)]
diff --git a/tests/ui/unicode.stderr b/tests/ui/unicode.stderr
index 595d80ea279..3fca463c620 100644
--- a/tests/ui/unicode.stderr
+++ b/tests/ui/unicode.stderr
@@ -12,8 +12,14 @@ error: invisible character detected
 LL |     print!("Here >­< is a SHY, and ­another");
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider replacing the string with: `"Here >/u{AD}< is a SHY, and /u{AD}another"`
 
+error: invisible character detected
+  --> $DIR/unicode.rs:7:12
+   |
+LL |     print!("Here >⁠< is a WJ, and ⁠another");
+   |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider replacing the string with: `"Here >/u{2060}< is a WJ, and /u{2060}another"`
+
 error: non-NFC Unicode sequence detected
-  --> $DIR/unicode.rs:11:12
+  --> $DIR/unicode.rs:13:12
    |
 LL |     print!("̀àh?");
    |            ^^^^^ help: consider replacing the string with: `"̀àh?"`
@@ -21,12 +27,12 @@ LL |     print!("̀àh?");
    = note: `-D clippy::unicode-not-nfc` implied by `-D warnings`
 
 error: literal non-ASCII character detected
-  --> $DIR/unicode.rs:17:12
+  --> $DIR/unicode.rs:19:12
    |
 LL |     print!("Üben!");
    |            ^^^^^^^ help: consider replacing the string with: `"/u{dc}ben!"`
    |
    = note: `-D clippy::non-ascii-literal` implied by `-D warnings`
 
-error: aborting due to 4 previous errors
+error: aborting due to 5 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From f58a1695a67e2db741b7237992e696ff9a14d0ab Mon Sep 17 00:00:00 2001
From: rail <12975677+rail-rain@users.noreply.github.com>
Date: Thu, 1 Oct 2020 10:51:49 +1300
Subject: fix a FP in `interior_mutable_const`

fix a false positive in two `interior_mutable_const` lints where a constant with enums gets linted
even if it uses a clearly unfrozen variant. Note that the code uses the MIR interpreter, which
the author of #3962 thought unlikely to be a solution. This might be over-engineering;
but, I think it's important to be able to work with the 'http' crate (#3825).
---
 clippy_lints/src/non_copy_const.rs                 | 170 ++++++++++++++++-----
 .../auxiliary/helper.rs                            |  16 ++
 tests/ui/borrow_interior_mutable_const/enums.rs    | 101 ++++++++++++
 .../ui/borrow_interior_mutable_const/enums.stderr  |  75 +++++++++
 tests/ui/declare_interior_mutable_const/enums.rs   | 123 +++++++++++++++
 .../ui/declare_interior_mutable_const/enums.stderr |  89 +++++++++++
 6 files changed, 539 insertions(+), 35 deletions(-)
 create mode 100644 tests/ui/borrow_interior_mutable_const/auxiliary/helper.rs
 create mode 100644 tests/ui/borrow_interior_mutable_const/enums.rs
 create mode 100644 tests/ui/borrow_interior_mutable_const/enums.stderr
 create mode 100644 tests/ui/declare_interior_mutable_const/enums.rs
 create mode 100644 tests/ui/declare_interior_mutable_const/enums.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/non_copy_const.rs b/clippy_lints/src/non_copy_const.rs
index 7b662eae775..6b0d198edcf 100644
--- a/clippy_lints/src/non_copy_const.rs
+++ b/clippy_lints/src/non_copy_const.rs
@@ -5,11 +5,15 @@
 use std::ptr;
 
 use rustc_hir::def::{DefKind, Res};
-use rustc_hir::{Expr, ExprKind, ImplItem, ImplItemKind, Item, ItemKind, Node, TraitItem, TraitItemKind, UnOp};
+use rustc_hir::def_id::DefId;
+use rustc_hir::{
+    BodyId, Expr, ExprKind, HirId, ImplItem, ImplItemKind, Item, ItemKind, Node, TraitItem, TraitItemKind, UnOp,
+};
 use rustc_infer::traits::specialization_graph;
 use rustc_lint::{LateContext, LateLintPass, Lint};
+use rustc_middle::mir::interpret::{ConstValue, ErrorHandled};
 use rustc_middle::ty::adjustment::Adjust;
-use rustc_middle::ty::{AssocKind, Ty};
+use rustc_middle::ty::{self, AssocKind, Const, Ty};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::{InnerSpan, Span, DUMMY_SP};
 use rustc_typeck::hir_ty_to_ty;
@@ -36,14 +40,17 @@ declare_clippy_lint! {
     /// `std::sync::ONCE_INIT` constant). In this case the use of `const` is legit,
     /// and this lint should be suppressed.
     ///
-    /// When an enum has variants with interior mutability, use of its non interior mutable
-    /// variants can generate false positives. See issue
-    /// [#3962](https://github.com/rust-lang/rust-clippy/issues/3962)
+    /// Even though the lint avoids triggering on a constant whose type has enums that have variants
+    /// with interior mutability, and its value uses non interior mutable variants (see
+    /// [#3962](https://github.com/rust-lang/rust-clippy/issues/3962) and
+    /// [#3825](https://github.com/rust-lang/rust-clippy/issues/3825) for examples);
+    /// it complains about associated constants without default values only based on its types;
+    /// which might not be preferable.
+    /// There're other enums plus associated constants cases that the lint cannot handle.
     ///
     /// Types that have underlying or potential interior mutability trigger the lint whether
     /// the interior mutable field is used or not. See issues
     /// [#5812](https://github.com/rust-lang/rust-clippy/issues/5812) and
-    /// [#3825](https://github.com/rust-lang/rust-clippy/issues/3825)
     ///
     /// **Example:**
     /// ```rust
@@ -105,6 +112,79 @@ declare_clippy_lint! {
     "referencing `const` with interior mutability"
 }
 
+fn is_unfrozen<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
+    // Ignore types whose layout is unknown since `is_freeze` reports every generic types as `!Freeze`,
+    // making it indistinguishable from `UnsafeCell`. i.e. it isn't a tool to prove a type is
+    // 'unfrozen'. However, this code causes a false negative in which
+    // a type contains a layout-unknown type, but also a unsafe cell like `const CELL: Cell<T>`.
+    // Yet, it's better than `ty.has_type_flags(TypeFlags::HAS_TY_PARAM | TypeFlags::HAS_PROJECTION)`
+    // since it works when a pointer indirection involves (`Cell<*const T>`).
+    // Making up a `ParamEnv` where every generic params and assoc types are `Freeze`is another option;
+    // but I'm not sure whether it's a decent way, if possible.
+    cx.tcx.layout_of(cx.param_env.and(ty)).is_ok() && !ty.is_freeze(cx.tcx.at(DUMMY_SP), cx.param_env)
+}
+
+fn is_value_unfrozen_raw<'tcx>(
+    cx: &LateContext<'tcx>,
+    result: Result<ConstValue<'tcx>, ErrorHandled>,
+    ty: Ty<'tcx>,
+) -> bool {
+    fn inner<'tcx>(cx: &LateContext<'tcx>, val: &'tcx Const<'tcx>) -> bool {
+        match val.ty.kind() {
+            // the fact that we have to dig into every structs to search enums
+            // leads us to the point checking `UnsafeCell` directly is the only option.
+            ty::Adt(ty_def, ..) if Some(ty_def.did) == cx.tcx.lang_items().unsafe_cell_type() => true,
+            ty::Array(..) | ty::Adt(..) | ty::Tuple(..) => {
+                let val = cx.tcx.destructure_const(cx.param_env.and(val));
+                val.fields.iter().any(|field| inner(cx, field))
+            },
+            _ => false,
+        }
+    }
+
+    result.map_or_else(
+        |err| {
+            // Consider `TooGeneric` cases as being unfrozen.
+            // This causes a false positive where an assoc const whose type is unfrozen
+            // have a value that is a frozen variant with a generic param (an example is
+            // `declare_interior_mutable_const::enums::BothOfCellAndGeneric::GENERIC_VARIANT`).
+            // However, it prevents a number of false negatives that is, I think, important:
+            // 1. assoc consts in trait defs referring to consts of themselves
+            //    (an example is `declare_interior_mutable_const::traits::ConcreteTypes::ANOTHER_ATOMIC`).
+            // 2. a path expr referring to assoc consts whose type is doesn't have
+            //    any frozen variants in trait defs (i.e. without substitute for `Self`).
+            //    (e.g. borrowing `borrow_interior_mutable_const::trait::ConcreteTypes::ATOMIC`)
+            // 3. similar to the false positive above;
+            //    but the value is an unfrozen variant, or the type has no enums. (An example is
+            //    `declare_interior_mutable_const::enums::BothOfCellAndGeneric::UNFROZEN_VARIANT`
+            //    and `declare_interior_mutable_const::enums::BothOfCellAndGeneric::NO_ENUM`).
+            // One might be able to prevent these FNs correctly, and replace this with `false`;
+            // e.g. implementing `has_frozen_variant` described above, and not running this function
+            // when the type doesn't have any frozen variants would be the 'correct' way for the 2nd
+            // case (that actually removes another suboptimal behavior (I won't say 'false positive') where,
+            // similar to 2., but with the a frozen variant) (e.g. borrowing
+            // `borrow_interior_mutable_const::enums::AssocConsts::TO_BE_FROZEN_VARIANT`).
+            // I chose this way because unfrozen enums as assoc consts are rare (or, hopefully, none).
+            err == ErrorHandled::TooGeneric
+        },
+        |val| inner(cx, Const::from_value(cx.tcx, val, ty)),
+    )
+}
+
+fn is_value_unfrozen_poly<'tcx>(cx: &LateContext<'tcx>, body_id: BodyId, ty: Ty<'tcx>) -> bool {
+    let result = cx.tcx.const_eval_poly(body_id.hir_id.owner.to_def_id());
+    is_value_unfrozen_raw(cx, result, ty)
+}
+
+fn is_value_unfrozen_expr<'tcx>(cx: &LateContext<'tcx>, hir_id: HirId, def_id: DefId, ty: Ty<'tcx>) -> bool {
+    let substs = cx.typeck_results().node_substs(hir_id);
+
+    let result = cx
+        .tcx
+        .const_eval_resolve(cx.param_env, ty::WithOptConstParam::unknown(def_id), substs, None, None);
+    is_value_unfrozen_raw(cx, result, ty)
+}
+
 #[derive(Copy, Clone)]
 enum Source {
     Item { item: Span },
@@ -130,19 +210,7 @@ impl Source {
     }
 }
 
-fn verify_ty_bound<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>, source: Source) {
-    // Ignore types whose layout is unknown since `is_freeze` reports every generic types as `!Freeze`,
-    // making it indistinguishable from `UnsafeCell`. i.e. it isn't a tool to prove a type is
-    // 'unfrozen'. However, this code causes a false negative in which
-    // a type contains a layout-unknown type, but also a unsafe cell like `const CELL: Cell<T>`.
-    // Yet, it's better than `ty.has_type_flags(TypeFlags::HAS_TY_PARAM | TypeFlags::HAS_PROJECTION)`
-    // since it works when a pointer indirection involves (`Cell<*const T>`).
-    // Making up a `ParamEnv` where every generic params and assoc types are `Freeze`is another option;
-    // but I'm not sure whether it's a decent way, if possible.
-    if cx.tcx.layout_of(cx.param_env.and(ty)).is_err() || ty.is_freeze(cx.tcx.at(DUMMY_SP), cx.param_env) {
-        return;
-    }
-
+fn lint(cx: &LateContext<'_>, source: Source) {
     let (lint, msg, span) = source.lint();
     span_lint_and_then(cx, lint, span, msg, |diag| {
         if span.from_expansion() {
@@ -165,24 +233,44 @@ declare_lint_pass!(NonCopyConst => [DECLARE_INTERIOR_MUTABLE_CONST, BORROW_INTER
 
 impl<'tcx> LateLintPass<'tcx> for NonCopyConst {
     fn check_item(&mut self, cx: &LateContext<'tcx>, it: &'tcx Item<'_>) {
-        if let ItemKind::Const(hir_ty, ..) = &it.kind {
+        if let ItemKind::Const(hir_ty, body_id) = it.kind {
             let ty = hir_ty_to_ty(cx.tcx, hir_ty);
-            verify_ty_bound(cx, ty, Source::Item { item: it.span });
+
+            if is_unfrozen(cx, ty) && is_value_unfrozen_poly(cx, body_id, ty) {
+                lint(cx, Source::Item { item: it.span });
+            }
         }
     }
 
     fn check_trait_item(&mut self, cx: &LateContext<'tcx>, trait_item: &'tcx TraitItem<'_>) {
-        if let TraitItemKind::Const(hir_ty, ..) = &trait_item.kind {
+        if let TraitItemKind::Const(hir_ty, body_id_opt) = &trait_item.kind {
             let ty = hir_ty_to_ty(cx.tcx, hir_ty);
+
             // Normalize assoc types because ones originated from generic params
             // bounded other traits could have their bound.
             let normalized = cx.tcx.normalize_erasing_regions(cx.param_env, ty);
-            verify_ty_bound(cx, normalized, Source::Assoc { item: trait_item.span });
+            if is_unfrozen(cx, normalized)
+                // When there's no default value, lint it only according to its type;
+                // in other words, lint consts whose value *could* be unfrozen, not definitely is.
+                // This feels inconsistent with how the lint treats generic types,
+                // which avoids linting types which potentially become unfrozen.
+                // One could check whether a unfrozen type have a *frozen variant*
+                // (like `body_id_opt.map_or_else(|| !has_frozen_variant(...), ...)`),
+                // and do the same as the case of generic types at impl items.
+                // Note that it isn't sufficient to check if it has an enum
+                // since all of that enum's variants can be unfrozen:
+                // i.e. having an enum doesn't necessary mean a type has a frozen variant.
+                // And, implementing it isn't a trivial task; it'll probably end up
+                // re-implementing the trait predicate evaluation specific to `Freeze`.
+                && body_id_opt.map_or(true, |body_id| is_value_unfrozen_poly(cx, body_id, normalized))
+            {
+                lint(cx, Source::Assoc { item: trait_item.span });
+            }
         }
     }
 
     fn check_impl_item(&mut self, cx: &LateContext<'tcx>, impl_item: &'tcx ImplItem<'_>) {
-        if let ImplItemKind::Const(hir_ty, ..) = &impl_item.kind {
+        if let ImplItemKind::Const(hir_ty, body_id) = &impl_item.kind {
             let item_hir_id = cx.tcx.hir().get_parent_node(impl_item.hir_id);
             let item = cx.tcx.hir().expect_item(item_hir_id);
 
@@ -209,16 +297,23 @@ impl<'tcx> LateLintPass<'tcx> for NonCopyConst {
                                 ),
                             ))
                             .is_err();
+                            // If there were a function like `has_frozen_variant` described above,
+                            // we should use here as a frozen variant is a potential to be frozen
+                            // similar to unknown layouts.
+                            // e.g. `layout_of(...).is_err() || has_frozen_variant(...);`
                         then {
                             let ty = hir_ty_to_ty(cx.tcx, hir_ty);
                             let normalized = cx.tcx.normalize_erasing_regions(cx.param_env, ty);
-                            verify_ty_bound(
-                                cx,
-                                normalized,
-                                Source::Assoc {
-                                    item: impl_item.span,
-                                },
-                            );
+                            if is_unfrozen(cx, normalized)
+                                && is_value_unfrozen_poly(cx, *body_id, normalized)
+                            {
+                                lint(
+                                   cx,
+                                   Source::Assoc {
+                                       item: impl_item.span,
+                                    },
+                                );
+                            }
                         }
                     }
                 },
@@ -226,7 +321,10 @@ impl<'tcx> LateLintPass<'tcx> for NonCopyConst {
                     let ty = hir_ty_to_ty(cx.tcx, hir_ty);
                     // Normalize assoc types originated from generic params.
                     let normalized = cx.tcx.normalize_erasing_regions(cx.param_env, ty);
-                    verify_ty_bound(cx, normalized, Source::Assoc { item: impl_item.span });
+
+                    if is_unfrozen(cx, ty) && is_value_unfrozen_poly(cx, *body_id, normalized) {
+                        lint(cx, Source::Assoc { item: impl_item.span });
+                    }
                 },
                 _ => (),
             }
@@ -241,8 +339,8 @@ impl<'tcx> LateLintPass<'tcx> for NonCopyConst {
             }
 
             // Make sure it is a const item.
-            match qpath_res(cx, qpath, expr.hir_id) {
-                Res::Def(DefKind::Const | DefKind::AssocConst, _) => {},
+            let item_def_id = match qpath_res(cx, qpath, expr.hir_id) {
+                Res::Def(DefKind::Const | DefKind::AssocConst, did) => did,
                 _ => return,
             };
 
@@ -319,7 +417,9 @@ impl<'tcx> LateLintPass<'tcx> for NonCopyConst {
                 cx.typeck_results().expr_ty(dereferenced_expr)
             };
 
-            verify_ty_bound(cx, ty, Source::Expr { expr: expr.span });
+            if is_unfrozen(cx, ty) && is_value_unfrozen_expr(cx, expr.hir_id, item_def_id, ty) {
+                lint(cx, Source::Expr { expr: expr.span });
+            }
         }
     }
 }
diff --git a/tests/ui/borrow_interior_mutable_const/auxiliary/helper.rs b/tests/ui/borrow_interior_mutable_const/auxiliary/helper.rs
new file mode 100644
index 00000000000..2289f7875f0
--- /dev/null
+++ b/tests/ui/borrow_interior_mutable_const/auxiliary/helper.rs
@@ -0,0 +1,16 @@
+// this file solely exists to test constants defined in foreign crates.
+// As the most common case is the `http` crate, it replicates `http::HeadewrName`'s structure.
+
+#![allow(clippy::declare_interior_mutable_const)]
+
+use std::sync::atomic::AtomicUsize;
+
+enum Private<T> {
+    ToBeUnfrozen(T),
+    Frozen(usize),
+}
+
+pub struct Wrapper(Private<AtomicUsize>);
+
+pub const WRAPPED_PRIVATE_UNFROZEN_VARIANT: Wrapper = Wrapper(Private::ToBeUnfrozen(AtomicUsize::new(6)));
+pub const WRAPPED_PRIVATE_FROZEN_VARIANT: Wrapper = Wrapper(Private::Frozen(7));
diff --git a/tests/ui/borrow_interior_mutable_const/enums.rs b/tests/ui/borrow_interior_mutable_const/enums.rs
new file mode 100644
index 00000000000..5027db44561
--- /dev/null
+++ b/tests/ui/borrow_interior_mutable_const/enums.rs
@@ -0,0 +1,101 @@
+// aux-build:helper.rs
+
+#![warn(clippy::borrow_interior_mutable_const)]
+#![allow(clippy::declare_interior_mutable_const)]
+
+// this file (mostly) replicates its `declare` counterpart. Please see it for more discussions.
+
+extern crate helper;
+
+use std::cell::Cell;
+use std::sync::atomic::AtomicUsize;
+
+enum OptionalCell {
+    Unfrozen(Cell<bool>),
+    Frozen,
+}
+
+const UNFROZEN_VARIANT: OptionalCell = OptionalCell::Unfrozen(Cell::new(true));
+const FROZEN_VARIANT: OptionalCell = OptionalCell::Frozen;
+
+fn borrow_optional_cell() {
+    let _ = &UNFROZEN_VARIANT; //~ ERROR interior mutability
+    let _ = &FROZEN_VARIANT;
+}
+
+trait AssocConsts {
+    const TO_BE_UNFROZEN_VARIANT: OptionalCell;
+    const TO_BE_FROZEN_VARIANT: OptionalCell;
+
+    const DEFAULTED_ON_UNFROZEN_VARIANT: OptionalCell = OptionalCell::Unfrozen(Cell::new(false));
+    const DEFAULTED_ON_FROZEN_VARIANT: OptionalCell = OptionalCell::Frozen;
+
+    fn function() {
+        // This is the "suboptimal behavior" mentioned in `is_value_unfrozen`
+        // caused by a similar reason to unfrozen types without any default values
+        // get linted even if it has frozen variants'.
+        let _ = &Self::TO_BE_FROZEN_VARIANT; //~ ERROR interior mutable
+
+        // The lint ignores default values because an impl of this trait can set
+        // an unfrozen variant to `DEFAULTED_ON_FROZEN_VARIANT` and use the default impl for `function`.
+        let _ = &Self::DEFAULTED_ON_FROZEN_VARIANT; //~ ERROR interior mutable
+    }
+}
+
+impl AssocConsts for u64 {
+    const TO_BE_UNFROZEN_VARIANT: OptionalCell = OptionalCell::Unfrozen(Cell::new(false));
+    const TO_BE_FROZEN_VARIANT: OptionalCell = OptionalCell::Frozen;
+
+    fn function() {
+        let _ = &<Self as AssocConsts>::TO_BE_UNFROZEN_VARIANT; //~ ERROR interior mutable
+        let _ = &<Self as AssocConsts>::TO_BE_FROZEN_VARIANT;
+        let _ = &Self::DEFAULTED_ON_UNFROZEN_VARIANT; //~ ERROR interior mutable
+        let _ = &Self::DEFAULTED_ON_FROZEN_VARIANT;
+    }
+}
+
+trait AssocTypes {
+    type ToBeUnfrozen;
+
+    const TO_BE_UNFROZEN_VARIANT: Option<Self::ToBeUnfrozen>;
+    const TO_BE_FROZEN_VARIANT: Option<Self::ToBeUnfrozen>;
+
+    // there's no need to test here because it's the exactly same as `trait::AssocTypes`
+    fn function();
+}
+
+impl AssocTypes for u64 {
+    type ToBeUnfrozen = AtomicUsize;
+
+    const TO_BE_UNFROZEN_VARIANT: Option<Self::ToBeUnfrozen> = Some(Self::ToBeUnfrozen::new(4)); //~ ERROR interior mutable
+    const TO_BE_FROZEN_VARIANT: Option<Self::ToBeUnfrozen> = None;
+
+    fn function() {
+        let _ = &<Self as AssocTypes>::TO_BE_UNFROZEN_VARIANT; //~ ERROR interior mutable
+        let _ = &<Self as AssocTypes>::TO_BE_FROZEN_VARIANT;
+    }
+}
+
+enum BothOfCellAndGeneric<T> {
+    Unfrozen(Cell<*const T>),
+    Generic(*const T),
+    Frozen(usize),
+}
+
+impl<T> BothOfCellAndGeneric<T> {
+    const UNFROZEN_VARIANT: BothOfCellAndGeneric<T> = BothOfCellAndGeneric::Unfrozen(Cell::new(std::ptr::null())); //~ ERROR interior mutable
+    const GENERIC_VARIANT: BothOfCellAndGeneric<T> = BothOfCellAndGeneric::Generic(std::ptr::null()); //~ ERROR interior mutable
+    const FROZEN_VARIANT: BothOfCellAndGeneric<T> = BothOfCellAndGeneric::Frozen(5);
+
+    fn function() {
+        let _ = &Self::UNFROZEN_VARIANT; //~ ERROR interior mutability
+        let _ = &Self::GENERIC_VARIANT; //~ ERROR interior mutability
+        let _ = &Self::FROZEN_VARIANT;
+    }
+}
+
+fn main() {
+    // constants defined in foreign crates
+    let _ = &helper::WRAPPED_PRIVATE_UNFROZEN_VARIANT; //~ ERROR interior mutability
+    let _ = &helper::WRAPPED_PRIVATE_FROZEN_VARIANT;
+}
diff --git a/tests/ui/borrow_interior_mutable_const/enums.stderr b/tests/ui/borrow_interior_mutable_const/enums.stderr
new file mode 100644
index 00000000000..654a1ee7df6
--- /dev/null
+++ b/tests/ui/borrow_interior_mutable_const/enums.stderr
@@ -0,0 +1,75 @@
+error: a `const` item with interior mutability should not be borrowed
+  --> $DIR/enums.rs:22:14
+   |
+LL |     let _ = &UNFROZEN_VARIANT; //~ ERROR interior mutability
+   |              ^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::borrow-interior-mutable-const` implied by `-D warnings`
+   = help: assign this const to a local or static variable, and use the variable here
+
+error: a `const` item with interior mutability should not be borrowed
+  --> $DIR/enums.rs:37:18
+   |
+LL |         let _ = &Self::TO_BE_FROZEN_VARIANT; //~ ERROR interior mutable
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: assign this const to a local or static variable, and use the variable here
+
+error: a `const` item with interior mutability should not be borrowed
+  --> $DIR/enums.rs:41:18
+   |
+LL |         let _ = &Self::DEFAULTED_ON_FROZEN_VARIANT; //~ ERROR interior mutable
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: assign this const to a local or static variable, and use the variable here
+
+error: a `const` item with interior mutability should not be borrowed
+  --> $DIR/enums.rs:50:18
+   |
+LL |         let _ = &<Self as AssocConsts>::TO_BE_UNFROZEN_VARIANT; //~ ERROR interior mutable
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: assign this const to a local or static variable, and use the variable here
+
+error: a `const` item with interior mutability should not be borrowed
+  --> $DIR/enums.rs:52:18
+   |
+LL |         let _ = &Self::DEFAULTED_ON_UNFROZEN_VARIANT; //~ ERROR interior mutable
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: assign this const to a local or static variable, and use the variable here
+
+error: a `const` item with interior mutability should not be borrowed
+  --> $DIR/enums.rs:74:18
+   |
+LL |         let _ = &<Self as AssocTypes>::TO_BE_UNFROZEN_VARIANT; //~ ERROR interior mutable
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: assign this const to a local or static variable, and use the variable here
+
+error: a `const` item with interior mutability should not be borrowed
+  --> $DIR/enums.rs:91:18
+   |
+LL |         let _ = &Self::UNFROZEN_VARIANT; //~ ERROR interior mutability
+   |                  ^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: assign this const to a local or static variable, and use the variable here
+
+error: a `const` item with interior mutability should not be borrowed
+  --> $DIR/enums.rs:92:18
+   |
+LL |         let _ = &Self::GENERIC_VARIANT; //~ ERROR interior mutability
+   |                  ^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: assign this const to a local or static variable, and use the variable here
+
+error: a `const` item with interior mutability should not be borrowed
+  --> $DIR/enums.rs:99:14
+   |
+LL |     let _ = &helper::WRAPPED_PRIVATE_UNFROZEN_VARIANT; //~ ERROR interior mutability
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: assign this const to a local or static variable, and use the variable here
+
+error: aborting due to 9 previous errors
+
diff --git a/tests/ui/declare_interior_mutable_const/enums.rs b/tests/ui/declare_interior_mutable_const/enums.rs
new file mode 100644
index 00000000000..f44518694b8
--- /dev/null
+++ b/tests/ui/declare_interior_mutable_const/enums.rs
@@ -0,0 +1,123 @@
+#![warn(clippy::declare_interior_mutable_const)]
+
+use std::cell::Cell;
+use std::sync::atomic::AtomicUsize;
+
+enum OptionalCell {
+    Unfrozen(Cell<bool>),
+    Frozen,
+}
+
+// a constant with enums should be linted only when the used variant is unfrozen (#3962).
+const UNFROZEN_VARIANT: OptionalCell = OptionalCell::Unfrozen(Cell::new(true)); //~ ERROR interior mutable
+const FROZEN_VARIANT: OptionalCell = OptionalCell::Frozen;
+
+const fn unfrozen_variant() -> OptionalCell {
+    OptionalCell::Unfrozen(Cell::new(false))
+}
+
+const fn frozen_variant() -> OptionalCell {
+    OptionalCell::Frozen
+}
+
+const UNFROZEN_VARIANT_FROM_FN: OptionalCell = unfrozen_variant(); //~ ERROR interior mutable
+const FROZEN_VARIANT_FROM_FN: OptionalCell = frozen_variant();
+
+enum NestedInnermost {
+    Unfrozen(AtomicUsize),
+    Frozen,
+}
+
+struct NestedInner {
+    inner: NestedInnermost,
+}
+
+enum NestedOuter {
+    NestedInner(NestedInner),
+    NotNested(usize),
+}
+
+struct NestedOutermost {
+    outer: NestedOuter,
+}
+
+// a constant with enums should be linted according to its value, no matter how structs involve.
+const NESTED_UNFROZEN_VARIANT: NestedOutermost = NestedOutermost {
+    outer: NestedOuter::NestedInner(NestedInner {
+        inner: NestedInnermost::Unfrozen(AtomicUsize::new(2)),
+    }),
+}; //~ ERROR interior mutable
+const NESTED_FROZEN_VARIANT: NestedOutermost = NestedOutermost {
+    outer: NestedOuter::NestedInner(NestedInner {
+        inner: NestedInnermost::Frozen,
+    }),
+};
+
+trait AssocConsts {
+    // When there's no default value, lint it only according to its type.
+    // Further details are on the corresponding code (`NonCopyConst::check_trait_item`).
+    const TO_BE_UNFROZEN_VARIANT: OptionalCell; //~ ERROR interior mutable
+    const TO_BE_FROZEN_VARIANT: OptionalCell; //~ ERROR interior mutable
+
+    // Lint default values accordingly.
+    const DEFAULTED_ON_UNFROZEN_VARIANT: OptionalCell = OptionalCell::Unfrozen(Cell::new(false)); //~ ERROR interior mutable
+    const DEFAULTED_ON_FROZEN_VARIANT: OptionalCell = OptionalCell::Frozen;
+}
+
+// The lint doesn't trigger for an assoc constant in a trait impl with an unfrozen type even if it
+// has enums. Further details are on the corresponding code in 'NonCopyConst::check_impl_item'.
+impl AssocConsts for u64 {
+    const TO_BE_UNFROZEN_VARIANT: OptionalCell = OptionalCell::Unfrozen(Cell::new(false));
+    const TO_BE_FROZEN_VARIANT: OptionalCell = OptionalCell::Frozen;
+
+    // even if this sets an unfrozen variant, the lint ignores it.
+    const DEFAULTED_ON_FROZEN_VARIANT: OptionalCell = OptionalCell::Unfrozen(Cell::new(false));
+}
+
+// At first, I thought I'd need to check every patterns in `trait.rs`; but, what matters
+// here are values; and I think substituted generics at definitions won't appear in MIR.
+trait AssocTypes {
+    type ToBeUnfrozen;
+
+    const TO_BE_UNFROZEN_VARIANT: Option<Self::ToBeUnfrozen>;
+    const TO_BE_FROZEN_VARIANT: Option<Self::ToBeUnfrozen>;
+}
+
+impl AssocTypes for u64 {
+    type ToBeUnfrozen = AtomicUsize;
+
+    const TO_BE_UNFROZEN_VARIANT: Option<Self::ToBeUnfrozen> = Some(Self::ToBeUnfrozen::new(4)); //~ ERROR interior mutable
+    const TO_BE_FROZEN_VARIANT: Option<Self::ToBeUnfrozen> = None;
+}
+
+// Use raw pointers since direct generics have a false negative at the type level.
+enum BothOfCellAndGeneric<T> {
+    Unfrozen(Cell<*const T>),
+    Generic(*const T),
+    Frozen(usize),
+}
+
+impl<T> BothOfCellAndGeneric<T> {
+    const UNFROZEN_VARIANT: BothOfCellAndGeneric<T> = BothOfCellAndGeneric::Unfrozen(Cell::new(std::ptr::null())); //~ ERROR interior mutable
+
+    // This is a false positive. The argument about this is on `is_value_unfrozen_raw`
+    const GENERIC_VARIANT: BothOfCellAndGeneric<T> = BothOfCellAndGeneric::Generic(std::ptr::null()); //~ ERROR interior mutable
+
+    const FROZEN_VARIANT: BothOfCellAndGeneric<T> = BothOfCellAndGeneric::Frozen(5);
+
+    // This is what is likely to be a false negative when one tries to fix
+    // the `GENERIC_VARIANT` false positive.
+    const NO_ENUM: Cell<*const T> = Cell::new(std::ptr::null()); //~ ERROR interior mutable
+}
+
+// associated types here is basically the same as the one above.
+trait BothOfCellAndGenericWithAssocType {
+    type AssocType;
+
+    const UNFROZEN_VARIANT: BothOfCellAndGeneric<Self::AssocType> =
+        BothOfCellAndGeneric::Unfrozen(Cell::new(std::ptr::null())); //~ ERROR interior mutable
+    const GENERIC_VARIANT: BothOfCellAndGeneric<Self::AssocType> = BothOfCellAndGeneric::Generic(std::ptr::null()); //~ ERROR interior mutable
+    const FROZEN_VARIANT: BothOfCellAndGeneric<Self::AssocType> = BothOfCellAndGeneric::Frozen(5);
+}
+
+fn main() {}
diff --git a/tests/ui/declare_interior_mutable_const/enums.stderr b/tests/ui/declare_interior_mutable_const/enums.stderr
new file mode 100644
index 00000000000..84198d54615
--- /dev/null
+++ b/tests/ui/declare_interior_mutable_const/enums.stderr
@@ -0,0 +1,89 @@
+error: a `const` item should never be interior mutable
+  --> $DIR/enums.rs:12:1
+   |
+LL | const UNFROZEN_VARIANT: OptionalCell = OptionalCell::Unfrozen(Cell::new(true)); //~ ERROR interior mutable
+   | -----^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   | |
+   | make this a static item (maybe with lazy_static)
+   |
+   = note: `-D clippy::declare-interior-mutable-const` implied by `-D warnings`
+
+error: a `const` item should never be interior mutable
+  --> $DIR/enums.rs:23:1
+   |
+LL | const UNFROZEN_VARIANT_FROM_FN: OptionalCell = unfrozen_variant(); //~ ERROR interior mutable
+   | -----^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   | |
+   | make this a static item (maybe with lazy_static)
+
+error: a `const` item should never be interior mutable
+  --> $DIR/enums.rs:45:1
+   |
+LL |   const NESTED_UNFROZEN_VARIANT: NestedOutermost = NestedOutermost {
+   |   ^----
+   |   |
+   |  _make this a static item (maybe with lazy_static)
+   | |
+LL | |     outer: NestedOuter::NestedInner(NestedInner {
+LL | |         inner: NestedInnermost::Unfrozen(AtomicUsize::new(2)),
+LL | |     }),
+LL | | }; //~ ERROR interior mutable
+   | |__^
+
+error: a `const` item should never be interior mutable
+  --> $DIR/enums.rs:59:5
+   |
+LL |     const TO_BE_UNFROZEN_VARIANT: OptionalCell; //~ ERROR interior mutable
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: a `const` item should never be interior mutable
+  --> $DIR/enums.rs:60:5
+   |
+LL |     const TO_BE_FROZEN_VARIANT: OptionalCell; //~ ERROR interior mutable
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: a `const` item should never be interior mutable
+  --> $DIR/enums.rs:63:5
+   |
+LL |     const DEFAULTED_ON_UNFROZEN_VARIANT: OptionalCell = OptionalCell::Unfrozen(Cell::new(false)); //~ ERROR interior mutable
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: a `const` item should never be interior mutable
+  --> $DIR/enums.rs:89:5
+   |
+LL |     const TO_BE_UNFROZEN_VARIANT: Option<Self::ToBeUnfrozen> = Some(Self::ToBeUnfrozen::new(4)); //~ ERROR interior mutable
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: a `const` item should never be interior mutable
+  --> $DIR/enums.rs:101:5
+   |
+LL |     const UNFROZEN_VARIANT: BothOfCellAndGeneric<T> = BothOfCellAndGeneric::Unfrozen(Cell::new(std::ptr::null())); //~ ERROR interior mut...
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: a `const` item should never be interior mutable
+  --> $DIR/enums.rs:104:5
+   |
+LL |     const GENERIC_VARIANT: BothOfCellAndGeneric<T> = BothOfCellAndGeneric::Generic(std::ptr::null()); //~ ERROR interior mutable
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: a `const` item should never be interior mutable
+  --> $DIR/enums.rs:110:5
+   |
+LL |     const NO_ENUM: Cell<*const T> = Cell::new(std::ptr::null()); //~ ERROR interior mutable
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: a `const` item should never be interior mutable
+  --> $DIR/enums.rs:117:5
+   |
+LL | /     const UNFROZEN_VARIANT: BothOfCellAndGeneric<Self::AssocType> =
+LL | |         BothOfCellAndGeneric::Unfrozen(Cell::new(std::ptr::null())); //~ ERROR interior mutable
+   | |____________________________________________________________________^
+
+error: a `const` item should never be interior mutable
+  --> $DIR/enums.rs:119:5
+   |
+LL |     const GENERIC_VARIANT: BothOfCellAndGeneric<Self::AssocType> = BothOfCellAndGeneric::Generic(std::ptr::null()); //~ ERROR interior mu...
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 12 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 78695bd4968d45ef6afd3433af4bf6f310128770 Mon Sep 17 00:00:00 2001
From: FliegendeWurst <2012gdwu@web.de>
Date: Mon, 5 Oct 2020 12:08:57 +0200
Subject: Do not lint float fractions in `mistyped_literal_suffixes` (fixes
 #4706)

---
 clippy_lints/src/literal_representation.rs |  9 +++------
 tests/ui/mistyped_literal_suffix.fixed     |  6 +++---
 tests/ui/mistyped_literal_suffix.rs        |  6 +++---
 tests/ui/mistyped_literal_suffix.stderr    | 14 +-------------
 4 files changed, 10 insertions(+), 25 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/literal_representation.rs b/clippy_lints/src/literal_representation.rs
index a36fdca5d5d..c54103b25c2 100644
--- a/clippy_lints/src/literal_representation.rs
+++ b/clippy_lints/src/literal_representation.rs
@@ -264,13 +264,10 @@ impl LiteralDigitGrouping {
 
         let (part, mistyped_suffixes, missing_char) = if let Some((_, exponent)) = &mut num_lit.exponent {
             (exponent, &["32", "64"][..], 'f')
+        } else if num_lit.fraction.is_some() {
+            (&mut num_lit.integer, &["32", "64"][..], 'f')
         } else {
-            num_lit
-                .fraction
-                .as_mut()
-                .map_or((&mut num_lit.integer, &["8", "16", "32", "64"][..], 'i'), |fraction| {
-                    (fraction, &["32", "64"][..], 'f')
-                })
+            (&mut num_lit.integer, &["8", "16", "32", "64"][..], 'i')
         };
 
         let mut split = part.rsplit('_');
diff --git a/tests/ui/mistyped_literal_suffix.fixed b/tests/ui/mistyped_literal_suffix.fixed
index baee7735730..8275bfa5db7 100644
--- a/tests/ui/mistyped_literal_suffix.fixed
+++ b/tests/ui/mistyped_literal_suffix.fixed
@@ -1,6 +1,6 @@
 // run-rustfix
 
-#![allow(dead_code, unused_variables, clippy::excessive_precision)]
+#![allow(dead_code, unused_variables, clippy::excessive_precision, clippy::inconsistent_digit_grouping)]
 
 fn main() {
     let fail14 = 2_i32;
@@ -12,13 +12,13 @@ fn main() {
     let fail20 = 2_i8; //
     let fail21 = 4_i16; //
 
-    let fail24 = 12.34_f64;
+    let ok24 = 12.34_64;
     let fail25 = 1E2_f32;
     let fail26 = 43E7_f64;
     let fail27 = 243E17_f32;
     #[allow(overflowing_literals)]
     let fail28 = 241_251_235E723_f64;
-    let fail29 = 42_279.911_f32;
+    let ok29 = 42279.911_32;
 
     let _ = 1.123_45E1_f32;
 }
diff --git a/tests/ui/mistyped_literal_suffix.rs b/tests/ui/mistyped_literal_suffix.rs
index 6de447f4021..8a451807aeb 100644
--- a/tests/ui/mistyped_literal_suffix.rs
+++ b/tests/ui/mistyped_literal_suffix.rs
@@ -1,6 +1,6 @@
 // run-rustfix
 
-#![allow(dead_code, unused_variables, clippy::excessive_precision)]
+#![allow(dead_code, unused_variables, clippy::excessive_precision, clippy::inconsistent_digit_grouping)]
 
 fn main() {
     let fail14 = 2_32;
@@ -12,13 +12,13 @@ fn main() {
     let fail20 = 2__8; //
     let fail21 = 4___16; //
 
-    let fail24 = 12.34_64;
+    let ok24 = 12.34_64;
     let fail25 = 1E2_32;
     let fail26 = 43E7_64;
     let fail27 = 243E17_32;
     #[allow(overflowing_literals)]
     let fail28 = 241251235E723_64;
-    let fail29 = 42279.911_32;
+    let ok29 = 42279.911_32;
 
     let _ = 1.12345E1_32;
 }
diff --git a/tests/ui/mistyped_literal_suffix.stderr b/tests/ui/mistyped_literal_suffix.stderr
index 48a7ae90494..f4c5adfe82c 100644
--- a/tests/ui/mistyped_literal_suffix.stderr
+++ b/tests/ui/mistyped_literal_suffix.stderr
@@ -36,12 +36,6 @@ error: mistyped literal suffix
 LL |     let fail21 = 4___16; //
    |                  ^^^^^^ help: did you mean to write: `4_i16`
 
-error: mistyped literal suffix
-  --> $DIR/mistyped_literal_suffix.rs:15:18
-   |
-LL |     let fail24 = 12.34_64;
-   |                  ^^^^^^^^ help: did you mean to write: `12.34_f64`
-
 error: mistyped literal suffix
   --> $DIR/mistyped_literal_suffix.rs:16:18
    |
@@ -66,17 +60,11 @@ error: mistyped literal suffix
 LL |     let fail28 = 241251235E723_64;
    |                  ^^^^^^^^^^^^^^^^ help: did you mean to write: `241_251_235E723_f64`
 
-error: mistyped literal suffix
-  --> $DIR/mistyped_literal_suffix.rs:21:18
-   |
-LL |     let fail29 = 42279.911_32;
-   |                  ^^^^^^^^^^^^ help: did you mean to write: `42_279.911_f32`
-
 error: mistyped literal suffix
   --> $DIR/mistyped_literal_suffix.rs:23:13
    |
 LL |     let _ = 1.12345E1_32;
    |             ^^^^^^^^^^^^ help: did you mean to write: `1.123_45E1_f32`
 
-error: aborting due to 13 previous errors
+error: aborting due to 11 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 5554641fceb640116316201bf669c04e1f86fcc3 Mon Sep 17 00:00:00 2001
From: Eduardo Broto <ebroto@tutanota.com>
Date: Mon, 5 Oct 2020 22:32:04 +0200
Subject: Fix rustup fallout

---
 clippy_lints/src/attrs.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs
index c8f153e7201..f6eadbdef0b 100644
--- a/clippy_lints/src/attrs.rs
+++ b/clippy_lints/src/attrs.rs
@@ -137,17 +137,17 @@ declare_clippy_lint! {
     /// **Example:**
     /// ```rust
     /// // Good (as inner attribute)
-    /// #![inline(always)]
+    /// #![allow(dead_code)]
     ///
     /// fn this_is_fine() { }
     ///
     /// // Bad
-    /// #[inline(always)]
+    /// #[allow(dead_code)]
     ///
     /// fn not_quite_good_code() { }
     ///
     /// // Good (as outer attribute)
-    /// #[inline(always)]
+    /// #[allow(dead_code)]
     /// fn this_is_fine_too() { }
     /// ```
     pub EMPTY_LINE_AFTER_OUTER_ATTR,
-- 
cgit 1.4.1-3-g733a5


From da57a16872297de5b6bb7754f722381631d4dca4 Mon Sep 17 00:00:00 2001
From: Philipp Hansch <dev@phansch.net>
Date: Tue, 6 Oct 2020 08:26:16 +0200
Subject: clippy_lints: Replace lazy_static with SyncLazy

---
 clippy_lints/Cargo.toml        | 1 -
 clippy_lints/src/lib.rs        | 1 +
 clippy_lints/src/macro_use.rs  | 4 ++--
 clippy_lints/src/utils/conf.rs | 8 ++++----
 4 files changed, 7 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/Cargo.toml b/clippy_lints/Cargo.toml
index 341d9e601ee..fcf817b82c8 100644
--- a/clippy_lints/Cargo.toml
+++ b/clippy_lints/Cargo.toml
@@ -20,7 +20,6 @@ edition = "2018"
 cargo_metadata = "0.11.1"
 if_chain = "1.0.0"
 itertools = "0.9"
-lazy_static = "1.0.2"
 pulldown-cmark = { version = "0.8", default-features = false }
 quine-mc_cluskey = "0.2.2"
 regex-syntax = "0.6"
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 72ad8d12e6d..826a059f92a 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -7,6 +7,7 @@
 #![feature(crate_visibility_modifier)]
 #![feature(drain_filter)]
 #![feature(in_band_lifetimes)]
+#![feature(once_cell)]
 #![feature(or_patterns)]
 #![feature(rustc_private)]
 #![feature(stmt_expr_attributes)]
diff --git a/clippy_lints/src/macro_use.rs b/clippy_lints/src/macro_use.rs
index 065c7c042d3..b4b4b3dc18d 100644
--- a/clippy_lints/src/macro_use.rs
+++ b/clippy_lints/src/macro_use.rs
@@ -18,9 +18,9 @@ declare_clippy_lint! {
     /// **Known problems:** None.
     ///
     /// **Example:**
-    /// ```rust
+    /// ```rust,ignore
     /// #[macro_use]
-    /// use lazy_static;
+    /// use some_macro;
     /// ```
     pub MACRO_USE_IMPORTS,
     pedantic,
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 03f8c5a2c07..dd2fd0bb445 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -2,10 +2,10 @@
 
 #![deny(clippy::missing_docs_in_private_items)]
 
-use lazy_static::lazy_static;
 use rustc_ast::ast::{LitKind, MetaItemKind, NestedMetaItem};
 use rustc_span::source_map;
 use source_map::Span;
+use std::lazy::SyncLazy;
 use std::path::{Path, PathBuf};
 use std::sync::Mutex;
 use std::{env, fmt, fs, io};
@@ -54,9 +54,8 @@ impl From<io::Error> for Error {
     }
 }
 
-lazy_static! {
-    static ref ERRORS: Mutex<Vec<Error>> = Mutex::new(Vec::new());
-}
+/// Vec of errors that might be collected during config toml parsing
+static ERRORS: SyncLazy<Mutex<Vec<Error>>> = SyncLazy::new(|| Mutex::new(Vec::new()));
 
 macro_rules! define_Conf {
     ($(#[$doc:meta] ($config:ident, $config_str:literal: $Ty:ty, $default:expr),)+) => {
@@ -82,6 +81,7 @@ macro_rules! define_Conf {
                     use serde::Deserialize;
                     pub fn deserialize<'de, D: serde::Deserializer<'de>>(deserializer: D) -> Result<$Ty, D::Error> {
                         use super::super::{ERRORS, Error};
+
                         Ok(
                             <$Ty>::deserialize(deserializer).unwrap_or_else(|e| {
                                 ERRORS
-- 
cgit 1.4.1-3-g733a5


From 7021d70d2e57e081597ea34eb18226a71b665ecd Mon Sep 17 00:00:00 2001
From: Ivan Tham <pickfire@riseup.net>
Date: Tue, 6 Oct 2020 23:58:32 +0800
Subject: Use more concrete explanation for methods

Show some code rather than "a single method call".
---
 clippy_lints/src/methods/mod.rs | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index dadd0f8ebb7..a9650e531b6 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -400,8 +400,8 @@ declare_clippy_lint! {
 declare_clippy_lint! {
     /// **What it does:** Checks for usage of `_.map(_).flatten(_)`,
     ///
-    /// **Why is this bad?** Readability, this can be written more concisely as a
-    /// single method call using `_.flat_map(_)`
+    /// **Why is this bad?** Readability, this can be written more concisely as
+    /// `_.flat_map(_)`
     ///
     /// **Known problems:**
     ///
@@ -424,8 +424,8 @@ declare_clippy_lint! {
     /// **What it does:** Checks for usage of `_.filter(_).map(_)`,
     /// `_.filter(_).flat_map(_)`, `_.filter_map(_).flat_map(_)` and similar.
     ///
-    /// **Why is this bad?** Readability, this can be written more concisely as a
-    /// single method call.
+    /// **Why is this bad?** Readability, this can be written more concisely as
+    /// `_.filter_map(_)`.
     ///
     /// **Known problems:** Often requires a condition + Option/Iterator creation
     /// inside the closure.
@@ -452,8 +452,8 @@ declare_clippy_lint! {
 declare_clippy_lint! {
     /// **What it does:** Checks for usage of `_.filter_map(_).next()`.
     ///
-    /// **Why is this bad?** Readability, this can be written more concisely as a
-    /// single method call.
+    /// **Why is this bad?** Readability, this can be written more concisely as
+    /// `_.find_map(_)`.
     ///
     /// **Known problems:** None
     ///
@@ -496,8 +496,8 @@ declare_clippy_lint! {
 declare_clippy_lint! {
     /// **What it does:** Checks for usage of `_.find(_).map(_)`.
     ///
-    /// **Why is this bad?** Readability, this can be written more concisely as a
-    /// single method call.
+    /// **Why is this bad?** Readability, this can be written more concisely as
+    /// `_.find_map(_)`.
     ///
     /// **Known problems:** Often requires a condition + Option/Iterator creation
     /// inside the closure.
@@ -1276,8 +1276,8 @@ declare_clippy_lint! {
 declare_clippy_lint! {
     /// **What it does:** Checks for usage of `_.as_ref().map(Deref::deref)` or it's aliases (such as String::as_str).
     ///
-    /// **Why is this bad?** Readability, this can be written more concisely as a
-    /// single method call.
+    /// **Why is this bad?** Readability, this can be written more concisely as
+    /// `_.as_deref()`.
     ///
     /// **Known problems:** None.
     ///
-- 
cgit 1.4.1-3-g733a5


From b05aeaa9bce36d69d9ee13d1b5f6a271b6e8c1e5 Mon Sep 17 00:00:00 2001
From: flip1995 <hello@philkrones.com>
Date: Tue, 6 Oct 2020 23:32:38 +0200
Subject: Run fmt

---
 clippy_lints/src/future_not_send.rs | 9 ++-------
 clippy_lints/src/methods/mod.rs     | 4 +---
 clippy_lints/src/utils/mod.rs       | 3 +--
 3 files changed, 4 insertions(+), 12 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/future_not_send.rs b/clippy_lints/src/future_not_send.rs
index d2a322e1223..71a30d1c33d 100644
--- a/clippy_lints/src/future_not_send.rs
+++ b/clippy_lints/src/future_not_send.rs
@@ -92,13 +92,8 @@ impl<'tcx> LateLintPass<'tcx> for FutureNotSend {
                         |db| {
                             cx.tcx.infer_ctxt().enter(|infcx| {
                                 for FulfillmentError { obligation, .. } in send_errors {
-                                    infcx.maybe_note_obligation_cause_for_async_await(
-                                        db,
-                                        &obligation,
-                                    );
-                                    if let Trait(trait_pred, _) =
-                                        obligation.predicate.skip_binders()
-                                    {
+                                    infcx.maybe_note_obligation_cause_for_async_await(db, &obligation);
+                                    if let Trait(trait_pred, _) = obligation.predicate.skip_binders() {
                                         db.note(&format!(
                                             "`{}` doesn't implement `{}`",
                                             trait_pred.self_ty(),
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index e0651f9ab5d..ec70b2f1e20 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1668,9 +1668,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             if let ty::Opaque(def_id, _) = *ret_ty.kind() {
                 // one of the associated types must be Self
                 for &(predicate, _span) in cx.tcx.explicit_item_bounds(def_id) {
-                    if let ty::PredicateAtom::Projection(projection_predicate) =
-                        predicate.skip_binders()
-                    {
+                    if let ty::PredicateAtom::Projection(projection_predicate) = predicate.skip_binders() {
                         // walk the associated type and check for Self
                         if contains_ty(projection_predicate.ty, self_ty) {
                             return;
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index 247effde19b..b2a8e3f08d5 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -1287,8 +1287,7 @@ pub fn is_must_use_ty<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
         ty::Opaque(ref def_id, _) => {
             for (predicate, _) in cx.tcx.explicit_item_bounds(*def_id) {
                 if let ty::PredicateAtom::Trait(trait_predicate, _) = predicate.skip_binders() {
-                    if must_use_attr(&cx.tcx.get_attrs(trait_predicate.trait_ref.def_id)).is_some()
-                    {
+                    if must_use_attr(&cx.tcx.get_attrs(trait_predicate.trait_ref.def_id)).is_some() {
                         return true;
                     }
                 }
-- 
cgit 1.4.1-3-g733a5


From a5ef305cb5a10437963ecda82a833b6932dc70d1 Mon Sep 17 00:00:00 2001
From: David Tolnay <dtolnay@gmail.com>
Date: Mon, 5 Oct 2020 12:19:35 -0700
Subject: Downgrade string_lit_as_bytes to nursery

---
 clippy_lints/src/lib.rs     | 3 +--
 clippy_lints/src/strings.rs | 2 +-
 src/lintlist/mod.rs         | 2 +-
 3 files changed, 3 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 72ad8d12e6d..6ae8ae9e38b 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1475,7 +1475,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS),
         LintId::of(&slow_vector_initialization::SLOW_VECTOR_INITIALIZATION),
         LintId::of(&stable_sort_primitive::STABLE_SORT_PRIMITIVE),
-        LintId::of(&strings::STRING_LIT_AS_BYTES),
         LintId::of(&suspicious_trait_impl::SUSPICIOUS_ARITHMETIC_IMPL),
         LintId::of(&suspicious_trait_impl::SUSPICIOUS_OP_ASSIGN_IMPL),
         LintId::of(&swap::ALMOST_SWAPPED),
@@ -1618,7 +1617,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&returns::LET_AND_RETURN),
         LintId::of(&returns::NEEDLESS_RETURN),
         LintId::of(&single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS),
-        LintId::of(&strings::STRING_LIT_AS_BYTES),
         LintId::of(&tabs_in_doc_comments::TABS_IN_DOC_COMMENTS),
         LintId::of(&to_digit_is_some::TO_DIGIT_IS_SOME),
         LintId::of(&try_err::TRY_ERR),
@@ -1831,6 +1829,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&needless_borrow::NEEDLESS_BORROW),
         LintId::of(&path_buf_push_overwrite::PATH_BUF_PUSH_OVERWRITE),
         LintId::of(&redundant_pub_crate::REDUNDANT_PUB_CRATE),
+        LintId::of(&strings::STRING_LIT_AS_BYTES),
         LintId::of(&transmute::USELESS_TRANSMUTE),
         LintId::of(&use_self::USE_SELF),
     ]);
diff --git a/clippy_lints/src/strings.rs b/clippy_lints/src/strings.rs
index 15b66684eab..203af06a734 100644
--- a/clippy_lints/src/strings.rs
+++ b/clippy_lints/src/strings.rs
@@ -80,7 +80,7 @@ declare_clippy_lint! {
     /// let bs = b"a byte string";
     /// ```
     pub STRING_LIT_AS_BYTES,
-    style,
+    nursery,
     "calling `as_bytes` on a string literal instead of using a byte string literal"
 }
 
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index 0dba5a71c50..959ac6d42bf 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -2161,7 +2161,7 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
     },
     Lint {
         name: "string_lit_as_bytes",
-        group: "style",
+        group: "nursery",
         desc: "calling `as_bytes` on a string literal instead of using a byte string literal",
         deprecation: None,
         module: "strings",
-- 
cgit 1.4.1-3-g733a5


From 0e159a55d66f4c3cd56237f28a36f31599442102 Mon Sep 17 00:00:00 2001
From: David Tolnay <dtolnay@gmail.com>
Date: Tue, 6 Oct 2020 19:46:03 -0700
Subject: Downgrade rc_buffer to restriction

---
 clippy_lints/src/lib.rs   | 3 +--
 clippy_lints/src/types.rs | 2 +-
 src/lintlist/mod.rs       | 2 +-
 3 files changed, 3 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 72ad8d12e6d..a5a24536772 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1171,6 +1171,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&shadow::SHADOW_REUSE),
         LintId::of(&shadow::SHADOW_SAME),
         LintId::of(&strings::STRING_ADD),
+        LintId::of(&types::RC_BUFFER),
         LintId::of(&unwrap_in_result::UNWRAP_IN_RESULT),
         LintId::of(&verbose_file_reads::VERBOSE_FILE_READS),
         LintId::of(&write::PRINT_STDOUT),
@@ -1504,7 +1505,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&types::CHAR_LIT_AS_U8),
         LintId::of(&types::FN_TO_NUMERIC_CAST),
         LintId::of(&types::FN_TO_NUMERIC_CAST_WITH_TRUNCATION),
-        LintId::of(&types::RC_BUFFER),
         LintId::of(&types::REDUNDANT_ALLOCATION),
         LintId::of(&types::TYPE_COMPLEXITY),
         LintId::of(&types::UNIT_ARG),
@@ -1805,7 +1805,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&slow_vector_initialization::SLOW_VECTOR_INITIALIZATION),
         LintId::of(&stable_sort_primitive::STABLE_SORT_PRIMITIVE),
         LintId::of(&types::BOX_VEC),
-        LintId::of(&types::RC_BUFFER),
         LintId::of(&types::REDUNDANT_ALLOCATION),
         LintId::of(&vec::USELESS_VEC),
     ]);
diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs
index 17d950169fd..5e83b6c81ec 100644
--- a/clippy_lints/src/types.rs
+++ b/clippy_lints/src/types.rs
@@ -242,7 +242,7 @@ declare_clippy_lint! {
     /// fn foo(interned: Rc<str>) { ... }
     /// ```
     pub RC_BUFFER,
-    perf,
+    restriction,
     "shared ownership of a buffer type"
 }
 
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index 0dba5a71c50..cc66b1a2db6 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -1888,7 +1888,7 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
     },
     Lint {
         name: "rc_buffer",
-        group: "perf",
+        group: "restriction",
         desc: "shared ownership of a buffer type",
         deprecation: None,
         module: "types",
-- 
cgit 1.4.1-3-g733a5


From 5bad9175fb363917ffee2c2da7223e96daa2f5ac Mon Sep 17 00:00:00 2001
From: Bruno BELANYI <bruno@belanyi.fr>
Date: Wed, 7 Oct 2020 11:37:32 +0200
Subject: New lint: Recommend using `ptr::eq` when possible

This is based almost entirely on the code available in the previous PR #4596.
---
 clippy_lints/src/lib.rs    |  5 +++
 clippy_lints/src/ptr_eq.rs | 96 ++++++++++++++++++++++++++++++++++++++++++++++
 tests/ui/ptr_eq.fixed      | 38 ++++++++++++++++++
 tests/ui/ptr_eq.rs         | 38 ++++++++++++++++++
 tests/ui/ptr_eq.stderr     | 16 ++++++++
 5 files changed, 193 insertions(+)
 create mode 100644 clippy_lints/src/ptr_eq.rs
 create mode 100644 tests/ui/ptr_eq.fixed
 create mode 100644 tests/ui/ptr_eq.rs
 create mode 100644 tests/ui/ptr_eq.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 826a059f92a..d11eeff8032 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -281,6 +281,7 @@ mod path_buf_push_overwrite;
 mod pattern_type_mismatch;
 mod precedence;
 mod ptr;
+mod ptr_eq;
 mod ptr_offset_with_cast;
 mod question_mark;
 mod ranges;
@@ -778,6 +779,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &ptr::CMP_NULL,
         &ptr::MUT_FROM_REF,
         &ptr::PTR_ARG,
+        &ptr_eq::PTR_EQ,
         &ptr_offset_with_cast::PTR_OFFSET_WITH_CAST,
         &question_mark::QUESTION_MARK,
         &ranges::RANGE_MINUS_ONE,
@@ -916,6 +918,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     let verbose_bit_mask_threshold = conf.verbose_bit_mask_threshold;
     store.register_late_pass(move || box bit_mask::BitMask::new(verbose_bit_mask_threshold));
     store.register_late_pass(|| box ptr::Ptr);
+    store.register_late_pass(|| box ptr_eq::PtrEq);
     store.register_late_pass(|| box needless_bool::NeedlessBool);
     store.register_late_pass(|| box needless_bool::BoolComparison);
     store.register_late_pass(|| box approx_const::ApproxConstant);
@@ -1456,6 +1459,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&ptr::CMP_NULL),
         LintId::of(&ptr::MUT_FROM_REF),
         LintId::of(&ptr::PTR_ARG),
+        LintId::of(&ptr_eq::PTR_EQ),
         LintId::of(&ptr_offset_with_cast::PTR_OFFSET_WITH_CAST),
         LintId::of(&question_mark::QUESTION_MARK),
         LintId::of(&ranges::RANGE_ZIP_WITH_LEN),
@@ -1612,6 +1616,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&panic_unimplemented::PANIC_PARAMS),
         LintId::of(&ptr::CMP_NULL),
         LintId::of(&ptr::PTR_ARG),
+        LintId::of(&ptr_eq::PTR_EQ),
         LintId::of(&question_mark::QUESTION_MARK),
         LintId::of(&redundant_field_names::REDUNDANT_FIELD_NAMES),
         LintId::of(&redundant_static_lifetimes::REDUNDANT_STATIC_LIFETIMES),
diff --git a/clippy_lints/src/ptr_eq.rs b/clippy_lints/src/ptr_eq.rs
new file mode 100644
index 00000000000..a05cb6270b7
--- /dev/null
+++ b/clippy_lints/src/ptr_eq.rs
@@ -0,0 +1,96 @@
+use crate::utils;
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir::{BinOpKind, Expr, ExprKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// **What it does:** Use `std::ptr::eq` when applicable
+    ///
+    /// **Why is this bad?**`ptr::eq` can be used to compare `&T` references
+    /// (which coerce to `*const T` implicitly) by their address rather than
+    /// comparing the values they point to.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// let a = &[1, 2, 3];
+    /// let b = &[1, 2, 3];
+    ///
+    /// assert!(a as *const _ as usize == b as *const _ as usize);
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// let a = &[1, 2, 3];
+    /// let b = &[1, 2, 3];
+    ///
+    /// assert!(std::ptr::eq(a, b));
+    /// ```
+    pub PTR_EQ,
+    style,
+    "use `std::ptr::eq` when comparing raw pointers"
+}
+
+declare_lint_pass!(PtrEq => [PTR_EQ]);
+
+static LINT_MSG: &str = "use `std::ptr::eq` when comparing raw pointers";
+
+impl LateLintPass<'_> for PtrEq {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        if utils::in_macro(expr.span) {
+            return;
+        }
+
+        if let ExprKind::Binary(ref op, ref left, ref right) = expr.kind {
+            if BinOpKind::Eq == op.node {
+                let (left, right) = match (expr_as_cast_to_usize(cx, left), expr_as_cast_to_usize(cx, right)) {
+                    (Some(lhs), Some(rhs)) => (lhs, rhs),
+                    _ => (&**left, &**right),
+                };
+
+                if_chain! {
+                    if let Some(left_var) = expr_as_cast_to_raw_pointer(cx, left);
+                    if let Some(right_var) = expr_as_cast_to_raw_pointer(cx, right);
+                    if let Some(left_snip) = utils::snippet_opt(cx, left_var.span);
+                    if let Some(right_snip) = utils::snippet_opt(cx, right_var.span);
+                    then {
+                        utils::span_lint_and_sugg(
+                            cx,
+                            PTR_EQ,
+                            expr.span,
+                            LINT_MSG,
+                            "try",
+                            format!("std::ptr::eq({}, {})", left_snip, right_snip),
+                            Applicability::MachineApplicable,
+                            );
+                    }
+                }
+            }
+        }
+    }
+}
+
+// If the given expression is a cast to an usize, return the lhs of the cast
+// E.g., `foo as *const _ as usize` returns `foo as *const _`.
+fn expr_as_cast_to_usize<'tcx>(cx: &LateContext<'tcx>, cast_expr: &'tcx Expr<'_>) -> Option<&'tcx Expr<'tcx>> {
+    if cx.typeck_results().expr_ty(cast_expr) == cx.tcx.types.usize {
+        if let ExprKind::Cast(ref expr, _) = cast_expr.kind {
+            return Some(expr);
+        }
+    }
+    None
+}
+
+// If the given expression is a cast to a `*const` pointer, return the lhs of the cast
+// E.g., `foo as *const _` returns `foo`.
+fn expr_as_cast_to_raw_pointer<'tcx>(cx: &LateContext<'tcx>, cast_expr: &'tcx Expr<'_>) -> Option<&'tcx Expr<'tcx>> {
+    if cx.typeck_results().expr_ty(cast_expr).is_unsafe_ptr() {
+        if let ExprKind::Cast(ref expr, _) = cast_expr.kind {
+            return Some(expr);
+        }
+    }
+    None
+}
diff --git a/tests/ui/ptr_eq.fixed b/tests/ui/ptr_eq.fixed
new file mode 100644
index 00000000000..209081e6e80
--- /dev/null
+++ b/tests/ui/ptr_eq.fixed
@@ -0,0 +1,38 @@
+// run-rustfix
+#![warn(clippy::ptr_eq)]
+
+macro_rules! mac {
+    ($a:expr, $b:expr) => {
+        $a as *const _ as usize == $b as *const _ as usize
+    };
+}
+
+macro_rules! another_mac {
+    ($a:expr, $b:expr) => {
+        $a as *const _ == $b as *const _
+    };
+}
+
+fn main() {
+    let a = &[1, 2, 3];
+    let b = &[1, 2, 3];
+
+    let _ = std::ptr::eq(a, b);
+    let _ = std::ptr::eq(a, b);
+    let _ = a.as_ptr() == b as *const _;
+    let _ = a.as_ptr() == b.as_ptr();
+
+    // Do not lint
+
+    let _ = mac!(a, b);
+    let _ = another_mac!(a, b);
+
+    let a = &mut [1, 2, 3];
+    let b = &mut [1, 2, 3];
+
+    let _ = a.as_mut_ptr() == b as *mut [i32] as *mut _;
+    let _ = a.as_mut_ptr() == b.as_mut_ptr();
+
+    let _ = a == b;
+    let _ = core::ptr::eq(a, b);
+}
diff --git a/tests/ui/ptr_eq.rs b/tests/ui/ptr_eq.rs
new file mode 100644
index 00000000000..69162870807
--- /dev/null
+++ b/tests/ui/ptr_eq.rs
@@ -0,0 +1,38 @@
+// run-rustfix
+#![warn(clippy::ptr_eq)]
+
+macro_rules! mac {
+    ($a:expr, $b:expr) => {
+        $a as *const _ as usize == $b as *const _ as usize
+    };
+}
+
+macro_rules! another_mac {
+    ($a:expr, $b:expr) => {
+        $a as *const _ == $b as *const _
+    };
+}
+
+fn main() {
+    let a = &[1, 2, 3];
+    let b = &[1, 2, 3];
+
+    let _ = a as *const _ as usize == b as *const _ as usize;
+    let _ = a as *const _ == b as *const _;
+    let _ = a.as_ptr() == b as *const _;
+    let _ = a.as_ptr() == b.as_ptr();
+
+    // Do not lint
+
+    let _ = mac!(a, b);
+    let _ = another_mac!(a, b);
+
+    let a = &mut [1, 2, 3];
+    let b = &mut [1, 2, 3];
+
+    let _ = a.as_mut_ptr() == b as *mut [i32] as *mut _;
+    let _ = a.as_mut_ptr() == b.as_mut_ptr();
+
+    let _ = a == b;
+    let _ = core::ptr::eq(a, b);
+}
diff --git a/tests/ui/ptr_eq.stderr b/tests/ui/ptr_eq.stderr
new file mode 100644
index 00000000000..45d8c60382b
--- /dev/null
+++ b/tests/ui/ptr_eq.stderr
@@ -0,0 +1,16 @@
+error: use `std::ptr::eq` when comparing raw pointers
+  --> $DIR/ptr_eq.rs:20:13
+   |
+LL |     let _ = a as *const _ as usize == b as *const _ as usize;
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::eq(a, b)`
+   |
+   = note: `-D clippy::ptr-eq` implied by `-D warnings`
+
+error: use `std::ptr::eq` when comparing raw pointers
+  --> $DIR/ptr_eq.rs:21:13
+   |
+LL |     let _ = a as *const _ == b as *const _;
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::eq(a, b)`
+
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 6edde811b5437f926c26b1b844acd60e3dd0a0c9 Mon Sep 17 00:00:00 2001
From: Bruno BELANYI <bruno@belanyi.fr>
Date: Wed, 7 Oct 2020 17:11:11 +0200
Subject: fixup! New lint: Recommend using `ptr::eq` when possible

Co-authored-by: Takayuki Nakata <f.seasons017@gmail.com>
---
 clippy_lints/src/ptr_eq.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/ptr_eq.rs b/clippy_lints/src/ptr_eq.rs
index a05cb6270b7..3be792ce5e4 100644
--- a/clippy_lints/src/ptr_eq.rs
+++ b/clippy_lints/src/ptr_eq.rs
@@ -8,7 +8,7 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 declare_clippy_lint! {
     /// **What it does:** Use `std::ptr::eq` when applicable
     ///
-    /// **Why is this bad?**`ptr::eq` can be used to compare `&T` references
+    /// **Why is this bad?** `ptr::eq` can be used to compare `&T` references
     /// (which coerce to `*const T` implicitly) by their address rather than
     /// comparing the values they point to.
     ///
-- 
cgit 1.4.1-3-g733a5


From 11672577debb4880edb5641c470c78175b121bcb Mon Sep 17 00:00:00 2001
From: Andre Bogus <bogusandre@gmail.com>
Date: Thu, 8 Oct 2020 01:07:00 +0200
Subject: Fix unicode regexen with bytes::Regex

fixes #6005
---
 clippy_lints/src/regex.rs | 2 +-
 tests/ui/regex.rs         | 3 +++
 2 files changed, 4 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/regex.rs b/clippy_lints/src/regex.rs
index dfc158661cb..95594e38c9e 100644
--- a/clippy_lints/src/regex.rs
+++ b/clippy_lints/src/regex.rs
@@ -143,7 +143,7 @@ fn check_set<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, utf8: bool) {
 
 fn check_regex<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, utf8: bool) {
     let mut parser = regex_syntax::ParserBuilder::new()
-        .unicode(utf8)
+        .unicode(true)
         .allow_invalid_utf8(!utf8)
         .build();
 
diff --git a/tests/ui/regex.rs b/tests/ui/regex.rs
index 9767e5bf76a..f7f3b195ccc 100644
--- a/tests/ui/regex.rs
+++ b/tests/ui/regex.rs
@@ -71,6 +71,9 @@ fn trivial_regex() {
     let non_trivial_ends_with = Regex::new("foo|bar");
     let non_trivial_binary = BRegex::new("foo|bar");
     let non_trivial_binary_builder = BRegexBuilder::new("foo|bar");
+
+    // #6005: unicode classes in bytes::Regex
+    let a_byte_of_unicode = BRegex::new(r"\p{C}");
 }
 
 fn main() {
-- 
cgit 1.4.1-3-g733a5


From 738ed383066a561ae4f3ef0a6a2d570eaba7b6fa Mon Sep 17 00:00:00 2001
From: João Paulo Taylor Ienczak Zanette <jpaulotiz@gmail.com>
Date: Wed, 7 Oct 2020 21:41:54 -0300
Subject: clippy_lints: Do not warn against Box parameter in C FFI

Fixes #5542.

When using C FFI, to handle pointers in parameters it is needed to
declare them as `Box` in its Rust-side signature. However, the current
linter warns against the usage of Box stating that "local variable
doesn't need to be boxed here".

This commit fixes it by ignoring functions whose Abi is Cdecl.
---
 clippy_lints/src/escape.rs | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/escape.rs b/clippy_lints/src/escape.rs
index 82549c12d0a..ffe81b3966c 100644
--- a/clippy_lints/src/escape.rs
+++ b/clippy_lints/src/escape.rs
@@ -6,6 +6,7 @@ use rustc_middle::ty::{self, Ty};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::Span;
 use rustc_target::abi::LayoutOf;
+use rustc_target::spec::abi::Abi;
 use rustc_typeck::expr_use_visitor::{ConsumeMode, Delegate, ExprUseVisitor, PlaceBase, PlaceWithHirId};
 
 use crate::utils::span_lint;
@@ -60,12 +61,18 @@ impl<'tcx> LateLintPass<'tcx> for BoxedLocal {
     fn check_fn(
         &mut self,
         cx: &LateContext<'tcx>,
-        _: intravisit::FnKind<'tcx>,
+        fn_kind: intravisit::FnKind<'tcx>,
         _: &'tcx FnDecl<'_>,
         body: &'tcx Body<'_>,
         _: Span,
         hir_id: HirId,
     ) {
+        if let Some(header) = fn_kind.header() {
+            if header.abi == Abi::Cdecl {
+                return;
+            }
+        }
+
         // If the method is an impl for a trait, don't warn.
         let parent_id = cx.tcx.hir().get_parent_item(hir_id);
         let parent_node = cx.tcx.hir().find(parent_id);
-- 
cgit 1.4.1-3-g733a5


From 15150c07eaeec50138a9c96c5bdecbdf92c3101e Mon Sep 17 00:00:00 2001
From: João Paulo Taylor Ienczak Zanette <jpaulotiz@gmail.com>
Date: Wed, 7 Oct 2020 22:49:50 -0300
Subject: clippy_lint: Test for BoxedLocal false-positive in C-FFI and fix
 C-FFI Abi comparison.

---
 clippy_lints/src/escape.rs  | 2 +-
 tests/ui/escape_analysis.rs | 5 +++++
 2 files changed, 6 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/escape.rs b/clippy_lints/src/escape.rs
index ffe81b3966c..b222475486d 100644
--- a/clippy_lints/src/escape.rs
+++ b/clippy_lints/src/escape.rs
@@ -68,7 +68,7 @@ impl<'tcx> LateLintPass<'tcx> for BoxedLocal {
         hir_id: HirId,
     ) {
         if let Some(header) = fn_kind.header() {
-            if header.abi == Abi::Cdecl {
+            if header.abi == Abi::C {
                 return;
             }
         }
diff --git a/tests/ui/escape_analysis.rs b/tests/ui/escape_analysis.rs
index c0a52d832c0..377a0fb502f 100644
--- a/tests/ui/escape_analysis.rs
+++ b/tests/ui/escape_analysis.rs
@@ -174,3 +174,8 @@ mod issue_3739 {
         };
     }
 }
+
+/// Issue #5542
+///
+/// This shouldn't warn for `boxed_local` as it is a function implemented in C.
+pub extern "C" fn do_now_warn_me(_c_pointer: Box<String>) -> () {}
-- 
cgit 1.4.1-3-g733a5


From 3a6f59ecae90892c3162df95d9633c4263ab91fa Mon Sep 17 00:00:00 2001
From: David Tolnay <dtolnay@gmail.com>
Date: Thu, 8 Oct 2020 04:50:24 -0700
Subject: Document string_lit_as_bytes known problems

---
 clippy_lints/src/strings.rs | 22 +++++++++++++++++++++-
 1 file changed, 21 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/strings.rs b/clippy_lints/src/strings.rs
index 203af06a734..415c07b2261 100644
--- a/clippy_lints/src/strings.rs
+++ b/clippy_lints/src/strings.rs
@@ -69,7 +69,27 @@ declare_clippy_lint! {
     /// **Why is this bad?** Byte string literals (e.g., `b"foo"`) can be used
     /// instead. They are shorter but less discoverable than `as_bytes()`.
     ///
-    /// **Known Problems:** None.
+    /// **Known Problems:**
+    /// `"str".as_bytes()` and the suggested replacement of `b"str"` are not
+    /// equivalent because they have different types. The former is `&[u8]`
+    /// while the latter is `&[u8; 3]`. That means in general they will have a
+    /// different set of methods and different trait implementations.
+    ///
+    /// ```rust
+    /// fn f(v: Vec<u8>) {}
+    ///
+    /// f("...".as_bytes().to_owned()); // works
+    /// f(b"...".to_owned()); // does not work, because arg is [u8; 3] not Vec<u8>
+    ///
+    /// fn g(r: impl std::io::Read) {}
+    ///
+    /// g("...".as_bytes()); // works
+    /// g(b"..."); // does not work
+    /// ```
+    ///
+    /// The actual equivalent of `"str".as_bytes()` with the same type is not
+    /// `b"str"` but `&b"str"[..]`, which is a great deal of punctuation and not
+    /// more readable than a function call.
     ///
     /// **Example:**
     /// ```rust
-- 
cgit 1.4.1-3-g733a5


From c81bea45f480d9d5a785778c944a3ad3daf30d27 Mon Sep 17 00:00:00 2001
From: David Tolnay <dtolnay@gmail.com>
Date: Thu, 8 Oct 2020 04:54:17 -0700
Subject: Make clippy_lints's doc tests succeed

---
 clippy_lints/src/strings.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/strings.rs b/clippy_lints/src/strings.rs
index 415c07b2261..3783bd78de2 100644
--- a/clippy_lints/src/strings.rs
+++ b/clippy_lints/src/strings.rs
@@ -75,7 +75,7 @@ declare_clippy_lint! {
     /// while the latter is `&[u8; 3]`. That means in general they will have a
     /// different set of methods and different trait implementations.
     ///
-    /// ```rust
+    /// ```compile_fail
     /// fn f(v: Vec<u8>) {}
     ///
     /// f("...".as_bytes().to_owned()); // works
-- 
cgit 1.4.1-3-g733a5


From cc26924cce6d6e6ee7913ba5026d205eefd42702 Mon Sep 17 00:00:00 2001
From: João Paulo Taylor Ienczak Zanette <jpaulotiz@gmail.com>
Date: Thu, 8 Oct 2020 09:03:11 -0300
Subject: clippy_lint: Extend BoxedLocal ignored ABI to all non-rust ABIs.

---
 clippy_lints/src/escape.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/escape.rs b/clippy_lints/src/escape.rs
index b222475486d..8b022912573 100644
--- a/clippy_lints/src/escape.rs
+++ b/clippy_lints/src/escape.rs
@@ -68,7 +68,7 @@ impl<'tcx> LateLintPass<'tcx> for BoxedLocal {
         hir_id: HirId,
     ) {
         if let Some(header) = fn_kind.header() {
-            if header.abi == Abi::C {
+            if header.abi != Abi::Rust {
                 return;
             }
         }
-- 
cgit 1.4.1-3-g733a5


From 732d370404198ca68a96901b25a5f2ab3ba9d562 Mon Sep 17 00:00:00 2001
From: Jean SIMARD <woshilapin@tuziwo.info>
Date: Fri, 9 Oct 2020 09:47:53 +0200
Subject: clippy_lint: Fix doc on 'option_if_let_else'

- a typo in `expresion`
- a useless double space
- Some back-tick quotes for 'if let'
---
 clippy_lints/src/option_if_let_else.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/option_if_let_else.rs b/clippy_lints/src/option_if_let_else.rs
index 4a3eb9c983a..383a62da821 100644
--- a/clippy_lints/src/option_if_let_else.rs
+++ b/clippy_lints/src/option_if_let_else.rs
@@ -13,14 +13,14 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
     /// **What it does:**
-    /// Lints usage of  `if let Some(v) = ... { y } else { x }` which is more
+    /// Lints usage of `if let Some(v) = ... { y } else { x }` which is more
     /// idiomatically done with `Option::map_or` (if the else bit is a pure
     /// expression) or `Option::map_or_else` (if the else bit is an impure
-    /// expresion).
+    /// expression).
     ///
     /// **Why is this bad?**
     /// Using the dedicated functions of the Option type is clearer and
-    /// more concise than an if let expression.
+    /// more concise than an `if let` expression.
     ///
     /// **Known problems:**
     /// This lint uses a deliberately conservative metric for checking
-- 
cgit 1.4.1-3-g733a5


From 7b7ddfa55da889b41e90243ac59a04eed832a71e Mon Sep 17 00:00:00 2001
From: Sebastian Andersson <sebastian@bittr.nu>
Date: Fri, 9 Oct 2020 20:23:03 +0200
Subject: Preserve raw strs for: format!(s) to s.to_string() lint

Ie:
|     let s = format!(r#""hello""#);
|             ^^^^^^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `r#""hello""#.to_string()`
---
 clippy_lints/src/format.rs | 8 ++++++--
 tests/ui/format.fixed      | 3 ++-
 tests/ui/format.stderr     | 8 +++++++-
 3 files changed, 15 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/format.rs b/clippy_lints/src/format.rs
index d6541010bca..26da058598e 100644
--- a/clippy_lints/src/format.rs
+++ b/clippy_lints/src/format.rs
@@ -1,6 +1,6 @@
 use crate::utils::paths;
 use crate::utils::{
-    is_expn_of, is_type_diagnostic_item, last_path_segment, match_def_path, match_function_call, snippet,
+    is_expn_of, is_type_diagnostic_item, last_path_segment, match_def_path, match_function_call, snippet, snippet_opt,
     span_lint_and_then,
 };
 use if_chain::if_chain;
@@ -132,7 +132,11 @@ fn on_new_v1<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<Strin
         then {
             // `format!("foo")` expansion contains `match () { () => [], }`
             if tup.is_empty() {
-                return Some(format!("{:?}.to_string()", s.as_str()));
+                if let Some(s_src) = snippet_opt(cx, lit.span) {
+                    // Simulate macro expansion, converting {{ and }} to { and }.
+                    let s_expand = s_src.replace("{{", "{").replace("}}", "}");
+                    return Some(format!("{}.to_string()", s_expand))
+                }
             } else if s.as_str().is_empty() {
                 return on_argumentv1_new(cx, &tup[0], arms);
             }
diff --git a/tests/ui/format.fixed b/tests/ui/format.fixed
index 30651476999..740a22a07d7 100644
--- a/tests/ui/format.fixed
+++ b/tests/ui/format.fixed
@@ -13,7 +13,8 @@ fn main() {
     "foo".to_string();
     "{}".to_string();
     "{} abc {}".to_string();
-    "foo {}\n\" bar".to_string();
+    r##"foo {}
+" bar"##.to_string();
 
     "foo".to_string();
     format!("{:?}", "foo"); // Don't warn about `Debug`.
diff --git a/tests/ui/format.stderr b/tests/ui/format.stderr
index 9734492154e..96df7f37f77 100644
--- a/tests/ui/format.stderr
+++ b/tests/ui/format.stderr
@@ -25,7 +25,13 @@ LL | /     format!(
 LL | |         r##"foo {{}}
 LL | | " bar"##
 LL | |     );
-   | |______^ help: consider using `.to_string()`: `"foo {}/n/" bar".to_string();`
+   | |______^
+   |
+help: consider using `.to_string()`
+   |
+LL |     r##"foo {}
+LL | " bar"##.to_string();
+   |
 
 error: useless use of `format!`
   --> $DIR/format.rs:21:5
-- 
cgit 1.4.1-3-g733a5


From 26e4de9557e5924d001652138ec0f8f40dc40372 Mon Sep 17 00:00:00 2001
From: Andre Bogus <bogusandre@gmail.com>
Date: Fri, 9 Oct 2020 00:49:27 +0200
Subject: allow refs in our constant handling

---
 clippy_lints/src/consts.rs | 10 +++++++++-
 tests/ui/float_cmp.rs      |  5 +++++
 tests/ui/float_cmp.stderr  | 12 ++++++------
 3 files changed, 20 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/consts.rs b/clippy_lints/src/consts.rs
index 062c9bd2d9e..c5e33b288a9 100644
--- a/clippy_lints/src/consts.rs
+++ b/clippy_lints/src/consts.rs
@@ -40,6 +40,8 @@ pub enum Constant {
     Tuple(Vec<Constant>),
     /// A raw pointer.
     RawPtr(u128),
+    /// A reference
+    Ref(Box<Constant>),
     /// A literal with syntax error.
     Err(Symbol),
 }
@@ -66,6 +68,7 @@ impl PartialEq for Constant {
             (&Self::Bool(l), &Self::Bool(r)) => l == r,
             (&Self::Vec(ref l), &Self::Vec(ref r)) | (&Self::Tuple(ref l), &Self::Tuple(ref r)) => l == r,
             (&Self::Repeat(ref lv, ref ls), &Self::Repeat(ref rv, ref rs)) => ls == rs && lv == rv,
+            (&Self::Ref(ref lb), &Self::Ref(ref rb)) => *lb == *rb,
             // TODO: are there inter-type equalities?
             _ => false,
         }
@@ -110,6 +113,9 @@ impl Hash for Constant {
             Self::RawPtr(u) => {
                 u.hash(state);
             },
+            Self::Ref(ref r) => {
+                r.hash(state);
+            },
             Self::Err(ref s) => {
                 s.hash(state);
             },
@@ -144,6 +150,7 @@ impl Constant {
                     x => x,
                 }
             },
+            (&Self::Ref(ref lb), &Self::Ref(ref rb)) => Self::partial_cmp(tcx, cmp_type, lb, rb),
             // TODO: are there any useful inter-type orderings?
             _ => None,
         }
@@ -239,7 +246,7 @@ impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
             ExprKind::Unary(op, ref operand) => self.expr(operand).and_then(|o| match op {
                 UnOp::UnNot => self.constant_not(&o, self.typeck_results.expr_ty(e)),
                 UnOp::UnNeg => self.constant_negate(&o, self.typeck_results.expr_ty(e)),
-                UnOp::UnDeref => Some(o),
+                UnOp::UnDeref => Some(if let Constant::Ref(r) = o { *r } else { o }),
             }),
             ExprKind::Binary(op, ref left, ref right) => self.binop(op, left, right),
             ExprKind::Call(ref callee, ref args) => {
@@ -269,6 +276,7 @@ impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
                 }
             },
             ExprKind::Index(ref arr, ref index) => self.index(arr, index),
+            ExprKind::AddrOf(_, _, ref inner) => self.expr(inner).map(|r| Constant::Ref(Box::new(r))),
             // TODO: add other expressions.
             _ => None,
         }
diff --git a/tests/ui/float_cmp.rs b/tests/ui/float_cmp.rs
index 9fa0e5f5c07..586784b73e6 100644
--- a/tests/ui/float_cmp.rs
+++ b/tests/ui/float_cmp.rs
@@ -2,6 +2,7 @@
 #![allow(
     unused,
     clippy::no_effect,
+    clippy::op_ref,
     clippy::unnecessary_operation,
     clippy::cast_lossless,
     clippy::many_single_char_names
@@ -116,4 +117,8 @@ fn main() {
     1.23f64.signum() != x64.signum();
     1.23f64.signum() != -(x64.signum());
     1.23f64.signum() != 3.21f64.signum();
+
+    // the comparison should also look through references
+    &0.0 == &ZERO;
+    &&&&0.0 == &&&&ZERO;
 }
diff --git a/tests/ui/float_cmp.stderr b/tests/ui/float_cmp.stderr
index f7c380fc915..bb4051c4662 100644
--- a/tests/ui/float_cmp.stderr
+++ b/tests/ui/float_cmp.stderr
@@ -1,5 +1,5 @@
 error: strict comparison of `f32` or `f64`
-  --> $DIR/float_cmp.rs:65:5
+  --> $DIR/float_cmp.rs:66:5
    |
 LL |     ONE as f64 != 2.0;
    |     ^^^^^^^^^^^^^^^^^ help: consider comparing them within some margin of error: `(ONE as f64 - 2.0).abs() > error_margin`
@@ -8,7 +8,7 @@ LL |     ONE as f64 != 2.0;
    = note: `f32::EPSILON` and `f64::EPSILON` are available for the `error_margin`
 
 error: strict comparison of `f32` or `f64`
-  --> $DIR/float_cmp.rs:70:5
+  --> $DIR/float_cmp.rs:71:5
    |
 LL |     x == 1.0;
    |     ^^^^^^^^ help: consider comparing them within some margin of error: `(x - 1.0).abs() < error_margin`
@@ -16,7 +16,7 @@ LL |     x == 1.0;
    = note: `f32::EPSILON` and `f64::EPSILON` are available for the `error_margin`
 
 error: strict comparison of `f32` or `f64`
-  --> $DIR/float_cmp.rs:73:5
+  --> $DIR/float_cmp.rs:74:5
    |
 LL |     twice(x) != twice(ONE as f64);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider comparing them within some margin of error: `(twice(x) - twice(ONE as f64)).abs() > error_margin`
@@ -24,7 +24,7 @@ LL |     twice(x) != twice(ONE as f64);
    = note: `f32::EPSILON` and `f64::EPSILON` are available for the `error_margin`
 
 error: strict comparison of `f32` or `f64`
-  --> $DIR/float_cmp.rs:93:5
+  --> $DIR/float_cmp.rs:94:5
    |
 LL |     NON_ZERO_ARRAY[i] == NON_ZERO_ARRAY[j];
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider comparing them within some margin of error: `(NON_ZERO_ARRAY[i] - NON_ZERO_ARRAY[j]).abs() < error_margin`
@@ -32,7 +32,7 @@ LL |     NON_ZERO_ARRAY[i] == NON_ZERO_ARRAY[j];
    = note: `f32::EPSILON` and `f64::EPSILON` are available for the `error_margin`
 
 error: strict comparison of `f32` or `f64` arrays
-  --> $DIR/float_cmp.rs:98:5
+  --> $DIR/float_cmp.rs:99:5
    |
 LL |     a1 == a2;
    |     ^^^^^^^^
@@ -40,7 +40,7 @@ LL |     a1 == a2;
    = note: `f32::EPSILON` and `f64::EPSILON` are available for the `error_margin`
 
 error: strict comparison of `f32` or `f64`
-  --> $DIR/float_cmp.rs:99:5
+  --> $DIR/float_cmp.rs:100:5
    |
 LL |     a1[0] == a2[0];
    |     ^^^^^^^^^^^^^^ help: consider comparing them within some margin of error: `(a1[0] - a2[0]).abs() < error_margin`
-- 
cgit 1.4.1-3-g733a5


From a98f9d21fcdad85ae95d00d3931cf438f9d5a9de Mon Sep 17 00:00:00 2001
From: flip1995 <hello@philkrones.com>
Date: Fri, 9 Oct 2020 22:22:21 +0200
Subject: (Hacky) Fix for ICE #6139

---
 clippy_lints/src/types.rs | 5 +++++
 1 file changed, 5 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs
index 5e83b6c81ec..a982b92bb2b 100644
--- a/clippy_lints/src/types.rs
+++ b/clippy_lints/src/types.rs
@@ -541,6 +541,11 @@ impl Types {
                                 _ => None,
                             });
                             let ty_ty = hir_ty_to_ty(cx.tcx, boxed_ty);
+                            // HACK(flip1995): This is a fix for an ICE occuring when `ty_ty` is a
+                            // trait object with a lifetime, e.g. `dyn T<'_>`. Since trait objects
+                            // don't have a known size, this shouldn't introduce FNs. But there
+                            // should be a better solution.
+                            if !matches!(ty_ty.kind(), ty::Dynamic(..));
                             if ty_ty.is_sized(cx.tcx.at(ty.span), cx.param_env);
                             if let Ok(ty_ty_size) = cx.layout_of(ty_ty).map(|l| l.size.bytes());
                             if ty_ty_size <= self.vec_box_size_threshold;
-- 
cgit 1.4.1-3-g733a5


From cf81975d7765bf0cf82fee9f3e991c880f77cd13 Mon Sep 17 00:00:00 2001
From: flip1995 <hello@philkrones.com>
Date: Sat, 10 Oct 2020 14:04:14 +0200
Subject: Fix two ICEs caused by ty.is_{sized,freeze}

---
 clippy_lints/src/mut_key.rs | 7 ++++++-
 clippy_lints/src/types.rs   | 7 ++-----
 2 files changed, 8 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/mut_key.rs b/clippy_lints/src/mut_key.rs
index 8a2dbdc50ea..4525b12689f 100644
--- a/clippy_lints/src/mut_key.rs
+++ b/clippy_lints/src/mut_key.rs
@@ -1,6 +1,7 @@
 use crate::utils::{match_def_path, paths, span_lint, trait_ref_of_method};
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::TypeFoldable;
 use rustc_middle::ty::{Adt, Array, RawPtr, Ref, Slice, Tuple, Ty, TypeAndMut};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
@@ -120,7 +121,11 @@ fn is_mutable_type<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>, span: Span) -> bo
             size.try_eval_usize(cx.tcx, cx.param_env).map_or(true, |u| u != 0) && is_mutable_type(cx, inner_ty, span)
         },
         Tuple(..) => ty.tuple_fields().any(|ty| is_mutable_type(cx, ty, span)),
-        Adt(..) => cx.tcx.layout_of(cx.param_env.and(ty)).is_ok() && !ty.is_freeze(cx.tcx.at(span), cx.param_env),
+        Adt(..) => {
+            cx.tcx.layout_of(cx.param_env.and(ty)).is_ok()
+                && !ty.has_escaping_bound_vars()
+                && !ty.is_freeze(cx.tcx.at(span), cx.param_env)
+        },
         _ => false,
     }
 }
diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs
index a982b92bb2b..9a948af8bfc 100644
--- a/clippy_lints/src/types.rs
+++ b/clippy_lints/src/types.rs
@@ -17,6 +17,7 @@ use rustc_hir::{
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::hir::map::Map;
 use rustc_middle::lint::in_external_macro;
+use rustc_middle::ty::TypeFoldable;
 use rustc_middle::ty::{self, InferTy, Ty, TyCtxt, TyS, TypeckResults};
 use rustc_session::{declare_lint_pass, declare_tool_lint, impl_lint_pass};
 use rustc_span::hygiene::{ExpnKind, MacroKind};
@@ -541,11 +542,7 @@ impl Types {
                                 _ => None,
                             });
                             let ty_ty = hir_ty_to_ty(cx.tcx, boxed_ty);
-                            // HACK(flip1995): This is a fix for an ICE occuring when `ty_ty` is a
-                            // trait object with a lifetime, e.g. `dyn T<'_>`. Since trait objects
-                            // don't have a known size, this shouldn't introduce FNs. But there
-                            // should be a better solution.
-                            if !matches!(ty_ty.kind(), ty::Dynamic(..));
+                            if !ty_ty.has_escaping_bound_vars();
                             if ty_ty.is_sized(cx.tcx.at(ty.span), cx.param_env);
                             if let Ok(ty_ty_size) = cx.layout_of(ty_ty).map(|l| l.size.bytes());
                             if ty_ty_size <= self.vec_box_size_threshold;
-- 
cgit 1.4.1-3-g733a5


From 6021c231599eabcb07b3a8207bddbb3796c93eee Mon Sep 17 00:00:00 2001
From: Andre Bogus <bogusandre@gmail.com>
Date: Sun, 11 Oct 2020 13:27:20 +0200
Subject: New lint: result-unit-err

---
 CHANGELOG.md                      |   1 +
 clippy_lints/src/functions.rs     | 106 +++++++++++++++++++++++++++++++++-----
 clippy_lints/src/lib.rs           |   3 ++
 src/lintlist/mod.rs               |   7 +++
 tests/ui/doc_errors.rs            |   1 +
 tests/ui/doc_errors.stderr        |  14 ++---
 tests/ui/double_must_use.rs       |   1 +
 tests/ui/double_must_use.stderr   |   6 +--
 tests/ui/result_unit_error.rs     |  38 ++++++++++++++
 tests/ui/result_unit_error.stderr |  35 +++++++++++++
 10 files changed, 189 insertions(+), 23 deletions(-)
 create mode 100644 tests/ui/result_unit_error.rs
 create mode 100644 tests/ui/result_unit_error.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 6fb6cf75d96..f21768c4498 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1918,6 +1918,7 @@ Released 2018-09-13
 [`rest_pat_in_fully_bound_structs`]: https://rust-lang.github.io/rust-clippy/master/index.html#rest_pat_in_fully_bound_structs
 [`result_map_or_into_option`]: https://rust-lang.github.io/rust-clippy/master/index.html#result_map_or_into_option
 [`result_map_unit_fn`]: https://rust-lang.github.io/rust-clippy/master/index.html#result_map_unit_fn
+[`result_unit_err`]: https://rust-lang.github.io/rust-clippy/master/index.html#result_unit_err
 [`reversed_empty_ranges`]: https://rust-lang.github.io/rust-clippy/master/index.html#reversed_empty_ranges
 [`same_functions_in_if_condition`]: https://rust-lang.github.io/rust-clippy/master/index.html#same_functions_in_if_condition
 [`same_item_push`]: https://rust-lang.github.io/rust-clippy/master/index.html#same_item_push
diff --git a/clippy_lints/src/functions.rs b/clippy_lints/src/functions.rs
index 50b39cf4ea7..212a3100637 100644
--- a/clippy_lints/src/functions.rs
+++ b/clippy_lints/src/functions.rs
@@ -1,8 +1,9 @@
 use crate::utils::{
-    attr_by_name, attrs::is_proc_macro, is_must_use_ty, is_trait_impl_item, iter_input_pats, match_def_path,
-    must_use_attr, qpath_res, return_ty, snippet, snippet_opt, span_lint, span_lint_and_help, span_lint_and_then,
-    trait_ref_of_method, type_is_unsafe_function,
+    attr_by_name, attrs::is_proc_macro, is_must_use_ty, is_trait_impl_item, is_type_diagnostic_item, iter_input_pats,
+    last_path_segment, match_def_path, must_use_attr, qpath_res, return_ty, snippet, snippet_opt, span_lint,
+    span_lint_and_help, span_lint_and_then, trait_ref_of_method, type_is_unsafe_function,
 };
+use if_chain::if_chain;
 use rustc_ast::ast::Attribute;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Applicability;
@@ -16,6 +17,7 @@ use rustc_middle::ty::{self, Ty};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::Span;
 use rustc_target::spec::abi::Abi;
+use rustc_typeck::hir_ty_to_ty;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for functions with too many parameters.
@@ -169,6 +171,52 @@ declare_clippy_lint! {
     "function or method that could take a `#[must_use]` attribute"
 }
 
+declare_clippy_lint! {
+    /// **What it does:** Checks for public functions that return a `Result`
+    /// with an `Err` type of `()`. It suggests using a custom type that
+    /// implements [`std::error::Error`].
+    ///
+    /// **Why is this bad?** Unit does not implement `Error` and carries no
+    /// further information about what went wrong.
+    ///
+    /// **Known problems:** Of course, this lint assumes that `Result` is used
+    /// for a fallible operation (which is after all the intended use). However
+    /// code may opt to (mis)use it as a basic two-variant-enum. In that case,
+    /// the suggestion is misguided, and the code should use a custom enum
+    /// instead.
+    ///
+    /// **Examples:**
+    /// ```rust
+    /// pub fn read_u8() -> Result<u8, ()> { Err(()) }
+    /// ```
+    /// should become
+    /// ```rust,should_panic
+    /// use std::fmt;
+    ///
+    /// #[derive(Debug)]
+    /// struct EndOfStream;
+    ///
+    /// impl fmt::Display for EndOfStream {
+    /// 	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    ///			write!(f, "End of Stream")
+    /// 	}
+    /// }
+    ///
+    /// impl std::error::Error for EndOfStream { }
+    ///
+    /// pub fn read_u8() -> Result<u8, EndOfStream> { Err(EndOfStream) }
+    ///# fn main() {
+    ///# 	read_u8().unwrap();
+    ///# }
+    /// ```
+    ///
+    /// Note that there are crates that simplify creating the error type, e.g.
+    /// [`thiserror`](https://docs.rs/thiserror).
+    pub RESULT_UNIT_ERR,
+    style,
+    "public function returning `Result` with an `Err` type of `()`"
+}
+
 #[derive(Copy, Clone)]
 pub struct Functions {
     threshold: u64,
@@ -188,6 +236,7 @@ impl_lint_pass!(Functions => [
     MUST_USE_UNIT,
     DOUBLE_MUST_USE,
     MUST_USE_CANDIDATE,
+    RESULT_UNIT_ERR,
 ]);
 
 impl<'tcx> LateLintPass<'tcx> for Functions {
@@ -233,15 +282,16 @@ impl<'tcx> LateLintPass<'tcx> for Functions {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) {
         let attr = must_use_attr(&item.attrs);
         if let hir::ItemKind::Fn(ref sig, ref _generics, ref body_id) = item.kind {
+            let is_public = cx.access_levels.is_exported(item.hir_id);
+            let fn_header_span = item.span.with_hi(sig.decl.output.span().hi());
+            if is_public {
+                check_result_unit_err(cx, &sig.decl, item.span, fn_header_span);
+            }
             if let Some(attr) = attr {
-                let fn_header_span = item.span.with_hi(sig.decl.output.span().hi());
                 check_needless_must_use(cx, &sig.decl, item.hir_id, item.span, fn_header_span, attr);
                 return;
             }
-            if cx.access_levels.is_exported(item.hir_id)
-                && !is_proc_macro(cx.sess(), &item.attrs)
-                && attr_by_name(&item.attrs, "no_mangle").is_none()
-            {
+            if is_public && !is_proc_macro(cx.sess(), &item.attrs) && attr_by_name(&item.attrs, "no_mangle").is_none() {
                 check_must_use_candidate(
                     cx,
                     &sig.decl,
@@ -257,11 +307,15 @@ impl<'tcx> LateLintPass<'tcx> for Functions {
 
     fn check_impl_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::ImplItem<'_>) {
         if let hir::ImplItemKind::Fn(ref sig, ref body_id) = item.kind {
+            let is_public = cx.access_levels.is_exported(item.hir_id);
+            let fn_header_span = item.span.with_hi(sig.decl.output.span().hi());
+            if is_public && trait_ref_of_method(cx, item.hir_id).is_none() {
+                check_result_unit_err(cx, &sig.decl, item.span, fn_header_span);
+            }
             let attr = must_use_attr(&item.attrs);
             if let Some(attr) = attr {
-                let fn_header_span = item.span.with_hi(sig.decl.output.span().hi());
                 check_needless_must_use(cx, &sig.decl, item.hir_id, item.span, fn_header_span, attr);
-            } else if cx.access_levels.is_exported(item.hir_id)
+            } else if is_public
                 && !is_proc_macro(cx.sess(), &item.attrs)
                 && trait_ref_of_method(cx, item.hir_id).is_none()
             {
@@ -284,18 +338,21 @@ impl<'tcx> LateLintPass<'tcx> for Functions {
             if sig.header.abi == Abi::Rust {
                 self.check_arg_number(cx, &sig.decl, item.span.with_hi(sig.decl.output.span().hi()));
             }
+            let is_public = cx.access_levels.is_exported(item.hir_id);
+            let fn_header_span = item.span.with_hi(sig.decl.output.span().hi());
+            if is_public {
+                check_result_unit_err(cx, &sig.decl, item.span, fn_header_span);
+            }
 
             let attr = must_use_attr(&item.attrs);
             if let Some(attr) = attr {
-                let fn_header_span = item.span.with_hi(sig.decl.output.span().hi());
                 check_needless_must_use(cx, &sig.decl, item.hir_id, item.span, fn_header_span, attr);
             }
             if let hir::TraitFn::Provided(eid) = *eid {
                 let body = cx.tcx.hir().body(eid);
                 Self::check_raw_ptr(cx, sig.header.unsafety, &sig.decl, body, item.hir_id);
 
-                if attr.is_none() && cx.access_levels.is_exported(item.hir_id) && !is_proc_macro(cx.sess(), &item.attrs)
-                {
+                if attr.is_none() && is_public && !is_proc_macro(cx.sess(), &item.attrs) {
                     check_must_use_candidate(
                         cx,
                         &sig.decl,
@@ -411,6 +468,29 @@ impl<'tcx> Functions {
     }
 }
 
+fn check_result_unit_err(cx: &LateContext<'_>, decl: &hir::FnDecl<'_>, item_span: Span, fn_header_span: Span) {
+    if_chain! {
+        if !in_external_macro(cx.sess(), item_span);
+        if let hir::FnRetTy::Return(ref ty) = decl.output;
+        if let hir::TyKind::Path(ref qpath) = ty.kind;
+        if is_type_diagnostic_item(cx, hir_ty_to_ty(cx.tcx, ty), sym!(result_type));
+        if let Some(ref args) = last_path_segment(qpath).args;
+        if let [_, hir::GenericArg::Type(ref err_ty)] = args.args;
+        if let hir::TyKind::Tup(t) = err_ty.kind;
+        if t.is_empty();
+        then {
+            span_lint_and_help(
+                cx,
+                RESULT_UNIT_ERR,
+                fn_header_span,
+                "This returns a `Result<_, ()>",
+                None,
+                "Use a custom Error type instead",
+            );
+        }
+    }
+}
+
 fn check_needless_must_use(
     cx: &LateContext<'_>,
     decl: &hir::FnDecl<'_>,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 097eca0af57..26a727687b1 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -582,6 +582,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &functions::MUST_USE_CANDIDATE,
         &functions::MUST_USE_UNIT,
         &functions::NOT_UNSAFE_PTR_ARG_DEREF,
+        &functions::RESULT_UNIT_ERR,
         &functions::TOO_MANY_ARGUMENTS,
         &functions::TOO_MANY_LINES,
         &future_not_send::FUTURE_NOT_SEND,
@@ -1327,6 +1328,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&functions::DOUBLE_MUST_USE),
         LintId::of(&functions::MUST_USE_UNIT),
         LintId::of(&functions::NOT_UNSAFE_PTR_ARG_DEREF),
+        LintId::of(&functions::RESULT_UNIT_ERR),
         LintId::of(&functions::TOO_MANY_ARGUMENTS),
         LintId::of(&get_last_with_len::GET_LAST_WITH_LEN),
         LintId::of(&identity_op::IDENTITY_OP),
@@ -1558,6 +1560,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&formatting::SUSPICIOUS_UNARY_OP_FORMATTING),
         LintId::of(&functions::DOUBLE_MUST_USE),
         LintId::of(&functions::MUST_USE_UNIT),
+        LintId::of(&functions::RESULT_UNIT_ERR),
         LintId::of(&if_let_some_result::IF_LET_SOME_RESULT),
         LintId::of(&inherent_to_string::INHERENT_TO_STRING),
         LintId::of(&len_zero::LEN_WITHOUT_IS_EMPTY),
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index 96c9d12d75f..d0fc8f0c8a9 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -2005,6 +2005,13 @@ pub static ref ALL_LINTS: Vec<Lint> = vec![
         deprecation: None,
         module: "map_unit_fn",
     },
+    Lint {
+        name: "result_unit_err",
+        group: "style",
+        desc: "public function returning `Result` with an `Err` type of `()`",
+        deprecation: None,
+        module: "functions",
+    },
     Lint {
         name: "reversed_empty_ranges",
         group: "correctness",
diff --git a/tests/ui/doc_errors.rs b/tests/ui/doc_errors.rs
index 445fc8d31d7..f47b81a450e 100644
--- a/tests/ui/doc_errors.rs
+++ b/tests/ui/doc_errors.rs
@@ -1,5 +1,6 @@
 // edition:2018
 #![warn(clippy::missing_errors_doc)]
+#![allow(clippy::result_unit_err)]
 
 use std::io;
 
diff --git a/tests/ui/doc_errors.stderr b/tests/ui/doc_errors.stderr
index f44d6693d30..c7b616e2897 100644
--- a/tests/ui/doc_errors.stderr
+++ b/tests/ui/doc_errors.stderr
@@ -1,5 +1,5 @@
 error: docs for function returning `Result` missing `# Errors` section
-  --> $DIR/doc_errors.rs:6:1
+  --> $DIR/doc_errors.rs:7:1
    |
 LL | / pub fn pub_fn_missing_errors_header() -> Result<(), ()> {
 LL | |     unimplemented!();
@@ -9,7 +9,7 @@ LL | | }
    = note: `-D clippy::missing-errors-doc` implied by `-D warnings`
 
 error: docs for function returning `Result` missing `# Errors` section
-  --> $DIR/doc_errors.rs:10:1
+  --> $DIR/doc_errors.rs:11:1
    |
 LL | / pub async fn async_pub_fn_missing_errors_header() -> Result<(), ()> {
 LL | |     unimplemented!();
@@ -17,7 +17,7 @@ LL | | }
    | |_^
 
 error: docs for function returning `Result` missing `# Errors` section
-  --> $DIR/doc_errors.rs:15:1
+  --> $DIR/doc_errors.rs:16:1
    |
 LL | / pub fn pub_fn_returning_io_result() -> io::Result<()> {
 LL | |     unimplemented!();
@@ -25,7 +25,7 @@ LL | | }
    | |_^
 
 error: docs for function returning `Result` missing `# Errors` section
-  --> $DIR/doc_errors.rs:20:1
+  --> $DIR/doc_errors.rs:21:1
    |
 LL | / pub async fn async_pub_fn_returning_io_result() -> io::Result<()> {
 LL | |     unimplemented!();
@@ -33,7 +33,7 @@ LL | | }
    | |_^
 
 error: docs for function returning `Result` missing `# Errors` section
-  --> $DIR/doc_errors.rs:50:5
+  --> $DIR/doc_errors.rs:51:5
    |
 LL | /     pub fn pub_method_missing_errors_header() -> Result<(), ()> {
 LL | |         unimplemented!();
@@ -41,7 +41,7 @@ LL | |     }
    | |_____^
 
 error: docs for function returning `Result` missing `# Errors` section
-  --> $DIR/doc_errors.rs:55:5
+  --> $DIR/doc_errors.rs:56:5
    |
 LL | /     pub async fn async_pub_method_missing_errors_header() -> Result<(), ()> {
 LL | |         unimplemented!();
@@ -49,7 +49,7 @@ LL | |     }
    | |_____^
 
 error: docs for function returning `Result` missing `# Errors` section
-  --> $DIR/doc_errors.rs:84:5
+  --> $DIR/doc_errors.rs:85:5
    |
 LL |     fn trait_method_missing_errors_header() -> Result<(), ()>;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/double_must_use.rs b/tests/ui/double_must_use.rs
index a48e675e4ea..05e087b08bc 100644
--- a/tests/ui/double_must_use.rs
+++ b/tests/ui/double_must_use.rs
@@ -1,4 +1,5 @@
 #![warn(clippy::double_must_use)]
+#![allow(clippy::result_unit_err)]
 
 #[must_use]
 pub fn must_use_result() -> Result<(), ()> {
diff --git a/tests/ui/double_must_use.stderr b/tests/ui/double_must_use.stderr
index bc37785294f..8290ece1cad 100644
--- a/tests/ui/double_must_use.stderr
+++ b/tests/ui/double_must_use.stderr
@@ -1,5 +1,5 @@
 error: this function has an empty `#[must_use]` attribute, but returns a type already marked as `#[must_use]`
-  --> $DIR/double_must_use.rs:4:1
+  --> $DIR/double_must_use.rs:5:1
    |
 LL | pub fn must_use_result() -> Result<(), ()> {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -8,7 +8,7 @@ LL | pub fn must_use_result() -> Result<(), ()> {
    = help: either add some descriptive text or remove the attribute
 
 error: this function has an empty `#[must_use]` attribute, but returns a type already marked as `#[must_use]`
-  --> $DIR/double_must_use.rs:9:1
+  --> $DIR/double_must_use.rs:10:1
    |
 LL | pub fn must_use_tuple() -> (Result<(), ()>, u8) {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -16,7 +16,7 @@ LL | pub fn must_use_tuple() -> (Result<(), ()>, u8) {
    = help: either add some descriptive text or remove the attribute
 
 error: this function has an empty `#[must_use]` attribute, but returns a type already marked as `#[must_use]`
-  --> $DIR/double_must_use.rs:14:1
+  --> $DIR/double_must_use.rs:15:1
    |
 LL | pub fn must_use_array() -> [Result<(), ()>; 1] {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/result_unit_error.rs b/tests/ui/result_unit_error.rs
new file mode 100644
index 00000000000..a66f581b215
--- /dev/null
+++ b/tests/ui/result_unit_error.rs
@@ -0,0 +1,38 @@
+#[warn(clippy::result_unit_err)]
+#[allow(unused)]
+
+pub fn returns_unit_error() -> Result<u32, ()> {
+    Err(())
+}
+
+fn private_unit_errors() -> Result<String, ()> {
+    Err(())
+}
+
+pub trait HasUnitError {
+    fn get_that_error(&self) -> Result<bool, ()>;
+
+    fn get_this_one_too(&self) -> Result<bool, ()> {
+        Err(())
+    }
+}
+
+impl HasUnitError for () {
+    fn get_that_error(&self) -> Result<bool, ()> {
+        Ok(true)
+    }
+}
+
+trait PrivateUnitError {
+    fn no_problem(&self) -> Result<usize, ()>;
+}
+
+pub struct UnitErrorHolder;
+
+impl UnitErrorHolder {
+    pub fn unit_error(&self) -> Result<usize, ()> {
+        Ok(0)
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/result_unit_error.stderr b/tests/ui/result_unit_error.stderr
new file mode 100644
index 00000000000..986d9718acd
--- /dev/null
+++ b/tests/ui/result_unit_error.stderr
@@ -0,0 +1,35 @@
+error: This returns a `Result<_, ()>
+  --> $DIR/result_unit_error.rs:4:1
+   |
+LL | pub fn returns_unit_error() -> Result<u32, ()> {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::result-unit-err` implied by `-D warnings`
+   = help: Use a custom Error type instead
+
+error: This returns a `Result<_, ()>
+  --> $DIR/result_unit_error.rs:13:5
+   |
+LL |     fn get_that_error(&self) -> Result<bool, ()>;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: Use a custom Error type instead
+
+error: This returns a `Result<_, ()>
+  --> $DIR/result_unit_error.rs:15:5
+   |
+LL |     fn get_this_one_too(&self) -> Result<bool, ()> {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: Use a custom Error type instead
+
+error: This returns a `Result<_, ()>
+  --> $DIR/result_unit_error.rs:33:5
+   |
+LL |     pub fn unit_error(&self) -> Result<usize, ()> {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: Use a custom Error type instead
+
+error: aborting due to 4 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 74ae116131696e4385d5b8e5da34deaad0d25ec9 Mon Sep 17 00:00:00 2001
From: Eduardo Broto <ebroto@tutanota.com>
Date: Sun, 11 Oct 2020 22:15:56 +0200
Subject: Use lowercase in error messages

---
 clippy_lints/src/functions.rs     | 14 +++++++-------
 tests/ui/result_unit_error.stderr | 16 ++++++++--------
 2 files changed, 15 insertions(+), 15 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/functions.rs b/clippy_lints/src/functions.rs
index 212a3100637..fd45a6da61c 100644
--- a/clippy_lints/src/functions.rs
+++ b/clippy_lints/src/functions.rs
@@ -194,19 +194,19 @@ declare_clippy_lint! {
     /// use std::fmt;
     ///
     /// #[derive(Debug)]
-    /// struct EndOfStream;
+    /// pub struct EndOfStream;
     ///
     /// impl fmt::Display for EndOfStream {
-    /// 	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-    ///			write!(f, "End of Stream")
-    /// 	}
+    ///     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    ///         write!(f, "End of Stream")
+    ///     }
     /// }
     ///
     /// impl std::error::Error for EndOfStream { }
     ///
     /// pub fn read_u8() -> Result<u8, EndOfStream> { Err(EndOfStream) }
     ///# fn main() {
-    ///# 	read_u8().unwrap();
+    ///#     read_u8().unwrap();
     ///# }
     /// ```
     ///
@@ -483,9 +483,9 @@ fn check_result_unit_err(cx: &LateContext<'_>, decl: &hir::FnDecl<'_>, item_span
                 cx,
                 RESULT_UNIT_ERR,
                 fn_header_span,
-                "This returns a `Result<_, ()>",
+                "this returns a `Result<_, ()>",
                 None,
-                "Use a custom Error type instead",
+                "use a custom Error type instead",
             );
         }
     }
diff --git a/tests/ui/result_unit_error.stderr b/tests/ui/result_unit_error.stderr
index 986d9718acd..b8230032491 100644
--- a/tests/ui/result_unit_error.stderr
+++ b/tests/ui/result_unit_error.stderr
@@ -1,35 +1,35 @@
-error: This returns a `Result<_, ()>
+error: this returns a `Result<_, ()>
   --> $DIR/result_unit_error.rs:4:1
    |
 LL | pub fn returns_unit_error() -> Result<u32, ()> {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::result-unit-err` implied by `-D warnings`
-   = help: Use a custom Error type instead
+   = help: use a custom Error type instead
 
-error: This returns a `Result<_, ()>
+error: this returns a `Result<_, ()>
   --> $DIR/result_unit_error.rs:13:5
    |
 LL |     fn get_that_error(&self) -> Result<bool, ()>;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: Use a custom Error type instead
+   = help: use a custom Error type instead
 
-error: This returns a `Result<_, ()>
+error: this returns a `Result<_, ()>
   --> $DIR/result_unit_error.rs:15:5
    |
 LL |     fn get_this_one_too(&self) -> Result<bool, ()> {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: Use a custom Error type instead
+   = help: use a custom Error type instead
 
-error: This returns a `Result<_, ()>
+error: this returns a `Result<_, ()>
   --> $DIR/result_unit_error.rs:33:5
    |
 LL |     pub fn unit_error(&self) -> Result<usize, ()> {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: Use a custom Error type instead
+   = help: use a custom Error type instead
 
 error: aborting due to 4 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 32fdb8fb0c15ddc202eed70b82babca8d529e39b Mon Sep 17 00:00:00 2001
From: ThibsG <Thibs@debian.com>
Date: Thu, 8 Oct 2020 23:02:16 +0200
Subject: Lint on identical variable used as args in `assert_eq!` macro call

---
 clippy_lints/src/eq_op.rs               | 37 ++++++++++++++++++++++++++++++++-
 clippy_lints/src/lib.rs                 |  2 ++
 tests/ui/auxiliary/proc_macro_derive.rs |  1 +
 tests/ui/double_parens.rs               |  2 +-
 tests/ui/eq_op_early.rs                 | 15 +++++++++++++
 tests/ui/eq_op_early.stderr             | 16 ++++++++++++++
 tests/ui/used_underscore_binding.rs     |  2 +-
 7 files changed, 72 insertions(+), 3 deletions(-)
 create mode 100644 tests/ui/eq_op_early.rs
 create mode 100644 tests/ui/eq_op_early.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/eq_op.rs b/clippy_lints/src/eq_op.rs
index e16ec783fab..7126c98a0b4 100644
--- a/clippy_lints/src/eq_op.rs
+++ b/clippy_lints/src/eq_op.rs
@@ -1,9 +1,13 @@
+use crate::utils::ast_utils::eq_expr;
 use crate::utils::{
     eq_expr_value, implements_trait, in_macro, is_copy, multispan_sugg, snippet, span_lint, span_lint_and_then,
 };
+use if_chain::if_chain;
+use rustc_ast::{ast, token};
 use rustc_errors::Applicability;
 use rustc_hir::{BinOp, BinOpKind, BorrowKind, Expr, ExprKind};
-use rustc_lint::{LateContext, LateLintPass};
+use rustc_lint::{EarlyContext, EarlyLintPass, LateContext, LateLintPass};
+use rustc_parse::parser;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
@@ -23,6 +27,12 @@ declare_clippy_lint! {
     /// # let x = 1;
     /// if x + 1 == x + 1 {}
     /// ```
+    /// or
+    /// ```rust
+    /// # let a = 3;
+    /// # let b = 4;
+    /// assert_eq!(a, a);
+    /// ```
     pub EQ_OP,
     correctness,
     "equal operands on both sides of a comparison or bitwise combination (e.g., `x == x`)"
@@ -52,6 +62,31 @@ declare_clippy_lint! {
 
 declare_lint_pass!(EqOp => [EQ_OP, OP_REF]);
 
+impl EarlyLintPass for EqOp {
+    fn check_mac(&mut self, cx: &EarlyContext<'_>, mac: &ast::MacCall) {
+        if_chain! {
+            if mac.path == sym!(assert_eq);
+            let tokens = mac.args.inner_tokens();
+            let mut parser = parser::Parser::new(&cx.sess.parse_sess, tokens, false, None);
+            if let Ok(left) = parser.parse_expr();
+            if parser.eat(&token::Comma);
+            if let Ok(right) = parser.parse_expr();
+            let left_expr = left.into_inner();
+            let right_expr = right.into_inner();
+            if eq_expr(&left_expr, &right_expr);
+
+            then {
+                span_lint(
+                    cx,
+                    EQ_OP,
+                    left_expr.span.to(right_expr.span),
+                    "identical args used in this `assert_eq!` macro call",
+                );
+            }
+        }
+    }
+}
+
 impl<'tcx> LateLintPass<'tcx> for EqOp {
     #[allow(clippy::similar_names, clippy::too_many_lines)]
     fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index fc4afde9d9e..dd99b6b9040 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -348,6 +348,7 @@ pub fn register_pre_expansion_lints(store: &mut rustc_lint::LintStore) {
     store.register_pre_expansion_pass(|| box write::Write::default());
     store.register_pre_expansion_pass(|| box attrs::EarlyAttributes);
     store.register_pre_expansion_pass(|| box dbg_macro::DbgMacro);
+    store.register_pre_expansion_pass(|| box eq_op::EqOp);
 }
 
 #[doc(hidden)]
@@ -910,6 +911,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     let vec_box_size_threshold = conf.vec_box_size_threshold;
     store.register_late_pass(move || box types::Types::new(vec_box_size_threshold));
     store.register_late_pass(|| box booleans::NonminimalBool);
+    store.register_early_pass(|| box eq_op::EqOp);
     store.register_late_pass(|| box eq_op::EqOp);
     store.register_late_pass(|| box enum_clike::UnportableVariant);
     store.register_late_pass(|| box float_literal::FloatLiteral);
diff --git a/tests/ui/auxiliary/proc_macro_derive.rs b/tests/ui/auxiliary/proc_macro_derive.rs
index 3df8be6c232..e369f62f8bf 100644
--- a/tests/ui/auxiliary/proc_macro_derive.rs
+++ b/tests/ui/auxiliary/proc_macro_derive.rs
@@ -3,6 +3,7 @@
 
 #![crate_type = "proc-macro"]
 #![feature(repr128, proc_macro_quote)]
+#![allow(clippy::eq_op)]
 
 extern crate proc_macro;
 
diff --git a/tests/ui/double_parens.rs b/tests/ui/double_parens.rs
index 9c7590c7dd6..ff1dc76ab63 100644
--- a/tests/ui/double_parens.rs
+++ b/tests/ui/double_parens.rs
@@ -1,5 +1,5 @@
 #![warn(clippy::double_parens)]
-#![allow(dead_code)]
+#![allow(dead_code, clippy::eq_op)]
 #![feature(custom_inner_attributes)]
 #![rustfmt::skip]
 
diff --git a/tests/ui/eq_op_early.rs b/tests/ui/eq_op_early.rs
new file mode 100644
index 00000000000..cf5660ea98d
--- /dev/null
+++ b/tests/ui/eq_op_early.rs
@@ -0,0 +1,15 @@
+#![warn(clippy::eq_op)]
+
+fn main() {
+    let a = 1;
+    let b = 2;
+
+    // lint identical args in `assert_eq!` (see #3574)
+    assert_eq!(a, a);
+    assert_eq!(a + 1, a + 1);
+
+    // ok
+    assert_eq!(a, b);
+    assert_eq!(a, a + 1);
+    assert_eq!(a + 1, b + 1);
+}
diff --git a/tests/ui/eq_op_early.stderr b/tests/ui/eq_op_early.stderr
new file mode 100644
index 00000000000..9206e9026e9
--- /dev/null
+++ b/tests/ui/eq_op_early.stderr
@@ -0,0 +1,16 @@
+error: identical args used in this `assert_eq!` macro call
+  --> $DIR/eq_op_early.rs:8:16
+   |
+LL |     assert_eq!(a, a);
+   |                ^^^^
+   |
+   = note: `-D clippy::eq-op` implied by `-D warnings`
+
+error: identical args used in this `assert_eq!` macro call
+  --> $DIR/eq_op_early.rs:9:16
+   |
+LL |     assert_eq!(a + 1, a + 1);
+   |                ^^^^^^^^^^^^
+
+error: aborting due to 2 previous errors
+
diff --git a/tests/ui/used_underscore_binding.rs b/tests/ui/used_underscore_binding.rs
index 8e0243c49aa..d8bda7e8f48 100644
--- a/tests/ui/used_underscore_binding.rs
+++ b/tests/ui/used_underscore_binding.rs
@@ -3,7 +3,7 @@
 
 #![feature(rustc_private)]
 #![warn(clippy::all)]
-#![allow(clippy::blacklisted_name)]
+#![allow(clippy::blacklisted_name, clippy::eq_op)]
 #![warn(clippy::used_underscore_binding)]
 
 #[macro_use]
-- 
cgit 1.4.1-3-g733a5


From a3e0446afe0ebd7a420f65cd6aec1c56687f0ef5 Mon Sep 17 00:00:00 2001
From: ThibsG <Thibs@debian.com>
Date: Tue, 13 Oct 2020 09:31:53 +0200
Subject: Extend to the `assert` macro family

---
 clippy_lints/src/eq_op.rs   | 17 ++++++++++++++---
 tests/ui/eq_op_early.rs     | 25 ++++++++++++++++++++++++-
 tests/ui/eq_op_early.stderr | 38 +++++++++++++++++++++++++++++++++++++-
 3 files changed, 75 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/eq_op.rs b/clippy_lints/src/eq_op.rs
index 7126c98a0b4..a95d71042ee 100644
--- a/clippy_lints/src/eq_op.rs
+++ b/clippy_lints/src/eq_op.rs
@@ -7,6 +7,7 @@ use rustc_ast::{ast, token};
 use rustc_errors::Applicability;
 use rustc_hir::{BinOp, BinOpKind, BorrowKind, Expr, ExprKind};
 use rustc_lint::{EarlyContext, EarlyLintPass, LateContext, LateLintPass};
+use rustc_middle::lint::in_external_macro;
 use rustc_parse::parser;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
@@ -64,10 +65,20 @@ declare_lint_pass!(EqOp => [EQ_OP, OP_REF]);
 
 impl EarlyLintPass for EqOp {
     fn check_mac(&mut self, cx: &EarlyContext<'_>, mac: &ast::MacCall) {
+        let macro_list = [
+            sym!(assert_eq),
+            sym!(assert_ne),
+            sym!(debug_assert_eq),
+            sym!(debug_assert_ne),
+        ];
         if_chain! {
-            if mac.path == sym!(assert_eq);
+            if !in_external_macro(cx.sess, mac.span());
+            if mac.path.segments.len() == 1;
+            let macro_name = mac.path.segments[0].ident.name;
+            if macro_list.contains(&macro_name);
             let tokens = mac.args.inner_tokens();
-            let mut parser = parser::Parser::new(&cx.sess.parse_sess, tokens, false, None);
+            let mut parser = parser::Parser::new(
+                &cx.sess.parse_sess, tokens, false, None);
             if let Ok(left) = parser.parse_expr();
             if parser.eat(&token::Comma);
             if let Ok(right) = parser.parse_expr();
@@ -80,7 +91,7 @@ impl EarlyLintPass for EqOp {
                     cx,
                     EQ_OP,
                     left_expr.span.to(right_expr.span),
-                    "identical args used in this `assert_eq!` macro call",
+                    &format!("identical args used in this `{}!` macro call", macro_name),
                 );
             }
         }
diff --git a/tests/ui/eq_op_early.rs b/tests/ui/eq_op_early.rs
index cf5660ea98d..25e1c6ac6b7 100644
--- a/tests/ui/eq_op_early.rs
+++ b/tests/ui/eq_op_early.rs
@@ -7,9 +7,32 @@ fn main() {
     // lint identical args in `assert_eq!` (see #3574)
     assert_eq!(a, a);
     assert_eq!(a + 1, a + 1);
-
     // ok
     assert_eq!(a, b);
     assert_eq!(a, a + 1);
     assert_eq!(a + 1, b + 1);
+
+    // lint identical args in `assert_ne!`
+    assert_ne!(a, a);
+    assert_ne!(a + 1, a + 1);
+    // ok
+    assert_ne!(a, b);
+    assert_ne!(a, a + 1);
+    assert_ne!(a + 1, b + 1);
+
+    // lint identical args in `debug_assert_eq!`
+    debug_assert_eq!(a, a);
+    debug_assert_eq!(a + 1, a + 1);
+    // ok
+    debug_assert_eq!(a, b);
+    debug_assert_eq!(a, a + 1);
+    debug_assert_eq!(a + 1, b + 1);
+
+    // lint identical args in `debug_assert_ne!`
+    debug_assert_ne!(a, a);
+    debug_assert_ne!(a + 1, a + 1);
+    // ok
+    debug_assert_ne!(a, b);
+    debug_assert_ne!(a, a + 1);
+    debug_assert_ne!(a + 1, b + 1);
 }
diff --git a/tests/ui/eq_op_early.stderr b/tests/ui/eq_op_early.stderr
index 9206e9026e9..1df094fae18 100644
--- a/tests/ui/eq_op_early.stderr
+++ b/tests/ui/eq_op_early.stderr
@@ -12,5 +12,41 @@ error: identical args used in this `assert_eq!` macro call
 LL |     assert_eq!(a + 1, a + 1);
    |                ^^^^^^^^^^^^
 
-error: aborting due to 2 previous errors
+error: identical args used in this `assert_ne!` macro call
+  --> $DIR/eq_op_early.rs:16:16
+   |
+LL |     assert_ne!(a, a);
+   |                ^^^^
+
+error: identical args used in this `assert_ne!` macro call
+  --> $DIR/eq_op_early.rs:17:16
+   |
+LL |     assert_ne!(a + 1, a + 1);
+   |                ^^^^^^^^^^^^
+
+error: identical args used in this `debug_assert_eq!` macro call
+  --> $DIR/eq_op_early.rs:24:22
+   |
+LL |     debug_assert_eq!(a, a);
+   |                      ^^^^
+
+error: identical args used in this `debug_assert_eq!` macro call
+  --> $DIR/eq_op_early.rs:25:22
+   |
+LL |     debug_assert_eq!(a + 1, a + 1);
+   |                      ^^^^^^^^^^^^
+
+error: identical args used in this `debug_assert_ne!` macro call
+  --> $DIR/eq_op_early.rs:32:22
+   |
+LL |     debug_assert_ne!(a, a);
+   |                      ^^^^
+
+error: identical args used in this `debug_assert_ne!` macro call
+  --> $DIR/eq_op_early.rs:33:22
+   |
+LL |     debug_assert_ne!(a + 1, a + 1);
+   |                      ^^^^^^^^^^^^
+
+error: aborting due to 8 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From e2124086b8107a59129e163aa120dec50add0f77 Mon Sep 17 00:00:00 2001
From: ThibsG <Thibs@debian.com>
Date: Tue, 13 Oct 2020 11:17:51 +0200
Subject: Fix FP in `same_functions_in_if_condition` lint about condition as
 macro

---
 clippy_lints/src/copies.rs                 |  6 +++++-
 tests/ui/same_functions_in_if_condition.rs | 12 +++++++++++-
 2 files changed, 16 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/copies.rs b/clippy_lints/src/copies.rs
index 10a64769585..6c969c3ead0 100644
--- a/clippy_lints/src/copies.rs
+++ b/clippy_lints/src/copies.rs
@@ -1,4 +1,4 @@
-use crate::utils::{eq_expr_value, SpanlessEq, SpanlessHash};
+use crate::utils::{eq_expr_value, in_macro, SpanlessEq, SpanlessHash};
 use crate::utils::{get_parent_expr, higher, if_sequence, snippet, span_lint_and_note, span_lint_and_then};
 use rustc_data_structures::fx::FxHashMap;
 use rustc_hir::{Arm, Block, Expr, ExprKind, MatchSource, Pat, PatKind};
@@ -220,6 +220,10 @@ fn lint_same_fns_in_if_cond(cx: &LateContext<'_>, conds: &[&Expr<'_>]) {
     };
 
     let eq: &dyn Fn(&&Expr<'_>, &&Expr<'_>) -> bool = &|&lhs, &rhs| -> bool {
+        // Do not lint if any expr originates from a macro
+        if in_macro(lhs.span) || in_macro(rhs.span) {
+            return false;
+        }
         // Do not spawn warning if `IFS_SAME_COND` already produced it.
         if eq_expr_value(cx, lhs, rhs) {
             return false;
diff --git a/tests/ui/same_functions_in_if_condition.rs b/tests/ui/same_functions_in_if_condition.rs
index 686867cf5c6..7f28f025790 100644
--- a/tests/ui/same_functions_in_if_condition.rs
+++ b/tests/ui/same_functions_in_if_condition.rs
@@ -77,4 +77,14 @@ fn ifs_same_cond_fn() {
     }
 }
 
-fn main() {}
+fn main() {
+    // macro as condition (see #6168)
+    let os = if cfg!(target_os = "macos") {
+        "macos"
+    } else if cfg!(target_os = "windows") {
+        "windows"
+    } else {
+        "linux"
+    };
+    println!("{}", os);
+}
-- 
cgit 1.4.1-3-g733a5


From 121a047645270d5e9ac965d57c324301ea1f21c0 Mon Sep 17 00:00:00 2001
From: ThibsG <Thibs@debian.com>
Date: Tue, 13 Oct 2020 23:46:23 +0200
Subject: Move linting of `assert` macros from early to late pass

---
 clippy_lints/src/eq_op.rs   | 73 +++++++++++++++-------------------
 clippy_lints/src/lib.rs     |  2 -
 tests/ui/eq_op.rs           | 53 +++++++++++++++++++++++++
 tests/ui/eq_op.stderr       | 95 ++++++++++++++++++++++++++++++++++++++++++++-
 tests/ui/eq_op_early.rs     | 38 ------------------
 tests/ui/eq_op_early.stderr | 52 -------------------------
 6 files changed, 179 insertions(+), 134 deletions(-)
 delete mode 100644 tests/ui/eq_op_early.rs
 delete mode 100644 tests/ui/eq_op_early.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/eq_op.rs b/clippy_lints/src/eq_op.rs
index a95d71042ee..9653e62cad0 100644
--- a/clippy_lints/src/eq_op.rs
+++ b/clippy_lints/src/eq_op.rs
@@ -1,14 +1,11 @@
-use crate::utils::ast_utils::eq_expr;
 use crate::utils::{
-    eq_expr_value, implements_trait, in_macro, is_copy, multispan_sugg, snippet, span_lint, span_lint_and_then,
+    eq_expr_value, implements_trait, in_macro, is_copy, is_expn_of, multispan_sugg, snippet, span_lint,
+    span_lint_and_then,
 };
 use if_chain::if_chain;
-use rustc_ast::{ast, token};
 use rustc_errors::Applicability;
-use rustc_hir::{BinOp, BinOpKind, BorrowKind, Expr, ExprKind};
-use rustc_lint::{EarlyContext, EarlyLintPass, LateContext, LateLintPass};
-use rustc_middle::lint::in_external_macro;
-use rustc_parse::parser;
+use rustc_hir::{BinOp, BinOpKind, BorrowKind, Expr, ExprKind, StmtKind};
+use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
@@ -63,44 +60,38 @@ declare_clippy_lint! {
 
 declare_lint_pass!(EqOp => [EQ_OP, OP_REF]);
 
-impl EarlyLintPass for EqOp {
-    fn check_mac(&mut self, cx: &EarlyContext<'_>, mac: &ast::MacCall) {
-        let macro_list = [
-            sym!(assert_eq),
-            sym!(assert_ne),
-            sym!(debug_assert_eq),
-            sym!(debug_assert_ne),
-        ];
-        if_chain! {
-            if !in_external_macro(cx.sess, mac.span());
-            if mac.path.segments.len() == 1;
-            let macro_name = mac.path.segments[0].ident.name;
-            if macro_list.contains(&macro_name);
-            let tokens = mac.args.inner_tokens();
-            let mut parser = parser::Parser::new(
-                &cx.sess.parse_sess, tokens, false, None);
-            if let Ok(left) = parser.parse_expr();
-            if parser.eat(&token::Comma);
-            if let Ok(right) = parser.parse_expr();
-            let left_expr = left.into_inner();
-            let right_expr = right.into_inner();
-            if eq_expr(&left_expr, &right_expr);
-
-            then {
-                span_lint(
-                    cx,
-                    EQ_OP,
-                    left_expr.span.to(right_expr.span),
-                    &format!("identical args used in this `{}!` macro call", macro_name),
-                );
-            }
-        }
-    }
-}
+const ASSERT_MACRO_NAMES: [&str; 4] = ["assert_eq", "assert_ne", "debug_assert_eq", "debug_assert_ne"];
 
 impl<'tcx> LateLintPass<'tcx> for EqOp {
     #[allow(clippy::similar_names, clippy::too_many_lines)]
     fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
+        if let ExprKind::Block(ref block, _) = e.kind {
+            for stmt in block.stmts {
+                for amn in &ASSERT_MACRO_NAMES {
+                    if_chain! {
+                        if is_expn_of(stmt.span, amn).is_some();
+                        if let StmtKind::Semi(ref matchexpr) = stmt.kind;
+                        if let ExprKind::Block(ref matchblock, _) = matchexpr.kind;
+                        if let Some(ref matchheader) = matchblock.expr;
+                        if let ExprKind::Match(ref headerexpr, _, _) = matchheader.kind;
+                        if let ExprKind::Tup(ref conditions) = headerexpr.kind;
+                        if conditions.len() == 2;
+                        if let ExprKind::AddrOf(BorrowKind::Ref, _, ref lhs) = conditions[0].kind;
+                        if let ExprKind::AddrOf(BorrowKind::Ref, _, ref rhs) = conditions[1].kind;
+                        if eq_expr_value(cx, lhs, rhs);
+
+                        then {
+                            span_lint(
+                                cx,
+                                EQ_OP,
+                                lhs.span.to(rhs.span),
+                                &format!("identical args used in this `{}!` macro call", amn),
+                            );
+                        }
+                    }
+                }
+            }
+        }
         if let ExprKind::Binary(op, ref left, ref right) = e.kind {
             if e.span.from_expansion() {
                 return;
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index dd99b6b9040..fc4afde9d9e 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -348,7 +348,6 @@ pub fn register_pre_expansion_lints(store: &mut rustc_lint::LintStore) {
     store.register_pre_expansion_pass(|| box write::Write::default());
     store.register_pre_expansion_pass(|| box attrs::EarlyAttributes);
     store.register_pre_expansion_pass(|| box dbg_macro::DbgMacro);
-    store.register_pre_expansion_pass(|| box eq_op::EqOp);
 }
 
 #[doc(hidden)]
@@ -911,7 +910,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     let vec_box_size_threshold = conf.vec_box_size_threshold;
     store.register_late_pass(move || box types::Types::new(vec_box_size_threshold));
     store.register_late_pass(|| box booleans::NonminimalBool);
-    store.register_early_pass(|| box eq_op::EqOp);
     store.register_late_pass(|| box eq_op::EqOp);
     store.register_late_pass(|| box enum_clike::UnportableVariant);
     store.register_late_pass(|| box float_literal::FloatLiteral);
diff --git a/tests/ui/eq_op.rs b/tests/ui/eq_op.rs
index 272b0900a31..3ab4dfc439b 100644
--- a/tests/ui/eq_op.rs
+++ b/tests/ui/eq_op.rs
@@ -60,6 +60,8 @@ fn main() {
     const B: u32 = 10;
     const C: u32 = A / B; // ok, different named constants
     const D: u32 = A / A;
+
+    check_assert_identical_args();
 }
 
 #[rustfmt::skip]
@@ -85,3 +87,54 @@ fn check_ignore_macro() {
     // checks if the lint ignores macros with `!` operator
     !bool_macro!(1) && !bool_macro!("");
 }
+
+macro_rules! assert_in_macro_def {
+    () => {
+        let a = 42;
+        assert_eq!(a, a);
+        assert_ne!(a, a);
+        debug_assert_eq!(a, a);
+        debug_assert_ne!(a, a);
+    };
+}
+
+// lint identical args in assert-like macro invocations (see #3574)
+fn check_assert_identical_args() {
+    // lint also in macro definition
+    assert_in_macro_def!();
+
+    let a = 1;
+    let b = 2;
+
+    // lint identical args in `assert_eq!`
+    assert_eq!(a, a);
+    assert_eq!(a + 1, a + 1);
+    // ok
+    assert_eq!(a, b);
+    assert_eq!(a, a + 1);
+    assert_eq!(a + 1, b + 1);
+
+    // lint identical args in `assert_ne!`
+    assert_ne!(a, a);
+    assert_ne!(a + 1, a + 1);
+    // ok
+    assert_ne!(a, b);
+    assert_ne!(a, a + 1);
+    assert_ne!(a + 1, b + 1);
+
+    // lint identical args in `debug_assert_eq!`
+    debug_assert_eq!(a, a);
+    debug_assert_eq!(a + 1, a + 1);
+    // ok
+    debug_assert_eq!(a, b);
+    debug_assert_eq!(a, a + 1);
+    debug_assert_eq!(a + 1, b + 1);
+
+    // lint identical args in `debug_assert_ne!`
+    debug_assert_ne!(a, a);
+    debug_assert_ne!(a + 1, a + 1);
+    // ok
+    debug_assert_ne!(a, b);
+    debug_assert_ne!(a, a + 1);
+    debug_assert_ne!(a + 1, b + 1);
+}
diff --git a/tests/ui/eq_op.stderr b/tests/ui/eq_op.stderr
index 5b80e6078ee..21a63aec7a1 100644
--- a/tests/ui/eq_op.stderr
+++ b/tests/ui/eq_op.stderr
@@ -162,5 +162,98 @@ error: equal expressions as operands to `/`
 LL |     const D: u32 = A / A;
    |                    ^^^^^
 
-error: aborting due to 27 previous errors
+error: identical args used in this `assert_eq!` macro call
+  --> $DIR/eq_op.rs:94:20
+   |
+LL |         assert_eq!(a, a);
+   |                    ^^^^
+...
+LL |     assert_in_macro_def!();
+   |     ----------------------- in this macro invocation
+   |
+   = note: `#[deny(clippy::eq_op)]` on by default
+   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: identical args used in this `assert_ne!` macro call
+  --> $DIR/eq_op.rs:95:20
+   |
+LL |         assert_ne!(a, a);
+   |                    ^^^^
+...
+LL |     assert_in_macro_def!();
+   |     ----------------------- in this macro invocation
+   |
+   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: identical args used in this `assert_eq!` macro call
+  --> $DIR/eq_op.rs:110:16
+   |
+LL |     assert_eq!(a, a);
+   |                ^^^^
+
+error: identical args used in this `assert_eq!` macro call
+  --> $DIR/eq_op.rs:111:16
+   |
+LL |     assert_eq!(a + 1, a + 1);
+   |                ^^^^^^^^^^^^
+
+error: identical args used in this `assert_ne!` macro call
+  --> $DIR/eq_op.rs:118:16
+   |
+LL |     assert_ne!(a, a);
+   |                ^^^^
+
+error: identical args used in this `assert_ne!` macro call
+  --> $DIR/eq_op.rs:119:16
+   |
+LL |     assert_ne!(a + 1, a + 1);
+   |                ^^^^^^^^^^^^
+
+error: identical args used in this `debug_assert_eq!` macro call
+  --> $DIR/eq_op.rs:96:26
+   |
+LL |         debug_assert_eq!(a, a);
+   |                          ^^^^
+...
+LL |     assert_in_macro_def!();
+   |     ----------------------- in this macro invocation
+   |
+   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: identical args used in this `debug_assert_ne!` macro call
+  --> $DIR/eq_op.rs:97:26
+   |
+LL |         debug_assert_ne!(a, a);
+   |                          ^^^^
+...
+LL |     assert_in_macro_def!();
+   |     ----------------------- in this macro invocation
+   |
+   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: identical args used in this `debug_assert_eq!` macro call
+  --> $DIR/eq_op.rs:126:22
+   |
+LL |     debug_assert_eq!(a, a);
+   |                      ^^^^
+
+error: identical args used in this `debug_assert_eq!` macro call
+  --> $DIR/eq_op.rs:127:22
+   |
+LL |     debug_assert_eq!(a + 1, a + 1);
+   |                      ^^^^^^^^^^^^
+
+error: identical args used in this `debug_assert_ne!` macro call
+  --> $DIR/eq_op.rs:134:22
+   |
+LL |     debug_assert_ne!(a, a);
+   |                      ^^^^
+
+error: identical args used in this `debug_assert_ne!` macro call
+  --> $DIR/eq_op.rs:135:22
+   |
+LL |     debug_assert_ne!(a + 1, a + 1);
+   |                      ^^^^^^^^^^^^
+
+error: aborting due to 39 previous errors
 
diff --git a/tests/ui/eq_op_early.rs b/tests/ui/eq_op_early.rs
deleted file mode 100644
index 25e1c6ac6b7..00000000000
--- a/tests/ui/eq_op_early.rs
+++ /dev/null
@@ -1,38 +0,0 @@
-#![warn(clippy::eq_op)]
-
-fn main() {
-    let a = 1;
-    let b = 2;
-
-    // lint identical args in `assert_eq!` (see #3574)
-    assert_eq!(a, a);
-    assert_eq!(a + 1, a + 1);
-    // ok
-    assert_eq!(a, b);
-    assert_eq!(a, a + 1);
-    assert_eq!(a + 1, b + 1);
-
-    // lint identical args in `assert_ne!`
-    assert_ne!(a, a);
-    assert_ne!(a + 1, a + 1);
-    // ok
-    assert_ne!(a, b);
-    assert_ne!(a, a + 1);
-    assert_ne!(a + 1, b + 1);
-
-    // lint identical args in `debug_assert_eq!`
-    debug_assert_eq!(a, a);
-    debug_assert_eq!(a + 1, a + 1);
-    // ok
-    debug_assert_eq!(a, b);
-    debug_assert_eq!(a, a + 1);
-    debug_assert_eq!(a + 1, b + 1);
-
-    // lint identical args in `debug_assert_ne!`
-    debug_assert_ne!(a, a);
-    debug_assert_ne!(a + 1, a + 1);
-    // ok
-    debug_assert_ne!(a, b);
-    debug_assert_ne!(a, a + 1);
-    debug_assert_ne!(a + 1, b + 1);
-}
diff --git a/tests/ui/eq_op_early.stderr b/tests/ui/eq_op_early.stderr
deleted file mode 100644
index 1df094fae18..00000000000
--- a/tests/ui/eq_op_early.stderr
+++ /dev/null
@@ -1,52 +0,0 @@
-error: identical args used in this `assert_eq!` macro call
-  --> $DIR/eq_op_early.rs:8:16
-   |
-LL |     assert_eq!(a, a);
-   |                ^^^^
-   |
-   = note: `-D clippy::eq-op` implied by `-D warnings`
-
-error: identical args used in this `assert_eq!` macro call
-  --> $DIR/eq_op_early.rs:9:16
-   |
-LL |     assert_eq!(a + 1, a + 1);
-   |                ^^^^^^^^^^^^
-
-error: identical args used in this `assert_ne!` macro call
-  --> $DIR/eq_op_early.rs:16:16
-   |
-LL |     assert_ne!(a, a);
-   |                ^^^^
-
-error: identical args used in this `assert_ne!` macro call
-  --> $DIR/eq_op_early.rs:17:16
-   |
-LL |     assert_ne!(a + 1, a + 1);
-   |                ^^^^^^^^^^^^
-
-error: identical args used in this `debug_assert_eq!` macro call
-  --> $DIR/eq_op_early.rs:24:22
-   |
-LL |     debug_assert_eq!(a, a);
-   |                      ^^^^
-
-error: identical args used in this `debug_assert_eq!` macro call
-  --> $DIR/eq_op_early.rs:25:22
-   |
-LL |     debug_assert_eq!(a + 1, a + 1);
-   |                      ^^^^^^^^^^^^
-
-error: identical args used in this `debug_assert_ne!` macro call
-  --> $DIR/eq_op_early.rs:32:22
-   |
-LL |     debug_assert_ne!(a, a);
-   |                      ^^^^
-
-error: identical args used in this `debug_assert_ne!` macro call
-  --> $DIR/eq_op_early.rs:33:22
-   |
-LL |     debug_assert_ne!(a + 1, a + 1);
-   |                      ^^^^^^^^^^^^
-
-error: aborting due to 8 previous errors
-
-- 
cgit 1.4.1-3-g733a5


From e82264860dd275fe95c335929ee9a231c3a61236 Mon Sep 17 00:00:00 2001
From: Xidorn Quan <me@upsuper.org>
Date: Wed, 14 Oct 2020 23:15:01 +1100
Subject: Add a known problem for transmute_ptr_to_ref lint

---
 clippy_lints/src/transmute.rs | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/transmute.rs b/clippy_lints/src/transmute.rs
index c75adb62f25..47c650ac27d 100644
--- a/clippy_lints/src/transmute.rs
+++ b/clippy_lints/src/transmute.rs
@@ -98,7 +98,11 @@ declare_clippy_lint! {
     ///
     /// **Why is this bad?** This can always be rewritten with `&` and `*`.
     ///
-    /// **Known problems:** None.
+    /// **Known problems:**
+    /// - `mem::transmute` in statics and constants is stable from Rust 1.46.0,
+    /// while dereferencing raw pointer is not stable yet.
+    /// If you need to do this in those places,
+    /// you would have to use `transmute` instead.
     ///
     /// **Example:**
     /// ```rust,ignore
-- 
cgit 1.4.1-3-g733a5


From 07b2da884cda8103af50beb327723dec8204fc61 Mon Sep 17 00:00:00 2001
From: Tim Nielens <tim.nielens@gmail.com>
Date: Tue, 6 Oct 2020 11:49:08 +0200
Subject: add lint less_concise_than_option_unwrap_or

---
 CHANGELOG.md                            |   1 +
 clippy_lints/src/less_concise_than.rs   | 107 ++++++++++++++++++++++++++++++++
 clippy_lints/src/lib.rs                 |   4 ++
 clippy_lints/src/option_if_let_else.rs  |  53 +---------------
 clippy_lints/src/utils/eager_or_lazy.rs |   2 +-
 clippy_lints/src/utils/usage.rs         |  50 ++++++++++++++-
 src/lintlist/mod.rs                     |   7 +++
 tests/ui/less_concise_than.fixed        |  43 +++++++++++++
 tests/ui/less_concise_than.rs           |  55 ++++++++++++++++
 tests/ui/less_concise_than.stderr       |  52 ++++++++++++++++
 tests/ui/shadow.rs                      |   1 +
 tests/ui/shadow.stderr                  |  46 +++++++-------
 12 files changed, 345 insertions(+), 76 deletions(-)
 create mode 100644 clippy_lints/src/less_concise_than.rs
 create mode 100644 tests/ui/less_concise_than.fixed
 create mode 100644 tests/ui/less_concise_than.rs
 create mode 100644 tests/ui/less_concise_than.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index f21768c4498..93ce6bb85d8 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1781,6 +1781,7 @@ Released 2018-09-13
 [`large_stack_arrays`]: https://rust-lang.github.io/rust-clippy/master/index.html#large_stack_arrays
 [`len_without_is_empty`]: https://rust-lang.github.io/rust-clippy/master/index.html#len_without_is_empty
 [`len_zero`]: https://rust-lang.github.io/rust-clippy/master/index.html#len_zero
+[`less_concise_than_option_unwrap_or`]: https://rust-lang.github.io/rust-clippy/master/index.html#less_concise_than_option_unwrap_or
 [`let_and_return`]: https://rust-lang.github.io/rust-clippy/master/index.html#let_and_return
 [`let_underscore_lock`]: https://rust-lang.github.io/rust-clippy/master/index.html#let_underscore_lock
 [`let_underscore_must_use`]: https://rust-lang.github.io/rust-clippy/master/index.html#let_underscore_must_use
diff --git a/clippy_lints/src/less_concise_than.rs b/clippy_lints/src/less_concise_than.rs
new file mode 100644
index 00000000000..097aff4b178
--- /dev/null
+++ b/clippy_lints/src/less_concise_than.rs
@@ -0,0 +1,107 @@
+use crate::utils;
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir::{def, Arm, Expr, ExprKind, PatKind, QPath};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// **What it does:**
+    /// Finds patterns that can be encoded more concisely with `Option::unwrap_or`.
+    ///
+    /// **Why is this bad?**
+    /// Concise code helps focusing on behavior instead of boilerplate.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// ```rust
+    /// match int_optional {
+    ///     Some(v) => v,
+    ///     None => 1,
+    /// }
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust
+    /// int_optional.unwrap_or(1)
+    /// ```
+    pub LESS_CONCISE_THAN_OPTION_UNWRAP_OR,
+    pedantic,
+    "finds patterns that can be encoded more concisely with `Option::unwrap_or`"
+}
+
+declare_lint_pass!(LessConciseThan => [LESS_CONCISE_THAN_OPTION_UNWRAP_OR]);
+
+impl LateLintPass<'_> for LessConciseThan {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
+        if utils::in_macro(expr.span) {
+            return;
+        }
+        if lint_option_unwrap_or_case(cx, expr) {
+            return;
+        }
+    }
+}
+
+fn lint_option_unwrap_or_case<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
+    #[allow(clippy::needless_bool)]
+    fn applicable_none_arm<'a>(arms: &'a [Arm<'a>]) -> Option<&'a Arm<'a>> {
+        if_chain! {
+            if arms.len() == 2;
+            if arms.iter().all(|arm| arm.guard.is_none());
+            if let Some((idx, none_arm)) = arms.iter().enumerate().find(|(_, arm)|
+               if_chain! {
+                    if let PatKind::Path(ref qpath) = arm.pat.kind;
+                    if utils::match_qpath(qpath, &utils::paths::OPTION_NONE);
+                    then { true }
+                    else { false }
+               }
+            );
+            let some_arm = &arms[1 - idx];
+            if let PatKind::TupleStruct(ref some_qpath, &[some_binding], _) = some_arm.pat.kind;
+            if utils::match_qpath(some_qpath, &utils::paths::OPTION_SOME);
+            if let PatKind::Binding(_, binding_hir_id, ..) = some_binding.kind;
+            if let ExprKind::Path(QPath::Resolved(_, body_path)) = some_arm.body.kind;
+            if let def::Res::Local(body_path_hir_id) = body_path.res;
+            if body_path_hir_id == binding_hir_id;
+            then { Some(none_arm) }
+            else { None }
+        }
+    }
+    if_chain! {
+      if !utils::usage::contains_return_break_continue_macro(expr);
+      if let ExprKind::Match (match_expr, match_arms, _) = expr.kind;
+      let ty = cx.typeck_results().expr_ty(match_expr);
+      if utils::is_type_diagnostic_item(cx, ty, sym!(option_type));
+      if let Some(none_arm) = applicable_none_arm(match_arms);
+      if let Some(match_expr_snippet) = utils::snippet_opt(cx, match_expr.span);
+      if let Some(none_body_snippet) = utils::snippet_opt(cx, none_arm.body.span);
+      if let Some(indent) = utils::indent_of(cx, expr.span);
+      then {
+          let reindented_none_body =
+              utils::reindent_multiline(none_body_snippet.into(), true, Some(indent));
+          let eager_eval = utils::eager_or_lazy::is_eagerness_candidate(cx, none_arm.body);
+          let method = if eager_eval {
+              "unwrap_or"
+          } else {
+              "unwrap_or_else"
+          };
+          utils::span_lint_and_sugg(
+              cx,
+              LESS_CONCISE_THAN_OPTION_UNWRAP_OR, expr.span,
+              "this pattern can be more concisely encoded with `Option::unwrap_or`",
+              "replace with",
+              format!(
+                  "{}.{}({}{})",
+                  match_expr_snippet,
+                  method,
+                  if eager_eval { ""} else { "|| " },
+                  reindented_none_body
+              ),
+              Applicability::MachineApplicable,
+          );
+          true
+      } else { false}
+    }
+}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 26a727687b1..2e9900815d9 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -224,6 +224,7 @@ mod large_const_arrays;
 mod large_enum_variant;
 mod large_stack_arrays;
 mod len_zero;
+mod less_concise_than;
 mod let_if_seq;
 mod let_underscore;
 mod lifetimes;
@@ -609,6 +610,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &large_stack_arrays::LARGE_STACK_ARRAYS,
         &len_zero::LEN_WITHOUT_IS_EMPTY,
         &len_zero::LEN_ZERO,
+        &less_concise_than::LESS_CONCISE_THAN_OPTION_UNWRAP_OR,
         &let_if_seq::USELESS_LET_IF_SEQ,
         &let_underscore::LET_UNDERSCORE_LOCK,
         &let_underscore::LET_UNDERSCORE_MUST_USE,
@@ -1126,6 +1128,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box repeat_once::RepeatOnce);
     store.register_late_pass(|| box unwrap_in_result::UnwrapInResult);
     store.register_late_pass(|| box self_assignment::SelfAssignment);
+    store.register_late_pass(|| box less_concise_than::LessConciseThan);
     store.register_late_pass(|| box float_equality_without_abs::FloatEqualityWithoutAbs);
     store.register_late_pass(|| box async_yields_async::AsyncYieldsAsync);
     store.register_late_pass(|| box manual_strip::ManualStrip);
@@ -1210,6 +1213,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&infinite_iter::MAYBE_INFINITE_ITER),
         LintId::of(&items_after_statements::ITEMS_AFTER_STATEMENTS),
         LintId::of(&large_stack_arrays::LARGE_STACK_ARRAYS),
+        LintId::of(&less_concise_than::LESS_CONCISE_THAN_OPTION_UNWRAP_OR),
         LintId::of(&literal_representation::LARGE_DIGIT_GROUPS),
         LintId::of(&literal_representation::UNREADABLE_LITERAL),
         LintId::of(&loops::EXPLICIT_INTO_ITER_LOOP),
diff --git a/clippy_lints/src/option_if_let_else.rs b/clippy_lints/src/option_if_let_else.rs
index 383a62da821..eb7624b25a3 100644
--- a/clippy_lints/src/option_if_let_else.rs
+++ b/clippy_lints/src/option_if_let_else.rs
@@ -5,10 +5,8 @@ use crate::utils::{is_type_diagnostic_item, paths, span_lint_and_sugg};
 use if_chain::if_chain;
 
 use rustc_errors::Applicability;
-use rustc_hir::intravisit::{NestedVisitorMap, Visitor};
 use rustc_hir::{Arm, BindingAnnotation, Block, Expr, ExprKind, MatchSource, Mutability, PatKind, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::hir::map::Map;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
@@ -84,53 +82,6 @@ struct OptionIfLetElseOccurence {
     wrap_braces: bool,
 }
 
-struct ReturnBreakContinueMacroVisitor {
-    seen_return_break_continue: bool,
-}
-
-impl ReturnBreakContinueMacroVisitor {
-    fn new() -> ReturnBreakContinueMacroVisitor {
-        ReturnBreakContinueMacroVisitor {
-            seen_return_break_continue: false,
-        }
-    }
-}
-
-impl<'tcx> Visitor<'tcx> for ReturnBreakContinueMacroVisitor {
-    type Map = Map<'tcx>;
-    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-        NestedVisitorMap::None
-    }
-
-    fn visit_expr(&mut self, ex: &'tcx Expr<'tcx>) {
-        if self.seen_return_break_continue {
-            // No need to look farther if we've already seen one of them
-            return;
-        }
-        match &ex.kind {
-            ExprKind::Ret(..) | ExprKind::Break(..) | ExprKind::Continue(..) => {
-                self.seen_return_break_continue = true;
-            },
-            // Something special could be done here to handle while or for loop
-            // desugaring, as this will detect a break if there's a while loop
-            // or a for loop inside the expression.
-            _ => {
-                if utils::in_macro(ex.span) {
-                    self.seen_return_break_continue = true;
-                } else {
-                    rustc_hir::intravisit::walk_expr(self, ex);
-                }
-            },
-        }
-    }
-}
-
-fn contains_return_break_continue_macro(expression: &Expr<'_>) -> bool {
-    let mut recursive_visitor = ReturnBreakContinueMacroVisitor::new();
-    recursive_visitor.visit_expr(expression);
-    recursive_visitor.seen_return_break_continue
-}
-
 /// Extracts the body of a given arm. If the arm contains only an expression,
 /// then it returns the expression. Otherwise, it returns the entire block
 fn extract_body_from_arm<'a>(arm: &'a Arm<'a>) -> Option<&'a Expr<'a>> {
@@ -208,8 +159,8 @@ fn detect_option_if_let_else<'tcx>(
         if let PatKind::TupleStruct(struct_qpath, &[inner_pat], _) = &arms[0].pat.kind;
         if utils::match_qpath(struct_qpath, &paths::OPTION_SOME);
         if let PatKind::Binding(bind_annotation, _, id, _) = &inner_pat.kind;
-        if !contains_return_break_continue_macro(arms[0].body);
-        if !contains_return_break_continue_macro(arms[1].body);
+        if !utils::usage::contains_return_break_continue_macro(arms[0].body);
+        if !utils::usage::contains_return_break_continue_macro(arms[1].body);
         then {
             let capture_mut = if bind_annotation == &BindingAnnotation::Mutable { "mut " } else { "" };
             let some_body = extract_body_from_arm(&arms[0])?;
diff --git a/clippy_lints/src/utils/eager_or_lazy.rs b/clippy_lints/src/utils/eager_or_lazy.rs
index 6938d9971d9..30e812c284b 100644
--- a/clippy_lints/src/utils/eager_or_lazy.rs
+++ b/clippy_lints/src/utils/eager_or_lazy.rs
@@ -82,7 +82,7 @@ fn identify_some_pure_patterns(expr: &Expr<'_>) -> bool {
 /// Identify some potentially computationally expensive patterns.
 /// This function is named so to stress that its implementation is non-exhaustive.
 /// It returns FNs and FPs.
-fn identify_some_potentially_expensive_patterns<'a, 'tcx>(cx: &'a LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
+fn identify_some_potentially_expensive_patterns<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
     // Searches an expression for method calls or function calls that aren't ctors
     struct FunCallFinder<'a, 'tcx> {
         cx: &'a LateContext<'tcx>,
diff --git a/clippy_lints/src/utils/usage.rs b/clippy_lints/src/utils/usage.rs
index ea1dc3be29b..2fd6046ebcf 100644
--- a/clippy_lints/src/utils/usage.rs
+++ b/clippy_lints/src/utils/usage.rs
@@ -1,10 +1,11 @@
+use crate::utils;
 use crate::utils::match_var;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_hir as hir;
 use rustc_hir::def::Res;
 use rustc_hir::intravisit;
 use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
-use rustc_hir::{Expr, HirId, Path};
+use rustc_hir::{Expr, ExprKind, HirId, Path};
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::LateContext;
 use rustc_middle::hir::map::Map;
@@ -174,3 +175,50 @@ impl<'a, 'tcx> intravisit::Visitor<'tcx> for BindingUsageFinder<'a, 'tcx> {
         intravisit::NestedVisitorMap::OnlyBodies(self.cx.tcx.hir())
     }
 }
+
+struct ReturnBreakContinueMacroVisitor {
+    seen_return_break_continue: bool,
+}
+
+impl ReturnBreakContinueMacroVisitor {
+    fn new() -> ReturnBreakContinueMacroVisitor {
+        ReturnBreakContinueMacroVisitor {
+            seen_return_break_continue: false,
+        }
+    }
+}
+
+impl<'tcx> Visitor<'tcx> for ReturnBreakContinueMacroVisitor {
+    type Map = Map<'tcx>;
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::None
+    }
+
+    fn visit_expr(&mut self, ex: &'tcx Expr<'tcx>) {
+        if self.seen_return_break_continue {
+            // No need to look farther if we've already seen one of them
+            return;
+        }
+        match &ex.kind {
+            ExprKind::Ret(..) | ExprKind::Break(..) | ExprKind::Continue(..) => {
+                self.seen_return_break_continue = true;
+            },
+            // Something special could be done here to handle while or for loop
+            // desugaring, as this will detect a break if there's a while loop
+            // or a for loop inside the expression.
+            _ => {
+                if utils::in_macro(ex.span) {
+                    self.seen_return_break_continue = true;
+                } else {
+                    rustc_hir::intravisit::walk_expr(self, ex);
+                }
+            },
+        }
+    }
+}
+
+pub fn contains_return_break_continue_macro(expression: &Expr<'_>) -> bool {
+    let mut recursive_visitor = ReturnBreakContinueMacroVisitor::new();
+    recursive_visitor.visit_expr(expression);
+    recursive_visitor.seen_return_break_continue
+}
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index 624223ff706..6dc95fcfdb2 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -1075,6 +1075,13 @@ vec![
         deprecation: None,
         module: "len_zero",
     },
+    Lint {
+        name: "less_concise_than_option_unwrap_or",
+        group: "pedantic",
+        desc: "finds patterns that can be encoded more concisely with `Option::unwrap_or`",
+        deprecation: None,
+        module: "less_concise_than",
+    },
     Lint {
         name: "let_and_return",
         group: "style",
diff --git a/tests/ui/less_concise_than.fixed b/tests/ui/less_concise_than.fixed
new file mode 100644
index 00000000000..52b69ebba3e
--- /dev/null
+++ b/tests/ui/less_concise_than.fixed
@@ -0,0 +1,43 @@
+// run-rustfix
+#![warn(clippy::less_concise_than_option_unwrap_or)]
+#![allow(dead_code)]
+
+fn unwrap_or() {
+    // int case
+    Some(1).unwrap_or(42);
+
+    // richer none expr
+    Some(1).unwrap_or_else(|| 1 + 42);
+
+    // multiline case
+    Some(1).unwrap_or_else(|| {
+        let a = 1 + 42;
+        let b = a + 42;
+        b + 42
+    });
+
+    // string case
+    Some("Bob").unwrap_or("Alice");
+
+    // don't lint
+    match Some(1) {
+        Some(i) => i + 2,
+        None => 42,
+    };
+    match Some(1) {
+        Some(i) => i,
+        None => return,
+    };
+    for j in 0..4 {
+        match Some(j) {
+            Some(i) => i,
+            None => continue,
+        };
+        match Some(j) {
+            Some(i) => i,
+            None => break,
+        };
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/less_concise_than.rs b/tests/ui/less_concise_than.rs
new file mode 100644
index 00000000000..bb2a8f2050a
--- /dev/null
+++ b/tests/ui/less_concise_than.rs
@@ -0,0 +1,55 @@
+// run-rustfix
+#![warn(clippy::less_concise_than_option_unwrap_or)]
+#![allow(dead_code)]
+
+fn unwrap_or() {
+    // int case
+    match Some(1) {
+        Some(i) => i,
+        None => 42,
+    };
+
+    // richer none expr
+    match Some(1) {
+        Some(i) => i,
+        None => 1 + 42,
+    };
+
+    // multiline case
+    match Some(1) {
+        Some(i) => i,
+        None => {
+            let a = 1 + 42;
+            let b = a + 42;
+            b + 42
+        },
+    };
+
+    // string case
+    match Some("Bob") {
+        Some(i) => i,
+        None => "Alice",
+    };
+
+    // don't lint
+    match Some(1) {
+        Some(i) => i + 2,
+        None => 42,
+    };
+    match Some(1) {
+        Some(i) => i,
+        None => return,
+    };
+    for j in 0..4 {
+        match Some(j) {
+            Some(i) => i,
+            None => continue,
+        };
+        match Some(j) {
+            Some(i) => i,
+            None => break,
+        };
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/less_concise_than.stderr b/tests/ui/less_concise_than.stderr
new file mode 100644
index 00000000000..e3e8a406db1
--- /dev/null
+++ b/tests/ui/less_concise_than.stderr
@@ -0,0 +1,52 @@
+error: this pattern can be more concisely encoded with `Option::unwrap_or`
+  --> $DIR/less_concise_than.rs:7:5
+   |
+LL | /     match Some(1) {
+LL | |         Some(i) => i,
+LL | |         None => 42,
+LL | |     };
+   | |_____^ help: replace with: `Some(1).unwrap_or(42)`
+   |
+   = note: `-D clippy::less-concise-than-option-unwrap-or` implied by `-D warnings`
+
+error: this pattern can be more concisely encoded with `Option::unwrap_or`
+  --> $DIR/less_concise_than.rs:13:5
+   |
+LL | /     match Some(1) {
+LL | |         Some(i) => i,
+LL | |         None => 1 + 42,
+LL | |     };
+   | |_____^ help: replace with: `Some(1).unwrap_or_else(|| 1 + 42)`
+
+error: this pattern can be more concisely encoded with `Option::unwrap_or`
+  --> $DIR/less_concise_than.rs:19:5
+   |
+LL | /     match Some(1) {
+LL | |         Some(i) => i,
+LL | |         None => {
+LL | |             let a = 1 + 42;
+...  |
+LL | |         },
+LL | |     };
+   | |_____^
+   |
+help: replace with
+   |
+LL |     Some(1).unwrap_or_else(|| {
+LL |         let a = 1 + 42;
+LL |         let b = a + 42;
+LL |         b + 42
+LL |     });
+   |
+
+error: this pattern can be more concisely encoded with `Option::unwrap_or`
+  --> $DIR/less_concise_than.rs:29:5
+   |
+LL | /     match Some("Bob") {
+LL | |         Some(i) => i,
+LL | |         None => "Alice",
+LL | |     };
+   | |_____^ help: replace with: `Some("Bob").unwrap_or("Alice")`
+
+error: aborting due to 4 previous errors
+
diff --git a/tests/ui/shadow.rs b/tests/ui/shadow.rs
index bd91ae4e934..e7441293d45 100644
--- a/tests/ui/shadow.rs
+++ b/tests/ui/shadow.rs
@@ -8,6 +8,7 @@
 #![allow(
     unused_parens,
     unused_variables,
+    clippy::less_concise_than_option_unwrap_or,
     clippy::missing_docs_in_private_items,
     clippy::single_match
 )]
diff --git a/tests/ui/shadow.stderr b/tests/ui/shadow.stderr
index 8a831375b41..7c1ad2949e9 100644
--- a/tests/ui/shadow.stderr
+++ b/tests/ui/shadow.stderr
@@ -1,135 +1,135 @@
 error: `x` is shadowed by itself in `&mut x`
-  --> $DIR/shadow.rs:26:5
+  --> $DIR/shadow.rs:27:5
    |
 LL |     let x = &mut x;
    |     ^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::shadow-same` implied by `-D warnings`
 note: previous binding is here
-  --> $DIR/shadow.rs:25:13
+  --> $DIR/shadow.rs:26:13
    |
 LL |     let mut x = 1;
    |             ^
 
 error: `x` is shadowed by itself in `{ x }`
-  --> $DIR/shadow.rs:27:5
+  --> $DIR/shadow.rs:28:5
    |
 LL |     let x = { x };
    |     ^^^^^^^^^^^^^^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:26:9
+  --> $DIR/shadow.rs:27:9
    |
 LL |     let x = &mut x;
    |         ^
 
 error: `x` is shadowed by itself in `(&*x)`
-  --> $DIR/shadow.rs:28:5
+  --> $DIR/shadow.rs:29:5
    |
 LL |     let x = (&*x);
    |     ^^^^^^^^^^^^^^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:27:9
+  --> $DIR/shadow.rs:28:9
    |
 LL |     let x = { x };
    |         ^
 
 error: `x` is shadowed by `{ *x + 1 }` which reuses the original value
-  --> $DIR/shadow.rs:29:9
+  --> $DIR/shadow.rs:30:9
    |
 LL |     let x = { *x + 1 };
    |         ^
    |
    = note: `-D clippy::shadow-reuse` implied by `-D warnings`
 note: initialization happens here
-  --> $DIR/shadow.rs:29:13
+  --> $DIR/shadow.rs:30:13
    |
 LL |     let x = { *x + 1 };
    |             ^^^^^^^^^^
 note: previous binding is here
-  --> $DIR/shadow.rs:28:9
+  --> $DIR/shadow.rs:29:9
    |
 LL |     let x = (&*x);
    |         ^
 
 error: `x` is shadowed by `id(x)` which reuses the original value
-  --> $DIR/shadow.rs:30:9
+  --> $DIR/shadow.rs:31:9
    |
 LL |     let x = id(x);
    |         ^
    |
 note: initialization happens here
-  --> $DIR/shadow.rs:30:13
+  --> $DIR/shadow.rs:31:13
    |
 LL |     let x = id(x);
    |             ^^^^^
 note: previous binding is here
-  --> $DIR/shadow.rs:29:9
+  --> $DIR/shadow.rs:30:9
    |
 LL |     let x = { *x + 1 };
    |         ^
 
 error: `x` is shadowed by `(1, x)` which reuses the original value
-  --> $DIR/shadow.rs:31:9
+  --> $DIR/shadow.rs:32:9
    |
 LL |     let x = (1, x);
    |         ^
    |
 note: initialization happens here
-  --> $DIR/shadow.rs:31:13
+  --> $DIR/shadow.rs:32:13
    |
 LL |     let x = (1, x);
    |             ^^^^^^
 note: previous binding is here
-  --> $DIR/shadow.rs:30:9
+  --> $DIR/shadow.rs:31:9
    |
 LL |     let x = id(x);
    |         ^
 
 error: `x` is shadowed by `first(x)` which reuses the original value
-  --> $DIR/shadow.rs:32:9
+  --> $DIR/shadow.rs:33:9
    |
 LL |     let x = first(x);
    |         ^
    |
 note: initialization happens here
-  --> $DIR/shadow.rs:32:13
+  --> $DIR/shadow.rs:33:13
    |
 LL |     let x = first(x);
    |             ^^^^^^^^
 note: previous binding is here
-  --> $DIR/shadow.rs:31:9
+  --> $DIR/shadow.rs:32:9
    |
 LL |     let x = (1, x);
    |         ^
 
 error: `x` is being shadowed
-  --> $DIR/shadow.rs:34:9
+  --> $DIR/shadow.rs:35:9
    |
 LL |     let x = y;
    |         ^
    |
    = note: `-D clippy::shadow-unrelated` implied by `-D warnings`
 note: initialization happens here
-  --> $DIR/shadow.rs:34:13
+  --> $DIR/shadow.rs:35:13
    |
 LL |     let x = y;
    |             ^
 note: previous binding is here
-  --> $DIR/shadow.rs:32:9
+  --> $DIR/shadow.rs:33:9
    |
 LL |     let x = first(x);
    |         ^
 
 error: `x` shadows a previous declaration
-  --> $DIR/shadow.rs:36:5
+  --> $DIR/shadow.rs:37:5
    |
 LL |     let x;
    |     ^^^^^^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:34:9
+  --> $DIR/shadow.rs:35:9
    |
 LL |     let x = y;
    |         ^
-- 
cgit 1.4.1-3-g733a5


From 9c9327980becadc15a68307705b3a06c28116ae1 Mon Sep 17 00:00:00 2001
From: Tim Nielens <tim.nielens@gmail.com>
Date: Sun, 11 Oct 2020 22:42:45 +0200
Subject: manual-unwrap-or / rename files

---
 clippy_lints/src/less_concise_than.rs | 107 ----------------------------------
 clippy_lints/src/manual_unwrap_or.rs  | 107 ++++++++++++++++++++++++++++++++++
 2 files changed, 107 insertions(+), 107 deletions(-)
 delete mode 100644 clippy_lints/src/less_concise_than.rs
 create mode 100644 clippy_lints/src/manual_unwrap_or.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/less_concise_than.rs b/clippy_lints/src/less_concise_than.rs
deleted file mode 100644
index 097aff4b178..00000000000
--- a/clippy_lints/src/less_concise_than.rs
+++ /dev/null
@@ -1,107 +0,0 @@
-use crate::utils;
-use if_chain::if_chain;
-use rustc_errors::Applicability;
-use rustc_hir::{def, Arm, Expr, ExprKind, PatKind, QPath};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-
-declare_clippy_lint! {
-    /// **What it does:**
-    /// Finds patterns that can be encoded more concisely with `Option::unwrap_or`.
-    ///
-    /// **Why is this bad?**
-    /// Concise code helps focusing on behavior instead of boilerplate.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    /// ```rust
-    /// match int_optional {
-    ///     Some(v) => v,
-    ///     None => 1,
-    /// }
-    /// ```
-    ///
-    /// Use instead:
-    /// ```rust
-    /// int_optional.unwrap_or(1)
-    /// ```
-    pub LESS_CONCISE_THAN_OPTION_UNWRAP_OR,
-    pedantic,
-    "finds patterns that can be encoded more concisely with `Option::unwrap_or`"
-}
-
-declare_lint_pass!(LessConciseThan => [LESS_CONCISE_THAN_OPTION_UNWRAP_OR]);
-
-impl LateLintPass<'_> for LessConciseThan {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
-        if utils::in_macro(expr.span) {
-            return;
-        }
-        if lint_option_unwrap_or_case(cx, expr) {
-            return;
-        }
-    }
-}
-
-fn lint_option_unwrap_or_case<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
-    #[allow(clippy::needless_bool)]
-    fn applicable_none_arm<'a>(arms: &'a [Arm<'a>]) -> Option<&'a Arm<'a>> {
-        if_chain! {
-            if arms.len() == 2;
-            if arms.iter().all(|arm| arm.guard.is_none());
-            if let Some((idx, none_arm)) = arms.iter().enumerate().find(|(_, arm)|
-               if_chain! {
-                    if let PatKind::Path(ref qpath) = arm.pat.kind;
-                    if utils::match_qpath(qpath, &utils::paths::OPTION_NONE);
-                    then { true }
-                    else { false }
-               }
-            );
-            let some_arm = &arms[1 - idx];
-            if let PatKind::TupleStruct(ref some_qpath, &[some_binding], _) = some_arm.pat.kind;
-            if utils::match_qpath(some_qpath, &utils::paths::OPTION_SOME);
-            if let PatKind::Binding(_, binding_hir_id, ..) = some_binding.kind;
-            if let ExprKind::Path(QPath::Resolved(_, body_path)) = some_arm.body.kind;
-            if let def::Res::Local(body_path_hir_id) = body_path.res;
-            if body_path_hir_id == binding_hir_id;
-            then { Some(none_arm) }
-            else { None }
-        }
-    }
-    if_chain! {
-      if !utils::usage::contains_return_break_continue_macro(expr);
-      if let ExprKind::Match (match_expr, match_arms, _) = expr.kind;
-      let ty = cx.typeck_results().expr_ty(match_expr);
-      if utils::is_type_diagnostic_item(cx, ty, sym!(option_type));
-      if let Some(none_arm) = applicable_none_arm(match_arms);
-      if let Some(match_expr_snippet) = utils::snippet_opt(cx, match_expr.span);
-      if let Some(none_body_snippet) = utils::snippet_opt(cx, none_arm.body.span);
-      if let Some(indent) = utils::indent_of(cx, expr.span);
-      then {
-          let reindented_none_body =
-              utils::reindent_multiline(none_body_snippet.into(), true, Some(indent));
-          let eager_eval = utils::eager_or_lazy::is_eagerness_candidate(cx, none_arm.body);
-          let method = if eager_eval {
-              "unwrap_or"
-          } else {
-              "unwrap_or_else"
-          };
-          utils::span_lint_and_sugg(
-              cx,
-              LESS_CONCISE_THAN_OPTION_UNWRAP_OR, expr.span,
-              "this pattern can be more concisely encoded with `Option::unwrap_or`",
-              "replace with",
-              format!(
-                  "{}.{}({}{})",
-                  match_expr_snippet,
-                  method,
-                  if eager_eval { ""} else { "|| " },
-                  reindented_none_body
-              ),
-              Applicability::MachineApplicable,
-          );
-          true
-      } else { false}
-    }
-}
diff --git a/clippy_lints/src/manual_unwrap_or.rs b/clippy_lints/src/manual_unwrap_or.rs
new file mode 100644
index 00000000000..097aff4b178
--- /dev/null
+++ b/clippy_lints/src/manual_unwrap_or.rs
@@ -0,0 +1,107 @@
+use crate::utils;
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir::{def, Arm, Expr, ExprKind, PatKind, QPath};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// **What it does:**
+    /// Finds patterns that can be encoded more concisely with `Option::unwrap_or`.
+    ///
+    /// **Why is this bad?**
+    /// Concise code helps focusing on behavior instead of boilerplate.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// ```rust
+    /// match int_optional {
+    ///     Some(v) => v,
+    ///     None => 1,
+    /// }
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust
+    /// int_optional.unwrap_or(1)
+    /// ```
+    pub LESS_CONCISE_THAN_OPTION_UNWRAP_OR,
+    pedantic,
+    "finds patterns that can be encoded more concisely with `Option::unwrap_or`"
+}
+
+declare_lint_pass!(LessConciseThan => [LESS_CONCISE_THAN_OPTION_UNWRAP_OR]);
+
+impl LateLintPass<'_> for LessConciseThan {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
+        if utils::in_macro(expr.span) {
+            return;
+        }
+        if lint_option_unwrap_or_case(cx, expr) {
+            return;
+        }
+    }
+}
+
+fn lint_option_unwrap_or_case<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
+    #[allow(clippy::needless_bool)]
+    fn applicable_none_arm<'a>(arms: &'a [Arm<'a>]) -> Option<&'a Arm<'a>> {
+        if_chain! {
+            if arms.len() == 2;
+            if arms.iter().all(|arm| arm.guard.is_none());
+            if let Some((idx, none_arm)) = arms.iter().enumerate().find(|(_, arm)|
+               if_chain! {
+                    if let PatKind::Path(ref qpath) = arm.pat.kind;
+                    if utils::match_qpath(qpath, &utils::paths::OPTION_NONE);
+                    then { true }
+                    else { false }
+               }
+            );
+            let some_arm = &arms[1 - idx];
+            if let PatKind::TupleStruct(ref some_qpath, &[some_binding], _) = some_arm.pat.kind;
+            if utils::match_qpath(some_qpath, &utils::paths::OPTION_SOME);
+            if let PatKind::Binding(_, binding_hir_id, ..) = some_binding.kind;
+            if let ExprKind::Path(QPath::Resolved(_, body_path)) = some_arm.body.kind;
+            if let def::Res::Local(body_path_hir_id) = body_path.res;
+            if body_path_hir_id == binding_hir_id;
+            then { Some(none_arm) }
+            else { None }
+        }
+    }
+    if_chain! {
+      if !utils::usage::contains_return_break_continue_macro(expr);
+      if let ExprKind::Match (match_expr, match_arms, _) = expr.kind;
+      let ty = cx.typeck_results().expr_ty(match_expr);
+      if utils::is_type_diagnostic_item(cx, ty, sym!(option_type));
+      if let Some(none_arm) = applicable_none_arm(match_arms);
+      if let Some(match_expr_snippet) = utils::snippet_opt(cx, match_expr.span);
+      if let Some(none_body_snippet) = utils::snippet_opt(cx, none_arm.body.span);
+      if let Some(indent) = utils::indent_of(cx, expr.span);
+      then {
+          let reindented_none_body =
+              utils::reindent_multiline(none_body_snippet.into(), true, Some(indent));
+          let eager_eval = utils::eager_or_lazy::is_eagerness_candidate(cx, none_arm.body);
+          let method = if eager_eval {
+              "unwrap_or"
+          } else {
+              "unwrap_or_else"
+          };
+          utils::span_lint_and_sugg(
+              cx,
+              LESS_CONCISE_THAN_OPTION_UNWRAP_OR, expr.span,
+              "this pattern can be more concisely encoded with `Option::unwrap_or`",
+              "replace with",
+              format!(
+                  "{}.{}({}{})",
+                  match_expr_snippet,
+                  method,
+                  if eager_eval { ""} else { "|| " },
+                  reindented_none_body
+              ),
+              Applicability::MachineApplicable,
+          );
+          true
+      } else { false}
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 6d4eeeabcda6d6d25738e1e8e2b64580daefc4b9 Mon Sep 17 00:00:00 2001
From: Tim Nielens <tim.nielens@gmail.com>
Date: Sun, 11 Oct 2020 22:55:05 +0200
Subject: manual-unwrap-or / pr remarks

---
 CHANGELOG.md                         |   2 +-
 clippy_lints/src/lib.rs              |   9 +--
 clippy_lints/src/manual_unwrap_or.rs | 113 ++++++++++++++++++-----------------
 src/lintlist/mod.rs                  |  14 ++---
 tests/ui/less_concise_than.fixed     |  43 -------------
 tests/ui/less_concise_than.rs        |  55 -----------------
 tests/ui/less_concise_than.stderr    |  52 ----------------
 tests/ui/manual_unwrap_or.fixed      |  45 ++++++++++++++
 tests/ui/manual_unwrap_or.rs         |  60 +++++++++++++++++++
 tests/ui/manual_unwrap_or.stderr     |  61 +++++++++++++++++++
 tests/ui/shadow.rs                   |   2 +-
 11 files changed, 239 insertions(+), 217 deletions(-)
 delete mode 100644 tests/ui/less_concise_than.fixed
 delete mode 100644 tests/ui/less_concise_than.rs
 delete mode 100644 tests/ui/less_concise_than.stderr
 create mode 100644 tests/ui/manual_unwrap_or.fixed
 create mode 100644 tests/ui/manual_unwrap_or.rs
 create mode 100644 tests/ui/manual_unwrap_or.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 93ce6bb85d8..d82f970b8bf 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1781,7 +1781,6 @@ Released 2018-09-13
 [`large_stack_arrays`]: https://rust-lang.github.io/rust-clippy/master/index.html#large_stack_arrays
 [`len_without_is_empty`]: https://rust-lang.github.io/rust-clippy/master/index.html#len_without_is_empty
 [`len_zero`]: https://rust-lang.github.io/rust-clippy/master/index.html#len_zero
-[`less_concise_than_option_unwrap_or`]: https://rust-lang.github.io/rust-clippy/master/index.html#less_concise_than_option_unwrap_or
 [`let_and_return`]: https://rust-lang.github.io/rust-clippy/master/index.html#let_and_return
 [`let_underscore_lock`]: https://rust-lang.github.io/rust-clippy/master/index.html#let_underscore_lock
 [`let_underscore_must_use`]: https://rust-lang.github.io/rust-clippy/master/index.html#let_underscore_must_use
@@ -1797,6 +1796,7 @@ Released 2018-09-13
 [`manual_saturating_arithmetic`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_saturating_arithmetic
 [`manual_strip`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_strip
 [`manual_swap`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_swap
+[`manual_unwrap_or`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_unwrap_or
 [`many_single_char_names`]: https://rust-lang.github.io/rust-clippy/master/index.html#many_single_char_names
 [`map_clone`]: https://rust-lang.github.io/rust-clippy/master/index.html#map_clone
 [`map_entry`]: https://rust-lang.github.io/rust-clippy/master/index.html#map_entry
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 2e9900815d9..d4d2f92a6a6 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -224,7 +224,6 @@ mod large_const_arrays;
 mod large_enum_variant;
 mod large_stack_arrays;
 mod len_zero;
-mod less_concise_than;
 mod let_if_seq;
 mod let_underscore;
 mod lifetimes;
@@ -235,6 +234,7 @@ mod main_recursion;
 mod manual_async_fn;
 mod manual_non_exhaustive;
 mod manual_strip;
+mod manual_unwrap_or;
 mod map_clone;
 mod map_err_ignore;
 mod map_identity;
@@ -610,7 +610,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &large_stack_arrays::LARGE_STACK_ARRAYS,
         &len_zero::LEN_WITHOUT_IS_EMPTY,
         &len_zero::LEN_ZERO,
-        &less_concise_than::LESS_CONCISE_THAN_OPTION_UNWRAP_OR,
         &let_if_seq::USELESS_LET_IF_SEQ,
         &let_underscore::LET_UNDERSCORE_LOCK,
         &let_underscore::LET_UNDERSCORE_MUST_USE,
@@ -642,6 +641,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &manual_async_fn::MANUAL_ASYNC_FN,
         &manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE,
         &manual_strip::MANUAL_STRIP,
+        &manual_unwrap_or::MANUAL_UNWRAP_OR,
         &map_clone::MAP_CLONE,
         &map_err_ignore::MAP_ERR_IGNORE,
         &map_identity::MAP_IDENTITY,
@@ -1128,7 +1128,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box repeat_once::RepeatOnce);
     store.register_late_pass(|| box unwrap_in_result::UnwrapInResult);
     store.register_late_pass(|| box self_assignment::SelfAssignment);
-    store.register_late_pass(|| box less_concise_than::LessConciseThan);
+    store.register_late_pass(|| box manual_unwrap_or::ManualUnwrapOr);
     store.register_late_pass(|| box float_equality_without_abs::FloatEqualityWithoutAbs);
     store.register_late_pass(|| box async_yields_async::AsyncYieldsAsync);
     store.register_late_pass(|| box manual_strip::ManualStrip);
@@ -1213,7 +1213,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&infinite_iter::MAYBE_INFINITE_ITER),
         LintId::of(&items_after_statements::ITEMS_AFTER_STATEMENTS),
         LintId::of(&large_stack_arrays::LARGE_STACK_ARRAYS),
-        LintId::of(&less_concise_than::LESS_CONCISE_THAN_OPTION_UNWRAP_OR),
         LintId::of(&literal_representation::LARGE_DIGIT_GROUPS),
         LintId::of(&literal_representation::UNREADABLE_LITERAL),
         LintId::of(&loops::EXPLICIT_INTO_ITER_LOOP),
@@ -1371,6 +1370,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&manual_async_fn::MANUAL_ASYNC_FN),
         LintId::of(&manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE),
         LintId::of(&manual_strip::MANUAL_STRIP),
+        LintId::of(&manual_unwrap_or::MANUAL_UNWRAP_OR),
         LintId::of(&map_clone::MAP_CLONE),
         LintId::of(&map_identity::MAP_IDENTITY),
         LintId::of(&map_unit_fn::OPTION_MAP_UNIT_FN),
@@ -1666,6 +1666,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&loops::MUT_RANGE_BOUND),
         LintId::of(&loops::WHILE_LET_LOOP),
         LintId::of(&manual_strip::MANUAL_STRIP),
+        LintId::of(&manual_unwrap_or::MANUAL_UNWRAP_OR),
         LintId::of(&map_identity::MAP_IDENTITY),
         LintId::of(&map_unit_fn::OPTION_MAP_UNIT_FN),
         LintId::of(&map_unit_fn::RESULT_MAP_UNIT_FN),
diff --git a/clippy_lints/src/manual_unwrap_or.rs b/clippy_lints/src/manual_unwrap_or.rs
index 097aff4b178..9d8fc863424 100644
--- a/clippy_lints/src/manual_unwrap_or.rs
+++ b/clippy_lints/src/manual_unwrap_or.rs
@@ -2,12 +2,14 @@ use crate::utils;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{def, Arm, Expr, ExprKind, PatKind, QPath};
+use rustc_lint::LintContext;
 use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
     /// **What it does:**
-    /// Finds patterns that can be encoded more concisely with `Option::unwrap_or`.
+    /// Finds patterns that reimplement `Option::unwrap_or`.
     ///
     /// **Why is this bad?**
     /// Concise code helps focusing on behavior instead of boilerplate.
@@ -16,7 +18,7 @@ declare_clippy_lint! {
     ///
     /// **Example:**
     /// ```rust
-    /// match int_optional {
+    /// match int_option {
     ///     Some(v) => v,
     ///     None => 1,
     /// }
@@ -24,39 +26,35 @@ declare_clippy_lint! {
     ///
     /// Use instead:
     /// ```rust
-    /// int_optional.unwrap_or(1)
+    /// int_option.unwrap_or(1)
     /// ```
-    pub LESS_CONCISE_THAN_OPTION_UNWRAP_OR,
-    pedantic,
-    "finds patterns that can be encoded more concisely with `Option::unwrap_or`"
+    pub MANUAL_UNWRAP_OR,
+    complexity,
+    "finds patterns that can be encoded more concisely with `Option::unwrap_or(_else)`"
 }
 
-declare_lint_pass!(LessConciseThan => [LESS_CONCISE_THAN_OPTION_UNWRAP_OR]);
+declare_lint_pass!(ManualUnwrapOr => [MANUAL_UNWRAP_OR]);
 
-impl LateLintPass<'_> for LessConciseThan {
+impl LateLintPass<'_> for ManualUnwrapOr {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
-        if utils::in_macro(expr.span) {
-            return;
-        }
-        if lint_option_unwrap_or_case(cx, expr) {
+        if in_external_macro(cx.sess(), expr.span) {
             return;
         }
+        lint_option_unwrap_or_case(cx, expr);
     }
 }
 
 fn lint_option_unwrap_or_case<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
-    #[allow(clippy::needless_bool)]
     fn applicable_none_arm<'a>(arms: &'a [Arm<'a>]) -> Option<&'a Arm<'a>> {
         if_chain! {
             if arms.len() == 2;
             if arms.iter().all(|arm| arm.guard.is_none());
             if let Some((idx, none_arm)) = arms.iter().enumerate().find(|(_, arm)|
-               if_chain! {
-                    if let PatKind::Path(ref qpath) = arm.pat.kind;
-                    if utils::match_qpath(qpath, &utils::paths::OPTION_NONE);
-                    then { true }
-                    else { false }
-               }
+                if let PatKind::Path(ref qpath) = arm.pat.kind {
+                    utils::match_qpath(qpath, &utils::paths::OPTION_NONE)
+                } else {
+                    false
+                }
             );
             let some_arm = &arms[1 - idx];
             if let PatKind::TupleStruct(ref some_qpath, &[some_binding], _) = some_arm.pat.kind;
@@ -65,43 +63,50 @@ fn lint_option_unwrap_or_case<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tc
             if let ExprKind::Path(QPath::Resolved(_, body_path)) = some_arm.body.kind;
             if let def::Res::Local(body_path_hir_id) = body_path.res;
             if body_path_hir_id == binding_hir_id;
-            then { Some(none_arm) }
-            else { None }
+            if !utils::usage::contains_return_break_continue_macro(none_arm.body);
+            then {
+                Some(none_arm)
+            }
+            else {
+                None
+            }
         }
     }
+
     if_chain! {
-      if !utils::usage::contains_return_break_continue_macro(expr);
-      if let ExprKind::Match (match_expr, match_arms, _) = expr.kind;
-      let ty = cx.typeck_results().expr_ty(match_expr);
-      if utils::is_type_diagnostic_item(cx, ty, sym!(option_type));
-      if let Some(none_arm) = applicable_none_arm(match_arms);
-      if let Some(match_expr_snippet) = utils::snippet_opt(cx, match_expr.span);
-      if let Some(none_body_snippet) = utils::snippet_opt(cx, none_arm.body.span);
-      if let Some(indent) = utils::indent_of(cx, expr.span);
-      then {
-          let reindented_none_body =
-              utils::reindent_multiline(none_body_snippet.into(), true, Some(indent));
-          let eager_eval = utils::eager_or_lazy::is_eagerness_candidate(cx, none_arm.body);
-          let method = if eager_eval {
-              "unwrap_or"
-          } else {
-              "unwrap_or_else"
-          };
-          utils::span_lint_and_sugg(
-              cx,
-              LESS_CONCISE_THAN_OPTION_UNWRAP_OR, expr.span,
-              "this pattern can be more concisely encoded with `Option::unwrap_or`",
-              "replace with",
-              format!(
-                  "{}.{}({}{})",
-                  match_expr_snippet,
-                  method,
-                  if eager_eval { ""} else { "|| " },
-                  reindented_none_body
-              ),
-              Applicability::MachineApplicable,
-          );
-          true
-      } else { false}
+        if let ExprKind::Match(scrutinee, match_arms, _) = expr.kind;
+        let ty = cx.typeck_results().expr_ty(scrutinee);
+        if utils::is_type_diagnostic_item(cx, ty, sym!(option_type));
+        if let Some(none_arm) = applicable_none_arm(match_arms);
+        if let Some(scrutinee_snippet) = utils::snippet_opt(cx, scrutinee.span);
+        if let Some(none_body_snippet) = utils::snippet_opt(cx, none_arm.body.span);
+        if let Some(indent) = utils::indent_of(cx, expr.span);
+        then {
+            let reindented_none_body =
+                utils::reindent_multiline(none_body_snippet.into(), true, Some(indent));
+            let eager_eval = utils::eager_or_lazy::is_eagerness_candidate(cx, none_arm.body);
+            let method = if eager_eval {
+                "unwrap_or"
+            } else {
+                "unwrap_or_else"
+            };
+            utils::span_lint_and_sugg(
+                cx,
+                MANUAL_UNWRAP_OR, expr.span,
+                &format!("this pattern reimplements `Option::{}`", &method),
+                "replace with",
+                format!(
+                    "{}.{}({}{})",
+                    scrutinee_snippet,
+                    method,
+                    if eager_eval { ""} else { "|| " },
+                    reindented_none_body
+                ),
+                Applicability::MachineApplicable,
+            );
+            true
+        } else {
+            false
+        }
     }
 }
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index 6dc95fcfdb2..debd3c31d8b 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -1075,13 +1075,6 @@ vec![
         deprecation: None,
         module: "len_zero",
     },
-    Lint {
-        name: "less_concise_than_option_unwrap_or",
-        group: "pedantic",
-        desc: "finds patterns that can be encoded more concisely with `Option::unwrap_or`",
-        deprecation: None,
-        module: "less_concise_than",
-    },
     Lint {
         name: "let_and_return",
         group: "style",
@@ -1187,6 +1180,13 @@ vec![
         deprecation: None,
         module: "swap",
     },
+    Lint {
+        name: "manual_unwrap_or",
+        group: "complexity",
+        desc: "finds patterns that can be encoded more concisely with `Option::unwrap_or(_else)`",
+        deprecation: None,
+        module: "manual_unwrap_or",
+    },
     Lint {
         name: "many_single_char_names",
         group: "style",
diff --git a/tests/ui/less_concise_than.fixed b/tests/ui/less_concise_than.fixed
deleted file mode 100644
index 52b69ebba3e..00000000000
--- a/tests/ui/less_concise_than.fixed
+++ /dev/null
@@ -1,43 +0,0 @@
-// run-rustfix
-#![warn(clippy::less_concise_than_option_unwrap_or)]
-#![allow(dead_code)]
-
-fn unwrap_or() {
-    // int case
-    Some(1).unwrap_or(42);
-
-    // richer none expr
-    Some(1).unwrap_or_else(|| 1 + 42);
-
-    // multiline case
-    Some(1).unwrap_or_else(|| {
-        let a = 1 + 42;
-        let b = a + 42;
-        b + 42
-    });
-
-    // string case
-    Some("Bob").unwrap_or("Alice");
-
-    // don't lint
-    match Some(1) {
-        Some(i) => i + 2,
-        None => 42,
-    };
-    match Some(1) {
-        Some(i) => i,
-        None => return,
-    };
-    for j in 0..4 {
-        match Some(j) {
-            Some(i) => i,
-            None => continue,
-        };
-        match Some(j) {
-            Some(i) => i,
-            None => break,
-        };
-    }
-}
-
-fn main() {}
diff --git a/tests/ui/less_concise_than.rs b/tests/ui/less_concise_than.rs
deleted file mode 100644
index bb2a8f2050a..00000000000
--- a/tests/ui/less_concise_than.rs
+++ /dev/null
@@ -1,55 +0,0 @@
-// run-rustfix
-#![warn(clippy::less_concise_than_option_unwrap_or)]
-#![allow(dead_code)]
-
-fn unwrap_or() {
-    // int case
-    match Some(1) {
-        Some(i) => i,
-        None => 42,
-    };
-
-    // richer none expr
-    match Some(1) {
-        Some(i) => i,
-        None => 1 + 42,
-    };
-
-    // multiline case
-    match Some(1) {
-        Some(i) => i,
-        None => {
-            let a = 1 + 42;
-            let b = a + 42;
-            b + 42
-        },
-    };
-
-    // string case
-    match Some("Bob") {
-        Some(i) => i,
-        None => "Alice",
-    };
-
-    // don't lint
-    match Some(1) {
-        Some(i) => i + 2,
-        None => 42,
-    };
-    match Some(1) {
-        Some(i) => i,
-        None => return,
-    };
-    for j in 0..4 {
-        match Some(j) {
-            Some(i) => i,
-            None => continue,
-        };
-        match Some(j) {
-            Some(i) => i,
-            None => break,
-        };
-    }
-}
-
-fn main() {}
diff --git a/tests/ui/less_concise_than.stderr b/tests/ui/less_concise_than.stderr
deleted file mode 100644
index e3e8a406db1..00000000000
--- a/tests/ui/less_concise_than.stderr
+++ /dev/null
@@ -1,52 +0,0 @@
-error: this pattern can be more concisely encoded with `Option::unwrap_or`
-  --> $DIR/less_concise_than.rs:7:5
-   |
-LL | /     match Some(1) {
-LL | |         Some(i) => i,
-LL | |         None => 42,
-LL | |     };
-   | |_____^ help: replace with: `Some(1).unwrap_or(42)`
-   |
-   = note: `-D clippy::less-concise-than-option-unwrap-or` implied by `-D warnings`
-
-error: this pattern can be more concisely encoded with `Option::unwrap_or`
-  --> $DIR/less_concise_than.rs:13:5
-   |
-LL | /     match Some(1) {
-LL | |         Some(i) => i,
-LL | |         None => 1 + 42,
-LL | |     };
-   | |_____^ help: replace with: `Some(1).unwrap_or_else(|| 1 + 42)`
-
-error: this pattern can be more concisely encoded with `Option::unwrap_or`
-  --> $DIR/less_concise_than.rs:19:5
-   |
-LL | /     match Some(1) {
-LL | |         Some(i) => i,
-LL | |         None => {
-LL | |             let a = 1 + 42;
-...  |
-LL | |         },
-LL | |     };
-   | |_____^
-   |
-help: replace with
-   |
-LL |     Some(1).unwrap_or_else(|| {
-LL |         let a = 1 + 42;
-LL |         let b = a + 42;
-LL |         b + 42
-LL |     });
-   |
-
-error: this pattern can be more concisely encoded with `Option::unwrap_or`
-  --> $DIR/less_concise_than.rs:29:5
-   |
-LL | /     match Some("Bob") {
-LL | |         Some(i) => i,
-LL | |         None => "Alice",
-LL | |     };
-   | |_____^ help: replace with: `Some("Bob").unwrap_or("Alice")`
-
-error: aborting due to 4 previous errors
-
diff --git a/tests/ui/manual_unwrap_or.fixed b/tests/ui/manual_unwrap_or.fixed
new file mode 100644
index 00000000000..99d30360db1
--- /dev/null
+++ b/tests/ui/manual_unwrap_or.fixed
@@ -0,0 +1,45 @@
+// run-rustfix
+#![allow(dead_code)]
+
+fn unwrap_or() {
+    // int case
+    Some(1).unwrap_or(42);
+
+    // int case reversed
+    Some(1).unwrap_or(42);
+
+    // richer none expr
+    Some(1).unwrap_or_else(|| 1 + 42);
+
+    // multiline case
+    Some(1).unwrap_or_else(|| {
+        let a = 1 + 42;
+        let b = a + 42;
+        b + 42
+    });
+
+    // string case
+    Some("Bob").unwrap_or("Alice");
+
+    // don't lint
+    match Some(1) {
+        Some(i) => i + 2,
+        None => 42,
+    };
+    match Some(1) {
+        Some(i) => i,
+        None => return,
+    };
+    for j in 0..4 {
+        match Some(j) {
+            Some(i) => i,
+            None => continue,
+        };
+        match Some(j) {
+            Some(i) => i,
+            None => break,
+        };
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/manual_unwrap_or.rs b/tests/ui/manual_unwrap_or.rs
new file mode 100644
index 00000000000..5d03d9db163
--- /dev/null
+++ b/tests/ui/manual_unwrap_or.rs
@@ -0,0 +1,60 @@
+// run-rustfix
+#![allow(dead_code)]
+
+fn unwrap_or() {
+    // int case
+    match Some(1) {
+        Some(i) => i,
+        None => 42,
+    };
+
+    // int case reversed
+    match Some(1) {
+        None => 42,
+        Some(i) => i,
+    };
+
+    // richer none expr
+    match Some(1) {
+        Some(i) => i,
+        None => 1 + 42,
+    };
+
+    // multiline case
+    match Some(1) {
+        Some(i) => i,
+        None => {
+            let a = 1 + 42;
+            let b = a + 42;
+            b + 42
+        },
+    };
+
+    // string case
+    match Some("Bob") {
+        Some(i) => i,
+        None => "Alice",
+    };
+
+    // don't lint
+    match Some(1) {
+        Some(i) => i + 2,
+        None => 42,
+    };
+    match Some(1) {
+        Some(i) => i,
+        None => return,
+    };
+    for j in 0..4 {
+        match Some(j) {
+            Some(i) => i,
+            None => continue,
+        };
+        match Some(j) {
+            Some(i) => i,
+            None => break,
+        };
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/manual_unwrap_or.stderr b/tests/ui/manual_unwrap_or.stderr
new file mode 100644
index 00000000000..03da118a0c4
--- /dev/null
+++ b/tests/ui/manual_unwrap_or.stderr
@@ -0,0 +1,61 @@
+error: this pattern reimplements `Option::unwrap_or`
+  --> $DIR/manual_unwrap_or.rs:6:5
+   |
+LL | /     match Some(1) {
+LL | |         Some(i) => i,
+LL | |         None => 42,
+LL | |     };
+   | |_____^ help: replace with: `Some(1).unwrap_or(42)`
+   |
+   = note: `-D clippy::manual-unwrap-or` implied by `-D warnings`
+
+error: this pattern reimplements `Option::unwrap_or`
+  --> $DIR/manual_unwrap_or.rs:12:5
+   |
+LL | /     match Some(1) {
+LL | |         None => 42,
+LL | |         Some(i) => i,
+LL | |     };
+   | |_____^ help: replace with: `Some(1).unwrap_or(42)`
+
+error: this pattern reimplements `Option::unwrap_or_else`
+  --> $DIR/manual_unwrap_or.rs:18:5
+   |
+LL | /     match Some(1) {
+LL | |         Some(i) => i,
+LL | |         None => 1 + 42,
+LL | |     };
+   | |_____^ help: replace with: `Some(1).unwrap_or_else(|| 1 + 42)`
+
+error: this pattern reimplements `Option::unwrap_or_else`
+  --> $DIR/manual_unwrap_or.rs:24:5
+   |
+LL | /     match Some(1) {
+LL | |         Some(i) => i,
+LL | |         None => {
+LL | |             let a = 1 + 42;
+...  |
+LL | |         },
+LL | |     };
+   | |_____^
+   |
+help: replace with
+   |
+LL |     Some(1).unwrap_or_else(|| {
+LL |         let a = 1 + 42;
+LL |         let b = a + 42;
+LL |         b + 42
+LL |     });
+   |
+
+error: this pattern reimplements `Option::unwrap_or`
+  --> $DIR/manual_unwrap_or.rs:34:5
+   |
+LL | /     match Some("Bob") {
+LL | |         Some(i) => i,
+LL | |         None => "Alice",
+LL | |     };
+   | |_____^ help: replace with: `Some("Bob").unwrap_or("Alice")`
+
+error: aborting due to 5 previous errors
+
diff --git a/tests/ui/shadow.rs b/tests/ui/shadow.rs
index e7441293d45..e366c75335c 100644
--- a/tests/ui/shadow.rs
+++ b/tests/ui/shadow.rs
@@ -8,7 +8,7 @@
 #![allow(
     unused_parens,
     unused_variables,
-    clippy::less_concise_than_option_unwrap_or,
+    clippy::manual_unwrap_or,
     clippy::missing_docs_in_private_items,
     clippy::single_match
 )]
-- 
cgit 1.4.1-3-g733a5


From fc846c37fcc720c4a5c2e2075102c1957433e703 Mon Sep 17 00:00:00 2001
From: Tim Nielens <tim.nielens@gmail.com>
Date: Mon, 12 Oct 2020 00:06:21 +0200
Subject: manual_unwrap_or / use consts::constant_simple helper

---
 clippy_lints/src/manual_unwrap_or.rs | 11 +++++++----
 tests/ui/manual_unwrap_or.fixed      |  2 +-
 tests/ui/manual_unwrap_or.stderr     |  4 ++--
 3 files changed, 10 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_unwrap_or.rs b/clippy_lints/src/manual_unwrap_or.rs
index 9d8fc863424..ced941fac1a 100644
--- a/clippy_lints/src/manual_unwrap_or.rs
+++ b/clippy_lints/src/manual_unwrap_or.rs
@@ -1,3 +1,4 @@
+use crate::consts::constant_simple;
 use crate::utils;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
@@ -18,15 +19,17 @@ declare_clippy_lint! {
     ///
     /// **Example:**
     /// ```rust
-    /// match int_option {
+    /// let foo: Option<i32> = None;
+    /// match foo {
     ///     Some(v) => v,
     ///     None => 1,
-    /// }
+    /// };
     /// ```
     ///
     /// Use instead:
     /// ```rust
-    /// int_option.unwrap_or(1)
+    /// let foo: Option<i32> = None;
+    /// foo.unwrap_or(1);
     /// ```
     pub MANUAL_UNWRAP_OR,
     complexity,
@@ -84,7 +87,7 @@ fn lint_option_unwrap_or_case<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tc
         then {
             let reindented_none_body =
                 utils::reindent_multiline(none_body_snippet.into(), true, Some(indent));
-            let eager_eval = utils::eager_or_lazy::is_eagerness_candidate(cx, none_arm.body);
+            let eager_eval = constant_simple(cx, cx.typeck_results(), none_arm.body).is_some();
             let method = if eager_eval {
                 "unwrap_or"
             } else {
diff --git a/tests/ui/manual_unwrap_or.fixed b/tests/ui/manual_unwrap_or.fixed
index 99d30360db1..a9cc8678c9d 100644
--- a/tests/ui/manual_unwrap_or.fixed
+++ b/tests/ui/manual_unwrap_or.fixed
@@ -9,7 +9,7 @@ fn unwrap_or() {
     Some(1).unwrap_or(42);
 
     // richer none expr
-    Some(1).unwrap_or_else(|| 1 + 42);
+    Some(1).unwrap_or(1 + 42);
 
     // multiline case
     Some(1).unwrap_or_else(|| {
diff --git a/tests/ui/manual_unwrap_or.stderr b/tests/ui/manual_unwrap_or.stderr
index 03da118a0c4..8f6835ed78d 100644
--- a/tests/ui/manual_unwrap_or.stderr
+++ b/tests/ui/manual_unwrap_or.stderr
@@ -18,14 +18,14 @@ LL | |         Some(i) => i,
 LL | |     };
    | |_____^ help: replace with: `Some(1).unwrap_or(42)`
 
-error: this pattern reimplements `Option::unwrap_or_else`
+error: this pattern reimplements `Option::unwrap_or`
   --> $DIR/manual_unwrap_or.rs:18:5
    |
 LL | /     match Some(1) {
 LL | |         Some(i) => i,
 LL | |         None => 1 + 42,
 LL | |     };
-   | |_____^ help: replace with: `Some(1).unwrap_or_else(|| 1 + 42)`
+   | |_____^ help: replace with: `Some(1).unwrap_or(1 + 42)`
 
 error: this pattern reimplements `Option::unwrap_or_else`
   --> $DIR/manual_unwrap_or.rs:24:5
-- 
cgit 1.4.1-3-g733a5


From a8fb69f065a427f5d3fc7222b834cad9a2a7a712 Mon Sep 17 00:00:00 2001
From: Tim Nielens <tim.nielens@gmail.com>
Date: Tue, 13 Oct 2020 10:24:00 +0200
Subject: manual-unwrap-or / more pr remarks

---
 clippy_lints/src/manual_unwrap_or.rs | 10 +++-------
 1 file changed, 3 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_unwrap_or.rs b/clippy_lints/src/manual_unwrap_or.rs
index ced941fac1a..719a8b91f66 100644
--- a/clippy_lints/src/manual_unwrap_or.rs
+++ b/clippy_lints/src/manual_unwrap_or.rs
@@ -47,7 +47,7 @@ impl LateLintPass<'_> for ManualUnwrapOr {
     }
 }
 
-fn lint_option_unwrap_or_case<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
+fn lint_option_unwrap_or_case<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
     fn applicable_none_arm<'a>(arms: &'a [Arm<'a>]) -> Option<&'a Arm<'a>> {
         if_chain! {
             if arms.len() == 2;
@@ -69,8 +69,7 @@ fn lint_option_unwrap_or_case<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tc
             if !utils::usage::contains_return_break_continue_macro(none_arm.body);
             then {
                 Some(none_arm)
-            }
-            else {
+            } else {
                 None
             }
         }
@@ -102,14 +101,11 @@ fn lint_option_unwrap_or_case<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tc
                     "{}.{}({}{})",
                     scrutinee_snippet,
                     method,
-                    if eager_eval { ""} else { "|| " },
+                    if eager_eval { "" } else { "|| " },
                     reindented_none_body
                 ),
                 Applicability::MachineApplicable,
             );
-            true
-        } else {
-            false
         }
     }
 }
-- 
cgit 1.4.1-3-g733a5


From 690a6a6c0eff1a3edeb5f4c2dcbf9994760c3184 Mon Sep 17 00:00:00 2001
From: Tim Nielens <tim.nielens@gmail.com>
Date: Wed, 14 Oct 2020 22:09:28 +0200
Subject: manual-unwrap-or / remove unwrap_or_else suggestion due to ownership
 issues

---
 clippy_lints/src/manual_unwrap_or.rs | 17 +++++------------
 src/lintlist/mod.rs                  |  2 +-
 tests/ui/manual_unwrap_or.fixed      | 31 +++++++++++++++++++++++++++----
 tests/ui/manual_unwrap_or.rs         | 31 +++++++++++++++++++++++++++----
 tests/ui/manual_unwrap_or.stderr     | 18 +++++++++---------
 5 files changed, 69 insertions(+), 30 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_unwrap_or.rs b/clippy_lints/src/manual_unwrap_or.rs
index 719a8b91f66..ddb8cc25077 100644
--- a/clippy_lints/src/manual_unwrap_or.rs
+++ b/clippy_lints/src/manual_unwrap_or.rs
@@ -33,7 +33,7 @@ declare_clippy_lint! {
     /// ```
     pub MANUAL_UNWRAP_OR,
     complexity,
-    "finds patterns that can be encoded more concisely with `Option::unwrap_or(_else)`"
+    "finds patterns that can be encoded more concisely with `Option::unwrap_or`"
 }
 
 declare_lint_pass!(ManualUnwrapOr => [MANUAL_UNWRAP_OR]);
@@ -83,26 +83,19 @@ fn lint_option_unwrap_or_case<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tc
         if let Some(scrutinee_snippet) = utils::snippet_opt(cx, scrutinee.span);
         if let Some(none_body_snippet) = utils::snippet_opt(cx, none_arm.body.span);
         if let Some(indent) = utils::indent_of(cx, expr.span);
+        if constant_simple(cx, cx.typeck_results(), none_arm.body).is_some();
         then {
             let reindented_none_body =
                 utils::reindent_multiline(none_body_snippet.into(), true, Some(indent));
-            let eager_eval = constant_simple(cx, cx.typeck_results(), none_arm.body).is_some();
-            let method = if eager_eval {
-                "unwrap_or"
-            } else {
-                "unwrap_or_else"
-            };
             utils::span_lint_and_sugg(
                 cx,
                 MANUAL_UNWRAP_OR, expr.span,
-                &format!("this pattern reimplements `Option::{}`", &method),
+                "this pattern reimplements `Option::unwrap_or`",
                 "replace with",
                 format!(
-                    "{}.{}({}{})",
+                    "{}.unwrap_or({})",
                     scrutinee_snippet,
-                    method,
-                    if eager_eval { "" } else { "|| " },
-                    reindented_none_body
+                    reindented_none_body,
                 ),
                 Applicability::MachineApplicable,
             );
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index debd3c31d8b..6301d623a2b 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -1183,7 +1183,7 @@ vec![
     Lint {
         name: "manual_unwrap_or",
         group: "complexity",
-        desc: "finds patterns that can be encoded more concisely with `Option::unwrap_or(_else)`",
+        desc: "finds patterns that can be encoded more concisely with `Option::unwrap_or`",
         deprecation: None,
         module: "manual_unwrap_or",
     },
diff --git a/tests/ui/manual_unwrap_or.fixed b/tests/ui/manual_unwrap_or.fixed
index a9cc8678c9d..a8736f1e6ef 100644
--- a/tests/ui/manual_unwrap_or.fixed
+++ b/tests/ui/manual_unwrap_or.fixed
@@ -12,10 +12,11 @@ fn unwrap_or() {
     Some(1).unwrap_or(1 + 42);
 
     // multiline case
-    Some(1).unwrap_or_else(|| {
-        let a = 1 + 42;
-        let b = a + 42;
-        b + 42
+    #[rustfmt::skip]
+    Some(1).unwrap_or({
+        42 + 42
+            + 42 + 42 + 42
+            + 42 + 42 + 42
     });
 
     // string case
@@ -40,6 +41,28 @@ fn unwrap_or() {
             None => break,
         };
     }
+
+    // cases where the none arm isn't a constant expression
+    // are not linted due to potential ownership issues
+
+    // ownership issue example, don't lint
+    struct NonCopyable;
+    let mut option: Option<NonCopyable> = None;
+    match option {
+        Some(x) => x,
+        None => {
+            option = Some(NonCopyable);
+            // some more code ...
+            option.unwrap()
+        },
+    };
+
+    // ownership issue example, don't lint
+    let option: Option<&str> = None;
+    match option {
+        Some(s) => s,
+        None => &format!("{} {}!", "hello", "world"),
+    };
 }
 
 fn main() {}
diff --git a/tests/ui/manual_unwrap_or.rs b/tests/ui/manual_unwrap_or.rs
index 5d03d9db163..bede8cffc32 100644
--- a/tests/ui/manual_unwrap_or.rs
+++ b/tests/ui/manual_unwrap_or.rs
@@ -21,13 +21,14 @@ fn unwrap_or() {
     };
 
     // multiline case
+    #[rustfmt::skip]
     match Some(1) {
         Some(i) => i,
         None => {
-            let a = 1 + 42;
-            let b = a + 42;
-            b + 42
-        },
+            42 + 42
+                + 42 + 42 + 42
+                + 42 + 42 + 42
+        }
     };
 
     // string case
@@ -55,6 +56,28 @@ fn unwrap_or() {
             None => break,
         };
     }
+
+    // cases where the none arm isn't a constant expression
+    // are not linted due to potential ownership issues
+
+    // ownership issue example, don't lint
+    struct NonCopyable;
+    let mut option: Option<NonCopyable> = None;
+    match option {
+        Some(x) => x,
+        None => {
+            option = Some(NonCopyable);
+            // some more code ...
+            option.unwrap()
+        },
+    };
+
+    // ownership issue example, don't lint
+    let option: Option<&str> = None;
+    match option {
+        Some(s) => s,
+        None => &format!("{} {}!", "hello", "world"),
+    };
 }
 
 fn main() {}
diff --git a/tests/ui/manual_unwrap_or.stderr b/tests/ui/manual_unwrap_or.stderr
index 8f6835ed78d..674f2952635 100644
--- a/tests/ui/manual_unwrap_or.stderr
+++ b/tests/ui/manual_unwrap_or.stderr
@@ -27,29 +27,29 @@ LL | |         None => 1 + 42,
 LL | |     };
    | |_____^ help: replace with: `Some(1).unwrap_or(1 + 42)`
 
-error: this pattern reimplements `Option::unwrap_or_else`
-  --> $DIR/manual_unwrap_or.rs:24:5
+error: this pattern reimplements `Option::unwrap_or`
+  --> $DIR/manual_unwrap_or.rs:25:5
    |
 LL | /     match Some(1) {
 LL | |         Some(i) => i,
 LL | |         None => {
-LL | |             let a = 1 + 42;
+LL | |             42 + 42
 ...  |
-LL | |         },
+LL | |         }
 LL | |     };
    | |_____^
    |
 help: replace with
    |
-LL |     Some(1).unwrap_or_else(|| {
-LL |         let a = 1 + 42;
-LL |         let b = a + 42;
-LL |         b + 42
+LL |     Some(1).unwrap_or({
+LL |         42 + 42
+LL |             + 42 + 42 + 42
+LL |             + 42 + 42 + 42
 LL |     });
    |
 
 error: this pattern reimplements `Option::unwrap_or`
-  --> $DIR/manual_unwrap_or.rs:34:5
+  --> $DIR/manual_unwrap_or.rs:35:5
    |
 LL | /     match Some("Bob") {
 LL | |         Some(i) => i,
-- 
cgit 1.4.1-3-g733a5


From 32e2021b75f5bb5c83bf753de76ec9ed499d12cc Mon Sep 17 00:00:00 2001
From: Chris Ayoup <chris@achris.net>
Date: Wed, 14 Oct 2020 23:49:48 -0400
Subject: Lint items after statements in macro expansions

The items_after_statements lint was skipping all expansions.  Instead
we should still lint local macros.

Fixes #578
---
 clippy_lints/src/items_after_statements.rs |  7 ++++---
 tests/ui/item_after_statement.rs           |  5 ++++-
 tests/ui/item_after_statement.stderr       | 15 ++++++++++++++-
 3 files changed, 22 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/items_after_statements.rs b/clippy_lints/src/items_after_statements.rs
index c8576bcfcb4..8998fae09de 100644
--- a/clippy_lints/src/items_after_statements.rs
+++ b/clippy_lints/src/items_after_statements.rs
@@ -2,7 +2,8 @@
 
 use crate::utils::span_lint;
 use rustc_ast::ast::{Block, ItemKind, StmtKind};
-use rustc_lint::{EarlyContext, EarlyLintPass};
+use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
+use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
@@ -53,7 +54,7 @@ declare_lint_pass!(ItemsAfterStatements => [ITEMS_AFTER_STATEMENTS]);
 
 impl EarlyLintPass for ItemsAfterStatements {
     fn check_block(&mut self, cx: &EarlyContext<'_>, item: &Block) {
-        if item.span.from_expansion() {
+        if in_external_macro(cx.sess(), item.span) {
             return;
         }
 
@@ -67,7 +68,7 @@ impl EarlyLintPass for ItemsAfterStatements {
         // lint on all further items
         for stmt in stmts {
             if let StmtKind::Item(ref it) = *stmt {
-                if it.span.from_expansion() {
+                if in_external_macro(cx.sess(), it.span) {
                     return;
                 }
                 if let ItemKind::MacroDef(..) = it.kind {
diff --git a/tests/ui/item_after_statement.rs b/tests/ui/item_after_statement.rs
index c17a7cbc8d9..377e58e4417 100644
--- a/tests/ui/item_after_statement.rs
+++ b/tests/ui/item_after_statement.rs
@@ -28,7 +28,10 @@ fn mac() {
     // do not lint this, because it needs to be after `a`
     macro_rules! b {
         () => {{
-            a = 6
+            a = 6;
+            fn say_something() {
+                println!("something");
+            }
         }};
     }
     b!();
diff --git a/tests/ui/item_after_statement.stderr b/tests/ui/item_after_statement.stderr
index f8f010b5e5c..68a3c81b6a8 100644
--- a/tests/ui/item_after_statement.stderr
+++ b/tests/ui/item_after_statement.stderr
@@ -16,5 +16,18 @@ LL | |         println!("foo");
 LL | |     }
    | |_____^
 
-error: aborting due to 2 previous errors
+error: adding items after statements is confusing, since items exist from the start of the scope
+  --> $DIR/item_after_statement.rs:32:13
+   |
+LL | /             fn say_something() {
+LL | |                 println!("something");
+LL | |             }
+   | |_____________^
+...
+LL |       b!();
+   |       ----- in this macro invocation
+   |
+   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: aborting due to 3 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From ef91de640294e6d0fbf881082196ba83379ea447 Mon Sep 17 00:00:00 2001
From: Joe Richey <joerichey@google.com>
Date: Thu, 15 Oct 2020 22:37:53 -0700
Subject: Run cargo dev fmt

Signed-off-by: Joe Richey <joerichey@google.com>
---
 clippy_lints/src/future_not_send.rs            | 9 ++-------
 clippy_lints/src/trivially_copy_pass_by_ref.rs | 2 +-
 2 files changed, 3 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/future_not_send.rs b/clippy_lints/src/future_not_send.rs
index d2a322e1223..71a30d1c33d 100644
--- a/clippy_lints/src/future_not_send.rs
+++ b/clippy_lints/src/future_not_send.rs
@@ -92,13 +92,8 @@ impl<'tcx> LateLintPass<'tcx> for FutureNotSend {
                         |db| {
                             cx.tcx.infer_ctxt().enter(|infcx| {
                                 for FulfillmentError { obligation, .. } in send_errors {
-                                    infcx.maybe_note_obligation_cause_for_async_await(
-                                        db,
-                                        &obligation,
-                                    );
-                                    if let Trait(trait_pred, _) =
-                                        obligation.predicate.skip_binders()
-                                    {
+                                    infcx.maybe_note_obligation_cause_for_async_await(db, &obligation);
+                                    if let Trait(trait_pred, _) = obligation.predicate.skip_binders() {
                                         db.note(&format!(
                                             "`{}` doesn't implement `{}`",
                                             trait_pred.self_ty(),
diff --git a/clippy_lints/src/trivially_copy_pass_by_ref.rs b/clippy_lints/src/trivially_copy_pass_by_ref.rs
index d92eb86fb2e..e90ea0fc200 100644
--- a/clippy_lints/src/trivially_copy_pass_by_ref.rs
+++ b/clippy_lints/src/trivially_copy_pass_by_ref.rs
@@ -12,8 +12,8 @@ use rustc_middle::ty;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::Span;
 use rustc_target::abi::LayoutOf;
-use rustc_target::spec::Target;
 use rustc_target::spec::abi::Abi;
+use rustc_target::spec::Target;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for functions taking arguments by reference, where
-- 
cgit 1.4.1-3-g733a5


From 5a13217ea9c07121e7d3cdcfb0ddd2aa52b90f12 Mon Sep 17 00:00:00 2001
From: ThibsG <Thibs@debian.com>
Date: Fri, 16 Oct 2020 17:58:26 +0200
Subject: Assert macro args extractor as a common function in higher

---
 clippy_lints/src/eq_op.rs                   | 12 ++----
 clippy_lints/src/mutable_debug_assertion.rs | 66 +++++------------------------
 clippy_lints/src/utils/higher.rs            | 54 +++++++++++++++++++++++
 3 files changed, 69 insertions(+), 63 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/eq_op.rs b/clippy_lints/src/eq_op.rs
index 9653e62cad0..3201adbf9a0 100644
--- a/clippy_lints/src/eq_op.rs
+++ b/clippy_lints/src/eq_op.rs
@@ -1,5 +1,5 @@
 use crate::utils::{
-    eq_expr_value, implements_trait, in_macro, is_copy, is_expn_of, multispan_sugg, snippet, span_lint,
+    eq_expr_value, higher, implements_trait, in_macro, is_copy, is_expn_of, multispan_sugg, snippet, span_lint,
     span_lint_and_then,
 };
 use if_chain::if_chain;
@@ -71,13 +71,9 @@ impl<'tcx> LateLintPass<'tcx> for EqOp {
                     if_chain! {
                         if is_expn_of(stmt.span, amn).is_some();
                         if let StmtKind::Semi(ref matchexpr) = stmt.kind;
-                        if let ExprKind::Block(ref matchblock, _) = matchexpr.kind;
-                        if let Some(ref matchheader) = matchblock.expr;
-                        if let ExprKind::Match(ref headerexpr, _, _) = matchheader.kind;
-                        if let ExprKind::Tup(ref conditions) = headerexpr.kind;
-                        if conditions.len() == 2;
-                        if let ExprKind::AddrOf(BorrowKind::Ref, _, ref lhs) = conditions[0].kind;
-                        if let ExprKind::AddrOf(BorrowKind::Ref, _, ref rhs) = conditions[1].kind;
+                        if let Some(macro_args) = higher::extract_assert_macro_args(matchexpr);
+                        if macro_args.len() == 2;
+                        let (lhs, rhs) = (macro_args[0], macro_args[1]);
                         if eq_expr_value(cx, lhs, rhs);
 
                         then {
diff --git a/clippy_lints/src/mutable_debug_assertion.rs b/clippy_lints/src/mutable_debug_assertion.rs
index cc635c2a202..76417aa7ed0 100644
--- a/clippy_lints/src/mutable_debug_assertion.rs
+++ b/clippy_lints/src/mutable_debug_assertion.rs
@@ -1,7 +1,6 @@
-use crate::utils::{is_direct_expn_of, span_lint};
-use if_chain::if_chain;
+use crate::utils::{higher, is_direct_expn_of, span_lint};
 use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
-use rustc_hir::{BorrowKind, Expr, ExprKind, MatchSource, Mutability, StmtKind, UnOp};
+use rustc_hir::{BorrowKind, Expr, ExprKind, MatchSource, Mutability};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::map::Map;
 use rustc_middle::ty;
@@ -39,66 +38,23 @@ impl<'tcx> LateLintPass<'tcx> for DebugAssertWithMutCall {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
         for dmn in &DEBUG_MACRO_NAMES {
             if is_direct_expn_of(e.span, dmn).is_some() {
-                if let Some(span) = extract_call(cx, e) {
-                    span_lint(
-                        cx,
-                        DEBUG_ASSERT_WITH_MUT_CALL,
-                        span,
-                        &format!("do not call a function with mutable arguments inside of `{}!`", dmn),
-                    );
-                }
-            }
-        }
-    }
-}
-
-//HACK(hellow554): remove this when #4694 is implemented
-fn extract_call<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> Option<Span> {
-    if_chain! {
-        if let ExprKind::Block(ref block, _) = e.kind;
-        if block.stmts.len() == 1;
-        if let StmtKind::Semi(ref matchexpr) = block.stmts[0].kind;
-        then {
-            // debug_assert
-            if_chain! {
-                if let ExprKind::Match(ref ifclause, _, _) = matchexpr.kind;
-                if let ExprKind::DropTemps(ref droptmp) = ifclause.kind;
-                if let ExprKind::Unary(UnOp::UnNot, ref condition) = droptmp.kind;
-                then {
-                    let mut visitor = MutArgVisitor::new(cx);
-                    visitor.visit_expr(condition);
-                    return visitor.expr_span();
-                }
-            }
-
-            // debug_assert_{eq,ne}
-            if_chain! {
-                if let ExprKind::Block(ref matchblock, _) = matchexpr.kind;
-                if let Some(ref matchheader) = matchblock.expr;
-                if let ExprKind::Match(ref headerexpr, _, _) = matchheader.kind;
-                if let ExprKind::Tup(ref conditions) = headerexpr.kind;
-                if conditions.len() == 2;
-                then {
-                    if let ExprKind::AddrOf(BorrowKind::Ref, _, ref lhs) = conditions[0].kind {
+                if let Some(macro_args) = higher::extract_assert_macro_args(e) {
+                    for arg in macro_args {
                         let mut visitor = MutArgVisitor::new(cx);
-                        visitor.visit_expr(lhs);
+                        visitor.visit_expr(arg);
                         if let Some(span) = visitor.expr_span() {
-                            return Some(span);
-                        }
-                    }
-                    if let ExprKind::AddrOf(BorrowKind::Ref, _, ref rhs) = conditions[1].kind {
-                        let mut visitor = MutArgVisitor::new(cx);
-                        visitor.visit_expr(rhs);
-                        if let Some(span) = visitor.expr_span() {
-                            return Some(span);
+                            span_lint(
+                                cx,
+                                DEBUG_ASSERT_WITH_MUT_CALL,
+                                span,
+                                &format!("do not call a function with mutable arguments inside of `{}!`", dmn),
+                            );
                         }
                     }
                 }
             }
         }
     }
-
-    None
 }
 
 struct MutArgVisitor<'a, 'tcx> {
diff --git a/clippy_lints/src/utils/higher.rs b/clippy_lints/src/utils/higher.rs
index 8563b469a30..6d7c5058b4f 100644
--- a/clippy_lints/src/utils/higher.rs
+++ b/clippy_lints/src/utils/higher.rs
@@ -7,6 +7,7 @@ use crate::utils::{is_expn_of, match_def_path, paths};
 use if_chain::if_chain;
 use rustc_ast::ast;
 use rustc_hir as hir;
+use rustc_hir::{BorrowKind, Expr, ExprKind, StmtKind, UnOp};
 use rustc_lint::LateContext;
 
 /// Converts a hir binary operator to the corresponding `ast` type.
@@ -241,3 +242,56 @@ pub fn vec_macro<'e>(cx: &LateContext<'_>, expr: &'e hir::Expr<'_>) -> Option<Ve
 
     None
 }
+
+/// Extract args from an assert-like macro.
+/// Currently working with:
+/// - `assert!`, `assert_eq!` and `assert_ne!`
+/// - `debug_assert!`, `debug_assert_eq!` and `debug_assert_ne!`
+/// For example:
+/// `assert!(expr)` will return Some([expr])
+/// `debug_assert_eq!(a, b)` will return Some([a, b])
+pub fn extract_assert_macro_args<'tcx>(e: &'tcx Expr<'tcx>) -> Option<Vec<&'tcx Expr<'tcx>>> {
+    /// Try to match the AST for a pattern that contains a match, for example when two args are
+    /// compared
+    fn ast_matchblock(matchblock_expr: &'tcx Expr<'tcx>) -> Option<Vec<&Expr<'_>>> {
+        if_chain! {
+            if let ExprKind::Match(ref headerexpr, _, _) = &matchblock_expr.kind;
+            if let ExprKind::Tup([lhs, rhs]) = &headerexpr.kind;
+            if let ExprKind::AddrOf(BorrowKind::Ref, _, lhs) = lhs.kind;
+            if let ExprKind::AddrOf(BorrowKind::Ref, _, rhs) = rhs.kind;
+            then {
+                return Some(vec![lhs, rhs]);
+            }
+        }
+        None
+    }
+
+    if let ExprKind::Block(ref block, _) = e.kind {
+        if block.stmts.len() == 1 {
+            if let StmtKind::Semi(ref matchexpr) = block.stmts[0].kind {
+                // macros with unique arg: `{debug_}assert!` (e.g., `debug_assert!(some_condition)`)
+                if_chain! {
+                    if let ExprKind::Match(ref ifclause, _, _) = matchexpr.kind;
+                    if let ExprKind::DropTemps(ref droptmp) = ifclause.kind;
+                    if let ExprKind::Unary(UnOp::UnNot, condition) = droptmp.kind;
+                    then {
+                        return Some(vec![condition]);
+                    }
+                }
+
+                // debug macros with two args: `debug_assert_{ne, eq}` (e.g., `assert_ne!(a, b)`)
+                if_chain! {
+                    if let ExprKind::Block(ref matchblock,_) = matchexpr.kind;
+                    if let Some(ref matchblock_expr) = matchblock.expr;
+                    then {
+                        return ast_matchblock(matchblock_expr);
+                    }
+                }
+            }
+        } else if let Some(matchblock_expr) = block.expr {
+            // macros with two args: `assert_{ne, eq}` (e.g., `assert_ne!(a, b)`)
+            return ast_matchblock(&matchblock_expr);
+        }
+    }
+    None
+}
-- 
cgit 1.4.1-3-g733a5


From bb0ce32423aefcb8b9eb587881973f56a6a6b0ee Mon Sep 17 00:00:00 2001
From: Geoffrey Copin <copin.geoffrey@gmail.com>
Date: Fri, 16 Oct 2020 00:22:35 +0200
Subject: Lint unnecessary int-to-int and float-to-float casts

---
 clippy_lints/src/types.rs                | 43 +++++++++++++++++++------
 tests/ui/eq_op.rs                        |  1 +
 tests/ui/eq_op.stderr                    | 54 ++++++++++++++++----------------
 tests/ui/unnecessary_cast_fixable.fixed  | 11 +++++--
 tests/ui/unnecessary_cast_fixable.rs     | 11 +++++--
 tests/ui/unnecessary_cast_fixable.stderr | 32 ++++++++++++++++++-
 6 files changed, 111 insertions(+), 41 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs
index 9a948af8bfc..716d027e434 100644
--- a/clippy_lints/src/types.rs
+++ b/clippy_lints/src/types.rs
@@ -3,6 +3,7 @@
 use std::borrow::Cow;
 use std::cmp::Ordering;
 use std::collections::BTreeMap;
+use std::fmt::Display;
 
 use if_chain::if_chain;
 use rustc_ast::{FloatTy, IntTy, LitFloatType, LitIntType, LitKind, UintTy};
@@ -1608,18 +1609,23 @@ impl<'tcx> LateLintPass<'tcx> for Casts {
                     let to_nbits = fp_ty_mantissa_nbits(cast_to);
                     if from_nbits != 0 && to_nbits != 0 && from_nbits <= to_nbits && num_lit.is_decimal();
                     then {
-                        span_lint_and_sugg(
-                            cx,
-                            UNNECESSARY_CAST,
-                            expr.span,
-                            &format!("casting integer literal to `{}` is unnecessary", cast_to),
-                            "try",
-                            format!("{}_{}", n, cast_to),
-                            Applicability::MachineApplicable,
-                        );
+                        show_unnecessary_cast(cx, expr, n , cast_from, cast_to);
                         return;
                     }
                 }
+
+                match lit.node {
+                    LitKind::Int(num, LitIntType::Unsuffixed) if cast_to.is_integral() => {
+                        show_unnecessary_cast(cx, expr, num, cast_from, cast_to);
+                        return;
+                    },
+                    LitKind::Float(num, LitFloatType::Unsuffixed) if cast_to.is_floating_point() => {
+                        show_unnecessary_cast(cx, expr, num, cast_from, cast_to);
+                        return;
+                    },
+                    _ => (),
+                };
+
                 match lit.node {
                     LitKind::Int(_, LitIntType::Unsuffixed) | LitKind::Float(_, LitFloatType::Unsuffixed) => {},
                     _ => {
@@ -1646,6 +1652,25 @@ impl<'tcx> LateLintPass<'tcx> for Casts {
     }
 }
 
+fn show_unnecessary_cast<Num: Display>(
+    cx: &LateContext<'_>,
+    expr: &Expr<'_>,
+    num: Num,
+    cast_from: Ty<'_>,
+    cast_to: Ty<'_>,
+) {
+    let literal_kind_name = if cast_from.is_integral() { "integer" } else { "float" };
+    span_lint_and_sugg(
+        cx,
+        UNNECESSARY_CAST,
+        expr.span,
+        &format!("casting {} literal to `{}` is unnecessary", literal_kind_name, cast_to),
+        "try",
+        format!("{}_{}", num, cast_to),
+        Applicability::MachineApplicable,
+    );
+}
+
 fn lint_numeric_casts<'tcx>(
     cx: &LateContext<'tcx>,
     expr: &Expr<'tcx>,
diff --git a/tests/ui/eq_op.rs b/tests/ui/eq_op.rs
index 272b0900a31..4e09d19ea21 100644
--- a/tests/ui/eq_op.rs
+++ b/tests/ui/eq_op.rs
@@ -6,6 +6,7 @@
 #[allow(clippy::no_effect, unused_variables, clippy::unnecessary_operation, clippy::short_circuit_statement)]
 #[allow(clippy::nonminimal_bool)]
 #[allow(unused)]
+#[allow(clippy::unnecessary_cast)]
 fn main() {
     // simple values and comparisons
     1 == 1;
diff --git a/tests/ui/eq_op.stderr b/tests/ui/eq_op.stderr
index 5b80e6078ee..ad81b35a766 100644
--- a/tests/ui/eq_op.stderr
+++ b/tests/ui/eq_op.stderr
@@ -1,5 +1,5 @@
 error: equal expressions as operands to `==`
-  --> $DIR/eq_op.rs:11:5
+  --> $DIR/eq_op.rs:12:5
    |
 LL |     1 == 1;
    |     ^^^^^^
@@ -7,157 +7,157 @@ LL |     1 == 1;
    = note: `-D clippy::eq-op` implied by `-D warnings`
 
 error: equal expressions as operands to `==`
-  --> $DIR/eq_op.rs:12:5
+  --> $DIR/eq_op.rs:13:5
    |
 LL |     "no" == "no";
    |     ^^^^^^^^^^^^
 
 error: equal expressions as operands to `!=`
-  --> $DIR/eq_op.rs:14:5
+  --> $DIR/eq_op.rs:15:5
    |
 LL |     false != false;
    |     ^^^^^^^^^^^^^^
 
 error: equal expressions as operands to `<`
-  --> $DIR/eq_op.rs:15:5
+  --> $DIR/eq_op.rs:16:5
    |
 LL |     1.5 < 1.5;
    |     ^^^^^^^^^
 
 error: equal expressions as operands to `>=`
-  --> $DIR/eq_op.rs:16:5
+  --> $DIR/eq_op.rs:17:5
    |
 LL |     1u64 >= 1u64;
    |     ^^^^^^^^^^^^
 
 error: equal expressions as operands to `&`
-  --> $DIR/eq_op.rs:19:5
+  --> $DIR/eq_op.rs:20:5
    |
 LL |     (1 as u64) & (1 as u64);
    |     ^^^^^^^^^^^^^^^^^^^^^^^
 
 error: equal expressions as operands to `^`
-  --> $DIR/eq_op.rs:20:5
+  --> $DIR/eq_op.rs:21:5
    |
 LL |     1 ^ ((((((1))))));
    |     ^^^^^^^^^^^^^^^^^
 
 error: equal expressions as operands to `<`
-  --> $DIR/eq_op.rs:23:5
+  --> $DIR/eq_op.rs:24:5
    |
 LL |     (-(2) < -(2));
    |     ^^^^^^^^^^^^^
 
 error: equal expressions as operands to `==`
-  --> $DIR/eq_op.rs:24:5
+  --> $DIR/eq_op.rs:25:5
    |
 LL |     ((1 + 1) & (1 + 1) == (1 + 1) & (1 + 1));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: equal expressions as operands to `&`
-  --> $DIR/eq_op.rs:24:6
+  --> $DIR/eq_op.rs:25:6
    |
 LL |     ((1 + 1) & (1 + 1) == (1 + 1) & (1 + 1));
    |      ^^^^^^^^^^^^^^^^^
 
 error: equal expressions as operands to `&`
-  --> $DIR/eq_op.rs:24:27
+  --> $DIR/eq_op.rs:25:27
    |
 LL |     ((1 + 1) & (1 + 1) == (1 + 1) & (1 + 1));
    |                           ^^^^^^^^^^^^^^^^^
 
 error: equal expressions as operands to `==`
-  --> $DIR/eq_op.rs:25:5
+  --> $DIR/eq_op.rs:26:5
    |
 LL |     (1 * 2) + (3 * 4) == 1 * 2 + 3 * 4;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: equal expressions as operands to `!=`
-  --> $DIR/eq_op.rs:28:5
+  --> $DIR/eq_op.rs:29:5
    |
 LL |     ([1] != [1]);
    |     ^^^^^^^^^^^^
 
 error: equal expressions as operands to `!=`
-  --> $DIR/eq_op.rs:29:5
+  --> $DIR/eq_op.rs:30:5
    |
 LL |     ((1, 2) != (1, 2));
    |     ^^^^^^^^^^^^^^^^^^
 
 error: equal expressions as operands to `==`
-  --> $DIR/eq_op.rs:33:5
+  --> $DIR/eq_op.rs:34:5
    |
 LL |     1 + 1 == 2;
    |     ^^^^^^^^^^
 
 error: equal expressions as operands to `==`
-  --> $DIR/eq_op.rs:34:5
+  --> $DIR/eq_op.rs:35:5
    |
 LL |     1 - 1 == 0;
    |     ^^^^^^^^^^
 
 error: equal expressions as operands to `-`
-  --> $DIR/eq_op.rs:34:5
+  --> $DIR/eq_op.rs:35:5
    |
 LL |     1 - 1 == 0;
    |     ^^^^^
 
 error: equal expressions as operands to `-`
-  --> $DIR/eq_op.rs:36:5
+  --> $DIR/eq_op.rs:37:5
    |
 LL |     1 - 1;
    |     ^^^^^
 
 error: equal expressions as operands to `/`
-  --> $DIR/eq_op.rs:37:5
+  --> $DIR/eq_op.rs:38:5
    |
 LL |     1 / 1;
    |     ^^^^^
 
 error: equal expressions as operands to `&&`
-  --> $DIR/eq_op.rs:38:5
+  --> $DIR/eq_op.rs:39:5
    |
 LL |     true && true;
    |     ^^^^^^^^^^^^
 
 error: equal expressions as operands to `||`
-  --> $DIR/eq_op.rs:40:5
+  --> $DIR/eq_op.rs:41:5
    |
 LL |     true || true;
    |     ^^^^^^^^^^^^
 
 error: equal expressions as operands to `&&`
-  --> $DIR/eq_op.rs:46:5
+  --> $DIR/eq_op.rs:47:5
    |
 LL |     a == b && b == a;
    |     ^^^^^^^^^^^^^^^^
 
 error: equal expressions as operands to `&&`
-  --> $DIR/eq_op.rs:47:5
+  --> $DIR/eq_op.rs:48:5
    |
 LL |     a != b && b != a;
    |     ^^^^^^^^^^^^^^^^
 
 error: equal expressions as operands to `&&`
-  --> $DIR/eq_op.rs:48:5
+  --> $DIR/eq_op.rs:49:5
    |
 LL |     a < b && b > a;
    |     ^^^^^^^^^^^^^^
 
 error: equal expressions as operands to `&&`
-  --> $DIR/eq_op.rs:49:5
+  --> $DIR/eq_op.rs:50:5
    |
 LL |     a <= b && b >= a;
    |     ^^^^^^^^^^^^^^^^
 
 error: equal expressions as operands to `==`
-  --> $DIR/eq_op.rs:52:5
+  --> $DIR/eq_op.rs:53:5
    |
 LL |     a == a;
    |     ^^^^^^
 
 error: equal expressions as operands to `/`
-  --> $DIR/eq_op.rs:62:20
+  --> $DIR/eq_op.rs:63:20
    |
 LL |     const D: u32 = A / A;
    |                    ^^^^^
diff --git a/tests/ui/unnecessary_cast_fixable.fixed b/tests/ui/unnecessary_cast_fixable.fixed
index fb89a9fce3d..ba52fc2703f 100644
--- a/tests/ui/unnecessary_cast_fixable.fixed
+++ b/tests/ui/unnecessary_cast_fixable.fixed
@@ -12,12 +12,19 @@ fn main() {
     #[rustfmt::skip]
     let v = vec!(1);
     &v as &[i32];
-    1.0 as f64;
-    1 as u64;
     0x10 as f32;
     0o10 as f32;
     0b10 as f32;
     0x11 as f64;
     0o11 as f64;
     0b11 as f64;
+
+    1_u32;
+    16_i32;
+    2_usize;
+
+    1.0_f64;
+    0.5_f32;
+
+    1.0 as u16;
 }
diff --git a/tests/ui/unnecessary_cast_fixable.rs b/tests/ui/unnecessary_cast_fixable.rs
index 4a0c8620dc1..0d2115548fd 100644
--- a/tests/ui/unnecessary_cast_fixable.rs
+++ b/tests/ui/unnecessary_cast_fixable.rs
@@ -12,12 +12,19 @@ fn main() {
     #[rustfmt::skip]
     let v = vec!(1);
     &v as &[i32];
-    1.0 as f64;
-    1 as u64;
     0x10 as f32;
     0o10 as f32;
     0b10 as f32;
     0x11 as f64;
     0o11 as f64;
     0b11 as f64;
+
+    1 as u32;
+    0x10 as i32;
+    0b10 as usize;
+
+    1.0 as f64;
+    0.5 as f32;
+
+    1.0 as u16;
 }
diff --git a/tests/ui/unnecessary_cast_fixable.stderr b/tests/ui/unnecessary_cast_fixable.stderr
index 8ff1e5dea60..474e62c30d5 100644
--- a/tests/ui/unnecessary_cast_fixable.stderr
+++ b/tests/ui/unnecessary_cast_fixable.stderr
@@ -18,5 +18,35 @@ error: casting integer literal to `f64` is unnecessary
 LL |     100_i32 as f64;
    |     ^^^^^^^^^^^^^^ help: try: `100_f64`
 
-error: aborting due to 3 previous errors
+error: casting integer literal to `u32` is unnecessary
+  --> $DIR/unnecessary_cast_fixable.rs:22:5
+   |
+LL |     1 as u32;
+   |     ^^^^^^^^ help: try: `1_u32`
+
+error: casting integer literal to `i32` is unnecessary
+  --> $DIR/unnecessary_cast_fixable.rs:23:5
+   |
+LL |     0x10 as i32;
+   |     ^^^^^^^^^^^ help: try: `16_i32`
+
+error: casting integer literal to `usize` is unnecessary
+  --> $DIR/unnecessary_cast_fixable.rs:24:5
+   |
+LL |     0b10 as usize;
+   |     ^^^^^^^^^^^^^ help: try: `2_usize`
+
+error: casting float literal to `f64` is unnecessary
+  --> $DIR/unnecessary_cast_fixable.rs:26:5
+   |
+LL |     1.0 as f64;
+   |     ^^^^^^^^^^ help: try: `1.0_f64`
+
+error: casting float literal to `f32` is unnecessary
+  --> $DIR/unnecessary_cast_fixable.rs:27:5
+   |
+LL |     0.5 as f32;
+   |     ^^^^^^^^^^ help: try: `0.5_f32`
+
+error: aborting due to 8 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 915ce3608724e6c900d1b5eb4412cac2fcace33a Mon Sep 17 00:00:00 2001
From: Tim Nielens <tim.nielens@gmail.com>
Date: Sun, 18 Oct 2020 01:11:59 +0200
Subject: manual_unwrap_or / support Result::unwrap_or

---
 clippy_lints/src/manual_unwrap_or.rs | 83 ++++++++++++++++++++++++------------
 src/lintlist/mod.rs                  |  2 +-
 tests/ui/manual_unwrap_or.fixed      | 44 ++++++++++++++++++-
 tests/ui/manual_unwrap_or.rs         | 59 ++++++++++++++++++++++++-
 tests/ui/manual_unwrap_or.stderr     | 59 ++++++++++++++++++++++++-
 5 files changed, 216 insertions(+), 31 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_unwrap_or.rs b/clippy_lints/src/manual_unwrap_or.rs
index ddb8cc25077..f3f1e31abde 100644
--- a/clippy_lints/src/manual_unwrap_or.rs
+++ b/clippy_lints/src/manual_unwrap_or.rs
@@ -2,7 +2,7 @@ use crate::consts::constant_simple;
 use crate::utils;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
-use rustc_hir::{def, Arm, Expr, ExprKind, PatKind, QPath};
+use rustc_hir::{def, Arm, Expr, ExprKind, Pat, PatKind, QPath};
 use rustc_lint::LintContext;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::lint::in_external_macro;
@@ -10,7 +10,7 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
     /// **What it does:**
-    /// Finds patterns that reimplement `Option::unwrap_or`.
+    /// Finds patterns that reimplement `Option::unwrap_or` or `Result::unwrap_or`.
     ///
     /// **Why is this bad?**
     /// Concise code helps focusing on behavior instead of boilerplate.
@@ -33,7 +33,7 @@ declare_clippy_lint! {
     /// ```
     pub MANUAL_UNWRAP_OR,
     complexity,
-    "finds patterns that can be encoded more concisely with `Option::unwrap_or`"
+    "finds patterns that can be encoded more concisely with `Option::unwrap_or` or `Result::unwrap_or`"
 }
 
 declare_lint_pass!(ManualUnwrapOr => [MANUAL_UNWRAP_OR]);
@@ -43,32 +43,50 @@ impl LateLintPass<'_> for ManualUnwrapOr {
         if in_external_macro(cx.sess(), expr.span) {
             return;
         }
-        lint_option_unwrap_or_case(cx, expr);
+        lint_manual_unwrap_or(cx, expr);
     }
 }
 
-fn lint_option_unwrap_or_case<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
-    fn applicable_none_arm<'a>(arms: &'a [Arm<'a>]) -> Option<&'a Arm<'a>> {
+#[derive(Copy, Clone)]
+enum Case {
+    Option,
+    Result,
+}
+
+impl Case {
+    fn unwrap_fn_path(&self) -> &str {
+        match self {
+            Case::Option => "Option::unwrap_or",
+            Case::Result => "Result::unwrap_or",
+        }
+    }
+}
+
+fn lint_manual_unwrap_or<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
+    fn applicable_or_arm<'a>(arms: &'a [Arm<'a>]) -> Option<&'a Arm<'a>> {
         if_chain! {
             if arms.len() == 2;
             if arms.iter().all(|arm| arm.guard.is_none());
-            if let Some((idx, none_arm)) = arms.iter().enumerate().find(|(_, arm)|
-                if let PatKind::Path(ref qpath) = arm.pat.kind {
-                    utils::match_qpath(qpath, &utils::paths::OPTION_NONE)
-                } else {
-                    false
+            if let Some((idx, or_arm)) = arms.iter().enumerate().find(|(_, arm)|
+                match arm.pat.kind {
+                    PatKind::Path(ref some_qpath) =>
+                        utils::match_qpath(some_qpath, &utils::paths::OPTION_NONE),
+                    PatKind::TupleStruct(ref err_qpath, &[Pat { kind: PatKind::Wild, .. }], _) =>
+                        utils::match_qpath(err_qpath, &utils::paths::RESULT_ERR),
+                    _ => false,
                 }
             );
-            let some_arm = &arms[1 - idx];
-            if let PatKind::TupleStruct(ref some_qpath, &[some_binding], _) = some_arm.pat.kind;
-            if utils::match_qpath(some_qpath, &utils::paths::OPTION_SOME);
-            if let PatKind::Binding(_, binding_hir_id, ..) = some_binding.kind;
-            if let ExprKind::Path(QPath::Resolved(_, body_path)) = some_arm.body.kind;
+            let unwrap_arm = &arms[1 - idx];
+            if let PatKind::TupleStruct(ref unwrap_qpath, &[unwrap_pat], _) = unwrap_arm.pat.kind;
+            if utils::match_qpath(unwrap_qpath, &utils::paths::OPTION_SOME)
+                || utils::match_qpath(unwrap_qpath, &utils::paths::RESULT_OK);
+            if let PatKind::Binding(_, binding_hir_id, ..) = unwrap_pat.kind;
+            if let ExprKind::Path(QPath::Resolved(_, body_path)) = unwrap_arm.body.kind;
             if let def::Res::Local(body_path_hir_id) = body_path.res;
             if body_path_hir_id == binding_hir_id;
-            if !utils::usage::contains_return_break_continue_macro(none_arm.body);
+            if !utils::usage::contains_return_break_continue_macro(or_arm.body);
             then {
-                Some(none_arm)
+                Some(or_arm)
             } else {
                 None
             }
@@ -78,24 +96,35 @@ fn lint_option_unwrap_or_case<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tc
     if_chain! {
         if let ExprKind::Match(scrutinee, match_arms, _) = expr.kind;
         let ty = cx.typeck_results().expr_ty(scrutinee);
-        if utils::is_type_diagnostic_item(cx, ty, sym!(option_type));
-        if let Some(none_arm) = applicable_none_arm(match_arms);
+        if let Some(case) = if utils::is_type_diagnostic_item(cx, ty, sym!(option_type)) {
+            Some(Case::Option)
+        } else if utils::is_type_diagnostic_item(cx, ty, sym!(result_type)) {
+            Some(Case::Result)
+        } else {
+            None
+        };
+        if let Some(or_arm) = applicable_or_arm(match_arms);
         if let Some(scrutinee_snippet) = utils::snippet_opt(cx, scrutinee.span);
-        if let Some(none_body_snippet) = utils::snippet_opt(cx, none_arm.body.span);
+        if let Some(or_body_snippet) = utils::snippet_opt(cx, or_arm.body.span);
         if let Some(indent) = utils::indent_of(cx, expr.span);
-        if constant_simple(cx, cx.typeck_results(), none_arm.body).is_some();
+        if constant_simple(cx, cx.typeck_results(), or_arm.body).is_some();
         then {
-            let reindented_none_body =
-                utils::reindent_multiline(none_body_snippet.into(), true, Some(indent));
+            let reindented_or_body =
+                utils::reindent_multiline(or_body_snippet.into(), true, Some(indent));
+            let wrap_in_parens = !matches!(scrutinee, Expr { kind: ExprKind::Call(..), .. });
+            let l_paren = if wrap_in_parens { "(" } else { "" };
+            let r_paren = if wrap_in_parens { ")" } else { "" };
             utils::span_lint_and_sugg(
                 cx,
                 MANUAL_UNWRAP_OR, expr.span,
-                "this pattern reimplements `Option::unwrap_or`",
+                &format!("this pattern reimplements `{}`", case.unwrap_fn_path()),
                 "replace with",
                 format!(
-                    "{}.unwrap_or({})",
+                    "{}{}{}.unwrap_or({})",
+                    l_paren,
                     scrutinee_snippet,
-                    reindented_none_body,
+                    r_paren,
+                    reindented_or_body,
                 ),
                 Applicability::MachineApplicable,
             );
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index 6301d623a2b..b930d9aedcf 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -1183,7 +1183,7 @@ vec![
     Lint {
         name: "manual_unwrap_or",
         group: "complexity",
-        desc: "finds patterns that can be encoded more concisely with `Option::unwrap_or`",
+        desc: "finds patterns that can be encoded more concisely with `Option::unwrap_or` or `Result::unwrap_or`",
         deprecation: None,
         module: "manual_unwrap_or",
     },
diff --git a/tests/ui/manual_unwrap_or.fixed b/tests/ui/manual_unwrap_or.fixed
index a8736f1e6ef..ceb8985d3d5 100644
--- a/tests/ui/manual_unwrap_or.fixed
+++ b/tests/ui/manual_unwrap_or.fixed
@@ -1,7 +1,7 @@
 // run-rustfix
 #![allow(dead_code)]
 
-fn unwrap_or() {
+fn option_unwrap_or() {
     // int case
     Some(1).unwrap_or(42);
 
@@ -65,4 +65,46 @@ fn unwrap_or() {
     };
 }
 
+fn result_unwrap_or() {
+    // int case
+    (Ok(1) as Result<i32, &str>).unwrap_or(42);
+
+    // int case reversed
+    (Ok(1) as Result<i32, &str>).unwrap_or(42);
+
+    // richer none expr
+    (Ok(1) as Result<i32, &str>).unwrap_or(1 + 42);
+
+    // multiline case
+    #[rustfmt::skip]
+    (Ok(1) as Result<i32, &str>).unwrap_or({
+        42 + 42
+            + 42 + 42 + 42
+            + 42 + 42 + 42
+    });
+
+    // string case
+    (Ok("Bob") as Result<&str, &str>).unwrap_or("Alice");
+
+    // don't lint
+    match Ok(1) as Result<i32, &str> {
+        Ok(i) => i + 2,
+        Err(_) => 42,
+    };
+    match Ok(1) as Result<i32, &str> {
+        Ok(i) => i,
+        Err(_) => return,
+    };
+    for j in 0..4 {
+        match Ok(j) as Result<i32, &str> {
+            Ok(i) => i,
+            Err(_) => continue,
+        };
+        match Ok(j) as Result<i32, &str> {
+            Ok(i) => i,
+            Err(_) => break,
+        };
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/manual_unwrap_or.rs b/tests/ui/manual_unwrap_or.rs
index bede8cffc32..beca1de0ed1 100644
--- a/tests/ui/manual_unwrap_or.rs
+++ b/tests/ui/manual_unwrap_or.rs
@@ -1,7 +1,7 @@
 // run-rustfix
 #![allow(dead_code)]
 
-fn unwrap_or() {
+fn option_unwrap_or() {
     // int case
     match Some(1) {
         Some(i) => i,
@@ -80,4 +80,61 @@ fn unwrap_or() {
     };
 }
 
+fn result_unwrap_or() {
+    // int case
+    match Ok(1) as Result<i32, &str> {
+        Ok(i) => i,
+        Err(_) => 42,
+    };
+
+    // int case reversed
+    match Ok(1) as Result<i32, &str> {
+        Err(_) => 42,
+        Ok(i) => i,
+    };
+
+    // richer none expr
+    match Ok(1) as Result<i32, &str> {
+        Ok(i) => i,
+        Err(_) => 1 + 42,
+    };
+
+    // multiline case
+    #[rustfmt::skip]
+    match Ok(1) as Result<i32, &str> {
+        Ok(i) => i,
+        Err(_) => {
+            42 + 42
+                + 42 + 42 + 42
+                + 42 + 42 + 42
+        }
+    };
+
+    // string case
+    match Ok("Bob") as Result<&str, &str> {
+        Ok(i) => i,
+        Err(_) => "Alice",
+    };
+
+    // don't lint
+    match Ok(1) as Result<i32, &str> {
+        Ok(i) => i + 2,
+        Err(_) => 42,
+    };
+    match Ok(1) as Result<i32, &str> {
+        Ok(i) => i,
+        Err(_) => return,
+    };
+    for j in 0..4 {
+        match Ok(j) as Result<i32, &str> {
+            Ok(i) => i,
+            Err(_) => continue,
+        };
+        match Ok(j) as Result<i32, &str> {
+            Ok(i) => i,
+            Err(_) => break,
+        };
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/manual_unwrap_or.stderr b/tests/ui/manual_unwrap_or.stderr
index 674f2952635..5d465666caf 100644
--- a/tests/ui/manual_unwrap_or.stderr
+++ b/tests/ui/manual_unwrap_or.stderr
@@ -57,5 +57,62 @@ LL | |         None => "Alice",
 LL | |     };
    | |_____^ help: replace with: `Some("Bob").unwrap_or("Alice")`
 
-error: aborting due to 5 previous errors
+error: this pattern reimplements `Result::unwrap_or`
+  --> $DIR/manual_unwrap_or.rs:85:5
+   |
+LL | /     match Ok(1) as Result<i32, &str> {
+LL | |         Ok(i) => i,
+LL | |         Err(_) => 42,
+LL | |     };
+   | |_____^ help: replace with: `(Ok(1) as Result<i32, &str>).unwrap_or(42)`
+
+error: this pattern reimplements `Result::unwrap_or`
+  --> $DIR/manual_unwrap_or.rs:91:5
+   |
+LL | /     match Ok(1) as Result<i32, &str> {
+LL | |         Err(_) => 42,
+LL | |         Ok(i) => i,
+LL | |     };
+   | |_____^ help: replace with: `(Ok(1) as Result<i32, &str>).unwrap_or(42)`
+
+error: this pattern reimplements `Result::unwrap_or`
+  --> $DIR/manual_unwrap_or.rs:97:5
+   |
+LL | /     match Ok(1) as Result<i32, &str> {
+LL | |         Ok(i) => i,
+LL | |         Err(_) => 1 + 42,
+LL | |     };
+   | |_____^ help: replace with: `(Ok(1) as Result<i32, &str>).unwrap_or(1 + 42)`
+
+error: this pattern reimplements `Result::unwrap_or`
+  --> $DIR/manual_unwrap_or.rs:104:5
+   |
+LL | /     match Ok(1) as Result<i32, &str> {
+LL | |         Ok(i) => i,
+LL | |         Err(_) => {
+LL | |             42 + 42
+...  |
+LL | |         }
+LL | |     };
+   | |_____^
+   |
+help: replace with
+   |
+LL |     (Ok(1) as Result<i32, &str>).unwrap_or({
+LL |         42 + 42
+LL |             + 42 + 42 + 42
+LL |             + 42 + 42 + 42
+LL |     });
+   |
+
+error: this pattern reimplements `Result::unwrap_or`
+  --> $DIR/manual_unwrap_or.rs:114:5
+   |
+LL | /     match Ok("Bob") as Result<&str, &str> {
+LL | |         Ok(i) => i,
+LL | |         Err(_) => "Alice",
+LL | |     };
+   | |_____^ help: replace with: `(Ok("Bob") as Result<&str, &str>).unwrap_or("Alice")`
+
+error: aborting due to 10 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 114cb218f3ab2a709e3017c380790dd6e407132c Mon Sep 17 00:00:00 2001
From: Takayuki Nakata <f.seasons017@gmail.com>
Date: Mon, 19 Oct 2020 10:34:01 +0900
Subject: Remove an extra blank line in doc examples

---
 clippy_lints/src/blocks_in_if_conditions.rs | 1 -
 clippy_lints/src/escape.rs                  | 1 -
 clippy_lints/src/matches.rs                 | 2 --
 clippy_lints/src/misc_early.rs              | 1 -
 4 files changed, 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/blocks_in_if_conditions.rs b/clippy_lints/src/blocks_in_if_conditions.rs
index 1b73ced89b3..736730d4084 100644
--- a/clippy_lints/src/blocks_in_if_conditions.rs
+++ b/clippy_lints/src/blocks_in_if_conditions.rs
@@ -28,7 +28,6 @@ declare_clippy_lint! {
     ///
     /// ```rust
     /// # fn somefunc() -> bool { true };
-    ///
     /// // Bad
     /// if { let x = somefunc(); x } { /* ... */ }
     ///
diff --git a/clippy_lints/src/escape.rs b/clippy_lints/src/escape.rs
index 8b022912573..1bf3b810fb5 100644
--- a/clippy_lints/src/escape.rs
+++ b/clippy_lints/src/escape.rs
@@ -29,7 +29,6 @@ declare_clippy_lint! {
     /// **Example:**
     /// ```rust
     /// # fn foo(bar: usize) {}
-    ///
     /// // Bad
     /// let x = Box::new(1);
     /// foo(*x);
diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index b1a4e06d4c3..d93433c607f 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -36,7 +36,6 @@ declare_clippy_lint! {
     /// ```rust
     /// # fn bar(stool: &str) {}
     /// # let x = Some("abc");
-    ///
     /// // Bad
     /// match x {
     ///     Some(ref foo) => bar(foo),
@@ -239,7 +238,6 @@ declare_clippy_lint! {
     /// ```rust
     /// # enum Foo { A(usize), B(usize) }
     /// # let x = Foo::B(1);
-    ///
     /// // Bad
     /// match x {
     ///     Foo::A(_) => {},
diff --git a/clippy_lints/src/misc_early.rs b/clippy_lints/src/misc_early.rs
index 9cb1cfb915d..5bc45c87874 100644
--- a/clippy_lints/src/misc_early.rs
+++ b/clippy_lints/src/misc_early.rs
@@ -231,7 +231,6 @@ declare_clippy_lint! {
     /// ```rust
     /// # struct TupleStruct(u32, u32, u32);
     /// # let t = TupleStruct(1, 2, 3);
-    ///
     /// // Bad
     /// match t {
     ///     TupleStruct(0, .., _) => (),
-- 
cgit 1.4.1-3-g733a5


From ec23db9496807f6c962b74fe0d6bf15be6c6d35b Mon Sep 17 00:00:00 2001
From: Patrick José Pereira <patrickelectric@gmail.com>
Date: Sat, 3 Oct 2020 15:46:28 -0300
Subject: Add linter for a single element for loop
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: Patrick José Pereira <patrickelectric@gmail.com>
---
 CHANGELOG.md                        |  1 +
 clippy_lints/src/lib.rs             |  3 ++
 clippy_lints/src/loops.rs           | 71 +++++++++++++++++++++++++++++++++++--
 src/lintlist/mod.rs                 |  7 ++++
 tests/ui/single_element_loop.fixed  | 11 ++++++
 tests/ui/single_element_loop.rs     | 10 ++++++
 tests/ui/single_element_loop.stderr | 19 ++++++++++
 7 files changed, 119 insertions(+), 3 deletions(-)
 create mode 100644 tests/ui/single_element_loop.fixed
 create mode 100644 tests/ui/single_element_loop.rs
 create mode 100644 tests/ui/single_element_loop.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index d82f970b8bf..1bf25bcd0f9 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1936,6 +1936,7 @@ Released 2018-09-13
 [`single_char_pattern`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_char_pattern
 [`single_char_push_str`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_char_push_str
 [`single_component_path_imports`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_component_path_imports
+[`single_element_loop`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_element_loop
 [`single_match`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_match
 [`single_match_else`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_match_else
 [`skip_while_next`]: https://rust-lang.github.io/rust-clippy/master/index.html#skip_while_next
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index d4d2f92a6a6..84ea2d5ca78 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -633,6 +633,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &loops::NEEDLESS_RANGE_LOOP,
         &loops::NEVER_LOOP,
         &loops::SAME_ITEM_PUSH,
+        &loops::SINGLE_ELEMENT_LOOP,
         &loops::WHILE_IMMUTABLE_CONDITION,
         &loops::WHILE_LET_LOOP,
         &loops::WHILE_LET_ON_ITERATOR,
@@ -1363,6 +1364,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&loops::NEEDLESS_RANGE_LOOP),
         LintId::of(&loops::NEVER_LOOP),
         LintId::of(&loops::SAME_ITEM_PUSH),
+        LintId::of(&loops::SINGLE_ELEMENT_LOOP),
         LintId::of(&loops::WHILE_IMMUTABLE_CONDITION),
         LintId::of(&loops::WHILE_LET_LOOP),
         LintId::of(&loops::WHILE_LET_ON_ITERATOR),
@@ -1664,6 +1666,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&lifetimes::NEEDLESS_LIFETIMES),
         LintId::of(&loops::EXPLICIT_COUNTER_LOOP),
         LintId::of(&loops::MUT_RANGE_BOUND),
+        LintId::of(&loops::SINGLE_ELEMENT_LOOP),
         LintId::of(&loops::WHILE_LET_LOOP),
         LintId::of(&manual_strip::MANUAL_STRIP),
         LintId::of(&manual_unwrap_or::MANUAL_UNWRAP_OR),
diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 63d7e3176b1..e50aa9ac15a 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -4,9 +4,10 @@ use crate::utils::sugg::Sugg;
 use crate::utils::usage::{is_unused, mutated_variables};
 use crate::utils::{
     contains_name, get_enclosing_block, get_parent_expr, get_trait_def_id, has_iter_method, higher, implements_trait,
-    is_integer_const, is_no_std_crate, is_refutable, is_type_diagnostic_item, last_path_segment, match_trait_method,
-    match_type, match_var, multispan_sugg, qpath_res, snippet, snippet_with_applicability, snippet_with_macro_callsite,
-    span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then, sugg, SpanlessEq,
+    indent_of, is_integer_const, is_no_std_crate, is_refutable, is_type_diagnostic_item, last_path_segment,
+    match_trait_method, match_type, match_var, multispan_sugg, qpath_res, single_segment_path, snippet,
+    snippet_with_applicability, snippet_with_macro_callsite, span_lint, span_lint_and_help, span_lint_and_sugg,
+    span_lint_and_then, sugg, SpanlessEq,
 };
 use if_chain::if_chain;
 use rustc_ast::ast;
@@ -452,6 +453,31 @@ declare_clippy_lint! {
     "the same item is pushed inside of a for loop"
 }
 
+declare_clippy_lint! {
+    /// **What it does:** Checks whether a for loop has a single element.
+    ///
+    /// **Why is this bad?** There is no reason to have a loop of a
+    /// single element.
+    /// **Known problems:** None
+    ///
+    /// **Example:**
+    /// ```rust
+    /// let item1 = 2;
+    /// for item in &[item1] {
+    ///     println!("{}", item);
+    /// }
+    /// ```
+    /// could be written as
+    /// ```rust
+    /// let item1 = 2;
+    /// let item = &item1;
+    /// println!("{}", item);
+    /// ```
+    pub SINGLE_ELEMENT_LOOP,
+    complexity,
+    "there is no reason to have a single element loop"
+}
+
 declare_lint_pass!(Loops => [
     MANUAL_MEMCPY,
     NEEDLESS_RANGE_LOOP,
@@ -469,6 +495,7 @@ declare_lint_pass!(Loops => [
     MUT_RANGE_BOUND,
     WHILE_IMMUTABLE_CONDITION,
     SAME_ITEM_PUSH,
+    SINGLE_ELEMENT_LOOP,
 ]);
 
 impl<'tcx> LateLintPass<'tcx> for Loops {
@@ -777,6 +804,7 @@ fn check_for_loop<'tcx>(
     check_for_loop_arg(cx, pat, arg, expr);
     check_for_loop_over_map_kv(cx, pat, arg, body, expr);
     check_for_mut_range_bound(cx, arg, body);
+    check_for_single_element_loop(cx, pat, arg, body, expr);
     detect_same_item_push(cx, pat, arg, body, expr);
 }
 
@@ -1866,6 +1894,43 @@ fn check_for_loop_over_map_kv<'tcx>(
     }
 }
 
+fn check_for_single_element_loop<'tcx>(
+    cx: &LateContext<'tcx>,
+    pat: &'tcx Pat<'_>,
+    arg: &'tcx Expr<'_>,
+    body: &'tcx Expr<'_>,
+    expr: &'tcx Expr<'_>,
+) {
+    if_chain! {
+        if let ExprKind::AddrOf(BorrowKind::Ref, _, ref arg_expr) = arg.kind;
+        if let PatKind::Binding(.., target, _) = pat.kind;
+        if let ExprKind::Array(ref arg_expr_list) = arg_expr.kind;
+        if let [arg_expression] = arg_expr_list;
+        if let ExprKind::Path(ref list_item) = arg_expression.kind;
+        if let Some(list_item_name) = single_segment_path(list_item).map(|ps| ps.ident.name);
+        if let ExprKind::Block(ref block, _) = body.kind;
+        if !block.stmts.is_empty();
+
+        then {
+            let for_span = get_span_of_entire_for_loop(expr);
+            let mut block_str = snippet(cx, block.span, "..").into_owned();
+            block_str.remove(0);
+            block_str.pop();
+
+
+            span_lint_and_sugg(
+                cx,
+                SINGLE_ELEMENT_LOOP,
+                for_span,
+                "for loop over a single element",
+                "try",
+                format!("{{\n{}let {} = &{};{}}}", " ".repeat(indent_of(cx, block.stmts[0].span).unwrap_or(0)), target.name, list_item_name, block_str),
+                Applicability::MachineApplicable
+            )
+        }
+    }
+}
+
 struct MutatePairDelegate<'a, 'tcx> {
     cx: &'a LateContext<'tcx>,
     hir_id_low: Option<HirId>,
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index 6301d623a2b..70369dc582a 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -2125,6 +2125,13 @@ vec![
         deprecation: None,
         module: "single_component_path_imports",
     },
+    Lint {
+        name: "single_element_loop",
+        group: "complexity",
+        desc: "there is no reason to have a single element loop",
+        deprecation: None,
+        module: "loops",
+    },
     Lint {
         name: "single_match",
         group: "style",
diff --git a/tests/ui/single_element_loop.fixed b/tests/ui/single_element_loop.fixed
new file mode 100644
index 00000000000..8ca068293a6
--- /dev/null
+++ b/tests/ui/single_element_loop.fixed
@@ -0,0 +1,11 @@
+// run-rustfix
+// Tests from for_loop.rs that don't have suggestions
+
+#[warn(clippy::single_element_loop)]
+fn main() {
+    let item1 = 2;
+    {
+        let item = &item1;
+        println!("{}", item);
+    }
+}
diff --git a/tests/ui/single_element_loop.rs b/tests/ui/single_element_loop.rs
new file mode 100644
index 00000000000..57e9336a31f
--- /dev/null
+++ b/tests/ui/single_element_loop.rs
@@ -0,0 +1,10 @@
+// run-rustfix
+// Tests from for_loop.rs that don't have suggestions
+
+#[warn(clippy::single_element_loop)]
+fn main() {
+    let item1 = 2;
+    for item in &[item1] {
+        println!("{}", item);
+    }
+}
diff --git a/tests/ui/single_element_loop.stderr b/tests/ui/single_element_loop.stderr
new file mode 100644
index 00000000000..90be1dc3283
--- /dev/null
+++ b/tests/ui/single_element_loop.stderr
@@ -0,0 +1,19 @@
+error: for loop over a single element
+  --> $DIR/single_element_loop.rs:7:5
+   |
+LL | /     for item in &[item1] {
+LL | |         println!("{}", item);
+LL | |     }
+   | |_____^
+   |
+   = note: `-D clippy::single-element-loop` implied by `-D warnings`
+help: try
+   |
+LL |     {
+LL |         let item = &item1;
+LL |         println!("{}", item);
+LL |     }
+   |
+
+error: aborting due to previous error
+
-- 
cgit 1.4.1-3-g733a5


From 65b52d84f83586752bff2834410e131290dc0155 Mon Sep 17 00:00:00 2001
From: Tim Nielens <tim.nielens@gmail.com>
Date: Tue, 20 Oct 2020 00:38:13 +0200
Subject: needless-lifetime / multiple where clause predicates regression

---
 clippy_lints/src/lifetimes.rs  |  6 ++++--
 tests/ui/needless_lifetimes.rs | 11 +++++++++++
 2 files changed, 15 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lifetimes.rs b/clippy_lints/src/lifetimes.rs
index d7043e7bd8f..c8a5a9c9431 100644
--- a/clippy_lints/src/lifetimes.rs
+++ b/clippy_lints/src/lifetimes.rs
@@ -414,7 +414,7 @@ fn has_where_lifetimes<'tcx>(cx: &LateContext<'tcx>, where_clause: &'tcx WhereCl
                 let mut visitor = RefVisitor::new(cx);
                 // walk the type F, it may not contain LT refs
                 walk_ty(&mut visitor, &pred.bounded_ty);
-                if !visitor.lts.is_empty() {
+                if !visitor.all_lts().is_empty() {
                     return true;
                 }
                 // if the bounds define new lifetimes, they are fine to occur
@@ -424,7 +424,9 @@ fn has_where_lifetimes<'tcx>(cx: &LateContext<'tcx>, where_clause: &'tcx WhereCl
                     walk_param_bound(&mut visitor, bound);
                 }
                 // and check that all lifetimes are allowed
-                return visitor.all_lts().iter().any(|it| !allowed_lts.contains(it));
+                if visitor.all_lts().iter().any(|it| !allowed_lts.contains(it)) {
+                    return true;
+                }
             },
             WherePredicate::EqPredicate(ref pred) => {
                 let mut visitor = RefVisitor::new(cx);
diff --git a/tests/ui/needless_lifetimes.rs b/tests/ui/needless_lifetimes.rs
index d482d466e44..6001ef37eb7 100644
--- a/tests/ui/needless_lifetimes.rs
+++ b/tests/ui/needless_lifetimes.rs
@@ -357,4 +357,15 @@ mod nested_elision_sites {
     }
 }
 
+mod issue6159 {
+    use std::ops::Deref;
+    pub fn apply_deref<'a, T, F, R>(x: &'a T, f: F) -> R
+    where
+        T: Deref,
+        F: FnOnce(&'a T::Target) -> R,
+    {
+        f(x.deref())
+    }
+}
+
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 57bf80f77626b134faaf2cd95664403627fba0da Mon Sep 17 00:00:00 2001
From: Daniel Smith <daniel.smith@datadoghq.com>
Date: Thu, 10 Sep 2020 15:53:36 -0400
Subject: Add lint for holding RefCell Ref across an await

---
 clippy_lints/src/await_holding_refcell_ref.rs | 83 +++++++++++++++++++++++++++
 clippy_lints/src/lib.rs                       |  4 ++
 clippy_lints/src/utils/paths.rs               |  2 +
 tests/ui/await_holding_refcell_ref.rs         | 71 +++++++++++++++++++++++
 tests/ui/await_holding_refcell_ref.stderr     | 77 +++++++++++++++++++++++++
 5 files changed, 237 insertions(+)
 create mode 100644 clippy_lints/src/await_holding_refcell_ref.rs
 create mode 100644 tests/ui/await_holding_refcell_ref.rs
 create mode 100644 tests/ui/await_holding_refcell_ref.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/await_holding_refcell_ref.rs b/clippy_lints/src/await_holding_refcell_ref.rs
new file mode 100644
index 00000000000..9a75911acbe
--- /dev/null
+++ b/clippy_lints/src/await_holding_refcell_ref.rs
@@ -0,0 +1,83 @@
+use crate::utils::{match_def_path, paths, span_lint_and_note};
+use rustc_hir::def_id::DefId;
+use rustc_hir::{AsyncGeneratorKind, Body, BodyId, GeneratorKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::GeneratorInteriorTypeCause;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::Span;
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for calls to await while holding a
+    /// `RefCell` `Ref` or `RefMut`.
+    ///
+    /// **Why is this bad?** `RefCell` refs only check for exclusive mutable access
+    /// at runtime. Holding onto a `RefCell` ref across an `await` suspension point
+    /// risks panics from a mutable ref shared while other refs are outstanding.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust,ignore
+    /// use std::cell::RefCell;
+    ///
+    /// async fn foo(x: &RefCell<u32>) {
+    ///   let b = x.borrow_mut()();
+    ///   *ref += 1;
+    ///   bar.await;
+    /// }
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust,ignore
+    /// use std::cell::RefCell;
+    ///
+    /// async fn foo(x: &RefCell<u32>) {
+    ///   {
+    ///     let b = x.borrow_mut();
+    ///     *ref += 1;
+    ///   }
+    ///   bar.await;
+    /// }
+    /// ```
+    pub AWAIT_HOLDING_REFCELL_REF,
+    pedantic,
+    "Inside an async function, holding a RefCell ref while calling await"
+}
+
+declare_lint_pass!(AwaitHoldingRefCellRef => [AWAIT_HOLDING_REFCELL_REF]);
+
+impl LateLintPass<'_> for AwaitHoldingRefCellRef {
+    fn check_body(&mut self, cx: &LateContext<'_>, body: &'_ Body<'_>) {
+        use AsyncGeneratorKind::{Block, Closure, Fn};
+        if let Some(GeneratorKind::Async(Block | Closure | Fn)) = body.generator_kind {
+            let body_id = BodyId {
+                hir_id: body.value.hir_id,
+            };
+            let def_id = cx.tcx.hir().body_owner_def_id(body_id);
+            let typeck_results = cx.tcx.typeck(def_id);
+            check_interior_types(cx, &typeck_results.generator_interior_types, body.value.span);
+        }
+    }
+}
+
+fn check_interior_types(cx: &LateContext<'_>, ty_causes: &[GeneratorInteriorTypeCause<'_>], span: Span) {
+    for ty_cause in ty_causes {
+        if let rustc_middle::ty::Adt(adt, _) = ty_cause.ty.kind() {
+            if is_refcell_ref(cx, adt.did) {
+                span_lint_and_note(
+                    cx,
+                    AWAIT_HOLDING_REFCELL_REF,
+                    ty_cause.span,
+                    "this RefCell Ref is held across an 'await' point. Consider ensuring the Ref is dropped before calling await.",
+                    ty_cause.scope_span.or(Some(span)),
+                    "these are all the await points this ref is held through",
+                );
+            }
+        }
+    }
+}
+
+fn is_refcell_ref(cx: &LateContext<'_>, def_id: DefId) -> bool {
+    match_def_path(cx, def_id, &paths::REFCELL_REF) || match_def_path(cx, def_id, &paths::REFCELL_REFMUT)
+}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index d4d2f92a6a6..69719986104 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -161,6 +161,7 @@ mod async_yields_async;
 mod atomic_ordering;
 mod attrs;
 mod await_holding_lock;
+mod await_holding_refcell_ref;
 mod bit_mask;
 mod blacklisted_name;
 mod blocks_in_if_conditions;
@@ -510,6 +511,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &attrs::UNKNOWN_CLIPPY_LINTS,
         &attrs::USELESS_ATTRIBUTE,
         &await_holding_lock::AWAIT_HOLDING_LOCK,
+        &await_holding_refcell_ref::AWAIT_HOLDING_REFCELL_REF,
         &bit_mask::BAD_BIT_MASK,
         &bit_mask::INEFFECTIVE_BIT_MASK,
         &bit_mask::VERBOSE_BIT_MASK,
@@ -906,6 +908,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     // end register lints, do not remove this comment, it’s used in `update_lints`
 
     store.register_late_pass(|| box await_holding_lock::AwaitHoldingLock);
+    store.register_late_pass(|| box await_holding_refcell_ref::AwaitHoldingRefCellRef);
     store.register_late_pass(|| box serde_api::SerdeAPI);
     store.register_late_pass(|| box utils::internal_lints::CompilerLintFunctions::new());
     store.register_late_pass(|| box utils::internal_lints::LintWithoutLintPass::default());
@@ -1189,6 +1192,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_group(true, "clippy::pedantic", Some("clippy_pedantic"), vec![
         LintId::of(&attrs::INLINE_ALWAYS),
         LintId::of(&await_holding_lock::AWAIT_HOLDING_LOCK),
+        LintId::of(&await_holding_refcell_ref::AWAIT_HOLDING_REFCELL_REF),
         LintId::of(&bit_mask::VERBOSE_BIT_MASK),
         LintId::of(&checked_conversions::CHECKED_CONVERSIONS),
         LintId::of(&copies::MATCH_SAME_ARMS),
diff --git a/clippy_lints/src/utils/paths.rs b/clippy_lints/src/utils/paths.rs
index 5e769c690a6..cd9b92efe58 100644
--- a/clippy_lints/src/utils/paths.rs
+++ b/clippy_lints/src/utils/paths.rs
@@ -93,6 +93,8 @@ pub const RANGE_ARGUMENT_TRAIT: [&str; 3] = ["core", "ops", "RangeBounds"];
 pub const RC: [&str; 3] = ["alloc", "rc", "Rc"];
 pub const RC_PTR_EQ: [&str; 4] = ["alloc", "rc", "Rc", "ptr_eq"];
 pub const RECEIVER: [&str; 4] = ["std", "sync", "mpsc", "Receiver"];
+pub const REFCELL_REF: [&str; 3] = ["core", "cell", "Ref"];
+pub const REFCELL_REFMUT: [&str; 3] = ["core", "cell", "RefMut"];
 pub const REGEX_BUILDER_NEW: [&str; 5] = ["regex", "re_builder", "unicode", "RegexBuilder", "new"];
 pub const REGEX_BYTES_BUILDER_NEW: [&str; 5] = ["regex", "re_builder", "bytes", "RegexBuilder", "new"];
 pub const REGEX_BYTES_NEW: [&str; 4] = ["regex", "re_bytes", "Regex", "new"];
diff --git a/tests/ui/await_holding_refcell_ref.rs b/tests/ui/await_holding_refcell_ref.rs
new file mode 100644
index 00000000000..6e330f47dfc
--- /dev/null
+++ b/tests/ui/await_holding_refcell_ref.rs
@@ -0,0 +1,71 @@
+// edition:2018
+#![warn(clippy::await_holding_refcell_ref)]
+
+use std::cell::RefCell;
+
+async fn bad(x: &RefCell<u32>) -> u32 {
+    let b = x.borrow();
+    baz().await
+}
+
+async fn bad_mut(x: &RefCell<u32>) -> u32 {
+    let b = x.borrow_mut();
+    baz().await
+}
+
+async fn good(x: &RefCell<u32>) -> u32 {
+    {
+        let b = x.borrow_mut();
+        let y = *b + 1;
+    }
+    baz().await;
+    let b = x.borrow_mut();
+    47
+}
+
+async fn baz() -> u32 {
+    42
+}
+
+async fn also_bad(x: &RefCell<u32>) -> u32 {
+    let first = baz().await;
+
+    let b = x.borrow_mut();
+
+    let second = baz().await;
+
+    let third = baz().await;
+
+    first + second + third
+}
+
+async fn not_good(x: &RefCell<u32>) -> u32 {
+    let first = baz().await;
+
+    let second = {
+        let b = x.borrow_mut();
+        baz().await
+    };
+
+    let third = baz().await;
+
+    first + second + third
+}
+
+#[allow(clippy::manual_async_fn)]
+fn block_bad(x: &RefCell<u32>) -> impl std::future::Future<Output = u32> + '_ {
+    async move {
+        let b = x.borrow_mut();
+        baz().await
+    }
+}
+
+fn main() {
+    let m = RefCell::new(100);
+    good(&m);
+    bad(&m);
+    bad_mut(&m);    
+    also_bad(&m);
+    not_good(&m);
+    block_bad(&m);
+}
diff --git a/tests/ui/await_holding_refcell_ref.stderr b/tests/ui/await_holding_refcell_ref.stderr
new file mode 100644
index 00000000000..b114945504a
--- /dev/null
+++ b/tests/ui/await_holding_refcell_ref.stderr
@@ -0,0 +1,77 @@
+error: this RefCell Ref is held across an 'await' point. Consider ensuring the Ref is dropped before calling await.
+  --> $DIR/await_holding_refcell_ref.rs:7:9
+   |
+LL |     let b = x.borrow();
+   |         ^
+   |
+   = note: `-D clippy::await-holding-refcell-ref` implied by `-D warnings`
+note: these are all the await points this ref is held through
+  --> $DIR/await_holding_refcell_ref.rs:7:5
+   |
+LL | /     let b = x.borrow();
+LL | |     baz().await
+LL | | }
+   | |_^
+
+error: this RefCell Ref is held across an 'await' point. Consider ensuring the Ref is dropped before calling await.
+  --> $DIR/await_holding_refcell_ref.rs:12:9
+   |
+LL |     let b = x.borrow_mut();
+   |         ^
+   |
+note: these are all the await points this ref is held through
+  --> $DIR/await_holding_refcell_ref.rs:12:5
+   |
+LL | /     let b = x.borrow_mut();
+LL | |     baz().await
+LL | | }
+   | |_^
+
+error: this RefCell Ref is held across an 'await' point. Consider ensuring the Ref is dropped before calling await.
+  --> $DIR/await_holding_refcell_ref.rs:33:9
+   |
+LL |     let b = x.borrow_mut();
+   |         ^
+   |
+note: these are all the await points this ref is held through
+  --> $DIR/await_holding_refcell_ref.rs:33:5
+   |
+LL | /     let b = x.borrow_mut();
+LL | |
+LL | |     let second = baz().await;
+LL | |
+...  |
+LL | |     first + second + third
+LL | | }
+   | |_^
+
+error: this RefCell Ref is held across an 'await' point. Consider ensuring the Ref is dropped before calling await.
+  --> $DIR/await_holding_refcell_ref.rs:46:13
+   |
+LL |         let b = x.borrow_mut();
+   |             ^
+   |
+note: these are all the await points this ref is held through
+  --> $DIR/await_holding_refcell_ref.rs:46:9
+   |
+LL | /         let b = x.borrow_mut();
+LL | |         baz().await
+LL | |     };
+   | |_____^
+
+error: this RefCell Ref is held across an 'await' point. Consider ensuring the Ref is dropped before calling await.
+  --> $DIR/await_holding_refcell_ref.rs:58:13
+   |
+LL |         let b = x.borrow_mut();
+   |             ^
+   |
+note: these are all the await points this ref is held through
+  --> $DIR/await_holding_refcell_ref.rs:58:9
+   |
+LL | /         let b = x.borrow_mut();
+LL | |         baz().await
+LL | |     }
+   | |_____^
+
+error: aborting due to 5 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 3ed69cdb13e5953467f9d849d7ad480479ca01d6 Mon Sep 17 00:00:00 2001
From: Daniel Smith <daniel.smith@datadoghq.com>
Date: Tue, 13 Oct 2020 12:39:20 -0400
Subject: Move existing lint into shared file

---
 clippy_lints/src/await_holding_invalid.rs | 92 +++++++++++++++++++++++++++++++
 clippy_lints/src/await_holding_lock.rs    | 92 -------------------------------
 clippy_lints/src/lib.rs                   |  8 +--
 src/lintlist/mod.rs                       |  2 +-
 tests/ui/await_holding_invalid.rs         | 65 ++++++++++++++++++++++
 tests/ui/await_holding_invalid.stderr     | 63 +++++++++++++++++++++
 tests/ui/await_holding_lock.rs            | 65 ----------------------
 tests/ui/await_holding_lock.stderr        | 63 ---------------------
 8 files changed, 225 insertions(+), 225 deletions(-)
 create mode 100644 clippy_lints/src/await_holding_invalid.rs
 delete mode 100644 clippy_lints/src/await_holding_lock.rs
 create mode 100644 tests/ui/await_holding_invalid.rs
 create mode 100644 tests/ui/await_holding_invalid.stderr
 delete mode 100644 tests/ui/await_holding_lock.rs
 delete mode 100644 tests/ui/await_holding_lock.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/await_holding_invalid.rs b/clippy_lints/src/await_holding_invalid.rs
new file mode 100644
index 00000000000..367534499fd
--- /dev/null
+++ b/clippy_lints/src/await_holding_invalid.rs
@@ -0,0 +1,92 @@
+use crate::utils::{match_def_path, paths, span_lint_and_note};
+use rustc_hir::def_id::DefId;
+use rustc_hir::{AsyncGeneratorKind, Body, BodyId, GeneratorKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::GeneratorInteriorTypeCause;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::Span;
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for calls to await while holding a
+    /// non-async-aware MutexGuard.
+    ///
+    /// **Why is this bad?** The Mutex types found in std::sync and parking_lot
+    /// are not designed to operate in an async context across await points.
+    ///
+    /// There are two potential solutions. One is to use an asynx-aware Mutex
+    /// type. Many asynchronous foundation crates provide such a Mutex type. The
+    /// other solution is to ensure the mutex is unlocked before calling await,
+    /// either by introducing a scope or an explicit call to Drop::drop.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust,ignore
+    /// use std::sync::Mutex;
+    ///
+    /// async fn foo(x: &Mutex<u32>) {
+    ///   let guard = x.lock().unwrap();
+    ///   *guard += 1;
+    ///   bar.await;
+    /// }
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust,ignore
+    /// use std::sync::Mutex;
+    ///
+    /// async fn foo(x: &Mutex<u32>) {
+    ///   {
+    ///     let guard = x.lock().unwrap();
+    ///     *guard += 1;
+    ///   }
+    ///   bar.await;
+    /// }
+    /// ```
+    pub AWAIT_HOLDING_LOCK,
+    pedantic,
+    "Inside an async function, holding a MutexGuard while calling await"
+}
+
+declare_lint_pass!(AwaitHoldingLock => [AWAIT_HOLDING_LOCK]);
+
+impl LateLintPass<'_> for AwaitHoldingLock {
+    fn check_body(&mut self, cx: &LateContext<'_>, body: &'_ Body<'_>) {
+        use AsyncGeneratorKind::{Block, Closure, Fn};
+        if let Some(GeneratorKind::Async(Block | Closure | Fn)) = body.generator_kind {
+            let body_id = BodyId {
+                hir_id: body.value.hir_id,
+            };
+            let def_id = cx.tcx.hir().body_owner_def_id(body_id);
+            let typeck_results = cx.tcx.typeck(def_id);
+            check_interior_types(cx, &typeck_results.generator_interior_types, body.value.span);
+        }
+    }
+}
+
+fn check_interior_types(cx: &LateContext<'_>, ty_causes: &[GeneratorInteriorTypeCause<'_>], span: Span) {
+    for ty_cause in ty_causes {
+        if let rustc_middle::ty::Adt(adt, _) = ty_cause.ty.kind() {
+            if is_mutex_guard(cx, adt.did) {
+                span_lint_and_note(
+                    cx,
+                    AWAIT_HOLDING_LOCK,
+                    ty_cause.span,
+                    "this MutexGuard is held across an 'await' point. Consider using an async-aware Mutex type or ensuring the MutexGuard is dropped before calling await.",
+                    ty_cause.scope_span.or(Some(span)),
+                    "these are all the await points this lock is held through",
+                );
+            }
+        }
+    }
+}
+
+fn is_mutex_guard(cx: &LateContext<'_>, def_id: DefId) -> bool {
+    match_def_path(cx, def_id, &paths::MUTEX_GUARD)
+        || match_def_path(cx, def_id, &paths::RWLOCK_READ_GUARD)
+        || match_def_path(cx, def_id, &paths::RWLOCK_WRITE_GUARD)
+        || match_def_path(cx, def_id, &paths::PARKING_LOT_MUTEX_GUARD)
+        || match_def_path(cx, def_id, &paths::PARKING_LOT_RWLOCK_READ_GUARD)
+        || match_def_path(cx, def_id, &paths::PARKING_LOT_RWLOCK_WRITE_GUARD)
+}
diff --git a/clippy_lints/src/await_holding_lock.rs b/clippy_lints/src/await_holding_lock.rs
deleted file mode 100644
index 367534499fd..00000000000
--- a/clippy_lints/src/await_holding_lock.rs
+++ /dev/null
@@ -1,92 +0,0 @@
-use crate::utils::{match_def_path, paths, span_lint_and_note};
-use rustc_hir::def_id::DefId;
-use rustc_hir::{AsyncGeneratorKind, Body, BodyId, GeneratorKind};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty::GeneratorInteriorTypeCause;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::Span;
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for calls to await while holding a
-    /// non-async-aware MutexGuard.
-    ///
-    /// **Why is this bad?** The Mutex types found in std::sync and parking_lot
-    /// are not designed to operate in an async context across await points.
-    ///
-    /// There are two potential solutions. One is to use an asynx-aware Mutex
-    /// type. Many asynchronous foundation crates provide such a Mutex type. The
-    /// other solution is to ensure the mutex is unlocked before calling await,
-    /// either by introducing a scope or an explicit call to Drop::drop.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
-    /// ```rust,ignore
-    /// use std::sync::Mutex;
-    ///
-    /// async fn foo(x: &Mutex<u32>) {
-    ///   let guard = x.lock().unwrap();
-    ///   *guard += 1;
-    ///   bar.await;
-    /// }
-    /// ```
-    ///
-    /// Use instead:
-    /// ```rust,ignore
-    /// use std::sync::Mutex;
-    ///
-    /// async fn foo(x: &Mutex<u32>) {
-    ///   {
-    ///     let guard = x.lock().unwrap();
-    ///     *guard += 1;
-    ///   }
-    ///   bar.await;
-    /// }
-    /// ```
-    pub AWAIT_HOLDING_LOCK,
-    pedantic,
-    "Inside an async function, holding a MutexGuard while calling await"
-}
-
-declare_lint_pass!(AwaitHoldingLock => [AWAIT_HOLDING_LOCK]);
-
-impl LateLintPass<'_> for AwaitHoldingLock {
-    fn check_body(&mut self, cx: &LateContext<'_>, body: &'_ Body<'_>) {
-        use AsyncGeneratorKind::{Block, Closure, Fn};
-        if let Some(GeneratorKind::Async(Block | Closure | Fn)) = body.generator_kind {
-            let body_id = BodyId {
-                hir_id: body.value.hir_id,
-            };
-            let def_id = cx.tcx.hir().body_owner_def_id(body_id);
-            let typeck_results = cx.tcx.typeck(def_id);
-            check_interior_types(cx, &typeck_results.generator_interior_types, body.value.span);
-        }
-    }
-}
-
-fn check_interior_types(cx: &LateContext<'_>, ty_causes: &[GeneratorInteriorTypeCause<'_>], span: Span) {
-    for ty_cause in ty_causes {
-        if let rustc_middle::ty::Adt(adt, _) = ty_cause.ty.kind() {
-            if is_mutex_guard(cx, adt.did) {
-                span_lint_and_note(
-                    cx,
-                    AWAIT_HOLDING_LOCK,
-                    ty_cause.span,
-                    "this MutexGuard is held across an 'await' point. Consider using an async-aware Mutex type or ensuring the MutexGuard is dropped before calling await.",
-                    ty_cause.scope_span.or(Some(span)),
-                    "these are all the await points this lock is held through",
-                );
-            }
-        }
-    }
-}
-
-fn is_mutex_guard(cx: &LateContext<'_>, def_id: DefId) -> bool {
-    match_def_path(cx, def_id, &paths::MUTEX_GUARD)
-        || match_def_path(cx, def_id, &paths::RWLOCK_READ_GUARD)
-        || match_def_path(cx, def_id, &paths::RWLOCK_WRITE_GUARD)
-        || match_def_path(cx, def_id, &paths::PARKING_LOT_MUTEX_GUARD)
-        || match_def_path(cx, def_id, &paths::PARKING_LOT_RWLOCK_READ_GUARD)
-        || match_def_path(cx, def_id, &paths::PARKING_LOT_RWLOCK_WRITE_GUARD)
-}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 69719986104..47cc0c90322 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -160,7 +160,7 @@ mod assign_ops;
 mod async_yields_async;
 mod atomic_ordering;
 mod attrs;
-mod await_holding_lock;
+mod await_holding_invalid;
 mod await_holding_refcell_ref;
 mod bit_mask;
 mod blacklisted_name;
@@ -510,7 +510,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &attrs::MISMATCHED_TARGET_OS,
         &attrs::UNKNOWN_CLIPPY_LINTS,
         &attrs::USELESS_ATTRIBUTE,
-        &await_holding_lock::AWAIT_HOLDING_LOCK,
+        &await_holding_invalid::AWAIT_HOLDING_LOCK,
         &await_holding_refcell_ref::AWAIT_HOLDING_REFCELL_REF,
         &bit_mask::BAD_BIT_MASK,
         &bit_mask::INEFFECTIVE_BIT_MASK,
@@ -907,7 +907,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     ]);
     // end register lints, do not remove this comment, it’s used in `update_lints`
 
-    store.register_late_pass(|| box await_holding_lock::AwaitHoldingLock);
+    store.register_late_pass(|| box await_holding_invalid::AwaitHoldingLock);
     store.register_late_pass(|| box await_holding_refcell_ref::AwaitHoldingRefCellRef);
     store.register_late_pass(|| box serde_api::SerdeAPI);
     store.register_late_pass(|| box utils::internal_lints::CompilerLintFunctions::new());
@@ -1191,7 +1191,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
 
     store.register_group(true, "clippy::pedantic", Some("clippy_pedantic"), vec![
         LintId::of(&attrs::INLINE_ALWAYS),
-        LintId::of(&await_holding_lock::AWAIT_HOLDING_LOCK),
+        LintId::of(&await_holding_invalid::AWAIT_HOLDING_LOCK),
         LintId::of(&await_holding_refcell_ref::AWAIT_HOLDING_REFCELL_REF),
         LintId::of(&bit_mask::VERBOSE_BIT_MASK),
         LintId::of(&checked_conversions::CHECKED_CONVERSIONS),
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index 21185a08d5c..63e9220ccd5 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -65,7 +65,7 @@ vec![
         group: "pedantic",
         desc: "Inside an async function, holding a MutexGuard while calling await",
         deprecation: None,
-        module: "await_holding_lock",
+        module: "await_holding_invalid",
     },
     Lint {
         name: "await_holding_refcell_ref",
diff --git a/tests/ui/await_holding_invalid.rs b/tests/ui/await_holding_invalid.rs
new file mode 100644
index 00000000000..0458950edee
--- /dev/null
+++ b/tests/ui/await_holding_invalid.rs
@@ -0,0 +1,65 @@
+// edition:2018
+#![warn(clippy::await_holding_lock)]
+
+use std::sync::Mutex;
+
+async fn bad(x: &Mutex<u32>) -> u32 {
+    let guard = x.lock().unwrap();
+    baz().await
+}
+
+async fn good(x: &Mutex<u32>) -> u32 {
+    {
+        let guard = x.lock().unwrap();
+        let y = *guard + 1;
+    }
+    baz().await;
+    let guard = x.lock().unwrap();
+    47
+}
+
+async fn baz() -> u32 {
+    42
+}
+
+async fn also_bad(x: &Mutex<u32>) -> u32 {
+    let first = baz().await;
+
+    let guard = x.lock().unwrap();
+
+    let second = baz().await;
+
+    let third = baz().await;
+
+    first + second + third
+}
+
+async fn not_good(x: &Mutex<u32>) -> u32 {
+    let first = baz().await;
+
+    let second = {
+        let guard = x.lock().unwrap();
+        baz().await
+    };
+
+    let third = baz().await;
+
+    first + second + third
+}
+
+#[allow(clippy::manual_async_fn)]
+fn block_bad(x: &Mutex<u32>) -> impl std::future::Future<Output = u32> + '_ {
+    async move {
+        let guard = x.lock().unwrap();
+        baz().await
+    }
+}
+
+fn main() {
+    let m = Mutex::new(100);
+    good(&m);
+    bad(&m);
+    also_bad(&m);
+    not_good(&m);
+    block_bad(&m);
+}
diff --git a/tests/ui/await_holding_invalid.stderr b/tests/ui/await_holding_invalid.stderr
new file mode 100644
index 00000000000..315d5731b96
--- /dev/null
+++ b/tests/ui/await_holding_invalid.stderr
@@ -0,0 +1,63 @@
+error: this MutexGuard is held across an 'await' point. Consider using an async-aware Mutex type or ensuring the MutexGuard is dropped before calling await.
+  --> $DIR/await_holding_invalid.rs:7:9
+   |
+LL |     let guard = x.lock().unwrap();
+   |         ^^^^^
+   |
+   = note: `-D clippy::await-holding-lock` implied by `-D warnings`
+note: these are all the await points this lock is held through
+  --> $DIR/await_holding_invalid.rs:7:5
+   |
+LL | /     let guard = x.lock().unwrap();
+LL | |     baz().await
+LL | | }
+   | |_^
+
+error: this MutexGuard is held across an 'await' point. Consider using an async-aware Mutex type or ensuring the MutexGuard is dropped before calling await.
+  --> $DIR/await_holding_invalid.rs:28:9
+   |
+LL |     let guard = x.lock().unwrap();
+   |         ^^^^^
+   |
+note: these are all the await points this lock is held through
+  --> $DIR/await_holding_invalid.rs:28:5
+   |
+LL | /     let guard = x.lock().unwrap();
+LL | |
+LL | |     let second = baz().await;
+LL | |
+...  |
+LL | |     first + second + third
+LL | | }
+   | |_^
+
+error: this MutexGuard is held across an 'await' point. Consider using an async-aware Mutex type or ensuring the MutexGuard is dropped before calling await.
+  --> $DIR/await_holding_invalid.rs:41:13
+   |
+LL |         let guard = x.lock().unwrap();
+   |             ^^^^^
+   |
+note: these are all the await points this lock is held through
+  --> $DIR/await_holding_invalid.rs:41:9
+   |
+LL | /         let guard = x.lock().unwrap();
+LL | |         baz().await
+LL | |     };
+   | |_____^
+
+error: this MutexGuard is held across an 'await' point. Consider using an async-aware Mutex type or ensuring the MutexGuard is dropped before calling await.
+  --> $DIR/await_holding_invalid.rs:53:13
+   |
+LL |         let guard = x.lock().unwrap();
+   |             ^^^^^
+   |
+note: these are all the await points this lock is held through
+  --> $DIR/await_holding_invalid.rs:53:9
+   |
+LL | /         let guard = x.lock().unwrap();
+LL | |         baz().await
+LL | |     }
+   | |_____^
+
+error: aborting due to 4 previous errors
+
diff --git a/tests/ui/await_holding_lock.rs b/tests/ui/await_holding_lock.rs
deleted file mode 100644
index 0458950edee..00000000000
--- a/tests/ui/await_holding_lock.rs
+++ /dev/null
@@ -1,65 +0,0 @@
-// edition:2018
-#![warn(clippy::await_holding_lock)]
-
-use std::sync::Mutex;
-
-async fn bad(x: &Mutex<u32>) -> u32 {
-    let guard = x.lock().unwrap();
-    baz().await
-}
-
-async fn good(x: &Mutex<u32>) -> u32 {
-    {
-        let guard = x.lock().unwrap();
-        let y = *guard + 1;
-    }
-    baz().await;
-    let guard = x.lock().unwrap();
-    47
-}
-
-async fn baz() -> u32 {
-    42
-}
-
-async fn also_bad(x: &Mutex<u32>) -> u32 {
-    let first = baz().await;
-
-    let guard = x.lock().unwrap();
-
-    let second = baz().await;
-
-    let third = baz().await;
-
-    first + second + third
-}
-
-async fn not_good(x: &Mutex<u32>) -> u32 {
-    let first = baz().await;
-
-    let second = {
-        let guard = x.lock().unwrap();
-        baz().await
-    };
-
-    let third = baz().await;
-
-    first + second + third
-}
-
-#[allow(clippy::manual_async_fn)]
-fn block_bad(x: &Mutex<u32>) -> impl std::future::Future<Output = u32> + '_ {
-    async move {
-        let guard = x.lock().unwrap();
-        baz().await
-    }
-}
-
-fn main() {
-    let m = Mutex::new(100);
-    good(&m);
-    bad(&m);
-    also_bad(&m);
-    not_good(&m);
-    block_bad(&m);
-}
diff --git a/tests/ui/await_holding_lock.stderr b/tests/ui/await_holding_lock.stderr
deleted file mode 100644
index 21bf49d16f0..00000000000
--- a/tests/ui/await_holding_lock.stderr
+++ /dev/null
@@ -1,63 +0,0 @@
-error: this MutexGuard is held across an 'await' point. Consider using an async-aware Mutex type or ensuring the MutexGuard is dropped before calling await.
-  --> $DIR/await_holding_lock.rs:7:9
-   |
-LL |     let guard = x.lock().unwrap();
-   |         ^^^^^
-   |
-   = note: `-D clippy::await-holding-lock` implied by `-D warnings`
-note: these are all the await points this lock is held through
-  --> $DIR/await_holding_lock.rs:7:5
-   |
-LL | /     let guard = x.lock().unwrap();
-LL | |     baz().await
-LL | | }
-   | |_^
-
-error: this MutexGuard is held across an 'await' point. Consider using an async-aware Mutex type or ensuring the MutexGuard is dropped before calling await.
-  --> $DIR/await_holding_lock.rs:28:9
-   |
-LL |     let guard = x.lock().unwrap();
-   |         ^^^^^
-   |
-note: these are all the await points this lock is held through
-  --> $DIR/await_holding_lock.rs:28:5
-   |
-LL | /     let guard = x.lock().unwrap();
-LL | |
-LL | |     let second = baz().await;
-LL | |
-...  |
-LL | |     first + second + third
-LL | | }
-   | |_^
-
-error: this MutexGuard is held across an 'await' point. Consider using an async-aware Mutex type or ensuring the MutexGuard is dropped before calling await.
-  --> $DIR/await_holding_lock.rs:41:13
-   |
-LL |         let guard = x.lock().unwrap();
-   |             ^^^^^
-   |
-note: these are all the await points this lock is held through
-  --> $DIR/await_holding_lock.rs:41:9
-   |
-LL | /         let guard = x.lock().unwrap();
-LL | |         baz().await
-LL | |     };
-   | |_____^
-
-error: this MutexGuard is held across an 'await' point. Consider using an async-aware Mutex type or ensuring the MutexGuard is dropped before calling await.
-  --> $DIR/await_holding_lock.rs:53:13
-   |
-LL |         let guard = x.lock().unwrap();
-   |             ^^^^^
-   |
-note: these are all the await points this lock is held through
-  --> $DIR/await_holding_lock.rs:53:9
-   |
-LL | /         let guard = x.lock().unwrap();
-LL | |         baz().await
-LL | |     }
-   | |_____^
-
-error: aborting due to 4 previous errors
-
-- 
cgit 1.4.1-3-g733a5


From ee20ebadafc9b2e4995015097e376c0a866d84af Mon Sep 17 00:00:00 2001
From: Daniel Smith <daniel.smith@datadoghq.com>
Date: Tue, 13 Oct 2020 13:15:45 -0400
Subject: Move refcell lint into shared module

---
 clippy_lints/src/await_holding_invalid.rs     |  80 ++++++++++++++++++-
 clippy_lints/src/await_holding_refcell_ref.rs |  83 -------------------
 clippy_lints/src/lib.rs                       |   7 +-
 src/lintlist/mod.rs                           |   2 +-
 tests/ui/await_holding_invalid.rs             | 104 +++++++++++++++++++++---
 tests/ui/await_holding_invalid.stderr         | 111 +++++++++++++++++++++++---
 tests/ui/await_holding_refcell_ref.rs         |  86 --------------------
 tests/ui/await_holding_refcell_ref.stderr     |  95 ----------------------
 8 files changed, 276 insertions(+), 292 deletions(-)
 delete mode 100644 clippy_lints/src/await_holding_refcell_ref.rs
 delete mode 100644 tests/ui/await_holding_refcell_ref.rs
 delete mode 100644 tests/ui/await_holding_refcell_ref.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/await_holding_invalid.rs b/clippy_lints/src/await_holding_invalid.rs
index 367534499fd..2000bdae363 100644
--- a/clippy_lints/src/await_holding_invalid.rs
+++ b/clippy_lints/src/await_holding_invalid.rs
@@ -60,12 +60,12 @@ impl LateLintPass<'_> for AwaitHoldingLock {
             };
             let def_id = cx.tcx.hir().body_owner_def_id(body_id);
             let typeck_results = cx.tcx.typeck(def_id);
-            check_interior_types(cx, &typeck_results.generator_interior_types, body.value.span);
+            check_interior_types_lock(cx, &typeck_results.generator_interior_types, body.value.span);
         }
     }
 }
 
-fn check_interior_types(cx: &LateContext<'_>, ty_causes: &[GeneratorInteriorTypeCause<'_>], span: Span) {
+fn check_interior_types_lock(cx: &LateContext<'_>, ty_causes: &[GeneratorInteriorTypeCause<'_>], span: Span) {
     for ty_cause in ty_causes {
         if let rustc_middle::ty::Adt(adt, _) = ty_cause.ty.kind() {
             if is_mutex_guard(cx, adt.did) {
@@ -90,3 +90,79 @@ fn is_mutex_guard(cx: &LateContext<'_>, def_id: DefId) -> bool {
         || match_def_path(cx, def_id, &paths::PARKING_LOT_RWLOCK_READ_GUARD)
         || match_def_path(cx, def_id, &paths::PARKING_LOT_RWLOCK_WRITE_GUARD)
 }
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for calls to await while holding a
+    /// `RefCell` `Ref` or `RefMut`.
+    ///
+    /// **Why is this bad?** `RefCell` refs only check for exclusive mutable access
+    /// at runtime. Holding onto a `RefCell` ref across an `await` suspension point
+    /// risks panics from a mutable ref shared while other refs are outstanding.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust,ignore
+    /// use std::cell::RefCell;
+    ///
+    /// async fn foo(x: &RefCell<u32>) {
+    ///   let b = x.borrow_mut()();
+    ///   *ref += 1;
+    ///   bar.await;
+    /// }
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust,ignore
+    /// use std::cell::RefCell;
+    ///
+    /// async fn foo(x: &RefCell<u32>) {
+    ///   {
+    ///     let b = x.borrow_mut();
+    ///     *ref += 1;
+    ///   }
+    ///   bar.await;
+    /// }
+    /// ```
+    pub AWAIT_HOLDING_REFCELL_REF,
+    pedantic,
+    "Inside an async function, holding a RefCell ref while calling await"
+}
+
+declare_lint_pass!(AwaitHoldingRefCellRef => [AWAIT_HOLDING_REFCELL_REF]);
+
+impl LateLintPass<'_> for AwaitHoldingRefCellRef {
+    fn check_body(&mut self, cx: &LateContext<'_>, body: &'_ Body<'_>) {
+        use AsyncGeneratorKind::{Block, Closure, Fn};
+        if let Some(GeneratorKind::Async(Block | Closure | Fn)) = body.generator_kind {
+            let body_id = BodyId {
+                hir_id: body.value.hir_id,
+            };
+            let def_id = cx.tcx.hir().body_owner_def_id(body_id);
+            let typeck_results = cx.tcx.typeck(def_id);
+            check_interior_types_refcell(cx, &typeck_results.generator_interior_types, body.value.span);
+        }
+    }
+}
+
+fn check_interior_types_refcell(cx: &LateContext<'_>, ty_causes: &[GeneratorInteriorTypeCause<'_>], span: Span) {
+    for ty_cause in ty_causes {
+        if let rustc_middle::ty::Adt(adt, _) = ty_cause.ty.kind() {
+            if is_refcell_ref(cx, adt.did) {
+                span_lint_and_note(
+                        cx,
+                        AWAIT_HOLDING_REFCELL_REF,
+                        ty_cause.span,
+                        "this RefCell Ref is held across an 'await' point. Consider ensuring the Ref is dropped before calling await.",
+                        ty_cause.scope_span.or(Some(span)),
+                        "these are all the await points this ref is held through",
+                    );
+            }
+        }
+    }
+}
+
+fn is_refcell_ref(cx: &LateContext<'_>, def_id: DefId) -> bool {
+    match_def_path(cx, def_id, &paths::REFCELL_REF) || match_def_path(cx, def_id, &paths::REFCELL_REFMUT)
+}
diff --git a/clippy_lints/src/await_holding_refcell_ref.rs b/clippy_lints/src/await_holding_refcell_ref.rs
deleted file mode 100644
index 9a75911acbe..00000000000
--- a/clippy_lints/src/await_holding_refcell_ref.rs
+++ /dev/null
@@ -1,83 +0,0 @@
-use crate::utils::{match_def_path, paths, span_lint_and_note};
-use rustc_hir::def_id::DefId;
-use rustc_hir::{AsyncGeneratorKind, Body, BodyId, GeneratorKind};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty::GeneratorInteriorTypeCause;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::Span;
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for calls to await while holding a
-    /// `RefCell` `Ref` or `RefMut`.
-    ///
-    /// **Why is this bad?** `RefCell` refs only check for exclusive mutable access
-    /// at runtime. Holding onto a `RefCell` ref across an `await` suspension point
-    /// risks panics from a mutable ref shared while other refs are outstanding.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
-    /// ```rust,ignore
-    /// use std::cell::RefCell;
-    ///
-    /// async fn foo(x: &RefCell<u32>) {
-    ///   let b = x.borrow_mut()();
-    ///   *ref += 1;
-    ///   bar.await;
-    /// }
-    /// ```
-    ///
-    /// Use instead:
-    /// ```rust,ignore
-    /// use std::cell::RefCell;
-    ///
-    /// async fn foo(x: &RefCell<u32>) {
-    ///   {
-    ///     let b = x.borrow_mut();
-    ///     *ref += 1;
-    ///   }
-    ///   bar.await;
-    /// }
-    /// ```
-    pub AWAIT_HOLDING_REFCELL_REF,
-    pedantic,
-    "Inside an async function, holding a RefCell ref while calling await"
-}
-
-declare_lint_pass!(AwaitHoldingRefCellRef => [AWAIT_HOLDING_REFCELL_REF]);
-
-impl LateLintPass<'_> for AwaitHoldingRefCellRef {
-    fn check_body(&mut self, cx: &LateContext<'_>, body: &'_ Body<'_>) {
-        use AsyncGeneratorKind::{Block, Closure, Fn};
-        if let Some(GeneratorKind::Async(Block | Closure | Fn)) = body.generator_kind {
-            let body_id = BodyId {
-                hir_id: body.value.hir_id,
-            };
-            let def_id = cx.tcx.hir().body_owner_def_id(body_id);
-            let typeck_results = cx.tcx.typeck(def_id);
-            check_interior_types(cx, &typeck_results.generator_interior_types, body.value.span);
-        }
-    }
-}
-
-fn check_interior_types(cx: &LateContext<'_>, ty_causes: &[GeneratorInteriorTypeCause<'_>], span: Span) {
-    for ty_cause in ty_causes {
-        if let rustc_middle::ty::Adt(adt, _) = ty_cause.ty.kind() {
-            if is_refcell_ref(cx, adt.did) {
-                span_lint_and_note(
-                    cx,
-                    AWAIT_HOLDING_REFCELL_REF,
-                    ty_cause.span,
-                    "this RefCell Ref is held across an 'await' point. Consider ensuring the Ref is dropped before calling await.",
-                    ty_cause.scope_span.or(Some(span)),
-                    "these are all the await points this ref is held through",
-                );
-            }
-        }
-    }
-}
-
-fn is_refcell_ref(cx: &LateContext<'_>, def_id: DefId) -> bool {
-    match_def_path(cx, def_id, &paths::REFCELL_REF) || match_def_path(cx, def_id, &paths::REFCELL_REFMUT)
-}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 47cc0c90322..0c5baf96970 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -161,7 +161,6 @@ mod async_yields_async;
 mod atomic_ordering;
 mod attrs;
 mod await_holding_invalid;
-mod await_holding_refcell_ref;
 mod bit_mask;
 mod blacklisted_name;
 mod blocks_in_if_conditions;
@@ -511,7 +510,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &attrs::UNKNOWN_CLIPPY_LINTS,
         &attrs::USELESS_ATTRIBUTE,
         &await_holding_invalid::AWAIT_HOLDING_LOCK,
-        &await_holding_refcell_ref::AWAIT_HOLDING_REFCELL_REF,
+        &await_holding_invalid::AWAIT_HOLDING_REFCELL_REF,
         &bit_mask::BAD_BIT_MASK,
         &bit_mask::INEFFECTIVE_BIT_MASK,
         &bit_mask::VERBOSE_BIT_MASK,
@@ -908,7 +907,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     // end register lints, do not remove this comment, it’s used in `update_lints`
 
     store.register_late_pass(|| box await_holding_invalid::AwaitHoldingLock);
-    store.register_late_pass(|| box await_holding_refcell_ref::AwaitHoldingRefCellRef);
+    store.register_late_pass(|| box await_holding_invalid::AwaitHoldingRefCellRef);
     store.register_late_pass(|| box serde_api::SerdeAPI);
     store.register_late_pass(|| box utils::internal_lints::CompilerLintFunctions::new());
     store.register_late_pass(|| box utils::internal_lints::LintWithoutLintPass::default());
@@ -1192,7 +1191,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_group(true, "clippy::pedantic", Some("clippy_pedantic"), vec![
         LintId::of(&attrs::INLINE_ALWAYS),
         LintId::of(&await_holding_invalid::AWAIT_HOLDING_LOCK),
-        LintId::of(&await_holding_refcell_ref::AWAIT_HOLDING_REFCELL_REF),
+        LintId::of(&await_holding_invalid::AWAIT_HOLDING_REFCELL_REF),
         LintId::of(&bit_mask::VERBOSE_BIT_MASK),
         LintId::of(&checked_conversions::CHECKED_CONVERSIONS),
         LintId::of(&copies::MATCH_SAME_ARMS),
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index 63e9220ccd5..c955f37b83a 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -72,7 +72,7 @@ vec![
         group: "pedantic",
         desc: "Inside an async function, holding a RefCell ref while calling await",
         deprecation: None,
-        module: "await_holding_refcell_ref",
+        module: "await_holding_invalid",
     },
     Lint {
         name: "bad_bit_mask",
diff --git a/tests/ui/await_holding_invalid.rs b/tests/ui/await_holding_invalid.rs
index 0458950edee..45aa3e64292 100644
--- a/tests/ui/await_holding_invalid.rs
+++ b/tests/ui/await_holding_invalid.rs
@@ -1,14 +1,15 @@
 // edition:2018
-#![warn(clippy::await_holding_lock)]
+#![warn(clippy::await_holding_lock, clippy::await_holding_refcell_ref)]
 
+use std::cell::RefCell;
 use std::sync::Mutex;
 
-async fn bad(x: &Mutex<u32>) -> u32 {
+async fn bad_lock(x: &Mutex<u32>) -> u32 {
     let guard = x.lock().unwrap();
     baz().await
 }
 
-async fn good(x: &Mutex<u32>) -> u32 {
+async fn good_lock(x: &Mutex<u32>) -> u32 {
     {
         let guard = x.lock().unwrap();
         let y = *guard + 1;
@@ -22,7 +23,7 @@ async fn baz() -> u32 {
     42
 }
 
-async fn also_bad(x: &Mutex<u32>) -> u32 {
+async fn also_bad_lock(x: &Mutex<u32>) -> u32 {
     let first = baz().await;
 
     let guard = x.lock().unwrap();
@@ -34,7 +35,7 @@ async fn also_bad(x: &Mutex<u32>) -> u32 {
     first + second + third
 }
 
-async fn not_good(x: &Mutex<u32>) -> u32 {
+async fn not_good_lock(x: &Mutex<u32>) -> u32 {
     let first = baz().await;
 
     let second = {
@@ -48,18 +49,97 @@ async fn not_good(x: &Mutex<u32>) -> u32 {
 }
 
 #[allow(clippy::manual_async_fn)]
-fn block_bad(x: &Mutex<u32>) -> impl std::future::Future<Output = u32> + '_ {
+fn block_bad_lock(x: &Mutex<u32>) -> impl std::future::Future<Output = u32> + '_ {
     async move {
         let guard = x.lock().unwrap();
         baz().await
     }
 }
 
+async fn bad_refcell(x: &RefCell<u32>) -> u32 {
+    let b = x.borrow();
+    baz().await
+}
+
+async fn bad_mut_refcell(x: &RefCell<u32>) -> u32 {
+    let b = x.borrow_mut();
+    baz().await
+}
+
+async fn good_refcell(x: &RefCell<u32>) -> u32 {
+    {
+        let b = x.borrow_mut();
+        let y = *b + 1;
+    }
+    baz().await;
+    let b = x.borrow_mut();
+    47
+}
+
+async fn also_bad_refcell(x: &RefCell<u32>) -> u32 {
+    let first = baz().await;
+
+    let b = x.borrow_mut();
+
+    let second = baz().await;
+
+    let third = baz().await;
+
+    first + second + third
+}
+
+async fn less_bad_refcell(x: &RefCell<u32>) -> u32 {
+    let first = baz().await;
+
+    let b = x.borrow_mut();
+
+    let second = baz().await;
+
+    drop(b);
+
+    let third = baz().await;
+
+    first + second + third
+}
+
+async fn not_good_refcell(x: &RefCell<u32>) -> u32 {
+    let first = baz().await;
+
+    let second = {
+        let b = x.borrow_mut();
+        baz().await
+    };
+
+    let third = baz().await;
+
+    first + second + third
+}
+
+#[allow(clippy::manual_async_fn)]
+fn block_bad_refcell(x: &RefCell<u32>) -> impl std::future::Future<Output = u32> + '_ {
+    async move {
+        let b = x.borrow_mut();
+        baz().await
+    }
+}
+
 fn main() {
-    let m = Mutex::new(100);
-    good(&m);
-    bad(&m);
-    also_bad(&m);
-    not_good(&m);
-    block_bad(&m);
+    {
+        let m = Mutex::new(100);
+        good_lock(&m);
+        bad_lock(&m);
+        also_bad_lock(&m);
+        not_good_lock(&m);
+        block_bad_lock(&m);
+    }
+    {
+        let rc = RefCell::new(100);
+        good_refcell(&rc);
+        bad_refcell(&rc);
+        bad_mut_refcell(&rc);
+        also_bad_refcell(&rc);
+        less_bad_refcell(&rc);
+        not_good_refcell(&rc);
+        block_bad_refcell(&rc);
+    }
 }
diff --git a/tests/ui/await_holding_invalid.stderr b/tests/ui/await_holding_invalid.stderr
index 315d5731b96..c8d49820c02 100644
--- a/tests/ui/await_holding_invalid.stderr
+++ b/tests/ui/await_holding_invalid.stderr
@@ -1,12 +1,12 @@
 error: this MutexGuard is held across an 'await' point. Consider using an async-aware Mutex type or ensuring the MutexGuard is dropped before calling await.
-  --> $DIR/await_holding_invalid.rs:7:9
+  --> $DIR/await_holding_invalid.rs:8:9
    |
 LL |     let guard = x.lock().unwrap();
    |         ^^^^^
    |
    = note: `-D clippy::await-holding-lock` implied by `-D warnings`
 note: these are all the await points this lock is held through
-  --> $DIR/await_holding_invalid.rs:7:5
+  --> $DIR/await_holding_invalid.rs:8:5
    |
 LL | /     let guard = x.lock().unwrap();
 LL | |     baz().await
@@ -14,13 +14,13 @@ LL | | }
    | |_^
 
 error: this MutexGuard is held across an 'await' point. Consider using an async-aware Mutex type or ensuring the MutexGuard is dropped before calling await.
-  --> $DIR/await_holding_invalid.rs:28:9
+  --> $DIR/await_holding_invalid.rs:29:9
    |
 LL |     let guard = x.lock().unwrap();
    |         ^^^^^
    |
 note: these are all the await points this lock is held through
-  --> $DIR/await_holding_invalid.rs:28:5
+  --> $DIR/await_holding_invalid.rs:29:5
    |
 LL | /     let guard = x.lock().unwrap();
 LL | |
@@ -32,13 +32,13 @@ LL | | }
    | |_^
 
 error: this MutexGuard is held across an 'await' point. Consider using an async-aware Mutex type or ensuring the MutexGuard is dropped before calling await.
-  --> $DIR/await_holding_invalid.rs:41:13
+  --> $DIR/await_holding_invalid.rs:42:13
    |
 LL |         let guard = x.lock().unwrap();
    |             ^^^^^
    |
 note: these are all the await points this lock is held through
-  --> $DIR/await_holding_invalid.rs:41:9
+  --> $DIR/await_holding_invalid.rs:42:9
    |
 LL | /         let guard = x.lock().unwrap();
 LL | |         baz().await
@@ -46,18 +46,111 @@ LL | |     };
    | |_____^
 
 error: this MutexGuard is held across an 'await' point. Consider using an async-aware Mutex type or ensuring the MutexGuard is dropped before calling await.
-  --> $DIR/await_holding_invalid.rs:53:13
+  --> $DIR/await_holding_invalid.rs:54:13
    |
 LL |         let guard = x.lock().unwrap();
    |             ^^^^^
    |
 note: these are all the await points this lock is held through
-  --> $DIR/await_holding_invalid.rs:53:9
+  --> $DIR/await_holding_invalid.rs:54:9
    |
 LL | /         let guard = x.lock().unwrap();
 LL | |         baz().await
 LL | |     }
    | |_____^
 
-error: aborting due to 4 previous errors
+error: this RefCell Ref is held across an 'await' point. Consider ensuring the Ref is dropped before calling await.
+  --> $DIR/await_holding_invalid.rs:60:9
+   |
+LL |     let b = x.borrow();
+   |         ^
+   |
+   = note: `-D clippy::await-holding-refcell-ref` implied by `-D warnings`
+note: these are all the await points this ref is held through
+  --> $DIR/await_holding_invalid.rs:60:5
+   |
+LL | /     let b = x.borrow();
+LL | |     baz().await
+LL | | }
+   | |_^
+
+error: this RefCell Ref is held across an 'await' point. Consider ensuring the Ref is dropped before calling await.
+  --> $DIR/await_holding_invalid.rs:65:9
+   |
+LL |     let b = x.borrow_mut();
+   |         ^
+   |
+note: these are all the await points this ref is held through
+  --> $DIR/await_holding_invalid.rs:65:5
+   |
+LL | /     let b = x.borrow_mut();
+LL | |     baz().await
+LL | | }
+   | |_^
+
+error: this RefCell Ref is held across an 'await' point. Consider ensuring the Ref is dropped before calling await.
+  --> $DIR/await_holding_invalid.rs:82:9
+   |
+LL |     let b = x.borrow_mut();
+   |         ^
+   |
+note: these are all the await points this ref is held through
+  --> $DIR/await_holding_invalid.rs:82:5
+   |
+LL | /     let b = x.borrow_mut();
+LL | |
+LL | |     let second = baz().await;
+LL | |
+...  |
+LL | |     first + second + third
+LL | | }
+   | |_^
+
+error: this RefCell Ref is held across an 'await' point. Consider ensuring the Ref is dropped before calling await.
+  --> $DIR/await_holding_invalid.rs:94:9
+   |
+LL |     let b = x.borrow_mut();
+   |         ^
+   |
+note: these are all the await points this ref is held through
+  --> $DIR/await_holding_invalid.rs:94:5
+   |
+LL | /     let b = x.borrow_mut();
+LL | |
+LL | |     let second = baz().await;
+LL | |
+...  |
+LL | |     first + second + third
+LL | | }
+   | |_^
+
+error: this RefCell Ref is held across an 'await' point. Consider ensuring the Ref is dropped before calling await.
+  --> $DIR/await_holding_invalid.rs:109:13
+   |
+LL |         let b = x.borrow_mut();
+   |             ^
+   |
+note: these are all the await points this ref is held through
+  --> $DIR/await_holding_invalid.rs:109:9
+   |
+LL | /         let b = x.borrow_mut();
+LL | |         baz().await
+LL | |     };
+   | |_____^
+
+error: this RefCell Ref is held across an 'await' point. Consider ensuring the Ref is dropped before calling await.
+  --> $DIR/await_holding_invalid.rs:121:13
+   |
+LL |         let b = x.borrow_mut();
+   |             ^
+   |
+note: these are all the await points this ref is held through
+  --> $DIR/await_holding_invalid.rs:121:9
+   |
+LL | /         let b = x.borrow_mut();
+LL | |         baz().await
+LL | |     }
+   | |_____^
+
+error: aborting due to 10 previous errors
 
diff --git a/tests/ui/await_holding_refcell_ref.rs b/tests/ui/await_holding_refcell_ref.rs
deleted file mode 100644
index 88841597bb6..00000000000
--- a/tests/ui/await_holding_refcell_ref.rs
+++ /dev/null
@@ -1,86 +0,0 @@
-// edition:2018
-#![warn(clippy::await_holding_refcell_ref)]
-
-use std::cell::RefCell;
-
-async fn bad(x: &RefCell<u32>) -> u32 {
-    let b = x.borrow();
-    baz().await
-}
-
-async fn bad_mut(x: &RefCell<u32>) -> u32 {
-    let b = x.borrow_mut();
-    baz().await
-}
-
-async fn good(x: &RefCell<u32>) -> u32 {
-    {
-        let b = x.borrow_mut();
-        let y = *b + 1;
-    }
-    baz().await;
-    let b = x.borrow_mut();
-    47
-}
-
-async fn baz() -> u32 {
-    42
-}
-
-async fn also_bad(x: &RefCell<u32>) -> u32 {
-    let first = baz().await;
-
-    let b = x.borrow_mut();
-
-    let second = baz().await;
-
-    let third = baz().await;
-
-    first + second + third
-}
-
-async fn less_bad(x: &RefCell<u32>) -> u32 {
-    let first = baz().await;
-
-    let b = x.borrow_mut();
-
-    let second = baz().await;
-
-    drop(b);
-
-    let third = baz().await;
-
-    first + second + third
-}
-
-async fn not_good(x: &RefCell<u32>) -> u32 {
-    let first = baz().await;
-
-    let second = {
-        let b = x.borrow_mut();
-        baz().await
-    };
-
-    let third = baz().await;
-
-    first + second + third
-}
-
-#[allow(clippy::manual_async_fn)]
-fn block_bad(x: &RefCell<u32>) -> impl std::future::Future<Output = u32> + '_ {
-    async move {
-        let b = x.borrow_mut();
-        baz().await
-    }
-}
-
-fn main() {
-    let rc = RefCell::new(100);
-    good(&rc);
-    bad(&rc);
-    bad_mut(&rc);
-    also_bad(&rc);
-    less_bad(&rc);
-    not_good(&rc);
-    block_bad(&rc);
-}
diff --git a/tests/ui/await_holding_refcell_ref.stderr b/tests/ui/await_holding_refcell_ref.stderr
deleted file mode 100644
index b504f045491..00000000000
--- a/tests/ui/await_holding_refcell_ref.stderr
+++ /dev/null
@@ -1,95 +0,0 @@
-error: this RefCell Ref is held across an 'await' point. Consider ensuring the Ref is dropped before calling await.
-  --> $DIR/await_holding_refcell_ref.rs:7:9
-   |
-LL |     let b = x.borrow();
-   |         ^
-   |
-   = note: `-D clippy::await-holding-refcell-ref` implied by `-D warnings`
-note: these are all the await points this ref is held through
-  --> $DIR/await_holding_refcell_ref.rs:7:5
-   |
-LL | /     let b = x.borrow();
-LL | |     baz().await
-LL | | }
-   | |_^
-
-error: this RefCell Ref is held across an 'await' point. Consider ensuring the Ref is dropped before calling await.
-  --> $DIR/await_holding_refcell_ref.rs:12:9
-   |
-LL |     let b = x.borrow_mut();
-   |         ^
-   |
-note: these are all the await points this ref is held through
-  --> $DIR/await_holding_refcell_ref.rs:12:5
-   |
-LL | /     let b = x.borrow_mut();
-LL | |     baz().await
-LL | | }
-   | |_^
-
-error: this RefCell Ref is held across an 'await' point. Consider ensuring the Ref is dropped before calling await.
-  --> $DIR/await_holding_refcell_ref.rs:33:9
-   |
-LL |     let b = x.borrow_mut();
-   |         ^
-   |
-note: these are all the await points this ref is held through
-  --> $DIR/await_holding_refcell_ref.rs:33:5
-   |
-LL | /     let b = x.borrow_mut();
-LL | |
-LL | |     let second = baz().await;
-LL | |
-...  |
-LL | |     first + second + third
-LL | | }
-   | |_^
-
-error: this RefCell Ref is held across an 'await' point. Consider ensuring the Ref is dropped before calling await.
-  --> $DIR/await_holding_refcell_ref.rs:45:9
-   |
-LL |     let b = x.borrow_mut();
-   |         ^
-   |
-note: these are all the await points this ref is held through
-  --> $DIR/await_holding_refcell_ref.rs:45:5
-   |
-LL | /     let b = x.borrow_mut();
-LL | |
-LL | |     let second = baz().await;
-LL | |
-...  |
-LL | |     first + second + third
-LL | | }
-   | |_^
-
-error: this RefCell Ref is held across an 'await' point. Consider ensuring the Ref is dropped before calling await.
-  --> $DIR/await_holding_refcell_ref.rs:60:13
-   |
-LL |         let b = x.borrow_mut();
-   |             ^
-   |
-note: these are all the await points this ref is held through
-  --> $DIR/await_holding_refcell_ref.rs:60:9
-   |
-LL | /         let b = x.borrow_mut();
-LL | |         baz().await
-LL | |     };
-   | |_____^
-
-error: this RefCell Ref is held across an 'await' point. Consider ensuring the Ref is dropped before calling await.
-  --> $DIR/await_holding_refcell_ref.rs:72:13
-   |
-LL |         let b = x.borrow_mut();
-   |             ^
-   |
-note: these are all the await points this ref is held through
-  --> $DIR/await_holding_refcell_ref.rs:72:9
-   |
-LL | /         let b = x.borrow_mut();
-LL | |         baz().await
-LL | |     }
-   | |_____^
-
-error: aborting due to 6 previous errors
-
-- 
cgit 1.4.1-3-g733a5


From d8c6bce4407b1c99ed961f75a093ffe767818069 Mon Sep 17 00:00:00 2001
From: Daniel Smith <daniel.smith@datadoghq.com>
Date: Tue, 13 Oct 2020 13:20:01 -0400
Subject: Convert the await holding lints to correctness

---
 clippy_lints/src/await_holding_invalid.rs | 4 ++--
 clippy_lints/src/lib.rs                   | 6 ++++--
 src/lintlist/mod.rs                       | 4 ++--
 3 files changed, 8 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/await_holding_invalid.rs b/clippy_lints/src/await_holding_invalid.rs
index 2000bdae363..1d201ff095b 100644
--- a/clippy_lints/src/await_holding_invalid.rs
+++ b/clippy_lints/src/await_holding_invalid.rs
@@ -45,7 +45,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     pub AWAIT_HOLDING_LOCK,
-    pedantic,
+    correctness,
     "Inside an async function, holding a MutexGuard while calling await"
 }
 
@@ -126,7 +126,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     pub AWAIT_HOLDING_REFCELL_REF,
-    pedantic,
+    correctness,
     "Inside an async function, holding a RefCell ref while calling await"
 }
 
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 0c5baf96970..c627df20976 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1190,8 +1190,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
 
     store.register_group(true, "clippy::pedantic", Some("clippy_pedantic"), vec![
         LintId::of(&attrs::INLINE_ALWAYS),
-        LintId::of(&await_holding_invalid::AWAIT_HOLDING_LOCK),
-        LintId::of(&await_holding_invalid::AWAIT_HOLDING_REFCELL_REF),
         LintId::of(&bit_mask::VERBOSE_BIT_MASK),
         LintId::of(&checked_conversions::CHECKED_CONVERSIONS),
         LintId::of(&copies::MATCH_SAME_ARMS),
@@ -1290,6 +1288,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&attrs::MISMATCHED_TARGET_OS),
         LintId::of(&attrs::UNKNOWN_CLIPPY_LINTS),
         LintId::of(&attrs::USELESS_ATTRIBUTE),
+        LintId::of(&await_holding_invalid::AWAIT_HOLDING_LOCK),
+        LintId::of(&await_holding_invalid::AWAIT_HOLDING_REFCELL_REF),
         LintId::of(&bit_mask::BAD_BIT_MASK),
         LintId::of(&bit_mask::INEFFECTIVE_BIT_MASK),
         LintId::of(&blacklisted_name::BLACKLISTED_NAME),
@@ -1736,6 +1736,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&attrs::DEPRECATED_SEMVER),
         LintId::of(&attrs::MISMATCHED_TARGET_OS),
         LintId::of(&attrs::USELESS_ATTRIBUTE),
+        LintId::of(&await_holding_invalid::AWAIT_HOLDING_LOCK),
+        LintId::of(&await_holding_invalid::AWAIT_HOLDING_REFCELL_REF),
         LintId::of(&bit_mask::BAD_BIT_MASK),
         LintId::of(&bit_mask::INEFFECTIVE_BIT_MASK),
         LintId::of(&booleans::LOGIC_BUG),
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index c955f37b83a..d9e019e2b61 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -62,14 +62,14 @@ vec![
     },
     Lint {
         name: "await_holding_lock",
-        group: "pedantic",
+        group: "correctness",
         desc: "Inside an async function, holding a MutexGuard while calling await",
         deprecation: None,
         module: "await_holding_invalid",
     },
     Lint {
         name: "await_holding_refcell_ref",
-        group: "pedantic",
+        group: "correctness",
         desc: "Inside an async function, holding a RefCell ref while calling await",
         deprecation: None,
         module: "await_holding_invalid",
-- 
cgit 1.4.1-3-g733a5


From 86f2b29d2ff33862264e2e6dfdc7cc20ad054ad1 Mon Sep 17 00:00:00 2001
From: Daniel Smith <daniel.smith@datadoghq.com>
Date: Mon, 19 Oct 2020 12:06:43 -0400
Subject: Merge lints into one pass

---
 clippy_lints/src/await_holding_invalid.rs | 69 +++++++++++--------------------
 clippy_lints/src/lib.rs                   |  3 +-
 2 files changed, 24 insertions(+), 48 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/await_holding_invalid.rs b/clippy_lints/src/await_holding_invalid.rs
index 1d201ff095b..fcebb54c6c2 100644
--- a/clippy_lints/src/await_holding_invalid.rs
+++ b/clippy_lints/src/await_holding_invalid.rs
@@ -49,48 +49,6 @@ declare_clippy_lint! {
     "Inside an async function, holding a MutexGuard while calling await"
 }
 
-declare_lint_pass!(AwaitHoldingLock => [AWAIT_HOLDING_LOCK]);
-
-impl LateLintPass<'_> for AwaitHoldingLock {
-    fn check_body(&mut self, cx: &LateContext<'_>, body: &'_ Body<'_>) {
-        use AsyncGeneratorKind::{Block, Closure, Fn};
-        if let Some(GeneratorKind::Async(Block | Closure | Fn)) = body.generator_kind {
-            let body_id = BodyId {
-                hir_id: body.value.hir_id,
-            };
-            let def_id = cx.tcx.hir().body_owner_def_id(body_id);
-            let typeck_results = cx.tcx.typeck(def_id);
-            check_interior_types_lock(cx, &typeck_results.generator_interior_types, body.value.span);
-        }
-    }
-}
-
-fn check_interior_types_lock(cx: &LateContext<'_>, ty_causes: &[GeneratorInteriorTypeCause<'_>], span: Span) {
-    for ty_cause in ty_causes {
-        if let rustc_middle::ty::Adt(adt, _) = ty_cause.ty.kind() {
-            if is_mutex_guard(cx, adt.did) {
-                span_lint_and_note(
-                    cx,
-                    AWAIT_HOLDING_LOCK,
-                    ty_cause.span,
-                    "this MutexGuard is held across an 'await' point. Consider using an async-aware Mutex type or ensuring the MutexGuard is dropped before calling await.",
-                    ty_cause.scope_span.or(Some(span)),
-                    "these are all the await points this lock is held through",
-                );
-            }
-        }
-    }
-}
-
-fn is_mutex_guard(cx: &LateContext<'_>, def_id: DefId) -> bool {
-    match_def_path(cx, def_id, &paths::MUTEX_GUARD)
-        || match_def_path(cx, def_id, &paths::RWLOCK_READ_GUARD)
-        || match_def_path(cx, def_id, &paths::RWLOCK_WRITE_GUARD)
-        || match_def_path(cx, def_id, &paths::PARKING_LOT_MUTEX_GUARD)
-        || match_def_path(cx, def_id, &paths::PARKING_LOT_RWLOCK_READ_GUARD)
-        || match_def_path(cx, def_id, &paths::PARKING_LOT_RWLOCK_WRITE_GUARD)
-}
-
 declare_clippy_lint! {
     /// **What it does:** Checks for calls to await while holding a
     /// `RefCell` `Ref` or `RefMut`.
@@ -130,9 +88,9 @@ declare_clippy_lint! {
     "Inside an async function, holding a RefCell ref while calling await"
 }
 
-declare_lint_pass!(AwaitHoldingRefCellRef => [AWAIT_HOLDING_REFCELL_REF]);
+declare_lint_pass!(AwaitHolding => [AWAIT_HOLDING_LOCK, AWAIT_HOLDING_REFCELL_REF]);
 
-impl LateLintPass<'_> for AwaitHoldingRefCellRef {
+impl LateLintPass<'_> for AwaitHolding {
     fn check_body(&mut self, cx: &LateContext<'_>, body: &'_ Body<'_>) {
         use AsyncGeneratorKind::{Block, Closure, Fn};
         if let Some(GeneratorKind::Async(Block | Closure | Fn)) = body.generator_kind {
@@ -141,14 +99,24 @@ impl LateLintPass<'_> for AwaitHoldingRefCellRef {
             };
             let def_id = cx.tcx.hir().body_owner_def_id(body_id);
             let typeck_results = cx.tcx.typeck(def_id);
-            check_interior_types_refcell(cx, &typeck_results.generator_interior_types, body.value.span);
+            check_interior_types(cx, &typeck_results.generator_interior_types, body.value.span);
         }
     }
 }
 
-fn check_interior_types_refcell(cx: &LateContext<'_>, ty_causes: &[GeneratorInteriorTypeCause<'_>], span: Span) {
+fn check_interior_types(cx: &LateContext<'_>, ty_causes: &[GeneratorInteriorTypeCause<'_>], span: Span) {
     for ty_cause in ty_causes {
         if let rustc_middle::ty::Adt(adt, _) = ty_cause.ty.kind() {
+            if is_mutex_guard(cx, adt.did) {
+                span_lint_and_note(
+                    cx,
+                    AWAIT_HOLDING_LOCK,
+                    ty_cause.span,
+                    "this MutexGuard is held across an 'await' point. Consider using an async-aware Mutex type or ensuring the MutexGuard is dropped before calling await.",
+                    ty_cause.scope_span.or(Some(span)),
+                    "these are all the await points this lock is held through",
+                );
+            }
             if is_refcell_ref(cx, adt.did) {
                 span_lint_and_note(
                         cx,
@@ -163,6 +131,15 @@ fn check_interior_types_refcell(cx: &LateContext<'_>, ty_causes: &[GeneratorInte
     }
 }
 
+fn is_mutex_guard(cx: &LateContext<'_>, def_id: DefId) -> bool {
+    match_def_path(cx, def_id, &paths::MUTEX_GUARD)
+        || match_def_path(cx, def_id, &paths::RWLOCK_READ_GUARD)
+        || match_def_path(cx, def_id, &paths::RWLOCK_WRITE_GUARD)
+        || match_def_path(cx, def_id, &paths::PARKING_LOT_MUTEX_GUARD)
+        || match_def_path(cx, def_id, &paths::PARKING_LOT_RWLOCK_READ_GUARD)
+        || match_def_path(cx, def_id, &paths::PARKING_LOT_RWLOCK_WRITE_GUARD)
+}
+
 fn is_refcell_ref(cx: &LateContext<'_>, def_id: DefId) -> bool {
     match_def_path(cx, def_id, &paths::REFCELL_REF) || match_def_path(cx, def_id, &paths::REFCELL_REFMUT)
 }
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index c627df20976..6d00e313ce1 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -906,8 +906,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     ]);
     // end register lints, do not remove this comment, it’s used in `update_lints`
 
-    store.register_late_pass(|| box await_holding_invalid::AwaitHoldingLock);
-    store.register_late_pass(|| box await_holding_invalid::AwaitHoldingRefCellRef);
+    store.register_late_pass(|| box await_holding_invalid::AwaitHolding);
     store.register_late_pass(|| box serde_api::SerdeAPI);
     store.register_late_pass(|| box utils::internal_lints::CompilerLintFunctions::new());
     store.register_late_pass(|| box utils::internal_lints::LintWithoutLintPass::default());
-- 
cgit 1.4.1-3-g733a5


From 4a4f998c39b1b7e06c34a5fc8ed90e8752142e20 Mon Sep 17 00:00:00 2001
From: cgm616 <cgm616@me.com>
Date: Fri, 16 Oct 2020 11:12:37 -0400
Subject: Add new lint for undropped ManuallyDrop values

---
 CHANGELOG.md                                 |  1 +
 clippy_lints/src/lib.rs                      |  4 +++
 clippy_lints/src/undropped_manually_drops.rs | 49 ++++++++++++++++++++++++++++
 src/lintlist/mod.rs                          |  7 ++++
 tests/ui/undropped_manually_drops.rs         | 18 ++++++++++
 5 files changed, 79 insertions(+)
 create mode 100644 clippy_lints/src/undropped_manually_drops.rs
 create mode 100644 tests/ui/undropped_manually_drops.rs

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index d82f970b8bf..697e6166fdf 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1979,6 +1979,7 @@ Released 2018-09-13
 [`try_err`]: https://rust-lang.github.io/rust-clippy/master/index.html#try_err
 [`type_complexity`]: https://rust-lang.github.io/rust-clippy/master/index.html#type_complexity
 [`type_repetition_in_bounds`]: https://rust-lang.github.io/rust-clippy/master/index.html#type_repetition_in_bounds
+[`undropped_manually_drops`]: https://rust-lang.github.io/rust-clippy/master/index.html#undropped_manually_drops
 [`unicode_not_nfc`]: https://rust-lang.github.io/rust-clippy/master/index.html#unicode_not_nfc
 [`unimplemented`]: https://rust-lang.github.io/rust-clippy/master/index.html#unimplemented
 [`uninit_assumed_init`]: https://rust-lang.github.io/rust-clippy/master/index.html#uninit_assumed_init
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index d4d2f92a6a6..49ff8ad366e 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -314,6 +314,7 @@ mod transmuting_null;
 mod trivially_copy_pass_by_ref;
 mod try_err;
 mod types;
+mod undropped_manually_drops;
 mod unicode;
 mod unit_return_expecting_ord;
 mod unnamed_address;
@@ -862,6 +863,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &types::UNIT_CMP,
         &types::UNNECESSARY_CAST,
         &types::VEC_BOX,
+        &undropped_manually_drops::UNDROPPED_MANUALLY_DROPS,
         &unicode::INVISIBLE_CHARACTERS,
         &unicode::NON_ASCII_LITERAL,
         &unicode::UNICODE_NOT_NFC,
@@ -1137,6 +1139,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(move || box disallowed_method::DisallowedMethod::new(&disallowed_methods));
     store.register_early_pass(|| box asm_syntax::InlineAsmX86AttSyntax);
     store.register_early_pass(|| box asm_syntax::InlineAsmX86IntelSyntax);
+    store.register_late_pass(|| box undropped_manually_drops::UndroppedManuallyDrops);
 
 
     store.register_group(true, "clippy::restriction", Some("clippy_restriction"), vec![
@@ -1790,6 +1793,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&types::ABSURD_EXTREME_COMPARISONS),
         LintId::of(&types::CAST_REF_TO_MUT),
         LintId::of(&types::UNIT_CMP),
+        LintId::of(&undropped_manually_drops::UNDROPPED_MANUALLY_DROPS),
         LintId::of(&unicode::INVISIBLE_CHARACTERS),
         LintId::of(&unit_return_expecting_ord::UNIT_RETURN_EXPECTING_ORD),
         LintId::of(&unnamed_address::FN_ADDRESS_COMPARISONS),
diff --git a/clippy_lints/src/undropped_manually_drops.rs b/clippy_lints/src/undropped_manually_drops.rs
new file mode 100644
index 00000000000..48a050777b7
--- /dev/null
+++ b/clippy_lints/src/undropped_manually_drops.rs
@@ -0,0 +1,49 @@
+use rustc_lint::{LateLintPass, LateContext};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_hir::*;
+use crate::utils::{match_function_call, is_type_lang_item, paths, span_lint_and_help};
+
+declare_clippy_lint! {
+    /// **What it does:** Prevents the safe `std::mem::drop` function from being called on `std::mem::ManuallyDrop`.
+    ///
+    /// **Why is this bad?** The safe `drop` function does not drop the inner value of a `ManuallyDrop`.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// struct S;
+    /// drop(std::mem::ManuallyDrop::new(S));
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// struct S;
+    /// unsafe {
+    ///     std::mem::ManuallyDrop::drop(std::mem::ManuallyDrop::new(S));
+    /// }
+    /// ```
+    pub UNDROPPED_MANUALLY_DROPS,
+    correctness,
+    "use of safe `std::mem::drop` function to drop a std::mem::ManuallyDrop, which will not drop the inner value"
+}
+
+declare_lint_pass!(UndroppedManuallyDrops => [UNDROPPED_MANUALLY_DROPS]);
+
+impl LateLintPass<'tcx> for UndroppedManuallyDrops {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        if let Some(ref args) = match_function_call(cx, expr, &paths::DROP) {
+            let ty = cx.typeck_results().expr_ty(&args[0]);
+            if is_type_lang_item(cx, ty, lang_items::LangItem::ManuallyDrop) {
+                span_lint_and_help(
+                    cx,
+                    UNDROPPED_MANUALLY_DROPS,
+                    expr.span,
+                    "the inner value of this ManuallyDrop will not be dropped",
+                    None,
+                    "to drop a `ManuallyDrop<T>`, use std::mem::ManuallyDrop::drop"
+                );
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index 6301d623a2b..25a69e78c8f 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -2412,6 +2412,13 @@ vec![
         deprecation: None,
         module: "trait_bounds",
     },
+    Lint {
+        name: "undropped_manually_drops",
+        group: "correctness",
+        desc: "use of safe `std::mem::drop` function to drop a std::mem::ManuallyDrop, which will not drop the inner value",
+        deprecation: None,
+        module: "undropped_manually_drops",
+    },
     Lint {
         name: "unicode_not_nfc",
         group: "pedantic",
diff --git a/tests/ui/undropped_manually_drops.rs b/tests/ui/undropped_manually_drops.rs
new file mode 100644
index 00000000000..bea62e1751e
--- /dev/null
+++ b/tests/ui/undropped_manually_drops.rs
@@ -0,0 +1,18 @@
+#![warn(clippy::undropped_manually_drops)]
+
+struct S;
+
+fn main() {
+    let f = drop;
+    let manual = std::mem::ManuallyDrop::new(S);
+
+    // These lines will not drop `S`
+    drop(std::mem::ManuallyDrop::new(S));
+    f(manual);
+
+    // These lines will
+    unsafe {
+        std::mem::ManuallyDrop::drop(std::mem::ManuallyDrop::new(S));
+        std::mem::ManuallyDrop::drop(manual);
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From e70817e712fd4d4e930ead0d587031e2b4a97a2e Mon Sep 17 00:00:00 2001
From: cgm616 <cgm616@me.com>
Date: Fri, 16 Oct 2020 16:20:03 -0400
Subject: Update tests and add known problems to docs

---
 clippy_lints/src/lib.rs                      |  1 +
 clippy_lints/src/undropped_manually_drops.rs | 15 ++++++++-------
 tests/ui/undropped_manually_drops.rs         | 22 +++++++++++++++-------
 tests/ui/undropped_manually_drops.stderr     | 19 +++++++++++++++++++
 4 files changed, 43 insertions(+), 14 deletions(-)
 create mode 100644 tests/ui/undropped_manually_drops.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 49ff8ad366e..97e7cfd1bb2 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1524,6 +1524,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&types::UNIT_CMP),
         LintId::of(&types::UNNECESSARY_CAST),
         LintId::of(&types::VEC_BOX),
+        LintId::of(&undropped_manually_drops::UNDROPPED_MANUALLY_DROPS),
         LintId::of(&unicode::INVISIBLE_CHARACTERS),
         LintId::of(&unit_return_expecting_ord::UNIT_RETURN_EXPECTING_ORD),
         LintId::of(&unnamed_address::FN_ADDRESS_COMPARISONS),
diff --git a/clippy_lints/src/undropped_manually_drops.rs b/clippy_lints/src/undropped_manually_drops.rs
index 48a050777b7..5443f1601fc 100644
--- a/clippy_lints/src/undropped_manually_drops.rs
+++ b/clippy_lints/src/undropped_manually_drops.rs
@@ -1,14 +1,15 @@
-use rustc_lint::{LateLintPass, LateContext};
+use crate::utils::{is_type_lang_item, match_function_call, paths, span_lint_and_help};
+use rustc_hir::{lang_items, Expr};
+use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_hir::*;
-use crate::utils::{match_function_call, is_type_lang_item, paths, span_lint_and_help};
 
 declare_clippy_lint! {
     /// **What it does:** Prevents the safe `std::mem::drop` function from being called on `std::mem::ManuallyDrop`.
     ///
     /// **Why is this bad?** The safe `drop` function does not drop the inner value of a `ManuallyDrop`.
     ///
-    /// **Known problems:** None.
+    /// **Known problems:** Does not catch cases if the user binds `std::mem::drop`
+    /// to a different name and calls it that way.
     ///
     /// **Example:**
     ///
@@ -20,7 +21,7 @@ declare_clippy_lint! {
     /// ```rust
     /// struct S;
     /// unsafe {
-    ///     std::mem::ManuallyDrop::drop(std::mem::ManuallyDrop::new(S));
+    ///     std::mem::ManuallyDrop::drop(&mut std::mem::ManuallyDrop::new(S));
     /// }
     /// ```
     pub UNDROPPED_MANUALLY_DROPS,
@@ -41,9 +42,9 @@ impl LateLintPass<'tcx> for UndroppedManuallyDrops {
                     expr.span,
                     "the inner value of this ManuallyDrop will not be dropped",
                     None,
-                    "to drop a `ManuallyDrop<T>`, use std::mem::ManuallyDrop::drop"
+                    "to drop a `ManuallyDrop<T>`, use std::mem::ManuallyDrop::drop",
                 );
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/tests/ui/undropped_manually_drops.rs b/tests/ui/undropped_manually_drops.rs
index bea62e1751e..f4cfc92e1cd 100644
--- a/tests/ui/undropped_manually_drops.rs
+++ b/tests/ui/undropped_manually_drops.rs
@@ -3,16 +3,24 @@
 struct S;
 
 fn main() {
-    let f = drop;
-    let manual = std::mem::ManuallyDrop::new(S);
+    let f = std::mem::drop;
+    let g = std::mem::ManuallyDrop::drop;
+    let mut manual1 = std::mem::ManuallyDrop::new(S);
+    let mut manual2 = std::mem::ManuallyDrop::new(S);
+    let mut manual3 = std::mem::ManuallyDrop::new(S);
+    let mut manual4 = std::mem::ManuallyDrop::new(S);
 
-    // These lines will not drop `S`
+    // These lines will not drop `S` and should be linted
     drop(std::mem::ManuallyDrop::new(S));
-    f(manual);
+    drop(manual1);
 
-    // These lines will
+    // FIXME: this line is not linted, though it should be
+    f(manual2);
+
+    // These lines will drop `S` and should be okay.
     unsafe {
-        std::mem::ManuallyDrop::drop(std::mem::ManuallyDrop::new(S));
-        std::mem::ManuallyDrop::drop(manual);
+        std::mem::ManuallyDrop::drop(&mut std::mem::ManuallyDrop::new(S));
+        std::mem::ManuallyDrop::drop(&mut manual3);
+        g(&mut manual4);
     }
 }
diff --git a/tests/ui/undropped_manually_drops.stderr b/tests/ui/undropped_manually_drops.stderr
new file mode 100644
index 00000000000..2ac0fe98697
--- /dev/null
+++ b/tests/ui/undropped_manually_drops.stderr
@@ -0,0 +1,19 @@
+error: the inner value of this ManuallyDrop will not be dropped
+  --> $DIR/undropped_manually_drops.rs:14:5
+   |
+LL |     drop(std::mem::ManuallyDrop::new(S));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::undropped-manually-drops` implied by `-D warnings`
+   = help: to drop a `ManuallyDrop<T>`, use std::mem::ManuallyDrop::drop
+
+error: the inner value of this ManuallyDrop will not be dropped
+  --> $DIR/undropped_manually_drops.rs:15:5
+   |
+LL |     drop(manual1);
+   |     ^^^^^^^^^^^^^
+   |
+   = help: to drop a `ManuallyDrop<T>`, use std::mem::ManuallyDrop::drop
+
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From c693de350aff4a3930e66bccf65caf79b390dca2 Mon Sep 17 00:00:00 2001
From: Andre Bogus <bogusandre@gmail.com>
Date: Thu, 15 Oct 2020 22:05:51 +0200
Subject: New lint: manual-range-contains

---
 CHANGELOG.md                   |   1 +
 clippy_lints/src/lib.rs        |   3 +
 clippy_lints/src/ranges.rs     | 216 +++++++++++++++++++++++++++++++++++------
 src/lintlist/mod.rs            |   7 ++
 tests/ui/range_contains.fixed  |  41 ++++++++
 tests/ui/range_contains.rs     |  41 ++++++++
 tests/ui/range_contains.stderr |  76 +++++++++++++++
 7 files changed, 354 insertions(+), 31 deletions(-)
 create mode 100644 tests/ui/range_contains.fixed
 create mode 100644 tests/ui/range_contains.rs
 create mode 100644 tests/ui/range_contains.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index d82f970b8bf..c9f0406a806 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1793,6 +1793,7 @@ Released 2018-09-13
 [`manual_async_fn`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_async_fn
 [`manual_memcpy`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_memcpy
 [`manual_non_exhaustive`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_non_exhaustive
+[`manual_range_contains`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_range_contains
 [`manual_saturating_arithmetic`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_saturating_arithmetic
 [`manual_strip`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_strip
 [`manual_swap`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_swap
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index d4d2f92a6a6..cc50655cb00 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -785,6 +785,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &ptr_eq::PTR_EQ,
         &ptr_offset_with_cast::PTR_OFFSET_WITH_CAST,
         &question_mark::QUESTION_MARK,
+        &ranges::MANUAL_RANGE_CONTAINS,
         &ranges::RANGE_MINUS_ONE,
         &ranges::RANGE_PLUS_ONE,
         &ranges::RANGE_ZIP_WITH_LEN,
@@ -1469,6 +1470,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&ptr_eq::PTR_EQ),
         LintId::of(&ptr_offset_with_cast::PTR_OFFSET_WITH_CAST),
         LintId::of(&question_mark::QUESTION_MARK),
+        LintId::of(&ranges::MANUAL_RANGE_CONTAINS),
         LintId::of(&ranges::RANGE_ZIP_WITH_LEN),
         LintId::of(&ranges::REVERSED_EMPTY_RANGES),
         LintId::of(&redundant_clone::REDUNDANT_CLONE),
@@ -1624,6 +1626,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&ptr::PTR_ARG),
         LintId::of(&ptr_eq::PTR_EQ),
         LintId::of(&question_mark::QUESTION_MARK),
+        LintId::of(&ranges::MANUAL_RANGE_CONTAINS),
         LintId::of(&redundant_field_names::REDUNDANT_FIELD_NAMES),
         LintId::of(&redundant_static_lifetimes::REDUNDANT_STATIC_LIFETIMES),
         LintId::of(&regex::TRIVIAL_REGEX),
diff --git a/clippy_lints/src/ranges.rs b/clippy_lints/src/ranges.rs
index cc492917b9d..de54711d851 100644
--- a/clippy_lints/src/ranges.rs
+++ b/clippy_lints/src/ranges.rs
@@ -2,15 +2,19 @@ use crate::consts::{constant, Constant};
 use if_chain::if_chain;
 use rustc_ast::ast::RangeLimits;
 use rustc_errors::Applicability;
-use rustc_hir::{BinOpKind, Expr, ExprKind, QPath};
+use rustc_hir::{BinOpKind, Expr, ExprKind, PathSegment, QPath};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::source_map::Spanned;
+use rustc_span::source_map::{Span, Spanned};
+use rustc_span::symbol::Ident;
 use std::cmp::Ordering;
 
 use crate::utils::sugg::Sugg;
-use crate::utils::{get_parent_expr, is_integer_const, snippet, snippet_opt, span_lint, span_lint_and_then};
+use crate::utils::{
+    get_parent_expr, is_integer_const, single_segment_path, snippet, snippet_opt, snippet_with_applicability,
+    span_lint, span_lint_and_sugg, span_lint_and_then,
+};
 use crate::utils::{higher, SpanlessEq};
 
 declare_clippy_lint! {
@@ -128,43 +132,51 @@ declare_clippy_lint! {
     "reversing the limits of range expressions, resulting in empty ranges"
 }
 
+declare_clippy_lint! {
+    /// **What it does:** Checks for expressions like `x >= 3 && x < 8` that could
+    /// be more readably expressed as `(3..8).contains(x)`.
+    ///
+    /// **Why is this bad?** `contains` expresses the intent better and has less
+    /// failure modes (such as fencepost errors or using `||` instead of `&&`).
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// // given
+    /// let x = 6;
+    ///
+    /// assert!(x >= 3 && x < 8);
+    /// ```
+    /// Use instead:
+    /// ```rust
+    ///# let x = 6;
+    /// assert!((3..8).contains(&x));
+    /// ```
+    pub MANUAL_RANGE_CONTAINS,
+    style,
+    "manually reimplementing {`Range`, `RangeInclusive`}`::contains`"
+}
+
 declare_lint_pass!(Ranges => [
     RANGE_ZIP_WITH_LEN,
     RANGE_PLUS_ONE,
     RANGE_MINUS_ONE,
     REVERSED_EMPTY_RANGES,
+    MANUAL_RANGE_CONTAINS,
 ]);
 
 impl<'tcx> LateLintPass<'tcx> for Ranges {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if let ExprKind::MethodCall(ref path, _, ref args, _) = expr.kind {
-            let name = path.ident.as_str();
-            if name == "zip" && args.len() == 2 {
-                let iter = &args[0].kind;
-                let zip_arg = &args[1];
-                if_chain! {
-                    // `.iter()` call
-                    if let ExprKind::MethodCall(ref iter_path, _, ref iter_args , _) = *iter;
-                    if iter_path.ident.name == sym!(iter);
-                    // range expression in `.zip()` call: `0..x.len()`
-                    if let Some(higher::Range { start: Some(start), end: Some(end), .. }) = higher::range(zip_arg);
-                    if is_integer_const(cx, start, 0);
-                    // `.len()` call
-                    if let ExprKind::MethodCall(ref len_path, _, ref len_args, _) = end.kind;
-                    if len_path.ident.name == sym!(len) && len_args.len() == 1;
-                    // `.iter()` and `.len()` called on same `Path`
-                    if let ExprKind::Path(QPath::Resolved(_, ref iter_path)) = iter_args[0].kind;
-                    if let ExprKind::Path(QPath::Resolved(_, ref len_path)) = len_args[0].kind;
-                    if SpanlessEq::new(cx).eq_path_segments(&iter_path.segments, &len_path.segments);
-                     then {
-                         span_lint(cx,
-                                   RANGE_ZIP_WITH_LEN,
-                                   expr.span,
-                                   &format!("it is more idiomatic to use `{}.iter().enumerate()`",
-                                            snippet(cx, iter_args[0].span, "_")));
-                    }
-                }
-            }
+        match expr.kind {
+            ExprKind::MethodCall(ref path, _, ref args, _) => {
+                check_range_zip_with_len(cx, path, args, expr.span);
+            },
+            ExprKind::Binary(ref op, ref l, ref r) => {
+                check_possible_range_contains(cx, op.node, l, r, expr.span);
+            },
+            _ => {},
         }
 
         check_exclusive_range_plus_one(cx, expr);
@@ -173,6 +185,148 @@ impl<'tcx> LateLintPass<'tcx> for Ranges {
     }
 }
 
+fn check_possible_range_contains(cx: &LateContext<'_>, op: BinOpKind, l: &Expr<'_>, r: &Expr<'_>, span: Span) {
+    let combine_and = match op {
+        BinOpKind::And | BinOpKind::BitAnd => true,
+        BinOpKind::Or | BinOpKind::BitOr => false,
+        _ => return,
+    };
+    // value, name, order (higher/lower), inclusiveness
+    if let (Some((lval, lname, name_span, lval_span, lord, linc)), Some((rval, rname, _, rval_span, rord, rinc))) =
+        (check_range_bounds(cx, l), check_range_bounds(cx, r))
+    {
+        // we only lint comparisons on the same name and with different
+        // direction
+        if lname != rname || lord == rord {
+            return;
+        }
+        let ord = Constant::partial_cmp(cx.tcx, cx.typeck_results().expr_ty(l), &lval, &rval);
+        if combine_and && ord == Some(rord) {
+            // order lower bound and upper bound
+            let (l_span, u_span, l_inc, u_inc) = if rord == Ordering::Less {
+                (lval_span, rval_span, linc, rinc)
+            } else {
+                (rval_span, lval_span, rinc, linc)
+            };
+            // we only lint inclusive lower bounds
+            if !l_inc {
+                return;
+            }
+            let (range_type, range_op) = if u_inc {
+                ("RangeInclusive", "..=")
+            } else {
+                ("Range", "..")
+            };
+            let mut applicability = Applicability::MachineApplicable;
+            let name = snippet_with_applicability(cx, name_span, "_", &mut applicability);
+            let lo = snippet_with_applicability(cx, l_span, "_", &mut applicability);
+            let hi = snippet_with_applicability(cx, u_span, "_", &mut applicability);
+            span_lint_and_sugg(
+                cx,
+                MANUAL_RANGE_CONTAINS,
+                span,
+                &format!("manual `{}::contains` implementation", range_type),
+                "use",
+                format!("({}{}{}).contains(&{})", lo, range_op, hi, name),
+                applicability,
+            );
+        } else if !combine_and && ord == Some(lord) {
+            // `!_.contains(_)`
+            // order lower bound and upper bound
+            let (l_span, u_span, l_inc, u_inc) = if lord == Ordering::Less {
+                (lval_span, rval_span, linc, rinc)
+            } else {
+                (rval_span, lval_span, rinc, linc)
+            };
+            if l_inc {
+                return;
+            }
+            let (range_type, range_op) = if u_inc {
+                ("Range", "..")
+            } else {
+                ("RangeInclusive", "..=")
+            };
+            let mut applicability = Applicability::MachineApplicable;
+            let name = snippet_with_applicability(cx, name_span, "_", &mut applicability);
+            let lo = snippet_with_applicability(cx, l_span, "_", &mut applicability);
+            let hi = snippet_with_applicability(cx, u_span, "_", &mut applicability);
+            span_lint_and_sugg(
+                cx,
+                MANUAL_RANGE_CONTAINS,
+                span,
+                &format!("manual `!{}::contains` implementation", range_type),
+                "use",
+                format!("!({}{}{}).contains(&{})", lo, range_op, hi, name),
+                applicability,
+            );
+        }
+    }
+}
+
+fn check_range_bounds(cx: &LateContext<'_>, ex: &Expr<'_>) -> Option<(Constant, Ident, Span, Span, Ordering, bool)> {
+    if let ExprKind::Binary(ref op, ref l, ref r) = ex.kind {
+        let (inclusive, ordering) = match op.node {
+            BinOpKind::Gt => (false, Ordering::Greater),
+            BinOpKind::Ge => (true, Ordering::Greater),
+            BinOpKind::Lt => (false, Ordering::Less),
+            BinOpKind::Le => (true, Ordering::Less),
+            _ => return None,
+        };
+        if let Some(id) = match_ident(l) {
+            if let Some((c, _)) = constant(cx, cx.typeck_results(), r) {
+                return Some((c, id, l.span, r.span, ordering, inclusive));
+            }
+        } else if let Some(id) = match_ident(r) {
+            if let Some((c, _)) = constant(cx, cx.typeck_results(), l) {
+                return Some((c, id, r.span, l.span, ordering.reverse(), inclusive));
+            }
+        }
+    }
+    None
+}
+
+fn match_ident(e: &Expr<'_>) -> Option<Ident> {
+    if let ExprKind::Path(ref qpath) = e.kind {
+        if let Some(seg) = single_segment_path(qpath) {
+            if seg.args.is_none() {
+                return Some(seg.ident);
+            }
+        }
+    }
+    None
+}
+
+fn check_range_zip_with_len(cx: &LateContext<'_>, path: &PathSegment<'_>, args: &[Expr<'_>], span: Span) {
+    let name = path.ident.as_str();
+    if name == "zip" && args.len() == 2 {
+        let iter = &args[0].kind;
+        let zip_arg = &args[1];
+        if_chain! {
+            // `.iter()` call
+            if let ExprKind::MethodCall(ref iter_path, _, ref iter_args, _) = *iter;
+            if iter_path.ident.name == sym!(iter);
+            // range expression in `.zip()` call: `0..x.len()`
+            if let Some(higher::Range { start: Some(start), end: Some(end), .. }) = higher::range(zip_arg);
+            if is_integer_const(cx, start, 0);
+            // `.len()` call
+            if let ExprKind::MethodCall(ref len_path, _, ref len_args, _) = end.kind;
+            if len_path.ident.name == sym!(len) && len_args.len() == 1;
+            // `.iter()` and `.len()` called on same `Path`
+            if let ExprKind::Path(QPath::Resolved(_, ref iter_path)) = iter_args[0].kind;
+            if let ExprKind::Path(QPath::Resolved(_, ref len_path)) = len_args[0].kind;
+            if SpanlessEq::new(cx).eq_path_segments(&iter_path.segments, &len_path.segments);
+            then {
+                span_lint(cx,
+                    RANGE_ZIP_WITH_LEN,
+                    span,
+                    &format!("it is more idiomatic to use `{}.iter().enumerate()`",
+                        snippet(cx, iter_args[0].span, "_"))
+                );
+            }
+        }
+    }
+}
+
 // exclusive range plus one: `x..(y+1)`
 fn check_exclusive_range_plus_one(cx: &LateContext<'_>, expr: &Expr<'_>) {
     if_chain! {
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index 6301d623a2b..7bb68acc062 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -1159,6 +1159,13 @@ vec![
         deprecation: None,
         module: "manual_non_exhaustive",
     },
+    Lint {
+        name: "manual_range_contains",
+        group: "style",
+        desc: "manually reimplementing {`Range`, `RangeInclusive`}`::contains`",
+        deprecation: None,
+        module: "ranges",
+    },
     Lint {
         name: "manual_saturating_arithmetic",
         group: "style",
diff --git a/tests/ui/range_contains.fixed b/tests/ui/range_contains.fixed
new file mode 100644
index 00000000000..632a6592a28
--- /dev/null
+++ b/tests/ui/range_contains.fixed
@@ -0,0 +1,41 @@
+// run-rustfix
+
+#[warn(clippy::manual_range_contains)]
+#[allow(unused)]
+#[allow(clippy::no_effect)]
+#[allow(clippy::short_circuit_statement)]
+#[allow(clippy::unnecessary_operation)]
+fn main() {
+    let x = 9_u32;
+
+    // order shouldn't matter
+    (8..12).contains(&x);
+    (21..42).contains(&x);
+    (1..100).contains(&x);
+
+    // also with inclusive ranges
+    (9..=99).contains(&x);
+    (1..=33).contains(&x);
+    (1..=999).contains(&x);
+
+    // and the outside
+    !(8..12).contains(&x);
+    !(21..42).contains(&x);
+    !(1..100).contains(&x);
+
+    // also with the outside of inclusive ranges
+    !(9..=99).contains(&x);
+    !(1..=33).contains(&x);
+    !(1..=999).contains(&x);
+
+    // not a range.contains
+    x > 8 && x < 12; // lower bound not inclusive
+    x < 8 && x <= 12; // same direction
+    x >= 12 && 12 >= x; // same bounds
+    x < 8 && x > 12; // wrong direction
+
+    x <= 8 || x >= 12;
+    x >= 8 || x >= 12;
+    x < 12 || 12 < x;
+    x >= 8 || x <= 12;
+}
diff --git a/tests/ui/range_contains.rs b/tests/ui/range_contains.rs
new file mode 100644
index 00000000000..6af0d034ef6
--- /dev/null
+++ b/tests/ui/range_contains.rs
@@ -0,0 +1,41 @@
+// run-rustfix
+
+#[warn(clippy::manual_range_contains)]
+#[allow(unused)]
+#[allow(clippy::no_effect)]
+#[allow(clippy::short_circuit_statement)]
+#[allow(clippy::unnecessary_operation)]
+fn main() {
+    let x = 9_u32;
+
+    // order shouldn't matter
+    x >= 8 && x < 12;
+    x < 42 && x >= 21;
+    100 > x && 1 <= x;
+
+    // also with inclusive ranges
+    x >= 9 && x <= 99;
+    x <= 33 && x >= 1;
+    999 >= x && 1 <= x;
+
+    // and the outside
+    x < 8 || x >= 12;
+    x >= 42 || x < 21;
+    100 <= x || 1 > x;
+
+    // also with the outside of inclusive ranges
+    x < 9 || x > 99;
+    x > 33 || x < 1;
+    999 < x || 1 > x;
+
+    // not a range.contains
+    x > 8 && x < 12; // lower bound not inclusive
+    x < 8 && x <= 12; // same direction
+    x >= 12 && 12 >= x; // same bounds
+    x < 8 && x > 12; // wrong direction
+
+    x <= 8 || x >= 12;
+    x >= 8 || x >= 12;
+    x < 12 || 12 < x;
+    x >= 8 || x <= 12;
+}
diff --git a/tests/ui/range_contains.stderr b/tests/ui/range_contains.stderr
new file mode 100644
index 00000000000..69b009eafc3
--- /dev/null
+++ b/tests/ui/range_contains.stderr
@@ -0,0 +1,76 @@
+error: manual `Range::contains` implementation
+  --> $DIR/range_contains.rs:12:5
+   |
+LL |     x >= 8 && x < 12;
+   |     ^^^^^^^^^^^^^^^^ help: use: `(8..12).contains(&x)`
+   |
+   = note: `-D clippy::manual-range-contains` implied by `-D warnings`
+
+error: manual `Range::contains` implementation
+  --> $DIR/range_contains.rs:13:5
+   |
+LL |     x < 42 && x >= 21;
+   |     ^^^^^^^^^^^^^^^^^ help: use: `(21..42).contains(&x)`
+
+error: manual `Range::contains` implementation
+  --> $DIR/range_contains.rs:14:5
+   |
+LL |     100 > x && 1 <= x;
+   |     ^^^^^^^^^^^^^^^^^ help: use: `(1..100).contains(&x)`
+
+error: manual `RangeInclusive::contains` implementation
+  --> $DIR/range_contains.rs:17:5
+   |
+LL |     x >= 9 && x <= 99;
+   |     ^^^^^^^^^^^^^^^^^ help: use: `(9..=99).contains(&x)`
+
+error: manual `RangeInclusive::contains` implementation
+  --> $DIR/range_contains.rs:18:5
+   |
+LL |     x <= 33 && x >= 1;
+   |     ^^^^^^^^^^^^^^^^^ help: use: `(1..=33).contains(&x)`
+
+error: manual `RangeInclusive::contains` implementation
+  --> $DIR/range_contains.rs:19:5
+   |
+LL |     999 >= x && 1 <= x;
+   |     ^^^^^^^^^^^^^^^^^^ help: use: `(1..=999).contains(&x)`
+
+error: manual `!Range::contains` implementation
+  --> $DIR/range_contains.rs:22:5
+   |
+LL |     x < 8 || x >= 12;
+   |     ^^^^^^^^^^^^^^^^ help: use: `!(8..12).contains(&x)`
+
+error: manual `!Range::contains` implementation
+  --> $DIR/range_contains.rs:23:5
+   |
+LL |     x >= 42 || x < 21;
+   |     ^^^^^^^^^^^^^^^^^ help: use: `!(21..42).contains(&x)`
+
+error: manual `!Range::contains` implementation
+  --> $DIR/range_contains.rs:24:5
+   |
+LL |     100 <= x || 1 > x;
+   |     ^^^^^^^^^^^^^^^^^ help: use: `!(1..100).contains(&x)`
+
+error: manual `!RangeInclusive::contains` implementation
+  --> $DIR/range_contains.rs:27:5
+   |
+LL |     x < 9 || x > 99;
+   |     ^^^^^^^^^^^^^^^ help: use: `!(9..=99).contains(&x)`
+
+error: manual `!RangeInclusive::contains` implementation
+  --> $DIR/range_contains.rs:28:5
+   |
+LL |     x > 33 || x < 1;
+   |     ^^^^^^^^^^^^^^^ help: use: `!(1..=33).contains(&x)`
+
+error: manual `!RangeInclusive::contains` implementation
+  --> $DIR/range_contains.rs:29:5
+   |
+LL |     999 < x || 1 > x;
+   |     ^^^^^^^^^^^^^^^^ help: use: `!(1..=999).contains(&x)`
+
+error: aborting due to 12 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 6533d8becfd198299d0bd38550dd6c574cbd194f Mon Sep 17 00:00:00 2001
From: Tim Nielens <tim.nielens@gmail.com>
Date: Thu, 22 Oct 2020 23:39:59 +0200
Subject: manual-unwrap-or / pr remarks, round 2

---
 clippy_lints/src/manual_unwrap_or.rs |  4 +++-
 tests/ui/manual_unwrap_or.fixed      |  4 ++++
 tests/ui/manual_unwrap_or.rs         |  7 +++++++
 tests/ui/manual_unwrap_or.stderr     | 21 +++++++++++++++------
 4 files changed, 29 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_unwrap_or.rs b/clippy_lints/src/manual_unwrap_or.rs
index f3f1e31abde..cc9ee28d027 100644
--- a/clippy_lints/src/manual_unwrap_or.rs
+++ b/clippy_lints/src/manual_unwrap_or.rs
@@ -111,7 +111,9 @@ fn lint_manual_unwrap_or<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
         then {
             let reindented_or_body =
                 utils::reindent_multiline(or_body_snippet.into(), true, Some(indent));
-            let wrap_in_parens = !matches!(scrutinee, Expr { kind: ExprKind::Call(..), .. });
+            let wrap_in_parens = !matches!(scrutinee, Expr {
+                kind: ExprKind::Call(..) | ExprKind::Path(_), ..
+            });
             let l_paren = if wrap_in_parens { "(" } else { "" };
             let r_paren = if wrap_in_parens { ")" } else { "" };
             utils::span_lint_and_sugg(
diff --git a/tests/ui/manual_unwrap_or.fixed b/tests/ui/manual_unwrap_or.fixed
index c784de0f604..582f5c6f7a8 100644
--- a/tests/ui/manual_unwrap_or.fixed
+++ b/tests/ui/manual_unwrap_or.fixed
@@ -70,6 +70,10 @@ fn result_unwrap_or() {
     // int case
     Ok::<i32, &str>(1).unwrap_or(42);
 
+    // int case, scrutinee is a binding
+    let a = Ok::<i32, &str>(1);
+    a.unwrap_or(42);
+
     // int case, suggestion must surround with parenthesis
     (Ok(1) as Result<i32, &str>).unwrap_or(42);
 
diff --git a/tests/ui/manual_unwrap_or.rs b/tests/ui/manual_unwrap_or.rs
index df5f237c3fb..0e2b7ecadb3 100644
--- a/tests/ui/manual_unwrap_or.rs
+++ b/tests/ui/manual_unwrap_or.rs
@@ -88,6 +88,13 @@ fn result_unwrap_or() {
         Err(_) => 42,
     };
 
+    // int case, scrutinee is a binding
+    let a = Ok::<i32, &str>(1);
+    match a {
+        Ok(i) => i,
+        Err(_) => 42,
+    };
+
     // int case, suggestion must surround with parenthesis
     match Ok(1) as Result<i32, &str> {
         Ok(i) => i,
diff --git a/tests/ui/manual_unwrap_or.stderr b/tests/ui/manual_unwrap_or.stderr
index 5bc01bf4e68..6603ab43437 100644
--- a/tests/ui/manual_unwrap_or.stderr
+++ b/tests/ui/manual_unwrap_or.stderr
@@ -67,7 +67,16 @@ LL | |     };
    | |_____^ help: replace with: `Ok::<i32, &str>(1).unwrap_or(42)`
 
 error: this pattern reimplements `Result::unwrap_or`
-  --> $DIR/manual_unwrap_or.rs:92:5
+  --> $DIR/manual_unwrap_or.rs:93:5
+   |
+LL | /     match a {
+LL | |         Ok(i) => i,
+LL | |         Err(_) => 42,
+LL | |     };
+   | |_____^ help: replace with: `a.unwrap_or(42)`
+
+error: this pattern reimplements `Result::unwrap_or`
+  --> $DIR/manual_unwrap_or.rs:99:5
    |
 LL | /     match Ok(1) as Result<i32, &str> {
 LL | |         Ok(i) => i,
@@ -76,7 +85,7 @@ LL | |     };
    | |_____^ help: replace with: `(Ok(1) as Result<i32, &str>).unwrap_or(42)`
 
 error: this pattern reimplements `Result::unwrap_or`
-  --> $DIR/manual_unwrap_or.rs:98:5
+  --> $DIR/manual_unwrap_or.rs:105:5
    |
 LL | /     match Ok::<i32, &str>(1) {
 LL | |         Err(_) => 42,
@@ -85,7 +94,7 @@ LL | |     };
    | |_____^ help: replace with: `Ok::<i32, &str>(1).unwrap_or(42)`
 
 error: this pattern reimplements `Result::unwrap_or`
-  --> $DIR/manual_unwrap_or.rs:104:5
+  --> $DIR/manual_unwrap_or.rs:111:5
    |
 LL | /     match Ok::<i32, &str>(1) {
 LL | |         Ok(i) => i,
@@ -94,7 +103,7 @@ LL | |     };
    | |_____^ help: replace with: `Ok::<i32, &str>(1).unwrap_or(1 + 42)`
 
 error: this pattern reimplements `Result::unwrap_or`
-  --> $DIR/manual_unwrap_or.rs:111:5
+  --> $DIR/manual_unwrap_or.rs:118:5
    |
 LL | /     match Ok::<i32, &str>(1) {
 LL | |         Ok(i) => i,
@@ -115,7 +124,7 @@ LL |     });
    |
 
 error: this pattern reimplements `Result::unwrap_or`
-  --> $DIR/manual_unwrap_or.rs:121:5
+  --> $DIR/manual_unwrap_or.rs:128:5
    |
 LL | /     match Ok::<&str, &str>("Bob") {
 LL | |         Ok(i) => i,
@@ -123,5 +132,5 @@ LL | |         Err(_) => "Alice",
 LL | |     };
    | |_____^ help: replace with: `Ok::<&str, &str>("Bob").unwrap_or("Alice")`
 
-error: aborting due to 11 previous errors
+error: aborting due to 12 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From e8f12d2f02644834282dec0c27710886f1e85ae6 Mon Sep 17 00:00:00 2001
From: Geoffrey Copin <copin.geoffrey@gmail.com>
Date: Thu, 22 Oct 2020 23:53:50 +0200
Subject: Address review comments

---
 clippy_lints/src/types.rs                | 53 +++++++++++++++++---------------
 tests/ui/unnecessary_cast_fixable.fixed  |  6 ++--
 tests/ui/unnecessary_cast_fixable.rs     |  2 ++
 tests/ui/unnecessary_cast_fixable.stderr | 22 ++++++++++---
 4 files changed, 52 insertions(+), 31 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs
index 716d027e434..f4bb648d15a 100644
--- a/clippy_lints/src/types.rs
+++ b/clippy_lints/src/types.rs
@@ -3,7 +3,6 @@
 use std::borrow::Cow;
 use std::cmp::Ordering;
 use std::collections::BTreeMap;
-use std::fmt::Display;
 
 use if_chain::if_chain;
 use rustc_ast::{FloatTy, IntTy, LitFloatType, LitIntType, LitKind, UintTy};
@@ -12,7 +11,7 @@ use rustc_hir as hir;
 use rustc_hir::intravisit::{walk_body, walk_expr, walk_ty, FnKind, NestedVisitorMap, Visitor};
 use rustc_hir::{
     BinOpKind, Block, Body, Expr, ExprKind, FnDecl, FnRetTy, FnSig, GenericArg, GenericParamKind, HirId, ImplItem,
-    ImplItemKind, Item, ItemKind, Lifetime, Local, MatchSource, MutTy, Mutability, Node, QPath, Stmt, StmtKind,
+    ImplItemKind, Item, ItemKind, Lifetime, Lit, Local, MatchSource, MutTy, Mutability, Node, QPath, Stmt, StmtKind,
     TraitFn, TraitItem, TraitItemKind, TyKind, UnOp,
 };
 use rustc_lint::{LateContext, LateLintPass, LintContext};
@@ -1225,7 +1224,8 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for casts to the same type.
+    /// **What it does:** Checks for casts to the same type, casts of int literals to integer types
+    /// and casts of float literals to float types.
     ///
     /// **Why is this bad?** It's just unnecessary.
     ///
@@ -1234,6 +1234,7 @@ declare_clippy_lint! {
     /// **Example:**
     /// ```rust
     /// let _ = 2i32 as i32;
+    /// let _ = 0.5 as f32;
     /// ```
     pub UNNECESSARY_CAST,
     complexity,
@@ -1599,7 +1600,9 @@ impl<'tcx> LateLintPass<'tcx> for Casts {
         if let ExprKind::Cast(ref ex, _) = expr.kind {
             let (cast_from, cast_to) = (cx.typeck_results().expr_ty(ex), cx.typeck_results().expr_ty(expr));
             lint_fn_to_numeric_cast(cx, expr, ex, cast_from, cast_to);
-            if let ExprKind::Lit(ref lit) = ex.kind {
+            if let Some(lit) = get_numeric_literal(ex) {
+                let literal_str = snippet_opt(cx, lit.span).unwrap_or_default();
+
                 if_chain! {
                     if let LitKind::Int(n, _) = lit.node;
                     if let Some(src) = snippet_opt(cx, lit.span);
@@ -1609,25 +1612,19 @@ impl<'tcx> LateLintPass<'tcx> for Casts {
                     let to_nbits = fp_ty_mantissa_nbits(cast_to);
                     if from_nbits != 0 && to_nbits != 0 && from_nbits <= to_nbits && num_lit.is_decimal();
                     then {
-                        show_unnecessary_cast(cx, expr, n , cast_from, cast_to);
+                        show_unnecessary_cast(cx, expr, num_lit.integer, cast_from, cast_to);
                         return;
                     }
                 }
 
                 match lit.node {
-                    LitKind::Int(num, LitIntType::Unsuffixed) if cast_to.is_integral() => {
-                        show_unnecessary_cast(cx, expr, num, cast_from, cast_to);
-                        return;
+                    LitKind::Int(_, LitIntType::Unsuffixed) if cast_to.is_integral() => {
+                        show_unnecessary_cast(cx, expr, &literal_str, cast_from, cast_to);
                     },
-                    LitKind::Float(num, LitFloatType::Unsuffixed) if cast_to.is_floating_point() => {
-                        show_unnecessary_cast(cx, expr, num, cast_from, cast_to);
-                        return;
+                    LitKind::Float(_, LitFloatType::Unsuffixed) if cast_to.is_floating_point() => {
+                        show_unnecessary_cast(cx, expr, &literal_str, cast_from, cast_to);
                     },
-                    _ => (),
-                };
-
-                match lit.node {
-                    LitKind::Int(_, LitIntType::Unsuffixed) | LitKind::Float(_, LitFloatType::Unsuffixed) => {},
+                    LitKind::Int(_, LitIntType::Unsuffixed) | LitKind::Float(_, LitFloatType::Unsuffixed) => (),
                     _ => {
                         if cast_from.kind() == cast_to.kind() && !in_external_macro(cx.sess(), expr.span) {
                             span_lint(
@@ -1652,13 +1649,21 @@ impl<'tcx> LateLintPass<'tcx> for Casts {
     }
 }
 
-fn show_unnecessary_cast<Num: Display>(
-    cx: &LateContext<'_>,
-    expr: &Expr<'_>,
-    num: Num,
-    cast_from: Ty<'_>,
-    cast_to: Ty<'_>,
-) {
+fn get_numeric_literal<'e>(expr: &'e Expr<'e>) -> Option<&'e Lit> {
+    match expr.kind {
+        ExprKind::Lit(ref lit) => Some(lit),
+        ExprKind::Unary(UnOp::UnNeg, e) => {
+            if let ExprKind::Lit(ref lit) = e.kind {
+                Some(lit)
+            } else {
+                None
+            }
+        },
+        _ => None,
+    }
+}
+
+fn show_unnecessary_cast(cx: &LateContext<'_>, expr: &Expr<'_>, literal_str: &str, cast_from: Ty<'_>, cast_to: Ty<'_>) {
     let literal_kind_name = if cast_from.is_integral() { "integer" } else { "float" };
     span_lint_and_sugg(
         cx,
@@ -1666,7 +1671,7 @@ fn show_unnecessary_cast<Num: Display>(
         expr.span,
         &format!("casting {} literal to `{}` is unnecessary", literal_kind_name, cast_to),
         "try",
-        format!("{}_{}", num, cast_to),
+        format!("{}_{}", literal_str, cast_to),
         Applicability::MachineApplicable,
     );
 }
diff --git a/tests/ui/unnecessary_cast_fixable.fixed b/tests/ui/unnecessary_cast_fixable.fixed
index ba52fc2703f..54853f4b8a2 100644
--- a/tests/ui/unnecessary_cast_fixable.fixed
+++ b/tests/ui/unnecessary_cast_fixable.fixed
@@ -20,8 +20,10 @@ fn main() {
     0b11 as f64;
 
     1_u32;
-    16_i32;
-    2_usize;
+    0x10_i32;
+    0b10_usize;
+    0o73_u16;
+    1_000_000_000_u32;
 
     1.0_f64;
     0.5_f32;
diff --git a/tests/ui/unnecessary_cast_fixable.rs b/tests/ui/unnecessary_cast_fixable.rs
index 0d2115548fd..8da3d947702 100644
--- a/tests/ui/unnecessary_cast_fixable.rs
+++ b/tests/ui/unnecessary_cast_fixable.rs
@@ -22,6 +22,8 @@ fn main() {
     1 as u32;
     0x10 as i32;
     0b10 as usize;
+    0o73 as u16;
+    1_000_000_000 as u32;
 
     1.0 as f64;
     0.5 as f32;
diff --git a/tests/ui/unnecessary_cast_fixable.stderr b/tests/ui/unnecessary_cast_fixable.stderr
index 474e62c30d5..28fb9540afc 100644
--- a/tests/ui/unnecessary_cast_fixable.stderr
+++ b/tests/ui/unnecessary_cast_fixable.stderr
@@ -28,25 +28,37 @@ error: casting integer literal to `i32` is unnecessary
   --> $DIR/unnecessary_cast_fixable.rs:23:5
    |
 LL |     0x10 as i32;
-   |     ^^^^^^^^^^^ help: try: `16_i32`
+   |     ^^^^^^^^^^^ help: try: `0x10_i32`
 
 error: casting integer literal to `usize` is unnecessary
   --> $DIR/unnecessary_cast_fixable.rs:24:5
    |
 LL |     0b10 as usize;
-   |     ^^^^^^^^^^^^^ help: try: `2_usize`
+   |     ^^^^^^^^^^^^^ help: try: `0b10_usize`
 
-error: casting float literal to `f64` is unnecessary
+error: casting integer literal to `u16` is unnecessary
+  --> $DIR/unnecessary_cast_fixable.rs:25:5
+   |
+LL |     0o73 as u16;
+   |     ^^^^^^^^^^^ help: try: `0o73_u16`
+
+error: casting integer literal to `u32` is unnecessary
   --> $DIR/unnecessary_cast_fixable.rs:26:5
    |
+LL |     1_000_000_000 as u32;
+   |     ^^^^^^^^^^^^^^^^^^^^ help: try: `1_000_000_000_u32`
+
+error: casting float literal to `f64` is unnecessary
+  --> $DIR/unnecessary_cast_fixable.rs:28:5
+   |
 LL |     1.0 as f64;
    |     ^^^^^^^^^^ help: try: `1.0_f64`
 
 error: casting float literal to `f32` is unnecessary
-  --> $DIR/unnecessary_cast_fixable.rs:27:5
+  --> $DIR/unnecessary_cast_fixable.rs:29:5
    |
 LL |     0.5 as f32;
    |     ^^^^^^^^^^ help: try: `0.5_f32`
 
-error: aborting due to 8 previous errors
+error: aborting due to 10 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 02f01104bfbb935ee1c3c3971ccf055173e4f82b Mon Sep 17 00:00:00 2001
From: Geoffrey Copin <copin.geoffrey@gmail.com>
Date: Fri, 23 Oct 2020 00:04:27 +0200
Subject: Add test case for negative literals

---
 clippy_lints/src/types.rs                |  2 +-
 tests/ui/unnecessary_cast_fixable.fixed  |  3 +++
 tests/ui/unnecessary_cast_fixable.rs     |  3 +++
 tests/ui/unnecessary_cast_fixable.stderr | 14 +++++++++++++-
 4 files changed, 20 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs
index f4bb648d15a..3a088709a7e 100644
--- a/clippy_lints/src/types.rs
+++ b/clippy_lints/src/types.rs
@@ -1601,7 +1601,7 @@ impl<'tcx> LateLintPass<'tcx> for Casts {
             let (cast_from, cast_to) = (cx.typeck_results().expr_ty(ex), cx.typeck_results().expr_ty(expr));
             lint_fn_to_numeric_cast(cx, expr, ex, cast_from, cast_to);
             if let Some(lit) = get_numeric_literal(ex) {
-                let literal_str = snippet_opt(cx, lit.span).unwrap_or_default();
+                let literal_str = snippet_opt(cx, ex.span).unwrap_or_default();
 
                 if_chain! {
                     if let LitKind::Int(n, _) = lit.node;
diff --git a/tests/ui/unnecessary_cast_fixable.fixed b/tests/ui/unnecessary_cast_fixable.fixed
index 54853f4b8a2..2a13469b146 100644
--- a/tests/ui/unnecessary_cast_fixable.fixed
+++ b/tests/ui/unnecessary_cast_fixable.fixed
@@ -29,4 +29,7 @@ fn main() {
     0.5_f32;
 
     1.0 as u16;
+
+    -1_i32;
+    -1.0_f32;
 }
diff --git a/tests/ui/unnecessary_cast_fixable.rs b/tests/ui/unnecessary_cast_fixable.rs
index 8da3d947702..65ddd3c7fbf 100644
--- a/tests/ui/unnecessary_cast_fixable.rs
+++ b/tests/ui/unnecessary_cast_fixable.rs
@@ -29,4 +29,7 @@ fn main() {
     0.5 as f32;
 
     1.0 as u16;
+
+    -1 as i32;
+    -1.0 as f32;
 }
diff --git a/tests/ui/unnecessary_cast_fixable.stderr b/tests/ui/unnecessary_cast_fixable.stderr
index 28fb9540afc..26b23e315e3 100644
--- a/tests/ui/unnecessary_cast_fixable.stderr
+++ b/tests/ui/unnecessary_cast_fixable.stderr
@@ -60,5 +60,17 @@ error: casting float literal to `f32` is unnecessary
 LL |     0.5 as f32;
    |     ^^^^^^^^^^ help: try: `0.5_f32`
 
-error: aborting due to 10 previous errors
+error: casting integer literal to `i32` is unnecessary
+  --> $DIR/unnecessary_cast_fixable.rs:33:5
+   |
+LL |     -1 as i32;
+   |     ^^^^^^^^^ help: try: `-1_i32`
+
+error: casting float literal to `f32` is unnecessary
+  --> $DIR/unnecessary_cast_fixable.rs:34:5
+   |
+LL |     -1.0 as f32;
+   |     ^^^^^^^^^^^ help: try: `-1.0_f32`
+
+error: aborting due to 12 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 3807634a470b572303d95feb8a5db273c7cea4af Mon Sep 17 00:00:00 2001
From: Joe Richey <joerichey@google.com>
Date: Sun, 11 Oct 2020 16:04:33 -0700
Subject: clippy_lints: Update empty_loop lint

We also update the documentation to note that the remediations are
different for `std` and `no_std` crates.

Signed-off-by: Joe Richey <joerichey@google.com>
---
 clippy_lints/src/loops.rs       | 29 +++++++++++++++++++++++------
 tests/ui/crashes/ice-360.stderr |  3 ++-
 tests/ui/empty_loop.stderr      | 11 ++++++++---
 tests/ui/empty_loop_no_std.rs   | 22 ++++++++++++++++++++++
 tests/ui/issue-3746.rs          | 22 ----------------------
 5 files changed, 55 insertions(+), 32 deletions(-)
 create mode 100644 tests/ui/empty_loop_no_std.rs
 delete mode 100644 tests/ui/issue-3746.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 63d7e3176b1..bae12943869 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -293,9 +293,24 @@ declare_clippy_lint! {
 declare_clippy_lint! {
     /// **What it does:** Checks for empty `loop` expressions.
     ///
-    /// **Why is this bad?** Those busy loops burn CPU cycles without doing
-    /// anything. Think of the environment and either block on something or at least
-    /// make the thread sleep for some microseconds.
+    /// **Why is this bad?** These busy loops burn CPU cycles without doing
+    /// anything. It is _almost always_ a better idea to `panic!` than to have
+    /// a busy loop.
+    ///
+    /// If panicking isn't possible, think of the environment and either:
+    ///   - block on something
+    ///   - sleep the thread for some microseconds
+    ///   - yield or pause the thread
+    ///
+    /// For `std` targets, this can be done with
+    /// [`std::thread::sleep`](https://doc.rust-lang.org/std/thread/fn.sleep.html)
+    /// or [`std::thread::yield_now`](https://doc.rust-lang.org/std/thread/fn.yield_now.html).
+    ///
+    /// For `no_std` targets, doing this is more complicated, especially because
+    /// `#[panic_handler]`s can't panic. To stop/pause the thread, you will
+    /// probably need to invoke some target-specific intrinsic. Examples include:
+    ///   - [`x86_64::instructions::hlt`](https://docs.rs/x86_64/0.12.2/x86_64/instructions/fn.hlt.html)
+    ///   - [`cortex_m::asm::wfi`](https://docs.rs/cortex-m/0.6.3/cortex_m/asm/fn.wfi.html)
     ///
     /// **Known problems:** None.
     ///
@@ -502,13 +517,15 @@ impl<'tcx> LateLintPass<'tcx> for Loops {
         // (even if the "match" or "if let" is used for declaration)
         if let ExprKind::Loop(ref block, _, LoopSource::Loop) = expr.kind {
             // also check for empty `loop {}` statements
+            // TODO(issue #6161): Enable for no_std crates (outside of #[panic_handler])
             if block.stmts.is_empty() && block.expr.is_none() && !is_no_std_crate(cx.tcx.hir().krate()) {
-                span_lint(
+                span_lint_and_help(
                     cx,
                     EMPTY_LOOP,
                     expr.span,
-                    "empty `loop {}` detected. You may want to either use `panic!()` or add \
-                     `std::thread::sleep(..);` to the loop body.",
+                    "empty `loop {}` wastes CPU cycles",
+                    None,
+                    "You should either use `panic!()` or add `std::thread::sleep(..);` to the loop body.",
                 );
             }
 
diff --git a/tests/ui/crashes/ice-360.stderr b/tests/ui/crashes/ice-360.stderr
index 84e31eaf2e9..bb03ce40355 100644
--- a/tests/ui/crashes/ice-360.stderr
+++ b/tests/ui/crashes/ice-360.stderr
@@ -12,13 +12,14 @@ LL | |     }
    |
    = note: `-D clippy::while-let-loop` implied by `-D warnings`
 
-error: empty `loop {}` detected. You may want to either use `panic!()` or add `std::thread::sleep(..);` to the loop body.
+error: empty `loop {}` wastes CPU cycles
   --> $DIR/ice-360.rs:10:9
    |
 LL |         loop {}
    |         ^^^^^^^
    |
    = note: `-D clippy::empty-loop` implied by `-D warnings`
+   = help: You should either use `panic!()` or add `std::thread::sleep(..);` to the loop body.
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/empty_loop.stderr b/tests/ui/empty_loop.stderr
index e44c58ea770..fd3979f259a 100644
--- a/tests/ui/empty_loop.stderr
+++ b/tests/ui/empty_loop.stderr
@@ -1,22 +1,27 @@
-error: empty `loop {}` detected. You may want to either use `panic!()` or add `std::thread::sleep(..);` to the loop body.
+error: empty `loop {}` wastes CPU cycles
   --> $DIR/empty_loop.rs:9:5
    |
 LL |     loop {}
    |     ^^^^^^^
    |
    = note: `-D clippy::empty-loop` implied by `-D warnings`
+   = help: You should either use `panic!()` or add `std::thread::sleep(..);` to the loop body.
 
-error: empty `loop {}` detected. You may want to either use `panic!()` or add `std::thread::sleep(..);` to the loop body.
+error: empty `loop {}` wastes CPU cycles
   --> $DIR/empty_loop.rs:11:9
    |
 LL |         loop {}
    |         ^^^^^^^
+   |
+   = help: You should either use `panic!()` or add `std::thread::sleep(..);` to the loop body.
 
-error: empty `loop {}` detected. You may want to either use `panic!()` or add `std::thread::sleep(..);` to the loop body.
+error: empty `loop {}` wastes CPU cycles
   --> $DIR/empty_loop.rs:15:9
    |
 LL |         'inner: loop {}
    |         ^^^^^^^^^^^^^^^
+   |
+   = help: You should either use `panic!()` or add `std::thread::sleep(..);` to the loop body.
 
 error: aborting due to 3 previous errors
 
diff --git a/tests/ui/empty_loop_no_std.rs b/tests/ui/empty_loop_no_std.rs
new file mode 100644
index 00000000000..879d1d5d916
--- /dev/null
+++ b/tests/ui/empty_loop_no_std.rs
@@ -0,0 +1,22 @@
+// ignore-macos
+// ignore-windows
+
+#![warn(clippy::empty_loop)]
+#![feature(lang_items, link_args, start, libc)]
+#![link_args = "-nostartfiles"]
+#![no_std]
+
+use core::panic::PanicInfo;
+
+#[start]
+fn main(argc: isize, argv: *const *const u8) -> isize {
+    loop {}
+}
+
+#[panic_handler]
+fn panic(_info: &PanicInfo) -> ! {
+    loop {}
+}
+
+#[lang = "eh_personality"]
+extern "C" fn eh_personality() {}
diff --git a/tests/ui/issue-3746.rs b/tests/ui/issue-3746.rs
deleted file mode 100644
index 879d1d5d916..00000000000
--- a/tests/ui/issue-3746.rs
+++ /dev/null
@@ -1,22 +0,0 @@
-// ignore-macos
-// ignore-windows
-
-#![warn(clippy::empty_loop)]
-#![feature(lang_items, link_args, start, libc)]
-#![link_args = "-nostartfiles"]
-#![no_std]
-
-use core::panic::PanicInfo;
-
-#[start]
-fn main(argc: isize, argv: *const *const u8) -> isize {
-    loop {}
-}
-
-#[panic_handler]
-fn panic(_info: &PanicInfo) -> ! {
-    loop {}
-}
-
-#[lang = "eh_personality"]
-extern "C" fn eh_personality() {}
-- 
cgit 1.4.1-3-g733a5


From d46edd99667ad342e6118b2216a0c24ee009e86c Mon Sep 17 00:00:00 2001
From: Geoffrey Copin <copin.geoffrey@gmail.com>
Date: Fri, 23 Oct 2020 23:40:57 +0200
Subject: Keep sign in int-to-float casts

---
 clippy_lints/src/types.rs                | 16 ++++++++++++--
 tests/ui/unnecessary_cast_fixable.fixed  |  3 +++
 tests/ui/unnecessary_cast_fixable.rs     |  3 +++
 tests/ui/unnecessary_cast_fixable.stderr | 38 +++++++++++++++++++++++---------
 4 files changed, 48 insertions(+), 12 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs
index 3a088709a7e..6a33aaaaab2 100644
--- a/clippy_lints/src/types.rs
+++ b/clippy_lints/src/types.rs
@@ -1236,6 +1236,13 @@ declare_clippy_lint! {
     /// let _ = 2i32 as i32;
     /// let _ = 0.5 as f32;
     /// ```
+    ///
+    /// Better:
+    ///
+    /// ```rust
+    /// let _ = 2_i32;
+    /// let _ = 0.5_f32;
+    /// ```
     pub UNNECESSARY_CAST,
     complexity,
     "cast to the same type, e.g., `x as i32` where `x: i32`"
@@ -1612,7 +1619,8 @@ impl<'tcx> LateLintPass<'tcx> for Casts {
                     let to_nbits = fp_ty_mantissa_nbits(cast_to);
                     if from_nbits != 0 && to_nbits != 0 && from_nbits <= to_nbits && num_lit.is_decimal();
                     then {
-                        show_unnecessary_cast(cx, expr, num_lit.integer, cast_from, cast_to);
+                        let literal_str = if is_unary_neg(ex) { format!("-{}", num_lit.integer) } else { num_lit.integer.into() };
+                        show_unnecessary_cast(cx, expr, &literal_str, cast_from, cast_to);
                         return;
                     }
                 }
@@ -1624,7 +1632,7 @@ impl<'tcx> LateLintPass<'tcx> for Casts {
                     LitKind::Float(_, LitFloatType::Unsuffixed) if cast_to.is_floating_point() => {
                         show_unnecessary_cast(cx, expr, &literal_str, cast_from, cast_to);
                     },
-                    LitKind::Int(_, LitIntType::Unsuffixed) | LitKind::Float(_, LitFloatType::Unsuffixed) => (),
+                    LitKind::Int(_, LitIntType::Unsuffixed) | LitKind::Float(_, LitFloatType::Unsuffixed) => {},
                     _ => {
                         if cast_from.kind() == cast_to.kind() && !in_external_macro(cx.sess(), expr.span) {
                             span_lint(
@@ -1649,6 +1657,10 @@ impl<'tcx> LateLintPass<'tcx> for Casts {
     }
 }
 
+fn is_unary_neg(expr: &Expr<'_>) -> bool {
+    matches!(expr.kind, ExprKind::Unary(UnOp::UnNeg, _))
+}
+
 fn get_numeric_literal<'e>(expr: &'e Expr<'e>) -> Option<&'e Lit> {
     match expr.kind {
         ExprKind::Lit(ref lit) => Some(lit),
diff --git a/tests/ui/unnecessary_cast_fixable.fixed b/tests/ui/unnecessary_cast_fixable.fixed
index 5aeb0340b26..350da4965d1 100644
--- a/tests/ui/unnecessary_cast_fixable.fixed
+++ b/tests/ui/unnecessary_cast_fixable.fixed
@@ -8,6 +8,9 @@ fn main() {
     100_f32;
     100_f64;
     100_f64;
+    let _ = -100_f32;
+    let _ = -100_f64;
+    let _ = -100_f64;
     // Should not trigger
     #[rustfmt::skip]
     let v = vec!(1);
diff --git a/tests/ui/unnecessary_cast_fixable.rs b/tests/ui/unnecessary_cast_fixable.rs
index 0f249c23055..ad2fb2e6289 100644
--- a/tests/ui/unnecessary_cast_fixable.rs
+++ b/tests/ui/unnecessary_cast_fixable.rs
@@ -8,6 +8,9 @@ fn main() {
     100 as f32;
     100 as f64;
     100_i32 as f64;
+    let _ = -100 as f32;
+    let _ = -100 as f64;
+    let _ = -100_i32 as f64;
     // Should not trigger
     #[rustfmt::skip]
     let v = vec!(1);
diff --git a/tests/ui/unnecessary_cast_fixable.stderr b/tests/ui/unnecessary_cast_fixable.stderr
index 5100e9798c4..5a210fc8909 100644
--- a/tests/ui/unnecessary_cast_fixable.stderr
+++ b/tests/ui/unnecessary_cast_fixable.stderr
@@ -18,59 +18,77 @@ error: casting integer literal to `f64` is unnecessary
 LL |     100_i32 as f64;
    |     ^^^^^^^^^^^^^^ help: try: `100_f64`
 
+error: casting integer literal to `f32` is unnecessary
+  --> $DIR/unnecessary_cast_fixable.rs:11:13
+   |
+LL |     let _ = -100 as f32;
+   |             ^^^^^^^^^^^ help: try: `-100_f32`
+
+error: casting integer literal to `f64` is unnecessary
+  --> $DIR/unnecessary_cast_fixable.rs:12:13
+   |
+LL |     let _ = -100 as f64;
+   |             ^^^^^^^^^^^ help: try: `-100_f64`
+
+error: casting integer literal to `f64` is unnecessary
+  --> $DIR/unnecessary_cast_fixable.rs:13:13
+   |
+LL |     let _ = -100_i32 as f64;
+   |             ^^^^^^^^^^^^^^^ help: try: `-100_f64`
+
 error: casting integer literal to `u32` is unnecessary
-  --> $DIR/unnecessary_cast_fixable.rs:22:5
+  --> $DIR/unnecessary_cast_fixable.rs:25:5
    |
 LL |     1 as u32;
    |     ^^^^^^^^ help: try: `1_u32`
 
 error: casting integer literal to `i32` is unnecessary
-  --> $DIR/unnecessary_cast_fixable.rs:23:5
+  --> $DIR/unnecessary_cast_fixable.rs:26:5
    |
 LL |     0x10 as i32;
    |     ^^^^^^^^^^^ help: try: `0x10_i32`
 
 error: casting integer literal to `usize` is unnecessary
-  --> $DIR/unnecessary_cast_fixable.rs:24:5
+  --> $DIR/unnecessary_cast_fixable.rs:27:5
    |
 LL |     0b10 as usize;
    |     ^^^^^^^^^^^^^ help: try: `0b10_usize`
 
 error: casting integer literal to `u16` is unnecessary
-  --> $DIR/unnecessary_cast_fixable.rs:25:5
+  --> $DIR/unnecessary_cast_fixable.rs:28:5
    |
 LL |     0o73 as u16;
    |     ^^^^^^^^^^^ help: try: `0o73_u16`
 
 error: casting integer literal to `u32` is unnecessary
-  --> $DIR/unnecessary_cast_fixable.rs:26:5
+  --> $DIR/unnecessary_cast_fixable.rs:29:5
    |
 LL |     1_000_000_000 as u32;
    |     ^^^^^^^^^^^^^^^^^^^^ help: try: `1_000_000_000_u32`
 
 error: casting float literal to `f64` is unnecessary
-  --> $DIR/unnecessary_cast_fixable.rs:28:5
+  --> $DIR/unnecessary_cast_fixable.rs:31:5
    |
 LL |     1.0 as f64;
    |     ^^^^^^^^^^ help: try: `1.0_f64`
 
 error: casting float literal to `f32` is unnecessary
-  --> $DIR/unnecessary_cast_fixable.rs:29:5
+  --> $DIR/unnecessary_cast_fixable.rs:32:5
    |
 LL |     0.5 as f32;
    |     ^^^^^^^^^^ help: try: `0.5_f32`
 
 error: casting integer literal to `i32` is unnecessary
-  --> $DIR/unnecessary_cast_fixable.rs:33:13
+  --> $DIR/unnecessary_cast_fixable.rs:36:13
    |
 LL |     let _ = -1 as i32;
    |             ^^^^^^^^^ help: try: `-1_i32`
 
 error: casting float literal to `f32` is unnecessary
-  --> $DIR/unnecessary_cast_fixable.rs:34:13
+  --> $DIR/unnecessary_cast_fixable.rs:37:13
    |
 LL |     let _ = -1.0 as f32;
    |             ^^^^^^^^^^^ help: try: `-1.0_f32`
 
-error: aborting due to 12 previous errors
+error: aborting due to 15 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 62f60e1ae5bd2287497746bf90a302903e0ae462 Mon Sep 17 00:00:00 2001
From: ThibsG <Thibs@debian.com>
Date: Sat, 24 Oct 2020 09:31:32 +0200
Subject: No lint with `cfg!` and fix sugg for macro in `needless_bool` lint

---
 clippy_lints/src/needless_bool.rs | 16 ++++++++--
 tests/ui/bool_comparison.fixed    | 40 ++++++++++++++++++++++++-
 tests/ui/bool_comparison.rs       | 40 ++++++++++++++++++++++++-
 tests/ui/bool_comparison.stderr   | 62 +++++++++++++++++++++++++++------------
 4 files changed, 135 insertions(+), 23 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/needless_bool.rs b/clippy_lints/src/needless_bool.rs
index dc5aa669139..a799a644e97 100644
--- a/clippy_lints/src/needless_bool.rs
+++ b/clippy_lints/src/needless_bool.rs
@@ -3,7 +3,9 @@
 //! This lint is **warn** by default
 
 use crate::utils::sugg::Sugg;
-use crate::utils::{higher, parent_node_is_if_expr, snippet_with_applicability, span_lint, span_lint_and_sugg};
+use crate::utils::{
+    higher, is_expn_of, parent_node_is_if_expr, snippet_with_applicability, span_lint, span_lint_and_sugg,
+};
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
@@ -233,6 +235,9 @@ fn check_comparison<'a, 'tcx>(
             cx.typeck_results().expr_ty(left_side),
             cx.typeck_results().expr_ty(right_side),
         );
+        if is_expn_of(left_side.span, "cfg").is_some() || is_expn_of(right_side.span, "cfg").is_some() {
+            return;
+        }
         if l_ty.is_bool() && r_ty.is_bool() {
             let mut applicability = Applicability::MachineApplicable;
 
@@ -295,7 +300,14 @@ fn suggest_bool_comparison<'a, 'tcx>(
     message: &str,
     conv_hint: impl FnOnce(Sugg<'a>) -> Sugg<'a>,
 ) {
-    let hint = Sugg::hir_with_applicability(cx, expr, "..", &mut applicability);
+    let hint = if expr.span.from_expansion() {
+        if applicability != Applicability::Unspecified {
+            applicability = Applicability::MaybeIncorrect;
+        }
+        Sugg::hir_with_macro_callsite(cx, expr, "..")
+    } else {
+        Sugg::hir_with_applicability(cx, expr, "..", &mut applicability)
+    };
     span_lint_and_sugg(
         cx,
         BOOL_COMPARISON,
diff --git a/tests/ui/bool_comparison.fixed b/tests/ui/bool_comparison.fixed
index 91211764759..5a012ff4d27 100644
--- a/tests/ui/bool_comparison.fixed
+++ b/tests/ui/bool_comparison.fixed
@@ -1,6 +1,7 @@
 // run-rustfix
 
-#[warn(clippy::bool_comparison)]
+#![warn(clippy::bool_comparison)]
+
 fn main() {
     let x = true;
     if x {
@@ -127,3 +128,40 @@ fn issue4983() {
     if b == a {};
     if !b == !a {};
 }
+
+macro_rules! m {
+    ($func:ident) => {
+        $func()
+    };
+}
+
+fn func() -> bool {
+    true
+}
+
+#[allow(dead_code)]
+fn issue3973() {
+    // ok, don't lint on `cfg` invocation
+    if false == cfg!(feature = "debugging") {}
+    if cfg!(feature = "debugging") == false {}
+    if true == cfg!(feature = "debugging") {}
+    if cfg!(feature = "debugging") == true {}
+
+    // lint, could be simplified
+    if !m!(func) {}
+    if !m!(func) {}
+    if m!(func) {}
+    if m!(func) {}
+
+    // no lint with a variable
+    let is_debug = false;
+    if is_debug == cfg!(feature = "debugging") {}
+    if cfg!(feature = "debugging") == is_debug {}
+    if is_debug == m!(func) {}
+    if m!(func) == is_debug {}
+    let is_debug = true;
+    if is_debug == cfg!(feature = "debugging") {}
+    if cfg!(feature = "debugging") == is_debug {}
+    if is_debug == m!(func) {}
+    if m!(func) == is_debug {}
+}
diff --git a/tests/ui/bool_comparison.rs b/tests/ui/bool_comparison.rs
index 01ee35859f0..c534bc25c20 100644
--- a/tests/ui/bool_comparison.rs
+++ b/tests/ui/bool_comparison.rs
@@ -1,6 +1,7 @@
 // run-rustfix
 
-#[warn(clippy::bool_comparison)]
+#![warn(clippy::bool_comparison)]
+
 fn main() {
     let x = true;
     if x == true {
@@ -127,3 +128,40 @@ fn issue4983() {
     if b == a {};
     if !b == !a {};
 }
+
+macro_rules! m {
+    ($func:ident) => {
+        $func()
+    };
+}
+
+fn func() -> bool {
+    true
+}
+
+#[allow(dead_code)]
+fn issue3973() {
+    // ok, don't lint on `cfg` invocation
+    if false == cfg!(feature = "debugging") {}
+    if cfg!(feature = "debugging") == false {}
+    if true == cfg!(feature = "debugging") {}
+    if cfg!(feature = "debugging") == true {}
+
+    // lint, could be simplified
+    if false == m!(func) {}
+    if m!(func) == false {}
+    if true == m!(func) {}
+    if m!(func) == true {}
+
+    // no lint with a variable
+    let is_debug = false;
+    if is_debug == cfg!(feature = "debugging") {}
+    if cfg!(feature = "debugging") == is_debug {}
+    if is_debug == m!(func) {}
+    if m!(func) == is_debug {}
+    let is_debug = true;
+    if is_debug == cfg!(feature = "debugging") {}
+    if cfg!(feature = "debugging") == is_debug {}
+    if is_debug == m!(func) {}
+    if m!(func) == is_debug {}
+}
diff --git a/tests/ui/bool_comparison.stderr b/tests/ui/bool_comparison.stderr
index 55d94b8257d..31522d4a525 100644
--- a/tests/ui/bool_comparison.stderr
+++ b/tests/ui/bool_comparison.stderr
@@ -1,5 +1,5 @@
 error: equality checks against true are unnecessary
-  --> $DIR/bool_comparison.rs:6:8
+  --> $DIR/bool_comparison.rs:7:8
    |
 LL |     if x == true {
    |        ^^^^^^^^^ help: try simplifying it as shown: `x`
@@ -7,106 +7,130 @@ LL |     if x == true {
    = note: `-D clippy::bool-comparison` implied by `-D warnings`
 
 error: equality checks against false can be replaced by a negation
-  --> $DIR/bool_comparison.rs:11:8
+  --> $DIR/bool_comparison.rs:12:8
    |
 LL |     if x == false {
    |        ^^^^^^^^^^ help: try simplifying it as shown: `!x`
 
 error: equality checks against true are unnecessary
-  --> $DIR/bool_comparison.rs:16:8
+  --> $DIR/bool_comparison.rs:17:8
    |
 LL |     if true == x {
    |        ^^^^^^^^^ help: try simplifying it as shown: `x`
 
 error: equality checks against false can be replaced by a negation
-  --> $DIR/bool_comparison.rs:21:8
+  --> $DIR/bool_comparison.rs:22:8
    |
 LL |     if false == x {
    |        ^^^^^^^^^^ help: try simplifying it as shown: `!x`
 
 error: inequality checks against true can be replaced by a negation
-  --> $DIR/bool_comparison.rs:26:8
+  --> $DIR/bool_comparison.rs:27:8
    |
 LL |     if x != true {
    |        ^^^^^^^^^ help: try simplifying it as shown: `!x`
 
 error: inequality checks against false are unnecessary
-  --> $DIR/bool_comparison.rs:31:8
+  --> $DIR/bool_comparison.rs:32:8
    |
 LL |     if x != false {
    |        ^^^^^^^^^^ help: try simplifying it as shown: `x`
 
 error: inequality checks against true can be replaced by a negation
-  --> $DIR/bool_comparison.rs:36:8
+  --> $DIR/bool_comparison.rs:37:8
    |
 LL |     if true != x {
    |        ^^^^^^^^^ help: try simplifying it as shown: `!x`
 
 error: inequality checks against false are unnecessary
-  --> $DIR/bool_comparison.rs:41:8
+  --> $DIR/bool_comparison.rs:42:8
    |
 LL |     if false != x {
    |        ^^^^^^^^^^ help: try simplifying it as shown: `x`
 
 error: less than comparison against true can be replaced by a negation
-  --> $DIR/bool_comparison.rs:46:8
+  --> $DIR/bool_comparison.rs:47:8
    |
 LL |     if x < true {
    |        ^^^^^^^^ help: try simplifying it as shown: `!x`
 
 error: greater than checks against false are unnecessary
-  --> $DIR/bool_comparison.rs:51:8
+  --> $DIR/bool_comparison.rs:52:8
    |
 LL |     if false < x {
    |        ^^^^^^^^^ help: try simplifying it as shown: `x`
 
 error: greater than checks against false are unnecessary
-  --> $DIR/bool_comparison.rs:56:8
+  --> $DIR/bool_comparison.rs:57:8
    |
 LL |     if x > false {
    |        ^^^^^^^^^ help: try simplifying it as shown: `x`
 
 error: less than comparison against true can be replaced by a negation
-  --> $DIR/bool_comparison.rs:61:8
+  --> $DIR/bool_comparison.rs:62:8
    |
 LL |     if true > x {
    |        ^^^^^^^^ help: try simplifying it as shown: `!x`
 
 error: order comparisons between booleans can be simplified
-  --> $DIR/bool_comparison.rs:67:8
+  --> $DIR/bool_comparison.rs:68:8
    |
 LL |     if x < y {
    |        ^^^^^ help: try simplifying it as shown: `!x & y`
 
 error: order comparisons between booleans can be simplified
-  --> $DIR/bool_comparison.rs:72:8
+  --> $DIR/bool_comparison.rs:73:8
    |
 LL |     if x > y {
    |        ^^^^^ help: try simplifying it as shown: `x & !y`
 
 error: this comparison might be written more concisely
-  --> $DIR/bool_comparison.rs:120:8
+  --> $DIR/bool_comparison.rs:121:8
    |
 LL |     if a == !b {};
    |        ^^^^^^^ help: try simplifying it as shown: `a != b`
 
 error: this comparison might be written more concisely
-  --> $DIR/bool_comparison.rs:121:8
+  --> $DIR/bool_comparison.rs:122:8
    |
 LL |     if !a == b {};
    |        ^^^^^^^ help: try simplifying it as shown: `a != b`
 
 error: this comparison might be written more concisely
-  --> $DIR/bool_comparison.rs:125:8
+  --> $DIR/bool_comparison.rs:126:8
    |
 LL |     if b == !a {};
    |        ^^^^^^^ help: try simplifying it as shown: `b != a`
 
 error: this comparison might be written more concisely
-  --> $DIR/bool_comparison.rs:126:8
+  --> $DIR/bool_comparison.rs:127:8
    |
 LL |     if !b == a {};
    |        ^^^^^^^ help: try simplifying it as shown: `b != a`
 
-error: aborting due to 18 previous errors
+error: equality checks against false can be replaced by a negation
+  --> $DIR/bool_comparison.rs:151:8
+   |
+LL |     if false == m!(func) {}
+   |        ^^^^^^^^^^^^^^^^^ help: try simplifying it as shown: `!m!(func)`
+
+error: equality checks against false can be replaced by a negation
+  --> $DIR/bool_comparison.rs:152:8
+   |
+LL |     if m!(func) == false {}
+   |        ^^^^^^^^^^^^^^^^^ help: try simplifying it as shown: `!m!(func)`
+
+error: equality checks against true are unnecessary
+  --> $DIR/bool_comparison.rs:153:8
+   |
+LL |     if true == m!(func) {}
+   |        ^^^^^^^^^^^^^^^^ help: try simplifying it as shown: `m!(func)`
+
+error: equality checks against true are unnecessary
+  --> $DIR/bool_comparison.rs:154:8
+   |
+LL |     if m!(func) == true {}
+   |        ^^^^^^^^^^^^^^^^ help: try simplifying it as shown: `m!(func)`
+
+error: aborting due to 22 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 0d21ae0e194fd8f7f1f67bf1921910e0ca21a32c Mon Sep 17 00:00:00 2001
From: Tim Nielens <tim.nielens@gmail.com>
Date: Sat, 24 Oct 2020 11:35:05 +0200
Subject: manual-unwrap-or / pr remarks, round 3

---
 clippy_lints/src/manual_unwrap_or.rs | 13 +++----------
 tests/ui/manual_unwrap_or.fixed      | 12 +++++++++++-
 tests/ui/manual_unwrap_or.rs         | 15 ++++++++++++++-
 tests/ui/manual_unwrap_or.stderr     | 19 ++++++++++++++-----
 4 files changed, 42 insertions(+), 17 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_unwrap_or.rs b/clippy_lints/src/manual_unwrap_or.rs
index cc9ee28d027..22aa37e41fe 100644
--- a/clippy_lints/src/manual_unwrap_or.rs
+++ b/clippy_lints/src/manual_unwrap_or.rs
@@ -1,5 +1,6 @@
 use crate::consts::constant_simple;
 use crate::utils;
+use crate::utils::sugg;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{def, Arm, Expr, ExprKind, Pat, PatKind, QPath};
@@ -104,28 +105,20 @@ fn lint_manual_unwrap_or<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
             None
         };
         if let Some(or_arm) = applicable_or_arm(match_arms);
-        if let Some(scrutinee_snippet) = utils::snippet_opt(cx, scrutinee.span);
         if let Some(or_body_snippet) = utils::snippet_opt(cx, or_arm.body.span);
         if let Some(indent) = utils::indent_of(cx, expr.span);
         if constant_simple(cx, cx.typeck_results(), or_arm.body).is_some();
         then {
             let reindented_or_body =
                 utils::reindent_multiline(or_body_snippet.into(), true, Some(indent));
-            let wrap_in_parens = !matches!(scrutinee, Expr {
-                kind: ExprKind::Call(..) | ExprKind::Path(_), ..
-            });
-            let l_paren = if wrap_in_parens { "(" } else { "" };
-            let r_paren = if wrap_in_parens { ")" } else { "" };
             utils::span_lint_and_sugg(
                 cx,
                 MANUAL_UNWRAP_OR, expr.span,
                 &format!("this pattern reimplements `{}`", case.unwrap_fn_path()),
                 "replace with",
                 format!(
-                    "{}{}{}.unwrap_or({})",
-                    l_paren,
-                    scrutinee_snippet,
-                    r_paren,
+                    "{}.unwrap_or({})",
+                    sugg::Sugg::hir(cx, scrutinee, "..").maybe_par(),
                     reindented_or_body,
                 ),
                 Applicability::MachineApplicable,
diff --git a/tests/ui/manual_unwrap_or.fixed b/tests/ui/manual_unwrap_or.fixed
index 582f5c6f7a8..5aa5a43cb92 100644
--- a/tests/ui/manual_unwrap_or.fixed
+++ b/tests/ui/manual_unwrap_or.fixed
@@ -74,9 +74,19 @@ fn result_unwrap_or() {
     let a = Ok::<i32, &str>(1);
     a.unwrap_or(42);
 
-    // int case, suggestion must surround with parenthesis
+    // int case, suggestion must surround Result expr with parenthesis
     (Ok(1) as Result<i32, &str>).unwrap_or(42);
 
+    // method call case, suggestion must not surround Result expr `s.method()` with parenthesis
+    struct S {}
+    impl S {
+        fn method(self) -> Option<i32> {
+            Some(42)
+        }
+    }
+    let s = S {};
+    s.method().unwrap_or(42);
+
     // int case reversed
     Ok::<i32, &str>(1).unwrap_or(42);
 
diff --git a/tests/ui/manual_unwrap_or.rs b/tests/ui/manual_unwrap_or.rs
index 0e2b7ecadb3..df534031f54 100644
--- a/tests/ui/manual_unwrap_or.rs
+++ b/tests/ui/manual_unwrap_or.rs
@@ -95,12 +95,25 @@ fn result_unwrap_or() {
         Err(_) => 42,
     };
 
-    // int case, suggestion must surround with parenthesis
+    // int case, suggestion must surround Result expr with parenthesis
     match Ok(1) as Result<i32, &str> {
         Ok(i) => i,
         Err(_) => 42,
     };
 
+    // method call case, suggestion must not surround Result expr `s.method()` with parenthesis
+    struct S {}
+    impl S {
+        fn method(self) -> Option<i32> {
+            Some(42)
+        }
+    }
+    let s = S {};
+    match s.method() {
+        Some(i) => i,
+        None => 42,
+    };
+
     // int case reversed
     match Ok::<i32, &str>(1) {
         Err(_) => 42,
diff --git a/tests/ui/manual_unwrap_or.stderr b/tests/ui/manual_unwrap_or.stderr
index 6603ab43437..fc174c4c270 100644
--- a/tests/ui/manual_unwrap_or.stderr
+++ b/tests/ui/manual_unwrap_or.stderr
@@ -84,8 +84,17 @@ LL | |         Err(_) => 42,
 LL | |     };
    | |_____^ help: replace with: `(Ok(1) as Result<i32, &str>).unwrap_or(42)`
 
+error: this pattern reimplements `Option::unwrap_or`
+  --> $DIR/manual_unwrap_or.rs:112:5
+   |
+LL | /     match s.method() {
+LL | |         Some(i) => i,
+LL | |         None => 42,
+LL | |     };
+   | |_____^ help: replace with: `s.method().unwrap_or(42)`
+
 error: this pattern reimplements `Result::unwrap_or`
-  --> $DIR/manual_unwrap_or.rs:105:5
+  --> $DIR/manual_unwrap_or.rs:118:5
    |
 LL | /     match Ok::<i32, &str>(1) {
 LL | |         Err(_) => 42,
@@ -94,7 +103,7 @@ LL | |     };
    | |_____^ help: replace with: `Ok::<i32, &str>(1).unwrap_or(42)`
 
 error: this pattern reimplements `Result::unwrap_or`
-  --> $DIR/manual_unwrap_or.rs:111:5
+  --> $DIR/manual_unwrap_or.rs:124:5
    |
 LL | /     match Ok::<i32, &str>(1) {
 LL | |         Ok(i) => i,
@@ -103,7 +112,7 @@ LL | |     };
    | |_____^ help: replace with: `Ok::<i32, &str>(1).unwrap_or(1 + 42)`
 
 error: this pattern reimplements `Result::unwrap_or`
-  --> $DIR/manual_unwrap_or.rs:118:5
+  --> $DIR/manual_unwrap_or.rs:131:5
    |
 LL | /     match Ok::<i32, &str>(1) {
 LL | |         Ok(i) => i,
@@ -124,7 +133,7 @@ LL |     });
    |
 
 error: this pattern reimplements `Result::unwrap_or`
-  --> $DIR/manual_unwrap_or.rs:128:5
+  --> $DIR/manual_unwrap_or.rs:141:5
    |
 LL | /     match Ok::<&str, &str>("Bob") {
 LL | |         Ok(i) => i,
@@ -132,5 +141,5 @@ LL | |         Err(_) => "Alice",
 LL | |     };
    | |_____^ help: replace with: `Ok::<&str, &str>("Bob").unwrap_or("Alice")`
 
-error: aborting due to 12 previous errors
+error: aborting due to 13 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From e8731a926c9a642ca1ddf5b52baf40e0a8873d53 Mon Sep 17 00:00:00 2001
From: Cauê Baasch de Souza <cauebs@pm.me>
Date: Thu, 8 Oct 2020 02:17:32 -0300
Subject: Add large_types_passed_by_value lint

Refactor trivially_copy_pass_by_ref and the new lint into pass_by_ref_or_value module

Update stderr of conf_unknown_key test

Rename lint to large_types_passed_by_value

Increase `pass_by_value_size_limit` default value to 256

Improve rules for `large_types_passed_by_value`

Improve tests for `large_types_passed_by_value`

Improve documentation for `large_types_passed_by_value`

Make minor corrections to pass_by_ref_or_value.rs suggested by clippy itself

Fix `large_types_passed_by_value` example and improve docs

pass_by_ref_or_value: Tweak check for mut annotation in params

large_types_passed_by_value: add tests for pub trait, trait impl and inline attributes
---
 CHANGELOG.md                                       |   1 +
 clippy_lints/src/lib.rs                            |  13 +-
 clippy_lints/src/pass_by_ref_or_value.rs           | 256 +++++++++++++++++++++
 clippy_lints/src/trivially_copy_pass_by_ref.rs     | 183 ---------------
 clippy_lints/src/utils/conf.rs                     |   2 +
 src/lintlist/mod.rs                                |   9 +-
 .../toml_unknown_key/conf_unknown_key.stderr       |   2 +-
 tests/ui/large_types_passed_by_value.rs            |  66 ++++++
 tests/ui/large_types_passed_by_value.stderr        |  52 +++++
 9 files changed, 394 insertions(+), 190 deletions(-)
 create mode 100644 clippy_lints/src/pass_by_ref_or_value.rs
 delete mode 100644 clippy_lints/src/trivially_copy_pass_by_ref.rs
 create mode 100644 tests/ui/large_types_passed_by_value.rs
 create mode 100644 tests/ui/large_types_passed_by_value.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index d82f970b8bf..22f96398153 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1779,6 +1779,7 @@ Released 2018-09-13
 [`large_digit_groups`]: https://rust-lang.github.io/rust-clippy/master/index.html#large_digit_groups
 [`large_enum_variant`]: https://rust-lang.github.io/rust-clippy/master/index.html#large_enum_variant
 [`large_stack_arrays`]: https://rust-lang.github.io/rust-clippy/master/index.html#large_stack_arrays
+[`large_types_passed_by_value`]: https://rust-lang.github.io/rust-clippy/master/index.html#large_types_passed_by_value
 [`len_without_is_empty`]: https://rust-lang.github.io/rust-clippy/master/index.html#len_without_is_empty
 [`len_zero`]: https://rust-lang.github.io/rust-clippy/master/index.html#len_zero
 [`let_and_return`]: https://rust-lang.github.io/rust-clippy/master/index.html#let_and_return
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index d4d2f92a6a6..1a950a7c334 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -278,6 +278,7 @@ mod overflow_check_conditional;
 mod panic_in_result_fn;
 mod panic_unimplemented;
 mod partialeq_ne_impl;
+mod pass_by_ref_or_value;
 mod path_buf_push_overwrite;
 mod pattern_type_mismatch;
 mod precedence;
@@ -311,7 +312,6 @@ mod to_string_in_display;
 mod trait_bounds;
 mod transmute;
 mod transmuting_null;
-mod trivially_copy_pass_by_ref;
 mod try_err;
 mod types;
 mod unicode;
@@ -776,6 +776,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &panic_unimplemented::UNIMPLEMENTED,
         &panic_unimplemented::UNREACHABLE,
         &partialeq_ne_impl::PARTIALEQ_NE_IMPL,
+        &pass_by_ref_or_value::LARGE_TYPES_PASSED_BY_VALUE,
+        &pass_by_ref_or_value::TRIVIALLY_COPY_PASS_BY_REF,
         &path_buf_push_overwrite::PATH_BUF_PUSH_OVERWRITE,
         &pattern_type_mismatch::PATTERN_TYPE_MISMATCH,
         &precedence::PRECEDENCE,
@@ -835,7 +837,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &transmute::USELESS_TRANSMUTE,
         &transmute::WRONG_TRANSMUTE,
         &transmuting_null::TRANSMUTING_NULL,
-        &trivially_copy_pass_by_ref::TRIVIALLY_COPY_PASS_BY_REF,
         &try_err::TRY_ERR,
         &types::ABSURD_EXTREME_COMPARISONS,
         &types::BORROWED_BOX,
@@ -1009,11 +1010,12 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(move || box large_enum_variant::LargeEnumVariant::new(enum_variant_size_threshold));
     store.register_late_pass(|| box explicit_write::ExplicitWrite);
     store.register_late_pass(|| box needless_pass_by_value::NeedlessPassByValue);
-    let trivially_copy_pass_by_ref = trivially_copy_pass_by_ref::TriviallyCopyPassByRef::new(
+    let pass_by_ref_or_value = pass_by_ref_or_value::PassByRefOrValue::new(
         conf.trivial_copy_size_limit,
+        conf.pass_by_value_size_limit,
         &sess.target,
     );
-    store.register_late_pass(move || box trivially_copy_pass_by_ref);
+    store.register_late_pass(move || box pass_by_ref_or_value);
     store.register_late_pass(|| box try_err::TryErr);
     store.register_late_pass(|| box use_self::UseSelf);
     store.register_late_pass(|| box bytecount::ByteCount);
@@ -1237,13 +1239,14 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&needless_pass_by_value::NEEDLESS_PASS_BY_VALUE),
         LintId::of(&non_expressive_names::SIMILAR_NAMES),
         LintId::of(&option_if_let_else::OPTION_IF_LET_ELSE),
+        LintId::of(&pass_by_ref_or_value::LARGE_TYPES_PASSED_BY_VALUE),
+        LintId::of(&pass_by_ref_or_value::TRIVIALLY_COPY_PASS_BY_REF),
         LintId::of(&ranges::RANGE_MINUS_ONE),
         LintId::of(&ranges::RANGE_PLUS_ONE),
         LintId::of(&shadow::SHADOW_UNRELATED),
         LintId::of(&strings::STRING_ADD_ASSIGN),
         LintId::of(&trait_bounds::TRAIT_DUPLICATION_IN_BOUNDS),
         LintId::of(&trait_bounds::TYPE_REPETITION_IN_BOUNDS),
-        LintId::of(&trivially_copy_pass_by_ref::TRIVIALLY_COPY_PASS_BY_REF),
         LintId::of(&types::CAST_LOSSLESS),
         LintId::of(&types::CAST_POSSIBLE_TRUNCATION),
         LintId::of(&types::CAST_POSSIBLE_WRAP),
diff --git a/clippy_lints/src/pass_by_ref_or_value.rs b/clippy_lints/src/pass_by_ref_or_value.rs
new file mode 100644
index 00000000000..28816c3076d
--- /dev/null
+++ b/clippy_lints/src/pass_by_ref_or_value.rs
@@ -0,0 +1,256 @@
+use std::cmp;
+
+use crate::utils::{is_copy, is_self_ty, snippet, span_lint_and_sugg};
+use if_chain::if_chain;
+use rustc_ast::attr;
+use rustc_errors::Applicability;
+use rustc_hir as hir;
+use rustc_hir::intravisit::FnKind;
+use rustc_hir::{BindingAnnotation, Body, FnDecl, HirId, ItemKind, MutTy, Mutability, Node, PatKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty;
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::Span;
+use rustc_target::abi::LayoutOf;
+use rustc_target::spec::abi::Abi;
+use rustc_target::spec::Target;
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for functions taking arguments by reference, where
+    /// the argument type is `Copy` and small enough to be more efficient to always
+    /// pass by value.
+    ///
+    /// **Why is this bad?** In many calling conventions instances of structs will
+    /// be passed through registers if they fit into two or less general purpose
+    /// registers.
+    ///
+    /// **Known problems:** This lint is target register size dependent, it is
+    /// limited to 32-bit to try and reduce portability problems between 32 and
+    /// 64-bit, but if you are compiling for 8 or 16-bit targets then the limit
+    /// will be different.
+    ///
+    /// The configuration option `trivial_copy_size_limit` can be set to override
+    /// this limit for a project.
+    ///
+    /// This lint attempts to allow passing arguments by reference if a reference
+    /// to that argument is returned. This is implemented by comparing the lifetime
+    /// of the argument and return value for equality. However, this can cause
+    /// false positives in cases involving multiple lifetimes that are bounded by
+    /// each other.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// // Bad
+    /// fn foo(v: &u32) {}
+    /// ```
+    ///
+    /// ```rust
+    /// // Better
+    /// fn foo(v: u32) {}
+    /// ```
+    pub TRIVIALLY_COPY_PASS_BY_REF,
+    pedantic,
+    "functions taking small copyable arguments by reference"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for functions taking arguments by value, where
+    /// the argument type is `Copy` and large enough to be worth considering
+    /// passing by reference. Does not trigger if the function is being exported,
+    /// because that might induce API breakage, if the parameter is declared as mutable,
+    /// or if the argument is a `self`.
+    ///
+    /// **Why is this bad?** Arguments passed by value might result in an unnecessary
+    /// shallow copy, taking up more space in the stack and requiring a call to
+    /// `memcpy`, which which can be expensive.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// #[derive(Clone, Copy)]
+    /// struct TooLarge([u8; 2048]);
+    ///
+    /// // Bad
+    /// fn foo(v: TooLarge) {}
+    /// ```
+    /// ```rust
+    /// #[derive(Clone, Copy)]
+    /// struct TooLarge([u8; 2048]);
+    ///
+    /// // Good
+    /// fn foo(v: &TooLarge) {}
+    /// ```
+    pub LARGE_TYPES_PASSED_BY_VALUE,
+    pedantic,
+    "functions taking large arguments by value"
+}
+
+#[derive(Copy, Clone)]
+pub struct PassByRefOrValue {
+    ref_min_size: u64,
+    value_max_size: u64,
+}
+
+impl<'tcx> PassByRefOrValue {
+    pub fn new(ref_min_size: Option<u64>, value_max_size: u64, target: &Target) -> Self {
+        let ref_min_size = ref_min_size.unwrap_or_else(|| {
+            let bit_width = u64::from(target.pointer_width);
+            // Cap the calculated bit width at 32-bits to reduce
+            // portability problems between 32 and 64-bit targets
+            let bit_width = cmp::min(bit_width, 32);
+            #[allow(clippy::integer_division)]
+            let byte_width = bit_width / 8;
+            // Use a limit of 2 times the register byte width
+            byte_width * 2
+        });
+
+        Self {
+            ref_min_size,
+            value_max_size,
+        }
+    }
+
+    fn check_poly_fn(&mut self, cx: &LateContext<'tcx>, hir_id: HirId, decl: &FnDecl<'_>, span: Option<Span>) {
+        let fn_def_id = cx.tcx.hir().local_def_id(hir_id);
+
+        let fn_sig = cx.tcx.fn_sig(fn_def_id);
+        let fn_sig = cx.tcx.erase_late_bound_regions(&fn_sig);
+
+        let fn_body = cx.enclosing_body.map(|id| cx.tcx.hir().body(id));
+
+        for (index, (input, &ty)) in decl.inputs.iter().zip(fn_sig.inputs()).enumerate() {
+            // All spans generated from a proc-macro invocation are the same...
+            match span {
+                Some(s) if s == input.span => return,
+                _ => (),
+            }
+
+            match ty.kind() {
+                ty::Ref(input_lt, ty, Mutability::Not) => {
+                    // Use lifetimes to determine if we're returning a reference to the
+                    // argument. In that case we can't switch to pass-by-value as the
+                    // argument will not live long enough.
+                    let output_lts = match *fn_sig.output().kind() {
+                        ty::Ref(output_lt, _, _) => vec![output_lt],
+                        ty::Adt(_, substs) => substs.regions().collect(),
+                        _ => vec![],
+                    };
+
+                    if_chain! {
+                        if !output_lts.contains(&input_lt);
+                        if is_copy(cx, ty);
+                        if let Some(size) = cx.layout_of(ty).ok().map(|l| l.size.bytes());
+                        if size <= self.ref_min_size;
+                        if let hir::TyKind::Rptr(_, MutTy { ty: ref decl_ty, .. }) = input.kind;
+                        then {
+                            let value_type = if is_self_ty(decl_ty) {
+                                "self".into()
+                            } else {
+                                snippet(cx, decl_ty.span, "_").into()
+                            };
+                            span_lint_and_sugg(
+                                cx,
+                                TRIVIALLY_COPY_PASS_BY_REF,
+                                input.span,
+                                &format!("this argument ({} byte) is passed by reference, but would be more efficient if passed by value (limit: {} byte)", size, self.ref_min_size),
+                                "consider passing by value instead",
+                                value_type,
+                                Applicability::Unspecified,
+                            );
+                        }
+                    }
+                },
+
+                ty::Adt(_, _) | ty::Array(_, _) | ty::Tuple(_) => {
+                    // if function has a body and parameter is annotated with mut, ignore
+                    if let Some(param) = fn_body.and_then(|body| body.params.get(index)) {
+                        match param.pat.kind {
+                            PatKind::Binding(BindingAnnotation::Unannotated, _, _, _) => {},
+                            _ => continue,
+                        }
+                    }
+
+                    if_chain! {
+                        if !cx.access_levels.is_exported(hir_id);
+                        if is_copy(cx, ty);
+                        if !is_self_ty(input);
+                        if let Some(size) = cx.layout_of(ty).ok().map(|l| l.size.bytes());
+                        if size > self.value_max_size;
+                        then {
+                            span_lint_and_sugg(
+                                cx,
+                                LARGE_TYPES_PASSED_BY_VALUE,
+                                input.span,
+                                &format!("this argument ({} byte) is passed by value, but might be more efficient if passed by reference (limit: {} byte)", size, self.value_max_size),
+                                "consider passing by reference instead",
+                                format!("&{}", snippet(cx, input.span, "_")),
+                                Applicability::MaybeIncorrect,
+                            );
+                        }
+                    }
+                },
+
+                _ => {},
+            }
+        }
+    }
+}
+
+impl_lint_pass!(PassByRefOrValue => [TRIVIALLY_COPY_PASS_BY_REF, LARGE_TYPES_PASSED_BY_VALUE]);
+
+impl<'tcx> LateLintPass<'tcx> for PassByRefOrValue {
+    fn check_trait_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::TraitItem<'_>) {
+        if item.span.from_expansion() {
+            return;
+        }
+
+        if let hir::TraitItemKind::Fn(method_sig, _) = &item.kind {
+            self.check_poly_fn(cx, item.hir_id, &*method_sig.decl, None);
+        }
+    }
+
+    fn check_fn(
+        &mut self,
+        cx: &LateContext<'tcx>,
+        kind: FnKind<'tcx>,
+        decl: &'tcx FnDecl<'_>,
+        _body: &'tcx Body<'_>,
+        span: Span,
+        hir_id: HirId,
+    ) {
+        if span.from_expansion() {
+            return;
+        }
+
+        match kind {
+            FnKind::ItemFn(.., header, _, attrs) => {
+                if header.abi != Abi::Rust {
+                    return;
+                }
+                for a in attrs {
+                    if let Some(meta_items) = a.meta_item_list() {
+                        if a.has_name(sym!(proc_macro_derive))
+                            || (a.has_name(sym!(inline)) && attr::list_contains_name(&meta_items, sym!(always)))
+                        {
+                            return;
+                        }
+                    }
+                }
+            },
+            FnKind::Method(..) => (),
+            FnKind::Closure(..) => return,
+        }
+
+        // Exclude non-inherent impls
+        if let Some(Node::Item(item)) = cx.tcx.hir().find(cx.tcx.hir().get_parent_node(hir_id)) {
+            if matches!(item.kind, ItemKind::Impl{ of_trait: Some(_), .. } |
+            ItemKind::Trait(..))
+            {
+                return;
+            }
+        }
+
+        self.check_poly_fn(cx, hir_id, decl, Some(span));
+    }
+}
diff --git a/clippy_lints/src/trivially_copy_pass_by_ref.rs b/clippy_lints/src/trivially_copy_pass_by_ref.rs
deleted file mode 100644
index e90ea0fc200..00000000000
--- a/clippy_lints/src/trivially_copy_pass_by_ref.rs
+++ /dev/null
@@ -1,183 +0,0 @@
-use std::cmp;
-
-use crate::utils::{is_copy, is_self_ty, snippet, span_lint_and_sugg};
-use if_chain::if_chain;
-use rustc_ast::attr;
-use rustc_errors::Applicability;
-use rustc_hir as hir;
-use rustc_hir::intravisit::FnKind;
-use rustc_hir::{Body, FnDecl, HirId, ItemKind, MutTy, Mutability, Node};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty;
-use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::Span;
-use rustc_target::abi::LayoutOf;
-use rustc_target::spec::abi::Abi;
-use rustc_target::spec::Target;
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for functions taking arguments by reference, where
-    /// the argument type is `Copy` and small enough to be more efficient to always
-    /// pass by value.
-    ///
-    /// **Why is this bad?** In many calling conventions instances of structs will
-    /// be passed through registers if they fit into two or less general purpose
-    /// registers.
-    ///
-    /// **Known problems:** This lint is target register size dependent, it is
-    /// limited to 32-bit to try and reduce portability problems between 32 and
-    /// 64-bit, but if you are compiling for 8 or 16-bit targets then the limit
-    /// will be different.
-    ///
-    /// The configuration option `trivial_copy_size_limit` can be set to override
-    /// this limit for a project.
-    ///
-    /// This lint attempts to allow passing arguments by reference if a reference
-    /// to that argument is returned. This is implemented by comparing the lifetime
-    /// of the argument and return value for equality. However, this can cause
-    /// false positives in cases involving multiple lifetimes that are bounded by
-    /// each other.
-    ///
-    /// **Example:**
-    ///
-    /// ```rust
-    /// // Bad
-    /// fn foo(v: &u32) {}
-    /// ```
-    ///
-    /// ```rust
-    /// // Better
-    /// fn foo(v: u32) {}
-    /// ```
-    pub TRIVIALLY_COPY_PASS_BY_REF,
-    pedantic,
-    "functions taking small copyable arguments by reference"
-}
-
-#[derive(Copy, Clone)]
-pub struct TriviallyCopyPassByRef {
-    limit: u64,
-}
-
-impl<'tcx> TriviallyCopyPassByRef {
-    pub fn new(limit: Option<u64>, target: &Target) -> Self {
-        let limit = limit.unwrap_or_else(|| {
-            let bit_width = u64::from(target.pointer_width);
-            // Cap the calculated bit width at 32-bits to reduce
-            // portability problems between 32 and 64-bit targets
-            let bit_width = cmp::min(bit_width, 32);
-            #[allow(clippy::integer_division)]
-            let byte_width = bit_width / 8;
-            // Use a limit of 2 times the register byte width
-            byte_width * 2
-        });
-        Self { limit }
-    }
-
-    fn check_poly_fn(&mut self, cx: &LateContext<'tcx>, hir_id: HirId, decl: &FnDecl<'_>, span: Option<Span>) {
-        let fn_def_id = cx.tcx.hir().local_def_id(hir_id);
-
-        let fn_sig = cx.tcx.fn_sig(fn_def_id);
-        let fn_sig = cx.tcx.erase_late_bound_regions(&fn_sig);
-
-        // Use lifetimes to determine if we're returning a reference to the
-        // argument. In that case we can't switch to pass-by-value as the
-        // argument will not live long enough.
-        let output_lts = match *fn_sig.output().kind() {
-            ty::Ref(output_lt, _, _) => vec![output_lt],
-            ty::Adt(_, substs) => substs.regions().collect(),
-            _ => vec![],
-        };
-
-        for (input, &ty) in decl.inputs.iter().zip(fn_sig.inputs()) {
-            // All spans generated from a proc-macro invocation are the same...
-            match span {
-                Some(s) if s == input.span => return,
-                _ => (),
-            }
-
-            if_chain! {
-                if let ty::Ref(input_lt, ty, Mutability::Not) = ty.kind();
-                if !output_lts.contains(&input_lt);
-                if is_copy(cx, ty);
-                if let Some(size) = cx.layout_of(ty).ok().map(|l| l.size.bytes());
-                if size <= self.limit;
-                if let hir::TyKind::Rptr(_, MutTy { ty: ref decl_ty, .. }) = input.kind;
-                then {
-                    let value_type = if is_self_ty(decl_ty) {
-                        "self".into()
-                    } else {
-                        snippet(cx, decl_ty.span, "_").into()
-                    };
-                    span_lint_and_sugg(
-                        cx,
-                        TRIVIALLY_COPY_PASS_BY_REF,
-                        input.span,
-                        &format!("this argument ({} byte) is passed by reference, but would be more efficient if passed by value (limit: {} byte)", size, self.limit),
-                        "consider passing by value instead",
-                        value_type,
-                        Applicability::Unspecified,
-                    );
-                }
-            }
-        }
-    }
-}
-
-impl_lint_pass!(TriviallyCopyPassByRef => [TRIVIALLY_COPY_PASS_BY_REF]);
-
-impl<'tcx> LateLintPass<'tcx> for TriviallyCopyPassByRef {
-    fn check_trait_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::TraitItem<'_>) {
-        if item.span.from_expansion() {
-            return;
-        }
-
-        if let hir::TraitItemKind::Fn(method_sig, _) = &item.kind {
-            self.check_poly_fn(cx, item.hir_id, &*method_sig.decl, None);
-        }
-    }
-
-    fn check_fn(
-        &mut self,
-        cx: &LateContext<'tcx>,
-        kind: FnKind<'tcx>,
-        decl: &'tcx FnDecl<'_>,
-        _body: &'tcx Body<'_>,
-        span: Span,
-        hir_id: HirId,
-    ) {
-        if span.from_expansion() {
-            return;
-        }
-
-        match kind {
-            FnKind::ItemFn(.., header, _, attrs) => {
-                if header.abi != Abi::Rust {
-                    return;
-                }
-                for a in attrs {
-                    if let Some(meta_items) = a.meta_item_list() {
-                        if a.has_name(sym!(proc_macro_derive))
-                            || (a.has_name(sym!(inline)) && attr::list_contains_name(&meta_items, sym!(always)))
-                        {
-                            return;
-                        }
-                    }
-                }
-            },
-            FnKind::Method(..) => (),
-            FnKind::Closure(..) => return,
-        }
-
-        // Exclude non-inherent impls
-        if let Some(Node::Item(item)) = cx.tcx.hir().find(cx.tcx.hir().get_parent_node(hir_id)) {
-            if matches!(item.kind, ItemKind::Impl{ of_trait: Some(_), .. } |
-                ItemKind::Trait(..))
-            {
-                return;
-            }
-        }
-
-        self.check_poly_fn(cx, hir_id, decl, Some(span));
-    }
-}
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index dd2fd0bb445..0ac8fff69f0 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -150,6 +150,8 @@ define_Conf! {
     (literal_representation_threshold, "literal_representation_threshold": u64, 16384),
     /// Lint: TRIVIALLY_COPY_PASS_BY_REF. The maximum size (in bytes) to consider a `Copy` type for passing by value instead of by reference.
     (trivial_copy_size_limit, "trivial_copy_size_limit": Option<u64>, None),
+    /// Lint: LARGE_TYPE_PASS_BY_MOVE. The minimum size (in bytes) to consider a type for passing by reference instead of by value.
+    (pass_by_value_size_limit, "pass_by_value_size_limit": u64, 256),
     /// Lint: TOO_MANY_LINES. The maximum number of lines a function or method can have
     (too_many_lines_threshold, "too_many_lines_threshold": u64, 100),
     /// Lint: LARGE_STACK_ARRAYS, LARGE_CONST_ARRAYS. The maximum allowed size for arrays on the stack
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index 6301d623a2b..f3536f26339 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -1061,6 +1061,13 @@ vec![
         deprecation: None,
         module: "large_stack_arrays",
     },
+    Lint {
+        name: "large_types_passed_by_value",
+        group: "pedantic",
+        desc: "functions taking large arguments by value",
+        deprecation: None,
+        module: "pass_by_ref_or_value",
+    },
     Lint {
         name: "len_without_is_empty",
         group: "style",
@@ -2389,7 +2396,7 @@ vec![
         group: "pedantic",
         desc: "functions taking small copyable arguments by reference",
         deprecation: None,
-        module: "trivially_copy_pass_by_ref",
+        module: "pass_by_ref_or_value",
     },
     Lint {
         name: "try_err",
diff --git a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
index 103ec27e7d7..a58e7e918e2 100644
--- a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
+++ b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
@@ -1,4 +1,4 @@
-error: error reading Clippy's configuration file `$DIR/clippy.toml`: unknown field `foobar`, expected one of `blacklisted-names`, `cognitive-complexity-threshold`, `cyclomatic-complexity-threshold`, `doc-valid-idents`, `too-many-arguments-threshold`, `type-complexity-threshold`, `single-char-binding-names-threshold`, `too-large-for-stack`, `enum-variant-name-threshold`, `enum-variant-size-threshold`, `verbose-bit-mask-threshold`, `literal-representation-threshold`, `trivial-copy-size-limit`, `too-many-lines-threshold`, `array-size-threshold`, `vec-box-size-threshold`, `max-trait-bounds`, `max-struct-bools`, `max-fn-params-bools`, `warn-on-all-wildcard-imports`, `disallowed-methods`, `third-party` at line 5 column 1
+error: error reading Clippy's configuration file `$DIR/clippy.toml`: unknown field `foobar`, expected one of `blacklisted-names`, `cognitive-complexity-threshold`, `cyclomatic-complexity-threshold`, `doc-valid-idents`, `too-many-arguments-threshold`, `type-complexity-threshold`, `single-char-binding-names-threshold`, `too-large-for-stack`, `enum-variant-name-threshold`, `enum-variant-size-threshold`, `verbose-bit-mask-threshold`, `literal-representation-threshold`, `trivial-copy-size-limit`, `pass-by-value-size-limit`, `too-many-lines-threshold`, `array-size-threshold`, `vec-box-size-threshold`, `max-trait-bounds`, `max-struct-bools`, `max-fn-params-bools`, `warn-on-all-wildcard-imports`, `disallowed-methods`, `third-party` at line 5 column 1
 
 error: aborting due to previous error
 
diff --git a/tests/ui/large_types_passed_by_value.rs b/tests/ui/large_types_passed_by_value.rs
new file mode 100644
index 00000000000..e4a2e9df4d7
--- /dev/null
+++ b/tests/ui/large_types_passed_by_value.rs
@@ -0,0 +1,66 @@
+// normalize-stderr-test "\(\d+ byte\)" -> "(N byte)"
+// normalize-stderr-test "\(limit: \d+ byte\)" -> "(limit: N byte)"
+
+#![warn(clippy::large_types_passed_by_value)]
+
+pub struct Large([u8; 2048]);
+
+#[derive(Clone, Copy)]
+pub struct LargeAndCopy([u8; 2048]);
+
+pub struct Small([u8; 4]);
+
+#[derive(Clone, Copy)]
+pub struct SmallAndCopy([u8; 4]);
+
+fn small(a: Small, b: SmallAndCopy) {}
+fn not_copy(a: Large) {}
+fn by_ref(a: &Large, b: &LargeAndCopy) {}
+fn mutable(mut a: LargeAndCopy) {}
+fn bad(a: LargeAndCopy) {}
+pub fn bad_but_pub(a: LargeAndCopy) {}
+
+impl LargeAndCopy {
+    fn self_is_ok(self) {}
+    fn other_is_not_ok(self, other: LargeAndCopy) {}
+    fn unless_other_can_change(self, mut other: LargeAndCopy) {}
+    pub fn or_were_in_public(self, other: LargeAndCopy) {}
+}
+
+trait LargeTypeDevourer {
+    fn devoure_array(&self, array: [u8; 6666]);
+    fn devoure_tuple(&self, tup: (LargeAndCopy, LargeAndCopy));
+    fn devoure_array_and_tuple_wow(&self, array: [u8; 6666], tup: (LargeAndCopy, LargeAndCopy));
+}
+
+pub trait PubLargeTypeDevourer {
+    fn devoure_array_in_public(&self, array: [u8; 6666]);
+}
+
+struct S {}
+impl LargeTypeDevourer for S {
+    fn devoure_array(&self, array: [u8; 6666]) {
+        todo!();
+    }
+    fn devoure_tuple(&self, tup: (LargeAndCopy, LargeAndCopy)) {
+        todo!();
+    }
+    fn devoure_array_and_tuple_wow(&self, array: [u8; 6666], tup: (LargeAndCopy, LargeAndCopy)) {
+        todo!();
+    }
+}
+
+#[inline(always)]
+fn foo_always(x: LargeAndCopy) {
+    todo!();
+}
+#[inline(never)]
+fn foo_never(x: LargeAndCopy) {
+    todo!();
+}
+#[inline]
+fn foo(x: LargeAndCopy) {
+    todo!();
+}
+
+fn main() {}
diff --git a/tests/ui/large_types_passed_by_value.stderr b/tests/ui/large_types_passed_by_value.stderr
new file mode 100644
index 00000000000..5f42dcfb9b5
--- /dev/null
+++ b/tests/ui/large_types_passed_by_value.stderr
@@ -0,0 +1,52 @@
+error: this argument (N byte) is passed by value, but might be more efficient if passed by reference (limit: N byte)
+  --> $DIR/large_types_passed_by_value.rs:20:11
+   |
+LL | fn bad(a: LargeAndCopy) {}
+   |           ^^^^^^^^^^^^ help: consider passing by reference instead: `&LargeAndCopy`
+   |
+   = note: `-D clippy::large-types-passed-by-value` implied by `-D warnings`
+
+error: this argument (N byte) is passed by value, but might be more efficient if passed by reference (limit: N byte)
+  --> $DIR/large_types_passed_by_value.rs:25:37
+   |
+LL |     fn other_is_not_ok(self, other: LargeAndCopy) {}
+   |                                     ^^^^^^^^^^^^ help: consider passing by reference instead: `&LargeAndCopy`
+
+error: this argument (N byte) is passed by value, but might be more efficient if passed by reference (limit: N byte)
+  --> $DIR/large_types_passed_by_value.rs:31:36
+   |
+LL |     fn devoure_array(&self, array: [u8; 6666]);
+   |                                    ^^^^^^^^^^ help: consider passing by reference instead: `&[u8; 6666]`
+
+error: this argument (N byte) is passed by value, but might be more efficient if passed by reference (limit: N byte)
+  --> $DIR/large_types_passed_by_value.rs:32:34
+   |
+LL |     fn devoure_tuple(&self, tup: (LargeAndCopy, LargeAndCopy));
+   |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider passing by reference instead: `&(LargeAndCopy, LargeAndCopy)`
+
+error: this argument (N byte) is passed by value, but might be more efficient if passed by reference (limit: N byte)
+  --> $DIR/large_types_passed_by_value.rs:33:50
+   |
+LL |     fn devoure_array_and_tuple_wow(&self, array: [u8; 6666], tup: (LargeAndCopy, LargeAndCopy));
+   |                                                  ^^^^^^^^^^ help: consider passing by reference instead: `&[u8; 6666]`
+
+error: this argument (N byte) is passed by value, but might be more efficient if passed by reference (limit: N byte)
+  --> $DIR/large_types_passed_by_value.rs:33:67
+   |
+LL |     fn devoure_array_and_tuple_wow(&self, array: [u8; 6666], tup: (LargeAndCopy, LargeAndCopy));
+   |                                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider passing by reference instead: `&(LargeAndCopy, LargeAndCopy)`
+
+error: this argument (N byte) is passed by value, but might be more efficient if passed by reference (limit: N byte)
+  --> $DIR/large_types_passed_by_value.rs:58:17
+   |
+LL | fn foo_never(x: LargeAndCopy) {
+   |                 ^^^^^^^^^^^^ help: consider passing by reference instead: `&LargeAndCopy`
+
+error: this argument (N byte) is passed by value, but might be more efficient if passed by reference (limit: N byte)
+  --> $DIR/large_types_passed_by_value.rs:62:11
+   |
+LL | fn foo(x: LargeAndCopy) {
+   |           ^^^^^^^^^^^^ help: consider passing by reference instead: `&LargeAndCopy`
+
+error: aborting due to 8 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From f82f9c2c55392ef9d7649bf2e485f7e509fd0038 Mon Sep 17 00:00:00 2001
From: Francis Murillo <francis.murillo@protonmail.com>
Date: Fri, 2 Oct 2020 09:05:30 +0800
Subject: Add lint for `&mut Mutex::lock`

---
 CHANGELOG.md                       |  1 +
 clippy_lints/src/lib.rs            |  7 ++++
 clippy_lints/src/mut_mutex_lock.rs | 75 ++++++++++++++++++++++++++++++++++++++
 src/lintlist/mod.rs                |  7 ++++
 tests/ui/mut_mutex_lock.rs         | 19 ++++++++++
 tests/ui/mut_mutex_lock.stderr     | 19 ++++++++++
 6 files changed, 128 insertions(+)
 create mode 100644 clippy_lints/src/mut_mutex_lock.rs
 create mode 100644 tests/ui/mut_mutex_lock.rs
 create mode 100644 tests/ui/mut_mutex_lock.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 1d995cc9701..ba080835f5c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1843,6 +1843,7 @@ Released 2018-09-13
 [`must_use_unit`]: https://rust-lang.github.io/rust-clippy/master/index.html#must_use_unit
 [`mut_from_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#mut_from_ref
 [`mut_mut`]: https://rust-lang.github.io/rust-clippy/master/index.html#mut_mut
+[`mut_mutex_lock`]: https://rust-lang.github.io/rust-clippy/master/index.html#mut_mutex_lock
 [`mut_range_bound`]: https://rust-lang.github.io/rust-clippy/master/index.html#mut_range_bound
 [`mutable_key_type`]: https://rust-lang.github.io/rust-clippy/master/index.html#mutable_key_type
 [`mutex_atomic`]: https://rust-lang.github.io/rust-clippy/master/index.html#mutex_atomic
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 8d53b9799f0..3a108bcfe6a 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -255,6 +255,7 @@ mod modulo_arithmetic;
 mod multiple_crate_versions;
 mod mut_key;
 mod mut_mut;
+mod mut_mutex_lock;
 mod mut_reference;
 mod mutable_debug_assertion;
 mod mutex_atomic;
@@ -744,6 +745,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &multiple_crate_versions::MULTIPLE_CRATE_VERSIONS,
         &mut_key::MUTABLE_KEY_TYPE,
         &mut_mut::MUT_MUT,
+        &mut_mutex_lock::MUT_MUTEX_LOCK,
         &mut_reference::UNNECESSARY_MUT_PASSED,
         &mutable_debug_assertion::DEBUG_ASSERT_WITH_MUT_CALL,
         &mutex_atomic::MUTEX_ATOMIC,
@@ -1112,6 +1114,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box future_not_send::FutureNotSend);
     store.register_late_pass(|| box utils::internal_lints::CollapsibleCalls);
     store.register_late_pass(|| box if_let_mutex::IfLetMutex);
+    store.register_late_pass(|| box mut_mutex_lock::MutMutexLock);
     store.register_late_pass(|| box match_on_vec_items::MatchOnVecItems);
     store.register_early_pass(|| box manual_non_exhaustive::ManualNonExhaustive);
     store.register_late_pass(|| box manual_async_fn::ManualAsyncFn);
@@ -1446,6 +1449,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&misc_early::UNNEEDED_WILDCARD_PATTERN),
         LintId::of(&misc_early::ZERO_PREFIXED_LITERAL),
         LintId::of(&mut_key::MUTABLE_KEY_TYPE),
+        LintId::of(&mut_mutex_lock::MUT_MUTEX_LOCK),
         LintId::of(&mut_reference::UNNECESSARY_MUT_PASSED),
         LintId::of(&mutex_atomic::MUTEX_ATOMIC),
         LintId::of(&needless_arbitrary_self_type::NEEDLESS_ARBITRARY_SELF_TYPE),
@@ -1780,6 +1784,9 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&misc::FLOAT_CMP),
         LintId::of(&misc::MODULO_ONE),
         LintId::of(&mut_key::MUTABLE_KEY_TYPE),
+        LintId::of(&mut_mutex_lock::MUT_MUTEX_LOCK),
+        LintId::of(&non_copy_const::BORROW_INTERIOR_MUTABLE_CONST),
+        LintId::of(&non_copy_const::DECLARE_INTERIOR_MUTABLE_CONST),
         LintId::of(&open_options::NONSENSICAL_OPEN_OPTIONS),
         LintId::of(&option_env_unwrap::OPTION_ENV_UNWRAP),
         LintId::of(&ptr::MUT_FROM_REF),
diff --git a/clippy_lints/src/mut_mutex_lock.rs b/clippy_lints/src/mut_mutex_lock.rs
new file mode 100644
index 00000000000..4f3108355ca
--- /dev/null
+++ b/clippy_lints/src/mut_mutex_lock.rs
@@ -0,0 +1,75 @@
+use crate::utils::{is_type_diagnostic_item, span_lint_and_help};
+use if_chain::if_chain;
+use rustc_hir::{Expr, ExprKind, Mutability};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for `&mut Mutex::lock` calls
+    ///
+    /// **Why is this bad?** `Mutex::lock` is less efficient than
+    /// calling `Mutex::get_mut`
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// use std::sync::{Arc, Mutex};
+    ///
+    /// let mut value_rc = Arc::new(Mutex::new(42_u8));
+    /// let value_mutex = Arc::get_mut(&mut value_rc).unwrap();
+    ///
+    /// let value = value_mutex.lock().unwrap();
+    /// do_stuff(value);
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// use std::sync::{Arc, Mutex};
+    ///
+    /// let mut value_rc = Arc::new(Mutex::new(42_u8));
+    /// let value_mutex = Arc::get_mut(&mut value_rc).unwrap();
+    ///
+    /// let value = value_mutex.get_mut().unwrap();
+    /// do_stuff(value);
+    /// ```
+    pub MUT_MUTEX_LOCK,
+    correctness,
+    "`&mut Mutex::lock` does unnecessary locking"
+}
+
+declare_lint_pass!(MutMutexLock => [MUT_MUTEX_LOCK]);
+
+impl<'tcx> LateLintPass<'tcx> for MutMutexLock {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, ex: &'tcx Expr<'tcx>) {
+        if_chain! {
+            if is_mut_mutex_lock_call(cx, ex).is_some();
+            then {
+                span_lint_and_help(
+                    cx,
+                    MUT_MUTEX_LOCK,
+                    ex.span,
+                    "calling `&mut Mutex::lock` unnecessarily locks an exclusive (mutable) reference",
+                    None,
+                    "use `&mut Mutex::get_mut` instead",
+                );
+            }
+        }
+    }
+}
+
+fn is_mut_mutex_lock_call<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<&'tcx Expr<'tcx>> {
+    if_chain! {
+        if let ExprKind::MethodCall(path, _span, args, _) = &expr.kind;
+        if path.ident.name == sym!(lock);
+        let ty = cx.typeck_results().expr_ty(&args[0]);
+        if let ty::Ref(_, inner_ty, Mutability::Mut) = ty.kind();
+        if is_type_diagnostic_item(cx, inner_ty, sym!(mutex_type));
+        then {
+            Some(&args[0])
+        } else {
+            None
+        }
+    }
+}
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index 98ad994ea7b..5e48757a4c5 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -1502,6 +1502,13 @@ vec![
         deprecation: None,
         module: "mut_mut",
     },
+    Lint {
+        name: "mut_mutex_lock",
+        group: "correctness",
+        desc: "`&mut Mutex::lock` does unnecessary locking",
+        deprecation: None,
+        module: "mut_mutex_lock",
+    },
     Lint {
         name: "mut_range_bound",
         group: "complexity",
diff --git a/tests/ui/mut_mutex_lock.rs b/tests/ui/mut_mutex_lock.rs
new file mode 100644
index 00000000000..516d44bb7a9
--- /dev/null
+++ b/tests/ui/mut_mutex_lock.rs
@@ -0,0 +1,19 @@
+#![warn(clippy::mut_mutex_lock)]
+
+use std::sync::{Arc, Mutex};
+
+fn mut_mutex_lock() {
+    let mut value_rc = Arc::new(Mutex::new(42_u8));
+    let value_mutex = Arc::get_mut(&mut value_rc).unwrap();
+
+    let value = value_mutex.lock().unwrap();
+    *value += 1;
+}
+
+fn no_owned_mutex_lock() {
+    let mut value_rc = Arc::new(Mutex::new(42_u8));
+    let value = value_rc.lock().unwrap();
+    *value += 1;
+}
+
+fn main() {}
diff --git a/tests/ui/mut_mutex_lock.stderr b/tests/ui/mut_mutex_lock.stderr
new file mode 100644
index 00000000000..426e0240830
--- /dev/null
+++ b/tests/ui/mut_mutex_lock.stderr
@@ -0,0 +1,19 @@
+error[E0596]: cannot borrow `value` as mutable, as it is not declared as mutable
+  --> $DIR/mut_mutex_lock.rs:10:6
+   |
+LL |     let value = value_mutex.lock().unwrap();
+   |         ----- help: consider changing this to be mutable: `mut value`
+LL |     *value += 1;
+   |      ^^^^^ cannot borrow as mutable
+
+error[E0596]: cannot borrow `value` as mutable, as it is not declared as mutable
+  --> $DIR/mut_mutex_lock.rs:16:6
+   |
+LL |     let value = value_rc.lock().unwrap();
+   |         ----- help: consider changing this to be mutable: `mut value`
+LL |     *value += 1;
+   |      ^^^^^ cannot borrow as mutable
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0596`.
-- 
cgit 1.4.1-3-g733a5


From fb8a9cb38d73f3876b57f250502895c7cc60d421 Mon Sep 17 00:00:00 2001
From: Francis Murillo <francis.murillo@protonmail.com>
Date: Fri, 2 Oct 2020 10:54:44 +0800
Subject: Change lint doc test

---
 clippy_lints/src/mut_mutex_lock.rs |  6 +++---
 tests/ui/mut_mutex_lock.rs         |  4 ++--
 tests/ui/mut_mutex_lock.stderr     | 22 +++++++---------------
 3 files changed, 12 insertions(+), 20 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/mut_mutex_lock.rs b/clippy_lints/src/mut_mutex_lock.rs
index 4f3108355ca..0680e578537 100644
--- a/clippy_lints/src/mut_mutex_lock.rs
+++ b/clippy_lints/src/mut_mutex_lock.rs
@@ -21,8 +21,8 @@ declare_clippy_lint! {
     /// let mut value_rc = Arc::new(Mutex::new(42_u8));
     /// let value_mutex = Arc::get_mut(&mut value_rc).unwrap();
     ///
-    /// let value = value_mutex.lock().unwrap();
-    /// do_stuff(value);
+    /// let mut value = value_mutex.lock().unwrap();
+    /// *value += 1;
     /// ```
     /// Use instead:
     /// ```rust
@@ -32,7 +32,7 @@ declare_clippy_lint! {
     /// let value_mutex = Arc::get_mut(&mut value_rc).unwrap();
     ///
     /// let value = value_mutex.get_mut().unwrap();
-    /// do_stuff(value);
+    /// *value += 1;
     /// ```
     pub MUT_MUTEX_LOCK,
     correctness,
diff --git a/tests/ui/mut_mutex_lock.rs b/tests/ui/mut_mutex_lock.rs
index 516d44bb7a9..9cd98e90c29 100644
--- a/tests/ui/mut_mutex_lock.rs
+++ b/tests/ui/mut_mutex_lock.rs
@@ -6,13 +6,13 @@ fn mut_mutex_lock() {
     let mut value_rc = Arc::new(Mutex::new(42_u8));
     let value_mutex = Arc::get_mut(&mut value_rc).unwrap();
 
-    let value = value_mutex.lock().unwrap();
+    let mut value = value_mutex.lock().unwrap();
     *value += 1;
 }
 
 fn no_owned_mutex_lock() {
     let mut value_rc = Arc::new(Mutex::new(42_u8));
-    let value = value_rc.lock().unwrap();
+    let mut value = value_rc.lock().unwrap();
     *value += 1;
 }
 
diff --git a/tests/ui/mut_mutex_lock.stderr b/tests/ui/mut_mutex_lock.stderr
index 426e0240830..d521ebb56c4 100644
--- a/tests/ui/mut_mutex_lock.stderr
+++ b/tests/ui/mut_mutex_lock.stderr
@@ -1,19 +1,11 @@
-error[E0596]: cannot borrow `value` as mutable, as it is not declared as mutable
-  --> $DIR/mut_mutex_lock.rs:10:6
+error: calling `&mut Mutex::lock` unnecessarily locks an exclusive (mutable) reference
+  --> $DIR/mut_mutex_lock.rs:9:21
    |
-LL |     let value = value_mutex.lock().unwrap();
-   |         ----- help: consider changing this to be mutable: `mut value`
-LL |     *value += 1;
-   |      ^^^^^ cannot borrow as mutable
-
-error[E0596]: cannot borrow `value` as mutable, as it is not declared as mutable
-  --> $DIR/mut_mutex_lock.rs:16:6
+LL |     let mut value = value_mutex.lock().unwrap();
+   |                     ^^^^^^^^^^^^^^^^^^
    |
-LL |     let value = value_rc.lock().unwrap();
-   |         ----- help: consider changing this to be mutable: `mut value`
-LL |     *value += 1;
-   |      ^^^^^ cannot borrow as mutable
+   = note: `-D clippy::mut-mutex-lock` implied by `-D warnings`
+   = help: use `&mut Mutex::get_mut` instead
 
-error: aborting due to 2 previous errors
+error: aborting due to previous error
 
-For more information about this error, try `rustc --explain E0596`.
-- 
cgit 1.4.1-3-g733a5


From ec0c3afa7303383ee039c252b59b56023052ae2e Mon Sep 17 00:00:00 2001
From: Francis Murillo <francis.murillo@protonmail.com>
Date: Sat, 3 Oct 2020 07:53:45 +0800
Subject: Run update_lints

---
 clippy_lints/src/lib.rs | 2 --
 1 file changed, 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 3a108bcfe6a..648c65ef7b0 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1785,8 +1785,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&misc::MODULO_ONE),
         LintId::of(&mut_key::MUTABLE_KEY_TYPE),
         LintId::of(&mut_mutex_lock::MUT_MUTEX_LOCK),
-        LintId::of(&non_copy_const::BORROW_INTERIOR_MUTABLE_CONST),
-        LintId::of(&non_copy_const::DECLARE_INTERIOR_MUTABLE_CONST),
         LintId::of(&open_options::NONSENSICAL_OPEN_OPTIONS),
         LintId::of(&option_env_unwrap::OPTION_ENV_UNWRAP),
         LintId::of(&ptr::MUT_FROM_REF),
-- 
cgit 1.4.1-3-g733a5


From 77e34a69bbbec0ef05dee9750ff3e7db4eb35d59 Mon Sep 17 00:00:00 2001
From: Francis Murillo <francis.murillo@protonmail.com>
Date: Mon, 5 Oct 2020 11:44:54 +0800
Subject: Inline is_mut_mutex_lock_call

---
 clippy_lints/src/mut_mutex_lock.rs | 21 +++++----------------
 1 file changed, 5 insertions(+), 16 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/mut_mutex_lock.rs b/clippy_lints/src/mut_mutex_lock.rs
index 0680e578537..ca3371a5d75 100644
--- a/clippy_lints/src/mut_mutex_lock.rs
+++ b/clippy_lints/src/mut_mutex_lock.rs
@@ -44,7 +44,11 @@ declare_lint_pass!(MutMutexLock => [MUT_MUTEX_LOCK]);
 impl<'tcx> LateLintPass<'tcx> for MutMutexLock {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, ex: &'tcx Expr<'tcx>) {
         if_chain! {
-            if is_mut_mutex_lock_call(cx, ex).is_some();
+            if let ExprKind::MethodCall(path, _span, args, _) = &ex.kind;
+            if path.ident.name == sym!(lock);
+            let ty = cx.typeck_results().expr_ty(&args[0]);
+            if let ty::Ref(_, inner_ty, Mutability::Mut) = ty.kind();
+            if is_type_diagnostic_item(cx, inner_ty, sym!(mutex_type));
             then {
                 span_lint_and_help(
                     cx,
@@ -58,18 +62,3 @@ impl<'tcx> LateLintPass<'tcx> for MutMutexLock {
         }
     }
 }
-
-fn is_mut_mutex_lock_call<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<&'tcx Expr<'tcx>> {
-    if_chain! {
-        if let ExprKind::MethodCall(path, _span, args, _) = &expr.kind;
-        if path.ident.name == sym!(lock);
-        let ty = cx.typeck_results().expr_ty(&args[0]);
-        if let ty::Ref(_, inner_ty, Mutability::Mut) = ty.kind();
-        if is_type_diagnostic_item(cx, inner_ty, sym!(mutex_type));
-        then {
-            Some(&args[0])
-        } else {
-            None
-        }
-    }
-}
-- 
cgit 1.4.1-3-g733a5


From 292cb9bfb6bc51595404425b0ada90f21e6d9661 Mon Sep 17 00:00:00 2001
From: Francis Murillo <francis.murillo@protonmail.com>
Date: Sat, 10 Oct 2020 18:07:47 +0800
Subject: Use `sugg_lint_and_help`

---
 clippy_lints/src/mut_mutex_lock.rs | 18 +++++++++++-------
 tests/ui/mut_mutex_lock.fixed      | 21 +++++++++++++++++++++
 tests/ui/mut_mutex_lock.rs         |  2 ++
 tests/ui/mut_mutex_lock.stderr     |  5 ++---
 4 files changed, 36 insertions(+), 10 deletions(-)
 create mode 100644 tests/ui/mut_mutex_lock.fixed

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/mut_mutex_lock.rs b/clippy_lints/src/mut_mutex_lock.rs
index ca3371a5d75..82ed2d6d69c 100644
--- a/clippy_lints/src/mut_mutex_lock.rs
+++ b/clippy_lints/src/mut_mutex_lock.rs
@@ -1,5 +1,6 @@
-use crate::utils::{is_type_diagnostic_item, span_lint_and_help};
+use crate::utils::{is_type_diagnostic_item, span_lint_and_sugg};
 use if_chain::if_chain;
+use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, Mutability};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
@@ -9,7 +10,9 @@ declare_clippy_lint! {
     /// **What it does:** Checks for `&mut Mutex::lock` calls
     ///
     /// **Why is this bad?** `Mutex::lock` is less efficient than
-    /// calling `Mutex::get_mut`
+    /// calling `Mutex::get_mut`. In addition you also have a statically
+    /// guarantee that the mutex isn't locked, instead of just a runtime
+    /// guarantee.
     ///
     /// **Known problems:** None.
     ///
@@ -44,19 +47,20 @@ declare_lint_pass!(MutMutexLock => [MUT_MUTEX_LOCK]);
 impl<'tcx> LateLintPass<'tcx> for MutMutexLock {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, ex: &'tcx Expr<'tcx>) {
         if_chain! {
-            if let ExprKind::MethodCall(path, _span, args, _) = &ex.kind;
+            if let ExprKind::MethodCall(path, method_span, args, _) = &ex.kind;
             if path.ident.name == sym!(lock);
             let ty = cx.typeck_results().expr_ty(&args[0]);
             if let ty::Ref(_, inner_ty, Mutability::Mut) = ty.kind();
             if is_type_diagnostic_item(cx, inner_ty, sym!(mutex_type));
             then {
-                span_lint_and_help(
+                span_lint_and_sugg(
                     cx,
                     MUT_MUTEX_LOCK,
-                    ex.span,
+                    *method_span,
                     "calling `&mut Mutex::lock` unnecessarily locks an exclusive (mutable) reference",
-                    None,
-                    "use `&mut Mutex::get_mut` instead",
+                    "change this to",
+                    "get_mut".to_owned(),
+                    Applicability::MachineApplicable,
                 );
             }
         }
diff --git a/tests/ui/mut_mutex_lock.fixed b/tests/ui/mut_mutex_lock.fixed
new file mode 100644
index 00000000000..36bc52e3374
--- /dev/null
+++ b/tests/ui/mut_mutex_lock.fixed
@@ -0,0 +1,21 @@
+// run-rustfix
+#![allow(dead_code, unused_mut)]
+#![warn(clippy::mut_mutex_lock)]
+
+use std::sync::{Arc, Mutex};
+
+fn mut_mutex_lock() {
+    let mut value_rc = Arc::new(Mutex::new(42_u8));
+    let value_mutex = Arc::get_mut(&mut value_rc).unwrap();
+
+    let mut value = value_mutex.get_mut().unwrap();
+    *value += 1;
+}
+
+fn no_owned_mutex_lock() {
+    let mut value_rc = Arc::new(Mutex::new(42_u8));
+    let mut value = value_rc.lock().unwrap();
+    *value += 1;
+}
+
+fn main() {}
diff --git a/tests/ui/mut_mutex_lock.rs b/tests/ui/mut_mutex_lock.rs
index 9cd98e90c29..ea60df5ae1b 100644
--- a/tests/ui/mut_mutex_lock.rs
+++ b/tests/ui/mut_mutex_lock.rs
@@ -1,3 +1,5 @@
+// run-rustfix
+#![allow(dead_code, unused_mut)]
 #![warn(clippy::mut_mutex_lock)]
 
 use std::sync::{Arc, Mutex};
diff --git a/tests/ui/mut_mutex_lock.stderr b/tests/ui/mut_mutex_lock.stderr
index d521ebb56c4..21c1b3486ca 100644
--- a/tests/ui/mut_mutex_lock.stderr
+++ b/tests/ui/mut_mutex_lock.stderr
@@ -1,11 +1,10 @@
 error: calling `&mut Mutex::lock` unnecessarily locks an exclusive (mutable) reference
-  --> $DIR/mut_mutex_lock.rs:9:21
+  --> $DIR/mut_mutex_lock.rs:11:33
    |
 LL |     let mut value = value_mutex.lock().unwrap();
-   |                     ^^^^^^^^^^^^^^^^^^
+   |                                 ^^^^ help: change this to: `get_mut`
    |
    = note: `-D clippy::mut-mutex-lock` implied by `-D warnings`
-   = help: use `&mut Mutex::get_mut` instead
 
 error: aborting due to previous error
 
-- 
cgit 1.4.1-3-g733a5


From e7e03b791217645d48e407b28ed023723cedb24c Mon Sep 17 00:00:00 2001
From: Francis Murillo <francis.murillo@protonmail.com>
Date: Sun, 18 Oct 2020 09:09:07 +0800
Subject: Change from correctness to style and MaybeIncorrect instead of
 MachineApplicable

---
 clippy_lints/src/lib.rs            | 2 +-
 clippy_lints/src/mut_mutex_lock.rs | 4 ++--
 src/lintlist/mod.rs                | 2 +-
 3 files changed, 4 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 648c65ef7b0..9d88cc22d10 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1621,6 +1621,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&misc_early::DUPLICATE_UNDERSCORE_ARGUMENT),
         LintId::of(&misc_early::MIXED_CASE_HEX_LITERALS),
         LintId::of(&misc_early::REDUNDANT_PATTERN),
+        LintId::of(&mut_mutex_lock::MUT_MUTEX_LOCK),
         LintId::of(&mut_reference::UNNECESSARY_MUT_PASSED),
         LintId::of(&neg_multiply::NEG_MULTIPLY),
         LintId::of(&new_without_default::NEW_WITHOUT_DEFAULT),
@@ -1784,7 +1785,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&misc::FLOAT_CMP),
         LintId::of(&misc::MODULO_ONE),
         LintId::of(&mut_key::MUTABLE_KEY_TYPE),
-        LintId::of(&mut_mutex_lock::MUT_MUTEX_LOCK),
         LintId::of(&open_options::NONSENSICAL_OPEN_OPTIONS),
         LintId::of(&option_env_unwrap::OPTION_ENV_UNWRAP),
         LintId::of(&ptr::MUT_FROM_REF),
diff --git a/clippy_lints/src/mut_mutex_lock.rs b/clippy_lints/src/mut_mutex_lock.rs
index 82ed2d6d69c..df1cecb328c 100644
--- a/clippy_lints/src/mut_mutex_lock.rs
+++ b/clippy_lints/src/mut_mutex_lock.rs
@@ -38,7 +38,7 @@ declare_clippy_lint! {
     /// *value += 1;
     /// ```
     pub MUT_MUTEX_LOCK,
-    correctness,
+    style,
     "`&mut Mutex::lock` does unnecessary locking"
 }
 
@@ -60,7 +60,7 @@ impl<'tcx> LateLintPass<'tcx> for MutMutexLock {
                     "calling `&mut Mutex::lock` unnecessarily locks an exclusive (mutable) reference",
                     "change this to",
                     "get_mut".to_owned(),
-                    Applicability::MachineApplicable,
+                    Applicability::MaybeIncorrect,
                 );
             }
         }
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index 5e48757a4c5..25ede21da77 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -1504,7 +1504,7 @@ vec![
     },
     Lint {
         name: "mut_mutex_lock",
-        group: "correctness",
+        group: "style",
         desc: "`&mut Mutex::lock` does unnecessary locking",
         deprecation: None,
         module: "mut_mutex_lock",
-- 
cgit 1.4.1-3-g733a5


From d5713898acd3e9afe04223522aad50c9da8f05e2 Mon Sep 17 00:00:00 2001
From: Yuki Okushi <huyuumi.dev@gmail.com>
Date: Sun, 25 Oct 2020 19:30:00 +0900
Subject: Remove redundant `expect_local()` call

---
 clippy_lints/src/functions.rs   | 10 ++++------
 clippy_lints/src/loops.rs       |  3 +--
 clippy_lints/src/utils/mod.rs   |  2 +-
 clippy_lints/src/utils/usage.rs |  3 +--
 4 files changed, 7 insertions(+), 11 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/functions.rs b/clippy_lints/src/functions.rs
index fd45a6da61c..9c0efef95de 100644
--- a/clippy_lints/src/functions.rs
+++ b/clippy_lints/src/functions.rs
@@ -579,9 +579,8 @@ fn is_mutable_pat(cx: &LateContext<'_>, pat: &hir::Pat<'_>, tys: &mut FxHashSet<
     if let hir::PatKind::Wild = pat.kind {
         return false; // ignore `_` patterns
     }
-    let def_id = pat.hir_id.owner.to_def_id();
-    if cx.tcx.has_typeck_results(def_id) {
-        is_mutable_ty(cx, &cx.tcx.typeck(def_id.expect_local()).pat_ty(pat), pat.span, tys)
+    if cx.tcx.has_typeck_results(pat.hir_id.owner.to_def_id()) {
+        is_mutable_ty(cx, &cx.tcx.typeck(pat.hir_id.owner).pat_ty(pat), pat.span, tys)
     } else {
         false
     }
@@ -694,11 +693,10 @@ impl<'a, 'tcx> intravisit::Visitor<'tcx> for StaticMutVisitor<'a, 'tcx> {
             Call(_, args) | MethodCall(_, _, args, _) => {
                 let mut tys = FxHashSet::default();
                 for arg in args {
-                    let def_id = arg.hir_id.owner.to_def_id();
-                    if self.cx.tcx.has_typeck_results(def_id)
+                    if self.cx.tcx.has_typeck_results(arg.hir_id.owner.to_def_id())
                         && is_mutable_ty(
                             self.cx,
-                            self.cx.tcx.typeck(def_id.expect_local()).expr_ty(arg),
+                            self.cx.tcx.typeck(arg.hir_id.owner).expr_ty(arg),
                             arg.span,
                             &mut tys,
                         )
diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 44f2674eaa2..23ca35fffaa 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -2051,12 +2051,11 @@ fn check_for_mutation<'tcx>(
         span_low: None,
         span_high: None,
     };
-    let def_id = body.hir_id.owner.to_def_id();
     cx.tcx.infer_ctxt().enter(|infcx| {
         ExprUseVisitor::new(
             &mut delegate,
             &infcx,
-            def_id.expect_local(),
+            body.hir_id.owner,
             cx.param_env,
             cx.typeck_results(),
         )
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index a9d26d48b12..8297b9d128d 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -299,7 +299,7 @@ pub fn qpath_res(cx: &LateContext<'_>, qpath: &hir::QPath<'_>, id: hir::HirId) -
         hir::QPath::Resolved(_, path) => path.res,
         hir::QPath::TypeRelative(..) | hir::QPath::LangItem(..) => {
             if cx.tcx.has_typeck_results(id.owner.to_def_id()) {
-                cx.tcx.typeck(id.owner.to_def_id().expect_local()).qpath_res(qpath, id)
+                cx.tcx.typeck(id.owner).qpath_res(qpath, id)
             } else {
                 Res::Err
             }
diff --git a/clippy_lints/src/utils/usage.rs b/clippy_lints/src/utils/usage.rs
index 2fd6046ebcf..8b327b2d467 100644
--- a/clippy_lints/src/utils/usage.rs
+++ b/clippy_lints/src/utils/usage.rs
@@ -19,12 +19,11 @@ pub fn mutated_variables<'tcx>(expr: &'tcx Expr<'_>, cx: &LateContext<'tcx>) ->
         used_mutably: FxHashSet::default(),
         skip: false,
     };
-    let def_id = expr.hir_id.owner.to_def_id();
     cx.tcx.infer_ctxt().enter(|infcx| {
         ExprUseVisitor::new(
             &mut delegate,
             &infcx,
-            def_id.expect_local(),
+            expr.hir_id.owner,
             cx.param_env,
             cx.typeck_results(),
         )
-- 
cgit 1.4.1-3-g733a5


From db8380c4a0e7f707112bbce19a6074a5fac2de59 Mon Sep 17 00:00:00 2001
From: Florian Hartwig <florian.j.hartwig@gmail.com>
Date: Wed, 31 Oct 2018 17:14:55 +0100
Subject: Add lint for unusually-grouped hex/binary literals

---
 CHANGELOG.md                               |  1 +
 clippy_lints/src/lib.rs                    |  3 +++
 clippy_lints/src/literal_representation.rs | 42 +++++++++++++++++++++++++++---
 clippy_lints/src/utils/numeric_literal.rs  |  6 ++---
 src/lintlist/mod.rs                        |  7 +++++
 tests/ui/large_digit_groups.fixed          |  2 +-
 tests/ui/large_digit_groups.stderr         | 20 +++++++++-----
 tests/ui/literals.rs                       | 13 ++++++---
 tests/ui/literals.stderr                   | 22 +++++++++++++++-
 tests/ui/unreadable_literal.fixed          |  2 +-
 tests/ui/unreadable_literal.stderr         | 10 ++++++-
 11 files changed, 107 insertions(+), 21 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 7fd79deb56c..c0dd7b352ad 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2017,6 +2017,7 @@ Released 2018-09-13
 [`unused_label`]: https://rust-lang.github.io/rust-clippy/master/index.html#unused_label
 [`unused_self`]: https://rust-lang.github.io/rust-clippy/master/index.html#unused_self
 [`unused_unit`]: https://rust-lang.github.io/rust-clippy/master/index.html#unused_unit
+[`unusual_byte_grouping`]: https://rust-lang.github.io/rust-clippy/master/index.html#unusual_byte_grouping
 [`unwrap_in_result`]: https://rust-lang.github.io/rust-clippy/master/index.html#unwrap_in_result
 [`unwrap_used`]: https://rust-lang.github.io/rust-clippy/master/index.html#unwrap_used
 [`use_debug`]: https://rust-lang.github.io/rust-clippy/master/index.html#use_debug
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index b330b66776c..5d6900f6b96 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -623,6 +623,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &literal_representation::LARGE_DIGIT_GROUPS,
         &literal_representation::MISTYPED_LITERAL_SUFFIXES,
         &literal_representation::UNREADABLE_LITERAL,
+        &literal_representation::UNUSUAL_BYTE_GROUPING,
         &loops::EMPTY_LOOP,
         &loops::EXPLICIT_COUNTER_LOOP,
         &loops::EXPLICIT_INTO_ITER_LOOP,
@@ -1365,6 +1366,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&lifetimes::NEEDLESS_LIFETIMES),
         LintId::of(&literal_representation::INCONSISTENT_DIGIT_GROUPING),
         LintId::of(&literal_representation::MISTYPED_LITERAL_SUFFIXES),
+        LintId::of(&literal_representation::UNUSUAL_BYTE_GROUPING),
         LintId::of(&loops::EMPTY_LOOP),
         LintId::of(&loops::EXPLICIT_COUNTER_LOOP),
         LintId::of(&loops::FOR_KV_MAP),
@@ -1587,6 +1589,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&len_zero::LEN_WITHOUT_IS_EMPTY),
         LintId::of(&len_zero::LEN_ZERO),
         LintId::of(&literal_representation::INCONSISTENT_DIGIT_GROUPING),
+        LintId::of(&literal_representation::UNUSUAL_BYTE_GROUPING),
         LintId::of(&loops::EMPTY_LOOP),
         LintId::of(&loops::FOR_KV_MAP),
         LintId::of(&loops::NEEDLESS_RANGE_LOOP),
diff --git a/clippy_lints/src/literal_representation.rs b/clippy_lints/src/literal_representation.rs
index c54103b25c2..b41cfe32cfe 100644
--- a/clippy_lints/src/literal_representation.rs
+++ b/clippy_lints/src/literal_representation.rs
@@ -82,6 +82,25 @@ declare_clippy_lint! {
     "integer literals with digits grouped inconsistently"
 }
 
+declare_clippy_lint! {
+    /// **What it does:** Warns if hexadecimal or binary literals are not grouped
+    /// by nibble or byte.
+    ///
+    /// **Why is this bad?** Negatively impacts readability.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// let x: u32 = 0xFFF_FFF;
+    /// let y: u8 = 0b01_011_101;
+    /// ```
+    pub UNUSUAL_BYTE_GROUPING,
+    style,
+    "binary or hex literals that aren't grouped by four"
+}
+
 declare_clippy_lint! {
     /// **What it does:** Warns if the digits of an integral or floating-point
     /// constant are grouped into groups that
@@ -125,6 +144,7 @@ enum WarningType {
     LargeDigitGroups,
     DecimalRepresentation,
     MistypedLiteralSuffix,
+    UnusualByteGrouping,
 }
 
 impl WarningType {
@@ -175,6 +195,15 @@ impl WarningType {
                 suggested_format,
                 Applicability::MachineApplicable,
             ),
+            Self::UnusualByteGrouping => span_lint_and_sugg(
+                cx,
+                UNUSUAL_BYTE_GROUPING,
+                span,
+                "digits of hex or binary literal not grouped by four",
+                "consider",
+                suggested_format,
+                Applicability::MachineApplicable,
+            ),
         };
     }
 }
@@ -184,6 +213,7 @@ declare_lint_pass!(LiteralDigitGrouping => [
     INCONSISTENT_DIGIT_GROUPING,
     LARGE_DIGIT_GROUPS,
     MISTYPED_LITERAL_SUFFIXES,
+    UNUSUAL_BYTE_GROUPING,
 ]);
 
 impl EarlyLintPass for LiteralDigitGrouping {
@@ -217,9 +247,9 @@ impl LiteralDigitGrouping {
 
                 let result = (|| {
 
-                    let integral_group_size = Self::get_group_size(num_lit.integer.split('_'))?;
+                    let integral_group_size = Self::get_group_size(num_lit.integer.split('_'), num_lit.radix)?;
                     if let Some(fraction) = num_lit.fraction {
-                        let fractional_group_size = Self::get_group_size(fraction.rsplit('_'))?;
+                        let fractional_group_size = Self::get_group_size(fraction.rsplit('_'), num_lit.radix)?;
 
                         let consistent = Self::parts_consistent(integral_group_size,
                                                                 fractional_group_size,
@@ -229,6 +259,7 @@ impl LiteralDigitGrouping {
                             return Err(WarningType::InconsistentDigitGrouping);
                         };
                     }
+
                     Ok(())
                 })();
 
@@ -237,6 +268,7 @@ impl LiteralDigitGrouping {
                     let should_warn = match warning_type {
                         | WarningType::UnreadableLiteral
                         | WarningType::InconsistentDigitGrouping
+                        | WarningType::UnusualByteGrouping
                         | WarningType::LargeDigitGroups => {
                             !in_macro(lit.span)
                         }
@@ -331,11 +363,15 @@ impl LiteralDigitGrouping {
 
     /// Returns the size of the digit groups (or None if ungrouped) if successful,
     /// otherwise returns a `WarningType` for linting.
-    fn get_group_size<'a>(groups: impl Iterator<Item = &'a str>) -> Result<Option<usize>, WarningType> {
+    fn get_group_size<'a>(groups: impl Iterator<Item = &'a str>, radix: Radix) -> Result<Option<usize>, WarningType> {
         let mut groups = groups.map(str::len);
 
         let first = groups.next().expect("At least one group");
 
+        if (radix == Radix::Binary || radix == Radix::Hexadecimal) && groups.any(|i| i % 4 != 0) {
+            return Err(WarningType::UnusualByteGrouping);
+        }
+
         if let Some(second) = groups.next() {
             if !groups.all(|x| x == second) || first > second {
                 Err(WarningType::InconsistentDigitGrouping)
diff --git a/clippy_lints/src/utils/numeric_literal.rs b/clippy_lints/src/utils/numeric_literal.rs
index 52d3c2c1daf..d02603d7702 100644
--- a/clippy_lints/src/utils/numeric_literal.rs
+++ b/clippy_lints/src/utils/numeric_literal.rs
@@ -1,6 +1,6 @@
 use rustc_ast::ast::{Lit, LitFloatType, LitIntType, LitKind};
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Copy, Clone)]
 pub enum Radix {
     Binary,
     Octal,
@@ -11,8 +11,8 @@ pub enum Radix {
 impl Radix {
     /// Returns a reasonable digit group size for this radix.
     #[must_use]
-    fn suggest_grouping(&self) -> usize {
-        match *self {
+    fn suggest_grouping(self) -> usize {
+        match self {
             Self::Binary | Self::Hexadecimal => 4,
             Self::Octal | Self::Decimal => 3,
         }
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index 4bf77dae637..fc8efb81cfc 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -2643,6 +2643,13 @@ vec![
         deprecation: None,
         module: "unused_unit",
     },
+    Lint {
+        name: "unusual_byte_grouping",
+        group: "style",
+        desc: "binary or hex literals that aren\'t grouped by four",
+        deprecation: None,
+        module: "literal_representation",
+    },
     Lint {
         name: "unwrap_in_result",
         group: "restriction",
diff --git a/tests/ui/large_digit_groups.fixed b/tests/ui/large_digit_groups.fixed
index 859fad2f54d..3430c137ec2 100644
--- a/tests/ui/large_digit_groups.fixed
+++ b/tests/ui/large_digit_groups.fixed
@@ -11,7 +11,7 @@ fn main() {
     let _good = (
         0b1011_i64,
         0o1_234_u32,
-        0x1_234_567,
+        0x0123_4567,
         1_2345_6789,
         1234_f32,
         1_234.12_f32,
diff --git a/tests/ui/large_digit_groups.stderr b/tests/ui/large_digit_groups.stderr
index b6d9672a78e..fe472e66949 100644
--- a/tests/ui/large_digit_groups.stderr
+++ b/tests/ui/large_digit_groups.stderr
@@ -1,24 +1,30 @@
-error: digit groups should be smaller
+error: digits of hex or binary literal not grouped by four
+  --> $DIR/large_digit_groups.rs:14:9
+   |
+LL |         0x1_234_567,
+   |         ^^^^^^^^^^^ help: consider: `0x0123_4567`
+   |
+   = note: `-D clippy::unusual-byte-grouping` implied by `-D warnings`
+
+error: digits of hex or binary literal not grouped by four
   --> $DIR/large_digit_groups.rs:22:9
    |
 LL |         0b1_10110_i64,
    |         ^^^^^^^^^^^^^ help: consider: `0b11_0110_i64`
-   |
-   = note: `-D clippy::large-digit-groups` implied by `-D warnings`
 
-error: digits grouped inconsistently by underscores
+error: digits of hex or binary literal not grouped by four
   --> $DIR/large_digit_groups.rs:23:9
    |
 LL |         0xd_e_adbee_f_usize,
    |         ^^^^^^^^^^^^^^^^^^^ help: consider: `0xdead_beef_usize`
-   |
-   = note: `-D clippy::inconsistent-digit-grouping` implied by `-D warnings`
 
 error: digit groups should be smaller
   --> $DIR/large_digit_groups.rs:24:9
    |
 LL |         1_23456_f32,
    |         ^^^^^^^^^^^ help: consider: `123_456_f32`
+   |
+   = note: `-D clippy::large-digit-groups` implied by `-D warnings`
 
 error: digit groups should be smaller
   --> $DIR/large_digit_groups.rs:25:9
@@ -38,5 +44,5 @@ error: digit groups should be smaller
 LL |         1_23456.12345_6_f64,
    |         ^^^^^^^^^^^^^^^^^^^ help: consider: `123_456.123_456_f64`
 
-error: aborting due to 6 previous errors
+error: aborting due to 7 previous errors
 
diff --git a/tests/ui/literals.rs b/tests/ui/literals.rs
index c299b16c8ce..2608638ff80 100644
--- a/tests/ui/literals.rs
+++ b/tests/ui/literals.rs
@@ -7,10 +7,10 @@
 
 fn main() {
     let ok1 = 0xABCD;
-    let ok3 = 0xab_cd;
-    let ok4 = 0xab_cd_i32;
-    let ok5 = 0xAB_CD_u32;
-    let ok5 = 0xAB_CD_isize;
+    let ok3 = 0xabcd;
+    let ok4 = 0xabcd_i32;
+    let ok5 = 0xABCD_u32;
+    let ok5 = 0xABCD_isize;
     let fail1 = 0xabCD;
     let fail2 = 0xabCD_u32;
     let fail2 = 0xabCD_isize;
@@ -33,4 +33,9 @@ fn main() {
     let fail19 = 12_3456_21;
     let fail22 = 3__4___23;
     let fail23 = 3__16___23;
+
+    let fail24 = 0xAB_ABC_AB;
+    let fail25 = 0b01_100_101;
+    let ok26 = 0x6_A0_BF;
+    let ok27 = 0b1_0010_0101;
 }
diff --git a/tests/ui/literals.stderr b/tests/ui/literals.stderr
index 0b3af2d8bc3..c88848a40fc 100644
--- a/tests/ui/literals.stderr
+++ b/tests/ui/literals.stderr
@@ -69,5 +69,25 @@ error: digits grouped inconsistently by underscores
 LL |     let fail23 = 3__16___23;
    |                  ^^^^^^^^^^ help: consider: `31_623`
 
-error: aborting due to 8 previous errors
+error: digits of hex or binary literal not grouped by four
+  --> $DIR/literals.rs:37:18
+   |
+LL |     let fail24 = 0xAB_ABC_AB;
+   |                  ^^^^^^^^^^^ help: consider: `0x0ABA_BCAB`
+   |
+   = note: `-D clippy::unusual-byte-grouping` implied by `-D warnings`
+
+error: digits of hex or binary literal not grouped by four
+  --> $DIR/literals.rs:38:18
+   |
+LL |     let fail25 = 0b01_100_101;
+   |                  ^^^^^^^^^^^^ help: consider: `0b0110_0101`
+
+error: digits of hex or binary literal not grouped by four
+  --> $DIR/literals.rs:39:16
+   |
+LL |     let ok26 = 0x6_A0_BF;
+   |                ^^^^^^^^^ help: consider: `0x0006_A0BF`
+
+error: aborting due to 11 previous errors
 
diff --git a/tests/ui/unreadable_literal.fixed b/tests/ui/unreadable_literal.fixed
index 3f358d9ecaa..4043d53299f 100644
--- a/tests/ui/unreadable_literal.fixed
+++ b/tests/ui/unreadable_literal.fixed
@@ -14,7 +14,7 @@ fn main() {
     let _good = (
         0b1011_i64,
         0o1_234_u32,
-        0x1_234_567,
+        0x0123_4567,
         65536,
         1_2345_6789,
         1234_f32,
diff --git a/tests/ui/unreadable_literal.stderr b/tests/ui/unreadable_literal.stderr
index 1b2ff6bff04..fa4c3fe13e3 100644
--- a/tests/ui/unreadable_literal.stderr
+++ b/tests/ui/unreadable_literal.stderr
@@ -1,3 +1,11 @@
+error: digits of hex or binary literal not grouped by four
+  --> $DIR/unreadable_literal.rs:17:9
+   |
+LL |         0x1_234_567,
+   |         ^^^^^^^^^^^ help: consider: `0x0123_4567`
+   |
+   = note: `-D clippy::unusual-byte-grouping` implied by `-D warnings`
+
 error: long literal lacking separators
   --> $DIR/unreadable_literal.rs:25:17
    |
@@ -54,5 +62,5 @@ error: long literal lacking separators
 LL |     let _fail12: i128 = 0xabcabcabcabcabcabc;
    |                         ^^^^^^^^^^^^^^^^^^^^ help: consider: `0x00ab_cabc_abca_bcab_cabc`
 
-error: aborting due to 9 previous errors
+error: aborting due to 10 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From f5a88b6de558d17ed088a93756facb901c7c0888 Mon Sep 17 00:00:00 2001
From: cgm616 <cgm616@me.com>
Date: Sun, 25 Oct 2020 09:18:06 -0400
Subject: Allow hex literals to pass w/ groups of 2

---
 clippy_lints/src/literal_representation.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/literal_representation.rs b/clippy_lints/src/literal_representation.rs
index b41cfe32cfe..813f3b6f378 100644
--- a/clippy_lints/src/literal_representation.rs
+++ b/clippy_lints/src/literal_representation.rs
@@ -368,7 +368,7 @@ impl LiteralDigitGrouping {
 
         let first = groups.next().expect("At least one group");
 
-        if (radix == Radix::Binary || radix == Radix::Hexadecimal) && groups.any(|i| i % 4 != 0) {
+        if (radix == Radix::Binary || radix == Radix::Hexadecimal) && groups.any(|i| i != 4 || i != 2) {
             return Err(WarningType::UnusualByteGrouping);
         }
 
-- 
cgit 1.4.1-3-g733a5


From e7e4b35bdf695c4db5a1f34319d01b12a9d54b34 Mon Sep 17 00:00:00 2001
From: cgm616 <cgm616@me.com>
Date: Sun, 25 Oct 2020 09:34:46 -0400
Subject: Fix logic mistake

---
 clippy_lints/src/literal_representation.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/literal_representation.rs b/clippy_lints/src/literal_representation.rs
index 813f3b6f378..f51a0edc9c5 100644
--- a/clippy_lints/src/literal_representation.rs
+++ b/clippy_lints/src/literal_representation.rs
@@ -368,7 +368,7 @@ impl LiteralDigitGrouping {
 
         let first = groups.next().expect("At least one group");
 
-        if (radix == Radix::Binary || radix == Radix::Hexadecimal) && groups.any(|i| i != 4 || i != 2) {
+        if (radix == Radix::Binary || radix == Radix::Hexadecimal) && groups.any(|i| i != 4 && i != 2) {
             return Err(WarningType::UnusualByteGrouping);
         }
 
-- 
cgit 1.4.1-3-g733a5


From 3ce820bf83657879493aa7b107634f1951e7c219 Mon Sep 17 00:00:00 2001
From: Takayuki Nakata <f.seasons017@gmail.com>
Date: Wed, 21 Oct 2020 22:33:41 +0900
Subject: Fix an invalid suggestion in `needless_collect` test

---
 clippy_lints/src/loops.rs                 | 9 ++++++++-
 tests/ui/needless_collect_indirect.stderr | 2 +-
 2 files changed, 9 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 23ca35fffaa..c3f75f283f4 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -3001,7 +3001,14 @@ impl IterFunction {
             IterFunctionKind::IntoIter => String::new(),
             IterFunctionKind::Len => String::from(".count()"),
             IterFunctionKind::IsEmpty => String::from(".next().is_none()"),
-            IterFunctionKind::Contains(span) => format!(".any(|x| x == {})", snippet(cx, *span, "..")),
+            IterFunctionKind::Contains(span) => {
+                let s = snippet(cx, *span, "..");
+                if let Some(stripped) = s.strip_prefix('&') {
+                    format!(".any(|x| x == {})", stripped)
+                } else {
+                    format!(".any(|x| x == *{})", s)
+                }
+            },
         }
     }
     fn get_suggestion_text(&self) -> &'static str {
diff --git a/tests/ui/needless_collect_indirect.stderr b/tests/ui/needless_collect_indirect.stderr
index 0c1e61d7496..7b8e227f304 100644
--- a/tests/ui/needless_collect_indirect.stderr
+++ b/tests/ui/needless_collect_indirect.stderr
@@ -48,7 +48,7 @@ LL | |     indirect_contains.contains(&&5);
 help: Check if the original Iterator contains an element instead of collecting then checking
    |
 LL |     
-LL |     sample.iter().any(|x| x == &&5);
+LL |     sample.iter().any(|x| x == &5);
    |
 
 error: aborting due to 4 previous errors
-- 
cgit 1.4.1-3-g733a5


From 312bbff6968dbebd367ca90677c676e2cf5198d2 Mon Sep 17 00:00:00 2001
From: cgm616 <cgm616@me.com>
Date: Sun, 25 Oct 2020 11:31:24 -0400
Subject: Integrate suggestions from code review

---
 CHANGELOG.md                               |  2 +-
 clippy_lints/src/lib.rs                    |  6 +++---
 clippy_lints/src/literal_representation.rs | 14 +++++++-------
 src/lintlist/mod.rs                        |  2 +-
 tests/ui/large_digit_groups.stderr         |  2 +-
 tests/ui/literals.rs                       |  8 ++++----
 tests/ui/literals.stderr                   |  2 +-
 tests/ui/unreadable_literal.stderr         |  2 +-
 8 files changed, 19 insertions(+), 19 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index c0dd7b352ad..25f3b5da198 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2017,7 +2017,7 @@ Released 2018-09-13
 [`unused_label`]: https://rust-lang.github.io/rust-clippy/master/index.html#unused_label
 [`unused_self`]: https://rust-lang.github.io/rust-clippy/master/index.html#unused_self
 [`unused_unit`]: https://rust-lang.github.io/rust-clippy/master/index.html#unused_unit
-[`unusual_byte_grouping`]: https://rust-lang.github.io/rust-clippy/master/index.html#unusual_byte_grouping
+[`unusual_byte_groupings`]: https://rust-lang.github.io/rust-clippy/master/index.html#unusual_byte_groupings
 [`unwrap_in_result`]: https://rust-lang.github.io/rust-clippy/master/index.html#unwrap_in_result
 [`unwrap_used`]: https://rust-lang.github.io/rust-clippy/master/index.html#unwrap_used
 [`use_debug`]: https://rust-lang.github.io/rust-clippy/master/index.html#use_debug
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 5d6900f6b96..3be8bc0e36d 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -623,7 +623,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &literal_representation::LARGE_DIGIT_GROUPS,
         &literal_representation::MISTYPED_LITERAL_SUFFIXES,
         &literal_representation::UNREADABLE_LITERAL,
-        &literal_representation::UNUSUAL_BYTE_GROUPING,
+        &literal_representation::UNUSUAL_BYTE_GROUPINGS,
         &loops::EMPTY_LOOP,
         &loops::EXPLICIT_COUNTER_LOOP,
         &loops::EXPLICIT_INTO_ITER_LOOP,
@@ -1366,7 +1366,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&lifetimes::NEEDLESS_LIFETIMES),
         LintId::of(&literal_representation::INCONSISTENT_DIGIT_GROUPING),
         LintId::of(&literal_representation::MISTYPED_LITERAL_SUFFIXES),
-        LintId::of(&literal_representation::UNUSUAL_BYTE_GROUPING),
+        LintId::of(&literal_representation::UNUSUAL_BYTE_GROUPINGS),
         LintId::of(&loops::EMPTY_LOOP),
         LintId::of(&loops::EXPLICIT_COUNTER_LOOP),
         LintId::of(&loops::FOR_KV_MAP),
@@ -1589,7 +1589,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&len_zero::LEN_WITHOUT_IS_EMPTY),
         LintId::of(&len_zero::LEN_ZERO),
         LintId::of(&literal_representation::INCONSISTENT_DIGIT_GROUPING),
-        LintId::of(&literal_representation::UNUSUAL_BYTE_GROUPING),
+        LintId::of(&literal_representation::UNUSUAL_BYTE_GROUPINGS),
         LintId::of(&loops::EMPTY_LOOP),
         LintId::of(&loops::FOR_KV_MAP),
         LintId::of(&loops::NEEDLESS_RANGE_LOOP),
diff --git a/clippy_lints/src/literal_representation.rs b/clippy_lints/src/literal_representation.rs
index f51a0edc9c5..e8a741683da 100644
--- a/clippy_lints/src/literal_representation.rs
+++ b/clippy_lints/src/literal_representation.rs
@@ -96,7 +96,7 @@ declare_clippy_lint! {
     /// let x: u32 = 0xFFF_FFF;
     /// let y: u8 = 0b01_011_101;
     /// ```
-    pub UNUSUAL_BYTE_GROUPING,
+    pub UNUSUAL_BYTE_GROUPINGS,
     style,
     "binary or hex literals that aren't grouped by four"
 }
@@ -144,7 +144,7 @@ enum WarningType {
     LargeDigitGroups,
     DecimalRepresentation,
     MistypedLiteralSuffix,
-    UnusualByteGrouping,
+    UnusualByteGroupings,
 }
 
 impl WarningType {
@@ -195,9 +195,9 @@ impl WarningType {
                 suggested_format,
                 Applicability::MachineApplicable,
             ),
-            Self::UnusualByteGrouping => span_lint_and_sugg(
+            Self::UnusualByteGroupings => span_lint_and_sugg(
                 cx,
-                UNUSUAL_BYTE_GROUPING,
+                UNUSUAL_BYTE_GROUPINGS,
                 span,
                 "digits of hex or binary literal not grouped by four",
                 "consider",
@@ -213,7 +213,7 @@ declare_lint_pass!(LiteralDigitGrouping => [
     INCONSISTENT_DIGIT_GROUPING,
     LARGE_DIGIT_GROUPS,
     MISTYPED_LITERAL_SUFFIXES,
-    UNUSUAL_BYTE_GROUPING,
+    UNUSUAL_BYTE_GROUPINGS,
 ]);
 
 impl EarlyLintPass for LiteralDigitGrouping {
@@ -268,7 +268,7 @@ impl LiteralDigitGrouping {
                     let should_warn = match warning_type {
                         | WarningType::UnreadableLiteral
                         | WarningType::InconsistentDigitGrouping
-                        | WarningType::UnusualByteGrouping
+                        | WarningType::UnusualByteGroupings
                         | WarningType::LargeDigitGroups => {
                             !in_macro(lit.span)
                         }
@@ -369,7 +369,7 @@ impl LiteralDigitGrouping {
         let first = groups.next().expect("At least one group");
 
         if (radix == Radix::Binary || radix == Radix::Hexadecimal) && groups.any(|i| i != 4 && i != 2) {
-            return Err(WarningType::UnusualByteGrouping);
+            return Err(WarningType::UnusualByteGroupings);
         }
 
         if let Some(second) = groups.next() {
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index fc8efb81cfc..6272ce45efb 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -2644,7 +2644,7 @@ vec![
         module: "unused_unit",
     },
     Lint {
-        name: "unusual_byte_grouping",
+        name: "unusual_byte_groupings",
         group: "style",
         desc: "binary or hex literals that aren\'t grouped by four",
         deprecation: None,
diff --git a/tests/ui/large_digit_groups.stderr b/tests/ui/large_digit_groups.stderr
index fe472e66949..13d108b56e0 100644
--- a/tests/ui/large_digit_groups.stderr
+++ b/tests/ui/large_digit_groups.stderr
@@ -4,7 +4,7 @@ error: digits of hex or binary literal not grouped by four
 LL |         0x1_234_567,
    |         ^^^^^^^^^^^ help: consider: `0x0123_4567`
    |
-   = note: `-D clippy::unusual-byte-grouping` implied by `-D warnings`
+   = note: `-D clippy::unusual-byte-groupings` implied by `-D warnings`
 
 error: digits of hex or binary literal not grouped by four
   --> $DIR/large_digit_groups.rs:22:9
diff --git a/tests/ui/literals.rs b/tests/ui/literals.rs
index 2608638ff80..a72a74b9131 100644
--- a/tests/ui/literals.rs
+++ b/tests/ui/literals.rs
@@ -7,10 +7,10 @@
 
 fn main() {
     let ok1 = 0xABCD;
-    let ok3 = 0xabcd;
-    let ok4 = 0xabcd_i32;
-    let ok5 = 0xABCD_u32;
-    let ok5 = 0xABCD_isize;
+    let ok3 = 0xab_cd;
+    let ok4 = 0xab_cd_i32;
+    let ok5 = 0xAB_CD_u32;
+    let ok5 = 0xAB_CD_isize;
     let fail1 = 0xabCD;
     let fail2 = 0xabCD_u32;
     let fail2 = 0xabCD_isize;
diff --git a/tests/ui/literals.stderr b/tests/ui/literals.stderr
index e321f2a1cef..64ceeb316d8 100644
--- a/tests/ui/literals.stderr
+++ b/tests/ui/literals.stderr
@@ -75,7 +75,7 @@ error: digits of hex or binary literal not grouped by four
 LL |     let fail24 = 0xAB_ABC_AB;
    |                  ^^^^^^^^^^^ help: consider: `0x0ABA_BCAB`
    |
-   = note: `-D clippy::unusual-byte-grouping` implied by `-D warnings`
+   = note: `-D clippy::unusual-byte-groupings` implied by `-D warnings`
 
 error: digits of hex or binary literal not grouped by four
   --> $DIR/literals.rs:38:18
diff --git a/tests/ui/unreadable_literal.stderr b/tests/ui/unreadable_literal.stderr
index fa4c3fe13e3..8645cabeabb 100644
--- a/tests/ui/unreadable_literal.stderr
+++ b/tests/ui/unreadable_literal.stderr
@@ -4,7 +4,7 @@ error: digits of hex or binary literal not grouped by four
 LL |         0x1_234_567,
    |         ^^^^^^^^^^^ help: consider: `0x0123_4567`
    |
-   = note: `-D clippy::unusual-byte-grouping` implied by `-D warnings`
+   = note: `-D clippy::unusual-byte-groupings` implied by `-D warnings`
 
 error: long literal lacking separators
   --> $DIR/unreadable_literal.rs:25:17
-- 
cgit 1.4.1-3-g733a5


From de5a6d3420d9f2f2c4c995e325412e862a9dc583 Mon Sep 17 00:00:00 2001
From: Urcra <urcra@urcra.com>
Date: Mon, 26 Oct 2020 00:31:25 +0100
Subject: Initial implementation of comparison_to_empty

---
 CHANGELOG.md                            |   1 +
 Cargo.toml                              |   7 ++
 clippy_lints/Cargo.toml                 |  22 +++++
 clippy_lints/src/comparison_to_empty.rs | 155 ++++++++++++++++++++++++++++++++
 clippy_lints/src/lib.rs                 |   5 ++
 src/lintlist/mod.rs                     |   7 ++
 tests/ui/comparison_to_empty.fixed      |  23 +++++
 tests/ui/comparison_to_empty.rs         |  23 +++++
 tests/ui/comparison_to_empty.stderr     |  28 ++++++
 9 files changed, 271 insertions(+)
 create mode 100644 clippy_lints/src/comparison_to_empty.rs
 create mode 100644 tests/ui/comparison_to_empty.fixed
 create mode 100644 tests/ui/comparison_to_empty.rs
 create mode 100644 tests/ui/comparison_to_empty.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 22f96398153..869e9949167 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1664,6 +1664,7 @@ Released 2018-09-13
 [`cognitive_complexity`]: https://rust-lang.github.io/rust-clippy/master/index.html#cognitive_complexity
 [`collapsible_if`]: https://rust-lang.github.io/rust-clippy/master/index.html#collapsible_if
 [`comparison_chain`]: https://rust-lang.github.io/rust-clippy/master/index.html#comparison_chain
+[`comparison_to_empty`]: https://rust-lang.github.io/rust-clippy/master/index.html#comparison_to_empty
 [`copy_iterator`]: https://rust-lang.github.io/rust-clippy/master/index.html#copy_iterator
 [`create_dir`]: https://rust-lang.github.io/rust-clippy/master/index.html#create_dir
 [`crosspointer_transmute`]: https://rust-lang.github.io/rust-clippy/master/index.html#crosspointer_transmute
diff --git a/Cargo.toml b/Cargo.toml
index 1ddcd18598d..dae3e03074f 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -27,6 +27,13 @@ path = "src/main.rs"
 name = "clippy-driver"
 path = "src/driver.rs"
 
+[target.'cfg(NOT_A_PLATFORM)'.dependencies]
+rustc_data_structures = { path = "/home/urcra/rust/compiler/rustc_data_structures" }
+rustc_driver = { path = "/home/urcra/rust/compiler/rustc_driver" }
+rustc_errors = { path = "/home/urcra/rust/compiler/rustc_errors" }
+rustc_interface = { path = "/home/urcra/rust/compiler/rustc_interface" }
+rustc_middle = { path = "/home/urcra/rust/compiler/rustc_middle" }
+
 [dependencies]
 # begin automatic update
 clippy_lints = { version = "0.0.212", path = "clippy_lints" }
diff --git a/clippy_lints/Cargo.toml b/clippy_lints/Cargo.toml
index d9471d25197..167db15be20 100644
--- a/clippy_lints/Cargo.toml
+++ b/clippy_lints/Cargo.toml
@@ -16,6 +16,28 @@ license = "MIT OR Apache-2.0"
 keywords = ["clippy", "lint", "plugin"]
 edition = "2018"
 
+[target.'cfg(NOT_A_PLATFORM)'.dependencies]
+rustc_ast = { path = "/home/urcra/rust/compiler/rustc_ast" }
+rustc_ast_pretty = { path = "/home/urcra/rust/compiler/rustc_ast_pretty" }
+rustc_attr = { path = "/home/urcra/rust/compiler/rustc_attr" }
+rustc_data_structures = { path = "/home/urcra/rust/compiler/rustc_data_structures" }
+rustc_errors = { path = "/home/urcra/rust/compiler/rustc_errors" }
+rustc_hir = { path = "/home/urcra/rust/compiler/rustc_hir" }
+rustc_hir_pretty = { path = "/home/urcra/rust/compiler/rustc_hir_pretty" }
+rustc_index = { path = "/home/urcra/rust/compiler/rustc_index" }
+rustc_infer = { path = "/home/urcra/rust/compiler/rustc_infer" }
+rustc_lexer = { path = "/home/urcra/rust/compiler/rustc_lexer" }
+rustc_lint = { path = "/home/urcra/rust/compiler/rustc_lint" }
+rustc_middle = { path = "/home/urcra/rust/compiler/rustc_middle" }
+rustc_mir = { path = "/home/urcra/rust/compiler/rustc_mir" }
+rustc_parse = { path = "/home/urcra/rust/compiler/rustc_parse" }
+rustc_parse_format = { path = "/home/urcra/rust/compiler/rustc_parse_format" }
+rustc_session = { path = "/home/urcra/rust/compiler/rustc_session" }
+rustc_span = { path = "/home/urcra/rust/compiler/rustc_span" }
+rustc_target = { path = "/home/urcra/rust/compiler/rustc_target" }
+rustc_trait_selection = { path = "/home/urcra/rust/compiler/rustc_trait_selection" }
+rustc_typeck = { path = "/home/urcra/rust/compiler/rustc_typeck" }
+
 [dependencies]
 cargo_metadata = "0.12"
 if_chain = "1.0.0"
diff --git a/clippy_lints/src/comparison_to_empty.rs b/clippy_lints/src/comparison_to_empty.rs
new file mode 100644
index 00000000000..3b55336722c
--- /dev/null
+++ b/clippy_lints/src/comparison_to_empty.rs
@@ -0,0 +1,155 @@
+use crate::utils::{snippet_with_applicability, span_lint_and_sugg};
+use rustc_ast::ast::LitKind;
+use rustc_errors::Applicability;
+use rustc_hir::def_id::DefId;
+use rustc_hir::{BinOpKind, Expr, ExprKind, ItemKind, TraitItemRef};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::source_map::{Span, Spanned};
+
+declare_clippy_lint! {
+    /// **What it does:**
+    ///
+    /// **Why is this bad?**
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// // example code where clippy issues a warning
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// // example code which does not raise clippy warning
+    /// ```
+    pub COMPARISON_TO_EMPTY,
+    style,
+    "default lint description"
+}
+
+declare_lint_pass!(ComparisonToEmpty => [COMPARISON_TO_EMPTY]);
+
+impl LateLintPass<'_> for ComparisonToEmpty {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        if expr.span.from_expansion() {
+            return;
+        }
+
+        if let ExprKind::Binary(Spanned { node: cmp, .. }, ref left, ref right) = expr.kind {
+            match cmp {
+                BinOpKind::Eq => {
+                    check_cmp(cx, expr.span, left, right, "", 0); // len == 0
+                    check_cmp(cx, expr.span, right, left, "", 0); // 0 == len
+                },
+                BinOpKind::Ne => {
+                    check_cmp(cx, expr.span, left, right, "!", 0); // len != 0
+                    check_cmp(cx, expr.span, right, left, "!", 0); // 0 != len
+                },
+                BinOpKind::Gt => {
+                    check_cmp(cx, expr.span, left, right, "!", 0); // len > 0
+                    check_cmp(cx, expr.span, right, left, "", 1); // 1 > len
+                },
+                BinOpKind::Lt => {
+                    check_cmp(cx, expr.span, left, right, "", 1); // len < 1
+                    check_cmp(cx, expr.span, right, left, "!", 0); // 0 < len
+                },
+                BinOpKind::Ge => check_cmp(cx, expr.span, left, right, "!", 1), // len >= 1
+                BinOpKind::Le => check_cmp(cx, expr.span, right, left, "!", 1), // 1 <= len
+                _ => (),
+            }
+        }
+    }
+
+}
+
+
+fn check_cmp(cx: &LateContext<'_>, span: Span, lit1: &Expr<'_>, lit2: &Expr<'_>, op: &str, compare_to: u32) {
+    check_empty_expr(cx, span, lit1, lit2, op)
+}
+
+fn check_empty_expr(
+    cx: &LateContext<'_>,
+    span: Span,
+    lit1: &Expr<'_>,
+    lit2: &Expr<'_>,
+    op: &str
+) {
+    if (is_empty_array(lit2) || is_empty_string(lit2)) && has_is_empty(cx, lit1) {
+        let mut applicability = Applicability::MachineApplicable;
+        span_lint_and_sugg(
+            cx,
+            COMPARISON_TO_EMPTY,
+            span,
+            &format!("comparison to empty slice"),
+            &format!("using `{}is_empty` is clearer and more explicit", op),
+            format!(
+                "{}{}.is_empty()",
+                op,
+                snippet_with_applicability(cx, lit1.span, "_", &mut applicability)
+            ),
+            applicability,
+        );
+    }
+}
+
+fn is_empty_string(expr: &Expr<'_>) -> bool {
+    if let ExprKind::Lit(ref lit) = expr.kind {
+        if let LitKind::Str(lit, _) = lit.node {
+            let lit = lit.as_str();
+            return lit == "";
+        }
+    }
+    false
+}
+
+fn is_empty_array(expr: &Expr<'_>) -> bool {
+    if let ExprKind::Array(ref arr) = expr.kind {
+        return arr.is_empty();
+    }
+    false
+}
+
+
+/// Checks if this type has an `is_empty` method.
+fn has_is_empty(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+    /// Gets an `AssocItem` and return true if it matches `is_empty(self)`.
+    fn is_is_empty(cx: &LateContext<'_>, item: &ty::AssocItem) -> bool {
+        if let ty::AssocKind::Fn = item.kind {
+            if item.ident.name.as_str() == "is_empty" {
+                let sig = cx.tcx.fn_sig(item.def_id);
+                let ty = sig.skip_binder();
+                ty.inputs().len() == 1
+            } else {
+                false
+            }
+        } else {
+            false
+        }
+    }
+
+    /// Checks the inherent impl's items for an `is_empty(self)` method.
+    fn has_is_empty_impl(cx: &LateContext<'_>, id: DefId) -> bool {
+        cx.tcx.inherent_impls(id).iter().any(|imp| {
+            cx.tcx
+                .associated_items(*imp)
+                .in_definition_order()
+                .any(|item| is_is_empty(cx, &item))
+        })
+    }
+
+    let ty = &cx.typeck_results().expr_ty(expr).peel_refs();
+    match ty.kind() {
+        ty::Dynamic(ref tt, ..) => tt.principal().map_or(false, |principal| {
+            cx.tcx
+                .associated_items(principal.def_id())
+                .in_definition_order()
+                .any(|item| is_is_empty(cx, &item))
+        }),
+        ty::Projection(ref proj) => has_is_empty_impl(cx, proj.item_def_id),
+        ty::Adt(id, _) => has_is_empty_impl(cx, id.did),
+        ty::Array(..) | ty::Slice(..) | ty::Str => true,
+        _ => false,
+    }
+}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 1a950a7c334..75629e13a8e 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -171,6 +171,7 @@ mod checked_conversions;
 mod cognitive_complexity;
 mod collapsible_if;
 mod comparison_chain;
+mod comparison_to_empty;
 mod copies;
 mod copy_iterator;
 mod create_dir;
@@ -523,6 +524,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &cognitive_complexity::COGNITIVE_COMPLEXITY,
         &collapsible_if::COLLAPSIBLE_IF,
         &comparison_chain::COMPARISON_CHAIN,
+        &comparison_to_empty::COMPARISON_TO_EMPTY,
         &copies::IFS_SAME_COND,
         &copies::IF_SAME_THEN_ELSE,
         &copies::MATCH_SAME_ARMS,
@@ -1139,6 +1141,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(move || box disallowed_method::DisallowedMethod::new(&disallowed_methods));
     store.register_early_pass(|| box asm_syntax::InlineAsmX86AttSyntax);
     store.register_early_pass(|| box asm_syntax::InlineAsmX86IntelSyntax);
+    store.register_late_pass(|| box comparison_to_empty::ComparisonToEmpty);
 
 
     store.register_group(true, "clippy::restriction", Some("clippy_restriction"), vec![
@@ -1299,6 +1302,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&bytecount::NAIVE_BYTECOUNT),
         LintId::of(&collapsible_if::COLLAPSIBLE_IF),
         LintId::of(&comparison_chain::COMPARISON_CHAIN),
+        LintId::of(&comparison_to_empty::COMPARISON_TO_EMPTY),
         LintId::of(&copies::IFS_SAME_COND),
         LintId::of(&copies::IF_SAME_THEN_ELSE),
         LintId::of(&derive::DERIVE_HASH_XOR_EQ),
@@ -1555,6 +1559,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&blocks_in_if_conditions::BLOCKS_IN_IF_CONDITIONS),
         LintId::of(&collapsible_if::COLLAPSIBLE_IF),
         LintId::of(&comparison_chain::COMPARISON_CHAIN),
+        LintId::of(&comparison_to_empty::COMPARISON_TO_EMPTY),
         LintId::of(&doc::MISSING_SAFETY_DOC),
         LintId::of(&doc::NEEDLESS_DOCTEST_MAIN),
         LintId::of(&enum_variants::ENUM_VARIANT_NAMES),
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index da865a66c45..c2b2236bc66 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -291,6 +291,13 @@ vec![
         deprecation: None,
         module: "comparison_chain",
     },
+    Lint {
+        name: "comparison_to_empty",
+        group: "style",
+        desc: "default lint description",
+        deprecation: None,
+        module: "comparison_to_empty",
+    },
     Lint {
         name: "copy_iterator",
         group: "pedantic",
diff --git a/tests/ui/comparison_to_empty.fixed b/tests/ui/comparison_to_empty.fixed
new file mode 100644
index 00000000000..261024caca7
--- /dev/null
+++ b/tests/ui/comparison_to_empty.fixed
@@ -0,0 +1,23 @@
+// run-rustfix
+
+#![warn(clippy::comparison_to_empty)]
+
+fn main() {
+    // Disallow comparisons to empty
+    let s = String::new();
+    let _ = s.is_empty();
+    let _ = !s.is_empty();
+
+    let v = vec![0];
+    let _ = v.is_empty();
+    let _ = !v.is_empty();
+
+    // Allow comparisons to non-empty
+    let s = String::new();
+    let _ = s == " ";
+    let _ = s != " ";
+
+    let v = vec![0];
+    let _ = v == [0];
+    let _ = v != [0];
+}
diff --git a/tests/ui/comparison_to_empty.rs b/tests/ui/comparison_to_empty.rs
new file mode 100644
index 00000000000..98ddd974951
--- /dev/null
+++ b/tests/ui/comparison_to_empty.rs
@@ -0,0 +1,23 @@
+// run-rustfix
+
+#![warn(clippy::comparison_to_empty)]
+
+fn main() {
+    // Disallow comparisons to empty
+    let s = String::new();
+    let _ = s == "";
+    let _ = s != "";
+
+    let v = vec![0];
+    let _ = v == [];
+    let _ = v != [];
+
+    // Allow comparisons to non-empty
+    let s = String::new();
+    let _ = s == " ";
+    let _ = s != " ";
+
+    let v = vec![0];
+    let _ = v == [0];
+    let _ = v != [0];
+}
diff --git a/tests/ui/comparison_to_empty.stderr b/tests/ui/comparison_to_empty.stderr
new file mode 100644
index 00000000000..f69d6bd5255
--- /dev/null
+++ b/tests/ui/comparison_to_empty.stderr
@@ -0,0 +1,28 @@
+error: comparison to empty slice
+  --> $DIR/comparison_to_empty.rs:8:13
+   |
+LL |     let _ = s == "";
+   |             ^^^^^^^ help: using `is_empty` is clearer and more explicit: `s.is_empty()`
+   |
+   = note: `-D clippy::comparison-to-empty` implied by `-D warnings`
+
+error: comparison to empty slice
+  --> $DIR/comparison_to_empty.rs:9:13
+   |
+LL |     let _ = s != "";
+   |             ^^^^^^^ help: using `!is_empty` is clearer and more explicit: `!s.is_empty()`
+
+error: comparison to empty slice
+  --> $DIR/comparison_to_empty.rs:12:13
+   |
+LL |     let _ = v == [];
+   |             ^^^^^^^ help: using `is_empty` is clearer and more explicit: `v.is_empty()`
+
+error: comparison to empty slice
+  --> $DIR/comparison_to_empty.rs:13:13
+   |
+LL |     let _ = v != [];
+   |             ^^^^^^^ help: using `!is_empty` is clearer and more explicit: `!v.is_empty()`
+
+error: aborting due to 4 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 7f7faa1ccf4683582563d2f7a63aba988cb24cc8 Mon Sep 17 00:00:00 2001
From: Urcra <urcra@urcra.com>
Date: Mon, 26 Oct 2020 00:51:18 +0100
Subject: Move implementation into len_zero.rs

---
 clippy_lints/src/comparison_to_empty.rs | 155 --------------------------------
 clippy_lints/src/len_zero.rs            |  84 ++++++++++++++++-
 clippy_lints/src/lib.rs                 |   8 +-
 3 files changed, 86 insertions(+), 161 deletions(-)
 delete mode 100644 clippy_lints/src/comparison_to_empty.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/comparison_to_empty.rs b/clippy_lints/src/comparison_to_empty.rs
deleted file mode 100644
index 3b55336722c..00000000000
--- a/clippy_lints/src/comparison_to_empty.rs
+++ /dev/null
@@ -1,155 +0,0 @@
-use crate::utils::{snippet_with_applicability, span_lint_and_sugg};
-use rustc_ast::ast::LitKind;
-use rustc_errors::Applicability;
-use rustc_hir::def_id::DefId;
-use rustc_hir::{BinOpKind, Expr, ExprKind, ItemKind, TraitItemRef};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::source_map::{Span, Spanned};
-
-declare_clippy_lint! {
-    /// **What it does:**
-    ///
-    /// **Why is this bad?**
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
-    /// ```rust
-    /// // example code where clippy issues a warning
-    /// ```
-    /// Use instead:
-    /// ```rust
-    /// // example code which does not raise clippy warning
-    /// ```
-    pub COMPARISON_TO_EMPTY,
-    style,
-    "default lint description"
-}
-
-declare_lint_pass!(ComparisonToEmpty => [COMPARISON_TO_EMPTY]);
-
-impl LateLintPass<'_> for ComparisonToEmpty {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if expr.span.from_expansion() {
-            return;
-        }
-
-        if let ExprKind::Binary(Spanned { node: cmp, .. }, ref left, ref right) = expr.kind {
-            match cmp {
-                BinOpKind::Eq => {
-                    check_cmp(cx, expr.span, left, right, "", 0); // len == 0
-                    check_cmp(cx, expr.span, right, left, "", 0); // 0 == len
-                },
-                BinOpKind::Ne => {
-                    check_cmp(cx, expr.span, left, right, "!", 0); // len != 0
-                    check_cmp(cx, expr.span, right, left, "!", 0); // 0 != len
-                },
-                BinOpKind::Gt => {
-                    check_cmp(cx, expr.span, left, right, "!", 0); // len > 0
-                    check_cmp(cx, expr.span, right, left, "", 1); // 1 > len
-                },
-                BinOpKind::Lt => {
-                    check_cmp(cx, expr.span, left, right, "", 1); // len < 1
-                    check_cmp(cx, expr.span, right, left, "!", 0); // 0 < len
-                },
-                BinOpKind::Ge => check_cmp(cx, expr.span, left, right, "!", 1), // len >= 1
-                BinOpKind::Le => check_cmp(cx, expr.span, right, left, "!", 1), // 1 <= len
-                _ => (),
-            }
-        }
-    }
-
-}
-
-
-fn check_cmp(cx: &LateContext<'_>, span: Span, lit1: &Expr<'_>, lit2: &Expr<'_>, op: &str, compare_to: u32) {
-    check_empty_expr(cx, span, lit1, lit2, op)
-}
-
-fn check_empty_expr(
-    cx: &LateContext<'_>,
-    span: Span,
-    lit1: &Expr<'_>,
-    lit2: &Expr<'_>,
-    op: &str
-) {
-    if (is_empty_array(lit2) || is_empty_string(lit2)) && has_is_empty(cx, lit1) {
-        let mut applicability = Applicability::MachineApplicable;
-        span_lint_and_sugg(
-            cx,
-            COMPARISON_TO_EMPTY,
-            span,
-            &format!("comparison to empty slice"),
-            &format!("using `{}is_empty` is clearer and more explicit", op),
-            format!(
-                "{}{}.is_empty()",
-                op,
-                snippet_with_applicability(cx, lit1.span, "_", &mut applicability)
-            ),
-            applicability,
-        );
-    }
-}
-
-fn is_empty_string(expr: &Expr<'_>) -> bool {
-    if let ExprKind::Lit(ref lit) = expr.kind {
-        if let LitKind::Str(lit, _) = lit.node {
-            let lit = lit.as_str();
-            return lit == "";
-        }
-    }
-    false
-}
-
-fn is_empty_array(expr: &Expr<'_>) -> bool {
-    if let ExprKind::Array(ref arr) = expr.kind {
-        return arr.is_empty();
-    }
-    false
-}
-
-
-/// Checks if this type has an `is_empty` method.
-fn has_is_empty(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-    /// Gets an `AssocItem` and return true if it matches `is_empty(self)`.
-    fn is_is_empty(cx: &LateContext<'_>, item: &ty::AssocItem) -> bool {
-        if let ty::AssocKind::Fn = item.kind {
-            if item.ident.name.as_str() == "is_empty" {
-                let sig = cx.tcx.fn_sig(item.def_id);
-                let ty = sig.skip_binder();
-                ty.inputs().len() == 1
-            } else {
-                false
-            }
-        } else {
-            false
-        }
-    }
-
-    /// Checks the inherent impl's items for an `is_empty(self)` method.
-    fn has_is_empty_impl(cx: &LateContext<'_>, id: DefId) -> bool {
-        cx.tcx.inherent_impls(id).iter().any(|imp| {
-            cx.tcx
-                .associated_items(*imp)
-                .in_definition_order()
-                .any(|item| is_is_empty(cx, &item))
-        })
-    }
-
-    let ty = &cx.typeck_results().expr_ty(expr).peel_refs();
-    match ty.kind() {
-        ty::Dynamic(ref tt, ..) => tt.principal().map_or(false, |principal| {
-            cx.tcx
-                .associated_items(principal.def_id())
-                .in_definition_order()
-                .any(|item| is_is_empty(cx, &item))
-        }),
-        ty::Projection(ref proj) => has_is_empty_impl(cx, proj.item_def_id),
-        ty::Adt(id, _) => has_is_empty_impl(cx, id.did),
-        ty::Array(..) | ty::Slice(..) | ty::Str => true,
-        _ => false,
-    }
-}
diff --git a/clippy_lints/src/len_zero.rs b/clippy_lints/src/len_zero.rs
index c9c4891bb08..75e9c5c973b 100644
--- a/clippy_lints/src/len_zero.rs
+++ b/clippy_lints/src/len_zero.rs
@@ -68,7 +68,45 @@ declare_clippy_lint! {
     "traits or impls with a public `len` method but no corresponding `is_empty` method"
 }
 
-declare_lint_pass!(LenZero => [LEN_ZERO, LEN_WITHOUT_IS_EMPTY]);
+declare_clippy_lint! {
+    /// **What it does:** Checks for comparing to an empty slice such as "" or [],`
+    /// and suggests using `.is_empty()` where applicable.
+    ///
+    /// **Why is this bad?** Some structures can answer `.is_empty()` much faster
+    /// than checking for equality. So it is good to get into the habit of using
+    /// `.is_empty()`, and having it is cheap.
+    /// Besides, it makes the intent clearer than a manual comparison in some contexts.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```ignore
+    /// if s == "" {
+    ///     ..
+    /// }
+
+    /// if arr == [] {
+    ///     ..
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```ignore
+    /// if s.is_empty() {
+    ///     ..
+    /// }
+
+    /// if arr.is_empty() {
+    ///     ..
+    /// }
+    /// ```
+    pub COMPARISON_TO_EMPTY,
+    style,
+    "default lint description"
+}
+
+
+declare_lint_pass!(LenZero => [LEN_ZERO, LEN_WITHOUT_IS_EMPTY, COMPARISON_TO_EMPTY]);
 
 impl<'tcx> LateLintPass<'tcx> for LenZero {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
@@ -221,6 +259,8 @@ fn check_cmp(cx: &LateContext<'_>, span: Span, method: &Expr<'_>, lit: &Expr<'_>
         }
 
         check_len(cx, span, method_path.ident.name, args, &lit.node, op, compare_to)
+    } else {
+        check_empty_expr(cx, span, method, lit, op)
     }
 }
 
@@ -258,6 +298,48 @@ fn check_len(
     }
 }
 
+fn check_empty_expr(
+    cx: &LateContext<'_>,
+    span: Span,
+    lit1: &Expr<'_>,
+    lit2: &Expr<'_>,
+    op: &str
+) {
+    if (is_empty_array(lit2) || is_empty_string(lit2)) && has_is_empty(cx, lit1) {
+        let mut applicability = Applicability::MachineApplicable;
+        span_lint_and_sugg(
+            cx,
+            COMPARISON_TO_EMPTY,
+            span,
+            &format!("comparison to empty slice"),
+            &format!("using `{}is_empty` is clearer and more explicit", op),
+            format!(
+                "{}{}.is_empty()",
+                op,
+                snippet_with_applicability(cx, lit1.span, "_", &mut applicability)
+            ),
+            applicability,
+        );
+    }
+}
+
+fn is_empty_string(expr: &Expr<'_>) -> bool {
+    if let ExprKind::Lit(ref lit) = expr.kind {
+        if let LitKind::Str(lit, _) = lit.node {
+            let lit = lit.as_str();
+            return lit == "";
+        }
+    }
+    false
+}
+
+fn is_empty_array(expr: &Expr<'_>) -> bool {
+    if let ExprKind::Array(ref arr) = expr.kind {
+        return arr.is_empty();
+    }
+    false
+}
+
 /// Checks if this type has an `is_empty` method.
 fn has_is_empty(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
     /// Gets an `AssocItem` and return true if it matches `is_empty(self)`.
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 75629e13a8e..3ad2e1e9d57 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -171,7 +171,6 @@ mod checked_conversions;
 mod cognitive_complexity;
 mod collapsible_if;
 mod comparison_chain;
-mod comparison_to_empty;
 mod copies;
 mod copy_iterator;
 mod create_dir;
@@ -524,7 +523,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &cognitive_complexity::COGNITIVE_COMPLEXITY,
         &collapsible_if::COLLAPSIBLE_IF,
         &comparison_chain::COMPARISON_CHAIN,
-        &comparison_to_empty::COMPARISON_TO_EMPTY,
+        &len_zero::COMPARISON_TO_EMPTY,
         &copies::IFS_SAME_COND,
         &copies::IF_SAME_THEN_ELSE,
         &copies::MATCH_SAME_ARMS,
@@ -1141,7 +1140,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(move || box disallowed_method::DisallowedMethod::new(&disallowed_methods));
     store.register_early_pass(|| box asm_syntax::InlineAsmX86AttSyntax);
     store.register_early_pass(|| box asm_syntax::InlineAsmX86IntelSyntax);
-    store.register_late_pass(|| box comparison_to_empty::ComparisonToEmpty);
 
 
     store.register_group(true, "clippy::restriction", Some("clippy_restriction"), vec![
@@ -1302,7 +1300,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&bytecount::NAIVE_BYTECOUNT),
         LintId::of(&collapsible_if::COLLAPSIBLE_IF),
         LintId::of(&comparison_chain::COMPARISON_CHAIN),
-        LintId::of(&comparison_to_empty::COMPARISON_TO_EMPTY),
+        LintId::of(&len_zero::COMPARISON_TO_EMPTY),
         LintId::of(&copies::IFS_SAME_COND),
         LintId::of(&copies::IF_SAME_THEN_ELSE),
         LintId::of(&derive::DERIVE_HASH_XOR_EQ),
@@ -1559,7 +1557,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&blocks_in_if_conditions::BLOCKS_IN_IF_CONDITIONS),
         LintId::of(&collapsible_if::COLLAPSIBLE_IF),
         LintId::of(&comparison_chain::COMPARISON_CHAIN),
-        LintId::of(&comparison_to_empty::COMPARISON_TO_EMPTY),
+        LintId::of(&len_zero::COMPARISON_TO_EMPTY),
         LintId::of(&doc::MISSING_SAFETY_DOC),
         LintId::of(&doc::NEEDLESS_DOCTEST_MAIN),
         LintId::of(&enum_variants::ENUM_VARIANT_NAMES),
-- 
cgit 1.4.1-3-g733a5


From deecfb5d13325d05842fb610a7ef506be4ac6175 Mon Sep 17 00:00:00 2001
From: Urcra <urcra@urcra.com>
Date: Mon, 26 Oct 2020 01:02:10 +0100
Subject: Add description to lint

---
 clippy_lints/src/len_zero.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/len_zero.rs b/clippy_lints/src/len_zero.rs
index 75e9c5c973b..9eba3750d2a 100644
--- a/clippy_lints/src/len_zero.rs
+++ b/clippy_lints/src/len_zero.rs
@@ -102,7 +102,7 @@ declare_clippy_lint! {
     /// ```
     pub COMPARISON_TO_EMPTY,
     style,
-    "default lint description"
+    "checking `x == \"\"` or `x == []` (or similar) when `.is_empty()` could be used instead"
 }
 
 
-- 
cgit 1.4.1-3-g733a5


From 4cf5b5ff7018abc91d0d0a81c73b3405228811a9 Mon Sep 17 00:00:00 2001
From: Urcra <urcra@urcra.com>
Date: Mon, 26 Oct 2020 01:21:34 +0100
Subject: Run update lints

---
 clippy_lints/src/lib.rs | 6 +++---
 src/lintlist/mod.rs     | 4 ++--
 2 files changed, 5 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 3ad2e1e9d57..8dff5ae42c3 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -523,7 +523,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &cognitive_complexity::COGNITIVE_COMPLEXITY,
         &collapsible_if::COLLAPSIBLE_IF,
         &comparison_chain::COMPARISON_CHAIN,
-        &len_zero::COMPARISON_TO_EMPTY,
         &copies::IFS_SAME_COND,
         &copies::IF_SAME_THEN_ELSE,
         &copies::MATCH_SAME_ARMS,
@@ -609,6 +608,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &large_const_arrays::LARGE_CONST_ARRAYS,
         &large_enum_variant::LARGE_ENUM_VARIANT,
         &large_stack_arrays::LARGE_STACK_ARRAYS,
+        &len_zero::COMPARISON_TO_EMPTY,
         &len_zero::LEN_WITHOUT_IS_EMPTY,
         &len_zero::LEN_ZERO,
         &let_if_seq::USELESS_LET_IF_SEQ,
@@ -1300,7 +1300,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&bytecount::NAIVE_BYTECOUNT),
         LintId::of(&collapsible_if::COLLAPSIBLE_IF),
         LintId::of(&comparison_chain::COMPARISON_CHAIN),
-        LintId::of(&len_zero::COMPARISON_TO_EMPTY),
         LintId::of(&copies::IFS_SAME_COND),
         LintId::of(&copies::IF_SAME_THEN_ELSE),
         LintId::of(&derive::DERIVE_HASH_XOR_EQ),
@@ -1350,6 +1349,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&int_plus_one::INT_PLUS_ONE),
         LintId::of(&large_const_arrays::LARGE_CONST_ARRAYS),
         LintId::of(&large_enum_variant::LARGE_ENUM_VARIANT),
+        LintId::of(&len_zero::COMPARISON_TO_EMPTY),
         LintId::of(&len_zero::LEN_WITHOUT_IS_EMPTY),
         LintId::of(&len_zero::LEN_ZERO),
         LintId::of(&let_underscore::LET_UNDERSCORE_LOCK),
@@ -1557,7 +1557,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&blocks_in_if_conditions::BLOCKS_IN_IF_CONDITIONS),
         LintId::of(&collapsible_if::COLLAPSIBLE_IF),
         LintId::of(&comparison_chain::COMPARISON_CHAIN),
-        LintId::of(&len_zero::COMPARISON_TO_EMPTY),
         LintId::of(&doc::MISSING_SAFETY_DOC),
         LintId::of(&doc::NEEDLESS_DOCTEST_MAIN),
         LintId::of(&enum_variants::ENUM_VARIANT_NAMES),
@@ -1573,6 +1572,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&functions::RESULT_UNIT_ERR),
         LintId::of(&if_let_some_result::IF_LET_SOME_RESULT),
         LintId::of(&inherent_to_string::INHERENT_TO_STRING),
+        LintId::of(&len_zero::COMPARISON_TO_EMPTY),
         LintId::of(&len_zero::LEN_WITHOUT_IS_EMPTY),
         LintId::of(&len_zero::LEN_ZERO),
         LintId::of(&literal_representation::INCONSISTENT_DIGIT_GROUPING),
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index c2b2236bc66..695c7408e23 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -294,9 +294,9 @@ vec![
     Lint {
         name: "comparison_to_empty",
         group: "style",
-        desc: "default lint description",
+        desc: "checking `x == \"\"` or `x == []` (or similar) when `.is_empty()` could be used instead",
         deprecation: None,
-        module: "comparison_to_empty",
+        module: "len_zero",
     },
     Lint {
         name: "copy_iterator",
-- 
cgit 1.4.1-3-g733a5


From 4532dd9e431e3df719941514ef2a3dbce7fff962 Mon Sep 17 00:00:00 2001
From: Urcra <urcra@urcra.com>
Date: Mon, 26 Oct 2020 01:31:13 +0100
Subject: run cargo fmt

---
 clippy_lints/src/len_zero.rs | 9 +--------
 1 file changed, 1 insertion(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/len_zero.rs b/clippy_lints/src/len_zero.rs
index 9eba3750d2a..542b4afcdf9 100644
--- a/clippy_lints/src/len_zero.rs
+++ b/clippy_lints/src/len_zero.rs
@@ -105,7 +105,6 @@ declare_clippy_lint! {
     "checking `x == \"\"` or `x == []` (or similar) when `.is_empty()` could be used instead"
 }
 
-
 declare_lint_pass!(LenZero => [LEN_ZERO, LEN_WITHOUT_IS_EMPTY, COMPARISON_TO_EMPTY]);
 
 impl<'tcx> LateLintPass<'tcx> for LenZero {
@@ -298,13 +297,7 @@ fn check_len(
     }
 }
 
-fn check_empty_expr(
-    cx: &LateContext<'_>,
-    span: Span,
-    lit1: &Expr<'_>,
-    lit2: &Expr<'_>,
-    op: &str
-) {
+fn check_empty_expr(cx: &LateContext<'_>, span: Span, lit1: &Expr<'_>, lit2: &Expr<'_>, op: &str) {
     if (is_empty_array(lit2) || is_empty_string(lit2)) && has_is_empty(cx, lit1) {
         let mut applicability = Applicability::MachineApplicable;
         span_lint_and_sugg(
-- 
cgit 1.4.1-3-g733a5


From 45aa3ef8dde9741c82bd3c98405d0b0464a8b79f Mon Sep 17 00:00:00 2001
From: Urcra <urcra@urcra.com>
Date: Mon, 26 Oct 2020 01:55:44 +0100
Subject: Remove unnecesary format

---
 clippy_lints/src/len_zero.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/len_zero.rs b/clippy_lints/src/len_zero.rs
index 542b4afcdf9..d0e7dea4a54 100644
--- a/clippy_lints/src/len_zero.rs
+++ b/clippy_lints/src/len_zero.rs
@@ -304,7 +304,7 @@ fn check_empty_expr(cx: &LateContext<'_>, span: Span, lit1: &Expr<'_>, lit2: &Ex
             cx,
             COMPARISON_TO_EMPTY,
             span,
-            &format!("comparison to empty slice"),
+            "comparison to empty slice",
             &format!("using `{}is_empty` is clearer and more explicit", op),
             format!(
                 "{}{}.is_empty()",
-- 
cgit 1.4.1-3-g733a5


From f0cf3bdca198ead0e1d76115bf30a2eef72e8c58 Mon Sep 17 00:00:00 2001
From: HMPerson1 <hmperson1@gmail.com>
Date: Sun, 25 Oct 2020 21:20:57 -0400
Subject: Add lint for replacing `.map().collect()` with `.try_for_each()`

---
 CHANGELOG.md                            |  1 +
 clippy_lints/src/lib.rs                 |  3 ++
 clippy_lints/src/methods/mod.rs         | 59 +++++++++++++++++++++++++++++++++
 src/lintlist/mod.rs                     |  7 ++++
 tests/ui/map_collect_result_unit.fixed  | 16 +++++++++
 tests/ui/map_collect_result_unit.rs     | 16 +++++++++
 tests/ui/map_collect_result_unit.stderr | 16 +++++++++
 7 files changed, 118 insertions(+)
 create mode 100644 tests/ui/map_collect_result_unit.fixed
 create mode 100644 tests/ui/map_collect_result_unit.rs
 create mode 100644 tests/ui/map_collect_result_unit.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 25f3b5da198..287cf6bb725 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1802,6 +1802,7 @@ Released 2018-09-13
 [`manual_unwrap_or`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_unwrap_or
 [`many_single_char_names`]: https://rust-lang.github.io/rust-clippy/master/index.html#many_single_char_names
 [`map_clone`]: https://rust-lang.github.io/rust-clippy/master/index.html#map_clone
+[`map_collect_result_unit`]: https://rust-lang.github.io/rust-clippy/master/index.html#map_collect_result_unit
 [`map_entry`]: https://rust-lang.github.io/rust-clippy/master/index.html#map_entry
 [`map_err_ignore`]: https://rust-lang.github.io/rust-clippy/master/index.html#map_err_ignore
 [`map_flatten`]: https://rust-lang.github.io/rust-clippy/master/index.html#map_flatten
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 3be8bc0e36d..138d1ab9b50 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -697,6 +697,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &methods::ITER_NTH_ZERO,
         &methods::ITER_SKIP_NEXT,
         &methods::MANUAL_SATURATING_ARITHMETIC,
+        &methods::MAP_COLLECT_RESULT_UNIT,
         &methods::MAP_FLATTEN,
         &methods::MAP_UNWRAP_OR,
         &methods::NEW_RET_NO_SELF,
@@ -1420,6 +1421,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&methods::ITER_NTH_ZERO),
         LintId::of(&methods::ITER_SKIP_NEXT),
         LintId::of(&methods::MANUAL_SATURATING_ARITHMETIC),
+        LintId::of(&methods::MAP_COLLECT_RESULT_UNIT),
         LintId::of(&methods::NEW_RET_NO_SELF),
         LintId::of(&methods::OK_EXPECT),
         LintId::of(&methods::OPTION_AS_REF_DEREF),
@@ -1615,6 +1617,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&methods::ITER_NTH_ZERO),
         LintId::of(&methods::ITER_SKIP_NEXT),
         LintId::of(&methods::MANUAL_SATURATING_ARITHMETIC),
+        LintId::of(&methods::MAP_COLLECT_RESULT_UNIT),
         LintId::of(&methods::NEW_RET_NO_SELF),
         LintId::of(&methods::OK_EXPECT),
         LintId::of(&methods::OPTION_MAP_OR_NONE),
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index c0824bacbc7..5f9bed90845 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1383,6 +1383,27 @@ declare_clippy_lint! {
     "using unnecessary lazy evaluation, which can be replaced with simpler eager evaluation"
 }
 
+declare_clippy_lint! {
+    /// **What it does:** Checks for usage of `_.map(_).collect::<Result<(),_>()`.
+    ///
+    /// **Why is this bad?** Using `try_for_each` instead is more readable and idiomatic.
+    ///
+    /// **Known problems:** None
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// (0..3).map(|t| Err(t)).collect::<Result<(), _>>();
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// (0..3).try_for_each(|t| Err(t));
+    /// ```
+    pub MAP_COLLECT_RESULT_UNIT,
+    style,
+    "using `.map(_).collect::<Result<(),_>()`, which can be replaced with `try_for_each`"
+}
+
 declare_lint_pass!(Methods => [
     UNWRAP_USED,
     EXPECT_USED,
@@ -1433,6 +1454,7 @@ declare_lint_pass!(Methods => [
     FILETYPE_IS_FILE,
     OPTION_AS_REF_DEREF,
     UNNECESSARY_LAZY_EVALUATIONS,
+    MAP_COLLECT_RESULT_UNIT,
 ]);
 
 impl<'tcx> LateLintPass<'tcx> for Methods {
@@ -1515,6 +1537,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             ["unwrap_or_else", ..] => unnecessary_lazy_eval::lint(cx, expr, arg_lists[0], "unwrap_or"),
             ["get_or_insert_with", ..] => unnecessary_lazy_eval::lint(cx, expr, arg_lists[0], "get_or_insert"),
             ["ok_or_else", ..] => unnecessary_lazy_eval::lint(cx, expr, arg_lists[0], "ok_or"),
+            ["collect", "map"] => lint_map_collect(cx, expr, arg_lists[1], arg_lists[0]),
             _ => {},
         }
 
@@ -3501,6 +3524,42 @@ fn lint_option_as_ref_deref<'tcx>(
     }
 }
 
+fn lint_map_collect(
+    cx: &LateContext<'_>,
+    expr: &hir::Expr<'_>,
+    map_args: &[hir::Expr<'_>],
+    collect_args: &[hir::Expr<'_>],
+) {
+    if_chain! {
+        // called on Iterator
+        if let [map_expr] = collect_args;
+        if match_trait_method(cx, map_expr, &paths::ITERATOR);
+        // return of collect `Result<(),_>`
+        let collect_ret_ty = cx.typeck_results().expr_ty(expr);
+        if is_type_diagnostic_item(cx, collect_ret_ty, sym!(result_type));
+        if let ty::Adt(_, substs) = collect_ret_ty.kind();
+        if let Some(result_t) = substs.types().next();
+        if result_t.is_unit();
+        // get parts for snippet
+        if let [iter, map_fn] = map_args;
+        then {
+            span_lint_and_sugg(
+                cx,
+                MAP_COLLECT_RESULT_UNIT,
+                expr.span,
+                "`.map().collect()` can be replaced with `.try_for_each()`",
+                "try this",
+                format!(
+                    "{}.try_for_each({})",
+                    snippet(cx, iter.span, ".."),
+                    snippet(cx, map_fn.span, "..")
+                ),
+                Applicability::MachineApplicable,
+            );
+        }
+    }
+}
+
 /// Given a `Result<T, E>` type, return its error type (`E`).
 fn get_error_type<'a>(cx: &LateContext<'_>, ty: Ty<'a>) -> Option<Ty<'a>> {
     match ty.kind() {
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index 6272ce45efb..d9b3e5c17f4 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -1222,6 +1222,13 @@ vec![
         deprecation: None,
         module: "map_clone",
     },
+    Lint {
+        name: "map_collect_result_unit",
+        group: "style",
+        desc: "using `.map(_).collect::<Result<(),_>()`, which can be replaced with `try_for_each`",
+        deprecation: None,
+        module: "methods",
+    },
     Lint {
         name: "map_entry",
         group: "perf",
diff --git a/tests/ui/map_collect_result_unit.fixed b/tests/ui/map_collect_result_unit.fixed
new file mode 100644
index 00000000000..e66c9cc2420
--- /dev/null
+++ b/tests/ui/map_collect_result_unit.fixed
@@ -0,0 +1,16 @@
+// run-rustfix
+#![warn(clippy::map_collect_result_unit)]
+
+fn main() {
+    {
+        let _ = (0..3).try_for_each(|t| Err(t + 1));
+        let _: Result<(), _> = (0..3).try_for_each(|t| Err(t + 1));
+
+        let _ = (0..3).try_for_each(|t| Err(t + 1));
+    }
+}
+
+fn _ignore() {
+    let _ = (0..3).map(|t| Err(t + 1)).collect::<Result<Vec<i32>, _>>();
+    let _ = (0..3).map(|t| Err(t + 1)).collect::<Vec<Result<(), _>>>();
+}
diff --git a/tests/ui/map_collect_result_unit.rs b/tests/ui/map_collect_result_unit.rs
new file mode 100644
index 00000000000..6f08f4c3c53
--- /dev/null
+++ b/tests/ui/map_collect_result_unit.rs
@@ -0,0 +1,16 @@
+// run-rustfix
+#![warn(clippy::map_collect_result_unit)]
+
+fn main() {
+    {
+        let _ = (0..3).map(|t| Err(t + 1)).collect::<Result<(), _>>();
+        let _: Result<(), _> = (0..3).map(|t| Err(t + 1)).collect();
+
+        let _ = (0..3).try_for_each(|t| Err(t + 1));
+    }
+}
+
+fn _ignore() {
+    let _ = (0..3).map(|t| Err(t + 1)).collect::<Result<Vec<i32>, _>>();
+    let _ = (0..3).map(|t| Err(t + 1)).collect::<Vec<Result<(), _>>>();
+}
diff --git a/tests/ui/map_collect_result_unit.stderr b/tests/ui/map_collect_result_unit.stderr
new file mode 100644
index 00000000000..8b06e13baa6
--- /dev/null
+++ b/tests/ui/map_collect_result_unit.stderr
@@ -0,0 +1,16 @@
+error: `.map().collect()` can be replaced with `.try_for_each()`
+  --> $DIR/map_collect_result_unit.rs:6:17
+   |
+LL |         let _ = (0..3).map(|t| Err(t + 1)).collect::<Result<(), _>>();
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `(0..3).try_for_each(|t| Err(t + 1))`
+   |
+   = note: `-D clippy::map-collect-result-unit` implied by `-D warnings`
+
+error: `.map().collect()` can be replaced with `.try_for_each()`
+  --> $DIR/map_collect_result_unit.rs:7:32
+   |
+LL |         let _: Result<(), _> = (0..3).map(|t| Err(t + 1)).collect();
+   |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `(0..3).try_for_each(|t| Err(t + 1))`
+
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From bab338685f42e4b184c0f645c3a1a24a79890e17 Mon Sep 17 00:00:00 2001
From: ThibsG <Thibs@debian.com>
Date: Sat, 24 Oct 2020 10:50:11 +0200
Subject: No lint in external macro for `toplevel_ref_arg`

---
 clippy_lints/src/misc.rs                     | 15 +++++++++++----
 tests/ui/auxiliary/macro_rules.rs            | 14 ++++++++++++++
 tests/ui/toplevel_ref_arg.fixed              | 21 +++++++++++++++++++++
 tests/ui/toplevel_ref_arg.rs                 | 21 +++++++++++++++++++++
 tests/ui/toplevel_ref_arg.stderr             | 23 +++++++++++++++++------
 tests/ui/toplevel_ref_arg_non_rustfix.rs     | 22 ++++++++++++++++++++++
 tests/ui/toplevel_ref_arg_non_rustfix.stderr | 15 +++++++++++++--
 7 files changed, 119 insertions(+), 12 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/misc.rs b/clippy_lints/src/misc.rs
index 909e79f661a..308e92057b7 100644
--- a/clippy_lints/src/misc.rs
+++ b/clippy_lints/src/misc.rs
@@ -7,6 +7,7 @@ use rustc_hir::{
     StmtKind, TyKind, UnOp,
 };
 use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::{self, Ty};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::hygiene::DesugaringKind;
@@ -271,13 +272,16 @@ impl<'tcx> LateLintPass<'tcx> for MiscLints {
         k: FnKind<'tcx>,
         decl: &'tcx FnDecl<'_>,
         body: &'tcx Body<'_>,
-        _: Span,
+        span: Span,
         _: HirId,
     ) {
         if let FnKind::Closure(_) = k {
             // Does not apply to closures
             return;
         }
+        if in_external_macro(cx.tcx.sess, span) {
+            return;
+        }
         for arg in iter_input_pats(decl, body) {
             if let PatKind::Binding(BindingAnnotation::Ref | BindingAnnotation::RefMut, ..) = arg.pat.kind {
                 span_lint(
@@ -293,13 +297,16 @@ impl<'tcx> LateLintPass<'tcx> for MiscLints {
 
     fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) {
         if_chain! {
+            if !in_external_macro(cx.tcx.sess, stmt.span);
             if let StmtKind::Local(ref local) = stmt.kind;
             if let PatKind::Binding(an, .., name, None) = local.pat.kind;
             if let Some(ref init) = local.init;
             if !higher::is_from_for_desugar(local);
             then {
                 if an == BindingAnnotation::Ref || an == BindingAnnotation::RefMut {
-                    let sugg_init = if init.span.from_expansion() {
+                    // use the macro callsite when the init span (but not the whole local span)
+                    // comes from an expansion like `vec![1, 2, 3]` in `let ref _ = vec![1, 2, 3];`
+                    let sugg_init = if init.span.from_expansion() && !local.span.from_expansion() {
                         Sugg::hir_with_macro_callsite(cx, init, "..")
                     } else {
                         Sugg::hir(cx, init, "..")
@@ -310,7 +317,7 @@ impl<'tcx> LateLintPass<'tcx> for MiscLints {
                         ("", sugg_init.addr())
                     };
                     let tyopt = if let Some(ref ty) = local.ty {
-                        format!(": &{mutopt}{ty}", mutopt=mutopt, ty=snippet(cx, ty.span, "_"))
+                        format!(": &{mutopt}{ty}", mutopt=mutopt, ty=snippet(cx, ty.span, ".."))
                     } else {
                         String::new()
                     };
@@ -326,7 +333,7 @@ impl<'tcx> LateLintPass<'tcx> for MiscLints {
                                 "try",
                                 format!(
                                     "let {name}{tyopt} = {initref};",
-                                    name=snippet(cx, name.span, "_"),
+                                    name=snippet(cx, name.span, ".."),
                                     tyopt=tyopt,
                                     initref=initref,
                                 ),
diff --git a/tests/ui/auxiliary/macro_rules.rs b/tests/ui/auxiliary/macro_rules.rs
index 0bbb9534928..93303865e17 100644
--- a/tests/ui/auxiliary/macro_rules.rs
+++ b/tests/ui/auxiliary/macro_rules.rs
@@ -56,3 +56,17 @@ macro_rules! option_env_unwrap_external {
         option_env!($env).expect($message)
     };
 }
+
+#[macro_export]
+macro_rules! ref_arg_binding {
+    () => {
+        let ref _y = 42;
+    };
+}
+
+#[macro_export]
+macro_rules! ref_arg_function {
+    () => {
+        fn fun_example(ref _x: usize) {}
+    };
+}
diff --git a/tests/ui/toplevel_ref_arg.fixed b/tests/ui/toplevel_ref_arg.fixed
index 33605aca019..b129d95c560 100644
--- a/tests/ui/toplevel_ref_arg.fixed
+++ b/tests/ui/toplevel_ref_arg.fixed
@@ -1,7 +1,17 @@
 // run-rustfix
+// aux-build:macro_rules.rs
 
 #![warn(clippy::toplevel_ref_arg)]
 
+#[macro_use]
+extern crate macro_rules;
+
+macro_rules! gen_binding {
+    () => {
+        let _y = &42;
+    };
+}
+
 fn main() {
     // Closures should not warn
     let y = |ref x| println!("{:?}", x);
@@ -26,4 +36,15 @@ fn main() {
 
     // ok
     for ref _x in 0..10 {}
+
+    // lint in macro
+    #[allow(unused)]
+    {
+        gen_binding!();
+    }
+
+    // do not lint in external macro
+    {
+        ref_arg_binding!();
+    }
 }
diff --git a/tests/ui/toplevel_ref_arg.rs b/tests/ui/toplevel_ref_arg.rs
index 59759f11893..73eb4ff7306 100644
--- a/tests/ui/toplevel_ref_arg.rs
+++ b/tests/ui/toplevel_ref_arg.rs
@@ -1,7 +1,17 @@
 // run-rustfix
+// aux-build:macro_rules.rs
 
 #![warn(clippy::toplevel_ref_arg)]
 
+#[macro_use]
+extern crate macro_rules;
+
+macro_rules! gen_binding {
+    () => {
+        let ref _y = 42;
+    };
+}
+
 fn main() {
     // Closures should not warn
     let y = |ref x| println!("{:?}", x);
@@ -26,4 +36,15 @@ fn main() {
 
     // ok
     for ref _x in 0..10 {}
+
+    // lint in macro
+    #[allow(unused)]
+    {
+        gen_binding!();
+    }
+
+    // do not lint in external macro
+    {
+        ref_arg_binding!();
+    }
 }
diff --git a/tests/ui/toplevel_ref_arg.stderr b/tests/ui/toplevel_ref_arg.stderr
index 19d69496709..15cb933fedc 100644
--- a/tests/ui/toplevel_ref_arg.stderr
+++ b/tests/ui/toplevel_ref_arg.stderr
@@ -1,5 +1,5 @@
 error: `ref` on an entire `let` pattern is discouraged, take a reference with `&` instead
-  --> $DIR/toplevel_ref_arg.rs:10:9
+  --> $DIR/toplevel_ref_arg.rs:20:9
    |
 LL |     let ref _x = 1;
    |     ----^^^^^^----- help: try: `let _x = &1;`
@@ -7,28 +7,39 @@ LL |     let ref _x = 1;
    = note: `-D clippy::toplevel-ref-arg` implied by `-D warnings`
 
 error: `ref` on an entire `let` pattern is discouraged, take a reference with `&` instead
-  --> $DIR/toplevel_ref_arg.rs:12:9
+  --> $DIR/toplevel_ref_arg.rs:22:9
    |
 LL |     let ref _y: (&_, u8) = (&1, 2);
    |     ----^^^^^^--------------------- help: try: `let _y: &(&_, u8) = &(&1, 2);`
 
 error: `ref` on an entire `let` pattern is discouraged, take a reference with `&` instead
-  --> $DIR/toplevel_ref_arg.rs:14:9
+  --> $DIR/toplevel_ref_arg.rs:24:9
    |
 LL |     let ref _z = 1 + 2;
    |     ----^^^^^^--------- help: try: `let _z = &(1 + 2);`
 
 error: `ref` on an entire `let` pattern is discouraged, take a reference with `&` instead
-  --> $DIR/toplevel_ref_arg.rs:16:9
+  --> $DIR/toplevel_ref_arg.rs:26:9
    |
 LL |     let ref mut _z = 1 + 2;
    |     ----^^^^^^^^^^--------- help: try: `let _z = &mut (1 + 2);`
 
 error: `ref` on an entire `let` pattern is discouraged, take a reference with `&` instead
-  --> $DIR/toplevel_ref_arg.rs:21:9
+  --> $DIR/toplevel_ref_arg.rs:31:9
    |
 LL |     let ref _x = vec![1, 2, 3];
    |     ----^^^^^^----------------- help: try: `let _x = &vec![1, 2, 3];`
 
-error: aborting due to 5 previous errors
+error: `ref` on an entire `let` pattern is discouraged, take a reference with `&` instead
+  --> $DIR/toplevel_ref_arg.rs:11:13
+   |
+LL |         let ref _y = 42;
+   |         ----^^^^^^------ help: try: `let _y = &42;`
+...
+LL |         gen_binding!();
+   |         --------------- in this macro invocation
+   |
+   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: aborting due to 6 previous errors
 
diff --git a/tests/ui/toplevel_ref_arg_non_rustfix.rs b/tests/ui/toplevel_ref_arg_non_rustfix.rs
index 42cac2ba4de..1a493fbce0e 100644
--- a/tests/ui/toplevel_ref_arg_non_rustfix.rs
+++ b/tests/ui/toplevel_ref_arg_non_rustfix.rs
@@ -1,11 +1,33 @@
+// aux-build:macro_rules.rs
+
 #![warn(clippy::toplevel_ref_arg)]
 #![allow(unused)]
 
+#[macro_use]
+extern crate macro_rules;
+
 fn the_answer(ref mut x: u8) {
     *x = 42;
 }
 
+macro_rules! gen_function {
+    () => {
+        fn fun_example(ref _x: usize) {}
+    };
+}
+
 fn main() {
     let mut x = 0;
     the_answer(x);
+
+    // lint in macro
+    #[allow(unused)]
+    {
+        gen_function!();
+    }
+
+    // do not lint in external macro
+    {
+        ref_arg_function!();
+    }
 }
diff --git a/tests/ui/toplevel_ref_arg_non_rustfix.stderr b/tests/ui/toplevel_ref_arg_non_rustfix.stderr
index 295e2f35608..6c36141a58c 100644
--- a/tests/ui/toplevel_ref_arg_non_rustfix.stderr
+++ b/tests/ui/toplevel_ref_arg_non_rustfix.stderr
@@ -1,10 +1,21 @@
 error: `ref` directly on a function argument is ignored. Consider using a reference type instead.
-  --> $DIR/toplevel_ref_arg_non_rustfix.rs:4:15
+  --> $DIR/toplevel_ref_arg_non_rustfix.rs:9:15
    |
 LL | fn the_answer(ref mut x: u8) {
    |               ^^^^^^^^^
    |
    = note: `-D clippy::toplevel-ref-arg` implied by `-D warnings`
 
-error: aborting due to previous error
+error: `ref` directly on a function argument is ignored. Consider using a reference type instead.
+  --> $DIR/toplevel_ref_arg_non_rustfix.rs:15:24
+   |
+LL |         fn fun_example(ref _x: usize) {}
+   |                        ^^^^^^
+...
+LL |         gen_function!();
+   |         ---------------- in this macro invocation
+   |
+   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: aborting due to 2 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 2911d9c7de4c0acf7bdd6a2d6983d1fccbeb6a69 Mon Sep 17 00:00:00 2001
From: ThibsG <Thibs@debian.com>
Date: Sun, 18 Oct 2020 13:09:06 +0200
Subject: Use better placeholders for some methods lint messages

---
 clippy_lints/src/methods/mod.rs                  | 58 ++++++++++++------------
 clippy_lints/src/methods/option_map_unwrap_or.rs |  8 ++--
 tests/ui/filter_map_next.stderr                  |  4 +-
 tests/ui/filter_methods.stderr                   |  8 ++--
 tests/ui/find_map.stderr                         |  4 +-
 tests/ui/iter_skip_next.stderr                   |  8 ++--
 tests/ui/map_unwrap_or.stderr                    | 40 ++++++++--------
 tests/ui/methods.stderr                          |  4 +-
 tests/ui/option_map_or_none.stderr               |  4 +-
 tests/ui/skip_while_next.stderr                  |  8 ++--
 10 files changed, 73 insertions(+), 73 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index c0824bacbc7..fc77cd52b8f 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1748,7 +1748,7 @@ fn lint_or_fun_call<'tcx>(
                     "try this",
                     format!(
                         "{}.unwrap_or_default()",
-                        snippet_with_applicability(cx, self_expr.span, "_", &mut applicability)
+                        snippet_with_applicability(cx, self_expr.span, "..", &mut applicability)
                     ),
                     applicability,
                 );
@@ -2155,7 +2155,7 @@ fn lint_clone_on_ref_ptr(cx: &LateContext<'_>, expr: &hir::Expr<'_>, arg: &hir::
             return;
         };
 
-        let snippet = snippet_with_macro_callsite(cx, arg.span, "_");
+        let snippet = snippet_with_macro_callsite(cx, arg.span, "..");
 
         span_lint_and_sugg(
             cx,
@@ -2191,9 +2191,9 @@ fn lint_string_extend(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::E
             "try this",
             format!(
                 "{}.push_str({}{})",
-                snippet_with_applicability(cx, args[0].span, "_", &mut applicability),
+                snippet_with_applicability(cx, args[0].span, "..", &mut applicability),
                 ref_str,
-                snippet_with_applicability(cx, target.span, "_", &mut applicability)
+                snippet_with_applicability(cx, target.span, "..", &mut applicability)
             ),
             applicability,
         );
@@ -2460,7 +2460,7 @@ fn lint_get_unwrap<'tcx>(cx: &LateContext<'tcx>, expr: &hir::Expr<'_>, get_args:
     let mut applicability = Applicability::MachineApplicable;
     let expr_ty = cx.typeck_results().expr_ty(&get_args[0]);
     let get_args_str = if get_args.len() > 1 {
-        snippet_with_applicability(cx, get_args[1].span, "_", &mut applicability)
+        snippet_with_applicability(cx, get_args[1].span, "..", &mut applicability)
     } else {
         return; // not linting on a .get().unwrap() chain or variant
     };
@@ -2520,7 +2520,7 @@ fn lint_get_unwrap<'tcx>(cx: &LateContext<'tcx>, expr: &hir::Expr<'_>, get_args:
         format!(
             "{}{}[{}]",
             borrow_str,
-            snippet_with_applicability(cx, get_args[0].span, "_", &mut applicability),
+            snippet_with_applicability(cx, get_args[0].span, "..", &mut applicability),
             get_args_str
         ),
         applicability,
@@ -2536,7 +2536,7 @@ fn lint_iter_skip_next(cx: &LateContext<'_>, expr: &hir::Expr<'_>, skip_args: &[
                 cx,
                 ITER_SKIP_NEXT,
                 expr.span.trim_start(caller.span).unwrap(),
-                "called `skip(x).next()` on an iterator",
+                "called `skip(..).next()` on an iterator",
                 "use `nth` instead",
                 hint,
                 Applicability::MachineApplicable,
@@ -2739,11 +2739,11 @@ fn lint_map_unwrap_or_else<'tcx>(
 
         // lint message
         let msg = if is_option {
-            "called `map(f).unwrap_or_else(g)` on an `Option` value. This can be done more directly by calling \
-            `map_or_else(g, f)` instead"
+            "called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling \
+            `map_or_else(<g>, <f>)` instead"
         } else {
-            "called `map(f).unwrap_or_else(g)` on a `Result` value. This can be done more directly by calling \
-            `.map_or_else(g, f)` instead"
+            "called `map(<f>).unwrap_or_else(<g>)` on a `Result` value. This can be done more directly by calling \
+            `.map_or_else(<g>, <f>)` instead"
         };
         // get snippets for args to map() and unwrap_or_else()
         let map_snippet = snippet(cx, map_args[1].span, "..");
@@ -2809,8 +2809,8 @@ fn lint_map_or_none<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, map
         if is_option {
             let self_snippet = snippet(cx, map_or_args[0].span, "..");
             let func_snippet = snippet(cx, map_or_args[2].span, "..");
-            let msg = "called `map_or(None, f)` on an `Option` value. This can be done more directly by calling \
-                       `and_then(f)` instead";
+            let msg = "called `map_or(None, ..)` on an `Option` value. This can be done more directly by calling \
+                       `and_then(..)` instead";
             (
                 OPTION_MAP_OR_NONE,
                 msg,
@@ -2848,8 +2848,8 @@ fn lint_map_or_none<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, map
 fn lint_filter_next<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, filter_args: &'tcx [hir::Expr<'_>]) {
     // lint if caller of `.filter().next()` is an Iterator
     if match_trait_method(cx, expr, &paths::ITERATOR) {
-        let msg = "called `filter(p).next()` on an `Iterator`. This is more succinctly expressed by calling \
-                   `.find(p)` instead.";
+        let msg = "called `filter(..).next()` on an `Iterator`. This is more succinctly expressed by calling \
+                   `.find(..)` instead.";
         let filter_snippet = snippet(cx, filter_args[1].span, "..");
         if filter_snippet.lines().count() <= 1 {
             // add note if not multi-line
@@ -2879,9 +2879,9 @@ fn lint_skip_while_next<'tcx>(
             cx,
             SKIP_WHILE_NEXT,
             expr.span,
-            "called `skip_while(p).next()` on an `Iterator`",
+            "called `skip_while(<p>).next()` on an `Iterator`",
             None,
-            "this is more succinctly expressed by calling `.find(!p)` instead",
+            "this is more succinctly expressed by calling `.find(!<p>)` instead",
         );
     }
 }
@@ -2895,7 +2895,7 @@ fn lint_filter_map<'tcx>(
 ) {
     // lint if caller of `.filter().map()` is an Iterator
     if match_trait_method(cx, expr, &paths::ITERATOR) {
-        let msg = "called `filter(p).map(q)` on an `Iterator`";
+        let msg = "called `filter(..).map(..)` on an `Iterator`";
         let hint = "this is more succinctly expressed by calling `.filter_map(..)` instead";
         span_lint_and_help(cx, FILTER_MAP, expr.span, msg, None, hint);
     }
@@ -2904,8 +2904,8 @@ fn lint_filter_map<'tcx>(
 /// lint use of `filter_map().next()` for `Iterators`
 fn lint_filter_map_next<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, filter_args: &'tcx [hir::Expr<'_>]) {
     if match_trait_method(cx, expr, &paths::ITERATOR) {
-        let msg = "called `filter_map(p).next()` on an `Iterator`. This is more succinctly expressed by calling \
-                   `.find_map(p)` instead.";
+        let msg = "called `filter_map(..).next()` on an `Iterator`. This is more succinctly expressed by calling \
+                   `.find_map(..)` instead.";
         let filter_snippet = snippet(cx, filter_args[1].span, "..");
         if filter_snippet.lines().count() <= 1 {
             span_lint_and_note(
@@ -2931,7 +2931,7 @@ fn lint_find_map<'tcx>(
 ) {
     // lint if caller of `.filter().map()` is an Iterator
     if match_trait_method(cx, &map_args[0], &paths::ITERATOR) {
-        let msg = "called `find(p).map(q)` on an `Iterator`";
+        let msg = "called `find(..).map(..)` on an `Iterator`";
         let hint = "this is more succinctly expressed by calling `.find_map(..)` instead";
         span_lint_and_help(cx, FIND_MAP, expr.span, msg, None, hint);
     }
@@ -2946,7 +2946,7 @@ fn lint_filter_map_map<'tcx>(
 ) {
     // lint if caller of `.filter().map()` is an Iterator
     if match_trait_method(cx, expr, &paths::ITERATOR) {
-        let msg = "called `filter_map(p).map(q)` on an `Iterator`";
+        let msg = "called `filter_map(..).map(..)` on an `Iterator`";
         let hint = "this is more succinctly expressed by only calling `.filter_map(..)` instead";
         span_lint_and_help(cx, FILTER_MAP, expr.span, msg, None, hint);
     }
@@ -2961,7 +2961,7 @@ fn lint_filter_flat_map<'tcx>(
 ) {
     // lint if caller of `.filter().flat_map()` is an Iterator
     if match_trait_method(cx, expr, &paths::ITERATOR) {
-        let msg = "called `filter(p).flat_map(q)` on an `Iterator`";
+        let msg = "called `filter(..).flat_map(..)` on an `Iterator`";
         let hint = "this is more succinctly expressed by calling `.flat_map(..)` \
                     and filtering by returning `iter::empty()`";
         span_lint_and_help(cx, FILTER_MAP, expr.span, msg, None, hint);
@@ -2977,7 +2977,7 @@ fn lint_filter_map_flat_map<'tcx>(
 ) {
     // lint if caller of `.filter_map().flat_map()` is an Iterator
     if match_trait_method(cx, expr, &paths::ITERATOR) {
-        let msg = "called `filter_map(p).flat_map(q)` on an `Iterator`";
+        let msg = "called `filter_map(..).flat_map(..)` on an `Iterator`";
         let hint = "this is more succinctly expressed by calling `.flat_map(..)` \
                     and filtering by returning `iter::empty()`";
         span_lint_and_help(cx, FILTER_MAP, expr.span, msg, None, hint);
@@ -3148,9 +3148,9 @@ fn lint_chars_cmp(
                 "like this",
                 format!("{}{}.{}({})",
                         if info.eq { "" } else { "!" },
-                        snippet_with_applicability(cx, args[0][0].span, "_", &mut applicability),
+                        snippet_with_applicability(cx, args[0][0].span, "..", &mut applicability),
                         suggest,
-                        snippet_with_applicability(cx, arg_char[0].span, "_", &mut applicability)),
+                        snippet_with_applicability(cx, arg_char[0].span, "..", &mut applicability)),
                 applicability,
             );
 
@@ -3197,7 +3197,7 @@ fn lint_chars_cmp_with_unwrap<'tcx>(
                 "like this",
                 format!("{}{}.{}('{}')",
                         if info.eq { "" } else { "!" },
-                        snippet_with_applicability(cx, args[0][0].span, "_", &mut applicability),
+                        snippet_with_applicability(cx, args[0][0].span, "..", &mut applicability),
                         suggest,
                         c),
                 applicability,
@@ -3272,7 +3272,7 @@ fn lint_single_char_pattern(cx: &LateContext<'_>, _expr: &hir::Expr<'_>, arg: &h
 fn lint_single_char_push_string(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::Expr<'_>]) {
     let mut applicability = Applicability::MachineApplicable;
     if let Some(extension_string) = get_hint_if_single_char_arg(cx, &args[1], &mut applicability) {
-        let base_string_snippet = snippet_with_applicability(cx, args[0].span, "_", &mut applicability);
+        let base_string_snippet = snippet_with_applicability(cx, args[0].span, "..", &mut applicability);
         let sugg = format!("{}.push({})", base_string_snippet, extension_string);
         span_lint_and_sugg(
             cx,
@@ -3315,7 +3315,7 @@ fn lint_asref(cx: &LateContext<'_>, expr: &hir::Expr<'_>, call_name: &str, as_re
                 expr.span,
                 &format!("this call to `{}` does nothing", call_name),
                 "try this",
-                snippet_with_applicability(cx, recvr.span, "_", &mut applicability).to_string(),
+                snippet_with_applicability(cx, recvr.span, "..", &mut applicability).to_string(),
                 applicability,
             );
         }
diff --git a/clippy_lints/src/methods/option_map_unwrap_or.rs b/clippy_lints/src/methods/option_map_unwrap_or.rs
index 95fa28e1c0f..d30b85d6a78 100644
--- a/clippy_lints/src/methods/option_map_unwrap_or.rs
+++ b/clippy_lints/src/methods/option_map_unwrap_or.rs
@@ -53,15 +53,15 @@ pub(super) fn lint<'tcx>(
         // lint message
         // comparing the snippet from source to raw text ("None") below is safe
         // because we already have checked the type.
-        let arg = if unwrap_snippet == "None" { "None" } else { "a" };
+        let arg = if unwrap_snippet == "None" { "None" } else { "<a>" };
         let unwrap_snippet_none = unwrap_snippet == "None";
         let suggest = if unwrap_snippet_none {
-            "and_then(f)"
+            "and_then(<f>)"
         } else {
-            "map_or(a, f)"
+            "map_or(<a>, <f>)"
         };
         let msg = &format!(
-            "called `map(f).unwrap_or({})` on an `Option` value. \
+            "called `map(<f>).unwrap_or({})` on an `Option` value. \
             This can be done more directly by calling `{}` instead",
             arg, suggest
         );
diff --git a/tests/ui/filter_map_next.stderr b/tests/ui/filter_map_next.stderr
index d69ae212414..01281ebaf6a 100644
--- a/tests/ui/filter_map_next.stderr
+++ b/tests/ui/filter_map_next.stderr
@@ -1,4 +1,4 @@
-error: called `filter_map(p).next()` on an `Iterator`. This is more succinctly expressed by calling `.find_map(p)` instead.
+error: called `filter_map(..).next()` on an `Iterator`. This is more succinctly expressed by calling `.find_map(..)` instead.
   --> $DIR/filter_map_next.rs:6:32
    |
 LL |     let element: Option<i32> = a.iter().filter_map(|s| s.parse().ok()).next();
@@ -7,7 +7,7 @@ LL |     let element: Option<i32> = a.iter().filter_map(|s| s.parse().ok()).next
    = note: `-D clippy::filter-map-next` implied by `-D warnings`
    = note: replace `filter_map(|s| s.parse().ok()).next()` with `find_map(|s| s.parse().ok())`
 
-error: called `filter_map(p).next()` on an `Iterator`. This is more succinctly expressed by calling `.find_map(p)` instead.
+error: called `filter_map(..).next()` on an `Iterator`. This is more succinctly expressed by calling `.find_map(..)` instead.
   --> $DIR/filter_map_next.rs:10:26
    |
 LL |       let _: Option<u32> = vec![1, 2, 3, 4, 5, 6]
diff --git a/tests/ui/filter_methods.stderr b/tests/ui/filter_methods.stderr
index 84a957a374c..91718dd1175 100644
--- a/tests/ui/filter_methods.stderr
+++ b/tests/ui/filter_methods.stderr
@@ -1,4 +1,4 @@
-error: called `filter(p).map(q)` on an `Iterator`
+error: called `filter(..).map(..)` on an `Iterator`
   --> $DIR/filter_methods.rs:5:21
    |
 LL |     let _: Vec<_> = vec![5; 6].into_iter().filter(|&x| x == 0).map(|x| x * 2).collect();
@@ -7,7 +7,7 @@ LL |     let _: Vec<_> = vec![5; 6].into_iter().filter(|&x| x == 0).map(|x| x *
    = note: `-D clippy::filter-map` implied by `-D warnings`
    = help: this is more succinctly expressed by calling `.filter_map(..)` instead
 
-error: called `filter(p).flat_map(q)` on an `Iterator`
+error: called `filter(..).flat_map(..)` on an `Iterator`
   --> $DIR/filter_methods.rs:7:21
    |
 LL |       let _: Vec<_> = vec![5_i8; 6]
@@ -19,7 +19,7 @@ LL | |         .flat_map(|x| x.checked_mul(2))
    |
    = help: this is more succinctly expressed by calling `.flat_map(..)` and filtering by returning `iter::empty()`
 
-error: called `filter_map(p).flat_map(q)` on an `Iterator`
+error: called `filter_map(..).flat_map(..)` on an `Iterator`
   --> $DIR/filter_methods.rs:13:21
    |
 LL |       let _: Vec<_> = vec![5_i8; 6]
@@ -31,7 +31,7 @@ LL | |         .flat_map(|x| x.checked_mul(2))
    |
    = help: this is more succinctly expressed by calling `.flat_map(..)` and filtering by returning `iter::empty()`
 
-error: called `filter_map(p).map(q)` on an `Iterator`
+error: called `filter_map(..).map(..)` on an `Iterator`
   --> $DIR/filter_methods.rs:19:21
    |
 LL |       let _: Vec<_> = vec![5_i8; 6]
diff --git a/tests/ui/find_map.stderr b/tests/ui/find_map.stderr
index f279850fef8..aea3cc62afc 100644
--- a/tests/ui/find_map.stderr
+++ b/tests/ui/find_map.stderr
@@ -1,4 +1,4 @@
-error: called `find(p).map(q)` on an `Iterator`
+error: called `find(..).map(..)` on an `Iterator`
   --> $DIR/find_map.rs:20:26
    |
 LL |     let _: Option<i32> = a.iter().find(|s| s.parse::<i32>().is_ok()).map(|s| s.parse().unwrap());
@@ -7,7 +7,7 @@ LL |     let _: Option<i32> = a.iter().find(|s| s.parse::<i32>().is_ok()).map(|s
    = note: `-D clippy::find-map` implied by `-D warnings`
    = help: this is more succinctly expressed by calling `.find_map(..)` instead
 
-error: called `find(p).map(q)` on an `Iterator`
+error: called `find(..).map(..)` on an `Iterator`
   --> $DIR/find_map.rs:23:29
    |
 LL |       let _: Option<Flavor> = desserts_of_the_week
diff --git a/tests/ui/iter_skip_next.stderr b/tests/ui/iter_skip_next.stderr
index feedc2f288a..486de718bb5 100644
--- a/tests/ui/iter_skip_next.stderr
+++ b/tests/ui/iter_skip_next.stderr
@@ -1,4 +1,4 @@
-error: called `skip(x).next()` on an iterator
+error: called `skip(..).next()` on an iterator
   --> $DIR/iter_skip_next.rs:15:28
    |
 LL |     let _ = some_vec.iter().skip(42).next();
@@ -6,19 +6,19 @@ LL |     let _ = some_vec.iter().skip(42).next();
    |
    = note: `-D clippy::iter-skip-next` implied by `-D warnings`
 
-error: called `skip(x).next()` on an iterator
+error: called `skip(..).next()` on an iterator
   --> $DIR/iter_skip_next.rs:16:36
    |
 LL |     let _ = some_vec.iter().cycle().skip(42).next();
    |                                    ^^^^^^^^^^^^^^^^ help: use `nth` instead: `.nth(42)`
 
-error: called `skip(x).next()` on an iterator
+error: called `skip(..).next()` on an iterator
   --> $DIR/iter_skip_next.rs:17:20
    |
 LL |     let _ = (1..10).skip(10).next();
    |                    ^^^^^^^^^^^^^^^^ help: use `nth` instead: `.nth(10)`
 
-error: called `skip(x).next()` on an iterator
+error: called `skip(..).next()` on an iterator
   --> $DIR/iter_skip_next.rs:18:33
    |
 LL |     let _ = &some_vec[..].iter().skip(3).next();
diff --git a/tests/ui/map_unwrap_or.stderr b/tests/ui/map_unwrap_or.stderr
index b62080a073f..6fa2800e9bd 100644
--- a/tests/ui/map_unwrap_or.stderr
+++ b/tests/ui/map_unwrap_or.stderr
@@ -1,4 +1,4 @@
-error: called `map(f).unwrap_or(a)` on an `Option` value. This can be done more directly by calling `map_or(a, f)` instead
+error: called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead
   --> $DIR/map_unwrap_or.rs:17:13
    |
 LL |       let _ = opt.map(|x| x + 1)
@@ -8,12 +8,12 @@ LL | |         .unwrap_or(0);
    | |_____________________^
    |
    = note: `-D clippy::map-unwrap-or` implied by `-D warnings`
-help: use `map_or(a, f)` instead
+help: use `map_or(<a>, <f>)` instead
    |
 LL |     let _ = opt.map_or(0, |x| x + 1);
    |                 ^^^^^^ ^^          --
 
-error: called `map(f).unwrap_or(a)` on an `Option` value. This can be done more directly by calling `map_or(a, f)` instead
+error: called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead
   --> $DIR/map_unwrap_or.rs:21:13
    |
 LL |       let _ = opt.map(|x| {
@@ -23,7 +23,7 @@ LL | |     }
 LL | |     ).unwrap_or(0);
    | |__________________^
    |
-help: use `map_or(a, f)` instead
+help: use `map_or(<a>, <f>)` instead
    |
 LL |     let _ = opt.map_or(0, |x| {
 LL |         x + 1
@@ -31,7 +31,7 @@ LL |     }
 LL |     );
    |
 
-error: called `map(f).unwrap_or(a)` on an `Option` value. This can be done more directly by calling `map_or(a, f)` instead
+error: called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead
   --> $DIR/map_unwrap_or.rs:25:13
    |
 LL |       let _ = opt.map(|x| x + 1)
@@ -41,25 +41,25 @@ LL | |             0
 LL | |         });
    | |__________^
    |
-help: use `map_or(a, f)` instead
+help: use `map_or(<a>, <f>)` instead
    |
 LL |     let _ = opt.map_or({
 LL |             0
 LL |         }, |x| x + 1);
    |
 
-error: called `map(f).unwrap_or(None)` on an `Option` value. This can be done more directly by calling `and_then(f)` instead
+error: called `map(<f>).unwrap_or(None)` on an `Option` value. This can be done more directly by calling `and_then(<f>)` instead
   --> $DIR/map_unwrap_or.rs:30:13
    |
 LL |     let _ = opt.map(|x| Some(x + 1)).unwrap_or(None);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-help: use `and_then(f)` instead
+help: use `and_then(<f>)` instead
    |
 LL |     let _ = opt.and_then(|x| Some(x + 1));
    |                 ^^^^^^^^                --
 
-error: called `map(f).unwrap_or(None)` on an `Option` value. This can be done more directly by calling `and_then(f)` instead
+error: called `map(<f>).unwrap_or(None)` on an `Option` value. This can be done more directly by calling `and_then(<f>)` instead
   --> $DIR/map_unwrap_or.rs:32:13
    |
 LL |       let _ = opt.map(|x| {
@@ -69,7 +69,7 @@ LL | |     }
 LL | |     ).unwrap_or(None);
    | |_____________________^
    |
-help: use `and_then(f)` instead
+help: use `and_then(<f>)` instead
    |
 LL |     let _ = opt.and_then(|x| {
 LL |         Some(x + 1)
@@ -77,7 +77,7 @@ LL |     }
 LL |     );
    |
 
-error: called `map(f).unwrap_or(None)` on an `Option` value. This can be done more directly by calling `and_then(f)` instead
+error: called `map(<f>).unwrap_or(None)` on an `Option` value. This can be done more directly by calling `and_then(<f>)` instead
   --> $DIR/map_unwrap_or.rs:36:13
    |
 LL |       let _ = opt
@@ -86,23 +86,23 @@ LL | |         .map(|x| Some(x + 1))
 LL | |         .unwrap_or(None);
    | |________________________^
    |
-help: use `and_then(f)` instead
+help: use `and_then(<f>)` instead
    |
 LL |         .and_then(|x| Some(x + 1));
    |          ^^^^^^^^                --
 
-error: called `map(f).unwrap_or(a)` on an `Option` value. This can be done more directly by calling `map_or(a, f)` instead
+error: called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead
   --> $DIR/map_unwrap_or.rs:47:13
    |
 LL |     let _ = Some("prefix").map(|p| format!("{}.", p)).unwrap_or(id);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-help: use `map_or(a, f)` instead
+help: use `map_or(<a>, <f>)` instead
    |
 LL |     let _ = Some("prefix").map_or(id, |p| format!("{}.", p));
    |                            ^^^^^^ ^^^                      --
 
-error: called `map(f).unwrap_or_else(g)` on an `Option` value. This can be done more directly by calling `map_or_else(g, f)` instead
+error: called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling `map_or_else(<g>, <f>)` instead
   --> $DIR/map_unwrap_or.rs:51:13
    |
 LL |       let _ = opt.map(|x| x + 1)
@@ -113,7 +113,7 @@ LL | |         .unwrap_or_else(|| 0);
    |
    = note: replace `map(|x| x + 1).unwrap_or_else(|| 0)` with `map_or_else(|| 0, |x| x + 1)`
 
-error: called `map(f).unwrap_or_else(g)` on an `Option` value. This can be done more directly by calling `map_or_else(g, f)` instead
+error: called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling `map_or_else(<g>, <f>)` instead
   --> $DIR/map_unwrap_or.rs:55:13
    |
 LL |       let _ = opt.map(|x| {
@@ -123,7 +123,7 @@ LL | |     }
 LL | |     ).unwrap_or_else(|| 0);
    | |__________________________^
 
-error: called `map(f).unwrap_or_else(g)` on an `Option` value. This can be done more directly by calling `map_or_else(g, f)` instead
+error: called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling `map_or_else(<g>, <f>)` instead
   --> $DIR/map_unwrap_or.rs:59:13
    |
 LL |       let _ = opt.map(|x| x + 1)
@@ -133,7 +133,7 @@ LL | |             0
 LL | |         );
    | |_________^
 
-error: called `map(f).unwrap_or_else(g)` on a `Result` value. This can be done more directly by calling `.map_or_else(g, f)` instead
+error: called `map(<f>).unwrap_or_else(<g>)` on a `Result` value. This can be done more directly by calling `.map_or_else(<g>, <f>)` instead
   --> $DIR/map_unwrap_or.rs:88:13
    |
 LL |     let _ = res.map(|x| x + 1).unwrap_or_else(|e| 0); // should lint even though this call is on a separate line
@@ -141,7 +141,7 @@ LL |     let _ = res.map(|x| x + 1).unwrap_or_else(|e| 0); // should lint even t
    |
    = note: replace `map(|x| x + 1).unwrap_or_else(|e| 0)` with `map_or_else(|e| 0, |x| x + 1)`
 
-error: called `map(f).unwrap_or_else(g)` on a `Result` value. This can be done more directly by calling `.map_or_else(g, f)` instead
+error: called `map(<f>).unwrap_or_else(<g>)` on a `Result` value. This can be done more directly by calling `.map_or_else(<g>, <f>)` instead
   --> $DIR/map_unwrap_or.rs:90:13
    |
 LL |     let _ = res.map(|x| x + 1).unwrap_or_else(|e| 0);
@@ -149,7 +149,7 @@ LL |     let _ = res.map(|x| x + 1).unwrap_or_else(|e| 0);
    |
    = note: replace `map(|x| x + 1).unwrap_or_else(|e| 0)` with `map_or_else(|e| 0, |x| x + 1)`
 
-error: called `map(f).unwrap_or_else(g)` on a `Result` value. This can be done more directly by calling `.map_or_else(g, f)` instead
+error: called `map(<f>).unwrap_or_else(<g>)` on a `Result` value. This can be done more directly by calling `.map_or_else(<g>, <f>)` instead
   --> $DIR/map_unwrap_or.rs:91:13
    |
 LL |     let _ = res.map(|x| x + 1).unwrap_or_else(|e| 0);
diff --git a/tests/ui/methods.stderr b/tests/ui/methods.stderr
index 2a0a43e83a6..74d8533d4da 100644
--- a/tests/ui/methods.stderr
+++ b/tests/ui/methods.stderr
@@ -8,7 +8,7 @@ LL | |     }
    |
    = note: `-D clippy::new-ret-no-self` implied by `-D warnings`
 
-error: called `filter(p).next()` on an `Iterator`. This is more succinctly expressed by calling `.find(p)` instead.
+error: called `filter(..).next()` on an `Iterator`. This is more succinctly expressed by calling `.find(..)` instead.
   --> $DIR/methods.rs:126:13
    |
 LL |     let _ = v.iter().filter(|&x| *x < 0).next();
@@ -17,7 +17,7 @@ LL |     let _ = v.iter().filter(|&x| *x < 0).next();
    = note: `-D clippy::filter-next` implied by `-D warnings`
    = note: replace `filter(|&x| *x < 0).next()` with `find(|&x| *x < 0)`
 
-error: called `filter(p).next()` on an `Iterator`. This is more succinctly expressed by calling `.find(p)` instead.
+error: called `filter(..).next()` on an `Iterator`. This is more succinctly expressed by calling `.find(..)` instead.
   --> $DIR/methods.rs:129:13
    |
 LL |       let _ = v.iter().filter(|&x| {
diff --git a/tests/ui/option_map_or_none.stderr b/tests/ui/option_map_or_none.stderr
index 6f707987dbc..1cba29412b8 100644
--- a/tests/ui/option_map_or_none.stderr
+++ b/tests/ui/option_map_or_none.stderr
@@ -1,4 +1,4 @@
-error: called `map_or(None, f)` on an `Option` value. This can be done more directly by calling `and_then(f)` instead
+error: called `map_or(None, ..)` on an `Option` value. This can be done more directly by calling `and_then(..)` instead
   --> $DIR/option_map_or_none.rs:10:13
    |
 LL |     let _ = opt.map_or(None, |x| Some(x + 1));
@@ -6,7 +6,7 @@ LL |     let _ = opt.map_or(None, |x| Some(x + 1));
    |
    = note: `-D clippy::option-map-or-none` implied by `-D warnings`
 
-error: called `map_or(None, f)` on an `Option` value. This can be done more directly by calling `and_then(f)` instead
+error: called `map_or(None, ..)` on an `Option` value. This can be done more directly by calling `and_then(..)` instead
   --> $DIR/option_map_or_none.rs:13:13
    |
 LL |       let _ = opt.map_or(None, |x| {
diff --git a/tests/ui/skip_while_next.stderr b/tests/ui/skip_while_next.stderr
index a6b7bcd63ff..269cc13468b 100644
--- a/tests/ui/skip_while_next.stderr
+++ b/tests/ui/skip_while_next.stderr
@@ -1,13 +1,13 @@
-error: called `skip_while(p).next()` on an `Iterator`
+error: called `skip_while(<p>).next()` on an `Iterator`
   --> $DIR/skip_while_next.rs:14:13
    |
 LL |     let _ = v.iter().skip_while(|&x| *x < 0).next();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::skip-while-next` implied by `-D warnings`
-   = help: this is more succinctly expressed by calling `.find(!p)` instead
+   = help: this is more succinctly expressed by calling `.find(!<p>)` instead
 
-error: called `skip_while(p).next()` on an `Iterator`
+error: called `skip_while(<p>).next()` on an `Iterator`
   --> $DIR/skip_while_next.rs:17:13
    |
 LL |       let _ = v.iter().skip_while(|&x| {
@@ -17,7 +17,7 @@ LL | |                             }
 LL | |                    ).next();
    | |___________________________^
    |
-   = help: this is more succinctly expressed by calling `.find(!p)` instead
+   = help: this is more succinctly expressed by calling `.find(!<p>)` instead
 
 error: aborting due to 2 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 3fec6f568daababf3520e2a818b4c1db79266b92 Mon Sep 17 00:00:00 2001
From: ThibsG <Thibs@debian.com>
Date: Mon, 19 Oct 2020 18:47:02 +0200
Subject: Improve some suggestions for `filter_map_next`, `filter_next` and
 `map_unwrap_or` lints

---
 clippy_lints/src/methods/mod.rs | 30 ++++++++++++++++--------------
 tests/ui/filter_map_next.stderr |  3 +--
 tests/ui/map_unwrap_or.stderr   | 16 ++++------------
 tests/ui/methods.stderr         |  3 +--
 4 files changed, 22 insertions(+), 30 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index fc77cd52b8f..d3e26a09ad4 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -32,8 +32,7 @@ use crate::utils::{
     is_copy, is_expn_of, is_type_diagnostic_item, iter_input_pats, last_path_segment, match_def_path, match_qpath,
     match_trait_method, match_type, match_var, method_calls, method_chain_args, paths, remove_blocks, return_ty,
     single_segment_path, snippet, snippet_with_applicability, snippet_with_macro_callsite, span_lint,
-    span_lint_and_help, span_lint_and_note, span_lint_and_sugg, span_lint_and_then, sugg, walk_ptrs_ty_depth,
-    SpanlessEq,
+    span_lint_and_help, span_lint_and_sugg, span_lint_and_then, sugg, walk_ptrs_ty_depth, SpanlessEq,
 };
 
 declare_clippy_lint! {
@@ -2753,16 +2752,15 @@ fn lint_map_unwrap_or_else<'tcx>(
         let multiline = map_snippet.lines().count() > 1 || unwrap_snippet.lines().count() > 1;
         let same_span = map_args[1].span.ctxt() == unwrap_args[1].span.ctxt();
         if same_span && !multiline {
-            span_lint_and_note(
+            let var_snippet = snippet(cx, map_args[0].span, "..");
+            span_lint_and_sugg(
                 cx,
                 MAP_UNWRAP_OR,
                 expr.span,
                 msg,
-                None,
-                &format!(
-                    "replace `map({0}).unwrap_or_else({1})` with `map_or_else({1}, {0})`",
-                    map_snippet, unwrap_snippet,
-                ),
+                "try this",
+                format!("{}.map_or_else({}, {})", var_snippet, unwrap_snippet, map_snippet),
+                Applicability::MachineApplicable,
             );
             return true;
         } else if same_span && multiline {
@@ -2852,14 +2850,16 @@ fn lint_filter_next<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, fil
                    `.find(..)` instead.";
         let filter_snippet = snippet(cx, filter_args[1].span, "..");
         if filter_snippet.lines().count() <= 1 {
+            let iter_snippet = snippet(cx, filter_args[0].span, "..");
             // add note if not multi-line
-            span_lint_and_note(
+            span_lint_and_sugg(
                 cx,
                 FILTER_NEXT,
                 expr.span,
                 msg,
-                None,
-                &format!("replace `filter({0}).next()` with `find({0})`", filter_snippet),
+                "try this",
+                format!("{}.find({})", iter_snippet, filter_snippet),
+                Applicability::MachineApplicable,
             );
         } else {
             span_lint(cx, FILTER_NEXT, expr.span, msg);
@@ -2908,13 +2908,15 @@ fn lint_filter_map_next<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>,
                    `.find_map(..)` instead.";
         let filter_snippet = snippet(cx, filter_args[1].span, "..");
         if filter_snippet.lines().count() <= 1 {
-            span_lint_and_note(
+            let iter_snippet = snippet(cx, filter_args[0].span, "..");
+            span_lint_and_sugg(
                 cx,
                 FILTER_MAP_NEXT,
                 expr.span,
                 msg,
-                None,
-                &format!("replace `filter_map({0}).next()` with `find_map({0})`", filter_snippet),
+                "try this",
+                format!("{}.find_map({})", iter_snippet, filter_snippet),
+                Applicability::MachineApplicable,
             );
         } else {
             span_lint(cx, FILTER_MAP_NEXT, expr.span, msg);
diff --git a/tests/ui/filter_map_next.stderr b/tests/ui/filter_map_next.stderr
index 01281ebaf6a..bcedf11e536 100644
--- a/tests/ui/filter_map_next.stderr
+++ b/tests/ui/filter_map_next.stderr
@@ -2,10 +2,9 @@ error: called `filter_map(..).next()` on an `Iterator`. This is more succinctly
   --> $DIR/filter_map_next.rs:6:32
    |
 LL |     let element: Option<i32> = a.iter().filter_map(|s| s.parse().ok()).next();
-   |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `a.iter().find_map(|s| s.parse().ok())`
    |
    = note: `-D clippy::filter-map-next` implied by `-D warnings`
-   = note: replace `filter_map(|s| s.parse().ok()).next()` with `find_map(|s| s.parse().ok())`
 
 error: called `filter_map(..).next()` on an `Iterator`. This is more succinctly expressed by calling `.find_map(..)` instead.
   --> $DIR/filter_map_next.rs:10:26
diff --git a/tests/ui/map_unwrap_or.stderr b/tests/ui/map_unwrap_or.stderr
index 6fa2800e9bd..1975abb3e9f 100644
--- a/tests/ui/map_unwrap_or.stderr
+++ b/tests/ui/map_unwrap_or.stderr
@@ -109,9 +109,7 @@ LL |       let _ = opt.map(|x| x + 1)
    |  _____________^
 LL | |         // Should lint even though this call is on a separate line.
 LL | |         .unwrap_or_else(|| 0);
-   | |_____________________________^
-   |
-   = note: replace `map(|x| x + 1).unwrap_or_else(|| 0)` with `map_or_else(|| 0, |x| x + 1)`
+   | |_____________________________^ help: try this: `opt.map_or_else(|| 0, |x| x + 1)`
 
 error: called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling `map_or_else(<g>, <f>)` instead
   --> $DIR/map_unwrap_or.rs:55:13
@@ -137,25 +135,19 @@ error: called `map(<f>).unwrap_or_else(<g>)` on a `Result` value. This can be do
   --> $DIR/map_unwrap_or.rs:88:13
    |
 LL |     let _ = res.map(|x| x + 1).unwrap_or_else(|e| 0); // should lint even though this call is on a separate line
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: replace `map(|x| x + 1).unwrap_or_else(|e| 0)` with `map_or_else(|e| 0, |x| x + 1)`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `res.map_or_else(|e| 0, |x| x + 1)`
 
 error: called `map(<f>).unwrap_or_else(<g>)` on a `Result` value. This can be done more directly by calling `.map_or_else(<g>, <f>)` instead
   --> $DIR/map_unwrap_or.rs:90:13
    |
 LL |     let _ = res.map(|x| x + 1).unwrap_or_else(|e| 0);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: replace `map(|x| x + 1).unwrap_or_else(|e| 0)` with `map_or_else(|e| 0, |x| x + 1)`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `res.map_or_else(|e| 0, |x| x + 1)`
 
 error: called `map(<f>).unwrap_or_else(<g>)` on a `Result` value. This can be done more directly by calling `.map_or_else(<g>, <f>)` instead
   --> $DIR/map_unwrap_or.rs:91:13
    |
 LL |     let _ = res.map(|x| x + 1).unwrap_or_else(|e| 0);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: replace `map(|x| x + 1).unwrap_or_else(|e| 0)` with `map_or_else(|e| 0, |x| x + 1)`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `res.map_or_else(|e| 0, |x| x + 1)`
 
 error: aborting due to 13 previous errors
 
diff --git a/tests/ui/methods.stderr b/tests/ui/methods.stderr
index 74d8533d4da..2df1941aaaa 100644
--- a/tests/ui/methods.stderr
+++ b/tests/ui/methods.stderr
@@ -12,10 +12,9 @@ error: called `filter(..).next()` on an `Iterator`. This is more succinctly expr
   --> $DIR/methods.rs:126:13
    |
 LL |     let _ = v.iter().filter(|&x| *x < 0).next();
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `v.iter().find(|&x| *x < 0)`
    |
    = note: `-D clippy::filter-next` implied by `-D warnings`
-   = note: replace `filter(|&x| *x < 0).next()` with `find(|&x| *x < 0)`
 
 error: called `filter(..).next()` on an `Iterator`. This is more succinctly expressed by calling `.find(..)` instead.
   --> $DIR/methods.rs:129:13
-- 
cgit 1.4.1-3-g733a5


From 213dbf7aacb01cc4d05d47f010833aa6e9c2a7d0 Mon Sep 17 00:00:00 2001
From: dvermd <315743+dvermd@users.noreply.github.com>
Date: Mon, 12 Oct 2020 23:58:59 +0200
Subject: clippy_lint: Add 'ref_option_ref'

---
 CHANGELOG.md                       |  1 +
 clippy_lints/src/lib.rs            |  5 +++
 clippy_lints/src/ref_option_ref.rs | 65 ++++++++++++++++++++++++++++++++++++++
 src/lintlist/mod.rs                |  7 ++++
 tests/ui/ref_option_ref.rs         |  5 +++
 tests/ui/ref_option_ref.stderr     | 10 ++++++
 6 files changed, 93 insertions(+)
 create mode 100644 clippy_lints/src/ref_option_ref.rs
 create mode 100644 tests/ui/ref_option_ref.rs
 create mode 100644 tests/ui/ref_option_ref.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 25f3b5da198..db834fe108b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1917,6 +1917,7 @@ Released 2018-09-13
 [`redundant_pub_crate`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_pub_crate
 [`redundant_static_lifetimes`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_static_lifetimes
 [`ref_in_deref`]: https://rust-lang.github.io/rust-clippy/master/index.html#ref_in_deref
+[`ref_option_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#ref_option_ref
 [`regex_macro`]: https://rust-lang.github.io/rust-clippy/master/index.html#regex_macro
 [`repeat_once`]: https://rust-lang.github.io/rust-clippy/master/index.html#repeat_once
 [`replace_consts`]: https://rust-lang.github.io/rust-clippy/master/index.html#replace_consts
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 3be8bc0e36d..1ab36231758 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -293,6 +293,7 @@ mod redundant_closure_call;
 mod redundant_field_names;
 mod redundant_pub_crate;
 mod redundant_static_lifetimes;
+mod ref_option_ref;
 mod reference;
 mod regex;
 mod repeat_once;
@@ -803,6 +804,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &redundant_field_names::REDUNDANT_FIELD_NAMES,
         &redundant_pub_crate::REDUNDANT_PUB_CRATE,
         &redundant_static_lifetimes::REDUNDANT_STATIC_LIFETIMES,
+        &ref_option_ref::REF_OPTION_REF,
         &reference::DEREF_ADDROF,
         &reference::REF_IN_DEREF,
         &regex::INVALID_REGEX,
@@ -1024,6 +1026,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &sess.target,
     );
     store.register_late_pass(move || box pass_by_ref_or_value);
+    store.register_late_pass(|| box ref_option_ref::RefOptionRef);
     store.register_late_pass(|| box try_err::TryErr);
     store.register_late_pass(|| box use_self::UseSelf);
     store.register_late_pass(|| box bytecount::ByteCount);
@@ -1493,6 +1496,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&redundant_closure_call::REDUNDANT_CLOSURE_CALL),
         LintId::of(&redundant_field_names::REDUNDANT_FIELD_NAMES),
         LintId::of(&redundant_static_lifetimes::REDUNDANT_STATIC_LIFETIMES),
+        LintId::of(&ref_option_ref::REF_OPTION_REF),
         LintId::of(&reference::DEREF_ADDROF),
         LintId::of(&reference::REF_IN_DEREF),
         LintId::of(&regex::INVALID_REGEX),
@@ -1648,6 +1652,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&ranges::MANUAL_RANGE_CONTAINS),
         LintId::of(&redundant_field_names::REDUNDANT_FIELD_NAMES),
         LintId::of(&redundant_static_lifetimes::REDUNDANT_STATIC_LIFETIMES),
+        LintId::of(&ref_option_ref::REF_OPTION_REF),
         LintId::of(&regex::TRIVIAL_REGEX),
         LintId::of(&returns::LET_AND_RETURN),
         LintId::of(&returns::NEEDLESS_RETURN),
diff --git a/clippy_lints/src/ref_option_ref.rs b/clippy_lints/src/ref_option_ref.rs
new file mode 100644
index 00000000000..fbee3263556
--- /dev/null
+++ b/clippy_lints/src/ref_option_ref.rs
@@ -0,0 +1,65 @@
+use crate::utils::{last_path_segment, match_def_path, paths, snippet, span_lint_and_sugg};
+use rustc_hir::{GenericArg, Local, Mutability, TyKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for usage of `&Option<&T>`.
+    ///
+    /// **Why is this bad?** Since `&` is Copy, it's useless to have a
+    /// reference on `Option<&T>`.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust,ignore
+    /// // example code where clippy issues a warning
+    /// let x: &Option<&u32> = &Some(&0u32);
+    /// ```
+    /// Use instead:
+    /// ```rust,ignore
+    /// // example code which does not raise clippy warning
+    /// let x: Option<&u32> = Some(&0u32);
+    /// ```
+    pub REF_OPTION_REF,
+    style,
+    "use `Option<&T>` instead of `&Option<&T>`"
+}
+
+declare_lint_pass!(RefOptionRef => [REF_OPTION_REF]);
+
+impl<'tcx> LateLintPass<'tcx> for RefOptionRef {
+    fn check_local(&mut self, cx: &LateContext<'tcx>, local: &'tcx Local<'_>) {
+        if_chain! {
+            if let Some(ref ty) = local.ty;
+            if let TyKind::Rptr(_, ref mut_ty) = ty.kind;
+            if mut_ty.mutbl == Mutability::Not;
+            if let TyKind::Path(ref qpath) = &mut_ty.ty.kind ;
+            if let Some(def_id) = cx.typeck_results().qpath_res(qpath, local.hir_id).opt_def_id();
+            if match_def_path(cx, def_id, &paths::OPTION);
+            if let Some(ref params) = last_path_segment(qpath).args ;
+            if !params.parenthesized;
+            if let Some(inner_ty) = params.args.iter().find_map(|arg| match arg {
+                GenericArg::Type(inner_ty) => Some(inner_ty),
+                _ => None,
+            });
+            if let TyKind::Rptr(_, _) = inner_ty.kind;
+
+            then {
+                span_lint_and_sugg(
+                    cx,
+                    REF_OPTION_REF,
+                    ty.span,
+                    "since & implements Copy trait, &Option<&T> can be simplifyied into Option<&T>",
+                    "try",
+                    format!("Option<{}>", &snippet(cx, inner_ty.span, "..")),
+                    Applicability::MachineApplicable,
+                );
+            }
+        }
+    }
+}
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index 6272ce45efb..b3bd1923d4e 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -2013,6 +2013,13 @@ vec![
         deprecation: None,
         module: "reference",
     },
+    Lint {
+        name: "ref_option_ref",
+        group: "style",
+        desc: "use `Option<&T>` instead of `&Option<&T>`",
+        deprecation: None,
+        module: "ref_option_ref",
+    },
     Lint {
         name: "repeat_once",
         group: "complexity",
diff --git a/tests/ui/ref_option_ref.rs b/tests/ui/ref_option_ref.rs
new file mode 100644
index 00000000000..7f05990c0a0
--- /dev/null
+++ b/tests/ui/ref_option_ref.rs
@@ -0,0 +1,5 @@
+#![warn(clippy::ref_option_ref)]
+
+fn main() {
+    let x: &Option<&u32> = &None;
+}
diff --git a/tests/ui/ref_option_ref.stderr b/tests/ui/ref_option_ref.stderr
new file mode 100644
index 00000000000..90bcaef7570
--- /dev/null
+++ b/tests/ui/ref_option_ref.stderr
@@ -0,0 +1,10 @@
+error: since & implements Copy trait, &Option<&T> can be simplifyied into Option<&T>
+  --> $DIR/ref_option_ref.rs:4:12
+   |
+LL |     let x: &Option<&u32> = &None;
+   |            ^^^^^^^^^^^^^ help: try: `Option<&u32>`
+   |
+   = note: `-D clippy::ref-option-ref` implied by `-D warnings`
+
+error: aborting due to previous error
+
-- 
cgit 1.4.1-3-g733a5


From d1baa25f046c8067ee1c9fa9e134de3ca0f64834 Mon Sep 17 00:00:00 2001
From: dvermd <315743+dvermd@users.noreply.github.com>
Date: Tue, 13 Oct 2020 14:16:33 +0200
Subject: clippy_lint: Add 'ref_option_ref' refactor code

---
 clippy_lints/src/ref_option_ref.rs | 18 +++++++++++++-----
 1 file changed, 13 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/ref_option_ref.rs b/clippy_lints/src/ref_option_ref.rs
index fbee3263556..40ac2b3f4f1 100644
--- a/clippy_lints/src/ref_option_ref.rs
+++ b/clippy_lints/src/ref_option_ref.rs
@@ -1,5 +1,5 @@
 use crate::utils::{last_path_segment, match_def_path, paths, snippet, span_lint_and_sugg};
-use rustc_hir::{GenericArg, Local, Mutability, TyKind};
+use rustc_hir::{GenericArg, Local, Mutability, Ty, TyKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
@@ -34,12 +34,20 @@ declare_lint_pass!(RefOptionRef => [REF_OPTION_REF]);
 
 impl<'tcx> LateLintPass<'tcx> for RefOptionRef {
     fn check_local(&mut self, cx: &LateContext<'tcx>, local: &'tcx Local<'_>) {
+
+        if let Some(ref ty) = local.ty {
+            self.check_ref_option_ref(cx, ty);
+        }
+    }
+}
+
+impl RefOptionRef {
+    fn check_ref_option_ref(&self, cx: &LateContext<'tcx>, ty: &'tcx Ty<'tcx>) {
         if_chain! {
-            if let Some(ref ty) = local.ty;
             if let TyKind::Rptr(_, ref mut_ty) = ty.kind;
             if mut_ty.mutbl == Mutability::Not;
             if let TyKind::Path(ref qpath) = &mut_ty.ty.kind ;
-            if let Some(def_id) = cx.typeck_results().qpath_res(qpath, local.hir_id).opt_def_id();
+            if let Some(def_id) = cx.typeck_results().qpath_res(qpath, ty.hir_id).opt_def_id();
             if match_def_path(cx, def_id, &paths::OPTION);
             if let Some(ref params) = last_path_segment(qpath).args ;
             if !params.parenthesized;
@@ -57,9 +65,9 @@ impl<'tcx> LateLintPass<'tcx> for RefOptionRef {
                     "since & implements Copy trait, &Option<&T> can be simplifyied into Option<&T>",
                     "try",
                     format!("Option<{}>", &snippet(cx, inner_ty.span, "..")),
-                    Applicability::MachineApplicable,
+                    Applicability::Unspecified,
                 );
             }
         }
     }
-}
+}
\ No newline at end of file
-- 
cgit 1.4.1-3-g733a5


From 469b2fc7811c14fa645dceadfb976fb4f4ef248a Mon Sep 17 00:00:00 2001
From: dvermd <315743+dvermd@users.noreply.github.com>
Date: Tue, 13 Oct 2020 22:13:54 +0200
Subject: clippy_lint: Add 'ref_option_ref' move to check_ty and add type alias
 test

---
 clippy_lints/src/ref_option_ref.rs | 16 ++++++++--------
 tests/ui/ref_option_ref.rs         |  4 ++++
 tests/ui/ref_option_ref.stderr     | 20 ++++++++++++++++----
 3 files changed, 28 insertions(+), 12 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/ref_option_ref.rs b/clippy_lints/src/ref_option_ref.rs
index 40ac2b3f4f1..4b5bc93d8a1 100644
--- a/clippy_lints/src/ref_option_ref.rs
+++ b/clippy_lints/src/ref_option_ref.rs
@@ -33,11 +33,8 @@ declare_clippy_lint! {
 declare_lint_pass!(RefOptionRef => [REF_OPTION_REF]);
 
 impl<'tcx> LateLintPass<'tcx> for RefOptionRef {
-    fn check_local(&mut self, cx: &LateContext<'tcx>, local: &'tcx Local<'_>) {
-
-        if let Some(ref ty) = local.ty {
-            self.check_ref_option_ref(cx, ty);
-        }
+    fn check_ty(&mut self, cx: &LateContext<'tcx>, ty: &'tcx Ty<'tcx>) {
+        self.check_ref_option_ref(cx, ty);
     }
 }
 
@@ -46,8 +43,11 @@ impl RefOptionRef {
         if_chain! {
             if let TyKind::Rptr(_, ref mut_ty) = ty.kind;
             if mut_ty.mutbl == Mutability::Not;
-            if let TyKind::Path(ref qpath) = &mut_ty.ty.kind ;
-            if let Some(def_id) = cx.typeck_results().qpath_res(qpath, ty.hir_id).opt_def_id();
+            if let TyKind::Path(ref qpath) = &mut_ty.ty.kind;
+            let last = last_path_segment(qpath);
+            if let Some(res) = last.res;
+            if let Some(def_id) = res.opt_def_id();
+
             if match_def_path(cx, def_id, &paths::OPTION);
             if let Some(ref params) = last_path_segment(qpath).args ;
             if !params.parenthesized;
@@ -70,4 +70,4 @@ impl RefOptionRef {
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/tests/ui/ref_option_ref.rs b/tests/ui/ref_option_ref.rs
index 7f05990c0a0..24db42efb80 100644
--- a/tests/ui/ref_option_ref.rs
+++ b/tests/ui/ref_option_ref.rs
@@ -1,5 +1,9 @@
+#![allow(unused)]
 #![warn(clippy::ref_option_ref)]
 
+type OptRefU32<'a> = &'a Option<&'a u32>;
+type OptRef<'a, T> = &'a Option<&'a T>;
+
 fn main() {
     let x: &Option<&u32> = &None;
 }
diff --git a/tests/ui/ref_option_ref.stderr b/tests/ui/ref_option_ref.stderr
index 90bcaef7570..26f4065d311 100644
--- a/tests/ui/ref_option_ref.stderr
+++ b/tests/ui/ref_option_ref.stderr
@@ -1,10 +1,22 @@
 error: since & implements Copy trait, &Option<&T> can be simplifyied into Option<&T>
-  --> $DIR/ref_option_ref.rs:4:12
+  --> $DIR/ref_option_ref.rs:4:22
    |
-LL |     let x: &Option<&u32> = &None;
-   |            ^^^^^^^^^^^^^ help: try: `Option<&u32>`
+LL | type OptRefU32<'a> = &'a Option<&'a u32>;
+   |                      ^^^^^^^^^^^^^^^^^^^ help: try: `Option<&'a u32>`
    |
    = note: `-D clippy::ref-option-ref` implied by `-D warnings`
 
-error: aborting due to previous error
+error: since & implements Copy trait, &Option<&T> can be simplifyied into Option<&T>
+  --> $DIR/ref_option_ref.rs:5:22
+   |
+LL | type OptRef<'a, T> = &'a Option<&'a T>;
+   |                      ^^^^^^^^^^^^^^^^^ help: try: `Option<&'a T>`
+
+error: since & implements Copy trait, &Option<&T> can be simplifyied into Option<&T>
+  --> $DIR/ref_option_ref.rs:8:12
+   |
+LL |     let x: &Option<&u32> = &None;
+   |            ^^^^^^^^^^^^^ help: try: `Option<&u32>`
+
+error: aborting due to 3 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From c1f3bab6b19ee27bce5b8c4df0d8413da7728473 Mon Sep 17 00:00:00 2001
From: dvermd <315743+dvermd@users.noreply.github.com>
Date: Tue, 13 Oct 2020 22:46:47 +0200
Subject: clippy_lint: Add 'ref_option_ref' remove unused import

---
 clippy_lints/src/ref_option_ref.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/ref_option_ref.rs b/clippy_lints/src/ref_option_ref.rs
index 4b5bc93d8a1..3b9465ec13d 100644
--- a/clippy_lints/src/ref_option_ref.rs
+++ b/clippy_lints/src/ref_option_ref.rs
@@ -1,5 +1,5 @@
 use crate::utils::{last_path_segment, match_def_path, paths, snippet, span_lint_and_sugg};
-use rustc_hir::{GenericArg, Local, Mutability, Ty, TyKind};
+use rustc_hir::{GenericArg, Mutability, Ty, TyKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
-- 
cgit 1.4.1-3-g733a5


From b41b38cb7f16e1a622738aff591268083dca2e39 Mon Sep 17 00:00:00 2001
From: dvermd <315743+dvermd@users.noreply.github.com>
Date: Tue, 13 Oct 2020 23:01:57 +0200
Subject: clippy_lint: Refactor 'ref_option_ref'

---
 clippy_lints/src/ref_option_ref.rs | 6 ------
 1 file changed, 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/ref_option_ref.rs b/clippy_lints/src/ref_option_ref.rs
index 3b9465ec13d..d4b09848ab6 100644
--- a/clippy_lints/src/ref_option_ref.rs
+++ b/clippy_lints/src/ref_option_ref.rs
@@ -34,12 +34,6 @@ declare_lint_pass!(RefOptionRef => [REF_OPTION_REF]);
 
 impl<'tcx> LateLintPass<'tcx> for RefOptionRef {
     fn check_ty(&mut self, cx: &LateContext<'tcx>, ty: &'tcx Ty<'tcx>) {
-        self.check_ref_option_ref(cx, ty);
-    }
-}
-
-impl RefOptionRef {
-    fn check_ref_option_ref(&self, cx: &LateContext<'tcx>, ty: &'tcx Ty<'tcx>) {
         if_chain! {
             if let TyKind::Rptr(_, ref mut_ty) = ty.kind;
             if mut_ty.mutbl == Mutability::Not;
-- 
cgit 1.4.1-3-g733a5


From 8e26004a5ff2d16a7ad37723f5d284703cff2b94 Mon Sep 17 00:00:00 2001
From: dvermd <315743+dvermd@users.noreply.github.com>
Date: Mon, 19 Oct 2020 21:37:36 +0200
Subject: Update clippy_lints/src/ref_option_ref.rs doctest

Co-authored-by: Philipp Krones <hello@philkrones.com>
---
 clippy_lints/src/ref_option_ref.rs | 2 --
 1 file changed, 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/ref_option_ref.rs b/clippy_lints/src/ref_option_ref.rs
index d4b09848ab6..902cd06f527 100644
--- a/clippy_lints/src/ref_option_ref.rs
+++ b/clippy_lints/src/ref_option_ref.rs
@@ -17,12 +17,10 @@ declare_clippy_lint! {
     /// **Example:**
     ///
     /// ```rust,ignore
-    /// // example code where clippy issues a warning
     /// let x: &Option<&u32> = &Some(&0u32);
     /// ```
     /// Use instead:
     /// ```rust,ignore
-    /// // example code which does not raise clippy warning
     /// let x: Option<&u32> = Some(&0u32);
     /// ```
     pub REF_OPTION_REF,
-- 
cgit 1.4.1-3-g733a5


From 1566db704d113ea6ed90f2b3927306bd84946dc2 Mon Sep 17 00:00:00 2001
From: dvermd <315743+dvermd@users.noreply.github.com>
Date: Mon, 19 Oct 2020 21:38:36 +0200
Subject: Update clippy_lints/src/ref_option_ref.rs

Co-authored-by: Philipp Krones <hello@philkrones.com>
---
 clippy_lints/src/ref_option_ref.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/ref_option_ref.rs b/clippy_lints/src/ref_option_ref.rs
index 902cd06f527..4ab2d8025e0 100644
--- a/clippy_lints/src/ref_option_ref.rs
+++ b/clippy_lints/src/ref_option_ref.rs
@@ -40,7 +40,7 @@ impl<'tcx> LateLintPass<'tcx> for RefOptionRef {
             if let Some(res) = last.res;
             if let Some(def_id) = res.opt_def_id();
 
-            if match_def_path(cx, def_id, &paths::OPTION);
+            if cx.tcx.is_diagnostic_item(sym!(option_type), def_id);
             if let Some(ref params) = last_path_segment(qpath).args ;
             if !params.parenthesized;
             if let Some(inner_ty) = params.args.iter().find_map(|arg| match arg {
-- 
cgit 1.4.1-3-g733a5


From 7fd74c6bf676e535592f5baadd412bf7c98e078c Mon Sep 17 00:00:00 2001
From: dvermd <315743+dvermd@users.noreply.github.com>
Date: Mon, 19 Oct 2020 22:01:37 +0200
Subject: clippy_lint: Add Known Problems message

---
 clippy_lints/src/ref_option_ref.rs | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/ref_option_ref.rs b/clippy_lints/src/ref_option_ref.rs
index 4ab2d8025e0..715938df138 100644
--- a/clippy_lints/src/ref_option_ref.rs
+++ b/clippy_lints/src/ref_option_ref.rs
@@ -1,4 +1,4 @@
-use crate::utils::{last_path_segment, match_def_path, paths, snippet, span_lint_and_sugg};
+use crate::utils::{last_path_segment, snippet, span_lint_and_sugg};
 use rustc_hir::{GenericArg, Mutability, Ty, TyKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -12,7 +12,8 @@ declare_clippy_lint! {
     /// **Why is this bad?** Since `&` is Copy, it's useless to have a
     /// reference on `Option<&T>`.
     ///
-    /// **Known problems:** None.
+    /// **Known problems:** It may be irrevelent to use this lint on
+    /// public API code as it will make a breaking change to apply it.
     ///
     /// **Example:**
     ///
-- 
cgit 1.4.1-3-g733a5


From db40a07665f74e58fbf2f161dcd618f6945ec0e3 Mon Sep 17 00:00:00 2001
From: dvermd <315743+dvermd@users.noreply.github.com>
Date: Tue, 20 Oct 2020 01:23:39 +0200
Subject: Update clippy_lints/src/ref_option_ref.rs

Co-authored-by: Philipp Krones <hello@philkrones.com>
---
 clippy_lints/src/ref_option_ref.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/ref_option_ref.rs b/clippy_lints/src/ref_option_ref.rs
index 715938df138..a83f11bf670 100644
--- a/clippy_lints/src/ref_option_ref.rs
+++ b/clippy_lints/src/ref_option_ref.rs
@@ -25,7 +25,7 @@ declare_clippy_lint! {
     /// let x: Option<&u32> = Some(&0u32);
     /// ```
     pub REF_OPTION_REF,
-    style,
+    pedantic,
     "use `Option<&T>` instead of `&Option<&T>`"
 }
 
-- 
cgit 1.4.1-3-g733a5


From ffddb669e02e5f38620d839756bb2d02fff6c5e8 Mon Sep 17 00:00:00 2001
From: dvermd <315743+dvermd@users.noreply.github.com>
Date: Tue, 20 Oct 2020 07:11:25 +0200
Subject: clippy_lint: run  after changing category to pendantic

---
 clippy_lints/src/lib.rs | 3 +--
 src/lintlist/mod.rs     | 2 +-
 2 files changed, 2 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 1ab36231758..cdfad908fc2 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1255,6 +1255,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&pass_by_ref_or_value::TRIVIALLY_COPY_PASS_BY_REF),
         LintId::of(&ranges::RANGE_MINUS_ONE),
         LintId::of(&ranges::RANGE_PLUS_ONE),
+        LintId::of(&ref_option_ref::REF_OPTION_REF),
         LintId::of(&shadow::SHADOW_UNRELATED),
         LintId::of(&strings::STRING_ADD_ASSIGN),
         LintId::of(&trait_bounds::TRAIT_DUPLICATION_IN_BOUNDS),
@@ -1496,7 +1497,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&redundant_closure_call::REDUNDANT_CLOSURE_CALL),
         LintId::of(&redundant_field_names::REDUNDANT_FIELD_NAMES),
         LintId::of(&redundant_static_lifetimes::REDUNDANT_STATIC_LIFETIMES),
-        LintId::of(&ref_option_ref::REF_OPTION_REF),
         LintId::of(&reference::DEREF_ADDROF),
         LintId::of(&reference::REF_IN_DEREF),
         LintId::of(&regex::INVALID_REGEX),
@@ -1652,7 +1652,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&ranges::MANUAL_RANGE_CONTAINS),
         LintId::of(&redundant_field_names::REDUNDANT_FIELD_NAMES),
         LintId::of(&redundant_static_lifetimes::REDUNDANT_STATIC_LIFETIMES),
-        LintId::of(&ref_option_ref::REF_OPTION_REF),
         LintId::of(&regex::TRIVIAL_REGEX),
         LintId::of(&returns::LET_AND_RETURN),
         LintId::of(&returns::NEEDLESS_RETURN),
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index b3bd1923d4e..8398c132b33 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -2015,7 +2015,7 @@ vec![
     },
     Lint {
         name: "ref_option_ref",
-        group: "style",
+        group: "pedantic",
         desc: "use `Option<&T>` instead of `&Option<&T>`",
         deprecation: None,
         module: "ref_option_ref",
-- 
cgit 1.4.1-3-g733a5


From 8337c467e9968b91277f0c0ae113e2d4917ac55e Mon Sep 17 00:00:00 2001
From: dvermd <315743+dvermd@users.noreply.github.com>
Date: Mon, 26 Oct 2020 22:33:48 +0100
Subject: Change Applicability to MaybeIncorrect

Co-authored-by: Philipp Krones <hello@philkrones.com>
---
 clippy_lints/src/ref_option_ref.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/ref_option_ref.rs b/clippy_lints/src/ref_option_ref.rs
index a83f11bf670..e8c60842e76 100644
--- a/clippy_lints/src/ref_option_ref.rs
+++ b/clippy_lints/src/ref_option_ref.rs
@@ -58,7 +58,7 @@ impl<'tcx> LateLintPass<'tcx> for RefOptionRef {
                     "since & implements Copy trait, &Option<&T> can be simplifyied into Option<&T>",
                     "try",
                     format!("Option<{}>", &snippet(cx, inner_ty.span, "..")),
-                    Applicability::Unspecified,
+                    Applicability::MaybeIncorrect,
                 );
             }
         }
-- 
cgit 1.4.1-3-g733a5


From e568a328f9eb528653351643b1482ccecada1480 Mon Sep 17 00:00:00 2001
From: rail <12975677+rail-rain@users.noreply.github.com>
Date: Wed, 21 Oct 2020 09:42:00 +1300
Subject: fix the error-causing suggestion of 'borrowed_box'

fix the error-causing suggestion of 'borrowed_box',
which missed parentheses and was ambiguous.
---
 clippy_lints/src/types.rs  | 44 ++++++++++++++++++++++++++++++++--------
 tests/ui/borrow_box.rs     | 16 +++++++++++++++
 tests/ui/borrow_box.stderr | 50 ++++++++++++++++++++++++++++++++++++++++++----
 3 files changed, 98 insertions(+), 12 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs
index 6a33aaaaab2..45f3bc3ea85 100644
--- a/clippy_lints/src/types.rs
+++ b/clippy_lints/src/types.rs
@@ -10,9 +10,9 @@ use rustc_errors::{Applicability, DiagnosticBuilder};
 use rustc_hir as hir;
 use rustc_hir::intravisit::{walk_body, walk_expr, walk_ty, FnKind, NestedVisitorMap, Visitor};
 use rustc_hir::{
-    BinOpKind, Block, Body, Expr, ExprKind, FnDecl, FnRetTy, FnSig, GenericArg, GenericParamKind, HirId, ImplItem,
-    ImplItemKind, Item, ItemKind, Lifetime, Lit, Local, MatchSource, MutTy, Mutability, Node, QPath, Stmt, StmtKind,
-    TraitFn, TraitItem, TraitItemKind, TyKind, UnOp,
+    BinOpKind, Block, Body, Expr, ExprKind, FnDecl, FnRetTy, FnSig, GenericArg, GenericBounds, GenericParamKind, HirId,
+    ImplItem, ImplItemKind, Item, ItemKind, Lifetime, Lit, Local, MatchSource, MutTy, Mutability, Node, QPath, Stmt,
+    StmtKind, SyntheticTyParamKind, TraitFn, TraitItem, TraitItemKind, TyKind, UnOp,
 };
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::hir::map::Map;
@@ -678,17 +678,30 @@ impl Types {
                             // details.
                             return;
                         }
+
+                        // When trait objects or opaque types have lifetime or auto-trait bounds,
+                        // we need to add parentheses to avoid a syntax error due to its ambiguity.
+                        // Originally reported as the issue #3128.
+                        let inner_snippet = snippet(cx, inner.span, "..");
+                        let suggestion = match &inner.kind {
+                            TyKind::TraitObject(bounds, lt_bound) if bounds.len() > 1 || !lt_bound.is_elided() => {
+                                format!("&{}({})", ltopt, &inner_snippet)
+                            },
+                            TyKind::Path(qpath)
+                                if get_bounds_if_impl_trait(cx, qpath, inner.hir_id)
+                                    .map_or(false, |bounds| bounds.len() > 1) =>
+                            {
+                                format!("&{}({})", ltopt, &inner_snippet)
+                            },
+                            _ => format!("&{}{}", ltopt, &inner_snippet),
+                        };
                         span_lint_and_sugg(
                             cx,
                             BORROWED_BOX,
                             hir_ty.span,
                             "you seem to be trying to use `&Box<T>`. Consider using just `&T`",
                             "try",
-                            format!(
-                                "&{}{}",
-                                ltopt,
-                                &snippet(cx, inner.span, "..")
-                            ),
+                            suggestion,
                             // To make this `MachineApplicable`, at least one needs to check if it isn't a trait item
                             // because the trait impls of it will break otherwise;
                             // and there may be other cases that result in invalid code.
@@ -721,6 +734,21 @@ fn is_any_trait(t: &hir::Ty<'_>) -> bool {
     false
 }
 
+fn get_bounds_if_impl_trait<'tcx>(cx: &LateContext<'tcx>, qpath: &QPath<'_>, id: HirId) -> Option<GenericBounds<'tcx>> {
+    if_chain! {
+        if let Some(did) = qpath_res(cx, qpath, id).opt_def_id();
+        if let Some(node) = cx.tcx.hir().get_if_local(did);
+        if let Node::GenericParam(generic_param) = node;
+        if let GenericParamKind::Type { synthetic, .. } = generic_param.kind;
+        if synthetic == Some(SyntheticTyParamKind::ImplTrait);
+        then {
+            Some(generic_param.bounds)
+        } else {
+            None
+        }
+    }
+}
+
 declare_clippy_lint! {
     /// **What it does:** Checks for binding a unit value.
     ///
diff --git a/tests/ui/borrow_box.rs b/tests/ui/borrow_box.rs
index 1901de46ca8..b606f773cfb 100644
--- a/tests/ui/borrow_box.rs
+++ b/tests/ui/borrow_box.rs
@@ -3,6 +3,8 @@
 #![allow(unused_variables)]
 #![allow(dead_code)]
 
+use std::fmt::Display;
+
 pub fn test1(foo: &mut Box<bool>) {
     // Although this function could be changed to "&mut bool",
     // avoiding the Box, mutable references to boxes are not
@@ -89,6 +91,20 @@ pub fn test13(boxed_slice: &mut Box<[i32]>) {
     *boxed_slice = data.into_boxed_slice();
 }
 
+// The suggestion should include proper parentheses to avoid a syntax error.
+pub fn test14(_display: &Box<dyn Display>) {}
+pub fn test15(_display: &Box<dyn Display + Send>) {}
+pub fn test16<'a>(_display: &'a Box<dyn Display + 'a>) {}
+
+pub fn test17(_display: &Box<impl Display>) {}
+pub fn test18(_display: &Box<impl Display + Send>) {}
+pub fn test19<'a>(_display: &'a Box<impl Display + 'a>) {}
+
+// This exists only to check what happens when parentheses are already present.
+// Even though the current implementation doesn't put extra parentheses,
+// it's fine that unnecessary parentheses appear in the future for some reason.
+pub fn test20(_display: &Box<(dyn Display + Send)>) {}
+
 fn main() {
     test1(&mut Box::new(false));
     test2();
diff --git a/tests/ui/borrow_box.stderr b/tests/ui/borrow_box.stderr
index b5db691f89f..3eac32815be 100644
--- a/tests/ui/borrow_box.stderr
+++ b/tests/ui/borrow_box.stderr
@@ -1,5 +1,5 @@
 error: you seem to be trying to use `&Box<T>`. Consider using just `&T`
-  --> $DIR/borrow_box.rs:19:14
+  --> $DIR/borrow_box.rs:21:14
    |
 LL |     let foo: &Box<bool>;
    |              ^^^^^^^^^^ help: try: `&bool`
@@ -11,16 +11,58 @@ LL | #![deny(clippy::borrowed_box)]
    |         ^^^^^^^^^^^^^^^^^^^^
 
 error: you seem to be trying to use `&Box<T>`. Consider using just `&T`
-  --> $DIR/borrow_box.rs:23:10
+  --> $DIR/borrow_box.rs:25:10
    |
 LL |     foo: &'a Box<bool>,
    |          ^^^^^^^^^^^^^ help: try: `&'a bool`
 
 error: you seem to be trying to use `&Box<T>`. Consider using just `&T`
-  --> $DIR/borrow_box.rs:27:17
+  --> $DIR/borrow_box.rs:29:17
    |
 LL |     fn test4(a: &Box<bool>);
    |                 ^^^^^^^^^^ help: try: `&bool`
 
-error: aborting due to 3 previous errors
+error: you seem to be trying to use `&Box<T>`. Consider using just `&T`
+  --> $DIR/borrow_box.rs:95:25
+   |
+LL | pub fn test14(_display: &Box<dyn Display>) {}
+   |                         ^^^^^^^^^^^^^^^^^ help: try: `&dyn Display`
+
+error: you seem to be trying to use `&Box<T>`. Consider using just `&T`
+  --> $DIR/borrow_box.rs:96:25
+   |
+LL | pub fn test15(_display: &Box<dyn Display + Send>) {}
+   |                         ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&(dyn Display + Send)`
+
+error: you seem to be trying to use `&Box<T>`. Consider using just `&T`
+  --> $DIR/borrow_box.rs:97:29
+   |
+LL | pub fn test16<'a>(_display: &'a Box<dyn Display + 'a>) {}
+   |                             ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&'a (dyn Display + 'a)`
+
+error: you seem to be trying to use `&Box<T>`. Consider using just `&T`
+  --> $DIR/borrow_box.rs:99:25
+   |
+LL | pub fn test17(_display: &Box<impl Display>) {}
+   |                         ^^^^^^^^^^^^^^^^^^ help: try: `&impl Display`
+
+error: you seem to be trying to use `&Box<T>`. Consider using just `&T`
+  --> $DIR/borrow_box.rs:100:25
+   |
+LL | pub fn test18(_display: &Box<impl Display + Send>) {}
+   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&(impl Display + Send)`
+
+error: you seem to be trying to use `&Box<T>`. Consider using just `&T`
+  --> $DIR/borrow_box.rs:101:29
+   |
+LL | pub fn test19<'a>(_display: &'a Box<impl Display + 'a>) {}
+   |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&'a (impl Display + 'a)`
+
+error: you seem to be trying to use `&Box<T>`. Consider using just `&T`
+  --> $DIR/borrow_box.rs:106:25
+   |
+LL | pub fn test20(_display: &Box<(dyn Display + Send)>) {}
+   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&(dyn Display + Send)`
+
+error: aborting due to 10 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 111b9023dad65721300a39c3cf337f6bfb96d5d3 Mon Sep 17 00:00:00 2001
From: Tim Nielens <tim.nielens@gmail.com>
Date: Tue, 27 Oct 2020 01:47:40 +0100
Subject: add manual_ok_or lint

---
 CHANGELOG.md                     |  1 +
 clippy_lints/src/lib.rs          |  4 ++
 clippy_lints/src/manual_ok_or.rs | 97 ++++++++++++++++++++++++++++++++++++++++
 src/lintlist/mod.rs              |  7 +++
 tests/ui/manual_ok_or.fixed      | 40 +++++++++++++++++
 tests/ui/manual_ok_or.rs         | 44 ++++++++++++++++++
 tests/ui/manual_ok_or.stderr     | 41 +++++++++++++++++
 7 files changed, 234 insertions(+)
 create mode 100644 clippy_lints/src/manual_ok_or.rs
 create mode 100644 tests/ui/manual_ok_or.fixed
 create mode 100644 tests/ui/manual_ok_or.rs
 create mode 100644 tests/ui/manual_ok_or.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 25f3b5da198..cd884e0665d 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1795,6 +1795,7 @@ Released 2018-09-13
 [`manual_async_fn`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_async_fn
 [`manual_memcpy`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_memcpy
 [`manual_non_exhaustive`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_non_exhaustive
+[`manual_ok_or`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_ok_or
 [`manual_range_contains`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_range_contains
 [`manual_saturating_arithmetic`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_saturating_arithmetic
 [`manual_strip`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_strip
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 3be8bc0e36d..9b6f8e73454 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -233,6 +233,7 @@ mod macro_use;
 mod main_recursion;
 mod manual_async_fn;
 mod manual_non_exhaustive;
+mod manual_ok_or;
 mod manual_strip;
 mod manual_unwrap_or;
 mod map_clone;
@@ -645,6 +646,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &main_recursion::MAIN_RECURSION,
         &manual_async_fn::MANUAL_ASYNC_FN,
         &manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE,
+        &manual_ok_or::MANUAL_OK_OR,
         &manual_strip::MANUAL_STRIP,
         &manual_unwrap_or::MANUAL_UNWRAP_OR,
         &map_clone::MAP_CLONE,
@@ -1140,6 +1142,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box unwrap_in_result::UnwrapInResult);
     store.register_late_pass(|| box self_assignment::SelfAssignment);
     store.register_late_pass(|| box manual_unwrap_or::ManualUnwrapOr);
+    store.register_late_pass(|| box manual_ok_or::ManualOkOr);
     store.register_late_pass(|| box float_equality_without_abs::FloatEqualityWithoutAbs);
     store.register_late_pass(|| box async_yields_async::AsyncYieldsAsync);
     store.register_late_pass(|| box manual_strip::ManualStrip);
@@ -1229,6 +1232,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&loops::EXPLICIT_INTO_ITER_LOOP),
         LintId::of(&loops::EXPLICIT_ITER_LOOP),
         LintId::of(&macro_use::MACRO_USE_IMPORTS),
+        LintId::of(&manual_ok_or::MANUAL_OK_OR),
         LintId::of(&map_err_ignore::MAP_ERR_IGNORE),
         LintId::of(&match_on_vec_items::MATCH_ON_VEC_ITEMS),
         LintId::of(&matches::MATCH_BOOL),
diff --git a/clippy_lints/src/manual_ok_or.rs b/clippy_lints/src/manual_ok_or.rs
new file mode 100644
index 00000000000..38298eb813a
--- /dev/null
+++ b/clippy_lints/src/manual_ok_or.rs
@@ -0,0 +1,97 @@
+use crate::utils;
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir::{def, Expr, ExprKind, PatKind, QPath};
+use rustc_lint::LintContext;
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::lint::in_external_macro;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// **What it does:**
+    /// Finds patterns that reimplement `Option::ok_or`.
+    ///
+    /// **Why is this bad?**
+    /// Concise code helps focusing on behavior instead of boilerplate.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Examples:**
+    /// ```rust
+    /// let foo: Option<i32> = None;
+    /// foo.map_or(Err("error"), |v| Ok(v));
+    ///
+    /// let foo: Option<i32> = None;
+    /// foo.map_or(Err("error"), |v| Ok(v));
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust
+    /// let foo: Option<i32> = None;
+    /// foo.ok_or("error");
+    /// ```
+    pub MANUAL_OK_OR,
+    pedantic,
+    "finds patterns that can be encoded more concisely with `Option::ok_or`"
+}
+
+declare_lint_pass!(ManualOkOr => [MANUAL_OK_OR]);
+
+impl LateLintPass<'_> for ManualOkOr {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, scrutinee: &'tcx Expr<'tcx>) {
+        if in_external_macro(cx.sess(), scrutinee.span) {
+            return;
+        }
+
+        if_chain! {
+            if let ExprKind::MethodCall(method_segment, _, args, _) = scrutinee.kind;
+            if method_segment.ident.name == sym!(map_or);
+            if args.len() == 3;
+            let method_receiver = &args[0];
+            let ty = cx.typeck_results().expr_ty(method_receiver);
+            if utils::is_type_diagnostic_item(cx, ty, sym!(option_type));
+            let or_expr = &args[1];
+            if is_ok_wrapping(cx, &args[2]);
+            if let ExprKind::Call(Expr { kind: ExprKind::Path(err_path), .. }, &[ref err_arg]) = or_expr.kind;
+            if utils::match_qpath(err_path, &utils::paths::RESULT_ERR);
+            if let Some(method_receiver_snippet) = utils::snippet_opt(cx, method_receiver.span);
+            if let Some(err_arg_snippet) = utils::snippet_opt(cx, err_arg.span);
+            if let Some(indent) = utils::indent_of(cx, scrutinee.span);
+            then {
+                let reindented_err_arg_snippet =
+                    utils::reindent_multiline(err_arg_snippet.into(), true, Some(indent + 4));
+                utils::span_lint_and_sugg(
+                    cx,
+                    MANUAL_OK_OR,
+                    scrutinee.span,
+                    "this pattern reimplements `Option::ok_or`",
+                    "replace with",
+                    format!(
+                        "{}.ok_or({})",
+                        method_receiver_snippet,
+                        reindented_err_arg_snippet
+                    ),
+                    Applicability::MachineApplicable,
+                );
+            }
+        }
+    }
+}
+
+fn is_ok_wrapping(cx: &LateContext<'_>, map_expr: &Expr<'_>) -> bool {
+    if let ExprKind::Path(ref qpath) = map_expr.kind {
+        if utils::match_qpath(qpath, &utils::paths::RESULT_OK) {
+            return true;
+        }
+    }
+    if_chain! {
+        if let ExprKind::Closure(_, _, body_id, ..) = map_expr.kind;
+        let body = cx.tcx.hir().body(body_id);
+        if let PatKind::Binding(_, param_id, ..) = body.params[0].pat.kind;
+        if let ExprKind::Call(Expr { kind: ExprKind::Path(ok_path), .. }, &[ref ok_arg]) = body.value.kind;
+        if utils::match_qpath(ok_path, &utils::paths::RESULT_OK);
+        if let ExprKind::Path(QPath::Resolved(_, ok_arg_path)) = ok_arg.kind;
+        if let def::Res::Local(ok_arg_path_id) = ok_arg_path.res;
+        then { param_id == ok_arg_path_id } else { false }
+    }
+}
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index 6272ce45efb..f438da00720 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -1173,6 +1173,13 @@ vec![
         deprecation: None,
         module: "manual_non_exhaustive",
     },
+    Lint {
+        name: "manual_ok_or",
+        group: "pedantic",
+        desc: "finds patterns that can be encoded more concisely with `Option::ok_or`",
+        deprecation: None,
+        module: "manual_ok_or",
+    },
     Lint {
         name: "manual_range_contains",
         group: "style",
diff --git a/tests/ui/manual_ok_or.fixed b/tests/ui/manual_ok_or.fixed
new file mode 100644
index 00000000000..b42e94bd727
--- /dev/null
+++ b/tests/ui/manual_ok_or.fixed
@@ -0,0 +1,40 @@
+// run-rustfix
+#![warn(clippy::manual_ok_or)]
+#![allow(clippy::blacklisted_name)]
+#![allow(clippy::redundant_closure)]
+#![allow(dead_code)]
+#![allow(unused_must_use)]
+
+fn main() {
+    // basic case
+    let foo: Option<i32> = None;
+    foo.ok_or("error");
+
+    // eta expansion case
+    foo.ok_or("error");
+
+    // turbo fish syntax
+    None::<i32>.ok_or("error");
+
+    // multiline case
+    #[rustfmt::skip]
+    foo.ok_or(&format!(
+        "{}{}{}{}{}{}{}",
+        "Alice", "Bob", "Sarah", "Marc", "Sandra", "Eric", "Jenifer"));
+
+    // not applicable, closure isn't direct `Ok` wrapping
+    foo.map_or(Err("error"), |v| Ok(v + 1));
+
+    // not applicable, or side isn't `Result::Err`
+    foo.map_or(Ok::<i32, &str>(1), |v| Ok(v));
+
+    // not applicatble, expr is not a `Result` value
+    foo.map_or(42, |v| v);
+
+    // TODO patterns not covered yet
+    match foo {
+        Some(v) => Ok(v),
+        None => Err("error"),
+    };
+    foo.map_or_else(|| Err("error"), |v| Ok(v));
+}
diff --git a/tests/ui/manual_ok_or.rs b/tests/ui/manual_ok_or.rs
new file mode 100644
index 00000000000..e5a6056fbf5
--- /dev/null
+++ b/tests/ui/manual_ok_or.rs
@@ -0,0 +1,44 @@
+// run-rustfix
+#![warn(clippy::manual_ok_or)]
+#![allow(clippy::blacklisted_name)]
+#![allow(clippy::redundant_closure)]
+#![allow(dead_code)]
+#![allow(unused_must_use)]
+
+fn main() {
+    // basic case
+    let foo: Option<i32> = None;
+    foo.map_or(Err("error"), |v| Ok(v));
+
+    // eta expansion case
+    foo.map_or(Err("error"), Ok);
+
+    // turbo fish syntax
+    None::<i32>.map_or(Err("error"), |v| Ok(v));
+
+    // multiline case
+    #[rustfmt::skip]
+    foo.map_or(Err::<i32, &str>(
+        &format!(
+            "{}{}{}{}{}{}{}",
+            "Alice", "Bob", "Sarah", "Marc", "Sandra", "Eric", "Jenifer")
+        ),
+        |v| Ok(v),
+    );
+
+    // not applicable, closure isn't direct `Ok` wrapping
+    foo.map_or(Err("error"), |v| Ok(v + 1));
+
+    // not applicable, or side isn't `Result::Err`
+    foo.map_or(Ok::<i32, &str>(1), |v| Ok(v));
+
+    // not applicatble, expr is not a `Result` value
+    foo.map_or(42, |v| v);
+
+    // TODO patterns not covered yet
+    match foo {
+        Some(v) => Ok(v),
+        None => Err("error"),
+    };
+    foo.map_or_else(|| Err("error"), |v| Ok(v));
+}
diff --git a/tests/ui/manual_ok_or.stderr b/tests/ui/manual_ok_or.stderr
new file mode 100644
index 00000000000..8ea10ac5436
--- /dev/null
+++ b/tests/ui/manual_ok_or.stderr
@@ -0,0 +1,41 @@
+error: this pattern reimplements `Option::ok_or`
+  --> $DIR/manual_ok_or.rs:11:5
+   |
+LL |     foo.map_or(Err("error"), |v| Ok(v));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `foo.ok_or("error")`
+   |
+   = note: `-D clippy::manual-ok-or` implied by `-D warnings`
+
+error: this pattern reimplements `Option::ok_or`
+  --> $DIR/manual_ok_or.rs:14:5
+   |
+LL |     foo.map_or(Err("error"), Ok);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `foo.ok_or("error")`
+
+error: this pattern reimplements `Option::ok_or`
+  --> $DIR/manual_ok_or.rs:17:5
+   |
+LL |     None::<i32>.map_or(Err("error"), |v| Ok(v));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `None::<i32>.ok_or("error")`
+
+error: this pattern reimplements `Option::ok_or`
+  --> $DIR/manual_ok_or.rs:21:5
+   |
+LL | /     foo.map_or(Err::<i32, &str>(
+LL | |         &format!(
+LL | |             "{}{}{}{}{}{}{}",
+LL | |             "Alice", "Bob", "Sarah", "Marc", "Sandra", "Eric", "Jenifer")
+LL | |         ),
+LL | |         |v| Ok(v),
+LL | |     );
+   | |_____^
+   |
+help: replace with
+   |
+LL |     foo.ok_or(&format!(
+LL |         "{}{}{}{}{}{}{}",
+LL |         "Alice", "Bob", "Sarah", "Marc", "Sandra", "Eric", "Jenifer"));
+   |
+
+error: aborting due to 4 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 66d56fefc5b7ce22d2db65ee9dc1a5f9f6bf2f09 Mon Sep 17 00:00:00 2001
From: Michael Wright <mikerite@lavabit.com>
Date: Tue, 27 Oct 2020 07:42:13 +0200
Subject: Add `invalid_paths` internal lint

---
 clippy_lints/src/lib.rs                  |  3 ++
 clippy_lints/src/utils/internal_lints.rs | 79 ++++++++++++++++++++++++++++++++
 clippy_lints/src/utils/mod.rs            | 25 ++++++++++
 tests/ui/invalid_paths.rs                | 23 ++++++++++
 tests/ui/invalid_paths.stderr            | 16 +++++++
 5 files changed, 146 insertions(+)
 create mode 100644 tests/ui/invalid_paths.rs
 create mode 100644 tests/ui/invalid_paths.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 3be8bc0e36d..7c8cb90fe1c 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -892,6 +892,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &utils::internal_lints::COLLAPSIBLE_SPAN_LINT_CALLS,
         &utils::internal_lints::COMPILER_LINT_FUNCTIONS,
         &utils::internal_lints::DEFAULT_LINT,
+        &utils::internal_lints::INVALID_PATHS,
         &utils::internal_lints::LINT_WITHOUT_LINT_PASS,
         &utils::internal_lints::MATCH_TYPE_ON_DIAGNOSTIC_ITEM,
         &utils::internal_lints::OUTER_EXPN_EXPN_DATA,
@@ -919,6 +920,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box utils::internal_lints::CompilerLintFunctions::new());
     store.register_late_pass(|| box utils::internal_lints::LintWithoutLintPass::default());
     store.register_late_pass(|| box utils::internal_lints::OuterExpnDataPass);
+    store.register_late_pass(|| box utils::internal_lints::InvalidPaths);
     store.register_late_pass(|| box utils::inspector::DeepCodeInspector);
     store.register_late_pass(|| box utils::author::Author);
     let vec_box_size_threshold = conf.vec_box_size_threshold;
@@ -1280,6 +1282,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&utils::internal_lints::COLLAPSIBLE_SPAN_LINT_CALLS),
         LintId::of(&utils::internal_lints::COMPILER_LINT_FUNCTIONS),
         LintId::of(&utils::internal_lints::DEFAULT_LINT),
+        LintId::of(&utils::internal_lints::INVALID_PATHS),
         LintId::of(&utils::internal_lints::LINT_WITHOUT_LINT_PASS),
         LintId::of(&utils::internal_lints::MATCH_TYPE_ON_DIAGNOSTIC_ITEM),
         LintId::of(&utils::internal_lints::OUTER_EXPN_EXPN_DATA),
diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs
index bfe426a25eb..6ca72d895c8 100644
--- a/clippy_lints/src/utils/internal_lints.rs
+++ b/clippy_lints/src/utils/internal_lints.rs
@@ -1,3 +1,4 @@
+use crate::consts::{constant_simple, Constant};
 use crate::utils::{
     is_expn_of, match_def_path, match_qpath, match_type, method_calls, path_to_res, paths, qpath_res, run_lints,
     snippet, span_lint, span_lint_and_help, span_lint_and_sugg, SpanlessEq,
@@ -14,9 +15,11 @@ use rustc_hir::intravisit::{NestedVisitorMap, Visitor};
 use rustc_hir::{Crate, Expr, ExprKind, HirId, Item, MutTy, Mutability, Node, Path, StmtKind, Ty, TyKind};
 use rustc_lint::{EarlyContext, EarlyLintPass, LateContext, LateLintPass};
 use rustc_middle::hir::map::Map;
+use rustc_middle::ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::{Span, Spanned};
 use rustc_span::symbol::{Symbol, SymbolStr};
+use rustc_typeck::hir_ty_to_ty;
 
 use std::borrow::{Borrow, Cow};
 
@@ -229,6 +232,21 @@ declare_clippy_lint! {
     "using `utils::match_type()` instead of `utils::is_type_diagnostic_item()`"
 }
 
+declare_clippy_lint! {
+    /// **What it does:**
+    /// Checks the paths module for invalid paths.
+    ///
+    /// **Why is this bad?**
+    /// It indicates a bug in the code.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:** None.
+    pub INVALID_PATHS,
+    internal,
+    "invalid path"
+}
+
 declare_lint_pass!(ClippyLintsInternal => [CLIPPY_LINTS_INTERNAL]);
 
 impl EarlyLintPass for ClippyLintsInternal {
@@ -761,3 +779,64 @@ fn path_to_matched_type(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> Option<Ve
 
     None
 }
+
+// This is not a complete resolver for paths. It works on all the paths currently used in the paths
+// module.  That's all it does and all it needs to do.
+pub fn check_path(cx: &LateContext<'_>, path: &[&str]) -> bool {
+    if path_to_res(cx, path).is_some() {
+        return true;
+    }
+
+    // Some implementations can't be found by `path_to_res`, particularly inherent
+    // implementations of native types. Check lang items.
+    let path_syms: Vec<_> = path.iter().map(|p| Symbol::intern(p)).collect();
+    let lang_items = cx.tcx.lang_items();
+    for lang_item in lang_items.items() {
+        if let Some(def_id) = lang_item {
+            let lang_item_path = cx.get_def_path(*def_id);
+            if path_syms.starts_with(&lang_item_path) {
+                if let [item] = &path_syms[lang_item_path.len()..] {
+                    for child in cx.tcx.item_children(*def_id) {
+                        if child.ident.name == *item {
+                            return true;
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    false
+}
+
+declare_lint_pass!(InvalidPaths => [INVALID_PATHS]);
+
+impl<'tcx> LateLintPass<'tcx> for InvalidPaths {
+    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
+        let local_def_id = &cx.tcx.parent_module(item.hir_id);
+        let mod_name = &cx.tcx.item_name(local_def_id.to_def_id());
+        if_chain! {
+            if mod_name.as_str() == "paths";
+            if let hir::ItemKind::Const(ty, body_id) = item.kind;
+            let ty = hir_ty_to_ty(cx.tcx, ty);
+            if let ty::Array(el_ty, _) = &ty.kind();
+            if let ty::Ref(_, el_ty, _) = &el_ty.kind();
+            if el_ty.is_str();
+            let body = cx.tcx.hir().body(body_id);
+            let typeck_results = cx.tcx.typeck_body(body_id);
+            if let Some(Constant::Vec(path)) = constant_simple(cx, typeck_results, &body.value);
+            let path: Vec<&str> = path.iter().map(|x| {
+                    if let Constant::Str(s) = x {
+                        s.as_str()
+                    } else {
+                        // We checked the type of the constant above
+                        unreachable!()
+                    }
+                }).collect();
+            if !check_path(cx, &path[..]);
+            then {
+                span_lint(cx, CLIPPY_LINTS_INTERNAL, item.span, "invalid path");
+            }
+        }
+    }
+}
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index 8297b9d128d..a1ecca0961a 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -268,6 +268,7 @@ pub fn path_to_res(cx: &LateContext<'_>, path: &[&str]) -> Option<def::Res> {
             krate: *krate,
             index: CRATE_DEF_INDEX,
         };
+        let mut current_item = None;
         let mut items = cx.tcx.item_children(krate);
         let mut path_it = path.iter().skip(1).peekable();
 
@@ -277,6 +278,12 @@ pub fn path_to_res(cx: &LateContext<'_>, path: &[&str]) -> Option<def::Res> {
                 None => return None,
             };
 
+            // `get_def_path` seems to generate these empty segments for extern blocks.
+            // We can just ignore them.
+            if segment.is_empty() {
+                continue;
+            }
+
             let result = SmallVec::<[_; 8]>::new();
             for item in mem::replace(&mut items, cx.tcx.arena.alloc_slice(&result)).iter() {
                 if item.ident.name.as_str() == *segment {
@@ -284,10 +291,28 @@ pub fn path_to_res(cx: &LateContext<'_>, path: &[&str]) -> Option<def::Res> {
                         return Some(item.res);
                     }
 
+                    current_item = Some(item);
                     items = cx.tcx.item_children(item.res.def_id());
                     break;
                 }
             }
+
+            // The segment isn't a child_item.
+            // Try to find it under an inherent impl.
+            if_chain! {
+                if path_it.peek().is_none();
+                if let Some(current_item) = current_item;
+                let item_def_id = current_item.res.def_id();
+                if cx.tcx.def_kind(item_def_id) == DefKind::Struct;
+                then {
+                    // Bad `find_map` suggestion. See #4193.
+                    #[allow(clippy::find_map)]
+                    return cx.tcx.inherent_impls(item_def_id).iter()
+                        .flat_map(|&impl_def_id| cx.tcx.item_children(impl_def_id))
+                        .find(|item| item.ident.name.as_str() == *segment)
+                        .map(|item| item.res);
+                }
+            }
         }
     } else {
         None
diff --git a/tests/ui/invalid_paths.rs b/tests/ui/invalid_paths.rs
new file mode 100644
index 00000000000..01e28ae5e9d
--- /dev/null
+++ b/tests/ui/invalid_paths.rs
@@ -0,0 +1,23 @@
+#![warn(clippy::internal)]
+
+mod paths {
+    // Good path
+    pub const ANY_TRAIT: [&str; 3] = ["std", "any", "Any"];
+
+    // Path to method on inherent impl of a primitive type
+    pub const F32_EPSILON: [&str; 4] = ["core", "f32", "<impl f32>", "EPSILON"];
+
+    // Path to method on inherent impl
+    pub const ARC_PTR_EQ: [&str; 4] = ["alloc", "sync", "Arc", "ptr_eq"];
+
+    // Path with empty segment
+    pub const TRANSMUTE: [&str; 4] = ["core", "intrinsics", "", "transmute"];
+
+    // Path with bad crate
+    pub const BAD_CRATE_PATH: [&str; 2] = ["bad", "path"];
+
+    // Path with bad module
+    pub const BAD_MOD_PATH: [&str; 2] = ["std", "xxx"];
+}
+
+fn main() {}
diff --git a/tests/ui/invalid_paths.stderr b/tests/ui/invalid_paths.stderr
new file mode 100644
index 00000000000..bd69d661b71
--- /dev/null
+++ b/tests/ui/invalid_paths.stderr
@@ -0,0 +1,16 @@
+error: invalid path
+  --> $DIR/invalid_paths.rs:17:5
+   |
+LL |     pub const BAD_CRATE_PATH: [&str; 2] = ["bad", "path"];
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::clippy-lints-internal` implied by `-D warnings`
+
+error: invalid path
+  --> $DIR/invalid_paths.rs:20:5
+   |
+LL |     pub const BAD_MOD_PATH: [&str; 2] = ["std", "xxx"];
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From f79c4afd3a5c408bd9253311b224773702a912df Mon Sep 17 00:00:00 2001
From: Michael Wright <mikerite@lavabit.com>
Date: Tue, 27 Oct 2020 07:43:38 +0200
Subject: Fix invalid paths

---
 clippy_lints/src/derive.rs                     | 10 +++++-----
 clippy_lints/src/float_equality_without_abs.rs |  6 ++++--
 clippy_lints/src/utils/paths.rs                | 16 ++++++++--------
 3 files changed, 17 insertions(+), 15 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/derive.rs b/clippy_lints/src/derive.rs
index bf8e030cc29..c75efc6e99f 100644
--- a/clippy_lints/src/derive.rs
+++ b/clippy_lints/src/derive.rs
@@ -1,6 +1,6 @@
 use crate::utils::paths;
 use crate::utils::{
-    get_trait_def_id, is_allowed, is_automatically_derived, is_copy, match_path, span_lint_and_help,
+    get_trait_def_id, is_allowed, is_automatically_derived, is_copy, match_def_path, match_path, span_lint_and_help,
     span_lint_and_note, span_lint_and_then,
 };
 use if_chain::if_chain;
@@ -193,10 +193,9 @@ fn check_hash_peq<'tcx>(
     hash_is_automatically_derived: bool,
 ) {
     if_chain! {
-        if match_path(&trait_ref.path, &paths::HASH);
         if let Some(peq_trait_def_id) = cx.tcx.lang_items().eq_trait();
-        if let Some(def_id) = &trait_ref.trait_def_id();
-        if !def_id.is_local();
+        if let Some(def_id) = trait_ref.trait_def_id();
+        if match_def_path(cx, def_id, &paths::HASH);
         then {
             // Look for the PartialEq implementations for `ty`
             cx.tcx.for_each_relevant_impl(peq_trait_def_id, ty, |impl_id| {
@@ -352,7 +351,8 @@ fn check_unsafe_derive_deserialize<'tcx>(
     }
 
     if_chain! {
-        if match_path(&trait_ref.path, &paths::SERDE_DESERIALIZE);
+        if let Some(trait_def_id) = trait_ref.trait_def_id();
+        if match_def_path(cx, trait_def_id, &paths::SERDE_DESERIALIZE);
         if let ty::Adt(def, _) = ty.kind();
         if let Some(local_def_id) = def.did.as_local();
         let adt_hir_id = cx.tcx.hir().local_def_id_to_hir_id(local_def_id);
diff --git a/clippy_lints/src/float_equality_without_abs.rs b/clippy_lints/src/float_equality_without_abs.rs
index 69818b4d3c6..c1c08597ee6 100644
--- a/clippy_lints/src/float_equality_without_abs.rs
+++ b/clippy_lints/src/float_equality_without_abs.rs
@@ -1,7 +1,8 @@
-use crate::utils::{match_qpath, paths, span_lint_and_then, sugg};
+use crate::utils::{match_def_path, paths, span_lint_and_then, sugg};
 use if_chain::if_chain;
 use rustc_ast::util::parser::AssocOp;
 use rustc_errors::Applicability;
+use rustc_hir::def::{DefKind, Res};
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
@@ -76,7 +77,8 @@ impl<'tcx> LateLintPass<'tcx> for FloatEqualityWithoutAbs {
 
             // right hand side matches either f32::EPSILON or f64::EPSILON
             if let ExprKind::Path(ref epsilon_path) = rhs.kind;
-            if match_qpath(epsilon_path, &paths::F32_EPSILON) || match_qpath(epsilon_path, &paths::F64_EPSILON);
+            if let Res::Def(DefKind::AssocConst, def_id) = cx.qpath_res(epsilon_path, rhs.hir_id);
+            if match_def_path(cx, def_id, &paths::F32_EPSILON) || match_def_path(cx, def_id, &paths::F64_EPSILON);
 
             // values of the substractions on the left hand side are of the type float
             let t_val_l = cx.typeck_results().expr_ty(val_l);
diff --git a/clippy_lints/src/utils/paths.rs b/clippy_lints/src/utils/paths.rs
index cd9b92efe58..d5a0e0d1f29 100644
--- a/clippy_lints/src/utils/paths.rs
+++ b/clippy_lints/src/utils/paths.rs
@@ -32,10 +32,10 @@ pub const DISPLAY_TRAIT: [&str; 3] = ["core", "fmt", "Display"];
 pub const DOUBLE_ENDED_ITERATOR: [&str; 4] = ["core", "iter", "traits", "DoubleEndedIterator"];
 pub const DROP: [&str; 3] = ["core", "mem", "drop"];
 pub const DURATION: [&str; 3] = ["core", "time", "Duration"];
-pub const EARLY_CONTEXT: [&str; 4] = ["rustc", "lint", "context", "EarlyContext"];
+pub const EARLY_CONTEXT: [&str; 2] = ["rustc_lint", "EarlyContext"];
 pub const EXIT: [&str; 3] = ["std", "process", "exit"];
-pub const F32_EPSILON: [&str; 2] = ["f32", "EPSILON"];
-pub const F64_EPSILON: [&str; 2] = ["f64", "EPSILON"];
+pub const F32_EPSILON: [&str; 4] = ["core", "f32", "<impl f32>", "EPSILON"];
+pub const F64_EPSILON: [&str; 4] = ["core", "f64", "<impl f64>", "EPSILON"];
 pub const FILE: [&str; 3] = ["std", "fs", "File"];
 pub const FILE_TYPE: [&str; 3] = ["std", "fs", "FileType"];
 pub const FMT_ARGUMENTS_NEW_V1: [&str; 4] = ["core", "fmt", "Arguments", "new_v1"];
@@ -47,7 +47,7 @@ pub const FN_ONCE: [&str; 3] = ["core", "ops", "FnOnce"];
 pub const FROM_FROM: [&str; 4] = ["core", "convert", "From", "from"];
 pub const FROM_TRAIT: [&str; 3] = ["core", "convert", "From"];
 pub const FUTURE_FROM_GENERATOR: [&str; 3] = ["core", "future", "from_generator"];
-pub const HASH: [&str; 2] = ["hash", "Hash"];
+pub const HASH: [&str; 3] = ["core", "hash", "Hash"];
 pub const HASHMAP: [&str; 5] = ["std", "collections", "hash", "map", "HashMap"];
 pub const HASHMAP_ENTRY: [&str; 5] = ["std", "collections", "hash", "map", "Entry"];
 pub const HASHSET: [&str; 5] = ["std", "collections", "hash", "set", "HashSet"];
@@ -58,7 +58,7 @@ pub const INTO_ITERATOR: [&str; 5] = ["core", "iter", "traits", "collect", "Into
 pub const IO_READ: [&str; 3] = ["std", "io", "Read"];
 pub const IO_WRITE: [&str; 3] = ["std", "io", "Write"];
 pub const ITERATOR: [&str; 5] = ["core", "iter", "traits", "iterator", "Iterator"];
-pub const LATE_CONTEXT: [&str; 4] = ["rustc", "lint", "context", "LateContext"];
+pub const LATE_CONTEXT: [&str; 2] = ["rustc_lint", "LateContext"];
 pub const LINKED_LIST: [&str; 4] = ["alloc", "collections", "linked_list", "LinkedList"];
 pub const LINT: [&str; 3] = ["rustc_session", "lint", "Lint"];
 pub const MEM_DISCRIMINANT: [&str; 3] = ["core", "mem", "discriminant"];
@@ -86,8 +86,8 @@ pub const PATH_BUF_AS_PATH: [&str; 4] = ["std", "path", "PathBuf", "as_path"];
 pub const PATH_TO_PATH_BUF: [&str; 4] = ["std", "path", "Path", "to_path_buf"];
 pub const POLL: [&str; 4] = ["core", "task", "poll", "Poll"];
 pub const PTR_EQ: [&str; 3] = ["core", "ptr", "eq"];
-pub const PTR_NULL: [&str; 2] = ["ptr", "null"];
-pub const PTR_NULL_MUT: [&str; 2] = ["ptr", "null_mut"];
+pub const PTR_NULL: [&str; 3] = ["core", "ptr", "null"];
+pub const PTR_NULL_MUT: [&str; 3] = ["core", "ptr", "null_mut"];
 pub const PUSH_STR: [&str; 4] = ["alloc", "string", "String", "push_str"];
 pub const RANGE_ARGUMENT_TRAIT: [&str; 3] = ["core", "ops", "RangeBounds"];
 pub const RC: [&str; 3] = ["alloc", "rc", "Rc"];
@@ -107,7 +107,7 @@ pub const RESULT_ERR: [&str; 4] = ["core", "result", "Result", "Err"];
 pub const RESULT_OK: [&str; 4] = ["core", "result", "Result", "Ok"];
 pub const RWLOCK_READ_GUARD: [&str; 4] = ["std", "sync", "rwlock", "RwLockReadGuard"];
 pub const RWLOCK_WRITE_GUARD: [&str; 4] = ["std", "sync", "rwlock", "RwLockWriteGuard"];
-pub const SERDE_DESERIALIZE: [&str; 2] = ["_serde", "Deserialize"];
+pub const SERDE_DESERIALIZE: [&str; 3] = ["serde", "de", "Deserialize"];
 pub const SERDE_DE_VISITOR: [&str; 3] = ["serde", "de", "Visitor"];
 pub const SLICE_INTO_VEC: [&str; 4] = ["alloc", "slice", "<impl [T]>", "into_vec"];
 pub const SLICE_ITER: [&str; 4] = ["core", "slice", "iter", "Iter"];
-- 
cgit 1.4.1-3-g733a5


From 09e70536075fd92506ef985c5e662e1b2be3dd3d Mon Sep 17 00:00:00 2001
From: Aleksei Latyshev <alex_700_95@mail.ru>
Date: Sat, 24 Oct 2020 18:05:02 +0300
Subject: simplify SpanlessEq::eq_path_segment

---
 clippy_lints/src/utils/hir_utils.rs | 10 ++--------
 1 file changed, 2 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/hir_utils.rs b/clippy_lints/src/utils/hir_utils.rs
index c9e639e8728..e4ad105c351 100644
--- a/clippy_lints/src/utils/hir_utils.rs
+++ b/clippy_lints/src/utils/hir_utils.rs
@@ -261,14 +261,8 @@ impl<'a, 'tcx> SpanlessEq<'a, 'tcx> {
     pub fn eq_path_segment(&mut self, left: &PathSegment<'_>, right: &PathSegment<'_>) -> bool {
         // The == of idents doesn't work with different contexts,
         // we have to be explicit about hygiene
-        if left.ident.as_str() != right.ident.as_str() {
-            return false;
-        }
-        match (&left.args, &right.args) {
-            (&None, &None) => true,
-            (&Some(ref l), &Some(ref r)) => self.eq_path_parameters(l, r),
-            _ => false,
-        }
+        left.ident.as_str() == right.ident.as_str()
+            && both(&left.args, &right.args, |l, r| self.eq_path_parameters(l, r))
     }
 
     pub fn eq_ty(&mut self, left: &Ty<'_>, right: &Ty<'_>) -> bool {
-- 
cgit 1.4.1-3-g733a5


From 2b7dd313685279fce06f86bd739d798792135331 Mon Sep 17 00:00:00 2001
From: Aleksei Latyshev <alex_700_95@mail.ru>
Date: Sat, 24 Oct 2020 18:06:07 +0300
Subject: improve MATCH_LIKE_MATCHES_MACRO lint

- add tests
- refactor match_same_arms lint
- prioritize match_expr_like_matches_macro over match_same_arms
---
 clippy_lints/src/copies.rs                    | 215 +------------------------
 clippy_lints/src/lib.rs                       |   4 +-
 clippy_lints/src/matches.rs                   | 217 +++++++++++++++++++++++---
 clippy_lints/src/utils/mod.rs                 |  38 +++++
 src/lintlist/mod.rs                           |   2 +-
 tests/ui/match_expr_like_matches_macro.fixed  |  68 +++++++-
 tests/ui/match_expr_like_matches_macro.rs     |  76 ++++++++-
 tests/ui/match_expr_like_matches_macro.stderr |  24 ++-
 tests/ui/match_same_arms2.rs                  |  16 ++
 tests/ui/match_same_arms2.stderr              |  15 +-
 10 files changed, 439 insertions(+), 236 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/copies.rs b/clippy_lints/src/copies.rs
index 6c969c3ead0..46ce92ea6d7 100644
--- a/clippy_lints/src/copies.rs
+++ b/clippy_lints/src/copies.rs
@@ -1,13 +1,8 @@
-use crate::utils::{eq_expr_value, in_macro, SpanlessEq, SpanlessHash};
-use crate::utils::{get_parent_expr, higher, if_sequence, snippet, span_lint_and_note, span_lint_and_then};
-use rustc_data_structures::fx::FxHashMap;
-use rustc_hir::{Arm, Block, Expr, ExprKind, MatchSource, Pat, PatKind};
+use crate::utils::{eq_expr_value, in_macro, search_same, SpanlessEq, SpanlessHash};
+use crate::utils::{get_parent_expr, higher, if_sequence, span_lint_and_note};
+use rustc_hir::{Block, Expr};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty::{Ty, TyS};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::symbol::Symbol;
-use std::collections::hash_map::Entry;
-use std::hash::BuildHasherDefault;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for consecutive `if`s with the same condition.
@@ -108,48 +103,7 @@ declare_clippy_lint! {
     "`if` with the same `then` and `else` blocks"
 }
 
-declare_clippy_lint! {
-    /// **What it does:** Checks for `match` with identical arm bodies.
-    ///
-    /// **Why is this bad?** This is probably a copy & paste error. If arm bodies
-    /// are the same on purpose, you can factor them
-    /// [using `|`](https://doc.rust-lang.org/book/patterns.html#multiple-patterns).
-    ///
-    /// **Known problems:** False positive possible with order dependent `match`
-    /// (see issue
-    /// [#860](https://github.com/rust-lang/rust-clippy/issues/860)).
-    ///
-    /// **Example:**
-    /// ```rust,ignore
-    /// match foo {
-    ///     Bar => bar(),
-    ///     Quz => quz(),
-    ///     Baz => bar(), // <= oops
-    /// }
-    /// ```
-    ///
-    /// This should probably be
-    /// ```rust,ignore
-    /// match foo {
-    ///     Bar => bar(),
-    ///     Quz => quz(),
-    ///     Baz => baz(), // <= fixed
-    /// }
-    /// ```
-    ///
-    /// or if the original code was not a typo:
-    /// ```rust,ignore
-    /// match foo {
-    ///     Bar | Baz => bar(), // <= shows the intent better
-    ///     Quz => quz(),
-    /// }
-    /// ```
-    pub MATCH_SAME_ARMS,
-    pedantic,
-    "`match` with identical arm bodies"
-}
-
-declare_lint_pass!(CopyAndPaste => [IFS_SAME_COND, SAME_FUNCTIONS_IN_IF_CONDITION, IF_SAME_THEN_ELSE, MATCH_SAME_ARMS]);
+declare_lint_pass!(CopyAndPaste => [IFS_SAME_COND, SAME_FUNCTIONS_IN_IF_CONDITION, IF_SAME_THEN_ELSE]);
 
 impl<'tcx> LateLintPass<'tcx> for CopyAndPaste {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
@@ -167,7 +121,6 @@ impl<'tcx> LateLintPass<'tcx> for CopyAndPaste {
             lint_same_then_else(cx, &blocks);
             lint_same_cond(cx, &conds);
             lint_same_fns_in_if_cond(cx, &conds);
-            lint_match_arms(cx, expr);
         }
     }
 }
@@ -243,122 +196,6 @@ fn lint_same_fns_in_if_cond(cx: &LateContext<'_>, conds: &[&Expr<'_>]) {
     }
 }
 
-/// Implementation of `MATCH_SAME_ARMS`.
-fn lint_match_arms<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>) {
-    fn same_bindings<'tcx>(lhs: &FxHashMap<Symbol, Ty<'tcx>>, rhs: &FxHashMap<Symbol, Ty<'tcx>>) -> bool {
-        lhs.len() == rhs.len()
-            && lhs
-                .iter()
-                .all(|(name, l_ty)| rhs.get(name).map_or(false, |r_ty| TyS::same_type(l_ty, r_ty)))
-    }
-
-    if let ExprKind::Match(_, ref arms, MatchSource::Normal) = expr.kind {
-        let hash = |&(_, arm): &(usize, &Arm<'_>)| -> u64 {
-            let mut h = SpanlessHash::new(cx);
-            h.hash_expr(&arm.body);
-            h.finish()
-        };
-
-        let eq = |&(lindex, lhs): &(usize, &Arm<'_>), &(rindex, rhs): &(usize, &Arm<'_>)| -> bool {
-            let min_index = usize::min(lindex, rindex);
-            let max_index = usize::max(lindex, rindex);
-
-            // Arms with a guard are ignored, those can’t always be merged together
-            // This is also the case for arms in-between each there is an arm with a guard
-            (min_index..=max_index).all(|index| arms[index].guard.is_none()) &&
-                SpanlessEq::new(cx).eq_expr(&lhs.body, &rhs.body) &&
-                // all patterns should have the same bindings
-                same_bindings(&bindings(cx, &lhs.pat), &bindings(cx, &rhs.pat))
-        };
-
-        let indexed_arms: Vec<(usize, &Arm<'_>)> = arms.iter().enumerate().collect();
-        for (&(_, i), &(_, j)) in search_same(&indexed_arms, hash, eq) {
-            span_lint_and_then(
-                cx,
-                MATCH_SAME_ARMS,
-                j.body.span,
-                "this `match` has identical arm bodies",
-                |diag| {
-                    diag.span_note(i.body.span, "same as this");
-
-                    // Note: this does not use `span_suggestion` on purpose:
-                    // there is no clean way
-                    // to remove the other arm. Building a span and suggest to replace it to ""
-                    // makes an even more confusing error message. Also in order not to make up a
-                    // span for the whole pattern, the suggestion is only shown when there is only
-                    // one pattern. The user should know about `|` if they are already using it…
-
-                    let lhs = snippet(cx, i.pat.span, "<pat1>");
-                    let rhs = snippet(cx, j.pat.span, "<pat2>");
-
-                    if let PatKind::Wild = j.pat.kind {
-                        // if the last arm is _, then i could be integrated into _
-                        // note that i.pat cannot be _, because that would mean that we're
-                        // hiding all the subsequent arms, and rust won't compile
-                        diag.span_note(
-                            i.body.span,
-                            &format!(
-                                "`{}` has the same arm body as the `_` wildcard, consider removing it",
-                                lhs
-                            ),
-                        );
-                    } else {
-                        diag.span_help(i.pat.span, &format!("consider refactoring into `{} | {}`", lhs, rhs));
-                    }
-                },
-            );
-        }
-    }
-}
-
-/// Returns the list of bindings in a pattern.
-fn bindings<'tcx>(cx: &LateContext<'tcx>, pat: &Pat<'_>) -> FxHashMap<Symbol, Ty<'tcx>> {
-    fn bindings_impl<'tcx>(cx: &LateContext<'tcx>, pat: &Pat<'_>, map: &mut FxHashMap<Symbol, Ty<'tcx>>) {
-        match pat.kind {
-            PatKind::Box(ref pat) | PatKind::Ref(ref pat, _) => bindings_impl(cx, pat, map),
-            PatKind::TupleStruct(_, pats, _) => {
-                for pat in pats {
-                    bindings_impl(cx, pat, map);
-                }
-            },
-            PatKind::Binding(.., ident, ref as_pat) => {
-                if let Entry::Vacant(v) = map.entry(ident.name) {
-                    v.insert(cx.typeck_results().pat_ty(pat));
-                }
-                if let Some(ref as_pat) = *as_pat {
-                    bindings_impl(cx, as_pat, map);
-                }
-            },
-            PatKind::Or(fields) | PatKind::Tuple(fields, _) => {
-                for pat in fields {
-                    bindings_impl(cx, pat, map);
-                }
-            },
-            PatKind::Struct(_, fields, _) => {
-                for pat in fields {
-                    bindings_impl(cx, &pat.pat, map);
-                }
-            },
-            PatKind::Slice(lhs, ref mid, rhs) => {
-                for pat in lhs {
-                    bindings_impl(cx, pat, map);
-                }
-                if let Some(ref mid) = *mid {
-                    bindings_impl(cx, mid, map);
-                }
-                for pat in rhs {
-                    bindings_impl(cx, pat, map);
-                }
-            },
-            PatKind::Lit(..) | PatKind::Range(..) | PatKind::Wild | PatKind::Path(..) => (),
-        }
-    }
-
-    let mut result = FxHashMap::default();
-    bindings_impl(cx, pat, &mut result);
-    result
-}
-
 fn search_same_sequenced<T, Eq>(exprs: &[T], eq: Eq) -> Option<(&T, &T)>
 where
     Eq: Fn(&T, &T) -> bool,
@@ -370,47 +207,3 @@ where
     }
     None
 }
-
-fn search_common_cases<'a, T, Eq>(exprs: &'a [T], eq: &Eq) -> Option<(&'a T, &'a T)>
-where
-    Eq: Fn(&T, &T) -> bool,
-{
-    if exprs.len() == 2 && eq(&exprs[0], &exprs[1]) {
-        Some((&exprs[0], &exprs[1]))
-    } else {
-        None
-    }
-}
-
-fn search_same<T, Hash, Eq>(exprs: &[T], hash: Hash, eq: Eq) -> Vec<(&T, &T)>
-where
-    Hash: Fn(&T) -> u64,
-    Eq: Fn(&T, &T) -> bool,
-{
-    if let Some(expr) = search_common_cases(&exprs, &eq) {
-        return vec![expr];
-    }
-
-    let mut match_expr_list: Vec<(&T, &T)> = Vec::new();
-
-    let mut map: FxHashMap<_, Vec<&_>> =
-        FxHashMap::with_capacity_and_hasher(exprs.len(), BuildHasherDefault::default());
-
-    for expr in exprs {
-        match map.entry(hash(expr)) {
-            Entry::Occupied(mut o) => {
-                for o in o.get() {
-                    if eq(o, expr) {
-                        match_expr_list.push((o, expr));
-                    }
-                }
-                o.get_mut().push(expr);
-            },
-            Entry::Vacant(v) => {
-                v.insert(vec![expr]);
-            },
-        }
-    }
-
-    match_expr_list
-}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 7c8cb90fe1c..459fdd70443 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -528,7 +528,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &comparison_chain::COMPARISON_CHAIN,
         &copies::IFS_SAME_COND,
         &copies::IF_SAME_THEN_ELSE,
-        &copies::MATCH_SAME_ARMS,
         &copies::SAME_FUNCTIONS_IN_IF_CONDITION,
         &copy_iterator::COPY_ITERATOR,
         &create_dir::CREATE_DIR,
@@ -659,6 +658,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &matches::MATCH_LIKE_MATCHES_MACRO,
         &matches::MATCH_OVERLAPPING_ARM,
         &matches::MATCH_REF_PATS,
+        &matches::MATCH_SAME_ARMS,
         &matches::MATCH_SINGLE_BINDING,
         &matches::MATCH_WILDCARD_FOR_SINGLE_VARIANTS,
         &matches::MATCH_WILD_ERR_ARM,
@@ -1204,7 +1204,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&attrs::INLINE_ALWAYS),
         LintId::of(&bit_mask::VERBOSE_BIT_MASK),
         LintId::of(&checked_conversions::CHECKED_CONVERSIONS),
-        LintId::of(&copies::MATCH_SAME_ARMS),
         LintId::of(&copies::SAME_FUNCTIONS_IN_IF_CONDITION),
         LintId::of(&copy_iterator::COPY_ITERATOR),
         LintId::of(&default_trait_access::DEFAULT_TRAIT_ACCESS),
@@ -1234,6 +1233,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&map_err_ignore::MAP_ERR_IGNORE),
         LintId::of(&match_on_vec_items::MATCH_ON_VEC_ITEMS),
         LintId::of(&matches::MATCH_BOOL),
+        LintId::of(&matches::MATCH_SAME_ARMS),
         LintId::of(&matches::MATCH_WILDCARD_FOR_SINGLE_VARIANTS),
         LintId::of(&matches::MATCH_WILD_ERR_ARM),
         LintId::of(&matches::SINGLE_MATCH_ELSE),
diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index d93433c607f..4bdfca1a292 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -1,5 +1,4 @@
 use crate::consts::{constant, miri_to_const, Constant};
-use crate::utils::paths;
 use crate::utils::sugg::Sugg;
 use crate::utils::usage::is_unused;
 use crate::utils::{
@@ -8,8 +7,10 @@ use crate::utils::{
     snippet_block, snippet_with_applicability, span_lint_and_help, span_lint_and_note, span_lint_and_sugg,
     span_lint_and_then,
 };
+use crate::utils::{paths, search_same, SpanlessEq, SpanlessHash};
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
+use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::Applicability;
 use rustc_hir::def::CtorKind;
 use rustc_hir::{
@@ -18,10 +19,12 @@ use rustc_hir::{
 };
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_middle::ty::{self, Ty};
+use rustc_middle::ty::{self, Ty, TyS};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::{Span, Spanned};
+use rustc_span::Symbol;
 use std::cmp::Ordering;
+use std::collections::hash_map::Entry;
 use std::collections::Bound;
 
 declare_clippy_lint! {
@@ -475,6 +478,47 @@ declare_clippy_lint! {
     "a match that could be written with the matches! macro"
 }
 
+declare_clippy_lint! {
+    /// **What it does:** Checks for `match` with identical arm bodies.
+    ///
+    /// **Why is this bad?** This is probably a copy & paste error. If arm bodies
+    /// are the same on purpose, you can factor them
+    /// [using `|`](https://doc.rust-lang.org/book/patterns.html#multiple-patterns).
+    ///
+    /// **Known problems:** False positive possible with order dependent `match`
+    /// (see issue
+    /// [#860](https://github.com/rust-lang/rust-clippy/issues/860)).
+    ///
+    /// **Example:**
+    /// ```rust,ignore
+    /// match foo {
+    ///     Bar => bar(),
+    ///     Quz => quz(),
+    ///     Baz => bar(), // <= oops
+    /// }
+    /// ```
+    ///
+    /// This should probably be
+    /// ```rust,ignore
+    /// match foo {
+    ///     Bar => bar(),
+    ///     Quz => quz(),
+    ///     Baz => baz(), // <= fixed
+    /// }
+    /// ```
+    ///
+    /// or if the original code was not a typo:
+    /// ```rust,ignore
+    /// match foo {
+    ///     Bar | Baz => bar(), // <= shows the intent better
+    ///     Quz => quz(),
+    /// }
+    /// ```
+    pub MATCH_SAME_ARMS,
+    pedantic,
+    "`match` with identical arm bodies"
+}
+
 #[derive(Default)]
 pub struct Matches {
     infallible_destructuring_match_linted: bool,
@@ -495,7 +539,8 @@ impl_lint_pass!(Matches => [
     INFALLIBLE_DESTRUCTURING_MATCH,
     REST_PAT_IN_FULLY_BOUND_STRUCTS,
     REDUNDANT_PATTERN_MATCHING,
-    MATCH_LIKE_MATCHES_MACRO
+    MATCH_LIKE_MATCHES_MACRO,
+    MATCH_SAME_ARMS,
 ]);
 
 impl<'tcx> LateLintPass<'tcx> for Matches {
@@ -505,7 +550,9 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
         }
 
         redundant_pattern_match::check(cx, expr);
-        check_match_like_matches(cx, expr);
+        if !check_match_like_matches(cx, expr) {
+            lint_match_arms(cx, expr);
+        }
 
         if let ExprKind::Match(ref ex, ref arms, MatchSource::Normal) = expr.kind {
             check_single_match(cx, ex, arms, expr);
@@ -1063,32 +1110,47 @@ fn check_wild_in_or_pats(cx: &LateContext<'_>, arms: &[Arm<'_>]) {
 }
 
 /// Lint a `match` or `if let .. { .. } else { .. }` expr that could be replaced by `matches!`
-fn check_match_like_matches<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+fn check_match_like_matches<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> bool {
     if let ExprKind::Match(ex, arms, ref match_source) = &expr.kind {
         match match_source {
             MatchSource::Normal => find_matches_sugg(cx, ex, arms, expr, false),
             MatchSource::IfLetDesugar { .. } => find_matches_sugg(cx, ex, arms, expr, true),
-            _ => return,
+            _ => false,
         }
+    } else {
+        false
     }
 }
 
 /// Lint a `match` or desugared `if let` for replacement by `matches!`
-fn find_matches_sugg(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>], expr: &Expr<'_>, desugared: bool) {
+fn find_matches_sugg(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>], expr: &Expr<'_>, desugared: bool) -> bool {
     if_chain! {
-        if arms.len() == 2;
+        if arms.len() >= 2;
         if cx.typeck_results().expr_ty(expr).is_bool();
-        if is_wild(&arms[1].pat);
-        if let Some(first) = find_bool_lit(&arms[0].body.kind, desugared);
-        if let Some(second) = find_bool_lit(&arms[1].body.kind, desugared);
-        if first != second;
+        if let Some((b1_arm, b0_arms)) = arms.split_last();
+        if let Some(b0) = find_bool_lit(&b0_arms[0].body.kind, desugared);
+        if let Some(b1) = find_bool_lit(&b1_arm.body.kind, desugared);
+        if is_wild(&b1_arm.pat);
+        if b0 != b1;
+        let if_guard = &b0_arms[0].guard;
+        if if_guard.is_none() || b0_arms.len() == 1;
+        if b0_arms[1..].iter()
+            .all(|arm| {
+                find_bool_lit(&arm.body.kind, desugared).map_or(false, |b| b == b0) &&
+                arm.guard.is_none()
+            });
         then {
             let mut applicability = Applicability::MachineApplicable;
-
-            let pat_and_guard = if let Some(Guard::If(g)) = arms[0].guard {
-                format!("{} if {}", snippet_with_applicability(cx, arms[0].pat.span, "..", &mut applicability), snippet_with_applicability(cx, g.span, "..", &mut applicability))
+            let pat = {
+                use itertools::Itertools as _;
+                b0_arms.iter()
+                    .map(|arm| snippet_with_applicability(cx, arm.pat.span, "..", &mut applicability))
+                    .join(" | ")
+            };
+            let pat_and_guard = if let Some(Guard::If(g)) = if_guard {
+                format!("{} if {}", pat, snippet_with_applicability(cx, g.span, "..", &mut applicability))
             } else {
-                format!("{}", snippet_with_applicability(cx, arms[0].pat.span, "..", &mut applicability))
+                pat
             };
             span_lint_and_sugg(
                 cx,
@@ -1098,12 +1160,15 @@ fn find_matches_sugg(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>], expr
                 "try this",
                 format!(
                     "{}matches!({}, {})",
-                    if first { "" } else { "!" },
+                    if b0 { "" } else { "!" },
                     snippet_with_applicability(cx, ex.span, "..", &mut applicability),
                     pat_and_guard,
                 ),
                 applicability,
-            )
+            );
+            true
+        } else {
+            false
         }
     }
 }
@@ -1657,3 +1722,119 @@ fn test_overlapping() {
         ],)
     );
 }
+
+/// Implementation of `MATCH_SAME_ARMS`.
+fn lint_match_arms<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>) {
+    fn same_bindings<'tcx>(lhs: &FxHashMap<Symbol, Ty<'tcx>>, rhs: &FxHashMap<Symbol, Ty<'tcx>>) -> bool {
+        lhs.len() == rhs.len()
+            && lhs
+                .iter()
+                .all(|(name, l_ty)| rhs.get(name).map_or(false, |r_ty| TyS::same_type(l_ty, r_ty)))
+    }
+
+    if let ExprKind::Match(_, ref arms, MatchSource::Normal) = expr.kind {
+        let hash = |&(_, arm): &(usize, &Arm<'_>)| -> u64 {
+            let mut h = SpanlessHash::new(cx);
+            h.hash_expr(&arm.body);
+            h.finish()
+        };
+
+        let eq = |&(lindex, lhs): &(usize, &Arm<'_>), &(rindex, rhs): &(usize, &Arm<'_>)| -> bool {
+            let min_index = usize::min(lindex, rindex);
+            let max_index = usize::max(lindex, rindex);
+
+            // Arms with a guard are ignored, those can’t always be merged together
+            // This is also the case for arms in-between each there is an arm with a guard
+            (min_index..=max_index).all(|index| arms[index].guard.is_none()) &&
+                SpanlessEq::new(cx).eq_expr(&lhs.body, &rhs.body) &&
+                // all patterns should have the same bindings
+                same_bindings(&bindings(cx, &lhs.pat), &bindings(cx, &rhs.pat))
+        };
+
+        let indexed_arms: Vec<(usize, &Arm<'_>)> = arms.iter().enumerate().collect();
+        for (&(_, i), &(_, j)) in search_same(&indexed_arms, hash, eq) {
+            span_lint_and_then(
+                cx,
+                MATCH_SAME_ARMS,
+                j.body.span,
+                "this `match` has identical arm bodies",
+                |diag| {
+                    diag.span_note(i.body.span, "same as this");
+
+                    // Note: this does not use `span_suggestion` on purpose:
+                    // there is no clean way
+                    // to remove the other arm. Building a span and suggest to replace it to ""
+                    // makes an even more confusing error message. Also in order not to make up a
+                    // span for the whole pattern, the suggestion is only shown when there is only
+                    // one pattern. The user should know about `|` if they are already using it…
+
+                    let lhs = snippet(cx, i.pat.span, "<pat1>");
+                    let rhs = snippet(cx, j.pat.span, "<pat2>");
+
+                    if let PatKind::Wild = j.pat.kind {
+                        // if the last arm is _, then i could be integrated into _
+                        // note that i.pat cannot be _, because that would mean that we're
+                        // hiding all the subsequent arms, and rust won't compile
+                        diag.span_note(
+                            i.body.span,
+                            &format!(
+                                "`{}` has the same arm body as the `_` wildcard, consider removing it",
+                                lhs
+                            ),
+                        );
+                    } else {
+                        diag.span_help(i.pat.span, &format!("consider refactoring into `{} | {}`", lhs, rhs));
+                    }
+                },
+            );
+        }
+    }
+}
+
+/// Returns the list of bindings in a pattern.
+fn bindings<'tcx>(cx: &LateContext<'tcx>, pat: &Pat<'_>) -> FxHashMap<Symbol, Ty<'tcx>> {
+    fn bindings_impl<'tcx>(cx: &LateContext<'tcx>, pat: &Pat<'_>, map: &mut FxHashMap<Symbol, Ty<'tcx>>) {
+        match pat.kind {
+            PatKind::Box(ref pat) | PatKind::Ref(ref pat, _) => bindings_impl(cx, pat, map),
+            PatKind::TupleStruct(_, pats, _) => {
+                for pat in pats {
+                    bindings_impl(cx, pat, map);
+                }
+            },
+            PatKind::Binding(.., ident, ref as_pat) => {
+                if let Entry::Vacant(v) = map.entry(ident.name) {
+                    v.insert(cx.typeck_results().pat_ty(pat));
+                }
+                if let Some(ref as_pat) = *as_pat {
+                    bindings_impl(cx, as_pat, map);
+                }
+            },
+            PatKind::Or(fields) | PatKind::Tuple(fields, _) => {
+                for pat in fields {
+                    bindings_impl(cx, pat, map);
+                }
+            },
+            PatKind::Struct(_, fields, _) => {
+                for pat in fields {
+                    bindings_impl(cx, &pat.pat, map);
+                }
+            },
+            PatKind::Slice(lhs, ref mid, rhs) => {
+                for pat in lhs {
+                    bindings_impl(cx, pat, map);
+                }
+                if let Some(ref mid) = *mid {
+                    bindings_impl(cx, mid, map);
+                }
+                for pat in rhs {
+                    bindings_impl(cx, pat, map);
+                }
+            },
+            PatKind::Lit(..) | PatKind::Range(..) | PatKind::Wild | PatKind::Path(..) => (),
+        }
+    }
+
+    let mut result = FxHashMap::default();
+    bindings_impl(cx, pat, &mut result);
+    result
+}
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index a1ecca0961a..0a8a4a5f9ae 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -27,11 +27,14 @@ pub use self::diagnostics::*;
 pub use self::hir_utils::{both, eq_expr_value, over, SpanlessEq, SpanlessHash};
 
 use std::borrow::Cow;
+use std::collections::hash_map::Entry;
+use std::hash::BuildHasherDefault;
 use std::mem;
 
 use if_chain::if_chain;
 use rustc_ast::ast::{self, Attribute, LitKind};
 use rustc_attr as attr;
+use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_hir::def::{DefKind, Res};
@@ -1465,6 +1468,41 @@ pub fn is_slice_of_primitives(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<S
     None
 }
 
+/// returns list of all pairs (a, b) from `exprs` such that `eq(a, b)`
+/// `hash` must be comformed with `eq`
+pub fn search_same<T, Hash, Eq>(exprs: &[T], hash: Hash, eq: Eq) -> Vec<(&T, &T)>
+where
+    Hash: Fn(&T) -> u64,
+    Eq: Fn(&T, &T) -> bool,
+{
+    if exprs.len() == 2 && eq(&exprs[0], &exprs[1]) {
+        return vec![(&exprs[0], &exprs[1])];
+    }
+
+    let mut match_expr_list: Vec<(&T, &T)> = Vec::new();
+
+    let mut map: FxHashMap<_, Vec<&_>> =
+        FxHashMap::with_capacity_and_hasher(exprs.len(), BuildHasherDefault::default());
+
+    for expr in exprs {
+        match map.entry(hash(expr)) {
+            Entry::Occupied(mut o) => {
+                for o in o.get() {
+                    if eq(o, expr) {
+                        match_expr_list.push((o, expr));
+                    }
+                }
+                o.get_mut().push(expr);
+            },
+            Entry::Vacant(v) => {
+                v.insert(vec![expr]);
+            },
+        }
+    }
+
+    match_expr_list
+}
+
 #[macro_export]
 macro_rules! unwrap_cargo_metadata {
     ($cx: ident, $lint: ident, $deps: expr) => {{
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index 6272ce45efb..aba436e5c02 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -1304,7 +1304,7 @@ vec![
         group: "pedantic",
         desc: "`match` with identical arm bodies",
         deprecation: None,
-        module: "copies",
+        module: "matches",
     },
     Lint {
         name: "match_single_binding",
diff --git a/tests/ui/match_expr_like_matches_macro.fixed b/tests/ui/match_expr_like_matches_macro.fixed
index f3e19092480..7f4ebf56673 100644
--- a/tests/ui/match_expr_like_matches_macro.fixed
+++ b/tests/ui/match_expr_like_matches_macro.fixed
@@ -1,7 +1,7 @@
 // run-rustfix
 
 #![warn(clippy::match_like_matches_macro)]
-#![allow(unreachable_patterns)]
+#![allow(unreachable_patterns, dead_code)]
 
 fn main() {
     let x = Some(5);
@@ -33,4 +33,70 @@ fn main() {
         _ => true,
         None => false,
     };
+
+    enum E {
+        A(u32),
+        B(i32),
+        C,
+        D,
+    };
+    let x = E::A(2);
+    {
+        // lint
+        let _ans = matches!(x, E::A(_) | E::B(_));
+    }
+    {
+        // lint
+        let _ans = !matches!(x, E::B(_) | E::C);
+    }
+    {
+        // no lint
+        let _ans = match x {
+            E::A(_) => false,
+            E::B(_) => false,
+            E::C => true,
+            _ => true,
+        };
+    }
+    {
+        // no lint
+        let _ans = match x {
+            E::A(_) => true,
+            E::B(_) => false,
+            E::C => false,
+            _ => true,
+        };
+    }
+    {
+        // no lint
+        let _ans = match x {
+            E::A(a) if a < 10 => false,
+            E::B(a) if a < 10 => false,
+            _ => true,
+        };
+    }
+    {
+        // no lint
+        let _ans = match x {
+            E::A(_) => false,
+            E::B(a) if a < 10 => false,
+            _ => true,
+        };
+    }
+    {
+        // no lint
+        let _ans = match x {
+            E::A(a) => a == 10,
+            E::B(_) => false,
+            _ => true,
+        };
+    }
+    {
+        // no lint
+        let _ans = match x {
+            E::A(_) => false,
+            E::B(_) => true,
+            _ => false,
+        };
+    }
 }
diff --git a/tests/ui/match_expr_like_matches_macro.rs b/tests/ui/match_expr_like_matches_macro.rs
index fbae7c18b92..aee56dd4a5e 100644
--- a/tests/ui/match_expr_like_matches_macro.rs
+++ b/tests/ui/match_expr_like_matches_macro.rs
@@ -1,7 +1,7 @@
 // run-rustfix
 
 #![warn(clippy::match_like_matches_macro)]
-#![allow(unreachable_patterns)]
+#![allow(unreachable_patterns, dead_code)]
 
 fn main() {
     let x = Some(5);
@@ -45,4 +45,78 @@ fn main() {
         _ => true,
         None => false,
     };
+
+    enum E {
+        A(u32),
+        B(i32),
+        C,
+        D,
+    };
+    let x = E::A(2);
+    {
+        // lint
+        let _ans = match x {
+            E::A(_) => true,
+            E::B(_) => true,
+            _ => false,
+        };
+    }
+    {
+        // lint
+        let _ans = match x {
+            E::B(_) => false,
+            E::C => false,
+            _ => true,
+        };
+    }
+    {
+        // no lint
+        let _ans = match x {
+            E::A(_) => false,
+            E::B(_) => false,
+            E::C => true,
+            _ => true,
+        };
+    }
+    {
+        // no lint
+        let _ans = match x {
+            E::A(_) => true,
+            E::B(_) => false,
+            E::C => false,
+            _ => true,
+        };
+    }
+    {
+        // no lint
+        let _ans = match x {
+            E::A(a) if a < 10 => false,
+            E::B(a) if a < 10 => false,
+            _ => true,
+        };
+    }
+    {
+        // no lint
+        let _ans = match x {
+            E::A(_) => false,
+            E::B(a) if a < 10 => false,
+            _ => true,
+        };
+    }
+    {
+        // no lint
+        let _ans = match x {
+            E::A(a) => a == 10,
+            E::B(_) => false,
+            _ => true,
+        };
+    }
+    {
+        // no lint
+        let _ans = match x {
+            E::A(_) => false,
+            E::B(_) => true,
+            _ => false,
+        };
+    }
 }
diff --git a/tests/ui/match_expr_like_matches_macro.stderr b/tests/ui/match_expr_like_matches_macro.stderr
index 4668f8565a6..c52e41c7889 100644
--- a/tests/ui/match_expr_like_matches_macro.stderr
+++ b/tests/ui/match_expr_like_matches_macro.stderr
@@ -48,5 +48,27 @@ error: if let .. else expression looks like `matches!` macro
 LL |     let _zzz = if let Some(5) = x { true } else { false };
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `matches!(x, Some(5))`
 
-error: aborting due to 5 previous errors
+error: match expression looks like `matches!` macro
+  --> $DIR/match_expr_like_matches_macro.rs:58:20
+   |
+LL |           let _ans = match x {
+   |  ____________________^
+LL | |             E::A(_) => true,
+LL | |             E::B(_) => true,
+LL | |             _ => false,
+LL | |         };
+   | |_________^ help: try this: `matches!(x, E::A(_) | E::B(_))`
+
+error: match expression looks like `matches!` macro
+  --> $DIR/match_expr_like_matches_macro.rs:66:20
+   |
+LL |           let _ans = match x {
+   |  ____________________^
+LL | |             E::B(_) => false,
+LL | |             E::C => false,
+LL | |             _ => true,
+LL | |         };
+   | |_________^ help: try this: `!matches!(x, E::B(_) | E::C)`
+
+error: aborting due to 7 previous errors
 
diff --git a/tests/ui/match_same_arms2.rs b/tests/ui/match_same_arms2.rs
index e1401d2796a..06d91497242 100644
--- a/tests/ui/match_same_arms2.rs
+++ b/tests/ui/match_same_arms2.rs
@@ -119,6 +119,22 @@ fn match_same_arms() {
             unreachable!();
         },
     }
+
+    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() {}
diff --git a/tests/ui/match_same_arms2.stderr b/tests/ui/match_same_arms2.stderr
index 26c65f32ad7..fccaf805616 100644
--- a/tests/ui/match_same_arms2.stderr
+++ b/tests/ui/match_same_arms2.stderr
@@ -141,5 +141,18 @@ LL |         Ok(3) => println!("ok"),
    |         ^^^^^
    = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to 7 previous errors
+error: match expression looks like `matches!` macro
+  --> $DIR/match_same_arms2.rs:133:16
+   |
+LL |       let _ans = match x {
+   |  ________________^
+LL | |         E::A => false,
+LL | |         E::B => false,
+LL | |         _ => true,
+LL | |     };
+   | |_____^ help: try this: `!matches!(x, E::A | E::B)`
+   |
+   = note: `-D clippy::match-like-matches-macro` implied by `-D warnings`
+
+error: aborting due to 8 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 4c58860cbfe51049d48f4f31f76dcc18b39cfe98 Mon Sep 17 00:00:00 2001
From: Takayuki Nakata <f.seasons017@gmail.com>
Date: Tue, 27 Oct 2020 23:18:08 +0900
Subject: Fix suggestion to add unneeded space in `unused_unit`

---
 clippy_lints/src/unused_unit.rs | 11 +++++++
 tests/ui/unused_unit.fixed      | 31 ++++++++++++-------
 tests/ui/unused_unit.rs         |  9 ++++++
 tests/ui/unused_unit.stderr     | 68 ++++++++++++++++++++++++++---------------
 4 files changed, 83 insertions(+), 36 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unused_unit.rs b/clippy_lints/src/unused_unit.rs
index 7548c6afa97..b1339c3d639 100644
--- a/clippy_lints/src/unused_unit.rs
+++ b/clippy_lints/src/unused_unit.rs
@@ -123,6 +123,17 @@ fn lint_unneeded_unit_return(cx: &EarlyContext<'_>, ty: &ast::Ty, span: Span) {
         fn_source
             .rfind("->")
             .map_or((ty.span, Applicability::MaybeIncorrect), |rpos| {
+                let mut rpos = rpos;
+                let chars: Vec<char> = fn_source.chars().collect();
+                while rpos > 1 {
+                    if let Some(c) = chars.get(rpos - 1) {
+                        if c.is_whitespace() {
+                            rpos -= 1;
+                            continue;
+                        }
+                    }
+                    break;
+                }
                 (
                     #[allow(clippy::cast_possible_truncation)]
                     ty.span.with_lo(BytePos(span.lo().0 + rpos as u32)),
diff --git a/tests/ui/unused_unit.fixed b/tests/ui/unused_unit.fixed
index 07f2791786d..7afc5361356 100644
--- a/tests/ui/unused_unit.fixed
+++ b/tests/ui/unused_unit.fixed
@@ -15,35 +15,35 @@
 struct Unitter;
 impl Unitter {
     #[allow(clippy::no_effect)]
-    pub fn get_unit<F: Fn() , G>(&self, f: F, _g: G) 
-    where G: Fn()  {
-        let _y: &dyn Fn()  = &f;
+    pub fn get_unit<F: Fn(), G>(&self, f: F, _g: G)
+    where G: Fn() {
+        let _y: &dyn Fn() = &f;
         (); // this should not lint, as it's not in return type position
     }
 }
 
 impl Into<()> for Unitter {
     #[rustfmt::skip]
-    fn into(self)  {
+    fn into(self) {
         
     }
 }
 
 trait Trait {
-    fn redundant<F: FnOnce() , G, H>(&self, _f: F, _g: G, _h: H)
+    fn redundant<F: FnOnce(), G, H>(&self, _f: F, _g: G, _h: H)
     where
-        G: FnMut() ,
-        H: Fn() ;
+        G: FnMut(),
+        H: Fn();
 }
 
 impl Trait for Unitter {
-    fn redundant<F: FnOnce() , G, H>(&self, _f: F, _g: G, _h: H)
+    fn redundant<F: FnOnce(), G, H>(&self, _f: F, _g: G, _h: H)
     where
-        G: FnMut() ,
-        H: Fn()  {}
+        G: FnMut(),
+        H: Fn() {}
 }
 
-fn return_unit()  {  }
+fn return_unit() {  }
 
 #[allow(clippy::needless_return)]
 #[allow(clippy::never_loop)]
@@ -70,3 +70,12 @@ fn foo() {
         recv(rx) -> _x => ()
     }
 }
+
+#[rustfmt::skip]
+fn test(){}
+
+#[rustfmt::skip]
+fn test2(){}
+
+#[rustfmt::skip]
+fn test3(){}
diff --git a/tests/ui/unused_unit.rs b/tests/ui/unused_unit.rs
index e2c6afb020f..96cef1ed5a5 100644
--- a/tests/ui/unused_unit.rs
+++ b/tests/ui/unused_unit.rs
@@ -70,3 +70,12 @@ fn foo() {
         recv(rx) -> _x => ()
     }
 }
+
+#[rustfmt::skip]
+fn test()->(){}
+
+#[rustfmt::skip]
+fn test2() ->(){}
+
+#[rustfmt::skip]
+fn test3()-> (){}
diff --git a/tests/ui/unused_unit.stderr b/tests/ui/unused_unit.stderr
index 81e6738e6bf..c45634c2b6d 100644
--- a/tests/ui/unused_unit.stderr
+++ b/tests/ui/unused_unit.stderr
@@ -1,8 +1,8 @@
 error: unneeded unit return type
-  --> $DIR/unused_unit.rs:18:29
+  --> $DIR/unused_unit.rs:18:28
    |
 LL |     pub fn get_unit<F: Fn() -> (), G>(&self, f: F, _g: G) -> ()
-   |                             ^^^^^ help: remove the `-> ()`
+   |                            ^^^^^^ help: remove the `-> ()`
    |
 note: the lint level is defined here
   --> $DIR/unused_unit.rs:12:9
@@ -11,28 +11,28 @@ LL | #![deny(clippy::unused_unit)]
    |         ^^^^^^^^^^^^^^^^^^^
 
 error: unneeded unit return type
-  --> $DIR/unused_unit.rs:19:19
+  --> $DIR/unused_unit.rs:19:18
    |
 LL |     where G: Fn() -> () {
-   |                   ^^^^^ help: remove the `-> ()`
+   |                  ^^^^^^ help: remove the `-> ()`
 
 error: unneeded unit return type
-  --> $DIR/unused_unit.rs:18:59
+  --> $DIR/unused_unit.rs:18:58
    |
 LL |     pub fn get_unit<F: Fn() -> (), G>(&self, f: F, _g: G) -> ()
-   |                                                           ^^^^^ help: remove the `-> ()`
+   |                                                          ^^^^^^ help: remove the `-> ()`
 
 error: unneeded unit return type
-  --> $DIR/unused_unit.rs:20:27
+  --> $DIR/unused_unit.rs:20:26
    |
 LL |         let _y: &dyn Fn() -> () = &f;
-   |                           ^^^^^ help: remove the `-> ()`
+   |                          ^^^^^^ help: remove the `-> ()`
 
 error: unneeded unit return type
-  --> $DIR/unused_unit.rs:27:19
+  --> $DIR/unused_unit.rs:27:18
    |
 LL |     fn into(self) -> () {
-   |                   ^^^^^ help: remove the `-> ()`
+   |                  ^^^^^^ help: remove the `-> ()`
 
 error: unneeded unit expression
   --> $DIR/unused_unit.rs:28:9
@@ -41,46 +41,46 @@ LL |         ()
    |         ^^ help: remove the final `()`
 
 error: unneeded unit return type
-  --> $DIR/unused_unit.rs:33:30
+  --> $DIR/unused_unit.rs:33:29
    |
 LL |     fn redundant<F: FnOnce() -> (), G, H>(&self, _f: F, _g: G, _h: H)
-   |                              ^^^^^ help: remove the `-> ()`
+   |                             ^^^^^^ help: remove the `-> ()`
 
 error: unneeded unit return type
-  --> $DIR/unused_unit.rs:35:20
+  --> $DIR/unused_unit.rs:35:19
    |
 LL |         G: FnMut() -> (),
-   |                    ^^^^^ help: remove the `-> ()`
+   |                   ^^^^^^ help: remove the `-> ()`
 
 error: unneeded unit return type
-  --> $DIR/unused_unit.rs:36:17
+  --> $DIR/unused_unit.rs:36:16
    |
 LL |         H: Fn() -> ();
-   |                 ^^^^^ help: remove the `-> ()`
+   |                ^^^^^^ help: remove the `-> ()`
 
 error: unneeded unit return type
-  --> $DIR/unused_unit.rs:40:30
+  --> $DIR/unused_unit.rs:40:29
    |
 LL |     fn redundant<F: FnOnce() -> (), G, H>(&self, _f: F, _g: G, _h: H)
-   |                              ^^^^^ help: remove the `-> ()`
+   |                             ^^^^^^ help: remove the `-> ()`
 
 error: unneeded unit return type
-  --> $DIR/unused_unit.rs:42:20
+  --> $DIR/unused_unit.rs:42:19
    |
 LL |         G: FnMut() -> (),
-   |                    ^^^^^ help: remove the `-> ()`
+   |                   ^^^^^^ help: remove the `-> ()`
 
 error: unneeded unit return type
-  --> $DIR/unused_unit.rs:43:17
+  --> $DIR/unused_unit.rs:43:16
    |
 LL |         H: Fn() -> () {}
-   |                 ^^^^^ help: remove the `-> ()`
+   |                ^^^^^^ help: remove the `-> ()`
 
 error: unneeded unit return type
-  --> $DIR/unused_unit.rs:46:18
+  --> $DIR/unused_unit.rs:46:17
    |
 LL | fn return_unit() -> () { () }
-   |                  ^^^^^ help: remove the `-> ()`
+   |                 ^^^^^^ help: remove the `-> ()`
 
 error: unneeded unit expression
   --> $DIR/unused_unit.rs:46:26
@@ -100,5 +100,23 @@ error: unneeded `()`
 LL |     return();
    |           ^^ help: remove the `()`
 
-error: aborting due to 16 previous errors
+error: unneeded unit return type
+  --> $DIR/unused_unit.rs:75:10
+   |
+LL | fn test()->(){}
+   |          ^^^^ help: remove the `-> ()`
+
+error: unneeded unit return type
+  --> $DIR/unused_unit.rs:78:11
+   |
+LL | fn test2() ->(){}
+   |           ^^^^^ help: remove the `-> ()`
+
+error: unneeded unit return type
+  --> $DIR/unused_unit.rs:81:11
+   |
+LL | fn test3()-> (){}
+   |           ^^^^^ help: remove the `-> ()`
+
+error: aborting due to 19 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From a50d9e7af641d52e066b111014993b042b0be5a7 Mon Sep 17 00:00:00 2001
From: Eduardo Broto <ebroto@tutanota.com>
Date: Wed, 28 Oct 2020 22:32:13 +0100
Subject: Deprecate temporary_cstr_as_ptr

---
 CHANGELOG.md                         | 1 +
 clippy_lints/src/deprecated_lints.rs | 9 +++++++++
 clippy_lints/src/lib.rs              | 4 ++++
 tests/ui/deprecated.rs               | 1 +
 tests/ui/deprecated.stderr           | 8 +++++++-
 5 files changed, 22 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index d10aefa2042..aa47930b520 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1962,6 +1962,7 @@ Released 2018-09-13
 [`suspicious_unary_op_formatting`]: https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_unary_op_formatting
 [`tabs_in_doc_comments`]: https://rust-lang.github.io/rust-clippy/master/index.html#tabs_in_doc_comments
 [`temporary_assignment`]: https://rust-lang.github.io/rust-clippy/master/index.html#temporary_assignment
+[`temporary_cstring_as_ptr`]: https://rust-lang.github.io/rust-clippy/master/index.html#temporary_cstring_as_ptr
 [`to_digit_is_some`]: https://rust-lang.github.io/rust-clippy/master/index.html#to_digit_is_some
 [`to_string_in_display`]: https://rust-lang.github.io/rust-clippy/master/index.html#to_string_in_display
 [`todo`]: https://rust-lang.github.io/rust-clippy/master/index.html#todo
diff --git a/clippy_lints/src/deprecated_lints.rs b/clippy_lints/src/deprecated_lints.rs
index c5884361dff..461c6e31d3e 100644
--- a/clippy_lints/src/deprecated_lints.rs
+++ b/clippy_lints/src/deprecated_lints.rs
@@ -172,3 +172,12 @@ declare_deprecated_lint! {
     pub DROP_BOUNDS,
     "this lint has been uplifted to rustc and is now called `drop_bounds`"
 }
+
+declare_deprecated_lint! {
+    /// **What it does:** Nothing. This lint has been deprecated.
+    ///
+    /// **Deprecation reason:** This lint has been uplifted to rustc and is now called
+    /// `temporary_cstring_as_ptr`.
+    pub TEMPORARY_CSTRING_AS_PTR,
+    "this lint has been uplifted to rustc and is now called `temporary_cstring_as_ptr`"
+}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index fb949345945..2d374969846 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -488,6 +488,10 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         "clippy::drop_bounds",
         "this lint has been uplifted to rustc and is now called `drop_bounds`",
     );
+    store.register_removed(
+        "clippy::temporary_cstring_as_ptr",
+        "this lint has been uplifted to rustc and is now called `temporary_cstring_as_ptr`",
+    );
     // end deprecated lints, do not remove this comment, it’s used in `update_lints`
 
     // begin register lints, do not remove this comment, it’s used in `update_lints`
diff --git a/tests/ui/deprecated.rs b/tests/ui/deprecated.rs
index 9e32fe36ece..56755596c97 100644
--- a/tests/ui/deprecated.rs
+++ b/tests/ui/deprecated.rs
@@ -9,5 +9,6 @@
 #[warn(clippy::unused_label)]
 #[warn(clippy::regex_macro)]
 #[warn(clippy::drop_bounds)]
+#[warn(clippy::temporary_cstring_as_ptr)]
 
 fn main() {}
diff --git a/tests/ui/deprecated.stderr b/tests/ui/deprecated.stderr
index d3400a7be09..37b726fc00f 100644
--- a/tests/ui/deprecated.stderr
+++ b/tests/ui/deprecated.stderr
@@ -66,11 +66,17 @@ error: lint `clippy::drop_bounds` has been removed: `this lint has been uplifted
 LL | #[warn(clippy::drop_bounds)]
    |        ^^^^^^^^^^^^^^^^^^^
 
+error: lint `clippy::temporary_cstring_as_ptr` has been removed: `this lint has been uplifted to rustc and is now called `temporary_cstring_as_ptr``
+  --> $DIR/deprecated.rs:12:8
+   |
+LL | #[warn(clippy::temporary_cstring_as_ptr)]
+   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
 error: lint `clippy::str_to_string` has been removed: `using `str::to_string` is common even today and specialization will likely happen soon`
   --> $DIR/deprecated.rs:1:8
    |
 LL | #[warn(clippy::str_to_string)]
    |        ^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 12 previous errors
+error: aborting due to 13 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From e97602e4825fd5a01834d7b0e218703dcc82c091 Mon Sep 17 00:00:00 2001
From: henil <dedaniahenil@gmail.com>
Date: Mon, 26 Oct 2020 19:28:22 +0530
Subject: Update existing arithmetic lint and add new tests related to it.

---
 clippy_lints/src/arithmetic.rs     |  30 +++++++++--
 tests/ui/integer_arithmetic.rs     |  10 ++++
 tests/ui/integer_arithmetic.stderr | 100 +++++++++++++++++++++++++++----------
 3 files changed, 112 insertions(+), 28 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/arithmetic.rs b/clippy_lints/src/arithmetic.rs
index e84481f9b53..b1cdbab6de9 100644
--- a/clippy_lints/src/arithmetic.rs
+++ b/clippy_lints/src/arithmetic.rs
@@ -88,9 +88,33 @@ impl<'tcx> LateLintPass<'tcx> for Arithmetic {
 
                 let (l_ty, r_ty) = (cx.typeck_results().expr_ty(l), cx.typeck_results().expr_ty(r));
                 if l_ty.peel_refs().is_integral() && r_ty.peel_refs().is_integral() {
-                    span_lint(cx, INTEGER_ARITHMETIC, expr.span, "integer arithmetic detected");
-                    self.expr_span = Some(expr.span);
-                } else if l_ty.peel_refs().is_floating_point() && r_ty.peel_refs().is_floating_point() {
+                    match op.node {
+                        hir::BinOpKind::Div | hir::BinOpKind::Rem => match &r.kind {
+                            hir::ExprKind::Lit(lit) => {
+                                if let rustc_ast::ast::LitKind::Int(0, _) = lit.node {
+                                    span_lint(cx, INTEGER_ARITHMETIC, expr.span, "integer arithmetic detected");
+                                    self.expr_span = Some(expr.span);
+                                }
+                            },
+                            hir::ExprKind::Unary(hir::UnOp::UnNeg, expr) => {
+                                if let hir::ExprKind::Lit(lit) = &expr.kind {
+                                    if let rustc_ast::ast::LitKind::Int(1, _) = lit.node {
+                                        span_lint(cx, INTEGER_ARITHMETIC, expr.span, "integer arithmetic detected");
+                                        self.expr_span = Some(expr.span);
+                                    }
+                                }
+                            },
+                            _ => {
+                                span_lint(cx, INTEGER_ARITHMETIC, expr.span, "integer arithmetic detected");
+                                self.expr_span = Some(expr.span);
+                            },
+                        },
+                        _ => {
+                            span_lint(cx, INTEGER_ARITHMETIC, expr.span, "integer arithmetic detected");
+                            self.expr_span = Some(expr.span);
+                        },
+                    }
+                } else if r_ty.peel_refs().is_floating_point() && r_ty.peel_refs().is_floating_point() {
                     span_lint(cx, FLOAT_ARITHMETIC, expr.span, "floating-point arithmetic detected");
                     self.expr_span = Some(expr.span);
                 }
diff --git a/tests/ui/integer_arithmetic.rs b/tests/ui/integer_arithmetic.rs
index 7b1b64f390a..b74c93dc4a6 100644
--- a/tests/ui/integer_arithmetic.rs
+++ b/tests/ui/integer_arithmetic.rs
@@ -11,6 +11,8 @@
 #[rustfmt::skip]
 fn main() {
     let mut i = 1i32;
+    let mut var1 = 0i32;
+    let mut var2 = -1i32;
     1 + i;
     i * 2;
     1 %
@@ -32,7 +34,15 @@ fn main() {
     i -= 1;
     i *= 2;
     i /= 2;
+    i /= 0;
+    i /= -1;
+    i /= var1;
+    i /= var2;
     i %= 2;
+    i %= 0;
+    i %= -1;
+    i %= var1;
+    i %= var2;
     i <<= 3;
     i >>= 2;
 
diff --git a/tests/ui/integer_arithmetic.stderr b/tests/ui/integer_arithmetic.stderr
index 83e8a9cde3f..20356afc358 100644
--- a/tests/ui/integer_arithmetic.stderr
+++ b/tests/ui/integer_arithmetic.stderr
@@ -1,5 +1,19 @@
+error: this operation will panic at runtime
+  --> $DIR/integer_arithmetic.rs:37:5
+   |
+LL |     i /= 0;
+   |     ^^^^^^ attempt to divide `_` by zero
+   |
+   = note: `#[deny(unconditional_panic)]` on by default
+
+error: this operation will panic at runtime
+  --> $DIR/integer_arithmetic.rs:42:5
+   |
+LL |     i %= 0;
+   |     ^^^^^^ attempt to calculate the remainder of `_` with a divisor of zero
+
 error: integer arithmetic detected
-  --> $DIR/integer_arithmetic.rs:14:5
+  --> $DIR/integer_arithmetic.rs:16:5
    |
 LL |     1 + i;
    |     ^^^^^
@@ -7,125 +21,161 @@ LL |     1 + i;
    = note: `-D clippy::integer-arithmetic` implied by `-D warnings`
 
 error: integer arithmetic detected
-  --> $DIR/integer_arithmetic.rs:15:5
+  --> $DIR/integer_arithmetic.rs:17:5
    |
 LL |     i * 2;
    |     ^^^^^
 
 error: integer arithmetic detected
-  --> $DIR/integer_arithmetic.rs:16:5
+  --> $DIR/integer_arithmetic.rs:18:5
    |
 LL | /     1 %
 LL | |     i / 2; // no error, this is part of the expression in the preceding line
-   | |_________^
+   | |_____^
 
 error: integer arithmetic detected
-  --> $DIR/integer_arithmetic.rs:18:5
+  --> $DIR/integer_arithmetic.rs:20:5
    |
 LL |     i - 2 + 2 - i;
    |     ^^^^^^^^^^^^^
 
 error: integer arithmetic detected
-  --> $DIR/integer_arithmetic.rs:19:5
+  --> $DIR/integer_arithmetic.rs:21:5
    |
 LL |     -i;
    |     ^^
 
 error: integer arithmetic detected
-  --> $DIR/integer_arithmetic.rs:20:5
+  --> $DIR/integer_arithmetic.rs:22:5
    |
 LL |     i >> 1;
    |     ^^^^^^
 
 error: integer arithmetic detected
-  --> $DIR/integer_arithmetic.rs:21:5
+  --> $DIR/integer_arithmetic.rs:23:5
    |
 LL |     i << 1;
    |     ^^^^^^
 
 error: integer arithmetic detected
-  --> $DIR/integer_arithmetic.rs:31:5
+  --> $DIR/integer_arithmetic.rs:33:5
    |
 LL |     i += 1;
    |     ^^^^^^
 
 error: integer arithmetic detected
-  --> $DIR/integer_arithmetic.rs:32:5
+  --> $DIR/integer_arithmetic.rs:34:5
    |
 LL |     i -= 1;
    |     ^^^^^^
 
 error: integer arithmetic detected
-  --> $DIR/integer_arithmetic.rs:33:5
+  --> $DIR/integer_arithmetic.rs:35:5
    |
 LL |     i *= 2;
    |     ^^^^^^
 
 error: integer arithmetic detected
-  --> $DIR/integer_arithmetic.rs:34:5
+  --> $DIR/integer_arithmetic.rs:37:5
    |
-LL |     i /= 2;
+LL |     i /= 0;
    |     ^^^^^^
 
 error: integer arithmetic detected
-  --> $DIR/integer_arithmetic.rs:35:5
+  --> $DIR/integer_arithmetic.rs:38:11
+   |
+LL |     i /= -1;
+   |           ^
+
+error: integer arithmetic detected
+  --> $DIR/integer_arithmetic.rs:39:5
+   |
+LL |     i /= var1;
+   |     ^^^^^^^^^
+
+error: integer arithmetic detected
+  --> $DIR/integer_arithmetic.rs:40:5
+   |
+LL |     i /= var2;
+   |     ^^^^^^^^^
+
+error: integer arithmetic detected
+  --> $DIR/integer_arithmetic.rs:42:5
    |
-LL |     i %= 2;
+LL |     i %= 0;
    |     ^^^^^^
 
 error: integer arithmetic detected
-  --> $DIR/integer_arithmetic.rs:36:5
+  --> $DIR/integer_arithmetic.rs:43:11
+   |
+LL |     i %= -1;
+   |           ^
+
+error: integer arithmetic detected
+  --> $DIR/integer_arithmetic.rs:44:5
+   |
+LL |     i %= var1;
+   |     ^^^^^^^^^
+
+error: integer arithmetic detected
+  --> $DIR/integer_arithmetic.rs:45:5
+   |
+LL |     i %= var2;
+   |     ^^^^^^^^^
+
+error: integer arithmetic detected
+  --> $DIR/integer_arithmetic.rs:46:5
    |
 LL |     i <<= 3;
    |     ^^^^^^^
 
 error: integer arithmetic detected
-  --> $DIR/integer_arithmetic.rs:37:5
+  --> $DIR/integer_arithmetic.rs:47:5
    |
 LL |     i >>= 2;
    |     ^^^^^^^
 
 error: integer arithmetic detected
-  --> $DIR/integer_arithmetic.rs:79:5
+  --> $DIR/integer_arithmetic.rs:89:5
    |
 LL |     3 + &1;
    |     ^^^^^^
 
 error: integer arithmetic detected
-  --> $DIR/integer_arithmetic.rs:80:5
+  --> $DIR/integer_arithmetic.rs:90:5
    |
 LL |     &3 + 1;
    |     ^^^^^^
 
 error: integer arithmetic detected
-  --> $DIR/integer_arithmetic.rs:81:5
+  --> $DIR/integer_arithmetic.rs:91:5
    |
 LL |     &3 + &1;
    |     ^^^^^^^
 
 error: integer arithmetic detected
-  --> $DIR/integer_arithmetic.rs:86:5
+  --> $DIR/integer_arithmetic.rs:96:5
    |
 LL |     a + x
    |     ^^^^^
 
 error: integer arithmetic detected
-  --> $DIR/integer_arithmetic.rs:90:5
+  --> $DIR/integer_arithmetic.rs:100:5
    |
 LL |     x + y
    |     ^^^^^
 
 error: integer arithmetic detected
-  --> $DIR/integer_arithmetic.rs:94:5
+  --> $DIR/integer_arithmetic.rs:104:5
    |
 LL |     x + y
    |     ^^^^^
 
 error: integer arithmetic detected
-  --> $DIR/integer_arithmetic.rs:98:5
+  --> $DIR/integer_arithmetic.rs:108:5
    |
 LL |     (&x + &y)
    |     ^^^^^^^^^
 
-error: aborting due to 21 previous errors
+error: aborting due to 29 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From e3de544c22feb01437a060e88249652c103cb612 Mon Sep 17 00:00:00 2001
From: Christian Nielsen <Urcra@users.noreply.github.com>
Date: Thu, 29 Oct 2020 15:49:42 +0100
Subject: Remove empty lines in doc comment

Co-authored-by: Philipp Krones <hello@philkrones.com>
---
 clippy_lints/src/len_zero.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/len_zero.rs b/clippy_lints/src/len_zero.rs
index d0e7dea4a54..8e2f03d6e4e 100644
--- a/clippy_lints/src/len_zero.rs
+++ b/clippy_lints/src/len_zero.rs
@@ -85,7 +85,7 @@ declare_clippy_lint! {
     /// if s == "" {
     ///     ..
     /// }
-
+    ///
     /// if arr == [] {
     ///     ..
     /// }
@@ -95,7 +95,7 @@ declare_clippy_lint! {
     /// if s.is_empty() {
     ///     ..
     /// }
-
+    ///
     /// if arr.is_empty() {
     ///     ..
     /// }
-- 
cgit 1.4.1-3-g733a5


From 230d9cbe36b809d45efb37092b102bc5d3b350d8 Mon Sep 17 00:00:00 2001
From: dvermd <315743+dvermd@users.noreply.github.com>
Date: Thu, 29 Oct 2020 17:39:19 +0100
Subject: Update clippy_lints/src/ref_option_ref.rs

Co-authored-by: Philipp Krones <hello@philkrones.com>
---
 clippy_lints/src/ref_option_ref.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/ref_option_ref.rs b/clippy_lints/src/ref_option_ref.rs
index e8c60842e76..a914a77d48b 100644
--- a/clippy_lints/src/ref_option_ref.rs
+++ b/clippy_lints/src/ref_option_ref.rs
@@ -55,7 +55,7 @@ impl<'tcx> LateLintPass<'tcx> for RefOptionRef {
                     cx,
                     REF_OPTION_REF,
                     ty.span,
-                    "since & implements Copy trait, &Option<&T> can be simplifyied into Option<&T>",
+                    "since `&` implements the `Copy` trait, `&Option<&T>` can be simplified to `Option<&T>`",
                     "try",
                     format!("Option<{}>", &snippet(cx, inner_ty.span, "..")),
                     Applicability::MaybeIncorrect,
-- 
cgit 1.4.1-3-g733a5


From d780f61d7b3febdf0808dfef9abe80e95f2d46f8 Mon Sep 17 00:00:00 2001
From: Tim Nielens <tim.nielens@gmail.com>
Date: Thu, 29 Oct 2020 19:08:54 +0100
Subject: add manual_ok_or / pr remarks

---
 clippy_lints/src/manual_ok_or.rs | 22 ++++++++++++----------
 1 file changed, 12 insertions(+), 10 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_ok_or.rs b/clippy_lints/src/manual_ok_or.rs
index 38298eb813a..c99d2e35b94 100644
--- a/clippy_lints/src/manual_ok_or.rs
+++ b/clippy_lints/src/manual_ok_or.rs
@@ -1,4 +1,6 @@
-use crate::utils;
+use crate::utils::{
+    indent_of, is_type_diagnostic_item, match_qpath, paths, reindent_multiline, snippet_opt, span_lint_and_sugg,
+};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{def, Expr, ExprKind, PatKind, QPath};
@@ -49,18 +51,18 @@ impl LateLintPass<'_> for ManualOkOr {
             if args.len() == 3;
             let method_receiver = &args[0];
             let ty = cx.typeck_results().expr_ty(method_receiver);
-            if utils::is_type_diagnostic_item(cx, ty, sym!(option_type));
+            if is_type_diagnostic_item(cx, ty, sym!(option_type));
             let or_expr = &args[1];
             if is_ok_wrapping(cx, &args[2]);
             if let ExprKind::Call(Expr { kind: ExprKind::Path(err_path), .. }, &[ref err_arg]) = or_expr.kind;
-            if utils::match_qpath(err_path, &utils::paths::RESULT_ERR);
-            if let Some(method_receiver_snippet) = utils::snippet_opt(cx, method_receiver.span);
-            if let Some(err_arg_snippet) = utils::snippet_opt(cx, err_arg.span);
-            if let Some(indent) = utils::indent_of(cx, scrutinee.span);
+            if match_qpath(err_path, &paths::RESULT_ERR);
+            if let Some(method_receiver_snippet) = snippet_opt(cx, method_receiver.span);
+            if let Some(err_arg_snippet) = snippet_opt(cx, err_arg.span);
+            if let Some(indent) = indent_of(cx, scrutinee.span);
             then {
                 let reindented_err_arg_snippet =
-                    utils::reindent_multiline(err_arg_snippet.into(), true, Some(indent + 4));
-                utils::span_lint_and_sugg(
+                    reindent_multiline(err_arg_snippet.into(), true, Some(indent + 4));
+                span_lint_and_sugg(
                     cx,
                     MANUAL_OK_OR,
                     scrutinee.span,
@@ -80,7 +82,7 @@ impl LateLintPass<'_> for ManualOkOr {
 
 fn is_ok_wrapping(cx: &LateContext<'_>, map_expr: &Expr<'_>) -> bool {
     if let ExprKind::Path(ref qpath) = map_expr.kind {
-        if utils::match_qpath(qpath, &utils::paths::RESULT_OK) {
+        if match_qpath(qpath, &paths::RESULT_OK) {
             return true;
         }
     }
@@ -89,7 +91,7 @@ fn is_ok_wrapping(cx: &LateContext<'_>, map_expr: &Expr<'_>) -> bool {
         let body = cx.tcx.hir().body(body_id);
         if let PatKind::Binding(_, param_id, ..) = body.params[0].pat.kind;
         if let ExprKind::Call(Expr { kind: ExprKind::Path(ok_path), .. }, &[ref ok_arg]) = body.value.kind;
-        if utils::match_qpath(ok_path, &utils::paths::RESULT_OK);
+        if match_qpath(ok_path, &paths::RESULT_OK);
         if let ExprKind::Path(QPath::Resolved(_, ok_arg_path)) = ok_arg.kind;
         if let def::Res::Local(ok_arg_path_id) = ok_arg_path.res;
         then { param_id == ok_arg_path_id } else { false }
-- 
cgit 1.4.1-3-g733a5


From fa0a78b130d52d4504eefbd16689b140e05fce59 Mon Sep 17 00:00:00 2001
From: henil <dedaniahenil@gmail.com>
Date: Fri, 30 Oct 2020 17:11:44 +0530
Subject: removed lint for division/modulo for literal `0`

---
 clippy_lints/src/arithmetic.rs     |  7 +------
 tests/ui/integer_arithmetic.stderr | 14 +-------------
 2 files changed, 2 insertions(+), 19 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/arithmetic.rs b/clippy_lints/src/arithmetic.rs
index b1cdbab6de9..9861d8cfc4e 100644
--- a/clippy_lints/src/arithmetic.rs
+++ b/clippy_lints/src/arithmetic.rs
@@ -90,12 +90,7 @@ impl<'tcx> LateLintPass<'tcx> for Arithmetic {
                 if l_ty.peel_refs().is_integral() && r_ty.peel_refs().is_integral() {
                     match op.node {
                         hir::BinOpKind::Div | hir::BinOpKind::Rem => match &r.kind {
-                            hir::ExprKind::Lit(lit) => {
-                                if let rustc_ast::ast::LitKind::Int(0, _) = lit.node {
-                                    span_lint(cx, INTEGER_ARITHMETIC, expr.span, "integer arithmetic detected");
-                                    self.expr_span = Some(expr.span);
-                                }
-                            },
+                            hir::ExprKind::Lit(_lit) => (),
                             hir::ExprKind::Unary(hir::UnOp::UnNeg, expr) => {
                                 if let hir::ExprKind::Lit(lit) = &expr.kind {
                                     if let rustc_ast::ast::LitKind::Int(1, _) = lit.node {
diff --git a/tests/ui/integer_arithmetic.stderr b/tests/ui/integer_arithmetic.stderr
index 20356afc358..add3b6b90fa 100644
--- a/tests/ui/integer_arithmetic.stderr
+++ b/tests/ui/integer_arithmetic.stderr
@@ -75,12 +75,6 @@ error: integer arithmetic detected
 LL |     i *= 2;
    |     ^^^^^^
 
-error: integer arithmetic detected
-  --> $DIR/integer_arithmetic.rs:37:5
-   |
-LL |     i /= 0;
-   |     ^^^^^^
-
 error: integer arithmetic detected
   --> $DIR/integer_arithmetic.rs:38:11
    |
@@ -99,12 +93,6 @@ error: integer arithmetic detected
 LL |     i /= var2;
    |     ^^^^^^^^^
 
-error: integer arithmetic detected
-  --> $DIR/integer_arithmetic.rs:42:5
-   |
-LL |     i %= 0;
-   |     ^^^^^^
-
 error: integer arithmetic detected
   --> $DIR/integer_arithmetic.rs:43:11
    |
@@ -177,5 +165,5 @@ error: integer arithmetic detected
 LL |     (&x + &y)
    |     ^^^^^^^^^
 
-error: aborting due to 29 previous errors
+error: aborting due to 27 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 7c74d870b5978fb100f8947850d0da3f38dd5c1c Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Fri, 30 Oct 2020 13:01:34 -0500
Subject: Fix vec_box scope error

Fixes #6236
---
 clippy_lints/src/types.rs     |  2 +-
 tests/ui/vec_box_sized.fixed  | 14 ++++++++++++++
 tests/ui/vec_box_sized.rs     | 14 ++++++++++++++
 tests/ui/vec_box_sized.stderr |  8 +++++++-
 4 files changed, 36 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs
index 45f3bc3ea85..1bb81bbc9a3 100644
--- a/clippy_lints/src/types.rs
+++ b/clippy_lints/src/types.rs
@@ -553,7 +553,7 @@ impl Types {
                                     hir_ty.span,
                                     "`Vec<T>` is already on the heap, the boxing is unnecessary.",
                                     "try",
-                                    format!("Vec<{}>", ty_ty),
+                                    format!("Vec<{}>", snippet(cx, boxed_ty.span, "..")),
                                     Applicability::MachineApplicable,
                                 );
                                 return; // don't recurse into the type
diff --git a/tests/ui/vec_box_sized.fixed b/tests/ui/vec_box_sized.fixed
index d0bee2460dd..4fa28b525c3 100644
--- a/tests/ui/vec_box_sized.fixed
+++ b/tests/ui/vec_box_sized.fixed
@@ -35,4 +35,18 @@ mod should_not_trigger {
     }
 }
 
+mod inner_mod {
+    mod inner {
+        pub struct S;
+    }
+
+    mod inner2 {
+        use super::inner::S;
+
+        pub fn f() -> Vec<S> {
+            vec![]
+        }
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/vec_box_sized.rs b/tests/ui/vec_box_sized.rs
index 500a0ae263e..7dc735cd90b 100644
--- a/tests/ui/vec_box_sized.rs
+++ b/tests/ui/vec_box_sized.rs
@@ -35,4 +35,18 @@ mod should_not_trigger {
     }
 }
 
+mod inner_mod {
+    mod inner {
+        pub struct S;
+    }
+
+    mod inner2 {
+        use super::inner::S;
+
+        pub fn f() -> Vec<Box<S>> {
+            vec![]
+        }
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/vec_box_sized.stderr b/tests/ui/vec_box_sized.stderr
index 29bf7069e8a..57e2f1fdf9a 100644
--- a/tests/ui/vec_box_sized.stderr
+++ b/tests/ui/vec_box_sized.stderr
@@ -18,5 +18,11 @@ error: `Vec<T>` is already on the heap, the boxing is unnecessary.
 LL |     struct B(Vec<Vec<Box<(u32)>>>);
    |                  ^^^^^^^^^^^^^^^ help: try: `Vec<u32>`
 
-error: aborting due to 3 previous errors
+error: `Vec<T>` is already on the heap, the boxing is unnecessary.
+  --> $DIR/vec_box_sized.rs:46:23
+   |
+LL |         pub fn f() -> Vec<Box<S>> {
+   |                       ^^^^^^^^^^^ help: try: `Vec<S>`
+
+error: aborting due to 4 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From c0d1002d9328104808253b5cb680d0cd0ab70c1a Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Fri, 30 Oct 2020 16:06:27 -0500
Subject: Fix unnecessary_lazy_eval suggestion applicability

Fixes #6240
---
 clippy_lints/src/methods/unnecessary_lazy_eval.rs | 12 +++++++++++-
 tests/ui/unnecessary_lazy_eval_unfixable.rs       | 18 ++++++++++++++++++
 tests/ui/unnecessary_lazy_eval_unfixable.stderr   | 22 ++++++++++++++++++++++
 3 files changed, 51 insertions(+), 1 deletion(-)
 create mode 100644 tests/ui/unnecessary_lazy_eval_unfixable.rs
 create mode 100644 tests/ui/unnecessary_lazy_eval_unfixable.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/unnecessary_lazy_eval.rs b/clippy_lints/src/methods/unnecessary_lazy_eval.rs
index 08b3eab9b7c..aec1b7e2e46 100644
--- a/clippy_lints/src/methods/unnecessary_lazy_eval.rs
+++ b/clippy_lints/src/methods/unnecessary_lazy_eval.rs
@@ -32,6 +32,16 @@ pub(super) fn lint<'tcx>(
                 } else {
                     "unnecessary closure used to substitute value for `Result::Err`"
                 };
+                let applicability = if body
+                    .params
+                    .iter()
+                    .all(|param| matches!(param.pat.kind, hir::PatKind::Wild))
+                {
+                    Applicability::MachineApplicable
+                } else {
+                    // replacing the lambda may break type inference
+                    Applicability::MaybeIncorrect
+                };
 
                 span_lint_and_sugg(
                     cx,
@@ -45,7 +55,7 @@ pub(super) fn lint<'tcx>(
                         simplify_using,
                         snippet(cx, body_expr.span, ".."),
                     ),
-                    Applicability::MachineApplicable,
+                    applicability,
                 );
             }
         }
diff --git a/tests/ui/unnecessary_lazy_eval_unfixable.rs b/tests/ui/unnecessary_lazy_eval_unfixable.rs
new file mode 100644
index 00000000000..2e923bc97a2
--- /dev/null
+++ b/tests/ui/unnecessary_lazy_eval_unfixable.rs
@@ -0,0 +1,18 @@
+#![warn(clippy::unnecessary_lazy_evaluations)]
+
+struct Deep(Option<usize>);
+
+#[derive(Copy, Clone)]
+struct SomeStruct {
+    some_field: usize,
+}
+
+fn main() {
+    // fix will break type inference
+    let _ = Ok(1).unwrap_or_else(|()| 2);
+    mod e {
+        pub struct E;
+    }
+    let _ = Ok(1).unwrap_or_else(|e::E| 2);
+    let _ = Ok(1).unwrap_or_else(|SomeStruct { .. }| 2);
+}
diff --git a/tests/ui/unnecessary_lazy_eval_unfixable.stderr b/tests/ui/unnecessary_lazy_eval_unfixable.stderr
new file mode 100644
index 00000000000..581d641cbf5
--- /dev/null
+++ b/tests/ui/unnecessary_lazy_eval_unfixable.stderr
@@ -0,0 +1,22 @@
+error: unnecessary closure used to substitute value for `Result::Err`
+  --> $DIR/unnecessary_lazy_eval_unfixable.rs:12:13
+   |
+LL |     let _ = Ok(1).unwrap_or_else(|()| 2);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `unwrap_or` instead: `Ok(1).unwrap_or(2)`
+   |
+   = note: `-D clippy::unnecessary-lazy-evaluations` implied by `-D warnings`
+
+error: unnecessary closure used to substitute value for `Result::Err`
+  --> $DIR/unnecessary_lazy_eval_unfixable.rs:16:13
+   |
+LL |     let _ = Ok(1).unwrap_or_else(|e::E| 2);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `unwrap_or` instead: `Ok(1).unwrap_or(2)`
+
+error: unnecessary closure used to substitute value for `Result::Err`
+  --> $DIR/unnecessary_lazy_eval_unfixable.rs:17:13
+   |
+LL |     let _ = Ok(1).unwrap_or_else(|SomeStruct { .. }| 2);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `unwrap_or` instead: `Ok(1).unwrap_or(2)`
+
+error: aborting due to 3 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 2350ee75b2cc9c3d8cfbbb8d950012678913b92d Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Sun, 13 Sep 2020 13:00:45 +0200
Subject: single_char_push_str lint using insert_str() on single-char literals
 and suggest insert()

changelog: single_char_push_str: lint using string.insert_str() with single char literals and suggests string.insert() with a char

Fixes #6026
---
 clippy_lints/src/methods/mod.rs        | 25 +++++++++++++++++++--
 clippy_lints/src/utils/paths.rs        |  1 +
 tests/ui/single_char_insert_str.fixed  | 18 +++++++++++++++
 tests/ui/single_char_insert_str.rs     | 18 +++++++++++++++
 tests/ui/single_char_insert_str.stderr | 40 ++++++++++++++++++++++++++++++++++
 5 files changed, 100 insertions(+), 2 deletions(-)
 create mode 100644 tests/ui/single_char_insert_str.fixed
 create mode 100644 tests/ui/single_char_insert_str.rs
 create mode 100644 tests/ui/single_char_insert_str.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 3c3093e869c..86e7c57afae 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1290,8 +1290,8 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Warns when using `push_str` with a single-character string literal,
-    /// and `push` with a `char` would work fine.
+    /// **What it does:** Warns when using `push_str` with a single-character string literal
+    /// where `push` with a `char` would work fine.
     ///
     /// **Why is this bad?** It's less clear that we are pushing a single character.
     ///
@@ -1521,6 +1521,8 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
                 if let Some(fn_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id) {
                     if match_def_path(cx, fn_def_id, &paths::PUSH_STR) {
                         lint_single_char_push_string(cx, expr, args);
+                    } else if match_def_path(cx, fn_def_id, &paths::INSERT_STR) {
+                        lint_single_char_insert_string(cx, expr, args);
                     }
                 }
 
@@ -3255,6 +3257,25 @@ fn lint_single_char_push_string(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args
     }
 }
 
+/// lint for length-1 `str`s as argument for `insert_str`
+fn lint_single_char_insert_string(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::Expr<'_>]) {
+    let mut applicability = Applicability::MachineApplicable;
+    if let Some(extension_string) = get_hint_if_single_char_arg(cx, &args[2], &mut applicability) {
+        let base_string_snippet = snippet_with_applicability(cx, args[0].span, "_", &mut applicability);
+        let pos_arg = snippet(cx, args[1].span, "..");
+        let sugg = format!("{}.insert({}, {})", base_string_snippet, pos_arg, extension_string);
+        span_lint_and_sugg(
+            cx,
+            SINGLE_CHAR_PUSH_STR,
+            expr.span,
+            "calling `insert_str()` using a single-character string literal",
+            "consider using `insert` with a character literal",
+            sugg,
+            applicability,
+        );
+    }
+}
+
 /// Checks for the `USELESS_ASREF` lint.
 fn lint_asref(cx: &LateContext<'_>, expr: &hir::Expr<'_>, call_name: &str, as_ref_args: &[hir::Expr<'_>]) {
     // when we get here, we've already checked that the call name is "as_ref" or "as_mut"
diff --git a/clippy_lints/src/utils/paths.rs b/clippy_lints/src/utils/paths.rs
index cd72fdd61fd..34d5c8d2eb7 100644
--- a/clippy_lints/src/utils/paths.rs
+++ b/clippy_lints/src/utils/paths.rs
@@ -52,6 +52,7 @@ pub const HASHMAP_ENTRY: [&str; 5] = ["std", "collections", "hash", "map", "Entr
 pub const HASHSET: [&str; 5] = ["std", "collections", "hash", "set", "HashSet"];
 pub const INDEX: [&str; 3] = ["core", "ops", "Index"];
 pub const INDEX_MUT: [&str; 3] = ["core", "ops", "IndexMut"];
+pub const INSERT_STR: [&str; 4] = ["alloc", "string", "String", "insert_str"];
 pub const INTO: [&str; 3] = ["core", "convert", "Into"];
 pub const INTO_ITERATOR: [&str; 5] = ["core", "iter", "traits", "collect", "IntoIterator"];
 pub const IO_READ: [&str; 3] = ["std", "io", "Read"];
diff --git a/tests/ui/single_char_insert_str.fixed b/tests/ui/single_char_insert_str.fixed
new file mode 100644
index 00000000000..c3416720ec3
--- /dev/null
+++ b/tests/ui/single_char_insert_str.fixed
@@ -0,0 +1,18 @@
+// run-rustfix
+#![warn(clippy::single_char_push_str)]
+
+fn main() {
+    let mut string = String::new();
+    string.insert(0, 'R');
+    string.insert(1, '\'');
+
+    string.insert(0, 'u');
+    string.insert_str(2, "st");
+    string.insert_str(0, "");
+    string.insert(0, '\x52');
+    string.insert(0, '\u{0052}');
+    let x: usize = 2;
+    string.insert(x, 'a');
+    const Y: usize = 1;
+    string.insert(Y, 'a');
+}
diff --git a/tests/ui/single_char_insert_str.rs b/tests/ui/single_char_insert_str.rs
new file mode 100644
index 00000000000..2295669e81d
--- /dev/null
+++ b/tests/ui/single_char_insert_str.rs
@@ -0,0 +1,18 @@
+// run-rustfix
+#![warn(clippy::single_char_push_str)]
+
+fn main() {
+    let mut string = String::new();
+    string.insert_str(0, "R");
+    string.insert_str(1, "'");
+
+    string.insert(0, 'u');
+    string.insert_str(2, "st");
+    string.insert_str(0, "");
+    string.insert_str(0, "\x52");
+    string.insert_str(0, "\u{0052}");
+    let x: usize = 2;
+    string.insert_str(x, r##"a"##);
+    const Y: usize = 1;
+    string.insert_str(Y, r##"a"##);
+}
diff --git a/tests/ui/single_char_insert_str.stderr b/tests/ui/single_char_insert_str.stderr
new file mode 100644
index 00000000000..65dc8a69d69
--- /dev/null
+++ b/tests/ui/single_char_insert_str.stderr
@@ -0,0 +1,40 @@
+error: calling `insert_str()` using a single-character string literal
+  --> $DIR/single_char_insert_str.rs:6:5
+   |
+LL |     string.insert_str(0, "R");
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `insert` with a character literal: `string.insert(0, 'R')`
+   |
+   = note: `-D clippy::single-char-push-str` implied by `-D warnings`
+
+error: calling `insert_str()` using a single-character string literal
+  --> $DIR/single_char_insert_str.rs:7:5
+   |
+LL |     string.insert_str(1, "'");
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `insert` with a character literal: `string.insert(1, '/'')`
+
+error: calling `insert_str()` using a single-character string literal
+  --> $DIR/single_char_insert_str.rs:12:5
+   |
+LL |     string.insert_str(0, "/x52");
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `insert` with a character literal: `string.insert(0, '/x52')`
+
+error: calling `insert_str()` using a single-character string literal
+  --> $DIR/single_char_insert_str.rs:13:5
+   |
+LL |     string.insert_str(0, "/u{0052}");
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `insert` with a character literal: `string.insert(0, '/u{0052}')`
+
+error: calling `insert_str()` using a single-character string literal
+  --> $DIR/single_char_insert_str.rs:15:5
+   |
+LL |     string.insert_str(x, r##"a"##);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `insert` with a character literal: `string.insert(x, 'a')`
+
+error: calling `insert_str()` using a single-character string literal
+  --> $DIR/single_char_insert_str.rs:17:5
+   |
+LL |     string.insert_str(Y, r##"a"##);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `insert` with a character literal: `string.insert(Y, 'a')`
+
+error: aborting due to 6 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From c6412aeebc432ab49d46fe1f45a0fb5322c805d1 Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Mon, 14 Sep 2020 15:31:04 +0200
Subject: handle macros returning Strings in single_char_push_str and
 single_char_insert_str

---
 clippy_lints/src/methods/mod.rs        |  6 ++++--
 tests/ui/single_char_insert_str.fixed  |  8 ++++++++
 tests/ui/single_char_insert_str.rs     |  8 ++++++++
 tests/ui/single_char_insert_str.stderr | 20 +++++++++++++-------
 tests/ui/single_char_push_str.fixed    |  8 ++++++++
 tests/ui/single_char_push_str.rs       |  8 ++++++++
 tests/ui/single_char_push_str.stderr   | 10 +++++-----
 7 files changed, 54 insertions(+), 14 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 86e7c57afae..68a152270e0 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3243,7 +3243,8 @@ fn lint_single_char_pattern(cx: &LateContext<'_>, _expr: &hir::Expr<'_>, arg: &h
 fn lint_single_char_push_string(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::Expr<'_>]) {
     let mut applicability = Applicability::MachineApplicable;
     if let Some(extension_string) = get_hint_if_single_char_arg(cx, &args[1], &mut applicability) {
-        let base_string_snippet = snippet_with_applicability(cx, args[0].span, "..", &mut applicability);
+        let base_string_snippet =
+            snippet_with_applicability(cx, args[0].span.source_callsite(), "..", &mut applicability);
         let sugg = format!("{}.push({})", base_string_snippet, extension_string);
         span_lint_and_sugg(
             cx,
@@ -3261,7 +3262,8 @@ fn lint_single_char_push_string(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args
 fn lint_single_char_insert_string(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::Expr<'_>]) {
     let mut applicability = Applicability::MachineApplicable;
     if let Some(extension_string) = get_hint_if_single_char_arg(cx, &args[2], &mut applicability) {
-        let base_string_snippet = snippet_with_applicability(cx, args[0].span, "_", &mut applicability);
+        let base_string_snippet =
+            snippet_with_applicability(cx, args[0].span.source_callsite(), "_", &mut applicability);
         let pos_arg = snippet(cx, args[1].span, "..");
         let sugg = format!("{}.insert({}, {})", base_string_snippet, pos_arg, extension_string);
         span_lint_and_sugg(
diff --git a/tests/ui/single_char_insert_str.fixed b/tests/ui/single_char_insert_str.fixed
index c3416720ec3..fd43f913330 100644
--- a/tests/ui/single_char_insert_str.fixed
+++ b/tests/ui/single_char_insert_str.fixed
@@ -1,6 +1,12 @@
 // run-rustfix
 #![warn(clippy::single_char_push_str)]
 
+macro_rules! get_string {
+    () => {
+        String::from("Hello world!")
+    };
+}
+
 fn main() {
     let mut string = String::new();
     string.insert(0, 'R');
@@ -15,4 +21,6 @@ fn main() {
     string.insert(x, 'a');
     const Y: usize = 1;
     string.insert(Y, 'a');
+
+    get_string!().insert(1, '?');
 }
diff --git a/tests/ui/single_char_insert_str.rs b/tests/ui/single_char_insert_str.rs
index 2295669e81d..4278f7ef9fd 100644
--- a/tests/ui/single_char_insert_str.rs
+++ b/tests/ui/single_char_insert_str.rs
@@ -1,6 +1,12 @@
 // run-rustfix
 #![warn(clippy::single_char_push_str)]
 
+macro_rules! get_string {
+    () => {
+        String::from("Hello world!")
+    };
+}
+
 fn main() {
     let mut string = String::new();
     string.insert_str(0, "R");
@@ -15,4 +21,6 @@ fn main() {
     string.insert_str(x, r##"a"##);
     const Y: usize = 1;
     string.insert_str(Y, r##"a"##);
+
+    get_string!().insert_str(1, "?");
 }
diff --git a/tests/ui/single_char_insert_str.stderr b/tests/ui/single_char_insert_str.stderr
index 65dc8a69d69..3d00c91a2ac 100644
--- a/tests/ui/single_char_insert_str.stderr
+++ b/tests/ui/single_char_insert_str.stderr
@@ -1,5 +1,5 @@
 error: calling `insert_str()` using a single-character string literal
-  --> $DIR/single_char_insert_str.rs:6:5
+  --> $DIR/single_char_insert_str.rs:12:5
    |
 LL |     string.insert_str(0, "R");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `insert` with a character literal: `string.insert(0, 'R')`
@@ -7,34 +7,40 @@ LL |     string.insert_str(0, "R");
    = note: `-D clippy::single-char-push-str` implied by `-D warnings`
 
 error: calling `insert_str()` using a single-character string literal
-  --> $DIR/single_char_insert_str.rs:7:5
+  --> $DIR/single_char_insert_str.rs:13:5
    |
 LL |     string.insert_str(1, "'");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `insert` with a character literal: `string.insert(1, '/'')`
 
 error: calling `insert_str()` using a single-character string literal
-  --> $DIR/single_char_insert_str.rs:12:5
+  --> $DIR/single_char_insert_str.rs:18:5
    |
 LL |     string.insert_str(0, "/x52");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `insert` with a character literal: `string.insert(0, '/x52')`
 
 error: calling `insert_str()` using a single-character string literal
-  --> $DIR/single_char_insert_str.rs:13:5
+  --> $DIR/single_char_insert_str.rs:19:5
    |
 LL |     string.insert_str(0, "/u{0052}");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `insert` with a character literal: `string.insert(0, '/u{0052}')`
 
 error: calling `insert_str()` using a single-character string literal
-  --> $DIR/single_char_insert_str.rs:15:5
+  --> $DIR/single_char_insert_str.rs:21:5
    |
 LL |     string.insert_str(x, r##"a"##);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `insert` with a character literal: `string.insert(x, 'a')`
 
 error: calling `insert_str()` using a single-character string literal
-  --> $DIR/single_char_insert_str.rs:17:5
+  --> $DIR/single_char_insert_str.rs:23:5
    |
 LL |     string.insert_str(Y, r##"a"##);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `insert` with a character literal: `string.insert(Y, 'a')`
 
-error: aborting due to 6 previous errors
+error: calling `insert_str()` using a single-character string literal
+  --> $DIR/single_char_insert_str.rs:25:5
+   |
+LL |     get_string!().insert_str(1, "?");
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `insert` with a character literal: `get_string!().insert(1, '?')`
+
+error: aborting due to 7 previous errors
 
diff --git a/tests/ui/single_char_push_str.fixed b/tests/ui/single_char_push_str.fixed
index 0812c026a64..da742fe70e2 100644
--- a/tests/ui/single_char_push_str.fixed
+++ b/tests/ui/single_char_push_str.fixed
@@ -1,6 +1,12 @@
 // run-rustfix
 #![warn(clippy::single_char_push_str)]
 
+macro_rules! get_string {
+    () => {
+        String::from("Hello world!")
+    };
+}
+
 fn main() {
     let mut string = String::new();
     string.push('R');
@@ -12,4 +18,6 @@ fn main() {
     string.push('\x52');
     string.push('\u{0052}');
     string.push('a');
+
+    get_string!().push_str("ö");
 }
diff --git a/tests/ui/single_char_push_str.rs b/tests/ui/single_char_push_str.rs
index ab293bbe4ee..a8203e6503e 100644
--- a/tests/ui/single_char_push_str.rs
+++ b/tests/ui/single_char_push_str.rs
@@ -1,6 +1,12 @@
 // run-rustfix
 #![warn(clippy::single_char_push_str)]
 
+macro_rules! get_string {
+    () => {
+        String::from("Hello world!")
+    };
+}
+
 fn main() {
     let mut string = String::new();
     string.push_str("R");
@@ -12,4 +18,6 @@ fn main() {
     string.push_str("\x52");
     string.push_str("\u{0052}");
     string.push_str(r##"a"##);
+
+    get_string!().push_str("ö");
 }
diff --git a/tests/ui/single_char_push_str.stderr b/tests/ui/single_char_push_str.stderr
index 0e9bdaa23e7..1f535589121 100644
--- a/tests/ui/single_char_push_str.stderr
+++ b/tests/ui/single_char_push_str.stderr
@@ -1,5 +1,5 @@
 error: calling `push_str()` using a single-character string literal
-  --> $DIR/single_char_push_str.rs:6:5
+  --> $DIR/single_char_push_str.rs:12:5
    |
 LL |     string.push_str("R");
    |     ^^^^^^^^^^^^^^^^^^^^ help: consider using `push` with a character literal: `string.push('R')`
@@ -7,25 +7,25 @@ LL |     string.push_str("R");
    = note: `-D clippy::single-char-push-str` implied by `-D warnings`
 
 error: calling `push_str()` using a single-character string literal
-  --> $DIR/single_char_push_str.rs:7:5
+  --> $DIR/single_char_push_str.rs:13:5
    |
 LL |     string.push_str("'");
    |     ^^^^^^^^^^^^^^^^^^^^ help: consider using `push` with a character literal: `string.push('/'')`
 
 error: calling `push_str()` using a single-character string literal
-  --> $DIR/single_char_push_str.rs:12:5
+  --> $DIR/single_char_push_str.rs:18:5
    |
 LL |     string.push_str("/x52");
    |     ^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `push` with a character literal: `string.push('/x52')`
 
 error: calling `push_str()` using a single-character string literal
-  --> $DIR/single_char_push_str.rs:13:5
+  --> $DIR/single_char_push_str.rs:19:5
    |
 LL |     string.push_str("/u{0052}");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `push` with a character literal: `string.push('/u{0052}')`
 
 error: calling `push_str()` using a single-character string literal
-  --> $DIR/single_char_push_str.rs:14:5
+  --> $DIR/single_char_push_str.rs:20:5
    |
 LL |     string.push_str(r##"a"##);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `push` with a character literal: `string.push('a')`
-- 
cgit 1.4.1-3-g733a5


From c1eb8ceede6538590a39721c65ee2f943ceffe40 Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Thu, 24 Sep 2020 16:36:29 +0200
Subject: get_hint_if_single_char_arg: fix bug where multi-char letters are not
 detected properly

---
 clippy_lints/src/methods/mod.rs      |  2 +-
 tests/ui/single_char_pattern.fixed   |  6 +++---
 tests/ui/single_char_pattern.stderr  | 20 +++++++++++++++++++-
 tests/ui/single_char_push_str.fixed  |  2 +-
 tests/ui/single_char_push_str.stderr |  8 +++++++-
 5 files changed, 31 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 68a152270e0..5cc3c25e01d 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3204,7 +3204,7 @@ fn get_hint_if_single_char_arg(
         if let hir::ExprKind::Lit(lit) = &arg.kind;
         if let ast::LitKind::Str(r, style) = lit.node;
         let string = r.as_str();
-        if string.len() == 1;
+        if string.chars().count() == 1;
         then {
             let snip = snippet_with_applicability(cx, arg.span, &string, applicability);
             let ch = if let ast::StrStyle::Raw(nhash) = style {
diff --git a/tests/ui/single_char_pattern.fixed b/tests/ui/single_char_pattern.fixed
index 3871c4f2268..817a06199ff 100644
--- a/tests/ui/single_char_pattern.fixed
+++ b/tests/ui/single_char_pattern.fixed
@@ -18,9 +18,9 @@ fn main() {
     //
     // We may not want to suggest changing these anyway
     // See: https://github.com/rust-lang/rust-clippy/issues/650#issuecomment-184328984
-    x.split("ß");
-    x.split("ℝ");
-    x.split("💣");
+    x.split('ß');
+    x.split('ℝ');
+    x.split('💣');
     // Can't use this lint for unicode code points which don't fit in a char
     x.split("❤️");
     x.contains('x');
diff --git a/tests/ui/single_char_pattern.stderr b/tests/ui/single_char_pattern.stderr
index fe7211c53f8..ecaabd9155b 100644
--- a/tests/ui/single_char_pattern.stderr
+++ b/tests/ui/single_char_pattern.stderr
@@ -6,6 +6,24 @@ LL |     x.split("x");
    |
    = note: `-D clippy::single-char-pattern` implied by `-D warnings`
 
+error: single-character string constant used as pattern
+  --> $DIR/single_char_pattern.rs:21:13
+   |
+LL |     x.split("ß");
+   |             ^^^ help: try using a `char` instead: `'ß'`
+
+error: single-character string constant used as pattern
+  --> $DIR/single_char_pattern.rs:22:13
+   |
+LL |     x.split("ℝ");
+   |             ^^^ help: try using a `char` instead: `'ℝ'`
+
+error: single-character string constant used as pattern
+  --> $DIR/single_char_pattern.rs:23:13
+   |
+LL |     x.split("💣");
+   |             ^^^^ help: try using a `char` instead: `'💣'`
+
 error: single-character string constant used as pattern
   --> $DIR/single_char_pattern.rs:26:16
    |
@@ -162,5 +180,5 @@ error: single-character string constant used as pattern
 LL |     x.split(r###"#"###);
    |             ^^^^^^^^^^ help: try using a `char` instead: `'#'`
 
-error: aborting due to 27 previous errors
+error: aborting due to 30 previous errors
 
diff --git a/tests/ui/single_char_push_str.fixed b/tests/ui/single_char_push_str.fixed
index da742fe70e2..3c550bee9a3 100644
--- a/tests/ui/single_char_push_str.fixed
+++ b/tests/ui/single_char_push_str.fixed
@@ -19,5 +19,5 @@ fn main() {
     string.push('\u{0052}');
     string.push('a');
 
-    get_string!().push_str("ö");
+    get_string!().push('ö');
 }
diff --git a/tests/ui/single_char_push_str.stderr b/tests/ui/single_char_push_str.stderr
index 1f535589121..d6e6e635cc5 100644
--- a/tests/ui/single_char_push_str.stderr
+++ b/tests/ui/single_char_push_str.stderr
@@ -30,5 +30,11 @@ error: calling `push_str()` using a single-character string literal
 LL |     string.push_str(r##"a"##);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `push` with a character literal: `string.push('a')`
 
-error: aborting due to 5 previous errors
+error: calling `push_str()` using a single-character string literal
+  --> $DIR/single_char_push_str.rs:22:5
+   |
+LL |     get_string!().push_str("ö");
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `push` with a character literal: `get_string!().push('ö')`
+
+error: aborting due to 6 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From d958269fe5afb26ee5026be5bc0cea459593bccf Mon Sep 17 00:00:00 2001
From: Eduardo Broto <ebroto@tutanota.com>
Date: Thu, 8 Oct 2020 00:03:26 +0200
Subject: Rename single_char_push_str to single_char_add_str

---
 CHANGELOG.md                           |  2 +-
 clippy_lints/src/lib.rs                |  6 +--
 clippy_lints/src/methods/mod.rs        | 16 ++++---
 src/lintlist/mod.rs                    | 12 ++---
 tests/ui/single_char_add_str.fixed     | 43 ++++++++++++++++++
 tests/ui/single_char_add_str.rs        | 43 ++++++++++++++++++
 tests/ui/single_char_add_str.stderr    | 82 ++++++++++++++++++++++++++++++++++
 tests/ui/single_char_insert_str.fixed  | 26 -----------
 tests/ui/single_char_insert_str.rs     | 26 -----------
 tests/ui/single_char_insert_str.stderr | 46 -------------------
 tests/ui/single_char_pattern.fixed     |  6 ---
 tests/ui/single_char_pattern.rs        |  6 ---
 tests/ui/single_char_pattern.stderr    | 58 ++++++++++++------------
 tests/ui/single_char_push_str.fixed    | 23 ----------
 tests/ui/single_char_push_str.rs       | 23 ----------
 tests/ui/single_char_push_str.stderr   | 40 -----------------
 16 files changed, 216 insertions(+), 242 deletions(-)
 create mode 100644 tests/ui/single_char_add_str.fixed
 create mode 100644 tests/ui/single_char_add_str.rs
 create mode 100644 tests/ui/single_char_add_str.stderr
 delete mode 100644 tests/ui/single_char_insert_str.fixed
 delete mode 100644 tests/ui/single_char_insert_str.rs
 delete mode 100644 tests/ui/single_char_insert_str.stderr
 delete mode 100644 tests/ui/single_char_push_str.fixed
 delete mode 100644 tests/ui/single_char_push_str.rs
 delete mode 100644 tests/ui/single_char_push_str.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 6b63dbb7eff..27e861b0d3e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1939,8 +1939,8 @@ Released 2018-09-13
 [`should_assert_eq`]: https://rust-lang.github.io/rust-clippy/master/index.html#should_assert_eq
 [`should_implement_trait`]: https://rust-lang.github.io/rust-clippy/master/index.html#should_implement_trait
 [`similar_names`]: https://rust-lang.github.io/rust-clippy/master/index.html#similar_names
+[`single_char_add_str`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_char_add_str
 [`single_char_pattern`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_char_pattern
-[`single_char_push_str`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_char_push_str
 [`single_component_path_imports`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_component_path_imports
 [`single_element_loop`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_element_loop
 [`single_match`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_match
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 97358e06c63..f2056c72c07 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -713,8 +713,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &methods::RESULT_MAP_OR_INTO_OPTION,
         &methods::SEARCH_IS_SOME,
         &methods::SHOULD_IMPLEMENT_TRAIT,
+        &methods::SINGLE_CHAR_ADD_STR,
         &methods::SINGLE_CHAR_PATTERN,
-        &methods::SINGLE_CHAR_PUSH_STR,
         &methods::SKIP_WHILE_NEXT,
         &methods::STRING_EXTEND_CHARS,
         &methods::SUSPICIOUS_MAP,
@@ -1438,8 +1438,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&methods::RESULT_MAP_OR_INTO_OPTION),
         LintId::of(&methods::SEARCH_IS_SOME),
         LintId::of(&methods::SHOULD_IMPLEMENT_TRAIT),
+        LintId::of(&methods::SINGLE_CHAR_ADD_STR),
         LintId::of(&methods::SINGLE_CHAR_PATTERN),
-        LintId::of(&methods::SINGLE_CHAR_PUSH_STR),
         LintId::of(&methods::SKIP_WHILE_NEXT),
         LintId::of(&methods::STRING_EXTEND_CHARS),
         LintId::of(&methods::SUSPICIOUS_MAP),
@@ -1631,7 +1631,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&methods::OPTION_MAP_OR_NONE),
         LintId::of(&methods::RESULT_MAP_OR_INTO_OPTION),
         LintId::of(&methods::SHOULD_IMPLEMENT_TRAIT),
-        LintId::of(&methods::SINGLE_CHAR_PUSH_STR),
+        LintId::of(&methods::SINGLE_CHAR_ADD_STR),
         LintId::of(&methods::STRING_EXTEND_CHARS),
         LintId::of(&methods::UNNECESSARY_FOLD),
         LintId::of(&methods::UNNECESSARY_LAZY_EVALUATIONS),
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 5cc3c25e01d..89a2db2b76b 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1290,8 +1290,8 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Warns when using `push_str` with a single-character string literal
-    /// where `push` with a `char` would work fine.
+    /// **What it does:** Warns when using `push_str`/`insert_str` with a single-character string literal
+    /// where `push`/`insert` with a `char` would work fine.
     ///
     /// **Why is this bad?** It's less clear that we are pushing a single character.
     ///
@@ -1300,16 +1300,18 @@ declare_clippy_lint! {
     /// **Example:**
     /// ```rust
     /// let mut string = String::new();
+    /// string.insert_str(0, "R");
     /// string.push_str("R");
     /// ```
     /// Could be written as
     /// ```rust
     /// let mut string = String::new();
+    /// string.insert(0, 'R');
     /// string.push('R');
     /// ```
-    pub SINGLE_CHAR_PUSH_STR,
+    pub SINGLE_CHAR_ADD_STR,
     style,
-    "`push_str()` used with a single-character string literal as parameter"
+    "`push_str()` or `insert_str()` used with a single-character string literal as parameter"
 }
 
 declare_clippy_lint! {
@@ -1390,7 +1392,7 @@ declare_lint_pass!(Methods => [
     INEFFICIENT_TO_STRING,
     NEW_RET_NO_SELF,
     SINGLE_CHAR_PATTERN,
-    SINGLE_CHAR_PUSH_STR,
+    SINGLE_CHAR_ADD_STR,
     SEARCH_IS_SOME,
     FILTER_NEXT,
     SKIP_WHILE_NEXT,
@@ -3248,7 +3250,7 @@ fn lint_single_char_push_string(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args
         let sugg = format!("{}.push({})", base_string_snippet, extension_string);
         span_lint_and_sugg(
             cx,
-            SINGLE_CHAR_PUSH_STR,
+            SINGLE_CHAR_ADD_STR,
             expr.span,
             "calling `push_str()` using a single-character string literal",
             "consider using `push` with a character literal",
@@ -3268,7 +3270,7 @@ fn lint_single_char_insert_string(cx: &LateContext<'_>, expr: &hir::Expr<'_>, ar
         let sugg = format!("{}.insert({}, {})", base_string_snippet, pos_arg, extension_string);
         span_lint_and_sugg(
             cx,
-            SINGLE_CHAR_PUSH_STR,
+            SINGLE_CHAR_ADD_STR,
             expr.span,
             "calling `insert_str()` using a single-character string literal",
             "consider using `insert` with a character literal",
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index 016bda77ef5..b22bb074238 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -2147,16 +2147,16 @@ vec![
         module: "non_expressive_names",
     },
     Lint {
-        name: "single_char_pattern",
-        group: "perf",
-        desc: "using a single-character str where a char could be used, e.g., `_.split(\"x\")`",
+        name: "single_char_add_str",
+        group: "style",
+        desc: "`push_str()` or `insert_str()` used with a single-character string literal as parameter",
         deprecation: None,
         module: "methods",
     },
     Lint {
-        name: "single_char_push_str",
-        group: "style",
-        desc: "`push_str()` used with a single-character string literal as parameter",
+        name: "single_char_pattern",
+        group: "perf",
+        desc: "using a single-character str where a char could be used, e.g., `_.split(\"x\")`",
         deprecation: None,
         module: "methods",
     },
diff --git a/tests/ui/single_char_add_str.fixed b/tests/ui/single_char_add_str.fixed
new file mode 100644
index 00000000000..2feba4b8069
--- /dev/null
+++ b/tests/ui/single_char_add_str.fixed
@@ -0,0 +1,43 @@
+// run-rustfix
+#![warn(clippy::single_char_add_str)]
+
+macro_rules! get_string {
+    () => {
+        String::from("Hello world!")
+    };
+}
+
+fn main() {
+    // `push_str` tests
+
+    let mut string = String::new();
+    string.push('R');
+    string.push('\'');
+
+    string.push('u');
+    string.push_str("st");
+    string.push_str("");
+    string.push('\x52');
+    string.push('\u{0052}');
+    string.push('a');
+
+    get_string!().push('ö');
+
+    // `insert_str` tests
+
+    let mut string = String::new();
+    string.insert(0, 'R');
+    string.insert(1, '\'');
+
+    string.insert(0, 'u');
+    string.insert_str(2, "st");
+    string.insert_str(0, "");
+    string.insert(0, '\x52');
+    string.insert(0, '\u{0052}');
+    let x: usize = 2;
+    string.insert(x, 'a');
+    const Y: usize = 1;
+    string.insert(Y, 'a');
+
+    get_string!().insert(1, '?');
+}
diff --git a/tests/ui/single_char_add_str.rs b/tests/ui/single_char_add_str.rs
new file mode 100644
index 00000000000..681b3d10345
--- /dev/null
+++ b/tests/ui/single_char_add_str.rs
@@ -0,0 +1,43 @@
+// run-rustfix
+#![warn(clippy::single_char_add_str)]
+
+macro_rules! get_string {
+    () => {
+        String::from("Hello world!")
+    };
+}
+
+fn main() {
+    // `push_str` tests
+
+    let mut string = String::new();
+    string.push_str("R");
+    string.push_str("'");
+
+    string.push('u');
+    string.push_str("st");
+    string.push_str("");
+    string.push_str("\x52");
+    string.push_str("\u{0052}");
+    string.push_str(r##"a"##);
+
+    get_string!().push_str("ö");
+
+    // `insert_str` tests
+
+    let mut string = String::new();
+    string.insert_str(0, "R");
+    string.insert_str(1, "'");
+
+    string.insert(0, 'u');
+    string.insert_str(2, "st");
+    string.insert_str(0, "");
+    string.insert_str(0, "\x52");
+    string.insert_str(0, "\u{0052}");
+    let x: usize = 2;
+    string.insert_str(x, r##"a"##);
+    const Y: usize = 1;
+    string.insert_str(Y, r##"a"##);
+
+    get_string!().insert_str(1, "?");
+}
diff --git a/tests/ui/single_char_add_str.stderr b/tests/ui/single_char_add_str.stderr
new file mode 100644
index 00000000000..2b17279a564
--- /dev/null
+++ b/tests/ui/single_char_add_str.stderr
@@ -0,0 +1,82 @@
+error: calling `push_str()` using a single-character string literal
+  --> $DIR/single_char_add_str.rs:14:5
+   |
+LL |     string.push_str("R");
+   |     ^^^^^^^^^^^^^^^^^^^^ help: consider using `push` with a character literal: `string.push('R')`
+   |
+   = note: `-D clippy::single-char-add-str` implied by `-D warnings`
+
+error: calling `push_str()` using a single-character string literal
+  --> $DIR/single_char_add_str.rs:15:5
+   |
+LL |     string.push_str("'");
+   |     ^^^^^^^^^^^^^^^^^^^^ help: consider using `push` with a character literal: `string.push('/'')`
+
+error: calling `push_str()` using a single-character string literal
+  --> $DIR/single_char_add_str.rs:20:5
+   |
+LL |     string.push_str("/x52");
+   |     ^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `push` with a character literal: `string.push('/x52')`
+
+error: calling `push_str()` using a single-character string literal
+  --> $DIR/single_char_add_str.rs:21:5
+   |
+LL |     string.push_str("/u{0052}");
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `push` with a character literal: `string.push('/u{0052}')`
+
+error: calling `push_str()` using a single-character string literal
+  --> $DIR/single_char_add_str.rs:22:5
+   |
+LL |     string.push_str(r##"a"##);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `push` with a character literal: `string.push('a')`
+
+error: calling `push_str()` using a single-character string literal
+  --> $DIR/single_char_add_str.rs:24:5
+   |
+LL |     get_string!().push_str("ö");
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `push` with a character literal: `get_string!().push('ö')`
+
+error: calling `insert_str()` using a single-character string literal
+  --> $DIR/single_char_add_str.rs:29:5
+   |
+LL |     string.insert_str(0, "R");
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `insert` with a character literal: `string.insert(0, 'R')`
+
+error: calling `insert_str()` using a single-character string literal
+  --> $DIR/single_char_add_str.rs:30:5
+   |
+LL |     string.insert_str(1, "'");
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `insert` with a character literal: `string.insert(1, '/'')`
+
+error: calling `insert_str()` using a single-character string literal
+  --> $DIR/single_char_add_str.rs:35:5
+   |
+LL |     string.insert_str(0, "/x52");
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `insert` with a character literal: `string.insert(0, '/x52')`
+
+error: calling `insert_str()` using a single-character string literal
+  --> $DIR/single_char_add_str.rs:36:5
+   |
+LL |     string.insert_str(0, "/u{0052}");
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `insert` with a character literal: `string.insert(0, '/u{0052}')`
+
+error: calling `insert_str()` using a single-character string literal
+  --> $DIR/single_char_add_str.rs:38:5
+   |
+LL |     string.insert_str(x, r##"a"##);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `insert` with a character literal: `string.insert(x, 'a')`
+
+error: calling `insert_str()` using a single-character string literal
+  --> $DIR/single_char_add_str.rs:40:5
+   |
+LL |     string.insert_str(Y, r##"a"##);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `insert` with a character literal: `string.insert(Y, 'a')`
+
+error: calling `insert_str()` using a single-character string literal
+  --> $DIR/single_char_add_str.rs:42:5
+   |
+LL |     get_string!().insert_str(1, "?");
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `insert` with a character literal: `get_string!().insert(1, '?')`
+
+error: aborting due to 13 previous errors
+
diff --git a/tests/ui/single_char_insert_str.fixed b/tests/ui/single_char_insert_str.fixed
deleted file mode 100644
index fd43f913330..00000000000
--- a/tests/ui/single_char_insert_str.fixed
+++ /dev/null
@@ -1,26 +0,0 @@
-// run-rustfix
-#![warn(clippy::single_char_push_str)]
-
-macro_rules! get_string {
-    () => {
-        String::from("Hello world!")
-    };
-}
-
-fn main() {
-    let mut string = String::new();
-    string.insert(0, 'R');
-    string.insert(1, '\'');
-
-    string.insert(0, 'u');
-    string.insert_str(2, "st");
-    string.insert_str(0, "");
-    string.insert(0, '\x52');
-    string.insert(0, '\u{0052}');
-    let x: usize = 2;
-    string.insert(x, 'a');
-    const Y: usize = 1;
-    string.insert(Y, 'a');
-
-    get_string!().insert(1, '?');
-}
diff --git a/tests/ui/single_char_insert_str.rs b/tests/ui/single_char_insert_str.rs
deleted file mode 100644
index 4278f7ef9fd..00000000000
--- a/tests/ui/single_char_insert_str.rs
+++ /dev/null
@@ -1,26 +0,0 @@
-// run-rustfix
-#![warn(clippy::single_char_push_str)]
-
-macro_rules! get_string {
-    () => {
-        String::from("Hello world!")
-    };
-}
-
-fn main() {
-    let mut string = String::new();
-    string.insert_str(0, "R");
-    string.insert_str(1, "'");
-
-    string.insert(0, 'u');
-    string.insert_str(2, "st");
-    string.insert_str(0, "");
-    string.insert_str(0, "\x52");
-    string.insert_str(0, "\u{0052}");
-    let x: usize = 2;
-    string.insert_str(x, r##"a"##);
-    const Y: usize = 1;
-    string.insert_str(Y, r##"a"##);
-
-    get_string!().insert_str(1, "?");
-}
diff --git a/tests/ui/single_char_insert_str.stderr b/tests/ui/single_char_insert_str.stderr
deleted file mode 100644
index 3d00c91a2ac..00000000000
--- a/tests/ui/single_char_insert_str.stderr
+++ /dev/null
@@ -1,46 +0,0 @@
-error: calling `insert_str()` using a single-character string literal
-  --> $DIR/single_char_insert_str.rs:12:5
-   |
-LL |     string.insert_str(0, "R");
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `insert` with a character literal: `string.insert(0, 'R')`
-   |
-   = note: `-D clippy::single-char-push-str` implied by `-D warnings`
-
-error: calling `insert_str()` using a single-character string literal
-  --> $DIR/single_char_insert_str.rs:13:5
-   |
-LL |     string.insert_str(1, "'");
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `insert` with a character literal: `string.insert(1, '/'')`
-
-error: calling `insert_str()` using a single-character string literal
-  --> $DIR/single_char_insert_str.rs:18:5
-   |
-LL |     string.insert_str(0, "/x52");
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `insert` with a character literal: `string.insert(0, '/x52')`
-
-error: calling `insert_str()` using a single-character string literal
-  --> $DIR/single_char_insert_str.rs:19:5
-   |
-LL |     string.insert_str(0, "/u{0052}");
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `insert` with a character literal: `string.insert(0, '/u{0052}')`
-
-error: calling `insert_str()` using a single-character string literal
-  --> $DIR/single_char_insert_str.rs:21:5
-   |
-LL |     string.insert_str(x, r##"a"##);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `insert` with a character literal: `string.insert(x, 'a')`
-
-error: calling `insert_str()` using a single-character string literal
-  --> $DIR/single_char_insert_str.rs:23:5
-   |
-LL |     string.insert_str(Y, r##"a"##);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `insert` with a character literal: `string.insert(Y, 'a')`
-
-error: calling `insert_str()` using a single-character string literal
-  --> $DIR/single_char_insert_str.rs:25:5
-   |
-LL |     get_string!().insert_str(1, "?");
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `insert` with a character literal: `get_string!().insert(1, '?')`
-
-error: aborting due to 7 previous errors
-
diff --git a/tests/ui/single_char_pattern.fixed b/tests/ui/single_char_pattern.fixed
index 817a06199ff..d8b5f19e144 100644
--- a/tests/ui/single_char_pattern.fixed
+++ b/tests/ui/single_char_pattern.fixed
@@ -12,12 +12,6 @@ fn main() {
 
     let y = "x";
     x.split(y);
-    // Not yet testing for multi-byte characters
-    // Changing `r.len() == 1` to `r.chars().count() == 1` in `lint_clippy::single_char_pattern`
-    // should have done this but produced an ICE
-    //
-    // We may not want to suggest changing these anyway
-    // See: https://github.com/rust-lang/rust-clippy/issues/650#issuecomment-184328984
     x.split('ß');
     x.split('ℝ');
     x.split('💣');
diff --git a/tests/ui/single_char_pattern.rs b/tests/ui/single_char_pattern.rs
index 32afe339cd8..a7bc73e3756 100644
--- a/tests/ui/single_char_pattern.rs
+++ b/tests/ui/single_char_pattern.rs
@@ -12,12 +12,6 @@ fn main() {
 
     let y = "x";
     x.split(y);
-    // Not yet testing for multi-byte characters
-    // Changing `r.len() == 1` to `r.chars().count() == 1` in `lint_clippy::single_char_pattern`
-    // should have done this but produced an ICE
-    //
-    // We may not want to suggest changing these anyway
-    // See: https://github.com/rust-lang/rust-clippy/issues/650#issuecomment-184328984
     x.split("ß");
     x.split("ℝ");
     x.split("💣");
diff --git a/tests/ui/single_char_pattern.stderr b/tests/ui/single_char_pattern.stderr
index ecaabd9155b..ee4e7e50efd 100644
--- a/tests/ui/single_char_pattern.stderr
+++ b/tests/ui/single_char_pattern.stderr
@@ -7,175 +7,175 @@ LL |     x.split("x");
    = note: `-D clippy::single-char-pattern` implied by `-D warnings`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:21:13
+  --> $DIR/single_char_pattern.rs:15:13
    |
 LL |     x.split("ß");
    |             ^^^ help: try using a `char` instead: `'ß'`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:22:13
+  --> $DIR/single_char_pattern.rs:16:13
    |
 LL |     x.split("ℝ");
    |             ^^^ help: try using a `char` instead: `'ℝ'`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:23:13
+  --> $DIR/single_char_pattern.rs:17:13
    |
 LL |     x.split("💣");
    |             ^^^^ help: try using a `char` instead: `'💣'`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:26:16
+  --> $DIR/single_char_pattern.rs:20:16
    |
 LL |     x.contains("x");
    |                ^^^ help: try using a `char` instead: `'x'`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:27:19
+  --> $DIR/single_char_pattern.rs:21:19
    |
 LL |     x.starts_with("x");
    |                   ^^^ help: try using a `char` instead: `'x'`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:28:17
+  --> $DIR/single_char_pattern.rs:22:17
    |
 LL |     x.ends_with("x");
    |                 ^^^ help: try using a `char` instead: `'x'`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:29:12
+  --> $DIR/single_char_pattern.rs:23:12
    |
 LL |     x.find("x");
    |            ^^^ help: try using a `char` instead: `'x'`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:30:13
+  --> $DIR/single_char_pattern.rs:24:13
    |
 LL |     x.rfind("x");
    |             ^^^ help: try using a `char` instead: `'x'`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:31:14
+  --> $DIR/single_char_pattern.rs:25:14
    |
 LL |     x.rsplit("x");
    |              ^^^ help: try using a `char` instead: `'x'`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:32:24
+  --> $DIR/single_char_pattern.rs:26:24
    |
 LL |     x.split_terminator("x");
    |                        ^^^ help: try using a `char` instead: `'x'`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:33:25
+  --> $DIR/single_char_pattern.rs:27:25
    |
 LL |     x.rsplit_terminator("x");
    |                         ^^^ help: try using a `char` instead: `'x'`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:34:17
+  --> $DIR/single_char_pattern.rs:28:17
    |
 LL |     x.splitn(0, "x");
    |                 ^^^ help: try using a `char` instead: `'x'`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:35:18
+  --> $DIR/single_char_pattern.rs:29:18
    |
 LL |     x.rsplitn(0, "x");
    |                  ^^^ help: try using a `char` instead: `'x'`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:36:15
+  --> $DIR/single_char_pattern.rs:30:15
    |
 LL |     x.matches("x");
    |               ^^^ help: try using a `char` instead: `'x'`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:37:16
+  --> $DIR/single_char_pattern.rs:31:16
    |
 LL |     x.rmatches("x");
    |                ^^^ help: try using a `char` instead: `'x'`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:38:21
+  --> $DIR/single_char_pattern.rs:32:21
    |
 LL |     x.match_indices("x");
    |                     ^^^ help: try using a `char` instead: `'x'`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:39:22
+  --> $DIR/single_char_pattern.rs:33:22
    |
 LL |     x.rmatch_indices("x");
    |                      ^^^ help: try using a `char` instead: `'x'`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:40:26
+  --> $DIR/single_char_pattern.rs:34:26
    |
 LL |     x.trim_start_matches("x");
    |                          ^^^ help: try using a `char` instead: `'x'`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:41:24
+  --> $DIR/single_char_pattern.rs:35:24
    |
 LL |     x.trim_end_matches("x");
    |                        ^^^ help: try using a `char` instead: `'x'`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:43:13
+  --> $DIR/single_char_pattern.rs:37:13
    |
 LL |     x.split("/n");
    |             ^^^^ help: try using a `char` instead: `'/n'`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:44:13
+  --> $DIR/single_char_pattern.rs:38:13
    |
 LL |     x.split("'");
    |             ^^^ help: try using a `char` instead: `'/''`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:45:13
+  --> $DIR/single_char_pattern.rs:39:13
    |
 LL |     x.split("/'");
    |             ^^^^ help: try using a `char` instead: `'/''`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:50:31
+  --> $DIR/single_char_pattern.rs:44:31
    |
 LL |     x.replace(";", ",").split(","); // issue #2978
    |                               ^^^ help: try using a `char` instead: `','`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:51:19
+  --> $DIR/single_char_pattern.rs:45:19
    |
 LL |     x.starts_with("/x03"); // issue #2996
    |                   ^^^^^^ help: try using a `char` instead: `'/x03'`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:58:13
+  --> $DIR/single_char_pattern.rs:52:13
    |
 LL |     x.split(r"a");
    |             ^^^^ help: try using a `char` instead: `'a'`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:59:13
+  --> $DIR/single_char_pattern.rs:53:13
    |
 LL |     x.split(r#"a"#);
    |             ^^^^^^ help: try using a `char` instead: `'a'`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:60:13
+  --> $DIR/single_char_pattern.rs:54:13
    |
 LL |     x.split(r###"a"###);
    |             ^^^^^^^^^^ help: try using a `char` instead: `'a'`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:61:13
+  --> $DIR/single_char_pattern.rs:55:13
    |
 LL |     x.split(r###"'"###);
    |             ^^^^^^^^^^ help: try using a `char` instead: `'/''`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:62:13
+  --> $DIR/single_char_pattern.rs:56:13
    |
 LL |     x.split(r###"#"###);
    |             ^^^^^^^^^^ help: try using a `char` instead: `'#'`
diff --git a/tests/ui/single_char_push_str.fixed b/tests/ui/single_char_push_str.fixed
deleted file mode 100644
index 3c550bee9a3..00000000000
--- a/tests/ui/single_char_push_str.fixed
+++ /dev/null
@@ -1,23 +0,0 @@
-// run-rustfix
-#![warn(clippy::single_char_push_str)]
-
-macro_rules! get_string {
-    () => {
-        String::from("Hello world!")
-    };
-}
-
-fn main() {
-    let mut string = String::new();
-    string.push('R');
-    string.push('\'');
-
-    string.push('u');
-    string.push_str("st");
-    string.push_str("");
-    string.push('\x52');
-    string.push('\u{0052}');
-    string.push('a');
-
-    get_string!().push('ö');
-}
diff --git a/tests/ui/single_char_push_str.rs b/tests/ui/single_char_push_str.rs
deleted file mode 100644
index a8203e6503e..00000000000
--- a/tests/ui/single_char_push_str.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-// run-rustfix
-#![warn(clippy::single_char_push_str)]
-
-macro_rules! get_string {
-    () => {
-        String::from("Hello world!")
-    };
-}
-
-fn main() {
-    let mut string = String::new();
-    string.push_str("R");
-    string.push_str("'");
-
-    string.push('u');
-    string.push_str("st");
-    string.push_str("");
-    string.push_str("\x52");
-    string.push_str("\u{0052}");
-    string.push_str(r##"a"##);
-
-    get_string!().push_str("ö");
-}
diff --git a/tests/ui/single_char_push_str.stderr b/tests/ui/single_char_push_str.stderr
deleted file mode 100644
index d6e6e635cc5..00000000000
--- a/tests/ui/single_char_push_str.stderr
+++ /dev/null
@@ -1,40 +0,0 @@
-error: calling `push_str()` using a single-character string literal
-  --> $DIR/single_char_push_str.rs:12:5
-   |
-LL |     string.push_str("R");
-   |     ^^^^^^^^^^^^^^^^^^^^ help: consider using `push` with a character literal: `string.push('R')`
-   |
-   = note: `-D clippy::single-char-push-str` implied by `-D warnings`
-
-error: calling `push_str()` using a single-character string literal
-  --> $DIR/single_char_push_str.rs:13:5
-   |
-LL |     string.push_str("'");
-   |     ^^^^^^^^^^^^^^^^^^^^ help: consider using `push` with a character literal: `string.push('/'')`
-
-error: calling `push_str()` using a single-character string literal
-  --> $DIR/single_char_push_str.rs:18:5
-   |
-LL |     string.push_str("/x52");
-   |     ^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `push` with a character literal: `string.push('/x52')`
-
-error: calling `push_str()` using a single-character string literal
-  --> $DIR/single_char_push_str.rs:19:5
-   |
-LL |     string.push_str("/u{0052}");
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `push` with a character literal: `string.push('/u{0052}')`
-
-error: calling `push_str()` using a single-character string literal
-  --> $DIR/single_char_push_str.rs:20:5
-   |
-LL |     string.push_str(r##"a"##);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `push` with a character literal: `string.push('a')`
-
-error: calling `push_str()` using a single-character string literal
-  --> $DIR/single_char_push_str.rs:22:5
-   |
-LL |     get_string!().push_str("ö");
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `push` with a character literal: `get_string!().push('ö')`
-
-error: aborting due to 6 previous errors
-
-- 
cgit 1.4.1-3-g733a5


From f8ac1f99efd996bea2b05c83a915a830d69e1690 Mon Sep 17 00:00:00 2001
From: Eduardo Broto <ebroto@tutanota.com>
Date: Fri, 30 Oct 2020 23:47:22 +0100
Subject: Address suggestions in PR review

---
 CHANGELOG.md                        |  2 +-
 clippy_lints/src/lib.rs             |  1 +
 clippy_lints/src/methods/mod.rs     |  2 +-
 tests/ui/single_char_add_str.fixed  |  2 ++
 tests/ui/single_char_add_str.rs     |  2 ++
 tests/ui/single_char_add_str.stderr | 14 +++++++++++++-
 6 files changed, 20 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 27e861b0d3e..be47eeaa073 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -22,7 +22,7 @@ Current beta, release 2020-11-19
 * [`map_err_ignore`] [#5998](https://github.com/rust-lang/rust-clippy/pull/5998)
 * [`rc_buffer`] [#6044](https://github.com/rust-lang/rust-clippy/pull/6044)
 * [`to_string_in_display`] [#5831](https://github.com/rust-lang/rust-clippy/pull/5831)
-* [`single_char_push_str`] [#5881](https://github.com/rust-lang/rust-clippy/pull/5881)
+* `single_char_push_str` [#5881](https://github.com/rust-lang/rust-clippy/pull/5881)
 
 ### Moves and Deprecations
 
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index f2056c72c07..9d9097002d6 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1958,6 +1958,7 @@ pub fn register_renamed(ls: &mut rustc_lint::LintStore) {
     ls.register_renamed("clippy::for_loop_over_result", "clippy::for_loops_over_fallibles");
     ls.register_renamed("clippy::identity_conversion", "clippy::useless_conversion");
     ls.register_renamed("clippy::zero_width_space", "clippy::invisible_characters");
+    ls.register_renamed("clippy::single_char_push_str", "clippy::single_char_add_str");
 }
 
 // only exists to let the dogfood integration test works.
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 89a2db2b76b..558c90249cc 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3266,7 +3266,7 @@ fn lint_single_char_insert_string(cx: &LateContext<'_>, expr: &hir::Expr<'_>, ar
     if let Some(extension_string) = get_hint_if_single_char_arg(cx, &args[2], &mut applicability) {
         let base_string_snippet =
             snippet_with_applicability(cx, args[0].span.source_callsite(), "_", &mut applicability);
-        let pos_arg = snippet(cx, args[1].span, "..");
+        let pos_arg = snippet_with_applicability(cx, args[1].span, "..", &mut applicability);
         let sugg = format!("{}.insert({}, {})", base_string_snippet, pos_arg, extension_string);
         span_lint_and_sugg(
             cx,
diff --git a/tests/ui/single_char_add_str.fixed b/tests/ui/single_char_add_str.fixed
index 2feba4b8069..63a6d37a9cc 100644
--- a/tests/ui/single_char_add_str.fixed
+++ b/tests/ui/single_char_add_str.fixed
@@ -38,6 +38,8 @@ fn main() {
     string.insert(x, 'a');
     const Y: usize = 1;
     string.insert(Y, 'a');
+    string.insert(Y, '"');
+    string.insert(Y, '\'');
 
     get_string!().insert(1, '?');
 }
diff --git a/tests/ui/single_char_add_str.rs b/tests/ui/single_char_add_str.rs
index 681b3d10345..a799ea7d885 100644
--- a/tests/ui/single_char_add_str.rs
+++ b/tests/ui/single_char_add_str.rs
@@ -38,6 +38,8 @@ fn main() {
     string.insert_str(x, r##"a"##);
     const Y: usize = 1;
     string.insert_str(Y, r##"a"##);
+    string.insert_str(Y, r##"""##);
+    string.insert_str(Y, r##"'"##);
 
     get_string!().insert_str(1, "?");
 }
diff --git a/tests/ui/single_char_add_str.stderr b/tests/ui/single_char_add_str.stderr
index 2b17279a564..55d91583ad0 100644
--- a/tests/ui/single_char_add_str.stderr
+++ b/tests/ui/single_char_add_str.stderr
@@ -72,11 +72,23 @@ error: calling `insert_str()` using a single-character string literal
 LL |     string.insert_str(Y, r##"a"##);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `insert` with a character literal: `string.insert(Y, 'a')`
 
+error: calling `insert_str()` using a single-character string literal
+  --> $DIR/single_char_add_str.rs:41:5
+   |
+LL |     string.insert_str(Y, r##"""##);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `insert` with a character literal: `string.insert(Y, '"')`
+
 error: calling `insert_str()` using a single-character string literal
   --> $DIR/single_char_add_str.rs:42:5
    |
+LL |     string.insert_str(Y, r##"'"##);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `insert` with a character literal: `string.insert(Y, '/'')`
+
+error: calling `insert_str()` using a single-character string literal
+  --> $DIR/single_char_add_str.rs:44:5
+   |
 LL |     get_string!().insert_str(1, "?");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `insert` with a character literal: `get_string!().insert(1, '?')`
 
-error: aborting due to 13 previous errors
+error: aborting due to 15 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 2eb248dd16f6727a2cdaa66f3f529a53bbcc54c7 Mon Sep 17 00:00:00 2001
From: Eduardo Broto <ebroto@tutanota.com>
Date: Sat, 31 Oct 2020 09:34:01 +0100
Subject: Fix formatting

---
 clippy_lints/src/redundant_clone.rs | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/redundant_clone.rs b/clippy_lints/src/redundant_clone.rs
index ae3b0a03754..344ed02361d 100644
--- a/clippy_lints/src/redundant_clone.rs
+++ b/clippy_lints/src/redundant_clone.rs
@@ -518,7 +518,10 @@ impl<'a, 'tcx> mir::visit::Visitor<'tcx> for PossibleBorrowerVisitor<'a, 'tcx> {
                 self.possible_borrower.add(borrowed.local, lhs);
             },
             other => {
-                if ContainsRegion.visit_ty(place.ty(&self.body.local_decls, self.cx.tcx).ty).is_continue() {
+                if ContainsRegion
+                    .visit_ty(place.ty(&self.body.local_decls, self.cx.tcx).ty)
+                    .is_continue()
+                {
                     return;
                 }
                 rvalue_locals(other, |rhs| {
-- 
cgit 1.4.1-3-g733a5


From 7b203f3da6b590059c12bb01d0873b31be347928 Mon Sep 17 00:00:00 2001
From: Henri Lunnikivi <henri.lunnikivi@gmail.com>
Date: Thu, 31 Oct 2019 18:02:02 +0200
Subject: Implement field_reassign_with_default

- Implement `field_reassign_with_default` as a `LateLintPass`
- Avoid triggering `default_trait_access` on a span already linted by
`field_reassigned_with_default`
- Merge `default_trait_access` and `field_reassign_with_default` into
`Default`
- Co-authored-by: Eduardo Broto <ebroto@tutanota.com>
- Fixes #568
---
 CHANGELOG.md                                |   1 +
 clippy_lints/src/default.rs                 | 304 ++++++++++++++++++++++++++++
 clippy_lints/src/default_trait_access.rs    |  62 ------
 clippy_lints/src/lib.rs                     |  11 +-
 src/lintlist/mod.rs                         |   9 +-
 tests/ui/field_reassign_with_default.rs     | 110 ++++++++++
 tests/ui/field_reassign_with_default.stderr |  75 +++++++
 7 files changed, 505 insertions(+), 67 deletions(-)
 create mode 100644 clippy_lints/src/default.rs
 delete mode 100644 clippy_lints/src/default_trait_access.rs
 create mode 100644 tests/ui/field_reassign_with_default.rs
 create mode 100644 tests/ui/field_reassign_with_default.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 6b63dbb7eff..36b54416a19 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1714,6 +1714,7 @@ Released 2018-09-13
 [`extend_from_slice`]: https://rust-lang.github.io/rust-clippy/master/index.html#extend_from_slice
 [`extra_unused_lifetimes`]: https://rust-lang.github.io/rust-clippy/master/index.html#extra_unused_lifetimes
 [`fallible_impl_from`]: https://rust-lang.github.io/rust-clippy/master/index.html#fallible_impl_from
+[`field_reassign_with_default`]: https://rust-lang.github.io/rust-clippy/master/index.html#field_reassign_with_default
 [`filetype_is_file`]: https://rust-lang.github.io/rust-clippy/master/index.html#filetype_is_file
 [`filter_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#filter_map
 [`filter_map_next`]: https://rust-lang.github.io/rust-clippy/master/index.html#filter_map_next
diff --git a/clippy_lints/src/default.rs b/clippy_lints/src/default.rs
new file mode 100644
index 00000000000..612c5355338
--- /dev/null
+++ b/clippy_lints/src/default.rs
@@ -0,0 +1,304 @@
+use crate::utils::{any_parent_is_automatically_derived, contains_name, match_def_path, paths, qpath_res, snippet};
+use crate::utils::{span_lint_and_note, span_lint_and_sugg};
+use if_chain::if_chain;
+use rustc_data_structures::fx::FxHashSet;
+use rustc_errors::Applicability;
+use rustc_hir::def::Res;
+use rustc_hir::{Block, Expr, ExprKind, PatKind, QPath, Stmt, StmtKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::{self, Adt, Ty};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::symbol::{Ident, Symbol};
+use rustc_span::Span;
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for literal calls to `Default::default()`.
+    ///
+    /// **Why is this bad?** It's more clear to the reader to use the name of the type whose default is
+    /// being gotten than the generic `Default`.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// ```rust
+    /// // Bad
+    /// let s: String = Default::default();
+    ///
+    /// // Good
+    /// let s = String::default();
+    /// ```
+    pub DEFAULT_TRAIT_ACCESS,
+    pedantic,
+    "checks for literal calls to `Default::default()`"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for immediate reassignment of fields initialized
+    /// with Default::default().
+    ///
+    /// **Why is this bad?**It's more idiomatic to use the [functional update syntax](https://doc.rust-lang.org/reference/expressions/struct-expr.html#functional-update-syntax).
+    ///
+    /// **Known problems:** Assignments to patterns that are of tuple type are not linted.
+    ///
+    /// **Example:**
+    /// Bad:
+    /// ```
+    /// # #[derive(Default)]
+    /// # struct A { i: i32 }
+    /// let mut a: A = Default::default();
+    /// a.i = 42;
+    /// ```
+    /// Use instead:
+    /// ```
+    /// # #[derive(Default)]
+    /// # struct A { i: i32 }
+    /// let a = A {
+    ///     i: 42,
+    ///     .. Default::default()
+    /// };
+    /// ```
+    pub FIELD_REASSIGN_WITH_DEFAULT,
+    style,
+    "binding initialized with Default should have its fields set in the initializer"
+}
+
+#[derive(Default)]
+pub struct Default {
+    // Spans linted by `field_reassign_with_default`.
+    reassigned_linted: FxHashSet<Span>,
+}
+
+impl_lint_pass!(Default => [DEFAULT_TRAIT_ACCESS, FIELD_REASSIGN_WITH_DEFAULT]);
+
+impl LateLintPass<'_> for Default {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        if_chain! {
+            // Avoid cases already linted by `field_reassign_with_default`
+            if !self.reassigned_linted.contains(&expr.span);
+            if let ExprKind::Call(ref path, ..) = expr.kind;
+            if !any_parent_is_automatically_derived(cx.tcx, expr.hir_id);
+            if let ExprKind::Path(ref qpath) = path.kind;
+            if let Some(def_id) = cx.qpath_res(qpath, path.hir_id).opt_def_id();
+            if match_def_path(cx, def_id, &paths::DEFAULT_TRAIT_METHOD);
+            // Detect and ignore <Foo as Default>::default() because these calls do explicitly name the type.
+            if let QPath::Resolved(None, _path) = qpath;
+            then {
+                let expr_ty = cx.typeck_results().expr_ty(expr);
+                if let ty::Adt(def, ..) = expr_ty.kind() {
+                    // TODO: Work out a way to put "whatever the imported way of referencing
+                    // this type in this file" rather than a fully-qualified type.
+                    let replacement = format!("{}::default()", cx.tcx.def_path_str(def.did));
+                    span_lint_and_sugg(
+                        cx,
+                        DEFAULT_TRAIT_ACCESS,
+                        expr.span,
+                        &format!("calling `{}` is more clear than this expression", replacement),
+                        "try",
+                        replacement,
+                        Applicability::Unspecified, // First resolve the TODO above
+                    );
+                }
+            }
+        }
+    }
+
+    fn check_block<'tcx>(&mut self, cx: &LateContext<'tcx>, block: &Block<'tcx>) {
+        // find all binding statements like `let mut _ = T::default()` where `T::default()` is the
+        // `default` method of the `Default` trait, and store statement index in current block being
+        // checked and the name of the bound variable
+        let binding_statements_using_default = enumerate_bindings_using_default(cx, block);
+
+        // start from the `let mut _ = _::default();` and look at all the following
+        // statements, see if they re-assign the fields of the binding
+        for (stmt_idx, binding_name, binding_type, span) in binding_statements_using_default {
+            // the last statement of a block cannot trigger the lint
+            if stmt_idx == block.stmts.len() - 1 {
+                break;
+            }
+
+            // find all "later statement"'s where the fields of the binding set as
+            // Default::default() get reassigned, unless the reassignment refers to the original binding
+            let mut first_assign = None;
+            let mut assigned_fields = Vec::new();
+            let mut cancel_lint = false;
+            for consecutive_statement in &block.stmts[stmt_idx + 1..] {
+                // interrupt if the statement is a let binding (`Local`) that shadows the original
+                // binding
+                if stmt_shadows_binding(consecutive_statement, binding_name) {
+                    break;
+                }
+                // find out if and which field was set by this `consecutive_statement`
+                else if let Some((field_ident, assign_rhs)) =
+                    field_reassigned_by_stmt(consecutive_statement, binding_name)
+                {
+                    // interrupt and cancel lint if assign_rhs references the original binding
+                    if contains_name(binding_name, assign_rhs) {
+                        cancel_lint = true;
+                        break;
+                    }
+
+                    // if the field was previously assigned, replace the assignment, otherwise insert the assignment
+                    if let Some(prev) = assigned_fields
+                        .iter_mut()
+                        .find(|(field_name, _)| field_name == &field_ident.name)
+                    {
+                        *prev = (field_ident.name, assign_rhs);
+                    } else {
+                        assigned_fields.push((field_ident.name, assign_rhs));
+                    }
+
+                    // also set first instance of error for help message
+                    if first_assign.is_none() {
+                        first_assign = Some(consecutive_statement);
+                    }
+                }
+                // interrupt also if no field was assigned, since we only want to look at consecutive statements
+                else {
+                    break;
+                }
+            }
+
+            // if there are incorrectly assigned fields, do a span_lint_and_note to suggest
+            // construction using `Ty { fields, ..Default::default() }`
+            if !assigned_fields.is_empty() && !cancel_lint {
+                // take the original assignment as span
+                let stmt = &block.stmts[stmt_idx];
+
+                if let StmtKind::Local(preceding_local) = &stmt.kind {
+                    // filter out fields like `= Default::default()`, because the FRU already covers them
+                    let assigned_fields = assigned_fields
+                        .into_iter()
+                        .filter(|(_, rhs)| !is_expr_default(rhs, cx))
+                        .collect::<Vec<(Symbol, &Expr<'_>)>>();
+
+                    // if all fields of the struct are not assigned, add `.. Default::default()` to the suggestion.
+                    let ext_with_default = !fields_of_type(binding_type)
+                        .iter()
+                        .all(|field| assigned_fields.iter().any(|(a, _)| a == &field.name));
+
+                    let field_list = assigned_fields
+                        .into_iter()
+                        .map(|(field, rhs)| {
+                            // extract and store the assigned value for help message
+                            let value_snippet = snippet(cx, rhs.span, "..");
+                            format!("{}: {}", field, value_snippet)
+                        })
+                        .collect::<Vec<String>>()
+                        .join(", ");
+
+                    let sugg = if ext_with_default {
+                        if field_list.is_empty() {
+                            format!("{}::default()", binding_type)
+                        } else {
+                            format!("{} {{ {}, ..Default::default() }}", binding_type, field_list)
+                        }
+                    } else {
+                        format!("{} {{ {} }}", binding_type, field_list)
+                    };
+
+                    // span lint once per statement that binds default
+                    span_lint_and_note(
+                        cx,
+                        FIELD_REASSIGN_WITH_DEFAULT,
+                        first_assign.unwrap().span,
+                        "field assignment outside of initializer for an instance created with Default::default()",
+                        Some(preceding_local.span),
+                        &format!(
+                            "consider initializing the variable with `{}` and removing relevant reassignments",
+                            sugg
+                        ),
+                    );
+                    self.reassigned_linted.insert(span);
+                }
+            }
+        }
+    }
+}
+
+/// Checks if the given expression is the `default` method belonging to the `Default` trait.
+fn is_expr_default<'tcx>(expr: &'tcx Expr<'tcx>, cx: &LateContext<'tcx>) -> bool {
+    if_chain! {
+        if let ExprKind::Call(ref fn_expr, _) = &expr.kind;
+        if let ExprKind::Path(qpath) = &fn_expr.kind;
+        if let Res::Def(_, def_id) = qpath_res(cx, qpath, fn_expr.hir_id);
+        then {
+            // right hand side of assignment is `Default::default`
+            match_def_path(cx, def_id, &paths::DEFAULT_TRAIT_METHOD)
+        } else {
+            false
+        }
+    }
+}
+
+/// Returns the block indices, identifiers and types of bindings set as `Default::default()`, except
+/// for when the pattern type is a tuple.
+fn enumerate_bindings_using_default<'tcx>(
+    cx: &LateContext<'tcx>,
+    block: &Block<'tcx>,
+) -> Vec<(usize, Symbol, Ty<'tcx>, Span)> {
+    block
+        .stmts
+        .iter()
+        .enumerate()
+        .filter_map(|(idx, stmt)| {
+            if_chain! {
+                // only take `let ...` statements
+                if let StmtKind::Local(ref local) = stmt.kind;
+                // only take bindings to identifiers
+                if let PatKind::Binding(_, _, ident, _) = local.pat.kind;
+                // that are not tuples
+                let ty = cx.typeck_results().pat_ty(local.pat);
+                if !matches!(ty.kind(), ty::Tuple(_));
+                // only when assigning `... = Default::default()`
+                if let Some(ref expr) = local.init;
+                if is_expr_default(expr, cx);
+                then {
+                    Some((idx, ident.name, ty, expr.span))
+                } else {
+                    None
+                }
+            }
+        })
+        .collect()
+}
+
+fn stmt_shadows_binding(this: &Stmt<'_>, shadowed: Symbol) -> bool {
+    if let StmtKind::Local(local) = &this.kind {
+        if let PatKind::Binding(_, _, ident, _) = local.pat.kind {
+            return ident.name == shadowed;
+        }
+    }
+    false
+}
+
+/// Returns the reassigned field and the assigning expression (right-hand side of assign).
+fn field_reassigned_by_stmt<'tcx>(this: &Stmt<'tcx>, binding_name: Symbol) -> Option<(Ident, &'tcx Expr<'tcx>)> {
+    if_chain! {
+        // only take assignments
+        if let StmtKind::Semi(ref later_expr) = this.kind;
+        if let ExprKind::Assign(ref assign_lhs, ref assign_rhs, _) = later_expr.kind;
+        // only take assignments to fields where the left-hand side field is a field of
+        // the same binding as the previous statement
+        if let ExprKind::Field(ref binding, field_ident) = assign_lhs.kind;
+        if let ExprKind::Path(ref qpath) = binding.kind;
+        if let QPath::Resolved(_, path) = qpath;
+        if let Some(second_binding_name) = path.segments.last();
+        if second_binding_name.ident.name == binding_name;
+        then {
+            Some((field_ident, assign_rhs))
+        } else {
+            None
+        }
+    }
+}
+
+/// Returns the vec of fields for a struct and an empty vec for non-struct ADTs.
+fn fields_of_type(ty: Ty<'_>) -> Vec<Ident> {
+    if let Adt(adt, _) = ty.kind() {
+        if adt.is_struct() {
+            let variant = &adt.non_enum_variant();
+            return variant.fields.iter().map(|f| f.ident).collect();
+        }
+    }
+    vec![]
+}
diff --git a/clippy_lints/src/default_trait_access.rs b/clippy_lints/src/default_trait_access.rs
deleted file mode 100644
index 3048436d9a7..00000000000
--- a/clippy_lints/src/default_trait_access.rs
+++ /dev/null
@@ -1,62 +0,0 @@
-use if_chain::if_chain;
-use rustc_errors::Applicability;
-use rustc_hir::{Expr, ExprKind, QPath};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-
-use crate::utils::{any_parent_is_automatically_derived, match_def_path, paths, span_lint_and_sugg};
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for literal calls to `Default::default()`.
-    ///
-    /// **Why is this bad?** It's more clear to the reader to use the name of the type whose default is
-    /// being gotten than the generic `Default`.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    /// ```rust
-    /// // Bad
-    /// let s: String = Default::default();
-    ///
-    /// // Good
-    /// let s = String::default();
-    /// ```
-    pub DEFAULT_TRAIT_ACCESS,
-    pedantic,
-    "checks for literal calls to `Default::default()`"
-}
-
-declare_lint_pass!(DefaultTraitAccess => [DEFAULT_TRAIT_ACCESS]);
-
-impl<'tcx> LateLintPass<'tcx> for DefaultTraitAccess {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if_chain! {
-            if let ExprKind::Call(ref path, ..) = expr.kind;
-            if !any_parent_is_automatically_derived(cx.tcx, expr.hir_id);
-            if let ExprKind::Path(ref qpath) = path.kind;
-            if let Some(def_id) = cx.qpath_res(qpath, path.hir_id).opt_def_id();
-            if match_def_path(cx, def_id, &paths::DEFAULT_TRAIT_METHOD);
-            // Detect and ignore <Foo as Default>::default() because these calls do explicitly name the type.
-            if let QPath::Resolved(None, _path) = qpath;
-            then {
-                let expr_ty = cx.typeck_results().expr_ty(expr);
-                if let ty::Adt(def, ..) = expr_ty.kind() {
-                    // TODO: Work out a way to put "whatever the imported way of referencing
-                    // this type in this file" rather than a fully-qualified type.
-                    let replacement = format!("{}::default()", cx.tcx.def_path_str(def.did));
-                    span_lint_and_sugg(
-                        cx,
-                        DEFAULT_TRAIT_ACCESS,
-                        expr.span,
-                        &format!("calling `{}` is more clear than this expression", replacement),
-                        "try",
-                        replacement,
-                        Applicability::Unspecified, // First resolve the TODO above
-                    );
-                }
-            }
-        }
-    }
-}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 5c3af014ee1..bb94b3f6cbe 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -176,7 +176,7 @@ mod copies;
 mod copy_iterator;
 mod create_dir;
 mod dbg_macro;
-mod default_trait_access;
+mod default;
 mod dereference;
 mod derive;
 mod disallowed_method;
@@ -537,7 +537,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &copy_iterator::COPY_ITERATOR,
         &create_dir::CREATE_DIR,
         &dbg_macro::DBG_MACRO,
-        &default_trait_access::DEFAULT_TRAIT_ACCESS,
+        &default::DEFAULT_TRAIT_ACCESS,
+        &default::FIELD_REASSIGN_WITH_DEFAULT,
         &dereference::EXPLICIT_DEREF_METHODS,
         &derive::DERIVE_HASH_XOR_EQ,
         &derive::DERIVE_ORD_XOR_PARTIAL_ORD,
@@ -1049,7 +1050,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box neg_cmp_op_on_partial_ord::NoNegCompOpForPartialOrd);
     store.register_late_pass(|| box unwrap::Unwrap);
     store.register_late_pass(|| box duration_subsec::DurationSubsec);
-    store.register_late_pass(|| box default_trait_access::DefaultTraitAccess);
     store.register_late_pass(|| box indexing_slicing::IndexingSlicing);
     store.register_late_pass(|| box non_copy_const::NonCopyConst);
     store.register_late_pass(|| box ptr_offset_with_cast::PtrOffsetWithCast);
@@ -1100,6 +1100,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     let enum_variant_name_threshold = conf.enum_variant_name_threshold;
     store.register_early_pass(move || box enum_variants::EnumVariantNames::new(enum_variant_name_threshold));
     store.register_early_pass(|| box tabs_in_doc_comments::TabsInDocComments);
+    store.register_late_pass(|| box default::Default::default());
     store.register_late_pass(|| box unused_self::UnusedSelf);
     store.register_late_pass(|| box mutable_debug_assertion::DebugAssertWithMutCall);
     store.register_late_pass(|| box exit::Exit);
@@ -1212,7 +1213,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&checked_conversions::CHECKED_CONVERSIONS),
         LintId::of(&copies::SAME_FUNCTIONS_IN_IF_CONDITION),
         LintId::of(&copy_iterator::COPY_ITERATOR),
-        LintId::of(&default_trait_access::DEFAULT_TRAIT_ACCESS),
+        LintId::of(&default::DEFAULT_TRAIT_ACCESS),
         LintId::of(&dereference::EXPLICIT_DEREF_METHODS),
         LintId::of(&derive::EXPL_IMPL_CLONE_ON_COPY),
         LintId::of(&derive::UNSAFE_DERIVE_DESERIALIZE),
@@ -1321,6 +1322,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&comparison_chain::COMPARISON_CHAIN),
         LintId::of(&copies::IFS_SAME_COND),
         LintId::of(&copies::IF_SAME_THEN_ELSE),
+        LintId::of(&default::FIELD_REASSIGN_WITH_DEFAULT),
         LintId::of(&derive::DERIVE_HASH_XOR_EQ),
         LintId::of(&derive::DERIVE_ORD_XOR_PARTIAL_ORD),
         LintId::of(&doc::MISSING_SAFETY_DOC),
@@ -1581,6 +1583,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&blocks_in_if_conditions::BLOCKS_IN_IF_CONDITIONS),
         LintId::of(&collapsible_if::COLLAPSIBLE_IF),
         LintId::of(&comparison_chain::COMPARISON_CHAIN),
+        LintId::of(&default::FIELD_REASSIGN_WITH_DEFAULT),
         LintId::of(&doc::MISSING_SAFETY_DOC),
         LintId::of(&doc::NEEDLESS_DOCTEST_MAIN),
         LintId::of(&enum_variants::ENUM_VARIANT_NAMES),
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index 016bda77ef5..a3645a65182 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -359,7 +359,7 @@ vec![
         group: "pedantic",
         desc: "checks for literal calls to `Default::default()`",
         deprecation: None,
-        module: "default_trait_access",
+        module: "default",
     },
     Lint {
         name: "deprecated_cfg_attr",
@@ -627,6 +627,13 @@ vec![
         deprecation: None,
         module: "fallible_impl_from",
     },
+    Lint {
+        name: "field_reassign_with_default",
+        group: "style",
+        desc: "binding initialized with Default should have its fields set in the initializer",
+        deprecation: None,
+        module: "default",
+    },
     Lint {
         name: "filetype_is_file",
         group: "restriction",
diff --git a/tests/ui/field_reassign_with_default.rs b/tests/ui/field_reassign_with_default.rs
new file mode 100644
index 00000000000..79a30c22f95
--- /dev/null
+++ b/tests/ui/field_reassign_with_default.rs
@@ -0,0 +1,110 @@
+#![warn(clippy::field_reassign_with_default)]
+
+#[derive(Default)]
+struct A {
+    i: i32,
+    j: i64,
+}
+
+struct B {
+    i: i32,
+    j: i64,
+}
+
+/// Implements .next() that returns a different number each time.
+struct SideEffect(i32);
+
+impl SideEffect {
+    fn new() -> SideEffect {
+        SideEffect(0)
+    }
+    fn next(&mut self) -> i32 {
+        self.0 += 1;
+        self.0
+    }
+}
+
+fn main() {
+    // wrong, produces first error in stderr
+    let mut a: A = Default::default();
+    a.i = 42;
+
+    // right
+    let mut a: A = Default::default();
+
+    // right
+    let a = A {
+        i: 42,
+        ..Default::default()
+    };
+
+    // right
+    let mut a: A = Default::default();
+    if a.i == 0 {
+        a.j = 12;
+    }
+
+    // right
+    let mut a: A = Default::default();
+    let b = 5;
+
+    // right
+    let mut b = 32;
+    let mut a: A = Default::default();
+    b = 2;
+
+    // right
+    let b: B = B { i: 42, j: 24 };
+
+    // right
+    let mut b: B = B { i: 42, j: 24 };
+    b.i = 52;
+
+    // right
+    let mut b = B { i: 15, j: 16 };
+    let mut a: A = Default::default();
+    b.i = 2;
+
+    // wrong, produces second error in stderr
+    let mut a: A = Default::default();
+    a.j = 43;
+    a.i = 42;
+
+    // wrong, produces third error in stderr
+    let mut a: A = Default::default();
+    a.i = 42;
+    a.j = 43;
+    a.j = 44;
+
+    // wrong, produces fourth error in stderr
+    let mut a = A::default();
+    a.i = 42;
+
+    // wrong, but does not produce an error in stderr, because we can't produce a correct kind of
+    // suggestion with current implementation
+    let mut c: (i32, i32) = Default::default();
+    c.0 = 42;
+    c.1 = 21;
+
+    // wrong, produces the fifth error in stderr
+    let mut a: A = Default::default();
+    a.i = Default::default();
+
+    // wrong, produces the sixth error in stderr
+    let mut a: A = Default::default();
+    a.i = Default::default();
+    a.j = 45;
+
+    // right, because an assignment refers to another field
+    let mut x = A::default();
+    x.i = 42;
+    x.j = 21 + x.i as i64;
+
+    // right, we bail out if there's a reassignment to the same variable, since there is a risk of
+    // side-effects affecting the outcome
+    let mut x = A::default();
+    let mut side_effect = SideEffect::new();
+    x.i = side_effect.next();
+    x.j = 2;
+    x.i = side_effect.next();
+}
diff --git a/tests/ui/field_reassign_with_default.stderr b/tests/ui/field_reassign_with_default.stderr
new file mode 100644
index 00000000000..c788ebae552
--- /dev/null
+++ b/tests/ui/field_reassign_with_default.stderr
@@ -0,0 +1,75 @@
+error: field assignment outside of initializer for an instance created with Default::default()
+  --> $DIR/field_reassign_with_default.rs:30:5
+   |
+LL |     a.i = 42;
+   |     ^^^^^^^^^
+   |
+   = note: `-D clippy::field-reassign-with-default` implied by `-D warnings`
+note: consider initializing the variable with `A { i: 42, ..Default::default() }` and removing relevant reassignments
+  --> $DIR/field_reassign_with_default.rs:29:5
+   |
+LL |     let mut a: A = Default::default();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: field assignment outside of initializer for an instance created with Default::default()
+  --> $DIR/field_reassign_with_default.rs:70:5
+   |
+LL |     a.j = 43;
+   |     ^^^^^^^^^
+   |
+note: consider initializing the variable with `A { j: 43, i: 42 }` and removing relevant reassignments
+  --> $DIR/field_reassign_with_default.rs:69:5
+   |
+LL |     let mut a: A = Default::default();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: field assignment outside of initializer for an instance created with Default::default()
+  --> $DIR/field_reassign_with_default.rs:75:5
+   |
+LL |     a.i = 42;
+   |     ^^^^^^^^^
+   |
+note: consider initializing the variable with `A { i: 42, j: 44 }` and removing relevant reassignments
+  --> $DIR/field_reassign_with_default.rs:74:5
+   |
+LL |     let mut a: A = Default::default();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: field assignment outside of initializer for an instance created with Default::default()
+  --> $DIR/field_reassign_with_default.rs:81:5
+   |
+LL |     a.i = 42;
+   |     ^^^^^^^^^
+   |
+note: consider initializing the variable with `A { i: 42, ..Default::default() }` and removing relevant reassignments
+  --> $DIR/field_reassign_with_default.rs:80:5
+   |
+LL |     let mut a = A::default();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: field assignment outside of initializer for an instance created with Default::default()
+  --> $DIR/field_reassign_with_default.rs:91:5
+   |
+LL |     a.i = Default::default();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: consider initializing the variable with `A::default()` and removing relevant reassignments
+  --> $DIR/field_reassign_with_default.rs:90:5
+   |
+LL |     let mut a: A = Default::default();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: field assignment outside of initializer for an instance created with Default::default()
+  --> $DIR/field_reassign_with_default.rs:95:5
+   |
+LL |     a.i = Default::default();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: consider initializing the variable with `A { j: 45, ..Default::default() }` and removing relevant reassignments
+  --> $DIR/field_reassign_with_default.rs:94:5
+   |
+LL |     let mut a: A = Default::default();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 6 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 158bf9aa443c5ea93ff4b3def8c7220632e45442 Mon Sep 17 00:00:00 2001
From: ThibsG <Thibs@debian.com>
Date: Sat, 31 Oct 2020 19:56:51 +0100
Subject: Fix incorrect suggestion for macro expansion in `deref_addrof` lint

---
 clippy_lints/src/reference.rs |  8 +++++++-
 tests/ui/deref_addrof.fixed   | 15 ++++++++++++++-
 tests/ui/deref_addrof.rs      | 15 ++++++++++++++-
 tests/ui/deref_addrof.stderr  | 13 ++++++++++++-
 4 files changed, 47 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/reference.rs b/clippy_lints/src/reference.rs
index 3fda00403c6..f1555ab3ec1 100644
--- a/clippy_lints/src/reference.rs
+++ b/clippy_lints/src/reference.rs
@@ -46,13 +46,19 @@ impl EarlyLintPass for DerefAddrOf {
             if !in_macro(addrof_target.span);
             then {
                 let mut applicability = Applicability::MachineApplicable;
+                let sugg = if e.span.from_expansion() {
+                    let snip = snippet_with_applicability(cx, e.span, "_", &mut applicability);
+                    snip.trim_start_matches(|c| c == '&' || c == '*').to_string()
+                } else {
+                    snippet_with_applicability(cx, addrof_target.span, "_", &mut applicability).to_string()
+                };
                 span_lint_and_sugg(
                     cx,
                     DEREF_ADDROF,
                     e.span,
                     "immediately dereferencing a reference",
                     "try this",
-                    format!("{}", snippet_with_applicability(cx, addrof_target.span, "_", &mut applicability)),
+                    sugg,
                     applicability,
                 );
             }
diff --git a/tests/ui/deref_addrof.fixed b/tests/ui/deref_addrof.fixed
index 9e5b51d6d5e..8cdec4201fe 100644
--- a/tests/ui/deref_addrof.fixed
+++ b/tests/ui/deref_addrof.fixed
@@ -1,4 +1,5 @@
 // run-rustfix
+#![warn(clippy::deref_addrof)]
 
 fn get_number() -> usize {
     10
@@ -10,7 +11,6 @@ fn get_reference(n: &usize) -> &usize {
 
 #[allow(clippy::many_single_char_names, clippy::double_parens)]
 #[allow(unused_variables, unused_parens)]
-#[warn(clippy::deref_addrof)]
 fn main() {
     let a = 10;
     let aref = &a;
@@ -37,3 +37,16 @@ fn main() {
 
     let b = *aref;
 }
+
+macro_rules! m {
+    ($visitor: expr) => {
+        $visitor
+    };
+}
+
+pub struct S;
+impl S {
+    pub fn f(&self) -> &Self {
+        m!(self)
+    }
+}
diff --git a/tests/ui/deref_addrof.rs b/tests/ui/deref_addrof.rs
index 5641a73cbc1..6433e63ca59 100644
--- a/tests/ui/deref_addrof.rs
+++ b/tests/ui/deref_addrof.rs
@@ -1,4 +1,5 @@
 // run-rustfix
+#![warn(clippy::deref_addrof)]
 
 fn get_number() -> usize {
     10
@@ -10,7 +11,6 @@ fn get_reference(n: &usize) -> &usize {
 
 #[allow(clippy::many_single_char_names, clippy::double_parens)]
 #[allow(unused_variables, unused_parens)]
-#[warn(clippy::deref_addrof)]
 fn main() {
     let a = 10;
     let aref = &a;
@@ -37,3 +37,16 @@ fn main() {
 
     let b = **&aref;
 }
+
+macro_rules! m {
+    ($visitor: expr) => {
+        *&$visitor
+    };
+}
+
+pub struct S;
+impl S {
+    pub fn f(&self) -> &Self {
+        m!(self)
+    }
+}
diff --git a/tests/ui/deref_addrof.stderr b/tests/ui/deref_addrof.stderr
index bc51719e8a7..1fe49ad49cd 100644
--- a/tests/ui/deref_addrof.stderr
+++ b/tests/ui/deref_addrof.stderr
@@ -48,5 +48,16 @@ error: immediately dereferencing a reference
 LL |     let b = **&aref;
    |              ^^^^^^ help: try this: `aref`
 
-error: aborting due to 8 previous errors
+error: immediately dereferencing a reference
+  --> $DIR/deref_addrof.rs:43:9
+   |
+LL |         *&$visitor
+   |         ^^^^^^^^^^ help: try this: `$visitor`
+...
+LL |         m!(self)
+   |         -------- in this macro invocation
+   |
+   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: aborting due to 9 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 343bdb33647627a6a001be039a107e7ef3362707 Mon Sep 17 00:00:00 2001
From: ThibsG <Thibs@debian.com>
Date: Mon, 2 Nov 2020 17:56:54 +0100
Subject: Give better suggestion by working on span on `deref_addrof` lint

---
 clippy_lints/src/reference.rs | 36 +++++++++++++++++++++++++++++++-----
 tests/ui/deref_addrof.fixed   | 10 ++++++++++
 tests/ui/deref_addrof.rs      | 12 +++++++++++-
 tests/ui/deref_addrof.stderr  | 17 ++++++++++++++---
 4 files changed, 66 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/reference.rs b/clippy_lints/src/reference.rs
index f1555ab3ec1..8646d616735 100644
--- a/clippy_lints/src/reference.rs
+++ b/clippy_lints/src/reference.rs
@@ -1,9 +1,11 @@
-use crate::utils::{in_macro, snippet_with_applicability, span_lint_and_sugg};
+use crate::utils::{in_macro, snippet_opt, snippet_with_applicability, span_lint_and_sugg};
 use if_chain::if_chain;
-use rustc_ast::ast::{Expr, ExprKind, UnOp};
+use rustc_ast::ast::{Expr, ExprKind, UnOp, Mutability};
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::BytePos;
+// use rustc_span::source_map::{BytePos, Span};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for usage of `*&` and `*&mut` in expressions.
@@ -42,13 +44,37 @@ impl EarlyLintPass for DerefAddrOf {
     fn check_expr(&mut self, cx: &EarlyContext<'_>, e: &Expr) {
         if_chain! {
             if let ExprKind::Unary(UnOp::Deref, ref deref_target) = e.kind;
-            if let ExprKind::AddrOf(_, _, ref addrof_target) = without_parens(deref_target).kind;
+            if let ExprKind::AddrOf(_, ref mutability, ref addrof_target) = without_parens(deref_target).kind;
             if !in_macro(addrof_target.span);
             then {
                 let mut applicability = Applicability::MachineApplicable;
                 let sugg = if e.span.from_expansion() {
-                    let snip = snippet_with_applicability(cx, e.span, "_", &mut applicability);
-                    snip.trim_start_matches(|c| c == '&' || c == '*').to_string()
+                    if let Ok(macro_source) = cx.sess.source_map().span_to_snippet(e.span) {
+                        // Remove leading whitespace from the given span
+                        // e.g: ` $visitor` turns into `$visitor`
+                        let trim_leading_whitespaces = |span| {
+                            if let Some(start_no_whitespace) = snippet_opt(cx, span).and_then(|snip| {
+                                snip.find(|c: char| !c.is_whitespace()).map(|pos| {
+                                    span.lo() + BytePos(pos as u32)
+                                })
+                            }) {
+                                e.span.with_lo(start_no_whitespace)
+                            } else {
+                                span
+                            }
+                        };
+
+                        let rpos = if *mutability == Mutability::Mut {
+                            macro_source.rfind("mut").expect("already checked this is a mutable reference") + "mut".len()
+                        } else {
+                            macro_source.rfind("&").expect("already checked this is a reference") + "&".len()
+                        };
+                        let span_after_ref = e.span.with_lo(BytePos(e.span.lo().0 + rpos as u32));
+                        let span = trim_leading_whitespaces(span_after_ref);
+                        snippet_with_applicability(cx, span, "_", &mut applicability).to_string()
+                    } else {
+                        snippet_with_applicability(cx, e.span, "_", &mut applicability).to_string()
+                    }
                 } else {
                     snippet_with_applicability(cx, addrof_target.span, "_", &mut applicability).to_string()
                 };
diff --git a/tests/ui/deref_addrof.fixed b/tests/ui/deref_addrof.fixed
index 8cdec4201fe..689e9d55223 100644
--- a/tests/ui/deref_addrof.fixed
+++ b/tests/ui/deref_addrof.fixed
@@ -44,9 +44,19 @@ macro_rules! m {
     };
 }
 
+#[rustfmt::skip]
+macro_rules! m_mut {
+    ($visitor: expr) => {
+        $visitor
+    };
+}
+
 pub struct S;
 impl S {
     pub fn f(&self) -> &Self {
         m!(self)
     }
+    pub fn f_mut(&self) -> &Self {
+        m_mut!(self)
+    }
 }
diff --git a/tests/ui/deref_addrof.rs b/tests/ui/deref_addrof.rs
index 6433e63ca59..57effce5d12 100644
--- a/tests/ui/deref_addrof.rs
+++ b/tests/ui/deref_addrof.rs
@@ -40,7 +40,14 @@ fn main() {
 
 macro_rules! m {
     ($visitor: expr) => {
-        *&$visitor
+        *& $visitor
+    };
+}
+
+#[rustfmt::skip]
+macro_rules! m_mut {
+    ($visitor: expr) => {
+        *& mut $visitor
     };
 }
 
@@ -49,4 +56,7 @@ impl S {
     pub fn f(&self) -> &Self {
         m!(self)
     }
+    pub fn f_mut(&self) -> &Self {
+        m_mut!(self)
+    }
 }
diff --git a/tests/ui/deref_addrof.stderr b/tests/ui/deref_addrof.stderr
index 1fe49ad49cd..52c1f7d1da8 100644
--- a/tests/ui/deref_addrof.stderr
+++ b/tests/ui/deref_addrof.stderr
@@ -51,13 +51,24 @@ LL |     let b = **&aref;
 error: immediately dereferencing a reference
   --> $DIR/deref_addrof.rs:43:9
    |
-LL |         *&$visitor
-   |         ^^^^^^^^^^ help: try this: `$visitor`
+LL |         *& $visitor
+   |         ^^^^^^^^^^^ help: try this: `$visitor`
 ...
 LL |         m!(self)
    |         -------- in this macro invocation
    |
    = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to 9 previous errors
+error: immediately dereferencing a reference
+  --> $DIR/deref_addrof.rs:50:9
+   |
+LL |         *& mut $visitor
+   |         ^^^^^^^^^^^^^^^ help: try this: `$visitor`
+...
+LL |         m_mut!(self)
+   |         ------------ in this macro invocation
+   |
+   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: aborting due to 10 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From ce98468158318a47f6bab3707d348e116451ad39 Mon Sep 17 00:00:00 2001
From: ThibsG <Thibs@debian.com>
Date: Mon, 2 Nov 2020 17:59:47 +0100
Subject: Fix incorrect suggestion when from expansion in `try_err` lint

---
 clippy_lints/src/try_err.rs | 10 ++++++++--
 tests/ui/try_err.fixed      | 16 ++++++++++++++++
 tests/ui/try_err.rs         | 16 ++++++++++++++++
 tests/ui/try_err.stderr     | 21 ++++++++++++++++-----
 4 files changed, 56 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/try_err.rs b/clippy_lints/src/try_err.rs
index 3e747ec4ad9..e6d8e7521a8 100644
--- a/clippy_lints/src/try_err.rs
+++ b/clippy_lints/src/try_err.rs
@@ -1,5 +1,5 @@
 use crate::utils::{
-    is_type_diagnostic_item, match_def_path, match_qpath, paths, snippet, snippet_with_macro_callsite,
+    in_macro, is_type_diagnostic_item, match_def_path, match_qpath, paths, snippet, snippet_with_macro_callsite,
     span_lint_and_sugg,
 };
 use if_chain::if_chain;
@@ -92,9 +92,13 @@ impl<'tcx> LateLintPass<'tcx> for TryErr {
 
                 let expr_err_ty = cx.typeck_results().expr_ty(err_arg);
 
-                let origin_snippet = if err_arg.span.from_expansion() {
+                // println!("\n\n{:?}", in_macro(expr.span));
+                // println!("{:#?}", snippet(cx, err_arg.span, "_"));
+                let origin_snippet = if err_arg.span.from_expansion() && !in_macro(expr.span) {
+                    // println!("from expansion");
                     snippet_with_macro_callsite(cx, err_arg.span, "_")
                 } else {
+                    // println!("just a snippet");
                     snippet(cx, err_arg.span, "_")
                 };
                 let suggestion = if err_ty == expr_err_ty {
@@ -102,6 +106,8 @@ impl<'tcx> LateLintPass<'tcx> for TryErr {
                 } else {
                     format!("return {}{}.into(){}", prefix, origin_snippet, suffix)
                 };
+                // println!("origin_snippet: {:#?}", origin_snippet);
+                // println!("suggestion: {:#?}", suggestion);
 
                 span_lint_and_sugg(
                     cx,
diff --git a/tests/ui/try_err.fixed b/tests/ui/try_err.fixed
index 9e77dcd8731..053dd45f23e 100644
--- a/tests/ui/try_err.fixed
+++ b/tests/ui/try_err.fixed
@@ -78,12 +78,28 @@ fn nested_error() -> Result<i32, i32> {
     Ok(1)
 }
 
+// Bad suggestion when in macro (see #6242)
+macro_rules! try_validation {
+    ($e: expr) => {{
+        match $e {
+            Ok(_) => 0,
+            Err(_) => return Err(1),
+        }
+    }};
+}
+
+fn calling_macro() -> Result<i32, i32> {
+    try_validation!(Ok::<_, i32>(5));
+    Ok(5)
+}
+
 fn main() {
     basic_test().unwrap();
     into_test().unwrap();
     negative_test().unwrap();
     closure_matches_test().unwrap();
     closure_into_test().unwrap();
+    calling_macro().unwrap();
 
     // We don't want to lint in external macros
     try_err!();
diff --git a/tests/ui/try_err.rs b/tests/ui/try_err.rs
index 41bcb0a189e..215ca6a07e6 100644
--- a/tests/ui/try_err.rs
+++ b/tests/ui/try_err.rs
@@ -78,12 +78,28 @@ fn nested_error() -> Result<i32, i32> {
     Ok(1)
 }
 
+// Bad suggestion when in macro (see #6242)
+macro_rules! try_validation {
+    ($e: expr) => {{
+        match $e {
+            Ok(_) => 0,
+            Err(_) => Err(1)?,
+        }
+    }};
+}
+
+fn calling_macro() -> Result<i32, i32> {
+    try_validation!(Ok::<_, i32>(5));
+    Ok(5)
+}
+
 fn main() {
     basic_test().unwrap();
     into_test().unwrap();
     negative_test().unwrap();
     closure_matches_test().unwrap();
     closure_into_test().unwrap();
+    calling_macro().unwrap();
 
     // We don't want to lint in external macros
     try_err!();
diff --git a/tests/ui/try_err.stderr b/tests/ui/try_err.stderr
index 3f1cbc17e72..443c8d08472 100644
--- a/tests/ui/try_err.stderr
+++ b/tests/ui/try_err.stderr
@@ -29,28 +29,39 @@ LL |                 Err(err)?;
    |                 ^^^^^^^^^ help: try this: `return Err(err.into())`
 
 error: returning an `Err(_)` with the `?` operator
-  --> $DIR/try_err.rs:106:9
+  --> $DIR/try_err.rs:86:23
+   |
+LL |             Err(_) => Err(1)?,
+   |                       ^^^^^^^ help: try this: `return Err(1)`
+...
+LL |     try_validation!(Ok::<_, i32>(5));
+   |     --------------------------------- in this macro invocation
+   |
+   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: returning an `Err(_)` with the `?` operator
+  --> $DIR/try_err.rs:122:9
    |
 LL |         Err(foo!())?;
    |         ^^^^^^^^^^^^ help: try this: `return Err(foo!())`
 
 error: returning an `Err(_)` with the `?` operator
-  --> $DIR/try_err.rs:113:9
+  --> $DIR/try_err.rs:129:9
    |
 LL |         Err(io::ErrorKind::WriteZero)?
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `return Poll::Ready(Err(io::ErrorKind::WriteZero.into()))`
 
 error: returning an `Err(_)` with the `?` operator
-  --> $DIR/try_err.rs:115:9
+  --> $DIR/try_err.rs:131:9
    |
 LL |         Err(io::Error::new(io::ErrorKind::InvalidInput, "error"))?
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `return Poll::Ready(Err(io::Error::new(io::ErrorKind::InvalidInput, "error")))`
 
 error: returning an `Err(_)` with the `?` operator
-  --> $DIR/try_err.rs:123:9
+  --> $DIR/try_err.rs:139:9
    |
 LL |         Err(io::ErrorKind::NotFound)?
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `return Poll::Ready(Some(Err(io::ErrorKind::NotFound.into())))`
 
-error: aborting due to 8 previous errors
+error: aborting due to 9 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 22cc77a232a0ec73475ff54b5116adf9defc8667 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Mon, 2 Nov 2020 10:32:55 -0600
Subject: Use const rustc sym where possible

---
 clippy_lints/src/attrs.rs                         | 22 ++++-----
 clippy_lints/src/booleans.rs                      |  5 +-
 clippy_lints/src/bytecount.rs                     |  3 +-
 clippy_lints/src/cognitive_complexity.rs          |  6 +--
 clippy_lints/src/doc.rs                           | 10 ++--
 clippy_lints/src/explicit_write.rs                |  3 +-
 clippy_lints/src/fallible_impl_from.rs            |  8 ++--
 clippy_lints/src/format.rs                        | 13 +++---
 clippy_lints/src/functions.rs                     |  3 +-
 clippy_lints/src/get_last_with_len.rs             |  3 +-
 clippy_lints/src/if_let_some_result.rs            |  3 +-
 clippy_lints/src/inherent_to_string.rs            |  3 +-
 clippy_lints/src/inline_fn_without_body.rs        |  4 +-
 clippy_lints/src/loops.rs                         | 22 ++++-----
 clippy_lints/src/manual_non_exhaustive.rs         | 10 ++--
 clippy_lints/src/manual_unwrap_or.rs              |  5 +-
 clippy_lints/src/map_clone.rs                     |  4 +-
 clippy_lints/src/map_identity.rs                  |  5 +-
 clippy_lints/src/map_unit_fn.rs                   |  5 +-
 clippy_lints/src/match_on_vec_items.rs            |  3 +-
 clippy_lints/src/matches.rs                       |  9 ++--
 clippy_lints/src/methods/inefficient_to_string.rs |  3 +-
 clippy_lints/src/methods/mod.rs                   | 56 +++++++++++------------
 clippy_lints/src/methods/option_map_unwrap_or.rs  |  4 +-
 clippy_lints/src/methods/unnecessary_lazy_eval.rs |  5 +-
 clippy_lints/src/missing_doc.rs                   |  7 +--
 clippy_lints/src/missing_inline.rs                |  3 +-
 clippy_lints/src/needless_borrow.rs               |  3 +-
 clippy_lints/src/needless_pass_by_value.rs        | 10 ++--
 clippy_lints/src/new_without_default.rs           |  3 +-
 clippy_lints/src/non_expressive_names.rs          |  3 +-
 clippy_lints/src/option_if_let_else.rs            |  3 +-
 clippy_lints/src/panic_in_result_fn.rs            |  4 +-
 clippy_lints/src/partialeq_ne_impl.rs             |  3 +-
 clippy_lints/src/pass_by_ref_or_value.rs          |  6 +--
 clippy_lints/src/ptr.rs                           |  6 +--
 clippy_lints/src/ptr_offset_with_cast.rs          |  3 +-
 clippy_lints/src/question_mark.rs                 |  3 +-
 clippy_lints/src/ranges.rs                        |  3 +-
 clippy_lints/src/redundant_clone.rs               |  3 +-
 clippy_lints/src/repeat_once.rs                   |  3 +-
 clippy_lints/src/returns.rs                       |  3 +-
 clippy_lints/src/strings.rs                       |  3 +-
 clippy_lints/src/swap.rs                          |  3 +-
 clippy_lints/src/try_err.rs                       |  9 ++--
 clippy_lints/src/types.rs                         | 10 ++--
 clippy_lints/src/unnecessary_sort_by.rs           |  3 +-
 clippy_lints/src/unwrap.rs                        |  9 ++--
 clippy_lints/src/unwrap_in_result.rs              | 14 +++---
 clippy_lints/src/useless_conversion.rs            |  5 +-
 clippy_lints/src/utils/mod.rs                     |  3 +-
 clippy_lints/src/write.rs                         |  5 +-
 52 files changed, 192 insertions(+), 158 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs
index f6eadbdef0b..a004abb58b8 100644
--- a/clippy_lints/src/attrs.rs
+++ b/clippy_lints/src/attrs.rs
@@ -16,6 +16,7 @@ use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
+use rustc_span::sym;
 use rustc_span::symbol::{Symbol, SymbolStr};
 use semver::Version;
 
@@ -286,14 +287,14 @@ impl<'tcx> LateLintPass<'tcx> for Attributes {
                     },
                     _ => {},
                 }
-                if items.is_empty() || !attr.has_name(sym!(deprecated)) {
+                if items.is_empty() || !attr.has_name(sym::deprecated) {
                     return;
                 }
                 for item in items {
                     if_chain! {
                         if let NestedMetaItem::MetaItem(mi) = &item;
                         if let MetaItemKind::NameValue(lit) = &mi.kind;
-                        if mi.has_name(sym!(since));
+                        if mi.has_name(sym::since);
                         then {
                             check_semver(cx, item.span(), lit);
                         }
@@ -309,7 +310,7 @@ impl<'tcx> LateLintPass<'tcx> for Attributes {
         }
         match item.kind {
             ItemKind::ExternCrate(..) | ItemKind::Use(..) => {
-                let skip_unused_imports = item.attrs.iter().any(|attr| attr.has_name(sym!(macro_use)));
+                let skip_unused_imports = item.attrs.iter().any(|attr| attr.has_name(sym::macro_use));
 
                 for attr in item.attrs {
                     if in_external_macro(cx.sess(), attr.span) {
@@ -326,7 +327,7 @@ impl<'tcx> LateLintPass<'tcx> for Attributes {
                                         match item.kind {
                                             ItemKind::Use(..) => {
                                                 if is_word(lint, sym!(unused_imports))
-                                                    || is_word(lint, sym!(deprecated))
+                                                    || is_word(lint, sym::deprecated)
                                                     || is_word(lint, sym!(unreachable_pub))
                                                     || is_word(lint, sym!(unused))
                                                     || extract_clippy_lint(lint)
@@ -411,8 +412,7 @@ fn check_clippy_lint_names(cx: &LateContext<'_>, ident: &str, items: &[NestedMet
     let lint_store = cx.lints();
     for lint in items {
         if let Some(lint_name) = extract_clippy_lint(lint) {
-            if let CheckLintNameResult::Tool(Err((None, _))) =
-                lint_store.check_lint_name(&lint_name, Some(sym!(clippy)))
+            if let CheckLintNameResult::Tool(Err((None, _))) = lint_store.check_lint_name(&lint_name, Some(sym::clippy))
             {
                 span_lint_and_then(
                     cx,
@@ -529,10 +529,10 @@ fn check_attrs(cx: &LateContext<'_>, span: Span, name: Symbol, attrs: &[Attribut
 
     for attr in attrs {
         if let Some(values) = attr.meta_item_list() {
-            if values.len() != 1 || !attr.has_name(sym!(inline)) {
+            if values.len() != 1 || !attr.has_name(sym::inline) {
                 continue;
             }
-            if is_word(&values[0], sym!(always)) {
+            if is_word(&values[0], sym::always) {
                 span_lint(
                     cx,
                     INLINE_ALWAYS,
@@ -623,12 +623,12 @@ fn check_empty_line_after_outer_attr(cx: &EarlyContext<'_>, item: &rustc_ast::It
 fn check_deprecated_cfg_attr(cx: &EarlyContext<'_>, attr: &Attribute) {
     if_chain! {
         // check cfg_attr
-        if attr.has_name(sym!(cfg_attr));
+        if attr.has_name(sym::cfg_attr);
         if let Some(items) = attr.meta_item_list();
         if items.len() == 2;
         // check for `rustfmt`
         if let Some(feature_item) = items[0].meta_item();
-        if feature_item.has_name(sym!(rustfmt));
+        if feature_item.has_name(sym::rustfmt);
         // check for `rustfmt_skip` and `rustfmt::skip`
         if let Some(skip_item) = &items[1].meta_item();
         if skip_item.has_name(sym!(rustfmt_skip)) ||
@@ -690,7 +690,7 @@ fn check_mismatched_target_os(cx: &EarlyContext<'_>, attr: &Attribute) {
     }
 
     if_chain! {
-        if attr.has_name(sym!(cfg));
+        if attr.has_name(sym::cfg);
         if let Some(list) = attr.meta_item_list();
         let mismatched = find_mismatched_target_os(&list);
         if !mismatched.is_empty();
diff --git a/clippy_lints/src/booleans.rs b/clippy_lints/src/booleans.rs
index 280a2c7fe67..90bb0bd555f 100644
--- a/clippy_lints/src/booleans.rs
+++ b/clippy_lints/src/booleans.rs
@@ -11,6 +11,7 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::map::Map;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
+use rustc_span::sym;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for boolean expressions that can be written more
@@ -253,8 +254,8 @@ fn simplify_not(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<String> {
         },
         ExprKind::MethodCall(path, _, args, _) if args.len() == 1 => {
             let type_of_receiver = cx.typeck_results().expr_ty(&args[0]);
-            if !is_type_diagnostic_item(cx, type_of_receiver, sym!(option_type))
-                && !is_type_diagnostic_item(cx, type_of_receiver, sym!(result_type))
+            if !is_type_diagnostic_item(cx, type_of_receiver, sym::option_type)
+                && !is_type_diagnostic_item(cx, type_of_receiver, sym::result_type)
             {
                 return None;
             }
diff --git a/clippy_lints/src/bytecount.rs b/clippy_lints/src/bytecount.rs
index d7d02ebf985..38a0e27c4cf 100644
--- a/clippy_lints/src/bytecount.rs
+++ b/clippy_lints/src/bytecount.rs
@@ -8,6 +8,7 @@ use rustc_hir::{BinOpKind, BorrowKind, Expr, ExprKind, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::sym;
 use rustc_span::Symbol;
 
 declare_clippy_lint! {
@@ -68,7 +69,7 @@ impl<'tcx> LateLintPass<'tcx> for ByteCount {
                         let haystack = if let ExprKind::MethodCall(ref path, _, ref args, _) =
                                 filter_args[0].kind {
                             let p = path.ident.name;
-                            if (p == sym!(iter) || p == sym!(iter_mut)) && args.len() == 1 {
+                            if (p == sym::iter || p == sym!(iter_mut)) && args.len() == 1 {
                                 &args[0]
                             } else {
                                 &filter_args[0]
diff --git a/clippy_lints/src/cognitive_complexity.rs b/clippy_lints/src/cognitive_complexity.rs
index 14ef8c319ef..b1bc2ec29e1 100644
--- a/clippy_lints/src/cognitive_complexity.rs
+++ b/clippy_lints/src/cognitive_complexity.rs
@@ -7,7 +7,7 @@ use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::hir::map::Map;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::Span;
-use rustc_span::BytePos;
+use rustc_span::{sym, BytePos};
 
 use crate::utils::{is_type_diagnostic_item, snippet_opt, span_lint_and_help, LimitStack};
 
@@ -61,7 +61,7 @@ impl CognitiveComplexity {
         helper.visit_expr(expr);
         let CCHelper { cc, returns } = helper;
         let ret_ty = cx.typeck_results().node_type(expr.hir_id);
-        let ret_adjust = if is_type_diagnostic_item(cx, ret_ty, sym!(result_type)) {
+        let ret_adjust = if is_type_diagnostic_item(cx, ret_ty, sym::result_type) {
             returns
         } else {
             #[allow(clippy::integer_division)]
@@ -123,7 +123,7 @@ impl<'tcx> LateLintPass<'tcx> for CognitiveComplexity {
         hir_id: HirId,
     ) {
         let def_id = cx.tcx.hir().local_def_id(hir_id);
-        if !cx.tcx.has_attr(def_id.to_def_id(), sym!(test)) {
+        if !cx.tcx.has_attr(def_id.to_def_id(), sym::test) {
             self.check(cx, kind, decl, body, span);
         }
     }
diff --git a/clippy_lints/src/doc.rs b/clippy_lints/src/doc.rs
index 07f604cf714..edecba57e44 100644
--- a/clippy_lints/src/doc.rs
+++ b/clippy_lints/src/doc.rs
@@ -15,7 +15,7 @@ use rustc_parse::maybe_new_parser_from_source_str;
 use rustc_session::parse::ParseSess;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::{BytePos, FilePathMapping, MultiSpan, SourceMap, Span};
-use rustc_span::{FileName, Pos};
+use rustc_span::{sym, FileName, Pos};
 use std::io;
 use std::ops::Range;
 use url::Url;
@@ -237,7 +237,7 @@ fn lint_for_missing_headers<'tcx>(
         );
     }
     if !headers.errors {
-        if is_type_diagnostic_item(cx, return_ty(cx, hir_id), sym!(result_type)) {
+        if is_type_diagnostic_item(cx, return_ty(cx, hir_id), sym::result_type) {
             span_lint(
                 cx,
                 MISSING_ERRORS_DOC,
@@ -255,7 +255,7 @@ fn lint_for_missing_headers<'tcx>(
                 if let ty::Opaque(_, subs) = ret_ty.kind();
                 if let Some(gen) = subs.types().next();
                 if let ty::Generator(_, subs, _) = gen.kind();
-                if is_type_diagnostic_item(cx, subs.as_generator().return_ty(), sym!(result_type));
+                if is_type_diagnostic_item(cx, subs.as_generator().return_ty(), sym::result_type);
                 then {
                     span_lint(
                         cx,
@@ -333,7 +333,7 @@ fn check_attrs<'a>(cx: &LateContext<'_>, valid_idents: &FxHashSet<String>, attrs
             let (comment, current_spans) = strip_doc_comment_decoration(&comment.as_str(), comment_kind, attr.span);
             spans.extend_from_slice(&current_spans);
             doc.push_str(&comment);
-        } else if attr.has_name(sym!(doc)) {
+        } else if attr.has_name(sym::doc) {
             // ignore mix of sugared and non-sugared doc
             // don't trigger the safety or errors check
             return DocHeaders {
@@ -479,7 +479,7 @@ fn check_code(cx: &LateContext<'_>, text: &str, span: Span) {
                     | ItemKind::ExternCrate(..)
                     | ItemKind::ForeignMod(..) => return false,
                     // We found a main function ...
-                    ItemKind::Fn(_, sig, _, Some(block)) if item.ident.name == sym!(main) => {
+                    ItemKind::Fn(_, sig, _, Some(block)) if item.ident.name == sym::main => {
                         let is_async = matches!(sig.header.asyncness, Async::Yes{..});
                         let returns_nothing = match &sig.decl.output {
                             FnRetTy::Default(..) => true,
diff --git a/clippy_lints/src/explicit_write.rs b/clippy_lints/src/explicit_write.rs
index 0240e80d814..f8038d06e50 100644
--- a/clippy_lints/src/explicit_write.rs
+++ b/clippy_lints/src/explicit_write.rs
@@ -5,6 +5,7 @@ use rustc_errors::Applicability;
 use rustc_hir::{BorrowKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::sym;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for usage of `write!()` / `writeln()!` which can be
@@ -33,7 +34,7 @@ impl<'tcx> LateLintPass<'tcx> for ExplicitWrite {
         if_chain! {
             // match call to unwrap
             if let ExprKind::MethodCall(ref unwrap_fun, _, ref unwrap_args, _) = expr.kind;
-            if unwrap_fun.ident.name == sym!(unwrap);
+            if unwrap_fun.ident.name == sym::unwrap;
             // match call to write_fmt
             if !unwrap_args.is_empty();
             if let ExprKind::MethodCall(ref write_fun, _, write_args, _) =
diff --git a/clippy_lints/src/fallible_impl_from.rs b/clippy_lints/src/fallible_impl_from.rs
index a9e05fddbe7..fe817fe94f2 100644
--- a/clippy_lints/src/fallible_impl_from.rs
+++ b/clippy_lints/src/fallible_impl_from.rs
@@ -6,7 +6,7 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::map::Map;
 use rustc_middle::ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::Span;
+use rustc_span::{sym, Span};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for impls of `From<..>` that contain `panic!()` or `unwrap()`
@@ -95,8 +95,8 @@ fn lint_impl_body<'tcx>(cx: &LateContext<'tcx>, impl_span: Span, impl_items: &[h
             // check for `unwrap`
             if let Some(arglists) = method_chain_args(expr, &["unwrap"]) {
                 let reciever_ty = self.typeck_results.expr_ty(&arglists[0][0]).peel_refs();
-                if is_type_diagnostic_item(self.lcx, reciever_ty, sym!(option_type))
-                    || is_type_diagnostic_item(self.lcx, reciever_ty, sym!(result_type))
+                if is_type_diagnostic_item(self.lcx, reciever_ty, sym::option_type)
+                    || is_type_diagnostic_item(self.lcx, reciever_ty, sym::result_type)
                 {
                     self.result.push(expr.span);
                 }
@@ -113,7 +113,7 @@ fn lint_impl_body<'tcx>(cx: &LateContext<'tcx>, impl_span: Span, impl_items: &[h
 
     for impl_item in impl_items {
         if_chain! {
-            if impl_item.ident.name == sym!(from);
+            if impl_item.ident.name == sym::from;
             if let ImplItemKind::Fn(_, body_id) =
                 cx.tcx.hir().impl_item(impl_item.id).kind;
             then {
diff --git a/clippy_lints/src/format.rs b/clippy_lints/src/format.rs
index 26da058598e..8e41e0e34da 100644
--- a/clippy_lints/src/format.rs
+++ b/clippy_lints/src/format.rs
@@ -10,6 +10,7 @@ use rustc_hir::{Arm, BorrowKind, Expr, ExprKind, MatchSource, PatKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
+use rustc_span::sym;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for the use of `format!("string literal with no
@@ -91,7 +92,7 @@ fn on_argumentv1_new<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, arms: &
         if pats.len() == 1;
         then {
             let ty = cx.typeck_results().pat_ty(&pats[0]).peel_refs();
-            if *ty.kind() != rustc_middle::ty::Str && !is_type_diagnostic_item(cx, ty, sym!(string_type)) {
+            if *ty.kind() != rustc_middle::ty::Str && !is_type_diagnostic_item(cx, ty, sym::string_type) {
                 return None;
             }
             if let ExprKind::Lit(ref lit) = format_args.kind {
@@ -186,15 +187,15 @@ fn check_unformatted(expr: &Expr<'_>) -> bool {
         if exprs.len() == 1;
         // struct `core::fmt::rt::v1::Argument`
         if let ExprKind::Struct(_, ref fields, _) = exprs[0].kind;
-        if let Some(format_field) = fields.iter().find(|f| f.ident.name == sym!(format));
+        if let Some(format_field) = fields.iter().find(|f| f.ident.name == sym::format);
         // struct `core::fmt::rt::v1::FormatSpec`
         if let ExprKind::Struct(_, ref fields, _) = format_field.expr.kind;
-        if let Some(precision_field) = fields.iter().find(|f| f.ident.name == sym!(precision));
+        if let Some(precision_field) = fields.iter().find(|f| f.ident.name == sym::precision);
         if let ExprKind::Path(ref precision_path) = precision_field.expr.kind;
-        if last_path_segment(precision_path).ident.name == sym!(Implied);
-        if let Some(width_field) = fields.iter().find(|f| f.ident.name == sym!(width));
+        if last_path_segment(precision_path).ident.name == sym::Implied;
+        if let Some(width_field) = fields.iter().find(|f| f.ident.name == sym::width);
         if let ExprKind::Path(ref width_qpath) = width_field.expr.kind;
-        if last_path_segment(width_qpath).ident.name == sym!(Implied);
+        if last_path_segment(width_qpath).ident.name == sym::Implied;
         then {
             return true;
         }
diff --git a/clippy_lints/src/functions.rs b/clippy_lints/src/functions.rs
index 9c0efef95de..8b58d1f2601 100644
--- a/clippy_lints/src/functions.rs
+++ b/clippy_lints/src/functions.rs
@@ -16,6 +16,7 @@ use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::{self, Ty};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::Span;
+use rustc_span::sym;
 use rustc_target::spec::abi::Abi;
 use rustc_typeck::hir_ty_to_ty;
 
@@ -473,7 +474,7 @@ fn check_result_unit_err(cx: &LateContext<'_>, decl: &hir::FnDecl<'_>, item_span
         if !in_external_macro(cx.sess(), item_span);
         if let hir::FnRetTy::Return(ref ty) = decl.output;
         if let hir::TyKind::Path(ref qpath) = ty.kind;
-        if is_type_diagnostic_item(cx, hir_ty_to_ty(cx.tcx, ty), sym!(result_type));
+        if is_type_diagnostic_item(cx, hir_ty_to_ty(cx.tcx, ty), sym::result_type);
         if let Some(ref args) = last_path_segment(qpath).args;
         if let [_, hir::GenericArg::Type(ref err_ty)] = args.args;
         if let hir::TyKind::Tup(t) = err_ty.kind;
diff --git a/clippy_lints/src/get_last_with_len.rs b/clippy_lints/src/get_last_with_len.rs
index 48ebcf5ebcd..cdd8a42e7cd 100644
--- a/clippy_lints/src/get_last_with_len.rs
+++ b/clippy_lints/src/get_last_with_len.rs
@@ -8,6 +8,7 @@ use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Spanned;
+use rustc_span::sym;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for using `x.get(x.len() - 1)` instead of
@@ -55,7 +56,7 @@ impl<'tcx> LateLintPass<'tcx> for GetLastWithLen {
             // Argument 0 (the struct we're calling the method on) is a vector
             if let Some(struct_calling_on) = args.get(0);
             let struct_ty = cx.typeck_results().expr_ty(struct_calling_on);
-            if is_type_diagnostic_item(cx, struct_ty, sym!(vec_type));
+            if is_type_diagnostic_item(cx, struct_ty, sym::vec_type);
 
             // Argument to "get" is a subtraction
             if let Some(get_index_arg) = args.get(1);
diff --git a/clippy_lints/src/if_let_some_result.rs b/clippy_lints/src/if_let_some_result.rs
index 28b20cdeac3..e0a1f4c5ca4 100644
--- a/clippy_lints/src/if_let_some_result.rs
+++ b/clippy_lints/src/if_let_some_result.rs
@@ -4,6 +4,7 @@ use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, MatchSource, PatKind, QPath};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::sym;
 
 declare_clippy_lint! {
     /// **What it does:*** Checks for unnecessary `ok()` in if let.
@@ -45,7 +46,7 @@ impl<'tcx> LateLintPass<'tcx> for OkIfLet {
             if let ExprKind::MethodCall(_, ok_span, ref result_types, _) = op.kind; //check is expr.ok() has type Result<T,E>.ok(, _)
             if let PatKind::TupleStruct(QPath::Resolved(_, ref x), ref y, _)  = body[0].pat.kind; //get operation
             if method_chain_args(op, &["ok"]).is_some(); //test to see if using ok() methoduse std::marker::Sized;
-            if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&result_types[0]), sym!(result_type));
+            if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&result_types[0]), sym::result_type);
             if rustc_hir_pretty::to_string(rustc_hir_pretty::NO_ANN, |s| s.print_path(x, false)) == "Some";
 
             then {
diff --git a/clippy_lints/src/inherent_to_string.rs b/clippy_lints/src/inherent_to_string.rs
index 0877b44d901..b723d06a688 100644
--- a/clippy_lints/src/inherent_to_string.rs
+++ b/clippy_lints/src/inherent_to_string.rs
@@ -2,6 +2,7 @@ use if_chain::if_chain;
 use rustc_hir::{ImplItem, ImplItemKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::sym;
 
 use crate::utils::{
     get_trait_def_id, implements_trait, is_type_diagnostic_item, paths, return_ty, span_lint_and_help,
@@ -107,7 +108,7 @@ impl<'tcx> LateLintPass<'tcx> for InherentToString {
             if decl.inputs.len() == 1;
 
             // Check if return type is String
-            if is_type_diagnostic_item(cx, return_ty(cx, impl_item.hir_id), sym!(string_type));
+            if is_type_diagnostic_item(cx, return_ty(cx, impl_item.hir_id), sym::string_type);
 
             // Filters instances of to_string which are required by a trait
             if trait_ref_of_method(cx, impl_item.hir_id).is_none();
diff --git a/clippy_lints/src/inline_fn_without_body.rs b/clippy_lints/src/inline_fn_without_body.rs
index 4b605fdb366..d1c3fdc7146 100644
--- a/clippy_lints/src/inline_fn_without_body.rs
+++ b/clippy_lints/src/inline_fn_without_body.rs
@@ -7,7 +7,7 @@ use rustc_errors::Applicability;
 use rustc_hir::{TraitFn, TraitItem, TraitItemKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::Symbol;
+use rustc_span::{sym, Symbol};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for `#[inline]` on trait methods without bodies
@@ -41,7 +41,7 @@ impl<'tcx> LateLintPass<'tcx> for InlineFnWithoutBody {
 
 fn check_attrs(cx: &LateContext<'_>, name: Symbol, attrs: &[Attribute]) {
     for attr in attrs {
-        if !attr.has_name(sym!(inline)) {
+        if !attr.has_name(sym::inline) {
             continue;
         }
 
diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index c3f75f283f4..c7d3f4e9b08 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -619,9 +619,9 @@ impl<'tcx> LateLintPass<'tcx> for Loops {
                 }
 
                 let lhs_constructor = last_path_segment(qpath);
-                if method_path.ident.name == sym!(next)
+                if method_path.ident.name == sym::next
                     && match_trait_method(cx, match_expr, &paths::ITERATOR)
-                    && lhs_constructor.ident.name == sym!(Some)
+                    && lhs_constructor.ident.name == sym::Some
                     && (pat_args.is_empty()
                         || !is_refutable(cx, &pat_args[0])
                             && !is_used_inside(cx, iter_expr, &arms[0].body)
@@ -985,13 +985,13 @@ fn is_slice_like<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'_>) -> bool {
         _ => false,
     };
 
-    is_slice || is_type_diagnostic_item(cx, ty, sym!(vec_type)) || is_type_diagnostic_item(cx, ty, sym!(vecdeque_type))
+    is_slice || is_type_diagnostic_item(cx, ty, sym::vec_type) || is_type_diagnostic_item(cx, ty, sym!(vecdeque_type))
 }
 
 fn fetch_cloned_expr<'tcx>(expr: &'tcx Expr<'tcx>) -> &'tcx Expr<'tcx> {
     if_chain! {
         if let ExprKind::MethodCall(method, _, args, _) = expr.kind;
-        if method.ident.name == sym!(clone);
+        if method.ident.name == sym::clone;
         if args.len() == 1;
         if let Some(arg) = args.get(0);
         then { arg } else { expr }
@@ -1355,7 +1355,7 @@ fn get_vec_push<'tcx>(cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) -> Option<(&
             if let Some(self_expr) = args.get(0);
             if let Some(pushed_item) = args.get(1);
             // Check that the method being called is push() on a Vec
-            if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(self_expr), sym!(vec_type));
+            if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(self_expr), sym::vec_type);
             if path.ident.name.as_str() == "push";
             then {
                 return Some((self_expr, pushed_item))
@@ -1736,7 +1736,7 @@ fn check_for_loop_arg(cx: &LateContext<'_>, pat: &Pat<'_>, arg: &Expr<'_>, expr:
 /// Checks for `for` loops over `Option`s and `Result`s.
 fn check_arg_type(cx: &LateContext<'_>, pat: &Pat<'_>, arg: &Expr<'_>) {
     let ty = cx.typeck_results().expr_ty(arg);
-    if is_type_diagnostic_item(cx, ty, sym!(option_type)) {
+    if is_type_diagnostic_item(cx, ty, sym::option_type) {
         span_lint_and_help(
             cx,
             FOR_LOOPS_OVER_FALLIBLES,
@@ -1753,7 +1753,7 @@ fn check_arg_type(cx: &LateContext<'_>, pat: &Pat<'_>, arg: &Expr<'_>) {
                 snippet(cx, arg.span, "_")
             ),
         );
-    } else if is_type_diagnostic_item(cx, ty, sym!(result_type)) {
+    } else if is_type_diagnostic_item(cx, ty, sym::result_type) {
         span_lint_and_help(
             cx,
             FOR_LOOPS_OVER_FALLIBLES,
@@ -2186,8 +2186,8 @@ impl<'a, 'tcx> Visitor<'tcx> for VarVisitor<'a, 'tcx> {
         if_chain! {
             // a range index op
             if let ExprKind::MethodCall(ref meth, _, ref args, _) = expr.kind;
-            if (meth.ident.name == sym!(index) && match_trait_method(self.cx, expr, &paths::INDEX))
-                || (meth.ident.name == sym!(index_mut) && match_trait_method(self.cx, expr, &paths::INDEX_MUT));
+            if (meth.ident.name == sym::index && match_trait_method(self.cx, expr, &paths::INDEX))
+                || (meth.ident.name == sym::index_mut && match_trait_method(self.cx, expr, &paths::INDEX_MUT));
             if !self.check(&args[1], &args[0], expr);
             then { return }
         }
@@ -2333,7 +2333,7 @@ fn is_ref_iterable_type(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
     // will allow further borrows afterwards
     let ty = cx.typeck_results().expr_ty(e);
     is_iterable_array(ty, cx) ||
-    is_type_diagnostic_item(cx, ty, sym!(vec_type)) ||
+    is_type_diagnostic_item(cx, ty, sym::vec_type) ||
     match_type(cx, ty, &paths::LINKED_LIST) ||
     is_type_diagnostic_item(cx, ty, sym!(hashmap_type)) ||
     is_type_diagnostic_item(cx, ty, sym!(hashset_type)) ||
@@ -2890,7 +2890,7 @@ fn check_needless_collect_direct_usage<'tcx>(expr: &'tcx Expr<'_>, cx: &LateCont
         if let Some(GenericArg::Type(ref ty)) = generic_args.args.get(0);
         then {
             let ty = cx.typeck_results().node_type(ty.hir_id);
-            if is_type_diagnostic_item(cx, ty, sym!(vec_type)) ||
+            if is_type_diagnostic_item(cx, ty, sym::vec_type) ||
                 is_type_diagnostic_item(cx, ty, sym!(vecdeque_type)) ||
                 match_type(cx, ty, &paths::BTREEMAP) ||
                 is_type_diagnostic_item(cx, ty, sym!(hashmap_type)) {
diff --git a/clippy_lints/src/manual_non_exhaustive.rs b/clippy_lints/src/manual_non_exhaustive.rs
index 9c623821fdd..a1450b0d5fe 100644
--- a/clippy_lints/src/manual_non_exhaustive.rs
+++ b/clippy_lints/src/manual_non_exhaustive.rs
@@ -5,7 +5,7 @@ use rustc_attr as attr;
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::Span;
+use rustc_span::{sym, Span};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for manual implementations of the non-exhaustive pattern.
@@ -83,9 +83,9 @@ fn check_manual_non_exhaustive_enum(cx: &EarlyContext<'_>, item: &Item, variants
     }
 
     fn is_doc_hidden(attr: &Attribute) -> bool {
-        attr.has_name(sym!(doc))
+        attr.has_name(sym::doc)
             && match attr.meta_item_list() {
-                Some(l) => attr::list_contains_name(&l, sym!(hidden)),
+                Some(l) => attr::list_contains_name(&l, sym::hidden),
                 None => false,
             }
     }
@@ -102,7 +102,7 @@ fn check_manual_non_exhaustive_enum(cx: &EarlyContext<'_>, item: &Item, variants
                 "this seems like a manual implementation of the non-exhaustive pattern",
                 |diag| {
                     if_chain! {
-                        if !item.attrs.iter().any(|attr| attr.has_name(sym!(non_exhaustive)));
+                        if !item.attrs.iter().any(|attr| attr.has_name(sym::non_exhaustive));
                         let header_span = cx.sess.source_map().span_until_char(item.span, '{');
                         if let Some(snippet) = snippet_opt(cx, header_span);
                         then {
@@ -154,7 +154,7 @@ fn check_manual_non_exhaustive_struct(cx: &EarlyContext<'_>, item: &Item, data:
                 "this seems like a manual implementation of the non-exhaustive pattern",
                 |diag| {
                     if_chain! {
-                        if !item.attrs.iter().any(|attr| attr.has_name(sym!(non_exhaustive)));
+                        if !item.attrs.iter().any(|attr| attr.has_name(sym::non_exhaustive));
                         let header_span = find_header_span(cx, item, data);
                         if let Some(snippet) = snippet_opt(cx, header_span);
                         then {
diff --git a/clippy_lints/src/manual_unwrap_or.rs b/clippy_lints/src/manual_unwrap_or.rs
index 22aa37e41fe..9e2c6c7f231 100644
--- a/clippy_lints/src/manual_unwrap_or.rs
+++ b/clippy_lints/src/manual_unwrap_or.rs
@@ -8,6 +8,7 @@ use rustc_lint::LintContext;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::sym;
 
 declare_clippy_lint! {
     /// **What it does:**
@@ -97,9 +98,9 @@ fn lint_manual_unwrap_or<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
     if_chain! {
         if let ExprKind::Match(scrutinee, match_arms, _) = expr.kind;
         let ty = cx.typeck_results().expr_ty(scrutinee);
-        if let Some(case) = if utils::is_type_diagnostic_item(cx, ty, sym!(option_type)) {
+        if let Some(case) = if utils::is_type_diagnostic_item(cx, ty, sym::option_type) {
             Some(Case::Option)
-        } else if utils::is_type_diagnostic_item(cx, ty, sym!(result_type)) {
+        } else if utils::is_type_diagnostic_item(cx, ty, sym::result_type) {
             Some(Case::Result)
         } else {
             None
diff --git a/clippy_lints/src/map_clone.rs b/clippy_lints/src/map_clone.rs
index 6d1c2ffbfbd..034cd99a9be 100644
--- a/clippy_lints/src/map_clone.rs
+++ b/clippy_lints/src/map_clone.rs
@@ -10,7 +10,7 @@ use rustc_middle::mir::Mutability;
 use rustc_middle::ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::symbol::Ident;
-use rustc_span::Span;
+use rustc_span::{sym, Span};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for usage of `iterator.map(|x| x.clone())` and suggests
@@ -53,7 +53,7 @@ impl<'tcx> LateLintPass<'tcx> for MapClone {
             if args.len() == 2;
             if method.ident.as_str() == "map";
             let ty = cx.typeck_results().expr_ty(&args[0]);
-            if is_type_diagnostic_item(cx, ty, sym!(option_type)) || match_trait_method(cx, e, &paths::ITERATOR);
+            if is_type_diagnostic_item(cx, ty, sym::option_type) || match_trait_method(cx, e, &paths::ITERATOR);
             if let hir::ExprKind::Closure(_, _, body_id, _, _) = args[1].kind;
             let closure_body = cx.tcx.hir().body(body_id);
             let closure_expr = remove_blocks(&closure_body.value);
diff --git a/clippy_lints/src/map_identity.rs b/clippy_lints/src/map_identity.rs
index d4c2e66ff4b..6b782385a38 100644
--- a/clippy_lints/src/map_identity.rs
+++ b/clippy_lints/src/map_identity.rs
@@ -7,6 +7,7 @@ use rustc_errors::Applicability;
 use rustc_hir::{Body, Expr, ExprKind, Pat, PatKind, QPath, StmtKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::sym;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for instances of `map(f)` where `f` is the identity function.
@@ -65,8 +66,8 @@ fn get_map_argument<'a>(cx: &LateContext<'_>, expr: &'a Expr<'a>) -> Option<&'a
         if args.len() == 2 && method.ident.as_str() == "map";
         let caller_ty = cx.typeck_results().expr_ty(&args[0]);
         if match_trait_method(cx, expr, &paths::ITERATOR)
-            || is_type_diagnostic_item(cx, caller_ty, sym!(result_type))
-            || is_type_diagnostic_item(cx, caller_ty, sym!(option_type));
+            || is_type_diagnostic_item(cx, caller_ty, sym::result_type)
+            || is_type_diagnostic_item(cx, caller_ty, sym::option_type);
         then {
             Some(args)
         } else {
diff --git a/clippy_lints/src/map_unit_fn.rs b/clippy_lints/src/map_unit_fn.rs
index 076ef235b8b..e50d11a4d71 100644
--- a/clippy_lints/src/map_unit_fn.rs
+++ b/clippy_lints/src/map_unit_fn.rs
@@ -6,6 +6,7 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{self, Ty};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
+use rustc_span::sym;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for usage of `option.map(f)` where f is a function
@@ -206,9 +207,9 @@ fn lint_map_unit_fn(cx: &LateContext<'_>, stmt: &hir::Stmt<'_>, expr: &hir::Expr
     let var_arg = &map_args[0];
 
     let (map_type, variant, lint) =
-        if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(var_arg), sym!(option_type)) {
+        if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(var_arg), sym::option_type) {
             ("Option", "Some", OPTION_MAP_UNIT_FN)
-        } else if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(var_arg), sym!(result_type)) {
+        } else if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(var_arg), sym::result_type) {
             ("Result", "Ok", RESULT_MAP_UNIT_FN)
         } else {
             return;
diff --git a/clippy_lints/src/match_on_vec_items.rs b/clippy_lints/src/match_on_vec_items.rs
index 331b6c6c34a..086dae9422f 100644
--- a/clippy_lints/src/match_on_vec_items.rs
+++ b/clippy_lints/src/match_on_vec_items.rs
@@ -5,6 +5,7 @@ use rustc_hir::{Expr, ExprKind, LangItem, MatchSource};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::sym;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for `match vec[idx]` or `match vec[n..m]`.
@@ -90,7 +91,7 @@ fn is_vec_indexing<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> Opti
 fn is_vector(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
     let ty = cx.typeck_results().expr_ty(expr);
     let ty = ty.peel_refs();
-    is_type_diagnostic_item(cx, ty, sym!(vec_type))
+    is_type_diagnostic_item(cx, ty, sym::vec_type)
 }
 
 fn is_full_range(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index 4bdfca1a292..c6dca54e250 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -22,7 +22,7 @@ use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::{self, Ty, TyS};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::{Span, Spanned};
-use rustc_span::Symbol;
+use rustc_span::{sym, Symbol};
 use std::cmp::Ordering;
 use std::collections::hash_map::Entry;
 use std::collections::Bound;
@@ -662,7 +662,7 @@ fn check_single_match(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>], exp
             }
         } else {
             // not a block, don't lint
-            return; 
+            return;
         };
 
         let ty = cx.typeck_results().expr_ty(ex);
@@ -840,7 +840,7 @@ fn check_overlapping_arms<'tcx>(cx: &LateContext<'tcx>, ex: &'tcx Expr<'_>, arms
 
 fn check_wild_err_arm(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>]) {
     let ex_ty = cx.typeck_results().expr_ty(ex).peel_refs();
-    if is_type_diagnostic_item(cx, ex_ty, sym!(result_type)) {
+    if is_type_diagnostic_item(cx, ex_ty, sym::result_type) {
         for arm in arms {
             if let PatKind::TupleStruct(ref path, ref inner, _) = arm.pat.kind {
                 let path_str = rustc_hir_pretty::to_string(rustc_hir_pretty::NO_ANN, |s| s.print_qpath(path, false));
@@ -1509,6 +1509,7 @@ mod redundant_pattern_match {
     use rustc_errors::Applicability;
     use rustc_hir::{Arm, Expr, ExprKind, MatchSource, PatKind, QPath};
     use rustc_lint::LateContext;
+    use rustc_span::sym;
 
     pub fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if let ExprKind::Match(op, arms, ref match_source) = &expr.kind {
@@ -1552,7 +1553,7 @@ mod redundant_pattern_match {
         if_chain! {
             if keyword == "while";
             if let ExprKind::MethodCall(method_path, _, _, _) = op.kind;
-            if method_path.ident.name == sym!(next);
+            if method_path.ident.name == sym::next;
             if match_trait_method(cx, op, &paths::ITERATOR);
             then {
                 return;
diff --git a/clippy_lints/src/methods/inefficient_to_string.rs b/clippy_lints/src/methods/inefficient_to_string.rs
index 5dae7efad97..c83b6f2c329 100644
--- a/clippy_lints/src/methods/inefficient_to_string.rs
+++ b/clippy_lints/src/methods/inefficient_to_string.rs
@@ -7,6 +7,7 @@ use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
 use rustc_middle::ty::{self, Ty};
+use rustc_span::sym;
 
 /// Checks for the `INEFFICIENT_TO_STRING` lint
 pub fn lint<'tcx>(cx: &LateContext<'tcx>, expr: &hir::Expr<'_>, arg: &hir::Expr<'_>, arg_ty: Ty<'tcx>) {
@@ -50,7 +51,7 @@ fn specializes_tostring(cx: &LateContext<'_>, ty: Ty<'_>) -> bool {
         return true;
     }
 
-    if is_type_diagnostic_item(cx, ty, sym!(string_type)) {
+    if is_type_diagnostic_item(cx, ty, sym::string_type) {
         return true;
     }
 
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 3c3093e869c..167b8cc2422 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1677,7 +1677,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
     fn check_trait_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx TraitItem<'_>) {
         if_chain! {
             if !in_external_macro(cx.tcx.sess, item.span);
-            if item.ident.name == sym!(new);
+            if item.ident.name == sym::new;
             if let TraitItemKind::Fn(_, _) = item.kind;
             let ret_ty = return_ty(cx, item.hir_id);
             let self_ty = TraitRef::identity(cx.tcx, item.hir_id.owner.to_def_id()).self_ty();
@@ -1767,7 +1767,7 @@ fn lint_or_fun_call<'tcx>(
                     _ => (),
                 }
 
-                if is_type_diagnostic_item(cx, ty, sym!(vec_type)) {
+                if is_type_diagnostic_item(cx, ty, sym::vec_type) {
                     return;
                 }
             }
@@ -1864,11 +1864,11 @@ fn lint_expect_fun_call(
                 hir::ExprKind::AddrOf(hir::BorrowKind::Ref, _, expr) => expr,
                 hir::ExprKind::MethodCall(method_name, _, call_args, _) => {
                     if call_args.len() == 1
-                        && (method_name.ident.name == sym!(as_str) || method_name.ident.name == sym!(as_ref))
+                        && (method_name.ident.name == sym::as_str || method_name.ident.name == sym!(as_ref))
                         && {
                             let arg_type = cx.typeck_results().expr_ty(&call_args[0]);
                             let base_type = arg_type.peel_refs();
-                            *base_type.kind() == ty::Str || is_type_diagnostic_item(cx, base_type, sym!(string_type))
+                            *base_type.kind() == ty::Str || is_type_diagnostic_item(cx, base_type, sym::string_type)
                         }
                     {
                         &call_args[0]
@@ -1886,7 +1886,7 @@ fn lint_expect_fun_call(
     // converted to string.
     fn requires_to_string(cx: &LateContext<'_>, arg: &hir::Expr<'_>) -> bool {
         let arg_ty = cx.typeck_results().expr_ty(arg);
-        if is_type_diagnostic_item(cx, arg_ty, sym!(string_type)) {
+        if is_type_diagnostic_item(cx, arg_ty, sym::string_type) {
             return false;
         }
         if let ty::Ref(_, ty, ..) = arg_ty.kind() {
@@ -1973,9 +1973,9 @@ fn lint_expect_fun_call(
     }
 
     let receiver_type = cx.typeck_results().expr_ty_adjusted(&args[0]);
-    let closure_args = if is_type_diagnostic_item(cx, receiver_type, sym!(option_type)) {
+    let closure_args = if is_type_diagnostic_item(cx, receiver_type, sym::option_type) {
         "||"
-    } else if is_type_diagnostic_item(cx, receiver_type, sym!(result_type)) {
+    } else if is_type_diagnostic_item(cx, receiver_type, sym::result_type) {
         "|_|"
     } else {
         return;
@@ -2162,7 +2162,7 @@ fn lint_string_extend(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::E
         let self_ty = cx.typeck_results().expr_ty(target).peel_refs();
         let ref_str = if *self_ty.kind() == ty::Str {
             ""
-        } else if is_type_diagnostic_item(cx, self_ty, sym!(string_type)) {
+        } else if is_type_diagnostic_item(cx, self_ty, sym::string_type) {
             "&"
         } else {
             return;
@@ -2188,14 +2188,14 @@ fn lint_string_extend(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::E
 
 fn lint_extend(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::Expr<'_>]) {
     let obj_ty = cx.typeck_results().expr_ty(&args[0]).peel_refs();
-    if is_type_diagnostic_item(cx, obj_ty, sym!(string_type)) {
+    if is_type_diagnostic_item(cx, obj_ty, sym::string_type) {
         lint_string_extend(cx, expr, args);
     }
 }
 
 fn lint_iter_cloned_collect<'tcx>(cx: &LateContext<'tcx>, expr: &hir::Expr<'_>, iter_args: &'tcx [hir::Expr<'_>]) {
     if_chain! {
-        if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(expr), sym!(vec_type));
+        if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(expr), sym::vec_type);
         if let Some(slice) = derefs_to_slice(cx, &iter_args[0], cx.typeck_results().expr_ty(&iter_args[0]));
         if let Some(to_replace) = expr.span.trim_start(slice.span.source_callsite());
 
@@ -2348,7 +2348,7 @@ fn lint_iter_next<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, iter_
                 );
             }
         }
-    } else if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(caller_expr), sym!(vec_type))
+    } else if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(caller_expr), sym::vec_type)
         || matches!(
             &cx.typeck_results().expr_ty(caller_expr).peel_refs().kind(),
             ty::Array(_, _)
@@ -2381,7 +2381,7 @@ fn lint_iter_nth<'tcx>(
     let mut_str = if is_mut { "_mut" } else { "" };
     let caller_type = if derefs_to_slice(cx, &iter_args[0], cx.typeck_results().expr_ty(&iter_args[0])).is_some() {
         "slice"
-    } else if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&iter_args[0]), sym!(vec_type)) {
+    } else if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&iter_args[0]), sym::vec_type) {
         "Vec"
     } else if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&iter_args[0]), sym!(vecdeque_type)) {
         "VecDeque"
@@ -2434,7 +2434,7 @@ fn lint_get_unwrap<'tcx>(cx: &LateContext<'tcx>, expr: &hir::Expr<'_>, get_args:
     let caller_type = if derefs_to_slice(cx, &get_args[0], expr_ty).is_some() {
         needs_ref = get_args_str.parse::<usize>().is_ok();
         "slice"
-    } else if is_type_diagnostic_item(cx, expr_ty, sym!(vec_type)) {
+    } else if is_type_diagnostic_item(cx, expr_ty, sym::vec_type) {
         needs_ref = get_args_str.parse::<usize>().is_ok();
         "Vec"
     } else if is_type_diagnostic_item(cx, expr_ty, sym!(vecdeque_type)) {
@@ -2520,7 +2520,7 @@ fn derefs_to_slice<'tcx>(
         match ty.kind() {
             ty::Slice(_) => true,
             ty::Adt(def, _) if def.is_box() => may_slice(cx, ty.boxed_ty()),
-            ty::Adt(..) => is_type_diagnostic_item(cx, ty, sym!(vec_type)),
+            ty::Adt(..) => is_type_diagnostic_item(cx, ty, sym::vec_type),
             ty::Array(_, size) => size
                 .try_eval_usize(cx.tcx, cx.param_env)
                 .map_or(false, |size| size < 32),
@@ -2530,7 +2530,7 @@ fn derefs_to_slice<'tcx>(
     }
 
     if let hir::ExprKind::MethodCall(ref path, _, ref args, _) = expr.kind {
-        if path.ident.name == sym!(iter) && may_slice(cx, cx.typeck_results().expr_ty(&args[0])) {
+        if path.ident.name == sym::iter && may_slice(cx, cx.typeck_results().expr_ty(&args[0])) {
             Some(&args[0])
         } else {
             None
@@ -2555,9 +2555,9 @@ fn derefs_to_slice<'tcx>(
 fn lint_unwrap(cx: &LateContext<'_>, expr: &hir::Expr<'_>, unwrap_args: &[hir::Expr<'_>]) {
     let obj_ty = cx.typeck_results().expr_ty(&unwrap_args[0]).peel_refs();
 
-    let mess = if is_type_diagnostic_item(cx, obj_ty, sym!(option_type)) {
+    let mess = if is_type_diagnostic_item(cx, obj_ty, sym::option_type) {
         Some((UNWRAP_USED, "an Option", "None"))
-    } else if is_type_diagnostic_item(cx, obj_ty, sym!(result_type)) {
+    } else if is_type_diagnostic_item(cx, obj_ty, sym::result_type) {
         Some((UNWRAP_USED, "a Result", "Err"))
     } else {
         None
@@ -2607,7 +2607,7 @@ fn lint_expect(cx: &LateContext<'_>, expr: &hir::Expr<'_>, expect_args: &[hir::E
 fn lint_ok_expect(cx: &LateContext<'_>, expr: &hir::Expr<'_>, ok_args: &[hir::Expr<'_>]) {
     if_chain! {
         // lint if the caller of `ok()` is a `Result`
-        if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&ok_args[0]), sym!(result_type));
+        if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&ok_args[0]), sym::result_type);
         let result_type = cx.typeck_results().expr_ty(&ok_args[0]);
         if let Some(error_type) = get_error_type(cx, result_type);
         if has_debug_impl(error_type, cx);
@@ -2637,7 +2637,7 @@ fn lint_map_flatten<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, map
                     _ => map_closure_ty.fn_sig(cx.tcx),
                 };
                 let map_closure_return_ty = cx.tcx.erase_late_bound_regions(&map_closure_sig.output());
-                is_type_diagnostic_item(cx, map_closure_return_ty, sym!(option_type))
+                is_type_diagnostic_item(cx, map_closure_return_ty, sym::option_type)
             },
             _ => false,
         };
@@ -2663,7 +2663,7 @@ fn lint_map_flatten<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, map
     }
 
     // lint if caller of `.map().flatten()` is an Option
-    if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&map_args[0]), sym!(option_type)) {
+    if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&map_args[0]), sym::option_type) {
         let func_snippet = snippet(cx, map_args[1].span, "..");
         let hint = format!(".and_then({})", func_snippet);
         span_lint_and_sugg(
@@ -2687,8 +2687,8 @@ fn lint_map_unwrap_or_else<'tcx>(
     unwrap_args: &'tcx [hir::Expr<'_>],
 ) -> bool {
     // lint if the caller of `map()` is an `Option`
-    let is_option = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&map_args[0]), sym!(option_type));
-    let is_result = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&map_args[0]), sym!(result_type));
+    let is_option = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&map_args[0]), sym::option_type);
+    let is_result = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&map_args[0]), sym::result_type);
 
     if is_option || is_result {
         // Don't make a suggestion that may fail to compile due to mutably borrowing
@@ -2741,8 +2741,8 @@ fn lint_map_unwrap_or_else<'tcx>(
 
 /// lint use of `_.map_or(None, _)` for `Option`s and `Result`s
 fn lint_map_or_none<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, map_or_args: &'tcx [hir::Expr<'_>]) {
-    let is_option = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&map_or_args[0]), sym!(option_type));
-    let is_result = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&map_or_args[0]), sym!(result_type));
+    let is_option = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&map_or_args[0]), sym::option_type);
+    let is_result = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&map_or_args[0]), sym::result_type);
 
     // There are two variants of this `map_or` lint:
     // (1) using `map_or` as an adapter from `Result<T,E>` to `Option<T>`
@@ -3100,7 +3100,7 @@ fn lint_chars_cmp(
         if arg_char.len() == 1;
         if let hir::ExprKind::Path(ref qpath) = fun.kind;
         if let Some(segment) = single_segment_path(qpath);
-        if segment.ident.name == sym!(Some);
+        if segment.ident.name == sym::Some;
         then {
             let mut applicability = Applicability::MachineApplicable;
             let self_ty = cx.typeck_results().expr_ty_adjusted(&args[0][0]).peel_refs();
@@ -3375,7 +3375,7 @@ fn lint_option_as_ref_deref<'tcx>(
     let same_mutability = |m| (is_mut && m == &hir::Mutability::Mut) || (!is_mut && m == &hir::Mutability::Not);
 
     let option_ty = cx.typeck_results().expr_ty(&as_ref_args[0]);
-    if !is_type_diagnostic_item(cx, option_ty, sym!(option_type)) {
+    if !is_type_diagnostic_item(cx, option_ty, sym::option_type) {
         return;
     }
 
@@ -3482,7 +3482,7 @@ fn lint_map_collect(
         if match_trait_method(cx, map_expr, &paths::ITERATOR);
         // return of collect `Result<(),_>`
         let collect_ret_ty = cx.typeck_results().expr_ty(expr);
-        if is_type_diagnostic_item(cx, collect_ret_ty, sym!(result_type));
+        if is_type_diagnostic_item(cx, collect_ret_ty, sym::result_type);
         if let ty::Adt(_, substs) = collect_ret_ty.kind();
         if let Some(result_t) = substs.types().next();
         if result_t.is_unit();
@@ -3509,7 +3509,7 @@ fn lint_map_collect(
 /// Given a `Result<T, E>` type, return its error type (`E`).
 fn get_error_type<'a>(cx: &LateContext<'_>, ty: Ty<'a>) -> Option<Ty<'a>> {
     match ty.kind() {
-        ty::Adt(_, substs) if is_type_diagnostic_item(cx, ty, sym!(result_type)) => substs.types().nth(1),
+        ty::Adt(_, substs) if is_type_diagnostic_item(cx, ty, sym::result_type) => substs.types().nth(1),
         _ => None,
     }
 }
diff --git a/clippy_lints/src/methods/option_map_unwrap_or.rs b/clippy_lints/src/methods/option_map_unwrap_or.rs
index d30b85d6a78..7763fd5f113 100644
--- a/clippy_lints/src/methods/option_map_unwrap_or.rs
+++ b/clippy_lints/src/methods/option_map_unwrap_or.rs
@@ -7,7 +7,7 @@ use rustc_hir::{self, HirId, Path};
 use rustc_lint::LateContext;
 use rustc_middle::hir::map::Map;
 use rustc_span::source_map::Span;
-use rustc_span::symbol::Symbol;
+use rustc_span::{sym, Symbol};
 
 use super::MAP_UNWRAP_OR;
 
@@ -20,7 +20,7 @@ pub(super) fn lint<'tcx>(
     map_span: Span,
 ) {
     // lint if the caller of `map()` is an `Option`
-    if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&map_args[0]), sym!(option_type)) {
+    if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&map_args[0]), sym::option_type) {
         if !is_copy(cx, cx.typeck_results().expr_ty(&unwrap_args[1])) {
             // Do not lint if the `map` argument uses identifiers in the `map`
             // argument that are also used in the `unwrap_or` argument
diff --git a/clippy_lints/src/methods/unnecessary_lazy_eval.rs b/clippy_lints/src/methods/unnecessary_lazy_eval.rs
index 08b3eab9b7c..cde89983a26 100644
--- a/clippy_lints/src/methods/unnecessary_lazy_eval.rs
+++ b/clippy_lints/src/methods/unnecessary_lazy_eval.rs
@@ -3,6 +3,7 @@ use crate::utils::{is_type_diagnostic_item, snippet, span_lint_and_sugg};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
+use rustc_span::sym;
 
 use super::UNNECESSARY_LAZY_EVALUATIONS;
 
@@ -14,8 +15,8 @@ pub(super) fn lint<'tcx>(
     args: &'tcx [hir::Expr<'_>],
     simplify_using: &str,
 ) {
-    let is_option = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&args[0]), sym!(option_type));
-    let is_result = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&args[0]), sym!(result_type));
+    let is_option = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&args[0]), sym::option_type);
+    let is_result = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&args[0]), sym::result_type);
 
     if is_option || is_result {
         if let hir::ExprKind::Closure(_, _, eid, _, _) = args[1].kind {
diff --git a/clippy_lints/src/missing_doc.rs b/clippy_lints/src/missing_doc.rs
index 813f9c43948..009e3d8937e 100644
--- a/clippy_lints/src/missing_doc.rs
+++ b/clippy_lints/src/missing_doc.rs
@@ -14,6 +14,7 @@ use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::ty;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::Span;
+use rustc_span::sym;
 
 declare_clippy_lint! {
     /// **What it does:** Warns if there is missing doc for any documentable item
@@ -105,10 +106,10 @@ impl<'tcx> LateLintPass<'tcx> for MissingDoc {
     fn enter_lint_attrs(&mut self, _: &LateContext<'tcx>, attrs: &'tcx [ast::Attribute]) {
         let doc_hidden = self.doc_hidden()
             || attrs.iter().any(|attr| {
-                attr.has_name(sym!(doc))
+                attr.has_name(sym::doc)
                     && match attr.meta_item_list() {
                         None => false,
-                        Some(l) => attr::list_contains_name(&l[..], sym!(hidden)),
+                        Some(l) => attr::list_contains_name(&l[..], sym::hidden),
                     }
             });
         self.doc_hidden_stack.push(doc_hidden);
@@ -128,7 +129,7 @@ impl<'tcx> LateLintPass<'tcx> for MissingDoc {
             hir::ItemKind::Enum(..) => "an enum",
             hir::ItemKind::Fn(..) => {
                 // ignore main()
-                if it.ident.name == sym!(main) {
+                if it.ident.name == sym::main {
                     let def_id = it.hir_id.owner;
                     let def_key = cx.tcx.hir().def_key(def_id);
                     if def_key.parent == Some(hir::def_id::CRATE_DEF_INDEX) {
diff --git a/clippy_lints/src/missing_inline.rs b/clippy_lints/src/missing_inline.rs
index 3eae45b2819..53abe6086ea 100644
--- a/clippy_lints/src/missing_inline.rs
+++ b/clippy_lints/src/missing_inline.rs
@@ -4,6 +4,7 @@ use rustc_hir as hir;
 use rustc_lint::{self, LateContext, LateLintPass, LintContext};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
+use rustc_span::sym;
 
 declare_clippy_lint! {
     /// **What it does:** it lints if an exported function, method, trait method with default impl,
@@ -57,7 +58,7 @@ declare_clippy_lint! {
 }
 
 fn check_missing_inline_attrs(cx: &LateContext<'_>, attrs: &[ast::Attribute], sp: Span, desc: &'static str) {
-    let has_inline = attrs.iter().any(|a| a.has_name(sym!(inline)));
+    let has_inline = attrs.iter().any(|a| a.has_name(sym::inline));
     if !has_inline {
         span_lint(
             cx,
diff --git a/clippy_lints/src/needless_borrow.rs b/clippy_lints/src/needless_borrow.rs
index b71d5496a37..405c21d608d 100644
--- a/clippy_lints/src/needless_borrow.rs
+++ b/clippy_lints/src/needless_borrow.rs
@@ -10,6 +10,7 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
 use rustc_middle::ty::adjustment::{Adjust, Adjustment};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::sym;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for address of operations (`&`) that are going to
@@ -112,7 +113,7 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessBorrow {
     }
 
     fn check_item(&mut self, _: &LateContext<'tcx>, item: &'tcx Item<'_>) {
-        if item.attrs.iter().any(|a| a.has_name(sym!(automatically_derived))) {
+        if item.attrs.iter().any(|a| a.has_name(sym::automatically_derived)) {
             debug_assert!(self.derived_item.is_none());
             self.derived_item = Some(item.hir_id);
         }
diff --git a/clippy_lints/src/needless_pass_by_value.rs b/clippy_lints/src/needless_pass_by_value.rs
index 7e933c674dd..5c92590f41e 100644
--- a/clippy_lints/src/needless_pass_by_value.rs
+++ b/clippy_lints/src/needless_pass_by_value.rs
@@ -13,7 +13,7 @@ use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{self, TypeFoldable};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::Span;
+use rustc_span::{sym, Span};
 use rustc_target::spec::abi::Abi;
 use rustc_trait_selection::traits;
 use rustc_trait_selection::traits::misc::can_type_implement_copy;
@@ -204,12 +204,12 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByValue {
 
                         let deref_span = spans_need_deref.get(&canonical_id);
                         if_chain! {
-                            if is_type_diagnostic_item(cx, ty, sym!(vec_type));
+                            if is_type_diagnostic_item(cx, ty, sym::vec_type);
                             if let Some(clone_spans) =
                                 get_spans(cx, Some(body.id()), idx, &[("clone", ".to_owned()")]);
                             if let TyKind::Path(QPath::Resolved(_, ref path)) = input.kind;
                             if let Some(elem_ty) = path.segments.iter()
-                                .find(|seg| seg.ident.name == sym!(Vec))
+                                .find(|seg| seg.ident.name == sym::Vec)
                                 .and_then(|ps| ps.args.as_ref())
                                 .map(|params| params.args.iter().find_map(|arg| match arg {
                                     GenericArg::Type(ty) => Some(ty),
@@ -243,7 +243,7 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByValue {
                             }
                         }
 
-                        if is_type_diagnostic_item(cx, ty, sym!(string_type)) {
+                        if is_type_diagnostic_item(cx, ty, sym::string_type) {
                             if let Some(clone_spans) =
                                 get_spans(cx, Some(body.id()), idx, &[("clone", ".to_string()"), ("as_str", "")]) {
                                 diag.span_suggestion(
@@ -302,7 +302,7 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByValue {
 /// Functions marked with these attributes must have the exact signature.
 fn requires_exact_signature(attrs: &[Attribute]) -> bool {
     attrs.iter().any(|attr| {
-        [sym!(proc_macro), sym!(proc_macro_attribute), sym!(proc_macro_derive)]
+        [sym::proc_macro, sym::proc_macro_attribute, sym::proc_macro_derive]
             .iter()
             .any(|&allow| attr.has_name(allow))
     })
diff --git a/clippy_lints/src/new_without_default.rs b/clippy_lints/src/new_without_default.rs
index 28d1322e946..68fdd0eb269 100644
--- a/clippy_lints/src/new_without_default.rs
+++ b/clippy_lints/src/new_without_default.rs
@@ -9,6 +9,7 @@ use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::{Ty, TyS};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::sym;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for types with a `fn new() -> Self` method and no
@@ -91,7 +92,7 @@ impl<'tcx> LateLintPass<'tcx> for NewWithoutDefault {
                             // impl of `Default`
                             return;
                         }
-                        if sig.decl.inputs.is_empty() && name == sym!(new) && cx.access_levels.is_reachable(id) {
+                        if sig.decl.inputs.is_empty() && name == sym::new && cx.access_levels.is_reachable(id) {
                             let self_def_id = cx.tcx.hir().local_def_id(cx.tcx.hir().get_parent_item(id));
                             let self_ty = cx.tcx.type_of(self_def_id);
                             if_chain! {
diff --git a/clippy_lints/src/non_expressive_names.rs b/clippy_lints/src/non_expressive_names.rs
index 603440c0f83..485888fa944 100644
--- a/clippy_lints/src/non_expressive_names.rs
+++ b/clippy_lints/src/non_expressive_names.rs
@@ -7,6 +7,7 @@ use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::Span;
+use rustc_span::sym;
 use rustc_span::symbol::{Ident, Symbol};
 use std::cmp::Ordering;
 
@@ -384,7 +385,7 @@ impl EarlyLintPass for NonExpressiveNames {
 }
 
 fn do_check(lint: &mut NonExpressiveNames, cx: &EarlyContext<'_>, attrs: &[Attribute], decl: &FnDecl, blk: &Block) {
-    if !attrs.iter().any(|attr| attr.has_name(sym!(test))) {
+    if !attrs.iter().any(|attr| attr.has_name(sym::test)) {
         let mut visitor = SimilarNamesLocalVisitor {
             names: Vec::new(),
             cx,
diff --git a/clippy_lints/src/option_if_let_else.rs b/clippy_lints/src/option_if_let_else.rs
index eb7624b25a3..681dbce9769 100644
--- a/clippy_lints/src/option_if_let_else.rs
+++ b/clippy_lints/src/option_if_let_else.rs
@@ -8,6 +8,7 @@ use rustc_errors::Applicability;
 use rustc_hir::{Arm, BindingAnnotation, Block, Expr, ExprKind, MatchSource, Mutability, PatKind, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::sym;
 
 declare_clippy_lint! {
     /// **What it does:**
@@ -66,7 +67,7 @@ declare_lint_pass!(OptionIfLetElse => [OPTION_IF_LET_ELSE]);
 fn is_result_ok(cx: &LateContext<'_>, expr: &'_ Expr<'_>) -> bool {
     if let ExprKind::MethodCall(ref path, _, &[ref receiver], _) = &expr.kind {
         path.ident.name.to_ident_string() == "ok"
-            && is_type_diagnostic_item(cx, &cx.typeck_results().expr_ty(&receiver), sym!(result_type))
+            && is_type_diagnostic_item(cx, &cx.typeck_results().expr_ty(&receiver), sym::result_type)
     } else {
         false
     }
diff --git a/clippy_lints/src/panic_in_result_fn.rs b/clippy_lints/src/panic_in_result_fn.rs
index 4077aba6ef1..72dfccc1089 100644
--- a/clippy_lints/src/panic_in_result_fn.rs
+++ b/clippy_lints/src/panic_in_result_fn.rs
@@ -5,7 +5,7 @@ use rustc_hir::Expr;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::map::Map;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::Span;
+use rustc_span::{sym, Span};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for usage of `panic!`, `unimplemented!`, `todo!` or `unreachable!` in a function of type result.
@@ -40,7 +40,7 @@ impl<'tcx> LateLintPass<'tcx> for PanicInResultFn {
         hir_id: hir::HirId,
     ) {
         if !matches!(fn_kind, FnKind::Closure(_))
-            && is_type_diagnostic_item(cx, return_ty(cx, hir_id), sym!(result_type))
+            && is_type_diagnostic_item(cx, return_ty(cx, hir_id), sym::result_type)
         {
             lint_impl_body(cx, span, body);
         }
diff --git a/clippy_lints/src/partialeq_ne_impl.rs b/clippy_lints/src/partialeq_ne_impl.rs
index 19d355e64ca..ceecc8dbc06 100644
--- a/clippy_lints/src/partialeq_ne_impl.rs
+++ b/clippy_lints/src/partialeq_ne_impl.rs
@@ -3,6 +3,7 @@ use if_chain::if_chain;
 use rustc_hir::{Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::sym;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for manual re-implementations of `PartialEq::ne`.
@@ -39,7 +40,7 @@ impl<'tcx> LateLintPass<'tcx> for PartialEqNeImpl {
             if trait_ref.path.res.def_id() == eq_trait;
             then {
                 for impl_item in impl_items {
-                    if impl_item.ident.name == sym!(ne) {
+                    if impl_item.ident.name == sym::ne {
                         span_lint_hir(
                             cx,
                             PARTIALEQ_NE_IMPL,
diff --git a/clippy_lints/src/pass_by_ref_or_value.rs b/clippy_lints/src/pass_by_ref_or_value.rs
index 28816c3076d..030650c3256 100644
--- a/clippy_lints/src/pass_by_ref_or_value.rs
+++ b/clippy_lints/src/pass_by_ref_or_value.rs
@@ -10,7 +10,7 @@ use rustc_hir::{BindingAnnotation, Body, FnDecl, HirId, ItemKind, MutTy, Mutabil
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::Span;
+use rustc_span::{sym, Span};
 use rustc_target::abi::LayoutOf;
 use rustc_target::spec::abi::Abi;
 use rustc_target::spec::Target;
@@ -230,8 +230,8 @@ impl<'tcx> LateLintPass<'tcx> for PassByRefOrValue {
                 }
                 for a in attrs {
                     if let Some(meta_items) = a.meta_item_list() {
-                        if a.has_name(sym!(proc_macro_derive))
-                            || (a.has_name(sym!(inline)) && attr::list_contains_name(&meta_items, sym!(always)))
+                        if a.has_name(sym::proc_macro_derive)
+                            || (a.has_name(sym::inline) && attr::list_contains_name(&meta_items, sym::always))
                         {
                             return;
                         }
diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs
index 6b1c848a946..dcb643a28ae 100644
--- a/clippy_lints/src/ptr.rs
+++ b/clippy_lints/src/ptr.rs
@@ -15,7 +15,7 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
-use rustc_span::MultiSpan;
+use rustc_span::{sym, MultiSpan};
 use std::borrow::Cow;
 
 declare_clippy_lint! {
@@ -181,7 +181,7 @@ fn check_fn(cx: &LateContext<'_>, decl: &FnDecl<'_>, fn_id: HirId, opt_body_id:
         }
 
         if let ty::Ref(_, ty, Mutability::Not) = ty.kind() {
-            if is_type_diagnostic_item(cx, ty, sym!(vec_type)) {
+            if is_type_diagnostic_item(cx, ty, sym::vec_type) {
                 let mut ty_snippet = None;
                 if_chain! {
                     if let TyKind::Path(QPath::Resolved(_, ref path)) = walk_ptrs_hir_ty(arg).kind;
@@ -225,7 +225,7 @@ fn check_fn(cx: &LateContext<'_>, decl: &FnDecl<'_>, fn_id: HirId, opt_body_id:
                         },
                     );
                 }
-            } else if is_type_diagnostic_item(cx, ty, sym!(string_type)) {
+            } else if is_type_diagnostic_item(cx, ty, sym::string_type) {
                 if let Some(spans) = get_spans(cx, opt_body_id, idx, &[("clone", ".to_string()"), ("as_str", "")]) {
                     span_lint_and_then(
                         cx,
diff --git a/clippy_lints/src/ptr_offset_with_cast.rs b/clippy_lints/src/ptr_offset_with_cast.rs
index 0a2d1b5fbe6..e0996804a59 100644
--- a/clippy_lints/src/ptr_offset_with_cast.rs
+++ b/clippy_lints/src/ptr_offset_with_cast.rs
@@ -3,6 +3,7 @@ use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::sym;
 use std::fmt;
 
 declare_clippy_lint! {
@@ -92,7 +93,7 @@ fn expr_as_ptr_offset_call<'tcx>(
 ) -> Option<(&'tcx Expr<'tcx>, &'tcx Expr<'tcx>, Method)> {
     if let ExprKind::MethodCall(ref path_segment, _, ref args, _) = expr.kind {
         if is_expr_ty_raw_ptr(cx, &args[0]) {
-            if path_segment.ident.name == sym!(offset) {
+            if path_segment.ident.name == sym::offset {
                 return Some((&args[0], &args[1], Method::Offset));
             }
             if path_segment.ident.name == sym!(wrapping_offset) {
diff --git a/clippy_lints/src/question_mark.rs b/clippy_lints/src/question_mark.rs
index dbc676ae224..d9b280b7a85 100644
--- a/clippy_lints/src/question_mark.rs
+++ b/clippy_lints/src/question_mark.rs
@@ -4,6 +4,7 @@ use rustc_hir::def::{DefKind, Res};
 use rustc_hir::{def, BindingAnnotation, Block, Expr, ExprKind, MatchSource, PatKind, StmtKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::sym;
 
 use crate::utils::sugg::Sugg;
 use crate::utils::{
@@ -143,7 +144,7 @@ impl QuestionMark {
     fn is_option(cx: &LateContext<'_>, expression: &Expr<'_>) -> bool {
         let expr_ty = cx.typeck_results().expr_ty(expression);
 
-        is_type_diagnostic_item(cx, expr_ty, sym!(option_type))
+        is_type_diagnostic_item(cx, expr_ty, sym::option_type)
     }
 
     fn expression_returns_none(cx: &LateContext<'_>, expression: &Expr<'_>) -> bool {
diff --git a/clippy_lints/src/ranges.rs b/clippy_lints/src/ranges.rs
index de54711d851..79e9a56af9a 100644
--- a/clippy_lints/src/ranges.rs
+++ b/clippy_lints/src/ranges.rs
@@ -7,6 +7,7 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::{Span, Spanned};
+use rustc_span::sym;
 use rustc_span::symbol::Ident;
 use std::cmp::Ordering;
 
@@ -304,7 +305,7 @@ fn check_range_zip_with_len(cx: &LateContext<'_>, path: &PathSegment<'_>, args:
         if_chain! {
             // `.iter()` call
             if let ExprKind::MethodCall(ref iter_path, _, ref iter_args, _) = *iter;
-            if iter_path.ident.name == sym!(iter);
+            if iter_path.ident.name == sym::iter;
             // range expression in `.zip()` call: `0..x.len()`
             if let Some(higher::Range { start: Some(start), end: Some(end), .. }) = higher::range(zip_arg);
             if is_integer_const(cx, start, 0);
diff --git a/clippy_lints/src/redundant_clone.rs b/clippy_lints/src/redundant_clone.rs
index 344ed02361d..b4a9804fb25 100644
--- a/clippy_lints/src/redundant_clone.rs
+++ b/clippy_lints/src/redundant_clone.rs
@@ -17,6 +17,7 @@ use rustc_middle::ty::{self, fold::TypeVisitor, Ty};
 use rustc_mir::dataflow::{Analysis, AnalysisDomain, GenKill, GenKillAnalysis, ResultsCursor};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::{BytePos, Span};
+use rustc_span::sym;
 use std::convert::TryFrom;
 use std::ops::ControlFlow;
 
@@ -115,7 +116,7 @@ impl<'tcx> LateLintPass<'tcx> for RedundantClone {
             let from_borrow = match_def_path(cx, fn_def_id, &paths::CLONE_TRAIT_METHOD)
                 || match_def_path(cx, fn_def_id, &paths::TO_OWNED_METHOD)
                 || (match_def_path(cx, fn_def_id, &paths::TO_STRING_METHOD)
-                    && is_type_diagnostic_item(cx, arg_ty, sym!(string_type)));
+                    && is_type_diagnostic_item(cx, arg_ty, sym::string_type));
 
             let from_deref = !from_borrow
                 && (match_def_path(cx, fn_def_id, &paths::PATH_TO_PATH_BUF)
diff --git a/clippy_lints/src/repeat_once.rs b/clippy_lints/src/repeat_once.rs
index ae601353009..d34e744eb94 100644
--- a/clippy_lints/src/repeat_once.rs
+++ b/clippy_lints/src/repeat_once.rs
@@ -5,6 +5,7 @@ use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::sym;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for usage of `.repeat(1)` and suggest the following method for each types.
@@ -65,7 +66,7 @@ impl<'tcx> LateLintPass<'tcx> for RepeatOnce {
                         format!("{}.to_vec()", snippet(cx, receiver.span, r#""...""#)),
                         Applicability::MachineApplicable,
                     );
-                } else if is_type_diagnostic_item(cx, ty, sym!(string_type)) {
+                } else if is_type_diagnostic_item(cx, ty, sym::string_type) {
                     span_lint_and_sugg(
                         cx,
                         REPEAT_ONCE,
diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
index a6e4252a0c8..7f4913a02cb 100644
--- a/clippy_lints/src/returns.rs
+++ b/clippy_lints/src/returns.rs
@@ -9,6 +9,7 @@ use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::subst::GenericArgKind;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
+use rustc_span::sym;
 
 use crate::utils::{fn_def_id, in_macro, match_qpath, snippet_opt, span_lint_and_sugg, span_lint_and_then};
 
@@ -141,7 +142,7 @@ impl<'tcx> LateLintPass<'tcx> for Return {
 }
 
 fn attr_is_cfg(attr: &Attribute) -> bool {
-    attr.meta_item_list().is_some() && attr.has_name(sym!(cfg))
+    attr.meta_item_list().is_some() && attr.has_name(sym::cfg)
 }
 
 fn check_block_return<'tcx>(cx: &LateContext<'tcx>, block: &Block<'tcx>) {
diff --git a/clippy_lints/src/strings.rs b/clippy_lints/src/strings.rs
index 3783bd78de2..0dd2da949c4 100644
--- a/clippy_lints/src/strings.rs
+++ b/clippy_lints/src/strings.rs
@@ -4,6 +4,7 @@ use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Spanned;
+use rustc_span::sym;
 
 use if_chain::if_chain;
 
@@ -154,7 +155,7 @@ impl<'tcx> LateLintPass<'tcx> for StringAdd {
 }
 
 fn is_string(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
-    is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(e).peel_refs(), sym!(string_type))
+    is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(e).peel_refs(), sym::string_type)
 }
 
 fn is_add(cx: &LateContext<'_>, src: &Expr<'_>, target: &Expr<'_>) -> bool {
diff --git a/clippy_lints/src/swap.rs b/clippy_lints/src/swap.rs
index 54b38d9f4ce..386987eb181 100644
--- a/clippy_lints/src/swap.rs
+++ b/clippy_lints/src/swap.rs
@@ -8,6 +8,7 @@ use rustc_hir::{Block, Expr, ExprKind, PatKind, QPath, StmtKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::sym;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for manual swapping.
@@ -197,7 +198,7 @@ fn check_for_slice<'a>(cx: &LateContext<'_>, lhs1: &'a Expr<'_>, lhs2: &'a Expr<
 
                 if matches!(ty.kind(), ty::Slice(_))
                     || matches!(ty.kind(), ty::Array(_, _))
-                    || is_type_diagnostic_item(cx, ty, sym!(vec_type))
+                    || is_type_diagnostic_item(cx, ty, sym::vec_type)
                     || is_type_diagnostic_item(cx, ty, sym!(vecdeque_type))
                 {
                     return Slice::Swappable(lhs1, idx1, idx2);
diff --git a/clippy_lints/src/try_err.rs b/clippy_lints/src/try_err.rs
index 3e747ec4ad9..6f6b6999bf0 100644
--- a/clippy_lints/src/try_err.rs
+++ b/clippy_lints/src/try_err.rs
@@ -9,6 +9,7 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::{self, Ty};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::sym;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for usages of `Err(x)?`.
@@ -133,7 +134,7 @@ fn find_return_type<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx ExprKind<'_>) -> O
 fn result_error_type<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Option<Ty<'tcx>> {
     if_chain! {
         if let ty::Adt(_, subst) = ty.kind();
-        if is_type_diagnostic_item(cx, ty, sym!(result_type));
+        if is_type_diagnostic_item(cx, ty, sym::result_type);
         let err_ty = subst.type_at(1);
         then {
             Some(err_ty)
@@ -151,7 +152,7 @@ fn poll_result_error_type<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Option<
         let ready_ty = subst.type_at(0);
 
         if let ty::Adt(ready_def, ready_subst) = ready_ty.kind();
-        if cx.tcx.is_diagnostic_item(sym!(result_type), ready_def.did);
+        if cx.tcx.is_diagnostic_item(sym::result_type, ready_def.did);
         let err_ty = ready_subst.type_at(1);
 
         then {
@@ -170,11 +171,11 @@ fn poll_option_result_error_type<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) ->
         let ready_ty = subst.type_at(0);
 
         if let ty::Adt(ready_def, ready_subst) = ready_ty.kind();
-        if cx.tcx.is_diagnostic_item(sym!(option_type), ready_def.did);
+        if cx.tcx.is_diagnostic_item(sym::option_type, ready_def.did);
         let some_ty = ready_subst.type_at(0);
 
         if let ty::Adt(some_def, some_subst) = some_ty.kind();
-        if cx.tcx.is_diagnostic_item(sym!(result_type), some_def.did);
+        if cx.tcx.is_diagnostic_item(sym::result_type, some_def.did);
         let err_ty = some_subst.type_at(1);
 
         then {
diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs
index 45f3bc3ea85..c7d82da3b8b 100644
--- a/clippy_lints/src/types.rs
+++ b/clippy_lints/src/types.rs
@@ -522,7 +522,7 @@ impl Types {
                             );
                             return; // don't recurse into the type
                         }
-                    } else if cx.tcx.is_diagnostic_item(sym!(vec_type), def_id) {
+                    } else if cx.tcx.is_diagnostic_item(sym::vec_type, def_id) {
                         if_chain! {
                             // Get the _ part of Vec<_>
                             if let Some(ref last) = last_path_segment(qpath).args;
@@ -559,7 +559,7 @@ impl Types {
                                 return; // don't recurse into the type
                             }
                         }
-                    } else if cx.tcx.is_diagnostic_item(sym!(option_type), def_id) {
+                    } else if cx.tcx.is_diagnostic_item(sym::option_type, def_id) {
                         if match_type_parameter(cx, qpath, &paths::OPTION).is_some() {
                             span_lint(
                                 cx,
@@ -1610,7 +1610,7 @@ fn is_c_void(cx: &LateContext<'_>, ty: Ty<'_>) -> bool {
         if names.is_empty() {
             return false;
         }
-        if names[0] == sym!(libc) || names[0] == sym::core && *names.last().unwrap() == sym!(c_void) {
+        if names[0] == sym::libc || names[0] == sym::core && *names.last().unwrap() == sym!(c_void) {
             return true;
         }
     }
@@ -2777,7 +2777,7 @@ impl<'a, 'b, 'tcx> Visitor<'tcx> for ImplicitHasherConstructorVisitor<'a, 'b, 't
                 }
 
                 if match_path(ty_path, &paths::HASHMAP) {
-                    if method.ident.name == sym!(new) {
+                    if method.ident.name == sym::new {
                         self.suggestions
                             .insert(e.span, "HashMap::default()".to_string());
                     } else if method.ident.name == sym!(with_capacity) {
@@ -2790,7 +2790,7 @@ impl<'a, 'b, 'tcx> Visitor<'tcx> for ImplicitHasherConstructorVisitor<'a, 'b, 't
                         );
                     }
                 } else if match_path(ty_path, &paths::HASHSET) {
-                    if method.ident.name == sym!(new) {
+                    if method.ident.name == sym::new {
                         self.suggestions
                             .insert(e.span, "HashSet::default()".to_string());
                     } else if method.ident.name == sym!(with_capacity) {
diff --git a/clippy_lints/src/unnecessary_sort_by.rs b/clippy_lints/src/unnecessary_sort_by.rs
index 1307237dbc7..0bccfc15678 100644
--- a/clippy_lints/src/unnecessary_sort_by.rs
+++ b/clippy_lints/src/unnecessary_sort_by.rs
@@ -6,6 +6,7 @@ use rustc_hir::{Expr, ExprKind, Mutability, Param, Pat, PatKind, Path, PathSegme
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{self, subst::GenericArgKind};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::sym;
 use rustc_span::symbol::Ident;
 
 declare_clippy_lint! {
@@ -175,7 +176,7 @@ fn detect_lint(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<LintTrigger> {
         if let name = name_ident.ident.name.to_ident_string();
         if name == "sort_by" || name == "sort_unstable_by";
         if let [vec, Expr { kind: ExprKind::Closure(_, _, closure_body_id, _, _), .. }] = args;
-        if utils::is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(vec), sym!(vec_type));
+        if utils::is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(vec), sym::vec_type);
         if let closure_body = cx.tcx.hir().body(*closure_body_id);
         if let &[
             Param { pat: Pat { kind: PatKind::Binding(_, _, left_ident, _), .. }, ..},
diff --git a/clippy_lints/src/unwrap.rs b/clippy_lints/src/unwrap.rs
index ea4b8172c9c..f4a77e54dd1 100644
--- a/clippy_lints/src/unwrap.rs
+++ b/clippy_lints/src/unwrap.rs
@@ -11,6 +11,7 @@ use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::Ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
+use rustc_span::sym;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for calls of `unwrap[_err]()` that cannot fail.
@@ -92,11 +93,11 @@ fn collect_unwrap_info<'tcx>(
     invert: bool,
 ) -> Vec<UnwrapInfo<'tcx>> {
     fn is_relevant_option_call(cx: &LateContext<'_>, ty: Ty<'_>, method_name: &str) -> bool {
-        is_type_diagnostic_item(cx, ty, sym!(option_type)) && ["is_some", "is_none"].contains(&method_name)
+        is_type_diagnostic_item(cx, ty, sym::option_type) && ["is_some", "is_none"].contains(&method_name)
     }
 
     fn is_relevant_result_call(cx: &LateContext<'_>, ty: Ty<'_>, method_name: &str) -> bool {
-        is_type_diagnostic_item(cx, ty, sym!(result_type)) && ["is_ok", "is_err"].contains(&method_name)
+        is_type_diagnostic_item(cx, ty, sym::result_type) && ["is_ok", "is_err"].contains(&method_name)
     }
 
     if let ExprKind::Binary(op, left, right) = &expr.kind {
@@ -168,8 +169,8 @@ impl<'a, 'tcx> Visitor<'tcx> for UnwrappableVariablesVisitor<'a, 'tcx> {
             if_chain! {
                 if let ExprKind::MethodCall(ref method_name, _, ref args, _) = expr.kind;
                 if let ExprKind::Path(QPath::Resolved(None, ref path)) = args[0].kind;
-                if [sym!(unwrap), sym!(unwrap_err)].contains(&method_name.ident.name);
-                let call_to_unwrap = method_name.ident.name == sym!(unwrap);
+                if [sym::unwrap, sym!(unwrap_err)].contains(&method_name.ident.name);
+                let call_to_unwrap = method_name.ident.name == sym::unwrap;
                 if let Some(unwrappable) = self.unwrappables.iter()
                     .find(|u| u.ident.res == path.res);
                 // Span contexts should not differ with the conditional branch
diff --git a/clippy_lints/src/unwrap_in_result.rs b/clippy_lints/src/unwrap_in_result.rs
index 0f8797243ec..fde31029330 100644
--- a/clippy_lints/src/unwrap_in_result.rs
+++ b/clippy_lints/src/unwrap_in_result.rs
@@ -5,7 +5,7 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::map::Map;
 use rustc_middle::ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::Span;
+use rustc_span::{sym, Span};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for functions of type Result that contain `expect()` or `unwrap()`
@@ -57,8 +57,8 @@ impl<'tcx> LateLintPass<'tcx> for UnwrapInResult {
             // first check if it's a method or function
             if let hir::ImplItemKind::Fn(ref _signature, _) = impl_item.kind;
             // checking if its return type is `result` or `option`
-            if is_type_diagnostic_item(cx, return_ty(cx, impl_item.hir_id), sym!(result_type))
-                || is_type_diagnostic_item(cx, return_ty(cx, impl_item.hir_id), sym!(option_type));
+            if is_type_diagnostic_item(cx, return_ty(cx, impl_item.hir_id), sym::result_type)
+                || is_type_diagnostic_item(cx, return_ty(cx, impl_item.hir_id), sym::option_type);
             then {
                 lint_impl_body(cx, impl_item.span, impl_item);
             }
@@ -82,8 +82,8 @@ impl<'a, 'tcx> Visitor<'tcx> for FindExpectUnwrap<'a, 'tcx> {
         // check for `expect`
         if let Some(arglists) = method_chain_args(expr, &["expect"]) {
             let reciever_ty = self.typeck_results.expr_ty(&arglists[0][0]).peel_refs();
-            if is_type_diagnostic_item(self.lcx, reciever_ty, sym!(option_type))
-                || is_type_diagnostic_item(self.lcx, reciever_ty, sym!(result_type))
+            if is_type_diagnostic_item(self.lcx, reciever_ty, sym::option_type)
+                || is_type_diagnostic_item(self.lcx, reciever_ty, sym::result_type)
             {
                 self.result.push(expr.span);
             }
@@ -92,8 +92,8 @@ impl<'a, 'tcx> Visitor<'tcx> for FindExpectUnwrap<'a, 'tcx> {
         // check for `unwrap`
         if let Some(arglists) = method_chain_args(expr, &["unwrap"]) {
             let reciever_ty = self.typeck_results.expr_ty(&arglists[0][0]).peel_refs();
-            if is_type_diagnostic_item(self.lcx, reciever_ty, sym!(option_type))
-                || is_type_diagnostic_item(self.lcx, reciever_ty, sym!(result_type))
+            if is_type_diagnostic_item(self.lcx, reciever_ty, sym::option_type)
+                || is_type_diagnostic_item(self.lcx, reciever_ty, sym::result_type)
             {
                 self.result.push(expr.span);
             }
diff --git a/clippy_lints/src/useless_conversion.rs b/clippy_lints/src/useless_conversion.rs
index 4e4a206a583..c6194b0c6de 100644
--- a/clippy_lints/src/useless_conversion.rs
+++ b/clippy_lints/src/useless_conversion.rs
@@ -9,6 +9,7 @@ use rustc_hir::{Expr, ExprKind, HirId, MatchSource};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{self, TyS};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::sym;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for `Into`, `TryInto`, `From`, `TryFrom`,`IntoIter` calls
@@ -106,7 +107,7 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
                     if_chain! {
                         let a = cx.typeck_results().expr_ty(e);
                         let b = cx.typeck_results().expr_ty(&args[0]);
-                        if is_type_diagnostic_item(cx, a, sym!(result_type));
+                        if is_type_diagnostic_item(cx, a, sym::result_type);
                         if let ty::Adt(_, substs) = a.kind();
                         if let Some(a_type) = substs.types().next();
                         if TyS::same_type(a_type, b);
@@ -136,7 +137,7 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
                     then {
                         if_chain! {
                             if match_def_path(cx, def_id, &paths::TRY_FROM);
-                            if is_type_diagnostic_item(cx, a, sym!(result_type));
+                            if is_type_diagnostic_item(cx, a, sym::result_type);
                             if let ty::Adt(_, substs) = a.kind();
                             if let Some(a_type) = substs.types().next();
                             if TyS::same_type(a_type, b);
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index 0a8a4a5f9ae..85e7f055e79 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -52,6 +52,7 @@ use rustc_middle::ty::subst::{GenericArg, GenericArgKind};
 use rustc_middle::ty::{self, layout::IntegerExt, Ty, TyCtxt, TypeFoldable};
 use rustc_span::hygiene::{ExpnKind, MacroKind};
 use rustc_span::source_map::original_sp;
+use rustc_span::sym as rustc_sym;
 use rustc_span::symbol::{self, kw, Symbol};
 use rustc_span::{BytePos, Pos, Span, DUMMY_SP};
 use rustc_target::abi::Integer;
@@ -974,7 +975,7 @@ pub fn is_refutable(cx: &LateContext<'_>, pat: &Pat<'_>) -> bool {
 /// Checks for the `#[automatically_derived]` attribute all `#[derive]`d
 /// implementations have.
 pub fn is_automatically_derived(attrs: &[ast::Attribute]) -> bool {
-    attrs.iter().any(|attr| attr.has_name(sym!(automatically_derived)))
+    attrs.iter().any(|attr| attr.has_name(rustc_sym::automatically_derived))
 }
 
 /// Remove blocks around an expression.
diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs
index d9d60fffcd7..ff414f748ef 100644
--- a/clippy_lints/src/write.rs
+++ b/clippy_lints/src/write.rs
@@ -10,8 +10,7 @@ use rustc_lexer::unescape::{self, EscapeError};
 use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_parse::parser;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::symbol::Symbol;
-use rustc_span::{BytePos, Span};
+use rustc_span::{sym, BytePos, Span, Symbol};
 
 declare_clippy_lint! {
     /// **What it does:** This lint warns when you use `println!("")` to
@@ -224,7 +223,7 @@ impl EarlyLintPass for Write {
                 .expect("path has at least one segment")
                 .ident
                 .name;
-            if trait_name == sym!(Debug) {
+            if trait_name == sym::Debug {
                 self.in_debug_impl = true;
             }
         }
-- 
cgit 1.4.1-3-g733a5


From b2332a7357b5da7220592aea4c711609eed54ef7 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Mon, 2 Nov 2020 11:47:17 -0600
Subject: Change lint to use const sym

---
 clippy_lints/src/utils/internal_lints.rs | 4 ++--
 tests/ui/match_type_on_diag_item.stderr  | 8 ++++----
 2 files changed, 6 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs
index 6ca72d895c8..8b59a9541a7 100644
--- a/clippy_lints/src/utils/internal_lints.rs
+++ b/clippy_lints/src/utils/internal_lints.rs
@@ -225,7 +225,7 @@ declare_clippy_lint! {
     ///
     /// Good:
     /// ```rust,ignore
-    /// utils::is_type_diagnostic_item(cx, ty, sym!(vec_type))
+    /// utils::is_type_diagnostic_item(cx, ty, sym::vec_type)
     /// ```
     pub MATCH_TYPE_ON_DIAGNOSTIC_ITEM,
     internal,
@@ -724,7 +724,7 @@ impl<'tcx> LateLintPass<'tcx> for MatchTypeOnDiagItem {
                     expr.span,
                     "usage of `utils::match_type()` on a type diagnostic item",
                     "try",
-                    format!("utils::is_type_diagnostic_item({}, {}, sym!({}))", cx_snippet, ty_snippet, item_name),
+                    format!("utils::is_type_diagnostic_item({}, {}, sym::{})", cx_snippet, ty_snippet, item_name),
                     Applicability::MaybeIncorrect,
                 );
             }
diff --git a/tests/ui/match_type_on_diag_item.stderr b/tests/ui/match_type_on_diag_item.stderr
index 5e5fe9e3a3e..82465dbaf6e 100644
--- a/tests/ui/match_type_on_diag_item.stderr
+++ b/tests/ui/match_type_on_diag_item.stderr
@@ -2,7 +2,7 @@ error: usage of `utils::match_type()` on a type diagnostic item
   --> $DIR/match_type_on_diag_item.rs:41:17
    |
 LL |         let _ = match_type(cx, ty, &paths::VEC);
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `utils::is_type_diagnostic_item(cx, ty, sym!(vec_type))`
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `utils::is_type_diagnostic_item(cx, ty, sym::vec_type)`
    |
 note: the lint level is defined here
   --> $DIR/match_type_on_diag_item.rs:1:9
@@ -15,19 +15,19 @@ error: usage of `utils::match_type()` on a type diagnostic item
   --> $DIR/match_type_on_diag_item.rs:42:17
    |
 LL |         let _ = match_type(cx, ty, &OPTION);
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `utils::is_type_diagnostic_item(cx, ty, sym!(option_type))`
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `utils::is_type_diagnostic_item(cx, ty, sym::option_type)`
 
 error: usage of `utils::match_type()` on a type diagnostic item
   --> $DIR/match_type_on_diag_item.rs:43:17
    |
 LL |         let _ = match_type(cx, ty, &["core", "result", "Result"]);
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `utils::is_type_diagnostic_item(cx, ty, sym!(result_type))`
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `utils::is_type_diagnostic_item(cx, ty, sym::result_type)`
 
 error: usage of `utils::match_type()` on a type diagnostic item
   --> $DIR/match_type_on_diag_item.rs:46:17
    |
 LL |         let _ = utils::match_type(cx, ty, rc_path);
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `utils::is_type_diagnostic_item(cx, ty, sym!(Rc))`
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `utils::is_type_diagnostic_item(cx, ty, sym::Rc)`
 
 error: aborting due to 4 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From a6611de75a9c6cf8b0ccfa371491a646a743667f Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Mon, 2 Nov 2020 12:55:05 -0600
Subject: Include bindings as machine applicable

---
 clippy_lints/src/methods/unnecessary_lazy_eval.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/unnecessary_lazy_eval.rs b/clippy_lints/src/methods/unnecessary_lazy_eval.rs
index aec1b7e2e46..fe54a238aa4 100644
--- a/clippy_lints/src/methods/unnecessary_lazy_eval.rs
+++ b/clippy_lints/src/methods/unnecessary_lazy_eval.rs
@@ -35,7 +35,8 @@ pub(super) fn lint<'tcx>(
                 let applicability = if body
                     .params
                     .iter()
-                    .all(|param| matches!(param.pat.kind, hir::PatKind::Wild))
+                    // bindings are checked to be unused above
+                    .all(|param| matches!(param.pat.kind, hir::PatKind::Binding(..) | hir::PatKind::Wild))
                 {
                     Applicability::MachineApplicable
                 } else {
-- 
cgit 1.4.1-3-g733a5


From 315bab0ea186d5324fba28ccd5db82ecc7996cc4 Mon Sep 17 00:00:00 2001
From: Piti the little Light <djhlinacz@gmail.com>
Date: Thu, 10 Sep 2020 20:14:23 +0200
Subject: Add `from_iter_instead_of_collect` lint implementation

---
 clippy_lints/src/methods/mod.rs | 59 +++++++++++++++++++++++++++++++++++++++++
 clippy_lints/src/utils/paths.rs |  1 +
 2 files changed, 60 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 3c3093e869c..93b5d4e7efc 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1369,6 +1369,38 @@ declare_clippy_lint! {
     "using `.map(_).collect::<Result<(),_>()`, which can be replaced with `try_for_each`"
 }
 
+declare_clippy_lint! {
+    /// **What it does:** Checks for `from_iter()` function calls that implements `FromIterator`
+    /// trait.
+    ///
+    /// **Why is this bad?** Makes code less readable especially in method chaining.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// use std::iter::FromIterator;
+    ///
+    /// let five_fives = std::iter::repeat(5).take(5);
+    ///
+    /// let v = Vec::from_iter(five_fives);
+    ///
+    /// assert_eq!(v, vec![5, 5, 5, 5, 5]);
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// let five_fives = std::iter::repeat(5).take(5);
+    ///
+    /// let v: Vec<i32> = five_fives.collect();
+    ///
+    /// assert_eq!(v, vec![5, 5, 5, 5, 5]);
+    /// ```
+    pub FROM_ITER_INSTEAD_OF_COLLECT,
+    style,
+    "use `.collect()` instead of `::from_iter()`"
+}
+
 declare_lint_pass!(Methods => [
     UNWRAP_USED,
     EXPECT_USED,
@@ -1419,6 +1451,7 @@ declare_lint_pass!(Methods => [
     OPTION_AS_REF_DEREF,
     UNNECESSARY_LAZY_EVALUATIONS,
     MAP_COLLECT_RESULT_UNIT,
+    FROM_ITER_INSTEAD_OF_COLLECT,
 ]);
 
 impl<'tcx> LateLintPass<'tcx> for Methods {
@@ -1505,6 +1538,14 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
         }
 
         match expr.kind {
+            hir::ExprKind::Call(ref func, ref args) => {
+                if let hir::ExprKind::Path(path) = &func.kind {
+                    let path_segment = last_path_segment(path);
+                    if path_segment.ident.name.as_str() == "from_iter" {
+                        lint_from_iter(cx, expr, args);
+                    }
+                }
+            },
             hir::ExprKind::MethodCall(ref method_call, ref method_span, ref args, _) => {
                 lint_or_fun_call(cx, expr, *method_span, &method_call.ident.as_str(), args);
                 lint_expect_fun_call(cx, expr, *method_span, &method_call.ident.as_str(), args);
@@ -3831,6 +3872,24 @@ fn lint_filetype_is_file(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir
     span_lint_and_help(cx, FILETYPE_IS_FILE, span, &lint_msg, None, &help_msg);
 }
 
+fn lint_from_iter(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::Expr<'_>]) {
+    let ty = cx.typeck_results().expr_ty(expr);
+    let id = get_trait_def_id(cx, &paths::FROM_ITERATOR_TRAIT).unwrap();
+
+    if implements_trait(cx, ty, id, &[]) {
+        // `expr` implements `FromIterator` trait
+        let iter_expr = snippet(cx, args[0].span, "..");
+        span_lint_and_help(
+            cx,
+            FROM_ITER_INSTEAD_OF_COLLECT,
+            expr.span,
+            "use `.collect()` instead of `::from_iter()`",
+            None,
+            &format!("consider using `{}.collect()`", iter_expr),
+        );
+    }
+}
+
 fn fn_header_equals(expected: hir::FnHeader, actual: hir::FnHeader) -> bool {
     expected.constness == actual.constness
         && expected.unsafety == actual.unsafety
diff --git a/clippy_lints/src/utils/paths.rs b/clippy_lints/src/utils/paths.rs
index 736a531eda6..3aade8ca8a2 100644
--- a/clippy_lints/src/utils/paths.rs
+++ b/clippy_lints/src/utils/paths.rs
@@ -44,6 +44,7 @@ pub const FN: [&str; 3] = ["core", "ops", "Fn"];
 pub const FN_MUT: [&str; 3] = ["core", "ops", "FnMut"];
 pub const FN_ONCE: [&str; 3] = ["core", "ops", "FnOnce"];
 pub const FROM_FROM: [&str; 4] = ["core", "convert", "From", "from"];
+pub const FROM_ITERATOR_TRAIT: [&str; 3] = ["std", "iter", "FromIterator"];
 pub const FROM_TRAIT: [&str; 3] = ["core", "convert", "From"];
 pub const FUTURE_FROM_GENERATOR: [&str; 3] = ["core", "future", "from_generator"];
 pub const HASH: [&str; 3] = ["core", "hash", "Hash"];
-- 
cgit 1.4.1-3-g733a5


From 9d6eedf5f2fccfc94f36473012794b2c679d3ad3 Mon Sep 17 00:00:00 2001
From: Piti the little Light <djhlinacz@gmail.com>
Date: Thu, 10 Sep 2020 20:16:28 +0200
Subject: Run `cargo dev update_lints`

---
 CHANGELOG.md            | 1 +
 clippy_lints/src/lib.rs | 3 +++
 src/lintlist/mod.rs     | 7 +++++++
 3 files changed, 11 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 6b63dbb7eff..50f03126c7a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1732,6 +1732,7 @@ Released 2018-09-13
 [`for_loops_over_fallibles`]: https://rust-lang.github.io/rust-clippy/master/index.html#for_loops_over_fallibles
 [`forget_copy`]: https://rust-lang.github.io/rust-clippy/master/index.html#forget_copy
 [`forget_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#forget_ref
+[`from_iter_instead_of_collect`]: https://rust-lang.github.io/rust-clippy/master/index.html#from_iter_instead_of_collect
 [`future_not_send`]: https://rust-lang.github.io/rust-clippy/master/index.html#future_not_send
 [`get_last_with_len`]: https://rust-lang.github.io/rust-clippy/master/index.html#get_last_with_len
 [`get_unwrap`]: https://rust-lang.github.io/rust-clippy/master/index.html#get_unwrap
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 5c3af014ee1..fa4b6d11623 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -693,6 +693,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &methods::FILTER_NEXT,
         &methods::FIND_MAP,
         &methods::FLAT_MAP_IDENTITY,
+        &methods::FROM_ITER_INSTEAD_OF_COLLECT,
         &methods::GET_UNWRAP,
         &methods::INEFFICIENT_TO_STRING,
         &methods::INTO_ITER_ON_REF,
@@ -1422,6 +1423,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&methods::EXPECT_FUN_CALL),
         LintId::of(&methods::FILTER_NEXT),
         LintId::of(&methods::FLAT_MAP_IDENTITY),
+        LintId::of(&methods::FROM_ITER_INSTEAD_OF_COLLECT),
         LintId::of(&methods::INTO_ITER_ON_REF),
         LintId::of(&methods::ITERATOR_STEP_BY_ZERO),
         LintId::of(&methods::ITER_CLONED_COLLECT),
@@ -1620,6 +1622,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&mem_replace::MEM_REPLACE_WITH_DEFAULT),
         LintId::of(&methods::CHARS_LAST_CMP),
         LintId::of(&methods::CHARS_NEXT_CMP),
+        LintId::of(&methods::FROM_ITER_INSTEAD_OF_COLLECT),
         LintId::of(&methods::INTO_ITER_ON_REF),
         LintId::of(&methods::ITER_CLONED_COLLECT),
         LintId::of(&methods::ITER_NEXT_SLICE),
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index 016bda77ef5..7a1ebc3d2dd 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -753,6 +753,13 @@ vec![
         deprecation: None,
         module: "drop_forget_ref",
     },
+    Lint {
+        name: "from_iter_instead_of_collect",
+        group: "style",
+        desc: "use `.collect()` instead of `::from_iter()`",
+        deprecation: None,
+        module: "methods",
+    },
     Lint {
         name: "future_not_send",
         group: "nursery",
-- 
cgit 1.4.1-3-g733a5


From 8a5d78b71a71317314d7dccef7c73b523f0a44c2 Mon Sep 17 00:00:00 2001
From: Piti the little Light <djhlinacz@gmail.com>
Date: Fri, 11 Sep 2020 13:29:52 +0200
Subject: Fix `from_iter_instead_of_collect` lint crashing on exprs without
 path segment

---
 clippy_lints/src/methods/mod.rs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 93b5d4e7efc..c0c39dae865 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1540,8 +1540,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
         match expr.kind {
             hir::ExprKind::Call(ref func, ref args) => {
                 if let hir::ExprKind::Path(path) = &func.kind {
-                    let path_segment = last_path_segment(path);
-                    if path_segment.ident.name.as_str() == "from_iter" {
+                    if match_qpath(path, &["from_iter"]) {
                         lint_from_iter(cx, expr, args);
                     }
                 }
-- 
cgit 1.4.1-3-g733a5


From 8906040445a6700be2aaf40ec09937b84dea5d6a Mon Sep 17 00:00:00 2001
From: Piti the little Light <djhlinacz@gmail.com>
Date: Thu, 1 Oct 2020 18:04:05 +0200
Subject: Improvements from PR feedback

---
 clippy_lints/src/methods/mod.rs              | 14 ++++++++------
 clippy_lints/src/utils/paths.rs              |  2 +-
 tests/ui/from_iter_instead_of_collect.rs     | 10 +++-------
 tests/ui/from_iter_instead_of_collect.stderr | 15 ++++++---------
 tests/ui/from_iter_instead_of_collect.stdout |  0
 5 files changed, 18 insertions(+), 23 deletions(-)
 delete mode 100644 tests/ui/from_iter_instead_of_collect.stdout

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index c0c39dae865..70be8909c43 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1370,10 +1370,11 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for `from_iter()` function calls that implements `FromIterator`
+    /// **What it does:** Checks for `from_iter()` function calls on types that implement the `FromIterator`
     /// trait.
     ///
-    /// **Why is this bad?** Makes code less readable especially in method chaining.
+    /// **Why is this bad?** It is recommended style to use collect. See
+    /// [FromIterator documentation](https://doc.rust-lang.org/std/iter/trait.FromIterator.html)
     ///
     /// **Known problems:** None.
     ///
@@ -3873,18 +3874,19 @@ fn lint_filetype_is_file(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir
 
 fn lint_from_iter(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::Expr<'_>]) {
     let ty = cx.typeck_results().expr_ty(expr);
-    let id = get_trait_def_id(cx, &paths::FROM_ITERATOR_TRAIT).unwrap();
+    let id = get_trait_def_id(cx, &paths::FROM_ITERATOR).unwrap();
 
     if implements_trait(cx, ty, id, &[]) {
         // `expr` implements `FromIterator` trait
         let iter_expr = snippet(cx, args[0].span, "..");
-        span_lint_and_help(
+        span_lint_and_sugg(
             cx,
             FROM_ITER_INSTEAD_OF_COLLECT,
             expr.span,
             "use `.collect()` instead of `::from_iter()`",
-            None,
-            &format!("consider using `{}.collect()`", iter_expr),
+            "consider using",
+            format!("`{}.collect()`", iter_expr),
+            Applicability::MaybeIncorrect
         );
     }
 }
diff --git a/clippy_lints/src/utils/paths.rs b/clippy_lints/src/utils/paths.rs
index 3aade8ca8a2..8afbd8930b6 100644
--- a/clippy_lints/src/utils/paths.rs
+++ b/clippy_lints/src/utils/paths.rs
@@ -44,7 +44,7 @@ pub const FN: [&str; 3] = ["core", "ops", "Fn"];
 pub const FN_MUT: [&str; 3] = ["core", "ops", "FnMut"];
 pub const FN_ONCE: [&str; 3] = ["core", "ops", "FnOnce"];
 pub const FROM_FROM: [&str; 4] = ["core", "convert", "From", "from"];
-pub const FROM_ITERATOR_TRAIT: [&str; 3] = ["std", "iter", "FromIterator"];
+pub const FROM_ITERATOR: [&str; 3] = ["std", "iter", "FromIterator"];
 pub const FROM_TRAIT: [&str; 3] = ["core", "convert", "From"];
 pub const FUTURE_FROM_GENERATOR: [&str; 3] = ["core", "future", "from_generator"];
 pub const HASH: [&str; 3] = ["core", "hash", "Hash"];
diff --git a/tests/ui/from_iter_instead_of_collect.rs b/tests/ui/from_iter_instead_of_collect.rs
index 7a1bc64f4bd..9071be33c64 100644
--- a/tests/ui/from_iter_instead_of_collect.rs
+++ b/tests/ui/from_iter_instead_of_collect.rs
@@ -4,12 +4,8 @@ use std::collections::HashMap;
 use std::iter::FromIterator;
 
 fn main() {
-    {
-        let iter_expr = std::iter::repeat(5).take(5);
+    let iter_expr = std::iter::repeat(5).take(5);
 
-        Vec::from_iter(iter_expr);
-        HashMap::<usize, &i8>::from_iter(vec![5, 5, 5, 5].iter().enumerate());
-        //let v: Vec<i32> = iter_expr.collect();
-        let a: Vec<i32> = Vec::new();
-    }
+    Vec::from_iter(iter_expr);
+    HashMap::<usize, &i8>::from_iter(vec![5, 5, 5, 5].iter().enumerate());
 }
diff --git a/tests/ui/from_iter_instead_of_collect.stderr b/tests/ui/from_iter_instead_of_collect.stderr
index cfb92dfbbfd..1bc787aa795 100644
--- a/tests/ui/from_iter_instead_of_collect.stderr
+++ b/tests/ui/from_iter_instead_of_collect.stderr
@@ -1,19 +1,16 @@
 error: use `.collect()` instead of `::from_iter()`
-  --> $DIR/from_iter_instead_of_collect.rs:10:9
+  --> $DIR/from_iter_instead_of_collect.rs:9:5
    |
-LL |         Vec::from_iter(iter_expr);
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |     Vec::from_iter(iter_expr);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: ``iter_expr.collect()``
    |
    = note: `-D clippy::from-iter-instead-of-collect` implied by `-D warnings`
-   = help: consider using `iter_expr.collect()`
 
 error: use `.collect()` instead of `::from_iter()`
-  --> $DIR/from_iter_instead_of_collect.rs:11:9
+  --> $DIR/from_iter_instead_of_collect.rs:10:5
    |
-LL |         HashMap::<usize, &i8>::from_iter(vec![5, 5, 5, 5].iter().enumerate());
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: consider using `vec![5, 5, 5, 5].iter().enumerate().collect()`
+LL |     HashMap::<usize, &i8>::from_iter(vec![5, 5, 5, 5].iter().enumerate());
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: ``vec![5, 5, 5, 5].iter().enumerate().collect()``
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/from_iter_instead_of_collect.stdout b/tests/ui/from_iter_instead_of_collect.stdout
deleted file mode 100644
index e69de29bb2d..00000000000
-- 
cgit 1.4.1-3-g733a5


From e320dd30428aeb85577b36afa594429a41bc07f6 Mon Sep 17 00:00:00 2001
From: Piti the little Light <djhlinacz@gmail.com>
Date: Thu, 1 Oct 2020 18:34:36 +0200
Subject: Improve: error message

---
 clippy_lints/src/utils/paths.rs              | 2 +-
 tests/ui/from_iter_instead_of_collect.rs     | 2 +-
 tests/ui/from_iter_instead_of_collect.stderr | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/paths.rs b/clippy_lints/src/utils/paths.rs
index 8afbd8930b6..95fe8733421 100644
--- a/clippy_lints/src/utils/paths.rs
+++ b/clippy_lints/src/utils/paths.rs
@@ -44,7 +44,7 @@ pub const FN: [&str; 3] = ["core", "ops", "Fn"];
 pub const FN_MUT: [&str; 3] = ["core", "ops", "FnMut"];
 pub const FN_ONCE: [&str; 3] = ["core", "ops", "FnOnce"];
 pub const FROM_FROM: [&str; 4] = ["core", "convert", "From", "from"];
-pub const FROM_ITERATOR: [&str; 3] = ["std", "iter", "FromIterator"];
+pub const FROM_ITERATOR: [&str; 5] = ["core", "iter", "traits", "collect", "FromIterator"];
 pub const FROM_TRAIT: [&str; 3] = ["core", "convert", "From"];
 pub const FUTURE_FROM_GENERATOR: [&str; 3] = ["core", "future", "from_generator"];
 pub const HASH: [&str; 3] = ["core", "hash", "Hash"];
diff --git a/tests/ui/from_iter_instead_of_collect.rs b/tests/ui/from_iter_instead_of_collect.rs
index 9071be33c64..25b87a0a903 100644
--- a/tests/ui/from_iter_instead_of_collect.rs
+++ b/tests/ui/from_iter_instead_of_collect.rs
@@ -5,7 +5,7 @@ use std::iter::FromIterator;
 
 fn main() {
     let iter_expr = std::iter::repeat(5).take(5);
-
     Vec::from_iter(iter_expr);
+
     HashMap::<usize, &i8>::from_iter(vec![5, 5, 5, 5].iter().enumerate());
 }
diff --git a/tests/ui/from_iter_instead_of_collect.stderr b/tests/ui/from_iter_instead_of_collect.stderr
index 1bc787aa795..3263005d7ec 100644
--- a/tests/ui/from_iter_instead_of_collect.stderr
+++ b/tests/ui/from_iter_instead_of_collect.stderr
@@ -1,5 +1,5 @@
 error: use `.collect()` instead of `::from_iter()`
-  --> $DIR/from_iter_instead_of_collect.rs:9:5
+  --> $DIR/from_iter_instead_of_collect.rs:8:5
    |
 LL |     Vec::from_iter(iter_expr);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: ``iter_expr.collect()``
-- 
cgit 1.4.1-3-g733a5


From 854f2cef06f60b37a3176b17b27c1104692f6255 Mon Sep 17 00:00:00 2001
From: Piti the little Light <djhlinacz@gmail.com>
Date: Thu, 1 Oct 2020 18:36:49 +0200
Subject: Run `cargo dev fmt`

---
 clippy_lints/src/methods/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 70be8909c43..013ed67b8e5 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3886,7 +3886,7 @@ fn lint_from_iter(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::Expr<
             "use `.collect()` instead of `::from_iter()`",
             "consider using",
             format!("`{}.collect()`", iter_expr),
-            Applicability::MaybeIncorrect
+            Applicability::MaybeIncorrect,
         );
     }
 }
-- 
cgit 1.4.1-3-g733a5


From abdb7aeb55461f0355829be49a09ed86af066ae8 Mon Sep 17 00:00:00 2001
From: Piti the little Light <djhlinacz@gmail.com>
Date: Thu, 1 Oct 2020 18:44:12 +0200
Subject: Remove backticks

---
 clippy_lints/src/methods/mod.rs              | 2 +-
 tests/ui/from_iter_instead_of_collect.stderr | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 013ed67b8e5..2119cb28fc3 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3885,7 +3885,7 @@ fn lint_from_iter(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::Expr<
             expr.span,
             "use `.collect()` instead of `::from_iter()`",
             "consider using",
-            format!("`{}.collect()`", iter_expr),
+            format!("{}.collect()", iter_expr),
             Applicability::MaybeIncorrect,
         );
     }
diff --git a/tests/ui/from_iter_instead_of_collect.stderr b/tests/ui/from_iter_instead_of_collect.stderr
index 3263005d7ec..7f248beadbe 100644
--- a/tests/ui/from_iter_instead_of_collect.stderr
+++ b/tests/ui/from_iter_instead_of_collect.stderr
@@ -2,7 +2,7 @@ error: use `.collect()` instead of `::from_iter()`
   --> $DIR/from_iter_instead_of_collect.rs:8:5
    |
 LL |     Vec::from_iter(iter_expr);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: ``iter_expr.collect()``
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `iter_expr.collect()`
    |
    = note: `-D clippy::from-iter-instead-of-collect` implied by `-D warnings`
 
@@ -10,7 +10,7 @@ error: use `.collect()` instead of `::from_iter()`
   --> $DIR/from_iter_instead_of_collect.rs:10:5
    |
 LL |     HashMap::<usize, &i8>::from_iter(vec![5, 5, 5, 5].iter().enumerate());
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: ``vec![5, 5, 5, 5].iter().enumerate().collect()``
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `vec![5, 5, 5, 5].iter().enumerate().collect()`
 
 error: aborting due to 2 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From f359fb872b405fca196f40eadd341d1d06f1fb8b Mon Sep 17 00:00:00 2001
From: Piti the little Light <djhlinacz@gmail.com>
Date: Thu, 1 Oct 2020 19:04:19 +0200
Subject: Improve error message

---
 clippy_lints/src/methods/mod.rs              | 2 +-
 tests/ui/from_iter_instead_of_collect.stderr | 8 ++++----
 2 files changed, 5 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 2119cb28fc3..fde43f0055d 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3883,8 +3883,8 @@ fn lint_from_iter(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::Expr<
             cx,
             FROM_ITER_INSTEAD_OF_COLLECT,
             expr.span,
+            "usage of `FromIterator::from_iter`",
             "use `.collect()` instead of `::from_iter()`",
-            "consider using",
             format!("{}.collect()", iter_expr),
             Applicability::MaybeIncorrect,
         );
diff --git a/tests/ui/from_iter_instead_of_collect.stderr b/tests/ui/from_iter_instead_of_collect.stderr
index 7f248beadbe..46bdc2f4e19 100644
--- a/tests/ui/from_iter_instead_of_collect.stderr
+++ b/tests/ui/from_iter_instead_of_collect.stderr
@@ -1,16 +1,16 @@
-error: use `.collect()` instead of `::from_iter()`
+error: usage of `FromIterator::from_iter`
   --> $DIR/from_iter_instead_of_collect.rs:8:5
    |
 LL |     Vec::from_iter(iter_expr);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `iter_expr.collect()`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `iter_expr.collect()`
    |
    = note: `-D clippy::from-iter-instead-of-collect` implied by `-D warnings`
 
-error: use `.collect()` instead of `::from_iter()`
+error: usage of `FromIterator::from_iter`
   --> $DIR/from_iter_instead_of_collect.rs:10:5
    |
 LL |     HashMap::<usize, &i8>::from_iter(vec![5, 5, 5, 5].iter().enumerate());
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `vec![5, 5, 5, 5].iter().enumerate().collect()`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `vec![5, 5, 5, 5].iter().enumerate().collect()`
 
 error: aborting due to 2 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 52d1ea3c9ad8ea97350ba7a0ca0a8e172cfcae78 Mon Sep 17 00:00:00 2001
From: Piti the little Light <djhlinacz@gmail.com>
Date: Mon, 12 Oct 2020 17:27:50 +0200
Subject: Fix: Don't show lint for types that doesn't implement Iterator

---
 clippy_lints/src/methods/mod.rs          | 7 +++++--
 tests/ui/from_iter_instead_of_collect.rs | 2 ++
 2 files changed, 7 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index fde43f0055d..521b151f5e1 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3874,9 +3874,12 @@ fn lint_filetype_is_file(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir
 
 fn lint_from_iter(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::Expr<'_>]) {
     let ty = cx.typeck_results().expr_ty(expr);
-    let id = get_trait_def_id(cx, &paths::FROM_ITERATOR).unwrap();
+    let arg_ty = cx.typeck_results().expr_ty(&args[0]);
 
-    if implements_trait(cx, ty, id, &[]) {
+    let from_iter_id = get_trait_def_id(cx, &paths::FROM_ITERATOR).unwrap();
+    let iter_id = get_trait_def_id(cx, &paths::ITERATOR).unwrap();
+
+    if implements_trait(cx, ty, from_iter_id, &[]) && implements_trait(cx, arg_ty, iter_id, &[]) {
         // `expr` implements `FromIterator` trait
         let iter_expr = snippet(cx, args[0].span, "..");
         span_lint_and_sugg(
diff --git a/tests/ui/from_iter_instead_of_collect.rs b/tests/ui/from_iter_instead_of_collect.rs
index 25b87a0a903..045eb3133d3 100644
--- a/tests/ui/from_iter_instead_of_collect.rs
+++ b/tests/ui/from_iter_instead_of_collect.rs
@@ -8,4 +8,6 @@ fn main() {
     Vec::from_iter(iter_expr);
 
     HashMap::<usize, &i8>::from_iter(vec![5, 5, 5, 5].iter().enumerate());
+
+    Vec::from_iter(vec![42u32]);
 }
-- 
cgit 1.4.1-3-g733a5


From ddf23d649ae02dde7aed22ec6699a736492b7184 Mon Sep 17 00:00:00 2001
From: Piti the little Light <djhlinacz@gmail.com>
Date: Sat, 24 Oct 2020 13:53:09 +0200
Subject: Fix: Use `.collect()` instead of `::fromIterator()`

---
 clippy_lints/src/lifetimes.rs | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lifetimes.rs b/clippy_lints/src/lifetimes.rs
index c8a5a9c9431..4d737b3f49b 100644
--- a/clippy_lints/src/lifetimes.rs
+++ b/clippy_lints/src/lifetimes.rs
@@ -16,7 +16,6 @@ use rustc_middle::hir::map::Map;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
 use rustc_span::symbol::{kw, Symbol};
-use std::iter::FromIterator;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for lifetime annotations which can be removed by
@@ -214,14 +213,15 @@ fn could_use_elision<'tcx>(
     }
 
     if allowed_lts
-        .intersection(&FxHashSet::from_iter(
-            input_visitor
+        .intersection(
+            &input_visitor
                 .nested_elision_site_lts
                 .iter()
                 .chain(output_visitor.nested_elision_site_lts.iter())
                 .cloned()
-                .filter(|v| matches!(v, RefLt::Named(_))),
-        ))
+                .filter(|v| matches!(v, RefLt::Named(_)))
+                .collect(),
+        )
         .next()
         .is_some()
     {
-- 
cgit 1.4.1-3-g733a5


From f5166e81b1065983de15f883ae04a81d30f75edf Mon Sep 17 00:00:00 2001
From: Eduardo Broto <ebroto@tutanota.com>
Date: Wed, 4 Nov 2020 22:41:15 +0100
Subject: Run cargo dev fmt

---
 clippy_lints/src/consts.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/consts.rs b/clippy_lints/src/consts.rs
index c8bbc9ce2b0..0035ded9356 100644
--- a/clippy_lints/src/consts.rs
+++ b/clippy_lints/src/consts.rs
@@ -7,10 +7,10 @@ use rustc_data_structures::sync::Lrc;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::{BinOp, BinOpKind, Block, Expr, ExprKind, HirId, QPath, UnOp};
 use rustc_lint::LateContext;
+use rustc_middle::mir::interpret::Scalar;
 use rustc_middle::ty::subst::{Subst, SubstsRef};
-use rustc_middle::ty::{self, Ty, TyCtxt, ScalarInt};
+use rustc_middle::ty::{self, ScalarInt, Ty, TyCtxt};
 use rustc_middle::{bug, span_bug};
-use rustc_middle::mir::interpret::Scalar;
 use rustc_span::symbol::Symbol;
 use std::cmp::Ordering::{self, Equal};
 use std::convert::TryInto;
@@ -501,7 +501,7 @@ impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
 }
 
 pub fn miri_to_const(result: &ty::Const<'_>) -> Option<Constant> {
-    use rustc_middle::mir::interpret::{ConstValue};
+    use rustc_middle::mir::interpret::ConstValue;
     match result.val {
         ty::ConstKind::Value(ConstValue::Scalar(Scalar::Int(int))) => {
             match result.ty.kind() {
-- 
cgit 1.4.1-3-g733a5


From a4acb3164ad93d8fe444783ad588a8b5d71dacd9 Mon Sep 17 00:00:00 2001
From: Urcra <urcra@urcra.com>
Date: Wed, 4 Nov 2020 23:39:52 +0100
Subject: Fix example for cargo common data

---
 clippy_lints/src/cargo_common_metadata.rs | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/cargo_common_metadata.rs b/clippy_lints/src/cargo_common_metadata.rs
index 76a000157df..0d294761af5 100644
--- a/clippy_lints/src/cargo_common_metadata.rs
+++ b/clippy_lints/src/cargo_common_metadata.rs
@@ -23,6 +23,21 @@ declare_clippy_lint! {
     /// [package]
     /// name = "clippy"
     /// version = "0.0.212"
+    /// description = "A bunch of helpful lints to avoid common pitfalls in Rust"
+    /// repository = "https://github.com/rust-lang/rust-clippy"
+    /// readme = "README.md"
+    /// license = "MIT OR Apache-2.0"
+    /// keywords = ["clippy", "lint", "plugin"]
+    /// categories = ["development-tools", "development-tools::cargo-plugins"]
+    /// ```
+    ///
+    /// Should include an authors field like:
+    ///
+    /// ```toml
+    /// # This `Cargo.toml` includes all common metadata
+    /// [package]
+    /// name = "clippy"
+    /// version = "0.0.212"
     /// authors = ["Someone <someone@rust-lang.org>"]
     /// description = "A bunch of helpful lints to avoid common pitfalls in Rust"
     /// repository = "https://github.com/rust-lang/rust-clippy"
-- 
cgit 1.4.1-3-g733a5


From bc27d1492d60ecfb0673629e28bc4bbe0b7fd886 Mon Sep 17 00:00:00 2001
From: Patrick José Pereira <patrickelectric@gmail.com>
Date: Thu, 8 Oct 2020 00:19:56 -0300
Subject: Add string_from_utf8_as_bytes linter
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: Patrick José Pereira <patrickelectric@gmail.com>
---
 CHANGELOG.md                              |  1 +
 clippy_lints/src/lib.rs                   |  3 ++
 clippy_lints/src/strings.rs               | 68 +++++++++++++++++++++++++++++--
 clippy_lints/src/utils/paths.rs           |  1 +
 src/lintlist/mod.rs                       |  7 ++++
 tests/ui/string_from_utf8_as_bytes.fixed  |  6 +++
 tests/ui/string_from_utf8_as_bytes.rs     |  6 +++
 tests/ui/string_from_utf8_as_bytes.stderr | 10 +++++
 8 files changed, 99 insertions(+), 3 deletions(-)
 create mode 100644 tests/ui/string_from_utf8_as_bytes.fixed
 create mode 100644 tests/ui/string_from_utf8_as_bytes.rs
 create mode 100644 tests/ui/string_from_utf8_as_bytes.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 6b63dbb7eff..aeccf6cf83b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1952,6 +1952,7 @@ Released 2018-09-13
 [`string_add`]: https://rust-lang.github.io/rust-clippy/master/index.html#string_add
 [`string_add_assign`]: https://rust-lang.github.io/rust-clippy/master/index.html#string_add_assign
 [`string_extend_chars`]: https://rust-lang.github.io/rust-clippy/master/index.html#string_extend_chars
+[`string_from_utf8_as_bytes`]: https://rust-lang.github.io/rust-clippy/master/index.html#string_from_utf8_as_bytes
 [`string_lit_as_bytes`]: https://rust-lang.github.io/rust-clippy/master/index.html#string_lit_as_bytes
 [`string_to_string`]: https://rust-lang.github.io/rust-clippy/master/index.html#string_to_string
 [`struct_excessive_bools`]: https://rust-lang.github.io/rust-clippy/master/index.html#struct_excessive_bools
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 5c3af014ee1..d29ba33064c 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -826,6 +826,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &stable_sort_primitive::STABLE_SORT_PRIMITIVE,
         &strings::STRING_ADD,
         &strings::STRING_ADD_ASSIGN,
+        &strings::STRING_FROM_UTF8_AS_BYTES,
         &strings::STRING_LIT_AS_BYTES,
         &suspicious_trait_impl::SUSPICIOUS_ARITHMETIC_IMPL,
         &suspicious_trait_impl::SUSPICIOUS_OP_ASSIGN_IMPL,
@@ -1515,6 +1516,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS),
         LintId::of(&slow_vector_initialization::SLOW_VECTOR_INITIALIZATION),
         LintId::of(&stable_sort_primitive::STABLE_SORT_PRIMITIVE),
+        LintId::of(&strings::STRING_FROM_UTF8_AS_BYTES),
         LintId::of(&suspicious_trait_impl::SUSPICIOUS_ARITHMETIC_IMPL),
         LintId::of(&suspicious_trait_impl::SUSPICIOUS_OP_ASSIGN_IMPL),
         LintId::of(&swap::ALMOST_SWAPPED),
@@ -1738,6 +1740,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&reference::DEREF_ADDROF),
         LintId::of(&reference::REF_IN_DEREF),
         LintId::of(&repeat_once::REPEAT_ONCE),
+        LintId::of(&strings::STRING_FROM_UTF8_AS_BYTES),
         LintId::of(&swap::MANUAL_SWAP),
         LintId::of(&temporary_assignment::TEMPORARY_ASSIGNMENT),
         LintId::of(&transmute::CROSSPOINTER_TRANSMUTE),
diff --git a/clippy_lints/src/strings.rs b/clippy_lints/src/strings.rs
index 3783bd78de2..a55df1e5502 100644
--- a/clippy_lints/src/strings.rs
+++ b/clippy_lints/src/strings.rs
@@ -1,5 +1,5 @@
 use rustc_errors::Applicability;
-use rustc_hir::{BinOpKind, Expr, ExprKind};
+use rustc_hir::{BinOpKind, BorrowKind, Expr, ExprKind, LangItem, QPath};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -8,7 +8,10 @@ use rustc_span::source_map::Spanned;
 use if_chain::if_chain;
 
 use crate::utils::SpanlessEq;
-use crate::utils::{get_parent_expr, is_allowed, is_type_diagnostic_item, span_lint, span_lint_and_sugg};
+use crate::utils::{
+    get_parent_expr, is_allowed, is_type_diagnostic_item, match_function_call, method_calls, paths, span_lint,
+    span_lint_and_sugg,
+};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for string appends of the form `x = x + y` (without
@@ -173,16 +176,75 @@ fn is_add(cx: &LateContext<'_>, src: &Expr<'_>, target: &Expr<'_>) -> bool {
     }
 }
 
+declare_clippy_lint! {
+    /// **What it does:** Check if the string is transformed to byte array and casted back to string.
+    ///
+    /// **Why is this bad?** It's unnecessary, the string can be used directly.
+    ///
+    /// **Known problems:** None
+    ///
+    /// **Example:**
+    /// ```rust
+    /// let _ = std::str::from_utf8(&"Hello World!".as_bytes()[6..11]).unwrap();
+    /// ```
+    /// could be written as
+    /// ```rust
+    /// let _ = &"Hello World!"[6..11];
+    /// ```
+    pub STRING_FROM_UTF8_AS_BYTES,
+    complexity,
+    "casting string slices to byte slices and back"
+}
+
 // Max length a b"foo" string can take
 const MAX_LENGTH_BYTE_STRING_LIT: usize = 32;
 
-declare_lint_pass!(StringLitAsBytes => [STRING_LIT_AS_BYTES]);
+declare_lint_pass!(StringLitAsBytes => [STRING_LIT_AS_BYTES, STRING_FROM_UTF8_AS_BYTES]);
 
 impl<'tcx> LateLintPass<'tcx> for StringLitAsBytes {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
         use crate::utils::{snippet, snippet_with_applicability};
         use rustc_ast::LitKind;
 
+        if_chain! {
+            // Find std::str::converts::from_utf8
+            if let Some(args) = match_function_call(cx, e, &paths::STR_FROM_UTF8);
+
+            // Find string::as_bytes
+            if let ExprKind::AddrOf(BorrowKind::Ref, _, ref args) = args[0].kind;
+            if let ExprKind::Index(ref left, ref right) = args.kind;
+            let (method_names, expressions, _) = method_calls(left, 1);
+            if method_names.len() == 1;
+            if expressions.len() == 1;
+            if expressions[0].len() == 1;
+            if method_names[0] == sym!(as_bytes);
+
+            // Check for slicer
+            if let ExprKind::Struct(ref path, _, _) = right.kind;
+            if let QPath::LangItem(LangItem::Range, _) = path;
+
+            then {
+                let mut applicability = Applicability::MachineApplicable;
+                let string_expression = &expressions[0][0];
+
+                let snippet_app = snippet_with_applicability(
+                    cx,
+                    string_expression.span, "..",
+                    &mut applicability,
+                );
+
+                span_lint_and_sugg(
+                    cx,
+                    STRING_FROM_UTF8_AS_BYTES,
+                    e.span,
+                    "calling a slice of `as_bytes()` with `from_utf8` should be not necessary",
+                    "try",
+                    format!("Some(&{}[{}])", snippet_app, snippet(cx, right.span, "..")),
+                    applicability
+                )
+            }
+        }
+
         if_chain! {
             if let ExprKind::MethodCall(path, _, args, _) = &e.kind;
             if path.ident.name == sym!(as_bytes);
diff --git a/clippy_lints/src/utils/paths.rs b/clippy_lints/src/utils/paths.rs
index cd72fdd61fd..0d0ecf9ae9f 100644
--- a/clippy_lints/src/utils/paths.rs
+++ b/clippy_lints/src/utils/paths.rs
@@ -120,6 +120,7 @@ pub const STRING: [&str; 3] = ["alloc", "string", "String"];
 pub const STRING_AS_MUT_STR: [&str; 4] = ["alloc", "string", "String", "as_mut_str"];
 pub const STRING_AS_STR: [&str; 4] = ["alloc", "string", "String", "as_str"];
 pub const STR_ENDS_WITH: [&str; 4] = ["core", "str", "<impl str>", "ends_with"];
+pub const STR_FROM_UTF8: [&str; 4] = ["core", "str", "converts", "from_utf8"];
 pub const STR_LEN: [&str; 4] = ["core", "str", "<impl str>", "len"];
 pub const STR_STARTS_WITH: [&str; 4] = ["core", "str", "<impl str>", "starts_with"];
 pub const SYNTAX_CONTEXT: [&str; 3] = ["rustc_span", "hygiene", "SyntaxContext"];
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index 016bda77ef5..4d824cf94be 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -2230,6 +2230,13 @@ vec![
         deprecation: None,
         module: "methods",
     },
+    Lint {
+        name: "string_from_utf8_as_bytes",
+        group: "complexity",
+        desc: "casting string slices to byte slices and back",
+        deprecation: None,
+        module: "strings",
+    },
     Lint {
         name: "string_lit_as_bytes",
         group: "nursery",
diff --git a/tests/ui/string_from_utf8_as_bytes.fixed b/tests/ui/string_from_utf8_as_bytes.fixed
new file mode 100644
index 00000000000..6e665cdd563
--- /dev/null
+++ b/tests/ui/string_from_utf8_as_bytes.fixed
@@ -0,0 +1,6 @@
+// run-rustfix
+#![warn(clippy::string_from_utf8_as_bytes)]
+
+fn main() {
+    let _ = Some(&"Hello World!"[6..11]);
+}
diff --git a/tests/ui/string_from_utf8_as_bytes.rs b/tests/ui/string_from_utf8_as_bytes.rs
new file mode 100644
index 00000000000..670d206d367
--- /dev/null
+++ b/tests/ui/string_from_utf8_as_bytes.rs
@@ -0,0 +1,6 @@
+// run-rustfix
+#![warn(clippy::string_from_utf8_as_bytes)]
+
+fn main() {
+    let _ = std::str::from_utf8(&"Hello World!".as_bytes()[6..11]);
+}
diff --git a/tests/ui/string_from_utf8_as_bytes.stderr b/tests/ui/string_from_utf8_as_bytes.stderr
new file mode 100644
index 00000000000..bf5e5d33e8f
--- /dev/null
+++ b/tests/ui/string_from_utf8_as_bytes.stderr
@@ -0,0 +1,10 @@
+error: calling a slice of `as_bytes()` with `from_utf8` should be not necessary
+  --> $DIR/string_from_utf8_as_bytes.rs:5:13
+   |
+LL |     let _ = std::str::from_utf8(&"Hello World!".as_bytes()[6..11]);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Some(&"Hello World!"[6..11])`
+   |
+   = note: `-D clippy::string-from-utf8-as-bytes` implied by `-D warnings`
+
+error: aborting due to previous error
+
-- 
cgit 1.4.1-3-g733a5


From f83762b79cf23bfa91d77d6f04ec2b87b2159b07 Mon Sep 17 00:00:00 2001
From: ThibsG <Thibs@debian.com>
Date: Mon, 2 Nov 2020 18:03:16 +0100
Subject: Skip rustfmt as it is wanted for this test

---
 clippy_lints/src/reference.rs | 23 ++++++++++-------------
 clippy_lints/src/try_err.rs   |  6 ------
 tests/ui/deref_addrof.fixed   |  1 +
 tests/ui/deref_addrof.rs      |  1 +
 tests/ui/deref_addrof.stderr  |  4 ++--
 5 files changed, 14 insertions(+), 21 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/reference.rs b/clippy_lints/src/reference.rs
index 8646d616735..35a1310d68b 100644
--- a/clippy_lints/src/reference.rs
+++ b/clippy_lints/src/reference.rs
@@ -1,11 +1,10 @@
 use crate::utils::{in_macro, snippet_opt, snippet_with_applicability, span_lint_and_sugg};
 use if_chain::if_chain;
-use rustc_ast::ast::{Expr, ExprKind, UnOp, Mutability};
+use rustc_ast::ast::{Expr, ExprKind, Mutability, UnOp};
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::BytePos;
-// use rustc_span::source_map::{BytePos, Span};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for usage of `*&` and `*&mut` in expressions.
@@ -53,31 +52,29 @@ impl EarlyLintPass for DerefAddrOf {
                         // Remove leading whitespace from the given span
                         // e.g: ` $visitor` turns into `$visitor`
                         let trim_leading_whitespaces = |span| {
-                            if let Some(start_no_whitespace) = snippet_opt(cx, span).and_then(|snip| {
+                            snippet_opt(cx, span).and_then(|snip| {
+                                #[allow(clippy::cast_possible_truncation)]
                                 snip.find(|c: char| !c.is_whitespace()).map(|pos| {
                                     span.lo() + BytePos(pos as u32)
                                 })
-                            }) {
-                                e.span.with_lo(start_no_whitespace)
-                            } else {
-                                span
-                            }
+                            }).map_or(span, |start_no_whitespace| e.span.with_lo(start_no_whitespace))
                         };
 
                         let rpos = if *mutability == Mutability::Mut {
                             macro_source.rfind("mut").expect("already checked this is a mutable reference") + "mut".len()
                         } else {
-                            macro_source.rfind("&").expect("already checked this is a reference") + "&".len()
+                            macro_source.rfind('&').expect("already checked this is a reference") + "&".len()
                         };
+                        #[allow(clippy::cast_possible_truncation)]
                         let span_after_ref = e.span.with_lo(BytePos(e.span.lo().0 + rpos as u32));
                         let span = trim_leading_whitespaces(span_after_ref);
-                        snippet_with_applicability(cx, span, "_", &mut applicability).to_string()
+                        snippet_with_applicability(cx, span, "_", &mut applicability)
                     } else {
-                        snippet_with_applicability(cx, e.span, "_", &mut applicability).to_string()
+                        snippet_with_applicability(cx, e.span, "_", &mut applicability)
                     }
                 } else {
-                    snippet_with_applicability(cx, addrof_target.span, "_", &mut applicability).to_string()
-                };
+                    snippet_with_applicability(cx, addrof_target.span, "_", &mut applicability)
+                }.to_string();
                 span_lint_and_sugg(
                     cx,
                     DEREF_ADDROF,
diff --git a/clippy_lints/src/try_err.rs b/clippy_lints/src/try_err.rs
index e6d8e7521a8..9c1185d30f2 100644
--- a/clippy_lints/src/try_err.rs
+++ b/clippy_lints/src/try_err.rs
@@ -92,13 +92,9 @@ impl<'tcx> LateLintPass<'tcx> for TryErr {
 
                 let expr_err_ty = cx.typeck_results().expr_ty(err_arg);
 
-                // println!("\n\n{:?}", in_macro(expr.span));
-                // println!("{:#?}", snippet(cx, err_arg.span, "_"));
                 let origin_snippet = if err_arg.span.from_expansion() && !in_macro(expr.span) {
-                    // println!("from expansion");
                     snippet_with_macro_callsite(cx, err_arg.span, "_")
                 } else {
-                    // println!("just a snippet");
                     snippet(cx, err_arg.span, "_")
                 };
                 let suggestion = if err_ty == expr_err_ty {
@@ -106,8 +102,6 @@ impl<'tcx> LateLintPass<'tcx> for TryErr {
                 } else {
                     format!("return {}{}.into(){}", prefix, origin_snippet, suffix)
                 };
-                // println!("origin_snippet: {:#?}", origin_snippet);
-                // println!("suggestion: {:#?}", suggestion);
 
                 span_lint_and_sugg(
                     cx,
diff --git a/tests/ui/deref_addrof.fixed b/tests/ui/deref_addrof.fixed
index 689e9d55223..0795900558b 100644
--- a/tests/ui/deref_addrof.fixed
+++ b/tests/ui/deref_addrof.fixed
@@ -38,6 +38,7 @@ fn main() {
     let b = *aref;
 }
 
+#[rustfmt::skip]
 macro_rules! m {
     ($visitor: expr) => {
         $visitor
diff --git a/tests/ui/deref_addrof.rs b/tests/ui/deref_addrof.rs
index 57effce5d12..60c4318601b 100644
--- a/tests/ui/deref_addrof.rs
+++ b/tests/ui/deref_addrof.rs
@@ -38,6 +38,7 @@ fn main() {
     let b = **&aref;
 }
 
+#[rustfmt::skip]
 macro_rules! m {
     ($visitor: expr) => {
         *& $visitor
diff --git a/tests/ui/deref_addrof.stderr b/tests/ui/deref_addrof.stderr
index 52c1f7d1da8..e85b30fa56e 100644
--- a/tests/ui/deref_addrof.stderr
+++ b/tests/ui/deref_addrof.stderr
@@ -49,7 +49,7 @@ LL |     let b = **&aref;
    |              ^^^^^^ help: try this: `aref`
 
 error: immediately dereferencing a reference
-  --> $DIR/deref_addrof.rs:43:9
+  --> $DIR/deref_addrof.rs:44:9
    |
 LL |         *& $visitor
    |         ^^^^^^^^^^^ help: try this: `$visitor`
@@ -60,7 +60,7 @@ LL |         m!(self)
    = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: immediately dereferencing a reference
-  --> $DIR/deref_addrof.rs:50:9
+  --> $DIR/deref_addrof.rs:51:9
    |
 LL |         *& mut $visitor
    |         ^^^^^^^^^^^^^^^ help: try this: `$visitor`
-- 
cgit 1.4.1-3-g733a5


From 83e75f92079909aa07306633f26f42eccfb608e1 Mon Sep 17 00:00:00 2001
From: ThibsG <Thibs@debian.com>
Date: Thu, 5 Nov 2020 18:00:34 +0100
Subject: Fix incorrect suggestion for `try_err` lint when `Err` arg is itself
 a macro

---
 clippy_lints/src/try_err.rs |  9 ++++++---
 tests/ui/try_err.fixed      | 18 ++++++++++++++++++
 tests/ui/try_err.rs         | 18 ++++++++++++++++++
 tests/ui/try_err.stderr     | 21 ++++++++++++++++-----
 4 files changed, 58 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/try_err.rs b/clippy_lints/src/try_err.rs
index 9c1185d30f2..e1dec63a98a 100644
--- a/clippy_lints/src/try_err.rs
+++ b/clippy_lints/src/try_err.rs
@@ -1,6 +1,6 @@
 use crate::utils::{
-    in_macro, is_type_diagnostic_item, match_def_path, match_qpath, paths, snippet, snippet_with_macro_callsite,
-    span_lint_and_sugg,
+    differing_macro_contexts, in_macro, is_type_diagnostic_item, match_def_path, match_qpath, paths, snippet,
+    snippet_with_macro_callsite, span_lint_and_sugg,
 };
 use if_chain::if_chain;
 use rustc_errors::Applicability;
@@ -91,8 +91,11 @@ impl<'tcx> LateLintPass<'tcx> for TryErr {
                 };
 
                 let expr_err_ty = cx.typeck_results().expr_ty(err_arg);
+                let differing_contexts = differing_macro_contexts(expr.span, err_arg.span);
 
-                let origin_snippet = if err_arg.span.from_expansion() && !in_macro(expr.span) {
+                let origin_snippet = if in_macro(expr.span) && in_macro(err_arg.span) && differing_contexts {
+                    snippet(cx, err_arg.span.ctxt().outer_expn_data().call_site, "_")
+                } else if err_arg.span.from_expansion() && !in_macro(expr.span) {
                     snippet_with_macro_callsite(cx, err_arg.span, "_")
                 } else {
                     snippet(cx, err_arg.span, "_")
diff --git a/tests/ui/try_err.fixed b/tests/ui/try_err.fixed
index 053dd45f23e..aa43e69f79e 100644
--- a/tests/ui/try_err.fixed
+++ b/tests/ui/try_err.fixed
@@ -88,8 +88,26 @@ macro_rules! try_validation {
     }};
 }
 
+macro_rules! ret_one {
+    () => {
+        1
+    };
+}
+
+macro_rules! try_validation_in_macro {
+    ($e: expr) => {{
+        match $e {
+            Ok(_) => 0,
+            Err(_) => return Err(ret_one!()),
+        }
+    }};
+}
+
 fn calling_macro() -> Result<i32, i32> {
+    // macro
     try_validation!(Ok::<_, i32>(5));
+    // `Err` arg is another macro
+    try_validation_in_macro!(Ok::<_, i32>(5));
     Ok(5)
 }
 
diff --git a/tests/ui/try_err.rs b/tests/ui/try_err.rs
index 215ca6a07e6..df3a9dc5367 100644
--- a/tests/ui/try_err.rs
+++ b/tests/ui/try_err.rs
@@ -88,8 +88,26 @@ macro_rules! try_validation {
     }};
 }
 
+macro_rules! ret_one {
+    () => {
+        1
+    };
+}
+
+macro_rules! try_validation_in_macro {
+    ($e: expr) => {{
+        match $e {
+            Ok(_) => 0,
+            Err(_) => Err(ret_one!())?,
+        }
+    }};
+}
+
 fn calling_macro() -> Result<i32, i32> {
+    // macro
     try_validation!(Ok::<_, i32>(5));
+    // `Err` arg is another macro
+    try_validation_in_macro!(Ok::<_, i32>(5));
     Ok(5)
 }
 
diff --git a/tests/ui/try_err.stderr b/tests/ui/try_err.stderr
index 443c8d08472..3905ed2476b 100644
--- a/tests/ui/try_err.stderr
+++ b/tests/ui/try_err.stderr
@@ -40,28 +40,39 @@ LL |     try_validation!(Ok::<_, i32>(5));
    = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: returning an `Err(_)` with the `?` operator
-  --> $DIR/try_err.rs:122:9
+  --> $DIR/try_err.rs:101:23
+   |
+LL |             Err(_) => Err(ret_one!())?,
+   |                       ^^^^^^^^^^^^^^^^ help: try this: `return Err(ret_one!())`
+...
+LL |     try_validation_in_macro!(Ok::<_, i32>(5));
+   |     ------------------------------------------ in this macro invocation
+   |
+   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: returning an `Err(_)` with the `?` operator
+  --> $DIR/try_err.rs:140:9
    |
 LL |         Err(foo!())?;
    |         ^^^^^^^^^^^^ help: try this: `return Err(foo!())`
 
 error: returning an `Err(_)` with the `?` operator
-  --> $DIR/try_err.rs:129:9
+  --> $DIR/try_err.rs:147:9
    |
 LL |         Err(io::ErrorKind::WriteZero)?
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `return Poll::Ready(Err(io::ErrorKind::WriteZero.into()))`
 
 error: returning an `Err(_)` with the `?` operator
-  --> $DIR/try_err.rs:131:9
+  --> $DIR/try_err.rs:149:9
    |
 LL |         Err(io::Error::new(io::ErrorKind::InvalidInput, "error"))?
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `return Poll::Ready(Err(io::Error::new(io::ErrorKind::InvalidInput, "error")))`
 
 error: returning an `Err(_)` with the `?` operator
-  --> $DIR/try_err.rs:139:9
+  --> $DIR/try_err.rs:157:9
    |
 LL |         Err(io::ErrorKind::NotFound)?
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `return Poll::Ready(Some(Err(io::ErrorKind::NotFound.into())))`
 
-error: aborting due to 9 previous errors
+error: aborting due to 10 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 1e4ce0fcaa2bd99ce51e1857767788cc498e62c0 Mon Sep 17 00:00:00 2001
From: Yuki Okushi <huyuumi.dev@gmail.com>
Date: Fri, 6 Nov 2020 04:02:41 +0900
Subject: Fix `await_holding_refcell_ref` examples for clarify

---
 clippy_lints/src/await_holding_invalid.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/await_holding_invalid.rs b/clippy_lints/src/await_holding_invalid.rs
index fcebb54c6c2..ca819663fde 100644
--- a/clippy_lints/src/await_holding_invalid.rs
+++ b/clippy_lints/src/await_holding_invalid.rs
@@ -65,8 +65,8 @@ declare_clippy_lint! {
     /// use std::cell::RefCell;
     ///
     /// async fn foo(x: &RefCell<u32>) {
-    ///   let b = x.borrow_mut()();
-    ///   *ref += 1;
+    ///   let mut y = x.borrow_mut();
+    ///   *y += 1;
     ///   bar.await;
     /// }
     /// ```
@@ -77,8 +77,8 @@ declare_clippy_lint! {
     ///
     /// async fn foo(x: &RefCell<u32>) {
     ///   {
-    ///     let b = x.borrow_mut();
-    ///     *ref += 1;
+    ///      let mut y = x.borrow_mut();
+    ///      *y += 1;
     ///   }
     ///   bar.await;
     /// }
-- 
cgit 1.4.1-3-g733a5


From 1624b00bde42a674c50a03e63868e8b4d08b6b49 Mon Sep 17 00:00:00 2001
From: Takayuki Nakata <f.seasons017@gmail.com>
Date: Thu, 5 Nov 2020 13:56:57 +0900
Subject: Fix suggestion to add unneeded space in `manual_async`

---
 clippy_lints/src/manual_async_fn.rs | 17 ++++++++-
 tests/ui/manual_async_fn.fixed      | 14 ++++++-
 tests/ui/manual_async_fn.rs         | 20 ++++++++++
 tests/ui/manual_async_fn.stderr     | 74 +++++++++++++++++++++++++++++++++----
 4 files changed, 115 insertions(+), 10 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_async_fn.rs b/clippy_lints/src/manual_async_fn.rs
index 864d1ea87f5..e9d65abb443 100644
--- a/clippy_lints/src/manual_async_fn.rs
+++ b/clippy_lints/src/manual_async_fn.rs
@@ -69,7 +69,20 @@ impl<'tcx> LateLintPass<'tcx> for ManualAsyncFn {
                     |diag| {
                         if_chain! {
                             if let Some(header_snip) = snippet_opt(cx, header_span);
-                            if let Some(ret_pos) = header_snip.rfind("->");
+                            if let Some(ret_pos) = header_snip.rfind("->").map(|rpos| {
+                                let mut rpos = rpos;
+                                let chars: Vec<char> = header_snip.chars().collect();
+                                while rpos > 1 {
+                                    if let Some(c) = chars.get(rpos - 1) {
+                                        if c.is_whitespace() {
+                                            rpos -= 1;
+                                            continue;
+                                        }
+                                    }
+                                    break;
+                                }
+                                rpos
+                            });
                             if let Some((ret_sugg, ret_snip)) = suggested_ret(cx, output);
                             then {
                                 let help = format!("make the function `async` and {}", ret_sugg);
@@ -194,7 +207,7 @@ fn suggested_ret(cx: &LateContext<'_>, output: &Ty<'_>) -> Option<(&'static str,
         },
         _ => {
             let sugg = "return the output of the future directly";
-            snippet_opt(cx, output.span).map(|snip| (sugg, format!("-> {}", snip)))
+            snippet_opt(cx, output.span).map(|snip| (sugg, format!(" -> {}", snip)))
         },
     }
 }
diff --git a/tests/ui/manual_async_fn.fixed b/tests/ui/manual_async_fn.fixed
index 4f551690c43..5184f6fdb88 100644
--- a/tests/ui/manual_async_fn.fixed
+++ b/tests/ui/manual_async_fn.fixed
@@ -7,7 +7,19 @@ use std::future::Future;
 
 async fn fut() -> i32 { 42 }
 
-async fn empty_fut()  {}
+#[rustfmt::skip]
+async fn fut2() -> i32 { 42 }
+
+#[rustfmt::skip]
+async fn fut3() -> i32 { 42 }
+
+async fn empty_fut() {}
+
+#[rustfmt::skip]
+async fn empty_fut2() {}
+
+#[rustfmt::skip]
+async fn empty_fut3() {}
 
 async fn core_fut() -> i32 { 42 }
 
diff --git a/tests/ui/manual_async_fn.rs b/tests/ui/manual_async_fn.rs
index 6ed60309947..68c0e591f0b 100644
--- a/tests/ui/manual_async_fn.rs
+++ b/tests/ui/manual_async_fn.rs
@@ -9,10 +9,30 @@ fn fut() -> impl Future<Output = i32> {
     async { 42 }
 }
 
+#[rustfmt::skip]
+fn fut2() ->impl Future<Output = i32> {
+    async { 42 }
+}
+
+#[rustfmt::skip]
+fn fut3()-> impl Future<Output = i32> {
+    async { 42 }
+}
+
 fn empty_fut() -> impl Future<Output = ()> {
     async {}
 }
 
+#[rustfmt::skip]
+fn empty_fut2() ->impl Future<Output = ()> {
+    async {}
+}
+
+#[rustfmt::skip]
+fn empty_fut3()-> impl Future<Output = ()> {
+    async {}
+}
+
 fn core_fut() -> impl core::future::Future<Output = i32> {
     async move { 42 }
 }
diff --git a/tests/ui/manual_async_fn.stderr b/tests/ui/manual_async_fn.stderr
index ccd82867427..fdd43db3255 100644
--- a/tests/ui/manual_async_fn.stderr
+++ b/tests/ui/manual_async_fn.stderr
@@ -15,14 +15,44 @@ LL | fn fut() -> impl Future<Output = i32> { 42 }
    |                                       ^^^^^^
 
 error: this function can be simplified using the `async fn` syntax
-  --> $DIR/manual_async_fn.rs:12:1
+  --> $DIR/manual_async_fn.rs:13:1
+   |
+LL | fn fut2() ->impl Future<Output = i32> {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: make the function `async` and return the output of the future directly
+   |
+LL | async fn fut2() -> i32 {
+   | ^^^^^^^^^^^^^^^^^^^^^^
+help: move the body of the async block to the enclosing function
+   |
+LL | fn fut2() ->impl Future<Output = i32> { 42 }
+   |                                       ^^^^^^
+
+error: this function can be simplified using the `async fn` syntax
+  --> $DIR/manual_async_fn.rs:18:1
+   |
+LL | fn fut3()-> impl Future<Output = i32> {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: make the function `async` and return the output of the future directly
+   |
+LL | async fn fut3() -> i32 {
+   | ^^^^^^^^^^^^^^^^^^^^^^
+help: move the body of the async block to the enclosing function
+   |
+LL | fn fut3()-> impl Future<Output = i32> { 42 }
+   |                                       ^^^^^^
+
+error: this function can be simplified using the `async fn` syntax
+  --> $DIR/manual_async_fn.rs:22:1
    |
 LL | fn empty_fut() -> impl Future<Output = ()> {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: make the function `async` and remove the return type
    |
-LL | async fn empty_fut()  {
+LL | async fn empty_fut() {
    | ^^^^^^^^^^^^^^^^^^^^
 help: move the body of the async block to the enclosing function
    |
@@ -30,7 +60,37 @@ LL | fn empty_fut() -> impl Future<Output = ()> {}
    |                                            ^^
 
 error: this function can be simplified using the `async fn` syntax
-  --> $DIR/manual_async_fn.rs:16:1
+  --> $DIR/manual_async_fn.rs:27:1
+   |
+LL | fn empty_fut2() ->impl Future<Output = ()> {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: make the function `async` and remove the return type
+   |
+LL | async fn empty_fut2() {
+   | ^^^^^^^^^^^^^^^^^^^^^
+help: move the body of the async block to the enclosing function
+   |
+LL | fn empty_fut2() ->impl Future<Output = ()> {}
+   |                                            ^^
+
+error: this function can be simplified using the `async fn` syntax
+  --> $DIR/manual_async_fn.rs:32:1
+   |
+LL | fn empty_fut3()-> impl Future<Output = ()> {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: make the function `async` and remove the return type
+   |
+LL | async fn empty_fut3() {
+   | ^^^^^^^^^^^^^^^^^^^^^
+help: move the body of the async block to the enclosing function
+   |
+LL | fn empty_fut3()-> impl Future<Output = ()> {}
+   |                                            ^^
+
+error: this function can be simplified using the `async fn` syntax
+  --> $DIR/manual_async_fn.rs:36:1
    |
 LL | fn core_fut() -> impl core::future::Future<Output = i32> {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -45,7 +105,7 @@ LL | fn core_fut() -> impl core::future::Future<Output = i32> { 42 }
    |                                                          ^^^^^^
 
 error: this function can be simplified using the `async fn` syntax
-  --> $DIR/manual_async_fn.rs:38:5
+  --> $DIR/manual_async_fn.rs:58:5
    |
 LL |     fn inh_fut() -> impl Future<Output = i32> {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -65,7 +125,7 @@ LL |             let c = 21;
  ...
 
 error: this function can be simplified using the `async fn` syntax
-  --> $DIR/manual_async_fn.rs:73:1
+  --> $DIR/manual_async_fn.rs:93:1
    |
 LL | fn elided(_: &i32) -> impl Future<Output = i32> + '_ {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -80,7 +140,7 @@ LL | fn elided(_: &i32) -> impl Future<Output = i32> + '_ { 42 }
    |                                                      ^^^^^^
 
 error: this function can be simplified using the `async fn` syntax
-  --> $DIR/manual_async_fn.rs:82:1
+  --> $DIR/manual_async_fn.rs:102:1
    |
 LL | fn explicit<'a, 'b>(_: &'a i32, _: &'b i32) -> impl Future<Output = i32> + 'a + 'b {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -94,5 +154,5 @@ help: move the body of the async block to the enclosing function
 LL | fn explicit<'a, 'b>(_: &'a i32, _: &'b i32) -> impl Future<Output = i32> + 'a + 'b { 42 }
    |                                                                                    ^^^^^^
 
-error: aborting due to 6 previous errors
+error: aborting due to 10 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 5f57608604bd35bd11c1f33cbd7202250e072b54 Mon Sep 17 00:00:00 2001
From: Aleksei Latyshev <alex_700_95@mail.ru>
Date: Fri, 6 Nov 2020 14:38:46 +0300
Subject: do not trigger map_clone in the case of &mut

---
 clippy_lints/src/map_clone.rs | 8 +++++---
 tests/ui/map_clone.fixed      | 8 ++++++++
 tests/ui/map_clone.rs         | 8 ++++++++
 3 files changed, 21 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/map_clone.rs b/clippy_lints/src/map_clone.rs
index 034cd99a9be..9a00608ce39 100644
--- a/clippy_lints/src/map_clone.rs
+++ b/clippy_lints/src/map_clone.rs
@@ -80,9 +80,11 @@ impl<'tcx> LateLintPass<'tcx> for MapClone {
                                     && match_trait_method(cx, closure_expr, &paths::CLONE_TRAIT) {
 
                                     let obj_ty = cx.typeck_results().expr_ty(&obj[0]);
-                                    if let ty::Ref(_, ty, _) = obj_ty.kind() {
-                                        let copy = is_copy(cx, ty);
-                                        lint(cx, e.span, args[0].span, copy);
+                                    if let ty::Ref(_, ty, mutability) = obj_ty.kind() {
+                                        if matches!(mutability, Mutability::Not) {
+                                            let copy = is_copy(cx, ty);
+                                            lint(cx, e.span, args[0].span, copy);
+                                        }
                                     } else {
                                         lint_needless_cloning(cx, e.span, args[0].span);
                                     }
diff --git a/tests/ui/map_clone.fixed b/tests/ui/map_clone.fixed
index 81c7f659efb..6e3a8e67e81 100644
--- a/tests/ui/map_clone.fixed
+++ b/tests/ui/map_clone.fixed
@@ -44,4 +44,12 @@ fn main() {
         let v = vec![&mut d];
         let _: Vec<u32> = v.into_iter().map(|&mut x| x).collect();
     }
+
+    // Issue #6299
+    {
+        let mut aa = 5;
+        let mut bb = 3;
+        let items = vec![&mut aa, &mut bb];
+        let _: Vec<_> = items.into_iter().map(|x| x.clone()).collect();
+    }
 }
diff --git a/tests/ui/map_clone.rs b/tests/ui/map_clone.rs
index 8ed164f0ed5..6fd395710d4 100644
--- a/tests/ui/map_clone.rs
+++ b/tests/ui/map_clone.rs
@@ -44,4 +44,12 @@ fn main() {
         let v = vec![&mut d];
         let _: Vec<u32> = v.into_iter().map(|&mut x| x).collect();
     }
+
+    // Issue #6299
+    {
+        let mut aa = 5;
+        let mut bb = 3;
+        let items = vec![&mut aa, &mut bb];
+        let _: Vec<_> = items.into_iter().map(|x| x.clone()).collect();
+    }
 }
-- 
cgit 1.4.1-3-g733a5


From b7892c6a26adf6173758641d3f7deb0ae972959d Mon Sep 17 00:00:00 2001
From: Takayuki Nakata <f.seasons017@gmail.com>
Date: Fri, 6 Nov 2020 22:54:38 +0900
Subject: Refactor to make getting position just before RArrow a common
 function

---
 clippy_lints/src/manual_async_fn.rs | 17 ++---------------
 clippy_lints/src/unused_unit.rs     | 29 ++++++++---------------------
 clippy_lints/src/utils/mod.rs       | 29 +++++++++++++++++++++++++++++
 3 files changed, 39 insertions(+), 36 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_async_fn.rs b/clippy_lints/src/manual_async_fn.rs
index e9d65abb443..7b3b450ef93 100644
--- a/clippy_lints/src/manual_async_fn.rs
+++ b/clippy_lints/src/manual_async_fn.rs
@@ -1,5 +1,5 @@
 use crate::utils::paths::FUTURE_FROM_GENERATOR;
-use crate::utils::{match_function_call, snippet_block, snippet_opt, span_lint_and_then};
+use crate::utils::{match_function_call, position_before_rarrow, snippet_block, snippet_opt, span_lint_and_then};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::FnKind;
@@ -69,20 +69,7 @@ impl<'tcx> LateLintPass<'tcx> for ManualAsyncFn {
                     |diag| {
                         if_chain! {
                             if let Some(header_snip) = snippet_opt(cx, header_span);
-                            if let Some(ret_pos) = header_snip.rfind("->").map(|rpos| {
-                                let mut rpos = rpos;
-                                let chars: Vec<char> = header_snip.chars().collect();
-                                while rpos > 1 {
-                                    if let Some(c) = chars.get(rpos - 1) {
-                                        if c.is_whitespace() {
-                                            rpos -= 1;
-                                            continue;
-                                        }
-                                    }
-                                    break;
-                                }
-                                rpos
-                            });
+                            if let Some(ret_pos) = position_before_rarrow(header_snip.clone());
                             if let Some((ret_sugg, ret_snip)) = suggested_ret(cx, output);
                             then {
                                 let help = format!("make the function `async` and {}", ret_sugg);
diff --git a/clippy_lints/src/unused_unit.rs b/clippy_lints/src/unused_unit.rs
index b1339c3d639..f61fd2ecd73 100644
--- a/clippy_lints/src/unused_unit.rs
+++ b/clippy_lints/src/unused_unit.rs
@@ -7,7 +7,7 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
 use rustc_span::BytePos;
 
-use crate::utils::span_lint_and_sugg;
+use crate::utils::{position_before_rarrow, span_lint_and_sugg};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for unit (`()`) expressions that can be removed.
@@ -120,26 +120,13 @@ fn is_unit_expr(expr: &ast::Expr) -> bool {
 
 fn lint_unneeded_unit_return(cx: &EarlyContext<'_>, ty: &ast::Ty, span: Span) {
     let (ret_span, appl) = if let Ok(fn_source) = cx.sess().source_map().span_to_snippet(span.with_hi(ty.span.hi())) {
-        fn_source
-            .rfind("->")
-            .map_or((ty.span, Applicability::MaybeIncorrect), |rpos| {
-                let mut rpos = rpos;
-                let chars: Vec<char> = fn_source.chars().collect();
-                while rpos > 1 {
-                    if let Some(c) = chars.get(rpos - 1) {
-                        if c.is_whitespace() {
-                            rpos -= 1;
-                            continue;
-                        }
-                    }
-                    break;
-                }
-                (
-                    #[allow(clippy::cast_possible_truncation)]
-                    ty.span.with_lo(BytePos(span.lo().0 + rpos as u32)),
-                    Applicability::MachineApplicable,
-                )
-            })
+        position_before_rarrow(fn_source).map_or((ty.span, Applicability::MaybeIncorrect), |rpos| {
+            (
+                #[allow(clippy::cast_possible_truncation)]
+                ty.span.with_lo(BytePos(span.lo().0 + rpos as u32)),
+                Applicability::MachineApplicable,
+            )
+        })
     } else {
         (ty.span, Applicability::MaybeIncorrect)
     };
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index 85e7f055e79..8e4149df032 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -659,6 +659,35 @@ pub fn indent_of<T: LintContext>(cx: &T, span: Span) -> Option<usize> {
     snippet_opt(cx, line_span(cx, span)).and_then(|snip| snip.find(|c: char| !c.is_whitespace()))
 }
 
+/// Returns the positon just before rarrow
+///
+/// ```rust,ignore
+/// fn into(self) -> () {}
+///              ^
+/// // in case of unformatted code
+/// fn into2(self)-> () {}
+///               ^
+/// fn into3(self)   -> () {}
+///               ^
+/// ```
+#[allow(clippy::needless_pass_by_value)]
+pub fn position_before_rarrow(s: String) -> Option<usize> {
+    s.rfind("->").map(|rpos| {
+        let mut rpos = rpos;
+        let chars: Vec<char> = s.chars().collect();
+        while rpos > 1 {
+            if let Some(c) = chars.get(rpos - 1) {
+                if c.is_whitespace() {
+                    rpos -= 1;
+                    continue;
+                }
+            }
+            break;
+        }
+        rpos
+    })
+}
+
 /// Extends the span to the beginning of the spans line, incl. whitespaces.
 ///
 /// ```rust,ignore
-- 
cgit 1.4.1-3-g733a5


From 5253595b3bb6a3cc6502bb2327590e582d1d27e9 Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Fri, 6 Nov 2020 19:34:34 +0100
Subject: FROM_ITER_INSTEAD_OF_COLLECT: avoid unwrapping unconditionally

Fixes #6302
---
 clippy_lints/src/methods/mod.rs | 31 +++++++++++++++++--------------
 1 file changed, 17 insertions(+), 14 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 7186656f4e1..a3fa3bdd36a 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3901,21 +3901,24 @@ fn lint_from_iter(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::Expr<
     let ty = cx.typeck_results().expr_ty(expr);
     let arg_ty = cx.typeck_results().expr_ty(&args[0]);
 
-    let from_iter_id = get_trait_def_id(cx, &paths::FROM_ITERATOR).unwrap();
-    let iter_id = get_trait_def_id(cx, &paths::ITERATOR).unwrap();
+    if_chain! {
+        if let Some(from_iter_id) = get_trait_def_id(cx, &paths::FROM_ITERATOR);
+        if let Some(iter_id) = get_trait_def_id(cx, &paths::ITERATOR);
 
-    if implements_trait(cx, ty, from_iter_id, &[]) && implements_trait(cx, arg_ty, iter_id, &[]) {
-        // `expr` implements `FromIterator` trait
-        let iter_expr = snippet(cx, args[0].span, "..");
-        span_lint_and_sugg(
-            cx,
-            FROM_ITER_INSTEAD_OF_COLLECT,
-            expr.span,
-            "usage of `FromIterator::from_iter`",
-            "use `.collect()` instead of `::from_iter()`",
-            format!("{}.collect()", iter_expr),
-            Applicability::MaybeIncorrect,
-        );
+        if implements_trait(cx, ty, from_iter_id, &[]) && implements_trait(cx, arg_ty, iter_id, &[]);
+        then {
+            // `expr` implements `FromIterator` trait
+            let iter_expr = snippet(cx, args[0].span, "..");
+            span_lint_and_sugg(
+                cx,
+                FROM_ITER_INSTEAD_OF_COLLECT,
+                expr.span,
+                "usage of `FromIterator::from_iter`",
+                "use `.collect()` instead of `::from_iter()`",
+                format!("{}.collect()", iter_expr),
+                Applicability::MaybeIncorrect,
+            );
+        }
     }
 }
 
-- 
cgit 1.4.1-3-g733a5


From c6a91df838b17a2366346db664072d7914ab241a Mon Sep 17 00:00:00 2001
From: Joe Richey <joerichey@google.com>
Date: Thu, 22 Oct 2020 23:39:25 -0700
Subject: Enable empty_loop lint for no_std crates

We skip the lint if the `loop {}` is in the `#[panic_handler]` as the
main recommendation we give is to panic, which obviously isn't
possible in a panic handler.

Signed-off-by: Joe Richey <joerichey@google.com>
---
 clippy_lints/src/loops.rs         | 28 +++++++++++++---------------
 clippy_lints/src/utils/mod.rs     |  7 +++++++
 tests/ui/empty_loop_no_std.rs     |  7 ++++++-
 tests/ui/empty_loop_no_std.stderr | 19 +++++++++++++++++++
 4 files changed, 45 insertions(+), 16 deletions(-)
 create mode 100644 tests/ui/empty_loop_no_std.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 32c2562ee95..2a53210efe3 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -4,10 +4,10 @@ use crate::utils::sugg::Sugg;
 use crate::utils::usage::{is_unused, mutated_variables};
 use crate::utils::{
     contains_name, get_enclosing_block, get_parent_expr, get_trait_def_id, has_iter_method, higher, implements_trait,
-    indent_of, is_integer_const, is_no_std_crate, is_refutable, is_type_diagnostic_item, last_path_segment,
-    match_trait_method, match_type, match_var, multispan_sugg, qpath_res, single_segment_path, snippet,
-    snippet_with_applicability, snippet_with_macro_callsite, span_lint, span_lint_and_help, span_lint_and_sugg,
-    span_lint_and_then, sugg, SpanlessEq,
+    indent_of, is_in_panic_handler, is_integer_const, is_no_std_crate, is_refutable, is_type_diagnostic_item,
+    last_path_segment, match_trait_method, match_type, match_var, multispan_sugg, qpath_res, single_segment_path,
+    snippet, snippet_with_applicability, snippet_with_macro_callsite, span_lint, span_lint_and_help,
+    span_lint_and_sugg, span_lint_and_then, sugg, SpanlessEq,
 };
 use if_chain::if_chain;
 use rustc_ast::ast;
@@ -543,17 +543,15 @@ impl<'tcx> LateLintPass<'tcx> for Loops {
         // (also matches an explicit "match" instead of "if let")
         // (even if the "match" or "if let" is used for declaration)
         if let ExprKind::Loop(ref block, _, LoopSource::Loop) = expr.kind {
-            // also check for empty `loop {}` statements
-            // TODO(issue #6161): Enable for no_std crates (outside of #[panic_handler])
-            if block.stmts.is_empty() && block.expr.is_none() && !is_no_std_crate(cx.tcx.hir().krate()) {
-                span_lint_and_help(
-                    cx,
-                    EMPTY_LOOP,
-                    expr.span,
-                    "empty `loop {}` wastes CPU cycles",
-                    None,
-                    "You should either use `panic!()` or add `std::thread::sleep(..);` to the loop body.",
-                );
+            // also check for empty `loop {}` statements, skipping those in #[panic_handler]
+            if block.stmts.is_empty() && block.expr.is_none() && !is_in_panic_handler(cx, expr) {
+                let msg = "empty `loop {}` wastes CPU cycles";
+                let help = if is_no_std_crate(cx.tcx.hir().krate()) {
+                    "You should either use `panic!()` or add a call pausing or sleeping the thread to the loop body."
+                } else {
+                    "You should either use `panic!()` or add `std::thread::sleep(..);` to the loop body."
+                };
+                span_lint_and_help(cx, EMPTY_LOOP, expr.span, msg, None, help);
             }
 
             // extract the expression from the first statement (if any) in a block
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index 8e4149df032..cba3a050249 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -468,6 +468,13 @@ pub fn is_entrypoint_fn(cx: &LateContext<'_>, def_id: DefId) -> bool {
         .map_or(false, |(entry_fn_def_id, _)| def_id == entry_fn_def_id.to_def_id())
 }
 
+/// Returns `true` if the expression is in the program's `#[panic_handler]`.
+pub fn is_in_panic_handler(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
+    let parent = cx.tcx.hir().get_parent_item(e.hir_id);
+    let def_id = cx.tcx.hir().local_def_id(parent).to_def_id();
+    Some(def_id) == cx.tcx.lang_items().panic_impl()
+}
+
 /// Gets the name of the item the expression is in, if available.
 pub fn get_item_name(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<Symbol> {
     let parent_id = cx.tcx.hir().get_parent_item(expr.hir_id);
diff --git a/tests/ui/empty_loop_no_std.rs b/tests/ui/empty_loop_no_std.rs
index 879d1d5d916..4553d3ec505 100644
--- a/tests/ui/empty_loop_no_std.rs
+++ b/tests/ui/empty_loop_no_std.rs
@@ -10,13 +10,18 @@ use core::panic::PanicInfo;
 
 #[start]
 fn main(argc: isize, argv: *const *const u8) -> isize {
+    // This should trigger the lint
     loop {}
 }
 
 #[panic_handler]
 fn panic(_info: &PanicInfo) -> ! {
+    // This should NOT trigger the lint
     loop {}
 }
 
 #[lang = "eh_personality"]
-extern "C" fn eh_personality() {}
+extern "C" fn eh_personality() {
+    // This should also trigger the lint
+    loop {}
+}
diff --git a/tests/ui/empty_loop_no_std.stderr b/tests/ui/empty_loop_no_std.stderr
new file mode 100644
index 00000000000..1cb454c3bbe
--- /dev/null
+++ b/tests/ui/empty_loop_no_std.stderr
@@ -0,0 +1,19 @@
+error: empty `loop {}` wastes CPU cycles
+  --> $DIR/empty_loop_no_std.rs:14:5
+   |
+LL |     loop {}
+   |     ^^^^^^^
+   |
+   = note: `-D clippy::empty-loop` implied by `-D warnings`
+   = help: You should either use `panic!()` or add a call pausing or sleeping the thread to the loop body.
+
+error: empty `loop {}` wastes CPU cycles
+  --> $DIR/empty_loop_no_std.rs:26:5
+   |
+LL |     loop {}
+   |     ^^^^^^^
+   |
+   = help: You should either use `panic!()` or add a call pausing or sleeping the thread to the loop body.
+
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 3579b7de24df6a617322ec07eae98618ef57e5ee Mon Sep 17 00:00:00 2001
From: Joseph Richey <joerichey@google.com>
Date: Wed, 4 Nov 2020 03:27:30 -0800
Subject: Update clippy_lints/src/loops.rs

Fix NITs

Co-authored-by: Philipp Krones <hello@philkrones.com>
---
 clippy_lints/src/loops.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 2a53210efe3..b246245af24 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -547,9 +547,9 @@ impl<'tcx> LateLintPass<'tcx> for Loops {
             if block.stmts.is_empty() && block.expr.is_none() && !is_in_panic_handler(cx, expr) {
                 let msg = "empty `loop {}` wastes CPU cycles";
                 let help = if is_no_std_crate(cx.tcx.hir().krate()) {
-                    "You should either use `panic!()` or add a call pausing or sleeping the thread to the loop body."
+                    "you should either use `panic!()` or add a call pausing or sleeping the thread to the loop body"
                 } else {
-                    "You should either use `panic!()` or add `std::thread::sleep(..);` to the loop body."
+                    "you should either use `panic!()` or add `std::thread::sleep(..);` to the loop body"
                 };
                 span_lint_and_help(cx, EMPTY_LOOP, expr.span, msg, None, help);
             }
-- 
cgit 1.4.1-3-g733a5


From f1f780c9422f038ae78e72a99b1ca2a0d7b392bc Mon Sep 17 00:00:00 2001
From: "Samuel E. Moelius III" <sam@moeli.us>
Date: Sat, 7 Nov 2020 18:26:14 -0500
Subject: Add let_underscore_drop

---
 CHANGELOG.md                        |  1 +
 clippy_lints/src/let_underscore.rs  | 56 +++++++++++++++++++++++++++++++++++--
 clippy_lints/src/lib.rs             |  3 ++
 src/lintlist/mod.rs                 |  7 +++++
 tests/ui/let_underscore_drop.rs     | 19 +++++++++++++
 tests/ui/let_underscore_drop.stderr | 27 ++++++++++++++++++
 6 files changed, 111 insertions(+), 2 deletions(-)
 create mode 100644 tests/ui/let_underscore_drop.rs
 create mode 100644 tests/ui/let_underscore_drop.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index e0770a45c53..816d25bcd93 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1787,6 +1787,7 @@ Released 2018-09-13
 [`len_without_is_empty`]: https://rust-lang.github.io/rust-clippy/master/index.html#len_without_is_empty
 [`len_zero`]: https://rust-lang.github.io/rust-clippy/master/index.html#len_zero
 [`let_and_return`]: https://rust-lang.github.io/rust-clippy/master/index.html#let_and_return
+[`let_underscore_drop`]: https://rust-lang.github.io/rust-clippy/master/index.html#let_underscore_drop
 [`let_underscore_lock`]: https://rust-lang.github.io/rust-clippy/master/index.html#let_underscore_lock
 [`let_underscore_must_use`]: https://rust-lang.github.io/rust-clippy/master/index.html#let_underscore_must_use
 [`let_unit_value`]: https://rust-lang.github.io/rust-clippy/master/index.html#let_unit_value
diff --git a/clippy_lints/src/let_underscore.rs b/clippy_lints/src/let_underscore.rs
index ae2f6131b5b..9c7fd634547 100644
--- a/clippy_lints/src/let_underscore.rs
+++ b/clippy_lints/src/let_underscore.rs
@@ -5,7 +5,7 @@ use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::subst::GenericArgKind;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
-use crate::utils::{is_must_use_func_call, is_must_use_ty, match_type, paths, span_lint_and_help};
+use crate::utils::{implements_trait, is_must_use_func_call, is_must_use_ty, match_type, paths, span_lint_and_help};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for `let _ = <expr>`
@@ -58,7 +58,40 @@ declare_clippy_lint! {
     "non-binding let on a synchronization lock"
 }
 
-declare_lint_pass!(LetUnderscore => [LET_UNDERSCORE_MUST_USE, LET_UNDERSCORE_LOCK]);
+declare_clippy_lint! {
+    /// **What it does:** Checks for `let _ = <expr>`
+    /// where expr has a type that implements `Drop`
+    ///
+    /// **Why is this bad?** This statement immediately drops the initializer
+    /// expression instead of extending its lifetime to the end of the scope, which
+    /// is often not intended. To extend the expression's lifetime to the end of the
+    /// scope, use an underscore-prefixed name instead (i.e. _var). If you want to
+    /// explicitly drop the expression, `std::mem::drop` conveys your intention
+    /// better and is less error-prone.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// Bad:
+    /// ```rust,ignore
+    /// struct Droppable;
+    /// impl Drop for Droppable {
+    ///     fn drop(&mut self) {}
+    /// }
+    /// let _ = Droppable;
+    /// ```
+    ///
+    /// Good:
+    /// ```rust,ignore
+    /// let _droppable = Droppable;
+    /// ```
+    pub LET_UNDERSCORE_DROP,
+    correctness,
+    "non-binding let on a type that implements `Drop`"
+}
+
+declare_lint_pass!(LetUnderscore => [LET_UNDERSCORE_MUST_USE, LET_UNDERSCORE_LOCK, LET_UNDERSCORE_DROP]);
 
 const SYNC_GUARD_PATHS: [&[&str]; 3] = [
     &paths::MUTEX_GUARD,
@@ -84,6 +117,15 @@ impl<'tcx> LateLintPass<'tcx> for LetUnderscore {
 
                     GenericArgKind::Lifetime(_) | GenericArgKind::Const(_) => false,
                 });
+                let implements_drop = cx.tcx.lang_items().drop_trait().map_or(false, |drop_trait|
+                    init_ty.walk().any(|inner| match inner.unpack() {
+                        GenericArgKind::Type(inner_ty) => {
+                            implements_trait(cx, inner_ty, drop_trait, &[])
+                        },
+
+                        GenericArgKind::Lifetime(_) | GenericArgKind::Const(_) => false,
+                    })
+                );
                 if contains_sync_guard {
                     span_lint_and_help(
                         cx,
@@ -94,6 +136,16 @@ impl<'tcx> LateLintPass<'tcx> for LetUnderscore {
                         "consider using an underscore-prefixed named \
                             binding or dropping explicitly with `std::mem::drop`"
                     )
+                } else if implements_drop {
+                    span_lint_and_help(
+                        cx,
+                        LET_UNDERSCORE_DROP,
+                        local.span,
+                        "non-binding let on a type that implements `Drop`",
+                        None,
+                        "consider using an underscore-prefixed named \
+                            binding or dropping explicitly with `std::mem::drop`"
+                    )
                 } else if is_must_use_ty(cx, cx.typeck_results().expr_ty(init)) {
                     span_lint_and_help(
                         cx,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 1f4bed92e69..b44e28b4596 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -622,6 +622,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &len_zero::LEN_WITHOUT_IS_EMPTY,
         &len_zero::LEN_ZERO,
         &let_if_seq::USELESS_LET_IF_SEQ,
+        &let_underscore::LET_UNDERSCORE_DROP,
         &let_underscore::LET_UNDERSCORE_LOCK,
         &let_underscore::LET_UNDERSCORE_MUST_USE,
         &lifetimes::EXTRA_UNUSED_LIFETIMES,
@@ -1383,6 +1384,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&len_zero::COMPARISON_TO_EMPTY),
         LintId::of(&len_zero::LEN_WITHOUT_IS_EMPTY),
         LintId::of(&len_zero::LEN_ZERO),
+        LintId::of(&let_underscore::LET_UNDERSCORE_DROP),
         LintId::of(&let_underscore::LET_UNDERSCORE_LOCK),
         LintId::of(&lifetimes::EXTRA_UNUSED_LIFETIMES),
         LintId::of(&lifetimes::NEEDLESS_LIFETIMES),
@@ -1809,6 +1811,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&infinite_iter::INFINITE_ITER),
         LintId::of(&inherent_to_string::INHERENT_TO_STRING_SHADOW_DISPLAY),
         LintId::of(&inline_fn_without_body::INLINE_FN_WITHOUT_BODY),
+        LintId::of(&let_underscore::LET_UNDERSCORE_DROP),
         LintId::of(&let_underscore::LET_UNDERSCORE_LOCK),
         LintId::of(&literal_representation::MISTYPED_LITERAL_SUFFIXES),
         LintId::of(&loops::FOR_LOOPS_OVER_FALLIBLES),
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index bc0a0ad2b17..8b5e6cc916f 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -1117,6 +1117,13 @@ vec![
         deprecation: None,
         module: "returns",
     },
+    Lint {
+        name: "let_underscore_drop",
+        group: "correctness",
+        desc: "non-binding let on a type that implements `Drop`",
+        deprecation: None,
+        module: "let_underscore",
+    },
     Lint {
         name: "let_underscore_lock",
         group: "correctness",
diff --git a/tests/ui/let_underscore_drop.rs b/tests/ui/let_underscore_drop.rs
new file mode 100644
index 00000000000..98593edb9c5
--- /dev/null
+++ b/tests/ui/let_underscore_drop.rs
@@ -0,0 +1,19 @@
+#![warn(clippy::let_underscore_drop)]
+
+struct Droppable;
+
+impl Drop for Droppable {
+    fn drop(&mut self) {}
+}
+
+fn main() {
+    let unit = ();
+    let boxed = Box::new(());
+    let droppable = Droppable;
+    let optional = Some(Droppable);
+
+    let _ = ();
+    let _ = Box::new(());
+    let _ = Droppable;
+    let _ = Some(Droppable);
+}
diff --git a/tests/ui/let_underscore_drop.stderr b/tests/ui/let_underscore_drop.stderr
new file mode 100644
index 00000000000..6dc8904c4fe
--- /dev/null
+++ b/tests/ui/let_underscore_drop.stderr
@@ -0,0 +1,27 @@
+error: non-binding let on a type that implements `Drop`
+  --> $DIR/let_underscore_drop.rs:16:5
+   |
+LL |     let _ = Box::new(());
+   |     ^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::let-underscore-drop` implied by `-D warnings`
+   = help: consider using an underscore-prefixed named binding or dropping explicitly with `std::mem::drop`
+
+error: non-binding let on a type that implements `Drop`
+  --> $DIR/let_underscore_drop.rs:17:5
+   |
+LL |     let _ = Droppable;
+   |     ^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using an underscore-prefixed named binding or dropping explicitly with `std::mem::drop`
+
+error: non-binding let on a type that implements `Drop`
+  --> $DIR/let_underscore_drop.rs:18:5
+   |
+LL |     let _ = Some(Droppable);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using an underscore-prefixed named binding or dropping explicitly with `std::mem::drop`
+
+error: aborting due to 3 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From b0994064b03f1f9f8bdb8f594bdaec9dbaa0788a Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Thu, 29 Oct 2020 16:21:01 -0500
Subject: Make KNOW_TYPES static

---
 clippy_lints/src/methods/mod.rs | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index a3fa3bdd36a..5309253531b 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1803,6 +1803,14 @@ fn lint_or_fun_call<'tcx>(
         or_has_args: bool,
         span: Span,
     ) {
+        // (path, fn_has_argument, methods, suffix)
+        static KNOW_TYPES: [(&[&str], bool, &[&str], &str); 4] = [
+            (&paths::BTREEMAP_ENTRY, false, &["or_insert"], "with"),
+            (&paths::HASHMAP_ENTRY, false, &["or_insert"], "with"),
+            (&paths::OPTION, false, &["map_or", "ok_or", "or", "unwrap_or"], "else"),
+            (&paths::RESULT, true, &["or", "unwrap_or"], "else"),
+        ];
+
         if let hir::ExprKind::MethodCall(ref path, _, ref args, _) = &arg.kind {
             if path.ident.as_str() == "len" {
                 let ty = cx.typeck_results().expr_ty(&args[0]).peel_refs();
@@ -1818,16 +1826,8 @@ fn lint_or_fun_call<'tcx>(
             }
         }
 
-        // (path, fn_has_argument, methods, suffix)
-        let know_types: &[(&[_], _, &[_], _)] = &[
-            (&paths::BTREEMAP_ENTRY, false, &["or_insert"], "with"),
-            (&paths::HASHMAP_ENTRY, false, &["or_insert"], "with"),
-            (&paths::OPTION, false, &["map_or", "ok_or", "or", "unwrap_or"], "else"),
-            (&paths::RESULT, true, &["or", "unwrap_or"], "else"),
-        ];
-
         if_chain! {
-            if know_types.iter().any(|k| k.2.contains(&name));
+            if KNOW_TYPES.iter().any(|k| k.2.contains(&name));
 
             if is_lazyness_candidate(cx, arg);
             if !contains_return(&arg);
@@ -1835,7 +1835,7 @@ fn lint_or_fun_call<'tcx>(
             let self_ty = cx.typeck_results().expr_ty(self_expr);
 
             if let Some(&(_, fn_has_arguments, poss, suffix)) =
-                know_types.iter().find(|&&i| match_type(cx, self_ty, i.0));
+                KNOW_TYPES.iter().find(|&&i| match_type(cx, self_ty, i.0));
 
             if poss.contains(&name);
 
-- 
cgit 1.4.1-3-g733a5


From 9cab08465b5d5b4bb4f5ff406b2e18ca550f7d93 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Thu, 29 Oct 2020 15:30:20 -0500
Subject: Fix or_fun_call for index operator

---
 clippy_lints/src/methods/mod.rs         | 45 ++++++++++++++-------------------
 clippy_lints/src/utils/eager_or_lazy.rs |  7 ++++-
 tests/ui/or_fun_call.fixed              |  9 +++++++
 tests/ui/or_fun_call.rs                 |  9 +++++++
 tests/ui/or_fun_call.stderr             | 18 ++++++++++---
 5 files changed, 58 insertions(+), 30 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 5309253531b..b6fb3d06934 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1797,11 +1797,11 @@ fn lint_or_fun_call<'tcx>(
         cx: &LateContext<'tcx>,
         name: &str,
         method_span: Span,
-        fun_span: Span,
         self_expr: &hir::Expr<'_>,
         arg: &'tcx hir::Expr<'_>,
-        or_has_args: bool,
         span: Span,
+        // None if lambda is required
+        fun_span: Option<Span>,
     ) {
         // (path, fn_has_argument, methods, suffix)
         static KNOW_TYPES: [(&[&str], bool, &[&str], &str); 4] = [
@@ -1840,10 +1840,18 @@ fn lint_or_fun_call<'tcx>(
             if poss.contains(&name);
 
             then {
-                let sugg: Cow<'_, _> = match (fn_has_arguments, !or_has_args) {
-                    (true, _) => format!("|_| {}", snippet_with_macro_callsite(cx, arg.span, "..")).into(),
-                    (false, false) => format!("|| {}", snippet_with_macro_callsite(cx, arg.span, "..")).into(),
-                    (false, true) => snippet_with_macro_callsite(cx, fun_span, ".."),
+                let sugg: Cow<'_, str> = {
+                    let (snippet_span, use_lambda) = match (fn_has_arguments, fun_span) {
+                        (false, Some(fun_span)) => (fun_span, false),
+                        _ => (arg.span, true),
+                    };
+                    let snippet = snippet_with_macro_callsite(cx, snippet_span, "..");
+                    if use_lambda {
+                        let l_arg = if fn_has_arguments { "_" } else { "" };
+                        format!("|{}| {}", l_arg, snippet).into()
+                    } else {
+                        snippet
+                    }
                 };
                 let span_replace_word = method_span.with_hi(span.hi());
                 span_lint_and_sugg(
@@ -1864,28 +1872,13 @@ fn lint_or_fun_call<'tcx>(
             hir::ExprKind::Call(ref fun, ref or_args) => {
                 let or_has_args = !or_args.is_empty();
                 if !check_unwrap_or_default(cx, name, fun, &args[0], &args[1], or_has_args, expr.span) {
-                    check_general_case(
-                        cx,
-                        name,
-                        method_span,
-                        fun.span,
-                        &args[0],
-                        &args[1],
-                        or_has_args,
-                        expr.span,
-                    );
+                    let fun_span = if or_has_args { None } else { Some(fun.span) };
+                    check_general_case(cx, name, method_span, &args[0], &args[1], expr.span, fun_span);
                 }
             },
-            hir::ExprKind::MethodCall(_, span, ref or_args, _) => check_general_case(
-                cx,
-                name,
-                method_span,
-                span,
-                &args[0],
-                &args[1],
-                !or_args.is_empty(),
-                expr.span,
-            ),
+            hir::ExprKind::Index(..) | hir::ExprKind::MethodCall(..) => {
+                check_general_case(cx, name, method_span, &args[0], &args[1], expr.span, None);
+            },
             _ => {},
         }
     }
diff --git a/clippy_lints/src/utils/eager_or_lazy.rs b/clippy_lints/src/utils/eager_or_lazy.rs
index 4ceea13df37..8fe5ddee1ca 100644
--- a/clippy_lints/src/utils/eager_or_lazy.rs
+++ b/clippy_lints/src/utils/eager_or_lazy.rs
@@ -9,7 +9,7 @@
 //!  - or-fun-call
 //!  - option-if-let-else
 
-use crate::utils::is_ctor_or_promotable_const_function;
+use crate::utils::{is_ctor_or_promotable_const_function, is_type_diagnostic_item, match_type, paths};
 use rustc_hir::def::{DefKind, Res};
 
 use rustc_hir::intravisit;
@@ -96,6 +96,11 @@ fn identify_some_potentially_expensive_patterns<'tcx>(cx: &LateContext<'tcx>, ex
             let call_found = match &expr.kind {
                 // ignore enum and struct constructors
                 ExprKind::Call(..) => !is_ctor_or_promotable_const_function(self.cx, expr),
+                ExprKind::Index(obj, _) => {
+                    let ty = self.cx.typeck_results().expr_ty(obj);
+                    is_type_diagnostic_item(self.cx, ty, sym!(hashmap_type))
+                        || match_type(self.cx, ty, &paths::BTREEMAP)
+                },
                 ExprKind::MethodCall(..) => true,
                 _ => false,
             };
diff --git a/tests/ui/or_fun_call.fixed b/tests/ui/or_fun_call.fixed
index 2045ffdb5f0..20e5016bc17 100644
--- a/tests/ui/or_fun_call.fixed
+++ b/tests/ui/or_fun_call.fixed
@@ -70,6 +70,15 @@ fn or_fun_call() {
     let opt = Some(1);
     let hello = "Hello";
     let _ = opt.ok_or(format!("{} world.", hello));
+
+    // index
+    let map = HashMap::<u64, u64>::new();
+    let _ = Some(1).unwrap_or_else(|| map[&1]);
+    let map = BTreeMap::<u64, u64>::new();
+    let _ = Some(1).unwrap_or_else(|| map[&1]);
+    // don't lint index vec
+    let vec = vec![1];
+    let _ = Some(1).unwrap_or(vec[1]);
 }
 
 struct Foo(u8);
diff --git a/tests/ui/or_fun_call.rs b/tests/ui/or_fun_call.rs
index 522f31b72d0..e7192deeebb 100644
--- a/tests/ui/or_fun_call.rs
+++ b/tests/ui/or_fun_call.rs
@@ -70,6 +70,15 @@ fn or_fun_call() {
     let opt = Some(1);
     let hello = "Hello";
     let _ = opt.ok_or(format!("{} world.", hello));
+
+    // index
+    let map = HashMap::<u64, u64>::new();
+    let _ = Some(1).unwrap_or(map[&1]);
+    let map = BTreeMap::<u64, u64>::new();
+    let _ = Some(1).unwrap_or(map[&1]);
+    // don't lint index vec
+    let vec = vec![1];
+    let _ = Some(1).unwrap_or(vec[1]);
 }
 
 struct Foo(u8);
diff --git a/tests/ui/or_fun_call.stderr b/tests/ui/or_fun_call.stderr
index bc5978b538f..d0c4df0e008 100644
--- a/tests/ui/or_fun_call.stderr
+++ b/tests/ui/or_fun_call.stderr
@@ -78,17 +78,29 @@ error: use of `unwrap_or` followed by a function call
 LL |     let _ = stringy.unwrap_or("".to_owned());
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|| "".to_owned())`
 
+error: use of `unwrap_or` followed by a function call
+  --> $DIR/or_fun_call.rs:76:21
+   |
+LL |     let _ = Some(1).unwrap_or(map[&1]);
+   |                     ^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|| map[&1])`
+
+error: use of `unwrap_or` followed by a function call
+  --> $DIR/or_fun_call.rs:78:21
+   |
+LL |     let _ = Some(1).unwrap_or(map[&1]);
+   |                     ^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|| map[&1])`
+
 error: use of `or` followed by a function call
-  --> $DIR/or_fun_call.rs:93:35
+  --> $DIR/or_fun_call.rs:102:35
    |
 LL |     let _ = Some("a".to_string()).or(Some("b".to_string()));
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `or_else(|| Some("b".to_string()))`
 
 error: use of `or` followed by a function call
-  --> $DIR/or_fun_call.rs:97:10
+  --> $DIR/or_fun_call.rs:106:10
    |
 LL |         .or(Some(Bar(b, Duration::from_secs(2))));
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `or_else(|| Some(Bar(b, Duration::from_secs(2))))`
 
-error: aborting due to 15 previous errors
+error: aborting due to 17 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From aa6bf1f90d9191cdf4c6d925f8137fa8eac37889 Mon Sep 17 00:00:00 2001
From: "Samuel E. Moelius" <35515885+smoelius@users.noreply.github.com>
Date: Sun, 8 Nov 2020 17:24:55 -0500
Subject: Update clippy_lints/src/let_underscore.rs

Co-authored-by: Philipp Krones <hello@philkrones.com>
---
 clippy_lints/src/let_underscore.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/let_underscore.rs b/clippy_lints/src/let_underscore.rs
index 9c7fd634547..e8e64bca535 100644
--- a/clippy_lints/src/let_underscore.rs
+++ b/clippy_lints/src/let_underscore.rs
@@ -141,7 +141,7 @@ impl<'tcx> LateLintPass<'tcx> for LetUnderscore {
                         cx,
                         LET_UNDERSCORE_DROP,
                         local.span,
-                        "non-binding let on a type that implements `Drop`",
+                        "non-binding `let` on a type that implements `Drop`",
                         None,
                         "consider using an underscore-prefixed named \
                             binding or dropping explicitly with `std::mem::drop`"
-- 
cgit 1.4.1-3-g733a5


From 9751cba2c675c2cd46742d2a81c891d4db4deacc Mon Sep 17 00:00:00 2001
From: "Samuel E. Moelius" <35515885+smoelius@users.noreply.github.com>
Date: Sun, 8 Nov 2020 17:25:23 -0500
Subject: Update clippy_lints/src/let_underscore.rs

Co-authored-by: Philipp Krones <hello@philkrones.com>
---
 clippy_lints/src/let_underscore.rs | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/let_underscore.rs b/clippy_lints/src/let_underscore.rs
index e8e64bca535..fb2df9369dc 100644
--- a/clippy_lints/src/let_underscore.rs
+++ b/clippy_lints/src/let_underscore.rs
@@ -79,12 +79,20 @@ declare_clippy_lint! {
     /// impl Drop for Droppable {
     ///     fn drop(&mut self) {}
     /// }
-    /// let _ = Droppable;
+    /// {
+    ///     let _ = Droppable;
+    ///     //               ^ dropped here
+    ///     /* more code */
+    /// }
     /// ```
     ///
     /// Good:
     /// ```rust,ignore
-    /// let _droppable = Droppable;
+    /// {
+    ///     let _droppable = Droppable;
+    ///     /* more code */
+    ///     // dropped at end of scope
+    /// }
     /// ```
     pub LET_UNDERSCORE_DROP,
     correctness,
-- 
cgit 1.4.1-3-g733a5


From 8211b597baff7d599df8c1fe42f4e7d15b7d3e95 Mon Sep 17 00:00:00 2001
From: "Samuel E. Moelius" <35515885+smoelius@users.noreply.github.com>
Date: Sun, 8 Nov 2020 17:25:50 -0500
Subject: Update clippy_lints/src/let_underscore.rs

Co-authored-by: Philipp Krones <hello@philkrones.com>
---
 clippy_lints/src/let_underscore.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/let_underscore.rs b/clippy_lints/src/let_underscore.rs
index fb2df9369dc..6a5a77f8690 100644
--- a/clippy_lints/src/let_underscore.rs
+++ b/clippy_lints/src/let_underscore.rs
@@ -95,7 +95,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     pub LET_UNDERSCORE_DROP,
-    correctness,
+    pedantic,
     "non-binding let on a type that implements `Drop`"
 }
 
-- 
cgit 1.4.1-3-g733a5


From 40d7af50ed9811e427aa65b0111bca261ecf1239 Mon Sep 17 00:00:00 2001
From: "Samuel E. Moelius III" <sam@moeli.us>
Date: Sun, 8 Nov 2020 17:33:54 -0500
Subject: Update lints

---
 clippy_lints/src/lib.rs | 3 +--
 src/lintlist/mod.rs     | 2 +-
 2 files changed, 2 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index b44e28b4596..20b38cbb6d0 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1241,6 +1241,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&infinite_iter::MAYBE_INFINITE_ITER),
         LintId::of(&items_after_statements::ITEMS_AFTER_STATEMENTS),
         LintId::of(&large_stack_arrays::LARGE_STACK_ARRAYS),
+        LintId::of(&let_underscore::LET_UNDERSCORE_DROP),
         LintId::of(&literal_representation::LARGE_DIGIT_GROUPS),
         LintId::of(&literal_representation::UNREADABLE_LITERAL),
         LintId::of(&loops::EXPLICIT_INTO_ITER_LOOP),
@@ -1384,7 +1385,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&len_zero::COMPARISON_TO_EMPTY),
         LintId::of(&len_zero::LEN_WITHOUT_IS_EMPTY),
         LintId::of(&len_zero::LEN_ZERO),
-        LintId::of(&let_underscore::LET_UNDERSCORE_DROP),
         LintId::of(&let_underscore::LET_UNDERSCORE_LOCK),
         LintId::of(&lifetimes::EXTRA_UNUSED_LIFETIMES),
         LintId::of(&lifetimes::NEEDLESS_LIFETIMES),
@@ -1811,7 +1811,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&infinite_iter::INFINITE_ITER),
         LintId::of(&inherent_to_string::INHERENT_TO_STRING_SHADOW_DISPLAY),
         LintId::of(&inline_fn_without_body::INLINE_FN_WITHOUT_BODY),
-        LintId::of(&let_underscore::LET_UNDERSCORE_DROP),
         LintId::of(&let_underscore::LET_UNDERSCORE_LOCK),
         LintId::of(&literal_representation::MISTYPED_LITERAL_SUFFIXES),
         LintId::of(&loops::FOR_LOOPS_OVER_FALLIBLES),
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index 8b5e6cc916f..4f1b56ed9be 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -1119,7 +1119,7 @@ vec![
     },
     Lint {
         name: "let_underscore_drop",
-        group: "correctness",
+        group: "pedantic",
         desc: "non-binding let on a type that implements `Drop`",
         deprecation: None,
         module: "let_underscore",
-- 
cgit 1.4.1-3-g733a5


From effcb52bbf818ca39c57f9beb7d7d63b1e47d1fd Mon Sep 17 00:00:00 2001
From: Eduardo Broto <ebroto@tutanota.com>
Date: Tue, 10 Nov 2020 22:33:02 +0100
Subject: Run cargo dev fmt

---
 clippy_lints/src/non_expressive_names.rs | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/non_expressive_names.rs b/clippy_lints/src/non_expressive_names.rs
index 6b175490cc8..5b42b61fcde 100644
--- a/clippy_lints/src/non_expressive_names.rs
+++ b/clippy_lints/src/non_expressive_names.rs
@@ -1,7 +1,5 @@
 use crate::utils::{span_lint, span_lint_and_then};
-use rustc_ast::ast::{
-    Arm, AssocItem, AssocItemKind, Attribute, Block, FnDecl, Item, ItemKind, Local, Pat, PatKind,
-};
+use rustc_ast::ast::{Arm, AssocItem, AssocItemKind, Attribute, Block, FnDecl, Item, ItemKind, Local, Pat, PatKind};
 use rustc_ast::visit::{walk_block, walk_expr, walk_pat, Visitor};
 use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_middle::lint::in_external_macro;
-- 
cgit 1.4.1-3-g733a5


From 769094410a22849c426972dd421a1937463a48e7 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Fri, 30 Oct 2020 09:18:16 -0500
Subject: Fix map_clone with deref and clone

---
 clippy_lints/src/map_clone.rs | 14 +++++++++-----
 tests/ui/map_clone.fixed      |  7 +++++++
 tests/ui/map_clone.rs         |  7 +++++++
 3 files changed, 23 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/map_clone.rs b/clippy_lints/src/map_clone.rs
index 9a00608ce39..3f34dd5112e 100644
--- a/clippy_lints/src/map_clone.rs
+++ b/clippy_lints/src/map_clone.rs
@@ -8,6 +8,7 @@ use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::mir::Mutability;
 use rustc_middle::ty;
+use rustc_middle::ty::adjustment::Adjust;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::symbol::Ident;
 use rustc_span::{sym, Span};
@@ -75,11 +76,14 @@ impl<'tcx> LateLintPass<'tcx> for MapClone {
                                     }
                                 }
                             },
-                            hir::ExprKind::MethodCall(ref method, _, ref obj, _) => {
-                                if ident_eq(name, &obj[0]) && method.ident.as_str() == "clone"
-                                    && match_trait_method(cx, closure_expr, &paths::CLONE_TRAIT) {
-
-                                    let obj_ty = cx.typeck_results().expr_ty(&obj[0]);
+                            hir::ExprKind::MethodCall(ref method, _, [obj], _) => if_chain! {
+                                if ident_eq(name, obj) && method.ident.name == sym::clone;
+                                if match_trait_method(cx, closure_expr, &paths::CLONE_TRAIT);
+                                // no autoderefs
+                                if !cx.typeck_results().expr_adjustments(obj).iter()
+                                    .any(|a| matches!(a.kind, Adjust::Deref(Some(..))));
+                                then {
+                                    let obj_ty = cx.typeck_results().expr_ty(obj);
                                     if let ty::Ref(_, ty, mutability) = obj_ty.kind() {
                                         if matches!(mutability, Mutability::Not) {
                                             let copy = is_copy(cx, ty);
diff --git a/tests/ui/map_clone.fixed b/tests/ui/map_clone.fixed
index 6e3a8e67e81..504ae281fe7 100644
--- a/tests/ui/map_clone.fixed
+++ b/tests/ui/map_clone.fixed
@@ -52,4 +52,11 @@ fn main() {
         let items = vec![&mut aa, &mut bb];
         let _: Vec<_> = items.into_iter().map(|x| x.clone()).collect();
     }
+
+    // Issue #6239 deref coercion and clone deref
+    {
+        use std::cell::RefCell;
+
+        let _ = Some(RefCell::new(String::new()).borrow()).map(|s| s.clone());
+    }
 }
diff --git a/tests/ui/map_clone.rs b/tests/ui/map_clone.rs
index 6fd395710d4..9348e6bae7a 100644
--- a/tests/ui/map_clone.rs
+++ b/tests/ui/map_clone.rs
@@ -52,4 +52,11 @@ fn main() {
         let items = vec![&mut aa, &mut bb];
         let _: Vec<_> = items.into_iter().map(|x| x.clone()).collect();
     }
+
+    // Issue #6239 deref coercion and clone deref
+    {
+        use std::cell::RefCell;
+
+        let _ = Some(RefCell::new(String::new()).borrow()).map(|s| s.clone());
+    }
 }
-- 
cgit 1.4.1-3-g733a5


From a1cf2d334d685fa11fdc96fc98f35292254e5651 Mon Sep 17 00:00:00 2001
From: Ryan Sullivant <rsulli55@gmail.com>
Date: Mon, 5 Oct 2020 21:23:36 -0700
Subject: Added a lint as suggested in 6010 which recommends using `contains()`
 instead of `find()` follows by `is_some()` on strings

Update clippy_lints/src/find_is_some_on_strs.rs
Co-authored-by: Takayuki Nakata <f.seasons017@gmail.com>

Update clippy_lints/src/methods/mod.rs
Co-authored-by: Philipp Krones <hello@philkrones.com>
---
 clippy_lints/src/methods/mod.rs | 38 +++++++++++++++++++++++++++++++++++---
 src/lintlist/mod.rs             |  2 +-
 tests/ui/methods.rs             | 23 +++++++++++++++++++++--
 tests/ui/methods.stderr         |  2 --
 4 files changed, 57 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index b6fb3d06934..bd04a95e4a1 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -515,11 +515,11 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for an iterator search (such as `find()`,
+    /// **What it does:** Checks for an iterator or string search (such as `find()`,
     /// `position()`, or `rposition()`) followed by a call to `is_some()`.
     ///
     /// **Why is this bad?** Readability, this can be written more concisely as
-    /// `_.any(_)`.
+    /// `_.any(_)` or `_.contains(_)`.
     ///
     /// **Known problems:** None.
     ///
@@ -535,7 +535,7 @@ declare_clippy_lint! {
     /// ```
     pub SEARCH_IS_SOME,
     complexity,
-    "using an iterator search followed by `is_some()`, which is more succinctly expressed as a call to `any()`"
+    "using an iterator or string search followed by `is_some()`, which is more succinctly expressed as a call to `any()` or `contains()`"
 }
 
 declare_clippy_lint! {
@@ -3041,6 +3041,7 @@ fn lint_flat_map_identity<'tcx>(
 }
 
 /// lint searching an Iterator followed by `is_some()`
+/// or calling `find()` on a string followed by `is_some()`
 fn lint_search_is_some<'tcx>(
     cx: &LateContext<'tcx>,
     expr: &'tcx hir::Expr<'_>,
@@ -3094,6 +3095,37 @@ fn lint_search_is_some<'tcx>(
             span_lint(cx, SEARCH_IS_SOME, expr.span, &msg);
         }
     }
+    // lint if `find()` is called by `String` or `&str`
+    else if search_method == "find" {
+        let is_string_or_str_slice = |e| {
+            let self_ty = cx.typeck_results().expr_ty(e).peel_refs();
+            if is_type_diagnostic_item(cx, self_ty, sym!(string_type)) {
+                true
+            } else {
+                *self_ty.kind() == ty::Str
+            }
+        };
+        if_chain! {
+            if is_string_or_str_slice(&search_args[0]);
+            if is_string_or_str_slice(&search_args[1]);
+            then {
+                let msg = "called `is_some()` after calling `find()` \
+                    on a string. This is more succinctly expressed by calling \
+                    `contains()`.".to_string();
+                let mut applicability = Applicability::MachineApplicable;
+                let find_arg = snippet_with_applicability(cx, search_args[1].span, "..", &mut applicability);
+                span_lint_and_sugg(
+                    cx,
+                    SEARCH_IS_SOME,
+                    method_span.with_hi(expr.span.hi()),
+                    &msg,
+                    "try this",
+                    format!("contains({})", find_arg),
+                    applicability,
+                );
+            }
+        }
+    }
 }
 
 /// Used for `lint_binary_expr_with_method_call`.
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index 4f1b56ed9be..69acd3d9b8b 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -2121,7 +2121,7 @@ vec![
     Lint {
         name: "search_is_some",
         group: "complexity",
-        desc: "using an iterator search followed by `is_some()`, which is more succinctly expressed as a call to `any()`",
+        desc: "using an iterator or string search followed by `is_some()`, which is more succinctly expressed as a call to `any()` or `contains()`",
         deprecation: None,
         module: "methods",
     },
diff --git a/tests/ui/methods.rs b/tests/ui/methods.rs
index d93e5b114ec..92ec00a11d2 100644
--- a/tests/ui/methods.rs
+++ b/tests/ui/methods.rs
@@ -168,8 +168,27 @@ fn search_is_some() {
                                    x < 0
                                }
                    ).is_some();
-
-    // Check that we don't lint if the caller is not an `Iterator`.
+    
+    let s1 = String::from("hello world");
+    let s2 = String::from("world");
+    // Check caller `find()` is a &`static str case
+    let _ = "hello world".find("world").is_some();
+    let _ = "hello world".find(&s2).is_some();
+    let _ = "hello world".find(&s2[2..]).is_some();
+    // Check caller of `find()` is a String case
+    let _ = s1.find("world").is_some();
+    let _ = s1.find(&s2).is_some();
+    let _ = s1.find(&s2[2..]).is_some();
+    //  Check caller of `find()` is a slice of String case
+    let _ = s1[2..].find("world").is_some();
+    let _ = s1[2..].find(&s2).is_some();
+    let _ = s1[2..].find(&s2[2..]).is_some();
+
+    // Check that we don't lint if `find()` is called with
+    // Pattern that is not a string
+    let _ = s1.find(|c: char| c == 'o' || c == 'l').is_some();
+
+    // Check that we don't lint if the caller is not an `Iterator` or string
     let foo = IteratorFalsePositives { foo: 0 };
     let _ = foo.find().is_some();
     let _ = foo.position().is_some();
diff --git a/tests/ui/methods.stderr b/tests/ui/methods.stderr
index 8a281c2dbd2..b2b551bd5f8 100644
--- a/tests/ui/methods.stderr
+++ b/tests/ui/methods.stderr
@@ -88,5 +88,3 @@ LL | |                                }
 LL | |                    ).is_some();
    | |______________________________^
 
-error: aborting due to 11 previous errors
-
-- 
cgit 1.4.1-3-g733a5


From e9612f3eca5566b601dda60c999be69e50f89cac Mon Sep 17 00:00:00 2001
From: rsulli55 <rsulli55@gmail.com>
Date: Sun, 25 Oct 2020 18:11:38 -0700
Subject: Remove `to_string` on msg

Co-authored-by: Philipp Krones <hello@philkrones.com>
---
 clippy_lints/src/methods/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index bd04a95e4a1..4df1b3d197f 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3111,7 +3111,7 @@ fn lint_search_is_some<'tcx>(
             then {
                 let msg = "called `is_some()` after calling `find()` \
                     on a string. This is more succinctly expressed by calling \
-                    `contains()`.".to_string();
+                    `contains()`";
                 let mut applicability = Applicability::MachineApplicable;
                 let find_arg = snippet_with_applicability(cx, search_args[1].span, "..", &mut applicability);
                 span_lint_and_sugg(
-- 
cgit 1.4.1-3-g733a5


From fb74b4802eda6da49f0ea9f2bc1ef238306c1329 Mon Sep 17 00:00:00 2001
From: rsulli55 <rsulli55@gmail.com>
Date: Sun, 25 Oct 2020 18:11:57 -0700
Subject: Remove borrow

Co-authored-by: Philipp Krones <hello@philkrones.com>
---
 clippy_lints/src/methods/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 4df1b3d197f..fc66bf0422f 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3118,7 +3118,7 @@ fn lint_search_is_some<'tcx>(
                     cx,
                     SEARCH_IS_SOME,
                     method_span.with_hi(expr.span.hi()),
-                    &msg,
+                    msg,
                     "try this",
                     format!("contains({})", find_arg),
                     applicability,
-- 
cgit 1.4.1-3-g733a5


From ee1b959054aaf69968d440915766e834568de8fd Mon Sep 17 00:00:00 2001
From: Ryan Sullivant <rsulli55@gmail.com>
Date: Sat, 31 Oct 2020 12:40:56 -0700
Subject: Added period back to lint `search_is_some` and ran
 `update-all-references.sh`

---
 clippy_lints/src/methods/mod.rs | 2 +-
 tests/ui/methods.stderr         | 2 ++
 2 files changed, 3 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index fc66bf0422f..19e63fbddf7 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3111,7 +3111,7 @@ fn lint_search_is_some<'tcx>(
             then {
                 let msg = "called `is_some()` after calling `find()` \
                     on a string. This is more succinctly expressed by calling \
-                    `contains()`";
+                    `contains()`.";
                 let mut applicability = Applicability::MachineApplicable;
                 let find_arg = snippet_with_applicability(cx, search_args[1].span, "..", &mut applicability);
                 span_lint_and_sugg(
diff --git a/tests/ui/methods.stderr b/tests/ui/methods.stderr
index bf4675966df..33aba630a53 100644
--- a/tests/ui/methods.stderr
+++ b/tests/ui/methods.stderr
@@ -20,3 +20,5 @@ LL | |                    ).next();
    |
    = note: `-D clippy::filter-next` implied by `-D warnings`
 
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From fd303132a27f0fa9bbbfb3282200f8190353574b Mon Sep 17 00:00:00 2001
From: Ryan Sullivant <rsulli55@gmail.com>
Date: Sat, 7 Nov 2020 00:21:22 -0700
Subject: Cleaned up message and suggestion for `lint_search_is_some`

---
 clippy_lints/src/methods/mod.rs        | 14 ++++----
 tests/ui/search_is_some.stderr         | 11 +++++--
 tests/ui/search_is_some_fixable.stderr | 60 +++++++++++++++++-----------------
 3 files changed, 44 insertions(+), 41 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 19e63fbddf7..66f5aa0c6a0 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3053,10 +3053,10 @@ fn lint_search_is_some<'tcx>(
     // lint if caller of search is an Iterator
     if match_trait_method(cx, &is_some_args[0], &paths::ITERATOR) {
         let msg = format!(
-            "called `is_some()` after searching an `Iterator` with {}. This is more succinctly \
-             expressed by calling `any()`.",
+            "called `is_some()` after searching an `Iterator` with {}",
             search_method
         );
+        let hint = "this is more succinctly expressed by calling `any()`";
         let search_snippet = snippet(cx, search_args[1].span, "..");
         if search_snippet.lines().count() <= 1 {
             // suggest `any(|x| ..)` instead of `any(|&x| ..)` for `find(|&x| ..).is_some()`
@@ -3084,7 +3084,7 @@ fn lint_search_is_some<'tcx>(
                 SEARCH_IS_SOME,
                 method_span.with_hi(expr.span.hi()),
                 &msg,
-                "try this",
+                "use `any()` instead",
                 format!(
                     "any({})",
                     any_search_snippet.as_ref().map_or(&*search_snippet, String::as_str)
@@ -3092,7 +3092,7 @@ fn lint_search_is_some<'tcx>(
                 Applicability::MachineApplicable,
             );
         } else {
-            span_lint(cx, SEARCH_IS_SOME, expr.span, &msg);
+            span_lint_and_help(cx, SEARCH_IS_SOME, expr.span, &msg, None, hint);
         }
     }
     // lint if `find()` is called by `String` or `&str`
@@ -3109,9 +3109,7 @@ fn lint_search_is_some<'tcx>(
             if is_string_or_str_slice(&search_args[0]);
             if is_string_or_str_slice(&search_args[1]);
             then {
-                let msg = "called `is_some()` after calling `find()` \
-                    on a string. This is more succinctly expressed by calling \
-                    `contains()`.";
+                let msg = "called `is_some()` after calling `find()` on a string";
                 let mut applicability = Applicability::MachineApplicable;
                 let find_arg = snippet_with_applicability(cx, search_args[1].span, "..", &mut applicability);
                 span_lint_and_sugg(
@@ -3119,7 +3117,7 @@ fn lint_search_is_some<'tcx>(
                     SEARCH_IS_SOME,
                     method_span.with_hi(expr.span.hi()),
                     msg,
-                    "try this",
+                    "use `contains()` instead",
                     format!("contains({})", find_arg),
                     applicability,
                 );
diff --git a/tests/ui/search_is_some.stderr b/tests/ui/search_is_some.stderr
index a124ab1dfd4..43827a6a98d 100644
--- a/tests/ui/search_is_some.stderr
+++ b/tests/ui/search_is_some.stderr
@@ -1,4 +1,4 @@
-error: called `is_some()` after searching an `Iterator` with find. This is more succinctly expressed by calling `any()`.
+error: called `is_some()` after searching an `Iterator` with find
   --> $DIR/search_is_some.rs:13:13
    |
 LL |       let _ = v.iter().find(|&x| {
@@ -9,8 +9,9 @@ LL | |                    ).is_some();
    | |______________________________^
    |
    = note: `-D clippy::search-is-some` implied by `-D warnings`
+   = help: this is more succinctly expressed by calling `any()`
 
-error: called `is_some()` after searching an `Iterator` with position. This is more succinctly expressed by calling `any()`.
+error: called `is_some()` after searching an `Iterator` with position
   --> $DIR/search_is_some.rs:19:13
    |
 LL |       let _ = v.iter().position(|&x| {
@@ -19,8 +20,10 @@ LL | |                                   x < 0
 LL | |                               }
 LL | |                    ).is_some();
    | |______________________________^
+   |
+   = help: this is more succinctly expressed by calling `any()`
 
-error: called `is_some()` after searching an `Iterator` with rposition. This is more succinctly expressed by calling `any()`.
+error: called `is_some()` after searching an `Iterator` with rposition
   --> $DIR/search_is_some.rs:25:13
    |
 LL |       let _ = v.iter().rposition(|&x| {
@@ -29,6 +32,8 @@ LL | |                                    x < 0
 LL | |                                }
 LL | |                    ).is_some();
    | |______________________________^
+   |
+   = help: this is more succinctly expressed by calling `any()`
 
 error: use of a blacklisted/placeholder name `foo`
   --> $DIR/search_is_some.rs:31:9
diff --git a/tests/ui/search_is_some_fixable.stderr b/tests/ui/search_is_some_fixable.stderr
index 7a2c063fee8..f4c5d7a3389 100644
--- a/tests/ui/search_is_some_fixable.stderr
+++ b/tests/ui/search_is_some_fixable.stderr
@@ -1,94 +1,94 @@
-error: called `is_some()` after searching an `Iterator` with find. This is more succinctly expressed by calling `any()`.
+error: called `is_some()` after searching an `Iterator` with find
   --> $DIR/search_is_some_fixable.rs:10:22
    |
 LL |     let _ = v.iter().find(|&x| *x < 0).is_some();
-   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `any(|x| *x < 0)`
+   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `any()` instead: `any(|x| *x < 0)`
    |
    = note: `-D clippy::search-is-some` implied by `-D warnings`
 
-error: called `is_some()` after searching an `Iterator` with find. This is more succinctly expressed by calling `any()`.
+error: called `is_some()` after searching an `Iterator` with find
   --> $DIR/search_is_some_fixable.rs:11:20
    |
 LL |     let _ = (0..1).find(|x| **y == *x).is_some(); // one dereference less
-   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `any(|x| **y == x)`
+   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `any()` instead: `any(|x| **y == x)`
 
-error: called `is_some()` after searching an `Iterator` with find. This is more succinctly expressed by calling `any()`.
+error: called `is_some()` after searching an `Iterator` with find
   --> $DIR/search_is_some_fixable.rs:12:20
    |
 LL |     let _ = (0..1).find(|x| *x == 0).is_some();
-   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `any(|x| x == 0)`
+   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `any()` instead: `any(|x| x == 0)`
 
-error: called `is_some()` after searching an `Iterator` with find. This is more succinctly expressed by calling `any()`.
+error: called `is_some()` after searching an `Iterator` with find
   --> $DIR/search_is_some_fixable.rs:13:22
    |
 LL |     let _ = v.iter().find(|x| **x == 0).is_some();
-   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `any(|x| *x == 0)`
+   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `any()` instead: `any(|x| *x == 0)`
 
-error: called `is_some()` after searching an `Iterator` with position. This is more succinctly expressed by calling `any()`.
+error: called `is_some()` after searching an `Iterator` with position
   --> $DIR/search_is_some_fixable.rs:16:22
    |
 LL |     let _ = v.iter().position(|&x| x < 0).is_some();
-   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `any(|&x| x < 0)`
+   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `any()` instead: `any(|&x| x < 0)`
 
-error: called `is_some()` after searching an `Iterator` with rposition. This is more succinctly expressed by calling `any()`.
+error: called `is_some()` after searching an `Iterator` with rposition
   --> $DIR/search_is_some_fixable.rs:19:22
    |
 LL |     let _ = v.iter().rposition(|&x| x < 0).is_some();
-   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `any(|&x| x < 0)`
+   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `any()` instead: `any(|&x| x < 0)`
 
-error: called `is_some()` after calling `find()` on a string. This is more succinctly expressed by calling `contains()`.
+error: called `is_some()` after calling `find()` on a string
   --> $DIR/search_is_some_fixable.rs:24:27
    |
 LL |     let _ = "hello world".find("world").is_some();
-   |                           ^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `contains("world")`
+   |                           ^^^^^^^^^^^^^^^^^^^^^^^ help: use `contains()` instead: `contains("world")`
 
-error: called `is_some()` after calling `find()` on a string. This is more succinctly expressed by calling `contains()`.
+error: called `is_some()` after calling `find()` on a string
   --> $DIR/search_is_some_fixable.rs:25:27
    |
 LL |     let _ = "hello world".find(&s2).is_some();
-   |                           ^^^^^^^^^^^^^^^^^^^ help: try this: `contains(&s2)`
+   |                           ^^^^^^^^^^^^^^^^^^^ help: use `contains()` instead: `contains(&s2)`
 
-error: called `is_some()` after calling `find()` on a string. This is more succinctly expressed by calling `contains()`.
+error: called `is_some()` after calling `find()` on a string
   --> $DIR/search_is_some_fixable.rs:26:27
    |
 LL |     let _ = "hello world".find(&s2[2..]).is_some();
-   |                           ^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `contains(&s2[2..])`
+   |                           ^^^^^^^^^^^^^^^^^^^^^^^^ help: use `contains()` instead: `contains(&s2[2..])`
 
-error: called `is_some()` after calling `find()` on a string. This is more succinctly expressed by calling `contains()`.
+error: called `is_some()` after calling `find()` on a string
   --> $DIR/search_is_some_fixable.rs:28:16
    |
 LL |     let _ = s1.find("world").is_some();
-   |                ^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `contains("world")`
+   |                ^^^^^^^^^^^^^^^^^^^^^^^ help: use `contains()` instead: `contains("world")`
 
-error: called `is_some()` after calling `find()` on a string. This is more succinctly expressed by calling `contains()`.
+error: called `is_some()` after calling `find()` on a string
   --> $DIR/search_is_some_fixable.rs:29:16
    |
 LL |     let _ = s1.find(&s2).is_some();
-   |                ^^^^^^^^^^^^^^^^^^^ help: try this: `contains(&s2)`
+   |                ^^^^^^^^^^^^^^^^^^^ help: use `contains()` instead: `contains(&s2)`
 
-error: called `is_some()` after calling `find()` on a string. This is more succinctly expressed by calling `contains()`.
+error: called `is_some()` after calling `find()` on a string
   --> $DIR/search_is_some_fixable.rs:30:16
    |
 LL |     let _ = s1.find(&s2[2..]).is_some();
-   |                ^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `contains(&s2[2..])`
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^ help: use `contains()` instead: `contains(&s2[2..])`
 
-error: called `is_some()` after calling `find()` on a string. This is more succinctly expressed by calling `contains()`.
+error: called `is_some()` after calling `find()` on a string
   --> $DIR/search_is_some_fixable.rs:32:21
    |
 LL |     let _ = s1[2..].find("world").is_some();
-   |                     ^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `contains("world")`
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^ help: use `contains()` instead: `contains("world")`
 
-error: called `is_some()` after calling `find()` on a string. This is more succinctly expressed by calling `contains()`.
+error: called `is_some()` after calling `find()` on a string
   --> $DIR/search_is_some_fixable.rs:33:21
    |
 LL |     let _ = s1[2..].find(&s2).is_some();
-   |                     ^^^^^^^^^^^^^^^^^^^ help: try this: `contains(&s2)`
+   |                     ^^^^^^^^^^^^^^^^^^^ help: use `contains()` instead: `contains(&s2)`
 
-error: called `is_some()` after calling `find()` on a string. This is more succinctly expressed by calling `contains()`.
+error: called `is_some()` after calling `find()` on a string
   --> $DIR/search_is_some_fixable.rs:34:21
    |
 LL |     let _ = s1[2..].find(&s2[2..]).is_some();
-   |                     ^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `contains(&s2[2..])`
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^ help: use `contains()` instead: `contains(&s2[2..])`
 
 error: aborting due to 15 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 56d252c53d1d4f7822b336d086659c26a8f0bb4d Mon Sep 17 00:00:00 2001
From: rsulli55 <rsulli55@gmail.com>
Date: Tue, 10 Nov 2020 23:17:46 -0700
Subject: Update clippy_lints/src/methods/mod.rs

Co-authored-by: Philipp Krones <hello@philkrones.com>
---
 clippy_lints/src/methods/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 66f5aa0c6a0..5c1c1594f7d 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3053,7 +3053,7 @@ fn lint_search_is_some<'tcx>(
     // lint if caller of search is an Iterator
     if match_trait_method(cx, &is_some_args[0], &paths::ITERATOR) {
         let msg = format!(
-            "called `is_some()` after searching an `Iterator` with {}",
+            "called `is_some()` after searching an `Iterator` with `{}`",
             search_method
         );
         let hint = "this is more succinctly expressed by calling `any()`";
-- 
cgit 1.4.1-3-g733a5


From 5f64867e1d5344da8ff7526308d4b63676242c0d Mon Sep 17 00:00:00 2001
From: Takayuki Nakata <f.seasons017@gmail.com>
Date: Wed, 11 Nov 2020 22:36:53 +0900
Subject: Fix suggestion in `manual_range_contains` when using float

---
 clippy_lints/src/ranges.rs     |  6 ++++--
 tests/ui/range_contains.fixed  |  5 +++++
 tests/ui/range_contains.rs     |  5 +++++
 tests/ui/range_contains.stderr | 14 +++++++++++++-
 4 files changed, 27 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/ranges.rs b/clippy_lints/src/ranges.rs
index 79e9a56af9a..4b514bbd42c 100644
--- a/clippy_lints/src/ranges.rs
+++ b/clippy_lints/src/ranges.rs
@@ -222,13 +222,14 @@ fn check_possible_range_contains(cx: &LateContext<'_>, op: BinOpKind, l: &Expr<'
             let name = snippet_with_applicability(cx, name_span, "_", &mut applicability);
             let lo = snippet_with_applicability(cx, l_span, "_", &mut applicability);
             let hi = snippet_with_applicability(cx, u_span, "_", &mut applicability);
+            let space = if lo.ends_with('.') { " " } else { "" };
             span_lint_and_sugg(
                 cx,
                 MANUAL_RANGE_CONTAINS,
                 span,
                 &format!("manual `{}::contains` implementation", range_type),
                 "use",
-                format!("({}{}{}).contains(&{})", lo, range_op, hi, name),
+                format!("({}{}{}{}).contains(&{})", lo, space, range_op, hi, name),
                 applicability,
             );
         } else if !combine_and && ord == Some(lord) {
@@ -251,13 +252,14 @@ fn check_possible_range_contains(cx: &LateContext<'_>, op: BinOpKind, l: &Expr<'
             let name = snippet_with_applicability(cx, name_span, "_", &mut applicability);
             let lo = snippet_with_applicability(cx, l_span, "_", &mut applicability);
             let hi = snippet_with_applicability(cx, u_span, "_", &mut applicability);
+            let space = if lo.ends_with('.') { " " } else { "" };
             span_lint_and_sugg(
                 cx,
                 MANUAL_RANGE_CONTAINS,
                 span,
                 &format!("manual `!{}::contains` implementation", range_type),
                 "use",
-                format!("!({}{}{}).contains(&{})", lo, range_op, hi, name),
+                format!("!({}{}{}{}).contains(&{})", lo, space, range_op, hi, name),
                 applicability,
             );
         }
diff --git a/tests/ui/range_contains.fixed b/tests/ui/range_contains.fixed
index 632a6592a28..048874a7f82 100644
--- a/tests/ui/range_contains.fixed
+++ b/tests/ui/range_contains.fixed
@@ -38,4 +38,9 @@ fn main() {
     x >= 8 || x >= 12;
     x < 12 || 12 < x;
     x >= 8 || x <= 12;
+
+    // Fix #6315
+    let y = 3.;
+    (0. ..1.).contains(&y);
+    !(0. ..=1.).contains(&y);
 }
diff --git a/tests/ui/range_contains.rs b/tests/ui/range_contains.rs
index 6af0d034ef6..60ad259f404 100644
--- a/tests/ui/range_contains.rs
+++ b/tests/ui/range_contains.rs
@@ -38,4 +38,9 @@ fn main() {
     x >= 8 || x >= 12;
     x < 12 || 12 < x;
     x >= 8 || x <= 12;
+
+    // Fix #6315
+    let y = 3.;
+    y >= 0. && y < 1.;
+    y < 0. || y > 1.;
 }
diff --git a/tests/ui/range_contains.stderr b/tests/ui/range_contains.stderr
index 69b009eafc3..bc79f1bca84 100644
--- a/tests/ui/range_contains.stderr
+++ b/tests/ui/range_contains.stderr
@@ -72,5 +72,17 @@ error: manual `!RangeInclusive::contains` implementation
 LL |     999 < x || 1 > x;
    |     ^^^^^^^^^^^^^^^^ help: use: `!(1..=999).contains(&x)`
 
-error: aborting due to 12 previous errors
+error: manual `Range::contains` implementation
+  --> $DIR/range_contains.rs:44:5
+   |
+LL |     y >= 0. && y < 1.;
+   |     ^^^^^^^^^^^^^^^^^ help: use: `(0. ..1.).contains(&y)`
+
+error: manual `!RangeInclusive::contains` implementation
+  --> $DIR/range_contains.rs:45:5
+   |
+LL |     y < 0. || y > 1.;
+   |     ^^^^^^^^^^^^^^^^ help: use: `!(0. ..=1.).contains(&y)`
+
+error: aborting due to 14 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 8f89108533690afe964799d8f514956ec8b72377 Mon Sep 17 00:00:00 2001
From: Takayuki Nakata <f.seasons017@gmail.com>
Date: Mon, 9 Nov 2020 22:14:11 +0900
Subject: Fix FP in indirect `needless_collect` when used multiple times

---
 clippy_lints/src/loops.rs             | 34 +++++++++++++++++++++++++++++++++-
 tests/ui/needless_collect_indirect.rs | 20 ++++++++++++++++++++
 2 files changed, 53 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 0d31e9cfc3d..143cbea5537 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -2950,7 +2950,7 @@ fn check_needless_collect_indirect_usage<'tcx>(expr: &'tcx Expr<'_>, cx: &LateCo
         for ref stmt in block.stmts {
             if_chain! {
                 if let StmtKind::Local(
-                    Local { pat: Pat { kind: PatKind::Binding(_, _, ident, .. ), .. },
+                    Local { pat: Pat { hir_id: pat_id, kind: PatKind::Binding(_, _, ident, .. ), .. },
                     init: Some(ref init_expr), .. }
                 ) = stmt.kind;
                 if let ExprKind::MethodCall(ref method_name, _, &[ref iter_source], ..) = init_expr.kind;
@@ -2964,6 +2964,16 @@ fn check_needless_collect_indirect_usage<'tcx>(expr: &'tcx Expr<'_>, cx: &LateCo
                 if let Some(iter_calls) = detect_iter_and_into_iters(block, *ident);
                 if iter_calls.len() == 1;
                 then {
+                    let mut used_count_visitor = UsedCountVisitor {
+                        cx,
+                        id: *pat_id,
+                        count: 0,
+                    };
+                    walk_block(&mut used_count_visitor, block);
+                    if used_count_visitor.count > 1 {
+                        return;
+                    }
+
                     // Suggest replacing iter_call with iter_replacement, and removing stmt
                     let iter_call = &iter_calls[0];
                     span_lint_and_then(
@@ -3087,6 +3097,28 @@ impl<'tcx> Visitor<'tcx> for IterFunctionVisitor {
     }
 }
 
+struct UsedCountVisitor<'a, 'tcx> {
+    cx: &'a LateContext<'tcx>,
+    id: HirId,
+    count: usize,
+}
+
+impl<'a, 'tcx> Visitor<'tcx> for UsedCountVisitor<'a, 'tcx> {
+    type Map = Map<'tcx>;
+
+    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
+        if same_var(self.cx, expr, self.id) {
+            self.count += 1;
+        } else {
+            walk_expr(self, expr);
+        }
+    }
+
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::OnlyBodies(self.cx.tcx.hir())
+    }
+}
+
 /// Detect the occurrences of calls to `iter` or `into_iter` for the
 /// given identifier
 fn detect_iter_and_into_iters<'tcx>(block: &'tcx Block<'tcx>, identifier: Ident) -> Option<Vec<IterFunction>> {
diff --git a/tests/ui/needless_collect_indirect.rs b/tests/ui/needless_collect_indirect.rs
index 4f6e5357727..0918a6868ab 100644
--- a/tests/ui/needless_collect_indirect.rs
+++ b/tests/ui/needless_collect_indirect.rs
@@ -22,4 +22,24 @@ fn main() {
     let sample = vec![a.clone(), "b".to_string(), "c".to_string()];
     let non_copy_contains = sample.into_iter().collect::<Vec<_>>();
     non_copy_contains.contains(&a);
+
+    // Fix #5991
+    let vec_a = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+    let vec_b = vec_a.iter().collect::<Vec<_>>();
+    if vec_b.len() > 3 {}
+    let other_vec = vec![1, 3, 12, 4, 16, 2];
+    let we_got_the_same_numbers = other_vec.iter().filter(|item| vec_b.contains(item)).collect::<Vec<_>>();
+
+    // Fix #6297
+    let sample = [1; 5];
+    let multiple_indirect = sample.iter().collect::<Vec<_>>();
+    let sample2 = vec![2, 3];
+    if multiple_indirect.is_empty() {
+        // do something
+    } else {
+        let found = sample2
+            .iter()
+            .filter(|i| multiple_indirect.iter().any(|s| **s % **i == 0))
+            .collect::<Vec<_>>();
+    }
 }
-- 
cgit 1.4.1-3-g733a5


From c6b74df6807792aae1b18031017a3d154c770173 Mon Sep 17 00:00:00 2001
From: Takayuki Nakata <f.seasons017@gmail.com>
Date: Fri, 13 Nov 2020 14:47:23 +0900
Subject: Fix dogfood test

---
 clippy_lints/src/utils/ast_utils.rs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/ast_utils.rs b/clippy_lints/src/utils/ast_utils.rs
index 9050b9b2d9a..fcf7a4b1367 100644
--- a/clippy_lints/src/utils/ast_utils.rs
+++ b/clippy_lints/src/utils/ast_utils.rs
@@ -110,8 +110,7 @@ pub fn eq_expr_opt(l: &Option<P<Expr>>, r: &Option<P<Expr>>) -> bool {
 pub fn eq_struct_rest(l: &StructRest, r: &StructRest) -> bool {
     match (l, r) {
         (StructRest::Base(lb), StructRest::Base(rb)) => eq_expr(lb, rb),
-        (StructRest::Rest(_), StructRest::Rest(_)) => true,
-        (StructRest::None, StructRest::None) => true,
+        (StructRest::Rest(_), StructRest::Rest(_)) | (StructRest::None, StructRest::None) => true,
         _ => false,
     }
 }
-- 
cgit 1.4.1-3-g733a5


From 5b8f2b6c93ea819cd6d6e02ad7e2b8b9da23fd67 Mon Sep 17 00:00:00 2001
From: ThibsG <Thibs@debian.com>
Date: Mon, 16 Nov 2020 18:32:01 +0100
Subject: Remove `expect()` calls to avoid ICEs in `deref_addrof` lint

---
 clippy_lints/src/reference.rs | 48 +++++++++++++++++++++++++------------------
 tests/ui/crashes/ice-6332.rs  | 11 ++++++++++
 2 files changed, 39 insertions(+), 20 deletions(-)
 create mode 100644 tests/ui/crashes/ice-6332.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/reference.rs b/clippy_lints/src/reference.rs
index 35a1310d68b..efe3237990d 100644
--- a/clippy_lints/src/reference.rs
+++ b/clippy_lints/src/reference.rs
@@ -60,30 +60,38 @@ impl EarlyLintPass for DerefAddrOf {
                             }).map_or(span, |start_no_whitespace| e.span.with_lo(start_no_whitespace))
                         };
 
-                        let rpos = if *mutability == Mutability::Mut {
-                            macro_source.rfind("mut").expect("already checked this is a mutable reference") + "mut".len()
-                        } else {
-                            macro_source.rfind('&').expect("already checked this is a reference") + "&".len()
+                        let mut generate_snippet = |pattern: &str| {
+                            #[allow(clippy::cast_possible_truncation)]
+                            macro_source.rfind(pattern).map(|pattern_pos| {
+                                let rpos = pattern_pos + pattern.len();
+                                let span_after_ref = e.span.with_lo(BytePos(e.span.lo().0 + rpos as u32));
+                                let span = trim_leading_whitespaces(span_after_ref);
+                                snippet_with_applicability(cx, span, "_", &mut applicability)
+                            })
                         };
-                        #[allow(clippy::cast_possible_truncation)]
-                        let span_after_ref = e.span.with_lo(BytePos(e.span.lo().0 + rpos as u32));
-                        let span = trim_leading_whitespaces(span_after_ref);
-                        snippet_with_applicability(cx, span, "_", &mut applicability)
+
+                        if *mutability == Mutability::Mut {
+                            generate_snippet("mut")
+                        } else {
+                            generate_snippet("&")
+                        }
                     } else {
-                        snippet_with_applicability(cx, e.span, "_", &mut applicability)
+                        Some(snippet_with_applicability(cx, e.span, "_", &mut applicability))
                     }
                 } else {
-                    snippet_with_applicability(cx, addrof_target.span, "_", &mut applicability)
-                }.to_string();
-                span_lint_and_sugg(
-                    cx,
-                    DEREF_ADDROF,
-                    e.span,
-                    "immediately dereferencing a reference",
-                    "try this",
-                    sugg,
-                    applicability,
-                );
+                    Some(snippet_with_applicability(cx, addrof_target.span, "_", &mut applicability))
+                };
+                if let Some(sugg) = sugg {
+                    span_lint_and_sugg(
+                        cx,
+                        DEREF_ADDROF,
+                        e.span,
+                        "immediately dereferencing a reference",
+                        "try this",
+                        sugg.to_string(),
+                        applicability,
+                    );
+                }
             }
         }
     }
diff --git a/tests/ui/crashes/ice-6332.rs b/tests/ui/crashes/ice-6332.rs
new file mode 100644
index 00000000000..9dc92aa500b
--- /dev/null
+++ b/tests/ui/crashes/ice-6332.rs
@@ -0,0 +1,11 @@
+fn cmark_check() {
+    let mut link_err = false;
+    macro_rules! cmark_error {
+        ($bad:expr) => {
+            *$bad = true;
+        };
+    }
+    cmark_error!(&mut link_err);
+}
+
+pub fn main() {}
-- 
cgit 1.4.1-3-g733a5


From a7ac441760ae034ff7401439b38da821f4e2df3a Mon Sep 17 00:00:00 2001
From: Hirochika Matsumoto <matsujika@gmail.com>
Date: Sun, 20 Sep 2020 02:03:14 +0900
Subject: Add new lint to detect unnecessarily wrapped value

---
 CHANGELOG.md                         |   1 +
 clippy_lints/src/lib.rs              |   5 +
 clippy_lints/src/unnecessary_wrap.rs | 177 +++++++++++++++++++++++++++++++++++
 src/lintlist/mod.rs                  |   7 ++
 tests/ui/unnecessary_wrap.fixed      |  47 ++++++++++
 tests/ui/unnecessary_wrap.rs         |  47 ++++++++++
 tests/ui/unnecessary_wrap.stderr     |  34 +++++++
 7 files changed, 318 insertions(+)
 create mode 100644 clippy_lints/src/unnecessary_wrap.rs
 create mode 100644 tests/ui/unnecessary_wrap.fixed
 create mode 100644 tests/ui/unnecessary_wrap.rs
 create mode 100644 tests/ui/unnecessary_wrap.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 816d25bcd93..02b862d3196 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2008,6 +2008,7 @@ Released 2018-09-13
 [`unnecessary_operation`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_operation
 [`unnecessary_sort_by`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_sort_by
 [`unnecessary_unwrap`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_unwrap
+[`unnecessary_wrap`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_wrap
 [`unneeded_field_pattern`]: https://rust-lang.github.io/rust-clippy/master/index.html#unneeded_field_pattern
 [`unneeded_wildcard_pattern`]: https://rust-lang.github.io/rust-clippy/master/index.html#unneeded_wildcard_pattern
 [`unnested_or_patterns`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnested_or_patterns
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 20b38cbb6d0..2d1f75391bb 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -323,6 +323,7 @@ mod unicode;
 mod unit_return_expecting_ord;
 mod unnamed_address;
 mod unnecessary_sort_by;
+mod unnecessary_wrap;
 mod unnested_or_patterns;
 mod unsafe_removed_from_name;
 mod unused_io_amount;
@@ -892,6 +893,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &unnamed_address::FN_ADDRESS_COMPARISONS,
         &unnamed_address::VTABLE_ADDRESS_COMPARISONS,
         &unnecessary_sort_by::UNNECESSARY_SORT_BY,
+        &unnecessary_wrap::UNNECESSARY_WRAP,
         &unnested_or_patterns::UNNESTED_OR_PATTERNS,
         &unsafe_removed_from_name::UNSAFE_REMOVED_FROM_NAME,
         &unused_io_amount::UNUSED_IO_AMOUNT,
@@ -1064,6 +1066,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box redundant_clone::RedundantClone);
     store.register_late_pass(|| box slow_vector_initialization::SlowVectorInit);
     store.register_late_pass(|| box unnecessary_sort_by::UnnecessarySortBy);
+    store.register_late_pass(|| box unnecessary_wrap::UnnecessaryWrap);
     store.register_late_pass(|| box types::RefToMut);
     store.register_late_pass(|| box assertions_on_constants::AssertionsOnConstants);
     store.register_late_pass(|| box missing_const_for_fn::MissingConstForFn);
@@ -1571,6 +1574,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&unnamed_address::FN_ADDRESS_COMPARISONS),
         LintId::of(&unnamed_address::VTABLE_ADDRESS_COMPARISONS),
         LintId::of(&unnecessary_sort_by::UNNECESSARY_SORT_BY),
+        LintId::of(&unnecessary_wrap::UNNECESSARY_WRAP),
         LintId::of(&unsafe_removed_from_name::UNSAFE_REMOVED_FROM_NAME),
         LintId::of(&unused_io_amount::UNUSED_IO_AMOUNT),
         LintId::of(&unused_unit::UNUSED_UNIT),
@@ -1775,6 +1779,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&types::UNNECESSARY_CAST),
         LintId::of(&types::VEC_BOX),
         LintId::of(&unnecessary_sort_by::UNNECESSARY_SORT_BY),
+        LintId::of(&unnecessary_wrap::UNNECESSARY_WRAP),
         LintId::of(&unwrap::UNNECESSARY_UNWRAP),
         LintId::of(&useless_conversion::USELESS_CONVERSION),
         LintId::of(&zero_div_zero::ZERO_DIVIDED_BY_ZERO),
diff --git a/clippy_lints/src/unnecessary_wrap.rs b/clippy_lints/src/unnecessary_wrap.rs
new file mode 100644
index 00000000000..26a57517258
--- /dev/null
+++ b/clippy_lints/src/unnecessary_wrap.rs
@@ -0,0 +1,177 @@
+use crate::utils::{
+    is_type_diagnostic_item, match_qpath, multispan_sugg_with_applicability, paths, return_ty, snippet,
+    span_lint_and_then,
+};
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir::intravisit::{FnKind, NestedVisitorMap, Visitor};
+use rustc_hir::*;
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::hir::map::Map;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::Span;
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for private functions that only return `Ok` or `Some`.
+    ///
+    /// **Why is this bad?** It is not meaningful to wrap values when no `None` or `Err` is returned.
+    ///
+    /// **Known problems:** Since this lint changes function type signature, you may need to
+    /// adjust some codes at callee side.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// pub fn get_cool_number(a: bool, b: bool) -> Option<i32> {
+    ///     if a && b {
+    ///         return Some(50);
+    ///     }
+    ///     if a {
+    ///         Some(0)
+    ///     } else {
+    ///         Some(10)
+    ///     }
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// pub fn get_cool_number(a: bool, b: bool) -> i32 {
+    ///     if a && b {
+    ///         return 50;
+    ///     }
+    ///     if a {
+    ///         0
+    ///     } else {
+    ///         10
+    ///     }
+    /// }
+    /// ```
+    pub UNNECESSARY_WRAP,
+    complexity,
+    "functions that only return `Ok` or `Some`"
+}
+
+declare_lint_pass!(UnnecessaryWrap => [UNNECESSARY_WRAP]);
+
+impl<'tcx> LateLintPass<'tcx> for UnnecessaryWrap {
+    fn check_fn(
+        &mut self,
+        cx: &LateContext<'tcx>,
+        fn_kind: FnKind<'tcx>,
+        fn_decl: &FnDecl<'tcx>,
+        body: &Body<'tcx>,
+        span: Span,
+        hir_id: HirId,
+    ) {
+        if_chain! {
+            if let FnKind::ItemFn(.., visibility, _) = fn_kind;
+            if visibility.node.is_pub();
+            then {
+                return;
+            }
+        }
+
+        if let ExprKind::Block(ref block, ..) = body.value.kind {
+            let path = if is_type_diagnostic_item(cx, return_ty(cx, hir_id), sym!(option_type)) {
+                &paths::OPTION_SOME
+            } else if is_type_diagnostic_item(cx, return_ty(cx, hir_id), sym!(result_type)) {
+                &paths::RESULT_OK
+            } else {
+                return;
+            };
+
+            let mut visitor = UnnecessaryWrapVisitor { result: Vec::new() };
+            visitor.visit_block(block);
+            let result = visitor.result;
+
+            if result.iter().any(|expr| {
+                if_chain! {
+                    if let ExprKind::Call(ref func, ref args) = expr.kind;
+                    if let ExprKind::Path(ref qpath) = func.kind;
+                    if match_qpath(qpath, path);
+                    if args.len() == 1;
+                    then {
+                        false
+                    } else {
+                        true
+                    }
+                }
+            }) {
+                return;
+            }
+
+            let suggs = result.iter().filter_map(|expr| {
+                let snippet = if let ExprKind::Call(_, ref args) = expr.kind {
+                    Some(snippet(cx, args[0].span, "..").to_string())
+                } else {
+                    None
+                };
+                snippet.map(|snip| (expr.span, snip))
+            });
+
+            span_lint_and_then(
+                cx,
+                UNNECESSARY_WRAP,
+                span,
+                "this function returns unnecessarily wrapping data",
+                move |diag| {
+                    multispan_sugg_with_applicability(
+                        diag,
+                        "factor this out to",
+                        Applicability::MachineApplicable,
+                        suggs,
+                    );
+                },
+            );
+        }
+    }
+}
+
+struct UnnecessaryWrapVisitor<'tcx> {
+    result: Vec<&'tcx Expr<'tcx>>,
+}
+
+impl<'tcx> Visitor<'tcx> for UnnecessaryWrapVisitor<'tcx> {
+    type Map = Map<'tcx>;
+
+    fn visit_block(&mut self, block: &'tcx Block<'tcx>) {
+        for stmt in block.stmts {
+            self.visit_stmt(stmt);
+        }
+        if let Some(expr) = block.expr {
+            self.visit_expr(expr)
+        }
+    }
+
+    fn visit_stmt(&mut self, stmt: &'tcx Stmt<'tcx>) {
+        match stmt.kind {
+            StmtKind::Semi(ref expr) => {
+                if let ExprKind::Ret(Some(value)) = expr.kind {
+                    self.result.push(value);
+                }
+            },
+            StmtKind::Expr(ref expr) => self.visit_expr(expr),
+            _ => (),
+        }
+    }
+
+    fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) {
+        match expr.kind {
+            ExprKind::Ret(Some(value)) => self.result.push(value),
+            ExprKind::Call(..) | ExprKind::Path(..) => self.result.push(expr),
+            ExprKind::Block(ref block, _) | ExprKind::Loop(ref block, ..) => {
+                self.visit_block(block);
+            },
+            ExprKind::Match(_, arms, _) => {
+                for arm in arms {
+                    self.visit_expr(arm.body);
+                }
+            },
+            _ => intravisit::walk_expr(self, expr),
+        }
+    }
+
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::None
+    }
+}
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index 69acd3d9b8b..4a0cdc5d82f 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -2608,6 +2608,13 @@ vec![
         deprecation: None,
         module: "unwrap",
     },
+    Lint {
+        name: "unnecessary_wrap",
+        group: "complexity",
+        desc: "functions that only return `Ok` or `Some`",
+        deprecation: None,
+        module: "unnecessary_wrap",
+    },
     Lint {
         name: "unneeded_field_pattern",
         group: "restriction",
diff --git a/tests/ui/unnecessary_wrap.fixed b/tests/ui/unnecessary_wrap.fixed
new file mode 100644
index 00000000000..1657a3173db
--- /dev/null
+++ b/tests/ui/unnecessary_wrap.fixed
@@ -0,0 +1,47 @@
+// run-rustfix
+#![warn(clippy::unnecessary_wrap)]
+#![allow(clippy::no_effect)]
+#![allow(clippy::needless_return)]
+#![allow(clippy::if_same_then_else)]
+
+// should be linted
+fn func1(a: bool, b: bool) -> Option<i32> {
+    if a && b {
+        return Some(42);
+    }
+    if a {
+        Some(-1);
+        Some(2)
+    } else {
+        return Some(1337);
+    }
+}
+
+// public fns should not be linted
+pub fn func2(a: bool) -> Option<i32> {
+    if a {
+        Some(1)
+    } else {
+        Some(1)
+    }
+}
+
+// should not be linted
+fn func3(a: bool) -> Option<i32> {
+    if a {
+        Some(1)
+    } else {
+        None
+    }
+}
+
+// should be linted
+fn func4() -> Option<i32> {
+    1
+}
+
+fn main() {
+    // method calls are not linted
+    func1(true, true);
+    func2(true);
+}
diff --git a/tests/ui/unnecessary_wrap.rs b/tests/ui/unnecessary_wrap.rs
new file mode 100644
index 00000000000..edf41dad790
--- /dev/null
+++ b/tests/ui/unnecessary_wrap.rs
@@ -0,0 +1,47 @@
+// run-rustfix
+#![warn(clippy::unnecessary_wrap)]
+#![allow(clippy::no_effect)]
+#![allow(clippy::needless_return)]
+#![allow(clippy::if_same_then_else)]
+
+// should be linted
+fn func1(a: bool, b: bool) -> Option<i32> {
+    if a && b {
+        return Some(42);
+    }
+    if a {
+        Some(-1);
+        Some(2)
+    } else {
+        return Some(1337);
+    }
+}
+
+// public fns should not be linted
+pub fn func2(a: bool) -> Option<i32> {
+    if a {
+        Some(1)
+    } else {
+        Some(1)
+    }
+}
+
+// should not be linted
+fn func3(a: bool) -> Option<i32> {
+    if a {
+        Some(1)
+    } else {
+        None
+    }
+}
+
+// should be linted
+fn func4() -> Option<i32> {
+    Some(1)
+}
+
+fn main() {
+    // method calls are not linted
+    func1(true, true);
+    func2(true);
+}
diff --git a/tests/ui/unnecessary_wrap.stderr b/tests/ui/unnecessary_wrap.stderr
new file mode 100644
index 00000000000..8473bd81839
--- /dev/null
+++ b/tests/ui/unnecessary_wrap.stderr
@@ -0,0 +1,34 @@
+error: this function unnecessarily wrapping data
+  --> $DIR/unnecessary_wrap.rs:8:1
+   |
+LL | / fn func1(a: bool, b: bool) -> Option<i32> {
+LL | |     if a && b {
+LL | |         return Some(42);
+LL | |     }
+...  |
+LL | |     }
+LL | | }
+   | |_^
+   |
+   = note: `-D clippy::unnecessary-wrap` implied by `-D warnings`
+help: factor this out to
+   |
+LL |         return 42;
+LL |     }
+LL |     if a {
+LL |         Some(-1);
+LL |         2
+LL |     } else {
+ ...
+
+error: this function unnecessarily wrapping data
+  --> $DIR/unnecessary_wrap.rs:39:1
+   |
+LL | / fn func4() -> Option<i32> {
+LL | |     Some(1)
+   | |     ------- help: factor this out to: `1`
+LL | | }
+   | |_^
+
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 750c118b347af938383c5bff53040480e0974071 Mon Sep 17 00:00:00 2001
From: Hirochika Matsumoto <matsujika@gmail.com>
Date: Sun, 20 Sep 2020 18:22:01 +0900
Subject: Add suggestion on type signatures

---
 clippy_lints/src/unnecessary_wrap.rs | 31 ++++++++++++++++++++++---------
 tests/ui/unnecessary_wrap.fixed      | 18 +++++++++++++++++-
 tests/ui/unnecessary_wrap.rs         | 16 ++++++++++++++++
 tests/ui/unnecessary_wrap.stderr     | 35 +++++++++++++++++++++++++++--------
 4 files changed, 82 insertions(+), 18 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unnecessary_wrap.rs b/clippy_lints/src/unnecessary_wrap.rs
index 26a57517258..7b586c1df0c 100644
--- a/clippy_lints/src/unnecessary_wrap.rs
+++ b/clippy_lints/src/unnecessary_wrap.rs
@@ -7,7 +7,7 @@ use rustc_errors::Applicability;
 use rustc_hir::intravisit::{FnKind, NestedVisitorMap, Visitor};
 use rustc_hir::*;
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::hir::map::Map;
+use rustc_middle::{hir::map::Map, ty::subst::GenericArgKind};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::Span;
 
@@ -100,14 +100,27 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryWrap {
                 return;
             }
 
-            let suggs = result.iter().filter_map(|expr| {
-                let snippet = if let ExprKind::Call(_, ref args) = expr.kind {
-                    Some(snippet(cx, args[0].span, "..").to_string())
-                } else {
-                    None
-                };
-                snippet.map(|snip| (expr.span, snip))
-            });
+            let suggs = result
+                .iter()
+                .filter_map(|expr| {
+                    let snippet = if let ExprKind::Call(_, ref args) = expr.kind {
+                        Some(snippet(cx, args[0].span, "..").to_string())
+                    } else {
+                        None
+                    };
+                    snippet.map(|snip| (expr.span, snip))
+                })
+                .chain({
+                    let inner_ty = return_ty(cx, hir_id)
+                        .walk()
+                        .skip(1) // skip `std::option::Option` or `std::result::Result`
+                        .take(1) // first outermost inner type is needed
+                        .filter_map(|inner| match inner.unpack() {
+                            GenericArgKind::Type(inner_ty) => Some(inner_ty.to_string()),
+                            _ => None,
+                        });
+                    inner_ty.map(|inner_ty| (fn_decl.output.span(), inner_ty))
+                });
 
             span_lint_and_then(
                 cx,
diff --git a/tests/ui/unnecessary_wrap.fixed b/tests/ui/unnecessary_wrap.fixed
index 1657a3173db..749bb95c417 100644
--- a/tests/ui/unnecessary_wrap.fixed
+++ b/tests/ui/unnecessary_wrap.fixed
@@ -1,8 +1,10 @@
 // run-rustfix
+
 #![warn(clippy::unnecessary_wrap)]
 #![allow(clippy::no_effect)]
 #![allow(clippy::needless_return)]
 #![allow(clippy::if_same_then_else)]
+#![allow(dead_code)]
 
 // should be linted
 fn func1(a: bool, b: bool) -> Option<i32> {
@@ -37,7 +39,21 @@ fn func3(a: bool) -> Option<i32> {
 
 // should be linted
 fn func4() -> Option<i32> {
-    1
+    Some(1)
+}
+
+// should be linted
+fn func5() -> Result<i32, ()> {
+    Ok(1)
+}
+
+// should not be linted
+fn func6(a: bool) -> Result<i32, ()> {
+    if a {
+        Ok(1)
+    } else {
+        Err(())
+    }
 }
 
 fn main() {
diff --git a/tests/ui/unnecessary_wrap.rs b/tests/ui/unnecessary_wrap.rs
index edf41dad790..749bb95c417 100644
--- a/tests/ui/unnecessary_wrap.rs
+++ b/tests/ui/unnecessary_wrap.rs
@@ -1,8 +1,10 @@
 // run-rustfix
+
 #![warn(clippy::unnecessary_wrap)]
 #![allow(clippy::no_effect)]
 #![allow(clippy::needless_return)]
 #![allow(clippy::if_same_then_else)]
+#![allow(dead_code)]
 
 // should be linted
 fn func1(a: bool, b: bool) -> Option<i32> {
@@ -40,6 +42,20 @@ fn func4() -> Option<i32> {
     Some(1)
 }
 
+// should be linted
+fn func5() -> Result<i32, ()> {
+    Ok(1)
+}
+
+// should not be linted
+fn func6(a: bool) -> Result<i32, ()> {
+    if a {
+        Ok(1)
+    } else {
+        Err(())
+    }
+}
+
 fn main() {
     // method calls are not linted
     func1(true, true);
diff --git a/tests/ui/unnecessary_wrap.stderr b/tests/ui/unnecessary_wrap.stderr
index 8473bd81839..511d085c82f 100644
--- a/tests/ui/unnecessary_wrap.stderr
+++ b/tests/ui/unnecessary_wrap.stderr
@@ -1,5 +1,5 @@
-error: this function unnecessarily wrapping data
-  --> $DIR/unnecessary_wrap.rs:8:1
+error: this function returns unnecessarily wrapping data
+  --> $DIR/unnecessary_wrap.rs:10:1
    |
 LL | / fn func1(a: bool, b: bool) -> Option<i32> {
 LL | |     if a && b {
@@ -13,22 +13,41 @@ LL | | }
    = note: `-D clippy::unnecessary-wrap` implied by `-D warnings`
 help: factor this out to
    |
+LL | fn func1(a: bool, b: bool) -> i32 {
+LL |     if a && b {
 LL |         return 42;
 LL |     }
 LL |     if a {
 LL |         Some(-1);
-LL |         2
-LL |     } else {
  ...
 
-error: this function unnecessarily wrapping data
-  --> $DIR/unnecessary_wrap.rs:39:1
+error: this function returns unnecessarily wrapping data
+  --> $DIR/unnecessary_wrap.rs:41:1
    |
 LL | / fn func4() -> Option<i32> {
 LL | |     Some(1)
-   | |     ------- help: factor this out to: `1`
 LL | | }
    | |_^
+   |
+help: factor this out to
+   |
+LL | fn func4() -> i32 {
+LL |     1
+   |
+
+error: this function returns unnecessarily wrapping data
+  --> $DIR/unnecessary_wrap.rs:46:1
+   |
+LL | / fn func5() -> Result<i32, ()> {
+LL | |     Ok(1)
+LL | | }
+   | |_^
+   |
+help: factor this out to
+   |
+LL | fn func5() -> i32 {
+LL |     1
+   |
 
-error: aborting due to 2 previous errors
+error: aborting due to 3 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 0335b8d6a747672c0a4ff6cb14b12eced3848325 Mon Sep 17 00:00:00 2001
From: Hirochika Matsumoto <matsujika@gmail.com>
Date: Mon, 21 Sep 2020 00:06:25 +0900
Subject: Fix lint example

---
 clippy_lints/src/unnecessary_wrap.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unnecessary_wrap.rs b/clippy_lints/src/unnecessary_wrap.rs
index 7b586c1df0c..c5d0d510079 100644
--- a/clippy_lints/src/unnecessary_wrap.rs
+++ b/clippy_lints/src/unnecessary_wrap.rs
@@ -22,7 +22,7 @@ declare_clippy_lint! {
     /// **Example:**
     ///
     /// ```rust
-    /// pub fn get_cool_number(a: bool, b: bool) -> Option<i32> {
+    /// fn get_cool_number(a: bool, b: bool) -> Option<i32> {
     ///     if a && b {
     ///         return Some(50);
     ///     }
@@ -35,7 +35,7 @@ declare_clippy_lint! {
     /// ```
     /// Use instead:
     /// ```rust
-    /// pub fn get_cool_number(a: bool, b: bool) -> i32 {
+    /// fn get_cool_number(a: bool, b: bool) -> i32 {
     ///     if a && b {
     ///         return 50;
     ///     }
-- 
cgit 1.4.1-3-g733a5


From ebdd4e2c723c6902851a050ec8bdc7b966dc2c64 Mon Sep 17 00:00:00 2001
From: Hirochika Matsumoto <matsujika@gmail.com>
Date: Wed, 23 Sep 2020 02:53:55 +0900
Subject: Refactor code according to reivews

---
 clippy_lints/src/unnecessary_wrap.rs | 224 ++++++++++++++++++++++-------------
 1 file changed, 141 insertions(+), 83 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unnecessary_wrap.rs b/clippy_lints/src/unnecessary_wrap.rs
index c5d0d510079..53ade7baec7 100644
--- a/clippy_lints/src/unnecessary_wrap.rs
+++ b/clippy_lints/src/unnecessary_wrap.rs
@@ -4,7 +4,7 @@ use crate::utils::{
 };
 use if_chain::if_chain;
 use rustc_errors::Applicability;
-use rustc_hir::intravisit::{FnKind, NestedVisitorMap, Visitor};
+use rustc_hir::intravisit::{FnKind, Visitor};
 use rustc_hir::*;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::{hir::map::Map, ty::subst::GenericArgKind};
@@ -71,57 +71,31 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryWrap {
             }
         }
 
-        if let ExprKind::Block(ref block, ..) = body.value.kind {
-            let path = if is_type_diagnostic_item(cx, return_ty(cx, hir_id), sym!(option_type)) {
-                &paths::OPTION_SOME
-            } else if is_type_diagnostic_item(cx, return_ty(cx, hir_id), sym!(result_type)) {
-                &paths::RESULT_OK
-            } else {
-                return;
-            };
-
-            let mut visitor = UnnecessaryWrapVisitor { result: Vec::new() };
-            visitor.visit_block(block);
-            let result = visitor.result;
-
-            if result.iter().any(|expr| {
-                if_chain! {
-                    if let ExprKind::Call(ref func, ref args) = expr.kind;
-                    if let ExprKind::Path(ref qpath) = func.kind;
-                    if match_qpath(qpath, path);
-                    if args.len() == 1;
-                    then {
-                        false
-                    } else {
-                        true
-                    }
+        let path = if is_type_diagnostic_item(cx, return_ty(cx, hir_id), sym!(option_type)) {
+            &paths::OPTION_SOME
+        } else if is_type_diagnostic_item(cx, return_ty(cx, hir_id), sym!(result_type)) {
+            &paths::RESULT_OK
+        } else {
+            return;
+        };
+
+        let mut suggs = Vec::new();
+        let can_sugg = find_all_ret_expressions(cx, &body.value, |ret_expr| {
+            if_chain! {
+                if let ExprKind::Call(ref func, ref args) = ret_expr.kind;
+                if let ExprKind::Path(ref qpath) = func.kind;
+                if match_qpath(qpath, path);
+                if args.len() == 1;
+                then {
+                    suggs.push((ret_expr.span, snippet(cx, args[0].span.source_callsite(), "..").to_string()));
+                    true
+                } else {
+                    false
                 }
-            }) {
-                return;
             }
+        });
 
-            let suggs = result
-                .iter()
-                .filter_map(|expr| {
-                    let snippet = if let ExprKind::Call(_, ref args) = expr.kind {
-                        Some(snippet(cx, args[0].span, "..").to_string())
-                    } else {
-                        None
-                    };
-                    snippet.map(|snip| (expr.span, snip))
-                })
-                .chain({
-                    let inner_ty = return_ty(cx, hir_id)
-                        .walk()
-                        .skip(1) // skip `std::option::Option` or `std::result::Result`
-                        .take(1) // first outermost inner type is needed
-                        .filter_map(|inner| match inner.unpack() {
-                            GenericArgKind::Type(inner_ty) => Some(inner_ty.to_string()),
-                            _ => None,
-                        });
-                    inner_ty.map(|inner_ty| (fn_decl.output.span(), inner_ty))
-                });
-
+        if can_sugg {
             span_lint_and_then(
                 cx,
                 UNNECESSARY_WRAP,
@@ -132,7 +106,17 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryWrap {
                         diag,
                         "factor this out to",
                         Applicability::MachineApplicable,
-                        suggs,
+                        suggs.into_iter().chain({
+                            let inner_ty = return_ty(cx, hir_id)
+                                .walk()
+                                .skip(1) // skip `std::option::Option` or `std::result::Result`
+                                .take(1) // take the first outermost inner type
+                                .filter_map(|inner| match inner.unpack() {
+                                    GenericArgKind::Type(inner_ty) => Some(inner_ty.to_string()),
+                                    _ => None,
+                                });
+                            inner_ty.map(|inner_ty| (fn_decl.output.span(), inner_ty))
+                        }),
                     );
                 },
             );
@@ -140,51 +124,125 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryWrap {
     }
 }
 
-struct UnnecessaryWrapVisitor<'tcx> {
-    result: Vec<&'tcx Expr<'tcx>>,
-}
+// code below is copied from `bind_instead_of_map`
+
+fn find_all_ret_expressions<'hir, F>(_cx: &LateContext<'_>, expr: &'hir Expr<'hir>, callback: F) -> bool
+where
+    F: FnMut(&'hir Expr<'hir>) -> bool,
+{
+    struct RetFinder<F> {
+        in_stmt: bool,
+        failed: bool,
+        cb: F,
+    }
+
+    struct WithStmtGuarg<'a, F> {
+        val: &'a mut RetFinder<F>,
+        prev_in_stmt: bool,
+    }
 
-impl<'tcx> Visitor<'tcx> for UnnecessaryWrapVisitor<'tcx> {
-    type Map = Map<'tcx>;
+    impl<F> RetFinder<F> {
+        fn inside_stmt(&mut self, in_stmt: bool) -> WithStmtGuarg<'_, F> {
+            let prev_in_stmt = std::mem::replace(&mut self.in_stmt, in_stmt);
+            WithStmtGuarg {
+                val: self,
+                prev_in_stmt,
+            }
+        }
+    }
 
-    fn visit_block(&mut self, block: &'tcx Block<'tcx>) {
-        for stmt in block.stmts {
-            self.visit_stmt(stmt);
+    impl<F> std::ops::Deref for WithStmtGuarg<'_, F> {
+        type Target = RetFinder<F>;
+
+        fn deref(&self) -> &Self::Target {
+            self.val
         }
-        if let Some(expr) = block.expr {
-            self.visit_expr(expr)
+    }
+
+    impl<F> std::ops::DerefMut for WithStmtGuarg<'_, F> {
+        fn deref_mut(&mut self) -> &mut Self::Target {
+            self.val
         }
     }
 
-    fn visit_stmt(&mut self, stmt: &'tcx Stmt<'tcx>) {
-        match stmt.kind {
-            StmtKind::Semi(ref expr) => {
-                if let ExprKind::Ret(Some(value)) = expr.kind {
-                    self.result.push(value);
-                }
-            },
-            StmtKind::Expr(ref expr) => self.visit_expr(expr),
-            _ => (),
+    impl<F> Drop for WithStmtGuarg<'_, F> {
+        fn drop(&mut self) {
+            self.val.in_stmt = self.prev_in_stmt;
         }
     }
 
-    fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) {
-        match expr.kind {
-            ExprKind::Ret(Some(value)) => self.result.push(value),
-            ExprKind::Call(..) | ExprKind::Path(..) => self.result.push(expr),
-            ExprKind::Block(ref block, _) | ExprKind::Loop(ref block, ..) => {
-                self.visit_block(block);
-            },
-            ExprKind::Match(_, arms, _) => {
-                for arm in arms {
-                    self.visit_expr(arm.body);
+    impl<'hir, F: FnMut(&'hir Expr<'hir>) -> bool> intravisit::Visitor<'hir> for RetFinder<F> {
+        type Map = Map<'hir>;
+
+        fn nested_visit_map(&mut self) -> intravisit::NestedVisitorMap<Self::Map> {
+            intravisit::NestedVisitorMap::None
+        }
+
+        fn visit_stmt(&mut self, stmt: &'hir Stmt<'_>) {
+            intravisit::walk_stmt(&mut *self.inside_stmt(true), stmt)
+        }
+
+        fn visit_expr(&mut self, expr: &'hir Expr<'_>) {
+            if self.failed {
+                return;
+            }
+            if self.in_stmt {
+                match expr.kind {
+                    ExprKind::Ret(Some(expr)) => self.inside_stmt(false).visit_expr(expr),
+                    _ => intravisit::walk_expr(self, expr),
+                }
+            } else {
+                match expr.kind {
+                    ExprKind::Match(cond, arms, _) => {
+                        self.inside_stmt(true).visit_expr(cond);
+                        for arm in arms {
+                            self.visit_expr(arm.body);
+                        }
+                    },
+                    ExprKind::Block(..) => intravisit::walk_expr(self, expr),
+                    ExprKind::Ret(Some(expr)) => self.visit_expr(expr),
+                    _ => self.failed |= !(self.cb)(expr),
                 }
-            },
-            _ => intravisit::walk_expr(self, expr),
+            }
         }
     }
 
-    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-        NestedVisitorMap::None
+    !contains_try(expr) && {
+        let mut ret_finder = RetFinder {
+            in_stmt: false,
+            failed: false,
+            cb: callback,
+        };
+        ret_finder.visit_expr(expr);
+        !ret_finder.failed
+    }
+}
+
+/// returns `true` if expr contains match expr desugared from try
+fn contains_try(expr: &Expr<'_>) -> bool {
+    struct TryFinder {
+        found: bool,
+    }
+
+    impl<'hir> intravisit::Visitor<'hir> for TryFinder {
+        type Map = Map<'hir>;
+
+        fn nested_visit_map(&mut self) -> intravisit::NestedVisitorMap<Self::Map> {
+            intravisit::NestedVisitorMap::None
+        }
+
+        fn visit_expr(&mut self, expr: &'hir Expr<'hir>) {
+            if self.found {
+                return;
+            }
+            match expr.kind {
+                ExprKind::Match(_, _, MatchSource::TryDesugar) => self.found = true,
+                _ => intravisit::walk_expr(self, expr),
+            }
+        }
     }
+
+    let mut visitor = TryFinder { found: false };
+    visitor.visit_expr(expr);
+    visitor.found
 }
-- 
cgit 1.4.1-3-g733a5


From 3ed89026231a17beed9e93b055ea1b6192997a68 Mon Sep 17 00:00:00 2001
From: Hirochika Matsumoto <matsujika@gmail.com>
Date: Wed, 23 Sep 2020 03:06:52 +0900
Subject: Fix typo

Co-authored-by: Philipp Krones <hello@philkrones.com>
---
 clippy_lints/src/unnecessary_wrap.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unnecessary_wrap.rs b/clippy_lints/src/unnecessary_wrap.rs
index 53ade7baec7..e5ef7cde789 100644
--- a/clippy_lints/src/unnecessary_wrap.rs
+++ b/clippy_lints/src/unnecessary_wrap.rs
@@ -17,7 +17,7 @@ declare_clippy_lint! {
     /// **Why is this bad?** It is not meaningful to wrap values when no `None` or `Err` is returned.
     ///
     /// **Known problems:** Since this lint changes function type signature, you may need to
-    /// adjust some codes at callee side.
+    /// adjust some code at callee side.
     ///
     /// **Example:**
     ///
-- 
cgit 1.4.1-3-g733a5


From c77585672720285db5180b2ee4207c7ee9b51072 Mon Sep 17 00:00:00 2001
From: Hirochika Matsumoto <matsujika@gmail.com>
Date: Wed, 23 Sep 2020 03:42:58 +0900
Subject: Call `diag.multipart_suggestion` instead

---
 clippy_lints/src/unnecessary_wrap.rs | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unnecessary_wrap.rs b/clippy_lints/src/unnecessary_wrap.rs
index e5ef7cde789..d581912284f 100644
--- a/clippy_lints/src/unnecessary_wrap.rs
+++ b/clippy_lints/src/unnecessary_wrap.rs
@@ -1,5 +1,5 @@
 use crate::utils::{
-    is_type_diagnostic_item, match_qpath, multispan_sugg_with_applicability, paths, return_ty, snippet,
+    is_type_diagnostic_item, match_qpath, paths, return_ty, snippet,
     span_lint_and_then,
 };
 use if_chain::if_chain;
@@ -102,10 +102,8 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryWrap {
                 span,
                 "this function returns unnecessarily wrapping data",
                 move |diag| {
-                    multispan_sugg_with_applicability(
-                        diag,
+                    diag.multipart_suggestion(
                         "factor this out to",
-                        Applicability::MachineApplicable,
                         suggs.into_iter().chain({
                             let inner_ty = return_ty(cx, hir_id)
                                 .walk()
@@ -116,7 +114,8 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryWrap {
                                     _ => None,
                                 });
                             inner_ty.map(|inner_ty| (fn_decl.output.span(), inner_ty))
-                        }),
+                        }).collect(),
+                        Applicability::MachineApplicable,
                     );
                 },
             );
-- 
cgit 1.4.1-3-g733a5


From a433d4690e04c8c8eceb1f59c78fded1f04cf6f0 Mon Sep 17 00:00:00 2001
From: Hirochika Matsumoto <matsujika@gmail.com>
Date: Wed, 23 Sep 2020 03:48:15 +0900
Subject: Run rustfmt

---
 clippy_lints/src/unnecessary_wrap.rs | 30 +++++++++++++++---------------
 1 file changed, 15 insertions(+), 15 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unnecessary_wrap.rs b/clippy_lints/src/unnecessary_wrap.rs
index d581912284f..1c8a08172a3 100644
--- a/clippy_lints/src/unnecessary_wrap.rs
+++ b/clippy_lints/src/unnecessary_wrap.rs
@@ -1,7 +1,4 @@
-use crate::utils::{
-    is_type_diagnostic_item, match_qpath, paths, return_ty, snippet,
-    span_lint_and_then,
-};
+use crate::utils::{is_type_diagnostic_item, match_qpath, paths, return_ty, snippet, span_lint_and_then};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{FnKind, Visitor};
@@ -104,17 +101,20 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryWrap {
                 move |diag| {
                     diag.multipart_suggestion(
                         "factor this out to",
-                        suggs.into_iter().chain({
-                            let inner_ty = return_ty(cx, hir_id)
-                                .walk()
-                                .skip(1) // skip `std::option::Option` or `std::result::Result`
-                                .take(1) // take the first outermost inner type
-                                .filter_map(|inner| match inner.unpack() {
-                                    GenericArgKind::Type(inner_ty) => Some(inner_ty.to_string()),
-                                    _ => None,
-                                });
-                            inner_ty.map(|inner_ty| (fn_decl.output.span(), inner_ty))
-                        }).collect(),
+                        suggs
+                            .into_iter()
+                            .chain({
+                                let inner_ty = return_ty(cx, hir_id)
+                                    .walk()
+                                    .skip(1) // skip `std::option::Option` or `std::result::Result`
+                                    .take(1) // take the first outermost inner type
+                                    .filter_map(|inner| match inner.unpack() {
+                                        GenericArgKind::Type(inner_ty) => Some(inner_ty.to_string()),
+                                        _ => None,
+                                    });
+                                inner_ty.map(|inner_ty| (fn_decl.output.span(), inner_ty))
+                            })
+                            .collect(),
                         Applicability::MachineApplicable,
                     );
                 },
-- 
cgit 1.4.1-3-g733a5


From cdb72df6f9f9d6946b0614b01e70bc9c46edfe89 Mon Sep 17 00:00:00 2001
From: Hirochika Matsumoto <matsujika@gmail.com>
Date: Sat, 26 Sep 2020 15:39:39 +0900
Subject: Split lint suggestion into two

---
 clippy_lints/src/unnecessary_wrap.rs | 41 +++++++++++++++++++-----------------
 tests/ui/unnecessary_wrap.stderr     | 18 ++++++++++++----
 2 files changed, 36 insertions(+), 23 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unnecessary_wrap.rs b/clippy_lints/src/unnecessary_wrap.rs
index 1c8a08172a3..3ddf921a04b 100644
--- a/clippy_lints/src/unnecessary_wrap.rs
+++ b/clippy_lints/src/unnecessary_wrap.rs
@@ -68,10 +68,10 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryWrap {
             }
         }
 
-        let path = if is_type_diagnostic_item(cx, return_ty(cx, hir_id), sym!(option_type)) {
-            &paths::OPTION_SOME
+        let (return_type, path) = if is_type_diagnostic_item(cx, return_ty(cx, hir_id), sym!(option_type)) {
+            ("Option", &paths::OPTION_SOME)
         } else if is_type_diagnostic_item(cx, return_ty(cx, hir_id), sym!(result_type)) {
-            &paths::RESULT_OK
+            ("Result", &paths::RESULT_OK)
         } else {
             return;
         };
@@ -98,23 +98,26 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryWrap {
                 UNNECESSARY_WRAP,
                 span,
                 "this function returns unnecessarily wrapping data",
-                move |diag| {
+                |diag| {
+                    let inner_ty = return_ty(cx, hir_id)
+                        .walk()
+                        .skip(1) // skip `std::option::Option` or `std::result::Result`
+                        .take(1) // take the first outermost inner type
+                        .filter_map(|inner| match inner.unpack() {
+                            GenericArgKind::Type(inner_ty) => Some(inner_ty.to_string()),
+                            _ => None,
+                        });
+                    inner_ty.for_each(|inner_ty| {
+                        diag.span_suggestion(
+                            fn_decl.output.span(),
+                            format!("remove `{}` from the return type...", return_type).as_str(),
+                            inner_ty,
+                            Applicability::MachineApplicable,
+                        );
+                    });
                     diag.multipart_suggestion(
-                        "factor this out to",
-                        suggs
-                            .into_iter()
-                            .chain({
-                                let inner_ty = return_ty(cx, hir_id)
-                                    .walk()
-                                    .skip(1) // skip `std::option::Option` or `std::result::Result`
-                                    .take(1) // take the first outermost inner type
-                                    .filter_map(|inner| match inner.unpack() {
-                                        GenericArgKind::Type(inner_ty) => Some(inner_ty.to_string()),
-                                        _ => None,
-                                    });
-                                inner_ty.map(|inner_ty| (fn_decl.output.span(), inner_ty))
-                            })
-                            .collect(),
+                        "...and change the returning expressions",
+                        suggs,
                         Applicability::MachineApplicable,
                     );
                 },
diff --git a/tests/ui/unnecessary_wrap.stderr b/tests/ui/unnecessary_wrap.stderr
index cd05104f490..7833ee4b213 100644
--- a/tests/ui/unnecessary_wrap.stderr
+++ b/tests/ui/unnecessary_wrap.stderr
@@ -11,14 +11,18 @@ LL | | }
    | |_^
    |
    = note: `-D clippy::unnecessary-wrap` implied by `-D warnings`
-help: factor this out to
+help: remove `Option` from the return type...
    |
 LL | fn func1(a: bool, b: bool) -> i32 {
-LL |     if a && b {
+   |                               ^^^
+help: ...and change the returning expressions
+   |
 LL |         return 42;
 LL |     }
 LL |     if a {
 LL |         Some(-1);
+LL |         2
+LL |     } else {
  ...
 
 error: this function returns unnecessarily wrapping data
@@ -29,9 +33,12 @@ LL | |     Some(1)
 LL | | }
    | |_^
    |
-help: factor this out to
+help: remove `Option` from the return type...
    |
 LL | fn func4() -> i32 {
+   |               ^^^
+help: ...and change the returning expressions
+   |
 LL |     1
    |
 
@@ -43,9 +50,12 @@ LL | |     Ok(1)
 LL | | }
    | |_^
    |
-help: factor this out to
+help: remove `Result` from the return type...
    |
 LL | fn func6() -> i32 {
+   |               ^^^
+help: ...and change the returning expressions
+   |
 LL |     1
    |
 
-- 
cgit 1.4.1-3-g733a5


From df0d565e597ad9c436fadfb8e11a16a92bcb4114 Mon Sep 17 00:00:00 2001
From: Hirochika Matsumoto <matsujika@gmail.com>
Date: Fri, 2 Oct 2020 18:21:17 +0900
Subject: Move `find_all_ret_expressions` into `utils`

---
 clippy_lints/src/methods/bind_instead_of_map.rs | 125 +---------------------
 clippy_lints/src/unnecessary_wrap.rs            | 132 ++----------------------
 clippy_lints/src/utils/mod.rs                   |   1 +
 clippy_lints/src/utils/visitors.rs              | 125 ++++++++++++++++++++++
 4 files changed, 133 insertions(+), 250 deletions(-)
 create mode 100644 clippy_lints/src/utils/visitors.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/bind_instead_of_map.rs b/clippy_lints/src/methods/bind_instead_of_map.rs
index ae37942e55a..540a1484a85 100644
--- a/clippy_lints/src/methods/bind_instead_of_map.rs
+++ b/clippy_lints/src/methods/bind_instead_of_map.rs
@@ -1,14 +1,12 @@
 use super::{contains_return, BIND_INSTEAD_OF_MAP};
 use crate::utils::{
     in_macro, match_qpath, match_type, method_calls, multispan_sugg_with_applicability, paths, remove_blocks, snippet,
-    snippet_with_macro_callsite, span_lint_and_sugg, span_lint_and_then,
+    snippet_with_macro_callsite, span_lint_and_sugg, span_lint_and_then, visitors::find_all_ret_expressions,
 };
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
-use rustc_hir::intravisit::{self, Visitor};
 use rustc_lint::LateContext;
-use rustc_middle::hir::map::Map;
 use rustc_span::Span;
 
 pub(crate) struct OptionAndThenSome;
@@ -193,124 +191,3 @@ pub(crate) trait BindInsteadOfMap {
         }
     }
 }
-
-/// returns `true` if expr contains match expr desugared from try
-fn contains_try(expr: &hir::Expr<'_>) -> bool {
-    struct TryFinder {
-        found: bool,
-    }
-
-    impl<'hir> intravisit::Visitor<'hir> for TryFinder {
-        type Map = Map<'hir>;
-
-        fn nested_visit_map(&mut self) -> intravisit::NestedVisitorMap<Self::Map> {
-            intravisit::NestedVisitorMap::None
-        }
-
-        fn visit_expr(&mut self, expr: &'hir hir::Expr<'hir>) {
-            if self.found {
-                return;
-            }
-            match expr.kind {
-                hir::ExprKind::Match(_, _, hir::MatchSource::TryDesugar) => self.found = true,
-                _ => intravisit::walk_expr(self, expr),
-            }
-        }
-    }
-
-    let mut visitor = TryFinder { found: false };
-    visitor.visit_expr(expr);
-    visitor.found
-}
-
-fn find_all_ret_expressions<'hir, F>(_cx: &LateContext<'_>, expr: &'hir hir::Expr<'hir>, callback: F) -> bool
-where
-    F: FnMut(&'hir hir::Expr<'hir>) -> bool,
-{
-    struct RetFinder<F> {
-        in_stmt: bool,
-        failed: bool,
-        cb: F,
-    }
-
-    struct WithStmtGuarg<'a, F> {
-        val: &'a mut RetFinder<F>,
-        prev_in_stmt: bool,
-    }
-
-    impl<F> RetFinder<F> {
-        fn inside_stmt(&mut self, in_stmt: bool) -> WithStmtGuarg<'_, F> {
-            let prev_in_stmt = std::mem::replace(&mut self.in_stmt, in_stmt);
-            WithStmtGuarg {
-                val: self,
-                prev_in_stmt,
-            }
-        }
-    }
-
-    impl<F> std::ops::Deref for WithStmtGuarg<'_, F> {
-        type Target = RetFinder<F>;
-
-        fn deref(&self) -> &Self::Target {
-            self.val
-        }
-    }
-
-    impl<F> std::ops::DerefMut for WithStmtGuarg<'_, F> {
-        fn deref_mut(&mut self) -> &mut Self::Target {
-            self.val
-        }
-    }
-
-    impl<F> Drop for WithStmtGuarg<'_, F> {
-        fn drop(&mut self) {
-            self.val.in_stmt = self.prev_in_stmt;
-        }
-    }
-
-    impl<'hir, F: FnMut(&'hir hir::Expr<'hir>) -> bool> intravisit::Visitor<'hir> for RetFinder<F> {
-        type Map = Map<'hir>;
-
-        fn nested_visit_map(&mut self) -> intravisit::NestedVisitorMap<Self::Map> {
-            intravisit::NestedVisitorMap::None
-        }
-
-        fn visit_stmt(&mut self, stmt: &'hir hir::Stmt<'_>) {
-            intravisit::walk_stmt(&mut *self.inside_stmt(true), stmt)
-        }
-
-        fn visit_expr(&mut self, expr: &'hir hir::Expr<'_>) {
-            if self.failed {
-                return;
-            }
-            if self.in_stmt {
-                match expr.kind {
-                    hir::ExprKind::Ret(Some(expr)) => self.inside_stmt(false).visit_expr(expr),
-                    _ => intravisit::walk_expr(self, expr),
-                }
-            } else {
-                match expr.kind {
-                    hir::ExprKind::Match(cond, arms, _) => {
-                        self.inside_stmt(true).visit_expr(cond);
-                        for arm in arms {
-                            self.visit_expr(arm.body);
-                        }
-                    },
-                    hir::ExprKind::Block(..) => intravisit::walk_expr(self, expr),
-                    hir::ExprKind::Ret(Some(expr)) => self.visit_expr(expr),
-                    _ => self.failed |= !(self.cb)(expr),
-                }
-            }
-        }
-    }
-
-    !contains_try(expr) && {
-        let mut ret_finder = RetFinder {
-            in_stmt: false,
-            failed: false,
-            cb: callback,
-        };
-        ret_finder.visit_expr(expr);
-        !ret_finder.failed
-    }
-}
diff --git a/clippy_lints/src/unnecessary_wrap.rs b/clippy_lints/src/unnecessary_wrap.rs
index 3ddf921a04b..de13301381e 100644
--- a/clippy_lints/src/unnecessary_wrap.rs
+++ b/clippy_lints/src/unnecessary_wrap.rs
@@ -1,10 +1,13 @@
-use crate::utils::{is_type_diagnostic_item, match_qpath, paths, return_ty, snippet, span_lint_and_then};
+use crate::utils::{
+    is_type_diagnostic_item, match_qpath, paths, return_ty, snippet, span_lint_and_then,
+    visitors::find_all_ret_expressions,
+};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
-use rustc_hir::intravisit::{FnKind, Visitor};
+use rustc_hir::intravisit::FnKind;
 use rustc_hir::*;
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::{hir::map::Map, ty::subst::GenericArgKind};
+use rustc_middle::ty::subst::GenericArgKind;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::Span;
 
@@ -125,126 +128,3 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryWrap {
         }
     }
 }
-
-// code below is copied from `bind_instead_of_map`
-
-fn find_all_ret_expressions<'hir, F>(_cx: &LateContext<'_>, expr: &'hir Expr<'hir>, callback: F) -> bool
-where
-    F: FnMut(&'hir Expr<'hir>) -> bool,
-{
-    struct RetFinder<F> {
-        in_stmt: bool,
-        failed: bool,
-        cb: F,
-    }
-
-    struct WithStmtGuarg<'a, F> {
-        val: &'a mut RetFinder<F>,
-        prev_in_stmt: bool,
-    }
-
-    impl<F> RetFinder<F> {
-        fn inside_stmt(&mut self, in_stmt: bool) -> WithStmtGuarg<'_, F> {
-            let prev_in_stmt = std::mem::replace(&mut self.in_stmt, in_stmt);
-            WithStmtGuarg {
-                val: self,
-                prev_in_stmt,
-            }
-        }
-    }
-
-    impl<F> std::ops::Deref for WithStmtGuarg<'_, F> {
-        type Target = RetFinder<F>;
-
-        fn deref(&self) -> &Self::Target {
-            self.val
-        }
-    }
-
-    impl<F> std::ops::DerefMut for WithStmtGuarg<'_, F> {
-        fn deref_mut(&mut self) -> &mut Self::Target {
-            self.val
-        }
-    }
-
-    impl<F> Drop for WithStmtGuarg<'_, F> {
-        fn drop(&mut self) {
-            self.val.in_stmt = self.prev_in_stmt;
-        }
-    }
-
-    impl<'hir, F: FnMut(&'hir Expr<'hir>) -> bool> intravisit::Visitor<'hir> for RetFinder<F> {
-        type Map = Map<'hir>;
-
-        fn nested_visit_map(&mut self) -> intravisit::NestedVisitorMap<Self::Map> {
-            intravisit::NestedVisitorMap::None
-        }
-
-        fn visit_stmt(&mut self, stmt: &'hir Stmt<'_>) {
-            intravisit::walk_stmt(&mut *self.inside_stmt(true), stmt)
-        }
-
-        fn visit_expr(&mut self, expr: &'hir Expr<'_>) {
-            if self.failed {
-                return;
-            }
-            if self.in_stmt {
-                match expr.kind {
-                    ExprKind::Ret(Some(expr)) => self.inside_stmt(false).visit_expr(expr),
-                    _ => intravisit::walk_expr(self, expr),
-                }
-            } else {
-                match expr.kind {
-                    ExprKind::Match(cond, arms, _) => {
-                        self.inside_stmt(true).visit_expr(cond);
-                        for arm in arms {
-                            self.visit_expr(arm.body);
-                        }
-                    },
-                    ExprKind::Block(..) => intravisit::walk_expr(self, expr),
-                    ExprKind::Ret(Some(expr)) => self.visit_expr(expr),
-                    _ => self.failed |= !(self.cb)(expr),
-                }
-            }
-        }
-    }
-
-    !contains_try(expr) && {
-        let mut ret_finder = RetFinder {
-            in_stmt: false,
-            failed: false,
-            cb: callback,
-        };
-        ret_finder.visit_expr(expr);
-        !ret_finder.failed
-    }
-}
-
-/// returns `true` if expr contains match expr desugared from try
-fn contains_try(expr: &Expr<'_>) -> bool {
-    struct TryFinder {
-        found: bool,
-    }
-
-    impl<'hir> intravisit::Visitor<'hir> for TryFinder {
-        type Map = Map<'hir>;
-
-        fn nested_visit_map(&mut self) -> intravisit::NestedVisitorMap<Self::Map> {
-            intravisit::NestedVisitorMap::None
-        }
-
-        fn visit_expr(&mut self, expr: &'hir Expr<'hir>) {
-            if self.found {
-                return;
-            }
-            match expr.kind {
-                ExprKind::Match(_, _, MatchSource::TryDesugar) => self.found = true,
-                _ => intravisit::walk_expr(self, expr),
-            }
-        }
-    }
-
-    let mut visitor = TryFinder { found: false };
-    visitor.visit_expr(expr);
-    visitor.found
-}
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index 253b7823bd9..bd62e67f80e 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -21,6 +21,7 @@ pub mod ptr;
 pub mod qualify_min_const_fn;
 pub mod sugg;
 pub mod usage;
+pub mod visitors;
 
 pub use self::attrs::*;
 pub use self::diagnostics::*;
diff --git a/clippy_lints/src/utils/visitors.rs b/clippy_lints/src/utils/visitors.rs
new file mode 100644
index 00000000000..b0837b6c43e
--- /dev/null
+++ b/clippy_lints/src/utils/visitors.rs
@@ -0,0 +1,125 @@
+use rustc_hir as hir;
+use rustc_hir::intravisit::{self, Visitor};
+use rustc_lint::LateContext;
+use rustc_middle::hir::map::Map;
+
+/// returns `true` if expr contains match expr desugared from try
+fn contains_try(expr: &hir::Expr<'_>) -> bool {
+    struct TryFinder {
+        found: bool,
+    }
+
+    impl<'hir> intravisit::Visitor<'hir> for TryFinder {
+        type Map = Map<'hir>;
+
+        fn nested_visit_map(&mut self) -> intravisit::NestedVisitorMap<Self::Map> {
+            intravisit::NestedVisitorMap::None
+        }
+
+        fn visit_expr(&mut self, expr: &'hir hir::Expr<'hir>) {
+            if self.found {
+                return;
+            }
+            match expr.kind {
+                hir::ExprKind::Match(_, _, hir::MatchSource::TryDesugar) => self.found = true,
+                _ => intravisit::walk_expr(self, expr),
+            }
+        }
+    }
+
+    let mut visitor = TryFinder { found: false };
+    visitor.visit_expr(expr);
+    visitor.found
+}
+
+pub fn find_all_ret_expressions<'hir, F>(_cx: &LateContext<'_>, expr: &'hir hir::Expr<'hir>, callback: F) -> bool
+where
+    F: FnMut(&'hir hir::Expr<'hir>) -> bool,
+{
+    struct RetFinder<F> {
+        in_stmt: bool,
+        failed: bool,
+        cb: F,
+    }
+
+    struct WithStmtGuarg<'a, F> {
+        val: &'a mut RetFinder<F>,
+        prev_in_stmt: bool,
+    }
+
+    impl<F> RetFinder<F> {
+        fn inside_stmt(&mut self, in_stmt: bool) -> WithStmtGuarg<'_, F> {
+            let prev_in_stmt = std::mem::replace(&mut self.in_stmt, in_stmt);
+            WithStmtGuarg {
+                val: self,
+                prev_in_stmt,
+            }
+        }
+    }
+
+    impl<F> std::ops::Deref for WithStmtGuarg<'_, F> {
+        type Target = RetFinder<F>;
+
+        fn deref(&self) -> &Self::Target {
+            self.val
+        }
+    }
+
+    impl<F> std::ops::DerefMut for WithStmtGuarg<'_, F> {
+        fn deref_mut(&mut self) -> &mut Self::Target {
+            self.val
+        }
+    }
+
+    impl<F> Drop for WithStmtGuarg<'_, F> {
+        fn drop(&mut self) {
+            self.val.in_stmt = self.prev_in_stmt;
+        }
+    }
+
+    impl<'hir, F: FnMut(&'hir hir::Expr<'hir>) -> bool> intravisit::Visitor<'hir> for RetFinder<F> {
+        type Map = Map<'hir>;
+
+        fn nested_visit_map(&mut self) -> intravisit::NestedVisitorMap<Self::Map> {
+            intravisit::NestedVisitorMap::None
+        }
+
+        fn visit_stmt(&mut self, stmt: &'hir hir::Stmt<'_>) {
+            intravisit::walk_stmt(&mut *self.inside_stmt(true), stmt)
+        }
+
+        fn visit_expr(&mut self, expr: &'hir hir::Expr<'_>) {
+            if self.failed {
+                return;
+            }
+            if self.in_stmt {
+                match expr.kind {
+                    hir::ExprKind::Ret(Some(expr)) => self.inside_stmt(false).visit_expr(expr),
+                    _ => intravisit::walk_expr(self, expr),
+                }
+            } else {
+                match expr.kind {
+                    hir::ExprKind::Match(cond, arms, _) => {
+                        self.inside_stmt(true).visit_expr(cond);
+                        for arm in arms {
+                            self.visit_expr(arm.body);
+                        }
+                    },
+                    hir::ExprKind::Block(..) => intravisit::walk_expr(self, expr),
+                    hir::ExprKind::Ret(Some(expr)) => self.visit_expr(expr),
+                    _ => self.failed |= !(self.cb)(expr),
+                }
+            }
+        }
+    }
+
+    !contains_try(expr) && {
+        let mut ret_finder = RetFinder {
+            in_stmt: false,
+            failed: false,
+            cb: callback,
+        };
+        ret_finder.visit_expr(expr);
+        !ret_finder.failed
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From eec7f5c1113d3d49dd7f42462ea25d0b36b4b49b Mon Sep 17 00:00:00 2001
From: Hirochika Matsumoto <matsujika@gmail.com>
Date: Mon, 12 Oct 2020 19:21:04 +0900
Subject: Update clippy_lints/src/unnecessary_wrap.rs

Co-authored-by: Philipp Krones <hello@philkrones.com>
---
 clippy_lints/src/unnecessary_wrap.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unnecessary_wrap.rs b/clippy_lints/src/unnecessary_wrap.rs
index de13301381e..28762b8d265 100644
--- a/clippy_lints/src/unnecessary_wrap.rs
+++ b/clippy_lints/src/unnecessary_wrap.rs
@@ -100,7 +100,7 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryWrap {
                 cx,
                 UNNECESSARY_WRAP,
                 span,
-                "this function returns unnecessarily wrapping data",
+                format!("this function's return value is unnecessarily wrapped by `{}`, return_type)",
                 |diag| {
                     let inner_ty = return_ty(cx, hir_id)
                         .walk()
-- 
cgit 1.4.1-3-g733a5


From 1bdac8712868e1418dcb13e817254620a8c01158 Mon Sep 17 00:00:00 2001
From: Hirochika Matsumoto <matsujika@gmail.com>
Date: Mon, 12 Oct 2020 19:27:47 +0900
Subject: Improve lint message

---
 clippy_lints/src/unnecessary_wrap.rs | 2 +-
 tests/ui/unnecessary_wrap.stderr     | 8 ++++----
 2 files changed, 5 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unnecessary_wrap.rs b/clippy_lints/src/unnecessary_wrap.rs
index 28762b8d265..db51ee681ef 100644
--- a/clippy_lints/src/unnecessary_wrap.rs
+++ b/clippy_lints/src/unnecessary_wrap.rs
@@ -100,7 +100,7 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryWrap {
                 cx,
                 UNNECESSARY_WRAP,
                 span,
-                format!("this function's return value is unnecessarily wrapped by `{}`, return_type)",
+                format!("this function's return value is unnecessarily wrapped by `{}`", return_type).as_str(),
                 |diag| {
                     let inner_ty = return_ty(cx, hir_id)
                         .walk()
diff --git a/tests/ui/unnecessary_wrap.stderr b/tests/ui/unnecessary_wrap.stderr
index a3481330e99..958bc998022 100644
--- a/tests/ui/unnecessary_wrap.stderr
+++ b/tests/ui/unnecessary_wrap.stderr
@@ -1,4 +1,4 @@
-error: this function returns unnecessarily wrapping data
+error: this function's return value is unnecessarily wrapped by `Option`
   --> $DIR/unnecessary_wrap.rs:8:1
    |
 LL | / fn func1(a: bool, b: bool) -> Option<i32> {
@@ -25,7 +25,7 @@ LL |         2
 LL |     } else {
  ...
 
-error: this function returns unnecessarily wrapping data
+error: this function's return value is unnecessarily wrapped by `Option`
   --> $DIR/unnecessary_wrap.rs:21:1
    |
 LL | / fn func2(a: bool, b: bool) -> Option<i32> {
@@ -51,7 +51,7 @@ LL |     } else {
 LL |         30
    |
 
-error: this function returns unnecessarily wrapping data
+error: this function's return value is unnecessarily wrapped by `Option`
   --> $DIR/unnecessary_wrap.rs:51:1
    |
 LL | / fn func5() -> Option<i32> {
@@ -68,7 +68,7 @@ help: ...and change the returning expressions
 LL |     1
    |
 
-error: this function returns unnecessarily wrapping data
+error: this function's return value is unnecessarily wrapped by `Result`
   --> $DIR/unnecessary_wrap.rs:61:1
    |
 LL | / fn func7() -> Result<i32, ()> {
-- 
cgit 1.4.1-3-g733a5


From 8392bc7946a212a85bc5a411f5321a1f76d5ccf6 Mon Sep 17 00:00:00 2001
From: Hirochika Matsumoto <matsujika@gmail.com>
Date: Mon, 12 Oct 2020 19:37:27 +0900
Subject: Run `cargo dev fmt`

---
 clippy_lints/src/unnecessary_wrap.rs | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unnecessary_wrap.rs b/clippy_lints/src/unnecessary_wrap.rs
index db51ee681ef..fc1a33fc6cd 100644
--- a/clippy_lints/src/unnecessary_wrap.rs
+++ b/clippy_lints/src/unnecessary_wrap.rs
@@ -100,7 +100,11 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryWrap {
                 cx,
                 UNNECESSARY_WRAP,
                 span,
-                format!("this function's return value is unnecessarily wrapped by `{}`", return_type).as_str(),
+                format!(
+                    "this function's return value is unnecessarily wrapped by `{}`",
+                    return_type
+                )
+                .as_str(),
                 |diag| {
                     let inner_ty = return_ty(cx, hir_id)
                         .walk()
-- 
cgit 1.4.1-3-g733a5


From 2f85aa736e85544803ff6d3e6b13e44c0729bbdd Mon Sep 17 00:00:00 2001
From: Hirochika Matsumoto <matsujika@gmail.com>
Date: Sun, 18 Oct 2020 16:30:46 +0900
Subject: Make lint skip closures

---
 clippy_lints/src/unnecessary_wrap.rs | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unnecessary_wrap.rs b/clippy_lints/src/unnecessary_wrap.rs
index fc1a33fc6cd..a20d1f82e9e 100644
--- a/clippy_lints/src/unnecessary_wrap.rs
+++ b/clippy_lints/src/unnecessary_wrap.rs
@@ -63,12 +63,10 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryWrap {
         span: Span,
         hir_id: HirId,
     ) {
-        if_chain! {
-            if let FnKind::ItemFn(.., visibility, _) = fn_kind;
-            if visibility.node.is_pub();
-            then {
-                return;
-            }
+        match fn_kind {
+            FnKind::ItemFn(.., visibility, _) if visibility.node.is_pub() => return,
+            FnKind::Closure(..) => return,
+            _ => (),
         }
 
         let (return_type, path) = if is_type_diagnostic_item(cx, return_ty(cx, hir_id), sym!(option_type)) {
-- 
cgit 1.4.1-3-g733a5


From 12474c62ff89ab122c2e6881b00680913fdf1d35 Mon Sep 17 00:00:00 2001
From: Hirochika Matsumoto <matsujika@gmail.com>
Date: Sun, 18 Oct 2020 16:53:18 +0900
Subject: Add support for methods

---
 clippy_lints/src/unnecessary_wrap.rs |  6 +++++-
 tests/ui/unnecessary_wrap.rs         | 14 ++++++++++++++
 tests/ui/unnecessary_wrap.stderr     | 19 ++++++++++++++++++-
 3 files changed, 37 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unnecessary_wrap.rs b/clippy_lints/src/unnecessary_wrap.rs
index a20d1f82e9e..365e9c9984e 100644
--- a/clippy_lints/src/unnecessary_wrap.rs
+++ b/clippy_lints/src/unnecessary_wrap.rs
@@ -64,7 +64,11 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryWrap {
         hir_id: HirId,
     ) {
         match fn_kind {
-            FnKind::ItemFn(.., visibility, _) if visibility.node.is_pub() => return,
+            FnKind::ItemFn(.., visibility, _) | FnKind::Method(.., Some(visibility), _) => {
+                if visibility.node.is_pub() {
+                    return;
+                }
+            },
             FnKind::Closure(..) => return,
             _ => (),
         }
diff --git a/tests/ui/unnecessary_wrap.rs b/tests/ui/unnecessary_wrap.rs
index 6037f5807d3..0ced20b7a56 100644
--- a/tests/ui/unnecessary_wrap.rs
+++ b/tests/ui/unnecessary_wrap.rs
@@ -76,6 +76,20 @@ fn func9(a: bool) -> Result<i32, ()> {
     Err(())
 }
 
+struct A;
+
+impl A {
+    // should not be linted
+    pub fn func10() -> Option<i32> {
+        Some(1)
+    }
+
+    // should be linted
+    fn func11() -> Option<i32> {
+        Some(1)
+    }
+}
+
 fn main() {
     // method calls are not linted
     func1(true, true);
diff --git a/tests/ui/unnecessary_wrap.stderr b/tests/ui/unnecessary_wrap.stderr
index 958bc998022..dbc5748c29e 100644
--- a/tests/ui/unnecessary_wrap.stderr
+++ b/tests/ui/unnecessary_wrap.stderr
@@ -85,5 +85,22 @@ help: ...and change the returning expressions
 LL |     1
    |
 
-error: aborting due to 4 previous errors
+error: this function's return value is unnecessarily wrapped by `Option`
+  --> $DIR/unnecessary_wrap.rs:88:5
+   |
+LL | /     fn func11() -> Option<i32> {
+LL | |         Some(1)
+LL | |     }
+   | |_____^
+   |
+help: remove `Option` from the return type...
+   |
+LL |     fn func11() -> i32 {
+   |                    ^^^
+help: ...and change the returning expressions
+   |
+LL |         1
+   |
+
+error: aborting due to 5 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From c5447eb3c167025fcc1b842fabd7bb43a2eb1e9e Mon Sep 17 00:00:00 2001
From: Hirochika Matsumoto <matsujika@gmail.com>
Date: Sun, 18 Oct 2020 17:17:45 +0900
Subject: Make lint skip macros

---
 clippy_lints/src/unnecessary_wrap.rs | 3 ++-
 tests/ui/unnecessary_wrap.rs         | 9 +++++++--
 tests/ui/unnecessary_wrap.stderr     | 6 +++---
 3 files changed, 12 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unnecessary_wrap.rs b/clippy_lints/src/unnecessary_wrap.rs
index 365e9c9984e..7ec523293c8 100644
--- a/clippy_lints/src/unnecessary_wrap.rs
+++ b/clippy_lints/src/unnecessary_wrap.rs
@@ -1,5 +1,5 @@
 use crate::utils::{
-    is_type_diagnostic_item, match_qpath, paths, return_ty, snippet, span_lint_and_then,
+    in_macro, is_type_diagnostic_item, match_qpath, paths, return_ty, snippet, span_lint_and_then,
     visitors::find_all_ret_expressions,
 };
 use if_chain::if_chain;
@@ -84,6 +84,7 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryWrap {
         let mut suggs = Vec::new();
         let can_sugg = find_all_ret_expressions(cx, &body.value, |ret_expr| {
             if_chain! {
+                if !in_macro(ret_expr.span);
                 if let ExprKind::Call(ref func, ref args) = ret_expr.kind;
                 if let ExprKind::Path(ref qpath) = func.kind;
                 if match_qpath(qpath, path);
diff --git a/tests/ui/unnecessary_wrap.rs b/tests/ui/unnecessary_wrap.rs
index 0ced20b7a56..618c452065b 100644
--- a/tests/ui/unnecessary_wrap.rs
+++ b/tests/ui/unnecessary_wrap.rs
@@ -76,16 +76,21 @@ fn func9(a: bool) -> Result<i32, ()> {
     Err(())
 }
 
+// should not be linted
+fn func10() -> Option<()> {
+    unimplemented!()
+}
+
 struct A;
 
 impl A {
     // should not be linted
-    pub fn func10() -> Option<i32> {
+    pub fn func11() -> Option<i32> {
         Some(1)
     }
 
     // should be linted
-    fn func11() -> Option<i32> {
+    fn func12() -> Option<i32> {
         Some(1)
     }
 }
diff --git a/tests/ui/unnecessary_wrap.stderr b/tests/ui/unnecessary_wrap.stderr
index dbc5748c29e..5f21b74bc76 100644
--- a/tests/ui/unnecessary_wrap.stderr
+++ b/tests/ui/unnecessary_wrap.stderr
@@ -86,16 +86,16 @@ LL |     1
    |
 
 error: this function's return value is unnecessarily wrapped by `Option`
-  --> $DIR/unnecessary_wrap.rs:88:5
+  --> $DIR/unnecessary_wrap.rs:93:5
    |
-LL | /     fn func11() -> Option<i32> {
+LL | /     fn func12() -> Option<i32> {
 LL | |         Some(1)
 LL | |     }
    | |_____^
    |
 help: remove `Option` from the return type...
    |
-LL |     fn func11() -> i32 {
+LL |     fn func12() -> i32 {
    |                    ^^^
 help: ...and change the returning expressions
    |
-- 
cgit 1.4.1-3-g733a5


From c7692cf7493facefd520a98bf86aa1f4a031f435 Mon Sep 17 00:00:00 2001
From: Hirochika Matsumoto <matsujika@gmail.com>
Date: Sun, 18 Oct 2020 17:27:08 +0900
Subject: Skip function with no exprs contained

---
 clippy_lints/src/unnecessary_wrap.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unnecessary_wrap.rs b/clippy_lints/src/unnecessary_wrap.rs
index 7ec523293c8..28cc20f0007 100644
--- a/clippy_lints/src/unnecessary_wrap.rs
+++ b/clippy_lints/src/unnecessary_wrap.rs
@@ -98,7 +98,7 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryWrap {
             }
         });
 
-        if can_sugg {
+        if can_sugg && !suggs.is_empty() {
             span_lint_and_then(
                 cx,
                 UNNECESSARY_WRAP,
-- 
cgit 1.4.1-3-g733a5


From e998d61fe6a1407f73504a2fee16df2f9167a37c Mon Sep 17 00:00:00 2001
From: Hirochika Matsumoto <matsujika@gmail.com>
Date: Sun, 18 Oct 2020 18:36:37 +0900
Subject: Downgrade applicability to MaybeIncorrect

---
 clippy_lints/src/unnecessary_wrap.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unnecessary_wrap.rs b/clippy_lints/src/unnecessary_wrap.rs
index 28cc20f0007..6434b3033dd 100644
--- a/clippy_lints/src/unnecessary_wrap.rs
+++ b/clippy_lints/src/unnecessary_wrap.rs
@@ -122,7 +122,7 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryWrap {
                             fn_decl.output.span(),
                             format!("remove `{}` from the return type...", return_type).as_str(),
                             inner_ty,
-                            Applicability::MachineApplicable,
+                            Applicability::MaybeIncorrect,
                         );
                     });
                     diag.multipart_suggestion(
-- 
cgit 1.4.1-3-g733a5


From 9d96311d7354d99b6f3b3956405b7defac81461c Mon Sep 17 00:00:00 2001
From: Hirochika Matsumoto <matsujika@gmail.com>
Date: Sun, 18 Oct 2020 18:46:16 +0900
Subject: Remove wildcard use

---
 clippy_lints/src/unnecessary_wrap.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unnecessary_wrap.rs b/clippy_lints/src/unnecessary_wrap.rs
index 6434b3033dd..7a9cf627059 100644
--- a/clippy_lints/src/unnecessary_wrap.rs
+++ b/clippy_lints/src/unnecessary_wrap.rs
@@ -5,7 +5,7 @@ use crate::utils::{
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::FnKind;
-use rustc_hir::*;
+use rustc_hir::{Body, ExprKind, FnDecl, HirId};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::subst::GenericArgKind;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-- 
cgit 1.4.1-3-g733a5


From 532d205218c7aa28c1718f9e9088eeced6e2c5ac Mon Sep 17 00:00:00 2001
From: Hirochika Matsumoto <matsujika@gmail.com>
Date: Sun, 18 Oct 2020 19:24:11 +0900
Subject: Skip functions in PartialOrd

---
 clippy_lints/src/unnecessary_wrap.rs | 12 ++++++++++--
 clippy_lints/src/utils/paths.rs      |  1 +
 2 files changed, 11 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unnecessary_wrap.rs b/clippy_lints/src/unnecessary_wrap.rs
index 7a9cf627059..ec6c823a4ec 100644
--- a/clippy_lints/src/unnecessary_wrap.rs
+++ b/clippy_lints/src/unnecessary_wrap.rs
@@ -1,6 +1,6 @@
 use crate::utils::{
-    in_macro, is_type_diagnostic_item, match_qpath, paths, return_ty, snippet, span_lint_and_then,
-    visitors::find_all_ret_expressions,
+    in_macro, is_type_diagnostic_item, match_path, match_qpath, paths, return_ty, snippet, span_lint_and_then,
+    trait_ref_of_method, visitors::find_all_ret_expressions,
 };
 use if_chain::if_chain;
 use rustc_errors::Applicability;
@@ -63,6 +63,14 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryWrap {
         span: Span,
         hir_id: HirId,
     ) {
+        if_chain! {
+            if let Some(trait_ref) = trait_ref_of_method(cx, hir_id);
+            if match_path(trait_ref.path, &paths::PARTIAL_ORD);
+            then {
+                return;
+            }
+        }
+
         match fn_kind {
             FnKind::ItemFn(.., visibility, _) | FnKind::Method(.., Some(visibility), _) => {
                 if visibility.node.is_pub() {
diff --git a/clippy_lints/src/utils/paths.rs b/clippy_lints/src/utils/paths.rs
index 2be5ff93f86..97e01f445ff 100644
--- a/clippy_lints/src/utils/paths.rs
+++ b/clippy_lints/src/utils/paths.rs
@@ -81,6 +81,7 @@ pub const OS_STR_TO_OS_STRING: [&str; 5] = ["std", "ffi", "os_str", "OsStr", "to
 pub const PARKING_LOT_MUTEX_GUARD: [&str; 2] = ["parking_lot", "MutexGuard"];
 pub const PARKING_LOT_RWLOCK_READ_GUARD: [&str; 2] = ["parking_lot", "RwLockReadGuard"];
 pub const PARKING_LOT_RWLOCK_WRITE_GUARD: [&str; 2] = ["parking_lot", "RwLockWriteGuard"];
+pub const PARTIAL_ORD: [&str; 3] = ["std", "cmp", "PartialOrd"];
 pub const PATH: [&str; 3] = ["std", "path", "Path"];
 pub const PATH_BUF: [&str; 3] = ["std", "path", "PathBuf"];
 pub const PATH_BUF_AS_PATH: [&str; 4] = ["std", "path", "PathBuf", "as_path"];
-- 
cgit 1.4.1-3-g733a5


From bf46f78ca7e15631f08253c14975896030ca24a8 Mon Sep 17 00:00:00 2001
From: Hirochika Matsumoto <matsujika@gmail.com>
Date: Sun, 18 Oct 2020 19:35:59 +0900
Subject: Fix clippy error

---
 clippy_lints/src/redundant_clone.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/redundant_clone.rs b/clippy_lints/src/redundant_clone.rs
index b4a9804fb25..c4ca7fcdecc 100644
--- a/clippy_lints/src/redundant_clone.rs
+++ b/clippy_lints/src/redundant_clone.rs
@@ -320,11 +320,11 @@ fn find_stmt_assigns_to<'tcx>(
 
     match (by_ref, &*rvalue) {
         (true, mir::Rvalue::Ref(_, _, place)) | (false, mir::Rvalue::Use(mir::Operand::Copy(place))) => {
-            base_local_and_movability(cx, mir, *place)
+            Some(base_local_and_movability(cx, mir, *place))
         },
         (false, mir::Rvalue::Ref(_, _, place)) => {
             if let [mir::ProjectionElem::Deref] = place.as_ref().projection {
-                base_local_and_movability(cx, mir, *place)
+                Some(base_local_and_movability(cx, mir, *place))
             } else {
                 None
             }
@@ -341,7 +341,7 @@ fn base_local_and_movability<'tcx>(
     cx: &LateContext<'tcx>,
     mir: &mir::Body<'tcx>,
     place: mir::Place<'tcx>,
-) -> Option<(mir::Local, CannotMoveOut)> {
+) -> (mir::Local, CannotMoveOut) {
     use rustc_middle::mir::PlaceRef;
 
     // Dereference. You cannot move things out from a borrowed value.
@@ -362,7 +362,7 @@ fn base_local_and_movability<'tcx>(
             && !is_copy(cx, mir::Place::ty_from(local, projection, &mir.local_decls, cx.tcx).ty);
     }
 
-    Some((local, deref || field || slice))
+    (local, deref || field || slice)
 }
 
 struct LocalUseVisitor {
-- 
cgit 1.4.1-3-g733a5


From 4e5c02e8980d16feeee953f112f940c598180ddc Mon Sep 17 00:00:00 2001
From: Hirochika Matsumoto <matsujika@gmail.com>
Date: Sat, 14 Nov 2020 19:25:54 +0900
Subject: Ignore trait implementations

---
 clippy_lints/src/unnecessary_wrap.rs | 20 +++++++++-----------
 clippy_lints/src/utils/paths.rs      |  1 -
 tests/ui/unnecessary_wrap.rs         | 14 ++++++++++++++
 3 files changed, 23 insertions(+), 12 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unnecessary_wrap.rs b/clippy_lints/src/unnecessary_wrap.rs
index ec6c823a4ec..2960ffc5352 100644
--- a/clippy_lints/src/unnecessary_wrap.rs
+++ b/clippy_lints/src/unnecessary_wrap.rs
@@ -1,11 +1,11 @@
 use crate::utils::{
-    in_macro, is_type_diagnostic_item, match_path, match_qpath, paths, return_ty, snippet, span_lint_and_then,
-    trait_ref_of_method, visitors::find_all_ret_expressions,
+    in_macro, is_type_diagnostic_item, match_qpath, paths, return_ty, snippet, span_lint_and_then,
+    visitors::find_all_ret_expressions,
 };
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::FnKind;
-use rustc_hir::{Body, ExprKind, FnDecl, HirId};
+use rustc_hir::{Body, ExprKind, FnDecl, HirId, ItemKind, Node};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::subst::GenericArgKind;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -63,14 +63,6 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryWrap {
         span: Span,
         hir_id: HirId,
     ) {
-        if_chain! {
-            if let Some(trait_ref) = trait_ref_of_method(cx, hir_id);
-            if match_path(trait_ref.path, &paths::PARTIAL_ORD);
-            then {
-                return;
-            }
-        }
-
         match fn_kind {
             FnKind::ItemFn(.., visibility, _) | FnKind::Method(.., Some(visibility), _) => {
                 if visibility.node.is_pub() {
@@ -81,6 +73,12 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryWrap {
             _ => (),
         }
 
+        if let Some(Node::Item(item)) = cx.tcx.hir().find(cx.tcx.hir().get_parent_node(hir_id)) {
+            if matches!(item.kind, ItemKind::Impl{ of_trait: Some(_), ..} | ItemKind::Trait(..)) {
+                return;
+            }
+        }
+
         let (return_type, path) = if is_type_diagnostic_item(cx, return_ty(cx, hir_id), sym!(option_type)) {
             ("Option", &paths::OPTION_SOME)
         } else if is_type_diagnostic_item(cx, return_ty(cx, hir_id), sym!(result_type)) {
diff --git a/clippy_lints/src/utils/paths.rs b/clippy_lints/src/utils/paths.rs
index 97e01f445ff..2be5ff93f86 100644
--- a/clippy_lints/src/utils/paths.rs
+++ b/clippy_lints/src/utils/paths.rs
@@ -81,7 +81,6 @@ pub const OS_STR_TO_OS_STRING: [&str; 5] = ["std", "ffi", "os_str", "OsStr", "to
 pub const PARKING_LOT_MUTEX_GUARD: [&str; 2] = ["parking_lot", "MutexGuard"];
 pub const PARKING_LOT_RWLOCK_READ_GUARD: [&str; 2] = ["parking_lot", "RwLockReadGuard"];
 pub const PARKING_LOT_RWLOCK_WRITE_GUARD: [&str; 2] = ["parking_lot", "RwLockWriteGuard"];
-pub const PARTIAL_ORD: [&str; 3] = ["std", "cmp", "PartialOrd"];
 pub const PATH: [&str; 3] = ["std", "path", "Path"];
 pub const PATH_BUF: [&str; 3] = ["std", "path", "PathBuf"];
 pub const PATH_BUF_AS_PATH: [&str; 4] = ["std", "path", "PathBuf", "as_path"];
diff --git a/tests/ui/unnecessary_wrap.rs b/tests/ui/unnecessary_wrap.rs
index 618c452065b..11208690428 100644
--- a/tests/ui/unnecessary_wrap.rs
+++ b/tests/ui/unnecessary_wrap.rs
@@ -95,6 +95,20 @@ impl A {
     }
 }
 
+trait B {
+    // trait impls are not linted
+    fn func13() -> Option<i32> {
+        Some(1)
+    }
+}
+
+impl A for B {
+    // trait impls are not linted
+    fn func13() -> Option<i32> {
+        Some(0)
+    }
+}
+
 fn main() {
     // method calls are not linted
     func1(true, true);
-- 
cgit 1.4.1-3-g733a5


From c7445d7f2c3eece2b9056d05ea92fb1d1112b3ca Mon Sep 17 00:00:00 2001
From: Hirochika Matsumoto <matsujika@gmail.com>
Date: Wed, 18 Nov 2020 01:01:22 +0900
Subject: Pluralize lint name

---
 CHANGELOG.md                              |   2 +-
 clippy_lints/src/lib.rs                   |  10 +--
 clippy_lints/src/unnecessary_wrap.rs      | 143 ------------------------------
 clippy_lints/src/unnecessary_wraps.rs     | 143 ++++++++++++++++++++++++++++++
 src/lintlist/mod.rs                       |   4 +-
 tests/ui/derive_ord_xor_partial_ord.rs    |   2 +-
 tests/ui/doc_errors.rs                    |   2 +-
 tests/ui/drop_ref.rs                      |   2 +-
 tests/ui/forget_ref.rs                    |   2 +-
 tests/ui/let_underscore_must_use.rs       |   2 +-
 tests/ui/manual_unwrap_or.fixed           |   2 +-
 tests/ui/manual_unwrap_or.rs              |   2 +-
 tests/ui/map_err.rs                       |   2 +-
 tests/ui/map_flatten.fixed                |   2 +-
 tests/ui/map_flatten.rs                   |   2 +-
 tests/ui/needless_lifetimes.rs            |   2 +-
 tests/ui/option_map_unit_fn_fixable.fixed |   2 +-
 tests/ui/option_map_unit_fn_fixable.rs    |   2 +-
 tests/ui/option_option.rs                 |   2 +-
 tests/ui/or_fun_call.fixed                |   2 +-
 tests/ui/or_fun_call.rs                   |   2 +-
 tests/ui/panic_in_result_fn.rs            |   2 +-
 tests/ui/question_mark.fixed              |   2 +-
 tests/ui/question_mark.rs                 |   2 +-
 tests/ui/redundant_pattern_matching.fixed |   2 +-
 tests/ui/redundant_pattern_matching.rs    |   2 +-
 tests/ui/result_unit_error.rs             |   2 +-
 tests/ui/try_err.fixed                    |   2 +-
 tests/ui/try_err.rs                       |   2 +-
 tests/ui/unit_arg.rs                      |   2 +-
 tests/ui/unnecessary_clone.rs             |   2 +-
 tests/ui/unnecessary_wrap.rs              | 116 ------------------------
 tests/ui/unnecessary_wrap.stderr          | 106 ----------------------
 tests/ui/unnecessary_wraps.rs             | 116 ++++++++++++++++++++++++
 tests/ui/unnecessary_wraps.stderr         | 106 ++++++++++++++++++++++
 tests/ui/useless_conversion.fixed         |   2 +-
 tests/ui/useless_conversion.rs            |   2 +-
 tests/ui/wildcard_imports.fixed           |   2 +-
 tests/ui/wildcard_imports.rs              |   2 +-
 39 files changed, 403 insertions(+), 403 deletions(-)
 delete mode 100644 clippy_lints/src/unnecessary_wrap.rs
 create mode 100644 clippy_lints/src/unnecessary_wraps.rs
 delete mode 100644 tests/ui/unnecessary_wrap.rs
 delete mode 100644 tests/ui/unnecessary_wrap.stderr
 create mode 100644 tests/ui/unnecessary_wraps.rs
 create mode 100644 tests/ui/unnecessary_wraps.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 02b862d3196..64f67680b6c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2008,7 +2008,7 @@ Released 2018-09-13
 [`unnecessary_operation`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_operation
 [`unnecessary_sort_by`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_sort_by
 [`unnecessary_unwrap`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_unwrap
-[`unnecessary_wrap`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_wrap
+[`unnecessary_wraps`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_wraps
 [`unneeded_field_pattern`]: https://rust-lang.github.io/rust-clippy/master/index.html#unneeded_field_pattern
 [`unneeded_wildcard_pattern`]: https://rust-lang.github.io/rust-clippy/master/index.html#unneeded_wildcard_pattern
 [`unnested_or_patterns`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnested_or_patterns
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 2d1f75391bb..f0c1cb8d6e5 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -323,7 +323,7 @@ mod unicode;
 mod unit_return_expecting_ord;
 mod unnamed_address;
 mod unnecessary_sort_by;
-mod unnecessary_wrap;
+mod unnecessary_wraps;
 mod unnested_or_patterns;
 mod unsafe_removed_from_name;
 mod unused_io_amount;
@@ -893,7 +893,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &unnamed_address::FN_ADDRESS_COMPARISONS,
         &unnamed_address::VTABLE_ADDRESS_COMPARISONS,
         &unnecessary_sort_by::UNNECESSARY_SORT_BY,
-        &unnecessary_wrap::UNNECESSARY_WRAP,
+        &unnecessary_wraps::UNNECESSARY_WRAPS,
         &unnested_or_patterns::UNNESTED_OR_PATTERNS,
         &unsafe_removed_from_name::UNSAFE_REMOVED_FROM_NAME,
         &unused_io_amount::UNUSED_IO_AMOUNT,
@@ -1066,7 +1066,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box redundant_clone::RedundantClone);
     store.register_late_pass(|| box slow_vector_initialization::SlowVectorInit);
     store.register_late_pass(|| box unnecessary_sort_by::UnnecessarySortBy);
-    store.register_late_pass(|| box unnecessary_wrap::UnnecessaryWrap);
+    store.register_late_pass(|| box unnecessary_wraps::UnnecessaryWraps);
     store.register_late_pass(|| box types::RefToMut);
     store.register_late_pass(|| box assertions_on_constants::AssertionsOnConstants);
     store.register_late_pass(|| box missing_const_for_fn::MissingConstForFn);
@@ -1574,7 +1574,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&unnamed_address::FN_ADDRESS_COMPARISONS),
         LintId::of(&unnamed_address::VTABLE_ADDRESS_COMPARISONS),
         LintId::of(&unnecessary_sort_by::UNNECESSARY_SORT_BY),
-        LintId::of(&unnecessary_wrap::UNNECESSARY_WRAP),
+        LintId::of(&unnecessary_wraps::UNNECESSARY_WRAPS),
         LintId::of(&unsafe_removed_from_name::UNSAFE_REMOVED_FROM_NAME),
         LintId::of(&unused_io_amount::UNUSED_IO_AMOUNT),
         LintId::of(&unused_unit::UNUSED_UNIT),
@@ -1779,7 +1779,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&types::UNNECESSARY_CAST),
         LintId::of(&types::VEC_BOX),
         LintId::of(&unnecessary_sort_by::UNNECESSARY_SORT_BY),
-        LintId::of(&unnecessary_wrap::UNNECESSARY_WRAP),
+        LintId::of(&unnecessary_wraps::UNNECESSARY_WRAPS),
         LintId::of(&unwrap::UNNECESSARY_UNWRAP),
         LintId::of(&useless_conversion::USELESS_CONVERSION),
         LintId::of(&zero_div_zero::ZERO_DIVIDED_BY_ZERO),
diff --git a/clippy_lints/src/unnecessary_wrap.rs b/clippy_lints/src/unnecessary_wrap.rs
deleted file mode 100644
index 2960ffc5352..00000000000
--- a/clippy_lints/src/unnecessary_wrap.rs
+++ /dev/null
@@ -1,143 +0,0 @@
-use crate::utils::{
-    in_macro, is_type_diagnostic_item, match_qpath, paths, return_ty, snippet, span_lint_and_then,
-    visitors::find_all_ret_expressions,
-};
-use if_chain::if_chain;
-use rustc_errors::Applicability;
-use rustc_hir::intravisit::FnKind;
-use rustc_hir::{Body, ExprKind, FnDecl, HirId, ItemKind, Node};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty::subst::GenericArgKind;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::Span;
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for private functions that only return `Ok` or `Some`.
-    ///
-    /// **Why is this bad?** It is not meaningful to wrap values when no `None` or `Err` is returned.
-    ///
-    /// **Known problems:** Since this lint changes function type signature, you may need to
-    /// adjust some code at callee side.
-    ///
-    /// **Example:**
-    ///
-    /// ```rust
-    /// fn get_cool_number(a: bool, b: bool) -> Option<i32> {
-    ///     if a && b {
-    ///         return Some(50);
-    ///     }
-    ///     if a {
-    ///         Some(0)
-    ///     } else {
-    ///         Some(10)
-    ///     }
-    /// }
-    /// ```
-    /// Use instead:
-    /// ```rust
-    /// fn get_cool_number(a: bool, b: bool) -> i32 {
-    ///     if a && b {
-    ///         return 50;
-    ///     }
-    ///     if a {
-    ///         0
-    ///     } else {
-    ///         10
-    ///     }
-    /// }
-    /// ```
-    pub UNNECESSARY_WRAP,
-    complexity,
-    "functions that only return `Ok` or `Some`"
-}
-
-declare_lint_pass!(UnnecessaryWrap => [UNNECESSARY_WRAP]);
-
-impl<'tcx> LateLintPass<'tcx> for UnnecessaryWrap {
-    fn check_fn(
-        &mut self,
-        cx: &LateContext<'tcx>,
-        fn_kind: FnKind<'tcx>,
-        fn_decl: &FnDecl<'tcx>,
-        body: &Body<'tcx>,
-        span: Span,
-        hir_id: HirId,
-    ) {
-        match fn_kind {
-            FnKind::ItemFn(.., visibility, _) | FnKind::Method(.., Some(visibility), _) => {
-                if visibility.node.is_pub() {
-                    return;
-                }
-            },
-            FnKind::Closure(..) => return,
-            _ => (),
-        }
-
-        if let Some(Node::Item(item)) = cx.tcx.hir().find(cx.tcx.hir().get_parent_node(hir_id)) {
-            if matches!(item.kind, ItemKind::Impl{ of_trait: Some(_), ..} | ItemKind::Trait(..)) {
-                return;
-            }
-        }
-
-        let (return_type, path) = if is_type_diagnostic_item(cx, return_ty(cx, hir_id), sym!(option_type)) {
-            ("Option", &paths::OPTION_SOME)
-        } else if is_type_diagnostic_item(cx, return_ty(cx, hir_id), sym!(result_type)) {
-            ("Result", &paths::RESULT_OK)
-        } else {
-            return;
-        };
-
-        let mut suggs = Vec::new();
-        let can_sugg = find_all_ret_expressions(cx, &body.value, |ret_expr| {
-            if_chain! {
-                if !in_macro(ret_expr.span);
-                if let ExprKind::Call(ref func, ref args) = ret_expr.kind;
-                if let ExprKind::Path(ref qpath) = func.kind;
-                if match_qpath(qpath, path);
-                if args.len() == 1;
-                then {
-                    suggs.push((ret_expr.span, snippet(cx, args[0].span.source_callsite(), "..").to_string()));
-                    true
-                } else {
-                    false
-                }
-            }
-        });
-
-        if can_sugg && !suggs.is_empty() {
-            span_lint_and_then(
-                cx,
-                UNNECESSARY_WRAP,
-                span,
-                format!(
-                    "this function's return value is unnecessarily wrapped by `{}`",
-                    return_type
-                )
-                .as_str(),
-                |diag| {
-                    let inner_ty = return_ty(cx, hir_id)
-                        .walk()
-                        .skip(1) // skip `std::option::Option` or `std::result::Result`
-                        .take(1) // take the first outermost inner type
-                        .filter_map(|inner| match inner.unpack() {
-                            GenericArgKind::Type(inner_ty) => Some(inner_ty.to_string()),
-                            _ => None,
-                        });
-                    inner_ty.for_each(|inner_ty| {
-                        diag.span_suggestion(
-                            fn_decl.output.span(),
-                            format!("remove `{}` from the return type...", return_type).as_str(),
-                            inner_ty,
-                            Applicability::MaybeIncorrect,
-                        );
-                    });
-                    diag.multipart_suggestion(
-                        "...and change the returning expressions",
-                        suggs,
-                        Applicability::MachineApplicable,
-                    );
-                },
-            );
-        }
-    }
-}
diff --git a/clippy_lints/src/unnecessary_wraps.rs b/clippy_lints/src/unnecessary_wraps.rs
new file mode 100644
index 00000000000..25ecc7a82f1
--- /dev/null
+++ b/clippy_lints/src/unnecessary_wraps.rs
@@ -0,0 +1,143 @@
+use crate::utils::{
+    in_macro, is_type_diagnostic_item, match_qpath, paths, return_ty, snippet, span_lint_and_then,
+    visitors::find_all_ret_expressions,
+};
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir::intravisit::FnKind;
+use rustc_hir::{Body, ExprKind, FnDecl, HirId, ItemKind, Node};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::subst::GenericArgKind;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::Span;
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for private functions that only return `Ok` or `Some`.
+    ///
+    /// **Why is this bad?** It is not meaningful to wrap values when no `None` or `Err` is returned.
+    ///
+    /// **Known problems:** Since this lint changes function type signature, you may need to
+    /// adjust some code at callee side.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// fn get_cool_number(a: bool, b: bool) -> Option<i32> {
+    ///     if a && b {
+    ///         return Some(50);
+    ///     }
+    ///     if a {
+    ///         Some(0)
+    ///     } else {
+    ///         Some(10)
+    ///     }
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// fn get_cool_number(a: bool, b: bool) -> i32 {
+    ///     if a && b {
+    ///         return 50;
+    ///     }
+    ///     if a {
+    ///         0
+    ///     } else {
+    ///         10
+    ///     }
+    /// }
+    /// ```
+    pub UNNECESSARY_WRAPS,
+    complexity,
+    "functions that only return `Ok` or `Some`"
+}
+
+declare_lint_pass!(UnnecessaryWraps => [UNNECESSARY_WRAPS]);
+
+impl<'tcx> LateLintPass<'tcx> for UnnecessaryWraps {
+    fn check_fn(
+        &mut self,
+        cx: &LateContext<'tcx>,
+        fn_kind: FnKind<'tcx>,
+        fn_decl: &FnDecl<'tcx>,
+        body: &Body<'tcx>,
+        span: Span,
+        hir_id: HirId,
+    ) {
+        match fn_kind {
+            FnKind::ItemFn(.., visibility, _) | FnKind::Method(.., Some(visibility), _) => {
+                if visibility.node.is_pub() {
+                    return;
+                }
+            },
+            FnKind::Closure(..) => return,
+            _ => (),
+        }
+
+        if let Some(Node::Item(item)) = cx.tcx.hir().find(cx.tcx.hir().get_parent_node(hir_id)) {
+            if matches!(item.kind, ItemKind::Impl{ of_trait: Some(_), ..} | ItemKind::Trait(..)) {
+                return;
+            }
+        }
+
+        let (return_type, path) = if is_type_diagnostic_item(cx, return_ty(cx, hir_id), sym!(option_type)) {
+            ("Option", &paths::OPTION_SOME)
+        } else if is_type_diagnostic_item(cx, return_ty(cx, hir_id), sym!(result_type)) {
+            ("Result", &paths::RESULT_OK)
+        } else {
+            return;
+        };
+
+        let mut suggs = Vec::new();
+        let can_sugg = find_all_ret_expressions(cx, &body.value, |ret_expr| {
+            if_chain! {
+                if !in_macro(ret_expr.span);
+                if let ExprKind::Call(ref func, ref args) = ret_expr.kind;
+                if let ExprKind::Path(ref qpath) = func.kind;
+                if match_qpath(qpath, path);
+                if args.len() == 1;
+                then {
+                    suggs.push((ret_expr.span, snippet(cx, args[0].span.source_callsite(), "..").to_string()));
+                    true
+                } else {
+                    false
+                }
+            }
+        });
+
+        if can_sugg && !suggs.is_empty() {
+            span_lint_and_then(
+                cx,
+                UNNECESSARY_WRAPS,
+                span,
+                format!(
+                    "this function's return value is unnecessarily wrapped by `{}`",
+                    return_type
+                )
+                .as_str(),
+                |diag| {
+                    let inner_ty = return_ty(cx, hir_id)
+                        .walk()
+                        .skip(1) // skip `std::option::Option` or `std::result::Result`
+                        .take(1) // take the first outermost inner type
+                        .filter_map(|inner| match inner.unpack() {
+                            GenericArgKind::Type(inner_ty) => Some(inner_ty.to_string()),
+                            _ => None,
+                        });
+                    inner_ty.for_each(|inner_ty| {
+                        diag.span_suggestion(
+                            fn_decl.output.span(),
+                            format!("remove `{}` from the return type...", return_type).as_str(),
+                            inner_ty,
+                            Applicability::MaybeIncorrect,
+                        );
+                    });
+                    diag.multipart_suggestion(
+                        "...and change the returning expressions",
+                        suggs,
+                        Applicability::MachineApplicable,
+                    );
+                },
+            );
+        }
+    }
+}
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index 4a0cdc5d82f..a2edd6cd0bd 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -2609,11 +2609,11 @@ vec![
         module: "unwrap",
     },
     Lint {
-        name: "unnecessary_wrap",
+        name: "unnecessary_wraps",
         group: "complexity",
         desc: "functions that only return `Ok` or `Some`",
         deprecation: None,
-        module: "unnecessary_wrap",
+        module: "unnecessary_wraps",
     },
     Lint {
         name: "unneeded_field_pattern",
diff --git a/tests/ui/derive_ord_xor_partial_ord.rs b/tests/ui/derive_ord_xor_partial_ord.rs
index 78ec1727fc1..6f12d36d777 100644
--- a/tests/ui/derive_ord_xor_partial_ord.rs
+++ b/tests/ui/derive_ord_xor_partial_ord.rs
@@ -1,5 +1,5 @@
 #![warn(clippy::derive_ord_xor_partial_ord)]
-#![allow(clippy::unnecessary_wrap)]
+#![allow(clippy::unnecessary_wraps)]
 
 use std::cmp::Ordering;
 
diff --git a/tests/ui/doc_errors.rs b/tests/ui/doc_errors.rs
index 77df7f176f0..c77a74a58f2 100644
--- a/tests/ui/doc_errors.rs
+++ b/tests/ui/doc_errors.rs
@@ -1,7 +1,7 @@
 // edition:2018
 #![warn(clippy::missing_errors_doc)]
 #![allow(clippy::result_unit_err)]
-#![allow(clippy::unnecessary_wrap)]
+#![allow(clippy::unnecessary_wraps)]
 
 use std::io;
 
diff --git a/tests/ui/drop_ref.rs b/tests/ui/drop_ref.rs
index ba12e763821..e1a15c609fd 100644
--- a/tests/ui/drop_ref.rs
+++ b/tests/ui/drop_ref.rs
@@ -1,7 +1,7 @@
 #![warn(clippy::drop_ref)]
 #![allow(clippy::toplevel_ref_arg)]
 #![allow(clippy::map_err_ignore)]
-#![allow(clippy::unnecessary_wrap)]
+#![allow(clippy::unnecessary_wraps)]
 
 use std::mem::drop;
 
diff --git a/tests/ui/forget_ref.rs b/tests/ui/forget_ref.rs
index a9c2a92ce6b..c49e6756a6c 100644
--- a/tests/ui/forget_ref.rs
+++ b/tests/ui/forget_ref.rs
@@ -1,6 +1,6 @@
 #![warn(clippy::forget_ref)]
 #![allow(clippy::toplevel_ref_arg)]
-#![allow(clippy::unnecessary_wrap)]
+#![allow(clippy::unnecessary_wraps)]
 
 use std::mem::forget;
 
diff --git a/tests/ui/let_underscore_must_use.rs b/tests/ui/let_underscore_must_use.rs
index e3800cda1b1..a842e872a37 100644
--- a/tests/ui/let_underscore_must_use.rs
+++ b/tests/ui/let_underscore_must_use.rs
@@ -1,5 +1,5 @@
 #![warn(clippy::let_underscore_must_use)]
-#![allow(clippy::unnecessary_wrap)]
+#![allow(clippy::unnecessary_wraps)]
 
 // Debug implementations can fire this lint,
 // so we shouldn't lint external macros
diff --git a/tests/ui/manual_unwrap_or.fixed b/tests/ui/manual_unwrap_or.fixed
index 740b2f66728..81d903c15d3 100644
--- a/tests/ui/manual_unwrap_or.fixed
+++ b/tests/ui/manual_unwrap_or.fixed
@@ -1,6 +1,6 @@
 // run-rustfix
 #![allow(dead_code)]
-#![allow(unused_variables, clippy::unnecessary_wrap)]
+#![allow(unused_variables, clippy::unnecessary_wraps)]
 
 fn option_unwrap_or() {
     // int case
diff --git a/tests/ui/manual_unwrap_or.rs b/tests/ui/manual_unwrap_or.rs
index 6750662c58c..16105d379c3 100644
--- a/tests/ui/manual_unwrap_or.rs
+++ b/tests/ui/manual_unwrap_or.rs
@@ -1,6 +1,6 @@
 // run-rustfix
 #![allow(dead_code)]
-#![allow(unused_variables, clippy::unnecessary_wrap)]
+#![allow(unused_variables, clippy::unnecessary_wraps)]
 
 fn option_unwrap_or() {
     // int case
diff --git a/tests/ui/map_err.rs b/tests/ui/map_err.rs
index 231562507a8..05b9949f102 100644
--- a/tests/ui/map_err.rs
+++ b/tests/ui/map_err.rs
@@ -1,5 +1,5 @@
 #![warn(clippy::map_err_ignore)]
-#![allow(clippy::unnecessary_wrap)]
+#![allow(clippy::unnecessary_wraps)]
 use std::convert::TryFrom;
 use std::error::Error;
 use std::fmt;
diff --git a/tests/ui/map_flatten.fixed b/tests/ui/map_flatten.fixed
index b4a51837b2f..773b5914439 100644
--- a/tests/ui/map_flatten.fixed
+++ b/tests/ui/map_flatten.fixed
@@ -4,7 +4,7 @@
 #![allow(clippy::let_underscore_drop)]
 #![allow(clippy::missing_docs_in_private_items)]
 #![allow(clippy::map_identity)]
-#![allow(clippy::unnecessary_wrap)]
+#![allow(clippy::unnecessary_wraps)]
 
 fn main() {
     // mapping to Option on Iterator
diff --git a/tests/ui/map_flatten.rs b/tests/ui/map_flatten.rs
index e83cc46bda2..578bd877267 100644
--- a/tests/ui/map_flatten.rs
+++ b/tests/ui/map_flatten.rs
@@ -4,7 +4,7 @@
 #![allow(clippy::let_underscore_drop)]
 #![allow(clippy::missing_docs_in_private_items)]
 #![allow(clippy::map_identity)]
-#![allow(clippy::unnecessary_wrap)]
+#![allow(clippy::unnecessary_wraps)]
 
 fn main() {
     // mapping to Option on Iterator
diff --git a/tests/ui/needless_lifetimes.rs b/tests/ui/needless_lifetimes.rs
index e5973bbef8d..44972c8c639 100644
--- a/tests/ui/needless_lifetimes.rs
+++ b/tests/ui/needless_lifetimes.rs
@@ -1,5 +1,5 @@
 #![warn(clippy::needless_lifetimes)]
-#![allow(dead_code, clippy::needless_pass_by_value, clippy::unnecessary_wrap)]
+#![allow(dead_code, clippy::needless_pass_by_value, clippy::unnecessary_wraps)]
 
 fn distinct_lifetimes<'a, 'b>(_x: &'a u8, _y: &'b u8, _z: u8) {}
 
diff --git a/tests/ui/option_map_unit_fn_fixable.fixed b/tests/ui/option_map_unit_fn_fixable.fixed
index de2e9155906..7d29445e66c 100644
--- a/tests/ui/option_map_unit_fn_fixable.fixed
+++ b/tests/ui/option_map_unit_fn_fixable.fixed
@@ -2,7 +2,7 @@
 
 #![warn(clippy::option_map_unit_fn)]
 #![allow(unused)]
-#![allow(clippy::unnecessary_wrap)]
+#![allow(clippy::unnecessary_wraps)]
 
 fn do_nothing<T>(_: T) {}
 
diff --git a/tests/ui/option_map_unit_fn_fixable.rs b/tests/ui/option_map_unit_fn_fixable.rs
index f0887c8a4bc..b6f834f686f 100644
--- a/tests/ui/option_map_unit_fn_fixable.rs
+++ b/tests/ui/option_map_unit_fn_fixable.rs
@@ -2,7 +2,7 @@
 
 #![warn(clippy::option_map_unit_fn)]
 #![allow(unused)]
-#![allow(clippy::unnecessary_wrap)]
+#![allow(clippy::unnecessary_wraps)]
 
 fn do_nothing<T>(_: T) {}
 
diff --git a/tests/ui/option_option.rs b/tests/ui/option_option.rs
index 557d29dff67..6859ba8e5bb 100644
--- a/tests/ui/option_option.rs
+++ b/tests/ui/option_option.rs
@@ -1,5 +1,5 @@
 #![deny(clippy::option_option)]
-#![allow(clippy::unnecessary_wrap)]
+#![allow(clippy::unnecessary_wraps)]
 
 fn input(_: Option<Option<u8>>) {}
 
diff --git a/tests/ui/or_fun_call.fixed b/tests/ui/or_fun_call.fixed
index e1735bc88f5..2a63318c8c7 100644
--- a/tests/ui/or_fun_call.fixed
+++ b/tests/ui/or_fun_call.fixed
@@ -2,7 +2,7 @@
 
 #![warn(clippy::or_fun_call)]
 #![allow(dead_code)]
-#![allow(clippy::unnecessary_wrap)]
+#![allow(clippy::unnecessary_wraps)]
 
 use std::collections::BTreeMap;
 use std::collections::HashMap;
diff --git a/tests/ui/or_fun_call.rs b/tests/ui/or_fun_call.rs
index a6abd2e8b34..026ef437caa 100644
--- a/tests/ui/or_fun_call.rs
+++ b/tests/ui/or_fun_call.rs
@@ -2,7 +2,7 @@
 
 #![warn(clippy::or_fun_call)]
 #![allow(dead_code)]
-#![allow(clippy::unnecessary_wrap)]
+#![allow(clippy::unnecessary_wraps)]
 
 use std::collections::BTreeMap;
 use std::collections::HashMap;
diff --git a/tests/ui/panic_in_result_fn.rs b/tests/ui/panic_in_result_fn.rs
index be4e85d05a7..3d3c19a1be5 100644
--- a/tests/ui/panic_in_result_fn.rs
+++ b/tests/ui/panic_in_result_fn.rs
@@ -1,5 +1,5 @@
 #![warn(clippy::panic_in_result_fn)]
-#![allow(clippy::unnecessary_wrap)]
+#![allow(clippy::unnecessary_wraps)]
 
 struct A;
 
diff --git a/tests/ui/question_mark.fixed b/tests/ui/question_mark.fixed
index df3c98a0aa5..0b5746cb522 100644
--- a/tests/ui/question_mark.fixed
+++ b/tests/ui/question_mark.fixed
@@ -1,6 +1,6 @@
 // run-rustfix
 #![allow(unreachable_code)]
-#![allow(clippy::unnecessary_wrap)]
+#![allow(clippy::unnecessary_wraps)]
 
 fn some_func(a: Option<u32>) -> Option<u32> {
     a?;
diff --git a/tests/ui/question_mark.rs b/tests/ui/question_mark.rs
index 62b3e96b65a..0f0825c9334 100644
--- a/tests/ui/question_mark.rs
+++ b/tests/ui/question_mark.rs
@@ -1,6 +1,6 @@
 // run-rustfix
 #![allow(unreachable_code)]
-#![allow(clippy::unnecessary_wrap)]
+#![allow(clippy::unnecessary_wraps)]
 
 fn some_func(a: Option<u32>) -> Option<u32> {
     if a.is_none() {
diff --git a/tests/ui/redundant_pattern_matching.fixed b/tests/ui/redundant_pattern_matching.fixed
index 2e7ba8bc04d..aa20512296a 100644
--- a/tests/ui/redundant_pattern_matching.fixed
+++ b/tests/ui/redundant_pattern_matching.fixed
@@ -7,7 +7,7 @@
     unused_must_use,
     clippy::needless_bool,
     clippy::match_like_matches_macro,
-    clippy::unnecessary_wrap,
+    clippy::unnecessary_wraps,
     deprecated
 )]
 
diff --git a/tests/ui/redundant_pattern_matching.rs b/tests/ui/redundant_pattern_matching.rs
index ea0e18f5970..d76f9c288ff 100644
--- a/tests/ui/redundant_pattern_matching.rs
+++ b/tests/ui/redundant_pattern_matching.rs
@@ -7,7 +7,7 @@
     unused_must_use,
     clippy::needless_bool,
     clippy::match_like_matches_macro,
-    clippy::unnecessary_wrap,
+    clippy::unnecessary_wraps,
     deprecated
 )]
 
diff --git a/tests/ui/result_unit_error.rs b/tests/ui/result_unit_error.rs
index 1b4a702377e..5e57c752b5a 100644
--- a/tests/ui/result_unit_error.rs
+++ b/tests/ui/result_unit_error.rs
@@ -1,4 +1,4 @@
-#![allow(clippy::unnecessary_wrap)]
+#![allow(clippy::unnecessary_wraps)]
 #[warn(clippy::result_unit_err)]
 #[allow(unused)]
 
diff --git a/tests/ui/try_err.fixed b/tests/ui/try_err.fixed
index 19458ddf68e..652b611208b 100644
--- a/tests/ui/try_err.fixed
+++ b/tests/ui/try_err.fixed
@@ -2,7 +2,7 @@
 // aux-build:macro_rules.rs
 
 #![deny(clippy::try_err)]
-#![allow(clippy::unnecessary_wrap)]
+#![allow(clippy::unnecessary_wraps)]
 
 #[macro_use]
 extern crate macro_rules;
diff --git a/tests/ui/try_err.rs b/tests/ui/try_err.rs
index ab6a32dbe4d..6bd479657b7 100644
--- a/tests/ui/try_err.rs
+++ b/tests/ui/try_err.rs
@@ -2,7 +2,7 @@
 // aux-build:macro_rules.rs
 
 #![deny(clippy::try_err)]
-#![allow(clippy::unnecessary_wrap)]
+#![allow(clippy::unnecessary_wraps)]
 
 #[macro_use]
 extern crate macro_rules;
diff --git a/tests/ui/unit_arg.rs b/tests/ui/unit_arg.rs
index 6bf704c09e0..9ad16d36509 100644
--- a/tests/ui/unit_arg.rs
+++ b/tests/ui/unit_arg.rs
@@ -4,7 +4,7 @@
     unused_must_use,
     unused_variables,
     clippy::unused_unit,
-    clippy::unnecessary_wrap,
+    clippy::unnecessary_wraps,
     clippy::or_fun_call
 )]
 
diff --git a/tests/ui/unnecessary_clone.rs b/tests/ui/unnecessary_clone.rs
index 3b1a6cf57c6..6770a7fac90 100644
--- a/tests/ui/unnecessary_clone.rs
+++ b/tests/ui/unnecessary_clone.rs
@@ -1,7 +1,7 @@
 // does not test any rustfixable lints
 
 #![warn(clippy::clone_on_ref_ptr)]
-#![allow(unused, clippy::redundant_clone, clippy::unnecessary_wrap)]
+#![allow(unused, clippy::redundant_clone, clippy::unnecessary_wraps)]
 
 use std::cell::RefCell;
 use std::rc::{self, Rc};
diff --git a/tests/ui/unnecessary_wrap.rs b/tests/ui/unnecessary_wrap.rs
deleted file mode 100644
index 58178e2e04b..00000000000
--- a/tests/ui/unnecessary_wrap.rs
+++ /dev/null
@@ -1,116 +0,0 @@
-#![warn(clippy::unnecessary_wrap)]
-#![allow(clippy::no_effect)]
-#![allow(clippy::needless_return)]
-#![allow(clippy::if_same_then_else)]
-#![allow(dead_code)]
-
-// should be linted
-fn func1(a: bool, b: bool) -> Option<i32> {
-    if a && b {
-        return Some(42);
-    }
-    if a {
-        Some(-1);
-        Some(2)
-    } else {
-        return Some(1337);
-    }
-}
-
-// should be linted
-fn func2(a: bool, b: bool) -> Option<i32> {
-    if a && b {
-        return Some(10);
-    }
-    if a {
-        Some(20)
-    } else {
-        Some(30)
-    }
-}
-
-// public fns should not be linted
-pub fn func3(a: bool) -> Option<i32> {
-    if a {
-        Some(1)
-    } else {
-        Some(1)
-    }
-}
-
-// should not be linted
-fn func4(a: bool) -> Option<i32> {
-    if a {
-        Some(1)
-    } else {
-        None
-    }
-}
-
-// should be linted
-fn func5() -> Option<i32> {
-    Some(1)
-}
-
-// should not be linted
-fn func6() -> Option<i32> {
-    None
-}
-
-// should be linted
-fn func7() -> Result<i32, ()> {
-    Ok(1)
-}
-
-// should not be linted
-fn func8(a: bool) -> Result<i32, ()> {
-    if a {
-        Ok(1)
-    } else {
-        Err(())
-    }
-}
-
-// should not be linted
-fn func9(a: bool) -> Result<i32, ()> {
-    Err(())
-}
-
-// should not be linted
-fn func10() -> Option<()> {
-    unimplemented!()
-}
-
-struct A;
-
-impl A {
-    // should not be linted
-    pub fn func11() -> Option<i32> {
-        Some(1)
-    }
-
-    // should be linted
-    fn func12() -> Option<i32> {
-        Some(1)
-    }
-}
-
-trait B {
-    // trait impls are not linted
-    fn func13() -> Option<i32> {
-        Some(1)
-    }
-}
-
-impl B for A {
-    // trait impls are not linted
-    fn func13() -> Option<i32> {
-        Some(0)
-    }
-}
-
-fn main() {
-    // method calls are not linted
-    func1(true, true);
-    func2(true, true);
-}
diff --git a/tests/ui/unnecessary_wrap.stderr b/tests/ui/unnecessary_wrap.stderr
deleted file mode 100644
index 5f21b74bc76..00000000000
--- a/tests/ui/unnecessary_wrap.stderr
+++ /dev/null
@@ -1,106 +0,0 @@
-error: this function's return value is unnecessarily wrapped by `Option`
-  --> $DIR/unnecessary_wrap.rs:8:1
-   |
-LL | / fn func1(a: bool, b: bool) -> Option<i32> {
-LL | |     if a && b {
-LL | |         return Some(42);
-LL | |     }
-...  |
-LL | |     }
-LL | | }
-   | |_^
-   |
-   = note: `-D clippy::unnecessary-wrap` implied by `-D warnings`
-help: remove `Option` from the return type...
-   |
-LL | fn func1(a: bool, b: bool) -> i32 {
-   |                               ^^^
-help: ...and change the returning expressions
-   |
-LL |         return 42;
-LL |     }
-LL |     if a {
-LL |         Some(-1);
-LL |         2
-LL |     } else {
- ...
-
-error: this function's return value is unnecessarily wrapped by `Option`
-  --> $DIR/unnecessary_wrap.rs:21:1
-   |
-LL | / fn func2(a: bool, b: bool) -> Option<i32> {
-LL | |     if a && b {
-LL | |         return Some(10);
-LL | |     }
-...  |
-LL | |     }
-LL | | }
-   | |_^
-   |
-help: remove `Option` from the return type...
-   |
-LL | fn func2(a: bool, b: bool) -> i32 {
-   |                               ^^^
-help: ...and change the returning expressions
-   |
-LL |         return 10;
-LL |     }
-LL |     if a {
-LL |         20
-LL |     } else {
-LL |         30
-   |
-
-error: this function's return value is unnecessarily wrapped by `Option`
-  --> $DIR/unnecessary_wrap.rs:51:1
-   |
-LL | / fn func5() -> Option<i32> {
-LL | |     Some(1)
-LL | | }
-   | |_^
-   |
-help: remove `Option` from the return type...
-   |
-LL | fn func5() -> i32 {
-   |               ^^^
-help: ...and change the returning expressions
-   |
-LL |     1
-   |
-
-error: this function's return value is unnecessarily wrapped by `Result`
-  --> $DIR/unnecessary_wrap.rs:61:1
-   |
-LL | / fn func7() -> Result<i32, ()> {
-LL | |     Ok(1)
-LL | | }
-   | |_^
-   |
-help: remove `Result` from the return type...
-   |
-LL | fn func7() -> i32 {
-   |               ^^^
-help: ...and change the returning expressions
-   |
-LL |     1
-   |
-
-error: this function's return value is unnecessarily wrapped by `Option`
-  --> $DIR/unnecessary_wrap.rs:93:5
-   |
-LL | /     fn func12() -> Option<i32> {
-LL | |         Some(1)
-LL | |     }
-   | |_____^
-   |
-help: remove `Option` from the return type...
-   |
-LL |     fn func12() -> i32 {
-   |                    ^^^
-help: ...and change the returning expressions
-   |
-LL |         1
-   |
-
-error: aborting due to 5 previous errors
-
diff --git a/tests/ui/unnecessary_wraps.rs b/tests/ui/unnecessary_wraps.rs
new file mode 100644
index 00000000000..a53dec8f91a
--- /dev/null
+++ b/tests/ui/unnecessary_wraps.rs
@@ -0,0 +1,116 @@
+#![warn(clippy::unnecessary_wraps)]
+#![allow(clippy::no_effect)]
+#![allow(clippy::needless_return)]
+#![allow(clippy::if_same_then_else)]
+#![allow(dead_code)]
+
+// should be linted
+fn func1(a: bool, b: bool) -> Option<i32> {
+    if a && b {
+        return Some(42);
+    }
+    if a {
+        Some(-1);
+        Some(2)
+    } else {
+        return Some(1337);
+    }
+}
+
+// should be linted
+fn func2(a: bool, b: bool) -> Option<i32> {
+    if a && b {
+        return Some(10);
+    }
+    if a {
+        Some(20)
+    } else {
+        Some(30)
+    }
+}
+
+// public fns should not be linted
+pub fn func3(a: bool) -> Option<i32> {
+    if a {
+        Some(1)
+    } else {
+        Some(1)
+    }
+}
+
+// should not be linted
+fn func4(a: bool) -> Option<i32> {
+    if a {
+        Some(1)
+    } else {
+        None
+    }
+}
+
+// should be linted
+fn func5() -> Option<i32> {
+    Some(1)
+}
+
+// should not be linted
+fn func6() -> Option<i32> {
+    None
+}
+
+// should be linted
+fn func7() -> Result<i32, ()> {
+    Ok(1)
+}
+
+// should not be linted
+fn func8(a: bool) -> Result<i32, ()> {
+    if a {
+        Ok(1)
+    } else {
+        Err(())
+    }
+}
+
+// should not be linted
+fn func9(a: bool) -> Result<i32, ()> {
+    Err(())
+}
+
+// should not be linted
+fn func10() -> Option<()> {
+    unimplemented!()
+}
+
+struct A;
+
+impl A {
+    // should not be linted
+    pub fn func11() -> Option<i32> {
+        Some(1)
+    }
+
+    // should be linted
+    fn func12() -> Option<i32> {
+        Some(1)
+    }
+}
+
+trait B {
+    // trait impls are not linted
+    fn func13() -> Option<i32> {
+        Some(1)
+    }
+}
+
+impl B for A {
+    // trait impls are not linted
+    fn func13() -> Option<i32> {
+        Some(0)
+    }
+}
+
+fn main() {
+    // method calls are not linted
+    func1(true, true);
+    func2(true, true);
+}
diff --git a/tests/ui/unnecessary_wraps.stderr b/tests/ui/unnecessary_wraps.stderr
new file mode 100644
index 00000000000..410f054b8ef
--- /dev/null
+++ b/tests/ui/unnecessary_wraps.stderr
@@ -0,0 +1,106 @@
+error: this function's return value is unnecessarily wrapped by `Option`
+  --> $DIR/unnecessary_wraps.rs:8:1
+   |
+LL | / fn func1(a: bool, b: bool) -> Option<i32> {
+LL | |     if a && b {
+LL | |         return Some(42);
+LL | |     }
+...  |
+LL | |     }
+LL | | }
+   | |_^
+   |
+   = note: `-D clippy::unnecessary-wraps` implied by `-D warnings`
+help: remove `Option` from the return type...
+   |
+LL | fn func1(a: bool, b: bool) -> i32 {
+   |                               ^^^
+help: ...and change the returning expressions
+   |
+LL |         return 42;
+LL |     }
+LL |     if a {
+LL |         Some(-1);
+LL |         2
+LL |     } else {
+ ...
+
+error: this function's return value is unnecessarily wrapped by `Option`
+  --> $DIR/unnecessary_wraps.rs:21:1
+   |
+LL | / fn func2(a: bool, b: bool) -> Option<i32> {
+LL | |     if a && b {
+LL | |         return Some(10);
+LL | |     }
+...  |
+LL | |     }
+LL | | }
+   | |_^
+   |
+help: remove `Option` from the return type...
+   |
+LL | fn func2(a: bool, b: bool) -> i32 {
+   |                               ^^^
+help: ...and change the returning expressions
+   |
+LL |         return 10;
+LL |     }
+LL |     if a {
+LL |         20
+LL |     } else {
+LL |         30
+   |
+
+error: this function's return value is unnecessarily wrapped by `Option`
+  --> $DIR/unnecessary_wraps.rs:51:1
+   |
+LL | / fn func5() -> Option<i32> {
+LL | |     Some(1)
+LL | | }
+   | |_^
+   |
+help: remove `Option` from the return type...
+   |
+LL | fn func5() -> i32 {
+   |               ^^^
+help: ...and change the returning expressions
+   |
+LL |     1
+   |
+
+error: this function's return value is unnecessarily wrapped by `Result`
+  --> $DIR/unnecessary_wraps.rs:61:1
+   |
+LL | / fn func7() -> Result<i32, ()> {
+LL | |     Ok(1)
+LL | | }
+   | |_^
+   |
+help: remove `Result` from the return type...
+   |
+LL | fn func7() -> i32 {
+   |               ^^^
+help: ...and change the returning expressions
+   |
+LL |     1
+   |
+
+error: this function's return value is unnecessarily wrapped by `Option`
+  --> $DIR/unnecessary_wraps.rs:93:5
+   |
+LL | /     fn func12() -> Option<i32> {
+LL | |         Some(1)
+LL | |     }
+   | |_____^
+   |
+help: remove `Option` from the return type...
+   |
+LL |     fn func12() -> i32 {
+   |                    ^^^
+help: ...and change the returning expressions
+   |
+LL |         1
+   |
+
+error: aborting due to 5 previous errors
+
diff --git a/tests/ui/useless_conversion.fixed b/tests/ui/useless_conversion.fixed
index 45ee367d649..03977de9455 100644
--- a/tests/ui/useless_conversion.fixed
+++ b/tests/ui/useless_conversion.fixed
@@ -1,7 +1,7 @@
 // run-rustfix
 
 #![deny(clippy::useless_conversion)]
-#![allow(clippy::unnecessary_wrap)]
+#![allow(clippy::unnecessary_wraps)]
 
 fn test_generic<T: Copy>(val: T) -> T {
     let _ = val;
diff --git a/tests/ui/useless_conversion.rs b/tests/ui/useless_conversion.rs
index e5bdffed20d..f6e094c1661 100644
--- a/tests/ui/useless_conversion.rs
+++ b/tests/ui/useless_conversion.rs
@@ -1,7 +1,7 @@
 // run-rustfix
 
 #![deny(clippy::useless_conversion)]
-#![allow(clippy::unnecessary_wrap)]
+#![allow(clippy::unnecessary_wraps)]
 
 fn test_generic<T: Copy>(val: T) -> T {
     let _ = T::from(val);
diff --git a/tests/ui/wildcard_imports.fixed b/tests/ui/wildcard_imports.fixed
index 14007e5f251..ee9c9045fff 100644
--- a/tests/ui/wildcard_imports.fixed
+++ b/tests/ui/wildcard_imports.fixed
@@ -4,7 +4,7 @@
 #![warn(clippy::wildcard_imports)]
 //#![allow(clippy::redundant_pub_crate)]
 #![allow(unused)]
-#![allow(clippy::unnecessary_wrap)]
+#![allow(clippy::unnecessary_wraps)]
 #![warn(unused_imports)]
 
 extern crate wildcard_imports_helper;
diff --git a/tests/ui/wildcard_imports.rs b/tests/ui/wildcard_imports.rs
index 0e8631ca704..efaa8f9ef66 100644
--- a/tests/ui/wildcard_imports.rs
+++ b/tests/ui/wildcard_imports.rs
@@ -4,7 +4,7 @@
 #![warn(clippy::wildcard_imports)]
 //#![allow(clippy::redundant_pub_crate)]
 #![allow(unused)]
-#![allow(clippy::unnecessary_wrap)]
+#![allow(clippy::unnecessary_wraps)]
 #![warn(unused_imports)]
 
 extern crate wildcard_imports_helper;
-- 
cgit 1.4.1-3-g733a5


From bf2d31d0533ee03a2c1e91f74780ea779e8b330c Mon Sep 17 00:00:00 2001
From: flip1995 <philipp.krones@embecosm.com>
Date: Tue, 17 Nov 2020 18:08:12 +0100
Subject: Run cargo dev fmt

---
 clippy_lints/src/mut_key.rs | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/mut_key.rs b/clippy_lints/src/mut_key.rs
index 9cceecc785a..11044e0c2fb 100644
--- a/clippy_lints/src/mut_key.rs
+++ b/clippy_lints/src/mut_key.rs
@@ -89,11 +89,7 @@ fn check_sig<'tcx>(cx: &LateContext<'tcx>, item_hir_id: hir::HirId, decl: &hir::
     for (hir_ty, ty) in decl.inputs.iter().zip(fn_sig.inputs().skip_binder().iter()) {
         check_ty(cx, hir_ty.span, ty);
     }
-    check_ty(
-        cx,
-        decl.output.span(),
-        cx.tcx.erase_late_bound_regions(fn_sig.output()),
-    );
+    check_ty(cx, decl.output.span(), cx.tcx.erase_late_bound_regions(fn_sig.output()));
 }
 
 // We want to lint 1. sets or maps with 2. not immutable key types and 3. no unerased
-- 
cgit 1.4.1-3-g733a5


From 5a8396887714fb75f44eae2a3775b1b2a12f38ae Mon Sep 17 00:00:00 2001
From: Christiaan Dirkx <christiaan@dirkx.email>
Date: Tue, 17 Nov 2020 22:34:39 +0100
Subject: Change `redundant_pattern_matching` to also lint `std::task::Poll`

Suggest using utility methods `is_pending` and `is_ready`.
---
 clippy_lints/src/matches.rs                       |  33 ++++-
 clippy_lints/src/utils/paths.rs                   |   2 +
 tests/ui/redundant_pattern_matching.fixed         | 110 ----------------
 tests/ui/redundant_pattern_matching.rs            | 128 ------------------
 tests/ui/redundant_pattern_matching.stderr        | 154 ----------------------
 tests/ui/redundant_pattern_matching_option.fixed  |   8 +-
 tests/ui/redundant_pattern_matching_option.rs     |   8 +-
 tests/ui/redundant_pattern_matching_option.stderr |  38 +++---
 tests/ui/redundant_pattern_matching_poll.fixed    |  73 ++++++++++
 tests/ui/redundant_pattern_matching_poll.rs       |  88 +++++++++++++
 tests/ui/redundant_pattern_matching_poll.stderr   | 128 ++++++++++++++++++
 tests/ui/redundant_pattern_matching_result.fixed  | 109 +++++++++++++++
 tests/ui/redundant_pattern_matching_result.rs     | 127 ++++++++++++++++++
 tests/ui/redundant_pattern_matching_result.stderr | 154 ++++++++++++++++++++++
 14 files changed, 732 insertions(+), 428 deletions(-)
 delete mode 100644 tests/ui/redundant_pattern_matching.fixed
 delete mode 100644 tests/ui/redundant_pattern_matching.rs
 delete mode 100644 tests/ui/redundant_pattern_matching.stderr
 create mode 100644 tests/ui/redundant_pattern_matching_poll.fixed
 create mode 100644 tests/ui/redundant_pattern_matching_poll.rs
 create mode 100644 tests/ui/redundant_pattern_matching_poll.stderr
 create mode 100644 tests/ui/redundant_pattern_matching_result.fixed
 create mode 100644 tests/ui/redundant_pattern_matching_result.rs
 create mode 100644 tests/ui/redundant_pattern_matching_result.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index c6dca54e250..af59917e801 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -411,8 +411,8 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Lint for redundant pattern matching over `Result` or
-    /// `Option`
+    /// **What it does:** Lint for redundant pattern matching over `Result`, `Option` or
+    /// `std::task::Poll`
     ///
     /// **Why is this bad?** It's more concise and clear to just use the proper
     /// utility function
@@ -422,10 +422,13 @@ declare_clippy_lint! {
     /// **Example:**
     ///
     /// ```rust
+    /// # use std::task::Poll;
     /// if let Ok(_) = Ok::<i32, i32>(42) {}
     /// if let Err(_) = Err::<i32, i32>(42) {}
     /// if let None = None::<()> {}
     /// if let Some(_) = Some(42) {}
+    /// if let Poll::Pending = Poll::Pending::<()> {}
+    /// if let Poll::Ready(_) = Poll::Ready(42) {}
     /// match Ok::<i32, i32>(42) {
     ///     Ok(_) => true,
     ///     Err(_) => false,
@@ -435,10 +438,13 @@ declare_clippy_lint! {
     /// The more idiomatic use would be:
     ///
     /// ```rust
+    /// # use std::task::Poll;
     /// if Ok::<i32, i32>(42).is_ok() {}
     /// if Err::<i32, i32>(42).is_err() {}
     /// if None::<()>.is_none() {}
     /// if Some(42).is_some() {}
+    /// if Poll::Pending::<()>.is_pending() {}
+    /// if Poll::Ready(42).is_ready() {}
     /// Ok::<i32, i32>(42).is_ok();
     /// ```
     pub REDUNDANT_PATTERN_MATCHING,
@@ -1538,6 +1544,8 @@ mod redundant_pattern_match {
                         "is_err()"
                     } else if match_qpath(path, &paths::OPTION_SOME) {
                         "is_some()"
+                    } else if match_qpath(path, &paths::POLL_READY) {
+                        "is_ready()"
                     } else {
                         return;
                     }
@@ -1545,7 +1553,15 @@ mod redundant_pattern_match {
                     return;
                 }
             },
-            PatKind::Path(ref path) if match_qpath(path, &paths::OPTION_NONE) => "is_none()",
+            PatKind::Path(ref path) => {
+                if match_qpath(path, &paths::OPTION_NONE) {
+                    "is_none()"
+                } else if match_qpath(path, &paths::POLL_PENDING) {
+                    "is_pending()"
+                } else {
+                    return;
+                }
+            },
             _ => return,
         };
 
@@ -1628,6 +1644,17 @@ mod redundant_pattern_match {
                             "is_some()",
                             "is_none()",
                         )
+                        .or_else(|| {
+                            find_good_method_for_match(
+                                arms,
+                                path_left,
+                                path_right,
+                                &paths::POLL_READY,
+                                &paths::POLL_PENDING,
+                                "is_ready()",
+                                "is_pending()",
+                            )
+                        })
                     } else {
                         None
                     }
diff --git a/clippy_lints/src/utils/paths.rs b/clippy_lints/src/utils/paths.rs
index 2be5ff93f86..e20f146f145 100644
--- a/clippy_lints/src/utils/paths.rs
+++ b/clippy_lints/src/utils/paths.rs
@@ -86,6 +86,8 @@ pub const PATH_BUF: [&str; 3] = ["std", "path", "PathBuf"];
 pub const PATH_BUF_AS_PATH: [&str; 4] = ["std", "path", "PathBuf", "as_path"];
 pub const PATH_TO_PATH_BUF: [&str; 4] = ["std", "path", "Path", "to_path_buf"];
 pub const POLL: [&str; 4] = ["core", "task", "poll", "Poll"];
+pub const POLL_PENDING: [&str; 5] = ["core", "task", "poll", "Poll", "Pending"];
+pub const POLL_READY: [&str; 5] = ["core", "task", "poll", "Poll", "Ready"];
 pub const PTR_EQ: [&str; 3] = ["core", "ptr", "eq"];
 pub const PTR_NULL: [&str; 3] = ["core", "ptr", "null"];
 pub const PTR_NULL_MUT: [&str; 3] = ["core", "ptr", "null_mut"];
diff --git a/tests/ui/redundant_pattern_matching.fixed b/tests/ui/redundant_pattern_matching.fixed
deleted file mode 100644
index aa20512296a..00000000000
--- a/tests/ui/redundant_pattern_matching.fixed
+++ /dev/null
@@ -1,110 +0,0 @@
-// 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,
-    clippy::unnecessary_wraps,
-    deprecated
-)]
-
-fn main() {
-    let result: Result<usize, usize> = Err(5);
-    if result.is_ok() {}
-
-    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() {}
-
-    if Ok::<i32, i32>(42).is_ok() {}
-
-    if Err::<i32, i32>(42).is_err() {}
-
-    if let Ok(x) = Ok::<i32, i32>(42) {
-        println!("{}", x);
-    }
-
-    Ok::<i32, i32>(42).is_ok();
-
-    Ok::<i32, i32>(42).is_err();
-
-    Err::<i32, i32>(42).is_err();
-
-    Err::<i32, i32>(42).is_ok();
-
-    let _ = if Ok::<usize, ()>(4).is_ok() { true } else { false };
-
-    issue5504();
-    issue6067();
-    issue6065();
-
-    let _ = if gen_res().is_ok() {
-        1
-    } else if gen_res().is_err() {
-        2
-    } else {
-        3
-    };
-}
-
-fn gen_res() -> Result<(), ()> {
-    Ok(())
-}
-
-macro_rules! m {
-    () => {
-        Some(42u32)
-    };
-}
-
-fn issue5504() {
-    fn result_opt() -> Result<Option<i32>, i32> {
-        Err(42)
-    }
-
-    fn try_result_opt() -> Result<i32, i32> {
-        while r#try!(result_opt()).is_some() {}
-        if r#try!(result_opt()).is_some() {}
-        Ok(42)
-    }
-
-    try_result_opt();
-
-    if m!().is_some() {}
-    while m!().is_some() {}
-}
-
-fn issue6065() {
-    macro_rules! if_let_in_macro {
-        ($pat:pat, $x:expr) => {
-            if let Some($pat) = $x {}
-        };
-    }
-
-    // shouldn't be linted
-    if_let_in_macro!(_, Some(42));
-}
-
-// 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_ok` and `is_err` of `Result` were stabilized as const,
-// so the following should be linted.
-const fn issue6067() {
-    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();
-}
diff --git a/tests/ui/redundant_pattern_matching.rs b/tests/ui/redundant_pattern_matching.rs
deleted file mode 100644
index d76f9c288ff..00000000000
--- a/tests/ui/redundant_pattern_matching.rs
+++ /dev/null
@@ -1,128 +0,0 @@
-// 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,
-    clippy::unnecessary_wraps,
-    deprecated
-)]
-
-fn main() {
-    let result: Result<usize, usize> = Err(5);
-    if let Ok(_) = &result {}
-
-    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) {}
-
-    if Ok::<i32, i32>(42).is_ok() {}
-
-    if Err::<i32, i32>(42).is_err() {}
-
-    if let Ok(x) = Ok::<i32, i32>(42) {
-        println!("{}", x);
-    }
-
-    match Ok::<i32, i32>(42) {
-        Ok(_) => true,
-        Err(_) => false,
-    };
-
-    match Ok::<i32, i32>(42) {
-        Ok(_) => false,
-        Err(_) => true,
-    };
-
-    match Err::<i32, i32>(42) {
-        Ok(_) => false,
-        Err(_) => true,
-    };
-
-    match Err::<i32, i32>(42) {
-        Ok(_) => true,
-        Err(_) => false,
-    };
-
-    let _ = if let Ok(_) = Ok::<usize, ()>(4) { true } else { false };
-
-    issue5504();
-    issue6067();
-    issue6065();
-
-    let _ = if let Ok(_) = gen_res() {
-        1
-    } else if let Err(_) = gen_res() {
-        2
-    } else {
-        3
-    };
-}
-
-fn gen_res() -> Result<(), ()> {
-    Ok(())
-}
-
-macro_rules! m {
-    () => {
-        Some(42u32)
-    };
-}
-
-fn issue5504() {
-    fn result_opt() -> Result<Option<i32>, i32> {
-        Err(42)
-    }
-
-    fn try_result_opt() -> Result<i32, i32> {
-        while let Some(_) = r#try!(result_opt()) {}
-        if let Some(_) = r#try!(result_opt()) {}
-        Ok(42)
-    }
-
-    try_result_opt();
-
-    if let Some(_) = m!() {}
-    while let Some(_) = m!() {}
-}
-
-fn issue6065() {
-    macro_rules! if_let_in_macro {
-        ($pat:pat, $x:expr) => {
-            if let Some($pat) = $x {}
-        };
-    }
-
-    // shouldn't be linted
-    if_let_in_macro!(_, Some(42));
-}
-
-// 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_ok` and `is_err` of `Result` were stabilized as const,
-// so the following should be linted.
-const fn issue6067() {
-    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,
-    };
-}
diff --git a/tests/ui/redundant_pattern_matching.stderr b/tests/ui/redundant_pattern_matching.stderr
deleted file mode 100644
index aeb309f5ba1..00000000000
--- a/tests/ui/redundant_pattern_matching.stderr
+++ /dev/null
@@ -1,154 +0,0 @@
-error: redundant pattern matching, consider using `is_ok()`
-  --> $DIR/redundant_pattern_matching.rs:16:12
-   |
-LL |     if let Ok(_) = &result {}
-   |     -------^^^^^---------- help: try this: `if result.is_ok()`
-   |
-   = note: `-D clippy::redundant-pattern-matching` implied by `-D warnings`
-
-error: redundant pattern matching, consider using `is_ok()`
-  --> $DIR/redundant_pattern_matching.rs:18: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:20: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:22: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:24: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:34: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:39:5
-   |
-LL | /     match Ok::<i32, i32>(42) {
-LL | |         Ok(_) => false,
-LL | |         Err(_) => true,
-LL | |     };
-   | |_____^ help: try this: `Ok::<i32, i32>(42).is_err()`
-
-error: redundant pattern matching, consider using `is_err()`
-  --> $DIR/redundant_pattern_matching.rs:44:5
-   |
-LL | /     match Err::<i32, i32>(42) {
-LL | |         Ok(_) => false,
-LL | |         Err(_) => true,
-LL | |     };
-   | |_____^ help: try this: `Err::<i32, i32>(42).is_err()`
-
-error: redundant pattern matching, consider using `is_ok()`
-  --> $DIR/redundant_pattern_matching.rs:49:5
-   |
-LL | /     match Err::<i32, i32>(42) {
-LL | |         Ok(_) => true,
-LL | |         Err(_) => false,
-LL | |     };
-   | |_____^ help: try this: `Err::<i32, i32>(42).is_ok()`
-
-error: redundant pattern matching, consider using `is_ok()`
-  --> $DIR/redundant_pattern_matching.rs:54: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_ok()`
-  --> $DIR/redundant_pattern_matching.rs:60:20
-   |
-LL |     let _ = if let Ok(_) = gen_res() {
-   |             -------^^^^^------------ help: try this: `if gen_res().is_ok()`
-
-error: redundant pattern matching, consider using `is_err()`
-  --> $DIR/redundant_pattern_matching.rs:62: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:85: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:86: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:92: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:93:15
-   |
-LL |     while let Some(_) = m!() {}
-   |     ----------^^^^^^^------- help: try this: `while m!().is_some()`
-
-error: redundant pattern matching, consider using `is_ok()`
-  --> $DIR/redundant_pattern_matching.rs:111: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:113: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:115: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:117: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:119: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:124: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
-
diff --git a/tests/ui/redundant_pattern_matching_option.fixed b/tests/ui/redundant_pattern_matching_option.fixed
index 499b975b2bb..bc369dd2491 100644
--- a/tests/ui/redundant_pattern_matching_option.fixed
+++ b/tests/ui/redundant_pattern_matching_option.fixed
@@ -2,13 +2,7 @@
 
 #![warn(clippy::all)]
 #![warn(clippy::redundant_pattern_matching)]
-#![allow(
-    clippy::unit_arg,
-    unused_must_use,
-    clippy::needless_bool,
-    clippy::match_like_matches_macro,
-    deprecated
-)]
+#![allow(unused_must_use, clippy::needless_bool, clippy::match_like_matches_macro)]
 
 fn main() {
     if None::<()>.is_none() {}
diff --git a/tests/ui/redundant_pattern_matching_option.rs b/tests/ui/redundant_pattern_matching_option.rs
index 2a98435e790..d7616a72913 100644
--- a/tests/ui/redundant_pattern_matching_option.rs
+++ b/tests/ui/redundant_pattern_matching_option.rs
@@ -2,13 +2,7 @@
 
 #![warn(clippy::all)]
 #![warn(clippy::redundant_pattern_matching)]
-#![allow(
-    clippy::unit_arg,
-    unused_must_use,
-    clippy::needless_bool,
-    clippy::match_like_matches_macro,
-    deprecated
-)]
+#![allow(unused_must_use, clippy::needless_bool, clippy::match_like_matches_macro)]
 
 fn main() {
     if let None = None::<()> {}
diff --git a/tests/ui/redundant_pattern_matching_option.stderr b/tests/ui/redundant_pattern_matching_option.stderr
index eebb3448491..7ddfbe503a2 100644
--- a/tests/ui/redundant_pattern_matching_option.stderr
+++ b/tests/ui/redundant_pattern_matching_option.stderr
@@ -1,5 +1,5 @@
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:14:12
+  --> $DIR/redundant_pattern_matching_option.rs:8:12
    |
 LL |     if let None = None::<()> {}
    |     -------^^^^------------- help: try this: `if None::<()>.is_none()`
@@ -7,43 +7,43 @@ LL |     if let None = 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
+  --> $DIR/redundant_pattern_matching_option.rs:10: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
+  --> $DIR/redundant_pattern_matching_option.rs:12: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
+  --> $DIR/redundant_pattern_matching_option.rs:18: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
+  --> $DIR/redundant_pattern_matching_option.rs:20: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
+  --> $DIR/redundant_pattern_matching_option.rs:22: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
+  --> $DIR/redundant_pattern_matching_option.rs:25: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
+  --> $DIR/redundant_pattern_matching_option.rs:33:5
    |
 LL | /     match Some(42) {
 LL | |         Some(_) => true,
@@ -52,7 +52,7 @@ LL | |     };
    | |_____^ help: try this: `Some(42).is_some()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:44:5
+  --> $DIR/redundant_pattern_matching_option.rs:38:5
    |
 LL | /     match None::<()> {
 LL | |         Some(_) => false,
@@ -61,7 +61,7 @@ LL | |     };
    | |_____^ help: try this: `None::<()>.is_none()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:49:13
+  --> $DIR/redundant_pattern_matching_option.rs:43:13
    |
 LL |       let _ = match None::<()> {
    |  _____________^
@@ -71,49 +71,49 @@ LL | |     };
    | |_____^ help: try this: `None::<()>.is_none()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/redundant_pattern_matching_option.rs:55:20
+  --> $DIR/redundant_pattern_matching_option.rs:49: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
+  --> $DIR/redundant_pattern_matching_option.rs:54: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
+  --> $DIR/redundant_pattern_matching_option.rs:56: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
+  --> $DIR/redundant_pattern_matching_option.rs:77: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
+  --> $DIR/redundant_pattern_matching_option.rs:79: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
+  --> $DIR/redundant_pattern_matching_option.rs:81: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
+  --> $DIR/redundant_pattern_matching_option.rs:83: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
+  --> $DIR/redundant_pattern_matching_option.rs:85:5
    |
 LL | /     match Some(42) {
 LL | |         Some(_) => true,
@@ -122,7 +122,7 @@ LL | |     };
    | |_____^ help: try this: `Some(42).is_some()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:96:5
+  --> $DIR/redundant_pattern_matching_option.rs:90:5
    |
 LL | /     match None::<()> {
 LL | |         Some(_) => false,
diff --git a/tests/ui/redundant_pattern_matching_poll.fixed b/tests/ui/redundant_pattern_matching_poll.fixed
new file mode 100644
index 00000000000..564c427f063
--- /dev/null
+++ b/tests/ui/redundant_pattern_matching_poll.fixed
@@ -0,0 +1,73 @@
+// run-rustfix
+
+#![warn(clippy::all)]
+#![warn(clippy::redundant_pattern_matching)]
+#![allow(unused_must_use, clippy::needless_bool, clippy::match_like_matches_macro)]
+
+use std::task::Poll::{self, Pending, Ready};
+
+fn main() {
+    if Pending::<()>.is_pending() {}
+
+    if Ready(42).is_ready() {}
+
+    if Ready(42).is_ready() {
+        foo();
+    } else {
+        bar();
+    }
+
+    while Ready(42).is_ready() {}
+
+    while Ready(42).is_pending() {}
+
+    while Pending::<()>.is_pending() {}
+
+    if Pending::<i32>.is_pending() {}
+
+    if Ready(42).is_ready() {}
+
+    Ready(42).is_ready();
+
+    Pending::<()>.is_pending();
+
+    let _ = Pending::<()>.is_pending();
+
+    let poll = Ready(false);
+    let x = if poll.is_ready() { true } else { false };
+    takes_poll(x);
+
+    poll_const();
+
+    let _ = if gen_poll().is_ready() {
+        1
+    } else if gen_poll().is_pending() {
+        2
+    } else {
+        3
+    };
+}
+
+fn gen_poll() -> Poll<()> {
+    Pending
+}
+
+fn takes_poll(_: bool) {}
+
+fn foo() {}
+
+fn bar() {}
+
+const fn poll_const() {
+    if Ready(42).is_ready() {}
+
+    if Pending::<()>.is_pending() {}
+
+    while Ready(42).is_ready() {}
+
+    while Pending::<()>.is_pending() {}
+
+    Ready(42).is_ready();
+
+    Pending::<()>.is_pending();
+}
diff --git a/tests/ui/redundant_pattern_matching_poll.rs b/tests/ui/redundant_pattern_matching_poll.rs
new file mode 100644
index 00000000000..d453d4184af
--- /dev/null
+++ b/tests/ui/redundant_pattern_matching_poll.rs
@@ -0,0 +1,88 @@
+// run-rustfix
+
+#![warn(clippy::all)]
+#![warn(clippy::redundant_pattern_matching)]
+#![allow(unused_must_use, clippy::needless_bool, clippy::match_like_matches_macro)]
+
+use std::task::Poll::{self, Pending, Ready};
+
+fn main() {
+    if let Pending = Pending::<()> {}
+
+    if let Ready(_) = Ready(42) {}
+
+    if let Ready(_) = Ready(42) {
+        foo();
+    } else {
+        bar();
+    }
+
+    while let Ready(_) = Ready(42) {}
+
+    while let Pending = Ready(42) {}
+
+    while let Pending = Pending::<()> {}
+
+    if Pending::<i32>.is_pending() {}
+
+    if Ready(42).is_ready() {}
+
+    match Ready(42) {
+        Ready(_) => true,
+        Pending => false,
+    };
+
+    match Pending::<()> {
+        Ready(_) => false,
+        Pending => true,
+    };
+
+    let _ = match Pending::<()> {
+        Ready(_) => false,
+        Pending => true,
+    };
+
+    let poll = Ready(false);
+    let x = if let Ready(_) = poll { true } else { false };
+    takes_poll(x);
+
+    poll_const();
+
+    let _ = if let Ready(_) = gen_poll() {
+        1
+    } else if let Pending = gen_poll() {
+        2
+    } else {
+        3
+    };
+}
+
+fn gen_poll() -> Poll<()> {
+    Pending
+}
+
+fn takes_poll(_: bool) {}
+
+fn foo() {}
+
+fn bar() {}
+
+const fn poll_const() {
+    if let Ready(_) = Ready(42) {}
+
+    if let Pending = Pending::<()> {}
+
+    while let Ready(_) = Ready(42) {}
+
+    while let Pending = Pending::<()> {}
+
+    match Ready(42) {
+        Ready(_) => true,
+        Pending => false,
+    };
+
+    match Pending::<()> {
+        Ready(_) => false,
+        Pending => true,
+    };
+}
diff --git a/tests/ui/redundant_pattern_matching_poll.stderr b/tests/ui/redundant_pattern_matching_poll.stderr
new file mode 100644
index 00000000000..42e5d6f41fe
--- /dev/null
+++ b/tests/ui/redundant_pattern_matching_poll.stderr
@@ -0,0 +1,128 @@
+error: redundant pattern matching, consider using `is_pending()`
+  --> $DIR/redundant_pattern_matching_poll.rs:10:12
+   |
+LL |     if let Pending = Pending::<()> {}
+   |     -------^^^^^^^---------------- help: try this: `if Pending::<()>.is_pending()`
+   |
+   = note: `-D clippy::redundant-pattern-matching` implied by `-D warnings`
+
+error: redundant pattern matching, consider using `is_ready()`
+  --> $DIR/redundant_pattern_matching_poll.rs:12:12
+   |
+LL |     if let Ready(_) = Ready(42) {}
+   |     -------^^^^^^^^------------ help: try this: `if Ready(42).is_ready()`
+
+error: redundant pattern matching, consider using `is_ready()`
+  --> $DIR/redundant_pattern_matching_poll.rs:14:12
+   |
+LL |     if let Ready(_) = Ready(42) {
+   |     -------^^^^^^^^------------ help: try this: `if Ready(42).is_ready()`
+
+error: redundant pattern matching, consider using `is_ready()`
+  --> $DIR/redundant_pattern_matching_poll.rs:20:15
+   |
+LL |     while let Ready(_) = Ready(42) {}
+   |     ----------^^^^^^^^------------ help: try this: `while Ready(42).is_ready()`
+
+error: redundant pattern matching, consider using `is_pending()`
+  --> $DIR/redundant_pattern_matching_poll.rs:22:15
+   |
+LL |     while let Pending = Ready(42) {}
+   |     ----------^^^^^^^------------ help: try this: `while Ready(42).is_pending()`
+
+error: redundant pattern matching, consider using `is_pending()`
+  --> $DIR/redundant_pattern_matching_poll.rs:24:15
+   |
+LL |     while let Pending = Pending::<()> {}
+   |     ----------^^^^^^^---------------- help: try this: `while Pending::<()>.is_pending()`
+
+error: redundant pattern matching, consider using `is_ready()`
+  --> $DIR/redundant_pattern_matching_poll.rs:30:5
+   |
+LL | /     match Ready(42) {
+LL | |         Ready(_) => true,
+LL | |         Pending => false,
+LL | |     };
+   | |_____^ help: try this: `Ready(42).is_ready()`
+
+error: redundant pattern matching, consider using `is_pending()`
+  --> $DIR/redundant_pattern_matching_poll.rs:35:5
+   |
+LL | /     match Pending::<()> {
+LL | |         Ready(_) => false,
+LL | |         Pending => true,
+LL | |     };
+   | |_____^ help: try this: `Pending::<()>.is_pending()`
+
+error: redundant pattern matching, consider using `is_pending()`
+  --> $DIR/redundant_pattern_matching_poll.rs:40:13
+   |
+LL |       let _ = match Pending::<()> {
+   |  _____________^
+LL | |         Ready(_) => false,
+LL | |         Pending => true,
+LL | |     };
+   | |_____^ help: try this: `Pending::<()>.is_pending()`
+
+error: redundant pattern matching, consider using `is_ready()`
+  --> $DIR/redundant_pattern_matching_poll.rs:46:20
+   |
+LL |     let x = if let Ready(_) = poll { true } else { false };
+   |             -------^^^^^^^^------- help: try this: `if poll.is_ready()`
+
+error: redundant pattern matching, consider using `is_ready()`
+  --> $DIR/redundant_pattern_matching_poll.rs:51:20
+   |
+LL |     let _ = if let Ready(_) = gen_poll() {
+   |             -------^^^^^^^^------------- help: try this: `if gen_poll().is_ready()`
+
+error: redundant pattern matching, consider using `is_pending()`
+  --> $DIR/redundant_pattern_matching_poll.rs:53:19
+   |
+LL |     } else if let Pending = gen_poll() {
+   |            -------^^^^^^^------------- help: try this: `if gen_poll().is_pending()`
+
+error: redundant pattern matching, consider using `is_ready()`
+  --> $DIR/redundant_pattern_matching_poll.rs:71:12
+   |
+LL |     if let Ready(_) = Ready(42) {}
+   |     -------^^^^^^^^------------ help: try this: `if Ready(42).is_ready()`
+
+error: redundant pattern matching, consider using `is_pending()`
+  --> $DIR/redundant_pattern_matching_poll.rs:73:12
+   |
+LL |     if let Pending = Pending::<()> {}
+   |     -------^^^^^^^---------------- help: try this: `if Pending::<()>.is_pending()`
+
+error: redundant pattern matching, consider using `is_ready()`
+  --> $DIR/redundant_pattern_matching_poll.rs:75:15
+   |
+LL |     while let Ready(_) = Ready(42) {}
+   |     ----------^^^^^^^^------------ help: try this: `while Ready(42).is_ready()`
+
+error: redundant pattern matching, consider using `is_pending()`
+  --> $DIR/redundant_pattern_matching_poll.rs:77:15
+   |
+LL |     while let Pending = Pending::<()> {}
+   |     ----------^^^^^^^---------------- help: try this: `while Pending::<()>.is_pending()`
+
+error: redundant pattern matching, consider using `is_ready()`
+  --> $DIR/redundant_pattern_matching_poll.rs:79:5
+   |
+LL | /     match Ready(42) {
+LL | |         Ready(_) => true,
+LL | |         Pending => false,
+LL | |     };
+   | |_____^ help: try this: `Ready(42).is_ready()`
+
+error: redundant pattern matching, consider using `is_pending()`
+  --> $DIR/redundant_pattern_matching_poll.rs:84:5
+   |
+LL | /     match Pending::<()> {
+LL | |         Ready(_) => false,
+LL | |         Pending => true,
+LL | |     };
+   | |_____^ help: try this: `Pending::<()>.is_pending()`
+
+error: aborting due to 18 previous errors
+
diff --git a/tests/ui/redundant_pattern_matching_result.fixed b/tests/ui/redundant_pattern_matching_result.fixed
new file mode 100644
index 00000000000..e94c5704b48
--- /dev/null
+++ b/tests/ui/redundant_pattern_matching_result.fixed
@@ -0,0 +1,109 @@
+// run-rustfix
+
+#![warn(clippy::all)]
+#![warn(clippy::redundant_pattern_matching)]
+#![allow(
+    unused_must_use,
+    clippy::needless_bool,
+    clippy::match_like_matches_macro,
+    clippy::unnecessary_wraps,
+    deprecated
+)]
+
+fn main() {
+    let result: Result<usize, usize> = Err(5);
+    if result.is_ok() {}
+
+    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() {}
+
+    if Ok::<i32, i32>(42).is_ok() {}
+
+    if Err::<i32, i32>(42).is_err() {}
+
+    if let Ok(x) = Ok::<i32, i32>(42) {
+        println!("{}", x);
+    }
+
+    Ok::<i32, i32>(42).is_ok();
+
+    Ok::<i32, i32>(42).is_err();
+
+    Err::<i32, i32>(42).is_err();
+
+    Err::<i32, i32>(42).is_ok();
+
+    let _ = if Ok::<usize, ()>(4).is_ok() { true } else { false };
+
+    issue5504();
+    issue6067();
+    issue6065();
+
+    let _ = if gen_res().is_ok() {
+        1
+    } else if gen_res().is_err() {
+        2
+    } else {
+        3
+    };
+}
+
+fn gen_res() -> Result<(), ()> {
+    Ok(())
+}
+
+macro_rules! m {
+    () => {
+        Some(42u32)
+    };
+}
+
+fn issue5504() {
+    fn result_opt() -> Result<Option<i32>, i32> {
+        Err(42)
+    }
+
+    fn try_result_opt() -> Result<i32, i32> {
+        while r#try!(result_opt()).is_some() {}
+        if r#try!(result_opt()).is_some() {}
+        Ok(42)
+    }
+
+    try_result_opt();
+
+    if m!().is_some() {}
+    while m!().is_some() {}
+}
+
+fn issue6065() {
+    macro_rules! if_let_in_macro {
+        ($pat:pat, $x:expr) => {
+            if let Some($pat) = $x {}
+        };
+    }
+
+    // shouldn't be linted
+    if_let_in_macro!(_, Some(42));
+}
+
+// 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_ok` and `is_err` of `Result` were stabilized as const,
+// so the following should be linted.
+const fn issue6067() {
+    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();
+}
diff --git a/tests/ui/redundant_pattern_matching_result.rs b/tests/ui/redundant_pattern_matching_result.rs
new file mode 100644
index 00000000000..5d175294232
--- /dev/null
+++ b/tests/ui/redundant_pattern_matching_result.rs
@@ -0,0 +1,127 @@
+// run-rustfix
+
+#![warn(clippy::all)]
+#![warn(clippy::redundant_pattern_matching)]
+#![allow(
+    unused_must_use,
+    clippy::needless_bool,
+    clippy::match_like_matches_macro,
+    clippy::unnecessary_wraps,
+    deprecated
+)]
+
+fn main() {
+    let result: Result<usize, usize> = Err(5);
+    if let Ok(_) = &result {}
+
+    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) {}
+
+    if Ok::<i32, i32>(42).is_ok() {}
+
+    if Err::<i32, i32>(42).is_err() {}
+
+    if let Ok(x) = Ok::<i32, i32>(42) {
+        println!("{}", x);
+    }
+
+    match Ok::<i32, i32>(42) {
+        Ok(_) => true,
+        Err(_) => false,
+    };
+
+    match Ok::<i32, i32>(42) {
+        Ok(_) => false,
+        Err(_) => true,
+    };
+
+    match Err::<i32, i32>(42) {
+        Ok(_) => false,
+        Err(_) => true,
+    };
+
+    match Err::<i32, i32>(42) {
+        Ok(_) => true,
+        Err(_) => false,
+    };
+
+    let _ = if let Ok(_) = Ok::<usize, ()>(4) { true } else { false };
+
+    issue5504();
+    issue6067();
+    issue6065();
+
+    let _ = if let Ok(_) = gen_res() {
+        1
+    } else if let Err(_) = gen_res() {
+        2
+    } else {
+        3
+    };
+}
+
+fn gen_res() -> Result<(), ()> {
+    Ok(())
+}
+
+macro_rules! m {
+    () => {
+        Some(42u32)
+    };
+}
+
+fn issue5504() {
+    fn result_opt() -> Result<Option<i32>, i32> {
+        Err(42)
+    }
+
+    fn try_result_opt() -> Result<i32, i32> {
+        while let Some(_) = r#try!(result_opt()) {}
+        if let Some(_) = r#try!(result_opt()) {}
+        Ok(42)
+    }
+
+    try_result_opt();
+
+    if let Some(_) = m!() {}
+    while let Some(_) = m!() {}
+}
+
+fn issue6065() {
+    macro_rules! if_let_in_macro {
+        ($pat:pat, $x:expr) => {
+            if let Some($pat) = $x {}
+        };
+    }
+
+    // shouldn't be linted
+    if_let_in_macro!(_, Some(42));
+}
+
+// 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_ok` and `is_err` of `Result` were stabilized as const,
+// so the following should be linted.
+const fn issue6067() {
+    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,
+    };
+}
diff --git a/tests/ui/redundant_pattern_matching_result.stderr b/tests/ui/redundant_pattern_matching_result.stderr
new file mode 100644
index 00000000000..d6a46babb77
--- /dev/null
+++ b/tests/ui/redundant_pattern_matching_result.stderr
@@ -0,0 +1,154 @@
+error: redundant pattern matching, consider using `is_ok()`
+  --> $DIR/redundant_pattern_matching_result.rs:15:12
+   |
+LL |     if let Ok(_) = &result {}
+   |     -------^^^^^---------- help: try this: `if result.is_ok()`
+   |
+   = note: `-D clippy::redundant-pattern-matching` implied by `-D warnings`
+
+error: redundant pattern matching, consider using `is_ok()`
+  --> $DIR/redundant_pattern_matching_result.rs:17: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_result.rs:19: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_result.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_result.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_ok()`
+  --> $DIR/redundant_pattern_matching_result.rs:33: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_result.rs:38:5
+   |
+LL | /     match Ok::<i32, i32>(42) {
+LL | |         Ok(_) => false,
+LL | |         Err(_) => true,
+LL | |     };
+   | |_____^ help: try this: `Ok::<i32, i32>(42).is_err()`
+
+error: redundant pattern matching, consider using `is_err()`
+  --> $DIR/redundant_pattern_matching_result.rs:43:5
+   |
+LL | /     match Err::<i32, i32>(42) {
+LL | |         Ok(_) => false,
+LL | |         Err(_) => true,
+LL | |     };
+   | |_____^ help: try this: `Err::<i32, i32>(42).is_err()`
+
+error: redundant pattern matching, consider using `is_ok()`
+  --> $DIR/redundant_pattern_matching_result.rs:48:5
+   |
+LL | /     match Err::<i32, i32>(42) {
+LL | |         Ok(_) => true,
+LL | |         Err(_) => false,
+LL | |     };
+   | |_____^ help: try this: `Err::<i32, i32>(42).is_ok()`
+
+error: redundant pattern matching, consider using `is_ok()`
+  --> $DIR/redundant_pattern_matching_result.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_ok()`
+  --> $DIR/redundant_pattern_matching_result.rs:59:20
+   |
+LL |     let _ = if let Ok(_) = gen_res() {
+   |             -------^^^^^------------ help: try this: `if gen_res().is_ok()`
+
+error: redundant pattern matching, consider using `is_err()`
+  --> $DIR/redundant_pattern_matching_result.rs:61: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_result.rs:84: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_result.rs:85: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_result.rs:91: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_result.rs:92:15
+   |
+LL |     while let Some(_) = m!() {}
+   |     ----------^^^^^^^------- help: try this: `while m!().is_some()`
+
+error: redundant pattern matching, consider using `is_ok()`
+  --> $DIR/redundant_pattern_matching_result.rs:110: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_result.rs:112: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_result.rs:114: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_result.rs:116: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_result.rs:118: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_result.rs:123: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
+
-- 
cgit 1.4.1-3-g733a5


From 0502ac2a87458620ae83e5260fd13149a558e090 Mon Sep 17 00:00:00 2001
From: Takayuki Nakata <f.seasons017@gmail.com>
Date: Wed, 18 Nov 2020 08:33:25 +0900
Subject: Improve doc about `map_clone`

---
 clippy_lints/src/map_clone.rs | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/map_clone.rs b/clippy_lints/src/map_clone.rs
index 3f34dd5112e..220240acb7a 100644
--- a/clippy_lints/src/map_clone.rs
+++ b/clippy_lints/src/map_clone.rs
@@ -14,8 +14,9 @@ use rustc_span::symbol::Ident;
 use rustc_span::{sym, Span};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for usage of `iterator.map(|x| x.clone())` and suggests
-    /// `iterator.cloned()` instead
+    /// **What it does:** Checks for usage of `map(|x| x.clone())` or
+    /// dereferencing closures for `Copy` types, on `Iterator` or `Option`,
+    /// and suggests `cloned()` or `copied()` instead
     ///
     /// **Why is this bad?** Readability, this can be written more concisely
     ///
-- 
cgit 1.4.1-3-g733a5


From dd4e471b3fb701312c2a3fabfba0011f239d4760 Mon Sep 17 00:00:00 2001
From: flip1995 <philipp.krones@embecosm.com>
Date: Fri, 20 Nov 2020 09:37:47 +0100
Subject: Properly deprecate panic_params lint

---
 clippy_lints/src/deprecated_lints.rs | 5 +++++
 clippy_lints/src/lib.rs              | 4 ++++
 src/lintlist/mod.rs                  | 7 -------
 tests/ui/deprecated.rs               | 1 +
 tests/ui/deprecated.stderr           | 8 +++++++-
 5 files changed, 17 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/deprecated_lints.rs b/clippy_lints/src/deprecated_lints.rs
index 461c6e31d3e..1c3285ed701 100644
--- a/clippy_lints/src/deprecated_lints.rs
+++ b/clippy_lints/src/deprecated_lints.rs
@@ -181,3 +181,8 @@ declare_deprecated_lint! {
     pub TEMPORARY_CSTRING_AS_PTR,
     "this lint has been uplifted to rustc and is now called `temporary_cstring_as_ptr`"
 }
+
+declare_deprecated_lint! {
+    pub PANIC_PARAMS,
+    "this lint has been uplifted to rustc and is now called `panic_fmt`"
+}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 19bf67d80c4..ff5d4846995 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -495,6 +495,10 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         "clippy::temporary_cstring_as_ptr",
         "this lint has been uplifted to rustc and is now called `temporary_cstring_as_ptr`",
     );
+    store.register_removed(
+        "clippy::panic_params",
+        "this lint has been uplifted to rustc and is now called `panic_fmt`",
+    );
     // end deprecated lints, do not remove this comment, it’s used in `update_lints`
 
     // begin register lints, do not remove this comment, it’s used in `update_lints`
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index 702f9d86de6..213e5758659 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -1831,13 +1831,6 @@ vec![
         deprecation: None,
         module: "panic_in_result_fn",
     },
-    Lint {
-        name: "panic_params",
-        group: "style",
-        desc: "missing parameters in `panic!` calls",
-        deprecation: None,
-        module: "panic_unimplemented",
-    },
     Lint {
         name: "panicking_unwrap",
         group: "correctness",
diff --git a/tests/ui/deprecated.rs b/tests/ui/deprecated.rs
index 56755596c97..4cbc5630d75 100644
--- a/tests/ui/deprecated.rs
+++ b/tests/ui/deprecated.rs
@@ -10,5 +10,6 @@
 #[warn(clippy::regex_macro)]
 #[warn(clippy::drop_bounds)]
 #[warn(clippy::temporary_cstring_as_ptr)]
+#[warn(clippy::panic_params)]
 
 fn main() {}
diff --git a/tests/ui/deprecated.stderr b/tests/ui/deprecated.stderr
index 37b726fc00f..a348d01d734 100644
--- a/tests/ui/deprecated.stderr
+++ b/tests/ui/deprecated.stderr
@@ -72,11 +72,17 @@ error: lint `clippy::temporary_cstring_as_ptr` has been removed: `this lint has
 LL | #[warn(clippy::temporary_cstring_as_ptr)]
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
+error: lint `clippy::panic_params` has been removed: `this lint has been uplifted to rustc and is now called `panic_fmt``
+  --> $DIR/deprecated.rs:13:8
+   |
+LL | #[warn(clippy::panic_params)]
+   |        ^^^^^^^^^^^^^^^^^^^^
+
 error: lint `clippy::str_to_string` has been removed: `using `str::to_string` is common even today and specialization will likely happen soon`
   --> $DIR/deprecated.rs:1:8
    |
 LL | #[warn(clippy::str_to_string)]
    |        ^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 13 previous errors
+error: aborting due to 14 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 5ee0a400fc5104a0fb9be5c85c48d79cf1af8dce Mon Sep 17 00:00:00 2001
From: flip1995 <philipp.krones@embecosm.com>
Date: Fri, 20 Nov 2020 10:06:26 +0100
Subject: Fix dogfood errors

---
 clippy_lints/src/panic_unimplemented.rs | 2 +-
 clippy_lints/src/utils/ast_utils.rs     | 3 +--
 2 files changed, 2 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/panic_unimplemented.rs b/clippy_lints/src/panic_unimplemented.rs
index 8b10d071647..31b03ecd101 100644
--- a/clippy_lints/src/panic_unimplemented.rs
+++ b/clippy_lints/src/panic_unimplemented.rs
@@ -73,7 +73,7 @@ declare_lint_pass!(PanicUnimplemented => [UNIMPLEMENTED, UNREACHABLE, TODO, PANI
 
 impl<'tcx> LateLintPass<'tcx> for PanicUnimplemented {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if let Some(_) = match_panic_call(cx, expr) {
+        if match_panic_call(cx, expr).is_some() {
             let span = get_outer_span(expr);
             if is_expn_of(expr.span, "unimplemented").is_some() {
                 span_lint(
diff --git a/clippy_lints/src/utils/ast_utils.rs b/clippy_lints/src/utils/ast_utils.rs
index 9050b9b2d9a..fcf7a4b1367 100644
--- a/clippy_lints/src/utils/ast_utils.rs
+++ b/clippy_lints/src/utils/ast_utils.rs
@@ -110,8 +110,7 @@ pub fn eq_expr_opt(l: &Option<P<Expr>>, r: &Option<P<Expr>>) -> bool {
 pub fn eq_struct_rest(l: &StructRest, r: &StructRest) -> bool {
     match (l, r) {
         (StructRest::Base(lb), StructRest::Base(rb)) => eq_expr(lb, rb),
-        (StructRest::Rest(_), StructRest::Rest(_)) => true,
-        (StructRest::None, StructRest::None) => true,
+        (StructRest::Rest(_), StructRest::Rest(_)) | (StructRest::None, StructRest::None) => true,
         _ => false,
     }
 }
-- 
cgit 1.4.1-3-g733a5


From 8b21241fd57376ab35e8ae75b3f57b7c601cdcdb Mon Sep 17 00:00:00 2001
From: Daniel Smith <daniel.smith@datadoghq.com>
Date: Fri, 20 Nov 2020 11:35:15 -0500
Subject: Revert "Convert the await holding lints to correctness"

This reverts commit d8c6bce4407b1c99ed961f75a093ffe767818069.
---
 clippy_lints/src/await_holding_invalid.rs | 4 ++--
 clippy_lints/src/lib.rs                   | 6 ++----
 src/lintlist/mod.rs                       | 4 ++--
 3 files changed, 6 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/await_holding_invalid.rs b/clippy_lints/src/await_holding_invalid.rs
index ca819663fde..58892024ce2 100644
--- a/clippy_lints/src/await_holding_invalid.rs
+++ b/clippy_lints/src/await_holding_invalid.rs
@@ -45,7 +45,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     pub AWAIT_HOLDING_LOCK,
-    correctness,
+    pedantic,
     "Inside an async function, holding a MutexGuard while calling await"
 }
 
@@ -84,7 +84,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     pub AWAIT_HOLDING_REFCELL_REF,
-    correctness,
+    pedantic,
     "Inside an async function, holding a RefCell ref while calling await"
 }
 
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 36016988b6b..7e8cbd00c22 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1224,6 +1224,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
 
     store.register_group(true, "clippy::pedantic", Some("clippy_pedantic"), vec![
         LintId::of(&attrs::INLINE_ALWAYS),
+        LintId::of(&await_holding_invalid::AWAIT_HOLDING_LOCK),
+        LintId::of(&await_holding_invalid::AWAIT_HOLDING_REFCELL_REF),
         LintId::of(&bit_mask::VERBOSE_BIT_MASK),
         LintId::of(&checked_conversions::CHECKED_CONVERSIONS),
         LintId::of(&copies::SAME_FUNCTIONS_IN_IF_CONDITION),
@@ -1327,8 +1329,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&attrs::MISMATCHED_TARGET_OS),
         LintId::of(&attrs::UNKNOWN_CLIPPY_LINTS),
         LintId::of(&attrs::USELESS_ATTRIBUTE),
-        LintId::of(&await_holding_invalid::AWAIT_HOLDING_LOCK),
-        LintId::of(&await_holding_invalid::AWAIT_HOLDING_REFCELL_REF),
         LintId::of(&bit_mask::BAD_BIT_MASK),
         LintId::of(&bit_mask::INEFFECTIVE_BIT_MASK),
         LintId::of(&blacklisted_name::BLACKLISTED_NAME),
@@ -1793,8 +1793,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&attrs::DEPRECATED_SEMVER),
         LintId::of(&attrs::MISMATCHED_TARGET_OS),
         LintId::of(&attrs::USELESS_ATTRIBUTE),
-        LintId::of(&await_holding_invalid::AWAIT_HOLDING_LOCK),
-        LintId::of(&await_holding_invalid::AWAIT_HOLDING_REFCELL_REF),
         LintId::of(&bit_mask::BAD_BIT_MASK),
         LintId::of(&bit_mask::INEFFECTIVE_BIT_MASK),
         LintId::of(&booleans::LOGIC_BUG),
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index c5a31fac254..79b24b83680 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -62,14 +62,14 @@ vec![
     },
     Lint {
         name: "await_holding_lock",
-        group: "correctness",
+        group: "pedantic",
         desc: "Inside an async function, holding a MutexGuard while calling await",
         deprecation: None,
         module: "await_holding_invalid",
     },
     Lint {
         name: "await_holding_refcell_ref",
-        group: "correctness",
+        group: "pedantic",
         desc: "Inside an async function, holding a RefCell ref while calling await",
         deprecation: None,
         module: "await_holding_invalid",
-- 
cgit 1.4.1-3-g733a5


From 9b910e19ce9bcd27c6dad220aba38121dc85138e Mon Sep 17 00:00:00 2001
From: oliver <16816606+o752d@users.noreply.github.com>
Date: Sun, 22 Nov 2020 04:44:47 +0000
Subject: a typo

typo
---
 clippy_lints/src/assertions_on_constants.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/assertions_on_constants.rs b/clippy_lints/src/assertions_on_constants.rs
index a52f0997d43..62c73dbac48 100644
--- a/clippy_lints/src/assertions_on_constants.rs
+++ b/clippy_lints/src/assertions_on_constants.rs
@@ -129,7 +129,7 @@ fn match_assert_with_message<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>)
         if let ExprKind::Block(ref block, _) = arms[0].body.kind;
         if block.stmts.is_empty();
         if let Some(block_expr) = &block.expr;
-        // inner block is optional. unwarp it if it exists, or use the expression as is otherwise.
+        // inner block is optional. unwrap it if it exists, or use the expression as is otherwise.
         if let Some(begin_panic_call) = match block_expr.kind {
             ExprKind::Block(ref inner_block, _) => &inner_block.expr,
             _ => &block.expr,
-- 
cgit 1.4.1-3-g733a5


From 034244f1081ee65ce9a258e99cf39baa5d692bca Mon Sep 17 00:00:00 2001
From: "Carol (Nichols || Goulding)" <carol.nichols@gmail.com>
Date: Sat, 21 Nov 2020 15:00:03 -0500
Subject: Small grammar, punctuation, and code style improvements to docs

---
 clippy_lints/src/len_zero.rs                  | 2 +-
 clippy_lints/src/methods/mod.rs               | 2 +-
 clippy_lints/src/regex.rs                     | 4 ++--
 clippy_lints/src/unit_return_expecting_ord.rs | 2 +-
 clippy_lints/src/useless_conversion.rs        | 6 +++---
 src/lintlist/mod.rs                           | 2 +-
 6 files changed, 9 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/len_zero.rs b/clippy_lints/src/len_zero.rs
index 8e2f03d6e4e..8842901d90b 100644
--- a/clippy_lints/src/len_zero.rs
+++ b/clippy_lints/src/len_zero.rs
@@ -69,7 +69,7 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for comparing to an empty slice such as "" or [],`
+    /// **What it does:** Checks for comparing to an empty slice such as `""` or `[]`,
     /// and suggests using `.is_empty()` where applicable.
     ///
     /// **Why is this bad?** Some structures can answer `.is_empty()` much faster
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index ff0a3532465..fa174404365 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1351,7 +1351,7 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for usage of `_.map(_).collect::<Result<(),_>()`.
+    /// **What it does:** Checks for usage of `_.map(_).collect::<Result<(), _>()`.
     ///
     /// **Why is this bad?** Using `try_for_each` instead is more readable and idiomatic.
     ///
diff --git a/clippy_lints/src/regex.rs b/clippy_lints/src/regex.rs
index 95594e38c9e..d06ab143482 100644
--- a/clippy_lints/src/regex.rs
+++ b/clippy_lints/src/regex.rs
@@ -11,7 +11,7 @@ use std::convert::TryFrom;
 
 declare_clippy_lint! {
     /// **What it does:** Checks [regex](https://crates.io/crates/regex) creation
-    /// (with `Regex::new`,`RegexBuilder::new` or `RegexSet::new`) for correct
+    /// (with `Regex::new`, `RegexBuilder::new`, or `RegexSet::new`) for correct
     /// regex syntax.
     ///
     /// **Why is this bad?** This will lead to a runtime panic.
@@ -29,7 +29,7 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// **What it does:** Checks for trivial [regex](https://crates.io/crates/regex)
-    /// creation (with `Regex::new`, `RegexBuilder::new` or `RegexSet::new`).
+    /// creation (with `Regex::new`, `RegexBuilder::new`, or `RegexSet::new`).
     ///
     /// **Why is this bad?** Matching the regex can likely be replaced by `==` or
     /// `str::starts_with`, `str::ends_with` or `std::contains` or other `str`
diff --git a/clippy_lints/src/unit_return_expecting_ord.rs b/clippy_lints/src/unit_return_expecting_ord.rs
index ade5fff5ffc..2501635e7ef 100644
--- a/clippy_lints/src/unit_return_expecting_ord.rs
+++ b/clippy_lints/src/unit_return_expecting_ord.rs
@@ -24,7 +24,7 @@ declare_clippy_lint! {
     /// **Example:**
     ///
     /// ```rust
-    /// let mut twins = vec!((1,1), (2,2));
+    /// let mut twins = vec!((1, 1), (2, 2));
     /// twins.sort_by_key(|x| { x.1; });
     /// ```
     pub UNIT_RETURN_EXPECTING_ORD,
diff --git a/clippy_lints/src/useless_conversion.rs b/clippy_lints/src/useless_conversion.rs
index c6194b0c6de..99c38e8f176 100644
--- a/clippy_lints/src/useless_conversion.rs
+++ b/clippy_lints/src/useless_conversion.rs
@@ -12,8 +12,8 @@ use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::sym;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for `Into`, `TryInto`, `From`, `TryFrom`,`IntoIter` calls
-    /// that useless converts to the same type as caller.
+    /// **What it does:** Checks for `Into`, `TryInto`, `From`, `TryFrom`, or `IntoIter` calls
+    /// that uselessly convert to the same type.
     ///
     /// **Why is this bad?** Redundant code.
     ///
@@ -31,7 +31,7 @@ declare_clippy_lint! {
     /// ```
     pub USELESS_CONVERSION,
     complexity,
-    "calls to `Into`, `TryInto`, `From`, `TryFrom`, `IntoIter` that performs useless conversions to the same type"
+    "calls to `Into`, `TryInto`, `From`, `TryFrom`, or `IntoIter` that perform useless conversions to the same type"
 }
 
 #[derive(Default)]
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index 79b24b83680..1d906d20ad4 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -2751,7 +2751,7 @@ vec![
     Lint {
         name: "useless_conversion",
         group: "complexity",
-        desc: "calls to `Into`, `TryInto`, `From`, `TryFrom`, `IntoIter` that performs useless conversions to the same type",
+        desc: "calls to `Into`, `TryInto`, `From`, `TryFrom`, or `IntoIter` which perform useless conversions to the same type",
         deprecation: None,
         module: "useless_conversion",
     },
-- 
cgit 1.4.1-3-g733a5


From 445466e567c192bb81ccc366743793ffb079da5d Mon Sep 17 00:00:00 2001
From: "Carol (Nichols || Goulding)"
 <193874+carols10cents@users.noreply.github.com>
Date: Sun, 22 Nov 2020 10:12:41 -0500
Subject: Apply suggestions from code review to change "that" to "which"

Co-authored-by: oliver <16816606+o752d@users.noreply.github.com>
---
 clippy_lints/src/useless_conversion.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/useless_conversion.rs b/clippy_lints/src/useless_conversion.rs
index 99c38e8f176..efa9c3fab4a 100644
--- a/clippy_lints/src/useless_conversion.rs
+++ b/clippy_lints/src/useless_conversion.rs
@@ -13,7 +13,7 @@ use rustc_span::sym;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for `Into`, `TryInto`, `From`, `TryFrom`, or `IntoIter` calls
-    /// that uselessly convert to the same type.
+    /// which uselessly convert to the same type.
     ///
     /// **Why is this bad?** Redundant code.
     ///
@@ -31,7 +31,7 @@ declare_clippy_lint! {
     /// ```
     pub USELESS_CONVERSION,
     complexity,
-    "calls to `Into`, `TryInto`, `From`, `TryFrom`, or `IntoIter` that perform useless conversions to the same type"
+    "calls to `Into`, `TryInto`, `From`, `TryFrom`, or `IntoIter` which perform useless conversions to the same type"
 }
 
 #[derive(Default)]
-- 
cgit 1.4.1-3-g733a5


From a8c47440b4ac59239f11838cfc7426b2adef3685 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Tue, 10 Nov 2020 09:19:30 -0600
Subject: Use article_and_description for missing docs

---
 clippy_lints/src/missing_doc.rs           | 64 ++++++++++++++++---------------
 tests/ui/missing-doc-crate-missing.stderr |  2 +-
 tests/ui/missing-doc-impl.stderr          | 12 +++---
 3 files changed, 40 insertions(+), 38 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/missing_doc.rs b/clippy_lints/src/missing_doc.rs
index 009e3d8937e..f2c0ab1222c 100644
--- a/clippy_lints/src/missing_doc.rs
+++ b/clippy_lints/src/missing_doc.rs
@@ -2,7 +2,7 @@
 // *rustc*'s
 // [`missing_doc`].
 //
-// [`missing_doc`]: https://github.com/rust-lang/rust/blob/d6d05904697d89099b55da3331155392f1db9c00/src/librustc_lint/builtin.rs#L246
+// [`missing_doc`]: https://github.com/rust-lang/rust/blob/cf9cf7c923eb01146971429044f216a3ca905e06/compiler/rustc_lint/src/builtin.rs#L415
 //
 
 use crate::utils::span_lint;
@@ -70,7 +70,14 @@ impl MissingDoc {
         }
     }
 
-    fn check_missing_docs_attrs(&self, cx: &LateContext<'_>, attrs: &[ast::Attribute], sp: Span, desc: &'static str) {
+    fn check_missing_docs_attrs(
+        &self,
+        cx: &LateContext<'_>,
+        attrs: &[ast::Attribute],
+        sp: Span,
+        article: &'static str,
+        desc: &'static str,
+    ) {
         // If we're building a test harness, then warning about
         // documentation is probably not really relevant right now.
         if cx.sess().opts.test {
@@ -94,7 +101,7 @@ impl MissingDoc {
                 cx,
                 MISSING_DOCS_IN_PRIVATE_ITEMS,
                 sp,
-                &format!("missing documentation for {}", desc),
+                &format!("missing documentation for {} {}", article, desc),
             );
         }
     }
@@ -120,13 +127,11 @@ impl<'tcx> LateLintPass<'tcx> for MissingDoc {
     }
 
     fn check_crate(&mut self, cx: &LateContext<'tcx>, krate: &'tcx hir::Crate<'_>) {
-        self.check_missing_docs_attrs(cx, &krate.item.attrs, krate.item.span, "crate");
+        self.check_missing_docs_attrs(cx, &krate.item.attrs, krate.item.span, "the", "crate");
     }
 
     fn check_item(&mut self, cx: &LateContext<'tcx>, it: &'tcx hir::Item<'_>) {
-        let desc = match it.kind {
-            hir::ItemKind::Const(..) => "a constant",
-            hir::ItemKind::Enum(..) => "an enum",
+        match it.kind {
             hir::ItemKind::Fn(..) => {
                 // ignore main()
                 if it.ident.name == sym::main {
@@ -136,16 +141,17 @@ impl<'tcx> LateLintPass<'tcx> for MissingDoc {
                         return;
                     }
                 }
-                "a function"
             },
-            hir::ItemKind::Mod(..) => "a module",
-            hir::ItemKind::Static(..) => "a static",
-            hir::ItemKind::Struct(..) => "a struct",
-            hir::ItemKind::Trait(..) => "a trait",
-            hir::ItemKind::TraitAlias(..) => "a trait alias",
-            hir::ItemKind::TyAlias(..) => "a type alias",
-            hir::ItemKind::Union(..) => "a union",
-            hir::ItemKind::OpaqueTy(..) => "an existential type",
+            hir::ItemKind::Const(..)
+            | hir::ItemKind::Enum(..)
+            | hir::ItemKind::Mod(..)
+            | hir::ItemKind::Static(..)
+            | hir::ItemKind::Struct(..)
+            | hir::ItemKind::Trait(..)
+            | hir::ItemKind::TraitAlias(..)
+            | hir::ItemKind::TyAlias(..)
+            | hir::ItemKind::Union(..)
+            | hir::ItemKind::OpaqueTy(..) => {},
             hir::ItemKind::ExternCrate(..)
             | hir::ItemKind::ForeignMod(..)
             | hir::ItemKind::GlobalAsm(..)
@@ -153,17 +159,17 @@ impl<'tcx> LateLintPass<'tcx> for MissingDoc {
             | hir::ItemKind::Use(..) => return,
         };
 
-        self.check_missing_docs_attrs(cx, &it.attrs, it.span, desc);
+        let def_id = cx.tcx.hir().local_def_id(it.hir_id);
+        let (article, desc) = cx.tcx.article_and_description(def_id.to_def_id());
+
+        self.check_missing_docs_attrs(cx, &it.attrs, it.span, article, desc);
     }
 
     fn check_trait_item(&mut self, cx: &LateContext<'tcx>, trait_item: &'tcx hir::TraitItem<'_>) {
-        let desc = match trait_item.kind {
-            hir::TraitItemKind::Const(..) => "an associated constant",
-            hir::TraitItemKind::Fn(..) => "a trait method",
-            hir::TraitItemKind::Type(..) => "an associated type",
-        };
+        let def_id = cx.tcx.hir().local_def_id(trait_item.hir_id);
+        let (article, desc) = cx.tcx.article_and_description(def_id.to_def_id());
 
-        self.check_missing_docs_attrs(cx, &trait_item.attrs, trait_item.span, desc);
+        self.check_missing_docs_attrs(cx, &trait_item.attrs, trait_item.span, article, desc);
     }
 
     fn check_impl_item(&mut self, cx: &LateContext<'tcx>, impl_item: &'tcx hir::ImplItem<'_>) {
@@ -178,21 +184,17 @@ impl<'tcx> LateLintPass<'tcx> for MissingDoc {
             },
         }
 
-        let desc = match impl_item.kind {
-            hir::ImplItemKind::Const(..) => "an associated constant",
-            hir::ImplItemKind::Fn(..) => "a method",
-            hir::ImplItemKind::TyAlias(_) => "an associated type",
-        };
-        self.check_missing_docs_attrs(cx, &impl_item.attrs, impl_item.span, desc);
+        let (article, desc) = cx.tcx.article_and_description(def_id.to_def_id());
+        self.check_missing_docs_attrs(cx, &impl_item.attrs, impl_item.span, article, desc);
     }
 
     fn check_struct_field(&mut self, cx: &LateContext<'tcx>, sf: &'tcx hir::StructField<'_>) {
         if !sf.is_positional() {
-            self.check_missing_docs_attrs(cx, &sf.attrs, sf.span, "a struct field");
+            self.check_missing_docs_attrs(cx, &sf.attrs, sf.span, "a", "struct field");
         }
     }
 
     fn check_variant(&mut self, cx: &LateContext<'tcx>, v: &'tcx hir::Variant<'_>) {
-        self.check_missing_docs_attrs(cx, &v.attrs, v.span, "a variant");
+        self.check_missing_docs_attrs(cx, &v.attrs, v.span, "a", "variant");
     }
 }
diff --git a/tests/ui/missing-doc-crate-missing.stderr b/tests/ui/missing-doc-crate-missing.stderr
index da46f988636..d56c5cc4c3a 100644
--- a/tests/ui/missing-doc-crate-missing.stderr
+++ b/tests/ui/missing-doc-crate-missing.stderr
@@ -1,4 +1,4 @@
-error: missing documentation for crate
+error: missing documentation for the crate
   --> $DIR/missing-doc-crate-missing.rs:1:1
    |
 LL | / #![warn(clippy::missing_docs_in_private_items)]
diff --git a/tests/ui/missing-doc-impl.stderr b/tests/ui/missing-doc-impl.stderr
index 9656a39abce..7e10404ca00 100644
--- a/tests/ui/missing-doc-impl.stderr
+++ b/tests/ui/missing-doc-impl.stderr
@@ -51,13 +51,13 @@ LL | |     fn foo_with_impl(&self) {}
 LL | | }
    | |_^
 
-error: missing documentation for a trait method
+error: missing documentation for an associated function
   --> $DIR/missing-doc-impl.rs:39:5
    |
 LL |     fn foo(&self);
    |     ^^^^^^^^^^^^^^
 
-error: missing documentation for a trait method
+error: missing documentation for an associated function
   --> $DIR/missing-doc-impl.rs:40:5
    |
 LL |     fn foo_with_impl(&self) {}
@@ -75,25 +75,25 @@ error: missing documentation for an associated type
 LL |     type AssociatedTypeDef = Self;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: missing documentation for a method
+error: missing documentation for an associated function
   --> $DIR/missing-doc-impl.rs:62:5
    |
 LL |     pub fn foo() {}
    |     ^^^^^^^^^^^^^^^
 
-error: missing documentation for a method
+error: missing documentation for an associated function
   --> $DIR/missing-doc-impl.rs:63:5
    |
 LL |     fn bar() {}
    |     ^^^^^^^^^^^
 
-error: missing documentation for a method
+error: missing documentation for an associated function
   --> $DIR/missing-doc-impl.rs:67:5
    |
 LL |     pub fn foo() {}
    |     ^^^^^^^^^^^^^^^
 
-error: missing documentation for a method
+error: missing documentation for an associated function
   --> $DIR/missing-doc-impl.rs:70:5
    |
 LL |     fn foo2() {}
-- 
cgit 1.4.1-3-g733a5


From a39a93faeb4969fac62e896138cdf72377fa5502 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Sun, 22 Nov 2020 19:21:01 -0600
Subject: Disable unnecessary_cast for cfg-dependant types

---
 clippy_lints/src/types.rs    | 10 +++++++++-
 tests/ui/unnecessary_cast.rs |  3 +++
 2 files changed, 12 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs
index f0e10e374e1..840adbbc57a 100644
--- a/clippy_lints/src/types.rs
+++ b/clippy_lints/src/types.rs
@@ -8,6 +8,7 @@ use if_chain::if_chain;
 use rustc_ast::{FloatTy, IntTy, LitFloatType, LitIntType, LitKind, UintTy};
 use rustc_errors::{Applicability, DiagnosticBuilder};
 use rustc_hir as hir;
+use rustc_hir::def::Res;
 use rustc_hir::intravisit::{walk_body, walk_expr, walk_ty, FnKind, NestedVisitorMap, Visitor};
 use rustc_hir::{
     BinOpKind, Block, Body, Expr, ExprKind, FnDecl, FnRetTy, FnSig, GenericArg, GenericBounds, GenericParamKind, HirId,
@@ -1632,7 +1633,14 @@ impl<'tcx> LateLintPass<'tcx> for Casts {
         if expr.span.from_expansion() {
             return;
         }
-        if let ExprKind::Cast(ref ex, _) = expr.kind {
+        if let ExprKind::Cast(ref ex, cast_to) = expr.kind {
+            if let TyKind::Path(QPath::Resolved(_, path)) = cast_to.kind {
+                if let Res::Def(_, def_id) = path.res {
+                    if cx.tcx.has_attr(def_id, sym::cfg) || cx.tcx.has_attr(def_id, sym::cfg_attr) {
+                        return;
+                    }
+                }
+            }
             let (cast_from, cast_to) = (cx.typeck_results().expr_ty(ex), cx.typeck_results().expr_ty(expr));
             lint_fn_to_numeric_cast(cx, expr, ex, cast_from, cast_to);
             if let Some(lit) = get_numeric_literal(ex) {
diff --git a/tests/ui/unnecessary_cast.rs b/tests/ui/unnecessary_cast.rs
index df9b227eeb3..e8f2fb46665 100644
--- a/tests/ui/unnecessary_cast.rs
+++ b/tests/ui/unnecessary_cast.rs
@@ -20,4 +20,7 @@ fn main() {
     foo!(a, i32);
     foo!(b, f32);
     foo!(c, f64);
+
+    // do not lint cast to cfg-dependant type
+    1 as std::os::raw::c_char;
 }
-- 
cgit 1.4.1-3-g733a5


From dc075b426675e61cc46089046cf41d85edd79aaa Mon Sep 17 00:00:00 2001
From: Christiaan Dirkx <christiaan@dirkx.email>
Date: Wed, 25 Nov 2020 02:01:05 +0100
Subject: Change `redundant_pattern_matching` to also lint `std::net::IpAddr`

Suggest using utility methods `is_ipv4` and `is_ipv6`.
---
 clippy_lints/src/matches.rs                       |  25 ++++-
 clippy_lints/src/utils/paths.rs                   |   2 +
 tests/ui/redundant_pattern_matching_ipaddr.fixed  |  73 ++++++++++++
 tests/ui/redundant_pattern_matching_ipaddr.rs     |  91 +++++++++++++++
 tests/ui/redundant_pattern_matching_ipaddr.stderr | 130 ++++++++++++++++++++++
 tests/ui/redundant_pattern_matching_option.fixed  |   5 +-
 tests/ui/redundant_pattern_matching_option.rs     |   5 +-
 tests/ui/redundant_pattern_matching_option.stderr |  18 +--
 tests/ui/redundant_pattern_matching_poll.fixed    |   5 +-
 tests/ui/redundant_pattern_matching_poll.rs       |   5 +-
 tests/ui/redundant_pattern_matching_poll.stderr   |  18 +--
 11 files changed, 341 insertions(+), 36 deletions(-)
 create mode 100644 tests/ui/redundant_pattern_matching_ipaddr.fixed
 create mode 100644 tests/ui/redundant_pattern_matching_ipaddr.rs
 create mode 100644 tests/ui/redundant_pattern_matching_ipaddr.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index af59917e801..a14b63faf78 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -411,8 +411,8 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Lint for redundant pattern matching over `Result`, `Option` or
-    /// `std::task::Poll`
+    /// **What it does:** Lint for redundant pattern matching over `Result`, `Option`,
+    /// `std::task::Poll` or `std::net::IpAddr`
     ///
     /// **Why is this bad?** It's more concise and clear to just use the proper
     /// utility function
@@ -423,12 +423,15 @@ declare_clippy_lint! {
     ///
     /// ```rust
     /// # use std::task::Poll;
+    /// # use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
     /// if let Ok(_) = Ok::<i32, i32>(42) {}
     /// if let Err(_) = Err::<i32, i32>(42) {}
     /// if let None = None::<()> {}
     /// if let Some(_) = Some(42) {}
     /// if let Poll::Pending = Poll::Pending::<()> {}
     /// if let Poll::Ready(_) = Poll::Ready(42) {}
+    /// if let IpAddr::V4(_) = IpAddr::V4(Ipv4Addr::LOCALHOST) {}
+    /// if let IpAddr::V6(_) = IpAddr::V6(Ipv6Addr::LOCALHOST) {}
     /// match Ok::<i32, i32>(42) {
     ///     Ok(_) => true,
     ///     Err(_) => false,
@@ -439,12 +442,15 @@ declare_clippy_lint! {
     ///
     /// ```rust
     /// # use std::task::Poll;
+    /// # use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
     /// if Ok::<i32, i32>(42).is_ok() {}
     /// if Err::<i32, i32>(42).is_err() {}
     /// if None::<()>.is_none() {}
     /// if Some(42).is_some() {}
     /// if Poll::Pending::<()>.is_pending() {}
     /// if Poll::Ready(42).is_ready() {}
+    /// if IpAddr::V4(Ipv4Addr::LOCALHOST).is_ipv4() {}
+    /// if IpAddr::V6(Ipv6Addr::LOCALHOST).is_ipv6() {}
     /// Ok::<i32, i32>(42).is_ok();
     /// ```
     pub REDUNDANT_PATTERN_MATCHING,
@@ -1546,6 +1552,10 @@ mod redundant_pattern_match {
                         "is_some()"
                     } else if match_qpath(path, &paths::POLL_READY) {
                         "is_ready()"
+                    } else if match_qpath(path, &paths::IPADDR_V4) {
+                        "is_ipv4()"
+                    } else if match_qpath(path, &paths::IPADDR_V6) {
+                        "is_ipv6()"
                     } else {
                         return;
                     }
@@ -1626,6 +1636,17 @@ mod redundant_pattern_match {
                             "is_ok()",
                             "is_err()",
                         )
+                        .or_else(|| {
+                            find_good_method_for_match(
+                                arms,
+                                path_left,
+                                path_right,
+                                &paths::IPADDR_V4,
+                                &paths::IPADDR_V6,
+                                "is_ipv4()",
+                                "is_ipv6()",
+                            )
+                        })
                     } else {
                         None
                     }
diff --git a/clippy_lints/src/utils/paths.rs b/clippy_lints/src/utils/paths.rs
index 829e9a2989c..61aeabb7ba7 100644
--- a/clippy_lints/src/utils/paths.rs
+++ b/clippy_lints/src/utils/paths.rs
@@ -58,6 +58,8 @@ pub const INTO: [&str; 3] = ["core", "convert", "Into"];
 pub const INTO_ITERATOR: [&str; 5] = ["core", "iter", "traits", "collect", "IntoIterator"];
 pub const IO_READ: [&str; 3] = ["std", "io", "Read"];
 pub const IO_WRITE: [&str; 3] = ["std", "io", "Write"];
+pub const IPADDR_V4: [&str; 4] = ["std", "net", "IpAddr", "V4"];
+pub const IPADDR_V6: [&str; 4] = ["std", "net", "IpAddr", "V6"];
 pub const ITERATOR: [&str; 5] = ["core", "iter", "traits", "iterator", "Iterator"];
 pub const LATE_CONTEXT: [&str; 2] = ["rustc_lint", "LateContext"];
 pub const LINKED_LIST: [&str; 4] = ["alloc", "collections", "linked_list", "LinkedList"];
diff --git a/tests/ui/redundant_pattern_matching_ipaddr.fixed b/tests/ui/redundant_pattern_matching_ipaddr.fixed
new file mode 100644
index 00000000000..acc8de5f41e
--- /dev/null
+++ b/tests/ui/redundant_pattern_matching_ipaddr.fixed
@@ -0,0 +1,73 @@
+// run-rustfix
+
+#![warn(clippy::all)]
+#![warn(clippy::redundant_pattern_matching)]
+#![allow(unused_must_use, clippy::needless_bool, clippy::match_like_matches_macro)]
+
+use std::net::{
+    IpAddr::{self, V4, V6},
+    Ipv4Addr, Ipv6Addr,
+};
+
+fn main() {
+    let ipaddr: IpAddr = V4(Ipv4Addr::LOCALHOST);
+    if ipaddr.is_ipv4() {}
+
+    if V4(Ipv4Addr::LOCALHOST).is_ipv4() {}
+
+    if V6(Ipv6Addr::LOCALHOST).is_ipv6() {}
+
+    while V4(Ipv4Addr::LOCALHOST).is_ipv4() {}
+
+    while V6(Ipv6Addr::LOCALHOST).is_ipv6() {}
+
+    if V4(Ipv4Addr::LOCALHOST).is_ipv4() {}
+
+    if V6(Ipv6Addr::LOCALHOST).is_ipv6() {}
+
+    if let V4(ipaddr) = V4(Ipv4Addr::LOCALHOST) {
+        println!("{}", ipaddr);
+    }
+
+    V4(Ipv4Addr::LOCALHOST).is_ipv4();
+
+    V4(Ipv4Addr::LOCALHOST).is_ipv6();
+
+    V6(Ipv6Addr::LOCALHOST).is_ipv6();
+
+    V6(Ipv6Addr::LOCALHOST).is_ipv4();
+
+    let _ = if V4(Ipv4Addr::LOCALHOST).is_ipv4() {
+        true
+    } else {
+        false
+    };
+
+    ipaddr_const();
+
+    let _ = if gen_ipaddr().is_ipv4() {
+        1
+    } else if gen_ipaddr().is_ipv6() {
+        2
+    } else {
+        3
+    };
+}
+
+fn gen_ipaddr() -> IpAddr {
+    V4(Ipv4Addr::LOCALHOST)
+}
+
+const fn ipaddr_const() {
+    if V4(Ipv4Addr::LOCALHOST).is_ipv4() {}
+
+    if V6(Ipv6Addr::LOCALHOST).is_ipv6() {}
+
+    while V4(Ipv4Addr::LOCALHOST).is_ipv4() {}
+
+    while V6(Ipv6Addr::LOCALHOST).is_ipv6() {}
+
+    V4(Ipv4Addr::LOCALHOST).is_ipv4();
+
+    V6(Ipv6Addr::LOCALHOST).is_ipv6();
+}
diff --git a/tests/ui/redundant_pattern_matching_ipaddr.rs b/tests/ui/redundant_pattern_matching_ipaddr.rs
new file mode 100644
index 00000000000..678d91ce93a
--- /dev/null
+++ b/tests/ui/redundant_pattern_matching_ipaddr.rs
@@ -0,0 +1,91 @@
+// run-rustfix
+
+#![warn(clippy::all)]
+#![warn(clippy::redundant_pattern_matching)]
+#![allow(unused_must_use, clippy::needless_bool, clippy::match_like_matches_macro)]
+
+use std::net::{
+    IpAddr::{self, V4, V6},
+    Ipv4Addr, Ipv6Addr,
+};
+
+fn main() {
+    let ipaddr: IpAddr = V4(Ipv4Addr::LOCALHOST);
+    if let V4(_) = &ipaddr {}
+
+    if let V4(_) = V4(Ipv4Addr::LOCALHOST) {}
+
+    if let V6(_) = V6(Ipv6Addr::LOCALHOST) {}
+
+    while let V4(_) = V4(Ipv4Addr::LOCALHOST) {}
+
+    while let V6(_) = V6(Ipv6Addr::LOCALHOST) {}
+
+    if V4(Ipv4Addr::LOCALHOST).is_ipv4() {}
+
+    if V6(Ipv6Addr::LOCALHOST).is_ipv6() {}
+
+    if let V4(ipaddr) = V4(Ipv4Addr::LOCALHOST) {
+        println!("{}", ipaddr);
+    }
+
+    match V4(Ipv4Addr::LOCALHOST) {
+        V4(_) => true,
+        V6(_) => false,
+    };
+
+    match V4(Ipv4Addr::LOCALHOST) {
+        V4(_) => false,
+        V6(_) => true,
+    };
+
+    match V6(Ipv6Addr::LOCALHOST) {
+        V4(_) => false,
+        V6(_) => true,
+    };
+
+    match V6(Ipv6Addr::LOCALHOST) {
+        V4(_) => true,
+        V6(_) => false,
+    };
+
+    let _ = if let V4(_) = V4(Ipv4Addr::LOCALHOST) {
+        true
+    } else {
+        false
+    };
+
+    ipaddr_const();
+
+    let _ = if let V4(_) = gen_ipaddr() {
+        1
+    } else if let V6(_) = gen_ipaddr() {
+        2
+    } else {
+        3
+    };
+}
+
+fn gen_ipaddr() -> IpAddr {
+    V4(Ipv4Addr::LOCALHOST)
+}
+
+const fn ipaddr_const() {
+    if let V4(_) = V4(Ipv4Addr::LOCALHOST) {}
+
+    if let V6(_) = V6(Ipv6Addr::LOCALHOST) {}
+
+    while let V4(_) = V4(Ipv4Addr::LOCALHOST) {}
+
+    while let V6(_) = V6(Ipv6Addr::LOCALHOST) {}
+
+    match V4(Ipv4Addr::LOCALHOST) {
+        V4(_) => true,
+        V6(_) => false,
+    };
+
+    match V6(Ipv6Addr::LOCALHOST) {
+        V4(_) => false,
+        V6(_) => true,
+    };
+}
diff --git a/tests/ui/redundant_pattern_matching_ipaddr.stderr b/tests/ui/redundant_pattern_matching_ipaddr.stderr
new file mode 100644
index 00000000000..caf458cd862
--- /dev/null
+++ b/tests/ui/redundant_pattern_matching_ipaddr.stderr
@@ -0,0 +1,130 @@
+error: redundant pattern matching, consider using `is_ipv4()`
+  --> $DIR/redundant_pattern_matching_ipaddr.rs:14:12
+   |
+LL |     if let V4(_) = &ipaddr {}
+   |     -------^^^^^---------- help: try this: `if ipaddr.is_ipv4()`
+   |
+   = note: `-D clippy::redundant-pattern-matching` implied by `-D warnings`
+
+error: redundant pattern matching, consider using `is_ipv4()`
+  --> $DIR/redundant_pattern_matching_ipaddr.rs:16:12
+   |
+LL |     if let V4(_) = V4(Ipv4Addr::LOCALHOST) {}
+   |     -------^^^^^-------------------------- help: try this: `if V4(Ipv4Addr::LOCALHOST).is_ipv4()`
+
+error: redundant pattern matching, consider using `is_ipv6()`
+  --> $DIR/redundant_pattern_matching_ipaddr.rs:18:12
+   |
+LL |     if let V6(_) = V6(Ipv6Addr::LOCALHOST) {}
+   |     -------^^^^^-------------------------- help: try this: `if V6(Ipv6Addr::LOCALHOST).is_ipv6()`
+
+error: redundant pattern matching, consider using `is_ipv4()`
+  --> $DIR/redundant_pattern_matching_ipaddr.rs:20:15
+   |
+LL |     while let V4(_) = V4(Ipv4Addr::LOCALHOST) {}
+   |     ----------^^^^^-------------------------- help: try this: `while V4(Ipv4Addr::LOCALHOST).is_ipv4()`
+
+error: redundant pattern matching, consider using `is_ipv6()`
+  --> $DIR/redundant_pattern_matching_ipaddr.rs:22:15
+   |
+LL |     while let V6(_) = V6(Ipv6Addr::LOCALHOST) {}
+   |     ----------^^^^^-------------------------- help: try this: `while V6(Ipv6Addr::LOCALHOST).is_ipv6()`
+
+error: redundant pattern matching, consider using `is_ipv4()`
+  --> $DIR/redundant_pattern_matching_ipaddr.rs:32:5
+   |
+LL | /     match V4(Ipv4Addr::LOCALHOST) {
+LL | |         V4(_) => true,
+LL | |         V6(_) => false,
+LL | |     };
+   | |_____^ help: try this: `V4(Ipv4Addr::LOCALHOST).is_ipv4()`
+
+error: redundant pattern matching, consider using `is_ipv6()`
+  --> $DIR/redundant_pattern_matching_ipaddr.rs:37:5
+   |
+LL | /     match V4(Ipv4Addr::LOCALHOST) {
+LL | |         V4(_) => false,
+LL | |         V6(_) => true,
+LL | |     };
+   | |_____^ help: try this: `V4(Ipv4Addr::LOCALHOST).is_ipv6()`
+
+error: redundant pattern matching, consider using `is_ipv6()`
+  --> $DIR/redundant_pattern_matching_ipaddr.rs:42:5
+   |
+LL | /     match V6(Ipv6Addr::LOCALHOST) {
+LL | |         V4(_) => false,
+LL | |         V6(_) => true,
+LL | |     };
+   | |_____^ help: try this: `V6(Ipv6Addr::LOCALHOST).is_ipv6()`
+
+error: redundant pattern matching, consider using `is_ipv4()`
+  --> $DIR/redundant_pattern_matching_ipaddr.rs:47:5
+   |
+LL | /     match V6(Ipv6Addr::LOCALHOST) {
+LL | |         V4(_) => true,
+LL | |         V6(_) => false,
+LL | |     };
+   | |_____^ help: try this: `V6(Ipv6Addr::LOCALHOST).is_ipv4()`
+
+error: redundant pattern matching, consider using `is_ipv4()`
+  --> $DIR/redundant_pattern_matching_ipaddr.rs:52:20
+   |
+LL |     let _ = if let V4(_) = V4(Ipv4Addr::LOCALHOST) {
+   |             -------^^^^^-------------------------- help: try this: `if V4(Ipv4Addr::LOCALHOST).is_ipv4()`
+
+error: redundant pattern matching, consider using `is_ipv4()`
+  --> $DIR/redundant_pattern_matching_ipaddr.rs:60:20
+   |
+LL |     let _ = if let V4(_) = gen_ipaddr() {
+   |             -------^^^^^--------------- help: try this: `if gen_ipaddr().is_ipv4()`
+
+error: redundant pattern matching, consider using `is_ipv6()`
+  --> $DIR/redundant_pattern_matching_ipaddr.rs:62:19
+   |
+LL |     } else if let V6(_) = gen_ipaddr() {
+   |            -------^^^^^--------------- help: try this: `if gen_ipaddr().is_ipv6()`
+
+error: redundant pattern matching, consider using `is_ipv4()`
+  --> $DIR/redundant_pattern_matching_ipaddr.rs:74:12
+   |
+LL |     if let V4(_) = V4(Ipv4Addr::LOCALHOST) {}
+   |     -------^^^^^-------------------------- help: try this: `if V4(Ipv4Addr::LOCALHOST).is_ipv4()`
+
+error: redundant pattern matching, consider using `is_ipv6()`
+  --> $DIR/redundant_pattern_matching_ipaddr.rs:76:12
+   |
+LL |     if let V6(_) = V6(Ipv6Addr::LOCALHOST) {}
+   |     -------^^^^^-------------------------- help: try this: `if V6(Ipv6Addr::LOCALHOST).is_ipv6()`
+
+error: redundant pattern matching, consider using `is_ipv4()`
+  --> $DIR/redundant_pattern_matching_ipaddr.rs:78:15
+   |
+LL |     while let V4(_) = V4(Ipv4Addr::LOCALHOST) {}
+   |     ----------^^^^^-------------------------- help: try this: `while V4(Ipv4Addr::LOCALHOST).is_ipv4()`
+
+error: redundant pattern matching, consider using `is_ipv6()`
+  --> $DIR/redundant_pattern_matching_ipaddr.rs:80:15
+   |
+LL |     while let V6(_) = V6(Ipv6Addr::LOCALHOST) {}
+   |     ----------^^^^^-------------------------- help: try this: `while V6(Ipv6Addr::LOCALHOST).is_ipv6()`
+
+error: redundant pattern matching, consider using `is_ipv4()`
+  --> $DIR/redundant_pattern_matching_ipaddr.rs:82:5
+   |
+LL | /     match V4(Ipv4Addr::LOCALHOST) {
+LL | |         V4(_) => true,
+LL | |         V6(_) => false,
+LL | |     };
+   | |_____^ help: try this: `V4(Ipv4Addr::LOCALHOST).is_ipv4()`
+
+error: redundant pattern matching, consider using `is_ipv6()`
+  --> $DIR/redundant_pattern_matching_ipaddr.rs:87:5
+   |
+LL | /     match V6(Ipv6Addr::LOCALHOST) {
+LL | |         V4(_) => false,
+LL | |         V6(_) => true,
+LL | |     };
+   | |_____^ help: try this: `V6(Ipv6Addr::LOCALHOST).is_ipv6()`
+
+error: aborting due to 18 previous errors
+
diff --git a/tests/ui/redundant_pattern_matching_option.fixed b/tests/ui/redundant_pattern_matching_option.fixed
index bc369dd2491..66f580a0a68 100644
--- a/tests/ui/redundant_pattern_matching_option.fixed
+++ b/tests/ui/redundant_pattern_matching_option.fixed
@@ -37,8 +37,7 @@ fn main() {
     let _ = None::<()>.is_none();
 
     let opt = Some(false);
-    let x = if opt.is_some() { true } else { false };
-    takes_bool(x);
+    let _ = if opt.is_some() { true } else { false };
 
     issue6067();
 
@@ -55,8 +54,6 @@ fn gen_opt() -> Option<()> {
     None
 }
 
-fn takes_bool(_: bool) {}
-
 fn foo() {}
 
 fn bar() {}
diff --git a/tests/ui/redundant_pattern_matching_option.rs b/tests/ui/redundant_pattern_matching_option.rs
index d7616a72913..f18b27b8b95 100644
--- a/tests/ui/redundant_pattern_matching_option.rs
+++ b/tests/ui/redundant_pattern_matching_option.rs
@@ -46,8 +46,7 @@ fn main() {
     };
 
     let opt = Some(false);
-    let x = if let Some(_) = opt { true } else { false };
-    takes_bool(x);
+    let _ = if let Some(_) = opt { true } else { false };
 
     issue6067();
 
@@ -64,8 +63,6 @@ fn gen_opt() -> Option<()> {
     None
 }
 
-fn takes_bool(_: bool) {}
-
 fn foo() {}
 
 fn bar() {}
diff --git a/tests/ui/redundant_pattern_matching_option.stderr b/tests/ui/redundant_pattern_matching_option.stderr
index 7ddfbe503a2..58482a0ab70 100644
--- a/tests/ui/redundant_pattern_matching_option.stderr
+++ b/tests/ui/redundant_pattern_matching_option.stderr
@@ -73,47 +73,47 @@ LL | |     };
 error: redundant pattern matching, consider using `is_some()`
   --> $DIR/redundant_pattern_matching_option.rs:49:20
    |
-LL |     let x = if let Some(_) = opt { true } else { false };
+LL |     let _ = 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:54:20
+  --> $DIR/redundant_pattern_matching_option.rs:53: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:56:19
+  --> $DIR/redundant_pattern_matching_option.rs:55: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:77:12
+  --> $DIR/redundant_pattern_matching_option.rs:74: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:79:12
+  --> $DIR/redundant_pattern_matching_option.rs:76: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:81:15
+  --> $DIR/redundant_pattern_matching_option.rs:78: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:83:15
+  --> $DIR/redundant_pattern_matching_option.rs:80: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:85:5
+  --> $DIR/redundant_pattern_matching_option.rs:82:5
    |
 LL | /     match Some(42) {
 LL | |         Some(_) => true,
@@ -122,7 +122,7 @@ LL | |     };
    | |_____^ help: try this: `Some(42).is_some()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:90:5
+  --> $DIR/redundant_pattern_matching_option.rs:87:5
    |
 LL | /     match None::<()> {
 LL | |         Some(_) => false,
diff --git a/tests/ui/redundant_pattern_matching_poll.fixed b/tests/ui/redundant_pattern_matching_poll.fixed
index 564c427f063..465aa80dac2 100644
--- a/tests/ui/redundant_pattern_matching_poll.fixed
+++ b/tests/ui/redundant_pattern_matching_poll.fixed
@@ -34,8 +34,7 @@ fn main() {
     let _ = Pending::<()>.is_pending();
 
     let poll = Ready(false);
-    let x = if poll.is_ready() { true } else { false };
-    takes_poll(x);
+    let _ = if poll.is_ready() { true } else { false };
 
     poll_const();
 
@@ -52,8 +51,6 @@ fn gen_poll() -> Poll<()> {
     Pending
 }
 
-fn takes_poll(_: bool) {}
-
 fn foo() {}
 
 fn bar() {}
diff --git a/tests/ui/redundant_pattern_matching_poll.rs b/tests/ui/redundant_pattern_matching_poll.rs
index d453d4184af..7891ff353b1 100644
--- a/tests/ui/redundant_pattern_matching_poll.rs
+++ b/tests/ui/redundant_pattern_matching_poll.rs
@@ -43,8 +43,7 @@ fn main() {
     };
 
     let poll = Ready(false);
-    let x = if let Ready(_) = poll { true } else { false };
-    takes_poll(x);
+    let _ = if let Ready(_) = poll { true } else { false };
 
     poll_const();
 
@@ -61,8 +60,6 @@ fn gen_poll() -> Poll<()> {
     Pending
 }
 
-fn takes_poll(_: bool) {}
-
 fn foo() {}
 
 fn bar() {}
diff --git a/tests/ui/redundant_pattern_matching_poll.stderr b/tests/ui/redundant_pattern_matching_poll.stderr
index 42e5d6f41fe..5ffc6c47c90 100644
--- a/tests/ui/redundant_pattern_matching_poll.stderr
+++ b/tests/ui/redundant_pattern_matching_poll.stderr
@@ -67,47 +67,47 @@ LL | |     };
 error: redundant pattern matching, consider using `is_ready()`
   --> $DIR/redundant_pattern_matching_poll.rs:46:20
    |
-LL |     let x = if let Ready(_) = poll { true } else { false };
+LL |     let _ = if let Ready(_) = poll { true } else { false };
    |             -------^^^^^^^^------- help: try this: `if poll.is_ready()`
 
 error: redundant pattern matching, consider using `is_ready()`
-  --> $DIR/redundant_pattern_matching_poll.rs:51:20
+  --> $DIR/redundant_pattern_matching_poll.rs:50:20
    |
 LL |     let _ = if let Ready(_) = gen_poll() {
    |             -------^^^^^^^^------------- help: try this: `if gen_poll().is_ready()`
 
 error: redundant pattern matching, consider using `is_pending()`
-  --> $DIR/redundant_pattern_matching_poll.rs:53:19
+  --> $DIR/redundant_pattern_matching_poll.rs:52:19
    |
 LL |     } else if let Pending = gen_poll() {
    |            -------^^^^^^^------------- help: try this: `if gen_poll().is_pending()`
 
 error: redundant pattern matching, consider using `is_ready()`
-  --> $DIR/redundant_pattern_matching_poll.rs:71:12
+  --> $DIR/redundant_pattern_matching_poll.rs:68:12
    |
 LL |     if let Ready(_) = Ready(42) {}
    |     -------^^^^^^^^------------ help: try this: `if Ready(42).is_ready()`
 
 error: redundant pattern matching, consider using `is_pending()`
-  --> $DIR/redundant_pattern_matching_poll.rs:73:12
+  --> $DIR/redundant_pattern_matching_poll.rs:70:12
    |
 LL |     if let Pending = Pending::<()> {}
    |     -------^^^^^^^---------------- help: try this: `if Pending::<()>.is_pending()`
 
 error: redundant pattern matching, consider using `is_ready()`
-  --> $DIR/redundant_pattern_matching_poll.rs:75:15
+  --> $DIR/redundant_pattern_matching_poll.rs:72:15
    |
 LL |     while let Ready(_) = Ready(42) {}
    |     ----------^^^^^^^^------------ help: try this: `while Ready(42).is_ready()`
 
 error: redundant pattern matching, consider using `is_pending()`
-  --> $DIR/redundant_pattern_matching_poll.rs:77:15
+  --> $DIR/redundant_pattern_matching_poll.rs:74:15
    |
 LL |     while let Pending = Pending::<()> {}
    |     ----------^^^^^^^---------------- help: try this: `while Pending::<()>.is_pending()`
 
 error: redundant pattern matching, consider using `is_ready()`
-  --> $DIR/redundant_pattern_matching_poll.rs:79:5
+  --> $DIR/redundant_pattern_matching_poll.rs:76:5
    |
 LL | /     match Ready(42) {
 LL | |         Ready(_) => true,
@@ -116,7 +116,7 @@ LL | |     };
    | |_____^ help: try this: `Ready(42).is_ready()`
 
 error: redundant pattern matching, consider using `is_pending()`
-  --> $DIR/redundant_pattern_matching_poll.rs:84:5
+  --> $DIR/redundant_pattern_matching_poll.rs:81:5
    |
 LL | /     match Pending::<()> {
 LL | |         Ready(_) => false,
-- 
cgit 1.4.1-3-g733a5


From aaa43250455c19ae54c821518c42219f6460038c Mon Sep 17 00:00:00 2001
From: Suyash458 <suyash.behera458@gmail.com>
Date: Wed, 21 Oct 2020 18:17:34 +0530
Subject: add support for minimum supported rust version.

add configuration option for minimum supported rust version
add msrv attribute to some lints listed in #6097
add tests
---
 clippy_lints/src/lib.rs                            | 23 ++++++--
 clippy_lints/src/manual_non_exhaustive.rs          | 33 ++++++++++-
 clippy_lints/src/manual_strip.rs                   | 37 ++++++++++--
 clippy_lints/src/matches.rs                        | 39 +++++++++++--
 clippy_lints/src/methods/mod.rs                    | 51 +++++++++++++---
 clippy_lints/src/utils/attrs.rs                    | 17 ++++++
 clippy_lints/src/utils/conf.rs                     |  2 +
 clippy_lints/src/utils/mod.rs                      | 49 ++++++++++++++++
 tests/ui-toml/invalid_min_rust_version/clippy.toml |  1 +
 .../invalid_min_rust_version.rs                    |  3 +
 .../invalid_min_rust_version.stderr                |  4 ++
 tests/ui-toml/min_rust_version/clippy.toml         |  1 +
 tests/ui-toml/min_rust_version/min_rust_version.rs | 68 ++++++++++++++++++++++
 .../toml_unknown_key/conf_unknown_key.stderr       |  2 +-
 tests/ui/min_rust_version_attr.rs                  | 51 ++++++++++++++++
 tests/ui/min_rust_version_invalid_attr.rs          |  4 ++
 tests/ui/min_rust_version_invalid_attr.stderr      |  8 +++
 tests/ui/min_rust_version_no_patch.rs              | 14 +++++
 tests/ui/min_rust_version_outer_attr.rs            |  4 ++
 tests/ui/min_rust_version_outer_attr.stderr        |  8 +++
 20 files changed, 390 insertions(+), 29 deletions(-)
 create mode 100644 tests/ui-toml/invalid_min_rust_version/clippy.toml
 create mode 100644 tests/ui-toml/invalid_min_rust_version/invalid_min_rust_version.rs
 create mode 100644 tests/ui-toml/invalid_min_rust_version/invalid_min_rust_version.stderr
 create mode 100644 tests/ui-toml/min_rust_version/clippy.toml
 create mode 100644 tests/ui-toml/min_rust_version/min_rust_version.rs
 create mode 100644 tests/ui/min_rust_version_attr.rs
 create mode 100644 tests/ui/min_rust_version_invalid_attr.rs
 create mode 100644 tests/ui/min_rust_version_invalid_attr.stderr
 create mode 100644 tests/ui/min_rust_version_no_patch.rs
 create mode 100644 tests/ui/min_rust_version_outer_attr.rs
 create mode 100644 tests/ui/min_rust_version_outer_attr.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 7e8cbd00c22..866dae110cc 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -44,6 +44,7 @@ extern crate rustc_target;
 extern crate rustc_trait_selection;
 extern crate rustc_typeck;
 
+use crate::utils::parse_msrv;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_lint::LintId;
 use rustc_session::Session;
@@ -933,7 +934,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &zero_div_zero::ZERO_DIVIDED_BY_ZERO,
     ]);
     // end register lints, do not remove this comment, it’s used in `update_lints`
-
     store.register_late_pass(|| box await_holding_invalid::AwaitHolding);
     store.register_late_pass(|| box serde_api::SerdeAPI);
     store.register_late_pass(|| box utils::internal_lints::CompilerLintFunctions::new());
@@ -969,7 +969,23 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box strings::StringAdd);
     store.register_late_pass(|| box implicit_return::ImplicitReturn);
     store.register_late_pass(|| box implicit_saturating_sub::ImplicitSaturatingSub);
-    store.register_late_pass(|| box methods::Methods);
+
+    let parsed_msrv = conf.msrv.as_ref().and_then(|s| {
+        parse_msrv(s, None, None).or_else(|| {
+            sess.err(&format!("error reading Clippy's configuration file. `{}` is not a valid Rust version", s));
+            None
+        })
+    });
+
+    let msrv = parsed_msrv.clone();
+    store.register_late_pass(move || box methods::Methods::new(msrv.clone()));
+    let msrv = parsed_msrv.clone();
+    store.register_late_pass(move || box matches::Matches::new(msrv.clone()));
+    let msrv = parsed_msrv.clone();
+    store.register_early_pass(move || box manual_non_exhaustive::ManualNonExhaustive::new(msrv.clone()));
+    let msrv = parsed_msrv;
+    store.register_late_pass(move || box manual_strip::ManualStrip::new(msrv.clone()));
+
     store.register_late_pass(|| box map_clone::MapClone);
     store.register_late_pass(|| box map_err_ignore::MapErrIgnore);
     store.register_late_pass(|| box shadow::Shadow);
@@ -983,7 +999,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box types::Casts);
     let type_complexity_threshold = conf.type_complexity_threshold;
     store.register_late_pass(move || box types::TypeComplexity::new(type_complexity_threshold));
-    store.register_late_pass(|| box matches::Matches::default());
     store.register_late_pass(|| box minmax::MinMaxPass);
     store.register_late_pass(|| box open_options::OpenOptions);
     store.register_late_pass(|| box zero_div_zero::ZeroDiv);
@@ -1144,7 +1159,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box if_let_mutex::IfLetMutex);
     store.register_late_pass(|| box mut_mutex_lock::MutMutexLock);
     store.register_late_pass(|| box match_on_vec_items::MatchOnVecItems);
-    store.register_early_pass(|| box manual_non_exhaustive::ManualNonExhaustive);
     store.register_late_pass(|| box manual_async_fn::ManualAsyncFn);
     store.register_early_pass(|| box redundant_field_names::RedundantFieldNames);
     store.register_late_pass(|| box vec_resize_to_zero::VecResizeToZero);
@@ -1166,7 +1180,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box manual_ok_or::ManualOkOr);
     store.register_late_pass(|| box float_equality_without_abs::FloatEqualityWithoutAbs);
     store.register_late_pass(|| box async_yields_async::AsyncYieldsAsync);
-    store.register_late_pass(|| box manual_strip::ManualStrip);
     store.register_late_pass(|| box utils::internal_lints::MatchTypeOnDiagItem);
     let disallowed_methods = conf.disallowed_methods.iter().cloned().collect::<FxHashSet<_>>();
     store.register_late_pass(move || box disallowed_method::DisallowedMethod::new(&disallowed_methods));
diff --git a/clippy_lints/src/manual_non_exhaustive.rs b/clippy_lints/src/manual_non_exhaustive.rs
index a1450b0d5fe..4762ba16ac7 100644
--- a/clippy_lints/src/manual_non_exhaustive.rs
+++ b/clippy_lints/src/manual_non_exhaustive.rs
@@ -1,11 +1,20 @@
-use crate::utils::{snippet_opt, span_lint_and_then};
+use crate::utils::{get_inner_attr, meets_msrv, snippet_opt, span_lint_and_then};
 use if_chain::if_chain;
 use rustc_ast::ast::{Attribute, Item, ItemKind, StructField, Variant, VariantData, VisibilityKind};
 use rustc_attr as attr;
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::{sym, Span};
+use semver::{Version, VersionReq};
+
+const MANUAL_NON_EXHAUSTIVE_MSRV: Version = Version {
+    major: 1,
+    minor: 40,
+    patch: 0,
+    pre: Vec::new(),
+    build: Vec::new(),
+};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for manual implementations of the non-exhaustive pattern.
@@ -55,10 +64,26 @@ declare_clippy_lint! {
     "manual implementations of the non-exhaustive pattern can be simplified using #[non_exhaustive]"
 }
 
-declare_lint_pass!(ManualNonExhaustive => [MANUAL_NON_EXHAUSTIVE]);
+#[derive(Clone)]
+pub struct ManualNonExhaustive {
+    msrv: Option<VersionReq>,
+}
+
+impl ManualNonExhaustive {
+    #[must_use]
+    pub fn new(msrv: Option<VersionReq>) -> Self {
+        Self { msrv }
+    }
+}
+
+impl_lint_pass!(ManualNonExhaustive => [MANUAL_NON_EXHAUSTIVE]);
 
 impl EarlyLintPass for ManualNonExhaustive {
     fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {
+        if !meets_msrv(self.msrv.as_ref(), &MANUAL_NON_EXHAUSTIVE_MSRV) {
+            return;
+        }
+
         match &item.kind {
             ItemKind::Enum(def, _) => {
                 check_manual_non_exhaustive_enum(cx, item, &def.variants);
@@ -73,6 +98,8 @@ impl EarlyLintPass for ManualNonExhaustive {
             _ => {},
         }
     }
+
+    extract_msrv_attr!(EarlyContext);
 }
 
 fn check_manual_non_exhaustive_enum(cx: &EarlyContext<'_>, item: &Item, variants: &[Variant]) {
diff --git a/clippy_lints/src/manual_strip.rs b/clippy_lints/src/manual_strip.rs
index 4afb0ab3bad..446641ca114 100644
--- a/clippy_lints/src/manual_strip.rs
+++ b/clippy_lints/src/manual_strip.rs
@@ -1,21 +1,31 @@
 use crate::consts::{constant, Constant};
 use crate::utils::usage::mutated_variables;
 use crate::utils::{
-    eq_expr_value, higher, match_def_path, multispan_sugg, paths, qpath_res, snippet, span_lint_and_then,
+    eq_expr_value, get_inner_attr, higher, match_def_path, meets_msrv, multispan_sugg, paths, qpath_res, snippet,
+    span_lint_and_then,
 };
 
 use if_chain::if_chain;
-use rustc_ast::ast::LitKind;
+use rustc_ast::ast::{Attribute, LitKind};
 use rustc_hir::def::Res;
 use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
 use rustc_hir::BinOpKind;
 use rustc_hir::{BorrowKind, Expr, ExprKind};
-use rustc_lint::{LateContext, LateLintPass};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::hir::map::Map;
 use rustc_middle::ty;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::Spanned;
 use rustc_span::Span;
+use semver::{Version, VersionReq};
+
+const MANUAL_STRIP_MSRV: Version = Version {
+    major: 1,
+    minor: 45,
+    patch: 0,
+    pre: Vec::new(),
+    build: Vec::new(),
+};
 
 declare_clippy_lint! {
     /// **What it does:**
@@ -51,7 +61,18 @@ declare_clippy_lint! {
     "suggests using `strip_{prefix,suffix}` over `str::{starts,ends}_with` and slicing"
 }
 
-declare_lint_pass!(ManualStrip => [MANUAL_STRIP]);
+pub struct ManualStrip {
+    msrv: Option<VersionReq>,
+}
+
+impl ManualStrip {
+    #[must_use]
+    pub fn new(msrv: Option<VersionReq>) -> Self {
+        Self { msrv }
+    }
+}
+
+impl_lint_pass!(ManualStrip => [MANUAL_STRIP]);
 
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 enum StripKind {
@@ -61,6 +82,10 @@ enum StripKind {
 
 impl<'tcx> LateLintPass<'tcx> for ManualStrip {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        if !meets_msrv(self.msrv.as_ref(), &MANUAL_STRIP_MSRV) {
+            return;
+        }
+
         if_chain! {
             if let Some((cond, then, _)) = higher::if_block(&expr);
             if let ExprKind::MethodCall(_, _, [target_arg, pattern], _) = cond.kind;
@@ -114,6 +139,8 @@ impl<'tcx> LateLintPass<'tcx> for ManualStrip {
             }
         }
     }
+
+    extract_msrv_attr!(LateContext);
 }
 
 // Returns `Some(arg)` if `expr` matches `arg.len()` and `None` otherwise.
diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index af59917e801..5c38abbd9c6 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -2,14 +2,14 @@ use crate::consts::{constant, miri_to_const, Constant};
 use crate::utils::sugg::Sugg;
 use crate::utils::usage::is_unused;
 use crate::utils::{
-    expr_block, get_arg_name, get_parent_expr, in_macro, indent_of, is_allowed, is_expn_of, is_refutable,
-    is_type_diagnostic_item, is_wild, match_qpath, match_type, match_var, multispan_sugg, remove_blocks, snippet,
-    snippet_block, snippet_with_applicability, span_lint_and_help, span_lint_and_note, span_lint_and_sugg,
-    span_lint_and_then,
+    expr_block, get_arg_name, get_inner_attr, get_parent_expr, in_macro, indent_of, is_allowed, is_expn_of,
+    is_refutable, is_type_diagnostic_item, is_wild, match_qpath, match_type, match_var, meets_msrv, multispan_sugg,
+    remove_blocks, snippet, snippet_block, snippet_with_applicability, span_lint_and_help, span_lint_and_note,
+    span_lint_and_sugg, span_lint_and_then,
 };
 use crate::utils::{paths, search_same, SpanlessEq, SpanlessHash};
 use if_chain::if_chain;
-use rustc_ast::ast::LitKind;
+use rustc_ast::ast::{Attribute, LitKind};
 use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::Applicability;
 use rustc_hir::def::CtorKind;
@@ -23,6 +23,7 @@ use rustc_middle::ty::{self, Ty, TyS};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::{Span, Spanned};
 use rustc_span::{sym, Symbol};
+use semver::{Version, VersionReq};
 use std::cmp::Ordering;
 use std::collections::hash_map::Entry;
 use std::collections::Bound;
@@ -527,9 +528,20 @@ declare_clippy_lint! {
 
 #[derive(Default)]
 pub struct Matches {
+    msrv: Option<VersionReq>,
     infallible_destructuring_match_linted: bool,
 }
 
+impl Matches {
+    #[must_use]
+    pub fn new(msrv: Option<VersionReq>) -> Self {
+        Self {
+            msrv,
+            ..Matches::default()
+        }
+    }
+}
+
 impl_lint_pass!(Matches => [
     SINGLE_MATCH,
     MATCH_REF_PATS,
@@ -549,6 +561,14 @@ impl_lint_pass!(Matches => [
     MATCH_SAME_ARMS,
 ]);
 
+const MATCH_LIKE_MATCHES_MACRO_MSRV: Version = Version {
+    major: 1,
+    minor: 42,
+    patch: 0,
+    pre: Vec::new(),
+    build: Vec::new(),
+};
+
 impl<'tcx> LateLintPass<'tcx> for Matches {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if in_external_macro(cx.sess(), expr.span) || in_macro(expr.span) {
@@ -556,7 +576,12 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
         }
 
         redundant_pattern_match::check(cx, expr);
-        if !check_match_like_matches(cx, expr) {
+
+        if meets_msrv(self.msrv.as_ref(), &MATCH_LIKE_MATCHES_MACRO_MSRV) {
+            if !check_match_like_matches(cx, expr) {
+                lint_match_arms(cx, expr);
+            }
+        } else {
             lint_match_arms(cx, expr);
         }
 
@@ -640,6 +665,8 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
             }
         }
     }
+
+    extract_msrv_attr!(LateContext);
 }
 
 #[rustfmt::skip]
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index fa174404365..6b478986067 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -12,6 +12,7 @@ use std::iter;
 use bind_instead_of_map::BindInsteadOfMap;
 use if_chain::if_chain;
 use rustc_ast::ast;
+use rustc_ast::ast::Attribute;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_hir::intravisit::{self, Visitor};
@@ -20,7 +21,7 @@ use rustc_lint::{LateContext, LateLintPass, Lint, LintContext};
 use rustc_middle::hir::map::Map;
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::{self, TraitRef, Ty, TyS};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::Span;
 use rustc_span::symbol::{sym, SymbolStr};
 
@@ -28,12 +29,14 @@ use crate::consts::{constant, Constant};
 use crate::utils::eager_or_lazy::is_lazyness_candidate;
 use crate::utils::usage::mutated_variables;
 use crate::utils::{
-    contains_ty, get_arg_name, get_parent_expr, get_trait_def_id, has_iter_method, higher, implements_trait, in_macro,
-    is_copy, is_expn_of, is_type_diagnostic_item, iter_input_pats, last_path_segment, match_def_path, match_qpath,
-    match_trait_method, match_type, match_var, method_calls, method_chain_args, paths, remove_blocks, return_ty,
-    single_segment_path, snippet, snippet_with_applicability, snippet_with_macro_callsite, span_lint,
-    span_lint_and_help, span_lint_and_sugg, span_lint_and_then, sugg, walk_ptrs_ty_depth, SpanlessEq,
+    contains_ty, get_arg_name, get_inner_attr, get_parent_expr, get_trait_def_id, has_iter_method, higher,
+    implements_trait, in_macro, is_copy, is_expn_of, is_type_diagnostic_item, iter_input_pats, last_path_segment,
+    match_def_path, match_qpath, match_trait_method, match_type, match_var, meets_msrv, method_calls,
+    method_chain_args, paths, remove_blocks, return_ty, single_segment_path, snippet, snippet_with_applicability,
+    snippet_with_macro_callsite, span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then, sugg,
+    walk_ptrs_ty_depth, SpanlessEq,
 };
+use semver::{Version, VersionReq};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for `.unwrap()` calls on `Option`s and on `Result`s.
@@ -1404,7 +1407,18 @@ declare_clippy_lint! {
     "use `.collect()` instead of `::from_iter()`"
 }
 
-declare_lint_pass!(Methods => [
+pub struct Methods {
+    msrv: Option<VersionReq>,
+}
+
+impl Methods {
+    #[must_use]
+    pub fn new(msrv: Option<VersionReq>) -> Self {
+        Self { msrv }
+    }
+}
+
+impl_lint_pass!(Methods => [
     UNWRAP_USED,
     EXPECT_USED,
     SHOULD_IMPLEMENT_TRAIT,
@@ -1531,8 +1545,12 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
                 check_pointer_offset(cx, expr, arg_lists[0])
             },
             ["is_file", ..] => lint_filetype_is_file(cx, expr, arg_lists[0]),
-            ["map", "as_ref"] => lint_option_as_ref_deref(cx, expr, arg_lists[1], arg_lists[0], false),
-            ["map", "as_mut"] => lint_option_as_ref_deref(cx, expr, arg_lists[1], arg_lists[0], true),
+            ["map", "as_ref"] => {
+                lint_option_as_ref_deref(cx, expr, arg_lists[1], arg_lists[0], false, self.msrv.as_ref())
+            },
+            ["map", "as_mut"] => {
+                lint_option_as_ref_deref(cx, expr, arg_lists[1], arg_lists[0], true, self.msrv.as_ref())
+            },
             ["unwrap_or_else", ..] => unnecessary_lazy_eval::lint(cx, expr, arg_lists[0], "unwrap_or"),
             ["get_or_insert_with", ..] => unnecessary_lazy_eval::lint(cx, expr, arg_lists[0], "get_or_insert"),
             ["ok_or_else", ..] => unnecessary_lazy_eval::lint(cx, expr, arg_lists[0], "ok_or"),
@@ -1738,6 +1756,8 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             }
         }
     }
+
+    extract_msrv_attr!(LateContext);
 }
 
 /// Checks for the `OR_FUN_CALL` lint.
@@ -3453,6 +3473,14 @@ fn lint_suspicious_map(cx: &LateContext<'_>, expr: &hir::Expr<'_>) {
     );
 }
 
+const OPTION_AS_REF_DEREF_MSRV: Version = Version {
+    major: 1,
+    minor: 40,
+    patch: 0,
+    pre: Vec::new(),
+    build: Vec::new(),
+};
+
 /// lint use of `_.as_ref().map(Deref::deref)` for `Option`s
 fn lint_option_as_ref_deref<'tcx>(
     cx: &LateContext<'tcx>,
@@ -3460,7 +3488,12 @@ fn lint_option_as_ref_deref<'tcx>(
     as_ref_args: &[hir::Expr<'_>],
     map_args: &[hir::Expr<'_>],
     is_mut: bool,
+    msrv: Option<&VersionReq>,
 ) {
+    if !meets_msrv(msrv, &OPTION_AS_REF_DEREF_MSRV) {
+        return;
+    }
+
     let same_mutability = |m| (is_mut && m == &hir::Mutability::Mut) || (!is_mut && m == &hir::Mutability::Not);
 
     let option_ty = cx.typeck_results().expr_ty(&as_ref_args[0]);
diff --git a/clippy_lints/src/utils/attrs.rs b/clippy_lints/src/utils/attrs.rs
index e6d41341a55..aed6ee5dc57 100644
--- a/clippy_lints/src/utils/attrs.rs
+++ b/clippy_lints/src/utils/attrs.rs
@@ -21,6 +21,7 @@ pub const BUILTIN_ATTRIBUTES: &[(&str, DeprecationStatus)] = &[
         DeprecationStatus::Replaced("cognitive_complexity"),
     ),
     ("dump", DeprecationStatus::None),
+    ("msrv", DeprecationStatus::None),
 ];
 
 pub struct LimitStack {
@@ -123,6 +124,22 @@ fn parse_attrs<F: FnMut(u64)>(sess: &Session, attrs: &[ast::Attribute], name: &'
     }
 }
 
+pub fn get_unique_inner_attr(sess: &Session, attrs: &[ast::Attribute], name: &'static str) -> Option<ast::Attribute> {
+    let mut unique_attr = None;
+    for attr in get_attr(sess, attrs, name) {
+        match attr.style {
+            ast::AttrStyle::Inner if unique_attr.is_none() => unique_attr = Some(attr.clone()),
+            ast::AttrStyle::Inner => {
+                sess.span_err(attr.span, &format!("`{}` is defined multiple times", name));
+            },
+            ast::AttrStyle::Outer => {
+                sess.span_err(attr.span, &format!("`{}` cannot be an outer attribute", name));
+            },
+        }
+    }
+    unique_attr
+}
+
 /// Return true if the attributes contain any of `proc_macro`,
 /// `proc_macro_derive` or `proc_macro_attribute`, false otherwise
 pub fn is_proc_macro(sess: &Session, attrs: &[ast::Attribute]) -> bool {
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 0ac8fff69f0..fc6304118d9 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -106,6 +106,8 @@ macro_rules! define_Conf {
 
 pub use self::helpers::Conf;
 define_Conf! {
+    /// Lint: MANUAL_NON_EXHAUSTIVE, MANUAL_STRIP, OPTION_AS_REF_DEREF, MATCH_LIKE_MATCHES_MACRO. The minimum rust version that the project supports
+    (msrv, "msrv": Option<String>, None),
     /// Lint: BLACKLISTED_NAME. The list of blacklisted names to lint about. NB: `bar` is not here since it has legitimate uses
     (blacklisted_names, "blacklisted_names": Vec<String>, ["foo", "baz", "quux"].iter().map(ToString::to_string).collect()),
     /// Lint: COGNITIVE_COMPLEXITY. The maximum cognitive complexity a function can have
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index e9c71e23a67..f8e88512048 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -51,6 +51,7 @@ use rustc_lint::{LateContext, Level, Lint, LintContext};
 use rustc_middle::hir::map::Map;
 use rustc_middle::ty::subst::{GenericArg, GenericArgKind};
 use rustc_middle::ty::{self, layout::IntegerExt, Ty, TyCtxt, TypeFoldable};
+use rustc_session::Session;
 use rustc_span::hygiene::{ExpnKind, MacroKind};
 use rustc_span::source_map::original_sp;
 use rustc_span::sym as rustc_sym;
@@ -58,10 +59,58 @@ use rustc_span::symbol::{self, kw, Symbol};
 use rustc_span::{BytePos, Pos, Span, DUMMY_SP};
 use rustc_target::abi::Integer;
 use rustc_trait_selection::traits::query::normalize::AtExt;
+use semver::{Version, VersionReq};
 use smallvec::SmallVec;
 
 use crate::consts::{constant, Constant};
 
+pub fn parse_msrv(msrv: &str, sess: Option<&Session>, span: Option<Span>) -> Option<VersionReq> {
+    if let Ok(version) = VersionReq::parse(msrv) {
+        return Some(version);
+    } else if let Some(sess) = sess {
+        if let Some(span) = span {
+            sess.span_err(span, &format!("`{}` is not a valid Rust version", msrv));
+        }
+    }
+    None
+}
+
+pub fn meets_msrv(msrv: Option<&VersionReq>, lint_msrv: &Version) -> bool {
+    msrv.map_or(true, |msrv| !msrv.matches(lint_msrv))
+}
+
+#[macro_export]
+macro_rules! extract_msrv_attr {
+    (LateContext) => {
+        fn enter_lint_attrs(&mut self, cx: &rustc_lint::LateContext<'tcx>, attrs: &'tcx [Attribute]) {
+            match get_inner_attr(cx.sess(), attrs, "msrv") {
+                Some(msrv_attr) => {
+                    if let Some(msrv) = msrv_attr.value_str() {
+                        self.msrv = crate::utils::parse_msrv(&msrv.to_string(), Some(cx.sess()), Some(msrv_attr.span));
+                    } else {
+                        cx.sess().span_err(msrv_attr.span, "bad clippy attribute");
+                    }
+                },
+                _ => (),
+            }
+        }
+    };
+    (EarlyContext) => {
+        fn enter_lint_attrs(&mut self, cx: &rustc_lint::EarlyContext<'tcx>, attrs: &'tcx [Attribute]) {
+            match get_inner_attr(cx.sess, attrs, "msrv") {
+                Some(msrv_attr) => {
+                    if let Some(msrv) = msrv_attr.value_str() {
+                        self.msrv = crate::utils::parse_msrv(&msrv.to_string(), Some(cx.sess), Some(msrv_attr.span));
+                    } else {
+                        cx.sess.span_err(msrv_attr.span, "bad clippy attribute");
+                    }
+                },
+                _ => (),
+            }
+        }
+    };
+}
+
 /// Returns `true` if the two spans come from differing expansions (i.e., one is
 /// from a macro and one isn't).
 #[must_use]
diff --git a/tests/ui-toml/invalid_min_rust_version/clippy.toml b/tests/ui-toml/invalid_min_rust_version/clippy.toml
new file mode 100644
index 00000000000..088b12b2dac
--- /dev/null
+++ b/tests/ui-toml/invalid_min_rust_version/clippy.toml
@@ -0,0 +1 @@
+msrv = "invalid.version"
diff --git a/tests/ui-toml/invalid_min_rust_version/invalid_min_rust_version.rs b/tests/ui-toml/invalid_min_rust_version/invalid_min_rust_version.rs
new file mode 100644
index 00000000000..2ebf28645e5
--- /dev/null
+++ b/tests/ui-toml/invalid_min_rust_version/invalid_min_rust_version.rs
@@ -0,0 +1,3 @@
+#![allow(clippy::redundant_clone)]
+
+fn main() {}
diff --git a/tests/ui-toml/invalid_min_rust_version/invalid_min_rust_version.stderr b/tests/ui-toml/invalid_min_rust_version/invalid_min_rust_version.stderr
new file mode 100644
index 00000000000..e9d8fd2e0f5
--- /dev/null
+++ b/tests/ui-toml/invalid_min_rust_version/invalid_min_rust_version.stderr
@@ -0,0 +1,4 @@
+error: error reading Clippy's configuration file. `invalid.version` is not a valid Rust version
+
+error: aborting due to previous error
+
diff --git a/tests/ui-toml/min_rust_version/clippy.toml b/tests/ui-toml/min_rust_version/clippy.toml
new file mode 100644
index 00000000000..8e17d8074c4
--- /dev/null
+++ b/tests/ui-toml/min_rust_version/clippy.toml
@@ -0,0 +1 @@
+msrv = "1.0.0"
diff --git a/tests/ui-toml/min_rust_version/min_rust_version.rs b/tests/ui-toml/min_rust_version/min_rust_version.rs
new file mode 100644
index 00000000000..bc41efa42a1
--- /dev/null
+++ b/tests/ui-toml/min_rust_version/min_rust_version.rs
@@ -0,0 +1,68 @@
+#![allow(clippy::redundant_clone)]
+#![warn(clippy::manual_non_exhaustive)]
+
+use std::ops::Deref;
+
+mod enums {
+    enum E {
+        A,
+        B,
+        #[doc(hidden)]
+        _C,
+    }
+
+    // user forgot to remove the marker
+    #[non_exhaustive]
+    enum Ep {
+        A,
+        B,
+        #[doc(hidden)]
+        _C,
+    }
+}
+
+fn option_as_ref_deref() {
+    let mut opt = Some(String::from("123"));
+
+    let _ = opt.as_ref().map(String::as_str);
+    let _ = opt.as_ref().map(|x| x.as_str());
+    let _ = opt.as_mut().map(String::as_mut_str);
+    let _ = opt.as_mut().map(|x| x.as_mut_str());
+}
+
+fn match_like_matches() {
+    let _y = match Some(5) {
+        Some(0) => true,
+        _ => false,
+    };
+}
+
+fn match_same_arms() {
+    match (1, 2, 3) {
+        (1, .., 3) => 42,
+        (.., 3) => 42, //~ ERROR match arms have same body
+        _ => 0,
+    };
+}
+
+fn match_same_arms2() {
+    let _ = match Some(42) {
+        Some(_) => 24,
+        None => 24, //~ ERROR match arms have same body
+    };
+}
+
+fn manual_strip_msrv() {
+    let s = "hello, world!";
+    if s.starts_with("hello, ") {
+        assert_eq!(s["hello, ".len()..].to_uppercase(), "WORLD!");
+    }
+}
+
+fn main() {
+    option_as_ref_deref();
+    match_like_matches();
+    match_same_arms();
+    match_same_arms2();
+    manual_strip_msrv();
+}
diff --git a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
index a58e7e918e2..af3d9ecf6e8 100644
--- a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
+++ b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
@@ -1,4 +1,4 @@
-error: error reading Clippy's configuration file `$DIR/clippy.toml`: unknown field `foobar`, expected one of `blacklisted-names`, `cognitive-complexity-threshold`, `cyclomatic-complexity-threshold`, `doc-valid-idents`, `too-many-arguments-threshold`, `type-complexity-threshold`, `single-char-binding-names-threshold`, `too-large-for-stack`, `enum-variant-name-threshold`, `enum-variant-size-threshold`, `verbose-bit-mask-threshold`, `literal-representation-threshold`, `trivial-copy-size-limit`, `pass-by-value-size-limit`, `too-many-lines-threshold`, `array-size-threshold`, `vec-box-size-threshold`, `max-trait-bounds`, `max-struct-bools`, `max-fn-params-bools`, `warn-on-all-wildcard-imports`, `disallowed-methods`, `third-party` at line 5 column 1
+error: error reading Clippy's configuration file `$DIR/clippy.toml`: unknown field `foobar`, expected one of `msrv`, `blacklisted-names`, `cognitive-complexity-threshold`, `cyclomatic-complexity-threshold`, `doc-valid-idents`, `too-many-arguments-threshold`, `type-complexity-threshold`, `single-char-binding-names-threshold`, `too-large-for-stack`, `enum-variant-name-threshold`, `enum-variant-size-threshold`, `verbose-bit-mask-threshold`, `literal-representation-threshold`, `trivial-copy-size-limit`, `pass-by-value-size-limit`, `too-many-lines-threshold`, `array-size-threshold`, `vec-box-size-threshold`, `max-trait-bounds`, `max-struct-bools`, `max-fn-params-bools`, `warn-on-all-wildcard-imports`, `disallowed-methods`, `third-party` at line 5 column 1
 
 error: aborting due to previous error
 
diff --git a/tests/ui/min_rust_version_attr.rs b/tests/ui/min_rust_version_attr.rs
new file mode 100644
index 00000000000..8ed483a3ac6
--- /dev/null
+++ b/tests/ui/min_rust_version_attr.rs
@@ -0,0 +1,51 @@
+#![allow(clippy::redundant_clone)]
+#![feature(custom_inner_attributes)]
+#![clippy::msrv = "1.0.0"]
+
+use std::ops::Deref;
+
+fn option_as_ref_deref() {
+    let mut opt = Some(String::from("123"));
+
+    let _ = opt.as_ref().map(String::as_str);
+    let _ = opt.as_ref().map(|x| x.as_str());
+    let _ = opt.as_mut().map(String::as_mut_str);
+    let _ = opt.as_mut().map(|x| x.as_mut_str());
+}
+
+fn match_like_matches() {
+    let _y = match Some(5) {
+        Some(0) => true,
+        _ => false,
+    };
+}
+
+fn match_same_arms() {
+    match (1, 2, 3) {
+        (1, .., 3) => 42,
+        (.., 3) => 42, //~ ERROR match arms have same body
+        _ => 0,
+    };
+}
+
+fn match_same_arms2() {
+    let _ = match Some(42) {
+        Some(_) => 24,
+        None => 24, //~ ERROR match arms have same body
+    };
+}
+
+fn manual_strip_msrv() {
+    let s = "hello, world!";
+    if s.starts_with("hello, ") {
+        assert_eq!(s["hello, ".len()..].to_uppercase(), "WORLD!");
+    }
+}
+
+fn main() {
+    option_as_ref_deref();
+    match_like_matches();
+    match_same_arms();
+    match_same_arms2();
+    manual_strip_msrv();
+}
diff --git a/tests/ui/min_rust_version_invalid_attr.rs b/tests/ui/min_rust_version_invalid_attr.rs
new file mode 100644
index 00000000000..f20841891a7
--- /dev/null
+++ b/tests/ui/min_rust_version_invalid_attr.rs
@@ -0,0 +1,4 @@
+#![feature(custom_inner_attributes)]
+#![clippy::msrv = "invalid.version"]
+
+fn main() {}
diff --git a/tests/ui/min_rust_version_invalid_attr.stderr b/tests/ui/min_rust_version_invalid_attr.stderr
new file mode 100644
index 00000000000..6ff88ca56f8
--- /dev/null
+++ b/tests/ui/min_rust_version_invalid_attr.stderr
@@ -0,0 +1,8 @@
+error: `invalid.version` is not a valid Rust version
+  --> $DIR/min_rust_version_invalid_attr.rs:2:1
+   |
+LL | #![clippy::msrv = "invalid.version"]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to previous error
+
diff --git a/tests/ui/min_rust_version_no_patch.rs b/tests/ui/min_rust_version_no_patch.rs
new file mode 100644
index 00000000000..515fe8f95e9
--- /dev/null
+++ b/tests/ui/min_rust_version_no_patch.rs
@@ -0,0 +1,14 @@
+#![allow(clippy::redundant_clone)]
+#![feature(custom_inner_attributes)]
+#![clippy::msrv = "^1.0"]
+
+fn manual_strip_msrv() {
+    let s = "hello, world!";
+    if s.starts_with("hello, ") {
+        assert_eq!(s["hello, ".len()..].to_uppercase(), "WORLD!");
+    }
+}
+
+fn main() {
+    manual_strip_msrv()
+}
diff --git a/tests/ui/min_rust_version_outer_attr.rs b/tests/ui/min_rust_version_outer_attr.rs
new file mode 100644
index 00000000000..551948bd72e
--- /dev/null
+++ b/tests/ui/min_rust_version_outer_attr.rs
@@ -0,0 +1,4 @@
+#![feature(custom_inner_attributes)]
+
+#[clippy::msrv = "invalid.version"]
+fn main() {}
diff --git a/tests/ui/min_rust_version_outer_attr.stderr b/tests/ui/min_rust_version_outer_attr.stderr
new file mode 100644
index 00000000000..579ee7a87d2
--- /dev/null
+++ b/tests/ui/min_rust_version_outer_attr.stderr
@@ -0,0 +1,8 @@
+error: `msrv` cannot be an outer attribute
+  --> $DIR/min_rust_version_outer_attr.rs:3:1
+   |
+LL | #[clippy::msrv = "invalid.version"]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to previous error
+
-- 
cgit 1.4.1-3-g733a5


From b2e2c0806ec2296bf7d98e0db5cc9c39a55f23ac Mon Sep 17 00:00:00 2001
From: flip1995 <philipp.krones@embecosm.com>
Date: Wed, 25 Nov 2020 11:50:13 +0100
Subject: Improve extract_msrv_attr! situation

---
 clippy_lints/src/manual_non_exhaustive.rs |  2 +-
 clippy_lints/src/manual_strip.rs          |  5 ++---
 clippy_lints/src/matches.rs               | 10 +++++-----
 clippy_lints/src/methods/mod.rs           | 12 +++++-------
 clippy_lints/src/utils/mod.rs             | 30 +++++++++++++-----------------
 5 files changed, 26 insertions(+), 33 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_non_exhaustive.rs b/clippy_lints/src/manual_non_exhaustive.rs
index 4762ba16ac7..703e6feeca5 100644
--- a/clippy_lints/src/manual_non_exhaustive.rs
+++ b/clippy_lints/src/manual_non_exhaustive.rs
@@ -1,4 +1,4 @@
-use crate::utils::{get_inner_attr, meets_msrv, snippet_opt, span_lint_and_then};
+use crate::utils::{meets_msrv, snippet_opt, span_lint_and_then};
 use if_chain::if_chain;
 use rustc_ast::ast::{Attribute, Item, ItemKind, StructField, Variant, VariantData, VisibilityKind};
 use rustc_attr as attr;
diff --git a/clippy_lints/src/manual_strip.rs b/clippy_lints/src/manual_strip.rs
index 446641ca114..e17e3adb94f 100644
--- a/clippy_lints/src/manual_strip.rs
+++ b/clippy_lints/src/manual_strip.rs
@@ -1,12 +1,11 @@
 use crate::consts::{constant, Constant};
 use crate::utils::usage::mutated_variables;
 use crate::utils::{
-    eq_expr_value, get_inner_attr, higher, match_def_path, meets_msrv, multispan_sugg, paths, qpath_res, snippet,
-    span_lint_and_then,
+    eq_expr_value, higher, match_def_path, meets_msrv, multispan_sugg, paths, qpath_res, snippet, span_lint_and_then,
 };
 
 use if_chain::if_chain;
-use rustc_ast::ast::{Attribute, LitKind};
+use rustc_ast::ast::LitKind;
 use rustc_hir::def::Res;
 use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
 use rustc_hir::BinOpKind;
diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index 5c38abbd9c6..d695af4de21 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -2,14 +2,14 @@ use crate::consts::{constant, miri_to_const, Constant};
 use crate::utils::sugg::Sugg;
 use crate::utils::usage::is_unused;
 use crate::utils::{
-    expr_block, get_arg_name, get_inner_attr, get_parent_expr, in_macro, indent_of, is_allowed, is_expn_of,
-    is_refutable, is_type_diagnostic_item, is_wild, match_qpath, match_type, match_var, meets_msrv, multispan_sugg,
-    remove_blocks, snippet, snippet_block, snippet_with_applicability, span_lint_and_help, span_lint_and_note,
-    span_lint_and_sugg, span_lint_and_then,
+    expr_block, get_arg_name, get_parent_expr, in_macro, indent_of, is_allowed, is_expn_of, is_refutable,
+    is_type_diagnostic_item, is_wild, match_qpath, match_type, match_var, meets_msrv, multispan_sugg, remove_blocks,
+    snippet, snippet_block, snippet_with_applicability, span_lint_and_help, span_lint_and_note, span_lint_and_sugg,
+    span_lint_and_then,
 };
 use crate::utils::{paths, search_same, SpanlessEq, SpanlessHash};
 use if_chain::if_chain;
-use rustc_ast::ast::{Attribute, LitKind};
+use rustc_ast::ast::LitKind;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::Applicability;
 use rustc_hir::def::CtorKind;
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 6b478986067..50dd760432d 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -12,7 +12,6 @@ use std::iter;
 use bind_instead_of_map::BindInsteadOfMap;
 use if_chain::if_chain;
 use rustc_ast::ast;
-use rustc_ast::ast::Attribute;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_hir::intravisit::{self, Visitor};
@@ -29,12 +28,11 @@ use crate::consts::{constant, Constant};
 use crate::utils::eager_or_lazy::is_lazyness_candidate;
 use crate::utils::usage::mutated_variables;
 use crate::utils::{
-    contains_ty, get_arg_name, get_inner_attr, get_parent_expr, get_trait_def_id, has_iter_method, higher,
-    implements_trait, in_macro, is_copy, is_expn_of, is_type_diagnostic_item, iter_input_pats, last_path_segment,
-    match_def_path, match_qpath, match_trait_method, match_type, match_var, meets_msrv, method_calls,
-    method_chain_args, paths, remove_blocks, return_ty, single_segment_path, snippet, snippet_with_applicability,
-    snippet_with_macro_callsite, span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then, sugg,
-    walk_ptrs_ty_depth, SpanlessEq,
+    contains_ty, get_arg_name, get_parent_expr, get_trait_def_id, has_iter_method, higher, implements_trait, in_macro,
+    is_copy, is_expn_of, is_type_diagnostic_item, iter_input_pats, last_path_segment, match_def_path, match_qpath,
+    match_trait_method, match_type, match_var, meets_msrv, method_calls, method_chain_args, paths, remove_blocks,
+    return_ty, single_segment_path, snippet, snippet_with_applicability, snippet_with_macro_callsite, span_lint,
+    span_lint_and_help, span_lint_and_sugg, span_lint_and_then, sugg, walk_ptrs_ty_depth, SpanlessEq,
 };
 use semver::{Version, VersionReq};
 
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index f8e88512048..6f89e51279a 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -79,30 +79,26 @@ pub fn meets_msrv(msrv: Option<&VersionReq>, lint_msrv: &Version) -> bool {
     msrv.map_or(true, |msrv| !msrv.matches(lint_msrv))
 }
 
-#[macro_export]
 macro_rules! extract_msrv_attr {
     (LateContext) => {
-        fn enter_lint_attrs(&mut self, cx: &rustc_lint::LateContext<'tcx>, attrs: &'tcx [Attribute]) {
-            match get_inner_attr(cx.sess(), attrs, "msrv") {
-                Some(msrv_attr) => {
-                    if let Some(msrv) = msrv_attr.value_str() {
-                        self.msrv = crate::utils::parse_msrv(&msrv.to_string(), Some(cx.sess()), Some(msrv_attr.span));
-                    } else {
-                        cx.sess().span_err(msrv_attr.span, "bad clippy attribute");
-                    }
-                },
-                _ => (),
-            }
-        }
+        extract_msrv_attr!(@LateContext, ());
     };
     (EarlyContext) => {
-        fn enter_lint_attrs(&mut self, cx: &rustc_lint::EarlyContext<'tcx>, attrs: &'tcx [Attribute]) {
-            match get_inner_attr(cx.sess, attrs, "msrv") {
+        extract_msrv_attr!(@EarlyContext);
+    };
+    (@$context:ident$(, $call:tt)?) => {
+        fn enter_lint_attrs(&mut self, cx: &rustc_lint::$context<'tcx>, attrs: &'tcx [rustc_ast::ast::Attribute]) {
+            use $crate::utils::get_unique_inner_attr;
+            match get_unique_inner_attr(cx.sess$($call)?, attrs, "msrv") {
                 Some(msrv_attr) => {
                     if let Some(msrv) = msrv_attr.value_str() {
-                        self.msrv = crate::utils::parse_msrv(&msrv.to_string(), Some(cx.sess), Some(msrv_attr.span));
+                        self.msrv = $crate::utils::parse_msrv(
+                            &msrv.to_string(),
+                            Some(cx.sess$($call)?),
+                            Some(msrv_attr.span),
+                        );
                     } else {
-                        cx.sess.span_err(msrv_attr.span, "bad clippy attribute");
+                        cx.sess$($call)?.span_err(msrv_attr.span, "bad clippy attribute");
                     }
                 },
                 _ => (),
-- 
cgit 1.4.1-3-g733a5


From 93f922a85843b2c04e47ea30c109f0bd305e039e Mon Sep 17 00:00:00 2001
From: flip1995 <philipp.krones@embecosm.com>
Date: Wed, 25 Nov 2020 12:19:13 +0100
Subject: Add note where the first definition of msrv attr is

---
 clippy_lints/src/utils/attrs.rs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/attrs.rs b/clippy_lints/src/utils/attrs.rs
index aed6ee5dc57..24052a243af 100644
--- a/clippy_lints/src/utils/attrs.rs
+++ b/clippy_lints/src/utils/attrs.rs
@@ -130,7 +130,9 @@ pub fn get_unique_inner_attr(sess: &Session, attrs: &[ast::Attribute], name: &'s
         match attr.style {
             ast::AttrStyle::Inner if unique_attr.is_none() => unique_attr = Some(attr.clone()),
             ast::AttrStyle::Inner => {
-                sess.span_err(attr.span, &format!("`{}` is defined multiple times", name));
+                sess.struct_span_err(attr.span, &format!("`{}` is defined multiple times", name))
+                    .span_note(unique_attr.as_ref().unwrap().span, "first definition found here")
+                    .emit();
             },
             ast::AttrStyle::Outer => {
                 sess.span_err(attr.span, &format!("`{}` cannot be an outer attribute", name));
-- 
cgit 1.4.1-3-g733a5


From 2345ef5b1f89d9cac7a6697de08c36bfb771fe12 Mon Sep 17 00:00:00 2001
From: PunitLodha <punitlodha@pm.me>
Date: Sat, 14 Nov 2020 19:21:33 +0530
Subject: added lints str_to_string and string_to_string

---
 clippy_lints/src/deprecated_lints.rs |  20 -------
 clippy_lints/src/lib.rs              |  22 +++-----
 clippy_lints/src/strings.rs          | 100 ++++++++++++++++++++++++++++++++++-
 src/lintlist/mod.rs                  |  14 +++++
 tests/ui/deprecated.rs               |   2 -
 tests/ui/deprecated.stderr           |  46 ++++++----------
 tests/ui/deprecated_old.rs           |   2 -
 tests/ui/deprecated_old.stderr       |  30 ++++-------
 tests/ui/str_to_string.rs            |   7 +++
 tests/ui/str_to_string.stderr        |  19 +++++++
 tests/ui/string_to_string.rs         |   7 +++
 tests/ui/string_to_string.stderr     |  11 ++++
 12 files changed, 189 insertions(+), 91 deletions(-)
 create mode 100644 tests/ui/str_to_string.rs
 create mode 100644 tests/ui/str_to_string.stderr
 create mode 100644 tests/ui/string_to_string.rs
 create mode 100644 tests/ui/string_to_string.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/deprecated_lints.rs b/clippy_lints/src/deprecated_lints.rs
index 1c3285ed701..bec0c9f93a0 100644
--- a/clippy_lints/src/deprecated_lints.rs
+++ b/clippy_lints/src/deprecated_lints.rs
@@ -51,26 +51,6 @@ declare_deprecated_lint! {
     "`Vec::as_mut_slice` has been stabilized in 1.7"
 }
 
-declare_deprecated_lint! {
-    /// **What it does:** Nothing. This lint has been deprecated.
-    ///
-    /// **Deprecation reason:** This used to check for `.to_string()` method calls on values
-    /// of type `&str`. This is not unidiomatic and with specialization coming, `to_string` could be
-    /// specialized to be as efficient as `to_owned`.
-    pub STR_TO_STRING,
-    "using `str::to_string` is common even today and specialization will likely happen soon"
-}
-
-declare_deprecated_lint! {
-    /// **What it does:** Nothing. This lint has been deprecated.
-    ///
-    /// **Deprecation reason:** This used to check for `.to_string()` method calls on values
-    /// of type `String`. This is not unidiomatic and with specialization coming, `to_string` could be
-    /// specialized to be as efficient as `clone`.
-    pub STRING_TO_STRING,
-    "using `string::to_string` is common even today and specialization will likely happen soon"
-}
-
 declare_deprecated_lint! {
     /// **What it does:** Nothing. This lint has been deprecated.
     ///
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 866dae110cc..67a3a3fcf48 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -441,14 +441,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         "clippy::unstable_as_mut_slice",
         "`Vec::as_mut_slice` has been stabilized in 1.7",
     );
-    store.register_removed(
-        "clippy::str_to_string",
-        "using `str::to_string` is common even today and specialization will likely happen soon",
-    );
-    store.register_removed(
-        "clippy::string_to_string",
-        "using `string::to_string` is common even today and specialization will likely happen soon",
-    );
     store.register_removed(
         "clippy::misaligned_transmute",
         "this lint has been split into cast_ptr_alignment and transmute_ptr_to_ptr",
@@ -840,6 +832,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &strings::STRING_ADD_ASSIGN,
         &strings::STRING_FROM_UTF8_AS_BYTES,
         &strings::STRING_LIT_AS_BYTES,
+        &strings::STRING_TO_STRING,
+        &strings::STR_TO_STRING,
         &suspicious_trait_impl::SUSPICIOUS_ARITHMETIC_IMPL,
         &suspicious_trait_impl::SUSPICIOUS_OP_ASSIGN_IMPL,
         &swap::ALMOST_SWAPPED,
@@ -1186,6 +1180,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_early_pass(|| box asm_syntax::InlineAsmX86AttSyntax);
     store.register_early_pass(|| box asm_syntax::InlineAsmX86IntelSyntax);
     store.register_late_pass(|| box undropped_manually_drops::UndroppedManuallyDrops);
+    store.register_late_pass(|| box strings::StrToString);
+    store.register_late_pass(|| box strings::StringToString);
 
 
     store.register_group(true, "clippy::restriction", Some("clippy_restriction"), vec![
@@ -1228,6 +1224,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&shadow::SHADOW_REUSE),
         LintId::of(&shadow::SHADOW_SAME),
         LintId::of(&strings::STRING_ADD),
+        LintId::of(&strings::STRING_TO_STRING),
+        LintId::of(&strings::STR_TO_STRING),
         LintId::of(&types::RC_BUFFER),
         LintId::of(&unwrap_in_result::UNWRAP_IN_RESULT),
         LintId::of(&verbose_file_reads::VERBOSE_FILE_READS),
@@ -1943,14 +1941,6 @@ fn register_removed_non_tool_lints(store: &mut rustc_lint::LintStore) {
         "unstable_as_mut_slice",
         "`Vec::as_mut_slice` has been stabilized in 1.7",
     );
-    store.register_removed(
-        "str_to_string",
-        "using `str::to_string` is common even today and specialization will likely happen soon",
-    );
-    store.register_removed(
-        "string_to_string",
-        "using `string::to_string` is common even today and specialization will likely happen soon",
-    );
     store.register_removed(
         "misaligned_transmute",
         "this lint has been split into cast_ptr_alignment and transmute_ptr_to_ptr",
diff --git a/clippy_lints/src/strings.rs b/clippy_lints/src/strings.rs
index ede37624f71..42c45be3b45 100644
--- a/clippy_lints/src/strings.rs
+++ b/clippy_lints/src/strings.rs
@@ -2,6 +2,7 @@ use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, BorrowKind, Expr, ExprKind, LangItem, QPath};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
+use rustc_middle::ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Spanned;
 use rustc_span::sym;
@@ -11,7 +12,7 @@ use if_chain::if_chain;
 use crate::utils::SpanlessEq;
 use crate::utils::{
     get_parent_expr, is_allowed, is_type_diagnostic_item, match_function_call, method_calls, paths, span_lint,
-    span_lint_and_sugg,
+    span_lint_and_help, span_lint_and_sugg,
 };
 
 declare_clippy_lint! {
@@ -289,3 +290,100 @@ impl<'tcx> LateLintPass<'tcx> for StringLitAsBytes {
         }
     }
 }
+
+declare_clippy_lint! {
+    /// **What it does:** This lint checks for `.to_string()` method calls on values of type `&str`.
+    ///
+    /// **Why is this bad?** The `to_string` method is also used on other types to convert them to a string.
+    /// When called on a `&str` it turns the `&str` into the owned variant `String`, which can be better
+    /// expressed with `.to_owned()`.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// // example code where clippy issues a warning
+    /// let _ = "str".to_string();
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// // example code which does not raise clippy warning
+    /// let _ = "str".to_owned();
+    /// ```
+    pub STR_TO_STRING,
+    restriction,
+    "using `to_string()` on a `&str`, which should be `to_owned()`"
+}
+
+declare_lint_pass!(StrToString => [STR_TO_STRING]);
+
+impl LateLintPass<'_> for StrToString {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &Expr<'_>) {
+        if_chain! {
+            if let ExprKind::MethodCall(path, _, args, _) = &expr.kind;
+            if path.ident.name == sym!(to_string);
+            let ty = cx.typeck_results().expr_ty(&args[0]);
+            if let ty::Ref(_, ty, ..) = ty.kind();
+            if *ty.kind() == ty::Str;
+            then {
+                span_lint_and_help(
+                    cx,
+                    STR_TO_STRING,
+                    expr.span,
+                    "`to_string()` called on a `&str`",
+                    None,
+                    "consider using `.to_owned()`",
+                );
+            }
+        }
+    }
+}
+
+declare_clippy_lint! {
+    /// **What it does:** This lint checks for `.to_string()` method calls on values of type `String`.
+    ///
+    /// **Why is this bad?** The `to_string` method is also used on other types to convert them to a string.
+    /// When called on a `String` it only clones the `String`, which can be better expressed with `.clone()`.
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// // example code where clippy issues a warning
+    /// let msg = String::from("Hello World");
+    /// let _ = msg.to_string();
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// // example code which does not raise clippy warning
+    /// let msg = String::from("Hello World");
+    /// let _ = msg.clone();
+    /// ```
+    pub STRING_TO_STRING,
+    restriction,
+    "using `to_string()` on a `String`, which should be `clone()`"
+}
+
+declare_lint_pass!(StringToString => [STRING_TO_STRING]);
+
+impl LateLintPass<'_> for StringToString {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &Expr<'_>) {
+        if_chain! {
+            if let ExprKind::MethodCall(path, _, args, _) = &expr.kind;
+            if path.ident.name == sym!(to_string);
+            let ty = cx.typeck_results().expr_ty(&args[0]);
+            if is_type_diagnostic_item(cx, ty, sym!(string_type));
+            then {
+                span_lint_and_help(
+                    cx,
+                    STRING_TO_STRING,
+                    expr.span,
+                    "`to_string()` called on a `String`",
+                    None,
+                    "consider using `.clone()`",
+                );
+            }
+        }
+    }
+}
diff --git a/src/lintlist/mod.rs b/src/lintlist/mod.rs
index 1d906d20ad4..a104f687bdf 100644
--- a/src/lintlist/mod.rs
+++ b/src/lintlist/mod.rs
@@ -2237,6 +2237,13 @@ vec![
         deprecation: None,
         module: "stable_sort_primitive",
     },
+    Lint {
+        name: "str_to_string",
+        group: "restriction",
+        desc: "using `to_string()` on a `&str`, which should be `to_owned()`",
+        deprecation: None,
+        module: "strings",
+    },
     Lint {
         name: "string_add",
         group: "restriction",
@@ -2272,6 +2279,13 @@ vec![
         deprecation: None,
         module: "strings",
     },
+    Lint {
+        name: "string_to_string",
+        group: "restriction",
+        desc: "using `to_string()` on a `String`, which should be `clone()`",
+        deprecation: None,
+        module: "strings",
+    },
     Lint {
         name: "struct_excessive_bools",
         group: "pedantic",
diff --git a/tests/ui/deprecated.rs b/tests/ui/deprecated.rs
index 4cbc5630d75..e1ee8dbca2c 100644
--- a/tests/ui/deprecated.rs
+++ b/tests/ui/deprecated.rs
@@ -1,5 +1,3 @@
-#[warn(clippy::str_to_string)]
-#[warn(clippy::string_to_string)]
 #[warn(clippy::unstable_as_slice)]
 #[warn(clippy::unstable_as_mut_slice)]
 #[warn(clippy::misaligned_transmute)]
diff --git a/tests/ui/deprecated.stderr b/tests/ui/deprecated.stderr
index a348d01d734..edbb891afe0 100644
--- a/tests/ui/deprecated.stderr
+++ b/tests/ui/deprecated.stderr
@@ -1,88 +1,76 @@
-error: lint `clippy::str_to_string` has been removed: `using `str::to_string` is common even today and specialization will likely happen soon`
-  --> $DIR/deprecated.rs:1:8
-   |
-LL | #[warn(clippy::str_to_string)]
-   |        ^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: `-D renamed-and-removed-lints` implied by `-D warnings`
-
-error: lint `clippy::string_to_string` has been removed: `using `string::to_string` is common even today and specialization will likely happen soon`
-  --> $DIR/deprecated.rs:2:8
-   |
-LL | #[warn(clippy::string_to_string)]
-   |        ^^^^^^^^^^^^^^^^^^^^^^^^
-
 error: lint `clippy::unstable_as_slice` has been removed: ``Vec::as_slice` has been stabilized in 1.7`
-  --> $DIR/deprecated.rs:3:8
+  --> $DIR/deprecated.rs:1:8
    |
 LL | #[warn(clippy::unstable_as_slice)]
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D renamed-and-removed-lints` implied by `-D warnings`
 
 error: lint `clippy::unstable_as_mut_slice` has been removed: ``Vec::as_mut_slice` has been stabilized in 1.7`
-  --> $DIR/deprecated.rs:4:8
+  --> $DIR/deprecated.rs:2:8
    |
 LL | #[warn(clippy::unstable_as_mut_slice)]
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: lint `clippy::misaligned_transmute` has been removed: `this lint has been split into cast_ptr_alignment and transmute_ptr_to_ptr`
-  --> $DIR/deprecated.rs:5:8
+  --> $DIR/deprecated.rs:3:8
    |
 LL | #[warn(clippy::misaligned_transmute)]
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: lint `clippy::unused_collect` has been removed: ``collect` has been marked as #[must_use] in rustc and that covers all cases of this lint`
-  --> $DIR/deprecated.rs:6:8
+  --> $DIR/deprecated.rs:4:8
    |
 LL | #[warn(clippy::unused_collect)]
    |        ^^^^^^^^^^^^^^^^^^^^^^
 
 error: lint `clippy::invalid_ref` has been removed: `superseded by rustc lint `invalid_value``
-  --> $DIR/deprecated.rs:7:8
+  --> $DIR/deprecated.rs:5:8
    |
 LL | #[warn(clippy::invalid_ref)]
    |        ^^^^^^^^^^^^^^^^^^^
 
 error: lint `clippy::into_iter_on_array` has been removed: `this lint has been uplifted to rustc and is now called `array_into_iter``
-  --> $DIR/deprecated.rs:8:8
+  --> $DIR/deprecated.rs:6:8
    |
 LL | #[warn(clippy::into_iter_on_array)]
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: lint `clippy::unused_label` has been removed: `this lint has been uplifted to rustc and is now called `unused_labels``
-  --> $DIR/deprecated.rs:9:8
+  --> $DIR/deprecated.rs:7:8
    |
 LL | #[warn(clippy::unused_label)]
    |        ^^^^^^^^^^^^^^^^^^^^
 
 error: lint `clippy::regex_macro` has been removed: `the regex! macro has been removed from the regex crate in 2018`
-  --> $DIR/deprecated.rs:10:8
+  --> $DIR/deprecated.rs:8:8
    |
 LL | #[warn(clippy::regex_macro)]
    |        ^^^^^^^^^^^^^^^^^^^
 
 error: lint `clippy::drop_bounds` has been removed: `this lint has been uplifted to rustc and is now called `drop_bounds``
-  --> $DIR/deprecated.rs:11:8
+  --> $DIR/deprecated.rs:9:8
    |
 LL | #[warn(clippy::drop_bounds)]
    |        ^^^^^^^^^^^^^^^^^^^
 
 error: lint `clippy::temporary_cstring_as_ptr` has been removed: `this lint has been uplifted to rustc and is now called `temporary_cstring_as_ptr``
-  --> $DIR/deprecated.rs:12:8
+  --> $DIR/deprecated.rs:10:8
    |
 LL | #[warn(clippy::temporary_cstring_as_ptr)]
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: lint `clippy::panic_params` has been removed: `this lint has been uplifted to rustc and is now called `panic_fmt``
-  --> $DIR/deprecated.rs:13:8
+  --> $DIR/deprecated.rs:11:8
    |
 LL | #[warn(clippy::panic_params)]
    |        ^^^^^^^^^^^^^^^^^^^^
 
-error: lint `clippy::str_to_string` has been removed: `using `str::to_string` is common even today and specialization will likely happen soon`
+error: lint `clippy::unstable_as_slice` has been removed: ``Vec::as_slice` has been stabilized in 1.7`
   --> $DIR/deprecated.rs:1:8
    |
-LL | #[warn(clippy::str_to_string)]
-   |        ^^^^^^^^^^^^^^^^^^^^^
+LL | #[warn(clippy::unstable_as_slice)]
+   |        ^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 14 previous errors
+error: aborting due to 12 previous errors
 
diff --git a/tests/ui/deprecated_old.rs b/tests/ui/deprecated_old.rs
index 2e5c5b7ead1..e89dca4fcfd 100644
--- a/tests/ui/deprecated_old.rs
+++ b/tests/ui/deprecated_old.rs
@@ -1,5 +1,3 @@
-#[warn(str_to_string)]
-#[warn(string_to_string)]
 #[warn(unstable_as_slice)]
 #[warn(unstable_as_mut_slice)]
 #[warn(misaligned_transmute)]
diff --git a/tests/ui/deprecated_old.stderr b/tests/ui/deprecated_old.stderr
index ff3e9e8fcf3..2fe1facf0c7 100644
--- a/tests/ui/deprecated_old.stderr
+++ b/tests/ui/deprecated_old.stderr
@@ -1,40 +1,28 @@
-error: lint `str_to_string` has been removed: `using `str::to_string` is common even today and specialization will likely happen soon`
-  --> $DIR/deprecated_old.rs:1:8
-   |
-LL | #[warn(str_to_string)]
-   |        ^^^^^^^^^^^^^
-   |
-   = note: `-D renamed-and-removed-lints` implied by `-D warnings`
-
-error: lint `string_to_string` has been removed: `using `string::to_string` is common even today and specialization will likely happen soon`
-  --> $DIR/deprecated_old.rs:2:8
-   |
-LL | #[warn(string_to_string)]
-   |        ^^^^^^^^^^^^^^^^
-
 error: lint `unstable_as_slice` has been removed: ``Vec::as_slice` has been stabilized in 1.7`
-  --> $DIR/deprecated_old.rs:3:8
+  --> $DIR/deprecated_old.rs:1:8
    |
 LL | #[warn(unstable_as_slice)]
    |        ^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D renamed-and-removed-lints` implied by `-D warnings`
 
 error: lint `unstable_as_mut_slice` has been removed: ``Vec::as_mut_slice` has been stabilized in 1.7`
-  --> $DIR/deprecated_old.rs:4:8
+  --> $DIR/deprecated_old.rs:2:8
    |
 LL | #[warn(unstable_as_mut_slice)]
    |        ^^^^^^^^^^^^^^^^^^^^^
 
 error: lint `misaligned_transmute` has been removed: `this lint has been split into cast_ptr_alignment and transmute_ptr_to_ptr`
-  --> $DIR/deprecated_old.rs:5:8
+  --> $DIR/deprecated_old.rs:3:8
    |
 LL | #[warn(misaligned_transmute)]
    |        ^^^^^^^^^^^^^^^^^^^^
 
-error: lint `str_to_string` has been removed: `using `str::to_string` is common even today and specialization will likely happen soon`
+error: lint `unstable_as_slice` has been removed: ``Vec::as_slice` has been stabilized in 1.7`
   --> $DIR/deprecated_old.rs:1:8
    |
-LL | #[warn(str_to_string)]
-   |        ^^^^^^^^^^^^^
+LL | #[warn(unstable_as_slice)]
+   |        ^^^^^^^^^^^^^^^^^
 
-error: aborting due to 6 previous errors
+error: aborting due to 4 previous errors
 
diff --git a/tests/ui/str_to_string.rs b/tests/ui/str_to_string.rs
new file mode 100644
index 00000000000..08f73402518
--- /dev/null
+++ b/tests/ui/str_to_string.rs
@@ -0,0 +1,7 @@
+#![warn(clippy::str_to_string)]
+
+fn main() {
+    let hello = "hello world".to_string();
+    let msg = &hello[..];
+    msg.to_string();
+}
diff --git a/tests/ui/str_to_string.stderr b/tests/ui/str_to_string.stderr
new file mode 100644
index 00000000000..b1f73eda5d2
--- /dev/null
+++ b/tests/ui/str_to_string.stderr
@@ -0,0 +1,19 @@
+error: `to_string()` called on a `&str`
+  --> $DIR/str_to_string.rs:4:17
+   |
+LL |     let hello = "hello world".to_string();
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::str-to-string` implied by `-D warnings`
+   = help: consider using `.to_owned()`
+
+error: `to_string()` called on a `&str`
+  --> $DIR/str_to_string.rs:6:5
+   |
+LL |     msg.to_string();
+   |     ^^^^^^^^^^^^^^^
+   |
+   = help: consider using `.to_owned()`
+
+error: aborting due to 2 previous errors
+
diff --git a/tests/ui/string_to_string.rs b/tests/ui/string_to_string.rs
new file mode 100644
index 00000000000..4c66855f709
--- /dev/null
+++ b/tests/ui/string_to_string.rs
@@ -0,0 +1,7 @@
+#![warn(clippy::string_to_string)]
+#![allow(clippy::redundant_clone)]
+
+fn main() {
+    let mut message = String::from("Hello");
+    let mut v = message.to_string();
+}
diff --git a/tests/ui/string_to_string.stderr b/tests/ui/string_to_string.stderr
new file mode 100644
index 00000000000..1ebd17999bd
--- /dev/null
+++ b/tests/ui/string_to_string.stderr
@@ -0,0 +1,11 @@
+error: `to_string()` called on a `String`
+  --> $DIR/string_to_string.rs:6:17
+   |
+LL |     let mut v = message.to_string();
+   |                 ^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::string-to-string` implied by `-D warnings`
+   = help: consider using `.clone()`
+
+error: aborting due to previous error
+
-- 
cgit 1.4.1-3-g733a5


From 3b53de6b36081646315c0721638c4318c28b6982 Mon Sep 17 00:00:00 2001
From: unknown <abramlujan@gmail.com>
Date: Sat, 21 Nov 2020 21:08:32 -0300
Subject: Fix rust-lang/rust#79255 - Incorrect try suggestion for unnecessary
 float literal cast ending in dot

---
 clippy_lints/src/types.rs                |  2 +-
 tests/ui/unnecessary_cast_fixable.fixed  |  2 ++
 tests/ui/unnecessary_cast_fixable.rs     |  2 ++
 tests/ui/unnecessary_cast_fixable.stderr | 32 ++++++++++++++++++++++----------
 4 files changed, 27 insertions(+), 11 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs
index f0e10e374e1..f3cad66cbf3 100644
--- a/clippy_lints/src/types.rs
+++ b/clippy_lints/src/types.rs
@@ -1711,7 +1711,7 @@ fn show_unnecessary_cast(cx: &LateContext<'_>, expr: &Expr<'_>, literal_str: &st
         expr.span,
         &format!("casting {} literal to `{}` is unnecessary", literal_kind_name, cast_to),
         "try",
-        format!("{}_{}", literal_str, cast_to),
+        format!("{}_{}", literal_str.trim_end_matches('.'), cast_to),
         Applicability::MachineApplicable,
     );
 }
diff --git a/tests/ui/unnecessary_cast_fixable.fixed b/tests/ui/unnecessary_cast_fixable.fixed
index 350da4965d1..7fbce58a82f 100644
--- a/tests/ui/unnecessary_cast_fixable.fixed
+++ b/tests/ui/unnecessary_cast_fixable.fixed
@@ -11,6 +11,8 @@ fn main() {
     let _ = -100_f32;
     let _ = -100_f64;
     let _ = -100_f64;
+    100_f32;
+    100_f64;
     // Should not trigger
     #[rustfmt::skip]
     let v = vec!(1);
diff --git a/tests/ui/unnecessary_cast_fixable.rs b/tests/ui/unnecessary_cast_fixable.rs
index ad2fb2e6289..a71363ea4d2 100644
--- a/tests/ui/unnecessary_cast_fixable.rs
+++ b/tests/ui/unnecessary_cast_fixable.rs
@@ -11,6 +11,8 @@ fn main() {
     let _ = -100 as f32;
     let _ = -100 as f64;
     let _ = -100_i32 as f64;
+    100. as f32;
+    100. as f64;
     // Should not trigger
     #[rustfmt::skip]
     let v = vec!(1);
diff --git a/tests/ui/unnecessary_cast_fixable.stderr b/tests/ui/unnecessary_cast_fixable.stderr
index 5a210fc8909..3695a8f819c 100644
--- a/tests/ui/unnecessary_cast_fixable.stderr
+++ b/tests/ui/unnecessary_cast_fixable.stderr
@@ -36,59 +36,71 @@ error: casting integer literal to `f64` is unnecessary
 LL |     let _ = -100_i32 as f64;
    |             ^^^^^^^^^^^^^^^ help: try: `-100_f64`
 
+error: casting float literal to `f32` is unnecessary
+  --> $DIR/unnecessary_cast_fixable.rs:14:5
+   |
+LL |     100. as f32;
+   |     ^^^^^^^^^^^ help: try: `100_f32`
+
+error: casting float literal to `f64` is unnecessary
+  --> $DIR/unnecessary_cast_fixable.rs:15:5
+   |
+LL |     100. as f64;
+   |     ^^^^^^^^^^^ help: try: `100_f64`
+
 error: casting integer literal to `u32` is unnecessary
-  --> $DIR/unnecessary_cast_fixable.rs:25:5
+  --> $DIR/unnecessary_cast_fixable.rs:27:5
    |
 LL |     1 as u32;
    |     ^^^^^^^^ help: try: `1_u32`
 
 error: casting integer literal to `i32` is unnecessary
-  --> $DIR/unnecessary_cast_fixable.rs:26:5
+  --> $DIR/unnecessary_cast_fixable.rs:28:5
    |
 LL |     0x10 as i32;
    |     ^^^^^^^^^^^ help: try: `0x10_i32`
 
 error: casting integer literal to `usize` is unnecessary
-  --> $DIR/unnecessary_cast_fixable.rs:27:5
+  --> $DIR/unnecessary_cast_fixable.rs:29:5
    |
 LL |     0b10 as usize;
    |     ^^^^^^^^^^^^^ help: try: `0b10_usize`
 
 error: casting integer literal to `u16` is unnecessary
-  --> $DIR/unnecessary_cast_fixable.rs:28:5
+  --> $DIR/unnecessary_cast_fixable.rs:30:5
    |
 LL |     0o73 as u16;
    |     ^^^^^^^^^^^ help: try: `0o73_u16`
 
 error: casting integer literal to `u32` is unnecessary
-  --> $DIR/unnecessary_cast_fixable.rs:29:5
+  --> $DIR/unnecessary_cast_fixable.rs:31:5
    |
 LL |     1_000_000_000 as u32;
    |     ^^^^^^^^^^^^^^^^^^^^ help: try: `1_000_000_000_u32`
 
 error: casting float literal to `f64` is unnecessary
-  --> $DIR/unnecessary_cast_fixable.rs:31:5
+  --> $DIR/unnecessary_cast_fixable.rs:33:5
    |
 LL |     1.0 as f64;
    |     ^^^^^^^^^^ help: try: `1.0_f64`
 
 error: casting float literal to `f32` is unnecessary
-  --> $DIR/unnecessary_cast_fixable.rs:32:5
+  --> $DIR/unnecessary_cast_fixable.rs:34:5
    |
 LL |     0.5 as f32;
    |     ^^^^^^^^^^ help: try: `0.5_f32`
 
 error: casting integer literal to `i32` is unnecessary
-  --> $DIR/unnecessary_cast_fixable.rs:36:13
+  --> $DIR/unnecessary_cast_fixable.rs:38:13
    |
 LL |     let _ = -1 as i32;
    |             ^^^^^^^^^ help: try: `-1_i32`
 
 error: casting float literal to `f32` is unnecessary
-  --> $DIR/unnecessary_cast_fixable.rs:37:13
+  --> $DIR/unnecessary_cast_fixable.rs:39:13
    |
 LL |     let _ = -1.0 as f32;
    |             ^^^^^^^^^^^ help: try: `-1.0_f32`
 
-error: aborting due to 15 previous errors
+error: aborting due to 17 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From cb6a654b75ca095aee9ebbe5cf05fc48df5b9b50 Mon Sep 17 00:00:00 2001
From: pro-grammer1 <1df0d0d3-eed4-45fc-bc60-43a85079f3f9@anonaddy.me>
Date: Thu, 26 Nov 2020 20:07:50 +0000
Subject: Added known problem to comparison_chain docs

---
 clippy_lints/src/comparison_chain.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/comparison_chain.rs b/clippy_lints/src/comparison_chain.rs
index 99f161a0510..ae1143b2c50 100644
--- a/clippy_lints/src/comparison_chain.rs
+++ b/clippy_lints/src/comparison_chain.rs
@@ -12,7 +12,8 @@ declare_clippy_lint! {
     /// **Why is this bad?** `if` is not guaranteed to be exhaustive and conditionals can get
     /// repetitive
     ///
-    /// **Known problems:** None.
+    /// **Known problems:** The match statement may be slower due to the compiler
+    /// not inlining the call to cmp. See issue #5354
     ///
     /// **Example:**
     /// ```rust,ignore
-- 
cgit 1.4.1-3-g733a5


From bd235707acd095fdd2b079d2992923d0d732a474 Mon Sep 17 00:00:00 2001
From: "kai.giebeler" <kai.giebeler@audiotool.com>
Date: Fri, 27 Nov 2020 01:42:37 +0100
Subject: add WebGL to doc_valid_idents

---
 clippy_lints/src/utils/conf.rs | 1 +
 1 file changed, 1 insertion(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index fc6304118d9..95f5d33fb23 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -127,6 +127,7 @@ define_Conf! {
         "OAuth", "GraphQL",
         "OCaml",
         "OpenGL", "OpenMP", "OpenSSH", "OpenSSL", "OpenStreetMap",
+        "WebGL",
         "TensorFlow",
         "TrueType",
         "iOS", "macOS",
-- 
cgit 1.4.1-3-g733a5


From e91d15f42d761c1a2f161a2b65deee06a7f472ab Mon Sep 17 00:00:00 2001
From: Takayuki Nakata <f.seasons017@gmail.com>
Date: Fri, 27 Nov 2020 10:32:44 +0900
Subject: cargo dev fmt

---
 clippy_lints/src/attrs.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs
index 15505fd79f4..3edbe723922 100644
--- a/clippy_lints/src/attrs.rs
+++ b/clippy_lints/src/attrs.rs
@@ -5,7 +5,6 @@ use crate::utils::{
     span_lint_and_sugg, span_lint_and_then, without_block_comments,
 };
 use if_chain::if_chain;
-use rustc_span::lev_distance::find_best_match_for_name;
 use rustc_ast::{AttrKind, AttrStyle, Attribute, Lit, LitKind, MetaItemKind, NestedMetaItem};
 use rustc_errors::Applicability;
 use rustc_hir::{
@@ -15,6 +14,7 @@ use rustc_lint::{CheckLintNameResult, EarlyContext, EarlyLintPass, LateContext,
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::lev_distance::find_best_match_for_name;
 use rustc_span::source_map::Span;
 use rustc_span::sym;
 use rustc_span::symbol::{Symbol, SymbolStr};
-- 
cgit 1.4.1-3-g733a5


From 82a7068007a1490b43a2eb4e70e0f70de384a9ae Mon Sep 17 00:00:00 2001
From: Markus Legner <markus@legner.ch>
Date: Sat, 21 Nov 2020 12:28:53 +0100
Subject: Trigger modulo_one lint also on -1.

---
 clippy_lints/src/misc.rs   | 30 ++++++++++++++++++--------
 tests/ui/modulo_one.rs     | 11 +++++++++-
 tests/ui/modulo_one.stderr | 54 +++++++++++++++++++++++++++++++++++++++++-----
 3 files changed, 80 insertions(+), 15 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/misc.rs b/clippy_lints/src/misc.rs
index 308e92057b7..f16feb9b1ba 100644
--- a/clippy_lints/src/misc.rs
+++ b/clippy_lints/src/misc.rs
@@ -18,7 +18,7 @@ use crate::utils::sugg::Sugg;
 use crate::utils::{
     get_item_name, get_parent_expr, higher, implements_trait, in_constant, is_integer_const, iter_input_pats,
     last_path_segment, match_qpath, match_trait_method, paths, snippet, snippet_opt, span_lint, span_lint_and_sugg,
-    span_lint_and_then, span_lint_hir_and_then, SpanlessEq,
+    span_lint_and_then, span_lint_hir_and_then, SpanlessEq, unsext,
 };
 
 declare_clippy_lint! {
@@ -139,12 +139,14 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for getting the remainder of a division by one.
+    /// **What it does:** Checks for getting the remainder of a division by one or minus
+    /// one.
     ///
-    /// **Why is this bad?** The result can only ever be zero. No one will write
-    /// such code deliberately, unless trying to win an Underhanded Rust
-    /// Contest. Even for that contest, it's probably a bad idea. Use something more
-    /// underhanded.
+    /// **Why is this bad?** The result for a divisor of one can only ever be zero; for
+    /// minus one it can cause panic/overflow (if the left operand is the minimal value of
+    /// the respective integer type) or results in zero. No one will write such code
+    /// deliberately, unless trying to win an Underhanded Rust Contest. Even for that
+    /// contest, it's probably a bad idea. Use something more underhanded.
     ///
     /// **Known problems:** None.
     ///
@@ -152,10 +154,11 @@ declare_clippy_lint! {
     /// ```rust
     /// # let x = 1;
     /// let a = x % 1;
+    /// let a = x % -1;
     /// ```
     pub MODULO_ONE,
     correctness,
-    "taking a number modulo 1, which always returns 0"
+    "taking a number modulo +/-1, which can either panic/overflow or always returns 0"
 }
 
 declare_clippy_lint! {
@@ -429,8 +432,17 @@ impl<'tcx> LateLintPass<'tcx> for MiscLints {
                         }
                         diag.note("`f32::EPSILON` and `f64::EPSILON` are available for the `error_margin`");
                     });
-                } else if op == BinOpKind::Rem && is_integer_const(cx, right, 1) {
-                    span_lint(cx, MODULO_ONE, expr.span, "any number modulo 1 will be 0");
+                } else if op == BinOpKind::Rem {
+                    if is_integer_const(cx, right, 1) {
+                        span_lint(cx, MODULO_ONE, expr.span, "any number modulo 1 will be 0");
+                    }
+
+                    if let ty::Int(ity) = cx.typeck_results().expr_ty(right).kind() {
+                        if is_integer_const(cx, right, unsext(cx.tcx, -1, *ity)) {
+                            span_lint(cx, MODULO_ONE, expr.span,
+                                "any number modulo -1 will panic/overflow or result in 0");
+                        }
+                    };
                 }
             },
             _ => {},
diff --git a/tests/ui/modulo_one.rs b/tests/ui/modulo_one.rs
index cc8c8e7cdae..678a312f66e 100644
--- a/tests/ui/modulo_one.rs
+++ b/tests/ui/modulo_one.rs
@@ -2,13 +2,22 @@
 #![allow(clippy::no_effect, clippy::unnecessary_operation)]
 
 static STATIC_ONE: usize = 2 - 1;
+static STATIC_NEG_ONE: i64 = 1 - 2;
 
 fn main() {
     10 % 1;
+    10 % -1;
     10 % 2;
+    i32::MIN % (-1); // also caught by rustc
 
     const ONE: u32 = 1 * 1;
+    const NEG_ONE: i64 = 1 - 2;
+    const INT_MIN: i64 = i64::MIN;
 
     2 % ONE;
-    5 % STATIC_ONE;
+    5 % STATIC_ONE; // NOT caught by lint
+    2 % NEG_ONE;
+    5 % STATIC_NEG_ONE; // NOT caught by lint
+    INT_MIN % NEG_ONE; // also caught by rustc
+    INT_MIN % STATIC_NEG_ONE; // ONLY caught by rustc
 }
diff --git a/tests/ui/modulo_one.stderr b/tests/ui/modulo_one.stderr
index 6bee68360b6..2b2c6997338 100644
--- a/tests/ui/modulo_one.stderr
+++ b/tests/ui/modulo_one.stderr
@@ -1,13 +1,45 @@
+error: this arithmetic operation will overflow
+  --> $DIR/modulo_one.rs:11:5
+   |
+LL |     i32::MIN % (-1); // also caught by rustc
+   |     ^^^^^^^^^^^^^^^ attempt to compute the remainder of `i32::MIN % -1_i32`, which would overflow
+   |
+   = note: `#[deny(arithmetic_overflow)]` on by default
+
+error: this arithmetic operation will overflow
+  --> $DIR/modulo_one.rs:21:5
+   |
+LL |     INT_MIN % NEG_ONE; // also caught by rustc
+   |     ^^^^^^^^^^^^^^^^^ attempt to compute the remainder of `i64::MIN % -1_i64`, which would overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/modulo_one.rs:22:5
+   |
+LL |     INT_MIN % STATIC_NEG_ONE; // ONLY caught by rustc
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^ attempt to compute the remainder of `i64::MIN % -1_i64`, which would overflow
+
 error: any number modulo 1 will be 0
-  --> $DIR/modulo_one.rs:7:5
+  --> $DIR/modulo_one.rs:8:5
    |
 LL |     10 % 1;
    |     ^^^^^^
    |
    = note: `-D clippy::modulo-one` implied by `-D warnings`
 
+error: any number modulo -1 will panic/overflow or result in 0
+  --> $DIR/modulo_one.rs:9:5
+   |
+LL |     10 % -1;
+   |     ^^^^^^^
+
+error: any number modulo -1 will panic/overflow or result in 0
+  --> $DIR/modulo_one.rs:11:5
+   |
+LL |     i32::MIN % (-1); // also caught by rustc
+   |     ^^^^^^^^^^^^^^^
+
 error: the operation is ineffective. Consider reducing it to `1`
-  --> $DIR/modulo_one.rs:10:22
+  --> $DIR/modulo_one.rs:13:22
    |
 LL |     const ONE: u32 = 1 * 1;
    |                      ^^^^^
@@ -15,16 +47,28 @@ LL |     const ONE: u32 = 1 * 1;
    = note: `-D clippy::identity-op` implied by `-D warnings`
 
 error: the operation is ineffective. Consider reducing it to `1`
-  --> $DIR/modulo_one.rs:10:22
+  --> $DIR/modulo_one.rs:13:22
    |
 LL |     const ONE: u32 = 1 * 1;
    |                      ^^^^^
 
 error: any number modulo 1 will be 0
-  --> $DIR/modulo_one.rs:12:5
+  --> $DIR/modulo_one.rs:17:5
    |
 LL |     2 % ONE;
    |     ^^^^^^^
 
-error: aborting due to 4 previous errors
+error: any number modulo -1 will panic/overflow or result in 0
+  --> $DIR/modulo_one.rs:19:5
+   |
+LL |     2 % NEG_ONE;
+   |     ^^^^^^^^^^^
+
+error: any number modulo -1 will panic/overflow or result in 0
+  --> $DIR/modulo_one.rs:21:5
+   |
+LL |     INT_MIN % NEG_ONE; // also caught by rustc
+   |     ^^^^^^^^^^^^^^^^^
+
+error: aborting due to 11 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From e42a18f02a45ffc12016a71bb4a210aa62af9a24 Mon Sep 17 00:00:00 2001
From: Markus Legner <markus@legner.ch>
Date: Sat, 21 Nov 2020 12:38:21 +0100
Subject: Run `cargo dev fmt`.

---
 clippy_lints/src/misc.rs | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/misc.rs b/clippy_lints/src/misc.rs
index f16feb9b1ba..b527b2cc1cb 100644
--- a/clippy_lints/src/misc.rs
+++ b/clippy_lints/src/misc.rs
@@ -18,7 +18,7 @@ use crate::utils::sugg::Sugg;
 use crate::utils::{
     get_item_name, get_parent_expr, higher, implements_trait, in_constant, is_integer_const, iter_input_pats,
     last_path_segment, match_qpath, match_trait_method, paths, snippet, snippet_opt, span_lint, span_lint_and_sugg,
-    span_lint_and_then, span_lint_hir_and_then, SpanlessEq, unsext,
+    span_lint_and_then, span_lint_hir_and_then, unsext, SpanlessEq,
 };
 
 declare_clippy_lint! {
@@ -439,8 +439,12 @@ impl<'tcx> LateLintPass<'tcx> for MiscLints {
 
                     if let ty::Int(ity) = cx.typeck_results().expr_ty(right).kind() {
                         if is_integer_const(cx, right, unsext(cx.tcx, -1, *ity)) {
-                            span_lint(cx, MODULO_ONE, expr.span,
-                                "any number modulo -1 will panic/overflow or result in 0");
+                            span_lint(
+                                cx,
+                                MODULO_ONE,
+                                expr.span,
+                                "any number modulo -1 will panic/overflow or result in 0",
+                            );
                         }
                     };
                 }
-- 
cgit 1.4.1-3-g733a5


From b8226320735bc8e3f699cc177be638433ed396d9 Mon Sep 17 00:00:00 2001
From: Markus Legner <markus@legner.ch>
Date: Mon, 23 Nov 2020 10:18:27 +0100
Subject: Factor out `check_binary` from function `check_expr`.

---
 clippy_lints/src/misc.rs | 140 ++++++++++++++++++++++++-----------------------
 1 file changed, 73 insertions(+), 67 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/misc.rs b/clippy_lints/src/misc.rs
index b527b2cc1cb..0512d74c7b1 100644
--- a/clippy_lints/src/misc.rs
+++ b/clippy_lints/src/misc.rs
@@ -381,73 +381,8 @@ impl<'tcx> LateLintPass<'tcx> for MiscLints {
                 return;
             },
             ExprKind::Binary(ref cmp, ref left, ref right) => {
-                let op = cmp.node;
-                if op.is_comparison() {
-                    check_nan(cx, left, expr);
-                    check_nan(cx, right, expr);
-                    check_to_owned(cx, left, right, true);
-                    check_to_owned(cx, right, left, false);
-                }
-                if (op == BinOpKind::Eq || op == BinOpKind::Ne) && (is_float(cx, left) || is_float(cx, right)) {
-                    if is_allowed(cx, left) || is_allowed(cx, right) {
-                        return;
-                    }
-
-                    // Allow comparing the results of signum()
-                    if is_signum(cx, left) && is_signum(cx, right) {
-                        return;
-                    }
-
-                    if let Some(name) = get_item_name(cx, expr) {
-                        let name = name.as_str();
-                        if name == "eq"
-                            || name == "ne"
-                            || name == "is_nan"
-                            || name.starts_with("eq_")
-                            || name.ends_with("_eq")
-                        {
-                            return;
-                        }
-                    }
-                    let is_comparing_arrays = is_array(cx, left) || is_array(cx, right);
-                    let (lint, msg) = get_lint_and_message(
-                        is_named_constant(cx, left) || is_named_constant(cx, right),
-                        is_comparing_arrays,
-                    );
-                    span_lint_and_then(cx, lint, expr.span, msg, |diag| {
-                        let lhs = Sugg::hir(cx, left, "..");
-                        let rhs = Sugg::hir(cx, right, "..");
-
-                        if !is_comparing_arrays {
-                            diag.span_suggestion(
-                                expr.span,
-                                "consider comparing them within some margin of error",
-                                format!(
-                                    "({}).abs() {} error_margin",
-                                    lhs - rhs,
-                                    if op == BinOpKind::Eq { '<' } else { '>' }
-                                ),
-                                Applicability::HasPlaceholders, // snippet
-                            );
-                        }
-                        diag.note("`f32::EPSILON` and `f64::EPSILON` are available for the `error_margin`");
-                    });
-                } else if op == BinOpKind::Rem {
-                    if is_integer_const(cx, right, 1) {
-                        span_lint(cx, MODULO_ONE, expr.span, "any number modulo 1 will be 0");
-                    }
-
-                    if let ty::Int(ity) = cx.typeck_results().expr_ty(right).kind() {
-                        if is_integer_const(cx, right, unsext(cx.tcx, -1, *ity)) {
-                            span_lint(
-                                cx,
-                                MODULO_ONE,
-                                expr.span,
-                                "any number modulo -1 will panic/overflow or result in 0",
-                            );
-                        }
-                    };
-                }
+                check_binary(cx, expr, cmp, left, right);
+                return;
             },
             _ => {},
         }
@@ -760,3 +695,74 @@ fn check_cast(cx: &LateContext<'_>, span: Span, e: &Expr<'_>, ty: &hir::Ty<'_>)
         }
     }
 }
+
+fn check_binary(
+    cx: &LateContext<'a>,
+    expr: &Expr<'_>,
+    cmp: &rustc_span::source_map::Spanned<rustc_hir::BinOpKind>,
+    left: &'a Expr<'_>,
+    right: &'a Expr<'_>,
+) {
+    let op = cmp.node;
+    if op.is_comparison() {
+        check_nan(cx, left, expr);
+        check_nan(cx, right, expr);
+        check_to_owned(cx, left, right, true);
+        check_to_owned(cx, right, left, false);
+    }
+    if (op == BinOpKind::Eq || op == BinOpKind::Ne) && (is_float(cx, left) || is_float(cx, right)) {
+        if is_allowed(cx, left) || is_allowed(cx, right) {
+            return;
+        }
+
+        // Allow comparing the results of signum()
+        if is_signum(cx, left) && is_signum(cx, right) {
+            return;
+        }
+
+        if let Some(name) = get_item_name(cx, expr) {
+            let name = name.as_str();
+            if name == "eq" || name == "ne" || name == "is_nan" || name.starts_with("eq_") || name.ends_with("_eq") {
+                return;
+            }
+        }
+        let is_comparing_arrays = is_array(cx, left) || is_array(cx, right);
+        let (lint, msg) = get_lint_and_message(
+            is_named_constant(cx, left) || is_named_constant(cx, right),
+            is_comparing_arrays,
+        );
+        span_lint_and_then(cx, lint, expr.span, msg, |diag| {
+            let lhs = Sugg::hir(cx, left, "..");
+            let rhs = Sugg::hir(cx, right, "..");
+
+            if !is_comparing_arrays {
+                diag.span_suggestion(
+                    expr.span,
+                    "consider comparing them within some margin of error",
+                    format!(
+                        "({}).abs() {} error_margin",
+                        lhs - rhs,
+                        if op == BinOpKind::Eq { '<' } else { '>' }
+                    ),
+                    Applicability::HasPlaceholders, // snippet
+                );
+            }
+            diag.note("`f32::EPSILON` and `f64::EPSILON` are available for the `error_margin`");
+        });
+    } else if op == BinOpKind::Rem {
+        if is_integer_const(cx, right, 1) {
+            span_lint(cx, MODULO_ONE, expr.span, "any number modulo 1 will be 0");
+        }
+
+        if let ty::Int(ity) = cx.typeck_results().expr_ty(right).kind() {
+            if is_integer_const(cx, right, unsext(cx.tcx, -1, *ity)) {
+                span_lint(
+                    cx,
+                    MODULO_ONE,
+                    expr.span,
+                    "any number modulo -1 will panic/overflow or result in 0",
+                );
+            }
+        };
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From af1cc5c91131e0ec30f0f34691a5e635350295a1 Mon Sep 17 00:00:00 2001
From: Ryan1729 <Ryan1729@gmail.com>
Date: Sat, 7 Nov 2020 16:00:42 -0700
Subject: add suspicious_operation_groupings lint

run `cargo dev new_lint --category correctness --name suspicious_chained_operators --pass early`

add (currently failing) tests for suspicious_chained_operators
add some tests to answer a question that came up during implementation

write usage code for functions we'll need to find or create

Complete left-right tracking TODO

get it compiling with several `todo!` invocations.

refactor to a set of incomplete functions that don't expect to be able to edit a `Span`

create placeholder for `suggestion_with_swapped_ident` function and correct some comments

add `inside_larger_boolean_expression` test

fill out `get_ident` and `suggestion_with_swapped_ident`

Implementi the `IdentIter`

start on implementing the `IdentIter`
handle the `ExprKind::Path` case in `IdentIter`

on second thought, make the iterator type dynamic so we don't need an explicit type for each one we will need

handle `ExprKind::MacCall` in `IdentIter`

Try handling `box x` expressions

restructure `IdentIter`

set `self.done` when returning `None`

Handle `ExprKind::Array`

reduce duplication with a macro that we expect to use several more times

handle ExprKind::Call

add `new_p` convenience method

handle `MethodCall`

handle `Tup` and `Binary`

handle `Unary`

simplify by not returning an additional `Expr` from the `IdentIter`

add cross product test against false positives

rename suspicious_chained_operators to suspicious_operation_groupings within files

For the record, the exact commands run were:
find . -type f -name "*.md" -exec sed -i 's/suspicious_chained_operators/suspicious_operation_groupings/g' {} +

find . -type f -name "*.rs" -exec sed -i 's/suspicious_chained_operators/suspicious_operation_groupings/g' {} +

find . -type f -name "*.rs" -exec sed -i 's/SUSPICIOUS_CHAINED_OPERATORS/SUSPICIOUS_OPERATION_GROUPINGS/g' {} +

find . -type f -name "*.rs" -exec sed -i 's/SuspiciousChainedOperators/SuspiciousOperationGroupings/g' {} +

Also:
rename file to match module name

rename test file to match lint name

start implementing `IdentDifference` creation

add `IdentIter` utility

use `ident_iter::IdentIter`

fix bug in `suggestion_with_swapped_ident`

add `inside_if_statements` test

implement `Add` `todo`s

register `SuspiciousOperationGroupings` lint pass

fill in `chained_binops`, and fill in a stopgap version of `ident_difference_expr`, but then notice that the lint does not seem to ever be run in the tests

run `cargo dev update_lints` and not that the `suspicious_operation_groupings` lint still does not seem to be run

fix base index incrementing bug

fix paired_identifiers bug, and remove ident from `Single`

change help prefix and note our first successful lint messages!

add odd_number_of_pairs test

get the `non_boolean_operators` test passing, with two copies of the error message

extract `is_useless_with_eq_exprs` so we can know when `eq_op` will already handle something

add `not_caught_by_eq_op` tests since `s1.b * s1.b` was (reasonably) not caught by `eq_op`

cover the case where the change should be made on either side of the expression with `not_caught_by_eq_op` tests

produce the expected suggestion on the `not_caught_by_eq_op_middle_change_left` test

confirm that the previous tests still pass and update references

fix early continue bug and get `not_caught_by_eq_op_middle_change_right` passing

note that `not_caught_by_eq_op_start` already passes

fix bugs based on misunderstanding of what `Iterator::skip` does, and note that `not_caught_by_eq_op_end` now passes

add several parens tests and make some of them pass

handle parens inside `chained_binops_helper` and note that this makes several tests pass

get `inside_larger_boolean_expression_with_unsorted_ops` test passing by extracting out `check_same_op_binops` function

also run `cargo dev fmt`

note that `inside_function_call` already passes

add another `if_statement` test

remove the matching op requirement, making `inside_larger_boolean_expression_with_unsorted_ops` pass

prevent non-change suggestions from being emitted

get the `Nested` tests passing, and remove apparently false note about eq_op

add a test to justify comment in `ident_difference_expr_with_base_location` but find that the failure mode seems different than expected

complete `todo` making `do_not_give_bad_suggestions_for_this_unusual_expr` pass and add some more tests that already pass

add test to `eq_op`

note that `inside_fn_with_similar_expression` already passes

fix `inside_an_if_statement` and note that it already passes

attempt to implement if statement extraction and notice that we don't seem to handle unary ops correctly

add `maximum_unary_minus_right_tree` test and make it pass

add two tests and note one of them passes

filter out unary operations in several places, and find that the issue seems to be that we don't currently recognize the error in `multiple_comparison_types_and_unary_minus` even so.

remove filtering that was causing bad suggestions

remove tests that were deemed too much for now

run `cargo dev fmt`

correct eq_op post-merge

fill out the description and delete debugging code

run `cargo dev update_lints`

update eq_op references

add parens to work around rustfmt issue #3666 and run rustfmt

https://github.com/rust-lang/rustfmt/issues/3666#issuecomment-714612257

update references after formatting

fix dogfood issues

fix multi-cursor edit

fix missed dogfood error

fix more dogfood pedantic issues, including function length

even more nesting

insert hidden definition of Vec3 so docs compile

add spaces to second struct def

reword test description comment

Co-authored-by: llogiq <bogusandre@gmail.com>

add local `use BinOpKind::*;`

Apply suggestions from code review

Co-authored-by: llogiq <bogusandre@gmail.com>

switch `SUSPICIOUS_OPERATION_GROUPINGS` to a style lint

run `cargo dev update_lints`

put both usages of `op_types` in the same closure to satisfy `borrowck`

fix compile error
---
 CHANGELOG.md                                       |   1 +
 clippy_lints/src/eq_op.rs                          |  27 +-
 clippy_lints/src/lib.rs                            |   5 +
 clippy_lints/src/suspicious_operation_groupings.rs | 693 +++++++++++++++++++++
 clippy_lints/src/utils/ast_utils.rs                |  11 +
 clippy_lints/src/utils/ast_utils/ident_iter.rs     |  45 ++
 tests/ui/eq_op.rs                                  |   9 +
 tests/ui/eq_op.stderr                              |  10 +-
 tests/ui/suspicious_operation_groupings.rs         | 207 ++++++
 tests/ui/suspicious_operation_groupings.stderr     | 166 +++++
 10 files changed, 1150 insertions(+), 24 deletions(-)
 create mode 100644 clippy_lints/src/suspicious_operation_groupings.rs
 create mode 100644 clippy_lints/src/utils/ast_utils/ident_iter.rs
 create mode 100644 tests/ui/suspicious_operation_groupings.rs
 create mode 100644 tests/ui/suspicious_operation_groupings.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index b9e4b0e6704..e76a781f13b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2073,6 +2073,7 @@ Released 2018-09-13
 [`suspicious_else_formatting`]: https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_else_formatting
 [`suspicious_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_map
 [`suspicious_op_assign_impl`]: https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_op_assign_impl
+[`suspicious_operation_groupings`]: https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_operation_groupings
 [`suspicious_unary_op_formatting`]: https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_unary_op_formatting
 [`tabs_in_doc_comments`]: https://rust-lang.github.io/rust-clippy/master/index.html#tabs_in_doc_comments
 [`temporary_assignment`]: https://rust-lang.github.io/rust-clippy/master/index.html#temporary_assignment
diff --git a/clippy_lints/src/eq_op.rs b/clippy_lints/src/eq_op.rs
index 3201adbf9a0..6308f6e2e7e 100644
--- a/clippy_lints/src/eq_op.rs
+++ b/clippy_lints/src/eq_op.rs
@@ -1,10 +1,10 @@
 use crate::utils::{
-    eq_expr_value, higher, implements_trait, in_macro, is_copy, is_expn_of, multispan_sugg, snippet, span_lint,
-    span_lint_and_then,
+    ast_utils::is_useless_with_eq_exprs, eq_expr_value, higher, implements_trait, in_macro, is_copy, is_expn_of,
+    multispan_sugg, snippet, span_lint, span_lint_and_then,
 };
 use if_chain::if_chain;
 use rustc_errors::Applicability;
-use rustc_hir::{BinOp, BinOpKind, BorrowKind, Expr, ExprKind, StmtKind};
+use rustc_hir::{BinOpKind, BorrowKind, Expr, ExprKind, StmtKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
@@ -102,7 +102,7 @@ impl<'tcx> LateLintPass<'tcx> for EqOp {
             if macro_with_not_op(&left.kind) || macro_with_not_op(&right.kind) {
                 return;
             }
-            if is_valid_operator(op) && eq_expr_value(cx, left, right) {
+            if is_useless_with_eq_exprs(higher::binop(op.node)) && eq_expr_value(cx, left, right) {
                 span_lint(
                     cx,
                     EQ_OP,
@@ -245,22 +245,3 @@ impl<'tcx> LateLintPass<'tcx> for EqOp {
         }
     }
 }
-
-fn is_valid_operator(op: BinOp) -> bool {
-    matches!(
-        op.node,
-        BinOpKind::Sub
-            | BinOpKind::Div
-            | BinOpKind::Eq
-            | BinOpKind::Lt
-            | BinOpKind::Le
-            | BinOpKind::Gt
-            | BinOpKind::Ge
-            | BinOpKind::Ne
-            | BinOpKind::And
-            | BinOpKind::Or
-            | BinOpKind::BitXor
-            | BinOpKind::BitAnd
-            | BinOpKind::BitOr
-    )
-}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 67a3a3fcf48..6eb5f6a7f48 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -308,6 +308,7 @@ mod single_component_path_imports;
 mod slow_vector_initialization;
 mod stable_sort_primitive;
 mod strings;
+mod suspicious_operation_groupings;
 mod suspicious_trait_impl;
 mod swap;
 mod tabs_in_doc_comments;
@@ -834,6 +835,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &strings::STRING_LIT_AS_BYTES,
         &strings::STRING_TO_STRING,
         &strings::STR_TO_STRING,
+        &suspicious_operation_groupings::SUSPICIOUS_OPERATION_GROUPINGS,
         &suspicious_trait_impl::SUSPICIOUS_ARITHMETIC_IMPL,
         &suspicious_trait_impl::SUSPICIOUS_OP_ASSIGN_IMPL,
         &swap::ALMOST_SWAPPED,
@@ -1066,6 +1068,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box types::UnitArg);
     store.register_late_pass(|| box double_comparison::DoubleComparisons);
     store.register_late_pass(|| box question_mark::QuestionMark);
+    store.register_early_pass(|| box suspicious_operation_groupings::SuspiciousOperationGroupings);
     store.register_late_pass(|| box suspicious_trait_impl::SuspiciousImpl);
     store.register_late_pass(|| box map_unit_fn::MapUnit);
     store.register_late_pass(|| box inherent_impl::MultipleInherentImpl::default());
@@ -1547,6 +1550,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&slow_vector_initialization::SLOW_VECTOR_INITIALIZATION),
         LintId::of(&stable_sort_primitive::STABLE_SORT_PRIMITIVE),
         LintId::of(&strings::STRING_FROM_UTF8_AS_BYTES),
+        LintId::of(&suspicious_operation_groupings::SUSPICIOUS_OPERATION_GROUPINGS),
         LintId::of(&suspicious_trait_impl::SUSPICIOUS_ARITHMETIC_IMPL),
         LintId::of(&suspicious_trait_impl::SUSPICIOUS_OP_ASSIGN_IMPL),
         LintId::of(&swap::ALMOST_SWAPPED),
@@ -1698,6 +1702,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&returns::LET_AND_RETURN),
         LintId::of(&returns::NEEDLESS_RETURN),
         LintId::of(&single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS),
+        LintId::of(&suspicious_operation_groupings::SUSPICIOUS_OPERATION_GROUPINGS),
         LintId::of(&tabs_in_doc_comments::TABS_IN_DOC_COMMENTS),
         LintId::of(&to_digit_is_some::TO_DIGIT_IS_SOME),
         LintId::of(&try_err::TRY_ERR),
diff --git a/clippy_lints/src/suspicious_operation_groupings.rs b/clippy_lints/src/suspicious_operation_groupings.rs
new file mode 100644
index 00000000000..cccd24ccf94
--- /dev/null
+++ b/clippy_lints/src/suspicious_operation_groupings.rs
@@ -0,0 +1,693 @@
+use crate::utils::ast_utils::{eq_id, is_useless_with_eq_exprs, IdentIter};
+use crate::utils::{snippet_with_applicability, span_lint_and_sugg};
+use core::ops::{Add, AddAssign};
+use if_chain::if_chain;
+use rustc_ast::ast::{BinOpKind, Expr, ExprKind, StmtKind};
+use rustc_data_structures::fx::FxHashSet;
+use rustc_errors::Applicability;
+use rustc_lint::{EarlyContext, EarlyLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::source_map::Spanned;
+use rustc_span::symbol::Ident;
+use rustc_span::Span;
+
+declare_clippy_lint! {
+    /// **What it does:**
+    /// Checks for unlikely usages of binary operators that are almost
+    /// certainly typos and/or copy/paste errors, given the other usages
+    /// of binary operators nearby.
+    /// **Why is this bad?**
+    /// They are probably bugs and if they aren't then they look like bugs
+    /// and you should add a comment explaining why you are doing such an
+    /// odd set of operations.
+    /// **Known problems:**
+    /// There may be some false positives if you are trying to do something
+    /// unusual that happens to look like a typo.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// struct Vec3 {
+    ///     x: f64,
+    ///     y: f64,
+    ///     z: f64,
+    /// }
+    ///
+    /// impl Eq for Vec3 {}
+    ///
+    /// impl PartialEq for Vec3 {
+    ///     fn eq(&self, other: &Self) -> bool {
+    ///         // This should trigger the lint because `self.x` is compared to `other.y`
+    ///         self.x == other.y && self.y == other.y && self.z == other.z
+    ///     }
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// # struct Vec3 {
+    /// #     x: f64,
+    /// #     y: f64,
+    /// #     z: f64,
+    /// # }
+    /// // same as above except:
+    /// impl PartialEq for Vec3 {
+    ///     fn eq(&self, other: &Self) -> bool {
+    ///         // Note we now compare other.x to self.x
+    ///         self.x == other.x && self.y == other.y && self.z == other.z
+    ///     }
+    /// }
+    /// ```
+    pub SUSPICIOUS_OPERATION_GROUPINGS,
+    style,
+    "groupings of binary operations that look suspiciously like typos"
+}
+
+declare_lint_pass!(SuspiciousOperationGroupings => [SUSPICIOUS_OPERATION_GROUPINGS]);
+
+impl EarlyLintPass for SuspiciousOperationGroupings {
+    fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
+        if expr.span.from_expansion() {
+            return;
+        }
+
+        if let Some(binops) = extract_related_binops(&expr.kind) {
+            check_binops(cx, &binops.iter().collect::<Vec<_>>());
+
+            let mut op_types = Vec::with_capacity(binops.len());
+            // We could use a hashmap, etc. to avoid being O(n*m) here, but
+            // we want the lints to be emitted in a consistent order. Besides,
+            // m, (the number of distinct `BinOpKind`s in `binops`)
+            // will often be small, and does have an upper limit.
+            binops.iter().map(|b| b.op).for_each(|op| {
+                if !op_types.contains(&op) {
+                    op_types.push(op);
+                }
+            });
+
+            for op_type in op_types {
+                let ops: Vec<_> = binops.iter().filter(|b| b.op == op_type).collect();
+
+                check_binops(cx, &ops);
+            }
+        }
+    }
+}
+
+fn check_binops(cx: &EarlyContext<'_>, binops: &[&BinaryOp<'_>]) {
+    let binop_count = binops.len();
+    if binop_count < 2 {
+        // Single binary operation expressions would likely be false
+        // positives.
+        return;
+    }
+
+    let mut one_ident_difference_count = 0;
+    let mut no_difference_info = None;
+    let mut double_difference_info = None;
+    let mut expected_ident_loc = None;
+
+    let mut paired_identifiers = FxHashSet::default();
+
+    for (i, BinaryOp { left, right, op, .. }) in binops.iter().enumerate() {
+        match ident_difference_expr(left, right) {
+            IdentDifference::NoDifference => {
+                if is_useless_with_eq_exprs(*op) {
+                    // The `eq_op` lint should catch this in this case.
+                    return;
+                }
+
+                no_difference_info = Some(i);
+            },
+            IdentDifference::Single(ident_loc) => {
+                one_ident_difference_count += 1;
+                if let Some(previous_expected) = expected_ident_loc {
+                    if previous_expected != ident_loc {
+                        // This expression doesn't match the form we're
+                        // looking for.
+                        return;
+                    }
+                } else {
+                    expected_ident_loc = Some(ident_loc);
+                }
+
+                // If there was only a single difference, all other idents
+                // must have been the same, and thus were paired.
+                for id in skip_index(IdentIter::from(*left), ident_loc.index) {
+                    paired_identifiers.insert(id);
+                }
+            },
+            IdentDifference::Double(ident_loc1, ident_loc2) => {
+                double_difference_info = Some((i, ident_loc1, ident_loc2));
+            },
+            IdentDifference::Multiple | IdentDifference::NonIdent => {
+                // It's too hard to know whether this is a bug or not.
+                return;
+            },
+        }
+    }
+
+    let mut applicability = Applicability::MachineApplicable;
+
+    if let Some(expected_loc) = expected_ident_loc {
+        match (no_difference_info, double_difference_info) {
+            (Some(i), None) => attempt_to_emit_no_difference_lint(cx, binops, i, expected_loc),
+            (None, Some((double_difference_index, ident_loc1, ident_loc2))) => {
+                if_chain! {
+                    if one_ident_difference_count == binop_count - 1;
+                    if let Some(binop) = binops.get(double_difference_index);
+                    then {
+                        let changed_loc = if ident_loc1 == expected_loc {
+                            ident_loc2
+                        } else if ident_loc2 == expected_loc {
+                            ident_loc1
+                        } else {
+                            // This expression doesn't match the form we're
+                            // looking for.
+                            return;
+                        };
+
+                        if let Some(sugg) = ident_swap_sugg(
+                            cx,
+                            &paired_identifiers,
+                            binop,
+                            changed_loc,
+                            &mut applicability,
+                        ) {
+                            emit_suggestion(
+                                cx,
+                                binop.span,
+                                sugg,
+                                applicability,
+                            );
+                        }
+                    }
+                }
+            },
+            _ => {},
+        }
+    }
+}
+
+fn attempt_to_emit_no_difference_lint(
+    cx: &EarlyContext<'_>,
+    binops: &[&BinaryOp<'_>],
+    i: usize,
+    expected_loc: IdentLocation,
+) {
+    if let Some(binop) = binops.get(i).cloned() {
+        // We need to try and figure out which identifier we should
+        // suggest using instead. Since there could be multiple
+        // replacement candidates in a given expression, and we're
+        // just taking the first one, we may get some bad lint
+        // messages.
+        let mut applicability = Applicability::MaybeIncorrect;
+
+        // We assume that the correct ident is one used elsewhere in
+        // the other binops, in a place that there was a single
+        // difference between idents before.
+        let old_left_ident = get_ident(binop.left, expected_loc);
+        let old_right_ident = get_ident(binop.right, expected_loc);
+
+        for b in skip_index(binops.iter(), i) {
+            if_chain! {
+                if let (Some(old_ident), Some(new_ident)) =
+                (old_left_ident, get_ident(b.left, expected_loc));
+                if old_ident != new_ident;
+                if let Some(sugg) = suggestion_with_swapped_ident(
+                    cx,
+                    binop.left,
+                    expected_loc,
+                    new_ident,
+                    &mut applicability,
+                );
+                then {
+                    emit_suggestion(
+                        cx,
+                        binop.span,
+                        replace_left_sugg(cx, &binop, &sugg, &mut applicability),
+                        applicability,
+                    );
+                    return;
+                }
+            }
+
+            if_chain! {
+                if let (Some(old_ident), Some(new_ident)) =
+                    (old_right_ident, get_ident(b.right, expected_loc));
+                if old_ident != new_ident;
+                if let Some(sugg) = suggestion_with_swapped_ident(
+                    cx,
+                    binop.right,
+                    expected_loc,
+                    new_ident,
+                    &mut applicability,
+                );
+                then {
+                    emit_suggestion(
+                        cx,
+                        binop.span,
+                        replace_right_sugg(cx, &binop, &sugg, &mut applicability),
+                        applicability,
+                    );
+                    return;
+                }
+            }
+        }
+    }
+}
+
+fn emit_suggestion(cx: &EarlyContext<'_>, span: Span, sugg: String, applicability: Applicability) {
+    span_lint_and_sugg(
+        cx,
+        SUSPICIOUS_OPERATION_GROUPINGS,
+        span,
+        "This sequence of operators looks suspiciously like a bug.",
+        "I think you meant",
+        sugg,
+        applicability,
+    )
+}
+
+fn ident_swap_sugg(
+    cx: &EarlyContext<'_>,
+    paired_identifiers: &FxHashSet<Ident>,
+    binop: &BinaryOp<'_>,
+    location: IdentLocation,
+    applicability: &mut Applicability,
+) -> Option<String> {
+    let left_ident = get_ident(&binop.left, location)?;
+    let right_ident = get_ident(&binop.right, location)?;
+
+    let sugg = match (
+        paired_identifiers.contains(&left_ident),
+        paired_identifiers.contains(&right_ident),
+    ) {
+        (true, true) | (false, false) => {
+            // We don't have a good guess of what ident should be
+            // used instead, in these cases.
+            *applicability = Applicability::MaybeIncorrect;
+
+            // We arbitraily choose one side to suggest changing,
+            // since we don't have a better guess. If the user
+            // ends up duplicating a clause, the `logic_bug` lint
+            // should catch it.
+
+            let right_suggestion =
+                suggestion_with_swapped_ident(cx, &binop.right, location, left_ident, applicability)?;
+
+            replace_right_sugg(cx, binop, &right_suggestion, applicability)
+        },
+        (false, true) => {
+            // We haven't seen a pair involving the left one, so
+            // it's probably what is wanted.
+
+            let right_suggestion =
+                suggestion_with_swapped_ident(cx, &binop.right, location, left_ident, applicability)?;
+
+            replace_right_sugg(cx, binop, &right_suggestion, applicability)
+        },
+        (true, false) => {
+            // We haven't seen a pair involving the right one, so
+            // it's probably what is wanted.
+            let left_suggestion = suggestion_with_swapped_ident(cx, &binop.left, location, right_ident, applicability)?;
+
+            replace_left_sugg(cx, binop, &left_suggestion, applicability)
+        },
+    };
+
+    Some(sugg)
+}
+
+fn replace_left_sugg(
+    cx: &EarlyContext<'_>,
+    binop: &BinaryOp<'_>,
+    left_suggestion: &str,
+    applicability: &mut Applicability,
+) -> String {
+    format!(
+        "{} {} {}",
+        left_suggestion,
+        binop.op.to_string(),
+        snippet_with_applicability(cx, binop.right.span, "..", applicability),
+    )
+}
+
+fn replace_right_sugg(
+    cx: &EarlyContext<'_>,
+    binop: &BinaryOp<'_>,
+    right_suggestion: &str,
+    applicability: &mut Applicability,
+) -> String {
+    format!(
+        "{} {} {}",
+        snippet_with_applicability(cx, binop.left.span, "..", applicability),
+        binop.op.to_string(),
+        right_suggestion,
+    )
+}
+
+#[derive(Clone, Debug)]
+struct BinaryOp<'exprs> {
+    op: BinOpKind,
+    span: Span,
+    left: &'exprs Expr,
+    right: &'exprs Expr,
+}
+
+impl BinaryOp<'exprs> {
+    fn new(op: BinOpKind, span: Span, (left, right): (&'exprs Expr, &'exprs Expr)) -> Self {
+        Self { op, span, left, right }
+    }
+}
+
+fn strip_non_ident_wrappers(expr: &Expr) -> &Expr {
+    let mut output = expr;
+    loop {
+        output = match &output.kind {
+            ExprKind::Paren(ref inner) | ExprKind::Unary(_, ref inner) => inner,
+            _ => {
+                return output;
+            },
+        };
+    }
+}
+
+fn extract_related_binops(kind: &ExprKind) -> Option<Vec<BinaryOp<'_>>> {
+    append_opt_vecs(chained_binops(kind), if_statment_binops(kind))
+}
+
+fn if_statment_binops(kind: &ExprKind) -> Option<Vec<BinaryOp<'_>>> {
+    match kind {
+        ExprKind::If(ref condition, _, _) => chained_binops(&condition.kind),
+        ExprKind::Paren(ref e) => if_statment_binops(&e.kind),
+        ExprKind::Block(ref block, _) => {
+            let mut output = None;
+            for stmt in &block.stmts {
+                match stmt.kind {
+                    StmtKind::Expr(ref e) | StmtKind::Semi(ref e) => {
+                        output = append_opt_vecs(output, if_statment_binops(&e.kind));
+                    },
+                    _ => {},
+                }
+            }
+            output
+        },
+        _ => None,
+    }
+}
+
+fn append_opt_vecs<A>(target_opt: Option<Vec<A>>, source_opt: Option<Vec<A>>) -> Option<Vec<A>> {
+    match (target_opt, source_opt) {
+        (Some(mut target), Some(mut source)) => {
+            target.reserve(source.len());
+            for op in source.drain(..) {
+                target.push(op);
+            }
+            Some(target)
+        },
+        (Some(v), None) | (None, Some(v)) => Some(v),
+        (None, None) => None,
+    }
+}
+
+fn chained_binops(kind: &ExprKind) -> Option<Vec<BinaryOp<'_>>> {
+    match kind {
+        ExprKind::Binary(_, left_outer, right_outer) => chained_binops_helper(left_outer, right_outer),
+        ExprKind::Paren(ref e) | ExprKind::Unary(_, ref e) => chained_binops(&e.kind),
+        _ => None,
+    }
+}
+
+fn chained_binops_helper(left_outer: &'expr Expr, right_outer: &'expr Expr) -> Option<Vec<BinaryOp<'expr>>> {
+    match (&left_outer.kind, &right_outer.kind) {
+        (
+            ExprKind::Paren(ref left_e) | ExprKind::Unary(_, ref left_e),
+            ExprKind::Paren(ref right_e) | ExprKind::Unary(_, ref right_e),
+        ) => chained_binops_helper(left_e, right_e),
+        (ExprKind::Paren(ref left_e) | ExprKind::Unary(_, ref left_e), _) => chained_binops_helper(left_e, right_outer),
+        (_, ExprKind::Paren(ref right_e) | ExprKind::Unary(_, ref right_e)) => {
+            chained_binops_helper(left_outer, right_e)
+        },
+        (
+            ExprKind::Binary(Spanned { node: left_op, .. }, ref left_left, ref left_right),
+            ExprKind::Binary(Spanned { node: right_op, .. }, ref right_left, ref right_right),
+        ) => match (
+            chained_binops_helper(left_left, left_right),
+            chained_binops_helper(right_left, right_right),
+        ) {
+            (Some(mut left_ops), Some(mut right_ops)) => {
+                left_ops.reserve(right_ops.len());
+                for op in right_ops.drain(..) {
+                    left_ops.push(op);
+                }
+                Some(left_ops)
+            },
+            (Some(mut left_ops), _) => {
+                left_ops.push(BinaryOp::new(*right_op, right_outer.span, (right_left, right_right)));
+                Some(left_ops)
+            },
+            (_, Some(mut right_ops)) => {
+                right_ops.insert(0, BinaryOp::new(*left_op, left_outer.span, (left_left, left_right)));
+                Some(right_ops)
+            },
+            (None, None) => Some(vec![
+                BinaryOp::new(*left_op, left_outer.span, (left_left, left_right)),
+                BinaryOp::new(*right_op, right_outer.span, (right_left, right_right)),
+            ]),
+        },
+        _ => None,
+    }
+}
+
+#[derive(Clone, Copy, PartialEq, Eq, Default, Debug)]
+struct IdentLocation {
+    index: usize,
+}
+
+impl Add for IdentLocation {
+    type Output = IdentLocation;
+
+    fn add(self, other: Self) -> Self::Output {
+        Self {
+            index: self.index + other.index,
+        }
+    }
+}
+
+impl AddAssign for IdentLocation {
+    fn add_assign(&mut self, other: Self) {
+        *self = *self + other
+    }
+}
+
+#[derive(Clone, Copy, Debug)]
+enum IdentDifference {
+    NoDifference,
+    Single(IdentLocation),
+    Double(IdentLocation, IdentLocation),
+    Multiple,
+    NonIdent,
+}
+
+impl Add for IdentDifference {
+    type Output = IdentDifference;
+
+    fn add(self, other: Self) -> Self::Output {
+        match (self, other) {
+            (Self::NoDifference, output) | (output, Self::NoDifference) => output,
+            (Self::Multiple, _)
+            | (_, Self::Multiple)
+            | (Self::Double(_, _), Self::Single(_))
+            | (Self::Single(_) | Self::Double(_, _), Self::Double(_, _)) => Self::Multiple,
+            (Self::NonIdent, _) | (_, Self::NonIdent) => Self::NonIdent,
+            (Self::Single(il1), Self::Single(il2)) => Self::Double(il1, il2),
+        }
+    }
+}
+
+impl AddAssign for IdentDifference {
+    fn add_assign(&mut self, other: Self) {
+        *self = *self + other
+    }
+}
+
+impl IdentDifference {
+    /// Returns true if learning about more differences will not change the value
+    /// of this `IdentDifference`, and false otherwise.
+    fn is_complete(&self) -> bool {
+        match self {
+            Self::NoDifference | Self::Single(_) | Self::Double(_, _) => false,
+            Self::Multiple | Self::NonIdent => true,
+        }
+    }
+}
+
+fn ident_difference_expr(left: &Expr, right: &Expr) -> IdentDifference {
+    ident_difference_expr_with_base_location(left, right, IdentLocation::default()).0
+}
+
+fn ident_difference_expr_with_base_location(
+    left: &Expr,
+    right: &Expr,
+    mut base: IdentLocation,
+) -> (IdentDifference, IdentLocation) {
+    // Ideally, this function should not use IdentIter because it should return
+    // early if the expressions have any non-ident differences. We want that early
+    // return because if without that restriction the lint would lead to false
+    // positives.
+    //
+    // But, we cannot (easily?) use a `rustc_ast::visit::Visitor`, since we need
+    // the two expressions to be walked in lockstep. And without a `Visitor`, we'd
+    // have to do all the AST traversal ourselves, which is a lot of work, since to
+    // do it properly we'd need to be able to handle more or less every possible
+    // AST node since `Item`s can be written inside `Expr`s.
+    //
+    // In practice, it seems likely that expressions, above a certain size, that
+    // happen to use the exact same idents in the exact same order, and which are
+    // not structured the same, would be rare. Therefore it seems likely that if
+    // we do only the first layer of matching ourselves and eventually fallback on
+    // IdentIter, then the output of this function will be almost always be correct
+    // in practice.
+    //
+    // If it turns out that problematic cases are more prelavent than we assume,
+    // then we should be able to change this function to do the correct traversal,
+    // without needing to change the rest of the code.
+
+    #![allow(clippy::enum_glob_use)]
+    use ExprKind::*;
+
+    match (
+        &strip_non_ident_wrappers(left).kind,
+        &strip_non_ident_wrappers(right).kind,
+    ) {
+        (Yield(_), Yield(_))
+        | (Try(_), Try(_))
+        | (Paren(_), Paren(_))
+        | (Repeat(_, _), Repeat(_, _))
+        | (Struct(_, _, _), Struct(_, _, _))
+        | (MacCall(_), MacCall(_))
+        | (LlvmInlineAsm(_), LlvmInlineAsm(_))
+        | (InlineAsm(_), InlineAsm(_))
+        | (Ret(_), Ret(_))
+        | (Continue(_), Continue(_))
+        | (Break(_, _), Break(_, _))
+        | (AddrOf(_, _, _), AddrOf(_, _, _))
+        | (Path(_, _), Path(_, _))
+        | (Range(_, _, _), Range(_, _, _))
+        | (Index(_, _), Index(_, _))
+        | (Field(_, _), Field(_, _))
+        | (AssignOp(_, _, _), AssignOp(_, _, _))
+        | (Assign(_, _, _), Assign(_, _, _))
+        | (TryBlock(_), TryBlock(_))
+        | (Await(_), Await(_))
+        | (Async(_, _, _), Async(_, _, _))
+        | (Block(_, _), Block(_, _))
+        | (Closure(_, _, _, _, _, _), Closure(_, _, _, _, _, _))
+        | (Match(_, _), Match(_, _))
+        | (Loop(_, _), Loop(_, _))
+        | (ForLoop(_, _, _, _), ForLoop(_, _, _, _))
+        | (While(_, _, _), While(_, _, _))
+        | (If(_, _, _), If(_, _, _))
+        | (Let(_, _), Let(_, _))
+        | (Type(_, _), Type(_, _))
+        | (Cast(_, _), Cast(_, _))
+        | (Lit(_), Lit(_))
+        | (Unary(_, _), Unary(_, _))
+        | (Binary(_, _, _), Binary(_, _, _))
+        | (Tup(_), Tup(_))
+        | (MethodCall(_, _, _), MethodCall(_, _, _))
+        | (Call(_, _), Call(_, _))
+        | (ConstBlock(_), ConstBlock(_))
+        | (Array(_), Array(_))
+        | (Box(_), Box(_)) => {
+            // keep going
+        },
+        _ => {
+            return (IdentDifference::NonIdent, base);
+        },
+    }
+
+    let mut difference = IdentDifference::NoDifference;
+
+    for (left_attr, right_attr) in left.attrs.iter().zip(right.attrs.iter()) {
+        let (new_difference, new_base) =
+            ident_difference_via_ident_iter_with_base_location(left_attr, right_attr, base);
+        base = new_base;
+        difference += new_difference;
+        if difference.is_complete() {
+            return (difference, base);
+        }
+    }
+
+    let (new_difference, new_base) = ident_difference_via_ident_iter_with_base_location(left, right, base);
+    base = new_base;
+    difference += new_difference;
+
+    (difference, base)
+}
+
+fn ident_difference_via_ident_iter_with_base_location<Iterable: Into<IdentIter>>(
+    left: Iterable,
+    right: Iterable,
+    mut base: IdentLocation,
+) -> (IdentDifference, IdentLocation) {
+    // See the note in `ident_difference_expr_with_base_location` about `IdentIter`
+    let mut difference = IdentDifference::NoDifference;
+
+    let mut left_iterator = left.into();
+    let mut right_iterator = right.into();
+
+    loop {
+        match (left_iterator.next(), right_iterator.next()) {
+            (Some(left_ident), Some(right_ident)) => {
+                if !eq_id(left_ident, right_ident) {
+                    difference += IdentDifference::Single(base);
+                    if difference.is_complete() {
+                        return (difference, base);
+                    }
+                }
+            },
+            (Some(_), None) | (None, Some(_)) => {
+                return (IdentDifference::NonIdent, base);
+            },
+            (None, None) => {
+                return (difference, base);
+            },
+        }
+        base += IdentLocation { index: 1 };
+    }
+}
+
+fn get_ident(expr: &Expr, location: IdentLocation) -> Option<Ident> {
+    IdentIter::from(expr).nth(location.index)
+}
+
+fn suggestion_with_swapped_ident(
+    cx: &EarlyContext<'_>,
+    expr: &Expr,
+    location: IdentLocation,
+    new_ident: Ident,
+    applicability: &mut Applicability,
+) -> Option<String> {
+    get_ident(expr, location).and_then(|current_ident| {
+        if eq_id(current_ident, new_ident) {
+            // We never want to suggest a non-change
+            return None;
+        }
+
+        Some(format!(
+            "{}{}{}",
+            snippet_with_applicability(cx, expr.span.with_hi(current_ident.span.lo()), "..", applicability),
+            new_ident.to_string(),
+            snippet_with_applicability(cx, expr.span.with_lo(current_ident.span.hi()), "..", applicability),
+        ))
+    })
+}
+
+fn skip_index<A, Iter>(iter: Iter, index: usize) -> impl Iterator<Item = A>
+where
+    Iter: Iterator<Item = A>,
+{
+    iter.enumerate()
+        .filter_map(move |(i, a)| if i == index { None } else { Some(a) })
+}
diff --git a/clippy_lints/src/utils/ast_utils.rs b/clippy_lints/src/utils/ast_utils.rs
index fcf7a4b1367..31b4e25411b 100644
--- a/clippy_lints/src/utils/ast_utils.rs
+++ b/clippy_lints/src/utils/ast_utils.rs
@@ -10,6 +10,17 @@ use rustc_ast::{self as ast, *};
 use rustc_span::symbol::Ident;
 use std::mem;
 
+pub mod ident_iter;
+pub use ident_iter::IdentIter;
+
+pub fn is_useless_with_eq_exprs(kind: BinOpKind) -> bool {
+    use BinOpKind::*;
+    matches!(
+        kind,
+        Sub | Div | Eq | Lt | Le | Gt | Ge | Ne | And | Or | BitXor | BitAnd | BitOr
+    )
+}
+
 /// Checks if each element in the first slice is contained within the latter as per `eq_fn`.
 pub fn unordered_over<X>(left: &[X], right: &[X], mut eq_fn: impl FnMut(&X, &X) -> bool) -> bool {
     left.len() == right.len() && left.iter().all(|l| right.iter().any(|r| eq_fn(l, r)))
diff --git a/clippy_lints/src/utils/ast_utils/ident_iter.rs b/clippy_lints/src/utils/ast_utils/ident_iter.rs
new file mode 100644
index 00000000000..eefcbabd835
--- /dev/null
+++ b/clippy_lints/src/utils/ast_utils/ident_iter.rs
@@ -0,0 +1,45 @@
+use core::iter::FusedIterator;
+use rustc_ast::visit::{walk_attribute, walk_expr, Visitor};
+use rustc_ast::{Attribute, Expr};
+use rustc_span::symbol::Ident;
+
+pub struct IdentIter(std::vec::IntoIter<Ident>);
+
+impl Iterator for IdentIter {
+    type Item = Ident;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.0.next()
+    }
+}
+
+impl FusedIterator for IdentIter {}
+
+impl From<&Expr> for IdentIter {
+    fn from(expr: &Expr) -> Self {
+        let mut visitor = IdentCollector::default();
+
+        walk_expr(&mut visitor, expr);
+
+        IdentIter(visitor.0.into_iter())
+    }
+}
+
+impl From<&Attribute> for IdentIter {
+    fn from(attr: &Attribute) -> Self {
+        let mut visitor = IdentCollector::default();
+
+        walk_attribute(&mut visitor, attr);
+
+        IdentIter(visitor.0.into_iter())
+    }
+}
+
+#[derive(Default)]
+struct IdentCollector(Vec<Ident>);
+
+impl Visitor<'_> for IdentCollector {
+    fn visit_ident(&mut self, ident: Ident) {
+        self.0.push(ident);
+    }
+}
diff --git a/tests/ui/eq_op.rs b/tests/ui/eq_op.rs
index 4e09d19ea21..7ab23320db6 100644
--- a/tests/ui/eq_op.rs
+++ b/tests/ui/eq_op.rs
@@ -86,3 +86,12 @@ fn check_ignore_macro() {
     // checks if the lint ignores macros with `!` operator
     !bool_macro!(1) && !bool_macro!("");
 }
+
+struct Nested {
+    inner: ((i32,), (i32,), (i32,)),
+}
+
+fn check_nested(n1: &Nested, n2: &Nested) -> bool {
+    // `n2.inner.0.0` mistyped as `n1.inner.0.0`
+    (n1.inner.0).0 == (n1.inner.0).0 && (n1.inner.1).0 == (n2.inner.1).0 && (n1.inner.2).0 == (n2.inner.2).0
+}
diff --git a/tests/ui/eq_op.stderr b/tests/ui/eq_op.stderr
index ad81b35a766..8ef658af8df 100644
--- a/tests/ui/eq_op.stderr
+++ b/tests/ui/eq_op.stderr
@@ -162,5 +162,13 @@ error: equal expressions as operands to `/`
 LL |     const D: u32 = A / A;
    |                    ^^^^^
 
-error: aborting due to 27 previous errors
+error: equal expressions as operands to `==`
+  --> $DIR/eq_op.rs:96:5
+   |
+LL |     (n1.inner.0).0 == (n1.inner.0).0 && (n1.inner.1).0 == (n2.inner.1).0 && (n1.inner.2).0 == (n2.inner.2).0
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `#[deny(clippy::eq_op)]` on by default
+
+error: aborting due to 28 previous errors
 
diff --git a/tests/ui/suspicious_operation_groupings.rs b/tests/ui/suspicious_operation_groupings.rs
new file mode 100644
index 00000000000..dd6f4ec7bd9
--- /dev/null
+++ b/tests/ui/suspicious_operation_groupings.rs
@@ -0,0 +1,207 @@
+#![warn(clippy::suspicious_operation_groupings)]
+
+struct Vec3 {
+    x: f64,
+    y: f64,
+    z: f64,
+}
+
+impl Eq for Vec3 {}
+
+impl PartialEq for Vec3 {
+    fn eq(&self, other: &Self) -> bool {
+        // This should trigger the lint because `self.x` is compared to `other.y`
+        self.x == other.y && self.y == other.y && self.z == other.z
+    }
+}
+
+struct S {
+    a: i32,
+    b: i32,
+    c: i32,
+    d: i32,
+}
+
+fn buggy_ab_cmp(s1: &S, s2: &S) -> bool {
+    // There's no `s1.b`
+    s1.a < s2.a && s1.a < s2.b
+}
+
+struct SAOnly {
+    a: i32,
+}
+
+impl S {
+    fn a(&self) -> i32 {
+        0
+    }
+}
+
+fn do_not_give_bad_suggestions_for_this_unusual_expr(s1: &S, s2: &SAOnly) -> bool {
+    // This is superficially similar to `buggy_ab_cmp`, but we should not suggest
+    // `s2.b` since that is invalid.
+    s1.a < s2.a && s1.a() < s1.b
+}
+
+fn do_not_give_bad_suggestions_for_this_macro_expr(s1: &S, s2: &SAOnly) -> bool {
+    macro_rules! s1 {
+        () => {
+            S {
+                a: 1,
+                b: 1,
+                c: 1,
+                d: 1,
+            }
+        };
+    }
+
+    // This is superficially similar to `buggy_ab_cmp`, but we should not suggest
+    // `s2.b` since that is invalid.
+    s1.a < s2.a && s1!().a < s1.b
+}
+
+fn do_not_give_bad_suggestions_for_this_incorrect_expr(s1: &S, s2: &SAOnly) -> bool {
+    // There's two `s1.b`, but we should not suggest `s2.b` since that is invalid
+    s1.a < s2.a && s1.b < s1.b
+}
+
+fn permissable(s1: &S, s2: &S) -> bool {
+    // Something like this seems like it might actually be what is desired.
+    s1.a == s2.b
+}
+
+fn non_boolean_operators(s1: &S, s2: &S) -> i32 {
+    // There's no `s2.c`
+    s1.a * s2.a + s1.b * s2.b + s1.c * s2.b + s1.d * s2.d
+}
+
+fn odd_number_of_pairs(s1: &S, s2: &S) -> i32 {
+    // There's no `s2.b`
+    s1.a * s2.a + s1.b * s2.c + s1.c * s2.c
+}
+
+fn not_caught_by_eq_op_middle_change_left(s1: &S, s2: &S) -> i32 {
+    // There's no `s1.b`
+    s1.a * s2.a + s2.b * s2.b + s1.c * s2.c
+}
+
+fn not_caught_by_eq_op_middle_change_right(s1: &S, s2: &S) -> i32 {
+    // There's no `s2.b`
+    s1.a * s2.a + s1.b * s1.b + s1.c * s2.c
+}
+
+fn not_caught_by_eq_op_start(s1: &S, s2: &S) -> i32 {
+    // There's no `s2.a`
+    s1.a * s1.a + s1.b * s2.b + s1.c * s2.c
+}
+
+fn not_caught_by_eq_op_end(s1: &S, s2: &S) -> i32 {
+    // There's no `s2.c`
+    s1.a * s2.a + s1.b * s2.b + s1.c * s1.c
+}
+
+fn the_cross_product_should_not_lint(s1: &S, s2: &S) -> (i32, i32, i32) {
+    (
+        s1.b * s2.c - s1.c * s2.b,
+        s1.c * s2.a - s1.a * s2.c,
+        s1.a * s2.b - s1.b * s2.a,
+    )
+}
+
+fn outer_parens_simple(s1: &S, s2: &S) -> i32 {
+    // There's no `s2.b`
+    (s1.a * s2.a + s1.b * s1.b)
+}
+
+fn outer_parens(s1: &S, s2: &S) -> i32 {
+    // There's no `s2.c`
+    (s1.a * s2.a + s1.b * s2.b + s1.c * s2.b + s1.d * s2.d)
+}
+
+fn inner_parens(s1: &S, s2: &S) -> i32 {
+    // There's no `s2.c`
+    (s1.a * s2.a) + (s1.b * s2.b) + (s1.c * s2.b) + (s1.d * s2.d)
+}
+
+fn outer_and_some_inner_parens(s1: &S, s2: &S) -> i32 {
+    // There's no `s2.c`
+    ((s1.a * s2.a) + (s1.b * s2.b) + (s1.c * s2.b) + (s1.d * s2.d))
+}
+
+fn all_parens_balanced_tree(s1: &S, s2: &S) -> i32 {
+    // There's no `s2.c`
+    (((s1.a * s2.a) + (s1.b * s2.b)) + ((s1.c * s2.b) + (s1.d * s2.d)))
+}
+
+fn all_parens_left_tree(s1: &S, s2: &S) -> i32 {
+    // There's no `s2.c`
+    (((s1.a * s2.a) + (s1.b * s2.b) + (s1.c * s2.b)) + (s1.d * s2.d))
+}
+
+fn all_parens_right_tree(s1: &S, s2: &S) -> i32 {
+    // There's no `s2.c`
+    ((s1.a * s2.a) + ((s1.b * s2.b) + (s1.c * s2.b) + (s1.d * s2.d)))
+}
+
+fn inside_other_binop_expression(s1: &S, s2: &S) -> i32 {
+    // There's no `s1.b`
+    (s1.a * s2.a + s2.b * s2.b) / 2
+}
+
+fn inside_function_call(s1: &S, s2: &S) -> i32 {
+    // There's no `s1.b`
+    i32::swap_bytes(s1.a * s2.a + s2.b * s2.b)
+}
+
+fn inside_larger_boolean_expression(s1: &S, s2: &S) -> bool {
+    // There's no `s1.c`
+    s1.a > 0 && s1.b > 0 && s1.d == s2.c && s1.d == s2.d
+}
+
+fn inside_larger_boolean_expression_with_unsorted_ops(s1: &S, s2: &S) -> bool {
+    // There's no `s1.c`
+    s1.a > 0 && s1.d == s2.c && s1.b > 0 && s1.d == s2.d
+}
+
+struct Nested {
+    inner: ((i32,), (i32,), (i32,)),
+}
+
+fn changed_middle_ident(n1: &Nested, n2: &Nested) -> bool {
+    // There's no `n2.inner.2.0`
+    (n1.inner.0).0 == (n2.inner.0).0 && (n1.inner.1).0 == (n2.inner.1).0 && (n1.inner.2).0 == (n2.inner.1).0
+}
+
+// `eq_op` should catch this one.
+fn changed_initial_ident(n1: &Nested, n2: &Nested) -> bool {
+    // There's no `n2.inner.0.0`
+    (n1.inner.0).0 == (n1.inner.0).0 && (n1.inner.1).0 == (n2.inner.1).0 && (n1.inner.2).0 == (n2.inner.2).0
+}
+
+fn inside_fn_with_similar_expression(s1: &S, s2: &S, strict: bool) -> bool {
+    if strict {
+        s1.a < s2.a && s1.b < s2.b
+    } else {
+        // There's no `s1.b` in this subexpression
+        s1.a <= s2.a && s1.a <= s2.b
+    }
+}
+
+fn inside_an_if_statement(s1: &S, s2: &S) {
+    // There's no `s1.b`
+    if s1.a < s2.a && s1.a < s2.b {
+        s1.c = s2.c;
+    }
+}
+
+fn maximum_unary_minus_right_tree(s1: &S, s2: &S) -> i32 {
+    // There's no `s2.c`
+    -(-(-s1.a * -s2.a) + (-(-s1.b * -s2.b) + -(-s1.c * -s2.b) + -(-s1.d * -s2.d)))
+}
+
+fn unary_minus_and_an_if_expression(s1: &S, s2: &S) -> i32 {
+    // There's no `s1.b`
+    -(if -s1.a < -s2.a && -s1.a < -s2.b { s1.c } else { s2.a })
+}
+
+fn main() {}
diff --git a/tests/ui/suspicious_operation_groupings.stderr b/tests/ui/suspicious_operation_groupings.stderr
new file mode 100644
index 00000000000..ce7108217f1
--- /dev/null
+++ b/tests/ui/suspicious_operation_groupings.stderr
@@ -0,0 +1,166 @@
+error: This sequence of operators looks suspiciously like a bug.
+  --> $DIR/suspicious_operation_groupings.rs:14:9
+   |
+LL |         self.x == other.y && self.y == other.y && self.z == other.z
+   |         ^^^^^^^^^^^^^^^^^ help: I think you meant: `self.x == other.x`
+   |
+   = note: `-D clippy::suspicious-operation-groupings` implied by `-D warnings`
+
+error: This sequence of operators looks suspiciously like a bug.
+  --> $DIR/suspicious_operation_groupings.rs:14:9
+   |
+LL |         self.x == other.y && self.y == other.y && self.z == other.z
+   |         ^^^^^^^^^^^^^^^^^ help: I think you meant: `self.x == other.x`
+
+error: This sequence of operators looks suspiciously like a bug.
+  --> $DIR/suspicious_operation_groupings.rs:27:20
+   |
+LL |     s1.a < s2.a && s1.a < s2.b
+   |                    ^^^^^^^^^^^ help: I think you meant: `s1.b < s2.b`
+
+error: This sequence of operators looks suspiciously like a bug.
+  --> $DIR/suspicious_operation_groupings.rs:75:33
+   |
+LL |     s1.a * s2.a + s1.b * s2.b + s1.c * s2.b + s1.d * s2.d
+   |                                 ^^^^^^^^^^^ help: I think you meant: `s1.c * s2.c`
+
+error: This sequence of operators looks suspiciously like a bug.
+  --> $DIR/suspicious_operation_groupings.rs:80:19
+   |
+LL |     s1.a * s2.a + s1.b * s2.c + s1.c * s2.c
+   |                   ^^^^^^^^^^^ help: I think you meant: `s1.b * s2.b`
+
+error: This sequence of operators looks suspiciously like a bug.
+  --> $DIR/suspicious_operation_groupings.rs:80:19
+   |
+LL |     s1.a * s2.a + s1.b * s2.c + s1.c * s2.c
+   |                   ^^^^^^^^^^^ help: I think you meant: `s1.b * s2.b`
+
+error: This sequence of operators looks suspiciously like a bug.
+  --> $DIR/suspicious_operation_groupings.rs:85:19
+   |
+LL |     s1.a * s2.a + s2.b * s2.b + s1.c * s2.c
+   |                   ^^^^^^^^^^^ help: I think you meant: `s1.b * s2.b`
+
+error: This sequence of operators looks suspiciously like a bug.
+  --> $DIR/suspicious_operation_groupings.rs:90:19
+   |
+LL |     s1.a * s2.a + s1.b * s1.b + s1.c * s2.c
+   |                   ^^^^^^^^^^^ help: I think you meant: `s1.b * s2.b`
+
+error: This sequence of operators looks suspiciously like a bug.
+  --> $DIR/suspicious_operation_groupings.rs:95:5
+   |
+LL |     s1.a * s1.a + s1.b * s2.b + s1.c * s2.c
+   |     ^^^^^^^^^^^ help: I think you meant: `s1.a * s2.a`
+
+error: This sequence of operators looks suspiciously like a bug.
+  --> $DIR/suspicious_operation_groupings.rs:100:33
+   |
+LL |     s1.a * s2.a + s1.b * s2.b + s1.c * s1.c
+   |                                 ^^^^^^^^^^^ help: I think you meant: `s1.c * s2.c`
+
+error: This sequence of operators looks suspiciously like a bug.
+  --> $DIR/suspicious_operation_groupings.rs:113:20
+   |
+LL |     (s1.a * s2.a + s1.b * s1.b)
+   |                    ^^^^^^^^^^^ help: I think you meant: `s1.b * s2.b`
+
+error: This sequence of operators looks suspiciously like a bug.
+  --> $DIR/suspicious_operation_groupings.rs:118:34
+   |
+LL |     (s1.a * s2.a + s1.b * s2.b + s1.c * s2.b + s1.d * s2.d)
+   |                                  ^^^^^^^^^^^ help: I think you meant: `s1.c * s2.c`
+
+error: This sequence of operators looks suspiciously like a bug.
+  --> $DIR/suspicious_operation_groupings.rs:123:38
+   |
+LL |     (s1.a * s2.a) + (s1.b * s2.b) + (s1.c * s2.b) + (s1.d * s2.d)
+   |                                      ^^^^^^^^^^^ help: I think you meant: `s1.c * s2.c`
+
+error: This sequence of operators looks suspiciously like a bug.
+  --> $DIR/suspicious_operation_groupings.rs:128:39
+   |
+LL |     ((s1.a * s2.a) + (s1.b * s2.b) + (s1.c * s2.b) + (s1.d * s2.d))
+   |                                       ^^^^^^^^^^^ help: I think you meant: `s1.c * s2.c`
+
+error: This sequence of operators looks suspiciously like a bug.
+  --> $DIR/suspicious_operation_groupings.rs:133:42
+   |
+LL |     (((s1.a * s2.a) + (s1.b * s2.b)) + ((s1.c * s2.b) + (s1.d * s2.d)))
+   |                                          ^^^^^^^^^^^ help: I think you meant: `s1.c * s2.c`
+
+error: This sequence of operators looks suspiciously like a bug.
+  --> $DIR/suspicious_operation_groupings.rs:133:42
+   |
+LL |     (((s1.a * s2.a) + (s1.b * s2.b)) + ((s1.c * s2.b) + (s1.d * s2.d)))
+   |                                          ^^^^^^^^^^^ help: I think you meant: `s1.c * s2.c`
+
+error: This sequence of operators looks suspiciously like a bug.
+  --> $DIR/suspicious_operation_groupings.rs:138:40
+   |
+LL |     (((s1.a * s2.a) + (s1.b * s2.b) + (s1.c * s2.b)) + (s1.d * s2.d))
+   |                                        ^^^^^^^^^^^ help: I think you meant: `s1.c * s2.c`
+
+error: This sequence of operators looks suspiciously like a bug.
+  --> $DIR/suspicious_operation_groupings.rs:143:40
+   |
+LL |     ((s1.a * s2.a) + ((s1.b * s2.b) + (s1.c * s2.b) + (s1.d * s2.d)))
+   |                                        ^^^^^^^^^^^ help: I think you meant: `s1.c * s2.c`
+
+error: This sequence of operators looks suspiciously like a bug.
+  --> $DIR/suspicious_operation_groupings.rs:148:20
+   |
+LL |     (s1.a * s2.a + s2.b * s2.b) / 2
+   |                    ^^^^^^^^^^^ help: I think you meant: `s1.b * s2.b`
+
+error: This sequence of operators looks suspiciously like a bug.
+  --> $DIR/suspicious_operation_groupings.rs:153:35
+   |
+LL |     i32::swap_bytes(s1.a * s2.a + s2.b * s2.b)
+   |                                   ^^^^^^^^^^^ help: I think you meant: `s1.b * s2.b`
+
+error: This sequence of operators looks suspiciously like a bug.
+  --> $DIR/suspicious_operation_groupings.rs:158:29
+   |
+LL |     s1.a > 0 && s1.b > 0 && s1.d == s2.c && s1.d == s2.d
+   |                             ^^^^^^^^^^^^ help: I think you meant: `s1.c == s2.c`
+
+error: This sequence of operators looks suspiciously like a bug.
+  --> $DIR/suspicious_operation_groupings.rs:163:17
+   |
+LL |     s1.a > 0 && s1.d == s2.c && s1.b > 0 && s1.d == s2.d
+   |                 ^^^^^^^^^^^^ help: I think you meant: `s1.c == s2.c`
+
+error: This sequence of operators looks suspiciously like a bug.
+  --> $DIR/suspicious_operation_groupings.rs:172:77
+   |
+LL |     (n1.inner.0).0 == (n2.inner.0).0 && (n1.inner.1).0 == (n2.inner.1).0 && (n1.inner.2).0 == (n2.inner.1).0
+   |                                                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: I think you meant: `(n1.inner.2).0 == (n2.inner.2).0`
+
+error: This sequence of operators looks suspiciously like a bug.
+  --> $DIR/suspicious_operation_groupings.rs:186:25
+   |
+LL |         s1.a <= s2.a && s1.a <= s2.b
+   |                         ^^^^^^^^^^^^ help: I think you meant: `s1.b <= s2.b`
+
+error: This sequence of operators looks suspiciously like a bug.
+  --> $DIR/suspicious_operation_groupings.rs:192:23
+   |
+LL |     if s1.a < s2.a && s1.a < s2.b {
+   |                       ^^^^^^^^^^^ help: I think you meant: `s1.b < s2.b`
+
+error: This sequence of operators looks suspiciously like a bug.
+  --> $DIR/suspicious_operation_groupings.rs:199:48
+   |
+LL |     -(-(-s1.a * -s2.a) + (-(-s1.b * -s2.b) + -(-s1.c * -s2.b) + -(-s1.d * -s2.d)))
+   |                                                ^^^^^^^^^^^^^ help: I think you meant: `-s1.c * -s2.c`
+
+error: This sequence of operators looks suspiciously like a bug.
+  --> $DIR/suspicious_operation_groupings.rs:204:27
+   |
+LL |     -(if -s1.a < -s2.a && -s1.a < -s2.b { s1.c } else { s2.a })
+   |                           ^^^^^^^^^^^^^ help: I think you meant: `-s1.b < -s2.b`
+
+error: aborting due to 27 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From c1b991588f3b2945bddfded808bdab45e250a8dd Mon Sep 17 00:00:00 2001
From: flip1995 <hello@philkrones.com>
Date: Sat, 28 Nov 2020 17:03:20 +0100
Subject: Fix weird dogfood error

---
 clippy_lints/src/redundant_closure_call.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/redundant_closure_call.rs b/clippy_lints/src/redundant_closure_call.rs
index 49cb2ffc4e3..f398b3fff25 100644
--- a/clippy_lints/src/redundant_closure_call.rs
+++ b/clippy_lints/src/redundant_closure_call.rs
@@ -104,7 +104,7 @@ impl<'tcx> LateLintPass<'tcx> for RedundantClosureCall {
                 cx: &'a LateContext<'tcx>,
                 path: &'tcx hir::Path<'tcx>,
                 count: usize,
-            };
+            }
             impl<'a, 'tcx> hir_visit::Visitor<'tcx> for ClosureUsageCount<'a, 'tcx> {
                 type Map = Map<'tcx>;
 
@@ -124,7 +124,7 @@ impl<'tcx> LateLintPass<'tcx> for RedundantClosureCall {
                 fn nested_visit_map(&mut self) -> hir_visit::NestedVisitorMap<Self::Map> {
                     hir_visit::NestedVisitorMap::OnlyBodies(self.cx.tcx.hir())
                 }
-            };
+            }
             let mut closure_usage_count = ClosureUsageCount { cx, path, count: 0 };
             closure_usage_count.visit_block(block);
             closure_usage_count.count
-- 
cgit 1.4.1-3-g733a5


From 0e5aee1fc1251493c35a4344700798e9a586ef16 Mon Sep 17 00:00:00 2001
From: flip1995 <hello@philkrones.com>
Date: Sat, 28 Nov 2020 17:18:15 +0100
Subject: items_after_statements: don't lint when they a separated by trailing
 semicolons

---
 clippy_lints/src/items_after_statements.rs |  4 ++--
 tests/ui/item_after_statement.rs           | 13 +++++++++++++
 2 files changed, 15 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/items_after_statements.rs b/clippy_lints/src/items_after_statements.rs
index 8998fae09de..0927d218446 100644
--- a/clippy_lints/src/items_after_statements.rs
+++ b/clippy_lints/src/items_after_statements.rs
@@ -58,12 +58,12 @@ impl EarlyLintPass for ItemsAfterStatements {
             return;
         }
 
-        // skip initial items
+        // skip initial items and trailing semicolons
         let stmts = item
             .stmts
             .iter()
             .map(|stmt| &stmt.kind)
-            .skip_while(|s| matches!(**s, StmtKind::Item(..)));
+            .skip_while(|s| matches!(**s, StmtKind::Item(..) | StmtKind::Empty));
 
         // lint on all further items
         for stmt in stmts {
diff --git a/tests/ui/item_after_statement.rs b/tests/ui/item_after_statement.rs
index 377e58e4417..d439ca1e4e1 100644
--- a/tests/ui/item_after_statement.rs
+++ b/tests/ui/item_after_statement.rs
@@ -37,3 +37,16 @@ fn mac() {
     b!();
     println!("{}", a);
 }
+
+fn semicolon() {
+    struct S {
+        a: u32,
+    };
+    impl S {
+        fn new(a: u32) -> Self {
+            Self { a }
+        }
+    }
+
+    let _ = S::new(3);
+}
-- 
cgit 1.4.1-3-g733a5


From f7b2098e1c4f8e13ec2194f7f094f471b4056f97 Mon Sep 17 00:00:00 2001
From: Hirochika Matsumoto <matsujika@gmail.com>
Date: Sun, 29 Nov 2020 01:55:15 +0900
Subject: Fix a false positive in `unnecessary_wraps`

---
 clippy_lints/src/methods/mod.rs       | 2 +-
 clippy_lints/src/unnecessary_wraps.rs | 2 ++
 tests/ui/unnecessary_wraps.rs         | 7 +++++++
 3 files changed, 10 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 50dd760432d..004b8416fc1 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3878,7 +3878,7 @@ fn is_bool(ty: &hir::Ty<'_>) -> bool {
 }
 
 // Returns `true` if `expr` contains a return expression
-fn contains_return(expr: &hir::Expr<'_>) -> bool {
+pub(crate) fn contains_return(expr: &hir::Expr<'_>) -> bool {
     struct RetCallFinder {
         found: bool,
     }
diff --git a/clippy_lints/src/unnecessary_wraps.rs b/clippy_lints/src/unnecessary_wraps.rs
index 25ecc7a82f1..7b550c702cd 100644
--- a/clippy_lints/src/unnecessary_wraps.rs
+++ b/clippy_lints/src/unnecessary_wraps.rs
@@ -1,3 +1,4 @@
+use crate::methods::contains_return;
 use crate::utils::{
     in_macro, is_type_diagnostic_item, match_qpath, paths, return_ty, snippet, span_lint_and_then,
     visitors::find_all_ret_expressions,
@@ -95,6 +96,7 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryWraps {
                 if let ExprKind::Path(ref qpath) = func.kind;
                 if match_qpath(qpath, path);
                 if args.len() == 1;
+                if !contains_return(&args[0]);
                 then {
                     suggs.push((ret_expr.span, snippet(cx, args[0].span.source_callsite(), "..").to_string()));
                     true
diff --git a/tests/ui/unnecessary_wraps.rs b/tests/ui/unnecessary_wraps.rs
index a53dec8f91a..a4570098d71 100644
--- a/tests/ui/unnecessary_wraps.rs
+++ b/tests/ui/unnecessary_wraps.rs
@@ -109,6 +109,13 @@ impl B for A {
     }
 }
 
+fn issue_6384(s: &str) -> Option<&str> {
+    Some(match s {
+        "a" => "A",
+        _ => return None,
+    })
+}
+
 fn main() {
     // method calls are not linted
     func1(true, true);
-- 
cgit 1.4.1-3-g733a5


From 2c26cb14db4d3a86aea0a897f9b727cef4e72e27 Mon Sep 17 00:00:00 2001
From: Hirochika Matsumoto <matsujika@gmail.com>
Date: Sun, 29 Nov 2020 02:18:05 +0900
Subject: Move `contains_return` to utils/mod.rs

---
 clippy_lints/src/methods/mod.rs       | 43 +++++------------------------------
 clippy_lints/src/unnecessary_wraps.rs |  3 +--
 clippy_lints/src/utils/mod.rs         | 30 ++++++++++++++++++++++++
 3 files changed, 37 insertions(+), 39 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 004b8416fc1..1476408e0fb 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -14,10 +14,8 @@ use if_chain::if_chain;
 use rustc_ast::ast;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
-use rustc_hir::intravisit::{self, Visitor};
 use rustc_hir::{TraitItem, TraitItemKind};
 use rustc_lint::{LateContext, LateLintPass, Lint, LintContext};
-use rustc_middle::hir::map::Map;
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::{self, TraitRef, Ty, TyS};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
@@ -28,11 +26,12 @@ use crate::consts::{constant, Constant};
 use crate::utils::eager_or_lazy::is_lazyness_candidate;
 use crate::utils::usage::mutated_variables;
 use crate::utils::{
-    contains_ty, get_arg_name, get_parent_expr, get_trait_def_id, has_iter_method, higher, implements_trait, in_macro,
-    is_copy, is_expn_of, is_type_diagnostic_item, iter_input_pats, last_path_segment, match_def_path, match_qpath,
-    match_trait_method, match_type, match_var, meets_msrv, method_calls, method_chain_args, paths, remove_blocks,
-    return_ty, single_segment_path, snippet, snippet_with_applicability, snippet_with_macro_callsite, span_lint,
-    span_lint_and_help, span_lint_and_sugg, span_lint_and_then, sugg, walk_ptrs_ty_depth, SpanlessEq,
+    contains_return, contains_ty, get_arg_name, get_parent_expr, get_trait_def_id, has_iter_method, higher,
+    implements_trait, in_macro, is_copy, is_expn_of, is_type_diagnostic_item, iter_input_pats, last_path_segment,
+    match_def_path, match_qpath, match_trait_method, match_type, match_var, meets_msrv, method_calls,
+    method_chain_args, paths, remove_blocks, return_ty, single_segment_path, snippet, snippet_with_applicability,
+    snippet_with_macro_callsite, span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then, sugg,
+    walk_ptrs_ty_depth, SpanlessEq,
 };
 use semver::{Version, VersionReq};
 
@@ -3877,36 +3876,6 @@ fn is_bool(ty: &hir::Ty<'_>) -> bool {
     }
 }
 
-// Returns `true` if `expr` contains a return expression
-pub(crate) fn contains_return(expr: &hir::Expr<'_>) -> bool {
-    struct RetCallFinder {
-        found: bool,
-    }
-
-    impl<'tcx> intravisit::Visitor<'tcx> for RetCallFinder {
-        type Map = Map<'tcx>;
-
-        fn visit_expr(&mut self, expr: &'tcx hir::Expr<'_>) {
-            if self.found {
-                return;
-            }
-            if let hir::ExprKind::Ret(..) = &expr.kind {
-                self.found = true;
-            } else {
-                intravisit::walk_expr(self, expr);
-            }
-        }
-
-        fn nested_visit_map(&mut self) -> intravisit::NestedVisitorMap<Self::Map> {
-            intravisit::NestedVisitorMap::None
-        }
-    }
-
-    let mut visitor = RetCallFinder { found: false };
-    visitor.visit_expr(expr);
-    visitor.found
-}
-
 fn check_pointer_offset(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::Expr<'_>]) {
     if_chain! {
         if args.len() == 2;
diff --git a/clippy_lints/src/unnecessary_wraps.rs b/clippy_lints/src/unnecessary_wraps.rs
index 7b550c702cd..360df2a6752 100644
--- a/clippy_lints/src/unnecessary_wraps.rs
+++ b/clippy_lints/src/unnecessary_wraps.rs
@@ -1,6 +1,5 @@
-use crate::methods::contains_return;
 use crate::utils::{
-    in_macro, is_type_diagnostic_item, match_qpath, paths, return_ty, snippet, span_lint_and_then,
+    contains_return, in_macro, is_type_diagnostic_item, match_qpath, paths, return_ty, snippet, span_lint_and_then,
     visitors::find_all_ret_expressions,
 };
 use if_chain::if_chain;
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index 6f89e51279a..850abc3bae7 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -572,6 +572,36 @@ pub fn contains_name(name: Symbol, expr: &Expr<'_>) -> bool {
     cn.result
 }
 
+/// Returns `true` if `expr` contains a return expression
+pub fn contains_return(expr: &hir::Expr<'_>) -> bool {
+    struct RetCallFinder {
+        found: bool,
+    }
+
+    impl<'tcx> hir::intravisit::Visitor<'tcx> for RetCallFinder {
+        type Map = Map<'tcx>;
+
+        fn visit_expr(&mut self, expr: &'tcx hir::Expr<'_>) {
+            if self.found {
+                return;
+            }
+            if let hir::ExprKind::Ret(..) = &expr.kind {
+                self.found = true;
+            } else {
+                hir::intravisit::walk_expr(self, expr);
+            }
+        }
+
+        fn nested_visit_map(&mut self) -> hir::intravisit::NestedVisitorMap<Self::Map> {
+            hir::intravisit::NestedVisitorMap::None
+        }
+    }
+
+    let mut visitor = RetCallFinder { found: false };
+    visitor.visit_expr(expr);
+    visitor.found
+}
+
 /// Converts a span to a code snippet if available, otherwise use default.
 ///
 /// This is useful if you want to provide suggestions for your lint or more generally, if you want
-- 
cgit 1.4.1-3-g733a5


From e266708c42dd3d9489586e65b9c6cd1bee0046d5 Mon Sep 17 00:00:00 2001
From: Aleksei Latyshev <alex_700_95@mail.ru>
Date: Wed, 4 Nov 2020 21:16:25 +0300
Subject: do not trigger MATCH_LIKE_MATCHES_MACRO lint with attrs

- it can't be solved completely for attrs evaluated into `false`
- change applicability to MaybeIncorrect and mention it in docs
---
 clippy_lints/src/matches.rs | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index d695af4de21..c49abbf781e 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -459,7 +459,8 @@ declare_clippy_lint! {
     ///
     /// **Why is this bad?** Readability and needless complexity.
     ///
-    /// **Known problems:** None
+    /// **Known problems:** It can be FP triggered, when some arms have `cfg`
+    /// attributes, which evaluate into `false`.
     ///
     /// **Example:**
     /// ```rust
@@ -1167,13 +1168,16 @@ fn find_matches_sugg(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>], expr
         if b0 != b1;
         let if_guard = &b0_arms[0].guard;
         if if_guard.is_none() || b0_arms.len() == 1;
+        if b0_arms[0].attrs.is_empty();
         if b0_arms[1..].iter()
             .all(|arm| {
                 find_bool_lit(&arm.body.kind, desugared).map_or(false, |b| b == b0) &&
-                arm.guard.is_none()
+                arm.guard.is_none() && arm.attrs.is_empty()
             });
         then {
-            let mut applicability = Applicability::MachineApplicable;
+            // The suggestion may be incorrect, because some arms can have `cfg` attributes
+            // evaluated into `false` and so such arms will be stripped before.
+            let mut applicability = Applicability::MaybeIncorrect;
             let pat = {
                 use itertools::Itertools as _;
                 b0_arms.iter()
-- 
cgit 1.4.1-3-g733a5


From 22e7775aa798c1e4688089c150c0a077b9875bf0 Mon Sep 17 00:00:00 2001
From: Philipp Krones <hello@philkrones.com>
Date: Sat, 28 Nov 2020 18:58:53 +0100
Subject: Change formulation of known problems section

---
 clippy_lints/src/matches.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index c49abbf781e..52da580b521 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -459,8 +459,8 @@ declare_clippy_lint! {
     ///
     /// **Why is this bad?** Readability and needless complexity.
     ///
-    /// **Known problems:** It can be FP triggered, when some arms have `cfg`
-    /// attributes, which evaluate into `false`.
+    /// **Known problems:** This lint falsely triggers, if there are arms with
+    /// `cfg` attributes that remove an arm evaluating to `false`. 
     ///
     /// **Example:**
     /// ```rust
-- 
cgit 1.4.1-3-g733a5


From 76f2c10fb6afb9071c56e8b6e410671573648ef4 Mon Sep 17 00:00:00 2001
From: Rajkumar Natarajan <rajkumar.natarajan@synacor.com>
Date: Sat, 28 Nov 2020 12:19:57 -0500
Subject: issue_6357 update unreachable macro usage

---
 clippy_lints/src/panic_unimplemented.rs | 9 ++-------
 tests/ui/panicking_macros.stderr        | 8 ++++----
 2 files changed, 6 insertions(+), 11 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/panic_unimplemented.rs b/clippy_lints/src/panic_unimplemented.rs
index 31b03ecd101..359620cc079 100644
--- a/clippy_lints/src/panic_unimplemented.rs
+++ b/clippy_lints/src/panic_unimplemented.rs
@@ -66,7 +66,7 @@ declare_clippy_lint! {
     /// ```
     pub UNREACHABLE,
     restriction,
-    "`unreachable!` should not be present in production code"
+    "usage of the `unreachable!` macro"
 }
 
 declare_lint_pass!(PanicUnimplemented => [UNIMPLEMENTED, UNREACHABLE, TODO, PANIC]);
@@ -85,12 +85,7 @@ impl<'tcx> LateLintPass<'tcx> for PanicUnimplemented {
             } else if is_expn_of(expr.span, "todo").is_some() {
                 span_lint(cx, TODO, span, "`todo` should not be present in production code");
             } else if is_expn_of(expr.span, "unreachable").is_some() {
-                span_lint(
-                    cx,
-                    UNREACHABLE,
-                    span,
-                    "`unreachable` should not be present in production code",
-                );
+                span_lint(cx, UNREACHABLE, span, "usage of the `unreachable!` macro");
             } else if is_expn_of(expr.span, "panic").is_some() {
                 span_lint(cx, PANIC, span, "`panic` should not be present in production code");
             }
diff --git a/tests/ui/panicking_macros.stderr b/tests/ui/panicking_macros.stderr
index 83234c0ed92..6028323a3c8 100644
--- a/tests/ui/panicking_macros.stderr
+++ b/tests/ui/panicking_macros.stderr
@@ -62,7 +62,7 @@ error: `unimplemented` should not be present in production code
 LL |     unimplemented!("{} {}", "panic with", "multiple arguments");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: `unreachable` should not be present in production code
+error: usage of the `unreachable!` macro
   --> $DIR/panicking_macros.rs:32:5
    |
 LL |     unreachable!();
@@ -70,7 +70,7 @@ LL |     unreachable!();
    |
    = note: `-D clippy::unreachable` implied by `-D warnings`
 
-error: `unreachable` should not be present in production code
+error: usage of the `unreachable!` macro
   --> $DIR/panicking_macros.rs:33:5
    |
 LL |     unreachable!("message");
@@ -78,7 +78,7 @@ LL |     unreachable!("message");
    |
    = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: `unreachable` should not be present in production code
+error: usage of the `unreachable!` macro
   --> $DIR/panicking_macros.rs:34:5
    |
 LL |     unreachable!("{} {}", "panic with", "multiple arguments");
@@ -102,7 +102,7 @@ error: `unimplemented` should not be present in production code
 LL |     unimplemented!();
    |     ^^^^^^^^^^^^^^^^^
 
-error: `unreachable` should not be present in production code
+error: usage of the `unreachable!` macro
   --> $DIR/panicking_macros.rs:43:5
    |
 LL |     unreachable!();
-- 
cgit 1.4.1-3-g733a5


From 84cdb0a939cec1e13d6f464bb7b036ff3b92dfb0 Mon Sep 17 00:00:00 2001
From: Philipp Krones <hello@philkrones.com>
Date: Sat, 28 Nov 2020 22:40:46 +0100
Subject: Fix formatting

---
 clippy_lints/src/matches.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index 52da580b521..665c59d7093 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -460,7 +460,7 @@ declare_clippy_lint! {
     /// **Why is this bad?** Readability and needless complexity.
     ///
     /// **Known problems:** This lint falsely triggers, if there are arms with
-    /// `cfg` attributes that remove an arm evaluating to `false`. 
+    /// `cfg` attributes that remove an arm evaluating to `false`.
     ///
     /// **Example:**
     /// ```rust
-- 
cgit 1.4.1-3-g733a5


From cd087e5c5e65fa61c0562ceb2d2488f8f5660454 Mon Sep 17 00:00:00 2001
From: Suyash458 <suyash.behera458@gmail.com>
Date: Sat, 28 Nov 2020 19:41:27 +0530
Subject: add rustc-semver to dependencies switch Version/VersionReq usages to
 RustcVersion

---
 clippy_lints/Cargo.toml                   |  1 +
 clippy_lints/src/manual_non_exhaustive.rs | 14 ++++----------
 clippy_lints/src/manual_strip.rs          | 14 ++++----------
 clippy_lints/src/matches.rs               | 14 ++++----------
 clippy_lints/src/methods/mod.rs           | 16 +++++-----------
 clippy_lints/src/utils/mod.rs             | 10 +++++-----
 6 files changed, 23 insertions(+), 46 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/Cargo.toml b/clippy_lints/Cargo.toml
index d9471d25197..45fd87b169f 100644
--- a/clippy_lints/Cargo.toml
+++ b/clippy_lints/Cargo.toml
@@ -28,6 +28,7 @@ smallvec = { version = "1", features = ["union"] }
 toml = "0.5.3"
 unicode-normalization = "0.1"
 semver = "0.11"
+rustc-semver="1.0.0"
 # NOTE: cargo requires serde feat in its url dep
 # see <https://github.com/rust-lang/rust/pull/63587#issuecomment-522343864>
 url = { version =  "2.1.0", features = ["serde"] }
diff --git a/clippy_lints/src/manual_non_exhaustive.rs b/clippy_lints/src/manual_non_exhaustive.rs
index 703e6feeca5..91849e74887 100644
--- a/clippy_lints/src/manual_non_exhaustive.rs
+++ b/clippy_lints/src/manual_non_exhaustive.rs
@@ -4,17 +4,11 @@ use rustc_ast::ast::{Attribute, Item, ItemKind, StructField, Variant, VariantDat
 use rustc_attr as attr;
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass};
+use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::{sym, Span};
-use semver::{Version, VersionReq};
 
-const MANUAL_NON_EXHAUSTIVE_MSRV: Version = Version {
-    major: 1,
-    minor: 40,
-    patch: 0,
-    pre: Vec::new(),
-    build: Vec::new(),
-};
+const MANUAL_NON_EXHAUSTIVE_MSRV: RustcVersion = RustcVersion::new(1, 40, 0);
 
 declare_clippy_lint! {
     /// **What it does:** Checks for manual implementations of the non-exhaustive pattern.
@@ -66,12 +60,12 @@ declare_clippy_lint! {
 
 #[derive(Clone)]
 pub struct ManualNonExhaustive {
-    msrv: Option<VersionReq>,
+    msrv: Option<RustcVersion>,
 }
 
 impl ManualNonExhaustive {
     #[must_use]
-    pub fn new(msrv: Option<VersionReq>) -> Self {
+    pub fn new(msrv: Option<RustcVersion>) -> Self {
         Self { msrv }
     }
 }
diff --git a/clippy_lints/src/manual_strip.rs b/clippy_lints/src/manual_strip.rs
index e17e3adb94f..f593abdb104 100644
--- a/clippy_lints/src/manual_strip.rs
+++ b/clippy_lints/src/manual_strip.rs
@@ -13,18 +13,12 @@ use rustc_hir::{BorrowKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::hir::map::Map;
 use rustc_middle::ty;
+use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::Spanned;
 use rustc_span::Span;
-use semver::{Version, VersionReq};
 
-const MANUAL_STRIP_MSRV: Version = Version {
-    major: 1,
-    minor: 45,
-    patch: 0,
-    pre: Vec::new(),
-    build: Vec::new(),
-};
+const MANUAL_STRIP_MSRV: RustcVersion = RustcVersion::new(1, 45, 0);
 
 declare_clippy_lint! {
     /// **What it does:**
@@ -61,12 +55,12 @@ declare_clippy_lint! {
 }
 
 pub struct ManualStrip {
-    msrv: Option<VersionReq>,
+    msrv: Option<RustcVersion>,
 }
 
 impl ManualStrip {
     #[must_use]
-    pub fn new(msrv: Option<VersionReq>) -> Self {
+    pub fn new(msrv: Option<RustcVersion>) -> Self {
         Self { msrv }
     }
 }
diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index 7d64fa6c262..86e3e2f637e 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -20,10 +20,10 @@ use rustc_hir::{
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::{self, Ty, TyS};
+use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::{Span, Spanned};
 use rustc_span::{sym, Symbol};
-use semver::{Version, VersionReq};
 use std::cmp::Ordering;
 use std::collections::hash_map::Entry;
 use std::collections::Bound;
@@ -535,13 +535,13 @@ declare_clippy_lint! {
 
 #[derive(Default)]
 pub struct Matches {
-    msrv: Option<VersionReq>,
+    msrv: Option<RustcVersion>,
     infallible_destructuring_match_linted: bool,
 }
 
 impl Matches {
     #[must_use]
-    pub fn new(msrv: Option<VersionReq>) -> Self {
+    pub fn new(msrv: Option<RustcVersion>) -> Self {
         Self {
             msrv,
             ..Matches::default()
@@ -568,13 +568,7 @@ impl_lint_pass!(Matches => [
     MATCH_SAME_ARMS,
 ]);
 
-const MATCH_LIKE_MATCHES_MACRO_MSRV: Version = Version {
-    major: 1,
-    minor: 42,
-    patch: 0,
-    pre: Vec::new(),
-    build: Vec::new(),
-};
+const MATCH_LIKE_MATCHES_MACRO_MSRV: RustcVersion = RustcVersion::new(1, 42, 0);
 
 impl<'tcx> LateLintPass<'tcx> for Matches {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 1476408e0fb..8002c27a5e9 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -18,6 +18,7 @@ use rustc_hir::{TraitItem, TraitItemKind};
 use rustc_lint::{LateContext, LateLintPass, Lint, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::{self, TraitRef, Ty, TyS};
+use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::Span;
 use rustc_span::symbol::{sym, SymbolStr};
@@ -33,7 +34,6 @@ use crate::utils::{
     snippet_with_macro_callsite, span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then, sugg,
     walk_ptrs_ty_depth, SpanlessEq,
 };
-use semver::{Version, VersionReq};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for `.unwrap()` calls on `Option`s and on `Result`s.
@@ -1405,12 +1405,12 @@ declare_clippy_lint! {
 }
 
 pub struct Methods {
-    msrv: Option<VersionReq>,
+    msrv: Option<RustcVersion>,
 }
 
 impl Methods {
     #[must_use]
-    pub fn new(msrv: Option<VersionReq>) -> Self {
+    pub fn new(msrv: Option<RustcVersion>) -> Self {
         Self { msrv }
     }
 }
@@ -3470,13 +3470,7 @@ fn lint_suspicious_map(cx: &LateContext<'_>, expr: &hir::Expr<'_>) {
     );
 }
 
-const OPTION_AS_REF_DEREF_MSRV: Version = Version {
-    major: 1,
-    minor: 40,
-    patch: 0,
-    pre: Vec::new(),
-    build: Vec::new(),
-};
+const OPTION_AS_REF_DEREF_MSRV: RustcVersion = RustcVersion::new(1, 40, 0);
 
 /// lint use of `_.as_ref().map(Deref::deref)` for `Option`s
 fn lint_option_as_ref_deref<'tcx>(
@@ -3485,7 +3479,7 @@ fn lint_option_as_ref_deref<'tcx>(
     as_ref_args: &[hir::Expr<'_>],
     map_args: &[hir::Expr<'_>],
     is_mut: bool,
-    msrv: Option<&VersionReq>,
+    msrv: Option<&RustcVersion>,
 ) {
     if !meets_msrv(msrv, &OPTION_AS_REF_DEREF_MSRV) {
         return;
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index 850abc3bae7..d68f0698153 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -51,6 +51,7 @@ use rustc_lint::{LateContext, Level, Lint, LintContext};
 use rustc_middle::hir::map::Map;
 use rustc_middle::ty::subst::{GenericArg, GenericArgKind};
 use rustc_middle::ty::{self, layout::IntegerExt, Ty, TyCtxt, TypeFoldable};
+use rustc_semver::RustcVersion;
 use rustc_session::Session;
 use rustc_span::hygiene::{ExpnKind, MacroKind};
 use rustc_span::source_map::original_sp;
@@ -59,13 +60,12 @@ use rustc_span::symbol::{self, kw, Symbol};
 use rustc_span::{BytePos, Pos, Span, DUMMY_SP};
 use rustc_target::abi::Integer;
 use rustc_trait_selection::traits::query::normalize::AtExt;
-use semver::{Version, VersionReq};
 use smallvec::SmallVec;
 
 use crate::consts::{constant, Constant};
 
-pub fn parse_msrv(msrv: &str, sess: Option<&Session>, span: Option<Span>) -> Option<VersionReq> {
-    if let Ok(version) = VersionReq::parse(msrv) {
+pub fn parse_msrv(msrv: &str, sess: Option<&Session>, span: Option<Span>) -> Option<RustcVersion> {
+    if let Ok(version) = RustcVersion::parse(msrv) {
         return Some(version);
     } else if let Some(sess) = sess {
         if let Some(span) = span {
@@ -75,8 +75,8 @@ pub fn parse_msrv(msrv: &str, sess: Option<&Session>, span: Option<Span>) -> Opt
     None
 }
 
-pub fn meets_msrv(msrv: Option<&VersionReq>, lint_msrv: &Version) -> bool {
-    msrv.map_or(true, |msrv| !msrv.matches(lint_msrv))
+pub fn meets_msrv(msrv: Option<&RustcVersion>, lint_msrv: &RustcVersion) -> bool {
+    msrv.map_or(true, |msrv| msrv > lint_msrv)
 }
 
 macro_rules! extract_msrv_attr {
-- 
cgit 1.4.1-3-g733a5


From a75ab302d28b6751fa1d1d5e47f8a75cebbaaf79 Mon Sep 17 00:00:00 2001
From: suyash458 <suyash.behera458@gmail.com>
Date: Sat, 28 Nov 2020 23:17:43 -0800
Subject: fix dogfood tests

---
 clippy_lints/src/lib.rs | 15 +++++----------
 1 file changed, 5 insertions(+), 10 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 6eb5f6a7f48..52237b76c35 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -966,22 +966,17 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box implicit_return::ImplicitReturn);
     store.register_late_pass(|| box implicit_saturating_sub::ImplicitSaturatingSub);
 
-    let parsed_msrv = conf.msrv.as_ref().and_then(|s| {
+    let msrv = conf.msrv.as_ref().and_then(|s| {
         parse_msrv(s, None, None).or_else(|| {
             sess.err(&format!("error reading Clippy's configuration file. `{}` is not a valid Rust version", s));
             None
         })
     });
 
-    let msrv = parsed_msrv.clone();
-    store.register_late_pass(move || box methods::Methods::new(msrv.clone()));
-    let msrv = parsed_msrv.clone();
-    store.register_late_pass(move || box matches::Matches::new(msrv.clone()));
-    let msrv = parsed_msrv.clone();
-    store.register_early_pass(move || box manual_non_exhaustive::ManualNonExhaustive::new(msrv.clone()));
-    let msrv = parsed_msrv;
-    store.register_late_pass(move || box manual_strip::ManualStrip::new(msrv.clone()));
-
+    store.register_late_pass(move || box methods::Methods::new(msrv));
+    store.register_late_pass(move || box matches::Matches::new(msrv));
+    store.register_early_pass(move || box manual_non_exhaustive::ManualNonExhaustive::new(msrv));
+    store.register_late_pass(move || box manual_strip::ManualStrip::new(msrv));
     store.register_late_pass(|| box map_clone::MapClone);
     store.register_late_pass(|| box map_err_ignore::MapErrIgnore);
     store.register_late_pass(|| box shadow::Shadow);
-- 
cgit 1.4.1-3-g733a5


From af095db64c48caa73211f40e1648dadd6a23a2ca Mon Sep 17 00:00:00 2001
From: suyash458 <suyash.behera458@gmail.com>
Date: Sun, 29 Nov 2020 00:33:07 -0800
Subject: fix msrv check

---
 clippy_lints/src/utils/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index d68f0698153..9c5e55b1ed5 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -76,7 +76,7 @@ pub fn parse_msrv(msrv: &str, sess: Option<&Session>, span: Option<Span>) -> Opt
 }
 
 pub fn meets_msrv(msrv: Option<&RustcVersion>, lint_msrv: &RustcVersion) -> bool {
-    msrv.map_or(true, |msrv| msrv > lint_msrv)
+    msrv.map_or(true, |msrv| msrv >= lint_msrv)
 }
 
 macro_rules! extract_msrv_attr {
-- 
cgit 1.4.1-3-g733a5


From 2838b044875b84bb9dc515ba3aa0c1b9772d870b Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Sun, 8 Nov 2020 13:39:46 +0100
Subject: add internal-lints feature to enable clippys internal lints (off by
 default)

---
 .github/workflows/clippy_bors.yml                  |   4 +-
 Cargo.toml                                         |   5 +-
 clippy_lints/Cargo.toml                            |   2 +
 clippy_lints/src/lib.rs                            |  28 ++++--
 clippy_lints/src/utils/diagnostics.rs              |   4 +-
 clippy_lints/src/utils/mod.rs                      |   1 +
 clippy_lints/src/utils/paths.rs                    |   4 +
 tests/compile-test.rs                              |  15 ++-
 tests/dogfood.rs                                   |  47 +++++++---
 .../ui-internal/collapsible_span_lint_calls.fixed  |  91 +++++++++++++++++++
 tests/ui-internal/collapsible_span_lint_calls.rs   | 101 +++++++++++++++++++++
 .../ui-internal/collapsible_span_lint_calls.stderr |  49 ++++++++++
 tests/ui-internal/custom_ice_message.rs            |  10 ++
 tests/ui-internal/custom_ice_message.stderr        |  13 +++
 tests/ui-internal/default_lint.rs                  |  27 ++++++
 tests/ui-internal/default_lint.stderr              |  21 +++++
 tests/ui-internal/invalid_paths.rs                 |  23 +++++
 tests/ui-internal/invalid_paths.stderr             |  16 ++++
 tests/ui-internal/lint_without_lint_pass.rs        |  44 +++++++++
 tests/ui-internal/lint_without_lint_pass.stderr    |  21 +++++
 tests/ui-internal/match_type_on_diag_item.rs       |  50 ++++++++++
 tests/ui-internal/match_type_on_diag_item.stderr   |  33 +++++++
 tests/ui-internal/outer_expn_data.fixed            |  28 ++++++
 tests/ui-internal/outer_expn_data.rs               |  28 ++++++
 tests/ui-internal/outer_expn_data.stderr           |  15 +++
 tests/ui/collapsible_span_lint_calls.fixed         |  91 -------------------
 tests/ui/collapsible_span_lint_calls.rs            | 101 ---------------------
 tests/ui/collapsible_span_lint_calls.stderr        |  49 ----------
 tests/ui/custom_ice_message.rs                     |  10 --
 tests/ui/custom_ice_message.stderr                 |  13 ---
 tests/ui/default_lint.rs                           |  27 ------
 tests/ui/default_lint.stderr                       |  21 -----
 tests/ui/invalid_paths.rs                          |  23 -----
 tests/ui/invalid_paths.stderr                      |  16 ----
 tests/ui/lint_without_lint_pass.rs                 |  44 ---------
 tests/ui/lint_without_lint_pass.stderr             |  21 -----
 tests/ui/match_type_on_diag_item.rs                |  50 ----------
 tests/ui/match_type_on_diag_item.stderr            |  33 -------
 tests/ui/outer_expn_data.fixed                     |  28 ------
 tests/ui/outer_expn_data.rs                        |  28 ------
 tests/ui/outer_expn_data.stderr                    |  15 ---
 41 files changed, 654 insertions(+), 596 deletions(-)
 create mode 100644 tests/ui-internal/collapsible_span_lint_calls.fixed
 create mode 100644 tests/ui-internal/collapsible_span_lint_calls.rs
 create mode 100644 tests/ui-internal/collapsible_span_lint_calls.stderr
 create mode 100644 tests/ui-internal/custom_ice_message.rs
 create mode 100644 tests/ui-internal/custom_ice_message.stderr
 create mode 100644 tests/ui-internal/default_lint.rs
 create mode 100644 tests/ui-internal/default_lint.stderr
 create mode 100644 tests/ui-internal/invalid_paths.rs
 create mode 100644 tests/ui-internal/invalid_paths.stderr
 create mode 100644 tests/ui-internal/lint_without_lint_pass.rs
 create mode 100644 tests/ui-internal/lint_without_lint_pass.stderr
 create mode 100644 tests/ui-internal/match_type_on_diag_item.rs
 create mode 100644 tests/ui-internal/match_type_on_diag_item.stderr
 create mode 100644 tests/ui-internal/outer_expn_data.fixed
 create mode 100644 tests/ui-internal/outer_expn_data.rs
 create mode 100644 tests/ui-internal/outer_expn_data.stderr
 delete mode 100644 tests/ui/collapsible_span_lint_calls.fixed
 delete mode 100644 tests/ui/collapsible_span_lint_calls.rs
 delete mode 100644 tests/ui/collapsible_span_lint_calls.stderr
 delete mode 100644 tests/ui/custom_ice_message.rs
 delete mode 100644 tests/ui/custom_ice_message.stderr
 delete mode 100644 tests/ui/default_lint.rs
 delete mode 100644 tests/ui/default_lint.stderr
 delete mode 100644 tests/ui/invalid_paths.rs
 delete mode 100644 tests/ui/invalid_paths.stderr
 delete mode 100644 tests/ui/lint_without_lint_pass.rs
 delete mode 100644 tests/ui/lint_without_lint_pass.stderr
 delete mode 100644 tests/ui/match_type_on_diag_item.rs
 delete mode 100644 tests/ui/match_type_on_diag_item.stderr
 delete mode 100644 tests/ui/outer_expn_data.fixed
 delete mode 100644 tests/ui/outer_expn_data.rs
 delete mode 100644 tests/ui/outer_expn_data.stderr

(limited to 'clippy_lints/src')

diff --git a/.github/workflows/clippy_bors.yml b/.github/workflows/clippy_bors.yml
index 7509d90c6c2..11c1eeac1cf 100644
--- a/.github/workflows/clippy_bors.yml
+++ b/.github/workflows/clippy_bors.yml
@@ -132,10 +132,10 @@ jobs:
       run: cargo build --features deny-warnings
 
     - name: Test
-      run: cargo test --features deny-warnings
+      run: cargo test --features deny-warnings  --features internal-lints
 
     - name: Test clippy_lints
-      run: cargo test --features deny-warnings
+      run: cargo test --features deny-warnings --features internal-lints
       working-directory: clippy_lints
 
     - name: Test rustc_tools_util
diff --git a/Cargo.toml b/Cargo.toml
index 1ddcd18598d..a765390c603 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -32,7 +32,7 @@ path = "src/driver.rs"
 clippy_lints = { version = "0.0.212", path = "clippy_lints" }
 # end automatic update
 semver = "0.11"
-rustc_tools_util = { version = "0.2.0", path = "rustc_tools_util"}
+rustc_tools_util = { version = "0.2.0", path = "rustc_tools_util" }
 tempfile = { version = "3.1.0", optional = true }
 
 [dev-dependencies]
@@ -49,8 +49,9 @@ derive-new = "0.5"
 rustc-workspace-hack = "1.0.0"
 
 [build-dependencies]
-rustc_tools_util = { version = "0.2.0", path = "rustc_tools_util"}
+rustc_tools_util = { version = "0.2.0", path = "rustc_tools_util" }
 
 [features]
 deny-warnings = []
 integration = ["tempfile"]
+internal-lints = ["clippy_lints/internal-lints"]
diff --git a/clippy_lints/Cargo.toml b/clippy_lints/Cargo.toml
index d9471d25197..969249cc446 100644
--- a/clippy_lints/Cargo.toml
+++ b/clippy_lints/Cargo.toml
@@ -36,3 +36,5 @@ syn = { version = "1", features = ["full"] }
 
 [features]
 deny-warnings = []
+# build clippy with internal lints enabled, off by default
+internal-lints = []
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 6eb5f6a7f48..a58f7eb3666 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -904,14 +904,23 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &unwrap_in_result::UNWRAP_IN_RESULT,
         &use_self::USE_SELF,
         &useless_conversion::USELESS_CONVERSION,
+        #[cfg(feature = "internal-lints")]
         &utils::internal_lints::CLIPPY_LINTS_INTERNAL,
+        #[cfg(feature = "internal-lints")]
         &utils::internal_lints::COLLAPSIBLE_SPAN_LINT_CALLS,
+        #[cfg(feature = "internal-lints")]
         &utils::internal_lints::COMPILER_LINT_FUNCTIONS,
+        #[cfg(feature = "internal-lints")]
         &utils::internal_lints::DEFAULT_LINT,
+        #[cfg(feature = "internal-lints")]
         &utils::internal_lints::INVALID_PATHS,
+        #[cfg(feature = "internal-lints")]
         &utils::internal_lints::LINT_WITHOUT_LINT_PASS,
+        #[cfg(feature = "internal-lints")]
         &utils::internal_lints::MATCH_TYPE_ON_DIAGNOSTIC_ITEM,
+        #[cfg(feature = "internal-lints")]
         &utils::internal_lints::OUTER_EXPN_EXPN_DATA,
+        #[cfg(feature = "internal-lints")]
         &utils::internal_lints::PRODUCE_ICE,
         &vec::USELESS_VEC,
         &vec_resize_to_zero::VEC_RESIZE_TO_ZERO,
@@ -932,11 +941,14 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     // end register lints, do not remove this comment, it’s used in `update_lints`
     store.register_late_pass(|| box await_holding_invalid::AwaitHolding);
     store.register_late_pass(|| box serde_api::SerdeAPI);
-    store.register_late_pass(|| box utils::internal_lints::CompilerLintFunctions::new());
-    store.register_late_pass(|| box utils::internal_lints::LintWithoutLintPass::default());
-    store.register_late_pass(|| box utils::internal_lints::OuterExpnDataPass);
-    store.register_late_pass(|| box utils::internal_lints::InvalidPaths);
-    store.register_late_pass(|| box utils::inspector::DeepCodeInspector);
+    #[cfg(feature = "internal-lints")]
+    {
+        store.register_late_pass(|| box utils::internal_lints::CompilerLintFunctions::new());
+        store.register_late_pass(|| box utils::internal_lints::LintWithoutLintPass::default());
+        store.register_late_pass(|| box utils::internal_lints::OuterExpnDataPass);
+        store.register_late_pass(|| box utils::internal_lints::InvalidPaths);
+        store.register_late_pass(|| box utils::inspector::DeepCodeInspector);
+    }
     store.register_late_pass(|| box utils::author::Author);
     let vec_box_size_threshold = conf.vec_box_size_threshold;
     store.register_late_pass(move || box types::Types::new(vec_box_size_threshold));
@@ -1122,6 +1134,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_early_pass(|| box literal_representation::LiteralDigitGrouping);
     let literal_representation_threshold = conf.literal_representation_threshold;
     store.register_early_pass(move || box literal_representation::DecimalLiteralRepresentation::new(literal_representation_threshold));
+    #[cfg(feature = "internal-lints")]
     store.register_early_pass(|| box utils::internal_lints::ClippyLintsInternal);
     let enum_variant_name_threshold = conf.enum_variant_name_threshold;
     store.register_early_pass(move || box enum_variants::EnumVariantNames::new(enum_variant_name_threshold));
@@ -1136,6 +1149,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(move || box large_const_arrays::LargeConstArrays::new(array_size_threshold));
     store.register_late_pass(|| box floating_point_arithmetic::FloatingPointArithmetic);
     store.register_early_pass(|| box as_conversions::AsConversions);
+    #[cfg(feature = "internal-lints")]
     store.register_early_pass(|| box utils::internal_lints::ProduceIce);
     store.register_late_pass(|| box let_underscore::LetUnderscore);
     store.register_late_pass(|| box atomic_ordering::AtomicOrdering);
@@ -1152,6 +1166,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box dereference::Dereferencing);
     store.register_late_pass(|| box option_if_let_else::OptionIfLetElse);
     store.register_late_pass(|| box future_not_send::FutureNotSend);
+    #[cfg(feature = "internal-lints")]
     store.register_late_pass(|| box utils::internal_lints::CollapsibleCalls);
     store.register_late_pass(|| box if_let_mutex::IfLetMutex);
     store.register_late_pass(|| box mut_mutex_lock::MutMutexLock);
@@ -1177,6 +1192,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box manual_ok_or::ManualOkOr);
     store.register_late_pass(|| box float_equality_without_abs::FloatEqualityWithoutAbs);
     store.register_late_pass(|| box async_yields_async::AsyncYieldsAsync);
+    #[cfg(feature = "internal-lints")]
     store.register_late_pass(|| box utils::internal_lints::MatchTypeOnDiagItem);
     let disallowed_methods = conf.disallowed_methods.iter().cloned().collect::<FxHashSet<_>>();
     store.register_late_pass(move || box disallowed_method::DisallowedMethod::new(&disallowed_methods));
@@ -1317,7 +1333,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&wildcard_imports::ENUM_GLOB_USE),
         LintId::of(&wildcard_imports::WILDCARD_IMPORTS),
     ]);
-
+    #[cfg(feature = "internal-lints")]
     store.register_group(true, "clippy::internal", Some("clippy_internal"), vec![
         LintId::of(&utils::internal_lints::CLIPPY_LINTS_INTERNAL),
         LintId::of(&utils::internal_lints::COLLAPSIBLE_SPAN_LINT_CALLS),
diff --git a/clippy_lints/src/utils/diagnostics.rs b/clippy_lints/src/utils/diagnostics.rs
index 0a58231558e..a7a6b5855b7 100644
--- a/clippy_lints/src/utils/diagnostics.rs
+++ b/clippy_lints/src/utils/diagnostics.rs
@@ -186,7 +186,9 @@ pub fn span_lint_hir_and_then(
 ///     |
 ///     = note: `-D fold-any` implied by `-D warnings`
 /// ```
-#[allow(clippy::collapsible_span_lint_calls)]
+
+#[allow(clippy::unknown_clippy_lints)]
+#[cfg_attr(feature = "internal-lints", allow(clippy::collapsible_span_lint_calls))]
 pub fn span_lint_and_sugg<'a, T: LintContext>(
     cx: &'a T,
     lint: &'static Lint,
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index 850abc3bae7..63f14c592bd 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -14,6 +14,7 @@ pub mod eager_or_lazy;
 pub mod higher;
 mod hir_utils;
 pub mod inspector;
+#[cfg(feature = "internal-lints")]
 pub mod internal_lints;
 pub mod numeric_literal;
 pub mod paths;
diff --git a/clippy_lints/src/utils/paths.rs b/clippy_lints/src/utils/paths.rs
index 61aeabb7ba7..16e6a016c9e 100644
--- a/clippy_lints/src/utils/paths.rs
+++ b/clippy_lints/src/utils/paths.rs
@@ -31,6 +31,7 @@ pub const DISPLAY_TRAIT: [&str; 3] = ["core", "fmt", "Display"];
 pub const DOUBLE_ENDED_ITERATOR: [&str; 4] = ["core", "iter", "traits", "DoubleEndedIterator"];
 pub const DROP: [&str; 3] = ["core", "mem", "drop"];
 pub const DURATION: [&str; 3] = ["core", "time", "Duration"];
+#[cfg(feature = "internal-lints")]
 pub const EARLY_CONTEXT: [&str; 2] = ["rustc_lint", "EarlyContext"];
 pub const EXIT: [&str; 3] = ["std", "process", "exit"];
 pub const F32_EPSILON: [&str; 4] = ["core", "f32", "<impl f32>", "EPSILON"];
@@ -61,8 +62,10 @@ pub const IO_WRITE: [&str; 3] = ["std", "io", "Write"];
 pub const IPADDR_V4: [&str; 4] = ["std", "net", "IpAddr", "V4"];
 pub const IPADDR_V6: [&str; 4] = ["std", "net", "IpAddr", "V6"];
 pub const ITERATOR: [&str; 5] = ["core", "iter", "traits", "iterator", "Iterator"];
+#[cfg(feature = "internal-lints")]
 pub const LATE_CONTEXT: [&str; 2] = ["rustc_lint", "LateContext"];
 pub const LINKED_LIST: [&str; 4] = ["alloc", "collections", "linked_list", "LinkedList"];
+#[cfg(feature = "internal-lints")]
 pub const LINT: [&str; 2] = ["rustc_lint_defs", "Lint"];
 pub const MEM_DISCRIMINANT: [&str; 3] = ["core", "mem", "discriminant"];
 pub const MEM_FORGET: [&str; 3] = ["core", "mem", "forget"];
@@ -133,6 +136,7 @@ pub const STR_ENDS_WITH: [&str; 4] = ["core", "str", "<impl str>", "ends_with"];
 pub const STR_FROM_UTF8: [&str; 4] = ["core", "str", "converts", "from_utf8"];
 pub const STR_LEN: [&str; 4] = ["core", "str", "<impl str>", "len"];
 pub const STR_STARTS_WITH: [&str; 4] = ["core", "str", "<impl str>", "starts_with"];
+#[cfg(feature = "internal-lints")]
 pub const SYNTAX_CONTEXT: [&str; 3] = ["rustc_span", "hygiene", "SyntaxContext"];
 pub const TO_OWNED: [&str; 3] = ["alloc", "borrow", "ToOwned"];
 pub const TO_OWNED_METHOD: [&str; 4] = ["alloc", "borrow", "ToOwned", "to_owned"];
diff --git a/tests/compile-test.rs b/tests/compile-test.rs
index 0e8f7683103..ec3af94b9ca 100644
--- a/tests/compile-test.rs
+++ b/tests/compile-test.rs
@@ -12,6 +12,9 @@ use std::path::{Path, PathBuf};
 
 mod cargo;
 
+// whether to run internal tests or not
+const RUN_INTERNAL_TESTS: bool = cfg!(feature = "internal-lints");
+
 fn host_lib() -> PathBuf {
     option_env!("HOST_LIBS").map_or(cargo::CARGO_TARGET_DIR.join(env!("PROFILE")), PathBuf::from)
 }
@@ -96,6 +99,16 @@ fn run_mode(cfg: &mut compiletest::Config) {
     compiletest::run_tests(&cfg);
 }
 
+fn run_internal_tests(cfg: &mut compiletest::Config) {
+    // only run internal tests with the internal-tests feature
+    if !RUN_INTERNAL_TESTS {
+        return;
+    }
+    cfg.mode = TestMode::Ui;
+    cfg.src_base = Path::new("tests").join("ui-internal");
+    compiletest::run_tests(&cfg);
+}
+
 fn run_ui_toml(config: &mut compiletest::Config) {
     fn run_tests(config: &compiletest::Config, mut tests: Vec<tester::TestDescAndFn>) -> Result<bool, io::Error> {
         let mut result = true;
@@ -199,7 +212,6 @@ fn run_ui_cargo(config: &mut compiletest::Config) {
                         Some("main.rs") => {},
                         _ => continue,
                     }
-
                     let paths = compiletest::common::TestPaths {
                         file: file_path,
                         base: config.src_base.clone(),
@@ -253,4 +265,5 @@ fn compile_test() {
     run_mode(&mut config);
     run_ui_toml(&mut config);
     run_ui_cargo(&mut config);
+    run_internal_tests(&mut config);
 }
diff --git a/tests/dogfood.rs b/tests/dogfood.rs
index 48e0478f169..eae25adf839 100644
--- a/tests/dogfood.rs
+++ b/tests/dogfood.rs
@@ -18,20 +18,39 @@ fn dogfood_clippy() {
     }
     let root_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
 
-    let output = Command::new(&*CLIPPY_PATH)
-        .current_dir(root_dir)
-        .env("CLIPPY_DOGFOOD", "1")
-        .env("CARGO_INCREMENTAL", "0")
-        .arg("clippy-preview")
-        .arg("--all-targets")
-        .arg("--all-features")
-        .arg("--")
-        .args(&["-D", "clippy::all"])
-        .args(&["-D", "clippy::internal"])
-        .args(&["-D", "clippy::pedantic"])
-        .arg("-Cdebuginfo=0") // disable debuginfo to generate less data in the target dir
-        .output()
-        .unwrap();
+    let output = if cfg!(feature = "internal-lints") {
+        // with internal lints and internal warnings
+        Command::new(&*CLIPPY_PATH)
+            .current_dir(root_dir)
+            .env("CLIPPY_DOGFOOD", "1")
+            .env("CARGO_INCREMENTAL", "0")
+            .arg("clippy-preview")
+            .arg("--all-targets")
+            .arg("--all-features")
+            .args(&["--features", "internal-lints"])
+            .arg("--")
+            .args(&["-D", "clippy::all"])
+            .args(&["-D", "clippy::pedantic"])
+            .args(&["-D", "clippy::internal"])
+            .arg("-Cdebuginfo=0") // disable debuginfo to generate less data in the target dir
+            .output()
+            .unwrap()
+    } else {
+        // without internal lints or warnings
+        Command::new(&*CLIPPY_PATH)
+            .current_dir(root_dir)
+            .env("CLIPPY_DOGFOOD", "1")
+            .env("CARGO_INCREMENTAL", "0")
+            .arg("clippy-preview")
+            .arg("--all-targets")
+            .arg("--all-features")
+            .arg("--")
+            .args(&["-D", "clippy::all"])
+            .args(&["-D", "clippy::pedantic"])
+            .arg("-Cdebuginfo=0") // disable debuginfo to generate less data in the target dir
+            .output()
+            .unwrap()
+    };
     println!("status: {}", output.status);
     println!("stdout: {}", String::from_utf8_lossy(&output.stdout));
     println!("stderr: {}", String::from_utf8_lossy(&output.stderr));
diff --git a/tests/ui-internal/collapsible_span_lint_calls.fixed b/tests/ui-internal/collapsible_span_lint_calls.fixed
new file mode 100644
index 00000000000..e588c23345e
--- /dev/null
+++ b/tests/ui-internal/collapsible_span_lint_calls.fixed
@@ -0,0 +1,91 @@
+// run-rustfix
+#![deny(clippy::internal)]
+#![feature(rustc_private)]
+
+extern crate rustc_ast;
+extern crate rustc_errors;
+extern crate rustc_lint;
+extern crate rustc_session;
+extern crate rustc_span;
+
+use rustc_ast::ast::Expr;
+use rustc_errors::{Applicability, DiagnosticBuilder};
+use rustc_lint::{EarlyContext, EarlyLintPass, Lint, LintContext};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::source_map::Span;
+
+#[allow(unused_variables)]
+pub fn span_lint_and_then<'a, T: LintContext, F>(cx: &'a T, lint: &'static Lint, sp: Span, msg: &str, f: F)
+where
+    F: for<'b> FnOnce(&mut DiagnosticBuilder<'b>),
+{
+}
+
+#[allow(unused_variables)]
+fn span_lint_and_help<'a, T: LintContext>(
+    cx: &'a T,
+    lint: &'static Lint,
+    span: Span,
+    msg: &str,
+    option_span: Option<Span>,
+    help: &str,
+) {
+}
+
+#[allow(unused_variables)]
+fn span_lint_and_note<'a, T: LintContext>(
+    cx: &'a T,
+    lint: &'static Lint,
+    span: Span,
+    msg: &str,
+    note_span: Option<Span>,
+    note: &str,
+) {
+}
+
+#[allow(unused_variables)]
+fn span_lint_and_sugg<'a, T: LintContext>(
+    cx: &'a T,
+    lint: &'static Lint,
+    sp: Span,
+    msg: &str,
+    help: &str,
+    sugg: String,
+    applicability: Applicability,
+) {
+}
+
+declare_tool_lint! {
+    pub clippy::TEST_LINT,
+    Warn,
+    "",
+    report_in_external_macro: true
+}
+
+declare_lint_pass!(Pass => [TEST_LINT]);
+
+impl EarlyLintPass for Pass {
+    fn check_expr(&mut self, cx: &EarlyContext, expr: &Expr) {
+        let lint_msg = "lint message";
+        let help_msg = "help message";
+        let note_msg = "note message";
+        let sugg = "new_call()";
+        let predicate = true;
+
+        span_lint_and_sugg(cx, TEST_LINT, expr.span, lint_msg, help_msg, sugg.to_string(), Applicability::MachineApplicable);
+        span_lint_and_help(cx, TEST_LINT, expr.span, lint_msg, Some(expr.span), help_msg);
+        span_lint_and_help(cx, TEST_LINT, expr.span, lint_msg, None, help_msg);
+        span_lint_and_note(cx, TEST_LINT, expr.span, lint_msg, Some(expr.span), note_msg);
+        span_lint_and_note(cx, TEST_LINT, expr.span, lint_msg, None, note_msg);
+
+        // This expr shouldn't trigger this lint.
+        span_lint_and_then(cx, TEST_LINT, expr.span, lint_msg, |db| {
+            db.note(note_msg);
+            if predicate {
+                db.note(note_msg);
+            }
+        })
+    }
+}
+
+fn main() {}
diff --git a/tests/ui-internal/collapsible_span_lint_calls.rs b/tests/ui-internal/collapsible_span_lint_calls.rs
new file mode 100644
index 00000000000..d5dd3bb562b
--- /dev/null
+++ b/tests/ui-internal/collapsible_span_lint_calls.rs
@@ -0,0 +1,101 @@
+// run-rustfix
+#![deny(clippy::internal)]
+#![feature(rustc_private)]
+
+extern crate rustc_ast;
+extern crate rustc_errors;
+extern crate rustc_lint;
+extern crate rustc_session;
+extern crate rustc_span;
+
+use rustc_ast::ast::Expr;
+use rustc_errors::{Applicability, DiagnosticBuilder};
+use rustc_lint::{EarlyContext, EarlyLintPass, Lint, LintContext};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::source_map::Span;
+
+#[allow(unused_variables)]
+pub fn span_lint_and_then<'a, T: LintContext, F>(cx: &'a T, lint: &'static Lint, sp: Span, msg: &str, f: F)
+where
+    F: for<'b> FnOnce(&mut DiagnosticBuilder<'b>),
+{
+}
+
+#[allow(unused_variables)]
+fn span_lint_and_help<'a, T: LintContext>(
+    cx: &'a T,
+    lint: &'static Lint,
+    span: Span,
+    msg: &str,
+    option_span: Option<Span>,
+    help: &str,
+) {
+}
+
+#[allow(unused_variables)]
+fn span_lint_and_note<'a, T: LintContext>(
+    cx: &'a T,
+    lint: &'static Lint,
+    span: Span,
+    msg: &str,
+    note_span: Option<Span>,
+    note: &str,
+) {
+}
+
+#[allow(unused_variables)]
+fn span_lint_and_sugg<'a, T: LintContext>(
+    cx: &'a T,
+    lint: &'static Lint,
+    sp: Span,
+    msg: &str,
+    help: &str,
+    sugg: String,
+    applicability: Applicability,
+) {
+}
+
+declare_tool_lint! {
+    pub clippy::TEST_LINT,
+    Warn,
+    "",
+    report_in_external_macro: true
+}
+
+declare_lint_pass!(Pass => [TEST_LINT]);
+
+impl EarlyLintPass for Pass {
+    fn check_expr(&mut self, cx: &EarlyContext, expr: &Expr) {
+        let lint_msg = "lint message";
+        let help_msg = "help message";
+        let note_msg = "note message";
+        let sugg = "new_call()";
+        let predicate = true;
+
+        span_lint_and_then(cx, TEST_LINT, expr.span, lint_msg, |db| {
+            db.span_suggestion(expr.span, help_msg, sugg.to_string(), Applicability::MachineApplicable);
+        });
+        span_lint_and_then(cx, TEST_LINT, expr.span, lint_msg, |db| {
+            db.span_help(expr.span, help_msg);
+        });
+        span_lint_and_then(cx, TEST_LINT, expr.span, lint_msg, |db| {
+            db.help(help_msg);
+        });
+        span_lint_and_then(cx, TEST_LINT, expr.span, lint_msg, |db| {
+            db.span_note(expr.span, note_msg);
+        });
+        span_lint_and_then(cx, TEST_LINT, expr.span, lint_msg, |db| {
+            db.note(note_msg);
+        });
+
+        // This expr shouldn't trigger this lint.
+        span_lint_and_then(cx, TEST_LINT, expr.span, lint_msg, |db| {
+            db.note(note_msg);
+            if predicate {
+                db.note(note_msg);
+            }
+        })
+    }
+}
+
+fn main() {}
diff --git a/tests/ui-internal/collapsible_span_lint_calls.stderr b/tests/ui-internal/collapsible_span_lint_calls.stderr
new file mode 100644
index 00000000000..874d4a9f255
--- /dev/null
+++ b/tests/ui-internal/collapsible_span_lint_calls.stderr
@@ -0,0 +1,49 @@
+error: this call is collapsible
+  --> $DIR/collapsible_span_lint_calls.rs:75:9
+   |
+LL | /         span_lint_and_then(cx, TEST_LINT, expr.span, lint_msg, |db| {
+LL | |             db.span_suggestion(expr.span, help_msg, sugg.to_string(), Applicability::MachineApplicable);
+LL | |         });
+   | |__________^ help: collapse into: `span_lint_and_sugg(cx, TEST_LINT, expr.span, lint_msg, help_msg, sugg.to_string(), Applicability::MachineApplicable)`
+   |
+note: the lint level is defined here
+  --> $DIR/collapsible_span_lint_calls.rs:2:9
+   |
+LL | #![deny(clippy::internal)]
+   |         ^^^^^^^^^^^^^^^^
+   = note: `#[deny(clippy::collapsible_span_lint_calls)]` implied by `#[deny(clippy::internal)]`
+
+error: this call is collapsible
+  --> $DIR/collapsible_span_lint_calls.rs:78:9
+   |
+LL | /         span_lint_and_then(cx, TEST_LINT, expr.span, lint_msg, |db| {
+LL | |             db.span_help(expr.span, help_msg);
+LL | |         });
+   | |__________^ help: collapse into: `span_lint_and_help(cx, TEST_LINT, expr.span, lint_msg, Some(expr.span), help_msg)`
+
+error: this call is collapsible
+  --> $DIR/collapsible_span_lint_calls.rs:81:9
+   |
+LL | /         span_lint_and_then(cx, TEST_LINT, expr.span, lint_msg, |db| {
+LL | |             db.help(help_msg);
+LL | |         });
+   | |__________^ help: collapse into: `span_lint_and_help(cx, TEST_LINT, expr.span, lint_msg, None, help_msg)`
+
+error: this call is collspible
+  --> $DIR/collapsible_span_lint_calls.rs:84:9
+   |
+LL | /         span_lint_and_then(cx, TEST_LINT, expr.span, lint_msg, |db| {
+LL | |             db.span_note(expr.span, note_msg);
+LL | |         });
+   | |__________^ help: collapse into: `span_lint_and_note(cx, TEST_LINT, expr.span, lint_msg, Some(expr.span), note_msg)`
+
+error: this call is collspible
+  --> $DIR/collapsible_span_lint_calls.rs:87:9
+   |
+LL | /         span_lint_and_then(cx, TEST_LINT, expr.span, lint_msg, |db| {
+LL | |             db.note(note_msg);
+LL | |         });
+   | |__________^ help: collapse into: `span_lint_and_note(cx, TEST_LINT, expr.span, lint_msg, None, note_msg)`
+
+error: aborting due to 5 previous errors
+
diff --git a/tests/ui-internal/custom_ice_message.rs b/tests/ui-internal/custom_ice_message.rs
new file mode 100644
index 00000000000..5b30c9d5721
--- /dev/null
+++ b/tests/ui-internal/custom_ice_message.rs
@@ -0,0 +1,10 @@
+// rustc-env:RUST_BACKTRACE=0
+// normalize-stderr-test: "Clippy version: .*" -> "Clippy version: foo"
+// normalize-stderr-test: "internal_lints.rs:\d*:\d*" -> "internal_lints.rs"
+// normalize-stderr-test: "', .*clippy_lints" -> "', clippy_lints"
+
+#![deny(clippy::internal)]
+
+fn it_looks_like_you_are_trying_to_kill_clippy() {}
+
+fn main() {}
diff --git a/tests/ui-internal/custom_ice_message.stderr b/tests/ui-internal/custom_ice_message.stderr
new file mode 100644
index 00000000000..a1b8e2ee162
--- /dev/null
+++ b/tests/ui-internal/custom_ice_message.stderr
@@ -0,0 +1,13 @@
+thread 'rustc' panicked at 'Would you like some help with that?', clippy_lints/src/utils/internal_lints.rs
+note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
+
+error: internal compiler error: unexpected panic
+
+note: the compiler unexpectedly panicked. this is a bug.
+
+note: we would appreciate a bug report: https://github.com/rust-lang/rust-clippy/issues/new
+
+note: Clippy version: foo
+
+query stack during panic:
+end of query stack
diff --git a/tests/ui-internal/default_lint.rs b/tests/ui-internal/default_lint.rs
new file mode 100644
index 00000000000..053faae02ce
--- /dev/null
+++ b/tests/ui-internal/default_lint.rs
@@ -0,0 +1,27 @@
+#![deny(clippy::internal)]
+#![feature(rustc_private)]
+
+#[macro_use]
+extern crate rustc_middle;
+#[macro_use]
+extern crate rustc_session;
+extern crate rustc_lint;
+
+declare_tool_lint! {
+    pub clippy::TEST_LINT,
+    Warn,
+    "",
+    report_in_external_macro: true
+}
+
+declare_tool_lint! {
+    pub clippy::TEST_LINT_DEFAULT,
+    Warn,
+    "default lint description",
+    report_in_external_macro: true
+}
+
+declare_lint_pass!(Pass => [TEST_LINT]);
+declare_lint_pass!(Pass2 => [TEST_LINT_DEFAULT]);
+
+fn main() {}
diff --git a/tests/ui-internal/default_lint.stderr b/tests/ui-internal/default_lint.stderr
new file mode 100644
index 00000000000..5c5836a7d29
--- /dev/null
+++ b/tests/ui-internal/default_lint.stderr
@@ -0,0 +1,21 @@
+error: the lint `TEST_LINT_DEFAULT` has the default lint description
+  --> $DIR/default_lint.rs:17:1
+   |
+LL | / declare_tool_lint! {
+LL | |     pub clippy::TEST_LINT_DEFAULT,
+LL | |     Warn,
+LL | |     "default lint description",
+LL | |     report_in_external_macro: true
+LL | | }
+   | |_^
+   |
+note: the lint level is defined here
+  --> $DIR/default_lint.rs:1:9
+   |
+LL | #![deny(clippy::internal)]
+   |         ^^^^^^^^^^^^^^^^
+   = note: `#[deny(clippy::default_lint)]` implied by `#[deny(clippy::internal)]`
+   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: aborting due to previous error
+
diff --git a/tests/ui-internal/invalid_paths.rs b/tests/ui-internal/invalid_paths.rs
new file mode 100644
index 00000000000..01e28ae5e9d
--- /dev/null
+++ b/tests/ui-internal/invalid_paths.rs
@@ -0,0 +1,23 @@
+#![warn(clippy::internal)]
+
+mod paths {
+    // Good path
+    pub const ANY_TRAIT: [&str; 3] = ["std", "any", "Any"];
+
+    // Path to method on inherent impl of a primitive type
+    pub const F32_EPSILON: [&str; 4] = ["core", "f32", "<impl f32>", "EPSILON"];
+
+    // Path to method on inherent impl
+    pub const ARC_PTR_EQ: [&str; 4] = ["alloc", "sync", "Arc", "ptr_eq"];
+
+    // Path with empty segment
+    pub const TRANSMUTE: [&str; 4] = ["core", "intrinsics", "", "transmute"];
+
+    // Path with bad crate
+    pub const BAD_CRATE_PATH: [&str; 2] = ["bad", "path"];
+
+    // Path with bad module
+    pub const BAD_MOD_PATH: [&str; 2] = ["std", "xxx"];
+}
+
+fn main() {}
diff --git a/tests/ui-internal/invalid_paths.stderr b/tests/ui-internal/invalid_paths.stderr
new file mode 100644
index 00000000000..bd69d661b71
--- /dev/null
+++ b/tests/ui-internal/invalid_paths.stderr
@@ -0,0 +1,16 @@
+error: invalid path
+  --> $DIR/invalid_paths.rs:17:5
+   |
+LL |     pub const BAD_CRATE_PATH: [&str; 2] = ["bad", "path"];
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::clippy-lints-internal` implied by `-D warnings`
+
+error: invalid path
+  --> $DIR/invalid_paths.rs:20:5
+   |
+LL |     pub const BAD_MOD_PATH: [&str; 2] = ["std", "xxx"];
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 2 previous errors
+
diff --git a/tests/ui-internal/lint_without_lint_pass.rs b/tests/ui-internal/lint_without_lint_pass.rs
new file mode 100644
index 00000000000..beaef79a340
--- /dev/null
+++ b/tests/ui-internal/lint_without_lint_pass.rs
@@ -0,0 +1,44 @@
+#![deny(clippy::internal)]
+#![feature(rustc_private)]
+
+#[macro_use]
+extern crate rustc_middle;
+#[macro_use]
+extern crate rustc_session;
+extern crate rustc_lint;
+use rustc_lint::LintPass;
+
+declare_tool_lint! {
+    pub clippy::TEST_LINT,
+    Warn,
+    "",
+    report_in_external_macro: true
+}
+
+declare_tool_lint! {
+    pub clippy::TEST_LINT_REGISTERED,
+    Warn,
+    "",
+    report_in_external_macro: true
+}
+
+declare_tool_lint! {
+    pub clippy::TEST_LINT_REGISTERED_ONLY_IMPL,
+    Warn,
+    "",
+    report_in_external_macro: true
+}
+
+pub struct Pass;
+impl LintPass for Pass {
+    fn name(&self) -> &'static str {
+        "TEST_LINT"
+    }
+}
+
+declare_lint_pass!(Pass2 => [TEST_LINT_REGISTERED]);
+
+pub struct Pass3;
+impl_lint_pass!(Pass3 => [TEST_LINT_REGISTERED_ONLY_IMPL]);
+
+fn main() {}
diff --git a/tests/ui-internal/lint_without_lint_pass.stderr b/tests/ui-internal/lint_without_lint_pass.stderr
new file mode 100644
index 00000000000..1257dae96d7
--- /dev/null
+++ b/tests/ui-internal/lint_without_lint_pass.stderr
@@ -0,0 +1,21 @@
+error: the lint `TEST_LINT` is not added to any `LintPass`
+  --> $DIR/lint_without_lint_pass.rs:11:1
+   |
+LL | / declare_tool_lint! {
+LL | |     pub clippy::TEST_LINT,
+LL | |     Warn,
+LL | |     "",
+LL | |     report_in_external_macro: true
+LL | | }
+   | |_^
+   |
+note: the lint level is defined here
+  --> $DIR/lint_without_lint_pass.rs:1:9
+   |
+LL | #![deny(clippy::internal)]
+   |         ^^^^^^^^^^^^^^^^
+   = note: `#[deny(clippy::lint_without_lint_pass)]` implied by `#[deny(clippy::internal)]`
+   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: aborting due to previous error
+
diff --git a/tests/ui-internal/match_type_on_diag_item.rs b/tests/ui-internal/match_type_on_diag_item.rs
new file mode 100644
index 00000000000..fe950b0aa7c
--- /dev/null
+++ b/tests/ui-internal/match_type_on_diag_item.rs
@@ -0,0 +1,50 @@
+#![deny(clippy::internal)]
+#![feature(rustc_private)]
+
+extern crate rustc_hir;
+extern crate rustc_lint;
+extern crate rustc_middle;
+#[macro_use]
+extern crate rustc_session;
+use rustc_hir::Expr;
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::Ty;
+
+mod paths {
+    pub const VEC: [&str; 3] = ["alloc", "vec", "Vec"];
+}
+
+mod utils {
+    use super::*;
+
+    pub fn match_type(_cx: &LateContext<'_>, _ty: Ty<'_>, _path: &[&str]) -> bool {
+        false
+    }
+}
+
+use utils::match_type;
+
+declare_lint! {
+    pub TEST_LINT,
+    Warn,
+    ""
+}
+
+declare_lint_pass!(Pass => [TEST_LINT]);
+
+static OPTION: [&str; 3] = ["core", "option", "Option"];
+
+impl<'tcx> LateLintPass<'tcx> for Pass {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr) {
+        let ty = cx.typeck_results().expr_ty(expr);
+
+        let _ = match_type(cx, ty, &paths::VEC);
+        let _ = match_type(cx, ty, &OPTION);
+        let _ = match_type(cx, ty, &["core", "result", "Result"]);
+
+        let rc_path = &["alloc", "rc", "Rc"];
+        let _ = utils::match_type(cx, ty, rc_path);
+    }
+}
+
+fn main() {}
diff --git a/tests/ui-internal/match_type_on_diag_item.stderr b/tests/ui-internal/match_type_on_diag_item.stderr
new file mode 100644
index 00000000000..82465dbaf6e
--- /dev/null
+++ b/tests/ui-internal/match_type_on_diag_item.stderr
@@ -0,0 +1,33 @@
+error: usage of `utils::match_type()` on a type diagnostic item
+  --> $DIR/match_type_on_diag_item.rs:41:17
+   |
+LL |         let _ = match_type(cx, ty, &paths::VEC);
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `utils::is_type_diagnostic_item(cx, ty, sym::vec_type)`
+   |
+note: the lint level is defined here
+  --> $DIR/match_type_on_diag_item.rs:1:9
+   |
+LL | #![deny(clippy::internal)]
+   |         ^^^^^^^^^^^^^^^^
+   = note: `#[deny(clippy::match_type_on_diagnostic_item)]` implied by `#[deny(clippy::internal)]`
+
+error: usage of `utils::match_type()` on a type diagnostic item
+  --> $DIR/match_type_on_diag_item.rs:42:17
+   |
+LL |         let _ = match_type(cx, ty, &OPTION);
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `utils::is_type_diagnostic_item(cx, ty, sym::option_type)`
+
+error: usage of `utils::match_type()` on a type diagnostic item
+  --> $DIR/match_type_on_diag_item.rs:43:17
+   |
+LL |         let _ = match_type(cx, ty, &["core", "result", "Result"]);
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `utils::is_type_diagnostic_item(cx, ty, sym::result_type)`
+
+error: usage of `utils::match_type()` on a type diagnostic item
+  --> $DIR/match_type_on_diag_item.rs:46:17
+   |
+LL |         let _ = utils::match_type(cx, ty, rc_path);
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `utils::is_type_diagnostic_item(cx, ty, sym::Rc)`
+
+error: aborting due to 4 previous errors
+
diff --git a/tests/ui-internal/outer_expn_data.fixed b/tests/ui-internal/outer_expn_data.fixed
new file mode 100644
index 00000000000..b0b3498f057
--- /dev/null
+++ b/tests/ui-internal/outer_expn_data.fixed
@@ -0,0 +1,28 @@
+// run-rustfix
+
+#![deny(clippy::internal)]
+#![feature(rustc_private)]
+
+extern crate rustc_hir;
+extern crate rustc_lint;
+extern crate rustc_middle;
+#[macro_use]
+extern crate rustc_session;
+use rustc_hir::Expr;
+use rustc_lint::{LateContext, LateLintPass};
+
+declare_lint! {
+    pub TEST_LINT,
+    Warn,
+    ""
+}
+
+declare_lint_pass!(Pass => [TEST_LINT]);
+
+impl<'tcx> LateLintPass<'tcx> for Pass {
+    fn check_expr(&mut self, _cx: &LateContext<'tcx>, expr: &'tcx Expr) {
+        let _ = expr.span.ctxt().outer_expn_data();
+    }
+}
+
+fn main() {}
diff --git a/tests/ui-internal/outer_expn_data.rs b/tests/ui-internal/outer_expn_data.rs
new file mode 100644
index 00000000000..55a3fed00d0
--- /dev/null
+++ b/tests/ui-internal/outer_expn_data.rs
@@ -0,0 +1,28 @@
+// run-rustfix
+
+#![deny(clippy::internal)]
+#![feature(rustc_private)]
+
+extern crate rustc_hir;
+extern crate rustc_lint;
+extern crate rustc_middle;
+#[macro_use]
+extern crate rustc_session;
+use rustc_hir::Expr;
+use rustc_lint::{LateContext, LateLintPass};
+
+declare_lint! {
+    pub TEST_LINT,
+    Warn,
+    ""
+}
+
+declare_lint_pass!(Pass => [TEST_LINT]);
+
+impl<'tcx> LateLintPass<'tcx> for Pass {
+    fn check_expr(&mut self, _cx: &LateContext<'tcx>, expr: &'tcx Expr) {
+        let _ = expr.span.ctxt().outer_expn().expn_data();
+    }
+}
+
+fn main() {}
diff --git a/tests/ui-internal/outer_expn_data.stderr b/tests/ui-internal/outer_expn_data.stderr
new file mode 100644
index 00000000000..56b6ce1f78e
--- /dev/null
+++ b/tests/ui-internal/outer_expn_data.stderr
@@ -0,0 +1,15 @@
+error: usage of `outer_expn().expn_data()`
+  --> $DIR/outer_expn_data.rs:24:34
+   |
+LL |         let _ = expr.span.ctxt().outer_expn().expn_data();
+   |                                  ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `outer_expn_data()`
+   |
+note: the lint level is defined here
+  --> $DIR/outer_expn_data.rs:3:9
+   |
+LL | #![deny(clippy::internal)]
+   |         ^^^^^^^^^^^^^^^^
+   = note: `#[deny(clippy::outer_expn_expn_data)]` implied by `#[deny(clippy::internal)]`
+
+error: aborting due to previous error
+
diff --git a/tests/ui/collapsible_span_lint_calls.fixed b/tests/ui/collapsible_span_lint_calls.fixed
deleted file mode 100644
index e588c23345e..00000000000
--- a/tests/ui/collapsible_span_lint_calls.fixed
+++ /dev/null
@@ -1,91 +0,0 @@
-// run-rustfix
-#![deny(clippy::internal)]
-#![feature(rustc_private)]
-
-extern crate rustc_ast;
-extern crate rustc_errors;
-extern crate rustc_lint;
-extern crate rustc_session;
-extern crate rustc_span;
-
-use rustc_ast::ast::Expr;
-use rustc_errors::{Applicability, DiagnosticBuilder};
-use rustc_lint::{EarlyContext, EarlyLintPass, Lint, LintContext};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::source_map::Span;
-
-#[allow(unused_variables)]
-pub fn span_lint_and_then<'a, T: LintContext, F>(cx: &'a T, lint: &'static Lint, sp: Span, msg: &str, f: F)
-where
-    F: for<'b> FnOnce(&mut DiagnosticBuilder<'b>),
-{
-}
-
-#[allow(unused_variables)]
-fn span_lint_and_help<'a, T: LintContext>(
-    cx: &'a T,
-    lint: &'static Lint,
-    span: Span,
-    msg: &str,
-    option_span: Option<Span>,
-    help: &str,
-) {
-}
-
-#[allow(unused_variables)]
-fn span_lint_and_note<'a, T: LintContext>(
-    cx: &'a T,
-    lint: &'static Lint,
-    span: Span,
-    msg: &str,
-    note_span: Option<Span>,
-    note: &str,
-) {
-}
-
-#[allow(unused_variables)]
-fn span_lint_and_sugg<'a, T: LintContext>(
-    cx: &'a T,
-    lint: &'static Lint,
-    sp: Span,
-    msg: &str,
-    help: &str,
-    sugg: String,
-    applicability: Applicability,
-) {
-}
-
-declare_tool_lint! {
-    pub clippy::TEST_LINT,
-    Warn,
-    "",
-    report_in_external_macro: true
-}
-
-declare_lint_pass!(Pass => [TEST_LINT]);
-
-impl EarlyLintPass for Pass {
-    fn check_expr(&mut self, cx: &EarlyContext, expr: &Expr) {
-        let lint_msg = "lint message";
-        let help_msg = "help message";
-        let note_msg = "note message";
-        let sugg = "new_call()";
-        let predicate = true;
-
-        span_lint_and_sugg(cx, TEST_LINT, expr.span, lint_msg, help_msg, sugg.to_string(), Applicability::MachineApplicable);
-        span_lint_and_help(cx, TEST_LINT, expr.span, lint_msg, Some(expr.span), help_msg);
-        span_lint_and_help(cx, TEST_LINT, expr.span, lint_msg, None, help_msg);
-        span_lint_and_note(cx, TEST_LINT, expr.span, lint_msg, Some(expr.span), note_msg);
-        span_lint_and_note(cx, TEST_LINT, expr.span, lint_msg, None, note_msg);
-
-        // This expr shouldn't trigger this lint.
-        span_lint_and_then(cx, TEST_LINT, expr.span, lint_msg, |db| {
-            db.note(note_msg);
-            if predicate {
-                db.note(note_msg);
-            }
-        })
-    }
-}
-
-fn main() {}
diff --git a/tests/ui/collapsible_span_lint_calls.rs b/tests/ui/collapsible_span_lint_calls.rs
deleted file mode 100644
index d5dd3bb562b..00000000000
--- a/tests/ui/collapsible_span_lint_calls.rs
+++ /dev/null
@@ -1,101 +0,0 @@
-// run-rustfix
-#![deny(clippy::internal)]
-#![feature(rustc_private)]
-
-extern crate rustc_ast;
-extern crate rustc_errors;
-extern crate rustc_lint;
-extern crate rustc_session;
-extern crate rustc_span;
-
-use rustc_ast::ast::Expr;
-use rustc_errors::{Applicability, DiagnosticBuilder};
-use rustc_lint::{EarlyContext, EarlyLintPass, Lint, LintContext};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::source_map::Span;
-
-#[allow(unused_variables)]
-pub fn span_lint_and_then<'a, T: LintContext, F>(cx: &'a T, lint: &'static Lint, sp: Span, msg: &str, f: F)
-where
-    F: for<'b> FnOnce(&mut DiagnosticBuilder<'b>),
-{
-}
-
-#[allow(unused_variables)]
-fn span_lint_and_help<'a, T: LintContext>(
-    cx: &'a T,
-    lint: &'static Lint,
-    span: Span,
-    msg: &str,
-    option_span: Option<Span>,
-    help: &str,
-) {
-}
-
-#[allow(unused_variables)]
-fn span_lint_and_note<'a, T: LintContext>(
-    cx: &'a T,
-    lint: &'static Lint,
-    span: Span,
-    msg: &str,
-    note_span: Option<Span>,
-    note: &str,
-) {
-}
-
-#[allow(unused_variables)]
-fn span_lint_and_sugg<'a, T: LintContext>(
-    cx: &'a T,
-    lint: &'static Lint,
-    sp: Span,
-    msg: &str,
-    help: &str,
-    sugg: String,
-    applicability: Applicability,
-) {
-}
-
-declare_tool_lint! {
-    pub clippy::TEST_LINT,
-    Warn,
-    "",
-    report_in_external_macro: true
-}
-
-declare_lint_pass!(Pass => [TEST_LINT]);
-
-impl EarlyLintPass for Pass {
-    fn check_expr(&mut self, cx: &EarlyContext, expr: &Expr) {
-        let lint_msg = "lint message";
-        let help_msg = "help message";
-        let note_msg = "note message";
-        let sugg = "new_call()";
-        let predicate = true;
-
-        span_lint_and_then(cx, TEST_LINT, expr.span, lint_msg, |db| {
-            db.span_suggestion(expr.span, help_msg, sugg.to_string(), Applicability::MachineApplicable);
-        });
-        span_lint_and_then(cx, TEST_LINT, expr.span, lint_msg, |db| {
-            db.span_help(expr.span, help_msg);
-        });
-        span_lint_and_then(cx, TEST_LINT, expr.span, lint_msg, |db| {
-            db.help(help_msg);
-        });
-        span_lint_and_then(cx, TEST_LINT, expr.span, lint_msg, |db| {
-            db.span_note(expr.span, note_msg);
-        });
-        span_lint_and_then(cx, TEST_LINT, expr.span, lint_msg, |db| {
-            db.note(note_msg);
-        });
-
-        // This expr shouldn't trigger this lint.
-        span_lint_and_then(cx, TEST_LINT, expr.span, lint_msg, |db| {
-            db.note(note_msg);
-            if predicate {
-                db.note(note_msg);
-            }
-        })
-    }
-}
-
-fn main() {}
diff --git a/tests/ui/collapsible_span_lint_calls.stderr b/tests/ui/collapsible_span_lint_calls.stderr
deleted file mode 100644
index 874d4a9f255..00000000000
--- a/tests/ui/collapsible_span_lint_calls.stderr
+++ /dev/null
@@ -1,49 +0,0 @@
-error: this call is collapsible
-  --> $DIR/collapsible_span_lint_calls.rs:75:9
-   |
-LL | /         span_lint_and_then(cx, TEST_LINT, expr.span, lint_msg, |db| {
-LL | |             db.span_suggestion(expr.span, help_msg, sugg.to_string(), Applicability::MachineApplicable);
-LL | |         });
-   | |__________^ help: collapse into: `span_lint_and_sugg(cx, TEST_LINT, expr.span, lint_msg, help_msg, sugg.to_string(), Applicability::MachineApplicable)`
-   |
-note: the lint level is defined here
-  --> $DIR/collapsible_span_lint_calls.rs:2:9
-   |
-LL | #![deny(clippy::internal)]
-   |         ^^^^^^^^^^^^^^^^
-   = note: `#[deny(clippy::collapsible_span_lint_calls)]` implied by `#[deny(clippy::internal)]`
-
-error: this call is collapsible
-  --> $DIR/collapsible_span_lint_calls.rs:78:9
-   |
-LL | /         span_lint_and_then(cx, TEST_LINT, expr.span, lint_msg, |db| {
-LL | |             db.span_help(expr.span, help_msg);
-LL | |         });
-   | |__________^ help: collapse into: `span_lint_and_help(cx, TEST_LINT, expr.span, lint_msg, Some(expr.span), help_msg)`
-
-error: this call is collapsible
-  --> $DIR/collapsible_span_lint_calls.rs:81:9
-   |
-LL | /         span_lint_and_then(cx, TEST_LINT, expr.span, lint_msg, |db| {
-LL | |             db.help(help_msg);
-LL | |         });
-   | |__________^ help: collapse into: `span_lint_and_help(cx, TEST_LINT, expr.span, lint_msg, None, help_msg)`
-
-error: this call is collspible
-  --> $DIR/collapsible_span_lint_calls.rs:84:9
-   |
-LL | /         span_lint_and_then(cx, TEST_LINT, expr.span, lint_msg, |db| {
-LL | |             db.span_note(expr.span, note_msg);
-LL | |         });
-   | |__________^ help: collapse into: `span_lint_and_note(cx, TEST_LINT, expr.span, lint_msg, Some(expr.span), note_msg)`
-
-error: this call is collspible
-  --> $DIR/collapsible_span_lint_calls.rs:87:9
-   |
-LL | /         span_lint_and_then(cx, TEST_LINT, expr.span, lint_msg, |db| {
-LL | |             db.note(note_msg);
-LL | |         });
-   | |__________^ help: collapse into: `span_lint_and_note(cx, TEST_LINT, expr.span, lint_msg, None, note_msg)`
-
-error: aborting due to 5 previous errors
-
diff --git a/tests/ui/custom_ice_message.rs b/tests/ui/custom_ice_message.rs
deleted file mode 100644
index 5b30c9d5721..00000000000
--- a/tests/ui/custom_ice_message.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-// rustc-env:RUST_BACKTRACE=0
-// normalize-stderr-test: "Clippy version: .*" -> "Clippy version: foo"
-// normalize-stderr-test: "internal_lints.rs:\d*:\d*" -> "internal_lints.rs"
-// normalize-stderr-test: "', .*clippy_lints" -> "', clippy_lints"
-
-#![deny(clippy::internal)]
-
-fn it_looks_like_you_are_trying_to_kill_clippy() {}
-
-fn main() {}
diff --git a/tests/ui/custom_ice_message.stderr b/tests/ui/custom_ice_message.stderr
deleted file mode 100644
index a1b8e2ee162..00000000000
--- a/tests/ui/custom_ice_message.stderr
+++ /dev/null
@@ -1,13 +0,0 @@
-thread 'rustc' panicked at 'Would you like some help with that?', clippy_lints/src/utils/internal_lints.rs
-note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
-
-error: internal compiler error: unexpected panic
-
-note: the compiler unexpectedly panicked. this is a bug.
-
-note: we would appreciate a bug report: https://github.com/rust-lang/rust-clippy/issues/new
-
-note: Clippy version: foo
-
-query stack during panic:
-end of query stack
diff --git a/tests/ui/default_lint.rs b/tests/ui/default_lint.rs
deleted file mode 100644
index 053faae02ce..00000000000
--- a/tests/ui/default_lint.rs
+++ /dev/null
@@ -1,27 +0,0 @@
-#![deny(clippy::internal)]
-#![feature(rustc_private)]
-
-#[macro_use]
-extern crate rustc_middle;
-#[macro_use]
-extern crate rustc_session;
-extern crate rustc_lint;
-
-declare_tool_lint! {
-    pub clippy::TEST_LINT,
-    Warn,
-    "",
-    report_in_external_macro: true
-}
-
-declare_tool_lint! {
-    pub clippy::TEST_LINT_DEFAULT,
-    Warn,
-    "default lint description",
-    report_in_external_macro: true
-}
-
-declare_lint_pass!(Pass => [TEST_LINT]);
-declare_lint_pass!(Pass2 => [TEST_LINT_DEFAULT]);
-
-fn main() {}
diff --git a/tests/ui/default_lint.stderr b/tests/ui/default_lint.stderr
deleted file mode 100644
index 5c5836a7d29..00000000000
--- a/tests/ui/default_lint.stderr
+++ /dev/null
@@ -1,21 +0,0 @@
-error: the lint `TEST_LINT_DEFAULT` has the default lint description
-  --> $DIR/default_lint.rs:17:1
-   |
-LL | / declare_tool_lint! {
-LL | |     pub clippy::TEST_LINT_DEFAULT,
-LL | |     Warn,
-LL | |     "default lint description",
-LL | |     report_in_external_macro: true
-LL | | }
-   | |_^
-   |
-note: the lint level is defined here
-  --> $DIR/default_lint.rs:1:9
-   |
-LL | #![deny(clippy::internal)]
-   |         ^^^^^^^^^^^^^^^^
-   = note: `#[deny(clippy::default_lint)]` implied by `#[deny(clippy::internal)]`
-   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
-
-error: aborting due to previous error
-
diff --git a/tests/ui/invalid_paths.rs b/tests/ui/invalid_paths.rs
deleted file mode 100644
index 01e28ae5e9d..00000000000
--- a/tests/ui/invalid_paths.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-#![warn(clippy::internal)]
-
-mod paths {
-    // Good path
-    pub const ANY_TRAIT: [&str; 3] = ["std", "any", "Any"];
-
-    // Path to method on inherent impl of a primitive type
-    pub const F32_EPSILON: [&str; 4] = ["core", "f32", "<impl f32>", "EPSILON"];
-
-    // Path to method on inherent impl
-    pub const ARC_PTR_EQ: [&str; 4] = ["alloc", "sync", "Arc", "ptr_eq"];
-
-    // Path with empty segment
-    pub const TRANSMUTE: [&str; 4] = ["core", "intrinsics", "", "transmute"];
-
-    // Path with bad crate
-    pub const BAD_CRATE_PATH: [&str; 2] = ["bad", "path"];
-
-    // Path with bad module
-    pub const BAD_MOD_PATH: [&str; 2] = ["std", "xxx"];
-}
-
-fn main() {}
diff --git a/tests/ui/invalid_paths.stderr b/tests/ui/invalid_paths.stderr
deleted file mode 100644
index bd69d661b71..00000000000
--- a/tests/ui/invalid_paths.stderr
+++ /dev/null
@@ -1,16 +0,0 @@
-error: invalid path
-  --> $DIR/invalid_paths.rs:17:5
-   |
-LL |     pub const BAD_CRATE_PATH: [&str; 2] = ["bad", "path"];
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: `-D clippy::clippy-lints-internal` implied by `-D warnings`
-
-error: invalid path
-  --> $DIR/invalid_paths.rs:20:5
-   |
-LL |     pub const BAD_MOD_PATH: [&str; 2] = ["std", "xxx"];
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: aborting due to 2 previous errors
-
diff --git a/tests/ui/lint_without_lint_pass.rs b/tests/ui/lint_without_lint_pass.rs
deleted file mode 100644
index beaef79a340..00000000000
--- a/tests/ui/lint_without_lint_pass.rs
+++ /dev/null
@@ -1,44 +0,0 @@
-#![deny(clippy::internal)]
-#![feature(rustc_private)]
-
-#[macro_use]
-extern crate rustc_middle;
-#[macro_use]
-extern crate rustc_session;
-extern crate rustc_lint;
-use rustc_lint::LintPass;
-
-declare_tool_lint! {
-    pub clippy::TEST_LINT,
-    Warn,
-    "",
-    report_in_external_macro: true
-}
-
-declare_tool_lint! {
-    pub clippy::TEST_LINT_REGISTERED,
-    Warn,
-    "",
-    report_in_external_macro: true
-}
-
-declare_tool_lint! {
-    pub clippy::TEST_LINT_REGISTERED_ONLY_IMPL,
-    Warn,
-    "",
-    report_in_external_macro: true
-}
-
-pub struct Pass;
-impl LintPass for Pass {
-    fn name(&self) -> &'static str {
-        "TEST_LINT"
-    }
-}
-
-declare_lint_pass!(Pass2 => [TEST_LINT_REGISTERED]);
-
-pub struct Pass3;
-impl_lint_pass!(Pass3 => [TEST_LINT_REGISTERED_ONLY_IMPL]);
-
-fn main() {}
diff --git a/tests/ui/lint_without_lint_pass.stderr b/tests/ui/lint_without_lint_pass.stderr
deleted file mode 100644
index 1257dae96d7..00000000000
--- a/tests/ui/lint_without_lint_pass.stderr
+++ /dev/null
@@ -1,21 +0,0 @@
-error: the lint `TEST_LINT` is not added to any `LintPass`
-  --> $DIR/lint_without_lint_pass.rs:11:1
-   |
-LL | / declare_tool_lint! {
-LL | |     pub clippy::TEST_LINT,
-LL | |     Warn,
-LL | |     "",
-LL | |     report_in_external_macro: true
-LL | | }
-   | |_^
-   |
-note: the lint level is defined here
-  --> $DIR/lint_without_lint_pass.rs:1:9
-   |
-LL | #![deny(clippy::internal)]
-   |         ^^^^^^^^^^^^^^^^
-   = note: `#[deny(clippy::lint_without_lint_pass)]` implied by `#[deny(clippy::internal)]`
-   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
-
-error: aborting due to previous error
-
diff --git a/tests/ui/match_type_on_diag_item.rs b/tests/ui/match_type_on_diag_item.rs
deleted file mode 100644
index fe950b0aa7c..00000000000
--- a/tests/ui/match_type_on_diag_item.rs
+++ /dev/null
@@ -1,50 +0,0 @@
-#![deny(clippy::internal)]
-#![feature(rustc_private)]
-
-extern crate rustc_hir;
-extern crate rustc_lint;
-extern crate rustc_middle;
-#[macro_use]
-extern crate rustc_session;
-use rustc_hir::Expr;
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty::Ty;
-
-mod paths {
-    pub const VEC: [&str; 3] = ["alloc", "vec", "Vec"];
-}
-
-mod utils {
-    use super::*;
-
-    pub fn match_type(_cx: &LateContext<'_>, _ty: Ty<'_>, _path: &[&str]) -> bool {
-        false
-    }
-}
-
-use utils::match_type;
-
-declare_lint! {
-    pub TEST_LINT,
-    Warn,
-    ""
-}
-
-declare_lint_pass!(Pass => [TEST_LINT]);
-
-static OPTION: [&str; 3] = ["core", "option", "Option"];
-
-impl<'tcx> LateLintPass<'tcx> for Pass {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr) {
-        let ty = cx.typeck_results().expr_ty(expr);
-
-        let _ = match_type(cx, ty, &paths::VEC);
-        let _ = match_type(cx, ty, &OPTION);
-        let _ = match_type(cx, ty, &["core", "result", "Result"]);
-
-        let rc_path = &["alloc", "rc", "Rc"];
-        let _ = utils::match_type(cx, ty, rc_path);
-    }
-}
-
-fn main() {}
diff --git a/tests/ui/match_type_on_diag_item.stderr b/tests/ui/match_type_on_diag_item.stderr
deleted file mode 100644
index 82465dbaf6e..00000000000
--- a/tests/ui/match_type_on_diag_item.stderr
+++ /dev/null
@@ -1,33 +0,0 @@
-error: usage of `utils::match_type()` on a type diagnostic item
-  --> $DIR/match_type_on_diag_item.rs:41:17
-   |
-LL |         let _ = match_type(cx, ty, &paths::VEC);
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `utils::is_type_diagnostic_item(cx, ty, sym::vec_type)`
-   |
-note: the lint level is defined here
-  --> $DIR/match_type_on_diag_item.rs:1:9
-   |
-LL | #![deny(clippy::internal)]
-   |         ^^^^^^^^^^^^^^^^
-   = note: `#[deny(clippy::match_type_on_diagnostic_item)]` implied by `#[deny(clippy::internal)]`
-
-error: usage of `utils::match_type()` on a type diagnostic item
-  --> $DIR/match_type_on_diag_item.rs:42:17
-   |
-LL |         let _ = match_type(cx, ty, &OPTION);
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `utils::is_type_diagnostic_item(cx, ty, sym::option_type)`
-
-error: usage of `utils::match_type()` on a type diagnostic item
-  --> $DIR/match_type_on_diag_item.rs:43:17
-   |
-LL |         let _ = match_type(cx, ty, &["core", "result", "Result"]);
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `utils::is_type_diagnostic_item(cx, ty, sym::result_type)`
-
-error: usage of `utils::match_type()` on a type diagnostic item
-  --> $DIR/match_type_on_diag_item.rs:46:17
-   |
-LL |         let _ = utils::match_type(cx, ty, rc_path);
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `utils::is_type_diagnostic_item(cx, ty, sym::Rc)`
-
-error: aborting due to 4 previous errors
-
diff --git a/tests/ui/outer_expn_data.fixed b/tests/ui/outer_expn_data.fixed
deleted file mode 100644
index b0b3498f057..00000000000
--- a/tests/ui/outer_expn_data.fixed
+++ /dev/null
@@ -1,28 +0,0 @@
-// run-rustfix
-
-#![deny(clippy::internal)]
-#![feature(rustc_private)]
-
-extern crate rustc_hir;
-extern crate rustc_lint;
-extern crate rustc_middle;
-#[macro_use]
-extern crate rustc_session;
-use rustc_hir::Expr;
-use rustc_lint::{LateContext, LateLintPass};
-
-declare_lint! {
-    pub TEST_LINT,
-    Warn,
-    ""
-}
-
-declare_lint_pass!(Pass => [TEST_LINT]);
-
-impl<'tcx> LateLintPass<'tcx> for Pass {
-    fn check_expr(&mut self, _cx: &LateContext<'tcx>, expr: &'tcx Expr) {
-        let _ = expr.span.ctxt().outer_expn_data();
-    }
-}
-
-fn main() {}
diff --git a/tests/ui/outer_expn_data.rs b/tests/ui/outer_expn_data.rs
deleted file mode 100644
index 55a3fed00d0..00000000000
--- a/tests/ui/outer_expn_data.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-// run-rustfix
-
-#![deny(clippy::internal)]
-#![feature(rustc_private)]
-
-extern crate rustc_hir;
-extern crate rustc_lint;
-extern crate rustc_middle;
-#[macro_use]
-extern crate rustc_session;
-use rustc_hir::Expr;
-use rustc_lint::{LateContext, LateLintPass};
-
-declare_lint! {
-    pub TEST_LINT,
-    Warn,
-    ""
-}
-
-declare_lint_pass!(Pass => [TEST_LINT]);
-
-impl<'tcx> LateLintPass<'tcx> for Pass {
-    fn check_expr(&mut self, _cx: &LateContext<'tcx>, expr: &'tcx Expr) {
-        let _ = expr.span.ctxt().outer_expn().expn_data();
-    }
-}
-
-fn main() {}
diff --git a/tests/ui/outer_expn_data.stderr b/tests/ui/outer_expn_data.stderr
deleted file mode 100644
index 56b6ce1f78e..00000000000
--- a/tests/ui/outer_expn_data.stderr
+++ /dev/null
@@ -1,15 +0,0 @@
-error: usage of `outer_expn().expn_data()`
-  --> $DIR/outer_expn_data.rs:24:34
-   |
-LL |         let _ = expr.span.ctxt().outer_expn().expn_data();
-   |                                  ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `outer_expn_data()`
-   |
-note: the lint level is defined here
-  --> $DIR/outer_expn_data.rs:3:9
-   |
-LL | #![deny(clippy::internal)]
-   |         ^^^^^^^^^^^^^^^^
-   = note: `#[deny(clippy::outer_expn_expn_data)]` implied by `#[deny(clippy::internal)]`
-
-error: aborting due to previous error
-
-- 
cgit 1.4.1-3-g733a5


From 958e2e20de762fa45f50e41a58c97548f79f8100 Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Fri, 13 Nov 2020 02:12:48 +0100
Subject: fix clippy-dev update_lints

---
 clippy_dev/src/lib.rs          | 30 +++++++++++++++++++++++-------
 clippy_dev/src/update_lints.rs |  2 +-
 clippy_lints/src/lib.rs        | 36 ++++++++++++++++++------------------
 3 files changed, 42 insertions(+), 26 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_dev/src/lib.rs b/clippy_dev/src/lib.rs
index 43cb2954b74..1453ac7efa3 100644
--- a/clippy_dev/src/lib.rs
+++ b/clippy_dev/src/lib.rs
@@ -146,16 +146,32 @@ pub fn gen_deprecated<'a>(lints: impl Iterator<Item = &'a Lint>) -> Vec<String>
 }
 
 #[must_use]
-pub fn gen_register_lint_list<'a>(lints: impl Iterator<Item = &'a Lint>) -> Vec<String> {
-    let pre = "    store.register_lints(&[".to_string();
-    let post = "    ]);".to_string();
-    let mut inner = lints
+pub fn gen_register_lint_list<'a>(
+    internal_lints: impl Iterator<Item = &'a Lint>,
+    usable_lints: impl Iterator<Item = &'a Lint>,
+) -> Vec<String> {
+    let header = "    store.register_lints(&[".to_string();
+    let footer = "    ]);".to_string();
+    let internal_lints = internal_lints
+        .sorted_by_key(|l| format!("        &{}::{},", l.module, l.name.to_uppercase()))
+        .map(|l| {
+            format!(
+                "        #[cfg(feature = \"internal-lints\")]\n        &{}::{},",
+                l.module,
+                l.name.to_uppercase()
+            )
+        })
+        .collect::<Vec<String>>();
+    let other_lints = usable_lints
+        .sorted_by_key(|l| format!("        &{}::{},", l.module, l.name.to_uppercase()))
         .map(|l| format!("        &{}::{},", l.module, l.name.to_uppercase()))
         .sorted()
         .collect::<Vec<String>>();
-    inner.insert(0, pre);
-    inner.push(post);
-    inner
+    let mut lint_list = vec![header];
+    lint_list.extend(internal_lints);
+    lint_list.extend(other_lints);
+    lint_list.push(footer);
+    lint_list
 }
 
 /// Gathers all files in `src/clippy_lints` and gathers all lints inside
diff --git a/clippy_dev/src/update_lints.rs b/clippy_dev/src/update_lints.rs
index fcf093f8835..edf6c5f57a4 100644
--- a/clippy_dev/src/update_lints.rs
+++ b/clippy_dev/src/update_lints.rs
@@ -68,7 +68,7 @@ pub fn run(update_mode: UpdateMode) {
         "end register lints",
         false,
         update_mode == UpdateMode::Change,
-        || gen_register_lint_list(usable_lints.iter().chain(internal_lints.iter())),
+        || gen_register_lint_list(internal_lints.iter(), usable_lints.iter()),
     )
     .changed;
 
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index a58f7eb3666..fed7da3ee4f 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -498,6 +498,24 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
 
     // begin register lints, do not remove this comment, it’s used in `update_lints`
     store.register_lints(&[
+        #[cfg(feature = "internal-lints")]
+        &utils::internal_lints::CLIPPY_LINTS_INTERNAL,
+        #[cfg(feature = "internal-lints")]
+        &utils::internal_lints::COLLAPSIBLE_SPAN_LINT_CALLS,
+        #[cfg(feature = "internal-lints")]
+        &utils::internal_lints::COMPILER_LINT_FUNCTIONS,
+        #[cfg(feature = "internal-lints")]
+        &utils::internal_lints::DEFAULT_LINT,
+        #[cfg(feature = "internal-lints")]
+        &utils::internal_lints::INVALID_PATHS,
+        #[cfg(feature = "internal-lints")]
+        &utils::internal_lints::LINT_WITHOUT_LINT_PASS,
+        #[cfg(feature = "internal-lints")]
+        &utils::internal_lints::MATCH_TYPE_ON_DIAGNOSTIC_ITEM,
+        #[cfg(feature = "internal-lints")]
+        &utils::internal_lints::OUTER_EXPN_EXPN_DATA,
+        #[cfg(feature = "internal-lints")]
+        &utils::internal_lints::PRODUCE_ICE,
         &approx_const::APPROX_CONSTANT,
         &arithmetic::FLOAT_ARITHMETIC,
         &arithmetic::INTEGER_ARITHMETIC,
@@ -904,24 +922,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &unwrap_in_result::UNWRAP_IN_RESULT,
         &use_self::USE_SELF,
         &useless_conversion::USELESS_CONVERSION,
-        #[cfg(feature = "internal-lints")]
-        &utils::internal_lints::CLIPPY_LINTS_INTERNAL,
-        #[cfg(feature = "internal-lints")]
-        &utils::internal_lints::COLLAPSIBLE_SPAN_LINT_CALLS,
-        #[cfg(feature = "internal-lints")]
-        &utils::internal_lints::COMPILER_LINT_FUNCTIONS,
-        #[cfg(feature = "internal-lints")]
-        &utils::internal_lints::DEFAULT_LINT,
-        #[cfg(feature = "internal-lints")]
-        &utils::internal_lints::INVALID_PATHS,
-        #[cfg(feature = "internal-lints")]
-        &utils::internal_lints::LINT_WITHOUT_LINT_PASS,
-        #[cfg(feature = "internal-lints")]
-        &utils::internal_lints::MATCH_TYPE_ON_DIAGNOSTIC_ITEM,
-        #[cfg(feature = "internal-lints")]
-        &utils::internal_lints::OUTER_EXPN_EXPN_DATA,
-        #[cfg(feature = "internal-lints")]
-        &utils::internal_lints::PRODUCE_ICE,
         &vec::USELESS_VEC,
         &vec_resize_to_zero::VEC_RESIZE_TO_ZERO,
         &verbose_file_reads::VERBOSE_FILE_READS,
-- 
cgit 1.4.1-3-g733a5


From 5df286b636e0bf71a665599f099da18a2b90936c Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Fri, 27 Nov 2020 12:15:05 -0600
Subject: Improve SpanlessEq for blocks

---
 clippy_lints/src/utils/hir_utils.rs | 28 +++++++++++++++++++++++++++-
 1 file changed, 27 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/hir_utils.rs b/clippy_lints/src/utils/hir_utils.rs
index e4ad105c351..d847d22275e 100644
--- a/clippy_lints/src/utils/hir_utils.rs
+++ b/clippy_lints/src/utils/hir_utils.rs
@@ -81,7 +81,7 @@ impl<'a, 'tcx> SpanlessEq<'a, 'tcx> {
             }
         }
 
-        match (&left.kind, &right.kind) {
+        match (&reduce_exprkind(&left.kind), &reduce_exprkind(&right.kind)) {
             (&ExprKind::AddrOf(lb, l_mut, ref le), &ExprKind::AddrOf(rb, r_mut, ref re)) => {
                 lb == rb && l_mut == r_mut && self.eq_expr(le, re)
             },
@@ -306,6 +306,32 @@ impl<'a, 'tcx> SpanlessEq<'a, 'tcx> {
     }
 }
 
+/// Some simple reductions like `{ return }` => `return`
+fn reduce_exprkind<'hir>(kind: &'hir ExprKind<'hir>) -> &ExprKind<'hir> {
+    if let ExprKind::Block(block, _) = kind {
+        match (block.stmts, block.expr) {
+            // `{}` => `()`
+            ([], None) => &ExprKind::Tup(&[]),
+            ([], Some(expr)) => match expr.kind {
+                // `{ return .. }` => `return ..`
+                ExprKind::Ret(..) => &expr.kind,
+                _ => kind,
+            },
+            ([stmt], None) => match stmt.kind {
+                StmtKind::Expr(expr) | StmtKind::Semi(expr) => match expr.kind {
+                    // `{ return ..; }` => `return ..`
+                    ExprKind::Ret(..) => &expr.kind,
+                    _ => kind,
+                },
+                _ => kind,
+            },
+            _ => kind,
+        }
+    } else {
+        kind
+    }
+}
+
 fn swap_binop<'a>(
     binop: BinOpKind,
     lhs: &'a Expr<'a>,
-- 
cgit 1.4.1-3-g733a5


From 6e1fbfdb8fe9a6b543fa2b0e688f928d2ee354b8 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Fri, 27 Nov 2020 17:13:19 -0600
Subject: Add LocalUseVisitor

---
 clippy_lints/src/utils/visitors.rs | 55 +++++++++++++++++++++++++++++++++++++-
 1 file changed, 54 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/visitors.rs b/clippy_lints/src/utils/visitors.rs
index b0837b6c43e..28b3e79d7a6 100644
--- a/clippy_lints/src/utils/visitors.rs
+++ b/clippy_lints/src/utils/visitors.rs
@@ -1,5 +1,7 @@
 use rustc_hir as hir;
-use rustc_hir::intravisit::{self, Visitor};
+use rustc_hir::def::Res;
+use rustc_hir::intravisit::{self, walk_expr, NestedVisitorMap, Visitor};
+use rustc_hir::{Arm, Expr, ExprKind, HirId, QPath, Stmt};
 use rustc_lint::LateContext;
 use rustc_middle::hir::map::Map;
 
@@ -123,3 +125,54 @@ where
         !ret_finder.failed
     }
 }
+
+pub struct LocalUsedVisitor {
+    pub local_hir_id: HirId,
+    pub used: bool,
+}
+
+impl LocalUsedVisitor {
+    pub fn new(local_hir_id: HirId) -> Self {
+        Self {
+            local_hir_id,
+            used: false,
+        }
+    }
+
+    fn check<T>(&mut self, t: T, visit: fn(&mut Self, T)) -> bool {
+        visit(self, t);
+        std::mem::replace(&mut self.used, false)
+    }
+
+    pub fn check_arm(&mut self, arm: &Arm<'_>) -> bool {
+        self.check(arm, Self::visit_arm)
+    }
+
+    pub fn check_expr(&mut self, expr: &Expr<'_>) -> bool {
+        self.check(expr, Self::visit_expr)
+    }
+
+    pub fn check_stmt(&mut self, stmt: &Stmt<'_>) -> bool {
+        self.check(stmt, Self::visit_stmt)
+    }
+}
+
+impl<'v> Visitor<'v> for LocalUsedVisitor {
+    type Map = Map<'v>;
+
+    fn visit_expr(&mut self, expr: &'v Expr<'v>) {
+        if let ExprKind::Path(QPath::Resolved(None, path)) = expr.kind {
+            if let Res::Local(id) = path.res {
+                if id == self.local_hir_id {
+                    self.used = true;
+                    return;
+                }
+            }
+        }
+        walk_expr(self, expr);
+    }
+
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::None
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 28dec3b708c3e0d5e45b6c70f054860cbd53d624 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Tue, 24 Nov 2020 20:37:07 -0600
Subject: Add collapsible_match lint

---
 CHANGELOG.md                          |   1 +
 clippy_lints/src/collapsible_match.rs | 172 +++++++++++++++++++++
 clippy_lints/src/lib.rs               |   5 +
 tests/ui/collapsible_match.rs         | 278 ++++++++++++++++++++++++++++++++++
 tests/ui/collapsible_match.stderr     | 237 +++++++++++++++++++++++++++++
 5 files changed, 693 insertions(+)
 create mode 100644 clippy_lints/src/collapsible_match.rs
 create mode 100644 tests/ui/collapsible_match.rs
 create mode 100644 tests/ui/collapsible_match.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index e76a781f13b..e65e7cc639f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1770,6 +1770,7 @@ Released 2018-09-13
 [`cmp_owned`]: https://rust-lang.github.io/rust-clippy/master/index.html#cmp_owned
 [`cognitive_complexity`]: https://rust-lang.github.io/rust-clippy/master/index.html#cognitive_complexity
 [`collapsible_if`]: https://rust-lang.github.io/rust-clippy/master/index.html#collapsible_if
+[`collapsible_match`]: https://rust-lang.github.io/rust-clippy/master/index.html#collapsible_match
 [`comparison_chain`]: https://rust-lang.github.io/rust-clippy/master/index.html#comparison_chain
 [`comparison_to_empty`]: https://rust-lang.github.io/rust-clippy/master/index.html#comparison_to_empty
 [`copy_iterator`]: https://rust-lang.github.io/rust-clippy/master/index.html#copy_iterator
diff --git a/clippy_lints/src/collapsible_match.rs b/clippy_lints/src/collapsible_match.rs
new file mode 100644
index 00000000000..a34ba2d00a8
--- /dev/null
+++ b/clippy_lints/src/collapsible_match.rs
@@ -0,0 +1,172 @@
+use crate::utils::visitors::LocalUsedVisitor;
+use crate::utils::{span_lint_and_then, SpanlessEq};
+use if_chain::if_chain;
+use rustc_hir::def::{CtorKind, CtorOf, DefKind, Res};
+use rustc_hir::{Arm, Expr, ExprKind, Guard, HirId, Pat, PatKind, QPath, StmtKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::{DefIdTree, TyCtxt};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::{MultiSpan, Span};
+
+declare_clippy_lint! {
+    /// **What it does:** Finds nested `match` or `if let` expressions where the patterns may be "collapsed" together
+    /// without adding any branches.
+    ///
+    /// Note that this lint is not intended to find _all_ cases where nested match patterns can be merged, but only
+    /// cases where merging would most likely make the code more readable.
+    ///
+    /// **Why is this bad?** It is unnecessarily verbose and complex.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// fn func(opt: Option<Result<u64, String>>) {
+    ///     let n = match opt {
+    ///         Some(n) => match n {
+    ///             Ok(n) => n,
+    ///             _ => return,
+    ///         }
+    ///         None => return,
+    ///     };
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// fn func(opt: Option<Result<u64, String>>) {
+    ///     let n = match opt {
+    ///         Some(Ok(n)) => n,
+    ///         _ => return,
+    ///     };
+    /// }
+    /// ```
+    pub COLLAPSIBLE_MATCH,
+    style,
+    "Nested `match` or `if let` expressions where the patterns may be \"collapsed\" together."
+}
+
+declare_lint_pass!(CollapsibleMatch => [COLLAPSIBLE_MATCH]);
+
+impl<'tcx> LateLintPass<'tcx> for CollapsibleMatch {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &Expr<'tcx>) {
+        if let ExprKind::Match(_expr, arms, _source) = expr.kind {
+            if let Some(wild_arm) = arms.iter().rfind(|arm| arm_is_wild_like(arm, cx.tcx)) {
+                for arm in arms {
+                    check_arm(arm, wild_arm, cx);
+                }
+            }
+        }
+    }
+}
+
+fn check_arm(arm: &Arm<'_>, wild_outer_arm: &Arm<'_>, cx: &LateContext<'_>) {
+    if_chain! {
+        let expr = strip_singleton_blocks(arm.body);
+        if let ExprKind::Match(expr_in, arms_inner, _) = expr.kind;
+        // the outer arm pattern and the inner match
+        if expr_in.span.ctxt() == arm.pat.span.ctxt();
+        // there must be no more than two arms in the inner match for this lint
+        if arms_inner.len() == 2;
+        // no if guards on the inner match
+        if arms_inner.iter().all(|arm| arm.guard.is_none());
+        // match expression must be a local binding
+        // match <local> { .. }
+        if let ExprKind::Path(QPath::Resolved(None, path)) = expr_in.kind;
+        if let Res::Local(binding_id) = path.res;
+        // one of the branches must be "wild-like"
+        if let Some(wild_inner_arm_idx) = arms_inner.iter().rposition(|arm_inner| arm_is_wild_like(arm_inner, cx.tcx));
+        let (wild_inner_arm, non_wild_inner_arm) =
+            (&arms_inner[wild_inner_arm_idx], &arms_inner[1 - wild_inner_arm_idx]);
+        if !pat_contains_or(non_wild_inner_arm.pat);
+        // the binding must come from the pattern of the containing match arm
+        // ..<local>.. => match <local> { .. }
+        if let Some(binding_span) = find_pat_binding(arm.pat, binding_id);
+        // the "wild-like" branches must be equal
+        if SpanlessEq::new(cx).eq_expr(wild_inner_arm.body, wild_outer_arm.body);
+        // the binding must not be used in the if guard
+        if !matches!(arm.guard, Some(Guard::If(guard)) if LocalUsedVisitor::new(binding_id).check_expr(guard));
+        // ...or anywhere in the inner match
+        if !arms_inner.iter().any(|arm| LocalUsedVisitor::new(binding_id).check_arm(arm));
+        then {
+            span_lint_and_then(
+                cx,
+                COLLAPSIBLE_MATCH,
+                expr.span,
+                "Unnecessary nested match",
+                |diag| {
+                    let mut help_span = MultiSpan::from_spans(vec![binding_span, non_wild_inner_arm.pat.span]);
+                    help_span.push_span_label(binding_span, "Replace this binding".into());
+                    help_span.push_span_label(non_wild_inner_arm.pat.span, "with this pattern".into());
+                    diag.span_help(help_span, "The outer pattern can be modified to include the inner pattern.");
+                },
+            );
+        }
+    }
+}
+
+fn strip_singleton_blocks<'hir>(mut expr: &'hir Expr<'hir>) -> &'hir Expr<'hir> {
+    while let ExprKind::Block(block, _) = expr.kind {
+        match (block.stmts, block.expr) {
+            ([stmt], None) => match stmt.kind {
+                StmtKind::Expr(e) | StmtKind::Semi(e) => expr = e,
+                _ => break,
+            },
+            ([], Some(e)) => expr = e,
+            _ => break,
+        }
+    }
+    expr
+}
+
+/// A "wild-like" pattern is wild ("_") or `None`.
+/// For this lint to apply, both the outer and inner match expressions
+/// must have "wild-like" branches that can be combined.
+fn arm_is_wild_like(arm: &Arm<'_>, tcx: TyCtxt<'_>) -> bool {
+    if arm.guard.is_some() {
+        return false;
+    }
+    match arm.pat.kind {
+        PatKind::Binding(..) | PatKind::Wild => true,
+        PatKind::Path(QPath::Resolved(None, path)) if is_none_ctor(path.res, tcx) => true,
+        _ => false,
+    }
+}
+
+fn find_pat_binding(pat: &Pat<'_>, hir_id: HirId) -> Option<Span> {
+    let mut span = None;
+    pat.walk_short(|p| match &p.kind {
+        // ignore OR patterns
+        PatKind::Or(_) => false,
+        PatKind::Binding(_bm, _, _ident, _) => {
+            let found = p.hir_id == hir_id;
+            if found {
+                span = Some(p.span);
+            }
+            !found
+        },
+        _ => true,
+    });
+    span
+}
+
+fn pat_contains_or(pat: &Pat<'_>) -> bool {
+    let mut result = false;
+    pat.walk(|p| {
+        let is_or = matches!(p.kind, PatKind::Or(_));
+        result |= is_or;
+        !is_or
+    });
+    result
+}
+
+fn is_none_ctor(res: Res, tcx: TyCtxt<'_>) -> bool {
+    if let Some(none_id) = tcx.lang_items().option_none_variant() {
+        if let Res::Def(DefKind::Ctor(CtorOf::Variant, CtorKind::Const), id) = res {
+            if let Some(variant_id) = tcx.parent(id) {
+                return variant_id == none_id;
+            }
+        }
+    }
+    false
+}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 6eb5f6a7f48..ca190986cdb 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -172,6 +172,7 @@ mod cargo_common_metadata;
 mod checked_conversions;
 mod cognitive_complexity;
 mod collapsible_if;
+mod collapsible_match;
 mod comparison_chain;
 mod copies;
 mod copy_iterator;
@@ -531,6 +532,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &checked_conversions::CHECKED_CONVERSIONS,
         &cognitive_complexity::COGNITIVE_COMPLEXITY,
         &collapsible_if::COLLAPSIBLE_IF,
+        &collapsible_match::COLLAPSIBLE_MATCH,
         &comparison_chain::COMPARISON_CHAIN,
         &copies::IFS_SAME_COND,
         &copies::IF_SAME_THEN_ELSE,
@@ -960,6 +962,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box len_zero::LenZero);
     store.register_late_pass(|| box attrs::Attributes);
     store.register_late_pass(|| box blocks_in_if_conditions::BlocksInIfConditions);
+    store.register_late_pass(|| box collapsible_match::CollapsibleMatch);
     store.register_late_pass(|| box unicode::Unicode);
     store.register_late_pass(|| box unit_return_expecting_ord::UnitReturnExpectingOrd);
     store.register_late_pass(|| box strings::StringAdd);
@@ -1351,6 +1354,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&booleans::NONMINIMAL_BOOL),
         LintId::of(&bytecount::NAIVE_BYTECOUNT),
         LintId::of(&collapsible_if::COLLAPSIBLE_IF),
+        LintId::of(&collapsible_match::COLLAPSIBLE_MATCH),
         LintId::of(&comparison_chain::COMPARISON_CHAIN),
         LintId::of(&copies::IFS_SAME_COND),
         LintId::of(&copies::IF_SAME_THEN_ELSE),
@@ -1617,6 +1621,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&blacklisted_name::BLACKLISTED_NAME),
         LintId::of(&blocks_in_if_conditions::BLOCKS_IN_IF_CONDITIONS),
         LintId::of(&collapsible_if::COLLAPSIBLE_IF),
+        LintId::of(&collapsible_match::COLLAPSIBLE_MATCH),
         LintId::of(&comparison_chain::COMPARISON_CHAIN),
         LintId::of(&default::FIELD_REASSIGN_WITH_DEFAULT),
         LintId::of(&doc::MISSING_SAFETY_DOC),
diff --git a/tests/ui/collapsible_match.rs b/tests/ui/collapsible_match.rs
new file mode 100644
index 00000000000..75640b70ff0
--- /dev/null
+++ b/tests/ui/collapsible_match.rs
@@ -0,0 +1,278 @@
+#![warn(clippy::collapsible_match)]
+#![allow(clippy::needless_return, clippy::no_effect, clippy::single_match)]
+
+fn lint_cases(opt_opt: Option<Option<u32>>, res_opt: Result<Option<u32>, String>) {
+    // match without block
+    match res_opt {
+        Ok(val) => match val {
+            Some(n) => foo(n),
+            _ => return,
+        },
+        _ => return,
+    }
+
+    // match with block
+    match res_opt {
+        Ok(val) => match val {
+            Some(n) => foo(n),
+            _ => return,
+        },
+        _ => return,
+    }
+
+    // if let, if let
+    if let Ok(val) = res_opt {
+        if let Some(n) = val {
+            take(n);
+        }
+    }
+
+    // if let else, if let else
+    if let Ok(val) = res_opt {
+        if let Some(n) = val {
+            take(n);
+        } else {
+            return;
+        }
+    } else {
+        return;
+    }
+
+    // if let, match
+    if let Ok(val) = res_opt {
+        match val {
+            Some(n) => foo(n),
+            _ => (),
+        }
+    }
+
+    // match, if let
+    match res_opt {
+        Ok(val) => {
+            if let Some(n) = val {
+                take(n);
+            }
+        },
+        _ => {},
+    }
+
+    // if let else, match
+    if let Ok(val) = res_opt {
+        match val {
+            Some(n) => foo(n),
+            _ => return,
+        }
+    } else {
+        return;
+    }
+
+    // match, if let else
+    match res_opt {
+        Ok(val) => {
+            if let Some(n) = val {
+                take(n);
+            } else {
+                return;
+            }
+        },
+        _ => return,
+    }
+
+    // None in inner match same as outer wild branch
+    match res_opt {
+        Ok(val) => match val {
+            Some(n) => foo(n),
+            None => return,
+        },
+        _ => return,
+    }
+
+    // None in outer match same as inner wild branch
+    match opt_opt {
+        Some(val) => match val {
+            Some(n) => foo(n),
+            _ => return,
+        },
+        None => return,
+    }
+
+    // if guards on outer match
+    {
+        match res_opt {
+            Ok(val) if make() => match val {
+                Some(n) => foo(n),
+                _ => return,
+            },
+            _ => return,
+        }
+        match res_opt {
+            Ok(val) => match val {
+                Some(n) => foo(n),
+                _ => return,
+            },
+            _ if make() => return,
+            _ => return,
+        }
+    }
+
+    // macro
+    {
+        macro_rules! mac {
+            ($outer:expr => $pat:pat, $e:expr => $inner_pat:pat, $then:expr) => {
+                match $outer {
+                    $pat => match $e {
+                        $inner_pat => $then,
+                        _ => return,
+                    },
+                    _ => return,
+                }
+            };
+        }
+        // Lint this since the patterns are not defined by the macro.
+        // Allows the lint to work on if_chain! for example.
+        // Fixing the lint requires knowledge of the specific macro, but we optimistically assume that
+        // there is still a better way to write this.
+        mac!(res_opt => Ok(val), val => Some(n), foo(n));
+    }
+}
+
+fn negative_cases(res_opt: Result<Option<u32>, String>, res_res: Result<Result<u32, String>, String>) {
+    // no wild pattern in outer match
+    match res_opt {
+        Ok(val) => match val {
+            Some(n) => foo(n),
+            _ => return,
+        },
+        Err(_) => return,
+    }
+
+    // inner branch is not wild or None
+    match res_res {
+        Ok(val) => match val {
+            Ok(n) => foo(n),
+            Err(_) => return,
+        },
+        _ => return,
+    }
+
+    // statement before inner match
+    match res_opt {
+        Ok(val) => {
+            "hi buddy";
+            match val {
+                Some(n) => foo(n),
+                _ => return,
+            }
+        },
+        _ => return,
+    }
+
+    // statement after inner match
+    match res_opt {
+        Ok(val) => {
+            match val {
+                Some(n) => foo(n),
+                _ => return,
+            }
+            "hi buddy";
+        },
+        _ => return,
+    }
+
+    // wild branches do not match
+    match res_opt {
+        Ok(val) => match val {
+            Some(n) => foo(n),
+            _ => {
+                "sup";
+                return;
+            },
+        },
+        _ => return,
+    }
+
+    // binding used in if guard
+    match res_opt {
+        Ok(val) if val.is_some() => match val {
+            Some(n) => foo(n),
+            _ => return,
+        },
+        _ => return,
+    }
+
+    // binding used in inner match body
+    match res_opt {
+        Ok(val) => match val {
+            Some(_) => take(val),
+            _ => return,
+        },
+        _ => return,
+    }
+
+    // if guard on inner match
+    {
+        match res_opt {
+            Ok(val) => match val {
+                Some(n) if make() => foo(n),
+                _ => return,
+            },
+            _ => return,
+        }
+        match res_opt {
+            Ok(val) => match val {
+                _ => make(),
+                _ if make() => return,
+            },
+            _ => return,
+        }
+    }
+
+    // differing macro contexts
+    {
+        macro_rules! mac {
+            ($val:ident) => {
+                match $val {
+                    Some(n) => foo(n),
+                    _ => return,
+                }
+            };
+        }
+        match res_opt {
+            Ok(val) => mac!(val),
+            _ => return,
+        }
+    }
+
+    // OR pattern
+    enum E<T> {
+        A(T),
+        B(T),
+        C(T),
+    };
+    match make::<E<Option<u32>>>() {
+        E::A(val) | E::B(val) => match val {
+            Some(n) => foo(n),
+            _ => return,
+        },
+        _ => return,
+    }
+    match make::<Option<E<u32>>>() {
+        Some(val) => match val {
+            E::A(val) | E::B(val) => foo(val),
+            _ => return,
+        },
+        _ => return,
+    }
+}
+
+fn make<T>() -> T {
+    unimplemented!()
+}
+
+fn foo<T, U>(t: T) -> U {
+    unimplemented!()
+}
+
+fn take<T>(t: T) {}
+
+fn main() {}
diff --git a/tests/ui/collapsible_match.stderr b/tests/ui/collapsible_match.stderr
new file mode 100644
index 00000000000..a9e4f911914
--- /dev/null
+++ b/tests/ui/collapsible_match.stderr
@@ -0,0 +1,237 @@
+error: Unnecessary nested match
+  --> $DIR/collapsible_match.rs:7:20
+   |
+LL |           Ok(val) => match val {
+   |  ____________________^
+LL | |             Some(n) => foo(n),
+LL | |             _ => return,
+LL | |         },
+   | |_________^
+   |
+   = note: `-D clippy::collapsible-match` implied by `-D warnings`
+help: The outer pattern can be modified to include the inner pattern.
+  --> $DIR/collapsible_match.rs:7:12
+   |
+LL |         Ok(val) => match val {
+   |            ^^^ Replace this binding
+LL |             Some(n) => foo(n),
+   |             ^^^^^^^ with this pattern
+
+error: Unnecessary nested match
+  --> $DIR/collapsible_match.rs:16:20
+   |
+LL |           Ok(val) => match val {
+   |  ____________________^
+LL | |             Some(n) => foo(n),
+LL | |             _ => return,
+LL | |         },
+   | |_________^
+   |
+help: The outer pattern can be modified to include the inner pattern.
+  --> $DIR/collapsible_match.rs:16:12
+   |
+LL |         Ok(val) => match val {
+   |            ^^^ Replace this binding
+LL |             Some(n) => foo(n),
+   |             ^^^^^^^ with this pattern
+
+error: Unnecessary nested match
+  --> $DIR/collapsible_match.rs:25:9
+   |
+LL | /         if let Some(n) = val {
+LL | |             take(n);
+LL | |         }
+   | |_________^
+   |
+help: The outer pattern can be modified to include the inner pattern.
+  --> $DIR/collapsible_match.rs:24:15
+   |
+LL |     if let Ok(val) = res_opt {
+   |               ^^^ Replace this binding
+LL |         if let Some(n) = val {
+   |                ^^^^^^^ with this pattern
+
+error: Unnecessary nested match
+  --> $DIR/collapsible_match.rs:32:9
+   |
+LL | /         if let Some(n) = val {
+LL | |             take(n);
+LL | |         } else {
+LL | |             return;
+LL | |         }
+   | |_________^
+   |
+help: The outer pattern can be modified to include the inner pattern.
+  --> $DIR/collapsible_match.rs:31:15
+   |
+LL |     if let Ok(val) = res_opt {
+   |               ^^^ Replace this binding
+LL |         if let Some(n) = val {
+   |                ^^^^^^^ with this pattern
+
+error: Unnecessary nested match
+  --> $DIR/collapsible_match.rs:43:9
+   |
+LL | /         match val {
+LL | |             Some(n) => foo(n),
+LL | |             _ => (),
+LL | |         }
+   | |_________^
+   |
+help: The outer pattern can be modified to include the inner pattern.
+  --> $DIR/collapsible_match.rs:42:15
+   |
+LL |     if let Ok(val) = res_opt {
+   |               ^^^ Replace this binding
+LL |         match val {
+LL |             Some(n) => foo(n),
+   |             ^^^^^^^ with this pattern
+
+error: Unnecessary nested match
+  --> $DIR/collapsible_match.rs:52:13
+   |
+LL | /             if let Some(n) = val {
+LL | |                 take(n);
+LL | |             }
+   | |_____________^
+   |
+help: The outer pattern can be modified to include the inner pattern.
+  --> $DIR/collapsible_match.rs:51:12
+   |
+LL |         Ok(val) => {
+   |            ^^^ Replace this binding
+LL |             if let Some(n) = val {
+   |                    ^^^^^^^ with this pattern
+
+error: Unnecessary nested match
+  --> $DIR/collapsible_match.rs:61:9
+   |
+LL | /         match val {
+LL | |             Some(n) => foo(n),
+LL | |             _ => return,
+LL | |         }
+   | |_________^
+   |
+help: The outer pattern can be modified to include the inner pattern.
+  --> $DIR/collapsible_match.rs:60:15
+   |
+LL |     if let Ok(val) = res_opt {
+   |               ^^^ Replace this binding
+LL |         match val {
+LL |             Some(n) => foo(n),
+   |             ^^^^^^^ with this pattern
+
+error: Unnecessary nested match
+  --> $DIR/collapsible_match.rs:72:13
+   |
+LL | /             if let Some(n) = val {
+LL | |                 take(n);
+LL | |             } else {
+LL | |                 return;
+LL | |             }
+   | |_____________^
+   |
+help: The outer pattern can be modified to include the inner pattern.
+  --> $DIR/collapsible_match.rs:71:12
+   |
+LL |         Ok(val) => {
+   |            ^^^ Replace this binding
+LL |             if let Some(n) = val {
+   |                    ^^^^^^^ with this pattern
+
+error: Unnecessary nested match
+  --> $DIR/collapsible_match.rs:83:20
+   |
+LL |           Ok(val) => match val {
+   |  ____________________^
+LL | |             Some(n) => foo(n),
+LL | |             None => return,
+LL | |         },
+   | |_________^
+   |
+help: The outer pattern can be modified to include the inner pattern.
+  --> $DIR/collapsible_match.rs:83:12
+   |
+LL |         Ok(val) => match val {
+   |            ^^^ Replace this binding
+LL |             Some(n) => foo(n),
+   |             ^^^^^^^ with this pattern
+
+error: Unnecessary nested match
+  --> $DIR/collapsible_match.rs:92:22
+   |
+LL |           Some(val) => match val {
+   |  ______________________^
+LL | |             Some(n) => foo(n),
+LL | |             _ => return,
+LL | |         },
+   | |_________^
+   |
+help: The outer pattern can be modified to include the inner pattern.
+  --> $DIR/collapsible_match.rs:92:14
+   |
+LL |         Some(val) => match val {
+   |              ^^^ Replace this binding
+LL |             Some(n) => foo(n),
+   |             ^^^^^^^ with this pattern
+
+error: Unnecessary nested match
+  --> $DIR/collapsible_match.rs:102:34
+   |
+LL |               Ok(val) if make() => match val {
+   |  __________________________________^
+LL | |                 Some(n) => foo(n),
+LL | |                 _ => return,
+LL | |             },
+   | |_____________^
+   |
+help: The outer pattern can be modified to include the inner pattern.
+  --> $DIR/collapsible_match.rs:102:16
+   |
+LL |             Ok(val) if make() => match val {
+   |                ^^^ Replace this binding
+LL |                 Some(n) => foo(n),
+   |                 ^^^^^^^ with this pattern
+
+error: Unnecessary nested match
+  --> $DIR/collapsible_match.rs:109:24
+   |
+LL |               Ok(val) => match val {
+   |  ________________________^
+LL | |                 Some(n) => foo(n),
+LL | |                 _ => return,
+LL | |             },
+   | |_____________^
+   |
+help: The outer pattern can be modified to include the inner pattern.
+  --> $DIR/collapsible_match.rs:109:16
+   |
+LL |             Ok(val) => match val {
+   |                ^^^ Replace this binding
+LL |                 Some(n) => foo(n),
+   |                 ^^^^^^^ with this pattern
+
+error: Unnecessary nested match
+  --> $DIR/collapsible_match.rs:123:29
+   |
+LL |                       $pat => match $e {
+   |  _____________________________^
+LL | |                         $inner_pat => $then,
+LL | |                         _ => return,
+LL | |                     },
+   | |_____________________^
+...
+LL |           mac!(res_opt => Ok(val), val => Some(n), foo(n));
+   |           ------------------------------------------------- in this macro invocation
+   |
+help: The outer pattern can be modified to include the inner pattern.
+  --> $DIR/collapsible_match.rs:135:28
+   |
+LL |         mac!(res_opt => Ok(val), val => Some(n), foo(n));
+   |                            ^^^          ^^^^^^^ with this pattern
+   |                            |
+   |                            Replace this binding
+   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: aborting due to 13 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From fff5fa65816f482357989f25a58e98688cb7363d Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Tue, 24 Nov 2020 20:57:09 -0600
Subject: Eat collapsible_match dogfood

---
 clippy_lints/src/default.rs                        |  3 +--
 clippy_lints/src/if_let_some_result.rs             |  3 +--
 clippy_lints/src/implicit_return.rs                |  3 +--
 clippy_lints/src/implicit_saturating_sub.rs        |  3 +--
 clippy_lints/src/large_const_arrays.rs             |  3 +--
 clippy_lints/src/large_stack_arrays.rs             |  3 +--
 clippy_lints/src/loops.rs                          |  6 ++----
 clippy_lints/src/manual_strip.rs                   |  3 +--
 clippy_lints/src/matches.rs                        | 24 +++++++++-------------
 .../src/methods/manual_saturating_arithmetic.rs    |  3 +--
 clippy_lints/src/needless_bool.rs                  | 11 +++-------
 clippy_lints/src/question_mark.rs                  |  3 +--
 clippy_lints/src/strings.rs                        |  3 +--
 clippy_lints/src/trait_bounds.rs                   |  3 +--
 clippy_lints/src/transmuting_null.rs               |  3 +--
 clippy_lints/src/types.rs                          |  6 ++----
 clippy_lints/src/utils/higher.rs                   |  3 +--
 17 files changed, 30 insertions(+), 56 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/default.rs b/clippy_lints/src/default.rs
index 612c5355338..f69f6f1412a 100644
--- a/clippy_lints/src/default.rs
+++ b/clippy_lints/src/default.rs
@@ -280,8 +280,7 @@ fn field_reassigned_by_stmt<'tcx>(this: &Stmt<'tcx>, binding_name: Symbol) -> Op
         // only take assignments to fields where the left-hand side field is a field of
         // the same binding as the previous statement
         if let ExprKind::Field(ref binding, field_ident) = assign_lhs.kind;
-        if let ExprKind::Path(ref qpath) = binding.kind;
-        if let QPath::Resolved(_, path) = qpath;
+        if let ExprKind::Path(QPath::Resolved(_, path)) = binding.kind;
         if let Some(second_binding_name) = path.segments.last();
         if second_binding_name.ident.name == binding_name;
         then {
diff --git a/clippy_lints/src/if_let_some_result.rs b/clippy_lints/src/if_let_some_result.rs
index e0a1f4c5ca4..1194bd7e55e 100644
--- a/clippy_lints/src/if_let_some_result.rs
+++ b/clippy_lints/src/if_let_some_result.rs
@@ -41,8 +41,7 @@ declare_lint_pass!(OkIfLet => [IF_LET_SOME_RESULT]);
 impl<'tcx> LateLintPass<'tcx> for OkIfLet {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if_chain! { //begin checking variables
-            if let ExprKind::Match(ref op, ref body, source) = expr.kind; //test if expr is a match
-            if let MatchSource::IfLetDesugar { .. } = source; //test if it is an If Let
+            if let ExprKind::Match(ref op, ref body, MatchSource::IfLetDesugar { .. }) = expr.kind; //test if expr is if let
             if let ExprKind::MethodCall(_, ok_span, ref result_types, _) = op.kind; //check is expr.ok() has type Result<T,E>.ok(, _)
             if let PatKind::TupleStruct(QPath::Resolved(_, ref x), ref y, _)  = body[0].pat.kind; //get operation
             if method_chain_args(op, &["ok"]).is_some(); //test to see if using ok() methoduse std::marker::Sized;
diff --git a/clippy_lints/src/implicit_return.rs b/clippy_lints/src/implicit_return.rs
index ed7f3b9293d..03e95c9e27f 100644
--- a/clippy_lints/src/implicit_return.rs
+++ b/clippy_lints/src/implicit_return.rs
@@ -68,8 +68,7 @@ fn expr_match(cx: &LateContext<'_>, expr: &Expr<'_>) {
                 if_chain! {
                     if let StmtKind::Semi(expr, ..) = &stmt.kind;
                     // make sure it's a break, otherwise we want to skip
-                    if let ExprKind::Break(.., break_expr) = &expr.kind;
-                    if let Some(break_expr) = break_expr;
+                    if let ExprKind::Break(.., Some(break_expr)) = &expr.kind;
                     then {
                             lint(cx, expr.span, break_expr.span, LINT_BREAK);
                     }
diff --git a/clippy_lints/src/implicit_saturating_sub.rs b/clippy_lints/src/implicit_saturating_sub.rs
index b57fe8dc426..3a01acd8fdc 100644
--- a/clippy_lints/src/implicit_saturating_sub.rs
+++ b/clippy_lints/src/implicit_saturating_sub.rs
@@ -59,8 +59,7 @@ impl<'tcx> LateLintPass<'tcx> for ImplicitSaturatingSub {
             if let Some(target) = subtracts_one(cx, e);
 
             // Extracting out the variable name
-            if let ExprKind::Path(ref assign_path) = target.kind;
-            if let QPath::Resolved(_, ref ares_path) = assign_path;
+            if let ExprKind::Path(QPath::Resolved(_, ref ares_path)) = target.kind;
 
             then {
                 // Handle symmetric conditions in the if statement
diff --git a/clippy_lints/src/large_const_arrays.rs b/clippy_lints/src/large_const_arrays.rs
index 025ff86da39..a76595ed089 100644
--- a/clippy_lints/src/large_const_arrays.rs
+++ b/clippy_lints/src/large_const_arrays.rs
@@ -52,8 +52,7 @@ impl<'tcx> LateLintPass<'tcx> for LargeConstArrays {
             if let ItemKind::Const(hir_ty, _) = &item.kind;
             let ty = hir_ty_to_ty(cx.tcx, hir_ty);
             if let ty::Array(element_type, cst) = ty.kind();
-            if let ConstKind::Value(val) = cst.val;
-            if let ConstValue::Scalar(element_count) = val;
+            if let ConstKind::Value(ConstValue::Scalar(element_count)) = cst.val;
             if let Ok(element_count) = element_count.to_machine_usize(&cx.tcx);
             if let Ok(element_size) = cx.layout_of(element_type).map(|l| l.size.bytes());
             if self.maximum_allowed_size < element_count * element_size;
diff --git a/clippy_lints/src/large_stack_arrays.rs b/clippy_lints/src/large_stack_arrays.rs
index 9fd3780e14e..9a448ab1256 100644
--- a/clippy_lints/src/large_stack_arrays.rs
+++ b/clippy_lints/src/large_stack_arrays.rs
@@ -43,8 +43,7 @@ impl<'tcx> LateLintPass<'tcx> for LargeStackArrays {
         if_chain! {
             if let ExprKind::Repeat(_, _) = expr.kind;
             if let ty::Array(element_type, cst) = cx.typeck_results().expr_ty(expr).kind();
-            if let ConstKind::Value(val) = cst.val;
-            if let ConstValue::Scalar(element_count) = val;
+            if let ConstKind::Value(ConstValue::Scalar(element_count)) = cst.val;
             if let Ok(element_count) = element_count.to_machine_usize(&cx.tcx);
             if let Ok(element_size) = cx.layout_of(element_type).map(|l| l.size.bytes());
             if self.maximum_allowed_size < element_count * element_size;
diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 143cbea5537..b0de355e242 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -1919,8 +1919,7 @@ fn check_for_single_element_loop<'tcx>(
     if_chain! {
         if let ExprKind::AddrOf(BorrowKind::Ref, _, ref arg_expr) = arg.kind;
         if let PatKind::Binding(.., target, _) = pat.kind;
-        if let ExprKind::Array(ref arg_expr_list) = arg_expr.kind;
-        if let [arg_expression] = arg_expr_list;
+        if let ExprKind::Array([arg_expression]) = arg_expr.kind;
         if let ExprKind::Path(ref list_item) = arg_expression.kind;
         if let Some(list_item_name) = single_segment_path(list_item).map(|ps| ps.ident.name);
         if let ExprKind::Block(ref block, _) = body.kind;
@@ -2025,8 +2024,7 @@ fn check_for_mutability(cx: &LateContext<'_>, bound: &Expr<'_>) -> Option<HirId>
                 let node_str = cx.tcx.hir().get(hir_id);
                 if_chain! {
                     if let Node::Binding(pat) = node_str;
-                    if let PatKind::Binding(bind_ann, ..) = pat.kind;
-                    if let BindingAnnotation::Mutable = bind_ann;
+                    if let PatKind::Binding(BindingAnnotation::Mutable, ..) = pat.kind;
                     then {
                         return Some(hir_id);
                     }
diff --git a/clippy_lints/src/manual_strip.rs b/clippy_lints/src/manual_strip.rs
index e17e3adb94f..80f3045415e 100644
--- a/clippy_lints/src/manual_strip.rs
+++ b/clippy_lints/src/manual_strip.rs
@@ -225,8 +225,7 @@ fn find_stripping<'tcx>(
                 if is_ref_str(self.cx, ex);
                 let unref = peel_ref(ex);
                 if let ExprKind::Index(indexed, index) = &unref.kind;
-                if let Some(range) = higher::range(index);
-                if let higher::Range { start, end, .. } = range;
+                if let Some(higher::Range { start, end, .. }) = higher::range(index);
                 if let ExprKind::Path(path) = &indexed.kind;
                 if qpath_res(self.cx, path, ex.hir_id) == self.target;
                 then {
diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index 7d64fa6c262..c223462af26 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -652,8 +652,7 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
         if_chain! {
             if !in_external_macro(cx.sess(), pat.span);
             if !in_macro(pat.span);
-            if let PatKind::Struct(ref qpath, fields, true) = pat.kind;
-            if let QPath::Resolved(_, ref path) = qpath;
+            if let PatKind::Struct(QPath::Resolved(_, ref path), fields, true) = pat.kind;
             if let Some(def_id) = path.res.opt_def_id();
             let ty = cx.tcx.type_of(def_id);
             if let ty::Adt(def, _) = ty.kind();
@@ -962,16 +961,14 @@ fn check_wild_enum_match(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>])
                 if let QPath::Resolved(_, p) = path {
                     missing_variants.retain(|e| e.ctor_def_id != Some(p.res.def_id()));
                 }
-            } else if let PatKind::TupleStruct(ref path, ref patterns, ..) = arm.pat.kind {
-                if let QPath::Resolved(_, p) = path {
-                    // Some simple checks for exhaustive patterns.
-                    // There is a room for improvements to detect more cases,
-                    // but it can be more expensive to do so.
-                    let is_pattern_exhaustive =
-                        |pat: &&Pat<'_>| matches!(pat.kind, PatKind::Wild | PatKind::Binding(.., None));
-                    if patterns.iter().all(is_pattern_exhaustive) {
-                        missing_variants.retain(|e| e.ctor_def_id != Some(p.res.def_id()));
-                    }
+            } else if let PatKind::TupleStruct(QPath::Resolved(_, p), ref patterns, ..) = arm.pat.kind {
+                // Some simple checks for exhaustive patterns.
+                // There is a room for improvements to detect more cases,
+                // but it can be more expensive to do so.
+                let is_pattern_exhaustive =
+                    |pat: &&Pat<'_>| matches!(pat.kind, PatKind::Wild | PatKind::Binding(.., None));
+                if patterns.iter().all(is_pattern_exhaustive) {
+                    missing_variants.retain(|e| e.ctor_def_id != Some(p.res.def_id()));
                 }
             }
         }
@@ -1446,8 +1443,7 @@ fn is_ref_some_arm(arm: &Arm<'_>) -> Option<BindingAnnotation> {
         if let ExprKind::Call(ref e, ref args) = remove_blocks(&arm.body).kind;
         if let ExprKind::Path(ref some_path) = e.kind;
         if match_qpath(some_path, &paths::OPTION_SOME) && args.len() == 1;
-        if let ExprKind::Path(ref qpath) = args[0].kind;
-        if let &QPath::Resolved(_, ref path2) = qpath;
+        if let ExprKind::Path(QPath::Resolved(_, ref path2)) = args[0].kind;
         if path2.segments.len() == 1 && ident.name == path2.segments[0].ident.name;
         then {
             return Some(rb)
diff --git a/clippy_lints/src/methods/manual_saturating_arithmetic.rs b/clippy_lints/src/methods/manual_saturating_arithmetic.rs
index 40a62575861..44c974b9d98 100644
--- a/clippy_lints/src/methods/manual_saturating_arithmetic.rs
+++ b/clippy_lints/src/methods/manual_saturating_arithmetic.rs
@@ -90,8 +90,7 @@ fn is_min_or_max<'tcx>(cx: &LateContext<'tcx>, expr: &hir::Expr<'_>) -> Option<M
     if_chain! {
         if let hir::ExprKind::Call(func, args) = &expr.kind;
         if args.is_empty();
-        if let hir::ExprKind::Path(path) = &func.kind;
-        if let hir::QPath::TypeRelative(_, segment) = path;
+        if let hir::ExprKind::Path(hir::QPath::TypeRelative(_, segment)) = &func.kind;
         then {
             match &*segment.ident.as_str() {
                 "max_value" => return Some(MinMax::Max),
diff --git a/clippy_lints/src/needless_bool.rs b/clippy_lints/src/needless_bool.rs
index a799a644e97..42f97b2ac49 100644
--- a/clippy_lints/src/needless_bool.rs
+++ b/clippy_lints/src/needless_bool.rs
@@ -6,7 +6,6 @@ use crate::utils::sugg::Sugg;
 use crate::utils::{
     higher, is_expn_of, parent_node_is_if_expr, snippet_with_applicability, span_lint, span_lint_and_sugg,
 };
-use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Block, Expr, ExprKind, StmtKind, UnOp};
@@ -198,13 +197,9 @@ struct ExpressionInfoWithSpan {
 }
 
 fn is_unary_not(e: &Expr<'_>) -> (bool, Span) {
-    if_chain! {
-        if let ExprKind::Unary(unop, operand) = e.kind;
-        if let UnOp::UnNot = unop;
-        then {
-            return (true, operand.span);
-        }
-    };
+    if let ExprKind::Unary(UnOp::UnNot, operand) = e.kind {
+        return (true, operand.span);
+    }
     (false, e.span)
 }
 
diff --git a/clippy_lints/src/question_mark.rs b/clippy_lints/src/question_mark.rs
index d9b280b7a85..b91233ac582 100644
--- a/clippy_lints/src/question_mark.rs
+++ b/clippy_lints/src/question_mark.rs
@@ -176,8 +176,7 @@ impl QuestionMark {
             if block.stmts.len() == 1;
             if let Some(expr) = block.stmts.iter().last();
             if let StmtKind::Semi(ref expr) = expr.kind;
-            if let ExprKind::Ret(ret_expr) = expr.kind;
-            if let Some(ret_expr) = ret_expr;
+            if let ExprKind::Ret(Some(ret_expr)) = expr.kind;
 
             then {
                 return Some(ret_expr);
diff --git a/clippy_lints/src/strings.rs b/clippy_lints/src/strings.rs
index 42c45be3b45..77e79073378 100644
--- a/clippy_lints/src/strings.rs
+++ b/clippy_lints/src/strings.rs
@@ -222,8 +222,7 @@ impl<'tcx> LateLintPass<'tcx> for StringLitAsBytes {
             if method_names[0] == sym!(as_bytes);
 
             // Check for slicer
-            if let ExprKind::Struct(ref path, _, _) = right.kind;
-            if let QPath::LangItem(LangItem::Range, _) = path;
+            if let ExprKind::Struct(QPath::LangItem(LangItem::Range, _), _, _) = right.kind;
 
             then {
                 let mut applicability = Applicability::MachineApplicable;
diff --git a/clippy_lints/src/trait_bounds.rs b/clippy_lints/src/trait_bounds.rs
index d4acf8df46d..daff5f81e8c 100644
--- a/clippy_lints/src/trait_bounds.rs
+++ b/clippy_lints/src/trait_bounds.rs
@@ -168,8 +168,7 @@ fn check_trait_bound_duplication(cx: &LateContext<'_>, gen: &'_ Generics<'_>) {
         if_chain! {
             if let WherePredicate::BoundPredicate(ref bound_predicate) = predicate;
             if !in_macro(bound_predicate.span);
-            if let TyKind::Path(ref path) = bound_predicate.bounded_ty.kind;
-            if let QPath::Resolved(_, Path { ref segments, .. }) = path;
+            if let TyKind::Path(QPath::Resolved(_, Path { ref segments, .. })) = bound_predicate.bounded_ty.kind;
             if let Some(segment) = segments.first();
             if let Some(trait_resolutions_direct) = map.get(&segment.ident);
             then {
diff --git a/clippy_lints/src/transmuting_null.rs b/clippy_lints/src/transmuting_null.rs
index d60306336c6..6b171a0fa1a 100644
--- a/clippy_lints/src/transmuting_null.rs
+++ b/clippy_lints/src/transmuting_null.rs
@@ -48,8 +48,7 @@ impl<'tcx> LateLintPass<'tcx> for TransmutingNull {
                 if_chain! {
                     if let ExprKind::Path(ref _qpath) = args[0].kind;
                     let x = const_eval_context.expr(&args[0]);
-                    if let Some(constant) = x;
-                    if let Constant::RawPtr(0) = constant;
+                    if let Some(Constant::RawPtr(0)) = x;
                     then {
                         span_lint(cx, TRANSMUTING_NULL, expr.span, LINT_MSG)
                     }
diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs
index c8bdc5a71e6..74ba53e6a9a 100644
--- a/clippy_lints/src/types.rs
+++ b/clippy_lints/src/types.rs
@@ -738,8 +738,7 @@ fn is_any_trait(t: &hir::Ty<'_>) -> bool {
 fn get_bounds_if_impl_trait<'tcx>(cx: &LateContext<'tcx>, qpath: &QPath<'_>, id: HirId) -> Option<GenericBounds<'tcx>> {
     if_chain! {
         if let Some(did) = qpath_res(cx, qpath, id).opt_def_id();
-        if let Some(node) = cx.tcx.hir().get_if_local(did);
-        if let Node::GenericParam(generic_param) = node;
+        if let Some(Node::GenericParam(generic_param)) = cx.tcx.hir().get_if_local(did);
         if let GenericParamKind::Type { synthetic, .. } = generic_param.kind;
         if synthetic == Some(SyntheticTyParamKind::ImplTrait);
         then {
@@ -1470,8 +1469,7 @@ fn check_loss_of_sign(cx: &LateContext<'_>, expr: &Expr<'_>, op: &Expr<'_>, cast
     // don't lint for positive constants
     let const_val = constant(cx, &cx.typeck_results(), op);
     if_chain! {
-        if let Some((const_val, _)) = const_val;
-        if let Constant::Int(n) = const_val;
+        if let Some((Constant::Int(n), _)) = const_val;
         if let ty::Int(ity) = *cast_from.kind();
         if sext(cx.tcx, n, ity) >= 0;
         then {
diff --git a/clippy_lints/src/utils/higher.rs b/clippy_lints/src/utils/higher.rs
index 6d7c5058b4f..01ffac5b559 100644
--- a/clippy_lints/src/utils/higher.rs
+++ b/clippy_lints/src/utils/higher.rs
@@ -162,8 +162,7 @@ pub fn while_loop<'tcx>(expr: &'tcx hir::Expr<'tcx>) -> Option<(&'tcx hir::Expr<
         if let hir::Block { expr: Some(expr), .. } = &**block;
         if let hir::ExprKind::Match(cond, arms, hir::MatchSource::WhileDesugar) = &expr.kind;
         if let hir::ExprKind::DropTemps(cond) = &cond.kind;
-        if let [arm, ..] = &arms[..];
-        if let hir::Arm { body, .. } = arm;
+        if let [hir::Arm { body, .. }, ..] = &arms[..];
         then {
             return Some((cond, body));
         }
-- 
cgit 1.4.1-3-g733a5


From a5d6855333c55636bc0fc56efcc83eac7c57ffa7 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Sat, 28 Nov 2020 20:41:29 -0600
Subject: Use LocalUsedVisitor in more places

---
 clippy_lints/src/let_if_seq.rs | 53 +++++-------------------------------------
 clippy_lints/src/loops.rs      | 29 ++---------------------
 2 files changed, 8 insertions(+), 74 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/let_if_seq.rs b/clippy_lints/src/let_if_seq.rs
index 8243b0a29bc..0d2d95324c4 100644
--- a/clippy_lints/src/let_if_seq.rs
+++ b/clippy_lints/src/let_if_seq.rs
@@ -1,12 +1,11 @@
+use crate::utils::visitors::LocalUsedVisitor;
 use crate::utils::{higher, qpath_res, snippet, span_lint_and_then};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_hir::def::Res;
-use rustc_hir::intravisit;
 use rustc_hir::BindingAnnotation;
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::hir::map::Map;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
@@ -66,10 +65,10 @@ impl<'tcx> LateLintPass<'tcx> for LetIfSeq {
                 if let hir::PatKind::Binding(mode, canonical_id, ident, None) = local.pat.kind;
                 if let hir::StmtKind::Expr(ref if_) = expr.kind;
                 if let Some((ref cond, ref then, ref else_)) = higher::if_block(&if_);
-                if !used_in_expr(cx, canonical_id, cond);
+                if !LocalUsedVisitor::new(canonical_id).check_expr(cond);
                 if let hir::ExprKind::Block(ref then, _) = then.kind;
                 if let Some(value) = check_assign(cx, canonical_id, &*then);
-                if !used_in_expr(cx, canonical_id, value);
+                if !LocalUsedVisitor::new(canonical_id).check_expr(value);
                 then {
                     let span = stmt.span.to(if_.span);
 
@@ -136,32 +135,6 @@ impl<'tcx> LateLintPass<'tcx> for LetIfSeq {
     }
 }
 
-struct UsedVisitor<'a, 'tcx> {
-    cx: &'a LateContext<'tcx>,
-    id: hir::HirId,
-    used: bool,
-}
-
-impl<'a, 'tcx> intravisit::Visitor<'tcx> for UsedVisitor<'a, 'tcx> {
-    type Map = Map<'tcx>;
-
-    fn visit_expr(&mut self, expr: &'tcx hir::Expr<'_>) {
-        if_chain! {
-            if let hir::ExprKind::Path(ref qpath) = expr.kind;
-            if let Res::Local(local_id) = qpath_res(self.cx, qpath, expr.hir_id);
-            if self.id == local_id;
-            then {
-                self.used = true;
-                return;
-            }
-        }
-        intravisit::walk_expr(self, expr);
-    }
-    fn nested_visit_map(&mut self) -> intravisit::NestedVisitorMap<Self::Map> {
-        intravisit::NestedVisitorMap::None
-    }
-}
-
 fn check_assign<'tcx>(
     cx: &LateContext<'tcx>,
     decl: hir::HirId,
@@ -176,18 +149,10 @@ fn check_assign<'tcx>(
         if let Res::Local(local_id) = qpath_res(cx, qpath, var.hir_id);
         if decl == local_id;
         then {
-            let mut v = UsedVisitor {
-                cx,
-                id: decl,
-                used: false,
-            };
-
-            for s in block.stmts.iter().take(block.stmts.len()-1) {
-                intravisit::walk_stmt(&mut v, s);
+            let mut v = LocalUsedVisitor::new(decl);
 
-                if v.used {
-                    return None;
-                }
+            if block.stmts.iter().take(block.stmts.len()-1).any(|stmt| v.check_stmt(stmt)) {
+                return None;
             }
 
             return Some(value);
@@ -196,9 +161,3 @@ fn check_assign<'tcx>(
 
     None
 }
-
-fn used_in_expr<'tcx>(cx: &LateContext<'tcx>, id: hir::HirId, expr: &'tcx hir::Expr<'_>) -> bool {
-    let mut v = UsedVisitor { cx, id, used: false };
-    intravisit::walk_expr(&mut v, expr);
-    v.used
-}
diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index b0de355e242..400148ab81d 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -2,6 +2,7 @@ use crate::consts::constant;
 use crate::utils::paths;
 use crate::utils::sugg::Sugg;
 use crate::utils::usage::{is_unused, mutated_variables};
+use crate::utils::visitors::LocalUsedVisitor;
 use crate::utils::{
     contains_name, get_enclosing_block, get_parent_expr, get_trait_def_id, has_iter_method, higher, implements_trait,
     indent_of, is_in_panic_handler, is_integer_const, is_no_std_crate, is_refutable, is_type_diagnostic_item,
@@ -2069,28 +2070,6 @@ fn pat_is_wild<'tcx>(pat: &'tcx PatKind<'_>, body: &'tcx Expr<'_>) -> bool {
     }
 }
 
-struct LocalUsedVisitor<'a, 'tcx> {
-    cx: &'a LateContext<'tcx>,
-    local: HirId,
-    used: bool,
-}
-
-impl<'a, 'tcx> Visitor<'tcx> for LocalUsedVisitor<'a, 'tcx> {
-    type Map = Map<'tcx>;
-
-    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
-        if same_var(self.cx, expr, self.local) {
-            self.used = true;
-        } else {
-            walk_expr(self, expr);
-        }
-    }
-
-    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-        NestedVisitorMap::None
-    }
-}
-
 struct VarVisitor<'a, 'tcx> {
     /// context reference
     cx: &'a LateContext<'tcx>,
@@ -2124,11 +2103,7 @@ impl<'a, 'tcx> VarVisitor<'a, 'tcx> {
             then {
                 let index_used_directly = same_var(self.cx, idx, self.var);
                 let indexed_indirectly = {
-                    let mut used_visitor = LocalUsedVisitor {
-                        cx: self.cx,
-                        local: self.var,
-                        used: false,
-                    };
+                    let mut used_visitor = LocalUsedVisitor::new(self.var);
                     walk_expr(&mut used_visitor, idx);
                     used_visitor.used
                 };
-- 
cgit 1.4.1-3-g733a5


From 252083f7e02a3a9174bb39821fd20356ada3dd4a Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Mon, 16 Nov 2020 12:44:05 +0100
Subject: address review comments and rebase

ci: always build with internal lints
group up internal lints in lib.rs
dogfood: we already pass --all-features, no need to enable internal-lints again
---
 .github/workflows/clippy_bors.yml |  7 ------
 clippy_dev/src/lib.rs             |  6 ++---
 clippy_lints/src/lib.rs           | 25 ++++++++----------
 tests/dogfood.rs                  | 53 +++++++++++++++------------------------
 4 files changed, 33 insertions(+), 58 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/.github/workflows/clippy_bors.yml b/.github/workflows/clippy_bors.yml
index a8b4925176c..784463fe0df 100644
--- a/.github/workflows/clippy_bors.yml
+++ b/.github/workflows/clippy_bors.yml
@@ -128,13 +128,6 @@ jobs:
         SYSROOT=$(rustc --print sysroot)
         echo "$SYSROOT/bin" >> $GITHUB_PATH
 
-    - name: Build
-      run: cargo build --features deny-warnings
-
-    # compiletest would panic due to "Found multiple rlibs for crate `clippy_lints`"
-    - name: clean rlibs
-      run: rm -f ./target/debug/deps/libclippy_lints*
-
     - name: Build with internal lints
       run: cargo build --features deny-warnings,internal-lints
 
diff --git a/clippy_dev/src/lib.rs b/clippy_dev/src/lib.rs
index 1453ac7efa3..f51c45e9eb5 100644
--- a/clippy_dev/src/lib.rs
+++ b/clippy_dev/src/lib.rs
@@ -160,13 +160,11 @@ pub fn gen_register_lint_list<'a>(
                 l.module,
                 l.name.to_uppercase()
             )
-        })
-        .collect::<Vec<String>>();
+        });
     let other_lints = usable_lints
         .sorted_by_key(|l| format!("        &{}::{},", l.module, l.name.to_uppercase()))
         .map(|l| format!("        &{}::{},", l.module, l.name.to_uppercase()))
-        .sorted()
-        .collect::<Vec<String>>();
+        .sorted();
     let mut lint_list = vec![header];
     lint_list.extend(internal_lints);
     lint_list.extend(other_lints);
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index fed7da3ee4f..8fbd44528b1 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -939,17 +939,23 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &zero_div_zero::ZERO_DIVIDED_BY_ZERO,
     ]);
     // end register lints, do not remove this comment, it’s used in `update_lints`
-    store.register_late_pass(|| box await_holding_invalid::AwaitHolding);
-    store.register_late_pass(|| box serde_api::SerdeAPI);
+
+    // all the internal lints
     #[cfg(feature = "internal-lints")]
     {
+        store.register_early_pass(|| box utils::internal_lints::ClippyLintsInternal);
+        store.register_early_pass(|| box utils::internal_lints::ProduceIce);
+        store.register_late_pass(|| box utils::inspector::DeepCodeInspector);
+        store.register_late_pass(|| box utils::internal_lints::CollapsibleCalls);
         store.register_late_pass(|| box utils::internal_lints::CompilerLintFunctions::new());
+        store.register_late_pass(|| box utils::internal_lints::InvalidPaths);
         store.register_late_pass(|| box utils::internal_lints::LintWithoutLintPass::default());
+        store.register_late_pass(|| box utils::internal_lints::MatchTypeOnDiagItem);
         store.register_late_pass(|| box utils::internal_lints::OuterExpnDataPass);
-        store.register_late_pass(|| box utils::internal_lints::InvalidPaths);
-        store.register_late_pass(|| box utils::inspector::DeepCodeInspector);
     }
     store.register_late_pass(|| box utils::author::Author);
+    store.register_late_pass(|| box await_holding_invalid::AwaitHolding);
+    store.register_late_pass(|| box serde_api::SerdeAPI);
     let vec_box_size_threshold = conf.vec_box_size_threshold;
     store.register_late_pass(move || box types::Types::new(vec_box_size_threshold));
     store.register_late_pass(|| box booleans::NonminimalBool);
@@ -1134,8 +1140,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_early_pass(|| box literal_representation::LiteralDigitGrouping);
     let literal_representation_threshold = conf.literal_representation_threshold;
     store.register_early_pass(move || box literal_representation::DecimalLiteralRepresentation::new(literal_representation_threshold));
-    #[cfg(feature = "internal-lints")]
-    store.register_early_pass(|| box utils::internal_lints::ClippyLintsInternal);
     let enum_variant_name_threshold = conf.enum_variant_name_threshold;
     store.register_early_pass(move || box enum_variants::EnumVariantNames::new(enum_variant_name_threshold));
     store.register_early_pass(|| box tabs_in_doc_comments::TabsInDocComments);
@@ -1149,8 +1153,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(move || box large_const_arrays::LargeConstArrays::new(array_size_threshold));
     store.register_late_pass(|| box floating_point_arithmetic::FloatingPointArithmetic);
     store.register_early_pass(|| box as_conversions::AsConversions);
-    #[cfg(feature = "internal-lints")]
-    store.register_early_pass(|| box utils::internal_lints::ProduceIce);
     store.register_late_pass(|| box let_underscore::LetUnderscore);
     store.register_late_pass(|| box atomic_ordering::AtomicOrdering);
     store.register_early_pass(|| box single_component_path_imports::SingleComponentPathImports);
@@ -1166,8 +1168,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box dereference::Dereferencing);
     store.register_late_pass(|| box option_if_let_else::OptionIfLetElse);
     store.register_late_pass(|| box future_not_send::FutureNotSend);
-    #[cfg(feature = "internal-lints")]
-    store.register_late_pass(|| box utils::internal_lints::CollapsibleCalls);
     store.register_late_pass(|| box if_let_mutex::IfLetMutex);
     store.register_late_pass(|| box mut_mutex_lock::MutMutexLock);
     store.register_late_pass(|| box match_on_vec_items::MatchOnVecItems);
@@ -1175,7 +1175,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_early_pass(|| box redundant_field_names::RedundantFieldNames);
     store.register_late_pass(|| box vec_resize_to_zero::VecResizeToZero);
     store.register_late_pass(|| box panic_in_result_fn::PanicInResultFn);
-
     let single_char_binding_names_threshold = conf.single_char_binding_names_threshold;
     store.register_early_pass(move || box non_expressive_names::NonExpressiveNames {
         single_char_binding_names_threshold,
@@ -1192,8 +1191,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box manual_ok_or::ManualOkOr);
     store.register_late_pass(|| box float_equality_without_abs::FloatEqualityWithoutAbs);
     store.register_late_pass(|| box async_yields_async::AsyncYieldsAsync);
-    #[cfg(feature = "internal-lints")]
-    store.register_late_pass(|| box utils::internal_lints::MatchTypeOnDiagItem);
     let disallowed_methods = conf.disallowed_methods.iter().cloned().collect::<FxHashSet<_>>();
     store.register_late_pass(move || box disallowed_method::DisallowedMethod::new(&disallowed_methods));
     store.register_early_pass(|| box asm_syntax::InlineAsmX86AttSyntax);
@@ -1202,7 +1199,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box strings::StrToString);
     store.register_late_pass(|| box strings::StringToString);
 
-
     store.register_group(true, "clippy::restriction", Some("clippy_restriction"), vec![
         LintId::of(&arithmetic::FLOAT_ARITHMETIC),
         LintId::of(&arithmetic::INTEGER_ARITHMETIC),
@@ -1333,6 +1329,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&wildcard_imports::ENUM_GLOB_USE),
         LintId::of(&wildcard_imports::WILDCARD_IMPORTS),
     ]);
+
     #[cfg(feature = "internal-lints")]
     store.register_group(true, "clippy::internal", Some("clippy_internal"), vec![
         LintId::of(&utils::internal_lints::CLIPPY_LINTS_INTERNAL),
diff --git a/tests/dogfood.rs b/tests/dogfood.rs
index eae25adf839..a6163a83d76 100644
--- a/tests/dogfood.rs
+++ b/tests/dogfood.rs
@@ -18,39 +18,26 @@ fn dogfood_clippy() {
     }
     let root_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
 
-    let output = if cfg!(feature = "internal-lints") {
-        // with internal lints and internal warnings
-        Command::new(&*CLIPPY_PATH)
-            .current_dir(root_dir)
-            .env("CLIPPY_DOGFOOD", "1")
-            .env("CARGO_INCREMENTAL", "0")
-            .arg("clippy-preview")
-            .arg("--all-targets")
-            .arg("--all-features")
-            .args(&["--features", "internal-lints"])
-            .arg("--")
-            .args(&["-D", "clippy::all"])
-            .args(&["-D", "clippy::pedantic"])
-            .args(&["-D", "clippy::internal"])
-            .arg("-Cdebuginfo=0") // disable debuginfo to generate less data in the target dir
-            .output()
-            .unwrap()
-    } else {
-        // without internal lints or warnings
-        Command::new(&*CLIPPY_PATH)
-            .current_dir(root_dir)
-            .env("CLIPPY_DOGFOOD", "1")
-            .env("CARGO_INCREMENTAL", "0")
-            .arg("clippy-preview")
-            .arg("--all-targets")
-            .arg("--all-features")
-            .arg("--")
-            .args(&["-D", "clippy::all"])
-            .args(&["-D", "clippy::pedantic"])
-            .arg("-Cdebuginfo=0") // disable debuginfo to generate less data in the target dir
-            .output()
-            .unwrap()
-    };
+    let mut command = Command::new(&*CLIPPY_PATH);
+    command
+        .current_dir(root_dir)
+        .env("CLIPPY_DOGFOOD", "1")
+        .env("CARGO_INCREMENTAL", "0")
+        .arg("clippy-preview")
+        .arg("--all-targets")
+        .arg("--all-features")
+        .arg("--")
+        .args(&["-D", "clippy::all"])
+        .args(&["-D", "clippy::pedantic"])
+        .arg("-Cdebuginfo=0"); // disable debuginfo to generate less data in the target dir
+
+    // internal lints only exist if we build with the internal-lints feature
+    if cfg!(feature = "internal-lints") {
+        command.args(&["-D", "clippy::internal"]);
+    }
+
+    let output = command.output().unwrap();
+
     println!("status: {}", output.status);
     println!("stdout: {}", String::from_utf8_lossy(&output.stdout));
     println!("stderr: {}", String::from_utf8_lossy(&output.stderr));
-- 
cgit 1.4.1-3-g733a5


From f059febe85f49fd7b432a24542321f9b948a49de Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Fri, 13 Nov 2020 12:13:50 -0600
Subject: Add redundant else lint

---
 CHANGELOG.md                       |   1 +
 clippy_lints/src/lib.rs            |   4 +
 clippy_lints/src/redundant_else.rs | 135 ++++++++++++++++++++++++++++++++
 tests/ui/redundant_else.rs         | 154 +++++++++++++++++++++++++++++++++++++
 tests/ui/redundant_else.stderr     |  80 +++++++++++++++++++
 5 files changed, 374 insertions(+)
 create mode 100644 clippy_lints/src/redundant_else.rs
 create mode 100644 tests/ui/redundant_else.rs
 create mode 100644 tests/ui/redundant_else.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index e76a781f13b..c3351793c66 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2023,6 +2023,7 @@ Released 2018-09-13
 [`redundant_closure`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_closure
 [`redundant_closure_call`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_closure_call
 [`redundant_closure_for_method_calls`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_closure_for_method_calls
+[`redundant_else`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_else
 [`redundant_field_names`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_field_names
 [`redundant_pattern`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_pattern
 [`redundant_pattern_matching`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_pattern_matching
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 6eb5f6a7f48..66895a866ee 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -293,6 +293,7 @@ mod question_mark;
 mod ranges;
 mod redundant_clone;
 mod redundant_closure_call;
+mod redundant_else;
 mod redundant_field_names;
 mod redundant_pub_crate;
 mod redundant_static_lifetimes;
@@ -810,6 +811,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &ranges::REVERSED_EMPTY_RANGES,
         &redundant_clone::REDUNDANT_CLONE,
         &redundant_closure_call::REDUNDANT_CLOSURE_CALL,
+        &redundant_else::REDUNDANT_ELSE,
         &redundant_field_names::REDUNDANT_FIELD_NAMES,
         &redundant_pub_crate::REDUNDANT_PUB_CRATE,
         &redundant_static_lifetimes::REDUNDANT_STATIC_LIFETIMES,
@@ -1113,6 +1115,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_early_pass(|| box items_after_statements::ItemsAfterStatements);
     store.register_early_pass(|| box precedence::Precedence);
     store.register_early_pass(|| box needless_continue::NeedlessContinue);
+    store.register_early_pass(|| box redundant_else::RedundantElse);
     store.register_late_pass(|| box create_dir::CreateDir);
     store.register_early_pass(|| box needless_arbitrary_self_type::NeedlessArbitrarySelfType);
     store.register_early_pass(|| box redundant_static_lifetimes::RedundantStaticLifetimes);
@@ -1294,6 +1297,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&pass_by_ref_or_value::TRIVIALLY_COPY_PASS_BY_REF),
         LintId::of(&ranges::RANGE_MINUS_ONE),
         LintId::of(&ranges::RANGE_PLUS_ONE),
+        LintId::of(&redundant_else::REDUNDANT_ELSE),
         LintId::of(&ref_option_ref::REF_OPTION_REF),
         LintId::of(&shadow::SHADOW_UNRELATED),
         LintId::of(&strings::STRING_ADD_ASSIGN),
diff --git a/clippy_lints/src/redundant_else.rs b/clippy_lints/src/redundant_else.rs
new file mode 100644
index 00000000000..3d585cd27a3
--- /dev/null
+++ b/clippy_lints/src/redundant_else.rs
@@ -0,0 +1,135 @@
+use crate::utils::span_lint_and_help;
+use rustc_ast::ast::{Block, Expr, ExprKind, Stmt, StmtKind};
+use rustc_ast::visit::{walk_expr, Visitor};
+use rustc_lint::{EarlyContext, EarlyLintPass};
+use rustc_middle::lint::in_external_macro;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for `else` blocks that can be removed without changing semantics.
+    ///
+    /// **Why is this bad?** The `else` block adds unnecessary indentation and verbosity.
+    ///
+    /// **Known problems:** Some may prefer to keep the `else` block for clarity.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// fn my_func(count: u32) {
+    ///     if count == 0 {
+    ///         print!("Nothing to do");
+    ///         return;
+    ///     } else {
+    ///         print!("Moving on...");
+    ///     }
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// fn my_func(count: u32) {
+    ///     if count == 0 {
+    ///         print!("Nothing to do");
+    ///         return;
+    ///     }
+    ///     print!("Moving on...");
+    /// }
+    /// ```
+    pub REDUNDANT_ELSE,
+    pedantic,
+    "`else` branch that can be removed without changing semantics"
+}
+
+declare_lint_pass!(RedundantElse => [REDUNDANT_ELSE]);
+
+impl EarlyLintPass for RedundantElse {
+    fn check_stmt(&mut self, cx: &EarlyContext<'_>, stmt: &Stmt) {
+        if in_external_macro(cx.sess, stmt.span) {
+            return;
+        }
+        // Only look at expressions that are a whole statement
+        let expr: &Expr = match &stmt.kind {
+            StmtKind::Expr(expr) | StmtKind::Semi(expr) => expr,
+            _ => return,
+        };
+        // if else
+        let (mut then, mut els): (&Block, &Expr) = match &expr.kind {
+            ExprKind::If(_, then, Some(els)) => (then, els),
+            _ => return,
+        };
+        loop {
+            if !BreakVisitor::default().check_block(then) {
+                // then block does not always break
+                return;
+            }
+            match &els.kind {
+                // else if else
+                ExprKind::If(_, next_then, Some(next_els)) => {
+                    then = next_then;
+                    els = next_els;
+                    continue;
+                },
+                // else if without else
+                ExprKind::If(..) => return,
+                // done
+                _ => break,
+            }
+        }
+        span_lint_and_help(
+            cx,
+            REDUNDANT_ELSE,
+            els.span,
+            "redundant else block",
+            None,
+            "remove the `else` block and move the contents out",
+        );
+    }
+}
+
+/// Call `check` functions to check if an expression always breaks control flow
+#[derive(Default)]
+struct BreakVisitor {
+    is_break: bool,
+}
+
+impl<'ast> Visitor<'ast> for BreakVisitor {
+    fn visit_block(&mut self, block: &'ast Block) {
+        self.is_break = match block.stmts.as_slice() {
+            [.., last] => self.check_stmt(last),
+            _ => false,
+        };
+    }
+
+    fn visit_expr(&mut self, expr: &'ast Expr) {
+        self.is_break = match expr.kind {
+            ExprKind::Break(..) | ExprKind::Continue(..) | ExprKind::Ret(..) => true,
+            ExprKind::Match(_, ref arms) => arms.iter().all(|arm| self.check_expr(&arm.body)),
+            ExprKind::If(_, ref then, Some(ref els)) => self.check_block(then) && self.check_expr(els),
+            ExprKind::If(_, _, None)
+            // ignore loops for simplicity
+            | ExprKind::While(..) | ExprKind::ForLoop(..) | ExprKind::Loop(..) => false,
+            _ => {
+                walk_expr(self, expr);
+                return;
+            },
+        };
+    }
+}
+
+impl BreakVisitor {
+    fn check<T>(&mut self, item: T, visit: fn(&mut Self, T)) -> bool {
+        visit(self, item);
+        std::mem::replace(&mut self.is_break, false)
+    }
+
+    fn check_block(&mut self, block: &Block) -> bool {
+        self.check(block, Self::visit_block)
+    }
+
+    fn check_expr(&mut self, expr: &Expr) -> bool {
+        self.check(expr, Self::visit_expr)
+    }
+
+    fn check_stmt(&mut self, stmt: &Stmt) -> bool {
+        self.check(stmt, Self::visit_stmt)
+    }
+}
diff --git a/tests/ui/redundant_else.rs b/tests/ui/redundant_else.rs
new file mode 100644
index 00000000000..737c8a9f8db
--- /dev/null
+++ b/tests/ui/redundant_else.rs
@@ -0,0 +1,154 @@
+#![warn(clippy::redundant_else)]
+#![allow(clippy::needless_return)]
+
+fn main() {
+    loop {
+        // break
+        if foo() {
+            println!("Love your neighbor;");
+            break;
+        } else {
+            println!("yet don't pull down your hedge.");
+        }
+        // continue
+        if foo() {
+            println!("He that lies down with Dogs,");
+            continue;
+        } else {
+            println!("shall rise up with fleas.");
+        }
+        // match block
+        if foo() {
+            match foo() {
+                1 => break,
+                _ => return,
+            }
+        } else {
+            println!("You may delay, but time will not.");
+        }
+    }
+    // else if
+    if foo() {
+        return;
+    } else if foo() {
+        return;
+    } else {
+        println!("A fat kitchen makes a lean will.");
+    }
+    // let binding outside of block
+    let _ = {
+        if foo() {
+            return;
+        } else {
+            1
+        }
+    };
+    // else if with let binding outside of block
+    let _ = {
+        if foo() {
+            return;
+        } else if foo() {
+            return;
+        } else {
+            2
+        }
+    };
+    // inside if let
+    let _ = if let Some(1) = foo() {
+        let _ = 1;
+        if foo() {
+            return;
+        } else {
+            1
+        }
+    } else {
+        1
+    };
+
+    //
+    // non-lint cases
+    //
+
+    // sanity check
+    if foo() {
+        let _ = 1;
+    } else {
+        println!("Who is wise? He that learns from every one.");
+    }
+    // else if without else
+    if foo() {
+        return;
+    } else if foo() {
+        foo()
+    };
+    // nested if return
+    if foo() {
+        if foo() {
+            return;
+        }
+    } else {
+        foo()
+    };
+    // match with non-breaking branch
+    if foo() {
+        match foo() {
+            1 => foo(),
+            _ => return,
+        }
+    } else {
+        println!("Three may keep a secret, if two of them are dead.");
+    }
+    // let binding
+    let _ = if foo() {
+        return;
+    } else {
+        1
+    };
+    // assign
+    let a;
+    a = if foo() {
+        return;
+    } else {
+        1
+    };
+    // assign-op
+    a += if foo() {
+        return;
+    } else {
+        1
+    };
+    // if return else if else
+    if foo() {
+        return;
+    } else if foo() {
+        1
+    } else {
+        2
+    };
+    // if else if return else
+    if foo() {
+        1
+    } else if foo() {
+        return;
+    } else {
+        2
+    };
+    // else if with let binding
+    let _ = if foo() {
+        return;
+    } else if foo() {
+        return;
+    } else {
+        2
+    };
+    // inside function call
+    Box::new(if foo() {
+        return;
+    } else {
+        1
+    });
+}
+
+fn foo<T>() -> T {
+    unimplemented!("I'm not Santa Claus")
+}
diff --git a/tests/ui/redundant_else.stderr b/tests/ui/redundant_else.stderr
new file mode 100644
index 00000000000..9000cdc814b
--- /dev/null
+++ b/tests/ui/redundant_else.stderr
@@ -0,0 +1,80 @@
+error: redundant else block
+  --> $DIR/redundant_else.rs:10:16
+   |
+LL |           } else {
+   |  ________________^
+LL | |             println!("yet don't pull down your hedge.");
+LL | |         }
+   | |_________^
+   |
+   = note: `-D clippy::redundant-else` implied by `-D warnings`
+   = help: remove the `else` block and move the contents out
+
+error: redundant else block
+  --> $DIR/redundant_else.rs:17:16
+   |
+LL |           } else {
+   |  ________________^
+LL | |             println!("shall rise up with fleas.");
+LL | |         }
+   | |_________^
+   |
+   = help: remove the `else` block and move the contents out
+
+error: redundant else block
+  --> $DIR/redundant_else.rs:26:16
+   |
+LL |           } else {
+   |  ________________^
+LL | |             println!("You may delay, but time will not.");
+LL | |         }
+   | |_________^
+   |
+   = help: remove the `else` block and move the contents out
+
+error: redundant else block
+  --> $DIR/redundant_else.rs:35:12
+   |
+LL |       } else {
+   |  ____________^
+LL | |         println!("A fat kitchen makes a lean will.");
+LL | |     }
+   | |_____^
+   |
+   = help: remove the `else` block and move the contents out
+
+error: redundant else block
+  --> $DIR/redundant_else.rs:42:16
+   |
+LL |           } else {
+   |  ________________^
+LL | |             1
+LL | |         }
+   | |_________^
+   |
+   = help: remove the `else` block and move the contents out
+
+error: redundant else block
+  --> $DIR/redundant_else.rs:52:16
+   |
+LL |           } else {
+   |  ________________^
+LL | |             2
+LL | |         }
+   | |_________^
+   |
+   = help: remove the `else` block and move the contents out
+
+error: redundant else block
+  --> $DIR/redundant_else.rs:61:16
+   |
+LL |           } else {
+   |  ________________^
+LL | |             1
+LL | |         }
+   | |_________^
+   |
+   = help: remove the `else` block and move the contents out
+
+error: aborting due to 7 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 70f6a2cae22cc1245ee62ca493f3027a76b3a381 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Fri, 13 Nov 2020 12:46:37 -0600
Subject: Eat redundant else dogfood

---
 clippy_lints/src/functions.rs                      | 13 +++++--------
 clippy_lints/src/len_zero.rs                       |  3 +--
 clippy_lints/src/matches.rs                        |  5 ++---
 clippy_lints/src/methods/unnecessary_filter_map.rs |  5 ++---
 clippy_lints/src/non_expressive_names.rs           |  7 +++----
 5 files changed, 13 insertions(+), 20 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/functions.rs b/clippy_lints/src/functions.rs
index 8b58d1f2601..fd93548b55c 100644
--- a/clippy_lints/src/functions.rs
+++ b/clippy_lints/src/functions.rs
@@ -405,13 +405,10 @@ impl<'tcx> Functions {
                     break;
                 }
                 if in_comment {
-                    match line.find("*/") {
-                        Some(i) => {
-                            line = &line[i + 2..];
-                            in_comment = false;
-                            continue;
-                        },
-                        None => break,
+                    if let Some(i) = line.find("*/") {
+                        line = &line[i + 2..];
+                        in_comment = false;
+                        continue;
                     }
                 } else {
                     let multi_idx = line.find("/*").unwrap_or_else(|| line.len());
@@ -423,8 +420,8 @@ impl<'tcx> Functions {
                         in_comment = true;
                         continue;
                     }
-                    break;
                 }
+                break;
             }
             if code_in_line {
                 line_count += 1;
diff --git a/clippy_lints/src/len_zero.rs b/clippy_lints/src/len_zero.rs
index 8842901d90b..6fe53351090 100644
--- a/clippy_lints/src/len_zero.rs
+++ b/clippy_lints/src/len_zero.rs
@@ -222,9 +222,8 @@ fn check_impl_items(cx: &LateContext<'_>, item: &Item<'_>, impl_items: &[ImplIte
     let is_empty = if let Some(is_empty) = impl_items.iter().find(|i| is_named_self(cx, i, "is_empty")) {
         if cx.access_levels.is_exported(is_empty.id.hir_id) {
             return;
-        } else {
-            "a private"
         }
+        "a private"
     } else {
         "no corresponding"
     };
diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index 7d64fa6c262..5c3901e5b28 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -696,10 +696,9 @@ fn check_single_match(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>], exp
             if stmts.len() == 1 && block_expr.is_none() || stmts.is_empty() && block_expr.is_some() {
                 // single statement/expr "else" block, don't lint
                 return;
-            } else {
-                // block with 2+ statements or 1 expr and 1+ statement
-                Some(els)
             }
+            // block with 2+ statements or 1 expr and 1+ statement
+            Some(els)
         } else {
             // not a block, don't lint
             return;
diff --git a/clippy_lints/src/methods/unnecessary_filter_map.rs b/clippy_lints/src/methods/unnecessary_filter_map.rs
index 75e123eb593..d082a88cd2d 100644
--- a/clippy_lints/src/methods/unnecessary_filter_map.rs
+++ b/clippy_lints/src/methods/unnecessary_filter_map.rs
@@ -69,10 +69,9 @@ fn check_expression<'tcx>(cx: &LateContext<'tcx>, arg_id: hir::HirId, expr: &'tc
                             }
                         }
                         return (true, false);
-                    } else {
-                        // We don't know. It might do anything.
-                        return (true, true);
                     }
+                    // We don't know. It might do anything.
+                    return (true, true);
                 }
             }
             (true, true)
diff --git a/clippy_lints/src/non_expressive_names.rs b/clippy_lints/src/non_expressive_names.rs
index 5b42b61fcde..446426b3e61 100644
--- a/clippy_lints/src/non_expressive_names.rs
+++ b/clippy_lints/src/non_expressive_names.rs
@@ -409,11 +409,10 @@ fn levenstein_not_1(a_name: &str, b_name: &str) -> bool {
         if let Some(b2) = b_chars.next() {
             // check if there's just one character inserted
             return a != b2 || a_chars.ne(b_chars);
-        } else {
-            // tuple
-            // ntuple
-            return true;
         }
+        // tuple
+        // ntuple
+        return true;
     }
     // for item in items
     true
-- 
cgit 1.4.1-3-g733a5


From e7258ac714941ed5534ae31cddac7164ce1f50c1 Mon Sep 17 00:00:00 2001
From: Suyash458 <suyash.behera458@gmail.com>
Date: Mon, 30 Nov 2020 11:24:10 +0530
Subject: bump rustc-semver version. use in built method to compare versions

---
 clippy_lints/Cargo.toml       | 2 +-
 clippy_lints/src/utils/mod.rs | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/Cargo.toml b/clippy_lints/Cargo.toml
index 45fd87b169f..9b8ff266f5c 100644
--- a/clippy_lints/Cargo.toml
+++ b/clippy_lints/Cargo.toml
@@ -28,7 +28,7 @@ smallvec = { version = "1", features = ["union"] }
 toml = "0.5.3"
 unicode-normalization = "0.1"
 semver = "0.11"
-rustc-semver="1.0.0"
+rustc-semver="1.1.0"
 # NOTE: cargo requires serde feat in its url dep
 # see <https://github.com/rust-lang/rust/pull/63587#issuecomment-522343864>
 url = { version =  "2.1.0", features = ["serde"] }
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index 9c5e55b1ed5..b2f16007e35 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -76,7 +76,7 @@ pub fn parse_msrv(msrv: &str, sess: Option<&Session>, span: Option<Span>) -> Opt
 }
 
 pub fn meets_msrv(msrv: Option<&RustcVersion>, lint_msrv: &RustcVersion) -> bool {
-    msrv.map_or(true, |msrv| msrv >= lint_msrv)
+    msrv.map_or(true, |msrv| msrv.meets(*lint_msrv))
 }
 
 macro_rules! extract_msrv_attr {
-- 
cgit 1.4.1-3-g733a5


From 415394c3fc0e008026b3f2a37fbd57a58449b4d3 Mon Sep 17 00:00:00 2001
From: pro-grammer1 <1df0d0d3-eed4-45fc-bc60-43a85079f3f9@anonaddy.me>
Date: Tue, 1 Dec 2020 09:44:43 +0000
Subject: Fix false positive in write_literal and print_literal due to numeric
 literals

---
 clippy_lints/src/write.rs | 22 +++++++++++++++++-----
 1 file changed, 17 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs
index ff414f748ef..78d23e1e0ef 100644
--- a/clippy_lints/src/write.rs
+++ b/clippy_lints/src/write.rs
@@ -2,7 +2,8 @@ use std::borrow::Cow;
 use std::ops::Range;
 
 use crate::utils::{snippet_with_applicability, span_lint, span_lint_and_sugg, span_lint_and_then};
-use rustc_ast::ast::{Expr, ExprKind, Item, ItemKind, MacCall, StrLit, StrStyle};
+use if_chain::if_chain;
+use rustc_ast::ast::{Expr, ExprKind, Item, ItemKind, LitKind, MacCall, StrLit, StrStyle};
 use rustc_ast::token;
 use rustc_ast::tokenstream::TokenStream;
 use rustc_errors::Applicability;
@@ -442,7 +443,12 @@ impl Write {
                 return (Some(fmtstr), None);
             };
             match &token_expr.kind {
-                ExprKind::Lit(_) => {
+                ExprKind::Lit(lit)
+                    if match lit.kind {
+                        LitKind::Int(_, _) | LitKind::Float(_, _) => false,
+                        _ => true,
+                    } =>
+                {
                     let mut all_simple = true;
                     let mut seen = false;
                     for arg in &args {
@@ -460,10 +466,16 @@ impl Write {
                         span_lint(cx, lint, token_expr.span, "literal with an empty format string");
                     }
                     idx += 1;
-                },
+                }
                 ExprKind::Assign(lhs, rhs, _) => {
-                    if let ExprKind::Lit(_) = rhs.kind {
-                        if let ExprKind::Path(_, p) = &lhs.kind {
+                    if_chain! {
+                        if let ExprKind::Lit(ref lit) = rhs.kind;
+                        if match lit.kind {
+                            LitKind::Int(_, _) | LitKind::Float(_, _) => false,
+                            _ => true,
+                        };
+                        if let ExprKind::Path(_, p) = &lhs.kind;
+                        then {
                             let mut all_simple = true;
                             let mut seen = false;
                             for arg in &args {
-- 
cgit 1.4.1-3-g733a5


From 8135ab8a22f4aa6ad071574798397aa131377ca2 Mon Sep 17 00:00:00 2001
From: Ricky <Ricky@Hosfelt.io>
Date: Thu, 3 Dec 2020 16:11:52 -0500
Subject: Moved map_err_ignore to restriction and updated help message

---
 clippy_lints/src/map_err_ignore.rs | 4 ++--
 tests/ui/map_err.stderr            | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/map_err_ignore.rs b/clippy_lints/src/map_err_ignore.rs
index 5298e16a04d..324a11f140a 100644
--- a/clippy_lints/src/map_err_ignore.rs
+++ b/clippy_lints/src/map_err_ignore.rs
@@ -99,7 +99,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     pub MAP_ERR_IGNORE,
-    pedantic,
+    restriction,
     "`map_err` should not ignore the original error"
 }
 
@@ -135,7 +135,7 @@ impl<'tcx> LateLintPass<'tcx> for MapErrIgnore {
                                     body_span,
                                     "`map_err(|_|...` ignores the original error",
                                     None,
-                                    "Consider wrapping the error in an enum variant",
+                                    "Consider wrapping the error in an enum variant for more error context, or using a named wildcard (`.map_err(|_ignored| ...`) to intentionally ignore the error",
                                 );
                             }
                         }
diff --git a/tests/ui/map_err.stderr b/tests/ui/map_err.stderr
index 390d7ce2e4e..8193f7cfb8e 100644
--- a/tests/ui/map_err.stderr
+++ b/tests/ui/map_err.stderr
@@ -5,7 +5,7 @@ LL |     println!("{:?}", x.map_err(|_| Errors::Ignored));
    |                                ^^^
    |
    = note: `-D clippy::map-err-ignore` implied by `-D warnings`
-   = help: Consider wrapping the error in an enum variant
+   = help: Consider wrapping the error in an enum variant for more error context, or using a named wildcard (`.map_err(|_ignored| ...`) to intentionally ignore the error
 
 error: aborting due to previous error
 
-- 
cgit 1.4.1-3-g733a5


From f633ef6bba70b91f0415316fe10bb1f9c016ba33 Mon Sep 17 00:00:00 2001
From: Ricky <Ricky@Hosfelt.io>
Date: Thu, 3 Dec 2020 17:22:03 -0500
Subject: didn't update lint correctly

---
 clippy_lints/src/lib.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 167e5b6b87f..013406347f2 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1214,6 +1214,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&integer_division::INTEGER_DIVISION),
         LintId::of(&let_underscore::LET_UNDERSCORE_MUST_USE),
         LintId::of(&literal_representation::DECIMAL_LITERAL_REPRESENTATION),
+        LintId::of(&map_err_ignore::MAP_ERR_IGNORE),
         LintId::of(&matches::REST_PAT_IN_FULLY_BOUND_STRUCTS),
         LintId::of(&matches::WILDCARD_ENUM_MATCH_ARM),
         LintId::of(&mem_forget::MEM_FORGET),
@@ -1280,7 +1281,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&loops::EXPLICIT_ITER_LOOP),
         LintId::of(&macro_use::MACRO_USE_IMPORTS),
         LintId::of(&manual_ok_or::MANUAL_OK_OR),
-        LintId::of(&map_err_ignore::MAP_ERR_IGNORE),
         LintId::of(&match_on_vec_items::MATCH_ON_VEC_ITEMS),
         LintId::of(&matches::MATCH_BOOL),
         LintId::of(&matches::MATCH_SAME_ARMS),
-- 
cgit 1.4.1-3-g733a5


From 75482f917d7fc65190274bd577dcc2e30ba34aff Mon Sep 17 00:00:00 2001
From: Ricky <ricky@hosfelt.io>
Date: Thu, 3 Dec 2020 17:44:50 -0500
Subject: Apply suggestions from code review

updated help message for the user

Co-authored-by: Jane Lusby <jlusby42@gmail.com>
---
 clippy_lints/src/map_err_ignore.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/map_err_ignore.rs b/clippy_lints/src/map_err_ignore.rs
index 324a11f140a..f3c0515b9bc 100644
--- a/clippy_lints/src/map_err_ignore.rs
+++ b/clippy_lints/src/map_err_ignore.rs
@@ -133,9 +133,9 @@ impl<'tcx> LateLintPass<'tcx> for MapErrIgnore {
                                     cx,
                                     MAP_ERR_IGNORE,
                                     body_span,
-                                    "`map_err(|_|...` ignores the original error",
+                                    "`map_err(|_|...` wildcard pattern discards the original error",
                                     None,
-                                    "Consider wrapping the error in an enum variant for more error context, or using a named wildcard (`.map_err(|_ignored| ...`) to intentionally ignore the error",
+                                    "Consider storing the original error as a source in the new error, or silence this warning using an ignored identifier (`.map_err(|_foo| ...`)",
                                 );
                             }
                         }
-- 
cgit 1.4.1-3-g733a5


From b6113066429bc3108f62b920ccbfc79accfef2dd Mon Sep 17 00:00:00 2001
From: unknown <abramlujan@gmail.com>
Date: Fri, 27 Nov 2020 22:44:02 -0300
Subject: Add lint unsafe_sizeof_count_copies

---
 CHANGELOG.md                                   |   1 +
 clippy_lints/src/lib.rs                        |   5 +
 clippy_lints/src/unsafe_sizeof_count_copies.rs |  98 ++++++++++++++++++
 clippy_lints/src/utils/paths.rs                |   4 +
 tests/ui/unsafe_sizeof_count_copies.rs         |  54 ++++++++++
 tests/ui/unsafe_sizeof_count_copies.stderr     | 131 +++++++++++++++++++++++++
 6 files changed, 293 insertions(+)
 create mode 100644 clippy_lints/src/unsafe_sizeof_count_copies.rs
 create mode 100644 tests/ui/unsafe_sizeof_count_copies.rs
 create mode 100644 tests/ui/unsafe_sizeof_count_copies.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index e65e7cc639f..e0f3b82ad25 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2124,6 +2124,7 @@ Released 2018-09-13
 [`unreadable_literal`]: https://rust-lang.github.io/rust-clippy/master/index.html#unreadable_literal
 [`unsafe_derive_deserialize`]: https://rust-lang.github.io/rust-clippy/master/index.html#unsafe_derive_deserialize
 [`unsafe_removed_from_name`]: https://rust-lang.github.io/rust-clippy/master/index.html#unsafe_removed_from_name
+[`unsafe_sizeof_count_copies`]: https://rust-lang.github.io/rust-clippy/master/index.html#unsafe_sizeof_count_copies
 [`unsafe_vector_initialization`]: https://rust-lang.github.io/rust-clippy/master/index.html#unsafe_vector_initialization
 [`unseparated_literal_suffix`]: https://rust-lang.github.io/rust-clippy/master/index.html#unseparated_literal_suffix
 [`unsound_collection_transmute`]: https://rust-lang.github.io/rust-clippy/master/index.html#unsound_collection_transmute
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 167e5b6b87f..1bce0130b40 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -329,6 +329,7 @@ mod unnecessary_sort_by;
 mod unnecessary_wraps;
 mod unnested_or_patterns;
 mod unsafe_removed_from_name;
+mod unsafe_sizeof_count_copies;
 mod unused_io_amount;
 mod unused_self;
 mod unused_unit;
@@ -916,6 +917,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &unnecessary_wraps::UNNECESSARY_WRAPS,
         &unnested_or_patterns::UNNESTED_OR_PATTERNS,
         &unsafe_removed_from_name::UNSAFE_REMOVED_FROM_NAME,
+        &unsafe_sizeof_count_copies::UNSAFE_SIZEOF_COUNT_COPIES,
         &unused_io_amount::UNUSED_IO_AMOUNT,
         &unused_self::UNUSED_SELF,
         &unused_unit::UNUSED_UNIT,
@@ -998,6 +1000,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(move || box matches::Matches::new(msrv));
     store.register_early_pass(move || box manual_non_exhaustive::ManualNonExhaustive::new(msrv));
     store.register_late_pass(move || box manual_strip::ManualStrip::new(msrv));
+    store.register_late_pass(|| box unsafe_sizeof_count_copies::UnsafeSizeofCountCopies);
     store.register_late_pass(|| box map_clone::MapClone);
     store.register_late_pass(|| box map_err_ignore::MapErrIgnore);
     store.register_late_pass(|| box shadow::Shadow);
@@ -1605,6 +1608,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&unnecessary_sort_by::UNNECESSARY_SORT_BY),
         LintId::of(&unnecessary_wraps::UNNECESSARY_WRAPS),
         LintId::of(&unsafe_removed_from_name::UNSAFE_REMOVED_FROM_NAME),
+        LintId::of(&unsafe_sizeof_count_copies::UNSAFE_SIZEOF_COUNT_COPIES),
         LintId::of(&unused_io_amount::UNUSED_IO_AMOUNT),
         LintId::of(&unused_unit::UNUSED_UNIT),
         LintId::of(&unwrap::PANICKING_UNWRAP),
@@ -1883,6 +1887,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&unit_return_expecting_ord::UNIT_RETURN_EXPECTING_ORD),
         LintId::of(&unnamed_address::FN_ADDRESS_COMPARISONS),
         LintId::of(&unnamed_address::VTABLE_ADDRESS_COMPARISONS),
+        LintId::of(&unsafe_sizeof_count_copies::UNSAFE_SIZEOF_COUNT_COPIES),
         LintId::of(&unused_io_amount::UNUSED_IO_AMOUNT),
         LintId::of(&unwrap::PANICKING_UNWRAP),
         LintId::of(&vec_resize_to_zero::VEC_RESIZE_TO_ZERO),
diff --git a/clippy_lints/src/unsafe_sizeof_count_copies.rs b/clippy_lints/src/unsafe_sizeof_count_copies.rs
new file mode 100644
index 00000000000..2422df8feba
--- /dev/null
+++ b/clippy_lints/src/unsafe_sizeof_count_copies.rs
@@ -0,0 +1,98 @@
+//! Lint on unsafe memory copying that use the `size_of` of the pointee type instead of a pointee
+//! count
+
+use crate::utils::{match_def_path, paths, span_lint_and_help};
+use if_chain::if_chain;
+use rustc_hir::BinOpKind;
+use rustc_hir::{Expr, ExprKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::{Ty as TyM, TyS};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// **What it does:** Detects expressions where
+    /// size_of::<T> is used as the count argument to unsafe
+    /// memory copying functions like ptr::copy and
+    /// ptr::copy_nonoverlapping where T is the pointee type
+    /// of the pointers used
+    ///
+    /// **Why is this bad?** These functions expect a count
+    /// of T and not a number of bytes, which can lead to
+    /// copying the incorrect amount of bytes, which can
+    /// result in Undefined Behaviour
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// ```rust,no_run
+    /// # use std::ptr::copy_nonoverlapping;
+    /// # use std::mem::size_of;
+    ///
+    /// const SIZE: usize = 128;
+    /// let x = [2u8; SIZE];
+    /// let mut y = [2u8; SIZE];
+    /// unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>() * SIZE) };
+    /// ```
+    pub UNSAFE_SIZEOF_COUNT_COPIES,
+    correctness,
+    "unsafe memory copying using a byte count instead of a count of T"
+}
+
+declare_lint_pass!(UnsafeSizeofCountCopies => [UNSAFE_SIZEOF_COUNT_COPIES]);
+
+fn get_size_of_ty(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<TyM<'tcx>> {
+    match &expr.kind {
+        ExprKind::Call(ref count_func, _func_args) => {
+            if_chain! {
+                if let ExprKind::Path(ref count_func_qpath) = count_func.kind;
+                if let Some(def_id) = cx.qpath_res(count_func_qpath, count_func.hir_id).opt_def_id();
+                if match_def_path(cx, def_id, &paths::MEM_SIZE_OF)
+                    || match_def_path(cx, def_id, &paths::MEM_SIZE_OF_VAL);
+                then {
+                    cx.typeck_results().node_substs(count_func.hir_id).types().next()
+                } else {
+                    None
+                }
+            }
+        },
+        ExprKind::Binary(op, left, right) if BinOpKind::Mul == op.node || BinOpKind::Div == op.node => {
+            get_size_of_ty(cx, &*left).or_else(|| get_size_of_ty(cx, &*right))
+        },
+        _ => None,
+    }
+}
+
+impl<'tcx> LateLintPass<'tcx> for UnsafeSizeofCountCopies {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        if_chain! {
+            // Find calls to ptr::copy and copy_nonoverlapping
+            if let ExprKind::Call(ref func, ref func_args) = expr.kind;
+            if let ExprKind::Path(ref func_qpath) = func.kind;
+            if let Some(def_id) = cx.qpath_res(func_qpath, func.hir_id).opt_def_id();
+            if match_def_path(cx, def_id, &paths::COPY_NONOVERLAPPING)
+                || match_def_path(cx, def_id, &paths::COPY);
+
+            // Get the pointee type
+            let _substs = cx.typeck_results().node_substs(func.hir_id);
+            if let Some(pointee_ty) = cx.typeck_results().node_substs(func.hir_id).types().next();
+
+            // Find a size_of call in the count parameter expression and
+            // check that it's the same type
+            if let [_src, _dest, count] = &**func_args;
+            if let Some(ty_used_for_size_of) = get_size_of_ty(cx, count);
+            if TyS::same_type(pointee_ty, ty_used_for_size_of);
+            then {
+                span_lint_and_help(
+                    cx,
+                    UNSAFE_SIZEOF_COUNT_COPIES,
+                    expr.span,
+                    "unsafe memory copying using a byte count (Multiplied by size_of::<T>) \
+                    instead of a count of T",
+                    None,
+                    "use a count of elements instead of a count of bytes for the count parameter, \
+                    it already gets multiplied by the size of the pointed to type"
+                );
+            }
+        };
+    }
+}
diff --git a/clippy_lints/src/utils/paths.rs b/clippy_lints/src/utils/paths.rs
index 16e6a016c9e..fe763d4bfbb 100644
--- a/clippy_lints/src/utils/paths.rs
+++ b/clippy_lints/src/utils/paths.rs
@@ -20,6 +20,8 @@ pub const CLONE_TRAIT: [&str; 3] = ["core", "clone", "Clone"];
 pub const CLONE_TRAIT_METHOD: [&str; 4] = ["core", "clone", "Clone", "clone"];
 pub const CMP_MAX: [&str; 3] = ["core", "cmp", "max"];
 pub const CMP_MIN: [&str; 3] = ["core", "cmp", "min"];
+pub const COPY: [&str; 3] = ["core", "intrinsics", "copy_nonoverlapping"];
+pub const COPY_NONOVERLAPPING: [&str; 3] = ["core", "intrinsics", "copy"];
 pub const COW: [&str; 3] = ["alloc", "borrow", "Cow"];
 pub const CSTRING_AS_C_STR: [&str; 5] = ["std", "ffi", "c_str", "CString", "as_c_str"];
 pub const DEFAULT_TRAIT: [&str; 3] = ["core", "default", "Default"];
@@ -73,6 +75,8 @@ pub const MEM_MANUALLY_DROP: [&str; 4] = ["core", "mem", "manually_drop", "Manua
 pub const MEM_MAYBEUNINIT: [&str; 4] = ["core", "mem", "maybe_uninit", "MaybeUninit"];
 pub const MEM_MAYBEUNINIT_UNINIT: [&str; 5] = ["core", "mem", "maybe_uninit", "MaybeUninit", "uninit"];
 pub const MEM_REPLACE: [&str; 3] = ["core", "mem", "replace"];
+pub const MEM_SIZE_OF: [&str; 3] = ["core", "mem", "size_of"];
+pub const MEM_SIZE_OF_VAL: [&str; 3] = ["core", "mem", "size_of_val"];
 pub const MUTEX_GUARD: [&str; 4] = ["std", "sync", "mutex", "MutexGuard"];
 pub const OPEN_OPTIONS: [&str; 3] = ["std", "fs", "OpenOptions"];
 pub const OPS_MODULE: [&str; 2] = ["core", "ops"];
diff --git a/tests/ui/unsafe_sizeof_count_copies.rs b/tests/ui/unsafe_sizeof_count_copies.rs
new file mode 100644
index 00000000000..0077ed07fce
--- /dev/null
+++ b/tests/ui/unsafe_sizeof_count_copies.rs
@@ -0,0 +1,54 @@
+#![warn(clippy::unsafe_sizeof_count_copies)]
+
+use std::mem::{size_of, size_of_val};
+use std::ptr::{copy, copy_nonoverlapping};
+
+fn main() {
+    const SIZE: usize = 128;
+    const HALF_SIZE: usize = SIZE / 2;
+    const DOUBLE_SIZE: usize = SIZE * 2;
+    let mut x = [2u8; SIZE];
+    let mut y = [2u8; SIZE];
+
+    // Count is size_of (Should trigger the lint)
+    unsafe { copy_nonoverlapping::<u8>(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>()) };
+    unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), size_of_val(&x[0])) };
+
+    unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>()) };
+    unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of_val(&x[0])) };
+
+    // Count expression involving multiplication of size_of (Should trigger the lint)
+    unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>() * SIZE) };
+    unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), size_of_val(&x[0]) * SIZE) };
+
+    unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>() * SIZE) };
+    unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of_val(&x[0]) * SIZE) };
+
+    // Count expression involving nested multiplications of size_of (Should trigger the lint)
+    unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>() * HALF_SIZE * 2) };
+    unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), HALF_SIZE * size_of_val(&x[0]) * 2) };
+
+    unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>() * SIZE * HALF_SIZE) };
+    unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of_val(&x[0]) * HALF_SIZE * 2) };
+
+    // Count expression involving divisions of size_of (Should trigger the lint)
+    unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>() * DOUBLE_SIZE / 2) };
+    unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), DOUBLE_SIZE / 2 * size_of_val(&x[0])) };
+
+    unsafe { copy(x.as_ptr(), y.as_mut_ptr(), DOUBLE_SIZE * size_of::<u8>() / 2) };
+    unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of_val(&x[0]) * DOUBLE_SIZE / 2) };
+
+    // No size_of calls (Should not trigger the lint)
+    unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), SIZE) };
+    unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), SIZE) };
+
+    unsafe { copy(x.as_ptr(), y.as_mut_ptr(), SIZE) };
+    unsafe { copy(x.as_ptr(), y.as_mut_ptr(), SIZE) };
+
+    // Different types for pointee and size_of (Should not trigger the lint)
+    unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), size_of::<u16>() / 2 * SIZE) };
+    unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), size_of_val(&0u16) / 2 * SIZE) };
+
+    unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of::<u16>() / 2 * SIZE) };
+    unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of_val(&0u16) / 2 * SIZE) };
+}
diff --git a/tests/ui/unsafe_sizeof_count_copies.stderr b/tests/ui/unsafe_sizeof_count_copies.stderr
new file mode 100644
index 00000000000..6804df8cdfc
--- /dev/null
+++ b/tests/ui/unsafe_sizeof_count_copies.stderr
@@ -0,0 +1,131 @@
+error: unsafe memory copying using a byte count (Multiplied by size_of::<T>) instead of a count of T
+  --> $DIR/unsafe_sizeof_count_copies.rs:14:14
+   |
+LL |     unsafe { copy_nonoverlapping::<u8>(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>()) };
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::unsafe-sizeof-count-copies` implied by `-D warnings`
+   = help: use a count of elements instead of a count of bytes for the count parameter, it already gets multiplied by the size of the pointed to type
+
+error: unsafe memory copying using a byte count (Multiplied by size_of::<T>) instead of a count of T
+  --> $DIR/unsafe_sizeof_count_copies.rs:15:14
+   |
+LL |     unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), size_of_val(&x[0])) };
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use a count of elements instead of a count of bytes for the count parameter, it already gets multiplied by the size of the pointed to type
+
+error: unsafe memory copying using a byte count (Multiplied by size_of::<T>) instead of a count of T
+  --> $DIR/unsafe_sizeof_count_copies.rs:17:14
+   |
+LL |     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>()) };
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use a count of elements instead of a count of bytes for the count parameter, it already gets multiplied by the size of the pointed to type
+
+error: unsafe memory copying using a byte count (Multiplied by size_of::<T>) instead of a count of T
+  --> $DIR/unsafe_sizeof_count_copies.rs:18:14
+   |
+LL |     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of_val(&x[0])) };
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use a count of elements instead of a count of bytes for the count parameter, it already gets multiplied by the size of the pointed to type
+
+error: unsafe memory copying using a byte count (Multiplied by size_of::<T>) instead of a count of T
+  --> $DIR/unsafe_sizeof_count_copies.rs:21:14
+   |
+LL |     unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>() * SIZE) };
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use a count of elements instead of a count of bytes for the count parameter, it already gets multiplied by the size of the pointed to type
+
+error: unsafe memory copying using a byte count (Multiplied by size_of::<T>) instead of a count of T
+  --> $DIR/unsafe_sizeof_count_copies.rs:22:14
+   |
+LL |     unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), size_of_val(&x[0]) * SIZE) };
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use a count of elements instead of a count of bytes for the count parameter, it already gets multiplied by the size of the pointed to type
+
+error: unsafe memory copying using a byte count (Multiplied by size_of::<T>) instead of a count of T
+  --> $DIR/unsafe_sizeof_count_copies.rs:24:14
+   |
+LL |     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>() * SIZE) };
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use a count of elements instead of a count of bytes for the count parameter, it already gets multiplied by the size of the pointed to type
+
+error: unsafe memory copying using a byte count (Multiplied by size_of::<T>) instead of a count of T
+  --> $DIR/unsafe_sizeof_count_copies.rs:25:14
+   |
+LL |     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of_val(&x[0]) * SIZE) };
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use a count of elements instead of a count of bytes for the count parameter, it already gets multiplied by the size of the pointed to type
+
+error: unsafe memory copying using a byte count (Multiplied by size_of::<T>) instead of a count of T
+  --> $DIR/unsafe_sizeof_count_copies.rs:28:14
+   |
+LL |     unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>() * HALF_SIZE * 2) };
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use a count of elements instead of a count of bytes for the count parameter, it already gets multiplied by the size of the pointed to type
+
+error: unsafe memory copying using a byte count (Multiplied by size_of::<T>) instead of a count of T
+  --> $DIR/unsafe_sizeof_count_copies.rs:29:14
+   |
+LL |     unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), HALF_SIZE * size_of_val(&x[0]) * 2) };
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use a count of elements instead of a count of bytes for the count parameter, it already gets multiplied by the size of the pointed to type
+
+error: unsafe memory copying using a byte count (Multiplied by size_of::<T>) instead of a count of T
+  --> $DIR/unsafe_sizeof_count_copies.rs:31:14
+   |
+LL |     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>() * SIZE * HALF_SIZE) };
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use a count of elements instead of a count of bytes for the count parameter, it already gets multiplied by the size of the pointed to type
+
+error: unsafe memory copying using a byte count (Multiplied by size_of::<T>) instead of a count of T
+  --> $DIR/unsafe_sizeof_count_copies.rs:32:14
+   |
+LL |     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of_val(&x[0]) * HALF_SIZE * 2) };
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use a count of elements instead of a count of bytes for the count parameter, it already gets multiplied by the size of the pointed to type
+
+error: unsafe memory copying using a byte count (Multiplied by size_of::<T>) instead of a count of T
+  --> $DIR/unsafe_sizeof_count_copies.rs:35:14
+   |
+LL |     unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>() * DOUBLE_SIZE / 2) };
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use a count of elements instead of a count of bytes for the count parameter, it already gets multiplied by the size of the pointed to type
+
+error: unsafe memory copying using a byte count (Multiplied by size_of::<T>) instead of a count of T
+  --> $DIR/unsafe_sizeof_count_copies.rs:36:14
+   |
+LL |     unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), DOUBLE_SIZE / 2 * size_of_val(&x[0])) };
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use a count of elements instead of a count of bytes for the count parameter, it already gets multiplied by the size of the pointed to type
+
+error: unsafe memory copying using a byte count (Multiplied by size_of::<T>) instead of a count of T
+  --> $DIR/unsafe_sizeof_count_copies.rs:38:14
+   |
+LL |     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), DOUBLE_SIZE * size_of::<u8>() / 2) };
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use a count of elements instead of a count of bytes for the count parameter, it already gets multiplied by the size of the pointed to type
+
+error: unsafe memory copying using a byte count (Multiplied by size_of::<T>) instead of a count of T
+  --> $DIR/unsafe_sizeof_count_copies.rs:39:14
+   |
+LL |     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of_val(&x[0]) * DOUBLE_SIZE / 2) };
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use a count of elements instead of a count of bytes for the count parameter, it already gets multiplied by the size of the pointed to type
+
+error: aborting due to 16 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 0f954babef41b16e26b900d3858ceac4005a4506 Mon Sep 17 00:00:00 2001
From: unknown <abramlujan@gmail.com>
Date: Sun, 29 Nov 2020 01:47:32 -0300
Subject: Make the unsafe_sizeof_count_copies lint find copy_{from,to} method
 calls

---
 clippy_lints/src/unsafe_sizeof_count_copies.rs | 66 +++++++++++++++++++-------
 tests/ui/unsafe_sizeof_count_copies.rs         |  5 ++
 tests/ui/unsafe_sizeof_count_copies.stderr     | 60 +++++++++++++++++------
 3 files changed, 99 insertions(+), 32 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unsafe_sizeof_count_copies.rs b/clippy_lints/src/unsafe_sizeof_count_copies.rs
index 2422df8feba..5df7d72564e 100644
--- a/clippy_lints/src/unsafe_sizeof_count_copies.rs
+++ b/clippy_lints/src/unsafe_sizeof_count_copies.rs
@@ -6,7 +6,7 @@ use if_chain::if_chain;
 use rustc_hir::BinOpKind;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty::{Ty as TyM, TyS};
+use rustc_middle::ty::{self, Ty, TyS, TypeAndMut};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
@@ -40,7 +40,7 @@ declare_clippy_lint! {
 
 declare_lint_pass!(UnsafeSizeofCountCopies => [UNSAFE_SIZEOF_COUNT_COPIES]);
 
-fn get_size_of_ty(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<TyM<'tcx>> {
+fn get_size_of_ty(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<Ty<'tcx>> {
     match &expr.kind {
         ExprKind::Call(ref count_func, _func_args) => {
             if_chain! {
@@ -62,35 +62,65 @@ fn get_size_of_ty(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<TyM<'t
     }
 }
 
+fn get_pointee_ty_and_count_expr(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<(Ty<'tcx>, &'tcx Expr<'tcx>)> {
+    if_chain! {
+        // Find calls to ptr::copy and copy_nonoverlapping
+        if let ExprKind::Call(ref func, ref args) = expr.kind;
+        if let [_src, _dest, count] = &**args;
+        if let ExprKind::Path(ref func_qpath) = func.kind;
+        if let Some(def_id) = cx.qpath_res(func_qpath, func.hir_id).opt_def_id();
+        if match_def_path(cx, def_id, &paths::COPY_NONOVERLAPPING)
+            || match_def_path(cx, def_id, &paths::COPY);
+
+        // Get the pointee type
+        if let Some(pointee_ty) = cx.typeck_results().node_substs(func.hir_id).types().next();
+        then {
+            return Some((pointee_ty, count));
+        }
+    };
+    if_chain! {
+        // Find calls to copy_{from,to}{,_nonoverlapping}
+        if let ExprKind::MethodCall(ref method_path, _, ref args, _) = expr.kind;
+        if let [ptr_self, _, count] = &**args;
+        let method_ident = method_path.ident.as_str();
+        if method_ident== "copy_to" || method_ident == "copy_from"
+            || method_ident == "copy_to_nonoverlapping" || method_ident == "copy_from_nonoverlapping";
+
+        // Get the pointee type
+        if let ty::RawPtr(TypeAndMut { ty: pointee_ty, mutbl:_mutability }) =
+            cx.typeck_results().expr_ty(ptr_self).kind();
+        then {
+            return Some((pointee_ty, count));
+        }
+    };
+    None
+}
+
 impl<'tcx> LateLintPass<'tcx> for UnsafeSizeofCountCopies {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if_chain! {
-            // Find calls to ptr::copy and copy_nonoverlapping
-            if let ExprKind::Call(ref func, ref func_args) = expr.kind;
-            if let ExprKind::Path(ref func_qpath) = func.kind;
-            if let Some(def_id) = cx.qpath_res(func_qpath, func.hir_id).opt_def_id();
-            if match_def_path(cx, def_id, &paths::COPY_NONOVERLAPPING)
-                || match_def_path(cx, def_id, &paths::COPY);
+        const HELP_MSG: &str = "use a count of elements instead of a count of bytes \
+            for the count parameter, it already gets multiplied by the size of the pointed to type";
+
+        const LINT_MSG: &str = "unsafe memory copying using a byte count \
+            (Multiplied by size_of::<T>) instead of a count of T";
 
-            // Get the pointee type
-            let _substs = cx.typeck_results().node_substs(func.hir_id);
-            if let Some(pointee_ty) = cx.typeck_results().node_substs(func.hir_id).types().next();
+        if_chain! {
+            // Find calls to unsafe copy functions and get
+            // the pointee type and count parameter expression
+            if let Some((pointee_ty, count_expr)) = get_pointee_ty_and_count_expr(cx, expr);
 
             // Find a size_of call in the count parameter expression and
             // check that it's the same type
-            if let [_src, _dest, count] = &**func_args;
-            if let Some(ty_used_for_size_of) = get_size_of_ty(cx, count);
+            if let Some(ty_used_for_size_of) = get_size_of_ty(cx, count_expr);
             if TyS::same_type(pointee_ty, ty_used_for_size_of);
             then {
                 span_lint_and_help(
                     cx,
                     UNSAFE_SIZEOF_COUNT_COPIES,
                     expr.span,
-                    "unsafe memory copying using a byte count (Multiplied by size_of::<T>) \
-                    instead of a count of T",
+                    LINT_MSG,
                     None,
-                    "use a count of elements instead of a count of bytes for the count parameter, \
-                    it already gets multiplied by the size of the pointed to type"
+                    HELP_MSG
                 );
             }
         };
diff --git a/tests/ui/unsafe_sizeof_count_copies.rs b/tests/ui/unsafe_sizeof_count_copies.rs
index 0077ed07fce..0bb22314cc0 100644
--- a/tests/ui/unsafe_sizeof_count_copies.rs
+++ b/tests/ui/unsafe_sizeof_count_copies.rs
@@ -14,6 +14,11 @@ fn main() {
     unsafe { copy_nonoverlapping::<u8>(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>()) };
     unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), size_of_val(&x[0])) };
 
+    unsafe { x.as_ptr().copy_to(y.as_mut_ptr(), size_of::<u8>()) };
+    unsafe { x.as_ptr().copy_to_nonoverlapping(y.as_mut_ptr(), size_of::<u8>()) };
+    unsafe { y.as_mut_ptr().copy_from(x.as_ptr(), size_of::<u8>()) };
+    unsafe { y.as_mut_ptr().copy_from_nonoverlapping(x.as_ptr(), size_of::<u8>()) };
+
     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>()) };
     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of_val(&x[0])) };
 
diff --git a/tests/ui/unsafe_sizeof_count_copies.stderr b/tests/ui/unsafe_sizeof_count_copies.stderr
index 6804df8cdfc..14ca04617c2 100644
--- a/tests/ui/unsafe_sizeof_count_copies.stderr
+++ b/tests/ui/unsafe_sizeof_count_copies.stderr
@@ -18,13 +18,45 @@ LL |     unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), size_of_val(&x
 error: unsafe memory copying using a byte count (Multiplied by size_of::<T>) instead of a count of T
   --> $DIR/unsafe_sizeof_count_copies.rs:17:14
    |
+LL |     unsafe { x.as_ptr().copy_to(y.as_mut_ptr(), size_of::<u8>()) };
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use a count of elements instead of a count of bytes for the count parameter, it already gets multiplied by the size of the pointed to type
+
+error: unsafe memory copying using a byte count (Multiplied by size_of::<T>) instead of a count of T
+  --> $DIR/unsafe_sizeof_count_copies.rs:18:14
+   |
+LL |     unsafe { x.as_ptr().copy_to_nonoverlapping(y.as_mut_ptr(), size_of::<u8>()) };
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use a count of elements instead of a count of bytes for the count parameter, it already gets multiplied by the size of the pointed to type
+
+error: unsafe memory copying using a byte count (Multiplied by size_of::<T>) instead of a count of T
+  --> $DIR/unsafe_sizeof_count_copies.rs:19:14
+   |
+LL |     unsafe { y.as_mut_ptr().copy_from(x.as_ptr(), size_of::<u8>()) };
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use a count of elements instead of a count of bytes for the count parameter, it already gets multiplied by the size of the pointed to type
+
+error: unsafe memory copying using a byte count (Multiplied by size_of::<T>) instead of a count of T
+  --> $DIR/unsafe_sizeof_count_copies.rs:20:14
+   |
+LL |     unsafe { y.as_mut_ptr().copy_from_nonoverlapping(x.as_ptr(), size_of::<u8>()) };
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use a count of elements instead of a count of bytes for the count parameter, it already gets multiplied by the size of the pointed to type
+
+error: unsafe memory copying using a byte count (Multiplied by size_of::<T>) instead of a count of T
+  --> $DIR/unsafe_sizeof_count_copies.rs:22:14
+   |
 LL |     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>()) };
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: use a count of elements instead of a count of bytes for the count parameter, it already gets multiplied by the size of the pointed to type
 
 error: unsafe memory copying using a byte count (Multiplied by size_of::<T>) instead of a count of T
-  --> $DIR/unsafe_sizeof_count_copies.rs:18:14
+  --> $DIR/unsafe_sizeof_count_copies.rs:23:14
    |
 LL |     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of_val(&x[0])) };
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -32,7 +64,7 @@ LL |     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of_val(&x[0])) };
    = help: use a count of elements instead of a count of bytes for the count parameter, it already gets multiplied by the size of the pointed to type
 
 error: unsafe memory copying using a byte count (Multiplied by size_of::<T>) instead of a count of T
-  --> $DIR/unsafe_sizeof_count_copies.rs:21:14
+  --> $DIR/unsafe_sizeof_count_copies.rs:26:14
    |
 LL |     unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>() * SIZE) };
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -40,7 +72,7 @@ LL |     unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>(
    = help: use a count of elements instead of a count of bytes for the count parameter, it already gets multiplied by the size of the pointed to type
 
 error: unsafe memory copying using a byte count (Multiplied by size_of::<T>) instead of a count of T
-  --> $DIR/unsafe_sizeof_count_copies.rs:22:14
+  --> $DIR/unsafe_sizeof_count_copies.rs:27:14
    |
 LL |     unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), size_of_val(&x[0]) * SIZE) };
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -48,7 +80,7 @@ LL |     unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), size_of_val(&x
    = help: use a count of elements instead of a count of bytes for the count parameter, it already gets multiplied by the size of the pointed to type
 
 error: unsafe memory copying using a byte count (Multiplied by size_of::<T>) instead of a count of T
-  --> $DIR/unsafe_sizeof_count_copies.rs:24:14
+  --> $DIR/unsafe_sizeof_count_copies.rs:29:14
    |
 LL |     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>() * SIZE) };
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -56,7 +88,7 @@ LL |     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>() * SIZE) };
    = help: use a count of elements instead of a count of bytes for the count parameter, it already gets multiplied by the size of the pointed to type
 
 error: unsafe memory copying using a byte count (Multiplied by size_of::<T>) instead of a count of T
-  --> $DIR/unsafe_sizeof_count_copies.rs:25:14
+  --> $DIR/unsafe_sizeof_count_copies.rs:30:14
    |
 LL |     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of_val(&x[0]) * SIZE) };
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -64,7 +96,7 @@ LL |     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of_val(&x[0]) * SIZE) };
    = help: use a count of elements instead of a count of bytes for the count parameter, it already gets multiplied by the size of the pointed to type
 
 error: unsafe memory copying using a byte count (Multiplied by size_of::<T>) instead of a count of T
-  --> $DIR/unsafe_sizeof_count_copies.rs:28:14
+  --> $DIR/unsafe_sizeof_count_copies.rs:33:14
    |
 LL |     unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>() * HALF_SIZE * 2) };
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -72,7 +104,7 @@ LL |     unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>(
    = help: use a count of elements instead of a count of bytes for the count parameter, it already gets multiplied by the size of the pointed to type
 
 error: unsafe memory copying using a byte count (Multiplied by size_of::<T>) instead of a count of T
-  --> $DIR/unsafe_sizeof_count_copies.rs:29:14
+  --> $DIR/unsafe_sizeof_count_copies.rs:34:14
    |
 LL |     unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), HALF_SIZE * size_of_val(&x[0]) * 2) };
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -80,7 +112,7 @@ LL |     unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), HALF_SIZE * si
    = help: use a count of elements instead of a count of bytes for the count parameter, it already gets multiplied by the size of the pointed to type
 
 error: unsafe memory copying using a byte count (Multiplied by size_of::<T>) instead of a count of T
-  --> $DIR/unsafe_sizeof_count_copies.rs:31:14
+  --> $DIR/unsafe_sizeof_count_copies.rs:36:14
    |
 LL |     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>() * SIZE * HALF_SIZE) };
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -88,7 +120,7 @@ LL |     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>() * SIZE * HALF
    = help: use a count of elements instead of a count of bytes for the count parameter, it already gets multiplied by the size of the pointed to type
 
 error: unsafe memory copying using a byte count (Multiplied by size_of::<T>) instead of a count of T
-  --> $DIR/unsafe_sizeof_count_copies.rs:32:14
+  --> $DIR/unsafe_sizeof_count_copies.rs:37:14
    |
 LL |     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of_val(&x[0]) * HALF_SIZE * 2) };
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -96,7 +128,7 @@ LL |     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of_val(&x[0]) * HALF_SIZ
    = help: use a count of elements instead of a count of bytes for the count parameter, it already gets multiplied by the size of the pointed to type
 
 error: unsafe memory copying using a byte count (Multiplied by size_of::<T>) instead of a count of T
-  --> $DIR/unsafe_sizeof_count_copies.rs:35:14
+  --> $DIR/unsafe_sizeof_count_copies.rs:40:14
    |
 LL |     unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>() * DOUBLE_SIZE / 2) };
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -104,7 +136,7 @@ LL |     unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>(
    = help: use a count of elements instead of a count of bytes for the count parameter, it already gets multiplied by the size of the pointed to type
 
 error: unsafe memory copying using a byte count (Multiplied by size_of::<T>) instead of a count of T
-  --> $DIR/unsafe_sizeof_count_copies.rs:36:14
+  --> $DIR/unsafe_sizeof_count_copies.rs:41:14
    |
 LL |     unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), DOUBLE_SIZE / 2 * size_of_val(&x[0])) };
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -112,7 +144,7 @@ LL |     unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), DOUBLE_SIZE /
    = help: use a count of elements instead of a count of bytes for the count parameter, it already gets multiplied by the size of the pointed to type
 
 error: unsafe memory copying using a byte count (Multiplied by size_of::<T>) instead of a count of T
-  --> $DIR/unsafe_sizeof_count_copies.rs:38:14
+  --> $DIR/unsafe_sizeof_count_copies.rs:43:14
    |
 LL |     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), DOUBLE_SIZE * size_of::<u8>() / 2) };
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -120,12 +152,12 @@ LL |     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), DOUBLE_SIZE * size_of::<u8>()
    = help: use a count of elements instead of a count of bytes for the count parameter, it already gets multiplied by the size of the pointed to type
 
 error: unsafe memory copying using a byte count (Multiplied by size_of::<T>) instead of a count of T
-  --> $DIR/unsafe_sizeof_count_copies.rs:39:14
+  --> $DIR/unsafe_sizeof_count_copies.rs:44:14
    |
 LL |     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of_val(&x[0]) * DOUBLE_SIZE / 2) };
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: use a count of elements instead of a count of bytes for the count parameter, it already gets multiplied by the size of the pointed to type
 
-error: aborting due to 16 previous errors
+error: aborting due to 20 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 1b80990fe01646868f85245f608203e23f64184a Mon Sep 17 00:00:00 2001
From: unknown <abramlujan@gmail.com>
Date: Sun, 29 Nov 2020 14:23:59 -0300
Subject: Make the unsafe_sizeof_count_copies lint work with more functions
 Specifically:  - find std::ptr::write_bytes  - find
 std::ptr::swap_nonoverlapping  - find std::ptr::slice_from_raw_parts  - find
 std::ptr::slice_from_raw_parts_mut  - pointer_primitive::write_bytes

---
 clippy_lints/src/unsafe_sizeof_count_copies.rs |  42 ++++++---
 clippy_lints/src/utils/paths.rs                |   4 +
 tests/ui/unsafe_sizeof_count_copies.rs         |  12 ++-
 tests/ui/unsafe_sizeof_count_copies.stderr     | 122 ++++++++++++++++---------
 4 files changed, 126 insertions(+), 54 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unsafe_sizeof_count_copies.rs b/clippy_lints/src/unsafe_sizeof_count_copies.rs
index 5df7d72564e..8a4538091e7 100644
--- a/clippy_lints/src/unsafe_sizeof_count_copies.rs
+++ b/clippy_lints/src/unsafe_sizeof_count_copies.rs
@@ -41,8 +41,8 @@ declare_clippy_lint! {
 declare_lint_pass!(UnsafeSizeofCountCopies => [UNSAFE_SIZEOF_COUNT_COPIES]);
 
 fn get_size_of_ty(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<Ty<'tcx>> {
-    match &expr.kind {
-        ExprKind::Call(ref count_func, _func_args) => {
+    match expr.kind {
+        ExprKind::Call(count_func, _func_args) => {
             if_chain! {
                 if let ExprKind::Path(ref count_func_qpath) = count_func.kind;
                 if let Some(def_id) = cx.qpath_res(count_func_qpath, count_func.hir_id).opt_def_id();
@@ -56,7 +56,7 @@ fn get_size_of_ty(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<Ty<'tc
             }
         },
         ExprKind::Binary(op, left, right) if BinOpKind::Mul == op.node || BinOpKind::Div == op.node => {
-            get_size_of_ty(cx, &*left).or_else(|| get_size_of_ty(cx, &*right))
+            get_size_of_ty(cx, left).or_else(|| get_size_of_ty(cx, right))
         },
         _ => None,
     }
@@ -64,13 +64,16 @@ fn get_size_of_ty(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<Ty<'tc
 
 fn get_pointee_ty_and_count_expr(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<(Ty<'tcx>, &'tcx Expr<'tcx>)> {
     if_chain! {
-        // Find calls to ptr::copy and copy_nonoverlapping
-        if let ExprKind::Call(ref func, ref args) = expr.kind;
-        if let [_src, _dest, count] = &**args;
+        // Find calls to ptr::{copy, copy_nonoverlapping}
+        // and ptr::{swap_nonoverlapping, write_bytes},
+        if let ExprKind::Call(func, args) = expr.kind;
+        if let [_, _, count] = args;
         if let ExprKind::Path(ref func_qpath) = func.kind;
         if let Some(def_id) = cx.qpath_res(func_qpath, func.hir_id).opt_def_id();
         if match_def_path(cx, def_id, &paths::COPY_NONOVERLAPPING)
-            || match_def_path(cx, def_id, &paths::COPY);
+            || match_def_path(cx, def_id, &paths::COPY)
+            || match_def_path(cx, def_id, &paths::WRITE_BYTES)
+            || match_def_path(cx, def_id, &paths::PTR_SWAP_NONOVERLAPPING);
 
         // Get the pointee type
         if let Some(pointee_ty) = cx.typeck_results().node_substs(func.hir_id).types().next();
@@ -79,11 +82,11 @@ fn get_pointee_ty_and_count_expr(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -
         }
     };
     if_chain! {
-        // Find calls to copy_{from,to}{,_nonoverlapping}
-        if let ExprKind::MethodCall(ref method_path, _, ref args, _) = expr.kind;
-        if let [ptr_self, _, count] = &**args;
+        // Find calls to copy_{from,to}{,_nonoverlapping} and write_bytes methods
+        if let ExprKind::MethodCall(method_path, _, args, _) = expr.kind;
+        if let [ptr_self, _, count] = args;
         let method_ident = method_path.ident.as_str();
-        if method_ident== "copy_to" || method_ident == "copy_from"
+        if method_ident == "write_bytes" || method_ident == "copy_to" || method_ident == "copy_from"
             || method_ident == "copy_to_nonoverlapping" || method_ident == "copy_from_nonoverlapping";
 
         // Get the pointee type
@@ -93,6 +96,21 @@ fn get_pointee_ty_and_count_expr(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -
             return Some((pointee_ty, count));
         }
     };
+    if_chain! {
+        // Find calls to ptr::copy and copy_nonoverlapping
+        if let ExprKind::Call(func, args) = expr.kind;
+        if let [_data, count] = args;
+        if let ExprKind::Path(ref func_qpath) = func.kind;
+        if let Some(def_id) = cx.qpath_res(func_qpath, func.hir_id).opt_def_id();
+        if match_def_path(cx, def_id, &paths::PTR_SLICE_FROM_RAW_PARTS)
+            || match_def_path(cx, def_id, &paths::PTR_SLICE_FROM_RAW_PARTS_MUT);
+
+        // Get the pointee type
+        if let Some(pointee_ty) = cx.typeck_results().node_substs(func.hir_id).types().next();
+        then {
+            return Some((pointee_ty, count));
+        }
+    };
     None
 }
 
@@ -102,7 +120,7 @@ impl<'tcx> LateLintPass<'tcx> for UnsafeSizeofCountCopies {
             for the count parameter, it already gets multiplied by the size of the pointed to type";
 
         const LINT_MSG: &str = "unsafe memory copying using a byte count \
-            (Multiplied by size_of::<T>) instead of a count of T";
+            (multiplied by size_of/size_of_val::<T>) instead of a count of T";
 
         if_chain! {
             // Find calls to unsafe copy functions and get
diff --git a/clippy_lints/src/utils/paths.rs b/clippy_lints/src/utils/paths.rs
index fe763d4bfbb..87c020a99db 100644
--- a/clippy_lints/src/utils/paths.rs
+++ b/clippy_lints/src/utils/paths.rs
@@ -104,6 +104,9 @@ pub const POLL_READY: [&str; 5] = ["core", "task", "poll", "Poll", "Ready"];
 pub const PTR_EQ: [&str; 3] = ["core", "ptr", "eq"];
 pub const PTR_NULL: [&str; 3] = ["core", "ptr", "null"];
 pub const PTR_NULL_MUT: [&str; 3] = ["core", "ptr", "null_mut"];
+pub const PTR_SLICE_FROM_RAW_PARTS: [&str; 3] = ["core", "ptr", "slice_from_raw_parts"];
+pub const PTR_SLICE_FROM_RAW_PARTS_MUT: [&str; 3] = ["core", "ptr", "slice_from_raw_parts_mut"];
+pub const PTR_SWAP_NONOVERLAPPING: [&str; 3] = ["core", "ptr", "swap_nonoverlapping"];
 pub const PUSH_STR: [&str; 4] = ["alloc", "string", "String", "push_str"];
 pub const RANGE_ARGUMENT_TRAIT: [&str; 3] = ["core", "ops", "RangeBounds"];
 pub const RC: [&str; 3] = ["alloc", "rc", "Rc"];
@@ -158,3 +161,4 @@ pub const VEC_NEW: [&str; 4] = ["alloc", "vec", "Vec", "new"];
 pub const VEC_RESIZE: [&str; 4] = ["alloc", "vec", "Vec", "resize"];
 pub const WEAK_ARC: [&str; 3] = ["alloc", "sync", "Weak"];
 pub const WEAK_RC: [&str; 3] = ["alloc", "rc", "Weak"];
+pub const WRITE_BYTES: [&str; 3] = ["core", "intrinsics", "write_bytes"];
diff --git a/tests/ui/unsafe_sizeof_count_copies.rs b/tests/ui/unsafe_sizeof_count_copies.rs
index 0bb22314cc0..6aed8c31f7e 100644
--- a/tests/ui/unsafe_sizeof_count_copies.rs
+++ b/tests/ui/unsafe_sizeof_count_copies.rs
@@ -1,7 +1,9 @@
 #![warn(clippy::unsafe_sizeof_count_copies)]
 
 use std::mem::{size_of, size_of_val};
-use std::ptr::{copy, copy_nonoverlapping};
+use std::ptr::{
+    copy, copy_nonoverlapping, slice_from_raw_parts, slice_from_raw_parts_mut, swap_nonoverlapping, write_bytes,
+};
 
 fn main() {
     const SIZE: usize = 128;
@@ -22,6 +24,14 @@ fn main() {
     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>()) };
     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of_val(&x[0])) };
 
+    unsafe { y.as_mut_ptr().write_bytes(0u8, size_of::<u8>() * SIZE) };
+    unsafe { write_bytes(y.as_mut_ptr(), 0u8, size_of::<u8>() * SIZE) };
+
+    unsafe { swap_nonoverlapping(y.as_mut_ptr(), x.as_mut_ptr(), size_of::<u8>() * SIZE) };
+
+    unsafe { slice_from_raw_parts_mut(y.as_mut_ptr(), size_of::<u8>() * SIZE) };
+    unsafe { slice_from_raw_parts(y.as_ptr(), size_of::<u8>() * SIZE) };
+
     // Count expression involving multiplication of size_of (Should trigger the lint)
     unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>() * SIZE) };
     unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), size_of_val(&x[0]) * SIZE) };
diff --git a/tests/ui/unsafe_sizeof_count_copies.stderr b/tests/ui/unsafe_sizeof_count_copies.stderr
index 14ca04617c2..6f491bc4e4a 100644
--- a/tests/ui/unsafe_sizeof_count_copies.stderr
+++ b/tests/ui/unsafe_sizeof_count_copies.stderr
@@ -1,5 +1,5 @@
-error: unsafe memory copying using a byte count (Multiplied by size_of::<T>) instead of a count of T
-  --> $DIR/unsafe_sizeof_count_copies.rs:14:14
+error: unsafe memory copying using a byte count (multiplied by size_of/size_of_val::<T>) instead of a count of T
+  --> $DIR/unsafe_sizeof_count_copies.rs:16:14
    |
 LL |     unsafe { copy_nonoverlapping::<u8>(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>()) };
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -7,157 +7,197 @@ LL |     unsafe { copy_nonoverlapping::<u8>(x.as_ptr(), y.as_mut_ptr(), size_of:
    = note: `-D clippy::unsafe-sizeof-count-copies` implied by `-D warnings`
    = help: use a count of elements instead of a count of bytes for the count parameter, it already gets multiplied by the size of the pointed to type
 
-error: unsafe memory copying using a byte count (Multiplied by size_of::<T>) instead of a count of T
-  --> $DIR/unsafe_sizeof_count_copies.rs:15:14
+error: unsafe memory copying using a byte count (multiplied by size_of/size_of_val::<T>) instead of a count of T
+  --> $DIR/unsafe_sizeof_count_copies.rs:17:14
    |
 LL |     unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), size_of_val(&x[0])) };
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: use a count of elements instead of a count of bytes for the count parameter, it already gets multiplied by the size of the pointed to type
 
-error: unsafe memory copying using a byte count (Multiplied by size_of::<T>) instead of a count of T
-  --> $DIR/unsafe_sizeof_count_copies.rs:17:14
+error: unsafe memory copying using a byte count (multiplied by size_of/size_of_val::<T>) instead of a count of T
+  --> $DIR/unsafe_sizeof_count_copies.rs:19:14
    |
 LL |     unsafe { x.as_ptr().copy_to(y.as_mut_ptr(), size_of::<u8>()) };
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: use a count of elements instead of a count of bytes for the count parameter, it already gets multiplied by the size of the pointed to type
 
-error: unsafe memory copying using a byte count (Multiplied by size_of::<T>) instead of a count of T
-  --> $DIR/unsafe_sizeof_count_copies.rs:18:14
+error: unsafe memory copying using a byte count (multiplied by size_of/size_of_val::<T>) instead of a count of T
+  --> $DIR/unsafe_sizeof_count_copies.rs:20:14
    |
 LL |     unsafe { x.as_ptr().copy_to_nonoverlapping(y.as_mut_ptr(), size_of::<u8>()) };
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: use a count of elements instead of a count of bytes for the count parameter, it already gets multiplied by the size of the pointed to type
 
-error: unsafe memory copying using a byte count (Multiplied by size_of::<T>) instead of a count of T
-  --> $DIR/unsafe_sizeof_count_copies.rs:19:14
+error: unsafe memory copying using a byte count (multiplied by size_of/size_of_val::<T>) instead of a count of T
+  --> $DIR/unsafe_sizeof_count_copies.rs:21:14
    |
 LL |     unsafe { y.as_mut_ptr().copy_from(x.as_ptr(), size_of::<u8>()) };
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: use a count of elements instead of a count of bytes for the count parameter, it already gets multiplied by the size of the pointed to type
 
-error: unsafe memory copying using a byte count (Multiplied by size_of::<T>) instead of a count of T
-  --> $DIR/unsafe_sizeof_count_copies.rs:20:14
+error: unsafe memory copying using a byte count (multiplied by size_of/size_of_val::<T>) instead of a count of T
+  --> $DIR/unsafe_sizeof_count_copies.rs:22:14
    |
 LL |     unsafe { y.as_mut_ptr().copy_from_nonoverlapping(x.as_ptr(), size_of::<u8>()) };
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: use a count of elements instead of a count of bytes for the count parameter, it already gets multiplied by the size of the pointed to type
 
-error: unsafe memory copying using a byte count (Multiplied by size_of::<T>) instead of a count of T
-  --> $DIR/unsafe_sizeof_count_copies.rs:22:14
+error: unsafe memory copying using a byte count (multiplied by size_of/size_of_val::<T>) instead of a count of T
+  --> $DIR/unsafe_sizeof_count_copies.rs:24:14
    |
 LL |     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>()) };
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: use a count of elements instead of a count of bytes for the count parameter, it already gets multiplied by the size of the pointed to type
 
-error: unsafe memory copying using a byte count (Multiplied by size_of::<T>) instead of a count of T
-  --> $DIR/unsafe_sizeof_count_copies.rs:23:14
+error: unsafe memory copying using a byte count (multiplied by size_of/size_of_val::<T>) instead of a count of T
+  --> $DIR/unsafe_sizeof_count_copies.rs:25:14
    |
 LL |     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of_val(&x[0])) };
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: use a count of elements instead of a count of bytes for the count parameter, it already gets multiplied by the size of the pointed to type
 
-error: unsafe memory copying using a byte count (Multiplied by size_of::<T>) instead of a count of T
-  --> $DIR/unsafe_sizeof_count_copies.rs:26:14
+error: unsafe memory copying using a byte count (multiplied by size_of/size_of_val::<T>) instead of a count of T
+  --> $DIR/unsafe_sizeof_count_copies.rs:27:14
+   |
+LL |     unsafe { y.as_mut_ptr().write_bytes(0u8, size_of::<u8>() * SIZE) };
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use a count of elements instead of a count of bytes for the count parameter, it already gets multiplied by the size of the pointed to type
+
+error: unsafe memory copying using a byte count (multiplied by size_of/size_of_val::<T>) instead of a count of T
+  --> $DIR/unsafe_sizeof_count_copies.rs:28:14
+   |
+LL |     unsafe { write_bytes(y.as_mut_ptr(), 0u8, size_of::<u8>() * SIZE) };
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use a count of elements instead of a count of bytes for the count parameter, it already gets multiplied by the size of the pointed to type
+
+error: unsafe memory copying using a byte count (multiplied by size_of/size_of_val::<T>) instead of a count of T
+  --> $DIR/unsafe_sizeof_count_copies.rs:30:14
+   |
+LL |     unsafe { swap_nonoverlapping(y.as_mut_ptr(), x.as_mut_ptr(), size_of::<u8>() * SIZE) };
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use a count of elements instead of a count of bytes for the count parameter, it already gets multiplied by the size of the pointed to type
+
+error: unsafe memory copying using a byte count (multiplied by size_of/size_of_val::<T>) instead of a count of T
+  --> $DIR/unsafe_sizeof_count_copies.rs:32:14
+   |
+LL |     unsafe { slice_from_raw_parts_mut(y.as_mut_ptr(), size_of::<u8>() * SIZE) };
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use a count of elements instead of a count of bytes for the count parameter, it already gets multiplied by the size of the pointed to type
+
+error: unsafe memory copying using a byte count (multiplied by size_of/size_of_val::<T>) instead of a count of T
+  --> $DIR/unsafe_sizeof_count_copies.rs:33:14
+   |
+LL |     unsafe { slice_from_raw_parts(y.as_ptr(), size_of::<u8>() * SIZE) };
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use a count of elements instead of a count of bytes for the count parameter, it already gets multiplied by the size of the pointed to type
+
+error: unsafe memory copying using a byte count (multiplied by size_of/size_of_val::<T>) instead of a count of T
+  --> $DIR/unsafe_sizeof_count_copies.rs:36:14
    |
 LL |     unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>() * SIZE) };
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: use a count of elements instead of a count of bytes for the count parameter, it already gets multiplied by the size of the pointed to type
 
-error: unsafe memory copying using a byte count (Multiplied by size_of::<T>) instead of a count of T
-  --> $DIR/unsafe_sizeof_count_copies.rs:27:14
+error: unsafe memory copying using a byte count (multiplied by size_of/size_of_val::<T>) instead of a count of T
+  --> $DIR/unsafe_sizeof_count_copies.rs:37:14
    |
 LL |     unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), size_of_val(&x[0]) * SIZE) };
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: use a count of elements instead of a count of bytes for the count parameter, it already gets multiplied by the size of the pointed to type
 
-error: unsafe memory copying using a byte count (Multiplied by size_of::<T>) instead of a count of T
-  --> $DIR/unsafe_sizeof_count_copies.rs:29:14
+error: unsafe memory copying using a byte count (multiplied by size_of/size_of_val::<T>) instead of a count of T
+  --> $DIR/unsafe_sizeof_count_copies.rs:39:14
    |
 LL |     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>() * SIZE) };
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: use a count of elements instead of a count of bytes for the count parameter, it already gets multiplied by the size of the pointed to type
 
-error: unsafe memory copying using a byte count (Multiplied by size_of::<T>) instead of a count of T
-  --> $DIR/unsafe_sizeof_count_copies.rs:30:14
+error: unsafe memory copying using a byte count (multiplied by size_of/size_of_val::<T>) instead of a count of T
+  --> $DIR/unsafe_sizeof_count_copies.rs:40:14
    |
 LL |     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of_val(&x[0]) * SIZE) };
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: use a count of elements instead of a count of bytes for the count parameter, it already gets multiplied by the size of the pointed to type
 
-error: unsafe memory copying using a byte count (Multiplied by size_of::<T>) instead of a count of T
-  --> $DIR/unsafe_sizeof_count_copies.rs:33:14
+error: unsafe memory copying using a byte count (multiplied by size_of/size_of_val::<T>) instead of a count of T
+  --> $DIR/unsafe_sizeof_count_copies.rs:43:14
    |
 LL |     unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>() * HALF_SIZE * 2) };
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: use a count of elements instead of a count of bytes for the count parameter, it already gets multiplied by the size of the pointed to type
 
-error: unsafe memory copying using a byte count (Multiplied by size_of::<T>) instead of a count of T
-  --> $DIR/unsafe_sizeof_count_copies.rs:34:14
+error: unsafe memory copying using a byte count (multiplied by size_of/size_of_val::<T>) instead of a count of T
+  --> $DIR/unsafe_sizeof_count_copies.rs:44:14
    |
 LL |     unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), HALF_SIZE * size_of_val(&x[0]) * 2) };
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: use a count of elements instead of a count of bytes for the count parameter, it already gets multiplied by the size of the pointed to type
 
-error: unsafe memory copying using a byte count (Multiplied by size_of::<T>) instead of a count of T
-  --> $DIR/unsafe_sizeof_count_copies.rs:36:14
+error: unsafe memory copying using a byte count (multiplied by size_of/size_of_val::<T>) instead of a count of T
+  --> $DIR/unsafe_sizeof_count_copies.rs:46:14
    |
 LL |     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>() * SIZE * HALF_SIZE) };
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: use a count of elements instead of a count of bytes for the count parameter, it already gets multiplied by the size of the pointed to type
 
-error: unsafe memory copying using a byte count (Multiplied by size_of::<T>) instead of a count of T
-  --> $DIR/unsafe_sizeof_count_copies.rs:37:14
+error: unsafe memory copying using a byte count (multiplied by size_of/size_of_val::<T>) instead of a count of T
+  --> $DIR/unsafe_sizeof_count_copies.rs:47:14
    |
 LL |     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of_val(&x[0]) * HALF_SIZE * 2) };
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: use a count of elements instead of a count of bytes for the count parameter, it already gets multiplied by the size of the pointed to type
 
-error: unsafe memory copying using a byte count (Multiplied by size_of::<T>) instead of a count of T
-  --> $DIR/unsafe_sizeof_count_copies.rs:40:14
+error: unsafe memory copying using a byte count (multiplied by size_of/size_of_val::<T>) instead of a count of T
+  --> $DIR/unsafe_sizeof_count_copies.rs:50:14
    |
 LL |     unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>() * DOUBLE_SIZE / 2) };
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: use a count of elements instead of a count of bytes for the count parameter, it already gets multiplied by the size of the pointed to type
 
-error: unsafe memory copying using a byte count (Multiplied by size_of::<T>) instead of a count of T
-  --> $DIR/unsafe_sizeof_count_copies.rs:41:14
+error: unsafe memory copying using a byte count (multiplied by size_of/size_of_val::<T>) instead of a count of T
+  --> $DIR/unsafe_sizeof_count_copies.rs:51:14
    |
 LL |     unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), DOUBLE_SIZE / 2 * size_of_val(&x[0])) };
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: use a count of elements instead of a count of bytes for the count parameter, it already gets multiplied by the size of the pointed to type
 
-error: unsafe memory copying using a byte count (Multiplied by size_of::<T>) instead of a count of T
-  --> $DIR/unsafe_sizeof_count_copies.rs:43:14
+error: unsafe memory copying using a byte count (multiplied by size_of/size_of_val::<T>) instead of a count of T
+  --> $DIR/unsafe_sizeof_count_copies.rs:53:14
    |
 LL |     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), DOUBLE_SIZE * size_of::<u8>() / 2) };
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: use a count of elements instead of a count of bytes for the count parameter, it already gets multiplied by the size of the pointed to type
 
-error: unsafe memory copying using a byte count (Multiplied by size_of::<T>) instead of a count of T
-  --> $DIR/unsafe_sizeof_count_copies.rs:44:14
+error: unsafe memory copying using a byte count (multiplied by size_of/size_of_val::<T>) instead of a count of T
+  --> $DIR/unsafe_sizeof_count_copies.rs:54:14
    |
 LL |     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of_val(&x[0]) * DOUBLE_SIZE / 2) };
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: use a count of elements instead of a count of bytes for the count parameter, it already gets multiplied by the size of the pointed to type
 
-error: aborting due to 20 previous errors
+error: aborting due to 25 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From af9685bb1e7e27a7b21d9939a42c1e9dce8c4df5 Mon Sep 17 00:00:00 2001
From: unknown <abramlujan@gmail.com>
Date: Thu, 3 Dec 2020 20:55:38 -0300
Subject: Rename unsafe_sizeof_count_copies to size_of_in_element_count

Also fix review comments:
 - Use const arrays and iterate them for the method/function names
 - merge 2 if_chain's into one using a rest pattern
 - remove unnecessary unsafe block in test

And make the lint only point to the count expression instead of the entire function call
---
 CHANGELOG.md                                   |   2 +-
 clippy_lints/src/lib.rs                        |  10 +-
 clippy_lints/src/size_of_in_element_count.rs   | 138 +++++++++++++++++++++++
 clippy_lints/src/unsafe_sizeof_count_copies.rs | 146 -------------------------
 tests/ui/size_of_in_element_count.rs           |  50 +++++++++
 tests/ui/size_of_in_element_count.stderr       | 131 ++++++++++++++++++++++
 tests/ui/unsafe_sizeof_count_copies.rs         |  49 ---------
 tests/ui/unsafe_sizeof_count_copies.stderr     | 131 ----------------------
 8 files changed, 325 insertions(+), 332 deletions(-)
 create mode 100644 clippy_lints/src/size_of_in_element_count.rs
 delete mode 100644 clippy_lints/src/unsafe_sizeof_count_copies.rs
 create mode 100644 tests/ui/size_of_in_element_count.rs
 create mode 100644 tests/ui/size_of_in_element_count.stderr
 delete mode 100644 tests/ui/unsafe_sizeof_count_copies.rs
 delete mode 100644 tests/ui/unsafe_sizeof_count_copies.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index e0f3b82ad25..c7e02aaf4e1 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2057,6 +2057,7 @@ Released 2018-09-13
 [`single_element_loop`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_element_loop
 [`single_match`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_match
 [`single_match_else`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_match_else
+[`size_of_in_element_count`]: https://rust-lang.github.io/rust-clippy/master/index.html#size_of_in_element_count
 [`skip_while_next`]: https://rust-lang.github.io/rust-clippy/master/index.html#skip_while_next
 [`slow_vector_initialization`]: https://rust-lang.github.io/rust-clippy/master/index.html#slow_vector_initialization
 [`stable_sort_primitive`]: https://rust-lang.github.io/rust-clippy/master/index.html#stable_sort_primitive
@@ -2124,7 +2125,6 @@ Released 2018-09-13
 [`unreadable_literal`]: https://rust-lang.github.io/rust-clippy/master/index.html#unreadable_literal
 [`unsafe_derive_deserialize`]: https://rust-lang.github.io/rust-clippy/master/index.html#unsafe_derive_deserialize
 [`unsafe_removed_from_name`]: https://rust-lang.github.io/rust-clippy/master/index.html#unsafe_removed_from_name
-[`unsafe_sizeof_count_copies`]: https://rust-lang.github.io/rust-clippy/master/index.html#unsafe_sizeof_count_copies
 [`unsafe_vector_initialization`]: https://rust-lang.github.io/rust-clippy/master/index.html#unsafe_vector_initialization
 [`unseparated_literal_suffix`]: https://rust-lang.github.io/rust-clippy/master/index.html#unseparated_literal_suffix
 [`unsound_collection_transmute`]: https://rust-lang.github.io/rust-clippy/master/index.html#unsound_collection_transmute
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 1bce0130b40..06961064a4b 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -306,6 +306,7 @@ mod self_assignment;
 mod serde_api;
 mod shadow;
 mod single_component_path_imports;
+mod size_of_in_element_count;
 mod slow_vector_initialization;
 mod stable_sort_primitive;
 mod strings;
@@ -329,7 +330,6 @@ mod unnecessary_sort_by;
 mod unnecessary_wraps;
 mod unnested_or_patterns;
 mod unsafe_removed_from_name;
-mod unsafe_sizeof_count_copies;
 mod unused_io_amount;
 mod unused_self;
 mod unused_unit;
@@ -917,7 +917,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &unnecessary_wraps::UNNECESSARY_WRAPS,
         &unnested_or_patterns::UNNESTED_OR_PATTERNS,
         &unsafe_removed_from_name::UNSAFE_REMOVED_FROM_NAME,
-        &unsafe_sizeof_count_copies::UNSAFE_SIZEOF_COUNT_COPIES,
+        &size_of_in_element_count::SIZE_OF_IN_ELEMENT_COUNT,
         &unused_io_amount::UNUSED_IO_AMOUNT,
         &unused_self::UNUSED_SELF,
         &unused_unit::UNUSED_UNIT,
@@ -1000,7 +1000,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(move || box matches::Matches::new(msrv));
     store.register_early_pass(move || box manual_non_exhaustive::ManualNonExhaustive::new(msrv));
     store.register_late_pass(move || box manual_strip::ManualStrip::new(msrv));
-    store.register_late_pass(|| box unsafe_sizeof_count_copies::UnsafeSizeofCountCopies);
+    store.register_late_pass(|| box size_of_in_element_count::SizeOfInElementCount);
     store.register_late_pass(|| box map_clone::MapClone);
     store.register_late_pass(|| box map_err_ignore::MapErrIgnore);
     store.register_late_pass(|| box shadow::Shadow);
@@ -1608,7 +1608,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&unnecessary_sort_by::UNNECESSARY_SORT_BY),
         LintId::of(&unnecessary_wraps::UNNECESSARY_WRAPS),
         LintId::of(&unsafe_removed_from_name::UNSAFE_REMOVED_FROM_NAME),
-        LintId::of(&unsafe_sizeof_count_copies::UNSAFE_SIZEOF_COUNT_COPIES),
+        LintId::of(&size_of_in_element_count::SIZE_OF_IN_ELEMENT_COUNT),
         LintId::of(&unused_io_amount::UNUSED_IO_AMOUNT),
         LintId::of(&unused_unit::UNUSED_UNIT),
         LintId::of(&unwrap::PANICKING_UNWRAP),
@@ -1887,7 +1887,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&unit_return_expecting_ord::UNIT_RETURN_EXPECTING_ORD),
         LintId::of(&unnamed_address::FN_ADDRESS_COMPARISONS),
         LintId::of(&unnamed_address::VTABLE_ADDRESS_COMPARISONS),
-        LintId::of(&unsafe_sizeof_count_copies::UNSAFE_SIZEOF_COUNT_COPIES),
+        LintId::of(&size_of_in_element_count::SIZE_OF_IN_ELEMENT_COUNT),
         LintId::of(&unused_io_amount::UNUSED_IO_AMOUNT),
         LintId::of(&unwrap::PANICKING_UNWRAP),
         LintId::of(&vec_resize_to_zero::VEC_RESIZE_TO_ZERO),
diff --git a/clippy_lints/src/size_of_in_element_count.rs b/clippy_lints/src/size_of_in_element_count.rs
new file mode 100644
index 00000000000..9701e793700
--- /dev/null
+++ b/clippy_lints/src/size_of_in_element_count.rs
@@ -0,0 +1,138 @@
+//! Lint on use of `size_of` or `size_of_val` of T in an expression
+//! expecting a count of T
+
+use crate::utils::{match_def_path, paths, span_lint_and_help};
+use if_chain::if_chain;
+use rustc_hir::BinOpKind;
+use rustc_hir::{Expr, ExprKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::{self, Ty, TyS, TypeAndMut};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// **What it does:** Detects expressions where
+    /// size_of::<T> or size_of_val::<T> is used as a
+    /// count of elements of type T
+    ///
+    /// **Why is this bad?** These functions expect a count
+    /// of T and not a number of bytes
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// ```rust,no_run
+    /// # use std::ptr::copy_nonoverlapping;
+    /// # use std::mem::size_of;
+    ///
+    /// const SIZE: usize = 128;
+    /// let x = [2u8; SIZE];
+    /// let mut y = [2u8; SIZE];
+    /// unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>() * SIZE) };
+    /// ```
+    pub SIZE_OF_IN_ELEMENT_COUNT,
+    correctness,
+    "using size_of::<T> or size_of_val::<T> where a count of elements of T is expected"
+}
+
+declare_lint_pass!(SizeOfInElementCount => [SIZE_OF_IN_ELEMENT_COUNT]);
+
+fn get_size_of_ty(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<Ty<'tcx>> {
+    match expr.kind {
+        ExprKind::Call(count_func, _func_args) => {
+            if_chain! {
+                if let ExprKind::Path(ref count_func_qpath) = count_func.kind;
+                if let Some(def_id) = cx.qpath_res(count_func_qpath, count_func.hir_id).opt_def_id();
+                if match_def_path(cx, def_id, &paths::MEM_SIZE_OF)
+                    || match_def_path(cx, def_id, &paths::MEM_SIZE_OF_VAL);
+                then {
+                    cx.typeck_results().node_substs(count_func.hir_id).types().next()
+                } else {
+                    None
+                }
+            }
+        },
+        ExprKind::Binary(op, left, right) if BinOpKind::Mul == op.node || BinOpKind::Div == op.node => {
+            get_size_of_ty(cx, left).or_else(|| get_size_of_ty(cx, right))
+        },
+        _ => None,
+    }
+}
+
+const FUNCTIONS: [[&str; 3]; 6] = [
+    paths::COPY_NONOVERLAPPING,
+    paths::COPY,
+    paths::WRITE_BYTES,
+    paths::PTR_SWAP_NONOVERLAPPING,
+    paths::PTR_SLICE_FROM_RAW_PARTS,
+    paths::PTR_SLICE_FROM_RAW_PARTS_MUT,
+    ];
+const METHODS: [&str; 5] = [
+    "write_bytes",
+    "copy_to",
+    "copy_from",
+    "copy_to_nonoverlapping",
+    "copy_from_nonoverlapping",
+    ];
+fn get_pointee_ty_and_count_expr(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<(Ty<'tcx>, &'tcx Expr<'tcx>)> {
+    if_chain! {
+        // Find calls to ptr::{copy, copy_nonoverlapping}
+        // and ptr::{swap_nonoverlapping, write_bytes},
+        if let ExprKind::Call(func, args) = expr.kind;
+        if let [.., count] = args;
+        if let ExprKind::Path(ref func_qpath) = func.kind;
+        if let Some(def_id) = cx.qpath_res(func_qpath, func.hir_id).opt_def_id();
+        if FUNCTIONS.iter().any(|func_path| match_def_path(cx, def_id, func_path));
+
+        // Get the pointee type
+        if let Some(pointee_ty) = cx.typeck_results().node_substs(func.hir_id).types().next();
+        then {
+            return Some((pointee_ty, count));
+        }
+    };
+    if_chain! {
+        // Find calls to copy_{from,to}{,_nonoverlapping} and write_bytes methods
+        if let ExprKind::MethodCall(method_path, _, args, _) = expr.kind;
+        if let [ptr_self, _, count] = args;
+        let method_ident = method_path.ident.as_str();
+        if METHODS.iter().any(|m| *m == &*method_ident);
+
+        // Get the pointee type
+        if let ty::RawPtr(TypeAndMut { ty: pointee_ty, mutbl:_mutability }) =
+            cx.typeck_results().expr_ty(ptr_self).kind();
+        then {
+            return Some((pointee_ty, count));
+        }
+    };
+    None
+}
+
+impl<'tcx> LateLintPass<'tcx> for SizeOfInElementCount {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        const HELP_MSG: &str = "use a count of elements instead of a count of bytes\
+            , it already gets multiplied by the size of the type";
+
+        const LINT_MSG: &str = "found a count of bytes \
+             instead of a count of elements of T";
+
+        if_chain! {
+            // Find calls to unsafe copy functions and get
+            // the pointee type and count parameter expression
+            if let Some((pointee_ty, count_expr)) = get_pointee_ty_and_count_expr(cx, expr);
+
+            // Find a size_of call in the count parameter expression and
+            // check that it's the same type
+            if let Some(ty_used_for_size_of) = get_size_of_ty(cx, count_expr);
+            if TyS::same_type(pointee_ty, ty_used_for_size_of);
+            then {
+                span_lint_and_help(
+                    cx,
+                    SIZE_OF_IN_ELEMENT_COUNT,
+                    count_expr.span,
+                    LINT_MSG,
+                    None,
+                    HELP_MSG
+                );
+            }
+        };
+    }
+}
diff --git a/clippy_lints/src/unsafe_sizeof_count_copies.rs b/clippy_lints/src/unsafe_sizeof_count_copies.rs
deleted file mode 100644
index 8a4538091e7..00000000000
--- a/clippy_lints/src/unsafe_sizeof_count_copies.rs
+++ /dev/null
@@ -1,146 +0,0 @@
-//! Lint on unsafe memory copying that use the `size_of` of the pointee type instead of a pointee
-//! count
-
-use crate::utils::{match_def_path, paths, span_lint_and_help};
-use if_chain::if_chain;
-use rustc_hir::BinOpKind;
-use rustc_hir::{Expr, ExprKind};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty::{self, Ty, TyS, TypeAndMut};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-
-declare_clippy_lint! {
-    /// **What it does:** Detects expressions where
-    /// size_of::<T> is used as the count argument to unsafe
-    /// memory copying functions like ptr::copy and
-    /// ptr::copy_nonoverlapping where T is the pointee type
-    /// of the pointers used
-    ///
-    /// **Why is this bad?** These functions expect a count
-    /// of T and not a number of bytes, which can lead to
-    /// copying the incorrect amount of bytes, which can
-    /// result in Undefined Behaviour
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    /// ```rust,no_run
-    /// # use std::ptr::copy_nonoverlapping;
-    /// # use std::mem::size_of;
-    ///
-    /// const SIZE: usize = 128;
-    /// let x = [2u8; SIZE];
-    /// let mut y = [2u8; SIZE];
-    /// unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>() * SIZE) };
-    /// ```
-    pub UNSAFE_SIZEOF_COUNT_COPIES,
-    correctness,
-    "unsafe memory copying using a byte count instead of a count of T"
-}
-
-declare_lint_pass!(UnsafeSizeofCountCopies => [UNSAFE_SIZEOF_COUNT_COPIES]);
-
-fn get_size_of_ty(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<Ty<'tcx>> {
-    match expr.kind {
-        ExprKind::Call(count_func, _func_args) => {
-            if_chain! {
-                if let ExprKind::Path(ref count_func_qpath) = count_func.kind;
-                if let Some(def_id) = cx.qpath_res(count_func_qpath, count_func.hir_id).opt_def_id();
-                if match_def_path(cx, def_id, &paths::MEM_SIZE_OF)
-                    || match_def_path(cx, def_id, &paths::MEM_SIZE_OF_VAL);
-                then {
-                    cx.typeck_results().node_substs(count_func.hir_id).types().next()
-                } else {
-                    None
-                }
-            }
-        },
-        ExprKind::Binary(op, left, right) if BinOpKind::Mul == op.node || BinOpKind::Div == op.node => {
-            get_size_of_ty(cx, left).or_else(|| get_size_of_ty(cx, right))
-        },
-        _ => None,
-    }
-}
-
-fn get_pointee_ty_and_count_expr(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<(Ty<'tcx>, &'tcx Expr<'tcx>)> {
-    if_chain! {
-        // Find calls to ptr::{copy, copy_nonoverlapping}
-        // and ptr::{swap_nonoverlapping, write_bytes},
-        if let ExprKind::Call(func, args) = expr.kind;
-        if let [_, _, count] = args;
-        if let ExprKind::Path(ref func_qpath) = func.kind;
-        if let Some(def_id) = cx.qpath_res(func_qpath, func.hir_id).opt_def_id();
-        if match_def_path(cx, def_id, &paths::COPY_NONOVERLAPPING)
-            || match_def_path(cx, def_id, &paths::COPY)
-            || match_def_path(cx, def_id, &paths::WRITE_BYTES)
-            || match_def_path(cx, def_id, &paths::PTR_SWAP_NONOVERLAPPING);
-
-        // Get the pointee type
-        if let Some(pointee_ty) = cx.typeck_results().node_substs(func.hir_id).types().next();
-        then {
-            return Some((pointee_ty, count));
-        }
-    };
-    if_chain! {
-        // Find calls to copy_{from,to}{,_nonoverlapping} and write_bytes methods
-        if let ExprKind::MethodCall(method_path, _, args, _) = expr.kind;
-        if let [ptr_self, _, count] = args;
-        let method_ident = method_path.ident.as_str();
-        if method_ident == "write_bytes" || method_ident == "copy_to" || method_ident == "copy_from"
-            || method_ident == "copy_to_nonoverlapping" || method_ident == "copy_from_nonoverlapping";
-
-        // Get the pointee type
-        if let ty::RawPtr(TypeAndMut { ty: pointee_ty, mutbl:_mutability }) =
-            cx.typeck_results().expr_ty(ptr_self).kind();
-        then {
-            return Some((pointee_ty, count));
-        }
-    };
-    if_chain! {
-        // Find calls to ptr::copy and copy_nonoverlapping
-        if let ExprKind::Call(func, args) = expr.kind;
-        if let [_data, count] = args;
-        if let ExprKind::Path(ref func_qpath) = func.kind;
-        if let Some(def_id) = cx.qpath_res(func_qpath, func.hir_id).opt_def_id();
-        if match_def_path(cx, def_id, &paths::PTR_SLICE_FROM_RAW_PARTS)
-            || match_def_path(cx, def_id, &paths::PTR_SLICE_FROM_RAW_PARTS_MUT);
-
-        // Get the pointee type
-        if let Some(pointee_ty) = cx.typeck_results().node_substs(func.hir_id).types().next();
-        then {
-            return Some((pointee_ty, count));
-        }
-    };
-    None
-}
-
-impl<'tcx> LateLintPass<'tcx> for UnsafeSizeofCountCopies {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        const HELP_MSG: &str = "use a count of elements instead of a count of bytes \
-            for the count parameter, it already gets multiplied by the size of the pointed to type";
-
-        const LINT_MSG: &str = "unsafe memory copying using a byte count \
-            (multiplied by size_of/size_of_val::<T>) instead of a count of T";
-
-        if_chain! {
-            // Find calls to unsafe copy functions and get
-            // the pointee type and count parameter expression
-            if let Some((pointee_ty, count_expr)) = get_pointee_ty_and_count_expr(cx, expr);
-
-            // Find a size_of call in the count parameter expression and
-            // check that it's the same type
-            if let Some(ty_used_for_size_of) = get_size_of_ty(cx, count_expr);
-            if TyS::same_type(pointee_ty, ty_used_for_size_of);
-            then {
-                span_lint_and_help(
-                    cx,
-                    UNSAFE_SIZEOF_COUNT_COPIES,
-                    expr.span,
-                    LINT_MSG,
-                    None,
-                    HELP_MSG
-                );
-            }
-        };
-    }
-}
diff --git a/tests/ui/size_of_in_element_count.rs b/tests/ui/size_of_in_element_count.rs
new file mode 100644
index 00000000000..d4658ebf72d
--- /dev/null
+++ b/tests/ui/size_of_in_element_count.rs
@@ -0,0 +1,50 @@
+#![warn(clippy::size_of_in_element_count)]
+
+use std::mem::{size_of, size_of_val};
+use std::ptr::{
+    copy, copy_nonoverlapping, slice_from_raw_parts,
+    slice_from_raw_parts_mut, swap_nonoverlapping, write_bytes,
+};
+
+fn main() {
+    const SIZE: usize = 128;
+    const HALF_SIZE: usize = SIZE / 2;
+    const DOUBLE_SIZE: usize = SIZE * 2;
+    let mut x = [2u8; SIZE];
+    let mut y = [2u8; SIZE];
+
+    // Count is size_of (Should trigger the lint)
+    unsafe { copy_nonoverlapping::<u8>(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>()) };
+    unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), size_of_val(&x[0])) };
+
+    unsafe { x.as_ptr().copy_to(y.as_mut_ptr(), size_of::<u8>()) };
+    unsafe { x.as_ptr().copy_to_nonoverlapping(y.as_mut_ptr(), size_of::<u8>()) };
+    unsafe { y.as_mut_ptr().copy_from(x.as_ptr(), size_of::<u8>()) };
+    unsafe { y.as_mut_ptr().copy_from_nonoverlapping(x.as_ptr(), size_of::<u8>()) };
+
+    unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>()) };
+    unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of_val(&x[0])) };
+
+    unsafe { y.as_mut_ptr().write_bytes(0u8, size_of::<u8>() * SIZE) };
+    unsafe { write_bytes(y.as_mut_ptr(), 0u8, size_of::<u8>() * SIZE) };
+
+    unsafe { swap_nonoverlapping(y.as_mut_ptr(), x.as_mut_ptr(), size_of::<u8>() * SIZE) };
+
+    slice_from_raw_parts_mut(y.as_mut_ptr(), size_of::<u8>() * SIZE);
+    slice_from_raw_parts(y.as_ptr(), size_of::<u8>() * SIZE);
+
+    // Count expression involving multiplication of size_of (Should trigger the lint)
+    unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>() * SIZE) };
+
+    // Count expression involving nested multiplications of size_of (Should trigger the lint)
+    unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), HALF_SIZE * size_of_val(&x[0]) * 2) };
+
+    // Count expression involving divisions of size_of (Should trigger the lint)
+    unsafe { copy(x.as_ptr(), y.as_mut_ptr(), DOUBLE_SIZE * size_of::<u8>() / 2) };
+
+    // No size_of calls (Should not trigger the lint)
+    unsafe { copy(x.as_ptr(), y.as_mut_ptr(), SIZE) };
+
+    // Different types for pointee and size_of (Should not trigger the lint)
+    unsafe { y.as_mut_ptr().write_bytes(0u8, size_of::<u16>() / 2 * SIZE) };
+}
diff --git a/tests/ui/size_of_in_element_count.stderr b/tests/ui/size_of_in_element_count.stderr
new file mode 100644
index 00000000000..80c3fec1b05
--- /dev/null
+++ b/tests/ui/size_of_in_element_count.stderr
@@ -0,0 +1,131 @@
+error: found a count of bytes instead of a count of elements of T
+  --> $DIR/size_of_in_element_count.rs:17:68
+   |
+LL |     unsafe { copy_nonoverlapping::<u8>(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>()) };
+   |                                                                    ^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::size-of-in-element-count` implied by `-D warnings`
+   = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
+
+error: found a count of bytes instead of a count of elements of T
+  --> $DIR/size_of_in_element_count.rs:18:62
+   |
+LL |     unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), size_of_val(&x[0])) };
+   |                                                              ^^^^^^^^^^^^^^^^^^
+   |
+   = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
+
+error: found a count of bytes instead of a count of elements of T
+  --> $DIR/size_of_in_element_count.rs:20:49
+   |
+LL |     unsafe { x.as_ptr().copy_to(y.as_mut_ptr(), size_of::<u8>()) };
+   |                                                 ^^^^^^^^^^^^^^^
+   |
+   = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
+
+error: found a count of bytes instead of a count of elements of T
+  --> $DIR/size_of_in_element_count.rs:21:64
+   |
+LL |     unsafe { x.as_ptr().copy_to_nonoverlapping(y.as_mut_ptr(), size_of::<u8>()) };
+   |                                                                ^^^^^^^^^^^^^^^
+   |
+   = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
+
+error: found a count of bytes instead of a count of elements of T
+  --> $DIR/size_of_in_element_count.rs:22:51
+   |
+LL |     unsafe { y.as_mut_ptr().copy_from(x.as_ptr(), size_of::<u8>()) };
+   |                                                   ^^^^^^^^^^^^^^^
+   |
+   = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
+
+error: found a count of bytes instead of a count of elements of T
+  --> $DIR/size_of_in_element_count.rs:23:66
+   |
+LL |     unsafe { y.as_mut_ptr().copy_from_nonoverlapping(x.as_ptr(), size_of::<u8>()) };
+   |                                                                  ^^^^^^^^^^^^^^^
+   |
+   = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
+
+error: found a count of bytes instead of a count of elements of T
+  --> $DIR/size_of_in_element_count.rs:25:47
+   |
+LL |     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>()) };
+   |                                               ^^^^^^^^^^^^^^^
+   |
+   = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
+
+error: found a count of bytes instead of a count of elements of T
+  --> $DIR/size_of_in_element_count.rs:26:47
+   |
+LL |     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of_val(&x[0])) };
+   |                                               ^^^^^^^^^^^^^^^^^^
+   |
+   = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
+
+error: found a count of bytes instead of a count of elements of T
+  --> $DIR/size_of_in_element_count.rs:28:46
+   |
+LL |     unsafe { y.as_mut_ptr().write_bytes(0u8, size_of::<u8>() * SIZE) };
+   |                                              ^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
+
+error: found a count of bytes instead of a count of elements of T
+  --> $DIR/size_of_in_element_count.rs:29:47
+   |
+LL |     unsafe { write_bytes(y.as_mut_ptr(), 0u8, size_of::<u8>() * SIZE) };
+   |                                               ^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
+
+error: found a count of bytes instead of a count of elements of T
+  --> $DIR/size_of_in_element_count.rs:31:66
+   |
+LL |     unsafe { swap_nonoverlapping(y.as_mut_ptr(), x.as_mut_ptr(), size_of::<u8>() * SIZE) };
+   |                                                                  ^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
+
+error: found a count of bytes instead of a count of elements of T
+  --> $DIR/size_of_in_element_count.rs:33:46
+   |
+LL |     slice_from_raw_parts_mut(y.as_mut_ptr(), size_of::<u8>() * SIZE);
+   |                                              ^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
+
+error: found a count of bytes instead of a count of elements of T
+  --> $DIR/size_of_in_element_count.rs:34:38
+   |
+LL |     slice_from_raw_parts(y.as_ptr(), size_of::<u8>() * SIZE);
+   |                                      ^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
+
+error: found a count of bytes instead of a count of elements of T
+  --> $DIR/size_of_in_element_count.rs:37:62
+   |
+LL |     unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>() * SIZE) };
+   |                                                              ^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
+
+error: found a count of bytes instead of a count of elements of T
+  --> $DIR/size_of_in_element_count.rs:40:62
+   |
+LL |     unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), HALF_SIZE * size_of_val(&x[0]) * 2) };
+   |                                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
+
+error: found a count of bytes instead of a count of elements of T
+  --> $DIR/size_of_in_element_count.rs:43:47
+   |
+LL |     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), DOUBLE_SIZE * size_of::<u8>() / 2) };
+   |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
+
+error: aborting due to 16 previous errors
+
diff --git a/tests/ui/unsafe_sizeof_count_copies.rs b/tests/ui/unsafe_sizeof_count_copies.rs
deleted file mode 100644
index 2a9adeb6bd9..00000000000
--- a/tests/ui/unsafe_sizeof_count_copies.rs
+++ /dev/null
@@ -1,49 +0,0 @@
-#![warn(clippy::unsafe_sizeof_count_copies)]
-
-use std::mem::{size_of, size_of_val};
-use std::ptr::{
-    copy, copy_nonoverlapping, slice_from_raw_parts, slice_from_raw_parts_mut, swap_nonoverlapping, write_bytes,
-};
-
-fn main() {
-    const SIZE: usize = 128;
-    const HALF_SIZE: usize = SIZE / 2;
-    const DOUBLE_SIZE: usize = SIZE * 2;
-    let mut x = [2u8; SIZE];
-    let mut y = [2u8; SIZE];
-
-    // Count is size_of (Should trigger the lint)
-    unsafe { copy_nonoverlapping::<u8>(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>()) };
-    unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), size_of_val(&x[0])) };
-
-    unsafe { x.as_ptr().copy_to(y.as_mut_ptr(), size_of::<u8>()) };
-    unsafe { x.as_ptr().copy_to_nonoverlapping(y.as_mut_ptr(), size_of::<u8>()) };
-    unsafe { y.as_mut_ptr().copy_from(x.as_ptr(), size_of::<u8>()) };
-    unsafe { y.as_mut_ptr().copy_from_nonoverlapping(x.as_ptr(), size_of::<u8>()) };
-
-    unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>()) };
-    unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of_val(&x[0])) };
-
-    unsafe { y.as_mut_ptr().write_bytes(0u8, size_of::<u8>() * SIZE) };
-    unsafe { write_bytes(y.as_mut_ptr(), 0u8, size_of::<u8>() * SIZE) };
-
-    unsafe { swap_nonoverlapping(y.as_mut_ptr(), x.as_mut_ptr(), size_of::<u8>() * SIZE) };
-
-    unsafe { slice_from_raw_parts_mut(y.as_mut_ptr(), size_of::<u8>() * SIZE) };
-    unsafe { slice_from_raw_parts(y.as_ptr(), size_of::<u8>() * SIZE) };
-
-    // Count expression involving multiplication of size_of (Should trigger the lint)
-    unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>() * SIZE) };
-
-    // Count expression involving nested multiplications of size_of (Should trigger the lint)
-    unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), HALF_SIZE * size_of_val(&x[0]) * 2) };
-
-    // Count expression involving divisions of size_of (Should trigger the lint)
-    unsafe { copy(x.as_ptr(), y.as_mut_ptr(), DOUBLE_SIZE * size_of::<u8>() / 2) };
-
-    // No size_of calls (Should not trigger the lint)
-    unsafe { copy(x.as_ptr(), y.as_mut_ptr(), SIZE) };
-
-    // Different types for pointee and size_of (Should not trigger the lint)
-    unsafe { y.as_mut_ptr().write_bytes(0u8, size_of::<u16>() / 2 * SIZE) };
-}
diff --git a/tests/ui/unsafe_sizeof_count_copies.stderr b/tests/ui/unsafe_sizeof_count_copies.stderr
deleted file mode 100644
index 7989e96dd21..00000000000
--- a/tests/ui/unsafe_sizeof_count_copies.stderr
+++ /dev/null
@@ -1,131 +0,0 @@
-error: unsafe memory copying using a byte count (multiplied by size_of/size_of_val::<T>) instead of a count of T
-  --> $DIR/unsafe_sizeof_count_copies.rs:16:14
-   |
-LL |     unsafe { copy_nonoverlapping::<u8>(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>()) };
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: `-D clippy::unsafe-sizeof-count-copies` implied by `-D warnings`
-   = help: use a count of elements instead of a count of bytes for the count parameter, it already gets multiplied by the size of the pointed to type
-
-error: unsafe memory copying using a byte count (multiplied by size_of/size_of_val::<T>) instead of a count of T
-  --> $DIR/unsafe_sizeof_count_copies.rs:17:14
-   |
-LL |     unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), size_of_val(&x[0])) };
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: use a count of elements instead of a count of bytes for the count parameter, it already gets multiplied by the size of the pointed to type
-
-error: unsafe memory copying using a byte count (multiplied by size_of/size_of_val::<T>) instead of a count of T
-  --> $DIR/unsafe_sizeof_count_copies.rs:19:14
-   |
-LL |     unsafe { x.as_ptr().copy_to(y.as_mut_ptr(), size_of::<u8>()) };
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: use a count of elements instead of a count of bytes for the count parameter, it already gets multiplied by the size of the pointed to type
-
-error: unsafe memory copying using a byte count (multiplied by size_of/size_of_val::<T>) instead of a count of T
-  --> $DIR/unsafe_sizeof_count_copies.rs:20:14
-   |
-LL |     unsafe { x.as_ptr().copy_to_nonoverlapping(y.as_mut_ptr(), size_of::<u8>()) };
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: use a count of elements instead of a count of bytes for the count parameter, it already gets multiplied by the size of the pointed to type
-
-error: unsafe memory copying using a byte count (multiplied by size_of/size_of_val::<T>) instead of a count of T
-  --> $DIR/unsafe_sizeof_count_copies.rs:21:14
-   |
-LL |     unsafe { y.as_mut_ptr().copy_from(x.as_ptr(), size_of::<u8>()) };
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: use a count of elements instead of a count of bytes for the count parameter, it already gets multiplied by the size of the pointed to type
-
-error: unsafe memory copying using a byte count (multiplied by size_of/size_of_val::<T>) instead of a count of T
-  --> $DIR/unsafe_sizeof_count_copies.rs:22:14
-   |
-LL |     unsafe { y.as_mut_ptr().copy_from_nonoverlapping(x.as_ptr(), size_of::<u8>()) };
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: use a count of elements instead of a count of bytes for the count parameter, it already gets multiplied by the size of the pointed to type
-
-error: unsafe memory copying using a byte count (multiplied by size_of/size_of_val::<T>) instead of a count of T
-  --> $DIR/unsafe_sizeof_count_copies.rs:24:14
-   |
-LL |     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>()) };
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: use a count of elements instead of a count of bytes for the count parameter, it already gets multiplied by the size of the pointed to type
-
-error: unsafe memory copying using a byte count (multiplied by size_of/size_of_val::<T>) instead of a count of T
-  --> $DIR/unsafe_sizeof_count_copies.rs:25:14
-   |
-LL |     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of_val(&x[0])) };
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: use a count of elements instead of a count of bytes for the count parameter, it already gets multiplied by the size of the pointed to type
-
-error: unsafe memory copying using a byte count (multiplied by size_of/size_of_val::<T>) instead of a count of T
-  --> $DIR/unsafe_sizeof_count_copies.rs:27:14
-   |
-LL |     unsafe { y.as_mut_ptr().write_bytes(0u8, size_of::<u8>() * SIZE) };
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: use a count of elements instead of a count of bytes for the count parameter, it already gets multiplied by the size of the pointed to type
-
-error: unsafe memory copying using a byte count (multiplied by size_of/size_of_val::<T>) instead of a count of T
-  --> $DIR/unsafe_sizeof_count_copies.rs:28:14
-   |
-LL |     unsafe { write_bytes(y.as_mut_ptr(), 0u8, size_of::<u8>() * SIZE) };
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: use a count of elements instead of a count of bytes for the count parameter, it already gets multiplied by the size of the pointed to type
-
-error: unsafe memory copying using a byte count (multiplied by size_of/size_of_val::<T>) instead of a count of T
-  --> $DIR/unsafe_sizeof_count_copies.rs:30:14
-   |
-LL |     unsafe { swap_nonoverlapping(y.as_mut_ptr(), x.as_mut_ptr(), size_of::<u8>() * SIZE) };
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: use a count of elements instead of a count of bytes for the count parameter, it already gets multiplied by the size of the pointed to type
-
-error: unsafe memory copying using a byte count (multiplied by size_of/size_of_val::<T>) instead of a count of T
-  --> $DIR/unsafe_sizeof_count_copies.rs:32:14
-   |
-LL |     unsafe { slice_from_raw_parts_mut(y.as_mut_ptr(), size_of::<u8>() * SIZE) };
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: use a count of elements instead of a count of bytes for the count parameter, it already gets multiplied by the size of the pointed to type
-
-error: unsafe memory copying using a byte count (multiplied by size_of/size_of_val::<T>) instead of a count of T
-  --> $DIR/unsafe_sizeof_count_copies.rs:33:14
-   |
-LL |     unsafe { slice_from_raw_parts(y.as_ptr(), size_of::<u8>() * SIZE) };
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: use a count of elements instead of a count of bytes for the count parameter, it already gets multiplied by the size of the pointed to type
-
-error: unsafe memory copying using a byte count (multiplied by size_of/size_of_val::<T>) instead of a count of T
-  --> $DIR/unsafe_sizeof_count_copies.rs:36:14
-   |
-LL |     unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>() * SIZE) };
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: use a count of elements instead of a count of bytes for the count parameter, it already gets multiplied by the size of the pointed to type
-
-error: unsafe memory copying using a byte count (multiplied by size_of/size_of_val::<T>) instead of a count of T
-  --> $DIR/unsafe_sizeof_count_copies.rs:39:14
-   |
-LL |     unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), HALF_SIZE * size_of_val(&x[0]) * 2) };
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: use a count of elements instead of a count of bytes for the count parameter, it already gets multiplied by the size of the pointed to type
-
-error: unsafe memory copying using a byte count (multiplied by size_of/size_of_val::<T>) instead of a count of T
-  --> $DIR/unsafe_sizeof_count_copies.rs:42:14
-   |
-LL |     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), DOUBLE_SIZE * size_of::<u8>() / 2) };
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: use a count of elements instead of a count of bytes for the count parameter, it already gets multiplied by the size of the pointed to type
-
-error: aborting due to 16 previous errors
-
-- 
cgit 1.4.1-3-g733a5


From c1a5329475d041dbeb077ecda6ae71f690b4bcc1 Mon Sep 17 00:00:00 2001
From: unknown <abramlujan@gmail.com>
Date: Mon, 30 Nov 2020 21:54:50 -0300
Subject: Add more functions to size_of_in_element_count Specifically
 ptr::{sub, wrapping_sub, add, wrapping_add, offset, wrapping_offset} and
 slice::{from_raw_parts, from_raw_parts_mut} The lint now also looks for
 size_of calls through casts (Since offset takes an isize)

---
 clippy_lints/src/lib.rs                      |  6 +-
 clippy_lints/src/size_of_in_element_count.rs | 48 ++++++++------
 clippy_lints/src/utils/paths.rs              |  2 +
 tests/ui/size_of_in_element_count.rs         | 15 ++++-
 tests/ui/size_of_in_element_count.stderr     | 98 +++++++++++++++++++++++-----
 5 files changed, 127 insertions(+), 42 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 06961064a4b..4ef595bcffd 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -848,6 +848,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &shadow::SHADOW_SAME,
         &shadow::SHADOW_UNRELATED,
         &single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS,
+        &size_of_in_element_count::SIZE_OF_IN_ELEMENT_COUNT,
         &slow_vector_initialization::SLOW_VECTOR_INITIALIZATION,
         &stable_sort_primitive::STABLE_SORT_PRIMITIVE,
         &strings::STRING_ADD,
@@ -917,7 +918,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &unnecessary_wraps::UNNECESSARY_WRAPS,
         &unnested_or_patterns::UNNESTED_OR_PATTERNS,
         &unsafe_removed_from_name::UNSAFE_REMOVED_FROM_NAME,
-        &size_of_in_element_count::SIZE_OF_IN_ELEMENT_COUNT,
         &unused_io_amount::UNUSED_IO_AMOUNT,
         &unused_self::UNUSED_SELF,
         &unused_unit::UNUSED_UNIT,
@@ -1562,6 +1562,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&self_assignment::SELF_ASSIGNMENT),
         LintId::of(&serde_api::SERDE_API_MISUSE),
         LintId::of(&single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS),
+        LintId::of(&size_of_in_element_count::SIZE_OF_IN_ELEMENT_COUNT),
         LintId::of(&slow_vector_initialization::SLOW_VECTOR_INITIALIZATION),
         LintId::of(&stable_sort_primitive::STABLE_SORT_PRIMITIVE),
         LintId::of(&strings::STRING_FROM_UTF8_AS_BYTES),
@@ -1608,7 +1609,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&unnecessary_sort_by::UNNECESSARY_SORT_BY),
         LintId::of(&unnecessary_wraps::UNNECESSARY_WRAPS),
         LintId::of(&unsafe_removed_from_name::UNSAFE_REMOVED_FROM_NAME),
-        LintId::of(&size_of_in_element_count::SIZE_OF_IN_ELEMENT_COUNT),
         LintId::of(&unused_io_amount::UNUSED_IO_AMOUNT),
         LintId::of(&unused_unit::UNUSED_UNIT),
         LintId::of(&unwrap::PANICKING_UNWRAP),
@@ -1872,6 +1872,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&regex::INVALID_REGEX),
         LintId::of(&self_assignment::SELF_ASSIGNMENT),
         LintId::of(&serde_api::SERDE_API_MISUSE),
+        LintId::of(&size_of_in_element_count::SIZE_OF_IN_ELEMENT_COUNT),
         LintId::of(&suspicious_trait_impl::SUSPICIOUS_ARITHMETIC_IMPL),
         LintId::of(&suspicious_trait_impl::SUSPICIOUS_OP_ASSIGN_IMPL),
         LintId::of(&swap::ALMOST_SWAPPED),
@@ -1887,7 +1888,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&unit_return_expecting_ord::UNIT_RETURN_EXPECTING_ORD),
         LintId::of(&unnamed_address::FN_ADDRESS_COMPARISONS),
         LintId::of(&unnamed_address::VTABLE_ADDRESS_COMPARISONS),
-        LintId::of(&size_of_in_element_count::SIZE_OF_IN_ELEMENT_COUNT),
         LintId::of(&unused_io_amount::UNUSED_IO_AMOUNT),
         LintId::of(&unwrap::PANICKING_UNWRAP),
         LintId::of(&vec_resize_to_zero::VEC_RESIZE_TO_ZERO),
diff --git a/clippy_lints/src/size_of_in_element_count.rs b/clippy_lints/src/size_of_in_element_count.rs
index 9701e793700..210cf5773e1 100644
--- a/clippy_lints/src/size_of_in_element_count.rs
+++ b/clippy_lints/src/size_of_in_element_count.rs
@@ -54,31 +54,40 @@ fn get_size_of_ty(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<Ty<'tc
         ExprKind::Binary(op, left, right) if BinOpKind::Mul == op.node || BinOpKind::Div == op.node => {
             get_size_of_ty(cx, left).or_else(|| get_size_of_ty(cx, right))
         },
+        ExprKind::Cast(expr, _) => get_size_of_ty(cx, expr),
         _ => None,
     }
 }
 
-const FUNCTIONS: [[&str; 3]; 6] = [
-    paths::COPY_NONOVERLAPPING,
-    paths::COPY,
-    paths::WRITE_BYTES,
-    paths::PTR_SWAP_NONOVERLAPPING,
-    paths::PTR_SLICE_FROM_RAW_PARTS,
-    paths::PTR_SLICE_FROM_RAW_PARTS_MUT,
+fn get_pointee_ty_and_count_expr(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<(Ty<'tcx>, &'tcx Expr<'tcx>)> {
+    const FUNCTIONS: [&[&str]; 8] = [
+        &paths::COPY_NONOVERLAPPING,
+        &paths::COPY,
+        &paths::WRITE_BYTES,
+        &paths::PTR_SWAP_NONOVERLAPPING,
+        &paths::PTR_SLICE_FROM_RAW_PARTS,
+        &paths::PTR_SLICE_FROM_RAW_PARTS_MUT,
+        &paths::SLICE_FROM_RAW_PARTS,
+        &paths::SLICE_FROM_RAW_PARTS_MUT,
     ];
-const METHODS: [&str; 5] = [
-    "write_bytes",
-    "copy_to",
-    "copy_from",
-    "copy_to_nonoverlapping",
-    "copy_from_nonoverlapping",
+    const METHODS: [&str; 11] = [
+        "write_bytes",
+        "copy_to",
+        "copy_from",
+        "copy_to_nonoverlapping",
+        "copy_from_nonoverlapping",
+        "add",
+        "wrapping_add",
+        "sub",
+        "wrapping_sub",
+        "offset",
+        "wrapping_offset",
     ];
-fn get_pointee_ty_and_count_expr(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<(Ty<'tcx>, &'tcx Expr<'tcx>)> {
+
     if_chain! {
         // Find calls to ptr::{copy, copy_nonoverlapping}
         // and ptr::{swap_nonoverlapping, write_bytes},
-        if let ExprKind::Call(func, args) = expr.kind;
-        if let [.., count] = args;
+        if let ExprKind::Call(func, [.., count]) = expr.kind;
         if let ExprKind::Path(ref func_qpath) = func.kind;
         if let Some(def_id) = cx.qpath_res(func_qpath, func.hir_id).opt_def_id();
         if FUNCTIONS.iter().any(|func_path| match_def_path(cx, def_id, func_path));
@@ -91,13 +100,12 @@ fn get_pointee_ty_and_count_expr(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -
     };
     if_chain! {
         // Find calls to copy_{from,to}{,_nonoverlapping} and write_bytes methods
-        if let ExprKind::MethodCall(method_path, _, args, _) = expr.kind;
-        if let [ptr_self, _, count] = args;
+        if let ExprKind::MethodCall(method_path, _, [ptr_self, .., count], _) = expr.kind;
         let method_ident = method_path.ident.as_str();
         if METHODS.iter().any(|m| *m == &*method_ident);
 
         // Get the pointee type
-        if let ty::RawPtr(TypeAndMut { ty: pointee_ty, mutbl:_mutability }) =
+        if let ty::RawPtr(TypeAndMut { ty: pointee_ty, .. }) =
             cx.typeck_results().expr_ty(ptr_self).kind();
         then {
             return Some((pointee_ty, count));
@@ -115,7 +123,7 @@ impl<'tcx> LateLintPass<'tcx> for SizeOfInElementCount {
              instead of a count of elements of T";
 
         if_chain! {
-            // Find calls to unsafe copy functions and get
+            // Find calls to functions with an element count parameter and get
             // the pointee type and count parameter expression
             if let Some((pointee_ty, count_expr)) = get_pointee_ty_and_count_expr(cx, expr);
 
diff --git a/clippy_lints/src/utils/paths.rs b/clippy_lints/src/utils/paths.rs
index 87c020a99db..6fdc7b4587f 100644
--- a/clippy_lints/src/utils/paths.rs
+++ b/clippy_lints/src/utils/paths.rs
@@ -128,6 +128,8 @@ pub const RWLOCK_READ_GUARD: [&str; 4] = ["std", "sync", "rwlock", "RwLockReadGu
 pub const RWLOCK_WRITE_GUARD: [&str; 4] = ["std", "sync", "rwlock", "RwLockWriteGuard"];
 pub const SERDE_DESERIALIZE: [&str; 3] = ["serde", "de", "Deserialize"];
 pub const SERDE_DE_VISITOR: [&str; 3] = ["serde", "de", "Visitor"];
+pub const SLICE_FROM_RAW_PARTS: [&str; 4] = ["core", "slice", "raw", "from_raw_parts"];
+pub const SLICE_FROM_RAW_PARTS_MUT: [&str; 4] = ["core", "slice", "raw", "from_raw_parts_mut"];
 pub const SLICE_INTO_VEC: [&str; 4] = ["alloc", "slice", "<impl [T]>", "into_vec"];
 pub const SLICE_ITER: [&str; 4] = ["core", "slice", "iter", "Iter"];
 pub const STDERR: [&str; 4] = ["std", "io", "stdio", "stderr"];
diff --git a/tests/ui/size_of_in_element_count.rs b/tests/ui/size_of_in_element_count.rs
index d4658ebf72d..b13e390705a 100644
--- a/tests/ui/size_of_in_element_count.rs
+++ b/tests/ui/size_of_in_element_count.rs
@@ -1,10 +1,11 @@
 #![warn(clippy::size_of_in_element_count)]
+#![allow(clippy::ptr_offset_with_cast)]
 
 use std::mem::{size_of, size_of_val};
 use std::ptr::{
-    copy, copy_nonoverlapping, slice_from_raw_parts,
-    slice_from_raw_parts_mut, swap_nonoverlapping, write_bytes,
+    copy, copy_nonoverlapping, slice_from_raw_parts, slice_from_raw_parts_mut, swap_nonoverlapping, write_bytes,
 };
+use std::slice::{from_raw_parts, from_raw_parts_mut};
 
 fn main() {
     const SIZE: usize = 128;
@@ -33,6 +34,16 @@ fn main() {
     slice_from_raw_parts_mut(y.as_mut_ptr(), size_of::<u8>() * SIZE);
     slice_from_raw_parts(y.as_ptr(), size_of::<u8>() * SIZE);
 
+    unsafe { from_raw_parts_mut(y.as_mut_ptr(), size_of::<u8>() * SIZE) };
+    unsafe { from_raw_parts(y.as_ptr(), size_of::<u8>() * SIZE) };
+
+    unsafe { y.as_mut_ptr().sub(size_of::<u8>()) };
+    y.as_ptr().wrapping_sub(size_of::<u8>());
+    unsafe { y.as_ptr().add(size_of::<u8>()) };
+    y.as_mut_ptr().wrapping_add(size_of::<u8>());
+    unsafe { y.as_ptr().offset(size_of::<u8>() as isize) };
+    y.as_mut_ptr().wrapping_offset(size_of::<u8>() as isize);
+
     // Count expression involving multiplication of size_of (Should trigger the lint)
     unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>() * SIZE) };
 
diff --git a/tests/ui/size_of_in_element_count.stderr b/tests/ui/size_of_in_element_count.stderr
index 80c3fec1b05..b7f421ec997 100644
--- a/tests/ui/size_of_in_element_count.stderr
+++ b/tests/ui/size_of_in_element_count.stderr
@@ -1,5 +1,5 @@
 error: found a count of bytes instead of a count of elements of T
-  --> $DIR/size_of_in_element_count.rs:17:68
+  --> $DIR/size_of_in_element_count.rs:18:68
    |
 LL |     unsafe { copy_nonoverlapping::<u8>(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>()) };
    |                                                                    ^^^^^^^^^^^^^^^
@@ -8,7 +8,7 @@ LL |     unsafe { copy_nonoverlapping::<u8>(x.as_ptr(), y.as_mut_ptr(), size_of:
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
 error: found a count of bytes instead of a count of elements of T
-  --> $DIR/size_of_in_element_count.rs:18:62
+  --> $DIR/size_of_in_element_count.rs:19:62
    |
 LL |     unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), size_of_val(&x[0])) };
    |                                                              ^^^^^^^^^^^^^^^^^^
@@ -16,7 +16,7 @@ LL |     unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), size_of_val(&x
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
 error: found a count of bytes instead of a count of elements of T
-  --> $DIR/size_of_in_element_count.rs:20:49
+  --> $DIR/size_of_in_element_count.rs:21:49
    |
 LL |     unsafe { x.as_ptr().copy_to(y.as_mut_ptr(), size_of::<u8>()) };
    |                                                 ^^^^^^^^^^^^^^^
@@ -24,7 +24,7 @@ LL |     unsafe { x.as_ptr().copy_to(y.as_mut_ptr(), size_of::<u8>()) };
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
 error: found a count of bytes instead of a count of elements of T
-  --> $DIR/size_of_in_element_count.rs:21:64
+  --> $DIR/size_of_in_element_count.rs:22:64
    |
 LL |     unsafe { x.as_ptr().copy_to_nonoverlapping(y.as_mut_ptr(), size_of::<u8>()) };
    |                                                                ^^^^^^^^^^^^^^^
@@ -32,7 +32,7 @@ LL |     unsafe { x.as_ptr().copy_to_nonoverlapping(y.as_mut_ptr(), size_of::<u8
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
 error: found a count of bytes instead of a count of elements of T
-  --> $DIR/size_of_in_element_count.rs:22:51
+  --> $DIR/size_of_in_element_count.rs:23:51
    |
 LL |     unsafe { y.as_mut_ptr().copy_from(x.as_ptr(), size_of::<u8>()) };
    |                                                   ^^^^^^^^^^^^^^^
@@ -40,7 +40,7 @@ LL |     unsafe { y.as_mut_ptr().copy_from(x.as_ptr(), size_of::<u8>()) };
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
 error: found a count of bytes instead of a count of elements of T
-  --> $DIR/size_of_in_element_count.rs:23:66
+  --> $DIR/size_of_in_element_count.rs:24:66
    |
 LL |     unsafe { y.as_mut_ptr().copy_from_nonoverlapping(x.as_ptr(), size_of::<u8>()) };
    |                                                                  ^^^^^^^^^^^^^^^
@@ -48,7 +48,7 @@ LL |     unsafe { y.as_mut_ptr().copy_from_nonoverlapping(x.as_ptr(), size_of::<
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
 error: found a count of bytes instead of a count of elements of T
-  --> $DIR/size_of_in_element_count.rs:25:47
+  --> $DIR/size_of_in_element_count.rs:26:47
    |
 LL |     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>()) };
    |                                               ^^^^^^^^^^^^^^^
@@ -56,7 +56,7 @@ LL |     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>()) };
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
 error: found a count of bytes instead of a count of elements of T
-  --> $DIR/size_of_in_element_count.rs:26:47
+  --> $DIR/size_of_in_element_count.rs:27:47
    |
 LL |     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of_val(&x[0])) };
    |                                               ^^^^^^^^^^^^^^^^^^
@@ -64,7 +64,7 @@ LL |     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of_val(&x[0])) };
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
 error: found a count of bytes instead of a count of elements of T
-  --> $DIR/size_of_in_element_count.rs:28:46
+  --> $DIR/size_of_in_element_count.rs:29:46
    |
 LL |     unsafe { y.as_mut_ptr().write_bytes(0u8, size_of::<u8>() * SIZE) };
    |                                              ^^^^^^^^^^^^^^^^^^^^^^
@@ -72,7 +72,7 @@ LL |     unsafe { y.as_mut_ptr().write_bytes(0u8, size_of::<u8>() * SIZE) };
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
 error: found a count of bytes instead of a count of elements of T
-  --> $DIR/size_of_in_element_count.rs:29:47
+  --> $DIR/size_of_in_element_count.rs:30:47
    |
 LL |     unsafe { write_bytes(y.as_mut_ptr(), 0u8, size_of::<u8>() * SIZE) };
    |                                               ^^^^^^^^^^^^^^^^^^^^^^
@@ -80,7 +80,7 @@ LL |     unsafe { write_bytes(y.as_mut_ptr(), 0u8, size_of::<u8>() * SIZE) };
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
 error: found a count of bytes instead of a count of elements of T
-  --> $DIR/size_of_in_element_count.rs:31:66
+  --> $DIR/size_of_in_element_count.rs:32:66
    |
 LL |     unsafe { swap_nonoverlapping(y.as_mut_ptr(), x.as_mut_ptr(), size_of::<u8>() * SIZE) };
    |                                                                  ^^^^^^^^^^^^^^^^^^^^^^
@@ -88,7 +88,7 @@ LL |     unsafe { swap_nonoverlapping(y.as_mut_ptr(), x.as_mut_ptr(), size_of::<
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
 error: found a count of bytes instead of a count of elements of T
-  --> $DIR/size_of_in_element_count.rs:33:46
+  --> $DIR/size_of_in_element_count.rs:34:46
    |
 LL |     slice_from_raw_parts_mut(y.as_mut_ptr(), size_of::<u8>() * SIZE);
    |                                              ^^^^^^^^^^^^^^^^^^^^^^
@@ -96,7 +96,7 @@ LL |     slice_from_raw_parts_mut(y.as_mut_ptr(), size_of::<u8>() * SIZE);
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
 error: found a count of bytes instead of a count of elements of T
-  --> $DIR/size_of_in_element_count.rs:34:38
+  --> $DIR/size_of_in_element_count.rs:35:38
    |
 LL |     slice_from_raw_parts(y.as_ptr(), size_of::<u8>() * SIZE);
    |                                      ^^^^^^^^^^^^^^^^^^^^^^
@@ -104,7 +104,71 @@ LL |     slice_from_raw_parts(y.as_ptr(), size_of::<u8>() * SIZE);
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
 error: found a count of bytes instead of a count of elements of T
-  --> $DIR/size_of_in_element_count.rs:37:62
+  --> $DIR/size_of_in_element_count.rs:37:49
+   |
+LL |     unsafe { from_raw_parts_mut(y.as_mut_ptr(), size_of::<u8>() * SIZE) };
+   |                                                 ^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
+
+error: found a count of bytes instead of a count of elements of T
+  --> $DIR/size_of_in_element_count.rs:38:41
+   |
+LL |     unsafe { from_raw_parts(y.as_ptr(), size_of::<u8>() * SIZE) };
+   |                                         ^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
+
+error: found a count of bytes instead of a count of elements of T
+  --> $DIR/size_of_in_element_count.rs:40:33
+   |
+LL |     unsafe { y.as_mut_ptr().sub(size_of::<u8>()) };
+   |                                 ^^^^^^^^^^^^^^^
+   |
+   = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
+
+error: found a count of bytes instead of a count of elements of T
+  --> $DIR/size_of_in_element_count.rs:41:29
+   |
+LL |     y.as_ptr().wrapping_sub(size_of::<u8>());
+   |                             ^^^^^^^^^^^^^^^
+   |
+   = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
+
+error: found a count of bytes instead of a count of elements of T
+  --> $DIR/size_of_in_element_count.rs:42:29
+   |
+LL |     unsafe { y.as_ptr().add(size_of::<u8>()) };
+   |                             ^^^^^^^^^^^^^^^
+   |
+   = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
+
+error: found a count of bytes instead of a count of elements of T
+  --> $DIR/size_of_in_element_count.rs:43:33
+   |
+LL |     y.as_mut_ptr().wrapping_add(size_of::<u8>());
+   |                                 ^^^^^^^^^^^^^^^
+   |
+   = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
+
+error: found a count of bytes instead of a count of elements of T
+  --> $DIR/size_of_in_element_count.rs:44:32
+   |
+LL |     unsafe { y.as_ptr().offset(size_of::<u8>() as isize) };
+   |                                ^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
+
+error: found a count of bytes instead of a count of elements of T
+  --> $DIR/size_of_in_element_count.rs:45:36
+   |
+LL |     y.as_mut_ptr().wrapping_offset(size_of::<u8>() as isize);
+   |                                    ^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
+
+error: found a count of bytes instead of a count of elements of T
+  --> $DIR/size_of_in_element_count.rs:48:62
    |
 LL |     unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>() * SIZE) };
    |                                                              ^^^^^^^^^^^^^^^^^^^^^^
@@ -112,7 +176,7 @@ LL |     unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>(
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
 error: found a count of bytes instead of a count of elements of T
-  --> $DIR/size_of_in_element_count.rs:40:62
+  --> $DIR/size_of_in_element_count.rs:51:62
    |
 LL |     unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), HALF_SIZE * size_of_val(&x[0]) * 2) };
    |                                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -120,12 +184,12 @@ LL |     unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), HALF_SIZE * si
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
 error: found a count of bytes instead of a count of elements of T
-  --> $DIR/size_of_in_element_count.rs:43:47
+  --> $DIR/size_of_in_element_count.rs:54:47
    |
 LL |     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), DOUBLE_SIZE * size_of::<u8>() / 2) };
    |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
-error: aborting due to 16 previous errors
+error: aborting due to 24 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 01f32116028a127b4a946c72b8ed5de3e03be477 Mon Sep 17 00:00:00 2001
From: flip1995 <philipp.krones@embecosm.com>
Date: Fri, 4 Dec 2020 10:01:09 +0100
Subject: Turn unnecessary_wraps applicability to MaybeIncorrect

---
 clippy_lints/src/unnecessary_wraps.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unnecessary_wraps.rs b/clippy_lints/src/unnecessary_wraps.rs
index 360df2a6752..5d801511a0b 100644
--- a/clippy_lints/src/unnecessary_wraps.rs
+++ b/clippy_lints/src/unnecessary_wraps.rs
@@ -135,7 +135,7 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryWraps {
                     diag.multipart_suggestion(
                         "...and change the returning expressions",
                         suggs,
-                        Applicability::MachineApplicable,
+                        Applicability::MaybeIncorrect,
                     );
                 },
             );
-- 
cgit 1.4.1-3-g733a5


From 75140e813f3701e76ab64e091653395ec397f68d Mon Sep 17 00:00:00 2001
From: Takayuki Nakata <f.seasons017@gmail.com>
Date: Fri, 4 Dec 2020 23:36:07 +0900
Subject: Fix a style of texts in `size_of_in_element_count`

---
 clippy_lints/src/size_of_in_element_count.rs | 11 +++----
 tests/ui/size_of_in_element_count.stderr     | 48 ++++++++++++++--------------
 2 files changed, 29 insertions(+), 30 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/size_of_in_element_count.rs b/clippy_lints/src/size_of_in_element_count.rs
index 210cf5773e1..ea7a76146f5 100644
--- a/clippy_lints/src/size_of_in_element_count.rs
+++ b/clippy_lints/src/size_of_in_element_count.rs
@@ -11,11 +11,11 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
     /// **What it does:** Detects expressions where
-    /// size_of::<T> or size_of_val::<T> is used as a
-    /// count of elements of type T
+    /// `size_of::<T>` or `size_of_val::<T>` is used as a
+    /// count of elements of type `T`
     ///
     /// **Why is this bad?** These functions expect a count
-    /// of T and not a number of bytes
+    /// of `T` and not a number of bytes
     ///
     /// **Known problems:** None.
     ///
@@ -23,7 +23,6 @@ declare_clippy_lint! {
     /// ```rust,no_run
     /// # use std::ptr::copy_nonoverlapping;
     /// # use std::mem::size_of;
-    ///
     /// const SIZE: usize = 128;
     /// let x = [2u8; SIZE];
     /// let mut y = [2u8; SIZE];
@@ -31,7 +30,7 @@ declare_clippy_lint! {
     /// ```
     pub SIZE_OF_IN_ELEMENT_COUNT,
     correctness,
-    "using size_of::<T> or size_of_val::<T> where a count of elements of T is expected"
+    "using `size_of::<T>` or `size_of_val::<T>` where a count of elements of `T` is expected"
 }
 
 declare_lint_pass!(SizeOfInElementCount => [SIZE_OF_IN_ELEMENT_COUNT]);
@@ -120,7 +119,7 @@ impl<'tcx> LateLintPass<'tcx> for SizeOfInElementCount {
             , it already gets multiplied by the size of the type";
 
         const LINT_MSG: &str = "found a count of bytes \
-             instead of a count of elements of T";
+             instead of a count of elements of `T`";
 
         if_chain! {
             // Find calls to functions with an element count parameter and get
diff --git a/tests/ui/size_of_in_element_count.stderr b/tests/ui/size_of_in_element_count.stderr
index b7f421ec997..8cf3612abda 100644
--- a/tests/ui/size_of_in_element_count.stderr
+++ b/tests/ui/size_of_in_element_count.stderr
@@ -1,4 +1,4 @@
-error: found a count of bytes instead of a count of elements of T
+error: found a count of bytes instead of a count of elements of `T`
   --> $DIR/size_of_in_element_count.rs:18:68
    |
 LL |     unsafe { copy_nonoverlapping::<u8>(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>()) };
@@ -7,7 +7,7 @@ LL |     unsafe { copy_nonoverlapping::<u8>(x.as_ptr(), y.as_mut_ptr(), size_of:
    = note: `-D clippy::size-of-in-element-count` implied by `-D warnings`
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
-error: found a count of bytes instead of a count of elements of T
+error: found a count of bytes instead of a count of elements of `T`
   --> $DIR/size_of_in_element_count.rs:19:62
    |
 LL |     unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), size_of_val(&x[0])) };
@@ -15,7 +15,7 @@ LL |     unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), size_of_val(&x
    |
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
-error: found a count of bytes instead of a count of elements of T
+error: found a count of bytes instead of a count of elements of `T`
   --> $DIR/size_of_in_element_count.rs:21:49
    |
 LL |     unsafe { x.as_ptr().copy_to(y.as_mut_ptr(), size_of::<u8>()) };
@@ -23,7 +23,7 @@ LL |     unsafe { x.as_ptr().copy_to(y.as_mut_ptr(), size_of::<u8>()) };
    |
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
-error: found a count of bytes instead of a count of elements of T
+error: found a count of bytes instead of a count of elements of `T`
   --> $DIR/size_of_in_element_count.rs:22:64
    |
 LL |     unsafe { x.as_ptr().copy_to_nonoverlapping(y.as_mut_ptr(), size_of::<u8>()) };
@@ -31,7 +31,7 @@ LL |     unsafe { x.as_ptr().copy_to_nonoverlapping(y.as_mut_ptr(), size_of::<u8
    |
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
-error: found a count of bytes instead of a count of elements of T
+error: found a count of bytes instead of a count of elements of `T`
   --> $DIR/size_of_in_element_count.rs:23:51
    |
 LL |     unsafe { y.as_mut_ptr().copy_from(x.as_ptr(), size_of::<u8>()) };
@@ -39,7 +39,7 @@ LL |     unsafe { y.as_mut_ptr().copy_from(x.as_ptr(), size_of::<u8>()) };
    |
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
-error: found a count of bytes instead of a count of elements of T
+error: found a count of bytes instead of a count of elements of `T`
   --> $DIR/size_of_in_element_count.rs:24:66
    |
 LL |     unsafe { y.as_mut_ptr().copy_from_nonoverlapping(x.as_ptr(), size_of::<u8>()) };
@@ -47,7 +47,7 @@ LL |     unsafe { y.as_mut_ptr().copy_from_nonoverlapping(x.as_ptr(), size_of::<
    |
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
-error: found a count of bytes instead of a count of elements of T
+error: found a count of bytes instead of a count of elements of `T`
   --> $DIR/size_of_in_element_count.rs:26:47
    |
 LL |     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>()) };
@@ -55,7 +55,7 @@ LL |     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>()) };
    |
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
-error: found a count of bytes instead of a count of elements of T
+error: found a count of bytes instead of a count of elements of `T`
   --> $DIR/size_of_in_element_count.rs:27:47
    |
 LL |     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of_val(&x[0])) };
@@ -63,7 +63,7 @@ LL |     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of_val(&x[0])) };
    |
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
-error: found a count of bytes instead of a count of elements of T
+error: found a count of bytes instead of a count of elements of `T`
   --> $DIR/size_of_in_element_count.rs:29:46
    |
 LL |     unsafe { y.as_mut_ptr().write_bytes(0u8, size_of::<u8>() * SIZE) };
@@ -71,7 +71,7 @@ LL |     unsafe { y.as_mut_ptr().write_bytes(0u8, size_of::<u8>() * SIZE) };
    |
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
-error: found a count of bytes instead of a count of elements of T
+error: found a count of bytes instead of a count of elements of `T`
   --> $DIR/size_of_in_element_count.rs:30:47
    |
 LL |     unsafe { write_bytes(y.as_mut_ptr(), 0u8, size_of::<u8>() * SIZE) };
@@ -79,7 +79,7 @@ LL |     unsafe { write_bytes(y.as_mut_ptr(), 0u8, size_of::<u8>() * SIZE) };
    |
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
-error: found a count of bytes instead of a count of elements of T
+error: found a count of bytes instead of a count of elements of `T`
   --> $DIR/size_of_in_element_count.rs:32:66
    |
 LL |     unsafe { swap_nonoverlapping(y.as_mut_ptr(), x.as_mut_ptr(), size_of::<u8>() * SIZE) };
@@ -87,7 +87,7 @@ LL |     unsafe { swap_nonoverlapping(y.as_mut_ptr(), x.as_mut_ptr(), size_of::<
    |
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
-error: found a count of bytes instead of a count of elements of T
+error: found a count of bytes instead of a count of elements of `T`
   --> $DIR/size_of_in_element_count.rs:34:46
    |
 LL |     slice_from_raw_parts_mut(y.as_mut_ptr(), size_of::<u8>() * SIZE);
@@ -95,7 +95,7 @@ LL |     slice_from_raw_parts_mut(y.as_mut_ptr(), size_of::<u8>() * SIZE);
    |
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
-error: found a count of bytes instead of a count of elements of T
+error: found a count of bytes instead of a count of elements of `T`
   --> $DIR/size_of_in_element_count.rs:35:38
    |
 LL |     slice_from_raw_parts(y.as_ptr(), size_of::<u8>() * SIZE);
@@ -103,7 +103,7 @@ LL |     slice_from_raw_parts(y.as_ptr(), size_of::<u8>() * SIZE);
    |
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
-error: found a count of bytes instead of a count of elements of T
+error: found a count of bytes instead of a count of elements of `T`
   --> $DIR/size_of_in_element_count.rs:37:49
    |
 LL |     unsafe { from_raw_parts_mut(y.as_mut_ptr(), size_of::<u8>() * SIZE) };
@@ -111,7 +111,7 @@ LL |     unsafe { from_raw_parts_mut(y.as_mut_ptr(), size_of::<u8>() * SIZE) };
    |
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
-error: found a count of bytes instead of a count of elements of T
+error: found a count of bytes instead of a count of elements of `T`
   --> $DIR/size_of_in_element_count.rs:38:41
    |
 LL |     unsafe { from_raw_parts(y.as_ptr(), size_of::<u8>() * SIZE) };
@@ -119,7 +119,7 @@ LL |     unsafe { from_raw_parts(y.as_ptr(), size_of::<u8>() * SIZE) };
    |
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
-error: found a count of bytes instead of a count of elements of T
+error: found a count of bytes instead of a count of elements of `T`
   --> $DIR/size_of_in_element_count.rs:40:33
    |
 LL |     unsafe { y.as_mut_ptr().sub(size_of::<u8>()) };
@@ -127,7 +127,7 @@ LL |     unsafe { y.as_mut_ptr().sub(size_of::<u8>()) };
    |
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
-error: found a count of bytes instead of a count of elements of T
+error: found a count of bytes instead of a count of elements of `T`
   --> $DIR/size_of_in_element_count.rs:41:29
    |
 LL |     y.as_ptr().wrapping_sub(size_of::<u8>());
@@ -135,7 +135,7 @@ LL |     y.as_ptr().wrapping_sub(size_of::<u8>());
    |
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
-error: found a count of bytes instead of a count of elements of T
+error: found a count of bytes instead of a count of elements of `T`
   --> $DIR/size_of_in_element_count.rs:42:29
    |
 LL |     unsafe { y.as_ptr().add(size_of::<u8>()) };
@@ -143,7 +143,7 @@ LL |     unsafe { y.as_ptr().add(size_of::<u8>()) };
    |
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
-error: found a count of bytes instead of a count of elements of T
+error: found a count of bytes instead of a count of elements of `T`
   --> $DIR/size_of_in_element_count.rs:43:33
    |
 LL |     y.as_mut_ptr().wrapping_add(size_of::<u8>());
@@ -151,7 +151,7 @@ LL |     y.as_mut_ptr().wrapping_add(size_of::<u8>());
    |
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
-error: found a count of bytes instead of a count of elements of T
+error: found a count of bytes instead of a count of elements of `T`
   --> $DIR/size_of_in_element_count.rs:44:32
    |
 LL |     unsafe { y.as_ptr().offset(size_of::<u8>() as isize) };
@@ -159,7 +159,7 @@ LL |     unsafe { y.as_ptr().offset(size_of::<u8>() as isize) };
    |
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
-error: found a count of bytes instead of a count of elements of T
+error: found a count of bytes instead of a count of elements of `T`
   --> $DIR/size_of_in_element_count.rs:45:36
    |
 LL |     y.as_mut_ptr().wrapping_offset(size_of::<u8>() as isize);
@@ -167,7 +167,7 @@ LL |     y.as_mut_ptr().wrapping_offset(size_of::<u8>() as isize);
    |
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
-error: found a count of bytes instead of a count of elements of T
+error: found a count of bytes instead of a count of elements of `T`
   --> $DIR/size_of_in_element_count.rs:48:62
    |
 LL |     unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>() * SIZE) };
@@ -175,7 +175,7 @@ LL |     unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>(
    |
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
-error: found a count of bytes instead of a count of elements of T
+error: found a count of bytes instead of a count of elements of `T`
   --> $DIR/size_of_in_element_count.rs:51:62
    |
 LL |     unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), HALF_SIZE * size_of_val(&x[0]) * 2) };
@@ -183,7 +183,7 @@ LL |     unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), HALF_SIZE * si
    |
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
-error: found a count of bytes instead of a count of elements of T
+error: found a count of bytes instead of a count of elements of `T`
   --> $DIR/size_of_in_element_count.rs:54:47
    |
 LL |     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), DOUBLE_SIZE * size_of::<u8>() / 2) };
-- 
cgit 1.4.1-3-g733a5


From 6edd59885605d2cf0aa8727cf2cd30cd13098804 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Fri, 4 Dec 2020 21:26:47 +0000
Subject: Added a lint-fraction-readability flag to the configuration

---
 clippy_lints/src/lib.rs                            |  3 +-
 clippy_lints/src/literal_representation.rs         | 37 ++++++++++++++-----
 clippy_lints/src/utils/conf.rs                     |  2 ++
 tests/ui-toml/lint_decimal_readability/clippy.toml |  1 +
 tests/ui-toml/lint_decimal_readability/test.rs     | 22 ++++++++++++
 tests/ui-toml/lint_decimal_readability/test.stderr | 10 ++++++
 .../toml_unknown_key/conf_unknown_key.stderr       |  2 +-
 tests/ui/unreadable_literal.fixed                  | 18 +++++++---
 tests/ui/unreadable_literal.rs                     | 18 +++++++---
 tests/ui/unreadable_literal.stderr                 | 42 ++++++++++++----------
 10 files changed, 118 insertions(+), 37 deletions(-)
 create mode 100644 tests/ui-toml/lint_decimal_readability/clippy.toml
 create mode 100644 tests/ui-toml/lint_decimal_readability/test.rs
 create mode 100644 tests/ui-toml/lint_decimal_readability/test.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index a861a34aeb7..58e91dd32bd 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1138,7 +1138,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box cargo_common_metadata::CargoCommonMetadata);
     store.register_late_pass(|| box multiple_crate_versions::MultipleCrateVersions);
     store.register_late_pass(|| box wildcard_dependencies::WildcardDependencies);
-    store.register_early_pass(|| box literal_representation::LiteralDigitGrouping);
+    let literal_representation_lint_fraction_readability = conf.lint_fraction_readability;
+    store.register_early_pass(move || box literal_representation::LiteralDigitGrouping::new(literal_representation_lint_fraction_readability));
     let literal_representation_threshold = conf.literal_representation_threshold;
     store.register_early_pass(move || box literal_representation::DecimalLiteralRepresentation::new(literal_representation_threshold));
     let enum_variant_name_threshold = conf.enum_variant_name_threshold;
diff --git a/clippy_lints/src/literal_representation.rs b/clippy_lints/src/literal_representation.rs
index e8a741683da..3920e5b6e83 100644
--- a/clippy_lints/src/literal_representation.rs
+++ b/clippy_lints/src/literal_representation.rs
@@ -11,7 +11,7 @@ use rustc_ast::ast::{Expr, ExprKind, Lit, LitKind};
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_session::{declare_lint_pass, declare_tool_lint, impl_lint_pass};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
 
 declare_clippy_lint! {
     /// **What it does:** Warns if a long integral or floating-point constant does
@@ -32,7 +32,7 @@ declare_clippy_lint! {
     /// ```
     pub UNREADABLE_LITERAL,
     pedantic,
-    "long integer literal without underscores"
+    "long literal without underscores"
 }
 
 declare_clippy_lint! {
@@ -208,7 +208,13 @@ impl WarningType {
     }
 }
 
-declare_lint_pass!(LiteralDigitGrouping => [
+#[allow(clippy::module_name_repetitions)]
+#[derive(Copy, Clone)]
+pub struct LiteralDigitGrouping {
+    lint_fraction_readability: bool,
+}
+
+impl_lint_pass!(LiteralDigitGrouping => [
     UNREADABLE_LITERAL,
     INCONSISTENT_DIGIT_GROUPING,
     LARGE_DIGIT_GROUPS,
@@ -223,7 +229,7 @@ impl EarlyLintPass for LiteralDigitGrouping {
         }
 
         if let ExprKind::Lit(ref lit) = expr.kind {
-            Self::check_lit(cx, lit)
+            self.check_lit(cx, lit)
         }
     }
 }
@@ -232,7 +238,13 @@ impl EarlyLintPass for LiteralDigitGrouping {
 const UUID_GROUP_LENS: [usize; 5] = [8, 4, 4, 4, 12];
 
 impl LiteralDigitGrouping {
-    fn check_lit(cx: &EarlyContext<'_>, lit: &Lit) {
+    pub fn new(lint_fraction_readability: bool) -> Self {
+        Self {
+            lint_fraction_readability,
+        }
+    }
+
+    fn check_lit(&self, cx: &EarlyContext<'_>, lit: &Lit) {
         if_chain! {
             if let Some(src) = snippet_opt(cx, lit.span);
             if let Some(mut num_lit) = NumericLiteral::from_lit(&src, &lit);
@@ -247,9 +259,12 @@ impl LiteralDigitGrouping {
 
                 let result = (|| {
 
-                    let integral_group_size = Self::get_group_size(num_lit.integer.split('_'), num_lit.radix)?;
+                    let integral_group_size = Self::get_group_size(num_lit.integer.split('_'), num_lit.radix, true)?;
                     if let Some(fraction) = num_lit.fraction {
-                        let fractional_group_size = Self::get_group_size(fraction.rsplit('_'), num_lit.radix)?;
+                        let fractional_group_size = Self::get_group_size(
+                            fraction.rsplit('_'),
+                            num_lit.radix,
+                            self.lint_fraction_readability)?;
 
                         let consistent = Self::parts_consistent(integral_group_size,
                                                                 fractional_group_size,
@@ -363,7 +378,11 @@ impl LiteralDigitGrouping {
 
     /// Returns the size of the digit groups (or None if ungrouped) if successful,
     /// otherwise returns a `WarningType` for linting.
-    fn get_group_size<'a>(groups: impl Iterator<Item = &'a str>, radix: Radix) -> Result<Option<usize>, WarningType> {
+    fn get_group_size<'a>(
+        groups: impl Iterator<Item = &'a str>,
+        radix: Radix,
+        lint_unreadable: bool,
+    ) -> Result<Option<usize>, WarningType> {
         let mut groups = groups.map(str::len);
 
         let first = groups.next().expect("At least one group");
@@ -380,7 +399,7 @@ impl LiteralDigitGrouping {
             } else {
                 Ok(Some(second))
             }
-        } else if first > 5 {
+        } else if first > 5 && lint_unreadable {
             Err(WarningType::UnreadableLiteral)
         } else {
             Ok(None)
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index fc6304118d9..c9d5f781f1b 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -170,6 +170,8 @@ define_Conf! {
     (warn_on_all_wildcard_imports, "warn_on_all_wildcard_imports": bool, false),
     /// Lint: DISALLOWED_METHOD. The list of blacklisted methods to lint about. NB: `bar` is not here since it has legitimate uses
     (disallowed_methods, "disallowed_methods": Vec<String>, Vec::<String>::new()),
+    /// Lint: UNREADABLE_LITERAL. Should the fraction of a decimal be linted to include separators.
+    (lint_fraction_readability, "lint_fraction_readability": bool, true),
 }
 
 impl Default for Conf {
diff --git a/tests/ui-toml/lint_decimal_readability/clippy.toml b/tests/ui-toml/lint_decimal_readability/clippy.toml
new file mode 100644
index 00000000000..635e282dc06
--- /dev/null
+++ b/tests/ui-toml/lint_decimal_readability/clippy.toml
@@ -0,0 +1 @@
+lint-fraction-readability = false
\ No newline at end of file
diff --git a/tests/ui-toml/lint_decimal_readability/test.rs b/tests/ui-toml/lint_decimal_readability/test.rs
new file mode 100644
index 00000000000..9377eb69b23
--- /dev/null
+++ b/tests/ui-toml/lint_decimal_readability/test.rs
@@ -0,0 +1,22 @@
+#[deny(clippy::unreadable_literal)]
+
+fn allow_inconsistent_digit_grouping() {
+    #![allow(clippy::inconsistent_digit_grouping)]
+    let _pass1 = 100_200_300.123456789;
+}
+
+fn main() {
+    allow_inconsistent_digit_grouping();
+
+    let _pass1 = 100_200_300.100_200_300;
+    let _pass2 = 1.123456789;
+    let _pass3 = 1.0;
+    let _pass4 = 10000.00001;
+    let _pass5 = 1.123456789e1;
+
+    // due to clippy::inconsistent-digit-grouping
+    let _fail1 = 100_200_300.123456789;
+
+    // fail due to the integer part
+    let _fail2 = 100200300.300200100;
+}
diff --git a/tests/ui-toml/lint_decimal_readability/test.stderr b/tests/ui-toml/lint_decimal_readability/test.stderr
new file mode 100644
index 00000000000..9119ef19a7b
--- /dev/null
+++ b/tests/ui-toml/lint_decimal_readability/test.stderr
@@ -0,0 +1,10 @@
+error: digits grouped inconsistently by underscores
+  --> $DIR/test.rs:18:18
+   |
+LL |     let _fail1 = 100_200_300.123456789;
+   |                  ^^^^^^^^^^^^^^^^^^^^^ help: consider: `100_200_300.123_456_789`
+   |
+   = note: `-D clippy::inconsistent-digit-grouping` implied by `-D warnings`
+
+error: aborting due to previous error
+
diff --git a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
index af3d9ecf6e8..eff4da7e658 100644
--- a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
+++ b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
@@ -1,4 +1,4 @@
-error: error reading Clippy's configuration file `$DIR/clippy.toml`: unknown field `foobar`, expected one of `msrv`, `blacklisted-names`, `cognitive-complexity-threshold`, `cyclomatic-complexity-threshold`, `doc-valid-idents`, `too-many-arguments-threshold`, `type-complexity-threshold`, `single-char-binding-names-threshold`, `too-large-for-stack`, `enum-variant-name-threshold`, `enum-variant-size-threshold`, `verbose-bit-mask-threshold`, `literal-representation-threshold`, `trivial-copy-size-limit`, `pass-by-value-size-limit`, `too-many-lines-threshold`, `array-size-threshold`, `vec-box-size-threshold`, `max-trait-bounds`, `max-struct-bools`, `max-fn-params-bools`, `warn-on-all-wildcard-imports`, `disallowed-methods`, `third-party` at line 5 column 1
+error: error reading Clippy's configuration file `$DIR/clippy.toml`: unknown field `foobar`, expected one of `msrv`, `blacklisted-names`, `cognitive-complexity-threshold`, `cyclomatic-complexity-threshold`, `doc-valid-idents`, `too-many-arguments-threshold`, `type-complexity-threshold`, `single-char-binding-names-threshold`, `too-large-for-stack`, `enum-variant-name-threshold`, `enum-variant-size-threshold`, `verbose-bit-mask-threshold`, `literal-representation-threshold`, `trivial-copy-size-limit`, `pass-by-value-size-limit`, `too-many-lines-threshold`, `array-size-threshold`, `vec-box-size-threshold`, `max-trait-bounds`, `max-struct-bools`, `max-fn-params-bools`, `warn-on-all-wildcard-imports`, `disallowed-methods`, `lint-fraction-readability`, `third-party` at line 5 column 1
 
 error: aborting due to previous error
 
diff --git a/tests/ui/unreadable_literal.fixed b/tests/ui/unreadable_literal.fixed
index 4043d53299f..c2e38037add 100644
--- a/tests/ui/unreadable_literal.fixed
+++ b/tests/ui/unreadable_literal.fixed
@@ -10,6 +10,14 @@ macro_rules! foo {
     };
 }
 
+struct Bar(f32);
+
+macro_rules! bar {
+    () => {
+        Bar(100200300400.100200300400500)
+    };
+}
+
 fn main() {
     let _good = (
         0b1011_i64,
@@ -26,10 +34,12 @@ fn main() {
     let _good_sci = 1.1234e1;
     let _bad_sci = 1.123_456e1;
 
-    let _fail9 = 0x00ab_cdef;
-    let _fail10: u32 = 0xBAFE_BAFE;
-    let _fail11 = 0x0abc_deff;
-    let _fail12: i128 = 0x00ab_cabc_abca_bcab_cabc;
+    let _fail1 = 0x00ab_cdef;
+    let _fail2: u32 = 0xBAFE_BAFE;
+    let _fail3 = 0x0abc_deff;
+    let _fail4: i128 = 0x00ab_cabc_abca_bcab_cabc;
+    let _fail5 = 1.100_300_400;
 
     let _ = foo!();
+    let _ = bar!();
 }
diff --git a/tests/ui/unreadable_literal.rs b/tests/ui/unreadable_literal.rs
index e658a5f28c9..8296945b25e 100644
--- a/tests/ui/unreadable_literal.rs
+++ b/tests/ui/unreadable_literal.rs
@@ -10,6 +10,14 @@ macro_rules! foo {
     };
 }
 
+struct Bar(f32);
+
+macro_rules! bar {
+    () => {
+        Bar(100200300400.100200300400500)
+    };
+}
+
 fn main() {
     let _good = (
         0b1011_i64,
@@ -26,10 +34,12 @@ fn main() {
     let _good_sci = 1.1234e1;
     let _bad_sci = 1.123456e1;
 
-    let _fail9 = 0xabcdef;
-    let _fail10: u32 = 0xBAFEBAFE;
-    let _fail11 = 0xabcdeff;
-    let _fail12: i128 = 0xabcabcabcabcabcabc;
+    let _fail1 = 0xabcdef;
+    let _fail2: u32 = 0xBAFEBAFE;
+    let _fail3 = 0xabcdeff;
+    let _fail4: i128 = 0xabcabcabcabcabcabc;
+    let _fail5 = 1.100300400;
 
     let _ = foo!();
+    let _ = bar!();
 }
diff --git a/tests/ui/unreadable_literal.stderr b/tests/ui/unreadable_literal.stderr
index 8645cabeabb..8436aac17ac 100644
--- a/tests/ui/unreadable_literal.stderr
+++ b/tests/ui/unreadable_literal.stderr
@@ -1,5 +1,5 @@
 error: digits of hex or binary literal not grouped by four
-  --> $DIR/unreadable_literal.rs:17:9
+  --> $DIR/unreadable_literal.rs:25:9
    |
 LL |         0x1_234_567,
    |         ^^^^^^^^^^^ help: consider: `0x0123_4567`
@@ -7,7 +7,7 @@ LL |         0x1_234_567,
    = note: `-D clippy::unusual-byte-groupings` implied by `-D warnings`
 
 error: long literal lacking separators
-  --> $DIR/unreadable_literal.rs:25:17
+  --> $DIR/unreadable_literal.rs:33:17
    |
 LL |     let _bad = (0b110110_i64, 0xcafebabe_usize, 123456_f32, 1.234567_f32);
    |                 ^^^^^^^^^^^^ help: consider: `0b11_0110_i64`
@@ -15,52 +15,58 @@ LL |     let _bad = (0b110110_i64, 0xcafebabe_usize, 123456_f32, 1.234567_f32);
    = note: `-D clippy::unreadable-literal` implied by `-D warnings`
 
 error: long literal lacking separators
-  --> $DIR/unreadable_literal.rs:25:31
+  --> $DIR/unreadable_literal.rs:33:31
    |
 LL |     let _bad = (0b110110_i64, 0xcafebabe_usize, 123456_f32, 1.234567_f32);
    |                               ^^^^^^^^^^^^^^^^ help: consider: `0xcafe_babe_usize`
 
 error: long literal lacking separators
-  --> $DIR/unreadable_literal.rs:25:49
+  --> $DIR/unreadable_literal.rs:33:49
    |
 LL |     let _bad = (0b110110_i64, 0xcafebabe_usize, 123456_f32, 1.234567_f32);
    |                                                 ^^^^^^^^^^ help: consider: `123_456_f32`
 
 error: long literal lacking separators
-  --> $DIR/unreadable_literal.rs:25:61
+  --> $DIR/unreadable_literal.rs:33:61
    |
 LL |     let _bad = (0b110110_i64, 0xcafebabe_usize, 123456_f32, 1.234567_f32);
    |                                                             ^^^^^^^^^^^^ help: consider: `1.234_567_f32`
 
 error: long literal lacking separators
-  --> $DIR/unreadable_literal.rs:27:20
+  --> $DIR/unreadable_literal.rs:35:20
    |
 LL |     let _bad_sci = 1.123456e1;
    |                    ^^^^^^^^^^ help: consider: `1.123_456e1`
 
 error: long literal lacking separators
-  --> $DIR/unreadable_literal.rs:29:18
+  --> $DIR/unreadable_literal.rs:37:18
    |
-LL |     let _fail9 = 0xabcdef;
+LL |     let _fail1 = 0xabcdef;
    |                  ^^^^^^^^ help: consider: `0x00ab_cdef`
 
 error: long literal lacking separators
-  --> $DIR/unreadable_literal.rs:30:24
+  --> $DIR/unreadable_literal.rs:38:23
    |
-LL |     let _fail10: u32 = 0xBAFEBAFE;
-   |                        ^^^^^^^^^^ help: consider: `0xBAFE_BAFE`
+LL |     let _fail2: u32 = 0xBAFEBAFE;
+   |                       ^^^^^^^^^^ help: consider: `0xBAFE_BAFE`
 
 error: long literal lacking separators
-  --> $DIR/unreadable_literal.rs:31:19
+  --> $DIR/unreadable_literal.rs:39:18
    |
-LL |     let _fail11 = 0xabcdeff;
-   |                   ^^^^^^^^^ help: consider: `0x0abc_deff`
+LL |     let _fail3 = 0xabcdeff;
+   |                  ^^^^^^^^^ help: consider: `0x0abc_deff`
 
 error: long literal lacking separators
-  --> $DIR/unreadable_literal.rs:32:25
+  --> $DIR/unreadable_literal.rs:40:24
    |
-LL |     let _fail12: i128 = 0xabcabcabcabcabcabc;
-   |                         ^^^^^^^^^^^^^^^^^^^^ help: consider: `0x00ab_cabc_abca_bcab_cabc`
+LL |     let _fail4: i128 = 0xabcabcabcabcabcabc;
+   |                        ^^^^^^^^^^^^^^^^^^^^ help: consider: `0x00ab_cabc_abca_bcab_cabc`
 
-error: aborting due to 10 previous errors
+error: long literal lacking separators
+  --> $DIR/unreadable_literal.rs:41:18
+   |
+LL |     let _fail5 = 1.100300400;
+   |                  ^^^^^^^^^^^ help: consider: `1.100_300_400`
+
+error: aborting due to 11 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 18383c69c1ebf0b6bc0f1ecdeee062f0767a69e8 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Fri, 4 Dec 2020 22:05:52 +0000
Subject: Updated code for CI

---
 clippy_lints/src/literal_representation.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/literal_representation.rs b/clippy_lints/src/literal_representation.rs
index 3920e5b6e83..87a957a9bd2 100644
--- a/clippy_lints/src/literal_representation.rs
+++ b/clippy_lints/src/literal_representation.rs
@@ -244,7 +244,7 @@ impl LiteralDigitGrouping {
         }
     }
 
-    fn check_lit(&self, cx: &EarlyContext<'_>, lit: &Lit) {
+    fn check_lit(self, cx: &EarlyContext<'_>, lit: &Lit) {
         if_chain! {
             if let Some(src) = snippet_opt(cx, lit.span);
             if let Some(mut num_lit) = NumericLiteral::from_lit(&src, &lit);
-- 
cgit 1.4.1-3-g733a5


From 898b7c594cfdf1eb56d24a4c6fa02678cf5029a8 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Sat, 5 Dec 2020 20:59:53 +0000
Subject: Renamed the configuraiton to unreadable-literal-lint-fractions

---
 clippy_lints/src/lib.rs                                | 2 +-
 clippy_lints/src/utils/conf.rs                         | 2 +-
 tests/ui-toml/lint_decimal_readability/clippy.toml     | 2 +-
 tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 58e91dd32bd..2b99ed570b1 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1138,7 +1138,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box cargo_common_metadata::CargoCommonMetadata);
     store.register_late_pass(|| box multiple_crate_versions::MultipleCrateVersions);
     store.register_late_pass(|| box wildcard_dependencies::WildcardDependencies);
-    let literal_representation_lint_fraction_readability = conf.lint_fraction_readability;
+    let literal_representation_lint_fraction_readability = conf.unreadable_literal_lint_fractions;
     store.register_early_pass(move || box literal_representation::LiteralDigitGrouping::new(literal_representation_lint_fraction_readability));
     let literal_representation_threshold = conf.literal_representation_threshold;
     store.register_early_pass(move || box literal_representation::DecimalLiteralRepresentation::new(literal_representation_threshold));
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index c9d5f781f1b..6403ff6dad1 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -171,7 +171,7 @@ define_Conf! {
     /// Lint: DISALLOWED_METHOD. The list of blacklisted methods to lint about. NB: `bar` is not here since it has legitimate uses
     (disallowed_methods, "disallowed_methods": Vec<String>, Vec::<String>::new()),
     /// Lint: UNREADABLE_LITERAL. Should the fraction of a decimal be linted to include separators.
-    (lint_fraction_readability, "lint_fraction_readability": bool, true),
+    (unreadable_literal_lint_fractions, "unreadable_literal_lint_fractions": bool, true),
 }
 
 impl Default for Conf {
diff --git a/tests/ui-toml/lint_decimal_readability/clippy.toml b/tests/ui-toml/lint_decimal_readability/clippy.toml
index 635e282dc06..6feaf7d5c0c 100644
--- a/tests/ui-toml/lint_decimal_readability/clippy.toml
+++ b/tests/ui-toml/lint_decimal_readability/clippy.toml
@@ -1 +1 @@
-lint-fraction-readability = false
\ No newline at end of file
+unreadable-literal-lint-fractions = false
\ No newline at end of file
diff --git a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
index eff4da7e658..7b3c476461d 100644
--- a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
+++ b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
@@ -1,4 +1,4 @@
-error: error reading Clippy's configuration file `$DIR/clippy.toml`: unknown field `foobar`, expected one of `msrv`, `blacklisted-names`, `cognitive-complexity-threshold`, `cyclomatic-complexity-threshold`, `doc-valid-idents`, `too-many-arguments-threshold`, `type-complexity-threshold`, `single-char-binding-names-threshold`, `too-large-for-stack`, `enum-variant-name-threshold`, `enum-variant-size-threshold`, `verbose-bit-mask-threshold`, `literal-representation-threshold`, `trivial-copy-size-limit`, `pass-by-value-size-limit`, `too-many-lines-threshold`, `array-size-threshold`, `vec-box-size-threshold`, `max-trait-bounds`, `max-struct-bools`, `max-fn-params-bools`, `warn-on-all-wildcard-imports`, `disallowed-methods`, `lint-fraction-readability`, `third-party` at line 5 column 1
+error: error reading Clippy's configuration file `$DIR/clippy.toml`: unknown field `foobar`, expected one of `msrv`, `blacklisted-names`, `cognitive-complexity-threshold`, `cyclomatic-complexity-threshold`, `doc-valid-idents`, `too-many-arguments-threshold`, `type-complexity-threshold`, `single-char-binding-names-threshold`, `too-large-for-stack`, `enum-variant-name-threshold`, `enum-variant-size-threshold`, `verbose-bit-mask-threshold`, `literal-representation-threshold`, `trivial-copy-size-limit`, `pass-by-value-size-limit`, `too-many-lines-threshold`, `array-size-threshold`, `vec-box-size-threshold`, `max-trait-bounds`, `max-struct-bools`, `max-fn-params-bools`, `warn-on-all-wildcard-imports`, `disallowed-methods`, `unreadable-literal-lint-fractions`, `third-party` at line 5 column 1
 
 error: aborting due to previous error
 
-- 
cgit 1.4.1-3-g733a5


From e90b977a082eac4283a52b53d4da3a507a8ee9a0 Mon Sep 17 00:00:00 2001
From: Takayuki Nakata <f.seasons017@gmail.com>
Date: Sun, 22 Nov 2020 22:04:18 +0900
Subject: Fix FP in `unnecessary_lazy_evaluations`

---
 clippy_lints/src/utils/usage.rs             | 21 ++++++++++++++-------
 tests/ui/unnecessary_lazy_eval_unfixable.rs |  4 ++++
 2 files changed, 18 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/usage.rs b/clippy_lints/src/utils/usage.rs
index a7d0ea6ccfb..fc0db7f64ec 100644
--- a/clippy_lints/src/utils/usage.rs
+++ b/clippy_lints/src/utils/usage.rs
@@ -116,20 +116,27 @@ pub struct ParamBindingIdCollector {
 }
 impl<'tcx> ParamBindingIdCollector {
     fn collect_binding_hir_ids(body: &'tcx hir::Body<'tcx>) -> Vec<hir::HirId> {
-        let mut finder = ParamBindingIdCollector {
-            binding_hir_ids: Vec::new(),
-        };
-        finder.visit_body(body);
-        finder.binding_hir_ids
+        let mut hir_ids: Vec<hir::HirId> = Vec::new();
+        for param in body.params.iter() {
+            let mut finder = ParamBindingIdCollector {
+                binding_hir_ids: Vec::new(),
+            };
+            finder.visit_param(param);
+            for hir_id in &finder.binding_hir_ids {
+                hir_ids.push(*hir_id);
+            }
+        }
+        hir_ids
     }
 }
 impl<'tcx> intravisit::Visitor<'tcx> for ParamBindingIdCollector {
     type Map = Map<'tcx>;
 
-    fn visit_param(&mut self, param: &'tcx hir::Param<'tcx>) {
-        if let hir::PatKind::Binding(_, hir_id, ..) = param.pat.kind {
+    fn visit_pat(&mut self, pat: &'tcx hir::Pat<'tcx>) {
+        if let hir::PatKind::Binding(_, hir_id, ..) = pat.kind {
             self.binding_hir_ids.push(hir_id);
         }
+        intravisit::walk_pat(self, pat);
     }
 
     fn nested_visit_map(&mut self) -> intravisit::NestedVisitorMap<Self::Map> {
diff --git a/tests/ui/unnecessary_lazy_eval_unfixable.rs b/tests/ui/unnecessary_lazy_eval_unfixable.rs
index 2e923bc97a2..b05dd143bfd 100644
--- a/tests/ui/unnecessary_lazy_eval_unfixable.rs
+++ b/tests/ui/unnecessary_lazy_eval_unfixable.rs
@@ -15,4 +15,8 @@ fn main() {
     }
     let _ = Ok(1).unwrap_or_else(|e::E| 2);
     let _ = Ok(1).unwrap_or_else(|SomeStruct { .. }| 2);
+
+    // Fix #6343
+    let arr = [(Some(1),)];
+    Some(&0).and_then(|&i| arr[i].0);
 }
-- 
cgit 1.4.1-3-g733a5


From ba1249465c036b2ccc6daf34749ea9d5df77f358 Mon Sep 17 00:00:00 2001
From: Takayuki Nakata <f.seasons017@gmail.com>
Date: Mon, 7 Dec 2020 16:45:10 +0900
Subject: cargo dev fmt

---
 clippy_lints/src/doc.rs                    | 2 +-
 clippy_lints/src/missing_const_for_fn.rs   | 2 +-
 clippy_lints/src/needless_pass_by_value.rs | 7 ++++---
 clippy_lints/src/pass_by_ref_or_value.rs   | 7 ++++---
 clippy_lints/src/redundant_clone.rs        | 5 ++++-
 clippy_lints/src/types.rs                  | 4 +++-
 clippy_lints/src/unnecessary_wraps.rs      | 5 ++++-
 clippy_lints/src/utils/ast_utils.rs        | 5 ++++-
 clippy_lints/src/utils/mod.rs              | 2 +-
 9 files changed, 26 insertions(+), 13 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/doc.rs b/clippy_lints/src/doc.rs
index edecba57e44..55e4755c278 100644
--- a/clippy_lints/src/doc.rs
+++ b/clippy_lints/src/doc.rs
@@ -480,7 +480,7 @@ fn check_code(cx: &LateContext<'_>, text: &str, span: Span) {
                     | ItemKind::ForeignMod(..) => return false,
                     // We found a main function ...
                     ItemKind::Fn(_, sig, _, Some(block)) if item.ident.name == sym::main => {
-                        let is_async = matches!(sig.header.asyncness, Async::Yes{..});
+                        let is_async = matches!(sig.header.asyncness, Async::Yes { .. });
                         let returns_nothing = match &sig.decl.output {
                             FnRetTy::Default(..) => true,
                             FnRetTy::Ty(ty) if ty.kind.is_unit() => true,
diff --git a/clippy_lints/src/missing_const_for_fn.rs b/clippy_lints/src/missing_const_for_fn.rs
index 25245b3dbf0..38e2ce563ee 100644
--- a/clippy_lints/src/missing_const_for_fn.rs
+++ b/clippy_lints/src/missing_const_for_fn.rs
@@ -99,7 +99,7 @@ impl<'tcx> LateLintPass<'tcx> for MissingConstForFn {
                 let has_const_generic_params = generics
                     .params
                     .iter()
-                    .any(|param| matches!(param.kind, GenericParamKind::Const{ .. }));
+                    .any(|param| matches!(param.kind, GenericParamKind::Const { .. }));
 
                 if already_const(header) || has_const_generic_params {
                     return;
diff --git a/clippy_lints/src/needless_pass_by_value.rs b/clippy_lints/src/needless_pass_by_value.rs
index 532c0266946..5043b7b1fc3 100644
--- a/clippy_lints/src/needless_pass_by_value.rs
+++ b/clippy_lints/src/needless_pass_by_value.rs
@@ -90,9 +90,10 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByValue {
 
         // Exclude non-inherent impls
         if let Some(Node::Item(item)) = cx.tcx.hir().find(cx.tcx.hir().get_parent_node(hir_id)) {
-            if matches!(item.kind, ItemKind::Impl{ of_trait: Some(_), .. } |
-                ItemKind::Trait(..))
-            {
+            if matches!(
+                item.kind,
+                ItemKind::Impl { of_trait: Some(_), .. } | ItemKind::Trait(..)
+            ) {
                 return;
             }
         }
diff --git a/clippy_lints/src/pass_by_ref_or_value.rs b/clippy_lints/src/pass_by_ref_or_value.rs
index f03facc235e..6a17d654ac9 100644
--- a/clippy_lints/src/pass_by_ref_or_value.rs
+++ b/clippy_lints/src/pass_by_ref_or_value.rs
@@ -244,9 +244,10 @@ impl<'tcx> LateLintPass<'tcx> for PassByRefOrValue {
 
         // Exclude non-inherent impls
         if let Some(Node::Item(item)) = cx.tcx.hir().find(cx.tcx.hir().get_parent_node(hir_id)) {
-            if matches!(item.kind, ItemKind::Impl{ of_trait: Some(_), .. } |
-            ItemKind::Trait(..))
-            {
+            if matches!(
+                item.kind,
+                ItemKind::Impl { of_trait: Some(_), .. } | ItemKind::Trait(..)
+            ) {
                 return;
             }
         }
diff --git a/clippy_lints/src/redundant_clone.rs b/clippy_lints/src/redundant_clone.rs
index f0e507105a6..06adbb523d7 100644
--- a/clippy_lints/src/redundant_clone.rs
+++ b/clippy_lints/src/redundant_clone.rs
@@ -390,7 +390,10 @@ impl<'tcx> mir::visit::Visitor<'tcx> for LocalUseVisitor {
         let local = place.local;
 
         if local == self.used.0
-            && !matches!(ctx, PlaceContext::MutatingUse(MutatingUseContext::Drop) | PlaceContext::NonUse(_))
+            && !matches!(
+                ctx,
+                PlaceContext::MutatingUse(MutatingUseContext::Drop) | PlaceContext::NonUse(_)
+            )
         {
             self.used.1 = true;
         }
diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs
index 74ba53e6a9a..fd74783335d 100644
--- a/clippy_lints/src/types.rs
+++ b/clippy_lints/src/types.rs
@@ -1104,7 +1104,9 @@ fn is_empty_block(expr: &Expr<'_>) -> bool {
         expr.kind,
         ExprKind::Block(
             Block {
-                stmts: &[], expr: None, ..
+                stmts: &[],
+                expr: None,
+                ..
             },
             _,
         )
diff --git a/clippy_lints/src/unnecessary_wraps.rs b/clippy_lints/src/unnecessary_wraps.rs
index 5d801511a0b..e763da593d4 100644
--- a/clippy_lints/src/unnecessary_wraps.rs
+++ b/clippy_lints/src/unnecessary_wraps.rs
@@ -74,7 +74,10 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryWraps {
         }
 
         if let Some(Node::Item(item)) = cx.tcx.hir().find(cx.tcx.hir().get_parent_node(hir_id)) {
-            if matches!(item.kind, ItemKind::Impl{ of_trait: Some(_), ..} | ItemKind::Trait(..)) {
+            if matches!(
+                item.kind,
+                ItemKind::Impl { of_trait: Some(_), .. } | ItemKind::Trait(..)
+            ) {
                 return;
             }
         }
diff --git a/clippy_lints/src/utils/ast_utils.rs b/clippy_lints/src/utils/ast_utils.rs
index 31b4e25411b..f0267e4c792 100644
--- a/clippy_lints/src/utils/ast_utils.rs
+++ b/clippy_lints/src/utils/ast_utils.rs
@@ -408,7 +408,10 @@ pub fn eq_use_tree_kind(l: &UseTreeKind, r: &UseTreeKind) -> bool {
 }
 
 pub fn eq_defaultness(l: Defaultness, r: Defaultness) -> bool {
-    matches!((l, r), (Defaultness::Final, Defaultness::Final) | (Defaultness::Default(_), Defaultness::Default(_)))
+    matches!(
+        (l, r),
+        (Defaultness::Final, Defaultness::Final) | (Defaultness::Default(_), Defaultness::Default(_))
+    )
 }
 
 pub fn eq_vis(l: &Visibility, r: &Visibility) -> bool {
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index 3a6b64c90e8..007e72d129f 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -1500,7 +1500,7 @@ pub fn is_no_std_crate(krate: &Crate<'_>) -> bool {
 /// ```
 pub fn is_trait_impl_item(cx: &LateContext<'_>, hir_id: HirId) -> bool {
     if let Some(Node::Item(item)) = cx.tcx.hir().find(cx.tcx.hir().get_parent_node(hir_id)) {
-        matches!(item.kind, ItemKind::Impl{ of_trait: Some(_), .. })
+        matches!(item.kind, ItemKind::Impl { of_trait: Some(_), .. })
     } else {
         false
     }
-- 
cgit 1.4.1-3-g733a5


From b81141cfb91cbf39e87e32a27530537f18e85405 Mon Sep 17 00:00:00 2001
From: Josias <me@josias.dev>
Date: Sun, 22 Nov 2020 19:02:57 +0100
Subject: Add lint print_stderr

Resolves #6348
Almost identical to print_stdout, this lint applies to the
`eprintln!` and `eprint!` macros rather than `println!` and
`print!`.
---
 CHANGELOG.md                 |  1 +
 clippy_lints/src/lib.rs      |  2 ++
 clippy_lints/src/write.rs    | 23 +++++++++++++++++++++++
 tests/ui/print_stderr.rs     |  6 ++++++
 tests/ui/print_stderr.stderr | 16 ++++++++++++++++
 5 files changed, 48 insertions(+)
 create mode 100644 tests/ui/print_stderr.rs
 create mode 100644 tests/ui/print_stderr.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index c7e02aaf4e1..1f2c4f310de 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2006,6 +2006,7 @@ Released 2018-09-13
 [`possible_missing_comma`]: https://rust-lang.github.io/rust-clippy/master/index.html#possible_missing_comma
 [`precedence`]: https://rust-lang.github.io/rust-clippy/master/index.html#precedence
 [`print_literal`]: https://rust-lang.github.io/rust-clippy/master/index.html#print_literal
+[`print_stderr`]: https://rust-lang.github.io/rust-clippy/master/index.html#print_stderr
 [`print_stdout`]: https://rust-lang.github.io/rust-clippy/master/index.html#print_stdout
 [`print_with_newline`]: https://rust-lang.github.io/rust-clippy/master/index.html#print_with_newline
 [`println_empty_string`]: https://rust-lang.github.io/rust-clippy/master/index.html#println_empty_string
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 2b99ed570b1..0e630a352fe 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -934,6 +934,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &wildcard_imports::WILDCARD_IMPORTS,
         &write::PRINTLN_EMPTY_STRING,
         &write::PRINT_LITERAL,
+        &write::PRINT_STDERR,
         &write::PRINT_STDOUT,
         &write::PRINT_WITH_NEWLINE,
         &write::USE_DEBUG,
@@ -1247,6 +1248,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&types::RC_BUFFER),
         LintId::of(&unwrap_in_result::UNWRAP_IN_RESULT),
         LintId::of(&verbose_file_reads::VERBOSE_FILE_READS),
+        LintId::of(&write::PRINT_STDERR),
         LintId::of(&write::PRINT_STDOUT),
         LintId::of(&write::USE_DEBUG),
     ]);
diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs
index ff414f748ef..2248bc1e32e 100644
--- a/clippy_lints/src/write.rs
+++ b/clippy_lints/src/write.rs
@@ -75,6 +75,24 @@ declare_clippy_lint! {
     "printing on stdout"
 }
 
+declare_clippy_lint! {
+    /// **What it does:** Checks for printing on *stderr*. The purpose of this lint
+    /// is to catch debugging remnants.
+    ///
+    /// **Why is this bad?** People often print on *stderr* while debugging an
+    /// application and might forget to remove those prints afterward.
+    ///
+    /// **Known problems:** Only catches `eprint!` and `eprintln!` calls.
+    ///
+    /// **Example:**
+    /// ```rust
+    /// eprintln!("Hello world!");
+    /// ```
+    pub PRINT_STDERR,
+    restriction,
+    "printing on stderr"
+}
+
 declare_clippy_lint! {
     /// **What it does:** Checks for use of `Debug` formatting. The purpose of this
     /// lint is to catch debugging remnants.
@@ -201,6 +219,7 @@ impl_lint_pass!(Write => [
     PRINT_WITH_NEWLINE,
     PRINTLN_EMPTY_STRING,
     PRINT_STDOUT,
+    PRINT_STDERR,
     USE_DEBUG,
     PRINT_LITERAL,
     WRITE_WITH_NEWLINE,
@@ -260,6 +279,10 @@ impl EarlyLintPass for Write {
                     );
                 }
             }
+        } else if mac.path == sym!(eprintln) {
+            span_lint(cx, PRINT_STDERR, mac.span(), "use of `eprintln!`");
+        } else if mac.path == sym!(eprint) {
+            span_lint(cx, PRINT_STDERR, mac.span(), "use of `eprint!`");
         } else if mac.path == sym!(print) {
             if !is_build_script(cx) {
                 span_lint(cx, PRINT_STDOUT, mac.span(), "use of `print!`");
diff --git a/tests/ui/print_stderr.rs b/tests/ui/print_stderr.rs
new file mode 100644
index 00000000000..e53f46b1c2f
--- /dev/null
+++ b/tests/ui/print_stderr.rs
@@ -0,0 +1,6 @@
+#![warn(clippy::print_stderr)]
+
+fn main() {
+    eprintln!("Hello");
+    eprint!("World");
+}
diff --git a/tests/ui/print_stderr.stderr b/tests/ui/print_stderr.stderr
new file mode 100644
index 00000000000..7252fce72c6
--- /dev/null
+++ b/tests/ui/print_stderr.stderr
@@ -0,0 +1,16 @@
+error: use of `eprintln!`
+  --> $DIR/print_stderr.rs:4:5
+   |
+LL |     eprintln!("Hello");
+   |     ^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::print-stderr` implied by `-D warnings`
+
+error: use of `eprint!`
+  --> $DIR/print_stderr.rs:5:5
+   |
+LL |     eprint!("World");
+   |     ^^^^^^^^^^^^^^^^
+
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 7063c36c912990bd67327a41445706a451fe5b48 Mon Sep 17 00:00:00 2001
From: Josias <me@josias.dev>
Date: Fri, 4 Dec 2020 15:39:09 +0100
Subject: Add eprint! to print_with_newline lint

---
 clippy_lints/src/write.rs           |  20 ++++++
 tests/ui/eprint_with_newline.rs     |  49 +++++++++++++++
 tests/ui/eprint_with_newline.stderr | 121 ++++++++++++++++++++++++++++++++++++
 3 files changed, 190 insertions(+)
 create mode 100644 tests/ui/eprint_with_newline.rs
 create mode 100644 tests/ui/eprint_with_newline.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs
index 2248bc1e32e..0fd56f78572 100644
--- a/clippy_lints/src/write.rs
+++ b/clippy_lints/src/write.rs
@@ -283,6 +283,26 @@ impl EarlyLintPass for Write {
             span_lint(cx, PRINT_STDERR, mac.span(), "use of `eprintln!`");
         } else if mac.path == sym!(eprint) {
             span_lint(cx, PRINT_STDERR, mac.span(), "use of `eprint!`");
+            if let (Some(fmt_str), _) = self.check_tts(cx, mac.args.inner_tokens(), false) {
+                if check_newlines(&fmt_str) {
+                    span_lint_and_then(
+                        cx,
+                        PRINT_WITH_NEWLINE,
+                        mac.span(),
+                        "using `eprint!()` with a format string that ends in a single newline",
+                        |err| {
+                            err.multipart_suggestion(
+                                "use `eprintln!` instead",
+                                vec![
+                                    (mac.path.span, String::from("eprintln")),
+                                    (newline_span(&fmt_str), String::new()),
+                                ],
+                                Applicability::MachineApplicable,
+                            );
+                        },
+                    );
+                }
+            }
         } else if mac.path == sym!(print) {
             if !is_build_script(cx) {
                 span_lint(cx, PRINT_STDOUT, mac.span(), "use of `print!`");
diff --git a/tests/ui/eprint_with_newline.rs b/tests/ui/eprint_with_newline.rs
new file mode 100644
index 00000000000..8df32649ad9
--- /dev/null
+++ b/tests/ui/eprint_with_newline.rs
@@ -0,0 +1,49 @@
+#![allow(clippy::print_literal)]
+#![warn(clippy::print_with_newline)]
+
+fn main() {
+    eprint!("Hello\n");
+    eprint!("Hello {}\n", "world");
+    eprint!("Hello {} {}\n", "world", "#2");
+    eprint!("{}\n", 1265);
+    eprint!("\n");
+
+    // these are all fine
+    eprint!("");
+    eprint!("Hello");
+    eprintln!("Hello");
+    eprintln!("Hello\n");
+    eprintln!("Hello {}\n", "world");
+    eprint!("Issue\n{}", 1265);
+    eprint!("{}", 1265);
+    eprint!("\n{}", 1275);
+    eprint!("\n\n");
+    eprint!("like eof\n\n");
+    eprint!("Hello {} {}\n\n", "world", "#2");
+    eprintln!("\ndon't\nwarn\nfor\nmultiple\nnewlines\n"); // #3126
+    eprintln!("\nbla\n\n"); // #3126
+
+    // Escaping
+    eprint!("\\n"); // #3514
+    eprint!("\\\n"); // should fail
+    eprint!("\\\\n");
+
+    // Raw strings
+    eprint!(r"\n"); // #3778
+
+    // Literal newlines should also fail
+    eprint!(
+        "
+"
+    );
+    eprint!(
+        r"
+"
+    );
+
+    // Don't warn on CRLF (#4208)
+    eprint!("\r\n");
+    eprint!("foo\r\n");
+    eprint!("\\r\n"); //~ ERROR
+    eprint!("foo\rbar\n") // ~ ERROR
+}
diff --git a/tests/ui/eprint_with_newline.stderr b/tests/ui/eprint_with_newline.stderr
new file mode 100644
index 00000000000..31811d1d92a
--- /dev/null
+++ b/tests/ui/eprint_with_newline.stderr
@@ -0,0 +1,121 @@
+error: using `eprint!()` with a format string that ends in a single newline
+  --> $DIR/eprint_with_newline.rs:5:5
+   |
+LL |     eprint!("Hello/n");
+   |     ^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::print-with-newline` implied by `-D warnings`
+help: use `eprintln!` instead
+   |
+LL |     eprintln!("Hello");
+   |     ^^^^^^^^       --
+
+error: using `eprint!()` with a format string that ends in a single newline
+  --> $DIR/eprint_with_newline.rs:6:5
+   |
+LL |     eprint!("Hello {}/n", "world");
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `eprintln!` instead
+   |
+LL |     eprintln!("Hello {}", "world");
+   |     ^^^^^^^^          --
+
+error: using `eprint!()` with a format string that ends in a single newline
+  --> $DIR/eprint_with_newline.rs:7:5
+   |
+LL |     eprint!("Hello {} {}/n", "world", "#2");
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `eprintln!` instead
+   |
+LL |     eprintln!("Hello {} {}", "world", "#2");
+   |     ^^^^^^^^             --
+
+error: using `eprint!()` with a format string that ends in a single newline
+  --> $DIR/eprint_with_newline.rs:8:5
+   |
+LL |     eprint!("{}/n", 1265);
+   |     ^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `eprintln!` instead
+   |
+LL |     eprintln!("{}", 1265);
+   |     ^^^^^^^^    --
+
+error: using `eprint!()` with a format string that ends in a single newline
+  --> $DIR/eprint_with_newline.rs:9:5
+   |
+LL |     eprint!("/n");
+   |     ^^^^^^^^^^^^^
+   |
+help: use `eprintln!` instead
+   |
+LL |     eprintln!();
+   |     ^^^^^^^^ --
+
+error: using `eprint!()` with a format string that ends in a single newline
+  --> $DIR/eprint_with_newline.rs:28:5
+   |
+LL |     eprint!("//n"); // should fail
+   |     ^^^^^^^^^^^^^^^
+   |
+help: use `eprintln!` instead
+   |
+LL |     eprintln!("/"); // should fail
+   |     ^^^^^^^^    --
+
+error: using `eprint!()` with a format string that ends in a single newline
+  --> $DIR/eprint_with_newline.rs:35:5
+   |
+LL | /     eprint!(
+LL | |         "
+LL | | "
+LL | |     );
+   | |_____^
+   |
+help: use `eprintln!` instead
+   |
+LL |     eprintln!(
+LL |         ""
+   |
+
+error: using `eprint!()` with a format string that ends in a single newline
+  --> $DIR/eprint_with_newline.rs:39:5
+   |
+LL | /     eprint!(
+LL | |         r"
+LL | | "
+LL | |     );
+   | |_____^
+   |
+help: use `eprintln!` instead
+   |
+LL |     eprintln!(
+LL |         r""
+   |
+
+error: using `eprint!()` with a format string that ends in a single newline
+  --> $DIR/eprint_with_newline.rs:47:5
+   |
+LL |     eprint!("/r/n"); //~ ERROR
+   |     ^^^^^^^^^^^^^^^^
+   |
+help: use `eprintln!` instead
+   |
+LL |     eprintln!("/r"); //~ ERROR
+   |     ^^^^^^^^     --
+
+error: using `eprint!()` with a format string that ends in a single newline
+  --> $DIR/eprint_with_newline.rs:48:5
+   |
+LL |     eprint!("foo/rbar/n") // ~ ERROR
+   |     ^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `eprintln!` instead
+   |
+LL |     eprintln!("foo/rbar") // ~ ERROR
+   |     ^^^^^^^^          --
+
+error: aborting due to 10 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From e58c7dd1685cb19e2ec87568cbc2cbd0aba3e2c7 Mon Sep 17 00:00:00 2001
From: Dobe Peter <dobepeter@gmail.com>
Date: Sat, 31 Oct 2020 20:31:34 +0100
Subject: panic_in_result_fn: Extend to also check usages of [debug_]assert*
 macros

Also, the macro-finding logic has been moved to the util module, for
use by future lints.
---
 clippy_lints/src/panic_in_result_fn.rs             | 68 ++++++++++------------
 clippy_lints/src/utils/mod.rs                      | 33 ++++++++++-
 tests/ui/panic_in_result_fn.stderr                 | 24 ++++----
 tests/ui/panic_in_result_fn_assertions.rs          | 48 +++++++++++++++
 tests/ui/panic_in_result_fn_assertions.stderr      | 57 ++++++++++++++++++
 tests/ui/panic_in_result_fn_debug_assertions.rs    | 48 +++++++++++++++
 .../ui/panic_in_result_fn_debug_assertions.stderr  | 57 ++++++++++++++++++
 7 files changed, 285 insertions(+), 50 deletions(-)
 create mode 100644 tests/ui/panic_in_result_fn_assertions.rs
 create mode 100644 tests/ui/panic_in_result_fn_assertions.stderr
 create mode 100644 tests/ui/panic_in_result_fn_debug_assertions.rs
 create mode 100644 tests/ui/panic_in_result_fn_debug_assertions.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/panic_in_result_fn.rs b/clippy_lints/src/panic_in_result_fn.rs
index 72dfccc1089..cdabb0d0dd6 100644
--- a/clippy_lints/src/panic_in_result_fn.rs
+++ b/clippy_lints/src/panic_in_result_fn.rs
@@ -1,18 +1,16 @@
-use crate::utils::{is_expn_of, is_type_diagnostic_item, return_ty, span_lint_and_then};
+use crate::utils::{find_macro_calls, is_type_diagnostic_item, return_ty, span_lint_and_then};
 use rustc_hir as hir;
-use rustc_hir::intravisit::{self, FnKind, NestedVisitorMap, Visitor};
-use rustc_hir::Expr;
+use rustc_hir::intravisit::FnKind;
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::hir::map::Map;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::{sym, Span};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for usage of `panic!`, `unimplemented!`, `todo!` or `unreachable!` in a function of type result.
+    /// **What it does:** Checks for usage of `panic!`, `unimplemented!`, `todo!`, `unreachable!` or assertions in a function of type result.
     ///
-    /// **Why is this bad?** For some codebases, it is desirable for functions of type result to return an error instead of crashing. Hence unimplemented, panic and unreachable should be avoided.
+    /// **Why is this bad?** For some codebases, it is desirable for functions of type result to return an error instead of crashing. Hence panicking macros should be avoided.
     ///
-    /// **Known problems:** None.
+    /// **Known problems:** Functions called from a function returning a `Result` may invoke a panicking macro. This is not checked.
     ///
     /// **Example:**
     ///
@@ -22,9 +20,15 @@ declare_clippy_lint! {
     ///     panic!("error");
     /// }
     /// ```
+    /// Use instead:
+    /// ```rust
+    /// fn result_without_panic() -> Result<bool, String> {
+    ///     Err(String::from("error"))
+    /// }
+    /// ```
     pub PANIC_IN_RESULT_FN,
     restriction,
-    "functions of type `Result<..>` that contain `panic!()`, `todo!()` or `unreachable()` or `unimplemented()` "
+    "functions of type `Result<..>` that contain `panic!()`, `todo!()`, `unreachable()`, `unimplemented()` or assertion"
 }
 
 declare_lint_pass!(PanicInResultFn  => [PANIC_IN_RESULT_FN]);
@@ -47,43 +51,33 @@ impl<'tcx> LateLintPass<'tcx> for PanicInResultFn {
     }
 }
 
-struct FindPanicUnimplementedUnreachable {
-    result: Vec<Span>,
-}
-
-impl<'tcx> Visitor<'tcx> for FindPanicUnimplementedUnreachable {
-    type Map = Map<'tcx>;
-
-    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
-        if ["unimplemented", "unreachable", "panic", "todo"]
-            .iter()
-            .any(|fun| is_expn_of(expr.span, fun).is_some())
-        {
-            self.result.push(expr.span);
-        }
-        // and check sub-expressions
-        intravisit::walk_expr(self, expr);
-    }
-
-    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-        NestedVisitorMap::None
-    }
-}
-
 fn lint_impl_body<'tcx>(cx: &LateContext<'tcx>, impl_span: Span, body: &'tcx hir::Body<'tcx>) {
-    let mut panics = FindPanicUnimplementedUnreachable { result: Vec::new() };
-    panics.visit_expr(&body.value);
-    if !panics.result.is_empty() {
+    let panics = find_macro_calls(
+        vec![
+            "unimplemented",
+            "unreachable",
+            "panic",
+            "todo",
+            "assert",
+            "assert_eq",
+            "assert_ne",
+            "debug_assert",
+            "debug_assert_eq",
+            "debug_assert_ne",
+        ],
+        body,
+    );
+    if !panics.is_empty() {
         span_lint_and_then(
             cx,
             PANIC_IN_RESULT_FN,
             impl_span,
-            "used `unimplemented!()`, `unreachable!()`, `todo!()` or `panic!()` in a function that returns `Result`",
+            "used `unimplemented!()`, `unreachable!()`, `todo!()`, `panic!()` or assertion in a function that returns `Result`",
             move |diag| {
                 diag.help(
-                    "`unimplemented!()`, `unreachable!()`, `todo!()` or `panic!()` should not be used in a function that returns `Result` as `Result` is expected to return an error instead of crashing",
+                    "`unimplemented!()`, `unreachable!()`, `todo!()`, `panic!()` or assertions should not be used in a function that returns `Result` as `Result` is expected to return an error instead of crashing",
                 );
-                diag.span_note(panics.result, "return Err() instead of panicking");
+                diag.span_note(panics, "return Err() instead of panicking");
             },
         );
     }
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index 007e72d129f..e47d71aac99 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -41,7 +41,7 @@ use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::def_id::{DefId, CRATE_DEF_INDEX, LOCAL_CRATE};
-use rustc_hir::intravisit::{NestedVisitorMap, Visitor};
+use rustc_hir::intravisit::{self, NestedVisitorMap, Visitor};
 use rustc_hir::Node;
 use rustc_hir::{
     def, Arm, Block, Body, Constness, Crate, Expr, ExprKind, FnDecl, HirId, ImplItem, ImplItemKind, Item, ItemKind,
@@ -603,6 +603,37 @@ pub fn contains_return(expr: &hir::Expr<'_>) -> bool {
     visitor.found
 }
 
+struct FindMacroCalls<'a> {
+    names: Vec<&'a str>,
+    result: Vec<Span>,
+}
+
+impl<'a, 'tcx> Visitor<'tcx> for FindMacroCalls<'a> {
+    type Map = Map<'tcx>;
+
+    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
+        if self.names.iter().any(|fun| is_expn_of(expr.span, fun).is_some()) {
+            self.result.push(expr.span);
+        }
+        // and check sub-expressions
+        intravisit::walk_expr(self, expr);
+    }
+
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::None
+    }
+}
+
+/// Finds calls of the specified macros in a function body.
+pub fn find_macro_calls(names: Vec<&str>, body: &'tcx Body<'tcx>) -> Vec<Span> {
+    let mut fmc = FindMacroCalls {
+        names,
+        result: Vec::new(),
+    };
+    fmc.visit_expr(&body.value);
+    fmc.result
+}
+
 /// Converts a span to a code snippet if available, otherwise use default.
 ///
 /// This is useful if you want to provide suggestions for your lint or more generally, if you want
diff --git a/tests/ui/panic_in_result_fn.stderr b/tests/ui/panic_in_result_fn.stderr
index ca73ac5a411..eb744b0c198 100644
--- a/tests/ui/panic_in_result_fn.stderr
+++ b/tests/ui/panic_in_result_fn.stderr
@@ -1,4 +1,4 @@
-error: used `unimplemented!()`, `unreachable!()`, `todo!()` or `panic!()` in a function that returns `Result`
+error: used `unimplemented!()`, `unreachable!()`, `todo!()`, `panic!()` or assertion in a function that returns `Result`
   --> $DIR/panic_in_result_fn.rs:7:5
    |
 LL | /     fn result_with_panic() -> Result<bool, String> // should emit lint
@@ -8,7 +8,7 @@ LL | |     }
    | |_____^
    |
    = note: `-D clippy::panic-in-result-fn` implied by `-D warnings`
-   = help: `unimplemented!()`, `unreachable!()`, `todo!()` or `panic!()` should not be used in a function that returns `Result` as `Result` is expected to return an error instead of crashing
+   = help: `unimplemented!()`, `unreachable!()`, `todo!()`, `panic!()` or assertions should not be used in a function that returns `Result` as `Result` is expected to return an error instead of crashing
 note: return Err() instead of panicking
   --> $DIR/panic_in_result_fn.rs:9:9
    |
@@ -16,7 +16,7 @@ LL |         panic!("error");
    |         ^^^^^^^^^^^^^^^^
    = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: used `unimplemented!()`, `unreachable!()`, `todo!()` or `panic!()` in a function that returns `Result`
+error: used `unimplemented!()`, `unreachable!()`, `todo!()`, `panic!()` or assertion in a function that returns `Result`
   --> $DIR/panic_in_result_fn.rs:12:5
    |
 LL | /     fn result_with_unimplemented() -> Result<bool, String> // should emit lint
@@ -25,7 +25,7 @@ LL | |         unimplemented!();
 LL | |     }
    | |_____^
    |
-   = help: `unimplemented!()`, `unreachable!()`, `todo!()` or `panic!()` should not be used in a function that returns `Result` as `Result` is expected to return an error instead of crashing
+   = help: `unimplemented!()`, `unreachable!()`, `todo!()`, `panic!()` or assertions should not be used in a function that returns `Result` as `Result` is expected to return an error instead of crashing
 note: return Err() instead of panicking
   --> $DIR/panic_in_result_fn.rs:14:9
    |
@@ -33,7 +33,7 @@ LL |         unimplemented!();
    |         ^^^^^^^^^^^^^^^^^
    = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: used `unimplemented!()`, `unreachable!()`, `todo!()` or `panic!()` in a function that returns `Result`
+error: used `unimplemented!()`, `unreachable!()`, `todo!()`, `panic!()` or assertion in a function that returns `Result`
   --> $DIR/panic_in_result_fn.rs:17:5
    |
 LL | /     fn result_with_unreachable() -> Result<bool, String> // should emit lint
@@ -42,7 +42,7 @@ LL | |         unreachable!();
 LL | |     }
    | |_____^
    |
-   = help: `unimplemented!()`, `unreachable!()`, `todo!()` or `panic!()` should not be used in a function that returns `Result` as `Result` is expected to return an error instead of crashing
+   = help: `unimplemented!()`, `unreachable!()`, `todo!()`, `panic!()` or assertions should not be used in a function that returns `Result` as `Result` is expected to return an error instead of crashing
 note: return Err() instead of panicking
   --> $DIR/panic_in_result_fn.rs:19:9
    |
@@ -50,7 +50,7 @@ LL |         unreachable!();
    |         ^^^^^^^^^^^^^^^
    = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: used `unimplemented!()`, `unreachable!()`, `todo!()` or `panic!()` in a function that returns `Result`
+error: used `unimplemented!()`, `unreachable!()`, `todo!()`, `panic!()` or assertion in a function that returns `Result`
   --> $DIR/panic_in_result_fn.rs:22:5
    |
 LL | /     fn result_with_todo() -> Result<bool, String> // should emit lint
@@ -59,7 +59,7 @@ LL | |         todo!("Finish this");
 LL | |     }
    | |_____^
    |
-   = help: `unimplemented!()`, `unreachable!()`, `todo!()` or `panic!()` should not be used in a function that returns `Result` as `Result` is expected to return an error instead of crashing
+   = help: `unimplemented!()`, `unreachable!()`, `todo!()`, `panic!()` or assertions should not be used in a function that returns `Result` as `Result` is expected to return an error instead of crashing
 note: return Err() instead of panicking
   --> $DIR/panic_in_result_fn.rs:24:9
    |
@@ -67,7 +67,7 @@ LL |         todo!("Finish this");
    |         ^^^^^^^^^^^^^^^^^^^^^
    = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: used `unimplemented!()`, `unreachable!()`, `todo!()` or `panic!()` in a function that returns `Result`
+error: used `unimplemented!()`, `unreachable!()`, `todo!()`, `panic!()` or assertion in a function that returns `Result`
   --> $DIR/panic_in_result_fn.rs:53:1
    |
 LL | / fn function_result_with_panic() -> Result<bool, String> // should emit lint
@@ -76,7 +76,7 @@ LL | |     panic!("error");
 LL | | }
    | |_^
    |
-   = help: `unimplemented!()`, `unreachable!()`, `todo!()` or `panic!()` should not be used in a function that returns `Result` as `Result` is expected to return an error instead of crashing
+   = help: `unimplemented!()`, `unreachable!()`, `todo!()`, `panic!()` or assertions should not be used in a function that returns `Result` as `Result` is expected to return an error instead of crashing
 note: return Err() instead of panicking
   --> $DIR/panic_in_result_fn.rs:55:5
    |
@@ -84,7 +84,7 @@ LL |     panic!("error");
    |     ^^^^^^^^^^^^^^^^
    = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: used `unimplemented!()`, `unreachable!()`, `todo!()` or `panic!()` in a function that returns `Result`
+error: used `unimplemented!()`, `unreachable!()`, `todo!()`, `panic!()` or assertion in a function that returns `Result`
   --> $DIR/panic_in_result_fn.rs:68:1
    |
 LL | / fn main() -> Result<(), String> {
@@ -93,7 +93,7 @@ LL | |     Ok(())
 LL | | }
    | |_^
    |
-   = help: `unimplemented!()`, `unreachable!()`, `todo!()` or `panic!()` should not be used in a function that returns `Result` as `Result` is expected to return an error instead of crashing
+   = help: `unimplemented!()`, `unreachable!()`, `todo!()`, `panic!()` or assertions should not be used in a function that returns `Result` as `Result` is expected to return an error instead of crashing
 note: return Err() instead of panicking
   --> $DIR/panic_in_result_fn.rs:69:5
    |
diff --git a/tests/ui/panic_in_result_fn_assertions.rs b/tests/ui/panic_in_result_fn_assertions.rs
new file mode 100644
index 00000000000..ffdf8288adc
--- /dev/null
+++ b/tests/ui/panic_in_result_fn_assertions.rs
@@ -0,0 +1,48 @@
+#![warn(clippy::panic_in_result_fn)]
+#![allow(clippy::unnecessary_wraps)]
+
+struct A;
+
+impl A {
+    fn result_with_assert_with_message(x: i32) -> Result<bool, String> // should emit lint
+    {
+        assert!(x == 5, "wrong argument");
+        Ok(true)
+    }
+
+    fn result_with_assert_eq(x: i32) -> Result<bool, String> // should emit lint
+    {
+        assert_eq!(x, 5);
+        Ok(true)
+    }
+
+    fn result_with_assert_ne(x: i32) -> Result<bool, String> // should emit lint
+    {
+        assert_ne!(x, 1);
+        Ok(true)
+    }
+
+    fn other_with_assert_with_message(x: i32) // should not emit lint
+    {
+        assert!(x == 5, "wrong argument");
+    }
+
+    fn other_with_assert_eq(x: i32) // should not emit lint
+    {
+        assert_eq!(x, 5);
+    }
+
+    fn other_with_assert_ne(x: i32) // should not emit lint
+    {
+        assert_ne!(x, 1);
+    }
+
+    fn result_without_banned_functions() -> Result<bool, String> // should not emit lint
+    {
+        let assert = "assert!";
+        println!("No {}", assert);
+        Ok(true)
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/panic_in_result_fn_assertions.stderr b/tests/ui/panic_in_result_fn_assertions.stderr
new file mode 100644
index 00000000000..a17f043737d
--- /dev/null
+++ b/tests/ui/panic_in_result_fn_assertions.stderr
@@ -0,0 +1,57 @@
+error: used `unimplemented!()`, `unreachable!()`, `todo!()`, `panic!()` or assertion in a function that returns `Result`
+  --> $DIR/panic_in_result_fn_assertions.rs:7:5
+   |
+LL | /     fn result_with_assert_with_message(x: i32) -> Result<bool, String> // should emit lint
+LL | |     {
+LL | |         assert!(x == 5, "wrong argument");
+LL | |         Ok(true)
+LL | |     }
+   | |_____^
+   |
+   = note: `-D clippy::panic-in-result-fn` implied by `-D warnings`
+   = help: `unimplemented!()`, `unreachable!()`, `todo!()`, `panic!()` or assertions should not be used in a function that returns `Result` as `Result` is expected to return an error instead of crashing
+note: return Err() instead of panicking
+  --> $DIR/panic_in_result_fn_assertions.rs:9:9
+   |
+LL |         assert!(x == 5, "wrong argument");
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: used `unimplemented!()`, `unreachable!()`, `todo!()`, `panic!()` or assertion in a function that returns `Result`
+  --> $DIR/panic_in_result_fn_assertions.rs:13:5
+   |
+LL | /     fn result_with_assert_eq(x: i32) -> Result<bool, String> // should emit lint
+LL | |     {
+LL | |         assert_eq!(x, 5);
+LL | |         Ok(true)
+LL | |     }
+   | |_____^
+   |
+   = help: `unimplemented!()`, `unreachable!()`, `todo!()`, `panic!()` or assertions should not be used in a function that returns `Result` as `Result` is expected to return an error instead of crashing
+note: return Err() instead of panicking
+  --> $DIR/panic_in_result_fn_assertions.rs:15:9
+   |
+LL |         assert_eq!(x, 5);
+   |         ^^^^^^^^^^^^^^^^^
+   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: used `unimplemented!()`, `unreachable!()`, `todo!()`, `panic!()` or assertion in a function that returns `Result`
+  --> $DIR/panic_in_result_fn_assertions.rs:19:5
+   |
+LL | /     fn result_with_assert_ne(x: i32) -> Result<bool, String> // should emit lint
+LL | |     {
+LL | |         assert_ne!(x, 1);
+LL | |         Ok(true)
+LL | |     }
+   | |_____^
+   |
+   = help: `unimplemented!()`, `unreachable!()`, `todo!()`, `panic!()` or assertions should not be used in a function that returns `Result` as `Result` is expected to return an error instead of crashing
+note: return Err() instead of panicking
+  --> $DIR/panic_in_result_fn_assertions.rs:21:9
+   |
+LL |         assert_ne!(x, 1);
+   |         ^^^^^^^^^^^^^^^^^
+   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: aborting due to 3 previous errors
+
diff --git a/tests/ui/panic_in_result_fn_debug_assertions.rs b/tests/ui/panic_in_result_fn_debug_assertions.rs
new file mode 100644
index 00000000000..b60c79f97c8
--- /dev/null
+++ b/tests/ui/panic_in_result_fn_debug_assertions.rs
@@ -0,0 +1,48 @@
+#![warn(clippy::panic_in_result_fn)]
+#![allow(clippy::unnecessary_wraps)]
+
+struct A;
+
+impl A {
+    fn result_with_debug_assert_with_message(x: i32) -> Result<bool, String> // should emit lint
+    {
+        debug_assert!(x == 5, "wrong argument");
+        Ok(true)
+    }
+
+    fn result_with_debug_assert_eq(x: i32) -> Result<bool, String> // should emit lint
+    {
+        debug_assert_eq!(x, 5);
+        Ok(true)
+    }
+
+    fn result_with_debug_assert_ne(x: i32) -> Result<bool, String> // should emit lint
+    {
+        debug_assert_ne!(x, 1);
+        Ok(true)
+    }
+
+    fn other_with_debug_assert_with_message(x: i32) // should not emit lint
+    {
+        debug_assert!(x == 5, "wrong argument");
+    }
+
+    fn other_with_debug_assert_eq(x: i32) // should not emit lint
+    {
+        debug_assert_eq!(x, 5);
+    }
+
+    fn other_with_debug_assert_ne(x: i32) // should not emit lint
+    {
+        debug_assert_ne!(x, 1);
+    }
+
+    fn result_without_banned_functions() -> Result<bool, String> // should not emit lint
+    {
+        let debug_assert = "debug_assert!";
+        println!("No {}", debug_assert);
+        Ok(true)
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/panic_in_result_fn_debug_assertions.stderr b/tests/ui/panic_in_result_fn_debug_assertions.stderr
new file mode 100644
index 00000000000..ec18e89698c
--- /dev/null
+++ b/tests/ui/panic_in_result_fn_debug_assertions.stderr
@@ -0,0 +1,57 @@
+error: used `unimplemented!()`, `unreachable!()`, `todo!()`, `panic!()` or assertion in a function that returns `Result`
+  --> $DIR/panic_in_result_fn_debug_assertions.rs:7:5
+   |
+LL | /     fn result_with_debug_assert_with_message(x: i32) -> Result<bool, String> // should emit lint
+LL | |     {
+LL | |         debug_assert!(x == 5, "wrong argument");
+LL | |         Ok(true)
+LL | |     }
+   | |_____^
+   |
+   = note: `-D clippy::panic-in-result-fn` implied by `-D warnings`
+   = help: `unimplemented!()`, `unreachable!()`, `todo!()`, `panic!()` or assertions should not be used in a function that returns `Result` as `Result` is expected to return an error instead of crashing
+note: return Err() instead of panicking
+  --> $DIR/panic_in_result_fn_debug_assertions.rs:9:9
+   |
+LL |         debug_assert!(x == 5, "wrong argument");
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: used `unimplemented!()`, `unreachable!()`, `todo!()`, `panic!()` or assertion in a function that returns `Result`
+  --> $DIR/panic_in_result_fn_debug_assertions.rs:13:5
+   |
+LL | /     fn result_with_debug_assert_eq(x: i32) -> Result<bool, String> // should emit lint
+LL | |     {
+LL | |         debug_assert_eq!(x, 5);
+LL | |         Ok(true)
+LL | |     }
+   | |_____^
+   |
+   = help: `unimplemented!()`, `unreachable!()`, `todo!()`, `panic!()` or assertions should not be used in a function that returns `Result` as `Result` is expected to return an error instead of crashing
+note: return Err() instead of panicking
+  --> $DIR/panic_in_result_fn_debug_assertions.rs:15:9
+   |
+LL |         debug_assert_eq!(x, 5);
+   |         ^^^^^^^^^^^^^^^^^^^^^^^
+   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: used `unimplemented!()`, `unreachable!()`, `todo!()`, `panic!()` or assertion in a function that returns `Result`
+  --> $DIR/panic_in_result_fn_debug_assertions.rs:19:5
+   |
+LL | /     fn result_with_debug_assert_ne(x: i32) -> Result<bool, String> // should emit lint
+LL | |     {
+LL | |         debug_assert_ne!(x, 1);
+LL | |         Ok(true)
+LL | |     }
+   | |_____^
+   |
+   = help: `unimplemented!()`, `unreachable!()`, `todo!()`, `panic!()` or assertions should not be used in a function that returns `Result` as `Result` is expected to return an error instead of crashing
+note: return Err() instead of panicking
+  --> $DIR/panic_in_result_fn_debug_assertions.rs:21:9
+   |
+LL |         debug_assert_ne!(x, 1);
+   |         ^^^^^^^^^^^^^^^^^^^^^^^
+   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: aborting due to 3 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From bdad7900f4558672ca02b24a0a079b05391acaf9 Mon Sep 17 00:00:00 2001
From: dp304 <34493835+dp304@users.noreply.github.com>
Date: Thu, 3 Dec 2020 23:07:24 +0100
Subject: Apply suggestions from code review

Use array slice instead of `Vec` in `find_macro_calls` as suggested by @ebroto

Co-authored-by: Eduardo Broto <ebroto@tutanota.com>
---
 clippy_lints/src/panic_in_result_fn.rs | 2 +-
 clippy_lints/src/utils/mod.rs          | 8 ++++----
 2 files changed, 5 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/panic_in_result_fn.rs b/clippy_lints/src/panic_in_result_fn.rs
index cdabb0d0dd6..37e2b50def1 100644
--- a/clippy_lints/src/panic_in_result_fn.rs
+++ b/clippy_lints/src/panic_in_result_fn.rs
@@ -53,7 +53,7 @@ impl<'tcx> LateLintPass<'tcx> for PanicInResultFn {
 
 fn lint_impl_body<'tcx>(cx: &LateContext<'tcx>, impl_span: Span, body: &'tcx hir::Body<'tcx>) {
     let panics = find_macro_calls(
-        vec![
+        &[
             "unimplemented",
             "unreachable",
             "panic",
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index e47d71aac99..e83371f8b99 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -603,12 +603,12 @@ pub fn contains_return(expr: &hir::Expr<'_>) -> bool {
     visitor.found
 }
 
-struct FindMacroCalls<'a> {
-    names: Vec<&'a str>,
+struct FindMacroCalls<'a, 'b> {
+    names: &'a [&'b str],
     result: Vec<Span>,
 }
 
-impl<'a, 'tcx> Visitor<'tcx> for FindMacroCalls<'a> {
+impl<'a, 'b, 'tcx> Visitor<'tcx> for FindMacroCalls<'a, 'b> {
     type Map = Map<'tcx>;
 
     fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
@@ -625,7 +625,7 @@ impl<'a, 'tcx> Visitor<'tcx> for FindMacroCalls<'a> {
 }
 
 /// Finds calls of the specified macros in a function body.
-pub fn find_macro_calls(names: Vec<&str>, body: &'tcx Body<'tcx>) -> Vec<Span> {
+pub fn find_macro_calls(names: &[&str], body: &Body<'_>) -> Vec<Span> {
     let mut fmc = FindMacroCalls {
         names,
         result: Vec::new(),
-- 
cgit 1.4.1-3-g733a5


From 3187cad8ec0e9c32272341028526d6f1e208a704 Mon Sep 17 00:00:00 2001
From: Eduardo Broto <ebroto@tutanota.com>
Date: Tue, 8 Dec 2020 23:17:12 +0100
Subject: Factor out some code in write.rs

Get rid of the too-many-lines error.
---
 clippy_lints/src/write.rs            | 110 ++++++++++++++++-------------------
 tests/ui/println_empty_string.fixed  |   7 +++
 tests/ui/println_empty_string.rs     |   7 +++
 tests/ui/println_empty_string.stderr |  14 ++++-
 4 files changed, 77 insertions(+), 61 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs
index 0fd56f78572..337f7a229b9 100644
--- a/clippy_lints/src/write.rs
+++ b/clippy_lints/src/write.rs
@@ -262,71 +262,22 @@ impl EarlyLintPass for Write {
                 .map_or(false, |crate_name| crate_name == "build_script_build")
         }
 
-        if mac.path == sym!(println) {
+        if mac.path == sym!(print) {
             if !is_build_script(cx) {
-                span_lint(cx, PRINT_STDOUT, mac.span(), "use of `println!`");
+                span_lint(cx, PRINT_STDOUT, mac.span(), "use of `print!`");
             }
-            if let (Some(fmt_str), _) = self.check_tts(cx, mac.args.inner_tokens(), false) {
-                if fmt_str.symbol == Symbol::intern("") {
-                    span_lint_and_sugg(
-                        cx,
-                        PRINTLN_EMPTY_STRING,
-                        mac.span(),
-                        "using `println!(\"\")`",
-                        "replace it with",
-                        "println!()".to_string(),
-                        Applicability::MachineApplicable,
-                    );
-                }
+            self.lint_print_with_newline(cx, mac);
+        } else if mac.path == sym!(println) {
+            if !is_build_script(cx) {
+                span_lint(cx, PRINT_STDOUT, mac.span(), "use of `println!`");
             }
-        } else if mac.path == sym!(eprintln) {
-            span_lint(cx, PRINT_STDERR, mac.span(), "use of `eprintln!`");
+            self.lint_println_empty_string(cx, mac);
         } else if mac.path == sym!(eprint) {
             span_lint(cx, PRINT_STDERR, mac.span(), "use of `eprint!`");
-            if let (Some(fmt_str), _) = self.check_tts(cx, mac.args.inner_tokens(), false) {
-                if check_newlines(&fmt_str) {
-                    span_lint_and_then(
-                        cx,
-                        PRINT_WITH_NEWLINE,
-                        mac.span(),
-                        "using `eprint!()` with a format string that ends in a single newline",
-                        |err| {
-                            err.multipart_suggestion(
-                                "use `eprintln!` instead",
-                                vec![
-                                    (mac.path.span, String::from("eprintln")),
-                                    (newline_span(&fmt_str), String::new()),
-                                ],
-                                Applicability::MachineApplicable,
-                            );
-                        },
-                    );
-                }
-            }
-        } else if mac.path == sym!(print) {
-            if !is_build_script(cx) {
-                span_lint(cx, PRINT_STDOUT, mac.span(), "use of `print!`");
-            }
-            if let (Some(fmt_str), _) = self.check_tts(cx, mac.args.inner_tokens(), false) {
-                if check_newlines(&fmt_str) {
-                    span_lint_and_then(
-                        cx,
-                        PRINT_WITH_NEWLINE,
-                        mac.span(),
-                        "using `print!()` with a format string that ends in a single newline",
-                        |err| {
-                            err.multipart_suggestion(
-                                "use `println!` instead",
-                                vec![
-                                    (mac.path.span, String::from("println")),
-                                    (newline_span(&fmt_str), String::new()),
-                                ],
-                                Applicability::MachineApplicable,
-                            );
-                        },
-                    );
-                }
-            }
+            self.lint_print_with_newline(cx, mac);
+        } else if mac.path == sym!(eprintln) {
+            span_lint(cx, PRINT_STDERR, mac.span(), "use of `eprintln!`");
+            self.lint_println_empty_string(cx, mac);
         } else if mac.path == sym!(write) {
             if let (Some(fmt_str), _) = self.check_tts(cx, mac.args.inner_tokens(), true) {
                 if check_newlines(&fmt_str) {
@@ -530,6 +481,45 @@ impl Write {
             }
         }
     }
+
+    fn lint_println_empty_string(&self, cx: &EarlyContext<'_>, mac: &MacCall) {
+        if let (Some(fmt_str), _) = self.check_tts(cx, mac.args.inner_tokens(), false) {
+            if fmt_str.symbol == Symbol::intern("") {
+                let name = mac.path.segments[0].ident.name;
+                span_lint_and_sugg(
+                    cx,
+                    PRINTLN_EMPTY_STRING,
+                    mac.span(),
+                    &format!("using `{}!(\"\")`", name),
+                    "replace it with",
+                    format!("{}!()", name),
+                    Applicability::MachineApplicable,
+                );
+            }
+        }
+    }
+
+    fn lint_print_with_newline(&self, cx: &EarlyContext<'_>, mac: &MacCall) {
+        if let (Some(fmt_str), _) = self.check_tts(cx, mac.args.inner_tokens(), false) {
+            if check_newlines(&fmt_str) {
+                let name = mac.path.segments[0].ident.name;
+                let suggested = format!("{}ln", name);
+                span_lint_and_then(
+                    cx,
+                    PRINT_WITH_NEWLINE,
+                    mac.span(),
+                    &format!("using `{}!()` with a format string that ends in a single newline", name),
+                    |err| {
+                        err.multipart_suggestion(
+                            &format!("use `{}!` instead", suggested),
+                            vec![(mac.path.span, suggested), (newline_span(&fmt_str), String::new())],
+                            Applicability::MachineApplicable,
+                        );
+                    },
+                );
+            }
+        }
+    }
 }
 
 /// Checks if the format string contains a single newline that terminates it.
diff --git a/tests/ui/println_empty_string.fixed b/tests/ui/println_empty_string.fixed
index 2b889b62ea9..9760680927a 100644
--- a/tests/ui/println_empty_string.fixed
+++ b/tests/ui/println_empty_string.fixed
@@ -8,4 +8,11 @@ fn main() {
     match "a" {
         _ => println!(),
     }
+
+    eprintln!();
+    eprintln!();
+
+    match "a" {
+        _ => eprintln!(),
+    }
 }
diff --git a/tests/ui/println_empty_string.rs b/tests/ui/println_empty_string.rs
index 890f5f68476..80fdb3e6e21 100644
--- a/tests/ui/println_empty_string.rs
+++ b/tests/ui/println_empty_string.rs
@@ -8,4 +8,11 @@ fn main() {
     match "a" {
         _ => println!(""),
     }
+
+    eprintln!();
+    eprintln!("");
+
+    match "a" {
+        _ => eprintln!(""),
+    }
 }
diff --git a/tests/ui/println_empty_string.stderr b/tests/ui/println_empty_string.stderr
index 23112b88168..17fe4ea7479 100644
--- a/tests/ui/println_empty_string.stderr
+++ b/tests/ui/println_empty_string.stderr
@@ -12,5 +12,17 @@ error: using `println!("")`
 LL |         _ => println!(""),
    |              ^^^^^^^^^^^^ help: replace it with: `println!()`
 
-error: aborting due to 2 previous errors
+error: using `eprintln!("")`
+  --> $DIR/println_empty_string.rs:13:5
+   |
+LL |     eprintln!("");
+   |     ^^^^^^^^^^^^^ help: replace it with: `eprintln!()`
+
+error: using `eprintln!("")`
+  --> $DIR/println_empty_string.rs:16:14
+   |
+LL |         _ => eprintln!(""),
+   |              ^^^^^^^^^^^^^ help: replace it with: `eprintln!()`
+
+error: aborting due to 4 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From f77f1db35b1f263286962cfa5e5c08a55add83cb Mon Sep 17 00:00:00 2001
From: Korrat <korrat@protonmail.com>
Date: Sat, 24 Oct 2020 16:48:10 +0200
Subject: Add a lint for maps with zero-sized values

Co-authored-by: Eduardo Broto <ebroto@tutanota.com>
---
 CHANGELOG.md                               |   1 +
 clippy_lints/src/lib.rs                    |   4 ++
 clippy_lints/src/zero_sized_map_values.rs  |  82 ++++++++++++++++++++++
 tests/ui/zero_sized_btreemap_values.rs     |  68 ++++++++++++++++++
 tests/ui/zero_sized_btreemap_values.stderr | 107 +++++++++++++++++++++++++++++
 tests/ui/zero_sized_hashmap_values.rs      |  68 ++++++++++++++++++
 tests/ui/zero_sized_hashmap_values.stderr  | 107 +++++++++++++++++++++++++++++
 7 files changed, 437 insertions(+)
 create mode 100644 clippy_lints/src/zero_sized_map_values.rs
 create mode 100644 tests/ui/zero_sized_btreemap_values.rs
 create mode 100644 tests/ui/zero_sized_btreemap_values.stderr
 create mode 100644 tests/ui/zero_sized_hashmap_values.rs
 create mode 100644 tests/ui/zero_sized_hashmap_values.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 82f2ad7ec4e..af3b1c1db2a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2171,5 +2171,6 @@ Released 2018-09-13
 [`zero_divided_by_zero`]: https://rust-lang.github.io/rust-clippy/master/index.html#zero_divided_by_zero
 [`zero_prefixed_literal`]: https://rust-lang.github.io/rust-clippy/master/index.html#zero_prefixed_literal
 [`zero_ptr`]: https://rust-lang.github.io/rust-clippy/master/index.html#zero_ptr
+[`zero_sized_map_values`]: https://rust-lang.github.io/rust-clippy/master/index.html#zero_sized_map_values
 [`zst_offset`]: https://rust-lang.github.io/rust-clippy/master/index.html#zst_offset
 <!-- end autogenerated links to lint list -->
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index a92ae9ed8d9..5fca088c9b4 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -345,6 +345,7 @@ mod wildcard_dependencies;
 mod wildcard_imports;
 mod write;
 mod zero_div_zero;
+mod zero_sized_map_values;
 // end lints modules, do not remove this comment, it’s used in `update_lints`
 
 pub use crate::utils::conf::Conf;
@@ -944,6 +945,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &write::WRITE_LITERAL,
         &write::WRITE_WITH_NEWLINE,
         &zero_div_zero::ZERO_DIVIDED_BY_ZERO,
+        &zero_sized_map_values::ZERO_SIZED_MAP_VALUES,
     ]);
     // end register lints, do not remove this comment, it’s used in `update_lints`
 
@@ -1204,6 +1206,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box undropped_manually_drops::UndroppedManuallyDrops);
     store.register_late_pass(|| box strings::StrToString);
     store.register_late_pass(|| box strings::StringToString);
+    store.register_late_pass(|| box zero_sized_map_values::ZeroSizedMapValues);
 
     store.register_group(true, "clippy::restriction", Some("clippy_restriction"), vec![
         LintId::of(&arithmetic::FLOAT_ARITHMETIC),
@@ -1336,6 +1339,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&unused_self::UNUSED_SELF),
         LintId::of(&wildcard_imports::ENUM_GLOB_USE),
         LintId::of(&wildcard_imports::WILDCARD_IMPORTS),
+        LintId::of(&zero_sized_map_values::ZERO_SIZED_MAP_VALUES),
     ]);
 
     #[cfg(feature = "internal-lints")]
diff --git a/clippy_lints/src/zero_sized_map_values.rs b/clippy_lints/src/zero_sized_map_values.rs
new file mode 100644
index 00000000000..1d5fa8d06a9
--- /dev/null
+++ b/clippy_lints/src/zero_sized_map_values.rs
@@ -0,0 +1,82 @@
+use if_chain::if_chain;
+use rustc_hir::{self as hir, HirId, ItemKind, Node};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::{Adt, Ty};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_target::abi::LayoutOf as _;
+use rustc_typeck::hir_ty_to_ty;
+
+use crate::utils::{is_type_diagnostic_item, match_type, paths, span_lint_and_help};
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for maps with zero-sized value types anywhere in the code.
+    ///
+    /// **Why is this bad?** Since there is only a single value for a zero-sized type, a map
+    /// containing zero sized values is effectively a set. Using a set in that case improves
+    /// readability and communicates intent more clearly.
+    ///
+    /// **Known problems:**
+    /// * A zero-sized type cannot be recovered later if it contains private fields.
+    /// * This lints the signature of public items
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// # use std::collections::HashMap;
+    /// fn unique_words(text: &str) -> HashMap<&str, ()> {
+    ///     todo!();
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// # use std::collections::HashSet;
+    /// fn unique_words(text: &str) -> HashSet<&str> {
+    ///     todo!();
+    /// }
+    /// ```
+    pub ZERO_SIZED_MAP_VALUES,
+    pedantic,
+    "usage of map with zero-sized value type"
+}
+
+declare_lint_pass!(ZeroSizedMapValues => [ZERO_SIZED_MAP_VALUES]);
+
+impl LateLintPass<'_> for ZeroSizedMapValues {
+    fn check_ty(&mut self, cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>) {
+        if_chain! {
+            if !hir_ty.span.from_expansion();
+            if !in_trait_impl(cx, hir_ty.hir_id);
+            let ty = ty_from_hir_ty(cx, hir_ty);
+            if is_type_diagnostic_item(cx, ty, sym!(hashmap_type)) || match_type(cx, ty, &paths::BTREEMAP);
+            if let Adt(_, ref substs) = ty.kind();
+            let ty = substs.type_at(1);
+            if let Ok(layout) = cx.layout_of(ty);
+            if layout.is_zst();
+            then {
+                span_lint_and_help(cx, ZERO_SIZED_MAP_VALUES, hir_ty.span, "map with zero-sized value type", None, "consider using a set instead");
+            }
+        }
+    }
+}
+
+fn in_trait_impl(cx: &LateContext<'_>, hir_id: HirId) -> bool {
+    let parent_id = cx.tcx.hir().get_parent_item(hir_id);
+    if let Some(Node::Item(item)) = cx.tcx.hir().find(cx.tcx.hir().get_parent_item(parent_id)) {
+        if let ItemKind::Impl { of_trait: Some(_), .. } = item.kind {
+            return true;
+        }
+    }
+    false
+}
+
+fn ty_from_hir_ty<'tcx>(cx: &LateContext<'tcx>, hir_ty: &hir::Ty<'_>) -> Ty<'tcx> {
+    cx.maybe_typeck_results()
+        .and_then(|results| {
+            if results.hir_owner == hir_ty.hir_id.owner {
+                results.node_type_opt(hir_ty.hir_id)
+            } else {
+                None
+            }
+        })
+        .unwrap_or_else(|| hir_ty_to_ty(cx.tcx, hir_ty))
+}
diff --git a/tests/ui/zero_sized_btreemap_values.rs b/tests/ui/zero_sized_btreemap_values.rs
new file mode 100644
index 00000000000..5cd254787d8
--- /dev/null
+++ b/tests/ui/zero_sized_btreemap_values.rs
@@ -0,0 +1,68 @@
+#![warn(clippy::zero_sized_map_values)]
+use std::collections::BTreeMap;
+
+const CONST_OK: Option<BTreeMap<String, usize>> = None;
+const CONST_NOT_OK: Option<BTreeMap<String, ()>> = None;
+
+static STATIC_OK: Option<BTreeMap<String, usize>> = None;
+static STATIC_NOT_OK: Option<BTreeMap<String, ()>> = None;
+
+type OkMap = BTreeMap<String, usize>;
+type NotOkMap = BTreeMap<String, ()>;
+
+enum TestEnum {
+    Ok(BTreeMap<String, usize>),
+    NotOk(BTreeMap<String, ()>),
+}
+
+struct Test {
+    ok: BTreeMap<String, usize>,
+    not_ok: BTreeMap<String, ()>,
+
+    also_not_ok: Vec<BTreeMap<usize, ()>>,
+}
+
+trait TestTrait {
+    type Output;
+
+    fn produce_output() -> Self::Output;
+
+    fn weird_map(&self, map: BTreeMap<usize, ()>);
+}
+
+impl Test {
+    fn ok(&self) -> BTreeMap<String, usize> {
+        todo!()
+    }
+
+    fn not_ok(&self) -> BTreeMap<String, ()> {
+        todo!()
+    }
+}
+
+impl TestTrait for Test {
+    type Output = BTreeMap<String, ()>;
+
+    fn produce_output() -> Self::Output {
+        todo!();
+    }
+
+    fn weird_map(&self, map: BTreeMap<usize, ()>) {
+        todo!();
+    }
+}
+
+fn test(map: BTreeMap<String, ()>, key: &str) -> BTreeMap<String, ()> {
+    todo!();
+}
+
+fn test2(map: BTreeMap<String, usize>, key: &str) -> BTreeMap<String, usize> {
+    todo!();
+}
+
+fn main() {
+    let _: BTreeMap<String, ()> = BTreeMap::new();
+    let _: BTreeMap<String, usize> = BTreeMap::new();
+
+    let _: BTreeMap<_, _> = std::iter::empty::<(String, ())>().collect();
+}
diff --git a/tests/ui/zero_sized_btreemap_values.stderr b/tests/ui/zero_sized_btreemap_values.stderr
new file mode 100644
index 00000000000..334d921a9af
--- /dev/null
+++ b/tests/ui/zero_sized_btreemap_values.stderr
@@ -0,0 +1,107 @@
+error: map with zero-sized value type
+  --> $DIR/zero_sized_btreemap_values.rs:5:28
+   |
+LL | const CONST_NOT_OK: Option<BTreeMap<String, ()>> = None;
+   |                            ^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::zero-sized-map-values` implied by `-D warnings`
+   = help: consider using a set instead
+
+error: map with zero-sized value type
+  --> $DIR/zero_sized_btreemap_values.rs:8:30
+   |
+LL | static STATIC_NOT_OK: Option<BTreeMap<String, ()>> = None;
+   |                              ^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using a set instead
+
+error: map with zero-sized value type
+  --> $DIR/zero_sized_btreemap_values.rs:11:17
+   |
+LL | type NotOkMap = BTreeMap<String, ()>;
+   |                 ^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using a set instead
+
+error: map with zero-sized value type
+  --> $DIR/zero_sized_btreemap_values.rs:15:11
+   |
+LL |     NotOk(BTreeMap<String, ()>),
+   |           ^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using a set instead
+
+error: map with zero-sized value type
+  --> $DIR/zero_sized_btreemap_values.rs:20:13
+   |
+LL |     not_ok: BTreeMap<String, ()>,
+   |             ^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using a set instead
+
+error: map with zero-sized value type
+  --> $DIR/zero_sized_btreemap_values.rs:22:22
+   |
+LL |     also_not_ok: Vec<BTreeMap<usize, ()>>,
+   |                      ^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using a set instead
+
+error: map with zero-sized value type
+  --> $DIR/zero_sized_btreemap_values.rs:30:30
+   |
+LL |     fn weird_map(&self, map: BTreeMap<usize, ()>);
+   |                              ^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using a set instead
+
+error: map with zero-sized value type
+  --> $DIR/zero_sized_btreemap_values.rs:38:25
+   |
+LL |     fn not_ok(&self) -> BTreeMap<String, ()> {
+   |                         ^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using a set instead
+
+error: map with zero-sized value type
+  --> $DIR/zero_sized_btreemap_values.rs:55:14
+   |
+LL | fn test(map: BTreeMap<String, ()>, key: &str) -> BTreeMap<String, ()> {
+   |              ^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using a set instead
+
+error: map with zero-sized value type
+  --> $DIR/zero_sized_btreemap_values.rs:55:50
+   |
+LL | fn test(map: BTreeMap<String, ()>, key: &str) -> BTreeMap<String, ()> {
+   |                                                  ^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using a set instead
+
+error: map with zero-sized value type
+  --> $DIR/zero_sized_btreemap_values.rs:64:35
+   |
+LL |     let _: BTreeMap<String, ()> = BTreeMap::new();
+   |                                   ^^^^^^^^^^^^^
+   |
+   = help: consider using a set instead
+
+error: map with zero-sized value type
+  --> $DIR/zero_sized_btreemap_values.rs:64:12
+   |
+LL |     let _: BTreeMap<String, ()> = BTreeMap::new();
+   |            ^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using a set instead
+
+error: map with zero-sized value type
+  --> $DIR/zero_sized_btreemap_values.rs:67:12
+   |
+LL |     let _: BTreeMap<_, _> = std::iter::empty::<(String, ())>().collect();
+   |            ^^^^^^^^^^^^^^
+   |
+   = help: consider using a set instead
+
+error: aborting due to 13 previous errors
+
diff --git a/tests/ui/zero_sized_hashmap_values.rs b/tests/ui/zero_sized_hashmap_values.rs
new file mode 100644
index 00000000000..a1608d863fb
--- /dev/null
+++ b/tests/ui/zero_sized_hashmap_values.rs
@@ -0,0 +1,68 @@
+#![warn(clippy::zero_sized_map_values)]
+use std::collections::HashMap;
+
+const CONST_OK: Option<HashMap<String, usize>> = None;
+const CONST_NOT_OK: Option<HashMap<String, ()>> = None;
+
+static STATIC_OK: Option<HashMap<String, usize>> = None;
+static STATIC_NOT_OK: Option<HashMap<String, ()>> = None;
+
+type OkMap = HashMap<String, usize>;
+type NotOkMap = HashMap<String, ()>;
+
+enum TestEnum {
+    Ok(HashMap<String, usize>),
+    NotOk(HashMap<String, ()>),
+}
+
+struct Test {
+    ok: HashMap<String, usize>,
+    not_ok: HashMap<String, ()>,
+
+    also_not_ok: Vec<HashMap<usize, ()>>,
+}
+
+trait TestTrait {
+    type Output;
+
+    fn produce_output() -> Self::Output;
+
+    fn weird_map(&self, map: HashMap<usize, ()>);
+}
+
+impl Test {
+    fn ok(&self) -> HashMap<String, usize> {
+        todo!()
+    }
+
+    fn not_ok(&self) -> HashMap<String, ()> {
+        todo!()
+    }
+}
+
+impl TestTrait for Test {
+    type Output = HashMap<String, ()>;
+
+    fn produce_output() -> Self::Output {
+        todo!();
+    }
+
+    fn weird_map(&self, map: HashMap<usize, ()>) {
+        todo!();
+    }
+}
+
+fn test(map: HashMap<String, ()>, key: &str) -> HashMap<String, ()> {
+    todo!();
+}
+
+fn test2(map: HashMap<String, usize>, key: &str) -> HashMap<String, usize> {
+    todo!();
+}
+
+fn main() {
+    let _: HashMap<String, ()> = HashMap::new();
+    let _: HashMap<String, usize> = HashMap::new();
+
+    let _: HashMap<_, _> = std::iter::empty::<(String, ())>().collect();
+}
diff --git a/tests/ui/zero_sized_hashmap_values.stderr b/tests/ui/zero_sized_hashmap_values.stderr
new file mode 100644
index 00000000000..43987b3d01d
--- /dev/null
+++ b/tests/ui/zero_sized_hashmap_values.stderr
@@ -0,0 +1,107 @@
+error: map with zero-sized value type
+  --> $DIR/zero_sized_hashmap_values.rs:5:28
+   |
+LL | const CONST_NOT_OK: Option<HashMap<String, ()>> = None;
+   |                            ^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::zero-sized-map-values` implied by `-D warnings`
+   = help: consider using a set instead
+
+error: map with zero-sized value type
+  --> $DIR/zero_sized_hashmap_values.rs:8:30
+   |
+LL | static STATIC_NOT_OK: Option<HashMap<String, ()>> = None;
+   |                              ^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using a set instead
+
+error: map with zero-sized value type
+  --> $DIR/zero_sized_hashmap_values.rs:11:17
+   |
+LL | type NotOkMap = HashMap<String, ()>;
+   |                 ^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using a set instead
+
+error: map with zero-sized value type
+  --> $DIR/zero_sized_hashmap_values.rs:15:11
+   |
+LL |     NotOk(HashMap<String, ()>),
+   |           ^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using a set instead
+
+error: map with zero-sized value type
+  --> $DIR/zero_sized_hashmap_values.rs:20:13
+   |
+LL |     not_ok: HashMap<String, ()>,
+   |             ^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using a set instead
+
+error: map with zero-sized value type
+  --> $DIR/zero_sized_hashmap_values.rs:22:22
+   |
+LL |     also_not_ok: Vec<HashMap<usize, ()>>,
+   |                      ^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using a set instead
+
+error: map with zero-sized value type
+  --> $DIR/zero_sized_hashmap_values.rs:30:30
+   |
+LL |     fn weird_map(&self, map: HashMap<usize, ()>);
+   |                              ^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using a set instead
+
+error: map with zero-sized value type
+  --> $DIR/zero_sized_hashmap_values.rs:38:25
+   |
+LL |     fn not_ok(&self) -> HashMap<String, ()> {
+   |                         ^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using a set instead
+
+error: map with zero-sized value type
+  --> $DIR/zero_sized_hashmap_values.rs:55:14
+   |
+LL | fn test(map: HashMap<String, ()>, key: &str) -> HashMap<String, ()> {
+   |              ^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using a set instead
+
+error: map with zero-sized value type
+  --> $DIR/zero_sized_hashmap_values.rs:55:49
+   |
+LL | fn test(map: HashMap<String, ()>, key: &str) -> HashMap<String, ()> {
+   |                                                 ^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using a set instead
+
+error: map with zero-sized value type
+  --> $DIR/zero_sized_hashmap_values.rs:64:34
+   |
+LL |     let _: HashMap<String, ()> = HashMap::new();
+   |                                  ^^^^^^^^^^^^
+   |
+   = help: consider using a set instead
+
+error: map with zero-sized value type
+  --> $DIR/zero_sized_hashmap_values.rs:64:12
+   |
+LL |     let _: HashMap<String, ()> = HashMap::new();
+   |            ^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using a set instead
+
+error: map with zero-sized value type
+  --> $DIR/zero_sized_hashmap_values.rs:67:12
+   |
+LL |     let _: HashMap<_, _> = std::iter::empty::<(String, ())>().collect();
+   |            ^^^^^^^^^^^^^
+   |
+   = help: consider using a set instead
+
+error: aborting due to 13 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From a6bb9276f7964b96899d04d680bc04bf99c8bf47 Mon Sep 17 00:00:00 2001
From: ThibsG <Thibs@debian.com>
Date: Mon, 9 Nov 2020 23:38:08 +0100
Subject: Lint wrong self convention in trait also

---
 clippy_lints/src/methods/mod.rs       | 49 ++++++++++++++++++++++++++++++-----
 tests/ui/wrong_self_convention.rs     | 26 +++++++++++++++++++
 tests/ui/wrong_self_convention.stderr | 34 +++++++++++++++++++++++-
 3 files changed, 101 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 8002c27a5e9..3c89c1b6ed2 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -22,6 +22,7 @@ use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::Span;
 use rustc_span::symbol::{sym, SymbolStr};
+use rustc_typeck::hir_ty_to_ty;
 
 use crate::consts::{constant, Constant};
 use crate::utils::eager_or_lazy::is_lazyness_candidate;
@@ -1623,10 +1624,15 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
         let item = cx.tcx.hir().expect_item(parent);
         let def_id = cx.tcx.hir().local_def_id(item.hir_id);
         let self_ty = cx.tcx.type_of(def_id);
+
+        // if this impl block implements a trait, lint in trait definition instead
+        if let hir::ItemKind::Impl { of_trait: Some(_), .. } = item.kind {
+            return;
+        }
+
         if_chain! {
             if let hir::ImplItemKind::Fn(ref sig, id) = impl_item.kind;
             if let Some(first_arg) = iter_input_pats(&sig.decl, cx.tcx.hir().body(id)).next();
-            if let hir::ItemKind::Impl{ of_trait: None, .. } = item.kind;
 
             let method_def_id = cx.tcx.hir().local_def_id(impl_item.hir_id);
             let method_sig = cx.tcx.fn_sig(method_def_id);
@@ -1697,11 +1703,6 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             }
         }
 
-        // if this impl block implements a trait, lint in trait definition instead
-        if let hir::ItemKind::Impl { of_trait: Some(_), .. } = item.kind {
-            return;
-        }
-
         if let hir::ImplItemKind::Fn(_, _) = impl_item.kind {
             let ret_ty = return_ty(cx, impl_item.hir_id);
 
@@ -1735,8 +1736,42 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
     }
 
     fn check_trait_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx TraitItem<'_>) {
+        if in_external_macro(cx.tcx.sess, item.span) {
+            return;
+        }
+
+        if_chain! {
+            if let TraitItemKind::Fn(ref sig, _) = item.kind;
+            if let Some(first_arg_ty) = sig.decl.inputs.iter().next();
+            let first_arg_span = first_arg_ty.span;
+            let first_arg_ty = hir_ty_to_ty(cx.tcx, first_arg_ty);
+            let self_ty = TraitRef::identity(cx.tcx, item.hir_id.owner.to_def_id()).self_ty();
+
+            then {
+                if let Some((ref conv, self_kinds)) = &CONVENTIONS
+                    .iter()
+                    .find(|(ref conv, _)| conv.check(&item.ident.name.as_str()))
+                {
+                    if !self_kinds.iter().any(|k| k.matches(cx, self_ty, first_arg_ty)) {
+                        span_lint(
+                            cx,
+                            WRONG_PUB_SELF_CONVENTION,
+                            first_arg_span,
+                            &format!("methods called `{}` usually take {}; consider choosing a less ambiguous name",
+                                conv,
+                                &self_kinds
+                                    .iter()
+                                    .map(|k| k.description())
+                                    .collect::<Vec<_>>()
+                                    .join(" or ")
+                            ),
+                        );
+                    }
+                }
+            }
+        }
+
         if_chain! {
-            if !in_external_macro(cx.tcx.sess, item.span);
             if item.ident.name == sym::new;
             if let TraitItemKind::Fn(_, _) = item.kind;
             let ret_ty = return_ty(cx, item.hir_id);
diff --git a/tests/ui/wrong_self_convention.rs b/tests/ui/wrong_self_convention.rs
index f44305d7e48..275866b8248 100644
--- a/tests/ui/wrong_self_convention.rs
+++ b/tests/ui/wrong_self_convention.rs
@@ -88,3 +88,29 @@ mod issue4037 {
         }
     }
 }
+
+// Lint also in trait definition (see #6307)
+mod issue6307{
+    trait T: Sized {
+        fn as_i32(self) {}
+        fn as_u32(&self) {}
+        fn into_i32(&self) {}
+        fn into_u32(self) {}
+        fn is_i32(self) {}
+        fn is_u32(&self) {}
+        fn to_i32(self) {}
+        fn to_u32(&self) {}
+        fn from_i32(self) {}
+        // check whether the lint can be allowed at the function level
+        #[allow(clippy::wrong_pub_self_convention)]
+        fn from_cake(self) {}
+
+        // test for false positives
+        fn as_(self) {}
+        fn into_(&self) {}
+        fn is_(self) {}
+        fn to_(self) {}
+        fn from_(self) {}
+        fn to_mut(&mut self) {}
+    }
+}
\ No newline at end of file
diff --git a/tests/ui/wrong_self_convention.stderr b/tests/ui/wrong_self_convention.stderr
index ef3ad73ebc7..64aa957fed6 100644
--- a/tests/ui/wrong_self_convention.stderr
+++ b/tests/ui/wrong_self_convention.stderr
@@ -72,5 +72,37 @@ error: methods called `from_*` usually take no self; consider choosing a less am
 LL |     pub fn from_i64(self) {}
    |                     ^^^^
 
-error: aborting due to 12 previous errors
+error: methods called `as_*` usually take self by reference or self by mutable reference; consider choosing a less ambiguous name
+  --> $DIR/wrong_self_convention.rs:95:19
+   |
+LL |         fn as_i32(self) {}
+   |                   ^^^^
+   |
+   = note: `-D clippy::wrong-pub-self-convention` implied by `-D warnings`
+
+error: methods called `into_*` usually take self by value; consider choosing a less ambiguous name
+  --> $DIR/wrong_self_convention.rs:97:21
+   |
+LL |         fn into_i32(&self) {}
+   |                     ^^^^^
+
+error: methods called `is_*` usually take self by reference or no self; consider choosing a less ambiguous name
+  --> $DIR/wrong_self_convention.rs:99:19
+   |
+LL |         fn is_i32(self) {}
+   |                   ^^^^
+
+error: methods called `to_*` usually take self by reference; consider choosing a less ambiguous name
+  --> $DIR/wrong_self_convention.rs:101:19
+   |
+LL |         fn to_i32(self) {}
+   |                   ^^^^
+
+error: methods called `from_*` usually take no self; consider choosing a less ambiguous name
+  --> $DIR/wrong_self_convention.rs:103:21
+   |
+LL |         fn from_i32(self) {}
+   |                     ^^^^
+
+error: aborting due to 17 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 4af9382bec3f49d9c7e0f03e9cfb5e8f1c70fdbe Mon Sep 17 00:00:00 2001
From: ThibsG <Thibs@debian.com>
Date: Tue, 10 Nov 2020 08:56:17 +0100
Subject: Common function to lint wrong self convention from impl and trait def

---
 clippy_lints/src/methods/mod.rs       | 88 +++++++++++++++++------------------
 tests/ui/wrong_self_convention.rs     |  6 +--
 tests/ui/wrong_self_convention.stderr |  2 -
 3 files changed, 45 insertions(+), 51 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 3c89c1b6ed2..9a082a89229 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1674,32 +1674,14 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
                     }
                 }
 
-                if let Some((ref conv, self_kinds)) = &CONVENTIONS
-                    .iter()
-                    .find(|(ref conv, _)| conv.check(&name))
-                {
-                    if !self_kinds.iter().any(|k| k.matches(cx, self_ty, first_arg_ty)) {
-                        let lint = if item.vis.node.is_pub() {
-                            WRONG_PUB_SELF_CONVENTION
-                        } else {
-                            WRONG_SELF_CONVENTION
-                        };
-
-                        span_lint(
-                            cx,
-                            lint,
-                            first_arg.pat.span,
-                            &format!("methods called `{}` usually take {}; consider choosing a less ambiguous name",
-                                conv,
-                                &self_kinds
-                                    .iter()
-                                    .map(|k| k.description())
-                                    .collect::<Vec<_>>()
-                                    .join(" or ")
-                            ),
-                        );
-                    }
-                }
+                lint_wrong_self_convention(
+                    cx,
+                    &name,
+                    item.vis.node.is_pub(),
+                    self_ty,
+                    first_arg_ty,
+                    first_arg.pat.span
+                );
             }
         }
 
@@ -1748,26 +1730,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             let self_ty = TraitRef::identity(cx.tcx, item.hir_id.owner.to_def_id()).self_ty();
 
             then {
-                if let Some((ref conv, self_kinds)) = &CONVENTIONS
-                    .iter()
-                    .find(|(ref conv, _)| conv.check(&item.ident.name.as_str()))
-                {
-                    if !self_kinds.iter().any(|k| k.matches(cx, self_ty, first_arg_ty)) {
-                        span_lint(
-                            cx,
-                            WRONG_PUB_SELF_CONVENTION,
-                            first_arg_span,
-                            &format!("methods called `{}` usually take {}; consider choosing a less ambiguous name",
-                                conv,
-                                &self_kinds
-                                    .iter()
-                                    .map(|k| k.description())
-                                    .collect::<Vec<_>>()
-                                    .join(" or ")
-                            ),
-                        );
-                    }
-                }
+                lint_wrong_self_convention(cx, &item.ident.name.as_str(), false, self_ty, first_arg_ty, first_arg_span);
             }
         }
 
@@ -1792,6 +1755,39 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
     extract_msrv_attr!(LateContext);
 }
 
+fn lint_wrong_self_convention<'tcx>(
+    cx: &LateContext<'tcx>,
+    item_name: &str,
+    is_pub: bool,
+    self_ty: &'tcx TyS<'tcx>,
+    first_arg_ty: &'tcx TyS<'tcx>,
+    first_arg_span: Span,
+) {
+    let lint = if is_pub {
+        WRONG_PUB_SELF_CONVENTION
+    } else {
+        WRONG_SELF_CONVENTION
+    };
+    if let Some((ref conv, self_kinds)) = &CONVENTIONS.iter().find(|(ref conv, _)| conv.check(item_name)) {
+        if !self_kinds.iter().any(|k| k.matches(cx, self_ty, first_arg_ty)) {
+            span_lint(
+                cx,
+                lint,
+                first_arg_span,
+                &format!(
+                    "methods called `{}` usually take {}; consider choosing a less ambiguous name",
+                    conv,
+                    &self_kinds
+                        .iter()
+                        .map(|k| k.description())
+                        .collect::<Vec<_>>()
+                        .join(" or ")
+                ),
+            );
+        }
+    }
+}
+
 /// Checks for the `OR_FUN_CALL` lint.
 #[allow(clippy::too_many_lines)]
 fn lint_or_fun_call<'tcx>(
diff --git a/tests/ui/wrong_self_convention.rs b/tests/ui/wrong_self_convention.rs
index 275866b8248..795ba77274c 100644
--- a/tests/ui/wrong_self_convention.rs
+++ b/tests/ui/wrong_self_convention.rs
@@ -90,7 +90,7 @@ mod issue4037 {
 }
 
 // Lint also in trait definition (see #6307)
-mod issue6307{
+mod issue6307 {
     trait T: Sized {
         fn as_i32(self) {}
         fn as_u32(&self) {}
@@ -102,7 +102,7 @@ mod issue6307{
         fn to_u32(&self) {}
         fn from_i32(self) {}
         // check whether the lint can be allowed at the function level
-        #[allow(clippy::wrong_pub_self_convention)]
+        #[allow(clippy::wrong_self_convention)]
         fn from_cake(self) {}
 
         // test for false positives
@@ -113,4 +113,4 @@ mod issue6307{
         fn from_(self) {}
         fn to_mut(&mut self) {}
     }
-}
\ No newline at end of file
+}
diff --git a/tests/ui/wrong_self_convention.stderr b/tests/ui/wrong_self_convention.stderr
index 64aa957fed6..289da6f059e 100644
--- a/tests/ui/wrong_self_convention.stderr
+++ b/tests/ui/wrong_self_convention.stderr
@@ -77,8 +77,6 @@ error: methods called `as_*` usually take self by reference or self by mutable r
    |
 LL |         fn as_i32(self) {}
    |                   ^^^^
-   |
-   = note: `-D clippy::wrong-pub-self-convention` implied by `-D warnings`
 
 error: methods called `into_*` usually take self by value; consider choosing a less ambiguous name
   --> $DIR/wrong_self_convention.rs:97:21
-- 
cgit 1.4.1-3-g733a5


From a7cfffef263a8b5a5dadfad0b7f56acd83d02b9b Mon Sep 17 00:00:00 2001
From: suyash458 <suyash.behera458@gmail.com>
Date: Sat, 5 Dec 2020 04:59:22 -0800
Subject: add MSRV to more lints specified in #6097 update tests

---
 clippy_lints/src/checked_conversions.rs        | 26 +++++++--
 clippy_lints/src/lib.rs                        | 15 +++---
 clippy_lints/src/mem_replace.rs                | 27 ++++++++--
 clippy_lints/src/methods/mod.rs                | 23 ++++++--
 clippy_lints/src/missing_const_for_fn.rs       | 29 ++++++++--
 clippy_lints/src/ranges.rs                     | 29 +++++++---
 clippy_lints/src/redundant_field_names.rs      | 25 +++++++--
 clippy_lints/src/redundant_static_lifetimes.rs | 26 +++++++--
 clippy_lints/src/use_self.rs                   | 25 +++++++--
 tests/ui/min_rust_version_attr.rs              | 74 +++++++++++++++++++++++++-
 tests/ui/min_rust_version_attr.stderr          | 51 ++++++++----------
 11 files changed, 282 insertions(+), 68 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/checked_conversions.rs b/clippy_lints/src/checked_conversions.rs
index 28c1a54d2c5..54bc69e058b 100644
--- a/clippy_lints/src/checked_conversions.rs
+++ b/clippy_lints/src/checked_conversions.rs
@@ -6,9 +6,12 @@ use rustc_errors::Applicability;
 use rustc_hir::{BinOp, BinOpKind, Expr, ExprKind, QPath, TyKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_semver::RustcVersion;
+use rustc_session::{declare_tool_lint, impl_lint_pass};
 
-use crate::utils::{snippet_with_applicability, span_lint_and_sugg, SpanlessEq};
+use crate::utils::{meets_msrv, snippet_with_applicability, span_lint_and_sugg, SpanlessEq};
+
+const CHECKED_CONVERSIONS_MSRV: RustcVersion = RustcVersion::new(1, 34, 0);
 
 declare_clippy_lint! {
     /// **What it does:** Checks for explicit bounds checking when casting.
@@ -39,10 +42,25 @@ declare_clippy_lint! {
     "`try_from` could replace manual bounds checking when casting"
 }
 
-declare_lint_pass!(CheckedConversions => [CHECKED_CONVERSIONS]);
+pub struct CheckedConversions {
+    msrv: Option<RustcVersion>,
+}
+
+impl CheckedConversions {
+    #[must_use]
+    pub fn new(msrv: Option<RustcVersion>) -> Self {
+        Self { msrv }
+    }
+}
+
+impl_lint_pass!(CheckedConversions => [CHECKED_CONVERSIONS]);
 
 impl<'tcx> LateLintPass<'tcx> for CheckedConversions {
     fn check_expr(&mut self, cx: &LateContext<'_>, item: &Expr<'_>) {
+        if !meets_msrv(self.msrv.as_ref(), &CHECKED_CONVERSIONS_MSRV) {
+            return;
+        }
+
         let result = if_chain! {
             if !in_external_macro(cx.sess(), item.span);
             if let ExprKind::Binary(op, ref left, ref right) = &item.kind;
@@ -74,6 +92,8 @@ impl<'tcx> LateLintPass<'tcx> for CheckedConversions {
             }
         }
     }
+
+    extract_msrv_attr!(LateContext);
 }
 
 /// Searches for a single check from unsigned to _ is done
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index a92ae9ed8d9..38a25d22aa2 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1003,6 +1003,14 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(move || box matches::Matches::new(msrv));
     store.register_early_pass(move || box manual_non_exhaustive::ManualNonExhaustive::new(msrv));
     store.register_late_pass(move || box manual_strip::ManualStrip::new(msrv));
+    store.register_early_pass(move || box redundant_static_lifetimes::RedundantStaticLifetimes::new(msrv));
+    store.register_early_pass(move || box redundant_field_names::RedundantFieldNames::new(msrv));
+    store.register_late_pass(move || box checked_conversions::CheckedConversions::new(msrv));
+    store.register_late_pass(move || box mem_replace::MemReplace::new(msrv));
+    store.register_late_pass(move || box ranges::Ranges::new(msrv));
+    store.register_late_pass(move || box use_self::UseSelf::new(msrv));
+    store.register_late_pass(move || box missing_const_for_fn::MissingConstForFn::new(msrv));
+
     store.register_late_pass(|| box size_of_in_element_count::SizeOfInElementCount);
     store.register_late_pass(|| box map_clone::MapClone);
     store.register_late_pass(|| box map_err_ignore::MapErrIgnore);
@@ -1013,7 +1021,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box main_recursion::MainRecursion::default());
     store.register_late_pass(|| box lifetimes::Lifetimes);
     store.register_late_pass(|| box entry::HashMapPass);
-    store.register_late_pass(|| box ranges::Ranges);
     store.register_late_pass(|| box types::Casts);
     let type_complexity_threshold = conf.type_complexity_threshold;
     store.register_late_pass(move || box types::TypeComplexity::new(type_complexity_threshold));
@@ -1058,7 +1065,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box neg_multiply::NegMultiply);
     store.register_late_pass(|| box mem_discriminant::MemDiscriminant);
     store.register_late_pass(|| box mem_forget::MemForget);
-    store.register_late_pass(|| box mem_replace::MemReplace);
     store.register_late_pass(|| box arithmetic::Arithmetic::default());
     store.register_late_pass(|| box assign_ops::AssignOps);
     store.register_late_pass(|| box let_if_seq::LetIfSeq);
@@ -1080,7 +1086,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(move || box pass_by_ref_or_value);
     store.register_late_pass(|| box ref_option_ref::RefOptionRef);
     store.register_late_pass(|| box try_err::TryErr);
-    store.register_late_pass(|| box use_self::UseSelf);
     store.register_late_pass(|| box bytecount::ByteCount);
     store.register_late_pass(|| box infinite_iter::InfiniteIter);
     store.register_late_pass(|| box inline_fn_without_body::InlineFnWithoutBody);
@@ -1106,10 +1111,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box unnecessary_wraps::UnnecessaryWraps);
     store.register_late_pass(|| box types::RefToMut);
     store.register_late_pass(|| box assertions_on_constants::AssertionsOnConstants);
-    store.register_late_pass(|| box missing_const_for_fn::MissingConstForFn);
     store.register_late_pass(|| box transmuting_null::TransmutingNull);
     store.register_late_pass(|| box path_buf_push_overwrite::PathBufPushOverwrite);
-    store.register_late_pass(|| box checked_conversions::CheckedConversions);
     store.register_late_pass(|| box integer_division::IntegerDivision);
     store.register_late_pass(|| box inherent_to_string::InherentToString);
     let max_trait_bounds = conf.max_trait_bounds;
@@ -1138,7 +1141,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_early_pass(|| box redundant_else::RedundantElse);
     store.register_late_pass(|| box create_dir::CreateDir);
     store.register_early_pass(|| box needless_arbitrary_self_type::NeedlessArbitrarySelfType);
-    store.register_early_pass(|| box redundant_static_lifetimes::RedundantStaticLifetimes);
     store.register_late_pass(|| box cargo_common_metadata::CargoCommonMetadata);
     store.register_late_pass(|| box multiple_crate_versions::MultipleCrateVersions);
     store.register_late_pass(|| box wildcard_dependencies::WildcardDependencies);
@@ -1178,7 +1180,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box mut_mutex_lock::MutMutexLock);
     store.register_late_pass(|| box match_on_vec_items::MatchOnVecItems);
     store.register_late_pass(|| box manual_async_fn::ManualAsyncFn);
-    store.register_early_pass(|| box redundant_field_names::RedundantFieldNames);
     store.register_late_pass(|| box vec_resize_to_zero::VecResizeToZero);
     store.register_late_pass(|| box panic_in_result_fn::PanicInResultFn);
     let single_char_binding_names_threshold = conf.single_char_binding_names_threshold;
diff --git a/clippy_lints/src/mem_replace.rs b/clippy_lints/src/mem_replace.rs
index bb0acecc5a9..19087b02077 100644
--- a/clippy_lints/src/mem_replace.rs
+++ b/clippy_lints/src/mem_replace.rs
@@ -1,13 +1,14 @@
 use crate::utils::{
-    in_macro, match_def_path, match_qpath, paths, snippet, snippet_with_applicability, span_lint_and_help,
+    in_macro, match_def_path, match_qpath, meets_msrv, paths, snippet, snippet_with_applicability, span_lint_and_help,
     span_lint_and_sugg, span_lint_and_then,
 };
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{BorrowKind, Expr, ExprKind, Mutability, QPath};
-use rustc_lint::{LateContext, LateLintPass};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_semver::RustcVersion;
+use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::Span;
 use rustc_span::symbol::sym;
 
@@ -94,7 +95,7 @@ declare_clippy_lint! {
     "replacing a value of type `T` with `T::default()` instead of using `std::mem::take`"
 }
 
-declare_lint_pass!(MemReplace =>
+impl_lint_pass!(MemReplace =>
     [MEM_REPLACE_OPTION_WITH_NONE, MEM_REPLACE_WITH_UNINIT, MEM_REPLACE_WITH_DEFAULT]);
 
 fn check_replace_option_with_none(cx: &LateContext<'_>, src: &Expr<'_>, dest: &Expr<'_>, expr_span: Span) {
@@ -224,6 +225,19 @@ fn check_replace_with_default(cx: &LateContext<'_>, src: &Expr<'_>, dest: &Expr<
     }
 }
 
+const MEM_REPLACE_WITH_DEFAULT_MSRV: RustcVersion = RustcVersion::new(1, 40, 0);
+
+pub struct MemReplace {
+    msrv: Option<RustcVersion>,
+}
+
+impl MemReplace {
+    #[must_use]
+    pub fn new(msrv: Option<RustcVersion>) -> Self {
+        Self { msrv }
+    }
+}
+
 impl<'tcx> LateLintPass<'tcx> for MemReplace {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if_chain! {
@@ -236,8 +250,11 @@ impl<'tcx> LateLintPass<'tcx> for MemReplace {
             then {
                 check_replace_option_with_none(cx, src, dest, expr.span);
                 check_replace_with_uninit(cx, src, dest, expr.span);
-                check_replace_with_default(cx, src, dest, expr.span);
+                if meets_msrv(self.msrv.as_ref(), &MEM_REPLACE_WITH_DEFAULT_MSRV) {
+                    check_replace_with_default(cx, src, dest, expr.span);
+                }
             }
         }
     }
+    extract_msrv_attr!(LateContext);
 }
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 8002c27a5e9..5133f31e0e7 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1487,7 +1487,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             ["expect", ..] => lint_expect(cx, expr, arg_lists[0]),
             ["unwrap_or", "map"] => option_map_unwrap_or::lint(cx, expr, arg_lists[1], arg_lists[0], method_spans[1]),
             ["unwrap_or_else", "map"] => {
-                if !lint_map_unwrap_or_else(cx, expr, arg_lists[1], arg_lists[0]) {
+                if !lint_map_unwrap_or_else(cx, expr, arg_lists[1], arg_lists[0], self.msrv.as_ref()) {
                     unnecessary_lazy_eval::lint(cx, expr, arg_lists[0], "unwrap_or");
                 }
             },
@@ -1509,7 +1509,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             ["next", "iter"] => lint_iter_next(cx, expr, arg_lists[1]),
             ["map", "filter"] => lint_filter_map(cx, expr, arg_lists[1], arg_lists[0]),
             ["map", "filter_map"] => lint_filter_map_map(cx, expr, arg_lists[1], arg_lists[0]),
-            ["next", "filter_map"] => lint_filter_map_next(cx, expr, arg_lists[1]),
+            ["next", "filter_map"] => lint_filter_map_next(cx, expr, arg_lists[1], self.msrv.as_ref()),
             ["map", "find"] => lint_find_map(cx, expr, arg_lists[1], arg_lists[0]),
             ["flat_map", "filter"] => lint_filter_flat_map(cx, expr, arg_lists[1], arg_lists[0]),
             ["flat_map", "filter_map"] => lint_filter_map_flat_map(cx, expr, arg_lists[1], arg_lists[0]),
@@ -2733,6 +2733,8 @@ fn lint_map_flatten<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, map
     }
 }
 
+const MAP_UNWRAP_OR_MSRV: RustcVersion = RustcVersion::new(1, 41, 0);
+
 /// lint use of `map().unwrap_or_else()` for `Option`s and `Result`s
 /// Return true if lint triggered
 fn lint_map_unwrap_or_else<'tcx>(
@@ -2740,7 +2742,11 @@ fn lint_map_unwrap_or_else<'tcx>(
     expr: &'tcx hir::Expr<'_>,
     map_args: &'tcx [hir::Expr<'_>],
     unwrap_args: &'tcx [hir::Expr<'_>],
+    msrv: Option<&RustcVersion>,
 ) -> bool {
+    if !meets_msrv(msrv, &MAP_UNWRAP_OR_MSRV) {
+        return false;
+    }
     // lint if the caller of `map()` is an `Option`
     let is_option = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&map_args[0]), sym::option_type);
     let is_result = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&map_args[0]), sym::result_type);
@@ -2923,9 +2929,20 @@ fn lint_filter_map<'tcx>(
     }
 }
 
+const FILTER_MAP_NEXT_MSRV: RustcVersion = RustcVersion::new(1, 30, 0);
+
 /// lint use of `filter_map().next()` for `Iterators`
-fn lint_filter_map_next<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, filter_args: &'tcx [hir::Expr<'_>]) {
+fn lint_filter_map_next<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx hir::Expr<'_>,
+    filter_args: &'tcx [hir::Expr<'_>],
+    msrv: Option<&RustcVersion>,
+) {
     if match_trait_method(cx, expr, &paths::ITERATOR) {
+        if !meets_msrv(msrv, &FILTER_MAP_NEXT_MSRV) {
+            return;
+        }
+
         let msg = "called `filter_map(..).next()` on an `Iterator`. This is more succinctly expressed by calling \
                    `.find_map(..)` instead.";
         let filter_snippet = snippet(cx, filter_args[1].span, "..");
diff --git a/clippy_lints/src/missing_const_for_fn.rs b/clippy_lints/src/missing_const_for_fn.rs
index 38e2ce563ee..6ebeaced62a 100644
--- a/clippy_lints/src/missing_const_for_fn.rs
+++ b/clippy_lints/src/missing_const_for_fn.rs
@@ -1,14 +1,19 @@
 use crate::utils::qualify_min_const_fn::is_min_const_fn;
-use crate::utils::{fn_has_unsatisfiable_preds, has_drop, is_entrypoint_fn, span_lint, trait_ref_of_method};
+use crate::utils::{
+    fn_has_unsatisfiable_preds, has_drop, is_entrypoint_fn, meets_msrv, span_lint, trait_ref_of_method,
+};
 use rustc_hir as hir;
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::{Body, Constness, FnDecl, GenericParamKind, HirId};
-use rustc_lint::{LateContext, LateLintPass};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_semver::RustcVersion;
+use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::Span;
 use rustc_typeck::hir_ty_to_ty;
 
+const MISSING_CONST_FOR_FN_MSRV: RustcVersion = RustcVersion::new(1, 37, 0);
+
 declare_clippy_lint! {
     /// **What it does:**
     ///
@@ -69,7 +74,18 @@ declare_clippy_lint! {
     "Lint functions definitions that could be made `const fn`"
 }
 
-declare_lint_pass!(MissingConstForFn => [MISSING_CONST_FOR_FN]);
+impl_lint_pass!(MissingConstForFn => [MISSING_CONST_FOR_FN]);
+
+pub struct MissingConstForFn {
+    msrv: Option<RustcVersion>,
+}
+
+impl MissingConstForFn {
+    #[must_use]
+    pub fn new(msrv: Option<RustcVersion>) -> Self {
+        Self { msrv }
+    }
+}
 
 impl<'tcx> LateLintPass<'tcx> for MissingConstForFn {
     fn check_fn(
@@ -81,6 +97,10 @@ impl<'tcx> LateLintPass<'tcx> for MissingConstForFn {
         span: Span,
         hir_id: HirId,
     ) {
+        if !meets_msrv(self.msrv.as_ref(), &MISSING_CONST_FOR_FN_MSRV) {
+            return;
+        }
+
         let def_id = cx.tcx.hir().local_def_id(hir_id);
 
         if in_external_macro(cx.tcx.sess, span) || is_entrypoint_fn(cx, def_id.to_def_id()) {
@@ -126,6 +146,7 @@ impl<'tcx> LateLintPass<'tcx> for MissingConstForFn {
             span_lint(cx, MISSING_CONST_FOR_FN, span, "this could be a `const fn`");
         }
     }
+    extract_msrv_attr!(LateContext);
 }
 
 /// Returns true if any of the method parameters is a type that implements `Drop`. The method
diff --git a/clippy_lints/src/ranges.rs b/clippy_lints/src/ranges.rs
index 4b514bbd42c..f9173808089 100644
--- a/clippy_lints/src/ranges.rs
+++ b/clippy_lints/src/ranges.rs
@@ -3,9 +3,10 @@ use if_chain::if_chain;
 use rustc_ast::ast::RangeLimits;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind, PathSegment, QPath};
-use rustc_lint::{LateContext, LateLintPass};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::ty;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_semver::RustcVersion;
+use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::{Span, Spanned};
 use rustc_span::sym;
 use rustc_span::symbol::Ident;
@@ -13,8 +14,8 @@ use std::cmp::Ordering;
 
 use crate::utils::sugg::Sugg;
 use crate::utils::{
-    get_parent_expr, is_integer_const, single_segment_path, snippet, snippet_opt, snippet_with_applicability,
-    span_lint, span_lint_and_sugg, span_lint_and_then,
+    get_parent_expr, is_integer_const, meets_msrv, single_segment_path, snippet, snippet_opt,
+    snippet_with_applicability, span_lint, span_lint_and_sugg, span_lint_and_then,
 };
 use crate::utils::{higher, SpanlessEq};
 
@@ -160,7 +161,20 @@ declare_clippy_lint! {
     "manually reimplementing {`Range`, `RangeInclusive`}`::contains`"
 }
 
-declare_lint_pass!(Ranges => [
+const MANUAL_RANGE_CONTAINS_MSRV: RustcVersion = RustcVersion::new(1, 35, 0);
+
+pub struct Ranges {
+    msrv: Option<RustcVersion>,
+}
+
+impl Ranges {
+    #[must_use]
+    pub fn new(msrv: Option<RustcVersion>) -> Self {
+        Self { msrv }
+    }
+}
+
+impl_lint_pass!(Ranges => [
     RANGE_ZIP_WITH_LEN,
     RANGE_PLUS_ONE,
     RANGE_MINUS_ONE,
@@ -175,7 +189,9 @@ impl<'tcx> LateLintPass<'tcx> for Ranges {
                 check_range_zip_with_len(cx, path, args, expr.span);
             },
             ExprKind::Binary(ref op, ref l, ref r) => {
-                check_possible_range_contains(cx, op.node, l, r, expr.span);
+                if meets_msrv(self.msrv.as_ref(), &MANUAL_RANGE_CONTAINS_MSRV) {
+                    check_possible_range_contains(cx, op.node, l, r, expr.span);
+                }
             },
             _ => {},
         }
@@ -184,6 +200,7 @@ impl<'tcx> LateLintPass<'tcx> for Ranges {
         check_inclusive_range_minus_one(cx, expr);
         check_reversed_empty_range(cx, expr);
     }
+    extract_msrv_attr!(LateContext);
 }
 
 fn check_possible_range_contains(cx: &LateContext<'_>, op: BinOpKind, l: &Expr<'_>, r: &Expr<'_>, span: Span) {
diff --git a/clippy_lints/src/redundant_field_names.rs b/clippy_lints/src/redundant_field_names.rs
index 2a81170e49e..38dcf7a192c 100644
--- a/clippy_lints/src/redundant_field_names.rs
+++ b/clippy_lints/src/redundant_field_names.rs
@@ -1,9 +1,12 @@
-use crate::utils::span_lint_and_sugg;
+use crate::utils::{meets_msrv, span_lint_and_sugg};
 use rustc_ast::ast::{Expr, ExprKind};
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_middle::lint::in_external_macro;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_semver::RustcVersion;
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+
+const REDUNDANT_FIELD_NAMES_MSRV: RustcVersion = RustcVersion::new(1, 17, 0);
 
 declare_clippy_lint! {
     /// **What it does:** Checks for fields in struct literals where shorthands
@@ -33,10 +36,25 @@ declare_clippy_lint! {
     "checks for fields in struct literals where shorthands could be used"
 }
 
-declare_lint_pass!(RedundantFieldNames => [REDUNDANT_FIELD_NAMES]);
+pub struct RedundantFieldNames {
+    msrv: Option<RustcVersion>,
+}
+
+impl RedundantFieldNames {
+    #[must_use]
+    pub fn new(msrv: Option<RustcVersion>) -> Self {
+        Self { msrv }
+    }
+}
+
+impl_lint_pass!(RedundantFieldNames => [REDUNDANT_FIELD_NAMES]);
 
 impl EarlyLintPass for RedundantFieldNames {
     fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
+        if !meets_msrv(self.msrv.as_ref(), &REDUNDANT_FIELD_NAMES_MSRV) {
+            return;
+        }
+
         if in_external_macro(cx.sess, expr.span) {
             return;
         }
@@ -64,4 +82,5 @@ impl EarlyLintPass for RedundantFieldNames {
             }
         }
     }
+    extract_msrv_attr!(EarlyContext);
 }
diff --git a/clippy_lints/src/redundant_static_lifetimes.rs b/clippy_lints/src/redundant_static_lifetimes.rs
index 7bbcc67aa2d..fcfa3c12755 100644
--- a/clippy_lints/src/redundant_static_lifetimes.rs
+++ b/clippy_lints/src/redundant_static_lifetimes.rs
@@ -1,8 +1,11 @@
-use crate::utils::{snippet, span_lint_and_then};
+use crate::utils::{meets_msrv, snippet, span_lint_and_then};
 use rustc_ast::ast::{Item, ItemKind, Ty, TyKind};
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_semver::RustcVersion;
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+
+const REDUNDANT_STATIC_LIFETIMES_MSRV: RustcVersion = RustcVersion::new(1, 17, 0);
 
 declare_clippy_lint! {
     /// **What it does:** Checks for constants and statics with an explicit `'static` lifetime.
@@ -29,7 +32,18 @@ declare_clippy_lint! {
     "Using explicit `'static` lifetime for constants or statics when elision rules would allow omitting them."
 }
 
-declare_lint_pass!(RedundantStaticLifetimes => [REDUNDANT_STATIC_LIFETIMES]);
+pub struct RedundantStaticLifetimes {
+    msrv: Option<RustcVersion>,
+}
+
+impl RedundantStaticLifetimes {
+    #[must_use]
+    pub fn new(msrv: Option<RustcVersion>) -> Self {
+        Self { msrv }
+    }
+}
+
+impl_lint_pass!(RedundantStaticLifetimes => [REDUNDANT_STATIC_LIFETIMES]);
 
 impl RedundantStaticLifetimes {
     // Recursively visit types
@@ -84,6 +98,10 @@ impl RedundantStaticLifetimes {
 
 impl EarlyLintPass for RedundantStaticLifetimes {
     fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {
+        if !meets_msrv(self.msrv.as_ref(), &REDUNDANT_STATIC_LIFETIMES_MSRV) {
+            return;
+        }
+
         if !item.span.from_expansion() {
             if let ItemKind::Const(_, ref var_type, _) = item.kind {
                 self.visit_type(var_type, cx, "constants have by default a `'static` lifetime");
@@ -96,4 +114,6 @@ impl EarlyLintPass for RedundantStaticLifetimes {
             }
         }
     }
+
+    extract_msrv_attr!(EarlyContext);
 }
diff --git a/clippy_lints/src/use_self.rs b/clippy_lints/src/use_self.rs
index 5ac4797680b..3b23f885e08 100644
--- a/clippy_lints/src/use_self.rs
+++ b/clippy_lints/src/use_self.rs
@@ -12,11 +12,12 @@ use rustc_middle::hir::map::Map;
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty;
 use rustc_middle::ty::{DefIdTree, Ty};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_semver::RustcVersion;
+use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::symbol::kw;
 use rustc_typeck::hir_ty_to_ty;
 
-use crate::utils::{differing_macro_contexts, span_lint_and_sugg};
+use crate::utils::{differing_macro_contexts, meets_msrv, span_lint_and_sugg};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for unnecessary repetition of structure name when a
@@ -53,7 +54,7 @@ declare_clippy_lint! {
     "unnecessary structure name repetition whereas `Self` is applicable"
 }
 
-declare_lint_pass!(UseSelf => [USE_SELF]);
+impl_lint_pass!(UseSelf => [USE_SELF]);
 
 const SEGMENTS_MSG: &str = "segments should be composed of at least 1 element";
 
@@ -157,8 +158,25 @@ fn check_trait_method_impl_decl<'tcx>(
     }
 }
 
+const USE_SELF_MSRV: RustcVersion = RustcVersion::new(1, 37, 0);
+
+pub struct UseSelf {
+    msrv: Option<RustcVersion>,
+}
+
+impl UseSelf {
+    #[must_use]
+    pub fn new(msrv: Option<RustcVersion>) -> Self {
+        Self { msrv }
+    }
+}
+
 impl<'tcx> LateLintPass<'tcx> for UseSelf {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
+        if !meets_msrv(self.msrv.as_ref(), &USE_SELF_MSRV) {
+            return;
+        }
+
         if in_external_macro(cx.sess(), item.span) {
             return;
         }
@@ -204,6 +222,7 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
             }
         }
     }
+    extract_msrv_attr!(LateContext);
 }
 
 struct UseSelfVisitor<'a, 'tcx> {
diff --git a/tests/ui/min_rust_version_attr.rs b/tests/ui/min_rust_version_attr.rs
index 1026cc40d3b..ac75f5e46c3 100644
--- a/tests/ui/min_rust_version_attr.rs
+++ b/tests/ui/min_rust_version_attr.rs
@@ -2,7 +2,7 @@
 #![feature(custom_inner_attributes)]
 #![clippy::msrv = "1.0.0"]
 
-use std::ops::Deref;
+use std::ops::{Deref, RangeFrom};
 
 fn option_as_ref_deref() {
     let mut opt = Some(String::from("123"));
@@ -42,12 +42,84 @@ pub fn manual_strip_msrv() {
     }
 }
 
+pub fn redundant_fieldnames() {
+    let start = 0;
+    let _ = RangeFrom { start: start };
+}
+
+pub fn redundant_static_lifetime() {
+    const VAR_ONE: &'static str = "Test constant #1";
+}
+
+pub fn checked_conversion() {
+    let value: i64 = 42;
+    let _ = value <= (u32::max_value() as i64) && value >= 0;
+    let _ = value <= (u32::MAX as i64) && value >= 0;
+}
+
+pub fn filter_map_next() {
+    let a = ["1", "lol", "3", "NaN", "5"];
+
+    #[rustfmt::skip]
+    let _: Option<u32> = vec![1, 2, 3, 4, 5, 6]
+        .into_iter()
+        .filter_map(|x| {
+            if x == 2 {
+                Some(x * 2)
+            } else {
+                None
+            }
+        })
+        .next();
+}
+
+pub fn manual_range_contains() {
+    x >= 8 && x < 12;
+}
+
+pub fn use_self() {
+    struct Foo {}
+
+    impl Foo {
+        fn new() -> Foo {
+            Foo {}
+        }
+        fn test() -> Foo {
+            Foo::new()
+        }
+    }
+}
+
+fn replace_with_default() {
+    let mut s = String::from("foo");
+    let _ = std::mem::replace(s, String::default());
+}
+
+fn map_unwrap_or() {
+    let opt = Some(1);
+
+    // Check for `option.map(_).unwrap_or(_)` use.
+    // Single line case.
+    let _ = opt
+        .map(|x| x + 1)
+        // Should lint even though this call is on a separate line.
+        .unwrap_or(0);
+}
+
 fn main() {
+    filter_map_next();
+    checked_conversion();
+    redundant_fieldnames();
+    redundant_static_lifetime();
     option_as_ref_deref();
     match_like_matches();
     match_same_arms();
     match_same_arms2();
     manual_strip_msrv();
+    manual_range_contains();
+    use_self();
+    replace_with_default();
+    map_unwrap_or();
 }
 
 mod meets_msrv {
diff --git a/tests/ui/min_rust_version_attr.stderr b/tests/ui/min_rust_version_attr.stderr
index 3e1af046e7a..d3eafe7312f 100644
--- a/tests/ui/min_rust_version_attr.stderr
+++ b/tests/ui/min_rust_version_attr.stderr
@@ -1,37 +1,28 @@
-error: stripping a prefix manually
-  --> $DIR/min_rust_version_attr.rs:60:24
-   |
-LL |             assert_eq!(s["hello, ".len()..].to_uppercase(), "WORLD!");
-   |                        ^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: `-D clippy::manual-strip` implied by `-D warnings`
-note: the prefix was tested here
-  --> $DIR/min_rust_version_attr.rs:59:9
-   |
-LL |         if s.starts_with("hello, ") {
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-help: try using the `strip_prefix` method
-   |
-LL |         if let Some(<stripped>) = s.strip_prefix("hello, ") {
-LL |             assert_eq!(<stripped>.to_uppercase(), "WORLD!");
+error[E0425]: cannot find value `x` in this scope
+  --> $DIR/min_rust_version_attr.rs:77:5
    |
+LL |     x >= 8 && x < 12;
+   |     ^ not found in this scope
 
-error: stripping a prefix manually
-  --> $DIR/min_rust_version_attr.rs:72:24
+error[E0425]: cannot find value `x` in this scope
+  --> $DIR/min_rust_version_attr.rs:77:15
    |
-LL |             assert_eq!(s["hello, ".len()..].to_uppercase(), "WORLD!");
-   |                        ^^^^^^^^^^^^^^^^^^^^
-   |
-note: the prefix was tested here
-  --> $DIR/min_rust_version_attr.rs:71:9
-   |
-LL |         if s.starts_with("hello, ") {
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-help: try using the `strip_prefix` method
+LL |     x >= 8 && x < 12;
+   |               ^ not found in this scope
+
+error[E0308]: mismatched types
+  --> $DIR/min_rust_version_attr.rs:95:31
    |
-LL |         if let Some(<stripped>) = s.strip_prefix("hello, ") {
-LL |             assert_eq!(<stripped>.to_uppercase(), "WORLD!");
+LL |     let _ = std::mem::replace(s, String::default());
+   |                               ^
+   |                               |
+   |                               expected `&mut _`, found struct `std::string::String`
+   |                               help: consider mutably borrowing here: `&mut s`
    |
+   = note: expected mutable reference `&mut _`
+                         found struct `std::string::String`
 
-error: aborting due to 2 previous errors
+error: aborting due to 3 previous errors
 
+Some errors have detailed explanations: E0308, E0425.
+For more information about an error, try `rustc --explain E0308`.
-- 
cgit 1.4.1-3-g733a5


From 26c61c7e49b173c8ae7c54c3a4c90b60cd9f71b8 Mon Sep 17 00:00:00 2001
From: Takayuki Nakata <f.seasons017@gmail.com>
Date: Wed, 25 Nov 2020 17:07:50 +0900
Subject: Fix FP of `manual_range_contains` in `const fn`

---
 clippy_lints/src/ranges.rs    | 11 ++++++++---
 tests/ui/range_contains.fixed |  5 +++++
 tests/ui/range_contains.rs    |  5 +++++
 3 files changed, 18 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/ranges.rs b/clippy_lints/src/ranges.rs
index f9173808089..3e454eecd97 100644
--- a/clippy_lints/src/ranges.rs
+++ b/clippy_lints/src/ranges.rs
@@ -14,7 +14,7 @@ use std::cmp::Ordering;
 
 use crate::utils::sugg::Sugg;
 use crate::utils::{
-    get_parent_expr, is_integer_const, meets_msrv, single_segment_path, snippet, snippet_opt,
+    get_parent_expr, in_constant, is_integer_const, meets_msrv, single_segment_path, snippet, snippet_opt,
     snippet_with_applicability, span_lint, span_lint_and_sugg, span_lint_and_then,
 };
 use crate::utils::{higher, SpanlessEq};
@@ -190,7 +190,7 @@ impl<'tcx> LateLintPass<'tcx> for Ranges {
             },
             ExprKind::Binary(ref op, ref l, ref r) => {
                 if meets_msrv(self.msrv.as_ref(), &MANUAL_RANGE_CONTAINS_MSRV) {
-                    check_possible_range_contains(cx, op.node, l, r, expr.span);
+                    check_possible_range_contains(cx, op.node, l, r, expr);
                 }
             },
             _ => {},
@@ -203,7 +203,12 @@ impl<'tcx> LateLintPass<'tcx> for Ranges {
     extract_msrv_attr!(LateContext);
 }
 
-fn check_possible_range_contains(cx: &LateContext<'_>, op: BinOpKind, l: &Expr<'_>, r: &Expr<'_>, span: Span) {
+fn check_possible_range_contains(cx: &LateContext<'_>, op: BinOpKind, l: &Expr<'_>, r: &Expr<'_>, expr: &Expr<'_>) {
+    if in_constant(cx, expr.hir_id) {
+        return;
+    }
+
+    let span = expr.span;
     let combine_and = match op {
         BinOpKind::And | BinOpKind::BitAnd => true,
         BinOpKind::Or | BinOpKind::BitOr => false,
diff --git a/tests/ui/range_contains.fixed b/tests/ui/range_contains.fixed
index 048874a7f82..47c974e614b 100644
--- a/tests/ui/range_contains.fixed
+++ b/tests/ui/range_contains.fixed
@@ -44,3 +44,8 @@ fn main() {
     (0. ..1.).contains(&y);
     !(0. ..=1.).contains(&y);
 }
+
+// Fix #6373
+pub const fn in_range(a: i32) -> bool {
+    3 <= a && a <= 20
+}
diff --git a/tests/ui/range_contains.rs b/tests/ui/range_contains.rs
index 60ad259f404..835deced5e4 100644
--- a/tests/ui/range_contains.rs
+++ b/tests/ui/range_contains.rs
@@ -44,3 +44,8 @@ fn main() {
     y >= 0. && y < 1.;
     y < 0. || y > 1.;
 }
+
+// Fix #6373
+pub const fn in_range(a: i32) -> bool {
+    3 <= a && a <= 20
+}
-- 
cgit 1.4.1-3-g733a5


From 0b145d688b293a92cd855000f249d83acae53f9d Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Sat, 12 Dec 2020 01:09:30 +0100
Subject: clone_double_ref: print reference type in lint message

changelog: clone_double_ref: print the type of the reference in lint message
---
 clippy_lints/src/methods/mod.rs   | 7 +++++--
 tests/ui/unnecessary_clone.stderr | 6 +++---
 2 files changed, 8 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 5133f31e0e7..ce234e01a1b 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -2100,8 +2100,11 @@ fn lint_clone_on_copy(cx: &LateContext<'_>, expr: &hir::Expr<'_>, arg: &hir::Exp
                 cx,
                 CLONE_DOUBLE_REF,
                 expr.span,
-                "using `clone` on a double-reference; \
-                this will copy the reference instead of cloning the inner type",
+                &format!(
+                    "using `clone` on a double-reference; \
+                    this will copy the reference of type `{}` instead of cloning the inner type",
+                    ty
+                ),
                 |diag| {
                     if let Some(snip) = sugg::Sugg::hir_opt(cx, arg) {
                         let mut ty = innermost;
diff --git a/tests/ui/unnecessary_clone.stderr b/tests/ui/unnecessary_clone.stderr
index 5ffa6c4fd06..b908d0ce9c1 100644
--- a/tests/ui/unnecessary_clone.stderr
+++ b/tests/ui/unnecessary_clone.stderr
@@ -44,7 +44,7 @@ error: using `clone` on a `Copy` type
 LL |     Some(t).clone();
    |     ^^^^^^^^^^^^^^^ help: try removing the `clone` call: `Some(t)`
 
-error: using `clone` on a double-reference; this will copy the reference instead of cloning the inner type
+error: using `clone` on a double-reference; this will copy the reference of type `&std::vec::Vec<i32>` instead of cloning the inner type
   --> $DIR/unnecessary_clone.rs:48:22
    |
 LL |     let z: &Vec<_> = y.clone();
@@ -66,7 +66,7 @@ error: using `clone` on a `Copy` type
 LL |         let _: E = a.clone();
    |                    ^^^^^^^^^ help: try dereferencing it: `*****a`
 
-error: using `clone` on a double-reference; this will copy the reference instead of cloning the inner type
+error: using `clone` on a double-reference; this will copy the reference of type `&[u8]` instead of cloning the inner type
   --> $DIR/unnecessary_clone.rs:89:22
    |
 LL |         let _ = &mut encoded.clone();
@@ -81,7 +81,7 @@ help: or try being explicit if you are sure, that you want to clone a reference
 LL |         let _ = &mut <&[u8]>::clone(encoded);
    |                      ^^^^^^^^^^^^^^^^^^^^^^^
 
-error: using `clone` on a double-reference; this will copy the reference instead of cloning the inner type
+error: using `clone` on a double-reference; this will copy the reference of type `&[u8]` instead of cloning the inner type
   --> $DIR/unnecessary_clone.rs:90:18
    |
 LL |         let _ = &encoded.clone();
-- 
cgit 1.4.1-3-g733a5


From b2cb6ffbe3735ef8f137c9a6c1290c4a078793ef Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Sat, 12 Dec 2020 01:23:28 +0100
Subject: clone_on_copy: show the type in the lint message

changelog: clone_on_copy: show the type in the lint message
---
 clippy_lints/src/methods/mod.rs   | 16 +++++++++++-----
 tests/ui/clone_on_copy.stderr     | 10 +++++-----
 tests/ui/unnecessary_clone.stderr |  6 +++---
 3 files changed, 19 insertions(+), 13 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 5133f31e0e7..03eaee35fc4 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -2174,11 +2174,17 @@ fn lint_clone_on_copy(cx: &LateContext<'_>, expr: &hir::Expr<'_>, arg: &hir::Exp
         } else {
             snip = None;
         }
-        span_lint_and_then(cx, CLONE_ON_COPY, expr.span, "using `clone` on a `Copy` type", |diag| {
-            if let Some((text, snip)) = snip {
-                diag.span_suggestion(expr.span, text, snip, Applicability::MachineApplicable);
-            }
-        });
+        span_lint_and_then(
+            cx,
+            CLONE_ON_COPY,
+            expr.span,
+            &format!("using `clone` on type `{}` which implements the `Copy` trait", ty),
+            |diag| {
+                if let Some((text, snip)) = snip {
+                    diag.span_suggestion(expr.span, text, snip, Applicability::MachineApplicable);
+                }
+            },
+        );
     }
 }
 
diff --git a/tests/ui/clone_on_copy.stderr b/tests/ui/clone_on_copy.stderr
index ec2faf4ab40..14a700886a7 100644
--- a/tests/ui/clone_on_copy.stderr
+++ b/tests/ui/clone_on_copy.stderr
@@ -1,4 +1,4 @@
-error: using `clone` on a `Copy` type
+error: using `clone` on type `i32` which implements the `Copy` trait
   --> $DIR/clone_on_copy.rs:22:5
    |
 LL |     42.clone();
@@ -6,25 +6,25 @@ LL |     42.clone();
    |
    = note: `-D clippy::clone-on-copy` implied by `-D warnings`
 
-error: using `clone` on a `Copy` type
+error: using `clone` on type `i32` which implements the `Copy` trait
   --> $DIR/clone_on_copy.rs:26:5
    |
 LL |     (&42).clone();
    |     ^^^^^^^^^^^^^ help: try dereferencing it: `*(&42)`
 
-error: using `clone` on a `Copy` type
+error: using `clone` on type `i32` which implements the `Copy` trait
   --> $DIR/clone_on_copy.rs:29:5
    |
 LL |     rc.borrow().clone();
    |     ^^^^^^^^^^^^^^^^^^^ help: try dereferencing it: `*rc.borrow()`
 
-error: using `clone` on a `Copy` type
+error: using `clone` on type `char` which implements the `Copy` trait
   --> $DIR/clone_on_copy.rs:35:14
    |
 LL |     is_ascii('z'.clone());
    |              ^^^^^^^^^^^ help: try removing the `clone` call: `'z'`
 
-error: using `clone` on a `Copy` type
+error: using `clone` on type `i32` which implements the `Copy` trait
   --> $DIR/clone_on_copy.rs:39:14
    |
 LL |     vec.push(42.clone());
diff --git a/tests/ui/unnecessary_clone.stderr b/tests/ui/unnecessary_clone.stderr
index 5ffa6c4fd06..bb2dd998f27 100644
--- a/tests/ui/unnecessary_clone.stderr
+++ b/tests/ui/unnecessary_clone.stderr
@@ -30,7 +30,7 @@ error: using `.clone()` on a ref-counted pointer
 LL |     let _: Arc<dyn SomeTrait> = x.clone();
    |                                 ^^^^^^^^^ help: try this: `Arc::<SomeImpl>::clone(&x)`
 
-error: using `clone` on a `Copy` type
+error: using `clone` on type `T` which implements the `Copy` trait
   --> $DIR/unnecessary_clone.rs:40:5
    |
 LL |     t.clone();
@@ -38,7 +38,7 @@ LL |     t.clone();
    |
    = note: `-D clippy::clone-on-copy` implied by `-D warnings`
 
-error: using `clone` on a `Copy` type
+error: using `clone` on type `std::option::Option<T>` which implements the `Copy` trait
   --> $DIR/unnecessary_clone.rs:42:5
    |
 LL |     Some(t).clone();
@@ -60,7 +60,7 @@ help: or try being explicit if you are sure, that you want to clone a reference
 LL |     let z: &Vec<_> = <&std::vec::Vec<i32>>::clone(y);
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: using `clone` on a `Copy` type
+error: using `clone` on type `many_derefs::E` which implements the `Copy` trait
   --> $DIR/unnecessary_clone.rs:84:20
    |
 LL |         let _: E = a.clone();
-- 
cgit 1.4.1-3-g733a5


From 3af09b8cf1229fb05a549a13b144aca6b60784c7 Mon Sep 17 00:00:00 2001
From: Michael Wright <mikerite@lavabit.com>
Date: Sun, 13 Dec 2020 06:32:41 +0200
Subject: New internal lint: interning_defined_symbol

---
 clippy_lints/src/lib.rs                           |  4 ++
 clippy_lints/src/utils/internal_lints.rs          | 80 +++++++++++++++++++++++
 clippy_lints/src/utils/paths.rs                   |  6 ++
 tests/ui-internal/interning_defined_symbol.fixed  | 33 ++++++++++
 tests/ui-internal/interning_defined_symbol.rs     | 33 ++++++++++
 tests/ui-internal/interning_defined_symbol.stderr | 27 ++++++++
 6 files changed, 183 insertions(+)
 create mode 100644 tests/ui-internal/interning_defined_symbol.fixed
 create mode 100644 tests/ui-internal/interning_defined_symbol.rs
 create mode 100644 tests/ui-internal/interning_defined_symbol.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index f06926fa91d..97018599b05 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -513,6 +513,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         #[cfg(feature = "internal-lints")]
         &utils::internal_lints::INVALID_PATHS,
         #[cfg(feature = "internal-lints")]
+        &utils::internal_lints::INTERNING_DEFINED_SYMBOL,
+        #[cfg(feature = "internal-lints")]
         &utils::internal_lints::LINT_WITHOUT_LINT_PASS,
         #[cfg(feature = "internal-lints")]
         &utils::internal_lints::MATCH_TYPE_ON_DIAGNOSTIC_ITEM,
@@ -958,6 +960,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         store.register_late_pass(|| box utils::internal_lints::CollapsibleCalls);
         store.register_late_pass(|| box utils::internal_lints::CompilerLintFunctions::new());
         store.register_late_pass(|| box utils::internal_lints::InvalidPaths);
+        store.register_late_pass(|| box utils::internal_lints::InterningDefinedSymbol::default());
         store.register_late_pass(|| box utils::internal_lints::LintWithoutLintPass::default());
         store.register_late_pass(|| box utils::internal_lints::MatchTypeOnDiagItem);
         store.register_late_pass(|| box utils::internal_lints::OuterExpnDataPass);
@@ -1350,6 +1353,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&utils::internal_lints::COMPILER_LINT_FUNCTIONS),
         LintId::of(&utils::internal_lints::DEFAULT_LINT),
         LintId::of(&utils::internal_lints::INVALID_PATHS),
+        LintId::of(&utils::internal_lints::INTERNING_DEFINED_SYMBOL),
         LintId::of(&utils::internal_lints::LINT_WITHOUT_LINT_PASS),
         LintId::of(&utils::internal_lints::MATCH_TYPE_ON_DIAGNOSTIC_ITEM),
         LintId::of(&utils::internal_lints::OUTER_EXPN_EXPN_DATA),
diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs
index 8b59a9541a7..0de87fab528 100644
--- a/clippy_lints/src/utils/internal_lints.rs
+++ b/clippy_lints/src/utils/internal_lints.rs
@@ -15,6 +15,7 @@ use rustc_hir::intravisit::{NestedVisitorMap, Visitor};
 use rustc_hir::{Crate, Expr, ExprKind, HirId, Item, MutTy, Mutability, Node, Path, StmtKind, Ty, TyKind};
 use rustc_lint::{EarlyContext, EarlyLintPass, LateContext, LateLintPass};
 use rustc_middle::hir::map::Map;
+use rustc_middle::mir::interpret::ConstValue;
 use rustc_middle::ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::{Span, Spanned};
@@ -247,6 +248,30 @@ declare_clippy_lint! {
     "invalid path"
 }
 
+declare_clippy_lint! {
+    /// **What it does:**
+    /// Checks for interning symbols that have already been pre-interned and defined as constants.
+    ///
+    /// **Why is this bad?**
+    /// It's faster and easier to use the symbol constant.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// Bad:
+    /// ```rust,ignore
+    /// let _ = sym!(f32);
+    /// ```
+    ///
+    /// Good:
+    /// ```rust,ignore
+    /// let _ = sym::f32;
+    /// ```
+    pub INTERNING_DEFINED_SYMBOL,
+    internal,
+    "interning a symbol that is pre-interned and defined as a constant"
+}
+
 declare_lint_pass!(ClippyLintsInternal => [CLIPPY_LINTS_INTERNAL]);
 
 impl EarlyLintPass for ClippyLintsInternal {
@@ -840,3 +865,58 @@ impl<'tcx> LateLintPass<'tcx> for InvalidPaths {
         }
     }
 }
+
+#[derive(Default)]
+pub struct InterningDefinedSymbol {
+    // Maps the symbol to the constant name.
+    symbol_map: FxHashMap<String, String>,
+}
+
+impl_lint_pass!(InterningDefinedSymbol => [INTERNING_DEFINED_SYMBOL]);
+
+impl<'tcx> LateLintPass<'tcx> for InterningDefinedSymbol {
+    fn check_crate(&mut self, cx: &LateContext<'_>, _: &Crate<'_>) {
+        if !self.symbol_map.is_empty() {
+            return;
+        }
+
+        if let Some(Res::Def(_, def_id)) = path_to_res(cx, &paths::SYM_MODULE) {
+            for item in cx.tcx.item_children(def_id).iter() {
+                if_chain! {
+                    if let Res::Def(DefKind::Const, item_def_id) = item.res;
+                    let ty = cx.tcx.type_of(item_def_id);
+                    if match_type(cx, ty, &paths::SYMBOL);
+                    if let Ok(ConstValue::Scalar(value)) = cx.tcx.const_eval_poly(item_def_id);
+                    if let Ok(value) = value.to_u32();
+                    then {
+                        // SAFETY: We're converting the raw bytes of the symbol value back
+                        // into a Symbol instance.
+                        let symbol = unsafe { std::mem::transmute::<u32, Symbol>(value) };
+                        self.symbol_map.insert(symbol.to_string(), item.ident.to_string());
+                    }
+                }
+            }
+        }
+    }
+
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        if_chain! {
+            if let ExprKind::Call(func, [arg]) = &expr.kind;
+            if let ty::FnDef(def_id, _) = cx.typeck_results().expr_ty(func).kind();
+            if match_def_path(cx, *def_id, &paths::SYMBOL_INTERN);
+            if let Some(Constant::Str(arg)) = constant_simple(cx, cx.typeck_results(), arg);
+            if let Some(symbol_const) = self.symbol_map.get(&arg);
+            then {
+                span_lint_and_sugg(
+                    cx,
+                    INTERNING_DEFINED_SYMBOL,
+                    is_expn_of(expr.span, "sym").unwrap_or(expr.span),
+                    "interning a defined symbol",
+                    "try",
+                    format!("rustc_span::symbol::sym::{}", symbol_const),
+                    Applicability::MachineApplicable,
+                );
+            }
+        }
+    }
+}
diff --git a/clippy_lints/src/utils/paths.rs b/clippy_lints/src/utils/paths.rs
index 6fdc7b4587f..2080a49a11c 100644
--- a/clippy_lints/src/utils/paths.rs
+++ b/clippy_lints/src/utils/paths.rs
@@ -146,6 +146,12 @@ pub const STR_FROM_UTF8: [&str; 4] = ["core", "str", "converts", "from_utf8"];
 pub const STR_LEN: [&str; 4] = ["core", "str", "<impl str>", "len"];
 pub const STR_STARTS_WITH: [&str; 4] = ["core", "str", "<impl str>", "starts_with"];
 #[cfg(feature = "internal-lints")]
+pub const SYMBOL: [&str; 3] = ["rustc_span", "symbol", "Symbol"];
+#[cfg(feature = "internal-lints")]
+pub const SYMBOL_INTERN: [&str; 4] = ["rustc_span", "symbol", "Symbol", "intern"];
+#[cfg(feature = "internal-lints")]
+pub const SYM_MODULE: [&str; 3] = ["rustc_span", "symbol", "sym"];
+#[cfg(feature = "internal-lints")]
 pub const SYNTAX_CONTEXT: [&str; 3] = ["rustc_span", "hygiene", "SyntaxContext"];
 pub const TO_OWNED: [&str; 3] = ["alloc", "borrow", "ToOwned"];
 pub const TO_OWNED_METHOD: [&str; 4] = ["alloc", "borrow", "ToOwned", "to_owned"];
diff --git a/tests/ui-internal/interning_defined_symbol.fixed b/tests/ui-internal/interning_defined_symbol.fixed
new file mode 100644
index 00000000000..c6b84d2ef65
--- /dev/null
+++ b/tests/ui-internal/interning_defined_symbol.fixed
@@ -0,0 +1,33 @@
+// run-rustfix
+#![deny(clippy::internal)]
+#![feature(rustc_private)]
+
+extern crate rustc_span;
+
+use rustc_span::symbol::Symbol;
+
+macro_rules! sym {
+    ($tt:tt) => {
+        rustc_span::symbol::Symbol::intern(stringify!($tt))
+    };
+}
+
+fn main() {
+    // Direct use of Symbol::intern
+    let _ = rustc_span::symbol::sym::f32;
+
+    // Using a sym macro
+    let _ = rustc_span::symbol::sym::f32;
+
+    // Correct suggestion when symbol isn't stringified constant name
+    let _ = rustc_span::symbol::sym::proc_dash_macro;
+
+    // Interning a symbol that is not defined
+    let _ = Symbol::intern("xyz123");
+    let _ = sym!(xyz123);
+
+    // Using a different `intern` function
+    let _ = intern("f32");
+}
+
+fn intern(_: &str) {}
diff --git a/tests/ui-internal/interning_defined_symbol.rs b/tests/ui-internal/interning_defined_symbol.rs
new file mode 100644
index 00000000000..9ec82d4ad0b
--- /dev/null
+++ b/tests/ui-internal/interning_defined_symbol.rs
@@ -0,0 +1,33 @@
+// run-rustfix
+#![deny(clippy::internal)]
+#![feature(rustc_private)]
+
+extern crate rustc_span;
+
+use rustc_span::symbol::Symbol;
+
+macro_rules! sym {
+    ($tt:tt) => {
+        rustc_span::symbol::Symbol::intern(stringify!($tt))
+    };
+}
+
+fn main() {
+    // Direct use of Symbol::intern
+    let _ = Symbol::intern("f32");
+
+    // Using a sym macro
+    let _ = sym!(f32);
+
+    // Correct suggestion when symbol isn't stringified constant name
+    let _ = Symbol::intern("proc-macro");
+
+    // Interning a symbol that is not defined
+    let _ = Symbol::intern("xyz123");
+    let _ = sym!(xyz123);
+
+    // Using a different `intern` function
+    let _ = intern("f32");
+}
+
+fn intern(_: &str) {}
diff --git a/tests/ui-internal/interning_defined_symbol.stderr b/tests/ui-internal/interning_defined_symbol.stderr
new file mode 100644
index 00000000000..74b906c8a57
--- /dev/null
+++ b/tests/ui-internal/interning_defined_symbol.stderr
@@ -0,0 +1,27 @@
+error: interning a defined symbol
+  --> $DIR/interning_defined_symbol.rs:17:13
+   |
+LL |     let _ = Symbol::intern("f32");
+   |             ^^^^^^^^^^^^^^^^^^^^^ help: try: `rustc_span::symbol::sym::f32`
+   |
+note: the lint level is defined here
+  --> $DIR/interning_defined_symbol.rs:2:9
+   |
+LL | #![deny(clippy::internal)]
+   |         ^^^^^^^^^^^^^^^^
+   = note: `#[deny(clippy::interning_defined_symbol)]` implied by `#[deny(clippy::internal)]`
+
+error: interning a defined symbol
+  --> $DIR/interning_defined_symbol.rs:20:13
+   |
+LL |     let _ = sym!(f32);
+   |             ^^^^^^^^^ help: try: `rustc_span::symbol::sym::f32`
+
+error: interning a defined symbol
+  --> $DIR/interning_defined_symbol.rs:23:13
+   |
+LL |     let _ = Symbol::intern("proc-macro");
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `rustc_span::symbol::sym::proc_dash_macro`
+
+error: aborting due to 3 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From a6aa0acbeaeb74a50e08bfa2b18df4e22dbd9894 Mon Sep 17 00:00:00 2001
From: Michael Wright <mikerite@lavabit.com>
Date: Sun, 13 Dec 2020 06:32:41 +0200
Subject: Fix dogfood errors

---
 clippy_lints/src/manual_ok_or.rs      |  3 ++-
 clippy_lints/src/methods/mod.rs       | 10 +++++-----
 clippy_lints/src/ref_option_ref.rs    |  3 ++-
 clippy_lints/src/strings.rs           |  2 +-
 clippy_lints/src/unnecessary_wraps.rs |  5 +++--
 5 files changed, 13 insertions(+), 10 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_ok_or.rs b/clippy_lints/src/manual_ok_or.rs
index c99d2e35b94..b97d97ea1a5 100644
--- a/clippy_lints/src/manual_ok_or.rs
+++ b/clippy_lints/src/manual_ok_or.rs
@@ -8,6 +8,7 @@ use rustc_lint::LintContext;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::symbol::sym;
 
 declare_clippy_lint! {
     /// **What it does:**
@@ -51,7 +52,7 @@ impl LateLintPass<'_> for ManualOkOr {
             if args.len() == 3;
             let method_receiver = &args[0];
             let ty = cx.typeck_results().expr_ty(method_receiver);
-            if is_type_diagnostic_item(cx, ty, sym!(option_type));
+            if is_type_diagnostic_item(cx, ty, sym::option_type);
             let or_expr = &args[1];
             if is_ok_wrapping(cx, &args[2]);
             if let ExprKind::Call(Expr { kind: ExprKind::Path(err_path), .. }, &[ref err_arg]) = or_expr.kind;
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 5133f31e0e7..c5eab2a97fe 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1568,7 +1568,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
                 lint_expect_fun_call(cx, expr, *method_span, &method_call.ident.as_str(), args);
 
                 let self_ty = cx.typeck_results().expr_ty_adjusted(&args[0]);
-                if args.len() == 1 && method_call.ident.name == sym!(clone) {
+                if args.len() == 1 && method_call.ident.name == sym::clone {
                     lint_clone_on_copy(cx, expr, &args[0], self_ty);
                     lint_clone_on_ref_ptr(cx, expr, &args[0]);
                 }
@@ -1592,7 +1592,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
                             }
                         }
                     },
-                    ty::Ref(..) if method_call.ident.name == sym!(into_iter) => {
+                    ty::Ref(..) if method_call.ident.name == sym::into_iter => {
                         lint_into_iter(cx, expr, self_ty, *method_span);
                     },
                     _ => (),
@@ -2638,9 +2638,9 @@ fn lint_unwrap(cx: &LateContext<'_>, expr: &hir::Expr<'_>, unwrap_args: &[hir::E
 fn lint_expect(cx: &LateContext<'_>, expr: &hir::Expr<'_>, expect_args: &[hir::Expr<'_>]) {
     let obj_ty = cx.typeck_results().expr_ty(&expect_args[0]).peel_refs();
 
-    let mess = if is_type_diagnostic_item(cx, obj_ty, sym!(option_type)) {
+    let mess = if is_type_diagnostic_item(cx, obj_ty, sym::option_type) {
         Some((EXPECT_USED, "an Option", "None"))
-    } else if is_type_diagnostic_item(cx, obj_ty, sym!(result_type)) {
+    } else if is_type_diagnostic_item(cx, obj_ty, sym::result_type) {
         Some((EXPECT_USED, "a Result", "Err"))
     } else {
         None
@@ -3133,7 +3133,7 @@ fn lint_search_is_some<'tcx>(
     else if search_method == "find" {
         let is_string_or_str_slice = |e| {
             let self_ty = cx.typeck_results().expr_ty(e).peel_refs();
-            if is_type_diagnostic_item(cx, self_ty, sym!(string_type)) {
+            if is_type_diagnostic_item(cx, self_ty, sym::string_type) {
                 true
             } else {
                 *self_ty.kind() == ty::Str
diff --git a/clippy_lints/src/ref_option_ref.rs b/clippy_lints/src/ref_option_ref.rs
index a914a77d48b..803ebada54b 100644
--- a/clippy_lints/src/ref_option_ref.rs
+++ b/clippy_lints/src/ref_option_ref.rs
@@ -2,6 +2,7 @@ use crate::utils::{last_path_segment, snippet, span_lint_and_sugg};
 use rustc_hir::{GenericArg, Mutability, Ty, TyKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::symbol::sym;
 
 use if_chain::if_chain;
 use rustc_errors::Applicability;
@@ -41,7 +42,7 @@ impl<'tcx> LateLintPass<'tcx> for RefOptionRef {
             if let Some(res) = last.res;
             if let Some(def_id) = res.opt_def_id();
 
-            if cx.tcx.is_diagnostic_item(sym!(option_type), def_id);
+            if cx.tcx.is_diagnostic_item(sym::option_type, def_id);
             if let Some(ref params) = last_path_segment(qpath).args ;
             if !params.parenthesized;
             if let Some(inner_ty) = params.args.iter().find_map(|arg| match arg {
diff --git a/clippy_lints/src/strings.rs b/clippy_lints/src/strings.rs
index 77e79073378..31dd5965473 100644
--- a/clippy_lints/src/strings.rs
+++ b/clippy_lints/src/strings.rs
@@ -372,7 +372,7 @@ impl LateLintPass<'_> for StringToString {
             if let ExprKind::MethodCall(path, _, args, _) = &expr.kind;
             if path.ident.name == sym!(to_string);
             let ty = cx.typeck_results().expr_ty(&args[0]);
-            if is_type_diagnostic_item(cx, ty, sym!(string_type));
+            if is_type_diagnostic_item(cx, ty, sym::string_type);
             then {
                 span_lint_and_help(
                     cx,
diff --git a/clippy_lints/src/unnecessary_wraps.rs b/clippy_lints/src/unnecessary_wraps.rs
index e763da593d4..5b9a80f92db 100644
--- a/clippy_lints/src/unnecessary_wraps.rs
+++ b/clippy_lints/src/unnecessary_wraps.rs
@@ -9,6 +9,7 @@ use rustc_hir::{Body, ExprKind, FnDecl, HirId, ItemKind, Node};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::subst::GenericArgKind;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::symbol::sym;
 use rustc_span::Span;
 
 declare_clippy_lint! {
@@ -82,9 +83,9 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryWraps {
             }
         }
 
-        let (return_type, path) = if is_type_diagnostic_item(cx, return_ty(cx, hir_id), sym!(option_type)) {
+        let (return_type, path) = if is_type_diagnostic_item(cx, return_ty(cx, hir_id), sym::option_type) {
             ("Option", &paths::OPTION_SOME)
-        } else if is_type_diagnostic_item(cx, return_ty(cx, hir_id), sym!(result_type)) {
+        } else if is_type_diagnostic_item(cx, return_ty(cx, hir_id), sym::result_type) {
             ("Result", &paths::RESULT_OK)
         } else {
             return;
-- 
cgit 1.4.1-3-g733a5


From 64e630c28018972479394a2fbdcc9f7d8856bb91 Mon Sep 17 00:00:00 2001
From: Michael Wright <mikerite@lavabit.com>
Date: Sun, 13 Dec 2020 06:46:08 +0200
Subject: Run 'cargo dev update_lints'

---
 clippy_lints/src/lib.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 97018599b05..0498d469c00 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -511,10 +511,10 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         #[cfg(feature = "internal-lints")]
         &utils::internal_lints::DEFAULT_LINT,
         #[cfg(feature = "internal-lints")]
-        &utils::internal_lints::INVALID_PATHS,
-        #[cfg(feature = "internal-lints")]
         &utils::internal_lints::INTERNING_DEFINED_SYMBOL,
         #[cfg(feature = "internal-lints")]
+        &utils::internal_lints::INVALID_PATHS,
+        #[cfg(feature = "internal-lints")]
         &utils::internal_lints::LINT_WITHOUT_LINT_PASS,
         #[cfg(feature = "internal-lints")]
         &utils::internal_lints::MATCH_TYPE_ON_DIAGNOSTIC_ITEM,
@@ -1352,8 +1352,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&utils::internal_lints::COLLAPSIBLE_SPAN_LINT_CALLS),
         LintId::of(&utils::internal_lints::COMPILER_LINT_FUNCTIONS),
         LintId::of(&utils::internal_lints::DEFAULT_LINT),
-        LintId::of(&utils::internal_lints::INVALID_PATHS),
         LintId::of(&utils::internal_lints::INTERNING_DEFINED_SYMBOL),
+        LintId::of(&utils::internal_lints::INVALID_PATHS),
         LintId::of(&utils::internal_lints::LINT_WITHOUT_LINT_PASS),
         LintId::of(&utils::internal_lints::MATCH_TYPE_ON_DIAGNOSTIC_ITEM),
         LintId::of(&utils::internal_lints::OUTER_EXPN_EXPN_DATA),
-- 
cgit 1.4.1-3-g733a5


From cd2a62cb0cf89f5b4105c1c40651cf0eeaa85b14 Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Sun, 13 Dec 2020 15:17:47 +0100
Subject: needless_borrow: print the type in the lint message

changelog: needless_borrow: print type in lint message
---
 clippy_lints/src/needless_borrow.rs | 7 +++++--
 tests/ui/eta.stderr                 | 2 +-
 tests/ui/needless_borrow.stderr     | 4 ++--
 3 files changed, 8 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/needless_borrow.rs b/clippy_lints/src/needless_borrow.rs
index 405c21d608d..bff53eb8cca 100644
--- a/clippy_lints/src/needless_borrow.rs
+++ b/clippy_lints/src/needless_borrow.rs
@@ -47,7 +47,7 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessBorrow {
             return;
         }
         if let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Not, ref inner) = e.kind {
-            if let ty::Ref(..) = cx.typeck_results().expr_ty(inner).kind() {
+            if let ty::Ref(_, ty, _) = cx.typeck_results().expr_ty(inner).kind() {
                 for adj3 in cx.typeck_results().expr_adjustments(e).windows(3) {
                     if let [Adjustment {
                         kind: Adjust::Deref(_), ..
@@ -62,8 +62,11 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessBorrow {
                             cx,
                             NEEDLESS_BORROW,
                             e.span,
-                            "this expression borrows a reference that is immediately dereferenced \
+                            &format!(
+                                "this expression borrows a reference (`&{}`) that is immediately dereferenced \
                              by the compiler",
+                                ty
+                            ),
                             |diag| {
                                 if let Some(snippet) = snippet_opt(cx, inner.span) {
                                     diag.span_suggestion(
diff --git a/tests/ui/eta.stderr b/tests/ui/eta.stderr
index c4713ca8083..16aa1b07733 100644
--- a/tests/ui/eta.stderr
+++ b/tests/ui/eta.stderr
@@ -12,7 +12,7 @@ error: redundant closure found
 LL |     meta(|a| foo(a));
    |          ^^^^^^^^^^ help: remove closure as shown: `foo`
 
-error: this expression borrows a reference that is immediately dereferenced by the compiler
+error: this expression borrows a reference (`&u8`) that is immediately dereferenced by the compiler
   --> $DIR/eta.rs:24:21
    |
 LL |     all(&[1, 2, 3], &&2, |x, y| below(x, y)); //is adjusted
diff --git a/tests/ui/needless_borrow.stderr b/tests/ui/needless_borrow.stderr
index 0bfeda7914d..bea4b41b803 100644
--- a/tests/ui/needless_borrow.stderr
+++ b/tests/ui/needless_borrow.stderr
@@ -1,4 +1,4 @@
-error: this expression borrows a reference that is immediately dereferenced by the compiler
+error: this expression borrows a reference (`&i32`) that is immediately dereferenced by the compiler
   --> $DIR/needless_borrow.rs:14:15
    |
 LL |     let c = x(&&a);
@@ -12,7 +12,7 @@ error: this pattern creates a reference to a reference
 LL |     if let Some(ref cake) = Some(&5) {}
    |                 ^^^^^^^^ help: change this to: `cake`
 
-error: this expression borrows a reference that is immediately dereferenced by the compiler
+error: this expression borrows a reference (`&i32`) that is immediately dereferenced by the compiler
   --> $DIR/needless_borrow.rs:28:15
    |
 LL |         46 => &&a,
-- 
cgit 1.4.1-3-g733a5


From a37af06fea574f3d9f4d3cca58a70cd545523486 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Wed, 9 Dec 2020 12:25:45 +0000
Subject: Removing false positive for the match_single_binding lint

* Applying suggested changes from the PR
---
 clippy_lints/src/matches.rs          | 22 ++++++++++++++++++++--
 tests/ui/match_single_binding.fixed  | 28 ++++++++++++++++++++++++++++
 tests/ui/match_single_binding.rs     | 33 +++++++++++++++++++++++++++++++++
 tests/ui/match_single_binding.stderr | 13 ++++++++++++-
 4 files changed, 93 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index 2a1a73f98ee..04b35835c6b 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -4,8 +4,8 @@ use crate::utils::usage::is_unused;
 use crate::utils::{
     expr_block, get_arg_name, get_parent_expr, in_macro, indent_of, is_allowed, is_expn_of, is_refutable,
     is_type_diagnostic_item, is_wild, match_qpath, match_type, match_var, meets_msrv, multispan_sugg, remove_blocks,
-    snippet, snippet_block, snippet_with_applicability, span_lint_and_help, span_lint_and_note, span_lint_and_sugg,
-    span_lint_and_then,
+    snippet, snippet_block, snippet_opt, snippet_with_applicability, span_lint_and_help, span_lint_and_note,
+    span_lint_and_sugg, span_lint_and_then,
 };
 use crate::utils::{paths, search_same, SpanlessEq, SpanlessHash};
 use if_chain::if_chain;
@@ -1237,6 +1237,24 @@ fn check_match_single_binding<'a>(cx: &LateContext<'a>, ex: &Expr<'a>, arms: &[A
     if in_macro(expr.span) || arms.len() != 1 || is_refutable(cx, arms[0].pat) {
         return;
     }
+
+    // HACK:
+    // This is a hack to deal with arms that are excluded by macros like `#[cfg]`. It is only used here
+    // to prevent false positives as there is currently no better way to detect if code was excluded by
+    // a macro. See PR #6435
+    if_chain! {
+        if let Some(match_snippet) = snippet_opt(cx, expr.span);
+        if let Some(arm_snippet) = snippet_opt(cx, arms[0].span);
+        if let Some(ex_snippet) = snippet_opt(cx, ex.span);
+        let rest_snippet = match_snippet.replace(&arm_snippet, "").replace(&ex_snippet, "");
+        if rest_snippet.contains("=>");
+        then {
+            // The code it self contains another thick arrow "=>"
+            // -> Either another arm or a comment
+            return;
+        }
+    }
+
     let matched_vars = ex.span;
     let bind_names = arms[0].pat.span;
     let match_body = remove_blocks(&arms[0].body);
diff --git a/tests/ui/match_single_binding.fixed b/tests/ui/match_single_binding.fixed
index f3627902eec..526e94b10bd 100644
--- a/tests/ui/match_single_binding.fixed
+++ b/tests/ui/match_single_binding.fixed
@@ -87,4 +87,32 @@ fn main() {
             unwrapped
         })
         .collect::<Vec<u8>>();
+    // Ok
+    let x = 1;
+    match x {
+        #[cfg(disabled_feature)]
+        0 => println!("Disabled branch"),
+        _ => println!("Enabled branch"),
+    }
+    // Lint
+    let x = 1;
+    let y = 1;
+    println!("Single branch");
+    // Ok
+    let x = 1;
+    let y = 1;
+    match match y {
+        0 => 1,
+        _ => 2,
+    } {
+        #[cfg(disabled_feature)]
+        0 => println!("Array index start"),
+        _ => println!("Not an array index start"),
+    }
+    // False negative
+    let x = 1;
+    match x {
+        // =>
+        _ => println!("Not an array index start"),
+    }
 }
diff --git a/tests/ui/match_single_binding.rs b/tests/ui/match_single_binding.rs
index 8c182148ae1..6a2ca7c5e93 100644
--- a/tests/ui/match_single_binding.rs
+++ b/tests/ui/match_single_binding.rs
@@ -99,4 +99,37 @@ fn main() {
             unwrapped => unwrapped,
         })
         .collect::<Vec<u8>>();
+    // Ok
+    let x = 1;
+    match x {
+        #[cfg(disabled_feature)]
+        0 => println!("Disabled branch"),
+        _ => println!("Enabled branch"),
+    }
+    // Lint
+    let x = 1;
+    let y = 1;
+    match match y {
+        0 => 1,
+        _ => 2,
+    } {
+        _ => println!("Single branch"),
+    }
+    // Ok
+    let x = 1;
+    let y = 1;
+    match match y {
+        0 => 1,
+        _ => 2,
+    } {
+        #[cfg(disabled_feature)]
+        0 => println!("Array index start"),
+        _ => println!("Not an array index start"),
+    }
+    // False negative
+    let x = 1;
+    match x {
+        // =>
+        _ => println!("Not an array index start"),
+    }
 }
diff --git a/tests/ui/match_single_binding.stderr b/tests/ui/match_single_binding.stderr
index 795c8c3e24d..cbbf5d29c02 100644
--- a/tests/ui/match_single_binding.stderr
+++ b/tests/ui/match_single_binding.stderr
@@ -167,5 +167,16 @@ LL |             unwrapped
 LL |         })
    |
 
-error: aborting due to 11 previous errors
+error: this match could be replaced by its body itself
+  --> $DIR/match_single_binding.rs:112:5
+   |
+LL | /     match match y {
+LL | |         0 => 1,
+LL | |         _ => 2,
+LL | |     } {
+LL | |         _ => println!("Single branch"),
+LL | |     }
+   | |_____^ help: consider using the match body instead: `println!("Single branch");`
+
+error: aborting due to 12 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 39bcf8e55438016fb86427f9b8a78b6a32a84126 Mon Sep 17 00:00:00 2001
From: Eduardo Broto <ebroto@tutanota.com>
Date: Tue, 15 Dec 2020 23:18:03 +0100
Subject: Handle fatal errors when parsing doctests

---
 clippy_lints/src/doc.rs       | 116 ++++++++++++++++++++++--------------------
 clippy_lints/src/lib.rs       |   1 +
 tests/ui/needless_doc_main.rs |   6 +++
 3 files changed, 68 insertions(+), 55 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/doc.rs b/clippy_lints/src/doc.rs
index 55e4755c278..77203a286dd 100644
--- a/clippy_lints/src/doc.rs
+++ b/clippy_lints/src/doc.rs
@@ -451,66 +451,72 @@ fn check_doc<'a, Events: Iterator<Item = (pulldown_cmark::Event<'a>, Range<usize
 }
 
 fn check_code(cx: &LateContext<'_>, text: &str, span: Span) {
-    fn has_needless_main(code: &str) -> bool {
-        let filename = FileName::anon_source_code(code);
-
-        let sm = Lrc::new(SourceMap::new(FilePathMapping::empty()));
-        let emitter = EmitterWriter::new(box io::sink(), None, false, false, false, None, false);
-        let handler = Handler::with_emitter(false, None, box emitter);
-        let sess = ParseSess::with_span_handler(handler, sm);
-
-        let mut parser = match maybe_new_parser_from_source_str(&sess, filename, code.into()) {
-            Ok(p) => p,
-            Err(errs) => {
-                for mut err in errs {
-                    err.cancel();
-                }
-                return false;
-            },
-        };
-
-        let mut relevant_main_found = false;
-        loop {
-            match parser.parse_item() {
-                Ok(Some(item)) => match &item.kind {
-                    // Tests with one of these items are ignored
-                    ItemKind::Static(..)
-                    | ItemKind::Const(..)
-                    | ItemKind::ExternCrate(..)
-                    | ItemKind::ForeignMod(..) => return false,
-                    // We found a main function ...
-                    ItemKind::Fn(_, sig, _, Some(block)) if item.ident.name == sym::main => {
-                        let is_async = matches!(sig.header.asyncness, Async::Yes { .. });
-                        let returns_nothing = match &sig.decl.output {
-                            FnRetTy::Default(..) => true,
-                            FnRetTy::Ty(ty) if ty.kind.is_unit() => true,
-                            _ => false,
-                        };
-
-                        if returns_nothing && !is_async && !block.stmts.is_empty() {
-                            // This main function should be linted, but only if there are no other functions
-                            relevant_main_found = true;
-                        } else {
-                            // This main function should not be linted, we're done
-                            return false;
+    fn has_needless_main(cx: &LateContext<'_>, code: &str) -> bool {
+        rustc_driver::catch_fatal_errors(|| {
+            rustc_span::with_session_globals(cx.tcx.sess.edition(), || {
+                let filename = FileName::anon_source_code(code);
+
+                let sm = Lrc::new(SourceMap::new(FilePathMapping::empty()));
+                let emitter = EmitterWriter::new(box io::sink(), None, false, false, false, None, false);
+                let handler = Handler::with_emitter(false, None, box emitter);
+                let sess = ParseSess::with_span_handler(handler, sm);
+
+                let mut parser = match maybe_new_parser_from_source_str(&sess, filename, code.into()) {
+                    Ok(p) => p,
+                    Err(errs) => {
+                        for mut err in errs {
+                            err.cancel();
                         }
+                        return false;
                     },
-                    // Another function was found; this case is ignored too
-                    ItemKind::Fn(..) => return false,
-                    _ => {},
-                },
-                Ok(None) => break,
-                Err(mut e) => {
-                    e.cancel();
-                    return false;
-                },
-            }
-        }
+                };
+
+                let mut relevant_main_found = false;
+                loop {
+                    match parser.parse_item() {
+                        Ok(Some(item)) => match &item.kind {
+                            // Tests with one of these items are ignored
+                            ItemKind::Static(..)
+                            | ItemKind::Const(..)
+                            | ItemKind::ExternCrate(..)
+                            | ItemKind::ForeignMod(..) => return false,
+                            // We found a main function ...
+                            ItemKind::Fn(_, sig, _, Some(block)) if item.ident.name == sym::main => {
+                                let is_async = matches!(sig.header.asyncness, Async::Yes { .. });
+                                let returns_nothing = match &sig.decl.output {
+                                    FnRetTy::Default(..) => true,
+                                    FnRetTy::Ty(ty) if ty.kind.is_unit() => true,
+                                    _ => false,
+                                };
+
+                                if returns_nothing && !is_async && !block.stmts.is_empty() {
+                                    // This main function should be linted, but only if there are no other functions
+                                    relevant_main_found = true;
+                                } else {
+                                    // This main function should not be linted, we're done
+                                    return false;
+                                }
+                            },
+                            // Another function was found; this case is ignored too
+                            ItemKind::Fn(..) => return false,
+                            _ => {},
+                        },
+                        Ok(None) => break,
+                        Err(mut e) => {
+                            e.cancel();
+                            return false;
+                        },
+                    }
+                }
 
-        relevant_main_found
+                relevant_main_found
+            })
+        })
+        .ok()
+        .unwrap_or_default()
     }
 
-    if has_needless_main(text) {
+    if has_needless_main(cx, text) {
         span_lint(cx, NEEDLESS_DOCTEST_MAIN, span, "needless `fn main` in doctest");
     }
 }
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index f06926fa91d..651b9e71131 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -27,6 +27,7 @@ extern crate rustc_ast;
 extern crate rustc_ast_pretty;
 extern crate rustc_attr;
 extern crate rustc_data_structures;
+extern crate rustc_driver;
 extern crate rustc_errors;
 extern crate rustc_hir;
 extern crate rustc_hir_pretty;
diff --git a/tests/ui/needless_doc_main.rs b/tests/ui/needless_doc_main.rs
index 883683e08a2..52c84089fa8 100644
--- a/tests/ui/needless_doc_main.rs
+++ b/tests/ui/needless_doc_main.rs
@@ -128,6 +128,12 @@ fn bad_doctests() {}
 /// ```
 fn no_false_positives() {}
 
+/// Yields a parse error when interpreted as rust code:
+/// ```
+/// r#"hi"
+/// ```
+fn issue_6022() {}
+
 fn main() {
     bad_doctests();
     no_false_positives();
-- 
cgit 1.4.1-3-g733a5


From 41b5ebebfdc583d9e3702dd61c8d897999d1e7f5 Mon Sep 17 00:00:00 2001
From: Eduardo Broto <ebroto@tutanota.com>
Date: Wed, 16 Dec 2020 00:14:47 +0100
Subject: needless_doctest_main: add edition support

---
 clippy_lints/src/doc.rs       | 26 ++++++++++++++++++--------
 tests/ui/needless_doc_main.rs |  4 ++--
 2 files changed, 20 insertions(+), 10 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/doc.rs b/clippy_lints/src/doc.rs
index 77203a286dd..08134cc16c0 100644
--- a/clippy_lints/src/doc.rs
+++ b/clippy_lints/src/doc.rs
@@ -14,6 +14,7 @@ use rustc_middle::ty;
 use rustc_parse::maybe_new_parser_from_source_str;
 use rustc_session::parse::ParseSess;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::edition::Edition;
 use rustc_span::source_map::{BytePos, FilePathMapping, MultiSpan, SourceMap, Span};
 use rustc_span::{sym, FileName, Pos};
 use std::io;
@@ -377,7 +378,7 @@ fn check_attrs<'a>(cx: &LateContext<'_>, valid_idents: &FxHashSet<String>, attrs
     check_doc(cx, valid_idents, events, &spans)
 }
 
-const RUST_CODE: &[&str] = &["rust", "no_run", "should_panic", "compile_fail", "edition2018"];
+const RUST_CODE: &[&str] = &["rust", "no_run", "should_panic", "compile_fail"];
 
 fn check_doc<'a, Events: Iterator<Item = (pulldown_cmark::Event<'a>, Range<usize>)>>(
     cx: &LateContext<'_>,
@@ -400,13 +401,21 @@ fn check_doc<'a, Events: Iterator<Item = (pulldown_cmark::Event<'a>, Range<usize
     let mut in_link = None;
     let mut in_heading = false;
     let mut is_rust = false;
+    let mut edition = None;
     for (event, range) in events {
         match event {
             Start(CodeBlock(ref kind)) => {
                 in_code = true;
                 if let CodeBlockKind::Fenced(lang) = kind {
-                    is_rust =
-                        lang.is_empty() || !lang.contains("ignore") && lang.split(',').any(|i| RUST_CODE.contains(&i));
+                    let infos = lang.split(',').collect::<Vec<_>>();
+                    is_rust = !infos.iter().any(|&i| i == "ignore")
+                        && infos
+                            .iter()
+                            .any(|i| i.is_empty() || i.starts_with("edition") || RUST_CODE.contains(&i));
+                    edition = infos
+                        .iter()
+                        .find_map(|i| i.starts_with("edition").then(|| i[7..].parse::<Edition>().ok()))
+                        .flatten();
                 }
             },
             End(CodeBlock(_)) => {
@@ -436,7 +445,8 @@ fn check_doc<'a, Events: Iterator<Item = (pulldown_cmark::Event<'a>, Range<usize
                 let (begin, span) = spans[index];
                 if in_code {
                     if is_rust {
-                        check_code(cx, &text, span);
+                        let edition = edition.unwrap_or_else(|| cx.tcx.sess.edition());
+                        check_code(cx, &text, edition, span);
                     }
                 } else {
                     // Adjust for the beginning of the current `Event`
@@ -450,10 +460,10 @@ fn check_doc<'a, Events: Iterator<Item = (pulldown_cmark::Event<'a>, Range<usize
     headers
 }
 
-fn check_code(cx: &LateContext<'_>, text: &str, span: Span) {
-    fn has_needless_main(cx: &LateContext<'_>, code: &str) -> bool {
+fn check_code(cx: &LateContext<'_>, text: &str, edition: Edition, span: Span) {
+    fn has_needless_main(code: &str, edition: Edition) -> bool {
         rustc_driver::catch_fatal_errors(|| {
-            rustc_span::with_session_globals(cx.tcx.sess.edition(), || {
+            rustc_span::with_session_globals(edition, || {
                 let filename = FileName::anon_source_code(code);
 
                 let sm = Lrc::new(SourceMap::new(FilePathMapping::empty()));
@@ -516,7 +526,7 @@ fn check_code(cx: &LateContext<'_>, text: &str, span: Span) {
         .unwrap_or_default()
     }
 
-    if has_needless_main(cx, text) {
+    if has_needless_main(text, edition) {
         span_lint(cx, NEEDLESS_DOCTEST_MAIN, span, "needless `fn main` in doctest");
     }
 }
diff --git a/tests/ui/needless_doc_main.rs b/tests/ui/needless_doc_main.rs
index 52c84089fa8..83e9bbaa3af 100644
--- a/tests/ui/needless_doc_main.rs
+++ b/tests/ui/needless_doc_main.rs
@@ -10,7 +10,7 @@
 /// ```
 ///
 /// With an explicit return type it should lint too
-/// ```
+/// ```edition2015
 /// fn main() -> () {
 ///     unimplemented!();
 /// }
@@ -39,7 +39,7 @@ fn bad_doctests() {}
 /// ```
 ///
 /// This shouldn't lint either, because main is async:
-/// ```
+/// ```edition2018
 /// async fn main() {
 ///     assert_eq!(42, ANSWER);
 /// }
-- 
cgit 1.4.1-3-g733a5


From f732cc5cd6aeb06e07bd478d78fccaa625daa685 Mon Sep 17 00:00:00 2001
From: Michael Wright <mikerite@lavabit.com>
Date: Wed, 16 Dec 2020 06:05:25 +0200
Subject: Remove unsafe code

---
 clippy_lints/src/utils/internal_lints.rs | 12 +++++-------
 1 file changed, 5 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs
index 0de87fab528..9ba39f73ee8 100644
--- a/clippy_lints/src/utils/internal_lints.rs
+++ b/clippy_lints/src/utils/internal_lints.rs
@@ -868,8 +868,8 @@ impl<'tcx> LateLintPass<'tcx> for InvalidPaths {
 
 #[derive(Default)]
 pub struct InterningDefinedSymbol {
-    // Maps the symbol to the constant name.
-    symbol_map: FxHashMap<String, String>,
+    // Maps the symbol value to the constant name.
+    symbol_map: FxHashMap<u32, String>,
 }
 
 impl_lint_pass!(InterningDefinedSymbol => [INTERNING_DEFINED_SYMBOL]);
@@ -889,10 +889,7 @@ impl<'tcx> LateLintPass<'tcx> for InterningDefinedSymbol {
                     if let Ok(ConstValue::Scalar(value)) = cx.tcx.const_eval_poly(item_def_id);
                     if let Ok(value) = value.to_u32();
                     then {
-                        // SAFETY: We're converting the raw bytes of the symbol value back
-                        // into a Symbol instance.
-                        let symbol = unsafe { std::mem::transmute::<u32, Symbol>(value) };
-                        self.symbol_map.insert(symbol.to_string(), item.ident.to_string());
+                        self.symbol_map.insert(value, item.ident.to_string());
                     }
                 }
             }
@@ -905,7 +902,8 @@ impl<'tcx> LateLintPass<'tcx> for InterningDefinedSymbol {
             if let ty::FnDef(def_id, _) = cx.typeck_results().expr_ty(func).kind();
             if match_def_path(cx, *def_id, &paths::SYMBOL_INTERN);
             if let Some(Constant::Str(arg)) = constant_simple(cx, cx.typeck_results(), arg);
-            if let Some(symbol_const) = self.symbol_map.get(&arg);
+            let value = Symbol::intern(&arg).as_u32();
+            if let Some(symbol_const) = self.symbol_map.get(&value);
             then {
                 span_lint_and_sugg(
                     cx,
-- 
cgit 1.4.1-3-g733a5


From 1d6fac616767d84156e018e2a78582b7164241fb Mon Sep 17 00:00:00 2001
From: Naughty <dorminsama@gmail.com>
Date: Wed, 16 Dec 2020 20:48:03 -0300
Subject: Typo: std::fs::crate_dir -> std::fs::create_dir

---
 clippy_lints/src/create_dir.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/create_dir.rs b/clippy_lints/src/create_dir.rs
index 4002fb655a5..200b6a565cc 100644
--- a/clippy_lints/src/create_dir.rs
+++ b/clippy_lints/src/create_dir.rs
@@ -8,7 +8,7 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 declare_clippy_lint! {
     /// **What it does:** Checks usage of `std::fs::create_dir` and suggest using `std::fs::create_dir_all` instead.
     ///
-    /// **Why is this bad?** Sometimes `std::fs::crate_dir` is mistakenly chosen over `std::fs::create_dir_all`.
+    /// **Why is this bad?** Sometimes `std::fs::create_dir` is mistakenly chosen over `std::fs::create_dir_all`.
     ///
     /// **Known problems:** None.
     ///
-- 
cgit 1.4.1-3-g733a5


From bb68ec6cfc76a6ec69d21c0f64dbc4aa99158958 Mon Sep 17 00:00:00 2001
From: Eduardo Broto <ebroto@tutanota.com>
Date: Thu, 17 Dec 2020 15:24:44 +0100
Subject: Apply suggestion from PR review

---
 clippy_lints/src/doc.rs | 21 ++++++++++++---------
 1 file changed, 12 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/doc.rs b/clippy_lints/src/doc.rs
index 08134cc16c0..aba65532795 100644
--- a/clippy_lints/src/doc.rs
+++ b/clippy_lints/src/doc.rs
@@ -407,15 +407,18 @@ fn check_doc<'a, Events: Iterator<Item = (pulldown_cmark::Event<'a>, Range<usize
             Start(CodeBlock(ref kind)) => {
                 in_code = true;
                 if let CodeBlockKind::Fenced(lang) = kind {
-                    let infos = lang.split(',').collect::<Vec<_>>();
-                    is_rust = !infos.iter().any(|&i| i == "ignore")
-                        && infos
-                            .iter()
-                            .any(|i| i.is_empty() || i.starts_with("edition") || RUST_CODE.contains(&i));
-                    edition = infos
-                        .iter()
-                        .find_map(|i| i.starts_with("edition").then(|| i[7..].parse::<Edition>().ok()))
-                        .flatten();
+                    for item in lang.split(',') {
+                        if item == "ignore" {
+                            is_rust = false;
+                            break;
+                        }
+                        if let Some(stripped) = item.strip_prefix("edition") {
+                            is_rust = true;
+                            edition = stripped.parse::<Edition>().ok();
+                        } else if item.is_empty() || RUST_CODE.contains(&item) {
+                            is_rust = true;
+                        }
+                    }
                 }
             },
             End(CodeBlock(_)) => {
-- 
cgit 1.4.1-3-g733a5


From 1eb7608a2e7284eff2d0ba80705f1cf28a1117e5 Mon Sep 17 00:00:00 2001
From: Andrew Houts <ahouts4@gmail.com>
Date: Thu, 17 Dec 2020 21:09:55 -0600
Subject: make needless_update ignore non_exhaustive structs

---
 clippy_lints/src/needless_update.rs | 21 +++++++++++++++++++--
 tests/ui/needless_update.rs         | 11 +++++++++++
 tests/ui/needless_update.stderr     |  2 +-
 3 files changed, 31 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/needless_update.rs b/clippy_lints/src/needless_update.rs
index 98e9078094a..1e387b518c3 100644
--- a/clippy_lints/src/needless_update.rs
+++ b/clippy_lints/src/needless_update.rs
@@ -21,7 +21,14 @@ declare_clippy_lint! {
     /// #     z: i32,
     /// # }
     /// # let zero_point = Point { x: 0, y: 0, z: 0 };
-    ///
+    /// #
+    /// # #[non_exhaustive]
+    /// # struct Options {
+    /// #     a: bool,
+    /// #     b: i32,
+    /// # }
+    /// # let default_options = Options { a: false, b: 0 };
+    /// #
     /// // Bad
     /// Point {
     ///     x: 1,
@@ -36,6 +43,14 @@ declare_clippy_lint! {
     ///     y: 1,
     ///     ..zero_point
     /// };
+    ///
+    /// // this lint is not applied to structs marked with [non_exhaustive](https://doc.rust-lang.org/reference/attributes/type_system.html)
+    /// // Ok
+    /// Options {
+    ///     a: true,
+    ///     b: 321,
+    ///     ..default_options
+    ///  };
     /// ```
     pub NEEDLESS_UPDATE,
     complexity,
@@ -49,7 +64,9 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessUpdate {
         if let ExprKind::Struct(_, ref fields, Some(ref base)) = expr.kind {
             let ty = cx.typeck_results().expr_ty(expr);
             if let ty::Adt(def, _) = ty.kind() {
-                if fields.len() == def.non_enum_variant().fields.len() {
+                if fields.len() == def.non_enum_variant().fields.len()
+                    && !def.variants[0_usize.into()].is_field_list_non_exhaustive()
+                {
                     span_lint(
                         cx,
                         NEEDLESS_UPDATE,
diff --git a/tests/ui/needless_update.rs b/tests/ui/needless_update.rs
index bfa005a19f9..b93ff048a62 100644
--- a/tests/ui/needless_update.rs
+++ b/tests/ui/needless_update.rs
@@ -6,9 +6,20 @@ struct S {
     pub b: i32,
 }
 
+#[non_exhaustive]
+struct T {
+    pub x: i32,
+    pub y: i32,
+}
+
 fn main() {
     let base = S { a: 0, b: 0 };
     S { ..base }; // no error
     S { a: 1, ..base }; // no error
     S { a: 1, b: 1, ..base };
+
+    let base = T { x: 0, y: 0 };
+    T { ..base }; // no error
+    T { x: 1, ..base }; // no error
+    T { x: 1, y: 1, ..base }; // no error
 }
diff --git a/tests/ui/needless_update.stderr b/tests/ui/needless_update.stderr
index 133c834880d..b154b3b306d 100644
--- a/tests/ui/needless_update.stderr
+++ b/tests/ui/needless_update.stderr
@@ -1,5 +1,5 @@
 error: struct update has no effect, all the fields in the struct have already been specified
-  --> $DIR/needless_update.rs:13:23
+  --> $DIR/needless_update.rs:19:23
    |
 LL |     S { a: 1, b: 1, ..base };
    |                       ^^^^
-- 
cgit 1.4.1-3-g733a5


From 920c9a4aaefbc4bade7032e32ec099bff1c7b58a Mon Sep 17 00:00:00 2001
From: Suyash458 <suyash.behera458@gmail.com>
Date: Fri, 18 Dec 2020 10:55:09 +0530
Subject: add more lints to msrv docs

---
 clippy_lints/src/utils/conf.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 6403ff6dad1..32d7840a451 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -106,7 +106,7 @@ macro_rules! define_Conf {
 
 pub use self::helpers::Conf;
 define_Conf! {
-    /// Lint: MANUAL_NON_EXHAUSTIVE, MANUAL_STRIP, OPTION_AS_REF_DEREF, MATCH_LIKE_MATCHES_MACRO. The minimum rust version that the project supports
+    /// Lint: REDUNDANT_FIELD_NAMES, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN. The minimum rust version that the project supports
     (msrv, "msrv": Option<String>, None),
     /// Lint: BLACKLISTED_NAME. The list of blacklisted names to lint about. NB: `bar` is not here since it has legitimate uses
     (blacklisted_names, "blacklisted_names": Vec<String>, ["foo", "baz", "quux"].iter().map(ToString::to_string).collect()),
-- 
cgit 1.4.1-3-g733a5


From a24c6f14fa89dafc879ad76a185f43bc50f0bbb9 Mon Sep 17 00:00:00 2001
From: Andrew Houts <ahouts4@gmail.com>
Date: Fri, 18 Dec 2020 19:15:05 -0600
Subject: remove example

---
 clippy_lints/src/needless_update.rs | 20 ++++----------------
 1 file changed, 4 insertions(+), 16 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/needless_update.rs b/clippy_lints/src/needless_update.rs
index 1e387b518c3..41cf541ecf5 100644
--- a/clippy_lints/src/needless_update.rs
+++ b/clippy_lints/src/needless_update.rs
@@ -8,6 +8,9 @@ declare_clippy_lint! {
     /// **What it does:** Checks for needlessly including a base struct on update
     /// when all fields are changed anyway.
     ///
+    /// This lint is not applied to structs marked with
+    /// [non_exhaustive](https://doc.rust-lang.org/reference/attributes/type_system.html).
+    ///
     /// **Why is this bad?** This will cost resources (because the base has to be
     /// somewhere), and make the code less readable.
     ///
@@ -21,14 +24,7 @@ declare_clippy_lint! {
     /// #     z: i32,
     /// # }
     /// # let zero_point = Point { x: 0, y: 0, z: 0 };
-    /// #
-    /// # #[non_exhaustive]
-    /// # struct Options {
-    /// #     a: bool,
-    /// #     b: i32,
-    /// # }
-    /// # let default_options = Options { a: false, b: 0 };
-    /// #
+    ///
     /// // Bad
     /// Point {
     ///     x: 1,
@@ -43,14 +39,6 @@ declare_clippy_lint! {
     ///     y: 1,
     ///     ..zero_point
     /// };
-    ///
-    /// // this lint is not applied to structs marked with [non_exhaustive](https://doc.rust-lang.org/reference/attributes/type_system.html)
-    /// // Ok
-    /// Options {
-    ///     a: true,
-    ///     b: 321,
-    ///     ..default_options
-    ///  };
     /// ```
     pub NEEDLESS_UPDATE,
     complexity,
-- 
cgit 1.4.1-3-g733a5


From a451b2af30c173b081f5d6150e558a65062a1dc8 Mon Sep 17 00:00:00 2001
From: Bastian Kersting <bastian@cmbt.de>
Date: Sat, 19 Dec 2020 15:49:42 +0100
Subject: Added from_over_into lint

---
 CHANGELOG.md                       |  1 +
 clippy_lints/src/from_over_into.rs | 63 ++++++++++++++++++++++++++++++++++++++
 clippy_lints/src/lib.rs            |  5 +++
 tests/ui/from_over_into.rs         | 21 +++++++++++++
 tests/ui/from_over_into.stderr     | 15 +++++++++
 tests/ui/unused_unit.fixed         |  1 +
 tests/ui/unused_unit.rs            |  1 +
 tests/ui/unused_unit.stderr        | 38 +++++++++++------------
 8 files changed, 126 insertions(+), 19 deletions(-)
 create mode 100644 clippy_lints/src/from_over_into.rs
 create mode 100644 tests/ui/from_over_into.rs
 create mode 100644 tests/ui/from_over_into.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index af3b1c1db2a..de8da99cdee 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1841,6 +1841,7 @@ Released 2018-09-13
 [`forget_copy`]: https://rust-lang.github.io/rust-clippy/master/index.html#forget_copy
 [`forget_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#forget_ref
 [`from_iter_instead_of_collect`]: https://rust-lang.github.io/rust-clippy/master/index.html#from_iter_instead_of_collect
+[`from_over_into`]: https://rust-lang.github.io/rust-clippy/master/index.html#from_over_into
 [`future_not_send`]: https://rust-lang.github.io/rust-clippy/master/index.html#future_not_send
 [`get_last_with_len`]: https://rust-lang.github.io/rust-clippy/master/index.html#get_last_with_len
 [`get_unwrap`]: https://rust-lang.github.io/rust-clippy/master/index.html#get_unwrap
diff --git a/clippy_lints/src/from_over_into.rs b/clippy_lints/src/from_over_into.rs
new file mode 100644
index 00000000000..fe7120b0f9a
--- /dev/null
+++ b/clippy_lints/src/from_over_into.rs
@@ -0,0 +1,63 @@
+use crate::utils::paths::INTO;
+use crate::utils::{match_def_path, span_lint_and_help};
+use if_chain::if_chain;
+use rustc_hir as hir;
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// **What it does:** Searches for implementations of the `Into<..>` trait and suggests to implement `From<..>` instead.
+    ///
+    /// **Why is this bad?** According the std docs implementing `From<..>` is preferred since it gives you `Into<..>` for free where the reverse isn't true.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// struct StringWrapper(String);
+    ///
+    /// impl Into<StringWrapper> for String {
+    ///     fn into(self) -> StringWrapper {
+    ///         StringWrapper(self)
+    ///     }
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// struct StringWrapper(String);
+    ///
+    /// impl From<String> for StringWrapper {
+    ///     fn from(s: String) -> StringWrapper {
+    ///         StringWrapper(s)
+    ///     }
+    /// }
+    /// ```
+    pub FROM_OVER_INTO,
+    style,
+    "Warns on implementations of `Into<..>` to use `From<..>`"
+}
+
+declare_lint_pass!(FromOverInto => [FROM_OVER_INTO]);
+
+impl LateLintPass<'_> for FromOverInto {
+    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) {
+        let impl_def_id = cx.tcx.hir().local_def_id(item.hir_id);
+        if_chain! {
+            if let hir::ItemKind::Impl{ .. } = &item.kind;
+            if let Some(impl_trait_ref) = cx.tcx.impl_trait_ref(impl_def_id);
+            if match_def_path(cx, impl_trait_ref.def_id, &INTO);
+
+            then {
+                span_lint_and_help(
+                    cx,
+                    FROM_OVER_INTO,
+                    item.span,
+                    "An implementation of From is preferred since it gives you Into<..> for free where the reverse isn't true.",
+                    None,
+                    "consider implement From instead",
+                );
+            }
+        }
+    }
+}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 02ba422a2f5..58587481922 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -207,6 +207,7 @@ mod float_literal;
 mod floating_point_arithmetic;
 mod format;
 mod formatting;
+mod from_over_into;
 mod functions;
 mod future_not_send;
 mod get_last_with_len;
@@ -614,6 +615,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &formatting::SUSPICIOUS_ASSIGNMENT_FORMATTING,
         &formatting::SUSPICIOUS_ELSE_FORMATTING,
         &formatting::SUSPICIOUS_UNARY_OP_FORMATTING,
+        &from_over_into::FROM_OVER_INTO,
         &functions::DOUBLE_MUST_USE,
         &functions::MUST_USE_CANDIDATE,
         &functions::MUST_USE_UNIT,
@@ -1203,6 +1205,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box manual_unwrap_or::ManualUnwrapOr);
     store.register_late_pass(|| box manual_ok_or::ManualOkOr);
     store.register_late_pass(|| box float_equality_without_abs::FloatEqualityWithoutAbs);
+    store.register_late_pass(|| box from_over_into::FromOverInto);
     store.register_late_pass(|| box async_yields_async::AsyncYieldsAsync);
     let disallowed_methods = conf.disallowed_methods.iter().cloned().collect::<FxHashSet<_>>();
     store.register_late_pass(move || box disallowed_method::DisallowedMethod::new(&disallowed_methods));
@@ -1417,6 +1420,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&formatting::SUSPICIOUS_ASSIGNMENT_FORMATTING),
         LintId::of(&formatting::SUSPICIOUS_ELSE_FORMATTING),
         LintId::of(&formatting::SUSPICIOUS_UNARY_OP_FORMATTING),
+        LintId::of(&from_over_into::FROM_OVER_INTO),
         LintId::of(&functions::DOUBLE_MUST_USE),
         LintId::of(&functions::MUST_USE_UNIT),
         LintId::of(&functions::NOT_UNSAFE_PTR_ARG_DEREF),
@@ -1663,6 +1667,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&formatting::SUSPICIOUS_ASSIGNMENT_FORMATTING),
         LintId::of(&formatting::SUSPICIOUS_ELSE_FORMATTING),
         LintId::of(&formatting::SUSPICIOUS_UNARY_OP_FORMATTING),
+        LintId::of(&from_over_into::FROM_OVER_INTO),
         LintId::of(&functions::DOUBLE_MUST_USE),
         LintId::of(&functions::MUST_USE_UNIT),
         LintId::of(&functions::RESULT_UNIT_ERR),
diff --git a/tests/ui/from_over_into.rs b/tests/ui/from_over_into.rs
new file mode 100644
index 00000000000..292d0924fb1
--- /dev/null
+++ b/tests/ui/from_over_into.rs
@@ -0,0 +1,21 @@
+#![warn(clippy::from_over_into)]
+
+// this should throw an error
+struct StringWrapper(String);
+
+impl Into<StringWrapper> for String {
+    fn into(self) -> StringWrapper {
+        StringWrapper(self)
+    }
+}
+
+// this is fine
+struct A(String);
+
+impl From<String> for A {
+    fn from(s: String) -> A {
+        A(s)
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/from_over_into.stderr b/tests/ui/from_over_into.stderr
new file mode 100644
index 00000000000..17f30fa837e
--- /dev/null
+++ b/tests/ui/from_over_into.stderr
@@ -0,0 +1,15 @@
+error: An implementation of From is preferred since it gives you Into<..> for free where the reverse isn't true.
+  --> $DIR/from_over_into.rs:6:1
+   |
+LL | / impl Into<StringWrapper> for String {
+LL | |     fn into(self) -> StringWrapper {
+LL | |         StringWrapper(self)
+LL | |     }
+LL | | }
+   | |_^
+   |
+   = note: `-D clippy::from-over-into` implied by `-D warnings`
+   = help: consider implement From instead
+
+error: aborting due to previous error
+
diff --git a/tests/ui/unused_unit.fixed b/tests/ui/unused_unit.fixed
index 7afc5361356..a192ebde3eb 100644
--- a/tests/ui/unused_unit.fixed
+++ b/tests/ui/unused_unit.fixed
@@ -11,6 +11,7 @@
 
 #![deny(clippy::unused_unit)]
 #![allow(dead_code)]
+#![allow(clippy::from_over_into)]
 
 struct Unitter;
 impl Unitter {
diff --git a/tests/ui/unused_unit.rs b/tests/ui/unused_unit.rs
index 96cef1ed5a5..96041a7dd85 100644
--- a/tests/ui/unused_unit.rs
+++ b/tests/ui/unused_unit.rs
@@ -11,6 +11,7 @@
 
 #![deny(clippy::unused_unit)]
 #![allow(dead_code)]
+#![allow(clippy::from_over_into)]
 
 struct Unitter;
 impl Unitter {
diff --git a/tests/ui/unused_unit.stderr b/tests/ui/unused_unit.stderr
index c45634c2b6d..02038b5fb6b 100644
--- a/tests/ui/unused_unit.stderr
+++ b/tests/ui/unused_unit.stderr
@@ -1,5 +1,5 @@
 error: unneeded unit return type
-  --> $DIR/unused_unit.rs:18:28
+  --> $DIR/unused_unit.rs:19:28
    |
 LL |     pub fn get_unit<F: Fn() -> (), G>(&self, f: F, _g: G) -> ()
    |                            ^^^^^^ help: remove the `-> ()`
@@ -11,109 +11,109 @@ LL | #![deny(clippy::unused_unit)]
    |         ^^^^^^^^^^^^^^^^^^^
 
 error: unneeded unit return type
-  --> $DIR/unused_unit.rs:19:18
+  --> $DIR/unused_unit.rs:20:18
    |
 LL |     where G: Fn() -> () {
    |                  ^^^^^^ help: remove the `-> ()`
 
 error: unneeded unit return type
-  --> $DIR/unused_unit.rs:18:58
+  --> $DIR/unused_unit.rs:19:58
    |
 LL |     pub fn get_unit<F: Fn() -> (), G>(&self, f: F, _g: G) -> ()
    |                                                          ^^^^^^ help: remove the `-> ()`
 
 error: unneeded unit return type
-  --> $DIR/unused_unit.rs:20:26
+  --> $DIR/unused_unit.rs:21:26
    |
 LL |         let _y: &dyn Fn() -> () = &f;
    |                          ^^^^^^ help: remove the `-> ()`
 
 error: unneeded unit return type
-  --> $DIR/unused_unit.rs:27:18
+  --> $DIR/unused_unit.rs:28:18
    |
 LL |     fn into(self) -> () {
    |                  ^^^^^^ help: remove the `-> ()`
 
 error: unneeded unit expression
-  --> $DIR/unused_unit.rs:28:9
+  --> $DIR/unused_unit.rs:29:9
    |
 LL |         ()
    |         ^^ help: remove the final `()`
 
 error: unneeded unit return type
-  --> $DIR/unused_unit.rs:33:29
+  --> $DIR/unused_unit.rs:34:29
    |
 LL |     fn redundant<F: FnOnce() -> (), G, H>(&self, _f: F, _g: G, _h: H)
    |                             ^^^^^^ help: remove the `-> ()`
 
 error: unneeded unit return type
-  --> $DIR/unused_unit.rs:35:19
+  --> $DIR/unused_unit.rs:36:19
    |
 LL |         G: FnMut() -> (),
    |                   ^^^^^^ help: remove the `-> ()`
 
 error: unneeded unit return type
-  --> $DIR/unused_unit.rs:36:16
+  --> $DIR/unused_unit.rs:37:16
    |
 LL |         H: Fn() -> ();
    |                ^^^^^^ help: remove the `-> ()`
 
 error: unneeded unit return type
-  --> $DIR/unused_unit.rs:40:29
+  --> $DIR/unused_unit.rs:41:29
    |
 LL |     fn redundant<F: FnOnce() -> (), G, H>(&self, _f: F, _g: G, _h: H)
    |                             ^^^^^^ help: remove the `-> ()`
 
 error: unneeded unit return type
-  --> $DIR/unused_unit.rs:42:19
+  --> $DIR/unused_unit.rs:43:19
    |
 LL |         G: FnMut() -> (),
    |                   ^^^^^^ help: remove the `-> ()`
 
 error: unneeded unit return type
-  --> $DIR/unused_unit.rs:43:16
+  --> $DIR/unused_unit.rs:44:16
    |
 LL |         H: Fn() -> () {}
    |                ^^^^^^ help: remove the `-> ()`
 
 error: unneeded unit return type
-  --> $DIR/unused_unit.rs:46:17
+  --> $DIR/unused_unit.rs:47:17
    |
 LL | fn return_unit() -> () { () }
    |                 ^^^^^^ help: remove the `-> ()`
 
 error: unneeded unit expression
-  --> $DIR/unused_unit.rs:46:26
+  --> $DIR/unused_unit.rs:47:26
    |
 LL | fn return_unit() -> () { () }
    |                          ^^ help: remove the final `()`
 
 error: unneeded `()`
-  --> $DIR/unused_unit.rs:56:14
+  --> $DIR/unused_unit.rs:57:14
    |
 LL |         break();
    |              ^^ help: remove the `()`
 
 error: unneeded `()`
-  --> $DIR/unused_unit.rs:58:11
+  --> $DIR/unused_unit.rs:59:11
    |
 LL |     return();
    |           ^^ help: remove the `()`
 
 error: unneeded unit return type
-  --> $DIR/unused_unit.rs:75:10
+  --> $DIR/unused_unit.rs:76:10
    |
 LL | fn test()->(){}
    |          ^^^^ help: remove the `-> ()`
 
 error: unneeded unit return type
-  --> $DIR/unused_unit.rs:78:11
+  --> $DIR/unused_unit.rs:79:11
    |
 LL | fn test2() ->(){}
    |           ^^^^^ help: remove the `-> ()`
 
 error: unneeded unit return type
-  --> $DIR/unused_unit.rs:81:11
+  --> $DIR/unused_unit.rs:82:11
    |
 LL | fn test3()-> (){}
    |           ^^^^^ help: remove the `-> ()`
-- 
cgit 1.4.1-3-g733a5


From dd005c17e72a48f8579cd26a7165c960b04f6aa3 Mon Sep 17 00:00:00 2001
From: Bastian Kersting <bastian@cmbt.de>
Date: Sun, 20 Dec 2020 13:00:17 +0100
Subject: Added MSRV and fixed typo

---
 clippy_lints/src/from_over_into.rs    | 30 +++++++++++++++++++++++++-----
 clippy_lints/src/lib.rs               |  2 +-
 tests/ui/from_over_into.stderr        |  2 +-
 tests/ui/min_rust_version_attr.rs     |  8 ++++++++
 tests/ui/min_rust_version_attr.stderr |  8 ++++----
 5 files changed, 39 insertions(+), 11 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/from_over_into.rs b/clippy_lints/src/from_over_into.rs
index fe7120b0f9a..c7988d6f01f 100644
--- a/clippy_lints/src/from_over_into.rs
+++ b/clippy_lints/src/from_over_into.rs
@@ -1,9 +1,12 @@
 use crate::utils::paths::INTO;
-use crate::utils::{match_def_path, span_lint_and_help};
+use crate::utils::{match_def_path, meets_msrv, span_lint_and_help};
 use if_chain::if_chain;
 use rustc_hir as hir;
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_semver::RustcVersion;
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+
+const FROM_OVER_INTO_MSRV: RustcVersion = RustcVersion::new(1, 41, 0);
 
 declare_clippy_lint! {
     /// **What it does:** Searches for implementations of the `Into<..>` trait and suggests to implement `From<..>` instead.
@@ -38,10 +41,25 @@ declare_clippy_lint! {
     "Warns on implementations of `Into<..>` to use `From<..>`"
 }
 
-declare_lint_pass!(FromOverInto => [FROM_OVER_INTO]);
+pub struct FromOverInto {
+    msrv: Option<RustcVersion>,
+}
+
+impl FromOverInto {
+    #[must_use]
+    pub fn new(msrv: Option<RustcVersion>) -> Self {
+        FromOverInto { msrv }
+    }
+}
+
+impl_lint_pass!(FromOverInto => [FROM_OVER_INTO]);
 
 impl LateLintPass<'_> for FromOverInto {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) {
+        if !meets_msrv(self.msrv.as_ref(), &FROM_OVER_INTO_MSRV) {
+            return;
+        }
+
         let impl_def_id = cx.tcx.hir().local_def_id(item.hir_id);
         if_chain! {
             if let hir::ItemKind::Impl{ .. } = &item.kind;
@@ -55,9 +73,11 @@ impl LateLintPass<'_> for FromOverInto {
                     item.span,
                     "An implementation of From is preferred since it gives you Into<..> for free where the reverse isn't true.",
                     None,
-                    "consider implement From instead",
+                    "consider to implement From instead",
                 );
             }
         }
     }
+
+    extract_msrv_attr!(LateContext);
 }
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 58587481922..35b057d7b6a 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1016,6 +1016,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(move || box checked_conversions::CheckedConversions::new(msrv));
     store.register_late_pass(move || box mem_replace::MemReplace::new(msrv));
     store.register_late_pass(move || box ranges::Ranges::new(msrv));
+    store.register_late_pass(move || box from_over_into::FromOverInto::new(msrv));
     store.register_late_pass(move || box use_self::UseSelf::new(msrv));
     store.register_late_pass(move || box missing_const_for_fn::MissingConstForFn::new(msrv));
 
@@ -1205,7 +1206,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box manual_unwrap_or::ManualUnwrapOr);
     store.register_late_pass(|| box manual_ok_or::ManualOkOr);
     store.register_late_pass(|| box float_equality_without_abs::FloatEqualityWithoutAbs);
-    store.register_late_pass(|| box from_over_into::FromOverInto);
     store.register_late_pass(|| box async_yields_async::AsyncYieldsAsync);
     let disallowed_methods = conf.disallowed_methods.iter().cloned().collect::<FxHashSet<_>>();
     store.register_late_pass(move || box disallowed_method::DisallowedMethod::new(&disallowed_methods));
diff --git a/tests/ui/from_over_into.stderr b/tests/ui/from_over_into.stderr
index 17f30fa837e..c9c8e7c4b53 100644
--- a/tests/ui/from_over_into.stderr
+++ b/tests/ui/from_over_into.stderr
@@ -9,7 +9,7 @@ LL | | }
    | |_^
    |
    = note: `-D clippy::from-over-into` implied by `-D warnings`
-   = help: consider implement From instead
+   = help: consider to implement From instead
 
 error: aborting due to previous error
 
diff --git a/tests/ui/min_rust_version_attr.rs b/tests/ui/min_rust_version_attr.rs
index 3848bca3207..0f47f1cbc40 100644
--- a/tests/ui/min_rust_version_attr.rs
+++ b/tests/ui/min_rust_version_attr.rs
@@ -57,6 +57,14 @@ pub fn checked_conversion() {
     let _ = value <= (u32::MAX as i64) && value >= 0;
 }
 
+pub struct FromOverInto(String);
+
+impl Into<FromOverInto> for String {
+    fn into(self) -> FromOverInto {
+        FromOverInto(self)
+    }
+}
+
 pub fn filter_map_next() {
     let a = ["1", "lol", "3", "NaN", "5"];
 
diff --git a/tests/ui/min_rust_version_attr.stderr b/tests/ui/min_rust_version_attr.stderr
index 34805263104..e3e3b335cbe 100644
--- a/tests/ui/min_rust_version_attr.stderr
+++ b/tests/ui/min_rust_version_attr.stderr
@@ -1,12 +1,12 @@
 error: stripping a prefix manually
-  --> $DIR/min_rust_version_attr.rs:142:24
+  --> $DIR/min_rust_version_attr.rs:150:24
    |
 LL |             assert_eq!(s["hello, ".len()..].to_uppercase(), "WORLD!");
    |                        ^^^^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::manual-strip` implied by `-D warnings`
 note: the prefix was tested here
-  --> $DIR/min_rust_version_attr.rs:141:9
+  --> $DIR/min_rust_version_attr.rs:149:9
    |
 LL |         if s.starts_with("hello, ") {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -17,13 +17,13 @@ LL |             assert_eq!(<stripped>.to_uppercase(), "WORLD!");
    |
 
 error: stripping a prefix manually
-  --> $DIR/min_rust_version_attr.rs:154:24
+  --> $DIR/min_rust_version_attr.rs:162:24
    |
 LL |             assert_eq!(s["hello, ".len()..].to_uppercase(), "WORLD!");
    |                        ^^^^^^^^^^^^^^^^^^^^
    |
 note: the prefix was tested here
-  --> $DIR/min_rust_version_attr.rs:153:9
+  --> $DIR/min_rust_version_attr.rs:161:9
    |
 LL |         if s.starts_with("hello, ") {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From 7e641c8be774bba047d7d9ee57455957fd4e2a3b Mon Sep 17 00:00:00 2001
From: Bastian Kersting <bastian@cmbt.de>
Date: Sun, 20 Dec 2020 20:10:00 +0100
Subject: Fixed error messages

---
 clippy_lints/src/from_over_into.rs | 4 ++--
 tests/ui/from_over_into.stderr     | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/from_over_into.rs b/clippy_lints/src/from_over_into.rs
index c7988d6f01f..083101ab1c6 100644
--- a/clippy_lints/src/from_over_into.rs
+++ b/clippy_lints/src/from_over_into.rs
@@ -71,9 +71,9 @@ impl LateLintPass<'_> for FromOverInto {
                     cx,
                     FROM_OVER_INTO,
                     item.span,
-                    "An implementation of From is preferred since it gives you Into<..> for free where the reverse isn't true.",
+                    "An implementation of `From` is preferred since it gives you `Into<_>` for free where the reverse isn't true.",
                     None,
-                    "consider to implement From instead",
+                    "consider to implement `From` instead",
                 );
             }
         }
diff --git a/tests/ui/from_over_into.stderr b/tests/ui/from_over_into.stderr
index c9c8e7c4b53..0825d47add2 100644
--- a/tests/ui/from_over_into.stderr
+++ b/tests/ui/from_over_into.stderr
@@ -1,4 +1,4 @@
-error: An implementation of From is preferred since it gives you Into<..> for free where the reverse isn't true.
+error: An implementation of `From` is preferred since it gives you `Into<_>` for free where the reverse isn't true.
   --> $DIR/from_over_into.rs:6:1
    |
 LL | / impl Into<StringWrapper> for String {
@@ -9,7 +9,7 @@ LL | | }
    | |_^
    |
    = note: `-D clippy::from-over-into` implied by `-D warnings`
-   = help: consider to implement From instead
+   = help: consider to implement `From` instead
 
 error: aborting due to previous error
 
-- 
cgit 1.4.1-3-g733a5


From 0d6c128bfd41b61f246f603cfcd9ee4fc97ca3a0 Mon Sep 17 00:00:00 2001
From: llogiq <bogusandre@gmail.com>
Date: Mon, 21 Dec 2020 09:18:30 +0100
Subject: Update clippy_lints/src/from_over_into.rs

Co-authored-by: Takayuki Nakata <f.seasons017@gmail.com>
---
 clippy_lints/src/from_over_into.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/from_over_into.rs b/clippy_lints/src/from_over_into.rs
index 083101ab1c6..1e7e5f53cc2 100644
--- a/clippy_lints/src/from_over_into.rs
+++ b/clippy_lints/src/from_over_into.rs
@@ -71,7 +71,7 @@ impl LateLintPass<'_> for FromOverInto {
                     cx,
                     FROM_OVER_INTO,
                     item.span,
-                    "An implementation of `From` is preferred since it gives you `Into<_>` for free where the reverse isn't true.",
+                    "an implementation of `From` is preferred since it gives you `Into<_>` for free where the reverse isn't true",
                     None,
                     "consider to implement `From` instead",
                 );
-- 
cgit 1.4.1-3-g733a5


From 12bd244caa4547b4b84108d892e85bf953b1a408 Mon Sep 17 00:00:00 2001
From: Philipp Hansch <dev@phansch.net>
Date: Mon, 21 Dec 2020 11:09:49 +0100
Subject: Don't trigger large_enum_variant in external macros

---
 clippy_lints/src/large_enum_variant.rs |  4 ++++
 tests/ui/auxiliary/macro_rules.rs      | 10 ++++++++++
 tests/ui/large_enum_variant.rs         |  9 ++++++++-
 tests/ui/large_enum_variant.stderr     | 18 +++++++++---------
 4 files changed, 31 insertions(+), 10 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/large_enum_variant.rs b/clippy_lints/src/large_enum_variant.rs
index 3c7880d74ee..ad9b4f357a7 100644
--- a/clippy_lints/src/large_enum_variant.rs
+++ b/clippy_lints/src/large_enum_variant.rs
@@ -4,6 +4,7 @@ use crate::utils::{snippet_opt, span_lint_and_then};
 use rustc_errors::Applicability;
 use rustc_hir::{Item, ItemKind, VariantData};
 use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_target::abi::LayoutOf;
 
@@ -58,6 +59,9 @@ impl_lint_pass!(LargeEnumVariant => [LARGE_ENUM_VARIANT]);
 
 impl<'tcx> LateLintPass<'tcx> for LargeEnumVariant {
     fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
+        if in_external_macro(cx.tcx.sess, item.span) {
+            return;
+        }
         let did = cx.tcx.hir().local_def_id(item.hir_id);
         if let ItemKind::Enum(ref def, _) = item.kind {
             let ty = cx.tcx.type_of(did);
diff --git a/tests/ui/auxiliary/macro_rules.rs b/tests/ui/auxiliary/macro_rules.rs
index f985a15eda2..18324823468 100644
--- a/tests/ui/auxiliary/macro_rules.rs
+++ b/tests/ui/auxiliary/macro_rules.rs
@@ -84,3 +84,13 @@ macro_rules! as_conv {
         0u32 as u64
     };
 }
+
+#[macro_export]
+macro_rules! large_enum_variant {
+    () => {
+        enum LargeEnumInMacro {
+            A(i32),
+            B([i32; 8000]),
+        }
+    };
+}
diff --git a/tests/ui/large_enum_variant.rs b/tests/ui/large_enum_variant.rs
index 852ef5fec0e..d22fee3f27b 100644
--- a/tests/ui/large_enum_variant.rs
+++ b/tests/ui/large_enum_variant.rs
@@ -1,7 +1,12 @@
+// aux-build:macro_rules.rs
+
 #![allow(dead_code)]
 #![allow(unused_variables)]
 #![warn(clippy::large_enum_variant)]
 
+#[macro_use]
+extern crate macro_rules;
+
 enum LargeEnum {
     A(i32),
     B([i32; 8000]),
@@ -51,4 +56,6 @@ enum LargeEnumOk {
     LargeB([i32; 8001]),
 }
 
-fn main() {}
+fn main() {
+    large_enum_variant!();
+}
diff --git a/tests/ui/large_enum_variant.stderr b/tests/ui/large_enum_variant.stderr
index 8ce641a81f2..d39a4d462aa 100644
--- a/tests/ui/large_enum_variant.stderr
+++ b/tests/ui/large_enum_variant.stderr
@@ -1,12 +1,12 @@
 error: large size difference between variants
-  --> $DIR/large_enum_variant.rs:7:5
+  --> $DIR/large_enum_variant.rs:12:5
    |
 LL |     B([i32; 8000]),
    |     ^^^^^^^^^^^^^^ this variant is 32000 bytes
    |
    = note: `-D clippy::large-enum-variant` implied by `-D warnings`
 note: and the second-largest variant is 4 bytes:
-  --> $DIR/large_enum_variant.rs:6:5
+  --> $DIR/large_enum_variant.rs:11:5
    |
 LL |     A(i32),
    |     ^^^^^^
@@ -16,13 +16,13 @@ LL |     B(Box<[i32; 8000]>),
    |       ^^^^^^^^^^^^^^^^
 
 error: large size difference between variants
-  --> $DIR/large_enum_variant.rs:31:5
+  --> $DIR/large_enum_variant.rs:36:5
    |
 LL |     ContainingLargeEnum(LargeEnum),
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this variant is 32004 bytes
    |
 note: and the second-largest variant is 8 bytes:
-  --> $DIR/large_enum_variant.rs:30:5
+  --> $DIR/large_enum_variant.rs:35:5
    |
 LL |     VariantOk(i32, u32),
    |     ^^^^^^^^^^^^^^^^^^^
@@ -32,30 +32,30 @@ LL |     ContainingLargeEnum(Box<LargeEnum>),
    |                         ^^^^^^^^^^^^^^
 
 error: large size difference between variants
-  --> $DIR/large_enum_variant.rs:41:5
+  --> $DIR/large_enum_variant.rs:46:5
    |
 LL |     StructLikeLarge { x: [i32; 8000], y: i32 },
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this variant is 32004 bytes
    |
 note: and the second-largest variant is 8 bytes:
-  --> $DIR/large_enum_variant.rs:40:5
+  --> $DIR/large_enum_variant.rs:45:5
    |
 LL |     VariantOk(i32, u32),
    |     ^^^^^^^^^^^^^^^^^^^
 help: consider boxing the large fields to reduce the total size of the enum
-  --> $DIR/large_enum_variant.rs:41:5
+  --> $DIR/large_enum_variant.rs:46:5
    |
 LL |     StructLikeLarge { x: [i32; 8000], y: i32 },
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: large size difference between variants
-  --> $DIR/large_enum_variant.rs:46:5
+  --> $DIR/large_enum_variant.rs:51:5
    |
 LL |     StructLikeLarge2 { x: [i32; 8000] },
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this variant is 32000 bytes
    |
 note: and the second-largest variant is 8 bytes:
-  --> $DIR/large_enum_variant.rs:45:5
+  --> $DIR/large_enum_variant.rs:50:5
    |
 LL |     VariantOk(i32, u32),
    |     ^^^^^^^^^^^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From af22613a25ad866a600bec13995ec16c993e5aac Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Tue, 22 Dec 2020 03:11:35 +0100
Subject: remove clone in manual_async_fn lint

---
 clippy_lints/src/manual_async_fn.rs | 2 +-
 clippy_lints/src/unused_unit.rs     | 2 +-
 clippy_lints/src/utils/mod.rs       | 3 +--
 3 files changed, 3 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_async_fn.rs b/clippy_lints/src/manual_async_fn.rs
index 7b3b450ef93..29439e52c48 100644
--- a/clippy_lints/src/manual_async_fn.rs
+++ b/clippy_lints/src/manual_async_fn.rs
@@ -69,7 +69,7 @@ impl<'tcx> LateLintPass<'tcx> for ManualAsyncFn {
                     |diag| {
                         if_chain! {
                             if let Some(header_snip) = snippet_opt(cx, header_span);
-                            if let Some(ret_pos) = position_before_rarrow(header_snip.clone());
+                            if let Some(ret_pos) = position_before_rarrow(&header_snip);
                             if let Some((ret_sugg, ret_snip)) = suggested_ret(cx, output);
                             then {
                                 let help = format!("make the function `async` and {}", ret_sugg);
diff --git a/clippy_lints/src/unused_unit.rs b/clippy_lints/src/unused_unit.rs
index f61fd2ecd73..a31cd5fda84 100644
--- a/clippy_lints/src/unused_unit.rs
+++ b/clippy_lints/src/unused_unit.rs
@@ -120,7 +120,7 @@ fn is_unit_expr(expr: &ast::Expr) -> bool {
 
 fn lint_unneeded_unit_return(cx: &EarlyContext<'_>, ty: &ast::Ty, span: Span) {
     let (ret_span, appl) = if let Ok(fn_source) = cx.sess().source_map().span_to_snippet(span.with_hi(ty.span.hi())) {
-        position_before_rarrow(fn_source).map_or((ty.span, Applicability::MaybeIncorrect), |rpos| {
+        position_before_rarrow(&fn_source).map_or((ty.span, Applicability::MaybeIncorrect), |rpos| {
             (
                 #[allow(clippy::cast_possible_truncation)]
                 ty.span.with_lo(BytePos(span.lo().0 + rpos as u32)),
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index 424856090f2..1c68e837c4a 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -788,8 +788,7 @@ pub fn indent_of<T: LintContext>(cx: &T, span: Span) -> Option<usize> {
 /// fn into3(self)   -> () {}
 ///               ^
 /// ```
-#[allow(clippy::needless_pass_by_value)]
-pub fn position_before_rarrow(s: String) -> Option<usize> {
+pub fn position_before_rarrow(s: &str) -> Option<usize> {
     s.rfind("->").map(|rpos| {
         let mut rpos = rpos;
         let chars: Vec<char> = s.chars().collect();
-- 
cgit 1.4.1-3-g733a5


From 8bdf34e10cfa47b6e0cfccd5d0f8e6a5c079bc30 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Mon, 23 Nov 2020 12:26:35 -0600
Subject: Fix default initialized fields in suggestion

The default value for a field type does not necessarily match the
default value for that field in the struct Default.
---
 clippy_lints/src/default.rs                 | 6 ------
 tests/ui/field_reassign_with_default.stderr | 4 ++--
 2 files changed, 2 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/default.rs b/clippy_lints/src/default.rs
index f69f6f1412a..adcc17266d2 100644
--- a/clippy_lints/src/default.rs
+++ b/clippy_lints/src/default.rs
@@ -165,12 +165,6 @@ impl LateLintPass<'_> for Default {
                 let stmt = &block.stmts[stmt_idx];
 
                 if let StmtKind::Local(preceding_local) = &stmt.kind {
-                    // filter out fields like `= Default::default()`, because the FRU already covers them
-                    let assigned_fields = assigned_fields
-                        .into_iter()
-                        .filter(|(_, rhs)| !is_expr_default(rhs, cx))
-                        .collect::<Vec<(Symbol, &Expr<'_>)>>();
-
                     // if all fields of the struct are not assigned, add `.. Default::default()` to the suggestion.
                     let ext_with_default = !fields_of_type(binding_type)
                         .iter()
diff --git a/tests/ui/field_reassign_with_default.stderr b/tests/ui/field_reassign_with_default.stderr
index c788ebae552..9a2bc778c3f 100644
--- a/tests/ui/field_reassign_with_default.stderr
+++ b/tests/ui/field_reassign_with_default.stderr
@@ -53,7 +53,7 @@ error: field assignment outside of initializer for an instance created with Defa
 LL |     a.i = Default::default();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-note: consider initializing the variable with `A::default()` and removing relevant reassignments
+note: consider initializing the variable with `A { i: Default::default(), ..Default::default() }` and removing relevant reassignments
   --> $DIR/field_reassign_with_default.rs:90:5
    |
 LL |     let mut a: A = Default::default();
@@ -65,7 +65,7 @@ error: field assignment outside of initializer for an instance created with Defa
 LL |     a.i = Default::default();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-note: consider initializing the variable with `A { j: 45, ..Default::default() }` and removing relevant reassignments
+note: consider initializing the variable with `A { i: Default::default(), j: 45 }` and removing relevant reassignments
   --> $DIR/field_reassign_with_default.rs:94:5
    |
 LL |     let mut a: A = Default::default();
-- 
cgit 1.4.1-3-g733a5


From 73ce34a1970e860d14111127dd11d9ba56c41c3a Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Mon, 23 Nov 2020 13:20:53 -0600
Subject: Remove redundant shadow check

There is already an assertion that consecutive lines assign to a struct
field.
---
 clippy_lints/src/default.rs | 20 ++------------------
 1 file changed, 2 insertions(+), 18 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/default.rs b/clippy_lints/src/default.rs
index adcc17266d2..c3fe77f6250 100644
--- a/clippy_lints/src/default.rs
+++ b/clippy_lints/src/default.rs
@@ -122,15 +122,8 @@ impl LateLintPass<'_> for Default {
             let mut assigned_fields = Vec::new();
             let mut cancel_lint = false;
             for consecutive_statement in &block.stmts[stmt_idx + 1..] {
-                // interrupt if the statement is a let binding (`Local`) that shadows the original
-                // binding
-                if stmt_shadows_binding(consecutive_statement, binding_name) {
-                    break;
-                }
                 // find out if and which field was set by this `consecutive_statement`
-                else if let Some((field_ident, assign_rhs)) =
-                    field_reassigned_by_stmt(consecutive_statement, binding_name)
-                {
+                if let Some((field_ident, assign_rhs)) = field_reassigned_by_stmt(consecutive_statement, binding_name) {
                     // interrupt and cancel lint if assign_rhs references the original binding
                     if contains_name(binding_name, assign_rhs) {
                         cancel_lint = true;
@@ -152,7 +145,7 @@ impl LateLintPass<'_> for Default {
                         first_assign = Some(consecutive_statement);
                     }
                 }
-                // interrupt also if no field was assigned, since we only want to look at consecutive statements
+                // interrupt if no field was assigned, since we only want to look at consecutive statements
                 else {
                     break;
                 }
@@ -256,15 +249,6 @@ fn enumerate_bindings_using_default<'tcx>(
         .collect()
 }
 
-fn stmt_shadows_binding(this: &Stmt<'_>, shadowed: Symbol) -> bool {
-    if let StmtKind::Local(local) = &this.kind {
-        if let PatKind::Binding(_, _, ident, _) = local.pat.kind {
-            return ident.name == shadowed;
-        }
-    }
-    false
-}
-
 /// Returns the reassigned field and the assigning expression (right-hand side of assign).
 fn field_reassigned_by_stmt<'tcx>(this: &Stmt<'tcx>, binding_name: Symbol) -> Option<(Ident, &'tcx Expr<'tcx>)> {
     if_chain! {
-- 
cgit 1.4.1-3-g733a5


From c6450c70ddb5354bc2218bff20a325ded9682613 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Mon, 23 Nov 2020 09:23:24 -0600
Subject: Fix field_reassign_with_default for private fields

---
 clippy_lints/src/default.rs             | 162 ++++++++++++++------------------
 tests/ui/field_reassign_with_default.rs |  12 +++
 2 files changed, 81 insertions(+), 93 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/default.rs b/clippy_lints/src/default.rs
index c3fe77f6250..b0d7c7b3baa 100644
--- a/clippy_lints/src/default.rs
+++ b/clippy_lints/src/default.rs
@@ -6,7 +6,7 @@ use rustc_errors::Applicability;
 use rustc_hir::def::Res;
 use rustc_hir::{Block, Expr, ExprKind, PatKind, QPath, Stmt, StmtKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty::{self, Adt, Ty};
+use rustc_middle::ty;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::symbol::{Ident, Symbol};
 use rustc_span::Span;
@@ -103,18 +103,41 @@ impl LateLintPass<'_> for Default {
     }
 
     fn check_block<'tcx>(&mut self, cx: &LateContext<'tcx>, block: &Block<'tcx>) {
-        // find all binding statements like `let mut _ = T::default()` where `T::default()` is the
-        // `default` method of the `Default` trait, and store statement index in current block being
-        // checked and the name of the bound variable
-        let binding_statements_using_default = enumerate_bindings_using_default(cx, block);
-
         // start from the `let mut _ = _::default();` and look at all the following
         // statements, see if they re-assign the fields of the binding
-        for (stmt_idx, binding_name, binding_type, span) in binding_statements_using_default {
-            // the last statement of a block cannot trigger the lint
-            if stmt_idx == block.stmts.len() - 1 {
-                break;
-            }
+        let stmts_head = match block.stmts {
+            // Skip the last statement since there cannot possibly be any following statements that re-assign fields.
+            [head @ .., _] if !head.is_empty() => head,
+            _ => return,
+        };
+        for (stmt_idx, stmt) in stmts_head.iter().enumerate() {
+            // find all binding statements like `let mut _ = T::default()` where `T::default()` is the
+            // `default` method of the `Default` trait, and store statement index in current block being
+            // checked and the name of the bound variable
+            let (local, variant, binding_name, binding_type, span) = if_chain! {
+                // only take `let ...` statements
+                if let StmtKind::Local(local) = stmt.kind;
+                if let Some(expr) = local.init;
+                // only take bindings to identifiers
+                if let PatKind::Binding(_, binding_id, ident, _) = local.pat.kind;
+                // only when assigning `... = Default::default()`
+                if is_expr_default(expr, cx);
+                let binding_type = cx.typeck_results().node_type(binding_id);
+                if let Some(adt) = binding_type.ty_adt_def();
+                if adt.is_struct();
+                let variant = adt.non_enum_variant();
+                if adt.did.is_local() || !variant.is_field_list_non_exhaustive();
+                let module_did = cx.tcx.parent_module(stmt.hir_id).to_def_id();
+                if variant
+                    .fields
+                    .iter()
+                    .all(|field| field.vis.is_accessible_from(module_did, cx.tcx));
+                then {
+                    (local, variant, ident.name, binding_type, expr.span)
+                } else {
+                    continue;
+                }
+            };
 
             // find all "later statement"'s where the fields of the binding set as
             // Default::default() get reassigned, unless the reassignment refers to the original binding
@@ -154,49 +177,45 @@ impl LateLintPass<'_> for Default {
             // if there are incorrectly assigned fields, do a span_lint_and_note to suggest
             // construction using `Ty { fields, ..Default::default() }`
             if !assigned_fields.is_empty() && !cancel_lint {
-                // take the original assignment as span
-                let stmt = &block.stmts[stmt_idx];
-
-                if let StmtKind::Local(preceding_local) = &stmt.kind {
-                    // if all fields of the struct are not assigned, add `.. Default::default()` to the suggestion.
-                    let ext_with_default = !fields_of_type(binding_type)
-                        .iter()
-                        .all(|field| assigned_fields.iter().any(|(a, _)| a == &field.name));
+                // if all fields of the struct are not assigned, add `.. Default::default()` to the suggestion.
+                let ext_with_default = !variant
+                    .fields
+                    .iter()
+                    .all(|field| assigned_fields.iter().any(|(a, _)| a == &field.ident.name));
 
-                    let field_list = assigned_fields
-                        .into_iter()
-                        .map(|(field, rhs)| {
-                            // extract and store the assigned value for help message
-                            let value_snippet = snippet(cx, rhs.span, "..");
-                            format!("{}: {}", field, value_snippet)
-                        })
-                        .collect::<Vec<String>>()
-                        .join(", ");
+                let field_list = assigned_fields
+                    .into_iter()
+                    .map(|(field, rhs)| {
+                        // extract and store the assigned value for help message
+                        let value_snippet = snippet(cx, rhs.span, "..");
+                        format!("{}: {}", field, value_snippet)
+                    })
+                    .collect::<Vec<String>>()
+                    .join(", ");
 
-                    let sugg = if ext_with_default {
-                        if field_list.is_empty() {
-                            format!("{}::default()", binding_type)
-                        } else {
-                            format!("{} {{ {}, ..Default::default() }}", binding_type, field_list)
-                        }
+                let sugg = if ext_with_default {
+                    if field_list.is_empty() {
+                        format!("{}::default()", binding_type)
                     } else {
-                        format!("{} {{ {} }}", binding_type, field_list)
-                    };
+                        format!("{} {{ {}, ..Default::default() }}", binding_type, field_list)
+                    }
+                } else {
+                    format!("{} {{ {} }}", binding_type, field_list)
+                };
 
-                    // span lint once per statement that binds default
-                    span_lint_and_note(
-                        cx,
-                        FIELD_REASSIGN_WITH_DEFAULT,
-                        first_assign.unwrap().span,
-                        "field assignment outside of initializer for an instance created with Default::default()",
-                        Some(preceding_local.span),
-                        &format!(
-                            "consider initializing the variable with `{}` and removing relevant reassignments",
-                            sugg
-                        ),
-                    );
-                    self.reassigned_linted.insert(span);
-                }
+                // span lint once per statement that binds default
+                span_lint_and_note(
+                    cx,
+                    FIELD_REASSIGN_WITH_DEFAULT,
+                    first_assign.unwrap().span,
+                    "field assignment outside of initializer for an instance created with Default::default()",
+                    Some(local.span),
+                    &format!(
+                        "consider initializing the variable with `{}` and removing relevant reassignments",
+                        sugg
+                    ),
+                );
+                self.reassigned_linted.insert(span);
             }
         }
     }
@@ -217,38 +236,6 @@ fn is_expr_default<'tcx>(expr: &'tcx Expr<'tcx>, cx: &LateContext<'tcx>) -> bool
     }
 }
 
-/// Returns the block indices, identifiers and types of bindings set as `Default::default()`, except
-/// for when the pattern type is a tuple.
-fn enumerate_bindings_using_default<'tcx>(
-    cx: &LateContext<'tcx>,
-    block: &Block<'tcx>,
-) -> Vec<(usize, Symbol, Ty<'tcx>, Span)> {
-    block
-        .stmts
-        .iter()
-        .enumerate()
-        .filter_map(|(idx, stmt)| {
-            if_chain! {
-                // only take `let ...` statements
-                if let StmtKind::Local(ref local) = stmt.kind;
-                // only take bindings to identifiers
-                if let PatKind::Binding(_, _, ident, _) = local.pat.kind;
-                // that are not tuples
-                let ty = cx.typeck_results().pat_ty(local.pat);
-                if !matches!(ty.kind(), ty::Tuple(_));
-                // only when assigning `... = Default::default()`
-                if let Some(ref expr) = local.init;
-                if is_expr_default(expr, cx);
-                then {
-                    Some((idx, ident.name, ty, expr.span))
-                } else {
-                    None
-                }
-            }
-        })
-        .collect()
-}
-
 /// Returns the reassigned field and the assigning expression (right-hand side of assign).
 fn field_reassigned_by_stmt<'tcx>(this: &Stmt<'tcx>, binding_name: Symbol) -> Option<(Ident, &'tcx Expr<'tcx>)> {
     if_chain! {
@@ -268,14 +255,3 @@ fn field_reassigned_by_stmt<'tcx>(this: &Stmt<'tcx>, binding_name: Symbol) -> Op
         }
     }
 }
-
-/// Returns the vec of fields for a struct and an empty vec for non-struct ADTs.
-fn fields_of_type(ty: Ty<'_>) -> Vec<Ident> {
-    if let Adt(adt, _) = ty.kind() {
-        if adt.is_struct() {
-            let variant = &adt.non_enum_variant();
-            return variant.fields.iter().map(|f| f.ident).collect();
-        }
-    }
-    vec![]
-}
diff --git a/tests/ui/field_reassign_with_default.rs b/tests/ui/field_reassign_with_default.rs
index 79a30c22f95..3e0921022b4 100644
--- a/tests/ui/field_reassign_with_default.rs
+++ b/tests/ui/field_reassign_with_default.rs
@@ -107,4 +107,16 @@ fn main() {
     x.i = side_effect.next();
     x.j = 2;
     x.i = side_effect.next();
+
+    // don't lint - some private fields
+    let mut x = m::F::default();
+    x.a = 1;
+}
+
+mod m {
+    #[derive(Default)]
+    pub struct F {
+        pub a: u64,
+        b: u64,
+    }
 }
-- 
cgit 1.4.1-3-g733a5


From e1743ef5250d67260a2a1b0126708d969f80909f Mon Sep 17 00:00:00 2001
From: Takayuki Nakata <f.seasons017@gmail.com>
Date: Fri, 25 Dec 2020 08:59:34 +0900
Subject: Fix a style of texts in `map_err_ignore`

---
 clippy_lints/src/map_err_ignore.rs | 4 ++--
 tests/ui/map_err.stderr            | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/map_err_ignore.rs b/clippy_lints/src/map_err_ignore.rs
index f3c0515b9bc..76fe8e776ea 100644
--- a/clippy_lints/src/map_err_ignore.rs
+++ b/clippy_lints/src/map_err_ignore.rs
@@ -7,7 +7,7 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 declare_clippy_lint! {
     /// **What it does:** Checks for instances of `map_err(|_| Some::Enum)`
     ///
-    /// **Why is this bad?** This map_err throws away the original error rather than allowing the enum to contain and report the cause of the error
+    /// **Why is this bad?** This `map_err` throws away the original error rather than allowing the enum to contain and report the cause of the error
     ///
     /// **Known problems:** None.
     ///
@@ -135,7 +135,7 @@ impl<'tcx> LateLintPass<'tcx> for MapErrIgnore {
                                     body_span,
                                     "`map_err(|_|...` wildcard pattern discards the original error",
                                     None,
-                                    "Consider storing the original error as a source in the new error, or silence this warning using an ignored identifier (`.map_err(|_foo| ...`)",
+                                    "consider storing the original error as a source in the new error, or silence this warning using an ignored identifier (`.map_err(|_foo| ...`)",
                                 );
                             }
                         }
diff --git a/tests/ui/map_err.stderr b/tests/ui/map_err.stderr
index 8ee2941790d..37e87e64de2 100644
--- a/tests/ui/map_err.stderr
+++ b/tests/ui/map_err.stderr
@@ -5,7 +5,7 @@ LL |     println!("{:?}", x.map_err(|_| Errors::Ignored));
    |                                ^^^
    |
    = note: `-D clippy::map-err-ignore` implied by `-D warnings`
-   = help: Consider storing the original error as a source in the new error, or silence this warning using an ignored identifier (`.map_err(|_foo| ...`)
+   = help: consider storing the original error as a source in the new error, or silence this warning using an ignored identifier (`.map_err(|_foo| ...`)
 
 error: aborting due to previous error
 
-- 
cgit 1.4.1-3-g733a5


From dfaea9c9677f97656ad75f6bacd78f8f87e1d339 Mon Sep 17 00:00:00 2001
From: Aleksei Latyshev <alex_700_95@mail.ru>
Date: Fri, 25 Dec 2020 14:45:04 +0300
Subject: lint &PathBuf instead of &Path in PTR_ARG

- extract get_only_generic_arg_snippet to improve readability
---
 clippy_dev/src/ra_setup.rs |  4 ++--
 clippy_lints/src/ptr.rs    | 60 ++++++++++++++++++++++++++++++++++------------
 tests/ui/ptr_arg.rs        | 22 +++++++++++++++++
 tests/ui/ptr_arg.stderr    | 45 +++++++++++++++++++++++++++-------
 4 files changed, 106 insertions(+), 25 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_dev/src/ra_setup.rs b/clippy_dev/src/ra_setup.rs
index 40bf4a9505a..5f5048e79e7 100644
--- a/clippy_dev/src/ra_setup.rs
+++ b/clippy_dev/src/ra_setup.rs
@@ -3,7 +3,7 @@
 use std::fs;
 use std::fs::File;
 use std::io::prelude::*;
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 
 // This module takes an absolute path to a rustc repo and alters the dependencies to point towards
 // the respective rustc subcrates instead of using extern crate xyz.
@@ -44,7 +44,7 @@ pub fn run(rustc_path: Option<&str>) {
 }
 
 fn inject_deps_into_manifest(
-    rustc_source_dir: &PathBuf,
+    rustc_source_dir: &Path,
     manifest_path: &str,
     cargo_toml: &str,
     lib_rs: &str,
diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs
index dcb643a28ae..c494a713631 100644
--- a/clippy_lints/src/ptr.rs
+++ b/clippy_lints/src/ptr.rs
@@ -182,20 +182,6 @@ fn check_fn(cx: &LateContext<'_>, decl: &FnDecl<'_>, fn_id: HirId, opt_body_id:
 
         if let ty::Ref(_, ty, Mutability::Not) = ty.kind() {
             if is_type_diagnostic_item(cx, ty, sym::vec_type) {
-                let mut ty_snippet = None;
-                if_chain! {
-                    if let TyKind::Path(QPath::Resolved(_, ref path)) = walk_ptrs_hir_ty(arg).kind;
-                    if let Some(&PathSegment{args: Some(ref parameters), ..}) = path.segments.last();
-                    then {
-                        let types: Vec<_> = parameters.args.iter().filter_map(|arg| match arg {
-                            GenericArg::Type(ty) => Some(ty),
-                            _ => None,
-                        }).collect();
-                        if types.len() == 1 {
-                            ty_snippet = snippet_opt(cx, types[0].span);
-                        }
-                    }
-                };
                 if let Some(spans) = get_spans(cx, opt_body_id, idx, &[("clone", ".to_owned()")]) {
                     span_lint_and_then(
                         cx,
@@ -204,7 +190,7 @@ fn check_fn(cx: &LateContext<'_>, decl: &FnDecl<'_>, fn_id: HirId, opt_body_id:
                         "writing `&Vec<_>` instead of `&[_]` involves one more reference and cannot be used \
                          with non-Vec-based slices.",
                         |diag| {
-                            if let Some(ref snippet) = ty_snippet {
+                            if let Some(ref snippet) = get_only_generic_arg_snippet(cx, arg) {
                                 diag.span_suggestion(
                                     arg.span,
                                     "change this to",
@@ -247,6 +233,33 @@ fn check_fn(cx: &LateContext<'_>, decl: &FnDecl<'_>, fn_id: HirId, opt_body_id:
                         },
                     );
                 }
+            } else if match_type(cx, ty, &paths::PATH_BUF) {
+                if let Some(spans) = get_spans(cx, opt_body_id, idx, &[("clone", ".to_path_buf()"), ("as_path", "")]) {
+                    span_lint_and_then(
+                        cx,
+                        PTR_ARG,
+                        arg.span,
+                        "writing `&PathBuf` instead of `&Path` involves a new object where a slice will do.",
+                        |diag| {
+                            diag.span_suggestion(
+                                arg.span,
+                                "change this to",
+                                "&Path".into(),
+                                Applicability::Unspecified,
+                            );
+                            for (clonespan, suggestion) in spans {
+                                diag.span_suggestion_short(
+                                    clonespan,
+                                    &snippet_opt(cx, clonespan).map_or("change the call to".into(), |x| {
+                                        Cow::Owned(format!("change `{}` to", x))
+                                    }),
+                                    suggestion.into(),
+                                    Applicability::Unspecified,
+                                );
+                            }
+                        },
+                    );
+                }
             } else if match_type(cx, ty, &paths::COW) {
                 if_chain! {
                     if let TyKind::Rptr(_, MutTy { ref ty, ..} ) = arg.kind;
@@ -309,6 +322,23 @@ fn check_fn(cx: &LateContext<'_>, decl: &FnDecl<'_>, fn_id: HirId, opt_body_id:
     }
 }
 
+fn get_only_generic_arg_snippet(cx: &LateContext<'_>, arg: &Ty<'_>) -> Option<String> {
+    if_chain! {
+        if let TyKind::Path(QPath::Resolved(_, ref path)) = walk_ptrs_hir_ty(arg).kind;
+        if let Some(&PathSegment{args: Some(ref parameters), ..}) = path.segments.last();
+        let types: Vec<_> = parameters.args.iter().filter_map(|arg| match arg {
+            GenericArg::Type(ty) => Some(ty),
+            _ => None,
+        }).collect();
+        if types.len() == 1;
+        then {
+            snippet_opt(cx, types[0].span)
+        } else {
+            None
+        }
+    }
+}
+
 fn get_rptr_lm<'tcx>(ty: &'tcx Ty<'tcx>) -> Option<(&'tcx Lifetime, Mutability, Span)> {
     if let TyKind::Rptr(ref lt, ref m) = ty.kind {
         Some((lt, m.mutbl, ty.span))
diff --git a/tests/ui/ptr_arg.rs b/tests/ui/ptr_arg.rs
index 541225e6351..e8854fb73d9 100644
--- a/tests/ui/ptr_arg.rs
+++ b/tests/ui/ptr_arg.rs
@@ -2,6 +2,7 @@
 #![warn(clippy::ptr_arg)]
 
 use std::borrow::Cow;
+use std::path::PathBuf;
 
 fn do_vec(x: &Vec<i64>) {
     //Nothing here
@@ -21,6 +22,15 @@ fn do_str_mut(x: &mut String) {
     //Nothing here either
 }
 
+fn do_path(x: &PathBuf) {
+    //Nothing here either
+}
+
+fn do_path_mut(x: &mut PathBuf) {
+    // no error here
+    //Nothing here either
+}
+
 fn main() {}
 
 trait Foo {
@@ -55,6 +65,14 @@ fn str_cloned(x: &String) -> String {
     x.clone()
 }
 
+fn path_cloned(x: &PathBuf) -> PathBuf {
+    let a = x.clone();
+    let b = x.clone();
+    let c = b.clone();
+    let d = a.clone().clone().clone();
+    x.clone()
+}
+
 fn false_positive_capacity(x: &Vec<u8>, y: &String) {
     let a = x.capacity();
     let b = y.clone();
@@ -87,10 +105,12 @@ impl Foo2 for String {
 // Check that the allow attribute on parameters is honored
 mod issue_5644 {
     use std::borrow::Cow;
+    use std::path::PathBuf;
 
     fn allowed(
         #[allow(clippy::ptr_arg)] _v: &Vec<u32>,
         #[allow(clippy::ptr_arg)] _s: &String,
+        #[allow(clippy::ptr_arg)] _p: &PathBuf,
         #[allow(clippy::ptr_arg)] _c: &Cow<[i32]>,
     ) {
     }
@@ -100,6 +120,7 @@ mod issue_5644 {
         fn allowed(
             #[allow(clippy::ptr_arg)] _v: &Vec<u32>,
             #[allow(clippy::ptr_arg)] _s: &String,
+            #[allow(clippy::ptr_arg)] _p: &PathBuf,
             #[allow(clippy::ptr_arg)] _c: &Cow<[i32]>,
         ) {
         }
@@ -109,6 +130,7 @@ mod issue_5644 {
         fn allowed(
             #[allow(clippy::ptr_arg)] _v: &Vec<u32>,
             #[allow(clippy::ptr_arg)] _s: &String,
+            #[allow(clippy::ptr_arg)] _p: &PathBuf,
             #[allow(clippy::ptr_arg)] _c: &Cow<[i32]>,
         ) {
         }
diff --git a/tests/ui/ptr_arg.stderr b/tests/ui/ptr_arg.stderr
index 314f23497f9..70d1b2f5258 100644
--- a/tests/ui/ptr_arg.stderr
+++ b/tests/ui/ptr_arg.stderr
@@ -1,5 +1,5 @@
 error: writing `&Vec<_>` instead of `&[_]` involves one more reference and cannot be used with non-Vec-based slices.
-  --> $DIR/ptr_arg.rs:6:14
+  --> $DIR/ptr_arg.rs:7:14
    |
 LL | fn do_vec(x: &Vec<i64>) {
    |              ^^^^^^^^^ help: change this to: `&[i64]`
@@ -7,19 +7,25 @@ LL | fn do_vec(x: &Vec<i64>) {
    = note: `-D clippy::ptr-arg` implied by `-D warnings`
 
 error: writing `&String` instead of `&str` involves a new object where a slice will do.
-  --> $DIR/ptr_arg.rs:15:14
+  --> $DIR/ptr_arg.rs:16:14
    |
 LL | fn do_str(x: &String) {
    |              ^^^^^^^ help: change this to: `&str`
 
+error: writing `&PathBuf` instead of `&Path` involves a new object where a slice will do.
+  --> $DIR/ptr_arg.rs:25:15
+   |
+LL | fn do_path(x: &PathBuf) {
+   |               ^^^^^^^^ help: change this to: `&Path`
+
 error: writing `&Vec<_>` instead of `&[_]` involves one more reference and cannot be used with non-Vec-based slices.
-  --> $DIR/ptr_arg.rs:28:18
+  --> $DIR/ptr_arg.rs:38:18
    |
 LL |     fn do_vec(x: &Vec<i64>);
    |                  ^^^^^^^^^ help: change this to: `&[i64]`
 
 error: writing `&Vec<_>` instead of `&[_]` involves one more reference and cannot be used with non-Vec-based slices.
-  --> $DIR/ptr_arg.rs:41:14
+  --> $DIR/ptr_arg.rs:51:14
    |
 LL | fn cloned(x: &Vec<u8>) -> Vec<u8> {
    |              ^^^^^^^^
@@ -38,7 +44,7 @@ LL |     x.to_owned()
    |
 
 error: writing `&String` instead of `&str` involves a new object where a slice will do.
-  --> $DIR/ptr_arg.rs:50:18
+  --> $DIR/ptr_arg.rs:60:18
    |
 LL | fn str_cloned(x: &String) -> String {
    |                  ^^^^^^^
@@ -60,8 +66,31 @@ help: change `x.clone()` to
 LL |     x.to_string()
    |
 
+error: writing `&PathBuf` instead of `&Path` involves a new object where a slice will do.
+  --> $DIR/ptr_arg.rs:68:19
+   |
+LL | fn path_cloned(x: &PathBuf) -> PathBuf {
+   |                   ^^^^^^^^
+   |
+help: change this to
+   |
+LL | fn path_cloned(x: &Path) -> PathBuf {
+   |                   ^^^^^
+help: change `x.clone()` to
+   |
+LL |     let a = x.to_path_buf();
+   |             ^^^^^^^^^^^^^^^
+help: change `x.clone()` to
+   |
+LL |     let b = x.to_path_buf();
+   |             ^^^^^^^^^^^^^^^
+help: change `x.clone()` to
+   |
+LL |     x.to_path_buf()
+   |
+
 error: writing `&String` instead of `&str` involves a new object where a slice will do.
-  --> $DIR/ptr_arg.rs:58:44
+  --> $DIR/ptr_arg.rs:76:44
    |
 LL | fn false_positive_capacity(x: &Vec<u8>, y: &String) {
    |                                            ^^^^^^^
@@ -80,10 +109,10 @@ LL |     let c = y;
    |             ^
 
 error: using a reference to `Cow` is not recommended.
-  --> $DIR/ptr_arg.rs:72:25
+  --> $DIR/ptr_arg.rs:90:25
    |
 LL | fn test_cow_with_ref(c: &Cow<[i32]>) {}
    |                         ^^^^^^^^^^^ help: change this to: `&[i32]`
 
-error: aborting due to 7 previous errors
+error: aborting due to 9 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 203715aa4ecebb167868100fe14b0eaa05133718 Mon Sep 17 00:00:00 2001
From: Aleksei Latyshev <alex_700_95@mail.ru>
Date: Mon, 28 Dec 2020 01:09:04 +0300
Subject: don't ignore expression after first not matched method call in
 PtrCloneVisitor

---
 clippy_lints/src/utils/ptr.rs |  1 -
 tests/ui/ptr_arg.rs           | 19 ++++++++++++++
 tests/ui/ptr_arg.stderr       | 59 ++++++++++++++++++++++++++++++++++++++++++-
 3 files changed, 77 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/ptr.rs b/clippy_lints/src/utils/ptr.rs
index bd2c619f000..b330f3d890e 100644
--- a/clippy_lints/src/utils/ptr.rs
+++ b/clippy_lints/src/utils/ptr.rs
@@ -72,7 +72,6 @@ impl<'a, 'tcx> Visitor<'tcx> for PtrCloneVisitor<'a, 'tcx> {
                     }
                 }
             }
-            return;
         }
         walk_expr(self, expr);
     }
diff --git a/tests/ui/ptr_arg.rs b/tests/ui/ptr_arg.rs
index e8854fb73d9..06370dfce65 100644
--- a/tests/ui/ptr_arg.rs
+++ b/tests/ui/ptr_arg.rs
@@ -136,3 +136,22 @@ mod issue_5644 {
         }
     }
 }
+
+mod issue6509 {
+    use std::path::PathBuf;
+
+    fn foo_vec(vec: &Vec<u8>) {
+        let _ = vec.clone().pop();
+        let _ = vec.clone().clone();
+    }
+
+    fn foo_path(path: &PathBuf) {
+        let _ = path.clone().pop();
+        let _ = path.clone().clone();
+    }
+
+    fn foo_str(str: &PathBuf) {
+        let _ = str.clone().pop();
+        let _ = str.clone().clone();
+    }
+}
diff --git a/tests/ui/ptr_arg.stderr b/tests/ui/ptr_arg.stderr
index 70d1b2f5258..708318bbe29 100644
--- a/tests/ui/ptr_arg.stderr
+++ b/tests/ui/ptr_arg.stderr
@@ -114,5 +114,62 @@ error: using a reference to `Cow` is not recommended.
 LL | fn test_cow_with_ref(c: &Cow<[i32]>) {}
    |                         ^^^^^^^^^^^ help: change this to: `&[i32]`
 
-error: aborting due to 9 previous errors
+error: writing `&Vec<_>` instead of `&[_]` involves one more reference and cannot be used with non-Vec-based slices.
+  --> $DIR/ptr_arg.rs:143:21
+   |
+LL |     fn foo_vec(vec: &Vec<u8>) {
+   |                     ^^^^^^^^
+   |
+help: change this to
+   |
+LL |     fn foo_vec(vec: &[u8]) {
+   |                     ^^^^^
+help: change `vec.clone()` to
+   |
+LL |         let _ = vec.to_owned().pop();
+   |                 ^^^^^^^^^^^^^^
+help: change `vec.clone()` to
+   |
+LL |         let _ = vec.to_owned().clone();
+   |                 ^^^^^^^^^^^^^^
+
+error: writing `&PathBuf` instead of `&Path` involves a new object where a slice will do.
+  --> $DIR/ptr_arg.rs:148:23
+   |
+LL |     fn foo_path(path: &PathBuf) {
+   |                       ^^^^^^^^
+   |
+help: change this to
+   |
+LL |     fn foo_path(path: &Path) {
+   |                       ^^^^^
+help: change `path.clone()` to
+   |
+LL |         let _ = path.to_path_buf().pop();
+   |                 ^^^^^^^^^^^^^^^^^^
+help: change `path.clone()` to
+   |
+LL |         let _ = path.to_path_buf().clone();
+   |                 ^^^^^^^^^^^^^^^^^^
+
+error: writing `&PathBuf` instead of `&Path` involves a new object where a slice will do.
+  --> $DIR/ptr_arg.rs:153:21
+   |
+LL |     fn foo_str(str: &PathBuf) {
+   |                     ^^^^^^^^
+   |
+help: change this to
+   |
+LL |     fn foo_str(str: &Path) {
+   |                     ^^^^^
+help: change `str.clone()` to
+   |
+LL |         let _ = str.to_path_buf().pop();
+   |                 ^^^^^^^^^^^^^^^^^
+help: change `str.clone()` to
+   |
+LL |         let _ = str.to_path_buf().clone();
+   |                 ^^^^^^^^^^^^^^^^^
+
+error: aborting due to 12 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 469281c0dd6abb13b0b0067e0ed977e70145183c Mon Sep 17 00:00:00 2001
From: nahuakang <kangnahua@gmail.com>
Date: Mon, 28 Dec 2020 18:59:35 +0100
Subject: Check if never type feature is enabled by TyCtxt before suggesting
 empty enum lint

---
 clippy_lints/src/empty_enum.rs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/empty_enum.rs b/clippy_lints/src/empty_enum.rs
index a249117d182..585709660a4 100644
--- a/clippy_lints/src/empty_enum.rs
+++ b/clippy_lints/src/empty_enum.rs
@@ -44,7 +44,9 @@ impl<'tcx> LateLintPass<'tcx> for EmptyEnum {
         if let ItemKind::Enum(..) = item.kind {
             let ty = cx.tcx.type_of(did);
             let adt = ty.ty_adt_def().expect("already checked whether this is an enum");
-            if adt.variants.is_empty() {
+
+            // Only suggest the never type if the feature is enabled
+            if adt.variants.is_empty() && cx.tcx.features().never_type {
                 span_lint_and_help(
                     cx,
                     EMPTY_ENUM,
-- 
cgit 1.4.1-3-g733a5


From 275988cb73e5ad9e7628c7eb424be9cdcec57284 Mon Sep 17 00:00:00 2001
From: nahuakang <kangnahua@gmail.com>
Date: Mon, 28 Dec 2020 20:44:21 +0100
Subject: Add additional lint doc to known problems section

---
 clippy_lints/src/empty_enum.rs | 4 ++++
 1 file changed, 4 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/empty_enum.rs b/clippy_lints/src/empty_enum.rs
index 585709660a4..557a7c6ba98 100644
--- a/clippy_lints/src/empty_enum.rs
+++ b/clippy_lints/src/empty_enum.rs
@@ -8,6 +8,10 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 declare_clippy_lint! {
     /// **What it does:** Checks for `enum`s with no variants.
     ///
+    /// As of this writing, the never type is still a
+    /// nightly-only experimental API. Therefore, this lint is only triggered
+    /// if the never type is enabled
+    ///
     /// **Why is this bad?** If you want to introduce a type which
     /// can't be instantiated, you should use `!` (the never type),
     /// or a wrapper around it, because `!` has more extensive
-- 
cgit 1.4.1-3-g733a5


From e5a1f22f486d70676620cc67cad45ecf359fb56e Mon Sep 17 00:00:00 2001
From: Mara Bos <m-ou.se@m-ou.se>
Date: Fri, 1 Jan 2021 16:21:31 +0100
Subject: Initial support for Rust 2021.

Clippy treated Rust 2021 as Rust 2015, because 2018 was checked with
`==` instead of `>=`. This fixes that, such that 2018-specific things
are also enabled for 2021.
---
 clippy_lints/src/macro_use.rs                     | 2 +-
 clippy_lints/src/single_component_path_imports.rs | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/macro_use.rs b/clippy_lints/src/macro_use.rs
index b4b4b3dc18d..bb52888883a 100644
--- a/clippy_lints/src/macro_use.rs
+++ b/clippy_lints/src/macro_use.rs
@@ -105,7 +105,7 @@ impl MacroUseImports {
 impl<'tcx> LateLintPass<'tcx> for MacroUseImports {
     fn check_item(&mut self, cx: &LateContext<'_>, item: &hir::Item<'_>) {
         if_chain! {
-            if cx.sess().opts.edition == Edition::Edition2018;
+            if cx.sess().opts.edition >= Edition::Edition2018;
             if let hir::ItemKind::Use(path, _kind) = &item.kind;
             if let Some(mac_attr) = item
                 .attrs
diff --git a/clippy_lints/src/single_component_path_imports.rs b/clippy_lints/src/single_component_path_imports.rs
index 35b38eca14d..1fc4ff5c2e6 100644
--- a/clippy_lints/src/single_component_path_imports.rs
+++ b/clippy_lints/src/single_component_path_imports.rs
@@ -40,7 +40,7 @@ impl EarlyLintPass for SingleComponentPathImports {
     fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {
         if_chain! {
             if !in_macro(item.span);
-            if cx.sess.opts.edition == Edition::Edition2018;
+            if cx.sess.opts.edition >= Edition::Edition2018;
             if !item.vis.kind.is_pub();
             if let ItemKind::Use(use_tree) = &item.kind;
             if let segments = &use_tree.prefix.segments;
-- 
cgit 1.4.1-3-g733a5


From 5d48b91b40b3da6c29e8b6eea617bf8ed4033dec Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Fri, 1 Jan 2021 16:59:59 +0100
Subject: field_reassign_with_default: don't expand macros in suggestion

fixes #6522

changelog: field_reassign_with_default: don't expand macros in lint suggestion (#6522)
---
 clippy_lints/src/default.rs                 |  6 +++--
 tests/ui/field_reassign_with_default.rs     |  9 +++++++
 tests/ui/field_reassign_with_default.stderr | 38 +++++++++++++++++++----------
 3 files changed, 38 insertions(+), 15 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/default.rs b/clippy_lints/src/default.rs
index b0d7c7b3baa..9fa06d7cde9 100644
--- a/clippy_lints/src/default.rs
+++ b/clippy_lints/src/default.rs
@@ -1,4 +1,6 @@
-use crate::utils::{any_parent_is_automatically_derived, contains_name, match_def_path, paths, qpath_res, snippet};
+use crate::utils::{
+    any_parent_is_automatically_derived, contains_name, match_def_path, paths, qpath_res, snippet_with_macro_callsite,
+};
 use crate::utils::{span_lint_and_note, span_lint_and_sugg};
 use if_chain::if_chain;
 use rustc_data_structures::fx::FxHashSet;
@@ -187,7 +189,7 @@ impl LateLintPass<'_> for Default {
                     .into_iter()
                     .map(|(field, rhs)| {
                         // extract and store the assigned value for help message
-                        let value_snippet = snippet(cx, rhs.span, "..");
+                        let value_snippet = snippet_with_macro_callsite(cx, rhs.span, "..");
                         format!("{}: {}", field, value_snippet)
                     })
                     .collect::<Vec<String>>()
diff --git a/tests/ui/field_reassign_with_default.rs b/tests/ui/field_reassign_with_default.rs
index 3e0921022b4..2990397c03e 100644
--- a/tests/ui/field_reassign_with_default.rs
+++ b/tests/ui/field_reassign_with_default.rs
@@ -11,6 +11,11 @@ struct B {
     j: i64,
 }
 
+#[derive(Default)]
+struct C {
+    i: Vec<i32>,
+    j: i64,
+}
 /// Implements .next() that returns a different number each time.
 struct SideEffect(i32);
 
@@ -111,6 +116,10 @@ fn main() {
     // don't lint - some private fields
     let mut x = m::F::default();
     x.a = 1;
+
+    // don't expand macros in the suggestion (#6522)
+    let mut a: C = C::default();
+    a.i = vec![1];
 }
 
 mod m {
diff --git a/tests/ui/field_reassign_with_default.stderr b/tests/ui/field_reassign_with_default.stderr
index 9a2bc778c3f..59d2ac8ed69 100644
--- a/tests/ui/field_reassign_with_default.stderr
+++ b/tests/ui/field_reassign_with_default.stderr
@@ -1,75 +1,87 @@
 error: field assignment outside of initializer for an instance created with Default::default()
-  --> $DIR/field_reassign_with_default.rs:30:5
+  --> $DIR/field_reassign_with_default.rs:35:5
    |
 LL |     a.i = 42;
    |     ^^^^^^^^^
    |
    = note: `-D clippy::field-reassign-with-default` implied by `-D warnings`
 note: consider initializing the variable with `A { i: 42, ..Default::default() }` and removing relevant reassignments
-  --> $DIR/field_reassign_with_default.rs:29:5
+  --> $DIR/field_reassign_with_default.rs:34:5
    |
 LL |     let mut a: A = Default::default();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: field assignment outside of initializer for an instance created with Default::default()
-  --> $DIR/field_reassign_with_default.rs:70:5
+  --> $DIR/field_reassign_with_default.rs:75:5
    |
 LL |     a.j = 43;
    |     ^^^^^^^^^
    |
 note: consider initializing the variable with `A { j: 43, i: 42 }` and removing relevant reassignments
-  --> $DIR/field_reassign_with_default.rs:69:5
+  --> $DIR/field_reassign_with_default.rs:74:5
    |
 LL |     let mut a: A = Default::default();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: field assignment outside of initializer for an instance created with Default::default()
-  --> $DIR/field_reassign_with_default.rs:75:5
+  --> $DIR/field_reassign_with_default.rs:80:5
    |
 LL |     a.i = 42;
    |     ^^^^^^^^^
    |
 note: consider initializing the variable with `A { i: 42, j: 44 }` and removing relevant reassignments
-  --> $DIR/field_reassign_with_default.rs:74:5
+  --> $DIR/field_reassign_with_default.rs:79:5
    |
 LL |     let mut a: A = Default::default();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: field assignment outside of initializer for an instance created with Default::default()
-  --> $DIR/field_reassign_with_default.rs:81:5
+  --> $DIR/field_reassign_with_default.rs:86:5
    |
 LL |     a.i = 42;
    |     ^^^^^^^^^
    |
 note: consider initializing the variable with `A { i: 42, ..Default::default() }` and removing relevant reassignments
-  --> $DIR/field_reassign_with_default.rs:80:5
+  --> $DIR/field_reassign_with_default.rs:85:5
    |
 LL |     let mut a = A::default();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: field assignment outside of initializer for an instance created with Default::default()
-  --> $DIR/field_reassign_with_default.rs:91:5
+  --> $DIR/field_reassign_with_default.rs:96:5
    |
 LL |     a.i = Default::default();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: consider initializing the variable with `A { i: Default::default(), ..Default::default() }` and removing relevant reassignments
-  --> $DIR/field_reassign_with_default.rs:90:5
+  --> $DIR/field_reassign_with_default.rs:95:5
    |
 LL |     let mut a: A = Default::default();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: field assignment outside of initializer for an instance created with Default::default()
-  --> $DIR/field_reassign_with_default.rs:95:5
+  --> $DIR/field_reassign_with_default.rs:100:5
    |
 LL |     a.i = Default::default();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: consider initializing the variable with `A { i: Default::default(), j: 45 }` and removing relevant reassignments
-  --> $DIR/field_reassign_with_default.rs:94:5
+  --> $DIR/field_reassign_with_default.rs:99:5
    |
 LL |     let mut a: A = Default::default();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 6 previous errors
+error: field assignment outside of initializer for an instance created with Default::default()
+  --> $DIR/field_reassign_with_default.rs:122:5
+   |
+LL |     a.i = vec![1];
+   |     ^^^^^^^^^^^^^^
+   |
+note: consider initializing the variable with `C { i: vec![1], ..Default::default() }` and removing relevant reassignments
+  --> $DIR/field_reassign_with_default.rs:121:5
+   |
+LL |     let mut a: C = C::default();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 7 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 1853f8b228298d5b91e3d03ee677da91574554b4 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sat, 2 Jan 2021 11:08:56 -0500
Subject: Add lint

---
 CHANGELOG.md                           |   1 +
 clippy_lints/src/lib.rs                |   5 +
 clippy_lints/src/vec_init_then_push.rs | 186 +++++++++++++++++++++++++++++++++
 tests/ui/vec_init_then_push.rs         |  21 ++++
 tests/ui/vec_init_then_push.stderr     |  34 ++++++
 5 files changed, 247 insertions(+)
 create mode 100644 clippy_lints/src/vec_init_then_push.rs
 create mode 100644 tests/ui/vec_init_then_push.rs
 create mode 100644 tests/ui/vec_init_then_push.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index de8da99cdee..572dd8c0c6f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2152,6 +2152,7 @@ Released 2018-09-13
 [`useless_transmute`]: https://rust-lang.github.io/rust-clippy/master/index.html#useless_transmute
 [`useless_vec`]: https://rust-lang.github.io/rust-clippy/master/index.html#useless_vec
 [`vec_box`]: https://rust-lang.github.io/rust-clippy/master/index.html#vec_box
+[`vec_init_then_push`]: https://rust-lang.github.io/rust-clippy/master/index.html#vec_init_then_push
 [`vec_resize_to_zero`]: https://rust-lang.github.io/rust-clippy/master/index.html#vec_resize_to_zero
 [`verbose_bit_mask`]: https://rust-lang.github.io/rust-clippy/master/index.html#verbose_bit_mask
 [`verbose_file_reads`]: https://rust-lang.github.io/rust-clippy/master/index.html#verbose_file_reads
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 35b057d7b6a..6d84026d093 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -341,6 +341,7 @@ mod unwrap_in_result;
 mod use_self;
 mod useless_conversion;
 mod vec;
+mod vec_init_then_push;
 mod vec_resize_to_zero;
 mod verbose_file_reads;
 mod wildcard_dependencies;
@@ -935,6 +936,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &use_self::USE_SELF,
         &useless_conversion::USELESS_CONVERSION,
         &vec::USELESS_VEC,
+        &vec_init_then_push::VEC_INIT_THEN_PUSH,
         &vec_resize_to_zero::VEC_RESIZE_TO_ZERO,
         &verbose_file_reads::VERBOSE_FILE_READS,
         &wildcard_dependencies::WILDCARD_DEPENDENCIES,
@@ -1215,6 +1217,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box strings::StrToString);
     store.register_late_pass(|| box strings::StringToString);
     store.register_late_pass(|| box zero_sized_map_values::ZeroSizedMapValues);
+    store.register_late_pass(|| box vec_init_then_push::VecInitThenPush::default());
 
     store.register_group(true, "clippy::restriction", Some("clippy_restriction"), vec![
         LintId::of(&arithmetic::FLOAT_ARITHMETIC),
@@ -1636,6 +1639,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&unwrap::UNNECESSARY_UNWRAP),
         LintId::of(&useless_conversion::USELESS_CONVERSION),
         LintId::of(&vec::USELESS_VEC),
+        LintId::of(&vec_init_then_push::VEC_INIT_THEN_PUSH),
         LintId::of(&vec_resize_to_zero::VEC_RESIZE_TO_ZERO),
         LintId::of(&write::PRINTLN_EMPTY_STRING),
         LintId::of(&write::PRINT_LITERAL),
@@ -1935,6 +1939,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&types::BOX_VEC),
         LintId::of(&types::REDUNDANT_ALLOCATION),
         LintId::of(&vec::USELESS_VEC),
+        LintId::of(&vec_init_then_push::VEC_INIT_THEN_PUSH),
     ]);
 
     store.register_group(true, "clippy::cargo", Some("clippy_cargo"), vec![
diff --git a/clippy_lints/src/vec_init_then_push.rs b/clippy_lints/src/vec_init_then_push.rs
new file mode 100644
index 00000000000..0aadb453444
--- /dev/null
+++ b/clippy_lints/src/vec_init_then_push.rs
@@ -0,0 +1,186 @@
+use crate::utils::{is_type_diagnostic_item, match_def_path, paths, snippet, span_lint_and_sugg};
+use if_chain::if_chain;
+use rustc_ast::ast::LitKind;
+use rustc_errors::Applicability;
+use rustc_hir::{BindingAnnotation, Block, Expr, ExprKind, Local, PatKind, QPath, Stmt, StmtKind};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_middle::lint::in_external_macro;
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::{symbol::sym, Span, Symbol};
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for calls to `push` immediately after creating a new `Vec`.
+    ///
+    /// **Why is this bad?** The `vec![]` macro is both more performant and easier to read than
+    /// multiple `push` calls.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// let mut v: Vec<u32> = Vec::new();
+    /// v.push(0);
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// let v: Vec<u32> = vec![0];
+    /// ```
+    pub VEC_INIT_THEN_PUSH,
+    perf,
+    "`push` immediately after `Vec` creation"
+}
+
+impl_lint_pass!(VecInitThenPush => [VEC_INIT_THEN_PUSH]);
+
+#[derive(Default)]
+pub struct VecInitThenPush {
+    searcher: Option<VecPushSearcher>,
+}
+
+#[derive(Clone, Copy)]
+enum VecInitKind {
+    New,
+    WithCapacity(u64),
+}
+struct VecPushSearcher {
+    init: VecInitKind,
+    name: Symbol,
+    lhs_is_local: bool,
+    lhs_span: Span,
+    err_span: Span,
+    found: u64,
+}
+impl VecPushSearcher {
+    fn display_err(&self, cx: &LateContext<'_>) {
+        match self.init {
+            _ if self.found == 0 => return,
+            VecInitKind::WithCapacity(x) if x > self.found => return,
+            _ => (),
+        };
+
+        let mut s = if self.lhs_is_local {
+            String::from("let ")
+        } else {
+            String::new()
+        };
+        s.push_str(&snippet(cx, self.lhs_span, ".."));
+        s.push_str(" = vec![..];");
+
+        span_lint_and_sugg(
+            cx,
+            VEC_INIT_THEN_PUSH,
+            self.err_span,
+            "calls to `push` immediately after creation",
+            "consider using the `vec![]` macro",
+            s,
+            Applicability::HasPlaceholders,
+        );
+    }
+}
+
+impl LateLintPass<'_> for VecInitThenPush {
+    fn check_local(&mut self, cx: &LateContext<'tcx>, local: &'tcx Local<'tcx>) {
+        self.searcher = None;
+        if_chain! {
+            if !in_external_macro(cx.sess(), local.span);
+            if let Some(init) = local.init;
+            if let PatKind::Binding(BindingAnnotation::Mutable, _, ident, None) = local.pat.kind;
+            if let Some(init_kind) = get_vec_init_kind(cx, init);
+            then {
+                self.searcher = Some(VecPushSearcher {
+                        init: init_kind,
+                        name: ident.name,
+                        lhs_is_local: true,
+                        lhs_span: local.ty.map(|t| local.pat.span.to(t.span)).unwrap_or(local.pat.span),
+                        err_span: local.span,
+                        found: 0,
+                    });
+            }
+        }
+    }
+
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        if self.searcher.is_none() {
+            if_chain! {
+                if !in_external_macro(cx.sess(), expr.span);
+                if let ExprKind::Assign(left, right, _) = expr.kind;
+                if let ExprKind::Path(QPath::Resolved(_, path)) = left.kind;
+                if let Some(name) = path.segments.get(0);
+                if let Some(init_kind) = get_vec_init_kind(cx, right);
+                then {
+                    self.searcher = Some(VecPushSearcher {
+                        init: init_kind,
+                        name: name.ident.name,
+                        lhs_is_local: false,
+                        lhs_span: left.span,
+                        err_span: expr.span,
+                        found: 0,
+                    });
+                }
+            }
+        }
+    }
+
+    fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) {
+        if let Some(searcher) = self.searcher.take() {
+            if_chain! {
+                if let StmtKind::Expr(expr) | StmtKind::Semi(expr) = stmt.kind;
+                if let ExprKind::MethodCall(path, _, [self_arg, _], _) = expr.kind;
+                if path.ident.name.as_str() == "push";
+                if let ExprKind::Path(QPath::Resolved(_, self_path)) = self_arg.kind;
+                if let [self_name] = self_path.segments;
+                if self_name.ident.name == searcher.name;
+                then {
+                    self.searcher = Some(VecPushSearcher {
+                        found: searcher.found + 1,
+                        err_span: searcher.err_span.to(stmt.span),
+                        .. searcher
+                    });
+                } else {
+                    searcher.display_err(cx);
+                }
+            }
+        }
+    }
+
+    fn check_block_post(&mut self, cx: &LateContext<'tcx>, _: &'tcx Block<'tcx>) {
+        if let Some(searcher) = self.searcher.take() {
+            searcher.display_err(cx);
+        }
+    }
+}
+
+fn get_vec_init_kind<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> Option<VecInitKind> {
+    if let ExprKind::Call(func, args) = expr.kind {
+        match func.kind {
+            ExprKind::Path(QPath::TypeRelative(ty, name))
+                if is_type_diagnostic_item(cx, cx.typeck_results().node_type(ty.hir_id), sym::vec_type) =>
+            {
+                if name.ident.name.as_str() == "new" {
+                    return Some(VecInitKind::New);
+                } else if name.ident.name.as_str() == "with_capacity" {
+                    return args.get(0).and_then(|arg| {
+                        if_chain! {
+                            if let ExprKind::Lit(lit) = &arg.kind;
+                            if let LitKind::Int(num, _) = lit.node;
+                            then {
+                                Some(VecInitKind::WithCapacity(num as u64))
+                            } else {
+                                None
+                            }
+                        }
+                    });
+                }
+            }
+            ExprKind::Path(QPath::Resolved(_, path))
+                if match_def_path(cx, path.res.opt_def_id()?, &paths::DEFAULT_TRAIT_METHOD)
+                    && is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(expr), sym::vec_type) =>
+            {
+                return Some(VecInitKind::New);
+            }
+            _ => (),
+        }
+    }
+    None
+}
diff --git a/tests/ui/vec_init_then_push.rs b/tests/ui/vec_init_then_push.rs
new file mode 100644
index 00000000000..642ce504009
--- /dev/null
+++ b/tests/ui/vec_init_then_push.rs
@@ -0,0 +1,21 @@
+#![allow(unused_variables)]
+#![warn(clippy::vec_init_then_push)]
+
+fn main() {
+    let mut def_err: Vec<u32> = Default::default();
+    def_err.push(0);
+
+    let mut new_err = Vec::<u32>::new();
+    new_err.push(1);
+
+    let mut cap_err = Vec::with_capacity(2);
+    cap_err.push(0);
+    cap_err.push(1);
+    cap_err.push(2);
+
+    let mut cap_ok = Vec::with_capacity(10);
+    cap_ok.push(0);
+
+    new_err = Vec::new();
+    new_err.push(0);
+}
diff --git a/tests/ui/vec_init_then_push.stderr b/tests/ui/vec_init_then_push.stderr
new file mode 100644
index 00000000000..819ed47d099
--- /dev/null
+++ b/tests/ui/vec_init_then_push.stderr
@@ -0,0 +1,34 @@
+error: calls to `push` immediately after creation
+  --> $DIR/vec_init_then_push.rs:5:5
+   |
+LL | /     let mut def_err: Vec<u32> = Default::default();
+LL | |     def_err.push(0);
+   | |____________________^ help: consider using the `vec![]` macro: `let mut def_err: Vec<u32> = vec![..];`
+   |
+   = note: `-D clippy::vec-init-then-push` implied by `-D warnings`
+
+error: calls to `push` immediately after creation
+  --> $DIR/vec_init_then_push.rs:8:5
+   |
+LL | /     let mut new_err = Vec::<u32>::new();
+LL | |     new_err.push(1);
+   | |____________________^ help: consider using the `vec![]` macro: `let mut new_err = vec![..];`
+
+error: calls to `push` immediately after creation
+  --> $DIR/vec_init_then_push.rs:11:5
+   |
+LL | /     let mut cap_err = Vec::with_capacity(2);
+LL | |     cap_err.push(0);
+LL | |     cap_err.push(1);
+LL | |     cap_err.push(2);
+   | |____________________^ help: consider using the `vec![]` macro: `let mut cap_err = vec![..];`
+
+error: calls to `push` immediately after creation
+  --> $DIR/vec_init_then_push.rs:19:5
+   |
+LL | /     new_err = Vec::new();
+LL | |     new_err.push(0);
+   | |____________________^ help: consider using the `vec![]` macro: `new_err = vec![..];`
+
+error: aborting due to 4 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From d37ee6ffa0642a0812cbda4592be6650aa4eda08 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sat, 2 Jan 2021 14:31:21 -0500
Subject: Fix lint errors

---
 clippy_lints/src/vec_init_then_push.rs | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/vec_init_then_push.rs b/clippy_lints/src/vec_init_then_push.rs
index 0aadb453444..e2cbcc9108c 100644
--- a/clippy_lints/src/vec_init_then_push.rs
+++ b/clippy_lints/src/vec_init_then_push.rs
@@ -7,6 +7,7 @@ use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::{symbol::sym, Span, Symbol};
+use std::convert::TryInto;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for calls to `push` immediately after creating a new `Vec`.
@@ -92,7 +93,7 @@ impl LateLintPass<'_> for VecInitThenPush {
                         init: init_kind,
                         name: ident.name,
                         lhs_is_local: true,
-                        lhs_span: local.ty.map(|t| local.pat.span.to(t.span)).unwrap_or(local.pat.span),
+                        lhs_span: local.ty.map_or(local.pat.span, |t| local.pat.span.to(t.span)),
                         err_span: local.span,
                         found: 0,
                     });
@@ -165,7 +166,7 @@ fn get_vec_init_kind<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> Op
                             if let ExprKind::Lit(lit) = &arg.kind;
                             if let LitKind::Int(num, _) = lit.node;
                             then {
-                                Some(VecInitKind::WithCapacity(num as u64))
+                                Some(VecInitKind::WithCapacity(num.try_into().ok()?))
                             } else {
                                 None
                             }
-- 
cgit 1.4.1-3-g733a5


From 7b5f54954aa18991edd6e22edfd9af6bc9bae24b Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sun, 3 Jan 2021 14:04:05 -0500
Subject: Fix docs: use type inference

---
 clippy_lints/src/vec_init_then_push.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/vec_init_then_push.rs b/clippy_lints/src/vec_init_then_push.rs
index e2cbcc9108c..6249d7e867b 100644
--- a/clippy_lints/src/vec_init_then_push.rs
+++ b/clippy_lints/src/vec_init_then_push.rs
@@ -20,12 +20,12 @@ declare_clippy_lint! {
     /// **Example:**
     ///
     /// ```rust
-    /// let mut v: Vec<u32> = Vec::new();
+    /// let mut v = Vec::new();
     /// v.push(0);
     /// ```
     /// Use instead:
     /// ```rust
-    /// let v: Vec<u32> = vec![0];
+    /// let v = vec![0];
     /// ```
     pub VEC_INIT_THEN_PUSH,
     perf,
-- 
cgit 1.4.1-3-g733a5


From 39f39d5405b7e55eb08cb927e78686a5ce7377d4 Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Fri, 1 Jan 2021 17:43:24 +0100
Subject: match_like_matches_macro: strip refs in suggestion

fixes #6503

changelog: match_like_matches_macro: strip refs in suggestion (#6503)
---
 clippy_lints/src/matches.rs                   | 10 +++-
 tests/ui/match_expr_like_matches_macro.fixed  | 47 +++++++++++++++
 tests/ui/match_expr_like_matches_macro.rs     | 62 +++++++++++++++++++
 tests/ui/match_expr_like_matches_macro.stderr | 85 ++++++++++++++++++++++++++-
 4 files changed, 202 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index 04b35835c6b..6372cb86616 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -1185,6 +1185,14 @@ fn find_matches_sugg(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>], expr
             } else {
                 pat
             };
+
+            // strip potential borrows (#6503), but only if the type is a reference
+            let mut ex_new = ex;
+            if let ExprKind::AddrOf(BorrowKind::Ref, .., ex_inner) = ex.kind {
+                if let ty::Ref(..) = cx.typeck_results().expr_ty(&ex_inner).kind() {
+                    ex_new = ex_inner;
+                }
+            };
             span_lint_and_sugg(
                 cx,
                 MATCH_LIKE_MATCHES_MACRO,
@@ -1194,7 +1202,7 @@ fn find_matches_sugg(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>], expr
                 format!(
                     "{}matches!({}, {})",
                     if b0 { "" } else { "!" },
-                    snippet_with_applicability(cx, ex.span, "..", &mut applicability),
+                    snippet_with_applicability(cx, ex_new.span, "..", &mut applicability),
                     pat_and_guard,
                 ),
                 applicability,
diff --git a/tests/ui/match_expr_like_matches_macro.fixed b/tests/ui/match_expr_like_matches_macro.fixed
index 84981a52597..319299862a7 100644
--- a/tests/ui/match_expr_like_matches_macro.fixed
+++ b/tests/ui/match_expr_like_matches_macro.fixed
@@ -99,4 +99,51 @@ fn main() {
             _ => false,
         };
     }
+
+    {
+        // should print "z" in suggestion (#6503)
+        let z = &Some(3);
+        let _z = matches!(z, Some(3));
+    }
+
+    {
+        // this could also print "z" in suggestion..?
+        let z = Some(3);
+        let _z = matches!(&z, Some(3));
+    }
+
+    {
+        enum AnEnum {
+            X,
+            Y,
+        }
+
+        fn foo(_x: AnEnum) {}
+
+        fn main() {
+            let z = AnEnum::X;
+            // we can't remove the reference here!
+            let _ = matches!(&z, AnEnum::X);
+            foo(z);
+        }
+    }
+
+    {
+        struct S(i32);
+
+        fn fun(_val: Option<S>) {}
+        let val = Some(S(42));
+        // we need the reference here because later val is consumed by fun()
+        let _res = matches!(&val, &Some(ref _a));
+        fun(val);
+    }
+
+    {
+        struct S(i32);
+
+        fn fun(_val: Option<S>) {}
+        let val = Some(S(42));
+        let _res = matches!(&val, &Some(ref _a));
+        fun(val);
+    }
 }
diff --git a/tests/ui/match_expr_like_matches_macro.rs b/tests/ui/match_expr_like_matches_macro.rs
index 94c7c3cadac..2ef6cf42387 100644
--- a/tests/ui/match_expr_like_matches_macro.rs
+++ b/tests/ui/match_expr_like_matches_macro.rs
@@ -119,4 +119,66 @@ fn main() {
             _ => false,
         };
     }
+
+    {
+        // should print "z" in suggestion (#6503)
+        let z = &Some(3);
+        let _z = match &z {
+            Some(3) => true,
+            _ => false,
+        };
+    }
+
+    {
+        // this could also print "z" in suggestion..?
+        let z = Some(3);
+        let _z = match &z {
+            Some(3) => true,
+            _ => false,
+        };
+    }
+
+    {
+        enum AnEnum {
+            X,
+            Y,
+        }
+
+        fn foo(_x: AnEnum) {}
+
+        fn main() {
+            let z = AnEnum::X;
+            // we can't remove the reference here!
+            let _ = match &z {
+                AnEnum::X => true,
+                _ => false,
+            };
+            foo(z);
+        }
+    }
+
+    {
+        struct S(i32);
+
+        fn fun(_val: Option<S>) {}
+        let val = Some(S(42));
+        // we need the reference here because later val is consumed by fun()
+        let _res = match &val {
+            &Some(ref _a) => true,
+            _ => false,
+        };
+        fun(val);
+    }
+
+    {
+        struct S(i32);
+
+        fn fun(_val: Option<S>) {}
+        let val = Some(S(42));
+        let _res = match &val {
+            &Some(ref _a) => true,
+            _ => false,
+        };
+        fun(val);
+    }
 }
diff --git a/tests/ui/match_expr_like_matches_macro.stderr b/tests/ui/match_expr_like_matches_macro.stderr
index c52e41c7889..f27b4e9cb20 100644
--- a/tests/ui/match_expr_like_matches_macro.stderr
+++ b/tests/ui/match_expr_like_matches_macro.stderr
@@ -70,5 +70,88 @@ LL | |             _ => true,
 LL | |         };
    | |_________^ help: try this: `!matches!(x, E::B(_) | E::C)`
 
-error: aborting due to 7 previous errors
+error: match expression looks like `matches!` macro
+  --> $DIR/match_expr_like_matches_macro.rs:126:18
+   |
+LL |           let _z = match &z {
+   |  __________________^
+LL | |             Some(3) => true,
+LL | |             _ => false,
+LL | |         };
+   | |_________^ help: try this: `matches!(z, Some(3))`
+
+error: match expression looks like `matches!` macro
+  --> $DIR/match_expr_like_matches_macro.rs:135:18
+   |
+LL |           let _z = match &z {
+   |  __________________^
+LL | |             Some(3) => true,
+LL | |             _ => false,
+LL | |         };
+   | |_________^ help: try this: `matches!(&z, Some(3))`
+
+error: match expression looks like `matches!` macro
+  --> $DIR/match_expr_like_matches_macro.rs:152:21
+   |
+LL |               let _ = match &z {
+   |  _____________________^
+LL | |                 AnEnum::X => true,
+LL | |                 _ => false,
+LL | |             };
+   | |_____________^ help: try this: `matches!(&z, AnEnum::X)`
+
+error: match expression looks like `matches!` macro
+  --> $DIR/match_expr_like_matches_macro.rs:166:20
+   |
+LL |           let _res = match &val {
+   |  ____________________^
+LL | |             &Some(ref _a) => true,
+LL | |             _ => false,
+LL | |         };
+   | |_________^ help: try this: `matches!(&val, &Some(ref _a))`
+
+error: you don't need to add `&` to both the expression and the patterns
+  --> $DIR/match_expr_like_matches_macro.rs:166:20
+   |
+LL |           let _res = match &val {
+   |  ____________________^
+LL | |             &Some(ref _a) => true,
+LL | |             _ => false,
+LL | |         };
+   | |_________^
+   |
+   = note: `-D clippy::match-ref-pats` implied by `-D warnings`
+help: try
+   |
+LL |         let _res = match val {
+LL |             Some(ref _a) => true,
+   |
+
+error: match expression looks like `matches!` macro
+  --> $DIR/match_expr_like_matches_macro.rs:178:20
+   |
+LL |           let _res = match &val {
+   |  ____________________^
+LL | |             &Some(ref _a) => true,
+LL | |             _ => false,
+LL | |         };
+   | |_________^ help: try this: `matches!(&val, &Some(ref _a))`
+
+error: you don't need to add `&` to both the expression and the patterns
+  --> $DIR/match_expr_like_matches_macro.rs:178:20
+   |
+LL |           let _res = match &val {
+   |  ____________________^
+LL | |             &Some(ref _a) => true,
+LL | |             _ => false,
+LL | |         };
+   | |_________^
+   |
+help: try
+   |
+LL |         let _res = match val {
+LL |             Some(ref _a) => true,
+   |
+
+error: aborting due to 14 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 6dcec6ae863930b7056a68744759d2bfb3481f92 Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Mon, 4 Jan 2021 08:25:38 +0100
Subject: collapsible_if: split collapsible_else_if into its own lint so we can
 enable/disable it particularly

This splits up clippy::collapsible_if into collapsible_if for
if x {
  if y { }
}
=>
if x && y { }

and collapsible_else_if for

if x {
} else {
 if y { }
}

=>
if x {

} else if y {

}

so that we can lint for only the latter but not the first if we desire.

changelog: collapsible_if: split up linting for if x {} else { if y {} } into collapsible_else_if lint
---
 CHANGELOG.md                        |  1 +
 clippy_lints/src/collapsible_if.rs  | 44 +++++++++++++++++++++++++------------
 clippy_lints/src/lib.rs             |  3 +++
 tests/ui/collapsible_else_if.fixed  |  2 ++
 tests/ui/collapsible_else_if.rs     |  2 ++
 tests/ui/collapsible_else_if.stderr | 16 +++++++-------
 tests/ui/if_same_then_else2.rs      |  1 +
 tests/ui/if_same_then_else2.stderr  | 24 ++++++++++----------
 8 files changed, 59 insertions(+), 34 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index ec424068a54..b643627c2e9 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1896,6 +1896,7 @@ Released 2018-09-13
 [`cmp_null`]: https://rust-lang.github.io/rust-clippy/master/index.html#cmp_null
 [`cmp_owned`]: https://rust-lang.github.io/rust-clippy/master/index.html#cmp_owned
 [`cognitive_complexity`]: https://rust-lang.github.io/rust-clippy/master/index.html#cognitive_complexity
+[`collapsible_else_if`]: https://rust-lang.github.io/rust-clippy/master/index.html#collapsible_else_if
 [`collapsible_if`]: https://rust-lang.github.io/rust-clippy/master/index.html#collapsible_if
 [`collapsible_match`]: https://rust-lang.github.io/rust-clippy/master/index.html#collapsible_match
 [`comparison_chain`]: https://rust-lang.github.io/rust-clippy/master/index.html#comparison_chain
diff --git a/clippy_lints/src/collapsible_if.rs b/clippy_lints/src/collapsible_if.rs
index 42bff564de0..93ccc76d0c9 100644
--- a/clippy_lints/src/collapsible_if.rs
+++ b/clippy_lints/src/collapsible_if.rs
@@ -23,9 +23,7 @@ use rustc_errors::Applicability;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for nested `if` statements which can be collapsed
-    /// by `&&`-combining their conditions and for `else { if ... }` expressions
-    /// that
-    /// can be collapsed to `else if ...`.
+    /// by `&&`-combining their conditions.
     ///
     /// **Why is this bad?** Each `if`-statement adds one level of nesting, which
     /// makes code look more complex than it really is.
@@ -40,7 +38,31 @@ declare_clippy_lint! {
     ///     }
     /// }
     ///
-    /// // or
+    /// ```
+    ///
+    /// Should be written:
+    ///
+    /// ```rust.ignore
+    /// if x && y {
+    ///     …
+    /// }
+    /// ```
+    pub COLLAPSIBLE_IF,
+    style,
+    "nested `if`s that can be collapsed (e.g., `if x { if y { ... } }`"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for collapsible `else { if ... }` expressions
+    /// that can be collapsed to `else if ...`.
+    ///
+    /// **Why is this bad?** Each `if`-statement adds one level of nesting, which
+    /// makes code look more complex than it really is.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// ```rust,ignore
     ///
     /// if x {
     ///     …
@@ -54,24 +76,18 @@ declare_clippy_lint! {
     /// Should be written:
     ///
     /// ```rust.ignore
-    /// if x && y {
-    ///     …
-    /// }
-    ///
-    /// // or
-    ///
     /// if x {
     ///     …
     /// } else if y {
     ///     …
     /// }
     /// ```
-    pub COLLAPSIBLE_IF,
+    pub COLLAPSIBLE_ELSE_IF,
     style,
-    "`if`s that can be collapsed (e.g., `if x { if y { ... } }` and `else { if x { ... } }`)"
+    "nested `else`-`if` expressions that can be collapsed (e.g., `else { if x { ... } }`)"
 }
 
-declare_lint_pass!(CollapsibleIf => [COLLAPSIBLE_IF]);
+declare_lint_pass!(CollapsibleIf => [COLLAPSIBLE_IF, COLLAPSIBLE_ELSE_IF]);
 
 impl EarlyLintPass for CollapsibleIf {
     fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &ast::Expr) {
@@ -112,7 +128,7 @@ fn check_collapsible_maybe_if_let(cx: &EarlyContext<'_>, else_: &ast::Expr) {
             let mut applicability = Applicability::MachineApplicable;
             span_lint_and_sugg(
                 cx,
-                COLLAPSIBLE_IF,
+                COLLAPSIBLE_ELSE_IF,
                 block.span,
                 "this `else { if .. }` block can be collapsed",
                 "collapse nested if block",
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 35b057d7b6a..4f41b6c77e2 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -556,6 +556,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &cargo_common_metadata::CARGO_COMMON_METADATA,
         &checked_conversions::CHECKED_CONVERSIONS,
         &cognitive_complexity::COGNITIVE_COMPLEXITY,
+        &collapsible_if::COLLAPSIBLE_ELSE_IF,
         &collapsible_if::COLLAPSIBLE_IF,
         &collapsible_match::COLLAPSIBLE_MATCH,
         &comparison_chain::COMPARISON_CHAIN,
@@ -1384,6 +1385,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&booleans::LOGIC_BUG),
         LintId::of(&booleans::NONMINIMAL_BOOL),
         LintId::of(&bytecount::NAIVE_BYTECOUNT),
+        LintId::of(&collapsible_if::COLLAPSIBLE_ELSE_IF),
         LintId::of(&collapsible_if::COLLAPSIBLE_IF),
         LintId::of(&collapsible_match::COLLAPSIBLE_MATCH),
         LintId::of(&comparison_chain::COMPARISON_CHAIN),
@@ -1653,6 +1655,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&attrs::UNKNOWN_CLIPPY_LINTS),
         LintId::of(&blacklisted_name::BLACKLISTED_NAME),
         LintId::of(&blocks_in_if_conditions::BLOCKS_IN_IF_CONDITIONS),
+        LintId::of(&collapsible_if::COLLAPSIBLE_ELSE_IF),
         LintId::of(&collapsible_if::COLLAPSIBLE_IF),
         LintId::of(&collapsible_match::COLLAPSIBLE_MATCH),
         LintId::of(&comparison_chain::COMPARISON_CHAIN),
diff --git a/tests/ui/collapsible_else_if.fixed b/tests/ui/collapsible_else_if.fixed
index ce2a1c28c8a..fa4bc30e933 100644
--- a/tests/ui/collapsible_else_if.fixed
+++ b/tests/ui/collapsible_else_if.fixed
@@ -3,6 +3,8 @@
 
 #[rustfmt::skip]
 #[warn(clippy::collapsible_if)]
+#[warn(clippy::collapsible_else_if)]
+
 fn main() {
     let x = "hello";
     let y = "world";
diff --git a/tests/ui/collapsible_else_if.rs b/tests/ui/collapsible_else_if.rs
index 99c40b8d38e..bf6c1d1f894 100644
--- a/tests/ui/collapsible_else_if.rs
+++ b/tests/ui/collapsible_else_if.rs
@@ -3,6 +3,8 @@
 
 #[rustfmt::skip]
 #[warn(clippy::collapsible_if)]
+#[warn(clippy::collapsible_else_if)]
+
 fn main() {
     let x = "hello";
     let y = "world";
diff --git a/tests/ui/collapsible_else_if.stderr b/tests/ui/collapsible_else_if.stderr
index 3d1c458879e..ee3e11ae565 100644
--- a/tests/ui/collapsible_else_if.stderr
+++ b/tests/ui/collapsible_else_if.stderr
@@ -1,5 +1,5 @@
 error: this `else { if .. }` block can be collapsed
-  --> $DIR/collapsible_else_if.rs:12:12
+  --> $DIR/collapsible_else_if.rs:14:12
    |
 LL |       } else {
    |  ____________^
@@ -9,7 +9,7 @@ LL | |         }
 LL | |     }
    | |_____^
    |
-   = note: `-D clippy::collapsible-if` implied by `-D warnings`
+   = note: `-D clippy::collapsible-else-if` implied by `-D warnings`
 help: collapse nested if block
    |
 LL |     } else if y == "world" {
@@ -18,7 +18,7 @@ LL |     }
    |
 
 error: this `else { if .. }` block can be collapsed
-  --> $DIR/collapsible_else_if.rs:20:12
+  --> $DIR/collapsible_else_if.rs:22:12
    |
 LL |       } else {
    |  ____________^
@@ -36,7 +36,7 @@ LL |     }
    |
 
 error: this `else { if .. }` block can be collapsed
-  --> $DIR/collapsible_else_if.rs:28:12
+  --> $DIR/collapsible_else_if.rs:30:12
    |
 LL |       } else {
    |  ____________^
@@ -59,7 +59,7 @@ LL |     }
    |
 
 error: this `else { if .. }` block can be collapsed
-  --> $DIR/collapsible_else_if.rs:39:12
+  --> $DIR/collapsible_else_if.rs:41:12
    |
 LL |       } else {
    |  ____________^
@@ -82,7 +82,7 @@ LL |     }
    |
 
 error: this `else { if .. }` block can be collapsed
-  --> $DIR/collapsible_else_if.rs:50:12
+  --> $DIR/collapsible_else_if.rs:52:12
    |
 LL |       } else {
    |  ____________^
@@ -105,7 +105,7 @@ LL |     }
    |
 
 error: this `else { if .. }` block can be collapsed
-  --> $DIR/collapsible_else_if.rs:61:12
+  --> $DIR/collapsible_else_if.rs:63:12
    |
 LL |       } else {
    |  ____________^
@@ -128,7 +128,7 @@ LL |     }
    |
 
 error: this `else { if .. }` block can be collapsed
-  --> $DIR/collapsible_else_if.rs:72:12
+  --> $DIR/collapsible_else_if.rs:74:12
    |
 LL |       } else {
    |  ____________^
diff --git a/tests/ui/if_same_then_else2.rs b/tests/ui/if_same_then_else2.rs
index 8d54f75b5d1..e83ce47e563 100644
--- a/tests/ui/if_same_then_else2.rs
+++ b/tests/ui/if_same_then_else2.rs
@@ -1,6 +1,7 @@
 #![warn(clippy::if_same_then_else)]
 #![allow(
     clippy::blacklisted_name,
+    clippy::collapsible_else_if,
     clippy::collapsible_if,
     clippy::ifs_same_cond,
     clippy::needless_return,
diff --git a/tests/ui/if_same_then_else2.stderr b/tests/ui/if_same_then_else2.stderr
index da2be6c8aa5..f98e30fa376 100644
--- a/tests/ui/if_same_then_else2.stderr
+++ b/tests/ui/if_same_then_else2.stderr
@@ -1,5 +1,5 @@
 error: this `if` has identical blocks
-  --> $DIR/if_same_then_else2.rs:20:12
+  --> $DIR/if_same_then_else2.rs:21:12
    |
 LL |       } else {
    |  ____________^
@@ -13,7 +13,7 @@ LL | |     }
    |
    = note: `-D clippy::if-same-then-else` implied by `-D warnings`
 note: same as this
-  --> $DIR/if_same_then_else2.rs:11:13
+  --> $DIR/if_same_then_else2.rs:12:13
    |
 LL |       if true {
    |  _____________^
@@ -26,7 +26,7 @@ LL | |     } else {
    | |_____^
 
 error: this `if` has identical blocks
-  --> $DIR/if_same_then_else2.rs:34:12
+  --> $DIR/if_same_then_else2.rs:35:12
    |
 LL |       } else {
    |  ____________^
@@ -36,7 +36,7 @@ LL | |     }
    | |_____^
    |
 note: same as this
-  --> $DIR/if_same_then_else2.rs:32:13
+  --> $DIR/if_same_then_else2.rs:33:13
    |
 LL |       if true {
    |  _____________^
@@ -45,7 +45,7 @@ LL | |     } else {
    | |_____^
 
 error: this `if` has identical blocks
-  --> $DIR/if_same_then_else2.rs:41:12
+  --> $DIR/if_same_then_else2.rs:42:12
    |
 LL |       } else {
    |  ____________^
@@ -55,7 +55,7 @@ LL | |     }
    | |_____^
    |
 note: same as this
-  --> $DIR/if_same_then_else2.rs:39:13
+  --> $DIR/if_same_then_else2.rs:40:13
    |
 LL |       if true {
    |  _____________^
@@ -64,7 +64,7 @@ LL | |     } else {
    | |_____^
 
 error: this `if` has identical blocks
-  --> $DIR/if_same_then_else2.rs:91:12
+  --> $DIR/if_same_then_else2.rs:92:12
    |
 LL |       } else {
    |  ____________^
@@ -74,7 +74,7 @@ LL | |     };
    | |_____^
    |
 note: same as this
-  --> $DIR/if_same_then_else2.rs:89:21
+  --> $DIR/if_same_then_else2.rs:90:21
    |
 LL |       let _ = if true {
    |  _____________________^
@@ -83,7 +83,7 @@ LL | |     } else {
    | |_____^
 
 error: this `if` has identical blocks
-  --> $DIR/if_same_then_else2.rs:98:12
+  --> $DIR/if_same_then_else2.rs:99:12
    |
 LL |       } else {
    |  ____________^
@@ -93,7 +93,7 @@ LL | |     }
    | |_____^
    |
 note: same as this
-  --> $DIR/if_same_then_else2.rs:96:13
+  --> $DIR/if_same_then_else2.rs:97:13
    |
 LL |       if true {
    |  _____________^
@@ -102,7 +102,7 @@ LL | |     } else {
    | |_____^
 
 error: this `if` has identical blocks
-  --> $DIR/if_same_then_else2.rs:123:12
+  --> $DIR/if_same_then_else2.rs:124:12
    |
 LL |       } else {
    |  ____________^
@@ -112,7 +112,7 @@ LL | |     }
    | |_____^
    |
 note: same as this
-  --> $DIR/if_same_then_else2.rs:120:20
+  --> $DIR/if_same_then_else2.rs:121:20
    |
 LL |       } else if true {
    |  ____________________^
-- 
cgit 1.4.1-3-g733a5


From ba87acb44090412f5ace0a5ca655e8298d82b874 Mon Sep 17 00:00:00 2001
From: Benjamin Sparks <benjamin.sparks@protonmail.com>
Date: Sat, 26 Dec 2020 18:02:46 +0100
Subject: Implemented needless question mark lint

---
 CHANGELOG.md                               |   1 +
 clippy_lints/src/lib.rs                    |   5 +
 clippy_lints/src/needless_question_mark.rs | 232 +++++++++++++++++++++++++++++
 tests/ui/needless_question_mark.fixed      | 163 ++++++++++++++++++++
 tests/ui/needless_question_mark.rs         | 163 ++++++++++++++++++++
 tests/ui/needless_question_mark.stderr     |  88 +++++++++++
 tests/ui/try_err.fixed                     |   2 +-
 tests/ui/try_err.rs                        |   2 +-
 tests/ui/unit_arg.rs                       |   3 +-
 tests/ui/unit_arg.stderr                   |  20 +--
 10 files changed, 666 insertions(+), 13 deletions(-)
 create mode 100644 clippy_lints/src/needless_question_mark.rs
 create mode 100644 tests/ui/needless_question_mark.fixed
 create mode 100644 tests/ui/needless_question_mark.rs
 create mode 100644 tests/ui/needless_question_mark.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index de8da99cdee..41a92dd4c41 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1973,6 +1973,7 @@ Released 2018-09-13
 [`needless_doctest_main`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_doctest_main
 [`needless_lifetimes`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_lifetimes
 [`needless_pass_by_value`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_pass_by_value
+[`needless_question_mark`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_question_mark
 [`needless_range_loop`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_range_loop
 [`needless_return`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_return
 [`needless_update`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_update
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 35b057d7b6a..0299f8e12fa 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -271,6 +271,7 @@ mod needless_borrow;
 mod needless_borrowed_ref;
 mod needless_continue;
 mod needless_pass_by_value;
+mod needless_question_mark;
 mod needless_update;
 mod neg_cmp_op_on_partial_ord;
 mod neg_multiply;
@@ -799,6 +800,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &needless_borrowed_ref::NEEDLESS_BORROWED_REFERENCE,
         &needless_continue::NEEDLESS_CONTINUE,
         &needless_pass_by_value::NEEDLESS_PASS_BY_VALUE,
+        &needless_question_mark::NEEDLESS_QUESTION_MARK,
         &needless_update::NEEDLESS_UPDATE,
         &neg_cmp_op_on_partial_ord::NEG_CMP_OP_ON_PARTIAL_ORD,
         &neg_multiply::NEG_MULTIPLY,
@@ -1019,6 +1021,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(move || box from_over_into::FromOverInto::new(msrv));
     store.register_late_pass(move || box use_self::UseSelf::new(msrv));
     store.register_late_pass(move || box missing_const_for_fn::MissingConstForFn::new(msrv));
+    store.register_late_pass(move || box needless_question_mark::NeedlessQuestionMark::new(msrv));
 
     store.register_late_pass(|| box size_of_in_element_count::SizeOfInElementCount);
     store.register_late_pass(|| box map_clone::MapClone);
@@ -1545,6 +1548,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&needless_bool::BOOL_COMPARISON),
         LintId::of(&needless_bool::NEEDLESS_BOOL),
         LintId::of(&needless_borrowed_ref::NEEDLESS_BORROWED_REFERENCE),
+        LintId::of(&needless_question_mark::NEEDLESS_QUESTION_MARK),
         LintId::of(&needless_update::NEEDLESS_UPDATE),
         LintId::of(&neg_cmp_op_on_partial_ord::NEG_CMP_OP_ON_PARTIAL_ORD),
         LintId::of(&neg_multiply::NEG_MULTIPLY),
@@ -1803,6 +1807,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&needless_bool::BOOL_COMPARISON),
         LintId::of(&needless_bool::NEEDLESS_BOOL),
         LintId::of(&needless_borrowed_ref::NEEDLESS_BORROWED_REFERENCE),
+        LintId::of(&needless_question_mark::NEEDLESS_QUESTION_MARK),
         LintId::of(&needless_update::NEEDLESS_UPDATE),
         LintId::of(&neg_cmp_op_on_partial_ord::NEG_CMP_OP_ON_PARTIAL_ORD),
         LintId::of(&no_effect::NO_EFFECT),
diff --git a/clippy_lints/src/needless_question_mark.rs b/clippy_lints/src/needless_question_mark.rs
new file mode 100644
index 00000000000..783e6b716d4
--- /dev/null
+++ b/clippy_lints/src/needless_question_mark.rs
@@ -0,0 +1,232 @@
+use rustc_errors::Applicability;
+use rustc_hir::def::{CtorKind, CtorOf, DefKind, Res};
+use rustc_hir::{Body, Expr, ExprKind, LangItem, MatchSource, QPath};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_middle::ty::DefIdTree;
+use rustc_semver::RustcVersion;
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::sym;
+
+use crate::utils;
+use if_chain::if_chain;
+
+declare_clippy_lint! {
+    /// **What it does:**
+    /// Suggests alternatives for useless applications of `?` in terminating expressions
+    ///
+    /// **Why is this bad?** There's no reason to use ? to short-circuit when execution of the body will end there anyway.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// struct TO {
+    ///     magic: Option<usize>,
+    /// }
+    ///
+    /// fn f(to: TO) -> Option<usize> {
+    ///     Some(to.magic?)
+    /// }
+    ///
+    /// struct TR {
+    ///     magic: Result<usize, bool>,
+    /// }
+    ///
+    /// fn g(tr: Result<TR, bool>) -> Result<usize, bool> {
+    ///     tr.and_then(|t| Ok(t.magic?))
+    /// }
+    ///
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// struct TO {
+    ///     magic: Option<usize>,
+    /// }
+    ///
+    /// fn f(to: TO) -> Option<usize> {
+    ///    to.magic
+    /// }
+    ///
+    /// struct TR {
+    ///     magic: Result<usize, bool>,
+    /// }
+    ///
+    /// fn g(tr: Result<TR, bool>) -> Result<usize, bool> {
+    ///     tr.and_then(|t| t.magic)
+    /// }
+    /// ```
+    pub NEEDLESS_QUESTION_MARK,
+    complexity,
+    "Suggest value.inner_option instead of Some(value.inner_option?). The same goes for Result<T, E>."
+}
+
+const NEEDLESS_QUESTION_MARK_RESULT_MSRV: RustcVersion = RustcVersion::new(1, 13, 0);
+const NEEDLESS_QUESTION_MARK_OPTION_MSRV: RustcVersion = RustcVersion::new(1, 22, 0);
+
+pub struct NeedlessQuestionMark {
+    msrv: Option<RustcVersion>,
+}
+
+impl NeedlessQuestionMark {
+    #[must_use]
+    pub fn new(msrv: Option<RustcVersion>) -> Self {
+        Self { msrv }
+    }
+}
+
+impl_lint_pass!(NeedlessQuestionMark => [NEEDLESS_QUESTION_MARK]);
+
+#[derive(Debug)]
+enum SomeOkCall<'a> {
+    SomeCall(&'a Expr<'a>, &'a Expr<'a>),
+    OkCall(&'a Expr<'a>, &'a Expr<'a>),
+}
+
+impl LateLintPass<'_> for NeedlessQuestionMark {
+    /*
+     * The question mark operator is compatible with both Result<T, E> and Option<T>,
+     * from Rust 1.13 and 1.22 respectively.
+     */
+
+    /*
+     * What do we match:
+     * Expressions that look like this:
+     * Some(option?), Ok(result?)
+     *
+     * Where do we match:
+     *      Last expression of a body
+     *      Return statement
+     *      A body's value (single line closure)
+     *
+     * What do we not match:
+     *      Implicit calls to `from(..)` on the error value
+     */
+
+    fn check_expr(&mut self, cx: &LateContext<'_>, expr: &'_ Expr<'_>) {
+        let e = match &expr.kind {
+            ExprKind::Ret(Some(e)) => e,
+            _ => return,
+        };
+
+        if let Some(ok_some_call) = is_some_or_ok_call(self, cx, e) {
+            emit_lint(cx, &ok_some_call);
+        }
+    }
+
+    fn check_body(&mut self, cx: &LateContext<'_>, body: &'_ Body<'_>) {
+        // Function / Closure block
+        let expr_opt = if let ExprKind::Block(block, _) = &body.value.kind {
+            block.expr
+        } else {
+            // Single line closure
+            Some(&body.value)
+        };
+
+        if_chain! {
+            if let Some(expr) = expr_opt;
+            if let Some(ok_some_call) = is_some_or_ok_call(self, cx, expr);
+            then {
+                emit_lint(cx, &ok_some_call);
+            }
+        };
+    }
+
+    extract_msrv_attr!(LateContext);
+}
+
+fn emit_lint(cx: &LateContext<'_>, expr: &SomeOkCall<'_>) {
+    let (entire_expr, inner_expr) = match expr {
+        SomeOkCall::OkCall(outer, inner) | SomeOkCall::SomeCall(outer, inner) => (outer, inner),
+    };
+
+    utils::span_lint_and_sugg(
+        cx,
+        NEEDLESS_QUESTION_MARK,
+        entire_expr.span,
+        "Question mark operator is useless here",
+        "try",
+        format!("{}", utils::snippet(cx, inner_expr.span, r#""...""#)),
+        Applicability::MachineApplicable,
+    );
+}
+
+fn is_some_or_ok_call<'a>(
+    nqml: &NeedlessQuestionMark,
+    cx: &'a LateContext<'_>,
+    expr: &'a Expr<'_>,
+) -> Option<SomeOkCall<'a>> {
+    if_chain! {
+        // Check outer expression matches CALL_IDENT(ARGUMENT) format
+        if let ExprKind::Call(path, args) = &expr.kind;
+        if let ExprKind::Path(QPath::Resolved(None, path)) = &path.kind;
+        if is_some_ctor(cx, path.res) || is_ok_ctor(cx, path.res);
+
+        // Extract inner expression from ARGUMENT
+        if let ExprKind::Match(inner_expr_with_q, _, MatchSource::TryDesugar) = &args[0].kind;
+        if let ExprKind::Call(called, args) = &inner_expr_with_q.kind;
+        if args.len() == 1;
+
+        if let ExprKind::Path(QPath::LangItem(LangItem::TryIntoResult, _)) = &called.kind;
+        then {
+            // Extract inner expr type from match argument generated by
+            // question mark operator
+            let inner_expr = &args[0];
+
+            let inner_ty = cx.typeck_results().expr_ty(inner_expr);
+            let outer_ty = cx.typeck_results().expr_ty(expr);
+
+            // Check if outer and inner type are Option
+            let outer_is_some = utils::is_type_diagnostic_item(cx, outer_ty, sym::option_type);
+            let inner_is_some = utils::is_type_diagnostic_item(cx, inner_ty, sym::option_type);
+
+            // Check for Option MSRV
+            let meets_option_msrv = utils::meets_msrv(nqml.msrv.as_ref(), &NEEDLESS_QUESTION_MARK_OPTION_MSRV);
+            if outer_is_some && inner_is_some && meets_option_msrv {
+                return Some(SomeOkCall::SomeCall(expr, inner_expr));
+            }
+
+            // Check if outer and inner type are Result
+            let outer_is_result = utils::is_type_diagnostic_item(cx, outer_ty, sym::result_type);
+            let inner_is_result = utils::is_type_diagnostic_item(cx, inner_ty, sym::result_type);
+
+            // Additional check: if the error type of the Result can be converted
+            // via the From trait, then don't match
+            let does_not_call_from = !has_implicit_error_from(cx, expr, inner_expr);
+
+            // Must meet Result MSRV
+            let meets_result_msrv = utils::meets_msrv(nqml.msrv.as_ref(), &NEEDLESS_QUESTION_MARK_RESULT_MSRV);
+            if outer_is_result && inner_is_result && does_not_call_from && meets_result_msrv {
+                return Some(SomeOkCall::OkCall(expr, inner_expr));
+            }
+        }
+    }
+
+    None
+}
+
+fn has_implicit_error_from(cx: &LateContext<'_>, entire_expr: &Expr<'_>, inner_result_expr: &Expr<'_>) -> bool {
+    return cx.typeck_results().expr_ty(entire_expr) != cx.typeck_results().expr_ty(inner_result_expr);
+}
+
+fn is_ok_ctor(cx: &LateContext<'_>, res: Res) -> bool {
+    if let Some(ok_id) = cx.tcx.lang_items().result_ok_variant() {
+        if let Res::Def(DefKind::Ctor(CtorOf::Variant, CtorKind::Fn), id) = res {
+            if let Some(variant_id) = cx.tcx.parent(id) {
+                return variant_id == ok_id;
+            }
+        }
+    }
+    false
+}
+
+fn is_some_ctor(cx: &LateContext<'_>, res: Res) -> bool {
+    if let Some(some_id) = cx.tcx.lang_items().option_some_variant() {
+        if let Res::Def(DefKind::Ctor(CtorOf::Variant, CtorKind::Fn), id) = res {
+            if let Some(variant_id) = cx.tcx.parent(id) {
+                return variant_id == some_id;
+            }
+        }
+    }
+    false
+}
diff --git a/tests/ui/needless_question_mark.fixed b/tests/ui/needless_question_mark.fixed
new file mode 100644
index 00000000000..70218f3f041
--- /dev/null
+++ b/tests/ui/needless_question_mark.fixed
@@ -0,0 +1,163 @@
+// run-rustfix
+
+#![warn(clippy::needless_question_mark)]
+#![allow(clippy::needless_return, clippy::unnecessary_unwrap, dead_code, unused_must_use)]
+#![feature(custom_inner_attributes)]
+
+struct TO {
+    magic: Option<usize>,
+}
+
+struct TR {
+    magic: Result<usize, bool>,
+}
+
+fn simple_option_bad1(to: TO) -> Option<usize> {
+    // return as a statement
+    return to.magic;
+}
+
+// formatting will add a semi-colon, which would make
+// this identical to the test case above
+#[rustfmt::skip]
+fn simple_option_bad2(to: TO) -> Option<usize> {
+    // return as an expression
+    return to.magic
+}
+
+fn simple_option_bad3(to: TO) -> Option<usize> {
+    // block value "return"
+    to.magic
+}
+
+fn simple_option_bad4(to: Option<TO>) -> Option<usize> {
+    // single line closure
+    to.and_then(|t| t.magic)
+}
+
+// formatting this will remove the block brackets, making
+// this test identical to the one above
+#[rustfmt::skip]
+fn simple_option_bad5(to: Option<TO>) -> Option<usize> {
+    // closure with body
+    to.and_then(|t| {
+        t.magic
+    })
+}
+
+fn simple_result_bad1(tr: TR) -> Result<usize, bool> {
+    return tr.magic;
+}
+
+// formatting will add a semi-colon, which would make
+// this identical to the test case above
+#[rustfmt::skip]
+fn simple_result_bad2(tr: TR) -> Result<usize, bool> {
+    return tr.magic
+}
+
+fn simple_result_bad3(tr: TR) -> Result<usize, bool> {
+    tr.magic
+}
+
+fn simple_result_bad4(tr: Result<TR, bool>) -> Result<usize, bool> {
+    tr.and_then(|t| t.magic)
+}
+
+// formatting this will remove the block brackets, making
+// this test identical to the one above
+#[rustfmt::skip]
+fn simple_result_bad5(tr: Result<TR, bool>) -> Result<usize, bool> {
+    tr.and_then(|t| {
+        t.magic
+    })
+}
+
+fn also_bad(tr: Result<TR, bool>) -> Result<usize, bool> {
+    if tr.is_ok() {
+        let t = tr.unwrap();
+        return t.magic;
+    }
+    Err(false)
+}
+
+fn false_positive_test<U, T>(x: Result<(), U>) -> Result<(), T>
+where
+    T: From<U>,
+{
+    Ok(x?)
+}
+
+fn main() {}
+
+mod question_mark_none {
+    #![clippy::msrv = "1.12.0"]
+    fn needless_question_mark_option() -> Option<usize> {
+        struct TO {
+            magic: Option<usize>,
+        }
+        let to = TO { magic: None };
+        Some(to.magic?) // should not be triggered
+    }
+
+    fn needless_question_mark_result() -> Result<usize, bool> {
+        struct TO {
+            magic: Result<usize, bool>,
+        }
+        let to = TO { magic: Ok(1_usize) };
+        Ok(to.magic?) // should not be triggered
+    }
+
+    fn main() {
+        needless_question_mark_option();
+        needless_question_mark_result();
+    }
+}
+
+mod question_mark_result {
+    #![clippy::msrv = "1.21.0"]
+    fn needless_question_mark_option() -> Option<usize> {
+        struct TO {
+            magic: Option<usize>,
+        }
+        let to = TO { magic: None };
+        Some(to.magic?) // should not be triggered
+    }
+
+    fn needless_question_mark_result() -> Result<usize, bool> {
+        struct TO {
+            magic: Result<usize, bool>,
+        }
+        let to = TO { magic: Ok(1_usize) };
+        to.magic // should be triggered
+    }
+
+    fn main() {
+        needless_question_mark_option();
+        needless_question_mark_result();
+    }
+}
+
+mod question_mark_both {
+    #![clippy::msrv = "1.22.0"]
+    fn needless_question_mark_option() -> Option<usize> {
+        struct TO {
+            magic: Option<usize>,
+        }
+        let to = TO { magic: None };
+        to.magic // should be triggered
+    }
+
+    fn needless_question_mark_result() -> Result<usize, bool> {
+        struct TO {
+            magic: Result<usize, bool>,
+        }
+        let to = TO { magic: Ok(1_usize) };
+        to.magic // should be triggered
+    }
+
+    fn main() {
+        needless_question_mark_option();
+        needless_question_mark_result();
+    }
+}
diff --git a/tests/ui/needless_question_mark.rs b/tests/ui/needless_question_mark.rs
new file mode 100644
index 00000000000..60ac2c8d72e
--- /dev/null
+++ b/tests/ui/needless_question_mark.rs
@@ -0,0 +1,163 @@
+// run-rustfix
+
+#![warn(clippy::needless_question_mark)]
+#![allow(clippy::needless_return, clippy::unnecessary_unwrap, dead_code, unused_must_use)]
+#![feature(custom_inner_attributes)]
+
+struct TO {
+    magic: Option<usize>,
+}
+
+struct TR {
+    magic: Result<usize, bool>,
+}
+
+fn simple_option_bad1(to: TO) -> Option<usize> {
+    // return as a statement
+    return Some(to.magic?);
+}
+
+// formatting will add a semi-colon, which would make
+// this identical to the test case above
+#[rustfmt::skip]
+fn simple_option_bad2(to: TO) -> Option<usize> {
+    // return as an expression
+    return Some(to.magic?)
+}
+
+fn simple_option_bad3(to: TO) -> Option<usize> {
+    // block value "return"
+    Some(to.magic?)
+}
+
+fn simple_option_bad4(to: Option<TO>) -> Option<usize> {
+    // single line closure
+    to.and_then(|t| Some(t.magic?))
+}
+
+// formatting this will remove the block brackets, making
+// this test identical to the one above
+#[rustfmt::skip]
+fn simple_option_bad5(to: Option<TO>) -> Option<usize> {
+    // closure with body
+    to.and_then(|t| {
+        Some(t.magic?)
+    })
+}
+
+fn simple_result_bad1(tr: TR) -> Result<usize, bool> {
+    return Ok(tr.magic?);
+}
+
+// formatting will add a semi-colon, which would make
+// this identical to the test case above
+#[rustfmt::skip]
+fn simple_result_bad2(tr: TR) -> Result<usize, bool> {
+    return Ok(tr.magic?)
+}
+
+fn simple_result_bad3(tr: TR) -> Result<usize, bool> {
+    Ok(tr.magic?)
+}
+
+fn simple_result_bad4(tr: Result<TR, bool>) -> Result<usize, bool> {
+    tr.and_then(|t| Ok(t.magic?))
+}
+
+// formatting this will remove the block brackets, making
+// this test identical to the one above
+#[rustfmt::skip]
+fn simple_result_bad5(tr: Result<TR, bool>) -> Result<usize, bool> {
+    tr.and_then(|t| {
+        Ok(t.magic?)
+    })
+}
+
+fn also_bad(tr: Result<TR, bool>) -> Result<usize, bool> {
+    if tr.is_ok() {
+        let t = tr.unwrap();
+        return Ok(t.magic?);
+    }
+    Err(false)
+}
+
+fn false_positive_test<U, T>(x: Result<(), U>) -> Result<(), T>
+where
+    T: From<U>,
+{
+    Ok(x?)
+}
+
+fn main() {}
+
+mod question_mark_none {
+    #![clippy::msrv = "1.12.0"]
+    fn needless_question_mark_option() -> Option<usize> {
+        struct TO {
+            magic: Option<usize>,
+        }
+        let to = TO { magic: None };
+        Some(to.magic?) // should not be triggered
+    }
+
+    fn needless_question_mark_result() -> Result<usize, bool> {
+        struct TO {
+            magic: Result<usize, bool>,
+        }
+        let to = TO { magic: Ok(1_usize) };
+        Ok(to.magic?) // should not be triggered
+    }
+
+    fn main() {
+        needless_question_mark_option();
+        needless_question_mark_result();
+    }
+}
+
+mod question_mark_result {
+    #![clippy::msrv = "1.21.0"]
+    fn needless_question_mark_option() -> Option<usize> {
+        struct TO {
+            magic: Option<usize>,
+        }
+        let to = TO { magic: None };
+        Some(to.magic?) // should not be triggered
+    }
+
+    fn needless_question_mark_result() -> Result<usize, bool> {
+        struct TO {
+            magic: Result<usize, bool>,
+        }
+        let to = TO { magic: Ok(1_usize) };
+        Ok(to.magic?) // should be triggered
+    }
+
+    fn main() {
+        needless_question_mark_option();
+        needless_question_mark_result();
+    }
+}
+
+mod question_mark_both {
+    #![clippy::msrv = "1.22.0"]
+    fn needless_question_mark_option() -> Option<usize> {
+        struct TO {
+            magic: Option<usize>,
+        }
+        let to = TO { magic: None };
+        Some(to.magic?) // should be triggered
+    }
+
+    fn needless_question_mark_result() -> Result<usize, bool> {
+        struct TO {
+            magic: Result<usize, bool>,
+        }
+        let to = TO { magic: Ok(1_usize) };
+        Ok(to.magic?) // should be triggered
+    }
+
+    fn main() {
+        needless_question_mark_option();
+        needless_question_mark_result();
+    }
+}
diff --git a/tests/ui/needless_question_mark.stderr b/tests/ui/needless_question_mark.stderr
new file mode 100644
index 00000000000..b4eb21882ec
--- /dev/null
+++ b/tests/ui/needless_question_mark.stderr
@@ -0,0 +1,88 @@
+error: Question mark operator is useless here
+  --> $DIR/needless_question_mark.rs:17:12
+   |
+LL |     return Some(to.magic?);
+   |            ^^^^^^^^^^^^^^^ help: try: `to.magic`
+   |
+   = note: `-D clippy::needless-question-mark` implied by `-D warnings`
+
+error: Question mark operator is useless here
+  --> $DIR/needless_question_mark.rs:25:12
+   |
+LL |     return Some(to.magic?)
+   |            ^^^^^^^^^^^^^^^ help: try: `to.magic`
+
+error: Question mark operator is useless here
+  --> $DIR/needless_question_mark.rs:30:5
+   |
+LL |     Some(to.magic?)
+   |     ^^^^^^^^^^^^^^^ help: try: `to.magic`
+
+error: Question mark operator is useless here
+  --> $DIR/needless_question_mark.rs:35:21
+   |
+LL |     to.and_then(|t| Some(t.magic?))
+   |                     ^^^^^^^^^^^^^^ help: try: `t.magic`
+
+error: Question mark operator is useless here
+  --> $DIR/needless_question_mark.rs:44:9
+   |
+LL |         Some(t.magic?)
+   |         ^^^^^^^^^^^^^^ help: try: `t.magic`
+
+error: Question mark operator is useless here
+  --> $DIR/needless_question_mark.rs:49:12
+   |
+LL |     return Ok(tr.magic?);
+   |            ^^^^^^^^^^^^^ help: try: `tr.magic`
+
+error: Question mark operator is useless here
+  --> $DIR/needless_question_mark.rs:56:12
+   |
+LL |     return Ok(tr.magic?)
+   |            ^^^^^^^^^^^^^ help: try: `tr.magic`
+
+error: Question mark operator is useless here
+  --> $DIR/needless_question_mark.rs:60:5
+   |
+LL |     Ok(tr.magic?)
+   |     ^^^^^^^^^^^^^ help: try: `tr.magic`
+
+error: Question mark operator is useless here
+  --> $DIR/needless_question_mark.rs:64:21
+   |
+LL |     tr.and_then(|t| Ok(t.magic?))
+   |                     ^^^^^^^^^^^^ help: try: `t.magic`
+
+error: Question mark operator is useless here
+  --> $DIR/needless_question_mark.rs:72:9
+   |
+LL |         Ok(t.magic?)
+   |         ^^^^^^^^^^^^ help: try: `t.magic`
+
+error: Question mark operator is useless here
+  --> $DIR/needless_question_mark.rs:79:16
+   |
+LL |         return Ok(t.magic?);
+   |                ^^^^^^^^^^^^ help: try: `t.magic`
+
+error: Question mark operator is useless here
+  --> $DIR/needless_question_mark.rs:132:9
+   |
+LL |         Ok(to.magic?) // should be triggered
+   |         ^^^^^^^^^^^^^ help: try: `to.magic`
+
+error: Question mark operator is useless here
+  --> $DIR/needless_question_mark.rs:148:9
+   |
+LL |         Some(to.magic?) // should be triggered
+   |         ^^^^^^^^^^^^^^^ help: try: `to.magic`
+
+error: Question mark operator is useless here
+  --> $DIR/needless_question_mark.rs:156:9
+   |
+LL |         Ok(to.magic?) // should be triggered
+   |         ^^^^^^^^^^^^^ help: try: `to.magic`
+
+error: aborting due to 14 previous errors
+
diff --git a/tests/ui/try_err.fixed b/tests/ui/try_err.fixed
index 652b611208b..5b96bb59c5f 100644
--- a/tests/ui/try_err.fixed
+++ b/tests/ui/try_err.fixed
@@ -2,7 +2,7 @@
 // aux-build:macro_rules.rs
 
 #![deny(clippy::try_err)]
-#![allow(clippy::unnecessary_wraps)]
+#![allow(clippy::unnecessary_wraps, clippy::needless_question_mark)]
 
 #[macro_use]
 extern crate macro_rules;
diff --git a/tests/ui/try_err.rs b/tests/ui/try_err.rs
index 6bd479657b7..f220d697d2c 100644
--- a/tests/ui/try_err.rs
+++ b/tests/ui/try_err.rs
@@ -2,7 +2,7 @@
 // aux-build:macro_rules.rs
 
 #![deny(clippy::try_err)]
-#![allow(clippy::unnecessary_wraps)]
+#![allow(clippy::unnecessary_wraps, clippy::needless_question_mark)]
 
 #[macro_use]
 extern crate macro_rules;
diff --git a/tests/ui/unit_arg.rs b/tests/ui/unit_arg.rs
index 9ad16d36509..b6a7bc5a1cc 100644
--- a/tests/ui/unit_arg.rs
+++ b/tests/ui/unit_arg.rs
@@ -5,7 +5,8 @@
     unused_variables,
     clippy::unused_unit,
     clippy::unnecessary_wraps,
-    clippy::or_fun_call
+    clippy::or_fun_call,
+    clippy::needless_question_mark
 )]
 
 use std::fmt::Debug;
diff --git a/tests/ui/unit_arg.stderr b/tests/ui/unit_arg.stderr
index c3a839a9bf8..094cff8c985 100644
--- a/tests/ui/unit_arg.stderr
+++ b/tests/ui/unit_arg.stderr
@@ -1,5 +1,5 @@
 error: passing a unit value to a function
-  --> $DIR/unit_arg.rs:30:5
+  --> $DIR/unit_arg.rs:31:5
    |
 LL | /     foo({
 LL | |         1;
@@ -20,7 +20,7 @@ LL |     foo(());
    |
 
 error: passing a unit value to a function
-  --> $DIR/unit_arg.rs:33:5
+  --> $DIR/unit_arg.rs:34:5
    |
 LL |     foo(foo(1));
    |     ^^^^^^^^^^^
@@ -32,7 +32,7 @@ LL |     foo(());
    |
 
 error: passing a unit value to a function
-  --> $DIR/unit_arg.rs:34:5
+  --> $DIR/unit_arg.rs:35:5
    |
 LL | /     foo({
 LL | |         foo(1);
@@ -54,7 +54,7 @@ LL |     foo(());
    |
 
 error: passing a unit value to a function
-  --> $DIR/unit_arg.rs:39:5
+  --> $DIR/unit_arg.rs:40:5
    |
 LL | /     b.bar({
 LL | |         1;
@@ -74,7 +74,7 @@ LL |     b.bar(());
    |
 
 error: passing unit values to a function
-  --> $DIR/unit_arg.rs:42:5
+  --> $DIR/unit_arg.rs:43:5
    |
 LL |     taking_multiple_units(foo(0), foo(1));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -87,7 +87,7 @@ LL |     taking_multiple_units((), ());
    |
 
 error: passing unit values to a function
-  --> $DIR/unit_arg.rs:43:5
+  --> $DIR/unit_arg.rs:44:5
    |
 LL | /     taking_multiple_units(foo(0), {
 LL | |         foo(1);
@@ -110,7 +110,7 @@ LL |     taking_multiple_units((), ());
    |
 
 error: passing unit values to a function
-  --> $DIR/unit_arg.rs:47:5
+  --> $DIR/unit_arg.rs:48:5
    |
 LL | /     taking_multiple_units(
 LL | |         {
@@ -140,7 +140,7 @@ LL |         foo(2);
  ...
 
 error: passing a unit value to a function
-  --> $DIR/unit_arg.rs:58:13
+  --> $DIR/unit_arg.rs:59:13
    |
 LL |     None.or(Some(foo(2)));
    |             ^^^^^^^^^^^^
@@ -154,7 +154,7 @@ LL |     });
    |
 
 error: passing a unit value to a function
-  --> $DIR/unit_arg.rs:61:5
+  --> $DIR/unit_arg.rs:62:5
    |
 LL |     foo(foo(()))
    |     ^^^^^^^^^^^^
@@ -166,7 +166,7 @@ LL |     foo(())
    |
 
 error: passing a unit value to a function
-  --> $DIR/unit_arg.rs:94:5
+  --> $DIR/unit_arg.rs:95:5
    |
 LL |     Some(foo(1))
    |     ^^^^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From bc97f5d2156e2fc42ff1a69ccbad9adb2b4568fb Mon Sep 17 00:00:00 2001
From: nahuakang <kangnahua@gmail.com>
Date: Mon, 4 Jan 2021 17:47:59 +0100
Subject: Address flip1995's review comments

---
 clippy_lints/src/empty_enum.rs            | 15 +++++++++------
 tests/ui/empty_enum_without_never_type.rs |  7 +++++++
 2 files changed, 16 insertions(+), 6 deletions(-)
 create mode 100644 tests/ui/empty_enum_without_never_type.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/empty_enum.rs b/clippy_lints/src/empty_enum.rs
index 557a7c6ba98..4533d6447a7 100644
--- a/clippy_lints/src/empty_enum.rs
+++ b/clippy_lints/src/empty_enum.rs
@@ -8,12 +8,12 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 declare_clippy_lint! {
     /// **What it does:** Checks for `enum`s with no variants.
     ///
-    /// As of this writing, the never type is still a
+    /// As of this writing, the `never_type` is still a
     /// nightly-only experimental API. Therefore, this lint is only triggered
-    /// if the never type is enabled
+    /// if the `never_type` is enabled.
     ///
     /// **Why is this bad?** If you want to introduce a type which
-    /// can't be instantiated, you should use `!` (the never type),
+    /// can't be instantiated, you should use `!` (the primitive type never),
     /// or a wrapper around it, because `!` has more extensive
     /// compiler support (type inference, etc...) and wrappers
     /// around it are the conventional way to define an uninhabited type.
@@ -44,13 +44,16 @@ declare_lint_pass!(EmptyEnum => [EMPTY_ENUM]);
 
 impl<'tcx> LateLintPass<'tcx> for EmptyEnum {
     fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
+        // Only suggest the `never_type` if the feature is enabled
+        if !cx.tcx.features().never_type {
+            return;
+        }
+
         let did = cx.tcx.hir().local_def_id(item.hir_id);
         if let ItemKind::Enum(..) = item.kind {
             let ty = cx.tcx.type_of(did);
             let adt = ty.ty_adt_def().expect("already checked whether this is an enum");
-
-            // Only suggest the never type if the feature is enabled
-            if adt.variants.is_empty() && cx.tcx.features().never_type {
+            if adt.variants.is_empty() {
                 span_lint_and_help(
                     cx,
                     EMPTY_ENUM,
diff --git a/tests/ui/empty_enum_without_never_type.rs b/tests/ui/empty_enum_without_never_type.rs
new file mode 100644
index 00000000000..4cbdfc47910
--- /dev/null
+++ b/tests/ui/empty_enum_without_never_type.rs
@@ -0,0 +1,7 @@
+#![allow(dead_code)]
+#![warn(clippy::empty_enum)]
+
+// `never_type` is not enabled; this test has no stderr file
+enum Empty {}
+
+fn main() {}
\ No newline at end of file
-- 
cgit 1.4.1-3-g733a5


From a8d47b4b78a6e6a23dc3320ad3c9e6308f6d1934 Mon Sep 17 00:00:00 2001
From: nahuakang <kangnahua@gmail.com>
Date: Mon, 4 Jan 2021 18:41:42 +0100
Subject: Run cargo dev fmt

---
 clippy_lints/src/empty_enum.rs            | 2 +-
 tests/ui/empty_enum_without_never_type.rs | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/empty_enum.rs b/clippy_lints/src/empty_enum.rs
index 4533d6447a7..853b3afdc3a 100644
--- a/clippy_lints/src/empty_enum.rs
+++ b/clippy_lints/src/empty_enum.rs
@@ -13,7 +13,7 @@ declare_clippy_lint! {
     /// if the `never_type` is enabled.
     ///
     /// **Why is this bad?** If you want to introduce a type which
-    /// can't be instantiated, you should use `!` (the primitive type never),
+    /// can't be instantiated, you should use `!` (the primitive type "never"),
     /// or a wrapper around it, because `!` has more extensive
     /// compiler support (type inference, etc...) and wrappers
     /// around it are the conventional way to define an uninhabited type.
diff --git a/tests/ui/empty_enum_without_never_type.rs b/tests/ui/empty_enum_without_never_type.rs
index 4cbdfc47910..386677352e2 100644
--- a/tests/ui/empty_enum_without_never_type.rs
+++ b/tests/ui/empty_enum_without_never_type.rs
@@ -4,4 +4,4 @@
 // `never_type` is not enabled; this test has no stderr file
 enum Empty {}
 
-fn main() {}
\ No newline at end of file
+fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 4b478a5731956de7d19db9ac76fed81b2ae9db1c Mon Sep 17 00:00:00 2001
From: rail <12975677+rail-rain@users.noreply.github.com>
Date: Mon, 4 Jan 2021 10:34:11 +1300
Subject: Add a new lint `ptr_as_ptr`,

which checks for `as` casts between raw pointers
without changing its mutability
and suggest replacing it with `pointer::cast`.
---
 CHANGELOG.md               |  1 +
 clippy_lints/src/lib.rs    |  3 ++
 clippy_lints/src/types.rs  | 99 ++++++++++++++++++++++++++++++++++++++++++++--
 tests/ui/ptr_as_ptr.fixed  | 30 ++++++++++++++
 tests/ui/ptr_as_ptr.rs     | 30 ++++++++++++++
 tests/ui/ptr_as_ptr.stderr | 34 ++++++++++++++++
 6 files changed, 193 insertions(+), 4 deletions(-)
 create mode 100644 tests/ui/ptr_as_ptr.fixed
 create mode 100644 tests/ui/ptr_as_ptr.rs
 create mode 100644 tests/ui/ptr_as_ptr.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 38c943fec00..64864c2e278 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2141,6 +2141,7 @@ Released 2018-09-13
 [`print_with_newline`]: https://rust-lang.github.io/rust-clippy/master/index.html#print_with_newline
 [`println_empty_string`]: https://rust-lang.github.io/rust-clippy/master/index.html#println_empty_string
 [`ptr_arg`]: https://rust-lang.github.io/rust-clippy/master/index.html#ptr_arg
+[`ptr_as_ptr`]: https://rust-lang.github.io/rust-clippy/master/index.html#ptr_as_ptr
 [`ptr_eq`]: https://rust-lang.github.io/rust-clippy/master/index.html#ptr_eq
 [`ptr_offset_with_cast`]: https://rust-lang.github.io/rust-clippy/master/index.html#ptr_offset_with_cast
 [`pub_enum_variant_names`]: https://rust-lang.github.io/rust-clippy/master/index.html#pub_enum_variant_names
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index f57c6bd6324..37a56bc20c8 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -912,6 +912,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &types::LET_UNIT_VALUE,
         &types::LINKEDLIST,
         &types::OPTION_OPTION,
+        &types::PTR_AS_PTR,
         &types::RC_BUFFER,
         &types::REDUNDANT_ALLOCATION,
         &types::TYPE_COMPLEXITY,
@@ -1222,6 +1223,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box strings::StringToString);
     store.register_late_pass(|| box zero_sized_map_values::ZeroSizedMapValues);
     store.register_late_pass(|| box vec_init_then_push::VecInitThenPush::default());
+    store.register_late_pass(move || box types::PtrAsPtr::new(msrv));
 
     store.register_group(true, "clippy::restriction", Some("clippy_restriction"), vec![
         LintId::of(&arithmetic::FLOAT_ARITHMETIC),
@@ -1348,6 +1350,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&types::LET_UNIT_VALUE),
         LintId::of(&types::LINKEDLIST),
         LintId::of(&types::OPTION_OPTION),
+        LintId::of(&types::PTR_AS_PTR),
         LintId::of(&unicode::NON_ASCII_LITERAL),
         LintId::of(&unicode::UNICODE_NOT_NFC),
         LintId::of(&unnested_or_patterns::UNNESTED_OR_PATTERNS),
diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs
index fd74783335d..d9cf26ad4b3 100644
--- a/clippy_lints/src/types.rs
+++ b/clippy_lints/src/types.rs
@@ -19,7 +19,8 @@ use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::hir::map::Map;
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::TypeFoldable;
-use rustc_middle::ty::{self, InferTy, Ty, TyCtxt, TyS, TypeckResults};
+use rustc_middle::ty::{self, InferTy, Ty, TyCtxt, TyS, TypeAndMut, TypeckResults};
+use rustc_semver::RustcVersion;
 use rustc_session::{declare_lint_pass, declare_tool_lint, impl_lint_pass};
 use rustc_span::hygiene::{ExpnKind, MacroKind};
 use rustc_span::source_map::Span;
@@ -30,11 +31,13 @@ use rustc_typeck::hir_ty_to_ty;
 
 use crate::consts::{constant, Constant};
 use crate::utils::paths;
+use crate::utils::sugg::Sugg;
 use crate::utils::{
     clip, comparisons, differing_macro_contexts, higher, in_constant, indent_of, int_bits, is_type_diagnostic_item,
-    last_path_segment, match_def_path, match_path, method_chain_args, multispan_sugg, numeric_literal::NumericLiteral,
-    qpath_res, reindent_multiline, sext, snippet, snippet_opt, snippet_with_applicability, snippet_with_macro_callsite,
-    span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then, unsext,
+    last_path_segment, match_def_path, match_path, meets_msrv, method_chain_args, multispan_sugg,
+    numeric_literal::NumericLiteral, qpath_res, reindent_multiline, sext, snippet, snippet_opt,
+    snippet_with_applicability, snippet_with_macro_callsite, span_lint, span_lint_and_help, span_lint_and_sugg,
+    span_lint_and_then, unsext,
 };
 
 declare_clippy_lint! {
@@ -2878,3 +2881,91 @@ impl<'tcx> LateLintPass<'tcx> for RefToMut {
         }
     }
 }
+
+const PTR_AS_PTR_MSRV: RustcVersion = RustcVersion::new(1, 38, 0);
+
+declare_clippy_lint! {
+    /// **What it does:**
+    /// Checks for `as` casts between raw pointers without changing its mutability,
+    /// namely `*const T` to `*const U` and `*mut T` to `*mut U`.
+    ///
+    /// **Why is this bad?**
+    /// Though `as` casts between raw pointers is not terrible, `pointer::cast` is safer because
+    /// it cannot accidentally change the pointer's mutability nor cast the pointer to other types like `usize`.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// let ptr: *const u32 = &42_u32;
+    /// let mut_ptr: *mut u32 = &mut 42_u32;
+    /// let _ = ptr as *const i32;
+    /// let _ = mut_ptr as *mut i32;
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// let ptr: *const u32 = &42_u32;
+    /// let mut_ptr: *mut u32 = &mut 42_u32;
+    /// let _ = ptr.cast::<i32>();
+    /// let _ = mut_ptr.cast::<i32>();
+    /// ```
+    pub PTR_AS_PTR,
+    pedantic,
+    "casting using `as` from and to raw pointers that doesn't change its mutability, where `pointer::cast` could take the place of `as`"
+}
+
+pub struct PtrAsPtr {
+    msrv: Option<RustcVersion>,
+}
+
+impl PtrAsPtr {
+    #[must_use]
+    pub fn new(msrv: Option<RustcVersion>) -> Self {
+        Self { msrv }
+    }
+}
+
+impl_lint_pass!(PtrAsPtr => [PTR_AS_PTR]);
+
+impl<'tcx> LateLintPass<'tcx> for PtrAsPtr {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        if !meets_msrv(self.msrv.as_ref(), &PTR_AS_PTR_MSRV) {
+            return;
+        }
+
+        if expr.span.from_expansion() {
+            return;
+        }
+
+        if_chain! {
+            if let ExprKind::Cast(cast_expr, cast_to_hir_ty) = expr.kind;
+            let (cast_from, cast_to) = (cx.typeck_results().expr_ty(cast_expr), cx.typeck_results().expr_ty(expr));
+            if let ty::RawPtr(TypeAndMut { mutbl: from_mutbl, .. }) = cast_from.kind();
+            if let ty::RawPtr(TypeAndMut { ty: to_pointee_ty, mutbl: to_mutbl }) = cast_to.kind();
+            if matches!((from_mutbl, to_mutbl),
+                (Mutability::Not, Mutability::Not) | (Mutability::Mut, Mutability::Mut));
+            // The `U` in `pointer::cast` have to be `Sized`
+            // as explained here: https://github.com/rust-lang/rust/issues/60602.
+            if to_pointee_ty.is_sized(cx.tcx.at(expr.span), cx.param_env);
+            then {
+                let mut applicability = Applicability::MachineApplicable;
+                let cast_expr_sugg = Sugg::hir_with_applicability(cx, cast_expr, "_", &mut applicability);
+                let turbofish = match &cast_to_hir_ty.kind {
+                        TyKind::Infer => Cow::Borrowed(""),
+                        TyKind::Ptr(mut_ty) if matches!(mut_ty.ty.kind, TyKind::Infer) => Cow::Borrowed(""),
+                        _ => Cow::Owned(format!("::<{}>", to_pointee_ty)),
+                    };
+                span_lint_and_sugg(
+                    cx,
+                    PTR_AS_PTR,
+                    expr.span,
+                    "`as` casting between raw pointers without changing its mutability",
+                    "try `pointer::cast`, a safer alternative",
+                    format!("{}.cast{}()", cast_expr_sugg.maybe_par(), turbofish),
+                    applicability,
+                );
+            }
+        }
+    }
+}
diff --git a/tests/ui/ptr_as_ptr.fixed b/tests/ui/ptr_as_ptr.fixed
new file mode 100644
index 00000000000..e0b79004cbd
--- /dev/null
+++ b/tests/ui/ptr_as_ptr.fixed
@@ -0,0 +1,30 @@
+// run-rustfix
+
+#![warn(clippy::ptr_as_ptr)]
+
+fn main() {
+    let ptr: *const u32 = &42_u32;
+    let mut_ptr: *mut u32 = &mut 42_u32;
+
+    let _ = ptr.cast::<i32>();
+    let _ = mut_ptr.cast::<i32>();
+
+    // Make sure the lint can handle the difference in their operator precedences.
+    unsafe {
+        let ptr_ptr: *const *const u32 = &ptr;
+        let _ = (*ptr_ptr).cast::<i32>();
+    }
+
+    // Changes in mutability. Do not lint this.
+    let _ = ptr as *mut i32;
+    let _ = mut_ptr as *const i32;
+
+    // `pointer::cast` cannot perform unsized coercions unlike `as`. Do not lint this.
+    let ptr_of_array: *const [u32; 4] = &[1, 2, 3, 4];
+    let _ = ptr_of_array as *const [u32];
+    let _ = ptr_of_array as *const dyn std::fmt::Debug;
+
+    // Ensure the lint doesn't produce unnecessary turbofish for inferred types.
+    let _: *const i32 = ptr.cast();
+    let _: *mut i32 = mut_ptr.cast();
+}
diff --git a/tests/ui/ptr_as_ptr.rs b/tests/ui/ptr_as_ptr.rs
new file mode 100644
index 00000000000..f31940dbd1f
--- /dev/null
+++ b/tests/ui/ptr_as_ptr.rs
@@ -0,0 +1,30 @@
+// run-rustfix
+
+#![warn(clippy::ptr_as_ptr)]
+
+fn main() {
+    let ptr: *const u32 = &42_u32;
+    let mut_ptr: *mut u32 = &mut 42_u32;
+
+    let _ = ptr as *const i32;
+    let _ = mut_ptr as *mut i32;
+
+    // Make sure the lint can handle the difference in their operator precedences.
+    unsafe {
+        let ptr_ptr: *const *const u32 = &ptr;
+        let _ = *ptr_ptr as *const i32;
+    }
+
+    // Changes in mutability. Do not lint this.
+    let _ = ptr as *mut i32;
+    let _ = mut_ptr as *const i32;
+
+    // `pointer::cast` cannot perform unsized coercions unlike `as`. Do not lint this.
+    let ptr_of_array: *const [u32; 4] = &[1, 2, 3, 4];
+    let _ = ptr_of_array as *const [u32];
+    let _ = ptr_of_array as *const dyn std::fmt::Debug;
+
+    // Ensure the lint doesn't produce unnecessary turbofish for inferred types.
+    let _: *const i32 = ptr as *const _;
+    let _: *mut i32 = mut_ptr as _;
+}
diff --git a/tests/ui/ptr_as_ptr.stderr b/tests/ui/ptr_as_ptr.stderr
new file mode 100644
index 00000000000..22217e18c54
--- /dev/null
+++ b/tests/ui/ptr_as_ptr.stderr
@@ -0,0 +1,34 @@
+error: `as` casting between raw pointers without changing its mutability
+  --> $DIR/ptr_as_ptr.rs:9:13
+   |
+LL |     let _ = ptr as *const i32;
+   |             ^^^^^^^^^^^^^^^^^ help: try `pointer::cast`, a safer alternative: `ptr.cast::<i32>()`
+   |
+   = note: `-D clippy::ptr-as-ptr` implied by `-D warnings`
+
+error: `as` casting between raw pointers without changing its mutability
+  --> $DIR/ptr_as_ptr.rs:10:13
+   |
+LL |     let _ = mut_ptr as *mut i32;
+   |             ^^^^^^^^^^^^^^^^^^^ help: try `pointer::cast`, a safer alternative: `mut_ptr.cast::<i32>()`
+
+error: `as` casting between raw pointers without changing its mutability
+  --> $DIR/ptr_as_ptr.rs:15:17
+   |
+LL |         let _ = *ptr_ptr as *const i32;
+   |                 ^^^^^^^^^^^^^^^^^^^^^^ help: try `pointer::cast`, a safer alternative: `(*ptr_ptr).cast::<i32>()`
+
+error: `as` casting between raw pointers without changing its mutability
+  --> $DIR/ptr_as_ptr.rs:28:25
+   |
+LL |     let _: *const i32 = ptr as *const _;
+   |                         ^^^^^^^^^^^^^^^ help: try `pointer::cast`, a safer alternative: `ptr.cast()`
+
+error: `as` casting between raw pointers without changing its mutability
+  --> $DIR/ptr_as_ptr.rs:29:23
+   |
+LL |     let _: *mut i32 = mut_ptr as _;
+   |                       ^^^^^^^^^^^^ help: try `pointer::cast`, a safer alternative: `mut_ptr.cast()`
+
+error: aborting due to 5 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From dfa5d7e818c32ea48bc141799276f700ab9d8fb7 Mon Sep 17 00:00:00 2001
From: rail <12975677+rail-rain@users.noreply.github.com>
Date: Tue, 5 Jan 2021 10:17:31 +1300
Subject: Fix the MSRV and add the tests for MSRV

---
 clippy_lints/src/types.rs  |  2 ++
 tests/ui/ptr_as_ptr.fixed  | 20 ++++++++++++++++++++
 tests/ui/ptr_as_ptr.rs     | 20 ++++++++++++++++++++
 tests/ui/ptr_as_ptr.stderr | 24 ++++++++++++++++++------
 4 files changed, 60 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs
index d9cf26ad4b3..b21f81bd517 100644
--- a/clippy_lints/src/types.rs
+++ b/clippy_lints/src/types.rs
@@ -2968,4 +2968,6 @@ impl<'tcx> LateLintPass<'tcx> for PtrAsPtr {
             }
         }
     }
+
+    extract_msrv_attr!(LateContext);
 }
diff --git a/tests/ui/ptr_as_ptr.fixed b/tests/ui/ptr_as_ptr.fixed
index e0b79004cbd..8346a9454f4 100644
--- a/tests/ui/ptr_as_ptr.fixed
+++ b/tests/ui/ptr_as_ptr.fixed
@@ -1,6 +1,7 @@
 // run-rustfix
 
 #![warn(clippy::ptr_as_ptr)]
+#![feature(custom_inner_attributes)]
 
 fn main() {
     let ptr: *const u32 = &42_u32;
@@ -28,3 +29,22 @@ fn main() {
     let _: *const i32 = ptr.cast();
     let _: *mut i32 = mut_ptr.cast();
 }
+
+fn _msrv_1_37() {
+    #![clippy::msrv = "1.37"]
+    let ptr: *const u32 = &42_u32;
+    let mut_ptr: *mut u32 = &mut 42_u32;
+
+    // `pointer::cast` was stabilized in 1.38. Do not lint this
+    let _ = ptr as *const i32;
+    let _ = mut_ptr as *mut i32;
+}
+
+fn _msrv_1_38() {
+    #![clippy::msrv = "1.38"]
+    let ptr: *const u32 = &42_u32;
+    let mut_ptr: *mut u32 = &mut 42_u32;
+
+    let _ = ptr.cast::<i32>();
+    let _ = mut_ptr.cast::<i32>();
+}
diff --git a/tests/ui/ptr_as_ptr.rs b/tests/ui/ptr_as_ptr.rs
index f31940dbd1f..b68d4bc0aac 100644
--- a/tests/ui/ptr_as_ptr.rs
+++ b/tests/ui/ptr_as_ptr.rs
@@ -1,6 +1,7 @@
 // run-rustfix
 
 #![warn(clippy::ptr_as_ptr)]
+#![feature(custom_inner_attributes)]
 
 fn main() {
     let ptr: *const u32 = &42_u32;
@@ -28,3 +29,22 @@ fn main() {
     let _: *const i32 = ptr as *const _;
     let _: *mut i32 = mut_ptr as _;
 }
+
+fn _msrv_1_37() {
+    #![clippy::msrv = "1.37"]
+    let ptr: *const u32 = &42_u32;
+    let mut_ptr: *mut u32 = &mut 42_u32;
+
+    // `pointer::cast` was stabilized in 1.38. Do not lint this
+    let _ = ptr as *const i32;
+    let _ = mut_ptr as *mut i32;
+}
+
+fn _msrv_1_38() {
+    #![clippy::msrv = "1.38"]
+    let ptr: *const u32 = &42_u32;
+    let mut_ptr: *mut u32 = &mut 42_u32;
+
+    let _ = ptr as *const i32;
+    let _ = mut_ptr as *mut i32;
+}
diff --git a/tests/ui/ptr_as_ptr.stderr b/tests/ui/ptr_as_ptr.stderr
index 22217e18c54..854906dc111 100644
--- a/tests/ui/ptr_as_ptr.stderr
+++ b/tests/ui/ptr_as_ptr.stderr
@@ -1,5 +1,5 @@
 error: `as` casting between raw pointers without changing its mutability
-  --> $DIR/ptr_as_ptr.rs:9:13
+  --> $DIR/ptr_as_ptr.rs:10:13
    |
 LL |     let _ = ptr as *const i32;
    |             ^^^^^^^^^^^^^^^^^ help: try `pointer::cast`, a safer alternative: `ptr.cast::<i32>()`
@@ -7,28 +7,40 @@ LL |     let _ = ptr as *const i32;
    = note: `-D clippy::ptr-as-ptr` implied by `-D warnings`
 
 error: `as` casting between raw pointers without changing its mutability
-  --> $DIR/ptr_as_ptr.rs:10:13
+  --> $DIR/ptr_as_ptr.rs:11:13
    |
 LL |     let _ = mut_ptr as *mut i32;
    |             ^^^^^^^^^^^^^^^^^^^ help: try `pointer::cast`, a safer alternative: `mut_ptr.cast::<i32>()`
 
 error: `as` casting between raw pointers without changing its mutability
-  --> $DIR/ptr_as_ptr.rs:15:17
+  --> $DIR/ptr_as_ptr.rs:16:17
    |
 LL |         let _ = *ptr_ptr as *const i32;
    |                 ^^^^^^^^^^^^^^^^^^^^^^ help: try `pointer::cast`, a safer alternative: `(*ptr_ptr).cast::<i32>()`
 
 error: `as` casting between raw pointers without changing its mutability
-  --> $DIR/ptr_as_ptr.rs:28:25
+  --> $DIR/ptr_as_ptr.rs:29:25
    |
 LL |     let _: *const i32 = ptr as *const _;
    |                         ^^^^^^^^^^^^^^^ help: try `pointer::cast`, a safer alternative: `ptr.cast()`
 
 error: `as` casting between raw pointers without changing its mutability
-  --> $DIR/ptr_as_ptr.rs:29:23
+  --> $DIR/ptr_as_ptr.rs:30:23
    |
 LL |     let _: *mut i32 = mut_ptr as _;
    |                       ^^^^^^^^^^^^ help: try `pointer::cast`, a safer alternative: `mut_ptr.cast()`
 
-error: aborting due to 5 previous errors
+error: `as` casting between raw pointers without changing its mutability
+  --> $DIR/ptr_as_ptr.rs:48:13
+   |
+LL |     let _ = ptr as *const i32;
+   |             ^^^^^^^^^^^^^^^^^ help: try `pointer::cast`, a safer alternative: `ptr.cast::<i32>()`
+
+error: `as` casting between raw pointers without changing its mutability
+  --> $DIR/ptr_as_ptr.rs:49:13
+   |
+LL |     let _ = mut_ptr as *mut i32;
+   |             ^^^^^^^^^^^^^^^^^^^ help: try `pointer::cast`, a safer alternative: `mut_ptr.cast::<i32>()`
+
+error: aborting due to 7 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 61f3d9d46b5cbfdb56069a95e5839abe8fda9acf Mon Sep 17 00:00:00 2001
From: Javier Alvarez <javier.alvarez@allthingsembedded.net>
Date: Wed, 23 Dec 2020 12:37:37 +0100
Subject: Add case_sensitive_file_extensions lint

Closes #6425

Looks for ends_with methods calls with case sensitive extensions.
---
 CHANGELOG.md                                       |  1 +
 clippy_lints/Cargo.toml                            |  2 +
 .../case_sensitive_file_extension_comparisons.rs   | 88 ++++++++++++++++++++++
 clippy_lints/src/lib.rs                            |  4 +
 .../case_sensitive_file_extension_comparisons.rs   | 44 +++++++++++
 ...ase_sensitive_file_extension_comparisons.stderr | 43 +++++++++++
 6 files changed, 182 insertions(+)
 create mode 100644 clippy_lints/src/case_sensitive_file_extension_comparisons.rs
 create mode 100644 tests/ui/case_sensitive_file_extension_comparisons.rs
 create mode 100644 tests/ui/case_sensitive_file_extension_comparisons.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 64864c2e278..b0e9ad55b4f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1878,6 +1878,7 @@ Released 2018-09-13
 [`boxed_local`]: https://rust-lang.github.io/rust-clippy/master/index.html#boxed_local
 [`builtin_type_shadow`]: https://rust-lang.github.io/rust-clippy/master/index.html#builtin_type_shadow
 [`cargo_common_metadata`]: https://rust-lang.github.io/rust-clippy/master/index.html#cargo_common_metadata
+[`case_sensitive_file_extension_comparisons`]: https://rust-lang.github.io/rust-clippy/master/index.html#case_sensitive_file_extension_comparisons
 [`cast_lossless`]: https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
 [`cast_possible_truncation`]: https://rust-lang.github.io/rust-clippy/master/index.html#cast_possible_truncation
 [`cast_possible_wrap`]: https://rust-lang.github.io/rust-clippy/master/index.html#cast_possible_wrap
diff --git a/clippy_lints/Cargo.toml b/clippy_lints/Cargo.toml
index a9516560a61..38098f8a14c 100644
--- a/clippy_lints/Cargo.toml
+++ b/clippy_lints/Cargo.toml
@@ -34,6 +34,8 @@ rustc-semver="1.1.0"
 url = { version =  "2.1.0", features = ["serde"] }
 quote = "1"
 syn = { version = "1", features = ["full"] }
+regex = "1.4"
+lazy_static = "1.4"
 
 [features]
 deny-warnings = []
diff --git a/clippy_lints/src/case_sensitive_file_extension_comparisons.rs b/clippy_lints/src/case_sensitive_file_extension_comparisons.rs
new file mode 100644
index 00000000000..b227e9a981a
--- /dev/null
+++ b/clippy_lints/src/case_sensitive_file_extension_comparisons.rs
@@ -0,0 +1,88 @@
+use crate::utils::paths::STRING;
+use crate::utils::{match_def_path, span_lint_and_help};
+use if_chain::if_chain;
+use lazy_static::lazy_static;
+use regex::Regex;
+use rustc_ast::ast::LitKind;
+use rustc_hir::{Expr, ExprKind, PathSegment};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::{source_map::Spanned, Span};
+
+declare_clippy_lint! {
+    /// **What it does:**
+    /// Checks for calls to `ends_with` with possible file extensions
+    /// and suggests to use a case-insensitive approach instead.
+    ///
+    /// **Why is this bad?**
+    /// `ends_with` is case-sensitive and may not detect files with a valid extension.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// fn is_rust_file(filename: &str) -> bool {
+    ///     filename.ends_with(".rs")
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// fn is_rust_file(filename: &str) -> bool {
+    ///     filename.rsplit('.').next().map(|ext| ext.eq_ignore_ascii_case("rs")) == Some(true)
+    /// }
+    /// ```
+    pub CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS,
+    pedantic,
+    "default lint description"
+}
+
+declare_lint_pass!(CaseSensitiveFileExtensionComparisons => [CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS]);
+
+fn check_case_sensitive_file_extension_comparison(ctx: &LateContext<'_>, expr: &Expr<'_>) -> Option<Span> {
+    lazy_static! {
+        static ref RE: Regex = Regex::new(r"^\.([a-z0-9]{1,5}|[A-Z0-9]{1,5})$").unwrap();
+    }
+    if_chain! {
+        if let ExprKind::MethodCall(PathSegment { ident, .. }, _, [obj, extension, ..], span) = expr.kind;
+        if ident.as_str() == "ends_with";
+        if let ExprKind::Lit(Spanned { node: LitKind::Str(ext_literal, ..), ..}) = extension.kind;
+        if RE.is_match(&ext_literal.as_str());
+        then {
+            let mut ty = ctx.typeck_results().expr_ty(obj);
+            ty = match ty.kind() {
+                ty::Ref(_, ty, ..) => ty,
+                _ => ty
+            };
+
+            match ty.kind() {
+                ty::Str => {
+                    return Some(span);
+                },
+                ty::Adt(&ty::AdtDef { did, .. }, _) => {
+                    if match_def_path(ctx, did, &STRING) {
+                        return Some(span);
+                    }
+                },
+                _ => { return None; }
+            }
+        }
+    }
+    None
+}
+
+impl LateLintPass<'tcx> for CaseSensitiveFileExtensionComparisons {
+    fn check_expr(&mut self, ctx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
+        if let Some(span) = check_case_sensitive_file_extension_comparison(ctx, expr) {
+            span_lint_and_help(
+                ctx,
+                CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS,
+                span,
+                "case-sensitive file extension comparison",
+                None,
+                "consider using a case-insensitive comparison instead",
+            );
+        }
+    }
+}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 37a56bc20c8..ec433acf038 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -170,6 +170,7 @@ mod blocks_in_if_conditions;
 mod booleans;
 mod bytecount;
 mod cargo_common_metadata;
+mod case_sensitive_file_extension_comparisons;
 mod checked_conversions;
 mod cognitive_complexity;
 mod collapsible_if;
@@ -556,6 +557,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &booleans::NONMINIMAL_BOOL,
         &bytecount::NAIVE_BYTECOUNT,
         &cargo_common_metadata::CARGO_COMMON_METADATA,
+        &case_sensitive_file_extension_comparisons::CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS,
         &checked_conversions::CHECKED_CONVERSIONS,
         &cognitive_complexity::COGNITIVE_COMPLEXITY,
         &collapsible_if::COLLAPSIBLE_ELSE_IF,
@@ -1224,6 +1226,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box zero_sized_map_values::ZeroSizedMapValues);
     store.register_late_pass(|| box vec_init_then_push::VecInitThenPush::default());
     store.register_late_pass(move || box types::PtrAsPtr::new(msrv));
+    store.register_late_pass(|| box case_sensitive_file_extension_comparisons::CaseSensitiveFileExtensionComparisons);
 
     store.register_group(true, "clippy::restriction", Some("clippy_restriction"), vec![
         LintId::of(&arithmetic::FLOAT_ARITHMETIC),
@@ -1281,6 +1284,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&await_holding_invalid::AWAIT_HOLDING_LOCK),
         LintId::of(&await_holding_invalid::AWAIT_HOLDING_REFCELL_REF),
         LintId::of(&bit_mask::VERBOSE_BIT_MASK),
+        LintId::of(&case_sensitive_file_extension_comparisons::CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS),
         LintId::of(&checked_conversions::CHECKED_CONVERSIONS),
         LintId::of(&copies::SAME_FUNCTIONS_IN_IF_CONDITION),
         LintId::of(&copy_iterator::COPY_ITERATOR),
diff --git a/tests/ui/case_sensitive_file_extension_comparisons.rs b/tests/ui/case_sensitive_file_extension_comparisons.rs
new file mode 100644
index 00000000000..68719c2bc6d
--- /dev/null
+++ b/tests/ui/case_sensitive_file_extension_comparisons.rs
@@ -0,0 +1,44 @@
+#![warn(clippy::case_sensitive_file_extension_comparisons)]
+
+use std::string::String;
+
+struct TestStruct {}
+
+impl TestStruct {
+    fn ends_with(self, arg: &str) {}
+}
+
+fn is_rust_file(filename: &str) -> bool {
+    filename.ends_with(".rs")
+}
+
+fn main() {
+    // std::string::String and &str should trigger the lint failure with .ext12
+    let _ = String::from("").ends_with(".ext12");
+    let _ = "str".ends_with(".ext12");
+
+    // The test struct should not trigger the lint failure with .ext12
+    TestStruct {}.ends_with(".ext12");
+
+    // std::string::String and &str should trigger the lint failure with .EXT12
+    let _ = String::from("").ends_with(".EXT12");
+    let _ = "str".ends_with(".EXT12");
+
+    // The test struct should not trigger the lint failure with .EXT12
+    TestStruct {}.ends_with(".EXT12");
+
+    // Should not trigger the lint failure with .eXT12
+    let _ = String::from("").ends_with(".eXT12");
+    let _ = "str".ends_with(".eXT12");
+    TestStruct {}.ends_with(".eXT12");
+
+    // Should not trigger the lint failure with .EXT123 (too long)
+    let _ = String::from("").ends_with(".EXT123");
+    let _ = "str".ends_with(".EXT123");
+    TestStruct {}.ends_with(".EXT123");
+
+    // Shouldn't fail if it doesn't start with a dot
+    let _ = String::from("").ends_with("a.ext");
+    let _ = "str".ends_with("a.extA");
+    TestStruct {}.ends_with("a.ext");
+}
diff --git a/tests/ui/case_sensitive_file_extension_comparisons.stderr b/tests/ui/case_sensitive_file_extension_comparisons.stderr
new file mode 100644
index 00000000000..05b98169f2d
--- /dev/null
+++ b/tests/ui/case_sensitive_file_extension_comparisons.stderr
@@ -0,0 +1,43 @@
+error: case-sensitive file extension comparison
+  --> $DIR/case_sensitive_file_extension_comparisons.rs:12:14
+   |
+LL |     filename.ends_with(".rs")
+   |              ^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::case-sensitive-file-extension-comparisons` implied by `-D warnings`
+   = help: consider using a case-insensitive comparison instead
+
+error: case-sensitive file extension comparison
+  --> $DIR/case_sensitive_file_extension_comparisons.rs:17:30
+   |
+LL |     let _ = String::from("").ends_with(".ext12");
+   |                              ^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using a case-insensitive comparison instead
+
+error: case-sensitive file extension comparison
+  --> $DIR/case_sensitive_file_extension_comparisons.rs:18:19
+   |
+LL |     let _ = "str".ends_with(".ext12");
+   |                   ^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using a case-insensitive comparison instead
+
+error: case-sensitive file extension comparison
+  --> $DIR/case_sensitive_file_extension_comparisons.rs:24:30
+   |
+LL |     let _ = String::from("").ends_with(".EXT12");
+   |                              ^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using a case-insensitive comparison instead
+
+error: case-sensitive file extension comparison
+  --> $DIR/case_sensitive_file_extension_comparisons.rs:25:19
+   |
+LL |     let _ = "str".ends_with(".EXT12");
+   |                   ^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using a case-insensitive comparison instead
+
+error: aborting due to 5 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From e56973a8545d384d6dcb5271b54c90c584a58065 Mon Sep 17 00:00:00 2001
From: Javier Alvarez <javier.alvarez@allthingsembedded.net>
Date: Wed, 23 Dec 2020 16:59:17 +0100
Subject: Remove default lint description

This was left as default and caused a CI failure for the
case_sensitive_file_extension_comparison lint.
---
 clippy_lints/src/case_sensitive_file_extension_comparisons.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/case_sensitive_file_extension_comparisons.rs b/clippy_lints/src/case_sensitive_file_extension_comparisons.rs
index b227e9a981a..d5347ce6ed7 100644
--- a/clippy_lints/src/case_sensitive_file_extension_comparisons.rs
+++ b/clippy_lints/src/case_sensitive_file_extension_comparisons.rs
@@ -35,7 +35,7 @@ declare_clippy_lint! {
     /// ```
     pub CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS,
     pedantic,
-    "default lint description"
+    "Checks for calls to ends_with with case-sensitive file extensions"
 }
 
 declare_lint_pass!(CaseSensitiveFileExtensionComparisons => [CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS]);
-- 
cgit 1.4.1-3-g733a5


From ea885d90ad3d041cbd7918ab25b4fb2d5f7bc5e6 Mon Sep 17 00:00:00 2001
From: Philipp Hansch <dev@phansch.net>
Date: Tue, 5 Jan 2021 16:03:39 +0100
Subject: Tiny Symbol cleanup

* Renames `sym.rs` to `sym_helper.rs` so that the `sym as rustc_sym` is no longer needed.
* Removes one needless `symbol` from a path
---
 clippy_lints/src/utils/mod.rs        | 10 +++++-----
 clippy_lints/src/utils/sym.rs        |  6 ------
 clippy_lints/src/utils/sym_helper.rs |  7 +++++++
 3 files changed, 12 insertions(+), 11 deletions(-)
 delete mode 100644 clippy_lints/src/utils/sym.rs
 create mode 100644 clippy_lints/src/utils/sym_helper.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index 1c68e837c4a..8f54cad7728 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -1,5 +1,5 @@
 #[macro_use]
-pub mod sym;
+pub mod sym_helper;
 
 #[allow(clippy::module_name_repetitions)]
 pub mod ast_utils;
@@ -56,8 +56,8 @@ use rustc_semver::RustcVersion;
 use rustc_session::Session;
 use rustc_span::hygiene::{ExpnKind, MacroKind};
 use rustc_span::source_map::original_sp;
-use rustc_span::sym as rustc_sym;
-use rustc_span::symbol::{self, kw, Symbol};
+use rustc_span::sym;
+use rustc_span::symbol::{kw, Symbol};
 use rustc_span::{BytePos, Pos, Span, DUMMY_SP};
 use rustc_target::abi::Integer;
 use rustc_trait_selection::traits::query::normalize::AtExt;
@@ -1121,7 +1121,7 @@ pub fn is_refutable(cx: &LateContext<'_>, pat: &Pat<'_>) -> bool {
 /// Checks for the `#[automatically_derived]` attribute all `#[derive]`d
 /// implementations have.
 pub fn is_automatically_derived(attrs: &[ast::Attribute]) -> bool {
-    attrs.iter().any(|attr| attr.has_name(rustc_sym::automatically_derived))
+    attrs.iter().any(|attr| attr.has_name(sym::automatically_derived))
 }
 
 /// Remove blocks around an expression.
@@ -1514,7 +1514,7 @@ pub fn is_must_use_func_call(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
 pub fn is_no_std_crate(krate: &Crate<'_>) -> bool {
     krate.item.attrs.iter().any(|attr| {
         if let ast::AttrKind::Normal(ref attr, _) = attr.kind {
-            attr.path == symbol::sym::no_std
+            attr.path == sym::no_std
         } else {
             false
         }
diff --git a/clippy_lints/src/utils/sym.rs b/clippy_lints/src/utils/sym.rs
deleted file mode 100644
index 273288c3d52..00000000000
--- a/clippy_lints/src/utils/sym.rs
+++ /dev/null
@@ -1,6 +0,0 @@
-#[macro_export]
-macro_rules! sym {
-    ($tt:tt) => {
-        rustc_span::symbol::Symbol::intern(stringify!($tt))
-    };
-}
diff --git a/clippy_lints/src/utils/sym_helper.rs b/clippy_lints/src/utils/sym_helper.rs
new file mode 100644
index 00000000000..f47dc80ebad
--- /dev/null
+++ b/clippy_lints/src/utils/sym_helper.rs
@@ -0,0 +1,7 @@
+#[macro_export]
+/// Convenience wrapper around rustc's `Symbol::intern`
+macro_rules! sym {
+    ($tt:tt) => {
+        rustc_span::symbol::Symbol::intern(stringify!($tt))
+    };
+}
-- 
cgit 1.4.1-3-g733a5


From a8825e9af067e10406e13ff7fbe9bbd5c7699a41 Mon Sep 17 00:00:00 2001
From: Philipp Hansch <dev@phansch.net>
Date: Tue, 5 Jan 2021 16:31:08 +0100
Subject: Use existing 'is_automatically_derived' helper

---
 clippy_lints/src/needless_borrow.rs | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/needless_borrow.rs b/clippy_lints/src/needless_borrow.rs
index bff53eb8cca..f1c06692e30 100644
--- a/clippy_lints/src/needless_borrow.rs
+++ b/clippy_lints/src/needless_borrow.rs
@@ -2,7 +2,7 @@
 //!
 //! This lint is **warn** by default
 
-use crate::utils::{snippet_opt, span_lint_and_then};
+use crate::utils::{is_automatically_derived, snippet_opt, span_lint_and_then};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{BindingAnnotation, BorrowKind, Expr, ExprKind, HirId, Item, Mutability, Pat, PatKind};
@@ -10,7 +10,6 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
 use rustc_middle::ty::adjustment::{Adjust, Adjustment};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::sym;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for address of operations (`&`) that are going to
@@ -116,7 +115,7 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessBorrow {
     }
 
     fn check_item(&mut self, _: &LateContext<'tcx>, item: &'tcx Item<'_>) {
-        if item.attrs.iter().any(|a| a.has_name(sym::automatically_derived)) {
+        if is_automatically_derived(item.attrs) {
             debug_assert!(self.derived_item.is_none());
             self.derived_item = Some(item.hir_id);
         }
-- 
cgit 1.4.1-3-g733a5


From 92f2bbbe06b92ad9fc984804307958d8566cd4ed Mon Sep 17 00:00:00 2001
From: Philipp Hansch <dev@phansch.net>
Date: Tue, 5 Jan 2021 20:11:37 +0100
Subject: Fix macro issues with field_reassign_with_default

---
 clippy_lints/src/default.rs                 |  3 +++
 tests/ui/auxiliary/macro_rules.rs           | 16 ++++++++++++
 tests/ui/auxiliary/proc_macro_derive.rs     | 18 +++++++++++++
 tests/ui/field_reassign_with_default.rs     | 16 ++++++++++++
 tests/ui/field_reassign_with_default.stderr | 40 ++++++++++++++---------------
 5 files changed, 73 insertions(+), 20 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/default.rs b/clippy_lints/src/default.rs
index 9fa06d7cde9..f7224811e6e 100644
--- a/clippy_lints/src/default.rs
+++ b/clippy_lints/src/default.rs
@@ -8,6 +8,7 @@ use rustc_errors::Applicability;
 use rustc_hir::def::Res;
 use rustc_hir::{Block, Expr, ExprKind, PatKind, QPath, Stmt, StmtKind};
 use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::symbol::{Ident, Symbol};
@@ -120,6 +121,8 @@ impl LateLintPass<'_> for Default {
                 // only take `let ...` statements
                 if let StmtKind::Local(local) = stmt.kind;
                 if let Some(expr) = local.init;
+                if !any_parent_is_automatically_derived(cx.tcx, expr.hir_id);
+                if !in_external_macro(cx.tcx.sess, expr.span);
                 // only take bindings to identifiers
                 if let PatKind::Binding(_, binding_id, ident, _) = local.pat.kind;
                 // only when assigning `... = Default::default()`
diff --git a/tests/ui/auxiliary/macro_rules.rs b/tests/ui/auxiliary/macro_rules.rs
index 18324823468..d6ecd8568ce 100644
--- a/tests/ui/auxiliary/macro_rules.rs
+++ b/tests/ui/auxiliary/macro_rules.rs
@@ -94,3 +94,19 @@ macro_rules! large_enum_variant {
         }
     };
 }
+
+#[macro_export]
+macro_rules! field_reassign_with_default {
+    () => {
+        #[derive(Default)]
+        struct A {
+            pub i: i32,
+            pub j: i64,
+        }
+        fn lint() {
+            let mut a: A = Default::default();
+            a.i = 42;
+            a;
+        }
+    };
+}
diff --git a/tests/ui/auxiliary/proc_macro_derive.rs b/tests/ui/auxiliary/proc_macro_derive.rs
index 7c4e4a14551..24891682d36 100644
--- a/tests/ui/auxiliary/proc_macro_derive.rs
+++ b/tests/ui/auxiliary/proc_macro_derive.rs
@@ -4,6 +4,7 @@
 #![crate_type = "proc-macro"]
 #![feature(repr128, proc_macro_quote)]
 #![allow(incomplete_features)]
+#![allow(clippy::field_reassign_with_default)]
 #![allow(clippy::eq_op)]
 
 extern crate proc_macro;
@@ -23,3 +24,20 @@ pub fn derive(_: TokenStream) -> TokenStream {
     };
     output
 }
+
+#[proc_macro_derive(FieldReassignWithDefault)]
+pub fn derive_foo(_input: TokenStream) -> TokenStream {
+    quote! {
+        #[derive(Default)]
+        struct A {
+            pub i: i32,
+            pub j: i64,
+        }
+        #[automatically_derived]
+        fn lint() {
+            let mut a: A = Default::default();
+            a.i = 42;
+            a;
+        }
+    }
+}
diff --git a/tests/ui/field_reassign_with_default.rs b/tests/ui/field_reassign_with_default.rs
index 2990397c03e..9fc208f5332 100644
--- a/tests/ui/field_reassign_with_default.rs
+++ b/tests/ui/field_reassign_with_default.rs
@@ -1,5 +1,18 @@
+// aux-build:proc_macro_derive.rs
+// aux-build:macro_rules.rs
+
 #![warn(clippy::field_reassign_with_default)]
 
+#[macro_use]
+extern crate proc_macro_derive;
+#[macro_use]
+extern crate macro_rules;
+
+// Don't lint on derives that derive `Default`
+// See https://github.com/rust-lang/rust-clippy/issues/6545
+#[derive(FieldReassignWithDefault)]
+struct DerivedStruct;
+
 #[derive(Default)]
 struct A {
     i: i32,
@@ -120,6 +133,9 @@ fn main() {
     // don't expand macros in the suggestion (#6522)
     let mut a: C = C::default();
     a.i = vec![1];
+
+    // Don't lint in external macros
+    field_reassign_with_default!();
 }
 
 mod m {
diff --git a/tests/ui/field_reassign_with_default.stderr b/tests/ui/field_reassign_with_default.stderr
index 59d2ac8ed69..2f0f28f7bb7 100644
--- a/tests/ui/field_reassign_with_default.stderr
+++ b/tests/ui/field_reassign_with_default.stderr
@@ -1,84 +1,84 @@
 error: field assignment outside of initializer for an instance created with Default::default()
-  --> $DIR/field_reassign_with_default.rs:35:5
+  --> $DIR/field_reassign_with_default.rs:48:5
    |
 LL |     a.i = 42;
    |     ^^^^^^^^^
    |
    = note: `-D clippy::field-reassign-with-default` implied by `-D warnings`
-note: consider initializing the variable with `A { i: 42, ..Default::default() }` and removing relevant reassignments
-  --> $DIR/field_reassign_with_default.rs:34:5
+note: consider initializing the variable with `main::A { i: 42, ..Default::default() }` and removing relevant reassignments
+  --> $DIR/field_reassign_with_default.rs:47:5
    |
 LL |     let mut a: A = Default::default();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: field assignment outside of initializer for an instance created with Default::default()
-  --> $DIR/field_reassign_with_default.rs:75:5
+  --> $DIR/field_reassign_with_default.rs:88:5
    |
 LL |     a.j = 43;
    |     ^^^^^^^^^
    |
-note: consider initializing the variable with `A { j: 43, i: 42 }` and removing relevant reassignments
-  --> $DIR/field_reassign_with_default.rs:74:5
+note: consider initializing the variable with `main::A { j: 43, i: 42 }` and removing relevant reassignments
+  --> $DIR/field_reassign_with_default.rs:87:5
    |
 LL |     let mut a: A = Default::default();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: field assignment outside of initializer for an instance created with Default::default()
-  --> $DIR/field_reassign_with_default.rs:80:5
+  --> $DIR/field_reassign_with_default.rs:93:5
    |
 LL |     a.i = 42;
    |     ^^^^^^^^^
    |
-note: consider initializing the variable with `A { i: 42, j: 44 }` and removing relevant reassignments
-  --> $DIR/field_reassign_with_default.rs:79:5
+note: consider initializing the variable with `main::A { i: 42, j: 44 }` and removing relevant reassignments
+  --> $DIR/field_reassign_with_default.rs:92:5
    |
 LL |     let mut a: A = Default::default();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: field assignment outside of initializer for an instance created with Default::default()
-  --> $DIR/field_reassign_with_default.rs:86:5
+  --> $DIR/field_reassign_with_default.rs:99:5
    |
 LL |     a.i = 42;
    |     ^^^^^^^^^
    |
-note: consider initializing the variable with `A { i: 42, ..Default::default() }` and removing relevant reassignments
-  --> $DIR/field_reassign_with_default.rs:85:5
+note: consider initializing the variable with `main::A { i: 42, ..Default::default() }` and removing relevant reassignments
+  --> $DIR/field_reassign_with_default.rs:98:5
    |
 LL |     let mut a = A::default();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: field assignment outside of initializer for an instance created with Default::default()
-  --> $DIR/field_reassign_with_default.rs:96:5
+  --> $DIR/field_reassign_with_default.rs:109:5
    |
 LL |     a.i = Default::default();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-note: consider initializing the variable with `A { i: Default::default(), ..Default::default() }` and removing relevant reassignments
-  --> $DIR/field_reassign_with_default.rs:95:5
+note: consider initializing the variable with `main::A { i: Default::default(), ..Default::default() }` and removing relevant reassignments
+  --> $DIR/field_reassign_with_default.rs:108:5
    |
 LL |     let mut a: A = Default::default();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: field assignment outside of initializer for an instance created with Default::default()
-  --> $DIR/field_reassign_with_default.rs:100:5
+  --> $DIR/field_reassign_with_default.rs:113:5
    |
 LL |     a.i = Default::default();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-note: consider initializing the variable with `A { i: Default::default(), j: 45 }` and removing relevant reassignments
-  --> $DIR/field_reassign_with_default.rs:99:5
+note: consider initializing the variable with `main::A { i: Default::default(), j: 45 }` and removing relevant reassignments
+  --> $DIR/field_reassign_with_default.rs:112:5
    |
 LL |     let mut a: A = Default::default();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: field assignment outside of initializer for an instance created with Default::default()
-  --> $DIR/field_reassign_with_default.rs:122:5
+  --> $DIR/field_reassign_with_default.rs:135:5
    |
 LL |     a.i = vec![1];
    |     ^^^^^^^^^^^^^^
    |
 note: consider initializing the variable with `C { i: vec![1], ..Default::default() }` and removing relevant reassignments
-  --> $DIR/field_reassign_with_default.rs:121:5
+  --> $DIR/field_reassign_with_default.rs:134:5
    |
 LL |     let mut a: C = C::default();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From 8a45ffa11dc528749eec50d81e14d993e59b466b Mon Sep 17 00:00:00 2001
From: jekto_vatimeliju <jekto.vatimeliju@gmail.com>
Date: Wed, 6 Jan 2021 20:02:50 +0900
Subject: Fix typo: `which which can be` -> `which can be`

---
 clippy_lints/src/pass_by_ref_or_value.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/pass_by_ref_or_value.rs b/clippy_lints/src/pass_by_ref_or_value.rs
index 6a17d654ac9..c9d9e02717c 100644
--- a/clippy_lints/src/pass_by_ref_or_value.rs
+++ b/clippy_lints/src/pass_by_ref_or_value.rs
@@ -63,7 +63,7 @@ declare_clippy_lint! {
     ///
     /// **Why is this bad?** Arguments passed by value might result in an unnecessary
     /// shallow copy, taking up more space in the stack and requiring a call to
-    /// `memcpy`, which which can be expensive.
+    /// `memcpy`, which can be expensive.
     ///
     /// **Example:**
     ///
-- 
cgit 1.4.1-3-g733a5


From 15d5ac6b2fb411370a4d116a2b3a11dc1b54fb42 Mon Sep 17 00:00:00 2001
From: Stanislav Tkach <stanislav.tkach@gmail.com>
Date: Wed, 6 Jan 2021 13:26:35 +0200
Subject: Remove duplication in the manual_ok_or lint example

---
 clippy_lints/src/manual_ok_or.rs | 3 ---
 1 file changed, 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_ok_or.rs b/clippy_lints/src/manual_ok_or.rs
index b97d97ea1a5..8c77e155b70 100644
--- a/clippy_lints/src/manual_ok_or.rs
+++ b/clippy_lints/src/manual_ok_or.rs
@@ -23,9 +23,6 @@ declare_clippy_lint! {
     /// ```rust
     /// let foo: Option<i32> = None;
     /// foo.map_or(Err("error"), |v| Ok(v));
-    ///
-    /// let foo: Option<i32> = None;
-    /// foo.map_or(Err("error"), |v| Ok(v));
     /// ```
     ///
     /// Use instead:
-- 
cgit 1.4.1-3-g733a5


From f50ded059272ed3c060ea5df353966384d7df427 Mon Sep 17 00:00:00 2001
From: rail <12975677+rail-rain@users.noreply.github.com>
Date: Thu, 7 Jan 2021 16:41:15 +1300
Subject: Catch `pointer::cast` too in `cast_ptr_alignment`

---
 clippy_lints/src/types.rs      | 35 +++++++++++++++++++++++++++++------
 tests/ui/cast_alignment.rs     |  4 ++++
 tests/ui/cast_alignment.stderr | 14 +++++++++++++-
 3 files changed, 46 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs
index b21f81bd517..2d256b38b0d 100644
--- a/clippy_lints/src/types.rs
+++ b/clippy_lints/src/types.rs
@@ -1637,12 +1637,8 @@ impl<'tcx> LateLintPass<'tcx> for Casts {
             return;
         }
         if let ExprKind::Cast(ref ex, cast_to) = expr.kind {
-            if let TyKind::Path(QPath::Resolved(_, path)) = cast_to.kind {
-                if let Res::Def(_, def_id) = path.res {
-                    if cx.tcx.has_attr(def_id, sym::cfg) || cx.tcx.has_attr(def_id, sym::cfg_attr) {
-                        return;
-                    }
-                }
+            if is_hir_ty_cfg_dependant(cx, cast_to) {
+                return;
             }
             let (cast_from, cast_to) = (cx.typeck_results().expr_ty(ex), cx.typeck_results().expr_ty(expr));
             lint_fn_to_numeric_cast(cx, expr, ex, cast_from, cast_to);
@@ -1691,6 +1687,21 @@ impl<'tcx> LateLintPass<'tcx> for Casts {
                 lint_numeric_casts(cx, expr, ex, cast_from, cast_to);
             }
 
+            lint_cast_ptr_alignment(cx, expr, cast_from, cast_to);
+        } else if let ExprKind::MethodCall(method_path, _, args, _) = expr.kind {
+            if method_path.ident.name != sym!(cast) {
+                return;
+            }
+            if_chain! {
+                if let Some(generic_args) = method_path.args;
+                if let [GenericArg::Type(cast_to)] = generic_args.args;
+                // There probably is no obvious reason to do this, just to be consistent with `as` cases.
+                if is_hir_ty_cfg_dependant(cx, cast_to);
+                then {
+                    return;
+                }
+            }
+            let (cast_from, cast_to) = (cx.typeck_results().expr_ty(&args[0]), cx.typeck_results().expr_ty(expr));
             lint_cast_ptr_alignment(cx, expr, cast_from, cast_to);
         }
     }
@@ -1714,6 +1725,18 @@ fn get_numeric_literal<'e>(expr: &'e Expr<'e>) -> Option<&'e Lit> {
     }
 }
 
+fn is_hir_ty_cfg_dependant(cx: &LateContext<'_>, ty: &hir::Ty<'_>) -> bool {
+    if_chain! {
+        if let TyKind::Path(QPath::Resolved(_, path)) = ty.kind;
+        if let Res::Def(_, def_id) = path.res;
+        then {
+            cx.tcx.has_attr(def_id, sym::cfg) || cx.tcx.has_attr(def_id, sym::cfg_attr)
+        } else {
+            false
+        }
+    }
+}
+
 fn show_unnecessary_cast(cx: &LateContext<'_>, expr: &Expr<'_>, literal_str: &str, cast_from: Ty<'_>, cast_to: Ty<'_>) {
     let literal_kind_name = if cast_from.is_integral() { "integer" } else { "float" };
     span_lint_and_sugg(
diff --git a/tests/ui/cast_alignment.rs b/tests/ui/cast_alignment.rs
index 4c08935639f..d011e84b115 100644
--- a/tests/ui/cast_alignment.rs
+++ b/tests/ui/cast_alignment.rs
@@ -12,6 +12,10 @@ fn main() {
     (&1u8 as *const u8) as *const u16;
     (&mut 1u8 as *mut u8) as *mut u16;
 
+    // cast to more-strictly-aligned type, but with the `pointer::cast` function.
+    (&1u8 as *const u8).cast::<u16>();
+    (&mut 1u8 as *mut u8).cast::<u16>();
+
     /* These should be ok */
 
     // not a pointer type
diff --git a/tests/ui/cast_alignment.stderr b/tests/ui/cast_alignment.stderr
index 79219f86155..97e31c130a9 100644
--- a/tests/ui/cast_alignment.stderr
+++ b/tests/ui/cast_alignment.stderr
@@ -12,5 +12,17 @@ error: casting from `*mut u8` to a more-strictly-aligned pointer (`*mut u16`) (1
 LL |     (&mut 1u8 as *mut u8) as *mut u16;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 2 previous errors
+error: casting from `*const u8` to a more-strictly-aligned pointer (`*const u16`) (1 < 2 bytes)
+  --> $DIR/cast_alignment.rs:15:5
+   |
+LL |     (&1u8 as *const u8).cast::<u16>();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: casting from `*mut u8` to a more-strictly-aligned pointer (`*mut u16`) (1 < 2 bytes)
+  --> $DIR/cast_alignment.rs:16:5
+   |
+LL |     (&mut 1u8 as *mut u8).cast::<u16>();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 4 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 2b3c0ade6d34d26698806842eb8d4ad64b64a0ef Mon Sep 17 00:00:00 2001
From: Stanislav Tkach <stanislav.tkach@gmail.com>
Date: Thu, 7 Jan 2021 13:59:55 +0200
Subject: Fix typo: `irrevelent` -> `irrelevant`

---
 clippy_lints/src/ref_option_ref.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/ref_option_ref.rs b/clippy_lints/src/ref_option_ref.rs
index 803ebada54b..8cd6692ce03 100644
--- a/clippy_lints/src/ref_option_ref.rs
+++ b/clippy_lints/src/ref_option_ref.rs
@@ -13,7 +13,7 @@ declare_clippy_lint! {
     /// **Why is this bad?** Since `&` is Copy, it's useless to have a
     /// reference on `Option<&T>`.
     ///
-    /// **Known problems:** It may be irrevelent to use this lint on
+    /// **Known problems:** It may be irrelevant to use this lint on
     /// public API code as it will make a breaking change to apply it.
     ///
     /// **Example:**
-- 
cgit 1.4.1-3-g733a5


From aa9adbf244624a31d3fe7bfbd34c57377fafa682 Mon Sep 17 00:00:00 2001
From: Takayuki Nakata <f.seasons017@gmail.com>
Date: Fri, 8 Jan 2021 08:45:15 +0900
Subject: Small fixes of doc in `needless_question_mark`

---
 clippy_lints/src/needless_question_mark.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/needless_question_mark.rs b/clippy_lints/src/needless_question_mark.rs
index 783e6b716d4..9e9b79ee1cf 100644
--- a/clippy_lints/src/needless_question_mark.rs
+++ b/clippy_lints/src/needless_question_mark.rs
@@ -14,7 +14,7 @@ declare_clippy_lint! {
     /// **What it does:**
     /// Suggests alternatives for useless applications of `?` in terminating expressions
     ///
-    /// **Why is this bad?** There's no reason to use ? to short-circuit when execution of the body will end there anyway.
+    /// **Why is this bad?** There's no reason to use `?` to short-circuit when execution of the body will end there anyway.
     ///
     /// **Known problems:** None.
     ///
@@ -58,7 +58,7 @@ declare_clippy_lint! {
     /// ```
     pub NEEDLESS_QUESTION_MARK,
     complexity,
-    "Suggest value.inner_option instead of Some(value.inner_option?). The same goes for Result<T, E>."
+    "Suggest `value.inner_option` instead of `Some(value.inner_option?)`. The same goes for `Result<T, E>`."
 }
 
 const NEEDLESS_QUESTION_MARK_RESULT_MSRV: RustcVersion = RustcVersion::new(1, 13, 0);
-- 
cgit 1.4.1-3-g733a5


From 0e14a7550632f9bbe4e0f0b5589a8c38b55d649b Mon Sep 17 00:00:00 2001
From: Takayuki Nakata <f.seasons017@gmail.com>
Date: Fri, 8 Jan 2021 08:37:57 +0900
Subject: Reduce the span in `from_over_into` to impl header

---
 clippy_lints/src/from_over_into.rs | 2 +-
 tests/ui/from_over_into.stderr     | 8 ++------
 2 files changed, 3 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/from_over_into.rs b/clippy_lints/src/from_over_into.rs
index 1e7e5f53cc2..b010abda24d 100644
--- a/clippy_lints/src/from_over_into.rs
+++ b/clippy_lints/src/from_over_into.rs
@@ -70,7 +70,7 @@ impl LateLintPass<'_> for FromOverInto {
                 span_lint_and_help(
                     cx,
                     FROM_OVER_INTO,
-                    item.span,
+                    cx.tcx.sess.source_map().guess_head_span(item.span),
                     "an implementation of `From` is preferred since it gives you `Into<_>` for free where the reverse isn't true",
                     None,
                     "consider to implement `From` instead",
diff --git a/tests/ui/from_over_into.stderr b/tests/ui/from_over_into.stderr
index 18f56f85432..b101d2704fb 100644
--- a/tests/ui/from_over_into.stderr
+++ b/tests/ui/from_over_into.stderr
@@ -1,12 +1,8 @@
 error: an implementation of `From` is preferred since it gives you `Into<_>` for free where the reverse isn't true
   --> $DIR/from_over_into.rs:6:1
    |
-LL | / impl Into<StringWrapper> for String {
-LL | |     fn into(self) -> StringWrapper {
-LL | |         StringWrapper(self)
-LL | |     }
-LL | | }
-   | |_^
+LL | impl Into<StringWrapper> for String {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::from-over-into` implied by `-D warnings`
    = help: consider to implement `From` instead
-- 
cgit 1.4.1-3-g733a5


From ee9b47dae61cd34ee7cbcb013a72b5f162148e4a Mon Sep 17 00:00:00 2001
From: rail <12975677+rail-rain@users.noreply.github.com>
Date: Fri, 8 Jan 2021 14:15:12 +1300
Subject: Move `is_hir_ty_cfg_dependant` to `util`,

add stuff on pointer::cast` to the document for `cast_ptr_alignment`
and fix line numbers in the test.
---
 clippy_lints/src/types.rs      | 26 ++++++++------------------
 clippy_lints/src/utils/mod.rs  | 12 ++++++++++++
 tests/ui/cast_alignment.stderr |  4 ++--
 3 files changed, 22 insertions(+), 20 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs
index 2d256b38b0d..765a0569007 100644
--- a/clippy_lints/src/types.rs
+++ b/clippy_lints/src/types.rs
@@ -8,7 +8,6 @@ use if_chain::if_chain;
 use rustc_ast::{FloatTy, IntTy, LitFloatType, LitIntType, LitKind, UintTy};
 use rustc_errors::{Applicability, DiagnosticBuilder};
 use rustc_hir as hir;
-use rustc_hir::def::Res;
 use rustc_hir::intravisit::{walk_body, walk_expr, walk_ty, FnKind, NestedVisitorMap, Visitor};
 use rustc_hir::{
     BinOpKind, Block, Body, Expr, ExprKind, FnDecl, FnRetTy, FnSig, GenericArg, GenericBounds, GenericParamKind, HirId,
@@ -33,9 +32,9 @@ use crate::consts::{constant, Constant};
 use crate::utils::paths;
 use crate::utils::sugg::Sugg;
 use crate::utils::{
-    clip, comparisons, differing_macro_contexts, higher, in_constant, indent_of, int_bits, is_type_diagnostic_item,
-    last_path_segment, match_def_path, match_path, meets_msrv, method_chain_args, multispan_sugg,
-    numeric_literal::NumericLiteral, qpath_res, reindent_multiline, sext, snippet, snippet_opt,
+    clip, comparisons, differing_macro_contexts, higher, in_constant, indent_of, int_bits, is_hir_ty_cfg_dependant,
+    is_type_diagnostic_item, last_path_segment, match_def_path, match_path, meets_msrv, method_chain_args,
+    multispan_sugg, numeric_literal::NumericLiteral, qpath_res, reindent_multiline, sext, snippet, snippet_opt,
     snippet_with_applicability, snippet_with_macro_callsite, span_lint, span_lint_and_help, span_lint_and_sugg,
     span_lint_and_then, unsext,
 };
@@ -1282,8 +1281,8 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for casts from a less-strictly-aligned pointer to a
-    /// more-strictly-aligned pointer
+    /// **What it does:** Checks for casts, using `as` or `pointer::cast`,
+    /// from a less-strictly-aligned pointer to a more-strictly-aligned pointer
     ///
     /// **Why is this bad?** Dereferencing the resulting pointer may be undefined
     /// behavior.
@@ -1296,6 +1295,9 @@ declare_clippy_lint! {
     /// ```rust
     /// let _ = (&1u8 as *const u8) as *const u16;
     /// let _ = (&mut 1u8 as *mut u8) as *mut u16;
+    ///
+    /// (&1u8 as *const u8).cast::<u16>();
+    /// (&mut 1u8 as *mut u8).cast::<u16>();
     /// ```
     pub CAST_PTR_ALIGNMENT,
     pedantic,
@@ -1725,18 +1727,6 @@ fn get_numeric_literal<'e>(expr: &'e Expr<'e>) -> Option<&'e Lit> {
     }
 }
 
-fn is_hir_ty_cfg_dependant(cx: &LateContext<'_>, ty: &hir::Ty<'_>) -> bool {
-    if_chain! {
-        if let TyKind::Path(QPath::Resolved(_, path)) = ty.kind;
-        if let Res::Def(_, def_id) = path.res;
-        then {
-            cx.tcx.has_attr(def_id, sym::cfg) || cx.tcx.has_attr(def_id, sym::cfg_attr)
-        } else {
-            false
-        }
-    }
-}
-
 fn show_unnecessary_cast(cx: &LateContext<'_>, expr: &Expr<'_>, literal_str: &str, cast_from: Ty<'_>, cast_to: Ty<'_>) {
     let literal_kind_name = if cast_from.is_integral() { "integer" } else { "float" };
     span_lint_and_sugg(
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index 8f54cad7728..27f4cb2b254 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -1686,6 +1686,18 @@ macro_rules! unwrap_cargo_metadata {
     }};
 }
 
+pub fn is_hir_ty_cfg_dependant(cx: &LateContext<'_>, ty: &hir::Ty<'_>) -> bool {
+    if_chain! {
+        if let TyKind::Path(QPath::Resolved(_, path)) = ty.kind;
+        if let Res::Def(_, def_id) = path.res;
+        then {
+            cx.tcx.has_attr(def_id, sym::cfg) || cx.tcx.has_attr(def_id, sym::cfg_attr)
+        } else {
+            false
+        }
+    }
+}
+
 #[cfg(test)]
 mod test {
     use super::{reindent_multiline, without_block_comments};
diff --git a/tests/ui/cast_alignment.stderr b/tests/ui/cast_alignment.stderr
index 97e31c130a9..7998b787b91 100644
--- a/tests/ui/cast_alignment.stderr
+++ b/tests/ui/cast_alignment.stderr
@@ -13,13 +13,13 @@ LL |     (&mut 1u8 as *mut u8) as *mut u16;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: casting from `*const u8` to a more-strictly-aligned pointer (`*const u16`) (1 < 2 bytes)
-  --> $DIR/cast_alignment.rs:15:5
+  --> $DIR/cast_alignment.rs:16:5
    |
 LL |     (&1u8 as *const u8).cast::<u16>();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: casting from `*mut u8` to a more-strictly-aligned pointer (`*mut u16`) (1 < 2 bytes)
-  --> $DIR/cast_alignment.rs:16:5
+  --> $DIR/cast_alignment.rs:17:5
    |
 LL |     (&mut 1u8 as *mut u8).cast::<u16>();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From 8490862cc37d7518c79d09d7911d86bfca2cea89 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Wed, 6 Jan 2021 15:14:01 -0600
Subject: Fix path_to_res for enum inherent items

---
 clippy_lints/src/utils/mod.rs      | 96 +++++++++++++++-----------------------
 tests/ui-internal/invalid_paths.rs |  3 ++
 2 files changed, 40 insertions(+), 59 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index 8f54cad7728..b2c9d4f8739 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -31,7 +31,6 @@ pub use self::hir_utils::{both, eq_expr_value, over, SpanlessEq, SpanlessHash};
 use std::borrow::Cow;
 use std::collections::hash_map::Entry;
 use std::hash::BuildHasherDefault;
-use std::mem;
 
 use if_chain::if_chain;
 use rustc_ast::ast::{self, Attribute, LitKind};
@@ -40,7 +39,7 @@ use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_hir::def::{DefKind, Res};
-use rustc_hir::def_id::{DefId, CRATE_DEF_INDEX, LOCAL_CRATE};
+use rustc_hir::def_id::{DefId, LOCAL_CRATE};
 use rustc_hir::intravisit::{self, NestedVisitorMap, Visitor};
 use rustc_hir::Node;
 use rustc_hir::{
@@ -49,6 +48,7 @@ use rustc_hir::{
 };
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::{LateContext, Level, Lint, LintContext};
+use rustc_middle::hir::exports::Export;
 use rustc_middle::hir::map::Map;
 use rustc_middle::ty::subst::{GenericArg, GenericArgKind};
 use rustc_middle::ty::{self, layout::IntegerExt, Ty, TyCtxt, TypeFoldable};
@@ -309,65 +309,43 @@ pub fn match_path_ast(path: &ast::Path, segments: &[&str]) -> bool {
 }
 
 /// Gets the definition associated to a path.
-pub fn path_to_res(cx: &LateContext<'_>, path: &[&str]) -> Option<def::Res> {
-    let crates = cx.tcx.crates();
-    let krate = crates
-        .iter()
-        .find(|&&krate| cx.tcx.crate_name(krate).as_str() == path[0]);
-    if let Some(krate) = krate {
-        let krate = DefId {
-            krate: *krate,
-            index: CRATE_DEF_INDEX,
-        };
-        let mut current_item = None;
-        let mut items = cx.tcx.item_children(krate);
-        let mut path_it = path.iter().skip(1).peekable();
-
-        loop {
-            let segment = match path_it.next() {
-                Some(segment) => segment,
-                None => return None,
-            };
-
-            // `get_def_path` seems to generate these empty segments for extern blocks.
-            // We can just ignore them.
-            if segment.is_empty() {
-                continue;
-            }
-
-            let result = SmallVec::<[_; 8]>::new();
-            for item in mem::replace(&mut items, cx.tcx.arena.alloc_slice(&result)).iter() {
-                if item.ident.name.as_str() == *segment {
-                    if path_it.peek().is_none() {
-                        return Some(item.res);
-                    }
-
-                    current_item = Some(item);
-                    items = cx.tcx.item_children(item.res.def_id());
-                    break;
-                }
-            }
+#[allow(clippy::shadow_unrelated)] // false positive #6563
+pub fn path_to_res(cx: &LateContext<'_>, path: &[&str]) -> Option<Res> {
+    fn item_child_by_name<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId, name: &str) -> Option<&'tcx Export<HirId>> {
+        tcx.item_children(def_id)
+            .iter()
+            .find(|item| item.ident.name.as_str() == name)
+    }
 
-            // The segment isn't a child_item.
-            // Try to find it under an inherent impl.
-            if_chain! {
-                if path_it.peek().is_none();
-                if let Some(current_item) = current_item;
-                let item_def_id = current_item.res.def_id();
-                if cx.tcx.def_kind(item_def_id) == DefKind::Struct;
-                then {
-                    // Bad `find_map` suggestion. See #4193.
-                    #[allow(clippy::find_map)]
-                    return cx.tcx.inherent_impls(item_def_id).iter()
-                        .flat_map(|&impl_def_id| cx.tcx.item_children(impl_def_id))
-                        .find(|item| item.ident.name.as_str() == *segment)
-                        .map(|item| item.res);
-                }
+    let (krate, first, path) = match *path {
+        [krate, first, ref path @ ..] => (krate, first, path),
+        _ => return None,
+    };
+    let tcx = cx.tcx;
+    let crates = tcx.crates();
+    let krate = crates.iter().find(|&&num| tcx.crate_name(num).as_str() == krate)?;
+    let first = item_child_by_name(tcx, krate.as_def_id(), first)?;
+    let last = path
+        .iter()
+        .copied()
+        // `get_def_path` seems to generate these empty segments for extern blocks.
+        // We can just ignore them.
+        .filter(|segment| !segment.is_empty())
+        // for each segment, find the child item
+        .try_fold(first, |item, segment| {
+            let def_id = item.res.def_id();
+            if let Some(item) = item_child_by_name(tcx, def_id, segment) {
+                Some(item)
+            } else if matches!(item.res, Res::Def(DefKind::Enum | DefKind::Struct, _)) {
+                // it is not a child item so check inherent impl items
+                tcx.inherent_impls(def_id)
+                    .iter()
+                    .find_map(|&impl_def_id| item_child_by_name(tcx, impl_def_id, segment))
+            } else {
+                None
             }
-        }
-    } else {
-        None
-    }
+        })?;
+    Some(last.res)
 }
 
 pub fn qpath_res(cx: &LateContext<'_>, qpath: &hir::QPath<'_>, id: hir::HirId) -> Res {
diff --git a/tests/ui-internal/invalid_paths.rs b/tests/ui-internal/invalid_paths.rs
index 01e28ae5e9d..a3b19c2e394 100644
--- a/tests/ui-internal/invalid_paths.rs
+++ b/tests/ui-internal/invalid_paths.rs
@@ -18,6 +18,9 @@ mod paths {
 
     // Path with bad module
     pub const BAD_MOD_PATH: [&str; 2] = ["std", "xxx"];
+
+    // Path to method on an enum inherent impl
+    pub const OPTION_IS_SOME: [&str; 4] = ["core", "option", "Option", "is_some"];
 }
 
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 24c700b5d70f063521435c450ae1b48720b5f991 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Wed, 30 Dec 2020 15:38:21 -0600
Subject: Use DefId in interning defined symbol lint

---
 clippy_lints/src/utils/internal_lints.rs          | 11 ++++++-----
 tests/ui-internal/interning_defined_symbol.fixed  |  6 +++---
 tests/ui-internal/interning_defined_symbol.stderr |  6 +++---
 3 files changed, 12 insertions(+), 11 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs
index 9ba39f73ee8..945aaa4668c 100644
--- a/clippy_lints/src/utils/internal_lints.rs
+++ b/clippy_lints/src/utils/internal_lints.rs
@@ -10,6 +10,7 @@ use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_hir::def::{DefKind, Res};
+use rustc_hir::def_id::DefId;
 use rustc_hir::hir_id::CRATE_HIR_ID;
 use rustc_hir::intravisit::{NestedVisitorMap, Visitor};
 use rustc_hir::{Crate, Expr, ExprKind, HirId, Item, MutTy, Mutability, Node, Path, StmtKind, Ty, TyKind};
@@ -868,8 +869,8 @@ impl<'tcx> LateLintPass<'tcx> for InvalidPaths {
 
 #[derive(Default)]
 pub struct InterningDefinedSymbol {
-    // Maps the symbol value to the constant name.
-    symbol_map: FxHashMap<u32, String>,
+    // Maps the symbol value to the constant DefId.
+    symbol_map: FxHashMap<u32, DefId>,
 }
 
 impl_lint_pass!(InterningDefinedSymbol => [INTERNING_DEFINED_SYMBOL]);
@@ -889,7 +890,7 @@ impl<'tcx> LateLintPass<'tcx> for InterningDefinedSymbol {
                     if let Ok(ConstValue::Scalar(value)) = cx.tcx.const_eval_poly(item_def_id);
                     if let Ok(value) = value.to_u32();
                     then {
-                        self.symbol_map.insert(value, item.ident.to_string());
+                        self.symbol_map.insert(value, item_def_id);
                     }
                 }
             }
@@ -903,7 +904,7 @@ impl<'tcx> LateLintPass<'tcx> for InterningDefinedSymbol {
             if match_def_path(cx, *def_id, &paths::SYMBOL_INTERN);
             if let Some(Constant::Str(arg)) = constant_simple(cx, cx.typeck_results(), arg);
             let value = Symbol::intern(&arg).as_u32();
-            if let Some(symbol_const) = self.symbol_map.get(&value);
+            if let Some(&def_id) = self.symbol_map.get(&value);
             then {
                 span_lint_and_sugg(
                     cx,
@@ -911,7 +912,7 @@ impl<'tcx> LateLintPass<'tcx> for InterningDefinedSymbol {
                     is_expn_of(expr.span, "sym").unwrap_or(expr.span),
                     "interning a defined symbol",
                     "try",
-                    format!("rustc_span::symbol::sym::{}", symbol_const),
+                    cx.tcx.def_path_str(def_id),
                     Applicability::MachineApplicable,
                 );
             }
diff --git a/tests/ui-internal/interning_defined_symbol.fixed b/tests/ui-internal/interning_defined_symbol.fixed
index c6b84d2ef65..2af362b8f99 100644
--- a/tests/ui-internal/interning_defined_symbol.fixed
+++ b/tests/ui-internal/interning_defined_symbol.fixed
@@ -14,13 +14,13 @@ macro_rules! sym {
 
 fn main() {
     // Direct use of Symbol::intern
-    let _ = rustc_span::symbol::sym::f32;
+    let _ = rustc_span::sym::f32;
 
     // Using a sym macro
-    let _ = rustc_span::symbol::sym::f32;
+    let _ = rustc_span::sym::f32;
 
     // Correct suggestion when symbol isn't stringified constant name
-    let _ = rustc_span::symbol::sym::proc_dash_macro;
+    let _ = rustc_span::sym::proc_dash_macro;
 
     // Interning a symbol that is not defined
     let _ = Symbol::intern("xyz123");
diff --git a/tests/ui-internal/interning_defined_symbol.stderr b/tests/ui-internal/interning_defined_symbol.stderr
index 74b906c8a57..d7e1d62d51a 100644
--- a/tests/ui-internal/interning_defined_symbol.stderr
+++ b/tests/ui-internal/interning_defined_symbol.stderr
@@ -2,7 +2,7 @@ error: interning a defined symbol
   --> $DIR/interning_defined_symbol.rs:17:13
    |
 LL |     let _ = Symbol::intern("f32");
-   |             ^^^^^^^^^^^^^^^^^^^^^ help: try: `rustc_span::symbol::sym::f32`
+   |             ^^^^^^^^^^^^^^^^^^^^^ help: try: `rustc_span::sym::f32`
    |
 note: the lint level is defined here
   --> $DIR/interning_defined_symbol.rs:2:9
@@ -15,13 +15,13 @@ error: interning a defined symbol
   --> $DIR/interning_defined_symbol.rs:20:13
    |
 LL |     let _ = sym!(f32);
-   |             ^^^^^^^^^ help: try: `rustc_span::symbol::sym::f32`
+   |             ^^^^^^^^^ help: try: `rustc_span::sym::f32`
 
 error: interning a defined symbol
   --> $DIR/interning_defined_symbol.rs:23:13
    |
 LL |     let _ = Symbol::intern("proc-macro");
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `rustc_span::symbol::sym::proc_dash_macro`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `rustc_span::sym::proc_dash_macro`
 
 error: aborting due to 3 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 121c65f0cf2bf488128c60dc6c20a947bb1bb1ca Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Tue, 29 Dec 2020 15:40:55 -0600
Subject: Add keywords to interning defined symbol lint

---
 clippy_lints/src/utils/internal_lints.rs          | 22 ++++++++++++----------
 clippy_lints/src/utils/paths.rs                   |  2 ++
 tests/ui-internal/interning_defined_symbol.fixed  |  3 +++
 tests/ui-internal/interning_defined_symbol.rs     |  3 +++
 tests/ui-internal/interning_defined_symbol.stderr |  8 +++++++-
 5 files changed, 27 insertions(+), 11 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs
index 945aaa4668c..c0b6688fa15 100644
--- a/clippy_lints/src/utils/internal_lints.rs
+++ b/clippy_lints/src/utils/internal_lints.rs
@@ -881,16 +881,18 @@ impl<'tcx> LateLintPass<'tcx> for InterningDefinedSymbol {
             return;
         }
 
-        if let Some(Res::Def(_, def_id)) = path_to_res(cx, &paths::SYM_MODULE) {
-            for item in cx.tcx.item_children(def_id).iter() {
-                if_chain! {
-                    if let Res::Def(DefKind::Const, item_def_id) = item.res;
-                    let ty = cx.tcx.type_of(item_def_id);
-                    if match_type(cx, ty, &paths::SYMBOL);
-                    if let Ok(ConstValue::Scalar(value)) = cx.tcx.const_eval_poly(item_def_id);
-                    if let Ok(value) = value.to_u32();
-                    then {
-                        self.symbol_map.insert(value, item_def_id);
+        for &module in &[&paths::KW_MODULE, &paths::SYM_MODULE] {
+            if let Some(Res::Def(_, def_id)) = path_to_res(cx, module) {
+                for item in cx.tcx.item_children(def_id).iter() {
+                    if_chain! {
+                        if let Res::Def(DefKind::Const, item_def_id) = item.res;
+                        let ty = cx.tcx.type_of(item_def_id);
+                        if match_type(cx, ty, &paths::SYMBOL);
+                        if let Ok(ConstValue::Scalar(value)) = cx.tcx.const_eval_poly(item_def_id);
+                        if let Ok(value) = value.to_u32();
+                        then {
+                            self.symbol_map.insert(value, item_def_id);
+                        }
                     }
                 }
             }
diff --git a/clippy_lints/src/utils/paths.rs b/clippy_lints/src/utils/paths.rs
index 2080a49a11c..3179be6af2a 100644
--- a/clippy_lints/src/utils/paths.rs
+++ b/clippy_lints/src/utils/paths.rs
@@ -65,6 +65,8 @@ pub const IPADDR_V4: [&str; 4] = ["std", "net", "IpAddr", "V4"];
 pub const IPADDR_V6: [&str; 4] = ["std", "net", "IpAddr", "V6"];
 pub const ITERATOR: [&str; 5] = ["core", "iter", "traits", "iterator", "Iterator"];
 #[cfg(feature = "internal-lints")]
+pub const KW_MODULE: [&str; 3] = ["rustc_span", "symbol", "kw"];
+#[cfg(feature = "internal-lints")]
 pub const LATE_CONTEXT: [&str; 2] = ["rustc_lint", "LateContext"];
 pub const LINKED_LIST: [&str; 4] = ["alloc", "collections", "linked_list", "LinkedList"];
 #[cfg(feature = "internal-lints")]
diff --git a/tests/ui-internal/interning_defined_symbol.fixed b/tests/ui-internal/interning_defined_symbol.fixed
index 2af362b8f99..9ab845a573a 100644
--- a/tests/ui-internal/interning_defined_symbol.fixed
+++ b/tests/ui-internal/interning_defined_symbol.fixed
@@ -22,6 +22,9 @@ fn main() {
     // Correct suggestion when symbol isn't stringified constant name
     let _ = rustc_span::sym::proc_dash_macro;
 
+    // interning a keyword
+    let _ = rustc_span::symbol::kw::SelfLower;
+
     // Interning a symbol that is not defined
     let _ = Symbol::intern("xyz123");
     let _ = sym!(xyz123);
diff --git a/tests/ui-internal/interning_defined_symbol.rs b/tests/ui-internal/interning_defined_symbol.rs
index 9ec82d4ad0b..a58e182971d 100644
--- a/tests/ui-internal/interning_defined_symbol.rs
+++ b/tests/ui-internal/interning_defined_symbol.rs
@@ -22,6 +22,9 @@ fn main() {
     // Correct suggestion when symbol isn't stringified constant name
     let _ = Symbol::intern("proc-macro");
 
+    // interning a keyword
+    let _ = Symbol::intern("self");
+
     // Interning a symbol that is not defined
     let _ = Symbol::intern("xyz123");
     let _ = sym!(xyz123);
diff --git a/tests/ui-internal/interning_defined_symbol.stderr b/tests/ui-internal/interning_defined_symbol.stderr
index d7e1d62d51a..50c1c268eb1 100644
--- a/tests/ui-internal/interning_defined_symbol.stderr
+++ b/tests/ui-internal/interning_defined_symbol.stderr
@@ -23,5 +23,11 @@ error: interning a defined symbol
 LL |     let _ = Symbol::intern("proc-macro");
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `rustc_span::sym::proc_dash_macro`
 
-error: aborting due to 3 previous errors
+error: interning a defined symbol
+  --> $DIR/interning_defined_symbol.rs:26:13
+   |
+LL |     let _ = Symbol::intern("self");
+   |             ^^^^^^^^^^^^^^^^^^^^^^ help: try: `rustc_span::symbol::kw::SelfLower`
+
+error: aborting due to 4 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 76ccfb4ae24e1b6f3398e5cca350e41e76723fb1 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Tue, 29 Dec 2020 15:43:18 -0600
Subject: Fix unnecessary keyword intern dogfood

---
 clippy_lints/src/write.rs | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs
index 337f7a229b9..af324f831df 100644
--- a/clippy_lints/src/write.rs
+++ b/clippy_lints/src/write.rs
@@ -10,7 +10,8 @@ use rustc_lexer::unescape::{self, EscapeError};
 use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_parse::parser;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::{sym, BytePos, Span, Symbol};
+use rustc_span::symbol::kw;
+use rustc_span::{sym, BytePos, Span};
 
 declare_clippy_lint! {
     /// **What it does:** This lint warns when you use `println!("")` to
@@ -301,7 +302,7 @@ impl EarlyLintPass for Write {
             }
         } else if mac.path == sym!(writeln) {
             if let (Some(fmt_str), expr) = self.check_tts(cx, mac.args.inner_tokens(), true) {
-                if fmt_str.symbol == Symbol::intern("") {
+                if fmt_str.symbol == kw::Empty {
                     let mut applicability = Applicability::MachineApplicable;
                     // FIXME: remove this `#[allow(...)]` once the issue #5822 gets fixed
                     #[allow(clippy::option_if_let_else)]
@@ -484,7 +485,7 @@ impl Write {
 
     fn lint_println_empty_string(&self, cx: &EarlyContext<'_>, mac: &MacCall) {
         if let (Some(fmt_str), _) = self.check_tts(cx, mac.args.inner_tokens(), false) {
-            if fmt_str.symbol == Symbol::intern("") {
+            if fmt_str.symbol == kw::Empty {
                 let name = mac.path.segments[0].ident.name;
                 span_lint_and_sugg(
                     cx,
-- 
cgit 1.4.1-3-g733a5


From cc26919b4dcfbb31a0eb902e8cf3e009a93e5ac8 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Wed, 30 Dec 2020 15:52:15 -0600
Subject: Add unnecessary symbol string lint

---
 clippy_lints/src/lib.rs                         |   3 +
 clippy_lints/src/utils/internal_lints.rs        | 153 +++++++++++++++++++++++-
 clippy_lints/src/utils/paths.rs                 |   8 ++
 tests/ui-internal/unnecessary_symbol_str.fixed  |  16 +++
 tests/ui-internal/unnecessary_symbol_str.rs     |  16 +++
 tests/ui-internal/unnecessary_symbol_str.stderr |  39 ++++++
 6 files changed, 233 insertions(+), 2 deletions(-)
 create mode 100644 tests/ui-internal/unnecessary_symbol_str.fixed
 create mode 100644 tests/ui-internal/unnecessary_symbol_str.rs
 create mode 100644 tests/ui-internal/unnecessary_symbol_str.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 37a56bc20c8..f12994c7a60 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -526,6 +526,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &utils::internal_lints::OUTER_EXPN_EXPN_DATA,
         #[cfg(feature = "internal-lints")]
         &utils::internal_lints::PRODUCE_ICE,
+        #[cfg(feature = "internal-lints")]
+        &utils::internal_lints::UNNECESSARY_SYMBOL_STR,
         &approx_const::APPROX_CONSTANT,
         &arithmetic::FLOAT_ARITHMETIC,
         &arithmetic::INTEGER_ARITHMETIC,
@@ -1372,6 +1374,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&utils::internal_lints::MATCH_TYPE_ON_DIAGNOSTIC_ITEM),
         LintId::of(&utils::internal_lints::OUTER_EXPN_EXPN_DATA),
         LintId::of(&utils::internal_lints::PRODUCE_ICE),
+        LintId::of(&utils::internal_lints::UNNECESSARY_SYMBOL_STR),
     ]);
 
     store.register_group(true, "clippy::all", Some("clippy"), vec![
diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs
index c0b6688fa15..59a1852aba9 100644
--- a/clippy_lints/src/utils/internal_lints.rs
+++ b/clippy_lints/src/utils/internal_lints.rs
@@ -13,7 +13,9 @@ use rustc_hir::def::{DefKind, Res};
 use rustc_hir::def_id::DefId;
 use rustc_hir::hir_id::CRATE_HIR_ID;
 use rustc_hir::intravisit::{NestedVisitorMap, Visitor};
-use rustc_hir::{Crate, Expr, ExprKind, HirId, Item, MutTy, Mutability, Node, Path, StmtKind, Ty, TyKind};
+use rustc_hir::{
+    BinOpKind, Crate, Expr, ExprKind, HirId, Item, MutTy, Mutability, Node, Path, StmtKind, Ty, TyKind, UnOp,
+};
 use rustc_lint::{EarlyContext, EarlyLintPass, LateContext, LateLintPass};
 use rustc_middle::hir::map::Map;
 use rustc_middle::mir::interpret::ConstValue;
@@ -273,6 +275,28 @@ declare_clippy_lint! {
     "interning a symbol that is pre-interned and defined as a constant"
 }
 
+declare_clippy_lint! {
+    /// **What it does:** Checks for unnecessary conversion from Symbol to a string.
+    ///
+    /// **Why is this bad?** It's faster use symbols directly intead of strings.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// Bad:
+    /// ```rust,ignore
+    /// symbol.as_str() == "clippy";
+    /// ```
+    ///
+    /// Good:
+    /// ```rust,ignore
+    /// symbol == sym::clippy;
+    /// ```
+    pub UNNECESSARY_SYMBOL_STR,
+    internal,
+    "unnecessary conversion between Symbol and string"
+}
+
 declare_lint_pass!(ClippyLintsInternal => [CLIPPY_LINTS_INTERNAL]);
 
 impl EarlyLintPass for ClippyLintsInternal {
@@ -873,7 +897,7 @@ pub struct InterningDefinedSymbol {
     symbol_map: FxHashMap<u32, DefId>,
 }
 
-impl_lint_pass!(InterningDefinedSymbol => [INTERNING_DEFINED_SYMBOL]);
+impl_lint_pass!(InterningDefinedSymbol => [INTERNING_DEFINED_SYMBOL, UNNECESSARY_SYMBOL_STR]);
 
 impl<'tcx> LateLintPass<'tcx> for InterningDefinedSymbol {
     fn check_crate(&mut self, cx: &LateContext<'_>, _: &Crate<'_>) {
@@ -919,5 +943,130 @@ impl<'tcx> LateLintPass<'tcx> for InterningDefinedSymbol {
                 );
             }
         }
+        if let ExprKind::Binary(op, left, right) = expr.kind {
+            if matches!(op.node, BinOpKind::Eq | BinOpKind::Ne) {
+                let data = [
+                    (left, self.symbol_str_expr(left, cx)),
+                    (right, self.symbol_str_expr(right, cx)),
+                ];
+                match data {
+                    // both operands are a symbol string
+                    [(_, Some(left)), (_, Some(right))] => {
+                        span_lint_and_sugg(
+                            cx,
+                            UNNECESSARY_SYMBOL_STR,
+                            expr.span,
+                            "unnecessary `Symbol` to string conversion",
+                            "try",
+                            format!(
+                                "{} {} {}",
+                                left.as_symbol_snippet(cx),
+                                op.node.as_str(),
+                                right.as_symbol_snippet(cx),
+                            ),
+                            Applicability::MachineApplicable,
+                        );
+                    },
+                    // one of the operands is a symbol string
+                    [(expr, Some(symbol)), _] | [_, (expr, Some(symbol))] => {
+                        // creating an owned string for comparison
+                        if matches!(symbol, SymbolStrExpr::Expr { is_to_owned: true, .. }) {
+                            span_lint_and_sugg(
+                                cx,
+                                UNNECESSARY_SYMBOL_STR,
+                                expr.span,
+                                "unnecessary string allocation",
+                                "try",
+                                format!("{}.as_str()", symbol.as_symbol_snippet(cx)),
+                                Applicability::MachineApplicable,
+                            );
+                        }
+                    },
+                    // nothing found
+                    [(_, None), (_, None)] => {},
+                }
+            }
+        }
+    }
+}
+
+impl InterningDefinedSymbol {
+    fn symbol_str_expr<'tcx>(&self, expr: &'tcx Expr<'tcx>, cx: &LateContext<'tcx>) -> Option<SymbolStrExpr<'tcx>> {
+        static IDENT_STR_PATHS: &[&[&str]] = &[&paths::IDENT_AS_STR, &paths::TO_STRING_METHOD];
+        static SYMBOL_STR_PATHS: &[&[&str]] = &[
+            &paths::SYMBOL_AS_STR,
+            &paths::SYMBOL_TO_IDENT_STRING,
+            &paths::TO_STRING_METHOD,
+        ];
+        // SymbolStr might be de-referenced: `&*symbol.as_str()`
+        let call = if_chain! {
+            if let ExprKind::AddrOf(_, _, e) = expr.kind;
+            if let ExprKind::Unary(UnOp::UnDeref, e) = e.kind;
+            then { e } else { expr }
+        };
+        if_chain! {
+            // is a method call
+            if let ExprKind::MethodCall(_, _, [item], _) = call.kind;
+            if let Some(did) = cx.typeck_results().type_dependent_def_id(call.hir_id);
+            let ty = cx.typeck_results().expr_ty(item);
+            // ...on either an Ident or a Symbol
+            if let Some(is_ident) = if match_type(cx, ty, &paths::SYMBOL) {
+                Some(false)
+            } else if match_type(cx, ty, &paths::IDENT) {
+                Some(true)
+            } else {
+                None
+            };
+            // ...which converts it to a string
+            let paths = if is_ident { IDENT_STR_PATHS } else { SYMBOL_STR_PATHS };
+            if let Some(path) = paths.iter().find(|path| match_def_path(cx, did, path));
+            then {
+                let is_to_owned = path.last().unwrap().ends_with("string");
+                return Some(SymbolStrExpr::Expr {
+                    item,
+                    is_ident,
+                    is_to_owned,
+                });
+            }
+        }
+        // is a string constant
+        if let Some(Constant::Str(s)) = constant_simple(cx, cx.typeck_results(), expr) {
+            let value = Symbol::intern(&s).as_u32();
+            // ...which matches a symbol constant
+            if let Some(&def_id) = self.symbol_map.get(&value) {
+                return Some(SymbolStrExpr::Const(def_id));
+            }
+        }
+        None
+    }
+}
+
+enum SymbolStrExpr<'tcx> {
+    /// a string constant with a corresponding symbol constant
+    Const(DefId),
+    /// a "symbol to string" expression like `symbol.as_str()`
+    Expr {
+        /// part that evaluates to `Symbol` or `Ident`
+        item: &'tcx Expr<'tcx>,
+        is_ident: bool,
+        /// whether an owned `String` is created like `to_ident_string()`
+        is_to_owned: bool,
+    },
+}
+
+impl<'tcx> SymbolStrExpr<'tcx> {
+    /// Returns a snippet that evaluates to a `Symbol` and is const if possible
+    fn as_symbol_snippet(&self, cx: &LateContext<'_>) -> Cow<'tcx, str> {
+        match *self {
+            Self::Const(def_id) => cx.tcx.def_path_str(def_id).into(),
+            Self::Expr { item, is_ident, .. } => {
+                let mut snip = snippet(cx, item.span.source_callsite(), "..");
+                if is_ident {
+                    // get `Ident.name`
+                    snip.to_mut().push_str(".name");
+                }
+                snip
+            },
+        }
     }
 }
diff --git a/clippy_lints/src/utils/paths.rs b/clippy_lints/src/utils/paths.rs
index 3179be6af2a..c0b203b5388 100644
--- a/clippy_lints/src/utils/paths.rs
+++ b/clippy_lints/src/utils/paths.rs
@@ -54,6 +54,10 @@ pub const HASH: [&str; 3] = ["core", "hash", "Hash"];
 pub const HASHMAP: [&str; 5] = ["std", "collections", "hash", "map", "HashMap"];
 pub const HASHMAP_ENTRY: [&str; 5] = ["std", "collections", "hash", "map", "Entry"];
 pub const HASHSET: [&str; 5] = ["std", "collections", "hash", "set", "HashSet"];
+#[cfg(feature = "internal-lints")]
+pub const IDENT: [&str; 3] = ["rustc_span", "symbol", "Ident"];
+#[cfg(feature = "internal-lints")]
+pub const IDENT_AS_STR: [&str; 4] = ["rustc_span", "symbol", "Ident", "as_str"];
 pub const INDEX: [&str; 3] = ["core", "ops", "Index"];
 pub const INDEX_MUT: [&str; 3] = ["core", "ops", "IndexMut"];
 pub const INSERT_STR: [&str; 4] = ["alloc", "string", "String", "insert_str"];
@@ -150,8 +154,12 @@ pub const STR_STARTS_WITH: [&str; 4] = ["core", "str", "<impl str>", "starts_wit
 #[cfg(feature = "internal-lints")]
 pub const SYMBOL: [&str; 3] = ["rustc_span", "symbol", "Symbol"];
 #[cfg(feature = "internal-lints")]
+pub const SYMBOL_AS_STR: [&str; 4] = ["rustc_span", "symbol", "Symbol", "as_str"];
+#[cfg(feature = "internal-lints")]
 pub const SYMBOL_INTERN: [&str; 4] = ["rustc_span", "symbol", "Symbol", "intern"];
 #[cfg(feature = "internal-lints")]
+pub const SYMBOL_TO_IDENT_STRING: [&str; 4] = ["rustc_span", "symbol", "Symbol", "to_ident_string"];
+#[cfg(feature = "internal-lints")]
 pub const SYM_MODULE: [&str; 3] = ["rustc_span", "symbol", "sym"];
 #[cfg(feature = "internal-lints")]
 pub const SYNTAX_CONTEXT: [&str; 3] = ["rustc_span", "hygiene", "SyntaxContext"];
diff --git a/tests/ui-internal/unnecessary_symbol_str.fixed b/tests/ui-internal/unnecessary_symbol_str.fixed
new file mode 100644
index 00000000000..2ec0efe4c10
--- /dev/null
+++ b/tests/ui-internal/unnecessary_symbol_str.fixed
@@ -0,0 +1,16 @@
+// run-rustfix
+#![feature(rustc_private)]
+#![deny(clippy::internal)]
+#![allow(clippy::unnecessary_operation, unused_must_use)]
+
+extern crate rustc_span;
+
+use rustc_span::symbol::{Ident, Symbol};
+
+fn main() {
+    Symbol::intern("foo") == rustc_span::sym::clippy;
+    Symbol::intern("foo") == rustc_span::symbol::kw::SelfLower;
+    Symbol::intern("foo") != rustc_span::symbol::kw::SelfUpper;
+    Ident::invalid().name == rustc_span::sym::clippy;
+    rustc_span::sym::clippy == Ident::invalid().name;
+}
diff --git a/tests/ui-internal/unnecessary_symbol_str.rs b/tests/ui-internal/unnecessary_symbol_str.rs
new file mode 100644
index 00000000000..87e1b3a2ee7
--- /dev/null
+++ b/tests/ui-internal/unnecessary_symbol_str.rs
@@ -0,0 +1,16 @@
+// run-rustfix
+#![feature(rustc_private)]
+#![deny(clippy::internal)]
+#![allow(clippy::unnecessary_operation, unused_must_use)]
+
+extern crate rustc_span;
+
+use rustc_span::symbol::{Ident, Symbol};
+
+fn main() {
+    Symbol::intern("foo").as_str() == "clippy";
+    Symbol::intern("foo").to_string() == "self";
+    Symbol::intern("foo").to_ident_string() != "Self";
+    &*Ident::invalid().as_str() == "clippy";
+    "clippy" == Ident::invalid().to_string();
+}
diff --git a/tests/ui-internal/unnecessary_symbol_str.stderr b/tests/ui-internal/unnecessary_symbol_str.stderr
new file mode 100644
index 00000000000..b1284b7c8ff
--- /dev/null
+++ b/tests/ui-internal/unnecessary_symbol_str.stderr
@@ -0,0 +1,39 @@
+error: unnecessary `Symbol` to string conversion
+  --> $DIR/unnecessary_symbol_str.rs:11:5
+   |
+LL |     Symbol::intern("foo").as_str() == "clippy";
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Symbol::intern("foo") == rustc_span::sym::clippy`
+   |
+note: the lint level is defined here
+  --> $DIR/unnecessary_symbol_str.rs:3:9
+   |
+LL | #![deny(clippy::internal)]
+   |         ^^^^^^^^^^^^^^^^
+   = note: `#[deny(clippy::unnecessary_symbol_str)]` implied by `#[deny(clippy::internal)]`
+
+error: unnecessary `Symbol` to string conversion
+  --> $DIR/unnecessary_symbol_str.rs:12:5
+   |
+LL |     Symbol::intern("foo").to_string() == "self";
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Symbol::intern("foo") == rustc_span::symbol::kw::SelfLower`
+
+error: unnecessary `Symbol` to string conversion
+  --> $DIR/unnecessary_symbol_str.rs:13:5
+   |
+LL |     Symbol::intern("foo").to_ident_string() != "Self";
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Symbol::intern("foo") != rustc_span::symbol::kw::SelfUpper`
+
+error: unnecessary `Symbol` to string conversion
+  --> $DIR/unnecessary_symbol_str.rs:14:5
+   |
+LL |     &*Ident::invalid().as_str() == "clippy";
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Ident::invalid().name == rustc_span::sym::clippy`
+
+error: unnecessary `Symbol` to string conversion
+  --> $DIR/unnecessary_symbol_str.rs:15:5
+   |
+LL |     "clippy" == Ident::invalid().to_string();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `rustc_span::sym::clippy == Ident::invalid().name`
+
+error: aborting due to 5 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 7871ebaab9af1fffc3e68bae9f95c9db1e3863e5 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Tue, 29 Dec 2020 16:04:31 -0600
Subject: Fix symbol string comparison dogfood

---
 clippy_lints/src/attrs.rs                  |  2 +-
 clippy_lints/src/if_let_mutex.rs           |  2 +-
 clippy_lints/src/manual_async_fn.rs        |  4 ++--
 clippy_lints/src/map_clone.rs              |  2 +-
 clippy_lints/src/map_identity.rs           |  2 +-
 clippy_lints/src/methods/mod.rs            |  2 +-
 clippy_lints/src/minmax.rs                 |  4 ++--
 clippy_lints/src/missing_doc.rs            |  2 +-
 clippy_lints/src/needless_pass_by_value.rs |  3 ++-
 clippy_lints/src/option_if_let_else.rs     |  2 +-
 clippy_lints/src/shadow.rs                 |  2 +-
 clippy_lints/src/swap.rs                   |  2 +-
 clippy_lints/src/unnecessary_sort_by.rs    |  2 +-
 clippy_lints/src/useless_conversion.rs     |  4 ++--
 clippy_lints/src/utils/attrs.rs            |  9 +++++----
 clippy_lints/src/utils/hir_utils.rs        | 13 ++++++-------
 clippy_lints/src/vec_init_then_push.rs     |  2 +-
 clippy_lints/src/wildcard_imports.rs       |  7 ++++---
 18 files changed, 34 insertions(+), 32 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs
index 3edbe723922..9a00fc535fc 100644
--- a/clippy_lints/src/attrs.rs
+++ b/clippy_lints/src/attrs.rs
@@ -399,7 +399,7 @@ fn extract_clippy_lint(lint: &NestedMetaItem) -> Option<SymbolStr> {
         if let Some(meta_item) = lint.meta_item();
         if meta_item.path.segments.len() > 1;
         if let tool_name = meta_item.path.segments[0].ident;
-        if tool_name.as_str() == "clippy";
+        if tool_name.name == sym::clippy;
         let lint_name = meta_item.path.segments.last().unwrap().ident.name;
         then {
             return Some(lint_name.as_str());
diff --git a/clippy_lints/src/if_let_mutex.rs b/clippy_lints/src/if_let_mutex.rs
index 2e55094d90c..58511c6d57c 100644
--- a/clippy_lints/src/if_let_mutex.rs
+++ b/clippy_lints/src/if_let_mutex.rs
@@ -145,7 +145,7 @@ impl<'tcx, 'l> ArmVisitor<'tcx, 'l> {
 fn is_mutex_lock_call<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<&'tcx Expr<'tcx>> {
     if_chain! {
         if let ExprKind::MethodCall(path, _span, args, _) = &expr.kind;
-        if path.ident.to_string() == "lock";
+        if path.ident.as_str() == "lock";
         let ty = cx.typeck_results().expr_ty(&args[0]);
         if is_type_diagnostic_item(cx, ty, sym!(mutex_type));
         then {
diff --git a/clippy_lints/src/manual_async_fn.rs b/clippy_lints/src/manual_async_fn.rs
index 29439e52c48..89f5b2ff311 100644
--- a/clippy_lints/src/manual_async_fn.rs
+++ b/clippy_lints/src/manual_async_fn.rs
@@ -9,7 +9,7 @@ use rustc_hir::{
 };
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::Span;
+use rustc_span::{sym, Span};
 
 declare_clippy_lint! {
     /// **What it does:** It checks for manual implementations of `async` functions.
@@ -137,7 +137,7 @@ fn future_output_ty<'tcx>(trait_ref: &'tcx TraitRef<'tcx>) -> Option<&'tcx Ty<'t
         if let Some(args) = segment.args;
         if args.bindings.len() == 1;
         let binding = &args.bindings[0];
-        if binding.ident.as_str() == "Output";
+        if binding.ident.name == sym::Output;
         if let TypeBindingKind::Equality{ty: output} = binding.kind;
         then {
             return Some(output)
diff --git a/clippy_lints/src/map_clone.rs b/clippy_lints/src/map_clone.rs
index 220240acb7a..1818836d5d5 100644
--- a/clippy_lints/src/map_clone.rs
+++ b/clippy_lints/src/map_clone.rs
@@ -53,7 +53,7 @@ impl<'tcx> LateLintPass<'tcx> for MapClone {
         if_chain! {
             if let hir::ExprKind::MethodCall(ref method, _, ref args, _) = e.kind;
             if args.len() == 2;
-            if method.ident.as_str() == "map";
+            if method.ident.name == sym::map;
             let ty = cx.typeck_results().expr_ty(&args[0]);
             if is_type_diagnostic_item(cx, ty, sym::option_type) || match_trait_method(cx, e, &paths::ITERATOR);
             if let hir::ExprKind::Closure(_, _, body_id, _, _) = args[1].kind;
diff --git a/clippy_lints/src/map_identity.rs b/clippy_lints/src/map_identity.rs
index 6b782385a38..9f9c108a85a 100644
--- a/clippy_lints/src/map_identity.rs
+++ b/clippy_lints/src/map_identity.rs
@@ -63,7 +63,7 @@ impl<'tcx> LateLintPass<'tcx> for MapIdentity {
 fn get_map_argument<'a>(cx: &LateContext<'_>, expr: &'a Expr<'a>) -> Option<&'a [Expr<'a>]> {
     if_chain! {
         if let ExprKind::MethodCall(ref method, _, ref args, _) = expr.kind;
-        if args.len() == 2 && method.ident.as_str() == "map";
+        if args.len() == 2 && method.ident.name == sym::map;
         let caller_ty = cx.typeck_results().expr_ty(&args[0]);
         if match_trait_method(cx, expr, &paths::ITERATOR)
             || is_type_diagnostic_item(cx, caller_ty, sym::result_type)
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index e99fe1b97ff..f13f2491d6e 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3095,7 +3095,7 @@ fn lint_flat_map_identity<'tcx>(
             if let hir::ExprKind::Path(hir::QPath::Resolved(_, ref path)) = body.value.kind;
 
             if path.segments.len() == 1;
-            if path.segments[0].ident.as_str() == binding_ident.as_str();
+            if path.segments[0].ident.name == binding_ident.name;
 
             then {
                 apply_lint("called `flat_map(|x| x)` on an `Iterator`");
diff --git a/clippy_lints/src/minmax.rs b/clippy_lints/src/minmax.rs
index 004dd50a31b..8d0c3b8e0fe 100644
--- a/clippy_lints/src/minmax.rs
+++ b/clippy_lints/src/minmax.rs
@@ -89,9 +89,9 @@ fn min_max<'a>(cx: &LateContext<'_>, expr: &'a Expr<'a>) -> Option<(MinMax, Cons
                 if let [obj, _] = args;
                 if cx.typeck_results().expr_ty(obj).is_floating_point() || match_trait_method(cx, expr, &paths::ORD);
                 then {
-                    if path.ident.as_str() == sym!(max).as_str() {
+                    if path.ident.name == sym!(max) {
                         fetch_const(cx, args, MinMax::Max)
-                    } else if path.ident.as_str() == sym!(min).as_str() {
+                    } else if path.ident.name == sym!(min) {
                         fetch_const(cx, args, MinMax::Min)
                     } else {
                         None
diff --git a/clippy_lints/src/missing_doc.rs b/clippy_lints/src/missing_doc.rs
index 27f1074a0dd..0e49eaab436 100644
--- a/clippy_lints/src/missing_doc.rs
+++ b/clippy_lints/src/missing_doc.rs
@@ -63,7 +63,7 @@ impl MissingDoc {
             if let Some(meta) = list.get(0);
             if let Some(name) = meta.ident();
             then {
-                name.as_str() == "include"
+                name.name == sym::include
             } else {
                 false
             }
diff --git a/clippy_lints/src/needless_pass_by_value.rs b/clippy_lints/src/needless_pass_by_value.rs
index 5043b7b1fc3..1984942a914 100644
--- a/clippy_lints/src/needless_pass_by_value.rs
+++ b/clippy_lints/src/needless_pass_by_value.rs
@@ -13,6 +13,7 @@ use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{self, TypeFoldable};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::symbol::kw;
 use rustc_span::{sym, Span};
 use rustc_target::spec::abi::Abi;
 use rustc_trait_selection::traits;
@@ -153,7 +154,7 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByValue {
             // Ignore `self`s.
             if idx == 0 {
                 if let PatKind::Binding(.., ident, _) = arg.pat.kind {
-                    if ident.as_str() == "self" {
+                    if ident.name == kw::SelfLower {
                         continue;
                     }
                 }
diff --git a/clippy_lints/src/option_if_let_else.rs b/clippy_lints/src/option_if_let_else.rs
index 681dbce9769..58c00541af7 100644
--- a/clippy_lints/src/option_if_let_else.rs
+++ b/clippy_lints/src/option_if_let_else.rs
@@ -66,7 +66,7 @@ declare_lint_pass!(OptionIfLetElse => [OPTION_IF_LET_ELSE]);
 /// Returns true iff the given expression is the result of calling `Result::ok`
 fn is_result_ok(cx: &LateContext<'_>, expr: &'_ Expr<'_>) -> bool {
     if let ExprKind::MethodCall(ref path, _, &[ref receiver], _) = &expr.kind {
-        path.ident.name.to_ident_string() == "ok"
+        path.ident.name.as_str() == "ok"
             && is_type_diagnostic_item(cx, &cx.typeck_results().expr_ty(&receiver), sym::result_type)
     } else {
         false
diff --git a/clippy_lints/src/shadow.rs b/clippy_lints/src/shadow.rs
index f8396592678..4ae22468f78 100644
--- a/clippy_lints/src/shadow.rs
+++ b/clippy_lints/src/shadow.rs
@@ -389,5 +389,5 @@ fn is_self_shadow(name: Symbol, expr: &Expr<'_>) -> bool {
 }
 
 fn path_eq_name(name: Symbol, path: &Path<'_>) -> bool {
-    !path.is_global() && path.segments.len() == 1 && path.segments[0].ident.as_str() == name.as_str()
+    !path.is_global() && path.segments.len() == 1 && path.segments[0].ident.name == name
 }
diff --git a/clippy_lints/src/swap.rs b/clippy_lints/src/swap.rs
index 386987eb181..699fd51ccc1 100644
--- a/clippy_lints/src/swap.rs
+++ b/clippy_lints/src/swap.rs
@@ -91,7 +91,7 @@ fn check_manual_swap(cx: &LateContext<'_>, block: &Block<'_>) {
             if let ExprKind::Path(QPath::Resolved(None, ref rhs2)) = rhs2.kind;
             if rhs2.segments.len() == 1;
 
-            if ident.as_str() == rhs2.segments[0].ident.as_str();
+            if ident.name == rhs2.segments[0].ident.name;
             if eq_expr_value(cx, tmp_init, lhs1);
             if eq_expr_value(cx, rhs1, lhs2);
             then {
diff --git a/clippy_lints/src/unnecessary_sort_by.rs b/clippy_lints/src/unnecessary_sort_by.rs
index 0bccfc15678..9b45d38afd4 100644
--- a/clippy_lints/src/unnecessary_sort_by.rs
+++ b/clippy_lints/src/unnecessary_sort_by.rs
@@ -183,7 +183,7 @@ fn detect_lint(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<LintTrigger> {
             Param { pat: Pat { kind: PatKind::Binding(_, _, right_ident, _), .. }, .. }
         ] = &closure_body.params;
         if let ExprKind::MethodCall(method_path, _, [ref left_expr, ref right_expr], _) = &closure_body.value.kind;
-        if method_path.ident.name.to_ident_string() == "cmp";
+        if method_path.ident.name == sym::cmp;
         then {
             let (closure_body, closure_arg, reverse) = if mirrored_exprs(
                 &cx,
diff --git a/clippy_lints/src/useless_conversion.rs b/clippy_lints/src/useless_conversion.rs
index efa9c3fab4a..c5334853986 100644
--- a/clippy_lints/src/useless_conversion.rs
+++ b/clippy_lints/src/useless_conversion.rs
@@ -80,10 +80,10 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
                         );
                     }
                 }
-                if match_trait_method(cx, e, &paths::INTO_ITERATOR) && &*name.ident.as_str() == "into_iter" {
+                if match_trait_method(cx, e, &paths::INTO_ITERATOR) && name.ident.name == sym::into_iter {
                     if let Some(parent_expr) = get_parent_expr(cx, e) {
                         if let ExprKind::MethodCall(ref parent_name, ..) = parent_expr.kind {
-                            if &*parent_name.ident.as_str() != "into_iter" {
+                            if parent_name.ident.name != sym::into_iter {
                                 return;
                             }
                         }
diff --git a/clippy_lints/src/utils/attrs.rs b/clippy_lints/src/utils/attrs.rs
index 24052a243af..8d28421d70d 100644
--- a/clippy_lints/src/utils/attrs.rs
+++ b/clippy_lints/src/utils/attrs.rs
@@ -1,6 +1,7 @@
 use rustc_ast::ast;
 use rustc_errors::Applicability;
 use rustc_session::Session;
+use rustc_span::sym;
 use std::str::FromStr;
 
 /// Deprecation status of attributes known by Clippy.
@@ -64,11 +65,11 @@ pub fn get_attr<'a>(
             return false;
         };
         let attr_segments = &attr.path.segments;
-        if attr_segments.len() == 2 && attr_segments[0].ident.to_string() == "clippy" {
+        if attr_segments.len() == 2 && attr_segments[0].ident.name == sym::clippy {
             BUILTIN_ATTRIBUTES
                 .iter()
-                .find_map(|(builtin_name, deprecation_status)| {
-                    if *builtin_name == attr_segments[1].ident.to_string() {
+                .find_map(|&(builtin_name, ref deprecation_status)| {
+                    if attr_segments[1].ident.name.as_str() == builtin_name {
                         Some(deprecation_status)
                     } else {
                         None
@@ -99,7 +100,7 @@ pub fn get_attr<'a>(
                             },
                             DeprecationStatus::None => {
                                 diag.cancel();
-                                attr_segments[1].ident.to_string() == name
+                                attr_segments[1].ident.name.as_str() == name
                             },
                         }
                     },
diff --git a/clippy_lints/src/utils/hir_utils.rs b/clippy_lints/src/utils/hir_utils.rs
index a8fbb2ffaf0..8d8ad497be6 100644
--- a/clippy_lints/src/utils/hir_utils.rs
+++ b/clippy_lints/src/utils/hir_utils.rs
@@ -86,7 +86,7 @@ impl<'a, 'tcx> SpanlessEq<'a, 'tcx> {
                 lb == rb && l_mut == r_mut && self.eq_expr(le, re)
             },
             (&ExprKind::Continue(li), &ExprKind::Continue(ri)) => {
-                both(&li.label, &ri.label, |l, r| l.ident.as_str() == r.ident.as_str())
+                both(&li.label, &ri.label, |l, r| l.ident.name == r.ident.name)
             },
             (&ExprKind::Assign(ref ll, ref lr, _), &ExprKind::Assign(ref rl, ref rr, _)) => {
                 self.allow_side_effects && self.eq_expr(ll, rl) && self.eq_expr(lr, rr)
@@ -102,7 +102,7 @@ impl<'a, 'tcx> SpanlessEq<'a, 'tcx> {
                     })
             },
             (&ExprKind::Break(li, ref le), &ExprKind::Break(ri, ref re)) => {
-                both(&li.label, &ri.label, |l, r| l.ident.as_str() == r.ident.as_str())
+                both(&li.label, &ri.label, |l, r| l.ident.name == r.ident.name)
                     && both(le, re, |l, r| self.eq_expr(l, r))
             },
             (&ExprKind::Box(ref l), &ExprKind::Box(ref r)) => self.eq_expr(l, r),
@@ -121,7 +121,7 @@ impl<'a, 'tcx> SpanlessEq<'a, 'tcx> {
             },
             (&ExprKind::Lit(ref l), &ExprKind::Lit(ref r)) => l.node == r.node,
             (&ExprKind::Loop(ref lb, ref ll, ref lls), &ExprKind::Loop(ref rb, ref rl, ref rls)) => {
-                lls == rls && self.eq_block(lb, rb) && both(ll, rl, |l, r| l.ident.as_str() == r.ident.as_str())
+                lls == rls && self.eq_block(lb, rb) && both(ll, rl, |l, r| l.ident.name == r.ident.name)
             },
             (&ExprKind::Match(ref le, ref la, ref ls), &ExprKind::Match(ref re, ref ra, ref rs)) => {
                 ls == rs
@@ -188,7 +188,7 @@ impl<'a, 'tcx> SpanlessEq<'a, 'tcx> {
 
     pub fn eq_fieldpat(&mut self, left: &FieldPat<'_>, right: &FieldPat<'_>) -> bool {
         let (FieldPat { ident: li, pat: lp, .. }, FieldPat { ident: ri, pat: rp, .. }) = (&left, &right);
-        li.name.as_str() == ri.name.as_str() && self.eq_pat(lp, rp)
+        li.name == ri.name && self.eq_pat(lp, rp)
     }
 
     /// Checks whether two patterns are the same.
@@ -202,7 +202,7 @@ impl<'a, 'tcx> SpanlessEq<'a, 'tcx> {
                 self.eq_qpath(lp, rp) && over(la, ra, |l, r| self.eq_pat(l, r)) && ls == rs
             },
             (&PatKind::Binding(ref lb, .., ref li, ref lp), &PatKind::Binding(ref rb, .., ref ri, ref rp)) => {
-                lb == rb && li.name.as_str() == ri.name.as_str() && both(lp, rp, |l, r| self.eq_pat(l, r))
+                lb == rb && li.name == ri.name && both(lp, rp, |l, r| self.eq_pat(l, r))
             },
             (&PatKind::Path(ref l), &PatKind::Path(ref r)) => self.eq_qpath(l, r),
             (&PatKind::Lit(ref l), &PatKind::Lit(ref r)) => self.eq_expr(l, r),
@@ -263,8 +263,7 @@ impl<'a, 'tcx> SpanlessEq<'a, 'tcx> {
     pub fn eq_path_segment(&mut self, left: &PathSegment<'_>, right: &PathSegment<'_>) -> bool {
         // The == of idents doesn't work with different contexts,
         // we have to be explicit about hygiene
-        left.ident.as_str() == right.ident.as_str()
-            && both(&left.args, &right.args, |l, r| self.eq_path_parameters(l, r))
+        left.ident.name == right.ident.name && both(&left.args, &right.args, |l, r| self.eq_path_parameters(l, r))
     }
 
     pub fn eq_ty(&mut self, left: &Ty<'_>, right: &Ty<'_>) -> bool {
diff --git a/clippy_lints/src/vec_init_then_push.rs b/clippy_lints/src/vec_init_then_push.rs
index 6249d7e867b..e632a7e57ee 100644
--- a/clippy_lints/src/vec_init_then_push.rs
+++ b/clippy_lints/src/vec_init_then_push.rs
@@ -158,7 +158,7 @@ fn get_vec_init_kind<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> Op
             ExprKind::Path(QPath::TypeRelative(ty, name))
                 if is_type_diagnostic_item(cx, cx.typeck_results().node_type(ty.hir_id), sym::vec_type) =>
             {
-                if name.ident.name.as_str() == "new" {
+                if name.ident.name == sym::new {
                     return Some(VecInitKind::New);
                 } else if name.ident.name.as_str() == "with_capacity" {
                     return args.get(0).and_then(|arg| {
diff --git a/clippy_lints/src/wildcard_imports.rs b/clippy_lints/src/wildcard_imports.rs
index 5683a71efea..10005a7fc81 100644
--- a/clippy_lints/src/wildcard_imports.rs
+++ b/clippy_lints/src/wildcard_imports.rs
@@ -7,7 +7,8 @@ use rustc_hir::{
 };
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::BytePos;
+use rustc_span::symbol::kw;
+use rustc_span::{sym, BytePos};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for `use Enum::*`.
@@ -198,12 +199,12 @@ impl WildcardImports {
 // Allow "...prelude::..::*" imports.
 // Many crates have a prelude, and it is imported as a glob by design.
 fn is_prelude_import(segments: &[PathSegment<'_>]) -> bool {
-    segments.iter().any(|ps| ps.ident.as_str() == "prelude")
+    segments.iter().any(|ps| ps.ident.name == sym::prelude)
 }
 
 // Allow "super::*" imports in tests.
 fn is_super_only_import(segments: &[PathSegment<'_>]) -> bool {
-    segments.len() == 1 && segments[0].ident.as_str() == "super"
+    segments.len() == 1 && segments[0].ident.name == kw::Super
 }
 
 fn is_test_module_or_function(item: &Item<'_>) -> bool {
-- 
cgit 1.4.1-3-g733a5


From 8a6fea4fb85adb8446797f698ab92a0869ccc9c9 Mon Sep 17 00:00:00 2001
From: ThibsG <Thibs@debian.com>
Date: Sat, 9 Jan 2021 12:26:24 +0100
Subject: Fix FP for `boxed_local` lint in default trait fn impl

---
 clippy_lints/src/escape.rs      | 33 +++++++++++++++++++++++++++++----
 tests/ui/escape_analysis.rs     | 20 ++++++++++++++++++++
 tests/ui/escape_analysis.stderr | 14 +++++++++++++-
 3 files changed, 62 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/escape.rs b/clippy_lints/src/escape.rs
index d2dcb3e5c46..9fcd17a756a 100644
--- a/clippy_lints/src/escape.rs
+++ b/clippy_lints/src/escape.rs
@@ -1,15 +1,16 @@
 use rustc_hir::intravisit;
-use rustc_hir::{self, Body, FnDecl, HirId, HirIdSet, ItemKind, Node};
+use rustc_hir::{self, AssocItemKind, Body, FnDecl, HirId, HirIdSet, ItemKind, Node};
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty::{self, Ty};
+use rustc_middle::ty::{self, TraitRef, Ty};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::Span;
+use rustc_span::symbol::kw;
 use rustc_target::abi::LayoutOf;
 use rustc_target::spec::abi::Abi;
 use rustc_typeck::expr_use_visitor::{ConsumeMode, Delegate, ExprUseVisitor, PlaceBase, PlaceWithHirId};
 
-use crate::utils::span_lint;
+use crate::utils::{contains_ty, span_lint};
 
 #[derive(Copy, Clone)]
 pub struct BoxedLocal {
@@ -51,6 +52,7 @@ fn is_non_trait_box(ty: Ty<'_>) -> bool {
 struct EscapeDelegate<'a, 'tcx> {
     cx: &'a LateContext<'tcx>,
     set: HirIdSet,
+    trait_self_ty: Option<Ty<'a>>,
     too_large_for_stack: u64,
 }
 
@@ -72,19 +74,34 @@ impl<'tcx> LateLintPass<'tcx> for BoxedLocal {
             }
         }
 
-        // If the method is an impl for a trait, don't warn.
         let parent_id = cx.tcx.hir().get_parent_item(hir_id);
         let parent_node = cx.tcx.hir().find(parent_id);
 
+        let mut trait_self_ty = None;
         if let Some(Node::Item(item)) = parent_node {
+            // If the method is an impl for a trait, don't warn.
             if let ItemKind::Impl { of_trait: Some(_), .. } = item.kind {
                 return;
             }
+
+            // find `self` ty for this trait if relevant
+            if let ItemKind::Trait(_, _, _, _, items) = item.kind {
+                for trait_item in items {
+                    if trait_item.id.hir_id == hir_id {
+                        // be sure we have `self` parameter in this function
+                        if let AssocItemKind::Fn { has_self: true } = trait_item.kind {
+                            trait_self_ty =
+                                Some(TraitRef::identity(cx.tcx, trait_item.id.hir_id.owner.to_def_id()).self_ty());
+                        }
+                    }
+                }
+            }
         }
 
         let mut v = EscapeDelegate {
             cx,
             set: HirIdSet::default(),
+            trait_self_ty,
             too_large_for_stack: self.too_large_for_stack,
         };
 
@@ -153,6 +170,14 @@ impl<'a, 'tcx> Delegate<'tcx> for EscapeDelegate<'a, 'tcx> {
                     return;
                 }
 
+                // skip if there is a `self` parameter binding to a type
+                // that contains `Self` (i.e.: `self: Box<Self>`), see #4804
+                if let Some(trait_self_ty) = self.trait_self_ty {
+                    if map.name(cmt.hir_id) == kw::SelfLower && contains_ty(cmt.place.ty(), trait_self_ty) {
+                        return;
+                    }
+                }
+
                 if is_non_trait_box(cmt.place.ty()) && !self.is_large_box(cmt.place.ty()) {
                     self.set.insert(cmt.hir_id);
                 }
diff --git a/tests/ui/escape_analysis.rs b/tests/ui/escape_analysis.rs
index 07004489610..d26f48fc68f 100644
--- a/tests/ui/escape_analysis.rs
+++ b/tests/ui/escape_analysis.rs
@@ -182,3 +182,23 @@ pub extern "C" fn do_not_warn_me(_c_pointer: Box<String>) -> () {}
 
 #[rustfmt::skip] // Forces rustfmt to not add ABI
 pub extern fn do_not_warn_me_no_abi(_c_pointer: Box<String>) -> () {}
+
+// Issue #4804 - default implementation in trait
+mod issue4804 {
+    trait DefaultTraitImplTest {
+        // don't warn on `self`
+        fn default_impl(self: Box<Self>) -> u32 {
+            5
+        }
+
+        // warn on `x: Box<u32>`
+        fn default_impl_x(self: Box<Self>, x: Box<u32>) -> u32 {
+            4
+        }
+    }
+
+    trait WarnTrait {
+        // warn on `x: Box<u32>`
+        fn foo(x: Box<u32>) {}
+    }
+}
diff --git a/tests/ui/escape_analysis.stderr b/tests/ui/escape_analysis.stderr
index c86a769a3da..4a82b4419f9 100644
--- a/tests/ui/escape_analysis.stderr
+++ b/tests/ui/escape_analysis.stderr
@@ -12,5 +12,17 @@ error: local variable doesn't need to be boxed here
 LL | pub fn new(_needs_name: Box<PeekableSeekable<&()>>) -> () {}
    |            ^^^^^^^^^^^
 
-error: aborting due to 2 previous errors
+error: local variable doesn't need to be boxed here
+  --> $DIR/escape_analysis.rs:195:44
+   |
+LL |         fn default_impl_x(self: Box<Self>, x: Box<u32>) -> u32 {
+   |                                            ^
+
+error: local variable doesn't need to be boxed here
+  --> $DIR/escape_analysis.rs:202:16
+   |
+LL |         fn foo(x: Box<u32>) {}
+   |                ^
+
+error: aborting due to 4 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 8d7417d8079b7f942e3a116ede6d36dc7a219e71 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sun, 10 Jan 2021 23:32:23 -0500
Subject: Add: single_match will suggest using if .. == .. instead of if let
 when applicable

---
 clippy_lints/src/matches.rs  | 79 ++++++++++++++++++++++++++++++++++++--------
 tests/ui/single_match.rs     | 43 ++++++++++++++++++++++++
 tests/ui/single_match.stderr | 38 ++++++++++++++++++++-
 3 files changed, 146 insertions(+), 14 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index 04b35835c6b..2239b519632 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -2,10 +2,10 @@ use crate::consts::{constant, miri_to_const, Constant};
 use crate::utils::sugg::Sugg;
 use crate::utils::usage::is_unused;
 use crate::utils::{
-    expr_block, get_arg_name, get_parent_expr, in_macro, indent_of, is_allowed, is_expn_of, is_refutable,
-    is_type_diagnostic_item, is_wild, match_qpath, match_type, match_var, meets_msrv, multispan_sugg, remove_blocks,
-    snippet, snippet_block, snippet_opt, snippet_with_applicability, span_lint_and_help, span_lint_and_note,
-    span_lint_and_sugg, span_lint_and_then,
+    expr_block, get_arg_name, get_parent_expr, implements_trait, in_macro, indent_of, is_allowed, is_expn_of,
+    is_refutable, is_type_diagnostic_item, is_wild, match_qpath, match_type, match_var, meets_msrv, multispan_sugg,
+    remove_blocks, snippet, snippet_block, snippet_opt, snippet_with_applicability, span_lint_and_help,
+    span_lint_and_note, span_lint_and_sugg, span_lint_and_then,
 };
 use crate::utils::{paths, search_same, SpanlessEq, SpanlessHash};
 use if_chain::if_chain;
@@ -717,6 +717,28 @@ fn check_single_match_single_pattern(
     }
 }
 
+fn peel_pat_refs(pat: &'a Pat<'a>) -> (&'a Pat<'a>, usize) {
+    fn peel(pat: &'a Pat<'a>, count: usize) -> (&'a Pat<'a>, usize) {
+        if let PatKind::Ref(pat, _) = pat.kind {
+            peel(pat, count + 1)
+        } else {
+            (pat, count)
+        }
+    }
+    peel(pat, 0)
+}
+
+fn peel_ty_refs(ty: Ty<'_>) -> (Ty<'_>, usize) {
+    fn peel(ty: Ty<'_>, count: usize) -> (Ty<'_>, usize) {
+        if let ty::Ref(_, ty, _) = ty.kind() {
+            peel(ty, count + 1)
+        } else {
+            (ty, count)
+        }
+    }
+    peel(ty, 0)
+}
+
 fn report_single_match_single_pattern(
     cx: &LateContext<'_>,
     ex: &Expr<'_>,
@@ -728,20 +750,51 @@ fn report_single_match_single_pattern(
     let els_str = els.map_or(String::new(), |els| {
         format!(" else {}", expr_block(cx, els, None, "..", Some(expr.span)))
     });
+
+    let (msg, sugg) = if_chain! {
+        let (pat, pat_ref_count) = peel_pat_refs(arms[0].pat);
+        if let PatKind::Path(_) | PatKind::Lit(_) = pat.kind;
+        let (ty, ty_ref_count) = peel_ty_refs(cx.typeck_results().expr_ty(ex));
+        if let Some(trait_id) = cx.tcx.lang_items().structural_peq_trait();
+        if ty.is_integral() || ty.is_char() || ty.is_str() || implements_trait(cx, ty, trait_id, &[]);
+        then {
+            // scrutinee derives PartialEq and the pattern is a constant.
+            let pat_ref_count = match pat.kind {
+                // string literals are already a reference.
+                PatKind::Lit(Expr { kind: ExprKind::Lit(lit), .. }) if lit.node.is_str() => pat_ref_count + 1,
+                _ => pat_ref_count,
+            };
+            let msg = "you seem to be trying to use match for an equality check. Consider using `if`";
+            let sugg = format!(
+                "if {} == {}{} {}{}",
+                snippet(cx, ex.span, ".."),
+                // PartialEq for different reference counts may not exist.
+                "&".repeat(ty_ref_count - pat_ref_count),
+                snippet(cx, arms[0].pat.span, ".."),
+                expr_block(cx, &arms[0].body, None, "..", Some(expr.span)),
+                els_str,
+            );
+            (msg, sugg)
+        } else {
+            let msg = "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`";
+            let sugg = format!(
+                "if let {} = {} {}{}",
+                snippet(cx, arms[0].pat.span, ".."),
+                snippet(cx, ex.span, ".."),
+                expr_block(cx, &arms[0].body, None, "..", Some(expr.span)),
+                els_str,
+            );
+            (msg, sugg)
+        }
+    };
+
     span_lint_and_sugg(
         cx,
         lint,
         expr.span,
-        "you seem to be trying to use match for destructuring a single pattern. Consider using `if \
-         let`",
+        msg,
         "try this",
-        format!(
-            "if let {} = {} {}{}",
-            snippet(cx, arms[0].pat.span, ".."),
-            snippet(cx, ex.span, ".."),
-            expr_block(cx, &arms[0].body, None, "..", Some(expr.span)),
-            els_str,
-        ),
+        sugg,
         Applicability::HasPlaceholders,
     );
 }
diff --git a/tests/ui/single_match.rs b/tests/ui/single_match.rs
index 1c55af5dfb6..02266308fba 100644
--- a/tests/ui/single_match.rs
+++ b/tests/ui/single_match.rs
@@ -81,6 +81,49 @@ fn single_match_know_enum() {
     }
 }
 
+fn issue_173() {
+    let x = "test";
+    match x {
+        "test" => println!(),
+        _ => (),
+    }
+
+    #[derive(PartialEq, Eq)]
+    enum Foo {
+        A,
+        B,
+        C(u32),
+    }
+
+    let x = Foo::A;
+    match x {
+        Foo::A => println!(),
+        _ => (),
+    }
+
+    const FOO_C: Foo = Foo::C(0);
+    match x {
+        FOO_C => println!(),
+        _ => (),
+    }
+    enum Bar {
+        A,
+        B,
+    }
+    impl PartialEq for Bar {
+        fn eq(&self, rhs: &Self) -> bool {
+            matches!((self, rhs), (Self::A, Self::A) | (Self::B, Self::B))
+        }
+    }
+    impl Eq for Bar {}
+
+    let x = Bar::A;
+    match x {
+        Bar::A => println!(),
+        _ => (),
+    }
+}
+
 macro_rules! single_match {
     ($num:literal) => {
         match $num {
diff --git a/tests/ui/single_match.stderr b/tests/ui/single_match.stderr
index f69554d75f9..5eca07ab109 100644
--- a/tests/ui/single_match.stderr
+++ b/tests/ui/single_match.stderr
@@ -65,5 +65,41 @@ LL | |         Cow::Owned(..) => (),
 LL | |     };
    | |_____^ help: try this: `if let Cow::Borrowed(..) = c { dummy() }`
 
-error: aborting due to 6 previous errors
+error: you seem to be trying to use match for an equality check. Consider using `if`
+  --> $DIR/single_match.rs:86:5
+   |
+LL | /     match x {
+LL | |         "test" => println!(),
+LL | |         _ => (),
+LL | |     }
+   | |_____^ help: try this: `if x == "test" { println!() }`
+
+error: you seem to be trying to use match for an equality check. Consider using `if`
+  --> $DIR/single_match.rs:99:5
+   |
+LL | /     match x {
+LL | |         Foo::A => println!(),
+LL | |         _ => (),
+LL | |     }
+   | |_____^ help: try this: `if x == Foo::A { println!() }`
+
+error: you seem to be trying to use match for an equality check. Consider using `if`
+  --> $DIR/single_match.rs:105:5
+   |
+LL | /     match x {
+LL | |         FOO_C => println!(),
+LL | |         _ => (),
+LL | |     }
+   | |_____^ help: try this: `if x == FOO_C { println!() }`
+
+error: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
+  --> $DIR/single_match.rs:121:5
+   |
+LL | /     match x {
+LL | |         Bar::A => println!(),
+LL | |         _ => (),
+LL | |     }
+   | |_____^ help: try this: `if let Bar::A = x { println!() }`
+
+error: aborting due to 10 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 53f87310cd2fd965daf22f155cb4a2536ef8c8c6 Mon Sep 17 00:00:00 2001
From: rail <12975677+rail-rain@users.noreply.github.com>
Date: Tue, 12 Jan 2021 10:06:41 +1300
Subject: Simplify `cast_ptr_alignment` `pointer::casr` case

---
 clippy_lints/src/types.rs | 22 ++++++++++------------
 1 file changed, 10 insertions(+), 12 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs
index 765a0569007..75042d846d8 100644
--- a/clippy_lints/src/types.rs
+++ b/clippy_lints/src/types.rs
@@ -1691,20 +1691,18 @@ impl<'tcx> LateLintPass<'tcx> for Casts {
 
             lint_cast_ptr_alignment(cx, expr, cast_from, cast_to);
         } else if let ExprKind::MethodCall(method_path, _, args, _) = expr.kind {
-            if method_path.ident.name != sym!(cast) {
-                return;
-            }
             if_chain! {
-                if let Some(generic_args) = method_path.args;
-                if let [GenericArg::Type(cast_to)] = generic_args.args;
-                // There probably is no obvious reason to do this, just to be consistent with `as` cases.
-                if is_hir_ty_cfg_dependant(cx, cast_to);
-                then {
-                    return;
-                }
+            if method_path.ident.name == sym!(cast);
+            if let Some(generic_args) = method_path.args;
+            if let [GenericArg::Type(cast_to)] = generic_args.args;
+            // There probably is no obvious reason to do this, just to be consistent with `as` cases.
+            if !is_hir_ty_cfg_dependant(cx, cast_to);
+            then {
+                let (cast_from, cast_to) =
+                    (cx.typeck_results().expr_ty(&args[0]), cx.typeck_results().expr_ty(expr));
+                lint_cast_ptr_alignment(cx, expr, cast_from, cast_to);
+            }
             }
-            let (cast_from, cast_to) = (cx.typeck_results().expr_ty(&args[0]), cx.typeck_results().expr_ty(expr));
-            lint_cast_ptr_alignment(cx, expr, cast_from, cast_to);
         }
     }
 }
-- 
cgit 1.4.1-3-g733a5


From f2d493504cb863a30f45e8a0d5717285823f931e Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Sat, 28 Nov 2020 16:56:59 -0600
Subject: Similar names ignore underscore prefixed names

---
 clippy_lints/src/non_expressive_names.rs | 4 ++++
 tests/ui/similar_names.rs                | 5 +++++
 2 files changed, 9 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/non_expressive_names.rs b/clippy_lints/src/non_expressive_names.rs
index 446426b3e61..855529378e6 100644
--- a/clippy_lints/src/non_expressive_names.rs
+++ b/clippy_lints/src/non_expressive_names.rs
@@ -199,6 +199,10 @@ impl<'a, 'tcx, 'b> SimilarNamesNameVisitor<'a, 'tcx, 'b> {
             );
             return;
         }
+        if interned_name.starts_with('_') {
+            // these bindings are typically unused or represent an ignored portion of a destructuring pattern
+            return;
+        }
         let count = interned_name.chars().count();
         if count < 3 {
             if count == 1 {
diff --git a/tests/ui/similar_names.rs b/tests/ui/similar_names.rs
index 6796b15289e..5981980988b 100644
--- a/tests/ui/similar_names.rs
+++ b/tests/ui/similar_names.rs
@@ -101,3 +101,8 @@ pub(crate) struct DirSizes {
     pub(crate) numb_reg_cache_entries: u64,
     pub(crate) numb_reg_src_checkouts: u64,
 }
+
+fn ignore_underscore_prefix() {
+    let hello: ();
+    let _hello: ();
+}
-- 
cgit 1.4.1-3-g733a5


From feee45c87270a4e6cf1959315e2c4528e7da4ec7 Mon Sep 17 00:00:00 2001
From: rail <12975677+rail-rain@users.noreply.github.com>
Date: Wed, 13 Jan 2021 11:08:12 +1300
Subject: Fix the ICE 6539

It happened because `zero_sized_map_values` used `layout_of` with types
from type aliases, which is essentially the same as the ICE 4968.
---
 clippy_lints/src/zero_sized_map_values.rs |  4 +++-
 tests/ui/crashes/ice-6539.rs              | 16 ++++++++++++++++
 2 files changed, 19 insertions(+), 1 deletion(-)
 create mode 100644 tests/ui/crashes/ice-6539.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/zero_sized_map_values.rs b/clippy_lints/src/zero_sized_map_values.rs
index 1d5fa8d06a9..5e9ffab7dfb 100644
--- a/clippy_lints/src/zero_sized_map_values.rs
+++ b/clippy_lints/src/zero_sized_map_values.rs
@@ -6,7 +6,7 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_target::abi::LayoutOf as _;
 use rustc_typeck::hir_ty_to_ty;
 
-use crate::utils::{is_type_diagnostic_item, match_type, paths, span_lint_and_help};
+use crate::utils::{is_normalizable, is_type_diagnostic_item, match_type, paths, span_lint_and_help};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for maps with zero-sized value types anywhere in the code.
@@ -50,6 +50,8 @@ impl LateLintPass<'_> for ZeroSizedMapValues {
             if is_type_diagnostic_item(cx, ty, sym!(hashmap_type)) || match_type(cx, ty, &paths::BTREEMAP);
             if let Adt(_, ref substs) = ty.kind();
             let ty = substs.type_at(1);
+            // Do this to prevent `layout_of` crashing, being unable to fully normalize `ty`.
+            if is_normalizable(cx, cx.param_env, ty);
             if let Ok(layout) = cx.layout_of(ty);
             if layout.is_zst();
             then {
diff --git a/tests/ui/crashes/ice-6539.rs b/tests/ui/crashes/ice-6539.rs
new file mode 100644
index 00000000000..ac6c3e4aba0
--- /dev/null
+++ b/tests/ui/crashes/ice-6539.rs
@@ -0,0 +1,16 @@
+// The test for the ICE 6539: https://github.com/rust-lang/rust-clippy/issues/6539.
+// The cause is that `zero_sized_map_values` used `layout_of` with types from type aliases,
+// which is essentially the same as the ICE 4968.
+// Note that only type aliases with associated types caused the crash this time,
+// not others such as trait impls.
+
+use std::collections::{BTreeMap, HashMap};
+
+pub trait Trait {
+    type Assoc;
+}
+
+type TypeAlias<T> = HashMap<(), <T as Trait>::Assoc>;
+type TypeAlias2<T> = BTreeMap<(), <T as Trait>::Assoc>;
+
+fn main() {}
-- 
cgit 1.4.1-3-g733a5


From ea028497eddf6ad3cc3ae748ccf3f2c211c3f929 Mon Sep 17 00:00:00 2001
From: Takayuki Nakata <f.seasons017@gmail.com>
Date: Wed, 13 Jan 2021 09:21:26 +0900
Subject: Make a reference a link in doc

---
 clippy_lints/src/comparison_chain.rs | 2 +-
 clippy_lints/src/eta_reduction.rs    | 7 ++++---
 clippy_lints/src/loops.rs            | 2 +-
 clippy_lints/src/types.rs            | 2 +-
 clippy_lints/src/use_self.rs         | 4 ++--
 5 files changed, 9 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/comparison_chain.rs b/clippy_lints/src/comparison_chain.rs
index ae1143b2c50..90d31dece13 100644
--- a/clippy_lints/src/comparison_chain.rs
+++ b/clippy_lints/src/comparison_chain.rs
@@ -13,7 +13,7 @@ declare_clippy_lint! {
     /// repetitive
     ///
     /// **Known problems:** The match statement may be slower due to the compiler
-    /// not inlining the call to cmp. See issue #5354
+    /// not inlining the call to cmp. See issue [#5354](https://github.com/rust-lang/rust-clippy/issues/5354)
     ///
     /// **Example:**
     /// ```rust,ignore
diff --git a/clippy_lints/src/eta_reduction.rs b/clippy_lints/src/eta_reduction.rs
index 53df3abbf54..1a722d39f73 100644
--- a/clippy_lints/src/eta_reduction.rs
+++ b/clippy_lints/src/eta_reduction.rs
@@ -22,7 +22,7 @@ declare_clippy_lint! {
     /// **Known problems:** If creating the closure inside the closure has a side-
     /// effect then moving the closure creation out will change when that side-
     /// effect runs.
-    /// See rust-lang/rust-clippy#1439 for more details.
+    /// See [#1439](https://github.com/rust-lang/rust-clippy/issues/1439) for more details.
     ///
     /// **Example:**
     /// ```rust,ignore
@@ -45,8 +45,9 @@ declare_clippy_lint! {
     ///
     /// **Why is this bad?** It's unnecessary to create the closure.
     ///
-    /// **Known problems:** rust-lang/rust-clippy#3071, rust-lang/rust-clippy#4002,
-    /// rust-lang/rust-clippy#3942
+    /// **Known problems:** [#3071](https://github.com/rust-lang/rust-clippy/issues/3071),
+    /// [#3942](https://github.com/rust-lang/rust-clippy/issues/3942),
+    /// [#4002](https://github.com/rust-lang/rust-clippy/issues/4002)
     ///
     ///
     /// **Example:**
diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 1bd96b2b4c8..a6413dc2662 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -218,7 +218,7 @@ declare_clippy_lint! {
     /// **Why is this bad?** The `while let` loop is usually shorter and more
     /// readable.
     ///
-    /// **Known problems:** Sometimes the wrong binding is displayed (#383).
+    /// **Known problems:** Sometimes the wrong binding is displayed ([#383](https://github.com/rust-lang/rust-clippy/issues/383)).
     ///
     /// **Example:**
     /// ```rust,no_run
diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs
index 75042d846d8..ef199c11e27 100644
--- a/clippy_lints/src/types.rs
+++ b/clippy_lints/src/types.rs
@@ -75,7 +75,7 @@ declare_clippy_lint! {
     /// **Why is this bad?** `Vec` already keeps its contents in a separate area on
     /// the heap. So if you `Box` its contents, you just add another level of indirection.
     ///
-    /// **Known problems:** Vec<Box<T: Sized>> makes sense if T is a large type (see #3530,
+    /// **Known problems:** Vec<Box<T: Sized>> makes sense if T is a large type (see [#3530](https://github.com/rust-lang/rust-clippy/issues/3530),
     /// 1st comment).
     ///
     /// **Example:**
diff --git a/clippy_lints/src/use_self.rs b/clippy_lints/src/use_self.rs
index 3b23f885e08..bb73d66daba 100644
--- a/clippy_lints/src/use_self.rs
+++ b/clippy_lints/src/use_self.rs
@@ -28,8 +28,8 @@ declare_clippy_lint! {
     /// feels inconsistent.
     ///
     /// **Known problems:**
-    /// - False positive when using associated types (#2843)
-    /// - False positives in some situations when using generics (#3410)
+    /// - False positive when using associated types ([#2843](https://github.com/rust-lang/rust-clippy/issues/2843))
+    /// - False positives in some situations when using generics ([#3410](https://github.com/rust-lang/rust-clippy/issues/3410))
     ///
     /// **Example:**
     /// ```rust
-- 
cgit 1.4.1-3-g733a5


From 02f99bea87d0a3fe665aa825bccdcce7a8d190e9 Mon Sep 17 00:00:00 2001
From: Daniel Smith <daniel.smith@datadoghq.com>
Date: Wed, 13 Jan 2021 16:08:15 -0500
Subject: Explicitly document false positives

---
 clippy_lints/src/await_holding_invalid.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/await_holding_invalid.rs b/clippy_lints/src/await_holding_invalid.rs
index f136aa4572a..ae64c688744 100644
--- a/clippy_lints/src/await_holding_invalid.rs
+++ b/clippy_lints/src/await_holding_invalid.rs
@@ -18,7 +18,7 @@ declare_clippy_lint! {
     /// other solution is to ensure the mutex is unlocked before calling await,
     /// either by introducing a scope or an explicit call to Drop::drop.
     ///
-    /// **Known problems:** None.
+    /// **Known problems:** Will report false positive for explicitly dropped guards ([#6446](https://github.com/rust-lang/rust-clippy/issues/6446)).
     ///
     /// **Example:**
     ///
@@ -57,7 +57,7 @@ declare_clippy_lint! {
     /// at runtime. Holding onto a `RefCell` ref across an `await` suspension point
     /// risks panics from a mutable ref shared while other refs are outstanding.
     ///
-    /// **Known problems:** None.
+    /// **Known problems:** Will report false positive for explicitly dropped refs ([#6353](https://github.com/rust-lang/rust-clippy/issues/6353)).
     ///
     /// **Example:**
     ///
-- 
cgit 1.4.1-3-g733a5


From 85edd65bf69266dd7cec2ca6d7bb6941b6f85444 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Thu, 14 Jan 2021 14:26:26 -0500
Subject: Address review comments

Add: attempt to remove address of expressions from the scrutinee expression before adding references to the pattern
---
 clippy_lints/src/matches.rs       | 45 +++++++++++++-----------------------
 clippy_lints/src/utils/mod.rs     | 38 +++++++++++++++++++++++++++++++
 tests/ui/single_match.rs          | 15 +++++++++++-
 tests/ui/single_match.stderr      | 48 +++++++++++++++++++++++++++------------
 tests/ui/single_match_else.stderr |  6 ++---
 5 files changed, 104 insertions(+), 48 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index 2239b519632..6ecd738d2f0 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -4,8 +4,8 @@ use crate::utils::usage::is_unused;
 use crate::utils::{
     expr_block, get_arg_name, get_parent_expr, implements_trait, in_macro, indent_of, is_allowed, is_expn_of,
     is_refutable, is_type_diagnostic_item, is_wild, match_qpath, match_type, match_var, meets_msrv, multispan_sugg,
-    remove_blocks, snippet, snippet_block, snippet_opt, snippet_with_applicability, span_lint_and_help,
-    span_lint_and_note, span_lint_and_sugg, span_lint_and_then,
+    peel_hir_pat_refs, peel_mid_ty_refs, peeln_hir_expr_refs, remove_blocks, snippet, snippet_block, snippet_opt,
+    snippet_with_applicability, span_lint_and_help, span_lint_and_note, span_lint_and_sugg, span_lint_and_then,
 };
 use crate::utils::{paths, search_same, SpanlessEq, SpanlessHash};
 use if_chain::if_chain;
@@ -717,28 +717,6 @@ fn check_single_match_single_pattern(
     }
 }
 
-fn peel_pat_refs(pat: &'a Pat<'a>) -> (&'a Pat<'a>, usize) {
-    fn peel(pat: &'a Pat<'a>, count: usize) -> (&'a Pat<'a>, usize) {
-        if let PatKind::Ref(pat, _) = pat.kind {
-            peel(pat, count + 1)
-        } else {
-            (pat, count)
-        }
-    }
-    peel(pat, 0)
-}
-
-fn peel_ty_refs(ty: Ty<'_>) -> (Ty<'_>, usize) {
-    fn peel(ty: Ty<'_>, count: usize) -> (Ty<'_>, usize) {
-        if let ty::Ref(_, ty, _) = ty.kind() {
-            peel(ty, count + 1)
-        } else {
-            (ty, count)
-        }
-    }
-    peel(ty, 0)
-}
-
 fn report_single_match_single_pattern(
     cx: &LateContext<'_>,
     ex: &Expr<'_>,
@@ -752,9 +730,9 @@ fn report_single_match_single_pattern(
     });
 
     let (msg, sugg) = if_chain! {
-        let (pat, pat_ref_count) = peel_pat_refs(arms[0].pat);
+        let (pat, pat_ref_count) = peel_hir_pat_refs(arms[0].pat);
         if let PatKind::Path(_) | PatKind::Lit(_) = pat.kind;
-        let (ty, ty_ref_count) = peel_ty_refs(cx.typeck_results().expr_ty(ex));
+        let (ty, ty_ref_count) = peel_mid_ty_refs(cx.typeck_results().expr_ty(ex));
         if let Some(trait_id) = cx.tcx.lang_items().structural_peq_trait();
         if ty.is_integral() || ty.is_char() || ty.is_str() || implements_trait(cx, ty, trait_id, &[]);
         then {
@@ -764,19 +742,28 @@ fn report_single_match_single_pattern(
                 PatKind::Lit(Expr { kind: ExprKind::Lit(lit), .. }) if lit.node.is_str() => pat_ref_count + 1,
                 _ => pat_ref_count,
             };
-            let msg = "you seem to be trying to use match for an equality check. Consider using `if`";
+            // References are only implicitly added to the pattern, so no overflow here.
+            // e.g. will work: match &Some(_) { Some(_) => () }
+            // will not: match Some(_) { &Some(_) => () }
+            let ref_count_diff = ty_ref_count - pat_ref_count;
+
+            // Try to remove address of expressions first.
+            let (ex, removed) = peeln_hir_expr_refs(ex, ref_count_diff);
+            let ref_count_diff = ref_count_diff - removed;
+
+            let msg = "you seem to be trying to use `match` for an equality check. Consider using `if`";
             let sugg = format!(
                 "if {} == {}{} {}{}",
                 snippet(cx, ex.span, ".."),
                 // PartialEq for different reference counts may not exist.
-                "&".repeat(ty_ref_count - pat_ref_count),
+                "&".repeat(ref_count_diff),
                 snippet(cx, arms[0].pat.span, ".."),
                 expr_block(cx, &arms[0].body, None, "..", Some(expr.span)),
                 els_str,
             );
             (msg, sugg)
         } else {
-            let msg = "you seem to be trying to use match for destructuring a single pattern. Consider using `if let`";
+            let msg = "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`";
             let sugg = format!(
                 "if let {} = {} {}{}",
                 snippet(cx, arms[0].pat.span, ".."),
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index 8f54cad7728..8f8c681ecb7 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -1668,6 +1668,44 @@ where
     match_expr_list
 }
 
+/// Peels off all references on the pattern. Returns the underlying pattern and the number of
+/// references removed.
+pub fn peel_hir_pat_refs(pat: &'a Pat<'a>) -> (&'a Pat<'a>, usize) {
+    fn peel(pat: &'a Pat<'a>, count: usize) -> (&'a Pat<'a>, usize) {
+        if let PatKind::Ref(pat, _) = pat.kind {
+            peel(pat, count + 1)
+        } else {
+            (pat, count)
+        }
+    }
+    peel(pat, 0)
+}
+
+/// Peels off up to the given number of references on the expression. Returns the underlying
+/// expression and the number of references removed.
+pub fn peeln_hir_expr_refs(expr: &'a Expr<'a>, count: usize) -> (&'a Expr<'a>, usize) {
+    fn f(expr: &'a Expr<'a>, count: usize, target: usize) -> (&'a Expr<'a>, usize) {
+        match expr.kind {
+            ExprKind::AddrOf(_, _, expr) if count != target => f(expr, count + 1, target),
+            _ => (expr, count),
+        }
+    }
+    f(expr, 0, count)
+}
+
+/// Peels off all references on the type. Returns the underlying type and the number of references
+/// removed.
+pub fn peel_mid_ty_refs(ty: Ty<'_>) -> (Ty<'_>, usize) {
+    fn peel(ty: Ty<'_>, count: usize) -> (Ty<'_>, usize) {
+        if let ty::Ref(_, ty, _) = ty.kind() {
+            peel(ty, count + 1)
+        } else {
+            (ty, count)
+        }
+    }
+    peel(ty, 0)
+}
+
 #[macro_export]
 macro_rules! unwrap_cargo_metadata {
     ($cx: ident, $lint: ident, $deps: expr) => {{
diff --git a/tests/ui/single_match.rs b/tests/ui/single_match.rs
index 02266308fba..ca884b41c45 100644
--- a/tests/ui/single_match.rs
+++ b/tests/ui/single_match.rs
@@ -81,7 +81,8 @@ fn single_match_know_enum() {
     }
 }
 
-fn issue_173() {
+// issue #173
+fn if_suggestion() {
     let x = "test";
     match x {
         "test" => println!(),
@@ -106,6 +107,18 @@ fn issue_173() {
         FOO_C => println!(),
         _ => (),
     }
+
+    match &&x {
+        Foo::A => println!(),
+        _ => (),
+    }
+
+    let x = &x;
+    match &x {
+        Foo::A => println!(),
+        _ => (),
+    }
+
     enum Bar {
         A,
         B,
diff --git a/tests/ui/single_match.stderr b/tests/ui/single_match.stderr
index 5eca07ab109..7ea6955b740 100644
--- a/tests/ui/single_match.stderr
+++ b/tests/ui/single_match.stderr
@@ -1,4 +1,4 @@
-error: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
+error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
   --> $DIR/single_match.rs:8:5
    |
 LL | /     match x {
@@ -17,7 +17,7 @@ LL |         println!("{:?}", y);
 LL |     };
    |
 
-error: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
+error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
   --> $DIR/single_match.rs:16:5
    |
 LL | /     match x {
@@ -29,7 +29,7 @@ LL | |         _ => (),
 LL | |     }
    | |_____^ help: try this: `if let Some(y) = x { println!("{:?}", y) }`
 
-error: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
+error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
   --> $DIR/single_match.rs:25:5
    |
 LL | /     match z {
@@ -38,7 +38,7 @@ LL | |         _ => {},
 LL | |     };
    | |_____^ help: try this: `if let (2..=3, 7..=9) = z { dummy() }`
 
-error: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
+error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
   --> $DIR/single_match.rs:54:5
    |
 LL | /     match x {
@@ -47,7 +47,7 @@ LL | |         None => (),
 LL | |     };
    | |_____^ help: try this: `if let Some(y) = x { dummy() }`
 
-error: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
+error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
   --> $DIR/single_match.rs:59:5
    |
 LL | /     match y {
@@ -56,7 +56,7 @@ LL | |         Err(..) => (),
 LL | |     };
    | |_____^ help: try this: `if let Ok(y) = y { dummy() }`
 
-error: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
+error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
   --> $DIR/single_match.rs:66:5
    |
 LL | /     match c {
@@ -65,8 +65,8 @@ LL | |         Cow::Owned(..) => (),
 LL | |     };
    | |_____^ help: try this: `if let Cow::Borrowed(..) = c { dummy() }`
 
-error: you seem to be trying to use match for an equality check. Consider using `if`
-  --> $DIR/single_match.rs:86:5
+error: you seem to be trying to use `match` for an equality check. Consider using `if`
+  --> $DIR/single_match.rs:87:5
    |
 LL | /     match x {
 LL | |         "test" => println!(),
@@ -74,8 +74,8 @@ LL | |         _ => (),
 LL | |     }
    | |_____^ help: try this: `if x == "test" { println!() }`
 
-error: you seem to be trying to use match for an equality check. Consider using `if`
-  --> $DIR/single_match.rs:99:5
+error: you seem to be trying to use `match` for an equality check. Consider using `if`
+  --> $DIR/single_match.rs:100:5
    |
 LL | /     match x {
 LL | |         Foo::A => println!(),
@@ -83,8 +83,8 @@ LL | |         _ => (),
 LL | |     }
    | |_____^ help: try this: `if x == Foo::A { println!() }`
 
-error: you seem to be trying to use match for an equality check. Consider using `if`
-  --> $DIR/single_match.rs:105:5
+error: you seem to be trying to use `match` for an equality check. Consider using `if`
+  --> $DIR/single_match.rs:106:5
    |
 LL | /     match x {
 LL | |         FOO_C => println!(),
@@ -92,8 +92,26 @@ LL | |         _ => (),
 LL | |     }
    | |_____^ help: try this: `if x == FOO_C { println!() }`
 
-error: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
-  --> $DIR/single_match.rs:121:5
+error: you seem to be trying to use `match` for an equality check. Consider using `if`
+  --> $DIR/single_match.rs:111:5
+   |
+LL | /     match &&x {
+LL | |         Foo::A => println!(),
+LL | |         _ => (),
+LL | |     }
+   | |_____^ help: try this: `if x == Foo::A { println!() }`
+
+error: you seem to be trying to use `match` for an equality check. Consider using `if`
+  --> $DIR/single_match.rs:117:5
+   |
+LL | /     match &x {
+LL | |         Foo::A => println!(),
+LL | |         _ => (),
+LL | |     }
+   | |_____^ help: try this: `if x == &Foo::A { println!() }`
+
+error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
+  --> $DIR/single_match.rs:134:5
    |
 LL | /     match x {
 LL | |         Bar::A => println!(),
@@ -101,5 +119,5 @@ LL | |         _ => (),
 LL | |     }
    | |_____^ help: try this: `if let Bar::A = x { println!() }`
 
-error: aborting due to 10 previous errors
+error: aborting due to 12 previous errors
 
diff --git a/tests/ui/single_match_else.stderr b/tests/ui/single_match_else.stderr
index 3a07c2ec542..20be4fa226c 100644
--- a/tests/ui/single_match_else.stderr
+++ b/tests/ui/single_match_else.stderr
@@ -1,4 +1,4 @@
-error: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
+error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
   --> $DIR/single_match_else.rs:14:5
    |
 LL | /     match ExprNode::Butterflies {
@@ -19,7 +19,7 @@ LL |         None
 LL |     }
    |
 
-error: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
+error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
   --> $DIR/single_match_else.rs:70:5
    |
 LL | /     match Some(1) {
@@ -39,7 +39,7 @@ LL |         return
 LL |     }
    |
 
-error: you seem to be trying to use match for destructuring a single pattern. Consider using `if let`
+error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
   --> $DIR/single_match_else.rs:79:5
    |
 LL | /     match Some(1) {
-- 
cgit 1.4.1-3-g733a5


From 36ff2f739c62f81d5ecc1850d9f3354d15de928d Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Thu, 14 Jan 2021 22:02:04 -0500
Subject: Rename function

---
 clippy_lints/src/matches.rs   | 4 ++--
 clippy_lints/src/utils/mod.rs | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index 6ecd738d2f0..02021b87369 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -4,7 +4,7 @@ use crate::utils::usage::is_unused;
 use crate::utils::{
     expr_block, get_arg_name, get_parent_expr, implements_trait, in_macro, indent_of, is_allowed, is_expn_of,
     is_refutable, is_type_diagnostic_item, is_wild, match_qpath, match_type, match_var, meets_msrv, multispan_sugg,
-    peel_hir_pat_refs, peel_mid_ty_refs, peeln_hir_expr_refs, remove_blocks, snippet, snippet_block, snippet_opt,
+    peel_hir_pat_refs, peel_mid_ty_refs, peel_n_hir_expr_refs, remove_blocks, snippet, snippet_block, snippet_opt,
     snippet_with_applicability, span_lint_and_help, span_lint_and_note, span_lint_and_sugg, span_lint_and_then,
 };
 use crate::utils::{paths, search_same, SpanlessEq, SpanlessHash};
@@ -748,7 +748,7 @@ fn report_single_match_single_pattern(
             let ref_count_diff = ty_ref_count - pat_ref_count;
 
             // Try to remove address of expressions first.
-            let (ex, removed) = peeln_hir_expr_refs(ex, ref_count_diff);
+            let (ex, removed) = peel_n_hir_expr_refs(ex, ref_count_diff);
             let ref_count_diff = ref_count_diff - removed;
 
             let msg = "you seem to be trying to use `match` for an equality check. Consider using `if`";
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index 8f8c681ecb7..f81bf088ec4 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -1683,7 +1683,7 @@ pub fn peel_hir_pat_refs(pat: &'a Pat<'a>) -> (&'a Pat<'a>, usize) {
 
 /// Peels off up to the given number of references on the expression. Returns the underlying
 /// expression and the number of references removed.
-pub fn peeln_hir_expr_refs(expr: &'a Expr<'a>, count: usize) -> (&'a Expr<'a>, usize) {
+pub fn peel_n_hir_expr_refs(expr: &'a Expr<'a>, count: usize) -> (&'a Expr<'a>, usize) {
     fn f(expr: &'a Expr<'a>, count: usize, target: usize) -> (&'a Expr<'a>, usize) {
         match expr.kind {
             ExprKind::AddrOf(_, _, expr) if count != target => f(expr, count + 1, target),
-- 
cgit 1.4.1-3-g733a5


From f18cf82ca8764d6b0b07549cdba25b91bd0243fa Mon Sep 17 00:00:00 2001
From: flip1995 <philipp.krones@embecosm.com>
Date: Fri, 15 Jan 2021 10:41:29 +0100
Subject: Don't trigger needless_return lint in macros

---
 clippy_lints/src/returns.rs    |  3 +++
 tests/ui/needless_return.fixed | 15 +++++++++++++++
 tests/ui/needless_return.rs    | 15 +++++++++++++++
 3 files changed, 33 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
index 0e031e6151b..63548d8fdb4 100644
--- a/clippy_lints/src/returns.rs
+++ b/clippy_lints/src/returns.rs
@@ -217,6 +217,9 @@ fn check_final_expr<'tcx>(
 }
 
 fn emit_return_lint(cx: &LateContext<'_>, ret_span: Span, inner_span: Option<Span>, replacement: RetReplacement) {
+    if ret_span.from_expansion() {
+        return;
+    }
     match inner_span {
         Some(inner_span) => {
             if in_external_macro(cx.tcx.sess, inner_span) || inner_span.from_expansion() {
diff --git a/tests/ui/needless_return.fixed b/tests/ui/needless_return.fixed
index d849e093da7..86bfc5b4bb2 100644
--- a/tests/ui/needless_return.fixed
+++ b/tests/ui/needless_return.fixed
@@ -86,6 +86,21 @@ fn borrows_but_not_last(value: bool) -> String {
     }
 }
 
+macro_rules! needed_return {
+    ($e:expr) => {
+        if $e > 3 {
+            return;
+        }
+    };
+}
+
+fn test_return_in_macro() {
+    // This will return and the macro below won't be executed. Removing the `return` from the macro
+    // will change semantics.
+    needed_return!(10);
+    needed_return!(0);
+}
+
 fn main() {
     let _ = test_end_of_fn();
     let _ = test_no_semicolon();
diff --git a/tests/ui/needless_return.rs b/tests/ui/needless_return.rs
index 29f2bd1852a..51061370dfe 100644
--- a/tests/ui/needless_return.rs
+++ b/tests/ui/needless_return.rs
@@ -86,6 +86,21 @@ fn borrows_but_not_last(value: bool) -> String {
     }
 }
 
+macro_rules! needed_return {
+    ($e:expr) => {
+        if $e > 3 {
+            return;
+        }
+    };
+}
+
+fn test_return_in_macro() {
+    // This will return and the macro below won't be executed. Removing the `return` from the macro
+    // will change semantics.
+    needed_return!(10);
+    needed_return!(0);
+}
+
 fn main() {
     let _ = test_end_of_fn();
     let _ = test_no_semicolon();
-- 
cgit 1.4.1-3-g733a5


From 83f1abff4874a66124a6aaefec248ca4051c0d23 Mon Sep 17 00:00:00 2001
From: ThibsG <Thibs@debian.com>
Date: Mon, 4 Jan 2021 21:20:44 +0100
Subject: Fix FP with empty return for `needless_return` lint

---
 clippy_lints/src/returns.rs     | 11 ++++++++++-
 tests/ui/needless_return.fixed  | 13 +++++++++++++
 tests/ui/needless_return.rs     | 13 +++++++++++++
 tests/ui/needless_return.stderr | 20 +++++++++++++++++++-
 4 files changed, 55 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
index 63548d8fdb4..e438f92b136 100644
--- a/clippy_lints/src/returns.rs
+++ b/clippy_lints/src/returns.rs
@@ -131,7 +131,16 @@ impl<'tcx> LateLintPass<'tcx> for Return {
         _: HirId,
     ) {
         match kind {
-            FnKind::Closure(_) => check_final_expr(cx, &body.value, Some(body.value.span), RetReplacement::Empty),
+            FnKind::Closure(_) => {
+                // when returning without value in closure, replace this `return`
+                // with an empty block to prevent invalid suggestion (see #6501)
+                let replacement = if let ExprKind::Ret(None) = &body.value.kind {
+                    RetReplacement::Block
+                } else {
+                    RetReplacement::Empty
+                };
+                check_final_expr(cx, &body.value, Some(body.value.span), replacement)
+            },
             FnKind::ItemFn(..) | FnKind::Method(..) => {
                 if let ExprKind::Block(ref block, _) = body.value.kind {
                     check_block_return(cx, block);
diff --git a/tests/ui/needless_return.fixed b/tests/ui/needless_return.fixed
index 86bfc5b4bb2..f137e8ecae9 100644
--- a/tests/ui/needless_return.fixed
+++ b/tests/ui/needless_return.fixed
@@ -101,6 +101,19 @@ fn test_return_in_macro() {
     needed_return!(0);
 }
 
+mod issue6501 {
+    fn foo(bar: Result<(), ()>) {
+        bar.unwrap_or_else(|_| {})
+    }
+
+    fn test_closure() {
+        let _ = || {
+            
+        };
+        let _ = || {};
+    }
+}
+
 fn main() {
     let _ = test_end_of_fn();
     let _ = test_no_semicolon();
diff --git a/tests/ui/needless_return.rs b/tests/ui/needless_return.rs
index 51061370dfe..d754e4d37a8 100644
--- a/tests/ui/needless_return.rs
+++ b/tests/ui/needless_return.rs
@@ -101,6 +101,19 @@ fn test_return_in_macro() {
     needed_return!(0);
 }
 
+mod issue6501 {
+    fn foo(bar: Result<(), ()>) {
+        bar.unwrap_or_else(|_| return)
+    }
+
+    fn test_closure() {
+        let _ = || {
+            return;
+        };
+        let _ = || return;
+    }
+}
+
 fn main() {
     let _ = test_end_of_fn();
     let _ = test_no_semicolon();
diff --git a/tests/ui/needless_return.stderr b/tests/ui/needless_return.stderr
index f73c833a801..12d94e892ed 100644
--- a/tests/ui/needless_return.stderr
+++ b/tests/ui/needless_return.stderr
@@ -84,5 +84,23 @@ error: unneeded `return` statement
 LL |         return String::new();
    |         ^^^^^^^^^^^^^^^^^^^^^ help: remove `return`: `String::new()`
 
-error: aborting due to 14 previous errors
+error: unneeded `return` statement
+  --> $DIR/needless_return.rs:91:32
+   |
+LL |         bar.unwrap_or_else(|_| return)
+   |                                ^^^^^^ help: replace `return` with an empty block: `{}`
+
+error: unneeded `return` statement
+  --> $DIR/needless_return.rs:96:13
+   |
+LL |             return;
+   |             ^^^^^^^ help: remove `return`
+
+error: unneeded `return` statement
+  --> $DIR/needless_return.rs:98:20
+   |
+LL |         let _ = || return;
+   |                    ^^^^^^ help: replace `return` with an empty block: `{}`
+
+error: aborting due to 17 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 837bc9906552af5da429bef4b37be588b8d2f49d Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Thu, 31 Dec 2020 11:10:13 -0500
Subject: Initial implementation of redundant_slicing lint

---
 CHANGELOG.md                          |  1 +
 clippy_lints/src/lib.rs               |  5 ++++
 clippy_lints/src/redundant_slicing.rs | 56 +++++++++++++++++++++++++++++++++++
 tests/ui/redundant_slicing.rs         | 11 +++++++
 tests/ui/redundant_slicing.stderr     | 16 ++++++++++
 5 files changed, 89 insertions(+)
 create mode 100644 clippy_lints/src/redundant_slicing.rs
 create mode 100644 tests/ui/redundant_slicing.rs
 create mode 100644 tests/ui/redundant_slicing.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index b0e9ad55b4f..85f6929f924 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2162,6 +2162,7 @@ Released 2018-09-13
 [`redundant_pattern`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_pattern
 [`redundant_pattern_matching`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_pattern_matching
 [`redundant_pub_crate`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_pub_crate
+[`redundant_slicing`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_slicing
 [`redundant_static_lifetimes`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_static_lifetimes
 [`ref_in_deref`]: https://rust-lang.github.io/rust-clippy/master/index.html#ref_in_deref
 [`ref_option_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#ref_option_ref
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 4f9ebb4af3d..70fdfd22caa 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -301,6 +301,7 @@ mod redundant_closure_call;
 mod redundant_else;
 mod redundant_field_names;
 mod redundant_pub_crate;
+mod redundant_slicing;
 mod redundant_static_lifetimes;
 mod ref_option_ref;
 mod reference;
@@ -849,6 +850,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &redundant_else::REDUNDANT_ELSE,
         &redundant_field_names::REDUNDANT_FIELD_NAMES,
         &redundant_pub_crate::REDUNDANT_PUB_CRATE,
+        &redundant_slicing::REDUNDANT_SLICING,
         &redundant_static_lifetimes::REDUNDANT_STATIC_LIFETIMES,
         &ref_option_ref::REF_OPTION_REF,
         &reference::DEREF_ADDROF,
@@ -1229,6 +1231,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box vec_init_then_push::VecInitThenPush::default());
     store.register_late_pass(move || box types::PtrAsPtr::new(msrv));
     store.register_late_pass(|| box case_sensitive_file_extension_comparisons::CaseSensitiveFileExtensionComparisons);
+    store.register_late_pass(|| box redundant_slicing::RedundantSlicing);
 
     store.register_group(true, "clippy::restriction", Some("clippy_restriction"), vec![
         LintId::of(&arithmetic::FLOAT_ARITHMETIC),
@@ -1591,6 +1594,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&redundant_clone::REDUNDANT_CLONE),
         LintId::of(&redundant_closure_call::REDUNDANT_CLOSURE_CALL),
         LintId::of(&redundant_field_names::REDUNDANT_FIELD_NAMES),
+        LintId::of(&redundant_slicing::REDUNDANT_SLICING),
         LintId::of(&redundant_static_lifetimes::REDUNDANT_STATIC_LIFETIMES),
         LintId::of(&reference::DEREF_ADDROF),
         LintId::of(&reference::REF_IN_DEREF),
@@ -1835,6 +1839,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&ptr_offset_with_cast::PTR_OFFSET_WITH_CAST),
         LintId::of(&ranges::RANGE_ZIP_WITH_LEN),
         LintId::of(&redundant_closure_call::REDUNDANT_CLOSURE_CALL),
+        LintId::of(&redundant_slicing::REDUNDANT_SLICING),
         LintId::of(&reference::DEREF_ADDROF),
         LintId::of(&reference::REF_IN_DEREF),
         LintId::of(&repeat_once::REPEAT_ONCE),
diff --git a/clippy_lints/src/redundant_slicing.rs b/clippy_lints/src/redundant_slicing.rs
new file mode 100644
index 00000000000..686298b6943
--- /dev/null
+++ b/clippy_lints/src/redundant_slicing.rs
@@ -0,0 +1,56 @@
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind, LangItem};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::TyS;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+use crate::utils::{is_type_lang_item, snippet_with_applicability, span_lint_and_sugg};
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for redundant slicing expressions which use the full range, and
+    /// do not change the type.
+    ///
+    /// **Why is this bad?** It unnecessarily adds complexity to the expression.
+    ///
+    /// **Known problems:** If the type being sliced has an implementation of `Index<RangeFull>`
+    /// that actually changes anything then it can't be removed. However, this would be surprising
+    /// to people reading the code and should have a note with it.
+    ///
+    /// **Example:**
+    ///
+    /// ```ignore
+    /// fn get_slice(x: &[u32]) -> &[u32] {
+    ///     &x[..]
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```ignore
+    /// fn get_slice(x: &[u32]) -> &[u32] {
+    ///     x
+    /// }
+    /// ```
+    pub REDUNDANT_SLICING,
+    complexity,
+    "redundant slicing of the whole range of a type"
+}
+
+declare_lint_pass!(RedundantSlicing => [REDUNDANT_SLICING]);
+
+impl LateLintPass<'_> for RedundantSlicing {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        if_chain! {
+            if let ExprKind::AddrOf(_, _, addressee) = expr.kind;
+            if let ExprKind::Index(indexed, range) = addressee.kind;
+            if is_type_lang_item(cx, cx.typeck_results().expr_ty_adjusted(range), LangItem::RangeFull);
+            if TyS::same_type(cx.typeck_results().expr_ty(expr), cx.typeck_results().expr_ty(indexed));
+            then {
+                let mut app = Applicability::MachineApplicable;
+                let hint = snippet_with_applicability(cx, indexed.span, "..", &mut app).into_owned();
+
+                span_lint_and_sugg(cx, REDUNDANT_SLICING, expr.span, "redundant slicing of the whole range",
+                    "use the original slice instead", hint, app);
+            }
+        }
+    }
+}
diff --git a/tests/ui/redundant_slicing.rs b/tests/ui/redundant_slicing.rs
new file mode 100644
index 00000000000..922b8b4ce57
--- /dev/null
+++ b/tests/ui/redundant_slicing.rs
@@ -0,0 +1,11 @@
+#![allow(unused)]
+#![warn(clippy::redundant_slicing)]
+
+fn main() {
+    let x: &[u32] = &[0];
+    let err = &x[..];
+
+    let v = vec![0];
+    let ok = &v[..];
+    let err = &(&v[..])[..];
+}
diff --git a/tests/ui/redundant_slicing.stderr b/tests/ui/redundant_slicing.stderr
new file mode 100644
index 00000000000..9efd6484ad0
--- /dev/null
+++ b/tests/ui/redundant_slicing.stderr
@@ -0,0 +1,16 @@
+error: redundant slicing of the whole range
+  --> $DIR/redundant_slicing.rs:6:15
+   |
+LL |     let err = &x[..];
+   |               ^^^^^^ help: use the original slice instead: `x`
+   |
+   = note: `-D clippy::redundant-slicing` implied by `-D warnings`
+
+error: redundant slicing of the whole range
+  --> $DIR/redundant_slicing.rs:10:15
+   |
+LL |     let err = &(&v[..])[..];
+   |               ^^^^^^^^^^^^^ help: use the original slice instead: `(&v[..])`
+
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 2a41d40807ccf01268c29ba64ac9ea0efe1b26f7 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Thu, 31 Dec 2020 11:42:12 -0500
Subject: fix new lint error

---
 clippy_lints/src/map_unit_fn.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/map_unit_fn.rs b/clippy_lints/src/map_unit_fn.rs
index e50d11a4d71..01126e86199 100644
--- a/clippy_lints/src/map_unit_fn.rs
+++ b/clippy_lints/src/map_unit_fn.rs
@@ -131,7 +131,7 @@ fn reduce_unit_expression<'a>(cx: &LateContext<'_>, expr: &'a hir::Expr<'_>) ->
             Some(expr.span)
         },
         hir::ExprKind::Block(ref block, _) => {
-            match (&block.stmts[..], block.expr.as_ref()) {
+            match (block.stmts, block.expr.as_ref()) {
                 (&[], Some(inner_expr)) => {
                     // If block only contains an expression,
                     // reduce `{ X }` to `X`
-- 
cgit 1.4.1-3-g733a5


From 27c0d6c14bde219bcaf72b4bcb6426f6f8650f6e Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Thu, 31 Dec 2020 12:07:24 -0500
Subject: don't lint external macro expansions

---
 clippy_lints/src/redundant_slicing.rs | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/redundant_slicing.rs b/clippy_lints/src/redundant_slicing.rs
index 686298b6943..5140b30a473 100644
--- a/clippy_lints/src/redundant_slicing.rs
+++ b/clippy_lints/src/redundant_slicing.rs
@@ -2,7 +2,7 @@ use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, LangItem};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty::TyS;
+use rustc_middle::{lint::in_external_macro, ty::TyS};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 use crate::utils::{is_type_lang_item, snippet_with_applicability, span_lint_and_sugg};
@@ -39,6 +39,10 @@ declare_lint_pass!(RedundantSlicing => [REDUNDANT_SLICING]);
 
 impl LateLintPass<'_> for RedundantSlicing {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        if in_external_macro(cx.sess, expr.span) {
+            return;
+        }
+
         if_chain! {
             if let ExprKind::AddrOf(_, _, addressee) = expr.kind;
             if let ExprKind::Index(indexed, range) = addressee.kind;
-- 
cgit 1.4.1-3-g733a5


From bf028b3f4a440bc8a390837da3a3f940177de1e6 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Thu, 31 Dec 2020 14:40:07 -0500
Subject: fix copy-paste error

---
 clippy_lints/src/redundant_slicing.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/redundant_slicing.rs b/clippy_lints/src/redundant_slicing.rs
index 5140b30a473..4478f559266 100644
--- a/clippy_lints/src/redundant_slicing.rs
+++ b/clippy_lints/src/redundant_slicing.rs
@@ -1,7 +1,7 @@
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, LangItem};
-use rustc_lint::{LateContext, LateLintPass};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::{lint::in_external_macro, ty::TyS};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
@@ -39,7 +39,7 @@ declare_lint_pass!(RedundantSlicing => [REDUNDANT_SLICING]);
 
 impl LateLintPass<'_> for RedundantSlicing {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if in_external_macro(cx.sess, expr.span) {
+        if in_external_macro(cx.sess(), expr.span) {
             return;
         }
 
-- 
cgit 1.4.1-3-g733a5


From 9146a77032e7d8c96ccae177c60ddb04b6159329 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Thu, 14 Jan 2021 21:38:57 +0000
Subject: Update clippy_lints/src/redundant_slicing.rs

Co-authored-by: Philipp Krones <hello@philkrones.com>
---
 clippy_lints/src/redundant_slicing.rs | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/redundant_slicing.rs b/clippy_lints/src/redundant_slicing.rs
index 4478f559266..e5ced13514f 100644
--- a/clippy_lints/src/redundant_slicing.rs
+++ b/clippy_lints/src/redundant_slicing.rs
@@ -52,8 +52,15 @@ impl LateLintPass<'_> for RedundantSlicing {
                 let mut app = Applicability::MachineApplicable;
                 let hint = snippet_with_applicability(cx, indexed.span, "..", &mut app).into_owned();
 
-                span_lint_and_sugg(cx, REDUNDANT_SLICING, expr.span, "redundant slicing of the whole range",
-                    "use the original slice instead", hint, app);
+                span_lint_and_sugg(
+                    cx,
+                    REDUNDANT_SLICING,
+                    expr.span,
+                    "redundant slicing of the whole range",
+                    "use the original slice instead",
+                    hint,
+                    app,
+                );
             }
         }
     }
-- 
cgit 1.4.1-3-g733a5


From 0d542b7310294a32023e935916a4d8c8f47ec1a8 Mon Sep 17 00:00:00 2001
From: pro-grammer1 <1df0d0d3-eed4-45fc-bc60-43a85079f3f9@anonaddy.me>
Date: Sun, 17 Jan 2021 08:48:37 +0000
Subject: Run tests/ui/update-all-references.sh and refactor match into
 matches!

---
 clippy_lints/src/write.rs | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs
index 78d23e1e0ef..52118a56bb6 100644
--- a/clippy_lints/src/write.rs
+++ b/clippy_lints/src/write.rs
@@ -470,10 +470,7 @@ impl Write {
                 ExprKind::Assign(lhs, rhs, _) => {
                     if_chain! {
                         if let ExprKind::Lit(ref lit) = rhs.kind;
-                        if match lit.kind {
-                            LitKind::Int(_, _) | LitKind::Float(_, _) => false,
-                            _ => true,
-                        };
+                        if matches!(lit.kind, LitKind::Int(..) | LitKind::Float(..));
                         if let ExprKind::Path(_, p) = &lhs.kind;
                         then {
                             let mut all_simple = true;
-- 
cgit 1.4.1-3-g733a5


From 0c347d3d0686d8892512dcc1e13102d15afcc6dd Mon Sep 17 00:00:00 2001
From: Marc Dominik Migge <marcmigge@gmx.net>
Date: Sun, 17 Jan 2021 14:42:36 +0100
Subject: Fix false positive for unit_arg lint

---
 clippy_lints/src/types.rs | 11 ++++++++++-
 tests/ui/unit_arg.rs      | 20 +++++++++++++++++++-
 tests/ui/unit_arg.stderr  | 46 ++++++++++++++++++++++++++++++++++++++++++----
 3 files changed, 71 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs
index 3b5a83d2a0b..7d0eea37bc0 100644
--- a/clippy_lints/src/types.rs
+++ b/clippy_lints/src/types.rs
@@ -955,7 +955,16 @@ impl<'tcx> LateLintPass<'tcx> for UnitArg {
                     .iter()
                     .filter(|arg| {
                         if is_unit(cx.typeck_results().expr_ty(arg)) && !is_unit_literal(arg) {
-                            !matches!(&arg.kind, ExprKind::Match(.., MatchSource::TryDesugar))
+                            match &arg.kind {
+                                ExprKind::Block(..)
+                                | ExprKind::Call(..)
+                                | ExprKind::If(..)
+                                | ExprKind::MethodCall(..) => true,
+                                ExprKind::Match(..) => {
+                                    !matches!(&arg.kind, ExprKind::Match(.., MatchSource::TryDesugar))
+                                },
+                                _ => false,
+                            }
                         } else {
                             false
                         }
diff --git a/tests/ui/unit_arg.rs b/tests/ui/unit_arg.rs
index b6a7bc5a1cc..79dac925f08 100644
--- a/tests/ui/unit_arg.rs
+++ b/tests/ui/unit_arg.rs
@@ -59,7 +59,18 @@ fn bad() {
     None.or(Some(foo(2)));
     // in this case, the suggestion can be inlined, no need for a surrounding block
     // foo(()); foo(()) instead of { foo(()); foo(()) }
-    foo(foo(()))
+    foo(foo(()));
+    foo(if true {
+        1;
+    });
+    foo(match Some(1) {
+        Some(_) => {
+            1;
+        },
+        None => {
+            0;
+        },
+    });
 }
 
 fn ok() {
@@ -71,6 +82,13 @@ fn ok() {
     b.bar({ 1 });
     b.bar(());
     question_mark();
+    let named_unit_arg = ();
+    foo(named_unit_arg);
+    foo(if true { 1 } else { 0 });
+    foo(match Some(1) {
+        Some(_) => 1,
+        None => 0,
+    });
 }
 
 fn question_mark() -> Result<(), ()> {
diff --git a/tests/ui/unit_arg.stderr b/tests/ui/unit_arg.stderr
index 094cff8c985..8679706f8ec 100644
--- a/tests/ui/unit_arg.stderr
+++ b/tests/ui/unit_arg.stderr
@@ -156,17 +156,55 @@ LL |     });
 error: passing a unit value to a function
   --> $DIR/unit_arg.rs:62:5
    |
-LL |     foo(foo(()))
+LL |     foo(foo(()));
    |     ^^^^^^^^^^^^
    |
 help: move the expression in front of the call and replace it with the unit literal `()`
    |
 LL |     foo(());
-LL |     foo(())
+LL |     foo(());
+   |
+
+error: passing a unit value to a function
+  --> $DIR/unit_arg.rs:63:5
+   |
+LL | /     foo(if true {
+LL | |         1;
+LL | |     });
+   | |______^
+   |
+help: move the expression in front of the call and replace it with the unit literal `()`
+   |
+LL |     if true {
+LL |         1;
+LL |     };
+LL |     foo(());
+   |
+
+error: passing a unit value to a function
+  --> $DIR/unit_arg.rs:66:5
    |
+LL | /     foo(match Some(1) {
+LL | |         Some(_) => {
+LL | |             1;
+LL | |         },
+...  |
+LL | |         },
+LL | |     });
+   | |______^
+   |
+help: move the expression in front of the call and replace it with the unit literal `()`
+   |
+LL |     match Some(1) {
+LL |         Some(_) => {
+LL |             1;
+LL |         },
+LL |         None => {
+LL |             0;
+ ...
 
 error: passing a unit value to a function
-  --> $DIR/unit_arg.rs:95:5
+  --> $DIR/unit_arg.rs:113:5
    |
 LL |     Some(foo(1))
    |     ^^^^^^^^^^^^
@@ -177,5 +215,5 @@ LL |     foo(1);
 LL |     Some(())
    |
 
-error: aborting due to 10 previous errors
+error: aborting due to 12 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 2af642da28109c96145c7a5613ae2ec37d359448 Mon Sep 17 00:00:00 2001
From: pro-grammer1 <1df0d0d3-eed4-45fc-bc60-43a85079f3f9@anonaddy.me>
Date: Sun, 17 Jan 2021 18:01:01 +0000
Subject: Replace another instance of match with matches

---
 clippy_lints/src/write.rs | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs
index 52118a56bb6..6721639f724 100644
--- a/clippy_lints/src/write.rs
+++ b/clippy_lints/src/write.rs
@@ -443,12 +443,7 @@ impl Write {
                 return (Some(fmtstr), None);
             };
             match &token_expr.kind {
-                ExprKind::Lit(lit)
-                    if match lit.kind {
-                        LitKind::Int(_, _) | LitKind::Float(_, _) => false,
-                        _ => true,
-                    } =>
-                {
+                ExprKind::Lit(lit) if matches!(lit.kind, LitKind::Int(..) | LitKind::Float(..)) => {
                     let mut all_simple = true;
                     let mut seen = false;
                     for arg in &args {
-- 
cgit 1.4.1-3-g733a5


From ab155b14a27811c29e35bea76bfbf3845bc79fdf Mon Sep 17 00:00:00 2001
From: pro-grammer1 <1df0d0d3-eed4-45fc-bc60-43a85079f3f9@anonaddy.me>
Date: Sun, 17 Jan 2021 18:21:58 +0000
Subject: Negate results of matches!

---
 clippy_lints/src/write.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs
index 6721639f724..60a9fb59cd2 100644
--- a/clippy_lints/src/write.rs
+++ b/clippy_lints/src/write.rs
@@ -443,7 +443,7 @@ impl Write {
                 return (Some(fmtstr), None);
             };
             match &token_expr.kind {
-                ExprKind::Lit(lit) if matches!(lit.kind, LitKind::Int(..) | LitKind::Float(..)) => {
+                ExprKind::Lit(lit) if !matches!(lit.kind, LitKind::Int(..) | LitKind::Float(..)) => {
                     let mut all_simple = true;
                     let mut seen = false;
                     for arg in &args {
@@ -465,7 +465,7 @@ impl Write {
                 ExprKind::Assign(lhs, rhs, _) => {
                     if_chain! {
                         if let ExprKind::Lit(ref lit) = rhs.kind;
-                        if matches!(lit.kind, LitKind::Int(..) | LitKind::Float(..));
+                        if !matches!(lit.kind, LitKind::Int(..) | LitKind::Float(..));
                         if let ExprKind::Path(_, p) = &lhs.kind;
                         then {
                             let mut all_simple = true;
-- 
cgit 1.4.1-3-g733a5


From fb2a06dcce0680dfe8d2bed542be3c55eb2e18c7 Mon Sep 17 00:00:00 2001
From: pro-grammer1 <1df0d0d3-eed4-45fc-bc60-43a85079f3f9@anonaddy.me>
Date: Sun, 17 Jan 2021 18:55:59 +0000
Subject: Remove numeric literals from print_literal and write_literal tests

---
 clippy_lints/src/write.rs        |  2 +-
 tests/ui/crashes/ice-3891.stderr |  4 ++--
 tests/ui/print_literal.rs        |  3 ---
 tests/ui/print_literal.stderr    | 46 ++++++++++++----------------------------
 tests/ui/write_literal.rs        |  3 ---
 tests/ui/write_literal.stderr    | 46 ++++++++++++----------------------------
 6 files changed, 31 insertions(+), 73 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs
index 60a9fb59cd2..503cb82c3e5 100644
--- a/clippy_lints/src/write.rs
+++ b/clippy_lints/src/write.rs
@@ -461,7 +461,7 @@ impl Write {
                         span_lint(cx, lint, token_expr.span, "literal with an empty format string");
                     }
                     idx += 1;
-                }
+                },
                 ExprKind::Assign(lhs, rhs, _) => {
                     if_chain! {
                         if let ExprKind::Lit(ref lit) = rhs.kind;
diff --git a/tests/ui/crashes/ice-3891.stderr b/tests/ui/crashes/ice-3891.stderr
index 5a285b0e714..59469ec5891 100644
--- a/tests/ui/crashes/ice-3891.stderr
+++ b/tests/ui/crashes/ice-3891.stderr
@@ -1,10 +1,10 @@
-error: invalid suffix `x` for integer literal
+error: invalid suffix `x` for number literal
   --> $DIR/ice-3891.rs:2:5
    |
 LL |     1x;
    |     ^^ invalid suffix `x`
    |
-   = help: the suffix must be one of the integral types (`u32`, `isize`, etc)
+   = help: the suffix must be one of the numeric types (`u32`, `isize`, `f32`, etc.)
 
 error: aborting due to previous error
 
diff --git a/tests/ui/print_literal.rs b/tests/ui/print_literal.rs
index 40ed18e9302..0c8aecc2d8c 100644
--- a/tests/ui/print_literal.rs
+++ b/tests/ui/print_literal.rs
@@ -19,12 +19,9 @@ fn main() {
     println!("{number:>0width$}", number = 1, width = 6);
 
     // these should throw warnings
-    println!("{} of {:b} people know binary, the other half doesn't", 1, 2);
     print!("Hello {}", "world");
     println!("Hello {} {}", world, "world");
     println!("Hello {}", "world");
-    println!("10 / 4 is {}", 2.5);
-    println!("2 + 1 = {}", 3);
 
     // positional args don't change the fact
     // that we're using a literal -- this should
diff --git a/tests/ui/print_literal.stderr b/tests/ui/print_literal.stderr
index fc502e9f71d..692abdb3054 100644
--- a/tests/ui/print_literal.stderr
+++ b/tests/ui/print_literal.stderr
@@ -1,88 +1,70 @@
 error: literal with an empty format string
-  --> $DIR/print_literal.rs:22:71
-   |
-LL |     println!("{} of {:b} people know binary, the other half doesn't", 1, 2);
-   |                                                                       ^
-   |
-   = note: `-D clippy::print-literal` implied by `-D warnings`
-
-error: literal with an empty format string
-  --> $DIR/print_literal.rs:23:24
+  --> $DIR/print_literal.rs:22:24
    |
 LL |     print!("Hello {}", "world");
    |                        ^^^^^^^
+   |
+   = note: `-D clippy::print-literal` implied by `-D warnings`
 
 error: literal with an empty format string
-  --> $DIR/print_literal.rs:24:36
+  --> $DIR/print_literal.rs:23:36
    |
 LL |     println!("Hello {} {}", world, "world");
    |                                    ^^^^^^^
 
 error: literal with an empty format string
-  --> $DIR/print_literal.rs:25:26
+  --> $DIR/print_literal.rs:24:26
    |
 LL |     println!("Hello {}", "world");
    |                          ^^^^^^^
 
 error: literal with an empty format string
-  --> $DIR/print_literal.rs:26:30
-   |
-LL |     println!("10 / 4 is {}", 2.5);
-   |                              ^^^
-
-error: literal with an empty format string
-  --> $DIR/print_literal.rs:27:28
-   |
-LL |     println!("2 + 1 = {}", 3);
-   |                            ^
-
-error: literal with an empty format string
-  --> $DIR/print_literal.rs:32:25
+  --> $DIR/print_literal.rs:29:25
    |
 LL |     println!("{0} {1}", "hello", "world");
    |                         ^^^^^^^
 
 error: literal with an empty format string
-  --> $DIR/print_literal.rs:32:34
+  --> $DIR/print_literal.rs:29:34
    |
 LL |     println!("{0} {1}", "hello", "world");
    |                                  ^^^^^^^
 
 error: literal with an empty format string
-  --> $DIR/print_literal.rs:33:25
+  --> $DIR/print_literal.rs:30:25
    |
 LL |     println!("{1} {0}", "hello", "world");
    |                         ^^^^^^^
 
 error: literal with an empty format string
-  --> $DIR/print_literal.rs:33:34
+  --> $DIR/print_literal.rs:30:34
    |
 LL |     println!("{1} {0}", "hello", "world");
    |                                  ^^^^^^^
 
 error: literal with an empty format string
-  --> $DIR/print_literal.rs:36:35
+  --> $DIR/print_literal.rs:33:35
    |
 LL |     println!("{foo} {bar}", foo = "hello", bar = "world");
    |                                   ^^^^^^^
 
 error: literal with an empty format string
-  --> $DIR/print_literal.rs:36:50
+  --> $DIR/print_literal.rs:33:50
    |
 LL |     println!("{foo} {bar}", foo = "hello", bar = "world");
    |                                                  ^^^^^^^
 
 error: literal with an empty format string
-  --> $DIR/print_literal.rs:37:35
+  --> $DIR/print_literal.rs:34:35
    |
 LL |     println!("{bar} {foo}", foo = "hello", bar = "world");
    |                                   ^^^^^^^
 
 error: literal with an empty format string
-  --> $DIR/print_literal.rs:37:50
+  --> $DIR/print_literal.rs:34:50
    |
 LL |     println!("{bar} {foo}", foo = "hello", bar = "world");
    |                                                  ^^^^^^^
 
-error: aborting due to 14 previous errors
+error: aborting due to 11 previous errors
 
diff --git a/tests/ui/write_literal.rs b/tests/ui/write_literal.rs
index d8205c5eb67..f5de7ea71d3 100644
--- a/tests/ui/write_literal.rs
+++ b/tests/ui/write_literal.rs
@@ -24,12 +24,9 @@ fn main() {
     writeln!(&mut v, "{number:>0width$}", number = 1, width = 6);
 
     // these should throw warnings
-    writeln!(&mut v, "{} of {:b} people know binary, the other half doesn't", 1, 2);
     write!(&mut v, "Hello {}", "world");
     writeln!(&mut v, "Hello {} {}", world, "world");
     writeln!(&mut v, "Hello {}", "world");
-    writeln!(&mut v, "10 / 4 is {}", 2.5);
-    writeln!(&mut v, "2 + 1 = {}", 3);
 
     // positional args don't change the fact
     // that we're using a literal -- this should
diff --git a/tests/ui/write_literal.stderr b/tests/ui/write_literal.stderr
index 54a787fe555..4dcaaa474a8 100644
--- a/tests/ui/write_literal.stderr
+++ b/tests/ui/write_literal.stderr
@@ -1,88 +1,70 @@
 error: literal with an empty format string
-  --> $DIR/write_literal.rs:27:79
-   |
-LL |     writeln!(&mut v, "{} of {:b} people know binary, the other half doesn't", 1, 2);
-   |                                                                               ^
-   |
-   = note: `-D clippy::write-literal` implied by `-D warnings`
-
-error: literal with an empty format string
-  --> $DIR/write_literal.rs:28:32
+  --> $DIR/write_literal.rs:27:32
    |
 LL |     write!(&mut v, "Hello {}", "world");
    |                                ^^^^^^^
+   |
+   = note: `-D clippy::write-literal` implied by `-D warnings`
 
 error: literal with an empty format string
-  --> $DIR/write_literal.rs:29:44
+  --> $DIR/write_literal.rs:28:44
    |
 LL |     writeln!(&mut v, "Hello {} {}", world, "world");
    |                                            ^^^^^^^
 
 error: literal with an empty format string
-  --> $DIR/write_literal.rs:30:34
+  --> $DIR/write_literal.rs:29:34
    |
 LL |     writeln!(&mut v, "Hello {}", "world");
    |                                  ^^^^^^^
 
 error: literal with an empty format string
-  --> $DIR/write_literal.rs:31:38
-   |
-LL |     writeln!(&mut v, "10 / 4 is {}", 2.5);
-   |                                      ^^^
-
-error: literal with an empty format string
-  --> $DIR/write_literal.rs:32:36
-   |
-LL |     writeln!(&mut v, "2 + 1 = {}", 3);
-   |                                    ^
-
-error: literal with an empty format string
-  --> $DIR/write_literal.rs:37:33
+  --> $DIR/write_literal.rs:34:33
    |
 LL |     writeln!(&mut v, "{0} {1}", "hello", "world");
    |                                 ^^^^^^^
 
 error: literal with an empty format string
-  --> $DIR/write_literal.rs:37:42
+  --> $DIR/write_literal.rs:34:42
    |
 LL |     writeln!(&mut v, "{0} {1}", "hello", "world");
    |                                          ^^^^^^^
 
 error: literal with an empty format string
-  --> $DIR/write_literal.rs:38:33
+  --> $DIR/write_literal.rs:35:33
    |
 LL |     writeln!(&mut v, "{1} {0}", "hello", "world");
    |                                 ^^^^^^^
 
 error: literal with an empty format string
-  --> $DIR/write_literal.rs:38:42
+  --> $DIR/write_literal.rs:35:42
    |
 LL |     writeln!(&mut v, "{1} {0}", "hello", "world");
    |                                          ^^^^^^^
 
 error: literal with an empty format string
-  --> $DIR/write_literal.rs:41:43
+  --> $DIR/write_literal.rs:38:43
    |
 LL |     writeln!(&mut v, "{foo} {bar}", foo = "hello", bar = "world");
    |                                           ^^^^^^^
 
 error: literal with an empty format string
-  --> $DIR/write_literal.rs:41:58
+  --> $DIR/write_literal.rs:38:58
    |
 LL |     writeln!(&mut v, "{foo} {bar}", foo = "hello", bar = "world");
    |                                                          ^^^^^^^
 
 error: literal with an empty format string
-  --> $DIR/write_literal.rs:42:43
+  --> $DIR/write_literal.rs:39:43
    |
 LL |     writeln!(&mut v, "{bar} {foo}", foo = "hello", bar = "world");
    |                                           ^^^^^^^
 
 error: literal with an empty format string
-  --> $DIR/write_literal.rs:42:58
+  --> $DIR/write_literal.rs:39:58
    |
 LL |     writeln!(&mut v, "{bar} {foo}", foo = "hello", bar = "world");
    |                                                          ^^^^^^^
 
-error: aborting due to 14 previous errors
+error: aborting due to 11 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 70704db36fd07353de58c9330397d0137afdeebe Mon Sep 17 00:00:00 2001
From: ThibsG <Thibs@debian.com>
Date: Fri, 15 Jan 2021 18:51:00 +0100
Subject: Do not lint when range is completely included into another one

---
 clippy_lints/src/matches.rs           | 12 +++++++++++-
 tests/ui/match_overlapping_arm.rs     | 12 ++++++++++++
 tests/ui/match_overlapping_arm.stderr | 26 +-------------------------
 3 files changed, 24 insertions(+), 26 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index 04b35835c6b..90c63f32c13 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -1544,7 +1544,17 @@ where
                 }
             },
             (&Kind::End(a, _), &Kind::Start(b, _)) if a != Bound::Included(b) => (),
-            _ => return Some((a.range(), b.range())),
+            _ => {
+                // skip if the range `a` is completely included into the range `b`
+                if let Ordering::Equal | Ordering::Less = a.cmp(&b) {
+                    let kind_a = Kind::End(a.range().node.1, a.range());
+                    let kind_b = Kind::End(b.range().node.1, b.range());
+                    if let Ordering::Equal | Ordering::Greater = kind_a.cmp(&kind_b) {
+                        return None;
+                    }
+                }
+                return Some((a.range(), b.range()));
+            },
         }
     }
 
diff --git a/tests/ui/match_overlapping_arm.rs b/tests/ui/match_overlapping_arm.rs
index 97789bb766f..3e40f2187bf 100644
--- a/tests/ui/match_overlapping_arm.rs
+++ b/tests/ui/match_overlapping_arm.rs
@@ -57,6 +57,18 @@ fn overlapping() {
         _ => (),
     }
 
+    match 42 {
+        5..7 => println!("5 .. 7"),
+        0..10 => println!("0 .. 10"),
+        _ => (),
+    }
+
+    match 42 {
+        5..10 => println!("5 .. 10"),
+        0..=10 => println!("0 ... 10"),
+        _ => (),
+    }
+
     /*
     // FIXME(JohnTitor): uncomment this once rustfmt knows half-open patterns
     match 42 {
diff --git a/tests/ui/match_overlapping_arm.stderr b/tests/ui/match_overlapping_arm.stderr
index eb20d5405a9..74259cd88c7 100644
--- a/tests/ui/match_overlapping_arm.stderr
+++ b/tests/ui/match_overlapping_arm.stderr
@@ -23,30 +23,6 @@ note: overlaps with this
 LL |         FOO..=11 => println!("0 ... 11"),
    |         ^^^^^^^^
 
-error: some ranges overlap
-  --> $DIR/match_overlapping_arm.rs:26:9
-   |
-LL |         0..=5 => println!("0 ... 5"),
-   |         ^^^^^
-   |
-note: overlaps with this
-  --> $DIR/match_overlapping_arm.rs:25:9
-   |
-LL |         2 => println!("2"),
-   |         ^
-
-error: some ranges overlap
-  --> $DIR/match_overlapping_arm.rs:32:9
-   |
-LL |         0..=2 => println!("0 ... 2"),
-   |         ^^^^^
-   |
-note: overlaps with this
-  --> $DIR/match_overlapping_arm.rs:31:9
-   |
-LL |         2 => println!("2"),
-   |         ^
-
 error: some ranges overlap
   --> $DIR/match_overlapping_arm.rs:55:9
    |
@@ -59,5 +35,5 @@ note: overlaps with this
 LL |         0..=11 => println!("0 ... 11"),
    |         ^^^^^^
 
-error: aborting due to 5 previous errors
+error: aborting due to 3 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From c53192c34762f8104542168dbc7c83cdd280151c Mon Sep 17 00:00:00 2001
From: rail <12975677+rail-rain@users.noreply.github.com>
Date: Tue, 19 Jan 2021 12:46:24 +1300
Subject: Add a note to `as_conversions`
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

… to clalify its purpose.
---
 clippy_lints/src/as_conversions.rs | 8 ++++++++
 1 file changed, 8 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/as_conversions.rs b/clippy_lints/src/as_conversions.rs
index 0c8efd75514..c30d65bbc57 100644
--- a/clippy_lints/src/as_conversions.rs
+++ b/clippy_lints/src/as_conversions.rs
@@ -8,6 +8,14 @@ use crate::utils::span_lint_and_help;
 declare_clippy_lint! {
     /// **What it does:** Checks for usage of `as` conversions.
     ///
+    /// Note that this lint is specialized in linting *every single* use of `as`
+    /// regardless of whether good alternatives exist or not.
+    /// If you want more precise lints for `as`, please consider using these separate lints:
+    /// `unnecessary_cast`, `cast_lossless/possible_truncation/possible_wrap/precision_loss/sign_loss`,
+    /// `fn_to_numeric_cast(_with_truncation)`, `char_lit_as_u8`, `ref_to_mut` and `ptr_as_ptr`.
+    /// There is a good explanation the reason why this lint should work in this way and how it is useful
+    /// [in this issue](https://github.com/rust-lang/rust-clippy/issues/5122).
+    ///
     /// **Why is this bad?** `as` conversions will perform many kinds of
     /// conversions, including silently lossy conversions and dangerous coercions.
     /// There are cases when it makes sense to use `as`, so the lint is
-- 
cgit 1.4.1-3-g733a5


From 3269070261e8324c2b3074cd491ddf2ac6cf19d3 Mon Sep 17 00:00:00 2001
From: nahuakang <kangnahua@gmail.com>
Date: Mon, 11 Jan 2021 23:56:12 +0100
Subject: Create new lint for the usage of inspect for each.

---
 CHANGELOG.md                                 |  1 +
 clippy_lints/src/lib.rs                      |  3 +++
 clippy_lints/src/methods/inspect_for_each.rs | 23 +++++++++++++++++++
 clippy_lints/src/methods/mod.rs              | 33 ++++++++++++++++++++++++++++
 tests/ui/inspect_for_each.rs                 | 22 +++++++++++++++++++
 tests/ui/inspect_for_each.stderr             | 16 ++++++++++++++
 6 files changed, 98 insertions(+)
 create mode 100644 clippy_lints/src/methods/inspect_for_each.rs
 create mode 100644 tests/ui/inspect_for_each.rs
 create mode 100644 tests/ui/inspect_for_each.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 64864c2e278..a91b7c64770 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1996,6 +1996,7 @@ Released 2018-09-13
 [`inline_asm_x86_att_syntax`]: https://rust-lang.github.io/rust-clippy/master/index.html#inline_asm_x86_att_syntax
 [`inline_asm_x86_intel_syntax`]: https://rust-lang.github.io/rust-clippy/master/index.html#inline_asm_x86_intel_syntax
 [`inline_fn_without_body`]: https://rust-lang.github.io/rust-clippy/master/index.html#inline_fn_without_body
+[`inspect_for_each`]: https://rust-lang.github.io/rust-clippy/master/index.html#inspect_for_each
 [`int_plus_one`]: https://rust-lang.github.io/rust-clippy/master/index.html#int_plus_one
 [`integer_arithmetic`]: https://rust-lang.github.io/rust-clippy/master/index.html#integer_arithmetic
 [`integer_division`]: https://rust-lang.github.io/rust-clippy/master/index.html#integer_division
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index f12994c7a60..17662b81205 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -733,6 +733,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &methods::FROM_ITER_INSTEAD_OF_COLLECT,
         &methods::GET_UNWRAP,
         &methods::INEFFICIENT_TO_STRING,
+        &methods::INSPECT_FOR_EACH,
         &methods::INTO_ITER_ON_REF,
         &methods::ITERATOR_STEP_BY_ZERO,
         &methods::ITER_CLONED_COLLECT,
@@ -1507,6 +1508,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&methods::FILTER_NEXT),
         LintId::of(&methods::FLAT_MAP_IDENTITY),
         LintId::of(&methods::FROM_ITER_INSTEAD_OF_COLLECT),
+        LintId::of(&methods::INSPECT_FOR_EACH),
         LintId::of(&methods::INTO_ITER_ON_REF),
         LintId::of(&methods::ITERATOR_STEP_BY_ZERO),
         LintId::of(&methods::ITER_CLONED_COLLECT),
@@ -1807,6 +1809,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&methods::CLONE_ON_COPY),
         LintId::of(&methods::FILTER_NEXT),
         LintId::of(&methods::FLAT_MAP_IDENTITY),
+        LintId::of(&methods::INSPECT_FOR_EACH),
         LintId::of(&methods::OPTION_AS_REF_DEREF),
         LintId::of(&methods::SEARCH_IS_SOME),
         LintId::of(&methods::SKIP_WHILE_NEXT),
diff --git a/clippy_lints/src/methods/inspect_for_each.rs b/clippy_lints/src/methods/inspect_for_each.rs
new file mode 100644
index 00000000000..6d41ee38a27
--- /dev/null
+++ b/clippy_lints/src/methods/inspect_for_each.rs
@@ -0,0 +1,23 @@
+use rustc_hir as hir;
+use rustc_lint::LateContext;
+use rustc_span::source_map::Span;
+
+use crate::utils::{match_trait_method, paths, span_lint_and_help};
+
+use super::INSPECT_FOR_EACH;
+
+/// lint use of `inspect().for_each()` for `Iterators`
+pub(super) fn lint<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, inspect_span: Span) {
+    if match_trait_method(cx, expr, &paths::ITERATOR) {
+        let msg = "called `inspect(..).for_each(..)` on an `Iterator`";
+        let hint = "move the code from `inspect(..)` to `for_each(..)` and remove the `inspect(..)`";
+        span_lint_and_help(
+            cx,
+            INSPECT_FOR_EACH,
+            inspect_span.with_hi(expr.span.hi()),
+            msg,
+            None,
+            hint,
+        );
+    }
+}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index f13f2491d6e..018696ef0cf 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1,5 +1,6 @@
 mod bind_instead_of_map;
 mod inefficient_to_string;
+mod inspect_for_each;
 mod manual_saturating_arithmetic;
 mod option_map_unwrap_or;
 mod unnecessary_filter_map;
@@ -1405,6 +1406,36 @@ declare_clippy_lint! {
     "use `.collect()` instead of `::from_iter()`"
 }
 
+declare_clippy_lint! {
+    /// **What it does:** Checks for usage of `inspect().for_each()`.
+    ///
+    /// **Why is this bad?** It is the same as performing the computation
+    /// inside `inspect` at the beginning of the closure in `for_each`.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// [1,2,3,4,5].iter()
+    /// .inspect(|&x| println!("inspect the number: {}", x))
+    /// .for_each(|&x| {
+    ///     assert!(x >= 0);
+    /// });
+    /// ```
+    /// Can be written as
+    /// ```rust
+    /// [1,2,3,4,5].iter()
+    /// .for_each(|&x| {
+    ///     println!("inspect the number: {}", x);
+    ///     assert!(x >= 0);
+    /// });
+    /// ```
+    pub INSPECT_FOR_EACH,
+    complexity,
+    "using `.inspect().for_each()`, which can be replaced with `.for_each()`"
+}
+
 pub struct Methods {
     msrv: Option<RustcVersion>,
 }
@@ -1467,6 +1498,7 @@ impl_lint_pass!(Methods => [
     UNNECESSARY_LAZY_EVALUATIONS,
     MAP_COLLECT_RESULT_UNIT,
     FROM_ITER_INSTEAD_OF_COLLECT,
+    INSPECT_FOR_EACH,
 ]);
 
 impl<'tcx> LateLintPass<'tcx> for Methods {
@@ -1553,6 +1585,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             ["get_or_insert_with", ..] => unnecessary_lazy_eval::lint(cx, expr, arg_lists[0], "get_or_insert"),
             ["ok_or_else", ..] => unnecessary_lazy_eval::lint(cx, expr, arg_lists[0], "ok_or"),
             ["collect", "map"] => lint_map_collect(cx, expr, arg_lists[1], arg_lists[0]),
+            ["for_each", "inspect"] => inspect_for_each::lint(cx, expr, method_spans[1]),
             _ => {},
         }
 
diff --git a/tests/ui/inspect_for_each.rs b/tests/ui/inspect_for_each.rs
new file mode 100644
index 00000000000..7fe45c83bca
--- /dev/null
+++ b/tests/ui/inspect_for_each.rs
@@ -0,0 +1,22 @@
+#![warn(clippy::inspect_for_each)]
+
+fn main() {
+    let a: Vec<usize> = vec![1, 2, 3, 4, 5];
+
+    let mut b: Vec<usize> = Vec::new();
+    a.into_iter().inspect(|x| assert!(*x > 0)).for_each(|x| {
+        let y = do_some(x);
+        let z = do_more(y);
+        b.push(z);
+    });
+
+    assert_eq!(b, vec![4, 5, 6, 7, 8]);
+}
+
+fn do_some(a: usize) -> usize {
+    a + 1
+}
+
+fn do_more(a: usize) -> usize {
+    a + 2
+}
diff --git a/tests/ui/inspect_for_each.stderr b/tests/ui/inspect_for_each.stderr
new file mode 100644
index 00000000000..9f976bb7458
--- /dev/null
+++ b/tests/ui/inspect_for_each.stderr
@@ -0,0 +1,16 @@
+error: called `inspect(..).for_each(..)` on an `Iterator`
+  --> $DIR/inspect_for_each.rs:7:19
+   |
+LL |       a.into_iter().inspect(|x| assert!(*x > 0)).for_each(|x| {
+   |  ___________________^
+LL | |         let y = do_some(x);
+LL | |         let z = do_more(y);
+LL | |         b.push(z);
+LL | |     });
+   | |______^
+   |
+   = note: `-D clippy::inspect-for-each` implied by `-D warnings`
+   = help: move the code from `inspect(..)` to `for_each(..)` and remove the `inspect(..)`
+
+error: aborting due to previous error
+
-- 
cgit 1.4.1-3-g733a5


From 966320642b157c539901ed0461d6aab6cb34729d Mon Sep 17 00:00:00 2001
From: Takayuki Nakata <f.seasons017@gmail.com>
Date: Tue, 19 Jan 2021 23:51:10 +0900
Subject: Fix a wrong suggestion of `ref_in_deref`

---
 clippy_lints/src/reference.rs   | 10 ++++++++--
 tests/ui/unnecessary_ref.fixed  | 11 ++++++++++-
 tests/ui/unnecessary_ref.rs     | 11 ++++++++++-
 tests/ui/unnecessary_ref.stderr | 10 +++++++++-
 4 files changed, 37 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/reference.rs b/clippy_lints/src/reference.rs
index efe3237990d..2dfb947b5eb 100644
--- a/clippy_lints/src/reference.rs
+++ b/clippy_lints/src/reference.rs
@@ -1,3 +1,4 @@
+use crate::utils::sugg::Sugg;
 use crate::utils::{in_macro, snippet_opt, snippet_with_applicability, span_lint_and_sugg};
 use if_chain::if_chain;
 use rustc_ast::ast::{Expr, ExprKind, Mutability, UnOp};
@@ -124,14 +125,19 @@ impl EarlyLintPass for RefInDeref {
             if let ExprKind::Paren(ref parened) = object.kind;
             if let ExprKind::AddrOf(_, _, ref inner) = parened.kind;
             then {
-                let mut applicability = Applicability::MachineApplicable;
+                let applicability = if inner.span.from_expansion() {
+                    Applicability::MaybeIncorrect
+                } else {
+                    Applicability::MachineApplicable
+                };
+                let sugg = Sugg::ast(cx, inner, "_").maybe_par();
                 span_lint_and_sugg(
                     cx,
                     REF_IN_DEREF,
                     object.span,
                     "creating a reference that is immediately dereferenced",
                     "try this",
-                    snippet_with_applicability(cx, inner.span, "_", &mut applicability).to_string(),
+                    sugg.to_string(),
                     applicability,
                 );
             }
diff --git a/tests/ui/unnecessary_ref.fixed b/tests/ui/unnecessary_ref.fixed
index f7b94118d4e..d927bae976f 100644
--- a/tests/ui/unnecessary_ref.fixed
+++ b/tests/ui/unnecessary_ref.fixed
@@ -1,7 +1,7 @@
 // run-rustfix
 
 #![feature(stmt_expr_attributes)]
-#![allow(unused_variables)]
+#![allow(unused_variables, dead_code)]
 
 struct Outer {
     inner: u32,
@@ -12,3 +12,12 @@ fn main() {
     let outer = Outer { inner: 0 };
     let inner = outer.inner;
 }
+
+struct Apple;
+impl Apple {
+    fn hello(&self) {}
+}
+struct Package(pub *const Apple);
+fn foobar(package: *const Package) {
+    unsafe { &*(*package).0 }.hello();
+}
diff --git a/tests/ui/unnecessary_ref.rs b/tests/ui/unnecessary_ref.rs
index 4e585b9b96b..86bfb76ec26 100644
--- a/tests/ui/unnecessary_ref.rs
+++ b/tests/ui/unnecessary_ref.rs
@@ -1,7 +1,7 @@
 // run-rustfix
 
 #![feature(stmt_expr_attributes)]
-#![allow(unused_variables)]
+#![allow(unused_variables, dead_code)]
 
 struct Outer {
     inner: u32,
@@ -12,3 +12,12 @@ fn main() {
     let outer = Outer { inner: 0 };
     let inner = (&outer).inner;
 }
+
+struct Apple;
+impl Apple {
+    fn hello(&self) {}
+}
+struct Package(pub *const Apple);
+fn foobar(package: *const Package) {
+    unsafe { &*(&*package).0 }.hello();
+}
diff --git a/tests/ui/unnecessary_ref.stderr b/tests/ui/unnecessary_ref.stderr
index d0a0f219097..436f4bcf738 100644
--- a/tests/ui/unnecessary_ref.stderr
+++ b/tests/ui/unnecessary_ref.stderr
@@ -10,5 +10,13 @@ note: the lint level is defined here
 LL | #[deny(clippy::ref_in_deref)]
    |        ^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: creating a reference that is immediately dereferenced
+  --> $DIR/unnecessary_ref.rs:22:16
+   |
+LL |     unsafe { &*(&*package).0 }.hello();
+   |                ^^^^^^^^^^^ help: try this: `(*package)`
+   |
+   = note: `-D clippy::ref-in-deref` implied by `-D warnings`
+
+error: aborting due to 2 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From d4bf59b6ef24042653951b69105a3a68542f3bbd Mon Sep 17 00:00:00 2001
From: Marijn Suijten <marijn@traverseresearch.nl>
Date: Tue, 12 Jan 2021 11:35:44 +0100
Subject: size_of_in_element_count: Disable lint on division by byte-size

It is fairly common to divide some length in bytes by the byte-size of a
single element before creating a `from_raw_parts` slice or similar
operation. This lint would erroneously disallow such expressions.

Just in case, instead of simply disabling this lint in the RHS of a
division, keep track of the inversion and enable it again on recursive
division.
---
 clippy_lints/src/size_of_in_element_count.rs         | 14 +++++++++-----
 tests/ui/size_of_in_element_count/expressions.rs     |  9 +++++++++
 tests/ui/size_of_in_element_count/expressions.stderr | 10 +++++++++-
 3 files changed, 27 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/size_of_in_element_count.rs b/clippy_lints/src/size_of_in_element_count.rs
index ea7a76146f5..87e386baadc 100644
--- a/clippy_lints/src/size_of_in_element_count.rs
+++ b/clippy_lints/src/size_of_in_element_count.rs
@@ -35,10 +35,11 @@ declare_clippy_lint! {
 
 declare_lint_pass!(SizeOfInElementCount => [SIZE_OF_IN_ELEMENT_COUNT]);
 
-fn get_size_of_ty(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<Ty<'tcx>> {
+fn get_size_of_ty(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, inverted: bool) -> Option<Ty<'tcx>> {
     match expr.kind {
         ExprKind::Call(count_func, _func_args) => {
             if_chain! {
+                if !inverted;
                 if let ExprKind::Path(ref count_func_qpath) = count_func.kind;
                 if let Some(def_id) = cx.qpath_res(count_func_qpath, count_func.hir_id).opt_def_id();
                 if match_def_path(cx, def_id, &paths::MEM_SIZE_OF)
@@ -50,10 +51,13 @@ fn get_size_of_ty(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<Ty<'tc
                 }
             }
         },
-        ExprKind::Binary(op, left, right) if BinOpKind::Mul == op.node || BinOpKind::Div == op.node => {
-            get_size_of_ty(cx, left).or_else(|| get_size_of_ty(cx, right))
+        ExprKind::Binary(op, left, right) if BinOpKind::Mul == op.node => {
+            get_size_of_ty(cx, left, inverted).or_else(|| get_size_of_ty(cx, right, inverted))
         },
-        ExprKind::Cast(expr, _) => get_size_of_ty(cx, expr),
+        ExprKind::Binary(op, left, right) if BinOpKind::Div == op.node => {
+            get_size_of_ty(cx, left, inverted).or_else(|| get_size_of_ty(cx, right, !inverted))
+        },
+        ExprKind::Cast(expr, _) => get_size_of_ty(cx, expr, inverted),
         _ => None,
     }
 }
@@ -128,7 +132,7 @@ impl<'tcx> LateLintPass<'tcx> for SizeOfInElementCount {
 
             // Find a size_of call in the count parameter expression and
             // check that it's the same type
-            if let Some(ty_used_for_size_of) = get_size_of_ty(cx, count_expr);
+            if let Some(ty_used_for_size_of) = get_size_of_ty(cx, count_expr, false);
             if TyS::same_type(pointee_ty, ty_used_for_size_of);
             then {
                 span_lint_and_help(
diff --git a/tests/ui/size_of_in_element_count/expressions.rs b/tests/ui/size_of_in_element_count/expressions.rs
index b56910917ba..2594e8fa6ad 100644
--- a/tests/ui/size_of_in_element_count/expressions.rs
+++ b/tests/ui/size_of_in_element_count/expressions.rs
@@ -20,6 +20,15 @@ fn main() {
     // Count expression involving divisions of size_of (Should trigger the lint)
     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), DOUBLE_SIZE * size_of::<u8>() / 2) };
 
+    // Count expression involving divisions by size_of (Should not trigger the lint)
+    unsafe { copy(x.as_ptr(), y.as_mut_ptr(), DOUBLE_SIZE / size_of::<u8>()) };
+
+    // Count expression involving divisions by multiple size_of (Should not trigger the lint)
+    unsafe { copy(x.as_ptr(), y.as_mut_ptr(), DOUBLE_SIZE / (2 * size_of::<u8>())) };
+
+    // Count expression involving recursive divisions by size_of (Should trigger the lint)
+    unsafe { copy(x.as_ptr(), y.as_mut_ptr(), DOUBLE_SIZE / (2 / size_of::<u8>())) };
+
     // No size_of calls (Should not trigger the lint)
     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), SIZE) };
 
diff --git a/tests/ui/size_of_in_element_count/expressions.stderr b/tests/ui/size_of_in_element_count/expressions.stderr
index 47b98e9d947..0f0dff57f51 100644
--- a/tests/ui/size_of_in_element_count/expressions.stderr
+++ b/tests/ui/size_of_in_element_count/expressions.stderr
@@ -23,5 +23,13 @@ LL |     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), DOUBLE_SIZE * size_of::<u8>()
    |
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
-error: aborting due to 3 previous errors
+error: found a count of bytes instead of a count of elements of `T`
+  --> $DIR/expressions.rs:30:47
+   |
+LL |     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), DOUBLE_SIZE / (2 / size_of::<u8>())) };
+   |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
+
+error: aborting due to 4 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 6c830ff9e4621c6e159ce8edb33fb225352e7b69 Mon Sep 17 00:00:00 2001
From: Hirochika Matsumoto <matsujika@gmail.com>
Date: Sat, 19 Dec 2020 18:57:11 +0900
Subject: Run `cargo dev new_lint`

---
 CHANGELOG.md                             |  1 +
 clippy_lints/src/capitalized_acronyms.rs | 28 ++++++++++++++++++++++++++++
 clippy_lints/src/lib.rs                  |  2 ++
 tests/ui/capitalized_acronyms.rs         |  5 +++++
 4 files changed, 36 insertions(+)
 create mode 100644 clippy_lints/src/capitalized_acronyms.rs
 create mode 100644 tests/ui/capitalized_acronyms.rs

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index b3adeed7720..963c9e77a18 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1877,6 +1877,7 @@ Released 2018-09-13
 [`box_vec`]: https://rust-lang.github.io/rust-clippy/master/index.html#box_vec
 [`boxed_local`]: https://rust-lang.github.io/rust-clippy/master/index.html#boxed_local
 [`builtin_type_shadow`]: https://rust-lang.github.io/rust-clippy/master/index.html#builtin_type_shadow
+[`capitalized_acronyms`]: https://rust-lang.github.io/rust-clippy/master/index.html#capitalized_acronyms
 [`cargo_common_metadata`]: https://rust-lang.github.io/rust-clippy/master/index.html#cargo_common_metadata
 [`case_sensitive_file_extension_comparisons`]: https://rust-lang.github.io/rust-clippy/master/index.html#case_sensitive_file_extension_comparisons
 [`cast_lossless`]: https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
diff --git a/clippy_lints/src/capitalized_acronyms.rs b/clippy_lints/src/capitalized_acronyms.rs
new file mode 100644
index 00000000000..835e92dc04b
--- /dev/null
+++ b/clippy_lints/src/capitalized_acronyms.rs
@@ -0,0 +1,28 @@
+use rustc_lint::{EarlyLintPass, EarlyContext};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_ast::ast::*;
+
+declare_clippy_lint! {
+    /// **What it does:**
+    ///
+    /// **Why is this bad?**
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// // example code where clippy issues a warning
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// // example code which does not raise clippy warning
+    /// ```
+    pub CAPITALIZED_ACRONYMS,
+    style,
+    "default lint description"
+}
+
+declare_lint_pass!(CapitalizedAcronyms => [CAPITALIZED_ACRONYMS]);
+
+impl EarlyLintPass for CapitalizedAcronyms {}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 0b1b347ce42..a236e1b54bb 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -169,6 +169,7 @@ mod blacklisted_name;
 mod blocks_in_if_conditions;
 mod booleans;
 mod bytecount;
+mod capitalized_acronyms;
 mod cargo_common_metadata;
 mod case_sensitive_file_extension_comparisons;
 mod checked_conversions;
@@ -559,6 +560,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &booleans::LOGIC_BUG,
         &booleans::NONMINIMAL_BOOL,
         &bytecount::NAIVE_BYTECOUNT,
+        &capitalized_acronyms::CAPITALIZED_ACRONYMS,
         &cargo_common_metadata::CARGO_COMMON_METADATA,
         &case_sensitive_file_extension_comparisons::CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS,
         &checked_conversions::CHECKED_CONVERSIONS,
diff --git a/tests/ui/capitalized_acronyms.rs b/tests/ui/capitalized_acronyms.rs
new file mode 100644
index 00000000000..bf5ab9f8bb7
--- /dev/null
+++ b/tests/ui/capitalized_acronyms.rs
@@ -0,0 +1,5 @@
+#![warn(clippy::capitalized_acronyms)]
+
+fn main() {
+    // test code goes here
+}
-- 
cgit 1.4.1-3-g733a5


From ab1da8f86569e55d4b33702c6a062551f8abdd6e Mon Sep 17 00:00:00 2001
From: Hirochika Matsumoto <matsujika@gmail.com>
Date: Sat, 19 Dec 2020 22:50:45 +0900
Subject: Add new lint `upper_case_acronyms`

---
 CHANGELOG.md                               |  2 +-
 clippy_lints/src/capitalized_acronyms.rs   | 28 ---------
 clippy_lints/src/cognitive_complexity.rs   |  8 +--
 clippy_lints/src/int_plus_one.rs           | 24 ++++----
 clippy_lints/src/lib.rs                    | 10 +++-
 clippy_lints/src/serde_api.rs              |  4 +-
 clippy_lints/src/upper_case_acronyms.rs    | 93 ++++++++++++++++++++++++++++++
 tests/ui/capitalized_acronyms.rs           |  5 --
 tests/ui/complex_types.rs                  |  2 +-
 tests/ui/complex_types.stderr              |  2 +-
 tests/ui/crashes/ice-6256.rs               |  1 +
 tests/ui/crashes/ice-6256.stderr           |  6 +-
 tests/ui/enum_variants.rs                  |  2 +-
 tests/ui/needless_question_mark.fixed      |  8 ++-
 tests/ui/needless_question_mark.rs         |  8 ++-
 tests/ui/needless_question_mark.stderr     | 28 ++++-----
 tests/ui/suspicious_operation_groupings.rs |  8 +--
 tests/ui/transmute_ptr_to_ptr.rs           |  6 +-
 tests/ui/unnested_or_patterns.fixed        |  2 +-
 tests/ui/unnested_or_patterns.rs           |  2 +-
 tests/ui/upper_case_acronyms.rs            | 21 +++++++
 tests/ui/upper_case_acronyms.stderr        | 70 ++++++++++++++++++++++
 tests/ui/use_self.fixed                    |  2 +-
 tests/ui/use_self.rs                       |  2 +-
 24 files changed, 256 insertions(+), 88 deletions(-)
 delete mode 100644 clippy_lints/src/capitalized_acronyms.rs
 create mode 100644 clippy_lints/src/upper_case_acronyms.rs
 delete mode 100644 tests/ui/capitalized_acronyms.rs
 create mode 100644 tests/ui/upper_case_acronyms.rs
 create mode 100644 tests/ui/upper_case_acronyms.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 963c9e77a18..04f042b2deb 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1877,7 +1877,6 @@ Released 2018-09-13
 [`box_vec`]: https://rust-lang.github.io/rust-clippy/master/index.html#box_vec
 [`boxed_local`]: https://rust-lang.github.io/rust-clippy/master/index.html#boxed_local
 [`builtin_type_shadow`]: https://rust-lang.github.io/rust-clippy/master/index.html#builtin_type_shadow
-[`capitalized_acronyms`]: https://rust-lang.github.io/rust-clippy/master/index.html#capitalized_acronyms
 [`cargo_common_metadata`]: https://rust-lang.github.io/rust-clippy/master/index.html#cargo_common_metadata
 [`case_sensitive_file_extension_comparisons`]: https://rust-lang.github.io/rust-clippy/master/index.html#case_sensitive_file_extension_comparisons
 [`cast_lossless`]: https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
@@ -2275,6 +2274,7 @@ Released 2018-09-13
 [`unusual_byte_groupings`]: https://rust-lang.github.io/rust-clippy/master/index.html#unusual_byte_groupings
 [`unwrap_in_result`]: https://rust-lang.github.io/rust-clippy/master/index.html#unwrap_in_result
 [`unwrap_used`]: https://rust-lang.github.io/rust-clippy/master/index.html#unwrap_used
+[`upper_case_acronyms`]: https://rust-lang.github.io/rust-clippy/master/index.html#upper_case_acronyms
 [`use_debug`]: https://rust-lang.github.io/rust-clippy/master/index.html#use_debug
 [`use_self`]: https://rust-lang.github.io/rust-clippy/master/index.html#use_self
 [`used_underscore_binding`]: https://rust-lang.github.io/rust-clippy/master/index.html#used_underscore_binding
diff --git a/clippy_lints/src/capitalized_acronyms.rs b/clippy_lints/src/capitalized_acronyms.rs
deleted file mode 100644
index 835e92dc04b..00000000000
--- a/clippy_lints/src/capitalized_acronyms.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-use rustc_lint::{EarlyLintPass, EarlyContext};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_ast::ast::*;
-
-declare_clippy_lint! {
-    /// **What it does:**
-    ///
-    /// **Why is this bad?**
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
-    /// ```rust
-    /// // example code where clippy issues a warning
-    /// ```
-    /// Use instead:
-    /// ```rust
-    /// // example code which does not raise clippy warning
-    /// ```
-    pub CAPITALIZED_ACRONYMS,
-    style,
-    "default lint description"
-}
-
-declare_lint_pass!(CapitalizedAcronyms => [CAPITALIZED_ACRONYMS]);
-
-impl EarlyLintPass for CapitalizedAcronyms {}
diff --git a/clippy_lints/src/cognitive_complexity.rs b/clippy_lints/src/cognitive_complexity.rs
index b3ebdf4ca30..f21a734bb43 100644
--- a/clippy_lints/src/cognitive_complexity.rs
+++ b/clippy_lints/src/cognitive_complexity.rs
@@ -57,9 +57,9 @@ impl CognitiveComplexity {
 
         let expr = &body.value;
 
-        let mut helper = CCHelper { cc: 1, returns: 0 };
+        let mut helper = CcHelper { cc: 1, returns: 0 };
         helper.visit_expr(expr);
-        let CCHelper { cc, returns } = helper;
+        let CcHelper { cc, returns } = helper;
         let ret_ty = cx.typeck_results().node_type(expr.hir_id);
         let ret_adjust = if is_type_diagnostic_item(cx, ret_ty, sym::result_type) {
             returns
@@ -136,12 +136,12 @@ impl<'tcx> LateLintPass<'tcx> for CognitiveComplexity {
     }
 }
 
-struct CCHelper {
+struct CcHelper {
     cc: u64,
     returns: u64,
 }
 
-impl<'tcx> Visitor<'tcx> for CCHelper {
+impl<'tcx> Visitor<'tcx> for CcHelper {
     type Map = Map<'tcx>;
 
     fn visit_expr(&mut self, e: &'tcx Expr<'_>) {
diff --git a/clippy_lints/src/int_plus_one.rs b/clippy_lints/src/int_plus_one.rs
index c629ee05ab9..260b8988d37 100644
--- a/clippy_lints/src/int_plus_one.rs
+++ b/clippy_lints/src/int_plus_one.rs
@@ -46,8 +46,8 @@ declare_lint_pass!(IntPlusOne => [INT_PLUS_ONE]);
 
 #[derive(Copy, Clone)]
 enum Side {
-    LHS,
-    RHS,
+    Lhs,
+    Rhs,
 }
 
 impl IntPlusOne {
@@ -66,11 +66,11 @@ impl IntPlusOne {
                 match (lhskind.node, &lhslhs.kind, &lhsrhs.kind) {
                     // `-1 + x`
                     (BinOpKind::Add, &ExprKind::Lit(ref lit), _) if Self::check_lit(lit, -1) => {
-                        Self::generate_recommendation(cx, binop, lhsrhs, rhs, Side::LHS)
+                        Self::generate_recommendation(cx, binop, lhsrhs, rhs, Side::Lhs)
                     },
                     // `x - 1`
                     (BinOpKind::Sub, _, &ExprKind::Lit(ref lit)) if Self::check_lit(lit, 1) => {
-                        Self::generate_recommendation(cx, binop, lhslhs, rhs, Side::LHS)
+                        Self::generate_recommendation(cx, binop, lhslhs, rhs, Side::Lhs)
                     },
                     _ => None,
                 }
@@ -82,10 +82,10 @@ impl IntPlusOne {
                 match (&rhslhs.kind, &rhsrhs.kind) {
                     // `y + 1` and `1 + y`
                     (&ExprKind::Lit(ref lit), _) if Self::check_lit(lit, 1) => {
-                        Self::generate_recommendation(cx, binop, rhsrhs, lhs, Side::RHS)
+                        Self::generate_recommendation(cx, binop, rhsrhs, lhs, Side::Rhs)
                     },
                     (_, &ExprKind::Lit(ref lit)) if Self::check_lit(lit, 1) => {
-                        Self::generate_recommendation(cx, binop, rhslhs, lhs, Side::RHS)
+                        Self::generate_recommendation(cx, binop, rhslhs, lhs, Side::Rhs)
                     },
                     _ => None,
                 }
@@ -97,10 +97,10 @@ impl IntPlusOne {
                 match (&lhslhs.kind, &lhsrhs.kind) {
                     // `1 + x` and `x + 1`
                     (&ExprKind::Lit(ref lit), _) if Self::check_lit(lit, 1) => {
-                        Self::generate_recommendation(cx, binop, lhsrhs, rhs, Side::LHS)
+                        Self::generate_recommendation(cx, binop, lhsrhs, rhs, Side::Lhs)
                     },
                     (_, &ExprKind::Lit(ref lit)) if Self::check_lit(lit, 1) => {
-                        Self::generate_recommendation(cx, binop, lhslhs, rhs, Side::LHS)
+                        Self::generate_recommendation(cx, binop, lhslhs, rhs, Side::Lhs)
                     },
                     _ => None,
                 }
@@ -110,11 +110,11 @@ impl IntPlusOne {
                 match (rhskind.node, &rhslhs.kind, &rhsrhs.kind) {
                     // `-1 + y`
                     (BinOpKind::Add, &ExprKind::Lit(ref lit), _) if Self::check_lit(lit, -1) => {
-                        Self::generate_recommendation(cx, binop, rhsrhs, lhs, Side::RHS)
+                        Self::generate_recommendation(cx, binop, rhsrhs, lhs, Side::Rhs)
                     },
                     // `y - 1`
                     (BinOpKind::Sub, _, &ExprKind::Lit(ref lit)) if Self::check_lit(lit, 1) => {
-                        Self::generate_recommendation(cx, binop, rhslhs, lhs, Side::RHS)
+                        Self::generate_recommendation(cx, binop, rhslhs, lhs, Side::Rhs)
                     },
                     _ => None,
                 }
@@ -138,8 +138,8 @@ impl IntPlusOne {
         if let Some(snippet) = snippet_opt(cx, node.span) {
             if let Some(other_side_snippet) = snippet_opt(cx, other_side.span) {
                 let rec = match side {
-                    Side::LHS => Some(format!("{} {} {}", snippet, binop_string, other_side_snippet)),
-                    Side::RHS => Some(format!("{} {} {}", other_side_snippet, binop_string, snippet)),
+                    Side::Lhs => Some(format!("{} {} {}", snippet, binop_string, other_side_snippet)),
+                    Side::Rhs => Some(format!("{} {} {}", other_side_snippet, binop_string, snippet)),
                 };
                 return rec;
             }
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index a236e1b54bb..9b73c249643 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -6,6 +6,7 @@
 #![feature(concat_idents)]
 #![feature(crate_visibility_modifier)]
 #![feature(drain_filter)]
+#![feature(split_inclusive)]
 #![feature(in_band_lifetimes)]
 #![feature(once_cell)]
 #![feature(or_patterns)]
@@ -169,7 +170,6 @@ mod blacklisted_name;
 mod blocks_in_if_conditions;
 mod booleans;
 mod bytecount;
-mod capitalized_acronyms;
 mod cargo_common_metadata;
 mod case_sensitive_file_extension_comparisons;
 mod checked_conversions;
@@ -342,6 +342,7 @@ mod unused_self;
 mod unused_unit;
 mod unwrap;
 mod unwrap_in_result;
+mod upper_case_acronyms;
 mod use_self;
 mod useless_conversion;
 mod vec;
@@ -560,7 +561,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &booleans::LOGIC_BUG,
         &booleans::NONMINIMAL_BOOL,
         &bytecount::NAIVE_BYTECOUNT,
-        &capitalized_acronyms::CAPITALIZED_ACRONYMS,
         &cargo_common_metadata::CARGO_COMMON_METADATA,
         &case_sensitive_file_extension_comparisons::CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS,
         &checked_conversions::CHECKED_CONVERSIONS,
@@ -946,6 +946,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &unwrap::PANICKING_UNWRAP,
         &unwrap::UNNECESSARY_UNWRAP,
         &unwrap_in_result::UNWRAP_IN_RESULT,
+        &upper_case_acronyms::UPPER_CASE_ACRONYMS,
         &use_self::USE_SELF,
         &useless_conversion::USELESS_CONVERSION,
         &vec::USELESS_VEC,
@@ -985,7 +986,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     }
     store.register_late_pass(|| box utils::author::Author);
     store.register_late_pass(|| box await_holding_invalid::AwaitHolding);
-    store.register_late_pass(|| box serde_api::SerdeAPI);
+    store.register_late_pass(|| box serde_api::SerdeApi);
     let vec_box_size_threshold = conf.vec_box_size_threshold;
     store.register_late_pass(move || box types::Types::new(vec_box_size_threshold));
     store.register_late_pass(|| box booleans::NonminimalBool);
@@ -1176,6 +1177,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     let enum_variant_name_threshold = conf.enum_variant_name_threshold;
     store.register_early_pass(move || box enum_variants::EnumVariantNames::new(enum_variant_name_threshold));
     store.register_early_pass(|| box tabs_in_doc_comments::TabsInDocComments);
+    store.register_early_pass(|| box upper_case_acronyms::UpperCaseAcronyms);
     store.register_late_pass(|| box default::Default::default());
     store.register_late_pass(|| box unused_self::UnusedSelf);
     store.register_late_pass(|| box mutable_debug_assertion::DebugAssertWithMutCall);
@@ -1661,6 +1663,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&unused_unit::UNUSED_UNIT),
         LintId::of(&unwrap::PANICKING_UNWRAP),
         LintId::of(&unwrap::UNNECESSARY_UNWRAP),
+        LintId::of(&upper_case_acronyms::UPPER_CASE_ACRONYMS),
         LintId::of(&useless_conversion::USELESS_CONVERSION),
         LintId::of(&vec::USELESS_VEC),
         LintId::of(&vec_init_then_push::VEC_INIT_THEN_PUSH),
@@ -1778,6 +1781,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&types::FN_TO_NUMERIC_CAST_WITH_TRUNCATION),
         LintId::of(&unsafe_removed_from_name::UNSAFE_REMOVED_FROM_NAME),
         LintId::of(&unused_unit::UNUSED_UNIT),
+        LintId::of(&upper_case_acronyms::UPPER_CASE_ACRONYMS),
         LintId::of(&write::PRINTLN_EMPTY_STRING),
         LintId::of(&write::PRINT_LITERAL),
         LintId::of(&write::PRINT_WITH_NEWLINE),
diff --git a/clippy_lints/src/serde_api.rs b/clippy_lints/src/serde_api.rs
index 44e739725c8..90cf1b6c861 100644
--- a/clippy_lints/src/serde_api.rs
+++ b/clippy_lints/src/serde_api.rs
@@ -18,9 +18,9 @@ declare_clippy_lint! {
     "various things that will negatively affect your serde experience"
 }
 
-declare_lint_pass!(SerdeAPI => [SERDE_API_MISUSE]);
+declare_lint_pass!(SerdeApi => [SERDE_API_MISUSE]);
 
-impl<'tcx> LateLintPass<'tcx> for SerdeAPI {
+impl<'tcx> LateLintPass<'tcx> for SerdeApi {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
         if let ItemKind::Impl(Impl {
             of_trait: Some(ref trait_ref),
diff --git a/clippy_lints/src/upper_case_acronyms.rs b/clippy_lints/src/upper_case_acronyms.rs
new file mode 100644
index 00000000000..61e7031716a
--- /dev/null
+++ b/clippy_lints/src/upper_case_acronyms.rs
@@ -0,0 +1,93 @@
+use crate::utils::span_lint_and_sugg;
+use if_chain::if_chain;
+use itertools::Itertools;
+use rustc_ast::ast::{Item, ItemKind, Variant};
+use rustc_errors::Applicability;
+use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
+use rustc_middle::lint::in_external_macro;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::symbol::Ident;
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for camel case name containing a capitalized acronym.
+    ///
+    /// **Why is this bad?** In CamelCase, acronyms count as one word.
+    /// See [naming conventions](https://rust-lang.github.io/api-guidelines/naming.html#casing-conforms-to-rfc-430-c-case)
+    /// for more.
+    ///
+    /// **Known problems:** When two acronyms are contiguous, the lint can't tell where
+    /// the first acronym ends and the second starts, so it suggests to lowercase all of
+    /// the letters in the second acronym.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// struct HTTPResponse;
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// struct HttpResponse;
+    /// ```
+    pub UPPER_CASE_ACRONYMS,
+    style,
+    "capitalized acronyms are against the naming convention"
+}
+
+declare_lint_pass!(UpperCaseAcronyms => [UPPER_CASE_ACRONYMS]);
+
+fn correct_ident(ident: &str) -> String {
+    let ident = ident.chars().rev().collect::<String>();
+    let fragments = ident
+        .split_inclusive(|x: char| !x.is_ascii_lowercase())
+        .rev()
+        .map(|x| x.chars().rev().collect::<String>());
+
+    let mut ident = fragments.clone().next().unwrap();
+    for (ref prev, ref curr) in fragments.tuple_windows() {
+        if [prev, curr]
+            .iter()
+            .all(|s| s.len() == 1 && s.chars().next().unwrap().is_ascii_uppercase())
+        {
+            ident.push_str(&curr.to_ascii_lowercase());
+        } else {
+            ident.push_str(curr);
+        }
+    }
+    ident
+}
+
+fn check_ident(cx: &EarlyContext<'_>, ident: &Ident) {
+    let span = ident.span;
+    let ident = &ident.as_str();
+    let corrected = correct_ident(ident);
+    if ident != &corrected {
+        span_lint_and_sugg(
+            cx,
+            UPPER_CASE_ACRONYMS,
+            span,
+            &format!("name `{}` contains a capitalized acronym", ident),
+            "consider making the acronym lowercase, except the initial letter",
+            corrected,
+            Applicability::MaybeIncorrect,
+        )
+    }
+}
+
+impl EarlyLintPass for UpperCaseAcronyms {
+    fn check_item(&mut self, cx: &EarlyContext<'_>, it: &Item) {
+        if_chain! {
+            if !in_external_macro(cx.sess(), it.span);
+            if matches!(
+                it.kind,
+                ItemKind::TyAlias(..) | ItemKind::Enum(..) | ItemKind::Struct(..) | ItemKind::Trait(..)
+            );
+            then {
+                check_ident(cx, &it.ident);
+            }
+        }
+    }
+
+    fn check_variant(&mut self, cx: &EarlyContext<'_>, v: &Variant) {
+        check_ident(cx, &v.ident);
+    }
+}
diff --git a/tests/ui/capitalized_acronyms.rs b/tests/ui/capitalized_acronyms.rs
deleted file mode 100644
index bf5ab9f8bb7..00000000000
--- a/tests/ui/capitalized_acronyms.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-#![warn(clippy::capitalized_acronyms)]
-
-fn main() {
-    // test code goes here
-}
diff --git a/tests/ui/complex_types.rs b/tests/ui/complex_types.rs
index be61fb6b9be..383bbb49dbe 100644
--- a/tests/ui/complex_types.rs
+++ b/tests/ui/complex_types.rs
@@ -11,7 +11,7 @@ struct S {
     f: Vec<Vec<Box<(u32, u32, u32, u32)>>>,
 }
 
-struct TS(Vec<Vec<Box<(u32, u32, u32, u32)>>>);
+struct Ts(Vec<Vec<Box<(u32, u32, u32, u32)>>>);
 
 enum E {
     Tuple(Vec<Vec<Box<(u32, u32, u32, u32)>>>),
diff --git a/tests/ui/complex_types.stderr b/tests/ui/complex_types.stderr
index 8f5dbd27956..7fcbb4bce88 100644
--- a/tests/ui/complex_types.stderr
+++ b/tests/ui/complex_types.stderr
@@ -21,7 +21,7 @@ LL |     f: Vec<Vec<Box<(u32, u32, u32, u32)>>>,
 error: very complex type used. Consider factoring parts into `type` definitions
   --> $DIR/complex_types.rs:14:11
    |
-LL | struct TS(Vec<Vec<Box<(u32, u32, u32, u32)>>>);
+LL | struct Ts(Vec<Vec<Box<(u32, u32, u32, u32)>>>);
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: very complex type used. Consider factoring parts into `type` definitions
diff --git a/tests/ui/crashes/ice-6256.rs b/tests/ui/crashes/ice-6256.rs
index 6f60d45d68a..5409f36b3f1 100644
--- a/tests/ui/crashes/ice-6256.rs
+++ b/tests/ui/crashes/ice-6256.rs
@@ -1,5 +1,6 @@
 // originally from rustc ./src/test/ui/regions/issue-78262.rs
 // ICE: to get the signature of a closure, use substs.as_closure().sig() not fn_sig()
+#![allow(clippy::upper_case_acronyms)]
 
 trait TT {}
 
diff --git a/tests/ui/crashes/ice-6256.stderr b/tests/ui/crashes/ice-6256.stderr
index 0e8353a418a..d1a8bdc3c8d 100644
--- a/tests/ui/crashes/ice-6256.stderr
+++ b/tests/ui/crashes/ice-6256.stderr
@@ -1,13 +1,13 @@
 error[E0308]: mismatched types
-  --> $DIR/ice-6256.rs:11:28
+  --> $DIR/ice-6256.rs:12:28
    |
 LL |     let f = |x: &dyn TT| x.func(); //[default]~ ERROR: mismatched types
    |                            ^^^^ lifetime mismatch
    |
    = note: expected reference `&(dyn TT + 'static)`
               found reference `&dyn TT`
-note: the anonymous lifetime #1 defined on the body at 11:13...
-  --> $DIR/ice-6256.rs:11:13
+note: the anonymous lifetime #1 defined on the body at 12:13...
+  --> $DIR/ice-6256.rs:12:13
    |
 LL |     let f = |x: &dyn TT| x.func(); //[default]~ ERROR: mismatched types
    |             ^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/enum_variants.rs b/tests/ui/enum_variants.rs
index 01774a2a984..89d99dcf0c8 100644
--- a/tests/ui/enum_variants.rs
+++ b/tests/ui/enum_variants.rs
@@ -1,6 +1,6 @@
 #![feature(non_ascii_idents)]
 #![warn(clippy::enum_variant_names, clippy::pub_enum_variant_names)]
-#![allow(non_camel_case_types)]
+#![allow(non_camel_case_types, clippy::upper_case_acronyms)]
 
 enum FakeCallType {
     CALL,
diff --git a/tests/ui/needless_question_mark.fixed b/tests/ui/needless_question_mark.fixed
index 70218f3f041..71fb3565224 100644
--- a/tests/ui/needless_question_mark.fixed
+++ b/tests/ui/needless_question_mark.fixed
@@ -1,7 +1,13 @@
 // run-rustfix
 
 #![warn(clippy::needless_question_mark)]
-#![allow(clippy::needless_return, clippy::unnecessary_unwrap, dead_code, unused_must_use)]
+#![allow(
+    clippy::needless_return,
+    clippy::unnecessary_unwrap,
+    clippy::upper_case_acronyms,
+    dead_code,
+    unused_must_use
+)]
 #![feature(custom_inner_attributes)]
 
 struct TO {
diff --git a/tests/ui/needless_question_mark.rs b/tests/ui/needless_question_mark.rs
index 60ac2c8d72e..e31f6f48fa7 100644
--- a/tests/ui/needless_question_mark.rs
+++ b/tests/ui/needless_question_mark.rs
@@ -1,7 +1,13 @@
 // run-rustfix
 
 #![warn(clippy::needless_question_mark)]
-#![allow(clippy::needless_return, clippy::unnecessary_unwrap, dead_code, unused_must_use)]
+#![allow(
+    clippy::needless_return,
+    clippy::unnecessary_unwrap,
+    clippy::upper_case_acronyms,
+    dead_code,
+    unused_must_use
+)]
 #![feature(custom_inner_attributes)]
 
 struct TO {
diff --git a/tests/ui/needless_question_mark.stderr b/tests/ui/needless_question_mark.stderr
index b4eb21882ec..567bc518a3f 100644
--- a/tests/ui/needless_question_mark.stderr
+++ b/tests/ui/needless_question_mark.stderr
@@ -1,5 +1,5 @@
 error: Question mark operator is useless here
-  --> $DIR/needless_question_mark.rs:17:12
+  --> $DIR/needless_question_mark.rs:23:12
    |
 LL |     return Some(to.magic?);
    |            ^^^^^^^^^^^^^^^ help: try: `to.magic`
@@ -7,79 +7,79 @@ LL |     return Some(to.magic?);
    = note: `-D clippy::needless-question-mark` implied by `-D warnings`
 
 error: Question mark operator is useless here
-  --> $DIR/needless_question_mark.rs:25:12
+  --> $DIR/needless_question_mark.rs:31:12
    |
 LL |     return Some(to.magic?)
    |            ^^^^^^^^^^^^^^^ help: try: `to.magic`
 
 error: Question mark operator is useless here
-  --> $DIR/needless_question_mark.rs:30:5
+  --> $DIR/needless_question_mark.rs:36:5
    |
 LL |     Some(to.magic?)
    |     ^^^^^^^^^^^^^^^ help: try: `to.magic`
 
 error: Question mark operator is useless here
-  --> $DIR/needless_question_mark.rs:35:21
+  --> $DIR/needless_question_mark.rs:41:21
    |
 LL |     to.and_then(|t| Some(t.magic?))
    |                     ^^^^^^^^^^^^^^ help: try: `t.magic`
 
 error: Question mark operator is useless here
-  --> $DIR/needless_question_mark.rs:44:9
+  --> $DIR/needless_question_mark.rs:50:9
    |
 LL |         Some(t.magic?)
    |         ^^^^^^^^^^^^^^ help: try: `t.magic`
 
 error: Question mark operator is useless here
-  --> $DIR/needless_question_mark.rs:49:12
+  --> $DIR/needless_question_mark.rs:55:12
    |
 LL |     return Ok(tr.magic?);
    |            ^^^^^^^^^^^^^ help: try: `tr.magic`
 
 error: Question mark operator is useless here
-  --> $DIR/needless_question_mark.rs:56:12
+  --> $DIR/needless_question_mark.rs:62:12
    |
 LL |     return Ok(tr.magic?)
    |            ^^^^^^^^^^^^^ help: try: `tr.magic`
 
 error: Question mark operator is useless here
-  --> $DIR/needless_question_mark.rs:60:5
+  --> $DIR/needless_question_mark.rs:66:5
    |
 LL |     Ok(tr.magic?)
    |     ^^^^^^^^^^^^^ help: try: `tr.magic`
 
 error: Question mark operator is useless here
-  --> $DIR/needless_question_mark.rs:64:21
+  --> $DIR/needless_question_mark.rs:70:21
    |
 LL |     tr.and_then(|t| Ok(t.magic?))
    |                     ^^^^^^^^^^^^ help: try: `t.magic`
 
 error: Question mark operator is useless here
-  --> $DIR/needless_question_mark.rs:72:9
+  --> $DIR/needless_question_mark.rs:78:9
    |
 LL |         Ok(t.magic?)
    |         ^^^^^^^^^^^^ help: try: `t.magic`
 
 error: Question mark operator is useless here
-  --> $DIR/needless_question_mark.rs:79:16
+  --> $DIR/needless_question_mark.rs:85:16
    |
 LL |         return Ok(t.magic?);
    |                ^^^^^^^^^^^^ help: try: `t.magic`
 
 error: Question mark operator is useless here
-  --> $DIR/needless_question_mark.rs:132:9
+  --> $DIR/needless_question_mark.rs:138:9
    |
 LL |         Ok(to.magic?) // should be triggered
    |         ^^^^^^^^^^^^^ help: try: `to.magic`
 
 error: Question mark operator is useless here
-  --> $DIR/needless_question_mark.rs:148:9
+  --> $DIR/needless_question_mark.rs:154:9
    |
 LL |         Some(to.magic?) // should be triggered
    |         ^^^^^^^^^^^^^^^ help: try: `to.magic`
 
 error: Question mark operator is useless here
-  --> $DIR/needless_question_mark.rs:156:9
+  --> $DIR/needless_question_mark.rs:162:9
    |
 LL |         Ok(to.magic?) // should be triggered
    |         ^^^^^^^^^^^^^ help: try: `to.magic`
diff --git a/tests/ui/suspicious_operation_groupings.rs b/tests/ui/suspicious_operation_groupings.rs
index dd6f4ec7bd9..2f8c7cec50f 100644
--- a/tests/ui/suspicious_operation_groupings.rs
+++ b/tests/ui/suspicious_operation_groupings.rs
@@ -27,7 +27,7 @@ fn buggy_ab_cmp(s1: &S, s2: &S) -> bool {
     s1.a < s2.a && s1.a < s2.b
 }
 
-struct SAOnly {
+struct SaOnly {
     a: i32,
 }
 
@@ -37,13 +37,13 @@ impl S {
     }
 }
 
-fn do_not_give_bad_suggestions_for_this_unusual_expr(s1: &S, s2: &SAOnly) -> bool {
+fn do_not_give_bad_suggestions_for_this_unusual_expr(s1: &S, s2: &SaOnly) -> bool {
     // This is superficially similar to `buggy_ab_cmp`, but we should not suggest
     // `s2.b` since that is invalid.
     s1.a < s2.a && s1.a() < s1.b
 }
 
-fn do_not_give_bad_suggestions_for_this_macro_expr(s1: &S, s2: &SAOnly) -> bool {
+fn do_not_give_bad_suggestions_for_this_macro_expr(s1: &S, s2: &SaOnly) -> bool {
     macro_rules! s1 {
         () => {
             S {
@@ -60,7 +60,7 @@ fn do_not_give_bad_suggestions_for_this_macro_expr(s1: &S, s2: &SAOnly) -> bool
     s1.a < s2.a && s1!().a < s1.b
 }
 
-fn do_not_give_bad_suggestions_for_this_incorrect_expr(s1: &S, s2: &SAOnly) -> bool {
+fn do_not_give_bad_suggestions_for_this_incorrect_expr(s1: &S, s2: &SaOnly) -> bool {
     // There's two `s1.b`, but we should not suggest `s2.b` since that is invalid
     s1.a < s2.a && s1.b < s1.b
 }
diff --git a/tests/ui/transmute_ptr_to_ptr.rs b/tests/ui/transmute_ptr_to_ptr.rs
index 26b03bdc740..9e213aab68c 100644
--- a/tests/ui/transmute_ptr_to_ptr.rs
+++ b/tests/ui/transmute_ptr_to_ptr.rs
@@ -53,10 +53,10 @@ fn transmute_ptr_to_ptr() {
 
 // dereferencing raw pointers in const contexts, should not lint as it's unstable (issue 5959)
 const _: &() = {
-    struct ZST;
-    let zst = &ZST;
+    struct Zst;
+    let zst = &Zst;
 
-    unsafe { std::mem::transmute::<&'static ZST, &'static ()>(zst) }
+    unsafe { std::mem::transmute::<&'static Zst, &'static ()>(zst) }
 };
 
 fn main() {}
diff --git a/tests/ui/unnested_or_patterns.fixed b/tests/ui/unnested_or_patterns.fixed
index b39e891094f..13a036cd800 100644
--- a/tests/ui/unnested_or_patterns.fixed
+++ b/tests/ui/unnested_or_patterns.fixed
@@ -3,7 +3,7 @@
 #![feature(or_patterns)]
 #![feature(box_patterns)]
 #![warn(clippy::unnested_or_patterns)]
-#![allow(clippy::cognitive_complexity, clippy::match_ref_pats)]
+#![allow(clippy::cognitive_complexity, clippy::match_ref_pats, clippy::upper_case_acronyms)]
 #![allow(unreachable_patterns, irrefutable_let_patterns, unused_variables)]
 
 fn main() {
diff --git a/tests/ui/unnested_or_patterns.rs b/tests/ui/unnested_or_patterns.rs
index 096f5a71150..4a10cc702c4 100644
--- a/tests/ui/unnested_or_patterns.rs
+++ b/tests/ui/unnested_or_patterns.rs
@@ -3,7 +3,7 @@
 #![feature(or_patterns)]
 #![feature(box_patterns)]
 #![warn(clippy::unnested_or_patterns)]
-#![allow(clippy::cognitive_complexity, clippy::match_ref_pats)]
+#![allow(clippy::cognitive_complexity, clippy::match_ref_pats, clippy::upper_case_acronyms)]
 #![allow(unreachable_patterns, irrefutable_let_patterns, unused_variables)]
 
 fn main() {
diff --git a/tests/ui/upper_case_acronyms.rs b/tests/ui/upper_case_acronyms.rs
new file mode 100644
index 00000000000..af0b5776348
--- /dev/null
+++ b/tests/ui/upper_case_acronyms.rs
@@ -0,0 +1,21 @@
+#![warn(clippy::upper_case_acronyms)]
+
+struct HTTPResponse; // linted
+
+struct CString; // not linted
+
+enum Flags {
+    NS, // linted
+    CWR,
+    ECE,
+    URG,
+    ACK,
+    PSH,
+    RST,
+    SYN,
+    FIN,
+}
+
+struct GCCLLVMSomething; // linted, beware that lint suggests `GccllvmSomething` instead of `GccLlvmSomething`
+
+fn main() {}
diff --git a/tests/ui/upper_case_acronyms.stderr b/tests/ui/upper_case_acronyms.stderr
new file mode 100644
index 00000000000..2065fe10bb1
--- /dev/null
+++ b/tests/ui/upper_case_acronyms.stderr
@@ -0,0 +1,70 @@
+error: name `HTTPResponse` contains a capitalized acronym
+  --> $DIR/upper_case_acronyms.rs:3:8
+   |
+LL | struct HTTPResponse; // linted
+   |        ^^^^^^^^^^^^ help: consider making the acronym lowercase, except the initial letter: `HttpResponse`
+   |
+   = note: `-D clippy::upper-case-acronyms` implied by `-D warnings`
+
+error: name `NS` contains a capitalized acronym
+  --> $DIR/upper_case_acronyms.rs:8:5
+   |
+LL |     NS, // linted
+   |     ^^ help: consider making the acronym lowercase, except the initial letter (notice the capitalization): `Ns`
+
+error: name `CWR` contains a capitalized acronym
+  --> $DIR/upper_case_acronyms.rs:9:5
+   |
+LL |     CWR,
+   |     ^^^ help: consider making the acronym lowercase, except the initial letter: `Cwr`
+
+error: name `ECE` contains a capitalized acronym
+  --> $DIR/upper_case_acronyms.rs:10:5
+   |
+LL |     ECE,
+   |     ^^^ help: consider making the acronym lowercase, except the initial letter: `Ece`
+
+error: name `URG` contains a capitalized acronym
+  --> $DIR/upper_case_acronyms.rs:11:5
+   |
+LL |     URG,
+   |     ^^^ help: consider making the acronym lowercase, except the initial letter: `Urg`
+
+error: name `ACK` contains a capitalized acronym
+  --> $DIR/upper_case_acronyms.rs:12:5
+   |
+LL |     ACK,
+   |     ^^^ help: consider making the acronym lowercase, except the initial letter (notice the capitalization): `Ack`
+
+error: name `PSH` contains a capitalized acronym
+  --> $DIR/upper_case_acronyms.rs:13:5
+   |
+LL |     PSH,
+   |     ^^^ help: consider making the acronym lowercase, except the initial letter: `Psh`
+
+error: name `RST` contains a capitalized acronym
+  --> $DIR/upper_case_acronyms.rs:14:5
+   |
+LL |     RST,
+   |     ^^^ help: consider making the acronym lowercase, except the initial letter: `Rst`
+
+error: name `SYN` contains a capitalized acronym
+  --> $DIR/upper_case_acronyms.rs:15:5
+   |
+LL |     SYN,
+   |     ^^^ help: consider making the acronym lowercase, except the initial letter: `Syn`
+
+error: name `FIN` contains a capitalized acronym
+  --> $DIR/upper_case_acronyms.rs:16:5
+   |
+LL |     FIN,
+   |     ^^^ help: consider making the acronym lowercase, except the initial letter: `Fin`
+
+error: name `GCCLLVMSomething` contains a capitalized acronym
+  --> $DIR/upper_case_acronyms.rs:19:8
+   |
+LL | struct GCCLLVMSomething; // linted, beware that lint suggests `GccllvmSomething` instead of `GccLlvmSomething`
+   |        ^^^^^^^^^^^^^^^^ help: consider making the acronym lowercase, except the initial letter: `GccllvmSomething`
+
+error: aborting due to 11 previous errors
+
diff --git a/tests/ui/use_self.fixed b/tests/ui/use_self.fixed
index d6a890014e6..bb2012441d9 100644
--- a/tests/ui/use_self.fixed
+++ b/tests/ui/use_self.fixed
@@ -3,7 +3,7 @@
 
 #![warn(clippy::use_self)]
 #![allow(dead_code)]
-#![allow(clippy::should_implement_trait)]
+#![allow(clippy::should_implement_trait, clippy::upper_case_acronyms)]
 
 fn main() {}
 
diff --git a/tests/ui/use_self.rs b/tests/ui/use_self.rs
index b04d9ce75b2..ddfd2beba31 100644
--- a/tests/ui/use_self.rs
+++ b/tests/ui/use_self.rs
@@ -3,7 +3,7 @@
 
 #![warn(clippy::use_self)]
 #![allow(dead_code)]
-#![allow(clippy::should_implement_trait)]
+#![allow(clippy::should_implement_trait, clippy::upper_case_acronyms)]
 
 fn main() {}
 
-- 
cgit 1.4.1-3-g733a5


From 0ccb491caa668d55522c1bc78e368329a310db4c Mon Sep 17 00:00:00 2001
From: Hirochika Matsumoto <matsujika@gmail.com>
Date: Wed, 20 Jan 2021 18:14:09 +0900
Subject: Remove nightly-gate of `split_inclusive`

Co-authored-by: Philipp Krones <hello@philkrones.com>
---
 clippy_lints/src/lib.rs | 1 -
 1 file changed, 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 9b73c249643..53764bb7390 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -6,7 +6,6 @@
 #![feature(concat_idents)]
 #![feature(crate_visibility_modifier)]
 #![feature(drain_filter)]
-#![feature(split_inclusive)]
 #![feature(in_band_lifetimes)]
 #![feature(once_cell)]
 #![feature(or_patterns)]
-- 
cgit 1.4.1-3-g733a5


From e42208f1b7befe316e32c66b6dc6d242a56f4d84 Mon Sep 17 00:00:00 2001
From: pastchick3 <331604390@qq.com>
Date: Wed, 20 Jan 2021 20:05:25 +0800
Subject: Improve the suggestion message of `stable_sort_primitive`.

---
 clippy_lints/src/stable_sort_primitive.rs | 31 +++++++++++++++++++------------
 tests/ui/stable_sort_primitive.stderr     | 27 ++++++++++++++++++++-------
 2 files changed, 39 insertions(+), 19 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/stable_sort_primitive.rs b/clippy_lints/src/stable_sort_primitive.rs
index 99e4b293ac6..276a9338819 100644
--- a/clippy_lints/src/stable_sort_primitive.rs
+++ b/clippy_lints/src/stable_sort_primitive.rs
@@ -1,4 +1,4 @@
-use crate::utils::{is_slice_of_primitives, span_lint_and_sugg, sugg::Sugg};
+use crate::utils::{is_slice_of_primitives, span_lint_and_then, sugg::Sugg};
 
 use if_chain::if_chain;
 
@@ -107,25 +107,32 @@ fn detect_stable_sort_primitive(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option
 impl LateLintPass<'_> for StableSortPrimitive {
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
         if let Some(detection) = detect_stable_sort_primitive(cx, expr) {
-            span_lint_and_sugg(
+            span_lint_and_then(
                 cx,
                 STABLE_SORT_PRIMITIVE,
                 expr.span,
                 format!(
-                    "used {} instead of {} to sort primitive type `{}`",
+                    "used `{}` on primitive type `{}`",
                     detection.method.stable_name(),
-                    detection.method.unstable_name(),
                     detection.slice_type,
                 )
                 .as_str(),
-                "try",
-                format!(
-                    "{}.{}({})",
-                    detection.slice_name,
-                    detection.method.unstable_name(),
-                    detection.method_args
-                ),
-                Applicability::MachineApplicable,
+                |diag| {
+                    diag.span_suggestion(
+                        expr.span,
+                        "try",
+                        format!(
+                            "{}.{}({})",
+                            detection.slice_name,
+                            detection.method.unstable_name(),
+                            detection.method_args,
+                        ),
+                        Applicability::MachineApplicable,
+                    );
+                    diag.note(
+                        "an unstable sort would perform faster without any observable difference for this data type",
+                    );
+                },
             );
         }
     }
diff --git a/tests/ui/stable_sort_primitive.stderr b/tests/ui/stable_sort_primitive.stderr
index 780389f32bc..b8d22ed2504 100644
--- a/tests/ui/stable_sort_primitive.stderr
+++ b/tests/ui/stable_sort_primitive.stderr
@@ -1,46 +1,59 @@
-error: used sort instead of sort_unstable to sort primitive type `i32`
+error: used `sort` on primitive type `i32`
   --> $DIR/stable_sort_primitive.rs:7:5
    |
 LL |     vec.sort();
    |     ^^^^^^^^^^ help: try: `vec.sort_unstable()`
    |
    = note: `-D clippy::stable-sort-primitive` implied by `-D warnings`
+   = note: an unstable sort would perform faster without any observable difference for this data type
 
-error: used sort instead of sort_unstable to sort primitive type `bool`
+error: used `sort` on primitive type `bool`
   --> $DIR/stable_sort_primitive.rs:9:5
    |
 LL |     vec.sort();
    |     ^^^^^^^^^^ help: try: `vec.sort_unstable()`
+   |
+   = note: an unstable sort would perform faster without any observable difference for this data type
 
-error: used sort instead of sort_unstable to sort primitive type `char`
+error: used `sort` on primitive type `char`
   --> $DIR/stable_sort_primitive.rs:11:5
    |
 LL |     vec.sort();
    |     ^^^^^^^^^^ help: try: `vec.sort_unstable()`
+   |
+   = note: an unstable sort would perform faster without any observable difference for this data type
 
-error: used sort instead of sort_unstable to sort primitive type `str`
+error: used `sort` on primitive type `str`
   --> $DIR/stable_sort_primitive.rs:13:5
    |
 LL |     vec.sort();
    |     ^^^^^^^^^^ help: try: `vec.sort_unstable()`
+   |
+   = note: an unstable sort would perform faster without any observable difference for this data type
 
-error: used sort instead of sort_unstable to sort primitive type `tuple`
+error: used `sort` on primitive type `tuple`
   --> $DIR/stable_sort_primitive.rs:15:5
    |
 LL |     vec.sort();
    |     ^^^^^^^^^^ help: try: `vec.sort_unstable()`
+   |
+   = note: an unstable sort would perform faster without any observable difference for this data type
 
-error: used sort instead of sort_unstable to sort primitive type `array`
+error: used `sort` on primitive type `array`
   --> $DIR/stable_sort_primitive.rs:17:5
    |
 LL |     vec.sort();
    |     ^^^^^^^^^^ help: try: `vec.sort_unstable()`
+   |
+   = note: an unstable sort would perform faster without any observable difference for this data type
 
-error: used sort instead of sort_unstable to sort primitive type `i32`
+error: used `sort` on primitive type `i32`
   --> $DIR/stable_sort_primitive.rs:19:5
    |
 LL |     arr.sort();
    |     ^^^^^^^^^^ help: try: `arr.sort_unstable()`
+   |
+   = note: an unstable sort would perform faster without any observable difference for this data type
 
 error: aborting due to 7 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From f1ab3024b27cc7c02a80fd54382a10a1b4ef3bcd Mon Sep 17 00:00:00 2001
From: Manish Goregaokar <manishsmail@gmail.com>
Date: Thu, 21 Jan 2021 12:48:30 -0800
Subject: New lint: exhaustive_enums

---
 CHANGELOG.md                         |  1 +
 clippy_lints/src/exhaustive_enums.rs | 68 ++++++++++++++++++++++++++++++++++++
 clippy_lints/src/lib.rs              |  4 +++
 tests/ui/exhaustive_enums.fixed      | 24 +++++++++++++
 tests/ui/exhaustive_enums.rs         | 23 ++++++++++++
 tests/ui/exhaustive_enums.stderr     | 28 +++++++++++++++
 6 files changed, 148 insertions(+)
 create mode 100644 clippy_lints/src/exhaustive_enums.rs
 create mode 100644 tests/ui/exhaustive_enums.fixed
 create mode 100644 tests/ui/exhaustive_enums.rs
 create mode 100644 tests/ui/exhaustive_enums.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 04f042b2deb..4cf2125ea2f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1938,6 +1938,7 @@ Released 2018-09-13
 [`erasing_op`]: https://rust-lang.github.io/rust-clippy/master/index.html#erasing_op
 [`eval_order_dependence`]: https://rust-lang.github.io/rust-clippy/master/index.html#eval_order_dependence
 [`excessive_precision`]: https://rust-lang.github.io/rust-clippy/master/index.html#excessive_precision
+[`exhaustive_enums`]: https://rust-lang.github.io/rust-clippy/master/index.html#exhaustive_enums
 [`exit`]: https://rust-lang.github.io/rust-clippy/master/index.html#exit
 [`expect_fun_call`]: https://rust-lang.github.io/rust-clippy/master/index.html#expect_fun_call
 [`expect_used`]: https://rust-lang.github.io/rust-clippy/master/index.html#expect_used
diff --git a/clippy_lints/src/exhaustive_enums.rs b/clippy_lints/src/exhaustive_enums.rs
new file mode 100644
index 00000000000..099171962d3
--- /dev/null
+++ b/clippy_lints/src/exhaustive_enums.rs
@@ -0,0 +1,68 @@
+use crate::utils::{snippet_opt, span_lint_and_help, span_lint_and_sugg};
+use if_chain::if_chain;
+use rustc_ast::ast::{Item, ItemKind};
+use rustc_errors::Applicability;
+use rustc_lint::{EarlyContext, EarlyLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::sym;
+
+declare_clippy_lint! {
+    /// **What it does:** Warns on any `enum`s that are not tagged `#[non_exhaustive]`
+    ///
+    /// **Why is this bad?** Exhaustive enums are typically fine, but a project which does
+    /// not wish to make a stability commitment around enums may wish to disable them by default.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// enum Foo {
+    ///     Bar,
+    ///     Baz
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// #[non_exhaustive]
+    /// enum Foo {
+    ///     Bar,
+    ///     Baz
+    /// }    /// ```
+    pub EXHAUSTIVE_ENUMS,
+    restriction,
+    "default lint description"
+}
+
+declare_lint_pass!(ExhaustiveEnums => [EXHAUSTIVE_ENUMS]);
+
+impl EarlyLintPass for ExhaustiveEnums {
+    fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {
+        if_chain! {
+            if let ItemKind::Enum(..) = item.kind;
+            if !item.attrs.iter().any(|a| a.has_name(sym::non_exhaustive));
+            then {
+                if let Some(snippet) = snippet_opt(cx, item.span) {
+                    span_lint_and_sugg(
+                        cx,
+                        EXHAUSTIVE_ENUMS,
+                        item.span,
+                        "enums should not be exhaustive",
+                        "try adding #[non_exhaustive]",
+                        format!("#[non_exhaustive]\n{}", snippet),
+                        Applicability::MaybeIncorrect,
+                    );
+                } else {
+                    span_lint_and_help(
+                        cx,
+                        EXHAUSTIVE_ENUMS,
+                        item.span,
+                        "enums should not be exhaustive",
+                        None,
+                        "try adding #[non_exhaustive]",
+                    );
+                }
+            }
+        }
+    }
+}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 53764bb7390..465ad3846ce 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -200,6 +200,7 @@ mod escape;
 mod eta_reduction;
 mod eval_order_dependence;
 mod excessive_bools;
+mod exhaustive_enums;
 mod exit;
 mod explicit_write;
 mod fallible_impl_from;
@@ -611,6 +612,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &eval_order_dependence::EVAL_ORDER_DEPENDENCE,
         &excessive_bools::FN_PARAMS_EXCESSIVE_BOOLS,
         &excessive_bools::STRUCT_EXCESSIVE_BOOLS,
+        &exhaustive_enums::EXHAUSTIVE_ENUMS,
         &exit::EXIT,
         &explicit_write::EXPLICIT_WRITE,
         &fallible_impl_from::FALLIBLE_IMPL_FROM,
@@ -1096,6 +1098,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box eval_order_dependence::EvalOrderDependence);
     store.register_late_pass(|| box missing_doc::MissingDoc::new());
     store.register_late_pass(|| box missing_inline::MissingInline);
+    store.register_early_pass(move || box exhaustive_enums::ExhaustiveEnums);
     store.register_late_pass(|| box if_let_some_result::OkIfLet);
     store.register_late_pass(|| box partialeq_ne_impl::PartialEqNeImpl);
     store.register_late_pass(|| box unused_io_amount::UnusedIoAmount);
@@ -1246,6 +1249,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&create_dir::CREATE_DIR),
         LintId::of(&dbg_macro::DBG_MACRO),
         LintId::of(&else_if_without_else::ELSE_IF_WITHOUT_ELSE),
+        LintId::of(&exhaustive_enums::EXHAUSTIVE_ENUMS),
         LintId::of(&exit::EXIT),
         LintId::of(&float_literal::LOSSY_FLOAT_LITERAL),
         LintId::of(&implicit_return::IMPLICIT_RETURN),
diff --git a/tests/ui/exhaustive_enums.fixed b/tests/ui/exhaustive_enums.fixed
new file mode 100644
index 00000000000..2d5f0474bc0
--- /dev/null
+++ b/tests/ui/exhaustive_enums.fixed
@@ -0,0 +1,24 @@
+// run-rustfix
+
+#![deny(clippy::exhaustive_enums)]
+#![allow(unused)]
+
+fn main() {
+    // nop
+}
+
+#[non_exhaustive]
+enum Exhaustive {
+    Foo,
+    Bar,
+    Baz,
+    Quux(String),
+}
+
+#[non_exhaustive]
+enum NonExhaustive {
+    Foo,
+    Bar,
+    Baz,
+    Quux(String),
+}
diff --git a/tests/ui/exhaustive_enums.rs b/tests/ui/exhaustive_enums.rs
new file mode 100644
index 00000000000..5c88454ae61
--- /dev/null
+++ b/tests/ui/exhaustive_enums.rs
@@ -0,0 +1,23 @@
+// run-rustfix
+
+#![deny(clippy::exhaustive_enums)]
+#![allow(unused)]
+
+fn main() {
+    // nop
+}
+
+enum Exhaustive {
+    Foo,
+    Bar,
+    Baz,
+    Quux(String),
+}
+
+#[non_exhaustive]
+enum NonExhaustive {
+    Foo,
+    Bar,
+    Baz,
+    Quux(String),
+}
diff --git a/tests/ui/exhaustive_enums.stderr b/tests/ui/exhaustive_enums.stderr
new file mode 100644
index 00000000000..ee5a1836267
--- /dev/null
+++ b/tests/ui/exhaustive_enums.stderr
@@ -0,0 +1,28 @@
+error: enums should not be exhaustive
+  --> $DIR/exhaustive_enums.rs:10:1
+   |
+LL | / enum Exhaustive {
+LL | |     Foo,
+LL | |     Bar,
+LL | |     Baz,
+LL | |     Quux(String),
+LL | | }
+   | |_^
+   |
+note: the lint level is defined here
+  --> $DIR/exhaustive_enums.rs:3:9
+   |
+LL | #![deny(clippy::exhaustive_enums)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^
+help: try adding #[non_exhaustive]
+   |
+LL | #[non_exhaustive]
+LL | enum Exhaustive {
+LL |     Foo,
+LL |     Bar,
+LL |     Baz,
+LL |     Quux(String),
+ ...
+
+error: aborting due to previous error
+
-- 
cgit 1.4.1-3-g733a5


From dc93188805ac20fbccd7bd616a6b114680e9303a Mon Sep 17 00:00:00 2001
From: Manish Goregaokar <manishsmail@gmail.com>
Date: Thu, 21 Jan 2021 13:31:15 -0800
Subject: Make exhaustive_enums a late pass

---
 clippy_lints/src/exhaustive_enums.rs | 8 ++++----
 clippy_lints/src/lib.rs              | 2 +-
 2 files changed, 5 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/exhaustive_enums.rs b/clippy_lints/src/exhaustive_enums.rs
index 099171962d3..1391ebd9e31 100644
--- a/clippy_lints/src/exhaustive_enums.rs
+++ b/clippy_lints/src/exhaustive_enums.rs
@@ -1,8 +1,8 @@
 use crate::utils::{snippet_opt, span_lint_and_help, span_lint_and_sugg};
 use if_chain::if_chain;
-use rustc_ast::ast::{Item, ItemKind};
+use rustc_hir::{Item, ItemKind};
 use rustc_errors::Applicability;
-use rustc_lint::{EarlyContext, EarlyLintPass};
+use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::sym;
 
@@ -36,8 +36,8 @@ declare_clippy_lint! {
 
 declare_lint_pass!(ExhaustiveEnums => [EXHAUSTIVE_ENUMS]);
 
-impl EarlyLintPass for ExhaustiveEnums {
-    fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {
+impl LateLintPass<'_> for ExhaustiveEnums {
+    fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
         if_chain! {
             if let ItemKind::Enum(..) = item.kind;
             if !item.attrs.iter().any(|a| a.has_name(sym::non_exhaustive));
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 465ad3846ce..becd9f333fd 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1098,7 +1098,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box eval_order_dependence::EvalOrderDependence);
     store.register_late_pass(|| box missing_doc::MissingDoc::new());
     store.register_late_pass(|| box missing_inline::MissingInline);
-    store.register_early_pass(move || box exhaustive_enums::ExhaustiveEnums);
+    store.register_late_pass(move || box exhaustive_enums::ExhaustiveEnums);
     store.register_late_pass(|| box if_let_some_result::OkIfLet);
     store.register_late_pass(|| box partialeq_ne_impl::PartialEqNeImpl);
     store.register_late_pass(|| box unused_io_amount::UnusedIoAmount);
-- 
cgit 1.4.1-3-g733a5


From f6cb96ef07ac6197dac5be16adbe2b7950c82d99 Mon Sep 17 00:00:00 2001
From: Manish Goregaokar <manishsmail@gmail.com>
Date: Thu, 21 Jan 2021 13:34:44 -0800
Subject: Make exhaustive_enums only warn on exported items

---
 clippy_lints/src/exhaustive_enums.rs |  3 ++-
 tests/ui/exhaustive_enums.fixed      | 22 ++++++++++++++++++++--
 tests/ui/exhaustive_enums.rs         | 22 ++++++++++++++++++++--
 tests/ui/exhaustive_enums.stderr     |  4 ++--
 4 files changed, 44 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/exhaustive_enums.rs b/clippy_lints/src/exhaustive_enums.rs
index 1391ebd9e31..2e1c0728d2c 100644
--- a/clippy_lints/src/exhaustive_enums.rs
+++ b/clippy_lints/src/exhaustive_enums.rs
@@ -7,7 +7,7 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::sym;
 
 declare_clippy_lint! {
-    /// **What it does:** Warns on any `enum`s that are not tagged `#[non_exhaustive]`
+    /// **What it does:** Warns on any exported `enum`s that are not tagged `#[non_exhaustive]`
     ///
     /// **Why is this bad?** Exhaustive enums are typically fine, but a project which does
     /// not wish to make a stability commitment around enums may wish to disable them by default.
@@ -40,6 +40,7 @@ impl LateLintPass<'_> for ExhaustiveEnums {
     fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
         if_chain! {
             if let ItemKind::Enum(..) = item.kind;
+            if cx.access_levels.is_exported(item.hir_id);
             if !item.attrs.iter().any(|a| a.has_name(sym::non_exhaustive));
             then {
                 if let Some(snippet) = snippet_opt(cx, item.span) {
diff --git a/tests/ui/exhaustive_enums.fixed b/tests/ui/exhaustive_enums.fixed
index 2d5f0474bc0..71c4a251e3b 100644
--- a/tests/ui/exhaustive_enums.fixed
+++ b/tests/ui/exhaustive_enums.fixed
@@ -8,15 +8,33 @@ fn main() {
 }
 
 #[non_exhaustive]
-enum Exhaustive {
+pub enum Exhaustive {
     Foo,
     Bar,
     Baz,
     Quux(String),
 }
 
+// no warning, already non_exhaustive
 #[non_exhaustive]
-enum NonExhaustive {
+pub enum NonExhaustive {
+    Foo,
+    Bar,
+    Baz,
+    Quux(String),
+}
+
+// no warning, private
+enum ExhaustivePrivate {
+    Foo,
+    Bar,
+    Baz,
+    Quux(String),
+}
+
+// no warning, private
+#[non_exhaustive]
+enum NonExhaustivePrivate {
     Foo,
     Bar,
     Baz,
diff --git a/tests/ui/exhaustive_enums.rs b/tests/ui/exhaustive_enums.rs
index 5c88454ae61..45af6851dd1 100644
--- a/tests/ui/exhaustive_enums.rs
+++ b/tests/ui/exhaustive_enums.rs
@@ -7,15 +7,33 @@ fn main() {
     // nop
 }
 
-enum Exhaustive {
+pub enum Exhaustive {
     Foo,
     Bar,
     Baz,
     Quux(String),
 }
 
+// no warning, already non_exhaustive
 #[non_exhaustive]
-enum NonExhaustive {
+pub enum NonExhaustive {
+    Foo,
+    Bar,
+    Baz,
+    Quux(String),
+}
+
+// no warning, private
+enum ExhaustivePrivate {
+    Foo,
+    Bar,
+    Baz,
+    Quux(String),
+}
+
+// no warning, private
+#[non_exhaustive]
+enum NonExhaustivePrivate {
     Foo,
     Bar,
     Baz,
diff --git a/tests/ui/exhaustive_enums.stderr b/tests/ui/exhaustive_enums.stderr
index ee5a1836267..280c40b00aa 100644
--- a/tests/ui/exhaustive_enums.stderr
+++ b/tests/ui/exhaustive_enums.stderr
@@ -1,7 +1,7 @@
 error: enums should not be exhaustive
   --> $DIR/exhaustive_enums.rs:10:1
    |
-LL | / enum Exhaustive {
+LL | / pub enum Exhaustive {
 LL | |     Foo,
 LL | |     Bar,
 LL | |     Baz,
@@ -17,7 +17,7 @@ LL | #![deny(clippy::exhaustive_enums)]
 help: try adding #[non_exhaustive]
    |
 LL | #[non_exhaustive]
-LL | enum Exhaustive {
+LL | pub enum Exhaustive {
 LL |     Foo,
 LL |     Bar,
 LL |     Baz,
-- 
cgit 1.4.1-3-g733a5


From 09d4d49299c6614a0ae956980e709a234d21a9ef Mon Sep 17 00:00:00 2001
From: Manish Goregaokar <manishsmail@gmail.com>
Date: Thu, 21 Jan 2021 13:36:18 -0800
Subject: ExhaustiveEnums -> ExhaustiveItems

---
 clippy_lints/src/exhaustive_enums.rs | 69 ------------------------------------
 clippy_lints/src/exhaustive_items.rs | 69 ++++++++++++++++++++++++++++++++++++
 clippy_lints/src/lib.rs              |  8 ++---
 tests/ui/exhaustive_enums.fixed      | 42 ----------------------
 tests/ui/exhaustive_enums.rs         | 41 ---------------------
 tests/ui/exhaustive_enums.stderr     | 28 ---------------
 tests/ui/exhaustive_items.fixed      | 42 ++++++++++++++++++++++
 tests/ui/exhaustive_items.rs         | 41 +++++++++++++++++++++
 tests/ui/exhaustive_items.stderr     | 28 +++++++++++++++
 9 files changed, 184 insertions(+), 184 deletions(-)
 delete mode 100644 clippy_lints/src/exhaustive_enums.rs
 create mode 100644 clippy_lints/src/exhaustive_items.rs
 delete mode 100644 tests/ui/exhaustive_enums.fixed
 delete mode 100644 tests/ui/exhaustive_enums.rs
 delete mode 100644 tests/ui/exhaustive_enums.stderr
 create mode 100644 tests/ui/exhaustive_items.fixed
 create mode 100644 tests/ui/exhaustive_items.rs
 create mode 100644 tests/ui/exhaustive_items.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/exhaustive_enums.rs b/clippy_lints/src/exhaustive_enums.rs
deleted file mode 100644
index 2e1c0728d2c..00000000000
--- a/clippy_lints/src/exhaustive_enums.rs
+++ /dev/null
@@ -1,69 +0,0 @@
-use crate::utils::{snippet_opt, span_lint_and_help, span_lint_and_sugg};
-use if_chain::if_chain;
-use rustc_hir::{Item, ItemKind};
-use rustc_errors::Applicability;
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::sym;
-
-declare_clippy_lint! {
-    /// **What it does:** Warns on any exported `enum`s that are not tagged `#[non_exhaustive]`
-    ///
-    /// **Why is this bad?** Exhaustive enums are typically fine, but a project which does
-    /// not wish to make a stability commitment around enums may wish to disable them by default.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
-    /// ```rust
-    /// enum Foo {
-    ///     Bar,
-    ///     Baz
-    /// }
-    /// ```
-    /// Use instead:
-    /// ```rust
-    /// #[non_exhaustive]
-    /// enum Foo {
-    ///     Bar,
-    ///     Baz
-    /// }    /// ```
-    pub EXHAUSTIVE_ENUMS,
-    restriction,
-    "default lint description"
-}
-
-declare_lint_pass!(ExhaustiveEnums => [EXHAUSTIVE_ENUMS]);
-
-impl LateLintPass<'_> for ExhaustiveEnums {
-    fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
-        if_chain! {
-            if let ItemKind::Enum(..) = item.kind;
-            if cx.access_levels.is_exported(item.hir_id);
-            if !item.attrs.iter().any(|a| a.has_name(sym::non_exhaustive));
-            then {
-                if let Some(snippet) = snippet_opt(cx, item.span) {
-                    span_lint_and_sugg(
-                        cx,
-                        EXHAUSTIVE_ENUMS,
-                        item.span,
-                        "enums should not be exhaustive",
-                        "try adding #[non_exhaustive]",
-                        format!("#[non_exhaustive]\n{}", snippet),
-                        Applicability::MaybeIncorrect,
-                    );
-                } else {
-                    span_lint_and_help(
-                        cx,
-                        EXHAUSTIVE_ENUMS,
-                        item.span,
-                        "enums should not be exhaustive",
-                        None,
-                        "try adding #[non_exhaustive]",
-                    );
-                }
-            }
-        }
-    }
-}
diff --git a/clippy_lints/src/exhaustive_items.rs b/clippy_lints/src/exhaustive_items.rs
new file mode 100644
index 00000000000..0fa6c4b589f
--- /dev/null
+++ b/clippy_lints/src/exhaustive_items.rs
@@ -0,0 +1,69 @@
+use crate::utils::{snippet_opt, span_lint_and_help, span_lint_and_sugg};
+use if_chain::if_chain;
+use rustc_hir::{Item, ItemKind};
+use rustc_errors::Applicability;
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::sym;
+
+declare_clippy_lint! {
+    /// **What it does:** Warns on any exported `enum`s that are not tagged `#[non_exhaustive]`
+    ///
+    /// **Why is this bad?** Exhaustive enums are typically fine, but a project which does
+    /// not wish to make a stability commitment around enums may wish to disable them by default.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// enum Foo {
+    ///     Bar,
+    ///     Baz
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// #[non_exhaustive]
+    /// enum Foo {
+    ///     Bar,
+    ///     Baz
+    /// }    /// ```
+    pub EXHAUSTIVE_ENUMS,
+    restriction,
+    "default lint description"
+}
+
+declare_lint_pass!(ExhaustiveItems => [EXHAUSTIVE_ENUMS]);
+
+impl LateLintPass<'_> for ExhaustiveItems {
+    fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
+        if_chain! {
+            if let ItemKind::Enum(..) = item.kind;
+            if cx.access_levels.is_exported(item.hir_id);
+            if !item.attrs.iter().any(|a| a.has_name(sym::non_exhaustive));
+            then {
+                if let Some(snippet) = snippet_opt(cx, item.span) {
+                    span_lint_and_sugg(
+                        cx,
+                        EXHAUSTIVE_ENUMS,
+                        item.span,
+                        "enums should not be exhaustive",
+                        "try adding #[non_exhaustive]",
+                        format!("#[non_exhaustive]\n{}", snippet),
+                        Applicability::MaybeIncorrect,
+                    );
+                } else {
+                    span_lint_and_help(
+                        cx,
+                        EXHAUSTIVE_ENUMS,
+                        item.span,
+                        "enums should not be exhaustive",
+                        None,
+                        "try adding #[non_exhaustive]",
+                    );
+                }
+            }
+        }
+    }
+}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index becd9f333fd..a5deebf7d5f 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -200,7 +200,7 @@ mod escape;
 mod eta_reduction;
 mod eval_order_dependence;
 mod excessive_bools;
-mod exhaustive_enums;
+mod exhaustive_items;
 mod exit;
 mod explicit_write;
 mod fallible_impl_from;
@@ -612,7 +612,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &eval_order_dependence::EVAL_ORDER_DEPENDENCE,
         &excessive_bools::FN_PARAMS_EXCESSIVE_BOOLS,
         &excessive_bools::STRUCT_EXCESSIVE_BOOLS,
-        &exhaustive_enums::EXHAUSTIVE_ENUMS,
+        &exhaustive_items::EXHAUSTIVE_ENUMS,
         &exit::EXIT,
         &explicit_write::EXPLICIT_WRITE,
         &fallible_impl_from::FALLIBLE_IMPL_FROM,
@@ -1098,7 +1098,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box eval_order_dependence::EvalOrderDependence);
     store.register_late_pass(|| box missing_doc::MissingDoc::new());
     store.register_late_pass(|| box missing_inline::MissingInline);
-    store.register_late_pass(move || box exhaustive_enums::ExhaustiveEnums);
+    store.register_late_pass(move || box exhaustive_items::ExhaustiveItems);
     store.register_late_pass(|| box if_let_some_result::OkIfLet);
     store.register_late_pass(|| box partialeq_ne_impl::PartialEqNeImpl);
     store.register_late_pass(|| box unused_io_amount::UnusedIoAmount);
@@ -1249,7 +1249,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&create_dir::CREATE_DIR),
         LintId::of(&dbg_macro::DBG_MACRO),
         LintId::of(&else_if_without_else::ELSE_IF_WITHOUT_ELSE),
-        LintId::of(&exhaustive_enums::EXHAUSTIVE_ENUMS),
+        LintId::of(&exhaustive_items::EXHAUSTIVE_ENUMS),
         LintId::of(&exit::EXIT),
         LintId::of(&float_literal::LOSSY_FLOAT_LITERAL),
         LintId::of(&implicit_return::IMPLICIT_RETURN),
diff --git a/tests/ui/exhaustive_enums.fixed b/tests/ui/exhaustive_enums.fixed
deleted file mode 100644
index 71c4a251e3b..00000000000
--- a/tests/ui/exhaustive_enums.fixed
+++ /dev/null
@@ -1,42 +0,0 @@
-// run-rustfix
-
-#![deny(clippy::exhaustive_enums)]
-#![allow(unused)]
-
-fn main() {
-    // nop
-}
-
-#[non_exhaustive]
-pub enum Exhaustive {
-    Foo,
-    Bar,
-    Baz,
-    Quux(String),
-}
-
-// no warning, already non_exhaustive
-#[non_exhaustive]
-pub enum NonExhaustive {
-    Foo,
-    Bar,
-    Baz,
-    Quux(String),
-}
-
-// no warning, private
-enum ExhaustivePrivate {
-    Foo,
-    Bar,
-    Baz,
-    Quux(String),
-}
-
-// no warning, private
-#[non_exhaustive]
-enum NonExhaustivePrivate {
-    Foo,
-    Bar,
-    Baz,
-    Quux(String),
-}
diff --git a/tests/ui/exhaustive_enums.rs b/tests/ui/exhaustive_enums.rs
deleted file mode 100644
index 45af6851dd1..00000000000
--- a/tests/ui/exhaustive_enums.rs
+++ /dev/null
@@ -1,41 +0,0 @@
-// run-rustfix
-
-#![deny(clippy::exhaustive_enums)]
-#![allow(unused)]
-
-fn main() {
-    // nop
-}
-
-pub enum Exhaustive {
-    Foo,
-    Bar,
-    Baz,
-    Quux(String),
-}
-
-// no warning, already non_exhaustive
-#[non_exhaustive]
-pub enum NonExhaustive {
-    Foo,
-    Bar,
-    Baz,
-    Quux(String),
-}
-
-// no warning, private
-enum ExhaustivePrivate {
-    Foo,
-    Bar,
-    Baz,
-    Quux(String),
-}
-
-// no warning, private
-#[non_exhaustive]
-enum NonExhaustivePrivate {
-    Foo,
-    Bar,
-    Baz,
-    Quux(String),
-}
diff --git a/tests/ui/exhaustive_enums.stderr b/tests/ui/exhaustive_enums.stderr
deleted file mode 100644
index 280c40b00aa..00000000000
--- a/tests/ui/exhaustive_enums.stderr
+++ /dev/null
@@ -1,28 +0,0 @@
-error: enums should not be exhaustive
-  --> $DIR/exhaustive_enums.rs:10:1
-   |
-LL | / pub enum Exhaustive {
-LL | |     Foo,
-LL | |     Bar,
-LL | |     Baz,
-LL | |     Quux(String),
-LL | | }
-   | |_^
-   |
-note: the lint level is defined here
-  --> $DIR/exhaustive_enums.rs:3:9
-   |
-LL | #![deny(clippy::exhaustive_enums)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^
-help: try adding #[non_exhaustive]
-   |
-LL | #[non_exhaustive]
-LL | pub enum Exhaustive {
-LL |     Foo,
-LL |     Bar,
-LL |     Baz,
-LL |     Quux(String),
- ...
-
-error: aborting due to previous error
-
diff --git a/tests/ui/exhaustive_items.fixed b/tests/ui/exhaustive_items.fixed
new file mode 100644
index 00000000000..71c4a251e3b
--- /dev/null
+++ b/tests/ui/exhaustive_items.fixed
@@ -0,0 +1,42 @@
+// run-rustfix
+
+#![deny(clippy::exhaustive_enums)]
+#![allow(unused)]
+
+fn main() {
+    // nop
+}
+
+#[non_exhaustive]
+pub enum Exhaustive {
+    Foo,
+    Bar,
+    Baz,
+    Quux(String),
+}
+
+// no warning, already non_exhaustive
+#[non_exhaustive]
+pub enum NonExhaustive {
+    Foo,
+    Bar,
+    Baz,
+    Quux(String),
+}
+
+// no warning, private
+enum ExhaustivePrivate {
+    Foo,
+    Bar,
+    Baz,
+    Quux(String),
+}
+
+// no warning, private
+#[non_exhaustive]
+enum NonExhaustivePrivate {
+    Foo,
+    Bar,
+    Baz,
+    Quux(String),
+}
diff --git a/tests/ui/exhaustive_items.rs b/tests/ui/exhaustive_items.rs
new file mode 100644
index 00000000000..45af6851dd1
--- /dev/null
+++ b/tests/ui/exhaustive_items.rs
@@ -0,0 +1,41 @@
+// run-rustfix
+
+#![deny(clippy::exhaustive_enums)]
+#![allow(unused)]
+
+fn main() {
+    // nop
+}
+
+pub enum Exhaustive {
+    Foo,
+    Bar,
+    Baz,
+    Quux(String),
+}
+
+// no warning, already non_exhaustive
+#[non_exhaustive]
+pub enum NonExhaustive {
+    Foo,
+    Bar,
+    Baz,
+    Quux(String),
+}
+
+// no warning, private
+enum ExhaustivePrivate {
+    Foo,
+    Bar,
+    Baz,
+    Quux(String),
+}
+
+// no warning, private
+#[non_exhaustive]
+enum NonExhaustivePrivate {
+    Foo,
+    Bar,
+    Baz,
+    Quux(String),
+}
diff --git a/tests/ui/exhaustive_items.stderr b/tests/ui/exhaustive_items.stderr
new file mode 100644
index 00000000000..d00d950efc7
--- /dev/null
+++ b/tests/ui/exhaustive_items.stderr
@@ -0,0 +1,28 @@
+error: enums should not be exhaustive
+  --> $DIR/exhaustive_items.rs:10:1
+   |
+LL | / pub enum Exhaustive {
+LL | |     Foo,
+LL | |     Bar,
+LL | |     Baz,
+LL | |     Quux(String),
+LL | | }
+   | |_^
+   |
+note: the lint level is defined here
+  --> $DIR/exhaustive_items.rs:3:9
+   |
+LL | #![deny(clippy::exhaustive_enums)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^
+help: try adding #[non_exhaustive]
+   |
+LL | #[non_exhaustive]
+LL | pub enum Exhaustive {
+LL |     Foo,
+LL |     Bar,
+LL |     Baz,
+LL |     Quux(String),
+ ...
+
+error: aborting due to previous error
+
-- 
cgit 1.4.1-3-g733a5


From 2d509f8b404b77fd7fa949a13fd38c9f5f51b9fb Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Thu, 21 Jan 2021 18:12:46 -0600
Subject: Check if let guard in collapsible_match

---
 clippy_lints/src/collapsible_match.rs | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/collapsible_match.rs b/clippy_lints/src/collapsible_match.rs
index a34ba2d00a8..c75aa2bde97 100644
--- a/clippy_lints/src/collapsible_match.rs
+++ b/clippy_lints/src/collapsible_match.rs
@@ -85,7 +85,12 @@ fn check_arm(arm: &Arm<'_>, wild_outer_arm: &Arm<'_>, cx: &LateContext<'_>) {
         // the "wild-like" branches must be equal
         if SpanlessEq::new(cx).eq_expr(wild_inner_arm.body, wild_outer_arm.body);
         // the binding must not be used in the if guard
-        if !matches!(arm.guard, Some(Guard::If(guard)) if LocalUsedVisitor::new(binding_id).check_expr(guard));
+        if match arm.guard {
+            None => true,
+            Some(Guard::If(expr) | Guard::IfLet(_, expr)) => {
+                !LocalUsedVisitor::new(binding_id).check_expr(expr)
+            }
+        };
         // ...or anywhere in the inner match
         if !arms_inner.iter().any(|arm| LocalUsedVisitor::new(binding_id).check_arm(arm));
         then {
-- 
cgit 1.4.1-3-g733a5


From e89ad4ba71816cbe6fb1f90743d9229fc824b1c0 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Mon, 14 Dec 2020 13:50:53 -0600
Subject: Fix comment

---
 clippy_lints/src/methods/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 623554ea2d1..c8b69f4fbae 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3059,7 +3059,7 @@ fn lint_filter_map_map<'tcx>(
     _filter_args: &'tcx [hir::Expr<'_>],
     _map_args: &'tcx [hir::Expr<'_>],
 ) {
-    // lint if caller of `.filter().map()` is an Iterator
+    // lint if caller of `.filter_map().map()` is an Iterator
     if match_trait_method(cx, expr, &paths::ITERATOR) {
         let msg = "called `filter_map(..).map(..)` on an `Iterator`";
         let hint = "this is more succinctly expressed by only calling `.filter_map(..)` instead";
-- 
cgit 1.4.1-3-g733a5


From 7a8660861ecf11474e03823387a50eeaa2c18a57 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Fri, 1 Jan 2021 13:00:44 -0600
Subject: Add expr_fallback to SpanlessEq

---
 clippy_lints/src/utils/hir_utils.rs | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/hir_utils.rs b/clippy_lints/src/utils/hir_utils.rs
index 10120a8805d..1c7398f17f2 100644
--- a/clippy_lints/src/utils/hir_utils.rs
+++ b/clippy_lints/src/utils/hir_utils.rs
@@ -24,6 +24,7 @@ pub struct SpanlessEq<'a, 'tcx> {
     cx: &'a LateContext<'tcx>,
     maybe_typeck_results: Option<&'tcx TypeckResults<'tcx>>,
     allow_side_effects: bool,
+    expr_fallback: Option<Box<dyn Fn(&Expr<'_>, &Expr<'_>) -> bool + 'a>>,
 }
 
 impl<'a, 'tcx> SpanlessEq<'a, 'tcx> {
@@ -32,6 +33,7 @@ impl<'a, 'tcx> SpanlessEq<'a, 'tcx> {
             cx,
             maybe_typeck_results: cx.maybe_typeck_results(),
             allow_side_effects: true,
+            expr_fallback: None,
         }
     }
 
@@ -43,6 +45,13 @@ impl<'a, 'tcx> SpanlessEq<'a, 'tcx> {
         }
     }
 
+    pub fn expr_fallback(self, expr_fallback: impl Fn(&Expr<'_>, &Expr<'_>) -> bool + 'a) -> Self {
+        Self {
+            expr_fallback: Some(Box::new(expr_fallback)),
+            ..self
+        }
+    }
+
     /// Checks whether two statements are the same.
     pub fn eq_stmt(&mut self, left: &Stmt<'_>, right: &Stmt<'_>) -> bool {
         match (&left.kind, &right.kind) {
@@ -81,7 +90,7 @@ impl<'a, 'tcx> SpanlessEq<'a, 'tcx> {
             }
         }
 
-        match (&reduce_exprkind(&left.kind), &reduce_exprkind(&right.kind)) {
+        let is_eq = match (&reduce_exprkind(&left.kind), &reduce_exprkind(&right.kind)) {
             (&ExprKind::AddrOf(lb, l_mut, ref le), &ExprKind::AddrOf(rb, r_mut, ref re)) => {
                 lb == rb && l_mut == r_mut && self.eq_expr(le, re)
             },
@@ -158,7 +167,8 @@ impl<'a, 'tcx> SpanlessEq<'a, 'tcx> {
             (&ExprKind::Array(l), &ExprKind::Array(r)) => self.eq_exprs(l, r),
             (&ExprKind::DropTemps(ref le), &ExprKind::DropTemps(ref re)) => self.eq_expr(le, re),
             _ => false,
-        }
+        };
+        is_eq || self.expr_fallback.as_ref().map_or(false, |f| f(left, right))
     }
 
     fn eq_exprs(&mut self, left: &[Expr<'_>], right: &[Expr<'_>]) -> bool {
-- 
cgit 1.4.1-3-g733a5


From c92bdc4dbbd777f6933f7990f87066147a629c8d Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Fri, 1 Jan 2021 13:00:09 -0600
Subject: Split filter_map into manual_filter_map

---
 CHANGELOG.md                      |   1 +
 clippy_lints/src/lib.rs           |   3 ++
 clippy_lints/src/methods/mod.rs   | 109 +++++++++++++++++++++++++++++++++-----
 tests/ui/filter_methods.stderr    |  12 +----
 tests/ui/manual_filter_map.fixed  |  37 +++++++++++++
 tests/ui/manual_filter_map.rs     |  37 +++++++++++++
 tests/ui/manual_filter_map.stderr |  22 ++++++++
 7 files changed, 198 insertions(+), 23 deletions(-)
 create mode 100644 tests/ui/manual_filter_map.fixed
 create mode 100644 tests/ui/manual_filter_map.rs
 create mode 100644 tests/ui/manual_filter_map.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 04f042b2deb..8feb1a148af 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2035,6 +2035,7 @@ Released 2018-09-13
 [`macro_use_imports`]: https://rust-lang.github.io/rust-clippy/master/index.html#macro_use_imports
 [`main_recursion`]: https://rust-lang.github.io/rust-clippy/master/index.html#main_recursion
 [`manual_async_fn`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_async_fn
+[`manual_filter_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_filter_map
 [`manual_memcpy`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_memcpy
 [`manual_non_exhaustive`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_non_exhaustive
 [`manual_ok_or`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_ok_or
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 53764bb7390..bde9c630c6c 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -745,6 +745,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &methods::ITER_NTH,
         &methods::ITER_NTH_ZERO,
         &methods::ITER_SKIP_NEXT,
+        &methods::MANUAL_FILTER_MAP,
         &methods::MANUAL_SATURATING_ARITHMETIC,
         &methods::MAP_COLLECT_RESULT_UNIT,
         &methods::MAP_FLATTEN,
@@ -1526,6 +1527,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&methods::ITER_NTH),
         LintId::of(&methods::ITER_NTH_ZERO),
         LintId::of(&methods::ITER_SKIP_NEXT),
+        LintId::of(&methods::MANUAL_FILTER_MAP),
         LintId::of(&methods::MANUAL_SATURATING_ARITHMETIC),
         LintId::of(&methods::MAP_COLLECT_RESULT_UNIT),
         LintId::of(&methods::NEW_RET_NO_SELF),
@@ -1823,6 +1825,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&methods::FILTER_NEXT),
         LintId::of(&methods::FLAT_MAP_IDENTITY),
         LintId::of(&methods::INSPECT_FOR_EACH),
+        LintId::of(&methods::MANUAL_FILTER_MAP),
         LintId::of(&methods::OPTION_AS_REF_DEREF),
         LintId::of(&methods::SEARCH_IS_SOME),
         LintId::of(&methods::SKIP_WHILE_NEXT),
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index c8b69f4fbae..518d2e67ad1 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -15,7 +15,8 @@ use if_chain::if_chain;
 use rustc_ast::ast;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
-use rustc_hir::{TraitItem, TraitItemKind};
+use rustc_hir::def::Res;
+use rustc_hir::{Expr, ExprKind, PatKind, QPath, TraitItem, TraitItemKind, UnOp};
 use rustc_lint::{LateContext, LateLintPass, Lint, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::{self, TraitRef, Ty, TyS};
@@ -450,6 +451,32 @@ declare_clippy_lint! {
     "using combinations of `filter`, `map`, `filter_map` and `flat_map` which can usually be written as a single method call"
 }
 
+declare_clippy_lint! {
+    /// **What it does:** Checks for usage of `_.filter(_).map(_)` that can be written more simply
+    /// as `filter_map(_)`.
+    ///
+    /// **Why is this bad?** Redundant code in the `filter` and `map` operations is poor style and
+    /// less performant.
+    ///
+    /// **Known problems:** None.
+    ///
+     /// **Example:**
+    /// Bad:
+    /// ```rust
+    /// (0_i32..10)
+    ///     .filter(|n| n.checked_add(1).is_some())
+    ///     .map(|n| n.checked_add(1).unwrap());
+    /// ```
+    ///
+    /// Good:
+    /// ```rust
+    /// (0_i32..10).filter_map(|n| n.checked_add(1));
+    /// ```
+    pub MANUAL_FILTER_MAP,
+    complexity,
+    "using `_.filter(_).map(_)` in a way that can be written more simply as `filter_map(_)`"
+}
+
 declare_clippy_lint! {
     /// **What it does:** Checks for usage of `_.filter_map(_).next()`.
     ///
@@ -1473,6 +1500,7 @@ impl_lint_pass!(Methods => [
     FILTER_NEXT,
     SKIP_WHILE_NEXT,
     FILTER_MAP,
+    MANUAL_FILTER_MAP,
     FILTER_MAP_NEXT,
     FLAT_MAP_IDENTITY,
     FIND_MAP,
@@ -1540,7 +1568,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             ["next", "filter"] => lint_filter_next(cx, expr, arg_lists[1]),
             ["next", "skip_while"] => lint_skip_while_next(cx, expr, arg_lists[1]),
             ["next", "iter"] => lint_iter_next(cx, expr, arg_lists[1]),
-            ["map", "filter"] => lint_filter_map(cx, expr, arg_lists[1], arg_lists[0]),
+            ["map", "filter"] => lint_filter_map(cx, expr),
             ["map", "filter_map"] => lint_filter_map_map(cx, expr, arg_lists[1], arg_lists[0]),
             ["next", "filter_map"] => lint_filter_map_next(cx, expr, arg_lists[1], self.msrv.as_ref()),
             ["map", "find"] => lint_find_map(cx, expr, arg_lists[1], arg_lists[0]),
@@ -2989,17 +3017,72 @@ fn lint_skip_while_next<'tcx>(
 }
 
 /// lint use of `filter().map()` for `Iterators`
-fn lint_filter_map<'tcx>(
-    cx: &LateContext<'tcx>,
-    expr: &'tcx hir::Expr<'_>,
-    _filter_args: &'tcx [hir::Expr<'_>],
-    _map_args: &'tcx [hir::Expr<'_>],
-) {
-    // lint if caller of `.filter().map()` is an Iterator
-    if match_trait_method(cx, expr, &paths::ITERATOR) {
-        let msg = "called `filter(..).map(..)` on an `Iterator`";
-        let hint = "this is more succinctly expressed by calling `.filter_map(..)` instead";
-        span_lint_and_help(cx, FILTER_MAP, expr.span, msg, None, hint);
+fn lint_filter_map<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
+    if_chain! {
+        if let ExprKind::MethodCall(_, _, [map_recv, map_arg], map_span) = expr.kind;
+        if let ExprKind::MethodCall(_, _, [_, filter_arg], filter_span) = map_recv.kind;
+        if match_trait_method(cx, expr, &paths::ITERATOR);
+
+        // filter(|x| ...is_some())...
+        if let ExprKind::Closure(_, _, filter_body_id, ..) = filter_arg.kind;
+        let filter_body = cx.tcx.hir().body(filter_body_id);
+        if let [filter_param] = filter_body.params;
+        // optional ref pattern: `filter(|&x| ..)`
+        let (filter_pat, is_filter_param_ref) = if let PatKind::Ref(ref_pat, _) = filter_param.pat.kind {
+            (ref_pat, true)
+        } else {
+            (filter_param.pat, false)
+        };
+        // closure ends with is_some() or is_ok()
+        if let PatKind::Binding(_, filter_param_id, _, None) = filter_pat.kind;
+        if let ExprKind::MethodCall(path, _, [filter_arg], _) = filter_body.value.kind;
+        if let Some(opt_ty) = cx.typeck_results().expr_ty(filter_arg).ty_adt_def();
+        if let Some(is_result) = if cx.tcx.is_diagnostic_item(sym::option_type, opt_ty.did) {
+            Some(false)
+        } else if cx.tcx.is_diagnostic_item(sym::result_type, opt_ty.did) {
+            Some(true)
+        } else {
+            None
+        };
+        if path.ident.name.as_str() == if is_result { "is_ok" } else { "is_some" };
+
+        // ...map(|x| ...unwrap())
+        if let ExprKind::Closure(_, _, map_body_id, ..) = map_arg.kind;
+        let map_body = cx.tcx.hir().body(map_body_id);
+        if let [map_param] = map_body.params;
+        if let PatKind::Binding(_, map_param_id, map_param_ident, None) = map_param.pat.kind;
+        // closure ends with expect() or unwrap()
+        if let ExprKind::MethodCall(seg, _, [map_arg, ..], _) = map_body.value.kind;
+        if matches!(seg.ident.name, sym::expect | sym::unwrap | sym::unwrap_or);
+
+        let eq_fallback = |a: &Expr<'_>, b: &Expr<'_>| {
+            // in `filter(|x| ..)`, replace `*x` with `x`
+            let a_path = if_chain! {
+                if !is_filter_param_ref;
+                if let ExprKind::Unary(UnOp::UnDeref, expr_path) = a.kind;
+                then { expr_path } else { a }
+            };
+            // let the filter closure arg and the map closure arg be equal
+            if_chain! {
+                if let ExprKind::Path(QPath::Resolved(None, a_path)) = a_path.kind;
+                if let ExprKind::Path(QPath::Resolved(None, b_path)) = b.kind;
+                if a_path.res == Res::Local(filter_param_id);
+                if b_path.res == Res::Local(map_param_id);
+                if TyS::same_type(cx.typeck_results().expr_ty_adjusted(a), cx.typeck_results().expr_ty_adjusted(b));
+                then {
+                    return true;
+                }
+            }
+            false
+        };
+        if SpanlessEq::new(cx).expr_fallback(eq_fallback).eq_expr(filter_arg, map_arg);
+        then {
+            let span = filter_span.to(map_span);
+            let msg = "`filter(..).map(..)` can be simplified as `filter_map(..)`";
+            let to_opt = if is_result { ".ok()" } else { "" };
+            let sugg = format!("filter_map(|{}| {}{})", map_param_ident, snippet(cx, map_arg.span, ".."), to_opt);
+            span_lint_and_sugg(cx, MANUAL_FILTER_MAP, span, msg, "try", sugg, Applicability::MachineApplicable);
+        }
     }
 }
 
diff --git a/tests/ui/filter_methods.stderr b/tests/ui/filter_methods.stderr
index 11922681379..c7b4f28be3a 100644
--- a/tests/ui/filter_methods.stderr
+++ b/tests/ui/filter_methods.stderr
@@ -1,12 +1,3 @@
-error: called `filter(..).map(..)` on an `Iterator`
-  --> $DIR/filter_methods.rs:6:21
-   |
-LL |     let _: Vec<_> = vec![5; 6].into_iter().filter(|&x| x == 0).map(|x| x * 2).collect();
-   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: `-D clippy::filter-map` implied by `-D warnings`
-   = help: this is more succinctly expressed by calling `.filter_map(..)` instead
-
 error: called `filter(..).flat_map(..)` on an `Iterator`
   --> $DIR/filter_methods.rs:8:21
    |
@@ -17,6 +8,7 @@ LL | |         .filter(|&x| x == 0)
 LL | |         .flat_map(|x| x.checked_mul(2))
    | |_______________________________________^
    |
+   = note: `-D clippy::filter-map` implied by `-D warnings`
    = help: this is more succinctly expressed by calling `.flat_map(..)` and filtering by returning `iter::empty()`
 
 error: called `filter_map(..).flat_map(..)` on an `Iterator`
@@ -43,5 +35,5 @@ LL | |         .map(|x| x.checked_mul(2))
    |
    = help: this is more succinctly expressed by only calling `.filter_map(..)` instead
 
-error: aborting due to 4 previous errors
+error: aborting due to 3 previous errors
 
diff --git a/tests/ui/manual_filter_map.fixed b/tests/ui/manual_filter_map.fixed
new file mode 100644
index 00000000000..fc8f58f8ea5
--- /dev/null
+++ b/tests/ui/manual_filter_map.fixed
@@ -0,0 +1,37 @@
+// run-rustfix
+#![allow(dead_code)]
+#![warn(clippy::manual_filter_map)]
+#![allow(clippy::redundant_closure)] // FIXME suggestion may have redundant closure
+
+fn main() {
+    // is_some(), unwrap()
+    let _ = (0..).filter_map(|a| to_opt(a));
+
+    // ref pattern, expect()
+    let _ = (0..).filter_map(|a| to_opt(a));
+
+    // is_ok(), unwrap_or()
+    let _ = (0..).filter_map(|a| to_res(a).ok());
+}
+
+fn no_lint() {
+    // no shared code
+    let _ = (0..).filter(|n| *n > 1).map(|n| n + 1);
+
+    // very close but different since filter() provides a reference
+    let _ = (0..).filter(|n| to_opt(n).is_some()).map(|a| to_opt(a).unwrap());
+
+    // similar but different
+    let _ = (0..).filter(|n| to_opt(n).is_some()).map(|n| to_res(n).unwrap());
+    let _ = (0..)
+        .filter(|n| to_opt(n).map(|n| n + 1).is_some())
+        .map(|a| to_opt(a).unwrap());
+}
+
+fn to_opt<T>(_: T) -> Option<T> {
+    unimplemented!()
+}
+
+fn to_res<T>(_: T) -> Result<T, ()> {
+    unimplemented!()
+}
diff --git a/tests/ui/manual_filter_map.rs b/tests/ui/manual_filter_map.rs
new file mode 100644
index 00000000000..3af4bbee3bf
--- /dev/null
+++ b/tests/ui/manual_filter_map.rs
@@ -0,0 +1,37 @@
+// run-rustfix
+#![allow(dead_code)]
+#![warn(clippy::manual_filter_map)]
+#![allow(clippy::redundant_closure)] // FIXME suggestion may have redundant closure
+
+fn main() {
+    // is_some(), unwrap()
+    let _ = (0..).filter(|n| to_opt(*n).is_some()).map(|a| to_opt(a).unwrap());
+
+    // ref pattern, expect()
+    let _ = (0..).filter(|&n| to_opt(n).is_some()).map(|a| to_opt(a).expect("hi"));
+
+    // is_ok(), unwrap_or()
+    let _ = (0..).filter(|&n| to_res(n).is_ok()).map(|a| to_res(a).unwrap_or(1));
+}
+
+fn no_lint() {
+    // no shared code
+    let _ = (0..).filter(|n| *n > 1).map(|n| n + 1);
+
+    // very close but different since filter() provides a reference
+    let _ = (0..).filter(|n| to_opt(n).is_some()).map(|a| to_opt(a).unwrap());
+
+    // similar but different
+    let _ = (0..).filter(|n| to_opt(n).is_some()).map(|n| to_res(n).unwrap());
+    let _ = (0..)
+        .filter(|n| to_opt(n).map(|n| n + 1).is_some())
+        .map(|a| to_opt(a).unwrap());
+}
+
+fn to_opt<T>(_: T) -> Option<T> {
+    unimplemented!()
+}
+
+fn to_res<T>(_: T) -> Result<T, ()> {
+    unimplemented!()
+}
diff --git a/tests/ui/manual_filter_map.stderr b/tests/ui/manual_filter_map.stderr
new file mode 100644
index 00000000000..4d4e2d5c12f
--- /dev/null
+++ b/tests/ui/manual_filter_map.stderr
@@ -0,0 +1,22 @@
+error: `filter(..).map(..)` can be simplified as `filter_map(..)`
+  --> $DIR/manual_filter_map.rs:8:19
+   |
+LL |     let _ = (0..).filter(|n| to_opt(*n).is_some()).map(|a| to_opt(a).unwrap());
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `filter_map(|a| to_opt(a))`
+   |
+   = note: `-D clippy::manual-filter-map` implied by `-D warnings`
+
+error: `filter(..).map(..)` can be simplified as `filter_map(..)`
+  --> $DIR/manual_filter_map.rs:11:19
+   |
+LL |     let _ = (0..).filter(|&n| to_opt(n).is_some()).map(|a| to_opt(a).expect("hi"));
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `filter_map(|a| to_opt(a))`
+
+error: `filter(..).map(..)` can be simplified as `filter_map(..)`
+  --> $DIR/manual_filter_map.rs:14:19
+   |
+LL |     let _ = (0..).filter(|&n| to_res(n).is_ok()).map(|a| to_res(a).unwrap_or(1));
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `filter_map(|a| to_res(a).ok())`
+
+error: aborting due to 3 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From a752d31e0a8cd8c7d8549daf421a8b791d1325a4 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Thu, 14 Jan 2021 16:36:36 -0600
Subject: Replace find_map with manual_find_map

---
 CHANGELOG.md                    |  1 +
 clippy_lints/src/lib.rs         |  3 ++
 clippy_lints/src/methods/mod.rs | 64 ++++++++++++++++++++++++++---------------
 tests/ui/find_map.stderr        | 26 -----------------
 tests/ui/manual_find_map.fixed  | 37 ++++++++++++++++++++++++
 tests/ui/manual_find_map.rs     | 37 ++++++++++++++++++++++++
 tests/ui/manual_find_map.stderr | 22 ++++++++++++++
 7 files changed, 141 insertions(+), 49 deletions(-)
 delete mode 100644 tests/ui/find_map.stderr
 create mode 100644 tests/ui/manual_find_map.fixed
 create mode 100644 tests/ui/manual_find_map.rs
 create mode 100644 tests/ui/manual_find_map.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 8feb1a148af..7f2de888d35 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2036,6 +2036,7 @@ Released 2018-09-13
 [`main_recursion`]: https://rust-lang.github.io/rust-clippy/master/index.html#main_recursion
 [`manual_async_fn`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_async_fn
 [`manual_filter_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_filter_map
+[`manual_find_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_find_map
 [`manual_memcpy`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_memcpy
 [`manual_non_exhaustive`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_non_exhaustive
 [`manual_ok_or`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_ok_or
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index bde9c630c6c..b22ddfacf86 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -746,6 +746,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &methods::ITER_NTH_ZERO,
         &methods::ITER_SKIP_NEXT,
         &methods::MANUAL_FILTER_MAP,
+        &methods::MANUAL_FIND_MAP,
         &methods::MANUAL_SATURATING_ARITHMETIC,
         &methods::MAP_COLLECT_RESULT_UNIT,
         &methods::MAP_FLATTEN,
@@ -1528,6 +1529,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&methods::ITER_NTH_ZERO),
         LintId::of(&methods::ITER_SKIP_NEXT),
         LintId::of(&methods::MANUAL_FILTER_MAP),
+        LintId::of(&methods::MANUAL_FIND_MAP),
         LintId::of(&methods::MANUAL_SATURATING_ARITHMETIC),
         LintId::of(&methods::MAP_COLLECT_RESULT_UNIT),
         LintId::of(&methods::NEW_RET_NO_SELF),
@@ -1826,6 +1828,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&methods::FLAT_MAP_IDENTITY),
         LintId::of(&methods::INSPECT_FOR_EACH),
         LintId::of(&methods::MANUAL_FILTER_MAP),
+        LintId::of(&methods::MANUAL_FIND_MAP),
         LintId::of(&methods::OPTION_AS_REF_DEREF),
         LintId::of(&methods::SEARCH_IS_SOME),
         LintId::of(&methods::SKIP_WHILE_NEXT),
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 518d2e67ad1..9d078588746 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -477,6 +477,32 @@ declare_clippy_lint! {
     "using `_.filter(_).map(_)` in a way that can be written more simply as `filter_map(_)`"
 }
 
+declare_clippy_lint! {
+    /// **What it does:** Checks for usage of `_.find(_).map(_)` that can be written more simply
+    /// as `find_map(_)`.
+    ///
+    /// **Why is this bad?** Redundant code in the `find` and `map` operations is poor style and
+    /// less performant.
+    ///
+    /// **Known problems:** None.
+    ///
+     /// **Example:**
+    /// Bad:
+    /// ```rust
+    /// (0_i32..10)
+    ///     .find(|n| n.checked_add(1).is_some())
+    ///     .map(|n| n.checked_add(1).unwrap());
+    /// ```
+    ///
+    /// Good:
+    /// ```rust
+    /// (0_i32..10).find_map(|n| n.checked_add(1));
+    /// ```
+    pub MANUAL_FIND_MAP,
+    complexity,
+    "using `_.find(_).map(_)` in a way that can be written more simply as `find_map(_)`"
+}
+
 declare_clippy_lint! {
     /// **What it does:** Checks for usage of `_.filter_map(_).next()`.
     ///
@@ -1501,6 +1527,7 @@ impl_lint_pass!(Methods => [
     SKIP_WHILE_NEXT,
     FILTER_MAP,
     MANUAL_FILTER_MAP,
+    MANUAL_FIND_MAP,
     FILTER_MAP_NEXT,
     FLAT_MAP_IDENTITY,
     FIND_MAP,
@@ -1568,10 +1595,10 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             ["next", "filter"] => lint_filter_next(cx, expr, arg_lists[1]),
             ["next", "skip_while"] => lint_skip_while_next(cx, expr, arg_lists[1]),
             ["next", "iter"] => lint_iter_next(cx, expr, arg_lists[1]),
-            ["map", "filter"] => lint_filter_map(cx, expr),
+            ["map", "filter"] => lint_filter_map(cx, expr, false),
             ["map", "filter_map"] => lint_filter_map_map(cx, expr, arg_lists[1], arg_lists[0]),
             ["next", "filter_map"] => lint_filter_map_next(cx, expr, arg_lists[1], self.msrv.as_ref()),
-            ["map", "find"] => lint_find_map(cx, expr, arg_lists[1], arg_lists[0]),
+            ["map", "find"] => lint_filter_map(cx, expr, true),
             ["flat_map", "filter"] => lint_filter_flat_map(cx, expr, arg_lists[1], arg_lists[0]),
             ["flat_map", "filter_map"] => lint_filter_map_flat_map(cx, expr, arg_lists[1], arg_lists[0]),
             ["flat_map", ..] => lint_flat_map_identity(cx, expr, arg_lists[0], method_spans[0]),
@@ -3016,12 +3043,12 @@ fn lint_skip_while_next<'tcx>(
     }
 }
 
-/// lint use of `filter().map()` for `Iterators`
-fn lint_filter_map<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
+/// lint use of `filter().map()` or `find().map()` for `Iterators`
+fn lint_filter_map<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, is_find: bool) {
     if_chain! {
         if let ExprKind::MethodCall(_, _, [map_recv, map_arg], map_span) = expr.kind;
         if let ExprKind::MethodCall(_, _, [_, filter_arg], filter_span) = map_recv.kind;
-        if match_trait_method(cx, expr, &paths::ITERATOR);
+        if match_trait_method(cx, map_recv, &paths::ITERATOR);
 
         // filter(|x| ...is_some())...
         if let ExprKind::Closure(_, _, filter_body_id, ..) = filter_arg.kind;
@@ -3078,10 +3105,16 @@ fn lint_filter_map<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
         if SpanlessEq::new(cx).expr_fallback(eq_fallback).eq_expr(filter_arg, map_arg);
         then {
             let span = filter_span.to(map_span);
-            let msg = "`filter(..).map(..)` can be simplified as `filter_map(..)`";
+            let (filter_name, lint) = if is_find {
+                ("find", MANUAL_FIND_MAP)
+            } else {
+                ("filter", MANUAL_FILTER_MAP)
+            };
+            let msg = format!("`{}(..).map(..)` can be simplified as `{0}_map(..)`", filter_name);
             let to_opt = if is_result { ".ok()" } else { "" };
-            let sugg = format!("filter_map(|{}| {}{})", map_param_ident, snippet(cx, map_arg.span, ".."), to_opt);
-            span_lint_and_sugg(cx, MANUAL_FILTER_MAP, span, msg, "try", sugg, Applicability::MachineApplicable);
+            let sugg = format!("{}_map(|{}| {}{})", filter_name, map_param_ident,
+                snippet(cx, map_arg.span, ".."), to_opt);
+            span_lint_and_sugg(cx, lint, span, &msg, "try", sugg, Applicability::MachineApplicable);
         }
     }
 }
@@ -3120,21 +3153,6 @@ fn lint_filter_map_next<'tcx>(
     }
 }
 
-/// lint use of `find().map()` for `Iterators`
-fn lint_find_map<'tcx>(
-    cx: &LateContext<'tcx>,
-    expr: &'tcx hir::Expr<'_>,
-    _find_args: &'tcx [hir::Expr<'_>],
-    map_args: &'tcx [hir::Expr<'_>],
-) {
-    // lint if caller of `.filter().map()` is an Iterator
-    if match_trait_method(cx, &map_args[0], &paths::ITERATOR) {
-        let msg = "called `find(..).map(..)` on an `Iterator`";
-        let hint = "this is more succinctly expressed by calling `.find_map(..)` instead";
-        span_lint_and_help(cx, FIND_MAP, expr.span, msg, None, hint);
-    }
-}
-
 /// lint use of `filter_map().map()` for `Iterators`
 fn lint_filter_map_map<'tcx>(
     cx: &LateContext<'tcx>,
diff --git a/tests/ui/find_map.stderr b/tests/ui/find_map.stderr
deleted file mode 100644
index aea3cc62afc..00000000000
--- a/tests/ui/find_map.stderr
+++ /dev/null
@@ -1,26 +0,0 @@
-error: called `find(..).map(..)` on an `Iterator`
-  --> $DIR/find_map.rs:20:26
-   |
-LL |     let _: Option<i32> = a.iter().find(|s| s.parse::<i32>().is_ok()).map(|s| s.parse().unwrap());
-   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: `-D clippy::find-map` implied by `-D warnings`
-   = help: this is more succinctly expressed by calling `.find_map(..)` instead
-
-error: called `find(..).map(..)` on an `Iterator`
-  --> $DIR/find_map.rs:23:29
-   |
-LL |       let _: Option<Flavor> = desserts_of_the_week
-   |  _____________________________^
-LL | |         .iter()
-LL | |         .find(|dessert| match *dessert {
-LL | |             Dessert::Cake(_) => true,
-...  |
-LL | |             _ => unreachable!(),
-LL | |         });
-   | |__________^
-   |
-   = help: this is more succinctly expressed by calling `.find_map(..)` instead
-
-error: aborting due to 2 previous errors
-
diff --git a/tests/ui/manual_find_map.fixed b/tests/ui/manual_find_map.fixed
new file mode 100644
index 00000000000..95e97c4fd1f
--- /dev/null
+++ b/tests/ui/manual_find_map.fixed
@@ -0,0 +1,37 @@
+// run-rustfix
+#![allow(dead_code)]
+#![warn(clippy::manual_find_map)]
+#![allow(clippy::redundant_closure)] // FIXME suggestion may have redundant closure
+
+fn main() {
+    // is_some(), unwrap()
+    let _ = (0..).find_map(|a| to_opt(a));
+
+    // ref pattern, expect()
+    let _ = (0..).find_map(|a| to_opt(a));
+
+    // is_ok(), unwrap_or()
+    let _ = (0..).find_map(|a| to_res(a).ok());
+}
+
+fn no_lint() {
+    // no shared code
+    let _ = (0..).filter(|n| *n > 1).map(|n| n + 1);
+
+    // very close but different since filter() provides a reference
+    let _ = (0..).find(|n| to_opt(n).is_some()).map(|a| to_opt(a).unwrap());
+
+    // similar but different
+    let _ = (0..).find(|n| to_opt(n).is_some()).map(|n| to_res(n).unwrap());
+    let _ = (0..)
+        .find(|n| to_opt(n).map(|n| n + 1).is_some())
+        .map(|a| to_opt(a).unwrap());
+}
+
+fn to_opt<T>(_: T) -> Option<T> {
+    unimplemented!()
+}
+
+fn to_res<T>(_: T) -> Result<T, ()> {
+    unimplemented!()
+}
diff --git a/tests/ui/manual_find_map.rs b/tests/ui/manual_find_map.rs
new file mode 100644
index 00000000000..cd3c82e3b25
--- /dev/null
+++ b/tests/ui/manual_find_map.rs
@@ -0,0 +1,37 @@
+// run-rustfix
+#![allow(dead_code)]
+#![warn(clippy::manual_find_map)]
+#![allow(clippy::redundant_closure)] // FIXME suggestion may have redundant closure
+
+fn main() {
+    // is_some(), unwrap()
+    let _ = (0..).find(|n| to_opt(*n).is_some()).map(|a| to_opt(a).unwrap());
+
+    // ref pattern, expect()
+    let _ = (0..).find(|&n| to_opt(n).is_some()).map(|a| to_opt(a).expect("hi"));
+
+    // is_ok(), unwrap_or()
+    let _ = (0..).find(|&n| to_res(n).is_ok()).map(|a| to_res(a).unwrap_or(1));
+}
+
+fn no_lint() {
+    // no shared code
+    let _ = (0..).filter(|n| *n > 1).map(|n| n + 1);
+
+    // very close but different since filter() provides a reference
+    let _ = (0..).find(|n| to_opt(n).is_some()).map(|a| to_opt(a).unwrap());
+
+    // similar but different
+    let _ = (0..).find(|n| to_opt(n).is_some()).map(|n| to_res(n).unwrap());
+    let _ = (0..)
+        .find(|n| to_opt(n).map(|n| n + 1).is_some())
+        .map(|a| to_opt(a).unwrap());
+}
+
+fn to_opt<T>(_: T) -> Option<T> {
+    unimplemented!()
+}
+
+fn to_res<T>(_: T) -> Result<T, ()> {
+    unimplemented!()
+}
diff --git a/tests/ui/manual_find_map.stderr b/tests/ui/manual_find_map.stderr
new file mode 100644
index 00000000000..9e7f798df45
--- /dev/null
+++ b/tests/ui/manual_find_map.stderr
@@ -0,0 +1,22 @@
+error: `find(..).map(..)` can be simplified as `find_map(..)`
+  --> $DIR/manual_find_map.rs:8:19
+   |
+LL |     let _ = (0..).find(|n| to_opt(*n).is_some()).map(|a| to_opt(a).unwrap());
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|a| to_opt(a))`
+   |
+   = note: `-D clippy::manual-find-map` implied by `-D warnings`
+
+error: `find(..).map(..)` can be simplified as `find_map(..)`
+  --> $DIR/manual_find_map.rs:11:19
+   |
+LL |     let _ = (0..).find(|&n| to_opt(n).is_some()).map(|a| to_opt(a).expect("hi"));
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|a| to_opt(a))`
+
+error: `find(..).map(..)` can be simplified as `find_map(..)`
+  --> $DIR/manual_find_map.rs:14:19
+   |
+LL |     let _ = (0..).find(|&n| to_res(n).is_ok()).map(|a| to_res(a).unwrap_or(1));
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|a| to_res(a).ok())`
+
+error: aborting due to 3 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From a22915bf4893e16d64100365d902e52211374a0c Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Mon, 14 Dec 2020 14:03:11 -0600
Subject: Remove unneeded allow's

---
 clippy_dev/src/ra_setup.rs | 2 --
 clippy_lints/src/loops.rs  | 1 -
 2 files changed, 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_dev/src/ra_setup.rs b/clippy_dev/src/ra_setup.rs
index 5f5048e79e7..a8a6a2cb1bd 100644
--- a/clippy_dev/src/ra_setup.rs
+++ b/clippy_dev/src/ra_setup.rs
@@ -1,5 +1,3 @@
-#![allow(clippy::filter_map)]
-
 use std::fs;
 use std::fs::File;
 use std::io::prelude::*;
diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 1c5ab2874b0..c7e1088e353 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -1069,7 +1069,6 @@ fn get_assignments<'a: 'c, 'tcx: 'c, 'c>(
 ) -> impl Iterator<Item = Option<(&'tcx Expr<'tcx>, &'tcx Expr<'tcx>)>> + 'c {
     // As the `filter` and `map` below do different things, I think putting together
     // just increases complexity. (cc #3188 and #4193)
-    #[allow(clippy::filter_map)]
     stmts
         .iter()
         .filter_map(move |stmt| match stmt.kind {
-- 
cgit 1.4.1-3-g733a5


From 82bab19a0105ff86176b79a5eae7a9ea7d300cb9 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Thu, 14 Jan 2021 16:47:22 -0600
Subject: Deprecate find_map lint

---
 clippy_lints/src/deprecated_lints.rs |  5 +++++
 clippy_lints/src/lib.rs              |  6 ++++--
 clippy_lints/src/methods/mod.rs      | 23 -----------------------
 3 files changed, 9 insertions(+), 25 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/deprecated_lints.rs b/clippy_lints/src/deprecated_lints.rs
index bec0c9f93a0..ea386237f20 100644
--- a/clippy_lints/src/deprecated_lints.rs
+++ b/clippy_lints/src/deprecated_lints.rs
@@ -166,3 +166,8 @@ declare_deprecated_lint! {
     pub PANIC_PARAMS,
     "this lint has been uplifted to rustc and is now called `panic_fmt`"
 }
+
+declare_deprecated_lint! {
+    pub FIND_MAP,
+    "this lint is replaced by `manual_find_map`, a more specific lint"
+}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index b22ddfacf86..7097812e088 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -505,6 +505,10 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         "clippy::panic_params",
         "this lint has been uplifted to rustc and is now called `panic_fmt`",
     );
+    store.register_removed(
+        "clippy::find_map",
+        "this lint is replaced by `manual_find_map`, a more specific lint",
+    );
     // end deprecated lints, do not remove this comment, it’s used in `update_lints`
 
     // begin register lints, do not remove this comment, it’s used in `update_lints`
@@ -732,7 +736,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &methods::FILTER_MAP,
         &methods::FILTER_MAP_NEXT,
         &methods::FILTER_NEXT,
-        &methods::FIND_MAP,
         &methods::FLAT_MAP_IDENTITY,
         &methods::FROM_ITER_INSTEAD_OF_COLLECT,
         &methods::GET_UNWRAP,
@@ -1333,7 +1336,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&matches::SINGLE_MATCH_ELSE),
         LintId::of(&methods::FILTER_MAP),
         LintId::of(&methods::FILTER_MAP_NEXT),
-        LintId::of(&methods::FIND_MAP),
         LintId::of(&methods::INEFFICIENT_TO_STRING),
         LintId::of(&methods::MAP_FLATTEN),
         LintId::of(&methods::MAP_UNWRAP_OR),
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 9d078588746..7a459a440ca 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -547,28 +547,6 @@ declare_clippy_lint! {
     "call to `flat_map` where `flatten` is sufficient"
 }
 
-declare_clippy_lint! {
-    /// **What it does:** Checks for usage of `_.find(_).map(_)`.
-    ///
-    /// **Why is this bad?** Readability, this can be written more concisely as
-    /// `_.find_map(_)`.
-    ///
-    /// **Known problems:** Often requires a condition + Option/Iterator creation
-    /// inside the closure.
-    ///
-    /// **Example:**
-    /// ```rust
-    ///  (0..3).find(|x| *x == 2).map(|x| x * 2);
-    /// ```
-    /// Can be written as
-    /// ```rust
-    ///  (0..3).find_map(|x| if x == 2 { Some(x * 2) } else { None });
-    /// ```
-    pub FIND_MAP,
-    pedantic,
-    "using a combination of `find` and `map` can usually be written as a single method call"
-}
-
 declare_clippy_lint! {
     /// **What it does:** Checks for an iterator or string search (such as `find()`,
     /// `position()`, or `rposition()`) followed by a call to `is_some()`.
@@ -1530,7 +1508,6 @@ impl_lint_pass!(Methods => [
     MANUAL_FIND_MAP,
     FILTER_MAP_NEXT,
     FLAT_MAP_IDENTITY,
-    FIND_MAP,
     MAP_FLATTEN,
     ITERATOR_STEP_BY_ZERO,
     ITER_NEXT_SLICE,
-- 
cgit 1.4.1-3-g733a5


From 23662d1353a52be7c35bb3905337f2aadf7c504a Mon Sep 17 00:00:00 2001
From: Takayuki Nakata <f.seasons017@gmail.com>
Date: Fri, 22 Jan 2021 22:51:06 +0900
Subject: Improve the example in `ref_in_deref`

---
 clippy_lints/src/reference.rs | 6 ++++++
 1 file changed, 6 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/reference.rs b/clippy_lints/src/reference.rs
index 2dfb947b5eb..e1450466a7c 100644
--- a/clippy_lints/src/reference.rs
+++ b/clippy_lints/src/reference.rs
@@ -111,6 +111,12 @@ declare_clippy_lint! {
     /// let point = Point(30, 20);
     /// let x = (&point).0;
     /// ```
+    /// Use instead:
+    /// ```rust
+    /// # struct Point(u32, u32);
+    /// # let point = Point(30, 20);
+    /// let x = point.0;
+    /// ```
     pub REF_IN_DEREF,
     complexity,
     "Use of reference in auto dereference expression."
-- 
cgit 1.4.1-3-g733a5


From 8cb7e85006853e99e6ba2bf378c801fb53eee8fa Mon Sep 17 00:00:00 2001
From: Manish Goregaokar <manishsmail@gmail.com>
Date: Thu, 21 Jan 2021 13:41:57 -0800
Subject: Add exhaustive_structs lint

---
 CHANGELOG.md                         |  1 +
 clippy_lints/src/exhaustive_items.rs | 54 ++++++++++++++++++----
 clippy_lints/src/lib.rs              |  2 +
 tests/ui/exhaustive_items.fixed      | 86 ++++++++++++++++++++++++------------
 tests/ui/exhaustive_items.rs         | 85 +++++++++++++++++++++++------------
 tests/ui/exhaustive_items.stderr     | 52 +++++++++++++++-------
 6 files changed, 199 insertions(+), 81 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 4cf2125ea2f..ccc7eb7e881 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1939,6 +1939,7 @@ Released 2018-09-13
 [`eval_order_dependence`]: https://rust-lang.github.io/rust-clippy/master/index.html#eval_order_dependence
 [`excessive_precision`]: https://rust-lang.github.io/rust-clippy/master/index.html#excessive_precision
 [`exhaustive_enums`]: https://rust-lang.github.io/rust-clippy/master/index.html#exhaustive_enums
+[`exhaustive_structs`]: https://rust-lang.github.io/rust-clippy/master/index.html#exhaustive_structs
 [`exit`]: https://rust-lang.github.io/rust-clippy/master/index.html#exit
 [`expect_fun_call`]: https://rust-lang.github.io/rust-clippy/master/index.html#expect_fun_call
 [`expect_used`]: https://rust-lang.github.io/rust-clippy/master/index.html#expect_used
diff --git a/clippy_lints/src/exhaustive_items.rs b/clippy_lints/src/exhaustive_items.rs
index 0fa6c4b589f..d604ad0004f 100644
--- a/clippy_lints/src/exhaustive_items.rs
+++ b/clippy_lints/src/exhaustive_items.rs
@@ -1,7 +1,7 @@
 use crate::utils::{snippet_opt, span_lint_and_help, span_lint_and_sugg};
 use if_chain::if_chain;
-use rustc_hir::{Item, ItemKind};
 use rustc_errors::Applicability;
+use rustc_hir::{Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::sym;
@@ -10,7 +10,8 @@ declare_clippy_lint! {
     /// **What it does:** Warns on any exported `enum`s that are not tagged `#[non_exhaustive]`
     ///
     /// **Why is this bad?** Exhaustive enums are typically fine, but a project which does
-    /// not wish to make a stability commitment around enums may wish to disable them by default.
+    /// not wish to make a stability commitment around exported enums may wish to
+    /// disable them by default.
     ///
     /// **Known problems:** None.
     ///
@@ -28,25 +29,62 @@ declare_clippy_lint! {
     /// enum Foo {
     ///     Bar,
     ///     Baz
-    /// }    /// ```
+    /// }
+    /// ```
     pub EXHAUSTIVE_ENUMS,
     restriction,
-    "default lint description"
+    "detects exported enums that have not been marked #[non_exhaustive]"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Warns on any exported `structs`s that are not tagged `#[non_exhaustive]`
+    ///
+    /// **Why is this bad?** Exhaustive structs are typically fine, but a project which does
+    /// not wish to make a stability commitment around exported structs may wish to
+    /// disable them by default.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// struct Foo {
+    ///     bar: u8,
+    ///     baz: String,
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// #[non_exhaustive]
+    /// struct Foo {
+    ///     bar: u8,
+    ///     baz: String,
+    /// }
+    /// ```
+    pub EXHAUSTIVE_STRUCTS,
+    restriction,
+    "detects exported structs that have not been marked #[non_exhaustive]"
 }
 
-declare_lint_pass!(ExhaustiveItems => [EXHAUSTIVE_ENUMS]);
+declare_lint_pass!(ExhaustiveItems => [EXHAUSTIVE_ENUMS, EXHAUSTIVE_STRUCTS]);
 
 impl LateLintPass<'_> for ExhaustiveItems {
     fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
         if_chain! {
-            if let ItemKind::Enum(..) = item.kind;
+            if let ItemKind::Enum(..) | ItemKind::Struct(..) = item.kind;
             if cx.access_levels.is_exported(item.hir_id);
             if !item.attrs.iter().any(|a| a.has_name(sym::non_exhaustive));
             then {
+                let lint = if let ItemKind::Enum(..) = item.kind {
+                    EXHAUSTIVE_ENUMS
+                } else {
+                    EXHAUSTIVE_STRUCTS
+                };
+
                 if let Some(snippet) = snippet_opt(cx, item.span) {
                     span_lint_and_sugg(
                         cx,
-                        EXHAUSTIVE_ENUMS,
+                        lint,
                         item.span,
                         "enums should not be exhaustive",
                         "try adding #[non_exhaustive]",
@@ -56,7 +94,7 @@ impl LateLintPass<'_> for ExhaustiveItems {
                 } else {
                     span_lint_and_help(
                         cx,
-                        EXHAUSTIVE_ENUMS,
+                        lint,
                         item.span,
                         "enums should not be exhaustive",
                         None,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index a5deebf7d5f..91c74026f64 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -613,6 +613,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &excessive_bools::FN_PARAMS_EXCESSIVE_BOOLS,
         &excessive_bools::STRUCT_EXCESSIVE_BOOLS,
         &exhaustive_items::EXHAUSTIVE_ENUMS,
+        &exhaustive_items::EXHAUSTIVE_STRUCTS,
         &exit::EXIT,
         &explicit_write::EXPLICIT_WRITE,
         &fallible_impl_from::FALLIBLE_IMPL_FROM,
@@ -1250,6 +1251,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&dbg_macro::DBG_MACRO),
         LintId::of(&else_if_without_else::ELSE_IF_WITHOUT_ELSE),
         LintId::of(&exhaustive_items::EXHAUSTIVE_ENUMS),
+        LintId::of(&exhaustive_items::EXHAUSTIVE_STRUCTS),
         LintId::of(&exit::EXIT),
         LintId::of(&float_literal::LOSSY_FLOAT_LITERAL),
         LintId::of(&implicit_return::IMPLICIT_RETURN),
diff --git a/tests/ui/exhaustive_items.fixed b/tests/ui/exhaustive_items.fixed
index 71c4a251e3b..bc146c6afc5 100644
--- a/tests/ui/exhaustive_items.fixed
+++ b/tests/ui/exhaustive_items.fixed
@@ -1,42 +1,72 @@
 // run-rustfix
 
-#![deny(clippy::exhaustive_enums)]
+#![deny(clippy::exhaustive_enums, clippy::exhaustive_structs)]
 #![allow(unused)]
 
 fn main() {
     // nop
 }
 
-#[non_exhaustive]
+pub mod enums {
+    #[non_exhaustive]
 pub enum Exhaustive {
-    Foo,
-    Bar,
-    Baz,
-    Quux(String),
-}
+        Foo,
+        Bar,
+        Baz,
+        Quux(String),
+    }
 
-// no warning, already non_exhaustive
-#[non_exhaustive]
-pub enum NonExhaustive {
-    Foo,
-    Bar,
-    Baz,
-    Quux(String),
-}
+    // no warning, already non_exhaustive
+    #[non_exhaustive]
+    pub enum NonExhaustive {
+        Foo,
+        Bar,
+        Baz,
+        Quux(String),
+    }
+
+    // no warning, private
+    enum ExhaustivePrivate {
+        Foo,
+        Bar,
+        Baz,
+        Quux(String),
+    }
 
-// no warning, private
-enum ExhaustivePrivate {
-    Foo,
-    Bar,
-    Baz,
-    Quux(String),
+    // no warning, private
+    #[non_exhaustive]
+    enum NonExhaustivePrivate {
+        Foo,
+        Bar,
+        Baz,
+        Quux(String),
+    }
 }
 
-// no warning, private
-#[non_exhaustive]
-enum NonExhaustivePrivate {
-    Foo,
-    Bar,
-    Baz,
-    Quux(String),
+pub mod structs {
+    #[non_exhaustive]
+pub struct Exhaustive {
+        foo: u8,
+        bar: String,
+    }
+
+    // no warning, already non_exhaustive
+    #[non_exhaustive]
+    pub struct NonExhaustive {
+        foo: u8,
+        bar: String,
+    }
+
+    // no warning, private
+    struct ExhaustivePrivate {
+        foo: u8,
+        bar: String,
+    }
+
+    // no warning, private
+    #[non_exhaustive]
+    struct NonExhaustivePrivate {
+        foo: u8,
+        bar: String,
+    }
 }
diff --git a/tests/ui/exhaustive_items.rs b/tests/ui/exhaustive_items.rs
index 45af6851dd1..ed86b50be30 100644
--- a/tests/ui/exhaustive_items.rs
+++ b/tests/ui/exhaustive_items.rs
@@ -1,41 +1,70 @@
 // run-rustfix
 
-#![deny(clippy::exhaustive_enums)]
+#![deny(clippy::exhaustive_enums, clippy::exhaustive_structs)]
 #![allow(unused)]
 
 fn main() {
     // nop
 }
 
-pub enum Exhaustive {
-    Foo,
-    Bar,
-    Baz,
-    Quux(String),
-}
+pub mod enums {
+    pub enum Exhaustive {
+        Foo,
+        Bar,
+        Baz,
+        Quux(String),
+    }
 
-// no warning, already non_exhaustive
-#[non_exhaustive]
-pub enum NonExhaustive {
-    Foo,
-    Bar,
-    Baz,
-    Quux(String),
-}
+    // no warning, already non_exhaustive
+    #[non_exhaustive]
+    pub enum NonExhaustive {
+        Foo,
+        Bar,
+        Baz,
+        Quux(String),
+    }
+
+    // no warning, private
+    enum ExhaustivePrivate {
+        Foo,
+        Bar,
+        Baz,
+        Quux(String),
+    }
 
-// no warning, private
-enum ExhaustivePrivate {
-    Foo,
-    Bar,
-    Baz,
-    Quux(String),
+    // no warning, private
+    #[non_exhaustive]
+    enum NonExhaustivePrivate {
+        Foo,
+        Bar,
+        Baz,
+        Quux(String),
+    }
 }
 
-// no warning, private
-#[non_exhaustive]
-enum NonExhaustivePrivate {
-    Foo,
-    Bar,
-    Baz,
-    Quux(String),
+pub mod structs {
+    pub struct Exhaustive {
+        foo: u8,
+        bar: String,
+    }
+
+    // no warning, already non_exhaustive
+    #[non_exhaustive]
+    pub struct NonExhaustive {
+        foo: u8,
+        bar: String,
+    }
+
+    // no warning, private
+    struct ExhaustivePrivate {
+        foo: u8,
+        bar: String,
+    }
+
+    // no warning, private
+    #[non_exhaustive]
+    struct NonExhaustivePrivate {
+        foo: u8,
+        bar: String,
+    }
 }
diff --git a/tests/ui/exhaustive_items.stderr b/tests/ui/exhaustive_items.stderr
index d00d950efc7..7e286e65949 100644
--- a/tests/ui/exhaustive_items.stderr
+++ b/tests/ui/exhaustive_items.stderr
@@ -1,28 +1,46 @@
 error: enums should not be exhaustive
-  --> $DIR/exhaustive_items.rs:10:1
+  --> $DIR/exhaustive_items.rs:11:5
    |
-LL | / pub enum Exhaustive {
-LL | |     Foo,
-LL | |     Bar,
-LL | |     Baz,
-LL | |     Quux(String),
-LL | | }
-   | |_^
+LL | /     pub enum Exhaustive {
+LL | |         Foo,
+LL | |         Bar,
+LL | |         Baz,
+LL | |         Quux(String),
+LL | |     }
+   | |_____^
    |
 note: the lint level is defined here
-  --> $DIR/exhaustive_items.rs:3:9
+  --> $DIR/exhaustive_items.rs:3:35
    |
-LL | #![deny(clippy::exhaustive_enums)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^
+LL | #![deny(clippy::exhaustive_enums, clippy::exhaustive_structs)]
+   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^
 help: try adding #[non_exhaustive]
    |
-LL | #[non_exhaustive]
+LL |     #[non_exhaustive]
 LL | pub enum Exhaustive {
-LL |     Foo,
-LL |     Bar,
-LL |     Baz,
-LL |     Quux(String),
+LL |         Foo,
+LL |         Bar,
+LL |         Baz,
+LL |         Quux(String),
  ...
 
-error: aborting due to previous error
+error: enums should not be exhaustive
+  --> $DIR/exhaustive_items.rs:46:5
+   |
+LL | /     pub struct Exhaustive {
+LL | |         foo: u8,
+LL | |         bar: String,
+LL | |     }
+   | |_____^
+   |
+help: try adding #[non_exhaustive]
+   |
+LL |     #[non_exhaustive]
+LL | pub struct Exhaustive {
+LL |         foo: u8,
+LL |         bar: String,
+LL |     }
+   |
+
+error: aborting due to 2 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 752274eabdd9be991c9a4e11850890301b697032 Mon Sep 17 00:00:00 2001
From: Manish Goregaokar <manishsmail@gmail.com>
Date: Thu, 21 Jan 2021 14:00:25 -0800
Subject: Fix indentation of suggestion

---
 clippy_lints/src/exhaustive_items.rs | 5 +++--
 tests/ui/exhaustive_items.fixed      | 4 ++--
 tests/ui/exhaustive_items.stderr     | 4 ++--
 3 files changed, 7 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/exhaustive_items.rs b/clippy_lints/src/exhaustive_items.rs
index d604ad0004f..bbcf9bfea27 100644
--- a/clippy_lints/src/exhaustive_items.rs
+++ b/clippy_lints/src/exhaustive_items.rs
@@ -1,4 +1,4 @@
-use crate::utils::{snippet_opt, span_lint_and_help, span_lint_and_sugg};
+use crate::utils::{indent_of, snippet_opt, span_lint_and_help, span_lint_and_sugg};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Item, ItemKind};
@@ -82,13 +82,14 @@ impl LateLintPass<'_> for ExhaustiveItems {
                 };
 
                 if let Some(snippet) = snippet_opt(cx, item.span) {
+                    let indent = " ".repeat(indent_of(cx, item.span).unwrap_or(0));
                     span_lint_and_sugg(
                         cx,
                         lint,
                         item.span,
                         "enums should not be exhaustive",
                         "try adding #[non_exhaustive]",
-                        format!("#[non_exhaustive]\n{}", snippet),
+                        format!("#[non_exhaustive]\n{}{}", indent, snippet),
                         Applicability::MaybeIncorrect,
                     );
                 } else {
diff --git a/tests/ui/exhaustive_items.fixed b/tests/ui/exhaustive_items.fixed
index bc146c6afc5..7e355d2a58b 100644
--- a/tests/ui/exhaustive_items.fixed
+++ b/tests/ui/exhaustive_items.fixed
@@ -9,7 +9,7 @@ fn main() {
 
 pub mod enums {
     #[non_exhaustive]
-pub enum Exhaustive {
+    pub enum Exhaustive {
         Foo,
         Bar,
         Baz,
@@ -45,7 +45,7 @@ pub enum Exhaustive {
 
 pub mod structs {
     #[non_exhaustive]
-pub struct Exhaustive {
+    pub struct Exhaustive {
         foo: u8,
         bar: String,
     }
diff --git a/tests/ui/exhaustive_items.stderr b/tests/ui/exhaustive_items.stderr
index 7e286e65949..1716c8e2cb5 100644
--- a/tests/ui/exhaustive_items.stderr
+++ b/tests/ui/exhaustive_items.stderr
@@ -17,7 +17,7 @@ LL | #![deny(clippy::exhaustive_enums, clippy::exhaustive_structs)]
 help: try adding #[non_exhaustive]
    |
 LL |     #[non_exhaustive]
-LL | pub enum Exhaustive {
+LL |     pub enum Exhaustive {
 LL |         Foo,
 LL |         Bar,
 LL |         Baz,
@@ -36,7 +36,7 @@ LL | |     }
 help: try adding #[non_exhaustive]
    |
 LL |     #[non_exhaustive]
-LL | pub struct Exhaustive {
+LL |     pub struct Exhaustive {
 LL |         foo: u8,
 LL |         bar: String,
 LL |     }
-- 
cgit 1.4.1-3-g733a5


From 65d003a1128e9234730a66c79065afdabb31afa0 Mon Sep 17 00:00:00 2001
From: Manish Goregaokar <manishsmail@gmail.com>
Date: Fri, 22 Jan 2021 12:08:46 -0800
Subject: Clean up suggestion span; clarify help message

---
 clippy_lints/src/exhaustive_items.rs | 27 ++++++++++++++++-----------
 tests/ui/exhaustive_items.stderr     | 22 ++++++++++------------
 2 files changed, 26 insertions(+), 23 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/exhaustive_items.rs b/clippy_lints/src/exhaustive_items.rs
index bbcf9bfea27..4749e36238c 100644
--- a/clippy_lints/src/exhaustive_items.rs
+++ b/clippy_lints/src/exhaustive_items.rs
@@ -1,4 +1,4 @@
-use crate::utils::{indent_of, snippet_opt, span_lint_and_help, span_lint_and_sugg};
+use crate::utils::{indent_of, snippet_opt, span_lint_and_help, span_lint_and_then};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Item, ItemKind};
@@ -75,29 +75,34 @@ impl LateLintPass<'_> for ExhaustiveItems {
             if cx.access_levels.is_exported(item.hir_id);
             if !item.attrs.iter().any(|a| a.has_name(sym::non_exhaustive));
             then {
-                let lint = if let ItemKind::Enum(..) = item.kind {
-                    EXHAUSTIVE_ENUMS
+                let (lint, msg) = if let ItemKind::Enum(..) = item.kind {
+                    (EXHAUSTIVE_ENUMS, "exported enums should not be exhaustive")
                 } else {
-                    EXHAUSTIVE_STRUCTS
+                    (EXHAUSTIVE_STRUCTS, "exported structs should not be exhaustive")
                 };
+                let suggestion_span = item.span.until(item.ident.span);
 
-                if let Some(snippet) = snippet_opt(cx, item.span) {
+                if let Some(snippet) = snippet_opt(cx, suggestion_span) {
                     let indent = " ".repeat(indent_of(cx, item.span).unwrap_or(0));
-                    span_lint_and_sugg(
+                    span_lint_and_then(
                         cx,
                         lint,
                         item.span,
-                        "enums should not be exhaustive",
-                        "try adding #[non_exhaustive]",
-                        format!("#[non_exhaustive]\n{}{}", indent, snippet),
-                        Applicability::MaybeIncorrect,
+                        msg,
+                        |diag| {
+                            let sugg = format!("#[non_exhaustive]\n{}{}", indent, snippet);
+                            diag.span_suggestion(suggestion_span,
+                                                 "try adding #[non_exhaustive]",
+                                                 sugg,
+                                                 Applicability::MaybeIncorrect);
+                        }
                     );
                 } else {
                     span_lint_and_help(
                         cx,
                         lint,
                         item.span,
-                        "enums should not be exhaustive",
+                        msg,
                         None,
                         "try adding #[non_exhaustive]",
                     );
diff --git a/tests/ui/exhaustive_items.stderr b/tests/ui/exhaustive_items.stderr
index 1716c8e2cb5..a24e64b6705 100644
--- a/tests/ui/exhaustive_items.stderr
+++ b/tests/ui/exhaustive_items.stderr
@@ -1,4 +1,4 @@
-error: enums should not be exhaustive
+error: exported enums should not be exhaustive
   --> $DIR/exhaustive_items.rs:11:5
    |
 LL | /     pub enum Exhaustive {
@@ -10,21 +10,17 @@ LL | |     }
    | |_____^
    |
 note: the lint level is defined here
-  --> $DIR/exhaustive_items.rs:3:35
+  --> $DIR/exhaustive_items.rs:3:9
    |
 LL | #![deny(clippy::exhaustive_enums, clippy::exhaustive_structs)]
-   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^
 help: try adding #[non_exhaustive]
    |
 LL |     #[non_exhaustive]
 LL |     pub enum Exhaustive {
-LL |         Foo,
-LL |         Bar,
-LL |         Baz,
-LL |         Quux(String),
- ...
+   |
 
-error: enums should not be exhaustive
+error: exported structs should not be exhaustive
   --> $DIR/exhaustive_items.rs:46:5
    |
 LL | /     pub struct Exhaustive {
@@ -33,13 +29,15 @@ LL | |         bar: String,
 LL | |     }
    | |_____^
    |
+note: the lint level is defined here
+  --> $DIR/exhaustive_items.rs:3:35
+   |
+LL | #![deny(clippy::exhaustive_enums, clippy::exhaustive_structs)]
+   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^
 help: try adding #[non_exhaustive]
    |
 LL |     #[non_exhaustive]
 LL |     pub struct Exhaustive {
-LL |         foo: u8,
-LL |         bar: String,
-LL |     }
    |
 
 error: aborting due to 2 previous errors
-- 
cgit 1.4.1-3-g733a5


From 66afdd1f4292e7fda6ea89113c0c8343e3321d99 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Thu, 21 Jan 2021 19:21:12 -0600
Subject: Enhance collapsible_match for adjusted bindings

---
 clippy_lints/src/collapsible_match.rs | 22 +++++++++++++++++---
 tests/ui/collapsible_match2.rs        | 29 ++++++++++++++++++++++++++
 tests/ui/collapsible_match2.stderr    | 38 ++++++++++++++++++++++++++++++++++-
 3 files changed, 85 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/collapsible_match.rs b/clippy_lints/src/collapsible_match.rs
index c75aa2bde97..604ba102046 100644
--- a/clippy_lints/src/collapsible_match.rs
+++ b/clippy_lints/src/collapsible_match.rs
@@ -2,7 +2,7 @@ use crate::utils::visitors::LocalUsedVisitor;
 use crate::utils::{span_lint_and_then, SpanlessEq};
 use if_chain::if_chain;
 use rustc_hir::def::{CtorKind, CtorOf, DefKind, Res};
-use rustc_hir::{Arm, Expr, ExprKind, Guard, HirId, Pat, PatKind, QPath, StmtKind};
+use rustc_hir::{Arm, Expr, ExprKind, Guard, HirId, Pat, PatKind, QPath, StmtKind, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{DefIdTree, TyCtxt};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -72,8 +72,7 @@ fn check_arm(arm: &Arm<'_>, wild_outer_arm: &Arm<'_>, cx: &LateContext<'_>) {
         if arms_inner.iter().all(|arm| arm.guard.is_none());
         // match expression must be a local binding
         // match <local> { .. }
-        if let ExprKind::Path(QPath::Resolved(None, path)) = expr_in.kind;
-        if let Res::Local(binding_id) = path.res;
+        if let Some(binding_id) = addr_adjusted_binding(expr_in, cx);
         // one of the branches must be "wild-like"
         if let Some(wild_inner_arm_idx) = arms_inner.iter().rposition(|arm_inner| arm_is_wild_like(arm_inner, cx.tcx));
         let (wild_inner_arm, non_wild_inner_arm) =
@@ -175,3 +174,20 @@ fn is_none_ctor(res: Res, tcx: TyCtxt<'_>) -> bool {
     }
     false
 }
+
+/// Retrieves a binding ID with optional `&` and/or `*` operators removed. (e.g. `&**foo`)
+/// Returns `None` if a non-reference type is de-referenced.
+/// For example, if `Vec` is de-referenced to a slice, `None` is returned.
+fn addr_adjusted_binding(mut expr: &Expr<'_>, cx: &LateContext<'_>) -> Option<HirId> {
+    loop {
+        match expr.kind {
+            ExprKind::AddrOf(_, _, e) => expr = e,
+            ExprKind::Path(QPath::Resolved(None, path)) => match path.res {
+                Res::Local(binding_id) => break Some(binding_id),
+                _ => break None,
+            },
+            ExprKind::Unary(UnOp::UnDeref, e) if cx.typeck_results().expr_ty(e).is_ref() => expr = e,
+            _ => break None,
+        }
+    }
+}
diff --git a/tests/ui/collapsible_match2.rs b/tests/ui/collapsible_match2.rs
index d571ac4ab69..8372a212477 100644
--- a/tests/ui/collapsible_match2.rs
+++ b/tests/ui/collapsible_match2.rs
@@ -40,6 +40,35 @@ fn lint_cases(opt_opt: Option<Option<u32>>, res_opt: Result<Option<u32>, String>
         // there is still a better way to write this.
         mac!(res_opt => Ok(val), val => Some(n), foo(n));
     }
+
+    // deref reference value
+    match Some(&[1]) {
+        Some(s) => match *s {
+            [n] => foo(n),
+            _ => (),
+        },
+        _ => (),
+    }
+
+    // ref pattern and deref
+    match Some(&[1]) {
+        Some(ref s) => match &*s {
+            [n] => foo(n),
+            _ => (),
+        },
+        _ => (),
+    }
+}
+
+fn no_lint() {
+    // deref inner value (cannot pattern match with Vec)
+    match Some(vec![1]) {
+        Some(s) => match *s {
+            [n] => foo(n),
+            _ => (),
+        },
+        _ => (),
+    }
 }
 
 fn make<T>() -> T {
diff --git a/tests/ui/collapsible_match2.stderr b/tests/ui/collapsible_match2.stderr
index 490d82d12cd..b2eb457d173 100644
--- a/tests/ui/collapsible_match2.stderr
+++ b/tests/ui/collapsible_match2.stderr
@@ -57,5 +57,41 @@ LL |         mac!(res_opt => Ok(val), val => Some(n), foo(n));
    |                            Replace this binding
    = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to 3 previous errors
+error: Unnecessary nested match
+  --> $DIR/collapsible_match2.rs:46:20
+   |
+LL |           Some(s) => match *s {
+   |  ____________________^
+LL | |             [n] => foo(n),
+LL | |             _ => (),
+LL | |         },
+   | |_________^
+   |
+help: The outer pattern can be modified to include the inner pattern.
+  --> $DIR/collapsible_match2.rs:46:14
+   |
+LL |         Some(s) => match *s {
+   |              ^ Replace this binding
+LL |             [n] => foo(n),
+   |             ^^^ with this pattern
+
+error: Unnecessary nested match
+  --> $DIR/collapsible_match2.rs:55:24
+   |
+LL |           Some(ref s) => match &*s {
+   |  ________________________^
+LL | |             [n] => foo(n),
+LL | |             _ => (),
+LL | |         },
+   | |_________^
+   |
+help: The outer pattern can be modified to include the inner pattern.
+  --> $DIR/collapsible_match2.rs:55:14
+   |
+LL |         Some(ref s) => match &*s {
+   |              ^^^^^ Replace this binding
+LL |             [n] => foo(n),
+   |             ^^^ with this pattern
+
+error: aborting due to 5 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 50abde20c901cf815480f0b494234025c315cc7f Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Thu, 21 Jan 2021 19:25:22 -0600
Subject: Fix dogfood

---
 clippy_lints/src/main_recursion.rs | 3 +--
 clippy_lints/src/ptr.rs            | 3 +--
 clippy_lints/src/utils/higher.rs   | 3 +--
 clippy_lints/src/utils/mod.rs      | 3 +--
 4 files changed, 4 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/main_recursion.rs b/clippy_lints/src/main_recursion.rs
index eceae706e4f..1ed3f3de839 100644
--- a/clippy_lints/src/main_recursion.rs
+++ b/clippy_lints/src/main_recursion.rs
@@ -43,8 +43,7 @@ impl LateLintPass<'_> for MainRecursion {
 
         if_chain! {
             if let ExprKind::Call(func, _) = &expr.kind;
-            if let ExprKind::Path(path) = &func.kind;
-            if let QPath::Resolved(_, path) = &path;
+            if let ExprKind::Path(QPath::Resolved(_, path)) = &func.kind;
             if let Some(def_id) = path.res.opt_def_id();
             if is_entrypoint_fn(cx, def_id);
             then {
diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs
index c6329a1381c..b5aa3411140 100644
--- a/clippy_lints/src/ptr.rs
+++ b/clippy_lints/src/ptr.rs
@@ -263,8 +263,7 @@ fn check_fn(cx: &LateContext<'_>, decl: &FnDecl<'_>, fn_id: HirId, opt_body_id:
             } else if match_type(cx, ty, &paths::COW) {
                 if_chain! {
                     if let TyKind::Rptr(_, MutTy { ref ty, ..} ) = arg.kind;
-                    if let TyKind::Path(ref path) = ty.kind;
-                    if let QPath::Resolved(None, ref pp) = *path;
+                    if let TyKind::Path(QPath::Resolved(None, ref pp)) = ty.kind;
                     if let [ref bx] = *pp.segments;
                     if let Some(ref params) = bx.args;
                     if !params.parenthesized;
diff --git a/clippy_lints/src/utils/higher.rs b/clippy_lints/src/utils/higher.rs
index 9b3585865da..bb71d95a7e2 100644
--- a/clippy_lints/src/utils/higher.rs
+++ b/clippy_lints/src/utils/higher.rs
@@ -158,8 +158,7 @@ pub fn for_loop<'tcx>(
 /// `while cond { body }` becomes `(cond, body)`.
 pub fn while_loop<'tcx>(expr: &'tcx hir::Expr<'tcx>) -> Option<(&'tcx hir::Expr<'tcx>, &'tcx hir::Expr<'tcx>)> {
     if_chain! {
-        if let hir::ExprKind::Loop(block, _, hir::LoopSource::While) = &expr.kind;
-        if let hir::Block { expr: Some(expr), .. } = &**block;
+        if let hir::ExprKind::Loop(hir::Block { expr: Some(expr), .. }, _, hir::LoopSource::While) = &expr.kind;
         if let hir::ExprKind::Match(cond, arms, hir::MatchSource::WhileDesugar) = &expr.kind;
         if let hir::ExprKind::DropTemps(cond) = &cond.kind;
         if let [hir::Arm { body, .. }, ..] = &arms[..];
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index 8698a618f90..991fae6b1aa 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -1126,8 +1126,7 @@ pub fn is_self(slf: &Param<'_>) -> bool {
 
 pub fn is_self_ty(slf: &hir::Ty<'_>) -> bool {
     if_chain! {
-        if let TyKind::Path(ref qp) = slf.kind;
-        if let QPath::Resolved(None, ref path) = *qp;
+        if let TyKind::Path(QPath::Resolved(None, ref path)) = slf.kind;
         if let Res::SelfTy(..) = path.res;
         then {
             return true
-- 
cgit 1.4.1-3-g733a5


From e0ae980fab38e61bf39380e69bbf0000e681a9f8 Mon Sep 17 00:00:00 2001
From: Manish Goregaokar <manishsmail@gmail.com>
Date: Mon, 25 Jan 2021 14:35:57 -0800
Subject: Better suggestion span

---
 clippy_lints/src/exhaustive_items.rs | 43 ++++++++++++++----------------------
 1 file changed, 16 insertions(+), 27 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/exhaustive_items.rs b/clippy_lints/src/exhaustive_items.rs
index 4749e36238c..32b1299efce 100644
--- a/clippy_lints/src/exhaustive_items.rs
+++ b/clippy_lints/src/exhaustive_items.rs
@@ -1,4 +1,4 @@
-use crate::utils::{indent_of, snippet_opt, span_lint_and_help, span_lint_and_then};
+use crate::utils::{indent_of, span_lint_and_then};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Item, ItemKind};
@@ -80,33 +80,22 @@ impl LateLintPass<'_> for ExhaustiveItems {
                 } else {
                     (EXHAUSTIVE_STRUCTS, "exported structs should not be exhaustive")
                 };
-                let suggestion_span = item.span.until(item.ident.span);
+                let suggestion_span = item.span.shrink_to_lo();
+                let indent = " ".repeat(indent_of(cx, item.span).unwrap_or(0));
+                span_lint_and_then(
+                    cx,
+                    lint,
+                    item.span,
+                    msg,
+                    |diag| {
+                        let sugg = format!("#[non_exhaustive]\n{}", indent);
+                        diag.span_suggestion(suggestion_span,
+                                             "try adding #[non_exhaustive]",
+                                             sugg,
+                                             Applicability::MaybeIncorrect);
+                    }
+                );
 
-                if let Some(snippet) = snippet_opt(cx, suggestion_span) {
-                    let indent = " ".repeat(indent_of(cx, item.span).unwrap_or(0));
-                    span_lint_and_then(
-                        cx,
-                        lint,
-                        item.span,
-                        msg,
-                        |diag| {
-                            let sugg = format!("#[non_exhaustive]\n{}{}", indent, snippet);
-                            diag.span_suggestion(suggestion_span,
-                                                 "try adding #[non_exhaustive]",
-                                                 sugg,
-                                                 Applicability::MaybeIncorrect);
-                        }
-                    );
-                } else {
-                    span_lint_and_help(
-                        cx,
-                        lint,
-                        item.span,
-                        msg,
-                        None,
-                        "try adding #[non_exhaustive]",
-                    );
-                }
             }
         }
     }
-- 
cgit 1.4.1-3-g733a5


From 7f1595e18f542f2caf209a05dd090b4a2ebd3b8a Mon Sep 17 00:00:00 2001
From: Philip Hayes <philiphayes@fb.com>
Date: Fri, 29 Jan 2021 22:17:18 -0800
Subject: Fix let_and_return false positive

The issue:

See this Rust playground link: https://play.rust-lang.org/?edition=2018&gist=12cb5d1e7527f8c37743b87fc4a53748

Run the above with clippy to see the following warning:

```
warning: returning the result of a `let` binding from a block
  --> src/main.rs:24:5
   |
23 |     let value = Foo::new(&x).value();
   |     --------------------------------- unnecessary `let` binding
24 |     value
   |     ^^^^^
   |
   = note: `#[warn(clippy::let_and_return)]` on by default
   = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#let_and_return
help: return the expression directly
   |
23 |
24 |     Foo::new(&x).value()
   |
```

Implementing the suggested fix, removing the temporary let binding,
yields a compiler error:

```
error[E0597]: `x` does not live long enough
  --> src/main.rs:23:14
   |
23 |     Foo::new(&x).value()
   |     ---------^^-
   |     |        |
   |     |        borrowed value does not live long enough
   |     a temporary with access to the borrow is created here ...
24 | }
   | -
   | |
   | `x` dropped here while still borrowed
   | ... and the borrow might be used here, when that temporary is dropped and runs the `Drop` code for type `Foo`
   |
   = note: the temporary is part of an expression at the end of a block;
           consider forcing this temporary to be dropped sooner, before the block's local variables are dropped
help: for example, you could save the expression's value in a new local variable `x` and then make `x` be the expression at the end of the block
   |
23 |     let x = Foo::new(&x).value(); x
   |     ^^^^^^^                     ^^^
```

The fix:

Of course, clippy looks like it should already handle this edge case;
however, it appears `utils::fn_def_id` is not returning a `DefId` for
`Foo::new`. Changing the `qpath_res` lookup to use the child Path
`hir_id` instead of the parent Call `hir_id` fixes the issue.
---
 clippy_lints/src/utils/mod.rs  |  3 ++-
 tests/ui/let_and_return.rs     | 12 +++++++++++-
 tests/ui/let_and_return.stderr |  2 +-
 3 files changed, 14 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index 991fae6b1aa..caad7c88bcf 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -1546,10 +1546,11 @@ pub fn fn_def_id(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<DefId> {
         ExprKind::Call(
             Expr {
                 kind: ExprKind::Path(qpath),
+                hir_id: path_hir_id,
                 ..
             },
             ..,
-        ) => cx.typeck_results().qpath_res(qpath, expr.hir_id).opt_def_id(),
+        ) => cx.typeck_results().qpath_res(qpath, *path_hir_id).opt_def_id(),
         _ => None,
     }
 }
diff --git a/tests/ui/let_and_return.rs b/tests/ui/let_and_return.rs
index 73e550b3df8..e3561863c1e 100644
--- a/tests/ui/let_and_return.rs
+++ b/tests/ui/let_and_return.rs
@@ -117,7 +117,11 @@ mod no_lint_if_stmt_borrows {
             fn drop(&mut self) {}
         }
 
-        impl Foo<'_> {
+        impl<'a> Foo<'a> {
+            fn new(inner: &'a Inner) -> Self {
+                Self { inner }
+            }
+
             fn value(&self) -> i32 {
                 42
             }
@@ -132,6 +136,12 @@ mod no_lint_if_stmt_borrows {
             let value = some_foo(&x).value();
             value
         }
+
+        fn test2() -> i32 {
+            let x = Inner {};
+            let value = Foo::new(&x).value();
+            value
+        }
     }
 }
 
diff --git a/tests/ui/let_and_return.stderr b/tests/ui/let_and_return.stderr
index fe878e5f206..a6941dabeb8 100644
--- a/tests/ui/let_and_return.stderr
+++ b/tests/ui/let_and_return.stderr
@@ -28,7 +28,7 @@ LL |         5
    |
 
 error: returning the result of a `let` binding from a block
-  --> $DIR/let_and_return.rs:154:13
+  --> $DIR/let_and_return.rs:164:13
    |
 LL |             let clone = Arc::clone(&self.foo);
    |             ---------------------------------- unnecessary `let` binding
-- 
cgit 1.4.1-3-g733a5


From 797cf6554dd48792ed22c4f81322979548d542d1 Mon Sep 17 00:00:00 2001
From: flip1995 <hello@philkrones.com>
Date: Sat, 30 Jan 2021 17:43:00 +0100
Subject: Get rid of regex and lazy_static dependencies

---
 clippy_lints/Cargo.toml                                       |  2 --
 clippy_lints/src/case_sensitive_file_extension_comparisons.rs | 10 ++++------
 2 files changed, 4 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/Cargo.toml b/clippy_lints/Cargo.toml
index 38098f8a14c..a9516560a61 100644
--- a/clippy_lints/Cargo.toml
+++ b/clippy_lints/Cargo.toml
@@ -34,8 +34,6 @@ rustc-semver="1.1.0"
 url = { version =  "2.1.0", features = ["serde"] }
 quote = "1"
 syn = { version = "1", features = ["full"] }
-regex = "1.4"
-lazy_static = "1.4"
 
 [features]
 deny-warnings = []
diff --git a/clippy_lints/src/case_sensitive_file_extension_comparisons.rs b/clippy_lints/src/case_sensitive_file_extension_comparisons.rs
index d5347ce6ed7..6969ac949d8 100644
--- a/clippy_lints/src/case_sensitive_file_extension_comparisons.rs
+++ b/clippy_lints/src/case_sensitive_file_extension_comparisons.rs
@@ -1,8 +1,6 @@
 use crate::utils::paths::STRING;
 use crate::utils::{match_def_path, span_lint_and_help};
 use if_chain::if_chain;
-use lazy_static::lazy_static;
-use regex::Regex;
 use rustc_ast::ast::LitKind;
 use rustc_hir::{Expr, ExprKind, PathSegment};
 use rustc_lint::{LateContext, LateLintPass};
@@ -41,14 +39,14 @@ declare_clippy_lint! {
 declare_lint_pass!(CaseSensitiveFileExtensionComparisons => [CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS]);
 
 fn check_case_sensitive_file_extension_comparison(ctx: &LateContext<'_>, expr: &Expr<'_>) -> Option<Span> {
-    lazy_static! {
-        static ref RE: Regex = Regex::new(r"^\.([a-z0-9]{1,5}|[A-Z0-9]{1,5})$").unwrap();
-    }
     if_chain! {
         if let ExprKind::MethodCall(PathSegment { ident, .. }, _, [obj, extension, ..], span) = expr.kind;
         if ident.as_str() == "ends_with";
         if let ExprKind::Lit(Spanned { node: LitKind::Str(ext_literal, ..), ..}) = extension.kind;
-        if RE.is_match(&ext_literal.as_str());
+        if (2..=6).contains(&ext_literal.as_str().len());
+        if ext_literal.as_str().starts_with('.');
+        if ext_literal.as_str().chars().skip(1).all(|c| c.is_uppercase() || c.is_digit(10))
+            || ext_literal.as_str().chars().skip(1).all(|c| c.is_lowercase() || c.is_digit(10));
         then {
             let mut ty = ctx.typeck_results().expr_ty(obj);
             ty = match ty.kind() {
-- 
cgit 1.4.1-3-g733a5


From 3874631600811d964f18784859b34302d5533358 Mon Sep 17 00:00:00 2001
From: flip1995 <hello@philkrones.com>
Date: Sat, 30 Jan 2021 17:43:20 +0100
Subject: Remove unknown_clippy_lints allow attribute

---
 clippy_lints/src/utils/diagnostics.rs | 2 --
 1 file changed, 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/diagnostics.rs b/clippy_lints/src/utils/diagnostics.rs
index a7a6b5855b7..6caa04f651f 100644
--- a/clippy_lints/src/utils/diagnostics.rs
+++ b/clippy_lints/src/utils/diagnostics.rs
@@ -186,8 +186,6 @@ pub fn span_lint_hir_and_then(
 ///     |
 ///     = note: `-D fold-any` implied by `-D warnings`
 /// ```
-
-#[allow(clippy::unknown_clippy_lints)]
 #[cfg_attr(feature = "internal-lints", allow(clippy::collapsible_span_lint_calls))]
 pub fn span_lint_and_sugg<'a, T: LintContext>(
     cx: &'a T,
-- 
cgit 1.4.1-3-g733a5


From 939136d1bc512e4acb3a91bbec2d5f7db311d4d8 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Mon, 25 Jan 2021 13:39:35 -0600
Subject: Remove Option from path_to_res return type

---
 clippy_lints/src/utils/internal_lints.rs |  6 +++---
 clippy_lints/src/utils/mod.rs            | 28 +++++++++++++++-------------
 2 files changed, 18 insertions(+), 16 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs
index 822863ca3e2..cccad243e1b 100644
--- a/clippy_lints/src/utils/internal_lints.rs
+++ b/clippy_lints/src/utils/internal_lints.rs
@@ -760,7 +760,7 @@ impl<'tcx> LateLintPass<'tcx> for MatchTypeOnDiagItem {
             // Extract the path to the matched type
             if let Some(segments) = path_to_matched_type(cx, ty_path);
             let segments: Vec<&str> = segments.iter().map(|sym| &**sym).collect();
-            if let Some(ty_did) = path_to_res(cx, &segments[..]).and_then(|res| res.opt_def_id());
+            if let Some(ty_did) = path_to_res(cx, &segments[..]).opt_def_id();
             // Check if the matched type is a diagnostic item
             let diag_items = cx.tcx.diagnostic_items(ty_did.krate);
             if let Some(item_name) = diag_items.iter().find_map(|(k, v)| if *v == ty_did { Some(k) } else { None });
@@ -833,7 +833,7 @@ fn path_to_matched_type(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> Option<Ve
 // This is not a complete resolver for paths. It works on all the paths currently used in the paths
 // module.  That's all it does and all it needs to do.
 pub fn check_path(cx: &LateContext<'_>, path: &[&str]) -> bool {
-    if path_to_res(cx, path).is_some() {
+    if path_to_res(cx, path) != Res::Err {
         return true;
     }
 
@@ -906,7 +906,7 @@ impl<'tcx> LateLintPass<'tcx> for InterningDefinedSymbol {
         }
 
         for &module in &[&paths::KW_MODULE, &paths::SYM_MODULE] {
-            if let Some(Res::Def(_, def_id)) = path_to_res(cx, module) {
+            if let Some(def_id) = path_to_res(cx, module).opt_def_id() {
                 for item in cx.tcx.item_children(def_id).iter() {
                     if_chain! {
                         if let Res::Def(DefKind::Const, item_def_id) = item.res;
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index d0db3a67533..1c58512d4b5 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -309,7 +309,15 @@ pub fn match_path_ast(path: &ast::Path, segments: &[&str]) -> bool {
 
 /// Gets the definition associated to a path.
 #[allow(clippy::shadow_unrelated)] // false positive #6563
-pub fn path_to_res(cx: &LateContext<'_>, path: &[&str]) -> Option<Res> {
+pub fn path_to_res(cx: &LateContext<'_>, path: &[&str]) -> Res {
+    macro_rules! try_res {
+        ($e:expr) => {
+            match $e {
+                Some(e) => e,
+                None => return Res::Err,
+            }
+        };
+    }
     fn item_child_by_name<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId, name: &str) -> Option<&'tcx Export<HirId>> {
         tcx.item_children(def_id)
             .iter()
@@ -318,12 +326,12 @@ pub fn path_to_res(cx: &LateContext<'_>, path: &[&str]) -> Option<Res> {
 
     let (krate, first, path) = match *path {
         [krate, first, ref path @ ..] => (krate, first, path),
-        _ => return None,
+        _ => return Res::Err,
     };
     let tcx = cx.tcx;
     let crates = tcx.crates();
-    let krate = crates.iter().find(|&&num| tcx.crate_name(num).as_str() == krate)?;
-    let first = item_child_by_name(tcx, krate.as_def_id(), first)?;
+    let krate = try_res!(crates.iter().find(|&&num| tcx.crate_name(num).as_str() == krate));
+    let first = try_res!(item_child_by_name(tcx, krate.as_def_id(), first));
     let last = path
         .iter()
         .copied()
@@ -343,21 +351,15 @@ pub fn path_to_res(cx: &LateContext<'_>, path: &[&str]) -> Option<Res> {
             } else {
                 None
             }
-        })?;
-    Some(last.res)
+        });
+    try_res!(last).res
 }
 
 /// Convenience function to get the `DefId` of a trait by path.
 /// It could be a trait or trait alias.
 pub fn get_trait_def_id(cx: &LateContext<'_>, path: &[&str]) -> Option<DefId> {
-    let res = match path_to_res(cx, path) {
-        Some(res) => res,
-        None => return None,
-    };
-
-    match res {
+    match path_to_res(cx, path) {
         Res::Def(DefKind::Trait | DefKind::TraitAlias, trait_id) => Some(trait_id),
-        Res::Err => unreachable!("this trait resolution is impossible: {:?}", &path),
         _ => None,
     }
 }
-- 
cgit 1.4.1-3-g733a5


From 5753614152b4c6d9c0d20bc311a335c4746c3ed0 Mon Sep 17 00:00:00 2001
From: nahuakang <kangnahua@gmail.com>
Date: Wed, 27 Jan 2021 09:34:59 +0100
Subject: Draft skeleton for new lint

---
 CHANGELOG.md              |  1 +
 clippy_lints/src/lib.rs   |  3 +++
 clippy_lints/src/loops.rs | 64 +++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 68 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index dadb6832d1f..e8e738313d4 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1969,6 +1969,7 @@ Released 2018-09-13
 [`fn_to_numeric_cast_with_truncation`]: https://rust-lang.github.io/rust-clippy/master/index.html#fn_to_numeric_cast_with_truncation
 [`for_kv_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#for_kv_map
 [`for_loops_over_fallibles`]: https://rust-lang.github.io/rust-clippy/master/index.html#for_loops_over_fallibles
+[`for_loops_over_options`]: https://rust-lang.github.io/rust-clippy/master/index.html#for_loops_over_options
 [`forget_copy`]: https://rust-lang.github.io/rust-clippy/master/index.html#forget_copy
 [`forget_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#forget_ref
 [`from_iter_instead_of_collect`]: https://rust-lang.github.io/rust-clippy/master/index.html#from_iter_instead_of_collect
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 54007c29c6c..37932087355 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -685,6 +685,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &loops::EXPLICIT_ITER_LOOP,
         &loops::FOR_KV_MAP,
         &loops::FOR_LOOPS_OVER_FALLIBLES,
+        &loops::FOR_LOOPS_OVER_OPTIONS,
         &loops::ITER_NEXT_LOOP,
         &loops::MANUAL_MEMCPY,
         &loops::MUT_RANGE_BOUND,
@@ -1488,6 +1489,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&loops::EXPLICIT_COUNTER_LOOP),
         LintId::of(&loops::FOR_KV_MAP),
         LintId::of(&loops::FOR_LOOPS_OVER_FALLIBLES),
+        LintId::of(&loops::FOR_LOOPS_OVER_OPTIONS),
         LintId::of(&loops::ITER_NEXT_LOOP),
         LintId::of(&loops::MANUAL_MEMCPY),
         LintId::of(&loops::MUT_RANGE_BOUND),
@@ -1820,6 +1822,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&lifetimes::EXTRA_UNUSED_LIFETIMES),
         LintId::of(&lifetimes::NEEDLESS_LIFETIMES),
         LintId::of(&loops::EXPLICIT_COUNTER_LOOP),
+        LintId::of(&loops::FOR_LOOPS_OVER_OPTIONS),
         LintId::of(&loops::MUT_RANGE_BOUND),
         LintId::of(&loops::SINGLE_ELEMENT_LOOP),
         LintId::of(&loops::WHILE_LET_LOOP),
diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 5211ca7da32..c1a59650cb0 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -494,6 +494,37 @@ declare_clippy_lint! {
     "there is no reason to have a single element loop"
 }
 
+declare_clippy_lint! {
+    /// **What it does:** Checks for iteration of `Option`s with
+    /// a single `if let Some()` expression inside.
+    ///
+    /// **Why is this bad?** It is verbose and can be simplified
+    /// by first calling the `flatten` method on the `Iterator`.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// let x = vec![Some(1), Some(2), Some(3)];
+    /// for n in x {
+    ///     if let Some(n) = n {
+    ///         println!("{}", n);
+    ///     }
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// let x = vec![Some(1), Some(2), Some(3)];
+    /// for n in x.iter().flatten() {
+    ///     println!("{}", n);
+    /// }
+    /// ```
+    pub FOR_LOOPS_OVER_OPTIONS,
+    complexity,
+    "for loops over `Option`s or `Result`s with a single expression can be simplified"
+}
+
 declare_lint_pass!(Loops => [
     MANUAL_MEMCPY,
     NEEDLESS_RANGE_LOOP,
@@ -501,6 +532,7 @@ declare_lint_pass!(Loops => [
     EXPLICIT_INTO_ITER_LOOP,
     ITER_NEXT_LOOP,
     FOR_LOOPS_OVER_FALLIBLES,
+    FOR_LOOPS_OVER_OPTIONS,
     WHILE_LET_LOOP,
     NEEDLESS_COLLECT,
     EXPLICIT_COUNTER_LOOP,
@@ -830,6 +862,7 @@ fn check_for_loop<'tcx>(
     check_for_mut_range_bound(cx, arg, body);
     check_for_single_element_loop(cx, pat, arg, body, expr);
     detect_same_item_push(cx, pat, arg, body, expr);
+    check_for_loop_over_options_or_results(cx, pat, arg, body, expr);
 }
 
 // this function assumes the given expression is a `for` loop.
@@ -1953,6 +1986,37 @@ fn check_for_single_element_loop<'tcx>(
     }
 }
 
+/// Check if a for loop loops over `Option`s or `Result`s and contains only
+/// a `if let Some` or `if let Ok` expression.
+fn check_for_loop_over_options_or_results<'tcx>(
+    cx: &LateContext<'tcx>,
+    pat: &'tcx Pat<'_>,
+    arg: &'tcx Expr<'_>,
+    body: &'tcx Expr<'_>,
+    expr: &'tcx Expr<'_>,
+) {
+    if_chain! {
+        if let ExprKind::Block(ref block, _) = body.kind;
+        if block.stmts.is_empty();
+        if let Some(inner_expr) = block.expr;
+        if let ExprKind::Match(ref _match_expr, ref _match_arms, MatchSource::IfLetDesugar{ contains_else_clause }) = inner_expr.kind;
+        if !contains_else_clause;
+        then {
+            // println!("if_let_expr:\n{:?}", snippet(cx, if_let_expr.span, ".."));
+            // println!("pat is:\n {:?}", snippet(cx, pat.span, ".."));
+            // println!("arg is:\n {:?}", snippet(cx, arg.span, ".."));
+            // println!("body is:\n {:?}", snippet(cx, body.span, ".."));
+            // println!("arg kind is: {:?}", arg.kind);
+            // println!("expr is:\n {:?}", snippet(cx, expr.span, ".."));
+            // todo!();
+            let arg_snippet = snippet(cx, arg.span, "..");
+            let msg = "looping over `Option`s or `Result`s with an `if let` expression.";
+            let hint = format!("try turn {} into an `Iterator` and use `flatten`: `{}.iter().flatten()`", arg_snippet, arg_snippet);
+            span_lint_and_help(cx, FOR_LOOPS_OVER_OPTIONS, expr.span, msg, None, &hint);
+        }
+    }
+}
+
 struct MutatePairDelegate<'a, 'tcx> {
     cx: &'a LateContext<'tcx>,
     hir_id_low: Option<HirId>,
-- 
cgit 1.4.1-3-g733a5


From 3da25ed955baffe8c14cee4950762d268f1b48e7 Mon Sep 17 00:00:00 2001
From: nahuakang <kangnahua@gmail.com>
Date: Wed, 27 Jan 2021 09:49:53 +0100
Subject: Rename lint

---
 CHANGELOG.md                                  |  3 ++-
 clippy_lints/src/lib.rs                       |  6 +++---
 clippy_lints/src/loops.rs                     |  6 +++---
 tests/ui/for_loops_over_options.rs            | 31 ---------------------------
 tests/ui/for_loops_over_options_or_results.rs | 31 +++++++++++++++++++++++++++
 5 files changed, 39 insertions(+), 38 deletions(-)
 delete mode 100644 tests/ui/for_loops_over_options.rs
 create mode 100644 tests/ui/for_loops_over_options_or_results.rs

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index e8e738313d4..4bd04ffbd99 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1969,7 +1969,8 @@ Released 2018-09-13
 [`fn_to_numeric_cast_with_truncation`]: https://rust-lang.github.io/rust-clippy/master/index.html#fn_to_numeric_cast_with_truncation
 [`for_kv_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#for_kv_map
 [`for_loops_over_fallibles`]: https://rust-lang.github.io/rust-clippy/master/index.html#for_loops_over_fallibles
-[`for_loops_over_options`]: https://rust-lang.github.io/rust-clippy/master/index.html#for_loops_over_options
+[`for_loops_over_options_or_results`]:
+https://rust-lang.github.io/rust-clippy/master/index.html#for_loops_over_options_or_results
 [`forget_copy`]: https://rust-lang.github.io/rust-clippy/master/index.html#forget_copy
 [`forget_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#forget_ref
 [`from_iter_instead_of_collect`]: https://rust-lang.github.io/rust-clippy/master/index.html#from_iter_instead_of_collect
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 37932087355..dae6c93c7cb 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -685,7 +685,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &loops::EXPLICIT_ITER_LOOP,
         &loops::FOR_KV_MAP,
         &loops::FOR_LOOPS_OVER_FALLIBLES,
-        &loops::FOR_LOOPS_OVER_OPTIONS,
+        &loops::FOR_LOOPS_OVER_OPTIONS_OR_RESULTS,
         &loops::ITER_NEXT_LOOP,
         &loops::MANUAL_MEMCPY,
         &loops::MUT_RANGE_BOUND,
@@ -1489,7 +1489,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&loops::EXPLICIT_COUNTER_LOOP),
         LintId::of(&loops::FOR_KV_MAP),
         LintId::of(&loops::FOR_LOOPS_OVER_FALLIBLES),
-        LintId::of(&loops::FOR_LOOPS_OVER_OPTIONS),
+        LintId::of(&loops::FOR_LOOPS_OVER_OPTIONS_OR_RESULTS),
         LintId::of(&loops::ITER_NEXT_LOOP),
         LintId::of(&loops::MANUAL_MEMCPY),
         LintId::of(&loops::MUT_RANGE_BOUND),
@@ -1822,7 +1822,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&lifetimes::EXTRA_UNUSED_LIFETIMES),
         LintId::of(&lifetimes::NEEDLESS_LIFETIMES),
         LintId::of(&loops::EXPLICIT_COUNTER_LOOP),
-        LintId::of(&loops::FOR_LOOPS_OVER_OPTIONS),
+        LintId::of(&loops::FOR_LOOPS_OVER_OPTIONS_OR_RESULTS),
         LintId::of(&loops::MUT_RANGE_BOUND),
         LintId::of(&loops::SINGLE_ELEMENT_LOOP),
         LintId::of(&loops::WHILE_LET_LOOP),
diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index c1a59650cb0..e9047cce15f 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -520,7 +520,7 @@ declare_clippy_lint! {
     ///     println!("{}", n);
     /// }
     /// ```
-    pub FOR_LOOPS_OVER_OPTIONS,
+    pub FOR_LOOPS_OVER_OPTIONS_OR_RESULTS,
     complexity,
     "for loops over `Option`s or `Result`s with a single expression can be simplified"
 }
@@ -532,7 +532,7 @@ declare_lint_pass!(Loops => [
     EXPLICIT_INTO_ITER_LOOP,
     ITER_NEXT_LOOP,
     FOR_LOOPS_OVER_FALLIBLES,
-    FOR_LOOPS_OVER_OPTIONS,
+    FOR_LOOPS_OVER_OPTIONS_OR_RESULTS,
     WHILE_LET_LOOP,
     NEEDLESS_COLLECT,
     EXPLICIT_COUNTER_LOOP,
@@ -2012,7 +2012,7 @@ fn check_for_loop_over_options_or_results<'tcx>(
             let arg_snippet = snippet(cx, arg.span, "..");
             let msg = "looping over `Option`s or `Result`s with an `if let` expression.";
             let hint = format!("try turn {} into an `Iterator` and use `flatten`: `{}.iter().flatten()`", arg_snippet, arg_snippet);
-            span_lint_and_help(cx, FOR_LOOPS_OVER_OPTIONS, expr.span, msg, None, &hint);
+            span_lint_and_help(cx, FOR_LOOPS_OVER_OPTIONS_OR_RESULTS, expr.span, msg, None, &hint);
         }
     }
 }
diff --git a/tests/ui/for_loops_over_options.rs b/tests/ui/for_loops_over_options.rs
deleted file mode 100644
index d8144864a21..00000000000
--- a/tests/ui/for_loops_over_options.rs
+++ /dev/null
@@ -1,31 +0,0 @@
-#![warn(clippy::for_loops_over_options)]
-
-fn main() {
-    let x = vec![Some(1), Some(2), Some(3)];
-    for n in x {
-        if let Some(n) = n {
-            println!("{}", n);
-        }
-    }
-
-    let y: Vec<Result<i32, i32>> = vec![];
-    for n in y.clone() {
-        if let Ok(n) = n {
-            println!("{}", n);
-        }
-    }
-
-    // This should not trigger the lint
-    for n in y.clone() {
-        if let Ok(n) = n {
-            println!("{}", n);
-        } else {
-            println!("Oops!");
-        }
-    }
-
-    // This should not trigger the lint
-    for n in vec![Some(1), Some(2), Some(3)].iter().flatten() {
-        println!("{}", n);
-    }
-}
diff --git a/tests/ui/for_loops_over_options_or_results.rs b/tests/ui/for_loops_over_options_or_results.rs
new file mode 100644
index 00000000000..02e24b250f7
--- /dev/null
+++ b/tests/ui/for_loops_over_options_or_results.rs
@@ -0,0 +1,31 @@
+#![warn(clippy::for_loops_over_options_or_results)]
+
+fn main() {
+    let x = vec![Some(1), Some(2), Some(3)];
+    for n in x {
+        if let Some(n) = n {
+            println!("{}", n);
+        }
+    }
+
+    let y: Vec<Result<i32, i32>> = vec![];
+    for n in y.clone() {
+        if let Ok(n) = n {
+            println!("{}", n);
+        }
+    }
+
+    // This should not trigger the lint
+    for n in y.clone() {
+        if let Ok(n) = n {
+            println!("{}", n);
+        } else {
+            println!("Oops!");
+        }
+    }
+
+    // This should not trigger the lint
+    for n in vec![Some(1), Some(2), Some(3)].iter().flatten() {
+        println!("{}", n);
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From b87e189694eebb5b83d758528032cf4d4db81472 Mon Sep 17 00:00:00 2001
From: nahuakang <kangnahua@gmail.com>
Date: Fri, 29 Jan 2021 01:38:34 +0100
Subject: Implement manual flatten lint

---
 CHANGELOG.md                                  |  2 +-
 clippy_lints/src/lib.rs                       |  6 +-
 clippy_lints/src/loops.rs                     | 85 ++++++++++++++++++---------
 clippy_lints/src/mut_mut.rs                   |  2 +-
 clippy_lints/src/needless_question_mark.rs    | 26 +-------
 clippy_lints/src/ranges.rs                    |  2 +-
 clippy_lints/src/utils/higher.rs              |  9 +--
 clippy_lints/src/utils/internal_lints.rs      | 16 +++--
 clippy_lints/src/utils/mod.rs                 | 28 ++++++++-
 clippy_lints/src/vec.rs                       |  2 +-
 tests/ui/for_loops_over_options_or_results.rs | 31 ----------
 tests/ui/manual_flatten.rs                    | 54 +++++++++++++++++
 tests/ui/manual_flatten.stderr                | 51 ++++++++++++++++
 13 files changed, 208 insertions(+), 106 deletions(-)
 delete mode 100644 tests/ui/for_loops_over_options_or_results.rs
 create mode 100644 tests/ui/manual_flatten.rs
 create mode 100644 tests/ui/manual_flatten.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index e40cd8174fc..aceabcbbdfc 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1969,7 +1969,6 @@ Released 2018-09-13
 [`fn_to_numeric_cast_with_truncation`]: https://rust-lang.github.io/rust-clippy/master/index.html#fn_to_numeric_cast_with_truncation
 [`for_kv_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#for_kv_map
 [`for_loops_over_fallibles`]: https://rust-lang.github.io/rust-clippy/master/index.html#for_loops_over_fallibles
-[`for_loops_over_options_or_results`]: https://rust-lang.github.io/rust-clippy/master/index.html#for_loops_over_options_or_results
 [`forget_copy`]: https://rust-lang.github.io/rust-clippy/master/index.html#forget_copy
 [`forget_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#forget_ref
 [`from_iter_instead_of_collect`]: https://rust-lang.github.io/rust-clippy/master/index.html#from_iter_instead_of_collect
@@ -2040,6 +2039,7 @@ Released 2018-09-13
 [`manual_async_fn`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_async_fn
 [`manual_filter_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_filter_map
 [`manual_find_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_find_map
+[`manual_flatten`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_flatten
 [`manual_memcpy`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_memcpy
 [`manual_non_exhaustive`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_non_exhaustive
 [`manual_ok_or`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_ok_or
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index dae6c93c7cb..cd0a95a4585 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -685,8 +685,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &loops::EXPLICIT_ITER_LOOP,
         &loops::FOR_KV_MAP,
         &loops::FOR_LOOPS_OVER_FALLIBLES,
-        &loops::FOR_LOOPS_OVER_OPTIONS_OR_RESULTS,
         &loops::ITER_NEXT_LOOP,
+        &loops::MANUAL_FLATTEN,
         &loops::MANUAL_MEMCPY,
         &loops::MUT_RANGE_BOUND,
         &loops::NEEDLESS_COLLECT,
@@ -1489,8 +1489,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&loops::EXPLICIT_COUNTER_LOOP),
         LintId::of(&loops::FOR_KV_MAP),
         LintId::of(&loops::FOR_LOOPS_OVER_FALLIBLES),
-        LintId::of(&loops::FOR_LOOPS_OVER_OPTIONS_OR_RESULTS),
         LintId::of(&loops::ITER_NEXT_LOOP),
+        LintId::of(&loops::MANUAL_FLATTEN),
         LintId::of(&loops::MANUAL_MEMCPY),
         LintId::of(&loops::MUT_RANGE_BOUND),
         LintId::of(&loops::NEEDLESS_COLLECT),
@@ -1822,7 +1822,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&lifetimes::EXTRA_UNUSED_LIFETIMES),
         LintId::of(&lifetimes::NEEDLESS_LIFETIMES),
         LintId::of(&loops::EXPLICIT_COUNTER_LOOP),
-        LintId::of(&loops::FOR_LOOPS_OVER_OPTIONS_OR_RESULTS),
+        LintId::of(&loops::MANUAL_FLATTEN),
         LintId::of(&loops::MUT_RANGE_BOUND),
         LintId::of(&loops::SINGLE_ELEMENT_LOOP),
         LintId::of(&loops::WHILE_LET_LOOP),
diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index e9047cce15f..db5aec82e90 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -5,10 +5,10 @@ use crate::utils::usage::{is_unused, mutated_variables};
 use crate::utils::visitors::LocalUsedVisitor;
 use crate::utils::{
     contains_name, get_enclosing_block, get_parent_expr, get_trait_def_id, has_iter_method, higher, implements_trait,
-    indent_of, is_in_panic_handler, is_integer_const, is_no_std_crate, is_refutable, is_type_diagnostic_item,
-    last_path_segment, match_trait_method, match_type, match_var, multispan_sugg, single_segment_path, snippet,
-    snippet_with_applicability, snippet_with_macro_callsite, span_lint, span_lint_and_help, span_lint_and_sugg,
-    span_lint_and_then, sugg, SpanlessEq,
+    indent_of, is_in_panic_handler, is_integer_const, is_no_std_crate, is_ok_ctor, is_refutable, is_some_ctor,
+    is_type_diagnostic_item, last_path_segment, match_trait_method, match_type, match_var, multispan_sugg,
+    single_segment_path, snippet, snippet_with_applicability, snippet_with_macro_callsite, span_lint,
+    span_lint_and_help, span_lint_and_sugg, span_lint_and_then, sugg, SpanlessEq,
 };
 use if_chain::if_chain;
 use rustc_ast::ast;
@@ -495,8 +495,8 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for iteration of `Option`s with
-    /// a single `if let Some()` expression inside.
+    /// **What it does:** Check for unnecessary `if let` usage in a for loop
+    /// where only the `Some` or `Ok` variant of the iterator element is used.
     ///
     /// **Why is this bad?** It is verbose and can be simplified
     /// by first calling the `flatten` method on the `Iterator`.
@@ -516,23 +516,23 @@ declare_clippy_lint! {
     /// Use instead:
     /// ```rust
     /// let x = vec![Some(1), Some(2), Some(3)];
-    /// for n in x.iter().flatten() {
+    /// for n in x.into_iter().flatten() {
     ///     println!("{}", n);
     /// }
     /// ```
-    pub FOR_LOOPS_OVER_OPTIONS_OR_RESULTS,
+    pub MANUAL_FLATTEN,
     complexity,
     "for loops over `Option`s or `Result`s with a single expression can be simplified"
 }
 
 declare_lint_pass!(Loops => [
     MANUAL_MEMCPY,
+    MANUAL_FLATTEN,
     NEEDLESS_RANGE_LOOP,
     EXPLICIT_ITER_LOOP,
     EXPLICIT_INTO_ITER_LOOP,
     ITER_NEXT_LOOP,
     FOR_LOOPS_OVER_FALLIBLES,
-    FOR_LOOPS_OVER_OPTIONS_OR_RESULTS,
     WHILE_LET_LOOP,
     NEEDLESS_COLLECT,
     EXPLICIT_COUNTER_LOOP,
@@ -549,14 +549,14 @@ declare_lint_pass!(Loops => [
 impl<'tcx> LateLintPass<'tcx> for Loops {
     #[allow(clippy::too_many_lines)]
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if let Some((pat, arg, body)) = higher::for_loop(expr) {
+        if let Some((pat, arg, body, span)) = higher::for_loop(expr) {
             // we don't want to check expanded macros
             // this check is not at the top of the function
             // since higher::for_loop expressions are marked as expansions
             if body.span.from_expansion() {
                 return;
             }
-            check_for_loop(cx, pat, arg, body, expr);
+            check_for_loop(cx, pat, arg, body, expr, span);
         }
 
         // we don't want to check expanded macros
@@ -851,6 +851,7 @@ fn check_for_loop<'tcx>(
     arg: &'tcx Expr<'_>,
     body: &'tcx Expr<'_>,
     expr: &'tcx Expr<'_>,
+    span: Span,
 ) {
     let is_manual_memcpy_triggered = detect_manual_memcpy(cx, pat, arg, body, expr);
     if !is_manual_memcpy_triggered {
@@ -862,7 +863,7 @@ fn check_for_loop<'tcx>(
     check_for_mut_range_bound(cx, arg, body);
     check_for_single_element_loop(cx, pat, arg, body, expr);
     detect_same_item_push(cx, pat, arg, body, expr);
-    check_for_loop_over_options_or_results(cx, pat, arg, body, expr);
+    check_manual_flatten(cx, pat, arg, body, span);
 }
 
 // this function assumes the given expression is a `for` loop.
@@ -1986,33 +1987,61 @@ fn check_for_single_element_loop<'tcx>(
     }
 }
 
-/// Check if a for loop loops over `Option`s or `Result`s and contains only
-/// a `if let Some` or `if let Ok` expression.
-fn check_for_loop_over_options_or_results<'tcx>(
+/// Check for unnecessary `if let` usage in a for loop where only the `Some` or `Ok` variant of the
+/// iterator element is used.
+fn check_manual_flatten<'tcx>(
     cx: &LateContext<'tcx>,
     pat: &'tcx Pat<'_>,
     arg: &'tcx Expr<'_>,
     body: &'tcx Expr<'_>,
-    expr: &'tcx Expr<'_>,
+    span: Span,
 ) {
     if_chain! {
+        // Ensure the `if let` statement is the only expression in the for-loop
         if let ExprKind::Block(ref block, _) = body.kind;
         if block.stmts.is_empty();
         if let Some(inner_expr) = block.expr;
-        if let ExprKind::Match(ref _match_expr, ref _match_arms, MatchSource::IfLetDesugar{ contains_else_clause }) = inner_expr.kind;
-        if !contains_else_clause;
+        if let ExprKind::Match(
+            ref match_expr, ref match_arms, MatchSource::IfLetDesugar{ contains_else_clause: false }
+        ) = inner_expr.kind;
+        // Ensure match_expr in `if let` statement is the same as the pat from the for-loop
+        if let PatKind::Binding(_, pat_hir_id, _, _) = pat.kind;
+        if let ExprKind::Path(QPath::Resolved(None, match_expr_path)) = match_expr.kind;
+        if let Res::Local(match_expr_path_id) = match_expr_path.res;
+        if pat_hir_id == match_expr_path_id;
+        // Ensure the `if let` statement is for the `Some` variant of `Option` or the `Ok` variant of `Result`
+        if let PatKind::TupleStruct(QPath::Resolved(None, path), _, _) = match_arms[0].pat.kind;
+        if is_some_ctor(cx, path.res) || is_ok_ctor(cx, path.res);
+        let if_let_type = if is_some_ctor(cx, path.res) {
+            "Some"
+        } else {
+            "Ok"
+        };
+        // Determine if `arg` is `Iterator` or implicitly calls `into_iter`
+        let arg_ty = cx.typeck_results().expr_ty(arg);
+        if let Some(id) = get_trait_def_id(cx, &paths::ITERATOR);
+        if let is_iterator = implements_trait(cx, arg_ty, id, &[]);
+
         then {
-            // println!("if_let_expr:\n{:?}", snippet(cx, if_let_expr.span, ".."));
-            // println!("pat is:\n {:?}", snippet(cx, pat.span, ".."));
-            // println!("arg is:\n {:?}", snippet(cx, arg.span, ".."));
-            // println!("body is:\n {:?}", snippet(cx, body.span, ".."));
-            // println!("arg kind is: {:?}", arg.kind);
-            // println!("expr is:\n {:?}", snippet(cx, expr.span, ".."));
-            // todo!();
+            // Prepare the error message
+            let msg = format!("Unnecessary `if let` since only the `{}` variant of the iterator element is used.", if_let_type);
+
+            // Prepare the help message
             let arg_snippet = snippet(cx, arg.span, "..");
-            let msg = "looping over `Option`s or `Result`s with an `if let` expression.";
-            let hint = format!("try turn {} into an `Iterator` and use `flatten`: `{}.iter().flatten()`", arg_snippet, arg_snippet);
-            span_lint_and_help(cx, FOR_LOOPS_OVER_OPTIONS_OR_RESULTS, expr.span, msg, None, &hint);
+            let hint = if is_iterator {
+                format!("try: `{}.flatten()`", arg_snippet)
+            } else {
+                format!("try: `{}.into_iter().flatten()`", arg_snippet)
+            };
+
+            span_lint_and_help(
+                cx,
+                MANUAL_FLATTEN,
+                span,
+                &msg,
+                Some(arg.span),
+                &hint,
+            );
         }
     }
 }
diff --git a/clippy_lints/src/mut_mut.rs b/clippy_lints/src/mut_mut.rs
index 2f3cdb894f0..d7239b328bb 100644
--- a/clippy_lints/src/mut_mut.rs
+++ b/clippy_lints/src/mut_mut.rs
@@ -52,7 +52,7 @@ impl<'a, 'tcx> intravisit::Visitor<'tcx> for MutVisitor<'a, 'tcx> {
             return;
         }
 
-        if let Some((_, arg, body)) = higher::for_loop(expr) {
+        if let Some((_, arg, body, _)) = higher::for_loop(expr) {
             // A `for` loop lowers to:
             // ```rust
             // match ::std::iter::Iterator::next(&mut iter) {
diff --git a/clippy_lints/src/needless_question_mark.rs b/clippy_lints/src/needless_question_mark.rs
index 9e9b79ee1cf..fe8d4d07abc 100644
--- a/clippy_lints/src/needless_question_mark.rs
+++ b/clippy_lints/src/needless_question_mark.rs
@@ -1,8 +1,6 @@
 use rustc_errors::Applicability;
-use rustc_hir::def::{CtorKind, CtorOf, DefKind, Res};
 use rustc_hir::{Body, Expr, ExprKind, LangItem, MatchSource, QPath};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
-use rustc_middle::ty::DefIdTree;
 use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::sym;
@@ -160,7 +158,7 @@ fn is_some_or_ok_call<'a>(
         // Check outer expression matches CALL_IDENT(ARGUMENT) format
         if let ExprKind::Call(path, args) = &expr.kind;
         if let ExprKind::Path(QPath::Resolved(None, path)) = &path.kind;
-        if is_some_ctor(cx, path.res) || is_ok_ctor(cx, path.res);
+        if utils::is_some_ctor(cx, path.res) || utils::is_ok_ctor(cx, path.res);
 
         // Extract inner expression from ARGUMENT
         if let ExprKind::Match(inner_expr_with_q, _, MatchSource::TryDesugar) = &args[0].kind;
@@ -208,25 +206,3 @@ fn is_some_or_ok_call<'a>(
 fn has_implicit_error_from(cx: &LateContext<'_>, entire_expr: &Expr<'_>, inner_result_expr: &Expr<'_>) -> bool {
     return cx.typeck_results().expr_ty(entire_expr) != cx.typeck_results().expr_ty(inner_result_expr);
 }
-
-fn is_ok_ctor(cx: &LateContext<'_>, res: Res) -> bool {
-    if let Some(ok_id) = cx.tcx.lang_items().result_ok_variant() {
-        if let Res::Def(DefKind::Ctor(CtorOf::Variant, CtorKind::Fn), id) = res {
-            if let Some(variant_id) = cx.tcx.parent(id) {
-                return variant_id == ok_id;
-            }
-        }
-    }
-    false
-}
-
-fn is_some_ctor(cx: &LateContext<'_>, res: Res) -> bool {
-    if let Some(some_id) = cx.tcx.lang_items().option_some_variant() {
-        if let Res::Def(DefKind::Ctor(CtorOf::Variant, CtorKind::Fn), id) = res {
-            if let Some(variant_id) = cx.tcx.parent(id) {
-                return variant_id == some_id;
-            }
-        }
-    }
-    false
-}
diff --git a/clippy_lints/src/ranges.rs b/clippy_lints/src/ranges.rs
index 3e454eecd97..59503817c0f 100644
--- a/clippy_lints/src/ranges.rs
+++ b/clippy_lints/src/ranges.rs
@@ -442,7 +442,7 @@ fn check_reversed_empty_range(cx: &LateContext<'_>, expr: &Expr<'_>) {
         let mut cur_expr = expr;
         while let Some(parent_expr) = get_parent_expr(cx, cur_expr) {
             match higher::for_loop(parent_expr) {
-                Some((_, args, _)) if args.hir_id == expr.hir_id => return true,
+                Some((_, args, _, _)) if args.hir_id == expr.hir_id => return true,
                 _ => cur_expr = parent_expr,
             }
         }
diff --git a/clippy_lints/src/utils/higher.rs b/clippy_lints/src/utils/higher.rs
index 340d340d6d3..df7f0f95782 100644
--- a/clippy_lints/src/utils/higher.rs
+++ b/clippy_lints/src/utils/higher.rs
@@ -9,6 +9,7 @@ use rustc_ast::ast;
 use rustc_hir as hir;
 use rustc_hir::{BorrowKind, Expr, ExprKind, StmtKind, UnOp};
 use rustc_lint::LateContext;
+use rustc_span::source_map::Span;
 
 /// Converts a hir binary operator to the corresponding `ast` type.
 #[must_use]
@@ -133,11 +134,11 @@ pub fn is_from_for_desugar(local: &hir::Local<'_>) -> bool {
     false
 }
 
-/// Recover the essential nodes of a desugared for loop:
-/// `for pat in arg { body }` becomes `(pat, arg, body)`.
+/// Recover the essential nodes of a desugared for loop as well as the entire span:
+/// `for pat in arg { body }` becomes `(pat, arg, body)`. Return `(pat, arg, body, span)`.
 pub fn for_loop<'tcx>(
     expr: &'tcx hir::Expr<'tcx>,
-) -> Option<(&hir::Pat<'_>, &'tcx hir::Expr<'tcx>, &'tcx hir::Expr<'tcx>)> {
+) -> Option<(&hir::Pat<'_>, &'tcx hir::Expr<'tcx>, &'tcx hir::Expr<'tcx>, Span)> {
     if_chain! {
         if let hir::ExprKind::Match(ref iterexpr, ref arms, hir::MatchSource::ForLoopDesugar) = expr.kind;
         if let hir::ExprKind::Call(_, ref iterargs) = iterexpr.kind;
@@ -148,7 +149,7 @@ pub fn for_loop<'tcx>(
         if let hir::StmtKind::Local(ref local) = let_stmt.kind;
         if let hir::StmtKind::Expr(ref expr) = body.kind;
         then {
-            return Some((&*local.pat, &iterargs[0], expr));
+            return Some((&*local.pat, &iterargs[0], expr, arms[0].span));
         }
     }
     None
diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs
index 822863ca3e2..b3eae933062 100644
--- a/clippy_lints/src/utils/internal_lints.rs
+++ b/clippy_lints/src/utils/internal_lints.rs
@@ -841,15 +841,13 @@ pub fn check_path(cx: &LateContext<'_>, path: &[&str]) -> bool {
     // implementations of native types. Check lang items.
     let path_syms: Vec<_> = path.iter().map(|p| Symbol::intern(p)).collect();
     let lang_items = cx.tcx.lang_items();
-    for lang_item in lang_items.items() {
-        if let Some(def_id) = lang_item {
-            let lang_item_path = cx.get_def_path(*def_id);
-            if path_syms.starts_with(&lang_item_path) {
-                if let [item] = &path_syms[lang_item_path.len()..] {
-                    for child in cx.tcx.item_children(*def_id) {
-                        if child.ident.name == *item {
-                            return true;
-                        }
+    for item_def_id in lang_items.items().iter().flatten() {
+        let lang_item_path = cx.get_def_path(*item_def_id);
+        if path_syms.starts_with(&lang_item_path) {
+            if let [item] = &path_syms[lang_item_path.len()..] {
+                for child in cx.tcx.item_children(*item_def_id) {
+                    if child.ident.name == *item {
+                        return true;
                     }
                 }
             }
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index d0db3a67533..3390c71dd8e 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -37,7 +37,7 @@ use rustc_ast::ast::{self, Attribute, LitKind};
 use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
-use rustc_hir::def::{DefKind, Res};
+use rustc_hir::def::{CtorKind, CtorOf, DefKind, Res};
 use rustc_hir::def_id::{DefId, LOCAL_CRATE};
 use rustc_hir::intravisit::{self, NestedVisitorMap, Visitor};
 use rustc_hir::Node;
@@ -50,7 +50,7 @@ use rustc_lint::{LateContext, Level, Lint, LintContext};
 use rustc_middle::hir::exports::Export;
 use rustc_middle::hir::map::Map;
 use rustc_middle::ty::subst::{GenericArg, GenericArgKind};
-use rustc_middle::ty::{self, layout::IntegerExt, Ty, TyCtxt, TypeFoldable};
+use rustc_middle::ty::{self, layout::IntegerExt, DefIdTree, Ty, TyCtxt, TypeFoldable};
 use rustc_semver::RustcVersion;
 use rustc_session::Session;
 use rustc_span::hygiene::{ExpnKind, MacroKind};
@@ -1700,6 +1700,30 @@ pub fn is_hir_ty_cfg_dependant(cx: &LateContext<'_>, ty: &hir::Ty<'_>) -> bool {
     }
 }
 
+/// Check if the resolution of a given path is an `Ok` variant of `Result`.
+pub fn is_ok_ctor(cx: &LateContext<'_>, res: Res) -> bool {
+    if let Some(ok_id) = cx.tcx.lang_items().result_ok_variant() {
+        if let Res::Def(DefKind::Ctor(CtorOf::Variant, CtorKind::Fn), id) = res {
+            if let Some(variant_id) = cx.tcx.parent(id) {
+                return variant_id == ok_id;
+            }
+        }
+    }
+    false
+}
+
+/// Check if the resolution of a given path is a `Some` variant of `Option`.
+pub fn is_some_ctor(cx: &LateContext<'_>, res: Res) -> bool {
+    if let Some(some_id) = cx.tcx.lang_items().option_some_variant() {
+        if let Res::Def(DefKind::Ctor(CtorOf::Variant, CtorKind::Fn), id) = res {
+            if let Some(variant_id) = cx.tcx.parent(id) {
+                return variant_id == some_id;
+            }
+        }
+    }
+    false
+}
+
 #[cfg(test)]
 mod test {
     use super::{reindent_multiline, without_block_comments};
diff --git a/clippy_lints/src/vec.rs b/clippy_lints/src/vec.rs
index 149cceb39dd..c132e4de4f6 100644
--- a/clippy_lints/src/vec.rs
+++ b/clippy_lints/src/vec.rs
@@ -55,7 +55,7 @@ impl<'tcx> LateLintPass<'tcx> for UselessVec {
 
         // search for `for _ in vec![…]`
         if_chain! {
-            if let Some((_, arg, _)) = higher::for_loop(expr);
+            if let Some((_, arg, _, _)) = higher::for_loop(expr);
             if let Some(vec_args) = higher::vec_macro(cx, arg);
             if is_copy(cx, vec_type(cx.typeck_results().expr_ty_adjusted(arg)));
             then {
diff --git a/tests/ui/for_loops_over_options_or_results.rs b/tests/ui/for_loops_over_options_or_results.rs
deleted file mode 100644
index 02e24b250f7..00000000000
--- a/tests/ui/for_loops_over_options_or_results.rs
+++ /dev/null
@@ -1,31 +0,0 @@
-#![warn(clippy::for_loops_over_options_or_results)]
-
-fn main() {
-    let x = vec![Some(1), Some(2), Some(3)];
-    for n in x {
-        if let Some(n) = n {
-            println!("{}", n);
-        }
-    }
-
-    let y: Vec<Result<i32, i32>> = vec![];
-    for n in y.clone() {
-        if let Ok(n) = n {
-            println!("{}", n);
-        }
-    }
-
-    // This should not trigger the lint
-    for n in y.clone() {
-        if let Ok(n) = n {
-            println!("{}", n);
-        } else {
-            println!("Oops!");
-        }
-    }
-
-    // This should not trigger the lint
-    for n in vec![Some(1), Some(2), Some(3)].iter().flatten() {
-        println!("{}", n);
-    }
-}
diff --git a/tests/ui/manual_flatten.rs b/tests/ui/manual_flatten.rs
new file mode 100644
index 00000000000..f183ceecdd8
--- /dev/null
+++ b/tests/ui/manual_flatten.rs
@@ -0,0 +1,54 @@
+#![warn(clippy::manual_flatten)]
+
+fn main() {
+    let x = vec![Some(1), Some(2), Some(3)];
+    for n in x {
+        if let Some(n) = n {
+            println!("{}", n);
+        }
+    }
+
+    let y: Vec<Result<i32, i32>> = vec![];
+    for n in y.clone() {
+        if let Ok(n) = n {
+            println!("{}", n);
+        }
+    }
+
+    let z = vec![Some(1), Some(2), Some(3)];
+    let z = z.iter();
+    for n in z {
+        if let Some(n) = n {
+            println!("{}", n);
+        }
+    }
+
+    // Using the `None` variant should not trigger the lint
+    let z = vec![Some(1), Some(2), Some(3)];
+    for n in z {
+        if n.is_none() {
+            println!("Nada.");
+        }
+    }
+
+    // Using the `Err` variant should not trigger the lint
+    for n in y.clone() {
+        if let Err(e) = n {
+            println!("Oops: {}!", e);
+        }
+    }
+
+    // Having an else clause should not trigger the lint
+    for n in y.clone() {
+        if let Ok(n) = n {
+            println!("{}", n);
+        } else {
+            println!("Oops!");
+        }
+    }
+
+    // Using manual flatten should not trigger the lint
+    for n in vec![Some(1), Some(2), Some(3)].iter().flatten() {
+        println!("{}", n);
+    }
+}
diff --git a/tests/ui/manual_flatten.stderr b/tests/ui/manual_flatten.stderr
new file mode 100644
index 00000000000..cf99a2d9ab1
--- /dev/null
+++ b/tests/ui/manual_flatten.stderr
@@ -0,0 +1,51 @@
+error: Unnecessary `if let` since only the `Some` variant of the iterator element is used.
+  --> $DIR/manual_flatten.rs:5:5
+   |
+LL | /     for n in x {
+LL | |         if let Some(n) = n {
+LL | |             println!("{}", n);
+LL | |         }
+LL | |     }
+   | |_____^
+   |
+   = note: `-D clippy::manual-flatten` implied by `-D warnings`
+help: try: `x.into_iter().flatten()`
+  --> $DIR/manual_flatten.rs:5:14
+   |
+LL |     for n in x {
+   |              ^
+
+error: Unnecessary `if let` since only the `Ok` variant of the iterator element is used.
+  --> $DIR/manual_flatten.rs:12:5
+   |
+LL | /     for n in y.clone() {
+LL | |         if let Ok(n) = n {
+LL | |             println!("{}", n);
+LL | |         }
+LL | |     }
+   | |_____^
+   |
+help: try: `y.clone().into_iter().flatten()`
+  --> $DIR/manual_flatten.rs:12:14
+   |
+LL |     for n in y.clone() {
+   |              ^^^^^^^^^
+
+error: Unnecessary `if let` since only the `Some` variant of the iterator element is used.
+  --> $DIR/manual_flatten.rs:20:5
+   |
+LL | /     for n in z {
+LL | |         if let Some(n) = n {
+LL | |             println!("{}", n);
+LL | |         }
+LL | |     }
+   | |_____^
+   |
+help: try: `z.flatten()`
+  --> $DIR/manual_flatten.rs:20:14
+   |
+LL |     for n in z {
+   |              ^
+
+error: aborting due to 3 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 7825bf36d8dfee0099a23eb74451783da3ce261f Mon Sep 17 00:00:00 2001
From: ThibsG <Thibs@debian.com>
Date: Sun, 31 Jan 2021 21:43:35 +0100
Subject: Fix suggestions that need parens

---
 clippy_lints/src/methods/mod.rs              |  9 +++++++--
 tests/ui/from_iter_instead_of_collect.rs     |  8 +++++++-
 tests/ui/from_iter_instead_of_collect.stderr | 14 +++++++++++++-
 3 files changed, 27 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 7a459a440ca..f53b2f67d1d 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -4094,14 +4094,19 @@ fn lint_from_iter(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::Expr<
         if implements_trait(cx, ty, from_iter_id, &[]) && implements_trait(cx, arg_ty, iter_id, &[]);
         then {
             // `expr` implements `FromIterator` trait
-            let iter_expr = snippet(cx, args[0].span, "..");
+            let iter_expr = sugg::Sugg::hir(cx, &args[0], "..").maybe_par();
+            let sugg = if higher::range(&args[0]).is_some() {
+                format!("{}.collect::<{}>()", iter_expr, ty)
+            } else {
+                format!("{}.collect()", iter_expr)
+            };
             span_lint_and_sugg(
                 cx,
                 FROM_ITER_INSTEAD_OF_COLLECT,
                 expr.span,
                 "usage of `FromIterator::from_iter`",
                 "use `.collect()` instead of `::from_iter()`",
-                format!("{}.collect()", iter_expr),
+                sugg,
                 Applicability::MaybeIncorrect,
             );
         }
diff --git a/tests/ui/from_iter_instead_of_collect.rs b/tests/ui/from_iter_instead_of_collect.rs
index 045eb3133d3..6c81366c4df 100644
--- a/tests/ui/from_iter_instead_of_collect.rs
+++ b/tests/ui/from_iter_instead_of_collect.rs
@@ -1,6 +1,6 @@
 #![warn(clippy::from_iter_instead_of_collect)]
 
-use std::collections::HashMap;
+use std::collections::{HashMap, VecDeque};
 use std::iter::FromIterator;
 
 fn main() {
@@ -10,4 +10,10 @@ fn main() {
     HashMap::<usize, &i8>::from_iter(vec![5, 5, 5, 5].iter().enumerate());
 
     Vec::from_iter(vec![42u32]);
+
+    let a = vec![0, 1, 2];
+    assert_eq!(a, Vec::from_iter(0..3));
+
+    let mut b = VecDeque::from_iter(0..3);
+    b.push_back(4);
 }
diff --git a/tests/ui/from_iter_instead_of_collect.stderr b/tests/ui/from_iter_instead_of_collect.stderr
index 46bdc2f4e19..e2161dd3b57 100644
--- a/tests/ui/from_iter_instead_of_collect.stderr
+++ b/tests/ui/from_iter_instead_of_collect.stderr
@@ -12,5 +12,17 @@ error: usage of `FromIterator::from_iter`
 LL |     HashMap::<usize, &i8>::from_iter(vec![5, 5, 5, 5].iter().enumerate());
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `vec![5, 5, 5, 5].iter().enumerate().collect()`
 
-error: aborting due to 2 previous errors
+error: usage of `FromIterator::from_iter`
+  --> $DIR/from_iter_instead_of_collect.rs:15:19
+   |
+LL |     assert_eq!(a, Vec::from_iter(0..3));
+   |                   ^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `(0..3).collect::<std::vec::Vec<i32>>()`
+
+error: usage of `FromIterator::from_iter`
+  --> $DIR/from_iter_instead_of_collect.rs:17:17
+   |
+LL |     let mut b = VecDeque::from_iter(0..3);
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `(0..3).collect::<std::collections::VecDeque<i32>>()`
+
+error: aborting due to 4 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 0fb09d6b218b005b90fe5b3f3d5346a2b707e19e Mon Sep 17 00:00:00 2001
From: Manish Goregaokar <manishsmail@gmail.com>
Date: Mon, 1 Feb 2021 18:38:43 -0800
Subject: exhaustive_structs: don't trigger for structs with private fields

---
 clippy_lints/src/exhaustive_items.rs | 10 +++++++---
 tests/ui/exhaustive_items.fixed      | 25 +++++++++++++++++--------
 tests/ui/exhaustive_items.rs         | 23 ++++++++++++++++-------
 tests/ui/exhaustive_items.stderr     |  4 ++--
 4 files changed, 42 insertions(+), 20 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/exhaustive_items.rs b/clippy_lints/src/exhaustive_items.rs
index 32b1299efce..e3988d0038c 100644
--- a/clippy_lints/src/exhaustive_items.rs
+++ b/clippy_lints/src/exhaustive_items.rs
@@ -75,10 +75,14 @@ impl LateLintPass<'_> for ExhaustiveItems {
             if cx.access_levels.is_exported(item.hir_id);
             if !item.attrs.iter().any(|a| a.has_name(sym::non_exhaustive));
             then {
-                let (lint, msg) = if let ItemKind::Enum(..) = item.kind {
-                    (EXHAUSTIVE_ENUMS, "exported enums should not be exhaustive")
-                } else {
+                let (lint, msg) = if let ItemKind::Struct(ref v, ..) = item.kind {
+                    if v.fields().iter().any(|f| !f.vis.node.is_pub()) {
+                        // skip structs with private fields
+                        return;
+                    }
                     (EXHAUSTIVE_STRUCTS, "exported structs should not be exhaustive")
+                } else {
+                    (EXHAUSTIVE_ENUMS, "exported enums should not be exhaustive")
                 };
                 let suggestion_span = item.span.shrink_to_lo();
                 let indent = " ".repeat(indent_of(cx, item.span).unwrap_or(0));
diff --git a/tests/ui/exhaustive_items.fixed b/tests/ui/exhaustive_items.fixed
index 8174a0175ab..383b3d85a66 100644
--- a/tests/ui/exhaustive_items.fixed
+++ b/tests/ui/exhaustive_items.fixed
@@ -56,27 +56,36 @@ pub mod enums {
 pub mod structs {
     #[non_exhaustive]
     pub struct Exhaustive {
-        foo: u8,
-        bar: String,
+        pub foo: u8,
+        pub bar: String,
     }
 
     // no warning, already non_exhaustive
     #[non_exhaustive]
     pub struct NonExhaustive {
-        foo: u8,
-        bar: String,
+        pub foo: u8,
+        pub bar: String,
+    }
+
+    // no warning, private fields
+    pub struct ExhaustivePrivateFieldTuple(u8);
+
+    // no warning, private fields
+    pub struct ExhaustivePrivateField {
+        pub foo: u8,
+        bar: String
     }
 
     // no warning, private
     struct ExhaustivePrivate {
-        foo: u8,
-        bar: String,
+        pub foo: u8,
+        pub bar: String,
     }
 
     // no warning, private
     #[non_exhaustive]
     struct NonExhaustivePrivate {
-        foo: u8,
-        bar: String,
+        pub foo: u8,
+        pub bar: String,
     }
 }
diff --git a/tests/ui/exhaustive_items.rs b/tests/ui/exhaustive_items.rs
index b476f09f8a0..6f59dbf2da5 100644
--- a/tests/ui/exhaustive_items.rs
+++ b/tests/ui/exhaustive_items.rs
@@ -53,27 +53,36 @@ pub mod enums {
 
 pub mod structs {
     pub struct Exhaustive {
-        foo: u8,
-        bar: String,
+        pub foo: u8,
+        pub bar: String,
     }
 
     // no warning, already non_exhaustive
     #[non_exhaustive]
     pub struct NonExhaustive {
-        foo: u8,
+        pub foo: u8,
+        pub bar: String,
+    }
+
+    // no warning, private fields
+    pub struct ExhaustivePrivateFieldTuple(u8);
+
+    // no warning, private fields
+    pub struct ExhaustivePrivateField {
+        pub foo: u8,
         bar: String,
     }
 
     // no warning, private
     struct ExhaustivePrivate {
-        foo: u8,
-        bar: String,
+        pub foo: u8,
+        pub bar: String,
     }
 
     // no warning, private
     #[non_exhaustive]
     struct NonExhaustivePrivate {
-        foo: u8,
-        bar: String,
+        pub foo: u8,
+        pub bar: String,
     }
 }
diff --git a/tests/ui/exhaustive_items.stderr b/tests/ui/exhaustive_items.stderr
index 7369fe75a4f..8fbab535a9b 100644
--- a/tests/ui/exhaustive_items.stderr
+++ b/tests/ui/exhaustive_items.stderr
@@ -41,8 +41,8 @@ error: exported structs should not be exhaustive
   --> $DIR/exhaustive_items.rs:55:5
    |
 LL | /     pub struct Exhaustive {
-LL | |         foo: u8,
-LL | |         bar: String,
+LL | |         pub foo: u8,
+LL | |         pub bar: String,
 LL | |     }
    | |_____^
    |
-- 
cgit 1.4.1-3-g733a5


From bde667af7e7d512978daff3bc2b540bb913bd6a1 Mon Sep 17 00:00:00 2001
From: Caden Haustein <code@brightlysalty.33mail.com>
Date: Wed, 30 Dec 2020 16:37:59 -0600
Subject: Add missing_panics_doc lint

---
 CHANGELOG.md                                    |   1 +
 clippy_dev/src/bless.rs                         |   3 +
 clippy_dev/src/lib.rs                           |  13 +++
 clippy_dev/src/ra_setup.rs                      |   3 +
 clippy_dev/src/serve.rs                         |   3 +
 clippy_lints/src/doc.rs                         | 125 +++++++++++++++++++++++-
 clippy_lints/src/lib.rs                         |   2 +
 clippy_lints/src/utils/diagnostics.rs           |   2 +-
 mini-macro/src/lib.rs                           |   3 +
 tests/ui/doc_panics.rs                          |  95 ++++++++++++++++++
 tests/ui/doc_panics.stderr                      |  67 +++++++++++++
 tests/ui/should_impl_trait/corner_cases.rs      |   3 +-
 tests/ui/should_impl_trait/method_list_1.rs     |   3 +-
 tests/ui/should_impl_trait/method_list_1.stderr |  28 +++---
 tests/ui/should_impl_trait/method_list_2.rs     |   3 +-
 tests/ui/should_impl_trait/method_list_2.stderr |  30 +++---
 16 files changed, 346 insertions(+), 38 deletions(-)
 create mode 100644 tests/ui/doc_panics.rs
 create mode 100644 tests/ui/doc_panics.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index dadb6832d1f..c1032204a22 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2079,6 +2079,7 @@ Released 2018-09-13
 [`missing_docs_in_private_items`]: https://rust-lang.github.io/rust-clippy/master/index.html#missing_docs_in_private_items
 [`missing_errors_doc`]: https://rust-lang.github.io/rust-clippy/master/index.html#missing_errors_doc
 [`missing_inline_in_public_items`]: https://rust-lang.github.io/rust-clippy/master/index.html#missing_inline_in_public_items
+[`missing_panics_doc`]: https://rust-lang.github.io/rust-clippy/master/index.html#missing_panics_doc
 [`missing_safety_doc`]: https://rust-lang.github.io/rust-clippy/master/index.html#missing_safety_doc
 [`mistyped_literal_suffixes`]: https://rust-lang.github.io/rust-clippy/master/index.html#mistyped_literal_suffixes
 [`mixed_case_hex_literals`]: https://rust-lang.github.io/rust-clippy/master/index.html#mixed_case_hex_literals
diff --git a/clippy_dev/src/bless.rs b/clippy_dev/src/bless.rs
index b877806946c..2a869e9d449 100644
--- a/clippy_dev/src/bless.rs
+++ b/clippy_dev/src/bless.rs
@@ -24,6 +24,9 @@ static CLIPPY_BUILD_TIME: SyncLazy<Option<std::time::SystemTime>> = SyncLazy::ne
     fs::metadata(path).ok()?.modified().ok()
 });
 
+/// # Panics
+///
+/// Panics if the path to a test file is broken
 pub fn bless(ignore_timestamp: bool) {
     let test_suite_dirs = [
         clippy_project_root().join("tests").join("ui"),
diff --git a/clippy_dev/src/lib.rs b/clippy_dev/src/lib.rs
index 24d70d433f3..01d1fc9211a 100644
--- a/clippy_dev/src/lib.rs
+++ b/clippy_dev/src/lib.rs
@@ -236,6 +236,10 @@ pub struct FileChange {
 /// `path` is the relative path to the file on which you want to perform the replacement.
 ///
 /// See `replace_region_in_text` for documentation of the other options.
+///
+/// # Panics
+///
+/// Panics if the path could not read or then written
 pub fn replace_region_in_file<F>(
     path: &Path,
     start: &str,
@@ -283,6 +287,10 @@ where
 ///     .new_lines;
 /// assert_eq!("replace_start\na different\ntext\nreplace_end", result);
 /// ```
+///
+/// # Panics
+///
+/// Panics if start or end is not valid regex
 pub fn replace_region_in_text<F>(text: &str, start: &str, end: &str, replace_start: bool, replacements: F) -> FileChange
 where
     F: FnOnce() -> Vec<String>,
@@ -329,6 +337,11 @@ where
 }
 
 /// Returns the path to the Clippy project directory
+///
+/// # Panics
+///
+/// Panics if the current directory could not be retrieved, there was an error reading any of the
+/// Cargo.toml files or ancestor directory is the clippy root directory
 #[must_use]
 pub fn clippy_project_root() -> PathBuf {
     let current_dir = std::env::current_dir().unwrap();
diff --git a/clippy_dev/src/ra_setup.rs b/clippy_dev/src/ra_setup.rs
index a8a6a2cb1bd..a3c329b578b 100644
--- a/clippy_dev/src/ra_setup.rs
+++ b/clippy_dev/src/ra_setup.rs
@@ -8,6 +8,9 @@ use std::path::{Path, PathBuf};
 // This allows rust analyzer to analyze rustc internals and show proper information inside clippy
 // code. See https://github.com/rust-analyzer/rust-analyzer/issues/3517 and https://github.com/rust-lang/rust-clippy/issues/5514 for details
 
+/// # Panics
+///
+/// Panics if `rustc_path` does not lead to a rustc repo or the files could not be read
 pub fn run(rustc_path: Option<&str>) {
     // we can unwrap here because the arg is required by clap
     let rustc_path = PathBuf::from(rustc_path.unwrap());
diff --git a/clippy_dev/src/serve.rs b/clippy_dev/src/serve.rs
index a46c0e4d3f0..faa94859601 100644
--- a/clippy_dev/src/serve.rs
+++ b/clippy_dev/src/serve.rs
@@ -4,6 +4,9 @@ use std::process::Command;
 use std::thread;
 use std::time::{Duration, SystemTime};
 
+/// # Panics
+///
+/// Panics if the python commands could not be spawned
 pub fn run(port: u16, lint: Option<&str>) -> ! {
     let mut url = Some(match lint {
         None => format!("http://localhost:{}", port),
diff --git a/clippy_lints/src/doc.rs b/clippy_lints/src/doc.rs
index 3a754f49917..b3e3635c1c1 100644
--- a/clippy_lints/src/doc.rs
+++ b/clippy_lints/src/doc.rs
@@ -1,4 +1,7 @@
-use crate::utils::{implements_trait, is_entrypoint_fn, is_type_diagnostic_item, return_ty, span_lint};
+use crate::utils::{
+    implements_trait, is_entrypoint_fn, is_type_diagnostic_item, match_panic_def_id, method_chain_args, return_ty,
+    span_lint, span_lint_and_note,
+};
 use if_chain::if_chain;
 use itertools::Itertools;
 use rustc_ast::ast::{Async, AttrKind, Attribute, FnRetTy, ItemKind};
@@ -8,7 +11,10 @@ use rustc_data_structures::sync::Lrc;
 use rustc_errors::emitter::EmitterWriter;
 use rustc_errors::Handler;
 use rustc_hir as hir;
+use rustc_hir::intravisit::{self, NestedVisitorMap, Visitor};
+use rustc_hir::{Expr, ExprKind, QPath};
 use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::hir::map::Map;
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty;
 use rustc_parse::maybe_new_parser_from_source_str;
@@ -122,6 +128,37 @@ declare_clippy_lint! {
     "`pub fn` returns `Result` without `# Errors` in doc comment"
 }
 
+declare_clippy_lint! {
+    /// **What it does:** Checks the doc comments of publicly visible functions that
+    /// may panic and warns if there is no `# Panics` section.
+    ///
+    /// **Why is this bad?** Documenting the scenarios in which panicking occurs
+    /// can help callers who do not want to panic to avoid those situations.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Examples:**
+    ///
+    /// Since the following function may panic it has a `# Panics` section in
+    /// its doc comment:
+    ///
+    /// ```rust
+    /// /// # Panics
+    /// ///
+    /// /// Will panic if y is 0
+    /// pub fn divide_by(x: i32, y: i32) -> i32 {
+    ///     if y == 0 {
+    ///         panic!("Cannot divide by 0")
+    ///     } else {
+    ///         x / y
+    ///     }
+    /// }
+    /// ```
+    pub MISSING_PANICS_DOC,
+    pedantic,
+    "`pub fn` may panic without `# Panics` in doc comment"
+}
+
 declare_clippy_lint! {
     /// **What it does:** Checks for `fn main() { .. }` in doctests
     ///
@@ -166,7 +203,9 @@ impl DocMarkdown {
     }
 }
 
-impl_lint_pass!(DocMarkdown => [DOC_MARKDOWN, MISSING_SAFETY_DOC, MISSING_ERRORS_DOC, NEEDLESS_DOCTEST_MAIN]);
+impl_lint_pass!(DocMarkdown =>
+    [DOC_MARKDOWN, MISSING_SAFETY_DOC, MISSING_ERRORS_DOC, MISSING_PANICS_DOC, NEEDLESS_DOCTEST_MAIN]
+);
 
 impl<'tcx> LateLintPass<'tcx> for DocMarkdown {
     fn check_crate(&mut self, cx: &LateContext<'tcx>, krate: &'tcx hir::Crate<'_>) {
@@ -180,7 +219,15 @@ impl<'tcx> LateLintPass<'tcx> for DocMarkdown {
                 if !(is_entrypoint_fn(cx, cx.tcx.hir().local_def_id(item.hir_id).to_def_id())
                     || in_external_macro(cx.tcx.sess, item.span))
                 {
-                    lint_for_missing_headers(cx, item.hir_id, item.span, sig, headers, Some(body_id));
+                    let body = cx.tcx.hir().body(body_id);
+                    let impl_item_def_id = cx.tcx.hir().local_def_id(item.hir_id);
+                    let mut fpu = FindPanicUnwrap {
+                        cx,
+                        typeck_results: cx.tcx.typeck(impl_item_def_id),
+                        panic_span: None,
+                    };
+                    fpu.visit_expr(&body.value);
+                    lint_for_missing_headers(cx, item.hir_id, item.span, sig, headers, Some(body_id), fpu.panic_span);
                 }
             },
             hir::ItemKind::Impl(ref impl_) => {
@@ -200,7 +247,7 @@ impl<'tcx> LateLintPass<'tcx> for DocMarkdown {
         let headers = check_attrs(cx, &self.valid_idents, &item.attrs);
         if let hir::TraitItemKind::Fn(ref sig, ..) = item.kind {
             if !in_external_macro(cx.tcx.sess, item.span) {
-                lint_for_missing_headers(cx, item.hir_id, item.span, sig, headers, None);
+                lint_for_missing_headers(cx, item.hir_id, item.span, sig, headers, None, None);
             }
         }
     }
@@ -211,7 +258,15 @@ impl<'tcx> LateLintPass<'tcx> for DocMarkdown {
             return;
         }
         if let hir::ImplItemKind::Fn(ref sig, body_id) = item.kind {
-            lint_for_missing_headers(cx, item.hir_id, item.span, sig, headers, Some(body_id));
+            let body = cx.tcx.hir().body(body_id);
+            let impl_item_def_id = cx.tcx.hir().local_def_id(item.hir_id);
+            let mut fpu = FindPanicUnwrap {
+                cx,
+                typeck_results: cx.tcx.typeck(impl_item_def_id),
+                panic_span: None,
+            };
+            fpu.visit_expr(&body.value);
+            lint_for_missing_headers(cx, item.hir_id, item.span, sig, headers, Some(body_id), fpu.panic_span);
         }
     }
 }
@@ -223,6 +278,7 @@ fn lint_for_missing_headers<'tcx>(
     sig: &hir::FnSig<'_>,
     headers: DocHeaders,
     body_id: Option<hir::BodyId>,
+    panic_span: Option<Span>,
 ) {
     if !cx.access_levels.is_exported(hir_id) {
         return; // Private functions do not require doc comments
@@ -235,6 +291,16 @@ fn lint_for_missing_headers<'tcx>(
             "unsafe function's docs miss `# Safety` section",
         );
     }
+    if !headers.panics && panic_span.is_some() {
+        span_lint_and_note(
+            cx,
+            MISSING_PANICS_DOC,
+            span,
+            "docs for function which may panic missing `# Panics` section",
+            panic_span,
+            "first possible panic found here",
+        );
+    }
     if !headers.errors {
         if is_type_diagnostic_item(cx, return_ty(cx, hir_id), sym::result_type) {
             span_lint(
@@ -321,6 +387,7 @@ pub fn strip_doc_comment_decoration(doc: &str, comment_kind: CommentKind, span:
 struct DocHeaders {
     safety: bool,
     errors: bool,
+    panics: bool,
 }
 
 fn check_attrs<'a>(cx: &LateContext<'_>, valid_idents: &FxHashSet<String>, attrs: &'a [Attribute]) -> DocHeaders {
@@ -338,6 +405,7 @@ fn check_attrs<'a>(cx: &LateContext<'_>, valid_idents: &FxHashSet<String>, attrs
             return DocHeaders {
                 safety: true,
                 errors: true,
+                panics: true,
             };
         }
     }
@@ -353,6 +421,7 @@ fn check_attrs<'a>(cx: &LateContext<'_>, valid_idents: &FxHashSet<String>, attrs
         return DocHeaders {
             safety: false,
             errors: false,
+            panics: false,
         };
     }
 
@@ -394,6 +463,7 @@ fn check_doc<'a, Events: Iterator<Item = (pulldown_cmark::Event<'a>, Range<usize
     let mut headers = DocHeaders {
         safety: false,
         errors: false,
+        panics: false,
     };
     let mut in_code = false;
     let mut in_link = None;
@@ -439,6 +509,7 @@ fn check_doc<'a, Events: Iterator<Item = (pulldown_cmark::Event<'a>, Range<usize
                 }
                 headers.safety |= in_heading && text.trim() == "Safety";
                 headers.errors |= in_heading && text.trim() == "Errors";
+                headers.panics |= in_heading && text.trim() == "Panics";
                 let index = match spans.binary_search_by(|c| c.0.cmp(&range.start)) {
                     Ok(o) => o,
                     Err(e) => e - 1,
@@ -607,3 +678,47 @@ fn check_word(cx: &LateContext<'_>, word: &str, span: Span) {
         );
     }
 }
+
+struct FindPanicUnwrap<'a, 'tcx> {
+    cx: &'a LateContext<'tcx>,
+    panic_span: Option<Span>,
+    typeck_results: &'tcx ty::TypeckResults<'tcx>,
+}
+
+impl<'a, 'tcx> Visitor<'tcx> for FindPanicUnwrap<'a, 'tcx> {
+    type Map = Map<'tcx>;
+
+    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
+        if self.panic_span.is_some() {
+            return;
+        }
+
+        // check for `begin_panic`
+        if_chain! {
+            if let ExprKind::Call(ref func_expr, _) = expr.kind;
+            if let ExprKind::Path(QPath::Resolved(_, ref path)) = func_expr.kind;
+            if let Some(path_def_id) = path.res.opt_def_id();
+            if match_panic_def_id(self.cx, path_def_id);
+            then {
+                self.panic_span = Some(expr.span);
+            }
+        }
+
+        // check for `unwrap`
+        if let Some(arglists) = method_chain_args(expr, &["unwrap"]) {
+            let reciever_ty = self.typeck_results.expr_ty(&arglists[0][0]).peel_refs();
+            if is_type_diagnostic_item(self.cx, reciever_ty, sym::option_type)
+                || is_type_diagnostic_item(self.cx, reciever_ty, sym::result_type)
+            {
+                self.panic_span = Some(expr.span);
+            }
+        }
+
+        // and check sub-expressions
+        intravisit::walk_expr(self, expr);
+    }
+
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::OnlyBodies(self.cx.tcx.hir())
+    }
+}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 54007c29c6c..5a40c00bd67 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -592,6 +592,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &disallowed_method::DISALLOWED_METHOD,
         &doc::DOC_MARKDOWN,
         &doc::MISSING_ERRORS_DOC,
+        &doc::MISSING_PANICS_DOC,
         &doc::MISSING_SAFETY_DOC,
         &doc::NEEDLESS_DOCTEST_MAIN,
         &double_comparison::DOUBLE_COMPARISONS,
@@ -1317,6 +1318,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&derive::UNSAFE_DERIVE_DESERIALIZE),
         LintId::of(&doc::DOC_MARKDOWN),
         LintId::of(&doc::MISSING_ERRORS_DOC),
+        LintId::of(&doc::MISSING_PANICS_DOC),
         LintId::of(&empty_enum::EMPTY_ENUM),
         LintId::of(&enum_variants::MODULE_NAME_REPETITIONS),
         LintId::of(&enum_variants::PUB_ENUM_VARIANT_NAMES),
diff --git a/clippy_lints/src/utils/diagnostics.rs b/clippy_lints/src/utils/diagnostics.rs
index 6caa04f651f..269be217c2d 100644
--- a/clippy_lints/src/utils/diagnostics.rs
+++ b/clippy_lints/src/utils/diagnostics.rs
@@ -110,7 +110,7 @@ pub fn span_lint_and_help<'a, T: LintContext>(
 pub fn span_lint_and_note<'a, T: LintContext>(
     cx: &'a T,
     lint: &'static Lint,
-    span: Span,
+    span: impl Into<MultiSpan>,
     msg: &str,
     note_span: Option<Span>,
     note: &str,
diff --git a/mini-macro/src/lib.rs b/mini-macro/src/lib.rs
index ba946563ec5..2b793589049 100644
--- a/mini-macro/src/lib.rs
+++ b/mini-macro/src/lib.rs
@@ -7,6 +7,9 @@ extern crate proc_macro;
 use proc_macro::{quote, TokenStream};
 
 #[proc_macro_derive(ClippyMiniMacroTest)]
+/// # Panics
+///
+/// Panics if the macro derivation fails
 pub fn mini_macro(_: TokenStream) -> TokenStream {
     quote!(
         #[allow(unused)]
diff --git a/tests/ui/doc_panics.rs b/tests/ui/doc_panics.rs
new file mode 100644
index 00000000000..7ef932f367b
--- /dev/null
+++ b/tests/ui/doc_panics.rs
@@ -0,0 +1,95 @@
+#![warn(clippy::missing_panics_doc)]
+#![allow(clippy::option_map_unit_fn)]
+
+fn main() {}
+
+/// This needs to be documented
+pub fn unwrap() {
+    let result = Err("Hi");
+    result.unwrap()
+}
+
+/// This needs to be documented
+pub fn panic() {
+    panic!("This function panics")
+}
+
+/// This needs to be documented
+pub fn todo() {
+    todo!()
+}
+
+/// This needs to be documented
+pub fn inner_body(opt: Option<u32>) {
+    opt.map(|x| {
+        if x == 10 {
+            panic!()
+        }
+    });
+}
+
+/// This is documented
+///
+/// # Panics
+///
+/// Panics if `result` if an error
+pub fn unwrap_documented() {
+    let result = Err("Hi");
+    result.unwrap()
+}
+
+/// This is documented
+///
+/// # Panics
+///
+/// Panics just because
+pub fn panic_documented() {
+    panic!("This function panics")
+}
+
+/// This is documented
+///
+/// # Panics
+///
+/// Panics if `opt` is Just(10)
+pub fn inner_body_documented(opt: Option<u32>) {
+    opt.map(|x| {
+        if x == 10 {
+            panic!()
+        }
+    });
+}
+
+/// This is documented
+///
+/// # Panics
+///
+/// We still need to do this part
+pub fn todo_documented() {
+    todo!()
+}
+
+/// This is okay because it is private
+fn unwrap_private() {
+    let result = Err("Hi");
+    result.unwrap()
+}
+
+/// This is okay because it is private
+fn panic_private() {
+    panic!("This function panics")
+}
+
+/// This is okay because it is private
+fn todo_private() {
+    todo!()
+}
+
+/// This is okay because it is private
+fn inner_body_private(opt: Option<u32>) {
+    opt.map(|x| {
+        if x == 10 {
+            panic!()
+        }
+    });
+}
diff --git a/tests/ui/doc_panics.stderr b/tests/ui/doc_panics.stderr
new file mode 100644
index 00000000000..c0c4e9e4fa7
--- /dev/null
+++ b/tests/ui/doc_panics.stderr
@@ -0,0 +1,67 @@
+error: docs for function which may panic missing `# Panics` section
+  --> $DIR/doc_panics.rs:7:1
+   |
+LL | / pub fn unwrap() {
+LL | |     let result = Err("Hi");
+LL | |     result.unwrap()
+LL | | }
+   | |_^
+   |
+   = note: `-D clippy::missing-panics-doc` implied by `-D warnings`
+note: first possible panic found here
+  --> $DIR/doc_panics.rs:9:5
+   |
+LL |     result.unwrap()
+   |     ^^^^^^^^^^^^^^^
+
+error: docs for function which may panic missing `# Panics` section
+  --> $DIR/doc_panics.rs:13:1
+   |
+LL | / pub fn panic() {
+LL | |     panic!("This function panics")
+LL | | }
+   | |_^
+   |
+note: first possible panic found here
+  --> $DIR/doc_panics.rs:14:5
+   |
+LL |     panic!("This function panics")
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: docs for function which may panic missing `# Panics` section
+  --> $DIR/doc_panics.rs:18:1
+   |
+LL | / pub fn todo() {
+LL | |     todo!()
+LL | | }
+   | |_^
+   |
+note: first possible panic found here
+  --> $DIR/doc_panics.rs:19:5
+   |
+LL |     todo!()
+   |     ^^^^^^^
+   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: docs for function which may panic missing `# Panics` section
+  --> $DIR/doc_panics.rs:23:1
+   |
+LL | / pub fn inner_body(opt: Option<u32>) {
+LL | |     opt.map(|x| {
+LL | |         if x == 10 {
+LL | |             panic!()
+LL | |         }
+LL | |     });
+LL | | }
+   | |_^
+   |
+note: first possible panic found here
+  --> $DIR/doc_panics.rs:26:13
+   |
+LL |             panic!()
+   |             ^^^^^^^^
+   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: aborting due to 4 previous errors
+
diff --git a/tests/ui/should_impl_trait/corner_cases.rs b/tests/ui/should_impl_trait/corner_cases.rs
index 6c5ffe6aba8..a7f8f54f2be 100644
--- a/tests/ui/should_impl_trait/corner_cases.rs
+++ b/tests/ui/should_impl_trait/corner_cases.rs
@@ -8,7 +8,8 @@
     clippy::unused_self,
     clippy::needless_lifetimes,
     clippy::missing_safety_doc,
-    clippy::wrong_self_convention
+    clippy::wrong_self_convention,
+    clippy::missing_panics_doc
 )]
 
 use std::ops::Mul;
diff --git a/tests/ui/should_impl_trait/method_list_1.rs b/tests/ui/should_impl_trait/method_list_1.rs
index f8d248fc98d..69a3390b03b 100644
--- a/tests/ui/should_impl_trait/method_list_1.rs
+++ b/tests/ui/should_impl_trait/method_list_1.rs
@@ -8,7 +8,8 @@
     clippy::unused_self,
     clippy::needless_lifetimes,
     clippy::missing_safety_doc,
-    clippy::wrong_self_convention
+    clippy::wrong_self_convention,
+    clippy::missing_panics_doc
 )]
 
 use std::ops::Mul;
diff --git a/tests/ui/should_impl_trait/method_list_1.stderr b/tests/ui/should_impl_trait/method_list_1.stderr
index 2b7d4628c3f..86c63946516 100644
--- a/tests/ui/should_impl_trait/method_list_1.stderr
+++ b/tests/ui/should_impl_trait/method_list_1.stderr
@@ -1,5 +1,5 @@
 error: method `add` can be confused for the standard trait method `std::ops::Add::add`
-  --> $DIR/method_list_1.rs:25:5
+  --> $DIR/method_list_1.rs:26:5
    |
 LL | /     pub fn add(self, other: T) -> T {
 LL | |         unimplemented!()
@@ -10,7 +10,7 @@ LL | |     }
    = help: consider implementing the trait `std::ops::Add` or choosing a less ambiguous method name
 
 error: method `as_mut` can be confused for the standard trait method `std::convert::AsMut::as_mut`
-  --> $DIR/method_list_1.rs:29:5
+  --> $DIR/method_list_1.rs:30:5
    |
 LL | /     pub fn as_mut(&mut self) -> &mut T {
 LL | |         unimplemented!()
@@ -20,7 +20,7 @@ LL | |     }
    = help: consider implementing the trait `std::convert::AsMut` or choosing a less ambiguous method name
 
 error: method `as_ref` can be confused for the standard trait method `std::convert::AsRef::as_ref`
-  --> $DIR/method_list_1.rs:33:5
+  --> $DIR/method_list_1.rs:34:5
    |
 LL | /     pub fn as_ref(&self) -> &T {
 LL | |         unimplemented!()
@@ -30,7 +30,7 @@ LL | |     }
    = help: consider implementing the trait `std::convert::AsRef` or choosing a less ambiguous method name
 
 error: method `bitand` can be confused for the standard trait method `std::ops::BitAnd::bitand`
-  --> $DIR/method_list_1.rs:37:5
+  --> $DIR/method_list_1.rs:38:5
    |
 LL | /     pub fn bitand(self, rhs: T) -> T {
 LL | |         unimplemented!()
@@ -40,7 +40,7 @@ LL | |     }
    = help: consider implementing the trait `std::ops::BitAnd` or choosing a less ambiguous method name
 
 error: method `bitor` can be confused for the standard trait method `std::ops::BitOr::bitor`
-  --> $DIR/method_list_1.rs:41:5
+  --> $DIR/method_list_1.rs:42:5
    |
 LL | /     pub fn bitor(self, rhs: Self) -> Self {
 LL | |         unimplemented!()
@@ -50,7 +50,7 @@ LL | |     }
    = help: consider implementing the trait `std::ops::BitOr` or choosing a less ambiguous method name
 
 error: method `bitxor` can be confused for the standard trait method `std::ops::BitXor::bitxor`
-  --> $DIR/method_list_1.rs:45:5
+  --> $DIR/method_list_1.rs:46:5
    |
 LL | /     pub fn bitxor(self, rhs: Self) -> Self {
 LL | |         unimplemented!()
@@ -60,7 +60,7 @@ LL | |     }
    = help: consider implementing the trait `std::ops::BitXor` or choosing a less ambiguous method name
 
 error: method `borrow` can be confused for the standard trait method `std::borrow::Borrow::borrow`
-  --> $DIR/method_list_1.rs:49:5
+  --> $DIR/method_list_1.rs:50:5
    |
 LL | /     pub fn borrow(&self) -> &str {
 LL | |         unimplemented!()
@@ -70,7 +70,7 @@ LL | |     }
    = help: consider implementing the trait `std::borrow::Borrow` or choosing a less ambiguous method name
 
 error: method `borrow_mut` can be confused for the standard trait method `std::borrow::BorrowMut::borrow_mut`
-  --> $DIR/method_list_1.rs:53:5
+  --> $DIR/method_list_1.rs:54:5
    |
 LL | /     pub fn borrow_mut(&mut self) -> &mut str {
 LL | |         unimplemented!()
@@ -80,7 +80,7 @@ LL | |     }
    = help: consider implementing the trait `std::borrow::BorrowMut` or choosing a less ambiguous method name
 
 error: method `clone` can be confused for the standard trait method `std::clone::Clone::clone`
-  --> $DIR/method_list_1.rs:57:5
+  --> $DIR/method_list_1.rs:58:5
    |
 LL | /     pub fn clone(&self) -> Self {
 LL | |         unimplemented!()
@@ -90,7 +90,7 @@ LL | |     }
    = help: consider implementing the trait `std::clone::Clone` or choosing a less ambiguous method name
 
 error: method `cmp` can be confused for the standard trait method `std::cmp::Ord::cmp`
-  --> $DIR/method_list_1.rs:61:5
+  --> $DIR/method_list_1.rs:62:5
    |
 LL | /     pub fn cmp(&self, other: &Self) -> Self {
 LL | |         unimplemented!()
@@ -100,7 +100,7 @@ LL | |     }
    = help: consider implementing the trait `std::cmp::Ord` or choosing a less ambiguous method name
 
 error: method `deref` can be confused for the standard trait method `std::ops::Deref::deref`
-  --> $DIR/method_list_1.rs:69:5
+  --> $DIR/method_list_1.rs:70:5
    |
 LL | /     pub fn deref(&self) -> &Self {
 LL | |         unimplemented!()
@@ -110,7 +110,7 @@ LL | |     }
    = help: consider implementing the trait `std::ops::Deref` or choosing a less ambiguous method name
 
 error: method `deref_mut` can be confused for the standard trait method `std::ops::DerefMut::deref_mut`
-  --> $DIR/method_list_1.rs:73:5
+  --> $DIR/method_list_1.rs:74:5
    |
 LL | /     pub fn deref_mut(&mut self) -> &mut Self {
 LL | |         unimplemented!()
@@ -120,7 +120,7 @@ LL | |     }
    = help: consider implementing the trait `std::ops::DerefMut` or choosing a less ambiguous method name
 
 error: method `div` can be confused for the standard trait method `std::ops::Div::div`
-  --> $DIR/method_list_1.rs:77:5
+  --> $DIR/method_list_1.rs:78:5
    |
 LL | /     pub fn div(self, rhs: Self) -> Self {
 LL | |         unimplemented!()
@@ -130,7 +130,7 @@ LL | |     }
    = help: consider implementing the trait `std::ops::Div` or choosing a less ambiguous method name
 
 error: method `drop` can be confused for the standard trait method `std::ops::Drop::drop`
-  --> $DIR/method_list_1.rs:81:5
+  --> $DIR/method_list_1.rs:82:5
    |
 LL | /     pub fn drop(&mut self) {
 LL | |         unimplemented!()
diff --git a/tests/ui/should_impl_trait/method_list_2.rs b/tests/ui/should_impl_trait/method_list_2.rs
index ed5e0d384bf..2cdc1a06fe6 100644
--- a/tests/ui/should_impl_trait/method_list_2.rs
+++ b/tests/ui/should_impl_trait/method_list_2.rs
@@ -8,7 +8,8 @@
     clippy::unused_self,
     clippy::needless_lifetimes,
     clippy::missing_safety_doc,
-    clippy::wrong_self_convention
+    clippy::wrong_self_convention,
+    clippy::missing_panics_doc
 )]
 
 use std::ops::Mul;
diff --git a/tests/ui/should_impl_trait/method_list_2.stderr b/tests/ui/should_impl_trait/method_list_2.stderr
index b6fd4356956..0142e299108 100644
--- a/tests/ui/should_impl_trait/method_list_2.stderr
+++ b/tests/ui/should_impl_trait/method_list_2.stderr
@@ -1,5 +1,5 @@
 error: method `eq` can be confused for the standard trait method `std::cmp::PartialEq::eq`
-  --> $DIR/method_list_2.rs:26:5
+  --> $DIR/method_list_2.rs:27:5
    |
 LL | /     pub fn eq(&self, other: &Self) -> bool {
 LL | |         unimplemented!()
@@ -10,7 +10,7 @@ LL | |     }
    = help: consider implementing the trait `std::cmp::PartialEq` or choosing a less ambiguous method name
 
 error: method `from_iter` can be confused for the standard trait method `std::iter::FromIterator::from_iter`
-  --> $DIR/method_list_2.rs:30:5
+  --> $DIR/method_list_2.rs:31:5
    |
 LL | /     pub fn from_iter<T>(iter: T) -> Self {
 LL | |         unimplemented!()
@@ -20,7 +20,7 @@ LL | |     }
    = help: consider implementing the trait `std::iter::FromIterator` or choosing a less ambiguous method name
 
 error: method `from_str` can be confused for the standard trait method `std::str::FromStr::from_str`
-  --> $DIR/method_list_2.rs:34:5
+  --> $DIR/method_list_2.rs:35:5
    |
 LL | /     pub fn from_str(s: &str) -> Result<Self, Self> {
 LL | |         unimplemented!()
@@ -30,7 +30,7 @@ LL | |     }
    = help: consider implementing the trait `std::str::FromStr` or choosing a less ambiguous method name
 
 error: method `hash` can be confused for the standard trait method `std::hash::Hash::hash`
-  --> $DIR/method_list_2.rs:38:5
+  --> $DIR/method_list_2.rs:39:5
    |
 LL | /     pub fn hash(&self, state: &mut T) {
 LL | |         unimplemented!()
@@ -40,7 +40,7 @@ LL | |     }
    = help: consider implementing the trait `std::hash::Hash` or choosing a less ambiguous method name
 
 error: method `index` can be confused for the standard trait method `std::ops::Index::index`
-  --> $DIR/method_list_2.rs:42:5
+  --> $DIR/method_list_2.rs:43:5
    |
 LL | /     pub fn index(&self, index: usize) -> &Self {
 LL | |         unimplemented!()
@@ -50,7 +50,7 @@ LL | |     }
    = help: consider implementing the trait `std::ops::Index` or choosing a less ambiguous method name
 
 error: method `index_mut` can be confused for the standard trait method `std::ops::IndexMut::index_mut`
-  --> $DIR/method_list_2.rs:46:5
+  --> $DIR/method_list_2.rs:47:5
    |
 LL | /     pub fn index_mut(&mut self, index: usize) -> &mut Self {
 LL | |         unimplemented!()
@@ -60,7 +60,7 @@ LL | |     }
    = help: consider implementing the trait `std::ops::IndexMut` or choosing a less ambiguous method name
 
 error: method `into_iter` can be confused for the standard trait method `std::iter::IntoIterator::into_iter`
-  --> $DIR/method_list_2.rs:50:5
+  --> $DIR/method_list_2.rs:51:5
    |
 LL | /     pub fn into_iter(self) -> Self {
 LL | |         unimplemented!()
@@ -70,7 +70,7 @@ LL | |     }
    = help: consider implementing the trait `std::iter::IntoIterator` or choosing a less ambiguous method name
 
 error: method `mul` can be confused for the standard trait method `std::ops::Mul::mul`
-  --> $DIR/method_list_2.rs:54:5
+  --> $DIR/method_list_2.rs:55:5
    |
 LL | /     pub fn mul(self, rhs: Self) -> Self {
 LL | |         unimplemented!()
@@ -80,7 +80,7 @@ LL | |     }
    = help: consider implementing the trait `std::ops::Mul` or choosing a less ambiguous method name
 
 error: method `neg` can be confused for the standard trait method `std::ops::Neg::neg`
-  --> $DIR/method_list_2.rs:58:5
+  --> $DIR/method_list_2.rs:59:5
    |
 LL | /     pub fn neg(self) -> Self {
 LL | |         unimplemented!()
@@ -90,7 +90,7 @@ LL | |     }
    = help: consider implementing the trait `std::ops::Neg` or choosing a less ambiguous method name
 
 error: method `next` can be confused for the standard trait method `std::iter::Iterator::next`
-  --> $DIR/method_list_2.rs:62:5
+  --> $DIR/method_list_2.rs:63:5
    |
 LL | /     pub fn next(&mut self) -> Option<Self> {
 LL | |         unimplemented!()
@@ -100,7 +100,7 @@ LL | |     }
    = help: consider implementing the trait `std::iter::Iterator` or choosing a less ambiguous method name
 
 error: method `not` can be confused for the standard trait method `std::ops::Not::not`
-  --> $DIR/method_list_2.rs:66:5
+  --> $DIR/method_list_2.rs:67:5
    |
 LL | /     pub fn not(self) -> Self {
 LL | |         unimplemented!()
@@ -110,7 +110,7 @@ LL | |     }
    = help: consider implementing the trait `std::ops::Not` or choosing a less ambiguous method name
 
 error: method `rem` can be confused for the standard trait method `std::ops::Rem::rem`
-  --> $DIR/method_list_2.rs:70:5
+  --> $DIR/method_list_2.rs:71:5
    |
 LL | /     pub fn rem(self, rhs: Self) -> Self {
 LL | |         unimplemented!()
@@ -120,7 +120,7 @@ LL | |     }
    = help: consider implementing the trait `std::ops::Rem` or choosing a less ambiguous method name
 
 error: method `shl` can be confused for the standard trait method `std::ops::Shl::shl`
-  --> $DIR/method_list_2.rs:74:5
+  --> $DIR/method_list_2.rs:75:5
    |
 LL | /     pub fn shl(self, rhs: Self) -> Self {
 LL | |         unimplemented!()
@@ -130,7 +130,7 @@ LL | |     }
    = help: consider implementing the trait `std::ops::Shl` or choosing a less ambiguous method name
 
 error: method `shr` can be confused for the standard trait method `std::ops::Shr::shr`
-  --> $DIR/method_list_2.rs:78:5
+  --> $DIR/method_list_2.rs:79:5
    |
 LL | /     pub fn shr(self, rhs: Self) -> Self {
 LL | |         unimplemented!()
@@ -140,7 +140,7 @@ LL | |     }
    = help: consider implementing the trait `std::ops::Shr` or choosing a less ambiguous method name
 
 error: method `sub` can be confused for the standard trait method `std::ops::Sub::sub`
-  --> $DIR/method_list_2.rs:82:5
+  --> $DIR/method_list_2.rs:83:5
    |
 LL | /     pub fn sub(self, rhs: Self) -> Self {
 LL | |         unimplemented!()
-- 
cgit 1.4.1-3-g733a5


From e07cd5b6fe47b1e26f19a1bede7c2e4967cb46d7 Mon Sep 17 00:00:00 2001
From: nahuakang <kangnahua@gmail.com>
Date: Tue, 2 Feb 2021 19:04:20 +0100
Subject: Enhance manual flatten

---
 clippy_lints/src/loops.rs      | 112 ++++++++++++++++++++++++++---------------
 tests/ui/manual_flatten.rs     |  10 ++++
 tests/ui/manual_flatten.stderr |  47 ++++++++---------
 3 files changed, 101 insertions(+), 68 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index db5aec82e90..23dce283f28 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -1996,52 +1996,82 @@ fn check_manual_flatten<'tcx>(
     body: &'tcx Expr<'_>,
     span: Span,
 ) {
-    if_chain! {
-        // Ensure the `if let` statement is the only expression in the for-loop
-        if let ExprKind::Block(ref block, _) = body.kind;
-        if block.stmts.is_empty();
-        if let Some(inner_expr) = block.expr;
-        if let ExprKind::Match(
-            ref match_expr, ref match_arms, MatchSource::IfLetDesugar{ contains_else_clause: false }
-        ) = inner_expr.kind;
-        // Ensure match_expr in `if let` statement is the same as the pat from the for-loop
-        if let PatKind::Binding(_, pat_hir_id, _, _) = pat.kind;
-        if let ExprKind::Path(QPath::Resolved(None, match_expr_path)) = match_expr.kind;
-        if let Res::Local(match_expr_path_id) = match_expr_path.res;
-        if pat_hir_id == match_expr_path_id;
-        // Ensure the `if let` statement is for the `Some` variant of `Option` or the `Ok` variant of `Result`
-        if let PatKind::TupleStruct(QPath::Resolved(None, path), _, _) = match_arms[0].pat.kind;
-        if is_some_ctor(cx, path.res) || is_ok_ctor(cx, path.res);
-        let if_let_type = if is_some_ctor(cx, path.res) {
-            "Some"
+    if let ExprKind::Block(ref block, _) = body.kind {
+        // Ensure the `if let` statement is the only expression or statement in the for-loop
+        let inner_expr = if block.stmts.len() == 1 && block.expr.is_none() {
+            let match_stmt = &block.stmts[0];
+            if let StmtKind::Semi(inner_expr) = match_stmt.kind {
+                Some(inner_expr)
+            } else {
+                None
+            }
+        } else if block.stmts.is_empty() {
+            block.expr
         } else {
-            "Ok"
+            None
         };
-        // Determine if `arg` is `Iterator` or implicitly calls `into_iter`
-        let arg_ty = cx.typeck_results().expr_ty(arg);
-        if let Some(id) = get_trait_def_id(cx, &paths::ITERATOR);
-        if let is_iterator = implements_trait(cx, arg_ty, id, &[]);
 
-        then {
-            // Prepare the error message
-            let msg = format!("Unnecessary `if let` since only the `{}` variant of the iterator element is used.", if_let_type);
+        if_chain! {
+            if let Some(inner_expr) = inner_expr;
+            if let ExprKind::Match(
+                ref match_expr, ref match_arms, MatchSource::IfLetDesugar{ contains_else_clause: false }
+            ) = inner_expr.kind;
+            // Ensure match_expr in `if let` statement is the same as the pat from the for-loop
+            if let PatKind::Binding(_, pat_hir_id, _, _) = pat.kind;
+            if let ExprKind::Path(QPath::Resolved(None, match_expr_path)) = match_expr.kind;
+            if let Res::Local(match_expr_path_id) = match_expr_path.res;
+            if pat_hir_id == match_expr_path_id;
+            // Ensure the `if let` statement is for the `Some` variant of `Option` or the `Ok` variant of `Result`
+            if let PatKind::TupleStruct(QPath::Resolved(None, path), _, _) = match_arms[0].pat.kind;
+            let some_ctor = is_some_ctor(cx, path.res);
+            let ok_ctor = is_ok_ctor(cx, path.res);
+            if some_ctor || ok_ctor;
+            let if_let_type = if some_ctor { "Some" } else { "Ok" };
 
-            // Prepare the help message
-            let arg_snippet = snippet(cx, arg.span, "..");
-            let hint = if is_iterator {
-                format!("try: `{}.flatten()`", arg_snippet)
-            } else {
-                format!("try: `{}.into_iter().flatten()`", arg_snippet)
-            };
+            then {
+                // Prepare the error message
+                let msg = format!("unnecessary `if let` since only the `{}` variant of the iterator element is used", if_let_type);
 
-            span_lint_and_help(
-                cx,
-                MANUAL_FLATTEN,
-                span,
-                &msg,
-                Some(arg.span),
-                &hint,
-            );
+                // Prepare the help message
+                let mut applicability = Applicability::MaybeIncorrect;
+                let arg_snippet = snippet_with_applicability(
+                    cx,
+                    arg.span,
+                    "..",
+                    &mut applicability,
+                );
+                // Determine if `arg` is by reference, an `Iterator`, or implicitly adjusted with `into_iter`
+                let hint = match arg.kind {
+                    ExprKind::AddrOf(_, _, arg_expr) => {
+                        format!("{}.iter().flatten()", snippet(cx, arg_expr.span, ".."))
+                    },
+                    ExprKind::MethodCall(_, _, _, _) | ExprKind::Path(QPath::Resolved(None, _)) => {
+                        // Determine if `arg` is `Iterator` or implicitly calls `into_iter`
+                        let arg_ty = cx.typeck_results().expr_ty(arg);
+                        if let Some(id) = get_trait_def_id(cx, &paths::ITERATOR) {
+                            let is_iterator = implements_trait(cx, arg_ty, id, &[]);
+                            if is_iterator {
+                                format!("{}.flatten()", arg_snippet)
+                            } else {
+                                format!("{}.into_iter().flatten()", arg_snippet)
+                            }
+                        } else {
+                            return
+                        }
+                    },
+                    _ => return,
+                };
+
+                span_lint_and_sugg(
+                    cx,
+                    MANUAL_FLATTEN,
+                    span,
+                    &msg,
+                    "try",
+                    hint,
+                    applicability,
+                )
+            }
         }
     }
 }
diff --git a/tests/ui/manual_flatten.rs b/tests/ui/manual_flatten.rs
index f183ceecdd8..b97cceb66f8 100644
--- a/tests/ui/manual_flatten.rs
+++ b/tests/ui/manual_flatten.rs
@@ -1,6 +1,7 @@
 #![warn(clippy::manual_flatten)]
 
 fn main() {
+    // Test for loop over implicitly adjusted `Iterator` with `if let` expression
     let x = vec![Some(1), Some(2), Some(3)];
     for n in x {
         if let Some(n) = n {
@@ -8,13 +9,22 @@ fn main() {
         }
     }
 
+    // Test for loop over implicitly implicitly adjusted `Iterator` with `if let` statement
     let y: Vec<Result<i32, i32>> = vec![];
     for n in y.clone() {
+        if let Ok(n) = n {
+            println!("{}", n);
+        };
+    }
+
+    // Test for loop over by reference
+    for n in &y {
         if let Ok(n) = n {
             println!("{}", n);
         }
     }
 
+    // Test for loop over `Iterator` with `if let` expression
     let z = vec![Some(1), Some(2), Some(3)];
     let z = z.iter();
     for n in z {
diff --git a/tests/ui/manual_flatten.stderr b/tests/ui/manual_flatten.stderr
index cf99a2d9ab1..754921eb739 100644
--- a/tests/ui/manual_flatten.stderr
+++ b/tests/ui/manual_flatten.stderr
@@ -1,51 +1,44 @@
-error: Unnecessary `if let` since only the `Some` variant of the iterator element is used.
-  --> $DIR/manual_flatten.rs:5:5
+error: unnecessary `if let` since only the `Some` variant of the iterator element is used
+  --> $DIR/manual_flatten.rs:6:5
    |
 LL | /     for n in x {
 LL | |         if let Some(n) = n {
 LL | |             println!("{}", n);
 LL | |         }
 LL | |     }
-   | |_____^
+   | |_____^ help: try: `x.into_iter().flatten()`
    |
    = note: `-D clippy::manual-flatten` implied by `-D warnings`
-help: try: `x.into_iter().flatten()`
-  --> $DIR/manual_flatten.rs:5:14
-   |
-LL |     for n in x {
-   |              ^
 
-error: Unnecessary `if let` since only the `Ok` variant of the iterator element is used.
-  --> $DIR/manual_flatten.rs:12:5
+error: unnecessary `if let` since only the `Ok` variant of the iterator element is used
+  --> $DIR/manual_flatten.rs:14:5
    |
 LL | /     for n in y.clone() {
 LL | |         if let Ok(n) = n {
 LL | |             println!("{}", n);
-LL | |         }
+LL | |         };
 LL | |     }
-   | |_____^
-   |
-help: try: `y.clone().into_iter().flatten()`
-  --> $DIR/manual_flatten.rs:12:14
+   | |_____^ help: try: `y.clone().into_iter().flatten()`
+
+error: unnecessary `if let` since only the `Ok` variant of the iterator element is used
+  --> $DIR/manual_flatten.rs:21:5
    |
-LL |     for n in y.clone() {
-   |              ^^^^^^^^^
+LL | /     for n in &y {
+LL | |         if let Ok(n) = n {
+LL | |             println!("{}", n);
+LL | |         }
+LL | |     }
+   | |_____^ help: try: `y.iter().flatten()`
 
-error: Unnecessary `if let` since only the `Some` variant of the iterator element is used.
-  --> $DIR/manual_flatten.rs:20:5
+error: unnecessary `if let` since only the `Some` variant of the iterator element is used
+  --> $DIR/manual_flatten.rs:30:5
    |
 LL | /     for n in z {
 LL | |         if let Some(n) = n {
 LL | |             println!("{}", n);
 LL | |         }
 LL | |     }
-   | |_____^
-   |
-help: try: `z.flatten()`
-  --> $DIR/manual_flatten.rs:20:14
-   |
-LL |     for n in z {
-   |              ^
+   | |_____^ help: try: `z.flatten()`
 
-error: aborting due to 3 previous errors
+error: aborting due to 4 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From bfbc0835870f8bf6cde79a01dfe7de351dde14aa Mon Sep 17 00:00:00 2001
From: Pierre-Andre Gagnon <pagagnon@gmail.com>
Date: Tue, 2 Feb 2021 18:39:23 -0500
Subject: Fix for issue 6640

---
 clippy_lints/src/unnecessary_wraps.rs |  92 ++++++++++++++++++----------
 tests/ui/unnecessary_wraps.rs         |  28 +++++++++
 tests/ui/unnecessary_wraps.stderr     | 109 ++--------------------------------
 3 files changed, 93 insertions(+), 136 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unnecessary_wraps.rs b/clippy_lints/src/unnecessary_wraps.rs
index 8ac5dd696b7..eec76ce8b03 100644
--- a/clippy_lints/src/unnecessary_wraps.rs
+++ b/clippy_lints/src/unnecessary_wraps.rs
@@ -1,6 +1,6 @@
 use crate::utils::{
-    contains_return, in_macro, is_type_diagnostic_item, match_qpath, paths, return_ty, snippet, span_lint_and_then,
-    visitors::find_all_ret_expressions,
+    contains_return, in_macro, is_type_diagnostic_item, match_qpath, paths, return_ty, snippet, span_lint_and_sugg,
+    span_lint_and_then, visitors::find_all_ret_expressions,
 };
 use if_chain::if_chain;
 use rustc_errors::Applicability;
@@ -64,6 +64,7 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryWraps {
         span: Span,
         hir_id: HirId,
     ) {
+        // Abort if public function/method or closure.
         match fn_kind {
             FnKind::ItemFn(.., visibility, _) | FnKind::Method(.., Some(visibility), _) => {
                 if visibility.node.is_pub() {
@@ -74,6 +75,7 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryWraps {
             _ => (),
         }
 
+        // Abort if the method is implementing a trait or of it a trait method.
         if let Some(Node::Item(item)) = cx.tcx.hir().find(cx.tcx.hir().get_parent_node(hir_id)) {
             if matches!(
                 item.kind,
@@ -83,22 +85,43 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryWraps {
             }
         }
 
-        let (return_type, path) = if is_type_diagnostic_item(cx, return_ty(cx, hir_id), sym::option_type) {
+        // Check if return type is Option or Result. If neither, abort.
+        let return_ty = return_ty(cx, hir_id);
+        let (return_type_label, path) = if is_type_diagnostic_item(cx, return_ty, sym::option_type) {
             ("Option", &paths::OPTION_SOME)
-        } else if is_type_diagnostic_item(cx, return_ty(cx, hir_id), sym::result_type) {
+        } else if is_type_diagnostic_item(cx, return_ty, sym::result_type) {
             ("Result", &paths::RESULT_OK)
         } else {
             return;
         };
 
+        // Take the first inner type of the Option or Result. If can't, abort.
+        let inner_ty = if_chain! {
+            // Skip Option or Result and take the first outermost inner type.
+            if let Some(inner_ty) = return_ty.walk().nth(1);
+            if let GenericArgKind::Type(inner_ty) = inner_ty.unpack();
+            then {
+                inner_ty
+            } else {
+                return;
+            }
+        };
+
+        // Check if all return expression respect the following condition and collect them.
         let mut suggs = Vec::new();
         let can_sugg = find_all_ret_expressions(cx, &body.value, |ret_expr| {
             if_chain! {
+                // Abort if in macro.
                 if !in_macro(ret_expr.span);
+                // Check if a function call.
                 if let ExprKind::Call(ref func, ref args) = ret_expr.kind;
+                // Get the Path of the function call.
                 if let ExprKind::Path(ref qpath) = func.kind;
+                // Check if OPTION_SOME or RESULT_OK, depending on return type.
                 if match_qpath(qpath, path);
+                // Make sure the function call has only one argument.
                 if args.len() == 1;
+                // Make sure the function argument does not contain a return expression.
                 if !contains_return(&args[0]);
                 then {
                     suggs.push((ret_expr.span, snippet(cx, args[0].span.source_callsite(), "..").to_string()));
@@ -110,39 +133,42 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryWraps {
         });
 
         if can_sugg && !suggs.is_empty() {
-            span_lint_and_then(
-                cx,
-                UNNECESSARY_WRAPS,
-                span,
-                format!(
-                    "this function's return value is unnecessarily wrapped by `{}`",
-                    return_type
-                )
-                .as_str(),
-                |diag| {
-                    let inner_ty = return_ty(cx, hir_id)
-                        .walk()
-                        .skip(1) // skip `std::option::Option` or `std::result::Result`
-                        .take(1) // take the first outermost inner type
-                        .filter_map(|inner| match inner.unpack() {
-                            GenericArgKind::Type(inner_ty) => Some(inner_ty.to_string()),
-                            _ => None,
-                        });
-                    inner_ty.for_each(|inner_ty| {
+            // Issue 6640: If the inner type is Unit, emit lint similar to clippy::unused_unit.
+            if inner_ty.is_unit() {
+                span_lint_and_sugg(
+                    cx,
+                    UNNECESSARY_WRAPS,
+                    fn_decl.output.span(),
+                    "unneeded wrapped unit return type",
+                    format!("remove the `-> {}<()>`", return_type_label).as_str(),
+                    String::new(),
+                    Applicability::MaybeIncorrect,
+                );
+            } else {
+                span_lint_and_then(
+                    cx,
+                    UNNECESSARY_WRAPS,
+                    span,
+                    format!(
+                        "this function's return value is unnecessarily wrapped by `{}`",
+                        return_type_label
+                    )
+                    .as_str(),
+                    |diag| {
                         diag.span_suggestion(
                             fn_decl.output.span(),
-                            format!("remove `{}` from the return type...", return_type).as_str(),
-                            inner_ty,
+                            format!("remove `{}` from the return type...", return_type_label).as_str(),
+                            inner_ty.to_string(),
                             Applicability::MaybeIncorrect,
                         );
-                    });
-                    diag.multipart_suggestion(
-                        "...and change the returning expressions",
-                        suggs,
-                        Applicability::MaybeIncorrect,
-                    );
-                },
-            );
+                        diag.multipart_suggestion(
+                            "...and change the returning expressions",
+                            suggs,
+                            Applicability::MaybeIncorrect,
+                        );
+                    },
+                );
+            }
         }
     }
 }
diff --git a/tests/ui/unnecessary_wraps.rs b/tests/ui/unnecessary_wraps.rs
index a4570098d71..2d6aedc97ef 100644
--- a/tests/ui/unnecessary_wraps.rs
+++ b/tests/ui/unnecessary_wraps.rs
@@ -116,8 +116,36 @@ fn issue_6384(s: &str) -> Option<&str> {
     })
 }
 
+// should be linted
+fn issue_6640_1(a: bool, b: bool) -> Option<()> {
+    if a && b {
+        return Some(());
+    }
+    if a {
+        Some(());
+        Some(())
+    } else {
+        return Some(());
+    }
+}
+
+// should be linted
+fn issue_6640_2(a: bool, b: bool) -> Result<(), i32> {
+    if a && b {
+        return Ok(());
+    }
+    if a {
+        Ok(());
+        Ok(())
+    } else {
+        return Ok(());
+    }
+}
+
 fn main() {
     // method calls are not linted
     func1(true, true);
     func2(true, true);
+    issue_6640_1(true, true);
+    issue_6640_2(true, true);
 }
diff --git a/tests/ui/unnecessary_wraps.stderr b/tests/ui/unnecessary_wraps.stderr
index 410f054b8ef..3ca5a8d1702 100644
--- a/tests/ui/unnecessary_wraps.stderr
+++ b/tests/ui/unnecessary_wraps.stderr
@@ -1,106 +1,9 @@
-error: this function's return value is unnecessarily wrapped by `Option`
-  --> $DIR/unnecessary_wraps.rs:8:1
-   |
-LL | / fn func1(a: bool, b: bool) -> Option<i32> {
-LL | |     if a && b {
-LL | |         return Some(42);
-LL | |     }
-...  |
-LL | |     }
-LL | | }
-   | |_^
-   |
-   = note: `-D clippy::unnecessary-wraps` implied by `-D warnings`
-help: remove `Option` from the return type...
-   |
-LL | fn func1(a: bool, b: bool) -> i32 {
-   |                               ^^^
-help: ...and change the returning expressions
-   |
-LL |         return 42;
-LL |     }
-LL |     if a {
-LL |         Some(-1);
-LL |         2
-LL |     } else {
- ...
-
-error: this function's return value is unnecessarily wrapped by `Option`
-  --> $DIR/unnecessary_wraps.rs:21:1
-   |
-LL | / fn func2(a: bool, b: bool) -> Option<i32> {
-LL | |     if a && b {
-LL | |         return Some(10);
-LL | |     }
-...  |
-LL | |     }
-LL | | }
-   | |_^
-   |
-help: remove `Option` from the return type...
-   |
-LL | fn func2(a: bool, b: bool) -> i32 {
-   |                               ^^^
-help: ...and change the returning expressions
-   |
-LL |         return 10;
-LL |     }
-LL |     if a {
-LL |         20
-LL |     } else {
-LL |         30
-   |
-
-error: this function's return value is unnecessarily wrapped by `Option`
-  --> $DIR/unnecessary_wraps.rs:51:1
-   |
-LL | / fn func5() -> Option<i32> {
-LL | |     Some(1)
-LL | | }
-   | |_^
-   |
-help: remove `Option` from the return type...
-   |
-LL | fn func5() -> i32 {
-   |               ^^^
-help: ...and change the returning expressions
-   |
-LL |     1
-   |
-
-error: this function's return value is unnecessarily wrapped by `Result`
-  --> $DIR/unnecessary_wraps.rs:61:1
-   |
-LL | / fn func7() -> Result<i32, ()> {
-LL | |     Ok(1)
-LL | | }
-   | |_^
-   |
-help: remove `Result` from the return type...
-   |
-LL | fn func7() -> i32 {
-   |               ^^^
-help: ...and change the returning expressions
-   |
-LL |     1
-   |
-
-error: this function's return value is unnecessarily wrapped by `Option`
-  --> $DIR/unnecessary_wraps.rs:93:5
-   |
-LL | /     fn func12() -> Option<i32> {
-LL | |         Some(1)
-LL | |     }
-   | |_____^
-   |
-help: remove `Option` from the return type...
-   |
-LL |     fn func12() -> i32 {
-   |                    ^^^
-help: ...and change the returning expressions
-   |
-LL |         1
+error[E0282]: type annotations needed
+  --> $DIR/unnecessary_wraps.rs:138:9
    |
+LL |         Ok(());
+   |         ^^ cannot infer type for type parameter `E` declared on the enum `Result`
 
-error: aborting due to 5 previous errors
+error: aborting due to previous error
 
+For more information about this error, try `rustc --explain E0282`.
-- 
cgit 1.4.1-3-g733a5


From e0e51e418906916123b3bd15c175d80d3dc74bf2 Mon Sep 17 00:00:00 2001
From: Pierre-Andre Gagnon <pagagnon@gmail.com>
Date: Tue, 2 Feb 2021 19:14:13 -0500
Subject: Fixed test

---
 clippy_lints/src/unnecessary_wraps.rs |   2 +-
 tests/ui/unnecessary_wraps.rs         |   1 -
 tests/ui/unnecessary_wraps.stderr     | 121 ++++++++++++++++++++++++++++++++--
 3 files changed, 116 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unnecessary_wraps.rs b/clippy_lints/src/unnecessary_wraps.rs
index eec76ce8b03..7da42ba3934 100644
--- a/clippy_lints/src/unnecessary_wraps.rs
+++ b/clippy_lints/src/unnecessary_wraps.rs
@@ -140,7 +140,7 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryWraps {
                     UNNECESSARY_WRAPS,
                     fn_decl.output.span(),
                     "unneeded wrapped unit return type",
-                    format!("remove the `-> {}<()>`", return_type_label).as_str(),
+                    format!("remove the `-> {}<[...]>`", return_type_label).as_str(),
                     String::new(),
                     Applicability::MaybeIncorrect,
                 );
diff --git a/tests/ui/unnecessary_wraps.rs b/tests/ui/unnecessary_wraps.rs
index 2d6aedc97ef..5aaa99bbe5a 100644
--- a/tests/ui/unnecessary_wraps.rs
+++ b/tests/ui/unnecessary_wraps.rs
@@ -135,7 +135,6 @@ fn issue_6640_2(a: bool, b: bool) -> Result<(), i32> {
         return Ok(());
     }
     if a {
-        Ok(());
         Ok(())
     } else {
         return Ok(());
diff --git a/tests/ui/unnecessary_wraps.stderr b/tests/ui/unnecessary_wraps.stderr
index 3ca5a8d1702..f28981f9e34 100644
--- a/tests/ui/unnecessary_wraps.stderr
+++ b/tests/ui/unnecessary_wraps.stderr
@@ -1,9 +1,118 @@
-error[E0282]: type annotations needed
-  --> $DIR/unnecessary_wraps.rs:138:9
+error: this function's return value is unnecessarily wrapped by `Option`
+  --> $DIR/unnecessary_wraps.rs:8:1
    |
-LL |         Ok(());
-   |         ^^ cannot infer type for type parameter `E` declared on the enum `Result`
+LL | / fn func1(a: bool, b: bool) -> Option<i32> {
+LL | |     if a && b {
+LL | |         return Some(42);
+LL | |     }
+...  |
+LL | |     }
+LL | | }
+   | |_^
+   |
+   = note: `-D clippy::unnecessary-wraps` implied by `-D warnings`
+help: remove `Option` from the return type...
+   |
+LL | fn func1(a: bool, b: bool) -> i32 {
+   |                               ^^^
+help: ...and change the returning expressions
+   |
+LL |         return 42;
+LL |     }
+LL |     if a {
+LL |         Some(-1);
+LL |         2
+LL |     } else {
+ ...
+
+error: this function's return value is unnecessarily wrapped by `Option`
+  --> $DIR/unnecessary_wraps.rs:21:1
+   |
+LL | / fn func2(a: bool, b: bool) -> Option<i32> {
+LL | |     if a && b {
+LL | |         return Some(10);
+LL | |     }
+...  |
+LL | |     }
+LL | | }
+   | |_^
+   |
+help: remove `Option` from the return type...
+   |
+LL | fn func2(a: bool, b: bool) -> i32 {
+   |                               ^^^
+help: ...and change the returning expressions
+   |
+LL |         return 10;
+LL |     }
+LL |     if a {
+LL |         20
+LL |     } else {
+LL |         30
+   |
+
+error: this function's return value is unnecessarily wrapped by `Option`
+  --> $DIR/unnecessary_wraps.rs:51:1
+   |
+LL | / fn func5() -> Option<i32> {
+LL | |     Some(1)
+LL | | }
+   | |_^
+   |
+help: remove `Option` from the return type...
+   |
+LL | fn func5() -> i32 {
+   |               ^^^
+help: ...and change the returning expressions
+   |
+LL |     1
+   |
+
+error: this function's return value is unnecessarily wrapped by `Result`
+  --> $DIR/unnecessary_wraps.rs:61:1
+   |
+LL | / fn func7() -> Result<i32, ()> {
+LL | |     Ok(1)
+LL | | }
+   | |_^
+   |
+help: remove `Result` from the return type...
+   |
+LL | fn func7() -> i32 {
+   |               ^^^
+help: ...and change the returning expressions
+   |
+LL |     1
+   |
+
+error: this function's return value is unnecessarily wrapped by `Option`
+  --> $DIR/unnecessary_wraps.rs:93:5
+   |
+LL | /     fn func12() -> Option<i32> {
+LL | |         Some(1)
+LL | |     }
+   | |_____^
+   |
+help: remove `Option` from the return type...
+   |
+LL |     fn func12() -> i32 {
+   |                    ^^^
+help: ...and change the returning expressions
+   |
+LL |         1
+   |
+
+error: unneeded wrapped unit return type
+  --> $DIR/unnecessary_wraps.rs:120:38
+   |
+LL | fn issue_6640_1(a: bool, b: bool) -> Option<()> {
+   |                                      ^^^^^^^^^^ help: remove the `-> Option<[...]>`
+
+error: unneeded wrapped unit return type
+  --> $DIR/unnecessary_wraps.rs:133:38
+   |
+LL | fn issue_6640_2(a: bool, b: bool) -> Result<(), i32> {
+   |                                      ^^^^^^^^^^^^^^^ help: remove the `-> Result<[...]>`
 
-error: aborting due to previous error
+error: aborting due to 7 previous errors
 
-For more information about this error, try `rustc --explain E0282`.
-- 
cgit 1.4.1-3-g733a5


From 6fb10755c046ddc376efa27c396bc0e527059785 Mon Sep 17 00:00:00 2001
From: Manish Goregaokar <manishsmail@gmail.com>
Date: Tue, 2 Feb 2021 17:35:39 -0800
Subject: Rustup

---
 clippy_lints/src/write.rs | 6 +++---
 rust-toolchain            | 2 +-
 2 files changed, 4 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs
index 6358104eeda..04a0f6765c5 100644
--- a/clippy_lints/src/write.rs
+++ b/clippy_lints/src/write.rs
@@ -3,7 +3,7 @@ use std::ops::Range;
 
 use crate::utils::{snippet_with_applicability, span_lint, span_lint_and_sugg, span_lint_and_then};
 use if_chain::if_chain;
-use rustc_ast::ast::{Expr, ExprKind, Item, ItemKind, LitKind, MacCall, StrLit, StrStyle};
+use rustc_ast::ast::{Expr, ExprKind, ImplKind, Item, ItemKind, LitKind, MacCall, StrLit, StrStyle};
 use rustc_ast::token;
 use rustc_ast::tokenstream::TokenStream;
 use rustc_errors::Applicability;
@@ -231,10 +231,10 @@ impl_lint_pass!(Write => [
 
 impl EarlyLintPass for Write {
     fn check_item(&mut self, _: &EarlyContext<'_>, item: &Item) {
-        if let ItemKind::Impl {
+        if let ItemKind::Impl (box ImplKind {
             of_trait: Some(trait_ref),
             ..
-        } = &item.kind
+        }) = &item.kind
         {
             let trait_name = trait_ref
                 .path
diff --git a/rust-toolchain b/rust-toolchain
index f55d55d7065..b617203bef6 100644
--- a/rust-toolchain
+++ b/rust-toolchain
@@ -1,3 +1,3 @@
 [toolchain]
-channel = "nightly-2021-01-30"
+channel = "nightly-2021-02-03"
 components = ["llvm-tools-preview", "rustc-dev", "rust-src", "rustfmt"]
-- 
cgit 1.4.1-3-g733a5


From a31e5f5f3b300d200f7917e28f467437435b28c1 Mon Sep 17 00:00:00 2001
From: Manish Goregaokar <manishsmail@gmail.com>
Date: Tue, 2 Feb 2021 19:57:08 -0800
Subject: Run rustfmt

---
 clippy_lints/src/doc.rs                  |  4 +--
 clippy_lints/src/excessive_bools.rs      | 12 ++++-----
 clippy_lints/src/non_expressive_names.rs |  3 +--
 clippy_lints/src/utils/ast_utils.rs      | 45 +++++++++-----------------------
 clippy_lints/src/write.rs                |  2 +-
 5 files changed, 22 insertions(+), 44 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/doc.rs b/clippy_lints/src/doc.rs
index 75e71eb1e4c..1348f7530f4 100644
--- a/clippy_lints/src/doc.rs
+++ b/clippy_lints/src/doc.rs
@@ -563,9 +563,7 @@ fn check_code(cx: &LateContext<'_>, text: &str, edition: Edition, span: Span) {
                             | ItemKind::ExternCrate(..)
                             | ItemKind::ForeignMod(..) => return false,
                             // We found a main function ...
-                            ItemKind::Fn(box FnKind(_, sig, _, Some(block)))
-                                if item.ident.name == sym::main =>
-                            {
+                            ItemKind::Fn(box FnKind(_, sig, _, Some(block))) if item.ident.name == sym::main => {
                                 let is_async = matches!(sig.header.asyncness, Async::Yes { .. });
                                 let returns_nothing = match &sig.decl.output {
                                     FnRetTy::Default(..) => true,
diff --git a/clippy_lints/src/excessive_bools.rs b/clippy_lints/src/excessive_bools.rs
index fecde8e2743..6a85b57af07 100644
--- a/clippy_lints/src/excessive_bools.rs
+++ b/clippy_lints/src/excessive_bools.rs
@@ -1,7 +1,5 @@
 use crate::utils::{attr_by_name, in_macro, match_path_ast, span_lint_and_help};
-use rustc_ast::ast::{
-    AssocItemKind, Extern, FnKind, FnSig, ImplKind, Item, ItemKind, TraitKind, Ty, TyKind,
-};
+use rustc_ast::ast::{AssocItemKind, Extern, FnKind, FnSig, ImplKind, Item, ItemKind, TraitKind, Ty, TyKind};
 use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::Span;
@@ -160,15 +158,17 @@ impl EarlyLintPass for ExcessiveBools {
                         "consider using a state machine or refactoring bools into two-variant enums",
                     );
                 }
-            }
-            ItemKind::Impl(box ImplKind { of_trait: None, items, .. })
+            },
+            ItemKind::Impl(box ImplKind {
+                of_trait: None, items, ..
+            })
             | ItemKind::Trait(box TraitKind(.., items)) => {
                 for item in items {
                     if let AssocItemKind::Fn(box FnKind(_, fn_sig, _, _)) = &item.kind {
                         self.check_fn_sig(cx, fn_sig, item.span);
                     }
                 }
-            }
+            },
             ItemKind::Fn(box FnKind(_, fn_sig, _, _)) => self.check_fn_sig(cx, fn_sig, item.span),
             _ => (),
         }
diff --git a/clippy_lints/src/non_expressive_names.rs b/clippy_lints/src/non_expressive_names.rs
index d5222a030d7..7c74b316018 100644
--- a/clippy_lints/src/non_expressive_names.rs
+++ b/clippy_lints/src/non_expressive_names.rs
@@ -1,7 +1,6 @@
 use crate::utils::{span_lint, span_lint_and_then};
 use rustc_ast::ast::{
-    Arm, AssocItem, AssocItemKind, Attribute, Block, FnDecl, FnKind, Item, ItemKind, Local, Pat,
-    PatKind,
+    Arm, AssocItem, AssocItemKind, Attribute, Block, FnDecl, FnKind, Item, ItemKind, Local, Pat, PatKind,
 };
 use rustc_ast::visit::{walk_block, walk_expr, walk_pat, Visitor};
 use rustc_lint::{EarlyContext, EarlyLintPass};
diff --git a/clippy_lints/src/utils/ast_utils.rs b/clippy_lints/src/utils/ast_utils.rs
index 69492e84e4a..44eb3968ae7 100644
--- a/clippy_lints/src/utils/ast_utils.rs
+++ b/clippy_lints/src/utils/ast_utils.rs
@@ -229,25 +229,16 @@ pub fn eq_item_kind(l: &ItemKind, r: &ItemKind) -> bool {
     match (l, r) {
         (ExternCrate(l), ExternCrate(r)) => l == r,
         (Use(l), Use(r)) => eq_use_tree(l, r),
-        (Static(lt, lm, le), Static(rt, rm, re)) => {
-            lm == rm && eq_ty(lt, rt) && eq_expr_opt(le, re)
-        }
-        (Const(ld, lt, le), Const(rd, rt, re)) => {
-            eq_defaultness(*ld, *rd) && eq_ty(lt, rt) && eq_expr_opt(le, re)
-        }
+        (Static(lt, lm, le), Static(rt, rm, re)) => lm == rm && eq_ty(lt, rt) && eq_expr_opt(le, re),
+        (Const(ld, lt, le), Const(rd, rt, re)) => eq_defaultness(*ld, *rd) && eq_ty(lt, rt) && eq_expr_opt(le, re),
         (Fn(box FnKind(ld, lf, lg, lb)), Fn(box FnKind(rd, rf, rg, rb))) => {
-            eq_defaultness(*ld, *rd)
-                && eq_fn_sig(lf, rf)
-                && eq_generics(lg, rg)
-                && both(lb, rb, |l, r| eq_block(l, r))
-        }
-        (Mod(l), Mod(r)) => {
-            l.inline == r.inline && over(&l.items, &r.items, |l, r| eq_item(l, r, eq_item_kind))
-        }
+            eq_defaultness(*ld, *rd) && eq_fn_sig(lf, rf) && eq_generics(lg, rg) && both(lb, rb, |l, r| eq_block(l, r))
+        },
+        (Mod(l), Mod(r)) => l.inline == r.inline && over(&l.items, &r.items, |l, r| eq_item(l, r, eq_item_kind)),
         (ForeignMod(l), ForeignMod(r)) => {
             both(&l.abi, &r.abi, |l, r| eq_str_lit(l, r))
                 && over(&l.items, &r.items, |l, r| eq_item(l, r, eq_foreign_item_kind))
-        }
+        },
         (TyAlias(box TyAliasKind(ld, lg, lb, lt)), TyAlias(box TyAliasKind(rd, rg, rb, rt))) => {
             eq_defaultness(*ld, *rd)
                 && eq_generics(lg, rg)
@@ -259,7 +250,7 @@ pub fn eq_item_kind(l: &ItemKind, r: &ItemKind) -> bool {
         },
         (Struct(lv, lg), Struct(rv, rg)) | (Union(lv, lg), Union(rv, rg)) => {
             eq_variant_data(lv, rv) && eq_generics(lg, rg)
-        }
+        },
         (Trait(box TraitKind(la, lu, lg, lb, li)), Trait(box TraitKind(ra, ru, rg, rb, ri))) => {
             la == ra
                 && matches!(lu, Unsafe::No) == matches!(ru, Unsafe::No)
@@ -308,15 +299,10 @@ pub fn eq_item_kind(l: &ItemKind, r: &ItemKind) -> bool {
 pub fn eq_foreign_item_kind(l: &ForeignItemKind, r: &ForeignItemKind) -> bool {
     use ForeignItemKind::*;
     match (l, r) {
-        (Static(lt, lm, le), Static(rt, rm, re)) => {
-            lm == rm && eq_ty(lt, rt) && eq_expr_opt(le, re)
-        }
+        (Static(lt, lm, le), Static(rt, rm, re)) => lm == rm && eq_ty(lt, rt) && eq_expr_opt(le, re),
         (Fn(box FnKind(ld, lf, lg, lb)), Fn(box FnKind(rd, rf, rg, rb))) => {
-            eq_defaultness(*ld, *rd)
-                && eq_fn_sig(lf, rf)
-                && eq_generics(lg, rg)
-                && both(lb, rb, |l, r| eq_block(l, r))
-        }
+            eq_defaultness(*ld, *rd) && eq_fn_sig(lf, rf) && eq_generics(lg, rg) && both(lb, rb, |l, r| eq_block(l, r))
+        },
         (TyAlias(box TyAliasKind(ld, lg, lb, lt)), TyAlias(box TyAliasKind(rd, rg, rb, rt))) => {
             eq_defaultness(*ld, *rd)
                 && eq_generics(lg, rg)
@@ -331,15 +317,10 @@ pub fn eq_foreign_item_kind(l: &ForeignItemKind, r: &ForeignItemKind) -> bool {
 pub fn eq_assoc_item_kind(l: &AssocItemKind, r: &AssocItemKind) -> bool {
     use AssocItemKind::*;
     match (l, r) {
-        (Const(ld, lt, le), Const(rd, rt, re)) => {
-            eq_defaultness(*ld, *rd) && eq_ty(lt, rt) && eq_expr_opt(le, re)
-        }
+        (Const(ld, lt, le), Const(rd, rt, re)) => eq_defaultness(*ld, *rd) && eq_ty(lt, rt) && eq_expr_opt(le, re),
         (Fn(box FnKind(ld, lf, lg, lb)), Fn(box FnKind(rd, rf, rg, rb))) => {
-            eq_defaultness(*ld, *rd)
-                && eq_fn_sig(lf, rf)
-                && eq_generics(lg, rg)
-                && both(lb, rb, |l, r| eq_block(l, r))
-        }
+            eq_defaultness(*ld, *rd) && eq_fn_sig(lf, rf) && eq_generics(lg, rg) && both(lb, rb, |l, r| eq_block(l, r))
+        },
         (TyAlias(box TyAliasKind(ld, lg, lb, lt)), TyAlias(box TyAliasKind(rd, rg, rb, rt))) => {
             eq_defaultness(*ld, *rd)
                 && eq_generics(lg, rg)
diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs
index 04a0f6765c5..e40fdca6a99 100644
--- a/clippy_lints/src/write.rs
+++ b/clippy_lints/src/write.rs
@@ -231,7 +231,7 @@ impl_lint_pass!(Write => [
 
 impl EarlyLintPass for Write {
     fn check_item(&mut self, _: &EarlyContext<'_>, item: &Item) {
-        if let ItemKind::Impl (box ImplKind {
+        if let ItemKind::Impl(box ImplKind {
             of_trait: Some(trait_ref),
             ..
         }) = &item.kind
-- 
cgit 1.4.1-3-g733a5


From 0f5e71f8f2d42e3eac3e855a83d53899d4da6eb3 Mon Sep 17 00:00:00 2001
From: nahuakang <kangnahua@gmail.com>
Date: Wed, 3 Feb 2021 09:39:35 +0100
Subject: Add additional check on if arg type has iter method

---
 clippy_lints/src/loops.rs | 35 +++++++++++++++++------------------
 1 file changed, 17 insertions(+), 18 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 23dce283f28..5bfdc98bc6a 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -2041,25 +2041,24 @@ fn check_manual_flatten<'tcx>(
                     &mut applicability,
                 );
                 // Determine if `arg` is by reference, an `Iterator`, or implicitly adjusted with `into_iter`
-                let hint = match arg.kind {
-                    ExprKind::AddrOf(_, _, arg_expr) => {
+                let arg_ty = cx.typeck_results().expr_ty(arg);
+                let hint = if arg_ty.is_ref() {
+                    if has_iter_method(cx, arg_ty).is_none() {
+                        return;
+                    } else if let ExprKind::AddrOf(_, _, arg_expr) = arg.kind {
                         format!("{}.iter().flatten()", snippet(cx, arg_expr.span, ".."))
-                    },
-                    ExprKind::MethodCall(_, _, _, _) | ExprKind::Path(QPath::Resolved(None, _)) => {
-                        // Determine if `arg` is `Iterator` or implicitly calls `into_iter`
-                        let arg_ty = cx.typeck_results().expr_ty(arg);
-                        if let Some(id) = get_trait_def_id(cx, &paths::ITERATOR) {
-                            let is_iterator = implements_trait(cx, arg_ty, id, &[]);
-                            if is_iterator {
-                                format!("{}.flatten()", arg_snippet)
-                            } else {
-                                format!("{}.into_iter().flatten()", arg_snippet)
-                            }
-                        } else {
-                            return
-                        }
-                    },
-                    _ => return,
+                    } else {
+                        return;
+                    }
+                } else if let Some(id) = get_trait_def_id(cx, &paths::ITERATOR) {
+                    let is_iterator = implements_trait(cx, arg_ty, id, &[]);
+                    if is_iterator {
+                        format!("{}.flatten()", arg_snippet)
+                    } else {
+                        format!("{}.into_iter().flatten()", arg_snippet)
+                    }
+                } else {
+                    return
                 };
 
                 span_lint_and_sugg(
-- 
cgit 1.4.1-3-g733a5


From 78ef0f2f6c17f5933ab4dbab544b76f7da742467 Mon Sep 17 00:00:00 2001
From: nahuakang <kangnahua@gmail.com>
Date: Wed, 3 Feb 2021 19:45:58 +0100
Subject: Add additional test cases and improve span lint

---
 clippy_lints/src/loops.rs      | 47 ++++++++-------------
 tests/ui/manual_flatten.rs     | 18 +++++++--
 tests/ui/manual_flatten.stderr | 92 +++++++++++++++++++++++++++++++++++-------
 3 files changed, 108 insertions(+), 49 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 5bfdc98bc6a..817230a29c6 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -2034,42 +2034,27 @@ fn check_manual_flatten<'tcx>(
 
                 // Prepare the help message
                 let mut applicability = Applicability::MaybeIncorrect;
-                let arg_snippet = snippet_with_applicability(
-                    cx,
-                    arg.span,
-                    "..",
-                    &mut applicability,
-                );
-                // Determine if `arg` is by reference, an `Iterator`, or implicitly adjusted with `into_iter`
-                let arg_ty = cx.typeck_results().expr_ty(arg);
-                let hint = if arg_ty.is_ref() {
-                    if has_iter_method(cx, arg_ty).is_none() {
-                        return;
-                    } else if let ExprKind::AddrOf(_, _, arg_expr) = arg.kind {
-                        format!("{}.iter().flatten()", snippet(cx, arg_expr.span, ".."))
-                    } else {
-                        return;
-                    }
-                } else if let Some(id) = get_trait_def_id(cx, &paths::ITERATOR) {
-                    let is_iterator = implements_trait(cx, arg_ty, id, &[]);
-                    if is_iterator {
-                        format!("{}.flatten()", arg_snippet)
-                    } else {
-                        format!("{}.into_iter().flatten()", arg_snippet)
-                    }
-                } else {
-                    return
-                };
+                let arg_snippet = make_iterator_snippet(cx, arg, &mut applicability);
 
-                span_lint_and_sugg(
+                span_lint_and_then(
                     cx,
                     MANUAL_FLATTEN,
                     span,
                     &msg,
-                    "try",
-                    hint,
-                    applicability,
-                )
+                    |diag| {
+                        let sugg = format!("{}.flatten()", arg_snippet);
+                        diag.span_suggestion(
+                            arg.span,
+                            "try",
+                            sugg,
+                            Applicability::MaybeIncorrect,
+                        );
+                        diag.span_help(
+                            inner_expr.span,
+                            "also remove the `if let` statement in the for loop",
+                        );
+                    }
+                );
             }
         }
     }
diff --git a/tests/ui/manual_flatten.rs b/tests/ui/manual_flatten.rs
index b97cceb66f8..ea3440f6da2 100644
--- a/tests/ui/manual_flatten.rs
+++ b/tests/ui/manual_flatten.rs
@@ -4,8 +4,8 @@ fn main() {
     // Test for loop over implicitly adjusted `Iterator` with `if let` expression
     let x = vec![Some(1), Some(2), Some(3)];
     for n in x {
-        if let Some(n) = n {
-            println!("{}", n);
+        if let Some(y) = n {
+            println!("{}", y);
         }
     }
 
@@ -24,12 +24,22 @@ fn main() {
         }
     }
 
+    // Test for loop over an implicit reference
+    // Note: If `clippy::manual_flatten` is made autofixable, this case will
+    // lead to a follow-up lint `clippy::into_iter_on_ref`
+    let z = &y;
+    for n in z {
+        if let Ok(n) = n {
+            println!("{}", n);
+        }
+    }
+
     // Test for loop over `Iterator` with `if let` expression
     let z = vec![Some(1), Some(2), Some(3)];
     let z = z.iter();
     for n in z {
-        if let Some(n) = n {
-            println!("{}", n);
+        if let Some(m) = n {
+            println!("{}", m);
         }
     }
 
diff --git a/tests/ui/manual_flatten.stderr b/tests/ui/manual_flatten.stderr
index 754921eb739..49b8ed0564a 100644
--- a/tests/ui/manual_flatten.stderr
+++ b/tests/ui/manual_flatten.stderr
@@ -1,44 +1,108 @@
 error: unnecessary `if let` since only the `Some` variant of the iterator element is used
   --> $DIR/manual_flatten.rs:6:5
    |
-LL | /     for n in x {
-LL | |         if let Some(n) = n {
-LL | |             println!("{}", n);
+LL |       for n in x {
+   |       ^        - help: try: `x.into_iter().flatten()`
+   |  _____|
+   | |
+LL | |         if let Some(y) = n {
+LL | |             println!("{}", y);
 LL | |         }
 LL | |     }
-   | |_____^ help: try: `x.into_iter().flatten()`
+   | |_____^
    |
    = note: `-D clippy::manual-flatten` implied by `-D warnings`
+help: also remove the `if let` statement in the for loop
+  --> $DIR/manual_flatten.rs:7:9
+   |
+LL | /         if let Some(y) = n {
+LL | |             println!("{}", y);
+LL | |         }
+   | |_________^
 
 error: unnecessary `if let` since only the `Ok` variant of the iterator element is used
   --> $DIR/manual_flatten.rs:14:5
    |
-LL | /     for n in y.clone() {
+LL |       for n in y.clone() {
+   |       ^        --------- help: try: `y.clone().into_iter().flatten()`
+   |  _____|
+   | |
 LL | |         if let Ok(n) = n {
 LL | |             println!("{}", n);
 LL | |         };
 LL | |     }
-   | |_____^ help: try: `y.clone().into_iter().flatten()`
+   | |_____^
+   |
+help: also remove the `if let` statement in the for loop
+  --> $DIR/manual_flatten.rs:15:9
+   |
+LL | /         if let Ok(n) = n {
+LL | |             println!("{}", n);
+LL | |         };
+   | |_________^
 
 error: unnecessary `if let` since only the `Ok` variant of the iterator element is used
   --> $DIR/manual_flatten.rs:21:5
    |
-LL | /     for n in &y {
+LL |       for n in &y {
+   |       ^        -- help: try: `y.iter().flatten()`
+   |  _____|
+   | |
 LL | |         if let Ok(n) = n {
 LL | |             println!("{}", n);
 LL | |         }
 LL | |     }
-   | |_____^ help: try: `y.iter().flatten()`
+   | |_____^
+   |
+help: also remove the `if let` statement in the for loop
+  --> $DIR/manual_flatten.rs:22:9
+   |
+LL | /         if let Ok(n) = n {
+LL | |             println!("{}", n);
+LL | |         }
+   | |_________^
 
-error: unnecessary `if let` since only the `Some` variant of the iterator element is used
-  --> $DIR/manual_flatten.rs:30:5
+error: unnecessary `if let` since only the `Ok` variant of the iterator element is used
+  --> $DIR/manual_flatten.rs:31:5
    |
-LL | /     for n in z {
-LL | |         if let Some(n) = n {
+LL |       for n in z {
+   |       ^        - help: try: `z.into_iter().flatten()`
+   |  _____|
+   | |
+LL | |         if let Ok(n) = n {
 LL | |             println!("{}", n);
 LL | |         }
 LL | |     }
-   | |_____^ help: try: `z.flatten()`
+   | |_____^
+   |
+help: also remove the `if let` statement in the for loop
+  --> $DIR/manual_flatten.rs:32:9
+   |
+LL | /         if let Ok(n) = n {
+LL | |             println!("{}", n);
+LL | |         }
+   | |_________^
+
+error: unnecessary `if let` since only the `Some` variant of the iterator element is used
+  --> $DIR/manual_flatten.rs:40:5
+   |
+LL |       for n in z {
+   |       ^        - help: try: `z.flatten()`
+   |  _____|
+   | |
+LL | |         if let Some(m) = n {
+LL | |             println!("{}", m);
+LL | |         }
+LL | |     }
+   | |_____^
+   |
+help: also remove the `if let` statement in the for loop
+  --> $DIR/manual_flatten.rs:41:9
+   |
+LL | /         if let Some(m) = n {
+LL | |             println!("{}", m);
+LL | |         }
+   | |_________^
 
-error: aborting due to 4 previous errors
+error: aborting due to 5 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From e32e4dedf1781a4696c34f31d69e68c7c0eaf6a9 Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Tue, 2 Feb 2021 12:26:20 +0900
Subject: New lint: default_numeric_fallback

---
 CHANGELOG.md                                 |   1 +
 clippy_lints/src/default_numeric_fallback.rs | 388 +++++++++++++++++++++++++++
 clippy_lints/src/lib.rs                      |   4 +
 tests/ui/default_numeric_fallback.rs         |  99 +++++++
 tests/ui/default_numeric_fallback.stderr     | 187 +++++++++++++
 5 files changed, 679 insertions(+)
 create mode 100644 clippy_lints/src/default_numeric_fallback.rs
 create mode 100644 tests/ui/default_numeric_fallback.rs
 create mode 100644 tests/ui/default_numeric_fallback.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index c1032204a22..5eed9664088 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1909,6 +1909,7 @@ Released 2018-09-13
 [`debug_assert_with_mut_call`]: https://rust-lang.github.io/rust-clippy/master/index.html#debug_assert_with_mut_call
 [`decimal_literal_representation`]: https://rust-lang.github.io/rust-clippy/master/index.html#decimal_literal_representation
 [`declare_interior_mutable_const`]: https://rust-lang.github.io/rust-clippy/master/index.html#declare_interior_mutable_const
+[`default_numeric_fallback`]: https://rust-lang.github.io/rust-clippy/master/index.html#default_numeric_fallback
 [`default_trait_access`]: https://rust-lang.github.io/rust-clippy/master/index.html#default_trait_access
 [`deprecated_cfg_attr`]: https://rust-lang.github.io/rust-clippy/master/index.html#deprecated_cfg_attr
 [`deprecated_semver`]: https://rust-lang.github.io/rust-clippy/master/index.html#deprecated_semver
diff --git a/clippy_lints/src/default_numeric_fallback.rs b/clippy_lints/src/default_numeric_fallback.rs
new file mode 100644
index 00000000000..f049e64d0fb
--- /dev/null
+++ b/clippy_lints/src/default_numeric_fallback.rs
@@ -0,0 +1,388 @@
+use rustc_ast::ast::{Label, LitFloatType, LitIntType, LitKind};
+use rustc_hir::{
+    self as hir,
+    intravisit::{walk_expr, walk_stmt, walk_ty, FnKind, NestedVisitorMap, Visitor},
+    Body, Expr, ExprKind, FnDecl, FnRetTy, Guard, HirId, Lit, Stmt, StmtKind,
+};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::{
+    hir::map::Map,
+    ty::{self, subst::GenericArgKind, FloatTy, IntTy, Ty, TyCtxt},
+};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::Span;
+use rustc_typeck::hir_ty_to_ty;
+
+use if_chain::if_chain;
+
+use crate::utils::span_lint_and_help;
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for usage of unconstrained numeric literals which may cause default numeric fallback in type
+    /// inference.
+    ///
+    /// Default numeric fallback means that if numeric types have not yet been bound to concrete
+    /// types at the end of type inference, then integer type is bound to `i32`, and similarly
+    /// floating type is bound to `f64`.
+    ///
+    /// See [RFC0212](https://github.com/rust-lang/rfcs/blob/master/text/0212-restore-int-fallback.md) for more information about the fallback.
+    ///
+    /// **Why is this bad?** For those who are very careful about types, default numeric fallback
+    /// can be a pitfall that cause unexpected runtime behavior.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// ```rust
+    /// let i = 10;
+    /// let f = 1.23;
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust
+    /// let i = 10i32;
+    /// let f = 1.23f64;
+    /// ```
+    pub DEFAULT_NUMERIC_FALLBACK,
+    restriction,
+    "usage of unconstrained numeric literals which may cause default numeric fallback."
+}
+
+declare_lint_pass!(DefaultNumericFallback => [DEFAULT_NUMERIC_FALLBACK]);
+
+fn enclosing_body_owner_opt(tcx: TyCtxt<'_>, hir_id: HirId) -> Option<HirId> {
+    let hir_map = tcx.hir();
+    for (parent, _) in hir_map.parent_iter(hir_id) {
+        if let Some(body) = hir_map.maybe_body_owned_by(parent) {
+            return Some(hir_map.body_owner(body));
+        }
+    }
+    None
+}
+
+impl LateLintPass<'_> for DefaultNumericFallback {
+    fn check_fn(
+        &mut self,
+        cx: &LateContext<'tcx>,
+        _: FnKind<'tcx>,
+        fn_decl: &'tcx FnDecl<'_>,
+        body: &'tcx Body<'_>,
+        _: Span,
+        hir_id: HirId,
+    ) {
+        let ret_ty_bound = match fn_decl.output {
+            FnRetTy::DefaultReturn(_) => None,
+            FnRetTy::Return(ty) => Some(ty),
+        }
+        .and_then(|ty| {
+            let mut infer_ty_finder = InferTyFinder::new();
+            infer_ty_finder.visit_ty(ty);
+            if infer_ty_finder.found {
+                None
+            } else if enclosing_body_owner_opt(cx.tcx, hir_id).is_some() {
+                cx.typeck_results().node_type_opt(ty.hir_id)
+            } else {
+                Some(hir_ty_to_ty(cx.tcx, ty))
+            }
+        });
+
+        let mut visitor = NumericFallbackVisitor::new(ret_ty_bound, cx);
+        visitor.visit_body(body);
+    }
+}
+
+struct NumericFallbackVisitor<'a, 'tcx> {
+    /// Stack manages type bound of exprs. The top element holds current expr type.
+    ty_bounds: Vec<Option<Ty<'tcx>>>,
+
+    /// Ret type bound.
+    ret_ty_bound: Option<Ty<'tcx>>,
+
+    /// Break type bounds.
+    break_ty_bounds: Vec<(Option<Label>, Option<Ty<'tcx>>)>,
+
+    cx: &'a LateContext<'tcx>,
+}
+
+impl<'a, 'tcx> NumericFallbackVisitor<'a, 'tcx> {
+    fn new(ret_ty_bound: Option<Ty<'tcx>>, cx: &'a LateContext<'tcx>) -> Self {
+        Self {
+            ty_bounds: vec![ret_ty_bound],
+            ret_ty_bound,
+            break_ty_bounds: vec![],
+            cx,
+        }
+    }
+
+    /// Check whether lit cause fallback or not.
+    fn check_lit(&self, lit: &Lit, lit_ty: Ty<'tcx>) {
+        let ty_bound = self.ty_bounds.last().unwrap();
+
+        let should_lint = match (&lit.node, lit_ty.kind()) {
+            (LitKind::Int(_, LitIntType::Unsuffixed), ty::Int(ty::IntTy::I32)) => {
+                // In case integer literal is explicitly bound to i32, then suppress lint.
+                ty_bound.map_or(true, |ty_bound| !matches!(ty_bound.kind(), ty::Int(IntTy::I32)))
+            },
+
+            (LitKind::Float(_, LitFloatType::Unsuffixed), ty::Float(ty::FloatTy::F64)) => {
+                // In case float literal is explicitly bound to f64, then suppress lint.
+                ty_bound.map_or(true, |ty_bound| !matches!(ty_bound.kind(), ty::Float(FloatTy::F64)))
+            },
+
+            _ => false,
+        };
+
+        if should_lint {
+            span_lint_and_help(
+                self.cx,
+                DEFAULT_NUMERIC_FALLBACK,
+                lit.span,
+                "default numeric fallback might occur",
+                None,
+                "consider adding suffix to avoid default numeric fallback",
+            );
+        }
+    }
+}
+
+impl<'a, 'tcx> Visitor<'tcx> for NumericFallbackVisitor<'a, 'tcx> {
+    type Map = Map<'tcx>;
+
+    #[allow(clippy::too_many_lines)]
+    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
+        match (&expr.kind, *self.ty_bounds.last().unwrap()) {
+            (ExprKind::Array(_), Some(last_bound)) => {
+                if let ty::Array(ty, _) = last_bound.kind() {
+                    self.ty_bounds.push(Some(ty))
+                } else {
+                    self.ty_bounds.push(None)
+                }
+            },
+
+            (ExprKind::Call(func, args), _) => {
+                if_chain! {
+                    if let ExprKind::Path(ref func_path) = func.kind;
+                    if let Some(def_id) = self.cx.qpath_res(func_path, func.hir_id).opt_def_id();
+                    then {
+                        let fn_sig = self.cx.tcx.fn_sig(def_id).skip_binder();
+                        for (expr, bound) in args.iter().zip(fn_sig.inputs().iter()) {
+                            // Push found arg type, then visit arg.
+                            self.ty_bounds.push(Some(bound));
+                            self.visit_expr(expr);
+                            self.ty_bounds.pop();
+                        }
+                        return;
+                    } else {
+                        self.ty_bounds.push(None)
+                    }
+                }
+            },
+
+            (ExprKind::MethodCall(_, _, args, _), _) => {
+                if let Some(def_id) = self.cx.typeck_results().type_dependent_def_id(expr.hir_id) {
+                    let fn_sig = self.cx.tcx.fn_sig(def_id).skip_binder();
+                    for (expr, bound) in args.iter().zip(fn_sig.inputs().iter()) {
+                        self.ty_bounds.push(Some(bound));
+                        self.visit_expr(expr);
+                        self.ty_bounds.pop();
+                    }
+                    return;
+                }
+
+                self.ty_bounds.push(None)
+            },
+
+            (ExprKind::Tup(exprs), Some(last_bound)) => {
+                if let ty::Tuple(tys) = last_bound.kind() {
+                    for (expr, bound) in exprs.iter().zip(tys.iter()) {
+                        if let GenericArgKind::Type(ty) = bound.unpack() {
+                            self.ty_bounds.push(Some(ty));
+                        } else {
+                            self.ty_bounds.push(None);
+                        }
+
+                        self.visit_expr(expr);
+                        self.ty_bounds.pop();
+                    }
+                    return;
+                }
+
+                self.ty_bounds.push(None)
+            },
+
+            (ExprKind::Lit(lit), _) => {
+                let ty = self.cx.typeck_results().expr_ty(expr);
+                self.check_lit(lit, ty);
+                return;
+            },
+
+            (ExprKind::If(cond, then, else_), last_bound) => {
+                // Cond has no type bound in any situation.
+                self.ty_bounds.push(None);
+                self.visit_expr(cond);
+                self.ty_bounds.pop();
+
+                // Propagate current bound to childs.
+                self.ty_bounds.push(last_bound);
+                self.visit_expr(then);
+                if let Some(else_) = else_ {
+                    self.visit_expr(else_);
+                }
+                self.ty_bounds.pop();
+                return;
+            },
+
+            (ExprKind::Loop(_, label, ..), last_bound) => {
+                self.break_ty_bounds.push((*label, last_bound));
+                walk_expr(self, expr);
+                self.break_ty_bounds.pop();
+                return;
+            },
+
+            (ExprKind::Match(arg, arms, _), last_bound) => {
+                // Match argument has no type bound.
+                self.ty_bounds.push(None);
+                self.visit_expr(arg);
+                for arm in arms.iter() {
+                    self.visit_pat(arm.pat);
+                    if let Some(Guard::If(guard)) = arm.guard {
+                        self.visit_expr(guard);
+                    }
+                }
+                self.ty_bounds.pop();
+
+                // Propagate current bound.
+                self.ty_bounds.push(last_bound);
+                for arm in arms.iter() {
+                    self.visit_expr(arm.body);
+                }
+                self.ty_bounds.pop();
+                return;
+            },
+
+            (ExprKind::Block(..), last_bound) => self.ty_bounds.push(last_bound),
+
+            (ExprKind::Break(destination, _), _) => {
+                let ty = destination.label.map_or_else(
+                    || self.break_ty_bounds.last().unwrap().1,
+                    |dest_label| {
+                        self.break_ty_bounds
+                            .iter()
+                            .rev()
+                            .find_map(|(loop_label, ty)| {
+                                loop_label.map_or(None, |loop_label| {
+                                    if loop_label.ident == dest_label.ident {
+                                        Some(*ty)
+                                    } else {
+                                        None
+                                    }
+                                })
+                            })
+                            .unwrap()
+                    },
+                );
+                self.ty_bounds.push(ty);
+            },
+
+            (ExprKind::Ret(_), _) => self.ty_bounds.push(self.ret_ty_bound),
+
+            (ExprKind::Struct(qpath, fields, base), _) => {
+                if_chain! {
+                    if let Some(def_id) = self.cx.qpath_res(qpath, expr.hir_id).opt_def_id();
+                    let ty = self.cx.tcx.type_of(def_id);
+                    if let Some(adt_def) = ty.ty_adt_def();
+                    if adt_def.is_struct();
+                    if let Some(variant) = adt_def.variants.iter().next();
+                    then {
+                        let fields_def = &variant.fields;
+
+                        // Push field type then visit each field expr.
+                        for field in fields.iter() {
+                            let field_ty =
+                                fields_def
+                                    .iter()
+                                    .find_map(|f_def| {
+                                        if f_def.ident == field.ident
+                                            { Some(self.cx.tcx.type_of(f_def.did)) }
+                                        else { None }
+                                    });
+                            self.ty_bounds.push(field_ty);
+                            self.visit_expr(field.expr);
+                            self.ty_bounds.pop();
+                        }
+
+                        // Visit base with no bound.
+                        if let Some(base) = base {
+                            self.ty_bounds.push(None);
+                            self.visit_expr(base);
+                            self.ty_bounds.pop();
+                        }
+                        return;
+                    }
+                }
+                self.ty_bounds.push(None);
+            },
+
+            _ => self.ty_bounds.push(None),
+        }
+
+        walk_expr(self, expr);
+        self.ty_bounds.pop();
+    }
+
+    fn visit_stmt(&mut self, stmt: &'tcx Stmt<'_>) {
+        match stmt.kind {
+            StmtKind::Local(local) => {
+                let ty = local.ty.and_then(|hir_ty| {
+                    let mut infer_ty_finder = InferTyFinder::new();
+                    infer_ty_finder.visit_ty(hir_ty);
+                    if infer_ty_finder.found {
+                        None
+                    } else {
+                        self.cx.typeck_results().node_type_opt(hir_ty.hir_id)
+                    }
+                });
+                self.ty_bounds.push(ty);
+            },
+
+            _ => self.ty_bounds.push(None),
+        }
+
+        walk_stmt(self, stmt);
+        self.ty_bounds.pop();
+    }
+
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::None
+    }
+}
+
+/// Find `hir::TyKind::Infer` is included in passed typed.
+struct InferTyFinder {
+    found: bool,
+}
+
+impl InferTyFinder {
+    fn new() -> Self {
+        Self { found: false }
+    }
+}
+
+impl<'tcx> Visitor<'tcx> for InferTyFinder {
+    type Map = Map<'tcx>;
+
+    fn visit_ty(&mut self, ty: &'tcx hir::Ty<'_>) {
+        match ty.kind {
+            hir::TyKind::Infer => {
+                self.found = true;
+            },
+            _ => {
+                walk_ty(self, ty);
+            },
+        }
+    }
+
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::None
+    }
+}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 5a40c00bd67..642c1e68dac 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -181,6 +181,7 @@ mod copy_iterator;
 mod create_dir;
 mod dbg_macro;
 mod default;
+mod default_numeric_fallback;
 mod dereference;
 mod derive;
 mod disallowed_method;
@@ -584,6 +585,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &dbg_macro::DBG_MACRO,
         &default::DEFAULT_TRAIT_ACCESS,
         &default::FIELD_REASSIGN_WITH_DEFAULT,
+        &default_numeric_fallback::DEFAULT_NUMERIC_FALLBACK,
         &dereference::EXPLICIT_DEREF_METHODS,
         &derive::DERIVE_HASH_XOR_EQ,
         &derive::DERIVE_ORD_XOR_PARTIAL_ORD,
@@ -1026,6 +1028,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box strings::StringAdd);
     store.register_late_pass(|| box implicit_return::ImplicitReturn);
     store.register_late_pass(|| box implicit_saturating_sub::ImplicitSaturatingSub);
+    store.register_late_pass(|| box default_numeric_fallback::DefaultNumericFallback);
 
     let msrv = conf.msrv.as_ref().and_then(|s| {
         parse_msrv(s, None, None).or_else(|| {
@@ -1258,6 +1261,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&asm_syntax::INLINE_ASM_X86_INTEL_SYNTAX),
         LintId::of(&create_dir::CREATE_DIR),
         LintId::of(&dbg_macro::DBG_MACRO),
+        LintId::of(&default_numeric_fallback::DEFAULT_NUMERIC_FALLBACK),
         LintId::of(&else_if_without_else::ELSE_IF_WITHOUT_ELSE),
         LintId::of(&exhaustive_items::EXHAUSTIVE_ENUMS),
         LintId::of(&exhaustive_items::EXHAUSTIVE_STRUCTS),
diff --git a/tests/ui/default_numeric_fallback.rs b/tests/ui/default_numeric_fallback.rs
new file mode 100644
index 00000000000..90ee8ea0399
--- /dev/null
+++ b/tests/ui/default_numeric_fallback.rs
@@ -0,0 +1,99 @@
+#![warn(clippy::default_numeric_fallback)]
+#![allow(unused)]
+#![allow(clippy::never_loop)]
+#![allow(clippy::no_effect)]
+#![allow(clippy::unnecessary_operation)]
+
+fn ret_i31() -> i32 {
+    23
+}
+
+fn concrete_arg(x: i32) {}
+
+fn generic_arg<T>(t: T) {}
+
+struct ConcreteStruct {
+    x: i32,
+}
+
+struct GenericStruct<T> {
+    x: T,
+}
+
+struct StructForMethodCallTest {
+    x: i32,
+}
+
+impl StructForMethodCallTest {
+    fn concrete_arg(&self, x: i32) {}
+
+    fn generic_arg<T>(&self, t: T) {}
+}
+
+fn main() {
+    let s = StructForMethodCallTest { x: 10_i32 };
+
+    // Bad.
+    let x = 22;
+    let x = 0.12;
+    let x: _ = 13;
+    let x: [_; 3] = [1, 2, 3];
+    let x: (_, i32) = (1, 2);
+
+    let x = if true { (1, 2) } else { (3, 4) };
+
+    let x = match 1 {
+        1 => 1,
+        _ => 2,
+    };
+
+    let x = loop {
+        break 1;
+    };
+
+    let x = 'outer0: loop {
+        {
+            'inner0: loop {
+                break 3;
+            }
+        };
+        break 2;
+    };
+
+    let x = GenericStruct { x: 1 };
+
+    generic_arg(10);
+    s.generic_arg(10);
+    let f = || -> _ { 1 };
+
+    // Good.
+    let x = 22_i32;
+    let x: f64 = 0.12;
+    let x = 0.12_f64;
+    let x: i32 = 13;
+    let x: [i32; 3] = [1, 2, 3];
+    let x: (i32, i32) = (1, 2);
+
+    let x: (i32, i32) = if true { (1, 2) } else { (3, 4) };
+
+    let x: i32 = match true {
+        true => 1,
+        _ => 2,
+    };
+
+    let x: i32 = loop {
+        break 1;
+    };
+
+    let x: i32 = 'outer1: loop {
+        'inner1: loop {
+            break 'outer1 3;
+        }
+    };
+
+    let x = ConcreteStruct { x: 1 };
+
+    concrete_arg(10);
+    s.concrete_arg(10);
+    let f = || -> i32 { 1 };
+}
diff --git a/tests/ui/default_numeric_fallback.stderr b/tests/ui/default_numeric_fallback.stderr
new file mode 100644
index 00000000000..27629b994be
--- /dev/null
+++ b/tests/ui/default_numeric_fallback.stderr
@@ -0,0 +1,187 @@
+error: default numeric fallback might occur
+  --> $DIR/default_numeric_fallback.rs:37:13
+   |
+LL |     let x = 22;
+   |             ^^
+   |
+   = note: `-D clippy::default-numeric-fallback` implied by `-D warnings`
+   = help: consider adding suffix to avoid default numeric fallback
+
+error: default numeric fallback might occur
+  --> $DIR/default_numeric_fallback.rs:38:13
+   |
+LL |     let x = 0.12;
+   |             ^^^^
+   |
+   = help: consider adding suffix to avoid default numeric fallback
+
+error: default numeric fallback might occur
+  --> $DIR/default_numeric_fallback.rs:39:16
+   |
+LL |     let x: _ = 13;
+   |                ^^
+   |
+   = help: consider adding suffix to avoid default numeric fallback
+
+error: default numeric fallback might occur
+  --> $DIR/default_numeric_fallback.rs:40:22
+   |
+LL |     let x: [_; 3] = [1, 2, 3];
+   |                      ^
+   |
+   = help: consider adding suffix to avoid default numeric fallback
+
+error: default numeric fallback might occur
+  --> $DIR/default_numeric_fallback.rs:40:25
+   |
+LL |     let x: [_; 3] = [1, 2, 3];
+   |                         ^
+   |
+   = help: consider adding suffix to avoid default numeric fallback
+
+error: default numeric fallback might occur
+  --> $DIR/default_numeric_fallback.rs:40:28
+   |
+LL |     let x: [_; 3] = [1, 2, 3];
+   |                            ^
+   |
+   = help: consider adding suffix to avoid default numeric fallback
+
+error: default numeric fallback might occur
+  --> $DIR/default_numeric_fallback.rs:41:24
+   |
+LL |     let x: (_, i32) = (1, 2);
+   |                        ^
+   |
+   = help: consider adding suffix to avoid default numeric fallback
+
+error: default numeric fallback might occur
+  --> $DIR/default_numeric_fallback.rs:41:27
+   |
+LL |     let x: (_, i32) = (1, 2);
+   |                           ^
+   |
+   = help: consider adding suffix to avoid default numeric fallback
+
+error: default numeric fallback might occur
+  --> $DIR/default_numeric_fallback.rs:43:24
+   |
+LL |     let x = if true { (1, 2) } else { (3, 4) };
+   |                        ^
+   |
+   = help: consider adding suffix to avoid default numeric fallback
+
+error: default numeric fallback might occur
+  --> $DIR/default_numeric_fallback.rs:43:27
+   |
+LL |     let x = if true { (1, 2) } else { (3, 4) };
+   |                           ^
+   |
+   = help: consider adding suffix to avoid default numeric fallback
+
+error: default numeric fallback might occur
+  --> $DIR/default_numeric_fallback.rs:43:40
+   |
+LL |     let x = if true { (1, 2) } else { (3, 4) };
+   |                                        ^
+   |
+   = help: consider adding suffix to avoid default numeric fallback
+
+error: default numeric fallback might occur
+  --> $DIR/default_numeric_fallback.rs:43:43
+   |
+LL |     let x = if true { (1, 2) } else { (3, 4) };
+   |                                           ^
+   |
+   = help: consider adding suffix to avoid default numeric fallback
+
+error: default numeric fallback might occur
+  --> $DIR/default_numeric_fallback.rs:45:19
+   |
+LL |     let x = match 1 {
+   |                   ^
+   |
+   = help: consider adding suffix to avoid default numeric fallback
+
+error: default numeric fallback might occur
+  --> $DIR/default_numeric_fallback.rs:46:9
+   |
+LL |         1 => 1,
+   |         ^
+   |
+   = help: consider adding suffix to avoid default numeric fallback
+
+error: default numeric fallback might occur
+  --> $DIR/default_numeric_fallback.rs:46:14
+   |
+LL |         1 => 1,
+   |              ^
+   |
+   = help: consider adding suffix to avoid default numeric fallback
+
+error: default numeric fallback might occur
+  --> $DIR/default_numeric_fallback.rs:47:14
+   |
+LL |         _ => 2,
+   |              ^
+   |
+   = help: consider adding suffix to avoid default numeric fallback
+
+error: default numeric fallback might occur
+  --> $DIR/default_numeric_fallback.rs:51:15
+   |
+LL |         break 1;
+   |               ^
+   |
+   = help: consider adding suffix to avoid default numeric fallback
+
+error: default numeric fallback might occur
+  --> $DIR/default_numeric_fallback.rs:57:23
+   |
+LL |                 break 3;
+   |                       ^
+   |
+   = help: consider adding suffix to avoid default numeric fallback
+
+error: default numeric fallback might occur
+  --> $DIR/default_numeric_fallback.rs:60:15
+   |
+LL |         break 2;
+   |               ^
+   |
+   = help: consider adding suffix to avoid default numeric fallback
+
+error: default numeric fallback might occur
+  --> $DIR/default_numeric_fallback.rs:63:32
+   |
+LL |     let x = GenericStruct { x: 1 };
+   |                                ^
+   |
+   = help: consider adding suffix to avoid default numeric fallback
+
+error: default numeric fallback might occur
+  --> $DIR/default_numeric_fallback.rs:65:17
+   |
+LL |     generic_arg(10);
+   |                 ^^
+   |
+   = help: consider adding suffix to avoid default numeric fallback
+
+error: default numeric fallback might occur
+  --> $DIR/default_numeric_fallback.rs:66:19
+   |
+LL |     s.generic_arg(10);
+   |                   ^^
+   |
+   = help: consider adding suffix to avoid default numeric fallback
+
+error: default numeric fallback might occur
+  --> $DIR/default_numeric_fallback.rs:67:23
+   |
+LL |     let f = || -> _ { 1 };
+   |                       ^
+   |
+   = help: consider adding suffix to avoid default numeric fallback
+
+error: aborting due to 23 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 2f8a8d3468050f724473900bcfcc75a110314059 Mon Sep 17 00:00:00 2001
From: nahuakang <kangnahua@gmail.com>
Date: Thu, 4 Feb 2021 10:51:40 +0100
Subject: Improve lint message; add note for future autofixable updates

---
 clippy_lints/src/loops.rs      |  2 +-
 tests/ui/manual_flatten.rs     |  4 +++-
 tests/ui/manual_flatten.stderr | 10 +++++-----
 3 files changed, 9 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 817230a29c6..663c2df23e2 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -2051,7 +2051,7 @@ fn check_manual_flatten<'tcx>(
                         );
                         diag.span_help(
                             inner_expr.span,
-                            "also remove the `if let` statement in the for loop",
+                            "...and remove the `if let` statement in the for loop",
                         );
                     }
                 );
diff --git a/tests/ui/manual_flatten.rs b/tests/ui/manual_flatten.rs
index ea3440f6da2..cff68eca933 100644
--- a/tests/ui/manual_flatten.rs
+++ b/tests/ui/manual_flatten.rs
@@ -25,7 +25,7 @@ fn main() {
     }
 
     // Test for loop over an implicit reference
-    // Note: If `clippy::manual_flatten` is made autofixable, this case will
+    // Note: if `clippy::manual_flatten` is made autofixable, this case will
     // lead to a follow-up lint `clippy::into_iter_on_ref`
     let z = &y;
     for n in z {
@@ -44,6 +44,8 @@ fn main() {
     }
 
     // Using the `None` variant should not trigger the lint
+    // Note: for an autofixable suggestion, the binding in the for loop has to take the
+    // name of the binding in the `if let`
     let z = vec![Some(1), Some(2), Some(3)];
     for n in z {
         if n.is_none() {
diff --git a/tests/ui/manual_flatten.stderr b/tests/ui/manual_flatten.stderr
index 49b8ed0564a..855dd9130e2 100644
--- a/tests/ui/manual_flatten.stderr
+++ b/tests/ui/manual_flatten.stderr
@@ -12,7 +12,7 @@ LL | |     }
    | |_____^
    |
    = note: `-D clippy::manual-flatten` implied by `-D warnings`
-help: also remove the `if let` statement in the for loop
+help: ...and remove the `if let` statement in the for loop
   --> $DIR/manual_flatten.rs:7:9
    |
 LL | /         if let Some(y) = n {
@@ -33,7 +33,7 @@ LL | |         };
 LL | |     }
    | |_____^
    |
-help: also remove the `if let` statement in the for loop
+help: ...and remove the `if let` statement in the for loop
   --> $DIR/manual_flatten.rs:15:9
    |
 LL | /         if let Ok(n) = n {
@@ -54,7 +54,7 @@ LL | |         }
 LL | |     }
    | |_____^
    |
-help: also remove the `if let` statement in the for loop
+help: ...and remove the `if let` statement in the for loop
   --> $DIR/manual_flatten.rs:22:9
    |
 LL | /         if let Ok(n) = n {
@@ -75,7 +75,7 @@ LL | |         }
 LL | |     }
    | |_____^
    |
-help: also remove the `if let` statement in the for loop
+help: ...and remove the `if let` statement in the for loop
   --> $DIR/manual_flatten.rs:32:9
    |
 LL | /         if let Ok(n) = n {
@@ -96,7 +96,7 @@ LL | |         }
 LL | |     }
    | |_____^
    |
-help: also remove the `if let` statement in the for loop
+help: ...and remove the `if let` statement in the for loop
   --> $DIR/manual_flatten.rs:41:9
    |
 LL | /         if let Some(m) = n {
-- 
cgit 1.4.1-3-g733a5


From 8b8b0a94b05f7189d028d91deda659ed266ef09d Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Thu, 4 Feb 2021 22:57:03 +0900
Subject: Fix enclosing_body_owner_opt and rename it to enclosing_body_opt

---
 clippy_lints/src/default_numeric_fallback.rs | 47 ++++++++++++++++++----------
 1 file changed, 31 insertions(+), 16 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/default_numeric_fallback.rs b/clippy_lints/src/default_numeric_fallback.rs
index f049e64d0fb..5f0ee1be2b9 100644
--- a/clippy_lints/src/default_numeric_fallback.rs
+++ b/clippy_lints/src/default_numeric_fallback.rs
@@ -2,7 +2,7 @@ use rustc_ast::ast::{Label, LitFloatType, LitIntType, LitKind};
 use rustc_hir::{
     self as hir,
     intravisit::{walk_expr, walk_stmt, walk_ty, FnKind, NestedVisitorMap, Visitor},
-    Body, Expr, ExprKind, FnDecl, FnRetTy, Guard, HirId, Lit, Stmt, StmtKind,
+    Body, BodyId, Expr, ExprKind, FnDecl, FnRetTy, Guard, HirId, Lit, Stmt, StmtKind,
 };
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::{
@@ -50,16 +50,31 @@ declare_clippy_lint! {
 
 declare_lint_pass!(DefaultNumericFallback => [DEFAULT_NUMERIC_FALLBACK]);
 
-fn enclosing_body_owner_opt(tcx: TyCtxt<'_>, hir_id: HirId) -> Option<HirId> {
+/// Return the body that includes passed `hir_id` if exists.
+fn enclosing_body_opt(tcx: TyCtxt<'_>, hir_id: HirId) -> Option<BodyId> {
     let hir_map = tcx.hir();
+    let mut trace = vec![(hir_id)];
+
     for (parent, _) in hir_map.parent_iter(hir_id) {
+        trace.push(parent);
         if let Some(body) = hir_map.maybe_body_owned_by(parent) {
-            return Some(hir_map.body_owner(body));
+            if trace.iter().any(|hir_id| *hir_id == body.hir_id) {
+                return Some(body);
+            }
         }
     }
+
     None
 }
 
+fn ty_from_hir_ty<'tcx>(cx: &LateContext<'tcx>, hir_ty: &hir::Ty<'tcx>) -> Option<Ty<'tcx>> {
+    if enclosing_body_opt(cx.tcx, hir_ty.hir_id).is_some() {
+        cx.typeck_results().node_type_opt(hir_ty.hir_id)
+    } else {
+        Some(hir_ty_to_ty(cx.tcx, hir_ty))
+    }
+}
+
 impl LateLintPass<'_> for DefaultNumericFallback {
     fn check_fn(
         &mut self,
@@ -68,21 +83,17 @@ impl LateLintPass<'_> for DefaultNumericFallback {
         fn_decl: &'tcx FnDecl<'_>,
         body: &'tcx Body<'_>,
         _: Span,
-        hir_id: HirId,
+        _: HirId,
     ) {
         let ret_ty_bound = match fn_decl.output {
             FnRetTy::DefaultReturn(_) => None,
             FnRetTy::Return(ty) => Some(ty),
         }
         .and_then(|ty| {
-            let mut infer_ty_finder = InferTyFinder::new();
-            infer_ty_finder.visit_ty(ty);
-            if infer_ty_finder.found {
+            if is_infer_included(ty) {
                 None
-            } else if enclosing_body_owner_opt(cx.tcx, hir_id).is_some() {
-                cx.typeck_results().node_type_opt(ty.hir_id)
             } else {
-                Some(hir_ty_to_ty(cx.tcx, ty))
+                ty_from_hir_ty(cx, ty)
             }
         });
 
@@ -114,7 +125,7 @@ impl<'a, 'tcx> NumericFallbackVisitor<'a, 'tcx> {
         }
     }
 
-    /// Check whether lit cause fallback or not.
+    /// Check whether a passed literal has potential to cause fallback or not.
     fn check_lit(&self, lit: &Lit, lit_ty: Ty<'tcx>) {
         let ty_bound = self.ty_bounds.last().unwrap();
 
@@ -334,12 +345,10 @@ impl<'a, 'tcx> Visitor<'tcx> for NumericFallbackVisitor<'a, 'tcx> {
         match stmt.kind {
             StmtKind::Local(local) => {
                 let ty = local.ty.and_then(|hir_ty| {
-                    let mut infer_ty_finder = InferTyFinder::new();
-                    infer_ty_finder.visit_ty(hir_ty);
-                    if infer_ty_finder.found {
+                    if is_infer_included(hir_ty) {
                         None
                     } else {
-                        self.cx.typeck_results().node_type_opt(hir_ty.hir_id)
+                        ty_from_hir_ty(self.cx, hir_ty)
                     }
                 });
                 self.ty_bounds.push(ty);
@@ -357,7 +366,13 @@ impl<'a, 'tcx> Visitor<'tcx> for NumericFallbackVisitor<'a, 'tcx> {
     }
 }
 
-/// Find `hir::TyKind::Infer` is included in passed typed.
+/// Return true if a given ty includes `hir::TyKind::Infer`.
+fn is_infer_included(ty: &hir::Ty<'_>) -> bool {
+    let mut infer_ty_finder = InferTyFinder::new();
+    infer_ty_finder.visit_ty(ty);
+    infer_ty_finder.found
+}
+
 struct InferTyFinder {
     found: bool,
 }
-- 
cgit 1.4.1-3-g733a5


From 233fe11ce9711a3652141fbe7e9191314fd701d5 Mon Sep 17 00:00:00 2001
From: ThibsG <thibsg@pm.me>
Date: Thu, 4 Feb 2021 19:08:08 +0100
Subject: Set turbofish for every sugg and add more test cases

---
 clippy_lints/src/methods/mod.rs              |  6 +---
 tests/ui/from_iter_instead_of_collect.fixed  | 34 ++++++++++++++++++++++
 tests/ui/from_iter_instead_of_collect.rs     | 21 ++++++++++++--
 tests/ui/from_iter_instead_of_collect.stderr | 42 ++++++++++++++++++++++------
 4 files changed, 86 insertions(+), 17 deletions(-)
 create mode 100644 tests/ui/from_iter_instead_of_collect.fixed

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index f53b2f67d1d..3e356afa2a4 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -4095,11 +4095,7 @@ fn lint_from_iter(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::Expr<
         then {
             // `expr` implements `FromIterator` trait
             let iter_expr = sugg::Sugg::hir(cx, &args[0], "..").maybe_par();
-            let sugg = if higher::range(&args[0]).is_some() {
-                format!("{}.collect::<{}>()", iter_expr, ty)
-            } else {
-                format!("{}.collect()", iter_expr)
-            };
+            let sugg = format!("{}.collect::<{}>()", iter_expr, ty);
             span_lint_and_sugg(
                 cx,
                 FROM_ITER_INSTEAD_OF_COLLECT,
diff --git a/tests/ui/from_iter_instead_of_collect.fixed b/tests/ui/from_iter_instead_of_collect.fixed
new file mode 100644
index 00000000000..96701e86395
--- /dev/null
+++ b/tests/ui/from_iter_instead_of_collect.fixed
@@ -0,0 +1,34 @@
+// run-rustfix
+
+#![warn(clippy::from_iter_instead_of_collect)]
+#![allow(unused_imports)]
+
+use std::collections::{BTreeMap, BTreeSet, HashMap, VecDeque};
+use std::iter::FromIterator;
+
+fn main() {
+    let iter_expr = std::iter::repeat(5).take(5);
+    let _ = iter_expr.collect::<std::vec::Vec<i32>>();
+
+    let _ = vec![5, 5, 5, 5].iter().enumerate().collect::<std::collections::HashMap<usize, &i8>>();
+
+    Vec::from_iter(vec![42u32]);
+
+    let a = vec![0, 1, 2];
+    assert_eq!(a, (0..3).collect::<std::vec::Vec<i32>>());
+
+    let mut b = (0..3).collect::<std::collections::VecDeque<i32>>();
+    b.push_back(4);
+
+    let values = [(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd')];
+    let bm = values.iter().cloned().collect::<std::collections::BTreeMap<i32, char>>();
+    let mut bar = bm.range(0..2).collect::<std::collections::BTreeMap<&i32, &char>>();
+    bar.insert(&4, &'e');
+
+    let mut bts = (0..3).collect::<std::collections::BTreeSet<i32>>();
+    bts.insert(2);
+    {
+        use std::collections;
+        let _ = (0..3).collect::<std::collections::BTreeSet<i32>>();
+    }
+}
diff --git a/tests/ui/from_iter_instead_of_collect.rs b/tests/ui/from_iter_instead_of_collect.rs
index 6c81366c4df..211f57bc537 100644
--- a/tests/ui/from_iter_instead_of_collect.rs
+++ b/tests/ui/from_iter_instead_of_collect.rs
@@ -1,13 +1,16 @@
+// run-rustfix
+
 #![warn(clippy::from_iter_instead_of_collect)]
+#![allow(unused_imports)]
 
-use std::collections::{HashMap, VecDeque};
+use std::collections::{BTreeMap, BTreeSet, HashMap, VecDeque};
 use std::iter::FromIterator;
 
 fn main() {
     let iter_expr = std::iter::repeat(5).take(5);
-    Vec::from_iter(iter_expr);
+    let _ = Vec::from_iter(iter_expr);
 
-    HashMap::<usize, &i8>::from_iter(vec![5, 5, 5, 5].iter().enumerate());
+    let _ = HashMap::<usize, &i8>::from_iter(vec![5, 5, 5, 5].iter().enumerate());
 
     Vec::from_iter(vec![42u32]);
 
@@ -16,4 +19,16 @@ fn main() {
 
     let mut b = VecDeque::from_iter(0..3);
     b.push_back(4);
+
+    let values = [(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd')];
+    let bm = BTreeMap::from_iter(values.iter().cloned());
+    let mut bar = BTreeMap::from_iter(bm.range(0..2));
+    bar.insert(&4, &'e');
+
+    let mut bts = BTreeSet::from_iter(0..3);
+    bts.insert(2);
+    {
+        use std::collections;
+        let _ = collections::BTreeSet::from_iter(0..3);
+    }
 }
diff --git a/tests/ui/from_iter_instead_of_collect.stderr b/tests/ui/from_iter_instead_of_collect.stderr
index e2161dd3b57..336e25a8adf 100644
--- a/tests/ui/from_iter_instead_of_collect.stderr
+++ b/tests/ui/from_iter_instead_of_collect.stderr
@@ -1,28 +1,52 @@
 error: usage of `FromIterator::from_iter`
-  --> $DIR/from_iter_instead_of_collect.rs:8:5
+  --> $DIR/from_iter_instead_of_collect.rs:11:13
    |
-LL |     Vec::from_iter(iter_expr);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `iter_expr.collect()`
+LL |     let _ = Vec::from_iter(iter_expr);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `iter_expr.collect::<std::vec::Vec<i32>>()`
    |
    = note: `-D clippy::from-iter-instead-of-collect` implied by `-D warnings`
 
 error: usage of `FromIterator::from_iter`
-  --> $DIR/from_iter_instead_of_collect.rs:10:5
+  --> $DIR/from_iter_instead_of_collect.rs:13:13
    |
-LL |     HashMap::<usize, &i8>::from_iter(vec![5, 5, 5, 5].iter().enumerate());
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `vec![5, 5, 5, 5].iter().enumerate().collect()`
+LL |     let _ = HashMap::<usize, &i8>::from_iter(vec![5, 5, 5, 5].iter().enumerate());
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `vec![5, 5, 5, 5].iter().enumerate().collect::<std::collections::HashMap<usize, &i8>>()`
 
 error: usage of `FromIterator::from_iter`
-  --> $DIR/from_iter_instead_of_collect.rs:15:19
+  --> $DIR/from_iter_instead_of_collect.rs:18:19
    |
 LL |     assert_eq!(a, Vec::from_iter(0..3));
    |                   ^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `(0..3).collect::<std::vec::Vec<i32>>()`
 
 error: usage of `FromIterator::from_iter`
-  --> $DIR/from_iter_instead_of_collect.rs:17:17
+  --> $DIR/from_iter_instead_of_collect.rs:20:17
    |
 LL |     let mut b = VecDeque::from_iter(0..3);
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `(0..3).collect::<std::collections::VecDeque<i32>>()`
 
-error: aborting due to 4 previous errors
+error: usage of `FromIterator::from_iter`
+  --> $DIR/from_iter_instead_of_collect.rs:24:14
+   |
+LL |     let bm = BTreeMap::from_iter(values.iter().cloned());
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `values.iter().cloned().collect::<std::collections::BTreeMap<i32, char>>()`
+
+error: usage of `FromIterator::from_iter`
+  --> $DIR/from_iter_instead_of_collect.rs:25:19
+   |
+LL |     let mut bar = BTreeMap::from_iter(bm.range(0..2));
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `bm.range(0..2).collect::<std::collections::BTreeMap<&i32, &char>>()`
+
+error: usage of `FromIterator::from_iter`
+  --> $DIR/from_iter_instead_of_collect.rs:28:19
+   |
+LL |     let mut bts = BTreeSet::from_iter(0..3);
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `(0..3).collect::<std::collections::BTreeSet<i32>>()`
+
+error: usage of `FromIterator::from_iter`
+  --> $DIR/from_iter_instead_of_collect.rs:32:17
+   |
+LL |         let _ = collections::BTreeSet::from_iter(0..3);
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `(0..3).collect::<std::collections::BTreeSet<i32>>()`
+
+error: aborting due to 8 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 7b7e3ca5116983f5485bc9c8a5b2abf490900241 Mon Sep 17 00:00:00 2001
From: Philip Hayes <philiphayes@fb.com>
Date: Fri, 29 Jan 2021 22:18:56 -0800
Subject: Support free functions in disallowed-methods lint

In other words, support:

`disallowed_methods = ["alloc::vec::Vec::new"]` (a free function) in
addition to
`disallowed_methods = ["alloc::vec::Vec::leak"]` (a method).

Improve the documentation to clarify that users must specify the full
qualified path for each disallowed function, which can be confusing for
reexports. Include an example `clippy.toml`.

Simplify the actual lint pass so we can reuse `utils::fn_def_id`.
---
 clippy_lints/src/disallowed_method.rs              | 52 ++++++++++++++--------
 clippy_lints/src/utils/conf.rs                     |  2 +-
 tests/ui-toml/toml_disallowed_method/clippy.toml   |  2 +-
 .../conf_disallowed_method.rs                      |  3 +-
 .../conf_disallowed_method.stderr                  | 16 ++++---
 5 files changed, 48 insertions(+), 27 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/disallowed_method.rs b/clippy_lints/src/disallowed_method.rs
index 581c3242e37..56dc6d18a58 100644
--- a/clippy_lints/src/disallowed_method.rs
+++ b/clippy_lints/src/disallowed_method.rs
@@ -1,29 +1,47 @@
-use crate::utils::span_lint;
+use crate::utils::{fn_def_id, span_lint};
 
 use rustc_data_structures::fx::FxHashSet;
-use rustc_hir::{Expr, ExprKind};
+use rustc_hir::Expr;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::Symbol;
 
 declare_clippy_lint! {
-    /// **What it does:** Lints for specific trait methods defined in clippy.toml
+    /// **What it does:** Denies the configured methods and functions in clippy.toml
     ///
     /// **Why is this bad?** Some methods are undesirable in certain contexts,
-    /// and it would be beneficial to lint for them as needed.
+    /// and it's beneficial to lint for them as needed.
     ///
-    /// **Known problems:** None.
+    /// **Known problems:** Currently, you must write each function as a
+    /// fully-qualified path. This lint doesn't support aliases or reexported
+    /// names; be aware that many types in `std` are actually reexports.
+    ///
+    /// For example, if you want to disallow `Duration::as_secs`, your clippy.toml
+    /// configuration would look like
+    /// `disallowed-methods = ["core::time::Duration::as_secs"]` and not
+    /// `disallowed-methods = ["std::time::Duration::as_secs"]` as you might expect.
     ///
     /// **Example:**
     ///
+    /// An example clippy.toml configuration:
+    /// ```toml
+    /// # clippy.toml
+    /// disallowed-methods = ["alloc::vec::Vec::leak", "std::time::Instant::now"]
+    /// ```
+    ///
     /// ```rust,ignore
-    /// // example code where clippy issues a warning
-    /// foo.bad_method(); // Foo::bad_method is disallowed in the configuration
+    /// // Example code where clippy issues a warning
+    /// let xs = vec![1, 2, 3, 4];
+    /// xs.leak(); // Vec::leak is disallowed in the config.
+    ///
+    /// let _now = Instant::now(); // Instant::now is disallowed in the config.
     /// ```
+    ///
     /// Use instead:
     /// ```rust,ignore
-    /// // example code which does not raise clippy warning
-    /// goodStruct.bad_method(); // GoodStruct::bad_method is not disallowed
+    /// // Example code which does not raise clippy warning
+    /// let mut xs = Vec::new(); // Vec::new is _not_ disallowed in the config.
+    /// xs.push(123); // Vec::push is _not_ disallowed in the config.
     /// ```
     pub DISALLOWED_METHOD,
     nursery,
@@ -50,14 +68,12 @@ impl_lint_pass!(DisallowedMethod => [DISALLOWED_METHOD]);
 
 impl<'tcx> LateLintPass<'tcx> for DisallowedMethod {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if let ExprKind::MethodCall(_path, _, _args, _) = &expr.kind {
-            let def_id = cx.typeck_results().type_dependent_def_id(expr.hir_id).unwrap();
-
-            let method_call = cx.get_def_path(def_id);
-            if self.disallowed.contains(&method_call) {
-                let method = method_call
-                    .iter()
-                    .map(|s| s.to_ident_string())
+        if let Some(def_id) = fn_def_id(cx, expr) {
+            let func_path = cx.get_def_path(def_id);
+            if self.disallowed.contains(&func_path) {
+                let func_path_string = func_path
+                    .into_iter()
+                    .map(Symbol::to_ident_string)
                     .collect::<Vec<_>>()
                     .join("::");
 
@@ -65,7 +81,7 @@ impl<'tcx> LateLintPass<'tcx> for DisallowedMethod {
                     cx,
                     DISALLOWED_METHOD,
                     expr.span,
-                    &format!("use of a disallowed method `{}`", method),
+                    &format!("use of a disallowed method `{}`", func_path_string),
                 );
             }
         }
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index b5a8300376c..1fb99e04de3 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -169,7 +169,7 @@ define_Conf! {
     (max_fn_params_bools, "max_fn_params_bools": u64, 3),
     /// Lint: WILDCARD_IMPORTS. Whether to allow certain wildcard imports (prelude, super in tests).
     (warn_on_all_wildcard_imports, "warn_on_all_wildcard_imports": bool, false),
-    /// Lint: DISALLOWED_METHOD. The list of blacklisted methods to lint about. NB: `bar` is not here since it has legitimate uses
+    /// Lint: DISALLOWED_METHOD. The list of disallowed methods, written as fully qualified paths.
     (disallowed_methods, "disallowed_methods": Vec<String>, Vec::<String>::new()),
     /// Lint: UNREADABLE_LITERAL. Should the fraction of a decimal be linted to include separators.
     (unreadable_literal_lint_fractions, "unreadable_literal_lint_fractions": bool, true),
diff --git a/tests/ui-toml/toml_disallowed_method/clippy.toml b/tests/ui-toml/toml_disallowed_method/clippy.toml
index a1f515e443d..c0df3b6e8af 100644
--- a/tests/ui-toml/toml_disallowed_method/clippy.toml
+++ b/tests/ui-toml/toml_disallowed_method/clippy.toml
@@ -1 +1 @@
-disallowed-methods = ["core::iter::traits::iterator::Iterator::sum", "regex::re_unicode::Regex::is_match"]
+disallowed-methods = ["core::iter::traits::iterator::Iterator::sum", "regex::re_unicode::Regex::is_match", "regex::re_unicode::Regex::new"]
diff --git a/tests/ui-toml/toml_disallowed_method/conf_disallowed_method.rs b/tests/ui-toml/toml_disallowed_method/conf_disallowed_method.rs
index 3d3f0729abd..1901a99377e 100644
--- a/tests/ui-toml/toml_disallowed_method/conf_disallowed_method.rs
+++ b/tests/ui-toml/toml_disallowed_method/conf_disallowed_method.rs
@@ -4,10 +4,9 @@ extern crate regex;
 use regex::Regex;
 
 fn main() {
-    let a = vec![1, 2, 3, 4];
     let re = Regex::new(r"ab.*c").unwrap();
-
     re.is_match("abc");
 
+    let a = vec![1, 2, 3, 4];
     a.iter().sum::<i32>();
 }
diff --git a/tests/ui-toml/toml_disallowed_method/conf_disallowed_method.stderr b/tests/ui-toml/toml_disallowed_method/conf_disallowed_method.stderr
index ed91b5a6796..2b628c67fa7 100644
--- a/tests/ui-toml/toml_disallowed_method/conf_disallowed_method.stderr
+++ b/tests/ui-toml/toml_disallowed_method/conf_disallowed_method.stderr
@@ -1,16 +1,22 @@
+error: use of a disallowed method `regex::re_unicode::Regex::new`
+  --> $DIR/conf_disallowed_method.rs:7:14
+   |
+LL |     let re = Regex::new(r"ab.*c").unwrap();
+   |              ^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::disallowed-method` implied by `-D warnings`
+
 error: use of a disallowed method `regex::re_unicode::Regex::is_match`
-  --> $DIR/conf_disallowed_method.rs:10:5
+  --> $DIR/conf_disallowed_method.rs:8:5
    |
 LL |     re.is_match("abc");
    |     ^^^^^^^^^^^^^^^^^^
-   |
-   = note: `-D clippy::disallowed-method` implied by `-D warnings`
 
 error: use of a disallowed method `core::iter::traits::iterator::Iterator::sum`
-  --> $DIR/conf_disallowed_method.rs:12:5
+  --> $DIR/conf_disallowed_method.rs:11:5
    |
 LL |     a.iter().sum::<i32>();
    |     ^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 2 previous errors
+error: aborting due to 3 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 56f7fbb4ae67041fc1d2474da7fe52f5a2fd25a8 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Mon, 1 Feb 2021 19:22:31 -0600
Subject: Cleanup path to local checks

---
 clippy_lints/src/collapsible_match.rs              |  22 ++-
 clippy_lints/src/eval_order_dependence.rs          |  60 +++-----
 clippy_lints/src/functions.rs                      |  35 +++--
 clippy_lints/src/let_if_seq.rs                     |  17 +--
 clippy_lints/src/loops.rs                          | 168 +++++++--------------
 clippy_lints/src/manual_ok_or.rs                   |   9 +-
 clippy_lints/src/manual_unwrap_or.rs               |   8 +-
 clippy_lints/src/matches.rs                        |  15 +-
 clippy_lints/src/methods/mod.rs                    |  43 +++---
 clippy_lints/src/methods/unnecessary_filter_map.rs |  14 +-
 clippy_lints/src/to_string_in_display.rs           |  11 +-
 clippy_lints/src/utils/mod.rs                      |  29 +++-
 clippy_lints/src/utils/usage.rs                    |  34 +----
 clippy_lints/src/utils/visitors.rs                 |  16 +-
 14 files changed, 180 insertions(+), 301 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/collapsible_match.rs b/clippy_lints/src/collapsible_match.rs
index 604ba102046..834f294283e 100644
--- a/clippy_lints/src/collapsible_match.rs
+++ b/clippy_lints/src/collapsible_match.rs
@@ -1,10 +1,10 @@
 use crate::utils::visitors::LocalUsedVisitor;
-use crate::utils::{span_lint_and_then, SpanlessEq};
+use crate::utils::{path_to_local, span_lint_and_then, SpanlessEq};
 use if_chain::if_chain;
 use rustc_hir::def::{CtorKind, CtorOf, DefKind, Res};
 use rustc_hir::{Arm, Expr, ExprKind, Guard, HirId, Pat, PatKind, QPath, StmtKind, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty::{DefIdTree, TyCtxt};
+use rustc_middle::ty::{DefIdTree, TyCtxt, TypeckResults};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::{MultiSpan, Span};
 
@@ -72,7 +72,7 @@ fn check_arm(arm: &Arm<'_>, wild_outer_arm: &Arm<'_>, cx: &LateContext<'_>) {
         if arms_inner.iter().all(|arm| arm.guard.is_none());
         // match expression must be a local binding
         // match <local> { .. }
-        if let Some(binding_id) = addr_adjusted_binding(expr_in, cx);
+        if let Some(binding_id) = path_to_local(strip_ref_operators(expr_in, cx.typeck_results()));
         // one of the branches must be "wild-like"
         if let Some(wild_inner_arm_idx) = arms_inner.iter().rposition(|arm_inner| arm_is_wild_like(arm_inner, cx.tcx));
         let (wild_inner_arm, non_wild_inner_arm) =
@@ -175,19 +175,15 @@ fn is_none_ctor(res: Res, tcx: TyCtxt<'_>) -> bool {
     false
 }
 
-/// Retrieves a binding ID with optional `&` and/or `*` operators removed. (e.g. `&**foo`)
-/// Returns `None` if a non-reference type is de-referenced.
-/// For example, if `Vec` is de-referenced to a slice, `None` is returned.
-fn addr_adjusted_binding(mut expr: &Expr<'_>, cx: &LateContext<'_>) -> Option<HirId> {
+/// Removes `AddrOf` operators (`&`) or deref operators (`*`), but only if a reference type is
+/// dereferenced. An overloaded deref such as `Vec` to slice would not be removed.
+fn strip_ref_operators<'hir>(mut expr: &'hir Expr<'hir>, typeck_results: &TypeckResults<'_>) -> &'hir Expr<'hir> {
     loop {
         match expr.kind {
             ExprKind::AddrOf(_, _, e) => expr = e,
-            ExprKind::Path(QPath::Resolved(None, path)) => match path.res {
-                Res::Local(binding_id) => break Some(binding_id),
-                _ => break None,
-            },
-            ExprKind::Unary(UnOp::UnDeref, e) if cx.typeck_results().expr_ty(e).is_ref() => expr = e,
-            _ => break None,
+            ExprKind::Unary(UnOp::UnDeref, e) if typeck_results.expr_ty(e).is_ref() => expr = e,
+            _ => break,
         }
     }
+    expr
 }
diff --git a/clippy_lints/src/eval_order_dependence.rs b/clippy_lints/src/eval_order_dependence.rs
index bc2b2904698..83cee11c3a8 100644
--- a/clippy_lints/src/eval_order_dependence.rs
+++ b/clippy_lints/src/eval_order_dependence.rs
@@ -1,7 +1,6 @@
-use crate::utils::{get_parent_expr, span_lint, span_lint_and_note};
-use if_chain::if_chain;
+use crate::utils::{get_parent_expr, path_to_local, path_to_local_id, span_lint, span_lint_and_note};
 use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
-use rustc_hir::{def, BinOpKind, Block, Expr, ExprKind, Guard, HirId, Local, Node, QPath, Stmt, StmtKind};
+use rustc_hir::{BinOpKind, Block, Expr, ExprKind, Guard, HirId, Local, Node, Stmt, StmtKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::map::Map;
 use rustc_middle::ty;
@@ -72,20 +71,14 @@ impl<'tcx> LateLintPass<'tcx> for EvalOrderDependence {
         // Find a write to a local variable.
         match expr.kind {
             ExprKind::Assign(ref lhs, ..) | ExprKind::AssignOp(_, ref lhs, _) => {
-                if let ExprKind::Path(ref qpath) = lhs.kind {
-                    if let QPath::Resolved(_, ref path) = *qpath {
-                        if path.segments.len() == 1 {
-                            if let def::Res::Local(var) = cx.qpath_res(qpath, lhs.hir_id) {
-                                let mut visitor = ReadVisitor {
-                                    cx,
-                                    var,
-                                    write_expr: expr,
-                                    last_expr: expr,
-                                };
-                                check_for_unsequenced_reads(&mut visitor);
-                            }
-                        }
-                    }
+                if let Some(var) = path_to_local(lhs) {
+                    let mut visitor = ReadVisitor {
+                        cx,
+                        var,
+                        write_expr: expr,
+                        last_expr: expr,
+                    };
+                    check_for_unsequenced_reads(&mut visitor);
                 }
             },
             _ => {},
@@ -304,27 +297,20 @@ impl<'a, 'tcx> Visitor<'tcx> for ReadVisitor<'a, 'tcx> {
             return;
         }
 
-        match expr.kind {
-            ExprKind::Path(ref qpath) => {
-                if_chain! {
-                    if let QPath::Resolved(None, ref path) = *qpath;
-                    if path.segments.len() == 1;
-                    if let def::Res::Local(local_id) = self.cx.qpath_res(qpath, expr.hir_id);
-                    if local_id == self.var;
-                    // Check that this is a read, not a write.
-                    if !is_in_assignment_position(self.cx, expr);
-                    then {
-                        span_lint_and_note(
-                            self.cx,
-                            EVAL_ORDER_DEPENDENCE,
-                            expr.span,
-                            "unsequenced read of a variable",
-                            Some(self.write_expr.span),
-                            "whether read occurs before this write depends on evaluation order"
-                        );
-                    }
-                }
+        if path_to_local_id(expr, self.var) {
+            // Check that this is a read, not a write.
+            if !is_in_assignment_position(self.cx, expr) {
+                span_lint_and_note(
+                    self.cx,
+                    EVAL_ORDER_DEPENDENCE,
+                    expr.span,
+                    "unsequenced read of a variable",
+                    Some(self.write_expr.span),
+                    "whether read occurs before this write depends on evaluation order",
+                );
             }
+        }
+        match expr.kind {
             // We're about to descend a closure. Since we don't know when (or
             // if) the closure will be evaluated, any reads in it might not
             // occur here (or ever). Like above, bail to avoid false positives.
diff --git a/clippy_lints/src/functions.rs b/clippy_lints/src/functions.rs
index 87954254610..8344d974728 100644
--- a/clippy_lints/src/functions.rs
+++ b/clippy_lints/src/functions.rs
@@ -1,7 +1,7 @@
 use crate::utils::{
     attr_by_name, attrs::is_proc_macro, is_must_use_ty, is_trait_impl_item, is_type_diagnostic_item, iter_input_pats,
-    last_path_segment, match_def_path, must_use_attr, return_ty, snippet, snippet_opt, span_lint, span_lint_and_help,
-    span_lint_and_then, trait_ref_of_method, type_is_unsafe_function,
+    last_path_segment, match_def_path, must_use_attr, path_to_local, return_ty, snippet, snippet_opt, span_lint,
+    span_lint_and_help, span_lint_and_then, trait_ref_of_method, type_is_unsafe_function,
 };
 use if_chain::if_chain;
 use rustc_ast::ast::Attribute;
@@ -9,7 +9,7 @@ use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_hir::intravisit;
-use rustc_hir::{def::Res, def_id::DefId};
+use rustc_hir::{def::Res, def_id::DefId, QPath};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::hir::map::Map;
 use rustc_middle::lint::in_external_macro;
@@ -658,16 +658,14 @@ impl<'a, 'tcx> intravisit::Visitor<'tcx> for DerefVisitor<'a, 'tcx> {
 
 impl<'a, 'tcx> DerefVisitor<'a, 'tcx> {
     fn check_arg(&self, ptr: &hir::Expr<'_>) {
-        if let hir::ExprKind::Path(ref qpath) = ptr.kind {
-            if let Res::Local(id) = self.cx.qpath_res(qpath, ptr.hir_id) {
-                if self.ptrs.contains(&id) {
-                    span_lint(
-                        self.cx,
-                        NOT_UNSAFE_PTR_ARG_DEREF,
-                        ptr.span,
-                        "this public function dereferences a raw pointer but is not marked `unsafe`",
-                    );
-                }
+        if let Some(id) = path_to_local(ptr) {
+            if self.ptrs.contains(&id) {
+                span_lint(
+                    self.cx,
+                    NOT_UNSAFE_PTR_ARG_DEREF,
+                    ptr.span,
+                    "this public function dereferences a raw pointer but is not marked `unsafe`",
+                );
             }
         }
     }
@@ -698,7 +696,7 @@ impl<'a, 'tcx> intravisit::Visitor<'tcx> for StaticMutVisitor<'a, 'tcx> {
                             arg.span,
                             &mut tys,
                         )
-                        && is_mutated_static(self.cx, arg)
+                        && is_mutated_static(arg)
                     {
                         self.mutates_static = true;
                         return;
@@ -707,7 +705,7 @@ impl<'a, 'tcx> intravisit::Visitor<'tcx> for StaticMutVisitor<'a, 'tcx> {
                 }
             },
             Assign(ref target, ..) | AssignOp(_, ref target, _) | AddrOf(_, hir::Mutability::Mut, ref target) => {
-                self.mutates_static |= is_mutated_static(self.cx, target)
+                self.mutates_static |= is_mutated_static(target)
             },
             _ => {},
         }
@@ -718,12 +716,13 @@ impl<'a, 'tcx> intravisit::Visitor<'tcx> for StaticMutVisitor<'a, 'tcx> {
     }
 }
 
-fn is_mutated_static(cx: &LateContext<'_>, e: &hir::Expr<'_>) -> bool {
+fn is_mutated_static(e: &hir::Expr<'_>) -> bool {
     use hir::ExprKind::{Field, Index, Path};
 
     match e.kind {
-        Path(ref qpath) => !matches!(cx.qpath_res(qpath, e.hir_id), Res::Local(_)),
-        Field(ref inner, _) | Index(ref inner, _) => is_mutated_static(cx, inner),
+        Path(QPath::Resolved(_, path)) => !matches!(path.res, Res::Local(_)),
+        Path(_) => true,
+        Field(ref inner, _) | Index(ref inner, _) => is_mutated_static(inner),
         _ => false,
     }
 }
diff --git a/clippy_lints/src/let_if_seq.rs b/clippy_lints/src/let_if_seq.rs
index 5886c2360e3..6beaa51729a 100644
--- a/clippy_lints/src/let_if_seq.rs
+++ b/clippy_lints/src/let_if_seq.rs
@@ -1,8 +1,7 @@
-use crate::utils::{snippet, span_lint_and_then, visitors::LocalUsedVisitor};
+use crate::utils::{path_to_local_id, snippet, span_lint_and_then, visitors::LocalUsedVisitor};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
-use rustc_hir::def::Res;
 use rustc_hir::BindingAnnotation;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -66,7 +65,7 @@ impl<'tcx> LateLintPass<'tcx> for LetIfSeq {
                 if let hir::ExprKind::If(ref cond, ref then, ref else_) = if_.kind;
                 if !LocalUsedVisitor::new(canonical_id).check_expr(cond);
                 if let hir::ExprKind::Block(ref then, _) = then.kind;
-                if let Some(value) = check_assign(cx, canonical_id, &*then);
+                if let Some(value) = check_assign(canonical_id, &*then);
                 if !LocalUsedVisitor::new(canonical_id).check_expr(value);
                 then {
                     let span = stmt.span.to(if_.span);
@@ -79,7 +78,7 @@ impl<'tcx> LateLintPass<'tcx> for LetIfSeq {
 
                     let (default_multi_stmts, default) = if let Some(ref else_) = *else_ {
                         if let hir::ExprKind::Block(ref else_, _) = else_.kind {
-                            if let Some(default) = check_assign(cx, canonical_id, else_) {
+                            if let Some(default) = check_assign(canonical_id, else_) {
                                 (else_.stmts.len() > 1, default)
                             } else if let Some(ref default) = local.init {
                                 (true, &**default)
@@ -134,19 +133,13 @@ impl<'tcx> LateLintPass<'tcx> for LetIfSeq {
     }
 }
 
-fn check_assign<'tcx>(
-    cx: &LateContext<'tcx>,
-    decl: hir::HirId,
-    block: &'tcx hir::Block<'_>,
-) -> Option<&'tcx hir::Expr<'tcx>> {
+fn check_assign<'tcx>(decl: hir::HirId, block: &'tcx hir::Block<'_>) -> Option<&'tcx hir::Expr<'tcx>> {
     if_chain! {
         if block.expr.is_none();
         if let Some(expr) = block.stmts.iter().last();
         if let hir::StmtKind::Semi(ref expr) = expr.kind;
         if let hir::ExprKind::Assign(ref var, ref value, _) = expr.kind;
-        if let hir::ExprKind::Path(ref qpath) = var.kind;
-        if let Res::Local(local_id) = cx.qpath_res(qpath, var.hir_id);
-        if decl == local_id;
+        if path_to_local_id(var, decl);
         then {
             let mut v = LocalUsedVisitor::new(decl);
 
diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 663c2df23e2..d202072e920 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -1,14 +1,13 @@
 use crate::consts::constant;
-use crate::utils::paths;
 use crate::utils::sugg::Sugg;
-use crate::utils::usage::{is_unused, mutated_variables};
+use crate::utils::usage::mutated_variables;
 use crate::utils::visitors::LocalUsedVisitor;
 use crate::utils::{
     contains_name, get_enclosing_block, get_parent_expr, get_trait_def_id, has_iter_method, higher, implements_trait,
     indent_of, is_in_panic_handler, is_integer_const, is_no_std_crate, is_ok_ctor, is_refutable, is_some_ctor,
-    is_type_diagnostic_item, last_path_segment, match_trait_method, match_type, match_var, multispan_sugg,
-    single_segment_path, snippet, snippet_with_applicability, snippet_with_macro_callsite, span_lint,
-    span_lint_and_help, span_lint_and_sugg, span_lint_and_then, sugg, SpanlessEq,
+    is_type_diagnostic_item, last_path_segment, match_trait_method, match_type, multispan_sugg, path_to_local,
+    path_to_local_id, paths, single_segment_path, snippet, snippet_with_applicability, snippet_with_macro_callsite,
+    span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then, sugg, SpanlessEq,
 };
 use if_chain::if_chain;
 use rustc_ast::ast;
@@ -877,21 +876,6 @@ fn get_span_of_entire_for_loop(expr: &Expr<'_>) -> Span {
     }
 }
 
-fn same_var<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, var: HirId) -> bool {
-    if_chain! {
-        if let ExprKind::Path(qpath) = &expr.kind;
-        if let QPath::Resolved(None, path) = qpath;
-        if path.segments.len() == 1;
-        if let Res::Local(local_id) = cx.qpath_res(qpath, expr.hir_id);
-        then {
-            // our variable!
-            local_id == var
-        } else {
-            false
-        }
-    }
-}
-
 /// a wrapper of `Sugg`. Besides what `Sugg` do, this removes unnecessary `0`;
 /// and also, it avoids subtracting a variable from the same one by replacing it with `0`.
 /// it exists for the convenience of the overloaded operators while normal functions can do the
@@ -1044,14 +1028,9 @@ fn get_details_from_idx<'tcx>(
     idx: &Expr<'_>,
     starts: &[Start<'tcx>],
 ) -> Option<(StartKind<'tcx>, Offset)> {
-    fn get_start<'tcx>(cx: &LateContext<'tcx>, e: &Expr<'_>, starts: &[Start<'tcx>]) -> Option<StartKind<'tcx>> {
-        starts.iter().find_map(|start| {
-            if same_var(cx, e, start.id) {
-                Some(start.kind)
-            } else {
-                None
-            }
-        })
+    fn get_start<'tcx>(e: &Expr<'_>, starts: &[Start<'tcx>]) -> Option<StartKind<'tcx>> {
+        let id = path_to_local(e)?;
+        starts.iter().find(|start| start.id == id).map(|start| start.kind)
     }
 
     fn get_offset<'tcx>(cx: &LateContext<'tcx>, e: &Expr<'_>, starts: &[Start<'tcx>]) -> Option<Sugg<'static>> {
@@ -1060,7 +1039,7 @@ fn get_details_from_idx<'tcx>(
                 ast::LitKind::Int(x, _ty) => Some(Sugg::NonParen(x.to_string().into())),
                 _ => None,
             },
-            ExprKind::Path(..) if get_start(cx, e, starts).is_none() => Some(Sugg::hir(cx, e, "???")),
+            ExprKind::Path(..) if get_start(e, starts).is_none() => Some(Sugg::hir(cx, e, "???")),
             _ => None,
         }
     }
@@ -1068,18 +1047,18 @@ fn get_details_from_idx<'tcx>(
     match idx.kind {
         ExprKind::Binary(op, lhs, rhs) => match op.node {
             BinOpKind::Add => {
-                let offset_opt = get_start(cx, lhs, starts)
+                let offset_opt = get_start(lhs, starts)
                     .and_then(|s| get_offset(cx, rhs, starts).map(|o| (s, o)))
-                    .or_else(|| get_start(cx, rhs, starts).and_then(|s| get_offset(cx, lhs, starts).map(|o| (s, o))));
+                    .or_else(|| get_start(rhs, starts).and_then(|s| get_offset(cx, lhs, starts).map(|o| (s, o))));
 
                 offset_opt.map(|(s, o)| (s, Offset::positive(o)))
             },
             BinOpKind::Sub => {
-                get_start(cx, lhs, starts).and_then(|s| get_offset(cx, rhs, starts).map(|o| (s, Offset::negative(o))))
+                get_start(lhs, starts).and_then(|s| get_offset(cx, rhs, starts).map(|o| (s, Offset::negative(o))))
             },
             _ => None,
         },
-        ExprKind::Path(..) => get_start(cx, idx, starts).map(|s| (s, Offset::empty())),
+        ExprKind::Path(..) => get_start(idx, starts).map(|s| (s, Offset::empty())),
         _ => None,
     }
 }
@@ -1096,11 +1075,10 @@ fn get_assignment<'tcx>(e: &'tcx Expr<'tcx>) -> Option<(&'tcx Expr<'tcx>, &'tcx
 /// The returned iterator yields `None` if no assignment expressions are there,
 /// filtering out the increments of the given whitelisted loop counters;
 /// because its job is to make sure there's nothing other than assignments and the increments.
-fn get_assignments<'a: 'c, 'tcx: 'c, 'c>(
-    cx: &'a LateContext<'tcx>,
+fn get_assignments<'a, 'tcx>(
     Block { stmts, expr, .. }: &'tcx Block<'tcx>,
-    loop_counters: &'c [Start<'tcx>],
-) -> impl Iterator<Item = Option<(&'tcx Expr<'tcx>, &'tcx Expr<'tcx>)>> + 'c {
+    loop_counters: &'a [Start<'tcx>],
+) -> impl Iterator<Item = Option<(&'tcx Expr<'tcx>, &'tcx Expr<'tcx>)>> + 'a {
     // As the `filter` and `map` below do different things, I think putting together
     // just increases complexity. (cc #3188 and #4193)
     stmts
@@ -1112,12 +1090,14 @@ fn get_assignments<'a: 'c, 'tcx: 'c, 'c>(
         .chain((*expr).into_iter())
         .filter(move |e| {
             if let ExprKind::AssignOp(_, place, _) = e.kind {
-                !loop_counters
-                    .iter()
-                    // skip the first item which should be `StartKind::Range`
-                    // this makes it possible to use the slice with `StartKind::Range` in the same iterator loop.
-                    .skip(1)
-                    .any(|counter| same_var(cx, place, counter.id))
+                path_to_local(place).map_or(false, |id| {
+                    !loop_counters
+                        .iter()
+                        // skip the first item which should be `StartKind::Range`
+                        // this makes it possible to use the slice with `StartKind::Range` in the same iterator loop.
+                        .skip(1)
+                        .any(|counter| counter.id == id)
+                })
             } else {
                 true
             }
@@ -1174,7 +1154,7 @@ fn build_manual_memcpy_suggestion<'tcx>(
             if method.ident.name == sym!(len);
             if len_args.len() == 1;
             if let Some(arg) = len_args.get(0);
-            if var_def_id(cx, arg) == var_def_id(cx, base);
+            if path_to_local(arg) == path_to_local(base);
             then {
                 if sugg.as_str() == end_str {
                     sugg::EMPTY.into()
@@ -1279,7 +1259,7 @@ fn detect_manual_memcpy<'tcx>(
                 if let Some(loop_counters) = get_loop_counters(cx, block, expr) {
                     starts.extend(loop_counters);
                 }
-                iter_a = Some(get_assignments(cx, block, &starts));
+                iter_a = Some(get_assignments(block, &starts));
             } else {
                 iter_b = Some(get_assignment(body));
             }
@@ -1301,7 +1281,7 @@ fn detect_manual_memcpy<'tcx>(
                             if let Some((start_right, offset_right)) = get_details_from_idx(cx, &idx_right, &starts);
 
                             // Source and destination must be different
-                            if var_def_id(cx, base_left) != var_def_id(cx, base_right);
+                            if path_to_local(base_left) != path_to_local(base_right);
                             then {
                                 Some((IndexExpr { base: base_left, idx: start_left, idx_offset: offset_left },
                                     IndexExpr { base: base_right, idx: start_right, idx_offset: offset_right }))
@@ -2018,9 +1998,7 @@ fn check_manual_flatten<'tcx>(
             ) = inner_expr.kind;
             // Ensure match_expr in `if let` statement is the same as the pat from the for-loop
             if let PatKind::Binding(_, pat_hir_id, _, _) = pat.kind;
-            if let ExprKind::Path(QPath::Resolved(None, match_expr_path)) = match_expr.kind;
-            if let Res::Local(match_expr_path_id) = match_expr_path.res;
-            if pat_hir_id == match_expr_path_id;
+            if path_to_local_id(match_expr, pat_hir_id);
             // Ensure the `if let` statement is for the `Some` variant of `Option` or the `Ok` variant of `Result`
             if let PatKind::TupleStruct(QPath::Resolved(None, path), _, _) = match_arms[0].pat.kind;
             let some_ctor = is_some_ctor(cx, path.res);
@@ -2131,20 +2109,11 @@ fn mut_warn_with_span(cx: &LateContext<'_>, span: Option<Span>) {
 
 fn check_for_mutability(cx: &LateContext<'_>, bound: &Expr<'_>) -> Option<HirId> {
     if_chain! {
-        if let ExprKind::Path(ref qpath) = bound.kind;
-        if let QPath::Resolved(None, _) = *qpath;
+        if let Some(hir_id) = path_to_local(bound);
+        if let Node::Binding(pat) = cx.tcx.hir().get(hir_id);
+        if let PatKind::Binding(BindingAnnotation::Mutable, ..) = pat.kind;
         then {
-            let res = cx.qpath_res(qpath, bound.hir_id);
-            if let Res::Local(hir_id) = res {
-                let node_str = cx.tcx.hir().get(hir_id);
-                if_chain! {
-                    if let Node::Binding(pat) = node_str;
-                    if let PatKind::Binding(BindingAnnotation::Mutable, ..) = pat.kind;
-                    then {
-                        return Some(hir_id);
-                    }
-                }
-            }
+            return Some(hir_id);
         }
     }
     None
@@ -2179,7 +2148,9 @@ fn check_for_mutation<'tcx>(
 fn pat_is_wild<'tcx>(pat: &'tcx PatKind<'_>, body: &'tcx Expr<'_>) -> bool {
     match *pat {
         PatKind::Wild => true,
-        PatKind::Binding(.., ident, None) if ident.as_str().starts_with('_') => is_unused(&ident, body),
+        PatKind::Binding(_, id, ident, None) if ident.as_str().starts_with('_') => {
+            !LocalUsedVisitor::new(id).check_expr(body)
+        },
         _ => false,
     }
 }
@@ -2215,7 +2186,7 @@ impl<'a, 'tcx> VarVisitor<'a, 'tcx> {
             if let QPath::Resolved(None, ref seqvar) = *seqpath;
             if seqvar.segments.len() == 1;
             then {
-                let index_used_directly = same_var(self.cx, idx, self.var);
+                let index_used_directly = path_to_local_id(idx, self.var);
                 let indexed_indirectly = {
                     let mut used_visitor = LocalUsedVisitor::new(self.var);
                     walk_expr(&mut used_visitor, idx);
@@ -2286,17 +2257,14 @@ impl<'a, 'tcx> Visitor<'tcx> for VarVisitor<'a, 'tcx> {
 
         if_chain! {
             // directly using a variable
-            if let ExprKind::Path(ref qpath) = expr.kind;
-            if let QPath::Resolved(None, ref path) = *qpath;
-            if path.segments.len() == 1;
+            if let ExprKind::Path(QPath::Resolved(None, path)) = expr.kind;
+            if let Res::Local(local_id) = path.res;
             then {
-                if let Res::Local(local_id) = self.cx.qpath_res(qpath, expr.hir_id) {
-                    if local_id == self.var {
-                        self.nonindex = true;
-                    } else {
-                        // not the correct variable, but still a variable
-                        self.referenced.insert(path.segments[0].ident.name);
-                    }
+                if local_id == self.var {
+                    self.nonindex = true;
+                } else {
+                    // not the correct variable, but still a variable
+                    self.referenced.insert(path.segments[0].ident.name);
                 }
             }
         }
@@ -2354,7 +2322,7 @@ impl<'a, 'tcx> Visitor<'tcx> for VarVisitor<'a, 'tcx> {
 }
 
 fn is_used_inside<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, container: &'tcx Expr<'_>) -> bool {
-    let def_id = match var_def_id(cx, expr) {
+    let def_id = match path_to_local(expr) {
         Some(id) => id,
         None => return false,
     };
@@ -2367,12 +2335,11 @@ fn is_used_inside<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, container:
 }
 
 fn is_iterator_used_after_while_let<'tcx>(cx: &LateContext<'tcx>, iter_expr: &'tcx Expr<'_>) -> bool {
-    let def_id = match var_def_id(cx, iter_expr) {
+    let def_id = match path_to_local(iter_expr) {
         Some(id) => id,
         None => return false,
     };
     let mut visitor = VarUsedAfterLoopVisitor {
-        cx,
         def_id,
         iter_expr_id: iter_expr.hir_id,
         past_while_let: false,
@@ -2384,20 +2351,19 @@ fn is_iterator_used_after_while_let<'tcx>(cx: &LateContext<'tcx>, iter_expr: &'t
     visitor.var_used_after_while_let
 }
 
-struct VarUsedAfterLoopVisitor<'a, 'tcx> {
-    cx: &'a LateContext<'tcx>,
+struct VarUsedAfterLoopVisitor {
     def_id: HirId,
     iter_expr_id: HirId,
     past_while_let: bool,
     var_used_after_while_let: bool,
 }
 
-impl<'a, 'tcx> Visitor<'tcx> for VarUsedAfterLoopVisitor<'a, 'tcx> {
+impl<'tcx> Visitor<'tcx> for VarUsedAfterLoopVisitor {
     type Map = Map<'tcx>;
 
     fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
         if self.past_while_let {
-            if Some(self.def_id) == var_def_id(self.cx, expr) {
+            if path_to_local_id(expr, self.def_id) {
                 self.var_used_after_while_let = true;
             }
         } else if self.iter_expr_id == expr.hir_id {
@@ -2519,7 +2485,7 @@ impl<'a, 'tcx> Visitor<'tcx> for IncrementVisitor<'a, 'tcx> {
         }
 
         // If node is a variable
-        if let Some(def_id) = var_def_id(self.cx, expr) {
+        if let Some(def_id) = path_to_local(expr) {
             if let Some(parent) = get_parent_expr(self.cx, expr) {
                 let state = self.states.entry(def_id).or_insert(IncrementVisitorVarState::Initial);
                 if *state == IncrementVisitorVarState::IncrOnce {
@@ -2646,7 +2612,7 @@ impl<'a, 'tcx> Visitor<'tcx> for InitializeVisitor<'a, 'tcx> {
         }
 
         // If node is the desired variable, see how it's used
-        if var_def_id(self.cx, expr) == Some(self.var_id) {
+        if path_to_local_id(expr, self.var_id) {
             if self.past_loop {
                 self.state = InitializeVisitorState::DontWarn;
                 return;
@@ -2693,16 +2659,6 @@ impl<'a, 'tcx> Visitor<'tcx> for InitializeVisitor<'a, 'tcx> {
     }
 }
 
-fn var_def_id(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<HirId> {
-    if let ExprKind::Path(ref qpath) = expr.kind {
-        let path_res = cx.qpath_res(qpath, expr.hir_id);
-        if let Res::Local(hir_id) = path_res {
-            return Some(hir_id);
-        }
-    }
-    None
-}
-
 fn is_loop(expr: &Expr<'_>) -> bool {
     matches!(expr.kind, ExprKind::Loop(..))
 }
@@ -2725,8 +2681,8 @@ fn is_nested(cx: &LateContext<'_>, match_expr: &Expr<'_>, iter_expr: &Expr<'_>)
 
 fn is_loop_nested(cx: &LateContext<'_>, loop_expr: &Expr<'_>, iter_expr: &Expr<'_>) -> bool {
     let mut id = loop_expr.hir_id;
-    let iter_name = if let Some(name) = path_name(iter_expr) {
-        name
+    let iter_id = if let Some(id) = path_to_local(iter_expr) {
+        id
     } else {
         return true;
     };
@@ -2744,7 +2700,7 @@ fn is_loop_nested(cx: &LateContext<'_>, loop_expr: &Expr<'_>, iter_expr: &Expr<'
             Some(Node::Block(block)) => {
                 let mut block_visitor = LoopNestVisitor {
                     hir_id: id,
-                    iterator: iter_name,
+                    iterator: iter_id,
                     nesting: Unknown,
                 };
                 walk_block(&mut block_visitor, block);
@@ -2772,7 +2728,7 @@ use self::Nesting::{LookFurther, RuledOut, Unknown};
 
 struct LoopNestVisitor {
     hir_id: HirId,
-    iterator: Symbol,
+    iterator: HirId,
     nesting: Nesting,
 }
 
@@ -2797,7 +2753,7 @@ impl<'tcx> Visitor<'tcx> for LoopNestVisitor {
         }
         match expr.kind {
             ExprKind::Assign(ref path, _, _) | ExprKind::AssignOp(_, ref path, _) => {
-                if match_var(path, self.iterator) {
+                if path_to_local_id(path, self.iterator) {
                     self.nesting = RuledOut;
                 }
             },
@@ -2809,8 +2765,8 @@ impl<'tcx> Visitor<'tcx> for LoopNestVisitor {
         if self.nesting != Unknown {
             return;
         }
-        if let PatKind::Binding(.., span_name, _) = pat.kind {
-            if self.iterator == span_name.name {
+        if let PatKind::Binding(_, id, ..) = pat.kind {
+            if id == self.iterator {
                 self.nesting = RuledOut;
                 return;
             }
@@ -2823,16 +2779,6 @@ impl<'tcx> Visitor<'tcx> for LoopNestVisitor {
     }
 }
 
-fn path_name(e: &Expr<'_>) -> Option<Symbol> {
-    if let ExprKind::Path(QPath::Resolved(_, ref path)) = e.kind {
-        let segments = &path.segments;
-        if segments.len() == 1 {
-            return Some(segments[0].ident.name);
-        }
-    };
-    None
-}
-
 fn check_infinite_loop<'tcx>(cx: &LateContext<'tcx>, cond: &'tcx Expr<'_>, expr: &'tcx Expr<'_>) {
     if constant(cx, cx.typeck_results(), cond).is_some() {
         // A pure constant condition (e.g., `while false`) is not linted.
@@ -3194,7 +3140,7 @@ impl<'a, 'tcx> Visitor<'tcx> for UsedCountVisitor<'a, 'tcx> {
     type Map = Map<'tcx>;
 
     fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
-        if same_var(self.cx, expr, self.id) {
+        if path_to_local_id(expr, self.id) {
             self.count += 1;
         } else {
             walk_expr(self, expr);
diff --git a/clippy_lints/src/manual_ok_or.rs b/clippy_lints/src/manual_ok_or.rs
index 8c77e155b70..efb05b8ffdf 100644
--- a/clippy_lints/src/manual_ok_or.rs
+++ b/clippy_lints/src/manual_ok_or.rs
@@ -1,9 +1,10 @@
 use crate::utils::{
-    indent_of, is_type_diagnostic_item, match_qpath, paths, reindent_multiline, snippet_opt, span_lint_and_sugg,
+    indent_of, is_type_diagnostic_item, match_qpath, path_to_local_id, paths, reindent_multiline, snippet_opt,
+    span_lint_and_sugg,
 };
 use if_chain::if_chain;
 use rustc_errors::Applicability;
-use rustc_hir::{def, Expr, ExprKind, PatKind, QPath};
+use rustc_hir::{Expr, ExprKind, PatKind};
 use rustc_lint::LintContext;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::lint::in_external_macro;
@@ -90,8 +91,6 @@ fn is_ok_wrapping(cx: &LateContext<'_>, map_expr: &Expr<'_>) -> bool {
         if let PatKind::Binding(_, param_id, ..) = body.params[0].pat.kind;
         if let ExprKind::Call(Expr { kind: ExprKind::Path(ok_path), .. }, &[ref ok_arg]) = body.value.kind;
         if match_qpath(ok_path, &paths::RESULT_OK);
-        if let ExprKind::Path(QPath::Resolved(_, ok_arg_path)) = ok_arg.kind;
-        if let def::Res::Local(ok_arg_path_id) = ok_arg_path.res;
-        then { param_id == ok_arg_path_id } else { false }
+        then { path_to_local_id(ok_arg, param_id) } else { false }
     }
 }
diff --git a/clippy_lints/src/manual_unwrap_or.rs b/clippy_lints/src/manual_unwrap_or.rs
index 9e2c6c7f231..b452225b5db 100644
--- a/clippy_lints/src/manual_unwrap_or.rs
+++ b/clippy_lints/src/manual_unwrap_or.rs
@@ -1,9 +1,9 @@
 use crate::consts::constant_simple;
 use crate::utils;
-use crate::utils::sugg;
+use crate::utils::{path_to_local_id, sugg};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
-use rustc_hir::{def, Arm, Expr, ExprKind, Pat, PatKind, QPath};
+use rustc_hir::{Arm, Expr, ExprKind, Pat, PatKind};
 use rustc_lint::LintContext;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::lint::in_external_macro;
@@ -83,9 +83,7 @@ fn lint_manual_unwrap_or<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
             if utils::match_qpath(unwrap_qpath, &utils::paths::OPTION_SOME)
                 || utils::match_qpath(unwrap_qpath, &utils::paths::RESULT_OK);
             if let PatKind::Binding(_, binding_hir_id, ..) = unwrap_pat.kind;
-            if let ExprKind::Path(QPath::Resolved(_, body_path)) = unwrap_arm.body.kind;
-            if let def::Res::Local(body_path_hir_id) = body_path.res;
-            if body_path_hir_id == binding_hir_id;
+            if path_to_local_id(unwrap_arm.body, binding_hir_id);
             if !utils::usage::contains_return_break_continue_macro(or_arm.body);
             then {
                 Some(or_arm)
diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index ba7b9bd0424..c4aa2b30e7b 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -1,11 +1,12 @@
 use crate::consts::{constant, miri_to_const, Constant};
 use crate::utils::sugg::Sugg;
-use crate::utils::usage::is_unused;
+use crate::utils::visitors::LocalUsedVisitor;
 use crate::utils::{
-    expr_block, get_arg_name, get_parent_expr, implements_trait, in_macro, indent_of, is_allowed, is_expn_of,
-    is_refutable, is_type_diagnostic_item, is_wild, match_qpath, match_type, match_var, meets_msrv, multispan_sugg,
+    expr_block, get_parent_expr, implements_trait, in_macro, indent_of, is_allowed, is_expn_of, is_refutable,
+    is_type_diagnostic_item, is_wild, match_qpath, match_type, meets_msrv, multispan_sugg, path_to_local_id,
     peel_hir_pat_refs, peel_mid_ty_refs, peel_n_hir_expr_refs, remove_blocks, snippet, snippet_block, snippet_opt,
     snippet_with_applicability, span_lint_and_help, span_lint_and_note, span_lint_and_sugg, span_lint_and_then,
+    strip_pat_refs,
 };
 use crate::utils::{paths, search_same, SpanlessEq, SpanlessHash};
 use if_chain::if_chain;
@@ -616,9 +617,9 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
             if let PatKind::TupleStruct(
                 QPath::Resolved(None, ref variant_name), ref args, _) = arms[0].pat.kind;
             if args.len() == 1;
-            if let Some(arg) = get_arg_name(&args[0]);
+            if let PatKind::Binding(_, arg, ..) = strip_pat_refs(&args[0]).kind;
             let body = remove_blocks(&arms[0].body);
-            if match_var(body, arg);
+            if path_to_local_id(body, arg);
 
             then {
                 let mut applicability = Applicability::MachineApplicable;
@@ -922,8 +923,8 @@ fn check_wild_err_arm(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>]) {
                     if !matching_wild {
                         // Looking for unused bindings (i.e.: `_e`)
                         inner.iter().for_each(|pat| {
-                            if let PatKind::Binding(.., ident, None) = &pat.kind {
-                                if ident.as_str().starts_with('_') && is_unused(ident, arm.body) {
+                            if let PatKind::Binding(_, id, ident, None) = pat.kind {
+                                if ident.as_str().starts_with('_') && !LocalUsedVisitor::new(id).check_expr(arm.body) {
                                     ident_bind_name = (&ident.name.as_str()).to_string();
                                     matching_wild = true;
                                 }
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index a17c5996293..3dc4cd278e6 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -15,8 +15,7 @@ use if_chain::if_chain;
 use rustc_ast::ast;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
-use rustc_hir::def::Res;
-use rustc_hir::{Expr, ExprKind, PatKind, QPath, TraitItem, TraitItemKind, UnOp};
+use rustc_hir::{Expr, ExprKind, PatKind, TraitItem, TraitItemKind, UnOp};
 use rustc_lint::{LateContext, LateLintPass, Lint, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::{self, TraitRef, Ty, TyS};
@@ -30,12 +29,12 @@ use crate::consts::{constant, Constant};
 use crate::utils::eager_or_lazy::is_lazyness_candidate;
 use crate::utils::usage::mutated_variables;
 use crate::utils::{
-    contains_return, contains_ty, get_arg_name, get_parent_expr, get_trait_def_id, has_iter_method, higher,
-    implements_trait, in_macro, is_copy, is_expn_of, is_type_diagnostic_item, iter_input_pats, last_path_segment,
-    match_def_path, match_qpath, match_trait_method, match_type, match_var, meets_msrv, method_calls,
-    method_chain_args, paths, remove_blocks, return_ty, single_segment_path, snippet, snippet_with_applicability,
-    snippet_with_macro_callsite, span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then, sugg,
-    walk_ptrs_ty_depth, SpanlessEq,
+    contains_return, contains_ty, get_parent_expr, get_trait_def_id, has_iter_method, higher, implements_trait,
+    in_macro, is_copy, is_expn_of, is_type_diagnostic_item, iter_input_pats, last_path_segment, match_def_path,
+    match_qpath, match_trait_method, match_type, meets_msrv, method_calls, method_chain_args, path_to_local_id, paths,
+    remove_blocks, return_ty, single_segment_path, snippet, snippet_with_applicability, snippet_with_macro_callsite,
+    span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then, strip_pat_refs, sugg, walk_ptrs_ty_depth,
+    SpanlessEq,
 };
 
 declare_clippy_lint! {
@@ -2396,11 +2395,12 @@ fn lint_unnecessary_fold(cx: &LateContext<'_>, expr: &hir::Expr<'_>, fold_args:
             if bin_op.node == op;
 
             // Extract the names of the two arguments to the closure
-            if let Some(first_arg_ident) = get_arg_name(&closure_body.params[0].pat);
-            if let Some(second_arg_ident) = get_arg_name(&closure_body.params[1].pat);
+            if let [param_a, param_b] = closure_body.params;
+            if let PatKind::Binding(_, first_arg_id, ..) = strip_pat_refs(&param_a.pat).kind;
+            if let PatKind::Binding(_, second_arg_id, second_arg_ident, _) = strip_pat_refs(&param_b.pat).kind;
 
-            if match_var(&*left_expr, first_arg_ident);
-            if replacement_has_args || match_var(&*right_expr, second_arg_ident);
+            if path_to_local_id(left_expr, first_arg_id);
+            if replacement_has_args || path_to_local_id(right_expr, second_arg_id);
 
             then {
                 let mut applicability = Applicability::MachineApplicable;
@@ -3068,10 +3068,8 @@ fn lint_filter_map<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, is_f
             };
             // let the filter closure arg and the map closure arg be equal
             if_chain! {
-                if let ExprKind::Path(QPath::Resolved(None, a_path)) = a_path.kind;
-                if let ExprKind::Path(QPath::Resolved(None, b_path)) = b.kind;
-                if a_path.res == Res::Local(filter_param_id);
-                if b_path.res == Res::Local(map_param_id);
+                if path_to_local_id(a_path, filter_param_id);
+                if path_to_local_id(b, map_param_id);
                 if TyS::same_type(cx.typeck_results().expr_ty_adjusted(a), cx.typeck_results().expr_ty_adjusted(b));
                 then {
                     return true;
@@ -3255,8 +3253,9 @@ fn lint_search_is_some<'tcx>(
                 then {
                     if let hir::PatKind::Ref(..) = closure_arg.pat.kind {
                         Some(search_snippet.replacen('&', "", 1))
-                    } else if let Some(name) = get_arg_name(&closure_arg.pat) {
-                        Some(search_snippet.replace(&format!("*{}", name), &name.as_str()))
+                    } else if let PatKind::Binding(_, _, ident, _) = strip_pat_refs(&closure_arg.pat).kind {
+                        let name = &*ident.name.as_str();
+                        Some(search_snippet.replace(&format!("*{}", name), name))
                     } else {
                         None
                     }
@@ -3688,9 +3687,7 @@ fn lint_option_as_ref_deref<'tcx>(
                 hir::ExprKind::MethodCall(_, _, args, _) => {
                     if_chain! {
                         if args.len() == 1;
-                        if let hir::ExprKind::Path(qpath) = &args[0].kind;
-                        if let hir::def::Res::Local(local_id) = cx.qpath_res(qpath, args[0].hir_id);
-                        if closure_body.params[0].pat.hir_id == local_id;
+                        if path_to_local_id(&args[0], closure_body.params[0].pat.hir_id);
                         let adj = cx
                             .typeck_results()
                             .expr_adjustments(&args[0])
@@ -3710,10 +3707,8 @@ fn lint_option_as_ref_deref<'tcx>(
                     if_chain! {
                         if let hir::ExprKind::Unary(hir::UnOp::UnDeref, ref inner1) = inner.kind;
                         if let hir::ExprKind::Unary(hir::UnOp::UnDeref, ref inner2) = inner1.kind;
-                        if let hir::ExprKind::Path(ref qpath) = inner2.kind;
-                        if let hir::def::Res::Local(local_id) = cx.qpath_res(qpath, inner2.hir_id);
                         then {
-                            closure_body.params[0].pat.hir_id == local_id
+                            path_to_local_id(inner2, closure_body.params[0].pat.hir_id)
                         } else {
                             false
                         }
diff --git a/clippy_lints/src/methods/unnecessary_filter_map.rs b/clippy_lints/src/methods/unnecessary_filter_map.rs
index d98e6160d30..5691fcb88e9 100644
--- a/clippy_lints/src/methods/unnecessary_filter_map.rs
+++ b/clippy_lints/src/methods/unnecessary_filter_map.rs
@@ -1,8 +1,6 @@
-use crate::utils::paths;
 use crate::utils::usage::mutated_variables;
-use crate::utils::{match_qpath, match_trait_method, span_lint};
+use crate::utils::{match_qpath, match_trait_method, path_to_local_id, paths, span_lint};
 use rustc_hir as hir;
-use rustc_hir::def::Res;
 use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
 use rustc_lint::LateContext;
 use rustc_middle::hir::map::Map;
@@ -59,14 +57,8 @@ fn check_expression<'tcx>(cx: &LateContext<'tcx>, arg_id: hir::HirId, expr: &'tc
                 if let hir::ExprKind::Path(ref path) = func.kind;
                 then {
                     if match_qpath(path, &paths::OPTION_SOME) {
-                        if_chain! {
-                            if let hir::ExprKind::Path(path) = &args[0].kind;
-                            if let Res::Local(ref local) = cx.qpath_res(path, args[0].hir_id);
-                            then {
-                                if arg_id == *local {
-                                    return (false, false)
-                                }
-                            }
+                        if path_to_local_id(&args[0], arg_id) {
+                            return (false, false)
                         }
                         return (true, false);
                     }
diff --git a/clippy_lints/src/to_string_in_display.rs b/clippy_lints/src/to_string_in_display.rs
index fa508df865e..fdd105e6246 100644
--- a/clippy_lints/src/to_string_in_display.rs
+++ b/clippy_lints/src/to_string_in_display.rs
@@ -1,6 +1,5 @@
-use crate::utils::{match_def_path, match_trait_method, paths, span_lint};
+use crate::utils::{match_def_path, match_trait_method, path_to_local_id, paths, span_lint};
 use if_chain::if_chain;
-use rustc_hir::def::Res;
 use rustc_hir::{Expr, ExprKind, HirId, Impl, ImplItem, ImplItemKind, Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
@@ -89,14 +88,12 @@ impl LateLintPass<'_> for ToStringInDisplay {
 
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
         if_chain! {
+            if self.in_display_impl;
+            if let Some(self_hir_id) = self.self_hir_id;
             if let ExprKind::MethodCall(ref path, _, args, _) = expr.kind;
             if path.ident.name == sym!(to_string);
             if match_trait_method(cx, expr, &paths::TO_STRING);
-            if self.in_display_impl;
-            if let ExprKind::Path(ref qpath) = args[0].kind;
-            if let Res::Local(hir_id) = cx.qpath_res(qpath, args[0].hir_id);
-            if let Some(self_hir_id) = self.self_hir_id;
-            if hir_id == self_hir_id;
+            if path_to_local_id(&args[0], self_hir_id);
             then {
                 span_lint(
                     cx,
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index cf93ee0a7a5..15a254244c1 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -307,6 +307,22 @@ pub fn match_path_ast(path: &ast::Path, segments: &[&str]) -> bool {
         .all(|(a, b)| a.ident.name.as_str() == *b)
 }
 
+/// If the expression is a path to a local, returns the canonical `HirId` of the local.
+pub fn path_to_local(expr: &Expr<'_>) -> Option<HirId> {
+    if let ExprKind::Path(QPath::Resolved(None, ref path)) = expr.kind {
+        if let Res::Local(id) = path.res {
+            return Some(id);
+        }
+    }
+    None
+}
+
+/// Returns true if the expression is a path to a local with the specified `HirId`.
+/// Use this function to see if an expression matches a function argument or a match binding.
+pub fn path_to_local_id(expr: &Expr<'_>, id: HirId) -> bool {
+    path_to_local(expr) == Some(id)
+}
+
 /// Gets the definition associated to a path.
 #[allow(clippy::shadow_unrelated)] // false positive #6563
 pub fn path_to_res(cx: &LateContext<'_>, path: &[&str]) -> Res {
@@ -1135,9 +1151,7 @@ pub fn is_try<'tcx>(expr: &'tcx Expr<'tcx>) -> Option<&'tcx Expr<'tcx>> {
             if let PatKind::TupleStruct(ref path, ref pat, None) = arm.pat.kind;
             if match_qpath(path, &paths::RESULT_OK[1..]);
             if let PatKind::Binding(_, hir_id, _, None) = pat[0].kind;
-            if let ExprKind::Path(QPath::Resolved(None, ref path)) = arm.body.kind;
-            if let Res::Local(lid) = path.res;
-            if lid == hir_id;
+            if path_to_local_id(arm.body, hir_id);
             then {
                 return true;
             }
@@ -1181,12 +1195,11 @@ pub fn is_allowed(cx: &LateContext<'_>, lint: &'static Lint, id: HirId) -> bool
     cx.tcx.lint_level_at_node(lint, id).0 == Level::Allow
 }
 
-pub fn get_arg_name(pat: &Pat<'_>) -> Option<Symbol> {
-    match pat.kind {
-        PatKind::Binding(.., ident, None) => Some(ident.name),
-        PatKind::Ref(ref subpat, _) => get_arg_name(subpat),
-        _ => None,
+pub fn strip_pat_refs<'hir>(mut pat: &'hir Pat<'hir>) -> &'hir Pat<'hir> {
+    while let PatKind::Ref(subpat, _) = pat.kind {
+        pat = subpat;
     }
+    pat
 }
 
 pub fn int_bits(tcx: TyCtxt<'_>, ity: ty::IntTy) -> u64 {
diff --git a/clippy_lints/src/utils/usage.rs b/clippy_lints/src/utils/usage.rs
index fc0db7f64ec..7c7580a2c66 100644
--- a/clippy_lints/src/utils/usage.rs
+++ b/clippy_lints/src/utils/usage.rs
@@ -1,16 +1,14 @@
 use crate::utils;
-use crate::utils::match_var;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_hir as hir;
 use rustc_hir::def::Res;
 use rustc_hir::intravisit;
-use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
+use rustc_hir::intravisit::{NestedVisitorMap, Visitor};
 use rustc_hir::{Expr, ExprKind, HirId, Path};
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::LateContext;
 use rustc_middle::hir::map::Map;
 use rustc_middle::ty;
-use rustc_span::symbol::{Ident, Symbol};
 use rustc_typeck::expr_use_visitor::{ConsumeMode, Delegate, ExprUseVisitor, PlaceBase, PlaceWithHirId};
 
 /// Returns a set of mutated local variable IDs, or `None` if mutations could not be determined.
@@ -81,36 +79,6 @@ impl<'tcx> Delegate<'tcx> for MutVarsDelegate {
     }
 }
 
-pub struct UsedVisitor {
-    pub var: Symbol, // var to look for
-    pub used: bool,  // has the var been used otherwise?
-}
-
-impl<'tcx> Visitor<'tcx> for UsedVisitor {
-    type Map = Map<'tcx>;
-
-    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
-        if match_var(expr, self.var) {
-            self.used = true;
-        } else {
-            walk_expr(self, expr);
-        }
-    }
-
-    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-        NestedVisitorMap::None
-    }
-}
-
-pub fn is_unused<'tcx>(ident: &'tcx Ident, body: &'tcx Expr<'_>) -> bool {
-    let mut visitor = UsedVisitor {
-        var: ident.name,
-        used: false,
-    };
-    walk_expr(&mut visitor, body);
-    !visitor.used
-}
-
 pub struct ParamBindingIdCollector {
     binding_hir_ids: Vec<hir::HirId>,
 }
diff --git a/clippy_lints/src/utils/visitors.rs b/clippy_lints/src/utils/visitors.rs
index ebf69df31ca..a4064c3e705 100644
--- a/clippy_lints/src/utils/visitors.rs
+++ b/clippy_lints/src/utils/visitors.rs
@@ -1,7 +1,7 @@
+use crate::utils::path_to_local_id;
 use rustc_hir as hir;
-use rustc_hir::def::Res;
 use rustc_hir::intravisit::{self, walk_expr, NestedVisitorMap, Visitor};
-use rustc_hir::{Arm, Expr, ExprKind, HirId, QPath, Stmt};
+use rustc_hir::{Arm, Expr, HirId, Stmt};
 use rustc_lint::LateContext;
 use rustc_middle::hir::map::Map;
 
@@ -168,15 +168,11 @@ impl<'v> Visitor<'v> for LocalUsedVisitor {
     type Map = Map<'v>;
 
     fn visit_expr(&mut self, expr: &'v Expr<'v>) {
-        if let ExprKind::Path(QPath::Resolved(None, path)) = expr.kind {
-            if let Res::Local(id) = path.res {
-                if id == self.local_hir_id {
-                    self.used = true;
-                    return;
-                }
-            }
+        if path_to_local_id(expr, self.local_hir_id) {
+            self.used = true;
+        } else {
+            walk_expr(self, expr);
         }
-        walk_expr(self, expr);
     }
 
     fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-- 
cgit 1.4.1-3-g733a5


From eb9c6698ee36570efe79343d746afa3dcd04c7a9 Mon Sep 17 00:00:00 2001
From: Bastian Kersting <bastian@cmbt.de>
Date: Sun, 20 Dec 2020 11:48:56 +0100
Subject: First version of the lint

---
 CHANGELOG.md                                      |  1 +
 clippy_lints/src/lib.rs                           |  4 ++
 clippy_lints/src/semicolon_if_nothing_returned.rs | 58 +++++++++++++++++++++++
 tests/ui/semicolon_if_nothing_returned.rs         | 18 +++++++
 tests/ui/semicolon_if_nothing_returned.stderr     | 17 +++++++
 5 files changed, 98 insertions(+)
 create mode 100644 clippy_lints/src/semicolon_if_nothing_returned.rs
 create mode 100644 tests/ui/semicolon_if_nothing_returned.rs
 create mode 100644 tests/ui/semicolon_if_nothing_returned.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 45321751ba7..d0164d3be37 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2185,6 +2185,7 @@ Released 2018-09-13
 [`same_item_push`]: https://rust-lang.github.io/rust-clippy/master/index.html#same_item_push
 [`search_is_some`]: https://rust-lang.github.io/rust-clippy/master/index.html#search_is_some
 [`self_assignment`]: https://rust-lang.github.io/rust-clippy/master/index.html#self_assignment
+[`semicolon_if_nothing_returned`]: https://rust-lang.github.io/rust-clippy/master/index.html#semicolon_if_nothing_returned
 [`serde_api_misuse`]: https://rust-lang.github.io/rust-clippy/master/index.html#serde_api_misuse
 [`shadow_reuse`]: https://rust-lang.github.io/rust-clippy/master/index.html#shadow_reuse
 [`shadow_same`]: https://rust-lang.github.io/rust-clippy/master/index.html#shadow_same
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 7f5c4f56f9e..f6014c246d6 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -310,6 +310,7 @@ mod regex;
 mod repeat_once;
 mod returns;
 mod self_assignment;
+mod semicolon_if_nothing_returned;
 mod serde_api;
 mod shadow;
 mod single_component_path_imports;
@@ -876,6 +877,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &returns::LET_AND_RETURN,
         &returns::NEEDLESS_RETURN,
         &self_assignment::SELF_ASSIGNMENT,
+        &semicolon_if_nothing_returned::SEMICOLON_IF_NOTHING_RETURNED,
         &serde_api::SERDE_API_MISUSE,
         &shadow::SHADOW_REUSE,
         &shadow::SHADOW_SAME,
@@ -1237,6 +1239,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box manual_unwrap_or::ManualUnwrapOr);
     store.register_late_pass(|| box manual_ok_or::ManualOkOr);
     store.register_late_pass(|| box float_equality_without_abs::FloatEqualityWithoutAbs);
+    store.register_late_pass(|| box semicolon_if_nothing_returned::SemicolonIfNothingReturned);
     store.register_late_pass(|| box async_yields_async::AsyncYieldsAsync);
     let disallowed_methods = conf.disallowed_methods.iter().cloned().collect::<FxHashSet<_>>();
     store.register_late_pass(move || box disallowed_method::DisallowedMethod::new(&disallowed_methods));
@@ -1364,6 +1367,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&ranges::RANGE_PLUS_ONE),
         LintId::of(&redundant_else::REDUNDANT_ELSE),
         LintId::of(&ref_option_ref::REF_OPTION_REF),
+        LintId::of(&semicolon_if_nothing_returned::SEMICOLON_IF_NOTHING_RETURNED),
         LintId::of(&shadow::SHADOW_UNRELATED),
         LintId::of(&strings::STRING_ADD_ASSIGN),
         LintId::of(&trait_bounds::TRAIT_DUPLICATION_IN_BOUNDS),
diff --git a/clippy_lints/src/semicolon_if_nothing_returned.rs b/clippy_lints/src/semicolon_if_nothing_returned.rs
new file mode 100644
index 00000000000..99e5841d5a9
--- /dev/null
+++ b/clippy_lints/src/semicolon_if_nothing_returned.rs
@@ -0,0 +1,58 @@
+use crate::utils::{match_def_path, paths, span_lint_and_then, sugg};
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir::*;
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// **What it does:**
+    ///
+    /// **Why is this bad?**
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// // example code where clippy issues a warning
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// // example code which does not raise clippy warning
+    /// ```
+    pub SEMICOLON_IF_NOTHING_RETURNED,
+    pedantic,
+    "default lint description"
+}
+
+declare_lint_pass!(SemicolonIfNothingReturned => [SEMICOLON_IF_NOTHING_RETURNED]);
+
+impl LateLintPass<'_> for SemicolonIfNothingReturned {
+    fn check_block(&mut self, cx: &LateContext<'tcx>, block: &'tcx Block<'tcx>) {
+        if_chain! {
+            if let Some(expr) = block.expr;
+            let t_expr = cx.typeck_results().expr_ty(expr);
+            if t_expr.is_unit();
+            then {
+                let sugg = sugg::Sugg::hir(cx, &expr, "..");
+                let suggestion = format!("{0};", sugg);
+                span_lint_and_then(
+                    cx,
+                    SEMICOLON_IF_NOTHING_RETURNED,
+                    expr.span,
+                    "add `;` to terminate block",
+                    | diag | {
+                        diag.span_suggestion(
+                            expr.span,
+                            "add `;`",
+                            suggestion,
+                            Applicability::MaybeIncorrect,
+                        );
+                    }
+                )
+            }
+        }
+    }
+}
diff --git a/tests/ui/semicolon_if_nothing_returned.rs b/tests/ui/semicolon_if_nothing_returned.rs
new file mode 100644
index 00000000000..6790e91d813
--- /dev/null
+++ b/tests/ui/semicolon_if_nothing_returned.rs
@@ -0,0 +1,18 @@
+#![warn(clippy::semicolon_if_nothing_returned)]
+
+fn get_unit() {}
+
+// the functions below trigger the lint
+fn main() {
+    println!("Hello")
+}
+
+fn hello() {
+    get_unit()
+}
+
+// this is fine
+fn print_sum(a: i32, b: i32) {
+    println!("{}", a + b);
+    assert_eq!(true, false);
+}
diff --git a/tests/ui/semicolon_if_nothing_returned.stderr b/tests/ui/semicolon_if_nothing_returned.stderr
new file mode 100644
index 00000000000..ecb284ecf04
--- /dev/null
+++ b/tests/ui/semicolon_if_nothing_returned.stderr
@@ -0,0 +1,17 @@
+error: add `;` to terminate block
+  --> $DIR/semicolon_if_nothing_returned.rs:7:5
+   |
+LL |     println!("Hello")
+   |     ^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::semicolon-if-nothing-returned` implied by `-D warnings`
+   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: add `;` to terminate block
+  --> $DIR/semicolon_if_nothing_returned.rs:11:5
+   |
+LL |     get_unit()
+   |     ^^^^^^^^^^ help: add `;`: `get_unit();`
+
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From f907986580887ba8b0f30d91792bae81b394ab91 Mon Sep 17 00:00:00 2001
From: Bastian Kersting <bastian@cmbt.de>
Date: Mon, 21 Dec 2020 18:24:08 +0100
Subject: Added documentation

---
 clippy_lints/src/semicolon_if_nothing_returned.rs | 17 ++++++++++++-----
 1 file changed, 12 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/semicolon_if_nothing_returned.rs b/clippy_lints/src/semicolon_if_nothing_returned.rs
index 99e5841d5a9..84d14b9b48a 100644
--- a/clippy_lints/src/semicolon_if_nothing_returned.rs
+++ b/clippy_lints/src/semicolon_if_nothing_returned.rs
@@ -7,24 +7,31 @@ use rustc_middle::ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
-    /// **What it does:**
+    /// **What it does:** Looks for blocks of expressions and fires if the last expression returns `()`
+    /// but is not followed by a semicolon.
     ///
-    /// **Why is this bad?**
+    /// **Why is this bad?** The semicolon might be optional but when
+    /// extending the block with new code, it doesn't require a change in previous last line.
+    /// It's also more idiomatic.
     ///
     /// **Known problems:** None.
     ///
     /// **Example:**
     ///
     /// ```rust
-    /// // example code where clippy issues a warning
+    /// fn main() {
+    /// println!("Hello world")
+    /// }
     /// ```
     /// Use instead:
     /// ```rust
-    /// // example code which does not raise clippy warning
+    /// fn main() {
+    /// println!("Hello world");
+    /// }
     /// ```
     pub SEMICOLON_IF_NOTHING_RETURNED,
     pedantic,
-    "default lint description"
+    "add a semicolon if nothing is returned"
 }
 
 declare_lint_pass!(SemicolonIfNothingReturned => [SEMICOLON_IF_NOTHING_RETURNED]);
-- 
cgit 1.4.1-3-g733a5


From 55bfaa12d346572aecfe190a964b122932e22521 Mon Sep 17 00:00:00 2001
From: Bastian Kersting <bastian@cmbt.de>
Date: Fri, 5 Feb 2021 18:54:13 +0100
Subject: Fixed macro edge case for `semicolon_if_nothing_returned lint`

---
 clippy_lints/src/semicolon_if_nothing_returned.rs | 16 +++++++++---
 tests/ui/semicolon_if_nothing_returned.rs         | 30 +++++++++++++++++++++++
 tests/ui/semicolon_if_nothing_returned.stderr     | 12 ++++++---
 3 files changed, 51 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/semicolon_if_nothing_returned.rs b/clippy_lints/src/semicolon_if_nothing_returned.rs
index 84d14b9b48a..22cd10ced18 100644
--- a/clippy_lints/src/semicolon_if_nothing_returned.rs
+++ b/clippy_lints/src/semicolon_if_nothing_returned.rs
@@ -1,9 +1,8 @@
-use crate::utils::{match_def_path, paths, span_lint_and_then, sugg};
+use crate::utils::{in_macro, span_lint_and_then, sugg};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::*;
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
@@ -20,13 +19,13 @@ declare_clippy_lint! {
     ///
     /// ```rust
     /// fn main() {
-    /// println!("Hello world")
+    ///     println!("Hello world")
     /// }
     /// ```
     /// Use instead:
     /// ```rust
     /// fn main() {
-    /// println!("Hello world");
+    ///     println!("Hello world");
     /// }
     /// ```
     pub SEMICOLON_IF_NOTHING_RETURNED,
@@ -39,10 +38,19 @@ declare_lint_pass!(SemicolonIfNothingReturned => [SEMICOLON_IF_NOTHING_RETURNED]
 impl LateLintPass<'_> for SemicolonIfNothingReturned {
     fn check_block(&mut self, cx: &LateContext<'tcx>, block: &'tcx Block<'tcx>) {
         if_chain! {
+            if !in_macro(block.span);
             if let Some(expr) = block.expr;
             let t_expr = cx.typeck_results().expr_ty(expr);
             if t_expr.is_unit();
             then {
+                match expr.kind {
+                    ExprKind::Loop(..) | 
+                    ExprKind::Match(..) | 
+                    ExprKind::Block(..) | 
+                    ExprKind::If(..) if !in_macro(expr.span) => return,
+                   _ => (),
+                }
+
                 let sugg = sugg::Sugg::hir(cx, &expr, "..");
                 let suggestion = format!("{0};", sugg);
                 span_lint_and_then(
diff --git a/tests/ui/semicolon_if_nothing_returned.rs b/tests/ui/semicolon_if_nothing_returned.rs
index 6790e91d813..2c07cc9df40 100644
--- a/tests/ui/semicolon_if_nothing_returned.rs
+++ b/tests/ui/semicolon_if_nothing_returned.rs
@@ -1,4 +1,5 @@
 #![warn(clippy::semicolon_if_nothing_returned)]
+#![feature(label_break_value)]
 
 fn get_unit() {}
 
@@ -11,8 +12,37 @@ fn hello() {
     get_unit()
 }
 
+fn basic101(x: i32) {
+    let y: i32;
+    y = x + 1
+}
+
 // this is fine
 fn print_sum(a: i32, b: i32) {
     println!("{}", a + b);
     assert_eq!(true, false);
 }
+
+fn foo(x: i32) {
+    let y: i32;
+    if x < 1 {
+        y = 4;
+    } else {
+        y = 5;
+    }
+}
+
+fn bar(x: i32) {
+    let y: i32;
+    match x {
+        1 => y = 4,
+        _ => y = 32,
+    }
+}
+
+fn foobar(x: i32) {
+    let y: i32;
+    'label: {
+        y = x + 1;
+    }
+}
diff --git a/tests/ui/semicolon_if_nothing_returned.stderr b/tests/ui/semicolon_if_nothing_returned.stderr
index ecb284ecf04..6026320f4b4 100644
--- a/tests/ui/semicolon_if_nothing_returned.stderr
+++ b/tests/ui/semicolon_if_nothing_returned.stderr
@@ -1,5 +1,5 @@
 error: add `;` to terminate block
-  --> $DIR/semicolon_if_nothing_returned.rs:7:5
+  --> $DIR/semicolon_if_nothing_returned.rs:8:5
    |
 LL |     println!("Hello")
    |     ^^^^^^^^^^^^^^^^^
@@ -8,10 +8,16 @@ LL |     println!("Hello")
    = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: add `;` to terminate block
-  --> $DIR/semicolon_if_nothing_returned.rs:11:5
+  --> $DIR/semicolon_if_nothing_returned.rs:12:5
    |
 LL |     get_unit()
    |     ^^^^^^^^^^ help: add `;`: `get_unit();`
 
-error: aborting due to 2 previous errors
+error: add `;` to terminate block
+  --> $DIR/semicolon_if_nothing_returned.rs:17:5
+   |
+LL |     y = x + 1
+   |     ^^^^^^^^^ help: add `;`: `y = x + 1;`
+
+error: aborting due to 3 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From ac5e9c8d2691da5a3872a8eec97ce694193c1e5c Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Fri, 5 Feb 2021 14:45:24 -0600
Subject: Fix let_underscore_drop implements Drop logic

This fixes false positives and false negatives.
---
 clippy_lints/src/let_underscore.rs | 13 ++-----------
 tests/ui/let_underscore_drop.rs    |  8 ++++++++
 2 files changed, 10 insertions(+), 11 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/let_underscore.rs b/clippy_lints/src/let_underscore.rs
index 6a5a77f8690..7e96dfcc7da 100644
--- a/clippy_lints/src/let_underscore.rs
+++ b/clippy_lints/src/let_underscore.rs
@@ -5,7 +5,7 @@ use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::subst::GenericArgKind;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
-use crate::utils::{implements_trait, is_must_use_func_call, is_must_use_ty, match_type, paths, span_lint_and_help};
+use crate::utils::{is_must_use_func_call, is_must_use_ty, match_type, paths, span_lint_and_help};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for `let _ = <expr>`
@@ -125,15 +125,6 @@ impl<'tcx> LateLintPass<'tcx> for LetUnderscore {
 
                     GenericArgKind::Lifetime(_) | GenericArgKind::Const(_) => false,
                 });
-                let implements_drop = cx.tcx.lang_items().drop_trait().map_or(false, |drop_trait|
-                    init_ty.walk().any(|inner| match inner.unpack() {
-                        GenericArgKind::Type(inner_ty) => {
-                            implements_trait(cx, inner_ty, drop_trait, &[])
-                        },
-
-                        GenericArgKind::Lifetime(_) | GenericArgKind::Const(_) => false,
-                    })
-                );
                 if contains_sync_guard {
                     span_lint_and_help(
                         cx,
@@ -144,7 +135,7 @@ impl<'tcx> LateLintPass<'tcx> for LetUnderscore {
                         "consider using an underscore-prefixed named \
                             binding or dropping explicitly with `std::mem::drop`"
                     )
-                } else if implements_drop {
+                } else if init_ty.needs_drop(cx.tcx, cx.param_env) {
                     span_lint_and_help(
                         cx,
                         LET_UNDERSCORE_DROP,
diff --git a/tests/ui/let_underscore_drop.rs b/tests/ui/let_underscore_drop.rs
index 98593edb9c5..50744f81c3c 100644
--- a/tests/ui/let_underscore_drop.rs
+++ b/tests/ui/let_underscore_drop.rs
@@ -16,4 +16,12 @@ fn main() {
     let _ = Box::new(());
     let _ = Droppable;
     let _ = Some(Droppable);
+
+    // no lint for reference
+    let _ = droppable_ref();
+}
+
+#[must_use]
+fn droppable_ref() -> &'static mut Droppable {
+    unimplemented!()
 }
-- 
cgit 1.4.1-3-g733a5


From a60c143fe0cec1125e894f3d2d5008cc317fdacf Mon Sep 17 00:00:00 2001
From: Yusuke Tanaka <yusuktan@maguro.dev>
Date: Wed, 3 Feb 2021 23:24:06 +0900
Subject: Add new lint `filter_map_identity`

This commit adds a new lint named `filter_map_identity`. This lint is
the same as `flat_map_identity` except that it checks for `filter_map`.

Closes #6643
---
 CHANGELOG.md                                    |  1 +
 clippy_lints/src/lib.rs                         |  3 ++
 clippy_lints/src/methods/filter_map_identity.rs | 56 +++++++++++++++++++++++++
 clippy_lints/src/methods/mod.rs                 | 30 ++++++++++++-
 tests/ui/filter_map_identity.fixed              | 16 +++++++
 tests/ui/filter_map_identity.rs                 | 16 +++++++
 tests/ui/filter_map_identity.stderr             | 22 ++++++++++
 7 files changed, 143 insertions(+), 1 deletion(-)
 create mode 100644 clippy_lints/src/methods/filter_map_identity.rs
 create mode 100644 tests/ui/filter_map_identity.fixed
 create mode 100644 tests/ui/filter_map_identity.rs
 create mode 100644 tests/ui/filter_map_identity.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 45321751ba7..f32f5529751 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1955,6 +1955,7 @@ Released 2018-09-13
 [`field_reassign_with_default`]: https://rust-lang.github.io/rust-clippy/master/index.html#field_reassign_with_default
 [`filetype_is_file`]: https://rust-lang.github.io/rust-clippy/master/index.html#filetype_is_file
 [`filter_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#filter_map
+[`filter_map_identity`]: https://rust-lang.github.io/rust-clippy/master/index.html#filter_map_identity
 [`filter_map_next`]: https://rust-lang.github.io/rust-clippy/master/index.html#filter_map_next
 [`filter_next`]: https://rust-lang.github.io/rust-clippy/master/index.html#filter_next
 [`find_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#find_map
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 7f5c4f56f9e..760b490dc12 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -742,6 +742,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &methods::EXPECT_USED,
         &methods::FILETYPE_IS_FILE,
         &methods::FILTER_MAP,
+        &methods::FILTER_MAP_IDENTITY,
         &methods::FILTER_MAP_NEXT,
         &methods::FILTER_NEXT,
         &methods::FLAT_MAP_IDENTITY,
@@ -1531,6 +1532,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&methods::CLONE_DOUBLE_REF),
         LintId::of(&methods::CLONE_ON_COPY),
         LintId::of(&methods::EXPECT_FUN_CALL),
+        LintId::of(&methods::FILTER_MAP_IDENTITY),
         LintId::of(&methods::FILTER_NEXT),
         LintId::of(&methods::FLAT_MAP_IDENTITY),
         LintId::of(&methods::FROM_ITER_INSTEAD_OF_COLLECT),
@@ -1838,6 +1840,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&matches::WILDCARD_IN_OR_PATTERNS),
         LintId::of(&methods::BIND_INSTEAD_OF_MAP),
         LintId::of(&methods::CLONE_ON_COPY),
+        LintId::of(&methods::FILTER_MAP_IDENTITY),
         LintId::of(&methods::FILTER_NEXT),
         LintId::of(&methods::FLAT_MAP_IDENTITY),
         LintId::of(&methods::INSPECT_FOR_EACH),
diff --git a/clippy_lints/src/methods/filter_map_identity.rs b/clippy_lints/src/methods/filter_map_identity.rs
new file mode 100644
index 00000000000..d04e4be87ac
--- /dev/null
+++ b/clippy_lints/src/methods/filter_map_identity.rs
@@ -0,0 +1,56 @@
+use crate::utils::{match_qpath, match_trait_method, paths, span_lint_and_sugg};
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir as hir;
+use rustc_lint::LateContext;
+use rustc_span::source_map::Span;
+
+use super::FILTER_MAP_IDENTITY;
+
+pub(super) fn check(
+    cx: &LateContext<'_>,
+    expr: &hir::Expr<'_>,
+    filter_map_args: &[hir::Expr<'_>],
+    filter_map_span: Span,
+) {
+    if match_trait_method(cx, expr, &paths::ITERATOR) {
+        let arg_node = &filter_map_args[1].kind;
+
+        let apply_lint = |message: &str| {
+            span_lint_and_sugg(
+                cx,
+                FILTER_MAP_IDENTITY,
+                filter_map_span.with_hi(expr.span.hi()),
+                message,
+                "try",
+                "flatten()".to_string(),
+                Applicability::MachineApplicable,
+            );
+        };
+
+        if_chain! {
+            if let hir::ExprKind::Closure(_, _, body_id, _, _) = arg_node;
+            let body = cx.tcx.hir().body(*body_id);
+
+            if let hir::PatKind::Binding(_, _, binding_ident, _) = body.params[0].pat.kind;
+            if let hir::ExprKind::Path(hir::QPath::Resolved(_, ref path)) = body.value.kind;
+
+            if path.segments.len() == 1;
+            if path.segments[0].ident.name == binding_ident.name;
+
+            then {
+                apply_lint("called `filter_map(|x| x)` on an `Iterator`");
+            }
+        }
+
+        if_chain! {
+            if let hir::ExprKind::Path(ref qpath) = arg_node;
+
+            if match_qpath(qpath, &paths::STD_CONVERT_IDENTITY);
+
+            then {
+                apply_lint("called `filter_map(std::convert::identity)` on an `Iterator`");
+            }
+        }
+    }
+}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index a17c5996293..2f68bc0121a 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1,4 +1,5 @@
 mod bind_instead_of_map;
+mod filter_map_identity;
 mod inefficient_to_string;
 mod inspect_for_each;
 mod manual_saturating_arithmetic;
@@ -1467,6 +1468,29 @@ declare_clippy_lint! {
     "using `.inspect().for_each()`, which can be replaced with `.for_each()`"
 }
 
+declare_clippy_lint! {
+    /// **What it does:** Checks for usage of `filter_map(|x| x)`.
+    ///
+    /// **Why is this bad?** Readability, this can be written more concisely by using `flatten`.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// # let iter = vec![Some(1)].into_iter();
+    /// iter.filter_map(|x| x);
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// # let iter = vec![Some(1)].into_iter();
+    /// iter.flatten();
+    /// ```
+    pub FILTER_MAP_IDENTITY,
+    complexity,
+    "call to `filter_map` where `flatten` is sufficient"
+}
+
 pub struct Methods {
     msrv: Option<RustcVersion>,
 }
@@ -1504,6 +1528,7 @@ impl_lint_pass!(Methods => [
     FILTER_NEXT,
     SKIP_WHILE_NEXT,
     FILTER_MAP,
+    FILTER_MAP_IDENTITY,
     MANUAL_FILTER_MAP,
     MANUAL_FIND_MAP,
     FILTER_MAP_NEXT,
@@ -1597,7 +1622,10 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             ["as_ref"] => lint_asref(cx, expr, "as_ref", arg_lists[0]),
             ["as_mut"] => lint_asref(cx, expr, "as_mut", arg_lists[0]),
             ["fold", ..] => lint_unnecessary_fold(cx, expr, arg_lists[0], method_spans[0]),
-            ["filter_map", ..] => unnecessary_filter_map::lint(cx, expr, arg_lists[0]),
+            ["filter_map", ..] => {
+                unnecessary_filter_map::lint(cx, expr, arg_lists[0]);
+                filter_map_identity::check(cx, expr, arg_lists[0], method_spans[0]);
+            },
             ["count", "map"] => lint_suspicious_map(cx, expr),
             ["assume_init"] => lint_maybe_uninit(cx, &arg_lists[0][0], expr),
             ["unwrap_or", arith @ ("checked_add" | "checked_sub" | "checked_mul")] => {
diff --git a/tests/ui/filter_map_identity.fixed b/tests/ui/filter_map_identity.fixed
new file mode 100644
index 00000000000..23ce28d8e9b
--- /dev/null
+++ b/tests/ui/filter_map_identity.fixed
@@ -0,0 +1,16 @@
+// run-rustfix
+
+#![allow(unused_imports)]
+#![warn(clippy::filter_map_identity)]
+
+fn main() {
+    let iterator = vec![Some(1), None, Some(2)].into_iter();
+    let _ = iterator.flatten();
+
+    let iterator = vec![Some(1), None, Some(2)].into_iter();
+    let _ = iterator.flatten();
+
+    use std::convert::identity;
+    let iterator = vec![Some(1), None, Some(2)].into_iter();
+    let _ = iterator.flatten();
+}
diff --git a/tests/ui/filter_map_identity.rs b/tests/ui/filter_map_identity.rs
new file mode 100644
index 00000000000..e698df13eea
--- /dev/null
+++ b/tests/ui/filter_map_identity.rs
@@ -0,0 +1,16 @@
+// run-rustfix
+
+#![allow(unused_imports)]
+#![warn(clippy::filter_map_identity)]
+
+fn main() {
+    let iterator = vec![Some(1), None, Some(2)].into_iter();
+    let _ = iterator.filter_map(|x| x);
+
+    let iterator = vec![Some(1), None, Some(2)].into_iter();
+    let _ = iterator.filter_map(std::convert::identity);
+
+    use std::convert::identity;
+    let iterator = vec![Some(1), None, Some(2)].into_iter();
+    let _ = iterator.filter_map(identity);
+}
diff --git a/tests/ui/filter_map_identity.stderr b/tests/ui/filter_map_identity.stderr
new file mode 100644
index 00000000000..596a6320608
--- /dev/null
+++ b/tests/ui/filter_map_identity.stderr
@@ -0,0 +1,22 @@
+error: called `filter_map(|x| x)` on an `Iterator`
+  --> $DIR/filter_map_identity.rs:8:22
+   |
+LL |     let _ = iterator.filter_map(|x| x);
+   |                      ^^^^^^^^^^^^^^^^^ help: try: `flatten()`
+   |
+   = note: `-D clippy::filter-map-identity` implied by `-D warnings`
+
+error: called `filter_map(std::convert::identity)` on an `Iterator`
+  --> $DIR/filter_map_identity.rs:11:22
+   |
+LL |     let _ = iterator.filter_map(std::convert::identity);
+   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `flatten()`
+
+error: called `filter_map(std::convert::identity)` on an `Iterator`
+  --> $DIR/filter_map_identity.rs:15:22
+   |
+LL |     let _ = iterator.filter_map(identity);
+   |                      ^^^^^^^^^^^^^^^^^^^^ help: try: `flatten()`
+
+error: aborting due to 3 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From fbe436b1d4369603a6f89cbb8fb382ef5fe210f7 Mon Sep 17 00:00:00 2001
From: Yusuke Tanaka <yusuktan@maguro.dev>
Date: Sat, 6 Feb 2021 18:06:58 +0900
Subject: Use flatten instead of filter_map

---
 clippy_lints/src/loops.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 663c2df23e2..ac4005d0cfd 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -739,7 +739,7 @@ fn combine_branches(b1: NeverLoopResult, b2: NeverLoopResult) -> NeverLoopResult
 fn never_loop_block(block: &Block<'_>, main_loop_id: HirId) -> NeverLoopResult {
     let stmts = block.stmts.iter().map(stmt_to_expr);
     let expr = once(block.expr.as_deref());
-    let mut iter = stmts.chain(expr).filter_map(|e| e);
+    let mut iter = stmts.chain(expr).flatten();
     never_loop_expr_seq(&mut iter, main_loop_id)
 }
 
-- 
cgit 1.4.1-3-g733a5


From 6626295fbc747d04f1a8d14f19ee48c789b90e50 Mon Sep 17 00:00:00 2001
From: Bastian Kersting <bastian@cmbt.de>
Date: Sat, 6 Feb 2021 14:07:49 +0100
Subject: Fixed for loop problem, corrected all occurences that got linted

---
 clippy_lints/src/assertions_on_constants.rs        |  2 +-
 clippy_lints/src/attrs.rs                          |  6 ++--
 clippy_lints/src/bit_mask.rs                       |  6 ++--
 clippy_lints/src/booleans.rs                       |  6 ++--
 clippy_lints/src/collapsible_if.rs                 |  2 +-
 clippy_lints/src/comparison_chain.rs               |  2 +-
 clippy_lints/src/eq_op.rs                          | 10 +++----
 clippy_lints/src/eta_reduction.rs                  |  2 +-
 clippy_lints/src/eval_order_dependence.rs          |  2 +-
 clippy_lints/src/functions.rs                      |  6 ++--
 clippy_lints/src/future_not_send.rs                |  2 +-
 clippy_lints/src/infinite_iter.rs                  |  2 +-
 clippy_lints/src/inherent_impl.rs                  |  4 +--
 clippy_lints/src/len_zero.rs                       |  4 +--
 clippy_lints/src/let_underscore.rs                 |  8 +++---
 clippy_lints/src/lifetimes.rs                      |  4 +--
 clippy_lints/src/literal_representation.rs         |  8 +++---
 clippy_lints/src/loops.rs                          | 22 +++++++--------
 clippy_lints/src/macro_use.rs                      |  6 ++--
 clippy_lints/src/manual_strip.rs                   |  2 +-
 clippy_lints/src/map_clone.rs                      |  6 ++--
 clippy_lints/src/matches.rs                        |  6 ++--
 clippy_lints/src/methods/bind_instead_of_map.rs    |  2 +-
 clippy_lints/src/methods/mod.rs                    | 20 +++++++-------
 clippy_lints/src/mut_reference.rs                  |  2 +-
 clippy_lints/src/mutable_debug_assertion.rs        |  2 +-
 clippy_lints/src/needless_arbitrary_self_type.rs   |  2 +-
 clippy_lints/src/needless_bool.rs                  | 18 ++++++------
 clippy_lints/src/neg_cmp_op_on_partial_ord.rs      |  2 +-
 clippy_lints/src/open_options.rs                   | 10 +++----
 clippy_lints/src/question_mark.rs                  |  2 +-
 clippy_lints/src/redundant_closure_call.rs         |  2 +-
 clippy_lints/src/redundant_pub_crate.rs            |  2 +-
 clippy_lints/src/returns.rs                        |  4 +--
 clippy_lints/src/semicolon_if_nothing_returned.rs  | 32 +++++++++-------------
 clippy_lints/src/shadow.rs                         | 10 +++----
 clippy_lints/src/slow_vector_initialization.rs     |  2 +-
 clippy_lints/src/suspicious_operation_groupings.rs |  6 ++--
 clippy_lints/src/transmute.rs                      |  6 ++--
 clippy_lints/src/types.rs                          |  6 ++--
 clippy_lints/src/unicode.rs                        |  4 +--
 clippy_lints/src/unused_self.rs                    |  2 +-
 clippy_lints/src/upper_case_acronyms.rs            |  2 +-
 clippy_lints/src/use_self.rs                       |  2 +-
 clippy_lints/src/utils/attrs.rs                    |  2 +-
 clippy_lints/src/utils/author.rs                   |  2 +-
 clippy_lints/src/utils/diagnostics.rs              |  2 +-
 clippy_lints/src/utils/mod.rs                      |  2 +-
 clippy_lints/src/utils/sugg.rs                     |  2 +-
 clippy_lints/src/utils/usage.rs                    |  6 ++--
 clippy_lints/src/utils/visitors.rs                 |  2 +-
 clippy_lints/src/verbose_file_reads.rs             |  2 +-
 clippy_lints/src/write.rs                          |  2 +-
 tests/ui/semicolon_if_nothing_returned.rs          |  7 +++++
 tests/ui/semicolon_if_nothing_returned.stderr      | 10 +++----
 55 files changed, 149 insertions(+), 148 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/assertions_on_constants.rs b/clippy_lints/src/assertions_on_constants.rs
index aa431f0596c..b9de4780173 100644
--- a/clippy_lints/src/assertions_on_constants.rs
+++ b/clippy_lints/src/assertions_on_constants.rs
@@ -61,7 +61,7 @@ impl<'tcx> LateLintPass<'tcx> for AssertionsOnConstants {
                 &format!("`assert!(false, {})` should probably be replaced", panic_message),
                 None,
                 &format!("use `panic!({})` or `unreachable!({})`", panic_message, panic_message),
-            )
+            );
         };
 
         if let Some(debug_assert_span) = is_expn_of(e.span, "debug_assert") {
diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs
index 652d1fa16b6..90463d7f026 100644
--- a/clippy_lints/src/attrs.rs
+++ b/clippy_lints/src/attrs.rs
@@ -277,7 +277,7 @@ impl<'tcx> LateLintPass<'tcx> for Attributes {
 
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
         if is_relevant_item(cx, item) {
-            check_attrs(cx, item.span, item.ident.name, &item.attrs)
+            check_attrs(cx, item.span, item.ident.name, &item.attrs);
         }
         match item.kind {
             ItemKind::ExternCrate(..) | ItemKind::Use(..) => {
@@ -353,13 +353,13 @@ impl<'tcx> LateLintPass<'tcx> for Attributes {
 
     fn check_impl_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx ImplItem<'_>) {
         if is_relevant_impl(cx, item) {
-            check_attrs(cx, item.span, item.ident.name, &item.attrs)
+            check_attrs(cx, item.span, item.ident.name, &item.attrs);
         }
     }
 
     fn check_trait_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx TraitItem<'_>) {
         if is_relevant_trait(cx, item) {
-            check_attrs(cx, item.span, item.ident.name, &item.attrs)
+            check_attrs(cx, item.span, item.ident.name, &item.attrs);
         }
     }
 }
diff --git a/clippy_lints/src/bit_mask.rs b/clippy_lints/src/bit_mask.rs
index a4ee54076ee..8d9fbcf4fd1 100644
--- a/clippy_lints/src/bit_mask.rs
+++ b/clippy_lints/src/bit_mask.rs
@@ -115,9 +115,9 @@ impl<'tcx> LateLintPass<'tcx> for BitMask {
         if let ExprKind::Binary(cmp, left, right) = &e.kind {
             if cmp.node.is_comparison() {
                 if let Some(cmp_opt) = fetch_int_literal(cx, right) {
-                    check_compare(cx, left, cmp.node, cmp_opt, e.span)
+                    check_compare(cx, left, cmp.node, cmp_opt, e.span);
                 } else if let Some(cmp_val) = fetch_int_literal(cx, left) {
-                    check_compare(cx, right, invert_cmp(cmp.node), cmp_val, e.span)
+                    check_compare(cx, right, invert_cmp(cmp.node), cmp_val, e.span);
                 }
             }
         }
@@ -171,7 +171,7 @@ fn check_compare(cx: &LateContext<'_>, bit_op: &Expr<'_>, cmp_op: BinOpKind, cmp
         }
         fetch_int_literal(cx, right)
             .or_else(|| fetch_int_literal(cx, left))
-            .map_or((), |mask| check_bit_mask(cx, op.node, cmp_op, mask, cmp_value, span))
+            .map_or((), |mask| check_bit_mask(cx, op.node, cmp_op, mask, cmp_value, span));
     }
 }
 
diff --git a/clippy_lints/src/booleans.rs b/clippy_lints/src/booleans.rs
index 90bb0bd555f..75f011a7fa0 100644
--- a/clippy_lints/src/booleans.rs
+++ b/clippy_lints/src/booleans.rs
@@ -66,7 +66,7 @@ impl<'tcx> LateLintPass<'tcx> for NonminimalBool {
         _: Span,
         _: HirId,
     ) {
-        NonminimalBoolVisitor { cx }.visit_body(body)
+        NonminimalBoolVisitor { cx }.visit_body(body);
     }
 }
 
@@ -184,7 +184,7 @@ impl<'a, 'tcx, 'v> SuggestContext<'a, 'tcx, 'v> {
                 Term(n) => {
                     let terminal = self.terminals[n as usize];
                     if let Some(str) = simplify_not(self.cx, terminal) {
-                        self.output.push_str(&str)
+                        self.output.push_str(&str);
                     } else {
                         self.output.push('!');
                         let snip = snippet_opt(self.cx, terminal.span)?;
@@ -452,7 +452,7 @@ impl<'a, 'tcx> Visitor<'tcx> for NonminimalBoolVisitor<'a, 'tcx> {
         }
         match &e.kind {
             ExprKind::Binary(binop, _, _) if binop.node == BinOpKind::Or || binop.node == BinOpKind::And => {
-                self.bool_expr(e)
+                self.bool_expr(e);
             },
             ExprKind::Unary(UnOp::UnNot, inner) => {
                 if self.cx.typeck_results().node_types()[inner.hir_id].is_bool() {
diff --git a/clippy_lints/src/collapsible_if.rs b/clippy_lints/src/collapsible_if.rs
index 93ccc76d0c9..4e7a6250add 100644
--- a/clippy_lints/src/collapsible_if.rs
+++ b/clippy_lints/src/collapsible_if.rs
@@ -92,7 +92,7 @@ declare_lint_pass!(CollapsibleIf => [COLLAPSIBLE_IF, COLLAPSIBLE_ELSE_IF]);
 impl EarlyLintPass for CollapsibleIf {
     fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &ast::Expr) {
         if !expr.span.from_expansion() {
-            check_if(cx, expr)
+            check_if(cx, expr);
         }
     }
 }
diff --git a/clippy_lints/src/comparison_chain.rs b/clippy_lints/src/comparison_chain.rs
index 90d31dece13..59b1c806e23 100644
--- a/clippy_lints/src/comparison_chain.rs
+++ b/clippy_lints/src/comparison_chain.rs
@@ -118,7 +118,7 @@ impl<'tcx> LateLintPass<'tcx> for ComparisonChain {
             "`if` chain can be rewritten with `match`",
             None,
             "Consider rewriting the `if` chain to use `cmp` and `match`.",
-        )
+        );
     }
 }
 
diff --git a/clippy_lints/src/eq_op.rs b/clippy_lints/src/eq_op.rs
index 6308f6e2e7e..e2881315b56 100644
--- a/clippy_lints/src/eq_op.rs
+++ b/clippy_lints/src/eq_op.rs
@@ -156,7 +156,7 @@ impl<'tcx> LateLintPass<'tcx> for EqOp {
                                         vec![(left.span, lsnip), (right.span, rsnip)],
                                     );
                                 },
-                            )
+                            );
                         } else if lcpy
                             && !rcpy
                             && implements_trait(cx, lty, trait_id, &[cx.typeck_results().expr_ty(right).into()])
@@ -175,7 +175,7 @@ impl<'tcx> LateLintPass<'tcx> for EqOp {
                                         Applicability::MaybeIncorrect, // FIXME #2597
                                     );
                                 },
-                            )
+                            );
                         } else if !lcpy
                             && rcpy
                             && implements_trait(cx, cx.typeck_results().expr_ty(left), trait_id, &[rty.into()])
@@ -194,7 +194,7 @@ impl<'tcx> LateLintPass<'tcx> for EqOp {
                                         Applicability::MaybeIncorrect, // FIXME #2597
                                     );
                                 },
-                            )
+                            );
                         }
                     },
                     // &foo == bar
@@ -218,7 +218,7 @@ impl<'tcx> LateLintPass<'tcx> for EqOp {
                                         Applicability::MaybeIncorrect, // FIXME #2597
                                     );
                                 },
-                            )
+                            );
                         }
                     },
                     // foo == &bar
@@ -236,7 +236,7 @@ impl<'tcx> LateLintPass<'tcx> for EqOp {
                                     rsnip,
                                     Applicability::MaybeIncorrect, // FIXME #2597
                                 );
-                            })
+                            });
                         }
                     },
                     _ => {},
diff --git a/clippy_lints/src/eta_reduction.rs b/clippy_lints/src/eta_reduction.rs
index 1a722d39f73..91f9df4649b 100644
--- a/clippy_lints/src/eta_reduction.rs
+++ b/clippy_lints/src/eta_reduction.rs
@@ -74,7 +74,7 @@ impl<'tcx> LateLintPass<'tcx> for EtaReduction {
         match expr.kind {
             ExprKind::Call(_, args) | ExprKind::MethodCall(_, _, args, _) => {
                 for arg in args {
-                    check_closure(cx, arg)
+                    check_closure(cx, arg);
                 }
             },
             _ => (),
diff --git a/clippy_lints/src/eval_order_dependence.rs b/clippy_lints/src/eval_order_dependence.rs
index bc2b2904698..8df14d80026 100644
--- a/clippy_lints/src/eval_order_dependence.rs
+++ b/clippy_lints/src/eval_order_dependence.rs
@@ -116,7 +116,7 @@ impl<'a, 'tcx> DivergenceVisitor<'a, 'tcx> {
                 self.visit_expr(e);
                 for arm in arms {
                     if let Some(Guard::If(if_expr)) = arm.guard {
-                        self.visit_expr(if_expr)
+                        self.visit_expr(if_expr);
                     }
                     // make sure top level arm expressions aren't linted
                     self.maybe_walk_expr(&*arm.body);
diff --git a/clippy_lints/src/functions.rs b/clippy_lints/src/functions.rs
index 87954254610..45973c8b0f7 100644
--- a/clippy_lints/src/functions.rs
+++ b/clippy_lints/src/functions.rs
@@ -270,7 +270,7 @@ impl<'tcx> LateLintPass<'tcx> for Functions {
                     _,
                 )
                 | intravisit::FnKind::ItemFn(_, _, hir::FnHeader { abi: Abi::Rust, .. }, _, _) => {
-                    self.check_arg_number(cx, decl, span.with_hi(decl.output.span().hi()))
+                    self.check_arg_number(cx, decl, span.with_hi(decl.output.span().hi()));
                 },
                 _ => {},
             }
@@ -434,7 +434,7 @@ impl<'tcx> Functions {
                 TOO_MANY_LINES,
                 span,
                 &format!("this function has too many lines ({}/{})", line_count, self.max_lines),
-            )
+            );
         }
     }
 
@@ -707,7 +707,7 @@ impl<'a, 'tcx> intravisit::Visitor<'tcx> for StaticMutVisitor<'a, 'tcx> {
                 }
             },
             Assign(ref target, ..) | AssignOp(_, ref target, _) | AddrOf(_, hir::Mutability::Mut, ref target) => {
-                self.mutates_static |= is_mutated_static(self.cx, target)
+                self.mutates_static |= is_mutated_static(self.cx, target);
             },
             _ => {},
         }
diff --git a/clippy_lints/src/future_not_send.rs b/clippy_lints/src/future_not_send.rs
index 7208e66ff7b..55bdda7138e 100644
--- a/clippy_lints/src/future_not_send.rs
+++ b/clippy_lints/src/future_not_send.rs
@@ -101,7 +101,7 @@ impl<'tcx> LateLintPass<'tcx> for FutureNotSend {
                                         ));
                                     }
                                 }
-                            })
+                            });
                         },
                     );
                 }
diff --git a/clippy_lints/src/infinite_iter.rs b/clippy_lints/src/infinite_iter.rs
index 129abd7d897..dd0a3d1610b 100644
--- a/clippy_lints/src/infinite_iter.rs
+++ b/clippy_lints/src/infinite_iter.rs
@@ -53,7 +53,7 @@ impl<'tcx> LateLintPass<'tcx> for InfiniteIter {
                 return;
             },
         };
-        span_lint(cx, lint, expr.span, msg)
+        span_lint(cx, lint, expr.span, msg);
     }
 }
 
diff --git a/clippy_lints/src/inherent_impl.rs b/clippy_lints/src/inherent_impl.rs
index ea26c84cde1..2c5e6f11216 100644
--- a/clippy_lints/src/inherent_impl.rs
+++ b/clippy_lints/src/inherent_impl.rs
@@ -85,8 +85,8 @@ impl<'tcx> LateLintPass<'tcx> for MultipleInherentImpl {
                             |diag| {
                                 diag.span_note(*initial_span, "first implementation here");
                             },
-                        )
-                    })
+                        );
+                    });
                 }
             }
         }
diff --git a/clippy_lints/src/len_zero.rs b/clippy_lints/src/len_zero.rs
index e95caf6a35f..599602c4a0b 100644
--- a/clippy_lints/src/len_zero.rs
+++ b/clippy_lints/src/len_zero.rs
@@ -256,9 +256,9 @@ fn check_cmp(cx: &LateContext<'_>, span: Span, method: &Expr<'_>, lit: &Expr<'_>
             }
         }
 
-        check_len(cx, span, method_path.ident.name, args, &lit.node, op, compare_to)
+        check_len(cx, span, method_path.ident.name, args, &lit.node, op, compare_to);
     } else {
-        check_empty_expr(cx, span, method, lit, op)
+        check_empty_expr(cx, span, method, lit, op);
     }
 }
 
diff --git a/clippy_lints/src/let_underscore.rs b/clippy_lints/src/let_underscore.rs
index 6a5a77f8690..33621775742 100644
--- a/clippy_lints/src/let_underscore.rs
+++ b/clippy_lints/src/let_underscore.rs
@@ -143,7 +143,7 @@ impl<'tcx> LateLintPass<'tcx> for LetUnderscore {
                         None,
                         "consider using an underscore-prefixed named \
                             binding or dropping explicitly with `std::mem::drop`"
-                    )
+                    );
                 } else if implements_drop {
                     span_lint_and_help(
                         cx,
@@ -153,7 +153,7 @@ impl<'tcx> LateLintPass<'tcx> for LetUnderscore {
                         None,
                         "consider using an underscore-prefixed named \
                             binding or dropping explicitly with `std::mem::drop`"
-                    )
+                    );
                 } else if is_must_use_ty(cx, cx.typeck_results().expr_ty(init)) {
                     span_lint_and_help(
                         cx,
@@ -162,7 +162,7 @@ impl<'tcx> LateLintPass<'tcx> for LetUnderscore {
                         "non-binding let on an expression with `#[must_use]` type",
                         None,
                         "consider explicitly using expression value"
-                    )
+                    );
                 } else if is_must_use_func_call(cx, init) {
                     span_lint_and_help(
                         cx,
@@ -171,7 +171,7 @@ impl<'tcx> LateLintPass<'tcx> for LetUnderscore {
                         "non-binding let on a result of a `#[must_use]` function",
                         None,
                         "consider explicitly using function result"
-                    )
+                    );
                 }
             }
         }
diff --git a/clippy_lints/src/lifetimes.rs b/clippy_lints/src/lifetimes.rs
index e84c8b4e5b3..740f207b214 100644
--- a/clippy_lints/src/lifetimes.rs
+++ b/clippy_lints/src/lifetimes.rs
@@ -205,7 +205,7 @@ fn could_use_elision<'tcx>(
         output_visitor.visit_ty(ty);
     }
     for lt in named_generics {
-        input_visitor.visit_generic_param(lt)
+        input_visitor.visit_generic_param(lt);
     }
 
     if input_visitor.abort() || output_visitor.abort() {
@@ -460,7 +460,7 @@ impl<'tcx> Visitor<'tcx> for LifetimeChecker {
         // `'b` in `'a: 'b` is useless unless used elsewhere in
         // a non-lifetime bound
         if let GenericParamKind::Type { .. } = param.kind {
-            walk_generic_param(self, param)
+            walk_generic_param(self, param);
         }
     }
     fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
diff --git a/clippy_lints/src/literal_representation.rs b/clippy_lints/src/literal_representation.rs
index 87a957a9bd2..7b75ab89bb8 100644
--- a/clippy_lints/src/literal_representation.rs
+++ b/clippy_lints/src/literal_representation.rs
@@ -229,7 +229,7 @@ impl EarlyLintPass for LiteralDigitGrouping {
         }
 
         if let ExprKind::Lit(ref lit) = expr.kind {
-            self.check_lit(cx, lit)
+            self.check_lit(cx, lit);
         }
     }
 }
@@ -292,7 +292,7 @@ impl LiteralDigitGrouping {
                         }
                     };
                     if should_warn {
-                        warning_type.display(num_lit.format(), cx, lit.span)
+                        warning_type.display(num_lit.format(), cx, lit.span);
                     }
                 }
             }
@@ -422,7 +422,7 @@ impl EarlyLintPass for DecimalLiteralRepresentation {
         }
 
         if let ExprKind::Lit(ref lit) = expr.kind {
-            self.check_lit(cx, lit)
+            self.check_lit(cx, lit);
         }
     }
 }
@@ -444,7 +444,7 @@ impl DecimalLiteralRepresentation {
                 let hex = format!("{:#X}", val);
                 let num_lit = NumericLiteral::new(&hex, num_lit.suffix, false);
                 let _ = Self::do_lint(num_lit.integer).map_err(|warning_type| {
-                    warning_type.display(num_lit.format(), cx, lit.span)
+                    warning_type.display(num_lit.format(), cx, lit.span);
                 });
             }
         }
diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 663c2df23e2..c7e0d32ca27 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -1426,7 +1426,7 @@ fn detect_same_item_push<'tcx>(
                 "try using vec![{};SIZE] or {}.resize(NEW_SIZE, {})",
                 item_str, vec_str, item_str
             ),
-        )
+        );
     }
 
     if !matches!(pat.kind, PatKind::Wild) {
@@ -1714,7 +1714,7 @@ fn lint_iter_method(cx: &LateContext<'_>, args: &[Expr<'_>], arg: &Expr<'_>, met
         "to write this more concisely, try",
         format!("&{}{}", muta, object),
         applicability,
-    )
+    );
 }
 
 fn check_for_loop_arg(cx: &LateContext<'_>, pat: &Pat<'_>, arg: &Expr<'_>, expr: &Expr<'_>) {
@@ -1753,7 +1753,7 @@ fn check_for_loop_arg(cx: &LateContext<'_>, pat: &Pat<'_>, arg: &Expr<'_>, expr:
                         },
                     );
                     if TyS::same_type(receiver_ty_adjusted, ref_receiver_ty) {
-                        lint_iter_method(cx, args, arg, method_name)
+                        lint_iter_method(cx, args, arg, method_name);
                     }
                 }
             } else if method_name == "next" && match_trait_method(cx, arg, &paths::ITERATOR) {
@@ -2075,10 +2075,10 @@ impl<'tcx> Delegate<'tcx> for MutatePairDelegate<'_, 'tcx> {
         if let ty::BorrowKind::MutBorrow = bk {
             if let PlaceBase::Local(id) = cmt.place.base {
                 if Some(id) == self.hir_id_low {
-                    self.span_low = Some(self.cx.tcx.hir().span(diag_expr_id))
+                    self.span_low = Some(self.cx.tcx.hir().span(diag_expr_id));
                 }
                 if Some(id) == self.hir_id_high {
-                    self.span_high = Some(self.cx.tcx.hir().span(diag_expr_id))
+                    self.span_high = Some(self.cx.tcx.hir().span(diag_expr_id));
                 }
             }
         }
@@ -2087,10 +2087,10 @@ impl<'tcx> Delegate<'tcx> for MutatePairDelegate<'_, 'tcx> {
     fn mutate(&mut self, cmt: &PlaceWithHirId<'tcx>, diag_expr_id: HirId) {
         if let PlaceBase::Local(id) = cmt.place.base {
             if Some(id) == self.hir_id_low {
-                self.span_low = Some(self.cx.tcx.hir().span(diag_expr_id))
+                self.span_low = Some(self.cx.tcx.hir().span(diag_expr_id));
             }
             if Some(id) == self.hir_id_high {
-                self.span_high = Some(self.cx.tcx.hir().span(diag_expr_id))
+                self.span_high = Some(self.cx.tcx.hir().span(diag_expr_id));
             }
         }
     }
@@ -2543,10 +2543,10 @@ impl<'a, 'tcx> Visitor<'tcx> for IncrementVisitor<'a, 'tcx> {
                         }
                     },
                     ExprKind::Assign(ref lhs, _, _) if lhs.hir_id == expr.hir_id => {
-                        *state = IncrementVisitorVarState::DontWarn
+                        *state = IncrementVisitorVarState::DontWarn;
                     },
                     ExprKind::AddrOf(BorrowKind::Ref, mutability, _) if mutability == Mutability::Mut => {
-                        *state = IncrementVisitorVarState::DontWarn
+                        *state = IncrementVisitorVarState::DontWarn;
                     },
                     _ => (),
                 }
@@ -2670,7 +2670,7 @@ impl<'a, 'tcx> Visitor<'tcx> for InitializeVisitor<'a, 'tcx> {
                         }
                     },
                     ExprKind::AddrOf(BorrowKind::Ref, mutability, _) if mutability == Mutability::Mut => {
-                        self.state = InitializeVisitorState::DontWarn
+                        self.state = InitializeVisitorState::DontWarn;
                     },
                     _ => (),
                 }
@@ -2815,7 +2815,7 @@ impl<'tcx> Visitor<'tcx> for LoopNestVisitor {
                 return;
             }
         }
-        walk_pat(self, pat)
+        walk_pat(self, pat);
     }
 
     fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
diff --git a/clippy_lints/src/macro_use.rs b/clippy_lints/src/macro_use.rs
index bb52888883a..f4ffe189940 100644
--- a/clippy_lints/src/macro_use.rs
+++ b/clippy_lints/src/macro_use.rs
@@ -206,9 +206,9 @@ impl<'tcx> LateLintPass<'tcx> for MacroUseImports {
         let mut suggestions = vec![];
         for ((root, span), path) in used {
             if path.len() == 1 {
-                suggestions.push((span, format!("{}::{}", root, path[0])))
+                suggestions.push((span, format!("{}::{}", root, path[0])));
             } else {
-                suggestions.push((span, format!("{}::{{{}}}", root, path.join(", "))))
+                suggestions.push((span, format!("{}::{{{}}}", root, path.join(", "))));
             }
         }
 
@@ -225,7 +225,7 @@ impl<'tcx> LateLintPass<'tcx> for MacroUseImports {
                     "remove the attribute and import the macro directly, try",
                     help,
                     Applicability::MaybeIncorrect,
-                )
+                );
             }
         }
     }
diff --git a/clippy_lints/src/manual_strip.rs b/clippy_lints/src/manual_strip.rs
index 42a92104a49..11d101c5025 100644
--- a/clippy_lints/src/manual_strip.rs
+++ b/clippy_lints/src/manual_strip.rs
@@ -126,7 +126,7 @@ impl<'tcx> LateLintPass<'tcx> for ManualStrip {
                                           kind_word,
                                           snippet(cx, pattern.span, "..")))]
                             .into_iter().chain(strippings.into_iter().map(|span| (span, "<stripped>".into()))),
-                        )
+                        );
                     });
                 }
             }
diff --git a/clippy_lints/src/map_clone.rs b/clippy_lints/src/map_clone.rs
index 1818836d5d5..b3be755d488 100644
--- a/clippy_lints/src/map_clone.rs
+++ b/clippy_lints/src/map_clone.rs
@@ -122,7 +122,7 @@ fn lint_needless_cloning(cx: &LateContext<'_>, root: Span, receiver: Span) {
         "remove the `map` call",
         String::new(),
         Applicability::MachineApplicable,
-    )
+    );
 }
 
 fn lint(cx: &LateContext<'_>, replace: Span, root: Span, copied: bool) {
@@ -139,7 +139,7 @@ fn lint(cx: &LateContext<'_>, replace: Span, root: Span, copied: bool) {
                 snippet_with_applicability(cx, root, "..", &mut applicability)
             ),
             applicability,
-        )
+        );
     } else {
         span_lint_and_sugg(
             cx,
@@ -152,6 +152,6 @@ fn lint(cx: &LateContext<'_>, replace: Span, root: Span, copied: bool) {
                 snippet_with_applicability(cx, root, "..", &mut applicability)
             ),
             applicability,
-        )
+        );
     }
 }
diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index ba7b9bd0424..74d36777779 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -1046,7 +1046,7 @@ fn check_wild_enum_match(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>])
                 "try this",
                 suggestion[0].clone(),
                 Applicability::MaybeIncorrect,
-            )
+            );
         };
 
         span_lint_and_sugg(
@@ -1057,7 +1057,7 @@ fn check_wild_enum_match(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>])
             "try this",
             suggestion.join(" | "),
             Applicability::MaybeIncorrect,
-        )
+        );
     }
 }
 
@@ -1156,7 +1156,7 @@ fn check_match_as_ref(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>], exp
                     cast,
                 ),
                 applicability,
-            )
+            );
         }
     }
 }
diff --git a/clippy_lints/src/methods/bind_instead_of_map.rs b/clippy_lints/src/methods/bind_instead_of_map.rs
index 540a1484a85..897a3194ca1 100644
--- a/clippy_lints/src/methods/bind_instead_of_map.rs
+++ b/clippy_lints/src/methods/bind_instead_of_map.rs
@@ -151,7 +151,7 @@ pub(crate) trait BindInsteadOfMap {
                             .into_iter()
                             .map(|(span1, span2)| (span1, snippet(cx, span2, "_").into())),
                     ),
-                )
+                );
             });
         }
         can_sugg
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index a17c5996293..e02b6403819 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1582,10 +1582,10 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             ["flatten", "map"] => lint_map_flatten(cx, expr, arg_lists[1]),
             ["is_some", "find"] => lint_search_is_some(cx, expr, "find", arg_lists[1], arg_lists[0], method_spans[1]),
             ["is_some", "position"] => {
-                lint_search_is_some(cx, expr, "position", arg_lists[1], arg_lists[0], method_spans[1])
+                lint_search_is_some(cx, expr, "position", arg_lists[1], arg_lists[0], method_spans[1]);
             },
             ["is_some", "rposition"] => {
-                lint_search_is_some(cx, expr, "rposition", arg_lists[1], arg_lists[0], method_spans[1])
+                lint_search_is_some(cx, expr, "rposition", arg_lists[1], arg_lists[0], method_spans[1]);
             },
             ["extend", ..] => lint_extend(cx, expr, arg_lists[0]),
             ["nth", "iter"] => lint_iter_nth(cx, expr, &arg_lists, false),
@@ -1601,17 +1601,17 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             ["count", "map"] => lint_suspicious_map(cx, expr),
             ["assume_init"] => lint_maybe_uninit(cx, &arg_lists[0][0], expr),
             ["unwrap_or", arith @ ("checked_add" | "checked_sub" | "checked_mul")] => {
-                manual_saturating_arithmetic::lint(cx, expr, &arg_lists, &arith["checked_".len()..])
+                manual_saturating_arithmetic::lint(cx, expr, &arg_lists, &arith["checked_".len()..]);
             },
             ["add" | "offset" | "sub" | "wrapping_offset" | "wrapping_add" | "wrapping_sub"] => {
-                check_pointer_offset(cx, expr, arg_lists[0])
+                check_pointer_offset(cx, expr, arg_lists[0]);
             },
             ["is_file", ..] => lint_filetype_is_file(cx, expr, arg_lists[0]),
             ["map", "as_ref"] => {
-                lint_option_as_ref_deref(cx, expr, arg_lists[1], arg_lists[0], false, self.msrv.as_ref())
+                lint_option_as_ref_deref(cx, expr, arg_lists[1], arg_lists[0], false, self.msrv.as_ref());
             },
             ["map", "as_mut"] => {
-                lint_option_as_ref_deref(cx, expr, arg_lists[1], arg_lists[0], true, self.msrv.as_ref())
+                lint_option_as_ref_deref(cx, expr, arg_lists[1], arg_lists[0], true, self.msrv.as_ref());
             },
             ["unwrap_or_else", ..] => unnecessary_lazy_eval::lint(cx, expr, arg_lists[0], "unwrap_or"),
             ["get_or_insert_with", ..] => unnecessary_lazy_eval::lint(cx, expr, arg_lists[0], "get_or_insert"),
@@ -2446,16 +2446,16 @@ fn lint_unnecessary_fold(cx: &LateContext<'_>, expr: &hir::Expr<'_>, fold_args:
     if let hir::ExprKind::Lit(ref lit) = fold_args[1].kind {
         match lit.node {
             ast::LitKind::Bool(false) => {
-                check_fold_with_op(cx, expr, fold_args, fold_span, hir::BinOpKind::Or, "any", true)
+                check_fold_with_op(cx, expr, fold_args, fold_span, hir::BinOpKind::Or, "any", true);
             },
             ast::LitKind::Bool(true) => {
-                check_fold_with_op(cx, expr, fold_args, fold_span, hir::BinOpKind::And, "all", true)
+                check_fold_with_op(cx, expr, fold_args, fold_span, hir::BinOpKind::And, "all", true);
             },
             ast::LitKind::Int(0, _) => {
-                check_fold_with_op(cx, expr, fold_args, fold_span, hir::BinOpKind::Add, "sum", false)
+                check_fold_with_op(cx, expr, fold_args, fold_span, hir::BinOpKind::Add, "sum", false);
             },
             ast::LitKind::Int(1, _) => {
-                check_fold_with_op(cx, expr, fold_args, fold_span, hir::BinOpKind::Mul, "product", false)
+                check_fold_with_op(cx, expr, fold_args, fold_span, hir::BinOpKind::Mul, "product", false);
             },
             _ => (),
         }
diff --git a/clippy_lints/src/mut_reference.rs b/clippy_lints/src/mut_reference.rs
index 3f0b765df15..7c21632c9d5 100644
--- a/clippy_lints/src/mut_reference.rs
+++ b/clippy_lints/src/mut_reference.rs
@@ -47,7 +47,7 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryMutPassed {
                 let def_id = cx.typeck_results().type_dependent_def_id(e.hir_id).unwrap();
                 let substs = cx.typeck_results().node_substs(e.hir_id);
                 let method_type = cx.tcx.type_of(def_id).subst(cx.tcx, substs);
-                check_arguments(cx, arguments, method_type, &path.ident.as_str(), "method")
+                check_arguments(cx, arguments, method_type, &path.ident.as_str(), "method");
             },
             _ => (),
         }
diff --git a/clippy_lints/src/mutable_debug_assertion.rs b/clippy_lints/src/mutable_debug_assertion.rs
index 76417aa7ed0..b99e9576f5e 100644
--- a/clippy_lints/src/mutable_debug_assertion.rs
+++ b/clippy_lints/src/mutable_debug_assertion.rs
@@ -106,7 +106,7 @@ impl<'a, 'tcx> Visitor<'tcx> for MutArgVisitor<'a, 'tcx> {
             _ if !self.found => self.expr_span = Some(expr.span),
             _ => return,
         }
-        walk_expr(self, expr)
+        walk_expr(self, expr);
     }
 
     fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
diff --git a/clippy_lints/src/needless_arbitrary_self_type.rs b/clippy_lints/src/needless_arbitrary_self_type.rs
index 7687962bdd9..107d6a57966 100644
--- a/clippy_lints/src/needless_arbitrary_self_type.rs
+++ b/clippy_lints/src/needless_arbitrary_self_type.rs
@@ -120,7 +120,7 @@ impl EarlyLintPass for NeedlessArbitrarySelfType {
         match &p.ty.kind {
             TyKind::Path(None, path) => {
                 if let PatKind::Ident(BindingMode::ByValue(mutbl), _, _) = p.pat.kind {
-                    check_param_inner(cx, path, p.span.to(p.ty.span), &Mode::Value, mutbl)
+                    check_param_inner(cx, path, p.span.to(p.ty.span), &Mode::Value, mutbl);
                 }
             },
             TyKind::Rptr(lifetime, mut_ty) => {
diff --git a/clippy_lints/src/needless_bool.rs b/clippy_lints/src/needless_bool.rs
index d795f126457..614a1e8980c 100644
--- a/clippy_lints/src/needless_bool.rs
+++ b/clippy_lints/src/needless_bool.rs
@@ -80,7 +80,7 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessBool {
                 }
 
                 if parent_node_is_if_expr(&e, &cx) {
-                    snip = snip.blockify()
+                    snip = snip.blockify();
                 }
 
                 span_lint_and_sugg(
@@ -142,7 +142,7 @@ impl<'tcx> LateLintPass<'tcx> for BoolComparison {
                         |h: Sugg<'_>| !h,
                         "equality checks against false can be replaced by a negation",
                     ));
-                    check_comparison(cx, e, true_case, false_case, true_case, false_case, ignore_no_literal)
+                    check_comparison(cx, e, true_case, false_case, true_case, false_case, ignore_no_literal);
                 },
                 BinOpKind::Ne => {
                     let true_case = Some((
@@ -150,7 +150,7 @@ impl<'tcx> LateLintPass<'tcx> for BoolComparison {
                         "inequality checks against true can be replaced by a negation",
                     ));
                     let false_case = Some((|h| h, "inequality checks against false are unnecessary"));
-                    check_comparison(cx, e, true_case, false_case, true_case, false_case, ignore_no_literal)
+                    check_comparison(cx, e, true_case, false_case, true_case, false_case, ignore_no_literal);
                 },
                 BinOpKind::Lt => check_comparison(
                     cx,
@@ -249,22 +249,22 @@ fn check_comparison<'a, 'tcx>(
                             snippet_with_applicability(cx, expression_info.right_span, "..", &mut applicability)
                         ),
                         applicability,
-                    )
+                    );
                 }
             }
 
             match (fetch_bool_expr(left_side), fetch_bool_expr(right_side)) {
                 (Bool(true), Other) => left_true.map_or((), |(h, m)| {
-                    suggest_bool_comparison(cx, e, right_side, applicability, m, h)
+                    suggest_bool_comparison(cx, e, right_side, applicability, m, h);
                 }),
                 (Other, Bool(true)) => right_true.map_or((), |(h, m)| {
-                    suggest_bool_comparison(cx, e, left_side, applicability, m, h)
+                    suggest_bool_comparison(cx, e, left_side, applicability, m, h);
                 }),
                 (Bool(false), Other) => left_false.map_or((), |(h, m)| {
-                    suggest_bool_comparison(cx, e, right_side, applicability, m, h)
+                    suggest_bool_comparison(cx, e, right_side, applicability, m, h);
                 }),
                 (Other, Bool(false)) => right_false.map_or((), |(h, m)| {
-                    suggest_bool_comparison(cx, e, left_side, applicability, m, h)
+                    suggest_bool_comparison(cx, e, left_side, applicability, m, h);
                 }),
                 (Other, Other) => no_literal.map_or((), |(h, m)| {
                     let left_side = Sugg::hir_with_applicability(cx, left_side, "..", &mut applicability);
@@ -277,7 +277,7 @@ fn check_comparison<'a, 'tcx>(
                         "try simplifying it as shown",
                         h(left_side, right_side).to_string(),
                         applicability,
-                    )
+                    );
                 }),
                 _ => (),
             }
diff --git a/clippy_lints/src/neg_cmp_op_on_partial_ord.rs b/clippy_lints/src/neg_cmp_op_on_partial_ord.rs
index 4fb899125e8..6a20d5f139a 100644
--- a/clippy_lints/src/neg_cmp_op_on_partial_ord.rs
+++ b/clippy_lints/src/neg_cmp_op_on_partial_ord.rs
@@ -83,7 +83,7 @@ impl<'tcx> LateLintPass<'tcx> for NoNegCompOpForPartialOrd {
                         types produces code that is hard to read and refactor, please \
                         consider using the `partial_cmp` method instead, to make it \
                         clear that the two values could be incomparable"
-                    )
+                    );
                 }
             }
         }
diff --git a/clippy_lints/src/open_options.rs b/clippy_lints/src/open_options.rs
index 73a99a3a2f8..82143f7a288 100644
--- a/clippy_lints/src/open_options.rs
+++ b/clippy_lints/src/open_options.rs
@@ -125,7 +125,7 @@ fn check_open_options(cx: &LateContext<'_>, options: &[(OpenOption, Argument)],
                         "the method `create` is called more than once",
                     );
                 } else {
-                    create = true
+                    create = true;
                 }
                 create_arg = create_arg || (arg == Argument::True);
             },
@@ -138,7 +138,7 @@ fn check_open_options(cx: &LateContext<'_>, options: &[(OpenOption, Argument)],
                         "the method `append` is called more than once",
                     );
                 } else {
-                    append = true
+                    append = true;
                 }
                 append_arg = append_arg || (arg == Argument::True);
             },
@@ -151,7 +151,7 @@ fn check_open_options(cx: &LateContext<'_>, options: &[(OpenOption, Argument)],
                         "the method `truncate` is called more than once",
                     );
                 } else {
-                    truncate = true
+                    truncate = true;
                 }
                 truncate_arg = truncate_arg || (arg == Argument::True);
             },
@@ -164,7 +164,7 @@ fn check_open_options(cx: &LateContext<'_>, options: &[(OpenOption, Argument)],
                         "the method `read` is called more than once",
                     );
                 } else {
-                    read = true
+                    read = true;
                 }
                 read_arg = read_arg || (arg == Argument::True);
             },
@@ -177,7 +177,7 @@ fn check_open_options(cx: &LateContext<'_>, options: &[(OpenOption, Argument)],
                         "the method `write` is called more than once",
                     );
                 } else {
-                    write = true
+                    write = true;
                 }
                 write_arg = write_arg || (arg == Argument::True);
             },
diff --git a/clippy_lints/src/question_mark.rs b/clippy_lints/src/question_mark.rs
index 6c480d48c75..63c904b7fb4 100644
--- a/clippy_lints/src/question_mark.rs
+++ b/clippy_lints/src/question_mark.rs
@@ -88,7 +88,7 @@ impl QuestionMark {
                         "replace it with",
                         replacement_str,
                         applicability,
-                    )
+                    );
                 }
             }
         }
diff --git a/clippy_lints/src/redundant_closure_call.rs b/clippy_lints/src/redundant_closure_call.rs
index f398b3fff25..daea1592018 100644
--- a/clippy_lints/src/redundant_closure_call.rs
+++ b/clippy_lints/src/redundant_closure_call.rs
@@ -56,7 +56,7 @@ impl<'ast> ast_visit::Visitor<'ast> for ReturnVisitor {
             self.found_return = true;
         }
 
-        ast_visit::walk_expr(self, ex)
+        ast_visit::walk_expr(self, ex);
     }
 }
 
diff --git a/clippy_lints/src/redundant_pub_crate.rs b/clippy_lints/src/redundant_pub_crate.rs
index acd9047ace6..127f6078dab 100644
--- a/clippy_lints/src/redundant_pub_crate.rs
+++ b/clippy_lints/src/redundant_pub_crate.rs
@@ -60,7 +60,7 @@ impl<'tcx> LateLintPass<'tcx> for RedundantPubCrate {
                                 Applicability::MachineApplicable,
                             );
                         },
-                    )
+                    );
                 }
             }
         }
diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
index e438f92b136..e7b66c5ebcf 100644
--- a/clippy_lints/src/returns.rs
+++ b/clippy_lints/src/returns.rs
@@ -139,7 +139,7 @@ impl<'tcx> LateLintPass<'tcx> for Return {
                 } else {
                     RetReplacement::Empty
                 };
-                check_final_expr(cx, &body.value, Some(body.value.span), replacement)
+                check_final_expr(cx, &body.value, Some(body.value.span), replacement);
             },
             FnKind::ItemFn(..) | FnKind::Method(..) => {
                 if let ExprKind::Block(ref block, _) = body.value.kind {
@@ -239,7 +239,7 @@ fn emit_return_lint(cx: &LateContext<'_>, ret_span: Span, inner_span: Option<Spa
                 if let Some(snippet) = snippet_opt(cx, inner_span) {
                     diag.span_suggestion(ret_span, "remove `return`", snippet, Applicability::MachineApplicable);
                 }
-            })
+            });
         },
         None => match replacement {
             RetReplacement::Empty => {
diff --git a/clippy_lints/src/semicolon_if_nothing_returned.rs b/clippy_lints/src/semicolon_if_nothing_returned.rs
index 22cd10ced18..f47ca1b69b1 100644
--- a/clippy_lints/src/semicolon_if_nothing_returned.rs
+++ b/clippy_lints/src/semicolon_if_nothing_returned.rs
@@ -1,7 +1,7 @@
-use crate::utils::{in_macro, span_lint_and_then, sugg};
+use crate::utils::{in_macro, span_lint_and_sugg, sugg};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
-use rustc_hir::*;
+use rustc_hir::{Block, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
@@ -42,31 +42,25 @@ impl LateLintPass<'_> for SemicolonIfNothingReturned {
             if let Some(expr) = block.expr;
             let t_expr = cx.typeck_results().expr_ty(expr);
             if t_expr.is_unit();
+            if let Ok(snippet) = cx.tcx.sess.source_map().span_to_snippet(expr.span.source_callsite());
+            if !snippet.ends_with('}');
             then {
-                match expr.kind {
-                    ExprKind::Loop(..) | 
-                    ExprKind::Match(..) | 
-                    ExprKind::Block(..) | 
-                    ExprKind::If(..) if !in_macro(expr.span) => return,
-                   _ => (),
+                // filter out the desugared `for` loop
+                if let ExprKind::DropTemps(..) = &expr.kind {
+                    return;
                 }
 
                 let sugg = sugg::Sugg::hir(cx, &expr, "..");
                 let suggestion = format!("{0};", sugg);
-                span_lint_and_then(
+                span_lint_and_sugg(
                     cx,
                     SEMICOLON_IF_NOTHING_RETURNED,
                     expr.span,
-                    "add `;` to terminate block",
-                    | diag | {
-                        diag.span_suggestion(
-                            expr.span,
-                            "add `;`",
-                            suggestion,
-                            Applicability::MaybeIncorrect,
-                        );
-                    }
-                )
+                    "Consider adding a `;` to the last statement for consistent formatting",
+                    "add a `;` here",
+                    suggestion,
+                    Applicability::MaybeIncorrect,
+                );
             }
         }
     }
diff --git a/clippy_lints/src/shadow.rs b/clippy_lints/src/shadow.rs
index d5b1767e945..3af98632712 100644
--- a/clippy_lints/src/shadow.rs
+++ b/clippy_lints/src/shadow.rs
@@ -118,7 +118,7 @@ fn check_fn<'tcx>(cx: &LateContext<'tcx>, decl: &'tcx FnDecl<'_>, body: &'tcx Bo
     let mut bindings = Vec::with_capacity(decl.inputs.len());
     for arg in iter_input_pats(decl, body) {
         if let PatKind::Binding(.., ident, _) = arg.pat.kind {
-            bindings.push((ident.name, ident.span))
+            bindings.push((ident.name, ident.span));
         }
     }
     check_expr(cx, &body.value, &mut bindings);
@@ -154,7 +154,7 @@ fn check_local<'tcx>(cx: &LateContext<'tcx>, local: &'tcx Local<'_>, bindings: &
         ..
     } = *local;
     if let Some(ref t) = *ty {
-        check_ty(cx, t, bindings)
+        check_ty(cx, t, bindings);
     }
     if let Some(ref o) = *init {
         check_expr(cx, o, bindings);
@@ -330,7 +330,7 @@ fn check_expr<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, bindings: &mut
         // ExprKind::MethodCall
         ExprKind::Array(v) | ExprKind::Tup(v) => {
             for e in v {
-                check_expr(cx, e, bindings)
+                check_expr(cx, e, bindings);
             }
         },
         ExprKind::If(ref cond, ref then, ref otherwise) => {
@@ -371,11 +371,11 @@ fn check_ty<'tcx>(cx: &LateContext<'tcx>, ty: &'tcx Ty<'_>, bindings: &mut Vec<(
             check_expr(cx, &cx.tcx.hir().body(anon_const.body).value, bindings);
         },
         TyKind::Ptr(MutTy { ty: ref mty, .. }) | TyKind::Rptr(_, MutTy { ty: ref mty, .. }) => {
-            check_ty(cx, mty, bindings)
+            check_ty(cx, mty, bindings);
         },
         TyKind::Tup(tup) => {
             for t in tup {
-                check_ty(cx, t, bindings)
+                check_ty(cx, t, bindings);
             }
         },
         TyKind::Typeof(ref anon_const) => check_expr(cx, &cx.tcx.hir().body(anon_const.body).value, bindings),
diff --git a/clippy_lints/src/slow_vector_initialization.rs b/clippy_lints/src/slow_vector_initialization.rs
index 96f6881556c..9ba9b4187d2 100644
--- a/clippy_lints/src/slow_vector_initialization.rs
+++ b/clippy_lints/src/slow_vector_initialization.rs
@@ -306,7 +306,7 @@ impl<'a, 'tcx> Visitor<'tcx> for VectorInitializationVisitor<'a, 'tcx> {
     fn visit_block(&mut self, block: &'tcx Block<'_>) {
         if self.initialization_found {
             if let Some(ref s) = block.stmts.get(0) {
-                self.visit_stmt(s)
+                self.visit_stmt(s);
             }
 
             self.initialization_found = false;
diff --git a/clippy_lints/src/suspicious_operation_groupings.rs b/clippy_lints/src/suspicious_operation_groupings.rs
index cccd24ccf94..f245789d75d 100644
--- a/clippy_lints/src/suspicious_operation_groupings.rs
+++ b/clippy_lints/src/suspicious_operation_groupings.rs
@@ -265,7 +265,7 @@ fn emit_suggestion(cx: &EarlyContext<'_>, span: Span, sugg: String, applicabilit
         "I think you meant",
         sugg,
         applicability,
-    )
+    );
 }
 
 fn ident_swap_sugg(
@@ -476,7 +476,7 @@ impl Add for IdentLocation {
 
 impl AddAssign for IdentLocation {
     fn add_assign(&mut self, other: Self) {
-        *self = *self + other
+        *self = *self + other;
     }
 }
 
@@ -507,7 +507,7 @@ impl Add for IdentDifference {
 
 impl AddAssign for IdentDifference {
     fn add_assign(&mut self, other: Self) {
-        *self = *self + other
+        *self = *self + other;
     }
 }
 
diff --git a/clippy_lints/src/transmute.rs b/clippy_lints/src/transmute.rs
index d977cea4da5..e619a1a698a 100644
--- a/clippy_lints/src/transmute.rs
+++ b/clippy_lints/src/transmute.rs
@@ -463,7 +463,7 @@ impl<'tcx> LateLintPass<'tcx> for Transmute {
                                     Applicability::Unspecified,
                                 );
                             },
-                        )
+                        );
                     },
                     (ty::Ref(_, ty_from, from_mutbl), ty::Ref(_, ty_to, to_mutbl)) => {
                         if_chain! {
@@ -519,7 +519,7 @@ impl<'tcx> LateLintPass<'tcx> for Transmute {
                                                 Applicability::Unspecified,
                                             );
                                         },
-                                    )
+                                    );
                                 }
                             }
                         }
@@ -552,7 +552,7 @@ impl<'tcx> LateLintPass<'tcx> for Transmute {
                                     Applicability::Unspecified,
                                 );
                             },
-                        )
+                        );
                     },
                     (ty::Int(_) | ty::Uint(_), ty::Float(_)) if !const_context => span_lint_and_then(
                         cx,
diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs
index 1b0f1e309aa..dd3e934889a 100644
--- a/clippy_lints/src/types.rs
+++ b/clippy_lints/src/types.rs
@@ -630,7 +630,7 @@ impl Types {
             TyKind::Rptr(ref lt, ref mut_ty) => self.check_ty_rptr(cx, hir_ty, is_local, lt, mut_ty),
             // recurse
             TyKind::Slice(ref ty) | TyKind::Array(ref ty, _) | TyKind::Ptr(MutTy { ref ty, .. }) => {
-                self.check_ty(cx, ty, is_local)
+                self.check_ty(cx, ty, is_local);
             },
             TyKind::Tup(tys) => {
                 for ty in tys {
@@ -2436,7 +2436,7 @@ fn upcast_comparison_bounds_err<'tcx>(
                 },
                 Rel::Eq | Rel::Ne => unreachable!(),
             } {
-                err_upcast_comparison(cx, span, lhs, true)
+                err_upcast_comparison(cx, span, lhs, true);
             } else if match rel {
                 Rel::Lt => {
                     if invert {
@@ -2454,7 +2454,7 @@ fn upcast_comparison_bounds_err<'tcx>(
                 },
                 Rel::Eq | Rel::Ne => unreachable!(),
             } {
-                err_upcast_comparison(cx, span, lhs, false)
+                err_upcast_comparison(cx, span, lhs, false);
             }
         }
     }
diff --git a/clippy_lints/src/unicode.rs b/clippy_lints/src/unicode.rs
index 93d59cc7fcd..9346e3c1d3b 100644
--- a/clippy_lints/src/unicode.rs
+++ b/clippy_lints/src/unicode.rs
@@ -69,7 +69,7 @@ impl LateLintPass<'_> for Unicode {
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &'_ Expr<'_>) {
         if let ExprKind::Lit(ref lit) = expr.kind {
             if let LitKind::Str(_, _) = lit.node {
-                check_str(cx, lit.span, expr.hir_id)
+                check_str(cx, lit.span, expr.hir_id);
             }
         }
     }
@@ -80,7 +80,7 @@ fn escape<T: Iterator<Item = char>>(s: T) -> String {
     for c in s {
         if c as u32 > 0x7F {
             for d in c.escape_unicode() {
-                result.push(d)
+                result.push(d);
             }
         } else {
             result.push(c);
diff --git a/clippy_lints/src/unused_self.rs b/clippy_lints/src/unused_self.rs
index 5349c4f7eb8..83ba9c897e0 100644
--- a/clippy_lints/src/unused_self.rs
+++ b/clippy_lints/src/unused_self.rs
@@ -94,7 +94,7 @@ impl<'a, 'tcx> Visitor<'tcx> for UnusedSelfVisitor<'a, 'tcx> {
             return;
         }
         if let Res::Local(hir_id) = &path.res {
-            self.uses_self = self.self_hir_id == hir_id
+            self.uses_self = self.self_hir_id == hir_id;
         }
         walk_path(self, path);
     }
diff --git a/clippy_lints/src/upper_case_acronyms.rs b/clippy_lints/src/upper_case_acronyms.rs
index 61e7031716a..0f04a4a62ce 100644
--- a/clippy_lints/src/upper_case_acronyms.rs
+++ b/clippy_lints/src/upper_case_acronyms.rs
@@ -69,7 +69,7 @@ fn check_ident(cx: &EarlyContext<'_>, ident: &Ident) {
             "consider making the acronym lowercase, except the initial letter",
             corrected,
             Applicability::MaybeIncorrect,
-        )
+        );
     }
 }
 
diff --git a/clippy_lints/src/use_self.rs b/clippy_lints/src/use_self.rs
index 72d1ca73929..4bbfb3fbeb1 100644
--- a/clippy_lints/src/use_self.rs
+++ b/clippy_lints/src/use_self.rs
@@ -103,7 +103,7 @@ impl<'a, 'tcx> Visitor<'tcx> for SemanticUseSelfVisitor<'a, 'tcx> {
             }
         }
 
-        walk_ty(self, hir_ty)
+        walk_ty(self, hir_ty);
     }
 
     fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
diff --git a/clippy_lints/src/utils/attrs.rs b/clippy_lints/src/utils/attrs.rs
index 8d28421d70d..588c31ea40f 100644
--- a/clippy_lints/src/utils/attrs.rs
+++ b/clippy_lints/src/utils/attrs.rs
@@ -115,7 +115,7 @@ fn parse_attrs<F: FnMut(u64)>(sess: &Session, attrs: &[ast::Attribute], name: &'
     for attr in get_attr(sess, attrs, name) {
         if let Some(ref value) = attr.value_str() {
             if let Ok(value) = FromStr::from_str(&value.as_str()) {
-                f(value)
+                f(value);
             } else {
                 sess.span_err(attr.span, "not a number");
             }
diff --git a/clippy_lints/src/utils/author.rs b/clippy_lints/src/utils/author.rs
index ca60d335262..b8c50112497 100644
--- a/clippy_lints/src/utils/author.rs
+++ b/clippy_lints/src/utils/author.rs
@@ -293,7 +293,7 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor {
                     LitKind::Str(ref text, _) => {
                         let str_pat = self.next("s");
                         println!("    if let LitKind::Str(ref {}, _) = {}.node;", str_pat, lit_pat);
-                        println!("    if {}.as_str() == {:?}", str_pat, &*text.as_str())
+                        println!("    if {}.as_str() == {:?}", str_pat, &*text.as_str());
                     },
                 }
             },
diff --git a/clippy_lints/src/utils/diagnostics.rs b/clippy_lints/src/utils/diagnostics.rs
index 269be217c2d..f74ce999b5c 100644
--- a/clippy_lints/src/utils/diagnostics.rs
+++ b/clippy_lints/src/utils/diagnostics.rs
@@ -211,7 +211,7 @@ pub fn multispan_sugg<I>(diag: &mut DiagnosticBuilder<'_>, help_msg: &str, sugg:
 where
     I: IntoIterator<Item = (Span, String)>,
 {
-    multispan_sugg_with_applicability(diag, help_msg, Applicability::Unspecified, sugg)
+    multispan_sugg_with_applicability(diag, help_msg, Applicability::Unspecified, sugg);
 }
 
 pub fn multispan_sugg_with_applicability<I>(
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index cf93ee0a7a5..a519dce66d4 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -464,7 +464,7 @@ pub fn method_chain_args<'a>(expr: &'a Expr<'_>, methods: &[&str]) -> Option<Vec
                     return None;
                 }
                 matched.push(&**args); // build up `matched` backwards
-                current = &args[0] // go to parent expression
+                current = &args[0]; // go to parent expression
             } else {
                 return None;
             }
diff --git a/clippy_lints/src/utils/sugg.rs b/clippy_lints/src/utils/sugg.rs
index 03678db575f..281ea4dffc7 100644
--- a/clippy_lints/src/utils/sugg.rs
+++ b/clippy_lints/src/utils/sugg.rs
@@ -656,7 +656,7 @@ impl<T: LintContext> DiagnosticBuilderExt<T> for rustc_errors::DiagnosticBuilder
 
             if let Some(non_whitespace_offset) = non_whitespace_offset {
                 remove_span = remove_span
-                    .with_hi(remove_span.hi() + BytePos(non_whitespace_offset.try_into().expect("offset too large")))
+                    .with_hi(remove_span.hi() + BytePos(non_whitespace_offset.try_into().expect("offset too large")));
             }
         }
 
diff --git a/clippy_lints/src/utils/usage.rs b/clippy_lints/src/utils/usage.rs
index fc0db7f64ec..8bf169c0d06 100644
--- a/clippy_lints/src/utils/usage.rs
+++ b/clippy_lints/src/utils/usage.rs
@@ -60,7 +60,7 @@ impl<'tcx> MutVarsDelegate {
                 //FIXME: This causes false negatives. We can't get the `NodeId` from
                 //`Categorization::Upvar(_)`. So we search for any `Upvar`s in the
                 //`while`-body, not just the ones in the condition.
-                self.skip = true
+                self.skip = true;
             },
             _ => {},
         }
@@ -72,12 +72,12 @@ impl<'tcx> Delegate<'tcx> for MutVarsDelegate {
 
     fn borrow(&mut self, cmt: &PlaceWithHirId<'tcx>, _: HirId, bk: ty::BorrowKind) {
         if let ty::BorrowKind::MutBorrow = bk {
-            self.update(&cmt)
+            self.update(&cmt);
         }
     }
 
     fn mutate(&mut self, cmt: &PlaceWithHirId<'tcx>, _: HirId) {
-        self.update(&cmt)
+        self.update(&cmt);
     }
 }
 
diff --git a/clippy_lints/src/utils/visitors.rs b/clippy_lints/src/utils/visitors.rs
index ebf69df31ca..caaf636c897 100644
--- a/clippy_lints/src/utils/visitors.rs
+++ b/clippy_lints/src/utils/visitors.rs
@@ -87,7 +87,7 @@ where
         }
 
         fn visit_stmt(&mut self, stmt: &'hir hir::Stmt<'_>) {
-            intravisit::walk_stmt(&mut *self.inside_stmt(true), stmt)
+            intravisit::walk_stmt(&mut *self.inside_stmt(true), stmt);
         }
 
         fn visit_expr(&mut self, expr: &'hir hir::Expr<'_>) {
diff --git a/clippy_lints/src/verbose_file_reads.rs b/clippy_lints/src/verbose_file_reads.rs
index 32574d9d6c9..92965e95cda 100644
--- a/clippy_lints/src/verbose_file_reads.rs
+++ b/clippy_lints/src/verbose_file_reads.rs
@@ -52,7 +52,7 @@ impl<'tcx> LateLintPass<'tcx> for VerboseFileReads {
                 "use of `File::read_to_string`",
                 None,
                 "consider using `fs::read_to_string` instead",
-            )
+            );
         }
     }
 }
diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs
index e40fdca6a99..f9ccf322dda 100644
--- a/clippy_lints/src/write.rs
+++ b/clippy_lints/src/write.rs
@@ -298,7 +298,7 @@ impl EarlyLintPass for Write {
                                 Applicability::MachineApplicable,
                             );
                         },
-                    )
+                    );
                 }
             }
         } else if mac.path == sym!(writeln) {
diff --git a/tests/ui/semicolon_if_nothing_returned.rs b/tests/ui/semicolon_if_nothing_returned.rs
index 2c07cc9df40..0abe2cca267 100644
--- a/tests/ui/semicolon_if_nothing_returned.rs
+++ b/tests/ui/semicolon_if_nothing_returned.rs
@@ -46,3 +46,10 @@ fn foobar(x: i32) {
         y = x + 1;
     }
 }
+
+fn loop_test(x: i32) {
+    let y: i32;
+    for &ext in &["stdout", "stderr", "fixed"] {
+        println!("{}", ext);
+    }
+}
diff --git a/tests/ui/semicolon_if_nothing_returned.stderr b/tests/ui/semicolon_if_nothing_returned.stderr
index 6026320f4b4..2bc73342467 100644
--- a/tests/ui/semicolon_if_nothing_returned.stderr
+++ b/tests/ui/semicolon_if_nothing_returned.stderr
@@ -1,4 +1,4 @@
-error: add `;` to terminate block
+error: Consider adding a `;` to the last statement for consistent formatting
   --> $DIR/semicolon_if_nothing_returned.rs:8:5
    |
 LL |     println!("Hello")
@@ -7,17 +7,17 @@ LL |     println!("Hello")
    = note: `-D clippy::semicolon-if-nothing-returned` implied by `-D warnings`
    = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: add `;` to terminate block
+error: Consider adding a `;` to the last statement for consistent formatting
   --> $DIR/semicolon_if_nothing_returned.rs:12:5
    |
 LL |     get_unit()
-   |     ^^^^^^^^^^ help: add `;`: `get_unit();`
+   |     ^^^^^^^^^^ help: add a `;` here: `get_unit();`
 
-error: add `;` to terminate block
+error: Consider adding a `;` to the last statement for consistent formatting
   --> $DIR/semicolon_if_nothing_returned.rs:17:5
    |
 LL |     y = x + 1
-   |     ^^^^^^^^^ help: add `;`: `y = x + 1;`
+   |     ^^^^^^^^^ help: add a `;` here: `y = x + 1;`
 
 error: aborting due to 3 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From cd6748749a454e07a3f7f72c79bc62c2f5d6b9e4 Mon Sep 17 00:00:00 2001
From: Bastian Kersting <bastian@cmbt.de>
Date: Sat, 6 Feb 2021 16:44:57 +0100
Subject: Revert "Fixed for loop problem, corrected all occurences that got
 linted"

This reverts commit 6626295fbc747d04f1a8d14f19ee48c789b90e50.
---
 clippy_lints/src/assertions_on_constants.rs        |  2 +-
 clippy_lints/src/attrs.rs                          |  6 ++--
 clippy_lints/src/bit_mask.rs                       |  6 ++--
 clippy_lints/src/booleans.rs                       |  6 ++--
 clippy_lints/src/collapsible_if.rs                 |  2 +-
 clippy_lints/src/comparison_chain.rs               |  2 +-
 clippy_lints/src/eq_op.rs                          | 10 +++----
 clippy_lints/src/eta_reduction.rs                  |  2 +-
 clippy_lints/src/eval_order_dependence.rs          |  2 +-
 clippy_lints/src/functions.rs                      |  6 ++--
 clippy_lints/src/future_not_send.rs                |  2 +-
 clippy_lints/src/infinite_iter.rs                  |  2 +-
 clippy_lints/src/inherent_impl.rs                  |  4 +--
 clippy_lints/src/len_zero.rs                       |  4 +--
 clippy_lints/src/let_underscore.rs                 |  8 +++---
 clippy_lints/src/lifetimes.rs                      |  4 +--
 clippy_lints/src/literal_representation.rs         |  8 +++---
 clippy_lints/src/loops.rs                          | 22 +++++++--------
 clippy_lints/src/macro_use.rs                      |  6 ++--
 clippy_lints/src/manual_strip.rs                   |  2 +-
 clippy_lints/src/map_clone.rs                      |  6 ++--
 clippy_lints/src/matches.rs                        |  6 ++--
 clippy_lints/src/methods/bind_instead_of_map.rs    |  2 +-
 clippy_lints/src/methods/mod.rs                    | 20 +++++++-------
 clippy_lints/src/mut_reference.rs                  |  2 +-
 clippy_lints/src/mutable_debug_assertion.rs        |  2 +-
 clippy_lints/src/needless_arbitrary_self_type.rs   |  2 +-
 clippy_lints/src/needless_bool.rs                  | 18 ++++++------
 clippy_lints/src/neg_cmp_op_on_partial_ord.rs      |  2 +-
 clippy_lints/src/open_options.rs                   | 10 +++----
 clippy_lints/src/question_mark.rs                  |  2 +-
 clippy_lints/src/redundant_closure_call.rs         |  2 +-
 clippy_lints/src/redundant_pub_crate.rs            |  2 +-
 clippy_lints/src/returns.rs                        |  4 +--
 clippy_lints/src/semicolon_if_nothing_returned.rs  | 32 +++++++++++++---------
 clippy_lints/src/shadow.rs                         | 10 +++----
 clippy_lints/src/slow_vector_initialization.rs     |  2 +-
 clippy_lints/src/suspicious_operation_groupings.rs |  6 ++--
 clippy_lints/src/transmute.rs                      |  6 ++--
 clippy_lints/src/types.rs                          |  6 ++--
 clippy_lints/src/unicode.rs                        |  4 +--
 clippy_lints/src/unused_self.rs                    |  2 +-
 clippy_lints/src/upper_case_acronyms.rs            |  2 +-
 clippy_lints/src/use_self.rs                       |  2 +-
 clippy_lints/src/utils/attrs.rs                    |  2 +-
 clippy_lints/src/utils/author.rs                   |  2 +-
 clippy_lints/src/utils/diagnostics.rs              |  2 +-
 clippy_lints/src/utils/mod.rs                      |  2 +-
 clippy_lints/src/utils/sugg.rs                     |  2 +-
 clippy_lints/src/utils/usage.rs                    |  6 ++--
 clippy_lints/src/utils/visitors.rs                 |  2 +-
 clippy_lints/src/verbose_file_reads.rs             |  2 +-
 clippy_lints/src/write.rs                          |  2 +-
 tests/ui/semicolon_if_nothing_returned.rs          |  7 -----
 tests/ui/semicolon_if_nothing_returned.stderr      | 10 +++----
 55 files changed, 148 insertions(+), 149 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/assertions_on_constants.rs b/clippy_lints/src/assertions_on_constants.rs
index b9de4780173..aa431f0596c 100644
--- a/clippy_lints/src/assertions_on_constants.rs
+++ b/clippy_lints/src/assertions_on_constants.rs
@@ -61,7 +61,7 @@ impl<'tcx> LateLintPass<'tcx> for AssertionsOnConstants {
                 &format!("`assert!(false, {})` should probably be replaced", panic_message),
                 None,
                 &format!("use `panic!({})` or `unreachable!({})`", panic_message, panic_message),
-            );
+            )
         };
 
         if let Some(debug_assert_span) = is_expn_of(e.span, "debug_assert") {
diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs
index 90463d7f026..652d1fa16b6 100644
--- a/clippy_lints/src/attrs.rs
+++ b/clippy_lints/src/attrs.rs
@@ -277,7 +277,7 @@ impl<'tcx> LateLintPass<'tcx> for Attributes {
 
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
         if is_relevant_item(cx, item) {
-            check_attrs(cx, item.span, item.ident.name, &item.attrs);
+            check_attrs(cx, item.span, item.ident.name, &item.attrs)
         }
         match item.kind {
             ItemKind::ExternCrate(..) | ItemKind::Use(..) => {
@@ -353,13 +353,13 @@ impl<'tcx> LateLintPass<'tcx> for Attributes {
 
     fn check_impl_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx ImplItem<'_>) {
         if is_relevant_impl(cx, item) {
-            check_attrs(cx, item.span, item.ident.name, &item.attrs);
+            check_attrs(cx, item.span, item.ident.name, &item.attrs)
         }
     }
 
     fn check_trait_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx TraitItem<'_>) {
         if is_relevant_trait(cx, item) {
-            check_attrs(cx, item.span, item.ident.name, &item.attrs);
+            check_attrs(cx, item.span, item.ident.name, &item.attrs)
         }
     }
 }
diff --git a/clippy_lints/src/bit_mask.rs b/clippy_lints/src/bit_mask.rs
index 8d9fbcf4fd1..a4ee54076ee 100644
--- a/clippy_lints/src/bit_mask.rs
+++ b/clippy_lints/src/bit_mask.rs
@@ -115,9 +115,9 @@ impl<'tcx> LateLintPass<'tcx> for BitMask {
         if let ExprKind::Binary(cmp, left, right) = &e.kind {
             if cmp.node.is_comparison() {
                 if let Some(cmp_opt) = fetch_int_literal(cx, right) {
-                    check_compare(cx, left, cmp.node, cmp_opt, e.span);
+                    check_compare(cx, left, cmp.node, cmp_opt, e.span)
                 } else if let Some(cmp_val) = fetch_int_literal(cx, left) {
-                    check_compare(cx, right, invert_cmp(cmp.node), cmp_val, e.span);
+                    check_compare(cx, right, invert_cmp(cmp.node), cmp_val, e.span)
                 }
             }
         }
@@ -171,7 +171,7 @@ fn check_compare(cx: &LateContext<'_>, bit_op: &Expr<'_>, cmp_op: BinOpKind, cmp
         }
         fetch_int_literal(cx, right)
             .or_else(|| fetch_int_literal(cx, left))
-            .map_or((), |mask| check_bit_mask(cx, op.node, cmp_op, mask, cmp_value, span));
+            .map_or((), |mask| check_bit_mask(cx, op.node, cmp_op, mask, cmp_value, span))
     }
 }
 
diff --git a/clippy_lints/src/booleans.rs b/clippy_lints/src/booleans.rs
index 75f011a7fa0..90bb0bd555f 100644
--- a/clippy_lints/src/booleans.rs
+++ b/clippy_lints/src/booleans.rs
@@ -66,7 +66,7 @@ impl<'tcx> LateLintPass<'tcx> for NonminimalBool {
         _: Span,
         _: HirId,
     ) {
-        NonminimalBoolVisitor { cx }.visit_body(body);
+        NonminimalBoolVisitor { cx }.visit_body(body)
     }
 }
 
@@ -184,7 +184,7 @@ impl<'a, 'tcx, 'v> SuggestContext<'a, 'tcx, 'v> {
                 Term(n) => {
                     let terminal = self.terminals[n as usize];
                     if let Some(str) = simplify_not(self.cx, terminal) {
-                        self.output.push_str(&str);
+                        self.output.push_str(&str)
                     } else {
                         self.output.push('!');
                         let snip = snippet_opt(self.cx, terminal.span)?;
@@ -452,7 +452,7 @@ impl<'a, 'tcx> Visitor<'tcx> for NonminimalBoolVisitor<'a, 'tcx> {
         }
         match &e.kind {
             ExprKind::Binary(binop, _, _) if binop.node == BinOpKind::Or || binop.node == BinOpKind::And => {
-                self.bool_expr(e);
+                self.bool_expr(e)
             },
             ExprKind::Unary(UnOp::UnNot, inner) => {
                 if self.cx.typeck_results().node_types()[inner.hir_id].is_bool() {
diff --git a/clippy_lints/src/collapsible_if.rs b/clippy_lints/src/collapsible_if.rs
index 4e7a6250add..93ccc76d0c9 100644
--- a/clippy_lints/src/collapsible_if.rs
+++ b/clippy_lints/src/collapsible_if.rs
@@ -92,7 +92,7 @@ declare_lint_pass!(CollapsibleIf => [COLLAPSIBLE_IF, COLLAPSIBLE_ELSE_IF]);
 impl EarlyLintPass for CollapsibleIf {
     fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &ast::Expr) {
         if !expr.span.from_expansion() {
-            check_if(cx, expr);
+            check_if(cx, expr)
         }
     }
 }
diff --git a/clippy_lints/src/comparison_chain.rs b/clippy_lints/src/comparison_chain.rs
index 59b1c806e23..90d31dece13 100644
--- a/clippy_lints/src/comparison_chain.rs
+++ b/clippy_lints/src/comparison_chain.rs
@@ -118,7 +118,7 @@ impl<'tcx> LateLintPass<'tcx> for ComparisonChain {
             "`if` chain can be rewritten with `match`",
             None,
             "Consider rewriting the `if` chain to use `cmp` and `match`.",
-        );
+        )
     }
 }
 
diff --git a/clippy_lints/src/eq_op.rs b/clippy_lints/src/eq_op.rs
index e2881315b56..6308f6e2e7e 100644
--- a/clippy_lints/src/eq_op.rs
+++ b/clippy_lints/src/eq_op.rs
@@ -156,7 +156,7 @@ impl<'tcx> LateLintPass<'tcx> for EqOp {
                                         vec![(left.span, lsnip), (right.span, rsnip)],
                                     );
                                 },
-                            );
+                            )
                         } else if lcpy
                             && !rcpy
                             && implements_trait(cx, lty, trait_id, &[cx.typeck_results().expr_ty(right).into()])
@@ -175,7 +175,7 @@ impl<'tcx> LateLintPass<'tcx> for EqOp {
                                         Applicability::MaybeIncorrect, // FIXME #2597
                                     );
                                 },
-                            );
+                            )
                         } else if !lcpy
                             && rcpy
                             && implements_trait(cx, cx.typeck_results().expr_ty(left), trait_id, &[rty.into()])
@@ -194,7 +194,7 @@ impl<'tcx> LateLintPass<'tcx> for EqOp {
                                         Applicability::MaybeIncorrect, // FIXME #2597
                                     );
                                 },
-                            );
+                            )
                         }
                     },
                     // &foo == bar
@@ -218,7 +218,7 @@ impl<'tcx> LateLintPass<'tcx> for EqOp {
                                         Applicability::MaybeIncorrect, // FIXME #2597
                                     );
                                 },
-                            );
+                            )
                         }
                     },
                     // foo == &bar
@@ -236,7 +236,7 @@ impl<'tcx> LateLintPass<'tcx> for EqOp {
                                     rsnip,
                                     Applicability::MaybeIncorrect, // FIXME #2597
                                 );
-                            });
+                            })
                         }
                     },
                     _ => {},
diff --git a/clippy_lints/src/eta_reduction.rs b/clippy_lints/src/eta_reduction.rs
index 91f9df4649b..1a722d39f73 100644
--- a/clippy_lints/src/eta_reduction.rs
+++ b/clippy_lints/src/eta_reduction.rs
@@ -74,7 +74,7 @@ impl<'tcx> LateLintPass<'tcx> for EtaReduction {
         match expr.kind {
             ExprKind::Call(_, args) | ExprKind::MethodCall(_, _, args, _) => {
                 for arg in args {
-                    check_closure(cx, arg);
+                    check_closure(cx, arg)
                 }
             },
             _ => (),
diff --git a/clippy_lints/src/eval_order_dependence.rs b/clippy_lints/src/eval_order_dependence.rs
index 8df14d80026..bc2b2904698 100644
--- a/clippy_lints/src/eval_order_dependence.rs
+++ b/clippy_lints/src/eval_order_dependence.rs
@@ -116,7 +116,7 @@ impl<'a, 'tcx> DivergenceVisitor<'a, 'tcx> {
                 self.visit_expr(e);
                 for arm in arms {
                     if let Some(Guard::If(if_expr)) = arm.guard {
-                        self.visit_expr(if_expr);
+                        self.visit_expr(if_expr)
                     }
                     // make sure top level arm expressions aren't linted
                     self.maybe_walk_expr(&*arm.body);
diff --git a/clippy_lints/src/functions.rs b/clippy_lints/src/functions.rs
index 45973c8b0f7..87954254610 100644
--- a/clippy_lints/src/functions.rs
+++ b/clippy_lints/src/functions.rs
@@ -270,7 +270,7 @@ impl<'tcx> LateLintPass<'tcx> for Functions {
                     _,
                 )
                 | intravisit::FnKind::ItemFn(_, _, hir::FnHeader { abi: Abi::Rust, .. }, _, _) => {
-                    self.check_arg_number(cx, decl, span.with_hi(decl.output.span().hi()));
+                    self.check_arg_number(cx, decl, span.with_hi(decl.output.span().hi()))
                 },
                 _ => {},
             }
@@ -434,7 +434,7 @@ impl<'tcx> Functions {
                 TOO_MANY_LINES,
                 span,
                 &format!("this function has too many lines ({}/{})", line_count, self.max_lines),
-            );
+            )
         }
     }
 
@@ -707,7 +707,7 @@ impl<'a, 'tcx> intravisit::Visitor<'tcx> for StaticMutVisitor<'a, 'tcx> {
                 }
             },
             Assign(ref target, ..) | AssignOp(_, ref target, _) | AddrOf(_, hir::Mutability::Mut, ref target) => {
-                self.mutates_static |= is_mutated_static(self.cx, target);
+                self.mutates_static |= is_mutated_static(self.cx, target)
             },
             _ => {},
         }
diff --git a/clippy_lints/src/future_not_send.rs b/clippy_lints/src/future_not_send.rs
index 55bdda7138e..7208e66ff7b 100644
--- a/clippy_lints/src/future_not_send.rs
+++ b/clippy_lints/src/future_not_send.rs
@@ -101,7 +101,7 @@ impl<'tcx> LateLintPass<'tcx> for FutureNotSend {
                                         ));
                                     }
                                 }
-                            });
+                            })
                         },
                     );
                 }
diff --git a/clippy_lints/src/infinite_iter.rs b/clippy_lints/src/infinite_iter.rs
index dd0a3d1610b..129abd7d897 100644
--- a/clippy_lints/src/infinite_iter.rs
+++ b/clippy_lints/src/infinite_iter.rs
@@ -53,7 +53,7 @@ impl<'tcx> LateLintPass<'tcx> for InfiniteIter {
                 return;
             },
         };
-        span_lint(cx, lint, expr.span, msg);
+        span_lint(cx, lint, expr.span, msg)
     }
 }
 
diff --git a/clippy_lints/src/inherent_impl.rs b/clippy_lints/src/inherent_impl.rs
index 2c5e6f11216..ea26c84cde1 100644
--- a/clippy_lints/src/inherent_impl.rs
+++ b/clippy_lints/src/inherent_impl.rs
@@ -85,8 +85,8 @@ impl<'tcx> LateLintPass<'tcx> for MultipleInherentImpl {
                             |diag| {
                                 diag.span_note(*initial_span, "first implementation here");
                             },
-                        );
-                    });
+                        )
+                    })
                 }
             }
         }
diff --git a/clippy_lints/src/len_zero.rs b/clippy_lints/src/len_zero.rs
index 599602c4a0b..e95caf6a35f 100644
--- a/clippy_lints/src/len_zero.rs
+++ b/clippy_lints/src/len_zero.rs
@@ -256,9 +256,9 @@ fn check_cmp(cx: &LateContext<'_>, span: Span, method: &Expr<'_>, lit: &Expr<'_>
             }
         }
 
-        check_len(cx, span, method_path.ident.name, args, &lit.node, op, compare_to);
+        check_len(cx, span, method_path.ident.name, args, &lit.node, op, compare_to)
     } else {
-        check_empty_expr(cx, span, method, lit, op);
+        check_empty_expr(cx, span, method, lit, op)
     }
 }
 
diff --git a/clippy_lints/src/let_underscore.rs b/clippy_lints/src/let_underscore.rs
index 33621775742..6a5a77f8690 100644
--- a/clippy_lints/src/let_underscore.rs
+++ b/clippy_lints/src/let_underscore.rs
@@ -143,7 +143,7 @@ impl<'tcx> LateLintPass<'tcx> for LetUnderscore {
                         None,
                         "consider using an underscore-prefixed named \
                             binding or dropping explicitly with `std::mem::drop`"
-                    );
+                    )
                 } else if implements_drop {
                     span_lint_and_help(
                         cx,
@@ -153,7 +153,7 @@ impl<'tcx> LateLintPass<'tcx> for LetUnderscore {
                         None,
                         "consider using an underscore-prefixed named \
                             binding or dropping explicitly with `std::mem::drop`"
-                    );
+                    )
                 } else if is_must_use_ty(cx, cx.typeck_results().expr_ty(init)) {
                     span_lint_and_help(
                         cx,
@@ -162,7 +162,7 @@ impl<'tcx> LateLintPass<'tcx> for LetUnderscore {
                         "non-binding let on an expression with `#[must_use]` type",
                         None,
                         "consider explicitly using expression value"
-                    );
+                    )
                 } else if is_must_use_func_call(cx, init) {
                     span_lint_and_help(
                         cx,
@@ -171,7 +171,7 @@ impl<'tcx> LateLintPass<'tcx> for LetUnderscore {
                         "non-binding let on a result of a `#[must_use]` function",
                         None,
                         "consider explicitly using function result"
-                    );
+                    )
                 }
             }
         }
diff --git a/clippy_lints/src/lifetimes.rs b/clippy_lints/src/lifetimes.rs
index 740f207b214..e84c8b4e5b3 100644
--- a/clippy_lints/src/lifetimes.rs
+++ b/clippy_lints/src/lifetimes.rs
@@ -205,7 +205,7 @@ fn could_use_elision<'tcx>(
         output_visitor.visit_ty(ty);
     }
     for lt in named_generics {
-        input_visitor.visit_generic_param(lt);
+        input_visitor.visit_generic_param(lt)
     }
 
     if input_visitor.abort() || output_visitor.abort() {
@@ -460,7 +460,7 @@ impl<'tcx> Visitor<'tcx> for LifetimeChecker {
         // `'b` in `'a: 'b` is useless unless used elsewhere in
         // a non-lifetime bound
         if let GenericParamKind::Type { .. } = param.kind {
-            walk_generic_param(self, param);
+            walk_generic_param(self, param)
         }
     }
     fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
diff --git a/clippy_lints/src/literal_representation.rs b/clippy_lints/src/literal_representation.rs
index 7b75ab89bb8..87a957a9bd2 100644
--- a/clippy_lints/src/literal_representation.rs
+++ b/clippy_lints/src/literal_representation.rs
@@ -229,7 +229,7 @@ impl EarlyLintPass for LiteralDigitGrouping {
         }
 
         if let ExprKind::Lit(ref lit) = expr.kind {
-            self.check_lit(cx, lit);
+            self.check_lit(cx, lit)
         }
     }
 }
@@ -292,7 +292,7 @@ impl LiteralDigitGrouping {
                         }
                     };
                     if should_warn {
-                        warning_type.display(num_lit.format(), cx, lit.span);
+                        warning_type.display(num_lit.format(), cx, lit.span)
                     }
                 }
             }
@@ -422,7 +422,7 @@ impl EarlyLintPass for DecimalLiteralRepresentation {
         }
 
         if let ExprKind::Lit(ref lit) = expr.kind {
-            self.check_lit(cx, lit);
+            self.check_lit(cx, lit)
         }
     }
 }
@@ -444,7 +444,7 @@ impl DecimalLiteralRepresentation {
                 let hex = format!("{:#X}", val);
                 let num_lit = NumericLiteral::new(&hex, num_lit.suffix, false);
                 let _ = Self::do_lint(num_lit.integer).map_err(|warning_type| {
-                    warning_type.display(num_lit.format(), cx, lit.span);
+                    warning_type.display(num_lit.format(), cx, lit.span)
                 });
             }
         }
diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index c7e0d32ca27..663c2df23e2 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -1426,7 +1426,7 @@ fn detect_same_item_push<'tcx>(
                 "try using vec![{};SIZE] or {}.resize(NEW_SIZE, {})",
                 item_str, vec_str, item_str
             ),
-        );
+        )
     }
 
     if !matches!(pat.kind, PatKind::Wild) {
@@ -1714,7 +1714,7 @@ fn lint_iter_method(cx: &LateContext<'_>, args: &[Expr<'_>], arg: &Expr<'_>, met
         "to write this more concisely, try",
         format!("&{}{}", muta, object),
         applicability,
-    );
+    )
 }
 
 fn check_for_loop_arg(cx: &LateContext<'_>, pat: &Pat<'_>, arg: &Expr<'_>, expr: &Expr<'_>) {
@@ -1753,7 +1753,7 @@ fn check_for_loop_arg(cx: &LateContext<'_>, pat: &Pat<'_>, arg: &Expr<'_>, expr:
                         },
                     );
                     if TyS::same_type(receiver_ty_adjusted, ref_receiver_ty) {
-                        lint_iter_method(cx, args, arg, method_name);
+                        lint_iter_method(cx, args, arg, method_name)
                     }
                 }
             } else if method_name == "next" && match_trait_method(cx, arg, &paths::ITERATOR) {
@@ -2075,10 +2075,10 @@ impl<'tcx> Delegate<'tcx> for MutatePairDelegate<'_, 'tcx> {
         if let ty::BorrowKind::MutBorrow = bk {
             if let PlaceBase::Local(id) = cmt.place.base {
                 if Some(id) == self.hir_id_low {
-                    self.span_low = Some(self.cx.tcx.hir().span(diag_expr_id));
+                    self.span_low = Some(self.cx.tcx.hir().span(diag_expr_id))
                 }
                 if Some(id) == self.hir_id_high {
-                    self.span_high = Some(self.cx.tcx.hir().span(diag_expr_id));
+                    self.span_high = Some(self.cx.tcx.hir().span(diag_expr_id))
                 }
             }
         }
@@ -2087,10 +2087,10 @@ impl<'tcx> Delegate<'tcx> for MutatePairDelegate<'_, 'tcx> {
     fn mutate(&mut self, cmt: &PlaceWithHirId<'tcx>, diag_expr_id: HirId) {
         if let PlaceBase::Local(id) = cmt.place.base {
             if Some(id) == self.hir_id_low {
-                self.span_low = Some(self.cx.tcx.hir().span(diag_expr_id));
+                self.span_low = Some(self.cx.tcx.hir().span(diag_expr_id))
             }
             if Some(id) == self.hir_id_high {
-                self.span_high = Some(self.cx.tcx.hir().span(diag_expr_id));
+                self.span_high = Some(self.cx.tcx.hir().span(diag_expr_id))
             }
         }
     }
@@ -2543,10 +2543,10 @@ impl<'a, 'tcx> Visitor<'tcx> for IncrementVisitor<'a, 'tcx> {
                         }
                     },
                     ExprKind::Assign(ref lhs, _, _) if lhs.hir_id == expr.hir_id => {
-                        *state = IncrementVisitorVarState::DontWarn;
+                        *state = IncrementVisitorVarState::DontWarn
                     },
                     ExprKind::AddrOf(BorrowKind::Ref, mutability, _) if mutability == Mutability::Mut => {
-                        *state = IncrementVisitorVarState::DontWarn;
+                        *state = IncrementVisitorVarState::DontWarn
                     },
                     _ => (),
                 }
@@ -2670,7 +2670,7 @@ impl<'a, 'tcx> Visitor<'tcx> for InitializeVisitor<'a, 'tcx> {
                         }
                     },
                     ExprKind::AddrOf(BorrowKind::Ref, mutability, _) if mutability == Mutability::Mut => {
-                        self.state = InitializeVisitorState::DontWarn;
+                        self.state = InitializeVisitorState::DontWarn
                     },
                     _ => (),
                 }
@@ -2815,7 +2815,7 @@ impl<'tcx> Visitor<'tcx> for LoopNestVisitor {
                 return;
             }
         }
-        walk_pat(self, pat);
+        walk_pat(self, pat)
     }
 
     fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
diff --git a/clippy_lints/src/macro_use.rs b/clippy_lints/src/macro_use.rs
index f4ffe189940..bb52888883a 100644
--- a/clippy_lints/src/macro_use.rs
+++ b/clippy_lints/src/macro_use.rs
@@ -206,9 +206,9 @@ impl<'tcx> LateLintPass<'tcx> for MacroUseImports {
         let mut suggestions = vec![];
         for ((root, span), path) in used {
             if path.len() == 1 {
-                suggestions.push((span, format!("{}::{}", root, path[0])));
+                suggestions.push((span, format!("{}::{}", root, path[0])))
             } else {
-                suggestions.push((span, format!("{}::{{{}}}", root, path.join(", "))));
+                suggestions.push((span, format!("{}::{{{}}}", root, path.join(", "))))
             }
         }
 
@@ -225,7 +225,7 @@ impl<'tcx> LateLintPass<'tcx> for MacroUseImports {
                     "remove the attribute and import the macro directly, try",
                     help,
                     Applicability::MaybeIncorrect,
-                );
+                )
             }
         }
     }
diff --git a/clippy_lints/src/manual_strip.rs b/clippy_lints/src/manual_strip.rs
index 11d101c5025..42a92104a49 100644
--- a/clippy_lints/src/manual_strip.rs
+++ b/clippy_lints/src/manual_strip.rs
@@ -126,7 +126,7 @@ impl<'tcx> LateLintPass<'tcx> for ManualStrip {
                                           kind_word,
                                           snippet(cx, pattern.span, "..")))]
                             .into_iter().chain(strippings.into_iter().map(|span| (span, "<stripped>".into()))),
-                        );
+                        )
                     });
                 }
             }
diff --git a/clippy_lints/src/map_clone.rs b/clippy_lints/src/map_clone.rs
index b3be755d488..1818836d5d5 100644
--- a/clippy_lints/src/map_clone.rs
+++ b/clippy_lints/src/map_clone.rs
@@ -122,7 +122,7 @@ fn lint_needless_cloning(cx: &LateContext<'_>, root: Span, receiver: Span) {
         "remove the `map` call",
         String::new(),
         Applicability::MachineApplicable,
-    );
+    )
 }
 
 fn lint(cx: &LateContext<'_>, replace: Span, root: Span, copied: bool) {
@@ -139,7 +139,7 @@ fn lint(cx: &LateContext<'_>, replace: Span, root: Span, copied: bool) {
                 snippet_with_applicability(cx, root, "..", &mut applicability)
             ),
             applicability,
-        );
+        )
     } else {
         span_lint_and_sugg(
             cx,
@@ -152,6 +152,6 @@ fn lint(cx: &LateContext<'_>, replace: Span, root: Span, copied: bool) {
                 snippet_with_applicability(cx, root, "..", &mut applicability)
             ),
             applicability,
-        );
+        )
     }
 }
diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index 74d36777779..ba7b9bd0424 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -1046,7 +1046,7 @@ fn check_wild_enum_match(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>])
                 "try this",
                 suggestion[0].clone(),
                 Applicability::MaybeIncorrect,
-            );
+            )
         };
 
         span_lint_and_sugg(
@@ -1057,7 +1057,7 @@ fn check_wild_enum_match(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>])
             "try this",
             suggestion.join(" | "),
             Applicability::MaybeIncorrect,
-        );
+        )
     }
 }
 
@@ -1156,7 +1156,7 @@ fn check_match_as_ref(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>], exp
                     cast,
                 ),
                 applicability,
-            );
+            )
         }
     }
 }
diff --git a/clippy_lints/src/methods/bind_instead_of_map.rs b/clippy_lints/src/methods/bind_instead_of_map.rs
index 897a3194ca1..540a1484a85 100644
--- a/clippy_lints/src/methods/bind_instead_of_map.rs
+++ b/clippy_lints/src/methods/bind_instead_of_map.rs
@@ -151,7 +151,7 @@ pub(crate) trait BindInsteadOfMap {
                             .into_iter()
                             .map(|(span1, span2)| (span1, snippet(cx, span2, "_").into())),
                     ),
-                );
+                )
             });
         }
         can_sugg
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index e02b6403819..a17c5996293 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1582,10 +1582,10 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             ["flatten", "map"] => lint_map_flatten(cx, expr, arg_lists[1]),
             ["is_some", "find"] => lint_search_is_some(cx, expr, "find", arg_lists[1], arg_lists[0], method_spans[1]),
             ["is_some", "position"] => {
-                lint_search_is_some(cx, expr, "position", arg_lists[1], arg_lists[0], method_spans[1]);
+                lint_search_is_some(cx, expr, "position", arg_lists[1], arg_lists[0], method_spans[1])
             },
             ["is_some", "rposition"] => {
-                lint_search_is_some(cx, expr, "rposition", arg_lists[1], arg_lists[0], method_spans[1]);
+                lint_search_is_some(cx, expr, "rposition", arg_lists[1], arg_lists[0], method_spans[1])
             },
             ["extend", ..] => lint_extend(cx, expr, arg_lists[0]),
             ["nth", "iter"] => lint_iter_nth(cx, expr, &arg_lists, false),
@@ -1601,17 +1601,17 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             ["count", "map"] => lint_suspicious_map(cx, expr),
             ["assume_init"] => lint_maybe_uninit(cx, &arg_lists[0][0], expr),
             ["unwrap_or", arith @ ("checked_add" | "checked_sub" | "checked_mul")] => {
-                manual_saturating_arithmetic::lint(cx, expr, &arg_lists, &arith["checked_".len()..]);
+                manual_saturating_arithmetic::lint(cx, expr, &arg_lists, &arith["checked_".len()..])
             },
             ["add" | "offset" | "sub" | "wrapping_offset" | "wrapping_add" | "wrapping_sub"] => {
-                check_pointer_offset(cx, expr, arg_lists[0]);
+                check_pointer_offset(cx, expr, arg_lists[0])
             },
             ["is_file", ..] => lint_filetype_is_file(cx, expr, arg_lists[0]),
             ["map", "as_ref"] => {
-                lint_option_as_ref_deref(cx, expr, arg_lists[1], arg_lists[0], false, self.msrv.as_ref());
+                lint_option_as_ref_deref(cx, expr, arg_lists[1], arg_lists[0], false, self.msrv.as_ref())
             },
             ["map", "as_mut"] => {
-                lint_option_as_ref_deref(cx, expr, arg_lists[1], arg_lists[0], true, self.msrv.as_ref());
+                lint_option_as_ref_deref(cx, expr, arg_lists[1], arg_lists[0], true, self.msrv.as_ref())
             },
             ["unwrap_or_else", ..] => unnecessary_lazy_eval::lint(cx, expr, arg_lists[0], "unwrap_or"),
             ["get_or_insert_with", ..] => unnecessary_lazy_eval::lint(cx, expr, arg_lists[0], "get_or_insert"),
@@ -2446,16 +2446,16 @@ fn lint_unnecessary_fold(cx: &LateContext<'_>, expr: &hir::Expr<'_>, fold_args:
     if let hir::ExprKind::Lit(ref lit) = fold_args[1].kind {
         match lit.node {
             ast::LitKind::Bool(false) => {
-                check_fold_with_op(cx, expr, fold_args, fold_span, hir::BinOpKind::Or, "any", true);
+                check_fold_with_op(cx, expr, fold_args, fold_span, hir::BinOpKind::Or, "any", true)
             },
             ast::LitKind::Bool(true) => {
-                check_fold_with_op(cx, expr, fold_args, fold_span, hir::BinOpKind::And, "all", true);
+                check_fold_with_op(cx, expr, fold_args, fold_span, hir::BinOpKind::And, "all", true)
             },
             ast::LitKind::Int(0, _) => {
-                check_fold_with_op(cx, expr, fold_args, fold_span, hir::BinOpKind::Add, "sum", false);
+                check_fold_with_op(cx, expr, fold_args, fold_span, hir::BinOpKind::Add, "sum", false)
             },
             ast::LitKind::Int(1, _) => {
-                check_fold_with_op(cx, expr, fold_args, fold_span, hir::BinOpKind::Mul, "product", false);
+                check_fold_with_op(cx, expr, fold_args, fold_span, hir::BinOpKind::Mul, "product", false)
             },
             _ => (),
         }
diff --git a/clippy_lints/src/mut_reference.rs b/clippy_lints/src/mut_reference.rs
index 7c21632c9d5..3f0b765df15 100644
--- a/clippy_lints/src/mut_reference.rs
+++ b/clippy_lints/src/mut_reference.rs
@@ -47,7 +47,7 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryMutPassed {
                 let def_id = cx.typeck_results().type_dependent_def_id(e.hir_id).unwrap();
                 let substs = cx.typeck_results().node_substs(e.hir_id);
                 let method_type = cx.tcx.type_of(def_id).subst(cx.tcx, substs);
-                check_arguments(cx, arguments, method_type, &path.ident.as_str(), "method");
+                check_arguments(cx, arguments, method_type, &path.ident.as_str(), "method")
             },
             _ => (),
         }
diff --git a/clippy_lints/src/mutable_debug_assertion.rs b/clippy_lints/src/mutable_debug_assertion.rs
index b99e9576f5e..76417aa7ed0 100644
--- a/clippy_lints/src/mutable_debug_assertion.rs
+++ b/clippy_lints/src/mutable_debug_assertion.rs
@@ -106,7 +106,7 @@ impl<'a, 'tcx> Visitor<'tcx> for MutArgVisitor<'a, 'tcx> {
             _ if !self.found => self.expr_span = Some(expr.span),
             _ => return,
         }
-        walk_expr(self, expr);
+        walk_expr(self, expr)
     }
 
     fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
diff --git a/clippy_lints/src/needless_arbitrary_self_type.rs b/clippy_lints/src/needless_arbitrary_self_type.rs
index 107d6a57966..7687962bdd9 100644
--- a/clippy_lints/src/needless_arbitrary_self_type.rs
+++ b/clippy_lints/src/needless_arbitrary_self_type.rs
@@ -120,7 +120,7 @@ impl EarlyLintPass for NeedlessArbitrarySelfType {
         match &p.ty.kind {
             TyKind::Path(None, path) => {
                 if let PatKind::Ident(BindingMode::ByValue(mutbl), _, _) = p.pat.kind {
-                    check_param_inner(cx, path, p.span.to(p.ty.span), &Mode::Value, mutbl);
+                    check_param_inner(cx, path, p.span.to(p.ty.span), &Mode::Value, mutbl)
                 }
             },
             TyKind::Rptr(lifetime, mut_ty) => {
diff --git a/clippy_lints/src/needless_bool.rs b/clippy_lints/src/needless_bool.rs
index 614a1e8980c..d795f126457 100644
--- a/clippy_lints/src/needless_bool.rs
+++ b/clippy_lints/src/needless_bool.rs
@@ -80,7 +80,7 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessBool {
                 }
 
                 if parent_node_is_if_expr(&e, &cx) {
-                    snip = snip.blockify();
+                    snip = snip.blockify()
                 }
 
                 span_lint_and_sugg(
@@ -142,7 +142,7 @@ impl<'tcx> LateLintPass<'tcx> for BoolComparison {
                         |h: Sugg<'_>| !h,
                         "equality checks against false can be replaced by a negation",
                     ));
-                    check_comparison(cx, e, true_case, false_case, true_case, false_case, ignore_no_literal);
+                    check_comparison(cx, e, true_case, false_case, true_case, false_case, ignore_no_literal)
                 },
                 BinOpKind::Ne => {
                     let true_case = Some((
@@ -150,7 +150,7 @@ impl<'tcx> LateLintPass<'tcx> for BoolComparison {
                         "inequality checks against true can be replaced by a negation",
                     ));
                     let false_case = Some((|h| h, "inequality checks against false are unnecessary"));
-                    check_comparison(cx, e, true_case, false_case, true_case, false_case, ignore_no_literal);
+                    check_comparison(cx, e, true_case, false_case, true_case, false_case, ignore_no_literal)
                 },
                 BinOpKind::Lt => check_comparison(
                     cx,
@@ -249,22 +249,22 @@ fn check_comparison<'a, 'tcx>(
                             snippet_with_applicability(cx, expression_info.right_span, "..", &mut applicability)
                         ),
                         applicability,
-                    );
+                    )
                 }
             }
 
             match (fetch_bool_expr(left_side), fetch_bool_expr(right_side)) {
                 (Bool(true), Other) => left_true.map_or((), |(h, m)| {
-                    suggest_bool_comparison(cx, e, right_side, applicability, m, h);
+                    suggest_bool_comparison(cx, e, right_side, applicability, m, h)
                 }),
                 (Other, Bool(true)) => right_true.map_or((), |(h, m)| {
-                    suggest_bool_comparison(cx, e, left_side, applicability, m, h);
+                    suggest_bool_comparison(cx, e, left_side, applicability, m, h)
                 }),
                 (Bool(false), Other) => left_false.map_or((), |(h, m)| {
-                    suggest_bool_comparison(cx, e, right_side, applicability, m, h);
+                    suggest_bool_comparison(cx, e, right_side, applicability, m, h)
                 }),
                 (Other, Bool(false)) => right_false.map_or((), |(h, m)| {
-                    suggest_bool_comparison(cx, e, left_side, applicability, m, h);
+                    suggest_bool_comparison(cx, e, left_side, applicability, m, h)
                 }),
                 (Other, Other) => no_literal.map_or((), |(h, m)| {
                     let left_side = Sugg::hir_with_applicability(cx, left_side, "..", &mut applicability);
@@ -277,7 +277,7 @@ fn check_comparison<'a, 'tcx>(
                         "try simplifying it as shown",
                         h(left_side, right_side).to_string(),
                         applicability,
-                    );
+                    )
                 }),
                 _ => (),
             }
diff --git a/clippy_lints/src/neg_cmp_op_on_partial_ord.rs b/clippy_lints/src/neg_cmp_op_on_partial_ord.rs
index 6a20d5f139a..4fb899125e8 100644
--- a/clippy_lints/src/neg_cmp_op_on_partial_ord.rs
+++ b/clippy_lints/src/neg_cmp_op_on_partial_ord.rs
@@ -83,7 +83,7 @@ impl<'tcx> LateLintPass<'tcx> for NoNegCompOpForPartialOrd {
                         types produces code that is hard to read and refactor, please \
                         consider using the `partial_cmp` method instead, to make it \
                         clear that the two values could be incomparable"
-                    );
+                    )
                 }
             }
         }
diff --git a/clippy_lints/src/open_options.rs b/clippy_lints/src/open_options.rs
index 82143f7a288..73a99a3a2f8 100644
--- a/clippy_lints/src/open_options.rs
+++ b/clippy_lints/src/open_options.rs
@@ -125,7 +125,7 @@ fn check_open_options(cx: &LateContext<'_>, options: &[(OpenOption, Argument)],
                         "the method `create` is called more than once",
                     );
                 } else {
-                    create = true;
+                    create = true
                 }
                 create_arg = create_arg || (arg == Argument::True);
             },
@@ -138,7 +138,7 @@ fn check_open_options(cx: &LateContext<'_>, options: &[(OpenOption, Argument)],
                         "the method `append` is called more than once",
                     );
                 } else {
-                    append = true;
+                    append = true
                 }
                 append_arg = append_arg || (arg == Argument::True);
             },
@@ -151,7 +151,7 @@ fn check_open_options(cx: &LateContext<'_>, options: &[(OpenOption, Argument)],
                         "the method `truncate` is called more than once",
                     );
                 } else {
-                    truncate = true;
+                    truncate = true
                 }
                 truncate_arg = truncate_arg || (arg == Argument::True);
             },
@@ -164,7 +164,7 @@ fn check_open_options(cx: &LateContext<'_>, options: &[(OpenOption, Argument)],
                         "the method `read` is called more than once",
                     );
                 } else {
-                    read = true;
+                    read = true
                 }
                 read_arg = read_arg || (arg == Argument::True);
             },
@@ -177,7 +177,7 @@ fn check_open_options(cx: &LateContext<'_>, options: &[(OpenOption, Argument)],
                         "the method `write` is called more than once",
                     );
                 } else {
-                    write = true;
+                    write = true
                 }
                 write_arg = write_arg || (arg == Argument::True);
             },
diff --git a/clippy_lints/src/question_mark.rs b/clippy_lints/src/question_mark.rs
index 63c904b7fb4..6c480d48c75 100644
--- a/clippy_lints/src/question_mark.rs
+++ b/clippy_lints/src/question_mark.rs
@@ -88,7 +88,7 @@ impl QuestionMark {
                         "replace it with",
                         replacement_str,
                         applicability,
-                    );
+                    )
                 }
             }
         }
diff --git a/clippy_lints/src/redundant_closure_call.rs b/clippy_lints/src/redundant_closure_call.rs
index daea1592018..f398b3fff25 100644
--- a/clippy_lints/src/redundant_closure_call.rs
+++ b/clippy_lints/src/redundant_closure_call.rs
@@ -56,7 +56,7 @@ impl<'ast> ast_visit::Visitor<'ast> for ReturnVisitor {
             self.found_return = true;
         }
 
-        ast_visit::walk_expr(self, ex);
+        ast_visit::walk_expr(self, ex)
     }
 }
 
diff --git a/clippy_lints/src/redundant_pub_crate.rs b/clippy_lints/src/redundant_pub_crate.rs
index 127f6078dab..acd9047ace6 100644
--- a/clippy_lints/src/redundant_pub_crate.rs
+++ b/clippy_lints/src/redundant_pub_crate.rs
@@ -60,7 +60,7 @@ impl<'tcx> LateLintPass<'tcx> for RedundantPubCrate {
                                 Applicability::MachineApplicable,
                             );
                         },
-                    );
+                    )
                 }
             }
         }
diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
index e7b66c5ebcf..e438f92b136 100644
--- a/clippy_lints/src/returns.rs
+++ b/clippy_lints/src/returns.rs
@@ -139,7 +139,7 @@ impl<'tcx> LateLintPass<'tcx> for Return {
                 } else {
                     RetReplacement::Empty
                 };
-                check_final_expr(cx, &body.value, Some(body.value.span), replacement);
+                check_final_expr(cx, &body.value, Some(body.value.span), replacement)
             },
             FnKind::ItemFn(..) | FnKind::Method(..) => {
                 if let ExprKind::Block(ref block, _) = body.value.kind {
@@ -239,7 +239,7 @@ fn emit_return_lint(cx: &LateContext<'_>, ret_span: Span, inner_span: Option<Spa
                 if let Some(snippet) = snippet_opt(cx, inner_span) {
                     diag.span_suggestion(ret_span, "remove `return`", snippet, Applicability::MachineApplicable);
                 }
-            });
+            })
         },
         None => match replacement {
             RetReplacement::Empty => {
diff --git a/clippy_lints/src/semicolon_if_nothing_returned.rs b/clippy_lints/src/semicolon_if_nothing_returned.rs
index f47ca1b69b1..22cd10ced18 100644
--- a/clippy_lints/src/semicolon_if_nothing_returned.rs
+++ b/clippy_lints/src/semicolon_if_nothing_returned.rs
@@ -1,7 +1,7 @@
-use crate::utils::{in_macro, span_lint_and_sugg, sugg};
+use crate::utils::{in_macro, span_lint_and_then, sugg};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
-use rustc_hir::{Block, ExprKind};
+use rustc_hir::*;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
@@ -42,25 +42,31 @@ impl LateLintPass<'_> for SemicolonIfNothingReturned {
             if let Some(expr) = block.expr;
             let t_expr = cx.typeck_results().expr_ty(expr);
             if t_expr.is_unit();
-            if let Ok(snippet) = cx.tcx.sess.source_map().span_to_snippet(expr.span.source_callsite());
-            if !snippet.ends_with('}');
             then {
-                // filter out the desugared `for` loop
-                if let ExprKind::DropTemps(..) = &expr.kind {
-                    return;
+                match expr.kind {
+                    ExprKind::Loop(..) | 
+                    ExprKind::Match(..) | 
+                    ExprKind::Block(..) | 
+                    ExprKind::If(..) if !in_macro(expr.span) => return,
+                   _ => (),
                 }
 
                 let sugg = sugg::Sugg::hir(cx, &expr, "..");
                 let suggestion = format!("{0};", sugg);
-                span_lint_and_sugg(
+                span_lint_and_then(
                     cx,
                     SEMICOLON_IF_NOTHING_RETURNED,
                     expr.span,
-                    "Consider adding a `;` to the last statement for consistent formatting",
-                    "add a `;` here",
-                    suggestion,
-                    Applicability::MaybeIncorrect,
-                );
+                    "add `;` to terminate block",
+                    | diag | {
+                        diag.span_suggestion(
+                            expr.span,
+                            "add `;`",
+                            suggestion,
+                            Applicability::MaybeIncorrect,
+                        );
+                    }
+                )
             }
         }
     }
diff --git a/clippy_lints/src/shadow.rs b/clippy_lints/src/shadow.rs
index 3af98632712..d5b1767e945 100644
--- a/clippy_lints/src/shadow.rs
+++ b/clippy_lints/src/shadow.rs
@@ -118,7 +118,7 @@ fn check_fn<'tcx>(cx: &LateContext<'tcx>, decl: &'tcx FnDecl<'_>, body: &'tcx Bo
     let mut bindings = Vec::with_capacity(decl.inputs.len());
     for arg in iter_input_pats(decl, body) {
         if let PatKind::Binding(.., ident, _) = arg.pat.kind {
-            bindings.push((ident.name, ident.span));
+            bindings.push((ident.name, ident.span))
         }
     }
     check_expr(cx, &body.value, &mut bindings);
@@ -154,7 +154,7 @@ fn check_local<'tcx>(cx: &LateContext<'tcx>, local: &'tcx Local<'_>, bindings: &
         ..
     } = *local;
     if let Some(ref t) = *ty {
-        check_ty(cx, t, bindings);
+        check_ty(cx, t, bindings)
     }
     if let Some(ref o) = *init {
         check_expr(cx, o, bindings);
@@ -330,7 +330,7 @@ fn check_expr<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, bindings: &mut
         // ExprKind::MethodCall
         ExprKind::Array(v) | ExprKind::Tup(v) => {
             for e in v {
-                check_expr(cx, e, bindings);
+                check_expr(cx, e, bindings)
             }
         },
         ExprKind::If(ref cond, ref then, ref otherwise) => {
@@ -371,11 +371,11 @@ fn check_ty<'tcx>(cx: &LateContext<'tcx>, ty: &'tcx Ty<'_>, bindings: &mut Vec<(
             check_expr(cx, &cx.tcx.hir().body(anon_const.body).value, bindings);
         },
         TyKind::Ptr(MutTy { ty: ref mty, .. }) | TyKind::Rptr(_, MutTy { ty: ref mty, .. }) => {
-            check_ty(cx, mty, bindings);
+            check_ty(cx, mty, bindings)
         },
         TyKind::Tup(tup) => {
             for t in tup {
-                check_ty(cx, t, bindings);
+                check_ty(cx, t, bindings)
             }
         },
         TyKind::Typeof(ref anon_const) => check_expr(cx, &cx.tcx.hir().body(anon_const.body).value, bindings),
diff --git a/clippy_lints/src/slow_vector_initialization.rs b/clippy_lints/src/slow_vector_initialization.rs
index 9ba9b4187d2..96f6881556c 100644
--- a/clippy_lints/src/slow_vector_initialization.rs
+++ b/clippy_lints/src/slow_vector_initialization.rs
@@ -306,7 +306,7 @@ impl<'a, 'tcx> Visitor<'tcx> for VectorInitializationVisitor<'a, 'tcx> {
     fn visit_block(&mut self, block: &'tcx Block<'_>) {
         if self.initialization_found {
             if let Some(ref s) = block.stmts.get(0) {
-                self.visit_stmt(s);
+                self.visit_stmt(s)
             }
 
             self.initialization_found = false;
diff --git a/clippy_lints/src/suspicious_operation_groupings.rs b/clippy_lints/src/suspicious_operation_groupings.rs
index f245789d75d..cccd24ccf94 100644
--- a/clippy_lints/src/suspicious_operation_groupings.rs
+++ b/clippy_lints/src/suspicious_operation_groupings.rs
@@ -265,7 +265,7 @@ fn emit_suggestion(cx: &EarlyContext<'_>, span: Span, sugg: String, applicabilit
         "I think you meant",
         sugg,
         applicability,
-    );
+    )
 }
 
 fn ident_swap_sugg(
@@ -476,7 +476,7 @@ impl Add for IdentLocation {
 
 impl AddAssign for IdentLocation {
     fn add_assign(&mut self, other: Self) {
-        *self = *self + other;
+        *self = *self + other
     }
 }
 
@@ -507,7 +507,7 @@ impl Add for IdentDifference {
 
 impl AddAssign for IdentDifference {
     fn add_assign(&mut self, other: Self) {
-        *self = *self + other;
+        *self = *self + other
     }
 }
 
diff --git a/clippy_lints/src/transmute.rs b/clippy_lints/src/transmute.rs
index e619a1a698a..d977cea4da5 100644
--- a/clippy_lints/src/transmute.rs
+++ b/clippy_lints/src/transmute.rs
@@ -463,7 +463,7 @@ impl<'tcx> LateLintPass<'tcx> for Transmute {
                                     Applicability::Unspecified,
                                 );
                             },
-                        );
+                        )
                     },
                     (ty::Ref(_, ty_from, from_mutbl), ty::Ref(_, ty_to, to_mutbl)) => {
                         if_chain! {
@@ -519,7 +519,7 @@ impl<'tcx> LateLintPass<'tcx> for Transmute {
                                                 Applicability::Unspecified,
                                             );
                                         },
-                                    );
+                                    )
                                 }
                             }
                         }
@@ -552,7 +552,7 @@ impl<'tcx> LateLintPass<'tcx> for Transmute {
                                     Applicability::Unspecified,
                                 );
                             },
-                        );
+                        )
                     },
                     (ty::Int(_) | ty::Uint(_), ty::Float(_)) if !const_context => span_lint_and_then(
                         cx,
diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs
index dd3e934889a..1b0f1e309aa 100644
--- a/clippy_lints/src/types.rs
+++ b/clippy_lints/src/types.rs
@@ -630,7 +630,7 @@ impl Types {
             TyKind::Rptr(ref lt, ref mut_ty) => self.check_ty_rptr(cx, hir_ty, is_local, lt, mut_ty),
             // recurse
             TyKind::Slice(ref ty) | TyKind::Array(ref ty, _) | TyKind::Ptr(MutTy { ref ty, .. }) => {
-                self.check_ty(cx, ty, is_local);
+                self.check_ty(cx, ty, is_local)
             },
             TyKind::Tup(tys) => {
                 for ty in tys {
@@ -2436,7 +2436,7 @@ fn upcast_comparison_bounds_err<'tcx>(
                 },
                 Rel::Eq | Rel::Ne => unreachable!(),
             } {
-                err_upcast_comparison(cx, span, lhs, true);
+                err_upcast_comparison(cx, span, lhs, true)
             } else if match rel {
                 Rel::Lt => {
                     if invert {
@@ -2454,7 +2454,7 @@ fn upcast_comparison_bounds_err<'tcx>(
                 },
                 Rel::Eq | Rel::Ne => unreachable!(),
             } {
-                err_upcast_comparison(cx, span, lhs, false);
+                err_upcast_comparison(cx, span, lhs, false)
             }
         }
     }
diff --git a/clippy_lints/src/unicode.rs b/clippy_lints/src/unicode.rs
index 9346e3c1d3b..93d59cc7fcd 100644
--- a/clippy_lints/src/unicode.rs
+++ b/clippy_lints/src/unicode.rs
@@ -69,7 +69,7 @@ impl LateLintPass<'_> for Unicode {
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &'_ Expr<'_>) {
         if let ExprKind::Lit(ref lit) = expr.kind {
             if let LitKind::Str(_, _) = lit.node {
-                check_str(cx, lit.span, expr.hir_id);
+                check_str(cx, lit.span, expr.hir_id)
             }
         }
     }
@@ -80,7 +80,7 @@ fn escape<T: Iterator<Item = char>>(s: T) -> String {
     for c in s {
         if c as u32 > 0x7F {
             for d in c.escape_unicode() {
-                result.push(d);
+                result.push(d)
             }
         } else {
             result.push(c);
diff --git a/clippy_lints/src/unused_self.rs b/clippy_lints/src/unused_self.rs
index 83ba9c897e0..5349c4f7eb8 100644
--- a/clippy_lints/src/unused_self.rs
+++ b/clippy_lints/src/unused_self.rs
@@ -94,7 +94,7 @@ impl<'a, 'tcx> Visitor<'tcx> for UnusedSelfVisitor<'a, 'tcx> {
             return;
         }
         if let Res::Local(hir_id) = &path.res {
-            self.uses_self = self.self_hir_id == hir_id;
+            self.uses_self = self.self_hir_id == hir_id
         }
         walk_path(self, path);
     }
diff --git a/clippy_lints/src/upper_case_acronyms.rs b/clippy_lints/src/upper_case_acronyms.rs
index 0f04a4a62ce..61e7031716a 100644
--- a/clippy_lints/src/upper_case_acronyms.rs
+++ b/clippy_lints/src/upper_case_acronyms.rs
@@ -69,7 +69,7 @@ fn check_ident(cx: &EarlyContext<'_>, ident: &Ident) {
             "consider making the acronym lowercase, except the initial letter",
             corrected,
             Applicability::MaybeIncorrect,
-        );
+        )
     }
 }
 
diff --git a/clippy_lints/src/use_self.rs b/clippy_lints/src/use_self.rs
index 4bbfb3fbeb1..72d1ca73929 100644
--- a/clippy_lints/src/use_self.rs
+++ b/clippy_lints/src/use_self.rs
@@ -103,7 +103,7 @@ impl<'a, 'tcx> Visitor<'tcx> for SemanticUseSelfVisitor<'a, 'tcx> {
             }
         }
 
-        walk_ty(self, hir_ty);
+        walk_ty(self, hir_ty)
     }
 
     fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
diff --git a/clippy_lints/src/utils/attrs.rs b/clippy_lints/src/utils/attrs.rs
index 588c31ea40f..8d28421d70d 100644
--- a/clippy_lints/src/utils/attrs.rs
+++ b/clippy_lints/src/utils/attrs.rs
@@ -115,7 +115,7 @@ fn parse_attrs<F: FnMut(u64)>(sess: &Session, attrs: &[ast::Attribute], name: &'
     for attr in get_attr(sess, attrs, name) {
         if let Some(ref value) = attr.value_str() {
             if let Ok(value) = FromStr::from_str(&value.as_str()) {
-                f(value);
+                f(value)
             } else {
                 sess.span_err(attr.span, "not a number");
             }
diff --git a/clippy_lints/src/utils/author.rs b/clippy_lints/src/utils/author.rs
index b8c50112497..ca60d335262 100644
--- a/clippy_lints/src/utils/author.rs
+++ b/clippy_lints/src/utils/author.rs
@@ -293,7 +293,7 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor {
                     LitKind::Str(ref text, _) => {
                         let str_pat = self.next("s");
                         println!("    if let LitKind::Str(ref {}, _) = {}.node;", str_pat, lit_pat);
-                        println!("    if {}.as_str() == {:?}", str_pat, &*text.as_str());
+                        println!("    if {}.as_str() == {:?}", str_pat, &*text.as_str())
                     },
                 }
             },
diff --git a/clippy_lints/src/utils/diagnostics.rs b/clippy_lints/src/utils/diagnostics.rs
index f74ce999b5c..269be217c2d 100644
--- a/clippy_lints/src/utils/diagnostics.rs
+++ b/clippy_lints/src/utils/diagnostics.rs
@@ -211,7 +211,7 @@ pub fn multispan_sugg<I>(diag: &mut DiagnosticBuilder<'_>, help_msg: &str, sugg:
 where
     I: IntoIterator<Item = (Span, String)>,
 {
-    multispan_sugg_with_applicability(diag, help_msg, Applicability::Unspecified, sugg);
+    multispan_sugg_with_applicability(diag, help_msg, Applicability::Unspecified, sugg)
 }
 
 pub fn multispan_sugg_with_applicability<I>(
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index a519dce66d4..cf93ee0a7a5 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -464,7 +464,7 @@ pub fn method_chain_args<'a>(expr: &'a Expr<'_>, methods: &[&str]) -> Option<Vec
                     return None;
                 }
                 matched.push(&**args); // build up `matched` backwards
-                current = &args[0]; // go to parent expression
+                current = &args[0] // go to parent expression
             } else {
                 return None;
             }
diff --git a/clippy_lints/src/utils/sugg.rs b/clippy_lints/src/utils/sugg.rs
index 281ea4dffc7..03678db575f 100644
--- a/clippy_lints/src/utils/sugg.rs
+++ b/clippy_lints/src/utils/sugg.rs
@@ -656,7 +656,7 @@ impl<T: LintContext> DiagnosticBuilderExt<T> for rustc_errors::DiagnosticBuilder
 
             if let Some(non_whitespace_offset) = non_whitespace_offset {
                 remove_span = remove_span
-                    .with_hi(remove_span.hi() + BytePos(non_whitespace_offset.try_into().expect("offset too large")));
+                    .with_hi(remove_span.hi() + BytePos(non_whitespace_offset.try_into().expect("offset too large")))
             }
         }
 
diff --git a/clippy_lints/src/utils/usage.rs b/clippy_lints/src/utils/usage.rs
index 8bf169c0d06..fc0db7f64ec 100644
--- a/clippy_lints/src/utils/usage.rs
+++ b/clippy_lints/src/utils/usage.rs
@@ -60,7 +60,7 @@ impl<'tcx> MutVarsDelegate {
                 //FIXME: This causes false negatives. We can't get the `NodeId` from
                 //`Categorization::Upvar(_)`. So we search for any `Upvar`s in the
                 //`while`-body, not just the ones in the condition.
-                self.skip = true;
+                self.skip = true
             },
             _ => {},
         }
@@ -72,12 +72,12 @@ impl<'tcx> Delegate<'tcx> for MutVarsDelegate {
 
     fn borrow(&mut self, cmt: &PlaceWithHirId<'tcx>, _: HirId, bk: ty::BorrowKind) {
         if let ty::BorrowKind::MutBorrow = bk {
-            self.update(&cmt);
+            self.update(&cmt)
         }
     }
 
     fn mutate(&mut self, cmt: &PlaceWithHirId<'tcx>, _: HirId) {
-        self.update(&cmt);
+        self.update(&cmt)
     }
 }
 
diff --git a/clippy_lints/src/utils/visitors.rs b/clippy_lints/src/utils/visitors.rs
index caaf636c897..ebf69df31ca 100644
--- a/clippy_lints/src/utils/visitors.rs
+++ b/clippy_lints/src/utils/visitors.rs
@@ -87,7 +87,7 @@ where
         }
 
         fn visit_stmt(&mut self, stmt: &'hir hir::Stmt<'_>) {
-            intravisit::walk_stmt(&mut *self.inside_stmt(true), stmt);
+            intravisit::walk_stmt(&mut *self.inside_stmt(true), stmt)
         }
 
         fn visit_expr(&mut self, expr: &'hir hir::Expr<'_>) {
diff --git a/clippy_lints/src/verbose_file_reads.rs b/clippy_lints/src/verbose_file_reads.rs
index 92965e95cda..32574d9d6c9 100644
--- a/clippy_lints/src/verbose_file_reads.rs
+++ b/clippy_lints/src/verbose_file_reads.rs
@@ -52,7 +52,7 @@ impl<'tcx> LateLintPass<'tcx> for VerboseFileReads {
                 "use of `File::read_to_string`",
                 None,
                 "consider using `fs::read_to_string` instead",
-            );
+            )
         }
     }
 }
diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs
index f9ccf322dda..e40fdca6a99 100644
--- a/clippy_lints/src/write.rs
+++ b/clippy_lints/src/write.rs
@@ -298,7 +298,7 @@ impl EarlyLintPass for Write {
                                 Applicability::MachineApplicable,
                             );
                         },
-                    );
+                    )
                 }
             }
         } else if mac.path == sym!(writeln) {
diff --git a/tests/ui/semicolon_if_nothing_returned.rs b/tests/ui/semicolon_if_nothing_returned.rs
index 0abe2cca267..2c07cc9df40 100644
--- a/tests/ui/semicolon_if_nothing_returned.rs
+++ b/tests/ui/semicolon_if_nothing_returned.rs
@@ -46,10 +46,3 @@ fn foobar(x: i32) {
         y = x + 1;
     }
 }
-
-fn loop_test(x: i32) {
-    let y: i32;
-    for &ext in &["stdout", "stderr", "fixed"] {
-        println!("{}", ext);
-    }
-}
diff --git a/tests/ui/semicolon_if_nothing_returned.stderr b/tests/ui/semicolon_if_nothing_returned.stderr
index 2bc73342467..6026320f4b4 100644
--- a/tests/ui/semicolon_if_nothing_returned.stderr
+++ b/tests/ui/semicolon_if_nothing_returned.stderr
@@ -1,4 +1,4 @@
-error: Consider adding a `;` to the last statement for consistent formatting
+error: add `;` to terminate block
   --> $DIR/semicolon_if_nothing_returned.rs:8:5
    |
 LL |     println!("Hello")
@@ -7,17 +7,17 @@ LL |     println!("Hello")
    = note: `-D clippy::semicolon-if-nothing-returned` implied by `-D warnings`
    = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: Consider adding a `;` to the last statement for consistent formatting
+error: add `;` to terminate block
   --> $DIR/semicolon_if_nothing_returned.rs:12:5
    |
 LL |     get_unit()
-   |     ^^^^^^^^^^ help: add a `;` here: `get_unit();`
+   |     ^^^^^^^^^^ help: add `;`: `get_unit();`
 
-error: Consider adding a `;` to the last statement for consistent formatting
+error: add `;` to terminate block
   --> $DIR/semicolon_if_nothing_returned.rs:17:5
    |
 LL |     y = x + 1
-   |     ^^^^^^^^^ help: add a `;` here: `y = x + 1;`
+   |     ^^^^^^^^^ help: add `;`: `y = x + 1;`
 
 error: aborting due to 3 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 85c2b1e5f4cbe7d31ebbaf6b9620350020251c15 Mon Sep 17 00:00:00 2001
From: Bastian Kersting <bastian@cmbt.de>
Date: Sat, 6 Feb 2021 16:56:18 +0100
Subject: Switched to `snippet_with_macro_callsite`

---
 clippy_lints/src/semicolon_if_nothing_returned.rs | 35 +++++++++--------------
 tests/ui/semicolon_if_nothing_returned.rs         |  7 +++++
 tests/ui/semicolon_if_nothing_returned.stderr     | 10 +++----
 3 files changed, 26 insertions(+), 26 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/semicolon_if_nothing_returned.rs b/clippy_lints/src/semicolon_if_nothing_returned.rs
index 22cd10ced18..628725c52e9 100644
--- a/clippy_lints/src/semicolon_if_nothing_returned.rs
+++ b/clippy_lints/src/semicolon_if_nothing_returned.rs
@@ -1,7 +1,7 @@
-use crate::utils::{in_macro, span_lint_and_then, sugg};
+use crate::utils::{in_macro, span_lint_and_sugg, sugg, snippet_with_macro_callsite};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
-use rustc_hir::*;
+use rustc_hir::{Block, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
@@ -11,7 +11,6 @@ declare_clippy_lint! {
     ///
     /// **Why is this bad?** The semicolon might be optional but when
     /// extending the block with new code, it doesn't require a change in previous last line.
-    /// It's also more idiomatic.
     ///
     /// **Known problems:** None.
     ///
@@ -29,7 +28,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     pub SEMICOLON_IF_NOTHING_RETURNED,
-    pedantic,
+    restriction,
     "add a semicolon if nothing is returned"
 }
 
@@ -42,31 +41,25 @@ impl LateLintPass<'_> for SemicolonIfNothingReturned {
             if let Some(expr) = block.expr;
             let t_expr = cx.typeck_results().expr_ty(expr);
             if t_expr.is_unit();
+            if let snippet = snippet_with_macro_callsite(cx, expr.span, "}");
+            if !snippet.ends_with('}');
             then {
-                match expr.kind {
-                    ExprKind::Loop(..) | 
-                    ExprKind::Match(..) | 
-                    ExprKind::Block(..) | 
-                    ExprKind::If(..) if !in_macro(expr.span) => return,
-                   _ => (),
+                // filter out the desugared `for` loop
+                if let ExprKind::DropTemps(..) = &expr.kind {
+                    return;
                 }
 
                 let sugg = sugg::Sugg::hir(cx, &expr, "..");
                 let suggestion = format!("{0};", sugg);
-                span_lint_and_then(
+                span_lint_and_sugg(
                     cx,
                     SEMICOLON_IF_NOTHING_RETURNED,
                     expr.span,
-                    "add `;` to terminate block",
-                    | diag | {
-                        diag.span_suggestion(
-                            expr.span,
-                            "add `;`",
-                            suggestion,
-                            Applicability::MaybeIncorrect,
-                        );
-                    }
-                )
+                    "consider adding a `;` to the last statement for consistent formatting",
+                    "add a `;` here",
+                    suggestion,
+                    Applicability::MaybeIncorrect,
+                );
             }
         }
     }
diff --git a/tests/ui/semicolon_if_nothing_returned.rs b/tests/ui/semicolon_if_nothing_returned.rs
index 2c07cc9df40..0abe2cca267 100644
--- a/tests/ui/semicolon_if_nothing_returned.rs
+++ b/tests/ui/semicolon_if_nothing_returned.rs
@@ -46,3 +46,10 @@ fn foobar(x: i32) {
         y = x + 1;
     }
 }
+
+fn loop_test(x: i32) {
+    let y: i32;
+    for &ext in &["stdout", "stderr", "fixed"] {
+        println!("{}", ext);
+    }
+}
diff --git a/tests/ui/semicolon_if_nothing_returned.stderr b/tests/ui/semicolon_if_nothing_returned.stderr
index 6026320f4b4..56211ff7f77 100644
--- a/tests/ui/semicolon_if_nothing_returned.stderr
+++ b/tests/ui/semicolon_if_nothing_returned.stderr
@@ -1,4 +1,4 @@
-error: add `;` to terminate block
+error: consider adding a `;` to the last statement for consistent formatting
   --> $DIR/semicolon_if_nothing_returned.rs:8:5
    |
 LL |     println!("Hello")
@@ -7,17 +7,17 @@ LL |     println!("Hello")
    = note: `-D clippy::semicolon-if-nothing-returned` implied by `-D warnings`
    = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: add `;` to terminate block
+error: consider adding a `;` to the last statement for consistent formatting
   --> $DIR/semicolon_if_nothing_returned.rs:12:5
    |
 LL |     get_unit()
-   |     ^^^^^^^^^^ help: add `;`: `get_unit();`
+   |     ^^^^^^^^^^ help: add a `;` here: `get_unit();`
 
-error: add `;` to terminate block
+error: consider adding a `;` to the last statement for consistent formatting
   --> $DIR/semicolon_if_nothing_returned.rs:17:5
    |
 LL |     y = x + 1
-   |     ^^^^^^^^^ help: add `;`: `y = x + 1;`
+   |     ^^^^^^^^^ help: add a `;` here: `y = x + 1;`
 
 error: aborting due to 3 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From f1c15840a2bbd953414a650d24ee22d3a1c710f5 Mon Sep 17 00:00:00 2001
From: Bastian Kersting <bastian@cmbt.de>
Date: Sat, 6 Feb 2021 17:06:06 +0100
Subject: Changed lint level to `restriction`

---
 clippy_lints/src/lib.rs                           | 2 +-
 clippy_lints/src/semicolon_if_nothing_returned.rs | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index f6014c246d6..e2c325a7647 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1294,6 +1294,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&panic_unimplemented::UNIMPLEMENTED),
         LintId::of(&panic_unimplemented::UNREACHABLE),
         LintId::of(&pattern_type_mismatch::PATTERN_TYPE_MISMATCH),
+        LintId::of(&semicolon_if_nothing_returned::SEMICOLON_IF_NOTHING_RETURNED),
         LintId::of(&shadow::SHADOW_REUSE),
         LintId::of(&shadow::SHADOW_SAME),
         LintId::of(&strings::STRING_ADD),
@@ -1367,7 +1368,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&ranges::RANGE_PLUS_ONE),
         LintId::of(&redundant_else::REDUNDANT_ELSE),
         LintId::of(&ref_option_ref::REF_OPTION_REF),
-        LintId::of(&semicolon_if_nothing_returned::SEMICOLON_IF_NOTHING_RETURNED),
         LintId::of(&shadow::SHADOW_UNRELATED),
         LintId::of(&strings::STRING_ADD_ASSIGN),
         LintId::of(&trait_bounds::TRAIT_DUPLICATION_IN_BOUNDS),
diff --git a/clippy_lints/src/semicolon_if_nothing_returned.rs b/clippy_lints/src/semicolon_if_nothing_returned.rs
index 628725c52e9..6133e86a26a 100644
--- a/clippy_lints/src/semicolon_if_nothing_returned.rs
+++ b/clippy_lints/src/semicolon_if_nothing_returned.rs
@@ -1,4 +1,4 @@
-use crate::utils::{in_macro, span_lint_and_sugg, sugg, snippet_with_macro_callsite};
+use crate::utils::{in_macro, snippet_with_macro_callsite, span_lint_and_sugg, sugg};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Block, ExprKind};
-- 
cgit 1.4.1-3-g733a5


From 915e9b85a410a69542d147c3644d9e0548986034 Mon Sep 17 00:00:00 2001
From: daxpedda <daxpedda@gmail.com>
Date: Fri, 29 Jan 2021 14:03:26 +0100
Subject: Fix cargo_common_metadata warning on `publish = false`.

---
 clippy_lints/src/cargo_common_metadata.rs          | 54 +++++++++++-----------
 .../ui-cargo/cargo_common_metadata/fail/Cargo.toml |  1 -
 .../cargo_common_metadata/fail_publish/Cargo.toml  |  6 +++
 .../cargo_common_metadata/fail_publish/src/main.rs |  4 ++
 .../fail_publish/src/main.stderr                   | 18 ++++++++
 .../ui-cargo/cargo_common_metadata/pass/Cargo.toml |  1 -
 .../pass_publish_empty/Cargo.toml                  |  6 +++
 .../pass_publish_empty/src/main.rs                 |  4 ++
 .../pass_publish_false/Cargo.toml                  |  6 +++
 .../pass_publish_false/src/main.rs                 |  4 ++
 10 files changed, 76 insertions(+), 28 deletions(-)
 create mode 100644 tests/ui-cargo/cargo_common_metadata/fail_publish/Cargo.toml
 create mode 100644 tests/ui-cargo/cargo_common_metadata/fail_publish/src/main.rs
 create mode 100644 tests/ui-cargo/cargo_common_metadata/fail_publish/src/main.stderr
 create mode 100644 tests/ui-cargo/cargo_common_metadata/pass_publish_empty/Cargo.toml
 create mode 100644 tests/ui-cargo/cargo_common_metadata/pass_publish_empty/src/main.rs
 create mode 100644 tests/ui-cargo/cargo_common_metadata/pass_publish_false/Cargo.toml
 create mode 100644 tests/ui-cargo/cargo_common_metadata/pass_publish_false/src/main.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/cargo_common_metadata.rs b/clippy_lints/src/cargo_common_metadata.rs
index 0d294761af5..84c6eff79a1 100644
--- a/clippy_lints/src/cargo_common_metadata.rs
+++ b/clippy_lints/src/cargo_common_metadata.rs
@@ -80,32 +80,34 @@ impl LateLintPass<'_> for CargoCommonMetadata {
         let metadata = unwrap_cargo_metadata!(cx, CARGO_COMMON_METADATA, false);
 
         for package in metadata.packages {
-            if is_empty_vec(&package.authors) {
-                missing_warning(cx, &package, "package.authors");
-            }
-
-            if is_empty_str(&package.description) {
-                missing_warning(cx, &package, "package.description");
-            }
-
-            if is_empty_str(&package.license) && is_empty_path(&package.license_file) {
-                missing_warning(cx, &package, "either package.license or package.license_file");
-            }
-
-            if is_empty_str(&package.repository) {
-                missing_warning(cx, &package, "package.repository");
-            }
-
-            if is_empty_path(&package.readme) {
-                missing_warning(cx, &package, "package.readme");
-            }
-
-            if is_empty_vec(&package.keywords) {
-                missing_warning(cx, &package, "package.keywords");
-            }
-
-            if is_empty_vec(&package.categories) {
-                missing_warning(cx, &package, "package.categories");
+            if package.publish.as_ref().filter(|publish| publish.is_empty()).is_none() {
+                if is_empty_vec(&package.authors) {
+                    missing_warning(cx, &package, "package.authors");
+                }
+
+                if is_empty_str(&package.description) {
+                    missing_warning(cx, &package, "package.description");
+                }
+
+                if is_empty_str(&package.license) && is_empty_path(&package.license_file) {
+                    missing_warning(cx, &package, "either package.license or package.license_file");
+                }
+
+                if is_empty_str(&package.repository) {
+                    missing_warning(cx, &package, "package.repository");
+                }
+
+                if is_empty_path(&package.readme) {
+                    missing_warning(cx, &package, "package.readme");
+                }
+
+                if is_empty_vec(&package.keywords) {
+                    missing_warning(cx, &package, "package.keywords");
+                }
+
+                if is_empty_vec(&package.categories) {
+                    missing_warning(cx, &package, "package.categories");
+                }
             }
         }
     }
diff --git a/tests/ui-cargo/cargo_common_metadata/fail/Cargo.toml b/tests/ui-cargo/cargo_common_metadata/fail/Cargo.toml
index ae0a6032996..1645c975be1 100644
--- a/tests/ui-cargo/cargo_common_metadata/fail/Cargo.toml
+++ b/tests/ui-cargo/cargo_common_metadata/fail/Cargo.toml
@@ -1,6 +1,5 @@
 [package]
 name = "cargo_common_metadata"
 version = "0.1.0"
-publish = false
 
 [workspace]
diff --git a/tests/ui-cargo/cargo_common_metadata/fail_publish/Cargo.toml b/tests/ui-cargo/cargo_common_metadata/fail_publish/Cargo.toml
new file mode 100644
index 00000000000..7595696353c
--- /dev/null
+++ b/tests/ui-cargo/cargo_common_metadata/fail_publish/Cargo.toml
@@ -0,0 +1,6 @@
+[package]
+name = "cargo_common_metadata"
+version = "0.1.0"
+publish = ["some-registry-name"]
+
+[workspace]
diff --git a/tests/ui-cargo/cargo_common_metadata/fail_publish/src/main.rs b/tests/ui-cargo/cargo_common_metadata/fail_publish/src/main.rs
new file mode 100644
index 00000000000..27841e18aa9
--- /dev/null
+++ b/tests/ui-cargo/cargo_common_metadata/fail_publish/src/main.rs
@@ -0,0 +1,4 @@
+// compile-flags: --crate-name=cargo_common_metadata
+#![warn(clippy::cargo_common_metadata)]
+
+fn main() {}
diff --git a/tests/ui-cargo/cargo_common_metadata/fail_publish/src/main.stderr b/tests/ui-cargo/cargo_common_metadata/fail_publish/src/main.stderr
new file mode 100644
index 00000000000..c8ae6c820df
--- /dev/null
+++ b/tests/ui-cargo/cargo_common_metadata/fail_publish/src/main.stderr
@@ -0,0 +1,18 @@
+error: package `cargo_common_metadata` is missing `package.authors` metadata
+   |
+   = note: `-D clippy::cargo-common-metadata` implied by `-D warnings`
+
+error: package `cargo_common_metadata` is missing `package.description` metadata
+
+error: package `cargo_common_metadata` is missing `either package.license or package.license_file` metadata
+
+error: package `cargo_common_metadata` is missing `package.repository` metadata
+
+error: package `cargo_common_metadata` is missing `package.readme` metadata
+
+error: package `cargo_common_metadata` is missing `package.keywords` metadata
+
+error: package `cargo_common_metadata` is missing `package.categories` metadata
+
+error: aborting due to 7 previous errors
+
diff --git a/tests/ui-cargo/cargo_common_metadata/pass/Cargo.toml b/tests/ui-cargo/cargo_common_metadata/pass/Cargo.toml
index 737e84e963c..86abfd54d4d 100644
--- a/tests/ui-cargo/cargo_common_metadata/pass/Cargo.toml
+++ b/tests/ui-cargo/cargo_common_metadata/pass/Cargo.toml
@@ -1,7 +1,6 @@
 [package]
 name = "cargo_common_metadata"
 version = "0.1.0"
-publish = false
 authors = ["Random person from the Internet <someone@someplace.org>"]
 description = "A test package for the cargo_common_metadata lint"
 repository = "https://github.com/someone/cargo_common_metadata"
diff --git a/tests/ui-cargo/cargo_common_metadata/pass_publish_empty/Cargo.toml b/tests/ui-cargo/cargo_common_metadata/pass_publish_empty/Cargo.toml
new file mode 100644
index 00000000000..ae0a6032996
--- /dev/null
+++ b/tests/ui-cargo/cargo_common_metadata/pass_publish_empty/Cargo.toml
@@ -0,0 +1,6 @@
+[package]
+name = "cargo_common_metadata"
+version = "0.1.0"
+publish = false
+
+[workspace]
diff --git a/tests/ui-cargo/cargo_common_metadata/pass_publish_empty/src/main.rs b/tests/ui-cargo/cargo_common_metadata/pass_publish_empty/src/main.rs
new file mode 100644
index 00000000000..27841e18aa9
--- /dev/null
+++ b/tests/ui-cargo/cargo_common_metadata/pass_publish_empty/src/main.rs
@@ -0,0 +1,4 @@
+// compile-flags: --crate-name=cargo_common_metadata
+#![warn(clippy::cargo_common_metadata)]
+
+fn main() {}
diff --git a/tests/ui-cargo/cargo_common_metadata/pass_publish_false/Cargo.toml b/tests/ui-cargo/cargo_common_metadata/pass_publish_false/Cargo.toml
new file mode 100644
index 00000000000..0a879c99b5b
--- /dev/null
+++ b/tests/ui-cargo/cargo_common_metadata/pass_publish_false/Cargo.toml
@@ -0,0 +1,6 @@
+[package]
+name = "cargo_common_metadata"
+version = "0.1.0"
+publish = []
+
+[workspace]
diff --git a/tests/ui-cargo/cargo_common_metadata/pass_publish_false/src/main.rs b/tests/ui-cargo/cargo_common_metadata/pass_publish_false/src/main.rs
new file mode 100644
index 00000000000..27841e18aa9
--- /dev/null
+++ b/tests/ui-cargo/cargo_common_metadata/pass_publish_false/src/main.rs
@@ -0,0 +1,4 @@
+// compile-flags: --crate-name=cargo_common_metadata
+#![warn(clippy::cargo_common_metadata)]
+
+fn main() {}
-- 
cgit 1.4.1-3-g733a5


From f0d3fd72d7bacb60b1be554612ba19e87ca285cd Mon Sep 17 00:00:00 2001
From: daxpedda <daxpedda@gmail.com>
Date: Wed, 3 Feb 2021 19:19:30 +0100
Subject: Implement `_cargo_ignore_publish`.

---
 clippy_lints/src/cargo_common_metadata.rs           | 21 +++++++++++++++++----
 clippy_lints/src/lib.rs                             |  3 ++-
 clippy_lints/src/utils/conf.rs                      |  2 ++
 .../ui-cargo/cargo_common_metadata/pass/Cargo.toml  |  1 +
 .../ui-cargo/cargo_common_metadata/pass/clippy.toml |  1 +
 5 files changed, 23 insertions(+), 5 deletions(-)
 create mode 100644 tests/ui-cargo/cargo_common_metadata/pass/clippy.toml

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/cargo_common_metadata.rs b/clippy_lints/src/cargo_common_metadata.rs
index 84c6eff79a1..f499345636c 100644
--- a/clippy_lints/src/cargo_common_metadata.rs
+++ b/clippy_lints/src/cargo_common_metadata.rs
@@ -5,7 +5,7 @@ use std::path::PathBuf;
 use crate::utils::{run_lints, span_lint};
 use rustc_hir::{hir_id::CRATE_HIR_ID, Crate};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::DUMMY_SP;
 
 declare_clippy_lint! {
@@ -51,6 +51,21 @@ declare_clippy_lint! {
     "common metadata is defined in `Cargo.toml`"
 }
 
+#[derive(Copy, Clone, Debug)]
+pub struct CargoCommonMetadata {
+    ignore_publish: bool,
+}
+
+impl CargoCommonMetadata {
+    pub fn new(ignore_publish: bool) -> Self {
+        Self { ignore_publish }
+    }
+}
+
+impl_lint_pass!(CargoCommonMetadata => [
+    CARGO_COMMON_METADATA
+]);
+
 fn missing_warning(cx: &LateContext<'_>, package: &cargo_metadata::Package, field: &str) {
     let message = format!("package `{}` is missing `{}` metadata", package.name, field);
     span_lint(cx, CARGO_COMMON_METADATA, DUMMY_SP, &message);
@@ -69,8 +84,6 @@ fn is_empty_vec(value: &[String]) -> bool {
     value.iter().all(String::is_empty)
 }
 
-declare_lint_pass!(CargoCommonMetadata => [CARGO_COMMON_METADATA]);
-
 impl LateLintPass<'_> for CargoCommonMetadata {
     fn check_crate(&mut self, cx: &LateContext<'_>, _: &Crate<'_>) {
         if !run_lints(cx, &[CARGO_COMMON_METADATA], CRATE_HIR_ID) {
@@ -80,7 +93,7 @@ impl LateLintPass<'_> for CargoCommonMetadata {
         let metadata = unwrap_cargo_metadata!(cx, CARGO_COMMON_METADATA, false);
 
         for package in metadata.packages {
-            if package.publish.as_ref().filter(|publish| publish.is_empty()).is_none() {
+            if package.publish.as_ref().filter(|publish| publish.is_empty()).is_none() || self.ignore_publish {
                 if is_empty_vec(&package.authors) {
                     missing_warning(cx, &package, "package.authors");
                 }
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 7f5c4f56f9e..e8e8229915b 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1180,7 +1180,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_early_pass(|| box redundant_else::RedundantElse);
     store.register_late_pass(|| box create_dir::CreateDir);
     store.register_early_pass(|| box needless_arbitrary_self_type::NeedlessArbitrarySelfType);
-    store.register_late_pass(|| box cargo_common_metadata::CargoCommonMetadata);
+    let cargo_ignore_publish = conf._cargo_ignore_publish;
+    store.register_late_pass(move || box cargo_common_metadata::CargoCommonMetadata::new(cargo_ignore_publish));
     store.register_late_pass(|| box multiple_crate_versions::MultipleCrateVersions);
     store.register_late_pass(|| box wildcard_dependencies::WildcardDependencies);
     let literal_representation_lint_fraction_readability = conf.unreadable_literal_lint_fractions;
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index b5a8300376c..0b0d31c8603 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -173,6 +173,8 @@ define_Conf! {
     (disallowed_methods, "disallowed_methods": Vec<String>, Vec::<String>::new()),
     /// Lint: UNREADABLE_LITERAL. Should the fraction of a decimal be linted to include separators.
     (unreadable_literal_lint_fractions, "unreadable_literal_lint_fractions": bool, true),
+    /// Lint: CARGO_COMMON_METADATA. For internal testing only, ignores the current `publish` settings in the Cargo manifest.
+    (_cargo_ignore_publish, "_cargo_ignore_publish": bool, false),
 }
 
 impl Default for Conf {
diff --git a/tests/ui-cargo/cargo_common_metadata/pass/Cargo.toml b/tests/ui-cargo/cargo_common_metadata/pass/Cargo.toml
index 86abfd54d4d..737e84e963c 100644
--- a/tests/ui-cargo/cargo_common_metadata/pass/Cargo.toml
+++ b/tests/ui-cargo/cargo_common_metadata/pass/Cargo.toml
@@ -1,6 +1,7 @@
 [package]
 name = "cargo_common_metadata"
 version = "0.1.0"
+publish = false
 authors = ["Random person from the Internet <someone@someplace.org>"]
 description = "A test package for the cargo_common_metadata lint"
 repository = "https://github.com/someone/cargo_common_metadata"
diff --git a/tests/ui-cargo/cargo_common_metadata/pass/clippy.toml b/tests/ui-cargo/cargo_common_metadata/pass/clippy.toml
new file mode 100644
index 00000000000..866c4f3c35e
--- /dev/null
+++ b/tests/ui-cargo/cargo_common_metadata/pass/clippy.toml
@@ -0,0 +1 @@
+_cargo_ignore_publish = true
-- 
cgit 1.4.1-3-g733a5


From 8805931ce35eeebb9c27c3efdf90245afecef20c Mon Sep 17 00:00:00 2001
From: daxpedda <daxpedda@gmail.com>
Date: Sat, 6 Feb 2021 16:51:51 +0100
Subject: Hide clippy configuration option.

Co-authored-by: Philipp Krones <hello@philkrones.com>
---
 clippy_lints/src/utils/conf.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 0b0d31c8603..e8a4236eeaa 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -173,7 +173,7 @@ define_Conf! {
     (disallowed_methods, "disallowed_methods": Vec<String>, Vec::<String>::new()),
     /// Lint: UNREADABLE_LITERAL. Should the fraction of a decimal be linted to include separators.
     (unreadable_literal_lint_fractions, "unreadable_literal_lint_fractions": bool, true),
-    /// Lint: CARGO_COMMON_METADATA. For internal testing only, ignores the current `publish` settings in the Cargo manifest.
+    /// Lint: _CARGO_COMMON_METADATA. For internal testing only, ignores the current `publish` settings in the Cargo manifest.
     (_cargo_ignore_publish, "_cargo_ignore_publish": bool, false),
 }
 
-- 
cgit 1.4.1-3-g733a5


From f2391a5569a468e5c73cce3b312bb47b655da9d4 Mon Sep 17 00:00:00 2001
From: daxpedda <daxpedda@gmail.com>
Date: Sat, 6 Feb 2021 17:38:14 +0100
Subject: Change clippy configuration option.

---
 clippy_lints/src/lib.rs                               | 2 +-
 clippy_lints/src/utils/conf.rs                        | 2 +-
 tests/ui-cargo/cargo_common_metadata/pass/clippy.toml | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index e8e8229915b..122523b0528 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1180,7 +1180,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_early_pass(|| box redundant_else::RedundantElse);
     store.register_late_pass(|| box create_dir::CreateDir);
     store.register_early_pass(|| box needless_arbitrary_self_type::NeedlessArbitrarySelfType);
-    let cargo_ignore_publish = conf._cargo_ignore_publish;
+    let cargo_ignore_publish = conf.cargo_ignore_publish;
     store.register_late_pass(move || box cargo_common_metadata::CargoCommonMetadata::new(cargo_ignore_publish));
     store.register_late_pass(|| box multiple_crate_versions::MultipleCrateVersions);
     store.register_late_pass(|| box wildcard_dependencies::WildcardDependencies);
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index e8a4236eeaa..b4498d13a24 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -174,7 +174,7 @@ define_Conf! {
     /// Lint: UNREADABLE_LITERAL. Should the fraction of a decimal be linted to include separators.
     (unreadable_literal_lint_fractions, "unreadable_literal_lint_fractions": bool, true),
     /// Lint: _CARGO_COMMON_METADATA. For internal testing only, ignores the current `publish` settings in the Cargo manifest.
-    (_cargo_ignore_publish, "_cargo_ignore_publish": bool, false),
+    (cargo_ignore_publish, "cargo_ignore_publish": bool, false),
 }
 
 impl Default for Conf {
diff --git a/tests/ui-cargo/cargo_common_metadata/pass/clippy.toml b/tests/ui-cargo/cargo_common_metadata/pass/clippy.toml
index 866c4f3c35e..de4f04b24fc 100644
--- a/tests/ui-cargo/cargo_common_metadata/pass/clippy.toml
+++ b/tests/ui-cargo/cargo_common_metadata/pass/clippy.toml
@@ -1 +1 @@
-_cargo_ignore_publish = true
+cargo-ignore-publish = true
-- 
cgit 1.4.1-3-g733a5


From ea0b8324d6457c4a380a6c30e41414f863ff7897 Mon Sep 17 00:00:00 2001
From: daxpedda <daxpedda@gmail.com>
Date: Sat, 6 Feb 2021 18:24:08 +0100
Subject: Document condition.

---
 clippy_lints/src/cargo_common_metadata.rs | 1 +
 1 file changed, 1 insertion(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/cargo_common_metadata.rs b/clippy_lints/src/cargo_common_metadata.rs
index f499345636c..12cbaea26cd 100644
--- a/clippy_lints/src/cargo_common_metadata.rs
+++ b/clippy_lints/src/cargo_common_metadata.rs
@@ -93,6 +93,7 @@ impl LateLintPass<'_> for CargoCommonMetadata {
         let metadata = unwrap_cargo_metadata!(cx, CARGO_COMMON_METADATA, false);
 
         for package in metadata.packages {
+            // we want to skip the lint if publish is `None` (`publish = false`) or if the vector is empty (`publish = []`)
             if package.publish.as_ref().filter(|publish| publish.is_empty()).is_none() || self.ignore_publish {
                 if is_empty_vec(&package.authors) {
                     missing_warning(cx, &package, "package.authors");
-- 
cgit 1.4.1-3-g733a5


From fd8b5fa1aa614dcfd21471ab5a9a56c7873ce14a Mon Sep 17 00:00:00 2001
From: daxpedda <daxpedda@gmail.com>
Date: Sat, 6 Feb 2021 18:29:07 +0100
Subject: Confused about my own explanation.

---
 clippy_lints/src/cargo_common_metadata.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/cargo_common_metadata.rs b/clippy_lints/src/cargo_common_metadata.rs
index 12cbaea26cd..cc2869ab495 100644
--- a/clippy_lints/src/cargo_common_metadata.rs
+++ b/clippy_lints/src/cargo_common_metadata.rs
@@ -93,7 +93,8 @@ impl LateLintPass<'_> for CargoCommonMetadata {
         let metadata = unwrap_cargo_metadata!(cx, CARGO_COMMON_METADATA, false);
 
         for package in metadata.packages {
-            // we want to skip the lint if publish is `None` (`publish = false`) or if the vector is empty (`publish = []`)
+            // only run the lint if publish is `None` (`publish = true` or skipped entirely)
+            // or if the vector isn't empty (`publish = ["something"]`)
             if package.publish.as_ref().filter(|publish| publish.is_empty()).is_none() || self.ignore_publish {
                 if is_empty_vec(&package.authors) {
                     missing_warning(cx, &package, "package.authors");
-- 
cgit 1.4.1-3-g733a5


From 6b4789d7cf8d4165398985ff89dfdbaa5548d39a Mon Sep 17 00:00:00 2001
From: Bastian Kersting <bastian@cmbt.de>
Date: Sat, 6 Feb 2021 20:05:51 +0100
Subject: Fixed suggestion in macro invocations

---
 clippy_lints/src/semicolon_if_nothing_returned.rs | 4 ++--
 tests/ui/semicolon_if_nothing_returned.stderr     | 3 +--
 2 files changed, 3 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/semicolon_if_nothing_returned.rs b/clippy_lints/src/semicolon_if_nothing_returned.rs
index 6133e86a26a..839c995e525 100644
--- a/clippy_lints/src/semicolon_if_nothing_returned.rs
+++ b/clippy_lints/src/semicolon_if_nothing_returned.rs
@@ -49,12 +49,12 @@ impl LateLintPass<'_> for SemicolonIfNothingReturned {
                     return;
                 }
 
-                let sugg = sugg::Sugg::hir(cx, &expr, "..");
+                let sugg = sugg::Sugg::hir_with_macro_callsite(cx, &expr, "..");
                 let suggestion = format!("{0};", sugg);
                 span_lint_and_sugg(
                     cx,
                     SEMICOLON_IF_NOTHING_RETURNED,
-                    expr.span,
+                    expr.span.source_callsite(),
                     "consider adding a `;` to the last statement for consistent formatting",
                     "add a `;` here",
                     suggestion,
diff --git a/tests/ui/semicolon_if_nothing_returned.stderr b/tests/ui/semicolon_if_nothing_returned.stderr
index 56211ff7f77..b73f8967538 100644
--- a/tests/ui/semicolon_if_nothing_returned.stderr
+++ b/tests/ui/semicolon_if_nothing_returned.stderr
@@ -2,10 +2,9 @@ error: consider adding a `;` to the last statement for consistent formatting
   --> $DIR/semicolon_if_nothing_returned.rs:8:5
    |
 LL |     println!("Hello")
-   |     ^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^ help: add a `;` here: `println!("Hello");`
    |
    = note: `-D clippy::semicolon-if-nothing-returned` implied by `-D warnings`
-   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: consider adding a `;` to the last statement for consistent formatting
   --> $DIR/semicolon_if_nothing_returned.rs:12:5
-- 
cgit 1.4.1-3-g733a5


From 40ce05654be9f4f6fb80e295f3eb05bee211cfc7 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Fri, 5 Feb 2021 14:55:09 -0600
Subject: Eat dogfood

---
 clippy_dev/src/serve.rs       | 2 +-
 clippy_lints/src/macro_use.rs | 2 +-
 src/main.rs                   | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_dev/src/serve.rs b/clippy_dev/src/serve.rs
index faa94859601..d13c27a1957 100644
--- a/clippy_dev/src/serve.rs
+++ b/clippy_dev/src/serve.rs
@@ -34,7 +34,7 @@ pub fn run(port: u16, lint: Option<&str>) -> ! {
                 // Give some time for python to start
                 thread::sleep(Duration::from_millis(500));
                 // Launch browser after first export.py has completed and http.server is up
-                let _ = opener::open(url);
+                let _result = opener::open(url);
             });
         }
         thread::sleep(Duration::from_millis(1000));
diff --git a/clippy_lints/src/macro_use.rs b/clippy_lints/src/macro_use.rs
index bb52888883a..40f04bd677d 100644
--- a/clippy_lints/src/macro_use.rs
+++ b/clippy_lints/src/macro_use.rs
@@ -160,7 +160,7 @@ impl<'tcx> LateLintPass<'tcx> for MacroUseImports {
             let found_idx = self.mac_refs.iter().position(|mac| import.ends_with(&mac.name));
 
             if let Some(idx) = found_idx {
-                let _ = self.mac_refs.remove(idx);
+                self.mac_refs.remove(idx);
                 let seg = import.split("::").collect::<Vec<_>>();
 
                 match seg.as_slice() {
diff --git a/src/main.rs b/src/main.rs
index ea06743394d..b4423ce9ec7 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -195,7 +195,7 @@ mod tests {
     #[should_panic]
     fn fix_without_unstable() {
         let args = "cargo clippy --fix".split_whitespace().map(ToString::to_string);
-        let _ = ClippyCmd::new(args);
+        ClippyCmd::new(args);
     }
 
     #[test]
-- 
cgit 1.4.1-3-g733a5


From 22d4483dee55fbf0c9ba48a3ddfd8abe06805c07 Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Sun, 7 Feb 2021 18:00:08 +0900
Subject: Simplify DefaultNumericFallback

---
 clippy_lints/src/default_numeric_fallback.rs | 394 +++------------------------
 clippy_lints/src/lib.rs                      |   2 +-
 tests/ui/default_numeric_fallback.rs         | 101 +------
 tests/ui/default_numeric_fallback.stderr     | 176 +-----------
 4 files changed, 61 insertions(+), 612 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/default_numeric_fallback.rs b/clippy_lints/src/default_numeric_fallback.rs
index 5f0ee1be2b9..b3b5a4a8251 100644
--- a/clippy_lints/src/default_numeric_fallback.rs
+++ b/clippy_lints/src/default_numeric_fallback.rs
@@ -1,17 +1,9 @@
-use rustc_ast::ast::{Label, LitFloatType, LitIntType, LitKind};
-use rustc_hir::{
-    self as hir,
-    intravisit::{walk_expr, walk_stmt, walk_ty, FnKind, NestedVisitorMap, Visitor},
-    Body, BodyId, Expr, ExprKind, FnDecl, FnRetTy, Guard, HirId, Lit, Stmt, StmtKind,
-};
+use rustc_ast::{LitFloatType, LitIntType, LitKind};
+use rustc_data_structures::fx::FxHashSet;
+use rustc_hir::{Expr, ExprKind, HirId, Stmt, StmtKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::{
-    hir::map::Map,
-    ty::{self, subst::GenericArgKind, FloatTy, IntTy, Ty, TyCtxt},
-};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::Span;
-use rustc_typeck::hir_ty_to_ty;
+use rustc_middle::ty::{self, FloatTy, IntTy};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
 
 use if_chain::if_chain;
 
@@ -41,363 +33,53 @@ declare_clippy_lint! {
     /// Use instead:
     /// ```rust
     /// let i = 10i32;
-    /// let f = 1.23f64;
+    /// let f: f64 = 1.23;
     /// ```
     pub DEFAULT_NUMERIC_FALLBACK,
     restriction,
     "usage of unconstrained numeric literals which may cause default numeric fallback."
 }
 
-declare_lint_pass!(DefaultNumericFallback => [DEFAULT_NUMERIC_FALLBACK]);
-
-/// Return the body that includes passed `hir_id` if exists.
-fn enclosing_body_opt(tcx: TyCtxt<'_>, hir_id: HirId) -> Option<BodyId> {
-    let hir_map = tcx.hir();
-    let mut trace = vec![(hir_id)];
-
-    for (parent, _) in hir_map.parent_iter(hir_id) {
-        trace.push(parent);
-        if let Some(body) = hir_map.maybe_body_owned_by(parent) {
-            if trace.iter().any(|hir_id| *hir_id == body.hir_id) {
-                return Some(body);
-            }
-        }
-    }
-
-    None
+#[derive(Default)]
+pub struct DefaultNumericFallback {
+    /// Hold `init` in `Local` if `Local` has a type annotation.
+    bounded_inits: FxHashSet<HirId>,
 }
 
-fn ty_from_hir_ty<'tcx>(cx: &LateContext<'tcx>, hir_ty: &hir::Ty<'tcx>) -> Option<Ty<'tcx>> {
-    if enclosing_body_opt(cx.tcx, hir_ty.hir_id).is_some() {
-        cx.typeck_results().node_type_opt(hir_ty.hir_id)
-    } else {
-        Some(hir_ty_to_ty(cx.tcx, hir_ty))
-    }
-}
+impl_lint_pass!(DefaultNumericFallback => [DEFAULT_NUMERIC_FALLBACK]);
 
 impl LateLintPass<'_> for DefaultNumericFallback {
-    fn check_fn(
-        &mut self,
-        cx: &LateContext<'tcx>,
-        _: FnKind<'tcx>,
-        fn_decl: &'tcx FnDecl<'_>,
-        body: &'tcx Body<'_>,
-        _: Span,
-        _: HirId,
-    ) {
-        let ret_ty_bound = match fn_decl.output {
-            FnRetTy::DefaultReturn(_) => None,
-            FnRetTy::Return(ty) => Some(ty),
-        }
-        .and_then(|ty| {
-            if is_infer_included(ty) {
-                None
-            } else {
-                ty_from_hir_ty(cx, ty)
+    fn check_stmt(&mut self, _: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) {
+        if_chain! {
+            if let StmtKind::Local(local) = stmt.kind;
+            if local.ty.is_some();
+            if let Some(init) = local.init;
+            then {
+                self.bounded_inits.insert(init.hir_id);
             }
-        });
-
-        let mut visitor = NumericFallbackVisitor::new(ret_ty_bound, cx);
-        visitor.visit_body(body);
-    }
-}
-
-struct NumericFallbackVisitor<'a, 'tcx> {
-    /// Stack manages type bound of exprs. The top element holds current expr type.
-    ty_bounds: Vec<Option<Ty<'tcx>>>,
-
-    /// Ret type bound.
-    ret_ty_bound: Option<Ty<'tcx>>,
-
-    /// Break type bounds.
-    break_ty_bounds: Vec<(Option<Label>, Option<Ty<'tcx>>)>,
-
-    cx: &'a LateContext<'tcx>,
-}
-
-impl<'a, 'tcx> NumericFallbackVisitor<'a, 'tcx> {
-    fn new(ret_ty_bound: Option<Ty<'tcx>>, cx: &'a LateContext<'tcx>) -> Self {
-        Self {
-            ty_bounds: vec![ret_ty_bound],
-            ret_ty_bound,
-            break_ty_bounds: vec![],
-            cx,
         }
     }
 
-    /// Check whether a passed literal has potential to cause fallback or not.
-    fn check_lit(&self, lit: &Lit, lit_ty: Ty<'tcx>) {
-        let ty_bound = self.ty_bounds.last().unwrap();
-
-        let should_lint = match (&lit.node, lit_ty.kind()) {
-            (LitKind::Int(_, LitIntType::Unsuffixed), ty::Int(ty::IntTy::I32)) => {
-                // In case integer literal is explicitly bound to i32, then suppress lint.
-                ty_bound.map_or(true, |ty_bound| !matches!(ty_bound.kind(), ty::Int(IntTy::I32)))
-            },
-
-            (LitKind::Float(_, LitFloatType::Unsuffixed), ty::Float(ty::FloatTy::F64)) => {
-                // In case float literal is explicitly bound to f64, then suppress lint.
-                ty_bound.map_or(true, |ty_bound| !matches!(ty_bound.kind(), ty::Float(FloatTy::F64)))
-            },
-
-            _ => false,
-        };
-
-        if should_lint {
-            span_lint_and_help(
-                self.cx,
-                DEFAULT_NUMERIC_FALLBACK,
-                lit.span,
-                "default numeric fallback might occur",
-                None,
-                "consider adding suffix to avoid default numeric fallback",
-            );
-        }
-    }
-}
-
-impl<'a, 'tcx> Visitor<'tcx> for NumericFallbackVisitor<'a, 'tcx> {
-    type Map = Map<'tcx>;
-
-    #[allow(clippy::too_many_lines)]
-    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
-        match (&expr.kind, *self.ty_bounds.last().unwrap()) {
-            (ExprKind::Array(_), Some(last_bound)) => {
-                if let ty::Array(ty, _) = last_bound.kind() {
-                    self.ty_bounds.push(Some(ty))
-                } else {
-                    self.ty_bounds.push(None)
-                }
-            },
-
-            (ExprKind::Call(func, args), _) => {
-                if_chain! {
-                    if let ExprKind::Path(ref func_path) = func.kind;
-                    if let Some(def_id) = self.cx.qpath_res(func_path, func.hir_id).opt_def_id();
-                    then {
-                        let fn_sig = self.cx.tcx.fn_sig(def_id).skip_binder();
-                        for (expr, bound) in args.iter().zip(fn_sig.inputs().iter()) {
-                            // Push found arg type, then visit arg.
-                            self.ty_bounds.push(Some(bound));
-                            self.visit_expr(expr);
-                            self.ty_bounds.pop();
-                        }
-                        return;
-                    } else {
-                        self.ty_bounds.push(None)
-                    }
-                }
-            },
-
-            (ExprKind::MethodCall(_, _, args, _), _) => {
-                if let Some(def_id) = self.cx.typeck_results().type_dependent_def_id(expr.hir_id) {
-                    let fn_sig = self.cx.tcx.fn_sig(def_id).skip_binder();
-                    for (expr, bound) in args.iter().zip(fn_sig.inputs().iter()) {
-                        self.ty_bounds.push(Some(bound));
-                        self.visit_expr(expr);
-                        self.ty_bounds.pop();
-                    }
-                    return;
-                }
-
-                self.ty_bounds.push(None)
-            },
-
-            (ExprKind::Tup(exprs), Some(last_bound)) => {
-                if let ty::Tuple(tys) = last_bound.kind() {
-                    for (expr, bound) in exprs.iter().zip(tys.iter()) {
-                        if let GenericArgKind::Type(ty) = bound.unpack() {
-                            self.ty_bounds.push(Some(ty));
-                        } else {
-                            self.ty_bounds.push(None);
-                        }
-
-                        self.visit_expr(expr);
-                        self.ty_bounds.pop();
-                    }
-                    return;
-                }
-
-                self.ty_bounds.push(None)
-            },
-
-            (ExprKind::Lit(lit), _) => {
-                let ty = self.cx.typeck_results().expr_ty(expr);
-                self.check_lit(lit, ty);
-                return;
-            },
-
-            (ExprKind::If(cond, then, else_), last_bound) => {
-                // Cond has no type bound in any situation.
-                self.ty_bounds.push(None);
-                self.visit_expr(cond);
-                self.ty_bounds.pop();
-
-                // Propagate current bound to childs.
-                self.ty_bounds.push(last_bound);
-                self.visit_expr(then);
-                if let Some(else_) = else_ {
-                    self.visit_expr(else_);
-                }
-                self.ty_bounds.pop();
-                return;
-            },
-
-            (ExprKind::Loop(_, label, ..), last_bound) => {
-                self.break_ty_bounds.push((*label, last_bound));
-                walk_expr(self, expr);
-                self.break_ty_bounds.pop();
-                return;
-            },
-
-            (ExprKind::Match(arg, arms, _), last_bound) => {
-                // Match argument has no type bound.
-                self.ty_bounds.push(None);
-                self.visit_expr(arg);
-                for arm in arms.iter() {
-                    self.visit_pat(arm.pat);
-                    if let Some(Guard::If(guard)) = arm.guard {
-                        self.visit_expr(guard);
-                    }
-                }
-                self.ty_bounds.pop();
-
-                // Propagate current bound.
-                self.ty_bounds.push(last_bound);
-                for arm in arms.iter() {
-                    self.visit_expr(arm.body);
-                }
-                self.ty_bounds.pop();
-                return;
-            },
-
-            (ExprKind::Block(..), last_bound) => self.ty_bounds.push(last_bound),
-
-            (ExprKind::Break(destination, _), _) => {
-                let ty = destination.label.map_or_else(
-                    || self.break_ty_bounds.last().unwrap().1,
-                    |dest_label| {
-                        self.break_ty_bounds
-                            .iter()
-                            .rev()
-                            .find_map(|(loop_label, ty)| {
-                                loop_label.map_or(None, |loop_label| {
-                                    if loop_label.ident == dest_label.ident {
-                                        Some(*ty)
-                                    } else {
-                                        None
-                                    }
-                                })
-                            })
-                            .unwrap()
-                    },
-                );
-                self.ty_bounds.push(ty);
-            },
-
-            (ExprKind::Ret(_), _) => self.ty_bounds.push(self.ret_ty_bound),
-
-            (ExprKind::Struct(qpath, fields, base), _) => {
-                if_chain! {
-                    if let Some(def_id) = self.cx.qpath_res(qpath, expr.hir_id).opt_def_id();
-                    let ty = self.cx.tcx.type_of(def_id);
-                    if let Some(adt_def) = ty.ty_adt_def();
-                    if adt_def.is_struct();
-                    if let Some(variant) = adt_def.variants.iter().next();
-                    then {
-                        let fields_def = &variant.fields;
-
-                        // Push field type then visit each field expr.
-                        for field in fields.iter() {
-                            let field_ty =
-                                fields_def
-                                    .iter()
-                                    .find_map(|f_def| {
-                                        if f_def.ident == field.ident
-                                            { Some(self.cx.tcx.type_of(f_def.did)) }
-                                        else { None }
-                                    });
-                            self.ty_bounds.push(field_ty);
-                            self.visit_expr(field.expr);
-                            self.ty_bounds.pop();
-                        }
-
-                        // Visit base with no bound.
-                        if let Some(base) = base {
-                            self.ty_bounds.push(None);
-                            self.visit_expr(base);
-                            self.ty_bounds.pop();
-                        }
-                        return;
-                    }
-                }
-                self.ty_bounds.push(None);
-            },
-
-            _ => self.ty_bounds.push(None),
-        }
-
-        walk_expr(self, expr);
-        self.ty_bounds.pop();
-    }
-
-    fn visit_stmt(&mut self, stmt: &'tcx Stmt<'_>) {
-        match stmt.kind {
-            StmtKind::Local(local) => {
-                let ty = local.ty.and_then(|hir_ty| {
-                    if is_infer_included(hir_ty) {
-                        None
-                    } else {
-                        ty_from_hir_ty(self.cx, hir_ty)
-                    }
-                });
-                self.ty_bounds.push(ty);
-            },
-
-            _ => self.ty_bounds.push(None),
-        }
-
-        walk_stmt(self, stmt);
-        self.ty_bounds.pop();
-    }
-
-    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-        NestedVisitorMap::None
-    }
-}
-
-/// Return true if a given ty includes `hir::TyKind::Infer`.
-fn is_infer_included(ty: &hir::Ty<'_>) -> bool {
-    let mut infer_ty_finder = InferTyFinder::new();
-    infer_ty_finder.visit_ty(ty);
-    infer_ty_finder.found
-}
-
-struct InferTyFinder {
-    found: bool,
-}
-
-impl InferTyFinder {
-    fn new() -> Self {
-        Self { found: false }
-    }
-}
-
-impl<'tcx> Visitor<'tcx> for InferTyFinder {
-    type Map = Map<'tcx>;
-
-    fn visit_ty(&mut self, ty: &'tcx hir::Ty<'_>) {
-        match ty.kind {
-            hir::TyKind::Infer => {
-                self.found = true;
-            },
-            _ => {
-                walk_ty(self, ty);
-            },
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        let expr_ty = cx.typeck_results().expr_ty(expr);
+        let hir_id = expr.hir_id;
+        if_chain! {
+            if let ExprKind::Lit(ref lit) = expr.kind;
+            if matches!(lit.node,
+                        LitKind::Int(_, LitIntType::Unsuffixed) | LitKind::Float(_, LitFloatType::Unsuffixed));
+            if matches!(expr_ty.kind(), ty::Int(IntTy::I32) | ty::Float(FloatTy::F64));
+            if !self.bounded_inits.contains(&hir_id);
+            if !cx.tcx.hir().parent_iter(hir_id).any(|(ref hir_id, _)| self.bounded_inits.contains(hir_id));
+            then {
+                 span_lint_and_help(
+                    cx,
+                    DEFAULT_NUMERIC_FALLBACK,
+                    lit.span,
+                    "default numeric fallback might occur",
+                    None,
+                    "consider adding suffix to avoid default numeric fallback",
+                 )
+            }
         }
     }
-
-    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-        NestedVisitorMap::None
-    }
 }
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 642c1e68dac..6590613b93a 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1028,7 +1028,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box strings::StringAdd);
     store.register_late_pass(|| box implicit_return::ImplicitReturn);
     store.register_late_pass(|| box implicit_saturating_sub::ImplicitSaturatingSub);
-    store.register_late_pass(|| box default_numeric_fallback::DefaultNumericFallback);
+    store.register_late_pass(|| box default_numeric_fallback::DefaultNumericFallback::default());
 
     let msrv = conf.msrv.as_ref().and_then(|s| {
         parse_msrv(s, None, None).or_else(|| {
diff --git a/tests/ui/default_numeric_fallback.rs b/tests/ui/default_numeric_fallback.rs
index 90ee8ea0399..5ca5bc1e907 100644
--- a/tests/ui/default_numeric_fallback.rs
+++ b/tests/ui/default_numeric_fallback.rs
@@ -1,99 +1,18 @@
 #![warn(clippy::default_numeric_fallback)]
 #![allow(unused)]
-#![allow(clippy::never_loop)]
-#![allow(clippy::no_effect)]
-#![allow(clippy::unnecessary_operation)]
-
-fn ret_i31() -> i32 {
-    23
-}
-
-fn concrete_arg(x: i32) {}
-
-fn generic_arg<T>(t: T) {}
-
-struct ConcreteStruct {
-    x: i32,
-}
-
-struct GenericStruct<T> {
-    x: T,
-}
-
-struct StructForMethodCallTest {
-    x: i32,
-}
-
-impl StructForMethodCallTest {
-    fn concrete_arg(&self, x: i32) {}
-
-    fn generic_arg<T>(&self, t: T) {}
-}
 
 fn main() {
-    let s = StructForMethodCallTest { x: 10_i32 };
-
     // Bad.
-    let x = 22;
-    let x = 0.12;
-    let x: _ = 13;
-    let x: [_; 3] = [1, 2, 3];
-    let x: (_, i32) = (1, 2);
-
-    let x = if true { (1, 2) } else { (3, 4) };
-
-    let x = match 1 {
-        1 => 1,
-        _ => 2,
-    };
-
-    let x = loop {
-        break 1;
-    };
-
-    let x = 'outer0: loop {
-        {
-            'inner0: loop {
-                break 3;
-            }
-        };
-        break 2;
-    };
-
-    let x = GenericStruct { x: 1 };
-
-    generic_arg(10);
-    s.generic_arg(10);
-    let f = || -> _ { 1 };
+    let x = 1;
+    let x = 0.1;
+    let x = if true { 1 } else { 2 };
 
     // Good.
-    let x = 22_i32;
-    let x: f64 = 0.12;
-    let x = 0.12_f64;
-    let x: i32 = 13;
-    let x: [i32; 3] = [1, 2, 3];
-    let x: (i32, i32) = (1, 2);
-
-    let x: (i32, i32) = if true { (1, 2) } else { (3, 4) };
-
-    let x: i32 = match true {
-        true => 1,
-        _ => 2,
-    };
-
-    let x: i32 = loop {
-        break 1;
-    };
-
-    let x: i32 = 'outer1: loop {
-        'inner1: loop {
-            break 'outer1 3;
-        }
-    };
-
-    let x = ConcreteStruct { x: 1 };
-
-    concrete_arg(10);
-    s.concrete_arg(10);
-    let f = || -> i32 { 1 };
+    let x = 1_i32;
+    let x: i32 = 1;
+    let x: _ = 1;
+    let x = 0.1_f64;
+    let x: f64 = 0.1;
+    let x: _ = 0.1;
+    let x: _ = if true { 1 } else { 2 };
 }
diff --git a/tests/ui/default_numeric_fallback.stderr b/tests/ui/default_numeric_fallback.stderr
index 27629b994be..c36409a052c 100644
--- a/tests/ui/default_numeric_fallback.stderr
+++ b/tests/ui/default_numeric_fallback.stderr
@@ -1,187 +1,35 @@
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:37:13
+  --> $DIR/default_numeric_fallback.rs:6:13
    |
-LL |     let x = 22;
-   |             ^^
+LL |     let x = 1;
+   |             ^
    |
    = note: `-D clippy::default-numeric-fallback` implied by `-D warnings`
    = help: consider adding suffix to avoid default numeric fallback
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:38:13
+  --> $DIR/default_numeric_fallback.rs:7:13
    |
-LL |     let x = 0.12;
-   |             ^^^^
+LL |     let x = 0.1;
+   |             ^^^
    |
    = help: consider adding suffix to avoid default numeric fallback
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:39:16
+  --> $DIR/default_numeric_fallback.rs:8:23
    |
-LL |     let x: _ = 13;
-   |                ^^
-   |
-   = help: consider adding suffix to avoid default numeric fallback
-
-error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:40:22
-   |
-LL |     let x: [_; 3] = [1, 2, 3];
-   |                      ^
-   |
-   = help: consider adding suffix to avoid default numeric fallback
-
-error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:40:25
-   |
-LL |     let x: [_; 3] = [1, 2, 3];
-   |                         ^
-   |
-   = help: consider adding suffix to avoid default numeric fallback
-
-error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:40:28
-   |
-LL |     let x: [_; 3] = [1, 2, 3];
-   |                            ^
-   |
-   = help: consider adding suffix to avoid default numeric fallback
-
-error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:41:24
-   |
-LL |     let x: (_, i32) = (1, 2);
-   |                        ^
-   |
-   = help: consider adding suffix to avoid default numeric fallback
-
-error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:41:27
-   |
-LL |     let x: (_, i32) = (1, 2);
-   |                           ^
-   |
-   = help: consider adding suffix to avoid default numeric fallback
-
-error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:43:24
-   |
-LL |     let x = if true { (1, 2) } else { (3, 4) };
-   |                        ^
-   |
-   = help: consider adding suffix to avoid default numeric fallback
-
-error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:43:27
-   |
-LL |     let x = if true { (1, 2) } else { (3, 4) };
-   |                           ^
-   |
-   = help: consider adding suffix to avoid default numeric fallback
-
-error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:43:40
-   |
-LL |     let x = if true { (1, 2) } else { (3, 4) };
-   |                                        ^
-   |
-   = help: consider adding suffix to avoid default numeric fallback
-
-error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:43:43
-   |
-LL |     let x = if true { (1, 2) } else { (3, 4) };
-   |                                           ^
-   |
-   = help: consider adding suffix to avoid default numeric fallback
-
-error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:45:19
-   |
-LL |     let x = match 1 {
-   |                   ^
-   |
-   = help: consider adding suffix to avoid default numeric fallback
-
-error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:46:9
-   |
-LL |         1 => 1,
-   |         ^
-   |
-   = help: consider adding suffix to avoid default numeric fallback
-
-error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:46:14
-   |
-LL |         1 => 1,
-   |              ^
-   |
-   = help: consider adding suffix to avoid default numeric fallback
-
-error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:47:14
-   |
-LL |         _ => 2,
-   |              ^
-   |
-   = help: consider adding suffix to avoid default numeric fallback
-
-error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:51:15
-   |
-LL |         break 1;
-   |               ^
-   |
-   = help: consider adding suffix to avoid default numeric fallback
-
-error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:57:23
-   |
-LL |                 break 3;
+LL |     let x = if true { 1 } else { 2 };
    |                       ^
    |
    = help: consider adding suffix to avoid default numeric fallback
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:60:15
-   |
-LL |         break 2;
-   |               ^
-   |
-   = help: consider adding suffix to avoid default numeric fallback
-
-error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:63:32
-   |
-LL |     let x = GenericStruct { x: 1 };
-   |                                ^
-   |
-   = help: consider adding suffix to avoid default numeric fallback
-
-error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:65:17
-   |
-LL |     generic_arg(10);
-   |                 ^^
-   |
-   = help: consider adding suffix to avoid default numeric fallback
-
-error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:66:19
+  --> $DIR/default_numeric_fallback.rs:8:34
    |
-LL |     s.generic_arg(10);
-   |                   ^^
-   |
-   = help: consider adding suffix to avoid default numeric fallback
-
-error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:67:23
-   |
-LL |     let f = || -> _ { 1 };
-   |                       ^
+LL |     let x = if true { 1 } else { 2 };
+   |                                  ^
    |
    = help: consider adding suffix to avoid default numeric fallback
 
-error: aborting due to 23 previous errors
+error: aborting due to 4 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 1c3033d5cf903d19d8f3dcdfc01ba1dc55debf71 Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Mon, 8 Feb 2021 01:34:59 +0900
Subject: add a new lint `bytes_nth`

---
 CHANGELOG.md                          |  1 +
 clippy_lints/src/lib.rs               |  3 +++
 clippy_lints/src/methods/bytes_nth.rs | 39 +++++++++++++++++++++++++++++++++++
 clippy_lints/src/methods/mod.rs       | 25 ++++++++++++++++++++++
 tests/ui/bytes_nth.fixed              |  9 ++++++++
 tests/ui/bytes_nth.rs                 |  9 ++++++++
 tests/ui/bytes_nth.stderr             | 16 ++++++++++++++
 7 files changed, 102 insertions(+)
 create mode 100644 clippy_lints/src/methods/bytes_nth.rs
 create mode 100644 tests/ui/bytes_nth.fixed
 create mode 100644 tests/ui/bytes_nth.rs
 create mode 100644 tests/ui/bytes_nth.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index b74841c7794..7c79fe88816 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1877,6 +1877,7 @@ Released 2018-09-13
 [`box_vec`]: https://rust-lang.github.io/rust-clippy/master/index.html#box_vec
 [`boxed_local`]: https://rust-lang.github.io/rust-clippy/master/index.html#boxed_local
 [`builtin_type_shadow`]: https://rust-lang.github.io/rust-clippy/master/index.html#builtin_type_shadow
+[`bytes_nth`]: https://rust-lang.github.io/rust-clippy/master/index.html#bytes_nth
 [`cargo_common_metadata`]: https://rust-lang.github.io/rust-clippy/master/index.html#cargo_common_metadata
 [`case_sensitive_file_extension_comparisons`]: https://rust-lang.github.io/rust-clippy/master/index.html#case_sensitive_file_extension_comparisons
 [`cast_lossless`]: https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index fe4aa584b18..22d91c9d40d 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -734,6 +734,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &mem_replace::MEM_REPLACE_WITH_DEFAULT,
         &mem_replace::MEM_REPLACE_WITH_UNINIT,
         &methods::BIND_INSTEAD_OF_MAP,
+        &methods::BYTES_NTH,
         &methods::CHARS_LAST_CMP,
         &methods::CHARS_NEXT_CMP,
         &methods::CLONE_DOUBLE_REF,
@@ -1531,6 +1532,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&mem_replace::MEM_REPLACE_WITH_DEFAULT),
         LintId::of(&mem_replace::MEM_REPLACE_WITH_UNINIT),
         LintId::of(&methods::BIND_INSTEAD_OF_MAP),
+        LintId::of(&methods::BYTES_NTH),
         LintId::of(&methods::CHARS_LAST_CMP),
         LintId::of(&methods::CHARS_NEXT_CMP),
         LintId::of(&methods::CLONE_DOUBLE_REF),
@@ -1749,6 +1751,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&matches::SINGLE_MATCH),
         LintId::of(&mem_replace::MEM_REPLACE_OPTION_WITH_NONE),
         LintId::of(&mem_replace::MEM_REPLACE_WITH_DEFAULT),
+        LintId::of(&methods::BYTES_NTH),
         LintId::of(&methods::CHARS_LAST_CMP),
         LintId::of(&methods::CHARS_NEXT_CMP),
         LintId::of(&methods::FROM_ITER_INSTEAD_OF_COLLECT),
diff --git a/clippy_lints/src/methods/bytes_nth.rs b/clippy_lints/src/methods/bytes_nth.rs
new file mode 100644
index 00000000000..4f38db06c0a
--- /dev/null
+++ b/clippy_lints/src/methods/bytes_nth.rs
@@ -0,0 +1,39 @@
+use crate::utils::{is_type_diagnostic_item, snippet_with_applicability, span_lint_and_sugg};
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind};
+use rustc_lint::LateContext;
+use rustc_span::sym;
+
+use super::BYTES_NTH;
+
+pub(super) fn lints<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, iter_args: &'tcx [Expr<'tcx>]) {
+    if_chain! {
+        if let ExprKind::MethodCall(_, _, ref args, _) = expr.kind;
+        let ty = cx.typeck_results().expr_ty(&iter_args[0]).peel_refs();
+        let caller_type = if is_type_diagnostic_item(cx, ty, sym::string_type) {
+            Some("String")
+        } else if ty.is_str() {
+            Some("str")
+        } else {
+            None
+        };
+        if let Some(caller_type) = caller_type;
+        then {
+            let mut applicability = Applicability::MachineApplicable;
+            span_lint_and_sugg(
+                cx,
+                BYTES_NTH,
+                expr.span,
+                &format!("called `.byte().nth()` on a `{}`", caller_type),
+                "try calling `.as_bytes().get()`",
+                format!(
+                    "{}.as_bytes().get({})",
+                    snippet_with_applicability(cx, iter_args[0].span, "..", &mut applicability),
+                    snippet_with_applicability(cx, args[1].span, "..", &mut applicability)
+                ),
+                applicability,
+            );
+        }
+    }
+}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 3e34fc1aed1..4cb3a858511 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1,4 +1,5 @@
 mod bind_instead_of_map;
+mod bytes_nth;
 mod filter_map_identity;
 mod inefficient_to_string;
 mod inspect_for_each;
@@ -1490,6 +1491,28 @@ declare_clippy_lint! {
     "call to `filter_map` where `flatten` is sufficient"
 }
 
+declare_clippy_lint! {
+    /// **What it does:** Checks for the use of `.bytes().nth()`.
+    ///
+    /// **Why is this bad?** `.as_bytes().get()` is more efficient and more
+    /// readable.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// // Bad
+    /// let _ = "Hello".bytes().nth(3);;
+    ///
+    /// // Good
+    /// let _ = "Hello".as_bytes().get(3);
+    /// ```
+    pub BYTES_NTH,
+    style,
+    "replace `.bytes().nth()` with `.as_bytes().get()`"
+}
+
 pub struct Methods {
     msrv: Option<RustcVersion>,
 }
@@ -1537,6 +1560,7 @@ impl_lint_pass!(Methods => [
     ITER_NEXT_SLICE,
     ITER_NTH,
     ITER_NTH_ZERO,
+    BYTES_NTH,
     ITER_SKIP_NEXT,
     GET_UNWRAP,
     STRING_EXTEND_CHARS,
@@ -1614,6 +1638,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             ["extend", ..] => lint_extend(cx, expr, arg_lists[0]),
             ["nth", "iter"] => lint_iter_nth(cx, expr, &arg_lists, false),
             ["nth", "iter_mut"] => lint_iter_nth(cx, expr, &arg_lists, true),
+            ["nth", "bytes"] => bytes_nth::lints(cx, expr, &arg_lists[1]),
             ["nth", ..] => lint_iter_nth_zero(cx, expr, arg_lists[0]),
             ["step_by", ..] => lint_step_by(cx, expr, arg_lists[0]),
             ["next", "skip"] => lint_iter_skip_next(cx, expr, arg_lists[1]),
diff --git a/tests/ui/bytes_nth.fixed b/tests/ui/bytes_nth.fixed
new file mode 100644
index 00000000000..36bf8660a34
--- /dev/null
+++ b/tests/ui/bytes_nth.fixed
@@ -0,0 +1,9 @@
+// run-rustfix
+
+#![warn(clippy::bytes_nth)]
+
+fn main() {
+    let _ = "Hello".as_bytes().get(3);
+
+    let _ = String::from("Hello").as_bytes().get(3);
+}
diff --git a/tests/ui/bytes_nth.rs b/tests/ui/bytes_nth.rs
new file mode 100644
index 00000000000..257344c2d32
--- /dev/null
+++ b/tests/ui/bytes_nth.rs
@@ -0,0 +1,9 @@
+// run-rustfix
+
+#![warn(clippy::bytes_nth)]
+
+fn main() {
+    let _ = "Hello".bytes().nth(3);
+
+    let _ = String::from("Hello").bytes().nth(3);
+}
diff --git a/tests/ui/bytes_nth.stderr b/tests/ui/bytes_nth.stderr
new file mode 100644
index 00000000000..b46a0736414
--- /dev/null
+++ b/tests/ui/bytes_nth.stderr
@@ -0,0 +1,16 @@
+error: called `.byte().nth()` on a `str`
+  --> $DIR/bytes_nth.rs:6:13
+   |
+LL |     let _ = "Hello".bytes().nth(3);
+   |             ^^^^^^^^^^^^^^^^^^^^^^ help: try calling `.as_bytes().get()`: `"Hello".as_bytes().get(3)`
+   |
+   = note: `-D clippy::bytes-nth` implied by `-D warnings`
+
+error: called `.byte().nth()` on a `String`
+  --> $DIR/bytes_nth.rs:8:13
+   |
+LL |     let _ = String::from("Hello").bytes().nth(3);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try calling `.as_bytes().get()`: `String::from("Hello").as_bytes().get(3)`
+
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From fd35517bd47372a4c9bbd436f3d6885cdc452e7f Mon Sep 17 00:00:00 2001
From: David Tolnay <dtolnay@gmail.com>
Date: Sun, 7 Feb 2021 16:54:09 -0800
Subject: Downgrade trivial_regex to nursery

---
 clippy_lints/src/lib.rs   | 3 +--
 clippy_lints/src/regex.rs | 6 ++++--
 2 files changed, 5 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index fe4aa584b18..6e693ccd75c 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1628,7 +1628,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&reference::DEREF_ADDROF),
         LintId::of(&reference::REF_IN_DEREF),
         LintId::of(&regex::INVALID_REGEX),
-        LintId::of(&regex::TRIVIAL_REGEX),
         LintId::of(&repeat_once::REPEAT_ONCE),
         LintId::of(&returns::LET_AND_RETURN),
         LintId::of(&returns::NEEDLESS_RETURN),
@@ -1791,7 +1790,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&ranges::MANUAL_RANGE_CONTAINS),
         LintId::of(&redundant_field_names::REDUNDANT_FIELD_NAMES),
         LintId::of(&redundant_static_lifetimes::REDUNDANT_STATIC_LIFETIMES),
-        LintId::of(&regex::TRIVIAL_REGEX),
         LintId::of(&returns::LET_AND_RETURN),
         LintId::of(&returns::NEEDLESS_RETURN),
         LintId::of(&single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS),
@@ -2021,6 +2019,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&needless_borrow::NEEDLESS_BORROW),
         LintId::of(&path_buf_push_overwrite::PATH_BUF_PUSH_OVERWRITE),
         LintId::of(&redundant_pub_crate::REDUNDANT_PUB_CRATE),
+        LintId::of(&regex::TRIVIAL_REGEX),
         LintId::of(&strings::STRING_LIT_AS_BYTES),
         LintId::of(&transmute::USELESS_TRANSMUTE),
         LintId::of(&use_self::USE_SELF),
diff --git a/clippy_lints/src/regex.rs b/clippy_lints/src/regex.rs
index d06ab143482..1edea613148 100644
--- a/clippy_lints/src/regex.rs
+++ b/clippy_lints/src/regex.rs
@@ -35,14 +35,16 @@ declare_clippy_lint! {
     /// `str::starts_with`, `str::ends_with` or `std::contains` or other `str`
     /// methods.
     ///
-    /// **Known problems:** None.
+    /// **Known problems:** If the same regex is going to be applied to multiple
+    /// inputs, the precomputations done by `Regex` construction can give
+    /// significantly better performance than any of the `str`-based methods.
     ///
     /// **Example:**
     /// ```ignore
     /// Regex::new("^foobar")
     /// ```
     pub TRIVIAL_REGEX,
-    style,
+    nursery,
     "trivial regular expressions"
 }
 
-- 
cgit 1.4.1-3-g733a5


From c44eafdcd7a20bfe1af761d07a7ad8aaf5254d91 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Fri, 5 Feb 2021 16:27:23 -0600
Subject: Use id instead of name

---
 clippy_lints/src/vec_init_then_push.rs | 23 +++++++++++------------
 1 file changed, 11 insertions(+), 12 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/vec_init_then_push.rs b/clippy_lints/src/vec_init_then_push.rs
index e632a7e57ee..4768cb4830b 100644
--- a/clippy_lints/src/vec_init_then_push.rs
+++ b/clippy_lints/src/vec_init_then_push.rs
@@ -1,12 +1,14 @@
-use crate::utils::{is_type_diagnostic_item, match_def_path, paths, snippet, span_lint_and_sugg};
+use crate::utils::{
+    is_type_diagnostic_item, match_def_path, path_to_local, path_to_local_id, paths, snippet, span_lint_and_sugg,
+};
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
-use rustc_hir::{BindingAnnotation, Block, Expr, ExprKind, Local, PatKind, QPath, Stmt, StmtKind};
+use rustc_hir::{BindingAnnotation, Block, Expr, ExprKind, HirId, Local, PatKind, QPath, Stmt, StmtKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::{symbol::sym, Span, Symbol};
+use rustc_span::{symbol::sym, Span};
 use std::convert::TryInto;
 
 declare_clippy_lint! {
@@ -45,8 +47,8 @@ enum VecInitKind {
     WithCapacity(u64),
 }
 struct VecPushSearcher {
+    local_id: HirId,
     init: VecInitKind,
-    name: Symbol,
     lhs_is_local: bool,
     lhs_span: Span,
     err_span: Span,
@@ -86,12 +88,12 @@ impl LateLintPass<'_> for VecInitThenPush {
         if_chain! {
             if !in_external_macro(cx.sess(), local.span);
             if let Some(init) = local.init;
-            if let PatKind::Binding(BindingAnnotation::Mutable, _, ident, None) = local.pat.kind;
+            if let PatKind::Binding(BindingAnnotation::Mutable, id, _, None) = local.pat.kind;
             if let Some(init_kind) = get_vec_init_kind(cx, init);
             then {
                 self.searcher = Some(VecPushSearcher {
+                        local_id: id,
                         init: init_kind,
-                        name: ident.name,
                         lhs_is_local: true,
                         lhs_span: local.ty.map_or(local.pat.span, |t| local.pat.span.to(t.span)),
                         err_span: local.span,
@@ -106,13 +108,12 @@ impl LateLintPass<'_> for VecInitThenPush {
             if_chain! {
                 if !in_external_macro(cx.sess(), expr.span);
                 if let ExprKind::Assign(left, right, _) = expr.kind;
-                if let ExprKind::Path(QPath::Resolved(_, path)) = left.kind;
-                if let Some(name) = path.segments.get(0);
+                if let Some(id) = path_to_local(left);
                 if let Some(init_kind) = get_vec_init_kind(cx, right);
                 then {
                     self.searcher = Some(VecPushSearcher {
+                        local_id: id,
                         init: init_kind,
-                        name: name.ident.name,
                         lhs_is_local: false,
                         lhs_span: left.span,
                         err_span: expr.span,
@@ -128,10 +129,8 @@ impl LateLintPass<'_> for VecInitThenPush {
             if_chain! {
                 if let StmtKind::Expr(expr) | StmtKind::Semi(expr) = stmt.kind;
                 if let ExprKind::MethodCall(path, _, [self_arg, _], _) = expr.kind;
+                if path_to_local_id(self_arg, searcher.local_id);
                 if path.ident.name.as_str() == "push";
-                if let ExprKind::Path(QPath::Resolved(_, self_path)) = self_arg.kind;
-                if let [self_name] = self_path.segments;
-                if self_name.ident.name == searcher.name;
                 then {
                     self.searcher = Some(VecPushSearcher {
                         found: searcher.found + 1,
-- 
cgit 1.4.1-3-g733a5


From a42be8589a0b380da18a78da4c81205ff8086243 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Fri, 5 Feb 2021 16:28:13 -0600
Subject: Fix vec_init_then_push FP

---
 clippy_lints/src/vec_init_then_push.rs |  5 ++++-
 tests/ui/vec_init_then_push.rs         | 25 +++++++++++++++++++++++++
 tests/ui/vec_init_then_push.stderr     |  2 +-
 3 files changed, 30 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/vec_init_then_push.rs b/clippy_lints/src/vec_init_then_push.rs
index 4768cb4830b..8d111f98add 100644
--- a/clippy_lints/src/vec_init_then_push.rs
+++ b/clippy_lints/src/vec_init_then_push.rs
@@ -83,8 +83,11 @@ impl VecPushSearcher {
 }
 
 impl LateLintPass<'_> for VecInitThenPush {
-    fn check_local(&mut self, cx: &LateContext<'tcx>, local: &'tcx Local<'tcx>) {
+    fn check_block(&mut self, _: &LateContext<'tcx>, _: &'tcx Block<'tcx>) {
         self.searcher = None;
+    }
+
+    fn check_local(&mut self, cx: &LateContext<'tcx>, local: &'tcx Local<'tcx>) {
         if_chain! {
             if !in_external_macro(cx.sess(), local.span);
             if let Some(init) = local.init;
diff --git a/tests/ui/vec_init_then_push.rs b/tests/ui/vec_init_then_push.rs
index 642ce504009..5099aad83bc 100644
--- a/tests/ui/vec_init_then_push.rs
+++ b/tests/ui/vec_init_then_push.rs
@@ -12,10 +12,35 @@ fn main() {
     cap_err.push(0);
     cap_err.push(1);
     cap_err.push(2);
+    if true {
+        // don't include this one
+        cap_err.push(3);
+    }
 
     let mut cap_ok = Vec::with_capacity(10);
     cap_ok.push(0);
 
     new_err = Vec::new();
     new_err.push(0);
+
+    let mut vec = Vec::new();
+    // control flow at block final expression
+    if true {
+        // no lint
+        vec.push(1);
+    }
+}
+
+pub fn no_lint() -> Vec<i32> {
+    let mut p = Some(1);
+    let mut vec = Vec::new();
+    loop {
+        match p {
+            None => return vec,
+            Some(i) => {
+                vec.push(i);
+                p = None;
+            },
+        }
+    }
 }
diff --git a/tests/ui/vec_init_then_push.stderr b/tests/ui/vec_init_then_push.stderr
index 819ed47d099..9ec3e10e624 100644
--- a/tests/ui/vec_init_then_push.stderr
+++ b/tests/ui/vec_init_then_push.stderr
@@ -24,7 +24,7 @@ LL | |     cap_err.push(2);
    | |____________________^ help: consider using the `vec![]` macro: `let mut cap_err = vec![..];`
 
 error: calls to `push` immediately after creation
-  --> $DIR/vec_init_then_push.rs:19:5
+  --> $DIR/vec_init_then_push.rs:23:5
    |
 LL | /     new_err = Vec::new();
 LL | |     new_err.push(0);
-- 
cgit 1.4.1-3-g733a5


From 1d3042294503e6027759baadc92056403aa8c991 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Wed, 3 Feb 2021 11:35:16 -0600
Subject: Enhance LocalUsedVisitor to check closure bodies

---
 clippy_lints/src/collapsible_match.rs |  9 ++++-----
 clippy_lints/src/let_if_seq.rs        | 17 +++++++++++------
 clippy_lints/src/loops.rs             | 10 +++++-----
 clippy_lints/src/matches.rs           |  6 ++++--
 clippy_lints/src/utils/visitors.rs    | 21 +++++++++++++--------
 tests/ui/collapsible_match.rs         |  8 ++++++++
 6 files changed, 45 insertions(+), 26 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/collapsible_match.rs b/clippy_lints/src/collapsible_match.rs
index 834f294283e..75a973fe37e 100644
--- a/clippy_lints/src/collapsible_match.rs
+++ b/clippy_lints/src/collapsible_match.rs
@@ -60,7 +60,7 @@ impl<'tcx> LateLintPass<'tcx> for CollapsibleMatch {
     }
 }
 
-fn check_arm(arm: &Arm<'_>, wild_outer_arm: &Arm<'_>, cx: &LateContext<'_>) {
+fn check_arm<'tcx>(arm: &Arm<'tcx>, wild_outer_arm: &Arm<'tcx>, cx: &LateContext<'tcx>) {
     if_chain! {
         let expr = strip_singleton_blocks(arm.body);
         if let ExprKind::Match(expr_in, arms_inner, _) = expr.kind;
@@ -84,14 +84,13 @@ fn check_arm(arm: &Arm<'_>, wild_outer_arm: &Arm<'_>, cx: &LateContext<'_>) {
         // the "wild-like" branches must be equal
         if SpanlessEq::new(cx).eq_expr(wild_inner_arm.body, wild_outer_arm.body);
         // the binding must not be used in the if guard
+        let mut used_visitor = LocalUsedVisitor::new(cx, binding_id);
         if match arm.guard {
             None => true,
-            Some(Guard::If(expr) | Guard::IfLet(_, expr)) => {
-                !LocalUsedVisitor::new(binding_id).check_expr(expr)
-            }
+            Some(Guard::If(expr) | Guard::IfLet(_, expr)) => !used_visitor.check_expr(expr),
         };
         // ...or anywhere in the inner match
-        if !arms_inner.iter().any(|arm| LocalUsedVisitor::new(binding_id).check_arm(arm));
+        if !arms_inner.iter().any(|arm| used_visitor.check_arm(arm));
         then {
             span_lint_and_then(
                 cx,
diff --git a/clippy_lints/src/let_if_seq.rs b/clippy_lints/src/let_if_seq.rs
index 6beaa51729a..5863eef8a26 100644
--- a/clippy_lints/src/let_if_seq.rs
+++ b/clippy_lints/src/let_if_seq.rs
@@ -63,10 +63,11 @@ impl<'tcx> LateLintPass<'tcx> for LetIfSeq {
                 if let hir::PatKind::Binding(mode, canonical_id, ident, None) = local.pat.kind;
                 if let hir::StmtKind::Expr(ref if_) = expr.kind;
                 if let hir::ExprKind::If(ref cond, ref then, ref else_) = if_.kind;
-                if !LocalUsedVisitor::new(canonical_id).check_expr(cond);
+                let mut used_visitor = LocalUsedVisitor::new(cx, canonical_id);
+                if !used_visitor.check_expr(cond);
                 if let hir::ExprKind::Block(ref then, _) = then.kind;
-                if let Some(value) = check_assign(canonical_id, &*then);
-                if !LocalUsedVisitor::new(canonical_id).check_expr(value);
+                if let Some(value) = check_assign(cx, canonical_id, &*then);
+                if !used_visitor.check_expr(value);
                 then {
                     let span = stmt.span.to(if_.span);
 
@@ -78,7 +79,7 @@ impl<'tcx> LateLintPass<'tcx> for LetIfSeq {
 
                     let (default_multi_stmts, default) = if let Some(ref else_) = *else_ {
                         if let hir::ExprKind::Block(ref else_, _) = else_.kind {
-                            if let Some(default) = check_assign(canonical_id, else_) {
+                            if let Some(default) = check_assign(cx, canonical_id, else_) {
                                 (else_.stmts.len() > 1, default)
                             } else if let Some(ref default) = local.init {
                                 (true, &**default)
@@ -133,7 +134,11 @@ impl<'tcx> LateLintPass<'tcx> for LetIfSeq {
     }
 }
 
-fn check_assign<'tcx>(decl: hir::HirId, block: &'tcx hir::Block<'_>) -> Option<&'tcx hir::Expr<'tcx>> {
+fn check_assign<'tcx>(
+    cx: &LateContext<'tcx>,
+    decl: hir::HirId,
+    block: &'tcx hir::Block<'_>,
+) -> Option<&'tcx hir::Expr<'tcx>> {
     if_chain! {
         if block.expr.is_none();
         if let Some(expr) = block.stmts.iter().last();
@@ -141,7 +146,7 @@ fn check_assign<'tcx>(decl: hir::HirId, block: &'tcx hir::Block<'_>) -> Option<&
         if let hir::ExprKind::Assign(ref var, ref value, _) = expr.kind;
         if path_to_local_id(var, decl);
         then {
-            let mut v = LocalUsedVisitor::new(decl);
+            let mut v = LocalUsedVisitor::new(cx, decl);
 
             if block.stmts.iter().take(block.stmts.len()-1).any(|stmt| v.check_stmt(stmt)) {
                 return None;
diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index b5a9632ee19..eb185377e20 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -1893,8 +1893,8 @@ fn check_for_loop_over_map_kv<'tcx>(
             let arg_span = arg.span;
             let (new_pat_span, kind, ty, mutbl) = match *cx.typeck_results().expr_ty(arg).kind() {
                 ty::Ref(_, ty, mutbl) => match (&pat[0].kind, &pat[1].kind) {
-                    (key, _) if pat_is_wild(key, body) => (pat[1].span, "value", ty, mutbl),
-                    (_, value) if pat_is_wild(value, body) => (pat[0].span, "key", ty, Mutability::Not),
+                    (key, _) if pat_is_wild(cx, key, body) => (pat[1].span, "value", ty, mutbl),
+                    (_, value) if pat_is_wild(cx, value, body) => (pat[0].span, "key", ty, Mutability::Not),
                     _ => return,
                 },
                 _ => return,
@@ -2145,11 +2145,11 @@ fn check_for_mutation<'tcx>(
 }
 
 /// Returns `true` if the pattern is a `PatWild` or an ident prefixed with `_`.
-fn pat_is_wild<'tcx>(pat: &'tcx PatKind<'_>, body: &'tcx Expr<'_>) -> bool {
+fn pat_is_wild<'tcx>(cx: &LateContext<'tcx>, pat: &'tcx PatKind<'_>, body: &'tcx Expr<'_>) -> bool {
     match *pat {
         PatKind::Wild => true,
         PatKind::Binding(_, id, ident, None) if ident.as_str().starts_with('_') => {
-            !LocalUsedVisitor::new(id).check_expr(body)
+            !LocalUsedVisitor::new(cx, id).check_expr(body)
         },
         _ => false,
     }
@@ -2188,7 +2188,7 @@ impl<'a, 'tcx> VarVisitor<'a, 'tcx> {
             then {
                 let index_used_directly = path_to_local_id(idx, self.var);
                 let indexed_indirectly = {
-                    let mut used_visitor = LocalUsedVisitor::new(self.var);
+                    let mut used_visitor = LocalUsedVisitor::new(self.cx, self.var);
                     walk_expr(&mut used_visitor, idx);
                     used_visitor.used
                 };
diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index c4aa2b30e7b..e33001b16bc 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -911,7 +911,7 @@ fn check_overlapping_arms<'tcx>(cx: &LateContext<'tcx>, ex: &'tcx Expr<'_>, arms
     }
 }
 
-fn check_wild_err_arm(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>]) {
+fn check_wild_err_arm<'tcx>(cx: &LateContext<'tcx>, ex: &Expr<'tcx>, arms: &[Arm<'tcx>]) {
     let ex_ty = cx.typeck_results().expr_ty(ex).peel_refs();
     if is_type_diagnostic_item(cx, ex_ty, sym::result_type) {
         for arm in arms {
@@ -924,7 +924,9 @@ fn check_wild_err_arm(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>]) {
                         // Looking for unused bindings (i.e.: `_e`)
                         inner.iter().for_each(|pat| {
                             if let PatKind::Binding(_, id, ident, None) = pat.kind {
-                                if ident.as_str().starts_with('_') && !LocalUsedVisitor::new(id).check_expr(arm.body) {
+                                if ident.as_str().starts_with('_')
+                                    && !LocalUsedVisitor::new(cx, id).check_expr(arm.body)
+                                {
                                     ident_bind_name = (&ident.name.as_str()).to_string();
                                     matching_wild = true;
                                 }
diff --git a/clippy_lints/src/utils/visitors.rs b/clippy_lints/src/utils/visitors.rs
index a4064c3e705..24409346ca6 100644
--- a/clippy_lints/src/utils/visitors.rs
+++ b/clippy_lints/src/utils/visitors.rs
@@ -133,14 +133,16 @@ where
     }
 }
 
-pub struct LocalUsedVisitor {
+pub struct LocalUsedVisitor<'hir> {
+    hir: Map<'hir>,
     pub local_hir_id: HirId,
     pub used: bool,
 }
 
-impl LocalUsedVisitor {
-    pub fn new(local_hir_id: HirId) -> Self {
+impl<'hir> LocalUsedVisitor<'hir> {
+    pub fn new(cx: &LateContext<'hir>, local_hir_id: HirId) -> Self {
         Self {
+            hir: cx.tcx.hir(),
             local_hir_id,
             used: false,
         }
@@ -151,23 +153,26 @@ impl LocalUsedVisitor {
         std::mem::replace(&mut self.used, false)
     }
 
-    pub fn check_arm(&mut self, arm: &Arm<'_>) -> bool {
+    pub fn check_arm(&mut self, arm: &'hir Arm<'_>) -> bool {
         self.check(arm, Self::visit_arm)
     }
 
-    pub fn check_expr(&mut self, expr: &Expr<'_>) -> bool {
+    pub fn check_expr(&mut self, expr: &'hir Expr<'_>) -> bool {
         self.check(expr, Self::visit_expr)
     }
 
-    pub fn check_stmt(&mut self, stmt: &Stmt<'_>) -> bool {
+    pub fn check_stmt(&mut self, stmt: &'hir Stmt<'_>) -> bool {
         self.check(stmt, Self::visit_stmt)
     }
 }
 
-impl<'v> Visitor<'v> for LocalUsedVisitor {
+impl<'v> Visitor<'v> for LocalUsedVisitor<'v> {
     type Map = Map<'v>;
 
     fn visit_expr(&mut self, expr: &'v Expr<'v>) {
+        if self.used {
+            return;
+        }
         if path_to_local_id(expr, self.local_hir_id) {
             self.used = true;
         } else {
@@ -176,6 +181,6 @@ impl<'v> Visitor<'v> for LocalUsedVisitor {
     }
 
     fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-        NestedVisitorMap::None
+        NestedVisitorMap::OnlyBodies(self.hir)
     }
 }
diff --git a/tests/ui/collapsible_match.rs b/tests/ui/collapsible_match.rs
index a83e6c77b12..3294da7e814 100644
--- a/tests/ui/collapsible_match.rs
+++ b/tests/ui/collapsible_match.rs
@@ -224,6 +224,14 @@ fn negative_cases(res_opt: Result<Option<u32>, String>, res_res: Result<Result<u
         },
         _ => return,
     }
+    if let Ok(val) = res_opt {
+        if let Some(n) = val {
+            let _ = || {
+                // usage in closure
+                println!("{:?}", val);
+            };
+        }
+    }
 }
 
 fn make<T>() -> T {
-- 
cgit 1.4.1-3-g733a5


From 5db48a382a928969be301ee416df27f6508105c2 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Wed, 3 Feb 2021 11:45:16 -0600
Subject: Refactor out UnusedSelfVisitor

---
 clippy_lints/src/unused_self.rs    | 39 +++-----------------------------------
 clippy_lints/src/utils/visitors.rs |  6 +++++-
 2 files changed, 8 insertions(+), 37 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unused_self.rs b/clippy_lints/src/unused_self.rs
index 5349c4f7eb8..9d61bd0cc2f 100644
--- a/clippy_lints/src/unused_self.rs
+++ b/clippy_lints/src/unused_self.rs
@@ -1,12 +1,10 @@
 use if_chain::if_chain;
-use rustc_hir::def::Res;
-use rustc_hir::intravisit::{walk_path, NestedVisitorMap, Visitor};
-use rustc_hir::{HirId, Impl, ImplItem, ImplItemKind, ItemKind, Path};
+use rustc_hir::{Impl, ImplItem, ImplItemKind, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::hir::map::Map;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 use crate::utils::span_lint_and_help;
+use crate::utils::visitors::LocalUsedVisitor;
 
 declare_clippy_lint! {
     /// **What it does:** Checks methods that contain a `self` argument but don't use it
@@ -57,13 +55,7 @@ impl<'tcx> LateLintPass<'tcx> for UnusedSelf {
             then {
                 let self_param = &body.params[0];
                 let self_hir_id = self_param.pat.hir_id;
-                let mut visitor = UnusedSelfVisitor {
-                    cx,
-                    uses_self: false,
-                    self_hir_id: &self_hir_id,
-                };
-                visitor.visit_body(body);
-                if !visitor.uses_self {
+                if !LocalUsedVisitor::new(cx, self_hir_id).check_body(body) {
                     span_lint_and_help(
                         cx,
                         UNUSED_SELF,
@@ -78,28 +70,3 @@ impl<'tcx> LateLintPass<'tcx> for UnusedSelf {
         }
     }
 }
-
-struct UnusedSelfVisitor<'a, 'tcx> {
-    cx: &'a LateContext<'tcx>,
-    uses_self: bool,
-    self_hir_id: &'a HirId,
-}
-
-impl<'a, 'tcx> Visitor<'tcx> for UnusedSelfVisitor<'a, 'tcx> {
-    type Map = Map<'tcx>;
-
-    fn visit_path(&mut self, path: &'tcx Path<'_>, _id: HirId) {
-        if self.uses_self {
-            // This function already uses `self`
-            return;
-        }
-        if let Res::Local(hir_id) = &path.res {
-            self.uses_self = self.self_hir_id == hir_id
-        }
-        walk_path(self, path);
-    }
-
-    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-        NestedVisitorMap::OnlyBodies(self.cx.tcx.hir())
-    }
-}
diff --git a/clippy_lints/src/utils/visitors.rs b/clippy_lints/src/utils/visitors.rs
index 24409346ca6..085c1f9c0cb 100644
--- a/clippy_lints/src/utils/visitors.rs
+++ b/clippy_lints/src/utils/visitors.rs
@@ -1,7 +1,7 @@
 use crate::utils::path_to_local_id;
 use rustc_hir as hir;
 use rustc_hir::intravisit::{self, walk_expr, NestedVisitorMap, Visitor};
-use rustc_hir::{Arm, Expr, HirId, Stmt};
+use rustc_hir::{Arm, Body, Expr, HirId, Stmt};
 use rustc_lint::LateContext;
 use rustc_middle::hir::map::Map;
 
@@ -157,6 +157,10 @@ impl<'hir> LocalUsedVisitor<'hir> {
         self.check(arm, Self::visit_arm)
     }
 
+    pub fn check_body(&mut self, body: &'hir Body<'_>) -> bool {
+        self.check(body, Self::visit_body)
+    }
+
     pub fn check_expr(&mut self, expr: &'hir Expr<'_>) -> bool {
         self.check(expr, Self::visit_expr)
     }
-- 
cgit 1.4.1-3-g733a5


From 37555f8f73baf82b7761db56e7440c79a956b9ec Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Mon, 8 Feb 2021 09:50:13 -0600
Subject: Use path_to_local_id

---
 clippy_lints/src/methods/filter_map_identity.rs | 10 +++-------
 1 file changed, 3 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/filter_map_identity.rs b/clippy_lints/src/methods/filter_map_identity.rs
index d04e4be87ac..9e646360a40 100644
--- a/clippy_lints/src/methods/filter_map_identity.rs
+++ b/clippy_lints/src/methods/filter_map_identity.rs
@@ -1,4 +1,4 @@
-use crate::utils::{match_qpath, match_trait_method, paths, span_lint_and_sugg};
+use crate::utils::{match_qpath, match_trait_method, path_to_local_id, paths, span_lint_and_sugg};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
@@ -32,12 +32,8 @@ pub(super) fn check(
             if let hir::ExprKind::Closure(_, _, body_id, _, _) = arg_node;
             let body = cx.tcx.hir().body(*body_id);
 
-            if let hir::PatKind::Binding(_, _, binding_ident, _) = body.params[0].pat.kind;
-            if let hir::ExprKind::Path(hir::QPath::Resolved(_, ref path)) = body.value.kind;
-
-            if path.segments.len() == 1;
-            if path.segments[0].ident.name == binding_ident.name;
-
+            if let hir::PatKind::Binding(_, binding_id, ..) = body.params[0].pat.kind;
+            if path_to_local_id(&body.value, binding_id);
             then {
                 apply_lint("called `filter_map(|x| x)` on an `Iterator`");
             }
-- 
cgit 1.4.1-3-g733a5


From 6c73f989e2682b0fde6759428df27e6f8aacd656 Mon Sep 17 00:00:00 2001
From: daxpedda <daxpedda@gmail.com>
Date: Mon, 8 Feb 2021 17:25:10 +0100
Subject: Fix missing_panics_doc warning on `unreachable!`.

---
 clippy_lints/src/doc.rs | 5 +++--
 tests/ui/doc_panics.rs  | 5 +++++
 2 files changed, 8 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/doc.rs b/clippy_lints/src/doc.rs
index 1348f7530f4..ae06c2c60be 100644
--- a/clippy_lints/src/doc.rs
+++ b/clippy_lints/src/doc.rs
@@ -1,6 +1,6 @@
 use crate::utils::{
-    implements_trait, is_entrypoint_fn, is_type_diagnostic_item, match_panic_def_id, method_chain_args, return_ty,
-    span_lint, span_lint_and_note,
+    implements_trait, is_entrypoint_fn, is_expn_of, is_type_diagnostic_item, match_panic_def_id, method_chain_args,
+    return_ty, span_lint, span_lint_and_note,
 };
 use if_chain::if_chain;
 use itertools::Itertools;
@@ -699,6 +699,7 @@ impl<'a, 'tcx> Visitor<'tcx> for FindPanicUnwrap<'a, 'tcx> {
             if let ExprKind::Path(QPath::Resolved(_, ref path)) = func_expr.kind;
             if let Some(path_def_id) = path.res.opt_def_id();
             if match_panic_def_id(self.cx, path_def_id);
+            if is_expn_of(expr.span, "unreachable").is_none();
             then {
                 self.panic_span = Some(expr.span);
             }
diff --git a/tests/ui/doc_panics.rs b/tests/ui/doc_panics.rs
index 7ef932f367b..a3b9cbb5114 100644
--- a/tests/ui/doc_panics.rs
+++ b/tests/ui/doc_panics.rs
@@ -93,3 +93,8 @@ fn inner_body_private(opt: Option<u32>) {
         }
     });
 }
+
+/// This is okay because unreachable
+pub fn unreachable() {
+    unreachable!("This function panics")
+}
-- 
cgit 1.4.1-3-g733a5


From 10213277815cdf4d32ccadf17ae47aa03b5399cd Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Mon, 8 Feb 2021 10:51:40 -0600
Subject: Simplify if_chain

---
 clippy_lints/src/collapsible_if.rs | 11 +++--------
 1 file changed, 3 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/collapsible_if.rs b/clippy_lints/src/collapsible_if.rs
index 93ccc76d0c9..9edd85c8d17 100644
--- a/clippy_lints/src/collapsible_if.rs
+++ b/clippy_lints/src/collapsible_if.rs
@@ -144,15 +144,10 @@ fn check_collapsible_no_if_let(cx: &EarlyContext<'_>, expr: &ast::Expr, check: &
         if !block_starts_with_comment(cx, then);
         if let Some(inner) = expr_block(then);
         if let ast::ExprKind::If(ref check_inner, ref content, None) = inner.kind;
+        // Prevent triggering on `if c { if let a = b { .. } }`.
+        if !matches!(check_inner.kind, ast::ExprKind::Let(..));
+        if expr.span.ctxt() == inner.span.ctxt();
         then {
-            if let ast::ExprKind::Let(..) = check_inner.kind {
-                // Prevent triggering on `if c { if let a = b { .. } }`.
-                return;
-            }
-
-            if expr.span.ctxt() != inner.span.ctxt() {
-                return;
-            }
             span_lint_and_then(cx, COLLAPSIBLE_IF, expr.span, "this `if` statement can be collapsed", |diag| {
                 let lhs = Sugg::ast(cx, check, "..");
                 let rhs = Sugg::ast(cx, check_inner, "..");
-- 
cgit 1.4.1-3-g733a5


From 39ba449c2ad563d4840f623b35d05e96e0c2c43f Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Mon, 8 Feb 2021 11:00:30 -0600
Subject: Fix collapsible_if false positive with attributes

---
 clippy_lints/src/collapsible_if.rs | 2 ++
 tests/ui/collapsible_else_if.fixed | 9 +++++++++
 tests/ui/collapsible_else_if.rs    | 9 +++++++++
 tests/ui/collapsible_if.fixed      | 7 +++++++
 tests/ui/collapsible_if.rs         | 7 +++++++
 5 files changed, 34 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/collapsible_if.rs b/clippy_lints/src/collapsible_if.rs
index 9edd85c8d17..34f0e6ab027 100644
--- a/clippy_lints/src/collapsible_if.rs
+++ b/clippy_lints/src/collapsible_if.rs
@@ -122,6 +122,7 @@ fn check_collapsible_maybe_if_let(cx: &EarlyContext<'_>, else_: &ast::Expr) {
         if let ast::ExprKind::Block(ref block, _) = else_.kind;
         if !block_starts_with_comment(cx, block);
         if let Some(else_) = expr_block(block);
+        if else_.attrs.is_empty();
         if !else_.span.from_expansion();
         if let ast::ExprKind::If(..) = else_.kind;
         then {
@@ -143,6 +144,7 @@ fn check_collapsible_no_if_let(cx: &EarlyContext<'_>, expr: &ast::Expr, check: &
     if_chain! {
         if !block_starts_with_comment(cx, then);
         if let Some(inner) = expr_block(then);
+        if inner.attrs.is_empty();
         if let ast::ExprKind::If(ref check_inner, ref content, None) = inner.kind;
         // Prevent triggering on `if c { if let a = b { .. } }`.
         if !matches!(check_inner.kind, ast::ExprKind::Let(..));
diff --git a/tests/ui/collapsible_else_if.fixed b/tests/ui/collapsible_else_if.fixed
index fa4bc30e933..c69a46f0a77 100644
--- a/tests/ui/collapsible_else_if.fixed
+++ b/tests/ui/collapsible_else_if.fixed
@@ -65,4 +65,13 @@ fn main() {
     else {
         println!("!")
     }
+
+    if x == "hello" {
+        print!("Hello ");
+    } else {
+        #[cfg(not(roflol))]
+        if y == "world" {
+            println!("world!")
+        }
+    }
 }
diff --git a/tests/ui/collapsible_else_if.rs b/tests/ui/collapsible_else_if.rs
index bf6c1d1f894..1359c7eb627 100644
--- a/tests/ui/collapsible_else_if.rs
+++ b/tests/ui/collapsible_else_if.rs
@@ -79,4 +79,13 @@ fn main() {
             println!("!")
         }
     }
+
+    if x == "hello" {
+        print!("Hello ");
+    } else {
+        #[cfg(not(roflol))]
+        if y == "world" {
+            println!("world!")
+        }
+    }
 }
diff --git a/tests/ui/collapsible_if.fixed b/tests/ui/collapsible_if.fixed
index efd4187947b..e4c088bf6f0 100644
--- a/tests/ui/collapsible_if.fixed
+++ b/tests/ui/collapsible_if.fixed
@@ -138,4 +138,11 @@ fn main() {
 
     // Fix #5962
     if matches!(true, true) && matches!(true, true) {}
+
+    if true {
+        #[cfg(not(teehee))]
+        if true {
+            println!("Hello world!");
+        }
+    }
 }
diff --git a/tests/ui/collapsible_if.rs b/tests/ui/collapsible_if.rs
index 657f32d38a3..d6cf01c8319 100644
--- a/tests/ui/collapsible_if.rs
+++ b/tests/ui/collapsible_if.rs
@@ -154,4 +154,11 @@ fn main() {
     if matches!(true, true) {
         if matches!(true, true) {}
     }
+
+    if true {
+        #[cfg(not(teehee))]
+        if true {
+            println!("Hello world!");
+        }
+    }
 }
-- 
cgit 1.4.1-3-g733a5


From b932587c5d92bc7524ecd9d496f7081005299fa5 Mon Sep 17 00:00:00 2001
From: ThibsG <thibsg@pm.me>
Date: Tue, 9 Feb 2021 17:38:16 +0100
Subject: Add better turbofish extractor

---
 clippy_lints/src/methods/mod.rs              | 35 ++++++++++++++-
 tests/ui/from_iter_instead_of_collect.fixed  | 30 +++++++++----
 tests/ui/from_iter_instead_of_collect.rs     | 14 ++++++
 tests/ui/from_iter_instead_of_collect.stderr | 64 ++++++++++++++++++++++------
 4 files changed, 120 insertions(+), 23 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 3e356afa2a4..d9f906619a0 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -4095,7 +4095,8 @@ fn lint_from_iter(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::Expr<
         then {
             // `expr` implements `FromIterator` trait
             let iter_expr = sugg::Sugg::hir(cx, &args[0], "..").maybe_par();
-            let sugg = format!("{}.collect::<{}>()", iter_expr, ty);
+            let turbofish = extract_turbofish(cx, expr, ty);
+            let sugg = format!("{}.collect::<{}>()", iter_expr, turbofish);
             span_lint_and_sugg(
                 cx,
                 FROM_ITER_INSTEAD_OF_COLLECT,
@@ -4109,6 +4110,38 @@ fn lint_from_iter(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::Expr<
     }
 }
 
+fn extract_turbofish(cx: &LateContext<'_>, expr: &hir::Expr<'_>, ty: Ty<'tcx>) -> String {
+    if_chain! {
+        let call_site = expr.span.source_callsite();
+        if let Ok(snippet) = cx.sess().source_map().span_to_snippet(call_site);
+        let snippet_split = snippet.split("::").collect::<Vec<_>>();
+        if let Some((_, elements)) = snippet_split.split_last();
+
+        then {
+            // is there a type specifier? (i.e.: like `<u32>` in `collections::BTreeSet::<u32>::`)
+            if let Some(type_specifier) = snippet_split.iter().find(|e| e.starts_with('<') && e.ends_with('>')) {
+                // remove the type specifier from the path elements
+                let without_ts = elements.iter().filter_map(|e| {
+                    if e == type_specifier { None } else { Some((*e).to_string()) }
+                }).collect::<Vec<_>>();
+                // join and add the type specifier at the end (i.e.: `collections::BTreeSet<u32>`)
+                format!("{}{}", without_ts.join("::"), type_specifier)
+            } else {
+                // type is not explicitly specified so wildcards are needed
+                // i.e.: 2 wildcards in `std::collections::BTreeMap<&i32, &char>`
+                let ty_str = ty.to_string();
+                let start = ty_str.find('<').unwrap_or(0);
+                let end = ty_str.find('>').unwrap_or_else(|| ty_str.len());
+                let nb_wildcard = ty_str[start..end].split(',').count();
+                let wildcards = format!("_{}", ", _".repeat(nb_wildcard - 1));
+                format!("{}<{}>", elements.join("::"), wildcards)
+            }
+        } else {
+            ty.to_string()
+        }
+    }
+}
+
 fn fn_header_equals(expected: hir::FnHeader, actual: hir::FnHeader) -> bool {
     expected.constness == actual.constness
         && expected.unsafety == actual.unsafety
diff --git a/tests/ui/from_iter_instead_of_collect.fixed b/tests/ui/from_iter_instead_of_collect.fixed
index 96701e86395..b5f548810e6 100644
--- a/tests/ui/from_iter_instead_of_collect.fixed
+++ b/tests/ui/from_iter_instead_of_collect.fixed
@@ -8,27 +8,41 @@ use std::iter::FromIterator;
 
 fn main() {
     let iter_expr = std::iter::repeat(5).take(5);
-    let _ = iter_expr.collect::<std::vec::Vec<i32>>();
+    let _ = iter_expr.collect::<Vec<_>>();
 
-    let _ = vec![5, 5, 5, 5].iter().enumerate().collect::<std::collections::HashMap<usize, &i8>>();
+    let _ = vec![5, 5, 5, 5].iter().enumerate().collect::<HashMap<usize, &i8>>();
 
     Vec::from_iter(vec![42u32]);
 
     let a = vec![0, 1, 2];
-    assert_eq!(a, (0..3).collect::<std::vec::Vec<i32>>());
+    assert_eq!(a, (0..3).collect::<Vec<_>>());
+    assert_eq!(a, (0..3).collect::<Vec<i32>>());
 
-    let mut b = (0..3).collect::<std::collections::VecDeque<i32>>();
+    let mut b = (0..3).collect::<VecDeque<_>>();
     b.push_back(4);
 
+    let mut b = (0..3).collect::<VecDeque<i32>>();
+    b.push_back(4);
+
+    {
+        use std::collections;
+        let mut b = (0..3).collect::<collections::VecDeque<i32>>();
+        b.push_back(4);
+    }
+
     let values = [(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd')];
-    let bm = values.iter().cloned().collect::<std::collections::BTreeMap<i32, char>>();
-    let mut bar = bm.range(0..2).collect::<std::collections::BTreeMap<&i32, &char>>();
+    let bm = values.iter().cloned().collect::<BTreeMap<_, _>>();
+    let mut bar = bm.range(0..2).collect::<BTreeMap<_, _>>();
     bar.insert(&4, &'e');
 
-    let mut bts = (0..3).collect::<std::collections::BTreeSet<i32>>();
+    let mut bts = (0..3).collect::<BTreeSet<_>>();
     bts.insert(2);
     {
         use std::collections;
-        let _ = (0..3).collect::<std::collections::BTreeSet<i32>>();
+        let _ = (0..3).collect::<collections::BTreeSet<_>>();
+        let _ = (0..3).collect::<collections::BTreeSet<u32>>();
     }
+
+    for _i in [1, 2, 3].iter().collect::<Vec<_>>() {}
+    for _i in [1, 2, 3].iter().collect::<Vec<&i32>>() {}
 }
diff --git a/tests/ui/from_iter_instead_of_collect.rs b/tests/ui/from_iter_instead_of_collect.rs
index 211f57bc537..b842b5451d1 100644
--- a/tests/ui/from_iter_instead_of_collect.rs
+++ b/tests/ui/from_iter_instead_of_collect.rs
@@ -16,10 +16,20 @@ fn main() {
 
     let a = vec![0, 1, 2];
     assert_eq!(a, Vec::from_iter(0..3));
+    assert_eq!(a, Vec::<i32>::from_iter(0..3));
 
     let mut b = VecDeque::from_iter(0..3);
     b.push_back(4);
 
+    let mut b = VecDeque::<i32>::from_iter(0..3);
+    b.push_back(4);
+
+    {
+        use std::collections;
+        let mut b = collections::VecDeque::<i32>::from_iter(0..3);
+        b.push_back(4);
+    }
+
     let values = [(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd')];
     let bm = BTreeMap::from_iter(values.iter().cloned());
     let mut bar = BTreeMap::from_iter(bm.range(0..2));
@@ -30,5 +40,9 @@ fn main() {
     {
         use std::collections;
         let _ = collections::BTreeSet::from_iter(0..3);
+        let _ = collections::BTreeSet::<u32>::from_iter(0..3);
     }
+
+    for _i in Vec::from_iter([1, 2, 3].iter()) {}
+    for _i in Vec::<&i32>::from_iter([1, 2, 3].iter()) {}
 }
diff --git a/tests/ui/from_iter_instead_of_collect.stderr b/tests/ui/from_iter_instead_of_collect.stderr
index 336e25a8adf..434734c9a21 100644
--- a/tests/ui/from_iter_instead_of_collect.stderr
+++ b/tests/ui/from_iter_instead_of_collect.stderr
@@ -2,7 +2,7 @@ error: usage of `FromIterator::from_iter`
   --> $DIR/from_iter_instead_of_collect.rs:11:13
    |
 LL |     let _ = Vec::from_iter(iter_expr);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `iter_expr.collect::<std::vec::Vec<i32>>()`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `iter_expr.collect::<Vec<_>>()`
    |
    = note: `-D clippy::from-iter-instead-of-collect` implied by `-D warnings`
 
@@ -10,43 +10,79 @@ error: usage of `FromIterator::from_iter`
   --> $DIR/from_iter_instead_of_collect.rs:13:13
    |
 LL |     let _ = HashMap::<usize, &i8>::from_iter(vec![5, 5, 5, 5].iter().enumerate());
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `vec![5, 5, 5, 5].iter().enumerate().collect::<std::collections::HashMap<usize, &i8>>()`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `vec![5, 5, 5, 5].iter().enumerate().collect::<HashMap<usize, &i8>>()`
 
 error: usage of `FromIterator::from_iter`
   --> $DIR/from_iter_instead_of_collect.rs:18:19
    |
 LL |     assert_eq!(a, Vec::from_iter(0..3));
-   |                   ^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `(0..3).collect::<std::vec::Vec<i32>>()`
+   |                   ^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `(0..3).collect::<Vec<_>>()`
 
 error: usage of `FromIterator::from_iter`
-  --> $DIR/from_iter_instead_of_collect.rs:20:17
+  --> $DIR/from_iter_instead_of_collect.rs:19:19
+   |
+LL |     assert_eq!(a, Vec::<i32>::from_iter(0..3));
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `(0..3).collect::<Vec<i32>>()`
+
+error: usage of `FromIterator::from_iter`
+  --> $DIR/from_iter_instead_of_collect.rs:21:17
    |
 LL |     let mut b = VecDeque::from_iter(0..3);
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `(0..3).collect::<std::collections::VecDeque<i32>>()`
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `(0..3).collect::<VecDeque<_>>()`
+
+error: usage of `FromIterator::from_iter`
+  --> $DIR/from_iter_instead_of_collect.rs:24:17
+   |
+LL |     let mut b = VecDeque::<i32>::from_iter(0..3);
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `(0..3).collect::<VecDeque<i32>>()`
+
+error: usage of `FromIterator::from_iter`
+  --> $DIR/from_iter_instead_of_collect.rs:29:21
+   |
+LL |         let mut b = collections::VecDeque::<i32>::from_iter(0..3);
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `(0..3).collect::<collections::VecDeque<i32>>()`
 
 error: usage of `FromIterator::from_iter`
-  --> $DIR/from_iter_instead_of_collect.rs:24:14
+  --> $DIR/from_iter_instead_of_collect.rs:34:14
    |
 LL |     let bm = BTreeMap::from_iter(values.iter().cloned());
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `values.iter().cloned().collect::<std::collections::BTreeMap<i32, char>>()`
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `values.iter().cloned().collect::<BTreeMap<_, _>>()`
 
 error: usage of `FromIterator::from_iter`
-  --> $DIR/from_iter_instead_of_collect.rs:25:19
+  --> $DIR/from_iter_instead_of_collect.rs:35:19
    |
 LL |     let mut bar = BTreeMap::from_iter(bm.range(0..2));
-   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `bm.range(0..2).collect::<std::collections::BTreeMap<&i32, &char>>()`
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `bm.range(0..2).collect::<BTreeMap<_, _>>()`
 
 error: usage of `FromIterator::from_iter`
-  --> $DIR/from_iter_instead_of_collect.rs:28:19
+  --> $DIR/from_iter_instead_of_collect.rs:38:19
    |
 LL |     let mut bts = BTreeSet::from_iter(0..3);
-   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `(0..3).collect::<std::collections::BTreeSet<i32>>()`
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `(0..3).collect::<BTreeSet<_>>()`
 
 error: usage of `FromIterator::from_iter`
-  --> $DIR/from_iter_instead_of_collect.rs:32:17
+  --> $DIR/from_iter_instead_of_collect.rs:42:17
    |
 LL |         let _ = collections::BTreeSet::from_iter(0..3);
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `(0..3).collect::<std::collections::BTreeSet<i32>>()`
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `(0..3).collect::<collections::BTreeSet<_>>()`
+
+error: usage of `FromIterator::from_iter`
+  --> $DIR/from_iter_instead_of_collect.rs:43:17
+   |
+LL |         let _ = collections::BTreeSet::<u32>::from_iter(0..3);
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `(0..3).collect::<collections::BTreeSet<u32>>()`
+
+error: usage of `FromIterator::from_iter`
+  --> $DIR/from_iter_instead_of_collect.rs:46:15
+   |
+LL |     for _i in Vec::from_iter([1, 2, 3].iter()) {}
+   |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `[1, 2, 3].iter().collect::<Vec<_>>()`
+
+error: usage of `FromIterator::from_iter`
+  --> $DIR/from_iter_instead_of_collect.rs:47:15
+   |
+LL |     for _i in Vec::<&i32>::from_iter([1, 2, 3].iter()) {}
+   |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `[1, 2, 3].iter().collect::<Vec<&i32>>()`
 
-error: aborting due to 8 previous errors
+error: aborting due to 14 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 932cc085e6ac277d58fbb6bebe05252b75d5dc54 Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <41065217+TaKO8Ki@users.noreply.github.com>
Date: Wed, 10 Feb 2021 15:49:07 +0900
Subject: Update clippy_lints/src/methods/bytes_nth.rs

Co-authored-by: Phil Hansch <dev@phansch.net>
---
 clippy_lints/src/methods/bytes_nth.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/bytes_nth.rs b/clippy_lints/src/methods/bytes_nth.rs
index 4f38db06c0a..defc50ede22 100644
--- a/clippy_lints/src/methods/bytes_nth.rs
+++ b/clippy_lints/src/methods/bytes_nth.rs
@@ -26,7 +26,7 @@ pub(super) fn lints<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, iter_args: &'
                 BYTES_NTH,
                 expr.span,
                 &format!("called `.byte().nth()` on a `{}`", caller_type),
-                "try calling `.as_bytes().get()`",
+                "try",
                 format!(
                     "{}.as_bytes().get({})",
                     snippet_with_applicability(cx, iter_args[0].span, "..", &mut applicability),
-- 
cgit 1.4.1-3-g733a5


From 347b01eb1f41154e3e1d6f13c54afa0336d80516 Mon Sep 17 00:00:00 2001
From: Tim Nielens <tim.nielens@gmail.com>
Date: Sun, 26 Apr 2020 02:48:02 +0200
Subject: rework use_self impl based on ty::Ty comparison

---
 clippy_lints/src/use_self.rs   | 320 +++++++++++++++++++++++++----------------
 tests/ui/use_self.fixed        | 230 +++++++++++++++++++++++++++--
 tests/ui/use_self.rs           | 216 +++++++++++++++++++++++++++-
 tests/ui/use_self.stderr       | 100 +++++--------
 tests/ui/use_self_trait.fixed  |   4 +-
 tests/ui/use_self_trait.stderr |  14 +-
 6 files changed, 668 insertions(+), 216 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/use_self.rs b/clippy_lints/src/use_self.rs
index 72d1ca73929..1b5070d1cff 100644
--- a/clippy_lints/src/use_self.rs
+++ b/clippy_lints/src/use_self.rs
@@ -1,24 +1,24 @@
+use crate::utils;
+use crate::utils::snippet_opt;
+use crate::utils::span_lint_and_sugg;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
-use rustc_hir::def::{DefKind, Res};
-use rustc_hir::intravisit::{walk_item, walk_path, walk_ty, NestedVisitorMap, Visitor};
+use rustc_hir::def::DefKind;
+use rustc_hir::intravisit::{walk_expr, walk_impl_item, walk_ty, NestedVisitorMap, Visitor};
 use rustc_hir::{
-    def, FnDecl, FnRetTy, FnSig, GenericArg, HirId, ImplItem, ImplItemKind, Item, ItemKind, Path, PathSegment, QPath,
-    TyKind,
+    def, Expr, ExprKind, FnDecl, FnRetTy, FnSig, GenericArg, ImplItem, ImplItemKind, ItemKind, Node, Path, PathSegment,
+    QPath, TyKind,
 };
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::hir::map::Map;
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty;
-use rustc_middle::ty::{DefIdTree, Ty};
-use rustc_semver::RustcVersion;
-use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::symbol::kw;
+use rustc_middle::ty::Ty;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::{BytePos, Span};
 use rustc_typeck::hir_ty_to_ty;
 
-use crate::utils::{differing_macro_contexts, meets_msrv, span_lint_and_sugg};
-
 declare_clippy_lint! {
     /// **What it does:** Checks for unnecessary repetition of structure name when a
     /// replacement with `Self` is applicable.
@@ -28,8 +28,7 @@ declare_clippy_lint! {
     /// feels inconsistent.
     ///
     /// **Known problems:**
-    /// - False positive when using associated types ([#2843](https://github.com/rust-lang/rust-clippy/issues/2843))
-    /// - False positives in some situations when using generics ([#3410](https://github.com/rust-lang/rust-clippy/issues/3410))
+    /// Unaddressed false negatives related to unresolved internal compiler errors.
     ///
     /// **Example:**
     /// ```rust
@@ -54,23 +53,11 @@ declare_clippy_lint! {
     "unnecessary structure name repetition whereas `Self` is applicable"
 }
 
-impl_lint_pass!(UseSelf => [USE_SELF]);
+declare_lint_pass!(UseSelf => [USE_SELF]);
 
 const SEGMENTS_MSG: &str = "segments should be composed of at least 1 element";
 
-fn span_use_self_lint(cx: &LateContext<'_>, path: &Path<'_>, last_segment: Option<&PathSegment<'_>>) {
-    let last_segment = last_segment.unwrap_or_else(|| path.segments.last().expect(SEGMENTS_MSG));
-
-    // Path segments only include actual path, no methods or fields.
-    let last_path_span = last_segment.ident.span;
-
-    if differing_macro_contexts(path.span, last_path_span) {
-        return;
-    }
-
-    // Only take path up to the end of last_path_span.
-    let span = path.span.with_hi(last_path_span.hi());
-
+fn span_lint<'tcx>(cx: &LateContext<'tcx>, span: Span) {
     span_lint_and_sugg(
         cx,
         USE_SELF,
@@ -82,107 +69,196 @@ fn span_use_self_lint(cx: &LateContext<'_>, path: &Path<'_>, last_segment: Optio
     );
 }
 
-// FIXME: always use this (more correct) visitor, not just in method signatures.
-struct SemanticUseSelfVisitor<'a, 'tcx> {
+#[allow(clippy::cast_possible_truncation)]
+fn span_lint_until_last_segment<'tcx>(cx: &LateContext<'tcx>, span: Span, segment: &'tcx PathSegment<'tcx>) {
+    let sp = span.with_hi(segment.ident.span.lo());
+    // remove the trailing ::
+    let span_without_last_segment = match snippet_opt(cx, sp) {
+        Some(snippet) => match snippet.rfind("::") {
+            Some(bidx) => sp.with_hi(sp.lo() + BytePos(bidx as u32)),
+            None => sp,
+        },
+        None => sp,
+    };
+    span_lint(cx, span_without_last_segment);
+}
+
+fn span_lint_on_path_until_last_segment<'tcx>(cx: &LateContext<'tcx>, path: &'tcx Path<'tcx>) {
+    if path.segments.len() > 1 {
+        span_lint_until_last_segment(cx, path.span, path.segments.last().unwrap());
+    }
+}
+
+fn span_lint_on_qpath_resolved<'tcx>(cx: &LateContext<'tcx>, qpath: &'tcx QPath<'tcx>, until_last_segment: bool) {
+    if let QPath::Resolved(_, path) = qpath {
+        if until_last_segment {
+            span_lint_on_path_until_last_segment(cx, path);
+        } else {
+            span_lint(cx, path.span);
+        }
+    }
+}
+
+struct ImplVisitor<'a, 'tcx> {
     cx: &'a LateContext<'tcx>,
     self_ty: Ty<'tcx>,
 }
 
-impl<'a, 'tcx> Visitor<'tcx> for SemanticUseSelfVisitor<'a, 'tcx> {
+impl<'a, 'tcx> ImplVisitor<'a, 'tcx> {
+    fn check_trait_method_impl_decl(
+        &mut self,
+        impl_item: &ImplItem<'tcx>,
+        impl_decl: &'tcx FnDecl<'tcx>,
+        impl_trait_ref: ty::TraitRef<'tcx>,
+    ) {
+        let tcx = self.cx.tcx;
+        let trait_method = tcx
+            .associated_items(impl_trait_ref.def_id)
+            .find_by_name_and_kind(tcx, impl_item.ident, ty::AssocKind::Fn, impl_trait_ref.def_id)
+            .expect("impl method matches a trait method");
+
+        let trait_method_sig = tcx.fn_sig(trait_method.def_id);
+        let trait_method_sig = tcx.erase_late_bound_regions(&trait_method_sig);
+
+        let output_hir_ty = if let FnRetTy::Return(ty) = &impl_decl.output {
+            Some(&**ty)
+        } else {
+            None
+        };
+
+        // `impl_hir_ty` (of type `hir::Ty`) represents the type written in the signature.
+        // `trait_ty` (of type `ty::Ty`) is the semantic type for the signature in the trait.
+        // We use `impl_hir_ty` to see if the type was written as `Self`,
+        // `hir_ty_to_ty(...)` to check semantic types of paths, and
+        // `trait_ty` to determine which parts of the signature in the trait, mention
+        // the type being implemented verbatim (as opposed to `Self`).
+        for (impl_hir_ty, trait_ty) in impl_decl
+            .inputs
+            .iter()
+            .chain(output_hir_ty)
+            .zip(trait_method_sig.inputs_and_output)
+        {
+            // Check if the input/output type in the trait method specifies the implemented
+            // type verbatim, and only suggest `Self` if that isn't the case.
+            // This avoids suggestions to e.g. replace `Vec<u8>` with `Vec<Self>`,
+            // in an `impl Trait for u8`, when the trait always uses `Vec<u8>`.
+            // See also https://github.com/rust-lang/rust-clippy/issues/2894.
+            let self_ty = impl_trait_ref.self_ty();
+            if !trait_ty.walk().any(|inner| inner == self_ty.into()) {
+                self.visit_ty(&impl_hir_ty);
+            }
+        }
+    }
+}
+
+impl<'a, 'tcx> Visitor<'tcx> for ImplVisitor<'a, 'tcx> {
     type Map = Map<'tcx>;
 
-    fn visit_ty(&mut self, hir_ty: &'tcx hir::Ty<'_>) {
-        if let TyKind::Path(QPath::Resolved(_, path)) = &hir_ty.kind {
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::OnlyBodies(self.cx.tcx.hir())
+    }
+
+    fn visit_ty(&mut self, hir_ty: &'tcx hir::Ty<'tcx>) {
+        if let TyKind::Path(QPath::Resolved(_, path)) = hir_ty.kind {
             match path.res {
                 def::Res::SelfTy(..) => {},
                 _ => {
-                    if hir_ty_to_ty(self.cx.tcx, hir_ty) == self.self_ty {
-                        span_use_self_lint(self.cx, path, None);
+                    match self.cx.tcx.hir().find(self.cx.tcx.hir().get_parent_node(hir_ty.hir_id)) {
+                        Some(Node::Expr(Expr {
+                            kind: ExprKind::Path(QPath::TypeRelative(_, _segment)),
+                            ..
+                        })) => {
+                            // The following block correctly identifies applicable lint locations
+                            // but `hir_ty_to_ty` calls cause odd ICEs.
+                            //
+                            // if hir_ty_to_ty(self.cx.tcx, hir_ty) == self.self_ty {
+                            //     // FIXME: this span manipulation should not be necessary
+                            //     // @flip1995 found an ast lowering issue in
+                            //     // https://github.com/rust-lang/rust/blob/master/src/librustc_ast_lowering/path.rs#L142-L162
+                            //     span_lint_until_last_segment(self.cx, hir_ty.span, segment);
+                            // }
+                        },
+                        _ => {
+                            if hir_ty_to_ty(self.cx.tcx, hir_ty) == self.self_ty {
+                                span_lint(self.cx, hir_ty.span)
+                            }
+                        },
                     }
                 },
             }
         }
 
-        walk_ty(self, hir_ty)
+        walk_ty(self, hir_ty);
     }
 
-    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-        NestedVisitorMap::None
-    }
-}
-
-fn check_trait_method_impl_decl<'tcx>(
-    cx: &LateContext<'tcx>,
-    impl_item: &ImplItem<'_>,
-    impl_decl: &'tcx FnDecl<'_>,
-    impl_trait_ref: ty::TraitRef<'tcx>,
-) {
-    let trait_method = cx
-        .tcx
-        .associated_items(impl_trait_ref.def_id)
-        .find_by_name_and_kind(cx.tcx, impl_item.ident, ty::AssocKind::Fn, impl_trait_ref.def_id)
-        .expect("impl method matches a trait method");
-
-    let trait_method_sig = cx.tcx.fn_sig(trait_method.def_id);
-    let trait_method_sig = cx.tcx.erase_late_bound_regions(trait_method_sig);
-
-    let output_hir_ty = if let FnRetTy::Return(ty) = &impl_decl.output {
-        Some(&**ty)
-    } else {
-        None
-    };
-
-    // `impl_hir_ty` (of type `hir::Ty`) represents the type written in the signature.
-    // `trait_ty` (of type `ty::Ty`) is the semantic type for the signature in the trait.
-    // We use `impl_hir_ty` to see if the type was written as `Self`,
-    // `hir_ty_to_ty(...)` to check semantic types of paths, and
-    // `trait_ty` to determine which parts of the signature in the trait, mention
-    // the type being implemented verbatim (as opposed to `Self`).
-    for (impl_hir_ty, trait_ty) in impl_decl
-        .inputs
-        .iter()
-        .chain(output_hir_ty)
-        .zip(trait_method_sig.inputs_and_output)
-    {
-        // Check if the input/output type in the trait method specifies the implemented
-        // type verbatim, and only suggest `Self` if that isn't the case.
-        // This avoids suggestions to e.g. replace `Vec<u8>` with `Vec<Self>`,
-        // in an `impl Trait for u8`, when the trait always uses `Vec<u8>`.
-        // See also https://github.com/rust-lang/rust-clippy/issues/2894.
-        let self_ty = impl_trait_ref.self_ty();
-        if !trait_ty.walk().any(|inner| inner == self_ty.into()) {
-            let mut visitor = SemanticUseSelfVisitor { cx, self_ty };
-
-            visitor.visit_ty(&impl_hir_ty);
+    fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) {
+        fn expr_ty_matches<'tcx>(expr: &'tcx Expr<'tcx>, self_ty: Ty<'tcx>, cx: &LateContext<'tcx>) -> bool {
+            let def_id = expr.hir_id.owner;
+            if cx.tcx.has_typeck_results(def_id) {
+                cx.tcx.typeck(def_id).expr_ty_opt(expr) == Some(self_ty)
+            } else {
+                false
+            }
         }
-    }
-}
-
-const USE_SELF_MSRV: RustcVersion = RustcVersion::new(1, 37, 0);
-
-pub struct UseSelf {
-    msrv: Option<RustcVersion>,
-}
-
-impl UseSelf {
-    #[must_use]
-    pub fn new(msrv: Option<RustcVersion>) -> Self {
-        Self { msrv }
+        match expr.kind {
+            ExprKind::Struct(QPath::Resolved(_, path), ..) => {
+                if expr_ty_matches(expr, self.self_ty, self.cx) {
+                    match path.res {
+                        def::Res::SelfTy(..) => (),
+                        def::Res::Def(DefKind::Variant, _) => span_lint_on_path_until_last_segment(self.cx, path),
+                        _ => {
+                            span_lint(self.cx, path.span);
+                        },
+                    }
+                }
+            },
+            // tuple struct instantiation (`Foo(arg)` or `Enum::Foo(arg)`)
+            ExprKind::Call(fun, _) => {
+                if let Expr {
+                    kind: ExprKind::Path(ref qpath),
+                    ..
+                } = fun
+                {
+                    if expr_ty_matches(expr, self.self_ty, self.cx) {
+                        let res = utils::qpath_res(self.cx, qpath, fun.hir_id);
+
+                        if let def::Res::Def(DefKind::Ctor(ctor_of, _), ..) = res {
+                            match ctor_of {
+                                def::CtorOf::Variant => {
+                                    span_lint_on_qpath_resolved(self.cx, qpath, true);
+                                },
+                                def::CtorOf::Struct => {
+                                    span_lint_on_qpath_resolved(self.cx, qpath, false);
+                                },
+                            }
+                        }
+                    }
+                }
+            },
+            // unit enum variants (`Enum::A`)
+            ExprKind::Path(ref qpath) => {
+                if expr_ty_matches(expr, self.self_ty, self.cx) {
+                    span_lint_on_qpath_resolved(self.cx, qpath, true);
+                }
+            },
+            _ => (),
+        }
+        walk_expr(self, expr);
     }
 }
 
 impl<'tcx> LateLintPass<'tcx> for UseSelf {
-    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
-        if !meets_msrv(self.msrv.as_ref(), &USE_SELF_MSRV) {
+    fn check_impl_item(&mut self, cx: &LateContext<'tcx>, impl_item: &'tcx ImplItem<'_>) {
+        if in_external_macro(cx.sess(), impl_item.span) {
             return;
         }
 
-        if in_external_macro(cx.sess(), item.span) {
-            return;
-        }
+        let parent_id = cx.tcx.hir().get_parent_item(impl_item.hir_id);
+        let imp = cx.tcx.hir().expect_item(parent_id);
+
         if_chain! {
-            if let ItemKind::Impl(impl_) = &item.kind;
-            if let TyKind::Path(QPath::Resolved(_, ref item_path)) = impl_.self_ty.kind;
+            if let ItemKind::Impl { self_ty: hir_self_ty, .. } = imp.kind;
+            if let TyKind::Path(QPath::Resolved(_, ref item_path)) = hir_self_ty.kind;
             then {
                 let parameters = &item_path.segments.last().expect(SEGMENTS_MSG).args;
                 let should_check = parameters.as_ref().map_or(
@@ -191,31 +267,23 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
                         &&!params.args.iter().any(|arg| matches!(arg, GenericArg::Lifetime(_)))
                 );
 
+                // TODO: don't short-circuit upon lifetime parameters
                 if should_check {
-                    let visitor = &mut UseSelfVisitor {
-                        item_path,
-                        cx,
-                    };
-                    let impl_def_id = cx.tcx.hir().local_def_id(item.hir_id);
-                    let impl_trait_ref = cx.tcx.impl_trait_ref(impl_def_id);
-
-                    if let Some(impl_trait_ref) = impl_trait_ref {
-                        for impl_item_ref in impl_.items {
-                            let impl_item = cx.tcx.hir().impl_item(impl_item_ref.id);
-                            if let ImplItemKind::Fn(FnSig{ decl: impl_decl, .. }, impl_body_id)
-                                    = &impl_item.kind {
-                                check_trait_method_impl_decl(cx, impl_item, impl_decl, impl_trait_ref);
-
-                                let body = cx.tcx.hir().body(*impl_body_id);
-                                visitor.visit_body(body);
-                            } else {
-                                visitor.visit_impl_item(impl_item);
-                            }
-                        }
-                    } else {
-                        for impl_item_ref in impl_.items {
-                            let impl_item = cx.tcx.hir().impl_item(impl_item_ref.id);
-                            visitor.visit_impl_item(impl_item);
+                    let self_ty = hir_ty_to_ty(cx.tcx, hir_self_ty);
+                    let visitor = &mut ImplVisitor { cx, self_ty };
+
+                    let tcx = cx.tcx;
+                    let impl_def_id = tcx.hir().local_def_id(imp.hir_id);
+                    let impl_trait_ref = tcx.impl_trait_ref(impl_def_id);
+                    if_chain! {
+                        if let Some(impl_trait_ref) = impl_trait_ref;
+                        if let ImplItemKind::Fn(FnSig { decl: impl_decl, .. }, impl_body_id) = &impl_item.kind;
+                        then {
+                            visitor.check_trait_method_impl_decl(impl_item, impl_decl, impl_trait_ref);
+                            let body = tcx.hir().body(*impl_body_id);
+                            visitor.visit_body(body);
+                        } else {
+                            walk_impl_item(visitor, impl_item)
                         }
                     }
                 }
diff --git a/tests/ui/use_self.fixed b/tests/ui/use_self.fixed
index bb2012441d9..916484eef93 100644
--- a/tests/ui/use_self.fixed
+++ b/tests/ui/use_self.fixed
@@ -15,13 +15,14 @@ mod use_self {
             Self {}
         }
         fn test() -> Self {
-            Self::new()
+            Foo::new()
         }
     }
 
     impl Default for Foo {
         fn default() -> Self {
-            Self::new()
+            // FIXME: applicable here
+            Foo::new()
         }
     }
 }
@@ -87,7 +88,11 @@ mod existential {
     struct Foo;
 
     impl Foo {
-        fn bad(foos: &[Self]) -> impl Iterator<Item = &Self> {
+        // FIXME:
+        // TyKind::Def (used for `impl Trait` types) does not include type parameters yet.
+        // See documentation in rustc_hir::hir::TyKind.
+        // The hir tree walk stops at `impl Iterator` level and does not inspect &Foo.
+        fn bad(foos: &[Self]) -> impl Iterator<Item = &Foo> {
             foos.iter()
         }
 
@@ -177,11 +182,22 @@ mod issue3410 {
     struct B;
 
     trait Trait<T> {
-        fn a(v: T);
+        fn a(v: T) -> Self;
     }
 
     impl Trait<Vec<A>> for Vec<B> {
-        fn a(_: Vec<A>) {}
+        fn a(_: Vec<A>) -> Self {
+            unimplemented!()
+        }
+    }
+
+    impl<T> Trait<Vec<A>> for Vec<T>
+    where
+        T: Trait<B>,
+    {
+        fn a(v: Vec<A>) -> Self {
+            <Vec<B>>::a(v).into_iter().map(Trait::a).collect()
+        }
     }
 }
 
@@ -197,8 +213,8 @@ mod rustfix {
         fn fun_1() {}
 
         fn fun_2() {
-            Self::fun_1();
-            Self::A;
+            nested::A::fun_1();
+            nested::A::A;
 
             Self {};
         }
@@ -219,7 +235,8 @@ mod issue3567 {
 
     impl Test for TestStruct {
         fn test() -> TestStruct {
-            Self::from_something()
+            // FIXME: applicable here
+            TestStruct::from_something()
         }
     }
 }
@@ -233,12 +250,14 @@ mod paths_created_by_lowering {
         const A: usize = 0;
         const B: usize = 1;
 
-        async fn g() -> Self {
+        // FIXME: applicable here
+        async fn g() -> S {
             Self {}
         }
 
         fn f<'a>(&self, p: &'a [u8]) -> &'a [u8] {
-            &p[Self::A..Self::B]
+            // FIXME: applicable here twice
+            &p[S::A..S::B]
         }
     }
 
@@ -252,3 +271,194 @@ mod paths_created_by_lowering {
         }
     }
 }
+
+// reused from #1997
+mod generics {
+    struct Foo<T> {
+        value: T,
+    }
+
+    impl<T> Foo<T> {
+        // `Self` is applicable here
+        fn foo(value: T) -> Self {
+            Self { value }
+        }
+
+        // `Cannot` use `Self` as a return type as the generic types are different
+        fn bar(value: i32) -> Foo<i32> {
+            Foo { value }
+        }
+    }
+}
+
+mod issue4140 {
+    pub struct Error<From, To> {
+        _from: From,
+        _too: To,
+    }
+
+    pub trait From<T> {
+        type From;
+        type To;
+
+        fn from(value: T) -> Self;
+    }
+
+    pub trait TryFrom<T>
+    where
+        Self: Sized,
+    {
+        type From;
+        type To;
+
+        fn try_from(value: T) -> Result<Self, Error<Self::From, Self::To>>;
+    }
+
+    impl<F, T> TryFrom<F> for T
+    where
+        T: From<F>,
+    {
+        type From = Self;
+        type To = Self;
+
+        fn try_from(value: F) -> Result<Self, Error<Self::From, Self::To>> {
+            Ok(From::from(value))
+        }
+    }
+
+    impl From<bool> for i64 {
+        type From = bool;
+        type To = Self;
+
+        fn from(value: bool) -> Self {
+            if value {
+                100
+            } else {
+                0
+            }
+        }
+    }
+}
+
+mod issue2843 {
+    trait Foo {
+        type Bar;
+    }
+
+    impl Foo for usize {
+        type Bar = u8;
+    }
+
+    impl<T: Foo> Foo for Option<T> {
+        type Bar = Option<T::Bar>;
+    }
+}
+
+mod issue3859 {
+    pub struct Foo;
+    pub struct Bar([usize; 3]);
+
+    impl Foo {
+        pub const BAR: usize = 3;
+
+        pub fn foo() {
+            const _X: usize = Foo::BAR;
+            // const _Y: usize = Self::BAR;
+        }
+    }
+}
+
+mod issue4305 {
+    trait Foo: 'static {}
+
+    struct Bar;
+
+    impl Foo for Bar {}
+
+    impl<T: Foo> From<T> for Box<dyn Foo> {
+        fn from(t: T) -> Self {
+            // FIXME: applicable here
+            Box::new(t)
+        }
+    }
+}
+
+mod lint_at_item_level {
+    struct Foo {}
+
+    #[allow(clippy::use_self)]
+    impl Foo {
+        fn new() -> Foo {
+            Foo {}
+        }
+    }
+
+    #[allow(clippy::use_self)]
+    impl Default for Foo {
+        fn default() -> Foo {
+            Foo::new()
+        }
+    }
+}
+
+mod lint_at_impl_item_level {
+    struct Foo {}
+
+    impl Foo {
+        #[allow(clippy::use_self)]
+        fn new() -> Foo {
+            Foo {}
+        }
+    }
+
+    impl Default for Foo {
+        #[allow(clippy::use_self)]
+        fn default() -> Foo {
+            Foo::new()
+        }
+    }
+}
+
+mod issue4734 {
+    #[repr(C, packed)]
+    pub struct X {
+        pub x: u32,
+    }
+
+    impl From<X> for u32 {
+        fn from(c: X) -> Self {
+            unsafe { core::mem::transmute(c) }
+        }
+    }
+}
+
+mod nested_paths {
+    use std::convert::Into;
+    mod submod {
+        pub struct B {}
+        pub struct C {}
+
+        impl Into<C> for B {
+            fn into(self) -> C {
+                C {}
+            }
+        }
+    }
+
+    struct A<T> {
+        t: T,
+    }
+
+    impl<T> A<T> {
+        fn new<V: Into<T>>(v: V) -> Self {
+            Self { t: Into::into(v) }
+        }
+    }
+
+    impl A<submod::C> {
+        fn test() -> Self {
+            // FIXME: applicable here
+            A::new::<submod::B>(submod::B {})
+        }
+    }
+}
diff --git a/tests/ui/use_self.rs b/tests/ui/use_self.rs
index ddfd2beba31..347f5e96555 100644
--- a/tests/ui/use_self.rs
+++ b/tests/ui/use_self.rs
@@ -21,6 +21,7 @@ mod use_self {
 
     impl Default for Foo {
         fn default() -> Foo {
+            // FIXME: applicable here
             Foo::new()
         }
     }
@@ -87,7 +88,11 @@ mod existential {
     struct Foo;
 
     impl Foo {
-        fn bad(foos: &[Self]) -> impl Iterator<Item = &Foo> {
+        // FIXME:
+        // TyKind::Def (used for `impl Trait` types) does not include type parameters yet.
+        // See documentation in rustc_hir::hir::TyKind.
+        // The hir tree walk stops at `impl Iterator` level and does not inspect &Foo.
+        fn bad(foos: &[Foo]) -> impl Iterator<Item = &Foo> {
             foos.iter()
         }
 
@@ -177,11 +182,22 @@ mod issue3410 {
     struct B;
 
     trait Trait<T> {
-        fn a(v: T);
+        fn a(v: T) -> Self;
     }
 
     impl Trait<Vec<A>> for Vec<B> {
-        fn a(_: Vec<A>) {}
+        fn a(_: Vec<A>) -> Self {
+            unimplemented!()
+        }
+    }
+
+    impl<T> Trait<Vec<A>> for Vec<T>
+    where
+        T: Trait<B>,
+    {
+        fn a(v: Vec<A>) -> Self {
+            <Vec<B>>::a(v).into_iter().map(Trait::a).collect()
+        }
     }
 }
 
@@ -219,6 +235,7 @@ mod issue3567 {
 
     impl Test for TestStruct {
         fn test() -> TestStruct {
+            // FIXME: applicable here
             TestStruct::from_something()
         }
     }
@@ -233,11 +250,13 @@ mod paths_created_by_lowering {
         const A: usize = 0;
         const B: usize = 1;
 
+        // FIXME: applicable here
         async fn g() -> S {
             S {}
         }
 
         fn f<'a>(&self, p: &'a [u8]) -> &'a [u8] {
+            // FIXME: applicable here twice
             &p[S::A..S::B]
         }
     }
@@ -252,3 +271,194 @@ mod paths_created_by_lowering {
         }
     }
 }
+
+// reused from #1997
+mod generics {
+    struct Foo<T> {
+        value: T,
+    }
+
+    impl<T> Foo<T> {
+        // `Self` is applicable here
+        fn foo(value: T) -> Foo<T> {
+            Foo { value }
+        }
+
+        // `Cannot` use `Self` as a return type as the generic types are different
+        fn bar(value: i32) -> Foo<i32> {
+            Foo { value }
+        }
+    }
+}
+
+mod issue4140 {
+    pub struct Error<From, To> {
+        _from: From,
+        _too: To,
+    }
+
+    pub trait From<T> {
+        type From;
+        type To;
+
+        fn from(value: T) -> Self;
+    }
+
+    pub trait TryFrom<T>
+    where
+        Self: Sized,
+    {
+        type From;
+        type To;
+
+        fn try_from(value: T) -> Result<Self, Error<Self::From, Self::To>>;
+    }
+
+    impl<F, T> TryFrom<F> for T
+    where
+        T: From<F>,
+    {
+        type From = T::From;
+        type To = T::To;
+
+        fn try_from(value: F) -> Result<Self, Error<Self::From, Self::To>> {
+            Ok(From::from(value))
+        }
+    }
+
+    impl From<bool> for i64 {
+        type From = bool;
+        type To = Self;
+
+        fn from(value: bool) -> Self {
+            if value {
+                100
+            } else {
+                0
+            }
+        }
+    }
+}
+
+mod issue2843 {
+    trait Foo {
+        type Bar;
+    }
+
+    impl Foo for usize {
+        type Bar = u8;
+    }
+
+    impl<T: Foo> Foo for Option<T> {
+        type Bar = Option<T::Bar>;
+    }
+}
+
+mod issue3859 {
+    pub struct Foo;
+    pub struct Bar([usize; 3]);
+
+    impl Foo {
+        pub const BAR: usize = 3;
+
+        pub fn foo() {
+            const _X: usize = Foo::BAR;
+            // const _Y: usize = Self::BAR;
+        }
+    }
+}
+
+mod issue4305 {
+    trait Foo: 'static {}
+
+    struct Bar;
+
+    impl Foo for Bar {}
+
+    impl<T: Foo> From<T> for Box<dyn Foo> {
+        fn from(t: T) -> Self {
+            // FIXME: applicable here
+            Box::new(t)
+        }
+    }
+}
+
+mod lint_at_item_level {
+    struct Foo {}
+
+    #[allow(clippy::use_self)]
+    impl Foo {
+        fn new() -> Foo {
+            Foo {}
+        }
+    }
+
+    #[allow(clippy::use_self)]
+    impl Default for Foo {
+        fn default() -> Foo {
+            Foo::new()
+        }
+    }
+}
+
+mod lint_at_impl_item_level {
+    struct Foo {}
+
+    impl Foo {
+        #[allow(clippy::use_self)]
+        fn new() -> Foo {
+            Foo {}
+        }
+    }
+
+    impl Default for Foo {
+        #[allow(clippy::use_self)]
+        fn default() -> Foo {
+            Foo::new()
+        }
+    }
+}
+
+mod issue4734 {
+    #[repr(C, packed)]
+    pub struct X {
+        pub x: u32,
+    }
+
+    impl From<X> for u32 {
+        fn from(c: X) -> Self {
+            unsafe { core::mem::transmute(c) }
+        }
+    }
+}
+
+mod nested_paths {
+    use std::convert::Into;
+    mod submod {
+        pub struct B {}
+        pub struct C {}
+
+        impl Into<C> for B {
+            fn into(self) -> C {
+                C {}
+            }
+        }
+    }
+
+    struct A<T> {
+        t: T,
+    }
+
+    impl<T> A<T> {
+        fn new<V: Into<T>>(v: V) -> Self {
+            Self { t: Into::into(v) }
+        }
+    }
+
+    impl A<submod::C> {
+        fn test() -> Self {
+            // FIXME: applicable here
+            A::new::<submod::B>(submod::B {})
+        }
+    }
+}
diff --git a/tests/ui/use_self.stderr b/tests/ui/use_self.stderr
index 80e1bfc75e8..a88dd04f13d 100644
--- a/tests/ui/use_self.stderr
+++ b/tests/ui/use_self.stderr
@@ -18,12 +18,6 @@ error: unnecessary structure name repetition
 LL |         fn test() -> Foo {
    |                      ^^^ help: use the applicable keyword: `Self`
 
-error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:18:13
-   |
-LL |             Foo::new()
-   |             ^^^ help: use the applicable keyword: `Self`
-
 error: unnecessary structure name repetition
   --> $DIR/use_self.rs:23:25
    |
@@ -31,25 +25,19 @@ LL |         fn default() -> Foo {
    |                         ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:24:13
-   |
-LL |             Foo::new()
-   |             ^^^ help: use the applicable keyword: `Self`
-
-error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:90:56
+  --> $DIR/use_self.rs:94:24
    |
-LL |         fn bad(foos: &[Self]) -> impl Iterator<Item = &Foo> {
-   |                                                        ^^^ help: use the applicable keyword: `Self`
+LL |         fn bad(foos: &[Foo]) -> impl Iterator<Item = &Foo> {
+   |                        ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:105:13
+  --> $DIR/use_self.rs:109:13
    |
 LL |             TS(0)
    |             ^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:113:25
+  --> $DIR/use_self.rs:117:25
    |
 LL |             fn new() -> Foo {
    |                         ^^^ help: use the applicable keyword: `Self`
@@ -60,7 +48,7 @@ LL |         use_self_expand!(); // Should lint in local macros
    = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:114:17
+  --> $DIR/use_self.rs:118:17
    |
 LL |                 Foo {}
    |                 ^^^ help: use the applicable keyword: `Self`
@@ -71,94 +59,82 @@ LL |         use_self_expand!(); // Should lint in local macros
    = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:149:21
+  --> $DIR/use_self.rs:141:29
    |
-LL |         fn baz() -> Foo {
-   |                     ^^^ help: use the applicable keyword: `Self`
+LL |                 fn bar() -> Bar {
+   |                             ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:150:13
+  --> $DIR/use_self.rs:142:21
    |
-LL |             Foo {}
-   |             ^^^ help: use the applicable keyword: `Self`
+LL |                     Bar { foo: Foo {} }
+   |                     ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:137:29
+  --> $DIR/use_self.rs:153:21
    |
-LL |                 fn bar() -> Bar {
-   |                             ^^^ help: use the applicable keyword: `Self`
+LL |         fn baz() -> Foo {
+   |                     ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:138:21
+  --> $DIR/use_self.rs:154:13
    |
-LL |                     Bar { foo: Foo {} }
-   |                     ^^^ help: use the applicable keyword: `Self`
+LL |             Foo {}
+   |             ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:167:21
+  --> $DIR/use_self.rs:171:21
    |
 LL |             let _ = Enum::B(42);
    |                     ^^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:168:21
+  --> $DIR/use_self.rs:172:21
    |
 LL |             let _ = Enum::C { field: true };
    |                     ^^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:169:21
+  --> $DIR/use_self.rs:173:21
    |
 LL |             let _ = Enum::A;
    |                     ^^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:200:13
-   |
-LL |             nested::A::fun_1();
-   |             ^^^^^^^^^ help: use the applicable keyword: `Self`
-
-error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:201:13
-   |
-LL |             nested::A::A;
-   |             ^^^^^^^^^ help: use the applicable keyword: `Self`
-
-error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:203:13
+  --> $DIR/use_self.rs:218:13
    |
 LL |             nested::A {};
    |             ^^^^^^^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:222:13
+  --> $DIR/use_self.rs:254:13
    |
-LL |             TestStruct::from_something()
-   |             ^^^^^^^^^^ help: use the applicable keyword: `Self`
+LL |             S {}
+   |             ^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:236:25
+  --> $DIR/use_self.rs:282:29
    |
-LL |         async fn g() -> S {
-   |                         ^ help: use the applicable keyword: `Self`
+LL |         fn foo(value: T) -> Foo<T> {
+   |                             ^^^^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:237:13
+  --> $DIR/use_self.rs:283:13
    |
-LL |             S {}
-   |             ^ help: use the applicable keyword: `Self`
+LL |             Foo { value }
+   |             ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:241:16
+  --> $DIR/use_self.rs:320:21
    |
-LL |             &p[S::A..S::B]
-   |                ^ help: use the applicable keyword: `Self`
+LL |         type From = T::From;
+   |                     ^^^^^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:241:22
+  --> $DIR/use_self.rs:321:19
    |
-LL |             &p[S::A..S::B]
-   |                      ^ help: use the applicable keyword: `Self`
+LL |         type To = T::To;
+   |                   ^^^^^ help: use the applicable keyword: `Self`
 
-error: aborting due to 25 previous errors
+error: aborting due to 21 previous errors
 
diff --git a/tests/ui/use_self_trait.fixed b/tests/ui/use_self_trait.fixed
index 1582ae114bf..d425f953a9c 100644
--- a/tests/ui/use_self_trait.fixed
+++ b/tests/ui/use_self_trait.fixed
@@ -33,7 +33,7 @@ impl SelfTrait for Bad {
     fn nested(_p1: Box<Self>, _p2: (&u8, &Self)) {}
 
     fn vals(_: Self) -> Self {
-        Self::default()
+        Bad::default()
     }
 }
 
@@ -47,7 +47,7 @@ impl Mul for Bad {
 
 impl Clone for Bad {
     fn clone(&self) -> Self {
-        Self
+        Bad
     }
 }
 
diff --git a/tests/ui/use_self_trait.stderr b/tests/ui/use_self_trait.stderr
index 4f2506cc119..fa528cc5b7d 100644
--- a/tests/ui/use_self_trait.stderr
+++ b/tests/ui/use_self_trait.stderr
@@ -60,12 +60,6 @@ error: unnecessary structure name repetition
 LL |     fn vals(_: Bad) -> Bad {
    |                        ^^^ help: use the applicable keyword: `Self`
 
-error: unnecessary structure name repetition
-  --> $DIR/use_self_trait.rs:36:9
-   |
-LL |         Bad::default()
-   |         ^^^ help: use the applicable keyword: `Self`
-
 error: unnecessary structure name repetition
   --> $DIR/use_self_trait.rs:41:19
    |
@@ -84,11 +78,5 @@ error: unnecessary structure name repetition
 LL |     fn mul(self, rhs: Bad) -> Bad {
    |                               ^^^ help: use the applicable keyword: `Self`
 
-error: unnecessary structure name repetition
-  --> $DIR/use_self_trait.rs:50:9
-   |
-LL |         Bad
-   |         ^^^ help: use the applicable keyword: `Self`
-
-error: aborting due to 15 previous errors
+error: aborting due to 13 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From fc334fb8f4cc7e6513578d88f52b2899f624a1de Mon Sep 17 00:00:00 2001
From: Tim Nielens <tim.nielens@gmail.com>
Date: Sat, 10 Oct 2020 00:26:12 +0200
Subject: use_self - fix issue with `hir_ty_to_ty`

---
 clippy_lints/src/use_self.rs   | 97 ++++++++++++++++++++++++------------------
 tests/ui/use_self.fixed        |  6 ++-
 tests/ui/use_self.rs           |  4 ++
 tests/ui/use_self.stderr       | 84 +++++++++++++++++-------------------
 tests/ui/use_self_trait.fixed  | 12 +++---
 tests/ui/use_self_trait.stderr | 76 +--------------------------------
 6 files changed, 112 insertions(+), 167 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/use_self.rs b/clippy_lints/src/use_self.rs
index 1b5070d1cff..023fce947b3 100644
--- a/clippy_lints/src/use_self.rs
+++ b/clippy_lints/src/use_self.rs
@@ -57,7 +57,7 @@ declare_lint_pass!(UseSelf => [USE_SELF]);
 
 const SEGMENTS_MSG: &str = "segments should be composed of at least 1 element";
 
-fn span_lint<'tcx>(cx: &LateContext<'tcx>, span: Span) {
+fn span_lint(cx: &LateContext<'_>, span: Span) {
     span_lint_and_sugg(
         cx,
         USE_SELF,
@@ -99,12 +99,12 @@ fn span_lint_on_qpath_resolved<'tcx>(cx: &LateContext<'tcx>, qpath: &'tcx QPath<
     }
 }
 
-struct ImplVisitor<'a, 'tcx> {
+struct BodyVisitor<'a, 'tcx> {
     cx: &'a LateContext<'tcx>,
     self_ty: Ty<'tcx>,
 }
 
-impl<'a, 'tcx> ImplVisitor<'a, 'tcx> {
+impl<'a, 'tcx> BodyVisitor<'a, 'tcx> {
     fn check_trait_method_impl_decl(
         &mut self,
         impl_item: &ImplItem<'tcx>,
@@ -151,46 +151,13 @@ impl<'a, 'tcx> ImplVisitor<'a, 'tcx> {
     }
 }
 
-impl<'a, 'tcx> Visitor<'tcx> for ImplVisitor<'a, 'tcx> {
+impl<'a, 'tcx> Visitor<'tcx> for BodyVisitor<'a, 'tcx> {
     type Map = Map<'tcx>;
 
     fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
         NestedVisitorMap::OnlyBodies(self.cx.tcx.hir())
     }
 
-    fn visit_ty(&mut self, hir_ty: &'tcx hir::Ty<'tcx>) {
-        if let TyKind::Path(QPath::Resolved(_, path)) = hir_ty.kind {
-            match path.res {
-                def::Res::SelfTy(..) => {},
-                _ => {
-                    match self.cx.tcx.hir().find(self.cx.tcx.hir().get_parent_node(hir_ty.hir_id)) {
-                        Some(Node::Expr(Expr {
-                            kind: ExprKind::Path(QPath::TypeRelative(_, _segment)),
-                            ..
-                        })) => {
-                            // The following block correctly identifies applicable lint locations
-                            // but `hir_ty_to_ty` calls cause odd ICEs.
-                            //
-                            // if hir_ty_to_ty(self.cx.tcx, hir_ty) == self.self_ty {
-                            //     // FIXME: this span manipulation should not be necessary
-                            //     // @flip1995 found an ast lowering issue in
-                            //     // https://github.com/rust-lang/rust/blob/master/src/librustc_ast_lowering/path.rs#L142-L162
-                            //     span_lint_until_last_segment(self.cx, hir_ty.span, segment);
-                            // }
-                        },
-                        _ => {
-                            if hir_ty_to_ty(self.cx.tcx, hir_ty) == self.self_ty {
-                                span_lint(self.cx, hir_ty.span)
-                            }
-                        },
-                    }
-                },
-            }
-        }
-
-        walk_ty(self, hir_ty);
-    }
-
     fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) {
         fn expr_ty_matches<'tcx>(expr: &'tcx Expr<'tcx>, self_ty: Ty<'tcx>, cx: &LateContext<'tcx>) -> bool {
             let def_id = expr.hir_id.owner;
@@ -247,6 +214,52 @@ impl<'a, 'tcx> Visitor<'tcx> for ImplVisitor<'a, 'tcx> {
     }
 }
 
+struct FnSigVisitor<'a, 'tcx> {
+    cx: &'a LateContext<'tcx>,
+    self_ty: Ty<'tcx>,
+}
+
+impl<'a, 'tcx> Visitor<'tcx> for FnSigVisitor<'a, 'tcx> {
+    type Map = Map<'tcx>;
+
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::None
+    }
+
+    fn visit_ty(&mut self, hir_ty: &'tcx hir::Ty<'tcx>) {
+        if let TyKind::Path(QPath::Resolved(_, path)) = hir_ty.kind {
+            match path.res {
+                def::Res::SelfTy(..) => {},
+                _ => {
+                    match self.cx.tcx.hir().find(self.cx.tcx.hir().get_parent_node(hir_ty.hir_id)) {
+                        Some(Node::Expr(Expr {
+                            kind: ExprKind::Path(QPath::TypeRelative(_, segment)),
+                            ..
+                        })) => {
+                            // The following block correctly identifies applicable lint locations
+                            // but `hir_ty_to_ty` calls cause odd ICEs.
+                            //
+                            if hir_ty_to_ty(self.cx.tcx, hir_ty) == self.self_ty {
+                                // fixme: this span manipulation should not be necessary
+                                // @flip1995 found an ast lowering issue in
+                                // https://github.com/rust-lang/rust/blob/master/src/librustc_ast_lowering/path.rs#l142-l162
+                                span_lint_until_last_segment(self.cx, hir_ty.span, segment);
+                            }
+                        },
+                        _ => {
+                            if hir_ty_to_ty(self.cx.tcx, hir_ty) == self.self_ty {
+                                span_lint(self.cx, hir_ty.span)
+                            }
+                        },
+                    }
+                },
+            }
+        }
+
+        walk_ty(self, hir_ty);
+    }
+}
+
 impl<'tcx> LateLintPass<'tcx> for UseSelf {
     fn check_impl_item(&mut self, cx: &LateContext<'tcx>, impl_item: &'tcx ImplItem<'_>) {
         if in_external_macro(cx.sess(), impl_item.span) {
@@ -270,7 +283,8 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
                 // TODO: don't short-circuit upon lifetime parameters
                 if should_check {
                     let self_ty = hir_ty_to_ty(cx.tcx, hir_self_ty);
-                    let visitor = &mut ImplVisitor { cx, self_ty };
+                    let body_visitor = &mut BodyVisitor { cx, self_ty };
+                    let fn_sig_visitor = &mut FnSigVisitor { cx, self_ty };
 
                     let tcx = cx.tcx;
                     let impl_def_id = tcx.hir().local_def_id(imp.hir_id);
@@ -279,11 +293,12 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
                         if let Some(impl_trait_ref) = impl_trait_ref;
                         if let ImplItemKind::Fn(FnSig { decl: impl_decl, .. }, impl_body_id) = &impl_item.kind;
                         then {
-                            visitor.check_trait_method_impl_decl(impl_item, impl_decl, impl_trait_ref);
+                            body_visitor.check_trait_method_impl_decl(impl_item, impl_decl, impl_trait_ref);
                             let body = tcx.hir().body(*impl_body_id);
-                            visitor.visit_body(body);
+                            body_visitor.visit_body(body);
                         } else {
-                            walk_impl_item(visitor, impl_item)
+                            walk_impl_item(body_visitor, impl_item);
+                            walk_impl_item(fn_sig_visitor, impl_item);
                         }
                     }
                 }
diff --git a/tests/ui/use_self.fixed b/tests/ui/use_self.fixed
index 916484eef93..d59750cbfd8 100644
--- a/tests/ui/use_self.fixed
+++ b/tests/ui/use_self.fixed
@@ -15,12 +15,14 @@ mod use_self {
             Self {}
         }
         fn test() -> Self {
+            // FIXME: applicable here
             Foo::new()
         }
     }
 
     impl Default for Foo {
-        fn default() -> Self {
+        // FIXME: applicable here
+        fn default() -> Foo {
             // FIXME: applicable here
             Foo::new()
         }
@@ -213,7 +215,9 @@ mod rustfix {
         fn fun_1() {}
 
         fn fun_2() {
+            // FIXME: applicable here
             nested::A::fun_1();
+            // FIXME: applicable here
             nested::A::A;
 
             Self {};
diff --git a/tests/ui/use_self.rs b/tests/ui/use_self.rs
index 347f5e96555..85606049774 100644
--- a/tests/ui/use_self.rs
+++ b/tests/ui/use_self.rs
@@ -15,11 +15,13 @@ mod use_self {
             Foo {}
         }
         fn test() -> Foo {
+            // FIXME: applicable here
             Foo::new()
         }
     }
 
     impl Default for Foo {
+        // FIXME: applicable here
         fn default() -> Foo {
             // FIXME: applicable here
             Foo::new()
@@ -213,7 +215,9 @@ mod rustfix {
         fn fun_1() {}
 
         fn fun_2() {
+            // FIXME: applicable here
             nested::A::fun_1();
+            // FIXME: applicable here
             nested::A::A;
 
             nested::A {};
diff --git a/tests/ui/use_self.stderr b/tests/ui/use_self.stderr
index a88dd04f13d..4d213316cf5 100644
--- a/tests/ui/use_self.stderr
+++ b/tests/ui/use_self.stderr
@@ -1,16 +1,16 @@
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:14:21
+  --> $DIR/use_self.rs:15:13
    |
-LL |         fn new() -> Foo {
-   |                     ^^^ help: use the applicable keyword: `Self`
+LL |             Foo {}
+   |             ^^^ help: use the applicable keyword: `Self`
    |
    = note: `-D clippy::use-self` implied by `-D warnings`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:15:13
+  --> $DIR/use_self.rs:14:21
    |
-LL |             Foo {}
-   |             ^^^ help: use the applicable keyword: `Self`
+LL |         fn new() -> Foo {
+   |                     ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
   --> $DIR/use_self.rs:17:22
@@ -19,28 +19,22 @@ LL |         fn test() -> Foo {
    |                      ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:23:25
-   |
-LL |         fn default() -> Foo {
-   |                         ^^^ help: use the applicable keyword: `Self`
-
-error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:94:24
+  --> $DIR/use_self.rs:96:24
    |
 LL |         fn bad(foos: &[Foo]) -> impl Iterator<Item = &Foo> {
    |                        ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:109:13
+  --> $DIR/use_self.rs:111:13
    |
 LL |             TS(0)
    |             ^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:117:25
+  --> $DIR/use_self.rs:120:17
    |
-LL |             fn new() -> Foo {
-   |                         ^^^ help: use the applicable keyword: `Self`
+LL |                 Foo {}
+   |                 ^^^ help: use the applicable keyword: `Self`
 ...
 LL |         use_self_expand!(); // Should lint in local macros
    |         ------------------- in this macro invocation
@@ -48,10 +42,10 @@ LL |         use_self_expand!(); // Should lint in local macros
    = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:118:17
+  --> $DIR/use_self.rs:119:25
    |
-LL |                 Foo {}
-   |                 ^^^ help: use the applicable keyword: `Self`
+LL |             fn new() -> Foo {
+   |                         ^^^ help: use the applicable keyword: `Self`
 ...
 LL |         use_self_expand!(); // Should lint in local macros
    |         ------------------- in this macro invocation
@@ -59,82 +53,82 @@ LL |         use_self_expand!(); // Should lint in local macros
    = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:141:29
-   |
-LL |                 fn bar() -> Bar {
-   |                             ^^^ help: use the applicable keyword: `Self`
-
-error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:142:21
+  --> $DIR/use_self.rs:144:21
    |
 LL |                     Bar { foo: Foo {} }
    |                     ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:153:21
+  --> $DIR/use_self.rs:143:29
    |
-LL |         fn baz() -> Foo {
-   |                     ^^^ help: use the applicable keyword: `Self`
+LL |                 fn bar() -> Bar {
+   |                             ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:154:13
+  --> $DIR/use_self.rs:156:13
    |
 LL |             Foo {}
    |             ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:171:21
+  --> $DIR/use_self.rs:155:21
+   |
+LL |         fn baz() -> Foo {
+   |                     ^^^ help: use the applicable keyword: `Self`
+
+error: unnecessary structure name repetition
+  --> $DIR/use_self.rs:173:21
    |
 LL |             let _ = Enum::B(42);
    |                     ^^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:172:21
+  --> $DIR/use_self.rs:174:21
    |
 LL |             let _ = Enum::C { field: true };
    |                     ^^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:173:21
+  --> $DIR/use_self.rs:175:21
    |
 LL |             let _ = Enum::A;
    |                     ^^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:218:13
+  --> $DIR/use_self.rs:222:13
    |
 LL |             nested::A {};
    |             ^^^^^^^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:254:13
+  --> $DIR/use_self.rs:258:13
    |
 LL |             S {}
    |             ^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:282:29
+  --> $DIR/use_self.rs:287:13
    |
-LL |         fn foo(value: T) -> Foo<T> {
-   |                             ^^^^^^ help: use the applicable keyword: `Self`
+LL |             Foo { value }
+   |             ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:283:13
+  --> $DIR/use_self.rs:286:29
    |
-LL |             Foo { value }
-   |             ^^^ help: use the applicable keyword: `Self`
+LL |         fn foo(value: T) -> Foo<T> {
+   |                             ^^^^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:320:21
+  --> $DIR/use_self.rs:324:21
    |
 LL |         type From = T::From;
    |                     ^^^^^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:321:19
+  --> $DIR/use_self.rs:325:19
    |
 LL |         type To = T::To;
    |                   ^^^^^ help: use the applicable keyword: `Self`
 
-error: aborting due to 21 previous errors
+error: aborting due to 20 previous errors
 
diff --git a/tests/ui/use_self_trait.fixed b/tests/ui/use_self_trait.fixed
index d425f953a9c..680a0623839 100644
--- a/tests/ui/use_self_trait.fixed
+++ b/tests/ui/use_self_trait.fixed
@@ -18,21 +18,21 @@ trait SelfTrait {
 struct Bad;
 
 impl SelfTrait for Bad {
-    fn refs(p1: &Self) -> &Self {
+    fn refs(p1: &Bad) -> &Bad {
         p1
     }
 
-    fn ref_refs<'a>(p1: &'a &'a Self) -> &'a &'a Self {
+    fn ref_refs<'a>(p1: &'a &'a Bad) -> &'a &'a Bad {
         p1
     }
 
-    fn mut_refs(p1: &mut Self) -> &mut Self {
+    fn mut_refs(p1: &mut Bad) -> &mut Bad {
         p1
     }
 
-    fn nested(_p1: Box<Self>, _p2: (&u8, &Self)) {}
+    fn nested(_p1: Box<Bad>, _p2: (&u8, &Bad)) {}
 
-    fn vals(_: Self) -> Self {
+    fn vals(_: Bad) -> Bad {
         Bad::default()
     }
 }
@@ -40,7 +40,7 @@ impl SelfTrait for Bad {
 impl Mul for Bad {
     type Output = Self;
 
-    fn mul(self, rhs: Self) -> Self {
+    fn mul(self, rhs: Bad) -> Bad {
         rhs
     }
 }
diff --git a/tests/ui/use_self_trait.stderr b/tests/ui/use_self_trait.stderr
index fa528cc5b7d..5409ccedf85 100644
--- a/tests/ui/use_self_trait.stderr
+++ b/tests/ui/use_self_trait.stderr
@@ -1,82 +1,10 @@
-error: unnecessary structure name repetition
-  --> $DIR/use_self_trait.rs:21:18
-   |
-LL |     fn refs(p1: &Bad) -> &Bad {
-   |                  ^^^ help: use the applicable keyword: `Self`
-   |
-   = note: `-D clippy::use-self` implied by `-D warnings`
-
-error: unnecessary structure name repetition
-  --> $DIR/use_self_trait.rs:21:27
-   |
-LL |     fn refs(p1: &Bad) -> &Bad {
-   |                           ^^^ help: use the applicable keyword: `Self`
-
-error: unnecessary structure name repetition
-  --> $DIR/use_self_trait.rs:25:33
-   |
-LL |     fn ref_refs<'a>(p1: &'a &'a Bad) -> &'a &'a Bad {
-   |                                 ^^^ help: use the applicable keyword: `Self`
-
-error: unnecessary structure name repetition
-  --> $DIR/use_self_trait.rs:25:49
-   |
-LL |     fn ref_refs<'a>(p1: &'a &'a Bad) -> &'a &'a Bad {
-   |                                                 ^^^ help: use the applicable keyword: `Self`
-
-error: unnecessary structure name repetition
-  --> $DIR/use_self_trait.rs:29:26
-   |
-LL |     fn mut_refs(p1: &mut Bad) -> &mut Bad {
-   |                          ^^^ help: use the applicable keyword: `Self`
-
-error: unnecessary structure name repetition
-  --> $DIR/use_self_trait.rs:29:39
-   |
-LL |     fn mut_refs(p1: &mut Bad) -> &mut Bad {
-   |                                       ^^^ help: use the applicable keyword: `Self`
-
-error: unnecessary structure name repetition
-  --> $DIR/use_self_trait.rs:33:24
-   |
-LL |     fn nested(_p1: Box<Bad>, _p2: (&u8, &Bad)) {}
-   |                        ^^^ help: use the applicable keyword: `Self`
-
-error: unnecessary structure name repetition
-  --> $DIR/use_self_trait.rs:33:42
-   |
-LL |     fn nested(_p1: Box<Bad>, _p2: (&u8, &Bad)) {}
-   |                                          ^^^ help: use the applicable keyword: `Self`
-
-error: unnecessary structure name repetition
-  --> $DIR/use_self_trait.rs:35:16
-   |
-LL |     fn vals(_: Bad) -> Bad {
-   |                ^^^ help: use the applicable keyword: `Self`
-
-error: unnecessary structure name repetition
-  --> $DIR/use_self_trait.rs:35:24
-   |
-LL |     fn vals(_: Bad) -> Bad {
-   |                        ^^^ help: use the applicable keyword: `Self`
-
 error: unnecessary structure name repetition
   --> $DIR/use_self_trait.rs:41:19
    |
 LL |     type Output = Bad;
    |                   ^^^ help: use the applicable keyword: `Self`
-
-error: unnecessary structure name repetition
-  --> $DIR/use_self_trait.rs:43:23
    |
-LL |     fn mul(self, rhs: Bad) -> Bad {
-   |                       ^^^ help: use the applicable keyword: `Self`
-
-error: unnecessary structure name repetition
-  --> $DIR/use_self_trait.rs:43:31
-   |
-LL |     fn mul(self, rhs: Bad) -> Bad {
-   |                               ^^^ help: use the applicable keyword: `Self`
+   = note: `-D clippy::use-self` implied by `-D warnings`
 
-error: aborting due to 13 previous errors
+error: aborting due to previous error
 
-- 
cgit 1.4.1-3-g733a5


From ae2dd671f5003e6722ca4d18ef447141db237213 Mon Sep 17 00:00:00 2001
From: flip1995 <hello@philkrones.com>
Date: Fri, 16 Oct 2020 13:25:38 +0200
Subject: Rewrite use_self lint one more time

This rewrite gets rid of complicated visitors, by using the lint infrastructure as much as possible
---
 clippy_lints/src/use_self.rs | 604 ++++++++++++++++++++++++-------------------
 1 file changed, 344 insertions(+), 260 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/use_self.rs b/clippy_lints/src/use_self.rs
index 023fce947b3..fbd996ad0e9 100644
--- a/clippy_lints/src/use_self.rs
+++ b/clippy_lints/src/use_self.rs
@@ -1,21 +1,22 @@
-use crate::utils;
-use crate::utils::snippet_opt;
-use crate::utils::span_lint_and_sugg;
+use crate::utils::{meets_msrv, qpath_res, snippet_opt, span_lint_and_sugg};
 use if_chain::if_chain;
+
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_hir::def::DefKind;
-use rustc_hir::intravisit::{walk_expr, walk_impl_item, walk_ty, NestedVisitorMap, Visitor};
 use rustc_hir::{
-    def, Expr, ExprKind, FnDecl, FnRetTy, FnSig, GenericArg, ImplItem, ImplItemKind, ItemKind, Node, Path, PathSegment,
+    def,
+    def_id::LocalDefId,
+    intravisit::{walk_ty, NestedVisitorMap, Visitor},
+    Expr, ExprKind, FnRetTy, FnSig, GenericArg, HirId, Impl, ImplItemKind, Item, ItemKind, Node, Path, PathSegment,
     QPath, TyKind,
 };
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::hir::map::Map;
 use rustc_middle::lint::in_external_macro;
-use rustc_middle::ty;
-use rustc_middle::ty::Ty;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_middle::ty::{AssocKind, Ty};
+use rustc_semver::RustcVersion;
+use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::{BytePos, Span};
 use rustc_typeck::hir_ty_to_ty;
 
@@ -28,9 +29,11 @@ declare_clippy_lint! {
     /// feels inconsistent.
     ///
     /// **Known problems:**
-    /// Unaddressed false negatives related to unresolved internal compiler errors.
+    /// - Unaddressed false negative in fn bodies of trait implementations
+    /// - False positive with assotiated types in traits (#4140)
     ///
     /// **Example:**
+    ///
     /// ```rust
     /// struct Foo {}
     /// impl Foo {
@@ -53,113 +56,216 @@ declare_clippy_lint! {
     "unnecessary structure name repetition whereas `Self` is applicable"
 }
 
-declare_lint_pass!(UseSelf => [USE_SELF]);
+#[derive(Default)]
+pub struct UseSelf {
+    msrv: Option<RustcVersion>,
+    stack: Vec<StackItem>,
+    types_to_skip: Vec<HirId>,
+    types_to_lint: Vec<HirId>,
+}
 
-const SEGMENTS_MSG: &str = "segments should be composed of at least 1 element";
+const USE_SELF_MSRV: RustcVersion = RustcVersion::new(1, 37, 0);
 
-fn span_lint(cx: &LateContext<'_>, span: Span) {
-    span_lint_and_sugg(
-        cx,
-        USE_SELF,
-        span,
-        "unnecessary structure name repetition",
-        "use the applicable keyword",
-        "Self".to_owned(),
-        Applicability::MachineApplicable,
-    );
+impl UseSelf {
+    #[must_use]
+    pub fn new(msrv: Option<RustcVersion>) -> Self {
+        Self {
+            msrv,
+            ..Self::default()
+        }
+    }
 }
 
-#[allow(clippy::cast_possible_truncation)]
-fn span_lint_until_last_segment<'tcx>(cx: &LateContext<'tcx>, span: Span, segment: &'tcx PathSegment<'tcx>) {
-    let sp = span.with_hi(segment.ident.span.lo());
-    // remove the trailing ::
-    let span_without_last_segment = match snippet_opt(cx, sp) {
-        Some(snippet) => match snippet.rfind("::") {
-            Some(bidx) => sp.with_hi(sp.lo() + BytePos(bidx as u32)),
-            None => sp,
-        },
-        None => sp,
-    };
-    span_lint(cx, span_without_last_segment);
+#[derive(Debug, PartialEq, Eq, Copy, Clone)]
+enum StackItem {
+    Check {
+        hir_id: HirId,
+        impl_trait_ref_def_id: Option<LocalDefId>,
+    },
+    NoCheck,
 }
 
-fn span_lint_on_path_until_last_segment<'tcx>(cx: &LateContext<'tcx>, path: &'tcx Path<'tcx>) {
-    if path.segments.len() > 1 {
-        span_lint_until_last_segment(cx, path.span, path.segments.last().unwrap());
+impl_lint_pass!(UseSelf => [USE_SELF]);
+
+const SEGMENTS_MSG: &str = "segments should be composed of at least 1 element";
+
+impl<'tcx> LateLintPass<'tcx> for UseSelf {
+    fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
+        // We push the self types of `impl`s on a stack here. Only the top type on the stack is
+        // relevant for linting, since this is the self type of the `impl` we're currently in. To
+        // avoid linting on nested items, we push `StackItem::NoCheck` on the stack to signal, that
+        // we're in an `impl` or nested item, that we don't want to lint
+        //
+        // NB: If you push something on the stack in this method, remember to also pop it in the
+        // `check_item_post` method.
+        match &item.kind {
+            ItemKind::Impl(Impl {
+                self_ty: hir_self_ty,
+                of_trait,
+                ..
+            }) => {
+                let should_check = if let TyKind::Path(QPath::Resolved(_, ref item_path)) = hir_self_ty.kind {
+                    let parameters = &item_path.segments.last().expect(SEGMENTS_MSG).args;
+                    parameters.as_ref().map_or(true, |params| {
+                        !params.parenthesized && !params.args.iter().any(|arg| matches!(arg, GenericArg::Lifetime(_)))
+                    })
+                } else {
+                    false
+                };
+                let impl_trait_ref_def_id = of_trait.as_ref().map(|_| cx.tcx.hir().local_def_id(item.hir_id));
+                if should_check {
+                    self.stack.push(StackItem::Check {
+                        hir_id: hir_self_ty.hir_id,
+                        impl_trait_ref_def_id,
+                    });
+                } else {
+                    self.stack.push(StackItem::NoCheck);
+                }
+            },
+            ItemKind::Static(..)
+            | ItemKind::Const(..)
+            | ItemKind::Fn(..)
+            | ItemKind::Enum(..)
+            | ItemKind::Struct(..)
+            | ItemKind::Union(..)
+            | ItemKind::Trait(..) => {
+                self.stack.push(StackItem::NoCheck);
+            },
+            _ => (),
+        }
     }
-}
 
-fn span_lint_on_qpath_resolved<'tcx>(cx: &LateContext<'tcx>, qpath: &'tcx QPath<'tcx>, until_last_segment: bool) {
-    if let QPath::Resolved(_, path) = qpath {
-        if until_last_segment {
-            span_lint_on_path_until_last_segment(cx, path);
-        } else {
-            span_lint(cx, path.span);
+    fn check_item_post(&mut self, _: &LateContext<'_>, item: &Item<'_>) {
+        use ItemKind::{Const, Enum, Fn, Impl, Static, Struct, Trait, Union};
+        match item.kind {
+            Impl { .. } | Static(..) | Const(..) | Fn(..) | Enum(..) | Struct(..) | Union(..) | Trait(..) => {
+                self.stack.pop();
+            },
+            _ => (),
         }
     }
-}
 
-struct BodyVisitor<'a, 'tcx> {
-    cx: &'a LateContext<'tcx>,
-    self_ty: Ty<'tcx>,
-}
+    fn check_impl_item(&mut self, cx: &LateContext<'_>, impl_item: &hir::ImplItem<'_>) {
+        // We want to skip types in trait `impl`s that aren't declared as `Self` in the trait
+        // declaration. The collection of those types is all this method implementation does.
+        if_chain! {
+            if let ImplItemKind::Fn(FnSig { decl, .. }, ..) = impl_item.kind;
+            if let Some(StackItem::Check { impl_trait_ref_def_id: Some(def_id), .. }) = self.stack.last().copied();
+            if let Some(impl_trait_ref) = cx.tcx.impl_trait_ref(def_id);
+            then {
+                // `self_ty` is the semantic self type of `impl <trait> for <type>`. This cannot be
+                // `Self`.
+                let self_ty = impl_trait_ref.self_ty();
+
+                // `trait_method_sig` is the signature of the function, how it is declared in the
+                // trait, not in the impl of the trait.
+                let trait_method = cx
+                    .tcx
+                    .associated_items(impl_trait_ref.def_id)
+                    .find_by_name_and_kind(cx.tcx, impl_item.ident, AssocKind::Fn, impl_trait_ref.def_id)
+                    .expect("impl method matches a trait method");
+                let trait_method_sig = cx.tcx.fn_sig(trait_method.def_id);
+                let trait_method_sig = cx.tcx.erase_late_bound_regions(trait_method_sig);
+
+                // `impl_inputs_outputs` is an iterator over the types (`hir::Ty`) declared in the
+                // implementation of the trait.
+                let output_hir_ty = if let FnRetTy::Return(ty) = &decl.output {
+                    Some(&**ty)
+                } else {
+                    None
+                };
+                let impl_inputs_outputs = decl.inputs.iter().chain(output_hir_ty);
+
+                // `impl_hir_ty` (of type `hir::Ty`) represents the type written in the signature.
+                //
+                // `trait_sem_ty` (of type `ty::Ty`) is the semantic type for the signature in the
+                // trait declaration. This is used to check if `Self` was used in the trait
+                // declaration.
+                //
+                // If `any`where in the `trait_sem_ty` the `self_ty` was used verbatim (as opposed
+                // to `Self`), we want to skip linting that type and all subtypes of it. This
+                // avoids suggestions to e.g. replace `Vec<u8>` with `Vec<Self>`, in an `impl Trait
+                // for u8`, when the trait always uses `Vec<u8>`.
+                //
+                // See also https://github.com/rust-lang/rust-clippy/issues/2894.
+                for (impl_hir_ty, trait_sem_ty) in impl_inputs_outputs.zip(trait_method_sig.inputs_and_output) {
+                    if trait_sem_ty.walk().any(|inner| inner == self_ty.into()) {
+                        let mut visitor = SkipTyCollector::default();
+                        visitor.visit_ty(&impl_hir_ty);
+                        self.types_to_skip.extend(visitor.types_to_skip);
+                    }
+                }
+            }
+        }
+    }
 
-impl<'a, 'tcx> BodyVisitor<'a, 'tcx> {
-    fn check_trait_method_impl_decl(
-        &mut self,
-        impl_item: &ImplItem<'tcx>,
-        impl_decl: &'tcx FnDecl<'tcx>,
-        impl_trait_ref: ty::TraitRef<'tcx>,
-    ) {
-        let tcx = self.cx.tcx;
-        let trait_method = tcx
-            .associated_items(impl_trait_ref.def_id)
-            .find_by_name_and_kind(tcx, impl_item.ident, ty::AssocKind::Fn, impl_trait_ref.def_id)
-            .expect("impl method matches a trait method");
-
-        let trait_method_sig = tcx.fn_sig(trait_method.def_id);
-        let trait_method_sig = tcx.erase_late_bound_regions(&trait_method_sig);
-
-        let output_hir_ty = if let FnRetTy::Return(ty) = &impl_decl.output {
-            Some(&**ty)
-        } else {
-            None
-        };
+    fn check_impl_item_post(&mut self, _: &LateContext<'_>, _: &hir::ImplItem<'_>) {
+        self.types_to_skip.clear();
+    }
 
-        // `impl_hir_ty` (of type `hir::Ty`) represents the type written in the signature.
-        // `trait_ty` (of type `ty::Ty`) is the semantic type for the signature in the trait.
-        // We use `impl_hir_ty` to see if the type was written as `Self`,
-        // `hir_ty_to_ty(...)` to check semantic types of paths, and
-        // `trait_ty` to determine which parts of the signature in the trait, mention
-        // the type being implemented verbatim (as opposed to `Self`).
-        for (impl_hir_ty, trait_ty) in impl_decl
-            .inputs
-            .iter()
-            .chain(output_hir_ty)
-            .zip(trait_method_sig.inputs_and_output)
-        {
-            // Check if the input/output type in the trait method specifies the implemented
-            // type verbatim, and only suggest `Self` if that isn't the case.
-            // This avoids suggestions to e.g. replace `Vec<u8>` with `Vec<Self>`,
-            // in an `impl Trait for u8`, when the trait always uses `Vec<u8>`.
-            // See also https://github.com/rust-lang/rust-clippy/issues/2894.
-            let self_ty = impl_trait_ref.self_ty();
-            if !trait_ty.walk().any(|inner| inner == self_ty.into()) {
-                self.visit_ty(&impl_hir_ty);
-            }
+    fn check_body(&mut self, cx: &LateContext<'tcx>, body: &'tcx hir::Body<'_>) {
+        // `hir_ty_to_ty` cannot be called in `Body`s or it will panic (sometimes). But in bodies
+        // we can use `cx.typeck_results.node_type(..)` to get the `ty::Ty` from a `hir::Ty`.
+        // However the `node_type()` method can *only* be called in bodies.
+        //
+        // This method implementation determines which types should get linted in a `Body` and
+        // which shouldn't, with a visitor. We could directly lint in the visitor, but then we
+        // could only allow this lint on item scope. And we would have to check if those types are
+        // already dealt with in `check_ty` anyway.
+        if let Some(StackItem::Check { hir_id, .. }) = self.stack.last() {
+            let self_ty = ty_from_hir_id(cx, *hir_id);
+
+            let mut visitor = LintTyCollector {
+                cx,
+                self_ty,
+                types_to_lint: vec![],
+                types_to_skip: vec![],
+            };
+            visitor.visit_expr(&body.value);
+            self.types_to_lint.extend(visitor.types_to_lint);
+            self.types_to_skip.extend(visitor.types_to_skip);
         }
     }
-}
 
-impl<'a, 'tcx> Visitor<'tcx> for BodyVisitor<'a, 'tcx> {
-    type Map = Map<'tcx>;
+    fn check_body_post(&mut self, _: &LateContext<'_>, _: &hir::Body<'_>) {
+        self.types_to_lint.clear();
+    }
 
-    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-        NestedVisitorMap::OnlyBodies(self.cx.tcx.hir())
+    fn check_ty(&mut self, cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>) {
+        if in_external_macro(cx.sess(), hir_ty.span)
+            | in_impl(cx, hir_ty)
+            | self.types_to_skip.contains(&hir_ty.hir_id)
+            | !meets_msrv(self.msrv.as_ref(), &USE_SELF_MSRV)
+        {
+            return;
+        }
+
+        let lint_dependend_on_expr_kind = || {
+            // FIXME: this span manipulation should not be necessary
+            // @flip1995 found an ast lowering issue in
+            // https://github.com/rust-lang/rust/blob/master/src/librustc_ast_lowering/path.rs#l142-l162
+            match cx.tcx.hir().find(cx.tcx.hir().get_parent_node(hir_ty.hir_id)) {
+                Some(Node::Expr(Expr {
+                    kind: ExprKind::Path(QPath::TypeRelative(_, segment)),
+                    ..
+                })) => span_lint_until_last_segment(cx, hir_ty.span, segment),
+                _ => span_lint(cx, hir_ty.span),
+            }
+        };
+
+        if self.types_to_lint.contains(&hir_ty.hir_id) {
+            lint_dependend_on_expr_kind();
+        } else if let Some(StackItem::Check { hir_id, .. }) = self.stack.last() {
+            let self_ty = ty_from_hir_id(cx, *hir_id);
+
+            if should_lint_ty(hir_ty, hir_ty_to_ty(cx.tcx, hir_ty), self_ty) {
+                lint_dependend_on_expr_kind();
+            }
+        }
     }
 
-    fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) {
-        fn expr_ty_matches<'tcx>(expr: &'tcx Expr<'tcx>, self_ty: Ty<'tcx>, cx: &LateContext<'tcx>) -> bool {
+    fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
+        fn expr_ty_matches(cx: &LateContext<'_>, expr: &Expr<'_>, self_ty: Ty<'_>) -> bool {
             let def_id = expr.hir_id.owner;
             if cx.tcx.has_typeck_results(def_id) {
                 cx.tcx.typeck(def_id).expr_ty_opt(expr) == Some(self_ty)
@@ -167,205 +273,183 @@ impl<'a, 'tcx> Visitor<'tcx> for BodyVisitor<'a, 'tcx> {
                 false
             }
         }
-        match expr.kind {
-            ExprKind::Struct(QPath::Resolved(_, path), ..) => {
-                if expr_ty_matches(expr, self.self_ty, self.cx) {
-                    match path.res {
-                        def::Res::SelfTy(..) => (),
-                        def::Res::Def(DefKind::Variant, _) => span_lint_on_path_until_last_segment(self.cx, path),
-                        _ => {
-                            span_lint(self.cx, path.span);
-                        },
+
+        if in_external_macro(cx.sess(), expr.span) | !meets_msrv(self.msrv.as_ref(), &USE_SELF_MSRV) {
+            return;
+        }
+
+        if let Some(StackItem::Check { hir_id, .. }) = self.stack.last() {
+            let self_ty = ty_from_hir_id(cx, *hir_id);
+
+            match &expr.kind {
+                ExprKind::Struct(QPath::Resolved(_, path), ..) => {
+                    if expr_ty_matches(cx, expr, self_ty) {
+                        match path.res {
+                            def::Res::SelfTy(..) => (),
+                            def::Res::Def(DefKind::Variant, _) => span_lint_on_path_until_last_segment(cx, path),
+                            _ => {
+                                span_lint(cx, path.span);
+                            },
+                        }
                     }
-                }
-            },
-            // tuple struct instantiation (`Foo(arg)` or `Enum::Foo(arg)`)
-            ExprKind::Call(fun, _) => {
-                if let Expr {
-                    kind: ExprKind::Path(ref qpath),
-                    ..
-                } = fun
-                {
-                    if expr_ty_matches(expr, self.self_ty, self.cx) {
-                        let res = utils::qpath_res(self.cx, qpath, fun.hir_id);
-
-                        if let def::Res::Def(DefKind::Ctor(ctor_of, _), ..) = res {
-                            match ctor_of {
-                                def::CtorOf::Variant => {
-                                    span_lint_on_qpath_resolved(self.cx, qpath, true);
-                                },
-                                def::CtorOf::Struct => {
-                                    span_lint_on_qpath_resolved(self.cx, qpath, false);
-                                },
+                },
+                // tuple struct instantiation (`Foo(arg)` or `Enum::Foo(arg)`)
+                ExprKind::Call(fun, _) => {
+                    if let Expr {
+                        kind: ExprKind::Path(ref qpath),
+                        ..
+                    } = fun
+                    {
+                        if expr_ty_matches(cx, expr, self_ty) {
+                            let res = qpath_res(cx, qpath, fun.hir_id);
+
+                            if let def::Res::Def(DefKind::Ctor(ctor_of, _), ..) = res {
+                                match ctor_of {
+                                    def::CtorOf::Variant => {
+                                        span_lint_on_qpath_resolved(cx, qpath, true);
+                                    },
+                                    def::CtorOf::Struct => {
+                                        span_lint_on_qpath_resolved(cx, qpath, false);
+                                    },
+                                }
                             }
                         }
                     }
-                }
-            },
-            // unit enum variants (`Enum::A`)
-            ExprKind::Path(ref qpath) => {
-                if expr_ty_matches(expr, self.self_ty, self.cx) {
-                    span_lint_on_qpath_resolved(self.cx, qpath, true);
-                }
-            },
-            _ => (),
+                },
+                // unit enum variants (`Enum::A`)
+                ExprKind::Path(qpath) => {
+                    if expr_ty_matches(cx, expr, self_ty) {
+                        span_lint_on_qpath_resolved(cx, &qpath, true);
+                    }
+                },
+                _ => (),
+            }
         }
-        walk_expr(self, expr);
     }
+
+    extract_msrv_attr!(LateContext);
 }
 
-struct FnSigVisitor<'a, 'tcx> {
-    cx: &'a LateContext<'tcx>,
-    self_ty: Ty<'tcx>,
+#[derive(Default)]
+struct SkipTyCollector {
+    types_to_skip: Vec<HirId>,
 }
 
-impl<'a, 'tcx> Visitor<'tcx> for FnSigVisitor<'a, 'tcx> {
+impl<'tcx> Visitor<'tcx> for SkipTyCollector {
     type Map = Map<'tcx>;
 
-    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-        NestedVisitorMap::None
-    }
+    fn visit_ty(&mut self, hir_ty: &hir::Ty<'_>) {
+        self.types_to_skip.push(hir_ty.hir_id);
 
-    fn visit_ty(&mut self, hir_ty: &'tcx hir::Ty<'tcx>) {
-        if let TyKind::Path(QPath::Resolved(_, path)) = hir_ty.kind {
-            match path.res {
-                def::Res::SelfTy(..) => {},
-                _ => {
-                    match self.cx.tcx.hir().find(self.cx.tcx.hir().get_parent_node(hir_ty.hir_id)) {
-                        Some(Node::Expr(Expr {
-                            kind: ExprKind::Path(QPath::TypeRelative(_, segment)),
-                            ..
-                        })) => {
-                            // The following block correctly identifies applicable lint locations
-                            // but `hir_ty_to_ty` calls cause odd ICEs.
-                            //
-                            if hir_ty_to_ty(self.cx.tcx, hir_ty) == self.self_ty {
-                                // fixme: this span manipulation should not be necessary
-                                // @flip1995 found an ast lowering issue in
-                                // https://github.com/rust-lang/rust/blob/master/src/librustc_ast_lowering/path.rs#l142-l162
-                                span_lint_until_last_segment(self.cx, hir_ty.span, segment);
-                            }
-                        },
-                        _ => {
-                            if hir_ty_to_ty(self.cx.tcx, hir_ty) == self.self_ty {
-                                span_lint(self.cx, hir_ty.span)
-                            }
-                        },
-                    }
-                },
-            }
-        }
+        walk_ty(self, hir_ty)
+    }
 
-        walk_ty(self, hir_ty);
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::None
     }
 }
 
-impl<'tcx> LateLintPass<'tcx> for UseSelf {
-    fn check_impl_item(&mut self, cx: &LateContext<'tcx>, impl_item: &'tcx ImplItem<'_>) {
-        if in_external_macro(cx.sess(), impl_item.span) {
-            return;
-        }
+struct LintTyCollector<'a, 'tcx> {
+    cx: &'a LateContext<'tcx>,
+    self_ty: Ty<'tcx>,
+    types_to_lint: Vec<HirId>,
+    types_to_skip: Vec<HirId>,
+}
 
-        let parent_id = cx.tcx.hir().get_parent_item(impl_item.hir_id);
-        let imp = cx.tcx.hir().expect_item(parent_id);
+impl<'a, 'tcx> Visitor<'tcx> for LintTyCollector<'a, 'tcx> {
+    type Map = Map<'tcx>;
 
+    fn visit_ty(&mut self, hir_ty: &'tcx hir::Ty<'_>) {
         if_chain! {
-            if let ItemKind::Impl { self_ty: hir_self_ty, .. } = imp.kind;
-            if let TyKind::Path(QPath::Resolved(_, ref item_path)) = hir_self_ty.kind;
+            if let Some(ty) = self.cx.typeck_results().node_type_opt(hir_ty.hir_id);
+            if should_lint_ty(hir_ty, ty, self.self_ty);
             then {
-                let parameters = &item_path.segments.last().expect(SEGMENTS_MSG).args;
-                let should_check = parameters.as_ref().map_or(
-                    true,
-                    |params| !params.parenthesized
-                        &&!params.args.iter().any(|arg| matches!(arg, GenericArg::Lifetime(_)))
-                );
-
-                // TODO: don't short-circuit upon lifetime parameters
-                if should_check {
-                    let self_ty = hir_ty_to_ty(cx.tcx, hir_self_ty);
-                    let body_visitor = &mut BodyVisitor { cx, self_ty };
-                    let fn_sig_visitor = &mut FnSigVisitor { cx, self_ty };
-
-                    let tcx = cx.tcx;
-                    let impl_def_id = tcx.hir().local_def_id(imp.hir_id);
-                    let impl_trait_ref = tcx.impl_trait_ref(impl_def_id);
-                    if_chain! {
-                        if let Some(impl_trait_ref) = impl_trait_ref;
-                        if let ImplItemKind::Fn(FnSig { decl: impl_decl, .. }, impl_body_id) = &impl_item.kind;
-                        then {
-                            body_visitor.check_trait_method_impl_decl(impl_item, impl_decl, impl_trait_ref);
-                            let body = tcx.hir().body(*impl_body_id);
-                            body_visitor.visit_body(body);
-                        } else {
-                            walk_impl_item(body_visitor, impl_item);
-                            walk_impl_item(fn_sig_visitor, impl_item);
-                        }
-                    }
-                }
+                self.types_to_lint.push(hir_ty.hir_id);
+            } else {
+                self.types_to_skip.push(hir_ty.hir_id);
             }
         }
+
+        walk_ty(self, hir_ty)
+    }
+
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::None
     }
-    extract_msrv_attr!(LateContext);
 }
 
-struct UseSelfVisitor<'a, 'tcx> {
-    item_path: &'a Path<'a>,
-    cx: &'a LateContext<'tcx>,
+fn span_lint(cx: &LateContext<'_>, span: Span) {
+    span_lint_and_sugg(
+        cx,
+        USE_SELF,
+        span,
+        "unnecessary structure name repetition",
+        "use the applicable keyword",
+        "Self".to_owned(),
+        Applicability::MachineApplicable,
+    );
 }
 
-impl<'a, 'tcx> Visitor<'tcx> for UseSelfVisitor<'a, 'tcx> {
-    type Map = Map<'tcx>;
+#[allow(clippy::cast_possible_truncation)]
+fn span_lint_until_last_segment(cx: &LateContext<'_>, span: Span, segment: &PathSegment<'_>) {
+    let sp = span.with_hi(segment.ident.span.lo());
+    // remove the trailing ::
+    let span_without_last_segment = match snippet_opt(cx, sp) {
+        Some(snippet) => match snippet.rfind("::") {
+            Some(bidx) => sp.with_hi(sp.lo() + BytePos(bidx as u32)),
+            None => sp,
+        },
+        None => sp,
+    };
+    span_lint(cx, span_without_last_segment);
+}
 
-    fn visit_path(&mut self, path: &'tcx Path<'_>, _id: HirId) {
-        if !path.segments.iter().any(|p| p.ident.span.is_dummy()) {
-            if path.segments.len() >= 2 {
-                let last_but_one = &path.segments[path.segments.len() - 2];
-                if last_but_one.ident.name != kw::SelfUpper {
-                    let enum_def_id = match path.res {
-                        Res::Def(DefKind::Variant, variant_def_id) => self.cx.tcx.parent(variant_def_id),
-                        Res::Def(DefKind::Ctor(def::CtorOf::Variant, _), ctor_def_id) => {
-                            let variant_def_id = self.cx.tcx.parent(ctor_def_id);
-                            variant_def_id.and_then(|def_id| self.cx.tcx.parent(def_id))
-                        },
-                        _ => None,
-                    };
-
-                    if self.item_path.res.opt_def_id() == enum_def_id {
-                        span_use_self_lint(self.cx, path, Some(last_but_one));
-                    }
-                }
-            }
+fn span_lint_on_path_until_last_segment(cx: &LateContext<'_>, path: &Path<'_>) {
+    if path.segments.len() > 1 {
+        span_lint_until_last_segment(cx, path.span, path.segments.last().unwrap());
+    }
+}
 
-            if path.segments.last().expect(SEGMENTS_MSG).ident.name != kw::SelfUpper {
-                if self.item_path.res == path.res {
-                    span_use_self_lint(self.cx, path, None);
-                } else if let Res::Def(DefKind::Ctor(def::CtorOf::Struct, _), ctor_def_id) = path.res {
-                    if self.item_path.res.opt_def_id() == self.cx.tcx.parent(ctor_def_id) {
-                        span_use_self_lint(self.cx, path, None);
-                    }
-                }
-            }
+fn span_lint_on_qpath_resolved(cx: &LateContext<'_>, qpath: &QPath<'_>, until_last_segment: bool) {
+    if let QPath::Resolved(_, path) = qpath {
+        if until_last_segment {
+            span_lint_on_path_until_last_segment(cx, path);
+        } else {
+            span_lint(cx, path.span);
         }
+    }
+}
 
-        walk_path(self, path);
+fn ty_from_hir_id<'tcx>(cx: &LateContext<'tcx>, hir_id: HirId) -> Ty<'tcx> {
+    if let Some(Node::Ty(hir_ty)) = cx.tcx.hir().find(hir_id) {
+        hir_ty_to_ty(cx.tcx, hir_ty)
+    } else {
+        unreachable!("This function should only be called with `HirId`s that are for sure `Node::Ty`")
     }
+}
 
-    fn visit_item(&mut self, item: &'tcx Item<'_>) {
-        match item.kind {
-            ItemKind::Use(..)
-            | ItemKind::Static(..)
-            | ItemKind::Enum(..)
-            | ItemKind::Struct(..)
-            | ItemKind::Union(..)
-            | ItemKind::Impl { .. }
-            | ItemKind::Fn(..) => {
-                // Don't check statements that shadow `Self` or where `Self` can't be used
-            },
-            _ => walk_item(self, item),
+fn in_impl(cx: &LateContext<'tcx>, hir_ty: &hir::Ty<'_>) -> bool {
+    let map = cx.tcx.hir();
+    let parent = map.get_parent_node(hir_ty.hir_id);
+    if_chain! {
+        if let Some(Node::Item(item)) = map.find(parent);
+        if let ItemKind::Impl { .. } = item.kind;
+        then {
+            true
+        } else {
+            false
         }
     }
+}
 
-    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-        NestedVisitorMap::All(self.cx.tcx.hir())
+fn should_lint_ty(hir_ty: &hir::Ty<'_>, ty: Ty<'_>, self_ty: Ty<'_>) -> bool {
+    if_chain! {
+        if ty == self_ty;
+        if let TyKind::Path(QPath::Resolved(_, path)) = hir_ty.kind;
+        then {
+            !matches!(path.res, def::Res::SelfTy(..))
+        } else {
+            false
+        }
     }
 }
-- 
cgit 1.4.1-3-g733a5


From da65d8166fe50a817a49d542460986234e94dc6d Mon Sep 17 00:00:00 2001
From: flip1995 <hello@philkrones.com>
Date: Sun, 17 Jan 2021 19:09:24 +0100
Subject: Don't trigger use_self in macros

---
 clippy_lints/src/use_self.rs            |  7 ++-
 tests/ui/auxiliary/proc_macro_derive.rs | 12 +++++
 tests/ui/use_self.fixed                 | 13 ++++--
 tests/ui/use_self.rs                    |  9 +++-
 tests/ui/use_self.stderr                | 82 ++++++++++++---------------------
 5 files changed, 63 insertions(+), 60 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/use_self.rs b/clippy_lints/src/use_self.rs
index fbd996ad0e9..3dfec190541 100644
--- a/clippy_lints/src/use_self.rs
+++ b/clippy_lints/src/use_self.rs
@@ -1,4 +1,4 @@
-use crate::utils::{meets_msrv, qpath_res, snippet_opt, span_lint_and_sugg};
+use crate::utils::{in_macro, meets_msrv, qpath_res, snippet_opt, span_lint_and_sugg};
 use if_chain::if_chain;
 
 use rustc_errors::Applicability;
@@ -13,7 +13,6 @@ use rustc_hir::{
 };
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::hir::map::Map;
-use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::{AssocKind, Ty};
 use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
@@ -232,7 +231,7 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
     }
 
     fn check_ty(&mut self, cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>) {
-        if in_external_macro(cx.sess(), hir_ty.span)
+        if in_macro(hir_ty.span)
             | in_impl(cx, hir_ty)
             | self.types_to_skip.contains(&hir_ty.hir_id)
             | !meets_msrv(self.msrv.as_ref(), &USE_SELF_MSRV)
@@ -274,7 +273,7 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
             }
         }
 
-        if in_external_macro(cx.sess(), expr.span) | !meets_msrv(self.msrv.as_ref(), &USE_SELF_MSRV) {
+        if in_macro(expr.span) | !meets_msrv(self.msrv.as_ref(), &USE_SELF_MSRV) {
             return;
         }
 
diff --git a/tests/ui/auxiliary/proc_macro_derive.rs b/tests/ui/auxiliary/proc_macro_derive.rs
index 24891682d36..aebeaf34679 100644
--- a/tests/ui/auxiliary/proc_macro_derive.rs
+++ b/tests/ui/auxiliary/proc_macro_derive.rs
@@ -41,3 +41,15 @@ pub fn derive_foo(_input: TokenStream) -> TokenStream {
         }
     }
 }
+
+#[proc_macro_derive(StructAUseSelf)]
+pub fn derive_use_self(_input: TokenStream) -> proc_macro::TokenStream {
+    quote! {
+        struct A;
+        impl A {
+            fn new() -> A {
+                A
+            }
+        }
+    }
+}
diff --git a/tests/ui/use_self.fixed b/tests/ui/use_self.fixed
index 1632e6aca44..95e7bc75431 100644
--- a/tests/ui/use_self.fixed
+++ b/tests/ui/use_self.fixed
@@ -1,10 +1,14 @@
 // run-rustfix
 // edition:2018
+// aux-build:proc_macro_derive.rs
 
 #![warn(clippy::use_self)]
 #![allow(dead_code)]
 #![allow(clippy::should_implement_trait, clippy::upper_case_acronyms, clippy::from_over_into)]
 
+#[macro_use]
+extern crate proc_macro_derive;
+
 fn main() {}
 
 mod use_self {
@@ -109,8 +113,8 @@ mod tuple_structs {
 mod macros {
     macro_rules! use_self_expand {
         () => {
-            fn new() -> Self {
-                Self {}
+            fn new() -> Foo {
+                Foo {}
             }
         };
     }
@@ -118,8 +122,11 @@ mod macros {
     struct Foo {}
 
     impl Foo {
-        use_self_expand!(); // Should lint in local macros
+        use_self_expand!(); // Should not lint in local macros
     }
+
+    #[derive(StructAUseSelf)] // Should not lint in derives
+    struct A;
 }
 
 mod nesting {
diff --git a/tests/ui/use_self.rs b/tests/ui/use_self.rs
index bbe92c9e338..75424f34159 100644
--- a/tests/ui/use_self.rs
+++ b/tests/ui/use_self.rs
@@ -1,10 +1,14 @@
 // run-rustfix
 // edition:2018
+// aux-build:proc_macro_derive.rs
 
 #![warn(clippy::use_self)]
 #![allow(dead_code)]
 #![allow(clippy::should_implement_trait, clippy::upper_case_acronyms, clippy::from_over_into)]
 
+#[macro_use]
+extern crate proc_macro_derive;
+
 fn main() {}
 
 mod use_self {
@@ -118,8 +122,11 @@ mod macros {
     struct Foo {}
 
     impl Foo {
-        use_self_expand!(); // Should lint in local macros
+        use_self_expand!(); // Should not lint in local macros
     }
+
+    #[derive(StructAUseSelf)] // Should not lint in derives
+    struct A;
 }
 
 mod nesting {
diff --git a/tests/ui/use_self.stderr b/tests/ui/use_self.stderr
index d86453eb2f0..37dfef7cfe0 100644
--- a/tests/ui/use_self.stderr
+++ b/tests/ui/use_self.stderr
@@ -1,5 +1,5 @@
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:14:21
+  --> $DIR/use_self.rs:18:21
    |
 LL |         fn new() -> Foo {
    |                     ^^^ help: use the applicable keyword: `Self`
@@ -7,194 +7,172 @@ LL |         fn new() -> Foo {
    = note: `-D clippy::use-self` implied by `-D warnings`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:15:13
+  --> $DIR/use_self.rs:19:13
    |
 LL |             Foo {}
    |             ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:17:22
+  --> $DIR/use_self.rs:21:22
    |
 LL |         fn test() -> Foo {
    |                      ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:18:13
+  --> $DIR/use_self.rs:22:13
    |
 LL |             Foo::new()
    |             ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:23:25
+  --> $DIR/use_self.rs:27:25
    |
 LL |         fn default() -> Foo {
    |                         ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:24:13
+  --> $DIR/use_self.rs:28:13
    |
 LL |             Foo::new()
    |             ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:89:24
+  --> $DIR/use_self.rs:93:24
    |
 LL |         fn bad(foos: &[Foo]) -> impl Iterator<Item = &Foo> {
    |                        ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:89:55
+  --> $DIR/use_self.rs:93:55
    |
 LL |         fn bad(foos: &[Foo]) -> impl Iterator<Item = &Foo> {
    |                                                       ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:104:13
+  --> $DIR/use_self.rs:108:13
    |
 LL |             TS(0)
    |             ^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:112:25
-   |
-LL |             fn new() -> Foo {
-   |                         ^^^ help: use the applicable keyword: `Self`
-...
-LL |         use_self_expand!(); // Should lint in local macros
-   |         ------------------- in this macro invocation
-   |
-   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
-
-error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:113:17
-   |
-LL |                 Foo {}
-   |                 ^^^ help: use the applicable keyword: `Self`
-...
-LL |         use_self_expand!(); // Should lint in local macros
-   |         ------------------- in this macro invocation
-   |
-   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
-
-error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:136:29
+  --> $DIR/use_self.rs:143:29
    |
 LL |                 fn bar() -> Bar {
    |                             ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:137:21
+  --> $DIR/use_self.rs:144:21
    |
 LL |                     Bar { foo: Foo {} }
    |                     ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:148:21
+  --> $DIR/use_self.rs:155:21
    |
 LL |         fn baz() -> Foo {
    |                     ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:149:13
+  --> $DIR/use_self.rs:156:13
    |
 LL |             Foo {}
    |             ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:166:21
+  --> $DIR/use_self.rs:173:21
    |
 LL |             let _ = Enum::B(42);
    |                     ^^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:167:21
+  --> $DIR/use_self.rs:174:21
    |
 LL |             let _ = Enum::C { field: true };
    |                     ^^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:168:21
+  --> $DIR/use_self.rs:175:21
    |
 LL |             let _ = Enum::A;
    |                     ^^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:210:13
+  --> $DIR/use_self.rs:217:13
    |
 LL |             nested::A::fun_1();
    |             ^^^^^^^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:211:13
+  --> $DIR/use_self.rs:218:13
    |
 LL |             nested::A::A;
    |             ^^^^^^^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:213:13
+  --> $DIR/use_self.rs:220:13
    |
 LL |             nested::A {};
    |             ^^^^^^^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:232:13
+  --> $DIR/use_self.rs:239:13
    |
 LL |             TestStruct::from_something()
    |             ^^^^^^^^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:246:25
+  --> $DIR/use_self.rs:253:25
    |
 LL |         async fn g() -> S {
    |                         ^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:247:13
+  --> $DIR/use_self.rs:254:13
    |
 LL |             S {}
    |             ^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:251:16
+  --> $DIR/use_self.rs:258:16
    |
 LL |             &p[S::A..S::B]
    |                ^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:251:22
+  --> $DIR/use_self.rs:258:22
    |
 LL |             &p[S::A..S::B]
    |                      ^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:274:29
+  --> $DIR/use_self.rs:281:29
    |
 LL |         fn foo(value: T) -> Foo<T> {
    |                             ^^^^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:275:13
+  --> $DIR/use_self.rs:282:13
    |
 LL |             Foo { value }
    |             ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:312:21
+  --> $DIR/use_self.rs:319:21
    |
 LL |         type From = T::From;
    |                     ^^^^^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:313:19
+  --> $DIR/use_self.rs:320:19
    |
 LL |         type To = T::To;
    |                   ^^^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:450:13
+  --> $DIR/use_self.rs:457:13
    |
 LL |             A::new::<submod::B>(submod::B {})
    |             ^ help: use the applicable keyword: `Self`
 
-error: aborting due to 31 previous errors
+error: aborting due to 29 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 7e1c1c154166d9eaa4184eab166b540e17ff26f3 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Tue, 9 Feb 2021 19:38:40 -0600
Subject: Fix qpath_res call

---
 clippy_lints/src/use_self.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/use_self.rs b/clippy_lints/src/use_self.rs
index 3dfec190541..cdaa08be86b 100644
--- a/clippy_lints/src/use_self.rs
+++ b/clippy_lints/src/use_self.rs
@@ -1,4 +1,4 @@
-use crate::utils::{in_macro, meets_msrv, qpath_res, snippet_opt, span_lint_and_sugg};
+use crate::utils::{in_macro, meets_msrv, snippet_opt, span_lint_and_sugg};
 use if_chain::if_chain;
 
 use rustc_errors::Applicability;
@@ -300,7 +300,7 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
                     } = fun
                     {
                         if expr_ty_matches(cx, expr, self_ty) {
-                            let res = qpath_res(cx, qpath, fun.hir_id);
+                            let res = cx.qpath_res(qpath, fun.hir_id);
 
                             if let def::Res::Def(DefKind::Ctor(ctor_of, _), ..) = res {
                                 match ctor_of {
-- 
cgit 1.4.1-3-g733a5


From 7f61ddd5b85f5e2340ef238476139df8a837afb1 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Tue, 9 Feb 2021 19:39:38 -0600
Subject: Move "types to lint" to the item stack

---
 clippy_lints/src/use_self.rs | 73 +++++++++++++++++++++++++-------------------
 1 file changed, 41 insertions(+), 32 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/use_self.rs b/clippy_lints/src/use_self.rs
index cdaa08be86b..8c83ad5650d 100644
--- a/clippy_lints/src/use_self.rs
+++ b/clippy_lints/src/use_self.rs
@@ -59,8 +59,6 @@ declare_clippy_lint! {
 pub struct UseSelf {
     msrv: Option<RustcVersion>,
     stack: Vec<StackItem>,
-    types_to_skip: Vec<HirId>,
-    types_to_lint: Vec<HirId>,
 }
 
 const USE_SELF_MSRV: RustcVersion = RustcVersion::new(1, 37, 0);
@@ -75,11 +73,13 @@ impl UseSelf {
     }
 }
 
-#[derive(Debug, PartialEq, Eq, Copy, Clone)]
+#[derive(Debug)]
 enum StackItem {
     Check {
         hir_id: HirId,
         impl_trait_ref_def_id: Option<LocalDefId>,
+        types_to_skip: Vec<HirId>,
+        types_to_lint: Vec<HirId>,
     },
     NoCheck,
 }
@@ -116,6 +116,8 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
                     self.stack.push(StackItem::Check {
                         hir_id: hir_self_ty.hir_id,
                         impl_trait_ref_def_id,
+                        types_to_lint: Vec::new(),
+                        types_to_skip: Vec::new(),
                     });
                 } else {
                     self.stack.push(StackItem::NoCheck);
@@ -149,7 +151,11 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
         // declaration. The collection of those types is all this method implementation does.
         if_chain! {
             if let ImplItemKind::Fn(FnSig { decl, .. }, ..) = impl_item.kind;
-            if let Some(StackItem::Check { impl_trait_ref_def_id: Some(def_id), .. }) = self.stack.last().copied();
+            if let Some(&mut StackItem::Check {
+                impl_trait_ref_def_id: Some(def_id),
+                ref mut types_to_skip,
+                ..
+            }) = self.stack.last_mut();
             if let Some(impl_trait_ref) = cx.tcx.impl_trait_ref(def_id);
             then {
                 // `self_ty` is the semantic self type of `impl <trait> for <type>`. This cannot be
@@ -191,17 +197,13 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
                     if trait_sem_ty.walk().any(|inner| inner == self_ty.into()) {
                         let mut visitor = SkipTyCollector::default();
                         visitor.visit_ty(&impl_hir_ty);
-                        self.types_to_skip.extend(visitor.types_to_skip);
+                        types_to_skip.extend(visitor.types_to_skip);
                     }
                 }
             }
         }
     }
 
-    fn check_impl_item_post(&mut self, _: &LateContext<'_>, _: &hir::ImplItem<'_>) {
-        self.types_to_skip.clear();
-    }
-
     fn check_body(&mut self, cx: &LateContext<'tcx>, body: &'tcx hir::Body<'_>) {
         // `hir_ty_to_ty` cannot be called in `Body`s or it will panic (sometimes). But in bodies
         // we can use `cx.typeck_results.node_type(..)` to get the `ty::Ty` from a `hir::Ty`.
@@ -211,7 +213,13 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
         // which shouldn't, with a visitor. We could directly lint in the visitor, but then we
         // could only allow this lint on item scope. And we would have to check if those types are
         // already dealt with in `check_ty` anyway.
-        if let Some(StackItem::Check { hir_id, .. }) = self.stack.last() {
+        if let Some(StackItem::Check {
+            hir_id,
+            types_to_lint,
+            types_to_skip,
+            ..
+        }) = self.stack.last_mut()
+        {
             let self_ty = ty_from_hir_id(cx, *hir_id);
 
             let mut visitor = LintTyCollector {
@@ -221,25 +229,36 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
                 types_to_skip: vec![],
             };
             visitor.visit_expr(&body.value);
-            self.types_to_lint.extend(visitor.types_to_lint);
-            self.types_to_skip.extend(visitor.types_to_skip);
+            types_to_lint.extend(visitor.types_to_lint);
+            types_to_skip.extend(visitor.types_to_skip);
         }
     }
 
-    fn check_body_post(&mut self, _: &LateContext<'_>, _: &hir::Body<'_>) {
-        self.types_to_lint.clear();
-    }
-
     fn check_ty(&mut self, cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>) {
-        if in_macro(hir_ty.span)
-            | in_impl(cx, hir_ty)
-            | self.types_to_skip.contains(&hir_ty.hir_id)
-            | !meets_msrv(self.msrv.as_ref(), &USE_SELF_MSRV)
-        {
+        if in_macro(hir_ty.span) | in_impl(cx, hir_ty) | !meets_msrv(self.msrv.as_ref(), &USE_SELF_MSRV) {
             return;
         }
 
-        let lint_dependend_on_expr_kind = || {
+        let lint_dependend_on_expr_kind = if let Some(StackItem::Check {
+            hir_id,
+            types_to_lint,
+            types_to_skip,
+            ..
+        }) = self.stack.last()
+        {
+            if types_to_skip.contains(&hir_ty.hir_id) {
+                false
+            } else if types_to_lint.contains(&hir_ty.hir_id) {
+                true
+            } else {
+                let self_ty = ty_from_hir_id(cx, *hir_id);
+                should_lint_ty(hir_ty, hir_ty_to_ty(cx.tcx, hir_ty), self_ty)
+            }
+        } else {
+            false
+        };
+
+        if lint_dependend_on_expr_kind {
             // FIXME: this span manipulation should not be necessary
             // @flip1995 found an ast lowering issue in
             // https://github.com/rust-lang/rust/blob/master/src/librustc_ast_lowering/path.rs#l142-l162
@@ -250,16 +269,6 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
                 })) => span_lint_until_last_segment(cx, hir_ty.span, segment),
                 _ => span_lint(cx, hir_ty.span),
             }
-        };
-
-        if self.types_to_lint.contains(&hir_ty.hir_id) {
-            lint_dependend_on_expr_kind();
-        } else if let Some(StackItem::Check { hir_id, .. }) = self.stack.last() {
-            let self_ty = ty_from_hir_id(cx, *hir_id);
-
-            if should_lint_ty(hir_ty, hir_ty_to_ty(cx.tcx, hir_ty), self_ty) {
-                lint_dependend_on_expr_kind();
-            }
         }
     }
 
-- 
cgit 1.4.1-3-g733a5


From 52f98d832dc5ca982b9edad7807b2a9a9ddd13e0 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Tue, 9 Feb 2021 19:42:32 -0600
Subject: Use TyS::same_type

---
 clippy_lints/src/use_self.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/use_self.rs b/clippy_lints/src/use_self.rs
index 8c83ad5650d..a0dd53af661 100644
--- a/clippy_lints/src/use_self.rs
+++ b/clippy_lints/src/use_self.rs
@@ -13,7 +13,7 @@ use rustc_hir::{
 };
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::hir::map::Map;
-use rustc_middle::ty::{AssocKind, Ty};
+use rustc_middle::ty::{AssocKind, Ty, TyS};
 use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::{BytePos, Span};
@@ -452,7 +452,7 @@ fn in_impl(cx: &LateContext<'tcx>, hir_ty: &hir::Ty<'_>) -> bool {
 
 fn should_lint_ty(hir_ty: &hir::Ty<'_>, ty: Ty<'_>, self_ty: Ty<'_>) -> bool {
     if_chain! {
-        if ty == self_ty;
+        if TyS::same_type(ty, self_ty);
         if let TyKind::Path(QPath::Resolved(_, path)) = hir_ty.kind;
         then {
             !matches!(path.res, def::Res::SelfTy(..))
-- 
cgit 1.4.1-3-g733a5


From 94b8f23baf045b16e2a8b2e2cdd7436724bbf8d5 Mon Sep 17 00:00:00 2001
From: alpaca-tc <alpaca-tc@alpaca.tc>
Date: Thu, 11 Feb 2021 00:45:28 +0900
Subject: Fix typo

---
 clippy_lints/src/methods/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 4cb3a858511..d3db9c666df 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1503,7 +1503,7 @@ declare_clippy_lint! {
     ///
     /// ```rust
     /// // Bad
-    /// let _ = "Hello".bytes().nth(3);;
+    /// let _ = "Hello".bytes().nth(3);
     ///
     /// // Good
     /// let _ = "Hello".as_bytes().get(3);
-- 
cgit 1.4.1-3-g733a5


From b80ac2af9c0939428054e7d018f19fc16b920b05 Mon Sep 17 00:00:00 2001
From: boolean_coercion <booleancoercion@gmail.com>
Date: Wed, 10 Feb 2021 21:47:04 +0200
Subject: Added boilerplate

---
 CHANGELOG.md                          |  1 +
 clippy_lints/src/from_str_radix_10.rs | 34 ++++++++++++++++++++++++++++++++++
 clippy_lints/src/lib.rs               |  4 ++++
 tests/ui/from_str_radix_10.rs         |  5 +++++
 4 files changed, 44 insertions(+)
 create mode 100644 clippy_lints/src/from_str_radix_10.rs
 create mode 100644 tests/ui/from_str_radix_10.rs

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 4dcf9c3529b..56b74a7d0ab 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2092,6 +2092,7 @@ Released 2018-09-13
 [`forget_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#forget_ref
 [`from_iter_instead_of_collect`]: https://rust-lang.github.io/rust-clippy/master/index.html#from_iter_instead_of_collect
 [`from_over_into`]: https://rust-lang.github.io/rust-clippy/master/index.html#from_over_into
+[`from_str_radix_10`]: https://rust-lang.github.io/rust-clippy/master/index.html#from_str_radix_10
 [`future_not_send`]: https://rust-lang.github.io/rust-clippy/master/index.html#future_not_send
 [`get_last_with_len`]: https://rust-lang.github.io/rust-clippy/master/index.html#get_last_with_len
 [`get_unwrap`]: https://rust-lang.github.io/rust-clippy/master/index.html#get_unwrap
diff --git a/clippy_lints/src/from_str_radix_10.rs b/clippy_lints/src/from_str_radix_10.rs
new file mode 100644
index 00000000000..ec2a60ec47c
--- /dev/null
+++ b/clippy_lints/src/from_str_radix_10.rs
@@ -0,0 +1,34 @@
+use rustc_lint::{EarlyLintPass, EarlyContext};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_ast::ast::*;
+
+declare_clippy_lint! {
+    /// **What it does:**
+    /// Checks for function invocations of the form `primitive::from_str_radix(s, 10)`
+    ///
+    /// **Why is this bad?**
+    /// This specific common use case can be rewritten as `s.parse::<primitive>()`
+    /// (and in most cases, the turbofish can be removed), which reduces code length
+    /// and complexity.
+    ///
+    /// **Known problems:** None.
+    /// 
+    /// **Example:**
+    ///
+    /// ```rust
+    /// let input: &str = get_input();
+    /// let num = u16::from_str_radix(input, 10)?;
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// let input: &str = get_input();
+    /// let num: u16 = input.parse()?;
+    /// ```
+    pub FROM_STR_RADIX_10,
+    style,
+    "default lint description"
+}
+
+declare_lint_pass!(FromStrRadix10 => [FROM_STR_RADIX_10]);
+
+impl EarlyLintPass for FromStrRadix10 {}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index d96911fac1a..5b84422458f 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -210,6 +210,7 @@ mod floating_point_arithmetic;
 mod format;
 mod formatting;
 mod from_over_into;
+mod from_str_radix_10;
 mod functions;
 mod future_not_send;
 mod get_last_with_len;
@@ -637,6 +638,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &formatting::SUSPICIOUS_ELSE_FORMATTING,
         &formatting::SUSPICIOUS_UNARY_OP_FORMATTING,
         &from_over_into::FROM_OVER_INTO,
+        &from_str_radix_10::FROM_STR_RADIX_10,
         &functions::DOUBLE_MUST_USE,
         &functions::MUST_USE_CANDIDATE,
         &functions::MUST_USE_UNIT,
@@ -1468,6 +1470,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&formatting::SUSPICIOUS_ELSE_FORMATTING),
         LintId::of(&formatting::SUSPICIOUS_UNARY_OP_FORMATTING),
         LintId::of(&from_over_into::FROM_OVER_INTO),
+        LintId::of(&from_str_radix_10::FROM_STR_RADIX_10),
         LintId::of(&functions::DOUBLE_MUST_USE),
         LintId::of(&functions::MUST_USE_UNIT),
         LintId::of(&functions::NOT_UNSAFE_PTR_ARG_DEREF),
@@ -1724,6 +1727,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&formatting::SUSPICIOUS_ELSE_FORMATTING),
         LintId::of(&formatting::SUSPICIOUS_UNARY_OP_FORMATTING),
         LintId::of(&from_over_into::FROM_OVER_INTO),
+        LintId::of(&from_str_radix_10::FROM_STR_RADIX_10),
         LintId::of(&functions::DOUBLE_MUST_USE),
         LintId::of(&functions::MUST_USE_UNIT),
         LintId::of(&functions::RESULT_UNIT_ERR),
diff --git a/tests/ui/from_str_radix_10.rs b/tests/ui/from_str_radix_10.rs
new file mode 100644
index 00000000000..70eaa8d666c
--- /dev/null
+++ b/tests/ui/from_str_radix_10.rs
@@ -0,0 +1,5 @@
+#![warn(clippy::from_str_radix_10)]
+
+fn main() {
+    // test code goes here
+}
-- 
cgit 1.4.1-3-g733a5


From 64729390a1b2b6b05f8a4407658163ddff4d017e Mon Sep 17 00:00:00 2001
From: boolean_coercion <booleancoercion@gmail.com>
Date: Thu, 11 Feb 2021 02:30:37 +0200
Subject: Implemented majority of from_str_radix_10

---
 clippy_lints/src/from_str_radix_10.rs | 59 ++++++++++++++++++++++++++++++++---
 clippy_lints/src/lib.rs               |  1 +
 tests/ui/from_str_radix_10.rs         | 32 +++++++++++++++++--
 3 files changed, 86 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/from_str_radix_10.rs b/clippy_lints/src/from_str_radix_10.rs
index ec2a60ec47c..612ea9ae62c 100644
--- a/clippy_lints/src/from_str_radix_10.rs
+++ b/clippy_lints/src/from_str_radix_10.rs
@@ -1,6 +1,10 @@
-use rustc_lint::{EarlyLintPass, EarlyContext};
+use rustc_lint::{LateLintPass, LateContext};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_ast::ast::*;
+use rustc_hir::*;
+use rustc_errors::Applicability;
+use if_chain::if_chain;
+
+use crate::utils::span_lint_and_sugg;
 
 declare_clippy_lint! {
     /// **What it does:**
@@ -26,9 +30,56 @@ declare_clippy_lint! {
     /// ```
     pub FROM_STR_RADIX_10,
     style,
-    "default lint description"
+    "from_str_radix with radix 10"
 }
 
 declare_lint_pass!(FromStrRadix10 => [FROM_STR_RADIX_10]);
 
-impl EarlyLintPass for FromStrRadix10 {}
+impl LateLintPass<'tcx> for FromStrRadix10 {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, exp: &Expr<'tcx>) {
+        if_chain! {
+            if let ExprKind::Call(maybe_path, arguments) = &exp.kind;
+            if let ExprKind::Path(qpath) = &maybe_path.kind;
+            if let QPath::TypeRelative(ty, pathseg) = &qpath;
+
+            // check if the first part of the path is some integer primitive
+            if let TyKind::Path(ty_qpath) = &ty.kind;
+            let ty_res = cx.qpath_res(ty_qpath, ty.hir_id);
+            if let def::Res::PrimTy(prim_ty) = ty_res;
+            if is_primitive_integer_ty(prim_ty);
+
+            // check if the second part of the path indeed calls the associated
+            // function `from_str_radix`
+            if pathseg.ident.name.as_str() == "from_str_radix";
+
+            // check if the second argument resolves to a constant `10`
+            if arguments.len() == 2;
+            if is_constant_10(&arguments[1]);
+
+            then {
+                span_lint_and_sugg(
+                    cx,
+                    FROM_STR_RADIX_10,
+                    exp.span,
+                    "This call to `from_str_radix` can be shortened to a call to str::parse",
+                    "try",
+                    format!("TODO"),
+                    Applicability::MachineApplicable
+                );
+            }
+        }
+    }
+}
+
+fn is_primitive_integer_ty(ty: PrimTy) -> bool {
+    match ty {
+        PrimTy::Int(_) => true,
+        PrimTy::Uint(_) => true,
+        _ => false
+    }
+}
+
+fn is_constant_10<'tcx>(expr: &Expr<'tcx>) -> bool {
+    // TODO
+    true
+}
\ No newline at end of file
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 5b84422458f..dae686b1229 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1258,6 +1258,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(move || box types::PtrAsPtr::new(msrv));
     store.register_late_pass(|| box case_sensitive_file_extension_comparisons::CaseSensitiveFileExtensionComparisons);
     store.register_late_pass(|| box redundant_slicing::RedundantSlicing);
+    store.register_late_pass(|| box from_str_radix_10::FromStrRadix10);
 
     store.register_group(true, "clippy::restriction", Some("clippy_restriction"), vec![
         LintId::of(&arithmetic::FLOAT_ARITHMETIC),
diff --git a/tests/ui/from_str_radix_10.rs b/tests/ui/from_str_radix_10.rs
index 70eaa8d666c..086616d09ff 100644
--- a/tests/ui/from_str_radix_10.rs
+++ b/tests/ui/from_str_radix_10.rs
@@ -1,5 +1,33 @@
 #![warn(clippy::from_str_radix_10)]
 
-fn main() {
-    // test code goes here
+mod some_mod {
+    // fake function that shouldn't trigger the lint
+    pub fn from_str_radix(_: &str, _: u32) -> Result<(), std::num::ParseIntError> {
+        unimplemented!()
+    }
 }
+
+// fake function that shouldn't trigger the lint
+fn from_str_radix(_: &str, _: u32) -> Result<(), std::num::ParseIntError> {
+    unimplemented!()
+}
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    // all of these should trigger the lint
+    u32::from_str_radix("30", 10)?;
+    i64::from_str_radix("24", 10)?;
+    isize::from_str_radix("100", 10)?;
+    u8::from_str_radix("7", 10)?;
+
+    // none of these should trigger the lint
+    u16::from_str_radix("20", 3)?;
+    i32::from_str_radix("45", 12)?;
+    usize::from_str_radix("10", 16)?;
+    i128::from_str_radix("10", 13)?;
+    some_mod::from_str_radix("50", 10)?;
+    some_mod::from_str_radix("50", 6)?;
+    from_str_radix("50", 10)?;
+    from_str_radix("50", 6)?;
+
+    Ok(())
+}
\ No newline at end of file
-- 
cgit 1.4.1-3-g733a5


From a389c02461107a71da042c1a9dbf4c0e597df3b4 Mon Sep 17 00:00:00 2001
From: boolean_coercion <booleancoercion@gmail.com>
Date: Thu, 11 Feb 2021 12:30:23 +0200
Subject: from_str_radix_10 should be done

---
 clippy_lints/src/from_str_radix_10.rs | 13 +++++--------
 1 file changed, 5 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/from_str_radix_10.rs b/clippy_lints/src/from_str_radix_10.rs
index 612ea9ae62c..57661e0f9bc 100644
--- a/clippy_lints/src/from_str_radix_10.rs
+++ b/clippy_lints/src/from_str_radix_10.rs
@@ -52,18 +52,20 @@ impl LateLintPass<'tcx> for FromStrRadix10 {
             // function `from_str_radix`
             if pathseg.ident.name.as_str() == "from_str_radix";
 
-            // check if the second argument resolves to a constant `10`
+            // check if the second argument is a primitive `10`
             if arguments.len() == 2;
-            if is_constant_10(&arguments[1]);
+            if let ExprKind::Lit(lit) = &arguments[1].kind;
+            if let rustc_ast::ast::LitKind::Int(10, _) = lit.node;
 
             then {
+                let orig_string = crate::utils::snippet(cx, arguments[0].span, "string");
                 span_lint_and_sugg(
                     cx,
                     FROM_STR_RADIX_10,
                     exp.span,
                     "This call to `from_str_radix` can be shortened to a call to str::parse",
                     "try",
-                    format!("TODO"),
+                    format!("({}).parse()", orig_string),
                     Applicability::MachineApplicable
                 );
             }
@@ -77,9 +79,4 @@ fn is_primitive_integer_ty(ty: PrimTy) -> bool {
         PrimTy::Uint(_) => true,
         _ => false
     }
-}
-
-fn is_constant_10<'tcx>(expr: &Expr<'tcx>) -> bool {
-    // TODO
-    true
 }
\ No newline at end of file
-- 
cgit 1.4.1-3-g733a5


From 0b31b470ad743fc758a1c47a17d7241948cd4a3b Mon Sep 17 00:00:00 2001
From: boolean_coercion <booleancoercion@gmail.com>
Date: Thu, 11 Feb 2021 12:42:20 +0200
Subject: Changed applicability to MaybeIncorrect because of surrounding braces

---
 clippy_lints/src/from_str_radix_10.rs | 2 +-
 tests/ui/from_str_radix_10.rs         | 3 +++
 2 files changed, 4 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/from_str_radix_10.rs b/clippy_lints/src/from_str_radix_10.rs
index 57661e0f9bc..9371104bf9b 100644
--- a/clippy_lints/src/from_str_radix_10.rs
+++ b/clippy_lints/src/from_str_radix_10.rs
@@ -66,7 +66,7 @@ impl LateLintPass<'tcx> for FromStrRadix10 {
                     "This call to `from_str_radix` can be shortened to a call to str::parse",
                     "try",
                     format!("({}).parse()", orig_string),
-                    Applicability::MachineApplicable
+                    Applicability::MaybeIncorrect
                 );
             }
         }
diff --git a/tests/ui/from_str_radix_10.rs b/tests/ui/from_str_radix_10.rs
index 086616d09ff..795e795fcb3 100644
--- a/tests/ui/from_str_radix_10.rs
+++ b/tests/ui/from_str_radix_10.rs
@@ -19,6 +19,9 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     isize::from_str_radix("100", 10)?;
     u8::from_str_radix("7", 10)?;
 
+    let string = "300";
+    i32::from_str_radix(string, 10)?;
+
     // none of these should trigger the lint
     u16::from_str_radix("20", 3)?;
     i32::from_str_radix("45", 12)?;
-- 
cgit 1.4.1-3-g733a5


From d1a627ab3bd801879a565cc9e68a322d8d28bcbf Mon Sep 17 00:00:00 2001
From: boolean_coercion <booleancoercion@gmail.com>
Date: Thu, 11 Feb 2021 12:46:11 +0200
Subject: Ran bless and rustfmt

---
 clippy_lints/src/from_str_radix_10.rs | 14 +++++++-------
 tests/ui/from_str_radix_10.rs         |  2 +-
 tests/ui/from_str_radix_10.stderr     | 34 ++++++++++++++++++++++++++++++++++
 3 files changed, 42 insertions(+), 8 deletions(-)
 create mode 100644 tests/ui/from_str_radix_10.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/from_str_radix_10.rs b/clippy_lints/src/from_str_radix_10.rs
index 9371104bf9b..9a8d4542616 100644
--- a/clippy_lints/src/from_str_radix_10.rs
+++ b/clippy_lints/src/from_str_radix_10.rs
@@ -1,8 +1,8 @@
-use rustc_lint::{LateLintPass, LateContext};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_hir::*;
-use rustc_errors::Applicability;
 use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir::*;
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 use crate::utils::span_lint_and_sugg;
 
@@ -16,7 +16,7 @@ declare_clippy_lint! {
     /// and complexity.
     ///
     /// **Known problems:** None.
-    /// 
+    ///
     /// **Example:**
     ///
     /// ```rust
@@ -77,6 +77,6 @@ fn is_primitive_integer_ty(ty: PrimTy) -> bool {
     match ty {
         PrimTy::Int(_) => true,
         PrimTy::Uint(_) => true,
-        _ => false
+        _ => false,
     }
-}
\ No newline at end of file
+}
diff --git a/tests/ui/from_str_radix_10.rs b/tests/ui/from_str_radix_10.rs
index 795e795fcb3..2d8106da7ba 100644
--- a/tests/ui/from_str_radix_10.rs
+++ b/tests/ui/from_str_radix_10.rs
@@ -33,4 +33,4 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     from_str_radix("50", 6)?;
 
     Ok(())
-}
\ No newline at end of file
+}
diff --git a/tests/ui/from_str_radix_10.stderr b/tests/ui/from_str_radix_10.stderr
new file mode 100644
index 00000000000..376d0dd56ea
--- /dev/null
+++ b/tests/ui/from_str_radix_10.stderr
@@ -0,0 +1,34 @@
+error: This call to `from_str_radix` can be shortened to a call to str::parse
+  --> $DIR/from_str_radix_10.rs:17:5
+   |
+LL |     u32::from_str_radix("30", 10)?;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `("30").parse()`
+   |
+   = note: `-D clippy::from-str-radix-10` implied by `-D warnings`
+
+error: This call to `from_str_radix` can be shortened to a call to str::parse
+  --> $DIR/from_str_radix_10.rs:18:5
+   |
+LL |     i64::from_str_radix("24", 10)?;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `("24").parse()`
+
+error: This call to `from_str_radix` can be shortened to a call to str::parse
+  --> $DIR/from_str_radix_10.rs:19:5
+   |
+LL |     isize::from_str_radix("100", 10)?;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `("100").parse()`
+
+error: This call to `from_str_radix` can be shortened to a call to str::parse
+  --> $DIR/from_str_radix_10.rs:20:5
+   |
+LL |     u8::from_str_radix("7", 10)?;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `("7").parse()`
+
+error: This call to `from_str_radix` can be shortened to a call to str::parse
+  --> $DIR/from_str_radix_10.rs:23:5
+   |
+LL |     i32::from_str_radix(string, 10)?;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `(string).parse()`
+
+error: aborting due to 5 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 9194c11d69aa98c9d85fd0979bf9b93d3d7de809 Mon Sep 17 00:00:00 2001
From: boolean_coercion <booleancoercion@gmail.com>
Date: Thu, 11 Feb 2021 13:15:06 +0200
Subject: Fixed doctests that shouldn't have been compiled

---
 clippy_lints/src/from_str_radix_10.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/from_str_radix_10.rs b/clippy_lints/src/from_str_radix_10.rs
index 9a8d4542616..53cb1e3ecd9 100644
--- a/clippy_lints/src/from_str_radix_10.rs
+++ b/clippy_lints/src/from_str_radix_10.rs
@@ -19,12 +19,12 @@ declare_clippy_lint! {
     ///
     /// **Example:**
     ///
-    /// ```rust
+    /// ```ignore
     /// let input: &str = get_input();
     /// let num = u16::from_str_radix(input, 10)?;
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```ignore
     /// let input: &str = get_input();
     /// let num: u16 = input.parse()?;
     /// ```
-- 
cgit 1.4.1-3-g733a5


From 642efabfbbba6577a3698a305bac8ce0c693e67f Mon Sep 17 00:00:00 2001
From: boolean_coercion <booleancoercion@gmail.com>
Date: Fri, 12 Feb 2021 11:53:52 +0200
Subject: Fixed typos and updated to matches! where applicable

---
 clippy_lints/src/from_str_radix_10.rs | 12 ++----------
 tests/ui/from_str_radix_10.stderr     | 10 +++++-----
 2 files changed, 7 insertions(+), 15 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/from_str_radix_10.rs b/clippy_lints/src/from_str_radix_10.rs
index 53cb1e3ecd9..de9add4b6b6 100644
--- a/clippy_lints/src/from_str_radix_10.rs
+++ b/clippy_lints/src/from_str_radix_10.rs
@@ -46,7 +46,7 @@ impl LateLintPass<'tcx> for FromStrRadix10 {
             if let TyKind::Path(ty_qpath) = &ty.kind;
             let ty_res = cx.qpath_res(ty_qpath, ty.hir_id);
             if let def::Res::PrimTy(prim_ty) = ty_res;
-            if is_primitive_integer_ty(prim_ty);
+            if matches!(prim_ty, PrimTy::Int(_) | PrimTy::Uint(_));
 
             // check if the second part of the path indeed calls the associated
             // function `from_str_radix`
@@ -63,7 +63,7 @@ impl LateLintPass<'tcx> for FromStrRadix10 {
                     cx,
                     FROM_STR_RADIX_10,
                     exp.span,
-                    "This call to `from_str_radix` can be shortened to a call to str::parse",
+                    "this call to `from_str_radix` can be replaced with a call to `str::parse`",
                     "try",
                     format!("({}).parse()", orig_string),
                     Applicability::MaybeIncorrect
@@ -72,11 +72,3 @@ impl LateLintPass<'tcx> for FromStrRadix10 {
         }
     }
 }
-
-fn is_primitive_integer_ty(ty: PrimTy) -> bool {
-    match ty {
-        PrimTy::Int(_) => true,
-        PrimTy::Uint(_) => true,
-        _ => false,
-    }
-}
diff --git a/tests/ui/from_str_radix_10.stderr b/tests/ui/from_str_radix_10.stderr
index 376d0dd56ea..5557cd3b9ef 100644
--- a/tests/ui/from_str_radix_10.stderr
+++ b/tests/ui/from_str_radix_10.stderr
@@ -1,4 +1,4 @@
-error: This call to `from_str_radix` can be shortened to a call to str::parse
+error: this call to `from_str_radix` can be replaced with a call to `str::parse`
   --> $DIR/from_str_radix_10.rs:17:5
    |
 LL |     u32::from_str_radix("30", 10)?;
@@ -6,25 +6,25 @@ LL |     u32::from_str_radix("30", 10)?;
    |
    = note: `-D clippy::from-str-radix-10` implied by `-D warnings`
 
-error: This call to `from_str_radix` can be shortened to a call to str::parse
+error: this call to `from_str_radix` can be replaced with a call to `str::parse`
   --> $DIR/from_str_radix_10.rs:18:5
    |
 LL |     i64::from_str_radix("24", 10)?;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `("24").parse()`
 
-error: This call to `from_str_radix` can be shortened to a call to str::parse
+error: this call to `from_str_radix` can be replaced with a call to `str::parse`
   --> $DIR/from_str_radix_10.rs:19:5
    |
 LL |     isize::from_str_radix("100", 10)?;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `("100").parse()`
 
-error: This call to `from_str_radix` can be shortened to a call to str::parse
+error: this call to `from_str_radix` can be replaced with a call to `str::parse`
   --> $DIR/from_str_radix_10.rs:20:5
    |
 LL |     u8::from_str_radix("7", 10)?;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `("7").parse()`
 
-error: This call to `from_str_radix` can be shortened to a call to str::parse
+error: this call to `from_str_radix` can be replaced with a call to `str::parse`
   --> $DIR/from_str_radix_10.rs:23:5
    |
 LL |     i32::from_str_radix(string, 10)?;
-- 
cgit 1.4.1-3-g733a5


From d36fe8556962467545f5e92bf896b6672f4e88ae Mon Sep 17 00:00:00 2001
From: boolean_coercion <booleancoercion@gmail.com>
Date: Sat, 13 Feb 2021 00:33:08 +0200
Subject: Made parens addition smarter and added tests with bless

---
 clippy_lints/src/from_str_radix_10.rs | 11 +++++++++--
 tests/ui/from_str_radix_10.rs         | 13 +++++++++++++
 tests/ui/from_str_radix_10.stderr     | 34 +++++++++++++++++++++++-----------
 3 files changed, 45 insertions(+), 13 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/from_str_radix_10.rs b/clippy_lints/src/from_str_radix_10.rs
index de9add4b6b6..993b85ed998 100644
--- a/clippy_lints/src/from_str_radix_10.rs
+++ b/clippy_lints/src/from_str_radix_10.rs
@@ -5,6 +5,7 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 use crate::utils::span_lint_and_sugg;
+use crate::utils::sugg::Sugg;
 
 declare_clippy_lint! {
     /// **What it does:**
@@ -58,14 +59,20 @@ impl LateLintPass<'tcx> for FromStrRadix10 {
             if let rustc_ast::ast::LitKind::Int(10, _) = lit.node;
 
             then {
-                let orig_string = crate::utils::snippet(cx, arguments[0].span, "string");
+                let sugg = Sugg::hir_with_applicability(
+                    cx,
+                    &arguments[0],
+                    "<string>",
+                    &mut Applicability::MachineApplicable
+                ).maybe_par();
+
                 span_lint_and_sugg(
                     cx,
                     FROM_STR_RADIX_10,
                     exp.span,
                     "this call to `from_str_radix` can be replaced with a call to `str::parse`",
                     "try",
-                    format!("({}).parse()", orig_string),
+                    format!("{}.parse::<{}>()", sugg, prim_ty.name_str()),
                     Applicability::MaybeIncorrect
                 );
             }
diff --git a/tests/ui/from_str_radix_10.rs b/tests/ui/from_str_radix_10.rs
index 2d8106da7ba..0a973128664 100644
--- a/tests/ui/from_str_radix_10.rs
+++ b/tests/ui/from_str_radix_10.rs
@@ -12,12 +12,25 @@ fn from_str_radix(_: &str, _: u32) -> Result<(), std::num::ParseIntError> {
     unimplemented!()
 }
 
+// to test parenthesis addition
+struct Test;
+
+impl std::ops::Add<Test> for Test {
+    type Output = &'static str;
+
+    fn add(self, _: Self) -> Self::Output {
+        "304"
+    }
+}
+
 fn main() -> Result<(), Box<dyn std::error::Error>> {
     // all of these should trigger the lint
     u32::from_str_radix("30", 10)?;
     i64::from_str_radix("24", 10)?;
     isize::from_str_radix("100", 10)?;
     u8::from_str_radix("7", 10)?;
+    u16::from_str_radix(&("10".to_owned() + "5"), 10)?;
+    i128::from_str_radix(Test + Test, 10)?;
 
     let string = "300";
     i32::from_str_radix(string, 10)?;
diff --git a/tests/ui/from_str_radix_10.stderr b/tests/ui/from_str_radix_10.stderr
index 5557cd3b9ef..d6669001915 100644
--- a/tests/ui/from_str_radix_10.stderr
+++ b/tests/ui/from_str_radix_10.stderr
@@ -1,34 +1,46 @@
 error: this call to `from_str_radix` can be replaced with a call to `str::parse`
-  --> $DIR/from_str_radix_10.rs:17:5
+  --> $DIR/from_str_radix_10.rs:28:5
    |
 LL |     u32::from_str_radix("30", 10)?;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `("30").parse()`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `"30".parse::<u32>()`
    |
    = note: `-D clippy::from-str-radix-10` implied by `-D warnings`
 
 error: this call to `from_str_radix` can be replaced with a call to `str::parse`
-  --> $DIR/from_str_radix_10.rs:18:5
+  --> $DIR/from_str_radix_10.rs:29:5
    |
 LL |     i64::from_str_radix("24", 10)?;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `("24").parse()`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `"24".parse::<i64>()`
 
 error: this call to `from_str_radix` can be replaced with a call to `str::parse`
-  --> $DIR/from_str_radix_10.rs:19:5
+  --> $DIR/from_str_radix_10.rs:30:5
    |
 LL |     isize::from_str_radix("100", 10)?;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `("100").parse()`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `"100".parse::<isize>()`
 
 error: this call to `from_str_radix` can be replaced with a call to `str::parse`
-  --> $DIR/from_str_radix_10.rs:20:5
+  --> $DIR/from_str_radix_10.rs:31:5
    |
 LL |     u8::from_str_radix("7", 10)?;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `("7").parse()`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `"7".parse::<u8>()`
 
 error: this call to `from_str_radix` can be replaced with a call to `str::parse`
-  --> $DIR/from_str_radix_10.rs:23:5
+  --> $DIR/from_str_radix_10.rs:32:5
+   |
+LL |     u16::from_str_radix(&("10".to_owned() + "5"), 10)?;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `(&("10".to_owned() + "5")).parse::<u16>()`
+
+error: this call to `from_str_radix` can be replaced with a call to `str::parse`
+  --> $DIR/from_str_radix_10.rs:33:5
+   |
+LL |     i128::from_str_radix(Test + Test, 10)?;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `(Test + Test).parse::<i128>()`
+
+error: this call to `from_str_radix` can be replaced with a call to `str::parse`
+  --> $DIR/from_str_radix_10.rs:36:5
    |
 LL |     i32::from_str_radix(string, 10)?;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `(string).parse()`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `string.parse::<i32>()`
 
-error: aborting due to 5 previous errors
+error: aborting due to 7 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 12025506d61bc05a10455ae96a623515663c09fe Mon Sep 17 00:00:00 2001
From: ThibsG <thibsg@pm.me>
Date: Sun, 14 Feb 2021 16:21:12 +0100
Subject: Do not lint when the closure is called using an iterator

---
 clippy_lints/src/blocks_in_if_conditions.rs | 18 +++++++++++++++++-
 tests/ui/blocks_in_if_conditions_closure.rs | 11 ++++++++++-
 2 files changed, 27 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/blocks_in_if_conditions.rs b/clippy_lints/src/blocks_in_if_conditions.rs
index 4efca10bcdf..b53f80fd8bc 100644
--- a/clippy_lints/src/blocks_in_if_conditions.rs
+++ b/clippy_lints/src/blocks_in_if_conditions.rs
@@ -1,4 +1,8 @@
-use crate::utils::{differing_macro_contexts, snippet_block_with_applicability, span_lint, span_lint_and_sugg};
+use crate::utils::{
+    differing_macro_contexts, get_parent_expr, get_trait_def_id, implements_trait, paths,
+    snippet_block_with_applicability, span_lint, span_lint_and_sugg,
+};
+use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
 use rustc_hir::{BlockCheckMode, Expr, ExprKind};
@@ -52,6 +56,18 @@ impl<'a, 'tcx> Visitor<'tcx> for ExVisitor<'a, 'tcx> {
 
     fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) {
         if let ExprKind::Closure(_, _, eid, _, _) = expr.kind {
+            // do not lint if the closure is called using an iterator (see #1141)
+            if_chain! {
+                if let Some(parent) = get_parent_expr(self.cx, expr);
+                if let ExprKind::MethodCall(_, _, args, _) = parent.kind;
+                let caller = self.cx.typeck_results().expr_ty(&args[0]);
+                if let Some(iter_id) = get_trait_def_id(self.cx, &paths::ITERATOR);
+                if implements_trait(self.cx, caller, iter_id, &[]);
+                then {
+                    return;
+                }
+            }
+
             let body = self.cx.tcx.hir().body(eid);
             let ex = &body.value;
             if matches!(ex.kind, ExprKind::Block(_, _)) && !body.value.span.from_expansion() {
diff --git a/tests/ui/blocks_in_if_conditions_closure.rs b/tests/ui/blocks_in_if_conditions_closure.rs
index acbabfa20d7..2856943b9be 100644
--- a/tests/ui/blocks_in_if_conditions_closure.rs
+++ b/tests/ui/blocks_in_if_conditions_closure.rs
@@ -44,4 +44,13 @@ fn macro_in_closure() {
     }
 }
 
-fn main() {}
+#[rustfmt::skip]
+fn main() {
+    let mut range = 0..10;
+    range.all(|i| {i < 10} );
+
+    let v = vec![1, 2, 3];
+    if v.into_iter().any(|x| {x == 4}) {
+        println!("contains 4!");
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 93796b2346a1177809628ea141f0dd958f4c4d29 Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Mon, 15 Feb 2021 14:22:31 +0900
Subject: Add some restrictions to default_numeric_fallback to avoid FNs

---
 clippy_lints/src/default_numeric_fallback.rs | 171 +++++++++++++++++++++------
 clippy_lints/src/lib.rs                      |   2 +-
 tests/ui/default_numeric_fallback.rs         |  40 +++++++
 tests/ui/default_numeric_fallback.stderr     |  50 +++++++-
 4 files changed, 218 insertions(+), 45 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/default_numeric_fallback.rs b/clippy_lints/src/default_numeric_fallback.rs
index b3b5a4a8251..3102d032057 100644
--- a/clippy_lints/src/default_numeric_fallback.rs
+++ b/clippy_lints/src/default_numeric_fallback.rs
@@ -1,9 +1,14 @@
-use rustc_ast::{LitFloatType, LitIntType, LitKind};
-use rustc_data_structures::fx::FxHashSet;
-use rustc_hir::{Expr, ExprKind, HirId, Stmt, StmtKind};
+use rustc_ast::ast::{LitFloatType, LitIntType, LitKind};
+use rustc_hir::{
+    intravisit::{walk_expr, walk_stmt, NestedVisitorMap, Visitor},
+    Body, Expr, ExprKind, Lit, Stmt, StmtKind,
+};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty::{self, FloatTy, IntTy};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_middle::{
+    hir::map::Map,
+    ty::{self, FloatTy, IntTy, Ty},
+};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 use if_chain::if_chain;
 
@@ -33,53 +38,141 @@ declare_clippy_lint! {
     /// Use instead:
     /// ```rust
     /// let i = 10i32;
-    /// let f: f64 = 1.23;
+    /// let f = 1.23f64;
     /// ```
     pub DEFAULT_NUMERIC_FALLBACK,
     restriction,
     "usage of unconstrained numeric literals which may cause default numeric fallback."
 }
 
-#[derive(Default)]
-pub struct DefaultNumericFallback {
-    /// Hold `init` in `Local` if `Local` has a type annotation.
-    bounded_inits: FxHashSet<HirId>,
+declare_lint_pass!(DefaultNumericFallback => [DEFAULT_NUMERIC_FALLBACK]);
+
+impl LateLintPass<'_> for DefaultNumericFallback {
+    fn check_body(&mut self, cx: &LateContext<'tcx>, body: &'tcx Body<'_>) {
+        let mut visitor = NumericFallbackVisitor::new(cx);
+        visitor.visit_body(body);
+    }
 }
 
-impl_lint_pass!(DefaultNumericFallback => [DEFAULT_NUMERIC_FALLBACK]);
+struct NumericFallbackVisitor<'a, 'tcx> {
+    /// Stack manages type bound of exprs. The top element holds current expr type.
+    ty_bounds: Vec<TyBound<'tcx>>,
 
-impl LateLintPass<'_> for DefaultNumericFallback {
-    fn check_stmt(&mut self, _: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) {
-        if_chain! {
-            if let StmtKind::Local(local) = stmt.kind;
-            if local.ty.is_some();
-            if let Some(init) = local.init;
-            then {
-                self.bounded_inits.insert(init.hir_id);
-            }
+    cx: &'a LateContext<'tcx>,
+}
+
+impl<'a, 'tcx> NumericFallbackVisitor<'a, 'tcx> {
+    fn new(cx: &'a LateContext<'tcx>) -> Self {
+        Self {
+            ty_bounds: vec![TyBound::Nothing],
+            cx,
         }
     }
 
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        let expr_ty = cx.typeck_results().expr_ty(expr);
-        let hir_id = expr.hir_id;
+    /// Check whether a passed literal has potential to cause fallback or not.
+    fn check_lit(&self, lit: &Lit, lit_ty: Ty<'tcx>) {
+        let ty_bound = self.ty_bounds.last().unwrap();
         if_chain! {
-            if let ExprKind::Lit(ref lit) = expr.kind;
-            if matches!(lit.node,
-                        LitKind::Int(_, LitIntType::Unsuffixed) | LitKind::Float(_, LitFloatType::Unsuffixed));
-            if matches!(expr_ty.kind(), ty::Int(IntTy::I32) | ty::Float(FloatTy::F64));
-            if !self.bounded_inits.contains(&hir_id);
-            if !cx.tcx.hir().parent_iter(hir_id).any(|(ref hir_id, _)| self.bounded_inits.contains(hir_id));
-            then {
-                 span_lint_and_help(
-                    cx,
-                    DEFAULT_NUMERIC_FALLBACK,
-                    lit.span,
-                    "default numeric fallback might occur",
-                    None,
-                    "consider adding suffix to avoid default numeric fallback",
-                 )
-            }
+                if matches!(lit.node,
+                            LitKind::Int(_, LitIntType::Unsuffixed) | LitKind::Float(_, LitFloatType::Unsuffixed));
+                if matches!(lit_ty.kind(), ty::Int(IntTy::I32) | ty::Float(FloatTy::F64));
+                if !ty_bound.is_integral();
+                then {
+                    span_lint_and_help(
+                        self.cx,
+                        DEFAULT_NUMERIC_FALLBACK,
+                        lit.span,
+                        "default numeric fallback might occur",
+                        None,
+                        "consider adding suffix to avoid default numeric fallback",
+                    );
+                }
+        }
+    }
+}
+
+impl<'a, 'tcx> Visitor<'tcx> for NumericFallbackVisitor<'a, 'tcx> {
+    type Map = Map<'tcx>;
+
+    #[allow(clippy::too_many_lines)]
+    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
+        match &expr.kind {
+            ExprKind::Call(func, args) => {
+                if_chain! {
+                    if let ExprKind::Path(ref func_path) = func.kind;
+                    if let Some(def_id) = self.cx.qpath_res(func_path, func.hir_id).opt_def_id();
+                    then {
+                        let fn_sig = self.cx.tcx.fn_sig(def_id).skip_binder();
+                        for (expr, bound) in args.iter().zip(fn_sig.inputs().iter()) {
+                            // Push found arg type, then visit arg.
+                            self.ty_bounds.push(TyBound::Ty(bound));
+                            self.visit_expr(expr);
+                            self.ty_bounds.pop();
+                        }
+                        return;
+                    }
+                }
+            },
+
+            ExprKind::MethodCall(_, _, args, _) => {
+                if let Some(def_id) = self.cx.typeck_results().type_dependent_def_id(expr.hir_id) {
+                    let fn_sig = self.cx.tcx.fn_sig(def_id).skip_binder();
+                    for (expr, bound) in args.iter().zip(fn_sig.inputs().iter()) {
+                        self.ty_bounds.push(TyBound::Ty(bound));
+                        self.visit_expr(expr);
+                        self.ty_bounds.pop();
+                    }
+                    return;
+                }
+            },
+
+            ExprKind::Lit(lit) => {
+                let ty = self.cx.typeck_results().expr_ty(expr);
+                self.check_lit(lit, ty);
+                return;
+            },
+
+            _ => {},
+        }
+
+        walk_expr(self, expr);
+    }
+
+    fn visit_stmt(&mut self, stmt: &'tcx Stmt<'_>) {
+        match stmt.kind {
+            StmtKind::Local(local) => {
+                if local.ty.is_some() {
+                    self.ty_bounds.push(TyBound::Any)
+                } else {
+                    self.ty_bounds.push(TyBound::Nothing)
+                }
+            },
+
+            _ => self.ty_bounds.push(TyBound::Nothing),
+        }
+
+        walk_stmt(self, stmt);
+        self.ty_bounds.pop();
+    }
+
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::None
+    }
+}
+
+#[derive(Debug, Clone, Copy)]
+enum TyBound<'ctx> {
+    Any,
+    Ty(Ty<'ctx>),
+    Nothing,
+}
+
+impl<'ctx> TyBound<'ctx> {
+    fn is_integral(self) -> bool {
+        match self {
+            TyBound::Any => true,
+            TyBound::Ty(t) => t.is_integral(),
+            TyBound::Nothing => false,
         }
     }
 }
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 6590613b93a..642c1e68dac 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1028,7 +1028,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box strings::StringAdd);
     store.register_late_pass(|| box implicit_return::ImplicitReturn);
     store.register_late_pass(|| box implicit_saturating_sub::ImplicitSaturatingSub);
-    store.register_late_pass(|| box default_numeric_fallback::DefaultNumericFallback::default());
+    store.register_late_pass(|| box default_numeric_fallback::DefaultNumericFallback);
 
     let msrv = conf.msrv.as_ref().and_then(|s| {
         parse_msrv(s, None, None).or_else(|| {
diff --git a/tests/ui/default_numeric_fallback.rs b/tests/ui/default_numeric_fallback.rs
index 5ca5bc1e907..420c1f0c931 100644
--- a/tests/ui/default_numeric_fallback.rs
+++ b/tests/ui/default_numeric_fallback.rs
@@ -1,12 +1,46 @@
 #![warn(clippy::default_numeric_fallback)]
 #![allow(unused)]
+#![allow(clippy::never_loop)]
+#![allow(clippy::no_effect)]
+#![allow(clippy::unnecessary_operation)]
+
+fn concrete_arg(x: i32) {}
+
+fn generic_arg<T>(t: T) {}
+
+struct ConcreteStruct {
+    x: i32,
+}
+
+struct StructForMethodCallTest {
+    x: i32,
+}
+
+impl StructForMethodCallTest {
+    fn concrete_arg(&self, x: i32) {}
+
+    fn generic_arg<T>(&self, t: T) {}
+}
 
 fn main() {
+    let s = StructForMethodCallTest { x: 10_i32 };
+
     // Bad.
     let x = 1;
     let x = 0.1;
+
     let x = if true { 1 } else { 2 };
 
+    let x: _ = {
+        let y = 1;
+        1
+    };
+
+    generic_arg(10);
+    s.generic_arg(10);
+    let x: _ = generic_arg(10);
+    let x: _ = s.generic_arg(10);
+
     // Good.
     let x = 1_i32;
     let x: i32 = 1;
@@ -14,5 +48,11 @@ fn main() {
     let x = 0.1_f64;
     let x: f64 = 0.1;
     let x: _ = 0.1;
+
     let x: _ = if true { 1 } else { 2 };
+
+    concrete_arg(10);
+    s.concrete_arg(10);
+    let x = concrete_arg(10);
+    let x = s.concrete_arg(10);
 }
diff --git a/tests/ui/default_numeric_fallback.stderr b/tests/ui/default_numeric_fallback.stderr
index c36409a052c..cb7c174ad8d 100644
--- a/tests/ui/default_numeric_fallback.stderr
+++ b/tests/ui/default_numeric_fallback.stderr
@@ -1,5 +1,5 @@
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:6:13
+  --> $DIR/default_numeric_fallback.rs:29:13
    |
 LL |     let x = 1;
    |             ^
@@ -8,7 +8,7 @@ LL |     let x = 1;
    = help: consider adding suffix to avoid default numeric fallback
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:7:13
+  --> $DIR/default_numeric_fallback.rs:30:13
    |
 LL |     let x = 0.1;
    |             ^^^
@@ -16,7 +16,7 @@ LL |     let x = 0.1;
    = help: consider adding suffix to avoid default numeric fallback
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:8:23
+  --> $DIR/default_numeric_fallback.rs:32:23
    |
 LL |     let x = if true { 1 } else { 2 };
    |                       ^
@@ -24,12 +24,52 @@ LL |     let x = if true { 1 } else { 2 };
    = help: consider adding suffix to avoid default numeric fallback
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:8:34
+  --> $DIR/default_numeric_fallback.rs:32:34
    |
 LL |     let x = if true { 1 } else { 2 };
    |                                  ^
    |
    = help: consider adding suffix to avoid default numeric fallback
 
-error: aborting due to 4 previous errors
+error: default numeric fallback might occur
+  --> $DIR/default_numeric_fallback.rs:35:17
+   |
+LL |         let y = 1;
+   |                 ^
+   |
+   = help: consider adding suffix to avoid default numeric fallback
+
+error: default numeric fallback might occur
+  --> $DIR/default_numeric_fallback.rs:39:17
+   |
+LL |     generic_arg(10);
+   |                 ^^
+   |
+   = help: consider adding suffix to avoid default numeric fallback
+
+error: default numeric fallback might occur
+  --> $DIR/default_numeric_fallback.rs:40:19
+   |
+LL |     s.generic_arg(10);
+   |                   ^^
+   |
+   = help: consider adding suffix to avoid default numeric fallback
+
+error: default numeric fallback might occur
+  --> $DIR/default_numeric_fallback.rs:41:28
+   |
+LL |     let x: _ = generic_arg(10);
+   |                            ^^
+   |
+   = help: consider adding suffix to avoid default numeric fallback
+
+error: default numeric fallback might occur
+  --> $DIR/default_numeric_fallback.rs:42:30
+   |
+LL |     let x: _ = s.generic_arg(10);
+   |                              ^^
+   |
+   = help: consider adding suffix to avoid default numeric fallback
+
+error: aborting due to 9 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 0198ac7bdd807abeb8f6b423c22b1e594fb0b4bf Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Mon, 15 Feb 2021 22:40:28 +0900
Subject: Add fn_sig_opt to get fn signature from HirId

---
 clippy_lints/src/default_numeric_fallback.rs | 37 ++++++++++++++++------------
 1 file changed, 21 insertions(+), 16 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/default_numeric_fallback.rs b/clippy_lints/src/default_numeric_fallback.rs
index 3102d032057..b6730afa4af 100644
--- a/clippy_lints/src/default_numeric_fallback.rs
+++ b/clippy_lints/src/default_numeric_fallback.rs
@@ -1,12 +1,12 @@
 use rustc_ast::ast::{LitFloatType, LitIntType, LitKind};
 use rustc_hir::{
     intravisit::{walk_expr, walk_stmt, NestedVisitorMap, Visitor},
-    Body, Expr, ExprKind, Lit, Stmt, StmtKind,
+    Body, Expr, ExprKind, HirId, Lit, Stmt, StmtKind,
 };
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::{
     hir::map::Map,
-    ty::{self, FloatTy, IntTy, Ty},
+    ty::{self, FloatTy, IntTy, PolyFnSig, Ty},
 };
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
@@ -64,15 +64,15 @@ struct NumericFallbackVisitor<'a, 'tcx> {
 impl<'a, 'tcx> NumericFallbackVisitor<'a, 'tcx> {
     fn new(cx: &'a LateContext<'tcx>) -> Self {
         Self {
-            ty_bounds: vec![TyBound::Nothing],
+            ty_bounds: Vec::new(),
             cx,
         }
     }
 
     /// Check whether a passed literal has potential to cause fallback or not.
     fn check_lit(&self, lit: &Lit, lit_ty: Ty<'tcx>) {
-        let ty_bound = self.ty_bounds.last().unwrap();
         if_chain! {
+                if let Some(ty_bound) = self.ty_bounds.last();
                 if matches!(lit.node,
                             LitKind::Int(_, LitIntType::Unsuffixed) | LitKind::Float(_, LitFloatType::Unsuffixed));
                 if matches!(lit_ty.kind(), ty::Int(IntTy::I32) | ty::Float(FloatTy::F64));
@@ -98,19 +98,14 @@ impl<'a, 'tcx> Visitor<'tcx> for NumericFallbackVisitor<'a, 'tcx> {
     fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
         match &expr.kind {
             ExprKind::Call(func, args) => {
-                if_chain! {
-                    if let ExprKind::Path(ref func_path) = func.kind;
-                    if let Some(def_id) = self.cx.qpath_res(func_path, func.hir_id).opt_def_id();
-                    then {
-                        let fn_sig = self.cx.tcx.fn_sig(def_id).skip_binder();
-                        for (expr, bound) in args.iter().zip(fn_sig.inputs().iter()) {
-                            // Push found arg type, then visit arg.
-                            self.ty_bounds.push(TyBound::Ty(bound));
-                            self.visit_expr(expr);
-                            self.ty_bounds.pop();
-                        }
-                        return;
+                if let Some(fn_sig) = fn_sig_opt(self.cx, func.hir_id) {
+                    for (expr, bound) in args.iter().zip(fn_sig.skip_binder().inputs().iter()) {
+                        // Push found arg type, then visit arg.
+                        self.ty_bounds.push(TyBound::Ty(bound));
+                        self.visit_expr(expr);
+                        self.ty_bounds.pop();
                     }
+                    return;
                 }
             },
 
@@ -160,6 +155,16 @@ impl<'a, 'tcx> Visitor<'tcx> for NumericFallbackVisitor<'a, 'tcx> {
     }
 }
 
+fn fn_sig_opt<'tcx>(cx: &LateContext<'tcx>, hir_id: HirId) -> Option<PolyFnSig<'tcx>> {
+    let node_ty = cx.typeck_results().node_type_opt(hir_id)?;
+    // We can't use `TyS::fn_sig` because it automatically performs substs, this may result in FNs.
+    match node_ty.kind() {
+        ty::FnDef(def_id, _) => Some(cx.tcx.fn_sig(*def_id)),
+        ty::FnPtr(fn_sig) => Some(*fn_sig),
+        _ => None,
+    }
+}
+
 #[derive(Debug, Clone, Copy)]
 enum TyBound<'ctx> {
     Any,
-- 
cgit 1.4.1-3-g733a5


From fb91c76586a3a01fef6a8c49edb9e4598fbd138f Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Mon, 15 Feb 2021 23:33:27 +0900
Subject: Add more tests for default_numeric_fallback

---
 clippy_lints/src/default_numeric_fallback.rs |   2 +-
 tests/ui/default_numeric_fallback.rs         | 112 +++++++++++++++++--------
 tests/ui/default_numeric_fallback.stderr     | 118 +++++++++++++++++++++------
 3 files changed, 169 insertions(+), 63 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/default_numeric_fallback.rs b/clippy_lints/src/default_numeric_fallback.rs
index b6730afa4af..d755112a178 100644
--- a/clippy_lints/src/default_numeric_fallback.rs
+++ b/clippy_lints/src/default_numeric_fallback.rs
@@ -27,7 +27,7 @@ declare_clippy_lint! {
     /// **Why is this bad?** For those who are very careful about types, default numeric fallback
     /// can be a pitfall that cause unexpected runtime behavior.
     ///
-    /// **Known problems:** None.
+    /// **Known problems:** This lint can only be allowed at the function level or above.
     ///
     /// **Example:**
     /// ```rust
diff --git a/tests/ui/default_numeric_fallback.rs b/tests/ui/default_numeric_fallback.rs
index 420c1f0c931..c4881094469 100644
--- a/tests/ui/default_numeric_fallback.rs
+++ b/tests/ui/default_numeric_fallback.rs
@@ -4,55 +4,97 @@
 #![allow(clippy::no_effect)]
 #![allow(clippy::unnecessary_operation)]
 
-fn concrete_arg(x: i32) {}
+mod basic_expr {
+    fn test() {
+        // Should lint unsuffixed literals typed `i32`.
+        let x = 22;
+        let x = [1, 2, 3];
+        let x = if true { (1, 2) } else { (3, 4) };
+        let x = match 1 {
+            1 => 1,
+            _ => 2,
+        };
 
-fn generic_arg<T>(t: T) {}
+        // Should lint unsuffixed literals typed `f64`.
+        let x = 0.12;
 
-struct ConcreteStruct {
-    x: i32,
+        // Should NOT lint suffixed literals.
+        let x = 22_i32;
+        let x = 0.12_f64;
+
+        // Should NOT lint literals in init expr if `Local` has a type annotation.
+        let x: f64 = 0.1;
+        let x: [i32; 3] = [1, 2, 3];
+        let x: (i32, i32) = if true { (1, 2) } else { (3, 4) };
+        let x: _ = 1;
+    }
 }
 
-struct StructForMethodCallTest {
-    x: i32,
+mod nested_local {
+    fn test() {
+        let x: _ = {
+            // Should lint this because this literal is not bound to any types.
+            let y = 1;
+
+            // Should NOT lint this because this literal is bound to `_` of outer `Local`.
+            1
+        };
+    }
 }
 
-impl StructForMethodCallTest {
-    fn concrete_arg(&self, x: i32) {}
+mod function_def {
+    fn ret_i32() -> i32 {
+        // Even though the output type is specified,
+        // this unsuffixed literal is linted to reduce heuristics and keep codebase simple.
+        23
+    }
 
-    fn generic_arg<T>(&self, t: T) {}
+    fn test() {
+        // Should lint this because return type is inferred to `i32` and NOT bound to a concrete
+        // type.
+        let f = || -> _ { 1 };
+
+        // Even though the output type is specified,
+        // this unsuffixed literal is linted to reduce heuristics and keep codebase simple.
+        let f = || -> i32 { 1 };
+    }
 }
 
-fn main() {
-    let s = StructForMethodCallTest { x: 10_i32 };
+mod function_calls {
+    fn concrete_arg(x: i32) {}
+
+    fn generic_arg<T>(t: T) {}
 
-    // Bad.
-    let x = 1;
-    let x = 0.1;
+    fn test() {
+        // Should NOT lint this because the argument type is bound to a concrete type.
+        concrete_arg(1);
 
-    let x = if true { 1 } else { 2 };
+        // Should lint this because the argument type is inferred to `i32` and NOT bound to a concrete type.
+        generic_arg(1);
 
-    let x: _ = {
-        let y = 1;
-        1
-    };
+        // Should lint this because the argument type is inferred to `i32` and NOT bound to a concrete type.
+        let x: _ = generic_arg(1);
+    }
+}
+
+mod method_calls {
+    struct StructForMethodCallTest {}
 
-    generic_arg(10);
-    s.generic_arg(10);
-    let x: _ = generic_arg(10);
-    let x: _ = s.generic_arg(10);
+    impl StructForMethodCallTest {
+        fn concrete_arg(&self, x: i32) {}
 
-    // Good.
-    let x = 1_i32;
-    let x: i32 = 1;
-    let x: _ = 1;
-    let x = 0.1_f64;
-    let x: f64 = 0.1;
-    let x: _ = 0.1;
+        fn generic_arg<T>(&self, t: T) {}
+    }
 
-    let x: _ = if true { 1 } else { 2 };
+    fn test() {
+        let s = StructForMethodCallTest {};
 
-    concrete_arg(10);
-    s.concrete_arg(10);
-    let x = concrete_arg(10);
-    let x = s.concrete_arg(10);
+        // Should NOT lint this because the argument type is bound to a concrete type.
+        s.concrete_arg(1);
+
+        // Should lint this because the argument type is bound to a concrete type.
+        s.generic_arg(1);
+    }
 }
+
+fn main() {}
diff --git a/tests/ui/default_numeric_fallback.stderr b/tests/ui/default_numeric_fallback.stderr
index cb7c174ad8d..c71d05d7993 100644
--- a/tests/ui/default_numeric_fallback.stderr
+++ b/tests/ui/default_numeric_fallback.stderr
@@ -1,75 +1,139 @@
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:29:13
+  --> $DIR/default_numeric_fallback.rs:10:17
    |
-LL |     let x = 1;
-   |             ^
+LL |         let x = 22;
+   |                 ^^
    |
    = note: `-D clippy::default-numeric-fallback` implied by `-D warnings`
    = help: consider adding suffix to avoid default numeric fallback
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:30:13
+  --> $DIR/default_numeric_fallback.rs:11:18
+   |
+LL |         let x = [1, 2, 3];
+   |                  ^
+   |
+   = help: consider adding suffix to avoid default numeric fallback
+
+error: default numeric fallback might occur
+  --> $DIR/default_numeric_fallback.rs:11:21
+   |
+LL |         let x = [1, 2, 3];
+   |                     ^
+   |
+   = help: consider adding suffix to avoid default numeric fallback
+
+error: default numeric fallback might occur
+  --> $DIR/default_numeric_fallback.rs:11:24
    |
-LL |     let x = 0.1;
-   |             ^^^
+LL |         let x = [1, 2, 3];
+   |                        ^
    |
    = help: consider adding suffix to avoid default numeric fallback
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:32:23
+  --> $DIR/default_numeric_fallback.rs:12:28
+   |
+LL |         let x = if true { (1, 2) } else { (3, 4) };
+   |                            ^
+   |
+   = help: consider adding suffix to avoid default numeric fallback
+
+error: default numeric fallback might occur
+  --> $DIR/default_numeric_fallback.rs:12:31
+   |
+LL |         let x = if true { (1, 2) } else { (3, 4) };
+   |                               ^
+   |
+   = help: consider adding suffix to avoid default numeric fallback
+
+error: default numeric fallback might occur
+  --> $DIR/default_numeric_fallback.rs:12:44
+   |
+LL |         let x = if true { (1, 2) } else { (3, 4) };
+   |                                            ^
    |
-LL |     let x = if true { 1 } else { 2 };
+   = help: consider adding suffix to avoid default numeric fallback
+
+error: default numeric fallback might occur
+  --> $DIR/default_numeric_fallback.rs:12:47
+   |
+LL |         let x = if true { (1, 2) } else { (3, 4) };
+   |                                               ^
+   |
+   = help: consider adding suffix to avoid default numeric fallback
+
+error: default numeric fallback might occur
+  --> $DIR/default_numeric_fallback.rs:13:23
+   |
+LL |         let x = match 1 {
    |                       ^
    |
    = help: consider adding suffix to avoid default numeric fallback
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:32:34
+  --> $DIR/default_numeric_fallback.rs:14:13
    |
-LL |     let x = if true { 1 } else { 2 };
-   |                                  ^
+LL |             1 => 1,
+   |             ^
    |
    = help: consider adding suffix to avoid default numeric fallback
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:35:17
+  --> $DIR/default_numeric_fallback.rs:14:18
    |
-LL |         let y = 1;
-   |                 ^
+LL |             1 => 1,
+   |                  ^
    |
    = help: consider adding suffix to avoid default numeric fallback
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:39:17
+  --> $DIR/default_numeric_fallback.rs:15:18
    |
-LL |     generic_arg(10);
-   |                 ^^
+LL |             _ => 2,
+   |                  ^
    |
    = help: consider adding suffix to avoid default numeric fallback
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:40:19
+  --> $DIR/default_numeric_fallback.rs:19:17
    |
-LL |     s.generic_arg(10);
-   |                   ^^
+LL |         let x = 0.12;
+   |                 ^^^^
    |
    = help: consider adding suffix to avoid default numeric fallback
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:41:28
+  --> $DIR/default_numeric_fallback.rs:37:21
    |
-LL |     let x: _ = generic_arg(10);
-   |                            ^^
+LL |             let y = 1;
+   |                     ^
    |
    = help: consider adding suffix to avoid default numeric fallback
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:42:30
+  --> $DIR/default_numeric_fallback.rs:73:21
    |
-LL |     let x: _ = s.generic_arg(10);
-   |                              ^^
+LL |         generic_arg(1);
+   |                     ^
+   |
+   = help: consider adding suffix to avoid default numeric fallback
+
+error: default numeric fallback might occur
+  --> $DIR/default_numeric_fallback.rs:76:32
+   |
+LL |         let x: _ = generic_arg(1);
+   |                                ^
+   |
+   = help: consider adding suffix to avoid default numeric fallback
+
+error: default numeric fallback might occur
+  --> $DIR/default_numeric_fallback.rs:96:23
+   |
+LL |         s.generic_arg(1);
+   |                       ^
    |
    = help: consider adding suffix to avoid default numeric fallback
 
-error: aborting due to 9 previous errors
+error: aborting due to 17 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 1f8ee3cc19f9259eea5e633affef968280d2ed1a Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Tue, 16 Feb 2021 11:20:51 +0900
Subject: Handle struct ctor case

---
 clippy_lints/src/default_numeric_fallback.rs | 53 +++++++++++++++++++++--
 tests/ui/default_numeric_fallback.rs         | 37 +++++++++++++++-
 tests/ui/default_numeric_fallback.stderr     | 64 ++++++++++++++++++++++++++--
 3 files changed, 145 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/default_numeric_fallback.rs b/clippy_lints/src/default_numeric_fallback.rs
index d755112a178..33a577f336d 100644
--- a/clippy_lints/src/default_numeric_fallback.rs
+++ b/clippy_lints/src/default_numeric_fallback.rs
@@ -64,7 +64,7 @@ struct NumericFallbackVisitor<'a, 'tcx> {
 impl<'a, 'tcx> NumericFallbackVisitor<'a, 'tcx> {
     fn new(cx: &'a LateContext<'tcx>) -> Self {
         Self {
-            ty_bounds: Vec::new(),
+            ty_bounds: vec![TyBound::Nothing],
             cx,
         }
     }
@@ -121,6 +121,42 @@ impl<'a, 'tcx> Visitor<'tcx> for NumericFallbackVisitor<'a, 'tcx> {
                 }
             },
 
+            ExprKind::Struct(qpath, fields, base) => {
+                if_chain! {
+                    if let Some(def_id) = self.cx.qpath_res(qpath, expr.hir_id).opt_def_id();
+                    let ty = self.cx.tcx.type_of(def_id);
+                    if let Some(adt_def) = ty.ty_adt_def();
+                    if adt_def.is_struct();
+                    if let Some(variant) = adt_def.variants.iter().next();
+                    then {
+                        let fields_def = &variant.fields;
+
+                        // Push field type then visit each field expr.
+                        for field in fields.iter() {
+                            let bound =
+                                fields_def
+                                    .iter()
+                                    .find_map(|f_def| {
+                                        if f_def.ident == field.ident
+                                            { Some(self.cx.tcx.type_of(f_def.did)) }
+                                        else { None }
+                                    });
+                            self.ty_bounds.push(bound.into());
+                            self.visit_expr(field.expr);
+                            self.ty_bounds.pop();
+                        }
+
+                        // Visit base with no bound.
+                        if let Some(base) = base {
+                            self.ty_bounds.push(TyBound::Nothing);
+                            self.visit_expr(base);
+                            self.ty_bounds.pop();
+                        }
+                        return;
+                    }
+                }
+            },
+
             ExprKind::Lit(lit) => {
                 let ty = self.cx.typeck_results().expr_ty(expr);
                 self.check_lit(lit, ty);
@@ -166,13 +202,13 @@ fn fn_sig_opt<'tcx>(cx: &LateContext<'tcx>, hir_id: HirId) -> Option<PolyFnSig<'
 }
 
 #[derive(Debug, Clone, Copy)]
-enum TyBound<'ctx> {
+enum TyBound<'tcx> {
     Any,
-    Ty(Ty<'ctx>),
+    Ty(Ty<'tcx>),
     Nothing,
 }
 
-impl<'ctx> TyBound<'ctx> {
+impl<'tcx> TyBound<'tcx> {
     fn is_integral(self) -> bool {
         match self {
             TyBound::Any => true,
@@ -181,3 +217,12 @@ impl<'ctx> TyBound<'ctx> {
         }
     }
 }
+
+impl<'tcx> From<Option<Ty<'tcx>>> for TyBound<'tcx> {
+    fn from(v: Option<Ty<'tcx>>) -> Self {
+        match v {
+            Some(t) => TyBound::Ty(t),
+            None => TyBound::Nothing,
+        }
+    }
+}
diff --git a/tests/ui/default_numeric_fallback.rs b/tests/ui/default_numeric_fallback.rs
index c4881094469..0b3758952ac 100644
--- a/tests/ui/default_numeric_fallback.rs
+++ b/tests/ui/default_numeric_fallback.rs
@@ -39,6 +39,20 @@ mod nested_local {
             // Should NOT lint this because this literal is bound to `_` of outer `Local`.
             1
         };
+
+        let x: _ = if true {
+            // Should lint this because this literal is not bound to any types.
+            let y = 1;
+
+            // Should NOT lint this because this literal is bound to `_` of outer `Local`.
+            1
+        } else {
+            // Should lint this because this literal is not bound to any types.
+            let y = 1;
+
+            // Should NOT lint this because this literal is bound to `_` of outer `Local`.
+            2
+        };
     }
 }
 
@@ -46,7 +60,7 @@ mod function_def {
     fn ret_i32() -> i32 {
         // Even though the output type is specified,
         // this unsuffixed literal is linted to reduce heuristics and keep codebase simple.
-        23
+        1
     }
 
     fn test() {
@@ -77,6 +91,27 @@ mod function_calls {
     }
 }
 
+mod struct_ctor {
+    struct ConcreteStruct {
+        x: i32,
+    }
+
+    struct GenericStruct<T> {
+        x: T,
+    }
+
+    fn test() {
+        // Should NOT lint this because the field type is bound to a concrete type.
+        ConcreteStruct { x: 1 };
+
+        // Should lint this because the field type is inferred to `i32` and NOT bound to a concrete type.
+        GenericStruct { x: 1 };
+
+        // Should lint this because the field type is inferred to `i32` and NOT bound to a concrete type.
+        let _ = GenericStruct { x: 1 };
+    }
+}
+
 mod method_calls {
     struct StructForMethodCallTest {}
 
diff --git a/tests/ui/default_numeric_fallback.stderr b/tests/ui/default_numeric_fallback.stderr
index c71d05d7993..50fcdfb510e 100644
--- a/tests/ui/default_numeric_fallback.stderr
+++ b/tests/ui/default_numeric_fallback.stderr
@@ -112,7 +112,47 @@ LL |             let y = 1;
    = help: consider adding suffix to avoid default numeric fallback
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:73:21
+  --> $DIR/default_numeric_fallback.rs:45:21
+   |
+LL |             let y = 1;
+   |                     ^
+   |
+   = help: consider adding suffix to avoid default numeric fallback
+
+error: default numeric fallback might occur
+  --> $DIR/default_numeric_fallback.rs:51:21
+   |
+LL |             let y = 1;
+   |                     ^
+   |
+   = help: consider adding suffix to avoid default numeric fallback
+
+error: default numeric fallback might occur
+  --> $DIR/default_numeric_fallback.rs:63:9
+   |
+LL |         1
+   |         ^
+   |
+   = help: consider adding suffix to avoid default numeric fallback
+
+error: default numeric fallback might occur
+  --> $DIR/default_numeric_fallback.rs:69:27
+   |
+LL |         let f = || -> _ { 1 };
+   |                           ^
+   |
+   = help: consider adding suffix to avoid default numeric fallback
+
+error: default numeric fallback might occur
+  --> $DIR/default_numeric_fallback.rs:73:29
+   |
+LL |         let f = || -> i32 { 1 };
+   |                             ^
+   |
+   = help: consider adding suffix to avoid default numeric fallback
+
+error: default numeric fallback might occur
+  --> $DIR/default_numeric_fallback.rs:87:21
    |
 LL |         generic_arg(1);
    |                     ^
@@ -120,7 +160,7 @@ LL |         generic_arg(1);
    = help: consider adding suffix to avoid default numeric fallback
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:76:32
+  --> $DIR/default_numeric_fallback.rs:90:32
    |
 LL |         let x: _ = generic_arg(1);
    |                                ^
@@ -128,12 +168,28 @@ LL |         let x: _ = generic_arg(1);
    = help: consider adding suffix to avoid default numeric fallback
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:96:23
+  --> $DIR/default_numeric_fallback.rs:108:28
+   |
+LL |         GenericStruct { x: 1 };
+   |                            ^
+   |
+   = help: consider adding suffix to avoid default numeric fallback
+
+error: default numeric fallback might occur
+  --> $DIR/default_numeric_fallback.rs:111:36
+   |
+LL |         let _ = GenericStruct { x: 1 };
+   |                                    ^
+   |
+   = help: consider adding suffix to avoid default numeric fallback
+
+error: default numeric fallback might occur
+  --> $DIR/default_numeric_fallback.rs:131:23
    |
 LL |         s.generic_arg(1);
    |                       ^
    |
    = help: consider adding suffix to avoid default numeric fallback
 
-error: aborting due to 17 previous errors
+error: aborting due to 24 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 9b0c1ebc183bbf0fab5fbbe5ac8b2f94e5e56b87 Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Tue, 16 Feb 2021 18:07:09 +0900
Subject: Change to span_lint_and_sugg from span_lint_and_help

---
 clippy_lints/src/default_numeric_fallback.rs | 19 ++++--
 tests/ui/default_numeric_fallback.stderr     | 95 +++++++---------------------
 2 files changed, 38 insertions(+), 76 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/default_numeric_fallback.rs b/clippy_lints/src/default_numeric_fallback.rs
index 33a577f336d..6ace9aa6bdf 100644
--- a/clippy_lints/src/default_numeric_fallback.rs
+++ b/clippy_lints/src/default_numeric_fallback.rs
@@ -1,4 +1,5 @@
 use rustc_ast::ast::{LitFloatType, LitIntType, LitKind};
+use rustc_errors::Applicability;
 use rustc_hir::{
     intravisit::{walk_expr, walk_stmt, NestedVisitorMap, Visitor},
     Body, Expr, ExprKind, HirId, Lit, Stmt, StmtKind,
@@ -12,7 +13,7 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 use if_chain::if_chain;
 
-use crate::utils::span_lint_and_help;
+use crate::utils::{snippet, span_lint_and_sugg};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for usage of unconstrained numeric literals which may cause default numeric fallback in type
@@ -75,16 +76,24 @@ impl<'a, 'tcx> NumericFallbackVisitor<'a, 'tcx> {
                 if let Some(ty_bound) = self.ty_bounds.last();
                 if matches!(lit.node,
                             LitKind::Int(_, LitIntType::Unsuffixed) | LitKind::Float(_, LitFloatType::Unsuffixed));
-                if matches!(lit_ty.kind(), ty::Int(IntTy::I32) | ty::Float(FloatTy::F64));
                 if !ty_bound.is_integral();
                 then {
-                    span_lint_and_help(
+                    let suffix = match lit_ty.kind() {
+                        ty::Int(IntTy::I32) => "i32",
+                        ty::Float(FloatTy::F64) => "f64",
+                        // Default numeric fallback never results in other types.
+                        _ => return,
+                    };
+
+                    let sugg = format!("{}_{}", snippet(self.cx, lit.span, ""), suffix);
+                    span_lint_and_sugg(
                         self.cx,
                         DEFAULT_NUMERIC_FALLBACK,
                         lit.span,
                         "default numeric fallback might occur",
-                        None,
-                        "consider adding suffix to avoid default numeric fallback",
+                        "consider adding suffix",
+                        sugg,
+                        Applicability::MaybeIncorrect,
                     );
                 }
         }
diff --git a/tests/ui/default_numeric_fallback.stderr b/tests/ui/default_numeric_fallback.stderr
index 50fcdfb510e..b31aa4ebcf8 100644
--- a/tests/ui/default_numeric_fallback.stderr
+++ b/tests/ui/default_numeric_fallback.stderr
@@ -2,194 +2,147 @@ error: default numeric fallback might occur
   --> $DIR/default_numeric_fallback.rs:10:17
    |
 LL |         let x = 22;
-   |                 ^^
+   |                 ^^ help: consider adding suffix: `22_i32`
    |
    = note: `-D clippy::default-numeric-fallback` implied by `-D warnings`
-   = help: consider adding suffix to avoid default numeric fallback
 
 error: default numeric fallback might occur
   --> $DIR/default_numeric_fallback.rs:11:18
    |
 LL |         let x = [1, 2, 3];
-   |                  ^
-   |
-   = help: consider adding suffix to avoid default numeric fallback
+   |                  ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
   --> $DIR/default_numeric_fallback.rs:11:21
    |
 LL |         let x = [1, 2, 3];
-   |                     ^
-   |
-   = help: consider adding suffix to avoid default numeric fallback
+   |                     ^ help: consider adding suffix: `2_i32`
 
 error: default numeric fallback might occur
   --> $DIR/default_numeric_fallback.rs:11:24
    |
 LL |         let x = [1, 2, 3];
-   |                        ^
-   |
-   = help: consider adding suffix to avoid default numeric fallback
+   |                        ^ help: consider adding suffix: `3_i32`
 
 error: default numeric fallback might occur
   --> $DIR/default_numeric_fallback.rs:12:28
    |
 LL |         let x = if true { (1, 2) } else { (3, 4) };
-   |                            ^
-   |
-   = help: consider adding suffix to avoid default numeric fallback
+   |                            ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
   --> $DIR/default_numeric_fallback.rs:12:31
    |
 LL |         let x = if true { (1, 2) } else { (3, 4) };
-   |                               ^
-   |
-   = help: consider adding suffix to avoid default numeric fallback
+   |                               ^ help: consider adding suffix: `2_i32`
 
 error: default numeric fallback might occur
   --> $DIR/default_numeric_fallback.rs:12:44
    |
 LL |         let x = if true { (1, 2) } else { (3, 4) };
-   |                                            ^
-   |
-   = help: consider adding suffix to avoid default numeric fallback
+   |                                            ^ help: consider adding suffix: `3_i32`
 
 error: default numeric fallback might occur
   --> $DIR/default_numeric_fallback.rs:12:47
    |
 LL |         let x = if true { (1, 2) } else { (3, 4) };
-   |                                               ^
-   |
-   = help: consider adding suffix to avoid default numeric fallback
+   |                                               ^ help: consider adding suffix: `4_i32`
 
 error: default numeric fallback might occur
   --> $DIR/default_numeric_fallback.rs:13:23
    |
 LL |         let x = match 1 {
-   |                       ^
-   |
-   = help: consider adding suffix to avoid default numeric fallback
+   |                       ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
   --> $DIR/default_numeric_fallback.rs:14:13
    |
 LL |             1 => 1,
-   |             ^
-   |
-   = help: consider adding suffix to avoid default numeric fallback
+   |             ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
   --> $DIR/default_numeric_fallback.rs:14:18
    |
 LL |             1 => 1,
-   |                  ^
-   |
-   = help: consider adding suffix to avoid default numeric fallback
+   |                  ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
   --> $DIR/default_numeric_fallback.rs:15:18
    |
 LL |             _ => 2,
-   |                  ^
-   |
-   = help: consider adding suffix to avoid default numeric fallback
+   |                  ^ help: consider adding suffix: `2_i32`
 
 error: default numeric fallback might occur
   --> $DIR/default_numeric_fallback.rs:19:17
    |
 LL |         let x = 0.12;
-   |                 ^^^^
-   |
-   = help: consider adding suffix to avoid default numeric fallback
+   |                 ^^^^ help: consider adding suffix: `0.12_f64`
 
 error: default numeric fallback might occur
   --> $DIR/default_numeric_fallback.rs:37:21
    |
 LL |             let y = 1;
-   |                     ^
-   |
-   = help: consider adding suffix to avoid default numeric fallback
+   |                     ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
   --> $DIR/default_numeric_fallback.rs:45:21
    |
 LL |             let y = 1;
-   |                     ^
-   |
-   = help: consider adding suffix to avoid default numeric fallback
+   |                     ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
   --> $DIR/default_numeric_fallback.rs:51:21
    |
 LL |             let y = 1;
-   |                     ^
-   |
-   = help: consider adding suffix to avoid default numeric fallback
+   |                     ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
   --> $DIR/default_numeric_fallback.rs:63:9
    |
 LL |         1
-   |         ^
-   |
-   = help: consider adding suffix to avoid default numeric fallback
+   |         ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
   --> $DIR/default_numeric_fallback.rs:69:27
    |
 LL |         let f = || -> _ { 1 };
-   |                           ^
-   |
-   = help: consider adding suffix to avoid default numeric fallback
+   |                           ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
   --> $DIR/default_numeric_fallback.rs:73:29
    |
 LL |         let f = || -> i32 { 1 };
-   |                             ^
-   |
-   = help: consider adding suffix to avoid default numeric fallback
+   |                             ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
   --> $DIR/default_numeric_fallback.rs:87:21
    |
 LL |         generic_arg(1);
-   |                     ^
-   |
-   = help: consider adding suffix to avoid default numeric fallback
+   |                     ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
   --> $DIR/default_numeric_fallback.rs:90:32
    |
 LL |         let x: _ = generic_arg(1);
-   |                                ^
-   |
-   = help: consider adding suffix to avoid default numeric fallback
+   |                                ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
   --> $DIR/default_numeric_fallback.rs:108:28
    |
 LL |         GenericStruct { x: 1 };
-   |                            ^
-   |
-   = help: consider adding suffix to avoid default numeric fallback
+   |                            ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
   --> $DIR/default_numeric_fallback.rs:111:36
    |
 LL |         let _ = GenericStruct { x: 1 };
-   |                                    ^
-   |
-   = help: consider adding suffix to avoid default numeric fallback
+   |                                    ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
   --> $DIR/default_numeric_fallback.rs:131:23
    |
 LL |         s.generic_arg(1);
-   |                       ^
-   |
-   = help: consider adding suffix to avoid default numeric fallback
+   |                       ^ help: consider adding suffix: `1_i32`
 
 error: aborting due to 24 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 4ac14f9e63ba71e7f15204f9cff208f022563996 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Wed, 17 Feb 2021 09:34:35 -0600
Subject: Teach SpanlessEq binding IDs

---
 clippy_lints/src/utils/hir_utils.rs | 134 ++++++++++++++++++++++++------------
 tests/ui/collapsible_match.rs       |   8 +++
 tests/ui/if_same_then_else2.rs      |   6 +-
 tests/ui/if_same_then_else2.stderr  |   4 +-
 4 files changed, 102 insertions(+), 50 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/hir_utils.rs b/clippy_lints/src/utils/hir_utils.rs
index c5870dc5124..0a9719901f0 100644
--- a/clippy_lints/src/utils/hir_utils.rs
+++ b/clippy_lints/src/utils/hir_utils.rs
@@ -1,10 +1,12 @@
 use crate::consts::{constant_context, constant_simple};
 use crate::utils::differing_macro_contexts;
 use rustc_ast::ast::InlineAsmTemplatePiece;
+use rustc_data_structures::fx::FxHashMap;
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
+use rustc_hir::def::Res;
 use rustc_hir::{
     BinOpKind, Block, BlockCheckMode, BodyId, BorrowKind, CaptureBy, Expr, ExprKind, Field, FieldPat, FnRetTy,
-    GenericArg, GenericArgs, Guard, InlineAsmOperand, Lifetime, LifetimeName, ParamName, Pat, PatKind, Path,
+    GenericArg, GenericArgs, Guard, HirId, InlineAsmOperand, Lifetime, LifetimeName, ParamName, Pat, PatKind, Path,
     PathSegment, QPath, Stmt, StmtKind, Ty, TyKind, TypeBinding,
 };
 use rustc_lint::LateContext;
@@ -52,8 +54,47 @@ impl<'a, 'tcx> SpanlessEq<'a, 'tcx> {
         }
     }
 
-    /// Checks whether two statements are the same.
-    pub fn eq_stmt(&mut self, left: &Stmt<'_>, right: &Stmt<'_>) -> bool {
+    /// Use this method to wrap comparisons that may involve inter-expression context.
+    /// See `self.locals`.
+    fn inter_expr(&mut self) -> HirEqInterExpr<'_, 'a, 'tcx> {
+        HirEqInterExpr {
+            inner: self,
+            locals: FxHashMap::default(),
+        }
+    }
+
+    pub fn eq_block(&mut self, left: &Block<'_>, right: &Block<'_>) -> bool {
+        self.inter_expr().eq_block(left, right)
+    }
+
+    pub fn eq_expr(&mut self, left: &Expr<'_>, right: &Expr<'_>) -> bool {
+        self.inter_expr().eq_expr(left, right)
+    }
+
+    pub fn eq_path_segment(&mut self, left: &PathSegment<'_>, right: &PathSegment<'_>) -> bool {
+        self.inter_expr().eq_path_segment(left, right)
+    }
+
+    pub fn eq_path_segments(&mut self, left: &[PathSegment<'_>], right: &[PathSegment<'_>]) -> bool {
+        self.inter_expr().eq_path_segments(left, right)
+    }
+
+    pub fn eq_ty_kind(&mut self, left: &TyKind<'_>, right: &TyKind<'_>) -> bool {
+        self.inter_expr().eq_ty_kind(left, right)
+    }
+}
+
+struct HirEqInterExpr<'a, 'b, 'tcx> {
+    inner: &'a mut SpanlessEq<'b, 'tcx>,
+
+    // When binding are declared, the binding ID in the left expression is mapped to the one on the
+    // right. For example, when comparing `{ let x = 1; x + 2 }` and `{ let y = 1; y + 2 }`,
+    // these blocks are considered equal since `x` is mapped to `y`.
+    locals: FxHashMap<HirId, HirId>,
+}
+
+impl HirEqInterExpr<'_, '_, '_> {
+    fn eq_stmt(&mut self, left: &Stmt<'_>, right: &Stmt<'_>) -> bool {
         match (&left.kind, &right.kind) {
             (&StmtKind::Local(ref l), &StmtKind::Local(ref r)) => {
                 self.eq_pat(&l.pat, &r.pat)
@@ -68,21 +109,21 @@ impl<'a, 'tcx> SpanlessEq<'a, 'tcx> {
     }
 
     /// Checks whether two blocks are the same.
-    pub fn eq_block(&mut self, left: &Block<'_>, right: &Block<'_>) -> bool {
+    fn eq_block(&mut self, left: &Block<'_>, right: &Block<'_>) -> bool {
         over(&left.stmts, &right.stmts, |l, r| self.eq_stmt(l, r))
             && both(&left.expr, &right.expr, |l, r| self.eq_expr(l, r))
     }
 
     #[allow(clippy::similar_names)]
-    pub fn eq_expr(&mut self, left: &Expr<'_>, right: &Expr<'_>) -> bool {
-        if !self.allow_side_effects && differing_macro_contexts(left.span, right.span) {
+    fn eq_expr(&mut self, left: &Expr<'_>, right: &Expr<'_>) -> bool {
+        if !self.inner.allow_side_effects && differing_macro_contexts(left.span, right.span) {
             return false;
         }
 
-        if let Some(typeck_results) = self.maybe_typeck_results {
+        if let Some(typeck_results) = self.inner.maybe_typeck_results {
             if let (Some(l), Some(r)) = (
-                constant_simple(self.cx, typeck_results, left),
-                constant_simple(self.cx, typeck_results, right),
+                constant_simple(self.inner.cx, typeck_results, left),
+                constant_simple(self.inner.cx, typeck_results, right),
             ) {
                 if l == r {
                     return true;
@@ -98,10 +139,10 @@ impl<'a, 'tcx> SpanlessEq<'a, 'tcx> {
                 both(&li.label, &ri.label, |l, r| l.ident.name == r.ident.name)
             },
             (&ExprKind::Assign(ref ll, ref lr, _), &ExprKind::Assign(ref rl, ref rr, _)) => {
-                self.allow_side_effects && self.eq_expr(ll, rl) && self.eq_expr(lr, rr)
+                self.inner.allow_side_effects && self.eq_expr(ll, rl) && self.eq_expr(lr, rr)
             },
             (&ExprKind::AssignOp(ref lo, ref ll, ref lr), &ExprKind::AssignOp(ref ro, ref rl, ref rr)) => {
-                self.allow_side_effects && lo.node == ro.node && self.eq_expr(ll, rl) && self.eq_expr(lr, rr)
+                self.inner.allow_side_effects && lo.node == ro.node && self.eq_expr(ll, rl) && self.eq_expr(lr, rr)
             },
             (&ExprKind::Block(ref l, _), &ExprKind::Block(ref r, _)) => self.eq_block(l, r),
             (&ExprKind::Binary(l_op, ref ll, ref lr), &ExprKind::Binary(r_op, ref rl, ref rr)) => {
@@ -116,7 +157,7 @@ impl<'a, 'tcx> SpanlessEq<'a, 'tcx> {
             },
             (&ExprKind::Box(ref l), &ExprKind::Box(ref r)) => self.eq_expr(l, r),
             (&ExprKind::Call(l_fun, l_args), &ExprKind::Call(r_fun, r_args)) => {
-                self.allow_side_effects && self.eq_expr(l_fun, r_fun) && self.eq_exprs(l_args, r_args)
+                self.inner.allow_side_effects && self.eq_expr(l_fun, r_fun) && self.eq_exprs(l_args, r_args)
             },
             (&ExprKind::Cast(ref lx, ref lt), &ExprKind::Cast(ref rx, ref rt))
             | (&ExprKind::Type(ref lx, ref lt), &ExprKind::Type(ref rx, ref rt)) => {
@@ -139,19 +180,19 @@ impl<'a, 'tcx> SpanlessEq<'a, 'tcx> {
                 ls == rs
                     && self.eq_expr(le, re)
                     && over(la, ra, |l, r| {
-                        self.eq_expr(&l.body, &r.body)
+                        self.eq_pat(&l.pat, &r.pat)
                             && both(&l.guard, &r.guard, |l, r| self.eq_guard(l, r))
-                            && self.eq_pat(&l.pat, &r.pat)
+                            && self.eq_expr(&l.body, &r.body)
                     })
             },
             (&ExprKind::MethodCall(l_path, _, l_args, _), &ExprKind::MethodCall(r_path, _, r_args, _)) => {
-                self.allow_side_effects && self.eq_path_segment(l_path, r_path) && self.eq_exprs(l_args, r_args)
+                self.inner.allow_side_effects && self.eq_path_segment(l_path, r_path) && self.eq_exprs(l_args, r_args)
             },
             (&ExprKind::Repeat(ref le, ref ll_id), &ExprKind::Repeat(ref re, ref rl_id)) => {
-                let mut celcx = constant_context(self.cx, self.cx.tcx.typeck_body(ll_id.body));
-                let ll = celcx.expr(&self.cx.tcx.hir().body(ll_id.body).value);
-                let mut celcx = constant_context(self.cx, self.cx.tcx.typeck_body(rl_id.body));
-                let rl = celcx.expr(&self.cx.tcx.hir().body(rl_id.body).value);
+                let mut celcx = constant_context(self.inner.cx, self.inner.cx.tcx.typeck_body(ll_id.body));
+                let ll = celcx.expr(&self.inner.cx.tcx.hir().body(ll_id.body).value);
+                let mut celcx = constant_context(self.inner.cx, self.inner.cx.tcx.typeck_body(rl_id.body));
+                let rl = celcx.expr(&self.inner.cx.tcx.hir().body(rl_id.body).value);
 
                 self.eq_expr(le, re) && ll == rl
             },
@@ -168,7 +209,7 @@ impl<'a, 'tcx> SpanlessEq<'a, 'tcx> {
             (&ExprKind::DropTemps(ref le), &ExprKind::DropTemps(ref re)) => self.eq_expr(le, re),
             _ => false,
         };
-        is_eq || self.expr_fallback.as_ref().map_or(false, |f| f(left, right))
+        is_eq || self.inner.expr_fallback.as_ref().map_or(false, |f| f(left, right))
     }
 
     fn eq_exprs(&mut self, left: &[Expr<'_>], right: &[Expr<'_>]) -> bool {
@@ -199,13 +240,13 @@ impl<'a, 'tcx> SpanlessEq<'a, 'tcx> {
         left.name == right.name
     }
 
-    pub fn eq_fieldpat(&mut self, left: &FieldPat<'_>, right: &FieldPat<'_>) -> bool {
+    fn eq_fieldpat(&mut self, left: &FieldPat<'_>, right: &FieldPat<'_>) -> bool {
         let (FieldPat { ident: li, pat: lp, .. }, FieldPat { ident: ri, pat: rp, .. }) = (&left, &right);
         li.name == ri.name && self.eq_pat(lp, rp)
     }
 
     /// Checks whether two patterns are the same.
-    pub fn eq_pat(&mut self, left: &Pat<'_>, right: &Pat<'_>) -> bool {
+    fn eq_pat(&mut self, left: &Pat<'_>, right: &Pat<'_>) -> bool {
         match (&left.kind, &right.kind) {
             (&PatKind::Box(ref l), &PatKind::Box(ref r)) => self.eq_pat(l, r),
             (&PatKind::Struct(ref lp, ref la, ..), &PatKind::Struct(ref rp, ref ra, ..)) => {
@@ -214,8 +255,12 @@ impl<'a, 'tcx> SpanlessEq<'a, 'tcx> {
             (&PatKind::TupleStruct(ref lp, ref la, ls), &PatKind::TupleStruct(ref rp, ref ra, rs)) => {
                 self.eq_qpath(lp, rp) && over(la, ra, |l, r| self.eq_pat(l, r)) && ls == rs
             },
-            (&PatKind::Binding(ref lb, .., ref li, ref lp), &PatKind::Binding(ref rb, .., ref ri, ref rp)) => {
-                lb == rb && li.name == ri.name && both(lp, rp, |l, r| self.eq_pat(l, r))
+            (&PatKind::Binding(lb, li, _, ref lp), &PatKind::Binding(rb, ri, _, ref rp)) => {
+                let eq = lb == rb && both(lp, rp, |l, r| self.eq_pat(l, r));
+                if eq {
+                    self.locals.insert(li, ri);
+                }
+                eq
             },
             (&PatKind::Path(ref l), &PatKind::Path(ref r)) => self.eq_qpath(l, r),
             (&PatKind::Lit(ref l), &PatKind::Lit(ref r)) => self.eq_expr(l, r),
@@ -251,8 +296,11 @@ impl<'a, 'tcx> SpanlessEq<'a, 'tcx> {
     }
 
     fn eq_path(&mut self, left: &Path<'_>, right: &Path<'_>) -> bool {
-        left.is_global() == right.is_global()
-            && over(&left.segments, &right.segments, |l, r| self.eq_path_segment(l, r))
+        match (left.res, right.res) {
+            (Res::Local(l), Res::Local(r)) => l == r || self.locals.get(&l) == Some(&r),
+            (Res::Local(_), _) | (_, Res::Local(_)) => false,
+            _ => over(&left.segments, &right.segments, |l, r| self.eq_path_segment(l, r)),
+        }
     }
 
     fn eq_path_parameters(&mut self, left: &GenericArgs<'_>, right: &GenericArgs<'_>) -> bool {
@@ -279,28 +327,19 @@ impl<'a, 'tcx> SpanlessEq<'a, 'tcx> {
         left.ident.name == right.ident.name && both(&left.args, &right.args, |l, r| self.eq_path_parameters(l, r))
     }
 
-    pub fn eq_ty(&mut self, left: &Ty<'_>, right: &Ty<'_>) -> bool {
+    fn eq_ty(&mut self, left: &Ty<'_>, right: &Ty<'_>) -> bool {
         self.eq_ty_kind(&left.kind, &right.kind)
     }
 
     #[allow(clippy::similar_names)]
-    pub fn eq_ty_kind(&mut self, left: &TyKind<'_>, right: &TyKind<'_>) -> bool {
+    fn eq_ty_kind(&mut self, left: &TyKind<'_>, right: &TyKind<'_>) -> bool {
         match (left, right) {
             (&TyKind::Slice(ref l_vec), &TyKind::Slice(ref r_vec)) => self.eq_ty(l_vec, r_vec),
             (&TyKind::Array(ref lt, ref ll_id), &TyKind::Array(ref rt, ref rl_id)) => {
-                let old_maybe_typeck_results = self.maybe_typeck_results;
-
-                let mut celcx = constant_context(self.cx, self.cx.tcx.typeck_body(ll_id.body));
-                self.maybe_typeck_results = Some(self.cx.tcx.typeck_body(ll_id.body));
-                let ll = celcx.expr(&self.cx.tcx.hir().body(ll_id.body).value);
-
-                let mut celcx = constant_context(self.cx, self.cx.tcx.typeck_body(rl_id.body));
-                self.maybe_typeck_results = Some(self.cx.tcx.typeck_body(rl_id.body));
-                let rl = celcx.expr(&self.cx.tcx.hir().body(rl_id.body).value);
-
-                let eq_ty = self.eq_ty(lt, rt);
-                self.maybe_typeck_results = old_maybe_typeck_results;
-                eq_ty && ll == rl
+                let cx = self.inner.cx;
+                let eval_const =
+                    |body| constant_context(cx, cx.tcx.typeck_body(body)).expr(&cx.tcx.hir().body(body).value);
+                self.eq_ty(lt, rt) && eval_const(ll_id.body) == eval_const(rl_id.body)
             },
             (&TyKind::Ptr(ref l_mut), &TyKind::Ptr(ref r_mut)) => {
                 l_mut.mutbl == r_mut.mutbl && self.eq_ty(&*l_mut.ty, &*r_mut.ty)
@@ -667,10 +706,15 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> {
         // self.maybe_typeck_results.unwrap().qpath_res(p, id).hash(&mut self.s);
     }
 
-    pub fn hash_path(&mut self, p: &Path<'_>) {
-        p.is_global().hash(&mut self.s);
-        for p in p.segments {
-            self.hash_name(p.ident.name);
+    pub fn hash_path(&mut self, path: &Path<'_>) {
+        match path.res {
+            // constant hash since equality is dependant on inter-expression context
+            Res::Local(_) => 1_usize.hash(&mut self.s),
+            _ => {
+                for seg in path.segments {
+                    self.hash_name(seg.ident.name);
+                }
+            },
         }
     }
 
diff --git a/tests/ui/collapsible_match.rs b/tests/ui/collapsible_match.rs
index 3294da7e814..55467cf4229 100644
--- a/tests/ui/collapsible_match.rs
+++ b/tests/ui/collapsible_match.rs
@@ -232,6 +232,14 @@ fn negative_cases(res_opt: Result<Option<u32>, String>, res_res: Result<Result<u
             };
         }
     }
+    let _: &dyn std::any::Any = match &Some(Some(1)) {
+        Some(e) => match e {
+            Some(e) => e,
+            e => e,
+        },
+        // else branch looks the same but the binding is different
+        e => e,
+    };
 }
 
 fn make<T>() -> T {
diff --git a/tests/ui/if_same_then_else2.rs b/tests/ui/if_same_then_else2.rs
index e83ce47e563..a2ff1b741ca 100644
--- a/tests/ui/if_same_then_else2.rs
+++ b/tests/ui/if_same_then_else2.rs
@@ -12,7 +12,7 @@ fn if_same_then_else2() -> Result<&'static str, ()> {
     if true {
         for _ in &[42] {
             let foo: &Option<_> = &Some::<u8>(42);
-            if true {
+            if foo.is_some() {
                 break;
             } else {
                 continue;
@@ -21,8 +21,8 @@ fn if_same_then_else2() -> Result<&'static str, ()> {
     } else {
         //~ ERROR same body as `if` block
         for _ in &[42] {
-            let foo: &Option<_> = &Some::<u8>(42);
-            if true {
+            let bar: &Option<_> = &Some::<u8>(42);
+            if bar.is_some() {
                 break;
             } else {
                 continue;
diff --git a/tests/ui/if_same_then_else2.stderr b/tests/ui/if_same_then_else2.stderr
index f98e30fa376..454322d8aac 100644
--- a/tests/ui/if_same_then_else2.stderr
+++ b/tests/ui/if_same_then_else2.stderr
@@ -5,7 +5,7 @@ LL |       } else {
    |  ____________^
 LL | |         //~ ERROR same body as `if` block
 LL | |         for _ in &[42] {
-LL | |             let foo: &Option<_> = &Some::<u8>(42);
+LL | |             let bar: &Option<_> = &Some::<u8>(42);
 ...  |
 LL | |         }
 LL | |     }
@@ -19,7 +19,7 @@ LL |       if true {
    |  _____________^
 LL | |         for _ in &[42] {
 LL | |             let foo: &Option<_> = &Some::<u8>(42);
-LL | |             if true {
+LL | |             if foo.is_some() {
 ...  |
 LL | |         }
 LL | |     } else {
-- 
cgit 1.4.1-3-g733a5


From 742922a41a07653ec85b81a3be2c5788707e10d9 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Wed, 17 Feb 2021 09:35:55 -0600
Subject: Make expr_fallback FnMut

---
 clippy_lints/src/utils/hir_utils.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/hir_utils.rs b/clippy_lints/src/utils/hir_utils.rs
index 0a9719901f0..c042990b759 100644
--- a/clippy_lints/src/utils/hir_utils.rs
+++ b/clippy_lints/src/utils/hir_utils.rs
@@ -26,7 +26,7 @@ pub struct SpanlessEq<'a, 'tcx> {
     cx: &'a LateContext<'tcx>,
     maybe_typeck_results: Option<&'tcx TypeckResults<'tcx>>,
     allow_side_effects: bool,
-    expr_fallback: Option<Box<dyn Fn(&Expr<'_>, &Expr<'_>) -> bool + 'a>>,
+    expr_fallback: Option<Box<dyn FnMut(&Expr<'_>, &Expr<'_>) -> bool + 'a>>,
 }
 
 impl<'a, 'tcx> SpanlessEq<'a, 'tcx> {
@@ -47,7 +47,7 @@ impl<'a, 'tcx> SpanlessEq<'a, 'tcx> {
         }
     }
 
-    pub fn expr_fallback(self, expr_fallback: impl Fn(&Expr<'_>, &Expr<'_>) -> bool + 'a) -> Self {
+    pub fn expr_fallback(self, expr_fallback: impl FnMut(&Expr<'_>, &Expr<'_>) -> bool + 'a) -> Self {
         Self {
             expr_fallback: Some(Box::new(expr_fallback)),
             ..self
@@ -209,7 +209,7 @@ impl HirEqInterExpr<'_, '_, '_> {
             (&ExprKind::DropTemps(ref le), &ExprKind::DropTemps(ref re)) => self.eq_expr(le, re),
             _ => false,
         };
-        is_eq || self.inner.expr_fallback.as_ref().map_or(false, |f| f(left, right))
+        is_eq || self.inner.expr_fallback.as_mut().map_or(false, |f| f(left, right))
     }
 
     fn eq_exprs(&mut self, left: &[Expr<'_>], right: &[Expr<'_>]) -> bool {
-- 
cgit 1.4.1-3-g733a5


From 9ad6e263c9eec118a37cdbd5e182afaaad42840a Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Wed, 17 Feb 2021 10:02:22 -0600
Subject: Fix match_same_arms with SpanlessEq changes

---
 clippy_lints/src/matches.rs | 113 ++++++++++++++++++++------------------------
 1 file changed, 50 insertions(+), 63 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index e33001b16bc..efc8b139425 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -3,19 +3,19 @@ use crate::utils::sugg::Sugg;
 use crate::utils::visitors::LocalUsedVisitor;
 use crate::utils::{
     expr_block, get_parent_expr, implements_trait, in_macro, indent_of, is_allowed, is_expn_of, is_refutable,
-    is_type_diagnostic_item, is_wild, match_qpath, match_type, meets_msrv, multispan_sugg, path_to_local_id,
-    peel_hir_pat_refs, peel_mid_ty_refs, peel_n_hir_expr_refs, remove_blocks, snippet, snippet_block, snippet_opt,
-    snippet_with_applicability, span_lint_and_help, span_lint_and_note, span_lint_and_sugg, span_lint_and_then,
-    strip_pat_refs,
+    is_type_diagnostic_item, is_wild, match_qpath, match_type, meets_msrv, multispan_sugg, path_to_local,
+    path_to_local_id, peel_hir_pat_refs, peel_mid_ty_refs, peel_n_hir_expr_refs, remove_blocks, snippet, snippet_block,
+    snippet_opt, snippet_with_applicability, span_lint_and_help, span_lint_and_note, span_lint_and_sugg,
+    span_lint_and_then, strip_pat_refs,
 };
 use crate::utils::{paths, search_same, SpanlessEq, SpanlessHash};
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
-use rustc_data_structures::fx::FxHashMap;
+use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_errors::Applicability;
 use rustc_hir::def::CtorKind;
 use rustc_hir::{
-    Arm, BindingAnnotation, Block, BorrowKind, Expr, ExprKind, Guard, Local, MatchSource, Mutability, Node, Pat,
+    Arm, BindingAnnotation, Block, BorrowKind, Expr, ExprKind, Guard, HirId, Local, MatchSource, Mutability, Node, Pat,
     PatKind, QPath, RangeEnd,
 };
 use rustc_lint::{LateContext, LateLintPass, LintContext};
@@ -24,7 +24,7 @@ use rustc_middle::ty::{self, Ty, TyS};
 use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::{Span, Spanned};
-use rustc_span::{sym, Symbol};
+use rustc_span::sym;
 use std::cmp::Ordering;
 use std::collections::hash_map::Entry;
 use std::collections::Bound;
@@ -1873,13 +1873,6 @@ fn test_overlapping() {
 
 /// Implementation of `MATCH_SAME_ARMS`.
 fn lint_match_arms<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>) {
-    fn same_bindings<'tcx>(lhs: &FxHashMap<Symbol, Ty<'tcx>>, rhs: &FxHashMap<Symbol, Ty<'tcx>>) -> bool {
-        lhs.len() == rhs.len()
-            && lhs
-                .iter()
-                .all(|(name, l_ty)| rhs.get(name).map_or(false, |r_ty| TyS::same_type(l_ty, r_ty)))
-    }
-
     if let ExprKind::Match(_, ref arms, MatchSource::Normal) = expr.kind {
         let hash = |&(_, arm): &(usize, &Arm<'_>)| -> u64 {
             let mut h = SpanlessHash::new(cx);
@@ -1891,12 +1884,38 @@ fn lint_match_arms<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>) {
             let min_index = usize::min(lindex, rindex);
             let max_index = usize::max(lindex, rindex);
 
+            let mut local_map: FxHashMap<HirId, HirId> = FxHashMap::default();
+            let eq_fallback = |a: &Expr<'_>, b: &Expr<'_>| {
+                if_chain! {
+                    if let Some(a_id) = path_to_local(a);
+                    if let Some(b_id) = path_to_local(b);
+                    let entry = match local_map.entry(a_id) {
+                        Entry::Vacant(entry) => entry,
+                        // check if using the same bindings as before
+                        Entry::Occupied(entry) => return *entry.get() == b_id,
+                    };
+                    // the names technically don't have to match; this makes the lint more conservative
+                    if cx.tcx.hir().name(a_id) == cx.tcx.hir().name(b_id);
+                    if TyS::same_type(cx.typeck_results().expr_ty(a), cx.typeck_results().expr_ty(b));
+                    if pat_contains_local(lhs.pat, a_id);
+                    if pat_contains_local(rhs.pat, b_id);
+                    then {
+                        entry.insert(b_id);
+                        true
+                    } else {
+                        false
+                    }
+                }
+            };
             // Arms with a guard are ignored, those can’t always be merged together
             // This is also the case for arms in-between each there is an arm with a guard
-            (min_index..=max_index).all(|index| arms[index].guard.is_none()) &&
-                SpanlessEq::new(cx).eq_expr(&lhs.body, &rhs.body) &&
-                // all patterns should have the same bindings
-                same_bindings(&bindings(cx, &lhs.pat), &bindings(cx, &rhs.pat))
+            (min_index..=max_index).all(|index| arms[index].guard.is_none())
+                && SpanlessEq::new(cx)
+                    .expr_fallback(eq_fallback)
+                    .eq_expr(&lhs.body, &rhs.body)
+                // these checks could be removed to allow unused bindings
+                && bindings_eq(lhs.pat, local_map.keys().copied().collect())
+                && bindings_eq(rhs.pat, local_map.values().copied().collect())
         };
 
         let indexed_arms: Vec<(usize, &Arm<'_>)> = arms.iter().enumerate().collect();
@@ -1939,50 +1958,18 @@ fn lint_match_arms<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>) {
     }
 }
 
-/// Returns the list of bindings in a pattern.
-fn bindings<'tcx>(cx: &LateContext<'tcx>, pat: &Pat<'_>) -> FxHashMap<Symbol, Ty<'tcx>> {
-    fn bindings_impl<'tcx>(cx: &LateContext<'tcx>, pat: &Pat<'_>, map: &mut FxHashMap<Symbol, Ty<'tcx>>) {
-        match pat.kind {
-            PatKind::Box(ref pat) | PatKind::Ref(ref pat, _) => bindings_impl(cx, pat, map),
-            PatKind::TupleStruct(_, pats, _) => {
-                for pat in pats {
-                    bindings_impl(cx, pat, map);
-                }
-            },
-            PatKind::Binding(.., ident, ref as_pat) => {
-                if let Entry::Vacant(v) = map.entry(ident.name) {
-                    v.insert(cx.typeck_results().pat_ty(pat));
-                }
-                if let Some(ref as_pat) = *as_pat {
-                    bindings_impl(cx, as_pat, map);
-                }
-            },
-            PatKind::Or(fields) | PatKind::Tuple(fields, _) => {
-                for pat in fields {
-                    bindings_impl(cx, pat, map);
-                }
-            },
-            PatKind::Struct(_, fields, _) => {
-                for pat in fields {
-                    bindings_impl(cx, &pat.pat, map);
-                }
-            },
-            PatKind::Slice(lhs, ref mid, rhs) => {
-                for pat in lhs {
-                    bindings_impl(cx, pat, map);
-                }
-                if let Some(ref mid) = *mid {
-                    bindings_impl(cx, mid, map);
-                }
-                for pat in rhs {
-                    bindings_impl(cx, pat, map);
-                }
-            },
-            PatKind::Lit(..) | PatKind::Range(..) | PatKind::Wild | PatKind::Path(..) => (),
-        }
-    }
-
-    let mut result = FxHashMap::default();
-    bindings_impl(cx, pat, &mut result);
+fn pat_contains_local(pat: &Pat<'_>, id: HirId) -> bool {
+    let mut result = false;
+    pat.walk_short(|p| {
+        result |= matches!(p.kind, PatKind::Binding(_, binding_id, ..) if binding_id == id);
+        !result
+    });
     result
 }
+
+/// Returns true if all the bindings in the `Pat` are in `ids` and vice versa
+fn bindings_eq(pat: &Pat<'_>, mut ids: FxHashSet<HirId>) -> bool {
+    let mut result = true;
+    pat.each_binding_or_first(&mut |_, id, _, _| result &= ids.remove(&id));
+    result && ids.is_empty()
+}
-- 
cgit 1.4.1-3-g733a5


From 6165cccf7e43cf4ca2234e84dcf7060c7d89ef45 Mon Sep 17 00:00:00 2001
From: Pierre-Andre Gagnon <pagagnon@gmail.com>
Date: Wed, 17 Feb 2021 16:41:50 -0500
Subject: Added detailled suggs for new case

---
 clippy_lints/src/unnecessary_wraps.rs | 100 ++++++++++++++++------------------
 tests/ui/unnecessary_wraps.stderr     |  62 +++++++++++++++++----
 2 files changed, 97 insertions(+), 65 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unnecessary_wraps.rs b/clippy_lints/src/unnecessary_wraps.rs
index 7da42ba3934..b097d531bc4 100644
--- a/clippy_lints/src/unnecessary_wraps.rs
+++ b/clippy_lints/src/unnecessary_wraps.rs
@@ -1,13 +1,13 @@
 use crate::utils::{
-    contains_return, in_macro, is_type_diagnostic_item, match_qpath, paths, return_ty, snippet, span_lint_and_sugg,
-    span_lint_and_then, visitors::find_all_ret_expressions,
+    contains_return, in_macro, match_qpath, paths, return_ty, snippet, span_lint_and_then,
+    visitors::find_all_ret_expressions,
 };
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::{Body, ExprKind, FnDecl, HirId, Impl, ItemKind, Node};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty::subst::GenericArgKind;
+use rustc_middle::ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::symbol::sym;
 use rustc_span::Span;
@@ -85,33 +85,23 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryWraps {
             }
         }
 
-        // Check if return type is Option or Result. If neither, abort.
-        let return_ty = return_ty(cx, hir_id);
-        let (return_type_label, path) = if is_type_diagnostic_item(cx, return_ty, sym::option_type) {
-            ("Option", &paths::OPTION_SOME)
-        } else if is_type_diagnostic_item(cx, return_ty, sym::result_type) {
-            ("Result", &paths::RESULT_OK)
-        } else {
-            return;
-        };
-
-        // Take the first inner type of the Option or Result. If can't, abort.
-        let inner_ty = if_chain! {
-            // Skip Option or Result and take the first outermost inner type.
-            if let Some(inner_ty) = return_ty.walk().nth(1);
-            if let GenericArgKind::Type(inner_ty) = inner_ty.unpack();
-            then {
-                inner_ty
+        // Get the wrapper and inner types, if can't, abort.
+        let (return_type_label, path, inner_type) = if let ty::Adt(adt_def, subst) = return_ty(cx, hir_id).kind() {
+            if cx.tcx.is_diagnostic_item(sym::option_type, adt_def.did) {
+                ("Option", &paths::OPTION_SOME, subst.type_at(0))
+            } else if cx.tcx.is_diagnostic_item(sym::result_type, adt_def.did) {
+                ("Result", &paths::RESULT_OK, subst.type_at(0))
             } else {
                 return;
             }
+        } else {
+            return;
         };
 
         // Check if all return expression respect the following condition and collect them.
         let mut suggs = Vec::new();
         let can_sugg = find_all_ret_expressions(cx, &body.value, |ret_expr| {
             if_chain! {
-                // Abort if in macro.
                 if !in_macro(ret_expr.span);
                 // Check if a function call.
                 if let ExprKind::Call(ref func, ref args) = ret_expr.kind;
@@ -119,12 +109,20 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryWraps {
                 if let ExprKind::Path(ref qpath) = func.kind;
                 // Check if OPTION_SOME or RESULT_OK, depending on return type.
                 if match_qpath(qpath, path);
-                // Make sure the function call has only one argument.
                 if args.len() == 1;
                 // Make sure the function argument does not contain a return expression.
                 if !contains_return(&args[0]);
                 then {
-                    suggs.push((ret_expr.span, snippet(cx, args[0].span.source_callsite(), "..").to_string()));
+                    suggs.push(
+                        (
+                            ret_expr.span,
+                            if inner_type.is_unit() {
+                                "".to_string()
+                            } else {
+                                snippet(cx, args[0].span.source_callsite(), "..").to_string()
+                            }
+                        )
+                    );
                     true
                 } else {
                     false
@@ -133,42 +131,36 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryWraps {
         });
 
         if can_sugg && !suggs.is_empty() {
-            // Issue 6640: If the inner type is Unit, emit lint similar to clippy::unused_unit.
-            if inner_ty.is_unit() {
-                span_lint_and_sugg(
-                    cx,
-                    UNNECESSARY_WRAPS,
-                    fn_decl.output.span(),
-                    "unneeded wrapped unit return type",
-                    format!("remove the `-> {}<[...]>`", return_type_label).as_str(),
-                    String::new(),
-                    Applicability::MaybeIncorrect,
-                );
+            let (lint_msg, return_type_suggestion_msg, return_type_suggestion) = if inner_type.is_unit() {
+                (
+                    "this function's return value is unnecessary".to_string(),
+                    "remove the return type...".to_string(),
+                    snippet(cx, fn_decl.output.span(), "..").to_string(),
+                )
             } else {
-                span_lint_and_then(
-                    cx,
-                    UNNECESSARY_WRAPS,
-                    span,
+                (
                     format!(
                         "this function's return value is unnecessarily wrapped by `{}`",
                         return_type_label
-                    )
-                    .as_str(),
-                    |diag| {
-                        diag.span_suggestion(
-                            fn_decl.output.span(),
-                            format!("remove `{}` from the return type...", return_type_label).as_str(),
-                            inner_ty.to_string(),
-                            Applicability::MaybeIncorrect,
-                        );
-                        diag.multipart_suggestion(
-                            "...and change the returning expressions",
-                            suggs,
-                            Applicability::MaybeIncorrect,
-                        );
-                    },
+                    ),
+                    format!("remove `{}` from the return type...", return_type_label),
+                    inner_type.to_string(),
+                )
+            };
+
+            span_lint_and_then(cx, UNNECESSARY_WRAPS, span, lint_msg.as_str(), |diag| {
+                diag.span_suggestion(
+                    fn_decl.output.span(),
+                    return_type_suggestion_msg.as_str(),
+                    return_type_suggestion,
+                    Applicability::MaybeIncorrect,
                 );
-            }
+                diag.multipart_suggestion(
+                    "...and then change the returning expressions",
+                    suggs,
+                    Applicability::MaybeIncorrect,
+                );
+            });
         }
     }
 }
diff --git a/tests/ui/unnecessary_wraps.stderr b/tests/ui/unnecessary_wraps.stderr
index f28981f9e34..40effb89499 100644
--- a/tests/ui/unnecessary_wraps.stderr
+++ b/tests/ui/unnecessary_wraps.stderr
@@ -15,7 +15,7 @@ help: remove `Option` from the return type...
    |
 LL | fn func1(a: bool, b: bool) -> i32 {
    |                               ^^^
-help: ...and change the returning expressions
+help: ...and then change the returning expressions
    |
 LL |         return 42;
 LL |     }
@@ -41,7 +41,7 @@ help: remove `Option` from the return type...
    |
 LL | fn func2(a: bool, b: bool) -> i32 {
    |                               ^^^
-help: ...and change the returning expressions
+help: ...and then change the returning expressions
    |
 LL |         return 10;
 LL |     }
@@ -63,7 +63,7 @@ help: remove `Option` from the return type...
    |
 LL | fn func5() -> i32 {
    |               ^^^
-help: ...and change the returning expressions
+help: ...and then change the returning expressions
    |
 LL |     1
    |
@@ -80,7 +80,7 @@ help: remove `Result` from the return type...
    |
 LL | fn func7() -> i32 {
    |               ^^^
-help: ...and change the returning expressions
+help: ...and then change the returning expressions
    |
 LL |     1
    |
@@ -97,22 +97,62 @@ help: remove `Option` from the return type...
    |
 LL |     fn func12() -> i32 {
    |                    ^^^
-help: ...and change the returning expressions
+help: ...and then change the returning expressions
    |
 LL |         1
    |
 
-error: unneeded wrapped unit return type
-  --> $DIR/unnecessary_wraps.rs:120:38
+error: this function's return value is unnecessary
+  --> $DIR/unnecessary_wraps.rs:120:1
+   |
+LL | / fn issue_6640_1(a: bool, b: bool) -> Option<()> {
+LL | |     if a && b {
+LL | |         return Some(());
+LL | |     }
+...  |
+LL | |     }
+LL | | }
+   | |_^
+   |
+help: remove the return type...
    |
 LL | fn issue_6640_1(a: bool, b: bool) -> Option<()> {
-   |                                      ^^^^^^^^^^ help: remove the `-> Option<[...]>`
+   |                                      ^^^^^^^^^^
+help: ...and then change the returning expressions
+   |
+LL |         return ;
+LL |     }
+LL |     if a {
+LL |         Some(());
+LL |         
+LL |     } else {
+ ...
 
-error: unneeded wrapped unit return type
-  --> $DIR/unnecessary_wraps.rs:133:38
+error: this function's return value is unnecessary
+  --> $DIR/unnecessary_wraps.rs:133:1
+   |
+LL | / fn issue_6640_2(a: bool, b: bool) -> Result<(), i32> {
+LL | |     if a && b {
+LL | |         return Ok(());
+LL | |     }
+...  |
+LL | |     }
+LL | | }
+   | |_^
+   |
+help: remove the return type...
    |
 LL | fn issue_6640_2(a: bool, b: bool) -> Result<(), i32> {
-   |                                      ^^^^^^^^^^^^^^^ help: remove the `-> Result<[...]>`
+   |                                      ^^^^^^^^^^^^^^^
+help: ...and then change the returning expressions
+   |
+LL |         return ;
+LL |     }
+LL |     if a {
+LL |         
+LL |     } else {
+LL |         return ;
+   |
 
 error: aborting due to 7 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From a87fa0e35049470aff2dc8f9ddc8399bb6c0718d Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Thu, 18 Feb 2021 18:35:25 +0900
Subject: Fix FP of result_unit_err when using type aliases

---
 clippy_lints/src/functions.rs     | 15 +++++++--------
 tests/ui/result_unit_error.rs     | 23 ++++++++++++++++++++---
 tests/ui/result_unit_error.stderr | 18 +++++++++++++-----
 3 files changed, 40 insertions(+), 16 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/functions.rs b/clippy_lints/src/functions.rs
index 94200a15420..30814e869e6 100644
--- a/clippy_lints/src/functions.rs
+++ b/clippy_lints/src/functions.rs
@@ -1,7 +1,7 @@
 use crate::utils::{
     attr_by_name, attrs::is_proc_macro, is_must_use_ty, is_trait_impl_item, is_type_diagnostic_item, iter_input_pats,
-    last_path_segment, match_def_path, must_use_attr, path_to_local, return_ty, snippet, snippet_opt, span_lint,
-    span_lint_and_help, span_lint_and_then, trait_ref_of_method, type_is_unsafe_function,
+    match_def_path, must_use_attr, path_to_local, return_ty, snippet, snippet_opt, span_lint, span_lint_and_help,
+    span_lint_and_then, trait_ref_of_method, type_is_unsafe_function,
 };
 use if_chain::if_chain;
 use rustc_ast::ast::Attribute;
@@ -470,12 +470,11 @@ fn check_result_unit_err(cx: &LateContext<'_>, decl: &hir::FnDecl<'_>, item_span
     if_chain! {
         if !in_external_macro(cx.sess(), item_span);
         if let hir::FnRetTy::Return(ref ty) = decl.output;
-        if let hir::TyKind::Path(ref qpath) = ty.kind;
-        if is_type_diagnostic_item(cx, hir_ty_to_ty(cx.tcx, ty), sym::result_type);
-        if let Some(ref args) = last_path_segment(qpath).args;
-        if let [_, hir::GenericArg::Type(ref err_ty)] = args.args;
-        if let hir::TyKind::Tup(t) = err_ty.kind;
-        if t.is_empty();
+        let ty = hir_ty_to_ty(cx.tcx, ty);
+        if is_type_diagnostic_item(cx, ty, sym::result_type);
+        if let ty::Adt(_, substs) = ty.kind();
+        let err_ty = substs.type_at(1);
+        if err_ty.is_unit();
         then {
             span_lint_and_help(
                 cx,
diff --git a/tests/ui/result_unit_error.rs b/tests/ui/result_unit_error.rs
index 5e57c752b5a..a4ec803024e 100644
--- a/tests/ui/result_unit_error.rs
+++ b/tests/ui/result_unit_error.rs
@@ -1,6 +1,4 @@
-#![allow(clippy::unnecessary_wraps)]
-#[warn(clippy::result_unit_err)]
-#[allow(unused)]
+#![warn(clippy::result_unit_err)]
 
 pub fn returns_unit_error() -> Result<u32, ()> {
     Err(())
@@ -36,4 +34,23 @@ impl UnitErrorHolder {
     }
 }
 
+// https://github.com/rust-lang/rust-clippy/issues/6546
+pub mod issue_6546 {
+    type ResInv<A, B> = Result<B, A>;
+
+    pub fn should_lint() -> ResInv<(), usize> {
+        Ok(0)
+    }
+
+    pub fn should_not_lint() -> ResInv<usize, ()> {
+        Ok(())
+    }
+
+    type MyRes<A, B> = Result<(A, B), Box<dyn std::error::Error>>;
+
+    pub fn should_not_lint2(x: i32) -> MyRes<i32, ()> {
+        Ok((x, ()))
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/result_unit_error.stderr b/tests/ui/result_unit_error.stderr
index 12901b354f9..41d8b0a7cb7 100644
--- a/tests/ui/result_unit_error.stderr
+++ b/tests/ui/result_unit_error.stderr
@@ -1,5 +1,5 @@
 error: this returns a `Result<_, ()>
-  --> $DIR/result_unit_error.rs:5:1
+  --> $DIR/result_unit_error.rs:3:1
    |
 LL | pub fn returns_unit_error() -> Result<u32, ()> {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -8,7 +8,7 @@ LL | pub fn returns_unit_error() -> Result<u32, ()> {
    = help: use a custom Error type instead
 
 error: this returns a `Result<_, ()>
-  --> $DIR/result_unit_error.rs:14:5
+  --> $DIR/result_unit_error.rs:12:5
    |
 LL |     fn get_that_error(&self) -> Result<bool, ()>;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -16,7 +16,7 @@ LL |     fn get_that_error(&self) -> Result<bool, ()>;
    = help: use a custom Error type instead
 
 error: this returns a `Result<_, ()>
-  --> $DIR/result_unit_error.rs:16:5
+  --> $DIR/result_unit_error.rs:14:5
    |
 LL |     fn get_this_one_too(&self) -> Result<bool, ()> {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -24,12 +24,20 @@ LL |     fn get_this_one_too(&self) -> Result<bool, ()> {
    = help: use a custom Error type instead
 
 error: this returns a `Result<_, ()>
-  --> $DIR/result_unit_error.rs:34:5
+  --> $DIR/result_unit_error.rs:32:5
    |
 LL |     pub fn unit_error(&self) -> Result<usize, ()> {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: use a custom Error type instead
 
-error: aborting due to 4 previous errors
+error: this returns a `Result<_, ()>
+  --> $DIR/result_unit_error.rs:41:5
+   |
+LL |     pub fn should_lint() -> ResInv<(), usize> {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use a custom Error type instead
+
+error: aborting due to 5 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From a78271b8611d7ab7709976dfb94ae36b668ac42b Mon Sep 17 00:00:00 2001
From: Pierre-Andre Gagnon <pagagnon@gmail.com>
Date: Thu, 18 Feb 2021 17:32:55 -0500
Subject: Changed fn body suggestion msg

---
 clippy_lints/src/unnecessary_wraps.rs | 14 ++++++--------
 tests/ui/unnecessary_wraps.rs         | 18 ++++++++++++++++++
 tests/ui/unnecessary_wraps.stderr     | 14 +++++++-------
 3 files changed, 31 insertions(+), 15 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unnecessary_wraps.rs b/clippy_lints/src/unnecessary_wraps.rs
index b097d531bc4..607585125a4 100644
--- a/clippy_lints/src/unnecessary_wraps.rs
+++ b/clippy_lints/src/unnecessary_wraps.rs
@@ -131,11 +131,12 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryWraps {
         });
 
         if can_sugg && !suggs.is_empty() {
-            let (lint_msg, return_type_suggestion_msg, return_type_suggestion) = if inner_type.is_unit() {
+            let (lint_msg, return_type_sugg_msg, return_type_sugg, body_sugg_msg) = if inner_type.is_unit() {
                 (
                     "this function's return value is unnecessary".to_string(),
                     "remove the return type...".to_string(),
                     snippet(cx, fn_decl.output.span(), "..").to_string(),
+                    "...and then remove returned values",
                 )
             } else {
                 (
@@ -145,21 +146,18 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryWraps {
                     ),
                     format!("remove `{}` from the return type...", return_type_label),
                     inner_type.to_string(),
+                    "...and then change returning expressions",
                 )
             };
 
             span_lint_and_then(cx, UNNECESSARY_WRAPS, span, lint_msg.as_str(), |diag| {
                 diag.span_suggestion(
                     fn_decl.output.span(),
-                    return_type_suggestion_msg.as_str(),
-                    return_type_suggestion,
-                    Applicability::MaybeIncorrect,
-                );
-                diag.multipart_suggestion(
-                    "...and then change the returning expressions",
-                    suggs,
+                    return_type_sugg_msg.as_str(),
+                    return_type_sugg,
                     Applicability::MaybeIncorrect,
                 );
+                diag.multipart_suggestion(body_sugg_msg, suggs, Applicability::MaybeIncorrect);
             });
         }
     }
diff --git a/tests/ui/unnecessary_wraps.rs b/tests/ui/unnecessary_wraps.rs
index 5aaa99bbe5a..a510263e67d 100644
--- a/tests/ui/unnecessary_wraps.rs
+++ b/tests/ui/unnecessary_wraps.rs
@@ -141,6 +141,24 @@ fn issue_6640_2(a: bool, b: bool) -> Result<(), i32> {
     }
 }
 
+// should not be linted
+fn issue_6640_3() -> Option<()> {
+    if true {
+        Some(())
+    } else {
+        None
+    }
+}
+
+// should not be linted
+fn issue_6640_4() -> Result<(), ()> {
+    if true {
+        Ok(())
+    } else {
+        Err(())
+    }
+}
+
 fn main() {
     // method calls are not linted
     func1(true, true);
diff --git a/tests/ui/unnecessary_wraps.stderr b/tests/ui/unnecessary_wraps.stderr
index 40effb89499..9a861c61a46 100644
--- a/tests/ui/unnecessary_wraps.stderr
+++ b/tests/ui/unnecessary_wraps.stderr
@@ -15,7 +15,7 @@ help: remove `Option` from the return type...
    |
 LL | fn func1(a: bool, b: bool) -> i32 {
    |                               ^^^
-help: ...and then change the returning expressions
+help: ...and then change returning expressions
    |
 LL |         return 42;
 LL |     }
@@ -41,7 +41,7 @@ help: remove `Option` from the return type...
    |
 LL | fn func2(a: bool, b: bool) -> i32 {
    |                               ^^^
-help: ...and then change the returning expressions
+help: ...and then change returning expressions
    |
 LL |         return 10;
 LL |     }
@@ -63,7 +63,7 @@ help: remove `Option` from the return type...
    |
 LL | fn func5() -> i32 {
    |               ^^^
-help: ...and then change the returning expressions
+help: ...and then change returning expressions
    |
 LL |     1
    |
@@ -80,7 +80,7 @@ help: remove `Result` from the return type...
    |
 LL | fn func7() -> i32 {
    |               ^^^
-help: ...and then change the returning expressions
+help: ...and then change returning expressions
    |
 LL |     1
    |
@@ -97,7 +97,7 @@ help: remove `Option` from the return type...
    |
 LL |     fn func12() -> i32 {
    |                    ^^^
-help: ...and then change the returning expressions
+help: ...and then change returning expressions
    |
 LL |         1
    |
@@ -118,7 +118,7 @@ help: remove the return type...
    |
 LL | fn issue_6640_1(a: bool, b: bool) -> Option<()> {
    |                                      ^^^^^^^^^^
-help: ...and then change the returning expressions
+help: ...and then remove returned values
    |
 LL |         return ;
 LL |     }
@@ -144,7 +144,7 @@ help: remove the return type...
    |
 LL | fn issue_6640_2(a: bool, b: bool) -> Result<(), i32> {
    |                                      ^^^^^^^^^^^^^^^
-help: ...and then change the returning expressions
+help: ...and then remove returned values
    |
 LL |         return ;
 LL |     }
-- 
cgit 1.4.1-3-g733a5


From 54c6054ec72c7ec8babd95324059713abdfa74f7 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Thu, 18 Feb 2021 20:02:58 -0600
Subject: Change unnecessary_wraps to pedantic

---
 clippy_lints/src/lib.rs               | 3 +--
 clippy_lints/src/unnecessary_wraps.rs | 2 +-
 2 files changed, 2 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 40727980693..102a5f05d73 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1393,6 +1393,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&types::PTR_AS_PTR),
         LintId::of(&unicode::NON_ASCII_LITERAL),
         LintId::of(&unicode::UNICODE_NOT_NFC),
+        LintId::of(&unnecessary_wraps::UNNECESSARY_WRAPS),
         LintId::of(&unnested_or_patterns::UNNESTED_OR_PATTERNS),
         LintId::of(&unused_self::UNUSED_SELF),
         LintId::of(&wildcard_imports::ENUM_GLOB_USE),
@@ -1686,7 +1687,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&unnamed_address::FN_ADDRESS_COMPARISONS),
         LintId::of(&unnamed_address::VTABLE_ADDRESS_COMPARISONS),
         LintId::of(&unnecessary_sort_by::UNNECESSARY_SORT_BY),
-        LintId::of(&unnecessary_wraps::UNNECESSARY_WRAPS),
         LintId::of(&unsafe_removed_from_name::UNSAFE_REMOVED_FROM_NAME),
         LintId::of(&unused_io_amount::UNUSED_IO_AMOUNT),
         LintId::of(&unused_unit::UNUSED_UNIT),
@@ -1903,7 +1903,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&types::UNNECESSARY_CAST),
         LintId::of(&types::VEC_BOX),
         LintId::of(&unnecessary_sort_by::UNNECESSARY_SORT_BY),
-        LintId::of(&unnecessary_wraps::UNNECESSARY_WRAPS),
         LintId::of(&unwrap::UNNECESSARY_UNWRAP),
         LintId::of(&useless_conversion::USELESS_CONVERSION),
         LintId::of(&zero_div_zero::ZERO_DIVIDED_BY_ZERO),
diff --git a/clippy_lints/src/unnecessary_wraps.rs b/clippy_lints/src/unnecessary_wraps.rs
index 8ac5dd696b7..0e78c76a7d1 100644
--- a/clippy_lints/src/unnecessary_wraps.rs
+++ b/clippy_lints/src/unnecessary_wraps.rs
@@ -48,7 +48,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     pub UNNECESSARY_WRAPS,
-    complexity,
+    pedantic,
     "functions that only return `Ok` or `Some`"
 }
 
-- 
cgit 1.4.1-3-g733a5


From 46c91db1e1c1f497854069d78e522bc5ff6bf0f7 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Thu, 18 Feb 2021 20:23:49 -0600
Subject: Change known problems

---
 clippy_lints/src/unnecessary_wraps.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unnecessary_wraps.rs b/clippy_lints/src/unnecessary_wraps.rs
index 0e78c76a7d1..9c0c21b9bc7 100644
--- a/clippy_lints/src/unnecessary_wraps.rs
+++ b/clippy_lints/src/unnecessary_wraps.rs
@@ -17,8 +17,8 @@ declare_clippy_lint! {
     ///
     /// **Why is this bad?** It is not meaningful to wrap values when no `None` or `Err` is returned.
     ///
-    /// **Known problems:** Since this lint changes function type signature, you may need to
-    /// adjust some code at callee side.
+    /// **Known problems:** There can be false positives if the function signature is designed to
+    /// fit some external requirement.
     ///
     /// **Example:**
     ///
-- 
cgit 1.4.1-3-g733a5


From 1f4153aa1e2fc4a59527c17cde43f3feb3088463 Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Fri, 19 Feb 2021 10:02:17 +0100
Subject: collapsible_match: fix lint message capitalization

(see https://rustc-dev-guide.rust-lang.org/diagnostics.html for details)
---
 clippy_lints/src/collapsible_match.rs |  6 ++--
 tests/ui/collapsible_match.stderr     | 60 +++++++++++++++++------------------
 tests/ui/collapsible_match2.stderr    | 30 +++++++++---------
 3 files changed, 48 insertions(+), 48 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/collapsible_match.rs b/clippy_lints/src/collapsible_match.rs
index 67282cb7900..3c45525684b 100644
--- a/clippy_lints/src/collapsible_match.rs
+++ b/clippy_lints/src/collapsible_match.rs
@@ -96,12 +96,12 @@ fn check_arm<'tcx>(arm: &Arm<'tcx>, wild_outer_arm: &Arm<'tcx>, cx: &LateContext
                 cx,
                 COLLAPSIBLE_MATCH,
                 expr.span,
-                "Unnecessary nested match",
+                "unnecessary nested match",
                 |diag| {
                     let mut help_span = MultiSpan::from_spans(vec![binding_span, non_wild_inner_arm.pat.span]);
-                    help_span.push_span_label(binding_span, "Replace this binding".into());
+                    help_span.push_span_label(binding_span, "replace this binding".into());
                     help_span.push_span_label(non_wild_inner_arm.pat.span, "with this pattern".into());
-                    diag.span_help(help_span, "The outer pattern can be modified to include the inner pattern.");
+                    diag.span_help(help_span, "the outer pattern can be modified to include the inner pattern");
                 },
             );
         }
diff --git a/tests/ui/collapsible_match.stderr b/tests/ui/collapsible_match.stderr
index 63ac6a1613d..77978884900 100644
--- a/tests/ui/collapsible_match.stderr
+++ b/tests/ui/collapsible_match.stderr
@@ -1,4 +1,4 @@
-error: Unnecessary nested match
+error: unnecessary nested match
   --> $DIR/collapsible_match.rs:7:20
    |
 LL |           Ok(val) => match val {
@@ -9,15 +9,15 @@ LL | |         },
    | |_________^
    |
    = note: `-D clippy::collapsible-match` implied by `-D warnings`
-help: The outer pattern can be modified to include the inner pattern.
+help: the outer pattern can be modified to include the inner pattern
   --> $DIR/collapsible_match.rs:7:12
    |
 LL |         Ok(val) => match val {
-   |            ^^^ Replace this binding
+   |            ^^^ replace this binding
 LL |             Some(n) => foo(n),
    |             ^^^^^^^ with this pattern
 
-error: Unnecessary nested match
+error: unnecessary nested match
   --> $DIR/collapsible_match.rs:16:20
    |
 LL |           Ok(val) => match val {
@@ -27,15 +27,15 @@ LL | |             _ => return,
 LL | |         },
    | |_________^
    |
-help: The outer pattern can be modified to include the inner pattern.
+help: the outer pattern can be modified to include the inner pattern
   --> $DIR/collapsible_match.rs:16:12
    |
 LL |         Ok(val) => match val {
-   |            ^^^ Replace this binding
+   |            ^^^ replace this binding
 LL |             Some(n) => foo(n),
    |             ^^^^^^^ with this pattern
 
-error: Unnecessary nested match
+error: unnecessary nested match
   --> $DIR/collapsible_match.rs:25:9
    |
 LL | /         if let Some(n) = val {
@@ -43,15 +43,15 @@ LL | |             take(n);
 LL | |         }
    | |_________^
    |
-help: The outer pattern can be modified to include the inner pattern.
+help: the outer pattern can be modified to include the inner pattern
   --> $DIR/collapsible_match.rs:24:15
    |
 LL |     if let Ok(val) = res_opt {
-   |               ^^^ Replace this binding
+   |               ^^^ replace this binding
 LL |         if let Some(n) = val {
    |                ^^^^^^^ with this pattern
 
-error: Unnecessary nested match
+error: unnecessary nested match
   --> $DIR/collapsible_match.rs:32:9
    |
 LL | /         if let Some(n) = val {
@@ -61,15 +61,15 @@ LL | |             return;
 LL | |         }
    | |_________^
    |
-help: The outer pattern can be modified to include the inner pattern.
+help: the outer pattern can be modified to include the inner pattern
   --> $DIR/collapsible_match.rs:31:15
    |
 LL |     if let Ok(val) = res_opt {
-   |               ^^^ Replace this binding
+   |               ^^^ replace this binding
 LL |         if let Some(n) = val {
    |                ^^^^^^^ with this pattern
 
-error: Unnecessary nested match
+error: unnecessary nested match
   --> $DIR/collapsible_match.rs:43:9
    |
 LL | /         match val {
@@ -78,16 +78,16 @@ LL | |             _ => (),
 LL | |         }
    | |_________^
    |
-help: The outer pattern can be modified to include the inner pattern.
+help: the outer pattern can be modified to include the inner pattern
   --> $DIR/collapsible_match.rs:42:15
    |
 LL |     if let Ok(val) = res_opt {
-   |               ^^^ Replace this binding
+   |               ^^^ replace this binding
 LL |         match val {
 LL |             Some(n) => foo(n),
    |             ^^^^^^^ with this pattern
 
-error: Unnecessary nested match
+error: unnecessary nested match
   --> $DIR/collapsible_match.rs:52:13
    |
 LL | /             if let Some(n) = val {
@@ -95,15 +95,15 @@ LL | |                 take(n);
 LL | |             }
    | |_____________^
    |
-help: The outer pattern can be modified to include the inner pattern.
+help: the outer pattern can be modified to include the inner pattern
   --> $DIR/collapsible_match.rs:51:12
    |
 LL |         Ok(val) => {
-   |            ^^^ Replace this binding
+   |            ^^^ replace this binding
 LL |             if let Some(n) = val {
    |                    ^^^^^^^ with this pattern
 
-error: Unnecessary nested match
+error: unnecessary nested match
   --> $DIR/collapsible_match.rs:61:9
    |
 LL | /         match val {
@@ -112,16 +112,16 @@ LL | |             _ => return,
 LL | |         }
    | |_________^
    |
-help: The outer pattern can be modified to include the inner pattern.
+help: the outer pattern can be modified to include the inner pattern
   --> $DIR/collapsible_match.rs:60:15
    |
 LL |     if let Ok(val) = res_opt {
-   |               ^^^ Replace this binding
+   |               ^^^ replace this binding
 LL |         match val {
 LL |             Some(n) => foo(n),
    |             ^^^^^^^ with this pattern
 
-error: Unnecessary nested match
+error: unnecessary nested match
   --> $DIR/collapsible_match.rs:72:13
    |
 LL | /             if let Some(n) = val {
@@ -131,15 +131,15 @@ LL | |                 return;
 LL | |             }
    | |_____________^
    |
-help: The outer pattern can be modified to include the inner pattern.
+help: the outer pattern can be modified to include the inner pattern
   --> $DIR/collapsible_match.rs:71:12
    |
 LL |         Ok(val) => {
-   |            ^^^ Replace this binding
+   |            ^^^ replace this binding
 LL |             if let Some(n) = val {
    |                    ^^^^^^^ with this pattern
 
-error: Unnecessary nested match
+error: unnecessary nested match
   --> $DIR/collapsible_match.rs:83:20
    |
 LL |           Ok(val) => match val {
@@ -149,15 +149,15 @@ LL | |             None => return,
 LL | |         },
    | |_________^
    |
-help: The outer pattern can be modified to include the inner pattern.
+help: the outer pattern can be modified to include the inner pattern
   --> $DIR/collapsible_match.rs:83:12
    |
 LL |         Ok(val) => match val {
-   |            ^^^ Replace this binding
+   |            ^^^ replace this binding
 LL |             Some(n) => foo(n),
    |             ^^^^^^^ with this pattern
 
-error: Unnecessary nested match
+error: unnecessary nested match
   --> $DIR/collapsible_match.rs:92:22
    |
 LL |           Some(val) => match val {
@@ -167,11 +167,11 @@ LL | |             _ => return,
 LL | |         },
    | |_________^
    |
-help: The outer pattern can be modified to include the inner pattern.
+help: the outer pattern can be modified to include the inner pattern
   --> $DIR/collapsible_match.rs:92:14
    |
 LL |         Some(val) => match val {
-   |              ^^^ Replace this binding
+   |              ^^^ replace this binding
 LL |             Some(n) => foo(n),
    |             ^^^^^^^ with this pattern
 
diff --git a/tests/ui/collapsible_match2.stderr b/tests/ui/collapsible_match2.stderr
index b2eb457d173..c8a445ef369 100644
--- a/tests/ui/collapsible_match2.stderr
+++ b/tests/ui/collapsible_match2.stderr
@@ -1,4 +1,4 @@
-error: Unnecessary nested match
+error: unnecessary nested match
   --> $DIR/collapsible_match2.rs:8:34
    |
 LL |               Ok(val) if make() => match val {
@@ -9,15 +9,15 @@ LL | |             },
    | |_____________^
    |
    = note: `-D clippy::collapsible-match` implied by `-D warnings`
-help: The outer pattern can be modified to include the inner pattern.
+help: the outer pattern can be modified to include the inner pattern
   --> $DIR/collapsible_match2.rs:8:16
    |
 LL |             Ok(val) if make() => match val {
-   |                ^^^ Replace this binding
+   |                ^^^ replace this binding
 LL |                 Some(n) => foo(n),
    |                 ^^^^^^^ with this pattern
 
-error: Unnecessary nested match
+error: unnecessary nested match
   --> $DIR/collapsible_match2.rs:15:24
    |
 LL |               Ok(val) => match val {
@@ -27,15 +27,15 @@ LL | |                 _ => return,
 LL | |             },
    | |_____________^
    |
-help: The outer pattern can be modified to include the inner pattern.
+help: the outer pattern can be modified to include the inner pattern
   --> $DIR/collapsible_match2.rs:15:16
    |
 LL |             Ok(val) => match val {
-   |                ^^^ Replace this binding
+   |                ^^^ replace this binding
 LL |                 Some(n) => foo(n),
    |                 ^^^^^^^ with this pattern
 
-error: Unnecessary nested match
+error: unnecessary nested match
   --> $DIR/collapsible_match2.rs:29:29
    |
 LL |                       $pat => match $e {
@@ -48,16 +48,16 @@ LL | |                     },
 LL |           mac!(res_opt => Ok(val), val => Some(n), foo(n));
    |           ------------------------------------------------- in this macro invocation
    |
-help: The outer pattern can be modified to include the inner pattern.
+help: the outer pattern can be modified to include the inner pattern
   --> $DIR/collapsible_match2.rs:41:28
    |
 LL |         mac!(res_opt => Ok(val), val => Some(n), foo(n));
    |                            ^^^          ^^^^^^^ with this pattern
    |                            |
-   |                            Replace this binding
+   |                            replace this binding
    = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: Unnecessary nested match
+error: unnecessary nested match
   --> $DIR/collapsible_match2.rs:46:20
    |
 LL |           Some(s) => match *s {
@@ -67,15 +67,15 @@ LL | |             _ => (),
 LL | |         },
    | |_________^
    |
-help: The outer pattern can be modified to include the inner pattern.
+help: the outer pattern can be modified to include the inner pattern
   --> $DIR/collapsible_match2.rs:46:14
    |
 LL |         Some(s) => match *s {
-   |              ^ Replace this binding
+   |              ^ replace this binding
 LL |             [n] => foo(n),
    |             ^^^ with this pattern
 
-error: Unnecessary nested match
+error: unnecessary nested match
   --> $DIR/collapsible_match2.rs:55:24
    |
 LL |           Some(ref s) => match &*s {
@@ -85,11 +85,11 @@ LL | |             _ => (),
 LL | |         },
    | |_________^
    |
-help: The outer pattern can be modified to include the inner pattern.
+help: the outer pattern can be modified to include the inner pattern
   --> $DIR/collapsible_match2.rs:55:14
    |
 LL |         Some(ref s) => match &*s {
-   |              ^^^^^ Replace this binding
+   |              ^^^^^ replace this binding
 LL |             [n] => foo(n),
    |             ^^^ with this pattern
 
-- 
cgit 1.4.1-3-g733a5


From bf55aee7b142ad14d102de3260e314a84bf8c35c Mon Sep 17 00:00:00 2001
From: bool <booleancoercion@gmail.com>
Date: Fri, 19 Feb 2021 19:36:28 +0200
Subject: Updated from_str_radix_10 sugg to be slightly smarter and ran bless

---
 clippy_lints/src/from_str_radix_10.rs | 26 ++++++++++++++++++++++----
 tests/ui/from_str_radix_10.rs         |  3 +++
 tests/ui/from_str_radix_10.stderr     | 10 ++++++++--
 3 files changed, 33 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/from_str_radix_10.rs b/clippy_lints/src/from_str_radix_10.rs
index 993b85ed998..d0a170acb4f 100644
--- a/clippy_lints/src/from_str_radix_10.rs
+++ b/clippy_lints/src/from_str_radix_10.rs
@@ -1,9 +1,12 @@
 use if_chain::if_chain;
 use rustc_errors::Applicability;
-use rustc_hir::*;
+use rustc_hir::{def, Expr, ExprKind, PrimTy, QPath, TyKind};
 use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::Ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::symbol::sym;
 
+use crate::utils::is_type_diagnostic_item;
 use crate::utils::span_lint_and_sugg;
 use crate::utils::sugg::Sugg;
 
@@ -40,8 +43,7 @@ impl LateLintPass<'tcx> for FromStrRadix10 {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, exp: &Expr<'tcx>) {
         if_chain! {
             if let ExprKind::Call(maybe_path, arguments) = &exp.kind;
-            if let ExprKind::Path(qpath) = &maybe_path.kind;
-            if let QPath::TypeRelative(ty, pathseg) = &qpath;
+            if let ExprKind::Path(QPath::TypeRelative(ty, pathseg)) = &maybe_path.kind;
 
             // check if the first part of the path is some integer primitive
             if let TyKind::Path(ty_qpath) = &ty.kind;
@@ -59,9 +61,20 @@ impl LateLintPass<'tcx> for FromStrRadix10 {
             if let rustc_ast::ast::LitKind::Int(10, _) = lit.node;
 
             then {
+                let expr = if let ExprKind::AddrOf(_, _, expr) = &arguments[0].kind {
+                    let ty = cx.typeck_results().expr_ty(expr);
+                    if is_ty_stringish(cx, ty) {
+                        expr
+                    } else {
+                        &arguments[0]
+                    }
+                } else {
+                    &arguments[0]
+                };
+
                 let sugg = Sugg::hir_with_applicability(
                     cx,
-                    &arguments[0],
+                    expr,
                     "<string>",
                     &mut Applicability::MachineApplicable
                 ).maybe_par();
@@ -79,3 +92,8 @@ impl LateLintPass<'tcx> for FromStrRadix10 {
         }
     }
 }
+
+/// Checks if a Ty is `String` or `&str`
+fn is_ty_stringish(cx: &LateContext<'_>, ty: Ty<'_>) -> bool {
+    is_type_diagnostic_item(cx, ty, sym::string_type) || is_type_diagnostic_item(cx, ty, sym::str)
+}
diff --git a/tests/ui/from_str_radix_10.rs b/tests/ui/from_str_radix_10.rs
index 0a973128664..2f2ea04847a 100644
--- a/tests/ui/from_str_radix_10.rs
+++ b/tests/ui/from_str_radix_10.rs
@@ -35,6 +35,9 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     let string = "300";
     i32::from_str_radix(string, 10)?;
 
+    let stringier = "400".to_string();
+    i32::from_str_radix(&stringier, 10)?;
+
     // none of these should trigger the lint
     u16::from_str_radix("20", 3)?;
     i32::from_str_radix("45", 12)?;
diff --git a/tests/ui/from_str_radix_10.stderr b/tests/ui/from_str_radix_10.stderr
index d6669001915..471bf52a9a7 100644
--- a/tests/ui/from_str_radix_10.stderr
+++ b/tests/ui/from_str_radix_10.stderr
@@ -28,7 +28,7 @@ error: this call to `from_str_radix` can be replaced with a call to `str::parse`
   --> $DIR/from_str_radix_10.rs:32:5
    |
 LL |     u16::from_str_radix(&("10".to_owned() + "5"), 10)?;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `(&("10".to_owned() + "5")).parse::<u16>()`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `(("10".to_owned() + "5")).parse::<u16>()`
 
 error: this call to `from_str_radix` can be replaced with a call to `str::parse`
   --> $DIR/from_str_radix_10.rs:33:5
@@ -42,5 +42,11 @@ error: this call to `from_str_radix` can be replaced with a call to `str::parse`
 LL |     i32::from_str_radix(string, 10)?;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `string.parse::<i32>()`
 
-error: aborting due to 7 previous errors
+error: this call to `from_str_radix` can be replaced with a call to `str::parse`
+  --> $DIR/from_str_radix_10.rs:39:5
+   |
+LL |     i32::from_str_radix(&stringier, 10)?;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `stringier.parse::<i32>()`
+
+error: aborting due to 8 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From c4b8d87ab96cb6ef44685d928adeb9915b06f71f Mon Sep 17 00:00:00 2001
From: bool <booleancoercion@gmail.com>
Date: Fri, 19 Feb 2021 22:00:23 +0200
Subject: Fixed the known problems section

---
 clippy_lints/src/from_str_radix_10.rs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/from_str_radix_10.rs b/clippy_lints/src/from_str_radix_10.rs
index d0a170acb4f..0933f983014 100644
--- a/clippy_lints/src/from_str_radix_10.rs
+++ b/clippy_lints/src/from_str_radix_10.rs
@@ -19,7 +19,9 @@ declare_clippy_lint! {
     /// (and in most cases, the turbofish can be removed), which reduces code length
     /// and complexity.
     ///
-    /// **Known problems:** None.
+    /// **Known problems:**
+    /// This lint may suggest using (&<expression>).parse() instead of <expression>.parse() directly
+    /// in some cases, which is correct but adds unnecessary complexity to the code.
     ///
     /// **Example:**
     ///
-- 
cgit 1.4.1-3-g733a5


From 5af6f96c8fe029ae4f9696084f6a22f5d750f3a9 Mon Sep 17 00:00:00 2001
From: ThibsG <thibsg@pm.me>
Date: Sat, 20 Feb 2021 19:48:04 +0100
Subject: Fix camel case postfix for `enum_variant_names` lint

---
 clippy_lints/src/utils/camel_case.rs |  6 ++++++
 tests/ui/enum_variants.rs            | 13 +++++++++++++
 tests/ui/enum_variants.stderr        | 26 +++++++++++++++++++++++++-
 3 files changed, 44 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/camel_case.rs b/clippy_lints/src/utils/camel_case.rs
index 4192a26d3c8..ba1c01ebc9f 100644
--- a/clippy_lints/src/utils/camel_case.rs
+++ b/clippy_lints/src/utils/camel_case.rs
@@ -55,6 +55,8 @@ pub fn from(s: &str) -> usize {
             }
         } else if c.is_lowercase() {
             down = true;
+        } else if c.is_uppercase() {
+            last_i = i;
         } else {
             return last_i;
         }
@@ -70,12 +72,16 @@ mod test {
     fn from_full() {
         assert_eq!(from("AbcDef"), 0);
         assert_eq!(from("Abc"), 0);
+        assert_eq!(from("ABcd"), 0);
+        assert_eq!(from("ABcdEf"), 0);
+        assert_eq!(from("AabABcd"), 0);
     }
 
     #[test]
     fn from_partial() {
         assert_eq!(from("abcDef"), 3);
         assert_eq!(from("aDbc"), 1);
+        assert_eq!(from("aabABcd"), 3);
     }
 
     #[test]
diff --git a/tests/ui/enum_variants.rs b/tests/ui/enum_variants.rs
index 89d99dcf0c8..4fefc0b43f1 100644
--- a/tests/ui/enum_variants.rs
+++ b/tests/ui/enum_variants.rs
@@ -133,4 +133,17 @@ pub enum NetworkLayer {
     Layer3,
 }
 
+// should lint suggesting `IData`, not only `Data` (see #4639)
+enum IDataRequest {
+    PutIData(String),
+    GetIData(String),
+    DeleteUnpubIData(String),
+}
+
+enum HIDataRequest {
+    PutHIData(String),
+    GetHIData(String),
+    DeleteUnpubHIData(String),
+}
+
 fn main() {}
diff --git a/tests/ui/enum_variants.stderr b/tests/ui/enum_variants.stderr
index b1d481190ff..ab7fff4507a 100644
--- a/tests/ui/enum_variants.stderr
+++ b/tests/ui/enum_variants.stderr
@@ -97,5 +97,29 @@ LL | | }
    = note: `-D clippy::pub-enum-variant-names` implied by `-D warnings`
    = help: remove the prefixes and use full paths to the variants instead of glob imports
 
-error: aborting due to 10 previous errors
+error: all variants have the same postfix: `IData`
+  --> $DIR/enum_variants.rs:137:1
+   |
+LL | / enum IDataRequest {
+LL | |     PutIData(String),
+LL | |     GetIData(String),
+LL | |     DeleteUnpubIData(String),
+LL | | }
+   | |_^
+   |
+   = help: remove the postfixes and use full paths to the variants instead of glob imports
+
+error: all variants have the same postfix: `HIData`
+  --> $DIR/enum_variants.rs:143:1
+   |
+LL | / enum HIDataRequest {
+LL | |     PutHIData(String),
+LL | |     GetHIData(String),
+LL | |     DeleteUnpubHIData(String),
+LL | | }
+   | |_^
+   |
+   = help: remove the postfixes and use full paths to the variants instead of glob imports
+
+error: aborting due to 12 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From d23038944a0ab7aaf8566196f9680b918f7ec155 Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Sat, 20 Feb 2021 22:52:56 +0900
Subject: New lint: inconsistent_struct_constructor

---
 CHANGELOG.md                                       |   1 +
 .../src/inconsistent_struct_constructor.rs         | 118 +++++++++++++++++++++
 clippy_lints/src/lib.rs                            |   5 +
 tests/ui/inconsistent_struct_constructor.fixed     |  61 +++++++++++
 tests/ui/inconsistent_struct_constructor.rs        |  65 ++++++++++++
 tests/ui/inconsistent_struct_constructor.stderr    |  20 ++++
 6 files changed, 270 insertions(+)
 create mode 100644 clippy_lints/src/inconsistent_struct_constructor.rs
 create mode 100644 tests/ui/inconsistent_struct_constructor.fixed
 create mode 100644 tests/ui/inconsistent_struct_constructor.rs
 create mode 100644 tests/ui/inconsistent_struct_constructor.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 2ec8b3d98f8..c51557943e5 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2109,6 +2109,7 @@ Released 2018-09-13
 [`implicit_saturating_sub`]: https://rust-lang.github.io/rust-clippy/master/index.html#implicit_saturating_sub
 [`imprecise_flops`]: https://rust-lang.github.io/rust-clippy/master/index.html#imprecise_flops
 [`inconsistent_digit_grouping`]: https://rust-lang.github.io/rust-clippy/master/index.html#inconsistent_digit_grouping
+[`inconsistent_struct_constructor`]: https://rust-lang.github.io/rust-clippy/master/index.html#inconsistent_struct_constructor
 [`indexing_slicing`]: https://rust-lang.github.io/rust-clippy/master/index.html#indexing_slicing
 [`ineffective_bit_mask`]: https://rust-lang.github.io/rust-clippy/master/index.html#ineffective_bit_mask
 [`inefficient_to_string`]: https://rust-lang.github.io/rust-clippy/master/index.html#inefficient_to_string
diff --git a/clippy_lints/src/inconsistent_struct_constructor.rs b/clippy_lints/src/inconsistent_struct_constructor.rs
new file mode 100644
index 00000000000..24dbfbbae2f
--- /dev/null
+++ b/clippy_lints/src/inconsistent_struct_constructor.rs
@@ -0,0 +1,118 @@
+use rustc_data_structures::fx::FxHashMap;
+use rustc_errors::Applicability;
+use rustc_hir::{self as hir, ExprKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::symbol::Symbol;
+
+use if_chain::if_chain;
+
+use crate::utils::{snippet, span_lint_and_sugg};
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for struct constructors where the order of the field init
+    /// shorthand in the constructor is inconsistent with the order in the struct definition.
+    ///
+    /// **Why is this bad?** It decreases readability and consistency.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// struct Foo {
+    ///     x: i32,
+    ///     y: i32,
+    /// }
+    /// let x = 1;
+    /// let y = 2;
+    /// Foo { y, x };
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust
+    /// # struct Foo {
+    /// #     x: i32,
+    /// #     y: i32,
+    /// # }
+    /// # let x = 1;
+    /// # let y = 2;
+    /// Foo { x, y };
+    /// ```
+    pub INCONSISTENT_STRUCT_CONSTRUCTOR,
+    style,
+    "the order of the field init shorthand is inconsistent with the order in the struct definition"
+}
+
+declare_lint_pass!(InconsistentStructConstructor => [INCONSISTENT_STRUCT_CONSTRUCTOR]);
+
+impl LateLintPass<'_> for InconsistentStructConstructor {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
+        if_chain! {
+            if let ExprKind::Struct(qpath, fields, base) = expr.kind;
+            if let Some(def_id)  = cx.qpath_res(qpath, expr.hir_id).opt_def_id();
+            let ty = cx.tcx.type_of(def_id);
+            if let Some(adt_def) = ty.ty_adt_def();
+            if adt_def.is_struct();
+            if let Some(variant) = adt_def.variants.iter().next();
+            if fields.iter().all(|f| f.is_shorthand);
+            then {
+                let mut def_order_map = FxHashMap::default();
+                for (idx, field) in variant.fields.iter().enumerate() {
+                    def_order_map.insert(field.ident.name, idx);
+                }
+
+                if is_consistent_order(fields, &def_order_map) {
+                    return;
+                }
+
+                let mut ordered_fields: Vec<_> = fields.iter().map(|f| f.ident.name).collect();
+                ordered_fields.sort_unstable_by_key(|id| def_order_map[id]);
+
+                let mut fields_snippet = String::new();
+                let (last_ident, idents) = ordered_fields.split_last().unwrap();
+                for ident in idents {
+                    fields_snippet.push_str(&format!("{}, ", ident));
+                }
+                fields_snippet.push_str(&format!("{}", last_ident));
+
+                let base_snippet = if let Some(base) = base {
+                        format!(", ..{}", snippet(cx, base.span, ".."))
+                    } else {
+                        "".to_string()
+                    };
+
+                let sugg = format!("{} {{ {}{} }}",
+                    snippet(cx, qpath.span(), ".."),
+                    fields_snippet,
+                    base_snippet,
+                    );
+
+                span_lint_and_sugg(
+                    cx,
+                    INCONSISTENT_STRUCT_CONSTRUCTOR,
+                    expr.span,
+                    "inconsistent struct constructor",
+                    "try",
+                    sugg,
+                    Applicability::MachineApplicable,
+                )
+            }
+        }
+    }
+}
+
+// Check whether the order of the fields in the constructor is consistent with the order in the
+// definition.
+fn is_consistent_order<'tcx>(fields: &'tcx [hir::Field<'tcx>], def_order_map: &FxHashMap<Symbol, usize>) -> bool {
+    let mut cur_idx = usize::MIN;
+    for f in fields {
+        let next_idx = def_order_map[&f.ident.name];
+        if cur_idx > next_idx {
+            return false;
+        }
+        cur_idx = next_idx;
+    }
+
+    true
+}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 67e490584e8..c846dc187a4 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -221,6 +221,7 @@ mod if_let_some_result;
 mod if_not_else;
 mod implicit_return;
 mod implicit_saturating_sub;
+mod inconsistent_struct_constructor;
 mod indexing_slicing;
 mod infinite_iter;
 mod inherent_impl;
@@ -656,6 +657,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &if_not_else::IF_NOT_ELSE,
         &implicit_return::IMPLICIT_RETURN,
         &implicit_saturating_sub::IMPLICIT_SATURATING_SUB,
+        &inconsistent_struct_constructor::INCONSISTENT_STRUCT_CONSTRUCTOR,
         &indexing_slicing::INDEXING_SLICING,
         &indexing_slicing::OUT_OF_BOUNDS_INDEXING,
         &infinite_iter::INFINITE_ITER,
@@ -1036,6 +1038,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box implicit_return::ImplicitReturn);
     store.register_late_pass(|| box implicit_saturating_sub::ImplicitSaturatingSub);
     store.register_late_pass(|| box default_numeric_fallback::DefaultNumericFallback);
+    store.register_late_pass(|| box inconsistent_struct_constructor::InconsistentStructConstructor);
 
     let msrv = conf.msrv.as_ref().and_then(|s| {
         parse_msrv(s, None, None).or_else(|| {
@@ -1485,6 +1488,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&identity_op::IDENTITY_OP),
         LintId::of(&if_let_mutex::IF_LET_MUTEX),
         LintId::of(&if_let_some_result::IF_LET_SOME_RESULT),
+        LintId::of(&inconsistent_struct_constructor::INCONSISTENT_STRUCT_CONSTRUCTOR),
         LintId::of(&indexing_slicing::OUT_OF_BOUNDS_INDEXING),
         LintId::of(&infinite_iter::INFINITE_ITER),
         LintId::of(&inherent_to_string::INHERENT_TO_STRING),
@@ -1737,6 +1741,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&functions::MUST_USE_UNIT),
         LintId::of(&functions::RESULT_UNIT_ERR),
         LintId::of(&if_let_some_result::IF_LET_SOME_RESULT),
+        LintId::of(&inconsistent_struct_constructor::INCONSISTENT_STRUCT_CONSTRUCTOR),
         LintId::of(&inherent_to_string::INHERENT_TO_STRING),
         LintId::of(&len_zero::COMPARISON_TO_EMPTY),
         LintId::of(&len_zero::LEN_WITHOUT_IS_EMPTY),
diff --git a/tests/ui/inconsistent_struct_constructor.fixed b/tests/ui/inconsistent_struct_constructor.fixed
new file mode 100644
index 00000000000..8d9c3110035
--- /dev/null
+++ b/tests/ui/inconsistent_struct_constructor.fixed
@@ -0,0 +1,61 @@
+// run-rustfix
+// edition:2018
+#![warn(clippy::inconsistent_struct_constructor)]
+#![allow(clippy::redundant_field_names)]
+#![allow(clippy::unnecessary_operation)]
+#![allow(clippy::no_effect)]
+#![allow(dead_code)]
+
+#[derive(Default)]
+struct Foo {
+    x: i32,
+    y: i32,
+    z: i32,
+}
+
+mod without_base {
+    use super::Foo;
+
+    fn test() {
+        let x = 1;
+        let y = 1;
+        let z = 1;
+
+        // Should lint.
+        Foo { x, y, z };
+
+        // Shoule NOT lint because the order is the same as in the definition.
+        Foo { x, y, z };
+
+        // Should NOT lint because z is not a shorthand init.
+        Foo { y, x, z: z };
+    }
+}
+
+mod with_base {
+    use super::Foo;
+
+    fn test() {
+        let x = 1;
+        let z = 1;
+
+        // Should lint.
+        Foo { x, z, ..Default::default() };
+
+        // Should NOT lint because the order is consistent with the definition.
+        Foo {
+            x,
+            z,
+            ..Default::default()
+        };
+
+        // Should NOT lint because z is not a shorthand init.
+        Foo {
+            z: z,
+            x,
+            ..Default::default()
+        };
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/inconsistent_struct_constructor.rs b/tests/ui/inconsistent_struct_constructor.rs
new file mode 100644
index 00000000000..63fac910501
--- /dev/null
+++ b/tests/ui/inconsistent_struct_constructor.rs
@@ -0,0 +1,65 @@
+// run-rustfix
+// edition:2018
+#![warn(clippy::inconsistent_struct_constructor)]
+#![allow(clippy::redundant_field_names)]
+#![allow(clippy::unnecessary_operation)]
+#![allow(clippy::no_effect)]
+#![allow(dead_code)]
+
+#[derive(Default)]
+struct Foo {
+    x: i32,
+    y: i32,
+    z: i32,
+}
+
+mod without_base {
+    use super::Foo;
+
+    fn test() {
+        let x = 1;
+        let y = 1;
+        let z = 1;
+
+        // Should lint.
+        Foo { y, x, z };
+
+        // Shoule NOT lint because the order is the same as in the definition.
+        Foo { x, y, z };
+
+        // Should NOT lint because z is not a shorthand init.
+        Foo { y, x, z: z };
+    }
+}
+
+mod with_base {
+    use super::Foo;
+
+    fn test() {
+        let x = 1;
+        let z = 1;
+
+        // Should lint.
+        Foo {
+            z,
+            x,
+            ..Default::default()
+        };
+
+        // Should NOT lint because the order is consistent with the definition.
+        Foo {
+            x,
+            z,
+            ..Default::default()
+        };
+
+        // Should NOT lint because z is not a shorthand init.
+        Foo {
+            z: z,
+            x,
+            ..Default::default()
+        };
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/inconsistent_struct_constructor.stderr b/tests/ui/inconsistent_struct_constructor.stderr
new file mode 100644
index 00000000000..d7abe44f254
--- /dev/null
+++ b/tests/ui/inconsistent_struct_constructor.stderr
@@ -0,0 +1,20 @@
+error: inconsistent struct constructor
+  --> $DIR/inconsistent_struct_constructor.rs:25:9
+   |
+LL |         Foo { y, x, z };
+   |         ^^^^^^^^^^^^^^^ help: try: `Foo { x, y, z }`
+   |
+   = note: `-D clippy::inconsistent-struct-constructor` implied by `-D warnings`
+
+error: inconsistent struct constructor
+  --> $DIR/inconsistent_struct_constructor.rs:43:9
+   |
+LL | /         Foo {
+LL | |             z,
+LL | |             x,
+LL | |             ..Default::default()
+LL | |         };
+   | |_________^ help: try: `Foo { x, z, ..Default::default() }`
+
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From d646aa2ae7a27495dd87344ffdad4b66c1bd4425 Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Sat, 20 Feb 2021 23:02:18 +0900
Subject: Fix unnecessary_sort_by.rs that fails the dogfood test

---
 clippy_lints/src/unnecessary_sort_by.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unnecessary_sort_by.rs b/clippy_lints/src/unnecessary_sort_by.rs
index 9b45d38afd4..00a707107bc 100644
--- a/clippy_lints/src/unnecessary_sort_by.rs
+++ b/clippy_lints/src/unnecessary_sort_by.rs
@@ -212,10 +212,10 @@ fn detect_lint(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<LintTrigger> {
             if !expr_borrows(cx, left_expr) {
                 return Some(LintTrigger::SortByKey(SortByKeyDetection {
                     vec_name,
-                    unstable,
                     closure_arg,
                     closure_body,
-                    reverse
+                    reverse,
+                    unstable,
                 }));
             }
         }
-- 
cgit 1.4.1-3-g733a5


From 19a377510c3de9a7404f690d52a5de761ce2aafd Mon Sep 17 00:00:00 2001
From: Morten Lohne <lohnemorten@gmail.com>
Date: Sat, 20 Feb 2021 23:47:49 +0100
Subject: Fix FP in inherent_to_string when the function has generic parameters

---
 clippy_lints/src/inherent_to_string.rs |  1 +
 tests/ui/inherent_to_string.rs         | 11 +++++++++++
 tests/ui/inherent_to_string.stderr     |  4 ++--
 3 files changed, 14 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/inherent_to_string.rs b/clippy_lints/src/inherent_to_string.rs
index b723d06a688..0b23cdaa9f0 100644
--- a/clippy_lints/src/inherent_to_string.rs
+++ b/clippy_lints/src/inherent_to_string.rs
@@ -106,6 +106,7 @@ impl<'tcx> LateLintPass<'tcx> for InherentToString {
             let decl = &signature.decl;
             if decl.implicit_self.has_implicit_self();
             if decl.inputs.len() == 1;
+            if impl_item.generics.params.is_empty();
 
             // Check if return type is String
             if is_type_diagnostic_item(cx, return_ty(cx, impl_item.hir_id), sym::string_type);
diff --git a/tests/ui/inherent_to_string.rs b/tests/ui/inherent_to_string.rs
index e6cf337d1bb..6e65fdbd04e 100644
--- a/tests/ui/inherent_to_string.rs
+++ b/tests/ui/inherent_to_string.rs
@@ -14,6 +14,7 @@ struct C;
 struct D;
 struct E;
 struct F;
+struct G;
 
 impl A {
     // Should be detected; emit warning
@@ -73,6 +74,13 @@ impl F {
     }
 }
 
+impl G {
+    // Should not be detected, as it does not match the function signature
+    fn to_string<const _N: usize>(&self) -> String {
+        "G.to_string()".to_string()
+    }
+}
+
 fn main() {
     let a = A;
     a.to_string();
@@ -93,4 +101,7 @@ fn main() {
 
     let f = F;
     f.to_string(1);
+
+    let g = G;
+    g.to_string::<1>();
 }
diff --git a/tests/ui/inherent_to_string.stderr b/tests/ui/inherent_to_string.stderr
index 4f331f5bec9..f5fcc193b4d 100644
--- a/tests/ui/inherent_to_string.stderr
+++ b/tests/ui/inherent_to_string.stderr
@@ -1,5 +1,5 @@
 error: implementation of inherent method `to_string(&self) -> String` for type `A`
-  --> $DIR/inherent_to_string.rs:20:5
+  --> $DIR/inherent_to_string.rs:21:5
    |
 LL | /     fn to_string(&self) -> String {
 LL | |         "A.to_string()".to_string()
@@ -10,7 +10,7 @@ LL | |     }
    = help: implement trait `Display` for type `A` instead
 
 error: type `C` implements inherent method `to_string(&self) -> String` which shadows the implementation of `Display`
-  --> $DIR/inherent_to_string.rs:44:5
+  --> $DIR/inherent_to_string.rs:45:5
    |
 LL | /     fn to_string(&self) -> String {
 LL | |         "C.to_string()".to_string()
-- 
cgit 1.4.1-3-g733a5


From bfdf0fa03f14be82d668036df221326374f7a321 Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Mon, 22 Feb 2021 11:45:25 +0900
Subject: Describe the order of fields in struct ctor doesn't affect the
 resulted instance

---
 .../src/inconsistent_struct_constructor.rs         | 22 +++++++++++++++++++---
 1 file changed, 19 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/inconsistent_struct_constructor.rs b/clippy_lints/src/inconsistent_struct_constructor.rs
index 24dbfbbae2f..c5afdf530eb 100644
--- a/clippy_lints/src/inconsistent_struct_constructor.rs
+++ b/clippy_lints/src/inconsistent_struct_constructor.rs
@@ -13,7 +13,23 @@ declare_clippy_lint! {
     /// **What it does:** Checks for struct constructors where the order of the field init
     /// shorthand in the constructor is inconsistent with the order in the struct definition.
     ///
-    /// **Why is this bad?** It decreases readability and consistency.
+    /// **Why is this bad?** Since the order of fields in a constructor doesn't affect the
+    /// resulted instance as the below example indicates,
+    ///
+    /// ```rust
+    /// #[derive(Debug, PartialEq, Eq)]
+    /// struct Foo {
+    ///     x: i32,
+    ///     y: i32,
+    /// }
+    /// let x = 1;
+    /// let y = 2;
+    ///
+    /// // This assertion never fails.
+    /// assert_eq!(Foo { x, y }, Foo { y, x });
+    /// ```
+    ///
+    /// inconsistent order means nothing and just decreases readability and consistency.
     ///
     /// **Known problems:** None.
     ///
@@ -74,12 +90,12 @@ impl LateLintPass<'_> for InconsistentStructConstructor {
                 for ident in idents {
                     fields_snippet.push_str(&format!("{}, ", ident));
                 }
-                fields_snippet.push_str(&format!("{}", last_ident));
+                fields_snippet.push_str(&last_ident.to_string());
 
                 let base_snippet = if let Some(base) = base {
                         format!(", ..{}", snippet(cx, base.span, ".."))
                     } else {
-                        "".to_string()
+                        String::new()
                     };
 
                 let sugg = format!("{} {{ {}{} }}",
-- 
cgit 1.4.1-3-g733a5


From efe33f9fe4bf6b644f26f51500d557614a5f2c93 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sun, 10 Jan 2021 09:46:03 -0500
Subject: Add: option_manual_map lint

---
 CHANGELOG.md                      |   1 +
 clippy_lints/src/lib.rs           |   5 +
 clippy_lints/src/manual_map.rs    | 262 ++++++++++++++++++++++++++++++++++++++
 clippy_lints/src/utils/mod.rs     |  27 +++-
 tests/ui/manual_map_option.fixed  |  61 +++++++++
 tests/ui/manual_map_option.rs     | 113 ++++++++++++++++
 tests/ui/manual_map_option.stderr | 158 +++++++++++++++++++++++
 7 files changed, 626 insertions(+), 1 deletion(-)
 create mode 100644 clippy_lints/src/manual_map.rs
 create mode 100644 tests/ui/manual_map_option.fixed
 create mode 100644 tests/ui/manual_map_option.rs
 create mode 100644 tests/ui/manual_map_option.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 2ec8b3d98f8..edc5cea1dd6 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2161,6 +2161,7 @@ Released 2018-09-13
 [`manual_filter_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_filter_map
 [`manual_find_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_find_map
 [`manual_flatten`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_flatten
+[`manual_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_map
 [`manual_memcpy`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_memcpy
 [`manual_non_exhaustive`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_non_exhaustive
 [`manual_ok_or`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_ok_or
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 2e0bc4de801..b151c178afa 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -241,6 +241,7 @@ mod loops;
 mod macro_use;
 mod main_recursion;
 mod manual_async_fn;
+mod manual_map;
 mod manual_non_exhaustive;
 mod manual_ok_or;
 mod manual_strip;
@@ -706,6 +707,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &macro_use::MACRO_USE_IMPORTS,
         &main_recursion::MAIN_RECURSION,
         &manual_async_fn::MANUAL_ASYNC_FN,
+        &manual_map::MANUAL_MAP,
         &manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE,
         &manual_ok_or::MANUAL_OK_OR,
         &manual_strip::MANUAL_STRIP,
@@ -1262,6 +1264,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box case_sensitive_file_extension_comparisons::CaseSensitiveFileExtensionComparisons);
     store.register_late_pass(|| box redundant_slicing::RedundantSlicing);
     store.register_late_pass(|| box from_str_radix_10::FromStrRadix10);
+    store.register_late_pass(|| box manual_map::ManualMap);
 
     store.register_group(true, "clippy::restriction", Some("clippy_restriction"), vec![
         LintId::of(&arithmetic::FLOAT_ARITHMETIC),
@@ -1521,6 +1524,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&loops::WHILE_LET_ON_ITERATOR),
         LintId::of(&main_recursion::MAIN_RECURSION),
         LintId::of(&manual_async_fn::MANUAL_ASYNC_FN),
+        LintId::of(&manual_map::MANUAL_MAP),
         LintId::of(&manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE),
         LintId::of(&manual_strip::MANUAL_STRIP),
         LintId::of(&manual_unwrap_or::MANUAL_UNWRAP_OR),
@@ -1750,6 +1754,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&loops::WHILE_LET_ON_ITERATOR),
         LintId::of(&main_recursion::MAIN_RECURSION),
         LintId::of(&manual_async_fn::MANUAL_ASYNC_FN),
+        LintId::of(&manual_map::MANUAL_MAP),
         LintId::of(&manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE),
         LintId::of(&map_clone::MAP_CLONE),
         LintId::of(&matches::INFALLIBLE_DESTRUCTURING_MATCH),
diff --git a/clippy_lints/src/manual_map.rs b/clippy_lints/src/manual_map.rs
new file mode 100644
index 00000000000..e399c8fda55
--- /dev/null
+++ b/clippy_lints/src/manual_map.rs
@@ -0,0 +1,262 @@
+use crate::utils::{
+    is_type_diagnostic_item, match_def_path, paths, peel_hir_expr_refs, peel_mid_ty_refs_is_mutable,
+    snippet_with_applicability, span_lint_and_sugg,
+};
+use rustc_ast::util::parser::PREC_POSTFIX;
+use rustc_errors::Applicability;
+use rustc_hir::{Arm, BindingAnnotation, Block, Expr, ExprKind, Mutability, Pat, PatKind, Path, QPath};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_middle::lint::in_external_macro;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::symbol::{sym, Ident};
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for usages of `match` which could be implemented using `map`
+    ///
+    /// **Why is this bad?** Using the `map` method is clearer and more concise.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// match Some(0) {
+    ///     Some(x) => Some(x + 1),
+    ///     None => None,
+    /// };
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// Some(0).map(|x| x + 1);
+    /// ```
+    pub MANUAL_MAP,
+    style,
+    "reimplementation of `map`"
+}
+
+declare_lint_pass!(ManualMap => [MANUAL_MAP]);
+
+impl LateLintPass<'_> for ManualMap {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        if in_external_macro(cx.sess(), expr.span) {
+            return;
+        }
+
+        if let ExprKind::Match(scrutinee, [arm1 @ Arm { guard: None, .. }, arm2 @ Arm { guard: None, .. }], _) =
+            expr.kind
+        {
+            let (scrutinee_ty, ty_ref_count, ty_mutability) =
+                peel_mid_ty_refs_is_mutable(cx.typeck_results().expr_ty(scrutinee));
+            if !is_type_diagnostic_item(cx, scrutinee_ty, sym::option_type)
+                || !is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(expr), sym::option_type)
+            {
+                return;
+            }
+
+            let (some_expr, some_pat, pat_ref_count, is_wild_none) =
+                match (try_parse_pattern(cx, arm1.pat), try_parse_pattern(cx, arm2.pat)) {
+                    (Some(OptionPat::Wild), Some(OptionPat::Some { pattern, ref_count }))
+                        if is_none_expr(cx, arm1.body) =>
+                    {
+                        (arm2.body, pattern, ref_count, true)
+                    },
+                    (Some(OptionPat::None), Some(OptionPat::Some { pattern, ref_count }))
+                        if is_none_expr(cx, arm1.body) =>
+                    {
+                        (arm2.body, pattern, ref_count, false)
+                    },
+                    (Some(OptionPat::Some { pattern, ref_count }), Some(OptionPat::Wild))
+                        if is_none_expr(cx, arm2.body) =>
+                    {
+                        (arm1.body, pattern, ref_count, true)
+                    },
+                    (Some(OptionPat::Some { pattern, ref_count }), Some(OptionPat::None))
+                        if is_none_expr(cx, arm2.body) =>
+                    {
+                        (arm1.body, pattern, ref_count, false)
+                    },
+                    _ => return,
+                };
+
+            // Top level or patterns aren't allowed in closures.
+            if matches!(some_pat.kind, PatKind::Or(_)) {
+                return;
+            }
+
+            let some_expr = match get_some_expr(cx, some_expr) {
+                Some(expr) => expr,
+                None => return,
+            };
+
+            // Determine which binding mode to use.
+            let explicit_ref = some_pat.contains_explicit_ref_binding();
+            let binding_mutability = explicit_ref.or(if ty_ref_count != pat_ref_count {
+                Some(ty_mutability)
+            } else {
+                None
+            });
+            let as_ref_str = match binding_mutability {
+                Some(Mutability::Mut) => ".as_mut()",
+                Some(Mutability::Not) => ".as_ref()",
+                None => "",
+            };
+
+            let mut app = Applicability::MachineApplicable;
+
+            // Remove address-of expressions from the scrutinee. `as_ref` will be called,
+            // the type is copyable, or the option is being passed by value.
+            let scrutinee = peel_hir_expr_refs(scrutinee).0;
+            let scrutinee_str = snippet_with_applicability(cx, scrutinee.span, "_", &mut app);
+            let scrutinee_str = if expr.precedence().order() < PREC_POSTFIX {
+                // Parens are needed to chain method calls.
+                format!("({})", scrutinee_str)
+            } else {
+                scrutinee_str.into()
+            };
+
+            let body_str = if let PatKind::Binding(annotation, _, some_binding, None) = some_pat.kind {
+                if let Some(func) = can_pass_as_func(cx, some_binding, some_expr) {
+                    snippet_with_applicability(cx, func.span, "..", &mut app).into_owned()
+                } else {
+                    // `ref` and `ref mut` annotations were handled earlier.
+                    let annotation = if matches!(annotation, BindingAnnotation::Mutable) {
+                        "mut "
+                    } else {
+                        ""
+                    };
+                    format!(
+                        "|{}{}| {}",
+                        annotation,
+                        some_binding,
+                        snippet_with_applicability(cx, some_expr.span, "..", &mut app)
+                    )
+                }
+            } else if !is_wild_none && explicit_ref.is_none() {
+                // TODO: handle explicit reference annotations.
+                format!(
+                    "|{}| {}",
+                    snippet_with_applicability(cx, some_pat.span, "..", &mut app),
+                    snippet_with_applicability(cx, some_expr.span, "..", &mut app)
+                )
+            } else {
+                // Refutable bindings and mixed reference annotations can't be handled by `map`.
+                return;
+            };
+
+            span_lint_and_sugg(
+                cx,
+                MANUAL_MAP,
+                expr.span,
+                "manual implementation of `Option::map`",
+                "try this",
+                format!("{}{}.map({})", scrutinee_str, as_ref_str, body_str),
+                app,
+            );
+        }
+    }
+}
+
+// Checks whether the expression could be passed as a function, or whether a closure is needed.
+// Returns the function to be passed to `map` if it exists.
+fn can_pass_as_func(cx: &LateContext<'tcx>, binding: Ident, expr: &'tcx Expr<'_>) -> Option<&'tcx Expr<'tcx>> {
+    match expr.kind {
+        ExprKind::Call(func, [arg])
+            if matches!(arg.kind,
+                ExprKind::Path(QPath::Resolved(None, Path { segments: [path], ..}))
+                if path.ident == binding
+            ) && cx.typeck_results().expr_adjustments(arg).is_empty() =>
+        {
+            Some(func)
+        },
+        _ => None,
+    }
+}
+
+enum OptionPat<'a> {
+    Wild,
+    None,
+    Some {
+        // The pattern contained in the `Some` tuple.
+        pattern: &'a Pat<'a>,
+        // The number of references before the `Some` tuple.
+        // e.g. `&&Some(_)` has a ref count of 2.
+        ref_count: usize,
+    },
+}
+
+// Try to parse into a recognized `Option` pattern.
+// i.e. `_`, `None`, `Some(..)`, or a reference to any of those.
+fn try_parse_pattern(cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>) -> Option<OptionPat<'tcx>> {
+    fn f(cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>, ref_count: usize) -> Option<OptionPat<'tcx>> {
+        match pat.kind {
+            PatKind::Wild => Some(OptionPat::Wild),
+            PatKind::Ref(pat, _) => f(cx, pat, ref_count + 1),
+            PatKind::Path(QPath::Resolved(None, path))
+                if path
+                    .res
+                    .opt_def_id()
+                    .map_or(false, |id| match_def_path(cx, id, &paths::OPTION_NONE)) =>
+            {
+                Some(OptionPat::None)
+            },
+            PatKind::TupleStruct(QPath::Resolved(None, path), [pattern], _)
+                if path
+                    .res
+                    .opt_def_id()
+                    .map_or(false, |id| match_def_path(cx, id, &paths::OPTION_SOME)) =>
+            {
+                Some(OptionPat::Some { pattern, ref_count })
+            },
+            _ => None,
+        }
+    }
+    f(cx, pat, 0)
+}
+
+// Checks for an expression wrapped by the `Some` constructor. Returns the contained expression.
+fn get_some_expr(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<&'tcx Expr<'tcx>> {
+    // TODO: Allow more complex expressions.
+    match expr.kind {
+        ExprKind::Call(
+            Expr {
+                kind: ExprKind::Path(QPath::Resolved(None, path)),
+                ..
+            },
+            [arg],
+        ) => {
+            if match_def_path(cx, path.res.opt_def_id()?, &paths::OPTION_SOME) {
+                Some(arg)
+            } else {
+                None
+            }
+        },
+        ExprKind::Block(
+            Block {
+                stmts: [],
+                expr: Some(expr),
+                ..
+            },
+            _,
+        ) => get_some_expr(cx, expr),
+        _ => None,
+    }
+}
+
+// Checks for the `None` value.
+fn is_none_expr(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> bool {
+    match expr.kind {
+        ExprKind::Path(QPath::Resolved(None, path)) => path
+            .res
+            .opt_def_id()
+            .map_or(false, |id| match_def_path(cx, id, &paths::OPTION_NONE)),
+        ExprKind::Block(
+            Block {
+                stmts: [],
+                expr: Some(expr),
+                ..
+            },
+            _,
+        ) => is_none_expr(cx, expr),
+        _ => false,
+    }
+}
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index fafa1400156..40771449264 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -32,7 +32,7 @@ use std::collections::hash_map::Entry;
 use std::hash::BuildHasherDefault;
 
 use if_chain::if_chain;
-use rustc_ast::ast::{self, Attribute, LitKind};
+use rustc_ast::ast::{self, Attribute, BorrowKind, LitKind, Mutability};
 use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
@@ -1672,6 +1672,18 @@ pub fn peel_n_hir_expr_refs(expr: &'a Expr<'a>, count: usize) -> (&'a Expr<'a>,
     f(expr, 0, count)
 }
 
+/// Peels off all references on the expression. Returns the underlying expression and the number of
+/// references removed.
+pub fn peel_hir_expr_refs(expr: &'a Expr<'a>) -> (&'a Expr<'a>, usize) {
+    fn f(expr: &'a Expr<'a>, count: usize) -> (&'a Expr<'a>, usize) {
+        match expr.kind {
+            ExprKind::AddrOf(BorrowKind::Ref, _, expr) => f(expr, count + 1),
+            _ => (expr, count),
+        }
+    }
+    f(expr, 0)
+}
+
 /// Peels off all references on the type. Returns the underlying type and the number of references
 /// removed.
 pub fn peel_mid_ty_refs(ty: Ty<'_>) -> (Ty<'_>, usize) {
@@ -1685,6 +1697,19 @@ pub fn peel_mid_ty_refs(ty: Ty<'_>) -> (Ty<'_>, usize) {
     peel(ty, 0)
 }
 
+/// Peels off all references on the type.Returns the underlying type, the number of references
+/// removed, and whether the pointer is ultimately mutable or not.
+pub fn peel_mid_ty_refs_is_mutable(ty: Ty<'_>) -> (Ty<'_>, usize, Mutability) {
+    fn f(ty: Ty<'_>, count: usize, mutability: Mutability) -> (Ty<'_>, usize, Mutability) {
+        match ty.kind() {
+            ty::Ref(_, ty, Mutability::Mut) => f(ty, count + 1, mutability),
+            ty::Ref(_, ty, Mutability::Not) => f(ty, count + 1, Mutability::Not),
+            _ => (ty, count, mutability),
+        }
+    }
+    f(ty, 0, Mutability::Mut)
+}
+
 #[macro_export]
 macro_rules! unwrap_cargo_metadata {
     ($cx: ident, $lint: ident, $deps: expr) => {{
diff --git a/tests/ui/manual_map_option.fixed b/tests/ui/manual_map_option.fixed
new file mode 100644
index 00000000000..6cb9a37b230
--- /dev/null
+++ b/tests/ui/manual_map_option.fixed
@@ -0,0 +1,61 @@
+// run-rustfix
+
+#![warn(clippy::manual_map)]
+#![allow(clippy::no_effect, clippy::map_identity, clippy::unit_arg, clippy::match_ref_pats)]
+
+fn main() {
+    Some(0).map(|_| 2);
+
+    Some(0).map(|x| x + 1);
+
+    Some("").map(|x| x.is_empty());
+
+    Some(0).map(|x| !x);
+
+    #[rustfmt::skip]
+    Some(0).map(std::convert::identity);
+
+    Some(&String::new()).map(|x| str::len(x));
+
+    match Some(0) {
+        Some(x) if false => Some(x + 1),
+        _ => None,
+    };
+
+    Some([0, 1]).as_ref().map(|x| x[0]);
+
+    Some(0).map(|x| x * 2);
+
+    Some(String::new()).as_ref().map(|x| x.is_empty());
+
+    Some(String::new()).as_ref().map(|x| x.len());
+
+    Some(0).map(|x| x + x);
+
+    Some(String::new()).as_mut().map(|x| x.push_str(""));
+
+    Some(String::new()).as_ref().map(|x| &**x);
+
+    Some(String::new()).as_ref().map(|x| x.is_empty());
+
+    Some((0, 1, 2)).map(|(x, y, z)| x + y + z);
+
+    Some([1, 2, 3]).map(|[first, ..]| first);
+
+    Some((String::new(), "test")).as_ref().map(|(x, y)| (y, x));
+
+    match Some((String::new(), 0)) {
+        Some((ref x, y)) => Some((y, x)),
+        None => None,
+    };
+
+    match Some(Some(0)) {
+        Some(Some(_)) | Some(None) => Some(0),
+        None => None,
+    };
+
+    match Some(Some((0, 1))) {
+        Some(Some((x, 1))) => Some(x),
+        _ => None,
+    };
+}
diff --git a/tests/ui/manual_map_option.rs b/tests/ui/manual_map_option.rs
new file mode 100644
index 00000000000..b9753060b99
--- /dev/null
+++ b/tests/ui/manual_map_option.rs
@@ -0,0 +1,113 @@
+// run-rustfix
+
+#![warn(clippy::manual_map)]
+#![allow(clippy::no_effect, clippy::map_identity, clippy::unit_arg, clippy::match_ref_pats)]
+
+fn main() {
+    match Some(0) {
+        Some(_) => Some(2),
+        None::<u32> => None,
+    };
+
+    match Some(0) {
+        Some(x) => Some(x + 1),
+        _ => None,
+    };
+
+    match Some("") {
+        Some(x) => Some(x.is_empty()),
+        None => None,
+    };
+
+    if let Some(x) = Some(0) {
+        Some(!x)
+    } else {
+        None
+    };
+
+    #[rustfmt::skip]
+    match Some(0) {
+        Some(x) => { Some(std::convert::identity(x)) }
+        None => { None }
+    };
+
+    match Some(&String::new()) {
+        Some(x) => Some(str::len(x)),
+        None => None,
+    };
+
+    match Some(0) {
+        Some(x) if false => Some(x + 1),
+        _ => None,
+    };
+
+    match &Some([0, 1]) {
+        Some(x) => Some(x[0]),
+        &None => None,
+    };
+
+    match &Some(0) {
+        &Some(x) => Some(x * 2),
+        None => None,
+    };
+
+    match Some(String::new()) {
+        Some(ref x) => Some(x.is_empty()),
+        _ => None,
+    };
+
+    match &&Some(String::new()) {
+        Some(x) => Some(x.len()),
+        _ => None,
+    };
+
+    match &&Some(0) {
+        &&Some(x) => Some(x + x),
+        &&_ => None,
+    };
+
+    match &mut Some(String::new()) {
+        Some(x) => Some(x.push_str("")),
+        None => None,
+    };
+
+    match &mut Some(String::new()) {
+        Some(ref x) => Some(&**x),
+        None => None,
+    };
+
+    match &mut &Some(String::new()) {
+        Some(x) => Some(x.is_empty()),
+        &mut _ => None,
+    };
+
+    match Some((0, 1, 2)) {
+        Some((x, y, z)) => Some(x + y + z),
+        None => None,
+    };
+
+    match Some([1, 2, 3]) {
+        Some([first, ..]) => Some(first),
+        None => None,
+    };
+
+    match &Some((String::new(), "test")) {
+        Some((x, y)) => Some((y, x)),
+        None => None,
+    };
+
+    match Some((String::new(), 0)) {
+        Some((ref x, y)) => Some((y, x)),
+        None => None,
+    };
+
+    match Some(Some(0)) {
+        Some(Some(_)) | Some(None) => Some(0),
+        None => None,
+    };
+
+    match Some(Some((0, 1))) {
+        Some(Some((x, 1))) => Some(x),
+        _ => None,
+    };
+}
diff --git a/tests/ui/manual_map_option.stderr b/tests/ui/manual_map_option.stderr
new file mode 100644
index 00000000000..f8e1bda83b2
--- /dev/null
+++ b/tests/ui/manual_map_option.stderr
@@ -0,0 +1,158 @@
+error: manual implementation of `Option::map`
+  --> $DIR/manual_map_option.rs:7:5
+   |
+LL | /     match Some(0) {
+LL | |         Some(_) => Some(2),
+LL | |         None::<u32> => None,
+LL | |     };
+   | |_____^ help: try this: `Some(0).map(|_| 2)`
+   |
+   = note: `-D clippy::manual-map` implied by `-D warnings`
+
+error: manual implementation of `Option::map`
+  --> $DIR/manual_map_option.rs:12:5
+   |
+LL | /     match Some(0) {
+LL | |         Some(x) => Some(x + 1),
+LL | |         _ => None,
+LL | |     };
+   | |_____^ help: try this: `Some(0).map(|x| x + 1)`
+
+error: manual implementation of `Option::map`
+  --> $DIR/manual_map_option.rs:17:5
+   |
+LL | /     match Some("") {
+LL | |         Some(x) => Some(x.is_empty()),
+LL | |         None => None,
+LL | |     };
+   | |_____^ help: try this: `Some("").map(|x| x.is_empty())`
+
+error: manual implementation of `Option::map`
+  --> $DIR/manual_map_option.rs:22:5
+   |
+LL | /     if let Some(x) = Some(0) {
+LL | |         Some(!x)
+LL | |     } else {
+LL | |         None
+LL | |     };
+   | |_____^ help: try this: `Some(0).map(|x| !x)`
+
+error: manual implementation of `Option::map`
+  --> $DIR/manual_map_option.rs:29:5
+   |
+LL | /     match Some(0) {
+LL | |         Some(x) => { Some(std::convert::identity(x)) }
+LL | |         None => { None }
+LL | |     };
+   | |_____^ help: try this: `Some(0).map(std::convert::identity)`
+
+error: manual implementation of `Option::map`
+  --> $DIR/manual_map_option.rs:34:5
+   |
+LL | /     match Some(&String::new()) {
+LL | |         Some(x) => Some(str::len(x)),
+LL | |         None => None,
+LL | |     };
+   | |_____^ help: try this: `Some(&String::new()).map(|x| str::len(x))`
+
+error: manual implementation of `Option::map`
+  --> $DIR/manual_map_option.rs:44:5
+   |
+LL | /     match &Some([0, 1]) {
+LL | |         Some(x) => Some(x[0]),
+LL | |         &None => None,
+LL | |     };
+   | |_____^ help: try this: `Some([0, 1]).as_ref().map(|x| x[0])`
+
+error: manual implementation of `Option::map`
+  --> $DIR/manual_map_option.rs:49:5
+   |
+LL | /     match &Some(0) {
+LL | |         &Some(x) => Some(x * 2),
+LL | |         None => None,
+LL | |     };
+   | |_____^ help: try this: `Some(0).map(|x| x * 2)`
+
+error: manual implementation of `Option::map`
+  --> $DIR/manual_map_option.rs:54:5
+   |
+LL | /     match Some(String::new()) {
+LL | |         Some(ref x) => Some(x.is_empty()),
+LL | |         _ => None,
+LL | |     };
+   | |_____^ help: try this: `Some(String::new()).as_ref().map(|x| x.is_empty())`
+
+error: manual implementation of `Option::map`
+  --> $DIR/manual_map_option.rs:59:5
+   |
+LL | /     match &&Some(String::new()) {
+LL | |         Some(x) => Some(x.len()),
+LL | |         _ => None,
+LL | |     };
+   | |_____^ help: try this: `Some(String::new()).as_ref().map(|x| x.len())`
+
+error: manual implementation of `Option::map`
+  --> $DIR/manual_map_option.rs:64:5
+   |
+LL | /     match &&Some(0) {
+LL | |         &&Some(x) => Some(x + x),
+LL | |         &&_ => None,
+LL | |     };
+   | |_____^ help: try this: `Some(0).map(|x| x + x)`
+
+error: manual implementation of `Option::map`
+  --> $DIR/manual_map_option.rs:69:5
+   |
+LL | /     match &mut Some(String::new()) {
+LL | |         Some(x) => Some(x.push_str("")),
+LL | |         None => None,
+LL | |     };
+   | |_____^ help: try this: `Some(String::new()).as_mut().map(|x| x.push_str(""))`
+
+error: manual implementation of `Option::map`
+  --> $DIR/manual_map_option.rs:74:5
+   |
+LL | /     match &mut Some(String::new()) {
+LL | |         Some(ref x) => Some(&**x),
+LL | |         None => None,
+LL | |     };
+   | |_____^ help: try this: `Some(String::new()).as_ref().map(|x| &**x)`
+
+error: manual implementation of `Option::map`
+  --> $DIR/manual_map_option.rs:79:5
+   |
+LL | /     match &mut &Some(String::new()) {
+LL | |         Some(x) => Some(x.is_empty()),
+LL | |         &mut _ => None,
+LL | |     };
+   | |_____^ help: try this: `Some(String::new()).as_ref().map(|x| x.is_empty())`
+
+error: manual implementation of `Option::map`
+  --> $DIR/manual_map_option.rs:84:5
+   |
+LL | /     match Some((0, 1, 2)) {
+LL | |         Some((x, y, z)) => Some(x + y + z),
+LL | |         None => None,
+LL | |     };
+   | |_____^ help: try this: `Some((0, 1, 2)).map(|(x, y, z)| x + y + z)`
+
+error: manual implementation of `Option::map`
+  --> $DIR/manual_map_option.rs:89:5
+   |
+LL | /     match Some([1, 2, 3]) {
+LL | |         Some([first, ..]) => Some(first),
+LL | |         None => None,
+LL | |     };
+   | |_____^ help: try this: `Some([1, 2, 3]).map(|[first, ..]| first)`
+
+error: manual implementation of `Option::map`
+  --> $DIR/manual_map_option.rs:94:5
+   |
+LL | /     match &Some((String::new(), "test")) {
+LL | |         Some((x, y)) => Some((y, x)),
+LL | |         None => None,
+LL | |     };
+   | |_____^ help: try this: `Some((String::new(), "test")).as_ref().map(|(x, y)| (y, x))`
+
+error: aborting due to 17 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 23aa2f880cc0bda7ea3bbef1391f7c4d86467d65 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Fri, 19 Feb 2021 14:04:37 -0500
Subject: Fix dogfood errors

---
 clippy_lints/src/manual_map.rs    | 40 +++++++++++++++++++++++++--------------
 tests/ui/manual_map_option.fixed  | 13 +++++++++++--
 tests/ui/manual_map_option.rs     | 11 ++++++++++-
 tests/ui/manual_map_option.stderr | 26 ++++++++++++-------------
 4 files changed, 60 insertions(+), 30 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_map.rs b/clippy_lints/src/manual_map.rs
index e399c8fda55..a50a3943bab 100644
--- a/clippy_lints/src/manual_map.rs
+++ b/clippy_lints/src/manual_map.rs
@@ -1,10 +1,14 @@
-use crate::utils::{
-    is_type_diagnostic_item, match_def_path, paths, peel_hir_expr_refs, peel_mid_ty_refs_is_mutable,
-    snippet_with_applicability, span_lint_and_sugg,
+use crate::{
+    map_unit_fn::OPTION_MAP_UNIT_FN,
+    matches::MATCH_AS_REF,
+    utils::{
+        is_allowed, is_type_diagnostic_item, match_def_path, match_var, paths, peel_hir_expr_refs,
+        peel_mid_ty_refs_is_mutable, snippet_with_applicability, span_lint_and_sugg,
+    },
 };
 use rustc_ast::util::parser::PREC_POSTFIX;
 use rustc_errors::Applicability;
-use rustc_hir::{Arm, BindingAnnotation, Block, Expr, ExprKind, Mutability, Pat, PatKind, Path, QPath};
+use rustc_hir::{Arm, BindingAnnotation, Block, Expr, ExprKind, Mutability, Pat, PatKind, QPath};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -37,6 +41,7 @@ declare_clippy_lint! {
 declare_lint_pass!(ManualMap => [MANUAL_MAP]);
 
 impl LateLintPass<'_> for ManualMap {
+    #[allow(clippy::too_many_lines)]
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if in_external_macro(cx.sess(), expr.span) {
             return;
@@ -88,14 +93,17 @@ impl LateLintPass<'_> for ManualMap {
                 None => return,
             };
 
+            if cx.typeck_results().expr_ty(some_expr) == cx.tcx.types.unit
+                && !is_allowed(cx, OPTION_MAP_UNIT_FN, expr.hir_id)
+            {
+                return;
+            }
+
             // Determine which binding mode to use.
             let explicit_ref = some_pat.contains_explicit_ref_binding();
-            let binding_mutability = explicit_ref.or(if ty_ref_count != pat_ref_count {
-                Some(ty_mutability)
-            } else {
-                None
-            });
-            let as_ref_str = match binding_mutability {
+            let binding_ref = explicit_ref.or_else(|| (ty_ref_count != pat_ref_count).then(|| ty_mutability));
+
+            let as_ref_str = match binding_ref {
                 Some(Mutability::Mut) => ".as_mut()",
                 Some(Mutability::Not) => ".as_ref()",
                 None => "",
@@ -118,6 +126,13 @@ impl LateLintPass<'_> for ManualMap {
                 if let Some(func) = can_pass_as_func(cx, some_binding, some_expr) {
                     snippet_with_applicability(cx, func.span, "..", &mut app).into_owned()
                 } else {
+                    if match_var(some_expr, some_binding.name)
+                        && !is_allowed(cx, MATCH_AS_REF, expr.hir_id)
+                        && binding_ref.is_some()
+                    {
+                        return;
+                    }
+
                     // `ref` and `ref mut` annotations were handled earlier.
                     let annotation = if matches!(annotation, BindingAnnotation::Mutable) {
                         "mut "
@@ -161,10 +176,7 @@ impl LateLintPass<'_> for ManualMap {
 fn can_pass_as_func(cx: &LateContext<'tcx>, binding: Ident, expr: &'tcx Expr<'_>) -> Option<&'tcx Expr<'tcx>> {
     match expr.kind {
         ExprKind::Call(func, [arg])
-            if matches!(arg.kind,
-                ExprKind::Path(QPath::Resolved(None, Path { segments: [path], ..}))
-                if path.ident == binding
-            ) && cx.typeck_results().expr_adjustments(arg).is_empty() =>
+            if match_var(arg, binding.name) && cx.typeck_results().expr_adjustments(arg).is_empty() =>
         {
             Some(func)
         },
diff --git a/tests/ui/manual_map_option.fixed b/tests/ui/manual_map_option.fixed
index 6cb9a37b230..19350906758 100644
--- a/tests/ui/manual_map_option.fixed
+++ b/tests/ui/manual_map_option.fixed
@@ -32,9 +32,18 @@ fn main() {
 
     Some(0).map(|x| x + x);
 
-    Some(String::new()).as_mut().map(|x| x.push_str(""));
+    #[warn(clippy::option_map_unit_fn)]
+    match &mut Some(String::new()) {
+        Some(x) => Some(x.push_str("")),
+        None => None,
+    };
 
-    Some(String::new()).as_ref().map(|x| &**x);
+    #[allow(clippy::option_map_unit_fn)]
+    {
+        Some(String::new()).as_mut().map(|x| x.push_str(""));
+    }
+
+    Some(String::new()).as_ref().map(|x| x.len());
 
     Some(String::new()).as_ref().map(|x| x.is_empty());
 
diff --git a/tests/ui/manual_map_option.rs b/tests/ui/manual_map_option.rs
index b9753060b99..8b8187db0a9 100644
--- a/tests/ui/manual_map_option.rs
+++ b/tests/ui/manual_map_option.rs
@@ -66,13 +66,22 @@ fn main() {
         &&_ => None,
     };
 
+    #[warn(clippy::option_map_unit_fn)]
     match &mut Some(String::new()) {
         Some(x) => Some(x.push_str("")),
         None => None,
     };
 
+    #[allow(clippy::option_map_unit_fn)]
+    {
+        match &mut Some(String::new()) {
+            Some(x) => Some(x.push_str("")),
+            None => None,
+        };
+    }
+
     match &mut Some(String::new()) {
-        Some(ref x) => Some(&**x),
+        Some(ref x) => Some(x.len()),
         None => None,
     };
 
diff --git a/tests/ui/manual_map_option.stderr b/tests/ui/manual_map_option.stderr
index f8e1bda83b2..210a30d05d4 100644
--- a/tests/ui/manual_map_option.stderr
+++ b/tests/ui/manual_map_option.stderr
@@ -101,25 +101,25 @@ LL | |     };
    | |_____^ help: try this: `Some(0).map(|x| x + x)`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:69:5
+  --> $DIR/manual_map_option.rs:77:9
    |
-LL | /     match &mut Some(String::new()) {
-LL | |         Some(x) => Some(x.push_str("")),
-LL | |         None => None,
-LL | |     };
-   | |_____^ help: try this: `Some(String::new()).as_mut().map(|x| x.push_str(""))`
+LL | /         match &mut Some(String::new()) {
+LL | |             Some(x) => Some(x.push_str("")),
+LL | |             None => None,
+LL | |         };
+   | |_________^ help: try this: `Some(String::new()).as_mut().map(|x| x.push_str(""))`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:74:5
+  --> $DIR/manual_map_option.rs:83:5
    |
 LL | /     match &mut Some(String::new()) {
-LL | |         Some(ref x) => Some(&**x),
+LL | |         Some(ref x) => Some(x.len()),
 LL | |         None => None,
 LL | |     };
-   | |_____^ help: try this: `Some(String::new()).as_ref().map(|x| &**x)`
+   | |_____^ help: try this: `Some(String::new()).as_ref().map(|x| x.len())`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:79:5
+  --> $DIR/manual_map_option.rs:88:5
    |
 LL | /     match &mut &Some(String::new()) {
 LL | |         Some(x) => Some(x.is_empty()),
@@ -128,7 +128,7 @@ LL | |     };
    | |_____^ help: try this: `Some(String::new()).as_ref().map(|x| x.is_empty())`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:84:5
+  --> $DIR/manual_map_option.rs:93:5
    |
 LL | /     match Some((0, 1, 2)) {
 LL | |         Some((x, y, z)) => Some(x + y + z),
@@ -137,7 +137,7 @@ LL | |     };
    | |_____^ help: try this: `Some((0, 1, 2)).map(|(x, y, z)| x + y + z)`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:89:5
+  --> $DIR/manual_map_option.rs:98:5
    |
 LL | /     match Some([1, 2, 3]) {
 LL | |         Some([first, ..]) => Some(first),
@@ -146,7 +146,7 @@ LL | |     };
    | |_____^ help: try this: `Some([1, 2, 3]).map(|[first, ..]| first)`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:94:5
+  --> $DIR/manual_map_option.rs:103:5
    |
 LL | /     match &Some((String::new(), "test")) {
 LL | |         Some((x, y)) => Some((y, x)),
-- 
cgit 1.4.1-3-g733a5


From 0eefa6169df7f55a7cbeeaff77bf9dfbce8bfcff Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Mon, 22 Feb 2021 12:30:28 +0100
Subject: upper_case_acronyms: move lint from style to pedantic lint group

The lint does point out inconsistency with the Rust naming convention,
but the fact that rustc does not warn about the inconsistency by default
means that clippy probably should not warn by default either.

changelog: move upper_case_acronyms lint from style to pedantic group.
---
 clippy_lints/src/lib.rs                 | 3 +--
 clippy_lints/src/upper_case_acronyms.rs | 2 +-
 2 files changed, 2 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 7dcf7a260c8..a6d07c1f519 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1402,6 +1402,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&unnecessary_wraps::UNNECESSARY_WRAPS),
         LintId::of(&unnested_or_patterns::UNNESTED_OR_PATTERNS),
         LintId::of(&unused_self::UNUSED_SELF),
+        LintId::of(&upper_case_acronyms::UPPER_CASE_ACRONYMS),
         LintId::of(&wildcard_imports::ENUM_GLOB_USE),
         LintId::of(&wildcard_imports::WILDCARD_IMPORTS),
         LintId::of(&zero_sized_map_values::ZERO_SIZED_MAP_VALUES),
@@ -1700,7 +1701,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&unused_unit::UNUSED_UNIT),
         LintId::of(&unwrap::PANICKING_UNWRAP),
         LintId::of(&unwrap::UNNECESSARY_UNWRAP),
-        LintId::of(&upper_case_acronyms::UPPER_CASE_ACRONYMS),
         LintId::of(&useless_conversion::USELESS_CONVERSION),
         LintId::of(&vec::USELESS_VEC),
         LintId::of(&vec_init_then_push::VEC_INIT_THEN_PUSH),
@@ -1819,7 +1819,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&types::FN_TO_NUMERIC_CAST_WITH_TRUNCATION),
         LintId::of(&unsafe_removed_from_name::UNSAFE_REMOVED_FROM_NAME),
         LintId::of(&unused_unit::UNUSED_UNIT),
-        LintId::of(&upper_case_acronyms::UPPER_CASE_ACRONYMS),
         LintId::of(&write::PRINTLN_EMPTY_STRING),
         LintId::of(&write::PRINT_LITERAL),
         LintId::of(&write::PRINT_WITH_NEWLINE),
diff --git a/clippy_lints/src/upper_case_acronyms.rs b/clippy_lints/src/upper_case_acronyms.rs
index 61e7031716a..b593fd0a699 100644
--- a/clippy_lints/src/upper_case_acronyms.rs
+++ b/clippy_lints/src/upper_case_acronyms.rs
@@ -29,7 +29,7 @@ declare_clippy_lint! {
     /// struct HttpResponse;
     /// ```
     pub UPPER_CASE_ACRONYMS,
-    style,
+    pedantic,
     "capitalized acronyms are against the naming convention"
 }
 
-- 
cgit 1.4.1-3-g733a5


From e05965eb13a3e303ffe9001bb73e7d9c87d3bf78 Mon Sep 17 00:00:00 2001
From: Takayuki Nakata <f.seasons017@gmail.com>
Date: Mon, 22 Feb 2021 23:02:04 +0900
Subject: Remove unneeded blank lines from doc

---
 clippy_lints/src/write.rs | 3 ---
 1 file changed, 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs
index e40fdca6a99..f21f5180554 100644
--- a/clippy_lints/src/write.rs
+++ b/clippy_lints/src/write.rs
@@ -147,7 +147,6 @@ declare_clippy_lint! {
     /// ```rust
     /// # use std::fmt::Write;
     /// # let mut buf = String::new();
-    ///
     /// // Bad
     /// writeln!(buf, "");
     ///
@@ -174,7 +173,6 @@ declare_clippy_lint! {
     /// # use std::fmt::Write;
     /// # let mut buf = String::new();
     /// # let name = "World";
-    ///
     /// // Bad
     /// write!(buf, "Hello {}!\n", name);
     ///
@@ -200,7 +198,6 @@ declare_clippy_lint! {
     /// ```rust
     /// # use std::fmt::Write;
     /// # let mut buf = String::new();
-    ///
     /// // Bad
     /// writeln!(buf, "{}", "foo");
     ///
-- 
cgit 1.4.1-3-g733a5


From 09bded443745a05daaeeca76e4b032381ca1a126 Mon Sep 17 00:00:00 2001
From: "Samuel E. Moelius III" <sam@moeli.us>
Date: Wed, 17 Feb 2021 12:42:21 -0500
Subject: Factor out `clippy_utils` crate

---
 .gitignore                                     |    1 +
 clippy_lints/Cargo.toml                        |    1 +
 clippy_lints/src/consts.rs                     |  575 +------
 clippy_lints/src/lib.rs                        |  110 +-
 clippy_lints/src/utils.rs                      |    1 +
 clippy_lints/src/utils/ast_utils.rs            |  562 -------
 clippy_lints/src/utils/ast_utils/ident_iter.rs |   45 -
 clippy_lints/src/utils/attrs.rs                |  150 --
 clippy_lints/src/utils/author.rs               |  779 ---------
 clippy_lints/src/utils/camel_case.rs           |  121 --
 clippy_lints/src/utils/comparisons.rs          |   36 -
 clippy_lints/src/utils/conf.rs                 |  257 ---
 clippy_lints/src/utils/diagnostics.rs          |  226 ---
 clippy_lints/src/utils/eager_or_lazy.rs        |  134 --
 clippy_lints/src/utils/higher.rs               |  268 ----
 clippy_lints/src/utils/hir_utils.rs            |  852 ----------
 clippy_lints/src/utils/inspector.rs            |  578 -------
 clippy_lints/src/utils/internal_lints.rs       | 1070 -------------
 clippy_lints/src/utils/mod.rs                  | 1862 ----------------------
 clippy_lints/src/utils/numeric_literal.rs      |  228 ---
 clippy_lints/src/utils/paths.rs                |  181 ---
 clippy_lints/src/utils/ptr.rs                  |   86 -
 clippy_lints/src/utils/qualify_min_const_fn.rs |  347 ----
 clippy_lints/src/utils/sugg.rs                 |  683 --------
 clippy_lints/src/utils/sym_helper.rs           |    7 -
 clippy_lints/src/utils/usage.rs                |  198 ---
 clippy_lints/src/utils/visitors.rs             |  190 ---
 clippy_utils/Cargo.toml                        |   24 +
 clippy_utils/src/ast_utils.rs                  |  562 +++++++
 clippy_utils/src/ast_utils/ident_iter.rs       |   45 +
 clippy_utils/src/attrs.rs                      |  150 ++
 clippy_utils/src/author.rs                     |  779 +++++++++
 clippy_utils/src/camel_case.rs                 |  121 ++
 clippy_utils/src/comparisons.rs                |   36 +
 clippy_utils/src/conf.rs                       |  257 +++
 clippy_utils/src/constants.rs                  |   13 +
 clippy_utils/src/consts.rs                     |  574 +++++++
 clippy_utils/src/diagnostics.rs                |  226 +++
 clippy_utils/src/eager_or_lazy.rs              |  134 ++
 clippy_utils/src/higher.rs                     |  268 ++++
 clippy_utils/src/hir_utils.rs                  |  852 ++++++++++
 clippy_utils/src/inspector.rs                  |  578 +++++++
 clippy_utils/src/internal_lints.rs             | 1070 +++++++++++++
 clippy_utils/src/lib.rs                        | 1998 ++++++++++++++++++++++++
 clippy_utils/src/numeric_literal.rs            |  228 +++
 clippy_utils/src/paths.rs                      |  181 +++
 clippy_utils/src/ptr.rs                        |   86 +
 clippy_utils/src/qualify_min_const_fn.rs       |  347 ++++
 clippy_utils/src/sugg.rs                       |  683 ++++++++
 clippy_utils/src/sym_helper.rs                 |    7 +
 clippy_utils/src/usage.rs                      |  198 +++
 clippy_utils/src/visitors.rs                   |  190 +++
 52 files changed, 9626 insertions(+), 9529 deletions(-)
 create mode 100644 clippy_lints/src/utils.rs
 delete mode 100644 clippy_lints/src/utils/ast_utils.rs
 delete mode 100644 clippy_lints/src/utils/ast_utils/ident_iter.rs
 delete mode 100644 clippy_lints/src/utils/attrs.rs
 delete mode 100644 clippy_lints/src/utils/author.rs
 delete mode 100644 clippy_lints/src/utils/camel_case.rs
 delete mode 100644 clippy_lints/src/utils/comparisons.rs
 delete mode 100644 clippy_lints/src/utils/conf.rs
 delete mode 100644 clippy_lints/src/utils/diagnostics.rs
 delete mode 100644 clippy_lints/src/utils/eager_or_lazy.rs
 delete mode 100644 clippy_lints/src/utils/higher.rs
 delete mode 100644 clippy_lints/src/utils/hir_utils.rs
 delete mode 100644 clippy_lints/src/utils/inspector.rs
 delete mode 100644 clippy_lints/src/utils/internal_lints.rs
 delete mode 100644 clippy_lints/src/utils/mod.rs
 delete mode 100644 clippy_lints/src/utils/numeric_literal.rs
 delete mode 100644 clippy_lints/src/utils/paths.rs
 delete mode 100644 clippy_lints/src/utils/ptr.rs
 delete mode 100644 clippy_lints/src/utils/qualify_min_const_fn.rs
 delete mode 100644 clippy_lints/src/utils/sugg.rs
 delete mode 100644 clippy_lints/src/utils/sym_helper.rs
 delete mode 100644 clippy_lints/src/utils/usage.rs
 delete mode 100644 clippy_lints/src/utils/visitors.rs
 create mode 100644 clippy_utils/Cargo.toml
 create mode 100644 clippy_utils/src/ast_utils.rs
 create mode 100644 clippy_utils/src/ast_utils/ident_iter.rs
 create mode 100644 clippy_utils/src/attrs.rs
 create mode 100644 clippy_utils/src/author.rs
 create mode 100644 clippy_utils/src/camel_case.rs
 create mode 100644 clippy_utils/src/comparisons.rs
 create mode 100644 clippy_utils/src/conf.rs
 create mode 100644 clippy_utils/src/constants.rs
 create mode 100644 clippy_utils/src/consts.rs
 create mode 100644 clippy_utils/src/diagnostics.rs
 create mode 100644 clippy_utils/src/eager_or_lazy.rs
 create mode 100644 clippy_utils/src/higher.rs
 create mode 100644 clippy_utils/src/hir_utils.rs
 create mode 100644 clippy_utils/src/inspector.rs
 create mode 100644 clippy_utils/src/internal_lints.rs
 create mode 100644 clippy_utils/src/lib.rs
 create mode 100644 clippy_utils/src/numeric_literal.rs
 create mode 100644 clippy_utils/src/paths.rs
 create mode 100644 clippy_utils/src/ptr.rs
 create mode 100644 clippy_utils/src/qualify_min_const_fn.rs
 create mode 100644 clippy_utils/src/sugg.rs
 create mode 100644 clippy_utils/src/sym_helper.rs
 create mode 100644 clippy_utils/src/usage.rs
 create mode 100644 clippy_utils/src/visitors.rs

(limited to 'clippy_lints/src')

diff --git a/.gitignore b/.gitignore
index adf5e8feddf..139129d55e3 100644
--- a/.gitignore
+++ b/.gitignore
@@ -18,6 +18,7 @@ out
 *Cargo.lock
 /target
 /clippy_lints/target
+/clippy_utils/target
 /clippy_workspace_tests/target
 /clippy_dev/target
 /rustc_tools_util/target
diff --git a/clippy_lints/Cargo.toml b/clippy_lints/Cargo.toml
index 840341fefc6..f09df3393d7 100644
--- a/clippy_lints/Cargo.toml
+++ b/clippy_lints/Cargo.toml
@@ -18,6 +18,7 @@ edition = "2018"
 
 [dependencies]
 cargo_metadata = "0.12"
+clippy_utils = { path = "../clippy_utils" }
 if_chain = "1.0.0"
 itertools = "0.9"
 pulldown-cmark = { version = "0.8", default-features = false }
diff --git a/clippy_lints/src/consts.rs b/clippy_lints/src/consts.rs
index 1b89d0bbe38..7e87f53e3fb 100644
--- a/clippy_lints/src/consts.rs
+++ b/clippy_lints/src/consts.rs
@@ -1,574 +1 @@
-#![allow(clippy::float_cmp)]
-
-use crate::utils::{clip, sext, unsext};
-use if_chain::if_chain;
-use rustc_ast::ast::{self, LitFloatType, LitKind};
-use rustc_data_structures::sync::Lrc;
-use rustc_hir::def::{DefKind, Res};
-use rustc_hir::{BinOp, BinOpKind, Block, Expr, ExprKind, HirId, QPath, UnOp};
-use rustc_lint::LateContext;
-use rustc_middle::mir::interpret::Scalar;
-use rustc_middle::ty::subst::{Subst, SubstsRef};
-use rustc_middle::ty::{self, FloatTy, ScalarInt, Ty, TyCtxt};
-use rustc_middle::{bug, span_bug};
-use rustc_span::symbol::Symbol;
-use std::cmp::Ordering::{self, Equal};
-use std::convert::TryInto;
-use std::hash::{Hash, Hasher};
-
-/// A `LitKind`-like enum to fold constant `Expr`s into.
-#[derive(Debug, Clone)]
-pub enum Constant {
-    /// A `String` (e.g., "abc").
-    Str(String),
-    /// A binary string (e.g., `b"abc"`).
-    Binary(Lrc<[u8]>),
-    /// A single `char` (e.g., `'a'`).
-    Char(char),
-    /// An integer's bit representation.
-    Int(u128),
-    /// An `f32`.
-    F32(f32),
-    /// An `f64`.
-    F64(f64),
-    /// `true` or `false`.
-    Bool(bool),
-    /// An array of constants.
-    Vec(Vec<Constant>),
-    /// Also an array, but with only one constant, repeated N times.
-    Repeat(Box<Constant>, u64),
-    /// A tuple of constants.
-    Tuple(Vec<Constant>),
-    /// A raw pointer.
-    RawPtr(u128),
-    /// A reference
-    Ref(Box<Constant>),
-    /// A literal with syntax error.
-    Err(Symbol),
-}
-
-impl PartialEq for Constant {
-    fn eq(&self, other: &Self) -> bool {
-        match (self, other) {
-            (&Self::Str(ref ls), &Self::Str(ref rs)) => ls == rs,
-            (&Self::Binary(ref l), &Self::Binary(ref r)) => l == r,
-            (&Self::Char(l), &Self::Char(r)) => l == r,
-            (&Self::Int(l), &Self::Int(r)) => l == r,
-            (&Self::F64(l), &Self::F64(r)) => {
-                // We want `Fw32 == FwAny` and `FwAny == Fw64`, and by transitivity we must have
-                // `Fw32 == Fw64`, so don’t compare them.
-                // `to_bits` is required to catch non-matching 0.0, -0.0, and NaNs.
-                l.to_bits() == r.to_bits()
-            },
-            (&Self::F32(l), &Self::F32(r)) => {
-                // We want `Fw32 == FwAny` and `FwAny == Fw64`, and by transitivity we must have
-                // `Fw32 == Fw64`, so don’t compare them.
-                // `to_bits` is required to catch non-matching 0.0, -0.0, and NaNs.
-                f64::from(l).to_bits() == f64::from(r).to_bits()
-            },
-            (&Self::Bool(l), &Self::Bool(r)) => l == r,
-            (&Self::Vec(ref l), &Self::Vec(ref r)) | (&Self::Tuple(ref l), &Self::Tuple(ref r)) => l == r,
-            (&Self::Repeat(ref lv, ref ls), &Self::Repeat(ref rv, ref rs)) => ls == rs && lv == rv,
-            (&Self::Ref(ref lb), &Self::Ref(ref rb)) => *lb == *rb,
-            // TODO: are there inter-type equalities?
-            _ => false,
-        }
-    }
-}
-
-impl Hash for Constant {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        std::mem::discriminant(self).hash(state);
-        match *self {
-            Self::Str(ref s) => {
-                s.hash(state);
-            },
-            Self::Binary(ref b) => {
-                b.hash(state);
-            },
-            Self::Char(c) => {
-                c.hash(state);
-            },
-            Self::Int(i) => {
-                i.hash(state);
-            },
-            Self::F32(f) => {
-                f64::from(f).to_bits().hash(state);
-            },
-            Self::F64(f) => {
-                f.to_bits().hash(state);
-            },
-            Self::Bool(b) => {
-                b.hash(state);
-            },
-            Self::Vec(ref v) | Self::Tuple(ref v) => {
-                v.hash(state);
-            },
-            Self::Repeat(ref c, l) => {
-                c.hash(state);
-                l.hash(state);
-            },
-            Self::RawPtr(u) => {
-                u.hash(state);
-            },
-            Self::Ref(ref r) => {
-                r.hash(state);
-            },
-            Self::Err(ref s) => {
-                s.hash(state);
-            },
-        }
-    }
-}
-
-impl Constant {
-    pub fn partial_cmp(tcx: TyCtxt<'_>, cmp_type: Ty<'_>, left: &Self, right: &Self) -> Option<Ordering> {
-        match (left, right) {
-            (&Self::Str(ref ls), &Self::Str(ref rs)) => Some(ls.cmp(rs)),
-            (&Self::Char(ref l), &Self::Char(ref r)) => Some(l.cmp(r)),
-            (&Self::Int(l), &Self::Int(r)) => {
-                if let ty::Int(int_ty) = *cmp_type.kind() {
-                    Some(sext(tcx, l, int_ty).cmp(&sext(tcx, r, int_ty)))
-                } else {
-                    Some(l.cmp(&r))
-                }
-            },
-            (&Self::F64(l), &Self::F64(r)) => l.partial_cmp(&r),
-            (&Self::F32(l), &Self::F32(r)) => l.partial_cmp(&r),
-            (&Self::Bool(ref l), &Self::Bool(ref r)) => Some(l.cmp(r)),
-            (&Self::Tuple(ref l), &Self::Tuple(ref r)) | (&Self::Vec(ref l), &Self::Vec(ref r)) => l
-                .iter()
-                .zip(r.iter())
-                .map(|(li, ri)| Self::partial_cmp(tcx, cmp_type, li, ri))
-                .find(|r| r.map_or(true, |o| o != Ordering::Equal))
-                .unwrap_or_else(|| Some(l.len().cmp(&r.len()))),
-            (&Self::Repeat(ref lv, ref ls), &Self::Repeat(ref rv, ref rs)) => {
-                match Self::partial_cmp(tcx, cmp_type, lv, rv) {
-                    Some(Equal) => Some(ls.cmp(rs)),
-                    x => x,
-                }
-            },
-            (&Self::Ref(ref lb), &Self::Ref(ref rb)) => Self::partial_cmp(tcx, cmp_type, lb, rb),
-            // TODO: are there any useful inter-type orderings?
-            _ => None,
-        }
-    }
-}
-
-/// Parses a `LitKind` to a `Constant`.
-pub fn lit_to_constant(lit: &LitKind, ty: Option<Ty<'_>>) -> Constant {
-    match *lit {
-        LitKind::Str(ref is, _) => Constant::Str(is.to_string()),
-        LitKind::Byte(b) => Constant::Int(u128::from(b)),
-        LitKind::ByteStr(ref s) => Constant::Binary(Lrc::clone(s)),
-        LitKind::Char(c) => Constant::Char(c),
-        LitKind::Int(n, _) => Constant::Int(n),
-        LitKind::Float(ref is, LitFloatType::Suffixed(fty)) => match fty {
-            ast::FloatTy::F32 => Constant::F32(is.as_str().parse().unwrap()),
-            ast::FloatTy::F64 => Constant::F64(is.as_str().parse().unwrap()),
-        },
-        LitKind::Float(ref is, LitFloatType::Unsuffixed) => match ty.expect("type of float is known").kind() {
-            ty::Float(FloatTy::F32) => Constant::F32(is.as_str().parse().unwrap()),
-            ty::Float(FloatTy::F64) => Constant::F64(is.as_str().parse().unwrap()),
-            _ => bug!(),
-        },
-        LitKind::Bool(b) => Constant::Bool(b),
-        LitKind::Err(s) => Constant::Err(s),
-    }
-}
-
-pub fn constant<'tcx>(
-    lcx: &LateContext<'tcx>,
-    typeck_results: &ty::TypeckResults<'tcx>,
-    e: &Expr<'_>,
-) -> Option<(Constant, bool)> {
-    let mut cx = ConstEvalLateContext {
-        lcx,
-        typeck_results,
-        param_env: lcx.param_env,
-        needed_resolution: false,
-        substs: lcx.tcx.intern_substs(&[]),
-    };
-    cx.expr(e).map(|cst| (cst, cx.needed_resolution))
-}
-
-pub fn constant_simple<'tcx>(
-    lcx: &LateContext<'tcx>,
-    typeck_results: &ty::TypeckResults<'tcx>,
-    e: &Expr<'_>,
-) -> Option<Constant> {
-    constant(lcx, typeck_results, e).and_then(|(cst, res)| if res { None } else { Some(cst) })
-}
-
-/// Creates a `ConstEvalLateContext` from the given `LateContext` and `TypeckResults`.
-pub fn constant_context<'a, 'tcx>(
-    lcx: &'a LateContext<'tcx>,
-    typeck_results: &'a ty::TypeckResults<'tcx>,
-) -> ConstEvalLateContext<'a, 'tcx> {
-    ConstEvalLateContext {
-        lcx,
-        typeck_results,
-        param_env: lcx.param_env,
-        needed_resolution: false,
-        substs: lcx.tcx.intern_substs(&[]),
-    }
-}
-
-pub struct ConstEvalLateContext<'a, 'tcx> {
-    lcx: &'a LateContext<'tcx>,
-    typeck_results: &'a ty::TypeckResults<'tcx>,
-    param_env: ty::ParamEnv<'tcx>,
-    needed_resolution: bool,
-    substs: SubstsRef<'tcx>,
-}
-
-impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
-    /// Simple constant folding: Insert an expression, get a constant or none.
-    pub fn expr(&mut self, e: &Expr<'_>) -> Option<Constant> {
-        match e.kind {
-            ExprKind::Path(ref qpath) => self.fetch_path(qpath, e.hir_id, self.typeck_results.expr_ty(e)),
-            ExprKind::Block(ref block, _) => self.block(block),
-            ExprKind::Lit(ref lit) => Some(lit_to_constant(&lit.node, self.typeck_results.expr_ty_opt(e))),
-            ExprKind::Array(ref vec) => self.multi(vec).map(Constant::Vec),
-            ExprKind::Tup(ref tup) => self.multi(tup).map(Constant::Tuple),
-            ExprKind::Repeat(ref value, _) => {
-                let n = match self.typeck_results.expr_ty(e).kind() {
-                    ty::Array(_, n) => n.try_eval_usize(self.lcx.tcx, self.lcx.param_env)?,
-                    _ => span_bug!(e.span, "typeck error"),
-                };
-                self.expr(value).map(|v| Constant::Repeat(Box::new(v), n))
-            },
-            ExprKind::Unary(op, ref operand) => self.expr(operand).and_then(|o| match op {
-                UnOp::Not => self.constant_not(&o, self.typeck_results.expr_ty(e)),
-                UnOp::Neg => self.constant_negate(&o, self.typeck_results.expr_ty(e)),
-                UnOp::Deref => Some(if let Constant::Ref(r) = o { *r } else { o }),
-            }),
-            ExprKind::If(ref cond, ref then, ref otherwise) => self.ifthenelse(cond, then, *otherwise),
-            ExprKind::Binary(op, ref left, ref right) => self.binop(op, left, right),
-            ExprKind::Call(ref callee, ref args) => {
-                // We only handle a few const functions for now.
-                if_chain! {
-                    if args.is_empty();
-                    if let ExprKind::Path(qpath) = &callee.kind;
-                    let res = self.typeck_results.qpath_res(qpath, callee.hir_id);
-                    if let Some(def_id) = res.opt_def_id();
-                    let def_path: Vec<_> = self.lcx.get_def_path(def_id).into_iter().map(Symbol::as_str).collect();
-                    let def_path: Vec<&str> = def_path.iter().take(4).map(|s| &**s).collect();
-                    if let ["core", "num", int_impl, "max_value"] = *def_path;
-                    then {
-                       let value = match int_impl {
-                           "<impl i8>" => i8::MAX as u128,
-                           "<impl i16>" => i16::MAX as u128,
-                           "<impl i32>" => i32::MAX as u128,
-                           "<impl i64>" => i64::MAX as u128,
-                           "<impl i128>" => i128::MAX as u128,
-                           _ => return None,
-                       };
-                       Some(Constant::Int(value))
-                    }
-                    else {
-                        None
-                    }
-                }
-            },
-            ExprKind::Index(ref arr, ref index) => self.index(arr, index),
-            ExprKind::AddrOf(_, _, ref inner) => self.expr(inner).map(|r| Constant::Ref(Box::new(r))),
-            // TODO: add other expressions.
-            _ => None,
-        }
-    }
-
-    #[allow(clippy::cast_possible_wrap)]
-    fn constant_not(&self, o: &Constant, ty: Ty<'_>) -> Option<Constant> {
-        use self::Constant::{Bool, Int};
-        match *o {
-            Bool(b) => Some(Bool(!b)),
-            Int(value) => {
-                let value = !value;
-                match *ty.kind() {
-                    ty::Int(ity) => Some(Int(unsext(self.lcx.tcx, value as i128, ity))),
-                    ty::Uint(ity) => Some(Int(clip(self.lcx.tcx, value, ity))),
-                    _ => None,
-                }
-            },
-            _ => None,
-        }
-    }
-
-    fn constant_negate(&self, o: &Constant, ty: Ty<'_>) -> Option<Constant> {
-        use self::Constant::{Int, F32, F64};
-        match *o {
-            Int(value) => {
-                let ity = match *ty.kind() {
-                    ty::Int(ity) => ity,
-                    _ => return None,
-                };
-                // sign extend
-                let value = sext(self.lcx.tcx, value, ity);
-                let value = value.checked_neg()?;
-                // clear unused bits
-                Some(Int(unsext(self.lcx.tcx, value, ity)))
-            },
-            F32(f) => Some(F32(-f)),
-            F64(f) => Some(F64(-f)),
-            _ => None,
-        }
-    }
-
-    /// Create `Some(Vec![..])` of all constants, unless there is any
-    /// non-constant part.
-    fn multi(&mut self, vec: &[Expr<'_>]) -> Option<Vec<Constant>> {
-        vec.iter().map(|elem| self.expr(elem)).collect::<Option<_>>()
-    }
-
-    /// Lookup a possibly constant expression from a `ExprKind::Path`.
-    fn fetch_path(&mut self, qpath: &QPath<'_>, id: HirId, ty: Ty<'tcx>) -> Option<Constant> {
-        let res = self.typeck_results.qpath_res(qpath, id);
-        match res {
-            Res::Def(DefKind::Const | DefKind::AssocConst, def_id) => {
-                let substs = self.typeck_results.node_substs(id);
-                let substs = if self.substs.is_empty() {
-                    substs
-                } else {
-                    substs.subst(self.lcx.tcx, self.substs)
-                };
-
-                let result = self
-                    .lcx
-                    .tcx
-                    .const_eval_resolve(
-                        self.param_env,
-                        ty::WithOptConstParam::unknown(def_id),
-                        substs,
-                        None,
-                        None,
-                    )
-                    .ok()
-                    .map(|val| rustc_middle::ty::Const::from_value(self.lcx.tcx, val, ty))?;
-                let result = miri_to_const(&result);
-                if result.is_some() {
-                    self.needed_resolution = true;
-                }
-                result
-            },
-            // FIXME: cover all usable cases.
-            _ => None,
-        }
-    }
-
-    fn index(&mut self, lhs: &'_ Expr<'_>, index: &'_ Expr<'_>) -> Option<Constant> {
-        let lhs = self.expr(lhs);
-        let index = self.expr(index);
-
-        match (lhs, index) {
-            (Some(Constant::Vec(vec)), Some(Constant::Int(index))) => match vec.get(index as usize) {
-                Some(Constant::F32(x)) => Some(Constant::F32(*x)),
-                Some(Constant::F64(x)) => Some(Constant::F64(*x)),
-                _ => None,
-            },
-            (Some(Constant::Vec(vec)), _) => {
-                if !vec.is_empty() && vec.iter().all(|x| *x == vec[0]) {
-                    match vec.get(0) {
-                        Some(Constant::F32(x)) => Some(Constant::F32(*x)),
-                        Some(Constant::F64(x)) => Some(Constant::F64(*x)),
-                        _ => None,
-                    }
-                } else {
-                    None
-                }
-            },
-            _ => None,
-        }
-    }
-
-    /// A block can only yield a constant if it only has one constant expression.
-    fn block(&mut self, block: &Block<'_>) -> Option<Constant> {
-        if block.stmts.is_empty() {
-            block.expr.as_ref().and_then(|b| self.expr(b))
-        } else {
-            None
-        }
-    }
-
-    fn ifthenelse(&mut self, cond: &Expr<'_>, then: &Expr<'_>, otherwise: Option<&Expr<'_>>) -> Option<Constant> {
-        if let Some(Constant::Bool(b)) = self.expr(cond) {
-            if b {
-                self.expr(&*then)
-            } else {
-                otherwise.as_ref().and_then(|expr| self.expr(expr))
-            }
-        } else {
-            None
-        }
-    }
-
-    fn binop(&mut self, op: BinOp, left: &Expr<'_>, right: &Expr<'_>) -> Option<Constant> {
-        let l = self.expr(left)?;
-        let r = self.expr(right);
-        match (l, r) {
-            (Constant::Int(l), Some(Constant::Int(r))) => match *self.typeck_results.expr_ty_opt(left)?.kind() {
-                ty::Int(ity) => {
-                    let l = sext(self.lcx.tcx, l, ity);
-                    let r = sext(self.lcx.tcx, r, ity);
-                    let zext = |n: i128| Constant::Int(unsext(self.lcx.tcx, n, ity));
-                    match op.node {
-                        BinOpKind::Add => l.checked_add(r).map(zext),
-                        BinOpKind::Sub => l.checked_sub(r).map(zext),
-                        BinOpKind::Mul => l.checked_mul(r).map(zext),
-                        BinOpKind::Div if r != 0 => l.checked_div(r).map(zext),
-                        BinOpKind::Rem if r != 0 => l.checked_rem(r).map(zext),
-                        BinOpKind::Shr => l.checked_shr(r.try_into().expect("invalid shift")).map(zext),
-                        BinOpKind::Shl => l.checked_shl(r.try_into().expect("invalid shift")).map(zext),
-                        BinOpKind::BitXor => Some(zext(l ^ r)),
-                        BinOpKind::BitOr => Some(zext(l | r)),
-                        BinOpKind::BitAnd => Some(zext(l & r)),
-                        BinOpKind::Eq => Some(Constant::Bool(l == r)),
-                        BinOpKind::Ne => Some(Constant::Bool(l != r)),
-                        BinOpKind::Lt => Some(Constant::Bool(l < r)),
-                        BinOpKind::Le => Some(Constant::Bool(l <= r)),
-                        BinOpKind::Ge => Some(Constant::Bool(l >= r)),
-                        BinOpKind::Gt => Some(Constant::Bool(l > r)),
-                        _ => None,
-                    }
-                },
-                ty::Uint(_) => match op.node {
-                    BinOpKind::Add => l.checked_add(r).map(Constant::Int),
-                    BinOpKind::Sub => l.checked_sub(r).map(Constant::Int),
-                    BinOpKind::Mul => l.checked_mul(r).map(Constant::Int),
-                    BinOpKind::Div => l.checked_div(r).map(Constant::Int),
-                    BinOpKind::Rem => l.checked_rem(r).map(Constant::Int),
-                    BinOpKind::Shr => l.checked_shr(r.try_into().expect("shift too large")).map(Constant::Int),
-                    BinOpKind::Shl => l.checked_shl(r.try_into().expect("shift too large")).map(Constant::Int),
-                    BinOpKind::BitXor => Some(Constant::Int(l ^ r)),
-                    BinOpKind::BitOr => Some(Constant::Int(l | r)),
-                    BinOpKind::BitAnd => Some(Constant::Int(l & r)),
-                    BinOpKind::Eq => Some(Constant::Bool(l == r)),
-                    BinOpKind::Ne => Some(Constant::Bool(l != r)),
-                    BinOpKind::Lt => Some(Constant::Bool(l < r)),
-                    BinOpKind::Le => Some(Constant::Bool(l <= r)),
-                    BinOpKind::Ge => Some(Constant::Bool(l >= r)),
-                    BinOpKind::Gt => Some(Constant::Bool(l > r)),
-                    _ => None,
-                },
-                _ => None,
-            },
-            (Constant::F32(l), Some(Constant::F32(r))) => match op.node {
-                BinOpKind::Add => Some(Constant::F32(l + r)),
-                BinOpKind::Sub => Some(Constant::F32(l - r)),
-                BinOpKind::Mul => Some(Constant::F32(l * r)),
-                BinOpKind::Div => Some(Constant::F32(l / r)),
-                BinOpKind::Rem => Some(Constant::F32(l % r)),
-                BinOpKind::Eq => Some(Constant::Bool(l == r)),
-                BinOpKind::Ne => Some(Constant::Bool(l != r)),
-                BinOpKind::Lt => Some(Constant::Bool(l < r)),
-                BinOpKind::Le => Some(Constant::Bool(l <= r)),
-                BinOpKind::Ge => Some(Constant::Bool(l >= r)),
-                BinOpKind::Gt => Some(Constant::Bool(l > r)),
-                _ => None,
-            },
-            (Constant::F64(l), Some(Constant::F64(r))) => match op.node {
-                BinOpKind::Add => Some(Constant::F64(l + r)),
-                BinOpKind::Sub => Some(Constant::F64(l - r)),
-                BinOpKind::Mul => Some(Constant::F64(l * r)),
-                BinOpKind::Div => Some(Constant::F64(l / r)),
-                BinOpKind::Rem => Some(Constant::F64(l % r)),
-                BinOpKind::Eq => Some(Constant::Bool(l == r)),
-                BinOpKind::Ne => Some(Constant::Bool(l != r)),
-                BinOpKind::Lt => Some(Constant::Bool(l < r)),
-                BinOpKind::Le => Some(Constant::Bool(l <= r)),
-                BinOpKind::Ge => Some(Constant::Bool(l >= r)),
-                BinOpKind::Gt => Some(Constant::Bool(l > r)),
-                _ => None,
-            },
-            (l, r) => match (op.node, l, r) {
-                (BinOpKind::And, Constant::Bool(false), _) => Some(Constant::Bool(false)),
-                (BinOpKind::Or, Constant::Bool(true), _) => Some(Constant::Bool(true)),
-                (BinOpKind::And, Constant::Bool(true), Some(r)) | (BinOpKind::Or, Constant::Bool(false), Some(r)) => {
-                    Some(r)
-                },
-                (BinOpKind::BitXor, Constant::Bool(l), Some(Constant::Bool(r))) => Some(Constant::Bool(l ^ r)),
-                (BinOpKind::BitAnd, Constant::Bool(l), Some(Constant::Bool(r))) => Some(Constant::Bool(l & r)),
-                (BinOpKind::BitOr, Constant::Bool(l), Some(Constant::Bool(r))) => Some(Constant::Bool(l | r)),
-                _ => None,
-            },
-        }
-    }
-}
-
-pub fn miri_to_const(result: &ty::Const<'_>) -> Option<Constant> {
-    use rustc_middle::mir::interpret::ConstValue;
-    match result.val {
-        ty::ConstKind::Value(ConstValue::Scalar(Scalar::Int(int))) => {
-            match result.ty.kind() {
-                ty::Bool => Some(Constant::Bool(int == ScalarInt::TRUE)),
-                ty::Uint(_) | ty::Int(_) => Some(Constant::Int(int.assert_bits(int.size()))),
-                ty::Float(FloatTy::F32) => Some(Constant::F32(f32::from_bits(
-                    int.try_into().expect("invalid f32 bit representation"),
-                ))),
-                ty::Float(FloatTy::F64) => Some(Constant::F64(f64::from_bits(
-                    int.try_into().expect("invalid f64 bit representation"),
-                ))),
-                ty::RawPtr(type_and_mut) => {
-                    if let ty::Uint(_) = type_and_mut.ty.kind() {
-                        return Some(Constant::RawPtr(int.assert_bits(int.size())));
-                    }
-                    None
-                },
-                // FIXME: implement other conversions.
-                _ => None,
-            }
-        },
-        ty::ConstKind::Value(ConstValue::Slice { data, start, end }) => match result.ty.kind() {
-            ty::Ref(_, tam, _) => match tam.kind() {
-                ty::Str => String::from_utf8(
-                    data.inspect_with_uninit_and_ptr_outside_interpreter(start..end)
-                        .to_owned(),
-                )
-                .ok()
-                .map(Constant::Str),
-                _ => None,
-            },
-            _ => None,
-        },
-        ty::ConstKind::Value(ConstValue::ByRef { alloc, offset: _ }) => match result.ty.kind() {
-            ty::Array(sub_type, len) => match sub_type.kind() {
-                ty::Float(FloatTy::F32) => match miri_to_const(len) {
-                    Some(Constant::Int(len)) => alloc
-                        .inspect_with_uninit_and_ptr_outside_interpreter(0..(4 * len as usize))
-                        .to_owned()
-                        .chunks(4)
-                        .map(|chunk| {
-                            Some(Constant::F32(f32::from_le_bytes(
-                                chunk.try_into().expect("this shouldn't happen"),
-                            )))
-                        })
-                        .collect::<Option<Vec<Constant>>>()
-                        .map(Constant::Vec),
-                    _ => None,
-                },
-                ty::Float(FloatTy::F64) => match miri_to_const(len) {
-                    Some(Constant::Int(len)) => alloc
-                        .inspect_with_uninit_and_ptr_outside_interpreter(0..(8 * len as usize))
-                        .to_owned()
-                        .chunks(8)
-                        .map(|chunk| {
-                            Some(Constant::F64(f64::from_le_bytes(
-                                chunk.try_into().expect("this shouldn't happen"),
-                            )))
-                        })
-                        .collect::<Option<Vec<Constant>>>()
-                        .map(Constant::Vec),
-                    _ => None,
-                },
-                // FIXME: implement other array type conversions.
-                _ => None,
-            },
-            _ => None,
-        },
-        // FIXME: implement other conversions.
-        _ => None,
-    }
-}
+pub use clippy_utils::consts::*;
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index d66e3720be0..381e6f9369f 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -50,103 +50,23 @@ use rustc_data_structures::fx::FxHashSet;
 use rustc_lint::LintId;
 use rustc_session::Session;
 
-/// Macro used to declare a Clippy lint.
-///
-/// Every lint declaration consists of 4 parts:
-///
-/// 1. The documentation, which is used for the website
-/// 2. The `LINT_NAME`. See [lint naming][lint_naming] on lint naming conventions.
-/// 3. The `lint_level`, which is a mapping from *one* of our lint groups to `Allow`, `Warn` or
-///    `Deny`. The lint level here has nothing to do with what lint groups the lint is a part of.
-/// 4. The `description` that contains a short explanation on what's wrong with code where the
-///    lint is triggered.
-///
-/// Currently the categories `style`, `correctness`, `complexity` and `perf` are enabled by default.
-/// As said in the README.md of this repository, if the lint level mapping changes, please update
-/// README.md.
-///
-/// # Example
-///
-/// ```
-/// #![feature(rustc_private)]
-/// extern crate rustc_session;
-/// use rustc_session::declare_tool_lint;
-/// use clippy_lints::declare_clippy_lint;
-///
-/// declare_clippy_lint! {
-///     /// **What it does:** Checks for ... (describe what the lint matches).
-///     ///
-///     /// **Why is this bad?** Supply the reason for linting the code.
-///     ///
-///     /// **Known problems:** None. (Or describe where it could go wrong.)
-///     ///
-///     /// **Example:**
-///     ///
-///     /// ```rust
-///     /// // Bad
-///     /// Insert a short example of code that triggers the lint
-///     ///
-///     /// // Good
-///     /// Insert a short example of improved code that doesn't trigger the lint
-///     /// ```
-///     pub LINT_NAME,
-///     pedantic,
-///     "description"
-/// }
-/// ```
-/// [lint_naming]: https://rust-lang.github.io/rfcs/0344-conventions-galore.html#lints
 #[macro_export]
 macro_rules! declare_clippy_lint {
-    { $(#[$attr:meta])* pub $name:tt, style, $description:tt } => {
-        declare_tool_lint! {
-            $(#[$attr])* pub clippy::$name, Warn, $description, report_in_external_macro: true
-        }
-    };
-    { $(#[$attr:meta])* pub $name:tt, correctness, $description:tt } => {
-        declare_tool_lint! {
-            $(#[$attr])* pub clippy::$name, Deny, $description, report_in_external_macro: true
-        }
-    };
-    { $(#[$attr:meta])* pub $name:tt, complexity, $description:tt } => {
-        declare_tool_lint! {
-            $(#[$attr])* pub clippy::$name, Warn, $description, report_in_external_macro: true
-        }
-    };
-    { $(#[$attr:meta])* pub $name:tt, perf, $description:tt } => {
-        declare_tool_lint! {
-            $(#[$attr])* pub clippy::$name, Warn, $description, report_in_external_macro: true
-        }
-    };
-    { $(#[$attr:meta])* pub $name:tt, pedantic, $description:tt } => {
-        declare_tool_lint! {
-            $(#[$attr])* pub clippy::$name, Allow, $description, report_in_external_macro: true
-        }
-    };
-    { $(#[$attr:meta])* pub $name:tt, restriction, $description:tt } => {
-        declare_tool_lint! {
-            $(#[$attr])* pub clippy::$name, Allow, $description, report_in_external_macro: true
-        }
-    };
-    { $(#[$attr:meta])* pub $name:tt, cargo, $description:tt } => {
-        declare_tool_lint! {
-            $(#[$attr])* pub clippy::$name, Allow, $description, report_in_external_macro: true
-        }
-    };
-    { $(#[$attr:meta])* pub $name:tt, nursery, $description:tt } => {
-        declare_tool_lint! {
-            $(#[$attr])* pub clippy::$name, Allow, $description, report_in_external_macro: true
-        }
-    };
-    { $(#[$attr:meta])* pub $name:tt, internal, $description:tt } => {
-        declare_tool_lint! {
-            $(#[$attr])* pub clippy::$name, Allow, $description, report_in_external_macro: true
-        }
-    };
-    { $(#[$attr:meta])* pub $name:tt, internal_warn, $description:tt } => {
-        declare_tool_lint! {
-            $(#[$attr])* pub clippy::$name, Warn, $description, report_in_external_macro: true
-        }
-    };
+    ( $($x:tt)* ) => { clippy_utils::declare_clippy_lint!($($x)*); }
+}
+
+#[macro_export]
+macro_rules! sym {
+    ( $($x:tt)* ) => { clippy_utils::sym!($($x)*); }
+}
+
+#[macro_export]
+macro_rules! unwrap_cargo_metadata {
+    ( $($x:tt)* ) => { clippy_utils::unwrap_cargo_metadata!($($x)*); }
+}
+
+macro_rules! extract_msrv_attr {
+    ( $($x:tt)* ) => { clippy_utils::extract_msrv_attr!($($x)*); }
 }
 
 mod consts;
diff --git a/clippy_lints/src/utils.rs b/clippy_lints/src/utils.rs
new file mode 100644
index 00000000000..bf54e39769c
--- /dev/null
+++ b/clippy_lints/src/utils.rs
@@ -0,0 +1 @@
+pub use clippy_utils::*;
diff --git a/clippy_lints/src/utils/ast_utils.rs b/clippy_lints/src/utils/ast_utils.rs
deleted file mode 100644
index 44eb3968ae7..00000000000
--- a/clippy_lints/src/utils/ast_utils.rs
+++ /dev/null
@@ -1,562 +0,0 @@
-//! Utilities for manipulating and extracting information from `rustc_ast::ast`.
-//!
-//! - The `eq_foobar` functions test for semantic equality but ignores `NodeId`s and `Span`s.
-
-#![allow(clippy::similar_names, clippy::wildcard_imports, clippy::enum_glob_use)]
-
-use crate::utils::{both, over};
-use rustc_ast::ptr::P;
-use rustc_ast::{self as ast, *};
-use rustc_span::symbol::Ident;
-use std::mem;
-
-pub mod ident_iter;
-pub use ident_iter::IdentIter;
-
-pub fn is_useless_with_eq_exprs(kind: BinOpKind) -> bool {
-    use BinOpKind::*;
-    matches!(
-        kind,
-        Sub | Div | Eq | Lt | Le | Gt | Ge | Ne | And | Or | BitXor | BitAnd | BitOr
-    )
-}
-
-/// Checks if each element in the first slice is contained within the latter as per `eq_fn`.
-pub fn unordered_over<X>(left: &[X], right: &[X], mut eq_fn: impl FnMut(&X, &X) -> bool) -> bool {
-    left.len() == right.len() && left.iter().all(|l| right.iter().any(|r| eq_fn(l, r)))
-}
-
-pub fn eq_id(l: Ident, r: Ident) -> bool {
-    l.name == r.name
-}
-
-pub fn eq_pat(l: &Pat, r: &Pat) -> bool {
-    use PatKind::*;
-    match (&l.kind, &r.kind) {
-        (Paren(l), _) => eq_pat(l, r),
-        (_, Paren(r)) => eq_pat(l, r),
-        (Wild, Wild) | (Rest, Rest) => true,
-        (Lit(l), Lit(r)) => eq_expr(l, r),
-        (Ident(b1, i1, s1), Ident(b2, i2, s2)) => b1 == b2 && eq_id(*i1, *i2) && both(s1, s2, |l, r| eq_pat(l, r)),
-        (Range(lf, lt, le), Range(rf, rt, re)) => {
-            eq_expr_opt(lf, rf) && eq_expr_opt(lt, rt) && eq_range_end(&le.node, &re.node)
-        },
-        (Box(l), Box(r))
-        | (Ref(l, Mutability::Not), Ref(r, Mutability::Not))
-        | (Ref(l, Mutability::Mut), Ref(r, Mutability::Mut)) => eq_pat(l, r),
-        (Tuple(l), Tuple(r)) | (Slice(l), Slice(r)) => over(l, r, |l, r| eq_pat(l, r)),
-        (Path(lq, lp), Path(rq, rp)) => both(lq, rq, |l, r| eq_qself(l, r)) && eq_path(lp, rp),
-        (TupleStruct(lp, lfs), TupleStruct(rp, rfs)) => eq_path(lp, rp) && over(lfs, rfs, |l, r| eq_pat(l, r)),
-        (Struct(lp, lfs, lr), Struct(rp, rfs, rr)) => {
-            lr == rr && eq_path(lp, rp) && unordered_over(lfs, rfs, |lf, rf| eq_field_pat(lf, rf))
-        },
-        (Or(ls), Or(rs)) => unordered_over(ls, rs, |l, r| eq_pat(l, r)),
-        (MacCall(l), MacCall(r)) => eq_mac_call(l, r),
-        _ => false,
-    }
-}
-
-pub fn eq_range_end(l: &RangeEnd, r: &RangeEnd) -> bool {
-    match (l, r) {
-        (RangeEnd::Excluded, RangeEnd::Excluded) => true,
-        (RangeEnd::Included(l), RangeEnd::Included(r)) => {
-            matches!(l, RangeSyntax::DotDotEq) == matches!(r, RangeSyntax::DotDotEq)
-        },
-        _ => false,
-    }
-}
-
-pub fn eq_field_pat(l: &FieldPat, r: &FieldPat) -> bool {
-    l.is_placeholder == r.is_placeholder
-        && eq_id(l.ident, r.ident)
-        && eq_pat(&l.pat, &r.pat)
-        && over(&l.attrs, &r.attrs, |l, r| eq_attr(l, r))
-}
-
-pub fn eq_qself(l: &QSelf, r: &QSelf) -> bool {
-    l.position == r.position && eq_ty(&l.ty, &r.ty)
-}
-
-pub fn eq_path(l: &Path, r: &Path) -> bool {
-    over(&l.segments, &r.segments, |l, r| eq_path_seg(l, r))
-}
-
-pub fn eq_path_seg(l: &PathSegment, r: &PathSegment) -> bool {
-    eq_id(l.ident, r.ident) && both(&l.args, &r.args, |l, r| eq_generic_args(l, r))
-}
-
-pub fn eq_generic_args(l: &GenericArgs, r: &GenericArgs) -> bool {
-    match (l, r) {
-        (GenericArgs::AngleBracketed(l), GenericArgs::AngleBracketed(r)) => {
-            over(&l.args, &r.args, |l, r| eq_angle_arg(l, r))
-        },
-        (GenericArgs::Parenthesized(l), GenericArgs::Parenthesized(r)) => {
-            over(&l.inputs, &r.inputs, |l, r| eq_ty(l, r)) && eq_fn_ret_ty(&l.output, &r.output)
-        },
-        _ => false,
-    }
-}
-
-pub fn eq_angle_arg(l: &AngleBracketedArg, r: &AngleBracketedArg) -> bool {
-    match (l, r) {
-        (AngleBracketedArg::Arg(l), AngleBracketedArg::Arg(r)) => eq_generic_arg(l, r),
-        (AngleBracketedArg::Constraint(l), AngleBracketedArg::Constraint(r)) => eq_assoc_constraint(l, r),
-        _ => false,
-    }
-}
-
-pub fn eq_generic_arg(l: &GenericArg, r: &GenericArg) -> bool {
-    match (l, r) {
-        (GenericArg::Lifetime(l), GenericArg::Lifetime(r)) => eq_id(l.ident, r.ident),
-        (GenericArg::Type(l), GenericArg::Type(r)) => eq_ty(l, r),
-        (GenericArg::Const(l), GenericArg::Const(r)) => eq_expr(&l.value, &r.value),
-        _ => false,
-    }
-}
-
-pub fn eq_expr_opt(l: &Option<P<Expr>>, r: &Option<P<Expr>>) -> bool {
-    both(l, r, |l, r| eq_expr(l, r))
-}
-
-pub fn eq_struct_rest(l: &StructRest, r: &StructRest) -> bool {
-    match (l, r) {
-        (StructRest::Base(lb), StructRest::Base(rb)) => eq_expr(lb, rb),
-        (StructRest::Rest(_), StructRest::Rest(_)) | (StructRest::None, StructRest::None) => true,
-        _ => false,
-    }
-}
-
-pub fn eq_expr(l: &Expr, r: &Expr) -> bool {
-    use ExprKind::*;
-    if !over(&l.attrs, &r.attrs, |l, r| eq_attr(l, r)) {
-        return false;
-    }
-    match (&l.kind, &r.kind) {
-        (Paren(l), _) => eq_expr(l, r),
-        (_, Paren(r)) => eq_expr(l, r),
-        (Err, Err) => true,
-        (Box(l), Box(r)) | (Try(l), Try(r)) | (Await(l), Await(r)) => eq_expr(l, r),
-        (Array(l), Array(r)) | (Tup(l), Tup(r)) => over(l, r, |l, r| eq_expr(l, r)),
-        (Repeat(le, ls), Repeat(re, rs)) => eq_expr(le, re) && eq_expr(&ls.value, &rs.value),
-        (Call(lc, la), Call(rc, ra)) => eq_expr(lc, rc) && over(la, ra, |l, r| eq_expr(l, r)),
-        (MethodCall(lc, la, _), MethodCall(rc, ra, _)) => eq_path_seg(lc, rc) && over(la, ra, |l, r| eq_expr(l, r)),
-        (Binary(lo, ll, lr), Binary(ro, rl, rr)) => lo.node == ro.node && eq_expr(ll, rl) && eq_expr(lr, rr),
-        (Unary(lo, l), Unary(ro, r)) => mem::discriminant(lo) == mem::discriminant(ro) && eq_expr(l, r),
-        (Lit(l), Lit(r)) => l.kind == r.kind,
-        (Cast(l, lt), Cast(r, rt)) | (Type(l, lt), Type(r, rt)) => eq_expr(l, r) && eq_ty(lt, rt),
-        (Let(lp, le), Let(rp, re)) => eq_pat(lp, rp) && eq_expr(le, re),
-        (If(lc, lt, le), If(rc, rt, re)) => eq_expr(lc, rc) && eq_block(lt, rt) && eq_expr_opt(le, re),
-        (While(lc, lt, ll), While(rc, rt, rl)) => eq_label(ll, rl) && eq_expr(lc, rc) && eq_block(lt, rt),
-        (ForLoop(lp, li, lt, ll), ForLoop(rp, ri, rt, rl)) => {
-            eq_label(ll, rl) && eq_pat(lp, rp) && eq_expr(li, ri) && eq_block(lt, rt)
-        },
-        (Loop(lt, ll), Loop(rt, rl)) => eq_label(ll, rl) && eq_block(lt, rt),
-        (Block(lb, ll), Block(rb, rl)) => eq_label(ll, rl) && eq_block(lb, rb),
-        (TryBlock(l), TryBlock(r)) => eq_block(l, r),
-        (Yield(l), Yield(r)) | (Ret(l), Ret(r)) => eq_expr_opt(l, r),
-        (Break(ll, le), Break(rl, re)) => eq_label(ll, rl) && eq_expr_opt(le, re),
-        (Continue(ll), Continue(rl)) => eq_label(ll, rl),
-        (Assign(l1, l2, _), Assign(r1, r2, _)) | (Index(l1, l2), Index(r1, r2)) => eq_expr(l1, r1) && eq_expr(l2, r2),
-        (AssignOp(lo, lp, lv), AssignOp(ro, rp, rv)) => lo.node == ro.node && eq_expr(lp, rp) && eq_expr(lv, rv),
-        (Field(lp, lf), Field(rp, rf)) => eq_id(*lf, *rf) && eq_expr(lp, rp),
-        (Match(ls, la), Match(rs, ra)) => eq_expr(ls, rs) && over(la, ra, |l, r| eq_arm(l, r)),
-        (Closure(lc, la, lm, lf, lb, _), Closure(rc, ra, rm, rf, rb, _)) => {
-            lc == rc && la.is_async() == ra.is_async() && lm == rm && eq_fn_decl(lf, rf) && eq_expr(lb, rb)
-        },
-        (Async(lc, _, lb), Async(rc, _, rb)) => lc == rc && eq_block(lb, rb),
-        (Range(lf, lt, ll), Range(rf, rt, rl)) => ll == rl && eq_expr_opt(lf, rf) && eq_expr_opt(lt, rt),
-        (AddrOf(lbk, lm, le), AddrOf(rbk, rm, re)) => lbk == rbk && lm == rm && eq_expr(le, re),
-        (Path(lq, lp), Path(rq, rp)) => both(lq, rq, |l, r| eq_qself(l, r)) && eq_path(lp, rp),
-        (MacCall(l), MacCall(r)) => eq_mac_call(l, r),
-        (Struct(lp, lfs, lb), Struct(rp, rfs, rb)) => {
-            eq_path(lp, rp) && eq_struct_rest(lb, rb) && unordered_over(lfs, rfs, |l, r| eq_field(l, r))
-        },
-        _ => false,
-    }
-}
-
-pub fn eq_field(l: &Field, r: &Field) -> bool {
-    l.is_placeholder == r.is_placeholder
-        && eq_id(l.ident, r.ident)
-        && eq_expr(&l.expr, &r.expr)
-        && over(&l.attrs, &r.attrs, |l, r| eq_attr(l, r))
-}
-
-pub fn eq_arm(l: &Arm, r: &Arm) -> bool {
-    l.is_placeholder == r.is_placeholder
-        && eq_pat(&l.pat, &r.pat)
-        && eq_expr(&l.body, &r.body)
-        && eq_expr_opt(&l.guard, &r.guard)
-        && over(&l.attrs, &r.attrs, |l, r| eq_attr(l, r))
-}
-
-pub fn eq_label(l: &Option<Label>, r: &Option<Label>) -> bool {
-    both(l, r, |l, r| eq_id(l.ident, r.ident))
-}
-
-pub fn eq_block(l: &Block, r: &Block) -> bool {
-    l.rules == r.rules && over(&l.stmts, &r.stmts, |l, r| eq_stmt(l, r))
-}
-
-pub fn eq_stmt(l: &Stmt, r: &Stmt) -> bool {
-    use StmtKind::*;
-    match (&l.kind, &r.kind) {
-        (Local(l), Local(r)) => {
-            eq_pat(&l.pat, &r.pat)
-                && both(&l.ty, &r.ty, |l, r| eq_ty(l, r))
-                && eq_expr_opt(&l.init, &r.init)
-                && over(&l.attrs, &r.attrs, |l, r| eq_attr(l, r))
-        },
-        (Item(l), Item(r)) => eq_item(l, r, eq_item_kind),
-        (Expr(l), Expr(r)) | (Semi(l), Semi(r)) => eq_expr(l, r),
-        (Empty, Empty) => true,
-        (MacCall(l), MacCall(r)) => {
-            l.style == r.style && eq_mac_call(&l.mac, &r.mac) && over(&l.attrs, &r.attrs, |l, r| eq_attr(l, r))
-        },
-        _ => false,
-    }
-}
-
-pub fn eq_item<K>(l: &Item<K>, r: &Item<K>, mut eq_kind: impl FnMut(&K, &K) -> bool) -> bool {
-    eq_id(l.ident, r.ident)
-        && over(&l.attrs, &r.attrs, |l, r| eq_attr(l, r))
-        && eq_vis(&l.vis, &r.vis)
-        && eq_kind(&l.kind, &r.kind)
-}
-
-pub fn eq_item_kind(l: &ItemKind, r: &ItemKind) -> bool {
-    use ItemKind::*;
-    match (l, r) {
-        (ExternCrate(l), ExternCrate(r)) => l == r,
-        (Use(l), Use(r)) => eq_use_tree(l, r),
-        (Static(lt, lm, le), Static(rt, rm, re)) => lm == rm && eq_ty(lt, rt) && eq_expr_opt(le, re),
-        (Const(ld, lt, le), Const(rd, rt, re)) => eq_defaultness(*ld, *rd) && eq_ty(lt, rt) && eq_expr_opt(le, re),
-        (Fn(box FnKind(ld, lf, lg, lb)), Fn(box FnKind(rd, rf, rg, rb))) => {
-            eq_defaultness(*ld, *rd) && eq_fn_sig(lf, rf) && eq_generics(lg, rg) && both(lb, rb, |l, r| eq_block(l, r))
-        },
-        (Mod(l), Mod(r)) => l.inline == r.inline && over(&l.items, &r.items, |l, r| eq_item(l, r, eq_item_kind)),
-        (ForeignMod(l), ForeignMod(r)) => {
-            both(&l.abi, &r.abi, |l, r| eq_str_lit(l, r))
-                && over(&l.items, &r.items, |l, r| eq_item(l, r, eq_foreign_item_kind))
-        },
-        (TyAlias(box TyAliasKind(ld, lg, lb, lt)), TyAlias(box TyAliasKind(rd, rg, rb, rt))) => {
-            eq_defaultness(*ld, *rd)
-                && eq_generics(lg, rg)
-                && over(lb, rb, |l, r| eq_generic_bound(l, r))
-                && both(lt, rt, |l, r| eq_ty(l, r))
-        },
-        (Enum(le, lg), Enum(re, rg)) => {
-            over(&le.variants, &re.variants, |l, r| eq_variant(l, r)) && eq_generics(lg, rg)
-        },
-        (Struct(lv, lg), Struct(rv, rg)) | (Union(lv, lg), Union(rv, rg)) => {
-            eq_variant_data(lv, rv) && eq_generics(lg, rg)
-        },
-        (Trait(box TraitKind(la, lu, lg, lb, li)), Trait(box TraitKind(ra, ru, rg, rb, ri))) => {
-            la == ra
-                && matches!(lu, Unsafe::No) == matches!(ru, Unsafe::No)
-                && eq_generics(lg, rg)
-                && over(lb, rb, |l, r| eq_generic_bound(l, r))
-                && over(li, ri, |l, r| eq_item(l, r, eq_assoc_item_kind))
-        },
-        (TraitAlias(lg, lb), TraitAlias(rg, rb)) => eq_generics(lg, rg) && over(lb, rb, |l, r| eq_generic_bound(l, r)),
-        (
-            Impl(box ImplKind {
-                unsafety: lu,
-                polarity: lp,
-                defaultness: ld,
-                constness: lc,
-                generics: lg,
-                of_trait: lot,
-                self_ty: lst,
-                items: li,
-            }),
-            Impl(box ImplKind {
-                unsafety: ru,
-                polarity: rp,
-                defaultness: rd,
-                constness: rc,
-                generics: rg,
-                of_trait: rot,
-                self_ty: rst,
-                items: ri,
-            }),
-        ) => {
-            matches!(lu, Unsafe::No) == matches!(ru, Unsafe::No)
-                && matches!(lp, ImplPolarity::Positive) == matches!(rp, ImplPolarity::Positive)
-                && eq_defaultness(*ld, *rd)
-                && matches!(lc, ast::Const::No) == matches!(rc, ast::Const::No)
-                && eq_generics(lg, rg)
-                && both(lot, rot, |l, r| eq_path(&l.path, &r.path))
-                && eq_ty(lst, rst)
-                && over(li, ri, |l, r| eq_item(l, r, eq_assoc_item_kind))
-        },
-        (MacCall(l), MacCall(r)) => eq_mac_call(l, r),
-        (MacroDef(l), MacroDef(r)) => l.macro_rules == r.macro_rules && eq_mac_args(&l.body, &r.body),
-        _ => false,
-    }
-}
-
-pub fn eq_foreign_item_kind(l: &ForeignItemKind, r: &ForeignItemKind) -> bool {
-    use ForeignItemKind::*;
-    match (l, r) {
-        (Static(lt, lm, le), Static(rt, rm, re)) => lm == rm && eq_ty(lt, rt) && eq_expr_opt(le, re),
-        (Fn(box FnKind(ld, lf, lg, lb)), Fn(box FnKind(rd, rf, rg, rb))) => {
-            eq_defaultness(*ld, *rd) && eq_fn_sig(lf, rf) && eq_generics(lg, rg) && both(lb, rb, |l, r| eq_block(l, r))
-        },
-        (TyAlias(box TyAliasKind(ld, lg, lb, lt)), TyAlias(box TyAliasKind(rd, rg, rb, rt))) => {
-            eq_defaultness(*ld, *rd)
-                && eq_generics(lg, rg)
-                && over(lb, rb, |l, r| eq_generic_bound(l, r))
-                && both(lt, rt, |l, r| eq_ty(l, r))
-        },
-        (MacCall(l), MacCall(r)) => eq_mac_call(l, r),
-        _ => false,
-    }
-}
-
-pub fn eq_assoc_item_kind(l: &AssocItemKind, r: &AssocItemKind) -> bool {
-    use AssocItemKind::*;
-    match (l, r) {
-        (Const(ld, lt, le), Const(rd, rt, re)) => eq_defaultness(*ld, *rd) && eq_ty(lt, rt) && eq_expr_opt(le, re),
-        (Fn(box FnKind(ld, lf, lg, lb)), Fn(box FnKind(rd, rf, rg, rb))) => {
-            eq_defaultness(*ld, *rd) && eq_fn_sig(lf, rf) && eq_generics(lg, rg) && both(lb, rb, |l, r| eq_block(l, r))
-        },
-        (TyAlias(box TyAliasKind(ld, lg, lb, lt)), TyAlias(box TyAliasKind(rd, rg, rb, rt))) => {
-            eq_defaultness(*ld, *rd)
-                && eq_generics(lg, rg)
-                && over(lb, rb, |l, r| eq_generic_bound(l, r))
-                && both(lt, rt, |l, r| eq_ty(l, r))
-        },
-        (MacCall(l), MacCall(r)) => eq_mac_call(l, r),
-        _ => false,
-    }
-}
-
-pub fn eq_variant(l: &Variant, r: &Variant) -> bool {
-    l.is_placeholder == r.is_placeholder
-        && over(&l.attrs, &r.attrs, |l, r| eq_attr(l, r))
-        && eq_vis(&l.vis, &r.vis)
-        && eq_id(l.ident, r.ident)
-        && eq_variant_data(&l.data, &r.data)
-        && both(&l.disr_expr, &r.disr_expr, |l, r| eq_expr(&l.value, &r.value))
-}
-
-pub fn eq_variant_data(l: &VariantData, r: &VariantData) -> bool {
-    use VariantData::*;
-    match (l, r) {
-        (Unit(_), Unit(_)) => true,
-        (Struct(l, _), Struct(r, _)) | (Tuple(l, _), Tuple(r, _)) => over(l, r, |l, r| eq_struct_field(l, r)),
-        _ => false,
-    }
-}
-
-pub fn eq_struct_field(l: &StructField, r: &StructField) -> bool {
-    l.is_placeholder == r.is_placeholder
-        && over(&l.attrs, &r.attrs, |l, r| eq_attr(l, r))
-        && eq_vis(&l.vis, &r.vis)
-        && both(&l.ident, &r.ident, |l, r| eq_id(*l, *r))
-        && eq_ty(&l.ty, &r.ty)
-}
-
-pub fn eq_fn_sig(l: &FnSig, r: &FnSig) -> bool {
-    eq_fn_decl(&l.decl, &r.decl) && eq_fn_header(&l.header, &r.header)
-}
-
-pub fn eq_fn_header(l: &FnHeader, r: &FnHeader) -> bool {
-    matches!(l.unsafety, Unsafe::No) == matches!(r.unsafety, Unsafe::No)
-        && l.asyncness.is_async() == r.asyncness.is_async()
-        && matches!(l.constness, Const::No) == matches!(r.constness, Const::No)
-        && eq_ext(&l.ext, &r.ext)
-}
-
-pub fn eq_generics(l: &Generics, r: &Generics) -> bool {
-    over(&l.params, &r.params, |l, r| eq_generic_param(l, r))
-        && over(&l.where_clause.predicates, &r.where_clause.predicates, |l, r| {
-            eq_where_predicate(l, r)
-        })
-}
-
-pub fn eq_where_predicate(l: &WherePredicate, r: &WherePredicate) -> bool {
-    use WherePredicate::*;
-    match (l, r) {
-        (BoundPredicate(l), BoundPredicate(r)) => {
-            over(&l.bound_generic_params, &r.bound_generic_params, |l, r| {
-                eq_generic_param(l, r)
-            }) && eq_ty(&l.bounded_ty, &r.bounded_ty)
-                && over(&l.bounds, &r.bounds, |l, r| eq_generic_bound(l, r))
-        },
-        (RegionPredicate(l), RegionPredicate(r)) => {
-            eq_id(l.lifetime.ident, r.lifetime.ident) && over(&l.bounds, &r.bounds, |l, r| eq_generic_bound(l, r))
-        },
-        (EqPredicate(l), EqPredicate(r)) => eq_ty(&l.lhs_ty, &r.lhs_ty) && eq_ty(&l.rhs_ty, &r.rhs_ty),
-        _ => false,
-    }
-}
-
-pub fn eq_use_tree(l: &UseTree, r: &UseTree) -> bool {
-    eq_path(&l.prefix, &r.prefix) && eq_use_tree_kind(&l.kind, &r.kind)
-}
-
-pub fn eq_use_tree_kind(l: &UseTreeKind, r: &UseTreeKind) -> bool {
-    use UseTreeKind::*;
-    match (l, r) {
-        (Glob, Glob) => true,
-        (Simple(l, _, _), Simple(r, _, _)) => both(l, r, |l, r| eq_id(*l, *r)),
-        (Nested(l), Nested(r)) => over(l, r, |(l, _), (r, _)| eq_use_tree(l, r)),
-        _ => false,
-    }
-}
-
-pub fn eq_anon_const(l: &AnonConst, r: &AnonConst) -> bool {
-    eq_expr(&l.value, &r.value)
-}
-
-pub fn eq_defaultness(l: Defaultness, r: Defaultness) -> bool {
-    matches!(
-        (l, r),
-        (Defaultness::Final, Defaultness::Final) | (Defaultness::Default(_), Defaultness::Default(_))
-    )
-}
-
-pub fn eq_vis(l: &Visibility, r: &Visibility) -> bool {
-    use VisibilityKind::*;
-    match (&l.kind, &r.kind) {
-        (Public, Public) | (Inherited, Inherited) | (Crate(_), Crate(_)) => true,
-        (Restricted { path: l, .. }, Restricted { path: r, .. }) => eq_path(l, r),
-        _ => false,
-    }
-}
-
-pub fn eq_fn_decl(l: &FnDecl, r: &FnDecl) -> bool {
-    eq_fn_ret_ty(&l.output, &r.output)
-        && over(&l.inputs, &r.inputs, |l, r| {
-            l.is_placeholder == r.is_placeholder
-                && eq_pat(&l.pat, &r.pat)
-                && eq_ty(&l.ty, &r.ty)
-                && over(&l.attrs, &r.attrs, |l, r| eq_attr(l, r))
-        })
-}
-
-pub fn eq_fn_ret_ty(l: &FnRetTy, r: &FnRetTy) -> bool {
-    match (l, r) {
-        (FnRetTy::Default(_), FnRetTy::Default(_)) => true,
-        (FnRetTy::Ty(l), FnRetTy::Ty(r)) => eq_ty(l, r),
-        _ => false,
-    }
-}
-
-pub fn eq_ty(l: &Ty, r: &Ty) -> bool {
-    use TyKind::*;
-    match (&l.kind, &r.kind) {
-        (Paren(l), _) => eq_ty(l, r),
-        (_, Paren(r)) => eq_ty(l, r),
-        (Never, Never) | (Infer, Infer) | (ImplicitSelf, ImplicitSelf) | (Err, Err) | (CVarArgs, CVarArgs) => true,
-        (Slice(l), Slice(r)) => eq_ty(l, r),
-        (Array(le, ls), Array(re, rs)) => eq_ty(le, re) && eq_expr(&ls.value, &rs.value),
-        (Ptr(l), Ptr(r)) => l.mutbl == r.mutbl && eq_ty(&l.ty, &r.ty),
-        (Rptr(ll, l), Rptr(rl, r)) => {
-            both(ll, rl, |l, r| eq_id(l.ident, r.ident)) && l.mutbl == r.mutbl && eq_ty(&l.ty, &r.ty)
-        },
-        (BareFn(l), BareFn(r)) => {
-            l.unsafety == r.unsafety
-                && eq_ext(&l.ext, &r.ext)
-                && over(&l.generic_params, &r.generic_params, |l, r| eq_generic_param(l, r))
-                && eq_fn_decl(&l.decl, &r.decl)
-        },
-        (Tup(l), Tup(r)) => over(l, r, |l, r| eq_ty(l, r)),
-        (Path(lq, lp), Path(rq, rp)) => both(lq, rq, |l, r| eq_qself(l, r)) && eq_path(lp, rp),
-        (TraitObject(lg, ls), TraitObject(rg, rs)) => ls == rs && over(lg, rg, |l, r| eq_generic_bound(l, r)),
-        (ImplTrait(_, lg), ImplTrait(_, rg)) => over(lg, rg, |l, r| eq_generic_bound(l, r)),
-        (Typeof(l), Typeof(r)) => eq_expr(&l.value, &r.value),
-        (MacCall(l), MacCall(r)) => eq_mac_call(l, r),
-        _ => false,
-    }
-}
-
-pub fn eq_ext(l: &Extern, r: &Extern) -> bool {
-    use Extern::*;
-    match (l, r) {
-        (None, None) | (Implicit, Implicit) => true,
-        (Explicit(l), Explicit(r)) => eq_str_lit(l, r),
-        _ => false,
-    }
-}
-
-pub fn eq_str_lit(l: &StrLit, r: &StrLit) -> bool {
-    l.style == r.style && l.symbol == r.symbol && l.suffix == r.suffix
-}
-
-pub fn eq_poly_ref_trait(l: &PolyTraitRef, r: &PolyTraitRef) -> bool {
-    eq_path(&l.trait_ref.path, &r.trait_ref.path)
-        && over(&l.bound_generic_params, &r.bound_generic_params, |l, r| {
-            eq_generic_param(l, r)
-        })
-}
-
-pub fn eq_generic_param(l: &GenericParam, r: &GenericParam) -> bool {
-    use GenericParamKind::*;
-    l.is_placeholder == r.is_placeholder
-        && eq_id(l.ident, r.ident)
-        && over(&l.bounds, &r.bounds, |l, r| eq_generic_bound(l, r))
-        && match (&l.kind, &r.kind) {
-            (Lifetime, Lifetime) => true,
-            (Type { default: l }, Type { default: r }) => both(l, r, |l, r| eq_ty(l, r)),
-            (
-                Const {
-                    ty: lt,
-                    kw_span: _,
-                    default: ld,
-                },
-                Const {
-                    ty: rt,
-                    kw_span: _,
-                    default: rd,
-                },
-            ) => eq_ty(lt, rt) && both(ld, rd, |ld, rd| eq_anon_const(ld, rd)),
-            _ => false,
-        }
-        && over(&l.attrs, &r.attrs, |l, r| eq_attr(l, r))
-}
-
-pub fn eq_generic_bound(l: &GenericBound, r: &GenericBound) -> bool {
-    use GenericBound::*;
-    match (l, r) {
-        (Trait(ptr1, tbm1), Trait(ptr2, tbm2)) => tbm1 == tbm2 && eq_poly_ref_trait(ptr1, ptr2),
-        (Outlives(l), Outlives(r)) => eq_id(l.ident, r.ident),
-        _ => false,
-    }
-}
-
-pub fn eq_assoc_constraint(l: &AssocTyConstraint, r: &AssocTyConstraint) -> bool {
-    use AssocTyConstraintKind::*;
-    eq_id(l.ident, r.ident)
-        && match (&l.kind, &r.kind) {
-            (Equality { ty: l }, Equality { ty: r }) => eq_ty(l, r),
-            (Bound { bounds: l }, Bound { bounds: r }) => over(l, r, |l, r| eq_generic_bound(l, r)),
-            _ => false,
-        }
-}
-
-pub fn eq_mac_call(l: &MacCall, r: &MacCall) -> bool {
-    eq_path(&l.path, &r.path) && eq_mac_args(&l.args, &r.args)
-}
-
-pub fn eq_attr(l: &Attribute, r: &Attribute) -> bool {
-    use AttrKind::*;
-    l.style == r.style
-        && match (&l.kind, &r.kind) {
-            (DocComment(l1, l2), DocComment(r1, r2)) => l1 == r1 && l2 == r2,
-            (Normal(l, _), Normal(r, _)) => eq_path(&l.path, &r.path) && eq_mac_args(&l.args, &r.args),
-            _ => false,
-        }
-}
-
-pub fn eq_mac_args(l: &MacArgs, r: &MacArgs) -> bool {
-    use MacArgs::*;
-    match (l, r) {
-        (Empty, Empty) => true,
-        (Delimited(_, ld, lts), Delimited(_, rd, rts)) => ld == rd && lts.eq_unspanned(rts),
-        (Eq(_, lt), Eq(_, rt)) => lt.kind == rt.kind,
-        _ => false,
-    }
-}
diff --git a/clippy_lints/src/utils/ast_utils/ident_iter.rs b/clippy_lints/src/utils/ast_utils/ident_iter.rs
deleted file mode 100644
index eefcbabd835..00000000000
--- a/clippy_lints/src/utils/ast_utils/ident_iter.rs
+++ /dev/null
@@ -1,45 +0,0 @@
-use core::iter::FusedIterator;
-use rustc_ast::visit::{walk_attribute, walk_expr, Visitor};
-use rustc_ast::{Attribute, Expr};
-use rustc_span::symbol::Ident;
-
-pub struct IdentIter(std::vec::IntoIter<Ident>);
-
-impl Iterator for IdentIter {
-    type Item = Ident;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        self.0.next()
-    }
-}
-
-impl FusedIterator for IdentIter {}
-
-impl From<&Expr> for IdentIter {
-    fn from(expr: &Expr) -> Self {
-        let mut visitor = IdentCollector::default();
-
-        walk_expr(&mut visitor, expr);
-
-        IdentIter(visitor.0.into_iter())
-    }
-}
-
-impl From<&Attribute> for IdentIter {
-    fn from(attr: &Attribute) -> Self {
-        let mut visitor = IdentCollector::default();
-
-        walk_attribute(&mut visitor, attr);
-
-        IdentIter(visitor.0.into_iter())
-    }
-}
-
-#[derive(Default)]
-struct IdentCollector(Vec<Ident>);
-
-impl Visitor<'_> for IdentCollector {
-    fn visit_ident(&mut self, ident: Ident) {
-        self.0.push(ident);
-    }
-}
diff --git a/clippy_lints/src/utils/attrs.rs b/clippy_lints/src/utils/attrs.rs
deleted file mode 100644
index 8d28421d70d..00000000000
--- a/clippy_lints/src/utils/attrs.rs
+++ /dev/null
@@ -1,150 +0,0 @@
-use rustc_ast::ast;
-use rustc_errors::Applicability;
-use rustc_session::Session;
-use rustc_span::sym;
-use std::str::FromStr;
-
-/// Deprecation status of attributes known by Clippy.
-#[allow(dead_code)]
-pub enum DeprecationStatus {
-    /// Attribute is deprecated
-    Deprecated,
-    /// Attribute is deprecated and was replaced by the named attribute
-    Replaced(&'static str),
-    None,
-}
-
-pub const BUILTIN_ATTRIBUTES: &[(&str, DeprecationStatus)] = &[
-    ("author", DeprecationStatus::None),
-    ("cognitive_complexity", DeprecationStatus::None),
-    (
-        "cyclomatic_complexity",
-        DeprecationStatus::Replaced("cognitive_complexity"),
-    ),
-    ("dump", DeprecationStatus::None),
-    ("msrv", DeprecationStatus::None),
-];
-
-pub struct LimitStack {
-    stack: Vec<u64>,
-}
-
-impl Drop for LimitStack {
-    fn drop(&mut self) {
-        assert_eq!(self.stack.len(), 1);
-    }
-}
-
-impl LimitStack {
-    #[must_use]
-    pub fn new(limit: u64) -> Self {
-        Self { stack: vec![limit] }
-    }
-    pub fn limit(&self) -> u64 {
-        *self.stack.last().expect("there should always be a value in the stack")
-    }
-    pub fn push_attrs(&mut self, sess: &Session, attrs: &[ast::Attribute], name: &'static str) {
-        let stack = &mut self.stack;
-        parse_attrs(sess, attrs, name, |val| stack.push(val));
-    }
-    pub fn pop_attrs(&mut self, sess: &Session, attrs: &[ast::Attribute], name: &'static str) {
-        let stack = &mut self.stack;
-        parse_attrs(sess, attrs, name, |val| assert_eq!(stack.pop(), Some(val)));
-    }
-}
-
-pub fn get_attr<'a>(
-    sess: &'a Session,
-    attrs: &'a [ast::Attribute],
-    name: &'static str,
-) -> impl Iterator<Item = &'a ast::Attribute> {
-    attrs.iter().filter(move |attr| {
-        let attr = if let ast::AttrKind::Normal(ref attr, _) = attr.kind {
-            attr
-        } else {
-            return false;
-        };
-        let attr_segments = &attr.path.segments;
-        if attr_segments.len() == 2 && attr_segments[0].ident.name == sym::clippy {
-            BUILTIN_ATTRIBUTES
-                .iter()
-                .find_map(|&(builtin_name, ref deprecation_status)| {
-                    if attr_segments[1].ident.name.as_str() == builtin_name {
-                        Some(deprecation_status)
-                    } else {
-                        None
-                    }
-                })
-                .map_or_else(
-                    || {
-                        sess.span_err(attr_segments[1].ident.span, "usage of unknown attribute");
-                        false
-                    },
-                    |deprecation_status| {
-                        let mut diag =
-                            sess.struct_span_err(attr_segments[1].ident.span, "usage of deprecated attribute");
-                        match *deprecation_status {
-                            DeprecationStatus::Deprecated => {
-                                diag.emit();
-                                false
-                            },
-                            DeprecationStatus::Replaced(new_name) => {
-                                diag.span_suggestion(
-                                    attr_segments[1].ident.span,
-                                    "consider using",
-                                    new_name.to_string(),
-                                    Applicability::MachineApplicable,
-                                );
-                                diag.emit();
-                                false
-                            },
-                            DeprecationStatus::None => {
-                                diag.cancel();
-                                attr_segments[1].ident.name.as_str() == name
-                            },
-                        }
-                    },
-                )
-        } else {
-            false
-        }
-    })
-}
-
-fn parse_attrs<F: FnMut(u64)>(sess: &Session, attrs: &[ast::Attribute], name: &'static str, mut f: F) {
-    for attr in get_attr(sess, attrs, name) {
-        if let Some(ref value) = attr.value_str() {
-            if let Ok(value) = FromStr::from_str(&value.as_str()) {
-                f(value)
-            } else {
-                sess.span_err(attr.span, "not a number");
-            }
-        } else {
-            sess.span_err(attr.span, "bad clippy attribute");
-        }
-    }
-}
-
-pub fn get_unique_inner_attr(sess: &Session, attrs: &[ast::Attribute], name: &'static str) -> Option<ast::Attribute> {
-    let mut unique_attr = None;
-    for attr in get_attr(sess, attrs, name) {
-        match attr.style {
-            ast::AttrStyle::Inner if unique_attr.is_none() => unique_attr = Some(attr.clone()),
-            ast::AttrStyle::Inner => {
-                sess.struct_span_err(attr.span, &format!("`{}` is defined multiple times", name))
-                    .span_note(unique_attr.as_ref().unwrap().span, "first definition found here")
-                    .emit();
-            },
-            ast::AttrStyle::Outer => {
-                sess.span_err(attr.span, &format!("`{}` cannot be an outer attribute", name));
-            },
-        }
-    }
-    unique_attr
-}
-
-/// Return true if the attributes contain any of `proc_macro`,
-/// `proc_macro_derive` or `proc_macro_attribute`, false otherwise
-pub fn is_proc_macro(sess: &Session, attrs: &[ast::Attribute]) -> bool {
-    attrs.iter().any(|attr| sess.is_proc_macro_attr(attr))
-}
diff --git a/clippy_lints/src/utils/author.rs b/clippy_lints/src/utils/author.rs
deleted file mode 100644
index ca60d335262..00000000000
--- a/clippy_lints/src/utils/author.rs
+++ /dev/null
@@ -1,779 +0,0 @@
-//! A group of attributes that can be attached to Rust code in order
-//! to generate a clippy lint detecting said code automatically.
-
-use crate::utils::get_attr;
-use rustc_ast::ast::{Attribute, LitFloatType, LitKind};
-use rustc_ast::walk_list;
-use rustc_data_structures::fx::FxHashMap;
-use rustc_hir as hir;
-use rustc_hir::intravisit::{NestedVisitorMap, Visitor};
-use rustc_hir::{BindingAnnotation, Block, Expr, ExprKind, Pat, PatKind, QPath, Stmt, StmtKind, TyKind};
-use rustc_lint::{LateContext, LateLintPass, LintContext};
-use rustc_middle::hir::map::Map;
-use rustc_session::Session;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-
-declare_clippy_lint! {
-    /// **What it does:** Generates clippy code that detects the offending pattern
-    ///
-    /// **Example:**
-    /// ```rust,ignore
-    /// // ./tests/ui/my_lint.rs
-    /// fn foo() {
-    ///     // detect the following pattern
-    ///     #[clippy::author]
-    ///     if x == 42 {
-    ///         // but ignore everything from here on
-    ///         #![clippy::author = "ignore"]
-    ///     }
-    ///     ()
-    /// }
-    /// ```
-    ///
-    /// Running `TESTNAME=ui/my_lint cargo uitest` will produce
-    /// a `./tests/ui/new_lint.stdout` file with the generated code:
-    ///
-    /// ```rust,ignore
-    /// // ./tests/ui/new_lint.stdout
-    /// if_chain! {
-    ///     if let ExprKind::If(ref cond, ref then, None) = item.kind,
-    ///     if let ExprKind::Binary(BinOp::Eq, ref left, ref right) = cond.kind,
-    ///     if let ExprKind::Path(ref path) = left.kind,
-    ///     if let ExprKind::Lit(ref lit) = right.kind,
-    ///     if let LitKind::Int(42, _) = lit.node,
-    ///     then {
-    ///         // report your lint here
-    ///     }
-    /// }
-    /// ```
-    pub LINT_AUTHOR,
-    internal_warn,
-    "helper for writing lints"
-}
-
-declare_lint_pass!(Author => [LINT_AUTHOR]);
-
-fn prelude() {
-    println!("if_chain! {{");
-}
-
-fn done() {
-    println!("    then {{");
-    println!("        // report your lint here");
-    println!("    }}");
-    println!("}}");
-}
-
-impl<'tcx> LateLintPass<'tcx> for Author {
-    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) {
-        if !has_attr(cx.sess(), &item.attrs) {
-            return;
-        }
-        prelude();
-        PrintVisitor::new("item").visit_item(item);
-        done();
-    }
-
-    fn check_impl_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::ImplItem<'_>) {
-        if !has_attr(cx.sess(), &item.attrs) {
-            return;
-        }
-        prelude();
-        PrintVisitor::new("item").visit_impl_item(item);
-        done();
-    }
-
-    fn check_trait_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::TraitItem<'_>) {
-        if !has_attr(cx.sess(), &item.attrs) {
-            return;
-        }
-        prelude();
-        PrintVisitor::new("item").visit_trait_item(item);
-        done();
-    }
-
-    fn check_variant(&mut self, cx: &LateContext<'tcx>, var: &'tcx hir::Variant<'_>) {
-        if !has_attr(cx.sess(), &var.attrs) {
-            return;
-        }
-        prelude();
-        let parent_hir_id = cx.tcx.hir().get_parent_node(var.id);
-        PrintVisitor::new("var").visit_variant(var, &hir::Generics::empty(), parent_hir_id);
-        done();
-    }
-
-    fn check_struct_field(&mut self, cx: &LateContext<'tcx>, field: &'tcx hir::StructField<'_>) {
-        if !has_attr(cx.sess(), &field.attrs) {
-            return;
-        }
-        prelude();
-        PrintVisitor::new("field").visit_struct_field(field);
-        done();
-    }
-
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
-        if !has_attr(cx.sess(), &expr.attrs) {
-            return;
-        }
-        prelude();
-        PrintVisitor::new("expr").visit_expr(expr);
-        done();
-    }
-
-    fn check_arm(&mut self, cx: &LateContext<'tcx>, arm: &'tcx hir::Arm<'_>) {
-        if !has_attr(cx.sess(), &arm.attrs) {
-            return;
-        }
-        prelude();
-        PrintVisitor::new("arm").visit_arm(arm);
-        done();
-    }
-
-    fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx hir::Stmt<'_>) {
-        if !has_attr(cx.sess(), stmt.kind.attrs(|id| cx.tcx.hir().item(id.id))) {
-            return;
-        }
-        prelude();
-        PrintVisitor::new("stmt").visit_stmt(stmt);
-        done();
-    }
-
-    fn check_foreign_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::ForeignItem<'_>) {
-        if !has_attr(cx.sess(), &item.attrs) {
-            return;
-        }
-        prelude();
-        PrintVisitor::new("item").visit_foreign_item(item);
-        done();
-    }
-}
-
-impl PrintVisitor {
-    #[must_use]
-    fn new(s: &'static str) -> Self {
-        Self {
-            ids: FxHashMap::default(),
-            current: s.to_owned(),
-        }
-    }
-
-    fn next(&mut self, s: &'static str) -> String {
-        use std::collections::hash_map::Entry::{Occupied, Vacant};
-        match self.ids.entry(s) {
-            // already there: start numbering from `1`
-            Occupied(mut occ) => {
-                let val = occ.get_mut();
-                *val += 1;
-                format!("{}{}", s, *val)
-            },
-            // not there: insert and return name as given
-            Vacant(vac) => {
-                vac.insert(0);
-                s.to_owned()
-            },
-        }
-    }
-
-    fn print_qpath(&mut self, path: &QPath<'_>) {
-        if let QPath::LangItem(lang_item, _) = *path {
-            println!(
-                "    if matches!({}, QPath::LangItem(LangItem::{:?}, _));",
-                self.current, lang_item,
-            );
-        } else {
-            print!("    if match_qpath({}, &[", self.current);
-            print_path(path, &mut true);
-            println!("]);");
-        }
-    }
-}
-
-struct PrintVisitor {
-    /// Fields are the current index that needs to be appended to pattern
-    /// binding names
-    ids: FxHashMap<&'static str, usize>,
-    /// the name that needs to be destructured
-    current: String,
-}
-
-impl<'tcx> Visitor<'tcx> for PrintVisitor {
-    type Map = Map<'tcx>;
-
-    #[allow(clippy::too_many_lines)]
-    fn visit_expr(&mut self, expr: &Expr<'_>) {
-        print!("    if let ExprKind::");
-        let current = format!("{}.kind", self.current);
-        match expr.kind {
-            ExprKind::Box(ref inner) => {
-                let inner_pat = self.next("inner");
-                println!("Box(ref {}) = {};", inner_pat, current);
-                self.current = inner_pat;
-                self.visit_expr(inner);
-            },
-            ExprKind::Array(ref elements) => {
-                let elements_pat = self.next("elements");
-                println!("Array(ref {}) = {};", elements_pat, current);
-                println!("    if {}.len() == {};", elements_pat, elements.len());
-                for (i, element) in elements.iter().enumerate() {
-                    self.current = format!("{}[{}]", elements_pat, i);
-                    self.visit_expr(element);
-                }
-            },
-            ExprKind::Call(ref func, ref args) => {
-                let func_pat = self.next("func");
-                let args_pat = self.next("args");
-                println!("Call(ref {}, ref {}) = {};", func_pat, args_pat, current);
-                self.current = func_pat;
-                self.visit_expr(func);
-                println!("    if {}.len() == {};", args_pat, args.len());
-                for (i, arg) in args.iter().enumerate() {
-                    self.current = format!("{}[{}]", args_pat, i);
-                    self.visit_expr(arg);
-                }
-            },
-            ExprKind::MethodCall(ref _method_name, ref _generics, ref _args, ref _fn_span) => {
-                println!(
-                    "MethodCall(ref method_name, ref generics, ref args, ref fn_span) = {};",
-                    current
-                );
-                println!("    // unimplemented: `ExprKind::MethodCall` is not further destructured at the moment");
-            },
-            ExprKind::Tup(ref elements) => {
-                let elements_pat = self.next("elements");
-                println!("Tup(ref {}) = {};", elements_pat, current);
-                println!("    if {}.len() == {};", elements_pat, elements.len());
-                for (i, element) in elements.iter().enumerate() {
-                    self.current = format!("{}[{}]", elements_pat, i);
-                    self.visit_expr(element);
-                }
-            },
-            ExprKind::Binary(ref op, ref left, ref right) => {
-                let op_pat = self.next("op");
-                let left_pat = self.next("left");
-                let right_pat = self.next("right");
-                println!(
-                    "Binary(ref {}, ref {}, ref {}) = {};",
-                    op_pat, left_pat, right_pat, current
-                );
-                println!("    if BinOpKind::{:?} == {}.node;", op.node, op_pat);
-                self.current = left_pat;
-                self.visit_expr(left);
-                self.current = right_pat;
-                self.visit_expr(right);
-            },
-            ExprKind::Unary(ref op, ref inner) => {
-                let inner_pat = self.next("inner");
-                println!("Unary(UnOp::{:?}, ref {}) = {};", op, inner_pat, current);
-                self.current = inner_pat;
-                self.visit_expr(inner);
-            },
-            ExprKind::Lit(ref lit) => {
-                let lit_pat = self.next("lit");
-                println!("Lit(ref {}) = {};", lit_pat, current);
-                match lit.node {
-                    LitKind::Bool(val) => println!("    if let LitKind::Bool({:?}) = {}.node;", val, lit_pat),
-                    LitKind::Char(c) => println!("    if let LitKind::Char({:?}) = {}.node;", c, lit_pat),
-                    LitKind::Err(val) => println!("    if let LitKind::Err({}) = {}.node;", val, lit_pat),
-                    LitKind::Byte(b) => println!("    if let LitKind::Byte({}) = {}.node;", b, lit_pat),
-                    // FIXME: also check int type
-                    LitKind::Int(i, _) => println!("    if let LitKind::Int({}, _) = {}.node;", i, lit_pat),
-                    LitKind::Float(_, LitFloatType::Suffixed(_)) => println!(
-                        "    if let LitKind::Float(_, LitFloatType::Suffixed(_)) = {}.node;",
-                        lit_pat
-                    ),
-                    LitKind::Float(_, LitFloatType::Unsuffixed) => println!(
-                        "    if let LitKind::Float(_, LitFloatType::Unsuffixed) = {}.node;",
-                        lit_pat
-                    ),
-                    LitKind::ByteStr(ref vec) => {
-                        let vec_pat = self.next("vec");
-                        println!("    if let LitKind::ByteStr(ref {}) = {}.node;", vec_pat, lit_pat);
-                        println!("    if let [{:?}] = **{};", vec, vec_pat);
-                    },
-                    LitKind::Str(ref text, _) => {
-                        let str_pat = self.next("s");
-                        println!("    if let LitKind::Str(ref {}, _) = {}.node;", str_pat, lit_pat);
-                        println!("    if {}.as_str() == {:?}", str_pat, &*text.as_str())
-                    },
-                }
-            },
-            ExprKind::Cast(ref expr, ref ty) => {
-                let cast_pat = self.next("expr");
-                let cast_ty = self.next("cast_ty");
-                let qp_label = self.next("qp");
-
-                println!("Cast(ref {}, ref {}) = {};", cast_pat, cast_ty, current);
-                if let TyKind::Path(ref qp) = ty.kind {
-                    println!("    if let TyKind::Path(ref {}) = {}.kind;", qp_label, cast_ty);
-                    self.current = qp_label;
-                    self.print_qpath(qp);
-                }
-                self.current = cast_pat;
-                self.visit_expr(expr);
-            },
-            ExprKind::Type(ref expr, ref _ty) => {
-                let cast_pat = self.next("expr");
-                println!("Type(ref {}, _) = {};", cast_pat, current);
-                self.current = cast_pat;
-                self.visit_expr(expr);
-            },
-            ExprKind::Loop(ref body, _, desugaring, _) => {
-                let body_pat = self.next("body");
-                let des = loop_desugaring_name(desugaring);
-                let label_pat = self.next("label");
-                println!("Loop(ref {}, ref {}, {}) = {};", body_pat, label_pat, des, current);
-                self.current = body_pat;
-                self.visit_block(body);
-            },
-            ExprKind::If(ref cond, ref then, ref opt_else) => {
-                let cond_pat = self.next("cond");
-                let then_pat = self.next("then");
-                if let Some(ref else_) = *opt_else {
-                    let else_pat = self.next("else_");
-                    println!(
-                        "If(ref {}, ref {}, Some(ref {})) = {};",
-                        cond_pat, then_pat, else_pat, current
-                    );
-                    self.current = else_pat;
-                    self.visit_expr(else_);
-                } else {
-                    println!("If(ref {}, ref {}, None) = {};", cond_pat, then_pat, current);
-                }
-                self.current = cond_pat;
-                self.visit_expr(cond);
-                self.current = then_pat;
-                self.visit_expr(then);
-            },
-            ExprKind::Match(ref expr, ref arms, desugaring) => {
-                let des = desugaring_name(desugaring);
-                let expr_pat = self.next("expr");
-                let arms_pat = self.next("arms");
-                println!("Match(ref {}, ref {}, {}) = {};", expr_pat, arms_pat, des, current);
-                self.current = expr_pat;
-                self.visit_expr(expr);
-                println!("    if {}.len() == {};", arms_pat, arms.len());
-                for (i, arm) in arms.iter().enumerate() {
-                    self.current = format!("{}[{}].body", arms_pat, i);
-                    self.visit_expr(&arm.body);
-                    if let Some(ref guard) = arm.guard {
-                        let guard_pat = self.next("guard");
-                        println!("    if let Some(ref {}) = {}[{}].guard;", guard_pat, arms_pat, i);
-                        match guard {
-                            hir::Guard::If(ref if_expr) => {
-                                let if_expr_pat = self.next("expr");
-                                println!("    if let Guard::If(ref {}) = {};", if_expr_pat, guard_pat);
-                                self.current = if_expr_pat;
-                                self.visit_expr(if_expr);
-                            },
-                            hir::Guard::IfLet(ref if_let_pat, ref if_let_expr) => {
-                                let if_let_pat_pat = self.next("pat");
-                                let if_let_expr_pat = self.next("expr");
-                                println!(
-                                    "    if let Guard::IfLet(ref {}, ref {}) = {};",
-                                    if_let_pat_pat, if_let_expr_pat, guard_pat
-                                );
-                                self.current = if_let_expr_pat;
-                                self.visit_expr(if_let_expr);
-                                self.current = if_let_pat_pat;
-                                self.visit_pat(if_let_pat);
-                            },
-                        }
-                    }
-                    self.current = format!("{}[{}].pat", arms_pat, i);
-                    self.visit_pat(&arm.pat);
-                }
-            },
-            ExprKind::Closure(ref _capture_clause, ref _func, _, _, _) => {
-                println!("Closure(ref capture_clause, ref func, _, _, _) = {};", current);
-                println!("    // unimplemented: `ExprKind::Closure` is not further destructured at the moment");
-            },
-            ExprKind::Yield(ref sub, _) => {
-                let sub_pat = self.next("sub");
-                println!("Yield(ref sub) = {};", current);
-                self.current = sub_pat;
-                self.visit_expr(sub);
-            },
-            ExprKind::Block(ref block, _) => {
-                let block_pat = self.next("block");
-                println!("Block(ref {}) = {};", block_pat, current);
-                self.current = block_pat;
-                self.visit_block(block);
-            },
-            ExprKind::Assign(ref target, ref value, _) => {
-                let target_pat = self.next("target");
-                let value_pat = self.next("value");
-                println!(
-                    "Assign(ref {}, ref {}, ref _span) = {};",
-                    target_pat, value_pat, current
-                );
-                self.current = target_pat;
-                self.visit_expr(target);
-                self.current = value_pat;
-                self.visit_expr(value);
-            },
-            ExprKind::AssignOp(ref op, ref target, ref value) => {
-                let op_pat = self.next("op");
-                let target_pat = self.next("target");
-                let value_pat = self.next("value");
-                println!(
-                    "AssignOp(ref {}, ref {}, ref {}) = {};",
-                    op_pat, target_pat, value_pat, current
-                );
-                println!("    if BinOpKind::{:?} == {}.node;", op.node, op_pat);
-                self.current = target_pat;
-                self.visit_expr(target);
-                self.current = value_pat;
-                self.visit_expr(value);
-            },
-            ExprKind::Field(ref object, ref field_ident) => {
-                let obj_pat = self.next("object");
-                let field_name_pat = self.next("field_name");
-                println!("Field(ref {}, ref {}) = {};", obj_pat, field_name_pat, current);
-                println!("    if {}.as_str() == {:?}", field_name_pat, field_ident.as_str());
-                self.current = obj_pat;
-                self.visit_expr(object);
-            },
-            ExprKind::Index(ref object, ref index) => {
-                let object_pat = self.next("object");
-                let index_pat = self.next("index");
-                println!("Index(ref {}, ref {}) = {};", object_pat, index_pat, current);
-                self.current = object_pat;
-                self.visit_expr(object);
-                self.current = index_pat;
-                self.visit_expr(index);
-            },
-            ExprKind::Path(ref path) => {
-                let path_pat = self.next("path");
-                println!("Path(ref {}) = {};", path_pat, current);
-                self.current = path_pat;
-                self.print_qpath(path);
-            },
-            ExprKind::AddrOf(kind, mutability, ref inner) => {
-                let inner_pat = self.next("inner");
-                println!(
-                    "AddrOf(BorrowKind::{:?}, Mutability::{:?}, ref {}) = {};",
-                    kind, mutability, inner_pat, current
-                );
-                self.current = inner_pat;
-                self.visit_expr(inner);
-            },
-            ExprKind::Break(ref _destination, ref opt_value) => {
-                let destination_pat = self.next("destination");
-                if let Some(ref value) = *opt_value {
-                    let value_pat = self.next("value");
-                    println!("Break(ref {}, Some(ref {})) = {};", destination_pat, value_pat, current);
-                    self.current = value_pat;
-                    self.visit_expr(value);
-                } else {
-                    println!("Break(ref {}, None) = {};", destination_pat, current);
-                }
-                // FIXME: implement label printing
-            },
-            ExprKind::Continue(ref _destination) => {
-                let destination_pat = self.next("destination");
-                println!("Again(ref {}) = {};", destination_pat, current);
-                // FIXME: implement label printing
-            },
-            ExprKind::Ret(ref opt_value) => {
-                if let Some(ref value) = *opt_value {
-                    let value_pat = self.next("value");
-                    println!("Ret(Some(ref {})) = {};", value_pat, current);
-                    self.current = value_pat;
-                    self.visit_expr(value);
-                } else {
-                    println!("Ret(None) = {};", current);
-                }
-            },
-            ExprKind::InlineAsm(_) => {
-                println!("InlineAsm(_) = {};", current);
-                println!("    // unimplemented: `ExprKind::InlineAsm` is not further destructured at the moment");
-            },
-            ExprKind::LlvmInlineAsm(_) => {
-                println!("LlvmInlineAsm(_) = {};", current);
-                println!("    // unimplemented: `ExprKind::LlvmInlineAsm` is not further destructured at the moment");
-            },
-            ExprKind::Struct(ref path, ref fields, ref opt_base) => {
-                let path_pat = self.next("path");
-                let fields_pat = self.next("fields");
-                if let Some(ref base) = *opt_base {
-                    let base_pat = self.next("base");
-                    println!(
-                        "Struct(ref {}, ref {}, Some(ref {})) = {};",
-                        path_pat, fields_pat, base_pat, current
-                    );
-                    self.current = base_pat;
-                    self.visit_expr(base);
-                } else {
-                    println!("Struct(ref {}, ref {}, None) = {};", path_pat, fields_pat, current);
-                }
-                self.current = path_pat;
-                self.print_qpath(path);
-                println!("    if {}.len() == {};", fields_pat, fields.len());
-                println!("    // unimplemented: field checks");
-            },
-            ExprKind::ConstBlock(_) => {
-                let value_pat = self.next("value");
-                println!("Const({})", value_pat);
-                self.current = value_pat;
-            },
-            // FIXME: compute length (needs type info)
-            ExprKind::Repeat(ref value, _) => {
-                let value_pat = self.next("value");
-                println!("Repeat(ref {}, _) = {};", value_pat, current);
-                println!("// unimplemented: repeat count check");
-                self.current = value_pat;
-                self.visit_expr(value);
-            },
-            ExprKind::Err => {
-                println!("Err = {}", current);
-            },
-            ExprKind::DropTemps(ref expr) => {
-                let expr_pat = self.next("expr");
-                println!("DropTemps(ref {}) = {};", expr_pat, current);
-                self.current = expr_pat;
-                self.visit_expr(expr);
-            },
-        }
-    }
-
-    fn visit_block(&mut self, block: &Block<'_>) {
-        let trailing_pat = self.next("trailing_expr");
-        println!("    if let Some({}) = &{}.expr;", trailing_pat, self.current);
-        println!("    if {}.stmts.len() == {};", self.current, block.stmts.len());
-        let current = self.current.clone();
-        for (i, stmt) in block.stmts.iter().enumerate() {
-            self.current = format!("{}.stmts[{}]", current, i);
-            self.visit_stmt(stmt);
-        }
-    }
-
-    #[allow(clippy::too_many_lines)]
-    fn visit_pat(&mut self, pat: &Pat<'_>) {
-        print!("    if let PatKind::");
-        let current = format!("{}.kind", self.current);
-        match pat.kind {
-            PatKind::Wild => println!("Wild = {};", current),
-            PatKind::Binding(anno, .., ident, ref sub) => {
-                let anno_pat = match anno {
-                    BindingAnnotation::Unannotated => "BindingAnnotation::Unannotated",
-                    BindingAnnotation::Mutable => "BindingAnnotation::Mutable",
-                    BindingAnnotation::Ref => "BindingAnnotation::Ref",
-                    BindingAnnotation::RefMut => "BindingAnnotation::RefMut",
-                };
-                let name_pat = self.next("name");
-                if let Some(ref sub) = *sub {
-                    let sub_pat = self.next("sub");
-                    println!(
-                        "Binding({}, _, {}, Some(ref {})) = {};",
-                        anno_pat, name_pat, sub_pat, current
-                    );
-                    self.current = sub_pat;
-                    self.visit_pat(sub);
-                } else {
-                    println!("Binding({}, _, {}, None) = {};", anno_pat, name_pat, current);
-                }
-                println!("    if {}.as_str() == \"{}\";", name_pat, ident.as_str());
-            },
-            PatKind::Struct(ref path, ref fields, ignore) => {
-                let path_pat = self.next("path");
-                let fields_pat = self.next("fields");
-                println!(
-                    "Struct(ref {}, ref {}, {}) = {};",
-                    path_pat, fields_pat, ignore, current
-                );
-                self.current = path_pat;
-                self.print_qpath(path);
-                println!("    if {}.len() == {};", fields_pat, fields.len());
-                println!("    // unimplemented: field checks");
-            },
-            PatKind::Or(ref fields) => {
-                let fields_pat = self.next("fields");
-                println!("Or(ref {}) = {};", fields_pat, current);
-                println!("    if {}.len() == {};", fields_pat, fields.len());
-                println!("    // unimplemented: field checks");
-            },
-            PatKind::TupleStruct(ref path, ref fields, skip_pos) => {
-                let path_pat = self.next("path");
-                let fields_pat = self.next("fields");
-                println!(
-                    "TupleStruct(ref {}, ref {}, {:?}) = {};",
-                    path_pat, fields_pat, skip_pos, current
-                );
-                self.current = path_pat;
-                self.print_qpath(path);
-                println!("    if {}.len() == {};", fields_pat, fields.len());
-                println!("    // unimplemented: field checks");
-            },
-            PatKind::Path(ref path) => {
-                let path_pat = self.next("path");
-                println!("Path(ref {}) = {};", path_pat, current);
-                self.current = path_pat;
-                self.print_qpath(path);
-            },
-            PatKind::Tuple(ref fields, skip_pos) => {
-                let fields_pat = self.next("fields");
-                println!("Tuple(ref {}, {:?}) = {};", fields_pat, skip_pos, current);
-                println!("    if {}.len() == {};", fields_pat, fields.len());
-                println!("    // unimplemented: field checks");
-            },
-            PatKind::Box(ref pat) => {
-                let pat_pat = self.next("pat");
-                println!("Box(ref {}) = {};", pat_pat, current);
-                self.current = pat_pat;
-                self.visit_pat(pat);
-            },
-            PatKind::Ref(ref pat, muta) => {
-                let pat_pat = self.next("pat");
-                println!("Ref(ref {}, Mutability::{:?}) = {};", pat_pat, muta, current);
-                self.current = pat_pat;
-                self.visit_pat(pat);
-            },
-            PatKind::Lit(ref lit_expr) => {
-                let lit_expr_pat = self.next("lit_expr");
-                println!("Lit(ref {}) = {}", lit_expr_pat, current);
-                self.current = lit_expr_pat;
-                self.visit_expr(lit_expr);
-            },
-            PatKind::Range(ref start, ref end, end_kind) => {
-                let start_pat = self.next("start");
-                let end_pat = self.next("end");
-                println!(
-                    "Range(ref {}, ref {}, RangeEnd::{:?}) = {};",
-                    start_pat, end_pat, end_kind, current
-                );
-                self.current = start_pat;
-                walk_list!(self, visit_expr, start);
-                self.current = end_pat;
-                walk_list!(self, visit_expr, end);
-            },
-            PatKind::Slice(ref start, ref middle, ref end) => {
-                let start_pat = self.next("start");
-                let end_pat = self.next("end");
-                if let Some(ref middle) = middle {
-                    let middle_pat = self.next("middle");
-                    println!(
-                        "Slice(ref {}, Some(ref {}), ref {}) = {};",
-                        start_pat, middle_pat, end_pat, current
-                    );
-                    self.current = middle_pat;
-                    self.visit_pat(middle);
-                } else {
-                    println!("Slice(ref {}, None, ref {}) = {};", start_pat, end_pat, current);
-                }
-                println!("    if {}.len() == {};", start_pat, start.len());
-                for (i, pat) in start.iter().enumerate() {
-                    self.current = format!("{}[{}]", start_pat, i);
-                    self.visit_pat(pat);
-                }
-                println!("    if {}.len() == {};", end_pat, end.len());
-                for (i, pat) in end.iter().enumerate() {
-                    self.current = format!("{}[{}]", end_pat, i);
-                    self.visit_pat(pat);
-                }
-            },
-        }
-    }
-
-    fn visit_stmt(&mut self, s: &Stmt<'_>) {
-        print!("    if let StmtKind::");
-        let current = format!("{}.kind", self.current);
-        match s.kind {
-            // A local (let) binding:
-            StmtKind::Local(ref local) => {
-                let local_pat = self.next("local");
-                println!("Local(ref {}) = {};", local_pat, current);
-                if let Some(ref init) = local.init {
-                    let init_pat = self.next("init");
-                    println!("    if let Some(ref {}) = {}.init;", init_pat, local_pat);
-                    self.current = init_pat;
-                    self.visit_expr(init);
-                }
-                self.current = format!("{}.pat", local_pat);
-                self.visit_pat(&local.pat);
-            },
-            // An item binding:
-            StmtKind::Item(_) => {
-                println!("Item(item_id) = {};", current);
-            },
-
-            // Expr without trailing semi-colon (must have unit type):
-            StmtKind::Expr(ref e) => {
-                let e_pat = self.next("e");
-                println!("Expr(ref {}, _) = {}", e_pat, current);
-                self.current = e_pat;
-                self.visit_expr(e);
-            },
-
-            // Expr with trailing semi-colon (may have any type):
-            StmtKind::Semi(ref e) => {
-                let e_pat = self.next("e");
-                println!("Semi(ref {}, _) = {}", e_pat, current);
-                self.current = e_pat;
-                self.visit_expr(e);
-            },
-        }
-    }
-
-    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-        NestedVisitorMap::None
-    }
-}
-
-fn has_attr(sess: &Session, attrs: &[Attribute]) -> bool {
-    get_attr(sess, attrs, "author").count() > 0
-}
-
-#[must_use]
-fn desugaring_name(des: hir::MatchSource) -> String {
-    match des {
-        hir::MatchSource::ForLoopDesugar => "MatchSource::ForLoopDesugar".to_string(),
-        hir::MatchSource::TryDesugar => "MatchSource::TryDesugar".to_string(),
-        hir::MatchSource::WhileDesugar => "MatchSource::WhileDesugar".to_string(),
-        hir::MatchSource::WhileLetDesugar => "MatchSource::WhileLetDesugar".to_string(),
-        hir::MatchSource::Normal => "MatchSource::Normal".to_string(),
-        hir::MatchSource::IfLetDesugar { contains_else_clause } => format!(
-            "MatchSource::IfLetDesugar {{ contains_else_clause: {} }}",
-            contains_else_clause
-        ),
-        hir::MatchSource::IfLetGuardDesugar => "MatchSource::IfLetGuardDesugar".to_string(),
-        hir::MatchSource::AwaitDesugar => "MatchSource::AwaitDesugar".to_string(),
-    }
-}
-
-#[must_use]
-fn loop_desugaring_name(des: hir::LoopSource) -> &'static str {
-    match des {
-        hir::LoopSource::ForLoop => "LoopSource::ForLoop",
-        hir::LoopSource::Loop => "LoopSource::Loop",
-        hir::LoopSource::While => "LoopSource::While",
-        hir::LoopSource::WhileLet => "LoopSource::WhileLet",
-    }
-}
-
-fn print_path(path: &QPath<'_>, first: &mut bool) {
-    match *path {
-        QPath::Resolved(_, ref path) => {
-            for segment in path.segments {
-                if *first {
-                    *first = false;
-                } else {
-                    print!(", ");
-                }
-                print!("{:?}", segment.ident.as_str());
-            }
-        },
-        QPath::TypeRelative(ref ty, ref segment) => match ty.kind {
-            hir::TyKind::Path(ref inner_path) => {
-                print_path(inner_path, first);
-                if *first {
-                    *first = false;
-                } else {
-                    print!(", ");
-                }
-                print!("{:?}", segment.ident.as_str());
-            },
-            ref other => print!("/* unimplemented: {:?}*/", other),
-        },
-        QPath::LangItem(..) => panic!("print_path: called for lang item qpath"),
-    }
-}
diff --git a/clippy_lints/src/utils/camel_case.rs b/clippy_lints/src/utils/camel_case.rs
deleted file mode 100644
index ba1c01ebc9f..00000000000
--- a/clippy_lints/src/utils/camel_case.rs
+++ /dev/null
@@ -1,121 +0,0 @@
-/// Returns the index of the character after the first camel-case component of `s`.
-#[must_use]
-pub fn until(s: &str) -> usize {
-    let mut iter = s.char_indices();
-    if let Some((_, first)) = iter.next() {
-        if !first.is_uppercase() {
-            return 0;
-        }
-    } else {
-        return 0;
-    }
-    let mut up = true;
-    let mut last_i = 0;
-    for (i, c) in iter {
-        if up {
-            if c.is_lowercase() {
-                up = false;
-            } else {
-                return last_i;
-            }
-        } else if c.is_uppercase() {
-            up = true;
-            last_i = i;
-        } else if !c.is_lowercase() {
-            return i;
-        }
-    }
-    if up {
-        last_i
-    } else {
-        s.len()
-    }
-}
-
-/// Returns index of the last camel-case component of `s`.
-#[must_use]
-pub fn from(s: &str) -> usize {
-    let mut iter = s.char_indices().rev();
-    if let Some((_, first)) = iter.next() {
-        if !first.is_lowercase() {
-            return s.len();
-        }
-    } else {
-        return s.len();
-    }
-    let mut down = true;
-    let mut last_i = s.len();
-    for (i, c) in iter {
-        if down {
-            if c.is_uppercase() {
-                down = false;
-                last_i = i;
-            } else if !c.is_lowercase() {
-                return last_i;
-            }
-        } else if c.is_lowercase() {
-            down = true;
-        } else if c.is_uppercase() {
-            last_i = i;
-        } else {
-            return last_i;
-        }
-    }
-    last_i
-}
-
-#[cfg(test)]
-mod test {
-    use super::{from, until};
-
-    #[test]
-    fn from_full() {
-        assert_eq!(from("AbcDef"), 0);
-        assert_eq!(from("Abc"), 0);
-        assert_eq!(from("ABcd"), 0);
-        assert_eq!(from("ABcdEf"), 0);
-        assert_eq!(from("AabABcd"), 0);
-    }
-
-    #[test]
-    fn from_partial() {
-        assert_eq!(from("abcDef"), 3);
-        assert_eq!(from("aDbc"), 1);
-        assert_eq!(from("aabABcd"), 3);
-    }
-
-    #[test]
-    fn from_not() {
-        assert_eq!(from("AbcDef_"), 7);
-        assert_eq!(from("AbcDD"), 5);
-    }
-
-    #[test]
-    fn from_caps() {
-        assert_eq!(from("ABCD"), 4);
-    }
-
-    #[test]
-    fn until_full() {
-        assert_eq!(until("AbcDef"), 6);
-        assert_eq!(until("Abc"), 3);
-    }
-
-    #[test]
-    fn until_not() {
-        assert_eq!(until("abcDef"), 0);
-        assert_eq!(until("aDbc"), 0);
-    }
-
-    #[test]
-    fn until_partial() {
-        assert_eq!(until("AbcDef_"), 6);
-        assert_eq!(until("CallTypeC"), 8);
-        assert_eq!(until("AbcDD"), 3);
-    }
-
-    #[test]
-    fn until_caps() {
-        assert_eq!(until("ABCD"), 0);
-    }
-}
diff --git a/clippy_lints/src/utils/comparisons.rs b/clippy_lints/src/utils/comparisons.rs
deleted file mode 100644
index 7a18d5e818f..00000000000
--- a/clippy_lints/src/utils/comparisons.rs
+++ /dev/null
@@ -1,36 +0,0 @@
-//! Utility functions about comparison operators.
-
-#![deny(clippy::missing_docs_in_private_items)]
-
-use rustc_hir::{BinOpKind, Expr};
-
-#[derive(PartialEq, Eq, Debug, Copy, Clone)]
-/// Represent a normalized comparison operator.
-pub enum Rel {
-    /// `<`
-    Lt,
-    /// `<=`
-    Le,
-    /// `==`
-    Eq,
-    /// `!=`
-    Ne,
-}
-
-/// Put the expression in the form  `lhs < rhs`, `lhs <= rhs`, `lhs == rhs` or
-/// `lhs != rhs`.
-pub fn normalize_comparison<'a>(
-    op: BinOpKind,
-    lhs: &'a Expr<'a>,
-    rhs: &'a Expr<'a>,
-) -> Option<(Rel, &'a Expr<'a>, &'a Expr<'a>)> {
-    match op {
-        BinOpKind::Lt => Some((Rel::Lt, lhs, rhs)),
-        BinOpKind::Le => Some((Rel::Le, lhs, rhs)),
-        BinOpKind::Gt => Some((Rel::Lt, rhs, lhs)),
-        BinOpKind::Ge => Some((Rel::Le, rhs, lhs)),
-        BinOpKind::Eq => Some((Rel::Eq, rhs, lhs)),
-        BinOpKind::Ne => Some((Rel::Ne, rhs, lhs)),
-        _ => None,
-    }
-}
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
deleted file mode 100644
index 7d7b35c2168..00000000000
--- a/clippy_lints/src/utils/conf.rs
+++ /dev/null
@@ -1,257 +0,0 @@
-//! Read configurations files.
-
-#![deny(clippy::missing_docs_in_private_items)]
-
-use rustc_ast::ast::{LitKind, MetaItemKind, NestedMetaItem};
-use rustc_span::source_map;
-use source_map::Span;
-use std::lazy::SyncLazy;
-use std::path::{Path, PathBuf};
-use std::sync::Mutex;
-use std::{env, fmt, fs, io};
-
-/// Gets the configuration file from arguments.
-pub fn file_from_args(args: &[NestedMetaItem]) -> Result<Option<PathBuf>, (&'static str, Span)> {
-    for arg in args.iter().filter_map(NestedMetaItem::meta_item) {
-        if arg.has_name(sym!(conf_file)) {
-            return match arg.kind {
-                MetaItemKind::Word | MetaItemKind::List(_) => Err(("`conf_file` must be a named value", arg.span)),
-                MetaItemKind::NameValue(ref value) => {
-                    if let LitKind::Str(ref file, _) = value.kind {
-                        Ok(Some(file.to_string().into()))
-                    } else {
-                        Err(("`conf_file` value must be a string", value.span))
-                    }
-                },
-            };
-        }
-    }
-
-    Ok(None)
-}
-
-/// Error from reading a configuration file.
-#[derive(Debug)]
-pub enum Error {
-    /// An I/O error.
-    Io(io::Error),
-    /// Not valid toml or doesn't fit the expected config format
-    Toml(String),
-}
-
-impl fmt::Display for Error {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Self::Io(err) => err.fmt(f),
-            Self::Toml(err) => err.fmt(f),
-        }
-    }
-}
-
-impl From<io::Error> for Error {
-    fn from(e: io::Error) -> Self {
-        Self::Io(e)
-    }
-}
-
-/// Vec of errors that might be collected during config toml parsing
-static ERRORS: SyncLazy<Mutex<Vec<Error>>> = SyncLazy::new(|| Mutex::new(Vec::new()));
-
-macro_rules! define_Conf {
-    ($(#[$doc:meta] ($config:ident, $config_str:literal: $Ty:ty, $default:expr),)+) => {
-        mod helpers {
-            use serde::Deserialize;
-            /// Type used to store lint configuration.
-            #[derive(Deserialize)]
-            #[serde(rename_all = "kebab-case", deny_unknown_fields)]
-            pub struct Conf {
-                $(
-                    #[$doc]
-                    #[serde(default = $config_str)]
-                    #[serde(with = $config_str)]
-                    pub $config: $Ty,
-                )+
-                #[allow(dead_code)]
-                #[serde(default)]
-                third_party: Option<::toml::Value>,
-            }
-
-            $(
-                mod $config {
-                    use serde::Deserialize;
-                    pub fn deserialize<'de, D: serde::Deserializer<'de>>(deserializer: D) -> Result<$Ty, D::Error> {
-                        use super::super::{ERRORS, Error};
-
-                        Ok(
-                            <$Ty>::deserialize(deserializer).unwrap_or_else(|e| {
-                                ERRORS
-                                    .lock()
-                                    .expect("no threading here")
-                                    .push(Error::Toml(e.to_string()));
-                                super::$config()
-                            })
-                        )
-                    }
-                }
-
-                #[must_use]
-                fn $config() -> $Ty {
-                    let x = $default;
-                    x
-                }
-            )+
-        }
-    };
-}
-
-pub use self::helpers::Conf;
-define_Conf! {
-    /// Lint: REDUNDANT_FIELD_NAMES, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN. The minimum rust version that the project supports
-    (msrv, "msrv": Option<String>, None),
-    /// Lint: BLACKLISTED_NAME. The list of blacklisted names to lint about. NB: `bar` is not here since it has legitimate uses
-    (blacklisted_names, "blacklisted_names": Vec<String>, ["foo", "baz", "quux"].iter().map(ToString::to_string).collect()),
-    /// Lint: COGNITIVE_COMPLEXITY. The maximum cognitive complexity a function can have
-    (cognitive_complexity_threshold, "cognitive_complexity_threshold": u64, 25),
-    /// DEPRECATED LINT: CYCLOMATIC_COMPLEXITY. Use the Cognitive Complexity lint instead.
-    (cyclomatic_complexity_threshold, "cyclomatic_complexity_threshold": Option<u64>, None),
-    /// Lint: DOC_MARKDOWN. The list of words this lint should not consider as identifiers needing ticks
-    (doc_valid_idents, "doc_valid_idents": Vec<String>, [
-        "KiB", "MiB", "GiB", "TiB", "PiB", "EiB",
-        "DirectX",
-        "ECMAScript",
-        "GPLv2", "GPLv3",
-        "GitHub", "GitLab",
-        "IPv4", "IPv6",
-        "ClojureScript", "CoffeeScript", "JavaScript", "PureScript", "TypeScript",
-        "NaN", "NaNs",
-        "OAuth", "GraphQL",
-        "OCaml",
-        "OpenGL", "OpenMP", "OpenSSH", "OpenSSL", "OpenStreetMap",
-        "WebGL",
-        "TensorFlow",
-        "TrueType",
-        "iOS", "macOS",
-        "TeX", "LaTeX", "BibTeX", "BibLaTeX",
-        "MinGW",
-        "CamelCase",
-    ].iter().map(ToString::to_string).collect()),
-    /// Lint: TOO_MANY_ARGUMENTS. The maximum number of argument a function or method can have
-    (too_many_arguments_threshold, "too_many_arguments_threshold": u64, 7),
-    /// Lint: TYPE_COMPLEXITY. The maximum complexity a type can have
-    (type_complexity_threshold, "type_complexity_threshold": u64, 250),
-    /// Lint: MANY_SINGLE_CHAR_NAMES. The maximum number of single char bindings a scope may have
-    (single_char_binding_names_threshold, "single_char_binding_names_threshold": u64, 4),
-    /// Lint: BOXED_LOCAL, USELESS_VEC. The maximum size of objects (in bytes) that will be linted. Larger objects are ok on the heap
-    (too_large_for_stack, "too_large_for_stack": u64, 200),
-    /// Lint: ENUM_VARIANT_NAMES. The minimum number of enum variants for the lints about variant names to trigger
-    (enum_variant_name_threshold, "enum_variant_name_threshold": u64, 3),
-    /// Lint: LARGE_ENUM_VARIANT. The maximum size of a enum's variant to avoid box suggestion
-    (enum_variant_size_threshold, "enum_variant_size_threshold": u64, 200),
-    /// Lint: VERBOSE_BIT_MASK. The maximum allowed size of a bit mask before suggesting to use 'trailing_zeros'
-    (verbose_bit_mask_threshold, "verbose_bit_mask_threshold": u64, 1),
-    /// Lint: DECIMAL_LITERAL_REPRESENTATION. The lower bound for linting decimal literals
-    (literal_representation_threshold, "literal_representation_threshold": u64, 16384),
-    /// Lint: TRIVIALLY_COPY_PASS_BY_REF. The maximum size (in bytes) to consider a `Copy` type for passing by value instead of by reference.
-    (trivial_copy_size_limit, "trivial_copy_size_limit": Option<u64>, None),
-    /// Lint: LARGE_TYPE_PASS_BY_MOVE. The minimum size (in bytes) to consider a type for passing by reference instead of by value.
-    (pass_by_value_size_limit, "pass_by_value_size_limit": u64, 256),
-    /// Lint: TOO_MANY_LINES. The maximum number of lines a function or method can have
-    (too_many_lines_threshold, "too_many_lines_threshold": u64, 100),
-    /// Lint: LARGE_STACK_ARRAYS, LARGE_CONST_ARRAYS. The maximum allowed size for arrays on the stack
-    (array_size_threshold, "array_size_threshold": u64, 512_000),
-    /// Lint: VEC_BOX. The size of the boxed type in bytes, where boxing in a `Vec` is allowed
-    (vec_box_size_threshold, "vec_box_size_threshold": u64, 4096),
-    /// Lint: TYPE_REPETITION_IN_BOUNDS. The maximum number of bounds a trait can have to be linted
-    (max_trait_bounds, "max_trait_bounds": u64, 3),
-    /// Lint: STRUCT_EXCESSIVE_BOOLS. The maximum number of bools a struct can have
-    (max_struct_bools, "max_struct_bools": u64, 3),
-    /// Lint: FN_PARAMS_EXCESSIVE_BOOLS. The maximum number of bools function parameters can have
-    (max_fn_params_bools, "max_fn_params_bools": u64, 3),
-    /// Lint: WILDCARD_IMPORTS. Whether to allow certain wildcard imports (prelude, super in tests).
-    (warn_on_all_wildcard_imports, "warn_on_all_wildcard_imports": bool, false),
-    /// Lint: DISALLOWED_METHOD. The list of disallowed methods, written as fully qualified paths.
-    (disallowed_methods, "disallowed_methods": Vec<String>, Vec::<String>::new()),
-    /// Lint: UNREADABLE_LITERAL. Should the fraction of a decimal be linted to include separators.
-    (unreadable_literal_lint_fractions, "unreadable_literal_lint_fractions": bool, true),
-    /// Lint: _CARGO_COMMON_METADATA. For internal testing only, ignores the current `publish` settings in the Cargo manifest.
-    (cargo_ignore_publish, "cargo_ignore_publish": bool, false),
-}
-
-impl Default for Conf {
-    #[must_use]
-    fn default() -> Self {
-        toml::from_str("").expect("we never error on empty config files")
-    }
-}
-
-/// Search for the configuration file.
-pub fn lookup_conf_file() -> io::Result<Option<PathBuf>> {
-    /// Possible filename to search for.
-    const CONFIG_FILE_NAMES: [&str; 2] = [".clippy.toml", "clippy.toml"];
-
-    // Start looking for a config file in CLIPPY_CONF_DIR, or failing that, CARGO_MANIFEST_DIR.
-    // If neither of those exist, use ".".
-    let mut current = env::var_os("CLIPPY_CONF_DIR")
-        .or_else(|| env::var_os("CARGO_MANIFEST_DIR"))
-        .map_or_else(|| PathBuf::from("."), PathBuf::from);
-    loop {
-        for config_file_name in &CONFIG_FILE_NAMES {
-            let config_file = current.join(config_file_name);
-            match fs::metadata(&config_file) {
-                // Only return if it's a file to handle the unlikely situation of a directory named
-                // `clippy.toml`.
-                Ok(ref md) if !md.is_dir() => return Ok(Some(config_file)),
-                // Return the error if it's something other than `NotFound`; otherwise we didn't
-                // find the project file yet, and continue searching.
-                Err(e) if e.kind() != io::ErrorKind::NotFound => return Err(e),
-                _ => {},
-            }
-        }
-
-        // If the current directory has no parent, we're done searching.
-        if !current.pop() {
-            return Ok(None);
-        }
-    }
-}
-
-/// Produces a `Conf` filled with the default values and forwards the errors
-///
-/// Used internally for convenience
-fn default(errors: Vec<Error>) -> (Conf, Vec<Error>) {
-    (Conf::default(), errors)
-}
-
-/// Read the `toml` configuration file.
-///
-/// In case of error, the function tries to continue as much as possible.
-pub fn read(path: &Path) -> (Conf, Vec<Error>) {
-    let content = match fs::read_to_string(path) {
-        Ok(content) => content,
-        Err(err) => return default(vec![err.into()]),
-    };
-
-    assert!(ERRORS.lock().expect("no threading -> mutex always safe").is_empty());
-    match toml::from_str(&content) {
-        Ok(toml) => {
-            let mut errors = ERRORS.lock().expect("no threading -> mutex always safe").split_off(0);
-
-            let toml_ref: &Conf = &toml;
-
-            let cyc_field: Option<u64> = toml_ref.cyclomatic_complexity_threshold;
-
-            if cyc_field.is_some() {
-                let cyc_err = "found deprecated field `cyclomatic-complexity-threshold`. Please use `cognitive-complexity-threshold` instead.".to_string();
-                errors.push(Error::Toml(cyc_err));
-            }
-
-            (toml, errors)
-        },
-        Err(e) => {
-            let mut errors = ERRORS.lock().expect("no threading -> mutex always safe").split_off(0);
-            errors.push(Error::Toml(e.to_string()));
-
-            default(errors)
-        },
-    }
-}
diff --git a/clippy_lints/src/utils/diagnostics.rs b/clippy_lints/src/utils/diagnostics.rs
deleted file mode 100644
index 269be217c2d..00000000000
--- a/clippy_lints/src/utils/diagnostics.rs
+++ /dev/null
@@ -1,226 +0,0 @@
-//! Clippy wrappers around rustc's diagnostic functions.
-
-use rustc_errors::{Applicability, DiagnosticBuilder};
-use rustc_hir::HirId;
-use rustc_lint::{LateContext, Lint, LintContext};
-use rustc_span::source_map::{MultiSpan, Span};
-use std::env;
-
-fn docs_link(diag: &mut DiagnosticBuilder<'_>, lint: &'static Lint) {
-    if env::var("CLIPPY_DISABLE_DOCS_LINKS").is_err() {
-        diag.help(&format!(
-            "for further information visit https://rust-lang.github.io/rust-clippy/{}/index.html#{}",
-            &option_env!("RUST_RELEASE_NUM").map_or("master".to_string(), |n| {
-                // extract just major + minor version and ignore patch versions
-                format!("rust-{}", n.rsplitn(2, '.').nth(1).unwrap())
-            }),
-            lint.name_lower().replacen("clippy::", "", 1)
-        ));
-    }
-}
-
-/// Emit a basic lint message with a `msg` and a `span`.
-///
-/// This is the most primitive of our lint emission methods and can
-/// be a good way to get a new lint started.
-///
-/// Usually it's nicer to provide more context for lint messages.
-/// Be sure the output is understandable when you use this method.
-///
-/// # Example
-///
-/// ```ignore
-/// error: usage of mem::forget on Drop type
-///   --> $DIR/mem_forget.rs:17:5
-///    |
-/// 17 |     std::mem::forget(seven);
-///    |     ^^^^^^^^^^^^^^^^^^^^^^^
-/// ```
-pub fn span_lint<T: LintContext>(cx: &T, lint: &'static Lint, sp: impl Into<MultiSpan>, msg: &str) {
-    cx.struct_span_lint(lint, sp, |diag| {
-        let mut diag = diag.build(msg);
-        docs_link(&mut diag, lint);
-        diag.emit();
-    });
-}
-
-/// Same as `span_lint` but with an extra `help` message.
-///
-/// Use this if you want to provide some general help but
-/// can't provide a specific machine applicable suggestion.
-///
-/// The `help` message can be optionally attached to a `Span`.
-///
-/// If you change the signature, remember to update the internal lint `CollapsibleCalls`
-///
-/// # Example
-///
-/// ```ignore
-/// error: constant division of 0.0 with 0.0 will always result in NaN
-///   --> $DIR/zero_div_zero.rs:6:25
-///    |
-/// 6  |     let other_f64_nan = 0.0f64 / 0.0;
-///    |                         ^^^^^^^^^^^^
-///    |
-///    = help: Consider using `f64::NAN` if you would like a constant representing NaN
-/// ```
-pub fn span_lint_and_help<'a, T: LintContext>(
-    cx: &'a T,
-    lint: &'static Lint,
-    span: Span,
-    msg: &str,
-    help_span: Option<Span>,
-    help: &str,
-) {
-    cx.struct_span_lint(lint, span, |diag| {
-        let mut diag = diag.build(msg);
-        if let Some(help_span) = help_span {
-            diag.span_help(help_span, help);
-        } else {
-            diag.help(help);
-        }
-        docs_link(&mut diag, lint);
-        diag.emit();
-    });
-}
-
-/// Like `span_lint` but with a `note` section instead of a `help` message.
-///
-/// The `note` message is presented separately from the main lint message
-/// and is attached to a specific span:
-///
-/// If you change the signature, remember to update the internal lint `CollapsibleCalls`
-///
-/// # Example
-///
-/// ```ignore
-/// error: calls to `std::mem::forget` with a reference instead of an owned value. Forgetting a reference does nothing.
-///   --> $DIR/drop_forget_ref.rs:10:5
-///    |
-/// 10 |     forget(&SomeStruct);
-///    |     ^^^^^^^^^^^^^^^^^^^
-///    |
-///    = note: `-D clippy::forget-ref` implied by `-D warnings`
-/// note: argument has type &SomeStruct
-///   --> $DIR/drop_forget_ref.rs:10:12
-///    |
-/// 10 |     forget(&SomeStruct);
-///    |            ^^^^^^^^^^^
-/// ```
-pub fn span_lint_and_note<'a, T: LintContext>(
-    cx: &'a T,
-    lint: &'static Lint,
-    span: impl Into<MultiSpan>,
-    msg: &str,
-    note_span: Option<Span>,
-    note: &str,
-) {
-    cx.struct_span_lint(lint, span, |diag| {
-        let mut diag = diag.build(msg);
-        if let Some(note_span) = note_span {
-            diag.span_note(note_span, note);
-        } else {
-            diag.note(note);
-        }
-        docs_link(&mut diag, lint);
-        diag.emit();
-    });
-}
-
-/// Like `span_lint` but allows to add notes, help and suggestions using a closure.
-///
-/// If you need to customize your lint output a lot, use this function.
-/// If you change the signature, remember to update the internal lint `CollapsibleCalls`
-pub fn span_lint_and_then<'a, T: LintContext, F>(cx: &'a T, lint: &'static Lint, sp: Span, msg: &str, f: F)
-where
-    F: for<'b> FnOnce(&mut DiagnosticBuilder<'b>),
-{
-    cx.struct_span_lint(lint, sp, |diag| {
-        let mut diag = diag.build(msg);
-        f(&mut diag);
-        docs_link(&mut diag, lint);
-        diag.emit();
-    });
-}
-
-pub fn span_lint_hir(cx: &LateContext<'_>, lint: &'static Lint, hir_id: HirId, sp: Span, msg: &str) {
-    cx.tcx.struct_span_lint_hir(lint, hir_id, sp, |diag| {
-        let mut diag = diag.build(msg);
-        docs_link(&mut diag, lint);
-        diag.emit();
-    });
-}
-
-pub fn span_lint_hir_and_then(
-    cx: &LateContext<'_>,
-    lint: &'static Lint,
-    hir_id: HirId,
-    sp: Span,
-    msg: &str,
-    f: impl FnOnce(&mut DiagnosticBuilder<'_>),
-) {
-    cx.tcx.struct_span_lint_hir(lint, hir_id, sp, |diag| {
-        let mut diag = diag.build(msg);
-        f(&mut diag);
-        docs_link(&mut diag, lint);
-        diag.emit();
-    });
-}
-
-/// Add a span lint with a suggestion on how to fix it.
-///
-/// These suggestions can be parsed by rustfix to allow it to automatically fix your code.
-/// In the example below, `help` is `"try"` and `sugg` is the suggested replacement `".any(|x| x >
-/// 2)"`.
-///
-/// If you change the signature, remember to update the internal lint `CollapsibleCalls`
-///
-/// # Example
-///
-/// ```ignore
-/// error: This `.fold` can be more succinctly expressed as `.any`
-/// --> $DIR/methods.rs:390:13
-///     |
-/// 390 |     let _ = (0..3).fold(false, |acc, x| acc || x > 2);
-///     |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `.any(|x| x > 2)`
-///     |
-///     = note: `-D fold-any` implied by `-D warnings`
-/// ```
-#[cfg_attr(feature = "internal-lints", allow(clippy::collapsible_span_lint_calls))]
-pub fn span_lint_and_sugg<'a, T: LintContext>(
-    cx: &'a T,
-    lint: &'static Lint,
-    sp: Span,
-    msg: &str,
-    help: &str,
-    sugg: String,
-    applicability: Applicability,
-) {
-    span_lint_and_then(cx, lint, sp, msg, |diag| {
-        diag.span_suggestion(sp, help, sugg, applicability);
-    });
-}
-
-/// Create a suggestion made from several `span → replacement`.
-///
-/// Note: in the JSON format (used by `compiletest_rs`), the help message will
-/// appear once per
-/// replacement. In human-readable format though, it only appears once before
-/// the whole suggestion.
-pub fn multispan_sugg<I>(diag: &mut DiagnosticBuilder<'_>, help_msg: &str, sugg: I)
-where
-    I: IntoIterator<Item = (Span, String)>,
-{
-    multispan_sugg_with_applicability(diag, help_msg, Applicability::Unspecified, sugg)
-}
-
-pub fn multispan_sugg_with_applicability<I>(
-    diag: &mut DiagnosticBuilder<'_>,
-    help_msg: &str,
-    applicability: Applicability,
-    sugg: I,
-) where
-    I: IntoIterator<Item = (Span, String)>,
-{
-    diag.multipart_suggestion(help_msg, sugg.into_iter().collect(), applicability);
-}
diff --git a/clippy_lints/src/utils/eager_or_lazy.rs b/clippy_lints/src/utils/eager_or_lazy.rs
deleted file mode 100644
index 2f157c5030f..00000000000
--- a/clippy_lints/src/utils/eager_or_lazy.rs
+++ /dev/null
@@ -1,134 +0,0 @@
-//! Utilities for evaluating whether eagerly evaluated expressions can be made lazy and vice versa.
-//!
-//! Things to consider:
-//!  - has the expression side-effects?
-//!  - is the expression computationally expensive?
-//!
-//! See lints:
-//!  - unnecessary-lazy-evaluations
-//!  - or-fun-call
-//!  - option-if-let-else
-
-use crate::utils::{is_ctor_or_promotable_const_function, is_type_diagnostic_item, match_type, paths};
-use rustc_hir::def::{DefKind, Res};
-
-use rustc_hir::intravisit;
-use rustc_hir::intravisit::{NestedVisitorMap, Visitor};
-
-use rustc_hir::{Block, Expr, ExprKind, Path, QPath};
-use rustc_lint::LateContext;
-use rustc_middle::hir::map::Map;
-
-/// Is the expr pure (is it free from side-effects)?
-/// This function is named so to stress that it isn't exhaustive and returns FNs.
-fn identify_some_pure_patterns(expr: &Expr<'_>) -> bool {
-    match expr.kind {
-        ExprKind::Lit(..) | ExprKind::ConstBlock(..) | ExprKind::Path(..) | ExprKind::Field(..) => true,
-        ExprKind::AddrOf(_, _, addr_of_expr) => identify_some_pure_patterns(addr_of_expr),
-        ExprKind::Tup(tup_exprs) => tup_exprs.iter().all(|expr| identify_some_pure_patterns(expr)),
-        ExprKind::Struct(_, fields, expr) => {
-            fields.iter().all(|f| identify_some_pure_patterns(f.expr))
-                && expr.map_or(true, |e| identify_some_pure_patterns(e))
-        },
-        ExprKind::Call(
-            &Expr {
-                kind:
-                    ExprKind::Path(QPath::Resolved(
-                        _,
-                        Path {
-                            res: Res::Def(DefKind::Ctor(..) | DefKind::Variant, ..),
-                            ..
-                        },
-                    )),
-                ..
-            },
-            args,
-        ) => args.iter().all(|expr| identify_some_pure_patterns(expr)),
-        ExprKind::Block(
-            &Block {
-                stmts,
-                expr: Some(expr),
-                ..
-            },
-            _,
-        ) => stmts.is_empty() && identify_some_pure_patterns(expr),
-        ExprKind::Box(..)
-        | ExprKind::Array(..)
-        | ExprKind::Call(..)
-        | ExprKind::MethodCall(..)
-        | ExprKind::Binary(..)
-        | ExprKind::Unary(..)
-        | ExprKind::Cast(..)
-        | ExprKind::Type(..)
-        | ExprKind::DropTemps(..)
-        | ExprKind::Loop(..)
-        | ExprKind::If(..)
-        | ExprKind::Match(..)
-        | ExprKind::Closure(..)
-        | ExprKind::Block(..)
-        | ExprKind::Assign(..)
-        | ExprKind::AssignOp(..)
-        | ExprKind::Index(..)
-        | ExprKind::Break(..)
-        | ExprKind::Continue(..)
-        | ExprKind::Ret(..)
-        | ExprKind::InlineAsm(..)
-        | ExprKind::LlvmInlineAsm(..)
-        | ExprKind::Repeat(..)
-        | ExprKind::Yield(..)
-        | ExprKind::Err => false,
-    }
-}
-
-/// Identify some potentially computationally expensive patterns.
-/// This function is named so to stress that its implementation is non-exhaustive.
-/// It returns FNs and FPs.
-fn identify_some_potentially_expensive_patterns<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
-    // Searches an expression for method calls or function calls that aren't ctors
-    struct FunCallFinder<'a, 'tcx> {
-        cx: &'a LateContext<'tcx>,
-        found: bool,
-    }
-
-    impl<'a, 'tcx> intravisit::Visitor<'tcx> for FunCallFinder<'a, 'tcx> {
-        type Map = Map<'tcx>;
-
-        fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) {
-            let call_found = match &expr.kind {
-                // ignore enum and struct constructors
-                ExprKind::Call(..) => !is_ctor_or_promotable_const_function(self.cx, expr),
-                ExprKind::Index(obj, _) => {
-                    let ty = self.cx.typeck_results().expr_ty(obj);
-                    is_type_diagnostic_item(self.cx, ty, sym!(hashmap_type))
-                        || match_type(self.cx, ty, &paths::BTREEMAP)
-                },
-                ExprKind::MethodCall(..) => true,
-                _ => false,
-            };
-
-            if call_found {
-                self.found |= true;
-            }
-
-            if !self.found {
-                intravisit::walk_expr(self, expr);
-            }
-        }
-
-        fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-            NestedVisitorMap::None
-        }
-    }
-
-    let mut finder = FunCallFinder { cx, found: false };
-    finder.visit_expr(expr);
-    finder.found
-}
-
-pub fn is_eagerness_candidate<'a, 'tcx>(cx: &'a LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
-    !identify_some_potentially_expensive_patterns(cx, expr) && identify_some_pure_patterns(expr)
-}
-
-pub fn is_lazyness_candidate<'a, 'tcx>(cx: &'a LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
-    identify_some_potentially_expensive_patterns(cx, expr)
-}
diff --git a/clippy_lints/src/utils/higher.rs b/clippy_lints/src/utils/higher.rs
deleted file mode 100644
index 1cf1aa363d5..00000000000
--- a/clippy_lints/src/utils/higher.rs
+++ /dev/null
@@ -1,268 +0,0 @@
-//! This module contains functions for retrieve the original AST from lowered
-//! `hir`.
-
-#![deny(clippy::missing_docs_in_private_items)]
-
-use crate::utils::{is_expn_of, match_def_path, paths};
-use if_chain::if_chain;
-use rustc_ast::ast;
-use rustc_hir as hir;
-use rustc_hir::{BorrowKind, Expr, ExprKind, StmtKind, UnOp};
-use rustc_lint::LateContext;
-use rustc_span::source_map::Span;
-
-/// Converts a hir binary operator to the corresponding `ast` type.
-#[must_use]
-pub fn binop(op: hir::BinOpKind) -> ast::BinOpKind {
-    match op {
-        hir::BinOpKind::Eq => ast::BinOpKind::Eq,
-        hir::BinOpKind::Ge => ast::BinOpKind::Ge,
-        hir::BinOpKind::Gt => ast::BinOpKind::Gt,
-        hir::BinOpKind::Le => ast::BinOpKind::Le,
-        hir::BinOpKind::Lt => ast::BinOpKind::Lt,
-        hir::BinOpKind::Ne => ast::BinOpKind::Ne,
-        hir::BinOpKind::Or => ast::BinOpKind::Or,
-        hir::BinOpKind::Add => ast::BinOpKind::Add,
-        hir::BinOpKind::And => ast::BinOpKind::And,
-        hir::BinOpKind::BitAnd => ast::BinOpKind::BitAnd,
-        hir::BinOpKind::BitOr => ast::BinOpKind::BitOr,
-        hir::BinOpKind::BitXor => ast::BinOpKind::BitXor,
-        hir::BinOpKind::Div => ast::BinOpKind::Div,
-        hir::BinOpKind::Mul => ast::BinOpKind::Mul,
-        hir::BinOpKind::Rem => ast::BinOpKind::Rem,
-        hir::BinOpKind::Shl => ast::BinOpKind::Shl,
-        hir::BinOpKind::Shr => ast::BinOpKind::Shr,
-        hir::BinOpKind::Sub => ast::BinOpKind::Sub,
-    }
-}
-
-/// Represent a range akin to `ast::ExprKind::Range`.
-#[derive(Debug, Copy, Clone)]
-pub struct Range<'a> {
-    /// The lower bound of the range, or `None` for ranges such as `..X`.
-    pub start: Option<&'a hir::Expr<'a>>,
-    /// The upper bound of the range, or `None` for ranges such as `X..`.
-    pub end: Option<&'a hir::Expr<'a>>,
-    /// Whether the interval is open or closed.
-    pub limits: ast::RangeLimits,
-}
-
-/// Higher a `hir` range to something similar to `ast::ExprKind::Range`.
-pub fn range<'a>(expr: &'a hir::Expr<'_>) -> Option<Range<'a>> {
-    /// Finds the field named `name` in the field. Always return `Some` for
-    /// convenience.
-    fn get_field<'c>(name: &str, fields: &'c [hir::Field<'_>]) -> Option<&'c hir::Expr<'c>> {
-        let expr = &fields.iter().find(|field| field.ident.name.as_str() == name)?.expr;
-
-        Some(expr)
-    }
-
-    match expr.kind {
-        hir::ExprKind::Call(ref path, ref args)
-            if matches!(
-                path.kind,
-                hir::ExprKind::Path(hir::QPath::LangItem(hir::LangItem::RangeInclusiveNew, _))
-            ) =>
-        {
-            Some(Range {
-                start: Some(&args[0]),
-                end: Some(&args[1]),
-                limits: ast::RangeLimits::Closed,
-            })
-        },
-        hir::ExprKind::Struct(ref path, ref fields, None) => match path {
-            hir::QPath::LangItem(hir::LangItem::RangeFull, _) => Some(Range {
-                start: None,
-                end: None,
-                limits: ast::RangeLimits::HalfOpen,
-            }),
-            hir::QPath::LangItem(hir::LangItem::RangeFrom, _) => Some(Range {
-                start: Some(get_field("start", fields)?),
-                end: None,
-                limits: ast::RangeLimits::HalfOpen,
-            }),
-            hir::QPath::LangItem(hir::LangItem::Range, _) => Some(Range {
-                start: Some(get_field("start", fields)?),
-                end: Some(get_field("end", fields)?),
-                limits: ast::RangeLimits::HalfOpen,
-            }),
-            hir::QPath::LangItem(hir::LangItem::RangeToInclusive, _) => Some(Range {
-                start: None,
-                end: Some(get_field("end", fields)?),
-                limits: ast::RangeLimits::Closed,
-            }),
-            hir::QPath::LangItem(hir::LangItem::RangeTo, _) => Some(Range {
-                start: None,
-                end: Some(get_field("end", fields)?),
-                limits: ast::RangeLimits::HalfOpen,
-            }),
-            _ => None,
-        },
-        _ => None,
-    }
-}
-
-/// Checks if a `let` statement is from a `for` loop desugaring.
-pub fn is_from_for_desugar(local: &hir::Local<'_>) -> bool {
-    // This will detect plain for-loops without an actual variable binding:
-    //
-    // ```
-    // for x in some_vec {
-    //     // do stuff
-    // }
-    // ```
-    if_chain! {
-        if let Some(ref expr) = local.init;
-        if let hir::ExprKind::Match(_, _, hir::MatchSource::ForLoopDesugar) = expr.kind;
-        then {
-            return true;
-        }
-    }
-
-    // This detects a variable binding in for loop to avoid `let_unit_value`
-    // lint (see issue #1964).
-    //
-    // ```
-    // for _ in vec![()] {
-    //     // anything
-    // }
-    // ```
-    if let hir::LocalSource::ForLoopDesugar = local.source {
-        return true;
-    }
-
-    false
-}
-
-/// Recover the essential nodes of a desugared for loop as well as the entire span:
-/// `for pat in arg { body }` becomes `(pat, arg, body)`. Return `(pat, arg, body, span)`.
-pub fn for_loop<'tcx>(
-    expr: &'tcx hir::Expr<'tcx>,
-) -> Option<(&hir::Pat<'_>, &'tcx hir::Expr<'tcx>, &'tcx hir::Expr<'tcx>, Span)> {
-    if_chain! {
-        if let hir::ExprKind::Match(ref iterexpr, ref arms, hir::MatchSource::ForLoopDesugar) = expr.kind;
-        if let hir::ExprKind::Call(_, ref iterargs) = iterexpr.kind;
-        if iterargs.len() == 1 && arms.len() == 1 && arms[0].guard.is_none();
-        if let hir::ExprKind::Loop(ref block, ..) = arms[0].body.kind;
-        if block.expr.is_none();
-        if let [ _, _, ref let_stmt, ref body ] = *block.stmts;
-        if let hir::StmtKind::Local(ref local) = let_stmt.kind;
-        if let hir::StmtKind::Expr(ref expr) = body.kind;
-        then {
-            return Some((&*local.pat, &iterargs[0], expr, arms[0].span));
-        }
-    }
-    None
-}
-
-/// Recover the essential nodes of a desugared while loop:
-/// `while cond { body }` becomes `(cond, body)`.
-pub fn while_loop<'tcx>(expr: &'tcx hir::Expr<'tcx>) -> Option<(&'tcx hir::Expr<'tcx>, &'tcx hir::Expr<'tcx>)> {
-    if_chain! {
-        if let hir::ExprKind::Loop(hir::Block { expr: Some(expr), .. }, _, hir::LoopSource::While, _) = &expr.kind;
-        if let hir::ExprKind::Match(cond, arms, hir::MatchSource::WhileDesugar) = &expr.kind;
-        if let hir::ExprKind::DropTemps(cond) = &cond.kind;
-        if let [hir::Arm { body, .. }, ..] = &arms[..];
-        then {
-            return Some((cond, body));
-        }
-    }
-    None
-}
-
-/// Represent the pre-expansion arguments of a `vec!` invocation.
-pub enum VecArgs<'a> {
-    /// `vec![elem; len]`
-    Repeat(&'a hir::Expr<'a>, &'a hir::Expr<'a>),
-    /// `vec![a, b, c]`
-    Vec(&'a [hir::Expr<'a>]),
-}
-
-/// Returns the arguments of the `vec!` macro if this expression was expanded
-/// from `vec!`.
-pub fn vec_macro<'e>(cx: &LateContext<'_>, expr: &'e hir::Expr<'_>) -> Option<VecArgs<'e>> {
-    if_chain! {
-        if let hir::ExprKind::Call(ref fun, ref args) = expr.kind;
-        if let hir::ExprKind::Path(ref qpath) = fun.kind;
-        if is_expn_of(fun.span, "vec").is_some();
-        if let Some(fun_def_id) = cx.qpath_res(qpath, fun.hir_id).opt_def_id();
-        then {
-            return if match_def_path(cx, fun_def_id, &paths::VEC_FROM_ELEM) && args.len() == 2 {
-                // `vec![elem; size]` case
-                Some(VecArgs::Repeat(&args[0], &args[1]))
-            }
-            else if match_def_path(cx, fun_def_id, &paths::SLICE_INTO_VEC) && args.len() == 1 {
-                // `vec![a, b, c]` case
-                if_chain! {
-                    if let hir::ExprKind::Box(ref boxed) = args[0].kind;
-                    if let hir::ExprKind::Array(ref args) = boxed.kind;
-                    then {
-                        return Some(VecArgs::Vec(&*args));
-                    }
-                }
-
-                None
-            }
-            else if match_def_path(cx, fun_def_id, &paths::VEC_NEW) && args.is_empty() {
-                Some(VecArgs::Vec(&[]))
-            }
-            else {
-                None
-            };
-        }
-    }
-
-    None
-}
-
-/// Extract args from an assert-like macro.
-/// Currently working with:
-/// - `assert!`, `assert_eq!` and `assert_ne!`
-/// - `debug_assert!`, `debug_assert_eq!` and `debug_assert_ne!`
-/// For example:
-/// `assert!(expr)` will return Some([expr])
-/// `debug_assert_eq!(a, b)` will return Some([a, b])
-pub fn extract_assert_macro_args<'tcx>(e: &'tcx Expr<'tcx>) -> Option<Vec<&'tcx Expr<'tcx>>> {
-    /// Try to match the AST for a pattern that contains a match, for example when two args are
-    /// compared
-    fn ast_matchblock(matchblock_expr: &'tcx Expr<'tcx>) -> Option<Vec<&Expr<'_>>> {
-        if_chain! {
-            if let ExprKind::Match(ref headerexpr, _, _) = &matchblock_expr.kind;
-            if let ExprKind::Tup([lhs, rhs]) = &headerexpr.kind;
-            if let ExprKind::AddrOf(BorrowKind::Ref, _, lhs) = lhs.kind;
-            if let ExprKind::AddrOf(BorrowKind::Ref, _, rhs) = rhs.kind;
-            then {
-                return Some(vec![lhs, rhs]);
-            }
-        }
-        None
-    }
-
-    if let ExprKind::Block(ref block, _) = e.kind {
-        if block.stmts.len() == 1 {
-            if let StmtKind::Semi(ref matchexpr) = block.stmts.get(0)?.kind {
-                // macros with unique arg: `{debug_}assert!` (e.g., `debug_assert!(some_condition)`)
-                if_chain! {
-                    if let ExprKind::If(ref clause, _, _)  = matchexpr.kind;
-                    if let ExprKind::Unary(UnOp::Not, condition) = clause.kind;
-                    then {
-                        return Some(vec![condition]);
-                    }
-                }
-
-                // debug macros with two args: `debug_assert_{ne, eq}` (e.g., `assert_ne!(a, b)`)
-                if_chain! {
-                    if let ExprKind::Block(ref matchblock,_) = matchexpr.kind;
-                    if let Some(ref matchblock_expr) = matchblock.expr;
-                    then {
-                        return ast_matchblock(matchblock_expr);
-                    }
-                }
-            }
-        } else if let Some(matchblock_expr) = block.expr {
-            // macros with two args: `assert_{ne, eq}` (e.g., `assert_ne!(a, b)`)
-            return ast_matchblock(&matchblock_expr);
-        }
-    }
-    None
-}
diff --git a/clippy_lints/src/utils/hir_utils.rs b/clippy_lints/src/utils/hir_utils.rs
deleted file mode 100644
index c042990b759..00000000000
--- a/clippy_lints/src/utils/hir_utils.rs
+++ /dev/null
@@ -1,852 +0,0 @@
-use crate::consts::{constant_context, constant_simple};
-use crate::utils::differing_macro_contexts;
-use rustc_ast::ast::InlineAsmTemplatePiece;
-use rustc_data_structures::fx::FxHashMap;
-use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
-use rustc_hir::def::Res;
-use rustc_hir::{
-    BinOpKind, Block, BlockCheckMode, BodyId, BorrowKind, CaptureBy, Expr, ExprKind, Field, FieldPat, FnRetTy,
-    GenericArg, GenericArgs, Guard, HirId, InlineAsmOperand, Lifetime, LifetimeName, ParamName, Pat, PatKind, Path,
-    PathSegment, QPath, Stmt, StmtKind, Ty, TyKind, TypeBinding,
-};
-use rustc_lint::LateContext;
-use rustc_middle::ich::StableHashingContextProvider;
-use rustc_middle::ty::TypeckResults;
-use rustc_span::Symbol;
-use std::hash::Hash;
-
-/// Type used to check whether two ast are the same. This is different from the
-/// operator
-/// `==` on ast types as this operator would compare true equality with ID and
-/// span.
-///
-/// Note that some expressions kinds are not considered but could be added.
-pub struct SpanlessEq<'a, 'tcx> {
-    /// Context used to evaluate constant expressions.
-    cx: &'a LateContext<'tcx>,
-    maybe_typeck_results: Option<&'tcx TypeckResults<'tcx>>,
-    allow_side_effects: bool,
-    expr_fallback: Option<Box<dyn FnMut(&Expr<'_>, &Expr<'_>) -> bool + 'a>>,
-}
-
-impl<'a, 'tcx> SpanlessEq<'a, 'tcx> {
-    pub fn new(cx: &'a LateContext<'tcx>) -> Self {
-        Self {
-            cx,
-            maybe_typeck_results: cx.maybe_typeck_results(),
-            allow_side_effects: true,
-            expr_fallback: None,
-        }
-    }
-
-    /// Consider expressions containing potential side effects as not equal.
-    pub fn deny_side_effects(self) -> Self {
-        Self {
-            allow_side_effects: false,
-            ..self
-        }
-    }
-
-    pub fn expr_fallback(self, expr_fallback: impl FnMut(&Expr<'_>, &Expr<'_>) -> bool + 'a) -> Self {
-        Self {
-            expr_fallback: Some(Box::new(expr_fallback)),
-            ..self
-        }
-    }
-
-    /// Use this method to wrap comparisons that may involve inter-expression context.
-    /// See `self.locals`.
-    fn inter_expr(&mut self) -> HirEqInterExpr<'_, 'a, 'tcx> {
-        HirEqInterExpr {
-            inner: self,
-            locals: FxHashMap::default(),
-        }
-    }
-
-    pub fn eq_block(&mut self, left: &Block<'_>, right: &Block<'_>) -> bool {
-        self.inter_expr().eq_block(left, right)
-    }
-
-    pub fn eq_expr(&mut self, left: &Expr<'_>, right: &Expr<'_>) -> bool {
-        self.inter_expr().eq_expr(left, right)
-    }
-
-    pub fn eq_path_segment(&mut self, left: &PathSegment<'_>, right: &PathSegment<'_>) -> bool {
-        self.inter_expr().eq_path_segment(left, right)
-    }
-
-    pub fn eq_path_segments(&mut self, left: &[PathSegment<'_>], right: &[PathSegment<'_>]) -> bool {
-        self.inter_expr().eq_path_segments(left, right)
-    }
-
-    pub fn eq_ty_kind(&mut self, left: &TyKind<'_>, right: &TyKind<'_>) -> bool {
-        self.inter_expr().eq_ty_kind(left, right)
-    }
-}
-
-struct HirEqInterExpr<'a, 'b, 'tcx> {
-    inner: &'a mut SpanlessEq<'b, 'tcx>,
-
-    // When binding are declared, the binding ID in the left expression is mapped to the one on the
-    // right. For example, when comparing `{ let x = 1; x + 2 }` and `{ let y = 1; y + 2 }`,
-    // these blocks are considered equal since `x` is mapped to `y`.
-    locals: FxHashMap<HirId, HirId>,
-}
-
-impl HirEqInterExpr<'_, '_, '_> {
-    fn eq_stmt(&mut self, left: &Stmt<'_>, right: &Stmt<'_>) -> bool {
-        match (&left.kind, &right.kind) {
-            (&StmtKind::Local(ref l), &StmtKind::Local(ref r)) => {
-                self.eq_pat(&l.pat, &r.pat)
-                    && both(&l.ty, &r.ty, |l, r| self.eq_ty(l, r))
-                    && both(&l.init, &r.init, |l, r| self.eq_expr(l, r))
-            },
-            (&StmtKind::Expr(ref l), &StmtKind::Expr(ref r)) | (&StmtKind::Semi(ref l), &StmtKind::Semi(ref r)) => {
-                self.eq_expr(l, r)
-            },
-            _ => false,
-        }
-    }
-
-    /// Checks whether two blocks are the same.
-    fn eq_block(&mut self, left: &Block<'_>, right: &Block<'_>) -> bool {
-        over(&left.stmts, &right.stmts, |l, r| self.eq_stmt(l, r))
-            && both(&left.expr, &right.expr, |l, r| self.eq_expr(l, r))
-    }
-
-    #[allow(clippy::similar_names)]
-    fn eq_expr(&mut self, left: &Expr<'_>, right: &Expr<'_>) -> bool {
-        if !self.inner.allow_side_effects && differing_macro_contexts(left.span, right.span) {
-            return false;
-        }
-
-        if let Some(typeck_results) = self.inner.maybe_typeck_results {
-            if let (Some(l), Some(r)) = (
-                constant_simple(self.inner.cx, typeck_results, left),
-                constant_simple(self.inner.cx, typeck_results, right),
-            ) {
-                if l == r {
-                    return true;
-                }
-            }
-        }
-
-        let is_eq = match (&reduce_exprkind(&left.kind), &reduce_exprkind(&right.kind)) {
-            (&ExprKind::AddrOf(lb, l_mut, ref le), &ExprKind::AddrOf(rb, r_mut, ref re)) => {
-                lb == rb && l_mut == r_mut && self.eq_expr(le, re)
-            },
-            (&ExprKind::Continue(li), &ExprKind::Continue(ri)) => {
-                both(&li.label, &ri.label, |l, r| l.ident.name == r.ident.name)
-            },
-            (&ExprKind::Assign(ref ll, ref lr, _), &ExprKind::Assign(ref rl, ref rr, _)) => {
-                self.inner.allow_side_effects && self.eq_expr(ll, rl) && self.eq_expr(lr, rr)
-            },
-            (&ExprKind::AssignOp(ref lo, ref ll, ref lr), &ExprKind::AssignOp(ref ro, ref rl, ref rr)) => {
-                self.inner.allow_side_effects && lo.node == ro.node && self.eq_expr(ll, rl) && self.eq_expr(lr, rr)
-            },
-            (&ExprKind::Block(ref l, _), &ExprKind::Block(ref r, _)) => self.eq_block(l, r),
-            (&ExprKind::Binary(l_op, ref ll, ref lr), &ExprKind::Binary(r_op, ref rl, ref rr)) => {
-                l_op.node == r_op.node && self.eq_expr(ll, rl) && self.eq_expr(lr, rr)
-                    || swap_binop(l_op.node, ll, lr).map_or(false, |(l_op, ll, lr)| {
-                        l_op == r_op.node && self.eq_expr(ll, rl) && self.eq_expr(lr, rr)
-                    })
-            },
-            (&ExprKind::Break(li, ref le), &ExprKind::Break(ri, ref re)) => {
-                both(&li.label, &ri.label, |l, r| l.ident.name == r.ident.name)
-                    && both(le, re, |l, r| self.eq_expr(l, r))
-            },
-            (&ExprKind::Box(ref l), &ExprKind::Box(ref r)) => self.eq_expr(l, r),
-            (&ExprKind::Call(l_fun, l_args), &ExprKind::Call(r_fun, r_args)) => {
-                self.inner.allow_side_effects && self.eq_expr(l_fun, r_fun) && self.eq_exprs(l_args, r_args)
-            },
-            (&ExprKind::Cast(ref lx, ref lt), &ExprKind::Cast(ref rx, ref rt))
-            | (&ExprKind::Type(ref lx, ref lt), &ExprKind::Type(ref rx, ref rt)) => {
-                self.eq_expr(lx, rx) && self.eq_ty(lt, rt)
-            },
-            (&ExprKind::Field(ref l_f_exp, ref l_f_ident), &ExprKind::Field(ref r_f_exp, ref r_f_ident)) => {
-                l_f_ident.name == r_f_ident.name && self.eq_expr(l_f_exp, r_f_exp)
-            },
-            (&ExprKind::Index(ref la, ref li), &ExprKind::Index(ref ra, ref ri)) => {
-                self.eq_expr(la, ra) && self.eq_expr(li, ri)
-            },
-            (&ExprKind::If(ref lc, ref lt, ref le), &ExprKind::If(ref rc, ref rt, ref re)) => {
-                self.eq_expr(lc, rc) && self.eq_expr(&**lt, &**rt) && both(le, re, |l, r| self.eq_expr(l, r))
-            },
-            (&ExprKind::Lit(ref l), &ExprKind::Lit(ref r)) => l.node == r.node,
-            (&ExprKind::Loop(ref lb, ref ll, ref lls, _), &ExprKind::Loop(ref rb, ref rl, ref rls, _)) => {
-                lls == rls && self.eq_block(lb, rb) && both(ll, rl, |l, r| l.ident.name == r.ident.name)
-            },
-            (&ExprKind::Match(ref le, ref la, ref ls), &ExprKind::Match(ref re, ref ra, ref rs)) => {
-                ls == rs
-                    && self.eq_expr(le, re)
-                    && over(la, ra, |l, r| {
-                        self.eq_pat(&l.pat, &r.pat)
-                            && both(&l.guard, &r.guard, |l, r| self.eq_guard(l, r))
-                            && self.eq_expr(&l.body, &r.body)
-                    })
-            },
-            (&ExprKind::MethodCall(l_path, _, l_args, _), &ExprKind::MethodCall(r_path, _, r_args, _)) => {
-                self.inner.allow_side_effects && self.eq_path_segment(l_path, r_path) && self.eq_exprs(l_args, r_args)
-            },
-            (&ExprKind::Repeat(ref le, ref ll_id), &ExprKind::Repeat(ref re, ref rl_id)) => {
-                let mut celcx = constant_context(self.inner.cx, self.inner.cx.tcx.typeck_body(ll_id.body));
-                let ll = celcx.expr(&self.inner.cx.tcx.hir().body(ll_id.body).value);
-                let mut celcx = constant_context(self.inner.cx, self.inner.cx.tcx.typeck_body(rl_id.body));
-                let rl = celcx.expr(&self.inner.cx.tcx.hir().body(rl_id.body).value);
-
-                self.eq_expr(le, re) && ll == rl
-            },
-            (&ExprKind::Ret(ref l), &ExprKind::Ret(ref r)) => both(l, r, |l, r| self.eq_expr(l, r)),
-            (&ExprKind::Path(ref l), &ExprKind::Path(ref r)) => self.eq_qpath(l, r),
-            (&ExprKind::Struct(ref l_path, ref lf, ref lo), &ExprKind::Struct(ref r_path, ref rf, ref ro)) => {
-                self.eq_qpath(l_path, r_path)
-                    && both(lo, ro, |l, r| self.eq_expr(l, r))
-                    && over(lf, rf, |l, r| self.eq_field(l, r))
-            },
-            (&ExprKind::Tup(l_tup), &ExprKind::Tup(r_tup)) => self.eq_exprs(l_tup, r_tup),
-            (&ExprKind::Unary(l_op, ref le), &ExprKind::Unary(r_op, ref re)) => l_op == r_op && self.eq_expr(le, re),
-            (&ExprKind::Array(l), &ExprKind::Array(r)) => self.eq_exprs(l, r),
-            (&ExprKind::DropTemps(ref le), &ExprKind::DropTemps(ref re)) => self.eq_expr(le, re),
-            _ => false,
-        };
-        is_eq || self.inner.expr_fallback.as_mut().map_or(false, |f| f(left, right))
-    }
-
-    fn eq_exprs(&mut self, left: &[Expr<'_>], right: &[Expr<'_>]) -> bool {
-        over(left, right, |l, r| self.eq_expr(l, r))
-    }
-
-    fn eq_field(&mut self, left: &Field<'_>, right: &Field<'_>) -> bool {
-        left.ident.name == right.ident.name && self.eq_expr(&left.expr, &right.expr)
-    }
-
-    fn eq_guard(&mut self, left: &Guard<'_>, right: &Guard<'_>) -> bool {
-        match (left, right) {
-            (Guard::If(l), Guard::If(r)) => self.eq_expr(l, r),
-            (Guard::IfLet(lp, le), Guard::IfLet(rp, re)) => self.eq_pat(lp, rp) && self.eq_expr(le, re),
-            _ => false,
-        }
-    }
-
-    fn eq_generic_arg(&mut self, left: &GenericArg<'_>, right: &GenericArg<'_>) -> bool {
-        match (left, right) {
-            (GenericArg::Lifetime(l_lt), GenericArg::Lifetime(r_lt)) => Self::eq_lifetime(l_lt, r_lt),
-            (GenericArg::Type(l_ty), GenericArg::Type(r_ty)) => self.eq_ty(l_ty, r_ty),
-            _ => false,
-        }
-    }
-
-    fn eq_lifetime(left: &Lifetime, right: &Lifetime) -> bool {
-        left.name == right.name
-    }
-
-    fn eq_fieldpat(&mut self, left: &FieldPat<'_>, right: &FieldPat<'_>) -> bool {
-        let (FieldPat { ident: li, pat: lp, .. }, FieldPat { ident: ri, pat: rp, .. }) = (&left, &right);
-        li.name == ri.name && self.eq_pat(lp, rp)
-    }
-
-    /// Checks whether two patterns are the same.
-    fn eq_pat(&mut self, left: &Pat<'_>, right: &Pat<'_>) -> bool {
-        match (&left.kind, &right.kind) {
-            (&PatKind::Box(ref l), &PatKind::Box(ref r)) => self.eq_pat(l, r),
-            (&PatKind::Struct(ref lp, ref la, ..), &PatKind::Struct(ref rp, ref ra, ..)) => {
-                self.eq_qpath(lp, rp) && over(la, ra, |l, r| self.eq_fieldpat(l, r))
-            },
-            (&PatKind::TupleStruct(ref lp, ref la, ls), &PatKind::TupleStruct(ref rp, ref ra, rs)) => {
-                self.eq_qpath(lp, rp) && over(la, ra, |l, r| self.eq_pat(l, r)) && ls == rs
-            },
-            (&PatKind::Binding(lb, li, _, ref lp), &PatKind::Binding(rb, ri, _, ref rp)) => {
-                let eq = lb == rb && both(lp, rp, |l, r| self.eq_pat(l, r));
-                if eq {
-                    self.locals.insert(li, ri);
-                }
-                eq
-            },
-            (&PatKind::Path(ref l), &PatKind::Path(ref r)) => self.eq_qpath(l, r),
-            (&PatKind::Lit(ref l), &PatKind::Lit(ref r)) => self.eq_expr(l, r),
-            (&PatKind::Tuple(ref l, ls), &PatKind::Tuple(ref r, rs)) => {
-                ls == rs && over(l, r, |l, r| self.eq_pat(l, r))
-            },
-            (&PatKind::Range(ref ls, ref le, li), &PatKind::Range(ref rs, ref re, ri)) => {
-                both(ls, rs, |a, b| self.eq_expr(a, b)) && both(le, re, |a, b| self.eq_expr(a, b)) && (li == ri)
-            },
-            (&PatKind::Ref(ref le, ref lm), &PatKind::Ref(ref re, ref rm)) => lm == rm && self.eq_pat(le, re),
-            (&PatKind::Slice(ref ls, ref li, ref le), &PatKind::Slice(ref rs, ref ri, ref re)) => {
-                over(ls, rs, |l, r| self.eq_pat(l, r))
-                    && over(le, re, |l, r| self.eq_pat(l, r))
-                    && both(li, ri, |l, r| self.eq_pat(l, r))
-            },
-            (&PatKind::Wild, &PatKind::Wild) => true,
-            _ => false,
-        }
-    }
-
-    #[allow(clippy::similar_names)]
-    fn eq_qpath(&mut self, left: &QPath<'_>, right: &QPath<'_>) -> bool {
-        match (left, right) {
-            (&QPath::Resolved(ref lty, ref lpath), &QPath::Resolved(ref rty, ref rpath)) => {
-                both(lty, rty, |l, r| self.eq_ty(l, r)) && self.eq_path(lpath, rpath)
-            },
-            (&QPath::TypeRelative(ref lty, ref lseg), &QPath::TypeRelative(ref rty, ref rseg)) => {
-                self.eq_ty(lty, rty) && self.eq_path_segment(lseg, rseg)
-            },
-            (&QPath::LangItem(llang_item, _), &QPath::LangItem(rlang_item, _)) => llang_item == rlang_item,
-            _ => false,
-        }
-    }
-
-    fn eq_path(&mut self, left: &Path<'_>, right: &Path<'_>) -> bool {
-        match (left.res, right.res) {
-            (Res::Local(l), Res::Local(r)) => l == r || self.locals.get(&l) == Some(&r),
-            (Res::Local(_), _) | (_, Res::Local(_)) => false,
-            _ => over(&left.segments, &right.segments, |l, r| self.eq_path_segment(l, r)),
-        }
-    }
-
-    fn eq_path_parameters(&mut self, left: &GenericArgs<'_>, right: &GenericArgs<'_>) -> bool {
-        if !(left.parenthesized || right.parenthesized) {
-            over(&left.args, &right.args, |l, r| self.eq_generic_arg(l, r)) // FIXME(flip1995): may not work
-                && over(&left.bindings, &right.bindings, |l, r| self.eq_type_binding(l, r))
-        } else if left.parenthesized && right.parenthesized {
-            over(left.inputs(), right.inputs(), |l, r| self.eq_ty(l, r))
-                && both(&Some(&left.bindings[0].ty()), &Some(&right.bindings[0].ty()), |l, r| {
-                    self.eq_ty(l, r)
-                })
-        } else {
-            false
-        }
-    }
-
-    pub fn eq_path_segments(&mut self, left: &[PathSegment<'_>], right: &[PathSegment<'_>]) -> bool {
-        left.len() == right.len() && left.iter().zip(right).all(|(l, r)| self.eq_path_segment(l, r))
-    }
-
-    pub fn eq_path_segment(&mut self, left: &PathSegment<'_>, right: &PathSegment<'_>) -> bool {
-        // The == of idents doesn't work with different contexts,
-        // we have to be explicit about hygiene
-        left.ident.name == right.ident.name && both(&left.args, &right.args, |l, r| self.eq_path_parameters(l, r))
-    }
-
-    fn eq_ty(&mut self, left: &Ty<'_>, right: &Ty<'_>) -> bool {
-        self.eq_ty_kind(&left.kind, &right.kind)
-    }
-
-    #[allow(clippy::similar_names)]
-    fn eq_ty_kind(&mut self, left: &TyKind<'_>, right: &TyKind<'_>) -> bool {
-        match (left, right) {
-            (&TyKind::Slice(ref l_vec), &TyKind::Slice(ref r_vec)) => self.eq_ty(l_vec, r_vec),
-            (&TyKind::Array(ref lt, ref ll_id), &TyKind::Array(ref rt, ref rl_id)) => {
-                let cx = self.inner.cx;
-                let eval_const =
-                    |body| constant_context(cx, cx.tcx.typeck_body(body)).expr(&cx.tcx.hir().body(body).value);
-                self.eq_ty(lt, rt) && eval_const(ll_id.body) == eval_const(rl_id.body)
-            },
-            (&TyKind::Ptr(ref l_mut), &TyKind::Ptr(ref r_mut)) => {
-                l_mut.mutbl == r_mut.mutbl && self.eq_ty(&*l_mut.ty, &*r_mut.ty)
-            },
-            (&TyKind::Rptr(_, ref l_rmut), &TyKind::Rptr(_, ref r_rmut)) => {
-                l_rmut.mutbl == r_rmut.mutbl && self.eq_ty(&*l_rmut.ty, &*r_rmut.ty)
-            },
-            (&TyKind::Path(ref l), &TyKind::Path(ref r)) => self.eq_qpath(l, r),
-            (&TyKind::Tup(ref l), &TyKind::Tup(ref r)) => over(l, r, |l, r| self.eq_ty(l, r)),
-            (&TyKind::Infer, &TyKind::Infer) => true,
-            _ => false,
-        }
-    }
-
-    fn eq_type_binding(&mut self, left: &TypeBinding<'_>, right: &TypeBinding<'_>) -> bool {
-        left.ident.name == right.ident.name && self.eq_ty(&left.ty(), &right.ty())
-    }
-}
-
-/// Some simple reductions like `{ return }` => `return`
-fn reduce_exprkind<'hir>(kind: &'hir ExprKind<'hir>) -> &ExprKind<'hir> {
-    if let ExprKind::Block(block, _) = kind {
-        match (block.stmts, block.expr) {
-            // `{}` => `()`
-            ([], None) => &ExprKind::Tup(&[]),
-            ([], Some(expr)) => match expr.kind {
-                // `{ return .. }` => `return ..`
-                ExprKind::Ret(..) => &expr.kind,
-                _ => kind,
-            },
-            ([stmt], None) => match stmt.kind {
-                StmtKind::Expr(expr) | StmtKind::Semi(expr) => match expr.kind {
-                    // `{ return ..; }` => `return ..`
-                    ExprKind::Ret(..) => &expr.kind,
-                    _ => kind,
-                },
-                _ => kind,
-            },
-            _ => kind,
-        }
-    } else {
-        kind
-    }
-}
-
-fn swap_binop<'a>(
-    binop: BinOpKind,
-    lhs: &'a Expr<'a>,
-    rhs: &'a Expr<'a>,
-) -> Option<(BinOpKind, &'a Expr<'a>, &'a Expr<'a>)> {
-    match binop {
-        BinOpKind::Add | BinOpKind::Eq | BinOpKind::Ne | BinOpKind::BitAnd | BinOpKind::BitXor | BinOpKind::BitOr => {
-            Some((binop, rhs, lhs))
-        },
-        BinOpKind::Lt => Some((BinOpKind::Gt, rhs, lhs)),
-        BinOpKind::Le => Some((BinOpKind::Ge, rhs, lhs)),
-        BinOpKind::Ge => Some((BinOpKind::Le, rhs, lhs)),
-        BinOpKind::Gt => Some((BinOpKind::Lt, rhs, lhs)),
-        BinOpKind::Mul // Not always commutative, e.g. with matrices. See issue #5698
-        | BinOpKind::Shl
-        | BinOpKind::Shr
-        | BinOpKind::Rem
-        | BinOpKind::Sub
-        | BinOpKind::Div
-        | BinOpKind::And
-        | BinOpKind::Or => None,
-    }
-}
-
-/// Checks if the two `Option`s are both `None` or some equal values as per
-/// `eq_fn`.
-pub fn both<X>(l: &Option<X>, r: &Option<X>, mut eq_fn: impl FnMut(&X, &X) -> bool) -> bool {
-    l.as_ref()
-        .map_or_else(|| r.is_none(), |x| r.as_ref().map_or(false, |y| eq_fn(x, y)))
-}
-
-/// Checks if two slices are equal as per `eq_fn`.
-pub fn over<X>(left: &[X], right: &[X], mut eq_fn: impl FnMut(&X, &X) -> bool) -> bool {
-    left.len() == right.len() && left.iter().zip(right).all(|(x, y)| eq_fn(x, y))
-}
-
-/// Checks if two expressions evaluate to the same value, and don't contain any side effects.
-pub fn eq_expr_value(cx: &LateContext<'_>, left: &Expr<'_>, right: &Expr<'_>) -> bool {
-    SpanlessEq::new(cx).deny_side_effects().eq_expr(left, right)
-}
-
-/// Type used to hash an ast element. This is different from the `Hash` trait
-/// on ast types as this
-/// trait would consider IDs and spans.
-///
-/// All expressions kind are hashed, but some might have a weaker hash.
-pub struct SpanlessHash<'a, 'tcx> {
-    /// Context used to evaluate constant expressions.
-    cx: &'a LateContext<'tcx>,
-    maybe_typeck_results: Option<&'tcx TypeckResults<'tcx>>,
-    s: StableHasher,
-}
-
-impl<'a, 'tcx> SpanlessHash<'a, 'tcx> {
-    pub fn new(cx: &'a LateContext<'tcx>) -> Self {
-        Self {
-            cx,
-            maybe_typeck_results: cx.maybe_typeck_results(),
-            s: StableHasher::new(),
-        }
-    }
-
-    pub fn finish(self) -> u64 {
-        self.s.finish()
-    }
-
-    pub fn hash_block(&mut self, b: &Block<'_>) {
-        for s in b.stmts {
-            self.hash_stmt(s);
-        }
-
-        if let Some(ref e) = b.expr {
-            self.hash_expr(e);
-        }
-
-        match b.rules {
-            BlockCheckMode::DefaultBlock => 0,
-            BlockCheckMode::UnsafeBlock(_) => 1,
-            BlockCheckMode::PushUnsafeBlock(_) => 2,
-            BlockCheckMode::PopUnsafeBlock(_) => 3,
-        }
-        .hash(&mut self.s);
-    }
-
-    #[allow(clippy::many_single_char_names, clippy::too_many_lines)]
-    pub fn hash_expr(&mut self, e: &Expr<'_>) {
-        let simple_const = self
-            .maybe_typeck_results
-            .and_then(|typeck_results| constant_simple(self.cx, typeck_results, e));
-
-        // const hashing may result in the same hash as some unrelated node, so add a sort of
-        // discriminant depending on which path we're choosing next
-        simple_const.is_some().hash(&mut self.s);
-
-        if let Some(e) = simple_const {
-            return e.hash(&mut self.s);
-        }
-
-        std::mem::discriminant(&e.kind).hash(&mut self.s);
-
-        match e.kind {
-            ExprKind::AddrOf(kind, m, ref e) => {
-                match kind {
-                    BorrowKind::Ref => 0,
-                    BorrowKind::Raw => 1,
-                }
-                .hash(&mut self.s);
-                m.hash(&mut self.s);
-                self.hash_expr(e);
-            },
-            ExprKind::Continue(i) => {
-                if let Some(i) = i.label {
-                    self.hash_name(i.ident.name);
-                }
-            },
-            ExprKind::Assign(ref l, ref r, _) => {
-                self.hash_expr(l);
-                self.hash_expr(r);
-            },
-            ExprKind::AssignOp(ref o, ref l, ref r) => {
-                o.node
-                    .hash_stable(&mut self.cx.tcx.get_stable_hashing_context(), &mut self.s);
-                self.hash_expr(l);
-                self.hash_expr(r);
-            },
-            ExprKind::Block(ref b, _) => {
-                self.hash_block(b);
-            },
-            ExprKind::Binary(op, ref l, ref r) => {
-                op.node
-                    .hash_stable(&mut self.cx.tcx.get_stable_hashing_context(), &mut self.s);
-                self.hash_expr(l);
-                self.hash_expr(r);
-            },
-            ExprKind::Break(i, ref j) => {
-                if let Some(i) = i.label {
-                    self.hash_name(i.ident.name);
-                }
-                if let Some(ref j) = *j {
-                    self.hash_expr(&*j);
-                }
-            },
-            ExprKind::Box(ref e) | ExprKind::DropTemps(ref e) | ExprKind::Yield(ref e, _) => {
-                self.hash_expr(e);
-            },
-            ExprKind::Call(ref fun, args) => {
-                self.hash_expr(fun);
-                self.hash_exprs(args);
-            },
-            ExprKind::Cast(ref e, ref ty) | ExprKind::Type(ref e, ref ty) => {
-                self.hash_expr(e);
-                self.hash_ty(ty);
-            },
-            ExprKind::Closure(cap, _, eid, _, _) => {
-                match cap {
-                    CaptureBy::Value => 0,
-                    CaptureBy::Ref => 1,
-                }
-                .hash(&mut self.s);
-                // closures inherit TypeckResults
-                self.hash_expr(&self.cx.tcx.hir().body(eid).value);
-            },
-            ExprKind::Field(ref e, ref f) => {
-                self.hash_expr(e);
-                self.hash_name(f.name);
-            },
-            ExprKind::Index(ref a, ref i) => {
-                self.hash_expr(a);
-                self.hash_expr(i);
-            },
-            ExprKind::InlineAsm(ref asm) => {
-                for piece in asm.template {
-                    match piece {
-                        InlineAsmTemplatePiece::String(s) => s.hash(&mut self.s),
-                        InlineAsmTemplatePiece::Placeholder {
-                            operand_idx,
-                            modifier,
-                            span: _,
-                        } => {
-                            operand_idx.hash(&mut self.s);
-                            modifier.hash(&mut self.s);
-                        },
-                    }
-                }
-                asm.options.hash(&mut self.s);
-                for (op, _op_sp) in asm.operands {
-                    match op {
-                        InlineAsmOperand::In { reg, expr } => {
-                            reg.hash(&mut self.s);
-                            self.hash_expr(expr);
-                        },
-                        InlineAsmOperand::Out { reg, late, expr } => {
-                            reg.hash(&mut self.s);
-                            late.hash(&mut self.s);
-                            if let Some(expr) = expr {
-                                self.hash_expr(expr);
-                            }
-                        },
-                        InlineAsmOperand::InOut { reg, late, expr } => {
-                            reg.hash(&mut self.s);
-                            late.hash(&mut self.s);
-                            self.hash_expr(expr);
-                        },
-                        InlineAsmOperand::SplitInOut {
-                            reg,
-                            late,
-                            in_expr,
-                            out_expr,
-                        } => {
-                            reg.hash(&mut self.s);
-                            late.hash(&mut self.s);
-                            self.hash_expr(in_expr);
-                            if let Some(out_expr) = out_expr {
-                                self.hash_expr(out_expr);
-                            }
-                        },
-                        InlineAsmOperand::Const { expr } | InlineAsmOperand::Sym { expr } => self.hash_expr(expr),
-                    }
-                }
-            },
-            ExprKind::LlvmInlineAsm(..) | ExprKind::Err => {},
-            ExprKind::Lit(ref l) => {
-                l.node.hash(&mut self.s);
-            },
-            ExprKind::Loop(ref b, ref i, ..) => {
-                self.hash_block(b);
-                if let Some(i) = *i {
-                    self.hash_name(i.ident.name);
-                }
-            },
-            ExprKind::If(ref cond, ref then, ref else_opt) => {
-                let c: fn(_, _, _) -> _ = ExprKind::If;
-                c.hash(&mut self.s);
-                self.hash_expr(cond);
-                self.hash_expr(&**then);
-                if let Some(ref e) = *else_opt {
-                    self.hash_expr(e);
-                }
-            },
-            ExprKind::Match(ref e, arms, ref s) => {
-                self.hash_expr(e);
-
-                for arm in arms {
-                    // TODO: arm.pat?
-                    if let Some(ref e) = arm.guard {
-                        self.hash_guard(e);
-                    }
-                    self.hash_expr(&arm.body);
-                }
-
-                s.hash(&mut self.s);
-            },
-            ExprKind::MethodCall(ref path, ref _tys, args, ref _fn_span) => {
-                self.hash_name(path.ident.name);
-                self.hash_exprs(args);
-            },
-            ExprKind::ConstBlock(ref l_id) => {
-                self.hash_body(l_id.body);
-            },
-            ExprKind::Repeat(ref e, ref l_id) => {
-                self.hash_expr(e);
-                self.hash_body(l_id.body);
-            },
-            ExprKind::Ret(ref e) => {
-                if let Some(ref e) = *e {
-                    self.hash_expr(e);
-                }
-            },
-            ExprKind::Path(ref qpath) => {
-                self.hash_qpath(qpath);
-            },
-            ExprKind::Struct(ref path, fields, ref expr) => {
-                self.hash_qpath(path);
-
-                for f in fields {
-                    self.hash_name(f.ident.name);
-                    self.hash_expr(&f.expr);
-                }
-
-                if let Some(ref e) = *expr {
-                    self.hash_expr(e);
-                }
-            },
-            ExprKind::Tup(tup) => {
-                self.hash_exprs(tup);
-            },
-            ExprKind::Array(v) => {
-                self.hash_exprs(v);
-            },
-            ExprKind::Unary(lop, ref le) => {
-                lop.hash_stable(&mut self.cx.tcx.get_stable_hashing_context(), &mut self.s);
-                self.hash_expr(le);
-            },
-        }
-    }
-
-    pub fn hash_exprs(&mut self, e: &[Expr<'_>]) {
-        for e in e {
-            self.hash_expr(e);
-        }
-    }
-
-    pub fn hash_name(&mut self, n: Symbol) {
-        n.as_str().hash(&mut self.s);
-    }
-
-    pub fn hash_qpath(&mut self, p: &QPath<'_>) {
-        match *p {
-            QPath::Resolved(_, ref path) => {
-                self.hash_path(path);
-            },
-            QPath::TypeRelative(_, ref path) => {
-                self.hash_name(path.ident.name);
-            },
-            QPath::LangItem(lang_item, ..) => {
-                lang_item.hash_stable(&mut self.cx.tcx.get_stable_hashing_context(), &mut self.s);
-            },
-        }
-        // self.maybe_typeck_results.unwrap().qpath_res(p, id).hash(&mut self.s);
-    }
-
-    pub fn hash_path(&mut self, path: &Path<'_>) {
-        match path.res {
-            // constant hash since equality is dependant on inter-expression context
-            Res::Local(_) => 1_usize.hash(&mut self.s),
-            _ => {
-                for seg in path.segments {
-                    self.hash_name(seg.ident.name);
-                }
-            },
-        }
-    }
-
-    pub fn hash_stmt(&mut self, b: &Stmt<'_>) {
-        std::mem::discriminant(&b.kind).hash(&mut self.s);
-
-        match &b.kind {
-            StmtKind::Local(local) => {
-                if let Some(ref init) = local.init {
-                    self.hash_expr(init);
-                }
-            },
-            StmtKind::Item(..) => {},
-            StmtKind::Expr(expr) | StmtKind::Semi(expr) => {
-                self.hash_expr(expr);
-            },
-        }
-    }
-
-    pub fn hash_guard(&mut self, g: &Guard<'_>) {
-        match g {
-            Guard::If(ref expr) | Guard::IfLet(_, ref expr) => {
-                self.hash_expr(expr);
-            },
-        }
-    }
-
-    pub fn hash_lifetime(&mut self, lifetime: &Lifetime) {
-        std::mem::discriminant(&lifetime.name).hash(&mut self.s);
-        if let LifetimeName::Param(ref name) = lifetime.name {
-            std::mem::discriminant(name).hash(&mut self.s);
-            match name {
-                ParamName::Plain(ref ident) => {
-                    ident.name.hash(&mut self.s);
-                },
-                ParamName::Fresh(ref size) => {
-                    size.hash(&mut self.s);
-                },
-                ParamName::Error => {},
-            }
-        }
-    }
-
-    pub fn hash_ty(&mut self, ty: &Ty<'_>) {
-        self.hash_tykind(&ty.kind);
-    }
-
-    pub fn hash_tykind(&mut self, ty: &TyKind<'_>) {
-        std::mem::discriminant(ty).hash(&mut self.s);
-        match ty {
-            TyKind::Slice(ty) => {
-                self.hash_ty(ty);
-            },
-            TyKind::Array(ty, anon_const) => {
-                self.hash_ty(ty);
-                self.hash_body(anon_const.body);
-            },
-            TyKind::Ptr(mut_ty) => {
-                self.hash_ty(&mut_ty.ty);
-                mut_ty.mutbl.hash(&mut self.s);
-            },
-            TyKind::Rptr(lifetime, mut_ty) => {
-                self.hash_lifetime(lifetime);
-                self.hash_ty(&mut_ty.ty);
-                mut_ty.mutbl.hash(&mut self.s);
-            },
-            TyKind::BareFn(bfn) => {
-                bfn.unsafety.hash(&mut self.s);
-                bfn.abi.hash(&mut self.s);
-                for arg in bfn.decl.inputs {
-                    self.hash_ty(&arg);
-                }
-                match bfn.decl.output {
-                    FnRetTy::DefaultReturn(_) => {
-                        ().hash(&mut self.s);
-                    },
-                    FnRetTy::Return(ref ty) => {
-                        self.hash_ty(ty);
-                    },
-                }
-                bfn.decl.c_variadic.hash(&mut self.s);
-            },
-            TyKind::Tup(ty_list) => {
-                for ty in *ty_list {
-                    self.hash_ty(ty);
-                }
-            },
-            TyKind::Path(qpath) => match qpath {
-                QPath::Resolved(ref maybe_ty, ref path) => {
-                    if let Some(ref ty) = maybe_ty {
-                        self.hash_ty(ty);
-                    }
-                    for segment in path.segments {
-                        segment.ident.name.hash(&mut self.s);
-                        self.hash_generic_args(segment.args().args);
-                    }
-                },
-                QPath::TypeRelative(ref ty, ref segment) => {
-                    self.hash_ty(ty);
-                    segment.ident.name.hash(&mut self.s);
-                },
-                QPath::LangItem(lang_item, ..) => {
-                    lang_item.hash(&mut self.s);
-                },
-            },
-            TyKind::OpaqueDef(_, arg_list) => {
-                self.hash_generic_args(arg_list);
-            },
-            TyKind::TraitObject(_, lifetime) => {
-                self.hash_lifetime(lifetime);
-            },
-            TyKind::Typeof(anon_const) => {
-                self.hash_body(anon_const.body);
-            },
-            TyKind::Err | TyKind::Infer | TyKind::Never => {},
-        }
-    }
-
-    pub fn hash_body(&mut self, body_id: BodyId) {
-        // swap out TypeckResults when hashing a body
-        let old_maybe_typeck_results = self.maybe_typeck_results.replace(self.cx.tcx.typeck_body(body_id));
-        self.hash_expr(&self.cx.tcx.hir().body(body_id).value);
-        self.maybe_typeck_results = old_maybe_typeck_results;
-    }
-
-    fn hash_generic_args(&mut self, arg_list: &[GenericArg<'_>]) {
-        for arg in arg_list {
-            match arg {
-                GenericArg::Lifetime(ref l) => self.hash_lifetime(l),
-                GenericArg::Type(ref ty) => self.hash_ty(&ty),
-                GenericArg::Const(ref ca) => self.hash_body(ca.value.body),
-            }
-        }
-    }
-}
diff --git a/clippy_lints/src/utils/inspector.rs b/clippy_lints/src/utils/inspector.rs
deleted file mode 100644
index 9bec24be9e4..00000000000
--- a/clippy_lints/src/utils/inspector.rs
+++ /dev/null
@@ -1,578 +0,0 @@
-//! checks for attributes
-
-use crate::utils::get_attr;
-use rustc_ast::ast::{Attribute, InlineAsmTemplatePiece};
-use rustc_hir as hir;
-use rustc_lint::{LateContext, LateLintPass, LintContext};
-use rustc_session::Session;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-
-declare_clippy_lint! {
-    /// **What it does:** Dumps every ast/hir node which has the `#[clippy::dump]`
-    /// attribute
-    ///
-    /// **Example:**
-    /// ```rust,ignore
-    /// #[clippy::dump]
-    /// extern crate foo;
-    /// ```
-    ///
-    /// prints
-    ///
-    /// ```text
-    /// item `foo`
-    /// visibility inherited from outer item
-    /// extern crate dylib source: "/path/to/foo.so"
-    /// ```
-    pub DEEP_CODE_INSPECTION,
-    internal_warn,
-    "helper to dump info about code"
-}
-
-declare_lint_pass!(DeepCodeInspector => [DEEP_CODE_INSPECTION]);
-
-impl<'tcx> LateLintPass<'tcx> for DeepCodeInspector {
-    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) {
-        if !has_attr(cx.sess(), &item.attrs) {
-            return;
-        }
-        print_item(cx, item);
-    }
-
-    fn check_impl_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::ImplItem<'_>) {
-        if !has_attr(cx.sess(), &item.attrs) {
-            return;
-        }
-        println!("impl item `{}`", item.ident.name);
-        match item.vis.node {
-            hir::VisibilityKind::Public => println!("public"),
-            hir::VisibilityKind::Crate(_) => println!("visible crate wide"),
-            hir::VisibilityKind::Restricted { ref path, .. } => println!(
-                "visible in module `{}`",
-                rustc_hir_pretty::to_string(rustc_hir_pretty::NO_ANN, |s| s.print_path(path, false))
-            ),
-            hir::VisibilityKind::Inherited => println!("visibility inherited from outer item"),
-        }
-        if item.defaultness.is_default() {
-            println!("default");
-        }
-        match item.kind {
-            hir::ImplItemKind::Const(_, body_id) => {
-                println!("associated constant");
-                print_expr(cx, &cx.tcx.hir().body(body_id).value, 1);
-            },
-            hir::ImplItemKind::Fn(..) => println!("method"),
-            hir::ImplItemKind::TyAlias(_) => println!("associated type"),
-        }
-    }
-    // fn check_trait_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx
-    // hir::TraitItem) {
-    // if !has_attr(&item.attrs) {
-    // return;
-    // }
-    // }
-    //
-    // fn check_variant(&mut self, cx: &LateContext<'tcx>, var: &'tcx
-    // hir::Variant, _:
-    // &hir::Generics) {
-    // if !has_attr(&var.node.attrs) {
-    // return;
-    // }
-    // }
-    //
-    // fn check_struct_field(&mut self, cx: &LateContext<'tcx>, field: &'tcx
-    // hir::StructField) {
-    // if !has_attr(&field.attrs) {
-    // return;
-    // }
-    // }
-    //
-
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
-        if !has_attr(cx.sess(), &expr.attrs) {
-            return;
-        }
-        print_expr(cx, expr, 0);
-    }
-
-    fn check_arm(&mut self, cx: &LateContext<'tcx>, arm: &'tcx hir::Arm<'_>) {
-        if !has_attr(cx.sess(), &arm.attrs) {
-            return;
-        }
-        print_pat(cx, &arm.pat, 1);
-        if let Some(ref guard) = arm.guard {
-            println!("guard:");
-            print_guard(cx, guard, 1);
-        }
-        println!("body:");
-        print_expr(cx, &arm.body, 1);
-    }
-
-    fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx hir::Stmt<'_>) {
-        if !has_attr(cx.sess(), stmt.kind.attrs(|id| cx.tcx.hir().item(id.id))) {
-            return;
-        }
-        match stmt.kind {
-            hir::StmtKind::Local(ref local) => {
-                println!("local variable of type {}", cx.typeck_results().node_type(local.hir_id));
-                println!("pattern:");
-                print_pat(cx, &local.pat, 0);
-                if let Some(ref e) = local.init {
-                    println!("init expression:");
-                    print_expr(cx, e, 0);
-                }
-            },
-            hir::StmtKind::Item(_) => println!("item decl"),
-            hir::StmtKind::Expr(ref e) | hir::StmtKind::Semi(ref e) => print_expr(cx, e, 0),
-        }
-    }
-    // fn check_foreign_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx
-    // hir::ForeignItem) {
-    // if !has_attr(&item.attrs) {
-    // return;
-    // }
-    // }
-    //
-}
-
-fn has_attr(sess: &Session, attrs: &[Attribute]) -> bool {
-    get_attr(sess, attrs, "dump").count() > 0
-}
-
-#[allow(clippy::similar_names)]
-#[allow(clippy::too_many_lines)]
-fn print_expr(cx: &LateContext<'_>, expr: &hir::Expr<'_>, indent: usize) {
-    let ind = "  ".repeat(indent);
-    println!("{}+", ind);
-    println!("{}ty: {}", ind, cx.typeck_results().expr_ty(expr));
-    println!(
-        "{}adjustments: {:?}",
-        ind,
-        cx.typeck_results().adjustments().get(expr.hir_id)
-    );
-    match expr.kind {
-        hir::ExprKind::Box(ref e) => {
-            println!("{}Box", ind);
-            print_expr(cx, e, indent + 1);
-        },
-        hir::ExprKind::Array(v) => {
-            println!("{}Array", ind);
-            for e in v {
-                print_expr(cx, e, indent + 1);
-            }
-        },
-        hir::ExprKind::Call(ref func, args) => {
-            println!("{}Call", ind);
-            println!("{}function:", ind);
-            print_expr(cx, func, indent + 1);
-            println!("{}arguments:", ind);
-            for arg in args {
-                print_expr(cx, arg, indent + 1);
-            }
-        },
-        hir::ExprKind::MethodCall(ref path, _, args, _) => {
-            println!("{}MethodCall", ind);
-            println!("{}method name: {}", ind, path.ident.name);
-            for arg in args {
-                print_expr(cx, arg, indent + 1);
-            }
-        },
-        hir::ExprKind::Tup(v) => {
-            println!("{}Tup", ind);
-            for e in v {
-                print_expr(cx, e, indent + 1);
-            }
-        },
-        hir::ExprKind::Binary(op, ref lhs, ref rhs) => {
-            println!("{}Binary", ind);
-            println!("{}op: {:?}", ind, op.node);
-            println!("{}lhs:", ind);
-            print_expr(cx, lhs, indent + 1);
-            println!("{}rhs:", ind);
-            print_expr(cx, rhs, indent + 1);
-        },
-        hir::ExprKind::Unary(op, ref inner) => {
-            println!("{}Unary", ind);
-            println!("{}op: {:?}", ind, op);
-            print_expr(cx, inner, indent + 1);
-        },
-        hir::ExprKind::Lit(ref lit) => {
-            println!("{}Lit", ind);
-            println!("{}{:?}", ind, lit);
-        },
-        hir::ExprKind::Cast(ref e, ref target) => {
-            println!("{}Cast", ind);
-            print_expr(cx, e, indent + 1);
-            println!("{}target type: {:?}", ind, target);
-        },
-        hir::ExprKind::Type(ref e, ref target) => {
-            println!("{}Type", ind);
-            print_expr(cx, e, indent + 1);
-            println!("{}target type: {:?}", ind, target);
-        },
-        hir::ExprKind::Loop(..) => {
-            println!("{}Loop", ind);
-        },
-        hir::ExprKind::If(ref cond, _, ref else_opt) => {
-            println!("{}If", ind);
-            println!("{}condition:", ind);
-            print_expr(cx, cond, indent + 1);
-            if let Some(ref els) = *else_opt {
-                println!("{}else:", ind);
-                print_expr(cx, els, indent + 1);
-            }
-        },
-        hir::ExprKind::Match(ref cond, _, ref source) => {
-            println!("{}Match", ind);
-            println!("{}condition:", ind);
-            print_expr(cx, cond, indent + 1);
-            println!("{}source: {:?}", ind, source);
-        },
-        hir::ExprKind::Closure(ref clause, _, _, _, _) => {
-            println!("{}Closure", ind);
-            println!("{}clause: {:?}", ind, clause);
-        },
-        hir::ExprKind::Yield(ref sub, _) => {
-            println!("{}Yield", ind);
-            print_expr(cx, sub, indent + 1);
-        },
-        hir::ExprKind::Block(_, _) => {
-            println!("{}Block", ind);
-        },
-        hir::ExprKind::Assign(ref lhs, ref rhs, _) => {
-            println!("{}Assign", ind);
-            println!("{}lhs:", ind);
-            print_expr(cx, lhs, indent + 1);
-            println!("{}rhs:", ind);
-            print_expr(cx, rhs, indent + 1);
-        },
-        hir::ExprKind::AssignOp(ref binop, ref lhs, ref rhs) => {
-            println!("{}AssignOp", ind);
-            println!("{}op: {:?}", ind, binop.node);
-            println!("{}lhs:", ind);
-            print_expr(cx, lhs, indent + 1);
-            println!("{}rhs:", ind);
-            print_expr(cx, rhs, indent + 1);
-        },
-        hir::ExprKind::Field(ref e, ident) => {
-            println!("{}Field", ind);
-            println!("{}field name: {}", ind, ident.name);
-            println!("{}struct expr:", ind);
-            print_expr(cx, e, indent + 1);
-        },
-        hir::ExprKind::Index(ref arr, ref idx) => {
-            println!("{}Index", ind);
-            println!("{}array expr:", ind);
-            print_expr(cx, arr, indent + 1);
-            println!("{}index expr:", ind);
-            print_expr(cx, idx, indent + 1);
-        },
-        hir::ExprKind::Path(hir::QPath::Resolved(ref ty, ref path)) => {
-            println!("{}Resolved Path, {:?}", ind, ty);
-            println!("{}path: {:?}", ind, path);
-        },
-        hir::ExprKind::Path(hir::QPath::TypeRelative(ref ty, ref seg)) => {
-            println!("{}Relative Path, {:?}", ind, ty);
-            println!("{}seg: {:?}", ind, seg);
-        },
-        hir::ExprKind::Path(hir::QPath::LangItem(lang_item, ..)) => {
-            println!("{}Lang Item Path, {:?}", ind, lang_item.name());
-        },
-        hir::ExprKind::AddrOf(kind, ref muta, ref e) => {
-            println!("{}AddrOf", ind);
-            println!("kind: {:?}", kind);
-            println!("mutability: {:?}", muta);
-            print_expr(cx, e, indent + 1);
-        },
-        hir::ExprKind::Break(_, ref e) => {
-            println!("{}Break", ind);
-            if let Some(ref e) = *e {
-                print_expr(cx, e, indent + 1);
-            }
-        },
-        hir::ExprKind::Continue(_) => println!("{}Again", ind),
-        hir::ExprKind::Ret(ref e) => {
-            println!("{}Ret", ind);
-            if let Some(ref e) = *e {
-                print_expr(cx, e, indent + 1);
-            }
-        },
-        hir::ExprKind::InlineAsm(ref asm) => {
-            println!("{}InlineAsm", ind);
-            println!("{}template: {}", ind, InlineAsmTemplatePiece::to_string(asm.template));
-            println!("{}options: {:?}", ind, asm.options);
-            println!("{}operands:", ind);
-            for (op, _op_sp) in asm.operands {
-                match op {
-                    hir::InlineAsmOperand::In { expr, .. }
-                    | hir::InlineAsmOperand::InOut { expr, .. }
-                    | hir::InlineAsmOperand::Const { expr }
-                    | hir::InlineAsmOperand::Sym { expr } => print_expr(cx, expr, indent + 1),
-                    hir::InlineAsmOperand::Out { expr, .. } => {
-                        if let Some(expr) = expr {
-                            print_expr(cx, expr, indent + 1);
-                        }
-                    },
-                    hir::InlineAsmOperand::SplitInOut { in_expr, out_expr, .. } => {
-                        print_expr(cx, in_expr, indent + 1);
-                        if let Some(out_expr) = out_expr {
-                            print_expr(cx, out_expr, indent + 1);
-                        }
-                    },
-                }
-            }
-        },
-        hir::ExprKind::LlvmInlineAsm(ref asm) => {
-            let inputs = &asm.inputs_exprs;
-            let outputs = &asm.outputs_exprs;
-            println!("{}LlvmInlineAsm", ind);
-            println!("{}inputs:", ind);
-            for e in inputs.iter() {
-                print_expr(cx, e, indent + 1);
-            }
-            println!("{}outputs:", ind);
-            for e in outputs.iter() {
-                print_expr(cx, e, indent + 1);
-            }
-        },
-        hir::ExprKind::Struct(ref path, fields, ref base) => {
-            println!("{}Struct", ind);
-            println!("{}path: {:?}", ind, path);
-            for field in fields {
-                println!("{}field \"{}\":", ind, field.ident.name);
-                print_expr(cx, &field.expr, indent + 1);
-            }
-            if let Some(ref base) = *base {
-                println!("{}base:", ind);
-                print_expr(cx, base, indent + 1);
-            }
-        },
-        hir::ExprKind::ConstBlock(ref anon_const) => {
-            println!("{}ConstBlock", ind);
-            println!("{}anon_const:", ind);
-            print_expr(cx, &cx.tcx.hir().body(anon_const.body).value, indent + 1);
-        },
-        hir::ExprKind::Repeat(ref val, ref anon_const) => {
-            println!("{}Repeat", ind);
-            println!("{}value:", ind);
-            print_expr(cx, val, indent + 1);
-            println!("{}repeat count:", ind);
-            print_expr(cx, &cx.tcx.hir().body(anon_const.body).value, indent + 1);
-        },
-        hir::ExprKind::Err => {
-            println!("{}Err", ind);
-        },
-        hir::ExprKind::DropTemps(ref e) => {
-            println!("{}DropTemps", ind);
-            print_expr(cx, e, indent + 1);
-        },
-    }
-}
-
-fn print_item(cx: &LateContext<'_>, item: &hir::Item<'_>) {
-    let did = cx.tcx.hir().local_def_id(item.hir_id);
-    println!("item `{}`", item.ident.name);
-    match item.vis.node {
-        hir::VisibilityKind::Public => println!("public"),
-        hir::VisibilityKind::Crate(_) => println!("visible crate wide"),
-        hir::VisibilityKind::Restricted { ref path, .. } => println!(
-            "visible in module `{}`",
-            rustc_hir_pretty::to_string(rustc_hir_pretty::NO_ANN, |s| s.print_path(path, false))
-        ),
-        hir::VisibilityKind::Inherited => println!("visibility inherited from outer item"),
-    }
-    match item.kind {
-        hir::ItemKind::ExternCrate(ref _renamed_from) => {
-            let def_id = cx.tcx.hir().local_def_id(item.hir_id);
-            if let Some(crate_id) = cx.tcx.extern_mod_stmt_cnum(def_id) {
-                let source = cx.tcx.used_crate_source(crate_id);
-                if let Some(ref src) = source.dylib {
-                    println!("extern crate dylib source: {:?}", src.0);
-                }
-                if let Some(ref src) = source.rlib {
-                    println!("extern crate rlib source: {:?}", src.0);
-                }
-            } else {
-                println!("weird extern crate without a crate id");
-            }
-        },
-        hir::ItemKind::Use(ref path, ref kind) => println!("{:?}, {:?}", path, kind),
-        hir::ItemKind::Static(..) => println!("static item of type {:#?}", cx.tcx.type_of(did)),
-        hir::ItemKind::Const(..) => println!("const item of type {:#?}", cx.tcx.type_of(did)),
-        hir::ItemKind::Fn(..) => {
-            let item_ty = cx.tcx.type_of(did);
-            println!("function of type {:#?}", item_ty);
-        },
-        hir::ItemKind::Mod(..) => println!("module"),
-        hir::ItemKind::ForeignMod { abi, .. } => println!("foreign module with abi: {}", abi),
-        hir::ItemKind::GlobalAsm(ref asm) => println!("global asm: {:?}", asm),
-        hir::ItemKind::TyAlias(..) => {
-            println!("type alias for {:?}", cx.tcx.type_of(did));
-        },
-        hir::ItemKind::OpaqueTy(..) => {
-            println!("existential type with real type {:?}", cx.tcx.type_of(did));
-        },
-        hir::ItemKind::Enum(..) => {
-            println!("enum definition of type {:?}", cx.tcx.type_of(did));
-        },
-        hir::ItemKind::Struct(..) => {
-            println!("struct definition of type {:?}", cx.tcx.type_of(did));
-        },
-        hir::ItemKind::Union(..) => {
-            println!("union definition of type {:?}", cx.tcx.type_of(did));
-        },
-        hir::ItemKind::Trait(..) => {
-            println!("trait decl");
-            if cx.tcx.trait_is_auto(did.to_def_id()) {
-                println!("trait is auto");
-            } else {
-                println!("trait is not auto");
-            }
-        },
-        hir::ItemKind::TraitAlias(..) => {
-            println!("trait alias");
-        },
-        hir::ItemKind::Impl(hir::Impl {
-            of_trait: Some(ref _trait_ref),
-            ..
-        }) => {
-            println!("trait impl");
-        },
-        hir::ItemKind::Impl(hir::Impl { of_trait: None, .. }) => {
-            println!("impl");
-        },
-    }
-}
-
-#[allow(clippy::similar_names)]
-#[allow(clippy::too_many_lines)]
-fn print_pat(cx: &LateContext<'_>, pat: &hir::Pat<'_>, indent: usize) {
-    let ind = "  ".repeat(indent);
-    println!("{}+", ind);
-    match pat.kind {
-        hir::PatKind::Wild => println!("{}Wild", ind),
-        hir::PatKind::Binding(ref mode, .., ident, ref inner) => {
-            println!("{}Binding", ind);
-            println!("{}mode: {:?}", ind, mode);
-            println!("{}name: {}", ind, ident.name);
-            if let Some(ref inner) = *inner {
-                println!("{}inner:", ind);
-                print_pat(cx, inner, indent + 1);
-            }
-        },
-        hir::PatKind::Or(fields) => {
-            println!("{}Or", ind);
-            for field in fields {
-                print_pat(cx, field, indent + 1);
-            }
-        },
-        hir::PatKind::Struct(ref path, fields, ignore) => {
-            println!("{}Struct", ind);
-            println!(
-                "{}name: {}",
-                ind,
-                rustc_hir_pretty::to_string(rustc_hir_pretty::NO_ANN, |s| s.print_qpath(path, false))
-            );
-            println!("{}ignore leftover fields: {}", ind, ignore);
-            println!("{}fields:", ind);
-            for field in fields {
-                println!("{}  field name: {}", ind, field.ident.name);
-                if field.is_shorthand {
-                    println!("{}  in shorthand notation", ind);
-                }
-                print_pat(cx, &field.pat, indent + 1);
-            }
-        },
-        hir::PatKind::TupleStruct(ref path, fields, opt_dots_position) => {
-            println!("{}TupleStruct", ind);
-            println!(
-                "{}path: {}",
-                ind,
-                rustc_hir_pretty::to_string(rustc_hir_pretty::NO_ANN, |s| s.print_qpath(path, false))
-            );
-            if let Some(dot_position) = opt_dots_position {
-                println!("{}dot position: {}", ind, dot_position);
-            }
-            for field in fields {
-                print_pat(cx, field, indent + 1);
-            }
-        },
-        hir::PatKind::Path(hir::QPath::Resolved(ref ty, ref path)) => {
-            println!("{}Resolved Path, {:?}", ind, ty);
-            println!("{}path: {:?}", ind, path);
-        },
-        hir::PatKind::Path(hir::QPath::TypeRelative(ref ty, ref seg)) => {
-            println!("{}Relative Path, {:?}", ind, ty);
-            println!("{}seg: {:?}", ind, seg);
-        },
-        hir::PatKind::Path(hir::QPath::LangItem(lang_item, ..)) => {
-            println!("{}Lang Item Path, {:?}", ind, lang_item.name());
-        },
-        hir::PatKind::Tuple(pats, opt_dots_position) => {
-            println!("{}Tuple", ind);
-            if let Some(dot_position) = opt_dots_position {
-                println!("{}dot position: {}", ind, dot_position);
-            }
-            for field in pats {
-                print_pat(cx, field, indent + 1);
-            }
-        },
-        hir::PatKind::Box(ref inner) => {
-            println!("{}Box", ind);
-            print_pat(cx, inner, indent + 1);
-        },
-        hir::PatKind::Ref(ref inner, ref muta) => {
-            println!("{}Ref", ind);
-            println!("{}mutability: {:?}", ind, muta);
-            print_pat(cx, inner, indent + 1);
-        },
-        hir::PatKind::Lit(ref e) => {
-            println!("{}Lit", ind);
-            print_expr(cx, e, indent + 1);
-        },
-        hir::PatKind::Range(ref l, ref r, ref range_end) => {
-            println!("{}Range", ind);
-            if let Some(expr) = l {
-                print_expr(cx, expr, indent + 1);
-            }
-            if let Some(expr) = r {
-                print_expr(cx, expr, indent + 1);
-            }
-            match *range_end {
-                hir::RangeEnd::Included => println!("{} end included", ind),
-                hir::RangeEnd::Excluded => println!("{} end excluded", ind),
-            }
-        },
-        hir::PatKind::Slice(first_pats, ref range, last_pats) => {
-            println!("{}Slice [a, b, ..i, y, z]", ind);
-            println!("[a, b]:");
-            for pat in first_pats {
-                print_pat(cx, pat, indent + 1);
-            }
-            println!("i:");
-            if let Some(ref pat) = *range {
-                print_pat(cx, pat, indent + 1);
-            }
-            println!("[y, z]:");
-            for pat in last_pats {
-                print_pat(cx, pat, indent + 1);
-            }
-        },
-    }
-}
-
-fn print_guard(cx: &LateContext<'_>, guard: &hir::Guard<'_>, indent: usize) {
-    let ind = "  ".repeat(indent);
-    println!("{}+", ind);
-    match guard {
-        hir::Guard::If(expr) => {
-            println!("{}If", ind);
-            print_expr(cx, expr, indent + 1);
-        },
-        hir::Guard::IfLet(pat, expr) => {
-            println!("{}IfLet", ind);
-            print_pat(cx, pat, indent + 1);
-            print_expr(cx, expr, indent + 1);
-        },
-    }
-}
diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs
deleted file mode 100644
index d8c602fab22..00000000000
--- a/clippy_lints/src/utils/internal_lints.rs
+++ /dev/null
@@ -1,1070 +0,0 @@
-use crate::consts::{constant_simple, Constant};
-use crate::utils::{
-    is_expn_of, match_def_path, match_qpath, match_type, method_calls, path_to_res, paths, run_lints, snippet,
-    span_lint, span_lint_and_help, span_lint_and_sugg, SpanlessEq,
-};
-use if_chain::if_chain;
-use rustc_ast::ast::{Crate as AstCrate, ItemKind, LitKind, NodeId};
-use rustc_ast::visit::FnKind;
-use rustc_data_structures::fx::{FxHashMap, FxHashSet};
-use rustc_errors::Applicability;
-use rustc_hir as hir;
-use rustc_hir::def::{DefKind, Res};
-use rustc_hir::def_id::DefId;
-use rustc_hir::hir_id::CRATE_HIR_ID;
-use rustc_hir::intravisit::{NestedVisitorMap, Visitor};
-use rustc_hir::{
-    BinOpKind, Crate, Expr, ExprKind, HirId, Item, MutTy, Mutability, Node, Path, StmtKind, Ty, TyKind, UnOp,
-};
-use rustc_lint::{EarlyContext, EarlyLintPass, LateContext, LateLintPass};
-use rustc_middle::hir::map::Map;
-use rustc_middle::mir::interpret::ConstValue;
-use rustc_middle::ty;
-use rustc_session::{declare_lint_pass, declare_tool_lint, impl_lint_pass};
-use rustc_span::source_map::{Span, Spanned};
-use rustc_span::symbol::{Symbol, SymbolStr};
-use rustc_typeck::hir_ty_to_ty;
-
-use std::borrow::{Borrow, Cow};
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for various things we like to keep tidy in clippy.
-    ///
-    /// **Why is this bad?** We like to pretend we're an example of tidy code.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:** Wrong ordering of the util::paths constants.
-    pub CLIPPY_LINTS_INTERNAL,
-    internal,
-    "various things that will negatively affect your clippy experience"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Ensures every lint is associated to a `LintPass`.
-    ///
-    /// **Why is this bad?** The compiler only knows lints via a `LintPass`. Without
-    /// putting a lint to a `LintPass::get_lints()`'s return, the compiler will not
-    /// know the name of the lint.
-    ///
-    /// **Known problems:** Only checks for lints associated using the
-    /// `declare_lint_pass!`, `impl_lint_pass!`, and `lint_array!` macros.
-    ///
-    /// **Example:**
-    /// ```rust,ignore
-    /// declare_lint! { pub LINT_1, ... }
-    /// declare_lint! { pub LINT_2, ... }
-    /// declare_lint! { pub FORGOTTEN_LINT, ... }
-    /// // ...
-    /// declare_lint_pass!(Pass => [LINT_1, LINT_2]);
-    /// // missing FORGOTTEN_LINT
-    /// ```
-    pub LINT_WITHOUT_LINT_PASS,
-    internal,
-    "declaring a lint without associating it in a LintPass"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for calls to `cx.span_lint*` and suggests to use the `utils::*`
-    /// variant of the function.
-    ///
-    /// **Why is this bad?** The `utils::*` variants also add a link to the Clippy documentation to the
-    /// warning/error messages.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    /// Bad:
-    /// ```rust,ignore
-    /// cx.span_lint(LINT_NAME, "message");
-    /// ```
-    ///
-    /// Good:
-    /// ```rust,ignore
-    /// utils::span_lint(cx, LINT_NAME, "message");
-    /// ```
-    pub COMPILER_LINT_FUNCTIONS,
-    internal,
-    "usage of the lint functions of the compiler instead of the utils::* variant"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for calls to `cx.outer().expn_data()` and suggests to use
-    /// the `cx.outer_expn_data()`
-    ///
-    /// **Why is this bad?** `cx.outer_expn_data()` is faster and more concise.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    /// Bad:
-    /// ```rust,ignore
-    /// expr.span.ctxt().outer().expn_data()
-    /// ```
-    ///
-    /// Good:
-    /// ```rust,ignore
-    /// expr.span.ctxt().outer_expn_data()
-    /// ```
-    pub OUTER_EXPN_EXPN_DATA,
-    internal,
-    "using `cx.outer_expn().expn_data()` instead of `cx.outer_expn_data()`"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Not an actual lint. This lint is only meant for testing our customized internal compiler
-    /// error message by calling `panic`.
-    ///
-    /// **Why is this bad?** ICE in large quantities can damage your teeth
-    ///
-    /// **Known problems:** None
-    ///
-    /// **Example:**
-    /// Bad:
-    /// ```rust,ignore
-    /// 🍦🍦🍦🍦🍦
-    /// ```
-    pub PRODUCE_ICE,
-    internal,
-    "this message should not appear anywhere as we ICE before and don't emit the lint"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for cases of an auto-generated lint without an updated description,
-    /// i.e. `default lint description`.
-    ///
-    /// **Why is this bad?** Indicates that the lint is not finished.
-    ///
-    /// **Known problems:** None
-    ///
-    /// **Example:**
-    /// Bad:
-    /// ```rust,ignore
-    /// declare_lint! { pub COOL_LINT, nursery, "default lint description" }
-    /// ```
-    ///
-    /// Good:
-    /// ```rust,ignore
-    /// declare_lint! { pub COOL_LINT, nursery, "a great new lint" }
-    /// ```
-    pub DEFAULT_LINT,
-    internal,
-    "found 'default lint description' in a lint declaration"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Lints `span_lint_and_then` function calls, where the
-    /// closure argument has only one statement and that statement is a method
-    /// call to `span_suggestion`, `span_help`, `span_note` (using the same
-    /// span), `help` or `note`.
-    ///
-    /// These usages of `span_lint_and_then` should be replaced with one of the
-    /// wrapper functions `span_lint_and_sugg`, span_lint_and_help`, or
-    /// `span_lint_and_note`.
-    ///
-    /// **Why is this bad?** Using the wrapper `span_lint_and_*` functions, is more
-    /// convenient, readable and less error prone.
-    ///
-    /// **Known problems:** None
-    ///
-    /// *Example:**
-    /// Bad:
-    /// ```rust,ignore
-    /// span_lint_and_then(cx, TEST_LINT, expr.span, lint_msg, |diag| {
-    ///     diag.span_suggestion(
-    ///         expr.span,
-    ///         help_msg,
-    ///         sugg.to_string(),
-    ///         Applicability::MachineApplicable,
-    ///     );
-    /// });
-    /// span_lint_and_then(cx, TEST_LINT, expr.span, lint_msg, |diag| {
-    ///     diag.span_help(expr.span, help_msg);
-    /// });
-    /// span_lint_and_then(cx, TEST_LINT, expr.span, lint_msg, |diag| {
-    ///     diag.help(help_msg);
-    /// });
-    /// span_lint_and_then(cx, TEST_LINT, expr.span, lint_msg, |diag| {
-    ///     diag.span_note(expr.span, note_msg);
-    /// });
-    /// span_lint_and_then(cx, TEST_LINT, expr.span, lint_msg, |diag| {
-    ///     diag.note(note_msg);
-    /// });
-    /// ```
-    ///
-    /// Good:
-    /// ```rust,ignore
-    /// span_lint_and_sugg(
-    ///     cx,
-    ///     TEST_LINT,
-    ///     expr.span,
-    ///     lint_msg,
-    ///     help_msg,
-    ///     sugg.to_string(),
-    ///     Applicability::MachineApplicable,
-    /// );
-    /// span_lint_and_help(cx, TEST_LINT, expr.span, lint_msg, Some(expr.span), help_msg);
-    /// span_lint_and_help(cx, TEST_LINT, expr.span, lint_msg, None, help_msg);
-    /// span_lint_and_note(cx, TEST_LINT, expr.span, lint_msg, Some(expr.span), note_msg);
-    /// span_lint_and_note(cx, TEST_LINT, expr.span, lint_msg, None, note_msg);
-    /// ```
-    pub COLLAPSIBLE_SPAN_LINT_CALLS,
-    internal,
-    "found collapsible `span_lint_and_then` calls"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for calls to `utils::match_type()` on a type diagnostic item
-    /// and suggests to use `utils::is_type_diagnostic_item()` instead.
-    ///
-    /// **Why is this bad?** `utils::is_type_diagnostic_item()` does not require hardcoded paths.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    /// Bad:
-    /// ```rust,ignore
-    /// utils::match_type(cx, ty, &paths::VEC)
-    /// ```
-    ///
-    /// Good:
-    /// ```rust,ignore
-    /// utils::is_type_diagnostic_item(cx, ty, sym::vec_type)
-    /// ```
-    pub MATCH_TYPE_ON_DIAGNOSTIC_ITEM,
-    internal,
-    "using `utils::match_type()` instead of `utils::is_type_diagnostic_item()`"
-}
-
-declare_clippy_lint! {
-    /// **What it does:**
-    /// Checks the paths module for invalid paths.
-    ///
-    /// **Why is this bad?**
-    /// It indicates a bug in the code.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:** None.
-    pub INVALID_PATHS,
-    internal,
-    "invalid path"
-}
-
-declare_clippy_lint! {
-    /// **What it does:**
-    /// Checks for interning symbols that have already been pre-interned and defined as constants.
-    ///
-    /// **Why is this bad?**
-    /// It's faster and easier to use the symbol constant.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    /// Bad:
-    /// ```rust,ignore
-    /// let _ = sym!(f32);
-    /// ```
-    ///
-    /// Good:
-    /// ```rust,ignore
-    /// let _ = sym::f32;
-    /// ```
-    pub INTERNING_DEFINED_SYMBOL,
-    internal,
-    "interning a symbol that is pre-interned and defined as a constant"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for unnecessary conversion from Symbol to a string.
-    ///
-    /// **Why is this bad?** It's faster use symbols directly intead of strings.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    /// Bad:
-    /// ```rust,ignore
-    /// symbol.as_str() == "clippy";
-    /// ```
-    ///
-    /// Good:
-    /// ```rust,ignore
-    /// symbol == sym::clippy;
-    /// ```
-    pub UNNECESSARY_SYMBOL_STR,
-    internal,
-    "unnecessary conversion between Symbol and string"
-}
-
-declare_lint_pass!(ClippyLintsInternal => [CLIPPY_LINTS_INTERNAL]);
-
-impl EarlyLintPass for ClippyLintsInternal {
-    fn check_crate(&mut self, cx: &EarlyContext<'_>, krate: &AstCrate) {
-        if let Some(utils) = krate
-            .module
-            .items
-            .iter()
-            .find(|item| item.ident.name.as_str() == "utils")
-        {
-            if let ItemKind::Mod(ref utils_mod) = utils.kind {
-                if let Some(paths) = utils_mod.items.iter().find(|item| item.ident.name.as_str() == "paths") {
-                    if let ItemKind::Mod(ref paths_mod) = paths.kind {
-                        let mut last_name: Option<SymbolStr> = None;
-                        for item in &*paths_mod.items {
-                            let name = item.ident.as_str();
-                            if let Some(ref last_name) = last_name {
-                                if **last_name > *name {
-                                    span_lint(
-                                        cx,
-                                        CLIPPY_LINTS_INTERNAL,
-                                        item.span,
-                                        "this constant should be before the previous constant due to lexical \
-                                         ordering",
-                                    );
-                                }
-                            }
-                            last_name = Some(name);
-                        }
-                    }
-                }
-            }
-        }
-    }
-}
-
-#[derive(Clone, Debug, Default)]
-pub struct LintWithoutLintPass {
-    declared_lints: FxHashMap<Symbol, Span>,
-    registered_lints: FxHashSet<Symbol>,
-}
-
-impl_lint_pass!(LintWithoutLintPass => [DEFAULT_LINT, LINT_WITHOUT_LINT_PASS]);
-
-impl<'tcx> LateLintPass<'tcx> for LintWithoutLintPass {
-    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
-        if !run_lints(cx, &[DEFAULT_LINT], item.hir_id) {
-            return;
-        }
-
-        if let hir::ItemKind::Static(ref ty, Mutability::Not, body_id) = item.kind {
-            if is_lint_ref_type(cx, ty) {
-                let expr = &cx.tcx.hir().body(body_id).value;
-                if_chain! {
-                    if let ExprKind::AddrOf(_, _, ref inner_exp) = expr.kind;
-                    if let ExprKind::Struct(_, ref fields, _) = inner_exp.kind;
-                    let field = fields
-                        .iter()
-                        .find(|f| f.ident.as_str() == "desc")
-                        .expect("lints must have a description field");
-                    if let ExprKind::Lit(Spanned {
-                        node: LitKind::Str(ref sym, _),
-                        ..
-                    }) = field.expr.kind;
-                    if sym.as_str() == "default lint description";
-
-                    then {
-                        span_lint(
-                            cx,
-                            DEFAULT_LINT,
-                            item.span,
-                            &format!("the lint `{}` has the default lint description", item.ident.name),
-                        );
-                    }
-                }
-                self.declared_lints.insert(item.ident.name, item.span);
-            }
-        } else if is_expn_of(item.span, "impl_lint_pass").is_some()
-            || is_expn_of(item.span, "declare_lint_pass").is_some()
-        {
-            if let hir::ItemKind::Impl(hir::Impl {
-                of_trait: None,
-                items: ref impl_item_refs,
-                ..
-            }) = item.kind
-            {
-                let mut collector = LintCollector {
-                    output: &mut self.registered_lints,
-                    cx,
-                };
-                let body_id = cx.tcx.hir().body_owned_by(
-                    impl_item_refs
-                        .iter()
-                        .find(|iiref| iiref.ident.as_str() == "get_lints")
-                        .expect("LintPass needs to implement get_lints")
-                        .id
-                        .hir_id,
-                );
-                collector.visit_expr(&cx.tcx.hir().body(body_id).value);
-            }
-        }
-    }
-
-    fn check_crate_post(&mut self, cx: &LateContext<'tcx>, _: &'tcx Crate<'_>) {
-        if !run_lints(cx, &[LINT_WITHOUT_LINT_PASS], CRATE_HIR_ID) {
-            return;
-        }
-
-        for (lint_name, &lint_span) in &self.declared_lints {
-            // When using the `declare_tool_lint!` macro, the original `lint_span`'s
-            // file points to "<rustc macros>".
-            // `compiletest-rs` thinks that's an error in a different file and
-            // just ignores it. This causes the test in compile-fail/lint_pass
-            // not able to capture the error.
-            // Therefore, we need to climb the macro expansion tree and find the
-            // actual span that invoked `declare_tool_lint!`:
-            let lint_span = lint_span.ctxt().outer_expn_data().call_site;
-
-            if !self.registered_lints.contains(lint_name) {
-                span_lint(
-                    cx,
-                    LINT_WITHOUT_LINT_PASS,
-                    lint_span,
-                    &format!("the lint `{}` is not added to any `LintPass`", lint_name),
-                );
-            }
-        }
-    }
-}
-
-fn is_lint_ref_type<'tcx>(cx: &LateContext<'tcx>, ty: &Ty<'_>) -> bool {
-    if let TyKind::Rptr(
-        _,
-        MutTy {
-            ty: ref inner,
-            mutbl: Mutability::Not,
-        },
-    ) = ty.kind
-    {
-        if let TyKind::Path(ref path) = inner.kind {
-            if let Res::Def(DefKind::Struct, def_id) = cx.qpath_res(path, inner.hir_id) {
-                return match_def_path(cx, def_id, &paths::LINT);
-            }
-        }
-    }
-
-    false
-}
-
-struct LintCollector<'a, 'tcx> {
-    output: &'a mut FxHashSet<Symbol>,
-    cx: &'a LateContext<'tcx>,
-}
-
-impl<'a, 'tcx> Visitor<'tcx> for LintCollector<'a, 'tcx> {
-    type Map = Map<'tcx>;
-
-    fn visit_path(&mut self, path: &'tcx Path<'_>, _: HirId) {
-        if path.segments.len() == 1 {
-            self.output.insert(path.segments[0].ident.name);
-        }
-    }
-
-    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-        NestedVisitorMap::All(self.cx.tcx.hir())
-    }
-}
-
-#[derive(Clone, Default)]
-pub struct CompilerLintFunctions {
-    map: FxHashMap<&'static str, &'static str>,
-}
-
-impl CompilerLintFunctions {
-    #[must_use]
-    pub fn new() -> Self {
-        let mut map = FxHashMap::default();
-        map.insert("span_lint", "utils::span_lint");
-        map.insert("struct_span_lint", "utils::span_lint");
-        map.insert("lint", "utils::span_lint");
-        map.insert("span_lint_note", "utils::span_lint_and_note");
-        map.insert("span_lint_help", "utils::span_lint_and_help");
-        Self { map }
-    }
-}
-
-impl_lint_pass!(CompilerLintFunctions => [COMPILER_LINT_FUNCTIONS]);
-
-impl<'tcx> LateLintPass<'tcx> for CompilerLintFunctions {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if !run_lints(cx, &[COMPILER_LINT_FUNCTIONS], expr.hir_id) {
-            return;
-        }
-
-        if_chain! {
-            if let ExprKind::MethodCall(ref path, _, ref args, _) = expr.kind;
-            let fn_name = path.ident;
-            if let Some(sugg) = self.map.get(&*fn_name.as_str());
-            let ty = cx.typeck_results().expr_ty(&args[0]).peel_refs();
-            if match_type(cx, ty, &paths::EARLY_CONTEXT)
-                || match_type(cx, ty, &paths::LATE_CONTEXT);
-            then {
-                span_lint_and_help(
-                    cx,
-                    COMPILER_LINT_FUNCTIONS,
-                    path.ident.span,
-                    "usage of a compiler lint function",
-                    None,
-                    &format!("please use the Clippy variant of this function: `{}`", sugg),
-                );
-            }
-        }
-    }
-}
-
-declare_lint_pass!(OuterExpnDataPass => [OUTER_EXPN_EXPN_DATA]);
-
-impl<'tcx> LateLintPass<'tcx> for OuterExpnDataPass {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
-        if !run_lints(cx, &[OUTER_EXPN_EXPN_DATA], expr.hir_id) {
-            return;
-        }
-
-        let (method_names, arg_lists, spans) = method_calls(expr, 2);
-        let method_names: Vec<SymbolStr> = method_names.iter().map(|s| s.as_str()).collect();
-        let method_names: Vec<&str> = method_names.iter().map(|s| &**s).collect();
-        if_chain! {
-            if let ["expn_data", "outer_expn"] = method_names.as_slice();
-            let args = arg_lists[1];
-            if args.len() == 1;
-            let self_arg = &args[0];
-            let self_ty = cx.typeck_results().expr_ty(self_arg).peel_refs();
-            if match_type(cx, self_ty, &paths::SYNTAX_CONTEXT);
-            then {
-                span_lint_and_sugg(
-                    cx,
-                    OUTER_EXPN_EXPN_DATA,
-                    spans[1].with_hi(expr.span.hi()),
-                    "usage of `outer_expn().expn_data()`",
-                    "try",
-                    "outer_expn_data()".to_string(),
-                    Applicability::MachineApplicable,
-                );
-            }
-        }
-    }
-}
-
-declare_lint_pass!(ProduceIce => [PRODUCE_ICE]);
-
-impl EarlyLintPass for ProduceIce {
-    fn check_fn(&mut self, _: &EarlyContext<'_>, fn_kind: FnKind<'_>, _: Span, _: NodeId) {
-        if is_trigger_fn(fn_kind) {
-            panic!("Would you like some help with that?");
-        }
-    }
-}
-
-fn is_trigger_fn(fn_kind: FnKind<'_>) -> bool {
-    match fn_kind {
-        FnKind::Fn(_, ident, ..) => ident.name.as_str() == "it_looks_like_you_are_trying_to_kill_clippy",
-        FnKind::Closure(..) => false,
-    }
-}
-
-declare_lint_pass!(CollapsibleCalls => [COLLAPSIBLE_SPAN_LINT_CALLS]);
-
-impl<'tcx> LateLintPass<'tcx> for CollapsibleCalls {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
-        if !run_lints(cx, &[COLLAPSIBLE_SPAN_LINT_CALLS], expr.hir_id) {
-            return;
-        }
-
-        if_chain! {
-            if let ExprKind::Call(ref func, ref and_then_args) = expr.kind;
-            if let ExprKind::Path(ref path) = func.kind;
-            if match_qpath(path, &["span_lint_and_then"]);
-            if and_then_args.len() == 5;
-            if let ExprKind::Closure(_, _, body_id, _, _) = &and_then_args[4].kind;
-            let body = cx.tcx.hir().body(*body_id);
-            if let ExprKind::Block(block, _) = &body.value.kind;
-            let stmts = &block.stmts;
-            if stmts.len() == 1 && block.expr.is_none();
-            if let StmtKind::Semi(only_expr) = &stmts[0].kind;
-            if let ExprKind::MethodCall(ref ps, _, ref span_call_args, _) = &only_expr.kind;
-            let and_then_snippets = get_and_then_snippets(cx, and_then_args);
-            let mut sle = SpanlessEq::new(cx).deny_side_effects();
-            then {
-                match &*ps.ident.as_str() {
-                    "span_suggestion" if sle.eq_expr(&and_then_args[2], &span_call_args[1]) => {
-                        suggest_suggestion(cx, expr, &and_then_snippets, &span_suggestion_snippets(cx, span_call_args));
-                    },
-                    "span_help" if sle.eq_expr(&and_then_args[2], &span_call_args[1]) => {
-                        let help_snippet = snippet(cx, span_call_args[2].span, r#""...""#);
-                        suggest_help(cx, expr, &and_then_snippets, help_snippet.borrow(), true);
-                    },
-                    "span_note" if sle.eq_expr(&and_then_args[2], &span_call_args[1]) => {
-                        let note_snippet = snippet(cx, span_call_args[2].span, r#""...""#);
-                        suggest_note(cx, expr, &and_then_snippets, note_snippet.borrow(), true);
-                    },
-                    "help" => {
-                        let help_snippet = snippet(cx, span_call_args[1].span, r#""...""#);
-                        suggest_help(cx, expr, &and_then_snippets, help_snippet.borrow(), false);
-                    }
-                    "note" => {
-                        let note_snippet = snippet(cx, span_call_args[1].span, r#""...""#);
-                        suggest_note(cx, expr, &and_then_snippets, note_snippet.borrow(), false);
-                    }
-                    _  => (),
-                }
-            }
-        }
-    }
-}
-
-struct AndThenSnippets<'a> {
-    cx: Cow<'a, str>,
-    lint: Cow<'a, str>,
-    span: Cow<'a, str>,
-    msg: Cow<'a, str>,
-}
-
-fn get_and_then_snippets<'a, 'hir>(cx: &LateContext<'_>, and_then_snippets: &'hir [Expr<'hir>]) -> AndThenSnippets<'a> {
-    let cx_snippet = snippet(cx, and_then_snippets[0].span, "cx");
-    let lint_snippet = snippet(cx, and_then_snippets[1].span, "..");
-    let span_snippet = snippet(cx, and_then_snippets[2].span, "span");
-    let msg_snippet = snippet(cx, and_then_snippets[3].span, r#""...""#);
-
-    AndThenSnippets {
-        cx: cx_snippet,
-        lint: lint_snippet,
-        span: span_snippet,
-        msg: msg_snippet,
-    }
-}
-
-struct SpanSuggestionSnippets<'a> {
-    help: Cow<'a, str>,
-    sugg: Cow<'a, str>,
-    applicability: Cow<'a, str>,
-}
-
-fn span_suggestion_snippets<'a, 'hir>(
-    cx: &LateContext<'_>,
-    span_call_args: &'hir [Expr<'hir>],
-) -> SpanSuggestionSnippets<'a> {
-    let help_snippet = snippet(cx, span_call_args[2].span, r#""...""#);
-    let sugg_snippet = snippet(cx, span_call_args[3].span, "..");
-    let applicability_snippet = snippet(cx, span_call_args[4].span, "Applicability::MachineApplicable");
-
-    SpanSuggestionSnippets {
-        help: help_snippet,
-        sugg: sugg_snippet,
-        applicability: applicability_snippet,
-    }
-}
-
-fn suggest_suggestion(
-    cx: &LateContext<'_>,
-    expr: &Expr<'_>,
-    and_then_snippets: &AndThenSnippets<'_>,
-    span_suggestion_snippets: &SpanSuggestionSnippets<'_>,
-) {
-    span_lint_and_sugg(
-        cx,
-        COLLAPSIBLE_SPAN_LINT_CALLS,
-        expr.span,
-        "this call is collapsible",
-        "collapse into",
-        format!(
-            "span_lint_and_sugg({}, {}, {}, {}, {}, {}, {})",
-            and_then_snippets.cx,
-            and_then_snippets.lint,
-            and_then_snippets.span,
-            and_then_snippets.msg,
-            span_suggestion_snippets.help,
-            span_suggestion_snippets.sugg,
-            span_suggestion_snippets.applicability
-        ),
-        Applicability::MachineApplicable,
-    );
-}
-
-fn suggest_help(
-    cx: &LateContext<'_>,
-    expr: &Expr<'_>,
-    and_then_snippets: &AndThenSnippets<'_>,
-    help: &str,
-    with_span: bool,
-) {
-    let option_span = if with_span {
-        format!("Some({})", and_then_snippets.span)
-    } else {
-        "None".to_string()
-    };
-
-    span_lint_and_sugg(
-        cx,
-        COLLAPSIBLE_SPAN_LINT_CALLS,
-        expr.span,
-        "this call is collapsible",
-        "collapse into",
-        format!(
-            "span_lint_and_help({}, {}, {}, {}, {}, {})",
-            and_then_snippets.cx,
-            and_then_snippets.lint,
-            and_then_snippets.span,
-            and_then_snippets.msg,
-            &option_span,
-            help
-        ),
-        Applicability::MachineApplicable,
-    );
-}
-
-fn suggest_note(
-    cx: &LateContext<'_>,
-    expr: &Expr<'_>,
-    and_then_snippets: &AndThenSnippets<'_>,
-    note: &str,
-    with_span: bool,
-) {
-    let note_span = if with_span {
-        format!("Some({})", and_then_snippets.span)
-    } else {
-        "None".to_string()
-    };
-
-    span_lint_and_sugg(
-        cx,
-        COLLAPSIBLE_SPAN_LINT_CALLS,
-        expr.span,
-        "this call is collspible",
-        "collapse into",
-        format!(
-            "span_lint_and_note({}, {}, {}, {}, {}, {})",
-            and_then_snippets.cx,
-            and_then_snippets.lint,
-            and_then_snippets.span,
-            and_then_snippets.msg,
-            note_span,
-            note
-        ),
-        Applicability::MachineApplicable,
-    );
-}
-
-declare_lint_pass!(MatchTypeOnDiagItem => [MATCH_TYPE_ON_DIAGNOSTIC_ITEM]);
-
-impl<'tcx> LateLintPass<'tcx> for MatchTypeOnDiagItem {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
-        if !run_lints(cx, &[MATCH_TYPE_ON_DIAGNOSTIC_ITEM], expr.hir_id) {
-            return;
-        }
-
-        if_chain! {
-            // Check if this is a call to utils::match_type()
-            if let ExprKind::Call(fn_path, [context, ty, ty_path]) = expr.kind;
-            if let ExprKind::Path(fn_qpath) = &fn_path.kind;
-            if match_qpath(&fn_qpath, &["utils", "match_type"]);
-            // Extract the path to the matched type
-            if let Some(segments) = path_to_matched_type(cx, ty_path);
-            let segments: Vec<&str> = segments.iter().map(|sym| &**sym).collect();
-            if let Some(ty_did) = path_to_res(cx, &segments[..]).opt_def_id();
-            // Check if the matched type is a diagnostic item
-            let diag_items = cx.tcx.diagnostic_items(ty_did.krate);
-            if let Some(item_name) = diag_items.iter().find_map(|(k, v)| if *v == ty_did { Some(k) } else { None });
-            then {
-                let cx_snippet = snippet(cx, context.span, "_");
-                let ty_snippet = snippet(cx, ty.span, "_");
-
-                span_lint_and_sugg(
-                    cx,
-                    MATCH_TYPE_ON_DIAGNOSTIC_ITEM,
-                    expr.span,
-                    "usage of `utils::match_type()` on a type diagnostic item",
-                    "try",
-                    format!("utils::is_type_diagnostic_item({}, {}, sym::{})", cx_snippet, ty_snippet, item_name),
-                    Applicability::MaybeIncorrect,
-                );
-            }
-        }
-    }
-}
-
-fn path_to_matched_type(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> Option<Vec<SymbolStr>> {
-    use rustc_hir::ItemKind;
-
-    match &expr.kind {
-        ExprKind::AddrOf(.., expr) => return path_to_matched_type(cx, expr),
-        ExprKind::Path(qpath) => match cx.qpath_res(qpath, expr.hir_id) {
-            Res::Local(hir_id) => {
-                let parent_id = cx.tcx.hir().get_parent_node(hir_id);
-                if let Some(Node::Local(local)) = cx.tcx.hir().find(parent_id) {
-                    if let Some(init) = local.init {
-                        return path_to_matched_type(cx, init);
-                    }
-                }
-            },
-            Res::Def(DefKind::Const | DefKind::Static, def_id) => {
-                if let Some(Node::Item(item)) = cx.tcx.hir().get_if_local(def_id) {
-                    if let ItemKind::Const(.., body_id) | ItemKind::Static(.., body_id) = item.kind {
-                        let body = cx.tcx.hir().body(body_id);
-                        return path_to_matched_type(cx, &body.value);
-                    }
-                }
-            },
-            _ => {},
-        },
-        ExprKind::Array(exprs) => {
-            let segments: Vec<SymbolStr> = exprs
-                .iter()
-                .filter_map(|expr| {
-                    if let ExprKind::Lit(lit) = &expr.kind {
-                        if let LitKind::Str(sym, _) = lit.node {
-                            return Some(sym.as_str());
-                        }
-                    }
-
-                    None
-                })
-                .collect();
-
-            if segments.len() == exprs.len() {
-                return Some(segments);
-            }
-        },
-        _ => {},
-    }
-
-    None
-}
-
-// This is not a complete resolver for paths. It works on all the paths currently used in the paths
-// module.  That's all it does and all it needs to do.
-pub fn check_path(cx: &LateContext<'_>, path: &[&str]) -> bool {
-    if path_to_res(cx, path) != Res::Err {
-        return true;
-    }
-
-    // Some implementations can't be found by `path_to_res`, particularly inherent
-    // implementations of native types. Check lang items.
-    let path_syms: Vec<_> = path.iter().map(|p| Symbol::intern(p)).collect();
-    let lang_items = cx.tcx.lang_items();
-    for item_def_id in lang_items.items().iter().flatten() {
-        let lang_item_path = cx.get_def_path(*item_def_id);
-        if path_syms.starts_with(&lang_item_path) {
-            if let [item] = &path_syms[lang_item_path.len()..] {
-                for child in cx.tcx.item_children(*item_def_id) {
-                    if child.ident.name == *item {
-                        return true;
-                    }
-                }
-            }
-        }
-    }
-
-    false
-}
-
-declare_lint_pass!(InvalidPaths => [INVALID_PATHS]);
-
-impl<'tcx> LateLintPass<'tcx> for InvalidPaths {
-    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
-        let local_def_id = &cx.tcx.parent_module(item.hir_id);
-        let mod_name = &cx.tcx.item_name(local_def_id.to_def_id());
-        if_chain! {
-            if mod_name.as_str() == "paths";
-            if let hir::ItemKind::Const(ty, body_id) = item.kind;
-            let ty = hir_ty_to_ty(cx.tcx, ty);
-            if let ty::Array(el_ty, _) = &ty.kind();
-            if let ty::Ref(_, el_ty, _) = &el_ty.kind();
-            if el_ty.is_str();
-            let body = cx.tcx.hir().body(body_id);
-            let typeck_results = cx.tcx.typeck_body(body_id);
-            if let Some(Constant::Vec(path)) = constant_simple(cx, typeck_results, &body.value);
-            let path: Vec<&str> = path.iter().map(|x| {
-                    if let Constant::Str(s) = x {
-                        s.as_str()
-                    } else {
-                        // We checked the type of the constant above
-                        unreachable!()
-                    }
-                }).collect();
-            if !check_path(cx, &path[..]);
-            then {
-                span_lint(cx, CLIPPY_LINTS_INTERNAL, item.span, "invalid path");
-            }
-        }
-    }
-}
-
-#[derive(Default)]
-pub struct InterningDefinedSymbol {
-    // Maps the symbol value to the constant DefId.
-    symbol_map: FxHashMap<u32, DefId>,
-}
-
-impl_lint_pass!(InterningDefinedSymbol => [INTERNING_DEFINED_SYMBOL, UNNECESSARY_SYMBOL_STR]);
-
-impl<'tcx> LateLintPass<'tcx> for InterningDefinedSymbol {
-    fn check_crate(&mut self, cx: &LateContext<'_>, _: &Crate<'_>) {
-        if !self.symbol_map.is_empty() {
-            return;
-        }
-
-        for &module in &[&paths::KW_MODULE, &paths::SYM_MODULE] {
-            if let Some(def_id) = path_to_res(cx, module).opt_def_id() {
-                for item in cx.tcx.item_children(def_id).iter() {
-                    if_chain! {
-                        if let Res::Def(DefKind::Const, item_def_id) = item.res;
-                        let ty = cx.tcx.type_of(item_def_id);
-                        if match_type(cx, ty, &paths::SYMBOL);
-                        if let Ok(ConstValue::Scalar(value)) = cx.tcx.const_eval_poly(item_def_id);
-                        if let Ok(value) = value.to_u32();
-                        then {
-                            self.symbol_map.insert(value, item_def_id);
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if_chain! {
-            if let ExprKind::Call(func, [arg]) = &expr.kind;
-            if let ty::FnDef(def_id, _) = cx.typeck_results().expr_ty(func).kind();
-            if match_def_path(cx, *def_id, &paths::SYMBOL_INTERN);
-            if let Some(Constant::Str(arg)) = constant_simple(cx, cx.typeck_results(), arg);
-            let value = Symbol::intern(&arg).as_u32();
-            if let Some(&def_id) = self.symbol_map.get(&value);
-            then {
-                span_lint_and_sugg(
-                    cx,
-                    INTERNING_DEFINED_SYMBOL,
-                    is_expn_of(expr.span, "sym").unwrap_or(expr.span),
-                    "interning a defined symbol",
-                    "try",
-                    cx.tcx.def_path_str(def_id),
-                    Applicability::MachineApplicable,
-                );
-            }
-        }
-        if let ExprKind::Binary(op, left, right) = expr.kind {
-            if matches!(op.node, BinOpKind::Eq | BinOpKind::Ne) {
-                let data = [
-                    (left, self.symbol_str_expr(left, cx)),
-                    (right, self.symbol_str_expr(right, cx)),
-                ];
-                match data {
-                    // both operands are a symbol string
-                    [(_, Some(left)), (_, Some(right))] => {
-                        span_lint_and_sugg(
-                            cx,
-                            UNNECESSARY_SYMBOL_STR,
-                            expr.span,
-                            "unnecessary `Symbol` to string conversion",
-                            "try",
-                            format!(
-                                "{} {} {}",
-                                left.as_symbol_snippet(cx),
-                                op.node.as_str(),
-                                right.as_symbol_snippet(cx),
-                            ),
-                            Applicability::MachineApplicable,
-                        );
-                    },
-                    // one of the operands is a symbol string
-                    [(expr, Some(symbol)), _] | [_, (expr, Some(symbol))] => {
-                        // creating an owned string for comparison
-                        if matches!(symbol, SymbolStrExpr::Expr { is_to_owned: true, .. }) {
-                            span_lint_and_sugg(
-                                cx,
-                                UNNECESSARY_SYMBOL_STR,
-                                expr.span,
-                                "unnecessary string allocation",
-                                "try",
-                                format!("{}.as_str()", symbol.as_symbol_snippet(cx)),
-                                Applicability::MachineApplicable,
-                            );
-                        }
-                    },
-                    // nothing found
-                    [(_, None), (_, None)] => {},
-                }
-            }
-        }
-    }
-}
-
-impl InterningDefinedSymbol {
-    fn symbol_str_expr<'tcx>(&self, expr: &'tcx Expr<'tcx>, cx: &LateContext<'tcx>) -> Option<SymbolStrExpr<'tcx>> {
-        static IDENT_STR_PATHS: &[&[&str]] = &[&paths::IDENT_AS_STR, &paths::TO_STRING_METHOD];
-        static SYMBOL_STR_PATHS: &[&[&str]] = &[
-            &paths::SYMBOL_AS_STR,
-            &paths::SYMBOL_TO_IDENT_STRING,
-            &paths::TO_STRING_METHOD,
-        ];
-        // SymbolStr might be de-referenced: `&*symbol.as_str()`
-        let call = if_chain! {
-            if let ExprKind::AddrOf(_, _, e) = expr.kind;
-            if let ExprKind::Unary(UnOp::Deref, e) = e.kind;
-            then { e } else { expr }
-        };
-        if_chain! {
-            // is a method call
-            if let ExprKind::MethodCall(_, _, [item], _) = call.kind;
-            if let Some(did) = cx.typeck_results().type_dependent_def_id(call.hir_id);
-            let ty = cx.typeck_results().expr_ty(item);
-            // ...on either an Ident or a Symbol
-            if let Some(is_ident) = if match_type(cx, ty, &paths::SYMBOL) {
-                Some(false)
-            } else if match_type(cx, ty, &paths::IDENT) {
-                Some(true)
-            } else {
-                None
-            };
-            // ...which converts it to a string
-            let paths = if is_ident { IDENT_STR_PATHS } else { SYMBOL_STR_PATHS };
-            if let Some(path) = paths.iter().find(|path| match_def_path(cx, did, path));
-            then {
-                let is_to_owned = path.last().unwrap().ends_with("string");
-                return Some(SymbolStrExpr::Expr {
-                    item,
-                    is_ident,
-                    is_to_owned,
-                });
-            }
-        }
-        // is a string constant
-        if let Some(Constant::Str(s)) = constant_simple(cx, cx.typeck_results(), expr) {
-            let value = Symbol::intern(&s).as_u32();
-            // ...which matches a symbol constant
-            if let Some(&def_id) = self.symbol_map.get(&value) {
-                return Some(SymbolStrExpr::Const(def_id));
-            }
-        }
-        None
-    }
-}
-
-enum SymbolStrExpr<'tcx> {
-    /// a string constant with a corresponding symbol constant
-    Const(DefId),
-    /// a "symbol to string" expression like `symbol.as_str()`
-    Expr {
-        /// part that evaluates to `Symbol` or `Ident`
-        item: &'tcx Expr<'tcx>,
-        is_ident: bool,
-        /// whether an owned `String` is created like `to_ident_string()`
-        is_to_owned: bool,
-    },
-}
-
-impl<'tcx> SymbolStrExpr<'tcx> {
-    /// Returns a snippet that evaluates to a `Symbol` and is const if possible
-    fn as_symbol_snippet(&self, cx: &LateContext<'_>) -> Cow<'tcx, str> {
-        match *self {
-            Self::Const(def_id) => cx.tcx.def_path_str(def_id).into(),
-            Self::Expr { item, is_ident, .. } => {
-                let mut snip = snippet(cx, item.span.source_callsite(), "..");
-                if is_ident {
-                    // get `Ident.name`
-                    snip.to_mut().push_str(".name");
-                }
-                snip
-            },
-        }
-    }
-}
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
deleted file mode 100644
index 40771449264..00000000000
--- a/clippy_lints/src/utils/mod.rs
+++ /dev/null
@@ -1,1862 +0,0 @@
-#[macro_use]
-pub mod sym_helper;
-
-#[allow(clippy::module_name_repetitions)]
-pub mod ast_utils;
-pub mod attrs;
-pub mod author;
-pub mod camel_case;
-pub mod comparisons;
-pub mod conf;
-mod diagnostics;
-pub mod eager_or_lazy;
-pub mod higher;
-mod hir_utils;
-pub mod inspector;
-#[cfg(feature = "internal-lints")]
-pub mod internal_lints;
-pub mod numeric_literal;
-pub mod paths;
-pub mod ptr;
-pub mod qualify_min_const_fn;
-pub mod sugg;
-pub mod usage;
-pub mod visitors;
-
-pub use self::attrs::*;
-pub use self::diagnostics::*;
-pub use self::hir_utils::{both, eq_expr_value, over, SpanlessEq, SpanlessHash};
-
-use std::borrow::Cow;
-use std::collections::hash_map::Entry;
-use std::hash::BuildHasherDefault;
-
-use if_chain::if_chain;
-use rustc_ast::ast::{self, Attribute, BorrowKind, LitKind, Mutability};
-use rustc_data_structures::fx::FxHashMap;
-use rustc_errors::Applicability;
-use rustc_hir as hir;
-use rustc_hir::def::{CtorKind, CtorOf, DefKind, Res};
-use rustc_hir::def_id::{DefId, LOCAL_CRATE};
-use rustc_hir::intravisit::{self, NestedVisitorMap, Visitor};
-use rustc_hir::Node;
-use rustc_hir::{
-    def, Arm, Block, Body, Constness, Crate, Expr, ExprKind, FnDecl, HirId, ImplItem, ImplItemKind, Item, ItemKind,
-    MatchSource, Param, Pat, PatKind, Path, PathSegment, QPath, TraitItem, TraitItemKind, TraitRef, TyKind, Unsafety,
-};
-use rustc_infer::infer::TyCtxtInferExt;
-use rustc_lint::{LateContext, Level, Lint, LintContext};
-use rustc_middle::hir::exports::Export;
-use rustc_middle::hir::map::Map;
-use rustc_middle::ty::subst::{GenericArg, GenericArgKind};
-use rustc_middle::ty::{self, layout::IntegerExt, DefIdTree, Ty, TyCtxt, TypeFoldable};
-use rustc_semver::RustcVersion;
-use rustc_session::Session;
-use rustc_span::hygiene::{ExpnKind, MacroKind};
-use rustc_span::source_map::original_sp;
-use rustc_span::sym;
-use rustc_span::symbol::{kw, Symbol};
-use rustc_span::{BytePos, Pos, Span, DUMMY_SP};
-use rustc_target::abi::Integer;
-use rustc_trait_selection::traits::query::normalize::AtExt;
-use smallvec::SmallVec;
-
-use crate::consts::{constant, Constant};
-
-pub fn parse_msrv(msrv: &str, sess: Option<&Session>, span: Option<Span>) -> Option<RustcVersion> {
-    if let Ok(version) = RustcVersion::parse(msrv) {
-        return Some(version);
-    } else if let Some(sess) = sess {
-        if let Some(span) = span {
-            sess.span_err(span, &format!("`{}` is not a valid Rust version", msrv));
-        }
-    }
-    None
-}
-
-pub fn meets_msrv(msrv: Option<&RustcVersion>, lint_msrv: &RustcVersion) -> bool {
-    msrv.map_or(true, |msrv| msrv.meets(*lint_msrv))
-}
-
-macro_rules! extract_msrv_attr {
-    (LateContext) => {
-        extract_msrv_attr!(@LateContext, ());
-    };
-    (EarlyContext) => {
-        extract_msrv_attr!(@EarlyContext);
-    };
-    (@$context:ident$(, $call:tt)?) => {
-        fn enter_lint_attrs(&mut self, cx: &rustc_lint::$context<'tcx>, attrs: &'tcx [rustc_ast::ast::Attribute]) {
-            use $crate::utils::get_unique_inner_attr;
-            match get_unique_inner_attr(cx.sess$($call)?, attrs, "msrv") {
-                Some(msrv_attr) => {
-                    if let Some(msrv) = msrv_attr.value_str() {
-                        self.msrv = $crate::utils::parse_msrv(
-                            &msrv.to_string(),
-                            Some(cx.sess$($call)?),
-                            Some(msrv_attr.span),
-                        );
-                    } else {
-                        cx.sess$($call)?.span_err(msrv_attr.span, "bad clippy attribute");
-                    }
-                },
-                _ => (),
-            }
-        }
-    };
-}
-
-/// Returns `true` if the two spans come from differing expansions (i.e., one is
-/// from a macro and one isn't).
-#[must_use]
-pub fn differing_macro_contexts(lhs: Span, rhs: Span) -> bool {
-    rhs.ctxt() != lhs.ctxt()
-}
-
-/// Returns `true` if the given `NodeId` is inside a constant context
-///
-/// # Example
-///
-/// ```rust,ignore
-/// if in_constant(cx, expr.hir_id) {
-///     // Do something
-/// }
-/// ```
-pub fn in_constant(cx: &LateContext<'_>, id: HirId) -> bool {
-    let parent_id = cx.tcx.hir().get_parent_item(id);
-    match cx.tcx.hir().get(parent_id) {
-        Node::Item(&Item {
-            kind: ItemKind::Const(..) | ItemKind::Static(..),
-            ..
-        })
-        | Node::TraitItem(&TraitItem {
-            kind: TraitItemKind::Const(..),
-            ..
-        })
-        | Node::ImplItem(&ImplItem {
-            kind: ImplItemKind::Const(..),
-            ..
-        })
-        | Node::AnonConst(_) => true,
-        Node::Item(&Item {
-            kind: ItemKind::Fn(ref sig, ..),
-            ..
-        })
-        | Node::ImplItem(&ImplItem {
-            kind: ImplItemKind::Fn(ref sig, _),
-            ..
-        }) => sig.header.constness == Constness::Const,
-        _ => false,
-    }
-}
-
-/// Returns `true` if this `span` was expanded by any macro.
-#[must_use]
-pub fn in_macro(span: Span) -> bool {
-    if span.from_expansion() {
-        !matches!(span.ctxt().outer_expn_data().kind, ExpnKind::Desugaring(..))
-    } else {
-        false
-    }
-}
-
-// If the snippet is empty, it's an attribute that was inserted during macro
-// expansion and we want to ignore those, because they could come from external
-// sources that the user has no control over.
-// For some reason these attributes don't have any expansion info on them, so
-// we have to check it this way until there is a better way.
-pub fn is_present_in_source<T: LintContext>(cx: &T, span: Span) -> bool {
-    if let Some(snippet) = snippet_opt(cx, span) {
-        if snippet.is_empty() {
-            return false;
-        }
-    }
-    true
-}
-
-/// Checks if given pattern is a wildcard (`_`)
-pub fn is_wild<'tcx>(pat: &impl std::ops::Deref<Target = Pat<'tcx>>) -> bool {
-    matches!(pat.kind, PatKind::Wild)
-}
-
-/// Checks if type is struct, enum or union type with the given def path.
-///
-/// If the type is a diagnostic item, use `is_type_diagnostic_item` instead.
-/// If you change the signature, remember to update the internal lint `MatchTypeOnDiagItem`
-pub fn match_type(cx: &LateContext<'_>, ty: Ty<'_>, path: &[&str]) -> bool {
-    match ty.kind() {
-        ty::Adt(adt, _) => match_def_path(cx, adt.did, path),
-        _ => false,
-    }
-}
-
-/// Checks if the type is equal to a diagnostic item
-///
-/// If you change the signature, remember to update the internal lint `MatchTypeOnDiagItem`
-pub fn is_type_diagnostic_item(cx: &LateContext<'_>, ty: Ty<'_>, diag_item: Symbol) -> bool {
-    match ty.kind() {
-        ty::Adt(adt, _) => cx.tcx.is_diagnostic_item(diag_item, adt.did),
-        _ => false,
-    }
-}
-
-/// Checks if the type is equal to a lang item
-pub fn is_type_lang_item(cx: &LateContext<'_>, ty: Ty<'_>, lang_item: hir::LangItem) -> bool {
-    match ty.kind() {
-        ty::Adt(adt, _) => cx.tcx.lang_items().require(lang_item).unwrap() == adt.did,
-        _ => false,
-    }
-}
-
-/// Checks if the method call given in `expr` belongs to the given trait.
-pub fn match_trait_method(cx: &LateContext<'_>, expr: &Expr<'_>, path: &[&str]) -> bool {
-    let def_id = cx.typeck_results().type_dependent_def_id(expr.hir_id).unwrap();
-    let trt_id = cx.tcx.trait_of_item(def_id);
-    trt_id.map_or(false, |trt_id| match_def_path(cx, trt_id, path))
-}
-
-/// Checks if an expression references a variable of the given name.
-pub fn match_var(expr: &Expr<'_>, var: Symbol) -> bool {
-    if let ExprKind::Path(QPath::Resolved(None, ref path)) = expr.kind {
-        if let [p] = path.segments {
-            return p.ident.name == var;
-        }
-    }
-    false
-}
-
-pub fn last_path_segment<'tcx>(path: &QPath<'tcx>) -> &'tcx PathSegment<'tcx> {
-    match *path {
-        QPath::Resolved(_, ref path) => path.segments.last().expect("A path must have at least one segment"),
-        QPath::TypeRelative(_, ref seg) => seg,
-        QPath::LangItem(..) => panic!("last_path_segment: lang item has no path segments"),
-    }
-}
-
-pub fn single_segment_path<'tcx>(path: &QPath<'tcx>) -> Option<&'tcx PathSegment<'tcx>> {
-    match *path {
-        QPath::Resolved(_, ref path) => path.segments.get(0),
-        QPath::TypeRelative(_, ref seg) => Some(seg),
-        QPath::LangItem(..) => None,
-    }
-}
-
-/// Matches a `QPath` against a slice of segment string literals.
-///
-/// There is also `match_path` if you are dealing with a `rustc_hir::Path` instead of a
-/// `rustc_hir::QPath`.
-///
-/// # Examples
-/// ```rust,ignore
-/// match_qpath(path, &["std", "rt", "begin_unwind"])
-/// ```
-pub fn match_qpath(path: &QPath<'_>, segments: &[&str]) -> bool {
-    match *path {
-        QPath::Resolved(_, ref path) => match_path(path, segments),
-        QPath::TypeRelative(ref ty, ref segment) => match ty.kind {
-            TyKind::Path(ref inner_path) => {
-                if let [prefix @ .., end] = segments {
-                    if match_qpath(inner_path, prefix) {
-                        return segment.ident.name.as_str() == *end;
-                    }
-                }
-                false
-            },
-            _ => false,
-        },
-        QPath::LangItem(..) => false,
-    }
-}
-
-/// Matches a `Path` against a slice of segment string literals.
-///
-/// There is also `match_qpath` if you are dealing with a `rustc_hir::QPath` instead of a
-/// `rustc_hir::Path`.
-///
-/// # Examples
-///
-/// ```rust,ignore
-/// if match_path(&trait_ref.path, &paths::HASH) {
-///     // This is the `std::hash::Hash` trait.
-/// }
-///
-/// if match_path(ty_path, &["rustc", "lint", "Lint"]) {
-///     // This is a `rustc_middle::lint::Lint`.
-/// }
-/// ```
-pub fn match_path(path: &Path<'_>, segments: &[&str]) -> bool {
-    path.segments
-        .iter()
-        .rev()
-        .zip(segments.iter().rev())
-        .all(|(a, b)| a.ident.name.as_str() == *b)
-}
-
-/// Matches a `Path` against a slice of segment string literals, e.g.
-///
-/// # Examples
-/// ```rust,ignore
-/// match_path_ast(path, &["std", "rt", "begin_unwind"])
-/// ```
-pub fn match_path_ast(path: &ast::Path, segments: &[&str]) -> bool {
-    path.segments
-        .iter()
-        .rev()
-        .zip(segments.iter().rev())
-        .all(|(a, b)| a.ident.name.as_str() == *b)
-}
-
-/// If the expression is a path to a local, returns the canonical `HirId` of the local.
-pub fn path_to_local(expr: &Expr<'_>) -> Option<HirId> {
-    if let ExprKind::Path(QPath::Resolved(None, ref path)) = expr.kind {
-        if let Res::Local(id) = path.res {
-            return Some(id);
-        }
-    }
-    None
-}
-
-/// Returns true if the expression is a path to a local with the specified `HirId`.
-/// Use this function to see if an expression matches a function argument or a match binding.
-pub fn path_to_local_id(expr: &Expr<'_>, id: HirId) -> bool {
-    path_to_local(expr) == Some(id)
-}
-
-/// Gets the definition associated to a path.
-#[allow(clippy::shadow_unrelated)] // false positive #6563
-pub fn path_to_res(cx: &LateContext<'_>, path: &[&str]) -> Res {
-    macro_rules! try_res {
-        ($e:expr) => {
-            match $e {
-                Some(e) => e,
-                None => return Res::Err,
-            }
-        };
-    }
-    fn item_child_by_name<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId, name: &str) -> Option<&'tcx Export<HirId>> {
-        tcx.item_children(def_id)
-            .iter()
-            .find(|item| item.ident.name.as_str() == name)
-    }
-
-    let (krate, first, path) = match *path {
-        [krate, first, ref path @ ..] => (krate, first, path),
-        _ => return Res::Err,
-    };
-    let tcx = cx.tcx;
-    let crates = tcx.crates();
-    let krate = try_res!(crates.iter().find(|&&num| tcx.crate_name(num).as_str() == krate));
-    let first = try_res!(item_child_by_name(tcx, krate.as_def_id(), first));
-    let last = path
-        .iter()
-        .copied()
-        // `get_def_path` seems to generate these empty segments for extern blocks.
-        // We can just ignore them.
-        .filter(|segment| !segment.is_empty())
-        // for each segment, find the child item
-        .try_fold(first, |item, segment| {
-            let def_id = item.res.def_id();
-            if let Some(item) = item_child_by_name(tcx, def_id, segment) {
-                Some(item)
-            } else if matches!(item.res, Res::Def(DefKind::Enum | DefKind::Struct, _)) {
-                // it is not a child item so check inherent impl items
-                tcx.inherent_impls(def_id)
-                    .iter()
-                    .find_map(|&impl_def_id| item_child_by_name(tcx, impl_def_id, segment))
-            } else {
-                None
-            }
-        });
-    try_res!(last).res
-}
-
-/// Convenience function to get the `DefId` of a trait by path.
-/// It could be a trait or trait alias.
-pub fn get_trait_def_id(cx: &LateContext<'_>, path: &[&str]) -> Option<DefId> {
-    match path_to_res(cx, path) {
-        Res::Def(DefKind::Trait | DefKind::TraitAlias, trait_id) => Some(trait_id),
-        _ => None,
-    }
-}
-
-/// Checks whether a type implements a trait.
-/// See also `get_trait_def_id`.
-pub fn implements_trait<'tcx>(
-    cx: &LateContext<'tcx>,
-    ty: Ty<'tcx>,
-    trait_id: DefId,
-    ty_params: &[GenericArg<'tcx>],
-) -> bool {
-    // Do not check on infer_types to avoid panic in evaluate_obligation.
-    if ty.has_infer_types() {
-        return false;
-    }
-    let ty = cx.tcx.erase_regions(ty);
-    if ty.has_escaping_bound_vars() {
-        return false;
-    }
-    let ty_params = cx.tcx.mk_substs(ty_params.iter());
-    cx.tcx.type_implements_trait((trait_id, ty, ty_params, cx.param_env))
-}
-
-/// Gets the `hir::TraitRef` of the trait the given method is implemented for.
-///
-/// Use this if you want to find the `TraitRef` of the `Add` trait in this example:
-///
-/// ```rust
-/// struct Point(isize, isize);
-///
-/// impl std::ops::Add for Point {
-///     type Output = Self;
-///
-///     fn add(self, other: Self) -> Self {
-///         Point(0, 0)
-///     }
-/// }
-/// ```
-pub fn trait_ref_of_method<'tcx>(cx: &LateContext<'tcx>, hir_id: HirId) -> Option<&'tcx TraitRef<'tcx>> {
-    // Get the implemented trait for the current function
-    let parent_impl = cx.tcx.hir().get_parent_item(hir_id);
-    if_chain! {
-        if parent_impl != hir::CRATE_HIR_ID;
-        if let hir::Node::Item(item) = cx.tcx.hir().get(parent_impl);
-        if let hir::ItemKind::Impl(impl_) = &item.kind;
-        then { return impl_.of_trait.as_ref(); }
-    }
-    None
-}
-
-/// Checks whether this type implements `Drop`.
-pub fn has_drop<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
-    match ty.ty_adt_def() {
-        Some(def) => def.has_dtor(cx.tcx),
-        None => false,
-    }
-}
-
-/// Returns the method names and argument list of nested method call expressions that make up
-/// `expr`. method/span lists are sorted with the most recent call first.
-pub fn method_calls<'tcx>(
-    expr: &'tcx Expr<'tcx>,
-    max_depth: usize,
-) -> (Vec<Symbol>, Vec<&'tcx [Expr<'tcx>]>, Vec<Span>) {
-    let mut method_names = Vec::with_capacity(max_depth);
-    let mut arg_lists = Vec::with_capacity(max_depth);
-    let mut spans = Vec::with_capacity(max_depth);
-
-    let mut current = expr;
-    for _ in 0..max_depth {
-        if let ExprKind::MethodCall(path, span, args, _) = &current.kind {
-            if args.iter().any(|e| e.span.from_expansion()) {
-                break;
-            }
-            method_names.push(path.ident.name);
-            arg_lists.push(&**args);
-            spans.push(*span);
-            current = &args[0];
-        } else {
-            break;
-        }
-    }
-
-    (method_names, arg_lists, spans)
-}
-
-/// Matches an `Expr` against a chain of methods, and return the matched `Expr`s.
-///
-/// For example, if `expr` represents the `.baz()` in `foo.bar().baz()`,
-/// `method_chain_args(expr, &["bar", "baz"])` will return a `Vec`
-/// containing the `Expr`s for
-/// `.bar()` and `.baz()`
-pub fn method_chain_args<'a>(expr: &'a Expr<'_>, methods: &[&str]) -> Option<Vec<&'a [Expr<'a>]>> {
-    let mut current = expr;
-    let mut matched = Vec::with_capacity(methods.len());
-    for method_name in methods.iter().rev() {
-        // method chains are stored last -> first
-        if let ExprKind::MethodCall(ref path, _, ref args, _) = current.kind {
-            if path.ident.name.as_str() == *method_name {
-                if args.iter().any(|e| e.span.from_expansion()) {
-                    return None;
-                }
-                matched.push(&**args); // build up `matched` backwards
-                current = &args[0] // go to parent expression
-            } else {
-                return None;
-            }
-        } else {
-            return None;
-        }
-    }
-    // Reverse `matched` so that it is in the same order as `methods`.
-    matched.reverse();
-    Some(matched)
-}
-
-/// Returns `true` if the provided `def_id` is an entrypoint to a program.
-pub fn is_entrypoint_fn(cx: &LateContext<'_>, def_id: DefId) -> bool {
-    cx.tcx
-        .entry_fn(LOCAL_CRATE)
-        .map_or(false, |(entry_fn_def_id, _)| def_id == entry_fn_def_id.to_def_id())
-}
-
-/// Returns `true` if the expression is in the program's `#[panic_handler]`.
-pub fn is_in_panic_handler(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
-    let parent = cx.tcx.hir().get_parent_item(e.hir_id);
-    let def_id = cx.tcx.hir().local_def_id(parent).to_def_id();
-    Some(def_id) == cx.tcx.lang_items().panic_impl()
-}
-
-/// Gets the name of the item the expression is in, if available.
-pub fn get_item_name(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<Symbol> {
-    let parent_id = cx.tcx.hir().get_parent_item(expr.hir_id);
-    match cx.tcx.hir().find(parent_id) {
-        Some(
-            Node::Item(Item { ident, .. })
-            | Node::TraitItem(TraitItem { ident, .. })
-            | Node::ImplItem(ImplItem { ident, .. }),
-        ) => Some(ident.name),
-        _ => None,
-    }
-}
-
-/// Gets the name of a `Pat`, if any.
-pub fn get_pat_name(pat: &Pat<'_>) -> Option<Symbol> {
-    match pat.kind {
-        PatKind::Binding(.., ref spname, _) => Some(spname.name),
-        PatKind::Path(ref qpath) => single_segment_path(qpath).map(|ps| ps.ident.name),
-        PatKind::Box(ref p) | PatKind::Ref(ref p, _) => get_pat_name(&*p),
-        _ => None,
-    }
-}
-
-struct ContainsName {
-    name: Symbol,
-    result: bool,
-}
-
-impl<'tcx> Visitor<'tcx> for ContainsName {
-    type Map = Map<'tcx>;
-
-    fn visit_name(&mut self, _: Span, name: Symbol) {
-        if self.name == name {
-            self.result = true;
-        }
-    }
-    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-        NestedVisitorMap::None
-    }
-}
-
-/// Checks if an `Expr` contains a certain name.
-pub fn contains_name(name: Symbol, expr: &Expr<'_>) -> bool {
-    let mut cn = ContainsName { name, result: false };
-    cn.visit_expr(expr);
-    cn.result
-}
-
-/// Returns `true` if `expr` contains a return expression
-pub fn contains_return(expr: &hir::Expr<'_>) -> bool {
-    struct RetCallFinder {
-        found: bool,
-    }
-
-    impl<'tcx> hir::intravisit::Visitor<'tcx> for RetCallFinder {
-        type Map = Map<'tcx>;
-
-        fn visit_expr(&mut self, expr: &'tcx hir::Expr<'_>) {
-            if self.found {
-                return;
-            }
-            if let hir::ExprKind::Ret(..) = &expr.kind {
-                self.found = true;
-            } else {
-                hir::intravisit::walk_expr(self, expr);
-            }
-        }
-
-        fn nested_visit_map(&mut self) -> hir::intravisit::NestedVisitorMap<Self::Map> {
-            hir::intravisit::NestedVisitorMap::None
-        }
-    }
-
-    let mut visitor = RetCallFinder { found: false };
-    visitor.visit_expr(expr);
-    visitor.found
-}
-
-struct FindMacroCalls<'a, 'b> {
-    names: &'a [&'b str],
-    result: Vec<Span>,
-}
-
-impl<'a, 'b, 'tcx> Visitor<'tcx> for FindMacroCalls<'a, 'b> {
-    type Map = Map<'tcx>;
-
-    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
-        if self.names.iter().any(|fun| is_expn_of(expr.span, fun).is_some()) {
-            self.result.push(expr.span);
-        }
-        // and check sub-expressions
-        intravisit::walk_expr(self, expr);
-    }
-
-    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-        NestedVisitorMap::None
-    }
-}
-
-/// Finds calls of the specified macros in a function body.
-pub fn find_macro_calls(names: &[&str], body: &Body<'_>) -> Vec<Span> {
-    let mut fmc = FindMacroCalls {
-        names,
-        result: Vec::new(),
-    };
-    fmc.visit_expr(&body.value);
-    fmc.result
-}
-
-/// Converts a span to a code snippet if available, otherwise use default.
-///
-/// This is useful if you want to provide suggestions for your lint or more generally, if you want
-/// to convert a given `Span` to a `str`.
-///
-/// # Example
-/// ```rust,ignore
-/// snippet(cx, expr.span, "..")
-/// ```
-pub fn snippet<'a, T: LintContext>(cx: &T, span: Span, default: &'a str) -> Cow<'a, str> {
-    snippet_opt(cx, span).map_or_else(|| Cow::Borrowed(default), From::from)
-}
-
-/// Same as `snippet`, but it adapts the applicability level by following rules:
-///
-/// - Applicability level `Unspecified` will never be changed.
-/// - If the span is inside a macro, change the applicability level to `MaybeIncorrect`.
-/// - If the default value is used and the applicability level is `MachineApplicable`, change it to
-/// `HasPlaceholders`
-pub fn snippet_with_applicability<'a, T: LintContext>(
-    cx: &T,
-    span: Span,
-    default: &'a str,
-    applicability: &mut Applicability,
-) -> Cow<'a, str> {
-    if *applicability != Applicability::Unspecified && span.from_expansion() {
-        *applicability = Applicability::MaybeIncorrect;
-    }
-    snippet_opt(cx, span).map_or_else(
-        || {
-            if *applicability == Applicability::MachineApplicable {
-                *applicability = Applicability::HasPlaceholders;
-            }
-            Cow::Borrowed(default)
-        },
-        From::from,
-    )
-}
-
-/// Same as `snippet`, but should only be used when it's clear that the input span is
-/// not a macro argument.
-pub fn snippet_with_macro_callsite<'a, T: LintContext>(cx: &T, span: Span, default: &'a str) -> Cow<'a, str> {
-    snippet(cx, span.source_callsite(), default)
-}
-
-/// Converts a span to a code snippet. Returns `None` if not available.
-pub fn snippet_opt<T: LintContext>(cx: &T, span: Span) -> Option<String> {
-    cx.sess().source_map().span_to_snippet(span).ok()
-}
-
-/// Converts a span (from a block) to a code snippet if available, otherwise use default.
-///
-/// This trims the code of indentation, except for the first line. Use it for blocks or block-like
-/// things which need to be printed as such.
-///
-/// The `indent_relative_to` arg can be used, to provide a span, where the indentation of the
-/// resulting snippet of the given span.
-///
-/// # Example
-///
-/// ```rust,ignore
-/// snippet_block(cx, block.span, "..", None)
-/// // where, `block` is the block of the if expr
-///     if x {
-///         y;
-///     }
-/// // will return the snippet
-/// {
-///     y;
-/// }
-/// ```
-///
-/// ```rust,ignore
-/// snippet_block(cx, block.span, "..", Some(if_expr.span))
-/// // where, `block` is the block of the if expr
-///     if x {
-///         y;
-///     }
-/// // will return the snippet
-/// {
-///         y;
-///     } // aligned with `if`
-/// ```
-/// Note that the first line of the snippet always has 0 indentation.
-pub fn snippet_block<'a, T: LintContext>(
-    cx: &T,
-    span: Span,
-    default: &'a str,
-    indent_relative_to: Option<Span>,
-) -> Cow<'a, str> {
-    let snip = snippet(cx, span, default);
-    let indent = indent_relative_to.and_then(|s| indent_of(cx, s));
-    reindent_multiline(snip, true, indent)
-}
-
-/// Same as `snippet_block`, but adapts the applicability level by the rules of
-/// `snippet_with_applicability`.
-pub fn snippet_block_with_applicability<'a, T: LintContext>(
-    cx: &T,
-    span: Span,
-    default: &'a str,
-    indent_relative_to: Option<Span>,
-    applicability: &mut Applicability,
-) -> Cow<'a, str> {
-    let snip = snippet_with_applicability(cx, span, default, applicability);
-    let indent = indent_relative_to.and_then(|s| indent_of(cx, s));
-    reindent_multiline(snip, true, indent)
-}
-
-/// Returns a new Span that extends the original Span to the first non-whitespace char of the first
-/// line.
-///
-/// ```rust,ignore
-///     let x = ();
-/// //          ^^
-/// // will be converted to
-///     let x = ();
-/// //  ^^^^^^^^^^
-/// ```
-pub fn first_line_of_span<T: LintContext>(cx: &T, span: Span) -> Span {
-    first_char_in_first_line(cx, span).map_or(span, |first_char_pos| span.with_lo(first_char_pos))
-}
-
-fn first_char_in_first_line<T: LintContext>(cx: &T, span: Span) -> Option<BytePos> {
-    let line_span = line_span(cx, span);
-    snippet_opt(cx, line_span).and_then(|snip| {
-        snip.find(|c: char| !c.is_whitespace())
-            .map(|pos| line_span.lo() + BytePos::from_usize(pos))
-    })
-}
-
-/// Returns the indentation of the line of a span
-///
-/// ```rust,ignore
-/// let x = ();
-/// //      ^^ -- will return 0
-///     let x = ();
-/// //          ^^ -- will return 4
-/// ```
-pub fn indent_of<T: LintContext>(cx: &T, span: Span) -> Option<usize> {
-    snippet_opt(cx, line_span(cx, span)).and_then(|snip| snip.find(|c: char| !c.is_whitespace()))
-}
-
-/// Returns the positon just before rarrow
-///
-/// ```rust,ignore
-/// fn into(self) -> () {}
-///              ^
-/// // in case of unformatted code
-/// fn into2(self)-> () {}
-///               ^
-/// fn into3(self)   -> () {}
-///               ^
-/// ```
-pub fn position_before_rarrow(s: &str) -> Option<usize> {
-    s.rfind("->").map(|rpos| {
-        let mut rpos = rpos;
-        let chars: Vec<char> = s.chars().collect();
-        while rpos > 1 {
-            if let Some(c) = chars.get(rpos - 1) {
-                if c.is_whitespace() {
-                    rpos -= 1;
-                    continue;
-                }
-            }
-            break;
-        }
-        rpos
-    })
-}
-
-/// Extends the span to the beginning of the spans line, incl. whitespaces.
-///
-/// ```rust,ignore
-///        let x = ();
-/// //             ^^
-/// // will be converted to
-///        let x = ();
-/// // ^^^^^^^^^^^^^^
-/// ```
-fn line_span<T: LintContext>(cx: &T, span: Span) -> Span {
-    let span = original_sp(span, DUMMY_SP);
-    let source_map_and_line = cx.sess().source_map().lookup_line(span.lo()).unwrap();
-    let line_no = source_map_and_line.line;
-    let line_start = source_map_and_line.sf.lines[line_no];
-    Span::new(line_start, span.hi(), span.ctxt())
-}
-
-/// Like `snippet_block`, but add braces if the expr is not an `ExprKind::Block`.
-/// Also takes an `Option<String>` which can be put inside the braces.
-pub fn expr_block<'a, T: LintContext>(
-    cx: &T,
-    expr: &Expr<'_>,
-    option: Option<String>,
-    default: &'a str,
-    indent_relative_to: Option<Span>,
-) -> Cow<'a, str> {
-    let code = snippet_block(cx, expr.span, default, indent_relative_to);
-    let string = option.unwrap_or_default();
-    if expr.span.from_expansion() {
-        Cow::Owned(format!("{{ {} }}", snippet_with_macro_callsite(cx, expr.span, default)))
-    } else if let ExprKind::Block(_, _) = expr.kind {
-        Cow::Owned(format!("{}{}", code, string))
-    } else if string.is_empty() {
-        Cow::Owned(format!("{{ {} }}", code))
-    } else {
-        Cow::Owned(format!("{{\n{};\n{}\n}}", code, string))
-    }
-}
-
-/// Reindent a multiline string with possibility of ignoring the first line.
-#[allow(clippy::needless_pass_by_value)]
-pub fn reindent_multiline(s: Cow<'_, str>, ignore_first: bool, indent: Option<usize>) -> Cow<'_, str> {
-    let s_space = reindent_multiline_inner(&s, ignore_first, indent, ' ');
-    let s_tab = reindent_multiline_inner(&s_space, ignore_first, indent, '\t');
-    reindent_multiline_inner(&s_tab, ignore_first, indent, ' ').into()
-}
-
-fn reindent_multiline_inner(s: &str, ignore_first: bool, indent: Option<usize>, ch: char) -> String {
-    let x = s
-        .lines()
-        .skip(ignore_first as usize)
-        .filter_map(|l| {
-            if l.is_empty() {
-                None
-            } else {
-                // ignore empty lines
-                Some(l.char_indices().find(|&(_, x)| x != ch).unwrap_or((l.len(), ch)).0)
-            }
-        })
-        .min()
-        .unwrap_or(0);
-    let indent = indent.unwrap_or(0);
-    s.lines()
-        .enumerate()
-        .map(|(i, l)| {
-            if (ignore_first && i == 0) || l.is_empty() {
-                l.to_owned()
-            } else if x > indent {
-                l.split_at(x - indent).1.to_owned()
-            } else {
-                " ".repeat(indent - x) + l
-            }
-        })
-        .collect::<Vec<String>>()
-        .join("\n")
-}
-
-/// Gets the parent expression, if any –- this is useful to constrain a lint.
-pub fn get_parent_expr<'tcx>(cx: &LateContext<'tcx>, e: &Expr<'_>) -> Option<&'tcx Expr<'tcx>> {
-    let map = &cx.tcx.hir();
-    let hir_id = e.hir_id;
-    let parent_id = map.get_parent_node(hir_id);
-    if hir_id == parent_id {
-        return None;
-    }
-    map.find(parent_id).and_then(|node| {
-        if let Node::Expr(parent) = node {
-            Some(parent)
-        } else {
-            None
-        }
-    })
-}
-
-pub fn get_enclosing_block<'tcx>(cx: &LateContext<'tcx>, hir_id: HirId) -> Option<&'tcx Block<'tcx>> {
-    let map = &cx.tcx.hir();
-    let enclosing_node = map
-        .get_enclosing_scope(hir_id)
-        .and_then(|enclosing_id| map.find(enclosing_id));
-    enclosing_node.and_then(|node| match node {
-        Node::Block(block) => Some(block),
-        Node::Item(&Item {
-            kind: ItemKind::Fn(_, _, eid),
-            ..
-        })
-        | Node::ImplItem(&ImplItem {
-            kind: ImplItemKind::Fn(_, eid),
-            ..
-        }) => match cx.tcx.hir().body(eid).value.kind {
-            ExprKind::Block(ref block, _) => Some(block),
-            _ => None,
-        },
-        _ => None,
-    })
-}
-
-/// Returns the base type for HIR references and pointers.
-pub fn walk_ptrs_hir_ty<'tcx>(ty: &'tcx hir::Ty<'tcx>) -> &'tcx hir::Ty<'tcx> {
-    match ty.kind {
-        TyKind::Ptr(ref mut_ty) | TyKind::Rptr(_, ref mut_ty) => walk_ptrs_hir_ty(&mut_ty.ty),
-        _ => ty,
-    }
-}
-
-/// Returns the base type for references and raw pointers, and count reference
-/// depth.
-pub fn walk_ptrs_ty_depth(ty: Ty<'_>) -> (Ty<'_>, usize) {
-    fn inner(ty: Ty<'_>, depth: usize) -> (Ty<'_>, usize) {
-        match ty.kind() {
-            ty::Ref(_, ty, _) => inner(ty, depth + 1),
-            _ => (ty, depth),
-        }
-    }
-    inner(ty, 0)
-}
-
-/// Checks whether the given expression is a constant integer of the given value.
-/// unlike `is_integer_literal`, this version does const folding
-pub fn is_integer_const(cx: &LateContext<'_>, e: &Expr<'_>, value: u128) -> bool {
-    if is_integer_literal(e, value) {
-        return true;
-    }
-    let map = cx.tcx.hir();
-    let parent_item = map.get_parent_item(e.hir_id);
-    if let Some((Constant::Int(v), _)) = map
-        .maybe_body_owned_by(parent_item)
-        .and_then(|body_id| constant(cx, cx.tcx.typeck_body(body_id), e))
-    {
-        value == v
-    } else {
-        false
-    }
-}
-
-/// Checks whether the given expression is a constant literal of the given value.
-pub fn is_integer_literal(expr: &Expr<'_>, value: u128) -> bool {
-    // FIXME: use constant folding
-    if let ExprKind::Lit(ref spanned) = expr.kind {
-        if let LitKind::Int(v, _) = spanned.node {
-            return v == value;
-        }
-    }
-    false
-}
-
-/// Returns `true` if the given `Expr` has been coerced before.
-///
-/// Examples of coercions can be found in the Nomicon at
-/// <https://doc.rust-lang.org/nomicon/coercions.html>.
-///
-/// See `rustc_middle::ty::adjustment::Adjustment` and `rustc_typeck::check::coercion` for more
-/// information on adjustments and coercions.
-pub fn is_adjusted(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
-    cx.typeck_results().adjustments().get(e.hir_id).is_some()
-}
-
-/// Returns the pre-expansion span if is this comes from an expansion of the
-/// macro `name`.
-/// See also `is_direct_expn_of`.
-#[must_use]
-pub fn is_expn_of(mut span: Span, name: &str) -> Option<Span> {
-    loop {
-        if span.from_expansion() {
-            let data = span.ctxt().outer_expn_data();
-            let new_span = data.call_site;
-
-            if let ExpnKind::Macro(MacroKind::Bang, mac_name) = data.kind {
-                if mac_name.as_str() == name {
-                    return Some(new_span);
-                }
-            }
-
-            span = new_span;
-        } else {
-            return None;
-        }
-    }
-}
-
-/// Returns the pre-expansion span if the span directly comes from an expansion
-/// of the macro `name`.
-/// The difference with `is_expn_of` is that in
-/// ```rust,ignore
-/// foo!(bar!(42));
-/// ```
-/// `42` is considered expanded from `foo!` and `bar!` by `is_expn_of` but only
-/// `bar!` by
-/// `is_direct_expn_of`.
-#[must_use]
-pub fn is_direct_expn_of(span: Span, name: &str) -> Option<Span> {
-    if span.from_expansion() {
-        let data = span.ctxt().outer_expn_data();
-        let new_span = data.call_site;
-
-        if let ExpnKind::Macro(MacroKind::Bang, mac_name) = data.kind {
-            if mac_name.as_str() == name {
-                return Some(new_span);
-            }
-        }
-    }
-
-    None
-}
-
-/// Convenience function to get the return type of a function.
-pub fn return_ty<'tcx>(cx: &LateContext<'tcx>, fn_item: hir::HirId) -> Ty<'tcx> {
-    let fn_def_id = cx.tcx.hir().local_def_id(fn_item);
-    let ret_ty = cx.tcx.fn_sig(fn_def_id).output();
-    cx.tcx.erase_late_bound_regions(ret_ty)
-}
-
-/// Walks into `ty` and returns `true` if any inner type is the same as `other_ty`
-pub fn contains_ty(ty: Ty<'_>, other_ty: Ty<'_>) -> bool {
-    ty.walk().any(|inner| match inner.unpack() {
-        GenericArgKind::Type(inner_ty) => ty::TyS::same_type(other_ty, inner_ty),
-        GenericArgKind::Lifetime(_) | GenericArgKind::Const(_) => false,
-    })
-}
-
-/// Returns `true` if the given type is an `unsafe` function.
-pub fn type_is_unsafe_function<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
-    match ty.kind() {
-        ty::FnDef(..) | ty::FnPtr(_) => ty.fn_sig(cx.tcx).unsafety() == Unsafety::Unsafe,
-        _ => false,
-    }
-}
-
-pub fn is_copy<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
-    ty.is_copy_modulo_regions(cx.tcx.at(DUMMY_SP), cx.param_env)
-}
-
-/// Checks if an expression is constructing a tuple-like enum variant or struct
-pub fn is_ctor_or_promotable_const_function(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-    if let ExprKind::Call(ref fun, _) = expr.kind {
-        if let ExprKind::Path(ref qp) = fun.kind {
-            let res = cx.qpath_res(qp, fun.hir_id);
-            return match res {
-                def::Res::Def(DefKind::Variant | DefKind::Ctor(..), ..) => true,
-                def::Res::Def(_, def_id) => cx.tcx.is_promotable_const_fn(def_id),
-                _ => false,
-            };
-        }
-    }
-    false
-}
-
-/// Returns `true` if a pattern is refutable.
-// TODO: should be implemented using rustc/mir_build/thir machinery
-pub fn is_refutable(cx: &LateContext<'_>, pat: &Pat<'_>) -> bool {
-    fn is_enum_variant(cx: &LateContext<'_>, qpath: &QPath<'_>, id: HirId) -> bool {
-        matches!(
-            cx.qpath_res(qpath, id),
-            def::Res::Def(DefKind::Variant, ..) | Res::Def(DefKind::Ctor(def::CtorOf::Variant, _), _)
-        )
-    }
-
-    fn are_refutable<'a, I: Iterator<Item = &'a Pat<'a>>>(cx: &LateContext<'_>, mut i: I) -> bool {
-        i.any(|pat| is_refutable(cx, pat))
-    }
-
-    match pat.kind {
-        PatKind::Wild => false,
-        PatKind::Binding(_, _, _, pat) => pat.map_or(false, |pat| is_refutable(cx, pat)),
-        PatKind::Box(ref pat) | PatKind::Ref(ref pat, _) => is_refutable(cx, pat),
-        PatKind::Lit(..) | PatKind::Range(..) => true,
-        PatKind::Path(ref qpath) => is_enum_variant(cx, qpath, pat.hir_id),
-        PatKind::Or(ref pats) => {
-            // TODO: should be the honest check, that pats is exhaustive set
-            are_refutable(cx, pats.iter().map(|pat| &**pat))
-        },
-        PatKind::Tuple(ref pats, _) => are_refutable(cx, pats.iter().map(|pat| &**pat)),
-        PatKind::Struct(ref qpath, ref fields, _) => {
-            is_enum_variant(cx, qpath, pat.hir_id) || are_refutable(cx, fields.iter().map(|field| &*field.pat))
-        },
-        PatKind::TupleStruct(ref qpath, ref pats, _) => {
-            is_enum_variant(cx, qpath, pat.hir_id) || are_refutable(cx, pats.iter().map(|pat| &**pat))
-        },
-        PatKind::Slice(ref head, ref middle, ref tail) => {
-            match &cx.typeck_results().node_type(pat.hir_id).kind() {
-                ty::Slice(..) => {
-                    // [..] is the only irrefutable slice pattern.
-                    !head.is_empty() || middle.is_none() || !tail.is_empty()
-                },
-                ty::Array(..) => are_refutable(cx, head.iter().chain(middle).chain(tail.iter()).map(|pat| &**pat)),
-                _ => {
-                    // unreachable!()
-                    true
-                },
-            }
-        },
-    }
-}
-
-/// Checks for the `#[automatically_derived]` attribute all `#[derive]`d
-/// implementations have.
-pub fn is_automatically_derived(attrs: &[ast::Attribute]) -> bool {
-    attrs.iter().any(|attr| attr.has_name(sym::automatically_derived))
-}
-
-/// Remove blocks around an expression.
-///
-/// Ie. `x`, `{ x }` and `{{{{ x }}}}` all give `x`. `{ x; y }` and `{}` return
-/// themselves.
-pub fn remove_blocks<'tcx>(mut expr: &'tcx Expr<'tcx>) -> &'tcx Expr<'tcx> {
-    while let ExprKind::Block(ref block, ..) = expr.kind {
-        match (block.stmts.is_empty(), block.expr.as_ref()) {
-            (true, Some(e)) => expr = e,
-            _ => break,
-        }
-    }
-    expr
-}
-
-pub fn is_self(slf: &Param<'_>) -> bool {
-    if let PatKind::Binding(.., name, _) = slf.pat.kind {
-        name.name == kw::SelfLower
-    } else {
-        false
-    }
-}
-
-pub fn is_self_ty(slf: &hir::Ty<'_>) -> bool {
-    if_chain! {
-        if let TyKind::Path(QPath::Resolved(None, ref path)) = slf.kind;
-        if let Res::SelfTy(..) = path.res;
-        then {
-            return true
-        }
-    }
-    false
-}
-
-pub fn iter_input_pats<'tcx>(decl: &FnDecl<'_>, body: &'tcx Body<'_>) -> impl Iterator<Item = &'tcx Param<'tcx>> {
-    (0..decl.inputs.len()).map(move |i| &body.params[i])
-}
-
-/// Checks if a given expression is a match expression expanded from the `?`
-/// operator or the `try` macro.
-pub fn is_try<'tcx>(expr: &'tcx Expr<'tcx>) -> Option<&'tcx Expr<'tcx>> {
-    fn is_ok(arm: &Arm<'_>) -> bool {
-        if_chain! {
-            if let PatKind::TupleStruct(ref path, ref pat, None) = arm.pat.kind;
-            if match_qpath(path, &paths::RESULT_OK[1..]);
-            if let PatKind::Binding(_, hir_id, _, None) = pat[0].kind;
-            if path_to_local_id(arm.body, hir_id);
-            then {
-                return true;
-            }
-        }
-        false
-    }
-
-    fn is_err(arm: &Arm<'_>) -> bool {
-        if let PatKind::TupleStruct(ref path, _, _) = arm.pat.kind {
-            match_qpath(path, &paths::RESULT_ERR[1..])
-        } else {
-            false
-        }
-    }
-
-    if let ExprKind::Match(_, ref arms, ref source) = expr.kind {
-        // desugared from a `?` operator
-        if let MatchSource::TryDesugar = *source {
-            return Some(expr);
-        }
-
-        if_chain! {
-            if arms.len() == 2;
-            if arms[0].guard.is_none();
-            if arms[1].guard.is_none();
-            if (is_ok(&arms[0]) && is_err(&arms[1])) ||
-                (is_ok(&arms[1]) && is_err(&arms[0]));
-            then {
-                return Some(expr);
-            }
-        }
-    }
-
-    None
-}
-
-/// Returns `true` if the lint is allowed in the current context
-///
-/// Useful for skipping long running code when it's unnecessary
-pub fn is_allowed(cx: &LateContext<'_>, lint: &'static Lint, id: HirId) -> bool {
-    cx.tcx.lint_level_at_node(lint, id).0 == Level::Allow
-}
-
-pub fn strip_pat_refs<'hir>(mut pat: &'hir Pat<'hir>) -> &'hir Pat<'hir> {
-    while let PatKind::Ref(subpat, _) = pat.kind {
-        pat = subpat;
-    }
-    pat
-}
-
-pub fn int_bits(tcx: TyCtxt<'_>, ity: ty::IntTy) -> u64 {
-    Integer::from_int_ty(&tcx, ity).size().bits()
-}
-
-#[allow(clippy::cast_possible_wrap)]
-/// Turn a constant int byte representation into an i128
-pub fn sext(tcx: TyCtxt<'_>, u: u128, ity: ty::IntTy) -> i128 {
-    let amt = 128 - int_bits(tcx, ity);
-    ((u as i128) << amt) >> amt
-}
-
-#[allow(clippy::cast_sign_loss)]
-/// clip unused bytes
-pub fn unsext(tcx: TyCtxt<'_>, u: i128, ity: ty::IntTy) -> u128 {
-    let amt = 128 - int_bits(tcx, ity);
-    ((u as u128) << amt) >> amt
-}
-
-/// clip unused bytes
-pub fn clip(tcx: TyCtxt<'_>, u: u128, ity: ty::UintTy) -> u128 {
-    let bits = Integer::from_uint_ty(&tcx, ity).size().bits();
-    let amt = 128 - bits;
-    (u << amt) >> amt
-}
-
-/// Removes block comments from the given `Vec` of lines.
-///
-/// # Examples
-///
-/// ```rust,ignore
-/// without_block_comments(vec!["/*", "foo", "*/"]);
-/// // => vec![]
-///
-/// without_block_comments(vec!["bar", "/*", "foo", "*/"]);
-/// // => vec!["bar"]
-/// ```
-pub fn without_block_comments(lines: Vec<&str>) -> Vec<&str> {
-    let mut without = vec![];
-
-    let mut nest_level = 0;
-
-    for line in lines {
-        if line.contains("/*") {
-            nest_level += 1;
-            continue;
-        } else if line.contains("*/") {
-            nest_level -= 1;
-            continue;
-        }
-
-        if nest_level == 0 {
-            without.push(line);
-        }
-    }
-
-    without
-}
-
-pub fn any_parent_is_automatically_derived(tcx: TyCtxt<'_>, node: HirId) -> bool {
-    let map = &tcx.hir();
-    let mut prev_enclosing_node = None;
-    let mut enclosing_node = node;
-    while Some(enclosing_node) != prev_enclosing_node {
-        if is_automatically_derived(map.attrs(enclosing_node)) {
-            return true;
-        }
-        prev_enclosing_node = Some(enclosing_node);
-        enclosing_node = map.get_parent_item(enclosing_node);
-    }
-    false
-}
-
-/// Returns true if ty has `iter` or `iter_mut` methods
-pub fn has_iter_method(cx: &LateContext<'_>, probably_ref_ty: Ty<'_>) -> Option<&'static str> {
-    // FIXME: instead of this hard-coded list, we should check if `<adt>::iter`
-    // exists and has the desired signature. Unfortunately FnCtxt is not exported
-    // so we can't use its `lookup_method` method.
-    let into_iter_collections: [&[&str]; 13] = [
-        &paths::VEC,
-        &paths::OPTION,
-        &paths::RESULT,
-        &paths::BTREESET,
-        &paths::BTREEMAP,
-        &paths::VEC_DEQUE,
-        &paths::LINKED_LIST,
-        &paths::BINARY_HEAP,
-        &paths::HASHSET,
-        &paths::HASHMAP,
-        &paths::PATH_BUF,
-        &paths::PATH,
-        &paths::RECEIVER,
-    ];
-
-    let ty_to_check = match probably_ref_ty.kind() {
-        ty::Ref(_, ty_to_check, _) => ty_to_check,
-        _ => probably_ref_ty,
-    };
-
-    let def_id = match ty_to_check.kind() {
-        ty::Array(..) => return Some("array"),
-        ty::Slice(..) => return Some("slice"),
-        ty::Adt(adt, _) => adt.did,
-        _ => return None,
-    };
-
-    for path in &into_iter_collections {
-        if match_def_path(cx, def_id, path) {
-            return Some(*path.last().unwrap());
-        }
-    }
-    None
-}
-
-/// Matches a function call with the given path and returns the arguments.
-///
-/// Usage:
-///
-/// ```rust,ignore
-/// if let Some(args) = match_function_call(cx, cmp_max_call, &paths::CMP_MAX);
-/// ```
-pub fn match_function_call<'tcx>(
-    cx: &LateContext<'tcx>,
-    expr: &'tcx Expr<'_>,
-    path: &[&str],
-) -> Option<&'tcx [Expr<'tcx>]> {
-    if_chain! {
-        if let ExprKind::Call(ref fun, ref args) = expr.kind;
-        if let ExprKind::Path(ref qpath) = fun.kind;
-        if let Some(fun_def_id) = cx.qpath_res(qpath, fun.hir_id).opt_def_id();
-        if match_def_path(cx, fun_def_id, path);
-        then {
-            return Some(&args)
-        }
-    };
-    None
-}
-
-/// Checks if `Ty` is normalizable. This function is useful
-/// to avoid crashes on `layout_of`.
-pub fn is_normalizable<'tcx>(cx: &LateContext<'tcx>, param_env: ty::ParamEnv<'tcx>, ty: Ty<'tcx>) -> bool {
-    cx.tcx.infer_ctxt().enter(|infcx| {
-        let cause = rustc_middle::traits::ObligationCause::dummy();
-        infcx.at(&cause, param_env).normalize(ty).is_ok()
-    })
-}
-
-pub fn match_def_path<'tcx>(cx: &LateContext<'tcx>, did: DefId, syms: &[&str]) -> bool {
-    // We have to convert `syms` to `&[Symbol]` here because rustc's `match_def_path`
-    // accepts only that. We should probably move to Symbols in Clippy as well.
-    let syms = syms.iter().map(|p| Symbol::intern(p)).collect::<Vec<Symbol>>();
-    cx.match_def_path(did, &syms)
-}
-
-pub fn match_panic_call<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<&'tcx [Expr<'tcx>]> {
-    match_function_call(cx, expr, &paths::BEGIN_PANIC)
-        .or_else(|| match_function_call(cx, expr, &paths::BEGIN_PANIC_FMT))
-        .or_else(|| match_function_call(cx, expr, &paths::PANIC_ANY))
-        .or_else(|| match_function_call(cx, expr, &paths::PANICKING_PANIC))
-        .or_else(|| match_function_call(cx, expr, &paths::PANICKING_PANIC_FMT))
-        .or_else(|| match_function_call(cx, expr, &paths::PANICKING_PANIC_STR))
-}
-
-pub fn match_panic_def_id(cx: &LateContext<'_>, did: DefId) -> bool {
-    match_def_path(cx, did, &paths::BEGIN_PANIC)
-        || match_def_path(cx, did, &paths::BEGIN_PANIC_FMT)
-        || match_def_path(cx, did, &paths::PANIC_ANY)
-        || match_def_path(cx, did, &paths::PANICKING_PANIC)
-        || match_def_path(cx, did, &paths::PANICKING_PANIC_FMT)
-        || match_def_path(cx, did, &paths::PANICKING_PANIC_STR)
-}
-
-/// Returns the list of condition expressions and the list of blocks in a
-/// sequence of `if/else`.
-/// E.g., this returns `([a, b], [c, d, e])` for the expression
-/// `if a { c } else if b { d } else { e }`.
-pub fn if_sequence<'tcx>(
-    mut expr: &'tcx Expr<'tcx>,
-) -> (SmallVec<[&'tcx Expr<'tcx>; 1]>, SmallVec<[&'tcx Block<'tcx>; 1]>) {
-    let mut conds = SmallVec::new();
-    let mut blocks: SmallVec<[&Block<'_>; 1]> = SmallVec::new();
-
-    while let ExprKind::If(ref cond, ref then_expr, ref else_expr) = expr.kind {
-        conds.push(&**cond);
-        if let ExprKind::Block(ref block, _) = then_expr.kind {
-            blocks.push(block);
-        } else {
-            panic!("ExprKind::If node is not an ExprKind::Block");
-        }
-
-        if let Some(ref else_expr) = *else_expr {
-            expr = else_expr;
-        } else {
-            break;
-        }
-    }
-
-    // final `else {..}`
-    if !blocks.is_empty() {
-        if let ExprKind::Block(ref block, _) = expr.kind {
-            blocks.push(&**block);
-        }
-    }
-
-    (conds, blocks)
-}
-
-pub fn parent_node_is_if_expr(expr: &Expr<'_>, cx: &LateContext<'_>) -> bool {
-    let map = cx.tcx.hir();
-    let parent_id = map.get_parent_node(expr.hir_id);
-    let parent_node = map.get(parent_id);
-    matches!(
-        parent_node,
-        Node::Expr(Expr {
-            kind: ExprKind::If(_, _, _),
-            ..
-        })
-    )
-}
-
-// Finds the attribute with the given name, if any
-pub fn attr_by_name<'a>(attrs: &'a [Attribute], name: &'_ str) -> Option<&'a Attribute> {
-    attrs
-        .iter()
-        .find(|attr| attr.ident().map_or(false, |ident| ident.as_str() == name))
-}
-
-// Finds the `#[must_use]` attribute, if any
-pub fn must_use_attr(attrs: &[Attribute]) -> Option<&Attribute> {
-    attr_by_name(attrs, "must_use")
-}
-
-// Returns whether the type has #[must_use] attribute
-pub fn is_must_use_ty<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
-    match ty.kind() {
-        ty::Adt(ref adt, _) => must_use_attr(&cx.tcx.get_attrs(adt.did)).is_some(),
-        ty::Foreign(ref did) => must_use_attr(&cx.tcx.get_attrs(*did)).is_some(),
-        ty::Slice(ref ty)
-        | ty::Array(ref ty, _)
-        | ty::RawPtr(ty::TypeAndMut { ref ty, .. })
-        | ty::Ref(_, ref ty, _) => {
-            // for the Array case we don't need to care for the len == 0 case
-            // because we don't want to lint functions returning empty arrays
-            is_must_use_ty(cx, *ty)
-        },
-        ty::Tuple(ref substs) => substs.types().any(|ty| is_must_use_ty(cx, ty)),
-        ty::Opaque(ref def_id, _) => {
-            for (predicate, _) in cx.tcx.explicit_item_bounds(*def_id) {
-                if let ty::PredicateKind::Trait(trait_predicate, _) = predicate.kind().skip_binder() {
-                    if must_use_attr(&cx.tcx.get_attrs(trait_predicate.trait_ref.def_id)).is_some() {
-                        return true;
-                    }
-                }
-            }
-            false
-        },
-        ty::Dynamic(binder, _) => {
-            for predicate in binder.iter() {
-                if let ty::ExistentialPredicate::Trait(ref trait_ref) = predicate.skip_binder() {
-                    if must_use_attr(&cx.tcx.get_attrs(trait_ref.def_id)).is_some() {
-                        return true;
-                    }
-                }
-            }
-            false
-        },
-        _ => false,
-    }
-}
-
-// check if expr is calling method or function with #[must_use] attribute
-pub fn is_must_use_func_call(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-    let did = match expr.kind {
-        ExprKind::Call(ref path, _) => if_chain! {
-            if let ExprKind::Path(ref qpath) = path.kind;
-            if let def::Res::Def(_, did) = cx.qpath_res(qpath, path.hir_id);
-            then {
-                Some(did)
-            } else {
-                None
-            }
-        },
-        ExprKind::MethodCall(_, _, _, _) => cx.typeck_results().type_dependent_def_id(expr.hir_id),
-        _ => None,
-    };
-
-    did.map_or(false, |did| must_use_attr(&cx.tcx.get_attrs(did)).is_some())
-}
-
-pub fn is_no_std_crate(krate: &Crate<'_>) -> bool {
-    krate.item.attrs.iter().any(|attr| {
-        if let ast::AttrKind::Normal(ref attr, _) = attr.kind {
-            attr.path == sym::no_std
-        } else {
-            false
-        }
-    })
-}
-
-/// Check if parent of a hir node is a trait implementation block.
-/// For example, `f` in
-/// ```rust,ignore
-/// impl Trait for S {
-///     fn f() {}
-/// }
-/// ```
-pub fn is_trait_impl_item(cx: &LateContext<'_>, hir_id: HirId) -> bool {
-    if let Some(Node::Item(item)) = cx.tcx.hir().find(cx.tcx.hir().get_parent_node(hir_id)) {
-        matches!(item.kind, ItemKind::Impl(hir::Impl { of_trait: Some(_), .. }))
-    } else {
-        false
-    }
-}
-
-/// Check if it's even possible to satisfy the `where` clause for the item.
-///
-/// `trivial_bounds` feature allows functions with unsatisfiable bounds, for example:
-///
-/// ```ignore
-/// fn foo() where i32: Iterator {
-///     for _ in 2i32 {}
-/// }
-/// ```
-pub fn fn_has_unsatisfiable_preds(cx: &LateContext<'_>, did: DefId) -> bool {
-    use rustc_trait_selection::traits;
-    let predicates =
-        cx.tcx
-            .predicates_of(did)
-            .predicates
-            .iter()
-            .filter_map(|(p, _)| if p.is_global() { Some(*p) } else { None });
-    traits::impossible_predicates(
-        cx.tcx,
-        traits::elaborate_predicates(cx.tcx, predicates)
-            .map(|o| o.predicate)
-            .collect::<Vec<_>>(),
-    )
-}
-
-/// Returns the `DefId` of the callee if the given expression is a function or method call.
-pub fn fn_def_id(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<DefId> {
-    match &expr.kind {
-        ExprKind::MethodCall(..) => cx.typeck_results().type_dependent_def_id(expr.hir_id),
-        ExprKind::Call(
-            Expr {
-                kind: ExprKind::Path(qpath),
-                hir_id: path_hir_id,
-                ..
-            },
-            ..,
-        ) => cx.typeck_results().qpath_res(qpath, *path_hir_id).opt_def_id(),
-        _ => None,
-    }
-}
-
-pub fn run_lints(cx: &LateContext<'_>, lints: &[&'static Lint], id: HirId) -> bool {
-    lints.iter().any(|lint| {
-        matches!(
-            cx.tcx.lint_level_at_node(lint, id),
-            (Level::Forbid | Level::Deny | Level::Warn, _)
-        )
-    })
-}
-
-/// Returns true iff the given type is a primitive (a bool or char, any integer or floating-point
-/// number type, a str, or an array, slice, or tuple of those types).
-pub fn is_recursively_primitive_type(ty: Ty<'_>) -> bool {
-    match ty.kind() {
-        ty::Bool | ty::Char | ty::Int(_) | ty::Uint(_) | ty::Float(_) | ty::Str => true,
-        ty::Ref(_, inner, _) if *inner.kind() == ty::Str => true,
-        ty::Array(inner_type, _) | ty::Slice(inner_type) => is_recursively_primitive_type(inner_type),
-        ty::Tuple(inner_types) => inner_types.types().all(is_recursively_primitive_type),
-        _ => false,
-    }
-}
-
-/// Returns Option<String> where String is a textual representation of the type encapsulated in the
-/// slice iff the given expression is a slice of primitives (as defined in the
-/// `is_recursively_primitive_type` function) and None otherwise.
-pub fn is_slice_of_primitives(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<String> {
-    let expr_type = cx.typeck_results().expr_ty_adjusted(expr);
-    let expr_kind = expr_type.kind();
-    let is_primitive = match expr_kind {
-        ty::Slice(element_type) => is_recursively_primitive_type(element_type),
-        ty::Ref(_, inner_ty, _) if matches!(inner_ty.kind(), &ty::Slice(_)) => {
-            if let ty::Slice(element_type) = inner_ty.kind() {
-                is_recursively_primitive_type(element_type)
-            } else {
-                unreachable!()
-            }
-        },
-        _ => false,
-    };
-
-    if is_primitive {
-        // if we have wrappers like Array, Slice or Tuple, print these
-        // and get the type enclosed in the slice ref
-        match expr_type.peel_refs().walk().nth(1).unwrap().expect_ty().kind() {
-            ty::Slice(..) => return Some("slice".into()),
-            ty::Array(..) => return Some("array".into()),
-            ty::Tuple(..) => return Some("tuple".into()),
-            _ => {
-                // is_recursively_primitive_type() should have taken care
-                // of the rest and we can rely on the type that is found
-                let refs_peeled = expr_type.peel_refs();
-                return Some(refs_peeled.walk().last().unwrap().to_string());
-            },
-        }
-    }
-    None
-}
-
-/// returns list of all pairs (a, b) from `exprs` such that `eq(a, b)`
-/// `hash` must be comformed with `eq`
-pub fn search_same<T, Hash, Eq>(exprs: &[T], hash: Hash, eq: Eq) -> Vec<(&T, &T)>
-where
-    Hash: Fn(&T) -> u64,
-    Eq: Fn(&T, &T) -> bool,
-{
-    if exprs.len() == 2 && eq(&exprs[0], &exprs[1]) {
-        return vec![(&exprs[0], &exprs[1])];
-    }
-
-    let mut match_expr_list: Vec<(&T, &T)> = Vec::new();
-
-    let mut map: FxHashMap<_, Vec<&_>> =
-        FxHashMap::with_capacity_and_hasher(exprs.len(), BuildHasherDefault::default());
-
-    for expr in exprs {
-        match map.entry(hash(expr)) {
-            Entry::Occupied(mut o) => {
-                for o in o.get() {
-                    if eq(o, expr) {
-                        match_expr_list.push((o, expr));
-                    }
-                }
-                o.get_mut().push(expr);
-            },
-            Entry::Vacant(v) => {
-                v.insert(vec![expr]);
-            },
-        }
-    }
-
-    match_expr_list
-}
-
-/// Peels off all references on the pattern. Returns the underlying pattern and the number of
-/// references removed.
-pub fn peel_hir_pat_refs(pat: &'a Pat<'a>) -> (&'a Pat<'a>, usize) {
-    fn peel(pat: &'a Pat<'a>, count: usize) -> (&'a Pat<'a>, usize) {
-        if let PatKind::Ref(pat, _) = pat.kind {
-            peel(pat, count + 1)
-        } else {
-            (pat, count)
-        }
-    }
-    peel(pat, 0)
-}
-
-/// Peels off up to the given number of references on the expression. Returns the underlying
-/// expression and the number of references removed.
-pub fn peel_n_hir_expr_refs(expr: &'a Expr<'a>, count: usize) -> (&'a Expr<'a>, usize) {
-    fn f(expr: &'a Expr<'a>, count: usize, target: usize) -> (&'a Expr<'a>, usize) {
-        match expr.kind {
-            ExprKind::AddrOf(_, _, expr) if count != target => f(expr, count + 1, target),
-            _ => (expr, count),
-        }
-    }
-    f(expr, 0, count)
-}
-
-/// Peels off all references on the expression. Returns the underlying expression and the number of
-/// references removed.
-pub fn peel_hir_expr_refs(expr: &'a Expr<'a>) -> (&'a Expr<'a>, usize) {
-    fn f(expr: &'a Expr<'a>, count: usize) -> (&'a Expr<'a>, usize) {
-        match expr.kind {
-            ExprKind::AddrOf(BorrowKind::Ref, _, expr) => f(expr, count + 1),
-            _ => (expr, count),
-        }
-    }
-    f(expr, 0)
-}
-
-/// Peels off all references on the type. Returns the underlying type and the number of references
-/// removed.
-pub fn peel_mid_ty_refs(ty: Ty<'_>) -> (Ty<'_>, usize) {
-    fn peel(ty: Ty<'_>, count: usize) -> (Ty<'_>, usize) {
-        if let ty::Ref(_, ty, _) = ty.kind() {
-            peel(ty, count + 1)
-        } else {
-            (ty, count)
-        }
-    }
-    peel(ty, 0)
-}
-
-/// Peels off all references on the type.Returns the underlying type, the number of references
-/// removed, and whether the pointer is ultimately mutable or not.
-pub fn peel_mid_ty_refs_is_mutable(ty: Ty<'_>) -> (Ty<'_>, usize, Mutability) {
-    fn f(ty: Ty<'_>, count: usize, mutability: Mutability) -> (Ty<'_>, usize, Mutability) {
-        match ty.kind() {
-            ty::Ref(_, ty, Mutability::Mut) => f(ty, count + 1, mutability),
-            ty::Ref(_, ty, Mutability::Not) => f(ty, count + 1, Mutability::Not),
-            _ => (ty, count, mutability),
-        }
-    }
-    f(ty, 0, Mutability::Mut)
-}
-
-#[macro_export]
-macro_rules! unwrap_cargo_metadata {
-    ($cx: ident, $lint: ident, $deps: expr) => {{
-        let mut command = cargo_metadata::MetadataCommand::new();
-        if !$deps {
-            command.no_deps();
-        }
-
-        match command.exec() {
-            Ok(metadata) => metadata,
-            Err(err) => {
-                span_lint($cx, $lint, DUMMY_SP, &format!("could not read cargo metadata: {}", err));
-                return;
-            },
-        }
-    }};
-}
-
-pub fn is_hir_ty_cfg_dependant(cx: &LateContext<'_>, ty: &hir::Ty<'_>) -> bool {
-    if_chain! {
-        if let TyKind::Path(QPath::Resolved(_, path)) = ty.kind;
-        if let Res::Def(_, def_id) = path.res;
-        then {
-            cx.tcx.has_attr(def_id, sym::cfg) || cx.tcx.has_attr(def_id, sym::cfg_attr)
-        } else {
-            false
-        }
-    }
-}
-
-/// Check if the resolution of a given path is an `Ok` variant of `Result`.
-pub fn is_ok_ctor(cx: &LateContext<'_>, res: Res) -> bool {
-    if let Some(ok_id) = cx.tcx.lang_items().result_ok_variant() {
-        if let Res::Def(DefKind::Ctor(CtorOf::Variant, CtorKind::Fn), id) = res {
-            if let Some(variant_id) = cx.tcx.parent(id) {
-                return variant_id == ok_id;
-            }
-        }
-    }
-    false
-}
-
-/// Check if the resolution of a given path is a `Some` variant of `Option`.
-pub fn is_some_ctor(cx: &LateContext<'_>, res: Res) -> bool {
-    if let Some(some_id) = cx.tcx.lang_items().option_some_variant() {
-        if let Res::Def(DefKind::Ctor(CtorOf::Variant, CtorKind::Fn), id) = res {
-            if let Some(variant_id) = cx.tcx.parent(id) {
-                return variant_id == some_id;
-            }
-        }
-    }
-    false
-}
-
-#[cfg(test)]
-mod test {
-    use super::{reindent_multiline, without_block_comments};
-
-    #[test]
-    fn test_reindent_multiline_single_line() {
-        assert_eq!("", reindent_multiline("".into(), false, None));
-        assert_eq!("...", reindent_multiline("...".into(), false, None));
-        assert_eq!("...", reindent_multiline("    ...".into(), false, None));
-        assert_eq!("...", reindent_multiline("\t...".into(), false, None));
-        assert_eq!("...", reindent_multiline("\t\t...".into(), false, None));
-    }
-
-    #[test]
-    #[rustfmt::skip]
-    fn test_reindent_multiline_block() {
-        assert_eq!("\
-    if x {
-        y
-    } else {
-        z
-    }", reindent_multiline("    if x {
-            y
-        } else {
-            z
-        }".into(), false, None));
-        assert_eq!("\
-    if x {
-    \ty
-    } else {
-    \tz
-    }", reindent_multiline("    if x {
-        \ty
-        } else {
-        \tz
-        }".into(), false, None));
-    }
-
-    #[test]
-    #[rustfmt::skip]
-    fn test_reindent_multiline_empty_line() {
-        assert_eq!("\
-    if x {
-        y
-
-    } else {
-        z
-    }", reindent_multiline("    if x {
-            y
-
-        } else {
-            z
-        }".into(), false, None));
-    }
-
-    #[test]
-    #[rustfmt::skip]
-    fn test_reindent_multiline_lines_deeper() {
-        assert_eq!("\
-        if x {
-            y
-        } else {
-            z
-        }", reindent_multiline("\
-    if x {
-        y
-    } else {
-        z
-    }".into(), true, Some(8)));
-    }
-
-    #[test]
-    fn test_without_block_comments_lines_without_block_comments() {
-        let result = without_block_comments(vec!["/*", "", "*/"]);
-        println!("result: {:?}", result);
-        assert!(result.is_empty());
-
-        let result = without_block_comments(vec!["", "/*", "", "*/", "#[crate_type = \"lib\"]", "/*", "", "*/", ""]);
-        assert_eq!(result, vec!["", "#[crate_type = \"lib\"]", ""]);
-
-        let result = without_block_comments(vec!["/* rust", "", "*/"]);
-        assert!(result.is_empty());
-
-        let result = without_block_comments(vec!["/* one-line comment */"]);
-        assert!(result.is_empty());
-
-        let result = without_block_comments(vec!["/* nested", "/* multi-line", "comment", "*/", "test", "*/"]);
-        assert!(result.is_empty());
-
-        let result = without_block_comments(vec!["/* nested /* inline /* comment */ test */ */"]);
-        assert!(result.is_empty());
-
-        let result = without_block_comments(vec!["foo", "bar", "baz"]);
-        assert_eq!(result, vec!["foo", "bar", "baz"]);
-    }
-}
diff --git a/clippy_lints/src/utils/numeric_literal.rs b/clippy_lints/src/utils/numeric_literal.rs
deleted file mode 100644
index d02603d7702..00000000000
--- a/clippy_lints/src/utils/numeric_literal.rs
+++ /dev/null
@@ -1,228 +0,0 @@
-use rustc_ast::ast::{Lit, LitFloatType, LitIntType, LitKind};
-
-#[derive(Debug, PartialEq, Copy, Clone)]
-pub enum Radix {
-    Binary,
-    Octal,
-    Decimal,
-    Hexadecimal,
-}
-
-impl Radix {
-    /// Returns a reasonable digit group size for this radix.
-    #[must_use]
-    fn suggest_grouping(self) -> usize {
-        match self {
-            Self::Binary | Self::Hexadecimal => 4,
-            Self::Octal | Self::Decimal => 3,
-        }
-    }
-}
-
-/// A helper method to format numeric literals with digit grouping.
-/// `lit` must be a valid numeric literal without suffix.
-pub fn format(lit: &str, type_suffix: Option<&str>, float: bool) -> String {
-    NumericLiteral::new(lit, type_suffix, float).format()
-}
-
-#[derive(Debug)]
-pub struct NumericLiteral<'a> {
-    /// Which radix the literal was represented in.
-    pub radix: Radix,
-    /// The radix prefix, if present.
-    pub prefix: Option<&'a str>,
-
-    /// The integer part of the number.
-    pub integer: &'a str,
-    /// The fraction part of the number.
-    pub fraction: Option<&'a str>,
-    /// The exponent separator (b'e' or b'E') including preceding underscore if present
-    /// and the exponent part.
-    pub exponent: Option<(&'a str, &'a str)>,
-
-    /// The type suffix, including preceding underscore if present.
-    pub suffix: Option<&'a str>,
-}
-
-impl<'a> NumericLiteral<'a> {
-    pub fn from_lit(src: &'a str, lit: &Lit) -> Option<NumericLiteral<'a>> {
-        NumericLiteral::from_lit_kind(src, &lit.kind)
-    }
-
-    pub fn from_lit_kind(src: &'a str, lit_kind: &LitKind) -> Option<NumericLiteral<'a>> {
-        if lit_kind.is_numeric() && src.chars().next().map_or(false, |c| c.is_digit(10)) {
-            let (unsuffixed, suffix) = split_suffix(&src, lit_kind);
-            let float = matches!(lit_kind, LitKind::Float(..));
-            Some(NumericLiteral::new(unsuffixed, suffix, float))
-        } else {
-            None
-        }
-    }
-
-    #[must_use]
-    pub fn new(lit: &'a str, suffix: Option<&'a str>, float: bool) -> Self {
-        // Determine delimiter for radix prefix, if present, and radix.
-        let radix = if lit.starts_with("0x") {
-            Radix::Hexadecimal
-        } else if lit.starts_with("0b") {
-            Radix::Binary
-        } else if lit.starts_with("0o") {
-            Radix::Octal
-        } else {
-            Radix::Decimal
-        };
-
-        // Grab part of the literal after prefix, if present.
-        let (prefix, mut sans_prefix) = if let Radix::Decimal = radix {
-            (None, lit)
-        } else {
-            let (p, s) = lit.split_at(2);
-            (Some(p), s)
-        };
-
-        if suffix.is_some() && sans_prefix.ends_with('_') {
-            // The '_' before the suffix isn't part of the digits
-            sans_prefix = &sans_prefix[..sans_prefix.len() - 1];
-        }
-
-        let (integer, fraction, exponent) = Self::split_digit_parts(sans_prefix, float);
-
-        Self {
-            radix,
-            prefix,
-            integer,
-            fraction,
-            exponent,
-            suffix,
-        }
-    }
-
-    pub fn is_decimal(&self) -> bool {
-        self.radix == Radix::Decimal
-    }
-
-    pub fn split_digit_parts(digits: &str, float: bool) -> (&str, Option<&str>, Option<(&str, &str)>) {
-        let mut integer = digits;
-        let mut fraction = None;
-        let mut exponent = None;
-
-        if float {
-            for (i, c) in digits.char_indices() {
-                match c {
-                    '.' => {
-                        integer = &digits[..i];
-                        fraction = Some(&digits[i + 1..]);
-                    },
-                    'e' | 'E' => {
-                        let exp_start = if digits[..i].ends_with('_') { i - 1 } else { i };
-
-                        if integer.len() > exp_start {
-                            integer = &digits[..exp_start];
-                        } else {
-                            fraction = Some(&digits[integer.len() + 1..exp_start]);
-                        };
-                        exponent = Some((&digits[exp_start..=i], &digits[i + 1..]));
-                        break;
-                    },
-                    _ => {},
-                }
-            }
-        }
-
-        (integer, fraction, exponent)
-    }
-
-    /// Returns literal formatted in a sensible way.
-    pub fn format(&self) -> String {
-        let mut output = String::new();
-
-        if let Some(prefix) = self.prefix {
-            output.push_str(prefix);
-        }
-
-        let group_size = self.radix.suggest_grouping();
-
-        Self::group_digits(
-            &mut output,
-            self.integer,
-            group_size,
-            true,
-            self.radix == Radix::Hexadecimal,
-        );
-
-        if let Some(fraction) = self.fraction {
-            output.push('.');
-            Self::group_digits(&mut output, fraction, group_size, false, false);
-        }
-
-        if let Some((separator, exponent)) = self.exponent {
-            output.push_str(separator);
-            Self::group_digits(&mut output, exponent, group_size, true, false);
-        }
-
-        if let Some(suffix) = self.suffix {
-            output.push('_');
-            output.push_str(suffix);
-        }
-
-        output
-    }
-
-    pub fn group_digits(output: &mut String, input: &str, group_size: usize, partial_group_first: bool, pad: bool) {
-        debug_assert!(group_size > 0);
-
-        let mut digits = input.chars().filter(|&c| c != '_');
-
-        let first_group_size;
-
-        if partial_group_first {
-            first_group_size = (digits.clone().count() - 1) % group_size + 1;
-            if pad {
-                for _ in 0..group_size - first_group_size {
-                    output.push('0');
-                }
-            }
-        } else {
-            first_group_size = group_size;
-        }
-
-        for _ in 0..first_group_size {
-            if let Some(digit) = digits.next() {
-                output.push(digit);
-            }
-        }
-
-        for (c, i) in digits.zip((0..group_size).cycle()) {
-            if i == 0 {
-                output.push('_');
-            }
-            output.push(c);
-        }
-    }
-}
-
-fn split_suffix<'a>(src: &'a str, lit_kind: &LitKind) -> (&'a str, Option<&'a str>) {
-    debug_assert!(lit_kind.is_numeric());
-    lit_suffix_length(lit_kind).map_or((src, None), |suffix_length| {
-        let (unsuffixed, suffix) = src.split_at(src.len() - suffix_length);
-        (unsuffixed, Some(suffix))
-    })
-}
-
-fn lit_suffix_length(lit_kind: &LitKind) -> Option<usize> {
-    debug_assert!(lit_kind.is_numeric());
-    let suffix = match lit_kind {
-        LitKind::Int(_, int_lit_kind) => match int_lit_kind {
-            LitIntType::Signed(int_ty) => Some(int_ty.name_str()),
-            LitIntType::Unsigned(uint_ty) => Some(uint_ty.name_str()),
-            LitIntType::Unsuffixed => None,
-        },
-        LitKind::Float(_, float_lit_kind) => match float_lit_kind {
-            LitFloatType::Suffixed(float_ty) => Some(float_ty.name_str()),
-            LitFloatType::Unsuffixed => None,
-        },
-        _ => None,
-    };
-
-    suffix.map(str::len)
-}
diff --git a/clippy_lints/src/utils/paths.rs b/clippy_lints/src/utils/paths.rs
deleted file mode 100644
index 432cc5b59f6..00000000000
--- a/clippy_lints/src/utils/paths.rs
+++ /dev/null
@@ -1,181 +0,0 @@
-//! This module contains paths to types and functions Clippy needs to know
-//! about.
-//!
-//! Whenever possible, please consider diagnostic items over hardcoded paths.
-//! See <https://github.com/rust-lang/rust-clippy/issues/5393> for more information.
-
-pub const ANY_TRAIT: [&str; 3] = ["std", "any", "Any"];
-pub const ARC_PTR_EQ: [&str; 4] = ["alloc", "sync", "Arc", "ptr_eq"];
-pub const ASMUT_TRAIT: [&str; 3] = ["core", "convert", "AsMut"];
-pub const ASREF_TRAIT: [&str; 3] = ["core", "convert", "AsRef"];
-pub(super) const BEGIN_PANIC: [&str; 3] = ["std", "panicking", "begin_panic"];
-pub(super) const BEGIN_PANIC_FMT: [&str; 3] = ["std", "panicking", "begin_panic_fmt"];
-pub const BINARY_HEAP: [&str; 4] = ["alloc", "collections", "binary_heap", "BinaryHeap"];
-pub const BORROW_TRAIT: [&str; 3] = ["core", "borrow", "Borrow"];
-pub const BOX: [&str; 3] = ["alloc", "boxed", "Box"];
-pub const BTREEMAP: [&str; 5] = ["alloc", "collections", "btree", "map", "BTreeMap"];
-pub const BTREEMAP_ENTRY: [&str; 6] = ["alloc", "collections", "btree", "map", "entry", "Entry"];
-pub const BTREESET: [&str; 5] = ["alloc", "collections", "btree", "set", "BTreeSet"];
-pub const CLONE_TRAIT: [&str; 3] = ["core", "clone", "Clone"];
-pub const CLONE_TRAIT_METHOD: [&str; 4] = ["core", "clone", "Clone", "clone"];
-pub const CMP_MAX: [&str; 3] = ["core", "cmp", "max"];
-pub const CMP_MIN: [&str; 3] = ["core", "cmp", "min"];
-pub const COPY: [&str; 3] = ["core", "intrinsics", "copy_nonoverlapping"];
-pub const COPY_NONOVERLAPPING: [&str; 3] = ["core", "intrinsics", "copy"];
-pub const COW: [&str; 3] = ["alloc", "borrow", "Cow"];
-pub const CSTRING_AS_C_STR: [&str; 5] = ["std", "ffi", "c_str", "CString", "as_c_str"];
-pub const DEFAULT_TRAIT: [&str; 3] = ["core", "default", "Default"];
-pub const DEFAULT_TRAIT_METHOD: [&str; 4] = ["core", "default", "Default", "default"];
-pub const DEREF_MUT_TRAIT_METHOD: [&str; 5] = ["core", "ops", "deref", "DerefMut", "deref_mut"];
-pub const DEREF_TRAIT_METHOD: [&str; 5] = ["core", "ops", "deref", "Deref", "deref"];
-pub const DISPLAY_FMT_METHOD: [&str; 4] = ["core", "fmt", "Display", "fmt"];
-pub const DISPLAY_TRAIT: [&str; 3] = ["core", "fmt", "Display"];
-pub const DOUBLE_ENDED_ITERATOR: [&str; 4] = ["core", "iter", "traits", "DoubleEndedIterator"];
-pub const DROP: [&str; 3] = ["core", "mem", "drop"];
-pub const DURATION: [&str; 3] = ["core", "time", "Duration"];
-#[cfg(feature = "internal-lints")]
-pub const EARLY_CONTEXT: [&str; 2] = ["rustc_lint", "EarlyContext"];
-pub const EXIT: [&str; 3] = ["std", "process", "exit"];
-pub const F32_EPSILON: [&str; 4] = ["core", "f32", "<impl f32>", "EPSILON"];
-pub const F64_EPSILON: [&str; 4] = ["core", "f64", "<impl f64>", "EPSILON"];
-pub const FILE: [&str; 3] = ["std", "fs", "File"];
-pub const FILE_TYPE: [&str; 3] = ["std", "fs", "FileType"];
-pub const FMT_ARGUMENTS_NEW_V1: [&str; 4] = ["core", "fmt", "Arguments", "new_v1"];
-pub const FMT_ARGUMENTS_NEW_V1_FORMATTED: [&str; 4] = ["core", "fmt", "Arguments", "new_v1_formatted"];
-pub const FMT_ARGUMENTV1_NEW: [&str; 4] = ["core", "fmt", "ArgumentV1", "new"];
-pub const FN: [&str; 3] = ["core", "ops", "Fn"];
-pub const FN_MUT: [&str; 3] = ["core", "ops", "FnMut"];
-pub const FN_ONCE: [&str; 3] = ["core", "ops", "FnOnce"];
-pub const FROM_FROM: [&str; 4] = ["core", "convert", "From", "from"];
-pub const FROM_ITERATOR: [&str; 5] = ["core", "iter", "traits", "collect", "FromIterator"];
-pub const FUTURE_FROM_GENERATOR: [&str; 3] = ["core", "future", "from_generator"];
-pub const HASH: [&str; 3] = ["core", "hash", "Hash"];
-pub const HASHMAP: [&str; 5] = ["std", "collections", "hash", "map", "HashMap"];
-pub const HASHMAP_ENTRY: [&str; 5] = ["std", "collections", "hash", "map", "Entry"];
-pub const HASHSET: [&str; 5] = ["std", "collections", "hash", "set", "HashSet"];
-#[cfg(feature = "internal-lints")]
-pub const IDENT: [&str; 3] = ["rustc_span", "symbol", "Ident"];
-#[cfg(feature = "internal-lints")]
-pub const IDENT_AS_STR: [&str; 4] = ["rustc_span", "symbol", "Ident", "as_str"];
-pub const INDEX: [&str; 3] = ["core", "ops", "Index"];
-pub const INDEX_MUT: [&str; 3] = ["core", "ops", "IndexMut"];
-pub const INSERT_STR: [&str; 4] = ["alloc", "string", "String", "insert_str"];
-pub const INTO: [&str; 3] = ["core", "convert", "Into"];
-pub const INTO_ITERATOR: [&str; 5] = ["core", "iter", "traits", "collect", "IntoIterator"];
-pub const IO_READ: [&str; 3] = ["std", "io", "Read"];
-pub const IO_WRITE: [&str; 3] = ["std", "io", "Write"];
-pub const IPADDR_V4: [&str; 4] = ["std", "net", "IpAddr", "V4"];
-pub const IPADDR_V6: [&str; 4] = ["std", "net", "IpAddr", "V6"];
-pub const ITERATOR: [&str; 5] = ["core", "iter", "traits", "iterator", "Iterator"];
-#[cfg(feature = "internal-lints")]
-pub const KW_MODULE: [&str; 3] = ["rustc_span", "symbol", "kw"];
-#[cfg(feature = "internal-lints")]
-pub const LATE_CONTEXT: [&str; 2] = ["rustc_lint", "LateContext"];
-pub const LINKED_LIST: [&str; 4] = ["alloc", "collections", "linked_list", "LinkedList"];
-#[cfg(feature = "internal-lints")]
-pub const LINT: [&str; 2] = ["rustc_lint_defs", "Lint"];
-pub const MEM_DISCRIMINANT: [&str; 3] = ["core", "mem", "discriminant"];
-pub const MEM_FORGET: [&str; 3] = ["core", "mem", "forget"];
-pub const MEM_MANUALLY_DROP: [&str; 4] = ["core", "mem", "manually_drop", "ManuallyDrop"];
-pub const MEM_MAYBEUNINIT: [&str; 4] = ["core", "mem", "maybe_uninit", "MaybeUninit"];
-pub const MEM_MAYBEUNINIT_UNINIT: [&str; 5] = ["core", "mem", "maybe_uninit", "MaybeUninit", "uninit"];
-pub const MEM_REPLACE: [&str; 3] = ["core", "mem", "replace"];
-pub const MEM_SIZE_OF: [&str; 3] = ["core", "mem", "size_of"];
-pub const MEM_SIZE_OF_VAL: [&str; 3] = ["core", "mem", "size_of_val"];
-pub const MUTEX_GUARD: [&str; 4] = ["std", "sync", "mutex", "MutexGuard"];
-pub const OPEN_OPTIONS: [&str; 3] = ["std", "fs", "OpenOptions"];
-pub const OPS_MODULE: [&str; 2] = ["core", "ops"];
-pub const OPTION: [&str; 3] = ["core", "option", "Option"];
-pub const OPTION_NONE: [&str; 4] = ["core", "option", "Option", "None"];
-pub const OPTION_SOME: [&str; 4] = ["core", "option", "Option", "Some"];
-pub const ORD: [&str; 3] = ["core", "cmp", "Ord"];
-pub const OS_STRING: [&str; 4] = ["std", "ffi", "os_str", "OsString"];
-pub const OS_STRING_AS_OS_STR: [&str; 5] = ["std", "ffi", "os_str", "OsString", "as_os_str"];
-pub const OS_STR_TO_OS_STRING: [&str; 5] = ["std", "ffi", "os_str", "OsStr", "to_os_string"];
-pub(super) const PANICKING_PANIC: [&str; 3] = ["core", "panicking", "panic"];
-pub(super) const PANICKING_PANIC_FMT: [&str; 3] = ["core", "panicking", "panic_fmt"];
-pub(super) const PANICKING_PANIC_STR: [&str; 3] = ["core", "panicking", "panic_str"];
-pub(super) const PANIC_ANY: [&str; 3] = ["std", "panic", "panic_any"];
-pub const PARKING_LOT_MUTEX_GUARD: [&str; 2] = ["parking_lot", "MutexGuard"];
-pub const PARKING_LOT_RWLOCK_READ_GUARD: [&str; 2] = ["parking_lot", "RwLockReadGuard"];
-pub const PARKING_LOT_RWLOCK_WRITE_GUARD: [&str; 2] = ["parking_lot", "RwLockWriteGuard"];
-pub const PATH: [&str; 3] = ["std", "path", "Path"];
-pub const PATH_BUF: [&str; 3] = ["std", "path", "PathBuf"];
-pub const PATH_BUF_AS_PATH: [&str; 4] = ["std", "path", "PathBuf", "as_path"];
-pub const PATH_TO_PATH_BUF: [&str; 4] = ["std", "path", "Path", "to_path_buf"];
-pub const POLL: [&str; 4] = ["core", "task", "poll", "Poll"];
-pub const POLL_PENDING: [&str; 5] = ["core", "task", "poll", "Poll", "Pending"];
-pub const POLL_READY: [&str; 5] = ["core", "task", "poll", "Poll", "Ready"];
-pub const PTR_EQ: [&str; 3] = ["core", "ptr", "eq"];
-pub const PTR_NULL: [&str; 3] = ["core", "ptr", "null"];
-pub const PTR_NULL_MUT: [&str; 3] = ["core", "ptr", "null_mut"];
-pub const PTR_SLICE_FROM_RAW_PARTS: [&str; 3] = ["core", "ptr", "slice_from_raw_parts"];
-pub const PTR_SLICE_FROM_RAW_PARTS_MUT: [&str; 3] = ["core", "ptr", "slice_from_raw_parts_mut"];
-pub const PTR_SWAP_NONOVERLAPPING: [&str; 3] = ["core", "ptr", "swap_nonoverlapping"];
-pub const PUSH_STR: [&str; 4] = ["alloc", "string", "String", "push_str"];
-pub const RANGE_ARGUMENT_TRAIT: [&str; 3] = ["core", "ops", "RangeBounds"];
-pub const RC: [&str; 3] = ["alloc", "rc", "Rc"];
-pub const RC_PTR_EQ: [&str; 4] = ["alloc", "rc", "Rc", "ptr_eq"];
-pub const RECEIVER: [&str; 4] = ["std", "sync", "mpsc", "Receiver"];
-pub const REFCELL_REF: [&str; 3] = ["core", "cell", "Ref"];
-pub const REFCELL_REFMUT: [&str; 3] = ["core", "cell", "RefMut"];
-pub const REGEX_BUILDER_NEW: [&str; 5] = ["regex", "re_builder", "unicode", "RegexBuilder", "new"];
-pub const REGEX_BYTES_BUILDER_NEW: [&str; 5] = ["regex", "re_builder", "bytes", "RegexBuilder", "new"];
-pub const REGEX_BYTES_NEW: [&str; 4] = ["regex", "re_bytes", "Regex", "new"];
-pub const REGEX_BYTES_SET_NEW: [&str; 5] = ["regex", "re_set", "bytes", "RegexSet", "new"];
-pub const REGEX_NEW: [&str; 4] = ["regex", "re_unicode", "Regex", "new"];
-pub const REGEX_SET_NEW: [&str; 5] = ["regex", "re_set", "unicode", "RegexSet", "new"];
-pub const REPEAT: [&str; 3] = ["core", "iter", "repeat"];
-pub const RESULT: [&str; 3] = ["core", "result", "Result"];
-pub const RESULT_ERR: [&str; 4] = ["core", "result", "Result", "Err"];
-pub const RESULT_OK: [&str; 4] = ["core", "result", "Result", "Ok"];
-pub const RWLOCK_READ_GUARD: [&str; 4] = ["std", "sync", "rwlock", "RwLockReadGuard"];
-pub const RWLOCK_WRITE_GUARD: [&str; 4] = ["std", "sync", "rwlock", "RwLockWriteGuard"];
-pub const SERDE_DESERIALIZE: [&str; 3] = ["serde", "de", "Deserialize"];
-pub const SERDE_DE_VISITOR: [&str; 3] = ["serde", "de", "Visitor"];
-pub const SLICE_FROM_RAW_PARTS: [&str; 4] = ["core", "slice", "raw", "from_raw_parts"];
-pub const SLICE_FROM_RAW_PARTS_MUT: [&str; 4] = ["core", "slice", "raw", "from_raw_parts_mut"];
-pub const SLICE_INTO_VEC: [&str; 4] = ["alloc", "slice", "<impl [T]>", "into_vec"];
-pub const SLICE_ITER: [&str; 4] = ["core", "slice", "iter", "Iter"];
-pub const STDERR: [&str; 4] = ["std", "io", "stdio", "stderr"];
-pub const STDOUT: [&str; 4] = ["std", "io", "stdio", "stdout"];
-pub const STD_CONVERT_IDENTITY: [&str; 3] = ["std", "convert", "identity"];
-pub const STD_FS_CREATE_DIR: [&str; 3] = ["std", "fs", "create_dir"];
-pub const STD_MEM_TRANSMUTE: [&str; 3] = ["std", "mem", "transmute"];
-pub const STD_PTR_NULL: [&str; 3] = ["std", "ptr", "null"];
-pub const STRING: [&str; 3] = ["alloc", "string", "String"];
-pub const STRING_AS_MUT_STR: [&str; 4] = ["alloc", "string", "String", "as_mut_str"];
-pub const STRING_AS_STR: [&str; 4] = ["alloc", "string", "String", "as_str"];
-pub const STR_ENDS_WITH: [&str; 4] = ["core", "str", "<impl str>", "ends_with"];
-pub const STR_FROM_UTF8: [&str; 4] = ["core", "str", "converts", "from_utf8"];
-pub const STR_LEN: [&str; 4] = ["core", "str", "<impl str>", "len"];
-pub const STR_STARTS_WITH: [&str; 4] = ["core", "str", "<impl str>", "starts_with"];
-#[cfg(feature = "internal-lints")]
-pub const SYMBOL: [&str; 3] = ["rustc_span", "symbol", "Symbol"];
-#[cfg(feature = "internal-lints")]
-pub const SYMBOL_AS_STR: [&str; 4] = ["rustc_span", "symbol", "Symbol", "as_str"];
-#[cfg(feature = "internal-lints")]
-pub const SYMBOL_INTERN: [&str; 4] = ["rustc_span", "symbol", "Symbol", "intern"];
-#[cfg(feature = "internal-lints")]
-pub const SYMBOL_TO_IDENT_STRING: [&str; 4] = ["rustc_span", "symbol", "Symbol", "to_ident_string"];
-#[cfg(feature = "internal-lints")]
-pub const SYM_MODULE: [&str; 3] = ["rustc_span", "symbol", "sym"];
-#[cfg(feature = "internal-lints")]
-pub const SYNTAX_CONTEXT: [&str; 3] = ["rustc_span", "hygiene", "SyntaxContext"];
-pub const TO_OWNED: [&str; 3] = ["alloc", "borrow", "ToOwned"];
-pub const TO_OWNED_METHOD: [&str; 4] = ["alloc", "borrow", "ToOwned", "to_owned"];
-pub const TO_STRING: [&str; 3] = ["alloc", "string", "ToString"];
-pub const TO_STRING_METHOD: [&str; 4] = ["alloc", "string", "ToString", "to_string"];
-pub const TRANSMUTE: [&str; 4] = ["core", "intrinsics", "", "transmute"];
-pub const TRY_FROM: [&str; 4] = ["core", "convert", "TryFrom", "try_from"];
-pub const TRY_INTO_TRAIT: [&str; 3] = ["core", "convert", "TryInto"];
-pub const VEC: [&str; 3] = ["alloc", "vec", "Vec"];
-pub const VEC_AS_MUT_SLICE: [&str; 4] = ["alloc", "vec", "Vec", "as_mut_slice"];
-pub const VEC_AS_SLICE: [&str; 4] = ["alloc", "vec", "Vec", "as_slice"];
-pub const VEC_DEQUE: [&str; 4] = ["alloc", "collections", "vec_deque", "VecDeque"];
-pub const VEC_FROM_ELEM: [&str; 3] = ["alloc", "vec", "from_elem"];
-pub const VEC_NEW: [&str; 4] = ["alloc", "vec", "Vec", "new"];
-pub const VEC_RESIZE: [&str; 4] = ["alloc", "vec", "Vec", "resize"];
-pub const WEAK_ARC: [&str; 3] = ["alloc", "sync", "Weak"];
-pub const WEAK_RC: [&str; 3] = ["alloc", "rc", "Weak"];
-pub const WRITE_BYTES: [&str; 3] = ["core", "intrinsics", "write_bytes"];
diff --git a/clippy_lints/src/utils/ptr.rs b/clippy_lints/src/utils/ptr.rs
deleted file mode 100644
index b330f3d890e..00000000000
--- a/clippy_lints/src/utils/ptr.rs
+++ /dev/null
@@ -1,86 +0,0 @@
-use crate::utils::{get_pat_name, match_var, snippet};
-use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
-use rustc_hir::{Body, BodyId, Expr, ExprKind, Param};
-use rustc_lint::LateContext;
-use rustc_middle::hir::map::Map;
-use rustc_span::{Span, Symbol};
-use std::borrow::Cow;
-
-pub fn get_spans(
-    cx: &LateContext<'_>,
-    opt_body_id: Option<BodyId>,
-    idx: usize,
-    replacements: &[(&'static str, &'static str)],
-) -> Option<Vec<(Span, Cow<'static, str>)>> {
-    if let Some(body) = opt_body_id.map(|id| cx.tcx.hir().body(id)) {
-        get_binding_name(&body.params[idx]).map_or_else(
-            || Some(vec![]),
-            |name| extract_clone_suggestions(cx, name, replacements, body),
-        )
-    } else {
-        Some(vec![])
-    }
-}
-
-fn extract_clone_suggestions<'tcx>(
-    cx: &LateContext<'tcx>,
-    name: Symbol,
-    replace: &[(&'static str, &'static str)],
-    body: &'tcx Body<'_>,
-) -> Option<Vec<(Span, Cow<'static, str>)>> {
-    let mut visitor = PtrCloneVisitor {
-        cx,
-        name,
-        replace,
-        spans: vec![],
-        abort: false,
-    };
-    visitor.visit_body(body);
-    if visitor.abort {
-        None
-    } else {
-        Some(visitor.spans)
-    }
-}
-
-struct PtrCloneVisitor<'a, 'tcx> {
-    cx: &'a LateContext<'tcx>,
-    name: Symbol,
-    replace: &'a [(&'static str, &'static str)],
-    spans: Vec<(Span, Cow<'static, str>)>,
-    abort: bool,
-}
-
-impl<'a, 'tcx> Visitor<'tcx> for PtrCloneVisitor<'a, 'tcx> {
-    type Map = Map<'tcx>;
-
-    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
-        if self.abort {
-            return;
-        }
-        if let ExprKind::MethodCall(ref seg, _, ref args, _) = expr.kind {
-            if args.len() == 1 && match_var(&args[0], self.name) {
-                if seg.ident.name.as_str() == "capacity" {
-                    self.abort = true;
-                    return;
-                }
-                for &(fn_name, suffix) in self.replace {
-                    if seg.ident.name.as_str() == fn_name {
-                        self.spans
-                            .push((expr.span, snippet(self.cx, args[0].span, "_") + suffix));
-                        return;
-                    }
-                }
-            }
-        }
-        walk_expr(self, expr);
-    }
-
-    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-        NestedVisitorMap::None
-    }
-}
-
-fn get_binding_name(arg: &Param<'_>) -> Option<Symbol> {
-    get_pat_name(&arg.pat)
-}
diff --git a/clippy_lints/src/utils/qualify_min_const_fn.rs b/clippy_lints/src/utils/qualify_min_const_fn.rs
deleted file mode 100644
index a482017afeb..00000000000
--- a/clippy_lints/src/utils/qualify_min_const_fn.rs
+++ /dev/null
@@ -1,347 +0,0 @@
-use rustc_hir as hir;
-use rustc_hir::def_id::DefId;
-use rustc_middle::mir::{
-    Body, CastKind, NullOp, Operand, Place, ProjectionElem, Rvalue, Statement, StatementKind, Terminator,
-    TerminatorKind,
-};
-use rustc_middle::ty::subst::GenericArgKind;
-use rustc_middle::ty::{self, adjustment::PointerCast, Ty, TyCtxt};
-use rustc_span::symbol::sym;
-use rustc_span::Span;
-use rustc_target::spec::abi::Abi::RustIntrinsic;
-use std::borrow::Cow;
-
-type McfResult = Result<(), (Span, Cow<'static, str>)>;
-
-pub fn is_min_const_fn(tcx: TyCtxt<'tcx>, body: &'a Body<'tcx>) -> McfResult {
-    let def_id = body.source.def_id();
-    let mut current = def_id;
-    loop {
-        let predicates = tcx.predicates_of(current);
-        for (predicate, _) in predicates.predicates {
-            match predicate.kind().skip_binder() {
-                ty::PredicateKind::RegionOutlives(_)
-                | ty::PredicateKind::TypeOutlives(_)
-                | ty::PredicateKind::WellFormed(_)
-                | ty::PredicateKind::Projection(_)
-                | ty::PredicateKind::ConstEvaluatable(..)
-                | ty::PredicateKind::ConstEquate(..)
-                | ty::PredicateKind::TypeWellFormedFromEnv(..) => continue,
-                ty::PredicateKind::ObjectSafe(_) => panic!("object safe predicate on function: {:#?}", predicate),
-                ty::PredicateKind::ClosureKind(..) => panic!("closure kind predicate on function: {:#?}", predicate),
-                ty::PredicateKind::Subtype(_) => panic!("subtype predicate on function: {:#?}", predicate),
-                ty::PredicateKind::Trait(pred, _) => {
-                    if Some(pred.def_id()) == tcx.lang_items().sized_trait() {
-                        continue;
-                    }
-                    match pred.self_ty().kind() {
-                        ty::Param(ref p) => {
-                            let generics = tcx.generics_of(current);
-                            let def = generics.type_param(p, tcx);
-                            let span = tcx.def_span(def.def_id);
-                            return Err((
-                                span,
-                                "trait bounds other than `Sized` \
-                                 on const fn parameters are unstable"
-                                    .into(),
-                            ));
-                        },
-                        // other kinds of bounds are either tautologies
-                        // or cause errors in other passes
-                        _ => continue,
-                    }
-                },
-            }
-        }
-        match predicates.parent {
-            Some(parent) => current = parent,
-            None => break,
-        }
-    }
-
-    for local in &body.local_decls {
-        check_ty(tcx, local.ty, local.source_info.span)?;
-    }
-    // impl trait is gone in MIR, so check the return type manually
-    check_ty(
-        tcx,
-        tcx.fn_sig(def_id).output().skip_binder(),
-        body.local_decls.iter().next().unwrap().source_info.span,
-    )?;
-
-    for bb in body.basic_blocks() {
-        check_terminator(tcx, body, bb.terminator())?;
-        for stmt in &bb.statements {
-            check_statement(tcx, body, def_id, stmt)?;
-        }
-    }
-    Ok(())
-}
-
-fn check_ty(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>, span: Span) -> McfResult {
-    for arg in ty.walk() {
-        let ty = match arg.unpack() {
-            GenericArgKind::Type(ty) => ty,
-
-            // No constraints on lifetimes or constants, except potentially
-            // constants' types, but `walk` will get to them as well.
-            GenericArgKind::Lifetime(_) | GenericArgKind::Const(_) => continue,
-        };
-
-        match ty.kind() {
-            ty::Ref(_, _, hir::Mutability::Mut) => {
-                return Err((span, "mutable references in const fn are unstable".into()));
-            },
-            ty::Opaque(..) => return Err((span, "`impl Trait` in const fn is unstable".into())),
-            ty::FnPtr(..) => {
-                return Err((span, "function pointers in const fn are unstable".into()));
-            },
-            ty::Dynamic(preds, _) => {
-                for pred in preds.iter() {
-                    match pred.skip_binder() {
-                        ty::ExistentialPredicate::AutoTrait(_) | ty::ExistentialPredicate::Projection(_) => {
-                            return Err((
-                                span,
-                                "trait bounds other than `Sized` \
-                                 on const fn parameters are unstable"
-                                    .into(),
-                            ));
-                        },
-                        ty::ExistentialPredicate::Trait(trait_ref) => {
-                            if Some(trait_ref.def_id) != tcx.lang_items().sized_trait() {
-                                return Err((
-                                    span,
-                                    "trait bounds other than `Sized` \
-                                     on const fn parameters are unstable"
-                                        .into(),
-                                ));
-                            }
-                        },
-                    }
-                }
-            },
-            _ => {},
-        }
-    }
-    Ok(())
-}
-
-fn check_rvalue(tcx: TyCtxt<'tcx>, body: &Body<'tcx>, def_id: DefId, rvalue: &Rvalue<'tcx>, span: Span) -> McfResult {
-    match rvalue {
-        Rvalue::ThreadLocalRef(_) => Err((span, "cannot access thread local storage in const fn".into())),
-        Rvalue::Repeat(operand, _) | Rvalue::Use(operand) => check_operand(tcx, operand, span, body),
-        Rvalue::Len(place) | Rvalue::Discriminant(place) | Rvalue::Ref(_, _, place) | Rvalue::AddressOf(_, place) => {
-            check_place(tcx, *place, span, body)
-        },
-        Rvalue::Cast(CastKind::Misc, operand, cast_ty) => {
-            use rustc_middle::ty::cast::CastTy;
-            let cast_in = CastTy::from_ty(operand.ty(body, tcx)).expect("bad input type for cast");
-            let cast_out = CastTy::from_ty(cast_ty).expect("bad output type for cast");
-            match (cast_in, cast_out) {
-                (CastTy::Ptr(_) | CastTy::FnPtr, CastTy::Int(_)) => {
-                    Err((span, "casting pointers to ints is unstable in const fn".into()))
-                },
-                _ => check_operand(tcx, operand, span, body),
-            }
-        },
-        Rvalue::Cast(CastKind::Pointer(PointerCast::MutToConstPointer | PointerCast::ArrayToPointer), operand, _) => {
-            check_operand(tcx, operand, span, body)
-        },
-        Rvalue::Cast(
-            CastKind::Pointer(
-                PointerCast::UnsafeFnPointer | PointerCast::ClosureFnPointer(_) | PointerCast::ReifyFnPointer,
-            ),
-            _,
-            _,
-        ) => Err((span, "function pointer casts are not allowed in const fn".into())),
-        Rvalue::Cast(CastKind::Pointer(PointerCast::Unsize), op, cast_ty) => {
-            let pointee_ty = if let Some(deref_ty) = cast_ty.builtin_deref(true) {
-                deref_ty.ty
-            } else {
-                // We cannot allow this for now.
-                return Err((span, "unsizing casts are only allowed for references right now".into()));
-            };
-            let unsized_ty = tcx.struct_tail_erasing_lifetimes(pointee_ty, tcx.param_env(def_id));
-            if let ty::Slice(_) | ty::Str = unsized_ty.kind() {
-                check_operand(tcx, op, span, body)?;
-                // Casting/coercing things to slices is fine.
-                Ok(())
-            } else {
-                // We just can't allow trait objects until we have figured out trait method calls.
-                Err((span, "unsizing casts are not allowed in const fn".into()))
-            }
-        },
-        // binops are fine on integers
-        Rvalue::BinaryOp(_, lhs, rhs) | Rvalue::CheckedBinaryOp(_, lhs, rhs) => {
-            check_operand(tcx, lhs, span, body)?;
-            check_operand(tcx, rhs, span, body)?;
-            let ty = lhs.ty(body, tcx);
-            if ty.is_integral() || ty.is_bool() || ty.is_char() {
-                Ok(())
-            } else {
-                Err((
-                    span,
-                    "only int, `bool` and `char` operations are stable in const fn".into(),
-                ))
-            }
-        },
-        Rvalue::NullaryOp(NullOp::SizeOf, _) => Ok(()),
-        Rvalue::NullaryOp(NullOp::Box, _) => Err((span, "heap allocations are not allowed in const fn".into())),
-        Rvalue::UnaryOp(_, operand) => {
-            let ty = operand.ty(body, tcx);
-            if ty.is_integral() || ty.is_bool() {
-                check_operand(tcx, operand, span, body)
-            } else {
-                Err((span, "only int and `bool` operations are stable in const fn".into()))
-            }
-        },
-        Rvalue::Aggregate(_, operands) => {
-            for operand in operands {
-                check_operand(tcx, operand, span, body)?;
-            }
-            Ok(())
-        },
-    }
-}
-
-fn check_statement(tcx: TyCtxt<'tcx>, body: &Body<'tcx>, def_id: DefId, statement: &Statement<'tcx>) -> McfResult {
-    let span = statement.source_info.span;
-    match &statement.kind {
-        StatementKind::Assign(box (place, rval)) => {
-            check_place(tcx, *place, span, body)?;
-            check_rvalue(tcx, body, def_id, rval, span)
-        },
-
-        StatementKind::FakeRead(_, place) |
-        // just an assignment
-        StatementKind::SetDiscriminant { place, .. } => check_place(tcx, **place, span, body),
-
-        StatementKind::LlvmInlineAsm { .. } => Err((span, "cannot use inline assembly in const fn".into())),
-
-        // These are all NOPs
-        StatementKind::StorageLive(_)
-        | StatementKind::StorageDead(_)
-        | StatementKind::Retag { .. }
-        | StatementKind::AscribeUserType(..)
-        | StatementKind::Coverage(..)
-        | StatementKind::Nop => Ok(()),
-    }
-}
-
-fn check_operand(tcx: TyCtxt<'tcx>, operand: &Operand<'tcx>, span: Span, body: &Body<'tcx>) -> McfResult {
-    match operand {
-        Operand::Move(place) | Operand::Copy(place) => check_place(tcx, *place, span, body),
-        Operand::Constant(c) => match c.check_static_ptr(tcx) {
-            Some(_) => Err((span, "cannot access `static` items in const fn".into())),
-            None => Ok(()),
-        },
-    }
-}
-
-fn check_place(tcx: TyCtxt<'tcx>, place: Place<'tcx>, span: Span, body: &Body<'tcx>) -> McfResult {
-    let mut cursor = place.projection.as_ref();
-    while let [ref proj_base @ .., elem] = *cursor {
-        cursor = proj_base;
-        match elem {
-            ProjectionElem::Field(..) => {
-                let base_ty = Place::ty_from(place.local, &proj_base, body, tcx).ty;
-                if let Some(def) = base_ty.ty_adt_def() {
-                    // No union field accesses in `const fn`
-                    if def.is_union() {
-                        return Err((span, "accessing union fields is unstable".into()));
-                    }
-                }
-            },
-            ProjectionElem::ConstantIndex { .. }
-            | ProjectionElem::Downcast(..)
-            | ProjectionElem::Subslice { .. }
-            | ProjectionElem::Deref
-            | ProjectionElem::Index(_) => {},
-        }
-    }
-
-    Ok(())
-}
-
-fn check_terminator(tcx: TyCtxt<'tcx>, body: &'a Body<'tcx>, terminator: &Terminator<'tcx>) -> McfResult {
-    let span = terminator.source_info.span;
-    match &terminator.kind {
-        TerminatorKind::FalseEdge { .. }
-        | TerminatorKind::FalseUnwind { .. }
-        | TerminatorKind::Goto { .. }
-        | TerminatorKind::Return
-        | TerminatorKind::Resume
-        | TerminatorKind::Unreachable => Ok(()),
-
-        TerminatorKind::Drop { place, .. } => check_place(tcx, *place, span, body),
-        TerminatorKind::DropAndReplace { place, value, .. } => {
-            check_place(tcx, *place, span, body)?;
-            check_operand(tcx, value, span, body)
-        },
-
-        TerminatorKind::SwitchInt {
-            discr,
-            switch_ty: _,
-            targets: _,
-        } => check_operand(tcx, discr, span, body),
-
-        TerminatorKind::Abort => Err((span, "abort is not stable in const fn".into())),
-        TerminatorKind::GeneratorDrop | TerminatorKind::Yield { .. } => {
-            Err((span, "const fn generators are unstable".into()))
-        },
-
-        TerminatorKind::Call {
-            func,
-            args,
-            from_hir_call: _,
-            destination: _,
-            cleanup: _,
-            fn_span: _,
-        } => {
-            let fn_ty = func.ty(body, tcx);
-            if let ty::FnDef(fn_def_id, _) = *fn_ty.kind() {
-                if !rustc_mir::const_eval::is_min_const_fn(tcx, fn_def_id) {
-                    return Err((
-                        span,
-                        format!(
-                            "can only call other `const fn` within a `const fn`, \
-                             but `{:?}` is not stable as `const fn`",
-                            func,
-                        )
-                        .into(),
-                    ));
-                }
-
-                // HACK: This is to "unstabilize" the `transmute` intrinsic
-                // within const fns. `transmute` is allowed in all other const contexts.
-                // This won't really scale to more intrinsics or functions. Let's allow const
-                // transmutes in const fn before we add more hacks to this.
-                if tcx.fn_sig(fn_def_id).abi() == RustIntrinsic && tcx.item_name(fn_def_id) == sym::transmute {
-                    return Err((
-                        span,
-                        "can only call `transmute` from const items, not `const fn`".into(),
-                    ));
-                }
-
-                check_operand(tcx, func, span, body)?;
-
-                for arg in args {
-                    check_operand(tcx, arg, span, body)?;
-                }
-                Ok(())
-            } else {
-                Err((span, "can only call other const fns within const fn".into()))
-            }
-        },
-
-        TerminatorKind::Assert {
-            cond,
-            expected: _,
-            msg: _,
-            target: _,
-            cleanup: _,
-        } => check_operand(tcx, cond, span, body),
-
-        TerminatorKind::InlineAsm { .. } => Err((span, "cannot use inline assembly in const fn".into())),
-    }
-}
diff --git a/clippy_lints/src/utils/sugg.rs b/clippy_lints/src/utils/sugg.rs
deleted file mode 100644
index 03678db575f..00000000000
--- a/clippy_lints/src/utils/sugg.rs
+++ /dev/null
@@ -1,683 +0,0 @@
-//! Contains utility functions to generate suggestions.
-#![deny(clippy::missing_docs_in_private_items)]
-
-use crate::utils::{higher, snippet, snippet_opt, snippet_with_macro_callsite};
-use rustc_ast::util::parser::AssocOp;
-use rustc_ast::{ast, token};
-use rustc_ast_pretty::pprust::token_kind_to_string;
-use rustc_errors::Applicability;
-use rustc_hir as hir;
-use rustc_lint::{EarlyContext, LateContext, LintContext};
-use rustc_span::source_map::{CharPos, Span};
-use rustc_span::{BytePos, Pos};
-use std::borrow::Cow;
-use std::convert::TryInto;
-use std::fmt::Display;
-use std::ops::{Add, Neg, Not, Sub};
-
-/// A helper type to build suggestion correctly handling parenthesis.
-#[derive(Clone, PartialEq)]
-pub enum Sugg<'a> {
-    /// An expression that never needs parenthesis such as `1337` or `[0; 42]`.
-    NonParen(Cow<'a, str>),
-    /// An expression that does not fit in other variants.
-    MaybeParen(Cow<'a, str>),
-    /// A binary operator expression, including `as`-casts and explicit type
-    /// coercion.
-    BinOp(AssocOp, Cow<'a, str>),
-}
-
-/// Literal constant `0`, for convenience.
-pub const ZERO: Sugg<'static> = Sugg::NonParen(Cow::Borrowed("0"));
-/// Literal constant `1`, for convenience.
-pub const ONE: Sugg<'static> = Sugg::NonParen(Cow::Borrowed("1"));
-/// a constant represents an empty string, for convenience.
-pub const EMPTY: Sugg<'static> = Sugg::NonParen(Cow::Borrowed(""));
-
-impl Display for Sugg<'_> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
-        match *self {
-            Sugg::NonParen(ref s) | Sugg::MaybeParen(ref s) | Sugg::BinOp(_, ref s) => s.fmt(f),
-        }
-    }
-}
-
-#[allow(clippy::wrong_self_convention)] // ok, because of the function `as_ty` method
-impl<'a> Sugg<'a> {
-    /// Prepare a suggestion from an expression.
-    pub fn hir_opt(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> Option<Self> {
-        snippet_opt(cx, expr.span).map(|snippet| {
-            let snippet = Cow::Owned(snippet);
-            Self::hir_from_snippet(expr, snippet)
-        })
-    }
-
-    /// Convenience function around `hir_opt` for suggestions with a default
-    /// text.
-    pub fn hir(cx: &LateContext<'_>, expr: &hir::Expr<'_>, default: &'a str) -> Self {
-        Self::hir_opt(cx, expr).unwrap_or(Sugg::NonParen(Cow::Borrowed(default)))
-    }
-
-    /// Same as `hir`, but it adapts the applicability level by following rules:
-    ///
-    /// - Applicability level `Unspecified` will never be changed.
-    /// - If the span is inside a macro, change the applicability level to `MaybeIncorrect`.
-    /// - If the default value is used and the applicability level is `MachineApplicable`, change it
-    ///   to
-    /// `HasPlaceholders`
-    pub fn hir_with_applicability(
-        cx: &LateContext<'_>,
-        expr: &hir::Expr<'_>,
-        default: &'a str,
-        applicability: &mut Applicability,
-    ) -> Self {
-        if *applicability != Applicability::Unspecified && expr.span.from_expansion() {
-            *applicability = Applicability::MaybeIncorrect;
-        }
-        Self::hir_opt(cx, expr).unwrap_or_else(|| {
-            if *applicability == Applicability::MachineApplicable {
-                *applicability = Applicability::HasPlaceholders;
-            }
-            Sugg::NonParen(Cow::Borrowed(default))
-        })
-    }
-
-    /// Same as `hir`, but will use the pre expansion span if the `expr` was in a macro.
-    pub fn hir_with_macro_callsite(cx: &LateContext<'_>, expr: &hir::Expr<'_>, default: &'a str) -> Self {
-        let snippet = snippet_with_macro_callsite(cx, expr.span, default);
-
-        Self::hir_from_snippet(expr, snippet)
-    }
-
-    /// Generate a suggestion for an expression with the given snippet. This is used by the `hir_*`
-    /// function variants of `Sugg`, since these use different snippet functions.
-    fn hir_from_snippet(expr: &hir::Expr<'_>, snippet: Cow<'a, str>) -> Self {
-        if let Some(range) = higher::range(expr) {
-            let op = match range.limits {
-                ast::RangeLimits::HalfOpen => AssocOp::DotDot,
-                ast::RangeLimits::Closed => AssocOp::DotDotEq,
-            };
-            return Sugg::BinOp(op, snippet);
-        }
-
-        match expr.kind {
-            hir::ExprKind::AddrOf(..)
-            | hir::ExprKind::Box(..)
-            | hir::ExprKind::If(..)
-            | hir::ExprKind::Closure(..)
-            | hir::ExprKind::Unary(..)
-            | hir::ExprKind::Match(..) => Sugg::MaybeParen(snippet),
-            hir::ExprKind::Continue(..)
-            | hir::ExprKind::Yield(..)
-            | hir::ExprKind::Array(..)
-            | hir::ExprKind::Block(..)
-            | hir::ExprKind::Break(..)
-            | hir::ExprKind::Call(..)
-            | hir::ExprKind::Field(..)
-            | hir::ExprKind::Index(..)
-            | hir::ExprKind::InlineAsm(..)
-            | hir::ExprKind::LlvmInlineAsm(..)
-            | hir::ExprKind::ConstBlock(..)
-            | hir::ExprKind::Lit(..)
-            | hir::ExprKind::Loop(..)
-            | hir::ExprKind::MethodCall(..)
-            | hir::ExprKind::Path(..)
-            | hir::ExprKind::Repeat(..)
-            | hir::ExprKind::Ret(..)
-            | hir::ExprKind::Struct(..)
-            | hir::ExprKind::Tup(..)
-            | hir::ExprKind::DropTemps(_)
-            | hir::ExprKind::Err => Sugg::NonParen(snippet),
-            hir::ExprKind::Assign(..) => Sugg::BinOp(AssocOp::Assign, snippet),
-            hir::ExprKind::AssignOp(op, ..) => Sugg::BinOp(hirbinop2assignop(op), snippet),
-            hir::ExprKind::Binary(op, ..) => Sugg::BinOp(AssocOp::from_ast_binop(higher::binop(op.node)), snippet),
-            hir::ExprKind::Cast(..) => Sugg::BinOp(AssocOp::As, snippet),
-            hir::ExprKind::Type(..) => Sugg::BinOp(AssocOp::Colon, snippet),
-        }
-    }
-
-    /// Prepare a suggestion from an expression.
-    pub fn ast(cx: &EarlyContext<'_>, expr: &ast::Expr, default: &'a str) -> Self {
-        use rustc_ast::ast::RangeLimits;
-
-        let snippet = if expr.span.from_expansion() {
-            snippet_with_macro_callsite(cx, expr.span, default)
-        } else {
-            snippet(cx, expr.span, default)
-        };
-
-        match expr.kind {
-            ast::ExprKind::AddrOf(..)
-            | ast::ExprKind::Box(..)
-            | ast::ExprKind::Closure(..)
-            | ast::ExprKind::If(..)
-            | ast::ExprKind::Let(..)
-            | ast::ExprKind::Unary(..)
-            | ast::ExprKind::Match(..) => Sugg::MaybeParen(snippet),
-            ast::ExprKind::Async(..)
-            | ast::ExprKind::Block(..)
-            | ast::ExprKind::Break(..)
-            | ast::ExprKind::Call(..)
-            | ast::ExprKind::Continue(..)
-            | ast::ExprKind::Yield(..)
-            | ast::ExprKind::Field(..)
-            | ast::ExprKind::ForLoop(..)
-            | ast::ExprKind::Index(..)
-            | ast::ExprKind::InlineAsm(..)
-            | ast::ExprKind::LlvmInlineAsm(..)
-            | ast::ExprKind::ConstBlock(..)
-            | ast::ExprKind::Lit(..)
-            | ast::ExprKind::Loop(..)
-            | ast::ExprKind::MacCall(..)
-            | ast::ExprKind::MethodCall(..)
-            | ast::ExprKind::Paren(..)
-            | ast::ExprKind::Underscore
-            | ast::ExprKind::Path(..)
-            | ast::ExprKind::Repeat(..)
-            | ast::ExprKind::Ret(..)
-            | ast::ExprKind::Struct(..)
-            | ast::ExprKind::Try(..)
-            | ast::ExprKind::TryBlock(..)
-            | ast::ExprKind::Tup(..)
-            | ast::ExprKind::Array(..)
-            | ast::ExprKind::While(..)
-            | ast::ExprKind::Await(..)
-            | ast::ExprKind::Err => Sugg::NonParen(snippet),
-            ast::ExprKind::Range(.., RangeLimits::HalfOpen) => Sugg::BinOp(AssocOp::DotDot, snippet),
-            ast::ExprKind::Range(.., RangeLimits::Closed) => Sugg::BinOp(AssocOp::DotDotEq, snippet),
-            ast::ExprKind::Assign(..) => Sugg::BinOp(AssocOp::Assign, snippet),
-            ast::ExprKind::AssignOp(op, ..) => Sugg::BinOp(astbinop2assignop(op), snippet),
-            ast::ExprKind::Binary(op, ..) => Sugg::BinOp(AssocOp::from_ast_binop(op.node), snippet),
-            ast::ExprKind::Cast(..) => Sugg::BinOp(AssocOp::As, snippet),
-            ast::ExprKind::Type(..) => Sugg::BinOp(AssocOp::Colon, snippet),
-        }
-    }
-
-    /// Convenience method to create the `<lhs> && <rhs>` suggestion.
-    pub fn and(self, rhs: &Self) -> Sugg<'static> {
-        make_binop(ast::BinOpKind::And, &self, rhs)
-    }
-
-    /// Convenience method to create the `<lhs> & <rhs>` suggestion.
-    pub fn bit_and(self, rhs: &Self) -> Sugg<'static> {
-        make_binop(ast::BinOpKind::BitAnd, &self, rhs)
-    }
-
-    /// Convenience method to create the `<lhs> as <rhs>` suggestion.
-    pub fn as_ty<R: Display>(self, rhs: R) -> Sugg<'static> {
-        make_assoc(AssocOp::As, &self, &Sugg::NonParen(rhs.to_string().into()))
-    }
-
-    /// Convenience method to create the `&<expr>` suggestion.
-    pub fn addr(self) -> Sugg<'static> {
-        make_unop("&", self)
-    }
-
-    /// Convenience method to create the `&mut <expr>` suggestion.
-    pub fn mut_addr(self) -> Sugg<'static> {
-        make_unop("&mut ", self)
-    }
-
-    /// Convenience method to create the `*<expr>` suggestion.
-    pub fn deref(self) -> Sugg<'static> {
-        make_unop("*", self)
-    }
-
-    /// Convenience method to create the `&*<expr>` suggestion. Currently this
-    /// is needed because `sugg.deref().addr()` produces an unnecessary set of
-    /// parentheses around the deref.
-    pub fn addr_deref(self) -> Sugg<'static> {
-        make_unop("&*", self)
-    }
-
-    /// Convenience method to create the `&mut *<expr>` suggestion. Currently
-    /// this is needed because `sugg.deref().mut_addr()` produces an unnecessary
-    /// set of parentheses around the deref.
-    pub fn mut_addr_deref(self) -> Sugg<'static> {
-        make_unop("&mut *", self)
-    }
-
-    /// Convenience method to transform suggestion into a return call
-    pub fn make_return(self) -> Sugg<'static> {
-        Sugg::NonParen(Cow::Owned(format!("return {}", self)))
-    }
-
-    /// Convenience method to transform suggestion into a block
-    /// where the suggestion is a trailing expression
-    pub fn blockify(self) -> Sugg<'static> {
-        Sugg::NonParen(Cow::Owned(format!("{{ {} }}", self)))
-    }
-
-    /// Convenience method to create the `<lhs>..<rhs>` or `<lhs>...<rhs>`
-    /// suggestion.
-    #[allow(dead_code)]
-    pub fn range(self, end: &Self, limit: ast::RangeLimits) -> Sugg<'static> {
-        match limit {
-            ast::RangeLimits::HalfOpen => make_assoc(AssocOp::DotDot, &self, end),
-            ast::RangeLimits::Closed => make_assoc(AssocOp::DotDotEq, &self, end),
-        }
-    }
-
-    /// Adds parenthesis to any expression that might need them. Suitable to the
-    /// `self` argument of a method call
-    /// (e.g., to build `bar.foo()` or `(1 + 2).foo()`).
-    pub fn maybe_par(self) -> Self {
-        match self {
-            Sugg::NonParen(..) => self,
-            // `(x)` and `(x).y()` both don't need additional parens.
-            Sugg::MaybeParen(sugg) => {
-                if sugg.starts_with('(') && sugg.ends_with(')') {
-                    Sugg::MaybeParen(sugg)
-                } else {
-                    Sugg::NonParen(format!("({})", sugg).into())
-                }
-            },
-            Sugg::BinOp(_, sugg) => Sugg::NonParen(format!("({})", sugg).into()),
-        }
-    }
-}
-
-// Copied from the rust standart library, and then edited
-macro_rules! forward_binop_impls_to_ref {
-    (impl $imp:ident, $method:ident for $t:ty, type Output = $o:ty) => {
-        impl $imp<$t> for &$t {
-            type Output = $o;
-
-            fn $method(self, other: $t) -> $o {
-                $imp::$method(self, &other)
-            }
-        }
-
-        impl $imp<&$t> for $t {
-            type Output = $o;
-
-            fn $method(self, other: &$t) -> $o {
-                $imp::$method(&self, other)
-            }
-        }
-
-        impl $imp for $t {
-            type Output = $o;
-
-            fn $method(self, other: $t) -> $o {
-                $imp::$method(&self, &other)
-            }
-        }
-    };
-}
-
-impl Add for &Sugg<'_> {
-    type Output = Sugg<'static>;
-    fn add(self, rhs: &Sugg<'_>) -> Sugg<'static> {
-        make_binop(ast::BinOpKind::Add, self, rhs)
-    }
-}
-
-impl Sub for &Sugg<'_> {
-    type Output = Sugg<'static>;
-    fn sub(self, rhs: &Sugg<'_>) -> Sugg<'static> {
-        make_binop(ast::BinOpKind::Sub, self, rhs)
-    }
-}
-
-forward_binop_impls_to_ref!(impl Add, add for Sugg<'_>, type Output = Sugg<'static>);
-forward_binop_impls_to_ref!(impl Sub, sub for Sugg<'_>, type Output = Sugg<'static>);
-
-impl Neg for Sugg<'_> {
-    type Output = Sugg<'static>;
-    fn neg(self) -> Sugg<'static> {
-        make_unop("-", self)
-    }
-}
-
-impl Not for Sugg<'_> {
-    type Output = Sugg<'static>;
-    fn not(self) -> Sugg<'static> {
-        make_unop("!", self)
-    }
-}
-
-/// Helper type to display either `foo` or `(foo)`.
-struct ParenHelper<T> {
-    /// `true` if parentheses are needed.
-    paren: bool,
-    /// The main thing to display.
-    wrapped: T,
-}
-
-impl<T> ParenHelper<T> {
-    /// Builds a `ParenHelper`.
-    fn new(paren: bool, wrapped: T) -> Self {
-        Self { paren, wrapped }
-    }
-}
-
-impl<T: Display> Display for ParenHelper<T> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
-        if self.paren {
-            write!(f, "({})", self.wrapped)
-        } else {
-            self.wrapped.fmt(f)
-        }
-    }
-}
-
-/// Builds the string for `<op><expr>` adding parenthesis when necessary.
-///
-/// For convenience, the operator is taken as a string because all unary
-/// operators have the same
-/// precedence.
-pub fn make_unop(op: &str, expr: Sugg<'_>) -> Sugg<'static> {
-    Sugg::MaybeParen(format!("{}{}", op, expr.maybe_par()).into())
-}
-
-/// Builds the string for `<lhs> <op> <rhs>` adding parenthesis when necessary.
-///
-/// Precedence of shift operator relative to other arithmetic operation is
-/// often confusing so
-/// parenthesis will always be added for a mix of these.
-pub fn make_assoc(op: AssocOp, lhs: &Sugg<'_>, rhs: &Sugg<'_>) -> Sugg<'static> {
-    /// Returns `true` if the operator is a shift operator `<<` or `>>`.
-    fn is_shift(op: AssocOp) -> bool {
-        matches!(op, AssocOp::ShiftLeft | AssocOp::ShiftRight)
-    }
-
-    /// Returns `true` if the operator is a arithmetic operator
-    /// (i.e., `+`, `-`, `*`, `/`, `%`).
-    fn is_arith(op: AssocOp) -> bool {
-        matches!(
-            op,
-            AssocOp::Add | AssocOp::Subtract | AssocOp::Multiply | AssocOp::Divide | AssocOp::Modulus
-        )
-    }
-
-    /// Returns `true` if the operator `op` needs parenthesis with the operator
-    /// `other` in the direction `dir`.
-    fn needs_paren(op: AssocOp, other: AssocOp, dir: Associativity) -> bool {
-        other.precedence() < op.precedence()
-            || (other.precedence() == op.precedence()
-                && ((op != other && associativity(op) != dir)
-                    || (op == other && associativity(op) != Associativity::Both)))
-            || is_shift(op) && is_arith(other)
-            || is_shift(other) && is_arith(op)
-    }
-
-    let lhs_paren = if let Sugg::BinOp(lop, _) = *lhs {
-        needs_paren(op, lop, Associativity::Left)
-    } else {
-        false
-    };
-
-    let rhs_paren = if let Sugg::BinOp(rop, _) = *rhs {
-        needs_paren(op, rop, Associativity::Right)
-    } else {
-        false
-    };
-
-    let lhs = ParenHelper::new(lhs_paren, lhs);
-    let rhs = ParenHelper::new(rhs_paren, rhs);
-    let sugg = match op {
-        AssocOp::Add
-        | AssocOp::BitAnd
-        | AssocOp::BitOr
-        | AssocOp::BitXor
-        | AssocOp::Divide
-        | AssocOp::Equal
-        | AssocOp::Greater
-        | AssocOp::GreaterEqual
-        | AssocOp::LAnd
-        | AssocOp::LOr
-        | AssocOp::Less
-        | AssocOp::LessEqual
-        | AssocOp::Modulus
-        | AssocOp::Multiply
-        | AssocOp::NotEqual
-        | AssocOp::ShiftLeft
-        | AssocOp::ShiftRight
-        | AssocOp::Subtract => format!(
-            "{} {} {}",
-            lhs,
-            op.to_ast_binop().expect("Those are AST ops").to_string(),
-            rhs
-        ),
-        AssocOp::Assign => format!("{} = {}", lhs, rhs),
-        AssocOp::AssignOp(op) => format!("{} {}= {}", lhs, token_kind_to_string(&token::BinOp(op)), rhs),
-        AssocOp::As => format!("{} as {}", lhs, rhs),
-        AssocOp::DotDot => format!("{}..{}", lhs, rhs),
-        AssocOp::DotDotEq => format!("{}..={}", lhs, rhs),
-        AssocOp::Colon => format!("{}: {}", lhs, rhs),
-    };
-
-    Sugg::BinOp(op, sugg.into())
-}
-
-/// Convenience wrapper around `make_assoc` and `AssocOp::from_ast_binop`.
-pub fn make_binop(op: ast::BinOpKind, lhs: &Sugg<'_>, rhs: &Sugg<'_>) -> Sugg<'static> {
-    make_assoc(AssocOp::from_ast_binop(op), lhs, rhs)
-}
-
-#[derive(PartialEq, Eq, Clone, Copy)]
-/// Operator associativity.
-enum Associativity {
-    /// The operator is both left-associative and right-associative.
-    Both,
-    /// The operator is left-associative.
-    Left,
-    /// The operator is not associative.
-    None,
-    /// The operator is right-associative.
-    Right,
-}
-
-/// Returns the associativity/fixity of an operator. The difference with
-/// `AssocOp::fixity` is that an operator can be both left and right associative
-/// (such as `+`: `a + b + c == (a + b) + c == a + (b + c)`.
-///
-/// Chained `as` and explicit `:` type coercion never need inner parenthesis so
-/// they are considered
-/// associative.
-#[must_use]
-fn associativity(op: AssocOp) -> Associativity {
-    use rustc_ast::util::parser::AssocOp::{
-        Add, As, Assign, AssignOp, BitAnd, BitOr, BitXor, Colon, Divide, DotDot, DotDotEq, Equal, Greater,
-        GreaterEqual, LAnd, LOr, Less, LessEqual, Modulus, Multiply, NotEqual, ShiftLeft, ShiftRight, Subtract,
-    };
-
-    match op {
-        Assign | AssignOp(_) => Associativity::Right,
-        Add | BitAnd | BitOr | BitXor | LAnd | LOr | Multiply | As | Colon => Associativity::Both,
-        Divide | Equal | Greater | GreaterEqual | Less | LessEqual | Modulus | NotEqual | ShiftLeft | ShiftRight
-        | Subtract => Associativity::Left,
-        DotDot | DotDotEq => Associativity::None,
-    }
-}
-
-/// Converts a `hir::BinOp` to the corresponding assigning binary operator.
-fn hirbinop2assignop(op: hir::BinOp) -> AssocOp {
-    use rustc_ast::token::BinOpToken::{And, Caret, Minus, Or, Percent, Plus, Shl, Shr, Slash, Star};
-
-    AssocOp::AssignOp(match op.node {
-        hir::BinOpKind::Add => Plus,
-        hir::BinOpKind::BitAnd => And,
-        hir::BinOpKind::BitOr => Or,
-        hir::BinOpKind::BitXor => Caret,
-        hir::BinOpKind::Div => Slash,
-        hir::BinOpKind::Mul => Star,
-        hir::BinOpKind::Rem => Percent,
-        hir::BinOpKind::Shl => Shl,
-        hir::BinOpKind::Shr => Shr,
-        hir::BinOpKind::Sub => Minus,
-
-        hir::BinOpKind::And
-        | hir::BinOpKind::Eq
-        | hir::BinOpKind::Ge
-        | hir::BinOpKind::Gt
-        | hir::BinOpKind::Le
-        | hir::BinOpKind::Lt
-        | hir::BinOpKind::Ne
-        | hir::BinOpKind::Or => panic!("This operator does not exist"),
-    })
-}
-
-/// Converts an `ast::BinOp` to the corresponding assigning binary operator.
-fn astbinop2assignop(op: ast::BinOp) -> AssocOp {
-    use rustc_ast::ast::BinOpKind::{
-        Add, And, BitAnd, BitOr, BitXor, Div, Eq, Ge, Gt, Le, Lt, Mul, Ne, Or, Rem, Shl, Shr, Sub,
-    };
-    use rustc_ast::token::BinOpToken;
-
-    AssocOp::AssignOp(match op.node {
-        Add => BinOpToken::Plus,
-        BitAnd => BinOpToken::And,
-        BitOr => BinOpToken::Or,
-        BitXor => BinOpToken::Caret,
-        Div => BinOpToken::Slash,
-        Mul => BinOpToken::Star,
-        Rem => BinOpToken::Percent,
-        Shl => BinOpToken::Shl,
-        Shr => BinOpToken::Shr,
-        Sub => BinOpToken::Minus,
-        And | Eq | Ge | Gt | Le | Lt | Ne | Or => panic!("This operator does not exist"),
-    })
-}
-
-/// Returns the indentation before `span` if there are nothing but `[ \t]`
-/// before it on its line.
-fn indentation<T: LintContext>(cx: &T, span: Span) -> Option<String> {
-    let lo = cx.sess().source_map().lookup_char_pos(span.lo());
-    lo.file
-        .get_line(lo.line - 1 /* line numbers in `Loc` are 1-based */)
-        .and_then(|line| {
-            if let Some((pos, _)) = line.char_indices().find(|&(_, c)| c != ' ' && c != '\t') {
-                // We can mix char and byte positions here because we only consider `[ \t]`.
-                if lo.col == CharPos(pos) {
-                    Some(line[..pos].into())
-                } else {
-                    None
-                }
-            } else {
-                None
-            }
-        })
-}
-
-/// Convenience extension trait for `DiagnosticBuilder`.
-pub trait DiagnosticBuilderExt<T: LintContext> {
-    /// Suggests to add an attribute to an item.
-    ///
-    /// Correctly handles indentation of the attribute and item.
-    ///
-    /// # Example
-    ///
-    /// ```rust,ignore
-    /// diag.suggest_item_with_attr(cx, item, "#[derive(Default)]");
-    /// ```
-    fn suggest_item_with_attr<D: Display + ?Sized>(
-        &mut self,
-        cx: &T,
-        item: Span,
-        msg: &str,
-        attr: &D,
-        applicability: Applicability,
-    );
-
-    /// Suggest to add an item before another.
-    ///
-    /// The item should not be indented (except for inner indentation).
-    ///
-    /// # Example
-    ///
-    /// ```rust,ignore
-    /// diag.suggest_prepend_item(cx, item,
-    /// "fn foo() {
-    ///     bar();
-    /// }");
-    /// ```
-    fn suggest_prepend_item(&mut self, cx: &T, item: Span, msg: &str, new_item: &str, applicability: Applicability);
-
-    /// Suggest to completely remove an item.
-    ///
-    /// This will remove an item and all following whitespace until the next non-whitespace
-    /// character. This should work correctly if item is on the same indentation level as the
-    /// following item.
-    ///
-    /// # Example
-    ///
-    /// ```rust,ignore
-    /// diag.suggest_remove_item(cx, item, "remove this")
-    /// ```
-    fn suggest_remove_item(&mut self, cx: &T, item: Span, msg: &str, applicability: Applicability);
-}
-
-impl<T: LintContext> DiagnosticBuilderExt<T> for rustc_errors::DiagnosticBuilder<'_> {
-    fn suggest_item_with_attr<D: Display + ?Sized>(
-        &mut self,
-        cx: &T,
-        item: Span,
-        msg: &str,
-        attr: &D,
-        applicability: Applicability,
-    ) {
-        if let Some(indent) = indentation(cx, item) {
-            let span = item.with_hi(item.lo());
-
-            self.span_suggestion(span, msg, format!("{}\n{}", attr, indent), applicability);
-        }
-    }
-
-    fn suggest_prepend_item(&mut self, cx: &T, item: Span, msg: &str, new_item: &str, applicability: Applicability) {
-        if let Some(indent) = indentation(cx, item) {
-            let span = item.with_hi(item.lo());
-
-            let mut first = true;
-            let new_item = new_item
-                .lines()
-                .map(|l| {
-                    if first {
-                        first = false;
-                        format!("{}\n", l)
-                    } else {
-                        format!("{}{}\n", indent, l)
-                    }
-                })
-                .collect::<String>();
-
-            self.span_suggestion(span, msg, format!("{}\n{}", new_item, indent), applicability);
-        }
-    }
-
-    fn suggest_remove_item(&mut self, cx: &T, item: Span, msg: &str, applicability: Applicability) {
-        let mut remove_span = item;
-        let hi = cx.sess().source_map().next_point(remove_span).hi();
-        let fmpos = cx.sess().source_map().lookup_byte_offset(hi);
-
-        if let Some(ref src) = fmpos.sf.src {
-            let non_whitespace_offset = src[fmpos.pos.to_usize()..].find(|c| c != ' ' && c != '\t' && c != '\n');
-
-            if let Some(non_whitespace_offset) = non_whitespace_offset {
-                remove_span = remove_span
-                    .with_hi(remove_span.hi() + BytePos(non_whitespace_offset.try_into().expect("offset too large")))
-            }
-        }
-
-        self.span_suggestion(remove_span, msg, String::new(), applicability);
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::Sugg;
-    use std::borrow::Cow;
-
-    const SUGGESTION: Sugg<'static> = Sugg::NonParen(Cow::Borrowed("function_call()"));
-
-    #[test]
-    fn make_return_transform_sugg_into_a_return_call() {
-        assert_eq!("return function_call()", SUGGESTION.make_return().to_string());
-    }
-
-    #[test]
-    fn blockify_transforms_sugg_into_a_block() {
-        assert_eq!("{ function_call() }", SUGGESTION.blockify().to_string());
-    }
-}
diff --git a/clippy_lints/src/utils/sym_helper.rs b/clippy_lints/src/utils/sym_helper.rs
deleted file mode 100644
index f47dc80ebad..00000000000
--- a/clippy_lints/src/utils/sym_helper.rs
+++ /dev/null
@@ -1,7 +0,0 @@
-#[macro_export]
-/// Convenience wrapper around rustc's `Symbol::intern`
-macro_rules! sym {
-    ($tt:tt) => {
-        rustc_span::symbol::Symbol::intern(stringify!($tt))
-    };
-}
diff --git a/clippy_lints/src/utils/usage.rs b/clippy_lints/src/utils/usage.rs
deleted file mode 100644
index 7c7580a2c66..00000000000
--- a/clippy_lints/src/utils/usage.rs
+++ /dev/null
@@ -1,198 +0,0 @@
-use crate::utils;
-use rustc_data_structures::fx::FxHashSet;
-use rustc_hir as hir;
-use rustc_hir::def::Res;
-use rustc_hir::intravisit;
-use rustc_hir::intravisit::{NestedVisitorMap, Visitor};
-use rustc_hir::{Expr, ExprKind, HirId, Path};
-use rustc_infer::infer::TyCtxtInferExt;
-use rustc_lint::LateContext;
-use rustc_middle::hir::map::Map;
-use rustc_middle::ty;
-use rustc_typeck::expr_use_visitor::{ConsumeMode, Delegate, ExprUseVisitor, PlaceBase, PlaceWithHirId};
-
-/// Returns a set of mutated local variable IDs, or `None` if mutations could not be determined.
-pub fn mutated_variables<'tcx>(expr: &'tcx Expr<'_>, cx: &LateContext<'tcx>) -> Option<FxHashSet<HirId>> {
-    let mut delegate = MutVarsDelegate {
-        used_mutably: FxHashSet::default(),
-        skip: false,
-    };
-    cx.tcx.infer_ctxt().enter(|infcx| {
-        ExprUseVisitor::new(
-            &mut delegate,
-            &infcx,
-            expr.hir_id.owner,
-            cx.param_env,
-            cx.typeck_results(),
-        )
-        .walk_expr(expr);
-    });
-
-    if delegate.skip {
-        return None;
-    }
-    Some(delegate.used_mutably)
-}
-
-pub fn is_potentially_mutated<'tcx>(variable: &'tcx Path<'_>, expr: &'tcx Expr<'_>, cx: &LateContext<'tcx>) -> bool {
-    if let Res::Local(id) = variable.res {
-        mutated_variables(expr, cx).map_or(true, |mutated| mutated.contains(&id))
-    } else {
-        true
-    }
-}
-
-struct MutVarsDelegate {
-    used_mutably: FxHashSet<HirId>,
-    skip: bool,
-}
-
-impl<'tcx> MutVarsDelegate {
-    #[allow(clippy::similar_names)]
-    fn update(&mut self, cat: &PlaceWithHirId<'tcx>) {
-        match cat.place.base {
-            PlaceBase::Local(id) => {
-                self.used_mutably.insert(id);
-            },
-            PlaceBase::Upvar(_) => {
-                //FIXME: This causes false negatives. We can't get the `NodeId` from
-                //`Categorization::Upvar(_)`. So we search for any `Upvar`s in the
-                //`while`-body, not just the ones in the condition.
-                self.skip = true
-            },
-            _ => {},
-        }
-    }
-}
-
-impl<'tcx> Delegate<'tcx> for MutVarsDelegate {
-    fn consume(&mut self, _: &PlaceWithHirId<'tcx>, _: HirId, _: ConsumeMode) {}
-
-    fn borrow(&mut self, cmt: &PlaceWithHirId<'tcx>, _: HirId, bk: ty::BorrowKind) {
-        if let ty::BorrowKind::MutBorrow = bk {
-            self.update(&cmt)
-        }
-    }
-
-    fn mutate(&mut self, cmt: &PlaceWithHirId<'tcx>, _: HirId) {
-        self.update(&cmt)
-    }
-}
-
-pub struct ParamBindingIdCollector {
-    binding_hir_ids: Vec<hir::HirId>,
-}
-impl<'tcx> ParamBindingIdCollector {
-    fn collect_binding_hir_ids(body: &'tcx hir::Body<'tcx>) -> Vec<hir::HirId> {
-        let mut hir_ids: Vec<hir::HirId> = Vec::new();
-        for param in body.params.iter() {
-            let mut finder = ParamBindingIdCollector {
-                binding_hir_ids: Vec::new(),
-            };
-            finder.visit_param(param);
-            for hir_id in &finder.binding_hir_ids {
-                hir_ids.push(*hir_id);
-            }
-        }
-        hir_ids
-    }
-}
-impl<'tcx> intravisit::Visitor<'tcx> for ParamBindingIdCollector {
-    type Map = Map<'tcx>;
-
-    fn visit_pat(&mut self, pat: &'tcx hir::Pat<'tcx>) {
-        if let hir::PatKind::Binding(_, hir_id, ..) = pat.kind {
-            self.binding_hir_ids.push(hir_id);
-        }
-        intravisit::walk_pat(self, pat);
-    }
-
-    fn nested_visit_map(&mut self) -> intravisit::NestedVisitorMap<Self::Map> {
-        intravisit::NestedVisitorMap::None
-    }
-}
-
-pub struct BindingUsageFinder<'a, 'tcx> {
-    cx: &'a LateContext<'tcx>,
-    binding_ids: Vec<hir::HirId>,
-    usage_found: bool,
-}
-impl<'a, 'tcx> BindingUsageFinder<'a, 'tcx> {
-    pub fn are_params_used(cx: &'a LateContext<'tcx>, body: &'tcx hir::Body<'tcx>) -> bool {
-        let mut finder = BindingUsageFinder {
-            cx,
-            binding_ids: ParamBindingIdCollector::collect_binding_hir_ids(body),
-            usage_found: false,
-        };
-        finder.visit_body(body);
-        finder.usage_found
-    }
-}
-impl<'a, 'tcx> intravisit::Visitor<'tcx> for BindingUsageFinder<'a, 'tcx> {
-    type Map = Map<'tcx>;
-
-    fn visit_expr(&mut self, expr: &'tcx hir::Expr<'tcx>) {
-        if !self.usage_found {
-            intravisit::walk_expr(self, expr);
-        }
-    }
-
-    fn visit_path(&mut self, path: &'tcx hir::Path<'tcx>, _: hir::HirId) {
-        if let hir::def::Res::Local(id) = path.res {
-            if self.binding_ids.contains(&id) {
-                self.usage_found = true;
-            }
-        }
-    }
-
-    fn nested_visit_map(&mut self) -> intravisit::NestedVisitorMap<Self::Map> {
-        intravisit::NestedVisitorMap::OnlyBodies(self.cx.tcx.hir())
-    }
-}
-
-struct ReturnBreakContinueMacroVisitor {
-    seen_return_break_continue: bool,
-}
-
-impl ReturnBreakContinueMacroVisitor {
-    fn new() -> ReturnBreakContinueMacroVisitor {
-        ReturnBreakContinueMacroVisitor {
-            seen_return_break_continue: false,
-        }
-    }
-}
-
-impl<'tcx> Visitor<'tcx> for ReturnBreakContinueMacroVisitor {
-    type Map = Map<'tcx>;
-    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-        NestedVisitorMap::None
-    }
-
-    fn visit_expr(&mut self, ex: &'tcx Expr<'tcx>) {
-        if self.seen_return_break_continue {
-            // No need to look farther if we've already seen one of them
-            return;
-        }
-        match &ex.kind {
-            ExprKind::Ret(..) | ExprKind::Break(..) | ExprKind::Continue(..) => {
-                self.seen_return_break_continue = true;
-            },
-            // Something special could be done here to handle while or for loop
-            // desugaring, as this will detect a break if there's a while loop
-            // or a for loop inside the expression.
-            _ => {
-                if utils::in_macro(ex.span) {
-                    self.seen_return_break_continue = true;
-                } else {
-                    rustc_hir::intravisit::walk_expr(self, ex);
-                }
-            },
-        }
-    }
-}
-
-pub fn contains_return_break_continue_macro(expression: &Expr<'_>) -> bool {
-    let mut recursive_visitor = ReturnBreakContinueMacroVisitor::new();
-    recursive_visitor.visit_expr(expression);
-    recursive_visitor.seen_return_break_continue
-}
diff --git a/clippy_lints/src/utils/visitors.rs b/clippy_lints/src/utils/visitors.rs
deleted file mode 100644
index 085c1f9c0cb..00000000000
--- a/clippy_lints/src/utils/visitors.rs
+++ /dev/null
@@ -1,190 +0,0 @@
-use crate::utils::path_to_local_id;
-use rustc_hir as hir;
-use rustc_hir::intravisit::{self, walk_expr, NestedVisitorMap, Visitor};
-use rustc_hir::{Arm, Body, Expr, HirId, Stmt};
-use rustc_lint::LateContext;
-use rustc_middle::hir::map::Map;
-
-/// returns `true` if expr contains match expr desugared from try
-fn contains_try(expr: &hir::Expr<'_>) -> bool {
-    struct TryFinder {
-        found: bool,
-    }
-
-    impl<'hir> intravisit::Visitor<'hir> for TryFinder {
-        type Map = Map<'hir>;
-
-        fn nested_visit_map(&mut self) -> intravisit::NestedVisitorMap<Self::Map> {
-            intravisit::NestedVisitorMap::None
-        }
-
-        fn visit_expr(&mut self, expr: &'hir hir::Expr<'hir>) {
-            if self.found {
-                return;
-            }
-            match expr.kind {
-                hir::ExprKind::Match(_, _, hir::MatchSource::TryDesugar) => self.found = true,
-                _ => intravisit::walk_expr(self, expr),
-            }
-        }
-    }
-
-    let mut visitor = TryFinder { found: false };
-    visitor.visit_expr(expr);
-    visitor.found
-}
-
-pub fn find_all_ret_expressions<'hir, F>(_cx: &LateContext<'_>, expr: &'hir hir::Expr<'hir>, callback: F) -> bool
-where
-    F: FnMut(&'hir hir::Expr<'hir>) -> bool,
-{
-    struct RetFinder<F> {
-        in_stmt: bool,
-        failed: bool,
-        cb: F,
-    }
-
-    struct WithStmtGuarg<'a, F> {
-        val: &'a mut RetFinder<F>,
-        prev_in_stmt: bool,
-    }
-
-    impl<F> RetFinder<F> {
-        fn inside_stmt(&mut self, in_stmt: bool) -> WithStmtGuarg<'_, F> {
-            let prev_in_stmt = std::mem::replace(&mut self.in_stmt, in_stmt);
-            WithStmtGuarg {
-                val: self,
-                prev_in_stmt,
-            }
-        }
-    }
-
-    impl<F> std::ops::Deref for WithStmtGuarg<'_, F> {
-        type Target = RetFinder<F>;
-
-        fn deref(&self) -> &Self::Target {
-            self.val
-        }
-    }
-
-    impl<F> std::ops::DerefMut for WithStmtGuarg<'_, F> {
-        fn deref_mut(&mut self) -> &mut Self::Target {
-            self.val
-        }
-    }
-
-    impl<F> Drop for WithStmtGuarg<'_, F> {
-        fn drop(&mut self) {
-            self.val.in_stmt = self.prev_in_stmt;
-        }
-    }
-
-    impl<'hir, F: FnMut(&'hir hir::Expr<'hir>) -> bool> intravisit::Visitor<'hir> for RetFinder<F> {
-        type Map = Map<'hir>;
-
-        fn nested_visit_map(&mut self) -> intravisit::NestedVisitorMap<Self::Map> {
-            intravisit::NestedVisitorMap::None
-        }
-
-        fn visit_stmt(&mut self, stmt: &'hir hir::Stmt<'_>) {
-            intravisit::walk_stmt(&mut *self.inside_stmt(true), stmt)
-        }
-
-        fn visit_expr(&mut self, expr: &'hir hir::Expr<'_>) {
-            if self.failed {
-                return;
-            }
-            if self.in_stmt {
-                match expr.kind {
-                    hir::ExprKind::Ret(Some(expr)) => self.inside_stmt(false).visit_expr(expr),
-                    _ => intravisit::walk_expr(self, expr),
-                }
-            } else {
-                match expr.kind {
-                    hir::ExprKind::If(cond, then, else_opt) => {
-                        self.inside_stmt(true).visit_expr(cond);
-                        self.visit_expr(then);
-                        if let Some(el) = else_opt {
-                            self.visit_expr(el);
-                        }
-                    },
-                    hir::ExprKind::Match(cond, arms, _) => {
-                        self.inside_stmt(true).visit_expr(cond);
-                        for arm in arms {
-                            self.visit_expr(arm.body);
-                        }
-                    },
-                    hir::ExprKind::Block(..) => intravisit::walk_expr(self, expr),
-                    hir::ExprKind::Ret(Some(expr)) => self.visit_expr(expr),
-                    _ => self.failed |= !(self.cb)(expr),
-                }
-            }
-        }
-    }
-
-    !contains_try(expr) && {
-        let mut ret_finder = RetFinder {
-            in_stmt: false,
-            failed: false,
-            cb: callback,
-        };
-        ret_finder.visit_expr(expr);
-        !ret_finder.failed
-    }
-}
-
-pub struct LocalUsedVisitor<'hir> {
-    hir: Map<'hir>,
-    pub local_hir_id: HirId,
-    pub used: bool,
-}
-
-impl<'hir> LocalUsedVisitor<'hir> {
-    pub fn new(cx: &LateContext<'hir>, local_hir_id: HirId) -> Self {
-        Self {
-            hir: cx.tcx.hir(),
-            local_hir_id,
-            used: false,
-        }
-    }
-
-    fn check<T>(&mut self, t: T, visit: fn(&mut Self, T)) -> bool {
-        visit(self, t);
-        std::mem::replace(&mut self.used, false)
-    }
-
-    pub fn check_arm(&mut self, arm: &'hir Arm<'_>) -> bool {
-        self.check(arm, Self::visit_arm)
-    }
-
-    pub fn check_body(&mut self, body: &'hir Body<'_>) -> bool {
-        self.check(body, Self::visit_body)
-    }
-
-    pub fn check_expr(&mut self, expr: &'hir Expr<'_>) -> bool {
-        self.check(expr, Self::visit_expr)
-    }
-
-    pub fn check_stmt(&mut self, stmt: &'hir Stmt<'_>) -> bool {
-        self.check(stmt, Self::visit_stmt)
-    }
-}
-
-impl<'v> Visitor<'v> for LocalUsedVisitor<'v> {
-    type Map = Map<'v>;
-
-    fn visit_expr(&mut self, expr: &'v Expr<'v>) {
-        if self.used {
-            return;
-        }
-        if path_to_local_id(expr, self.local_hir_id) {
-            self.used = true;
-        } else {
-            walk_expr(self, expr);
-        }
-    }
-
-    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-        NestedVisitorMap::OnlyBodies(self.hir)
-    }
-}
diff --git a/clippy_utils/Cargo.toml b/clippy_utils/Cargo.toml
new file mode 100644
index 00000000000..1b05b543186
--- /dev/null
+++ b/clippy_utils/Cargo.toml
@@ -0,0 +1,24 @@
+[package]
+name = "clippy_utils"
+version = "0.1.0"
+authors = ["The Rust Project Developers"]
+edition = "2018"
+
+[dependencies]
+cargo_metadata = "0.12"
+if_chain = "1.0.0"
+itertools = "0.9"
+pulldown-cmark = { version = "0.8", default-features = false }
+quine-mc_cluskey = "0.2.2"
+regex-syntax = "0.6"
+serde = { version = "1.0", features = ["derive"] }
+smallvec = { version = "1", features = ["union"] }
+toml = "0.5.3"
+unicode-normalization = "0.1"
+semver = "0.11"
+rustc-semver="1.1.0"
+# NOTE: cargo requires serde feat in its url dep
+# see <https://github.com/rust-lang/rust/pull/63587#issuecomment-522343864>
+url = { version =  "2.1.0", features = ["serde"] }
+quote = "1"
+syn = { version = "1", features = ["full"] }
diff --git a/clippy_utils/src/ast_utils.rs b/clippy_utils/src/ast_utils.rs
new file mode 100644
index 00000000000..7ec0e103c00
--- /dev/null
+++ b/clippy_utils/src/ast_utils.rs
@@ -0,0 +1,562 @@
+//! Utilities for manipulating and extracting information from `rustc_ast::ast`.
+//!
+//! - The `eq_foobar` functions test for semantic equality but ignores `NodeId`s and `Span`s.
+
+#![allow(clippy::similar_names, clippy::wildcard_imports, clippy::enum_glob_use)]
+
+use crate::{both, over};
+use rustc_ast::ptr::P;
+use rustc_ast::{self as ast, *};
+use rustc_span::symbol::Ident;
+use std::mem;
+
+pub mod ident_iter;
+pub use ident_iter::IdentIter;
+
+pub fn is_useless_with_eq_exprs(kind: BinOpKind) -> bool {
+    use BinOpKind::*;
+    matches!(
+        kind,
+        Sub | Div | Eq | Lt | Le | Gt | Ge | Ne | And | Or | BitXor | BitAnd | BitOr
+    )
+}
+
+/// Checks if each element in the first slice is contained within the latter as per `eq_fn`.
+pub fn unordered_over<X>(left: &[X], right: &[X], mut eq_fn: impl FnMut(&X, &X) -> bool) -> bool {
+    left.len() == right.len() && left.iter().all(|l| right.iter().any(|r| eq_fn(l, r)))
+}
+
+pub fn eq_id(l: Ident, r: Ident) -> bool {
+    l.name == r.name
+}
+
+pub fn eq_pat(l: &Pat, r: &Pat) -> bool {
+    use PatKind::*;
+    match (&l.kind, &r.kind) {
+        (Paren(l), _) => eq_pat(l, r),
+        (_, Paren(r)) => eq_pat(l, r),
+        (Wild, Wild) | (Rest, Rest) => true,
+        (Lit(l), Lit(r)) => eq_expr(l, r),
+        (Ident(b1, i1, s1), Ident(b2, i2, s2)) => b1 == b2 && eq_id(*i1, *i2) && both(s1, s2, |l, r| eq_pat(l, r)),
+        (Range(lf, lt, le), Range(rf, rt, re)) => {
+            eq_expr_opt(lf, rf) && eq_expr_opt(lt, rt) && eq_range_end(&le.node, &re.node)
+        },
+        (Box(l), Box(r))
+        | (Ref(l, Mutability::Not), Ref(r, Mutability::Not))
+        | (Ref(l, Mutability::Mut), Ref(r, Mutability::Mut)) => eq_pat(l, r),
+        (Tuple(l), Tuple(r)) | (Slice(l), Slice(r)) => over(l, r, |l, r| eq_pat(l, r)),
+        (Path(lq, lp), Path(rq, rp)) => both(lq, rq, |l, r| eq_qself(l, r)) && eq_path(lp, rp),
+        (TupleStruct(lp, lfs), TupleStruct(rp, rfs)) => eq_path(lp, rp) && over(lfs, rfs, |l, r| eq_pat(l, r)),
+        (Struct(lp, lfs, lr), Struct(rp, rfs, rr)) => {
+            lr == rr && eq_path(lp, rp) && unordered_over(lfs, rfs, |lf, rf| eq_field_pat(lf, rf))
+        },
+        (Or(ls), Or(rs)) => unordered_over(ls, rs, |l, r| eq_pat(l, r)),
+        (MacCall(l), MacCall(r)) => eq_mac_call(l, r),
+        _ => false,
+    }
+}
+
+pub fn eq_range_end(l: &RangeEnd, r: &RangeEnd) -> bool {
+    match (l, r) {
+        (RangeEnd::Excluded, RangeEnd::Excluded) => true,
+        (RangeEnd::Included(l), RangeEnd::Included(r)) => {
+            matches!(l, RangeSyntax::DotDotEq) == matches!(r, RangeSyntax::DotDotEq)
+        },
+        _ => false,
+    }
+}
+
+pub fn eq_field_pat(l: &FieldPat, r: &FieldPat) -> bool {
+    l.is_placeholder == r.is_placeholder
+        && eq_id(l.ident, r.ident)
+        && eq_pat(&l.pat, &r.pat)
+        && over(&l.attrs, &r.attrs, |l, r| eq_attr(l, r))
+}
+
+pub fn eq_qself(l: &QSelf, r: &QSelf) -> bool {
+    l.position == r.position && eq_ty(&l.ty, &r.ty)
+}
+
+pub fn eq_path(l: &Path, r: &Path) -> bool {
+    over(&l.segments, &r.segments, |l, r| eq_path_seg(l, r))
+}
+
+pub fn eq_path_seg(l: &PathSegment, r: &PathSegment) -> bool {
+    eq_id(l.ident, r.ident) && both(&l.args, &r.args, |l, r| eq_generic_args(l, r))
+}
+
+pub fn eq_generic_args(l: &GenericArgs, r: &GenericArgs) -> bool {
+    match (l, r) {
+        (GenericArgs::AngleBracketed(l), GenericArgs::AngleBracketed(r)) => {
+            over(&l.args, &r.args, |l, r| eq_angle_arg(l, r))
+        },
+        (GenericArgs::Parenthesized(l), GenericArgs::Parenthesized(r)) => {
+            over(&l.inputs, &r.inputs, |l, r| eq_ty(l, r)) && eq_fn_ret_ty(&l.output, &r.output)
+        },
+        _ => false,
+    }
+}
+
+pub fn eq_angle_arg(l: &AngleBracketedArg, r: &AngleBracketedArg) -> bool {
+    match (l, r) {
+        (AngleBracketedArg::Arg(l), AngleBracketedArg::Arg(r)) => eq_generic_arg(l, r),
+        (AngleBracketedArg::Constraint(l), AngleBracketedArg::Constraint(r)) => eq_assoc_constraint(l, r),
+        _ => false,
+    }
+}
+
+pub fn eq_generic_arg(l: &GenericArg, r: &GenericArg) -> bool {
+    match (l, r) {
+        (GenericArg::Lifetime(l), GenericArg::Lifetime(r)) => eq_id(l.ident, r.ident),
+        (GenericArg::Type(l), GenericArg::Type(r)) => eq_ty(l, r),
+        (GenericArg::Const(l), GenericArg::Const(r)) => eq_expr(&l.value, &r.value),
+        _ => false,
+    }
+}
+
+pub fn eq_expr_opt(l: &Option<P<Expr>>, r: &Option<P<Expr>>) -> bool {
+    both(l, r, |l, r| eq_expr(l, r))
+}
+
+pub fn eq_struct_rest(l: &StructRest, r: &StructRest) -> bool {
+    match (l, r) {
+        (StructRest::Base(lb), StructRest::Base(rb)) => eq_expr(lb, rb),
+        (StructRest::Rest(_), StructRest::Rest(_)) | (StructRest::None, StructRest::None) => true,
+        _ => false,
+    }
+}
+
+pub fn eq_expr(l: &Expr, r: &Expr) -> bool {
+    use ExprKind::*;
+    if !over(&l.attrs, &r.attrs, |l, r| eq_attr(l, r)) {
+        return false;
+    }
+    match (&l.kind, &r.kind) {
+        (Paren(l), _) => eq_expr(l, r),
+        (_, Paren(r)) => eq_expr(l, r),
+        (Err, Err) => true,
+        (Box(l), Box(r)) | (Try(l), Try(r)) | (Await(l), Await(r)) => eq_expr(l, r),
+        (Array(l), Array(r)) | (Tup(l), Tup(r)) => over(l, r, |l, r| eq_expr(l, r)),
+        (Repeat(le, ls), Repeat(re, rs)) => eq_expr(le, re) && eq_expr(&ls.value, &rs.value),
+        (Call(lc, la), Call(rc, ra)) => eq_expr(lc, rc) && over(la, ra, |l, r| eq_expr(l, r)),
+        (MethodCall(lc, la, _), MethodCall(rc, ra, _)) => eq_path_seg(lc, rc) && over(la, ra, |l, r| eq_expr(l, r)),
+        (Binary(lo, ll, lr), Binary(ro, rl, rr)) => lo.node == ro.node && eq_expr(ll, rl) && eq_expr(lr, rr),
+        (Unary(lo, l), Unary(ro, r)) => mem::discriminant(lo) == mem::discriminant(ro) && eq_expr(l, r),
+        (Lit(l), Lit(r)) => l.kind == r.kind,
+        (Cast(l, lt), Cast(r, rt)) | (Type(l, lt), Type(r, rt)) => eq_expr(l, r) && eq_ty(lt, rt),
+        (Let(lp, le), Let(rp, re)) => eq_pat(lp, rp) && eq_expr(le, re),
+        (If(lc, lt, le), If(rc, rt, re)) => eq_expr(lc, rc) && eq_block(lt, rt) && eq_expr_opt(le, re),
+        (While(lc, lt, ll), While(rc, rt, rl)) => eq_label(ll, rl) && eq_expr(lc, rc) && eq_block(lt, rt),
+        (ForLoop(lp, li, lt, ll), ForLoop(rp, ri, rt, rl)) => {
+            eq_label(ll, rl) && eq_pat(lp, rp) && eq_expr(li, ri) && eq_block(lt, rt)
+        },
+        (Loop(lt, ll), Loop(rt, rl)) => eq_label(ll, rl) && eq_block(lt, rt),
+        (Block(lb, ll), Block(rb, rl)) => eq_label(ll, rl) && eq_block(lb, rb),
+        (TryBlock(l), TryBlock(r)) => eq_block(l, r),
+        (Yield(l), Yield(r)) | (Ret(l), Ret(r)) => eq_expr_opt(l, r),
+        (Break(ll, le), Break(rl, re)) => eq_label(ll, rl) && eq_expr_opt(le, re),
+        (Continue(ll), Continue(rl)) => eq_label(ll, rl),
+        (Assign(l1, l2, _), Assign(r1, r2, _)) | (Index(l1, l2), Index(r1, r2)) => eq_expr(l1, r1) && eq_expr(l2, r2),
+        (AssignOp(lo, lp, lv), AssignOp(ro, rp, rv)) => lo.node == ro.node && eq_expr(lp, rp) && eq_expr(lv, rv),
+        (Field(lp, lf), Field(rp, rf)) => eq_id(*lf, *rf) && eq_expr(lp, rp),
+        (Match(ls, la), Match(rs, ra)) => eq_expr(ls, rs) && over(la, ra, |l, r| eq_arm(l, r)),
+        (Closure(lc, la, lm, lf, lb, _), Closure(rc, ra, rm, rf, rb, _)) => {
+            lc == rc && la.is_async() == ra.is_async() && lm == rm && eq_fn_decl(lf, rf) && eq_expr(lb, rb)
+        },
+        (Async(lc, _, lb), Async(rc, _, rb)) => lc == rc && eq_block(lb, rb),
+        (Range(lf, lt, ll), Range(rf, rt, rl)) => ll == rl && eq_expr_opt(lf, rf) && eq_expr_opt(lt, rt),
+        (AddrOf(lbk, lm, le), AddrOf(rbk, rm, re)) => lbk == rbk && lm == rm && eq_expr(le, re),
+        (Path(lq, lp), Path(rq, rp)) => both(lq, rq, |l, r| eq_qself(l, r)) && eq_path(lp, rp),
+        (MacCall(l), MacCall(r)) => eq_mac_call(l, r),
+        (Struct(lp, lfs, lb), Struct(rp, rfs, rb)) => {
+            eq_path(lp, rp) && eq_struct_rest(lb, rb) && unordered_over(lfs, rfs, |l, r| eq_field(l, r))
+        },
+        _ => false,
+    }
+}
+
+pub fn eq_field(l: &Field, r: &Field) -> bool {
+    l.is_placeholder == r.is_placeholder
+        && eq_id(l.ident, r.ident)
+        && eq_expr(&l.expr, &r.expr)
+        && over(&l.attrs, &r.attrs, |l, r| eq_attr(l, r))
+}
+
+pub fn eq_arm(l: &Arm, r: &Arm) -> bool {
+    l.is_placeholder == r.is_placeholder
+        && eq_pat(&l.pat, &r.pat)
+        && eq_expr(&l.body, &r.body)
+        && eq_expr_opt(&l.guard, &r.guard)
+        && over(&l.attrs, &r.attrs, |l, r| eq_attr(l, r))
+}
+
+pub fn eq_label(l: &Option<Label>, r: &Option<Label>) -> bool {
+    both(l, r, |l, r| eq_id(l.ident, r.ident))
+}
+
+pub fn eq_block(l: &Block, r: &Block) -> bool {
+    l.rules == r.rules && over(&l.stmts, &r.stmts, |l, r| eq_stmt(l, r))
+}
+
+pub fn eq_stmt(l: &Stmt, r: &Stmt) -> bool {
+    use StmtKind::*;
+    match (&l.kind, &r.kind) {
+        (Local(l), Local(r)) => {
+            eq_pat(&l.pat, &r.pat)
+                && both(&l.ty, &r.ty, |l, r| eq_ty(l, r))
+                && eq_expr_opt(&l.init, &r.init)
+                && over(&l.attrs, &r.attrs, |l, r| eq_attr(l, r))
+        },
+        (Item(l), Item(r)) => eq_item(l, r, eq_item_kind),
+        (Expr(l), Expr(r)) | (Semi(l), Semi(r)) => eq_expr(l, r),
+        (Empty, Empty) => true,
+        (MacCall(l), MacCall(r)) => {
+            l.style == r.style && eq_mac_call(&l.mac, &r.mac) && over(&l.attrs, &r.attrs, |l, r| eq_attr(l, r))
+        },
+        _ => false,
+    }
+}
+
+pub fn eq_item<K>(l: &Item<K>, r: &Item<K>, mut eq_kind: impl FnMut(&K, &K) -> bool) -> bool {
+    eq_id(l.ident, r.ident)
+        && over(&l.attrs, &r.attrs, |l, r| eq_attr(l, r))
+        && eq_vis(&l.vis, &r.vis)
+        && eq_kind(&l.kind, &r.kind)
+}
+
+pub fn eq_item_kind(l: &ItemKind, r: &ItemKind) -> bool {
+    use ItemKind::*;
+    match (l, r) {
+        (ExternCrate(l), ExternCrate(r)) => l == r,
+        (Use(l), Use(r)) => eq_use_tree(l, r),
+        (Static(lt, lm, le), Static(rt, rm, re)) => lm == rm && eq_ty(lt, rt) && eq_expr_opt(le, re),
+        (Const(ld, lt, le), Const(rd, rt, re)) => eq_defaultness(*ld, *rd) && eq_ty(lt, rt) && eq_expr_opt(le, re),
+        (Fn(box FnKind(ld, lf, lg, lb)), Fn(box FnKind(rd, rf, rg, rb))) => {
+            eq_defaultness(*ld, *rd) && eq_fn_sig(lf, rf) && eq_generics(lg, rg) && both(lb, rb, |l, r| eq_block(l, r))
+        },
+        (Mod(l), Mod(r)) => l.inline == r.inline && over(&l.items, &r.items, |l, r| eq_item(l, r, eq_item_kind)),
+        (ForeignMod(l), ForeignMod(r)) => {
+            both(&l.abi, &r.abi, |l, r| eq_str_lit(l, r))
+                && over(&l.items, &r.items, |l, r| eq_item(l, r, eq_foreign_item_kind))
+        },
+        (TyAlias(box TyAliasKind(ld, lg, lb, lt)), TyAlias(box TyAliasKind(rd, rg, rb, rt))) => {
+            eq_defaultness(*ld, *rd)
+                && eq_generics(lg, rg)
+                && over(lb, rb, |l, r| eq_generic_bound(l, r))
+                && both(lt, rt, |l, r| eq_ty(l, r))
+        },
+        (Enum(le, lg), Enum(re, rg)) => {
+            over(&le.variants, &re.variants, |l, r| eq_variant(l, r)) && eq_generics(lg, rg)
+        },
+        (Struct(lv, lg), Struct(rv, rg)) | (Union(lv, lg), Union(rv, rg)) => {
+            eq_variant_data(lv, rv) && eq_generics(lg, rg)
+        },
+        (Trait(box TraitKind(la, lu, lg, lb, li)), Trait(box TraitKind(ra, ru, rg, rb, ri))) => {
+            la == ra
+                && matches!(lu, Unsafe::No) == matches!(ru, Unsafe::No)
+                && eq_generics(lg, rg)
+                && over(lb, rb, |l, r| eq_generic_bound(l, r))
+                && over(li, ri, |l, r| eq_item(l, r, eq_assoc_item_kind))
+        },
+        (TraitAlias(lg, lb), TraitAlias(rg, rb)) => eq_generics(lg, rg) && over(lb, rb, |l, r| eq_generic_bound(l, r)),
+        (
+            Impl(box ImplKind {
+                unsafety: lu,
+                polarity: lp,
+                defaultness: ld,
+                constness: lc,
+                generics: lg,
+                of_trait: lot,
+                self_ty: lst,
+                items: li,
+            }),
+            Impl(box ImplKind {
+                unsafety: ru,
+                polarity: rp,
+                defaultness: rd,
+                constness: rc,
+                generics: rg,
+                of_trait: rot,
+                self_ty: rst,
+                items: ri,
+            }),
+        ) => {
+            matches!(lu, Unsafe::No) == matches!(ru, Unsafe::No)
+                && matches!(lp, ImplPolarity::Positive) == matches!(rp, ImplPolarity::Positive)
+                && eq_defaultness(*ld, *rd)
+                && matches!(lc, ast::Const::No) == matches!(rc, ast::Const::No)
+                && eq_generics(lg, rg)
+                && both(lot, rot, |l, r| eq_path(&l.path, &r.path))
+                && eq_ty(lst, rst)
+                && over(li, ri, |l, r| eq_item(l, r, eq_assoc_item_kind))
+        },
+        (MacCall(l), MacCall(r)) => eq_mac_call(l, r),
+        (MacroDef(l), MacroDef(r)) => l.macro_rules == r.macro_rules && eq_mac_args(&l.body, &r.body),
+        _ => false,
+    }
+}
+
+pub fn eq_foreign_item_kind(l: &ForeignItemKind, r: &ForeignItemKind) -> bool {
+    use ForeignItemKind::*;
+    match (l, r) {
+        (Static(lt, lm, le), Static(rt, rm, re)) => lm == rm && eq_ty(lt, rt) && eq_expr_opt(le, re),
+        (Fn(box FnKind(ld, lf, lg, lb)), Fn(box FnKind(rd, rf, rg, rb))) => {
+            eq_defaultness(*ld, *rd) && eq_fn_sig(lf, rf) && eq_generics(lg, rg) && both(lb, rb, |l, r| eq_block(l, r))
+        },
+        (TyAlias(box TyAliasKind(ld, lg, lb, lt)), TyAlias(box TyAliasKind(rd, rg, rb, rt))) => {
+            eq_defaultness(*ld, *rd)
+                && eq_generics(lg, rg)
+                && over(lb, rb, |l, r| eq_generic_bound(l, r))
+                && both(lt, rt, |l, r| eq_ty(l, r))
+        },
+        (MacCall(l), MacCall(r)) => eq_mac_call(l, r),
+        _ => false,
+    }
+}
+
+pub fn eq_assoc_item_kind(l: &AssocItemKind, r: &AssocItemKind) -> bool {
+    use AssocItemKind::*;
+    match (l, r) {
+        (Const(ld, lt, le), Const(rd, rt, re)) => eq_defaultness(*ld, *rd) && eq_ty(lt, rt) && eq_expr_opt(le, re),
+        (Fn(box FnKind(ld, lf, lg, lb)), Fn(box FnKind(rd, rf, rg, rb))) => {
+            eq_defaultness(*ld, *rd) && eq_fn_sig(lf, rf) && eq_generics(lg, rg) && both(lb, rb, |l, r| eq_block(l, r))
+        },
+        (TyAlias(box TyAliasKind(ld, lg, lb, lt)), TyAlias(box TyAliasKind(rd, rg, rb, rt))) => {
+            eq_defaultness(*ld, *rd)
+                && eq_generics(lg, rg)
+                && over(lb, rb, |l, r| eq_generic_bound(l, r))
+                && both(lt, rt, |l, r| eq_ty(l, r))
+        },
+        (MacCall(l), MacCall(r)) => eq_mac_call(l, r),
+        _ => false,
+    }
+}
+
+pub fn eq_variant(l: &Variant, r: &Variant) -> bool {
+    l.is_placeholder == r.is_placeholder
+        && over(&l.attrs, &r.attrs, |l, r| eq_attr(l, r))
+        && eq_vis(&l.vis, &r.vis)
+        && eq_id(l.ident, r.ident)
+        && eq_variant_data(&l.data, &r.data)
+        && both(&l.disr_expr, &r.disr_expr, |l, r| eq_expr(&l.value, &r.value))
+}
+
+pub fn eq_variant_data(l: &VariantData, r: &VariantData) -> bool {
+    use VariantData::*;
+    match (l, r) {
+        (Unit(_), Unit(_)) => true,
+        (Struct(l, _), Struct(r, _)) | (Tuple(l, _), Tuple(r, _)) => over(l, r, |l, r| eq_struct_field(l, r)),
+        _ => false,
+    }
+}
+
+pub fn eq_struct_field(l: &StructField, r: &StructField) -> bool {
+    l.is_placeholder == r.is_placeholder
+        && over(&l.attrs, &r.attrs, |l, r| eq_attr(l, r))
+        && eq_vis(&l.vis, &r.vis)
+        && both(&l.ident, &r.ident, |l, r| eq_id(*l, *r))
+        && eq_ty(&l.ty, &r.ty)
+}
+
+pub fn eq_fn_sig(l: &FnSig, r: &FnSig) -> bool {
+    eq_fn_decl(&l.decl, &r.decl) && eq_fn_header(&l.header, &r.header)
+}
+
+pub fn eq_fn_header(l: &FnHeader, r: &FnHeader) -> bool {
+    matches!(l.unsafety, Unsafe::No) == matches!(r.unsafety, Unsafe::No)
+        && l.asyncness.is_async() == r.asyncness.is_async()
+        && matches!(l.constness, Const::No) == matches!(r.constness, Const::No)
+        && eq_ext(&l.ext, &r.ext)
+}
+
+pub fn eq_generics(l: &Generics, r: &Generics) -> bool {
+    over(&l.params, &r.params, |l, r| eq_generic_param(l, r))
+        && over(&l.where_clause.predicates, &r.where_clause.predicates, |l, r| {
+            eq_where_predicate(l, r)
+        })
+}
+
+pub fn eq_where_predicate(l: &WherePredicate, r: &WherePredicate) -> bool {
+    use WherePredicate::*;
+    match (l, r) {
+        (BoundPredicate(l), BoundPredicate(r)) => {
+            over(&l.bound_generic_params, &r.bound_generic_params, |l, r| {
+                eq_generic_param(l, r)
+            }) && eq_ty(&l.bounded_ty, &r.bounded_ty)
+                && over(&l.bounds, &r.bounds, |l, r| eq_generic_bound(l, r))
+        },
+        (RegionPredicate(l), RegionPredicate(r)) => {
+            eq_id(l.lifetime.ident, r.lifetime.ident) && over(&l.bounds, &r.bounds, |l, r| eq_generic_bound(l, r))
+        },
+        (EqPredicate(l), EqPredicate(r)) => eq_ty(&l.lhs_ty, &r.lhs_ty) && eq_ty(&l.rhs_ty, &r.rhs_ty),
+        _ => false,
+    }
+}
+
+pub fn eq_use_tree(l: &UseTree, r: &UseTree) -> bool {
+    eq_path(&l.prefix, &r.prefix) && eq_use_tree_kind(&l.kind, &r.kind)
+}
+
+pub fn eq_use_tree_kind(l: &UseTreeKind, r: &UseTreeKind) -> bool {
+    use UseTreeKind::*;
+    match (l, r) {
+        (Glob, Glob) => true,
+        (Simple(l, _, _), Simple(r, _, _)) => both(l, r, |l, r| eq_id(*l, *r)),
+        (Nested(l), Nested(r)) => over(l, r, |(l, _), (r, _)| eq_use_tree(l, r)),
+        _ => false,
+    }
+}
+
+pub fn eq_anon_const(l: &AnonConst, r: &AnonConst) -> bool {
+    eq_expr(&l.value, &r.value)
+}
+
+pub fn eq_defaultness(l: Defaultness, r: Defaultness) -> bool {
+    matches!(
+        (l, r),
+        (Defaultness::Final, Defaultness::Final) | (Defaultness::Default(_), Defaultness::Default(_))
+    )
+}
+
+pub fn eq_vis(l: &Visibility, r: &Visibility) -> bool {
+    use VisibilityKind::*;
+    match (&l.kind, &r.kind) {
+        (Public, Public) | (Inherited, Inherited) | (Crate(_), Crate(_)) => true,
+        (Restricted { path: l, .. }, Restricted { path: r, .. }) => eq_path(l, r),
+        _ => false,
+    }
+}
+
+pub fn eq_fn_decl(l: &FnDecl, r: &FnDecl) -> bool {
+    eq_fn_ret_ty(&l.output, &r.output)
+        && over(&l.inputs, &r.inputs, |l, r| {
+            l.is_placeholder == r.is_placeholder
+                && eq_pat(&l.pat, &r.pat)
+                && eq_ty(&l.ty, &r.ty)
+                && over(&l.attrs, &r.attrs, |l, r| eq_attr(l, r))
+        })
+}
+
+pub fn eq_fn_ret_ty(l: &FnRetTy, r: &FnRetTy) -> bool {
+    match (l, r) {
+        (FnRetTy::Default(_), FnRetTy::Default(_)) => true,
+        (FnRetTy::Ty(l), FnRetTy::Ty(r)) => eq_ty(l, r),
+        _ => false,
+    }
+}
+
+pub fn eq_ty(l: &Ty, r: &Ty) -> bool {
+    use TyKind::*;
+    match (&l.kind, &r.kind) {
+        (Paren(l), _) => eq_ty(l, r),
+        (_, Paren(r)) => eq_ty(l, r),
+        (Never, Never) | (Infer, Infer) | (ImplicitSelf, ImplicitSelf) | (Err, Err) | (CVarArgs, CVarArgs) => true,
+        (Slice(l), Slice(r)) => eq_ty(l, r),
+        (Array(le, ls), Array(re, rs)) => eq_ty(le, re) && eq_expr(&ls.value, &rs.value),
+        (Ptr(l), Ptr(r)) => l.mutbl == r.mutbl && eq_ty(&l.ty, &r.ty),
+        (Rptr(ll, l), Rptr(rl, r)) => {
+            both(ll, rl, |l, r| eq_id(l.ident, r.ident)) && l.mutbl == r.mutbl && eq_ty(&l.ty, &r.ty)
+        },
+        (BareFn(l), BareFn(r)) => {
+            l.unsafety == r.unsafety
+                && eq_ext(&l.ext, &r.ext)
+                && over(&l.generic_params, &r.generic_params, |l, r| eq_generic_param(l, r))
+                && eq_fn_decl(&l.decl, &r.decl)
+        },
+        (Tup(l), Tup(r)) => over(l, r, |l, r| eq_ty(l, r)),
+        (Path(lq, lp), Path(rq, rp)) => both(lq, rq, |l, r| eq_qself(l, r)) && eq_path(lp, rp),
+        (TraitObject(lg, ls), TraitObject(rg, rs)) => ls == rs && over(lg, rg, |l, r| eq_generic_bound(l, r)),
+        (ImplTrait(_, lg), ImplTrait(_, rg)) => over(lg, rg, |l, r| eq_generic_bound(l, r)),
+        (Typeof(l), Typeof(r)) => eq_expr(&l.value, &r.value),
+        (MacCall(l), MacCall(r)) => eq_mac_call(l, r),
+        _ => false,
+    }
+}
+
+pub fn eq_ext(l: &Extern, r: &Extern) -> bool {
+    use Extern::*;
+    match (l, r) {
+        (None, None) | (Implicit, Implicit) => true,
+        (Explicit(l), Explicit(r)) => eq_str_lit(l, r),
+        _ => false,
+    }
+}
+
+pub fn eq_str_lit(l: &StrLit, r: &StrLit) -> bool {
+    l.style == r.style && l.symbol == r.symbol && l.suffix == r.suffix
+}
+
+pub fn eq_poly_ref_trait(l: &PolyTraitRef, r: &PolyTraitRef) -> bool {
+    eq_path(&l.trait_ref.path, &r.trait_ref.path)
+        && over(&l.bound_generic_params, &r.bound_generic_params, |l, r| {
+            eq_generic_param(l, r)
+        })
+}
+
+pub fn eq_generic_param(l: &GenericParam, r: &GenericParam) -> bool {
+    use GenericParamKind::*;
+    l.is_placeholder == r.is_placeholder
+        && eq_id(l.ident, r.ident)
+        && over(&l.bounds, &r.bounds, |l, r| eq_generic_bound(l, r))
+        && match (&l.kind, &r.kind) {
+            (Lifetime, Lifetime) => true,
+            (Type { default: l }, Type { default: r }) => both(l, r, |l, r| eq_ty(l, r)),
+            (
+                Const {
+                    ty: lt,
+                    kw_span: _,
+                    default: ld,
+                },
+                Const {
+                    ty: rt,
+                    kw_span: _,
+                    default: rd,
+                },
+            ) => eq_ty(lt, rt) && both(ld, rd, |ld, rd| eq_anon_const(ld, rd)),
+            _ => false,
+        }
+        && over(&l.attrs, &r.attrs, |l, r| eq_attr(l, r))
+}
+
+pub fn eq_generic_bound(l: &GenericBound, r: &GenericBound) -> bool {
+    use GenericBound::*;
+    match (l, r) {
+        (Trait(ptr1, tbm1), Trait(ptr2, tbm2)) => tbm1 == tbm2 && eq_poly_ref_trait(ptr1, ptr2),
+        (Outlives(l), Outlives(r)) => eq_id(l.ident, r.ident),
+        _ => false,
+    }
+}
+
+pub fn eq_assoc_constraint(l: &AssocTyConstraint, r: &AssocTyConstraint) -> bool {
+    use AssocTyConstraintKind::*;
+    eq_id(l.ident, r.ident)
+        && match (&l.kind, &r.kind) {
+            (Equality { ty: l }, Equality { ty: r }) => eq_ty(l, r),
+            (Bound { bounds: l }, Bound { bounds: r }) => over(l, r, |l, r| eq_generic_bound(l, r)),
+            _ => false,
+        }
+}
+
+pub fn eq_mac_call(l: &MacCall, r: &MacCall) -> bool {
+    eq_path(&l.path, &r.path) && eq_mac_args(&l.args, &r.args)
+}
+
+pub fn eq_attr(l: &Attribute, r: &Attribute) -> bool {
+    use AttrKind::*;
+    l.style == r.style
+        && match (&l.kind, &r.kind) {
+            (DocComment(l1, l2), DocComment(r1, r2)) => l1 == r1 && l2 == r2,
+            (Normal(l, _), Normal(r, _)) => eq_path(&l.path, &r.path) && eq_mac_args(&l.args, &r.args),
+            _ => false,
+        }
+}
+
+pub fn eq_mac_args(l: &MacArgs, r: &MacArgs) -> bool {
+    use MacArgs::*;
+    match (l, r) {
+        (Empty, Empty) => true,
+        (Delimited(_, ld, lts), Delimited(_, rd, rts)) => ld == rd && lts.eq_unspanned(rts),
+        (Eq(_, lt), Eq(_, rt)) => lt.kind == rt.kind,
+        _ => false,
+    }
+}
diff --git a/clippy_utils/src/ast_utils/ident_iter.rs b/clippy_utils/src/ast_utils/ident_iter.rs
new file mode 100644
index 00000000000..eefcbabd835
--- /dev/null
+++ b/clippy_utils/src/ast_utils/ident_iter.rs
@@ -0,0 +1,45 @@
+use core::iter::FusedIterator;
+use rustc_ast::visit::{walk_attribute, walk_expr, Visitor};
+use rustc_ast::{Attribute, Expr};
+use rustc_span::symbol::Ident;
+
+pub struct IdentIter(std::vec::IntoIter<Ident>);
+
+impl Iterator for IdentIter {
+    type Item = Ident;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.0.next()
+    }
+}
+
+impl FusedIterator for IdentIter {}
+
+impl From<&Expr> for IdentIter {
+    fn from(expr: &Expr) -> Self {
+        let mut visitor = IdentCollector::default();
+
+        walk_expr(&mut visitor, expr);
+
+        IdentIter(visitor.0.into_iter())
+    }
+}
+
+impl From<&Attribute> for IdentIter {
+    fn from(attr: &Attribute) -> Self {
+        let mut visitor = IdentCollector::default();
+
+        walk_attribute(&mut visitor, attr);
+
+        IdentIter(visitor.0.into_iter())
+    }
+}
+
+#[derive(Default)]
+struct IdentCollector(Vec<Ident>);
+
+impl Visitor<'_> for IdentCollector {
+    fn visit_ident(&mut self, ident: Ident) {
+        self.0.push(ident);
+    }
+}
diff --git a/clippy_utils/src/attrs.rs b/clippy_utils/src/attrs.rs
new file mode 100644
index 00000000000..8d28421d70d
--- /dev/null
+++ b/clippy_utils/src/attrs.rs
@@ -0,0 +1,150 @@
+use rustc_ast::ast;
+use rustc_errors::Applicability;
+use rustc_session::Session;
+use rustc_span::sym;
+use std::str::FromStr;
+
+/// Deprecation status of attributes known by Clippy.
+#[allow(dead_code)]
+pub enum DeprecationStatus {
+    /// Attribute is deprecated
+    Deprecated,
+    /// Attribute is deprecated and was replaced by the named attribute
+    Replaced(&'static str),
+    None,
+}
+
+pub const BUILTIN_ATTRIBUTES: &[(&str, DeprecationStatus)] = &[
+    ("author", DeprecationStatus::None),
+    ("cognitive_complexity", DeprecationStatus::None),
+    (
+        "cyclomatic_complexity",
+        DeprecationStatus::Replaced("cognitive_complexity"),
+    ),
+    ("dump", DeprecationStatus::None),
+    ("msrv", DeprecationStatus::None),
+];
+
+pub struct LimitStack {
+    stack: Vec<u64>,
+}
+
+impl Drop for LimitStack {
+    fn drop(&mut self) {
+        assert_eq!(self.stack.len(), 1);
+    }
+}
+
+impl LimitStack {
+    #[must_use]
+    pub fn new(limit: u64) -> Self {
+        Self { stack: vec![limit] }
+    }
+    pub fn limit(&self) -> u64 {
+        *self.stack.last().expect("there should always be a value in the stack")
+    }
+    pub fn push_attrs(&mut self, sess: &Session, attrs: &[ast::Attribute], name: &'static str) {
+        let stack = &mut self.stack;
+        parse_attrs(sess, attrs, name, |val| stack.push(val));
+    }
+    pub fn pop_attrs(&mut self, sess: &Session, attrs: &[ast::Attribute], name: &'static str) {
+        let stack = &mut self.stack;
+        parse_attrs(sess, attrs, name, |val| assert_eq!(stack.pop(), Some(val)));
+    }
+}
+
+pub fn get_attr<'a>(
+    sess: &'a Session,
+    attrs: &'a [ast::Attribute],
+    name: &'static str,
+) -> impl Iterator<Item = &'a ast::Attribute> {
+    attrs.iter().filter(move |attr| {
+        let attr = if let ast::AttrKind::Normal(ref attr, _) = attr.kind {
+            attr
+        } else {
+            return false;
+        };
+        let attr_segments = &attr.path.segments;
+        if attr_segments.len() == 2 && attr_segments[0].ident.name == sym::clippy {
+            BUILTIN_ATTRIBUTES
+                .iter()
+                .find_map(|&(builtin_name, ref deprecation_status)| {
+                    if attr_segments[1].ident.name.as_str() == builtin_name {
+                        Some(deprecation_status)
+                    } else {
+                        None
+                    }
+                })
+                .map_or_else(
+                    || {
+                        sess.span_err(attr_segments[1].ident.span, "usage of unknown attribute");
+                        false
+                    },
+                    |deprecation_status| {
+                        let mut diag =
+                            sess.struct_span_err(attr_segments[1].ident.span, "usage of deprecated attribute");
+                        match *deprecation_status {
+                            DeprecationStatus::Deprecated => {
+                                diag.emit();
+                                false
+                            },
+                            DeprecationStatus::Replaced(new_name) => {
+                                diag.span_suggestion(
+                                    attr_segments[1].ident.span,
+                                    "consider using",
+                                    new_name.to_string(),
+                                    Applicability::MachineApplicable,
+                                );
+                                diag.emit();
+                                false
+                            },
+                            DeprecationStatus::None => {
+                                diag.cancel();
+                                attr_segments[1].ident.name.as_str() == name
+                            },
+                        }
+                    },
+                )
+        } else {
+            false
+        }
+    })
+}
+
+fn parse_attrs<F: FnMut(u64)>(sess: &Session, attrs: &[ast::Attribute], name: &'static str, mut f: F) {
+    for attr in get_attr(sess, attrs, name) {
+        if let Some(ref value) = attr.value_str() {
+            if let Ok(value) = FromStr::from_str(&value.as_str()) {
+                f(value)
+            } else {
+                sess.span_err(attr.span, "not a number");
+            }
+        } else {
+            sess.span_err(attr.span, "bad clippy attribute");
+        }
+    }
+}
+
+pub fn get_unique_inner_attr(sess: &Session, attrs: &[ast::Attribute], name: &'static str) -> Option<ast::Attribute> {
+    let mut unique_attr = None;
+    for attr in get_attr(sess, attrs, name) {
+        match attr.style {
+            ast::AttrStyle::Inner if unique_attr.is_none() => unique_attr = Some(attr.clone()),
+            ast::AttrStyle::Inner => {
+                sess.struct_span_err(attr.span, &format!("`{}` is defined multiple times", name))
+                    .span_note(unique_attr.as_ref().unwrap().span, "first definition found here")
+                    .emit();
+            },
+            ast::AttrStyle::Outer => {
+                sess.span_err(attr.span, &format!("`{}` cannot be an outer attribute", name));
+            },
+        }
+    }
+    unique_attr
+}
+
+/// Return true if the attributes contain any of `proc_macro`,
+/// `proc_macro_derive` or `proc_macro_attribute`, false otherwise
+pub fn is_proc_macro(sess: &Session, attrs: &[ast::Attribute]) -> bool {
+    attrs.iter().any(|attr| sess.is_proc_macro_attr(attr))
+}
diff --git a/clippy_utils/src/author.rs b/clippy_utils/src/author.rs
new file mode 100644
index 00000000000..ba83566b5e6
--- /dev/null
+++ b/clippy_utils/src/author.rs
@@ -0,0 +1,779 @@
+//! A group of attributes that can be attached to Rust code in order
+//! to generate a clippy lint detecting said code automatically.
+
+use crate::{declare_clippy_lint, get_attr};
+use rustc_ast::ast::{Attribute, LitFloatType, LitKind};
+use rustc_ast::walk_list;
+use rustc_data_structures::fx::FxHashMap;
+use rustc_hir as hir;
+use rustc_hir::intravisit::{NestedVisitorMap, Visitor};
+use rustc_hir::{BindingAnnotation, Block, Expr, ExprKind, Pat, PatKind, QPath, Stmt, StmtKind, TyKind};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_middle::hir::map::Map;
+use rustc_session::Session;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// **What it does:** Generates clippy code that detects the offending pattern
+    ///
+    /// **Example:**
+    /// ```rust,ignore
+    /// // ./tests/ui/my_lint.rs
+    /// fn foo() {
+    ///     // detect the following pattern
+    ///     #[clippy::author]
+    ///     if x == 42 {
+    ///         // but ignore everything from here on
+    ///         #![clippy::author = "ignore"]
+    ///     }
+    ///     ()
+    /// }
+    /// ```
+    ///
+    /// Running `TESTNAME=ui/my_lint cargo uitest` will produce
+    /// a `./tests/ui/new_lint.stdout` file with the generated code:
+    ///
+    /// ```rust,ignore
+    /// // ./tests/ui/new_lint.stdout
+    /// if_chain! {
+    ///     if let ExprKind::If(ref cond, ref then, None) = item.kind,
+    ///     if let ExprKind::Binary(BinOp::Eq, ref left, ref right) = cond.kind,
+    ///     if let ExprKind::Path(ref path) = left.kind,
+    ///     if let ExprKind::Lit(ref lit) = right.kind,
+    ///     if let LitKind::Int(42, _) = lit.node,
+    ///     then {
+    ///         // report your lint here
+    ///     }
+    /// }
+    /// ```
+    pub LINT_AUTHOR,
+    internal_warn,
+    "helper for writing lints"
+}
+
+declare_lint_pass!(Author => [LINT_AUTHOR]);
+
+fn prelude() {
+    println!("if_chain! {{");
+}
+
+fn done() {
+    println!("    then {{");
+    println!("        // report your lint here");
+    println!("    }}");
+    println!("}}");
+}
+
+impl<'tcx> LateLintPass<'tcx> for Author {
+    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) {
+        if !has_attr(cx.sess(), &item.attrs) {
+            return;
+        }
+        prelude();
+        PrintVisitor::new("item").visit_item(item);
+        done();
+    }
+
+    fn check_impl_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::ImplItem<'_>) {
+        if !has_attr(cx.sess(), &item.attrs) {
+            return;
+        }
+        prelude();
+        PrintVisitor::new("item").visit_impl_item(item);
+        done();
+    }
+
+    fn check_trait_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::TraitItem<'_>) {
+        if !has_attr(cx.sess(), &item.attrs) {
+            return;
+        }
+        prelude();
+        PrintVisitor::new("item").visit_trait_item(item);
+        done();
+    }
+
+    fn check_variant(&mut self, cx: &LateContext<'tcx>, var: &'tcx hir::Variant<'_>) {
+        if !has_attr(cx.sess(), &var.attrs) {
+            return;
+        }
+        prelude();
+        let parent_hir_id = cx.tcx.hir().get_parent_node(var.id);
+        PrintVisitor::new("var").visit_variant(var, &hir::Generics::empty(), parent_hir_id);
+        done();
+    }
+
+    fn check_struct_field(&mut self, cx: &LateContext<'tcx>, field: &'tcx hir::StructField<'_>) {
+        if !has_attr(cx.sess(), &field.attrs) {
+            return;
+        }
+        prelude();
+        PrintVisitor::new("field").visit_struct_field(field);
+        done();
+    }
+
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
+        if !has_attr(cx.sess(), &expr.attrs) {
+            return;
+        }
+        prelude();
+        PrintVisitor::new("expr").visit_expr(expr);
+        done();
+    }
+
+    fn check_arm(&mut self, cx: &LateContext<'tcx>, arm: &'tcx hir::Arm<'_>) {
+        if !has_attr(cx.sess(), &arm.attrs) {
+            return;
+        }
+        prelude();
+        PrintVisitor::new("arm").visit_arm(arm);
+        done();
+    }
+
+    fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx hir::Stmt<'_>) {
+        if !has_attr(cx.sess(), stmt.kind.attrs(|id| cx.tcx.hir().item(id.id))) {
+            return;
+        }
+        prelude();
+        PrintVisitor::new("stmt").visit_stmt(stmt);
+        done();
+    }
+
+    fn check_foreign_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::ForeignItem<'_>) {
+        if !has_attr(cx.sess(), &item.attrs) {
+            return;
+        }
+        prelude();
+        PrintVisitor::new("item").visit_foreign_item(item);
+        done();
+    }
+}
+
+impl PrintVisitor {
+    #[must_use]
+    fn new(s: &'static str) -> Self {
+        Self {
+            ids: FxHashMap::default(),
+            current: s.to_owned(),
+        }
+    }
+
+    fn next(&mut self, s: &'static str) -> String {
+        use std::collections::hash_map::Entry::{Occupied, Vacant};
+        match self.ids.entry(s) {
+            // already there: start numbering from `1`
+            Occupied(mut occ) => {
+                let val = occ.get_mut();
+                *val += 1;
+                format!("{}{}", s, *val)
+            },
+            // not there: insert and return name as given
+            Vacant(vac) => {
+                vac.insert(0);
+                s.to_owned()
+            },
+        }
+    }
+
+    fn print_qpath(&mut self, path: &QPath<'_>) {
+        if let QPath::LangItem(lang_item, _) = *path {
+            println!(
+                "    if matches!({}, QPath::LangItem(LangItem::{:?}, _));",
+                self.current, lang_item,
+            );
+        } else {
+            print!("    if match_qpath({}, &[", self.current);
+            print_path(path, &mut true);
+            println!("]);");
+        }
+    }
+}
+
+struct PrintVisitor {
+    /// Fields are the current index that needs to be appended to pattern
+    /// binding names
+    ids: FxHashMap<&'static str, usize>,
+    /// the name that needs to be destructured
+    current: String,
+}
+
+impl<'tcx> Visitor<'tcx> for PrintVisitor {
+    type Map = Map<'tcx>;
+
+    #[allow(clippy::too_many_lines)]
+    fn visit_expr(&mut self, expr: &Expr<'_>) {
+        print!("    if let ExprKind::");
+        let current = format!("{}.kind", self.current);
+        match expr.kind {
+            ExprKind::Box(ref inner) => {
+                let inner_pat = self.next("inner");
+                println!("Box(ref {}) = {};", inner_pat, current);
+                self.current = inner_pat;
+                self.visit_expr(inner);
+            },
+            ExprKind::Array(ref elements) => {
+                let elements_pat = self.next("elements");
+                println!("Array(ref {}) = {};", elements_pat, current);
+                println!("    if {}.len() == {};", elements_pat, elements.len());
+                for (i, element) in elements.iter().enumerate() {
+                    self.current = format!("{}[{}]", elements_pat, i);
+                    self.visit_expr(element);
+                }
+            },
+            ExprKind::Call(ref func, ref args) => {
+                let func_pat = self.next("func");
+                let args_pat = self.next("args");
+                println!("Call(ref {}, ref {}) = {};", func_pat, args_pat, current);
+                self.current = func_pat;
+                self.visit_expr(func);
+                println!("    if {}.len() == {};", args_pat, args.len());
+                for (i, arg) in args.iter().enumerate() {
+                    self.current = format!("{}[{}]", args_pat, i);
+                    self.visit_expr(arg);
+                }
+            },
+            ExprKind::MethodCall(ref _method_name, ref _generics, ref _args, ref _fn_span) => {
+                println!(
+                    "MethodCall(ref method_name, ref generics, ref args, ref fn_span) = {};",
+                    current
+                );
+                println!("    // unimplemented: `ExprKind::MethodCall` is not further destructured at the moment");
+            },
+            ExprKind::Tup(ref elements) => {
+                let elements_pat = self.next("elements");
+                println!("Tup(ref {}) = {};", elements_pat, current);
+                println!("    if {}.len() == {};", elements_pat, elements.len());
+                for (i, element) in elements.iter().enumerate() {
+                    self.current = format!("{}[{}]", elements_pat, i);
+                    self.visit_expr(element);
+                }
+            },
+            ExprKind::Binary(ref op, ref left, ref right) => {
+                let op_pat = self.next("op");
+                let left_pat = self.next("left");
+                let right_pat = self.next("right");
+                println!(
+                    "Binary(ref {}, ref {}, ref {}) = {};",
+                    op_pat, left_pat, right_pat, current
+                );
+                println!("    if BinOpKind::{:?} == {}.node;", op.node, op_pat);
+                self.current = left_pat;
+                self.visit_expr(left);
+                self.current = right_pat;
+                self.visit_expr(right);
+            },
+            ExprKind::Unary(ref op, ref inner) => {
+                let inner_pat = self.next("inner");
+                println!("Unary(UnOp::{:?}, ref {}) = {};", op, inner_pat, current);
+                self.current = inner_pat;
+                self.visit_expr(inner);
+            },
+            ExprKind::Lit(ref lit) => {
+                let lit_pat = self.next("lit");
+                println!("Lit(ref {}) = {};", lit_pat, current);
+                match lit.node {
+                    LitKind::Bool(val) => println!("    if let LitKind::Bool({:?}) = {}.node;", val, lit_pat),
+                    LitKind::Char(c) => println!("    if let LitKind::Char({:?}) = {}.node;", c, lit_pat),
+                    LitKind::Err(val) => println!("    if let LitKind::Err({}) = {}.node;", val, lit_pat),
+                    LitKind::Byte(b) => println!("    if let LitKind::Byte({}) = {}.node;", b, lit_pat),
+                    // FIXME: also check int type
+                    LitKind::Int(i, _) => println!("    if let LitKind::Int({}, _) = {}.node;", i, lit_pat),
+                    LitKind::Float(_, LitFloatType::Suffixed(_)) => println!(
+                        "    if let LitKind::Float(_, LitFloatType::Suffixed(_)) = {}.node;",
+                        lit_pat
+                    ),
+                    LitKind::Float(_, LitFloatType::Unsuffixed) => println!(
+                        "    if let LitKind::Float(_, LitFloatType::Unsuffixed) = {}.node;",
+                        lit_pat
+                    ),
+                    LitKind::ByteStr(ref vec) => {
+                        let vec_pat = self.next("vec");
+                        println!("    if let LitKind::ByteStr(ref {}) = {}.node;", vec_pat, lit_pat);
+                        println!("    if let [{:?}] = **{};", vec, vec_pat);
+                    },
+                    LitKind::Str(ref text, _) => {
+                        let str_pat = self.next("s");
+                        println!("    if let LitKind::Str(ref {}, _) = {}.node;", str_pat, lit_pat);
+                        println!("    if {}.as_str() == {:?}", str_pat, &*text.as_str())
+                    },
+                }
+            },
+            ExprKind::Cast(ref expr, ref ty) => {
+                let cast_pat = self.next("expr");
+                let cast_ty = self.next("cast_ty");
+                let qp_label = self.next("qp");
+
+                println!("Cast(ref {}, ref {}) = {};", cast_pat, cast_ty, current);
+                if let TyKind::Path(ref qp) = ty.kind {
+                    println!("    if let TyKind::Path(ref {}) = {}.kind;", qp_label, cast_ty);
+                    self.current = qp_label;
+                    self.print_qpath(qp);
+                }
+                self.current = cast_pat;
+                self.visit_expr(expr);
+            },
+            ExprKind::Type(ref expr, ref _ty) => {
+                let cast_pat = self.next("expr");
+                println!("Type(ref {}, _) = {};", cast_pat, current);
+                self.current = cast_pat;
+                self.visit_expr(expr);
+            },
+            ExprKind::Loop(ref body, _, desugaring, _) => {
+                let body_pat = self.next("body");
+                let des = loop_desugaring_name(desugaring);
+                let label_pat = self.next("label");
+                println!("Loop(ref {}, ref {}, {}) = {};", body_pat, label_pat, des, current);
+                self.current = body_pat;
+                self.visit_block(body);
+            },
+            ExprKind::If(ref cond, ref then, ref opt_else) => {
+                let cond_pat = self.next("cond");
+                let then_pat = self.next("then");
+                if let Some(ref else_) = *opt_else {
+                    let else_pat = self.next("else_");
+                    println!(
+                        "If(ref {}, ref {}, Some(ref {})) = {};",
+                        cond_pat, then_pat, else_pat, current
+                    );
+                    self.current = else_pat;
+                    self.visit_expr(else_);
+                } else {
+                    println!("If(ref {}, ref {}, None) = {};", cond_pat, then_pat, current);
+                }
+                self.current = cond_pat;
+                self.visit_expr(cond);
+                self.current = then_pat;
+                self.visit_expr(then);
+            },
+            ExprKind::Match(ref expr, ref arms, desugaring) => {
+                let des = desugaring_name(desugaring);
+                let expr_pat = self.next("expr");
+                let arms_pat = self.next("arms");
+                println!("Match(ref {}, ref {}, {}) = {};", expr_pat, arms_pat, des, current);
+                self.current = expr_pat;
+                self.visit_expr(expr);
+                println!("    if {}.len() == {};", arms_pat, arms.len());
+                for (i, arm) in arms.iter().enumerate() {
+                    self.current = format!("{}[{}].body", arms_pat, i);
+                    self.visit_expr(&arm.body);
+                    if let Some(ref guard) = arm.guard {
+                        let guard_pat = self.next("guard");
+                        println!("    if let Some(ref {}) = {}[{}].guard;", guard_pat, arms_pat, i);
+                        match guard {
+                            hir::Guard::If(ref if_expr) => {
+                                let if_expr_pat = self.next("expr");
+                                println!("    if let Guard::If(ref {}) = {};", if_expr_pat, guard_pat);
+                                self.current = if_expr_pat;
+                                self.visit_expr(if_expr);
+                            },
+                            hir::Guard::IfLet(ref if_let_pat, ref if_let_expr) => {
+                                let if_let_pat_pat = self.next("pat");
+                                let if_let_expr_pat = self.next("expr");
+                                println!(
+                                    "    if let Guard::IfLet(ref {}, ref {}) = {};",
+                                    if_let_pat_pat, if_let_expr_pat, guard_pat
+                                );
+                                self.current = if_let_expr_pat;
+                                self.visit_expr(if_let_expr);
+                                self.current = if_let_pat_pat;
+                                self.visit_pat(if_let_pat);
+                            },
+                        }
+                    }
+                    self.current = format!("{}[{}].pat", arms_pat, i);
+                    self.visit_pat(&arm.pat);
+                }
+            },
+            ExprKind::Closure(ref _capture_clause, ref _func, _, _, _) => {
+                println!("Closure(ref capture_clause, ref func, _, _, _) = {};", current);
+                println!("    // unimplemented: `ExprKind::Closure` is not further destructured at the moment");
+            },
+            ExprKind::Yield(ref sub, _) => {
+                let sub_pat = self.next("sub");
+                println!("Yield(ref sub) = {};", current);
+                self.current = sub_pat;
+                self.visit_expr(sub);
+            },
+            ExprKind::Block(ref block, _) => {
+                let block_pat = self.next("block");
+                println!("Block(ref {}) = {};", block_pat, current);
+                self.current = block_pat;
+                self.visit_block(block);
+            },
+            ExprKind::Assign(ref target, ref value, _) => {
+                let target_pat = self.next("target");
+                let value_pat = self.next("value");
+                println!(
+                    "Assign(ref {}, ref {}, ref _span) = {};",
+                    target_pat, value_pat, current
+                );
+                self.current = target_pat;
+                self.visit_expr(target);
+                self.current = value_pat;
+                self.visit_expr(value);
+            },
+            ExprKind::AssignOp(ref op, ref target, ref value) => {
+                let op_pat = self.next("op");
+                let target_pat = self.next("target");
+                let value_pat = self.next("value");
+                println!(
+                    "AssignOp(ref {}, ref {}, ref {}) = {};",
+                    op_pat, target_pat, value_pat, current
+                );
+                println!("    if BinOpKind::{:?} == {}.node;", op.node, op_pat);
+                self.current = target_pat;
+                self.visit_expr(target);
+                self.current = value_pat;
+                self.visit_expr(value);
+            },
+            ExprKind::Field(ref object, ref field_ident) => {
+                let obj_pat = self.next("object");
+                let field_name_pat = self.next("field_name");
+                println!("Field(ref {}, ref {}) = {};", obj_pat, field_name_pat, current);
+                println!("    if {}.as_str() == {:?}", field_name_pat, field_ident.as_str());
+                self.current = obj_pat;
+                self.visit_expr(object);
+            },
+            ExprKind::Index(ref object, ref index) => {
+                let object_pat = self.next("object");
+                let index_pat = self.next("index");
+                println!("Index(ref {}, ref {}) = {};", object_pat, index_pat, current);
+                self.current = object_pat;
+                self.visit_expr(object);
+                self.current = index_pat;
+                self.visit_expr(index);
+            },
+            ExprKind::Path(ref path) => {
+                let path_pat = self.next("path");
+                println!("Path(ref {}) = {};", path_pat, current);
+                self.current = path_pat;
+                self.print_qpath(path);
+            },
+            ExprKind::AddrOf(kind, mutability, ref inner) => {
+                let inner_pat = self.next("inner");
+                println!(
+                    "AddrOf(BorrowKind::{:?}, Mutability::{:?}, ref {}) = {};",
+                    kind, mutability, inner_pat, current
+                );
+                self.current = inner_pat;
+                self.visit_expr(inner);
+            },
+            ExprKind::Break(ref _destination, ref opt_value) => {
+                let destination_pat = self.next("destination");
+                if let Some(ref value) = *opt_value {
+                    let value_pat = self.next("value");
+                    println!("Break(ref {}, Some(ref {})) = {};", destination_pat, value_pat, current);
+                    self.current = value_pat;
+                    self.visit_expr(value);
+                } else {
+                    println!("Break(ref {}, None) = {};", destination_pat, current);
+                }
+                // FIXME: implement label printing
+            },
+            ExprKind::Continue(ref _destination) => {
+                let destination_pat = self.next("destination");
+                println!("Again(ref {}) = {};", destination_pat, current);
+                // FIXME: implement label printing
+            },
+            ExprKind::Ret(ref opt_value) => {
+                if let Some(ref value) = *opt_value {
+                    let value_pat = self.next("value");
+                    println!("Ret(Some(ref {})) = {};", value_pat, current);
+                    self.current = value_pat;
+                    self.visit_expr(value);
+                } else {
+                    println!("Ret(None) = {};", current);
+                }
+            },
+            ExprKind::InlineAsm(_) => {
+                println!("InlineAsm(_) = {};", current);
+                println!("    // unimplemented: `ExprKind::InlineAsm` is not further destructured at the moment");
+            },
+            ExprKind::LlvmInlineAsm(_) => {
+                println!("LlvmInlineAsm(_) = {};", current);
+                println!("    // unimplemented: `ExprKind::LlvmInlineAsm` is not further destructured at the moment");
+            },
+            ExprKind::Struct(ref path, ref fields, ref opt_base) => {
+                let path_pat = self.next("path");
+                let fields_pat = self.next("fields");
+                if let Some(ref base) = *opt_base {
+                    let base_pat = self.next("base");
+                    println!(
+                        "Struct(ref {}, ref {}, Some(ref {})) = {};",
+                        path_pat, fields_pat, base_pat, current
+                    );
+                    self.current = base_pat;
+                    self.visit_expr(base);
+                } else {
+                    println!("Struct(ref {}, ref {}, None) = {};", path_pat, fields_pat, current);
+                }
+                self.current = path_pat;
+                self.print_qpath(path);
+                println!("    if {}.len() == {};", fields_pat, fields.len());
+                println!("    // unimplemented: field checks");
+            },
+            ExprKind::ConstBlock(_) => {
+                let value_pat = self.next("value");
+                println!("Const({})", value_pat);
+                self.current = value_pat;
+            },
+            // FIXME: compute length (needs type info)
+            ExprKind::Repeat(ref value, _) => {
+                let value_pat = self.next("value");
+                println!("Repeat(ref {}, _) = {};", value_pat, current);
+                println!("// unimplemented: repeat count check");
+                self.current = value_pat;
+                self.visit_expr(value);
+            },
+            ExprKind::Err => {
+                println!("Err = {}", current);
+            },
+            ExprKind::DropTemps(ref expr) => {
+                let expr_pat = self.next("expr");
+                println!("DropTemps(ref {}) = {};", expr_pat, current);
+                self.current = expr_pat;
+                self.visit_expr(expr);
+            },
+        }
+    }
+
+    fn visit_block(&mut self, block: &Block<'_>) {
+        let trailing_pat = self.next("trailing_expr");
+        println!("    if let Some({}) = &{}.expr;", trailing_pat, self.current);
+        println!("    if {}.stmts.len() == {};", self.current, block.stmts.len());
+        let current = self.current.clone();
+        for (i, stmt) in block.stmts.iter().enumerate() {
+            self.current = format!("{}.stmts[{}]", current, i);
+            self.visit_stmt(stmt);
+        }
+    }
+
+    #[allow(clippy::too_many_lines)]
+    fn visit_pat(&mut self, pat: &Pat<'_>) {
+        print!("    if let PatKind::");
+        let current = format!("{}.kind", self.current);
+        match pat.kind {
+            PatKind::Wild => println!("Wild = {};", current),
+            PatKind::Binding(anno, .., ident, ref sub) => {
+                let anno_pat = match anno {
+                    BindingAnnotation::Unannotated => "BindingAnnotation::Unannotated",
+                    BindingAnnotation::Mutable => "BindingAnnotation::Mutable",
+                    BindingAnnotation::Ref => "BindingAnnotation::Ref",
+                    BindingAnnotation::RefMut => "BindingAnnotation::RefMut",
+                };
+                let name_pat = self.next("name");
+                if let Some(ref sub) = *sub {
+                    let sub_pat = self.next("sub");
+                    println!(
+                        "Binding({}, _, {}, Some(ref {})) = {};",
+                        anno_pat, name_pat, sub_pat, current
+                    );
+                    self.current = sub_pat;
+                    self.visit_pat(sub);
+                } else {
+                    println!("Binding({}, _, {}, None) = {};", anno_pat, name_pat, current);
+                }
+                println!("    if {}.as_str() == \"{}\";", name_pat, ident.as_str());
+            },
+            PatKind::Struct(ref path, ref fields, ignore) => {
+                let path_pat = self.next("path");
+                let fields_pat = self.next("fields");
+                println!(
+                    "Struct(ref {}, ref {}, {}) = {};",
+                    path_pat, fields_pat, ignore, current
+                );
+                self.current = path_pat;
+                self.print_qpath(path);
+                println!("    if {}.len() == {};", fields_pat, fields.len());
+                println!("    // unimplemented: field checks");
+            },
+            PatKind::Or(ref fields) => {
+                let fields_pat = self.next("fields");
+                println!("Or(ref {}) = {};", fields_pat, current);
+                println!("    if {}.len() == {};", fields_pat, fields.len());
+                println!("    // unimplemented: field checks");
+            },
+            PatKind::TupleStruct(ref path, ref fields, skip_pos) => {
+                let path_pat = self.next("path");
+                let fields_pat = self.next("fields");
+                println!(
+                    "TupleStruct(ref {}, ref {}, {:?}) = {};",
+                    path_pat, fields_pat, skip_pos, current
+                );
+                self.current = path_pat;
+                self.print_qpath(path);
+                println!("    if {}.len() == {};", fields_pat, fields.len());
+                println!("    // unimplemented: field checks");
+            },
+            PatKind::Path(ref path) => {
+                let path_pat = self.next("path");
+                println!("Path(ref {}) = {};", path_pat, current);
+                self.current = path_pat;
+                self.print_qpath(path);
+            },
+            PatKind::Tuple(ref fields, skip_pos) => {
+                let fields_pat = self.next("fields");
+                println!("Tuple(ref {}, {:?}) = {};", fields_pat, skip_pos, current);
+                println!("    if {}.len() == {};", fields_pat, fields.len());
+                println!("    // unimplemented: field checks");
+            },
+            PatKind::Box(ref pat) => {
+                let pat_pat = self.next("pat");
+                println!("Box(ref {}) = {};", pat_pat, current);
+                self.current = pat_pat;
+                self.visit_pat(pat);
+            },
+            PatKind::Ref(ref pat, muta) => {
+                let pat_pat = self.next("pat");
+                println!("Ref(ref {}, Mutability::{:?}) = {};", pat_pat, muta, current);
+                self.current = pat_pat;
+                self.visit_pat(pat);
+            },
+            PatKind::Lit(ref lit_expr) => {
+                let lit_expr_pat = self.next("lit_expr");
+                println!("Lit(ref {}) = {}", lit_expr_pat, current);
+                self.current = lit_expr_pat;
+                self.visit_expr(lit_expr);
+            },
+            PatKind::Range(ref start, ref end, end_kind) => {
+                let start_pat = self.next("start");
+                let end_pat = self.next("end");
+                println!(
+                    "Range(ref {}, ref {}, RangeEnd::{:?}) = {};",
+                    start_pat, end_pat, end_kind, current
+                );
+                self.current = start_pat;
+                walk_list!(self, visit_expr, start);
+                self.current = end_pat;
+                walk_list!(self, visit_expr, end);
+            },
+            PatKind::Slice(ref start, ref middle, ref end) => {
+                let start_pat = self.next("start");
+                let end_pat = self.next("end");
+                if let Some(ref middle) = middle {
+                    let middle_pat = self.next("middle");
+                    println!(
+                        "Slice(ref {}, Some(ref {}), ref {}) = {};",
+                        start_pat, middle_pat, end_pat, current
+                    );
+                    self.current = middle_pat;
+                    self.visit_pat(middle);
+                } else {
+                    println!("Slice(ref {}, None, ref {}) = {};", start_pat, end_pat, current);
+                }
+                println!("    if {}.len() == {};", start_pat, start.len());
+                for (i, pat) in start.iter().enumerate() {
+                    self.current = format!("{}[{}]", start_pat, i);
+                    self.visit_pat(pat);
+                }
+                println!("    if {}.len() == {};", end_pat, end.len());
+                for (i, pat) in end.iter().enumerate() {
+                    self.current = format!("{}[{}]", end_pat, i);
+                    self.visit_pat(pat);
+                }
+            },
+        }
+    }
+
+    fn visit_stmt(&mut self, s: &Stmt<'_>) {
+        print!("    if let StmtKind::");
+        let current = format!("{}.kind", self.current);
+        match s.kind {
+            // A local (let) binding:
+            StmtKind::Local(ref local) => {
+                let local_pat = self.next("local");
+                println!("Local(ref {}) = {};", local_pat, current);
+                if let Some(ref init) = local.init {
+                    let init_pat = self.next("init");
+                    println!("    if let Some(ref {}) = {}.init;", init_pat, local_pat);
+                    self.current = init_pat;
+                    self.visit_expr(init);
+                }
+                self.current = format!("{}.pat", local_pat);
+                self.visit_pat(&local.pat);
+            },
+            // An item binding:
+            StmtKind::Item(_) => {
+                println!("Item(item_id) = {};", current);
+            },
+
+            // Expr without trailing semi-colon (must have unit type):
+            StmtKind::Expr(ref e) => {
+                let e_pat = self.next("e");
+                println!("Expr(ref {}, _) = {}", e_pat, current);
+                self.current = e_pat;
+                self.visit_expr(e);
+            },
+
+            // Expr with trailing semi-colon (may have any type):
+            StmtKind::Semi(ref e) => {
+                let e_pat = self.next("e");
+                println!("Semi(ref {}, _) = {}", e_pat, current);
+                self.current = e_pat;
+                self.visit_expr(e);
+            },
+        }
+    }
+
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::None
+    }
+}
+
+fn has_attr(sess: &Session, attrs: &[Attribute]) -> bool {
+    get_attr(sess, attrs, "author").count() > 0
+}
+
+#[must_use]
+fn desugaring_name(des: hir::MatchSource) -> String {
+    match des {
+        hir::MatchSource::ForLoopDesugar => "MatchSource::ForLoopDesugar".to_string(),
+        hir::MatchSource::TryDesugar => "MatchSource::TryDesugar".to_string(),
+        hir::MatchSource::WhileDesugar => "MatchSource::WhileDesugar".to_string(),
+        hir::MatchSource::WhileLetDesugar => "MatchSource::WhileLetDesugar".to_string(),
+        hir::MatchSource::Normal => "MatchSource::Normal".to_string(),
+        hir::MatchSource::IfLetDesugar { contains_else_clause } => format!(
+            "MatchSource::IfLetDesugar {{ contains_else_clause: {} }}",
+            contains_else_clause
+        ),
+        hir::MatchSource::IfLetGuardDesugar => "MatchSource::IfLetGuardDesugar".to_string(),
+        hir::MatchSource::AwaitDesugar => "MatchSource::AwaitDesugar".to_string(),
+    }
+}
+
+#[must_use]
+fn loop_desugaring_name(des: hir::LoopSource) -> &'static str {
+    match des {
+        hir::LoopSource::ForLoop => "LoopSource::ForLoop",
+        hir::LoopSource::Loop => "LoopSource::Loop",
+        hir::LoopSource::While => "LoopSource::While",
+        hir::LoopSource::WhileLet => "LoopSource::WhileLet",
+    }
+}
+
+fn print_path(path: &QPath<'_>, first: &mut bool) {
+    match *path {
+        QPath::Resolved(_, ref path) => {
+            for segment in path.segments {
+                if *first {
+                    *first = false;
+                } else {
+                    print!(", ");
+                }
+                print!("{:?}", segment.ident.as_str());
+            }
+        },
+        QPath::TypeRelative(ref ty, ref segment) => match ty.kind {
+            hir::TyKind::Path(ref inner_path) => {
+                print_path(inner_path, first);
+                if *first {
+                    *first = false;
+                } else {
+                    print!(", ");
+                }
+                print!("{:?}", segment.ident.as_str());
+            },
+            ref other => print!("/* unimplemented: {:?}*/", other),
+        },
+        QPath::LangItem(..) => panic!("print_path: called for lang item qpath"),
+    }
+}
diff --git a/clippy_utils/src/camel_case.rs b/clippy_utils/src/camel_case.rs
new file mode 100644
index 00000000000..ba1c01ebc9f
--- /dev/null
+++ b/clippy_utils/src/camel_case.rs
@@ -0,0 +1,121 @@
+/// Returns the index of the character after the first camel-case component of `s`.
+#[must_use]
+pub fn until(s: &str) -> usize {
+    let mut iter = s.char_indices();
+    if let Some((_, first)) = iter.next() {
+        if !first.is_uppercase() {
+            return 0;
+        }
+    } else {
+        return 0;
+    }
+    let mut up = true;
+    let mut last_i = 0;
+    for (i, c) in iter {
+        if up {
+            if c.is_lowercase() {
+                up = false;
+            } else {
+                return last_i;
+            }
+        } else if c.is_uppercase() {
+            up = true;
+            last_i = i;
+        } else if !c.is_lowercase() {
+            return i;
+        }
+    }
+    if up {
+        last_i
+    } else {
+        s.len()
+    }
+}
+
+/// Returns index of the last camel-case component of `s`.
+#[must_use]
+pub fn from(s: &str) -> usize {
+    let mut iter = s.char_indices().rev();
+    if let Some((_, first)) = iter.next() {
+        if !first.is_lowercase() {
+            return s.len();
+        }
+    } else {
+        return s.len();
+    }
+    let mut down = true;
+    let mut last_i = s.len();
+    for (i, c) in iter {
+        if down {
+            if c.is_uppercase() {
+                down = false;
+                last_i = i;
+            } else if !c.is_lowercase() {
+                return last_i;
+            }
+        } else if c.is_lowercase() {
+            down = true;
+        } else if c.is_uppercase() {
+            last_i = i;
+        } else {
+            return last_i;
+        }
+    }
+    last_i
+}
+
+#[cfg(test)]
+mod test {
+    use super::{from, until};
+
+    #[test]
+    fn from_full() {
+        assert_eq!(from("AbcDef"), 0);
+        assert_eq!(from("Abc"), 0);
+        assert_eq!(from("ABcd"), 0);
+        assert_eq!(from("ABcdEf"), 0);
+        assert_eq!(from("AabABcd"), 0);
+    }
+
+    #[test]
+    fn from_partial() {
+        assert_eq!(from("abcDef"), 3);
+        assert_eq!(from("aDbc"), 1);
+        assert_eq!(from("aabABcd"), 3);
+    }
+
+    #[test]
+    fn from_not() {
+        assert_eq!(from("AbcDef_"), 7);
+        assert_eq!(from("AbcDD"), 5);
+    }
+
+    #[test]
+    fn from_caps() {
+        assert_eq!(from("ABCD"), 4);
+    }
+
+    #[test]
+    fn until_full() {
+        assert_eq!(until("AbcDef"), 6);
+        assert_eq!(until("Abc"), 3);
+    }
+
+    #[test]
+    fn until_not() {
+        assert_eq!(until("abcDef"), 0);
+        assert_eq!(until("aDbc"), 0);
+    }
+
+    #[test]
+    fn until_partial() {
+        assert_eq!(until("AbcDef_"), 6);
+        assert_eq!(until("CallTypeC"), 8);
+        assert_eq!(until("AbcDD"), 3);
+    }
+
+    #[test]
+    fn until_caps() {
+        assert_eq!(until("ABCD"), 0);
+    }
+}
diff --git a/clippy_utils/src/comparisons.rs b/clippy_utils/src/comparisons.rs
new file mode 100644
index 00000000000..7a18d5e818f
--- /dev/null
+++ b/clippy_utils/src/comparisons.rs
@@ -0,0 +1,36 @@
+//! Utility functions about comparison operators.
+
+#![deny(clippy::missing_docs_in_private_items)]
+
+use rustc_hir::{BinOpKind, Expr};
+
+#[derive(PartialEq, Eq, Debug, Copy, Clone)]
+/// Represent a normalized comparison operator.
+pub enum Rel {
+    /// `<`
+    Lt,
+    /// `<=`
+    Le,
+    /// `==`
+    Eq,
+    /// `!=`
+    Ne,
+}
+
+/// Put the expression in the form  `lhs < rhs`, `lhs <= rhs`, `lhs == rhs` or
+/// `lhs != rhs`.
+pub fn normalize_comparison<'a>(
+    op: BinOpKind,
+    lhs: &'a Expr<'a>,
+    rhs: &'a Expr<'a>,
+) -> Option<(Rel, &'a Expr<'a>, &'a Expr<'a>)> {
+    match op {
+        BinOpKind::Lt => Some((Rel::Lt, lhs, rhs)),
+        BinOpKind::Le => Some((Rel::Le, lhs, rhs)),
+        BinOpKind::Gt => Some((Rel::Lt, rhs, lhs)),
+        BinOpKind::Ge => Some((Rel::Le, rhs, lhs)),
+        BinOpKind::Eq => Some((Rel::Eq, rhs, lhs)),
+        BinOpKind::Ne => Some((Rel::Ne, rhs, lhs)),
+        _ => None,
+    }
+}
diff --git a/clippy_utils/src/conf.rs b/clippy_utils/src/conf.rs
new file mode 100644
index 00000000000..7d7b35c2168
--- /dev/null
+++ b/clippy_utils/src/conf.rs
@@ -0,0 +1,257 @@
+//! Read configurations files.
+
+#![deny(clippy::missing_docs_in_private_items)]
+
+use rustc_ast::ast::{LitKind, MetaItemKind, NestedMetaItem};
+use rustc_span::source_map;
+use source_map::Span;
+use std::lazy::SyncLazy;
+use std::path::{Path, PathBuf};
+use std::sync::Mutex;
+use std::{env, fmt, fs, io};
+
+/// Gets the configuration file from arguments.
+pub fn file_from_args(args: &[NestedMetaItem]) -> Result<Option<PathBuf>, (&'static str, Span)> {
+    for arg in args.iter().filter_map(NestedMetaItem::meta_item) {
+        if arg.has_name(sym!(conf_file)) {
+            return match arg.kind {
+                MetaItemKind::Word | MetaItemKind::List(_) => Err(("`conf_file` must be a named value", arg.span)),
+                MetaItemKind::NameValue(ref value) => {
+                    if let LitKind::Str(ref file, _) = value.kind {
+                        Ok(Some(file.to_string().into()))
+                    } else {
+                        Err(("`conf_file` value must be a string", value.span))
+                    }
+                },
+            };
+        }
+    }
+
+    Ok(None)
+}
+
+/// Error from reading a configuration file.
+#[derive(Debug)]
+pub enum Error {
+    /// An I/O error.
+    Io(io::Error),
+    /// Not valid toml or doesn't fit the expected config format
+    Toml(String),
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Io(err) => err.fmt(f),
+            Self::Toml(err) => err.fmt(f),
+        }
+    }
+}
+
+impl From<io::Error> for Error {
+    fn from(e: io::Error) -> Self {
+        Self::Io(e)
+    }
+}
+
+/// Vec of errors that might be collected during config toml parsing
+static ERRORS: SyncLazy<Mutex<Vec<Error>>> = SyncLazy::new(|| Mutex::new(Vec::new()));
+
+macro_rules! define_Conf {
+    ($(#[$doc:meta] ($config:ident, $config_str:literal: $Ty:ty, $default:expr),)+) => {
+        mod helpers {
+            use serde::Deserialize;
+            /// Type used to store lint configuration.
+            #[derive(Deserialize)]
+            #[serde(rename_all = "kebab-case", deny_unknown_fields)]
+            pub struct Conf {
+                $(
+                    #[$doc]
+                    #[serde(default = $config_str)]
+                    #[serde(with = $config_str)]
+                    pub $config: $Ty,
+                )+
+                #[allow(dead_code)]
+                #[serde(default)]
+                third_party: Option<::toml::Value>,
+            }
+
+            $(
+                mod $config {
+                    use serde::Deserialize;
+                    pub fn deserialize<'de, D: serde::Deserializer<'de>>(deserializer: D) -> Result<$Ty, D::Error> {
+                        use super::super::{ERRORS, Error};
+
+                        Ok(
+                            <$Ty>::deserialize(deserializer).unwrap_or_else(|e| {
+                                ERRORS
+                                    .lock()
+                                    .expect("no threading here")
+                                    .push(Error::Toml(e.to_string()));
+                                super::$config()
+                            })
+                        )
+                    }
+                }
+
+                #[must_use]
+                fn $config() -> $Ty {
+                    let x = $default;
+                    x
+                }
+            )+
+        }
+    };
+}
+
+pub use self::helpers::Conf;
+define_Conf! {
+    /// Lint: REDUNDANT_FIELD_NAMES, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN. The minimum rust version that the project supports
+    (msrv, "msrv": Option<String>, None),
+    /// Lint: BLACKLISTED_NAME. The list of blacklisted names to lint about. NB: `bar` is not here since it has legitimate uses
+    (blacklisted_names, "blacklisted_names": Vec<String>, ["foo", "baz", "quux"].iter().map(ToString::to_string).collect()),
+    /// Lint: COGNITIVE_COMPLEXITY. The maximum cognitive complexity a function can have
+    (cognitive_complexity_threshold, "cognitive_complexity_threshold": u64, 25),
+    /// DEPRECATED LINT: CYCLOMATIC_COMPLEXITY. Use the Cognitive Complexity lint instead.
+    (cyclomatic_complexity_threshold, "cyclomatic_complexity_threshold": Option<u64>, None),
+    /// Lint: DOC_MARKDOWN. The list of words this lint should not consider as identifiers needing ticks
+    (doc_valid_idents, "doc_valid_idents": Vec<String>, [
+        "KiB", "MiB", "GiB", "TiB", "PiB", "EiB",
+        "DirectX",
+        "ECMAScript",
+        "GPLv2", "GPLv3",
+        "GitHub", "GitLab",
+        "IPv4", "IPv6",
+        "ClojureScript", "CoffeeScript", "JavaScript", "PureScript", "TypeScript",
+        "NaN", "NaNs",
+        "OAuth", "GraphQL",
+        "OCaml",
+        "OpenGL", "OpenMP", "OpenSSH", "OpenSSL", "OpenStreetMap",
+        "WebGL",
+        "TensorFlow",
+        "TrueType",
+        "iOS", "macOS",
+        "TeX", "LaTeX", "BibTeX", "BibLaTeX",
+        "MinGW",
+        "CamelCase",
+    ].iter().map(ToString::to_string).collect()),
+    /// Lint: TOO_MANY_ARGUMENTS. The maximum number of argument a function or method can have
+    (too_many_arguments_threshold, "too_many_arguments_threshold": u64, 7),
+    /// Lint: TYPE_COMPLEXITY. The maximum complexity a type can have
+    (type_complexity_threshold, "type_complexity_threshold": u64, 250),
+    /// Lint: MANY_SINGLE_CHAR_NAMES. The maximum number of single char bindings a scope may have
+    (single_char_binding_names_threshold, "single_char_binding_names_threshold": u64, 4),
+    /// Lint: BOXED_LOCAL, USELESS_VEC. The maximum size of objects (in bytes) that will be linted. Larger objects are ok on the heap
+    (too_large_for_stack, "too_large_for_stack": u64, 200),
+    /// Lint: ENUM_VARIANT_NAMES. The minimum number of enum variants for the lints about variant names to trigger
+    (enum_variant_name_threshold, "enum_variant_name_threshold": u64, 3),
+    /// Lint: LARGE_ENUM_VARIANT. The maximum size of a enum's variant to avoid box suggestion
+    (enum_variant_size_threshold, "enum_variant_size_threshold": u64, 200),
+    /// Lint: VERBOSE_BIT_MASK. The maximum allowed size of a bit mask before suggesting to use 'trailing_zeros'
+    (verbose_bit_mask_threshold, "verbose_bit_mask_threshold": u64, 1),
+    /// Lint: DECIMAL_LITERAL_REPRESENTATION. The lower bound for linting decimal literals
+    (literal_representation_threshold, "literal_representation_threshold": u64, 16384),
+    /// Lint: TRIVIALLY_COPY_PASS_BY_REF. The maximum size (in bytes) to consider a `Copy` type for passing by value instead of by reference.
+    (trivial_copy_size_limit, "trivial_copy_size_limit": Option<u64>, None),
+    /// Lint: LARGE_TYPE_PASS_BY_MOVE. The minimum size (in bytes) to consider a type for passing by reference instead of by value.
+    (pass_by_value_size_limit, "pass_by_value_size_limit": u64, 256),
+    /// Lint: TOO_MANY_LINES. The maximum number of lines a function or method can have
+    (too_many_lines_threshold, "too_many_lines_threshold": u64, 100),
+    /// Lint: LARGE_STACK_ARRAYS, LARGE_CONST_ARRAYS. The maximum allowed size for arrays on the stack
+    (array_size_threshold, "array_size_threshold": u64, 512_000),
+    /// Lint: VEC_BOX. The size of the boxed type in bytes, where boxing in a `Vec` is allowed
+    (vec_box_size_threshold, "vec_box_size_threshold": u64, 4096),
+    /// Lint: TYPE_REPETITION_IN_BOUNDS. The maximum number of bounds a trait can have to be linted
+    (max_trait_bounds, "max_trait_bounds": u64, 3),
+    /// Lint: STRUCT_EXCESSIVE_BOOLS. The maximum number of bools a struct can have
+    (max_struct_bools, "max_struct_bools": u64, 3),
+    /// Lint: FN_PARAMS_EXCESSIVE_BOOLS. The maximum number of bools function parameters can have
+    (max_fn_params_bools, "max_fn_params_bools": u64, 3),
+    /// Lint: WILDCARD_IMPORTS. Whether to allow certain wildcard imports (prelude, super in tests).
+    (warn_on_all_wildcard_imports, "warn_on_all_wildcard_imports": bool, false),
+    /// Lint: DISALLOWED_METHOD. The list of disallowed methods, written as fully qualified paths.
+    (disallowed_methods, "disallowed_methods": Vec<String>, Vec::<String>::new()),
+    /// Lint: UNREADABLE_LITERAL. Should the fraction of a decimal be linted to include separators.
+    (unreadable_literal_lint_fractions, "unreadable_literal_lint_fractions": bool, true),
+    /// Lint: _CARGO_COMMON_METADATA. For internal testing only, ignores the current `publish` settings in the Cargo manifest.
+    (cargo_ignore_publish, "cargo_ignore_publish": bool, false),
+}
+
+impl Default for Conf {
+    #[must_use]
+    fn default() -> Self {
+        toml::from_str("").expect("we never error on empty config files")
+    }
+}
+
+/// Search for the configuration file.
+pub fn lookup_conf_file() -> io::Result<Option<PathBuf>> {
+    /// Possible filename to search for.
+    const CONFIG_FILE_NAMES: [&str; 2] = [".clippy.toml", "clippy.toml"];
+
+    // Start looking for a config file in CLIPPY_CONF_DIR, or failing that, CARGO_MANIFEST_DIR.
+    // If neither of those exist, use ".".
+    let mut current = env::var_os("CLIPPY_CONF_DIR")
+        .or_else(|| env::var_os("CARGO_MANIFEST_DIR"))
+        .map_or_else(|| PathBuf::from("."), PathBuf::from);
+    loop {
+        for config_file_name in &CONFIG_FILE_NAMES {
+            let config_file = current.join(config_file_name);
+            match fs::metadata(&config_file) {
+                // Only return if it's a file to handle the unlikely situation of a directory named
+                // `clippy.toml`.
+                Ok(ref md) if !md.is_dir() => return Ok(Some(config_file)),
+                // Return the error if it's something other than `NotFound`; otherwise we didn't
+                // find the project file yet, and continue searching.
+                Err(e) if e.kind() != io::ErrorKind::NotFound => return Err(e),
+                _ => {},
+            }
+        }
+
+        // If the current directory has no parent, we're done searching.
+        if !current.pop() {
+            return Ok(None);
+        }
+    }
+}
+
+/// Produces a `Conf` filled with the default values and forwards the errors
+///
+/// Used internally for convenience
+fn default(errors: Vec<Error>) -> (Conf, Vec<Error>) {
+    (Conf::default(), errors)
+}
+
+/// Read the `toml` configuration file.
+///
+/// In case of error, the function tries to continue as much as possible.
+pub fn read(path: &Path) -> (Conf, Vec<Error>) {
+    let content = match fs::read_to_string(path) {
+        Ok(content) => content,
+        Err(err) => return default(vec![err.into()]),
+    };
+
+    assert!(ERRORS.lock().expect("no threading -> mutex always safe").is_empty());
+    match toml::from_str(&content) {
+        Ok(toml) => {
+            let mut errors = ERRORS.lock().expect("no threading -> mutex always safe").split_off(0);
+
+            let toml_ref: &Conf = &toml;
+
+            let cyc_field: Option<u64> = toml_ref.cyclomatic_complexity_threshold;
+
+            if cyc_field.is_some() {
+                let cyc_err = "found deprecated field `cyclomatic-complexity-threshold`. Please use `cognitive-complexity-threshold` instead.".to_string();
+                errors.push(Error::Toml(cyc_err));
+            }
+
+            (toml, errors)
+        },
+        Err(e) => {
+            let mut errors = ERRORS.lock().expect("no threading -> mutex always safe").split_off(0);
+            errors.push(Error::Toml(e.to_string()));
+
+            default(errors)
+        },
+    }
+}
diff --git a/clippy_utils/src/constants.rs b/clippy_utils/src/constants.rs
new file mode 100644
index 00000000000..522932f054d
--- /dev/null
+++ b/clippy_utils/src/constants.rs
@@ -0,0 +1,13 @@
+//! This module contains some useful constants.
+
+#![deny(clippy::missing_docs_in_private_items)]
+
+/// List of the built-in types names.
+///
+/// See also [the reference][reference-types] for a list of such types.
+///
+/// [reference-types]: https://doc.rust-lang.org/reference/types.html
+pub const BUILTIN_TYPES: &[&str] = &[
+    "i8", "u8", "i16", "u16", "i32", "u32", "i64", "u64", "i128", "u128", "isize", "usize", "f32", "f64", "bool",
+    "str", "char",
+];
diff --git a/clippy_utils/src/consts.rs b/clippy_utils/src/consts.rs
new file mode 100644
index 00000000000..802c01055a6
--- /dev/null
+++ b/clippy_utils/src/consts.rs
@@ -0,0 +1,574 @@
+#![allow(clippy::float_cmp)]
+
+use crate::{clip, sext, unsext};
+use if_chain::if_chain;
+use rustc_ast::ast::{self, LitFloatType, LitKind};
+use rustc_data_structures::sync::Lrc;
+use rustc_hir::def::{DefKind, Res};
+use rustc_hir::{BinOp, BinOpKind, Block, Expr, ExprKind, HirId, QPath, UnOp};
+use rustc_lint::LateContext;
+use rustc_middle::mir::interpret::Scalar;
+use rustc_middle::ty::subst::{Subst, SubstsRef};
+use rustc_middle::ty::{self, FloatTy, ScalarInt, Ty, TyCtxt};
+use rustc_middle::{bug, span_bug};
+use rustc_span::symbol::Symbol;
+use std::cmp::Ordering::{self, Equal};
+use std::convert::TryInto;
+use std::hash::{Hash, Hasher};
+
+/// A `LitKind`-like enum to fold constant `Expr`s into.
+#[derive(Debug, Clone)]
+pub enum Constant {
+    /// A `String` (e.g., "abc").
+    Str(String),
+    /// A binary string (e.g., `b"abc"`).
+    Binary(Lrc<[u8]>),
+    /// A single `char` (e.g., `'a'`).
+    Char(char),
+    /// An integer's bit representation.
+    Int(u128),
+    /// An `f32`.
+    F32(f32),
+    /// An `f64`.
+    F64(f64),
+    /// `true` or `false`.
+    Bool(bool),
+    /// An array of constants.
+    Vec(Vec<Constant>),
+    /// Also an array, but with only one constant, repeated N times.
+    Repeat(Box<Constant>, u64),
+    /// A tuple of constants.
+    Tuple(Vec<Constant>),
+    /// A raw pointer.
+    RawPtr(u128),
+    /// A reference
+    Ref(Box<Constant>),
+    /// A literal with syntax error.
+    Err(Symbol),
+}
+
+impl PartialEq for Constant {
+    fn eq(&self, other: &Self) -> bool {
+        match (self, other) {
+            (&Self::Str(ref ls), &Self::Str(ref rs)) => ls == rs,
+            (&Self::Binary(ref l), &Self::Binary(ref r)) => l == r,
+            (&Self::Char(l), &Self::Char(r)) => l == r,
+            (&Self::Int(l), &Self::Int(r)) => l == r,
+            (&Self::F64(l), &Self::F64(r)) => {
+                // We want `Fw32 == FwAny` and `FwAny == Fw64`, and by transitivity we must have
+                // `Fw32 == Fw64`, so don’t compare them.
+                // `to_bits` is required to catch non-matching 0.0, -0.0, and NaNs.
+                l.to_bits() == r.to_bits()
+            },
+            (&Self::F32(l), &Self::F32(r)) => {
+                // We want `Fw32 == FwAny` and `FwAny == Fw64`, and by transitivity we must have
+                // `Fw32 == Fw64`, so don’t compare them.
+                // `to_bits` is required to catch non-matching 0.0, -0.0, and NaNs.
+                f64::from(l).to_bits() == f64::from(r).to_bits()
+            },
+            (&Self::Bool(l), &Self::Bool(r)) => l == r,
+            (&Self::Vec(ref l), &Self::Vec(ref r)) | (&Self::Tuple(ref l), &Self::Tuple(ref r)) => l == r,
+            (&Self::Repeat(ref lv, ref ls), &Self::Repeat(ref rv, ref rs)) => ls == rs && lv == rv,
+            (&Self::Ref(ref lb), &Self::Ref(ref rb)) => *lb == *rb,
+            // TODO: are there inter-type equalities?
+            _ => false,
+        }
+    }
+}
+
+impl Hash for Constant {
+    fn hash<H>(&self, state: &mut H)
+    where
+        H: Hasher,
+    {
+        std::mem::discriminant(self).hash(state);
+        match *self {
+            Self::Str(ref s) => {
+                s.hash(state);
+            },
+            Self::Binary(ref b) => {
+                b.hash(state);
+            },
+            Self::Char(c) => {
+                c.hash(state);
+            },
+            Self::Int(i) => {
+                i.hash(state);
+            },
+            Self::F32(f) => {
+                f64::from(f).to_bits().hash(state);
+            },
+            Self::F64(f) => {
+                f.to_bits().hash(state);
+            },
+            Self::Bool(b) => {
+                b.hash(state);
+            },
+            Self::Vec(ref v) | Self::Tuple(ref v) => {
+                v.hash(state);
+            },
+            Self::Repeat(ref c, l) => {
+                c.hash(state);
+                l.hash(state);
+            },
+            Self::RawPtr(u) => {
+                u.hash(state);
+            },
+            Self::Ref(ref r) => {
+                r.hash(state);
+            },
+            Self::Err(ref s) => {
+                s.hash(state);
+            },
+        }
+    }
+}
+
+impl Constant {
+    pub fn partial_cmp(tcx: TyCtxt<'_>, cmp_type: Ty<'_>, left: &Self, right: &Self) -> Option<Ordering> {
+        match (left, right) {
+            (&Self::Str(ref ls), &Self::Str(ref rs)) => Some(ls.cmp(rs)),
+            (&Self::Char(ref l), &Self::Char(ref r)) => Some(l.cmp(r)),
+            (&Self::Int(l), &Self::Int(r)) => {
+                if let ty::Int(int_ty) = *cmp_type.kind() {
+                    Some(sext(tcx, l, int_ty).cmp(&sext(tcx, r, int_ty)))
+                } else {
+                    Some(l.cmp(&r))
+                }
+            },
+            (&Self::F64(l), &Self::F64(r)) => l.partial_cmp(&r),
+            (&Self::F32(l), &Self::F32(r)) => l.partial_cmp(&r),
+            (&Self::Bool(ref l), &Self::Bool(ref r)) => Some(l.cmp(r)),
+            (&Self::Tuple(ref l), &Self::Tuple(ref r)) | (&Self::Vec(ref l), &Self::Vec(ref r)) => l
+                .iter()
+                .zip(r.iter())
+                .map(|(li, ri)| Self::partial_cmp(tcx, cmp_type, li, ri))
+                .find(|r| r.map_or(true, |o| o != Ordering::Equal))
+                .unwrap_or_else(|| Some(l.len().cmp(&r.len()))),
+            (&Self::Repeat(ref lv, ref ls), &Self::Repeat(ref rv, ref rs)) => {
+                match Self::partial_cmp(tcx, cmp_type, lv, rv) {
+                    Some(Equal) => Some(ls.cmp(rs)),
+                    x => x,
+                }
+            },
+            (&Self::Ref(ref lb), &Self::Ref(ref rb)) => Self::partial_cmp(tcx, cmp_type, lb, rb),
+            // TODO: are there any useful inter-type orderings?
+            _ => None,
+        }
+    }
+}
+
+/// Parses a `LitKind` to a `Constant`.
+pub fn lit_to_constant(lit: &LitKind, ty: Option<Ty<'_>>) -> Constant {
+    match *lit {
+        LitKind::Str(ref is, _) => Constant::Str(is.to_string()),
+        LitKind::Byte(b) => Constant::Int(u128::from(b)),
+        LitKind::ByteStr(ref s) => Constant::Binary(Lrc::clone(s)),
+        LitKind::Char(c) => Constant::Char(c),
+        LitKind::Int(n, _) => Constant::Int(n),
+        LitKind::Float(ref is, LitFloatType::Suffixed(fty)) => match fty {
+            ast::FloatTy::F32 => Constant::F32(is.as_str().parse().unwrap()),
+            ast::FloatTy::F64 => Constant::F64(is.as_str().parse().unwrap()),
+        },
+        LitKind::Float(ref is, LitFloatType::Unsuffixed) => match ty.expect("type of float is known").kind() {
+            ty::Float(FloatTy::F32) => Constant::F32(is.as_str().parse().unwrap()),
+            ty::Float(FloatTy::F64) => Constant::F64(is.as_str().parse().unwrap()),
+            _ => bug!(),
+        },
+        LitKind::Bool(b) => Constant::Bool(b),
+        LitKind::Err(s) => Constant::Err(s),
+    }
+}
+
+pub fn constant<'tcx>(
+    lcx: &LateContext<'tcx>,
+    typeck_results: &ty::TypeckResults<'tcx>,
+    e: &Expr<'_>,
+) -> Option<(Constant, bool)> {
+    let mut cx = ConstEvalLateContext {
+        lcx,
+        typeck_results,
+        param_env: lcx.param_env,
+        needed_resolution: false,
+        substs: lcx.tcx.intern_substs(&[]),
+    };
+    cx.expr(e).map(|cst| (cst, cx.needed_resolution))
+}
+
+pub fn constant_simple<'tcx>(
+    lcx: &LateContext<'tcx>,
+    typeck_results: &ty::TypeckResults<'tcx>,
+    e: &Expr<'_>,
+) -> Option<Constant> {
+    constant(lcx, typeck_results, e).and_then(|(cst, res)| if res { None } else { Some(cst) })
+}
+
+/// Creates a `ConstEvalLateContext` from the given `LateContext` and `TypeckResults`.
+pub fn constant_context<'a, 'tcx>(
+    lcx: &'a LateContext<'tcx>,
+    typeck_results: &'a ty::TypeckResults<'tcx>,
+) -> ConstEvalLateContext<'a, 'tcx> {
+    ConstEvalLateContext {
+        lcx,
+        typeck_results,
+        param_env: lcx.param_env,
+        needed_resolution: false,
+        substs: lcx.tcx.intern_substs(&[]),
+    }
+}
+
+pub struct ConstEvalLateContext<'a, 'tcx> {
+    lcx: &'a LateContext<'tcx>,
+    typeck_results: &'a ty::TypeckResults<'tcx>,
+    param_env: ty::ParamEnv<'tcx>,
+    needed_resolution: bool,
+    substs: SubstsRef<'tcx>,
+}
+
+impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
+    /// Simple constant folding: Insert an expression, get a constant or none.
+    pub fn expr(&mut self, e: &Expr<'_>) -> Option<Constant> {
+        match e.kind {
+            ExprKind::Path(ref qpath) => self.fetch_path(qpath, e.hir_id, self.typeck_results.expr_ty(e)),
+            ExprKind::Block(ref block, _) => self.block(block),
+            ExprKind::Lit(ref lit) => Some(lit_to_constant(&lit.node, self.typeck_results.expr_ty_opt(e))),
+            ExprKind::Array(ref vec) => self.multi(vec).map(Constant::Vec),
+            ExprKind::Tup(ref tup) => self.multi(tup).map(Constant::Tuple),
+            ExprKind::Repeat(ref value, _) => {
+                let n = match self.typeck_results.expr_ty(e).kind() {
+                    ty::Array(_, n) => n.try_eval_usize(self.lcx.tcx, self.lcx.param_env)?,
+                    _ => span_bug!(e.span, "typeck error"),
+                };
+                self.expr(value).map(|v| Constant::Repeat(Box::new(v), n))
+            },
+            ExprKind::Unary(op, ref operand) => self.expr(operand).and_then(|o| match op {
+                UnOp::Not => self.constant_not(&o, self.typeck_results.expr_ty(e)),
+                UnOp::Neg => self.constant_negate(&o, self.typeck_results.expr_ty(e)),
+                UnOp::Deref => Some(if let Constant::Ref(r) = o { *r } else { o }),
+            }),
+            ExprKind::If(ref cond, ref then, ref otherwise) => self.ifthenelse(cond, then, *otherwise),
+            ExprKind::Binary(op, ref left, ref right) => self.binop(op, left, right),
+            ExprKind::Call(ref callee, ref args) => {
+                // We only handle a few const functions for now.
+                if_chain! {
+                    if args.is_empty();
+                    if let ExprKind::Path(qpath) = &callee.kind;
+                    let res = self.typeck_results.qpath_res(qpath, callee.hir_id);
+                    if let Some(def_id) = res.opt_def_id();
+                    let def_path: Vec<_> = self.lcx.get_def_path(def_id).into_iter().map(Symbol::as_str).collect();
+                    let def_path: Vec<&str> = def_path.iter().take(4).map(|s| &**s).collect();
+                    if let ["core", "num", int_impl, "max_value"] = *def_path;
+                    then {
+                       let value = match int_impl {
+                           "<impl i8>" => i8::MAX as u128,
+                           "<impl i16>" => i16::MAX as u128,
+                           "<impl i32>" => i32::MAX as u128,
+                           "<impl i64>" => i64::MAX as u128,
+                           "<impl i128>" => i128::MAX as u128,
+                           _ => return None,
+                       };
+                       Some(Constant::Int(value))
+                    }
+                    else {
+                        None
+                    }
+                }
+            },
+            ExprKind::Index(ref arr, ref index) => self.index(arr, index),
+            ExprKind::AddrOf(_, _, ref inner) => self.expr(inner).map(|r| Constant::Ref(Box::new(r))),
+            // TODO: add other expressions.
+            _ => None,
+        }
+    }
+
+    #[allow(clippy::cast_possible_wrap)]
+    fn constant_not(&self, o: &Constant, ty: Ty<'_>) -> Option<Constant> {
+        use self::Constant::{Bool, Int};
+        match *o {
+            Bool(b) => Some(Bool(!b)),
+            Int(value) => {
+                let value = !value;
+                match *ty.kind() {
+                    ty::Int(ity) => Some(Int(unsext(self.lcx.tcx, value as i128, ity))),
+                    ty::Uint(ity) => Some(Int(clip(self.lcx.tcx, value, ity))),
+                    _ => None,
+                }
+            },
+            _ => None,
+        }
+    }
+
+    fn constant_negate(&self, o: &Constant, ty: Ty<'_>) -> Option<Constant> {
+        use self::Constant::{Int, F32, F64};
+        match *o {
+            Int(value) => {
+                let ity = match *ty.kind() {
+                    ty::Int(ity) => ity,
+                    _ => return None,
+                };
+                // sign extend
+                let value = sext(self.lcx.tcx, value, ity);
+                let value = value.checked_neg()?;
+                // clear unused bits
+                Some(Int(unsext(self.lcx.tcx, value, ity)))
+            },
+            F32(f) => Some(F32(-f)),
+            F64(f) => Some(F64(-f)),
+            _ => None,
+        }
+    }
+
+    /// Create `Some(Vec![..])` of all constants, unless there is any
+    /// non-constant part.
+    fn multi(&mut self, vec: &[Expr<'_>]) -> Option<Vec<Constant>> {
+        vec.iter().map(|elem| self.expr(elem)).collect::<Option<_>>()
+    }
+
+    /// Lookup a possibly constant expression from a `ExprKind::Path`.
+    fn fetch_path(&mut self, qpath: &QPath<'_>, id: HirId, ty: Ty<'tcx>) -> Option<Constant> {
+        let res = self.typeck_results.qpath_res(qpath, id);
+        match res {
+            Res::Def(DefKind::Const | DefKind::AssocConst, def_id) => {
+                let substs = self.typeck_results.node_substs(id);
+                let substs = if self.substs.is_empty() {
+                    substs
+                } else {
+                    substs.subst(self.lcx.tcx, self.substs)
+                };
+
+                let result = self
+                    .lcx
+                    .tcx
+                    .const_eval_resolve(
+                        self.param_env,
+                        ty::WithOptConstParam::unknown(def_id),
+                        substs,
+                        None,
+                        None,
+                    )
+                    .ok()
+                    .map(|val| rustc_middle::ty::Const::from_value(self.lcx.tcx, val, ty))?;
+                let result = miri_to_const(&result);
+                if result.is_some() {
+                    self.needed_resolution = true;
+                }
+                result
+            },
+            // FIXME: cover all usable cases.
+            _ => None,
+        }
+    }
+
+    fn index(&mut self, lhs: &'_ Expr<'_>, index: &'_ Expr<'_>) -> Option<Constant> {
+        let lhs = self.expr(lhs);
+        let index = self.expr(index);
+
+        match (lhs, index) {
+            (Some(Constant::Vec(vec)), Some(Constant::Int(index))) => match vec.get(index as usize) {
+                Some(Constant::F32(x)) => Some(Constant::F32(*x)),
+                Some(Constant::F64(x)) => Some(Constant::F64(*x)),
+                _ => None,
+            },
+            (Some(Constant::Vec(vec)), _) => {
+                if !vec.is_empty() && vec.iter().all(|x| *x == vec[0]) {
+                    match vec.get(0) {
+                        Some(Constant::F32(x)) => Some(Constant::F32(*x)),
+                        Some(Constant::F64(x)) => Some(Constant::F64(*x)),
+                        _ => None,
+                    }
+                } else {
+                    None
+                }
+            },
+            _ => None,
+        }
+    }
+
+    /// A block can only yield a constant if it only has one constant expression.
+    fn block(&mut self, block: &Block<'_>) -> Option<Constant> {
+        if block.stmts.is_empty() {
+            block.expr.as_ref().and_then(|b| self.expr(b))
+        } else {
+            None
+        }
+    }
+
+    fn ifthenelse(&mut self, cond: &Expr<'_>, then: &Expr<'_>, otherwise: Option<&Expr<'_>>) -> Option<Constant> {
+        if let Some(Constant::Bool(b)) = self.expr(cond) {
+            if b {
+                self.expr(&*then)
+            } else {
+                otherwise.as_ref().and_then(|expr| self.expr(expr))
+            }
+        } else {
+            None
+        }
+    }
+
+    fn binop(&mut self, op: BinOp, left: &Expr<'_>, right: &Expr<'_>) -> Option<Constant> {
+        let l = self.expr(left)?;
+        let r = self.expr(right);
+        match (l, r) {
+            (Constant::Int(l), Some(Constant::Int(r))) => match *self.typeck_results.expr_ty_opt(left)?.kind() {
+                ty::Int(ity) => {
+                    let l = sext(self.lcx.tcx, l, ity);
+                    let r = sext(self.lcx.tcx, r, ity);
+                    let zext = |n: i128| Constant::Int(unsext(self.lcx.tcx, n, ity));
+                    match op.node {
+                        BinOpKind::Add => l.checked_add(r).map(zext),
+                        BinOpKind::Sub => l.checked_sub(r).map(zext),
+                        BinOpKind::Mul => l.checked_mul(r).map(zext),
+                        BinOpKind::Div if r != 0 => l.checked_div(r).map(zext),
+                        BinOpKind::Rem if r != 0 => l.checked_rem(r).map(zext),
+                        BinOpKind::Shr => l.checked_shr(r.try_into().expect("invalid shift")).map(zext),
+                        BinOpKind::Shl => l.checked_shl(r.try_into().expect("invalid shift")).map(zext),
+                        BinOpKind::BitXor => Some(zext(l ^ r)),
+                        BinOpKind::BitOr => Some(zext(l | r)),
+                        BinOpKind::BitAnd => Some(zext(l & r)),
+                        BinOpKind::Eq => Some(Constant::Bool(l == r)),
+                        BinOpKind::Ne => Some(Constant::Bool(l != r)),
+                        BinOpKind::Lt => Some(Constant::Bool(l < r)),
+                        BinOpKind::Le => Some(Constant::Bool(l <= r)),
+                        BinOpKind::Ge => Some(Constant::Bool(l >= r)),
+                        BinOpKind::Gt => Some(Constant::Bool(l > r)),
+                        _ => None,
+                    }
+                },
+                ty::Uint(_) => match op.node {
+                    BinOpKind::Add => l.checked_add(r).map(Constant::Int),
+                    BinOpKind::Sub => l.checked_sub(r).map(Constant::Int),
+                    BinOpKind::Mul => l.checked_mul(r).map(Constant::Int),
+                    BinOpKind::Div => l.checked_div(r).map(Constant::Int),
+                    BinOpKind::Rem => l.checked_rem(r).map(Constant::Int),
+                    BinOpKind::Shr => l.checked_shr(r.try_into().expect("shift too large")).map(Constant::Int),
+                    BinOpKind::Shl => l.checked_shl(r.try_into().expect("shift too large")).map(Constant::Int),
+                    BinOpKind::BitXor => Some(Constant::Int(l ^ r)),
+                    BinOpKind::BitOr => Some(Constant::Int(l | r)),
+                    BinOpKind::BitAnd => Some(Constant::Int(l & r)),
+                    BinOpKind::Eq => Some(Constant::Bool(l == r)),
+                    BinOpKind::Ne => Some(Constant::Bool(l != r)),
+                    BinOpKind::Lt => Some(Constant::Bool(l < r)),
+                    BinOpKind::Le => Some(Constant::Bool(l <= r)),
+                    BinOpKind::Ge => Some(Constant::Bool(l >= r)),
+                    BinOpKind::Gt => Some(Constant::Bool(l > r)),
+                    _ => None,
+                },
+                _ => None,
+            },
+            (Constant::F32(l), Some(Constant::F32(r))) => match op.node {
+                BinOpKind::Add => Some(Constant::F32(l + r)),
+                BinOpKind::Sub => Some(Constant::F32(l - r)),
+                BinOpKind::Mul => Some(Constant::F32(l * r)),
+                BinOpKind::Div => Some(Constant::F32(l / r)),
+                BinOpKind::Rem => Some(Constant::F32(l % r)),
+                BinOpKind::Eq => Some(Constant::Bool(l == r)),
+                BinOpKind::Ne => Some(Constant::Bool(l != r)),
+                BinOpKind::Lt => Some(Constant::Bool(l < r)),
+                BinOpKind::Le => Some(Constant::Bool(l <= r)),
+                BinOpKind::Ge => Some(Constant::Bool(l >= r)),
+                BinOpKind::Gt => Some(Constant::Bool(l > r)),
+                _ => None,
+            },
+            (Constant::F64(l), Some(Constant::F64(r))) => match op.node {
+                BinOpKind::Add => Some(Constant::F64(l + r)),
+                BinOpKind::Sub => Some(Constant::F64(l - r)),
+                BinOpKind::Mul => Some(Constant::F64(l * r)),
+                BinOpKind::Div => Some(Constant::F64(l / r)),
+                BinOpKind::Rem => Some(Constant::F64(l % r)),
+                BinOpKind::Eq => Some(Constant::Bool(l == r)),
+                BinOpKind::Ne => Some(Constant::Bool(l != r)),
+                BinOpKind::Lt => Some(Constant::Bool(l < r)),
+                BinOpKind::Le => Some(Constant::Bool(l <= r)),
+                BinOpKind::Ge => Some(Constant::Bool(l >= r)),
+                BinOpKind::Gt => Some(Constant::Bool(l > r)),
+                _ => None,
+            },
+            (l, r) => match (op.node, l, r) {
+                (BinOpKind::And, Constant::Bool(false), _) => Some(Constant::Bool(false)),
+                (BinOpKind::Or, Constant::Bool(true), _) => Some(Constant::Bool(true)),
+                (BinOpKind::And, Constant::Bool(true), Some(r)) | (BinOpKind::Or, Constant::Bool(false), Some(r)) => {
+                    Some(r)
+                },
+                (BinOpKind::BitXor, Constant::Bool(l), Some(Constant::Bool(r))) => Some(Constant::Bool(l ^ r)),
+                (BinOpKind::BitAnd, Constant::Bool(l), Some(Constant::Bool(r))) => Some(Constant::Bool(l & r)),
+                (BinOpKind::BitOr, Constant::Bool(l), Some(Constant::Bool(r))) => Some(Constant::Bool(l | r)),
+                _ => None,
+            },
+        }
+    }
+}
+
+pub fn miri_to_const(result: &ty::Const<'_>) -> Option<Constant> {
+    use rustc_middle::mir::interpret::ConstValue;
+    match result.val {
+        ty::ConstKind::Value(ConstValue::Scalar(Scalar::Int(int))) => {
+            match result.ty.kind() {
+                ty::Bool => Some(Constant::Bool(int == ScalarInt::TRUE)),
+                ty::Uint(_) | ty::Int(_) => Some(Constant::Int(int.assert_bits(int.size()))),
+                ty::Float(FloatTy::F32) => Some(Constant::F32(f32::from_bits(
+                    int.try_into().expect("invalid f32 bit representation"),
+                ))),
+                ty::Float(FloatTy::F64) => Some(Constant::F64(f64::from_bits(
+                    int.try_into().expect("invalid f64 bit representation"),
+                ))),
+                ty::RawPtr(type_and_mut) => {
+                    if let ty::Uint(_) = type_and_mut.ty.kind() {
+                        return Some(Constant::RawPtr(int.assert_bits(int.size())));
+                    }
+                    None
+                },
+                // FIXME: implement other conversions.
+                _ => None,
+            }
+        },
+        ty::ConstKind::Value(ConstValue::Slice { data, start, end }) => match result.ty.kind() {
+            ty::Ref(_, tam, _) => match tam.kind() {
+                ty::Str => String::from_utf8(
+                    data.inspect_with_uninit_and_ptr_outside_interpreter(start..end)
+                        .to_owned(),
+                )
+                .ok()
+                .map(Constant::Str),
+                _ => None,
+            },
+            _ => None,
+        },
+        ty::ConstKind::Value(ConstValue::ByRef { alloc, offset: _ }) => match result.ty.kind() {
+            ty::Array(sub_type, len) => match sub_type.kind() {
+                ty::Float(FloatTy::F32) => match miri_to_const(len) {
+                    Some(Constant::Int(len)) => alloc
+                        .inspect_with_uninit_and_ptr_outside_interpreter(0..(4 * len as usize))
+                        .to_owned()
+                        .chunks(4)
+                        .map(|chunk| {
+                            Some(Constant::F32(f32::from_le_bytes(
+                                chunk.try_into().expect("this shouldn't happen"),
+                            )))
+                        })
+                        .collect::<Option<Vec<Constant>>>()
+                        .map(Constant::Vec),
+                    _ => None,
+                },
+                ty::Float(FloatTy::F64) => match miri_to_const(len) {
+                    Some(Constant::Int(len)) => alloc
+                        .inspect_with_uninit_and_ptr_outside_interpreter(0..(8 * len as usize))
+                        .to_owned()
+                        .chunks(8)
+                        .map(|chunk| {
+                            Some(Constant::F64(f64::from_le_bytes(
+                                chunk.try_into().expect("this shouldn't happen"),
+                            )))
+                        })
+                        .collect::<Option<Vec<Constant>>>()
+                        .map(Constant::Vec),
+                    _ => None,
+                },
+                // FIXME: implement other array type conversions.
+                _ => None,
+            },
+            _ => None,
+        },
+        // FIXME: implement other conversions.
+        _ => None,
+    }
+}
diff --git a/clippy_utils/src/diagnostics.rs b/clippy_utils/src/diagnostics.rs
new file mode 100644
index 00000000000..269be217c2d
--- /dev/null
+++ b/clippy_utils/src/diagnostics.rs
@@ -0,0 +1,226 @@
+//! Clippy wrappers around rustc's diagnostic functions.
+
+use rustc_errors::{Applicability, DiagnosticBuilder};
+use rustc_hir::HirId;
+use rustc_lint::{LateContext, Lint, LintContext};
+use rustc_span::source_map::{MultiSpan, Span};
+use std::env;
+
+fn docs_link(diag: &mut DiagnosticBuilder<'_>, lint: &'static Lint) {
+    if env::var("CLIPPY_DISABLE_DOCS_LINKS").is_err() {
+        diag.help(&format!(
+            "for further information visit https://rust-lang.github.io/rust-clippy/{}/index.html#{}",
+            &option_env!("RUST_RELEASE_NUM").map_or("master".to_string(), |n| {
+                // extract just major + minor version and ignore patch versions
+                format!("rust-{}", n.rsplitn(2, '.').nth(1).unwrap())
+            }),
+            lint.name_lower().replacen("clippy::", "", 1)
+        ));
+    }
+}
+
+/// Emit a basic lint message with a `msg` and a `span`.
+///
+/// This is the most primitive of our lint emission methods and can
+/// be a good way to get a new lint started.
+///
+/// Usually it's nicer to provide more context for lint messages.
+/// Be sure the output is understandable when you use this method.
+///
+/// # Example
+///
+/// ```ignore
+/// error: usage of mem::forget on Drop type
+///   --> $DIR/mem_forget.rs:17:5
+///    |
+/// 17 |     std::mem::forget(seven);
+///    |     ^^^^^^^^^^^^^^^^^^^^^^^
+/// ```
+pub fn span_lint<T: LintContext>(cx: &T, lint: &'static Lint, sp: impl Into<MultiSpan>, msg: &str) {
+    cx.struct_span_lint(lint, sp, |diag| {
+        let mut diag = diag.build(msg);
+        docs_link(&mut diag, lint);
+        diag.emit();
+    });
+}
+
+/// Same as `span_lint` but with an extra `help` message.
+///
+/// Use this if you want to provide some general help but
+/// can't provide a specific machine applicable suggestion.
+///
+/// The `help` message can be optionally attached to a `Span`.
+///
+/// If you change the signature, remember to update the internal lint `CollapsibleCalls`
+///
+/// # Example
+///
+/// ```ignore
+/// error: constant division of 0.0 with 0.0 will always result in NaN
+///   --> $DIR/zero_div_zero.rs:6:25
+///    |
+/// 6  |     let other_f64_nan = 0.0f64 / 0.0;
+///    |                         ^^^^^^^^^^^^
+///    |
+///    = help: Consider using `f64::NAN` if you would like a constant representing NaN
+/// ```
+pub fn span_lint_and_help<'a, T: LintContext>(
+    cx: &'a T,
+    lint: &'static Lint,
+    span: Span,
+    msg: &str,
+    help_span: Option<Span>,
+    help: &str,
+) {
+    cx.struct_span_lint(lint, span, |diag| {
+        let mut diag = diag.build(msg);
+        if let Some(help_span) = help_span {
+            diag.span_help(help_span, help);
+        } else {
+            diag.help(help);
+        }
+        docs_link(&mut diag, lint);
+        diag.emit();
+    });
+}
+
+/// Like `span_lint` but with a `note` section instead of a `help` message.
+///
+/// The `note` message is presented separately from the main lint message
+/// and is attached to a specific span:
+///
+/// If you change the signature, remember to update the internal lint `CollapsibleCalls`
+///
+/// # Example
+///
+/// ```ignore
+/// error: calls to `std::mem::forget` with a reference instead of an owned value. Forgetting a reference does nothing.
+///   --> $DIR/drop_forget_ref.rs:10:5
+///    |
+/// 10 |     forget(&SomeStruct);
+///    |     ^^^^^^^^^^^^^^^^^^^
+///    |
+///    = note: `-D clippy::forget-ref` implied by `-D warnings`
+/// note: argument has type &SomeStruct
+///   --> $DIR/drop_forget_ref.rs:10:12
+///    |
+/// 10 |     forget(&SomeStruct);
+///    |            ^^^^^^^^^^^
+/// ```
+pub fn span_lint_and_note<'a, T: LintContext>(
+    cx: &'a T,
+    lint: &'static Lint,
+    span: impl Into<MultiSpan>,
+    msg: &str,
+    note_span: Option<Span>,
+    note: &str,
+) {
+    cx.struct_span_lint(lint, span, |diag| {
+        let mut diag = diag.build(msg);
+        if let Some(note_span) = note_span {
+            diag.span_note(note_span, note);
+        } else {
+            diag.note(note);
+        }
+        docs_link(&mut diag, lint);
+        diag.emit();
+    });
+}
+
+/// Like `span_lint` but allows to add notes, help and suggestions using a closure.
+///
+/// If you need to customize your lint output a lot, use this function.
+/// If you change the signature, remember to update the internal lint `CollapsibleCalls`
+pub fn span_lint_and_then<'a, T: LintContext, F>(cx: &'a T, lint: &'static Lint, sp: Span, msg: &str, f: F)
+where
+    F: for<'b> FnOnce(&mut DiagnosticBuilder<'b>),
+{
+    cx.struct_span_lint(lint, sp, |diag| {
+        let mut diag = diag.build(msg);
+        f(&mut diag);
+        docs_link(&mut diag, lint);
+        diag.emit();
+    });
+}
+
+pub fn span_lint_hir(cx: &LateContext<'_>, lint: &'static Lint, hir_id: HirId, sp: Span, msg: &str) {
+    cx.tcx.struct_span_lint_hir(lint, hir_id, sp, |diag| {
+        let mut diag = diag.build(msg);
+        docs_link(&mut diag, lint);
+        diag.emit();
+    });
+}
+
+pub fn span_lint_hir_and_then(
+    cx: &LateContext<'_>,
+    lint: &'static Lint,
+    hir_id: HirId,
+    sp: Span,
+    msg: &str,
+    f: impl FnOnce(&mut DiagnosticBuilder<'_>),
+) {
+    cx.tcx.struct_span_lint_hir(lint, hir_id, sp, |diag| {
+        let mut diag = diag.build(msg);
+        f(&mut diag);
+        docs_link(&mut diag, lint);
+        diag.emit();
+    });
+}
+
+/// Add a span lint with a suggestion on how to fix it.
+///
+/// These suggestions can be parsed by rustfix to allow it to automatically fix your code.
+/// In the example below, `help` is `"try"` and `sugg` is the suggested replacement `".any(|x| x >
+/// 2)"`.
+///
+/// If you change the signature, remember to update the internal lint `CollapsibleCalls`
+///
+/// # Example
+///
+/// ```ignore
+/// error: This `.fold` can be more succinctly expressed as `.any`
+/// --> $DIR/methods.rs:390:13
+///     |
+/// 390 |     let _ = (0..3).fold(false, |acc, x| acc || x > 2);
+///     |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `.any(|x| x > 2)`
+///     |
+///     = note: `-D fold-any` implied by `-D warnings`
+/// ```
+#[cfg_attr(feature = "internal-lints", allow(clippy::collapsible_span_lint_calls))]
+pub fn span_lint_and_sugg<'a, T: LintContext>(
+    cx: &'a T,
+    lint: &'static Lint,
+    sp: Span,
+    msg: &str,
+    help: &str,
+    sugg: String,
+    applicability: Applicability,
+) {
+    span_lint_and_then(cx, lint, sp, msg, |diag| {
+        diag.span_suggestion(sp, help, sugg, applicability);
+    });
+}
+
+/// Create a suggestion made from several `span → replacement`.
+///
+/// Note: in the JSON format (used by `compiletest_rs`), the help message will
+/// appear once per
+/// replacement. In human-readable format though, it only appears once before
+/// the whole suggestion.
+pub fn multispan_sugg<I>(diag: &mut DiagnosticBuilder<'_>, help_msg: &str, sugg: I)
+where
+    I: IntoIterator<Item = (Span, String)>,
+{
+    multispan_sugg_with_applicability(diag, help_msg, Applicability::Unspecified, sugg)
+}
+
+pub fn multispan_sugg_with_applicability<I>(
+    diag: &mut DiagnosticBuilder<'_>,
+    help_msg: &str,
+    applicability: Applicability,
+    sugg: I,
+) where
+    I: IntoIterator<Item = (Span, String)>,
+{
+    diag.multipart_suggestion(help_msg, sugg.into_iter().collect(), applicability);
+}
diff --git a/clippy_utils/src/eager_or_lazy.rs b/clippy_utils/src/eager_or_lazy.rs
new file mode 100644
index 00000000000..52a33e9b170
--- /dev/null
+++ b/clippy_utils/src/eager_or_lazy.rs
@@ -0,0 +1,134 @@
+//! Utilities for evaluating whether eagerly evaluated expressions can be made lazy and vice versa.
+//!
+//! Things to consider:
+//!  - has the expression side-effects?
+//!  - is the expression computationally expensive?
+//!
+//! See lints:
+//!  - unnecessary-lazy-evaluations
+//!  - or-fun-call
+//!  - option-if-let-else
+
+use crate::{is_ctor_or_promotable_const_function, is_type_diagnostic_item, match_type, paths};
+use rustc_hir::def::{DefKind, Res};
+
+use rustc_hir::intravisit;
+use rustc_hir::intravisit::{NestedVisitorMap, Visitor};
+
+use rustc_hir::{Block, Expr, ExprKind, Path, QPath};
+use rustc_lint::LateContext;
+use rustc_middle::hir::map::Map;
+
+/// Is the expr pure (is it free from side-effects)?
+/// This function is named so to stress that it isn't exhaustive and returns FNs.
+fn identify_some_pure_patterns(expr: &Expr<'_>) -> bool {
+    match expr.kind {
+        ExprKind::Lit(..) | ExprKind::ConstBlock(..) | ExprKind::Path(..) | ExprKind::Field(..) => true,
+        ExprKind::AddrOf(_, _, addr_of_expr) => identify_some_pure_patterns(addr_of_expr),
+        ExprKind::Tup(tup_exprs) => tup_exprs.iter().all(|expr| identify_some_pure_patterns(expr)),
+        ExprKind::Struct(_, fields, expr) => {
+            fields.iter().all(|f| identify_some_pure_patterns(f.expr))
+                && expr.map_or(true, |e| identify_some_pure_patterns(e))
+        },
+        ExprKind::Call(
+            &Expr {
+                kind:
+                    ExprKind::Path(QPath::Resolved(
+                        _,
+                        Path {
+                            res: Res::Def(DefKind::Ctor(..) | DefKind::Variant, ..),
+                            ..
+                        },
+                    )),
+                ..
+            },
+            args,
+        ) => args.iter().all(|expr| identify_some_pure_patterns(expr)),
+        ExprKind::Block(
+            &Block {
+                stmts,
+                expr: Some(expr),
+                ..
+            },
+            _,
+        ) => stmts.is_empty() && identify_some_pure_patterns(expr),
+        ExprKind::Box(..)
+        | ExprKind::Array(..)
+        | ExprKind::Call(..)
+        | ExprKind::MethodCall(..)
+        | ExprKind::Binary(..)
+        | ExprKind::Unary(..)
+        | ExprKind::Cast(..)
+        | ExprKind::Type(..)
+        | ExprKind::DropTemps(..)
+        | ExprKind::Loop(..)
+        | ExprKind::If(..)
+        | ExprKind::Match(..)
+        | ExprKind::Closure(..)
+        | ExprKind::Block(..)
+        | ExprKind::Assign(..)
+        | ExprKind::AssignOp(..)
+        | ExprKind::Index(..)
+        | ExprKind::Break(..)
+        | ExprKind::Continue(..)
+        | ExprKind::Ret(..)
+        | ExprKind::InlineAsm(..)
+        | ExprKind::LlvmInlineAsm(..)
+        | ExprKind::Repeat(..)
+        | ExprKind::Yield(..)
+        | ExprKind::Err => false,
+    }
+}
+
+/// Identify some potentially computationally expensive patterns.
+/// This function is named so to stress that its implementation is non-exhaustive.
+/// It returns FNs and FPs.
+fn identify_some_potentially_expensive_patterns<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
+    // Searches an expression for method calls or function calls that aren't ctors
+    struct FunCallFinder<'a, 'tcx> {
+        cx: &'a LateContext<'tcx>,
+        found: bool,
+    }
+
+    impl<'a, 'tcx> intravisit::Visitor<'tcx> for FunCallFinder<'a, 'tcx> {
+        type Map = Map<'tcx>;
+
+        fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) {
+            let call_found = match &expr.kind {
+                // ignore enum and struct constructors
+                ExprKind::Call(..) => !is_ctor_or_promotable_const_function(self.cx, expr),
+                ExprKind::Index(obj, _) => {
+                    let ty = self.cx.typeck_results().expr_ty(obj);
+                    is_type_diagnostic_item(self.cx, ty, sym!(hashmap_type))
+                        || match_type(self.cx, ty, &paths::BTREEMAP)
+                },
+                ExprKind::MethodCall(..) => true,
+                _ => false,
+            };
+
+            if call_found {
+                self.found |= true;
+            }
+
+            if !self.found {
+                intravisit::walk_expr(self, expr);
+            }
+        }
+
+        fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+            NestedVisitorMap::None
+        }
+    }
+
+    let mut finder = FunCallFinder { cx, found: false };
+    finder.visit_expr(expr);
+    finder.found
+}
+
+pub fn is_eagerness_candidate<'a, 'tcx>(cx: &'a LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
+    !identify_some_potentially_expensive_patterns(cx, expr) && identify_some_pure_patterns(expr)
+}
+
+pub fn is_lazyness_candidate<'a, 'tcx>(cx: &'a LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
+    identify_some_potentially_expensive_patterns(cx, expr)
+}
diff --git a/clippy_utils/src/higher.rs b/clippy_utils/src/higher.rs
new file mode 100644
index 00000000000..be22df7109a
--- /dev/null
+++ b/clippy_utils/src/higher.rs
@@ -0,0 +1,268 @@
+//! This module contains functions for retrieve the original AST from lowered
+//! `hir`.
+
+#![deny(clippy::missing_docs_in_private_items)]
+
+use crate::{is_expn_of, match_def_path, paths};
+use if_chain::if_chain;
+use rustc_ast::ast;
+use rustc_hir as hir;
+use rustc_hir::{BorrowKind, Expr, ExprKind, StmtKind, UnOp};
+use rustc_lint::LateContext;
+use rustc_span::source_map::Span;
+
+/// Converts a hir binary operator to the corresponding `ast` type.
+#[must_use]
+pub fn binop(op: hir::BinOpKind) -> ast::BinOpKind {
+    match op {
+        hir::BinOpKind::Eq => ast::BinOpKind::Eq,
+        hir::BinOpKind::Ge => ast::BinOpKind::Ge,
+        hir::BinOpKind::Gt => ast::BinOpKind::Gt,
+        hir::BinOpKind::Le => ast::BinOpKind::Le,
+        hir::BinOpKind::Lt => ast::BinOpKind::Lt,
+        hir::BinOpKind::Ne => ast::BinOpKind::Ne,
+        hir::BinOpKind::Or => ast::BinOpKind::Or,
+        hir::BinOpKind::Add => ast::BinOpKind::Add,
+        hir::BinOpKind::And => ast::BinOpKind::And,
+        hir::BinOpKind::BitAnd => ast::BinOpKind::BitAnd,
+        hir::BinOpKind::BitOr => ast::BinOpKind::BitOr,
+        hir::BinOpKind::BitXor => ast::BinOpKind::BitXor,
+        hir::BinOpKind::Div => ast::BinOpKind::Div,
+        hir::BinOpKind::Mul => ast::BinOpKind::Mul,
+        hir::BinOpKind::Rem => ast::BinOpKind::Rem,
+        hir::BinOpKind::Shl => ast::BinOpKind::Shl,
+        hir::BinOpKind::Shr => ast::BinOpKind::Shr,
+        hir::BinOpKind::Sub => ast::BinOpKind::Sub,
+    }
+}
+
+/// Represent a range akin to `ast::ExprKind::Range`.
+#[derive(Debug, Copy, Clone)]
+pub struct Range<'a> {
+    /// The lower bound of the range, or `None` for ranges such as `..X`.
+    pub start: Option<&'a hir::Expr<'a>>,
+    /// The upper bound of the range, or `None` for ranges such as `X..`.
+    pub end: Option<&'a hir::Expr<'a>>,
+    /// Whether the interval is open or closed.
+    pub limits: ast::RangeLimits,
+}
+
+/// Higher a `hir` range to something similar to `ast::ExprKind::Range`.
+pub fn range<'a>(expr: &'a hir::Expr<'_>) -> Option<Range<'a>> {
+    /// Finds the field named `name` in the field. Always return `Some` for
+    /// convenience.
+    fn get_field<'c>(name: &str, fields: &'c [hir::Field<'_>]) -> Option<&'c hir::Expr<'c>> {
+        let expr = &fields.iter().find(|field| field.ident.name.as_str() == name)?.expr;
+
+        Some(expr)
+    }
+
+    match expr.kind {
+        hir::ExprKind::Call(ref path, ref args)
+            if matches!(
+                path.kind,
+                hir::ExprKind::Path(hir::QPath::LangItem(hir::LangItem::RangeInclusiveNew, _))
+            ) =>
+        {
+            Some(Range {
+                start: Some(&args[0]),
+                end: Some(&args[1]),
+                limits: ast::RangeLimits::Closed,
+            })
+        },
+        hir::ExprKind::Struct(ref path, ref fields, None) => match path {
+            hir::QPath::LangItem(hir::LangItem::RangeFull, _) => Some(Range {
+                start: None,
+                end: None,
+                limits: ast::RangeLimits::HalfOpen,
+            }),
+            hir::QPath::LangItem(hir::LangItem::RangeFrom, _) => Some(Range {
+                start: Some(get_field("start", fields)?),
+                end: None,
+                limits: ast::RangeLimits::HalfOpen,
+            }),
+            hir::QPath::LangItem(hir::LangItem::Range, _) => Some(Range {
+                start: Some(get_field("start", fields)?),
+                end: Some(get_field("end", fields)?),
+                limits: ast::RangeLimits::HalfOpen,
+            }),
+            hir::QPath::LangItem(hir::LangItem::RangeToInclusive, _) => Some(Range {
+                start: None,
+                end: Some(get_field("end", fields)?),
+                limits: ast::RangeLimits::Closed,
+            }),
+            hir::QPath::LangItem(hir::LangItem::RangeTo, _) => Some(Range {
+                start: None,
+                end: Some(get_field("end", fields)?),
+                limits: ast::RangeLimits::HalfOpen,
+            }),
+            _ => None,
+        },
+        _ => None,
+    }
+}
+
+/// Checks if a `let` statement is from a `for` loop desugaring.
+pub fn is_from_for_desugar(local: &hir::Local<'_>) -> bool {
+    // This will detect plain for-loops without an actual variable binding:
+    //
+    // ```
+    // for x in some_vec {
+    //     // do stuff
+    // }
+    // ```
+    if_chain! {
+        if let Some(ref expr) = local.init;
+        if let hir::ExprKind::Match(_, _, hir::MatchSource::ForLoopDesugar) = expr.kind;
+        then {
+            return true;
+        }
+    }
+
+    // This detects a variable binding in for loop to avoid `let_unit_value`
+    // lint (see issue #1964).
+    //
+    // ```
+    // for _ in vec![()] {
+    //     // anything
+    // }
+    // ```
+    if let hir::LocalSource::ForLoopDesugar = local.source {
+        return true;
+    }
+
+    false
+}
+
+/// Recover the essential nodes of a desugared for loop as well as the entire span:
+/// `for pat in arg { body }` becomes `(pat, arg, body)`. Return `(pat, arg, body, span)`.
+pub fn for_loop<'tcx>(
+    expr: &'tcx hir::Expr<'tcx>,
+) -> Option<(&hir::Pat<'_>, &'tcx hir::Expr<'tcx>, &'tcx hir::Expr<'tcx>, Span)> {
+    if_chain! {
+        if let hir::ExprKind::Match(ref iterexpr, ref arms, hir::MatchSource::ForLoopDesugar) = expr.kind;
+        if let hir::ExprKind::Call(_, ref iterargs) = iterexpr.kind;
+        if iterargs.len() == 1 && arms.len() == 1 && arms[0].guard.is_none();
+        if let hir::ExprKind::Loop(ref block, ..) = arms[0].body.kind;
+        if block.expr.is_none();
+        if let [ _, _, ref let_stmt, ref body ] = *block.stmts;
+        if let hir::StmtKind::Local(ref local) = let_stmt.kind;
+        if let hir::StmtKind::Expr(ref expr) = body.kind;
+        then {
+            return Some((&*local.pat, &iterargs[0], expr, arms[0].span));
+        }
+    }
+    None
+}
+
+/// Recover the essential nodes of a desugared while loop:
+/// `while cond { body }` becomes `(cond, body)`.
+pub fn while_loop<'tcx>(expr: &'tcx hir::Expr<'tcx>) -> Option<(&'tcx hir::Expr<'tcx>, &'tcx hir::Expr<'tcx>)> {
+    if_chain! {
+        if let hir::ExprKind::Loop(hir::Block { expr: Some(expr), .. }, _, hir::LoopSource::While, _) = &expr.kind;
+        if let hir::ExprKind::Match(cond, arms, hir::MatchSource::WhileDesugar) = &expr.kind;
+        if let hir::ExprKind::DropTemps(cond) = &cond.kind;
+        if let [hir::Arm { body, .. }, ..] = &arms[..];
+        then {
+            return Some((cond, body));
+        }
+    }
+    None
+}
+
+/// Represent the pre-expansion arguments of a `vec!` invocation.
+pub enum VecArgs<'a> {
+    /// `vec![elem; len]`
+    Repeat(&'a hir::Expr<'a>, &'a hir::Expr<'a>),
+    /// `vec![a, b, c]`
+    Vec(&'a [hir::Expr<'a>]),
+}
+
+/// Returns the arguments of the `vec!` macro if this expression was expanded
+/// from `vec!`.
+pub fn vec_macro<'e>(cx: &LateContext<'_>, expr: &'e hir::Expr<'_>) -> Option<VecArgs<'e>> {
+    if_chain! {
+        if let hir::ExprKind::Call(ref fun, ref args) = expr.kind;
+        if let hir::ExprKind::Path(ref qpath) = fun.kind;
+        if is_expn_of(fun.span, "vec").is_some();
+        if let Some(fun_def_id) = cx.qpath_res(qpath, fun.hir_id).opt_def_id();
+        then {
+            return if match_def_path(cx, fun_def_id, &paths::VEC_FROM_ELEM) && args.len() == 2 {
+                // `vec![elem; size]` case
+                Some(VecArgs::Repeat(&args[0], &args[1]))
+            }
+            else if match_def_path(cx, fun_def_id, &paths::SLICE_INTO_VEC) && args.len() == 1 {
+                // `vec![a, b, c]` case
+                if_chain! {
+                    if let hir::ExprKind::Box(ref boxed) = args[0].kind;
+                    if let hir::ExprKind::Array(ref args) = boxed.kind;
+                    then {
+                        return Some(VecArgs::Vec(&*args));
+                    }
+                }
+
+                None
+            }
+            else if match_def_path(cx, fun_def_id, &paths::VEC_NEW) && args.is_empty() {
+                Some(VecArgs::Vec(&[]))
+            }
+            else {
+                None
+            };
+        }
+    }
+
+    None
+}
+
+/// Extract args from an assert-like macro.
+/// Currently working with:
+/// - `assert!`, `assert_eq!` and `assert_ne!`
+/// - `debug_assert!`, `debug_assert_eq!` and `debug_assert_ne!`
+/// For example:
+/// `assert!(expr)` will return Some([expr])
+/// `debug_assert_eq!(a, b)` will return Some([a, b])
+pub fn extract_assert_macro_args<'tcx>(e: &'tcx Expr<'tcx>) -> Option<Vec<&'tcx Expr<'tcx>>> {
+    /// Try to match the AST for a pattern that contains a match, for example when two args are
+    /// compared
+    fn ast_matchblock(matchblock_expr: &'tcx Expr<'tcx>) -> Option<Vec<&Expr<'_>>> {
+        if_chain! {
+            if let ExprKind::Match(ref headerexpr, _, _) = &matchblock_expr.kind;
+            if let ExprKind::Tup([lhs, rhs]) = &headerexpr.kind;
+            if let ExprKind::AddrOf(BorrowKind::Ref, _, lhs) = lhs.kind;
+            if let ExprKind::AddrOf(BorrowKind::Ref, _, rhs) = rhs.kind;
+            then {
+                return Some(vec![lhs, rhs]);
+            }
+        }
+        None
+    }
+
+    if let ExprKind::Block(ref block, _) = e.kind {
+        if block.stmts.len() == 1 {
+            if let StmtKind::Semi(ref matchexpr) = block.stmts.get(0)?.kind {
+                // macros with unique arg: `{debug_}assert!` (e.g., `debug_assert!(some_condition)`)
+                if_chain! {
+                    if let ExprKind::If(ref clause, _, _)  = matchexpr.kind;
+                    if let ExprKind::Unary(UnOp::Not, condition) = clause.kind;
+                    then {
+                        return Some(vec![condition]);
+                    }
+                }
+
+                // debug macros with two args: `debug_assert_{ne, eq}` (e.g., `assert_ne!(a, b)`)
+                if_chain! {
+                    if let ExprKind::Block(ref matchblock,_) = matchexpr.kind;
+                    if let Some(ref matchblock_expr) = matchblock.expr;
+                    then {
+                        return ast_matchblock(matchblock_expr);
+                    }
+                }
+            }
+        } else if let Some(matchblock_expr) = block.expr {
+            // macros with two args: `assert_{ne, eq}` (e.g., `assert_ne!(a, b)`)
+            return ast_matchblock(&matchblock_expr);
+        }
+    }
+    None
+}
diff --git a/clippy_utils/src/hir_utils.rs b/clippy_utils/src/hir_utils.rs
new file mode 100644
index 00000000000..81be9254cbe
--- /dev/null
+++ b/clippy_utils/src/hir_utils.rs
@@ -0,0 +1,852 @@
+use crate::consts::{constant_context, constant_simple};
+use crate::differing_macro_contexts;
+use rustc_ast::ast::InlineAsmTemplatePiece;
+use rustc_data_structures::fx::FxHashMap;
+use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
+use rustc_hir::def::Res;
+use rustc_hir::{
+    BinOpKind, Block, BlockCheckMode, BodyId, BorrowKind, CaptureBy, Expr, ExprKind, Field, FieldPat, FnRetTy,
+    GenericArg, GenericArgs, Guard, HirId, InlineAsmOperand, Lifetime, LifetimeName, ParamName, Pat, PatKind, Path,
+    PathSegment, QPath, Stmt, StmtKind, Ty, TyKind, TypeBinding,
+};
+use rustc_lint::LateContext;
+use rustc_middle::ich::StableHashingContextProvider;
+use rustc_middle::ty::TypeckResults;
+use rustc_span::Symbol;
+use std::hash::Hash;
+
+/// Type used to check whether two ast are the same. This is different from the
+/// operator
+/// `==` on ast types as this operator would compare true equality with ID and
+/// span.
+///
+/// Note that some expressions kinds are not considered but could be added.
+pub struct SpanlessEq<'a, 'tcx> {
+    /// Context used to evaluate constant expressions.
+    cx: &'a LateContext<'tcx>,
+    maybe_typeck_results: Option<&'tcx TypeckResults<'tcx>>,
+    allow_side_effects: bool,
+    expr_fallback: Option<Box<dyn FnMut(&Expr<'_>, &Expr<'_>) -> bool + 'a>>,
+}
+
+impl<'a, 'tcx> SpanlessEq<'a, 'tcx> {
+    pub fn new(cx: &'a LateContext<'tcx>) -> Self {
+        Self {
+            cx,
+            maybe_typeck_results: cx.maybe_typeck_results(),
+            allow_side_effects: true,
+            expr_fallback: None,
+        }
+    }
+
+    /// Consider expressions containing potential side effects as not equal.
+    pub fn deny_side_effects(self) -> Self {
+        Self {
+            allow_side_effects: false,
+            ..self
+        }
+    }
+
+    pub fn expr_fallback(self, expr_fallback: impl FnMut(&Expr<'_>, &Expr<'_>) -> bool + 'a) -> Self {
+        Self {
+            expr_fallback: Some(Box::new(expr_fallback)),
+            ..self
+        }
+    }
+
+    /// Use this method to wrap comparisons that may involve inter-expression context.
+    /// See `self.locals`.
+    fn inter_expr(&mut self) -> HirEqInterExpr<'_, 'a, 'tcx> {
+        HirEqInterExpr {
+            inner: self,
+            locals: FxHashMap::default(),
+        }
+    }
+
+    pub fn eq_block(&mut self, left: &Block<'_>, right: &Block<'_>) -> bool {
+        self.inter_expr().eq_block(left, right)
+    }
+
+    pub fn eq_expr(&mut self, left: &Expr<'_>, right: &Expr<'_>) -> bool {
+        self.inter_expr().eq_expr(left, right)
+    }
+
+    pub fn eq_path_segment(&mut self, left: &PathSegment<'_>, right: &PathSegment<'_>) -> bool {
+        self.inter_expr().eq_path_segment(left, right)
+    }
+
+    pub fn eq_path_segments(&mut self, left: &[PathSegment<'_>], right: &[PathSegment<'_>]) -> bool {
+        self.inter_expr().eq_path_segments(left, right)
+    }
+
+    pub fn eq_ty_kind(&mut self, left: &TyKind<'_>, right: &TyKind<'_>) -> bool {
+        self.inter_expr().eq_ty_kind(left, right)
+    }
+}
+
+struct HirEqInterExpr<'a, 'b, 'tcx> {
+    inner: &'a mut SpanlessEq<'b, 'tcx>,
+
+    // When binding are declared, the binding ID in the left expression is mapped to the one on the
+    // right. For example, when comparing `{ let x = 1; x + 2 }` and `{ let y = 1; y + 2 }`,
+    // these blocks are considered equal since `x` is mapped to `y`.
+    locals: FxHashMap<HirId, HirId>,
+}
+
+impl HirEqInterExpr<'_, '_, '_> {
+    fn eq_stmt(&mut self, left: &Stmt<'_>, right: &Stmt<'_>) -> bool {
+        match (&left.kind, &right.kind) {
+            (&StmtKind::Local(ref l), &StmtKind::Local(ref r)) => {
+                self.eq_pat(&l.pat, &r.pat)
+                    && both(&l.ty, &r.ty, |l, r| self.eq_ty(l, r))
+                    && both(&l.init, &r.init, |l, r| self.eq_expr(l, r))
+            },
+            (&StmtKind::Expr(ref l), &StmtKind::Expr(ref r)) | (&StmtKind::Semi(ref l), &StmtKind::Semi(ref r)) => {
+                self.eq_expr(l, r)
+            },
+            _ => false,
+        }
+    }
+
+    /// Checks whether two blocks are the same.
+    fn eq_block(&mut self, left: &Block<'_>, right: &Block<'_>) -> bool {
+        over(&left.stmts, &right.stmts, |l, r| self.eq_stmt(l, r))
+            && both(&left.expr, &right.expr, |l, r| self.eq_expr(l, r))
+    }
+
+    #[allow(clippy::similar_names)]
+    fn eq_expr(&mut self, left: &Expr<'_>, right: &Expr<'_>) -> bool {
+        if !self.inner.allow_side_effects && differing_macro_contexts(left.span, right.span) {
+            return false;
+        }
+
+        if let Some(typeck_results) = self.inner.maybe_typeck_results {
+            if let (Some(l), Some(r)) = (
+                constant_simple(self.inner.cx, typeck_results, left),
+                constant_simple(self.inner.cx, typeck_results, right),
+            ) {
+                if l == r {
+                    return true;
+                }
+            }
+        }
+
+        let is_eq = match (&reduce_exprkind(&left.kind), &reduce_exprkind(&right.kind)) {
+            (&ExprKind::AddrOf(lb, l_mut, ref le), &ExprKind::AddrOf(rb, r_mut, ref re)) => {
+                lb == rb && l_mut == r_mut && self.eq_expr(le, re)
+            },
+            (&ExprKind::Continue(li), &ExprKind::Continue(ri)) => {
+                both(&li.label, &ri.label, |l, r| l.ident.name == r.ident.name)
+            },
+            (&ExprKind::Assign(ref ll, ref lr, _), &ExprKind::Assign(ref rl, ref rr, _)) => {
+                self.inner.allow_side_effects && self.eq_expr(ll, rl) && self.eq_expr(lr, rr)
+            },
+            (&ExprKind::AssignOp(ref lo, ref ll, ref lr), &ExprKind::AssignOp(ref ro, ref rl, ref rr)) => {
+                self.inner.allow_side_effects && lo.node == ro.node && self.eq_expr(ll, rl) && self.eq_expr(lr, rr)
+            },
+            (&ExprKind::Block(ref l, _), &ExprKind::Block(ref r, _)) => self.eq_block(l, r),
+            (&ExprKind::Binary(l_op, ref ll, ref lr), &ExprKind::Binary(r_op, ref rl, ref rr)) => {
+                l_op.node == r_op.node && self.eq_expr(ll, rl) && self.eq_expr(lr, rr)
+                    || swap_binop(l_op.node, ll, lr).map_or(false, |(l_op, ll, lr)| {
+                        l_op == r_op.node && self.eq_expr(ll, rl) && self.eq_expr(lr, rr)
+                    })
+            },
+            (&ExprKind::Break(li, ref le), &ExprKind::Break(ri, ref re)) => {
+                both(&li.label, &ri.label, |l, r| l.ident.name == r.ident.name)
+                    && both(le, re, |l, r| self.eq_expr(l, r))
+            },
+            (&ExprKind::Box(ref l), &ExprKind::Box(ref r)) => self.eq_expr(l, r),
+            (&ExprKind::Call(l_fun, l_args), &ExprKind::Call(r_fun, r_args)) => {
+                self.inner.allow_side_effects && self.eq_expr(l_fun, r_fun) && self.eq_exprs(l_args, r_args)
+            },
+            (&ExprKind::Cast(ref lx, ref lt), &ExprKind::Cast(ref rx, ref rt))
+            | (&ExprKind::Type(ref lx, ref lt), &ExprKind::Type(ref rx, ref rt)) => {
+                self.eq_expr(lx, rx) && self.eq_ty(lt, rt)
+            },
+            (&ExprKind::Field(ref l_f_exp, ref l_f_ident), &ExprKind::Field(ref r_f_exp, ref r_f_ident)) => {
+                l_f_ident.name == r_f_ident.name && self.eq_expr(l_f_exp, r_f_exp)
+            },
+            (&ExprKind::Index(ref la, ref li), &ExprKind::Index(ref ra, ref ri)) => {
+                self.eq_expr(la, ra) && self.eq_expr(li, ri)
+            },
+            (&ExprKind::If(ref lc, ref lt, ref le), &ExprKind::If(ref rc, ref rt, ref re)) => {
+                self.eq_expr(lc, rc) && self.eq_expr(&**lt, &**rt) && both(le, re, |l, r| self.eq_expr(l, r))
+            },
+            (&ExprKind::Lit(ref l), &ExprKind::Lit(ref r)) => l.node == r.node,
+            (&ExprKind::Loop(ref lb, ref ll, ref lls, _), &ExprKind::Loop(ref rb, ref rl, ref rls, _)) => {
+                lls == rls && self.eq_block(lb, rb) && both(ll, rl, |l, r| l.ident.name == r.ident.name)
+            },
+            (&ExprKind::Match(ref le, ref la, ref ls), &ExprKind::Match(ref re, ref ra, ref rs)) => {
+                ls == rs
+                    && self.eq_expr(le, re)
+                    && over(la, ra, |l, r| {
+                        self.eq_pat(&l.pat, &r.pat)
+                            && both(&l.guard, &r.guard, |l, r| self.eq_guard(l, r))
+                            && self.eq_expr(&l.body, &r.body)
+                    })
+            },
+            (&ExprKind::MethodCall(l_path, _, l_args, _), &ExprKind::MethodCall(r_path, _, r_args, _)) => {
+                self.inner.allow_side_effects && self.eq_path_segment(l_path, r_path) && self.eq_exprs(l_args, r_args)
+            },
+            (&ExprKind::Repeat(ref le, ref ll_id), &ExprKind::Repeat(ref re, ref rl_id)) => {
+                let mut celcx = constant_context(self.inner.cx, self.inner.cx.tcx.typeck_body(ll_id.body));
+                let ll = celcx.expr(&self.inner.cx.tcx.hir().body(ll_id.body).value);
+                let mut celcx = constant_context(self.inner.cx, self.inner.cx.tcx.typeck_body(rl_id.body));
+                let rl = celcx.expr(&self.inner.cx.tcx.hir().body(rl_id.body).value);
+
+                self.eq_expr(le, re) && ll == rl
+            },
+            (&ExprKind::Ret(ref l), &ExprKind::Ret(ref r)) => both(l, r, |l, r| self.eq_expr(l, r)),
+            (&ExprKind::Path(ref l), &ExprKind::Path(ref r)) => self.eq_qpath(l, r),
+            (&ExprKind::Struct(ref l_path, ref lf, ref lo), &ExprKind::Struct(ref r_path, ref rf, ref ro)) => {
+                self.eq_qpath(l_path, r_path)
+                    && both(lo, ro, |l, r| self.eq_expr(l, r))
+                    && over(lf, rf, |l, r| self.eq_field(l, r))
+            },
+            (&ExprKind::Tup(l_tup), &ExprKind::Tup(r_tup)) => self.eq_exprs(l_tup, r_tup),
+            (&ExprKind::Unary(l_op, ref le), &ExprKind::Unary(r_op, ref re)) => l_op == r_op && self.eq_expr(le, re),
+            (&ExprKind::Array(l), &ExprKind::Array(r)) => self.eq_exprs(l, r),
+            (&ExprKind::DropTemps(ref le), &ExprKind::DropTemps(ref re)) => self.eq_expr(le, re),
+            _ => false,
+        };
+        is_eq || self.inner.expr_fallback.as_mut().map_or(false, |f| f(left, right))
+    }
+
+    fn eq_exprs(&mut self, left: &[Expr<'_>], right: &[Expr<'_>]) -> bool {
+        over(left, right, |l, r| self.eq_expr(l, r))
+    }
+
+    fn eq_field(&mut self, left: &Field<'_>, right: &Field<'_>) -> bool {
+        left.ident.name == right.ident.name && self.eq_expr(&left.expr, &right.expr)
+    }
+
+    fn eq_guard(&mut self, left: &Guard<'_>, right: &Guard<'_>) -> bool {
+        match (left, right) {
+            (Guard::If(l), Guard::If(r)) => self.eq_expr(l, r),
+            (Guard::IfLet(lp, le), Guard::IfLet(rp, re)) => self.eq_pat(lp, rp) && self.eq_expr(le, re),
+            _ => false,
+        }
+    }
+
+    fn eq_generic_arg(&mut self, left: &GenericArg<'_>, right: &GenericArg<'_>) -> bool {
+        match (left, right) {
+            (GenericArg::Lifetime(l_lt), GenericArg::Lifetime(r_lt)) => Self::eq_lifetime(l_lt, r_lt),
+            (GenericArg::Type(l_ty), GenericArg::Type(r_ty)) => self.eq_ty(l_ty, r_ty),
+            _ => false,
+        }
+    }
+
+    fn eq_lifetime(left: &Lifetime, right: &Lifetime) -> bool {
+        left.name == right.name
+    }
+
+    fn eq_fieldpat(&mut self, left: &FieldPat<'_>, right: &FieldPat<'_>) -> bool {
+        let (FieldPat { ident: li, pat: lp, .. }, FieldPat { ident: ri, pat: rp, .. }) = (&left, &right);
+        li.name == ri.name && self.eq_pat(lp, rp)
+    }
+
+    /// Checks whether two patterns are the same.
+    fn eq_pat(&mut self, left: &Pat<'_>, right: &Pat<'_>) -> bool {
+        match (&left.kind, &right.kind) {
+            (&PatKind::Box(ref l), &PatKind::Box(ref r)) => self.eq_pat(l, r),
+            (&PatKind::Struct(ref lp, ref la, ..), &PatKind::Struct(ref rp, ref ra, ..)) => {
+                self.eq_qpath(lp, rp) && over(la, ra, |l, r| self.eq_fieldpat(l, r))
+            },
+            (&PatKind::TupleStruct(ref lp, ref la, ls), &PatKind::TupleStruct(ref rp, ref ra, rs)) => {
+                self.eq_qpath(lp, rp) && over(la, ra, |l, r| self.eq_pat(l, r)) && ls == rs
+            },
+            (&PatKind::Binding(lb, li, _, ref lp), &PatKind::Binding(rb, ri, _, ref rp)) => {
+                let eq = lb == rb && both(lp, rp, |l, r| self.eq_pat(l, r));
+                if eq {
+                    self.locals.insert(li, ri);
+                }
+                eq
+            },
+            (&PatKind::Path(ref l), &PatKind::Path(ref r)) => self.eq_qpath(l, r),
+            (&PatKind::Lit(ref l), &PatKind::Lit(ref r)) => self.eq_expr(l, r),
+            (&PatKind::Tuple(ref l, ls), &PatKind::Tuple(ref r, rs)) => {
+                ls == rs && over(l, r, |l, r| self.eq_pat(l, r))
+            },
+            (&PatKind::Range(ref ls, ref le, li), &PatKind::Range(ref rs, ref re, ri)) => {
+                both(ls, rs, |a, b| self.eq_expr(a, b)) && both(le, re, |a, b| self.eq_expr(a, b)) && (li == ri)
+            },
+            (&PatKind::Ref(ref le, ref lm), &PatKind::Ref(ref re, ref rm)) => lm == rm && self.eq_pat(le, re),
+            (&PatKind::Slice(ref ls, ref li, ref le), &PatKind::Slice(ref rs, ref ri, ref re)) => {
+                over(ls, rs, |l, r| self.eq_pat(l, r))
+                    && over(le, re, |l, r| self.eq_pat(l, r))
+                    && both(li, ri, |l, r| self.eq_pat(l, r))
+            },
+            (&PatKind::Wild, &PatKind::Wild) => true,
+            _ => false,
+        }
+    }
+
+    #[allow(clippy::similar_names)]
+    fn eq_qpath(&mut self, left: &QPath<'_>, right: &QPath<'_>) -> bool {
+        match (left, right) {
+            (&QPath::Resolved(ref lty, ref lpath), &QPath::Resolved(ref rty, ref rpath)) => {
+                both(lty, rty, |l, r| self.eq_ty(l, r)) && self.eq_path(lpath, rpath)
+            },
+            (&QPath::TypeRelative(ref lty, ref lseg), &QPath::TypeRelative(ref rty, ref rseg)) => {
+                self.eq_ty(lty, rty) && self.eq_path_segment(lseg, rseg)
+            },
+            (&QPath::LangItem(llang_item, _), &QPath::LangItem(rlang_item, _)) => llang_item == rlang_item,
+            _ => false,
+        }
+    }
+
+    fn eq_path(&mut self, left: &Path<'_>, right: &Path<'_>) -> bool {
+        match (left.res, right.res) {
+            (Res::Local(l), Res::Local(r)) => l == r || self.locals.get(&l) == Some(&r),
+            (Res::Local(_), _) | (_, Res::Local(_)) => false,
+            _ => over(&left.segments, &right.segments, |l, r| self.eq_path_segment(l, r)),
+        }
+    }
+
+    fn eq_path_parameters(&mut self, left: &GenericArgs<'_>, right: &GenericArgs<'_>) -> bool {
+        if !(left.parenthesized || right.parenthesized) {
+            over(&left.args, &right.args, |l, r| self.eq_generic_arg(l, r)) // FIXME(flip1995): may not work
+                && over(&left.bindings, &right.bindings, |l, r| self.eq_type_binding(l, r))
+        } else if left.parenthesized && right.parenthesized {
+            over(left.inputs(), right.inputs(), |l, r| self.eq_ty(l, r))
+                && both(&Some(&left.bindings[0].ty()), &Some(&right.bindings[0].ty()), |l, r| {
+                    self.eq_ty(l, r)
+                })
+        } else {
+            false
+        }
+    }
+
+    pub fn eq_path_segments(&mut self, left: &[PathSegment<'_>], right: &[PathSegment<'_>]) -> bool {
+        left.len() == right.len() && left.iter().zip(right).all(|(l, r)| self.eq_path_segment(l, r))
+    }
+
+    pub fn eq_path_segment(&mut self, left: &PathSegment<'_>, right: &PathSegment<'_>) -> bool {
+        // The == of idents doesn't work with different contexts,
+        // we have to be explicit about hygiene
+        left.ident.name == right.ident.name && both(&left.args, &right.args, |l, r| self.eq_path_parameters(l, r))
+    }
+
+    fn eq_ty(&mut self, left: &Ty<'_>, right: &Ty<'_>) -> bool {
+        self.eq_ty_kind(&left.kind, &right.kind)
+    }
+
+    #[allow(clippy::similar_names)]
+    fn eq_ty_kind(&mut self, left: &TyKind<'_>, right: &TyKind<'_>) -> bool {
+        match (left, right) {
+            (&TyKind::Slice(ref l_vec), &TyKind::Slice(ref r_vec)) => self.eq_ty(l_vec, r_vec),
+            (&TyKind::Array(ref lt, ref ll_id), &TyKind::Array(ref rt, ref rl_id)) => {
+                let cx = self.inner.cx;
+                let eval_const =
+                    |body| constant_context(cx, cx.tcx.typeck_body(body)).expr(&cx.tcx.hir().body(body).value);
+                self.eq_ty(lt, rt) && eval_const(ll_id.body) == eval_const(rl_id.body)
+            },
+            (&TyKind::Ptr(ref l_mut), &TyKind::Ptr(ref r_mut)) => {
+                l_mut.mutbl == r_mut.mutbl && self.eq_ty(&*l_mut.ty, &*r_mut.ty)
+            },
+            (&TyKind::Rptr(_, ref l_rmut), &TyKind::Rptr(_, ref r_rmut)) => {
+                l_rmut.mutbl == r_rmut.mutbl && self.eq_ty(&*l_rmut.ty, &*r_rmut.ty)
+            },
+            (&TyKind::Path(ref l), &TyKind::Path(ref r)) => self.eq_qpath(l, r),
+            (&TyKind::Tup(ref l), &TyKind::Tup(ref r)) => over(l, r, |l, r| self.eq_ty(l, r)),
+            (&TyKind::Infer, &TyKind::Infer) => true,
+            _ => false,
+        }
+    }
+
+    fn eq_type_binding(&mut self, left: &TypeBinding<'_>, right: &TypeBinding<'_>) -> bool {
+        left.ident.name == right.ident.name && self.eq_ty(&left.ty(), &right.ty())
+    }
+}
+
+/// Some simple reductions like `{ return }` => `return`
+fn reduce_exprkind<'hir>(kind: &'hir ExprKind<'hir>) -> &ExprKind<'hir> {
+    if let ExprKind::Block(block, _) = kind {
+        match (block.stmts, block.expr) {
+            // `{}` => `()`
+            ([], None) => &ExprKind::Tup(&[]),
+            ([], Some(expr)) => match expr.kind {
+                // `{ return .. }` => `return ..`
+                ExprKind::Ret(..) => &expr.kind,
+                _ => kind,
+            },
+            ([stmt], None) => match stmt.kind {
+                StmtKind::Expr(expr) | StmtKind::Semi(expr) => match expr.kind {
+                    // `{ return ..; }` => `return ..`
+                    ExprKind::Ret(..) => &expr.kind,
+                    _ => kind,
+                },
+                _ => kind,
+            },
+            _ => kind,
+        }
+    } else {
+        kind
+    }
+}
+
+fn swap_binop<'a>(
+    binop: BinOpKind,
+    lhs: &'a Expr<'a>,
+    rhs: &'a Expr<'a>,
+) -> Option<(BinOpKind, &'a Expr<'a>, &'a Expr<'a>)> {
+    match binop {
+        BinOpKind::Add | BinOpKind::Eq | BinOpKind::Ne | BinOpKind::BitAnd | BinOpKind::BitXor | BinOpKind::BitOr => {
+            Some((binop, rhs, lhs))
+        },
+        BinOpKind::Lt => Some((BinOpKind::Gt, rhs, lhs)),
+        BinOpKind::Le => Some((BinOpKind::Ge, rhs, lhs)),
+        BinOpKind::Ge => Some((BinOpKind::Le, rhs, lhs)),
+        BinOpKind::Gt => Some((BinOpKind::Lt, rhs, lhs)),
+        BinOpKind::Mul // Not always commutative, e.g. with matrices. See issue #5698
+        | BinOpKind::Shl
+        | BinOpKind::Shr
+        | BinOpKind::Rem
+        | BinOpKind::Sub
+        | BinOpKind::Div
+        | BinOpKind::And
+        | BinOpKind::Or => None,
+    }
+}
+
+/// Checks if the two `Option`s are both `None` or some equal values as per
+/// `eq_fn`.
+pub fn both<X>(l: &Option<X>, r: &Option<X>, mut eq_fn: impl FnMut(&X, &X) -> bool) -> bool {
+    l.as_ref()
+        .map_or_else(|| r.is_none(), |x| r.as_ref().map_or(false, |y| eq_fn(x, y)))
+}
+
+/// Checks if two slices are equal as per `eq_fn`.
+pub fn over<X>(left: &[X], right: &[X], mut eq_fn: impl FnMut(&X, &X) -> bool) -> bool {
+    left.len() == right.len() && left.iter().zip(right).all(|(x, y)| eq_fn(x, y))
+}
+
+/// Checks if two expressions evaluate to the same value, and don't contain any side effects.
+pub fn eq_expr_value(cx: &LateContext<'_>, left: &Expr<'_>, right: &Expr<'_>) -> bool {
+    SpanlessEq::new(cx).deny_side_effects().eq_expr(left, right)
+}
+
+/// Type used to hash an ast element. This is different from the `Hash` trait
+/// on ast types as this
+/// trait would consider IDs and spans.
+///
+/// All expressions kind are hashed, but some might have a weaker hash.
+pub struct SpanlessHash<'a, 'tcx> {
+    /// Context used to evaluate constant expressions.
+    cx: &'a LateContext<'tcx>,
+    maybe_typeck_results: Option<&'tcx TypeckResults<'tcx>>,
+    s: StableHasher,
+}
+
+impl<'a, 'tcx> SpanlessHash<'a, 'tcx> {
+    pub fn new(cx: &'a LateContext<'tcx>) -> Self {
+        Self {
+            cx,
+            maybe_typeck_results: cx.maybe_typeck_results(),
+            s: StableHasher::new(),
+        }
+    }
+
+    pub fn finish(self) -> u64 {
+        self.s.finish()
+    }
+
+    pub fn hash_block(&mut self, b: &Block<'_>) {
+        for s in b.stmts {
+            self.hash_stmt(s);
+        }
+
+        if let Some(ref e) = b.expr {
+            self.hash_expr(e);
+        }
+
+        match b.rules {
+            BlockCheckMode::DefaultBlock => 0,
+            BlockCheckMode::UnsafeBlock(_) => 1,
+            BlockCheckMode::PushUnsafeBlock(_) => 2,
+            BlockCheckMode::PopUnsafeBlock(_) => 3,
+        }
+        .hash(&mut self.s);
+    }
+
+    #[allow(clippy::many_single_char_names, clippy::too_many_lines)]
+    pub fn hash_expr(&mut self, e: &Expr<'_>) {
+        let simple_const = self
+            .maybe_typeck_results
+            .and_then(|typeck_results| constant_simple(self.cx, typeck_results, e));
+
+        // const hashing may result in the same hash as some unrelated node, so add a sort of
+        // discriminant depending on which path we're choosing next
+        simple_const.is_some().hash(&mut self.s);
+
+        if let Some(e) = simple_const {
+            return e.hash(&mut self.s);
+        }
+
+        std::mem::discriminant(&e.kind).hash(&mut self.s);
+
+        match e.kind {
+            ExprKind::AddrOf(kind, m, ref e) => {
+                match kind {
+                    BorrowKind::Ref => 0,
+                    BorrowKind::Raw => 1,
+                }
+                .hash(&mut self.s);
+                m.hash(&mut self.s);
+                self.hash_expr(e);
+            },
+            ExprKind::Continue(i) => {
+                if let Some(i) = i.label {
+                    self.hash_name(i.ident.name);
+                }
+            },
+            ExprKind::Assign(ref l, ref r, _) => {
+                self.hash_expr(l);
+                self.hash_expr(r);
+            },
+            ExprKind::AssignOp(ref o, ref l, ref r) => {
+                o.node
+                    .hash_stable(&mut self.cx.tcx.get_stable_hashing_context(), &mut self.s);
+                self.hash_expr(l);
+                self.hash_expr(r);
+            },
+            ExprKind::Block(ref b, _) => {
+                self.hash_block(b);
+            },
+            ExprKind::Binary(op, ref l, ref r) => {
+                op.node
+                    .hash_stable(&mut self.cx.tcx.get_stable_hashing_context(), &mut self.s);
+                self.hash_expr(l);
+                self.hash_expr(r);
+            },
+            ExprKind::Break(i, ref j) => {
+                if let Some(i) = i.label {
+                    self.hash_name(i.ident.name);
+                }
+                if let Some(ref j) = *j {
+                    self.hash_expr(&*j);
+                }
+            },
+            ExprKind::Box(ref e) | ExprKind::DropTemps(ref e) | ExprKind::Yield(ref e, _) => {
+                self.hash_expr(e);
+            },
+            ExprKind::Call(ref fun, args) => {
+                self.hash_expr(fun);
+                self.hash_exprs(args);
+            },
+            ExprKind::Cast(ref e, ref ty) | ExprKind::Type(ref e, ref ty) => {
+                self.hash_expr(e);
+                self.hash_ty(ty);
+            },
+            ExprKind::Closure(cap, _, eid, _, _) => {
+                match cap {
+                    CaptureBy::Value => 0,
+                    CaptureBy::Ref => 1,
+                }
+                .hash(&mut self.s);
+                // closures inherit TypeckResults
+                self.hash_expr(&self.cx.tcx.hir().body(eid).value);
+            },
+            ExprKind::Field(ref e, ref f) => {
+                self.hash_expr(e);
+                self.hash_name(f.name);
+            },
+            ExprKind::Index(ref a, ref i) => {
+                self.hash_expr(a);
+                self.hash_expr(i);
+            },
+            ExprKind::InlineAsm(ref asm) => {
+                for piece in asm.template {
+                    match piece {
+                        InlineAsmTemplatePiece::String(s) => s.hash(&mut self.s),
+                        InlineAsmTemplatePiece::Placeholder {
+                            operand_idx,
+                            modifier,
+                            span: _,
+                        } => {
+                            operand_idx.hash(&mut self.s);
+                            modifier.hash(&mut self.s);
+                        },
+                    }
+                }
+                asm.options.hash(&mut self.s);
+                for (op, _op_sp) in asm.operands {
+                    match op {
+                        InlineAsmOperand::In { reg, expr } => {
+                            reg.hash(&mut self.s);
+                            self.hash_expr(expr);
+                        },
+                        InlineAsmOperand::Out { reg, late, expr } => {
+                            reg.hash(&mut self.s);
+                            late.hash(&mut self.s);
+                            if let Some(expr) = expr {
+                                self.hash_expr(expr);
+                            }
+                        },
+                        InlineAsmOperand::InOut { reg, late, expr } => {
+                            reg.hash(&mut self.s);
+                            late.hash(&mut self.s);
+                            self.hash_expr(expr);
+                        },
+                        InlineAsmOperand::SplitInOut {
+                            reg,
+                            late,
+                            in_expr,
+                            out_expr,
+                        } => {
+                            reg.hash(&mut self.s);
+                            late.hash(&mut self.s);
+                            self.hash_expr(in_expr);
+                            if let Some(out_expr) = out_expr {
+                                self.hash_expr(out_expr);
+                            }
+                        },
+                        InlineAsmOperand::Const { expr } | InlineAsmOperand::Sym { expr } => self.hash_expr(expr),
+                    }
+                }
+            },
+            ExprKind::LlvmInlineAsm(..) | ExprKind::Err => {},
+            ExprKind::Lit(ref l) => {
+                l.node.hash(&mut self.s);
+            },
+            ExprKind::Loop(ref b, ref i, ..) => {
+                self.hash_block(b);
+                if let Some(i) = *i {
+                    self.hash_name(i.ident.name);
+                }
+            },
+            ExprKind::If(ref cond, ref then, ref else_opt) => {
+                let c: fn(_, _, _) -> _ = ExprKind::If;
+                c.hash(&mut self.s);
+                self.hash_expr(cond);
+                self.hash_expr(&**then);
+                if let Some(ref e) = *else_opt {
+                    self.hash_expr(e);
+                }
+            },
+            ExprKind::Match(ref e, arms, ref s) => {
+                self.hash_expr(e);
+
+                for arm in arms {
+                    // TODO: arm.pat?
+                    if let Some(ref e) = arm.guard {
+                        self.hash_guard(e);
+                    }
+                    self.hash_expr(&arm.body);
+                }
+
+                s.hash(&mut self.s);
+            },
+            ExprKind::MethodCall(ref path, ref _tys, args, ref _fn_span) => {
+                self.hash_name(path.ident.name);
+                self.hash_exprs(args);
+            },
+            ExprKind::ConstBlock(ref l_id) => {
+                self.hash_body(l_id.body);
+            },
+            ExprKind::Repeat(ref e, ref l_id) => {
+                self.hash_expr(e);
+                self.hash_body(l_id.body);
+            },
+            ExprKind::Ret(ref e) => {
+                if let Some(ref e) = *e {
+                    self.hash_expr(e);
+                }
+            },
+            ExprKind::Path(ref qpath) => {
+                self.hash_qpath(qpath);
+            },
+            ExprKind::Struct(ref path, fields, ref expr) => {
+                self.hash_qpath(path);
+
+                for f in fields {
+                    self.hash_name(f.ident.name);
+                    self.hash_expr(&f.expr);
+                }
+
+                if let Some(ref e) = *expr {
+                    self.hash_expr(e);
+                }
+            },
+            ExprKind::Tup(tup) => {
+                self.hash_exprs(tup);
+            },
+            ExprKind::Array(v) => {
+                self.hash_exprs(v);
+            },
+            ExprKind::Unary(lop, ref le) => {
+                lop.hash_stable(&mut self.cx.tcx.get_stable_hashing_context(), &mut self.s);
+                self.hash_expr(le);
+            },
+        }
+    }
+
+    pub fn hash_exprs(&mut self, e: &[Expr<'_>]) {
+        for e in e {
+            self.hash_expr(e);
+        }
+    }
+
+    pub fn hash_name(&mut self, n: Symbol) {
+        n.as_str().hash(&mut self.s);
+    }
+
+    pub fn hash_qpath(&mut self, p: &QPath<'_>) {
+        match *p {
+            QPath::Resolved(_, ref path) => {
+                self.hash_path(path);
+            },
+            QPath::TypeRelative(_, ref path) => {
+                self.hash_name(path.ident.name);
+            },
+            QPath::LangItem(lang_item, ..) => {
+                lang_item.hash_stable(&mut self.cx.tcx.get_stable_hashing_context(), &mut self.s);
+            },
+        }
+        // self.maybe_typeck_results.unwrap().qpath_res(p, id).hash(&mut self.s);
+    }
+
+    pub fn hash_path(&mut self, path: &Path<'_>) {
+        match path.res {
+            // constant hash since equality is dependant on inter-expression context
+            Res::Local(_) => 1_usize.hash(&mut self.s),
+            _ => {
+                for seg in path.segments {
+                    self.hash_name(seg.ident.name);
+                }
+            },
+        }
+    }
+
+    pub fn hash_stmt(&mut self, b: &Stmt<'_>) {
+        std::mem::discriminant(&b.kind).hash(&mut self.s);
+
+        match &b.kind {
+            StmtKind::Local(local) => {
+                if let Some(ref init) = local.init {
+                    self.hash_expr(init);
+                }
+            },
+            StmtKind::Item(..) => {},
+            StmtKind::Expr(expr) | StmtKind::Semi(expr) => {
+                self.hash_expr(expr);
+            },
+        }
+    }
+
+    pub fn hash_guard(&mut self, g: &Guard<'_>) {
+        match g {
+            Guard::If(ref expr) | Guard::IfLet(_, ref expr) => {
+                self.hash_expr(expr);
+            },
+        }
+    }
+
+    pub fn hash_lifetime(&mut self, lifetime: &Lifetime) {
+        std::mem::discriminant(&lifetime.name).hash(&mut self.s);
+        if let LifetimeName::Param(ref name) = lifetime.name {
+            std::mem::discriminant(name).hash(&mut self.s);
+            match name {
+                ParamName::Plain(ref ident) => {
+                    ident.name.hash(&mut self.s);
+                },
+                ParamName::Fresh(ref size) => {
+                    size.hash(&mut self.s);
+                },
+                ParamName::Error => {},
+            }
+        }
+    }
+
+    pub fn hash_ty(&mut self, ty: &Ty<'_>) {
+        self.hash_tykind(&ty.kind);
+    }
+
+    pub fn hash_tykind(&mut self, ty: &TyKind<'_>) {
+        std::mem::discriminant(ty).hash(&mut self.s);
+        match ty {
+            TyKind::Slice(ty) => {
+                self.hash_ty(ty);
+            },
+            TyKind::Array(ty, anon_const) => {
+                self.hash_ty(ty);
+                self.hash_body(anon_const.body);
+            },
+            TyKind::Ptr(mut_ty) => {
+                self.hash_ty(&mut_ty.ty);
+                mut_ty.mutbl.hash(&mut self.s);
+            },
+            TyKind::Rptr(lifetime, mut_ty) => {
+                self.hash_lifetime(lifetime);
+                self.hash_ty(&mut_ty.ty);
+                mut_ty.mutbl.hash(&mut self.s);
+            },
+            TyKind::BareFn(bfn) => {
+                bfn.unsafety.hash(&mut self.s);
+                bfn.abi.hash(&mut self.s);
+                for arg in bfn.decl.inputs {
+                    self.hash_ty(&arg);
+                }
+                match bfn.decl.output {
+                    FnRetTy::DefaultReturn(_) => {
+                        ().hash(&mut self.s);
+                    },
+                    FnRetTy::Return(ref ty) => {
+                        self.hash_ty(ty);
+                    },
+                }
+                bfn.decl.c_variadic.hash(&mut self.s);
+            },
+            TyKind::Tup(ty_list) => {
+                for ty in *ty_list {
+                    self.hash_ty(ty);
+                }
+            },
+            TyKind::Path(qpath) => match qpath {
+                QPath::Resolved(ref maybe_ty, ref path) => {
+                    if let Some(ref ty) = maybe_ty {
+                        self.hash_ty(ty);
+                    }
+                    for segment in path.segments {
+                        segment.ident.name.hash(&mut self.s);
+                        self.hash_generic_args(segment.args().args);
+                    }
+                },
+                QPath::TypeRelative(ref ty, ref segment) => {
+                    self.hash_ty(ty);
+                    segment.ident.name.hash(&mut self.s);
+                },
+                QPath::LangItem(lang_item, ..) => {
+                    lang_item.hash(&mut self.s);
+                },
+            },
+            TyKind::OpaqueDef(_, arg_list) => {
+                self.hash_generic_args(arg_list);
+            },
+            TyKind::TraitObject(_, lifetime) => {
+                self.hash_lifetime(lifetime);
+            },
+            TyKind::Typeof(anon_const) => {
+                self.hash_body(anon_const.body);
+            },
+            TyKind::Err | TyKind::Infer | TyKind::Never => {},
+        }
+    }
+
+    pub fn hash_body(&mut self, body_id: BodyId) {
+        // swap out TypeckResults when hashing a body
+        let old_maybe_typeck_results = self.maybe_typeck_results.replace(self.cx.tcx.typeck_body(body_id));
+        self.hash_expr(&self.cx.tcx.hir().body(body_id).value);
+        self.maybe_typeck_results = old_maybe_typeck_results;
+    }
+
+    fn hash_generic_args(&mut self, arg_list: &[GenericArg<'_>]) {
+        for arg in arg_list {
+            match arg {
+                GenericArg::Lifetime(ref l) => self.hash_lifetime(l),
+                GenericArg::Type(ref ty) => self.hash_ty(&ty),
+                GenericArg::Const(ref ca) => self.hash_body(ca.value.body),
+            }
+        }
+    }
+}
diff --git a/clippy_utils/src/inspector.rs b/clippy_utils/src/inspector.rs
new file mode 100644
index 00000000000..b082bb6cfda
--- /dev/null
+++ b/clippy_utils/src/inspector.rs
@@ -0,0 +1,578 @@
+//! checks for attributes
+
+use crate::{declare_clippy_lint, get_attr};
+use rustc_ast::ast::{Attribute, InlineAsmTemplatePiece};
+use rustc_hir as hir;
+use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_session::Session;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// **What it does:** Dumps every ast/hir node which has the `#[clippy::dump]`
+    /// attribute
+    ///
+    /// **Example:**
+    /// ```rust,ignore
+    /// #[clippy::dump]
+    /// extern crate foo;
+    /// ```
+    ///
+    /// prints
+    ///
+    /// ```text
+    /// item `foo`
+    /// visibility inherited from outer item
+    /// extern crate dylib source: "/path/to/foo.so"
+    /// ```
+    pub DEEP_CODE_INSPECTION,
+    internal_warn,
+    "helper to dump info about code"
+}
+
+declare_lint_pass!(DeepCodeInspector => [DEEP_CODE_INSPECTION]);
+
+impl<'tcx> LateLintPass<'tcx> for DeepCodeInspector {
+    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) {
+        if !has_attr(cx.sess(), &item.attrs) {
+            return;
+        }
+        print_item(cx, item);
+    }
+
+    fn check_impl_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::ImplItem<'_>) {
+        if !has_attr(cx.sess(), &item.attrs) {
+            return;
+        }
+        println!("impl item `{}`", item.ident.name);
+        match item.vis.node {
+            hir::VisibilityKind::Public => println!("public"),
+            hir::VisibilityKind::Crate(_) => println!("visible crate wide"),
+            hir::VisibilityKind::Restricted { ref path, .. } => println!(
+                "visible in module `{}`",
+                rustc_hir_pretty::to_string(rustc_hir_pretty::NO_ANN, |s| s.print_path(path, false))
+            ),
+            hir::VisibilityKind::Inherited => println!("visibility inherited from outer item"),
+        }
+        if item.defaultness.is_default() {
+            println!("default");
+        }
+        match item.kind {
+            hir::ImplItemKind::Const(_, body_id) => {
+                println!("associated constant");
+                print_expr(cx, &cx.tcx.hir().body(body_id).value, 1);
+            },
+            hir::ImplItemKind::Fn(..) => println!("method"),
+            hir::ImplItemKind::TyAlias(_) => println!("associated type"),
+        }
+    }
+    // fn check_trait_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx
+    // hir::TraitItem) {
+    // if !has_attr(&item.attrs) {
+    // return;
+    // }
+    // }
+    //
+    // fn check_variant(&mut self, cx: &LateContext<'tcx>, var: &'tcx
+    // hir::Variant, _:
+    // &hir::Generics) {
+    // if !has_attr(&var.node.attrs) {
+    // return;
+    // }
+    // }
+    //
+    // fn check_struct_field(&mut self, cx: &LateContext<'tcx>, field: &'tcx
+    // hir::StructField) {
+    // if !has_attr(&field.attrs) {
+    // return;
+    // }
+    // }
+    //
+
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
+        if !has_attr(cx.sess(), &expr.attrs) {
+            return;
+        }
+        print_expr(cx, expr, 0);
+    }
+
+    fn check_arm(&mut self, cx: &LateContext<'tcx>, arm: &'tcx hir::Arm<'_>) {
+        if !has_attr(cx.sess(), &arm.attrs) {
+            return;
+        }
+        print_pat(cx, &arm.pat, 1);
+        if let Some(ref guard) = arm.guard {
+            println!("guard:");
+            print_guard(cx, guard, 1);
+        }
+        println!("body:");
+        print_expr(cx, &arm.body, 1);
+    }
+
+    fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx hir::Stmt<'_>) {
+        if !has_attr(cx.sess(), stmt.kind.attrs(|id| cx.tcx.hir().item(id.id))) {
+            return;
+        }
+        match stmt.kind {
+            hir::StmtKind::Local(ref local) => {
+                println!("local variable of type {}", cx.typeck_results().node_type(local.hir_id));
+                println!("pattern:");
+                print_pat(cx, &local.pat, 0);
+                if let Some(ref e) = local.init {
+                    println!("init expression:");
+                    print_expr(cx, e, 0);
+                }
+            },
+            hir::StmtKind::Item(_) => println!("item decl"),
+            hir::StmtKind::Expr(ref e) | hir::StmtKind::Semi(ref e) => print_expr(cx, e, 0),
+        }
+    }
+    // fn check_foreign_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx
+    // hir::ForeignItem) {
+    // if !has_attr(&item.attrs) {
+    // return;
+    // }
+    // }
+    //
+}
+
+fn has_attr(sess: &Session, attrs: &[Attribute]) -> bool {
+    get_attr(sess, attrs, "dump").count() > 0
+}
+
+#[allow(clippy::similar_names)]
+#[allow(clippy::too_many_lines)]
+fn print_expr(cx: &LateContext<'_>, expr: &hir::Expr<'_>, indent: usize) {
+    let ind = "  ".repeat(indent);
+    println!("{}+", ind);
+    println!("{}ty: {}", ind, cx.typeck_results().expr_ty(expr));
+    println!(
+        "{}adjustments: {:?}",
+        ind,
+        cx.typeck_results().adjustments().get(expr.hir_id)
+    );
+    match expr.kind {
+        hir::ExprKind::Box(ref e) => {
+            println!("{}Box", ind);
+            print_expr(cx, e, indent + 1);
+        },
+        hir::ExprKind::Array(v) => {
+            println!("{}Array", ind);
+            for e in v {
+                print_expr(cx, e, indent + 1);
+            }
+        },
+        hir::ExprKind::Call(ref func, args) => {
+            println!("{}Call", ind);
+            println!("{}function:", ind);
+            print_expr(cx, func, indent + 1);
+            println!("{}arguments:", ind);
+            for arg in args {
+                print_expr(cx, arg, indent + 1);
+            }
+        },
+        hir::ExprKind::MethodCall(ref path, _, args, _) => {
+            println!("{}MethodCall", ind);
+            println!("{}method name: {}", ind, path.ident.name);
+            for arg in args {
+                print_expr(cx, arg, indent + 1);
+            }
+        },
+        hir::ExprKind::Tup(v) => {
+            println!("{}Tup", ind);
+            for e in v {
+                print_expr(cx, e, indent + 1);
+            }
+        },
+        hir::ExprKind::Binary(op, ref lhs, ref rhs) => {
+            println!("{}Binary", ind);
+            println!("{}op: {:?}", ind, op.node);
+            println!("{}lhs:", ind);
+            print_expr(cx, lhs, indent + 1);
+            println!("{}rhs:", ind);
+            print_expr(cx, rhs, indent + 1);
+        },
+        hir::ExprKind::Unary(op, ref inner) => {
+            println!("{}Unary", ind);
+            println!("{}op: {:?}", ind, op);
+            print_expr(cx, inner, indent + 1);
+        },
+        hir::ExprKind::Lit(ref lit) => {
+            println!("{}Lit", ind);
+            println!("{}{:?}", ind, lit);
+        },
+        hir::ExprKind::Cast(ref e, ref target) => {
+            println!("{}Cast", ind);
+            print_expr(cx, e, indent + 1);
+            println!("{}target type: {:?}", ind, target);
+        },
+        hir::ExprKind::Type(ref e, ref target) => {
+            println!("{}Type", ind);
+            print_expr(cx, e, indent + 1);
+            println!("{}target type: {:?}", ind, target);
+        },
+        hir::ExprKind::Loop(..) => {
+            println!("{}Loop", ind);
+        },
+        hir::ExprKind::If(ref cond, _, ref else_opt) => {
+            println!("{}If", ind);
+            println!("{}condition:", ind);
+            print_expr(cx, cond, indent + 1);
+            if let Some(ref els) = *else_opt {
+                println!("{}else:", ind);
+                print_expr(cx, els, indent + 1);
+            }
+        },
+        hir::ExprKind::Match(ref cond, _, ref source) => {
+            println!("{}Match", ind);
+            println!("{}condition:", ind);
+            print_expr(cx, cond, indent + 1);
+            println!("{}source: {:?}", ind, source);
+        },
+        hir::ExprKind::Closure(ref clause, _, _, _, _) => {
+            println!("{}Closure", ind);
+            println!("{}clause: {:?}", ind, clause);
+        },
+        hir::ExprKind::Yield(ref sub, _) => {
+            println!("{}Yield", ind);
+            print_expr(cx, sub, indent + 1);
+        },
+        hir::ExprKind::Block(_, _) => {
+            println!("{}Block", ind);
+        },
+        hir::ExprKind::Assign(ref lhs, ref rhs, _) => {
+            println!("{}Assign", ind);
+            println!("{}lhs:", ind);
+            print_expr(cx, lhs, indent + 1);
+            println!("{}rhs:", ind);
+            print_expr(cx, rhs, indent + 1);
+        },
+        hir::ExprKind::AssignOp(ref binop, ref lhs, ref rhs) => {
+            println!("{}AssignOp", ind);
+            println!("{}op: {:?}", ind, binop.node);
+            println!("{}lhs:", ind);
+            print_expr(cx, lhs, indent + 1);
+            println!("{}rhs:", ind);
+            print_expr(cx, rhs, indent + 1);
+        },
+        hir::ExprKind::Field(ref e, ident) => {
+            println!("{}Field", ind);
+            println!("{}field name: {}", ind, ident.name);
+            println!("{}struct expr:", ind);
+            print_expr(cx, e, indent + 1);
+        },
+        hir::ExprKind::Index(ref arr, ref idx) => {
+            println!("{}Index", ind);
+            println!("{}array expr:", ind);
+            print_expr(cx, arr, indent + 1);
+            println!("{}index expr:", ind);
+            print_expr(cx, idx, indent + 1);
+        },
+        hir::ExprKind::Path(hir::QPath::Resolved(ref ty, ref path)) => {
+            println!("{}Resolved Path, {:?}", ind, ty);
+            println!("{}path: {:?}", ind, path);
+        },
+        hir::ExprKind::Path(hir::QPath::TypeRelative(ref ty, ref seg)) => {
+            println!("{}Relative Path, {:?}", ind, ty);
+            println!("{}seg: {:?}", ind, seg);
+        },
+        hir::ExprKind::Path(hir::QPath::LangItem(lang_item, ..)) => {
+            println!("{}Lang Item Path, {:?}", ind, lang_item.name());
+        },
+        hir::ExprKind::AddrOf(kind, ref muta, ref e) => {
+            println!("{}AddrOf", ind);
+            println!("kind: {:?}", kind);
+            println!("mutability: {:?}", muta);
+            print_expr(cx, e, indent + 1);
+        },
+        hir::ExprKind::Break(_, ref e) => {
+            println!("{}Break", ind);
+            if let Some(ref e) = *e {
+                print_expr(cx, e, indent + 1);
+            }
+        },
+        hir::ExprKind::Continue(_) => println!("{}Again", ind),
+        hir::ExprKind::Ret(ref e) => {
+            println!("{}Ret", ind);
+            if let Some(ref e) = *e {
+                print_expr(cx, e, indent + 1);
+            }
+        },
+        hir::ExprKind::InlineAsm(ref asm) => {
+            println!("{}InlineAsm", ind);
+            println!("{}template: {}", ind, InlineAsmTemplatePiece::to_string(asm.template));
+            println!("{}options: {:?}", ind, asm.options);
+            println!("{}operands:", ind);
+            for (op, _op_sp) in asm.operands {
+                match op {
+                    hir::InlineAsmOperand::In { expr, .. }
+                    | hir::InlineAsmOperand::InOut { expr, .. }
+                    | hir::InlineAsmOperand::Const { expr }
+                    | hir::InlineAsmOperand::Sym { expr } => print_expr(cx, expr, indent + 1),
+                    hir::InlineAsmOperand::Out { expr, .. } => {
+                        if let Some(expr) = expr {
+                            print_expr(cx, expr, indent + 1);
+                        }
+                    },
+                    hir::InlineAsmOperand::SplitInOut { in_expr, out_expr, .. } => {
+                        print_expr(cx, in_expr, indent + 1);
+                        if let Some(out_expr) = out_expr {
+                            print_expr(cx, out_expr, indent + 1);
+                        }
+                    },
+                }
+            }
+        },
+        hir::ExprKind::LlvmInlineAsm(ref asm) => {
+            let inputs = &asm.inputs_exprs;
+            let outputs = &asm.outputs_exprs;
+            println!("{}LlvmInlineAsm", ind);
+            println!("{}inputs:", ind);
+            for e in inputs.iter() {
+                print_expr(cx, e, indent + 1);
+            }
+            println!("{}outputs:", ind);
+            for e in outputs.iter() {
+                print_expr(cx, e, indent + 1);
+            }
+        },
+        hir::ExprKind::Struct(ref path, fields, ref base) => {
+            println!("{}Struct", ind);
+            println!("{}path: {:?}", ind, path);
+            for field in fields {
+                println!("{}field \"{}\":", ind, field.ident.name);
+                print_expr(cx, &field.expr, indent + 1);
+            }
+            if let Some(ref base) = *base {
+                println!("{}base:", ind);
+                print_expr(cx, base, indent + 1);
+            }
+        },
+        hir::ExprKind::ConstBlock(ref anon_const) => {
+            println!("{}ConstBlock", ind);
+            println!("{}anon_const:", ind);
+            print_expr(cx, &cx.tcx.hir().body(anon_const.body).value, indent + 1);
+        },
+        hir::ExprKind::Repeat(ref val, ref anon_const) => {
+            println!("{}Repeat", ind);
+            println!("{}value:", ind);
+            print_expr(cx, val, indent + 1);
+            println!("{}repeat count:", ind);
+            print_expr(cx, &cx.tcx.hir().body(anon_const.body).value, indent + 1);
+        },
+        hir::ExprKind::Err => {
+            println!("{}Err", ind);
+        },
+        hir::ExprKind::DropTemps(ref e) => {
+            println!("{}DropTemps", ind);
+            print_expr(cx, e, indent + 1);
+        },
+    }
+}
+
+fn print_item(cx: &LateContext<'_>, item: &hir::Item<'_>) {
+    let did = cx.tcx.hir().local_def_id(item.hir_id);
+    println!("item `{}`", item.ident.name);
+    match item.vis.node {
+        hir::VisibilityKind::Public => println!("public"),
+        hir::VisibilityKind::Crate(_) => println!("visible crate wide"),
+        hir::VisibilityKind::Restricted { ref path, .. } => println!(
+            "visible in module `{}`",
+            rustc_hir_pretty::to_string(rustc_hir_pretty::NO_ANN, |s| s.print_path(path, false))
+        ),
+        hir::VisibilityKind::Inherited => println!("visibility inherited from outer item"),
+    }
+    match item.kind {
+        hir::ItemKind::ExternCrate(ref _renamed_from) => {
+            let def_id = cx.tcx.hir().local_def_id(item.hir_id);
+            if let Some(crate_id) = cx.tcx.extern_mod_stmt_cnum(def_id) {
+                let source = cx.tcx.used_crate_source(crate_id);
+                if let Some(ref src) = source.dylib {
+                    println!("extern crate dylib source: {:?}", src.0);
+                }
+                if let Some(ref src) = source.rlib {
+                    println!("extern crate rlib source: {:?}", src.0);
+                }
+            } else {
+                println!("weird extern crate without a crate id");
+            }
+        },
+        hir::ItemKind::Use(ref path, ref kind) => println!("{:?}, {:?}", path, kind),
+        hir::ItemKind::Static(..) => println!("static item of type {:#?}", cx.tcx.type_of(did)),
+        hir::ItemKind::Const(..) => println!("const item of type {:#?}", cx.tcx.type_of(did)),
+        hir::ItemKind::Fn(..) => {
+            let item_ty = cx.tcx.type_of(did);
+            println!("function of type {:#?}", item_ty);
+        },
+        hir::ItemKind::Mod(..) => println!("module"),
+        hir::ItemKind::ForeignMod { abi, .. } => println!("foreign module with abi: {}", abi),
+        hir::ItemKind::GlobalAsm(ref asm) => println!("global asm: {:?}", asm),
+        hir::ItemKind::TyAlias(..) => {
+            println!("type alias for {:?}", cx.tcx.type_of(did));
+        },
+        hir::ItemKind::OpaqueTy(..) => {
+            println!("existential type with real type {:?}", cx.tcx.type_of(did));
+        },
+        hir::ItemKind::Enum(..) => {
+            println!("enum definition of type {:?}", cx.tcx.type_of(did));
+        },
+        hir::ItemKind::Struct(..) => {
+            println!("struct definition of type {:?}", cx.tcx.type_of(did));
+        },
+        hir::ItemKind::Union(..) => {
+            println!("union definition of type {:?}", cx.tcx.type_of(did));
+        },
+        hir::ItemKind::Trait(..) => {
+            println!("trait decl");
+            if cx.tcx.trait_is_auto(did.to_def_id()) {
+                println!("trait is auto");
+            } else {
+                println!("trait is not auto");
+            }
+        },
+        hir::ItemKind::TraitAlias(..) => {
+            println!("trait alias");
+        },
+        hir::ItemKind::Impl(hir::Impl {
+            of_trait: Some(ref _trait_ref),
+            ..
+        }) => {
+            println!("trait impl");
+        },
+        hir::ItemKind::Impl(hir::Impl { of_trait: None, .. }) => {
+            println!("impl");
+        },
+    }
+}
+
+#[allow(clippy::similar_names)]
+#[allow(clippy::too_many_lines)]
+fn print_pat(cx: &LateContext<'_>, pat: &hir::Pat<'_>, indent: usize) {
+    let ind = "  ".repeat(indent);
+    println!("{}+", ind);
+    match pat.kind {
+        hir::PatKind::Wild => println!("{}Wild", ind),
+        hir::PatKind::Binding(ref mode, .., ident, ref inner) => {
+            println!("{}Binding", ind);
+            println!("{}mode: {:?}", ind, mode);
+            println!("{}name: {}", ind, ident.name);
+            if let Some(ref inner) = *inner {
+                println!("{}inner:", ind);
+                print_pat(cx, inner, indent + 1);
+            }
+        },
+        hir::PatKind::Or(fields) => {
+            println!("{}Or", ind);
+            for field in fields {
+                print_pat(cx, field, indent + 1);
+            }
+        },
+        hir::PatKind::Struct(ref path, fields, ignore) => {
+            println!("{}Struct", ind);
+            println!(
+                "{}name: {}",
+                ind,
+                rustc_hir_pretty::to_string(rustc_hir_pretty::NO_ANN, |s| s.print_qpath(path, false))
+            );
+            println!("{}ignore leftover fields: {}", ind, ignore);
+            println!("{}fields:", ind);
+            for field in fields {
+                println!("{}  field name: {}", ind, field.ident.name);
+                if field.is_shorthand {
+                    println!("{}  in shorthand notation", ind);
+                }
+                print_pat(cx, &field.pat, indent + 1);
+            }
+        },
+        hir::PatKind::TupleStruct(ref path, fields, opt_dots_position) => {
+            println!("{}TupleStruct", ind);
+            println!(
+                "{}path: {}",
+                ind,
+                rustc_hir_pretty::to_string(rustc_hir_pretty::NO_ANN, |s| s.print_qpath(path, false))
+            );
+            if let Some(dot_position) = opt_dots_position {
+                println!("{}dot position: {}", ind, dot_position);
+            }
+            for field in fields {
+                print_pat(cx, field, indent + 1);
+            }
+        },
+        hir::PatKind::Path(hir::QPath::Resolved(ref ty, ref path)) => {
+            println!("{}Resolved Path, {:?}", ind, ty);
+            println!("{}path: {:?}", ind, path);
+        },
+        hir::PatKind::Path(hir::QPath::TypeRelative(ref ty, ref seg)) => {
+            println!("{}Relative Path, {:?}", ind, ty);
+            println!("{}seg: {:?}", ind, seg);
+        },
+        hir::PatKind::Path(hir::QPath::LangItem(lang_item, ..)) => {
+            println!("{}Lang Item Path, {:?}", ind, lang_item.name());
+        },
+        hir::PatKind::Tuple(pats, opt_dots_position) => {
+            println!("{}Tuple", ind);
+            if let Some(dot_position) = opt_dots_position {
+                println!("{}dot position: {}", ind, dot_position);
+            }
+            for field in pats {
+                print_pat(cx, field, indent + 1);
+            }
+        },
+        hir::PatKind::Box(ref inner) => {
+            println!("{}Box", ind);
+            print_pat(cx, inner, indent + 1);
+        },
+        hir::PatKind::Ref(ref inner, ref muta) => {
+            println!("{}Ref", ind);
+            println!("{}mutability: {:?}", ind, muta);
+            print_pat(cx, inner, indent + 1);
+        },
+        hir::PatKind::Lit(ref e) => {
+            println!("{}Lit", ind);
+            print_expr(cx, e, indent + 1);
+        },
+        hir::PatKind::Range(ref l, ref r, ref range_end) => {
+            println!("{}Range", ind);
+            if let Some(expr) = l {
+                print_expr(cx, expr, indent + 1);
+            }
+            if let Some(expr) = r {
+                print_expr(cx, expr, indent + 1);
+            }
+            match *range_end {
+                hir::RangeEnd::Included => println!("{} end included", ind),
+                hir::RangeEnd::Excluded => println!("{} end excluded", ind),
+            }
+        },
+        hir::PatKind::Slice(first_pats, ref range, last_pats) => {
+            println!("{}Slice [a, b, ..i, y, z]", ind);
+            println!("[a, b]:");
+            for pat in first_pats {
+                print_pat(cx, pat, indent + 1);
+            }
+            println!("i:");
+            if let Some(ref pat) = *range {
+                print_pat(cx, pat, indent + 1);
+            }
+            println!("[y, z]:");
+            for pat in last_pats {
+                print_pat(cx, pat, indent + 1);
+            }
+        },
+    }
+}
+
+fn print_guard(cx: &LateContext<'_>, guard: &hir::Guard<'_>, indent: usize) {
+    let ind = "  ".repeat(indent);
+    println!("{}+", ind);
+    match guard {
+        hir::Guard::If(expr) => {
+            println!("{}If", ind);
+            print_expr(cx, expr, indent + 1);
+        },
+        hir::Guard::IfLet(pat, expr) => {
+            println!("{}IfLet", ind);
+            print_pat(cx, pat, indent + 1);
+            print_expr(cx, expr, indent + 1);
+        },
+    }
+}
diff --git a/clippy_utils/src/internal_lints.rs b/clippy_utils/src/internal_lints.rs
new file mode 100644
index 00000000000..164ecb23b14
--- /dev/null
+++ b/clippy_utils/src/internal_lints.rs
@@ -0,0 +1,1070 @@
+use crate::consts::{constant_simple, Constant};
+use crate::{
+    is_expn_of, match_def_path, match_qpath, match_type, method_calls, path_to_res, paths, run_lints, snippet,
+    span_lint, span_lint_and_help, span_lint_and_sugg, SpanlessEq,
+};
+use if_chain::if_chain;
+use rustc_ast::ast::{Crate as AstCrate, ItemKind, LitKind, NodeId};
+use rustc_ast::visit::FnKind;
+use rustc_data_structures::fx::{FxHashMap, FxHashSet};
+use rustc_errors::Applicability;
+use rustc_hir as hir;
+use rustc_hir::def::{DefKind, Res};
+use rustc_hir::def_id::DefId;
+use rustc_hir::hir_id::CRATE_HIR_ID;
+use rustc_hir::intravisit::{NestedVisitorMap, Visitor};
+use rustc_hir::{
+    BinOpKind, Crate, Expr, ExprKind, HirId, Item, MutTy, Mutability, Node, Path, StmtKind, Ty, TyKind, UnOp,
+};
+use rustc_lint::{EarlyContext, EarlyLintPass, LateContext, LateLintPass};
+use rustc_middle::hir::map::Map;
+use rustc_middle::mir::interpret::ConstValue;
+use rustc_middle::ty;
+use rustc_session::{declare_lint_pass, declare_tool_lint, impl_lint_pass};
+use rustc_span::source_map::{Span, Spanned};
+use rustc_span::symbol::{Symbol, SymbolStr};
+use rustc_typeck::hir_ty_to_ty;
+
+use std::borrow::{Borrow, Cow};
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for various things we like to keep tidy in clippy.
+    ///
+    /// **Why is this bad?** We like to pretend we're an example of tidy code.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:** Wrong ordering of the util::paths constants.
+    pub CLIPPY_LINTS_INTERNAL,
+    internal,
+    "various things that will negatively affect your clippy experience"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Ensures every lint is associated to a `LintPass`.
+    ///
+    /// **Why is this bad?** The compiler only knows lints via a `LintPass`. Without
+    /// putting a lint to a `LintPass::get_lints()`'s return, the compiler will not
+    /// know the name of the lint.
+    ///
+    /// **Known problems:** Only checks for lints associated using the
+    /// `declare_lint_pass!`, `impl_lint_pass!`, and `lint_array!` macros.
+    ///
+    /// **Example:**
+    /// ```rust,ignore
+    /// declare_lint! { pub LINT_1, ... }
+    /// declare_lint! { pub LINT_2, ... }
+    /// declare_lint! { pub FORGOTTEN_LINT, ... }
+    /// // ...
+    /// declare_lint_pass!(Pass => [LINT_1, LINT_2]);
+    /// // missing FORGOTTEN_LINT
+    /// ```
+    pub LINT_WITHOUT_LINT_PASS,
+    internal,
+    "declaring a lint without associating it in a LintPass"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for calls to `cx.span_lint*` and suggests to use the `utils::*`
+    /// variant of the function.
+    ///
+    /// **Why is this bad?** The `utils::*` variants also add a link to the Clippy documentation to the
+    /// warning/error messages.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// Bad:
+    /// ```rust,ignore
+    /// cx.span_lint(LINT_NAME, "message");
+    /// ```
+    ///
+    /// Good:
+    /// ```rust,ignore
+    /// utils::span_lint(cx, LINT_NAME, "message");
+    /// ```
+    pub COMPILER_LINT_FUNCTIONS,
+    internal,
+    "usage of the lint functions of the compiler instead of the utils::* variant"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for calls to `cx.outer().expn_data()` and suggests to use
+    /// the `cx.outer_expn_data()`
+    ///
+    /// **Why is this bad?** `cx.outer_expn_data()` is faster and more concise.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// Bad:
+    /// ```rust,ignore
+    /// expr.span.ctxt().outer().expn_data()
+    /// ```
+    ///
+    /// Good:
+    /// ```rust,ignore
+    /// expr.span.ctxt().outer_expn_data()
+    /// ```
+    pub OUTER_EXPN_EXPN_DATA,
+    internal,
+    "using `cx.outer_expn().expn_data()` instead of `cx.outer_expn_data()`"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Not an actual lint. This lint is only meant for testing our customized internal compiler
+    /// error message by calling `panic`.
+    ///
+    /// **Why is this bad?** ICE in large quantities can damage your teeth
+    ///
+    /// **Known problems:** None
+    ///
+    /// **Example:**
+    /// Bad:
+    /// ```rust,ignore
+    /// 🍦🍦🍦🍦🍦
+    /// ```
+    pub PRODUCE_ICE,
+    internal,
+    "this message should not appear anywhere as we ICE before and don't emit the lint"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for cases of an auto-generated lint without an updated description,
+    /// i.e. `default lint description`.
+    ///
+    /// **Why is this bad?** Indicates that the lint is not finished.
+    ///
+    /// **Known problems:** None
+    ///
+    /// **Example:**
+    /// Bad:
+    /// ```rust,ignore
+    /// declare_lint! { pub COOL_LINT, nursery, "default lint description" }
+    /// ```
+    ///
+    /// Good:
+    /// ```rust,ignore
+    /// declare_lint! { pub COOL_LINT, nursery, "a great new lint" }
+    /// ```
+    pub DEFAULT_LINT,
+    internal,
+    "found 'default lint description' in a lint declaration"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Lints `span_lint_and_then` function calls, where the
+    /// closure argument has only one statement and that statement is a method
+    /// call to `span_suggestion`, `span_help`, `span_note` (using the same
+    /// span), `help` or `note`.
+    ///
+    /// These usages of `span_lint_and_then` should be replaced with one of the
+    /// wrapper functions `span_lint_and_sugg`, span_lint_and_help`, or
+    /// `span_lint_and_note`.
+    ///
+    /// **Why is this bad?** Using the wrapper `span_lint_and_*` functions, is more
+    /// convenient, readable and less error prone.
+    ///
+    /// **Known problems:** None
+    ///
+    /// *Example:**
+    /// Bad:
+    /// ```rust,ignore
+    /// span_lint_and_then(cx, TEST_LINT, expr.span, lint_msg, |diag| {
+    ///     diag.span_suggestion(
+    ///         expr.span,
+    ///         help_msg,
+    ///         sugg.to_string(),
+    ///         Applicability::MachineApplicable,
+    ///     );
+    /// });
+    /// span_lint_and_then(cx, TEST_LINT, expr.span, lint_msg, |diag| {
+    ///     diag.span_help(expr.span, help_msg);
+    /// });
+    /// span_lint_and_then(cx, TEST_LINT, expr.span, lint_msg, |diag| {
+    ///     diag.help(help_msg);
+    /// });
+    /// span_lint_and_then(cx, TEST_LINT, expr.span, lint_msg, |diag| {
+    ///     diag.span_note(expr.span, note_msg);
+    /// });
+    /// span_lint_and_then(cx, TEST_LINT, expr.span, lint_msg, |diag| {
+    ///     diag.note(note_msg);
+    /// });
+    /// ```
+    ///
+    /// Good:
+    /// ```rust,ignore
+    /// span_lint_and_sugg(
+    ///     cx,
+    ///     TEST_LINT,
+    ///     expr.span,
+    ///     lint_msg,
+    ///     help_msg,
+    ///     sugg.to_string(),
+    ///     Applicability::MachineApplicable,
+    /// );
+    /// span_lint_and_help(cx, TEST_LINT, expr.span, lint_msg, Some(expr.span), help_msg);
+    /// span_lint_and_help(cx, TEST_LINT, expr.span, lint_msg, None, help_msg);
+    /// span_lint_and_note(cx, TEST_LINT, expr.span, lint_msg, Some(expr.span), note_msg);
+    /// span_lint_and_note(cx, TEST_LINT, expr.span, lint_msg, None, note_msg);
+    /// ```
+    pub COLLAPSIBLE_SPAN_LINT_CALLS,
+    internal,
+    "found collapsible `span_lint_and_then` calls"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for calls to `utils::match_type()` on a type diagnostic item
+    /// and suggests to use `utils::is_type_diagnostic_item()` instead.
+    ///
+    /// **Why is this bad?** `utils::is_type_diagnostic_item()` does not require hardcoded paths.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// Bad:
+    /// ```rust,ignore
+    /// utils::match_type(cx, ty, &paths::VEC)
+    /// ```
+    ///
+    /// Good:
+    /// ```rust,ignore
+    /// utils::is_type_diagnostic_item(cx, ty, sym::vec_type)
+    /// ```
+    pub MATCH_TYPE_ON_DIAGNOSTIC_ITEM,
+    internal,
+    "using `utils::match_type()` instead of `utils::is_type_diagnostic_item()`"
+}
+
+declare_clippy_lint! {
+    /// **What it does:**
+    /// Checks the paths module for invalid paths.
+    ///
+    /// **Why is this bad?**
+    /// It indicates a bug in the code.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:** None.
+    pub INVALID_PATHS,
+    internal,
+    "invalid path"
+}
+
+declare_clippy_lint! {
+    /// **What it does:**
+    /// Checks for interning symbols that have already been pre-interned and defined as constants.
+    ///
+    /// **Why is this bad?**
+    /// It's faster and easier to use the symbol constant.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// Bad:
+    /// ```rust,ignore
+    /// let _ = sym!(f32);
+    /// ```
+    ///
+    /// Good:
+    /// ```rust,ignore
+    /// let _ = sym::f32;
+    /// ```
+    pub INTERNING_DEFINED_SYMBOL,
+    internal,
+    "interning a symbol that is pre-interned and defined as a constant"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for unnecessary conversion from Symbol to a string.
+    ///
+    /// **Why is this bad?** It's faster use symbols directly intead of strings.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// Bad:
+    /// ```rust,ignore
+    /// symbol.as_str() == "clippy";
+    /// ```
+    ///
+    /// Good:
+    /// ```rust,ignore
+    /// symbol == sym::clippy;
+    /// ```
+    pub UNNECESSARY_SYMBOL_STR,
+    internal,
+    "unnecessary conversion between Symbol and string"
+}
+
+declare_lint_pass!(ClippyLintsInternal => [CLIPPY_LINTS_INTERNAL]);
+
+impl EarlyLintPass for ClippyLintsInternal {
+    fn check_crate(&mut self, cx: &EarlyContext<'_>, krate: &AstCrate) {
+        if let Some(utils) = krate
+            .module
+            .items
+            .iter()
+            .find(|item| item.ident.name.as_str() == "utils")
+        {
+            if let ItemKind::Mod(ref utils_mod) = utils.kind {
+                if let Some(paths) = utils_mod.items.iter().find(|item| item.ident.name.as_str() == "paths") {
+                    if let ItemKind::Mod(ref paths_mod) = paths.kind {
+                        let mut last_name: Option<SymbolStr> = None;
+                        for item in &*paths_mod.items {
+                            let name = item.ident.as_str();
+                            if let Some(ref last_name) = last_name {
+                                if **last_name > *name {
+                                    span_lint(
+                                        cx,
+                                        CLIPPY_LINTS_INTERNAL,
+                                        item.span,
+                                        "this constant should be before the previous constant due to lexical \
+                                         ordering",
+                                    );
+                                }
+                            }
+                            last_name = Some(name);
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+#[derive(Clone, Debug, Default)]
+pub struct LintWithoutLintPass {
+    declared_lints: FxHashMap<Symbol, Span>,
+    registered_lints: FxHashSet<Symbol>,
+}
+
+impl_lint_pass!(LintWithoutLintPass => [DEFAULT_LINT, LINT_WITHOUT_LINT_PASS]);
+
+impl<'tcx> LateLintPass<'tcx> for LintWithoutLintPass {
+    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
+        if !run_lints(cx, &[DEFAULT_LINT], item.hir_id) {
+            return;
+        }
+
+        if let hir::ItemKind::Static(ref ty, Mutability::Not, body_id) = item.kind {
+            if is_lint_ref_type(cx, ty) {
+                let expr = &cx.tcx.hir().body(body_id).value;
+                if_chain! {
+                    if let ExprKind::AddrOf(_, _, ref inner_exp) = expr.kind;
+                    if let ExprKind::Struct(_, ref fields, _) = inner_exp.kind;
+                    let field = fields
+                        .iter()
+                        .find(|f| f.ident.as_str() == "desc")
+                        .expect("lints must have a description field");
+                    if let ExprKind::Lit(Spanned {
+                        node: LitKind::Str(ref sym, _),
+                        ..
+                    }) = field.expr.kind;
+                    if sym.as_str() == "default lint description";
+
+                    then {
+                        span_lint(
+                            cx,
+                            DEFAULT_LINT,
+                            item.span,
+                            &format!("the lint `{}` has the default lint description", item.ident.name),
+                        );
+                    }
+                }
+                self.declared_lints.insert(item.ident.name, item.span);
+            }
+        } else if is_expn_of(item.span, "impl_lint_pass").is_some()
+            || is_expn_of(item.span, "declare_lint_pass").is_some()
+        {
+            if let hir::ItemKind::Impl(hir::Impl {
+                of_trait: None,
+                items: ref impl_item_refs,
+                ..
+            }) = item.kind
+            {
+                let mut collector = LintCollector {
+                    output: &mut self.registered_lints,
+                    cx,
+                };
+                let body_id = cx.tcx.hir().body_owned_by(
+                    impl_item_refs
+                        .iter()
+                        .find(|iiref| iiref.ident.as_str() == "get_lints")
+                        .expect("LintPass needs to implement get_lints")
+                        .id
+                        .hir_id,
+                );
+                collector.visit_expr(&cx.tcx.hir().body(body_id).value);
+            }
+        }
+    }
+
+    fn check_crate_post(&mut self, cx: &LateContext<'tcx>, _: &'tcx Crate<'_>) {
+        if !run_lints(cx, &[LINT_WITHOUT_LINT_PASS], CRATE_HIR_ID) {
+            return;
+        }
+
+        for (lint_name, &lint_span) in &self.declared_lints {
+            // When using the `declare_tool_lint!` macro, the original `lint_span`'s
+            // file points to "<rustc macros>".
+            // `compiletest-rs` thinks that's an error in a different file and
+            // just ignores it. This causes the test in compile-fail/lint_pass
+            // not able to capture the error.
+            // Therefore, we need to climb the macro expansion tree and find the
+            // actual span that invoked `declare_tool_lint!`:
+            let lint_span = lint_span.ctxt().outer_expn_data().call_site;
+
+            if !self.registered_lints.contains(lint_name) {
+                span_lint(
+                    cx,
+                    LINT_WITHOUT_LINT_PASS,
+                    lint_span,
+                    &format!("the lint `{}` is not added to any `LintPass`", lint_name),
+                );
+            }
+        }
+    }
+}
+
+fn is_lint_ref_type<'tcx>(cx: &LateContext<'tcx>, ty: &Ty<'_>) -> bool {
+    if let TyKind::Rptr(
+        _,
+        MutTy {
+            ty: ref inner,
+            mutbl: Mutability::Not,
+        },
+    ) = ty.kind
+    {
+        if let TyKind::Path(ref path) = inner.kind {
+            if let Res::Def(DefKind::Struct, def_id) = cx.qpath_res(path, inner.hir_id) {
+                return match_def_path(cx, def_id, &paths::LINT);
+            }
+        }
+    }
+
+    false
+}
+
+struct LintCollector<'a, 'tcx> {
+    output: &'a mut FxHashSet<Symbol>,
+    cx: &'a LateContext<'tcx>,
+}
+
+impl<'a, 'tcx> Visitor<'tcx> for LintCollector<'a, 'tcx> {
+    type Map = Map<'tcx>;
+
+    fn visit_path(&mut self, path: &'tcx Path<'_>, _: HirId) {
+        if path.segments.len() == 1 {
+            self.output.insert(path.segments[0].ident.name);
+        }
+    }
+
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::All(self.cx.tcx.hir())
+    }
+}
+
+#[derive(Clone, Default)]
+pub struct CompilerLintFunctions {
+    map: FxHashMap<&'static str, &'static str>,
+}
+
+impl CompilerLintFunctions {
+    #[must_use]
+    pub fn new() -> Self {
+        let mut map = FxHashMap::default();
+        map.insert("span_lint", "utils::span_lint");
+        map.insert("struct_span_lint", "utils::span_lint");
+        map.insert("lint", "utils::span_lint");
+        map.insert("span_lint_note", "utils::span_lint_and_note");
+        map.insert("span_lint_help", "utils::span_lint_and_help");
+        Self { map }
+    }
+}
+
+impl_lint_pass!(CompilerLintFunctions => [COMPILER_LINT_FUNCTIONS]);
+
+impl<'tcx> LateLintPass<'tcx> for CompilerLintFunctions {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        if !run_lints(cx, &[COMPILER_LINT_FUNCTIONS], expr.hir_id) {
+            return;
+        }
+
+        if_chain! {
+            if let ExprKind::MethodCall(ref path, _, ref args, _) = expr.kind;
+            let fn_name = path.ident;
+            if let Some(sugg) = self.map.get(&*fn_name.as_str());
+            let ty = cx.typeck_results().expr_ty(&args[0]).peel_refs();
+            if match_type(cx, ty, &paths::EARLY_CONTEXT)
+                || match_type(cx, ty, &paths::LATE_CONTEXT);
+            then {
+                span_lint_and_help(
+                    cx,
+                    COMPILER_LINT_FUNCTIONS,
+                    path.ident.span,
+                    "usage of a compiler lint function",
+                    None,
+                    &format!("please use the Clippy variant of this function: `{}`", sugg),
+                );
+            }
+        }
+    }
+}
+
+declare_lint_pass!(OuterExpnDataPass => [OUTER_EXPN_EXPN_DATA]);
+
+impl<'tcx> LateLintPass<'tcx> for OuterExpnDataPass {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
+        if !run_lints(cx, &[OUTER_EXPN_EXPN_DATA], expr.hir_id) {
+            return;
+        }
+
+        let (method_names, arg_lists, spans) = method_calls(expr, 2);
+        let method_names: Vec<SymbolStr> = method_names.iter().map(|s| s.as_str()).collect();
+        let method_names: Vec<&str> = method_names.iter().map(|s| &**s).collect();
+        if_chain! {
+            if let ["expn_data", "outer_expn"] = method_names.as_slice();
+            let args = arg_lists[1];
+            if args.len() == 1;
+            let self_arg = &args[0];
+            let self_ty = cx.typeck_results().expr_ty(self_arg).peel_refs();
+            if match_type(cx, self_ty, &paths::SYNTAX_CONTEXT);
+            then {
+                span_lint_and_sugg(
+                    cx,
+                    OUTER_EXPN_EXPN_DATA,
+                    spans[1].with_hi(expr.span.hi()),
+                    "usage of `outer_expn().expn_data()`",
+                    "try",
+                    "outer_expn_data()".to_string(),
+                    Applicability::MachineApplicable,
+                );
+            }
+        }
+    }
+}
+
+declare_lint_pass!(ProduceIce => [PRODUCE_ICE]);
+
+impl EarlyLintPass for ProduceIce {
+    fn check_fn(&mut self, _: &EarlyContext<'_>, fn_kind: FnKind<'_>, _: Span, _: NodeId) {
+        if is_trigger_fn(fn_kind) {
+            panic!("Would you like some help with that?");
+        }
+    }
+}
+
+fn is_trigger_fn(fn_kind: FnKind<'_>) -> bool {
+    match fn_kind {
+        FnKind::Fn(_, ident, ..) => ident.name.as_str() == "it_looks_like_you_are_trying_to_kill_clippy",
+        FnKind::Closure(..) => false,
+    }
+}
+
+declare_lint_pass!(CollapsibleCalls => [COLLAPSIBLE_SPAN_LINT_CALLS]);
+
+impl<'tcx> LateLintPass<'tcx> for CollapsibleCalls {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
+        if !run_lints(cx, &[COLLAPSIBLE_SPAN_LINT_CALLS], expr.hir_id) {
+            return;
+        }
+
+        if_chain! {
+            if let ExprKind::Call(ref func, ref and_then_args) = expr.kind;
+            if let ExprKind::Path(ref path) = func.kind;
+            if match_qpath(path, &["span_lint_and_then"]);
+            if and_then_args.len() == 5;
+            if let ExprKind::Closure(_, _, body_id, _, _) = &and_then_args[4].kind;
+            let body = cx.tcx.hir().body(*body_id);
+            if let ExprKind::Block(block, _) = &body.value.kind;
+            let stmts = &block.stmts;
+            if stmts.len() == 1 && block.expr.is_none();
+            if let StmtKind::Semi(only_expr) = &stmts[0].kind;
+            if let ExprKind::MethodCall(ref ps, _, ref span_call_args, _) = &only_expr.kind;
+            let and_then_snippets = get_and_then_snippets(cx, and_then_args);
+            let mut sle = SpanlessEq::new(cx).deny_side_effects();
+            then {
+                match &*ps.ident.as_str() {
+                    "span_suggestion" if sle.eq_expr(&and_then_args[2], &span_call_args[1]) => {
+                        suggest_suggestion(cx, expr, &and_then_snippets, &span_suggestion_snippets(cx, span_call_args));
+                    },
+                    "span_help" if sle.eq_expr(&and_then_args[2], &span_call_args[1]) => {
+                        let help_snippet = snippet(cx, span_call_args[2].span, r#""...""#);
+                        suggest_help(cx, expr, &and_then_snippets, help_snippet.borrow(), true);
+                    },
+                    "span_note" if sle.eq_expr(&and_then_args[2], &span_call_args[1]) => {
+                        let note_snippet = snippet(cx, span_call_args[2].span, r#""...""#);
+                        suggest_note(cx, expr, &and_then_snippets, note_snippet.borrow(), true);
+                    },
+                    "help" => {
+                        let help_snippet = snippet(cx, span_call_args[1].span, r#""...""#);
+                        suggest_help(cx, expr, &and_then_snippets, help_snippet.borrow(), false);
+                    }
+                    "note" => {
+                        let note_snippet = snippet(cx, span_call_args[1].span, r#""...""#);
+                        suggest_note(cx, expr, &and_then_snippets, note_snippet.borrow(), false);
+                    }
+                    _  => (),
+                }
+            }
+        }
+    }
+}
+
+struct AndThenSnippets<'a> {
+    cx: Cow<'a, str>,
+    lint: Cow<'a, str>,
+    span: Cow<'a, str>,
+    msg: Cow<'a, str>,
+}
+
+fn get_and_then_snippets<'a, 'hir>(cx: &LateContext<'_>, and_then_snippets: &'hir [Expr<'hir>]) -> AndThenSnippets<'a> {
+    let cx_snippet = snippet(cx, and_then_snippets[0].span, "cx");
+    let lint_snippet = snippet(cx, and_then_snippets[1].span, "..");
+    let span_snippet = snippet(cx, and_then_snippets[2].span, "span");
+    let msg_snippet = snippet(cx, and_then_snippets[3].span, r#""...""#);
+
+    AndThenSnippets {
+        cx: cx_snippet,
+        lint: lint_snippet,
+        span: span_snippet,
+        msg: msg_snippet,
+    }
+}
+
+struct SpanSuggestionSnippets<'a> {
+    help: Cow<'a, str>,
+    sugg: Cow<'a, str>,
+    applicability: Cow<'a, str>,
+}
+
+fn span_suggestion_snippets<'a, 'hir>(
+    cx: &LateContext<'_>,
+    span_call_args: &'hir [Expr<'hir>],
+) -> SpanSuggestionSnippets<'a> {
+    let help_snippet = snippet(cx, span_call_args[2].span, r#""...""#);
+    let sugg_snippet = snippet(cx, span_call_args[3].span, "..");
+    let applicability_snippet = snippet(cx, span_call_args[4].span, "Applicability::MachineApplicable");
+
+    SpanSuggestionSnippets {
+        help: help_snippet,
+        sugg: sugg_snippet,
+        applicability: applicability_snippet,
+    }
+}
+
+fn suggest_suggestion(
+    cx: &LateContext<'_>,
+    expr: &Expr<'_>,
+    and_then_snippets: &AndThenSnippets<'_>,
+    span_suggestion_snippets: &SpanSuggestionSnippets<'_>,
+) {
+    span_lint_and_sugg(
+        cx,
+        COLLAPSIBLE_SPAN_LINT_CALLS,
+        expr.span,
+        "this call is collapsible",
+        "collapse into",
+        format!(
+            "span_lint_and_sugg({}, {}, {}, {}, {}, {}, {})",
+            and_then_snippets.cx,
+            and_then_snippets.lint,
+            and_then_snippets.span,
+            and_then_snippets.msg,
+            span_suggestion_snippets.help,
+            span_suggestion_snippets.sugg,
+            span_suggestion_snippets.applicability
+        ),
+        Applicability::MachineApplicable,
+    );
+}
+
+fn suggest_help(
+    cx: &LateContext<'_>,
+    expr: &Expr<'_>,
+    and_then_snippets: &AndThenSnippets<'_>,
+    help: &str,
+    with_span: bool,
+) {
+    let option_span = if with_span {
+        format!("Some({})", and_then_snippets.span)
+    } else {
+        "None".to_string()
+    };
+
+    span_lint_and_sugg(
+        cx,
+        COLLAPSIBLE_SPAN_LINT_CALLS,
+        expr.span,
+        "this call is collapsible",
+        "collapse into",
+        format!(
+            "span_lint_and_help({}, {}, {}, {}, {}, {})",
+            and_then_snippets.cx,
+            and_then_snippets.lint,
+            and_then_snippets.span,
+            and_then_snippets.msg,
+            &option_span,
+            help
+        ),
+        Applicability::MachineApplicable,
+    );
+}
+
+fn suggest_note(
+    cx: &LateContext<'_>,
+    expr: &Expr<'_>,
+    and_then_snippets: &AndThenSnippets<'_>,
+    note: &str,
+    with_span: bool,
+) {
+    let note_span = if with_span {
+        format!("Some({})", and_then_snippets.span)
+    } else {
+        "None".to_string()
+    };
+
+    span_lint_and_sugg(
+        cx,
+        COLLAPSIBLE_SPAN_LINT_CALLS,
+        expr.span,
+        "this call is collspible",
+        "collapse into",
+        format!(
+            "span_lint_and_note({}, {}, {}, {}, {}, {})",
+            and_then_snippets.cx,
+            and_then_snippets.lint,
+            and_then_snippets.span,
+            and_then_snippets.msg,
+            note_span,
+            note
+        ),
+        Applicability::MachineApplicable,
+    );
+}
+
+declare_lint_pass!(MatchTypeOnDiagItem => [MATCH_TYPE_ON_DIAGNOSTIC_ITEM]);
+
+impl<'tcx> LateLintPass<'tcx> for MatchTypeOnDiagItem {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
+        if !run_lints(cx, &[MATCH_TYPE_ON_DIAGNOSTIC_ITEM], expr.hir_id) {
+            return;
+        }
+
+        if_chain! {
+            // Check if this is a call to utils::match_type()
+            if let ExprKind::Call(fn_path, [context, ty, ty_path]) = expr.kind;
+            if let ExprKind::Path(fn_qpath) = &fn_path.kind;
+            if match_qpath(&fn_qpath, &["utils", "match_type"]);
+            // Extract the path to the matched type
+            if let Some(segments) = path_to_matched_type(cx, ty_path);
+            let segments: Vec<&str> = segments.iter().map(|sym| &**sym).collect();
+            if let Some(ty_did) = path_to_res(cx, &segments[..]).opt_def_id();
+            // Check if the matched type is a diagnostic item
+            let diag_items = cx.tcx.diagnostic_items(ty_did.krate);
+            if let Some(item_name) = diag_items.iter().find_map(|(k, v)| if *v == ty_did { Some(k) } else { None });
+            then {
+                let cx_snippet = snippet(cx, context.span, "_");
+                let ty_snippet = snippet(cx, ty.span, "_");
+
+                span_lint_and_sugg(
+                    cx,
+                    MATCH_TYPE_ON_DIAGNOSTIC_ITEM,
+                    expr.span,
+                    "usage of `utils::match_type()` on a type diagnostic item",
+                    "try",
+                    format!("utils::is_type_diagnostic_item({}, {}, sym::{})", cx_snippet, ty_snippet, item_name),
+                    Applicability::MaybeIncorrect,
+                );
+            }
+        }
+    }
+}
+
+fn path_to_matched_type(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> Option<Vec<SymbolStr>> {
+    use rustc_hir::ItemKind;
+
+    match &expr.kind {
+        ExprKind::AddrOf(.., expr) => return path_to_matched_type(cx, expr),
+        ExprKind::Path(qpath) => match cx.qpath_res(qpath, expr.hir_id) {
+            Res::Local(hir_id) => {
+                let parent_id = cx.tcx.hir().get_parent_node(hir_id);
+                if let Some(Node::Local(local)) = cx.tcx.hir().find(parent_id) {
+                    if let Some(init) = local.init {
+                        return path_to_matched_type(cx, init);
+                    }
+                }
+            },
+            Res::Def(DefKind::Const | DefKind::Static, def_id) => {
+                if let Some(Node::Item(item)) = cx.tcx.hir().get_if_local(def_id) {
+                    if let ItemKind::Const(.., body_id) | ItemKind::Static(.., body_id) = item.kind {
+                        let body = cx.tcx.hir().body(body_id);
+                        return path_to_matched_type(cx, &body.value);
+                    }
+                }
+            },
+            _ => {},
+        },
+        ExprKind::Array(exprs) => {
+            let segments: Vec<SymbolStr> = exprs
+                .iter()
+                .filter_map(|expr| {
+                    if let ExprKind::Lit(lit) = &expr.kind {
+                        if let LitKind::Str(sym, _) = lit.node {
+                            return Some(sym.as_str());
+                        }
+                    }
+
+                    None
+                })
+                .collect();
+
+            if segments.len() == exprs.len() {
+                return Some(segments);
+            }
+        },
+        _ => {},
+    }
+
+    None
+}
+
+// This is not a complete resolver for paths. It works on all the paths currently used in the paths
+// module.  That's all it does and all it needs to do.
+pub fn check_path(cx: &LateContext<'_>, path: &[&str]) -> bool {
+    if path_to_res(cx, path) != Res::Err {
+        return true;
+    }
+
+    // Some implementations can't be found by `path_to_res`, particularly inherent
+    // implementations of native types. Check lang items.
+    let path_syms: Vec<_> = path.iter().map(|p| Symbol::intern(p)).collect();
+    let lang_items = cx.tcx.lang_items();
+    for item_def_id in lang_items.items().iter().flatten() {
+        let lang_item_path = cx.get_def_path(*item_def_id);
+        if path_syms.starts_with(&lang_item_path) {
+            if let [item] = &path_syms[lang_item_path.len()..] {
+                for child in cx.tcx.item_children(*item_def_id) {
+                    if child.ident.name == *item {
+                        return true;
+                    }
+                }
+            }
+        }
+    }
+
+    false
+}
+
+declare_lint_pass!(InvalidPaths => [INVALID_PATHS]);
+
+impl<'tcx> LateLintPass<'tcx> for InvalidPaths {
+    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
+        let local_def_id = &cx.tcx.parent_module(item.hir_id);
+        let mod_name = &cx.tcx.item_name(local_def_id.to_def_id());
+        if_chain! {
+            if mod_name.as_str() == "paths";
+            if let hir::ItemKind::Const(ty, body_id) = item.kind;
+            let ty = hir_ty_to_ty(cx.tcx, ty);
+            if let ty::Array(el_ty, _) = &ty.kind();
+            if let ty::Ref(_, el_ty, _) = &el_ty.kind();
+            if el_ty.is_str();
+            let body = cx.tcx.hir().body(body_id);
+            let typeck_results = cx.tcx.typeck_body(body_id);
+            if let Some(Constant::Vec(path)) = constant_simple(cx, typeck_results, &body.value);
+            let path: Vec<&str> = path.iter().map(|x| {
+                    if let Constant::Str(s) = x {
+                        s.as_str()
+                    } else {
+                        // We checked the type of the constant above
+                        unreachable!()
+                    }
+                }).collect();
+            if !check_path(cx, &path[..]);
+            then {
+                span_lint(cx, CLIPPY_LINTS_INTERNAL, item.span, "invalid path");
+            }
+        }
+    }
+}
+
+#[derive(Default)]
+pub struct InterningDefinedSymbol {
+    // Maps the symbol value to the constant DefId.
+    symbol_map: FxHashMap<u32, DefId>,
+}
+
+impl_lint_pass!(InterningDefinedSymbol => [INTERNING_DEFINED_SYMBOL, UNNECESSARY_SYMBOL_STR]);
+
+impl<'tcx> LateLintPass<'tcx> for InterningDefinedSymbol {
+    fn check_crate(&mut self, cx: &LateContext<'_>, _: &Crate<'_>) {
+        if !self.symbol_map.is_empty() {
+            return;
+        }
+
+        for &module in &[&paths::KW_MODULE, &paths::SYM_MODULE] {
+            if let Some(def_id) = path_to_res(cx, module).opt_def_id() {
+                for item in cx.tcx.item_children(def_id).iter() {
+                    if_chain! {
+                        if let Res::Def(DefKind::Const, item_def_id) = item.res;
+                        let ty = cx.tcx.type_of(item_def_id);
+                        if match_type(cx, ty, &paths::SYMBOL);
+                        if let Ok(ConstValue::Scalar(value)) = cx.tcx.const_eval_poly(item_def_id);
+                        if let Ok(value) = value.to_u32();
+                        then {
+                            self.symbol_map.insert(value, item_def_id);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        if_chain! {
+            if let ExprKind::Call(func, [arg]) = &expr.kind;
+            if let ty::FnDef(def_id, _) = cx.typeck_results().expr_ty(func).kind();
+            if match_def_path(cx, *def_id, &paths::SYMBOL_INTERN);
+            if let Some(Constant::Str(arg)) = constant_simple(cx, cx.typeck_results(), arg);
+            let value = Symbol::intern(&arg).as_u32();
+            if let Some(&def_id) = self.symbol_map.get(&value);
+            then {
+                span_lint_and_sugg(
+                    cx,
+                    INTERNING_DEFINED_SYMBOL,
+                    is_expn_of(expr.span, "sym").unwrap_or(expr.span),
+                    "interning a defined symbol",
+                    "try",
+                    cx.tcx.def_path_str(def_id),
+                    Applicability::MachineApplicable,
+                );
+            }
+        }
+        if let ExprKind::Binary(op, left, right) = expr.kind {
+            if matches!(op.node, BinOpKind::Eq | BinOpKind::Ne) {
+                let data = [
+                    (left, self.symbol_str_expr(left, cx)),
+                    (right, self.symbol_str_expr(right, cx)),
+                ];
+                match data {
+                    // both operands are a symbol string
+                    [(_, Some(left)), (_, Some(right))] => {
+                        span_lint_and_sugg(
+                            cx,
+                            UNNECESSARY_SYMBOL_STR,
+                            expr.span,
+                            "unnecessary `Symbol` to string conversion",
+                            "try",
+                            format!(
+                                "{} {} {}",
+                                left.as_symbol_snippet(cx),
+                                op.node.as_str(),
+                                right.as_symbol_snippet(cx),
+                            ),
+                            Applicability::MachineApplicable,
+                        );
+                    },
+                    // one of the operands is a symbol string
+                    [(expr, Some(symbol)), _] | [_, (expr, Some(symbol))] => {
+                        // creating an owned string for comparison
+                        if matches!(symbol, SymbolStrExpr::Expr { is_to_owned: true, .. }) {
+                            span_lint_and_sugg(
+                                cx,
+                                UNNECESSARY_SYMBOL_STR,
+                                expr.span,
+                                "unnecessary string allocation",
+                                "try",
+                                format!("{}.as_str()", symbol.as_symbol_snippet(cx)),
+                                Applicability::MachineApplicable,
+                            );
+                        }
+                    },
+                    // nothing found
+                    [(_, None), (_, None)] => {},
+                }
+            }
+        }
+    }
+}
+
+impl InterningDefinedSymbol {
+    fn symbol_str_expr<'tcx>(&self, expr: &'tcx Expr<'tcx>, cx: &LateContext<'tcx>) -> Option<SymbolStrExpr<'tcx>> {
+        static IDENT_STR_PATHS: &[&[&str]] = &[&paths::IDENT_AS_STR, &paths::TO_STRING_METHOD];
+        static SYMBOL_STR_PATHS: &[&[&str]] = &[
+            &paths::SYMBOL_AS_STR,
+            &paths::SYMBOL_TO_IDENT_STRING,
+            &paths::TO_STRING_METHOD,
+        ];
+        // SymbolStr might be de-referenced: `&*symbol.as_str()`
+        let call = if_chain! {
+            if let ExprKind::AddrOf(_, _, e) = expr.kind;
+            if let ExprKind::Unary(UnOp::Deref, e) = e.kind;
+            then { e } else { expr }
+        };
+        if_chain! {
+            // is a method call
+            if let ExprKind::MethodCall(_, _, [item], _) = call.kind;
+            if let Some(did) = cx.typeck_results().type_dependent_def_id(call.hir_id);
+            let ty = cx.typeck_results().expr_ty(item);
+            // ...on either an Ident or a Symbol
+            if let Some(is_ident) = if match_type(cx, ty, &paths::SYMBOL) {
+                Some(false)
+            } else if match_type(cx, ty, &paths::IDENT) {
+                Some(true)
+            } else {
+                None
+            };
+            // ...which converts it to a string
+            let paths = if is_ident { IDENT_STR_PATHS } else { SYMBOL_STR_PATHS };
+            if let Some(path) = paths.iter().find(|path| match_def_path(cx, did, path));
+            then {
+                let is_to_owned = path.last().unwrap().ends_with("string");
+                return Some(SymbolStrExpr::Expr {
+                    item,
+                    is_ident,
+                    is_to_owned,
+                });
+            }
+        }
+        // is a string constant
+        if let Some(Constant::Str(s)) = constant_simple(cx, cx.typeck_results(), expr) {
+            let value = Symbol::intern(&s).as_u32();
+            // ...which matches a symbol constant
+            if let Some(&def_id) = self.symbol_map.get(&value) {
+                return Some(SymbolStrExpr::Const(def_id));
+            }
+        }
+        None
+    }
+}
+
+enum SymbolStrExpr<'tcx> {
+    /// a string constant with a corresponding symbol constant
+    Const(DefId),
+    /// a "symbol to string" expression like `symbol.as_str()`
+    Expr {
+        /// part that evaluates to `Symbol` or `Ident`
+        item: &'tcx Expr<'tcx>,
+        is_ident: bool,
+        /// whether an owned `String` is created like `to_ident_string()`
+        is_to_owned: bool,
+    },
+}
+
+impl<'tcx> SymbolStrExpr<'tcx> {
+    /// Returns a snippet that evaluates to a `Symbol` and is const if possible
+    fn as_symbol_snippet(&self, cx: &LateContext<'_>) -> Cow<'tcx, str> {
+        match *self {
+            Self::Const(def_id) => cx.tcx.def_path_str(def_id).into(),
+            Self::Expr { item, is_ident, .. } => {
+                let mut snip = snippet(cx, item.span.source_callsite(), "..");
+                if is_ident {
+                    // get `Ident.name`
+                    snip.to_mut().push_str(".name");
+                }
+                snip
+            },
+        }
+    }
+}
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
new file mode 100644
index 00000000000..213945a63a3
--- /dev/null
+++ b/clippy_utils/src/lib.rs
@@ -0,0 +1,1998 @@
+#![feature(bindings_after_at)]
+#![feature(box_patterns)]
+#![feature(box_syntax)]
+#![feature(concat_idents)]
+#![feature(crate_visibility_modifier)]
+#![feature(drain_filter)]
+#![feature(in_band_lifetimes)]
+#![feature(once_cell)]
+#![feature(or_patterns)]
+#![feature(rustc_private)]
+#![feature(stmt_expr_attributes)]
+#![feature(control_flow_enum)]
+
+extern crate rustc_ast;
+extern crate rustc_ast_pretty;
+extern crate rustc_attr;
+extern crate rustc_data_structures;
+extern crate rustc_driver;
+extern crate rustc_errors;
+extern crate rustc_hir;
+extern crate rustc_hir_pretty;
+extern crate rustc_index;
+extern crate rustc_infer;
+extern crate rustc_lexer;
+extern crate rustc_lint;
+extern crate rustc_middle;
+extern crate rustc_mir;
+extern crate rustc_parse;
+extern crate rustc_parse_format;
+extern crate rustc_session;
+extern crate rustc_span;
+extern crate rustc_target;
+extern crate rustc_trait_selection;
+extern crate rustc_typeck;
+
+#[macro_use]
+pub mod sym_helper;
+
+#[allow(clippy::module_name_repetitions)]
+pub mod ast_utils;
+pub mod attrs;
+pub mod author;
+pub mod camel_case;
+pub mod comparisons;
+pub mod conf;
+pub mod consts;
+mod diagnostics;
+pub mod eager_or_lazy;
+pub mod higher;
+mod hir_utils;
+pub mod inspector;
+#[cfg(feature = "internal-lints")]
+pub mod internal_lints;
+pub mod numeric_literal;
+pub mod paths;
+pub mod ptr;
+pub mod qualify_min_const_fn;
+pub mod sugg;
+pub mod usage;
+pub mod visitors;
+
+pub use self::attrs::*;
+pub use self::diagnostics::*;
+pub use self::hir_utils::{both, eq_expr_value, over, SpanlessEq, SpanlessHash};
+
+use std::borrow::Cow;
+use std::collections::hash_map::Entry;
+use std::hash::BuildHasherDefault;
+
+use if_chain::if_chain;
+use rustc_ast::ast::{self, Attribute, BorrowKind, LitKind, Mutability};
+use rustc_data_structures::fx::FxHashMap;
+use rustc_errors::Applicability;
+use rustc_hir as hir;
+use rustc_hir::def::{CtorKind, CtorOf, DefKind, Res};
+use rustc_hir::def_id::{DefId, LOCAL_CRATE};
+use rustc_hir::intravisit::{self, NestedVisitorMap, Visitor};
+use rustc_hir::Node;
+use rustc_hir::{
+    def, Arm, Block, Body, Constness, Crate, Expr, ExprKind, FnDecl, HirId, ImplItem, ImplItemKind, Item, ItemKind,
+    MatchSource, Param, Pat, PatKind, Path, PathSegment, QPath, TraitItem, TraitItemKind, TraitRef, TyKind, Unsafety,
+};
+use rustc_infer::infer::TyCtxtInferExt;
+use rustc_lint::{LateContext, Level, Lint, LintContext};
+use rustc_middle::hir::exports::Export;
+use rustc_middle::hir::map::Map;
+use rustc_middle::ty::subst::{GenericArg, GenericArgKind};
+use rustc_middle::ty::{self, layout::IntegerExt, DefIdTree, Ty, TyCtxt, TypeFoldable};
+use rustc_semver::RustcVersion;
+use rustc_session::Session;
+use rustc_span::hygiene::{ExpnKind, MacroKind};
+use rustc_span::source_map::original_sp;
+use rustc_span::sym;
+use rustc_span::symbol::{kw, Symbol};
+use rustc_span::{BytePos, Pos, Span, DUMMY_SP};
+use rustc_target::abi::Integer;
+use rustc_trait_selection::traits::query::normalize::AtExt;
+use smallvec::SmallVec;
+
+use crate::consts::{constant, Constant};
+
+/// Macro used to declare a Clippy lint.
+///
+/// Every lint declaration consists of 4 parts:
+///
+/// 1. The documentation, which is used for the website
+/// 2. The `LINT_NAME`. See [lint naming][lint_naming] on lint naming conventions.
+/// 3. The `lint_level`, which is a mapping from *one* of our lint groups to `Allow`, `Warn` or
+///    `Deny`. The lint level here has nothing to do with what lint groups the lint is a part of.
+/// 4. The `description` that contains a short explanation on what's wrong with code where the
+///    lint is triggered.
+///
+/// Currently the categories `style`, `correctness`, `complexity` and `perf` are enabled by default.
+/// As said in the README.md of this repository, if the lint level mapping changes, please update
+/// README.md.
+///
+/// # Example
+///
+/// ```
+/// #![feature(rustc_private)]
+/// extern crate rustc_session;
+/// use rustc_session::declare_tool_lint;
+/// use clippy_lints::declare_clippy_lint;
+///
+/// declare_clippy_lint! {
+///     /// **What it does:** Checks for ... (describe what the lint matches).
+///     ///
+///     /// **Why is this bad?** Supply the reason for linting the code.
+///     ///
+///     /// **Known problems:** None. (Or describe where it could go wrong.)
+///     ///
+///     /// **Example:**
+///     ///
+///     /// ```rust
+///     /// // Bad
+///     /// Insert a short example of code that triggers the lint
+///     ///
+///     /// // Good
+///     /// Insert a short example of improved code that doesn't trigger the lint
+///     /// ```
+///     pub LINT_NAME,
+///     pedantic,
+///     "description"
+/// }
+/// ```
+/// [lint_naming]: https://rust-lang.github.io/rfcs/0344-conventions-galore.html#lints
+#[macro_export]
+macro_rules! declare_clippy_lint {
+    { $(#[$attr:meta])* pub $name:tt, style, $description:tt } => {
+        declare_tool_lint! {
+            $(#[$attr])* pub clippy::$name, Warn, $description, report_in_external_macro: true
+        }
+    };
+    { $(#[$attr:meta])* pub $name:tt, correctness, $description:tt } => {
+        declare_tool_lint! {
+            $(#[$attr])* pub clippy::$name, Deny, $description, report_in_external_macro: true
+        }
+    };
+    { $(#[$attr:meta])* pub $name:tt, complexity, $description:tt } => {
+        declare_tool_lint! {
+            $(#[$attr])* pub clippy::$name, Warn, $description, report_in_external_macro: true
+        }
+    };
+    { $(#[$attr:meta])* pub $name:tt, perf, $description:tt } => {
+        declare_tool_lint! {
+            $(#[$attr])* pub clippy::$name, Warn, $description, report_in_external_macro: true
+        }
+    };
+    { $(#[$attr:meta])* pub $name:tt, pedantic, $description:tt } => {
+        declare_tool_lint! {
+            $(#[$attr])* pub clippy::$name, Allow, $description, report_in_external_macro: true
+        }
+    };
+    { $(#[$attr:meta])* pub $name:tt, restriction, $description:tt } => {
+        declare_tool_lint! {
+            $(#[$attr])* pub clippy::$name, Allow, $description, report_in_external_macro: true
+        }
+    };
+    { $(#[$attr:meta])* pub $name:tt, cargo, $description:tt } => {
+        declare_tool_lint! {
+            $(#[$attr])* pub clippy::$name, Allow, $description, report_in_external_macro: true
+        }
+    };
+    { $(#[$attr:meta])* pub $name:tt, nursery, $description:tt } => {
+        declare_tool_lint! {
+            $(#[$attr])* pub clippy::$name, Allow, $description, report_in_external_macro: true
+        }
+    };
+    { $(#[$attr:meta])* pub $name:tt, internal, $description:tt } => {
+        declare_tool_lint! {
+            $(#[$attr])* pub clippy::$name, Allow, $description, report_in_external_macro: true
+        }
+    };
+    { $(#[$attr:meta])* pub $name:tt, internal_warn, $description:tt } => {
+        declare_tool_lint! {
+            $(#[$attr])* pub clippy::$name, Warn, $description, report_in_external_macro: true
+        }
+    };
+}
+
+pub fn parse_msrv(msrv: &str, sess: Option<&Session>, span: Option<Span>) -> Option<RustcVersion> {
+    if let Ok(version) = RustcVersion::parse(msrv) {
+        return Some(version);
+    } else if let Some(sess) = sess {
+        if let Some(span) = span {
+            sess.span_err(span, &format!("`{}` is not a valid Rust version", msrv));
+        }
+    }
+    None
+}
+
+pub fn meets_msrv(msrv: Option<&RustcVersion>, lint_msrv: &RustcVersion) -> bool {
+    msrv.map_or(true, |msrv| msrv.meets(*lint_msrv))
+}
+
+#[macro_export]
+macro_rules! extract_msrv_attr {
+    (LateContext) => {
+        extract_msrv_attr!(@LateContext, ());
+    };
+    (EarlyContext) => {
+        extract_msrv_attr!(@EarlyContext);
+    };
+    (@$context:ident$(, $call:tt)?) => {
+        fn enter_lint_attrs(&mut self, cx: &rustc_lint::$context<'tcx>, attrs: &'tcx [rustc_ast::ast::Attribute]) {
+            use $crate::get_unique_inner_attr;
+            match get_unique_inner_attr(cx.sess$($call)?, attrs, "msrv") {
+                Some(msrv_attr) => {
+                    if let Some(msrv) = msrv_attr.value_str() {
+                        self.msrv = $crate::parse_msrv(
+                            &msrv.to_string(),
+                            Some(cx.sess$($call)?),
+                            Some(msrv_attr.span),
+                        );
+                    } else {
+                        cx.sess$($call)?.span_err(msrv_attr.span, "bad clippy attribute");
+                    }
+                },
+                _ => (),
+            }
+        }
+    };
+}
+
+/// Returns `true` if the two spans come from differing expansions (i.e., one is
+/// from a macro and one isn't).
+#[must_use]
+pub fn differing_macro_contexts(lhs: Span, rhs: Span) -> bool {
+    rhs.ctxt() != lhs.ctxt()
+}
+
+/// Returns `true` if the given `NodeId` is inside a constant context
+///
+/// # Example
+///
+/// ```rust,ignore
+/// if in_constant(cx, expr.hir_id) {
+///     // Do something
+/// }
+/// ```
+pub fn in_constant(cx: &LateContext<'_>, id: HirId) -> bool {
+    let parent_id = cx.tcx.hir().get_parent_item(id);
+    match cx.tcx.hir().get(parent_id) {
+        Node::Item(&Item {
+            kind: ItemKind::Const(..) | ItemKind::Static(..),
+            ..
+        })
+        | Node::TraitItem(&TraitItem {
+            kind: TraitItemKind::Const(..),
+            ..
+        })
+        | Node::ImplItem(&ImplItem {
+            kind: ImplItemKind::Const(..),
+            ..
+        })
+        | Node::AnonConst(_) => true,
+        Node::Item(&Item {
+            kind: ItemKind::Fn(ref sig, ..),
+            ..
+        })
+        | Node::ImplItem(&ImplItem {
+            kind: ImplItemKind::Fn(ref sig, _),
+            ..
+        }) => sig.header.constness == Constness::Const,
+        _ => false,
+    }
+}
+
+/// Returns `true` if this `span` was expanded by any macro.
+#[must_use]
+pub fn in_macro(span: Span) -> bool {
+    if span.from_expansion() {
+        !matches!(span.ctxt().outer_expn_data().kind, ExpnKind::Desugaring(..))
+    } else {
+        false
+    }
+}
+
+// If the snippet is empty, it's an attribute that was inserted during macro
+// expansion and we want to ignore those, because they could come from external
+// sources that the user has no control over.
+// For some reason these attributes don't have any expansion info on them, so
+// we have to check it this way until there is a better way.
+pub fn is_present_in_source<T: LintContext>(cx: &T, span: Span) -> bool {
+    if let Some(snippet) = snippet_opt(cx, span) {
+        if snippet.is_empty() {
+            return false;
+        }
+    }
+    true
+}
+
+/// Checks if given pattern is a wildcard (`_`)
+pub fn is_wild<'tcx>(pat: &impl std::ops::Deref<Target = Pat<'tcx>>) -> bool {
+    matches!(pat.kind, PatKind::Wild)
+}
+
+/// Checks if type is struct, enum or union type with the given def path.
+///
+/// If the type is a diagnostic item, use `is_type_diagnostic_item` instead.
+/// If you change the signature, remember to update the internal lint `MatchTypeOnDiagItem`
+pub fn match_type(cx: &LateContext<'_>, ty: Ty<'_>, path: &[&str]) -> bool {
+    match ty.kind() {
+        ty::Adt(adt, _) => match_def_path(cx, adt.did, path),
+        _ => false,
+    }
+}
+
+/// Checks if the type is equal to a diagnostic item
+///
+/// If you change the signature, remember to update the internal lint `MatchTypeOnDiagItem`
+pub fn is_type_diagnostic_item(cx: &LateContext<'_>, ty: Ty<'_>, diag_item: Symbol) -> bool {
+    match ty.kind() {
+        ty::Adt(adt, _) => cx.tcx.is_diagnostic_item(diag_item, adt.did),
+        _ => false,
+    }
+}
+
+/// Checks if the type is equal to a lang item
+pub fn is_type_lang_item(cx: &LateContext<'_>, ty: Ty<'_>, lang_item: hir::LangItem) -> bool {
+    match ty.kind() {
+        ty::Adt(adt, _) => cx.tcx.lang_items().require(lang_item).unwrap() == adt.did,
+        _ => false,
+    }
+}
+
+/// Checks if the method call given in `expr` belongs to the given trait.
+pub fn match_trait_method(cx: &LateContext<'_>, expr: &Expr<'_>, path: &[&str]) -> bool {
+    let def_id = cx.typeck_results().type_dependent_def_id(expr.hir_id).unwrap();
+    let trt_id = cx.tcx.trait_of_item(def_id);
+    trt_id.map_or(false, |trt_id| match_def_path(cx, trt_id, path))
+}
+
+/// Checks if an expression references a variable of the given name.
+pub fn match_var(expr: &Expr<'_>, var: Symbol) -> bool {
+    if let ExprKind::Path(QPath::Resolved(None, ref path)) = expr.kind {
+        if let [p] = path.segments {
+            return p.ident.name == var;
+        }
+    }
+    false
+}
+
+pub fn last_path_segment<'tcx>(path: &QPath<'tcx>) -> &'tcx PathSegment<'tcx> {
+    match *path {
+        QPath::Resolved(_, ref path) => path.segments.last().expect("A path must have at least one segment"),
+        QPath::TypeRelative(_, ref seg) => seg,
+        QPath::LangItem(..) => panic!("last_path_segment: lang item has no path segments"),
+    }
+}
+
+pub fn single_segment_path<'tcx>(path: &QPath<'tcx>) -> Option<&'tcx PathSegment<'tcx>> {
+    match *path {
+        QPath::Resolved(_, ref path) => path.segments.get(0),
+        QPath::TypeRelative(_, ref seg) => Some(seg),
+        QPath::LangItem(..) => None,
+    }
+}
+
+/// Matches a `QPath` against a slice of segment string literals.
+///
+/// There is also `match_path` if you are dealing with a `rustc_hir::Path` instead of a
+/// `rustc_hir::QPath`.
+///
+/// # Examples
+/// ```rust,ignore
+/// match_qpath(path, &["std", "rt", "begin_unwind"])
+/// ```
+pub fn match_qpath(path: &QPath<'_>, segments: &[&str]) -> bool {
+    match *path {
+        QPath::Resolved(_, ref path) => match_path(path, segments),
+        QPath::TypeRelative(ref ty, ref segment) => match ty.kind {
+            TyKind::Path(ref inner_path) => {
+                if let [prefix @ .., end] = segments {
+                    if match_qpath(inner_path, prefix) {
+                        return segment.ident.name.as_str() == *end;
+                    }
+                }
+                false
+            },
+            _ => false,
+        },
+        QPath::LangItem(..) => false,
+    }
+}
+
+/// Matches a `Path` against a slice of segment string literals.
+///
+/// There is also `match_qpath` if you are dealing with a `rustc_hir::QPath` instead of a
+/// `rustc_hir::Path`.
+///
+/// # Examples
+///
+/// ```rust,ignore
+/// if match_path(&trait_ref.path, &paths::HASH) {
+///     // This is the `std::hash::Hash` trait.
+/// }
+///
+/// if match_path(ty_path, &["rustc", "lint", "Lint"]) {
+///     // This is a `rustc_middle::lint::Lint`.
+/// }
+/// ```
+pub fn match_path(path: &Path<'_>, segments: &[&str]) -> bool {
+    path.segments
+        .iter()
+        .rev()
+        .zip(segments.iter().rev())
+        .all(|(a, b)| a.ident.name.as_str() == *b)
+}
+
+/// Matches a `Path` against a slice of segment string literals, e.g.
+///
+/// # Examples
+/// ```rust,ignore
+/// match_path_ast(path, &["std", "rt", "begin_unwind"])
+/// ```
+pub fn match_path_ast(path: &ast::Path, segments: &[&str]) -> bool {
+    path.segments
+        .iter()
+        .rev()
+        .zip(segments.iter().rev())
+        .all(|(a, b)| a.ident.name.as_str() == *b)
+}
+
+/// If the expression is a path to a local, returns the canonical `HirId` of the local.
+pub fn path_to_local(expr: &Expr<'_>) -> Option<HirId> {
+    if let ExprKind::Path(QPath::Resolved(None, ref path)) = expr.kind {
+        if let Res::Local(id) = path.res {
+            return Some(id);
+        }
+    }
+    None
+}
+
+/// Returns true if the expression is a path to a local with the specified `HirId`.
+/// Use this function to see if an expression matches a function argument or a match binding.
+pub fn path_to_local_id(expr: &Expr<'_>, id: HirId) -> bool {
+    path_to_local(expr) == Some(id)
+}
+
+/// Gets the definition associated to a path.
+#[allow(clippy::shadow_unrelated)] // false positive #6563
+pub fn path_to_res(cx: &LateContext<'_>, path: &[&str]) -> Res {
+    macro_rules! try_res {
+        ($e:expr) => {
+            match $e {
+                Some(e) => e,
+                None => return Res::Err,
+            }
+        };
+    }
+    fn item_child_by_name<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId, name: &str) -> Option<&'tcx Export<HirId>> {
+        tcx.item_children(def_id)
+            .iter()
+            .find(|item| item.ident.name.as_str() == name)
+    }
+
+    let (krate, first, path) = match *path {
+        [krate, first, ref path @ ..] => (krate, first, path),
+        _ => return Res::Err,
+    };
+    let tcx = cx.tcx;
+    let crates = tcx.crates();
+    let krate = try_res!(crates.iter().find(|&&num| tcx.crate_name(num).as_str() == krate));
+    let first = try_res!(item_child_by_name(tcx, krate.as_def_id(), first));
+    let last = path
+        .iter()
+        .copied()
+        // `get_def_path` seems to generate these empty segments for extern blocks.
+        // We can just ignore them.
+        .filter(|segment| !segment.is_empty())
+        // for each segment, find the child item
+        .try_fold(first, |item, segment| {
+            let def_id = item.res.def_id();
+            if let Some(item) = item_child_by_name(tcx, def_id, segment) {
+                Some(item)
+            } else if matches!(item.res, Res::Def(DefKind::Enum | DefKind::Struct, _)) {
+                // it is not a child item so check inherent impl items
+                tcx.inherent_impls(def_id)
+                    .iter()
+                    .find_map(|&impl_def_id| item_child_by_name(tcx, impl_def_id, segment))
+            } else {
+                None
+            }
+        });
+    try_res!(last).res
+}
+
+/// Convenience function to get the `DefId` of a trait by path.
+/// It could be a trait or trait alias.
+pub fn get_trait_def_id(cx: &LateContext<'_>, path: &[&str]) -> Option<DefId> {
+    match path_to_res(cx, path) {
+        Res::Def(DefKind::Trait | DefKind::TraitAlias, trait_id) => Some(trait_id),
+        _ => None,
+    }
+}
+
+/// Checks whether a type implements a trait.
+/// See also `get_trait_def_id`.
+pub fn implements_trait<'tcx>(
+    cx: &LateContext<'tcx>,
+    ty: Ty<'tcx>,
+    trait_id: DefId,
+    ty_params: &[GenericArg<'tcx>],
+) -> bool {
+    // Do not check on infer_types to avoid panic in evaluate_obligation.
+    if ty.has_infer_types() {
+        return false;
+    }
+    let ty = cx.tcx.erase_regions(ty);
+    if ty.has_escaping_bound_vars() {
+        return false;
+    }
+    let ty_params = cx.tcx.mk_substs(ty_params.iter());
+    cx.tcx.type_implements_trait((trait_id, ty, ty_params, cx.param_env))
+}
+
+/// Gets the `hir::TraitRef` of the trait the given method is implemented for.
+///
+/// Use this if you want to find the `TraitRef` of the `Add` trait in this example:
+///
+/// ```rust
+/// struct Point(isize, isize);
+///
+/// impl std::ops::Add for Point {
+///     type Output = Self;
+///
+///     fn add(self, other: Self) -> Self {
+///         Point(0, 0)
+///     }
+/// }
+/// ```
+pub fn trait_ref_of_method<'tcx>(cx: &LateContext<'tcx>, hir_id: HirId) -> Option<&'tcx TraitRef<'tcx>> {
+    // Get the implemented trait for the current function
+    let parent_impl = cx.tcx.hir().get_parent_item(hir_id);
+    if_chain! {
+        if parent_impl != hir::CRATE_HIR_ID;
+        if let hir::Node::Item(item) = cx.tcx.hir().get(parent_impl);
+        if let hir::ItemKind::Impl(impl_) = &item.kind;
+        then { return impl_.of_trait.as_ref(); }
+    }
+    None
+}
+
+/// Checks whether this type implements `Drop`.
+pub fn has_drop<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
+    match ty.ty_adt_def() {
+        Some(def) => def.has_dtor(cx.tcx),
+        None => false,
+    }
+}
+
+/// Returns the method names and argument list of nested method call expressions that make up
+/// `expr`. method/span lists are sorted with the most recent call first.
+pub fn method_calls<'tcx>(
+    expr: &'tcx Expr<'tcx>,
+    max_depth: usize,
+) -> (Vec<Symbol>, Vec<&'tcx [Expr<'tcx>]>, Vec<Span>) {
+    let mut method_names = Vec::with_capacity(max_depth);
+    let mut arg_lists = Vec::with_capacity(max_depth);
+    let mut spans = Vec::with_capacity(max_depth);
+
+    let mut current = expr;
+    for _ in 0..max_depth {
+        if let ExprKind::MethodCall(path, span, args, _) = &current.kind {
+            if args.iter().any(|e| e.span.from_expansion()) {
+                break;
+            }
+            method_names.push(path.ident.name);
+            arg_lists.push(&**args);
+            spans.push(*span);
+            current = &args[0];
+        } else {
+            break;
+        }
+    }
+
+    (method_names, arg_lists, spans)
+}
+
+/// Matches an `Expr` against a chain of methods, and return the matched `Expr`s.
+///
+/// For example, if `expr` represents the `.baz()` in `foo.bar().baz()`,
+/// `method_chain_args(expr, &["bar", "baz"])` will return a `Vec`
+/// containing the `Expr`s for
+/// `.bar()` and `.baz()`
+pub fn method_chain_args<'a>(expr: &'a Expr<'_>, methods: &[&str]) -> Option<Vec<&'a [Expr<'a>]>> {
+    let mut current = expr;
+    let mut matched = Vec::with_capacity(methods.len());
+    for method_name in methods.iter().rev() {
+        // method chains are stored last -> first
+        if let ExprKind::MethodCall(ref path, _, ref args, _) = current.kind {
+            if path.ident.name.as_str() == *method_name {
+                if args.iter().any(|e| e.span.from_expansion()) {
+                    return None;
+                }
+                matched.push(&**args); // build up `matched` backwards
+                current = &args[0] // go to parent expression
+            } else {
+                return None;
+            }
+        } else {
+            return None;
+        }
+    }
+    // Reverse `matched` so that it is in the same order as `methods`.
+    matched.reverse();
+    Some(matched)
+}
+
+/// Returns `true` if the provided `def_id` is an entrypoint to a program.
+pub fn is_entrypoint_fn(cx: &LateContext<'_>, def_id: DefId) -> bool {
+    cx.tcx
+        .entry_fn(LOCAL_CRATE)
+        .map_or(false, |(entry_fn_def_id, _)| def_id == entry_fn_def_id.to_def_id())
+}
+
+/// Returns `true` if the expression is in the program's `#[panic_handler]`.
+pub fn is_in_panic_handler(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
+    let parent = cx.tcx.hir().get_parent_item(e.hir_id);
+    let def_id = cx.tcx.hir().local_def_id(parent).to_def_id();
+    Some(def_id) == cx.tcx.lang_items().panic_impl()
+}
+
+/// Gets the name of the item the expression is in, if available.
+pub fn get_item_name(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<Symbol> {
+    let parent_id = cx.tcx.hir().get_parent_item(expr.hir_id);
+    match cx.tcx.hir().find(parent_id) {
+        Some(
+            Node::Item(Item { ident, .. })
+            | Node::TraitItem(TraitItem { ident, .. })
+            | Node::ImplItem(ImplItem { ident, .. }),
+        ) => Some(ident.name),
+        _ => None,
+    }
+}
+
+/// Gets the name of a `Pat`, if any.
+pub fn get_pat_name(pat: &Pat<'_>) -> Option<Symbol> {
+    match pat.kind {
+        PatKind::Binding(.., ref spname, _) => Some(spname.name),
+        PatKind::Path(ref qpath) => single_segment_path(qpath).map(|ps| ps.ident.name),
+        PatKind::Box(ref p) | PatKind::Ref(ref p, _) => get_pat_name(&*p),
+        _ => None,
+    }
+}
+
+struct ContainsName {
+    name: Symbol,
+    result: bool,
+}
+
+impl<'tcx> Visitor<'tcx> for ContainsName {
+    type Map = Map<'tcx>;
+
+    fn visit_name(&mut self, _: Span, name: Symbol) {
+        if self.name == name {
+            self.result = true;
+        }
+    }
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::None
+    }
+}
+
+/// Checks if an `Expr` contains a certain name.
+pub fn contains_name(name: Symbol, expr: &Expr<'_>) -> bool {
+    let mut cn = ContainsName { name, result: false };
+    cn.visit_expr(expr);
+    cn.result
+}
+
+/// Returns `true` if `expr` contains a return expression
+pub fn contains_return(expr: &hir::Expr<'_>) -> bool {
+    struct RetCallFinder {
+        found: bool,
+    }
+
+    impl<'tcx> hir::intravisit::Visitor<'tcx> for RetCallFinder {
+        type Map = Map<'tcx>;
+
+        fn visit_expr(&mut self, expr: &'tcx hir::Expr<'_>) {
+            if self.found {
+                return;
+            }
+            if let hir::ExprKind::Ret(..) = &expr.kind {
+                self.found = true;
+            } else {
+                hir::intravisit::walk_expr(self, expr);
+            }
+        }
+
+        fn nested_visit_map(&mut self) -> hir::intravisit::NestedVisitorMap<Self::Map> {
+            hir::intravisit::NestedVisitorMap::None
+        }
+    }
+
+    let mut visitor = RetCallFinder { found: false };
+    visitor.visit_expr(expr);
+    visitor.found
+}
+
+struct FindMacroCalls<'a, 'b> {
+    names: &'a [&'b str],
+    result: Vec<Span>,
+}
+
+impl<'a, 'b, 'tcx> Visitor<'tcx> for FindMacroCalls<'a, 'b> {
+    type Map = Map<'tcx>;
+
+    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
+        if self.names.iter().any(|fun| is_expn_of(expr.span, fun).is_some()) {
+            self.result.push(expr.span);
+        }
+        // and check sub-expressions
+        intravisit::walk_expr(self, expr);
+    }
+
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::None
+    }
+}
+
+/// Finds calls of the specified macros in a function body.
+pub fn find_macro_calls(names: &[&str], body: &Body<'_>) -> Vec<Span> {
+    let mut fmc = FindMacroCalls {
+        names,
+        result: Vec::new(),
+    };
+    fmc.visit_expr(&body.value);
+    fmc.result
+}
+
+/// Converts a span to a code snippet if available, otherwise use default.
+///
+/// This is useful if you want to provide suggestions for your lint or more generally, if you want
+/// to convert a given `Span` to a `str`.
+///
+/// # Example
+/// ```rust,ignore
+/// snippet(cx, expr.span, "..")
+/// ```
+pub fn snippet<'a, T: LintContext>(cx: &T, span: Span, default: &'a str) -> Cow<'a, str> {
+    snippet_opt(cx, span).map_or_else(|| Cow::Borrowed(default), From::from)
+}
+
+/// Same as `snippet`, but it adapts the applicability level by following rules:
+///
+/// - Applicability level `Unspecified` will never be changed.
+/// - If the span is inside a macro, change the applicability level to `MaybeIncorrect`.
+/// - If the default value is used and the applicability level is `MachineApplicable`, change it to
+/// `HasPlaceholders`
+pub fn snippet_with_applicability<'a, T: LintContext>(
+    cx: &T,
+    span: Span,
+    default: &'a str,
+    applicability: &mut Applicability,
+) -> Cow<'a, str> {
+    if *applicability != Applicability::Unspecified && span.from_expansion() {
+        *applicability = Applicability::MaybeIncorrect;
+    }
+    snippet_opt(cx, span).map_or_else(
+        || {
+            if *applicability == Applicability::MachineApplicable {
+                *applicability = Applicability::HasPlaceholders;
+            }
+            Cow::Borrowed(default)
+        },
+        From::from,
+    )
+}
+
+/// Same as `snippet`, but should only be used when it's clear that the input span is
+/// not a macro argument.
+pub fn snippet_with_macro_callsite<'a, T: LintContext>(cx: &T, span: Span, default: &'a str) -> Cow<'a, str> {
+    snippet(cx, span.source_callsite(), default)
+}
+
+/// Converts a span to a code snippet. Returns `None` if not available.
+pub fn snippet_opt<T: LintContext>(cx: &T, span: Span) -> Option<String> {
+    cx.sess().source_map().span_to_snippet(span).ok()
+}
+
+/// Converts a span (from a block) to a code snippet if available, otherwise use default.
+///
+/// This trims the code of indentation, except for the first line. Use it for blocks or block-like
+/// things which need to be printed as such.
+///
+/// The `indent_relative_to` arg can be used, to provide a span, where the indentation of the
+/// resulting snippet of the given span.
+///
+/// # Example
+///
+/// ```rust,ignore
+/// snippet_block(cx, block.span, "..", None)
+/// // where, `block` is the block of the if expr
+///     if x {
+///         y;
+///     }
+/// // will return the snippet
+/// {
+///     y;
+/// }
+/// ```
+///
+/// ```rust,ignore
+/// snippet_block(cx, block.span, "..", Some(if_expr.span))
+/// // where, `block` is the block of the if expr
+///     if x {
+///         y;
+///     }
+/// // will return the snippet
+/// {
+///         y;
+///     } // aligned with `if`
+/// ```
+/// Note that the first line of the snippet always has 0 indentation.
+pub fn snippet_block<'a, T: LintContext>(
+    cx: &T,
+    span: Span,
+    default: &'a str,
+    indent_relative_to: Option<Span>,
+) -> Cow<'a, str> {
+    let snip = snippet(cx, span, default);
+    let indent = indent_relative_to.and_then(|s| indent_of(cx, s));
+    reindent_multiline(snip, true, indent)
+}
+
+/// Same as `snippet_block`, but adapts the applicability level by the rules of
+/// `snippet_with_applicability`.
+pub fn snippet_block_with_applicability<'a, T: LintContext>(
+    cx: &T,
+    span: Span,
+    default: &'a str,
+    indent_relative_to: Option<Span>,
+    applicability: &mut Applicability,
+) -> Cow<'a, str> {
+    let snip = snippet_with_applicability(cx, span, default, applicability);
+    let indent = indent_relative_to.and_then(|s| indent_of(cx, s));
+    reindent_multiline(snip, true, indent)
+}
+
+/// Returns a new Span that extends the original Span to the first non-whitespace char of the first
+/// line.
+///
+/// ```rust,ignore
+///     let x = ();
+/// //          ^^
+/// // will be converted to
+///     let x = ();
+/// //  ^^^^^^^^^^
+/// ```
+pub fn first_line_of_span<T: LintContext>(cx: &T, span: Span) -> Span {
+    first_char_in_first_line(cx, span).map_or(span, |first_char_pos| span.with_lo(first_char_pos))
+}
+
+fn first_char_in_first_line<T: LintContext>(cx: &T, span: Span) -> Option<BytePos> {
+    let line_span = line_span(cx, span);
+    snippet_opt(cx, line_span).and_then(|snip| {
+        snip.find(|c: char| !c.is_whitespace())
+            .map(|pos| line_span.lo() + BytePos::from_usize(pos))
+    })
+}
+
+/// Returns the indentation of the line of a span
+///
+/// ```rust,ignore
+/// let x = ();
+/// //      ^^ -- will return 0
+///     let x = ();
+/// //          ^^ -- will return 4
+/// ```
+pub fn indent_of<T: LintContext>(cx: &T, span: Span) -> Option<usize> {
+    snippet_opt(cx, line_span(cx, span)).and_then(|snip| snip.find(|c: char| !c.is_whitespace()))
+}
+
+/// Returns the positon just before rarrow
+///
+/// ```rust,ignore
+/// fn into(self) -> () {}
+///              ^
+/// // in case of unformatted code
+/// fn into2(self)-> () {}
+///               ^
+/// fn into3(self)   -> () {}
+///               ^
+/// ```
+pub fn position_before_rarrow(s: &str) -> Option<usize> {
+    s.rfind("->").map(|rpos| {
+        let mut rpos = rpos;
+        let chars: Vec<char> = s.chars().collect();
+        while rpos > 1 {
+            if let Some(c) = chars.get(rpos - 1) {
+                if c.is_whitespace() {
+                    rpos -= 1;
+                    continue;
+                }
+            }
+            break;
+        }
+        rpos
+    })
+}
+
+/// Extends the span to the beginning of the spans line, incl. whitespaces.
+///
+/// ```rust,ignore
+///        let x = ();
+/// //             ^^
+/// // will be converted to
+///        let x = ();
+/// // ^^^^^^^^^^^^^^
+/// ```
+fn line_span<T: LintContext>(cx: &T, span: Span) -> Span {
+    let span = original_sp(span, DUMMY_SP);
+    let source_map_and_line = cx.sess().source_map().lookup_line(span.lo()).unwrap();
+    let line_no = source_map_and_line.line;
+    let line_start = source_map_and_line.sf.lines[line_no];
+    Span::new(line_start, span.hi(), span.ctxt())
+}
+
+/// Like `snippet_block`, but add braces if the expr is not an `ExprKind::Block`.
+/// Also takes an `Option<String>` which can be put inside the braces.
+pub fn expr_block<'a, T: LintContext>(
+    cx: &T,
+    expr: &Expr<'_>,
+    option: Option<String>,
+    default: &'a str,
+    indent_relative_to: Option<Span>,
+) -> Cow<'a, str> {
+    let code = snippet_block(cx, expr.span, default, indent_relative_to);
+    let string = option.unwrap_or_default();
+    if expr.span.from_expansion() {
+        Cow::Owned(format!("{{ {} }}", snippet_with_macro_callsite(cx, expr.span, default)))
+    } else if let ExprKind::Block(_, _) = expr.kind {
+        Cow::Owned(format!("{}{}", code, string))
+    } else if string.is_empty() {
+        Cow::Owned(format!("{{ {} }}", code))
+    } else {
+        Cow::Owned(format!("{{\n{};\n{}\n}}", code, string))
+    }
+}
+
+/// Reindent a multiline string with possibility of ignoring the first line.
+#[allow(clippy::needless_pass_by_value)]
+pub fn reindent_multiline(s: Cow<'_, str>, ignore_first: bool, indent: Option<usize>) -> Cow<'_, str> {
+    let s_space = reindent_multiline_inner(&s, ignore_first, indent, ' ');
+    let s_tab = reindent_multiline_inner(&s_space, ignore_first, indent, '\t');
+    reindent_multiline_inner(&s_tab, ignore_first, indent, ' ').into()
+}
+
+fn reindent_multiline_inner(s: &str, ignore_first: bool, indent: Option<usize>, ch: char) -> String {
+    let x = s
+        .lines()
+        .skip(ignore_first as usize)
+        .filter_map(|l| {
+            if l.is_empty() {
+                None
+            } else {
+                // ignore empty lines
+                Some(l.char_indices().find(|&(_, x)| x != ch).unwrap_or((l.len(), ch)).0)
+            }
+        })
+        .min()
+        .unwrap_or(0);
+    let indent = indent.unwrap_or(0);
+    s.lines()
+        .enumerate()
+        .map(|(i, l)| {
+            if (ignore_first && i == 0) || l.is_empty() {
+                l.to_owned()
+            } else if x > indent {
+                l.split_at(x - indent).1.to_owned()
+            } else {
+                " ".repeat(indent - x) + l
+            }
+        })
+        .collect::<Vec<String>>()
+        .join("\n")
+}
+
+/// Gets the parent expression, if any –- this is useful to constrain a lint.
+pub fn get_parent_expr<'tcx>(cx: &LateContext<'tcx>, e: &Expr<'_>) -> Option<&'tcx Expr<'tcx>> {
+    let map = &cx.tcx.hir();
+    let hir_id = e.hir_id;
+    let parent_id = map.get_parent_node(hir_id);
+    if hir_id == parent_id {
+        return None;
+    }
+    map.find(parent_id).and_then(|node| {
+        if let Node::Expr(parent) = node {
+            Some(parent)
+        } else {
+            None
+        }
+    })
+}
+
+pub fn get_enclosing_block<'tcx>(cx: &LateContext<'tcx>, hir_id: HirId) -> Option<&'tcx Block<'tcx>> {
+    let map = &cx.tcx.hir();
+    let enclosing_node = map
+        .get_enclosing_scope(hir_id)
+        .and_then(|enclosing_id| map.find(enclosing_id));
+    enclosing_node.and_then(|node| match node {
+        Node::Block(block) => Some(block),
+        Node::Item(&Item {
+            kind: ItemKind::Fn(_, _, eid),
+            ..
+        })
+        | Node::ImplItem(&ImplItem {
+            kind: ImplItemKind::Fn(_, eid),
+            ..
+        }) => match cx.tcx.hir().body(eid).value.kind {
+            ExprKind::Block(ref block, _) => Some(block),
+            _ => None,
+        },
+        _ => None,
+    })
+}
+
+/// Returns the base type for HIR references and pointers.
+pub fn walk_ptrs_hir_ty<'tcx>(ty: &'tcx hir::Ty<'tcx>) -> &'tcx hir::Ty<'tcx> {
+    match ty.kind {
+        TyKind::Ptr(ref mut_ty) | TyKind::Rptr(_, ref mut_ty) => walk_ptrs_hir_ty(&mut_ty.ty),
+        _ => ty,
+    }
+}
+
+/// Returns the base type for references and raw pointers, and count reference
+/// depth.
+pub fn walk_ptrs_ty_depth(ty: Ty<'_>) -> (Ty<'_>, usize) {
+    fn inner(ty: Ty<'_>, depth: usize) -> (Ty<'_>, usize) {
+        match ty.kind() {
+            ty::Ref(_, ty, _) => inner(ty, depth + 1),
+            _ => (ty, depth),
+        }
+    }
+    inner(ty, 0)
+}
+
+/// Checks whether the given expression is a constant integer of the given value.
+/// unlike `is_integer_literal`, this version does const folding
+pub fn is_integer_const(cx: &LateContext<'_>, e: &Expr<'_>, value: u128) -> bool {
+    if is_integer_literal(e, value) {
+        return true;
+    }
+    let map = cx.tcx.hir();
+    let parent_item = map.get_parent_item(e.hir_id);
+    if let Some((Constant::Int(v), _)) = map
+        .maybe_body_owned_by(parent_item)
+        .and_then(|body_id| constant(cx, cx.tcx.typeck_body(body_id), e))
+    {
+        value == v
+    } else {
+        false
+    }
+}
+
+/// Checks whether the given expression is a constant literal of the given value.
+pub fn is_integer_literal(expr: &Expr<'_>, value: u128) -> bool {
+    // FIXME: use constant folding
+    if let ExprKind::Lit(ref spanned) = expr.kind {
+        if let LitKind::Int(v, _) = spanned.node {
+            return v == value;
+        }
+    }
+    false
+}
+
+/// Returns `true` if the given `Expr` has been coerced before.
+///
+/// Examples of coercions can be found in the Nomicon at
+/// <https://doc.rust-lang.org/nomicon/coercions.html>.
+///
+/// See `rustc_middle::ty::adjustment::Adjustment` and `rustc_typeck::check::coercion` for more
+/// information on adjustments and coercions.
+pub fn is_adjusted(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
+    cx.typeck_results().adjustments().get(e.hir_id).is_some()
+}
+
+/// Returns the pre-expansion span if is this comes from an expansion of the
+/// macro `name`.
+/// See also `is_direct_expn_of`.
+#[must_use]
+pub fn is_expn_of(mut span: Span, name: &str) -> Option<Span> {
+    loop {
+        if span.from_expansion() {
+            let data = span.ctxt().outer_expn_data();
+            let new_span = data.call_site;
+
+            if let ExpnKind::Macro(MacroKind::Bang, mac_name) = data.kind {
+                if mac_name.as_str() == name {
+                    return Some(new_span);
+                }
+            }
+
+            span = new_span;
+        } else {
+            return None;
+        }
+    }
+}
+
+/// Returns the pre-expansion span if the span directly comes from an expansion
+/// of the macro `name`.
+/// The difference with `is_expn_of` is that in
+/// ```rust,ignore
+/// foo!(bar!(42));
+/// ```
+/// `42` is considered expanded from `foo!` and `bar!` by `is_expn_of` but only
+/// `bar!` by
+/// `is_direct_expn_of`.
+#[must_use]
+pub fn is_direct_expn_of(span: Span, name: &str) -> Option<Span> {
+    if span.from_expansion() {
+        let data = span.ctxt().outer_expn_data();
+        let new_span = data.call_site;
+
+        if let ExpnKind::Macro(MacroKind::Bang, mac_name) = data.kind {
+            if mac_name.as_str() == name {
+                return Some(new_span);
+            }
+        }
+    }
+
+    None
+}
+
+/// Convenience function to get the return type of a function.
+pub fn return_ty<'tcx>(cx: &LateContext<'tcx>, fn_item: hir::HirId) -> Ty<'tcx> {
+    let fn_def_id = cx.tcx.hir().local_def_id(fn_item);
+    let ret_ty = cx.tcx.fn_sig(fn_def_id).output();
+    cx.tcx.erase_late_bound_regions(ret_ty)
+}
+
+/// Walks into `ty` and returns `true` if any inner type is the same as `other_ty`
+pub fn contains_ty(ty: Ty<'_>, other_ty: Ty<'_>) -> bool {
+    ty.walk().any(|inner| match inner.unpack() {
+        GenericArgKind::Type(inner_ty) => ty::TyS::same_type(other_ty, inner_ty),
+        GenericArgKind::Lifetime(_) | GenericArgKind::Const(_) => false,
+    })
+}
+
+/// Returns `true` if the given type is an `unsafe` function.
+pub fn type_is_unsafe_function<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
+    match ty.kind() {
+        ty::FnDef(..) | ty::FnPtr(_) => ty.fn_sig(cx.tcx).unsafety() == Unsafety::Unsafe,
+        _ => false,
+    }
+}
+
+pub fn is_copy<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
+    ty.is_copy_modulo_regions(cx.tcx.at(DUMMY_SP), cx.param_env)
+}
+
+/// Checks if an expression is constructing a tuple-like enum variant or struct
+pub fn is_ctor_or_promotable_const_function(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+    if let ExprKind::Call(ref fun, _) = expr.kind {
+        if let ExprKind::Path(ref qp) = fun.kind {
+            let res = cx.qpath_res(qp, fun.hir_id);
+            return match res {
+                def::Res::Def(DefKind::Variant | DefKind::Ctor(..), ..) => true,
+                def::Res::Def(_, def_id) => cx.tcx.is_promotable_const_fn(def_id),
+                _ => false,
+            };
+        }
+    }
+    false
+}
+
+/// Returns `true` if a pattern is refutable.
+// TODO: should be implemented using rustc/mir_build/thir machinery
+pub fn is_refutable(cx: &LateContext<'_>, pat: &Pat<'_>) -> bool {
+    fn is_enum_variant(cx: &LateContext<'_>, qpath: &QPath<'_>, id: HirId) -> bool {
+        matches!(
+            cx.qpath_res(qpath, id),
+            def::Res::Def(DefKind::Variant, ..) | Res::Def(DefKind::Ctor(def::CtorOf::Variant, _), _)
+        )
+    }
+
+    fn are_refutable<'a, I: Iterator<Item = &'a Pat<'a>>>(cx: &LateContext<'_>, mut i: I) -> bool {
+        i.any(|pat| is_refutable(cx, pat))
+    }
+
+    match pat.kind {
+        PatKind::Wild => false,
+        PatKind::Binding(_, _, _, pat) => pat.map_or(false, |pat| is_refutable(cx, pat)),
+        PatKind::Box(ref pat) | PatKind::Ref(ref pat, _) => is_refutable(cx, pat),
+        PatKind::Lit(..) | PatKind::Range(..) => true,
+        PatKind::Path(ref qpath) => is_enum_variant(cx, qpath, pat.hir_id),
+        PatKind::Or(ref pats) => {
+            // TODO: should be the honest check, that pats is exhaustive set
+            are_refutable(cx, pats.iter().map(|pat| &**pat))
+        },
+        PatKind::Tuple(ref pats, _) => are_refutable(cx, pats.iter().map(|pat| &**pat)),
+        PatKind::Struct(ref qpath, ref fields, _) => {
+            is_enum_variant(cx, qpath, pat.hir_id) || are_refutable(cx, fields.iter().map(|field| &*field.pat))
+        },
+        PatKind::TupleStruct(ref qpath, ref pats, _) => {
+            is_enum_variant(cx, qpath, pat.hir_id) || are_refutable(cx, pats.iter().map(|pat| &**pat))
+        },
+        PatKind::Slice(ref head, ref middle, ref tail) => {
+            match &cx.typeck_results().node_type(pat.hir_id).kind() {
+                ty::Slice(..) => {
+                    // [..] is the only irrefutable slice pattern.
+                    !head.is_empty() || middle.is_none() || !tail.is_empty()
+                },
+                ty::Array(..) => are_refutable(cx, head.iter().chain(middle).chain(tail.iter()).map(|pat| &**pat)),
+                _ => {
+                    // unreachable!()
+                    true
+                },
+            }
+        },
+    }
+}
+
+/// Checks for the `#[automatically_derived]` attribute all `#[derive]`d
+/// implementations have.
+pub fn is_automatically_derived(attrs: &[ast::Attribute]) -> bool {
+    attrs.iter().any(|attr| attr.has_name(sym::automatically_derived))
+}
+
+/// Remove blocks around an expression.
+///
+/// Ie. `x`, `{ x }` and `{{{{ x }}}}` all give `x`. `{ x; y }` and `{}` return
+/// themselves.
+pub fn remove_blocks<'tcx>(mut expr: &'tcx Expr<'tcx>) -> &'tcx Expr<'tcx> {
+    while let ExprKind::Block(ref block, ..) = expr.kind {
+        match (block.stmts.is_empty(), block.expr.as_ref()) {
+            (true, Some(e)) => expr = e,
+            _ => break,
+        }
+    }
+    expr
+}
+
+pub fn is_self(slf: &Param<'_>) -> bool {
+    if let PatKind::Binding(.., name, _) = slf.pat.kind {
+        name.name == kw::SelfLower
+    } else {
+        false
+    }
+}
+
+pub fn is_self_ty(slf: &hir::Ty<'_>) -> bool {
+    if_chain! {
+        if let TyKind::Path(QPath::Resolved(None, ref path)) = slf.kind;
+        if let Res::SelfTy(..) = path.res;
+        then {
+            return true
+        }
+    }
+    false
+}
+
+pub fn iter_input_pats<'tcx>(decl: &FnDecl<'_>, body: &'tcx Body<'_>) -> impl Iterator<Item = &'tcx Param<'tcx>> {
+    (0..decl.inputs.len()).map(move |i| &body.params[i])
+}
+
+/// Checks if a given expression is a match expression expanded from the `?`
+/// operator or the `try` macro.
+pub fn is_try<'tcx>(expr: &'tcx Expr<'tcx>) -> Option<&'tcx Expr<'tcx>> {
+    fn is_ok(arm: &Arm<'_>) -> bool {
+        if_chain! {
+            if let PatKind::TupleStruct(ref path, ref pat, None) = arm.pat.kind;
+            if match_qpath(path, &paths::RESULT_OK[1..]);
+            if let PatKind::Binding(_, hir_id, _, None) = pat[0].kind;
+            if path_to_local_id(arm.body, hir_id);
+            then {
+                return true;
+            }
+        }
+        false
+    }
+
+    fn is_err(arm: &Arm<'_>) -> bool {
+        if let PatKind::TupleStruct(ref path, _, _) = arm.pat.kind {
+            match_qpath(path, &paths::RESULT_ERR[1..])
+        } else {
+            false
+        }
+    }
+
+    if let ExprKind::Match(_, ref arms, ref source) = expr.kind {
+        // desugared from a `?` operator
+        if let MatchSource::TryDesugar = *source {
+            return Some(expr);
+        }
+
+        if_chain! {
+            if arms.len() == 2;
+            if arms[0].guard.is_none();
+            if arms[1].guard.is_none();
+            if (is_ok(&arms[0]) && is_err(&arms[1])) ||
+                (is_ok(&arms[1]) && is_err(&arms[0]));
+            then {
+                return Some(expr);
+            }
+        }
+    }
+
+    None
+}
+
+/// Returns `true` if the lint is allowed in the current context
+///
+/// Useful for skipping long running code when it's unnecessary
+pub fn is_allowed(cx: &LateContext<'_>, lint: &'static Lint, id: HirId) -> bool {
+    cx.tcx.lint_level_at_node(lint, id).0 == Level::Allow
+}
+
+pub fn strip_pat_refs<'hir>(mut pat: &'hir Pat<'hir>) -> &'hir Pat<'hir> {
+    while let PatKind::Ref(subpat, _) = pat.kind {
+        pat = subpat;
+    }
+    pat
+}
+
+pub fn int_bits(tcx: TyCtxt<'_>, ity: ty::IntTy) -> u64 {
+    Integer::from_int_ty(&tcx, ity).size().bits()
+}
+
+#[allow(clippy::cast_possible_wrap)]
+/// Turn a constant int byte representation into an i128
+pub fn sext(tcx: TyCtxt<'_>, u: u128, ity: ty::IntTy) -> i128 {
+    let amt = 128 - int_bits(tcx, ity);
+    ((u as i128) << amt) >> amt
+}
+
+#[allow(clippy::cast_sign_loss)]
+/// clip unused bytes
+pub fn unsext(tcx: TyCtxt<'_>, u: i128, ity: ty::IntTy) -> u128 {
+    let amt = 128 - int_bits(tcx, ity);
+    ((u as u128) << amt) >> amt
+}
+
+/// clip unused bytes
+pub fn clip(tcx: TyCtxt<'_>, u: u128, ity: ty::UintTy) -> u128 {
+    let bits = Integer::from_uint_ty(&tcx, ity).size().bits();
+    let amt = 128 - bits;
+    (u << amt) >> amt
+}
+
+/// Removes block comments from the given `Vec` of lines.
+///
+/// # Examples
+///
+/// ```rust,ignore
+/// without_block_comments(vec!["/*", "foo", "*/"]);
+/// // => vec![]
+///
+/// without_block_comments(vec!["bar", "/*", "foo", "*/"]);
+/// // => vec!["bar"]
+/// ```
+pub fn without_block_comments(lines: Vec<&str>) -> Vec<&str> {
+    let mut without = vec![];
+
+    let mut nest_level = 0;
+
+    for line in lines {
+        if line.contains("/*") {
+            nest_level += 1;
+            continue;
+        } else if line.contains("*/") {
+            nest_level -= 1;
+            continue;
+        }
+
+        if nest_level == 0 {
+            without.push(line);
+        }
+    }
+
+    without
+}
+
+pub fn any_parent_is_automatically_derived(tcx: TyCtxt<'_>, node: HirId) -> bool {
+    let map = &tcx.hir();
+    let mut prev_enclosing_node = None;
+    let mut enclosing_node = node;
+    while Some(enclosing_node) != prev_enclosing_node {
+        if is_automatically_derived(map.attrs(enclosing_node)) {
+            return true;
+        }
+        prev_enclosing_node = Some(enclosing_node);
+        enclosing_node = map.get_parent_item(enclosing_node);
+    }
+    false
+}
+
+/// Returns true if ty has `iter` or `iter_mut` methods
+pub fn has_iter_method(cx: &LateContext<'_>, probably_ref_ty: Ty<'_>) -> Option<&'static str> {
+    // FIXME: instead of this hard-coded list, we should check if `<adt>::iter`
+    // exists and has the desired signature. Unfortunately FnCtxt is not exported
+    // so we can't use its `lookup_method` method.
+    let into_iter_collections: [&[&str]; 13] = [
+        &paths::VEC,
+        &paths::OPTION,
+        &paths::RESULT,
+        &paths::BTREESET,
+        &paths::BTREEMAP,
+        &paths::VEC_DEQUE,
+        &paths::LINKED_LIST,
+        &paths::BINARY_HEAP,
+        &paths::HASHSET,
+        &paths::HASHMAP,
+        &paths::PATH_BUF,
+        &paths::PATH,
+        &paths::RECEIVER,
+    ];
+
+    let ty_to_check = match probably_ref_ty.kind() {
+        ty::Ref(_, ty_to_check, _) => ty_to_check,
+        _ => probably_ref_ty,
+    };
+
+    let def_id = match ty_to_check.kind() {
+        ty::Array(..) => return Some("array"),
+        ty::Slice(..) => return Some("slice"),
+        ty::Adt(adt, _) => adt.did,
+        _ => return None,
+    };
+
+    for path in &into_iter_collections {
+        if match_def_path(cx, def_id, path) {
+            return Some(*path.last().unwrap());
+        }
+    }
+    None
+}
+
+/// Matches a function call with the given path and returns the arguments.
+///
+/// Usage:
+///
+/// ```rust,ignore
+/// if let Some(args) = match_function_call(cx, cmp_max_call, &paths::CMP_MAX);
+/// ```
+pub fn match_function_call<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx Expr<'_>,
+    path: &[&str],
+) -> Option<&'tcx [Expr<'tcx>]> {
+    if_chain! {
+        if let ExprKind::Call(ref fun, ref args) = expr.kind;
+        if let ExprKind::Path(ref qpath) = fun.kind;
+        if let Some(fun_def_id) = cx.qpath_res(qpath, fun.hir_id).opt_def_id();
+        if match_def_path(cx, fun_def_id, path);
+        then {
+            return Some(&args)
+        }
+    };
+    None
+}
+
+/// Checks if `Ty` is normalizable. This function is useful
+/// to avoid crashes on `layout_of`.
+pub fn is_normalizable<'tcx>(cx: &LateContext<'tcx>, param_env: ty::ParamEnv<'tcx>, ty: Ty<'tcx>) -> bool {
+    cx.tcx.infer_ctxt().enter(|infcx| {
+        let cause = rustc_middle::traits::ObligationCause::dummy();
+        infcx.at(&cause, param_env).normalize(ty).is_ok()
+    })
+}
+
+pub fn match_def_path<'tcx>(cx: &LateContext<'tcx>, did: DefId, syms: &[&str]) -> bool {
+    // We have to convert `syms` to `&[Symbol]` here because rustc's `match_def_path`
+    // accepts only that. We should probably move to Symbols in Clippy as well.
+    let syms = syms.iter().map(|p| Symbol::intern(p)).collect::<Vec<Symbol>>();
+    cx.match_def_path(did, &syms)
+}
+
+pub fn match_panic_call<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<&'tcx [Expr<'tcx>]> {
+    match_function_call(cx, expr, &paths::BEGIN_PANIC)
+        .or_else(|| match_function_call(cx, expr, &paths::BEGIN_PANIC_FMT))
+        .or_else(|| match_function_call(cx, expr, &paths::PANIC_ANY))
+        .or_else(|| match_function_call(cx, expr, &paths::PANICKING_PANIC))
+        .or_else(|| match_function_call(cx, expr, &paths::PANICKING_PANIC_FMT))
+        .or_else(|| match_function_call(cx, expr, &paths::PANICKING_PANIC_STR))
+}
+
+pub fn match_panic_def_id(cx: &LateContext<'_>, did: DefId) -> bool {
+    match_def_path(cx, did, &paths::BEGIN_PANIC)
+        || match_def_path(cx, did, &paths::BEGIN_PANIC_FMT)
+        || match_def_path(cx, did, &paths::PANIC_ANY)
+        || match_def_path(cx, did, &paths::PANICKING_PANIC)
+        || match_def_path(cx, did, &paths::PANICKING_PANIC_FMT)
+        || match_def_path(cx, did, &paths::PANICKING_PANIC_STR)
+}
+
+/// Returns the list of condition expressions and the list of blocks in a
+/// sequence of `if/else`.
+/// E.g., this returns `([a, b], [c, d, e])` for the expression
+/// `if a { c } else if b { d } else { e }`.
+pub fn if_sequence<'tcx>(
+    mut expr: &'tcx Expr<'tcx>,
+) -> (SmallVec<[&'tcx Expr<'tcx>; 1]>, SmallVec<[&'tcx Block<'tcx>; 1]>) {
+    let mut conds = SmallVec::new();
+    let mut blocks: SmallVec<[&Block<'_>; 1]> = SmallVec::new();
+
+    while let ExprKind::If(ref cond, ref then_expr, ref else_expr) = expr.kind {
+        conds.push(&**cond);
+        if let ExprKind::Block(ref block, _) = then_expr.kind {
+            blocks.push(block);
+        } else {
+            panic!("ExprKind::If node is not an ExprKind::Block");
+        }
+
+        if let Some(ref else_expr) = *else_expr {
+            expr = else_expr;
+        } else {
+            break;
+        }
+    }
+
+    // final `else {..}`
+    if !blocks.is_empty() {
+        if let ExprKind::Block(ref block, _) = expr.kind {
+            blocks.push(&**block);
+        }
+    }
+
+    (conds, blocks)
+}
+
+pub fn parent_node_is_if_expr(expr: &Expr<'_>, cx: &LateContext<'_>) -> bool {
+    let map = cx.tcx.hir();
+    let parent_id = map.get_parent_node(expr.hir_id);
+    let parent_node = map.get(parent_id);
+    matches!(
+        parent_node,
+        Node::Expr(Expr {
+            kind: ExprKind::If(_, _, _),
+            ..
+        })
+    )
+}
+
+// Finds the attribute with the given name, if any
+pub fn attr_by_name<'a>(attrs: &'a [Attribute], name: &'_ str) -> Option<&'a Attribute> {
+    attrs
+        .iter()
+        .find(|attr| attr.ident().map_or(false, |ident| ident.as_str() == name))
+}
+
+// Finds the `#[must_use]` attribute, if any
+pub fn must_use_attr(attrs: &[Attribute]) -> Option<&Attribute> {
+    attr_by_name(attrs, "must_use")
+}
+
+// Returns whether the type has #[must_use] attribute
+pub fn is_must_use_ty<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
+    match ty.kind() {
+        ty::Adt(ref adt, _) => must_use_attr(&cx.tcx.get_attrs(adt.did)).is_some(),
+        ty::Foreign(ref did) => must_use_attr(&cx.tcx.get_attrs(*did)).is_some(),
+        ty::Slice(ref ty)
+        | ty::Array(ref ty, _)
+        | ty::RawPtr(ty::TypeAndMut { ref ty, .. })
+        | ty::Ref(_, ref ty, _) => {
+            // for the Array case we don't need to care for the len == 0 case
+            // because we don't want to lint functions returning empty arrays
+            is_must_use_ty(cx, *ty)
+        },
+        ty::Tuple(ref substs) => substs.types().any(|ty| is_must_use_ty(cx, ty)),
+        ty::Opaque(ref def_id, _) => {
+            for (predicate, _) in cx.tcx.explicit_item_bounds(*def_id) {
+                if let ty::PredicateKind::Trait(trait_predicate, _) = predicate.kind().skip_binder() {
+                    if must_use_attr(&cx.tcx.get_attrs(trait_predicate.trait_ref.def_id)).is_some() {
+                        return true;
+                    }
+                }
+            }
+            false
+        },
+        ty::Dynamic(binder, _) => {
+            for predicate in binder.iter() {
+                if let ty::ExistentialPredicate::Trait(ref trait_ref) = predicate.skip_binder() {
+                    if must_use_attr(&cx.tcx.get_attrs(trait_ref.def_id)).is_some() {
+                        return true;
+                    }
+                }
+            }
+            false
+        },
+        _ => false,
+    }
+}
+
+// check if expr is calling method or function with #[must_use] attribute
+pub fn is_must_use_func_call(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+    let did = match expr.kind {
+        ExprKind::Call(ref path, _) => if_chain! {
+            if let ExprKind::Path(ref qpath) = path.kind;
+            if let def::Res::Def(_, did) = cx.qpath_res(qpath, path.hir_id);
+            then {
+                Some(did)
+            } else {
+                None
+            }
+        },
+        ExprKind::MethodCall(_, _, _, _) => cx.typeck_results().type_dependent_def_id(expr.hir_id),
+        _ => None,
+    };
+
+    did.map_or(false, |did| must_use_attr(&cx.tcx.get_attrs(did)).is_some())
+}
+
+pub fn is_no_std_crate(krate: &Crate<'_>) -> bool {
+    krate.item.attrs.iter().any(|attr| {
+        if let ast::AttrKind::Normal(ref attr, _) = attr.kind {
+            attr.path == sym::no_std
+        } else {
+            false
+        }
+    })
+}
+
+/// Check if parent of a hir node is a trait implementation block.
+/// For example, `f` in
+/// ```rust,ignore
+/// impl Trait for S {
+///     fn f() {}
+/// }
+/// ```
+pub fn is_trait_impl_item(cx: &LateContext<'_>, hir_id: HirId) -> bool {
+    if let Some(Node::Item(item)) = cx.tcx.hir().find(cx.tcx.hir().get_parent_node(hir_id)) {
+        matches!(item.kind, ItemKind::Impl(hir::Impl { of_trait: Some(_), .. }))
+    } else {
+        false
+    }
+}
+
+/// Check if it's even possible to satisfy the `where` clause for the item.
+///
+/// `trivial_bounds` feature allows functions with unsatisfiable bounds, for example:
+///
+/// ```ignore
+/// fn foo() where i32: Iterator {
+///     for _ in 2i32 {}
+/// }
+/// ```
+pub fn fn_has_unsatisfiable_preds(cx: &LateContext<'_>, did: DefId) -> bool {
+    use rustc_trait_selection::traits;
+    let predicates =
+        cx.tcx
+            .predicates_of(did)
+            .predicates
+            .iter()
+            .filter_map(|(p, _)| if p.is_global() { Some(*p) } else { None });
+    traits::impossible_predicates(
+        cx.tcx,
+        traits::elaborate_predicates(cx.tcx, predicates)
+            .map(|o| o.predicate)
+            .collect::<Vec<_>>(),
+    )
+}
+
+/// Returns the `DefId` of the callee if the given expression is a function or method call.
+pub fn fn_def_id(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<DefId> {
+    match &expr.kind {
+        ExprKind::MethodCall(..) => cx.typeck_results().type_dependent_def_id(expr.hir_id),
+        ExprKind::Call(
+            Expr {
+                kind: ExprKind::Path(qpath),
+                hir_id: path_hir_id,
+                ..
+            },
+            ..,
+        ) => cx.typeck_results().qpath_res(qpath, *path_hir_id).opt_def_id(),
+        _ => None,
+    }
+}
+
+pub fn run_lints(cx: &LateContext<'_>, lints: &[&'static Lint], id: HirId) -> bool {
+    lints.iter().any(|lint| {
+        matches!(
+            cx.tcx.lint_level_at_node(lint, id),
+            (Level::Forbid | Level::Deny | Level::Warn, _)
+        )
+    })
+}
+
+/// Returns true iff the given type is a primitive (a bool or char, any integer or floating-point
+/// number type, a str, or an array, slice, or tuple of those types).
+pub fn is_recursively_primitive_type(ty: Ty<'_>) -> bool {
+    match ty.kind() {
+        ty::Bool | ty::Char | ty::Int(_) | ty::Uint(_) | ty::Float(_) | ty::Str => true,
+        ty::Ref(_, inner, _) if *inner.kind() == ty::Str => true,
+        ty::Array(inner_type, _) | ty::Slice(inner_type) => is_recursively_primitive_type(inner_type),
+        ty::Tuple(inner_types) => inner_types.types().all(is_recursively_primitive_type),
+        _ => false,
+    }
+}
+
+/// Returns Option<String> where String is a textual representation of the type encapsulated in the
+/// slice iff the given expression is a slice of primitives (as defined in the
+/// `is_recursively_primitive_type` function) and None otherwise.
+pub fn is_slice_of_primitives(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<String> {
+    let expr_type = cx.typeck_results().expr_ty_adjusted(expr);
+    let expr_kind = expr_type.kind();
+    let is_primitive = match expr_kind {
+        ty::Slice(element_type) => is_recursively_primitive_type(element_type),
+        ty::Ref(_, inner_ty, _) if matches!(inner_ty.kind(), &ty::Slice(_)) => {
+            if let ty::Slice(element_type) = inner_ty.kind() {
+                is_recursively_primitive_type(element_type)
+            } else {
+                unreachable!()
+            }
+        },
+        _ => false,
+    };
+
+    if is_primitive {
+        // if we have wrappers like Array, Slice or Tuple, print these
+        // and get the type enclosed in the slice ref
+        match expr_type.peel_refs().walk().nth(1).unwrap().expect_ty().kind() {
+            ty::Slice(..) => return Some("slice".into()),
+            ty::Array(..) => return Some("array".into()),
+            ty::Tuple(..) => return Some("tuple".into()),
+            _ => {
+                // is_recursively_primitive_type() should have taken care
+                // of the rest and we can rely on the type that is found
+                let refs_peeled = expr_type.peel_refs();
+                return Some(refs_peeled.walk().last().unwrap().to_string());
+            },
+        }
+    }
+    None
+}
+
+/// returns list of all pairs (a, b) from `exprs` such that `eq(a, b)`
+/// `hash` must be comformed with `eq`
+pub fn search_same<T, Hash, Eq>(exprs: &[T], hash: Hash, eq: Eq) -> Vec<(&T, &T)>
+where
+    Hash: Fn(&T) -> u64,
+    Eq: Fn(&T, &T) -> bool,
+{
+    if exprs.len() == 2 && eq(&exprs[0], &exprs[1]) {
+        return vec![(&exprs[0], &exprs[1])];
+    }
+
+    let mut match_expr_list: Vec<(&T, &T)> = Vec::new();
+
+    let mut map: FxHashMap<_, Vec<&_>> =
+        FxHashMap::with_capacity_and_hasher(exprs.len(), BuildHasherDefault::default());
+
+    for expr in exprs {
+        match map.entry(hash(expr)) {
+            Entry::Occupied(mut o) => {
+                for o in o.get() {
+                    if eq(o, expr) {
+                        match_expr_list.push((o, expr));
+                    }
+                }
+                o.get_mut().push(expr);
+            },
+            Entry::Vacant(v) => {
+                v.insert(vec![expr]);
+            },
+        }
+    }
+
+    match_expr_list
+}
+
+/// Peels off all references on the pattern. Returns the underlying pattern and the number of
+/// references removed.
+pub fn peel_hir_pat_refs(pat: &'a Pat<'a>) -> (&'a Pat<'a>, usize) {
+    fn peel(pat: &'a Pat<'a>, count: usize) -> (&'a Pat<'a>, usize) {
+        if let PatKind::Ref(pat, _) = pat.kind {
+            peel(pat, count + 1)
+        } else {
+            (pat, count)
+        }
+    }
+    peel(pat, 0)
+}
+
+/// Peels off up to the given number of references on the expression. Returns the underlying
+/// expression and the number of references removed.
+pub fn peel_n_hir_expr_refs(expr: &'a Expr<'a>, count: usize) -> (&'a Expr<'a>, usize) {
+    fn f(expr: &'a Expr<'a>, count: usize, target: usize) -> (&'a Expr<'a>, usize) {
+        match expr.kind {
+            ExprKind::AddrOf(_, _, expr) if count != target => f(expr, count + 1, target),
+            _ => (expr, count),
+        }
+    }
+    f(expr, 0, count)
+}
+
+/// Peels off all references on the expression. Returns the underlying expression and the number of
+/// references removed.
+pub fn peel_hir_expr_refs(expr: &'a Expr<'a>) -> (&'a Expr<'a>, usize) {
+    fn f(expr: &'a Expr<'a>, count: usize) -> (&'a Expr<'a>, usize) {
+        match expr.kind {
+            ExprKind::AddrOf(BorrowKind::Ref, _, expr) => f(expr, count + 1),
+            _ => (expr, count),
+        }
+    }
+    f(expr, 0)
+}
+
+/// Peels off all references on the type. Returns the underlying type and the number of references
+/// removed.
+pub fn peel_mid_ty_refs(ty: Ty<'_>) -> (Ty<'_>, usize) {
+    fn peel(ty: Ty<'_>, count: usize) -> (Ty<'_>, usize) {
+        if let ty::Ref(_, ty, _) = ty.kind() {
+            peel(ty, count + 1)
+        } else {
+            (ty, count)
+        }
+    }
+    peel(ty, 0)
+}
+
+/// Peels off all references on the type.Returns the underlying type, the number of references
+/// removed, and whether the pointer is ultimately mutable or not.
+pub fn peel_mid_ty_refs_is_mutable(ty: Ty<'_>) -> (Ty<'_>, usize, Mutability) {
+    fn f(ty: Ty<'_>, count: usize, mutability: Mutability) -> (Ty<'_>, usize, Mutability) {
+        match ty.kind() {
+            ty::Ref(_, ty, Mutability::Mut) => f(ty, count + 1, mutability),
+            ty::Ref(_, ty, Mutability::Not) => f(ty, count + 1, Mutability::Not),
+            _ => (ty, count, mutability),
+        }
+    }
+    f(ty, 0, Mutability::Mut)
+}
+
+#[macro_export]
+macro_rules! unwrap_cargo_metadata {
+    ($cx: ident, $lint: ident, $deps: expr) => {{
+        let mut command = cargo_metadata::MetadataCommand::new();
+        if !$deps {
+            command.no_deps();
+        }
+
+        match command.exec() {
+            Ok(metadata) => metadata,
+            Err(err) => {
+                span_lint($cx, $lint, DUMMY_SP, &format!("could not read cargo metadata: {}", err));
+                return;
+            },
+        }
+    }};
+}
+
+pub fn is_hir_ty_cfg_dependant(cx: &LateContext<'_>, ty: &hir::Ty<'_>) -> bool {
+    if_chain! {
+        if let TyKind::Path(QPath::Resolved(_, path)) = ty.kind;
+        if let Res::Def(_, def_id) = path.res;
+        then {
+            cx.tcx.has_attr(def_id, sym::cfg) || cx.tcx.has_attr(def_id, sym::cfg_attr)
+        } else {
+            false
+        }
+    }
+}
+
+/// Check if the resolution of a given path is an `Ok` variant of `Result`.
+pub fn is_ok_ctor(cx: &LateContext<'_>, res: Res) -> bool {
+    if let Some(ok_id) = cx.tcx.lang_items().result_ok_variant() {
+        if let Res::Def(DefKind::Ctor(CtorOf::Variant, CtorKind::Fn), id) = res {
+            if let Some(variant_id) = cx.tcx.parent(id) {
+                return variant_id == ok_id;
+            }
+        }
+    }
+    false
+}
+
+/// Check if the resolution of a given path is a `Some` variant of `Option`.
+pub fn is_some_ctor(cx: &LateContext<'_>, res: Res) -> bool {
+    if let Some(some_id) = cx.tcx.lang_items().option_some_variant() {
+        if let Res::Def(DefKind::Ctor(CtorOf::Variant, CtorKind::Fn), id) = res {
+            if let Some(variant_id) = cx.tcx.parent(id) {
+                return variant_id == some_id;
+            }
+        }
+    }
+    false
+}
+
+#[cfg(test)]
+mod test {
+    use super::{reindent_multiline, without_block_comments};
+
+    #[test]
+    fn test_reindent_multiline_single_line() {
+        assert_eq!("", reindent_multiline("".into(), false, None));
+        assert_eq!("...", reindent_multiline("...".into(), false, None));
+        assert_eq!("...", reindent_multiline("    ...".into(), false, None));
+        assert_eq!("...", reindent_multiline("\t...".into(), false, None));
+        assert_eq!("...", reindent_multiline("\t\t...".into(), false, None));
+    }
+
+    #[test]
+    #[rustfmt::skip]
+    fn test_reindent_multiline_block() {
+        assert_eq!("\
+    if x {
+        y
+    } else {
+        z
+    }", reindent_multiline("    if x {
+            y
+        } else {
+            z
+        }".into(), false, None));
+        assert_eq!("\
+    if x {
+    \ty
+    } else {
+    \tz
+    }", reindent_multiline("    if x {
+        \ty
+        } else {
+        \tz
+        }".into(), false, None));
+    }
+
+    #[test]
+    #[rustfmt::skip]
+    fn test_reindent_multiline_empty_line() {
+        assert_eq!("\
+    if x {
+        y
+
+    } else {
+        z
+    }", reindent_multiline("    if x {
+            y
+
+        } else {
+            z
+        }".into(), false, None));
+    }
+
+    #[test]
+    #[rustfmt::skip]
+    fn test_reindent_multiline_lines_deeper() {
+        assert_eq!("\
+        if x {
+            y
+        } else {
+            z
+        }", reindent_multiline("\
+    if x {
+        y
+    } else {
+        z
+    }".into(), true, Some(8)));
+    }
+
+    #[test]
+    fn test_without_block_comments_lines_without_block_comments() {
+        let result = without_block_comments(vec!["/*", "", "*/"]);
+        println!("result: {:?}", result);
+        assert!(result.is_empty());
+
+        let result = without_block_comments(vec!["", "/*", "", "*/", "#[crate_type = \"lib\"]", "/*", "", "*/", ""]);
+        assert_eq!(result, vec!["", "#[crate_type = \"lib\"]", ""]);
+
+        let result = without_block_comments(vec!["/* rust", "", "*/"]);
+        assert!(result.is_empty());
+
+        let result = without_block_comments(vec!["/* one-line comment */"]);
+        assert!(result.is_empty());
+
+        let result = without_block_comments(vec!["/* nested", "/* multi-line", "comment", "*/", "test", "*/"]);
+        assert!(result.is_empty());
+
+        let result = without_block_comments(vec!["/* nested /* inline /* comment */ test */ */"]);
+        assert!(result.is_empty());
+
+        let result = without_block_comments(vec!["foo", "bar", "baz"]);
+        assert_eq!(result, vec!["foo", "bar", "baz"]);
+    }
+}
diff --git a/clippy_utils/src/numeric_literal.rs b/clippy_utils/src/numeric_literal.rs
new file mode 100644
index 00000000000..d02603d7702
--- /dev/null
+++ b/clippy_utils/src/numeric_literal.rs
@@ -0,0 +1,228 @@
+use rustc_ast::ast::{Lit, LitFloatType, LitIntType, LitKind};
+
+#[derive(Debug, PartialEq, Copy, Clone)]
+pub enum Radix {
+    Binary,
+    Octal,
+    Decimal,
+    Hexadecimal,
+}
+
+impl Radix {
+    /// Returns a reasonable digit group size for this radix.
+    #[must_use]
+    fn suggest_grouping(self) -> usize {
+        match self {
+            Self::Binary | Self::Hexadecimal => 4,
+            Self::Octal | Self::Decimal => 3,
+        }
+    }
+}
+
+/// A helper method to format numeric literals with digit grouping.
+/// `lit` must be a valid numeric literal without suffix.
+pub fn format(lit: &str, type_suffix: Option<&str>, float: bool) -> String {
+    NumericLiteral::new(lit, type_suffix, float).format()
+}
+
+#[derive(Debug)]
+pub struct NumericLiteral<'a> {
+    /// Which radix the literal was represented in.
+    pub radix: Radix,
+    /// The radix prefix, if present.
+    pub prefix: Option<&'a str>,
+
+    /// The integer part of the number.
+    pub integer: &'a str,
+    /// The fraction part of the number.
+    pub fraction: Option<&'a str>,
+    /// The exponent separator (b'e' or b'E') including preceding underscore if present
+    /// and the exponent part.
+    pub exponent: Option<(&'a str, &'a str)>,
+
+    /// The type suffix, including preceding underscore if present.
+    pub suffix: Option<&'a str>,
+}
+
+impl<'a> NumericLiteral<'a> {
+    pub fn from_lit(src: &'a str, lit: &Lit) -> Option<NumericLiteral<'a>> {
+        NumericLiteral::from_lit_kind(src, &lit.kind)
+    }
+
+    pub fn from_lit_kind(src: &'a str, lit_kind: &LitKind) -> Option<NumericLiteral<'a>> {
+        if lit_kind.is_numeric() && src.chars().next().map_or(false, |c| c.is_digit(10)) {
+            let (unsuffixed, suffix) = split_suffix(&src, lit_kind);
+            let float = matches!(lit_kind, LitKind::Float(..));
+            Some(NumericLiteral::new(unsuffixed, suffix, float))
+        } else {
+            None
+        }
+    }
+
+    #[must_use]
+    pub fn new(lit: &'a str, suffix: Option<&'a str>, float: bool) -> Self {
+        // Determine delimiter for radix prefix, if present, and radix.
+        let radix = if lit.starts_with("0x") {
+            Radix::Hexadecimal
+        } else if lit.starts_with("0b") {
+            Radix::Binary
+        } else if lit.starts_with("0o") {
+            Radix::Octal
+        } else {
+            Radix::Decimal
+        };
+
+        // Grab part of the literal after prefix, if present.
+        let (prefix, mut sans_prefix) = if let Radix::Decimal = radix {
+            (None, lit)
+        } else {
+            let (p, s) = lit.split_at(2);
+            (Some(p), s)
+        };
+
+        if suffix.is_some() && sans_prefix.ends_with('_') {
+            // The '_' before the suffix isn't part of the digits
+            sans_prefix = &sans_prefix[..sans_prefix.len() - 1];
+        }
+
+        let (integer, fraction, exponent) = Self::split_digit_parts(sans_prefix, float);
+
+        Self {
+            radix,
+            prefix,
+            integer,
+            fraction,
+            exponent,
+            suffix,
+        }
+    }
+
+    pub fn is_decimal(&self) -> bool {
+        self.radix == Radix::Decimal
+    }
+
+    pub fn split_digit_parts(digits: &str, float: bool) -> (&str, Option<&str>, Option<(&str, &str)>) {
+        let mut integer = digits;
+        let mut fraction = None;
+        let mut exponent = None;
+
+        if float {
+            for (i, c) in digits.char_indices() {
+                match c {
+                    '.' => {
+                        integer = &digits[..i];
+                        fraction = Some(&digits[i + 1..]);
+                    },
+                    'e' | 'E' => {
+                        let exp_start = if digits[..i].ends_with('_') { i - 1 } else { i };
+
+                        if integer.len() > exp_start {
+                            integer = &digits[..exp_start];
+                        } else {
+                            fraction = Some(&digits[integer.len() + 1..exp_start]);
+                        };
+                        exponent = Some((&digits[exp_start..=i], &digits[i + 1..]));
+                        break;
+                    },
+                    _ => {},
+                }
+            }
+        }
+
+        (integer, fraction, exponent)
+    }
+
+    /// Returns literal formatted in a sensible way.
+    pub fn format(&self) -> String {
+        let mut output = String::new();
+
+        if let Some(prefix) = self.prefix {
+            output.push_str(prefix);
+        }
+
+        let group_size = self.radix.suggest_grouping();
+
+        Self::group_digits(
+            &mut output,
+            self.integer,
+            group_size,
+            true,
+            self.radix == Radix::Hexadecimal,
+        );
+
+        if let Some(fraction) = self.fraction {
+            output.push('.');
+            Self::group_digits(&mut output, fraction, group_size, false, false);
+        }
+
+        if let Some((separator, exponent)) = self.exponent {
+            output.push_str(separator);
+            Self::group_digits(&mut output, exponent, group_size, true, false);
+        }
+
+        if let Some(suffix) = self.suffix {
+            output.push('_');
+            output.push_str(suffix);
+        }
+
+        output
+    }
+
+    pub fn group_digits(output: &mut String, input: &str, group_size: usize, partial_group_first: bool, pad: bool) {
+        debug_assert!(group_size > 0);
+
+        let mut digits = input.chars().filter(|&c| c != '_');
+
+        let first_group_size;
+
+        if partial_group_first {
+            first_group_size = (digits.clone().count() - 1) % group_size + 1;
+            if pad {
+                for _ in 0..group_size - first_group_size {
+                    output.push('0');
+                }
+            }
+        } else {
+            first_group_size = group_size;
+        }
+
+        for _ in 0..first_group_size {
+            if let Some(digit) = digits.next() {
+                output.push(digit);
+            }
+        }
+
+        for (c, i) in digits.zip((0..group_size).cycle()) {
+            if i == 0 {
+                output.push('_');
+            }
+            output.push(c);
+        }
+    }
+}
+
+fn split_suffix<'a>(src: &'a str, lit_kind: &LitKind) -> (&'a str, Option<&'a str>) {
+    debug_assert!(lit_kind.is_numeric());
+    lit_suffix_length(lit_kind).map_or((src, None), |suffix_length| {
+        let (unsuffixed, suffix) = src.split_at(src.len() - suffix_length);
+        (unsuffixed, Some(suffix))
+    })
+}
+
+fn lit_suffix_length(lit_kind: &LitKind) -> Option<usize> {
+    debug_assert!(lit_kind.is_numeric());
+    let suffix = match lit_kind {
+        LitKind::Int(_, int_lit_kind) => match int_lit_kind {
+            LitIntType::Signed(int_ty) => Some(int_ty.name_str()),
+            LitIntType::Unsigned(uint_ty) => Some(uint_ty.name_str()),
+            LitIntType::Unsuffixed => None,
+        },
+        LitKind::Float(_, float_lit_kind) => match float_lit_kind {
+            LitFloatType::Suffixed(float_ty) => Some(float_ty.name_str()),
+            LitFloatType::Unsuffixed => None,
+        },
+        _ => None,
+    };
+
+    suffix.map(str::len)
+}
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
new file mode 100644
index 00000000000..432cc5b59f6
--- /dev/null
+++ b/clippy_utils/src/paths.rs
@@ -0,0 +1,181 @@
+//! This module contains paths to types and functions Clippy needs to know
+//! about.
+//!
+//! Whenever possible, please consider diagnostic items over hardcoded paths.
+//! See <https://github.com/rust-lang/rust-clippy/issues/5393> for more information.
+
+pub const ANY_TRAIT: [&str; 3] = ["std", "any", "Any"];
+pub const ARC_PTR_EQ: [&str; 4] = ["alloc", "sync", "Arc", "ptr_eq"];
+pub const ASMUT_TRAIT: [&str; 3] = ["core", "convert", "AsMut"];
+pub const ASREF_TRAIT: [&str; 3] = ["core", "convert", "AsRef"];
+pub(super) const BEGIN_PANIC: [&str; 3] = ["std", "panicking", "begin_panic"];
+pub(super) const BEGIN_PANIC_FMT: [&str; 3] = ["std", "panicking", "begin_panic_fmt"];
+pub const BINARY_HEAP: [&str; 4] = ["alloc", "collections", "binary_heap", "BinaryHeap"];
+pub const BORROW_TRAIT: [&str; 3] = ["core", "borrow", "Borrow"];
+pub const BOX: [&str; 3] = ["alloc", "boxed", "Box"];
+pub const BTREEMAP: [&str; 5] = ["alloc", "collections", "btree", "map", "BTreeMap"];
+pub const BTREEMAP_ENTRY: [&str; 6] = ["alloc", "collections", "btree", "map", "entry", "Entry"];
+pub const BTREESET: [&str; 5] = ["alloc", "collections", "btree", "set", "BTreeSet"];
+pub const CLONE_TRAIT: [&str; 3] = ["core", "clone", "Clone"];
+pub const CLONE_TRAIT_METHOD: [&str; 4] = ["core", "clone", "Clone", "clone"];
+pub const CMP_MAX: [&str; 3] = ["core", "cmp", "max"];
+pub const CMP_MIN: [&str; 3] = ["core", "cmp", "min"];
+pub const COPY: [&str; 3] = ["core", "intrinsics", "copy_nonoverlapping"];
+pub const COPY_NONOVERLAPPING: [&str; 3] = ["core", "intrinsics", "copy"];
+pub const COW: [&str; 3] = ["alloc", "borrow", "Cow"];
+pub const CSTRING_AS_C_STR: [&str; 5] = ["std", "ffi", "c_str", "CString", "as_c_str"];
+pub const DEFAULT_TRAIT: [&str; 3] = ["core", "default", "Default"];
+pub const DEFAULT_TRAIT_METHOD: [&str; 4] = ["core", "default", "Default", "default"];
+pub const DEREF_MUT_TRAIT_METHOD: [&str; 5] = ["core", "ops", "deref", "DerefMut", "deref_mut"];
+pub const DEREF_TRAIT_METHOD: [&str; 5] = ["core", "ops", "deref", "Deref", "deref"];
+pub const DISPLAY_FMT_METHOD: [&str; 4] = ["core", "fmt", "Display", "fmt"];
+pub const DISPLAY_TRAIT: [&str; 3] = ["core", "fmt", "Display"];
+pub const DOUBLE_ENDED_ITERATOR: [&str; 4] = ["core", "iter", "traits", "DoubleEndedIterator"];
+pub const DROP: [&str; 3] = ["core", "mem", "drop"];
+pub const DURATION: [&str; 3] = ["core", "time", "Duration"];
+#[cfg(feature = "internal-lints")]
+pub const EARLY_CONTEXT: [&str; 2] = ["rustc_lint", "EarlyContext"];
+pub const EXIT: [&str; 3] = ["std", "process", "exit"];
+pub const F32_EPSILON: [&str; 4] = ["core", "f32", "<impl f32>", "EPSILON"];
+pub const F64_EPSILON: [&str; 4] = ["core", "f64", "<impl f64>", "EPSILON"];
+pub const FILE: [&str; 3] = ["std", "fs", "File"];
+pub const FILE_TYPE: [&str; 3] = ["std", "fs", "FileType"];
+pub const FMT_ARGUMENTS_NEW_V1: [&str; 4] = ["core", "fmt", "Arguments", "new_v1"];
+pub const FMT_ARGUMENTS_NEW_V1_FORMATTED: [&str; 4] = ["core", "fmt", "Arguments", "new_v1_formatted"];
+pub const FMT_ARGUMENTV1_NEW: [&str; 4] = ["core", "fmt", "ArgumentV1", "new"];
+pub const FN: [&str; 3] = ["core", "ops", "Fn"];
+pub const FN_MUT: [&str; 3] = ["core", "ops", "FnMut"];
+pub const FN_ONCE: [&str; 3] = ["core", "ops", "FnOnce"];
+pub const FROM_FROM: [&str; 4] = ["core", "convert", "From", "from"];
+pub const FROM_ITERATOR: [&str; 5] = ["core", "iter", "traits", "collect", "FromIterator"];
+pub const FUTURE_FROM_GENERATOR: [&str; 3] = ["core", "future", "from_generator"];
+pub const HASH: [&str; 3] = ["core", "hash", "Hash"];
+pub const HASHMAP: [&str; 5] = ["std", "collections", "hash", "map", "HashMap"];
+pub const HASHMAP_ENTRY: [&str; 5] = ["std", "collections", "hash", "map", "Entry"];
+pub const HASHSET: [&str; 5] = ["std", "collections", "hash", "set", "HashSet"];
+#[cfg(feature = "internal-lints")]
+pub const IDENT: [&str; 3] = ["rustc_span", "symbol", "Ident"];
+#[cfg(feature = "internal-lints")]
+pub const IDENT_AS_STR: [&str; 4] = ["rustc_span", "symbol", "Ident", "as_str"];
+pub const INDEX: [&str; 3] = ["core", "ops", "Index"];
+pub const INDEX_MUT: [&str; 3] = ["core", "ops", "IndexMut"];
+pub const INSERT_STR: [&str; 4] = ["alloc", "string", "String", "insert_str"];
+pub const INTO: [&str; 3] = ["core", "convert", "Into"];
+pub const INTO_ITERATOR: [&str; 5] = ["core", "iter", "traits", "collect", "IntoIterator"];
+pub const IO_READ: [&str; 3] = ["std", "io", "Read"];
+pub const IO_WRITE: [&str; 3] = ["std", "io", "Write"];
+pub const IPADDR_V4: [&str; 4] = ["std", "net", "IpAddr", "V4"];
+pub const IPADDR_V6: [&str; 4] = ["std", "net", "IpAddr", "V6"];
+pub const ITERATOR: [&str; 5] = ["core", "iter", "traits", "iterator", "Iterator"];
+#[cfg(feature = "internal-lints")]
+pub const KW_MODULE: [&str; 3] = ["rustc_span", "symbol", "kw"];
+#[cfg(feature = "internal-lints")]
+pub const LATE_CONTEXT: [&str; 2] = ["rustc_lint", "LateContext"];
+pub const LINKED_LIST: [&str; 4] = ["alloc", "collections", "linked_list", "LinkedList"];
+#[cfg(feature = "internal-lints")]
+pub const LINT: [&str; 2] = ["rustc_lint_defs", "Lint"];
+pub const MEM_DISCRIMINANT: [&str; 3] = ["core", "mem", "discriminant"];
+pub const MEM_FORGET: [&str; 3] = ["core", "mem", "forget"];
+pub const MEM_MANUALLY_DROP: [&str; 4] = ["core", "mem", "manually_drop", "ManuallyDrop"];
+pub const MEM_MAYBEUNINIT: [&str; 4] = ["core", "mem", "maybe_uninit", "MaybeUninit"];
+pub const MEM_MAYBEUNINIT_UNINIT: [&str; 5] = ["core", "mem", "maybe_uninit", "MaybeUninit", "uninit"];
+pub const MEM_REPLACE: [&str; 3] = ["core", "mem", "replace"];
+pub const MEM_SIZE_OF: [&str; 3] = ["core", "mem", "size_of"];
+pub const MEM_SIZE_OF_VAL: [&str; 3] = ["core", "mem", "size_of_val"];
+pub const MUTEX_GUARD: [&str; 4] = ["std", "sync", "mutex", "MutexGuard"];
+pub const OPEN_OPTIONS: [&str; 3] = ["std", "fs", "OpenOptions"];
+pub const OPS_MODULE: [&str; 2] = ["core", "ops"];
+pub const OPTION: [&str; 3] = ["core", "option", "Option"];
+pub const OPTION_NONE: [&str; 4] = ["core", "option", "Option", "None"];
+pub const OPTION_SOME: [&str; 4] = ["core", "option", "Option", "Some"];
+pub const ORD: [&str; 3] = ["core", "cmp", "Ord"];
+pub const OS_STRING: [&str; 4] = ["std", "ffi", "os_str", "OsString"];
+pub const OS_STRING_AS_OS_STR: [&str; 5] = ["std", "ffi", "os_str", "OsString", "as_os_str"];
+pub const OS_STR_TO_OS_STRING: [&str; 5] = ["std", "ffi", "os_str", "OsStr", "to_os_string"];
+pub(super) const PANICKING_PANIC: [&str; 3] = ["core", "panicking", "panic"];
+pub(super) const PANICKING_PANIC_FMT: [&str; 3] = ["core", "panicking", "panic_fmt"];
+pub(super) const PANICKING_PANIC_STR: [&str; 3] = ["core", "panicking", "panic_str"];
+pub(super) const PANIC_ANY: [&str; 3] = ["std", "panic", "panic_any"];
+pub const PARKING_LOT_MUTEX_GUARD: [&str; 2] = ["parking_lot", "MutexGuard"];
+pub const PARKING_LOT_RWLOCK_READ_GUARD: [&str; 2] = ["parking_lot", "RwLockReadGuard"];
+pub const PARKING_LOT_RWLOCK_WRITE_GUARD: [&str; 2] = ["parking_lot", "RwLockWriteGuard"];
+pub const PATH: [&str; 3] = ["std", "path", "Path"];
+pub const PATH_BUF: [&str; 3] = ["std", "path", "PathBuf"];
+pub const PATH_BUF_AS_PATH: [&str; 4] = ["std", "path", "PathBuf", "as_path"];
+pub const PATH_TO_PATH_BUF: [&str; 4] = ["std", "path", "Path", "to_path_buf"];
+pub const POLL: [&str; 4] = ["core", "task", "poll", "Poll"];
+pub const POLL_PENDING: [&str; 5] = ["core", "task", "poll", "Poll", "Pending"];
+pub const POLL_READY: [&str; 5] = ["core", "task", "poll", "Poll", "Ready"];
+pub const PTR_EQ: [&str; 3] = ["core", "ptr", "eq"];
+pub const PTR_NULL: [&str; 3] = ["core", "ptr", "null"];
+pub const PTR_NULL_MUT: [&str; 3] = ["core", "ptr", "null_mut"];
+pub const PTR_SLICE_FROM_RAW_PARTS: [&str; 3] = ["core", "ptr", "slice_from_raw_parts"];
+pub const PTR_SLICE_FROM_RAW_PARTS_MUT: [&str; 3] = ["core", "ptr", "slice_from_raw_parts_mut"];
+pub const PTR_SWAP_NONOVERLAPPING: [&str; 3] = ["core", "ptr", "swap_nonoverlapping"];
+pub const PUSH_STR: [&str; 4] = ["alloc", "string", "String", "push_str"];
+pub const RANGE_ARGUMENT_TRAIT: [&str; 3] = ["core", "ops", "RangeBounds"];
+pub const RC: [&str; 3] = ["alloc", "rc", "Rc"];
+pub const RC_PTR_EQ: [&str; 4] = ["alloc", "rc", "Rc", "ptr_eq"];
+pub const RECEIVER: [&str; 4] = ["std", "sync", "mpsc", "Receiver"];
+pub const REFCELL_REF: [&str; 3] = ["core", "cell", "Ref"];
+pub const REFCELL_REFMUT: [&str; 3] = ["core", "cell", "RefMut"];
+pub const REGEX_BUILDER_NEW: [&str; 5] = ["regex", "re_builder", "unicode", "RegexBuilder", "new"];
+pub const REGEX_BYTES_BUILDER_NEW: [&str; 5] = ["regex", "re_builder", "bytes", "RegexBuilder", "new"];
+pub const REGEX_BYTES_NEW: [&str; 4] = ["regex", "re_bytes", "Regex", "new"];
+pub const REGEX_BYTES_SET_NEW: [&str; 5] = ["regex", "re_set", "bytes", "RegexSet", "new"];
+pub const REGEX_NEW: [&str; 4] = ["regex", "re_unicode", "Regex", "new"];
+pub const REGEX_SET_NEW: [&str; 5] = ["regex", "re_set", "unicode", "RegexSet", "new"];
+pub const REPEAT: [&str; 3] = ["core", "iter", "repeat"];
+pub const RESULT: [&str; 3] = ["core", "result", "Result"];
+pub const RESULT_ERR: [&str; 4] = ["core", "result", "Result", "Err"];
+pub const RESULT_OK: [&str; 4] = ["core", "result", "Result", "Ok"];
+pub const RWLOCK_READ_GUARD: [&str; 4] = ["std", "sync", "rwlock", "RwLockReadGuard"];
+pub const RWLOCK_WRITE_GUARD: [&str; 4] = ["std", "sync", "rwlock", "RwLockWriteGuard"];
+pub const SERDE_DESERIALIZE: [&str; 3] = ["serde", "de", "Deserialize"];
+pub const SERDE_DE_VISITOR: [&str; 3] = ["serde", "de", "Visitor"];
+pub const SLICE_FROM_RAW_PARTS: [&str; 4] = ["core", "slice", "raw", "from_raw_parts"];
+pub const SLICE_FROM_RAW_PARTS_MUT: [&str; 4] = ["core", "slice", "raw", "from_raw_parts_mut"];
+pub const SLICE_INTO_VEC: [&str; 4] = ["alloc", "slice", "<impl [T]>", "into_vec"];
+pub const SLICE_ITER: [&str; 4] = ["core", "slice", "iter", "Iter"];
+pub const STDERR: [&str; 4] = ["std", "io", "stdio", "stderr"];
+pub const STDOUT: [&str; 4] = ["std", "io", "stdio", "stdout"];
+pub const STD_CONVERT_IDENTITY: [&str; 3] = ["std", "convert", "identity"];
+pub const STD_FS_CREATE_DIR: [&str; 3] = ["std", "fs", "create_dir"];
+pub const STD_MEM_TRANSMUTE: [&str; 3] = ["std", "mem", "transmute"];
+pub const STD_PTR_NULL: [&str; 3] = ["std", "ptr", "null"];
+pub const STRING: [&str; 3] = ["alloc", "string", "String"];
+pub const STRING_AS_MUT_STR: [&str; 4] = ["alloc", "string", "String", "as_mut_str"];
+pub const STRING_AS_STR: [&str; 4] = ["alloc", "string", "String", "as_str"];
+pub const STR_ENDS_WITH: [&str; 4] = ["core", "str", "<impl str>", "ends_with"];
+pub const STR_FROM_UTF8: [&str; 4] = ["core", "str", "converts", "from_utf8"];
+pub const STR_LEN: [&str; 4] = ["core", "str", "<impl str>", "len"];
+pub const STR_STARTS_WITH: [&str; 4] = ["core", "str", "<impl str>", "starts_with"];
+#[cfg(feature = "internal-lints")]
+pub const SYMBOL: [&str; 3] = ["rustc_span", "symbol", "Symbol"];
+#[cfg(feature = "internal-lints")]
+pub const SYMBOL_AS_STR: [&str; 4] = ["rustc_span", "symbol", "Symbol", "as_str"];
+#[cfg(feature = "internal-lints")]
+pub const SYMBOL_INTERN: [&str; 4] = ["rustc_span", "symbol", "Symbol", "intern"];
+#[cfg(feature = "internal-lints")]
+pub const SYMBOL_TO_IDENT_STRING: [&str; 4] = ["rustc_span", "symbol", "Symbol", "to_ident_string"];
+#[cfg(feature = "internal-lints")]
+pub const SYM_MODULE: [&str; 3] = ["rustc_span", "symbol", "sym"];
+#[cfg(feature = "internal-lints")]
+pub const SYNTAX_CONTEXT: [&str; 3] = ["rustc_span", "hygiene", "SyntaxContext"];
+pub const TO_OWNED: [&str; 3] = ["alloc", "borrow", "ToOwned"];
+pub const TO_OWNED_METHOD: [&str; 4] = ["alloc", "borrow", "ToOwned", "to_owned"];
+pub const TO_STRING: [&str; 3] = ["alloc", "string", "ToString"];
+pub const TO_STRING_METHOD: [&str; 4] = ["alloc", "string", "ToString", "to_string"];
+pub const TRANSMUTE: [&str; 4] = ["core", "intrinsics", "", "transmute"];
+pub const TRY_FROM: [&str; 4] = ["core", "convert", "TryFrom", "try_from"];
+pub const TRY_INTO_TRAIT: [&str; 3] = ["core", "convert", "TryInto"];
+pub const VEC: [&str; 3] = ["alloc", "vec", "Vec"];
+pub const VEC_AS_MUT_SLICE: [&str; 4] = ["alloc", "vec", "Vec", "as_mut_slice"];
+pub const VEC_AS_SLICE: [&str; 4] = ["alloc", "vec", "Vec", "as_slice"];
+pub const VEC_DEQUE: [&str; 4] = ["alloc", "collections", "vec_deque", "VecDeque"];
+pub const VEC_FROM_ELEM: [&str; 3] = ["alloc", "vec", "from_elem"];
+pub const VEC_NEW: [&str; 4] = ["alloc", "vec", "Vec", "new"];
+pub const VEC_RESIZE: [&str; 4] = ["alloc", "vec", "Vec", "resize"];
+pub const WEAK_ARC: [&str; 3] = ["alloc", "sync", "Weak"];
+pub const WEAK_RC: [&str; 3] = ["alloc", "rc", "Weak"];
+pub const WRITE_BYTES: [&str; 3] = ["core", "intrinsics", "write_bytes"];
diff --git a/clippy_utils/src/ptr.rs b/clippy_utils/src/ptr.rs
new file mode 100644
index 00000000000..baeff08e02c
--- /dev/null
+++ b/clippy_utils/src/ptr.rs
@@ -0,0 +1,86 @@
+use crate::{get_pat_name, match_var, snippet};
+use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
+use rustc_hir::{Body, BodyId, Expr, ExprKind, Param};
+use rustc_lint::LateContext;
+use rustc_middle::hir::map::Map;
+use rustc_span::{Span, Symbol};
+use std::borrow::Cow;
+
+pub fn get_spans(
+    cx: &LateContext<'_>,
+    opt_body_id: Option<BodyId>,
+    idx: usize,
+    replacements: &[(&'static str, &'static str)],
+) -> Option<Vec<(Span, Cow<'static, str>)>> {
+    if let Some(body) = opt_body_id.map(|id| cx.tcx.hir().body(id)) {
+        get_binding_name(&body.params[idx]).map_or_else(
+            || Some(vec![]),
+            |name| extract_clone_suggestions(cx, name, replacements, body),
+        )
+    } else {
+        Some(vec![])
+    }
+}
+
+fn extract_clone_suggestions<'tcx>(
+    cx: &LateContext<'tcx>,
+    name: Symbol,
+    replace: &[(&'static str, &'static str)],
+    body: &'tcx Body<'_>,
+) -> Option<Vec<(Span, Cow<'static, str>)>> {
+    let mut visitor = PtrCloneVisitor {
+        cx,
+        name,
+        replace,
+        spans: vec![],
+        abort: false,
+    };
+    visitor.visit_body(body);
+    if visitor.abort {
+        None
+    } else {
+        Some(visitor.spans)
+    }
+}
+
+struct PtrCloneVisitor<'a, 'tcx> {
+    cx: &'a LateContext<'tcx>,
+    name: Symbol,
+    replace: &'a [(&'static str, &'static str)],
+    spans: Vec<(Span, Cow<'static, str>)>,
+    abort: bool,
+}
+
+impl<'a, 'tcx> Visitor<'tcx> for PtrCloneVisitor<'a, 'tcx> {
+    type Map = Map<'tcx>;
+
+    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
+        if self.abort {
+            return;
+        }
+        if let ExprKind::MethodCall(ref seg, _, ref args, _) = expr.kind {
+            if args.len() == 1 && match_var(&args[0], self.name) {
+                if seg.ident.name.as_str() == "capacity" {
+                    self.abort = true;
+                    return;
+                }
+                for &(fn_name, suffix) in self.replace {
+                    if seg.ident.name.as_str() == fn_name {
+                        self.spans
+                            .push((expr.span, snippet(self.cx, args[0].span, "_") + suffix));
+                        return;
+                    }
+                }
+            }
+        }
+        walk_expr(self, expr);
+    }
+
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::None
+    }
+}
+
+fn get_binding_name(arg: &Param<'_>) -> Option<Symbol> {
+    get_pat_name(&arg.pat)
+}
diff --git a/clippy_utils/src/qualify_min_const_fn.rs b/clippy_utils/src/qualify_min_const_fn.rs
new file mode 100644
index 00000000000..a482017afeb
--- /dev/null
+++ b/clippy_utils/src/qualify_min_const_fn.rs
@@ -0,0 +1,347 @@
+use rustc_hir as hir;
+use rustc_hir::def_id::DefId;
+use rustc_middle::mir::{
+    Body, CastKind, NullOp, Operand, Place, ProjectionElem, Rvalue, Statement, StatementKind, Terminator,
+    TerminatorKind,
+};
+use rustc_middle::ty::subst::GenericArgKind;
+use rustc_middle::ty::{self, adjustment::PointerCast, Ty, TyCtxt};
+use rustc_span::symbol::sym;
+use rustc_span::Span;
+use rustc_target::spec::abi::Abi::RustIntrinsic;
+use std::borrow::Cow;
+
+type McfResult = Result<(), (Span, Cow<'static, str>)>;
+
+pub fn is_min_const_fn(tcx: TyCtxt<'tcx>, body: &'a Body<'tcx>) -> McfResult {
+    let def_id = body.source.def_id();
+    let mut current = def_id;
+    loop {
+        let predicates = tcx.predicates_of(current);
+        for (predicate, _) in predicates.predicates {
+            match predicate.kind().skip_binder() {
+                ty::PredicateKind::RegionOutlives(_)
+                | ty::PredicateKind::TypeOutlives(_)
+                | ty::PredicateKind::WellFormed(_)
+                | ty::PredicateKind::Projection(_)
+                | ty::PredicateKind::ConstEvaluatable(..)
+                | ty::PredicateKind::ConstEquate(..)
+                | ty::PredicateKind::TypeWellFormedFromEnv(..) => continue,
+                ty::PredicateKind::ObjectSafe(_) => panic!("object safe predicate on function: {:#?}", predicate),
+                ty::PredicateKind::ClosureKind(..) => panic!("closure kind predicate on function: {:#?}", predicate),
+                ty::PredicateKind::Subtype(_) => panic!("subtype predicate on function: {:#?}", predicate),
+                ty::PredicateKind::Trait(pred, _) => {
+                    if Some(pred.def_id()) == tcx.lang_items().sized_trait() {
+                        continue;
+                    }
+                    match pred.self_ty().kind() {
+                        ty::Param(ref p) => {
+                            let generics = tcx.generics_of(current);
+                            let def = generics.type_param(p, tcx);
+                            let span = tcx.def_span(def.def_id);
+                            return Err((
+                                span,
+                                "trait bounds other than `Sized` \
+                                 on const fn parameters are unstable"
+                                    .into(),
+                            ));
+                        },
+                        // other kinds of bounds are either tautologies
+                        // or cause errors in other passes
+                        _ => continue,
+                    }
+                },
+            }
+        }
+        match predicates.parent {
+            Some(parent) => current = parent,
+            None => break,
+        }
+    }
+
+    for local in &body.local_decls {
+        check_ty(tcx, local.ty, local.source_info.span)?;
+    }
+    // impl trait is gone in MIR, so check the return type manually
+    check_ty(
+        tcx,
+        tcx.fn_sig(def_id).output().skip_binder(),
+        body.local_decls.iter().next().unwrap().source_info.span,
+    )?;
+
+    for bb in body.basic_blocks() {
+        check_terminator(tcx, body, bb.terminator())?;
+        for stmt in &bb.statements {
+            check_statement(tcx, body, def_id, stmt)?;
+        }
+    }
+    Ok(())
+}
+
+fn check_ty(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>, span: Span) -> McfResult {
+    for arg in ty.walk() {
+        let ty = match arg.unpack() {
+            GenericArgKind::Type(ty) => ty,
+
+            // No constraints on lifetimes or constants, except potentially
+            // constants' types, but `walk` will get to them as well.
+            GenericArgKind::Lifetime(_) | GenericArgKind::Const(_) => continue,
+        };
+
+        match ty.kind() {
+            ty::Ref(_, _, hir::Mutability::Mut) => {
+                return Err((span, "mutable references in const fn are unstable".into()));
+            },
+            ty::Opaque(..) => return Err((span, "`impl Trait` in const fn is unstable".into())),
+            ty::FnPtr(..) => {
+                return Err((span, "function pointers in const fn are unstable".into()));
+            },
+            ty::Dynamic(preds, _) => {
+                for pred in preds.iter() {
+                    match pred.skip_binder() {
+                        ty::ExistentialPredicate::AutoTrait(_) | ty::ExistentialPredicate::Projection(_) => {
+                            return Err((
+                                span,
+                                "trait bounds other than `Sized` \
+                                 on const fn parameters are unstable"
+                                    .into(),
+                            ));
+                        },
+                        ty::ExistentialPredicate::Trait(trait_ref) => {
+                            if Some(trait_ref.def_id) != tcx.lang_items().sized_trait() {
+                                return Err((
+                                    span,
+                                    "trait bounds other than `Sized` \
+                                     on const fn parameters are unstable"
+                                        .into(),
+                                ));
+                            }
+                        },
+                    }
+                }
+            },
+            _ => {},
+        }
+    }
+    Ok(())
+}
+
+fn check_rvalue(tcx: TyCtxt<'tcx>, body: &Body<'tcx>, def_id: DefId, rvalue: &Rvalue<'tcx>, span: Span) -> McfResult {
+    match rvalue {
+        Rvalue::ThreadLocalRef(_) => Err((span, "cannot access thread local storage in const fn".into())),
+        Rvalue::Repeat(operand, _) | Rvalue::Use(operand) => check_operand(tcx, operand, span, body),
+        Rvalue::Len(place) | Rvalue::Discriminant(place) | Rvalue::Ref(_, _, place) | Rvalue::AddressOf(_, place) => {
+            check_place(tcx, *place, span, body)
+        },
+        Rvalue::Cast(CastKind::Misc, operand, cast_ty) => {
+            use rustc_middle::ty::cast::CastTy;
+            let cast_in = CastTy::from_ty(operand.ty(body, tcx)).expect("bad input type for cast");
+            let cast_out = CastTy::from_ty(cast_ty).expect("bad output type for cast");
+            match (cast_in, cast_out) {
+                (CastTy::Ptr(_) | CastTy::FnPtr, CastTy::Int(_)) => {
+                    Err((span, "casting pointers to ints is unstable in const fn".into()))
+                },
+                _ => check_operand(tcx, operand, span, body),
+            }
+        },
+        Rvalue::Cast(CastKind::Pointer(PointerCast::MutToConstPointer | PointerCast::ArrayToPointer), operand, _) => {
+            check_operand(tcx, operand, span, body)
+        },
+        Rvalue::Cast(
+            CastKind::Pointer(
+                PointerCast::UnsafeFnPointer | PointerCast::ClosureFnPointer(_) | PointerCast::ReifyFnPointer,
+            ),
+            _,
+            _,
+        ) => Err((span, "function pointer casts are not allowed in const fn".into())),
+        Rvalue::Cast(CastKind::Pointer(PointerCast::Unsize), op, cast_ty) => {
+            let pointee_ty = if let Some(deref_ty) = cast_ty.builtin_deref(true) {
+                deref_ty.ty
+            } else {
+                // We cannot allow this for now.
+                return Err((span, "unsizing casts are only allowed for references right now".into()));
+            };
+            let unsized_ty = tcx.struct_tail_erasing_lifetimes(pointee_ty, tcx.param_env(def_id));
+            if let ty::Slice(_) | ty::Str = unsized_ty.kind() {
+                check_operand(tcx, op, span, body)?;
+                // Casting/coercing things to slices is fine.
+                Ok(())
+            } else {
+                // We just can't allow trait objects until we have figured out trait method calls.
+                Err((span, "unsizing casts are not allowed in const fn".into()))
+            }
+        },
+        // binops are fine on integers
+        Rvalue::BinaryOp(_, lhs, rhs) | Rvalue::CheckedBinaryOp(_, lhs, rhs) => {
+            check_operand(tcx, lhs, span, body)?;
+            check_operand(tcx, rhs, span, body)?;
+            let ty = lhs.ty(body, tcx);
+            if ty.is_integral() || ty.is_bool() || ty.is_char() {
+                Ok(())
+            } else {
+                Err((
+                    span,
+                    "only int, `bool` and `char` operations are stable in const fn".into(),
+                ))
+            }
+        },
+        Rvalue::NullaryOp(NullOp::SizeOf, _) => Ok(()),
+        Rvalue::NullaryOp(NullOp::Box, _) => Err((span, "heap allocations are not allowed in const fn".into())),
+        Rvalue::UnaryOp(_, operand) => {
+            let ty = operand.ty(body, tcx);
+            if ty.is_integral() || ty.is_bool() {
+                check_operand(tcx, operand, span, body)
+            } else {
+                Err((span, "only int and `bool` operations are stable in const fn".into()))
+            }
+        },
+        Rvalue::Aggregate(_, operands) => {
+            for operand in operands {
+                check_operand(tcx, operand, span, body)?;
+            }
+            Ok(())
+        },
+    }
+}
+
+fn check_statement(tcx: TyCtxt<'tcx>, body: &Body<'tcx>, def_id: DefId, statement: &Statement<'tcx>) -> McfResult {
+    let span = statement.source_info.span;
+    match &statement.kind {
+        StatementKind::Assign(box (place, rval)) => {
+            check_place(tcx, *place, span, body)?;
+            check_rvalue(tcx, body, def_id, rval, span)
+        },
+
+        StatementKind::FakeRead(_, place) |
+        // just an assignment
+        StatementKind::SetDiscriminant { place, .. } => check_place(tcx, **place, span, body),
+
+        StatementKind::LlvmInlineAsm { .. } => Err((span, "cannot use inline assembly in const fn".into())),
+
+        // These are all NOPs
+        StatementKind::StorageLive(_)
+        | StatementKind::StorageDead(_)
+        | StatementKind::Retag { .. }
+        | StatementKind::AscribeUserType(..)
+        | StatementKind::Coverage(..)
+        | StatementKind::Nop => Ok(()),
+    }
+}
+
+fn check_operand(tcx: TyCtxt<'tcx>, operand: &Operand<'tcx>, span: Span, body: &Body<'tcx>) -> McfResult {
+    match operand {
+        Operand::Move(place) | Operand::Copy(place) => check_place(tcx, *place, span, body),
+        Operand::Constant(c) => match c.check_static_ptr(tcx) {
+            Some(_) => Err((span, "cannot access `static` items in const fn".into())),
+            None => Ok(()),
+        },
+    }
+}
+
+fn check_place(tcx: TyCtxt<'tcx>, place: Place<'tcx>, span: Span, body: &Body<'tcx>) -> McfResult {
+    let mut cursor = place.projection.as_ref();
+    while let [ref proj_base @ .., elem] = *cursor {
+        cursor = proj_base;
+        match elem {
+            ProjectionElem::Field(..) => {
+                let base_ty = Place::ty_from(place.local, &proj_base, body, tcx).ty;
+                if let Some(def) = base_ty.ty_adt_def() {
+                    // No union field accesses in `const fn`
+                    if def.is_union() {
+                        return Err((span, "accessing union fields is unstable".into()));
+                    }
+                }
+            },
+            ProjectionElem::ConstantIndex { .. }
+            | ProjectionElem::Downcast(..)
+            | ProjectionElem::Subslice { .. }
+            | ProjectionElem::Deref
+            | ProjectionElem::Index(_) => {},
+        }
+    }
+
+    Ok(())
+}
+
+fn check_terminator(tcx: TyCtxt<'tcx>, body: &'a Body<'tcx>, terminator: &Terminator<'tcx>) -> McfResult {
+    let span = terminator.source_info.span;
+    match &terminator.kind {
+        TerminatorKind::FalseEdge { .. }
+        | TerminatorKind::FalseUnwind { .. }
+        | TerminatorKind::Goto { .. }
+        | TerminatorKind::Return
+        | TerminatorKind::Resume
+        | TerminatorKind::Unreachable => Ok(()),
+
+        TerminatorKind::Drop { place, .. } => check_place(tcx, *place, span, body),
+        TerminatorKind::DropAndReplace { place, value, .. } => {
+            check_place(tcx, *place, span, body)?;
+            check_operand(tcx, value, span, body)
+        },
+
+        TerminatorKind::SwitchInt {
+            discr,
+            switch_ty: _,
+            targets: _,
+        } => check_operand(tcx, discr, span, body),
+
+        TerminatorKind::Abort => Err((span, "abort is not stable in const fn".into())),
+        TerminatorKind::GeneratorDrop | TerminatorKind::Yield { .. } => {
+            Err((span, "const fn generators are unstable".into()))
+        },
+
+        TerminatorKind::Call {
+            func,
+            args,
+            from_hir_call: _,
+            destination: _,
+            cleanup: _,
+            fn_span: _,
+        } => {
+            let fn_ty = func.ty(body, tcx);
+            if let ty::FnDef(fn_def_id, _) = *fn_ty.kind() {
+                if !rustc_mir::const_eval::is_min_const_fn(tcx, fn_def_id) {
+                    return Err((
+                        span,
+                        format!(
+                            "can only call other `const fn` within a `const fn`, \
+                             but `{:?}` is not stable as `const fn`",
+                            func,
+                        )
+                        .into(),
+                    ));
+                }
+
+                // HACK: This is to "unstabilize" the `transmute` intrinsic
+                // within const fns. `transmute` is allowed in all other const contexts.
+                // This won't really scale to more intrinsics or functions. Let's allow const
+                // transmutes in const fn before we add more hacks to this.
+                if tcx.fn_sig(fn_def_id).abi() == RustIntrinsic && tcx.item_name(fn_def_id) == sym::transmute {
+                    return Err((
+                        span,
+                        "can only call `transmute` from const items, not `const fn`".into(),
+                    ));
+                }
+
+                check_operand(tcx, func, span, body)?;
+
+                for arg in args {
+                    check_operand(tcx, arg, span, body)?;
+                }
+                Ok(())
+            } else {
+                Err((span, "can only call other const fns within const fn".into()))
+            }
+        },
+
+        TerminatorKind::Assert {
+            cond,
+            expected: _,
+            msg: _,
+            target: _,
+            cleanup: _,
+        } => check_operand(tcx, cond, span, body),
+
+        TerminatorKind::InlineAsm { .. } => Err((span, "cannot use inline assembly in const fn".into())),
+    }
+}
diff --git a/clippy_utils/src/sugg.rs b/clippy_utils/src/sugg.rs
new file mode 100644
index 00000000000..d4f6f4281d3
--- /dev/null
+++ b/clippy_utils/src/sugg.rs
@@ -0,0 +1,683 @@
+//! Contains utility functions to generate suggestions.
+#![deny(clippy::missing_docs_in_private_items)]
+
+use crate::{higher, snippet, snippet_opt, snippet_with_macro_callsite};
+use rustc_ast::util::parser::AssocOp;
+use rustc_ast::{ast, token};
+use rustc_ast_pretty::pprust::token_kind_to_string;
+use rustc_errors::Applicability;
+use rustc_hir as hir;
+use rustc_lint::{EarlyContext, LateContext, LintContext};
+use rustc_span::source_map::{CharPos, Span};
+use rustc_span::{BytePos, Pos};
+use std::borrow::Cow;
+use std::convert::TryInto;
+use std::fmt::Display;
+use std::ops::{Add, Neg, Not, Sub};
+
+/// A helper type to build suggestion correctly handling parenthesis.
+#[derive(Clone, PartialEq)]
+pub enum Sugg<'a> {
+    /// An expression that never needs parenthesis such as `1337` or `[0; 42]`.
+    NonParen(Cow<'a, str>),
+    /// An expression that does not fit in other variants.
+    MaybeParen(Cow<'a, str>),
+    /// A binary operator expression, including `as`-casts and explicit type
+    /// coercion.
+    BinOp(AssocOp, Cow<'a, str>),
+}
+
+/// Literal constant `0`, for convenience.
+pub const ZERO: Sugg<'static> = Sugg::NonParen(Cow::Borrowed("0"));
+/// Literal constant `1`, for convenience.
+pub const ONE: Sugg<'static> = Sugg::NonParen(Cow::Borrowed("1"));
+/// a constant represents an empty string, for convenience.
+pub const EMPTY: Sugg<'static> = Sugg::NonParen(Cow::Borrowed(""));
+
+impl Display for Sugg<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
+        match *self {
+            Sugg::NonParen(ref s) | Sugg::MaybeParen(ref s) | Sugg::BinOp(_, ref s) => s.fmt(f),
+        }
+    }
+}
+
+#[allow(clippy::wrong_self_convention)] // ok, because of the function `as_ty` method
+impl<'a> Sugg<'a> {
+    /// Prepare a suggestion from an expression.
+    pub fn hir_opt(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> Option<Self> {
+        snippet_opt(cx, expr.span).map(|snippet| {
+            let snippet = Cow::Owned(snippet);
+            Self::hir_from_snippet(expr, snippet)
+        })
+    }
+
+    /// Convenience function around `hir_opt` for suggestions with a default
+    /// text.
+    pub fn hir(cx: &LateContext<'_>, expr: &hir::Expr<'_>, default: &'a str) -> Self {
+        Self::hir_opt(cx, expr).unwrap_or(Sugg::NonParen(Cow::Borrowed(default)))
+    }
+
+    /// Same as `hir`, but it adapts the applicability level by following rules:
+    ///
+    /// - Applicability level `Unspecified` will never be changed.
+    /// - If the span is inside a macro, change the applicability level to `MaybeIncorrect`.
+    /// - If the default value is used and the applicability level is `MachineApplicable`, change it
+    ///   to
+    /// `HasPlaceholders`
+    pub fn hir_with_applicability(
+        cx: &LateContext<'_>,
+        expr: &hir::Expr<'_>,
+        default: &'a str,
+        applicability: &mut Applicability,
+    ) -> Self {
+        if *applicability != Applicability::Unspecified && expr.span.from_expansion() {
+            *applicability = Applicability::MaybeIncorrect;
+        }
+        Self::hir_opt(cx, expr).unwrap_or_else(|| {
+            if *applicability == Applicability::MachineApplicable {
+                *applicability = Applicability::HasPlaceholders;
+            }
+            Sugg::NonParen(Cow::Borrowed(default))
+        })
+    }
+
+    /// Same as `hir`, but will use the pre expansion span if the `expr` was in a macro.
+    pub fn hir_with_macro_callsite(cx: &LateContext<'_>, expr: &hir::Expr<'_>, default: &'a str) -> Self {
+        let snippet = snippet_with_macro_callsite(cx, expr.span, default);
+
+        Self::hir_from_snippet(expr, snippet)
+    }
+
+    /// Generate a suggestion for an expression with the given snippet. This is used by the `hir_*`
+    /// function variants of `Sugg`, since these use different snippet functions.
+    fn hir_from_snippet(expr: &hir::Expr<'_>, snippet: Cow<'a, str>) -> Self {
+        if let Some(range) = higher::range(expr) {
+            let op = match range.limits {
+                ast::RangeLimits::HalfOpen => AssocOp::DotDot,
+                ast::RangeLimits::Closed => AssocOp::DotDotEq,
+            };
+            return Sugg::BinOp(op, snippet);
+        }
+
+        match expr.kind {
+            hir::ExprKind::AddrOf(..)
+            | hir::ExprKind::Box(..)
+            | hir::ExprKind::If(..)
+            | hir::ExprKind::Closure(..)
+            | hir::ExprKind::Unary(..)
+            | hir::ExprKind::Match(..) => Sugg::MaybeParen(snippet),
+            hir::ExprKind::Continue(..)
+            | hir::ExprKind::Yield(..)
+            | hir::ExprKind::Array(..)
+            | hir::ExprKind::Block(..)
+            | hir::ExprKind::Break(..)
+            | hir::ExprKind::Call(..)
+            | hir::ExprKind::Field(..)
+            | hir::ExprKind::Index(..)
+            | hir::ExprKind::InlineAsm(..)
+            | hir::ExprKind::LlvmInlineAsm(..)
+            | hir::ExprKind::ConstBlock(..)
+            | hir::ExprKind::Lit(..)
+            | hir::ExprKind::Loop(..)
+            | hir::ExprKind::MethodCall(..)
+            | hir::ExprKind::Path(..)
+            | hir::ExprKind::Repeat(..)
+            | hir::ExprKind::Ret(..)
+            | hir::ExprKind::Struct(..)
+            | hir::ExprKind::Tup(..)
+            | hir::ExprKind::DropTemps(_)
+            | hir::ExprKind::Err => Sugg::NonParen(snippet),
+            hir::ExprKind::Assign(..) => Sugg::BinOp(AssocOp::Assign, snippet),
+            hir::ExprKind::AssignOp(op, ..) => Sugg::BinOp(hirbinop2assignop(op), snippet),
+            hir::ExprKind::Binary(op, ..) => Sugg::BinOp(AssocOp::from_ast_binop(higher::binop(op.node)), snippet),
+            hir::ExprKind::Cast(..) => Sugg::BinOp(AssocOp::As, snippet),
+            hir::ExprKind::Type(..) => Sugg::BinOp(AssocOp::Colon, snippet),
+        }
+    }
+
+    /// Prepare a suggestion from an expression.
+    pub fn ast(cx: &EarlyContext<'_>, expr: &ast::Expr, default: &'a str) -> Self {
+        use rustc_ast::ast::RangeLimits;
+
+        let snippet = if expr.span.from_expansion() {
+            snippet_with_macro_callsite(cx, expr.span, default)
+        } else {
+            snippet(cx, expr.span, default)
+        };
+
+        match expr.kind {
+            ast::ExprKind::AddrOf(..)
+            | ast::ExprKind::Box(..)
+            | ast::ExprKind::Closure(..)
+            | ast::ExprKind::If(..)
+            | ast::ExprKind::Let(..)
+            | ast::ExprKind::Unary(..)
+            | ast::ExprKind::Match(..) => Sugg::MaybeParen(snippet),
+            ast::ExprKind::Async(..)
+            | ast::ExprKind::Block(..)
+            | ast::ExprKind::Break(..)
+            | ast::ExprKind::Call(..)
+            | ast::ExprKind::Continue(..)
+            | ast::ExprKind::Yield(..)
+            | ast::ExprKind::Field(..)
+            | ast::ExprKind::ForLoop(..)
+            | ast::ExprKind::Index(..)
+            | ast::ExprKind::InlineAsm(..)
+            | ast::ExprKind::LlvmInlineAsm(..)
+            | ast::ExprKind::ConstBlock(..)
+            | ast::ExprKind::Lit(..)
+            | ast::ExprKind::Loop(..)
+            | ast::ExprKind::MacCall(..)
+            | ast::ExprKind::MethodCall(..)
+            | ast::ExprKind::Paren(..)
+            | ast::ExprKind::Underscore
+            | ast::ExprKind::Path(..)
+            | ast::ExprKind::Repeat(..)
+            | ast::ExprKind::Ret(..)
+            | ast::ExprKind::Struct(..)
+            | ast::ExprKind::Try(..)
+            | ast::ExprKind::TryBlock(..)
+            | ast::ExprKind::Tup(..)
+            | ast::ExprKind::Array(..)
+            | ast::ExprKind::While(..)
+            | ast::ExprKind::Await(..)
+            | ast::ExprKind::Err => Sugg::NonParen(snippet),
+            ast::ExprKind::Range(.., RangeLimits::HalfOpen) => Sugg::BinOp(AssocOp::DotDot, snippet),
+            ast::ExprKind::Range(.., RangeLimits::Closed) => Sugg::BinOp(AssocOp::DotDotEq, snippet),
+            ast::ExprKind::Assign(..) => Sugg::BinOp(AssocOp::Assign, snippet),
+            ast::ExprKind::AssignOp(op, ..) => Sugg::BinOp(astbinop2assignop(op), snippet),
+            ast::ExprKind::Binary(op, ..) => Sugg::BinOp(AssocOp::from_ast_binop(op.node), snippet),
+            ast::ExprKind::Cast(..) => Sugg::BinOp(AssocOp::As, snippet),
+            ast::ExprKind::Type(..) => Sugg::BinOp(AssocOp::Colon, snippet),
+        }
+    }
+
+    /// Convenience method to create the `<lhs> && <rhs>` suggestion.
+    pub fn and(self, rhs: &Self) -> Sugg<'static> {
+        make_binop(ast::BinOpKind::And, &self, rhs)
+    }
+
+    /// Convenience method to create the `<lhs> & <rhs>` suggestion.
+    pub fn bit_and(self, rhs: &Self) -> Sugg<'static> {
+        make_binop(ast::BinOpKind::BitAnd, &self, rhs)
+    }
+
+    /// Convenience method to create the `<lhs> as <rhs>` suggestion.
+    pub fn as_ty<R: Display>(self, rhs: R) -> Sugg<'static> {
+        make_assoc(AssocOp::As, &self, &Sugg::NonParen(rhs.to_string().into()))
+    }
+
+    /// Convenience method to create the `&<expr>` suggestion.
+    pub fn addr(self) -> Sugg<'static> {
+        make_unop("&", self)
+    }
+
+    /// Convenience method to create the `&mut <expr>` suggestion.
+    pub fn mut_addr(self) -> Sugg<'static> {
+        make_unop("&mut ", self)
+    }
+
+    /// Convenience method to create the `*<expr>` suggestion.
+    pub fn deref(self) -> Sugg<'static> {
+        make_unop("*", self)
+    }
+
+    /// Convenience method to create the `&*<expr>` suggestion. Currently this
+    /// is needed because `sugg.deref().addr()` produces an unnecessary set of
+    /// parentheses around the deref.
+    pub fn addr_deref(self) -> Sugg<'static> {
+        make_unop("&*", self)
+    }
+
+    /// Convenience method to create the `&mut *<expr>` suggestion. Currently
+    /// this is needed because `sugg.deref().mut_addr()` produces an unnecessary
+    /// set of parentheses around the deref.
+    pub fn mut_addr_deref(self) -> Sugg<'static> {
+        make_unop("&mut *", self)
+    }
+
+    /// Convenience method to transform suggestion into a return call
+    pub fn make_return(self) -> Sugg<'static> {
+        Sugg::NonParen(Cow::Owned(format!("return {}", self)))
+    }
+
+    /// Convenience method to transform suggestion into a block
+    /// where the suggestion is a trailing expression
+    pub fn blockify(self) -> Sugg<'static> {
+        Sugg::NonParen(Cow::Owned(format!("{{ {} }}", self)))
+    }
+
+    /// Convenience method to create the `<lhs>..<rhs>` or `<lhs>...<rhs>`
+    /// suggestion.
+    #[allow(dead_code)]
+    pub fn range(self, end: &Self, limit: ast::RangeLimits) -> Sugg<'static> {
+        match limit {
+            ast::RangeLimits::HalfOpen => make_assoc(AssocOp::DotDot, &self, end),
+            ast::RangeLimits::Closed => make_assoc(AssocOp::DotDotEq, &self, end),
+        }
+    }
+
+    /// Adds parenthesis to any expression that might need them. Suitable to the
+    /// `self` argument of a method call
+    /// (e.g., to build `bar.foo()` or `(1 + 2).foo()`).
+    pub fn maybe_par(self) -> Self {
+        match self {
+            Sugg::NonParen(..) => self,
+            // `(x)` and `(x).y()` both don't need additional parens.
+            Sugg::MaybeParen(sugg) => {
+                if sugg.starts_with('(') && sugg.ends_with(')') {
+                    Sugg::MaybeParen(sugg)
+                } else {
+                    Sugg::NonParen(format!("({})", sugg).into())
+                }
+            },
+            Sugg::BinOp(_, sugg) => Sugg::NonParen(format!("({})", sugg).into()),
+        }
+    }
+}
+
+// Copied from the rust standart library, and then edited
+macro_rules! forward_binop_impls_to_ref {
+    (impl $imp:ident, $method:ident for $t:ty, type Output = $o:ty) => {
+        impl $imp<$t> for &$t {
+            type Output = $o;
+
+            fn $method(self, other: $t) -> $o {
+                $imp::$method(self, &other)
+            }
+        }
+
+        impl $imp<&$t> for $t {
+            type Output = $o;
+
+            fn $method(self, other: &$t) -> $o {
+                $imp::$method(&self, other)
+            }
+        }
+
+        impl $imp for $t {
+            type Output = $o;
+
+            fn $method(self, other: $t) -> $o {
+                $imp::$method(&self, &other)
+            }
+        }
+    };
+}
+
+impl Add for &Sugg<'_> {
+    type Output = Sugg<'static>;
+    fn add(self, rhs: &Sugg<'_>) -> Sugg<'static> {
+        make_binop(ast::BinOpKind::Add, self, rhs)
+    }
+}
+
+impl Sub for &Sugg<'_> {
+    type Output = Sugg<'static>;
+    fn sub(self, rhs: &Sugg<'_>) -> Sugg<'static> {
+        make_binop(ast::BinOpKind::Sub, self, rhs)
+    }
+}
+
+forward_binop_impls_to_ref!(impl Add, add for Sugg<'_>, type Output = Sugg<'static>);
+forward_binop_impls_to_ref!(impl Sub, sub for Sugg<'_>, type Output = Sugg<'static>);
+
+impl Neg for Sugg<'_> {
+    type Output = Sugg<'static>;
+    fn neg(self) -> Sugg<'static> {
+        make_unop("-", self)
+    }
+}
+
+impl Not for Sugg<'_> {
+    type Output = Sugg<'static>;
+    fn not(self) -> Sugg<'static> {
+        make_unop("!", self)
+    }
+}
+
+/// Helper type to display either `foo` or `(foo)`.
+struct ParenHelper<T> {
+    /// `true` if parentheses are needed.
+    paren: bool,
+    /// The main thing to display.
+    wrapped: T,
+}
+
+impl<T> ParenHelper<T> {
+    /// Builds a `ParenHelper`.
+    fn new(paren: bool, wrapped: T) -> Self {
+        Self { paren, wrapped }
+    }
+}
+
+impl<T: Display> Display for ParenHelper<T> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
+        if self.paren {
+            write!(f, "({})", self.wrapped)
+        } else {
+            self.wrapped.fmt(f)
+        }
+    }
+}
+
+/// Builds the string for `<op><expr>` adding parenthesis when necessary.
+///
+/// For convenience, the operator is taken as a string because all unary
+/// operators have the same
+/// precedence.
+pub fn make_unop(op: &str, expr: Sugg<'_>) -> Sugg<'static> {
+    Sugg::MaybeParen(format!("{}{}", op, expr.maybe_par()).into())
+}
+
+/// Builds the string for `<lhs> <op> <rhs>` adding parenthesis when necessary.
+///
+/// Precedence of shift operator relative to other arithmetic operation is
+/// often confusing so
+/// parenthesis will always be added for a mix of these.
+pub fn make_assoc(op: AssocOp, lhs: &Sugg<'_>, rhs: &Sugg<'_>) -> Sugg<'static> {
+    /// Returns `true` if the operator is a shift operator `<<` or `>>`.
+    fn is_shift(op: AssocOp) -> bool {
+        matches!(op, AssocOp::ShiftLeft | AssocOp::ShiftRight)
+    }
+
+    /// Returns `true` if the operator is a arithmetic operator
+    /// (i.e., `+`, `-`, `*`, `/`, `%`).
+    fn is_arith(op: AssocOp) -> bool {
+        matches!(
+            op,
+            AssocOp::Add | AssocOp::Subtract | AssocOp::Multiply | AssocOp::Divide | AssocOp::Modulus
+        )
+    }
+
+    /// Returns `true` if the operator `op` needs parenthesis with the operator
+    /// `other` in the direction `dir`.
+    fn needs_paren(op: AssocOp, other: AssocOp, dir: Associativity) -> bool {
+        other.precedence() < op.precedence()
+            || (other.precedence() == op.precedence()
+                && ((op != other && associativity(op) != dir)
+                    || (op == other && associativity(op) != Associativity::Both)))
+            || is_shift(op) && is_arith(other)
+            || is_shift(other) && is_arith(op)
+    }
+
+    let lhs_paren = if let Sugg::BinOp(lop, _) = *lhs {
+        needs_paren(op, lop, Associativity::Left)
+    } else {
+        false
+    };
+
+    let rhs_paren = if let Sugg::BinOp(rop, _) = *rhs {
+        needs_paren(op, rop, Associativity::Right)
+    } else {
+        false
+    };
+
+    let lhs = ParenHelper::new(lhs_paren, lhs);
+    let rhs = ParenHelper::new(rhs_paren, rhs);
+    let sugg = match op {
+        AssocOp::Add
+        | AssocOp::BitAnd
+        | AssocOp::BitOr
+        | AssocOp::BitXor
+        | AssocOp::Divide
+        | AssocOp::Equal
+        | AssocOp::Greater
+        | AssocOp::GreaterEqual
+        | AssocOp::LAnd
+        | AssocOp::LOr
+        | AssocOp::Less
+        | AssocOp::LessEqual
+        | AssocOp::Modulus
+        | AssocOp::Multiply
+        | AssocOp::NotEqual
+        | AssocOp::ShiftLeft
+        | AssocOp::ShiftRight
+        | AssocOp::Subtract => format!(
+            "{} {} {}",
+            lhs,
+            op.to_ast_binop().expect("Those are AST ops").to_string(),
+            rhs
+        ),
+        AssocOp::Assign => format!("{} = {}", lhs, rhs),
+        AssocOp::AssignOp(op) => format!("{} {}= {}", lhs, token_kind_to_string(&token::BinOp(op)), rhs),
+        AssocOp::As => format!("{} as {}", lhs, rhs),
+        AssocOp::DotDot => format!("{}..{}", lhs, rhs),
+        AssocOp::DotDotEq => format!("{}..={}", lhs, rhs),
+        AssocOp::Colon => format!("{}: {}", lhs, rhs),
+    };
+
+    Sugg::BinOp(op, sugg.into())
+}
+
+/// Convenience wrapper around `make_assoc` and `AssocOp::from_ast_binop`.
+pub fn make_binop(op: ast::BinOpKind, lhs: &Sugg<'_>, rhs: &Sugg<'_>) -> Sugg<'static> {
+    make_assoc(AssocOp::from_ast_binop(op), lhs, rhs)
+}
+
+#[derive(PartialEq, Eq, Clone, Copy)]
+/// Operator associativity.
+enum Associativity {
+    /// The operator is both left-associative and right-associative.
+    Both,
+    /// The operator is left-associative.
+    Left,
+    /// The operator is not associative.
+    None,
+    /// The operator is right-associative.
+    Right,
+}
+
+/// Returns the associativity/fixity of an operator. The difference with
+/// `AssocOp::fixity` is that an operator can be both left and right associative
+/// (such as `+`: `a + b + c == (a + b) + c == a + (b + c)`.
+///
+/// Chained `as` and explicit `:` type coercion never need inner parenthesis so
+/// they are considered
+/// associative.
+#[must_use]
+fn associativity(op: AssocOp) -> Associativity {
+    use rustc_ast::util::parser::AssocOp::{
+        Add, As, Assign, AssignOp, BitAnd, BitOr, BitXor, Colon, Divide, DotDot, DotDotEq, Equal, Greater,
+        GreaterEqual, LAnd, LOr, Less, LessEqual, Modulus, Multiply, NotEqual, ShiftLeft, ShiftRight, Subtract,
+    };
+
+    match op {
+        Assign | AssignOp(_) => Associativity::Right,
+        Add | BitAnd | BitOr | BitXor | LAnd | LOr | Multiply | As | Colon => Associativity::Both,
+        Divide | Equal | Greater | GreaterEqual | Less | LessEqual | Modulus | NotEqual | ShiftLeft | ShiftRight
+        | Subtract => Associativity::Left,
+        DotDot | DotDotEq => Associativity::None,
+    }
+}
+
+/// Converts a `hir::BinOp` to the corresponding assigning binary operator.
+fn hirbinop2assignop(op: hir::BinOp) -> AssocOp {
+    use rustc_ast::token::BinOpToken::{And, Caret, Minus, Or, Percent, Plus, Shl, Shr, Slash, Star};
+
+    AssocOp::AssignOp(match op.node {
+        hir::BinOpKind::Add => Plus,
+        hir::BinOpKind::BitAnd => And,
+        hir::BinOpKind::BitOr => Or,
+        hir::BinOpKind::BitXor => Caret,
+        hir::BinOpKind::Div => Slash,
+        hir::BinOpKind::Mul => Star,
+        hir::BinOpKind::Rem => Percent,
+        hir::BinOpKind::Shl => Shl,
+        hir::BinOpKind::Shr => Shr,
+        hir::BinOpKind::Sub => Minus,
+
+        hir::BinOpKind::And
+        | hir::BinOpKind::Eq
+        | hir::BinOpKind::Ge
+        | hir::BinOpKind::Gt
+        | hir::BinOpKind::Le
+        | hir::BinOpKind::Lt
+        | hir::BinOpKind::Ne
+        | hir::BinOpKind::Or => panic!("This operator does not exist"),
+    })
+}
+
+/// Converts an `ast::BinOp` to the corresponding assigning binary operator.
+fn astbinop2assignop(op: ast::BinOp) -> AssocOp {
+    use rustc_ast::ast::BinOpKind::{
+        Add, And, BitAnd, BitOr, BitXor, Div, Eq, Ge, Gt, Le, Lt, Mul, Ne, Or, Rem, Shl, Shr, Sub,
+    };
+    use rustc_ast::token::BinOpToken;
+
+    AssocOp::AssignOp(match op.node {
+        Add => BinOpToken::Plus,
+        BitAnd => BinOpToken::And,
+        BitOr => BinOpToken::Or,
+        BitXor => BinOpToken::Caret,
+        Div => BinOpToken::Slash,
+        Mul => BinOpToken::Star,
+        Rem => BinOpToken::Percent,
+        Shl => BinOpToken::Shl,
+        Shr => BinOpToken::Shr,
+        Sub => BinOpToken::Minus,
+        And | Eq | Ge | Gt | Le | Lt | Ne | Or => panic!("This operator does not exist"),
+    })
+}
+
+/// Returns the indentation before `span` if there are nothing but `[ \t]`
+/// before it on its line.
+fn indentation<T: LintContext>(cx: &T, span: Span) -> Option<String> {
+    let lo = cx.sess().source_map().lookup_char_pos(span.lo());
+    lo.file
+        .get_line(lo.line - 1 /* line numbers in `Loc` are 1-based */)
+        .and_then(|line| {
+            if let Some((pos, _)) = line.char_indices().find(|&(_, c)| c != ' ' && c != '\t') {
+                // We can mix char and byte positions here because we only consider `[ \t]`.
+                if lo.col == CharPos(pos) {
+                    Some(line[..pos].into())
+                } else {
+                    None
+                }
+            } else {
+                None
+            }
+        })
+}
+
+/// Convenience extension trait for `DiagnosticBuilder`.
+pub trait DiagnosticBuilderExt<T: LintContext> {
+    /// Suggests to add an attribute to an item.
+    ///
+    /// Correctly handles indentation of the attribute and item.
+    ///
+    /// # Example
+    ///
+    /// ```rust,ignore
+    /// diag.suggest_item_with_attr(cx, item, "#[derive(Default)]");
+    /// ```
+    fn suggest_item_with_attr<D: Display + ?Sized>(
+        &mut self,
+        cx: &T,
+        item: Span,
+        msg: &str,
+        attr: &D,
+        applicability: Applicability,
+    );
+
+    /// Suggest to add an item before another.
+    ///
+    /// The item should not be indented (except for inner indentation).
+    ///
+    /// # Example
+    ///
+    /// ```rust,ignore
+    /// diag.suggest_prepend_item(cx, item,
+    /// "fn foo() {
+    ///     bar();
+    /// }");
+    /// ```
+    fn suggest_prepend_item(&mut self, cx: &T, item: Span, msg: &str, new_item: &str, applicability: Applicability);
+
+    /// Suggest to completely remove an item.
+    ///
+    /// This will remove an item and all following whitespace until the next non-whitespace
+    /// character. This should work correctly if item is on the same indentation level as the
+    /// following item.
+    ///
+    /// # Example
+    ///
+    /// ```rust,ignore
+    /// diag.suggest_remove_item(cx, item, "remove this")
+    /// ```
+    fn suggest_remove_item(&mut self, cx: &T, item: Span, msg: &str, applicability: Applicability);
+}
+
+impl<T: LintContext> DiagnosticBuilderExt<T> for rustc_errors::DiagnosticBuilder<'_> {
+    fn suggest_item_with_attr<D: Display + ?Sized>(
+        &mut self,
+        cx: &T,
+        item: Span,
+        msg: &str,
+        attr: &D,
+        applicability: Applicability,
+    ) {
+        if let Some(indent) = indentation(cx, item) {
+            let span = item.with_hi(item.lo());
+
+            self.span_suggestion(span, msg, format!("{}\n{}", attr, indent), applicability);
+        }
+    }
+
+    fn suggest_prepend_item(&mut self, cx: &T, item: Span, msg: &str, new_item: &str, applicability: Applicability) {
+        if let Some(indent) = indentation(cx, item) {
+            let span = item.with_hi(item.lo());
+
+            let mut first = true;
+            let new_item = new_item
+                .lines()
+                .map(|l| {
+                    if first {
+                        first = false;
+                        format!("{}\n", l)
+                    } else {
+                        format!("{}{}\n", indent, l)
+                    }
+                })
+                .collect::<String>();
+
+            self.span_suggestion(span, msg, format!("{}\n{}", new_item, indent), applicability);
+        }
+    }
+
+    fn suggest_remove_item(&mut self, cx: &T, item: Span, msg: &str, applicability: Applicability) {
+        let mut remove_span = item;
+        let hi = cx.sess().source_map().next_point(remove_span).hi();
+        let fmpos = cx.sess().source_map().lookup_byte_offset(hi);
+
+        if let Some(ref src) = fmpos.sf.src {
+            let non_whitespace_offset = src[fmpos.pos.to_usize()..].find(|c| c != ' ' && c != '\t' && c != '\n');
+
+            if let Some(non_whitespace_offset) = non_whitespace_offset {
+                remove_span = remove_span
+                    .with_hi(remove_span.hi() + BytePos(non_whitespace_offset.try_into().expect("offset too large")))
+            }
+        }
+
+        self.span_suggestion(remove_span, msg, String::new(), applicability);
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::Sugg;
+    use std::borrow::Cow;
+
+    const SUGGESTION: Sugg<'static> = Sugg::NonParen(Cow::Borrowed("function_call()"));
+
+    #[test]
+    fn make_return_transform_sugg_into_a_return_call() {
+        assert_eq!("return function_call()", SUGGESTION.make_return().to_string());
+    }
+
+    #[test]
+    fn blockify_transforms_sugg_into_a_block() {
+        assert_eq!("{ function_call() }", SUGGESTION.blockify().to_string());
+    }
+}
diff --git a/clippy_utils/src/sym_helper.rs b/clippy_utils/src/sym_helper.rs
new file mode 100644
index 00000000000..f47dc80ebad
--- /dev/null
+++ b/clippy_utils/src/sym_helper.rs
@@ -0,0 +1,7 @@
+#[macro_export]
+/// Convenience wrapper around rustc's `Symbol::intern`
+macro_rules! sym {
+    ($tt:tt) => {
+        rustc_span::symbol::Symbol::intern(stringify!($tt))
+    };
+}
diff --git a/clippy_utils/src/usage.rs b/clippy_utils/src/usage.rs
new file mode 100644
index 00000000000..d577827dcf3
--- /dev/null
+++ b/clippy_utils/src/usage.rs
@@ -0,0 +1,198 @@
+use crate as utils;
+use rustc_data_structures::fx::FxHashSet;
+use rustc_hir as hir;
+use rustc_hir::def::Res;
+use rustc_hir::intravisit;
+use rustc_hir::intravisit::{NestedVisitorMap, Visitor};
+use rustc_hir::{Expr, ExprKind, HirId, Path};
+use rustc_infer::infer::TyCtxtInferExt;
+use rustc_lint::LateContext;
+use rustc_middle::hir::map::Map;
+use rustc_middle::ty;
+use rustc_typeck::expr_use_visitor::{ConsumeMode, Delegate, ExprUseVisitor, PlaceBase, PlaceWithHirId};
+
+/// Returns a set of mutated local variable IDs, or `None` if mutations could not be determined.
+pub fn mutated_variables<'tcx>(expr: &'tcx Expr<'_>, cx: &LateContext<'tcx>) -> Option<FxHashSet<HirId>> {
+    let mut delegate = MutVarsDelegate {
+        used_mutably: FxHashSet::default(),
+        skip: false,
+    };
+    cx.tcx.infer_ctxt().enter(|infcx| {
+        ExprUseVisitor::new(
+            &mut delegate,
+            &infcx,
+            expr.hir_id.owner,
+            cx.param_env,
+            cx.typeck_results(),
+        )
+        .walk_expr(expr);
+    });
+
+    if delegate.skip {
+        return None;
+    }
+    Some(delegate.used_mutably)
+}
+
+pub fn is_potentially_mutated<'tcx>(variable: &'tcx Path<'_>, expr: &'tcx Expr<'_>, cx: &LateContext<'tcx>) -> bool {
+    if let Res::Local(id) = variable.res {
+        mutated_variables(expr, cx).map_or(true, |mutated| mutated.contains(&id))
+    } else {
+        true
+    }
+}
+
+struct MutVarsDelegate {
+    used_mutably: FxHashSet<HirId>,
+    skip: bool,
+}
+
+impl<'tcx> MutVarsDelegate {
+    #[allow(clippy::similar_names)]
+    fn update(&mut self, cat: &PlaceWithHirId<'tcx>) {
+        match cat.place.base {
+            PlaceBase::Local(id) => {
+                self.used_mutably.insert(id);
+            },
+            PlaceBase::Upvar(_) => {
+                //FIXME: This causes false negatives. We can't get the `NodeId` from
+                //`Categorization::Upvar(_)`. So we search for any `Upvar`s in the
+                //`while`-body, not just the ones in the condition.
+                self.skip = true
+            },
+            _ => {},
+        }
+    }
+}
+
+impl<'tcx> Delegate<'tcx> for MutVarsDelegate {
+    fn consume(&mut self, _: &PlaceWithHirId<'tcx>, _: HirId, _: ConsumeMode) {}
+
+    fn borrow(&mut self, cmt: &PlaceWithHirId<'tcx>, _: HirId, bk: ty::BorrowKind) {
+        if let ty::BorrowKind::MutBorrow = bk {
+            self.update(&cmt)
+        }
+    }
+
+    fn mutate(&mut self, cmt: &PlaceWithHirId<'tcx>, _: HirId) {
+        self.update(&cmt)
+    }
+}
+
+pub struct ParamBindingIdCollector {
+    binding_hir_ids: Vec<hir::HirId>,
+}
+impl<'tcx> ParamBindingIdCollector {
+    fn collect_binding_hir_ids(body: &'tcx hir::Body<'tcx>) -> Vec<hir::HirId> {
+        let mut hir_ids: Vec<hir::HirId> = Vec::new();
+        for param in body.params.iter() {
+            let mut finder = ParamBindingIdCollector {
+                binding_hir_ids: Vec::new(),
+            };
+            finder.visit_param(param);
+            for hir_id in &finder.binding_hir_ids {
+                hir_ids.push(*hir_id);
+            }
+        }
+        hir_ids
+    }
+}
+impl<'tcx> intravisit::Visitor<'tcx> for ParamBindingIdCollector {
+    type Map = Map<'tcx>;
+
+    fn visit_pat(&mut self, pat: &'tcx hir::Pat<'tcx>) {
+        if let hir::PatKind::Binding(_, hir_id, ..) = pat.kind {
+            self.binding_hir_ids.push(hir_id);
+        }
+        intravisit::walk_pat(self, pat);
+    }
+
+    fn nested_visit_map(&mut self) -> intravisit::NestedVisitorMap<Self::Map> {
+        intravisit::NestedVisitorMap::None
+    }
+}
+
+pub struct BindingUsageFinder<'a, 'tcx> {
+    cx: &'a LateContext<'tcx>,
+    binding_ids: Vec<hir::HirId>,
+    usage_found: bool,
+}
+impl<'a, 'tcx> BindingUsageFinder<'a, 'tcx> {
+    pub fn are_params_used(cx: &'a LateContext<'tcx>, body: &'tcx hir::Body<'tcx>) -> bool {
+        let mut finder = BindingUsageFinder {
+            cx,
+            binding_ids: ParamBindingIdCollector::collect_binding_hir_ids(body),
+            usage_found: false,
+        };
+        finder.visit_body(body);
+        finder.usage_found
+    }
+}
+impl<'a, 'tcx> intravisit::Visitor<'tcx> for BindingUsageFinder<'a, 'tcx> {
+    type Map = Map<'tcx>;
+
+    fn visit_expr(&mut self, expr: &'tcx hir::Expr<'tcx>) {
+        if !self.usage_found {
+            intravisit::walk_expr(self, expr);
+        }
+    }
+
+    fn visit_path(&mut self, path: &'tcx hir::Path<'tcx>, _: hir::HirId) {
+        if let hir::def::Res::Local(id) = path.res {
+            if self.binding_ids.contains(&id) {
+                self.usage_found = true;
+            }
+        }
+    }
+
+    fn nested_visit_map(&mut self) -> intravisit::NestedVisitorMap<Self::Map> {
+        intravisit::NestedVisitorMap::OnlyBodies(self.cx.tcx.hir())
+    }
+}
+
+struct ReturnBreakContinueMacroVisitor {
+    seen_return_break_continue: bool,
+}
+
+impl ReturnBreakContinueMacroVisitor {
+    fn new() -> ReturnBreakContinueMacroVisitor {
+        ReturnBreakContinueMacroVisitor {
+            seen_return_break_continue: false,
+        }
+    }
+}
+
+impl<'tcx> Visitor<'tcx> for ReturnBreakContinueMacroVisitor {
+    type Map = Map<'tcx>;
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::None
+    }
+
+    fn visit_expr(&mut self, ex: &'tcx Expr<'tcx>) {
+        if self.seen_return_break_continue {
+            // No need to look farther if we've already seen one of them
+            return;
+        }
+        match &ex.kind {
+            ExprKind::Ret(..) | ExprKind::Break(..) | ExprKind::Continue(..) => {
+                self.seen_return_break_continue = true;
+            },
+            // Something special could be done here to handle while or for loop
+            // desugaring, as this will detect a break if there's a while loop
+            // or a for loop inside the expression.
+            _ => {
+                if utils::in_macro(ex.span) {
+                    self.seen_return_break_continue = true;
+                } else {
+                    rustc_hir::intravisit::walk_expr(self, ex);
+                }
+            },
+        }
+    }
+}
+
+pub fn contains_return_break_continue_macro(expression: &Expr<'_>) -> bool {
+    let mut recursive_visitor = ReturnBreakContinueMacroVisitor::new();
+    recursive_visitor.visit_expr(expression);
+    recursive_visitor.seen_return_break_continue
+}
diff --git a/clippy_utils/src/visitors.rs b/clippy_utils/src/visitors.rs
new file mode 100644
index 00000000000..085c1f9c0cb
--- /dev/null
+++ b/clippy_utils/src/visitors.rs
@@ -0,0 +1,190 @@
+use crate::utils::path_to_local_id;
+use rustc_hir as hir;
+use rustc_hir::intravisit::{self, walk_expr, NestedVisitorMap, Visitor};
+use rustc_hir::{Arm, Body, Expr, HirId, Stmt};
+use rustc_lint::LateContext;
+use rustc_middle::hir::map::Map;
+
+/// returns `true` if expr contains match expr desugared from try
+fn contains_try(expr: &hir::Expr<'_>) -> bool {
+    struct TryFinder {
+        found: bool,
+    }
+
+    impl<'hir> intravisit::Visitor<'hir> for TryFinder {
+        type Map = Map<'hir>;
+
+        fn nested_visit_map(&mut self) -> intravisit::NestedVisitorMap<Self::Map> {
+            intravisit::NestedVisitorMap::None
+        }
+
+        fn visit_expr(&mut self, expr: &'hir hir::Expr<'hir>) {
+            if self.found {
+                return;
+            }
+            match expr.kind {
+                hir::ExprKind::Match(_, _, hir::MatchSource::TryDesugar) => self.found = true,
+                _ => intravisit::walk_expr(self, expr),
+            }
+        }
+    }
+
+    let mut visitor = TryFinder { found: false };
+    visitor.visit_expr(expr);
+    visitor.found
+}
+
+pub fn find_all_ret_expressions<'hir, F>(_cx: &LateContext<'_>, expr: &'hir hir::Expr<'hir>, callback: F) -> bool
+where
+    F: FnMut(&'hir hir::Expr<'hir>) -> bool,
+{
+    struct RetFinder<F> {
+        in_stmt: bool,
+        failed: bool,
+        cb: F,
+    }
+
+    struct WithStmtGuarg<'a, F> {
+        val: &'a mut RetFinder<F>,
+        prev_in_stmt: bool,
+    }
+
+    impl<F> RetFinder<F> {
+        fn inside_stmt(&mut self, in_stmt: bool) -> WithStmtGuarg<'_, F> {
+            let prev_in_stmt = std::mem::replace(&mut self.in_stmt, in_stmt);
+            WithStmtGuarg {
+                val: self,
+                prev_in_stmt,
+            }
+        }
+    }
+
+    impl<F> std::ops::Deref for WithStmtGuarg<'_, F> {
+        type Target = RetFinder<F>;
+
+        fn deref(&self) -> &Self::Target {
+            self.val
+        }
+    }
+
+    impl<F> std::ops::DerefMut for WithStmtGuarg<'_, F> {
+        fn deref_mut(&mut self) -> &mut Self::Target {
+            self.val
+        }
+    }
+
+    impl<F> Drop for WithStmtGuarg<'_, F> {
+        fn drop(&mut self) {
+            self.val.in_stmt = self.prev_in_stmt;
+        }
+    }
+
+    impl<'hir, F: FnMut(&'hir hir::Expr<'hir>) -> bool> intravisit::Visitor<'hir> for RetFinder<F> {
+        type Map = Map<'hir>;
+
+        fn nested_visit_map(&mut self) -> intravisit::NestedVisitorMap<Self::Map> {
+            intravisit::NestedVisitorMap::None
+        }
+
+        fn visit_stmt(&mut self, stmt: &'hir hir::Stmt<'_>) {
+            intravisit::walk_stmt(&mut *self.inside_stmt(true), stmt)
+        }
+
+        fn visit_expr(&mut self, expr: &'hir hir::Expr<'_>) {
+            if self.failed {
+                return;
+            }
+            if self.in_stmt {
+                match expr.kind {
+                    hir::ExprKind::Ret(Some(expr)) => self.inside_stmt(false).visit_expr(expr),
+                    _ => intravisit::walk_expr(self, expr),
+                }
+            } else {
+                match expr.kind {
+                    hir::ExprKind::If(cond, then, else_opt) => {
+                        self.inside_stmt(true).visit_expr(cond);
+                        self.visit_expr(then);
+                        if let Some(el) = else_opt {
+                            self.visit_expr(el);
+                        }
+                    },
+                    hir::ExprKind::Match(cond, arms, _) => {
+                        self.inside_stmt(true).visit_expr(cond);
+                        for arm in arms {
+                            self.visit_expr(arm.body);
+                        }
+                    },
+                    hir::ExprKind::Block(..) => intravisit::walk_expr(self, expr),
+                    hir::ExprKind::Ret(Some(expr)) => self.visit_expr(expr),
+                    _ => self.failed |= !(self.cb)(expr),
+                }
+            }
+        }
+    }
+
+    !contains_try(expr) && {
+        let mut ret_finder = RetFinder {
+            in_stmt: false,
+            failed: false,
+            cb: callback,
+        };
+        ret_finder.visit_expr(expr);
+        !ret_finder.failed
+    }
+}
+
+pub struct LocalUsedVisitor<'hir> {
+    hir: Map<'hir>,
+    pub local_hir_id: HirId,
+    pub used: bool,
+}
+
+impl<'hir> LocalUsedVisitor<'hir> {
+    pub fn new(cx: &LateContext<'hir>, local_hir_id: HirId) -> Self {
+        Self {
+            hir: cx.tcx.hir(),
+            local_hir_id,
+            used: false,
+        }
+    }
+
+    fn check<T>(&mut self, t: T, visit: fn(&mut Self, T)) -> bool {
+        visit(self, t);
+        std::mem::replace(&mut self.used, false)
+    }
+
+    pub fn check_arm(&mut self, arm: &'hir Arm<'_>) -> bool {
+        self.check(arm, Self::visit_arm)
+    }
+
+    pub fn check_body(&mut self, body: &'hir Body<'_>) -> bool {
+        self.check(body, Self::visit_body)
+    }
+
+    pub fn check_expr(&mut self, expr: &'hir Expr<'_>) -> bool {
+        self.check(expr, Self::visit_expr)
+    }
+
+    pub fn check_stmt(&mut self, stmt: &'hir Stmt<'_>) -> bool {
+        self.check(stmt, Self::visit_stmt)
+    }
+}
+
+impl<'v> Visitor<'v> for LocalUsedVisitor<'v> {
+    type Map = Map<'v>;
+
+    fn visit_expr(&mut self, expr: &'v Expr<'v>) {
+        if self.used {
+            return;
+        }
+        if path_to_local_id(expr, self.local_hir_id) {
+            self.used = true;
+        } else {
+            walk_expr(self, expr);
+        }
+    }
+
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::OnlyBodies(self.hir)
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 8d2de8f256865863b17ece1b5125422101fa8601 Mon Sep 17 00:00:00 2001
From: "Samuel E. Moelius III" <sam@moeli.us>
Date: Thu, 11 Feb 2021 15:03:28 -0500
Subject: Update clippy_lints/src/lib.rs

---
 clippy_lints/src/lib.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 381e6f9369f..691bc86b885 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -57,12 +57,12 @@ macro_rules! declare_clippy_lint {
 
 #[macro_export]
 macro_rules! sym {
-    ( $($x:tt)* ) => { clippy_utils::sym!($($x)*); }
+    ( $($x:tt)* ) => { clippy_utils::sym!($($x)*) }
 }
 
 #[macro_export]
 macro_rules! unwrap_cargo_metadata {
-    ( $($x:tt)* ) => { clippy_utils::unwrap_cargo_metadata!($($x)*); }
+    ( $($x:tt)* ) => { clippy_utils::unwrap_cargo_metadata!($($x)*) }
 }
 
 macro_rules! extract_msrv_attr {
-- 
cgit 1.4.1-3-g733a5


From b7f03c6697a03c419e4976490b8988d50be6e9c5 Mon Sep 17 00:00:00 2001
From: "Samuel E. Moelius III" <sam@moeli.us>
Date: Sat, 13 Feb 2021 18:49:22 -0500
Subject: Remove unused features

---
 clippy_lints/src/lib.rs | 4 ----
 clippy_utils/src/lib.rs | 7 -------
 2 files changed, 11 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 691bc86b885..8a395e3a6e6 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1,13 +1,9 @@
 // error-pattern:cargo-clippy
 
-#![feature(bindings_after_at)]
 #![feature(box_patterns)]
 #![feature(box_syntax)]
-#![feature(concat_idents)]
-#![feature(crate_visibility_modifier)]
 #![feature(drain_filter)]
 #![feature(in_band_lifetimes)]
-#![feature(once_cell)]
 #![feature(or_patterns)]
 #![feature(rustc_private)]
 #![feature(stmt_expr_attributes)]
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index d417e94769b..48d72b4ea44 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -1,15 +1,8 @@
-#![feature(bindings_after_at)]
 #![feature(box_patterns)]
-#![feature(box_syntax)]
-#![feature(concat_idents)]
-#![feature(crate_visibility_modifier)]
-#![feature(drain_filter)]
 #![feature(in_band_lifetimes)]
 #![feature(once_cell)]
 #![feature(or_patterns)]
 #![feature(rustc_private)]
-#![feature(stmt_expr_attributes)]
-#![feature(control_flow_enum)]
 #![recursion_limit = "512"]
 #![allow(clippy::missing_errors_doc, clippy::missing_panics_doc, clippy::must_use_candidate)]
 
-- 
cgit 1.4.1-3-g733a5


From ab7381f085d587f49949e31a02847b5a78b9ea36 Mon Sep 17 00:00:00 2001
From: "Samuel E. Moelius III" <sam@moeli.us>
Date: Thu, 18 Feb 2021 12:25:35 -0500
Subject: Move `declare_clippy_lint` back into clippy_lints

---
 clippy_dev/src/lib.rs                       |   18 +-
 clippy_lints/src/lib.rs                     |   96 ++-
 clippy_lints/src/utils.rs                   |    1 -
 clippy_lints/src/utils/author.rs            |  779 +++++++++++++++++++
 clippy_lints/src/utils/inspector.rs         |  578 +++++++++++++++
 clippy_lints/src/utils/internal_lints.rs    | 1070 +++++++++++++++++++++++++++
 clippy_lints/src/utils/mod.rs               |    6 +
 clippy_utils/src/author.rs                  |  779 -------------------
 clippy_utils/src/inspector.rs               |  578 ---------------
 clippy_utils/src/internal_lints.rs          | 1070 ---------------------------
 clippy_utils/src/lib.rs                     |  103 ---
 tests/ui-internal/custom_ice_message.stderr |    2 +-
 12 files changed, 2534 insertions(+), 2546 deletions(-)
 delete mode 100644 clippy_lints/src/utils.rs
 create mode 100644 clippy_lints/src/utils/author.rs
 create mode 100644 clippy_lints/src/utils/inspector.rs
 create mode 100644 clippy_lints/src/utils/internal_lints.rs
 create mode 100644 clippy_lints/src/utils/mod.rs
 delete mode 100644 clippy_utils/src/author.rs
 delete mode 100644 clippy_utils/src/inspector.rs
 delete mode 100644 clippy_utils/src/internal_lints.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_dev/src/lib.rs b/clippy_dev/src/lib.rs
index 61e423d82f3..01d1fc9211a 100644
--- a/clippy_dev/src/lib.rs
+++ b/clippy_dev/src/lib.rs
@@ -186,17 +186,11 @@ fn gather_from_file(dir_entry: &walkdir::DirEntry) -> impl Iterator<Item = Lint>
     let path_buf = path.with_file_name(filename);
     let mut rel_path = path_buf
         .strip_prefix(clippy_project_root().join("clippy_lints/src"))
-        .map(PathBuf::from)
-        .or_else(|_| {
-            path_buf
-                .strip_prefix(clippy_project_root().join("clippy_utils/src"))
-                .map(|c| Path::new("utils").join(c))
-        })
-        .expect("only files in `clippy_lints/src` or `clippy_utils/src` should be looked at");
+        .expect("only files in `clippy_lints/src` should be looked at");
     // If the lints are stored in mod.rs, we get the module name from
     // the containing directory:
     if filename == "mod" {
-        rel_path = rel_path.parent().unwrap().to_path_buf();
+        rel_path = rel_path.parent().unwrap();
     }
 
     let module = rel_path
@@ -219,15 +213,13 @@ fn parse_contents(content: &str, module: &str) -> impl Iterator<Item = Lint> {
     lints.chain(deprecated).collect::<Vec<Lint>>().into_iter()
 }
 
-/// Collects all .rs files in the `clippy_lints/src` and `clippy_utils/src` directories
+/// Collects all .rs files in the `clippy_lints/src` directory
 fn lint_files() -> impl Iterator<Item = walkdir::DirEntry> {
     // We use `WalkDir` instead of `fs::read_dir` here in order to recurse into subdirectories.
     // Otherwise we would not collect all the lints, for example in `clippy_lints/src/methods/`.
-    let clippy_lints_path = clippy_project_root().join("clippy_lints/src");
-    let clippy_utils_path = clippy_project_root().join("clippy_utils/src");
-    WalkDir::new(clippy_lints_path)
+    let path = clippy_project_root().join("clippy_lints/src");
+    WalkDir::new(path)
         .into_iter()
-        .chain(WalkDir::new(clippy_utils_path).into_iter())
         .filter_map(Result::ok)
         .filter(|f| f.path().extension() == Some(OsStr::new("rs")))
 }
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 8a395e3a6e6..c8502e9cc74 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -46,9 +46,103 @@ use rustc_data_structures::fx::FxHashSet;
 use rustc_lint::LintId;
 use rustc_session::Session;
 
+/// Macro used to declare a Clippy lint.
+///
+/// Every lint declaration consists of 4 parts:
+///
+/// 1. The documentation, which is used for the website
+/// 2. The `LINT_NAME`. See [lint naming][lint_naming] on lint naming conventions.
+/// 3. The `lint_level`, which is a mapping from *one* of our lint groups to `Allow`, `Warn` or
+///    `Deny`. The lint level here has nothing to do with what lint groups the lint is a part of.
+/// 4. The `description` that contains a short explanation on what's wrong with code where the
+///    lint is triggered.
+///
+/// Currently the categories `style`, `correctness`, `complexity` and `perf` are enabled by default.
+/// As said in the README.md of this repository, if the lint level mapping changes, please update
+/// README.md.
+///
+/// # Example
+///
+/// ```
+/// #![feature(rustc_private)]
+/// extern crate rustc_session;
+/// use rustc_session::declare_tool_lint;
+/// use clippy_lints::declare_clippy_lint;
+///
+/// declare_clippy_lint! {
+///     /// **What it does:** Checks for ... (describe what the lint matches).
+///     ///
+///     /// **Why is this bad?** Supply the reason for linting the code.
+///     ///
+///     /// **Known problems:** None. (Or describe where it could go wrong.)
+///     ///
+///     /// **Example:**
+///     ///
+///     /// ```rust
+///     /// // Bad
+///     /// Insert a short example of code that triggers the lint
+///     ///
+///     /// // Good
+///     /// Insert a short example of improved code that doesn't trigger the lint
+///     /// ```
+///     pub LINT_NAME,
+///     pedantic,
+///     "description"
+/// }
+/// ```
+/// [lint_naming]: https://rust-lang.github.io/rfcs/0344-conventions-galore.html#lints
 #[macro_export]
 macro_rules! declare_clippy_lint {
-    ( $($x:tt)* ) => { clippy_utils::declare_clippy_lint!($($x)*); }
+    { $(#[$attr:meta])* pub $name:tt, style, $description:tt } => {
+        declare_tool_lint! {
+            $(#[$attr])* pub clippy::$name, Warn, $description, report_in_external_macro: true
+        }
+    };
+    { $(#[$attr:meta])* pub $name:tt, correctness, $description:tt } => {
+        declare_tool_lint! {
+            $(#[$attr])* pub clippy::$name, Deny, $description, report_in_external_macro: true
+        }
+    };
+    { $(#[$attr:meta])* pub $name:tt, complexity, $description:tt } => {
+        declare_tool_lint! {
+            $(#[$attr])* pub clippy::$name, Warn, $description, report_in_external_macro: true
+        }
+    };
+    { $(#[$attr:meta])* pub $name:tt, perf, $description:tt } => {
+        declare_tool_lint! {
+            $(#[$attr])* pub clippy::$name, Warn, $description, report_in_external_macro: true
+        }
+    };
+    { $(#[$attr:meta])* pub $name:tt, pedantic, $description:tt } => {
+        declare_tool_lint! {
+            $(#[$attr])* pub clippy::$name, Allow, $description, report_in_external_macro: true
+        }
+    };
+    { $(#[$attr:meta])* pub $name:tt, restriction, $description:tt } => {
+        declare_tool_lint! {
+            $(#[$attr])* pub clippy::$name, Allow, $description, report_in_external_macro: true
+        }
+    };
+    { $(#[$attr:meta])* pub $name:tt, cargo, $description:tt } => {
+        declare_tool_lint! {
+            $(#[$attr])* pub clippy::$name, Allow, $description, report_in_external_macro: true
+        }
+    };
+    { $(#[$attr:meta])* pub $name:tt, nursery, $description:tt } => {
+        declare_tool_lint! {
+            $(#[$attr])* pub clippy::$name, Allow, $description, report_in_external_macro: true
+        }
+    };
+    { $(#[$attr:meta])* pub $name:tt, internal, $description:tt } => {
+        declare_tool_lint! {
+            $(#[$attr])* pub clippy::$name, Allow, $description, report_in_external_macro: true
+        }
+    };
+    { $(#[$attr:meta])* pub $name:tt, internal_warn, $description:tt } => {
+        declare_tool_lint! {
+            $(#[$attr])* pub clippy::$name, Warn, $description, report_in_external_macro: true
+        }
+    };
 }
 
 #[macro_export]
diff --git a/clippy_lints/src/utils.rs b/clippy_lints/src/utils.rs
deleted file mode 100644
index bf54e39769c..00000000000
--- a/clippy_lints/src/utils.rs
+++ /dev/null
@@ -1 +0,0 @@
-pub use clippy_utils::*;
diff --git a/clippy_lints/src/utils/author.rs b/clippy_lints/src/utils/author.rs
new file mode 100644
index 00000000000..ca60d335262
--- /dev/null
+++ b/clippy_lints/src/utils/author.rs
@@ -0,0 +1,779 @@
+//! A group of attributes that can be attached to Rust code in order
+//! to generate a clippy lint detecting said code automatically.
+
+use crate::utils::get_attr;
+use rustc_ast::ast::{Attribute, LitFloatType, LitKind};
+use rustc_ast::walk_list;
+use rustc_data_structures::fx::FxHashMap;
+use rustc_hir as hir;
+use rustc_hir::intravisit::{NestedVisitorMap, Visitor};
+use rustc_hir::{BindingAnnotation, Block, Expr, ExprKind, Pat, PatKind, QPath, Stmt, StmtKind, TyKind};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_middle::hir::map::Map;
+use rustc_session::Session;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// **What it does:** Generates clippy code that detects the offending pattern
+    ///
+    /// **Example:**
+    /// ```rust,ignore
+    /// // ./tests/ui/my_lint.rs
+    /// fn foo() {
+    ///     // detect the following pattern
+    ///     #[clippy::author]
+    ///     if x == 42 {
+    ///         // but ignore everything from here on
+    ///         #![clippy::author = "ignore"]
+    ///     }
+    ///     ()
+    /// }
+    /// ```
+    ///
+    /// Running `TESTNAME=ui/my_lint cargo uitest` will produce
+    /// a `./tests/ui/new_lint.stdout` file with the generated code:
+    ///
+    /// ```rust,ignore
+    /// // ./tests/ui/new_lint.stdout
+    /// if_chain! {
+    ///     if let ExprKind::If(ref cond, ref then, None) = item.kind,
+    ///     if let ExprKind::Binary(BinOp::Eq, ref left, ref right) = cond.kind,
+    ///     if let ExprKind::Path(ref path) = left.kind,
+    ///     if let ExprKind::Lit(ref lit) = right.kind,
+    ///     if let LitKind::Int(42, _) = lit.node,
+    ///     then {
+    ///         // report your lint here
+    ///     }
+    /// }
+    /// ```
+    pub LINT_AUTHOR,
+    internal_warn,
+    "helper for writing lints"
+}
+
+declare_lint_pass!(Author => [LINT_AUTHOR]);
+
+fn prelude() {
+    println!("if_chain! {{");
+}
+
+fn done() {
+    println!("    then {{");
+    println!("        // report your lint here");
+    println!("    }}");
+    println!("}}");
+}
+
+impl<'tcx> LateLintPass<'tcx> for Author {
+    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) {
+        if !has_attr(cx.sess(), &item.attrs) {
+            return;
+        }
+        prelude();
+        PrintVisitor::new("item").visit_item(item);
+        done();
+    }
+
+    fn check_impl_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::ImplItem<'_>) {
+        if !has_attr(cx.sess(), &item.attrs) {
+            return;
+        }
+        prelude();
+        PrintVisitor::new("item").visit_impl_item(item);
+        done();
+    }
+
+    fn check_trait_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::TraitItem<'_>) {
+        if !has_attr(cx.sess(), &item.attrs) {
+            return;
+        }
+        prelude();
+        PrintVisitor::new("item").visit_trait_item(item);
+        done();
+    }
+
+    fn check_variant(&mut self, cx: &LateContext<'tcx>, var: &'tcx hir::Variant<'_>) {
+        if !has_attr(cx.sess(), &var.attrs) {
+            return;
+        }
+        prelude();
+        let parent_hir_id = cx.tcx.hir().get_parent_node(var.id);
+        PrintVisitor::new("var").visit_variant(var, &hir::Generics::empty(), parent_hir_id);
+        done();
+    }
+
+    fn check_struct_field(&mut self, cx: &LateContext<'tcx>, field: &'tcx hir::StructField<'_>) {
+        if !has_attr(cx.sess(), &field.attrs) {
+            return;
+        }
+        prelude();
+        PrintVisitor::new("field").visit_struct_field(field);
+        done();
+    }
+
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
+        if !has_attr(cx.sess(), &expr.attrs) {
+            return;
+        }
+        prelude();
+        PrintVisitor::new("expr").visit_expr(expr);
+        done();
+    }
+
+    fn check_arm(&mut self, cx: &LateContext<'tcx>, arm: &'tcx hir::Arm<'_>) {
+        if !has_attr(cx.sess(), &arm.attrs) {
+            return;
+        }
+        prelude();
+        PrintVisitor::new("arm").visit_arm(arm);
+        done();
+    }
+
+    fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx hir::Stmt<'_>) {
+        if !has_attr(cx.sess(), stmt.kind.attrs(|id| cx.tcx.hir().item(id.id))) {
+            return;
+        }
+        prelude();
+        PrintVisitor::new("stmt").visit_stmt(stmt);
+        done();
+    }
+
+    fn check_foreign_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::ForeignItem<'_>) {
+        if !has_attr(cx.sess(), &item.attrs) {
+            return;
+        }
+        prelude();
+        PrintVisitor::new("item").visit_foreign_item(item);
+        done();
+    }
+}
+
+impl PrintVisitor {
+    #[must_use]
+    fn new(s: &'static str) -> Self {
+        Self {
+            ids: FxHashMap::default(),
+            current: s.to_owned(),
+        }
+    }
+
+    fn next(&mut self, s: &'static str) -> String {
+        use std::collections::hash_map::Entry::{Occupied, Vacant};
+        match self.ids.entry(s) {
+            // already there: start numbering from `1`
+            Occupied(mut occ) => {
+                let val = occ.get_mut();
+                *val += 1;
+                format!("{}{}", s, *val)
+            },
+            // not there: insert and return name as given
+            Vacant(vac) => {
+                vac.insert(0);
+                s.to_owned()
+            },
+        }
+    }
+
+    fn print_qpath(&mut self, path: &QPath<'_>) {
+        if let QPath::LangItem(lang_item, _) = *path {
+            println!(
+                "    if matches!({}, QPath::LangItem(LangItem::{:?}, _));",
+                self.current, lang_item,
+            );
+        } else {
+            print!("    if match_qpath({}, &[", self.current);
+            print_path(path, &mut true);
+            println!("]);");
+        }
+    }
+}
+
+struct PrintVisitor {
+    /// Fields are the current index that needs to be appended to pattern
+    /// binding names
+    ids: FxHashMap<&'static str, usize>,
+    /// the name that needs to be destructured
+    current: String,
+}
+
+impl<'tcx> Visitor<'tcx> for PrintVisitor {
+    type Map = Map<'tcx>;
+
+    #[allow(clippy::too_many_lines)]
+    fn visit_expr(&mut self, expr: &Expr<'_>) {
+        print!("    if let ExprKind::");
+        let current = format!("{}.kind", self.current);
+        match expr.kind {
+            ExprKind::Box(ref inner) => {
+                let inner_pat = self.next("inner");
+                println!("Box(ref {}) = {};", inner_pat, current);
+                self.current = inner_pat;
+                self.visit_expr(inner);
+            },
+            ExprKind::Array(ref elements) => {
+                let elements_pat = self.next("elements");
+                println!("Array(ref {}) = {};", elements_pat, current);
+                println!("    if {}.len() == {};", elements_pat, elements.len());
+                for (i, element) in elements.iter().enumerate() {
+                    self.current = format!("{}[{}]", elements_pat, i);
+                    self.visit_expr(element);
+                }
+            },
+            ExprKind::Call(ref func, ref args) => {
+                let func_pat = self.next("func");
+                let args_pat = self.next("args");
+                println!("Call(ref {}, ref {}) = {};", func_pat, args_pat, current);
+                self.current = func_pat;
+                self.visit_expr(func);
+                println!("    if {}.len() == {};", args_pat, args.len());
+                for (i, arg) in args.iter().enumerate() {
+                    self.current = format!("{}[{}]", args_pat, i);
+                    self.visit_expr(arg);
+                }
+            },
+            ExprKind::MethodCall(ref _method_name, ref _generics, ref _args, ref _fn_span) => {
+                println!(
+                    "MethodCall(ref method_name, ref generics, ref args, ref fn_span) = {};",
+                    current
+                );
+                println!("    // unimplemented: `ExprKind::MethodCall` is not further destructured at the moment");
+            },
+            ExprKind::Tup(ref elements) => {
+                let elements_pat = self.next("elements");
+                println!("Tup(ref {}) = {};", elements_pat, current);
+                println!("    if {}.len() == {};", elements_pat, elements.len());
+                for (i, element) in elements.iter().enumerate() {
+                    self.current = format!("{}[{}]", elements_pat, i);
+                    self.visit_expr(element);
+                }
+            },
+            ExprKind::Binary(ref op, ref left, ref right) => {
+                let op_pat = self.next("op");
+                let left_pat = self.next("left");
+                let right_pat = self.next("right");
+                println!(
+                    "Binary(ref {}, ref {}, ref {}) = {};",
+                    op_pat, left_pat, right_pat, current
+                );
+                println!("    if BinOpKind::{:?} == {}.node;", op.node, op_pat);
+                self.current = left_pat;
+                self.visit_expr(left);
+                self.current = right_pat;
+                self.visit_expr(right);
+            },
+            ExprKind::Unary(ref op, ref inner) => {
+                let inner_pat = self.next("inner");
+                println!("Unary(UnOp::{:?}, ref {}) = {};", op, inner_pat, current);
+                self.current = inner_pat;
+                self.visit_expr(inner);
+            },
+            ExprKind::Lit(ref lit) => {
+                let lit_pat = self.next("lit");
+                println!("Lit(ref {}) = {};", lit_pat, current);
+                match lit.node {
+                    LitKind::Bool(val) => println!("    if let LitKind::Bool({:?}) = {}.node;", val, lit_pat),
+                    LitKind::Char(c) => println!("    if let LitKind::Char({:?}) = {}.node;", c, lit_pat),
+                    LitKind::Err(val) => println!("    if let LitKind::Err({}) = {}.node;", val, lit_pat),
+                    LitKind::Byte(b) => println!("    if let LitKind::Byte({}) = {}.node;", b, lit_pat),
+                    // FIXME: also check int type
+                    LitKind::Int(i, _) => println!("    if let LitKind::Int({}, _) = {}.node;", i, lit_pat),
+                    LitKind::Float(_, LitFloatType::Suffixed(_)) => println!(
+                        "    if let LitKind::Float(_, LitFloatType::Suffixed(_)) = {}.node;",
+                        lit_pat
+                    ),
+                    LitKind::Float(_, LitFloatType::Unsuffixed) => println!(
+                        "    if let LitKind::Float(_, LitFloatType::Unsuffixed) = {}.node;",
+                        lit_pat
+                    ),
+                    LitKind::ByteStr(ref vec) => {
+                        let vec_pat = self.next("vec");
+                        println!("    if let LitKind::ByteStr(ref {}) = {}.node;", vec_pat, lit_pat);
+                        println!("    if let [{:?}] = **{};", vec, vec_pat);
+                    },
+                    LitKind::Str(ref text, _) => {
+                        let str_pat = self.next("s");
+                        println!("    if let LitKind::Str(ref {}, _) = {}.node;", str_pat, lit_pat);
+                        println!("    if {}.as_str() == {:?}", str_pat, &*text.as_str())
+                    },
+                }
+            },
+            ExprKind::Cast(ref expr, ref ty) => {
+                let cast_pat = self.next("expr");
+                let cast_ty = self.next("cast_ty");
+                let qp_label = self.next("qp");
+
+                println!("Cast(ref {}, ref {}) = {};", cast_pat, cast_ty, current);
+                if let TyKind::Path(ref qp) = ty.kind {
+                    println!("    if let TyKind::Path(ref {}) = {}.kind;", qp_label, cast_ty);
+                    self.current = qp_label;
+                    self.print_qpath(qp);
+                }
+                self.current = cast_pat;
+                self.visit_expr(expr);
+            },
+            ExprKind::Type(ref expr, ref _ty) => {
+                let cast_pat = self.next("expr");
+                println!("Type(ref {}, _) = {};", cast_pat, current);
+                self.current = cast_pat;
+                self.visit_expr(expr);
+            },
+            ExprKind::Loop(ref body, _, desugaring, _) => {
+                let body_pat = self.next("body");
+                let des = loop_desugaring_name(desugaring);
+                let label_pat = self.next("label");
+                println!("Loop(ref {}, ref {}, {}) = {};", body_pat, label_pat, des, current);
+                self.current = body_pat;
+                self.visit_block(body);
+            },
+            ExprKind::If(ref cond, ref then, ref opt_else) => {
+                let cond_pat = self.next("cond");
+                let then_pat = self.next("then");
+                if let Some(ref else_) = *opt_else {
+                    let else_pat = self.next("else_");
+                    println!(
+                        "If(ref {}, ref {}, Some(ref {})) = {};",
+                        cond_pat, then_pat, else_pat, current
+                    );
+                    self.current = else_pat;
+                    self.visit_expr(else_);
+                } else {
+                    println!("If(ref {}, ref {}, None) = {};", cond_pat, then_pat, current);
+                }
+                self.current = cond_pat;
+                self.visit_expr(cond);
+                self.current = then_pat;
+                self.visit_expr(then);
+            },
+            ExprKind::Match(ref expr, ref arms, desugaring) => {
+                let des = desugaring_name(desugaring);
+                let expr_pat = self.next("expr");
+                let arms_pat = self.next("arms");
+                println!("Match(ref {}, ref {}, {}) = {};", expr_pat, arms_pat, des, current);
+                self.current = expr_pat;
+                self.visit_expr(expr);
+                println!("    if {}.len() == {};", arms_pat, arms.len());
+                for (i, arm) in arms.iter().enumerate() {
+                    self.current = format!("{}[{}].body", arms_pat, i);
+                    self.visit_expr(&arm.body);
+                    if let Some(ref guard) = arm.guard {
+                        let guard_pat = self.next("guard");
+                        println!("    if let Some(ref {}) = {}[{}].guard;", guard_pat, arms_pat, i);
+                        match guard {
+                            hir::Guard::If(ref if_expr) => {
+                                let if_expr_pat = self.next("expr");
+                                println!("    if let Guard::If(ref {}) = {};", if_expr_pat, guard_pat);
+                                self.current = if_expr_pat;
+                                self.visit_expr(if_expr);
+                            },
+                            hir::Guard::IfLet(ref if_let_pat, ref if_let_expr) => {
+                                let if_let_pat_pat = self.next("pat");
+                                let if_let_expr_pat = self.next("expr");
+                                println!(
+                                    "    if let Guard::IfLet(ref {}, ref {}) = {};",
+                                    if_let_pat_pat, if_let_expr_pat, guard_pat
+                                );
+                                self.current = if_let_expr_pat;
+                                self.visit_expr(if_let_expr);
+                                self.current = if_let_pat_pat;
+                                self.visit_pat(if_let_pat);
+                            },
+                        }
+                    }
+                    self.current = format!("{}[{}].pat", arms_pat, i);
+                    self.visit_pat(&arm.pat);
+                }
+            },
+            ExprKind::Closure(ref _capture_clause, ref _func, _, _, _) => {
+                println!("Closure(ref capture_clause, ref func, _, _, _) = {};", current);
+                println!("    // unimplemented: `ExprKind::Closure` is not further destructured at the moment");
+            },
+            ExprKind::Yield(ref sub, _) => {
+                let sub_pat = self.next("sub");
+                println!("Yield(ref sub) = {};", current);
+                self.current = sub_pat;
+                self.visit_expr(sub);
+            },
+            ExprKind::Block(ref block, _) => {
+                let block_pat = self.next("block");
+                println!("Block(ref {}) = {};", block_pat, current);
+                self.current = block_pat;
+                self.visit_block(block);
+            },
+            ExprKind::Assign(ref target, ref value, _) => {
+                let target_pat = self.next("target");
+                let value_pat = self.next("value");
+                println!(
+                    "Assign(ref {}, ref {}, ref _span) = {};",
+                    target_pat, value_pat, current
+                );
+                self.current = target_pat;
+                self.visit_expr(target);
+                self.current = value_pat;
+                self.visit_expr(value);
+            },
+            ExprKind::AssignOp(ref op, ref target, ref value) => {
+                let op_pat = self.next("op");
+                let target_pat = self.next("target");
+                let value_pat = self.next("value");
+                println!(
+                    "AssignOp(ref {}, ref {}, ref {}) = {};",
+                    op_pat, target_pat, value_pat, current
+                );
+                println!("    if BinOpKind::{:?} == {}.node;", op.node, op_pat);
+                self.current = target_pat;
+                self.visit_expr(target);
+                self.current = value_pat;
+                self.visit_expr(value);
+            },
+            ExprKind::Field(ref object, ref field_ident) => {
+                let obj_pat = self.next("object");
+                let field_name_pat = self.next("field_name");
+                println!("Field(ref {}, ref {}) = {};", obj_pat, field_name_pat, current);
+                println!("    if {}.as_str() == {:?}", field_name_pat, field_ident.as_str());
+                self.current = obj_pat;
+                self.visit_expr(object);
+            },
+            ExprKind::Index(ref object, ref index) => {
+                let object_pat = self.next("object");
+                let index_pat = self.next("index");
+                println!("Index(ref {}, ref {}) = {};", object_pat, index_pat, current);
+                self.current = object_pat;
+                self.visit_expr(object);
+                self.current = index_pat;
+                self.visit_expr(index);
+            },
+            ExprKind::Path(ref path) => {
+                let path_pat = self.next("path");
+                println!("Path(ref {}) = {};", path_pat, current);
+                self.current = path_pat;
+                self.print_qpath(path);
+            },
+            ExprKind::AddrOf(kind, mutability, ref inner) => {
+                let inner_pat = self.next("inner");
+                println!(
+                    "AddrOf(BorrowKind::{:?}, Mutability::{:?}, ref {}) = {};",
+                    kind, mutability, inner_pat, current
+                );
+                self.current = inner_pat;
+                self.visit_expr(inner);
+            },
+            ExprKind::Break(ref _destination, ref opt_value) => {
+                let destination_pat = self.next("destination");
+                if let Some(ref value) = *opt_value {
+                    let value_pat = self.next("value");
+                    println!("Break(ref {}, Some(ref {})) = {};", destination_pat, value_pat, current);
+                    self.current = value_pat;
+                    self.visit_expr(value);
+                } else {
+                    println!("Break(ref {}, None) = {};", destination_pat, current);
+                }
+                // FIXME: implement label printing
+            },
+            ExprKind::Continue(ref _destination) => {
+                let destination_pat = self.next("destination");
+                println!("Again(ref {}) = {};", destination_pat, current);
+                // FIXME: implement label printing
+            },
+            ExprKind::Ret(ref opt_value) => {
+                if let Some(ref value) = *opt_value {
+                    let value_pat = self.next("value");
+                    println!("Ret(Some(ref {})) = {};", value_pat, current);
+                    self.current = value_pat;
+                    self.visit_expr(value);
+                } else {
+                    println!("Ret(None) = {};", current);
+                }
+            },
+            ExprKind::InlineAsm(_) => {
+                println!("InlineAsm(_) = {};", current);
+                println!("    // unimplemented: `ExprKind::InlineAsm` is not further destructured at the moment");
+            },
+            ExprKind::LlvmInlineAsm(_) => {
+                println!("LlvmInlineAsm(_) = {};", current);
+                println!("    // unimplemented: `ExprKind::LlvmInlineAsm` is not further destructured at the moment");
+            },
+            ExprKind::Struct(ref path, ref fields, ref opt_base) => {
+                let path_pat = self.next("path");
+                let fields_pat = self.next("fields");
+                if let Some(ref base) = *opt_base {
+                    let base_pat = self.next("base");
+                    println!(
+                        "Struct(ref {}, ref {}, Some(ref {})) = {};",
+                        path_pat, fields_pat, base_pat, current
+                    );
+                    self.current = base_pat;
+                    self.visit_expr(base);
+                } else {
+                    println!("Struct(ref {}, ref {}, None) = {};", path_pat, fields_pat, current);
+                }
+                self.current = path_pat;
+                self.print_qpath(path);
+                println!("    if {}.len() == {};", fields_pat, fields.len());
+                println!("    // unimplemented: field checks");
+            },
+            ExprKind::ConstBlock(_) => {
+                let value_pat = self.next("value");
+                println!("Const({})", value_pat);
+                self.current = value_pat;
+            },
+            // FIXME: compute length (needs type info)
+            ExprKind::Repeat(ref value, _) => {
+                let value_pat = self.next("value");
+                println!("Repeat(ref {}, _) = {};", value_pat, current);
+                println!("// unimplemented: repeat count check");
+                self.current = value_pat;
+                self.visit_expr(value);
+            },
+            ExprKind::Err => {
+                println!("Err = {}", current);
+            },
+            ExprKind::DropTemps(ref expr) => {
+                let expr_pat = self.next("expr");
+                println!("DropTemps(ref {}) = {};", expr_pat, current);
+                self.current = expr_pat;
+                self.visit_expr(expr);
+            },
+        }
+    }
+
+    fn visit_block(&mut self, block: &Block<'_>) {
+        let trailing_pat = self.next("trailing_expr");
+        println!("    if let Some({}) = &{}.expr;", trailing_pat, self.current);
+        println!("    if {}.stmts.len() == {};", self.current, block.stmts.len());
+        let current = self.current.clone();
+        for (i, stmt) in block.stmts.iter().enumerate() {
+            self.current = format!("{}.stmts[{}]", current, i);
+            self.visit_stmt(stmt);
+        }
+    }
+
+    #[allow(clippy::too_many_lines)]
+    fn visit_pat(&mut self, pat: &Pat<'_>) {
+        print!("    if let PatKind::");
+        let current = format!("{}.kind", self.current);
+        match pat.kind {
+            PatKind::Wild => println!("Wild = {};", current),
+            PatKind::Binding(anno, .., ident, ref sub) => {
+                let anno_pat = match anno {
+                    BindingAnnotation::Unannotated => "BindingAnnotation::Unannotated",
+                    BindingAnnotation::Mutable => "BindingAnnotation::Mutable",
+                    BindingAnnotation::Ref => "BindingAnnotation::Ref",
+                    BindingAnnotation::RefMut => "BindingAnnotation::RefMut",
+                };
+                let name_pat = self.next("name");
+                if let Some(ref sub) = *sub {
+                    let sub_pat = self.next("sub");
+                    println!(
+                        "Binding({}, _, {}, Some(ref {})) = {};",
+                        anno_pat, name_pat, sub_pat, current
+                    );
+                    self.current = sub_pat;
+                    self.visit_pat(sub);
+                } else {
+                    println!("Binding({}, _, {}, None) = {};", anno_pat, name_pat, current);
+                }
+                println!("    if {}.as_str() == \"{}\";", name_pat, ident.as_str());
+            },
+            PatKind::Struct(ref path, ref fields, ignore) => {
+                let path_pat = self.next("path");
+                let fields_pat = self.next("fields");
+                println!(
+                    "Struct(ref {}, ref {}, {}) = {};",
+                    path_pat, fields_pat, ignore, current
+                );
+                self.current = path_pat;
+                self.print_qpath(path);
+                println!("    if {}.len() == {};", fields_pat, fields.len());
+                println!("    // unimplemented: field checks");
+            },
+            PatKind::Or(ref fields) => {
+                let fields_pat = self.next("fields");
+                println!("Or(ref {}) = {};", fields_pat, current);
+                println!("    if {}.len() == {};", fields_pat, fields.len());
+                println!("    // unimplemented: field checks");
+            },
+            PatKind::TupleStruct(ref path, ref fields, skip_pos) => {
+                let path_pat = self.next("path");
+                let fields_pat = self.next("fields");
+                println!(
+                    "TupleStruct(ref {}, ref {}, {:?}) = {};",
+                    path_pat, fields_pat, skip_pos, current
+                );
+                self.current = path_pat;
+                self.print_qpath(path);
+                println!("    if {}.len() == {};", fields_pat, fields.len());
+                println!("    // unimplemented: field checks");
+            },
+            PatKind::Path(ref path) => {
+                let path_pat = self.next("path");
+                println!("Path(ref {}) = {};", path_pat, current);
+                self.current = path_pat;
+                self.print_qpath(path);
+            },
+            PatKind::Tuple(ref fields, skip_pos) => {
+                let fields_pat = self.next("fields");
+                println!("Tuple(ref {}, {:?}) = {};", fields_pat, skip_pos, current);
+                println!("    if {}.len() == {};", fields_pat, fields.len());
+                println!("    // unimplemented: field checks");
+            },
+            PatKind::Box(ref pat) => {
+                let pat_pat = self.next("pat");
+                println!("Box(ref {}) = {};", pat_pat, current);
+                self.current = pat_pat;
+                self.visit_pat(pat);
+            },
+            PatKind::Ref(ref pat, muta) => {
+                let pat_pat = self.next("pat");
+                println!("Ref(ref {}, Mutability::{:?}) = {};", pat_pat, muta, current);
+                self.current = pat_pat;
+                self.visit_pat(pat);
+            },
+            PatKind::Lit(ref lit_expr) => {
+                let lit_expr_pat = self.next("lit_expr");
+                println!("Lit(ref {}) = {}", lit_expr_pat, current);
+                self.current = lit_expr_pat;
+                self.visit_expr(lit_expr);
+            },
+            PatKind::Range(ref start, ref end, end_kind) => {
+                let start_pat = self.next("start");
+                let end_pat = self.next("end");
+                println!(
+                    "Range(ref {}, ref {}, RangeEnd::{:?}) = {};",
+                    start_pat, end_pat, end_kind, current
+                );
+                self.current = start_pat;
+                walk_list!(self, visit_expr, start);
+                self.current = end_pat;
+                walk_list!(self, visit_expr, end);
+            },
+            PatKind::Slice(ref start, ref middle, ref end) => {
+                let start_pat = self.next("start");
+                let end_pat = self.next("end");
+                if let Some(ref middle) = middle {
+                    let middle_pat = self.next("middle");
+                    println!(
+                        "Slice(ref {}, Some(ref {}), ref {}) = {};",
+                        start_pat, middle_pat, end_pat, current
+                    );
+                    self.current = middle_pat;
+                    self.visit_pat(middle);
+                } else {
+                    println!("Slice(ref {}, None, ref {}) = {};", start_pat, end_pat, current);
+                }
+                println!("    if {}.len() == {};", start_pat, start.len());
+                for (i, pat) in start.iter().enumerate() {
+                    self.current = format!("{}[{}]", start_pat, i);
+                    self.visit_pat(pat);
+                }
+                println!("    if {}.len() == {};", end_pat, end.len());
+                for (i, pat) in end.iter().enumerate() {
+                    self.current = format!("{}[{}]", end_pat, i);
+                    self.visit_pat(pat);
+                }
+            },
+        }
+    }
+
+    fn visit_stmt(&mut self, s: &Stmt<'_>) {
+        print!("    if let StmtKind::");
+        let current = format!("{}.kind", self.current);
+        match s.kind {
+            // A local (let) binding:
+            StmtKind::Local(ref local) => {
+                let local_pat = self.next("local");
+                println!("Local(ref {}) = {};", local_pat, current);
+                if let Some(ref init) = local.init {
+                    let init_pat = self.next("init");
+                    println!("    if let Some(ref {}) = {}.init;", init_pat, local_pat);
+                    self.current = init_pat;
+                    self.visit_expr(init);
+                }
+                self.current = format!("{}.pat", local_pat);
+                self.visit_pat(&local.pat);
+            },
+            // An item binding:
+            StmtKind::Item(_) => {
+                println!("Item(item_id) = {};", current);
+            },
+
+            // Expr without trailing semi-colon (must have unit type):
+            StmtKind::Expr(ref e) => {
+                let e_pat = self.next("e");
+                println!("Expr(ref {}, _) = {}", e_pat, current);
+                self.current = e_pat;
+                self.visit_expr(e);
+            },
+
+            // Expr with trailing semi-colon (may have any type):
+            StmtKind::Semi(ref e) => {
+                let e_pat = self.next("e");
+                println!("Semi(ref {}, _) = {}", e_pat, current);
+                self.current = e_pat;
+                self.visit_expr(e);
+            },
+        }
+    }
+
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::None
+    }
+}
+
+fn has_attr(sess: &Session, attrs: &[Attribute]) -> bool {
+    get_attr(sess, attrs, "author").count() > 0
+}
+
+#[must_use]
+fn desugaring_name(des: hir::MatchSource) -> String {
+    match des {
+        hir::MatchSource::ForLoopDesugar => "MatchSource::ForLoopDesugar".to_string(),
+        hir::MatchSource::TryDesugar => "MatchSource::TryDesugar".to_string(),
+        hir::MatchSource::WhileDesugar => "MatchSource::WhileDesugar".to_string(),
+        hir::MatchSource::WhileLetDesugar => "MatchSource::WhileLetDesugar".to_string(),
+        hir::MatchSource::Normal => "MatchSource::Normal".to_string(),
+        hir::MatchSource::IfLetDesugar { contains_else_clause } => format!(
+            "MatchSource::IfLetDesugar {{ contains_else_clause: {} }}",
+            contains_else_clause
+        ),
+        hir::MatchSource::IfLetGuardDesugar => "MatchSource::IfLetGuardDesugar".to_string(),
+        hir::MatchSource::AwaitDesugar => "MatchSource::AwaitDesugar".to_string(),
+    }
+}
+
+#[must_use]
+fn loop_desugaring_name(des: hir::LoopSource) -> &'static str {
+    match des {
+        hir::LoopSource::ForLoop => "LoopSource::ForLoop",
+        hir::LoopSource::Loop => "LoopSource::Loop",
+        hir::LoopSource::While => "LoopSource::While",
+        hir::LoopSource::WhileLet => "LoopSource::WhileLet",
+    }
+}
+
+fn print_path(path: &QPath<'_>, first: &mut bool) {
+    match *path {
+        QPath::Resolved(_, ref path) => {
+            for segment in path.segments {
+                if *first {
+                    *first = false;
+                } else {
+                    print!(", ");
+                }
+                print!("{:?}", segment.ident.as_str());
+            }
+        },
+        QPath::TypeRelative(ref ty, ref segment) => match ty.kind {
+            hir::TyKind::Path(ref inner_path) => {
+                print_path(inner_path, first);
+                if *first {
+                    *first = false;
+                } else {
+                    print!(", ");
+                }
+                print!("{:?}", segment.ident.as_str());
+            },
+            ref other => print!("/* unimplemented: {:?}*/", other),
+        },
+        QPath::LangItem(..) => panic!("print_path: called for lang item qpath"),
+    }
+}
diff --git a/clippy_lints/src/utils/inspector.rs b/clippy_lints/src/utils/inspector.rs
new file mode 100644
index 00000000000..9bec24be9e4
--- /dev/null
+++ b/clippy_lints/src/utils/inspector.rs
@@ -0,0 +1,578 @@
+//! checks for attributes
+
+use crate::utils::get_attr;
+use rustc_ast::ast::{Attribute, InlineAsmTemplatePiece};
+use rustc_hir as hir;
+use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_session::Session;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// **What it does:** Dumps every ast/hir node which has the `#[clippy::dump]`
+    /// attribute
+    ///
+    /// **Example:**
+    /// ```rust,ignore
+    /// #[clippy::dump]
+    /// extern crate foo;
+    /// ```
+    ///
+    /// prints
+    ///
+    /// ```text
+    /// item `foo`
+    /// visibility inherited from outer item
+    /// extern crate dylib source: "/path/to/foo.so"
+    /// ```
+    pub DEEP_CODE_INSPECTION,
+    internal_warn,
+    "helper to dump info about code"
+}
+
+declare_lint_pass!(DeepCodeInspector => [DEEP_CODE_INSPECTION]);
+
+impl<'tcx> LateLintPass<'tcx> for DeepCodeInspector {
+    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) {
+        if !has_attr(cx.sess(), &item.attrs) {
+            return;
+        }
+        print_item(cx, item);
+    }
+
+    fn check_impl_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::ImplItem<'_>) {
+        if !has_attr(cx.sess(), &item.attrs) {
+            return;
+        }
+        println!("impl item `{}`", item.ident.name);
+        match item.vis.node {
+            hir::VisibilityKind::Public => println!("public"),
+            hir::VisibilityKind::Crate(_) => println!("visible crate wide"),
+            hir::VisibilityKind::Restricted { ref path, .. } => println!(
+                "visible in module `{}`",
+                rustc_hir_pretty::to_string(rustc_hir_pretty::NO_ANN, |s| s.print_path(path, false))
+            ),
+            hir::VisibilityKind::Inherited => println!("visibility inherited from outer item"),
+        }
+        if item.defaultness.is_default() {
+            println!("default");
+        }
+        match item.kind {
+            hir::ImplItemKind::Const(_, body_id) => {
+                println!("associated constant");
+                print_expr(cx, &cx.tcx.hir().body(body_id).value, 1);
+            },
+            hir::ImplItemKind::Fn(..) => println!("method"),
+            hir::ImplItemKind::TyAlias(_) => println!("associated type"),
+        }
+    }
+    // fn check_trait_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx
+    // hir::TraitItem) {
+    // if !has_attr(&item.attrs) {
+    // return;
+    // }
+    // }
+    //
+    // fn check_variant(&mut self, cx: &LateContext<'tcx>, var: &'tcx
+    // hir::Variant, _:
+    // &hir::Generics) {
+    // if !has_attr(&var.node.attrs) {
+    // return;
+    // }
+    // }
+    //
+    // fn check_struct_field(&mut self, cx: &LateContext<'tcx>, field: &'tcx
+    // hir::StructField) {
+    // if !has_attr(&field.attrs) {
+    // return;
+    // }
+    // }
+    //
+
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
+        if !has_attr(cx.sess(), &expr.attrs) {
+            return;
+        }
+        print_expr(cx, expr, 0);
+    }
+
+    fn check_arm(&mut self, cx: &LateContext<'tcx>, arm: &'tcx hir::Arm<'_>) {
+        if !has_attr(cx.sess(), &arm.attrs) {
+            return;
+        }
+        print_pat(cx, &arm.pat, 1);
+        if let Some(ref guard) = arm.guard {
+            println!("guard:");
+            print_guard(cx, guard, 1);
+        }
+        println!("body:");
+        print_expr(cx, &arm.body, 1);
+    }
+
+    fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx hir::Stmt<'_>) {
+        if !has_attr(cx.sess(), stmt.kind.attrs(|id| cx.tcx.hir().item(id.id))) {
+            return;
+        }
+        match stmt.kind {
+            hir::StmtKind::Local(ref local) => {
+                println!("local variable of type {}", cx.typeck_results().node_type(local.hir_id));
+                println!("pattern:");
+                print_pat(cx, &local.pat, 0);
+                if let Some(ref e) = local.init {
+                    println!("init expression:");
+                    print_expr(cx, e, 0);
+                }
+            },
+            hir::StmtKind::Item(_) => println!("item decl"),
+            hir::StmtKind::Expr(ref e) | hir::StmtKind::Semi(ref e) => print_expr(cx, e, 0),
+        }
+    }
+    // fn check_foreign_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx
+    // hir::ForeignItem) {
+    // if !has_attr(&item.attrs) {
+    // return;
+    // }
+    // }
+    //
+}
+
+fn has_attr(sess: &Session, attrs: &[Attribute]) -> bool {
+    get_attr(sess, attrs, "dump").count() > 0
+}
+
+#[allow(clippy::similar_names)]
+#[allow(clippy::too_many_lines)]
+fn print_expr(cx: &LateContext<'_>, expr: &hir::Expr<'_>, indent: usize) {
+    let ind = "  ".repeat(indent);
+    println!("{}+", ind);
+    println!("{}ty: {}", ind, cx.typeck_results().expr_ty(expr));
+    println!(
+        "{}adjustments: {:?}",
+        ind,
+        cx.typeck_results().adjustments().get(expr.hir_id)
+    );
+    match expr.kind {
+        hir::ExprKind::Box(ref e) => {
+            println!("{}Box", ind);
+            print_expr(cx, e, indent + 1);
+        },
+        hir::ExprKind::Array(v) => {
+            println!("{}Array", ind);
+            for e in v {
+                print_expr(cx, e, indent + 1);
+            }
+        },
+        hir::ExprKind::Call(ref func, args) => {
+            println!("{}Call", ind);
+            println!("{}function:", ind);
+            print_expr(cx, func, indent + 1);
+            println!("{}arguments:", ind);
+            for arg in args {
+                print_expr(cx, arg, indent + 1);
+            }
+        },
+        hir::ExprKind::MethodCall(ref path, _, args, _) => {
+            println!("{}MethodCall", ind);
+            println!("{}method name: {}", ind, path.ident.name);
+            for arg in args {
+                print_expr(cx, arg, indent + 1);
+            }
+        },
+        hir::ExprKind::Tup(v) => {
+            println!("{}Tup", ind);
+            for e in v {
+                print_expr(cx, e, indent + 1);
+            }
+        },
+        hir::ExprKind::Binary(op, ref lhs, ref rhs) => {
+            println!("{}Binary", ind);
+            println!("{}op: {:?}", ind, op.node);
+            println!("{}lhs:", ind);
+            print_expr(cx, lhs, indent + 1);
+            println!("{}rhs:", ind);
+            print_expr(cx, rhs, indent + 1);
+        },
+        hir::ExprKind::Unary(op, ref inner) => {
+            println!("{}Unary", ind);
+            println!("{}op: {:?}", ind, op);
+            print_expr(cx, inner, indent + 1);
+        },
+        hir::ExprKind::Lit(ref lit) => {
+            println!("{}Lit", ind);
+            println!("{}{:?}", ind, lit);
+        },
+        hir::ExprKind::Cast(ref e, ref target) => {
+            println!("{}Cast", ind);
+            print_expr(cx, e, indent + 1);
+            println!("{}target type: {:?}", ind, target);
+        },
+        hir::ExprKind::Type(ref e, ref target) => {
+            println!("{}Type", ind);
+            print_expr(cx, e, indent + 1);
+            println!("{}target type: {:?}", ind, target);
+        },
+        hir::ExprKind::Loop(..) => {
+            println!("{}Loop", ind);
+        },
+        hir::ExprKind::If(ref cond, _, ref else_opt) => {
+            println!("{}If", ind);
+            println!("{}condition:", ind);
+            print_expr(cx, cond, indent + 1);
+            if let Some(ref els) = *else_opt {
+                println!("{}else:", ind);
+                print_expr(cx, els, indent + 1);
+            }
+        },
+        hir::ExprKind::Match(ref cond, _, ref source) => {
+            println!("{}Match", ind);
+            println!("{}condition:", ind);
+            print_expr(cx, cond, indent + 1);
+            println!("{}source: {:?}", ind, source);
+        },
+        hir::ExprKind::Closure(ref clause, _, _, _, _) => {
+            println!("{}Closure", ind);
+            println!("{}clause: {:?}", ind, clause);
+        },
+        hir::ExprKind::Yield(ref sub, _) => {
+            println!("{}Yield", ind);
+            print_expr(cx, sub, indent + 1);
+        },
+        hir::ExprKind::Block(_, _) => {
+            println!("{}Block", ind);
+        },
+        hir::ExprKind::Assign(ref lhs, ref rhs, _) => {
+            println!("{}Assign", ind);
+            println!("{}lhs:", ind);
+            print_expr(cx, lhs, indent + 1);
+            println!("{}rhs:", ind);
+            print_expr(cx, rhs, indent + 1);
+        },
+        hir::ExprKind::AssignOp(ref binop, ref lhs, ref rhs) => {
+            println!("{}AssignOp", ind);
+            println!("{}op: {:?}", ind, binop.node);
+            println!("{}lhs:", ind);
+            print_expr(cx, lhs, indent + 1);
+            println!("{}rhs:", ind);
+            print_expr(cx, rhs, indent + 1);
+        },
+        hir::ExprKind::Field(ref e, ident) => {
+            println!("{}Field", ind);
+            println!("{}field name: {}", ind, ident.name);
+            println!("{}struct expr:", ind);
+            print_expr(cx, e, indent + 1);
+        },
+        hir::ExprKind::Index(ref arr, ref idx) => {
+            println!("{}Index", ind);
+            println!("{}array expr:", ind);
+            print_expr(cx, arr, indent + 1);
+            println!("{}index expr:", ind);
+            print_expr(cx, idx, indent + 1);
+        },
+        hir::ExprKind::Path(hir::QPath::Resolved(ref ty, ref path)) => {
+            println!("{}Resolved Path, {:?}", ind, ty);
+            println!("{}path: {:?}", ind, path);
+        },
+        hir::ExprKind::Path(hir::QPath::TypeRelative(ref ty, ref seg)) => {
+            println!("{}Relative Path, {:?}", ind, ty);
+            println!("{}seg: {:?}", ind, seg);
+        },
+        hir::ExprKind::Path(hir::QPath::LangItem(lang_item, ..)) => {
+            println!("{}Lang Item Path, {:?}", ind, lang_item.name());
+        },
+        hir::ExprKind::AddrOf(kind, ref muta, ref e) => {
+            println!("{}AddrOf", ind);
+            println!("kind: {:?}", kind);
+            println!("mutability: {:?}", muta);
+            print_expr(cx, e, indent + 1);
+        },
+        hir::ExprKind::Break(_, ref e) => {
+            println!("{}Break", ind);
+            if let Some(ref e) = *e {
+                print_expr(cx, e, indent + 1);
+            }
+        },
+        hir::ExprKind::Continue(_) => println!("{}Again", ind),
+        hir::ExprKind::Ret(ref e) => {
+            println!("{}Ret", ind);
+            if let Some(ref e) = *e {
+                print_expr(cx, e, indent + 1);
+            }
+        },
+        hir::ExprKind::InlineAsm(ref asm) => {
+            println!("{}InlineAsm", ind);
+            println!("{}template: {}", ind, InlineAsmTemplatePiece::to_string(asm.template));
+            println!("{}options: {:?}", ind, asm.options);
+            println!("{}operands:", ind);
+            for (op, _op_sp) in asm.operands {
+                match op {
+                    hir::InlineAsmOperand::In { expr, .. }
+                    | hir::InlineAsmOperand::InOut { expr, .. }
+                    | hir::InlineAsmOperand::Const { expr }
+                    | hir::InlineAsmOperand::Sym { expr } => print_expr(cx, expr, indent + 1),
+                    hir::InlineAsmOperand::Out { expr, .. } => {
+                        if let Some(expr) = expr {
+                            print_expr(cx, expr, indent + 1);
+                        }
+                    },
+                    hir::InlineAsmOperand::SplitInOut { in_expr, out_expr, .. } => {
+                        print_expr(cx, in_expr, indent + 1);
+                        if let Some(out_expr) = out_expr {
+                            print_expr(cx, out_expr, indent + 1);
+                        }
+                    },
+                }
+            }
+        },
+        hir::ExprKind::LlvmInlineAsm(ref asm) => {
+            let inputs = &asm.inputs_exprs;
+            let outputs = &asm.outputs_exprs;
+            println!("{}LlvmInlineAsm", ind);
+            println!("{}inputs:", ind);
+            for e in inputs.iter() {
+                print_expr(cx, e, indent + 1);
+            }
+            println!("{}outputs:", ind);
+            for e in outputs.iter() {
+                print_expr(cx, e, indent + 1);
+            }
+        },
+        hir::ExprKind::Struct(ref path, fields, ref base) => {
+            println!("{}Struct", ind);
+            println!("{}path: {:?}", ind, path);
+            for field in fields {
+                println!("{}field \"{}\":", ind, field.ident.name);
+                print_expr(cx, &field.expr, indent + 1);
+            }
+            if let Some(ref base) = *base {
+                println!("{}base:", ind);
+                print_expr(cx, base, indent + 1);
+            }
+        },
+        hir::ExprKind::ConstBlock(ref anon_const) => {
+            println!("{}ConstBlock", ind);
+            println!("{}anon_const:", ind);
+            print_expr(cx, &cx.tcx.hir().body(anon_const.body).value, indent + 1);
+        },
+        hir::ExprKind::Repeat(ref val, ref anon_const) => {
+            println!("{}Repeat", ind);
+            println!("{}value:", ind);
+            print_expr(cx, val, indent + 1);
+            println!("{}repeat count:", ind);
+            print_expr(cx, &cx.tcx.hir().body(anon_const.body).value, indent + 1);
+        },
+        hir::ExprKind::Err => {
+            println!("{}Err", ind);
+        },
+        hir::ExprKind::DropTemps(ref e) => {
+            println!("{}DropTemps", ind);
+            print_expr(cx, e, indent + 1);
+        },
+    }
+}
+
+fn print_item(cx: &LateContext<'_>, item: &hir::Item<'_>) {
+    let did = cx.tcx.hir().local_def_id(item.hir_id);
+    println!("item `{}`", item.ident.name);
+    match item.vis.node {
+        hir::VisibilityKind::Public => println!("public"),
+        hir::VisibilityKind::Crate(_) => println!("visible crate wide"),
+        hir::VisibilityKind::Restricted { ref path, .. } => println!(
+            "visible in module `{}`",
+            rustc_hir_pretty::to_string(rustc_hir_pretty::NO_ANN, |s| s.print_path(path, false))
+        ),
+        hir::VisibilityKind::Inherited => println!("visibility inherited from outer item"),
+    }
+    match item.kind {
+        hir::ItemKind::ExternCrate(ref _renamed_from) => {
+            let def_id = cx.tcx.hir().local_def_id(item.hir_id);
+            if let Some(crate_id) = cx.tcx.extern_mod_stmt_cnum(def_id) {
+                let source = cx.tcx.used_crate_source(crate_id);
+                if let Some(ref src) = source.dylib {
+                    println!("extern crate dylib source: {:?}", src.0);
+                }
+                if let Some(ref src) = source.rlib {
+                    println!("extern crate rlib source: {:?}", src.0);
+                }
+            } else {
+                println!("weird extern crate without a crate id");
+            }
+        },
+        hir::ItemKind::Use(ref path, ref kind) => println!("{:?}, {:?}", path, kind),
+        hir::ItemKind::Static(..) => println!("static item of type {:#?}", cx.tcx.type_of(did)),
+        hir::ItemKind::Const(..) => println!("const item of type {:#?}", cx.tcx.type_of(did)),
+        hir::ItemKind::Fn(..) => {
+            let item_ty = cx.tcx.type_of(did);
+            println!("function of type {:#?}", item_ty);
+        },
+        hir::ItemKind::Mod(..) => println!("module"),
+        hir::ItemKind::ForeignMod { abi, .. } => println!("foreign module with abi: {}", abi),
+        hir::ItemKind::GlobalAsm(ref asm) => println!("global asm: {:?}", asm),
+        hir::ItemKind::TyAlias(..) => {
+            println!("type alias for {:?}", cx.tcx.type_of(did));
+        },
+        hir::ItemKind::OpaqueTy(..) => {
+            println!("existential type with real type {:?}", cx.tcx.type_of(did));
+        },
+        hir::ItemKind::Enum(..) => {
+            println!("enum definition of type {:?}", cx.tcx.type_of(did));
+        },
+        hir::ItemKind::Struct(..) => {
+            println!("struct definition of type {:?}", cx.tcx.type_of(did));
+        },
+        hir::ItemKind::Union(..) => {
+            println!("union definition of type {:?}", cx.tcx.type_of(did));
+        },
+        hir::ItemKind::Trait(..) => {
+            println!("trait decl");
+            if cx.tcx.trait_is_auto(did.to_def_id()) {
+                println!("trait is auto");
+            } else {
+                println!("trait is not auto");
+            }
+        },
+        hir::ItemKind::TraitAlias(..) => {
+            println!("trait alias");
+        },
+        hir::ItemKind::Impl(hir::Impl {
+            of_trait: Some(ref _trait_ref),
+            ..
+        }) => {
+            println!("trait impl");
+        },
+        hir::ItemKind::Impl(hir::Impl { of_trait: None, .. }) => {
+            println!("impl");
+        },
+    }
+}
+
+#[allow(clippy::similar_names)]
+#[allow(clippy::too_many_lines)]
+fn print_pat(cx: &LateContext<'_>, pat: &hir::Pat<'_>, indent: usize) {
+    let ind = "  ".repeat(indent);
+    println!("{}+", ind);
+    match pat.kind {
+        hir::PatKind::Wild => println!("{}Wild", ind),
+        hir::PatKind::Binding(ref mode, .., ident, ref inner) => {
+            println!("{}Binding", ind);
+            println!("{}mode: {:?}", ind, mode);
+            println!("{}name: {}", ind, ident.name);
+            if let Some(ref inner) = *inner {
+                println!("{}inner:", ind);
+                print_pat(cx, inner, indent + 1);
+            }
+        },
+        hir::PatKind::Or(fields) => {
+            println!("{}Or", ind);
+            for field in fields {
+                print_pat(cx, field, indent + 1);
+            }
+        },
+        hir::PatKind::Struct(ref path, fields, ignore) => {
+            println!("{}Struct", ind);
+            println!(
+                "{}name: {}",
+                ind,
+                rustc_hir_pretty::to_string(rustc_hir_pretty::NO_ANN, |s| s.print_qpath(path, false))
+            );
+            println!("{}ignore leftover fields: {}", ind, ignore);
+            println!("{}fields:", ind);
+            for field in fields {
+                println!("{}  field name: {}", ind, field.ident.name);
+                if field.is_shorthand {
+                    println!("{}  in shorthand notation", ind);
+                }
+                print_pat(cx, &field.pat, indent + 1);
+            }
+        },
+        hir::PatKind::TupleStruct(ref path, fields, opt_dots_position) => {
+            println!("{}TupleStruct", ind);
+            println!(
+                "{}path: {}",
+                ind,
+                rustc_hir_pretty::to_string(rustc_hir_pretty::NO_ANN, |s| s.print_qpath(path, false))
+            );
+            if let Some(dot_position) = opt_dots_position {
+                println!("{}dot position: {}", ind, dot_position);
+            }
+            for field in fields {
+                print_pat(cx, field, indent + 1);
+            }
+        },
+        hir::PatKind::Path(hir::QPath::Resolved(ref ty, ref path)) => {
+            println!("{}Resolved Path, {:?}", ind, ty);
+            println!("{}path: {:?}", ind, path);
+        },
+        hir::PatKind::Path(hir::QPath::TypeRelative(ref ty, ref seg)) => {
+            println!("{}Relative Path, {:?}", ind, ty);
+            println!("{}seg: {:?}", ind, seg);
+        },
+        hir::PatKind::Path(hir::QPath::LangItem(lang_item, ..)) => {
+            println!("{}Lang Item Path, {:?}", ind, lang_item.name());
+        },
+        hir::PatKind::Tuple(pats, opt_dots_position) => {
+            println!("{}Tuple", ind);
+            if let Some(dot_position) = opt_dots_position {
+                println!("{}dot position: {}", ind, dot_position);
+            }
+            for field in pats {
+                print_pat(cx, field, indent + 1);
+            }
+        },
+        hir::PatKind::Box(ref inner) => {
+            println!("{}Box", ind);
+            print_pat(cx, inner, indent + 1);
+        },
+        hir::PatKind::Ref(ref inner, ref muta) => {
+            println!("{}Ref", ind);
+            println!("{}mutability: {:?}", ind, muta);
+            print_pat(cx, inner, indent + 1);
+        },
+        hir::PatKind::Lit(ref e) => {
+            println!("{}Lit", ind);
+            print_expr(cx, e, indent + 1);
+        },
+        hir::PatKind::Range(ref l, ref r, ref range_end) => {
+            println!("{}Range", ind);
+            if let Some(expr) = l {
+                print_expr(cx, expr, indent + 1);
+            }
+            if let Some(expr) = r {
+                print_expr(cx, expr, indent + 1);
+            }
+            match *range_end {
+                hir::RangeEnd::Included => println!("{} end included", ind),
+                hir::RangeEnd::Excluded => println!("{} end excluded", ind),
+            }
+        },
+        hir::PatKind::Slice(first_pats, ref range, last_pats) => {
+            println!("{}Slice [a, b, ..i, y, z]", ind);
+            println!("[a, b]:");
+            for pat in first_pats {
+                print_pat(cx, pat, indent + 1);
+            }
+            println!("i:");
+            if let Some(ref pat) = *range {
+                print_pat(cx, pat, indent + 1);
+            }
+            println!("[y, z]:");
+            for pat in last_pats {
+                print_pat(cx, pat, indent + 1);
+            }
+        },
+    }
+}
+
+fn print_guard(cx: &LateContext<'_>, guard: &hir::Guard<'_>, indent: usize) {
+    let ind = "  ".repeat(indent);
+    println!("{}+", ind);
+    match guard {
+        hir::Guard::If(expr) => {
+            println!("{}If", ind);
+            print_expr(cx, expr, indent + 1);
+        },
+        hir::Guard::IfLet(pat, expr) => {
+            println!("{}IfLet", ind);
+            print_pat(cx, pat, indent + 1);
+            print_expr(cx, expr, indent + 1);
+        },
+    }
+}
diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs
new file mode 100644
index 00000000000..d8c602fab22
--- /dev/null
+++ b/clippy_lints/src/utils/internal_lints.rs
@@ -0,0 +1,1070 @@
+use crate::consts::{constant_simple, Constant};
+use crate::utils::{
+    is_expn_of, match_def_path, match_qpath, match_type, method_calls, path_to_res, paths, run_lints, snippet,
+    span_lint, span_lint_and_help, span_lint_and_sugg, SpanlessEq,
+};
+use if_chain::if_chain;
+use rustc_ast::ast::{Crate as AstCrate, ItemKind, LitKind, NodeId};
+use rustc_ast::visit::FnKind;
+use rustc_data_structures::fx::{FxHashMap, FxHashSet};
+use rustc_errors::Applicability;
+use rustc_hir as hir;
+use rustc_hir::def::{DefKind, Res};
+use rustc_hir::def_id::DefId;
+use rustc_hir::hir_id::CRATE_HIR_ID;
+use rustc_hir::intravisit::{NestedVisitorMap, Visitor};
+use rustc_hir::{
+    BinOpKind, Crate, Expr, ExprKind, HirId, Item, MutTy, Mutability, Node, Path, StmtKind, Ty, TyKind, UnOp,
+};
+use rustc_lint::{EarlyContext, EarlyLintPass, LateContext, LateLintPass};
+use rustc_middle::hir::map::Map;
+use rustc_middle::mir::interpret::ConstValue;
+use rustc_middle::ty;
+use rustc_session::{declare_lint_pass, declare_tool_lint, impl_lint_pass};
+use rustc_span::source_map::{Span, Spanned};
+use rustc_span::symbol::{Symbol, SymbolStr};
+use rustc_typeck::hir_ty_to_ty;
+
+use std::borrow::{Borrow, Cow};
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for various things we like to keep tidy in clippy.
+    ///
+    /// **Why is this bad?** We like to pretend we're an example of tidy code.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:** Wrong ordering of the util::paths constants.
+    pub CLIPPY_LINTS_INTERNAL,
+    internal,
+    "various things that will negatively affect your clippy experience"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Ensures every lint is associated to a `LintPass`.
+    ///
+    /// **Why is this bad?** The compiler only knows lints via a `LintPass`. Without
+    /// putting a lint to a `LintPass::get_lints()`'s return, the compiler will not
+    /// know the name of the lint.
+    ///
+    /// **Known problems:** Only checks for lints associated using the
+    /// `declare_lint_pass!`, `impl_lint_pass!`, and `lint_array!` macros.
+    ///
+    /// **Example:**
+    /// ```rust,ignore
+    /// declare_lint! { pub LINT_1, ... }
+    /// declare_lint! { pub LINT_2, ... }
+    /// declare_lint! { pub FORGOTTEN_LINT, ... }
+    /// // ...
+    /// declare_lint_pass!(Pass => [LINT_1, LINT_2]);
+    /// // missing FORGOTTEN_LINT
+    /// ```
+    pub LINT_WITHOUT_LINT_PASS,
+    internal,
+    "declaring a lint without associating it in a LintPass"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for calls to `cx.span_lint*` and suggests to use the `utils::*`
+    /// variant of the function.
+    ///
+    /// **Why is this bad?** The `utils::*` variants also add a link to the Clippy documentation to the
+    /// warning/error messages.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// Bad:
+    /// ```rust,ignore
+    /// cx.span_lint(LINT_NAME, "message");
+    /// ```
+    ///
+    /// Good:
+    /// ```rust,ignore
+    /// utils::span_lint(cx, LINT_NAME, "message");
+    /// ```
+    pub COMPILER_LINT_FUNCTIONS,
+    internal,
+    "usage of the lint functions of the compiler instead of the utils::* variant"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for calls to `cx.outer().expn_data()` and suggests to use
+    /// the `cx.outer_expn_data()`
+    ///
+    /// **Why is this bad?** `cx.outer_expn_data()` is faster and more concise.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// Bad:
+    /// ```rust,ignore
+    /// expr.span.ctxt().outer().expn_data()
+    /// ```
+    ///
+    /// Good:
+    /// ```rust,ignore
+    /// expr.span.ctxt().outer_expn_data()
+    /// ```
+    pub OUTER_EXPN_EXPN_DATA,
+    internal,
+    "using `cx.outer_expn().expn_data()` instead of `cx.outer_expn_data()`"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Not an actual lint. This lint is only meant for testing our customized internal compiler
+    /// error message by calling `panic`.
+    ///
+    /// **Why is this bad?** ICE in large quantities can damage your teeth
+    ///
+    /// **Known problems:** None
+    ///
+    /// **Example:**
+    /// Bad:
+    /// ```rust,ignore
+    /// 🍦🍦🍦🍦🍦
+    /// ```
+    pub PRODUCE_ICE,
+    internal,
+    "this message should not appear anywhere as we ICE before and don't emit the lint"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for cases of an auto-generated lint without an updated description,
+    /// i.e. `default lint description`.
+    ///
+    /// **Why is this bad?** Indicates that the lint is not finished.
+    ///
+    /// **Known problems:** None
+    ///
+    /// **Example:**
+    /// Bad:
+    /// ```rust,ignore
+    /// declare_lint! { pub COOL_LINT, nursery, "default lint description" }
+    /// ```
+    ///
+    /// Good:
+    /// ```rust,ignore
+    /// declare_lint! { pub COOL_LINT, nursery, "a great new lint" }
+    /// ```
+    pub DEFAULT_LINT,
+    internal,
+    "found 'default lint description' in a lint declaration"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Lints `span_lint_and_then` function calls, where the
+    /// closure argument has only one statement and that statement is a method
+    /// call to `span_suggestion`, `span_help`, `span_note` (using the same
+    /// span), `help` or `note`.
+    ///
+    /// These usages of `span_lint_and_then` should be replaced with one of the
+    /// wrapper functions `span_lint_and_sugg`, span_lint_and_help`, or
+    /// `span_lint_and_note`.
+    ///
+    /// **Why is this bad?** Using the wrapper `span_lint_and_*` functions, is more
+    /// convenient, readable and less error prone.
+    ///
+    /// **Known problems:** None
+    ///
+    /// *Example:**
+    /// Bad:
+    /// ```rust,ignore
+    /// span_lint_and_then(cx, TEST_LINT, expr.span, lint_msg, |diag| {
+    ///     diag.span_suggestion(
+    ///         expr.span,
+    ///         help_msg,
+    ///         sugg.to_string(),
+    ///         Applicability::MachineApplicable,
+    ///     );
+    /// });
+    /// span_lint_and_then(cx, TEST_LINT, expr.span, lint_msg, |diag| {
+    ///     diag.span_help(expr.span, help_msg);
+    /// });
+    /// span_lint_and_then(cx, TEST_LINT, expr.span, lint_msg, |diag| {
+    ///     diag.help(help_msg);
+    /// });
+    /// span_lint_and_then(cx, TEST_LINT, expr.span, lint_msg, |diag| {
+    ///     diag.span_note(expr.span, note_msg);
+    /// });
+    /// span_lint_and_then(cx, TEST_LINT, expr.span, lint_msg, |diag| {
+    ///     diag.note(note_msg);
+    /// });
+    /// ```
+    ///
+    /// Good:
+    /// ```rust,ignore
+    /// span_lint_and_sugg(
+    ///     cx,
+    ///     TEST_LINT,
+    ///     expr.span,
+    ///     lint_msg,
+    ///     help_msg,
+    ///     sugg.to_string(),
+    ///     Applicability::MachineApplicable,
+    /// );
+    /// span_lint_and_help(cx, TEST_LINT, expr.span, lint_msg, Some(expr.span), help_msg);
+    /// span_lint_and_help(cx, TEST_LINT, expr.span, lint_msg, None, help_msg);
+    /// span_lint_and_note(cx, TEST_LINT, expr.span, lint_msg, Some(expr.span), note_msg);
+    /// span_lint_and_note(cx, TEST_LINT, expr.span, lint_msg, None, note_msg);
+    /// ```
+    pub COLLAPSIBLE_SPAN_LINT_CALLS,
+    internal,
+    "found collapsible `span_lint_and_then` calls"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for calls to `utils::match_type()` on a type diagnostic item
+    /// and suggests to use `utils::is_type_diagnostic_item()` instead.
+    ///
+    /// **Why is this bad?** `utils::is_type_diagnostic_item()` does not require hardcoded paths.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// Bad:
+    /// ```rust,ignore
+    /// utils::match_type(cx, ty, &paths::VEC)
+    /// ```
+    ///
+    /// Good:
+    /// ```rust,ignore
+    /// utils::is_type_diagnostic_item(cx, ty, sym::vec_type)
+    /// ```
+    pub MATCH_TYPE_ON_DIAGNOSTIC_ITEM,
+    internal,
+    "using `utils::match_type()` instead of `utils::is_type_diagnostic_item()`"
+}
+
+declare_clippy_lint! {
+    /// **What it does:**
+    /// Checks the paths module for invalid paths.
+    ///
+    /// **Why is this bad?**
+    /// It indicates a bug in the code.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:** None.
+    pub INVALID_PATHS,
+    internal,
+    "invalid path"
+}
+
+declare_clippy_lint! {
+    /// **What it does:**
+    /// Checks for interning symbols that have already been pre-interned and defined as constants.
+    ///
+    /// **Why is this bad?**
+    /// It's faster and easier to use the symbol constant.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// Bad:
+    /// ```rust,ignore
+    /// let _ = sym!(f32);
+    /// ```
+    ///
+    /// Good:
+    /// ```rust,ignore
+    /// let _ = sym::f32;
+    /// ```
+    pub INTERNING_DEFINED_SYMBOL,
+    internal,
+    "interning a symbol that is pre-interned and defined as a constant"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for unnecessary conversion from Symbol to a string.
+    ///
+    /// **Why is this bad?** It's faster use symbols directly intead of strings.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// Bad:
+    /// ```rust,ignore
+    /// symbol.as_str() == "clippy";
+    /// ```
+    ///
+    /// Good:
+    /// ```rust,ignore
+    /// symbol == sym::clippy;
+    /// ```
+    pub UNNECESSARY_SYMBOL_STR,
+    internal,
+    "unnecessary conversion between Symbol and string"
+}
+
+declare_lint_pass!(ClippyLintsInternal => [CLIPPY_LINTS_INTERNAL]);
+
+impl EarlyLintPass for ClippyLintsInternal {
+    fn check_crate(&mut self, cx: &EarlyContext<'_>, krate: &AstCrate) {
+        if let Some(utils) = krate
+            .module
+            .items
+            .iter()
+            .find(|item| item.ident.name.as_str() == "utils")
+        {
+            if let ItemKind::Mod(ref utils_mod) = utils.kind {
+                if let Some(paths) = utils_mod.items.iter().find(|item| item.ident.name.as_str() == "paths") {
+                    if let ItemKind::Mod(ref paths_mod) = paths.kind {
+                        let mut last_name: Option<SymbolStr> = None;
+                        for item in &*paths_mod.items {
+                            let name = item.ident.as_str();
+                            if let Some(ref last_name) = last_name {
+                                if **last_name > *name {
+                                    span_lint(
+                                        cx,
+                                        CLIPPY_LINTS_INTERNAL,
+                                        item.span,
+                                        "this constant should be before the previous constant due to lexical \
+                                         ordering",
+                                    );
+                                }
+                            }
+                            last_name = Some(name);
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+#[derive(Clone, Debug, Default)]
+pub struct LintWithoutLintPass {
+    declared_lints: FxHashMap<Symbol, Span>,
+    registered_lints: FxHashSet<Symbol>,
+}
+
+impl_lint_pass!(LintWithoutLintPass => [DEFAULT_LINT, LINT_WITHOUT_LINT_PASS]);
+
+impl<'tcx> LateLintPass<'tcx> for LintWithoutLintPass {
+    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
+        if !run_lints(cx, &[DEFAULT_LINT], item.hir_id) {
+            return;
+        }
+
+        if let hir::ItemKind::Static(ref ty, Mutability::Not, body_id) = item.kind {
+            if is_lint_ref_type(cx, ty) {
+                let expr = &cx.tcx.hir().body(body_id).value;
+                if_chain! {
+                    if let ExprKind::AddrOf(_, _, ref inner_exp) = expr.kind;
+                    if let ExprKind::Struct(_, ref fields, _) = inner_exp.kind;
+                    let field = fields
+                        .iter()
+                        .find(|f| f.ident.as_str() == "desc")
+                        .expect("lints must have a description field");
+                    if let ExprKind::Lit(Spanned {
+                        node: LitKind::Str(ref sym, _),
+                        ..
+                    }) = field.expr.kind;
+                    if sym.as_str() == "default lint description";
+
+                    then {
+                        span_lint(
+                            cx,
+                            DEFAULT_LINT,
+                            item.span,
+                            &format!("the lint `{}` has the default lint description", item.ident.name),
+                        );
+                    }
+                }
+                self.declared_lints.insert(item.ident.name, item.span);
+            }
+        } else if is_expn_of(item.span, "impl_lint_pass").is_some()
+            || is_expn_of(item.span, "declare_lint_pass").is_some()
+        {
+            if let hir::ItemKind::Impl(hir::Impl {
+                of_trait: None,
+                items: ref impl_item_refs,
+                ..
+            }) = item.kind
+            {
+                let mut collector = LintCollector {
+                    output: &mut self.registered_lints,
+                    cx,
+                };
+                let body_id = cx.tcx.hir().body_owned_by(
+                    impl_item_refs
+                        .iter()
+                        .find(|iiref| iiref.ident.as_str() == "get_lints")
+                        .expect("LintPass needs to implement get_lints")
+                        .id
+                        .hir_id,
+                );
+                collector.visit_expr(&cx.tcx.hir().body(body_id).value);
+            }
+        }
+    }
+
+    fn check_crate_post(&mut self, cx: &LateContext<'tcx>, _: &'tcx Crate<'_>) {
+        if !run_lints(cx, &[LINT_WITHOUT_LINT_PASS], CRATE_HIR_ID) {
+            return;
+        }
+
+        for (lint_name, &lint_span) in &self.declared_lints {
+            // When using the `declare_tool_lint!` macro, the original `lint_span`'s
+            // file points to "<rustc macros>".
+            // `compiletest-rs` thinks that's an error in a different file and
+            // just ignores it. This causes the test in compile-fail/lint_pass
+            // not able to capture the error.
+            // Therefore, we need to climb the macro expansion tree and find the
+            // actual span that invoked `declare_tool_lint!`:
+            let lint_span = lint_span.ctxt().outer_expn_data().call_site;
+
+            if !self.registered_lints.contains(lint_name) {
+                span_lint(
+                    cx,
+                    LINT_WITHOUT_LINT_PASS,
+                    lint_span,
+                    &format!("the lint `{}` is not added to any `LintPass`", lint_name),
+                );
+            }
+        }
+    }
+}
+
+fn is_lint_ref_type<'tcx>(cx: &LateContext<'tcx>, ty: &Ty<'_>) -> bool {
+    if let TyKind::Rptr(
+        _,
+        MutTy {
+            ty: ref inner,
+            mutbl: Mutability::Not,
+        },
+    ) = ty.kind
+    {
+        if let TyKind::Path(ref path) = inner.kind {
+            if let Res::Def(DefKind::Struct, def_id) = cx.qpath_res(path, inner.hir_id) {
+                return match_def_path(cx, def_id, &paths::LINT);
+            }
+        }
+    }
+
+    false
+}
+
+struct LintCollector<'a, 'tcx> {
+    output: &'a mut FxHashSet<Symbol>,
+    cx: &'a LateContext<'tcx>,
+}
+
+impl<'a, 'tcx> Visitor<'tcx> for LintCollector<'a, 'tcx> {
+    type Map = Map<'tcx>;
+
+    fn visit_path(&mut self, path: &'tcx Path<'_>, _: HirId) {
+        if path.segments.len() == 1 {
+            self.output.insert(path.segments[0].ident.name);
+        }
+    }
+
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::All(self.cx.tcx.hir())
+    }
+}
+
+#[derive(Clone, Default)]
+pub struct CompilerLintFunctions {
+    map: FxHashMap<&'static str, &'static str>,
+}
+
+impl CompilerLintFunctions {
+    #[must_use]
+    pub fn new() -> Self {
+        let mut map = FxHashMap::default();
+        map.insert("span_lint", "utils::span_lint");
+        map.insert("struct_span_lint", "utils::span_lint");
+        map.insert("lint", "utils::span_lint");
+        map.insert("span_lint_note", "utils::span_lint_and_note");
+        map.insert("span_lint_help", "utils::span_lint_and_help");
+        Self { map }
+    }
+}
+
+impl_lint_pass!(CompilerLintFunctions => [COMPILER_LINT_FUNCTIONS]);
+
+impl<'tcx> LateLintPass<'tcx> for CompilerLintFunctions {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        if !run_lints(cx, &[COMPILER_LINT_FUNCTIONS], expr.hir_id) {
+            return;
+        }
+
+        if_chain! {
+            if let ExprKind::MethodCall(ref path, _, ref args, _) = expr.kind;
+            let fn_name = path.ident;
+            if let Some(sugg) = self.map.get(&*fn_name.as_str());
+            let ty = cx.typeck_results().expr_ty(&args[0]).peel_refs();
+            if match_type(cx, ty, &paths::EARLY_CONTEXT)
+                || match_type(cx, ty, &paths::LATE_CONTEXT);
+            then {
+                span_lint_and_help(
+                    cx,
+                    COMPILER_LINT_FUNCTIONS,
+                    path.ident.span,
+                    "usage of a compiler lint function",
+                    None,
+                    &format!("please use the Clippy variant of this function: `{}`", sugg),
+                );
+            }
+        }
+    }
+}
+
+declare_lint_pass!(OuterExpnDataPass => [OUTER_EXPN_EXPN_DATA]);
+
+impl<'tcx> LateLintPass<'tcx> for OuterExpnDataPass {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
+        if !run_lints(cx, &[OUTER_EXPN_EXPN_DATA], expr.hir_id) {
+            return;
+        }
+
+        let (method_names, arg_lists, spans) = method_calls(expr, 2);
+        let method_names: Vec<SymbolStr> = method_names.iter().map(|s| s.as_str()).collect();
+        let method_names: Vec<&str> = method_names.iter().map(|s| &**s).collect();
+        if_chain! {
+            if let ["expn_data", "outer_expn"] = method_names.as_slice();
+            let args = arg_lists[1];
+            if args.len() == 1;
+            let self_arg = &args[0];
+            let self_ty = cx.typeck_results().expr_ty(self_arg).peel_refs();
+            if match_type(cx, self_ty, &paths::SYNTAX_CONTEXT);
+            then {
+                span_lint_and_sugg(
+                    cx,
+                    OUTER_EXPN_EXPN_DATA,
+                    spans[1].with_hi(expr.span.hi()),
+                    "usage of `outer_expn().expn_data()`",
+                    "try",
+                    "outer_expn_data()".to_string(),
+                    Applicability::MachineApplicable,
+                );
+            }
+        }
+    }
+}
+
+declare_lint_pass!(ProduceIce => [PRODUCE_ICE]);
+
+impl EarlyLintPass for ProduceIce {
+    fn check_fn(&mut self, _: &EarlyContext<'_>, fn_kind: FnKind<'_>, _: Span, _: NodeId) {
+        if is_trigger_fn(fn_kind) {
+            panic!("Would you like some help with that?");
+        }
+    }
+}
+
+fn is_trigger_fn(fn_kind: FnKind<'_>) -> bool {
+    match fn_kind {
+        FnKind::Fn(_, ident, ..) => ident.name.as_str() == "it_looks_like_you_are_trying_to_kill_clippy",
+        FnKind::Closure(..) => false,
+    }
+}
+
+declare_lint_pass!(CollapsibleCalls => [COLLAPSIBLE_SPAN_LINT_CALLS]);
+
+impl<'tcx> LateLintPass<'tcx> for CollapsibleCalls {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
+        if !run_lints(cx, &[COLLAPSIBLE_SPAN_LINT_CALLS], expr.hir_id) {
+            return;
+        }
+
+        if_chain! {
+            if let ExprKind::Call(ref func, ref and_then_args) = expr.kind;
+            if let ExprKind::Path(ref path) = func.kind;
+            if match_qpath(path, &["span_lint_and_then"]);
+            if and_then_args.len() == 5;
+            if let ExprKind::Closure(_, _, body_id, _, _) = &and_then_args[4].kind;
+            let body = cx.tcx.hir().body(*body_id);
+            if let ExprKind::Block(block, _) = &body.value.kind;
+            let stmts = &block.stmts;
+            if stmts.len() == 1 && block.expr.is_none();
+            if let StmtKind::Semi(only_expr) = &stmts[0].kind;
+            if let ExprKind::MethodCall(ref ps, _, ref span_call_args, _) = &only_expr.kind;
+            let and_then_snippets = get_and_then_snippets(cx, and_then_args);
+            let mut sle = SpanlessEq::new(cx).deny_side_effects();
+            then {
+                match &*ps.ident.as_str() {
+                    "span_suggestion" if sle.eq_expr(&and_then_args[2], &span_call_args[1]) => {
+                        suggest_suggestion(cx, expr, &and_then_snippets, &span_suggestion_snippets(cx, span_call_args));
+                    },
+                    "span_help" if sle.eq_expr(&and_then_args[2], &span_call_args[1]) => {
+                        let help_snippet = snippet(cx, span_call_args[2].span, r#""...""#);
+                        suggest_help(cx, expr, &and_then_snippets, help_snippet.borrow(), true);
+                    },
+                    "span_note" if sle.eq_expr(&and_then_args[2], &span_call_args[1]) => {
+                        let note_snippet = snippet(cx, span_call_args[2].span, r#""...""#);
+                        suggest_note(cx, expr, &and_then_snippets, note_snippet.borrow(), true);
+                    },
+                    "help" => {
+                        let help_snippet = snippet(cx, span_call_args[1].span, r#""...""#);
+                        suggest_help(cx, expr, &and_then_snippets, help_snippet.borrow(), false);
+                    }
+                    "note" => {
+                        let note_snippet = snippet(cx, span_call_args[1].span, r#""...""#);
+                        suggest_note(cx, expr, &and_then_snippets, note_snippet.borrow(), false);
+                    }
+                    _  => (),
+                }
+            }
+        }
+    }
+}
+
+struct AndThenSnippets<'a> {
+    cx: Cow<'a, str>,
+    lint: Cow<'a, str>,
+    span: Cow<'a, str>,
+    msg: Cow<'a, str>,
+}
+
+fn get_and_then_snippets<'a, 'hir>(cx: &LateContext<'_>, and_then_snippets: &'hir [Expr<'hir>]) -> AndThenSnippets<'a> {
+    let cx_snippet = snippet(cx, and_then_snippets[0].span, "cx");
+    let lint_snippet = snippet(cx, and_then_snippets[1].span, "..");
+    let span_snippet = snippet(cx, and_then_snippets[2].span, "span");
+    let msg_snippet = snippet(cx, and_then_snippets[3].span, r#""...""#);
+
+    AndThenSnippets {
+        cx: cx_snippet,
+        lint: lint_snippet,
+        span: span_snippet,
+        msg: msg_snippet,
+    }
+}
+
+struct SpanSuggestionSnippets<'a> {
+    help: Cow<'a, str>,
+    sugg: Cow<'a, str>,
+    applicability: Cow<'a, str>,
+}
+
+fn span_suggestion_snippets<'a, 'hir>(
+    cx: &LateContext<'_>,
+    span_call_args: &'hir [Expr<'hir>],
+) -> SpanSuggestionSnippets<'a> {
+    let help_snippet = snippet(cx, span_call_args[2].span, r#""...""#);
+    let sugg_snippet = snippet(cx, span_call_args[3].span, "..");
+    let applicability_snippet = snippet(cx, span_call_args[4].span, "Applicability::MachineApplicable");
+
+    SpanSuggestionSnippets {
+        help: help_snippet,
+        sugg: sugg_snippet,
+        applicability: applicability_snippet,
+    }
+}
+
+fn suggest_suggestion(
+    cx: &LateContext<'_>,
+    expr: &Expr<'_>,
+    and_then_snippets: &AndThenSnippets<'_>,
+    span_suggestion_snippets: &SpanSuggestionSnippets<'_>,
+) {
+    span_lint_and_sugg(
+        cx,
+        COLLAPSIBLE_SPAN_LINT_CALLS,
+        expr.span,
+        "this call is collapsible",
+        "collapse into",
+        format!(
+            "span_lint_and_sugg({}, {}, {}, {}, {}, {}, {})",
+            and_then_snippets.cx,
+            and_then_snippets.lint,
+            and_then_snippets.span,
+            and_then_snippets.msg,
+            span_suggestion_snippets.help,
+            span_suggestion_snippets.sugg,
+            span_suggestion_snippets.applicability
+        ),
+        Applicability::MachineApplicable,
+    );
+}
+
+fn suggest_help(
+    cx: &LateContext<'_>,
+    expr: &Expr<'_>,
+    and_then_snippets: &AndThenSnippets<'_>,
+    help: &str,
+    with_span: bool,
+) {
+    let option_span = if with_span {
+        format!("Some({})", and_then_snippets.span)
+    } else {
+        "None".to_string()
+    };
+
+    span_lint_and_sugg(
+        cx,
+        COLLAPSIBLE_SPAN_LINT_CALLS,
+        expr.span,
+        "this call is collapsible",
+        "collapse into",
+        format!(
+            "span_lint_and_help({}, {}, {}, {}, {}, {})",
+            and_then_snippets.cx,
+            and_then_snippets.lint,
+            and_then_snippets.span,
+            and_then_snippets.msg,
+            &option_span,
+            help
+        ),
+        Applicability::MachineApplicable,
+    );
+}
+
+fn suggest_note(
+    cx: &LateContext<'_>,
+    expr: &Expr<'_>,
+    and_then_snippets: &AndThenSnippets<'_>,
+    note: &str,
+    with_span: bool,
+) {
+    let note_span = if with_span {
+        format!("Some({})", and_then_snippets.span)
+    } else {
+        "None".to_string()
+    };
+
+    span_lint_and_sugg(
+        cx,
+        COLLAPSIBLE_SPAN_LINT_CALLS,
+        expr.span,
+        "this call is collspible",
+        "collapse into",
+        format!(
+            "span_lint_and_note({}, {}, {}, {}, {}, {})",
+            and_then_snippets.cx,
+            and_then_snippets.lint,
+            and_then_snippets.span,
+            and_then_snippets.msg,
+            note_span,
+            note
+        ),
+        Applicability::MachineApplicable,
+    );
+}
+
+declare_lint_pass!(MatchTypeOnDiagItem => [MATCH_TYPE_ON_DIAGNOSTIC_ITEM]);
+
+impl<'tcx> LateLintPass<'tcx> for MatchTypeOnDiagItem {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
+        if !run_lints(cx, &[MATCH_TYPE_ON_DIAGNOSTIC_ITEM], expr.hir_id) {
+            return;
+        }
+
+        if_chain! {
+            // Check if this is a call to utils::match_type()
+            if let ExprKind::Call(fn_path, [context, ty, ty_path]) = expr.kind;
+            if let ExprKind::Path(fn_qpath) = &fn_path.kind;
+            if match_qpath(&fn_qpath, &["utils", "match_type"]);
+            // Extract the path to the matched type
+            if let Some(segments) = path_to_matched_type(cx, ty_path);
+            let segments: Vec<&str> = segments.iter().map(|sym| &**sym).collect();
+            if let Some(ty_did) = path_to_res(cx, &segments[..]).opt_def_id();
+            // Check if the matched type is a diagnostic item
+            let diag_items = cx.tcx.diagnostic_items(ty_did.krate);
+            if let Some(item_name) = diag_items.iter().find_map(|(k, v)| if *v == ty_did { Some(k) } else { None });
+            then {
+                let cx_snippet = snippet(cx, context.span, "_");
+                let ty_snippet = snippet(cx, ty.span, "_");
+
+                span_lint_and_sugg(
+                    cx,
+                    MATCH_TYPE_ON_DIAGNOSTIC_ITEM,
+                    expr.span,
+                    "usage of `utils::match_type()` on a type diagnostic item",
+                    "try",
+                    format!("utils::is_type_diagnostic_item({}, {}, sym::{})", cx_snippet, ty_snippet, item_name),
+                    Applicability::MaybeIncorrect,
+                );
+            }
+        }
+    }
+}
+
+fn path_to_matched_type(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> Option<Vec<SymbolStr>> {
+    use rustc_hir::ItemKind;
+
+    match &expr.kind {
+        ExprKind::AddrOf(.., expr) => return path_to_matched_type(cx, expr),
+        ExprKind::Path(qpath) => match cx.qpath_res(qpath, expr.hir_id) {
+            Res::Local(hir_id) => {
+                let parent_id = cx.tcx.hir().get_parent_node(hir_id);
+                if let Some(Node::Local(local)) = cx.tcx.hir().find(parent_id) {
+                    if let Some(init) = local.init {
+                        return path_to_matched_type(cx, init);
+                    }
+                }
+            },
+            Res::Def(DefKind::Const | DefKind::Static, def_id) => {
+                if let Some(Node::Item(item)) = cx.tcx.hir().get_if_local(def_id) {
+                    if let ItemKind::Const(.., body_id) | ItemKind::Static(.., body_id) = item.kind {
+                        let body = cx.tcx.hir().body(body_id);
+                        return path_to_matched_type(cx, &body.value);
+                    }
+                }
+            },
+            _ => {},
+        },
+        ExprKind::Array(exprs) => {
+            let segments: Vec<SymbolStr> = exprs
+                .iter()
+                .filter_map(|expr| {
+                    if let ExprKind::Lit(lit) = &expr.kind {
+                        if let LitKind::Str(sym, _) = lit.node {
+                            return Some(sym.as_str());
+                        }
+                    }
+
+                    None
+                })
+                .collect();
+
+            if segments.len() == exprs.len() {
+                return Some(segments);
+            }
+        },
+        _ => {},
+    }
+
+    None
+}
+
+// This is not a complete resolver for paths. It works on all the paths currently used in the paths
+// module.  That's all it does and all it needs to do.
+pub fn check_path(cx: &LateContext<'_>, path: &[&str]) -> bool {
+    if path_to_res(cx, path) != Res::Err {
+        return true;
+    }
+
+    // Some implementations can't be found by `path_to_res`, particularly inherent
+    // implementations of native types. Check lang items.
+    let path_syms: Vec<_> = path.iter().map(|p| Symbol::intern(p)).collect();
+    let lang_items = cx.tcx.lang_items();
+    for item_def_id in lang_items.items().iter().flatten() {
+        let lang_item_path = cx.get_def_path(*item_def_id);
+        if path_syms.starts_with(&lang_item_path) {
+            if let [item] = &path_syms[lang_item_path.len()..] {
+                for child in cx.tcx.item_children(*item_def_id) {
+                    if child.ident.name == *item {
+                        return true;
+                    }
+                }
+            }
+        }
+    }
+
+    false
+}
+
+declare_lint_pass!(InvalidPaths => [INVALID_PATHS]);
+
+impl<'tcx> LateLintPass<'tcx> for InvalidPaths {
+    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
+        let local_def_id = &cx.tcx.parent_module(item.hir_id);
+        let mod_name = &cx.tcx.item_name(local_def_id.to_def_id());
+        if_chain! {
+            if mod_name.as_str() == "paths";
+            if let hir::ItemKind::Const(ty, body_id) = item.kind;
+            let ty = hir_ty_to_ty(cx.tcx, ty);
+            if let ty::Array(el_ty, _) = &ty.kind();
+            if let ty::Ref(_, el_ty, _) = &el_ty.kind();
+            if el_ty.is_str();
+            let body = cx.tcx.hir().body(body_id);
+            let typeck_results = cx.tcx.typeck_body(body_id);
+            if let Some(Constant::Vec(path)) = constant_simple(cx, typeck_results, &body.value);
+            let path: Vec<&str> = path.iter().map(|x| {
+                    if let Constant::Str(s) = x {
+                        s.as_str()
+                    } else {
+                        // We checked the type of the constant above
+                        unreachable!()
+                    }
+                }).collect();
+            if !check_path(cx, &path[..]);
+            then {
+                span_lint(cx, CLIPPY_LINTS_INTERNAL, item.span, "invalid path");
+            }
+        }
+    }
+}
+
+#[derive(Default)]
+pub struct InterningDefinedSymbol {
+    // Maps the symbol value to the constant DefId.
+    symbol_map: FxHashMap<u32, DefId>,
+}
+
+impl_lint_pass!(InterningDefinedSymbol => [INTERNING_DEFINED_SYMBOL, UNNECESSARY_SYMBOL_STR]);
+
+impl<'tcx> LateLintPass<'tcx> for InterningDefinedSymbol {
+    fn check_crate(&mut self, cx: &LateContext<'_>, _: &Crate<'_>) {
+        if !self.symbol_map.is_empty() {
+            return;
+        }
+
+        for &module in &[&paths::KW_MODULE, &paths::SYM_MODULE] {
+            if let Some(def_id) = path_to_res(cx, module).opt_def_id() {
+                for item in cx.tcx.item_children(def_id).iter() {
+                    if_chain! {
+                        if let Res::Def(DefKind::Const, item_def_id) = item.res;
+                        let ty = cx.tcx.type_of(item_def_id);
+                        if match_type(cx, ty, &paths::SYMBOL);
+                        if let Ok(ConstValue::Scalar(value)) = cx.tcx.const_eval_poly(item_def_id);
+                        if let Ok(value) = value.to_u32();
+                        then {
+                            self.symbol_map.insert(value, item_def_id);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        if_chain! {
+            if let ExprKind::Call(func, [arg]) = &expr.kind;
+            if let ty::FnDef(def_id, _) = cx.typeck_results().expr_ty(func).kind();
+            if match_def_path(cx, *def_id, &paths::SYMBOL_INTERN);
+            if let Some(Constant::Str(arg)) = constant_simple(cx, cx.typeck_results(), arg);
+            let value = Symbol::intern(&arg).as_u32();
+            if let Some(&def_id) = self.symbol_map.get(&value);
+            then {
+                span_lint_and_sugg(
+                    cx,
+                    INTERNING_DEFINED_SYMBOL,
+                    is_expn_of(expr.span, "sym").unwrap_or(expr.span),
+                    "interning a defined symbol",
+                    "try",
+                    cx.tcx.def_path_str(def_id),
+                    Applicability::MachineApplicable,
+                );
+            }
+        }
+        if let ExprKind::Binary(op, left, right) = expr.kind {
+            if matches!(op.node, BinOpKind::Eq | BinOpKind::Ne) {
+                let data = [
+                    (left, self.symbol_str_expr(left, cx)),
+                    (right, self.symbol_str_expr(right, cx)),
+                ];
+                match data {
+                    // both operands are a symbol string
+                    [(_, Some(left)), (_, Some(right))] => {
+                        span_lint_and_sugg(
+                            cx,
+                            UNNECESSARY_SYMBOL_STR,
+                            expr.span,
+                            "unnecessary `Symbol` to string conversion",
+                            "try",
+                            format!(
+                                "{} {} {}",
+                                left.as_symbol_snippet(cx),
+                                op.node.as_str(),
+                                right.as_symbol_snippet(cx),
+                            ),
+                            Applicability::MachineApplicable,
+                        );
+                    },
+                    // one of the operands is a symbol string
+                    [(expr, Some(symbol)), _] | [_, (expr, Some(symbol))] => {
+                        // creating an owned string for comparison
+                        if matches!(symbol, SymbolStrExpr::Expr { is_to_owned: true, .. }) {
+                            span_lint_and_sugg(
+                                cx,
+                                UNNECESSARY_SYMBOL_STR,
+                                expr.span,
+                                "unnecessary string allocation",
+                                "try",
+                                format!("{}.as_str()", symbol.as_symbol_snippet(cx)),
+                                Applicability::MachineApplicable,
+                            );
+                        }
+                    },
+                    // nothing found
+                    [(_, None), (_, None)] => {},
+                }
+            }
+        }
+    }
+}
+
+impl InterningDefinedSymbol {
+    fn symbol_str_expr<'tcx>(&self, expr: &'tcx Expr<'tcx>, cx: &LateContext<'tcx>) -> Option<SymbolStrExpr<'tcx>> {
+        static IDENT_STR_PATHS: &[&[&str]] = &[&paths::IDENT_AS_STR, &paths::TO_STRING_METHOD];
+        static SYMBOL_STR_PATHS: &[&[&str]] = &[
+            &paths::SYMBOL_AS_STR,
+            &paths::SYMBOL_TO_IDENT_STRING,
+            &paths::TO_STRING_METHOD,
+        ];
+        // SymbolStr might be de-referenced: `&*symbol.as_str()`
+        let call = if_chain! {
+            if let ExprKind::AddrOf(_, _, e) = expr.kind;
+            if let ExprKind::Unary(UnOp::Deref, e) = e.kind;
+            then { e } else { expr }
+        };
+        if_chain! {
+            // is a method call
+            if let ExprKind::MethodCall(_, _, [item], _) = call.kind;
+            if let Some(did) = cx.typeck_results().type_dependent_def_id(call.hir_id);
+            let ty = cx.typeck_results().expr_ty(item);
+            // ...on either an Ident or a Symbol
+            if let Some(is_ident) = if match_type(cx, ty, &paths::SYMBOL) {
+                Some(false)
+            } else if match_type(cx, ty, &paths::IDENT) {
+                Some(true)
+            } else {
+                None
+            };
+            // ...which converts it to a string
+            let paths = if is_ident { IDENT_STR_PATHS } else { SYMBOL_STR_PATHS };
+            if let Some(path) = paths.iter().find(|path| match_def_path(cx, did, path));
+            then {
+                let is_to_owned = path.last().unwrap().ends_with("string");
+                return Some(SymbolStrExpr::Expr {
+                    item,
+                    is_ident,
+                    is_to_owned,
+                });
+            }
+        }
+        // is a string constant
+        if let Some(Constant::Str(s)) = constant_simple(cx, cx.typeck_results(), expr) {
+            let value = Symbol::intern(&s).as_u32();
+            // ...which matches a symbol constant
+            if let Some(&def_id) = self.symbol_map.get(&value) {
+                return Some(SymbolStrExpr::Const(def_id));
+            }
+        }
+        None
+    }
+}
+
+enum SymbolStrExpr<'tcx> {
+    /// a string constant with a corresponding symbol constant
+    Const(DefId),
+    /// a "symbol to string" expression like `symbol.as_str()`
+    Expr {
+        /// part that evaluates to `Symbol` or `Ident`
+        item: &'tcx Expr<'tcx>,
+        is_ident: bool,
+        /// whether an owned `String` is created like `to_ident_string()`
+        is_to_owned: bool,
+    },
+}
+
+impl<'tcx> SymbolStrExpr<'tcx> {
+    /// Returns a snippet that evaluates to a `Symbol` and is const if possible
+    fn as_symbol_snippet(&self, cx: &LateContext<'_>) -> Cow<'tcx, str> {
+        match *self {
+            Self::Const(def_id) => cx.tcx.def_path_str(def_id).into(),
+            Self::Expr { item, is_ident, .. } => {
+                let mut snip = snippet(cx, item.span.source_callsite(), "..");
+                if is_ident {
+                    // get `Ident.name`
+                    snip.to_mut().push_str(".name");
+                }
+                snip
+            },
+        }
+    }
+}
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
new file mode 100644
index 00000000000..68ab8161e20
--- /dev/null
+++ b/clippy_lints/src/utils/mod.rs
@@ -0,0 +1,6 @@
+pub mod author;
+pub mod inspector;
+#[cfg(feature = "internal-lints")]
+pub mod internal_lints;
+
+pub use clippy_utils::*;
diff --git a/clippy_utils/src/author.rs b/clippy_utils/src/author.rs
deleted file mode 100644
index ba83566b5e6..00000000000
--- a/clippy_utils/src/author.rs
+++ /dev/null
@@ -1,779 +0,0 @@
-//! A group of attributes that can be attached to Rust code in order
-//! to generate a clippy lint detecting said code automatically.
-
-use crate::{declare_clippy_lint, get_attr};
-use rustc_ast::ast::{Attribute, LitFloatType, LitKind};
-use rustc_ast::walk_list;
-use rustc_data_structures::fx::FxHashMap;
-use rustc_hir as hir;
-use rustc_hir::intravisit::{NestedVisitorMap, Visitor};
-use rustc_hir::{BindingAnnotation, Block, Expr, ExprKind, Pat, PatKind, QPath, Stmt, StmtKind, TyKind};
-use rustc_lint::{LateContext, LateLintPass, LintContext};
-use rustc_middle::hir::map::Map;
-use rustc_session::Session;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-
-declare_clippy_lint! {
-    /// **What it does:** Generates clippy code that detects the offending pattern
-    ///
-    /// **Example:**
-    /// ```rust,ignore
-    /// // ./tests/ui/my_lint.rs
-    /// fn foo() {
-    ///     // detect the following pattern
-    ///     #[clippy::author]
-    ///     if x == 42 {
-    ///         // but ignore everything from here on
-    ///         #![clippy::author = "ignore"]
-    ///     }
-    ///     ()
-    /// }
-    /// ```
-    ///
-    /// Running `TESTNAME=ui/my_lint cargo uitest` will produce
-    /// a `./tests/ui/new_lint.stdout` file with the generated code:
-    ///
-    /// ```rust,ignore
-    /// // ./tests/ui/new_lint.stdout
-    /// if_chain! {
-    ///     if let ExprKind::If(ref cond, ref then, None) = item.kind,
-    ///     if let ExprKind::Binary(BinOp::Eq, ref left, ref right) = cond.kind,
-    ///     if let ExprKind::Path(ref path) = left.kind,
-    ///     if let ExprKind::Lit(ref lit) = right.kind,
-    ///     if let LitKind::Int(42, _) = lit.node,
-    ///     then {
-    ///         // report your lint here
-    ///     }
-    /// }
-    /// ```
-    pub LINT_AUTHOR,
-    internal_warn,
-    "helper for writing lints"
-}
-
-declare_lint_pass!(Author => [LINT_AUTHOR]);
-
-fn prelude() {
-    println!("if_chain! {{");
-}
-
-fn done() {
-    println!("    then {{");
-    println!("        // report your lint here");
-    println!("    }}");
-    println!("}}");
-}
-
-impl<'tcx> LateLintPass<'tcx> for Author {
-    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) {
-        if !has_attr(cx.sess(), &item.attrs) {
-            return;
-        }
-        prelude();
-        PrintVisitor::new("item").visit_item(item);
-        done();
-    }
-
-    fn check_impl_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::ImplItem<'_>) {
-        if !has_attr(cx.sess(), &item.attrs) {
-            return;
-        }
-        prelude();
-        PrintVisitor::new("item").visit_impl_item(item);
-        done();
-    }
-
-    fn check_trait_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::TraitItem<'_>) {
-        if !has_attr(cx.sess(), &item.attrs) {
-            return;
-        }
-        prelude();
-        PrintVisitor::new("item").visit_trait_item(item);
-        done();
-    }
-
-    fn check_variant(&mut self, cx: &LateContext<'tcx>, var: &'tcx hir::Variant<'_>) {
-        if !has_attr(cx.sess(), &var.attrs) {
-            return;
-        }
-        prelude();
-        let parent_hir_id = cx.tcx.hir().get_parent_node(var.id);
-        PrintVisitor::new("var").visit_variant(var, &hir::Generics::empty(), parent_hir_id);
-        done();
-    }
-
-    fn check_struct_field(&mut self, cx: &LateContext<'tcx>, field: &'tcx hir::StructField<'_>) {
-        if !has_attr(cx.sess(), &field.attrs) {
-            return;
-        }
-        prelude();
-        PrintVisitor::new("field").visit_struct_field(field);
-        done();
-    }
-
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
-        if !has_attr(cx.sess(), &expr.attrs) {
-            return;
-        }
-        prelude();
-        PrintVisitor::new("expr").visit_expr(expr);
-        done();
-    }
-
-    fn check_arm(&mut self, cx: &LateContext<'tcx>, arm: &'tcx hir::Arm<'_>) {
-        if !has_attr(cx.sess(), &arm.attrs) {
-            return;
-        }
-        prelude();
-        PrintVisitor::new("arm").visit_arm(arm);
-        done();
-    }
-
-    fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx hir::Stmt<'_>) {
-        if !has_attr(cx.sess(), stmt.kind.attrs(|id| cx.tcx.hir().item(id.id))) {
-            return;
-        }
-        prelude();
-        PrintVisitor::new("stmt").visit_stmt(stmt);
-        done();
-    }
-
-    fn check_foreign_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::ForeignItem<'_>) {
-        if !has_attr(cx.sess(), &item.attrs) {
-            return;
-        }
-        prelude();
-        PrintVisitor::new("item").visit_foreign_item(item);
-        done();
-    }
-}
-
-impl PrintVisitor {
-    #[must_use]
-    fn new(s: &'static str) -> Self {
-        Self {
-            ids: FxHashMap::default(),
-            current: s.to_owned(),
-        }
-    }
-
-    fn next(&mut self, s: &'static str) -> String {
-        use std::collections::hash_map::Entry::{Occupied, Vacant};
-        match self.ids.entry(s) {
-            // already there: start numbering from `1`
-            Occupied(mut occ) => {
-                let val = occ.get_mut();
-                *val += 1;
-                format!("{}{}", s, *val)
-            },
-            // not there: insert and return name as given
-            Vacant(vac) => {
-                vac.insert(0);
-                s.to_owned()
-            },
-        }
-    }
-
-    fn print_qpath(&mut self, path: &QPath<'_>) {
-        if let QPath::LangItem(lang_item, _) = *path {
-            println!(
-                "    if matches!({}, QPath::LangItem(LangItem::{:?}, _));",
-                self.current, lang_item,
-            );
-        } else {
-            print!("    if match_qpath({}, &[", self.current);
-            print_path(path, &mut true);
-            println!("]);");
-        }
-    }
-}
-
-struct PrintVisitor {
-    /// Fields are the current index that needs to be appended to pattern
-    /// binding names
-    ids: FxHashMap<&'static str, usize>,
-    /// the name that needs to be destructured
-    current: String,
-}
-
-impl<'tcx> Visitor<'tcx> for PrintVisitor {
-    type Map = Map<'tcx>;
-
-    #[allow(clippy::too_many_lines)]
-    fn visit_expr(&mut self, expr: &Expr<'_>) {
-        print!("    if let ExprKind::");
-        let current = format!("{}.kind", self.current);
-        match expr.kind {
-            ExprKind::Box(ref inner) => {
-                let inner_pat = self.next("inner");
-                println!("Box(ref {}) = {};", inner_pat, current);
-                self.current = inner_pat;
-                self.visit_expr(inner);
-            },
-            ExprKind::Array(ref elements) => {
-                let elements_pat = self.next("elements");
-                println!("Array(ref {}) = {};", elements_pat, current);
-                println!("    if {}.len() == {};", elements_pat, elements.len());
-                for (i, element) in elements.iter().enumerate() {
-                    self.current = format!("{}[{}]", elements_pat, i);
-                    self.visit_expr(element);
-                }
-            },
-            ExprKind::Call(ref func, ref args) => {
-                let func_pat = self.next("func");
-                let args_pat = self.next("args");
-                println!("Call(ref {}, ref {}) = {};", func_pat, args_pat, current);
-                self.current = func_pat;
-                self.visit_expr(func);
-                println!("    if {}.len() == {};", args_pat, args.len());
-                for (i, arg) in args.iter().enumerate() {
-                    self.current = format!("{}[{}]", args_pat, i);
-                    self.visit_expr(arg);
-                }
-            },
-            ExprKind::MethodCall(ref _method_name, ref _generics, ref _args, ref _fn_span) => {
-                println!(
-                    "MethodCall(ref method_name, ref generics, ref args, ref fn_span) = {};",
-                    current
-                );
-                println!("    // unimplemented: `ExprKind::MethodCall` is not further destructured at the moment");
-            },
-            ExprKind::Tup(ref elements) => {
-                let elements_pat = self.next("elements");
-                println!("Tup(ref {}) = {};", elements_pat, current);
-                println!("    if {}.len() == {};", elements_pat, elements.len());
-                for (i, element) in elements.iter().enumerate() {
-                    self.current = format!("{}[{}]", elements_pat, i);
-                    self.visit_expr(element);
-                }
-            },
-            ExprKind::Binary(ref op, ref left, ref right) => {
-                let op_pat = self.next("op");
-                let left_pat = self.next("left");
-                let right_pat = self.next("right");
-                println!(
-                    "Binary(ref {}, ref {}, ref {}) = {};",
-                    op_pat, left_pat, right_pat, current
-                );
-                println!("    if BinOpKind::{:?} == {}.node;", op.node, op_pat);
-                self.current = left_pat;
-                self.visit_expr(left);
-                self.current = right_pat;
-                self.visit_expr(right);
-            },
-            ExprKind::Unary(ref op, ref inner) => {
-                let inner_pat = self.next("inner");
-                println!("Unary(UnOp::{:?}, ref {}) = {};", op, inner_pat, current);
-                self.current = inner_pat;
-                self.visit_expr(inner);
-            },
-            ExprKind::Lit(ref lit) => {
-                let lit_pat = self.next("lit");
-                println!("Lit(ref {}) = {};", lit_pat, current);
-                match lit.node {
-                    LitKind::Bool(val) => println!("    if let LitKind::Bool({:?}) = {}.node;", val, lit_pat),
-                    LitKind::Char(c) => println!("    if let LitKind::Char({:?}) = {}.node;", c, lit_pat),
-                    LitKind::Err(val) => println!("    if let LitKind::Err({}) = {}.node;", val, lit_pat),
-                    LitKind::Byte(b) => println!("    if let LitKind::Byte({}) = {}.node;", b, lit_pat),
-                    // FIXME: also check int type
-                    LitKind::Int(i, _) => println!("    if let LitKind::Int({}, _) = {}.node;", i, lit_pat),
-                    LitKind::Float(_, LitFloatType::Suffixed(_)) => println!(
-                        "    if let LitKind::Float(_, LitFloatType::Suffixed(_)) = {}.node;",
-                        lit_pat
-                    ),
-                    LitKind::Float(_, LitFloatType::Unsuffixed) => println!(
-                        "    if let LitKind::Float(_, LitFloatType::Unsuffixed) = {}.node;",
-                        lit_pat
-                    ),
-                    LitKind::ByteStr(ref vec) => {
-                        let vec_pat = self.next("vec");
-                        println!("    if let LitKind::ByteStr(ref {}) = {}.node;", vec_pat, lit_pat);
-                        println!("    if let [{:?}] = **{};", vec, vec_pat);
-                    },
-                    LitKind::Str(ref text, _) => {
-                        let str_pat = self.next("s");
-                        println!("    if let LitKind::Str(ref {}, _) = {}.node;", str_pat, lit_pat);
-                        println!("    if {}.as_str() == {:?}", str_pat, &*text.as_str())
-                    },
-                }
-            },
-            ExprKind::Cast(ref expr, ref ty) => {
-                let cast_pat = self.next("expr");
-                let cast_ty = self.next("cast_ty");
-                let qp_label = self.next("qp");
-
-                println!("Cast(ref {}, ref {}) = {};", cast_pat, cast_ty, current);
-                if let TyKind::Path(ref qp) = ty.kind {
-                    println!("    if let TyKind::Path(ref {}) = {}.kind;", qp_label, cast_ty);
-                    self.current = qp_label;
-                    self.print_qpath(qp);
-                }
-                self.current = cast_pat;
-                self.visit_expr(expr);
-            },
-            ExprKind::Type(ref expr, ref _ty) => {
-                let cast_pat = self.next("expr");
-                println!("Type(ref {}, _) = {};", cast_pat, current);
-                self.current = cast_pat;
-                self.visit_expr(expr);
-            },
-            ExprKind::Loop(ref body, _, desugaring, _) => {
-                let body_pat = self.next("body");
-                let des = loop_desugaring_name(desugaring);
-                let label_pat = self.next("label");
-                println!("Loop(ref {}, ref {}, {}) = {};", body_pat, label_pat, des, current);
-                self.current = body_pat;
-                self.visit_block(body);
-            },
-            ExprKind::If(ref cond, ref then, ref opt_else) => {
-                let cond_pat = self.next("cond");
-                let then_pat = self.next("then");
-                if let Some(ref else_) = *opt_else {
-                    let else_pat = self.next("else_");
-                    println!(
-                        "If(ref {}, ref {}, Some(ref {})) = {};",
-                        cond_pat, then_pat, else_pat, current
-                    );
-                    self.current = else_pat;
-                    self.visit_expr(else_);
-                } else {
-                    println!("If(ref {}, ref {}, None) = {};", cond_pat, then_pat, current);
-                }
-                self.current = cond_pat;
-                self.visit_expr(cond);
-                self.current = then_pat;
-                self.visit_expr(then);
-            },
-            ExprKind::Match(ref expr, ref arms, desugaring) => {
-                let des = desugaring_name(desugaring);
-                let expr_pat = self.next("expr");
-                let arms_pat = self.next("arms");
-                println!("Match(ref {}, ref {}, {}) = {};", expr_pat, arms_pat, des, current);
-                self.current = expr_pat;
-                self.visit_expr(expr);
-                println!("    if {}.len() == {};", arms_pat, arms.len());
-                for (i, arm) in arms.iter().enumerate() {
-                    self.current = format!("{}[{}].body", arms_pat, i);
-                    self.visit_expr(&arm.body);
-                    if let Some(ref guard) = arm.guard {
-                        let guard_pat = self.next("guard");
-                        println!("    if let Some(ref {}) = {}[{}].guard;", guard_pat, arms_pat, i);
-                        match guard {
-                            hir::Guard::If(ref if_expr) => {
-                                let if_expr_pat = self.next("expr");
-                                println!("    if let Guard::If(ref {}) = {};", if_expr_pat, guard_pat);
-                                self.current = if_expr_pat;
-                                self.visit_expr(if_expr);
-                            },
-                            hir::Guard::IfLet(ref if_let_pat, ref if_let_expr) => {
-                                let if_let_pat_pat = self.next("pat");
-                                let if_let_expr_pat = self.next("expr");
-                                println!(
-                                    "    if let Guard::IfLet(ref {}, ref {}) = {};",
-                                    if_let_pat_pat, if_let_expr_pat, guard_pat
-                                );
-                                self.current = if_let_expr_pat;
-                                self.visit_expr(if_let_expr);
-                                self.current = if_let_pat_pat;
-                                self.visit_pat(if_let_pat);
-                            },
-                        }
-                    }
-                    self.current = format!("{}[{}].pat", arms_pat, i);
-                    self.visit_pat(&arm.pat);
-                }
-            },
-            ExprKind::Closure(ref _capture_clause, ref _func, _, _, _) => {
-                println!("Closure(ref capture_clause, ref func, _, _, _) = {};", current);
-                println!("    // unimplemented: `ExprKind::Closure` is not further destructured at the moment");
-            },
-            ExprKind::Yield(ref sub, _) => {
-                let sub_pat = self.next("sub");
-                println!("Yield(ref sub) = {};", current);
-                self.current = sub_pat;
-                self.visit_expr(sub);
-            },
-            ExprKind::Block(ref block, _) => {
-                let block_pat = self.next("block");
-                println!("Block(ref {}) = {};", block_pat, current);
-                self.current = block_pat;
-                self.visit_block(block);
-            },
-            ExprKind::Assign(ref target, ref value, _) => {
-                let target_pat = self.next("target");
-                let value_pat = self.next("value");
-                println!(
-                    "Assign(ref {}, ref {}, ref _span) = {};",
-                    target_pat, value_pat, current
-                );
-                self.current = target_pat;
-                self.visit_expr(target);
-                self.current = value_pat;
-                self.visit_expr(value);
-            },
-            ExprKind::AssignOp(ref op, ref target, ref value) => {
-                let op_pat = self.next("op");
-                let target_pat = self.next("target");
-                let value_pat = self.next("value");
-                println!(
-                    "AssignOp(ref {}, ref {}, ref {}) = {};",
-                    op_pat, target_pat, value_pat, current
-                );
-                println!("    if BinOpKind::{:?} == {}.node;", op.node, op_pat);
-                self.current = target_pat;
-                self.visit_expr(target);
-                self.current = value_pat;
-                self.visit_expr(value);
-            },
-            ExprKind::Field(ref object, ref field_ident) => {
-                let obj_pat = self.next("object");
-                let field_name_pat = self.next("field_name");
-                println!("Field(ref {}, ref {}) = {};", obj_pat, field_name_pat, current);
-                println!("    if {}.as_str() == {:?}", field_name_pat, field_ident.as_str());
-                self.current = obj_pat;
-                self.visit_expr(object);
-            },
-            ExprKind::Index(ref object, ref index) => {
-                let object_pat = self.next("object");
-                let index_pat = self.next("index");
-                println!("Index(ref {}, ref {}) = {};", object_pat, index_pat, current);
-                self.current = object_pat;
-                self.visit_expr(object);
-                self.current = index_pat;
-                self.visit_expr(index);
-            },
-            ExprKind::Path(ref path) => {
-                let path_pat = self.next("path");
-                println!("Path(ref {}) = {};", path_pat, current);
-                self.current = path_pat;
-                self.print_qpath(path);
-            },
-            ExprKind::AddrOf(kind, mutability, ref inner) => {
-                let inner_pat = self.next("inner");
-                println!(
-                    "AddrOf(BorrowKind::{:?}, Mutability::{:?}, ref {}) = {};",
-                    kind, mutability, inner_pat, current
-                );
-                self.current = inner_pat;
-                self.visit_expr(inner);
-            },
-            ExprKind::Break(ref _destination, ref opt_value) => {
-                let destination_pat = self.next("destination");
-                if let Some(ref value) = *opt_value {
-                    let value_pat = self.next("value");
-                    println!("Break(ref {}, Some(ref {})) = {};", destination_pat, value_pat, current);
-                    self.current = value_pat;
-                    self.visit_expr(value);
-                } else {
-                    println!("Break(ref {}, None) = {};", destination_pat, current);
-                }
-                // FIXME: implement label printing
-            },
-            ExprKind::Continue(ref _destination) => {
-                let destination_pat = self.next("destination");
-                println!("Again(ref {}) = {};", destination_pat, current);
-                // FIXME: implement label printing
-            },
-            ExprKind::Ret(ref opt_value) => {
-                if let Some(ref value) = *opt_value {
-                    let value_pat = self.next("value");
-                    println!("Ret(Some(ref {})) = {};", value_pat, current);
-                    self.current = value_pat;
-                    self.visit_expr(value);
-                } else {
-                    println!("Ret(None) = {};", current);
-                }
-            },
-            ExprKind::InlineAsm(_) => {
-                println!("InlineAsm(_) = {};", current);
-                println!("    // unimplemented: `ExprKind::InlineAsm` is not further destructured at the moment");
-            },
-            ExprKind::LlvmInlineAsm(_) => {
-                println!("LlvmInlineAsm(_) = {};", current);
-                println!("    // unimplemented: `ExprKind::LlvmInlineAsm` is not further destructured at the moment");
-            },
-            ExprKind::Struct(ref path, ref fields, ref opt_base) => {
-                let path_pat = self.next("path");
-                let fields_pat = self.next("fields");
-                if let Some(ref base) = *opt_base {
-                    let base_pat = self.next("base");
-                    println!(
-                        "Struct(ref {}, ref {}, Some(ref {})) = {};",
-                        path_pat, fields_pat, base_pat, current
-                    );
-                    self.current = base_pat;
-                    self.visit_expr(base);
-                } else {
-                    println!("Struct(ref {}, ref {}, None) = {};", path_pat, fields_pat, current);
-                }
-                self.current = path_pat;
-                self.print_qpath(path);
-                println!("    if {}.len() == {};", fields_pat, fields.len());
-                println!("    // unimplemented: field checks");
-            },
-            ExprKind::ConstBlock(_) => {
-                let value_pat = self.next("value");
-                println!("Const({})", value_pat);
-                self.current = value_pat;
-            },
-            // FIXME: compute length (needs type info)
-            ExprKind::Repeat(ref value, _) => {
-                let value_pat = self.next("value");
-                println!("Repeat(ref {}, _) = {};", value_pat, current);
-                println!("// unimplemented: repeat count check");
-                self.current = value_pat;
-                self.visit_expr(value);
-            },
-            ExprKind::Err => {
-                println!("Err = {}", current);
-            },
-            ExprKind::DropTemps(ref expr) => {
-                let expr_pat = self.next("expr");
-                println!("DropTemps(ref {}) = {};", expr_pat, current);
-                self.current = expr_pat;
-                self.visit_expr(expr);
-            },
-        }
-    }
-
-    fn visit_block(&mut self, block: &Block<'_>) {
-        let trailing_pat = self.next("trailing_expr");
-        println!("    if let Some({}) = &{}.expr;", trailing_pat, self.current);
-        println!("    if {}.stmts.len() == {};", self.current, block.stmts.len());
-        let current = self.current.clone();
-        for (i, stmt) in block.stmts.iter().enumerate() {
-            self.current = format!("{}.stmts[{}]", current, i);
-            self.visit_stmt(stmt);
-        }
-    }
-
-    #[allow(clippy::too_many_lines)]
-    fn visit_pat(&mut self, pat: &Pat<'_>) {
-        print!("    if let PatKind::");
-        let current = format!("{}.kind", self.current);
-        match pat.kind {
-            PatKind::Wild => println!("Wild = {};", current),
-            PatKind::Binding(anno, .., ident, ref sub) => {
-                let anno_pat = match anno {
-                    BindingAnnotation::Unannotated => "BindingAnnotation::Unannotated",
-                    BindingAnnotation::Mutable => "BindingAnnotation::Mutable",
-                    BindingAnnotation::Ref => "BindingAnnotation::Ref",
-                    BindingAnnotation::RefMut => "BindingAnnotation::RefMut",
-                };
-                let name_pat = self.next("name");
-                if let Some(ref sub) = *sub {
-                    let sub_pat = self.next("sub");
-                    println!(
-                        "Binding({}, _, {}, Some(ref {})) = {};",
-                        anno_pat, name_pat, sub_pat, current
-                    );
-                    self.current = sub_pat;
-                    self.visit_pat(sub);
-                } else {
-                    println!("Binding({}, _, {}, None) = {};", anno_pat, name_pat, current);
-                }
-                println!("    if {}.as_str() == \"{}\";", name_pat, ident.as_str());
-            },
-            PatKind::Struct(ref path, ref fields, ignore) => {
-                let path_pat = self.next("path");
-                let fields_pat = self.next("fields");
-                println!(
-                    "Struct(ref {}, ref {}, {}) = {};",
-                    path_pat, fields_pat, ignore, current
-                );
-                self.current = path_pat;
-                self.print_qpath(path);
-                println!("    if {}.len() == {};", fields_pat, fields.len());
-                println!("    // unimplemented: field checks");
-            },
-            PatKind::Or(ref fields) => {
-                let fields_pat = self.next("fields");
-                println!("Or(ref {}) = {};", fields_pat, current);
-                println!("    if {}.len() == {};", fields_pat, fields.len());
-                println!("    // unimplemented: field checks");
-            },
-            PatKind::TupleStruct(ref path, ref fields, skip_pos) => {
-                let path_pat = self.next("path");
-                let fields_pat = self.next("fields");
-                println!(
-                    "TupleStruct(ref {}, ref {}, {:?}) = {};",
-                    path_pat, fields_pat, skip_pos, current
-                );
-                self.current = path_pat;
-                self.print_qpath(path);
-                println!("    if {}.len() == {};", fields_pat, fields.len());
-                println!("    // unimplemented: field checks");
-            },
-            PatKind::Path(ref path) => {
-                let path_pat = self.next("path");
-                println!("Path(ref {}) = {};", path_pat, current);
-                self.current = path_pat;
-                self.print_qpath(path);
-            },
-            PatKind::Tuple(ref fields, skip_pos) => {
-                let fields_pat = self.next("fields");
-                println!("Tuple(ref {}, {:?}) = {};", fields_pat, skip_pos, current);
-                println!("    if {}.len() == {};", fields_pat, fields.len());
-                println!("    // unimplemented: field checks");
-            },
-            PatKind::Box(ref pat) => {
-                let pat_pat = self.next("pat");
-                println!("Box(ref {}) = {};", pat_pat, current);
-                self.current = pat_pat;
-                self.visit_pat(pat);
-            },
-            PatKind::Ref(ref pat, muta) => {
-                let pat_pat = self.next("pat");
-                println!("Ref(ref {}, Mutability::{:?}) = {};", pat_pat, muta, current);
-                self.current = pat_pat;
-                self.visit_pat(pat);
-            },
-            PatKind::Lit(ref lit_expr) => {
-                let lit_expr_pat = self.next("lit_expr");
-                println!("Lit(ref {}) = {}", lit_expr_pat, current);
-                self.current = lit_expr_pat;
-                self.visit_expr(lit_expr);
-            },
-            PatKind::Range(ref start, ref end, end_kind) => {
-                let start_pat = self.next("start");
-                let end_pat = self.next("end");
-                println!(
-                    "Range(ref {}, ref {}, RangeEnd::{:?}) = {};",
-                    start_pat, end_pat, end_kind, current
-                );
-                self.current = start_pat;
-                walk_list!(self, visit_expr, start);
-                self.current = end_pat;
-                walk_list!(self, visit_expr, end);
-            },
-            PatKind::Slice(ref start, ref middle, ref end) => {
-                let start_pat = self.next("start");
-                let end_pat = self.next("end");
-                if let Some(ref middle) = middle {
-                    let middle_pat = self.next("middle");
-                    println!(
-                        "Slice(ref {}, Some(ref {}), ref {}) = {};",
-                        start_pat, middle_pat, end_pat, current
-                    );
-                    self.current = middle_pat;
-                    self.visit_pat(middle);
-                } else {
-                    println!("Slice(ref {}, None, ref {}) = {};", start_pat, end_pat, current);
-                }
-                println!("    if {}.len() == {};", start_pat, start.len());
-                for (i, pat) in start.iter().enumerate() {
-                    self.current = format!("{}[{}]", start_pat, i);
-                    self.visit_pat(pat);
-                }
-                println!("    if {}.len() == {};", end_pat, end.len());
-                for (i, pat) in end.iter().enumerate() {
-                    self.current = format!("{}[{}]", end_pat, i);
-                    self.visit_pat(pat);
-                }
-            },
-        }
-    }
-
-    fn visit_stmt(&mut self, s: &Stmt<'_>) {
-        print!("    if let StmtKind::");
-        let current = format!("{}.kind", self.current);
-        match s.kind {
-            // A local (let) binding:
-            StmtKind::Local(ref local) => {
-                let local_pat = self.next("local");
-                println!("Local(ref {}) = {};", local_pat, current);
-                if let Some(ref init) = local.init {
-                    let init_pat = self.next("init");
-                    println!("    if let Some(ref {}) = {}.init;", init_pat, local_pat);
-                    self.current = init_pat;
-                    self.visit_expr(init);
-                }
-                self.current = format!("{}.pat", local_pat);
-                self.visit_pat(&local.pat);
-            },
-            // An item binding:
-            StmtKind::Item(_) => {
-                println!("Item(item_id) = {};", current);
-            },
-
-            // Expr without trailing semi-colon (must have unit type):
-            StmtKind::Expr(ref e) => {
-                let e_pat = self.next("e");
-                println!("Expr(ref {}, _) = {}", e_pat, current);
-                self.current = e_pat;
-                self.visit_expr(e);
-            },
-
-            // Expr with trailing semi-colon (may have any type):
-            StmtKind::Semi(ref e) => {
-                let e_pat = self.next("e");
-                println!("Semi(ref {}, _) = {}", e_pat, current);
-                self.current = e_pat;
-                self.visit_expr(e);
-            },
-        }
-    }
-
-    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-        NestedVisitorMap::None
-    }
-}
-
-fn has_attr(sess: &Session, attrs: &[Attribute]) -> bool {
-    get_attr(sess, attrs, "author").count() > 0
-}
-
-#[must_use]
-fn desugaring_name(des: hir::MatchSource) -> String {
-    match des {
-        hir::MatchSource::ForLoopDesugar => "MatchSource::ForLoopDesugar".to_string(),
-        hir::MatchSource::TryDesugar => "MatchSource::TryDesugar".to_string(),
-        hir::MatchSource::WhileDesugar => "MatchSource::WhileDesugar".to_string(),
-        hir::MatchSource::WhileLetDesugar => "MatchSource::WhileLetDesugar".to_string(),
-        hir::MatchSource::Normal => "MatchSource::Normal".to_string(),
-        hir::MatchSource::IfLetDesugar { contains_else_clause } => format!(
-            "MatchSource::IfLetDesugar {{ contains_else_clause: {} }}",
-            contains_else_clause
-        ),
-        hir::MatchSource::IfLetGuardDesugar => "MatchSource::IfLetGuardDesugar".to_string(),
-        hir::MatchSource::AwaitDesugar => "MatchSource::AwaitDesugar".to_string(),
-    }
-}
-
-#[must_use]
-fn loop_desugaring_name(des: hir::LoopSource) -> &'static str {
-    match des {
-        hir::LoopSource::ForLoop => "LoopSource::ForLoop",
-        hir::LoopSource::Loop => "LoopSource::Loop",
-        hir::LoopSource::While => "LoopSource::While",
-        hir::LoopSource::WhileLet => "LoopSource::WhileLet",
-    }
-}
-
-fn print_path(path: &QPath<'_>, first: &mut bool) {
-    match *path {
-        QPath::Resolved(_, ref path) => {
-            for segment in path.segments {
-                if *first {
-                    *first = false;
-                } else {
-                    print!(", ");
-                }
-                print!("{:?}", segment.ident.as_str());
-            }
-        },
-        QPath::TypeRelative(ref ty, ref segment) => match ty.kind {
-            hir::TyKind::Path(ref inner_path) => {
-                print_path(inner_path, first);
-                if *first {
-                    *first = false;
-                } else {
-                    print!(", ");
-                }
-                print!("{:?}", segment.ident.as_str());
-            },
-            ref other => print!("/* unimplemented: {:?}*/", other),
-        },
-        QPath::LangItem(..) => panic!("print_path: called for lang item qpath"),
-    }
-}
diff --git a/clippy_utils/src/inspector.rs b/clippy_utils/src/inspector.rs
deleted file mode 100644
index b082bb6cfda..00000000000
--- a/clippy_utils/src/inspector.rs
+++ /dev/null
@@ -1,578 +0,0 @@
-//! checks for attributes
-
-use crate::{declare_clippy_lint, get_attr};
-use rustc_ast::ast::{Attribute, InlineAsmTemplatePiece};
-use rustc_hir as hir;
-use rustc_lint::{LateContext, LateLintPass, LintContext};
-use rustc_session::Session;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-
-declare_clippy_lint! {
-    /// **What it does:** Dumps every ast/hir node which has the `#[clippy::dump]`
-    /// attribute
-    ///
-    /// **Example:**
-    /// ```rust,ignore
-    /// #[clippy::dump]
-    /// extern crate foo;
-    /// ```
-    ///
-    /// prints
-    ///
-    /// ```text
-    /// item `foo`
-    /// visibility inherited from outer item
-    /// extern crate dylib source: "/path/to/foo.so"
-    /// ```
-    pub DEEP_CODE_INSPECTION,
-    internal_warn,
-    "helper to dump info about code"
-}
-
-declare_lint_pass!(DeepCodeInspector => [DEEP_CODE_INSPECTION]);
-
-impl<'tcx> LateLintPass<'tcx> for DeepCodeInspector {
-    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) {
-        if !has_attr(cx.sess(), &item.attrs) {
-            return;
-        }
-        print_item(cx, item);
-    }
-
-    fn check_impl_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::ImplItem<'_>) {
-        if !has_attr(cx.sess(), &item.attrs) {
-            return;
-        }
-        println!("impl item `{}`", item.ident.name);
-        match item.vis.node {
-            hir::VisibilityKind::Public => println!("public"),
-            hir::VisibilityKind::Crate(_) => println!("visible crate wide"),
-            hir::VisibilityKind::Restricted { ref path, .. } => println!(
-                "visible in module `{}`",
-                rustc_hir_pretty::to_string(rustc_hir_pretty::NO_ANN, |s| s.print_path(path, false))
-            ),
-            hir::VisibilityKind::Inherited => println!("visibility inherited from outer item"),
-        }
-        if item.defaultness.is_default() {
-            println!("default");
-        }
-        match item.kind {
-            hir::ImplItemKind::Const(_, body_id) => {
-                println!("associated constant");
-                print_expr(cx, &cx.tcx.hir().body(body_id).value, 1);
-            },
-            hir::ImplItemKind::Fn(..) => println!("method"),
-            hir::ImplItemKind::TyAlias(_) => println!("associated type"),
-        }
-    }
-    // fn check_trait_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx
-    // hir::TraitItem) {
-    // if !has_attr(&item.attrs) {
-    // return;
-    // }
-    // }
-    //
-    // fn check_variant(&mut self, cx: &LateContext<'tcx>, var: &'tcx
-    // hir::Variant, _:
-    // &hir::Generics) {
-    // if !has_attr(&var.node.attrs) {
-    // return;
-    // }
-    // }
-    //
-    // fn check_struct_field(&mut self, cx: &LateContext<'tcx>, field: &'tcx
-    // hir::StructField) {
-    // if !has_attr(&field.attrs) {
-    // return;
-    // }
-    // }
-    //
-
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
-        if !has_attr(cx.sess(), &expr.attrs) {
-            return;
-        }
-        print_expr(cx, expr, 0);
-    }
-
-    fn check_arm(&mut self, cx: &LateContext<'tcx>, arm: &'tcx hir::Arm<'_>) {
-        if !has_attr(cx.sess(), &arm.attrs) {
-            return;
-        }
-        print_pat(cx, &arm.pat, 1);
-        if let Some(ref guard) = arm.guard {
-            println!("guard:");
-            print_guard(cx, guard, 1);
-        }
-        println!("body:");
-        print_expr(cx, &arm.body, 1);
-    }
-
-    fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx hir::Stmt<'_>) {
-        if !has_attr(cx.sess(), stmt.kind.attrs(|id| cx.tcx.hir().item(id.id))) {
-            return;
-        }
-        match stmt.kind {
-            hir::StmtKind::Local(ref local) => {
-                println!("local variable of type {}", cx.typeck_results().node_type(local.hir_id));
-                println!("pattern:");
-                print_pat(cx, &local.pat, 0);
-                if let Some(ref e) = local.init {
-                    println!("init expression:");
-                    print_expr(cx, e, 0);
-                }
-            },
-            hir::StmtKind::Item(_) => println!("item decl"),
-            hir::StmtKind::Expr(ref e) | hir::StmtKind::Semi(ref e) => print_expr(cx, e, 0),
-        }
-    }
-    // fn check_foreign_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx
-    // hir::ForeignItem) {
-    // if !has_attr(&item.attrs) {
-    // return;
-    // }
-    // }
-    //
-}
-
-fn has_attr(sess: &Session, attrs: &[Attribute]) -> bool {
-    get_attr(sess, attrs, "dump").count() > 0
-}
-
-#[allow(clippy::similar_names)]
-#[allow(clippy::too_many_lines)]
-fn print_expr(cx: &LateContext<'_>, expr: &hir::Expr<'_>, indent: usize) {
-    let ind = "  ".repeat(indent);
-    println!("{}+", ind);
-    println!("{}ty: {}", ind, cx.typeck_results().expr_ty(expr));
-    println!(
-        "{}adjustments: {:?}",
-        ind,
-        cx.typeck_results().adjustments().get(expr.hir_id)
-    );
-    match expr.kind {
-        hir::ExprKind::Box(ref e) => {
-            println!("{}Box", ind);
-            print_expr(cx, e, indent + 1);
-        },
-        hir::ExprKind::Array(v) => {
-            println!("{}Array", ind);
-            for e in v {
-                print_expr(cx, e, indent + 1);
-            }
-        },
-        hir::ExprKind::Call(ref func, args) => {
-            println!("{}Call", ind);
-            println!("{}function:", ind);
-            print_expr(cx, func, indent + 1);
-            println!("{}arguments:", ind);
-            for arg in args {
-                print_expr(cx, arg, indent + 1);
-            }
-        },
-        hir::ExprKind::MethodCall(ref path, _, args, _) => {
-            println!("{}MethodCall", ind);
-            println!("{}method name: {}", ind, path.ident.name);
-            for arg in args {
-                print_expr(cx, arg, indent + 1);
-            }
-        },
-        hir::ExprKind::Tup(v) => {
-            println!("{}Tup", ind);
-            for e in v {
-                print_expr(cx, e, indent + 1);
-            }
-        },
-        hir::ExprKind::Binary(op, ref lhs, ref rhs) => {
-            println!("{}Binary", ind);
-            println!("{}op: {:?}", ind, op.node);
-            println!("{}lhs:", ind);
-            print_expr(cx, lhs, indent + 1);
-            println!("{}rhs:", ind);
-            print_expr(cx, rhs, indent + 1);
-        },
-        hir::ExprKind::Unary(op, ref inner) => {
-            println!("{}Unary", ind);
-            println!("{}op: {:?}", ind, op);
-            print_expr(cx, inner, indent + 1);
-        },
-        hir::ExprKind::Lit(ref lit) => {
-            println!("{}Lit", ind);
-            println!("{}{:?}", ind, lit);
-        },
-        hir::ExprKind::Cast(ref e, ref target) => {
-            println!("{}Cast", ind);
-            print_expr(cx, e, indent + 1);
-            println!("{}target type: {:?}", ind, target);
-        },
-        hir::ExprKind::Type(ref e, ref target) => {
-            println!("{}Type", ind);
-            print_expr(cx, e, indent + 1);
-            println!("{}target type: {:?}", ind, target);
-        },
-        hir::ExprKind::Loop(..) => {
-            println!("{}Loop", ind);
-        },
-        hir::ExprKind::If(ref cond, _, ref else_opt) => {
-            println!("{}If", ind);
-            println!("{}condition:", ind);
-            print_expr(cx, cond, indent + 1);
-            if let Some(ref els) = *else_opt {
-                println!("{}else:", ind);
-                print_expr(cx, els, indent + 1);
-            }
-        },
-        hir::ExprKind::Match(ref cond, _, ref source) => {
-            println!("{}Match", ind);
-            println!("{}condition:", ind);
-            print_expr(cx, cond, indent + 1);
-            println!("{}source: {:?}", ind, source);
-        },
-        hir::ExprKind::Closure(ref clause, _, _, _, _) => {
-            println!("{}Closure", ind);
-            println!("{}clause: {:?}", ind, clause);
-        },
-        hir::ExprKind::Yield(ref sub, _) => {
-            println!("{}Yield", ind);
-            print_expr(cx, sub, indent + 1);
-        },
-        hir::ExprKind::Block(_, _) => {
-            println!("{}Block", ind);
-        },
-        hir::ExprKind::Assign(ref lhs, ref rhs, _) => {
-            println!("{}Assign", ind);
-            println!("{}lhs:", ind);
-            print_expr(cx, lhs, indent + 1);
-            println!("{}rhs:", ind);
-            print_expr(cx, rhs, indent + 1);
-        },
-        hir::ExprKind::AssignOp(ref binop, ref lhs, ref rhs) => {
-            println!("{}AssignOp", ind);
-            println!("{}op: {:?}", ind, binop.node);
-            println!("{}lhs:", ind);
-            print_expr(cx, lhs, indent + 1);
-            println!("{}rhs:", ind);
-            print_expr(cx, rhs, indent + 1);
-        },
-        hir::ExprKind::Field(ref e, ident) => {
-            println!("{}Field", ind);
-            println!("{}field name: {}", ind, ident.name);
-            println!("{}struct expr:", ind);
-            print_expr(cx, e, indent + 1);
-        },
-        hir::ExprKind::Index(ref arr, ref idx) => {
-            println!("{}Index", ind);
-            println!("{}array expr:", ind);
-            print_expr(cx, arr, indent + 1);
-            println!("{}index expr:", ind);
-            print_expr(cx, idx, indent + 1);
-        },
-        hir::ExprKind::Path(hir::QPath::Resolved(ref ty, ref path)) => {
-            println!("{}Resolved Path, {:?}", ind, ty);
-            println!("{}path: {:?}", ind, path);
-        },
-        hir::ExprKind::Path(hir::QPath::TypeRelative(ref ty, ref seg)) => {
-            println!("{}Relative Path, {:?}", ind, ty);
-            println!("{}seg: {:?}", ind, seg);
-        },
-        hir::ExprKind::Path(hir::QPath::LangItem(lang_item, ..)) => {
-            println!("{}Lang Item Path, {:?}", ind, lang_item.name());
-        },
-        hir::ExprKind::AddrOf(kind, ref muta, ref e) => {
-            println!("{}AddrOf", ind);
-            println!("kind: {:?}", kind);
-            println!("mutability: {:?}", muta);
-            print_expr(cx, e, indent + 1);
-        },
-        hir::ExprKind::Break(_, ref e) => {
-            println!("{}Break", ind);
-            if let Some(ref e) = *e {
-                print_expr(cx, e, indent + 1);
-            }
-        },
-        hir::ExprKind::Continue(_) => println!("{}Again", ind),
-        hir::ExprKind::Ret(ref e) => {
-            println!("{}Ret", ind);
-            if let Some(ref e) = *e {
-                print_expr(cx, e, indent + 1);
-            }
-        },
-        hir::ExprKind::InlineAsm(ref asm) => {
-            println!("{}InlineAsm", ind);
-            println!("{}template: {}", ind, InlineAsmTemplatePiece::to_string(asm.template));
-            println!("{}options: {:?}", ind, asm.options);
-            println!("{}operands:", ind);
-            for (op, _op_sp) in asm.operands {
-                match op {
-                    hir::InlineAsmOperand::In { expr, .. }
-                    | hir::InlineAsmOperand::InOut { expr, .. }
-                    | hir::InlineAsmOperand::Const { expr }
-                    | hir::InlineAsmOperand::Sym { expr } => print_expr(cx, expr, indent + 1),
-                    hir::InlineAsmOperand::Out { expr, .. } => {
-                        if let Some(expr) = expr {
-                            print_expr(cx, expr, indent + 1);
-                        }
-                    },
-                    hir::InlineAsmOperand::SplitInOut { in_expr, out_expr, .. } => {
-                        print_expr(cx, in_expr, indent + 1);
-                        if let Some(out_expr) = out_expr {
-                            print_expr(cx, out_expr, indent + 1);
-                        }
-                    },
-                }
-            }
-        },
-        hir::ExprKind::LlvmInlineAsm(ref asm) => {
-            let inputs = &asm.inputs_exprs;
-            let outputs = &asm.outputs_exprs;
-            println!("{}LlvmInlineAsm", ind);
-            println!("{}inputs:", ind);
-            for e in inputs.iter() {
-                print_expr(cx, e, indent + 1);
-            }
-            println!("{}outputs:", ind);
-            for e in outputs.iter() {
-                print_expr(cx, e, indent + 1);
-            }
-        },
-        hir::ExprKind::Struct(ref path, fields, ref base) => {
-            println!("{}Struct", ind);
-            println!("{}path: {:?}", ind, path);
-            for field in fields {
-                println!("{}field \"{}\":", ind, field.ident.name);
-                print_expr(cx, &field.expr, indent + 1);
-            }
-            if let Some(ref base) = *base {
-                println!("{}base:", ind);
-                print_expr(cx, base, indent + 1);
-            }
-        },
-        hir::ExprKind::ConstBlock(ref anon_const) => {
-            println!("{}ConstBlock", ind);
-            println!("{}anon_const:", ind);
-            print_expr(cx, &cx.tcx.hir().body(anon_const.body).value, indent + 1);
-        },
-        hir::ExprKind::Repeat(ref val, ref anon_const) => {
-            println!("{}Repeat", ind);
-            println!("{}value:", ind);
-            print_expr(cx, val, indent + 1);
-            println!("{}repeat count:", ind);
-            print_expr(cx, &cx.tcx.hir().body(anon_const.body).value, indent + 1);
-        },
-        hir::ExprKind::Err => {
-            println!("{}Err", ind);
-        },
-        hir::ExprKind::DropTemps(ref e) => {
-            println!("{}DropTemps", ind);
-            print_expr(cx, e, indent + 1);
-        },
-    }
-}
-
-fn print_item(cx: &LateContext<'_>, item: &hir::Item<'_>) {
-    let did = cx.tcx.hir().local_def_id(item.hir_id);
-    println!("item `{}`", item.ident.name);
-    match item.vis.node {
-        hir::VisibilityKind::Public => println!("public"),
-        hir::VisibilityKind::Crate(_) => println!("visible crate wide"),
-        hir::VisibilityKind::Restricted { ref path, .. } => println!(
-            "visible in module `{}`",
-            rustc_hir_pretty::to_string(rustc_hir_pretty::NO_ANN, |s| s.print_path(path, false))
-        ),
-        hir::VisibilityKind::Inherited => println!("visibility inherited from outer item"),
-    }
-    match item.kind {
-        hir::ItemKind::ExternCrate(ref _renamed_from) => {
-            let def_id = cx.tcx.hir().local_def_id(item.hir_id);
-            if let Some(crate_id) = cx.tcx.extern_mod_stmt_cnum(def_id) {
-                let source = cx.tcx.used_crate_source(crate_id);
-                if let Some(ref src) = source.dylib {
-                    println!("extern crate dylib source: {:?}", src.0);
-                }
-                if let Some(ref src) = source.rlib {
-                    println!("extern crate rlib source: {:?}", src.0);
-                }
-            } else {
-                println!("weird extern crate without a crate id");
-            }
-        },
-        hir::ItemKind::Use(ref path, ref kind) => println!("{:?}, {:?}", path, kind),
-        hir::ItemKind::Static(..) => println!("static item of type {:#?}", cx.tcx.type_of(did)),
-        hir::ItemKind::Const(..) => println!("const item of type {:#?}", cx.tcx.type_of(did)),
-        hir::ItemKind::Fn(..) => {
-            let item_ty = cx.tcx.type_of(did);
-            println!("function of type {:#?}", item_ty);
-        },
-        hir::ItemKind::Mod(..) => println!("module"),
-        hir::ItemKind::ForeignMod { abi, .. } => println!("foreign module with abi: {}", abi),
-        hir::ItemKind::GlobalAsm(ref asm) => println!("global asm: {:?}", asm),
-        hir::ItemKind::TyAlias(..) => {
-            println!("type alias for {:?}", cx.tcx.type_of(did));
-        },
-        hir::ItemKind::OpaqueTy(..) => {
-            println!("existential type with real type {:?}", cx.tcx.type_of(did));
-        },
-        hir::ItemKind::Enum(..) => {
-            println!("enum definition of type {:?}", cx.tcx.type_of(did));
-        },
-        hir::ItemKind::Struct(..) => {
-            println!("struct definition of type {:?}", cx.tcx.type_of(did));
-        },
-        hir::ItemKind::Union(..) => {
-            println!("union definition of type {:?}", cx.tcx.type_of(did));
-        },
-        hir::ItemKind::Trait(..) => {
-            println!("trait decl");
-            if cx.tcx.trait_is_auto(did.to_def_id()) {
-                println!("trait is auto");
-            } else {
-                println!("trait is not auto");
-            }
-        },
-        hir::ItemKind::TraitAlias(..) => {
-            println!("trait alias");
-        },
-        hir::ItemKind::Impl(hir::Impl {
-            of_trait: Some(ref _trait_ref),
-            ..
-        }) => {
-            println!("trait impl");
-        },
-        hir::ItemKind::Impl(hir::Impl { of_trait: None, .. }) => {
-            println!("impl");
-        },
-    }
-}
-
-#[allow(clippy::similar_names)]
-#[allow(clippy::too_many_lines)]
-fn print_pat(cx: &LateContext<'_>, pat: &hir::Pat<'_>, indent: usize) {
-    let ind = "  ".repeat(indent);
-    println!("{}+", ind);
-    match pat.kind {
-        hir::PatKind::Wild => println!("{}Wild", ind),
-        hir::PatKind::Binding(ref mode, .., ident, ref inner) => {
-            println!("{}Binding", ind);
-            println!("{}mode: {:?}", ind, mode);
-            println!("{}name: {}", ind, ident.name);
-            if let Some(ref inner) = *inner {
-                println!("{}inner:", ind);
-                print_pat(cx, inner, indent + 1);
-            }
-        },
-        hir::PatKind::Or(fields) => {
-            println!("{}Or", ind);
-            for field in fields {
-                print_pat(cx, field, indent + 1);
-            }
-        },
-        hir::PatKind::Struct(ref path, fields, ignore) => {
-            println!("{}Struct", ind);
-            println!(
-                "{}name: {}",
-                ind,
-                rustc_hir_pretty::to_string(rustc_hir_pretty::NO_ANN, |s| s.print_qpath(path, false))
-            );
-            println!("{}ignore leftover fields: {}", ind, ignore);
-            println!("{}fields:", ind);
-            for field in fields {
-                println!("{}  field name: {}", ind, field.ident.name);
-                if field.is_shorthand {
-                    println!("{}  in shorthand notation", ind);
-                }
-                print_pat(cx, &field.pat, indent + 1);
-            }
-        },
-        hir::PatKind::TupleStruct(ref path, fields, opt_dots_position) => {
-            println!("{}TupleStruct", ind);
-            println!(
-                "{}path: {}",
-                ind,
-                rustc_hir_pretty::to_string(rustc_hir_pretty::NO_ANN, |s| s.print_qpath(path, false))
-            );
-            if let Some(dot_position) = opt_dots_position {
-                println!("{}dot position: {}", ind, dot_position);
-            }
-            for field in fields {
-                print_pat(cx, field, indent + 1);
-            }
-        },
-        hir::PatKind::Path(hir::QPath::Resolved(ref ty, ref path)) => {
-            println!("{}Resolved Path, {:?}", ind, ty);
-            println!("{}path: {:?}", ind, path);
-        },
-        hir::PatKind::Path(hir::QPath::TypeRelative(ref ty, ref seg)) => {
-            println!("{}Relative Path, {:?}", ind, ty);
-            println!("{}seg: {:?}", ind, seg);
-        },
-        hir::PatKind::Path(hir::QPath::LangItem(lang_item, ..)) => {
-            println!("{}Lang Item Path, {:?}", ind, lang_item.name());
-        },
-        hir::PatKind::Tuple(pats, opt_dots_position) => {
-            println!("{}Tuple", ind);
-            if let Some(dot_position) = opt_dots_position {
-                println!("{}dot position: {}", ind, dot_position);
-            }
-            for field in pats {
-                print_pat(cx, field, indent + 1);
-            }
-        },
-        hir::PatKind::Box(ref inner) => {
-            println!("{}Box", ind);
-            print_pat(cx, inner, indent + 1);
-        },
-        hir::PatKind::Ref(ref inner, ref muta) => {
-            println!("{}Ref", ind);
-            println!("{}mutability: {:?}", ind, muta);
-            print_pat(cx, inner, indent + 1);
-        },
-        hir::PatKind::Lit(ref e) => {
-            println!("{}Lit", ind);
-            print_expr(cx, e, indent + 1);
-        },
-        hir::PatKind::Range(ref l, ref r, ref range_end) => {
-            println!("{}Range", ind);
-            if let Some(expr) = l {
-                print_expr(cx, expr, indent + 1);
-            }
-            if let Some(expr) = r {
-                print_expr(cx, expr, indent + 1);
-            }
-            match *range_end {
-                hir::RangeEnd::Included => println!("{} end included", ind),
-                hir::RangeEnd::Excluded => println!("{} end excluded", ind),
-            }
-        },
-        hir::PatKind::Slice(first_pats, ref range, last_pats) => {
-            println!("{}Slice [a, b, ..i, y, z]", ind);
-            println!("[a, b]:");
-            for pat in first_pats {
-                print_pat(cx, pat, indent + 1);
-            }
-            println!("i:");
-            if let Some(ref pat) = *range {
-                print_pat(cx, pat, indent + 1);
-            }
-            println!("[y, z]:");
-            for pat in last_pats {
-                print_pat(cx, pat, indent + 1);
-            }
-        },
-    }
-}
-
-fn print_guard(cx: &LateContext<'_>, guard: &hir::Guard<'_>, indent: usize) {
-    let ind = "  ".repeat(indent);
-    println!("{}+", ind);
-    match guard {
-        hir::Guard::If(expr) => {
-            println!("{}If", ind);
-            print_expr(cx, expr, indent + 1);
-        },
-        hir::Guard::IfLet(pat, expr) => {
-            println!("{}IfLet", ind);
-            print_pat(cx, pat, indent + 1);
-            print_expr(cx, expr, indent + 1);
-        },
-    }
-}
diff --git a/clippy_utils/src/internal_lints.rs b/clippy_utils/src/internal_lints.rs
deleted file mode 100644
index bbfb60f11d3..00000000000
--- a/clippy_utils/src/internal_lints.rs
+++ /dev/null
@@ -1,1070 +0,0 @@
-use crate::consts::{constant_simple, Constant};
-use crate::{
-    declare_clippy_lint, is_expn_of, match_def_path, match_qpath, match_type, method_calls, path_to_res, paths,
-    run_lints, snippet, span_lint, span_lint_and_help, span_lint_and_sugg, SpanlessEq,
-};
-use if_chain::if_chain;
-use rustc_ast::ast::{Crate as AstCrate, ItemKind, LitKind, NodeId};
-use rustc_ast::visit::FnKind;
-use rustc_data_structures::fx::{FxHashMap, FxHashSet};
-use rustc_errors::Applicability;
-use rustc_hir as hir;
-use rustc_hir::def::{DefKind, Res};
-use rustc_hir::def_id::DefId;
-use rustc_hir::hir_id::CRATE_HIR_ID;
-use rustc_hir::intravisit::{NestedVisitorMap, Visitor};
-use rustc_hir::{
-    BinOpKind, Crate, Expr, ExprKind, HirId, Item, MutTy, Mutability, Node, Path, StmtKind, Ty, TyKind, UnOp,
-};
-use rustc_lint::{EarlyContext, EarlyLintPass, LateContext, LateLintPass};
-use rustc_middle::hir::map::Map;
-use rustc_middle::mir::interpret::ConstValue;
-use rustc_middle::ty;
-use rustc_session::{declare_lint_pass, declare_tool_lint, impl_lint_pass};
-use rustc_span::source_map::{Span, Spanned};
-use rustc_span::symbol::{Symbol, SymbolStr};
-use rustc_typeck::hir_ty_to_ty;
-
-use std::borrow::{Borrow, Cow};
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for various things we like to keep tidy in clippy.
-    ///
-    /// **Why is this bad?** We like to pretend we're an example of tidy code.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:** Wrong ordering of the util::paths constants.
-    pub CLIPPY_LINTS_INTERNAL,
-    internal,
-    "various things that will negatively affect your clippy experience"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Ensures every lint is associated to a `LintPass`.
-    ///
-    /// **Why is this bad?** The compiler only knows lints via a `LintPass`. Without
-    /// putting a lint to a `LintPass::get_lints()`'s return, the compiler will not
-    /// know the name of the lint.
-    ///
-    /// **Known problems:** Only checks for lints associated using the
-    /// `declare_lint_pass!`, `impl_lint_pass!`, and `lint_array!` macros.
-    ///
-    /// **Example:**
-    /// ```rust,ignore
-    /// declare_lint! { pub LINT_1, ... }
-    /// declare_lint! { pub LINT_2, ... }
-    /// declare_lint! { pub FORGOTTEN_LINT, ... }
-    /// // ...
-    /// declare_lint_pass!(Pass => [LINT_1, LINT_2]);
-    /// // missing FORGOTTEN_LINT
-    /// ```
-    pub LINT_WITHOUT_LINT_PASS,
-    internal,
-    "declaring a lint without associating it in a LintPass"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for calls to `cx.span_lint*` and suggests to use the `utils::*`
-    /// variant of the function.
-    ///
-    /// **Why is this bad?** The `utils::*` variants also add a link to the Clippy documentation to the
-    /// warning/error messages.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    /// Bad:
-    /// ```rust,ignore
-    /// cx.span_lint(LINT_NAME, "message");
-    /// ```
-    ///
-    /// Good:
-    /// ```rust,ignore
-    /// utils::span_lint(cx, LINT_NAME, "message");
-    /// ```
-    pub COMPILER_LINT_FUNCTIONS,
-    internal,
-    "usage of the lint functions of the compiler instead of the utils::* variant"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for calls to `cx.outer().expn_data()` and suggests to use
-    /// the `cx.outer_expn_data()`
-    ///
-    /// **Why is this bad?** `cx.outer_expn_data()` is faster and more concise.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    /// Bad:
-    /// ```rust,ignore
-    /// expr.span.ctxt().outer().expn_data()
-    /// ```
-    ///
-    /// Good:
-    /// ```rust,ignore
-    /// expr.span.ctxt().outer_expn_data()
-    /// ```
-    pub OUTER_EXPN_EXPN_DATA,
-    internal,
-    "using `cx.outer_expn().expn_data()` instead of `cx.outer_expn_data()`"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Not an actual lint. This lint is only meant for testing our customized internal compiler
-    /// error message by calling `panic`.
-    ///
-    /// **Why is this bad?** ICE in large quantities can damage your teeth
-    ///
-    /// **Known problems:** None
-    ///
-    /// **Example:**
-    /// Bad:
-    /// ```rust,ignore
-    /// 🍦🍦🍦🍦🍦
-    /// ```
-    pub PRODUCE_ICE,
-    internal,
-    "this message should not appear anywhere as we ICE before and don't emit the lint"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for cases of an auto-generated lint without an updated description,
-    /// i.e. `default lint description`.
-    ///
-    /// **Why is this bad?** Indicates that the lint is not finished.
-    ///
-    /// **Known problems:** None
-    ///
-    /// **Example:**
-    /// Bad:
-    /// ```rust,ignore
-    /// declare_lint! { pub COOL_LINT, nursery, "default lint description" }
-    /// ```
-    ///
-    /// Good:
-    /// ```rust,ignore
-    /// declare_lint! { pub COOL_LINT, nursery, "a great new lint" }
-    /// ```
-    pub DEFAULT_LINT,
-    internal,
-    "found 'default lint description' in a lint declaration"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Lints `span_lint_and_then` function calls, where the
-    /// closure argument has only one statement and that statement is a method
-    /// call to `span_suggestion`, `span_help`, `span_note` (using the same
-    /// span), `help` or `note`.
-    ///
-    /// These usages of `span_lint_and_then` should be replaced with one of the
-    /// wrapper functions `span_lint_and_sugg`, span_lint_and_help`, or
-    /// `span_lint_and_note`.
-    ///
-    /// **Why is this bad?** Using the wrapper `span_lint_and_*` functions, is more
-    /// convenient, readable and less error prone.
-    ///
-    /// **Known problems:** None
-    ///
-    /// *Example:**
-    /// Bad:
-    /// ```rust,ignore
-    /// span_lint_and_then(cx, TEST_LINT, expr.span, lint_msg, |diag| {
-    ///     diag.span_suggestion(
-    ///         expr.span,
-    ///         help_msg,
-    ///         sugg.to_string(),
-    ///         Applicability::MachineApplicable,
-    ///     );
-    /// });
-    /// span_lint_and_then(cx, TEST_LINT, expr.span, lint_msg, |diag| {
-    ///     diag.span_help(expr.span, help_msg);
-    /// });
-    /// span_lint_and_then(cx, TEST_LINT, expr.span, lint_msg, |diag| {
-    ///     diag.help(help_msg);
-    /// });
-    /// span_lint_and_then(cx, TEST_LINT, expr.span, lint_msg, |diag| {
-    ///     diag.span_note(expr.span, note_msg);
-    /// });
-    /// span_lint_and_then(cx, TEST_LINT, expr.span, lint_msg, |diag| {
-    ///     diag.note(note_msg);
-    /// });
-    /// ```
-    ///
-    /// Good:
-    /// ```rust,ignore
-    /// span_lint_and_sugg(
-    ///     cx,
-    ///     TEST_LINT,
-    ///     expr.span,
-    ///     lint_msg,
-    ///     help_msg,
-    ///     sugg.to_string(),
-    ///     Applicability::MachineApplicable,
-    /// );
-    /// span_lint_and_help(cx, TEST_LINT, expr.span, lint_msg, Some(expr.span), help_msg);
-    /// span_lint_and_help(cx, TEST_LINT, expr.span, lint_msg, None, help_msg);
-    /// span_lint_and_note(cx, TEST_LINT, expr.span, lint_msg, Some(expr.span), note_msg);
-    /// span_lint_and_note(cx, TEST_LINT, expr.span, lint_msg, None, note_msg);
-    /// ```
-    pub COLLAPSIBLE_SPAN_LINT_CALLS,
-    internal,
-    "found collapsible `span_lint_and_then` calls"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for calls to `utils::match_type()` on a type diagnostic item
-    /// and suggests to use `utils::is_type_diagnostic_item()` instead.
-    ///
-    /// **Why is this bad?** `utils::is_type_diagnostic_item()` does not require hardcoded paths.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    /// Bad:
-    /// ```rust,ignore
-    /// utils::match_type(cx, ty, &paths::VEC)
-    /// ```
-    ///
-    /// Good:
-    /// ```rust,ignore
-    /// utils::is_type_diagnostic_item(cx, ty, sym::vec_type)
-    /// ```
-    pub MATCH_TYPE_ON_DIAGNOSTIC_ITEM,
-    internal,
-    "using `utils::match_type()` instead of `utils::is_type_diagnostic_item()`"
-}
-
-declare_clippy_lint! {
-    /// **What it does:**
-    /// Checks the paths module for invalid paths.
-    ///
-    /// **Why is this bad?**
-    /// It indicates a bug in the code.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:** None.
-    pub INVALID_PATHS,
-    internal,
-    "invalid path"
-}
-
-declare_clippy_lint! {
-    /// **What it does:**
-    /// Checks for interning symbols that have already been pre-interned and defined as constants.
-    ///
-    /// **Why is this bad?**
-    /// It's faster and easier to use the symbol constant.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    /// Bad:
-    /// ```rust,ignore
-    /// let _ = sym!(f32);
-    /// ```
-    ///
-    /// Good:
-    /// ```rust,ignore
-    /// let _ = sym::f32;
-    /// ```
-    pub INTERNING_DEFINED_SYMBOL,
-    internal,
-    "interning a symbol that is pre-interned and defined as a constant"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for unnecessary conversion from Symbol to a string.
-    ///
-    /// **Why is this bad?** It's faster use symbols directly intead of strings.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    /// Bad:
-    /// ```rust,ignore
-    /// symbol.as_str() == "clippy";
-    /// ```
-    ///
-    /// Good:
-    /// ```rust,ignore
-    /// symbol == sym::clippy;
-    /// ```
-    pub UNNECESSARY_SYMBOL_STR,
-    internal,
-    "unnecessary conversion between Symbol and string"
-}
-
-declare_lint_pass!(ClippyLintsInternal => [CLIPPY_LINTS_INTERNAL]);
-
-impl EarlyLintPass for ClippyLintsInternal {
-    fn check_crate(&mut self, cx: &EarlyContext<'_>, krate: &AstCrate) {
-        if let Some(utils) = krate
-            .module
-            .items
-            .iter()
-            .find(|item| item.ident.name.as_str() == "utils")
-        {
-            if let ItemKind::Mod(ref utils_mod) = utils.kind {
-                if let Some(paths) = utils_mod.items.iter().find(|item| item.ident.name.as_str() == "paths") {
-                    if let ItemKind::Mod(ref paths_mod) = paths.kind {
-                        let mut last_name: Option<SymbolStr> = None;
-                        for item in &*paths_mod.items {
-                            let name = item.ident.as_str();
-                            if let Some(ref last_name) = last_name {
-                                if **last_name > *name {
-                                    span_lint(
-                                        cx,
-                                        CLIPPY_LINTS_INTERNAL,
-                                        item.span,
-                                        "this constant should be before the previous constant due to lexical \
-                                         ordering",
-                                    );
-                                }
-                            }
-                            last_name = Some(name);
-                        }
-                    }
-                }
-            }
-        }
-    }
-}
-
-#[derive(Clone, Debug, Default)]
-pub struct LintWithoutLintPass {
-    declared_lints: FxHashMap<Symbol, Span>,
-    registered_lints: FxHashSet<Symbol>,
-}
-
-impl_lint_pass!(LintWithoutLintPass => [DEFAULT_LINT, LINT_WITHOUT_LINT_PASS]);
-
-impl<'tcx> LateLintPass<'tcx> for LintWithoutLintPass {
-    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
-        if !run_lints(cx, &[DEFAULT_LINT], item.hir_id) {
-            return;
-        }
-
-        if let hir::ItemKind::Static(ref ty, Mutability::Not, body_id) = item.kind {
-            if is_lint_ref_type(cx, ty) {
-                let expr = &cx.tcx.hir().body(body_id).value;
-                if_chain! {
-                    if let ExprKind::AddrOf(_, _, ref inner_exp) = expr.kind;
-                    if let ExprKind::Struct(_, ref fields, _) = inner_exp.kind;
-                    let field = fields
-                        .iter()
-                        .find(|f| f.ident.as_str() == "desc")
-                        .expect("lints must have a description field");
-                    if let ExprKind::Lit(Spanned {
-                        node: LitKind::Str(ref sym, _),
-                        ..
-                    }) = field.expr.kind;
-                    if sym.as_str() == "default lint description";
-
-                    then {
-                        span_lint(
-                            cx,
-                            DEFAULT_LINT,
-                            item.span,
-                            &format!("the lint `{}` has the default lint description", item.ident.name),
-                        );
-                    }
-                }
-                self.declared_lints.insert(item.ident.name, item.span);
-            }
-        } else if is_expn_of(item.span, "impl_lint_pass").is_some()
-            || is_expn_of(item.span, "declare_lint_pass").is_some()
-        {
-            if let hir::ItemKind::Impl(hir::Impl {
-                of_trait: None,
-                items: ref impl_item_refs,
-                ..
-            }) = item.kind
-            {
-                let mut collector = LintCollector {
-                    output: &mut self.registered_lints,
-                    cx,
-                };
-                let body_id = cx.tcx.hir().body_owned_by(
-                    impl_item_refs
-                        .iter()
-                        .find(|iiref| iiref.ident.as_str() == "get_lints")
-                        .expect("LintPass needs to implement get_lints")
-                        .id
-                        .hir_id,
-                );
-                collector.visit_expr(&cx.tcx.hir().body(body_id).value);
-            }
-        }
-    }
-
-    fn check_crate_post(&mut self, cx: &LateContext<'tcx>, _: &'tcx Crate<'_>) {
-        if !run_lints(cx, &[LINT_WITHOUT_LINT_PASS], CRATE_HIR_ID) {
-            return;
-        }
-
-        for (lint_name, &lint_span) in &self.declared_lints {
-            // When using the `declare_tool_lint!` macro, the original `lint_span`'s
-            // file points to "<rustc macros>".
-            // `compiletest-rs` thinks that's an error in a different file and
-            // just ignores it. This causes the test in compile-fail/lint_pass
-            // not able to capture the error.
-            // Therefore, we need to climb the macro expansion tree and find the
-            // actual span that invoked `declare_tool_lint!`:
-            let lint_span = lint_span.ctxt().outer_expn_data().call_site;
-
-            if !self.registered_lints.contains(lint_name) {
-                span_lint(
-                    cx,
-                    LINT_WITHOUT_LINT_PASS,
-                    lint_span,
-                    &format!("the lint `{}` is not added to any `LintPass`", lint_name),
-                );
-            }
-        }
-    }
-}
-
-fn is_lint_ref_type<'tcx>(cx: &LateContext<'tcx>, ty: &Ty<'_>) -> bool {
-    if let TyKind::Rptr(
-        _,
-        MutTy {
-            ty: ref inner,
-            mutbl: Mutability::Not,
-        },
-    ) = ty.kind
-    {
-        if let TyKind::Path(ref path) = inner.kind {
-            if let Res::Def(DefKind::Struct, def_id) = cx.qpath_res(path, inner.hir_id) {
-                return match_def_path(cx, def_id, &paths::LINT);
-            }
-        }
-    }
-
-    false
-}
-
-struct LintCollector<'a, 'tcx> {
-    output: &'a mut FxHashSet<Symbol>,
-    cx: &'a LateContext<'tcx>,
-}
-
-impl<'a, 'tcx> Visitor<'tcx> for LintCollector<'a, 'tcx> {
-    type Map = Map<'tcx>;
-
-    fn visit_path(&mut self, path: &'tcx Path<'_>, _: HirId) {
-        if path.segments.len() == 1 {
-            self.output.insert(path.segments[0].ident.name);
-        }
-    }
-
-    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-        NestedVisitorMap::All(self.cx.tcx.hir())
-    }
-}
-
-#[derive(Clone, Default)]
-pub struct CompilerLintFunctions {
-    map: FxHashMap<&'static str, &'static str>,
-}
-
-impl CompilerLintFunctions {
-    #[must_use]
-    pub fn new() -> Self {
-        let mut map = FxHashMap::default();
-        map.insert("span_lint", "utils::span_lint");
-        map.insert("struct_span_lint", "utils::span_lint");
-        map.insert("lint", "utils::span_lint");
-        map.insert("span_lint_note", "utils::span_lint_and_note");
-        map.insert("span_lint_help", "utils::span_lint_and_help");
-        Self { map }
-    }
-}
-
-impl_lint_pass!(CompilerLintFunctions => [COMPILER_LINT_FUNCTIONS]);
-
-impl<'tcx> LateLintPass<'tcx> for CompilerLintFunctions {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if !run_lints(cx, &[COMPILER_LINT_FUNCTIONS], expr.hir_id) {
-            return;
-        }
-
-        if_chain! {
-            if let ExprKind::MethodCall(ref path, _, ref args, _) = expr.kind;
-            let fn_name = path.ident;
-            if let Some(sugg) = self.map.get(&*fn_name.as_str());
-            let ty = cx.typeck_results().expr_ty(&args[0]).peel_refs();
-            if match_type(cx, ty, &paths::EARLY_CONTEXT)
-                || match_type(cx, ty, &paths::LATE_CONTEXT);
-            then {
-                span_lint_and_help(
-                    cx,
-                    COMPILER_LINT_FUNCTIONS,
-                    path.ident.span,
-                    "usage of a compiler lint function",
-                    None,
-                    &format!("please use the Clippy variant of this function: `{}`", sugg),
-                );
-            }
-        }
-    }
-}
-
-declare_lint_pass!(OuterExpnDataPass => [OUTER_EXPN_EXPN_DATA]);
-
-impl<'tcx> LateLintPass<'tcx> for OuterExpnDataPass {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
-        if !run_lints(cx, &[OUTER_EXPN_EXPN_DATA], expr.hir_id) {
-            return;
-        }
-
-        let (method_names, arg_lists, spans) = method_calls(expr, 2);
-        let method_names: Vec<SymbolStr> = method_names.iter().map(|s| s.as_str()).collect();
-        let method_names: Vec<&str> = method_names.iter().map(|s| &**s).collect();
-        if_chain! {
-            if let ["expn_data", "outer_expn"] = method_names.as_slice();
-            let args = arg_lists[1];
-            if args.len() == 1;
-            let self_arg = &args[0];
-            let self_ty = cx.typeck_results().expr_ty(self_arg).peel_refs();
-            if match_type(cx, self_ty, &paths::SYNTAX_CONTEXT);
-            then {
-                span_lint_and_sugg(
-                    cx,
-                    OUTER_EXPN_EXPN_DATA,
-                    spans[1].with_hi(expr.span.hi()),
-                    "usage of `outer_expn().expn_data()`",
-                    "try",
-                    "outer_expn_data()".to_string(),
-                    Applicability::MachineApplicable,
-                );
-            }
-        }
-    }
-}
-
-declare_lint_pass!(ProduceIce => [PRODUCE_ICE]);
-
-impl EarlyLintPass for ProduceIce {
-    fn check_fn(&mut self, _: &EarlyContext<'_>, fn_kind: FnKind<'_>, _: Span, _: NodeId) {
-        if is_trigger_fn(fn_kind) {
-            panic!("Would you like some help with that?");
-        }
-    }
-}
-
-fn is_trigger_fn(fn_kind: FnKind<'_>) -> bool {
-    match fn_kind {
-        FnKind::Fn(_, ident, ..) => ident.name.as_str() == "it_looks_like_you_are_trying_to_kill_clippy",
-        FnKind::Closure(..) => false,
-    }
-}
-
-declare_lint_pass!(CollapsibleCalls => [COLLAPSIBLE_SPAN_LINT_CALLS]);
-
-impl<'tcx> LateLintPass<'tcx> for CollapsibleCalls {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
-        if !run_lints(cx, &[COLLAPSIBLE_SPAN_LINT_CALLS], expr.hir_id) {
-            return;
-        }
-
-        if_chain! {
-            if let ExprKind::Call(ref func, ref and_then_args) = expr.kind;
-            if let ExprKind::Path(ref path) = func.kind;
-            if match_qpath(path, &["span_lint_and_then"]);
-            if and_then_args.len() == 5;
-            if let ExprKind::Closure(_, _, body_id, _, _) = &and_then_args[4].kind;
-            let body = cx.tcx.hir().body(*body_id);
-            if let ExprKind::Block(block, _) = &body.value.kind;
-            let stmts = &block.stmts;
-            if stmts.len() == 1 && block.expr.is_none();
-            if let StmtKind::Semi(only_expr) = &stmts[0].kind;
-            if let ExprKind::MethodCall(ref ps, _, ref span_call_args, _) = &only_expr.kind;
-            let and_then_snippets = get_and_then_snippets(cx, and_then_args);
-            let mut sle = SpanlessEq::new(cx).deny_side_effects();
-            then {
-                match &*ps.ident.as_str() {
-                    "span_suggestion" if sle.eq_expr(&and_then_args[2], &span_call_args[1]) => {
-                        suggest_suggestion(cx, expr, &and_then_snippets, &span_suggestion_snippets(cx, span_call_args));
-                    },
-                    "span_help" if sle.eq_expr(&and_then_args[2], &span_call_args[1]) => {
-                        let help_snippet = snippet(cx, span_call_args[2].span, r#""...""#);
-                        suggest_help(cx, expr, &and_then_snippets, help_snippet.borrow(), true);
-                    },
-                    "span_note" if sle.eq_expr(&and_then_args[2], &span_call_args[1]) => {
-                        let note_snippet = snippet(cx, span_call_args[2].span, r#""...""#);
-                        suggest_note(cx, expr, &and_then_snippets, note_snippet.borrow(), true);
-                    },
-                    "help" => {
-                        let help_snippet = snippet(cx, span_call_args[1].span, r#""...""#);
-                        suggest_help(cx, expr, &and_then_snippets, help_snippet.borrow(), false);
-                    }
-                    "note" => {
-                        let note_snippet = snippet(cx, span_call_args[1].span, r#""...""#);
-                        suggest_note(cx, expr, &and_then_snippets, note_snippet.borrow(), false);
-                    }
-                    _  => (),
-                }
-            }
-        }
-    }
-}
-
-struct AndThenSnippets<'a> {
-    cx: Cow<'a, str>,
-    lint: Cow<'a, str>,
-    span: Cow<'a, str>,
-    msg: Cow<'a, str>,
-}
-
-fn get_and_then_snippets<'a, 'hir>(cx: &LateContext<'_>, and_then_snippets: &'hir [Expr<'hir>]) -> AndThenSnippets<'a> {
-    let cx_snippet = snippet(cx, and_then_snippets[0].span, "cx");
-    let lint_snippet = snippet(cx, and_then_snippets[1].span, "..");
-    let span_snippet = snippet(cx, and_then_snippets[2].span, "span");
-    let msg_snippet = snippet(cx, and_then_snippets[3].span, r#""...""#);
-
-    AndThenSnippets {
-        cx: cx_snippet,
-        lint: lint_snippet,
-        span: span_snippet,
-        msg: msg_snippet,
-    }
-}
-
-struct SpanSuggestionSnippets<'a> {
-    help: Cow<'a, str>,
-    sugg: Cow<'a, str>,
-    applicability: Cow<'a, str>,
-}
-
-fn span_suggestion_snippets<'a, 'hir>(
-    cx: &LateContext<'_>,
-    span_call_args: &'hir [Expr<'hir>],
-) -> SpanSuggestionSnippets<'a> {
-    let help_snippet = snippet(cx, span_call_args[2].span, r#""...""#);
-    let sugg_snippet = snippet(cx, span_call_args[3].span, "..");
-    let applicability_snippet = snippet(cx, span_call_args[4].span, "Applicability::MachineApplicable");
-
-    SpanSuggestionSnippets {
-        help: help_snippet,
-        sugg: sugg_snippet,
-        applicability: applicability_snippet,
-    }
-}
-
-fn suggest_suggestion(
-    cx: &LateContext<'_>,
-    expr: &Expr<'_>,
-    and_then_snippets: &AndThenSnippets<'_>,
-    span_suggestion_snippets: &SpanSuggestionSnippets<'_>,
-) {
-    span_lint_and_sugg(
-        cx,
-        COLLAPSIBLE_SPAN_LINT_CALLS,
-        expr.span,
-        "this call is collapsible",
-        "collapse into",
-        format!(
-            "span_lint_and_sugg({}, {}, {}, {}, {}, {}, {})",
-            and_then_snippets.cx,
-            and_then_snippets.lint,
-            and_then_snippets.span,
-            and_then_snippets.msg,
-            span_suggestion_snippets.help,
-            span_suggestion_snippets.sugg,
-            span_suggestion_snippets.applicability
-        ),
-        Applicability::MachineApplicable,
-    );
-}
-
-fn suggest_help(
-    cx: &LateContext<'_>,
-    expr: &Expr<'_>,
-    and_then_snippets: &AndThenSnippets<'_>,
-    help: &str,
-    with_span: bool,
-) {
-    let option_span = if with_span {
-        format!("Some({})", and_then_snippets.span)
-    } else {
-        "None".to_string()
-    };
-
-    span_lint_and_sugg(
-        cx,
-        COLLAPSIBLE_SPAN_LINT_CALLS,
-        expr.span,
-        "this call is collapsible",
-        "collapse into",
-        format!(
-            "span_lint_and_help({}, {}, {}, {}, {}, {})",
-            and_then_snippets.cx,
-            and_then_snippets.lint,
-            and_then_snippets.span,
-            and_then_snippets.msg,
-            &option_span,
-            help
-        ),
-        Applicability::MachineApplicable,
-    );
-}
-
-fn suggest_note(
-    cx: &LateContext<'_>,
-    expr: &Expr<'_>,
-    and_then_snippets: &AndThenSnippets<'_>,
-    note: &str,
-    with_span: bool,
-) {
-    let note_span = if with_span {
-        format!("Some({})", and_then_snippets.span)
-    } else {
-        "None".to_string()
-    };
-
-    span_lint_and_sugg(
-        cx,
-        COLLAPSIBLE_SPAN_LINT_CALLS,
-        expr.span,
-        "this call is collspible",
-        "collapse into",
-        format!(
-            "span_lint_and_note({}, {}, {}, {}, {}, {})",
-            and_then_snippets.cx,
-            and_then_snippets.lint,
-            and_then_snippets.span,
-            and_then_snippets.msg,
-            note_span,
-            note
-        ),
-        Applicability::MachineApplicable,
-    );
-}
-
-declare_lint_pass!(MatchTypeOnDiagItem => [MATCH_TYPE_ON_DIAGNOSTIC_ITEM]);
-
-impl<'tcx> LateLintPass<'tcx> for MatchTypeOnDiagItem {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
-        if !run_lints(cx, &[MATCH_TYPE_ON_DIAGNOSTIC_ITEM], expr.hir_id) {
-            return;
-        }
-
-        if_chain! {
-            // Check if this is a call to utils::match_type()
-            if let ExprKind::Call(fn_path, [context, ty, ty_path]) = expr.kind;
-            if let ExprKind::Path(fn_qpath) = &fn_path.kind;
-            if match_qpath(&fn_qpath, &["utils", "match_type"]);
-            // Extract the path to the matched type
-            if let Some(segments) = path_to_matched_type(cx, ty_path);
-            let segments: Vec<&str> = segments.iter().map(|sym| &**sym).collect();
-            if let Some(ty_did) = path_to_res(cx, &segments[..]).opt_def_id();
-            // Check if the matched type is a diagnostic item
-            let diag_items = cx.tcx.diagnostic_items(ty_did.krate);
-            if let Some(item_name) = diag_items.iter().find_map(|(k, v)| if *v == ty_did { Some(k) } else { None });
-            then {
-                let cx_snippet = snippet(cx, context.span, "_");
-                let ty_snippet = snippet(cx, ty.span, "_");
-
-                span_lint_and_sugg(
-                    cx,
-                    MATCH_TYPE_ON_DIAGNOSTIC_ITEM,
-                    expr.span,
-                    "usage of `utils::match_type()` on a type diagnostic item",
-                    "try",
-                    format!("utils::is_type_diagnostic_item({}, {}, sym::{})", cx_snippet, ty_snippet, item_name),
-                    Applicability::MaybeIncorrect,
-                );
-            }
-        }
-    }
-}
-
-fn path_to_matched_type(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> Option<Vec<SymbolStr>> {
-    use rustc_hir::ItemKind;
-
-    match &expr.kind {
-        ExprKind::AddrOf(.., expr) => return path_to_matched_type(cx, expr),
-        ExprKind::Path(qpath) => match cx.qpath_res(qpath, expr.hir_id) {
-            Res::Local(hir_id) => {
-                let parent_id = cx.tcx.hir().get_parent_node(hir_id);
-                if let Some(Node::Local(local)) = cx.tcx.hir().find(parent_id) {
-                    if let Some(init) = local.init {
-                        return path_to_matched_type(cx, init);
-                    }
-                }
-            },
-            Res::Def(DefKind::Const | DefKind::Static, def_id) => {
-                if let Some(Node::Item(item)) = cx.tcx.hir().get_if_local(def_id) {
-                    if let ItemKind::Const(.., body_id) | ItemKind::Static(.., body_id) = item.kind {
-                        let body = cx.tcx.hir().body(body_id);
-                        return path_to_matched_type(cx, &body.value);
-                    }
-                }
-            },
-            _ => {},
-        },
-        ExprKind::Array(exprs) => {
-            let segments: Vec<SymbolStr> = exprs
-                .iter()
-                .filter_map(|expr| {
-                    if let ExprKind::Lit(lit) = &expr.kind {
-                        if let LitKind::Str(sym, _) = lit.node {
-                            return Some(sym.as_str());
-                        }
-                    }
-
-                    None
-                })
-                .collect();
-
-            if segments.len() == exprs.len() {
-                return Some(segments);
-            }
-        },
-        _ => {},
-    }
-
-    None
-}
-
-// This is not a complete resolver for paths. It works on all the paths currently used in the paths
-// module.  That's all it does and all it needs to do.
-pub fn check_path(cx: &LateContext<'_>, path: &[&str]) -> bool {
-    if path_to_res(cx, path) != Res::Err {
-        return true;
-    }
-
-    // Some implementations can't be found by `path_to_res`, particularly inherent
-    // implementations of native types. Check lang items.
-    let path_syms: Vec<_> = path.iter().map(|p| Symbol::intern(p)).collect();
-    let lang_items = cx.tcx.lang_items();
-    for item_def_id in lang_items.items().iter().flatten() {
-        let lang_item_path = cx.get_def_path(*item_def_id);
-        if path_syms.starts_with(&lang_item_path) {
-            if let [item] = &path_syms[lang_item_path.len()..] {
-                for child in cx.tcx.item_children(*item_def_id) {
-                    if child.ident.name == *item {
-                        return true;
-                    }
-                }
-            }
-        }
-    }
-
-    false
-}
-
-declare_lint_pass!(InvalidPaths => [INVALID_PATHS]);
-
-impl<'tcx> LateLintPass<'tcx> for InvalidPaths {
-    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
-        let local_def_id = &cx.tcx.parent_module(item.hir_id);
-        let mod_name = &cx.tcx.item_name(local_def_id.to_def_id());
-        if_chain! {
-            if mod_name.as_str() == "paths";
-            if let hir::ItemKind::Const(ty, body_id) = item.kind;
-            let ty = hir_ty_to_ty(cx.tcx, ty);
-            if let ty::Array(el_ty, _) = &ty.kind();
-            if let ty::Ref(_, el_ty, _) = &el_ty.kind();
-            if el_ty.is_str();
-            let body = cx.tcx.hir().body(body_id);
-            let typeck_results = cx.tcx.typeck_body(body_id);
-            if let Some(Constant::Vec(path)) = constant_simple(cx, typeck_results, &body.value);
-            let path: Vec<&str> = path.iter().map(|x| {
-                    if let Constant::Str(s) = x {
-                        s.as_str()
-                    } else {
-                        // We checked the type of the constant above
-                        unreachable!()
-                    }
-                }).collect();
-            if !check_path(cx, &path[..]);
-            then {
-                span_lint(cx, CLIPPY_LINTS_INTERNAL, item.span, "invalid path");
-            }
-        }
-    }
-}
-
-#[derive(Default)]
-pub struct InterningDefinedSymbol {
-    // Maps the symbol value to the constant DefId.
-    symbol_map: FxHashMap<u32, DefId>,
-}
-
-impl_lint_pass!(InterningDefinedSymbol => [INTERNING_DEFINED_SYMBOL, UNNECESSARY_SYMBOL_STR]);
-
-impl<'tcx> LateLintPass<'tcx> for InterningDefinedSymbol {
-    fn check_crate(&mut self, cx: &LateContext<'_>, _: &Crate<'_>) {
-        if !self.symbol_map.is_empty() {
-            return;
-        }
-
-        for &module in &[&paths::KW_MODULE, &paths::SYM_MODULE] {
-            if let Some(def_id) = path_to_res(cx, module).opt_def_id() {
-                for item in cx.tcx.item_children(def_id).iter() {
-                    if_chain! {
-                        if let Res::Def(DefKind::Const, item_def_id) = item.res;
-                        let ty = cx.tcx.type_of(item_def_id);
-                        if match_type(cx, ty, &paths::SYMBOL);
-                        if let Ok(ConstValue::Scalar(value)) = cx.tcx.const_eval_poly(item_def_id);
-                        if let Ok(value) = value.to_u32();
-                        then {
-                            self.symbol_map.insert(value, item_def_id);
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if_chain! {
-            if let ExprKind::Call(func, [arg]) = &expr.kind;
-            if let ty::FnDef(def_id, _) = cx.typeck_results().expr_ty(func).kind();
-            if match_def_path(cx, *def_id, &paths::SYMBOL_INTERN);
-            if let Some(Constant::Str(arg)) = constant_simple(cx, cx.typeck_results(), arg);
-            let value = Symbol::intern(&arg).as_u32();
-            if let Some(&def_id) = self.symbol_map.get(&value);
-            then {
-                span_lint_and_sugg(
-                    cx,
-                    INTERNING_DEFINED_SYMBOL,
-                    is_expn_of(expr.span, "sym").unwrap_or(expr.span),
-                    "interning a defined symbol",
-                    "try",
-                    cx.tcx.def_path_str(def_id),
-                    Applicability::MachineApplicable,
-                );
-            }
-        }
-        if let ExprKind::Binary(op, left, right) = expr.kind {
-            if matches!(op.node, BinOpKind::Eq | BinOpKind::Ne) {
-                let data = [
-                    (left, self.symbol_str_expr(left, cx)),
-                    (right, self.symbol_str_expr(right, cx)),
-                ];
-                match data {
-                    // both operands are a symbol string
-                    [(_, Some(left)), (_, Some(right))] => {
-                        span_lint_and_sugg(
-                            cx,
-                            UNNECESSARY_SYMBOL_STR,
-                            expr.span,
-                            "unnecessary `Symbol` to string conversion",
-                            "try",
-                            format!(
-                                "{} {} {}",
-                                left.as_symbol_snippet(cx),
-                                op.node.as_str(),
-                                right.as_symbol_snippet(cx),
-                            ),
-                            Applicability::MachineApplicable,
-                        );
-                    },
-                    // one of the operands is a symbol string
-                    [(expr, Some(symbol)), _] | [_, (expr, Some(symbol))] => {
-                        // creating an owned string for comparison
-                        if matches!(symbol, SymbolStrExpr::Expr { is_to_owned: true, .. }) {
-                            span_lint_and_sugg(
-                                cx,
-                                UNNECESSARY_SYMBOL_STR,
-                                expr.span,
-                                "unnecessary string allocation",
-                                "try",
-                                format!("{}.as_str()", symbol.as_symbol_snippet(cx)),
-                                Applicability::MachineApplicable,
-                            );
-                        }
-                    },
-                    // nothing found
-                    [(_, None), (_, None)] => {},
-                }
-            }
-        }
-    }
-}
-
-impl InterningDefinedSymbol {
-    fn symbol_str_expr<'tcx>(&self, expr: &'tcx Expr<'tcx>, cx: &LateContext<'tcx>) -> Option<SymbolStrExpr<'tcx>> {
-        static IDENT_STR_PATHS: &[&[&str]] = &[&paths::IDENT_AS_STR, &paths::TO_STRING_METHOD];
-        static SYMBOL_STR_PATHS: &[&[&str]] = &[
-            &paths::SYMBOL_AS_STR,
-            &paths::SYMBOL_TO_IDENT_STRING,
-            &paths::TO_STRING_METHOD,
-        ];
-        // SymbolStr might be de-referenced: `&*symbol.as_str()`
-        let call = if_chain! {
-            if let ExprKind::AddrOf(_, _, e) = expr.kind;
-            if let ExprKind::Unary(UnOp::Deref, e) = e.kind;
-            then { e } else { expr }
-        };
-        if_chain! {
-            // is a method call
-            if let ExprKind::MethodCall(_, _, [item], _) = call.kind;
-            if let Some(did) = cx.typeck_results().type_dependent_def_id(call.hir_id);
-            let ty = cx.typeck_results().expr_ty(item);
-            // ...on either an Ident or a Symbol
-            if let Some(is_ident) = if match_type(cx, ty, &paths::SYMBOL) {
-                Some(false)
-            } else if match_type(cx, ty, &paths::IDENT) {
-                Some(true)
-            } else {
-                None
-            };
-            // ...which converts it to a string
-            let paths = if is_ident { IDENT_STR_PATHS } else { SYMBOL_STR_PATHS };
-            if let Some(path) = paths.iter().find(|path| match_def_path(cx, did, path));
-            then {
-                let is_to_owned = path.last().unwrap().ends_with("string");
-                return Some(SymbolStrExpr::Expr {
-                    item,
-                    is_ident,
-                    is_to_owned,
-                });
-            }
-        }
-        // is a string constant
-        if let Some(Constant::Str(s)) = constant_simple(cx, cx.typeck_results(), expr) {
-            let value = Symbol::intern(&s).as_u32();
-            // ...which matches a symbol constant
-            if let Some(&def_id) = self.symbol_map.get(&value) {
-                return Some(SymbolStrExpr::Const(def_id));
-            }
-        }
-        None
-    }
-}
-
-enum SymbolStrExpr<'tcx> {
-    /// a string constant with a corresponding symbol constant
-    Const(DefId),
-    /// a "symbol to string" expression like `symbol.as_str()`
-    Expr {
-        /// part that evaluates to `Symbol` or `Ident`
-        item: &'tcx Expr<'tcx>,
-        is_ident: bool,
-        /// whether an owned `String` is created like `to_ident_string()`
-        is_to_owned: bool,
-    },
-}
-
-impl<'tcx> SymbolStrExpr<'tcx> {
-    /// Returns a snippet that evaluates to a `Symbol` and is const if possible
-    fn as_symbol_snippet(&self, cx: &LateContext<'_>) -> Cow<'tcx, str> {
-        match *self {
-            Self::Const(def_id) => cx.tcx.def_path_str(def_id).into(),
-            Self::Expr { item, is_ident, .. } => {
-                let mut snip = snippet(cx, item.span.source_callsite(), "..");
-                if is_ident {
-                    // get `Ident.name`
-                    snip.to_mut().push_str(".name");
-                }
-                snip
-            },
-        }
-    }
-}
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 0c955259672..5e0f0f084cb 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -30,7 +30,6 @@ pub mod sym_helper;
 #[allow(clippy::module_name_repetitions)]
 pub mod ast_utils;
 pub mod attrs;
-pub mod author;
 pub mod camel_case;
 pub mod comparisons;
 pub mod conf;
@@ -39,9 +38,6 @@ mod diagnostics;
 pub mod eager_or_lazy;
 pub mod higher;
 mod hir_utils;
-pub mod inspector;
-#[cfg(feature = "internal-lints")]
-pub mod internal_lints;
 pub mod numeric_literal;
 pub mod paths;
 pub mod ptr;
@@ -90,105 +86,6 @@ use smallvec::SmallVec;
 
 use crate::consts::{constant, Constant};
 
-/// Macro used to declare a Clippy lint.
-///
-/// Every lint declaration consists of 4 parts:
-///
-/// 1. The documentation, which is used for the website
-/// 2. The `LINT_NAME`. See [lint naming][lint_naming] on lint naming conventions.
-/// 3. The `lint_level`, which is a mapping from *one* of our lint groups to `Allow`, `Warn` or
-///    `Deny`. The lint level here has nothing to do with what lint groups the lint is a part of.
-/// 4. The `description` that contains a short explanation on what's wrong with code where the
-///    lint is triggered.
-///
-/// Currently the categories `style`, `correctness`, `complexity` and `perf` are enabled by default.
-/// As said in the README.md of this repository, if the lint level mapping changes, please update
-/// README.md.
-///
-/// # Example
-///
-/// ```
-/// #![feature(rustc_private)]
-/// extern crate rustc_session;
-/// use rustc_session::declare_tool_lint;
-/// use clippy_utils::declare_clippy_lint;
-///
-/// declare_clippy_lint! {
-///     /// **What it does:** Checks for ... (describe what the lint matches).
-///     ///
-///     /// **Why is this bad?** Supply the reason for linting the code.
-///     ///
-///     /// **Known problems:** None. (Or describe where it could go wrong.)
-///     ///
-///     /// **Example:**
-///     ///
-///     /// ```rust
-///     /// // Bad
-///     /// Insert a short example of code that triggers the lint
-///     ///
-///     /// // Good
-///     /// Insert a short example of improved code that doesn't trigger the lint
-///     /// ```
-///     pub LINT_NAME,
-///     pedantic,
-///     "description"
-/// }
-/// ```
-/// [lint_naming]: https://rust-lang.github.io/rfcs/0344-conventions-galore.html#lints
-#[macro_export]
-macro_rules! declare_clippy_lint {
-    { $(#[$attr:meta])* pub $name:tt, style, $description:tt } => {
-        declare_tool_lint! {
-            $(#[$attr])* pub clippy::$name, Warn, $description, report_in_external_macro: true
-        }
-    };
-    { $(#[$attr:meta])* pub $name:tt, correctness, $description:tt } => {
-        declare_tool_lint! {
-            $(#[$attr])* pub clippy::$name, Deny, $description, report_in_external_macro: true
-        }
-    };
-    { $(#[$attr:meta])* pub $name:tt, complexity, $description:tt } => {
-        declare_tool_lint! {
-            $(#[$attr])* pub clippy::$name, Warn, $description, report_in_external_macro: true
-        }
-    };
-    { $(#[$attr:meta])* pub $name:tt, perf, $description:tt } => {
-        declare_tool_lint! {
-            $(#[$attr])* pub clippy::$name, Warn, $description, report_in_external_macro: true
-        }
-    };
-    { $(#[$attr:meta])* pub $name:tt, pedantic, $description:tt } => {
-        declare_tool_lint! {
-            $(#[$attr])* pub clippy::$name, Allow, $description, report_in_external_macro: true
-        }
-    };
-    { $(#[$attr:meta])* pub $name:tt, restriction, $description:tt } => {
-        declare_tool_lint! {
-            $(#[$attr])* pub clippy::$name, Allow, $description, report_in_external_macro: true
-        }
-    };
-    { $(#[$attr:meta])* pub $name:tt, cargo, $description:tt } => {
-        declare_tool_lint! {
-            $(#[$attr])* pub clippy::$name, Allow, $description, report_in_external_macro: true
-        }
-    };
-    { $(#[$attr:meta])* pub $name:tt, nursery, $description:tt } => {
-        declare_tool_lint! {
-            $(#[$attr])* pub clippy::$name, Allow, $description, report_in_external_macro: true
-        }
-    };
-    { $(#[$attr:meta])* pub $name:tt, internal, $description:tt } => {
-        declare_tool_lint! {
-            $(#[$attr])* pub clippy::$name, Allow, $description, report_in_external_macro: true
-        }
-    };
-    { $(#[$attr:meta])* pub $name:tt, internal_warn, $description:tt } => {
-        declare_tool_lint! {
-            $(#[$attr])* pub clippy::$name, Warn, $description, report_in_external_macro: true
-        }
-    };
-}
-
 pub fn parse_msrv(msrv: &str, sess: Option<&Session>, span: Option<Span>) -> Option<RustcVersion> {
     if let Ok(version) = RustcVersion::parse(msrv) {
         return Some(version);
diff --git a/tests/ui-internal/custom_ice_message.stderr b/tests/ui-internal/custom_ice_message.stderr
index 29dee73c946..a1b8e2ee162 100644
--- a/tests/ui-internal/custom_ice_message.stderr
+++ b/tests/ui-internal/custom_ice_message.stderr
@@ -1,4 +1,4 @@
-thread 'rustc' panicked at 'Would you like some help with that?', clippy_utils/src/internal_lints.rs
+thread 'rustc' panicked at 'Would you like some help with that?', clippy_lints/src/utils/internal_lints.rs
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
 
 error: internal compiler error: unexpected panic
-- 
cgit 1.4.1-3-g733a5


From 8047458f404779c88a63e96dd4dd3599296c8d2e Mon Sep 17 00:00:00 2001
From: "Samuel E. Moelius III" <sam@moeli.us>
Date: Wed, 24 Feb 2021 06:12:27 -0500
Subject: Move conf.rs back into clippy_lints

---
 clippy_lints/src/lib.rs        |   1 +
 clippy_lints/src/utils/conf.rs | 257 +++++++++++++++++++++++++++++++++++++++++
 clippy_lints/src/utils/mod.rs  |   1 +
 clippy_utils/src/conf.rs       | 257 -----------------------------------------
 clippy_utils/src/lib.rs        |   2 -
 5 files changed, 259 insertions(+), 259 deletions(-)
 create mode 100644 clippy_lints/src/utils/conf.rs
 delete mode 100644 clippy_utils/src/conf.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index c8502e9cc74..5add8d44b42 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -4,6 +4,7 @@
 #![feature(box_syntax)]
 #![feature(drain_filter)]
 #![feature(in_band_lifetimes)]
+#![feature(once_cell)]
 #![feature(or_patterns)]
 #![feature(rustc_private)]
 #![feature(stmt_expr_attributes)]
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
new file mode 100644
index 00000000000..7d7b35c2168
--- /dev/null
+++ b/clippy_lints/src/utils/conf.rs
@@ -0,0 +1,257 @@
+//! Read configurations files.
+
+#![deny(clippy::missing_docs_in_private_items)]
+
+use rustc_ast::ast::{LitKind, MetaItemKind, NestedMetaItem};
+use rustc_span::source_map;
+use source_map::Span;
+use std::lazy::SyncLazy;
+use std::path::{Path, PathBuf};
+use std::sync::Mutex;
+use std::{env, fmt, fs, io};
+
+/// Gets the configuration file from arguments.
+pub fn file_from_args(args: &[NestedMetaItem]) -> Result<Option<PathBuf>, (&'static str, Span)> {
+    for arg in args.iter().filter_map(NestedMetaItem::meta_item) {
+        if arg.has_name(sym!(conf_file)) {
+            return match arg.kind {
+                MetaItemKind::Word | MetaItemKind::List(_) => Err(("`conf_file` must be a named value", arg.span)),
+                MetaItemKind::NameValue(ref value) => {
+                    if let LitKind::Str(ref file, _) = value.kind {
+                        Ok(Some(file.to_string().into()))
+                    } else {
+                        Err(("`conf_file` value must be a string", value.span))
+                    }
+                },
+            };
+        }
+    }
+
+    Ok(None)
+}
+
+/// Error from reading a configuration file.
+#[derive(Debug)]
+pub enum Error {
+    /// An I/O error.
+    Io(io::Error),
+    /// Not valid toml or doesn't fit the expected config format
+    Toml(String),
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Io(err) => err.fmt(f),
+            Self::Toml(err) => err.fmt(f),
+        }
+    }
+}
+
+impl From<io::Error> for Error {
+    fn from(e: io::Error) -> Self {
+        Self::Io(e)
+    }
+}
+
+/// Vec of errors that might be collected during config toml parsing
+static ERRORS: SyncLazy<Mutex<Vec<Error>>> = SyncLazy::new(|| Mutex::new(Vec::new()));
+
+macro_rules! define_Conf {
+    ($(#[$doc:meta] ($config:ident, $config_str:literal: $Ty:ty, $default:expr),)+) => {
+        mod helpers {
+            use serde::Deserialize;
+            /// Type used to store lint configuration.
+            #[derive(Deserialize)]
+            #[serde(rename_all = "kebab-case", deny_unknown_fields)]
+            pub struct Conf {
+                $(
+                    #[$doc]
+                    #[serde(default = $config_str)]
+                    #[serde(with = $config_str)]
+                    pub $config: $Ty,
+                )+
+                #[allow(dead_code)]
+                #[serde(default)]
+                third_party: Option<::toml::Value>,
+            }
+
+            $(
+                mod $config {
+                    use serde::Deserialize;
+                    pub fn deserialize<'de, D: serde::Deserializer<'de>>(deserializer: D) -> Result<$Ty, D::Error> {
+                        use super::super::{ERRORS, Error};
+
+                        Ok(
+                            <$Ty>::deserialize(deserializer).unwrap_or_else(|e| {
+                                ERRORS
+                                    .lock()
+                                    .expect("no threading here")
+                                    .push(Error::Toml(e.to_string()));
+                                super::$config()
+                            })
+                        )
+                    }
+                }
+
+                #[must_use]
+                fn $config() -> $Ty {
+                    let x = $default;
+                    x
+                }
+            )+
+        }
+    };
+}
+
+pub use self::helpers::Conf;
+define_Conf! {
+    /// Lint: REDUNDANT_FIELD_NAMES, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN. The minimum rust version that the project supports
+    (msrv, "msrv": Option<String>, None),
+    /// Lint: BLACKLISTED_NAME. The list of blacklisted names to lint about. NB: `bar` is not here since it has legitimate uses
+    (blacklisted_names, "blacklisted_names": Vec<String>, ["foo", "baz", "quux"].iter().map(ToString::to_string).collect()),
+    /// Lint: COGNITIVE_COMPLEXITY. The maximum cognitive complexity a function can have
+    (cognitive_complexity_threshold, "cognitive_complexity_threshold": u64, 25),
+    /// DEPRECATED LINT: CYCLOMATIC_COMPLEXITY. Use the Cognitive Complexity lint instead.
+    (cyclomatic_complexity_threshold, "cyclomatic_complexity_threshold": Option<u64>, None),
+    /// Lint: DOC_MARKDOWN. The list of words this lint should not consider as identifiers needing ticks
+    (doc_valid_idents, "doc_valid_idents": Vec<String>, [
+        "KiB", "MiB", "GiB", "TiB", "PiB", "EiB",
+        "DirectX",
+        "ECMAScript",
+        "GPLv2", "GPLv3",
+        "GitHub", "GitLab",
+        "IPv4", "IPv6",
+        "ClojureScript", "CoffeeScript", "JavaScript", "PureScript", "TypeScript",
+        "NaN", "NaNs",
+        "OAuth", "GraphQL",
+        "OCaml",
+        "OpenGL", "OpenMP", "OpenSSH", "OpenSSL", "OpenStreetMap",
+        "WebGL",
+        "TensorFlow",
+        "TrueType",
+        "iOS", "macOS",
+        "TeX", "LaTeX", "BibTeX", "BibLaTeX",
+        "MinGW",
+        "CamelCase",
+    ].iter().map(ToString::to_string).collect()),
+    /// Lint: TOO_MANY_ARGUMENTS. The maximum number of argument a function or method can have
+    (too_many_arguments_threshold, "too_many_arguments_threshold": u64, 7),
+    /// Lint: TYPE_COMPLEXITY. The maximum complexity a type can have
+    (type_complexity_threshold, "type_complexity_threshold": u64, 250),
+    /// Lint: MANY_SINGLE_CHAR_NAMES. The maximum number of single char bindings a scope may have
+    (single_char_binding_names_threshold, "single_char_binding_names_threshold": u64, 4),
+    /// Lint: BOXED_LOCAL, USELESS_VEC. The maximum size of objects (in bytes) that will be linted. Larger objects are ok on the heap
+    (too_large_for_stack, "too_large_for_stack": u64, 200),
+    /// Lint: ENUM_VARIANT_NAMES. The minimum number of enum variants for the lints about variant names to trigger
+    (enum_variant_name_threshold, "enum_variant_name_threshold": u64, 3),
+    /// Lint: LARGE_ENUM_VARIANT. The maximum size of a enum's variant to avoid box suggestion
+    (enum_variant_size_threshold, "enum_variant_size_threshold": u64, 200),
+    /// Lint: VERBOSE_BIT_MASK. The maximum allowed size of a bit mask before suggesting to use 'trailing_zeros'
+    (verbose_bit_mask_threshold, "verbose_bit_mask_threshold": u64, 1),
+    /// Lint: DECIMAL_LITERAL_REPRESENTATION. The lower bound for linting decimal literals
+    (literal_representation_threshold, "literal_representation_threshold": u64, 16384),
+    /// Lint: TRIVIALLY_COPY_PASS_BY_REF. The maximum size (in bytes) to consider a `Copy` type for passing by value instead of by reference.
+    (trivial_copy_size_limit, "trivial_copy_size_limit": Option<u64>, None),
+    /// Lint: LARGE_TYPE_PASS_BY_MOVE. The minimum size (in bytes) to consider a type for passing by reference instead of by value.
+    (pass_by_value_size_limit, "pass_by_value_size_limit": u64, 256),
+    /// Lint: TOO_MANY_LINES. The maximum number of lines a function or method can have
+    (too_many_lines_threshold, "too_many_lines_threshold": u64, 100),
+    /// Lint: LARGE_STACK_ARRAYS, LARGE_CONST_ARRAYS. The maximum allowed size for arrays on the stack
+    (array_size_threshold, "array_size_threshold": u64, 512_000),
+    /// Lint: VEC_BOX. The size of the boxed type in bytes, where boxing in a `Vec` is allowed
+    (vec_box_size_threshold, "vec_box_size_threshold": u64, 4096),
+    /// Lint: TYPE_REPETITION_IN_BOUNDS. The maximum number of bounds a trait can have to be linted
+    (max_trait_bounds, "max_trait_bounds": u64, 3),
+    /// Lint: STRUCT_EXCESSIVE_BOOLS. The maximum number of bools a struct can have
+    (max_struct_bools, "max_struct_bools": u64, 3),
+    /// Lint: FN_PARAMS_EXCESSIVE_BOOLS. The maximum number of bools function parameters can have
+    (max_fn_params_bools, "max_fn_params_bools": u64, 3),
+    /// Lint: WILDCARD_IMPORTS. Whether to allow certain wildcard imports (prelude, super in tests).
+    (warn_on_all_wildcard_imports, "warn_on_all_wildcard_imports": bool, false),
+    /// Lint: DISALLOWED_METHOD. The list of disallowed methods, written as fully qualified paths.
+    (disallowed_methods, "disallowed_methods": Vec<String>, Vec::<String>::new()),
+    /// Lint: UNREADABLE_LITERAL. Should the fraction of a decimal be linted to include separators.
+    (unreadable_literal_lint_fractions, "unreadable_literal_lint_fractions": bool, true),
+    /// Lint: _CARGO_COMMON_METADATA. For internal testing only, ignores the current `publish` settings in the Cargo manifest.
+    (cargo_ignore_publish, "cargo_ignore_publish": bool, false),
+}
+
+impl Default for Conf {
+    #[must_use]
+    fn default() -> Self {
+        toml::from_str("").expect("we never error on empty config files")
+    }
+}
+
+/// Search for the configuration file.
+pub fn lookup_conf_file() -> io::Result<Option<PathBuf>> {
+    /// Possible filename to search for.
+    const CONFIG_FILE_NAMES: [&str; 2] = [".clippy.toml", "clippy.toml"];
+
+    // Start looking for a config file in CLIPPY_CONF_DIR, or failing that, CARGO_MANIFEST_DIR.
+    // If neither of those exist, use ".".
+    let mut current = env::var_os("CLIPPY_CONF_DIR")
+        .or_else(|| env::var_os("CARGO_MANIFEST_DIR"))
+        .map_or_else(|| PathBuf::from("."), PathBuf::from);
+    loop {
+        for config_file_name in &CONFIG_FILE_NAMES {
+            let config_file = current.join(config_file_name);
+            match fs::metadata(&config_file) {
+                // Only return if it's a file to handle the unlikely situation of a directory named
+                // `clippy.toml`.
+                Ok(ref md) if !md.is_dir() => return Ok(Some(config_file)),
+                // Return the error if it's something other than `NotFound`; otherwise we didn't
+                // find the project file yet, and continue searching.
+                Err(e) if e.kind() != io::ErrorKind::NotFound => return Err(e),
+                _ => {},
+            }
+        }
+
+        // If the current directory has no parent, we're done searching.
+        if !current.pop() {
+            return Ok(None);
+        }
+    }
+}
+
+/// Produces a `Conf` filled with the default values and forwards the errors
+///
+/// Used internally for convenience
+fn default(errors: Vec<Error>) -> (Conf, Vec<Error>) {
+    (Conf::default(), errors)
+}
+
+/// Read the `toml` configuration file.
+///
+/// In case of error, the function tries to continue as much as possible.
+pub fn read(path: &Path) -> (Conf, Vec<Error>) {
+    let content = match fs::read_to_string(path) {
+        Ok(content) => content,
+        Err(err) => return default(vec![err.into()]),
+    };
+
+    assert!(ERRORS.lock().expect("no threading -> mutex always safe").is_empty());
+    match toml::from_str(&content) {
+        Ok(toml) => {
+            let mut errors = ERRORS.lock().expect("no threading -> mutex always safe").split_off(0);
+
+            let toml_ref: &Conf = &toml;
+
+            let cyc_field: Option<u64> = toml_ref.cyclomatic_complexity_threshold;
+
+            if cyc_field.is_some() {
+                let cyc_err = "found deprecated field `cyclomatic-complexity-threshold`. Please use `cognitive-complexity-threshold` instead.".to_string();
+                errors.push(Error::Toml(cyc_err));
+            }
+
+            (toml, errors)
+        },
+        Err(e) => {
+            let mut errors = ERRORS.lock().expect("no threading -> mutex always safe").split_off(0);
+            errors.push(Error::Toml(e.to_string()));
+
+            default(errors)
+        },
+    }
+}
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index 68ab8161e20..be9a07f8d7c 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -1,4 +1,5 @@
 pub mod author;
+pub mod conf;
 pub mod inspector;
 #[cfg(feature = "internal-lints")]
 pub mod internal_lints;
diff --git a/clippy_utils/src/conf.rs b/clippy_utils/src/conf.rs
deleted file mode 100644
index 7d7b35c2168..00000000000
--- a/clippy_utils/src/conf.rs
+++ /dev/null
@@ -1,257 +0,0 @@
-//! Read configurations files.
-
-#![deny(clippy::missing_docs_in_private_items)]
-
-use rustc_ast::ast::{LitKind, MetaItemKind, NestedMetaItem};
-use rustc_span::source_map;
-use source_map::Span;
-use std::lazy::SyncLazy;
-use std::path::{Path, PathBuf};
-use std::sync::Mutex;
-use std::{env, fmt, fs, io};
-
-/// Gets the configuration file from arguments.
-pub fn file_from_args(args: &[NestedMetaItem]) -> Result<Option<PathBuf>, (&'static str, Span)> {
-    for arg in args.iter().filter_map(NestedMetaItem::meta_item) {
-        if arg.has_name(sym!(conf_file)) {
-            return match arg.kind {
-                MetaItemKind::Word | MetaItemKind::List(_) => Err(("`conf_file` must be a named value", arg.span)),
-                MetaItemKind::NameValue(ref value) => {
-                    if let LitKind::Str(ref file, _) = value.kind {
-                        Ok(Some(file.to_string().into()))
-                    } else {
-                        Err(("`conf_file` value must be a string", value.span))
-                    }
-                },
-            };
-        }
-    }
-
-    Ok(None)
-}
-
-/// Error from reading a configuration file.
-#[derive(Debug)]
-pub enum Error {
-    /// An I/O error.
-    Io(io::Error),
-    /// Not valid toml or doesn't fit the expected config format
-    Toml(String),
-}
-
-impl fmt::Display for Error {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Self::Io(err) => err.fmt(f),
-            Self::Toml(err) => err.fmt(f),
-        }
-    }
-}
-
-impl From<io::Error> for Error {
-    fn from(e: io::Error) -> Self {
-        Self::Io(e)
-    }
-}
-
-/// Vec of errors that might be collected during config toml parsing
-static ERRORS: SyncLazy<Mutex<Vec<Error>>> = SyncLazy::new(|| Mutex::new(Vec::new()));
-
-macro_rules! define_Conf {
-    ($(#[$doc:meta] ($config:ident, $config_str:literal: $Ty:ty, $default:expr),)+) => {
-        mod helpers {
-            use serde::Deserialize;
-            /// Type used to store lint configuration.
-            #[derive(Deserialize)]
-            #[serde(rename_all = "kebab-case", deny_unknown_fields)]
-            pub struct Conf {
-                $(
-                    #[$doc]
-                    #[serde(default = $config_str)]
-                    #[serde(with = $config_str)]
-                    pub $config: $Ty,
-                )+
-                #[allow(dead_code)]
-                #[serde(default)]
-                third_party: Option<::toml::Value>,
-            }
-
-            $(
-                mod $config {
-                    use serde::Deserialize;
-                    pub fn deserialize<'de, D: serde::Deserializer<'de>>(deserializer: D) -> Result<$Ty, D::Error> {
-                        use super::super::{ERRORS, Error};
-
-                        Ok(
-                            <$Ty>::deserialize(deserializer).unwrap_or_else(|e| {
-                                ERRORS
-                                    .lock()
-                                    .expect("no threading here")
-                                    .push(Error::Toml(e.to_string()));
-                                super::$config()
-                            })
-                        )
-                    }
-                }
-
-                #[must_use]
-                fn $config() -> $Ty {
-                    let x = $default;
-                    x
-                }
-            )+
-        }
-    };
-}
-
-pub use self::helpers::Conf;
-define_Conf! {
-    /// Lint: REDUNDANT_FIELD_NAMES, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN. The minimum rust version that the project supports
-    (msrv, "msrv": Option<String>, None),
-    /// Lint: BLACKLISTED_NAME. The list of blacklisted names to lint about. NB: `bar` is not here since it has legitimate uses
-    (blacklisted_names, "blacklisted_names": Vec<String>, ["foo", "baz", "quux"].iter().map(ToString::to_string).collect()),
-    /// Lint: COGNITIVE_COMPLEXITY. The maximum cognitive complexity a function can have
-    (cognitive_complexity_threshold, "cognitive_complexity_threshold": u64, 25),
-    /// DEPRECATED LINT: CYCLOMATIC_COMPLEXITY. Use the Cognitive Complexity lint instead.
-    (cyclomatic_complexity_threshold, "cyclomatic_complexity_threshold": Option<u64>, None),
-    /// Lint: DOC_MARKDOWN. The list of words this lint should not consider as identifiers needing ticks
-    (doc_valid_idents, "doc_valid_idents": Vec<String>, [
-        "KiB", "MiB", "GiB", "TiB", "PiB", "EiB",
-        "DirectX",
-        "ECMAScript",
-        "GPLv2", "GPLv3",
-        "GitHub", "GitLab",
-        "IPv4", "IPv6",
-        "ClojureScript", "CoffeeScript", "JavaScript", "PureScript", "TypeScript",
-        "NaN", "NaNs",
-        "OAuth", "GraphQL",
-        "OCaml",
-        "OpenGL", "OpenMP", "OpenSSH", "OpenSSL", "OpenStreetMap",
-        "WebGL",
-        "TensorFlow",
-        "TrueType",
-        "iOS", "macOS",
-        "TeX", "LaTeX", "BibTeX", "BibLaTeX",
-        "MinGW",
-        "CamelCase",
-    ].iter().map(ToString::to_string).collect()),
-    /// Lint: TOO_MANY_ARGUMENTS. The maximum number of argument a function or method can have
-    (too_many_arguments_threshold, "too_many_arguments_threshold": u64, 7),
-    /// Lint: TYPE_COMPLEXITY. The maximum complexity a type can have
-    (type_complexity_threshold, "type_complexity_threshold": u64, 250),
-    /// Lint: MANY_SINGLE_CHAR_NAMES. The maximum number of single char bindings a scope may have
-    (single_char_binding_names_threshold, "single_char_binding_names_threshold": u64, 4),
-    /// Lint: BOXED_LOCAL, USELESS_VEC. The maximum size of objects (in bytes) that will be linted. Larger objects are ok on the heap
-    (too_large_for_stack, "too_large_for_stack": u64, 200),
-    /// Lint: ENUM_VARIANT_NAMES. The minimum number of enum variants for the lints about variant names to trigger
-    (enum_variant_name_threshold, "enum_variant_name_threshold": u64, 3),
-    /// Lint: LARGE_ENUM_VARIANT. The maximum size of a enum's variant to avoid box suggestion
-    (enum_variant_size_threshold, "enum_variant_size_threshold": u64, 200),
-    /// Lint: VERBOSE_BIT_MASK. The maximum allowed size of a bit mask before suggesting to use 'trailing_zeros'
-    (verbose_bit_mask_threshold, "verbose_bit_mask_threshold": u64, 1),
-    /// Lint: DECIMAL_LITERAL_REPRESENTATION. The lower bound for linting decimal literals
-    (literal_representation_threshold, "literal_representation_threshold": u64, 16384),
-    /// Lint: TRIVIALLY_COPY_PASS_BY_REF. The maximum size (in bytes) to consider a `Copy` type for passing by value instead of by reference.
-    (trivial_copy_size_limit, "trivial_copy_size_limit": Option<u64>, None),
-    /// Lint: LARGE_TYPE_PASS_BY_MOVE. The minimum size (in bytes) to consider a type for passing by reference instead of by value.
-    (pass_by_value_size_limit, "pass_by_value_size_limit": u64, 256),
-    /// Lint: TOO_MANY_LINES. The maximum number of lines a function or method can have
-    (too_many_lines_threshold, "too_many_lines_threshold": u64, 100),
-    /// Lint: LARGE_STACK_ARRAYS, LARGE_CONST_ARRAYS. The maximum allowed size for arrays on the stack
-    (array_size_threshold, "array_size_threshold": u64, 512_000),
-    /// Lint: VEC_BOX. The size of the boxed type in bytes, where boxing in a `Vec` is allowed
-    (vec_box_size_threshold, "vec_box_size_threshold": u64, 4096),
-    /// Lint: TYPE_REPETITION_IN_BOUNDS. The maximum number of bounds a trait can have to be linted
-    (max_trait_bounds, "max_trait_bounds": u64, 3),
-    /// Lint: STRUCT_EXCESSIVE_BOOLS. The maximum number of bools a struct can have
-    (max_struct_bools, "max_struct_bools": u64, 3),
-    /// Lint: FN_PARAMS_EXCESSIVE_BOOLS. The maximum number of bools function parameters can have
-    (max_fn_params_bools, "max_fn_params_bools": u64, 3),
-    /// Lint: WILDCARD_IMPORTS. Whether to allow certain wildcard imports (prelude, super in tests).
-    (warn_on_all_wildcard_imports, "warn_on_all_wildcard_imports": bool, false),
-    /// Lint: DISALLOWED_METHOD. The list of disallowed methods, written as fully qualified paths.
-    (disallowed_methods, "disallowed_methods": Vec<String>, Vec::<String>::new()),
-    /// Lint: UNREADABLE_LITERAL. Should the fraction of a decimal be linted to include separators.
-    (unreadable_literal_lint_fractions, "unreadable_literal_lint_fractions": bool, true),
-    /// Lint: _CARGO_COMMON_METADATA. For internal testing only, ignores the current `publish` settings in the Cargo manifest.
-    (cargo_ignore_publish, "cargo_ignore_publish": bool, false),
-}
-
-impl Default for Conf {
-    #[must_use]
-    fn default() -> Self {
-        toml::from_str("").expect("we never error on empty config files")
-    }
-}
-
-/// Search for the configuration file.
-pub fn lookup_conf_file() -> io::Result<Option<PathBuf>> {
-    /// Possible filename to search for.
-    const CONFIG_FILE_NAMES: [&str; 2] = [".clippy.toml", "clippy.toml"];
-
-    // Start looking for a config file in CLIPPY_CONF_DIR, or failing that, CARGO_MANIFEST_DIR.
-    // If neither of those exist, use ".".
-    let mut current = env::var_os("CLIPPY_CONF_DIR")
-        .or_else(|| env::var_os("CARGO_MANIFEST_DIR"))
-        .map_or_else(|| PathBuf::from("."), PathBuf::from);
-    loop {
-        for config_file_name in &CONFIG_FILE_NAMES {
-            let config_file = current.join(config_file_name);
-            match fs::metadata(&config_file) {
-                // Only return if it's a file to handle the unlikely situation of a directory named
-                // `clippy.toml`.
-                Ok(ref md) if !md.is_dir() => return Ok(Some(config_file)),
-                // Return the error if it's something other than `NotFound`; otherwise we didn't
-                // find the project file yet, and continue searching.
-                Err(e) if e.kind() != io::ErrorKind::NotFound => return Err(e),
-                _ => {},
-            }
-        }
-
-        // If the current directory has no parent, we're done searching.
-        if !current.pop() {
-            return Ok(None);
-        }
-    }
-}
-
-/// Produces a `Conf` filled with the default values and forwards the errors
-///
-/// Used internally for convenience
-fn default(errors: Vec<Error>) -> (Conf, Vec<Error>) {
-    (Conf::default(), errors)
-}
-
-/// Read the `toml` configuration file.
-///
-/// In case of error, the function tries to continue as much as possible.
-pub fn read(path: &Path) -> (Conf, Vec<Error>) {
-    let content = match fs::read_to_string(path) {
-        Ok(content) => content,
-        Err(err) => return default(vec![err.into()]),
-    };
-
-    assert!(ERRORS.lock().expect("no threading -> mutex always safe").is_empty());
-    match toml::from_str(&content) {
-        Ok(toml) => {
-            let mut errors = ERRORS.lock().expect("no threading -> mutex always safe").split_off(0);
-
-            let toml_ref: &Conf = &toml;
-
-            let cyc_field: Option<u64> = toml_ref.cyclomatic_complexity_threshold;
-
-            if cyc_field.is_some() {
-                let cyc_err = "found deprecated field `cyclomatic-complexity-threshold`. Please use `cognitive-complexity-threshold` instead.".to_string();
-                errors.push(Error::Toml(cyc_err));
-            }
-
-            (toml, errors)
-        },
-        Err(e) => {
-            let mut errors = ERRORS.lock().expect("no threading -> mutex always safe").split_off(0);
-            errors.push(Error::Toml(e.to_string()));
-
-            default(errors)
-        },
-    }
-}
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 5e0f0f084cb..8e5cf5dc654 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -1,6 +1,5 @@
 #![feature(box_patterns)]
 #![feature(in_band_lifetimes)]
-#![feature(once_cell)]
 #![feature(or_patterns)]
 #![feature(rustc_private)]
 #![recursion_limit = "512"]
@@ -32,7 +31,6 @@ pub mod ast_utils;
 pub mod attrs;
 pub mod camel_case;
 pub mod comparisons;
-pub mod conf;
 pub mod consts;
 mod diagnostics;
 pub mod eager_or_lazy;
-- 
cgit 1.4.1-3-g733a5


From 9fe9d94abda8d2698d1dede6961007e0026760ea Mon Sep 17 00:00:00 2001
From: Marc Dominik Migge <marcmigge@gmx.net>
Date: Wed, 24 Feb 2021 13:31:04 +0100
Subject: Don't lint unit args if expression kind is path

---
 clippy_lints/src/types.rs            | 14 ++++--------
 tests/ui/unit_arg.rs                 |  5 +++++
 tests/ui/unit_arg.stderr             | 20 +++++++++---------
 tests/ui/unit_arg_expressions.rs     | 35 ------------------------------
 tests/ui/unit_arg_expressions.stderr | 41 ------------------------------------
 5 files changed, 19 insertions(+), 96 deletions(-)
 delete mode 100644 tests/ui/unit_arg_expressions.rs
 delete mode 100644 tests/ui/unit_arg_expressions.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs
index 7d0eea37bc0..77cde8b60c1 100644
--- a/clippy_lints/src/types.rs
+++ b/clippy_lints/src/types.rs
@@ -955,16 +955,10 @@ impl<'tcx> LateLintPass<'tcx> for UnitArg {
                     .iter()
                     .filter(|arg| {
                         if is_unit(cx.typeck_results().expr_ty(arg)) && !is_unit_literal(arg) {
-                            match &arg.kind {
-                                ExprKind::Block(..)
-                                | ExprKind::Call(..)
-                                | ExprKind::If(..)
-                                | ExprKind::MethodCall(..) => true,
-                                ExprKind::Match(..) => {
-                                    !matches!(&arg.kind, ExprKind::Match(.., MatchSource::TryDesugar))
-                                },
-                                _ => false,
-                            }
+                            !matches!(
+                                &arg.kind,
+                                ExprKind::Match(.., MatchSource::TryDesugar) | ExprKind::Path(..)
+                            )
                         } else {
                             false
                         }
diff --git a/tests/ui/unit_arg.rs b/tests/ui/unit_arg.rs
index cce543006d7..5ea2e5d65c5 100644
--- a/tests/ui/unit_arg.rs
+++ b/tests/ui/unit_arg.rs
@@ -27,6 +27,10 @@ impl Bar {
     }
 }
 
+fn baz<T: Debug>(t: T) {
+    foo(t);
+}
+
 fn bad() {
     foo({
         1;
@@ -73,6 +77,7 @@ fn ok() {
     question_mark();
     let named_unit_arg = ();
     foo(named_unit_arg);
+    baz(());
 }
 
 fn question_mark() -> Result<(), ()> {
diff --git a/tests/ui/unit_arg.stderr b/tests/ui/unit_arg.stderr
index 8e3f1811c65..b3fe9addb62 100644
--- a/tests/ui/unit_arg.stderr
+++ b/tests/ui/unit_arg.stderr
@@ -1,5 +1,5 @@
 error: passing a unit value to a function
-  --> $DIR/unit_arg.rs:31:5
+  --> $DIR/unit_arg.rs:35:5
    |
 LL | /     foo({
 LL | |         1;
@@ -20,7 +20,7 @@ LL |     foo(());
    |
 
 error: passing a unit value to a function
-  --> $DIR/unit_arg.rs:34:5
+  --> $DIR/unit_arg.rs:38:5
    |
 LL |     foo(foo(1));
    |     ^^^^^^^^^^^
@@ -32,7 +32,7 @@ LL |     foo(());
    |
 
 error: passing a unit value to a function
-  --> $DIR/unit_arg.rs:35:5
+  --> $DIR/unit_arg.rs:39:5
    |
 LL | /     foo({
 LL | |         foo(1);
@@ -54,7 +54,7 @@ LL |     foo(());
    |
 
 error: passing a unit value to a function
-  --> $DIR/unit_arg.rs:40:5
+  --> $DIR/unit_arg.rs:44:5
    |
 LL | /     b.bar({
 LL | |         1;
@@ -74,7 +74,7 @@ LL |     b.bar(());
    |
 
 error: passing unit values to a function
-  --> $DIR/unit_arg.rs:43:5
+  --> $DIR/unit_arg.rs:47:5
    |
 LL |     taking_multiple_units(foo(0), foo(1));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -87,7 +87,7 @@ LL |     taking_multiple_units((), ());
    |
 
 error: passing unit values to a function
-  --> $DIR/unit_arg.rs:44:5
+  --> $DIR/unit_arg.rs:48:5
    |
 LL | /     taking_multiple_units(foo(0), {
 LL | |         foo(1);
@@ -110,7 +110,7 @@ LL |     taking_multiple_units((), ());
    |
 
 error: passing unit values to a function
-  --> $DIR/unit_arg.rs:48:5
+  --> $DIR/unit_arg.rs:52:5
    |
 LL | /     taking_multiple_units(
 LL | |         {
@@ -140,7 +140,7 @@ LL |         foo(2);
  ...
 
 error: passing a unit value to a function
-  --> $DIR/unit_arg.rs:59:13
+  --> $DIR/unit_arg.rs:63:13
    |
 LL |     None.or(Some(foo(2)));
    |             ^^^^^^^^^^^^
@@ -154,7 +154,7 @@ LL |     });
    |
 
 error: passing a unit value to a function
-  --> $DIR/unit_arg.rs:62:5
+  --> $DIR/unit_arg.rs:66:5
    |
 LL |     foo(foo(()));
    |     ^^^^^^^^^^^^
@@ -166,7 +166,7 @@ LL |     foo(());
    |
 
 error: passing a unit value to a function
-  --> $DIR/unit_arg.rs:97:5
+  --> $DIR/unit_arg.rs:102:5
    |
 LL |     Some(foo(1))
    |     ^^^^^^^^^^^^
diff --git a/tests/ui/unit_arg_expressions.rs b/tests/ui/unit_arg_expressions.rs
deleted file mode 100644
index a6807cb2e97..00000000000
--- a/tests/ui/unit_arg_expressions.rs
+++ /dev/null
@@ -1,35 +0,0 @@
-#![warn(clippy::unit_arg)]
-#![allow(clippy::no_effect)]
-
-use std::fmt::Debug;
-
-fn foo<T: Debug>(t: T) {
-    println!("{:?}", t);
-}
-
-fn bad() {
-    foo(if true {
-        1;
-    });
-    foo(match Some(1) {
-        Some(_) => {
-            1;
-        },
-        None => {
-            0;
-        },
-    });
-}
-
-fn ok() {
-    foo(if true { 1 } else { 0 });
-    foo(match Some(1) {
-        Some(_) => 1,
-        None => 0,
-    });
-}
-
-fn main() {
-    bad();
-    ok();
-}
diff --git a/tests/ui/unit_arg_expressions.stderr b/tests/ui/unit_arg_expressions.stderr
deleted file mode 100644
index 9fb08106b72..00000000000
--- a/tests/ui/unit_arg_expressions.stderr
+++ /dev/null
@@ -1,41 +0,0 @@
-error: passing a unit value to a function
-  --> $DIR/unit_arg_expressions.rs:11:5
-   |
-LL | /     foo(if true {
-LL | |         1;
-LL | |     });
-   | |______^
-   |
-   = note: `-D clippy::unit-arg` implied by `-D warnings`
-help: move the expression in front of the call and replace it with the unit literal `()`
-   |
-LL |     if true {
-LL |         1;
-LL |     };
-LL |     foo(());
-   |
-
-error: passing a unit value to a function
-  --> $DIR/unit_arg_expressions.rs:14:5
-   |
-LL | /     foo(match Some(1) {
-LL | |         Some(_) => {
-LL | |             1;
-LL | |         },
-...  |
-LL | |         },
-LL | |     });
-   | |______^
-   |
-help: move the expression in front of the call and replace it with the unit literal `()`
-   |
-LL |     match Some(1) {
-LL |         Some(_) => {
-LL |             1;
-LL |         },
-LL |         None => {
-LL |             0;
- ...
-
-error: aborting due to 2 previous errors
-
-- 
cgit 1.4.1-3-g733a5


From 72e3335684d1f537cd6ed4ef62a93ec3a033a940 Mon Sep 17 00:00:00 2001
From: avitex <theavitex@gmail.com>
Date: Wed, 24 Feb 2021 15:04:00 +1100
Subject: Add OpenDNS to `doc-valid-idents`

---
 clippy_lints/src/utils/conf.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 7d7b35c2168..3ebca92f4cb 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -126,7 +126,7 @@ define_Conf! {
         "NaN", "NaNs",
         "OAuth", "GraphQL",
         "OCaml",
-        "OpenGL", "OpenMP", "OpenSSH", "OpenSSL", "OpenStreetMap",
+        "OpenGL", "OpenMP", "OpenSSH", "OpenSSL", "OpenStreetMap", "OpenDNS",
         "WebGL",
         "TensorFlow",
         "TrueType",
-- 
cgit 1.4.1-3-g733a5


From 59750dceb8bb7a743efc4b4a84c3ea79e31791a5 Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Wed, 24 Feb 2021 23:20:49 +0100
Subject: upper_case_acronyms: add optional aggressive mode and relax default

Moves the lint back from pedantic to style group.
The lint default now only warns on names that are completely capitalized, like "WORD"
and only if the name is longer than 2 chars (so that names where each of the letter represents a word are still distinguishable).
For example: FP (false positive) would still be "valid" and not warned about (but EOF would warn).

A "upper_case_acronyms_aggressive: true/false" config option was added that restores the original lint behaviour to warn
on any kind of camel case name that had more than one capital letter following another capital letter.
---
 clippy_lints/src/lib.rs                 |  5 +++--
 clippy_lints/src/upper_case_acronyms.rs | 40 ++++++++++++++++++++++++++-------
 clippy_lints/src/utils/conf.rs          |  2 ++
 3 files changed, 37 insertions(+), 10 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 5add8d44b42..15262cfbf54 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1216,7 +1216,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     let enum_variant_name_threshold = conf.enum_variant_name_threshold;
     store.register_early_pass(move || box enum_variants::EnumVariantNames::new(enum_variant_name_threshold));
     store.register_early_pass(|| box tabs_in_doc_comments::TabsInDocComments);
-    store.register_early_pass(|| box upper_case_acronyms::UpperCaseAcronyms);
+    let upper_case_acronyms_aggressive = conf.upper_case_acronyms_aggressive;
+    store.register_early_pass(move || box upper_case_acronyms::UpperCaseAcronyms::new(upper_case_acronyms_aggressive));
     store.register_late_pass(|| box default::Default::default());
     store.register_late_pass(|| box unused_self::UnusedSelf);
     store.register_late_pass(|| box mutable_debug_assertion::DebugAssertWithMutCall);
@@ -1416,7 +1417,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&unnecessary_wraps::UNNECESSARY_WRAPS),
         LintId::of(&unnested_or_patterns::UNNESTED_OR_PATTERNS),
         LintId::of(&unused_self::UNUSED_SELF),
-        LintId::of(&upper_case_acronyms::UPPER_CASE_ACRONYMS),
         LintId::of(&wildcard_imports::ENUM_GLOB_USE),
         LintId::of(&wildcard_imports::WILDCARD_IMPORTS),
         LintId::of(&zero_sized_map_values::ZERO_SIZED_MAP_VALUES),
@@ -1835,6 +1835,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&types::FN_TO_NUMERIC_CAST_WITH_TRUNCATION),
         LintId::of(&unsafe_removed_from_name::UNSAFE_REMOVED_FROM_NAME),
         LintId::of(&unused_unit::UNUSED_UNIT),
+        LintId::of(&upper_case_acronyms::UPPER_CASE_ACRONYMS),
         LintId::of(&write::PRINTLN_EMPTY_STRING),
         LintId::of(&write::PRINT_LITERAL),
         LintId::of(&write::PRINT_WITH_NEWLINE),
diff --git a/clippy_lints/src/upper_case_acronyms.rs b/clippy_lints/src/upper_case_acronyms.rs
index b593fd0a699..6995fbce72c 100644
--- a/clippy_lints/src/upper_case_acronyms.rs
+++ b/clippy_lints/src/upper_case_acronyms.rs
@@ -5,16 +5,20 @@ use rustc_ast::ast::{Item, ItemKind, Variant};
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::symbol::Ident;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for camel case name containing a capitalized acronym.
+    /// **What it does:** Checks for fully capitalized names and optionally names containing a capitalized acronym.
     ///
     /// **Why is this bad?** In CamelCase, acronyms count as one word.
     /// See [naming conventions](https://rust-lang.github.io/api-guidelines/naming.html#casing-conforms-to-rfc-430-c-case)
     /// for more.
     ///
+    /// By default, the lint only triggers on fully-capitalized names.
+    /// You can use the `upper_case_acronyms_aggressive: true` config option to enable linting
+    /// on all camel case names
+    ///
     /// **Known problems:** When two acronyms are contiguous, the lint can't tell where
     /// the first acronym ends and the second starts, so it suggests to lowercase all of
     /// the letters in the second acronym.
@@ -29,11 +33,24 @@ declare_clippy_lint! {
     /// struct HttpResponse;
     /// ```
     pub UPPER_CASE_ACRONYMS,
-    pedantic,
+    style,
     "capitalized acronyms are against the naming convention"
 }
 
-declare_lint_pass!(UpperCaseAcronyms => [UPPER_CASE_ACRONYMS]);
+#[derive(Default)]
+pub struct UpperCaseAcronyms {
+    upper_case_acronyms_aggressive: bool,
+}
+
+impl UpperCaseAcronyms {
+    pub fn new(aggressive: bool) -> Self {
+        Self {
+            upper_case_acronyms_aggressive: aggressive,
+        }
+    }
+}
+
+impl_lint_pass!(UpperCaseAcronyms => [UPPER_CASE_ACRONYMS]);
 
 fn correct_ident(ident: &str) -> String {
     let ident = ident.chars().rev().collect::<String>();
@@ -56,11 +73,18 @@ fn correct_ident(ident: &str) -> String {
     ident
 }
 
-fn check_ident(cx: &EarlyContext<'_>, ident: &Ident) {
+fn check_ident(cx: &EarlyContext<'_>, ident: &Ident, be_aggressive: bool) {
     let span = ident.span;
     let ident = &ident.as_str();
     let corrected = correct_ident(ident);
-    if ident != &corrected {
+    // warn if we have pure-uppercase idents
+    // assume that two-letter words are some kind of valid abbreviation like FP for false positive
+    // (and don't warn)
+    if (ident.chars().all(|c| c.is_ascii_uppercase()) && ident.len() > 2)
+    // otherwise, warn if we have SOmeTHING lIKE THIs but only warn with the aggressive 
+    // upper_case_acronyms_aggressive config option enabled
+    || (be_aggressive && ident != &corrected)
+    {
         span_lint_and_sugg(
             cx,
             UPPER_CASE_ACRONYMS,
@@ -82,12 +106,12 @@ impl EarlyLintPass for UpperCaseAcronyms {
                 ItemKind::TyAlias(..) | ItemKind::Enum(..) | ItemKind::Struct(..) | ItemKind::Trait(..)
             );
             then {
-                check_ident(cx, &it.ident);
+                check_ident(cx, &it.ident, self.upper_case_acronyms_aggressive);
             }
         }
     }
 
     fn check_variant(&mut self, cx: &EarlyContext<'_>, v: &Variant) {
-        check_ident(cx, &v.ident);
+        check_ident(cx, &v.ident, self.upper_case_acronyms_aggressive);
     }
 }
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 7d7b35c2168..34b9ecf2830 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -173,6 +173,8 @@ define_Conf! {
     (disallowed_methods, "disallowed_methods": Vec<String>, Vec::<String>::new()),
     /// Lint: UNREADABLE_LITERAL. Should the fraction of a decimal be linted to include separators.
     (unreadable_literal_lint_fractions, "unreadable_literal_lint_fractions": bool, true),
+    /// Lint: UPPER_CASE_ACRONYMS. Enabler verbose mode triggers if there is more than one uppercase char next to each other
+    (upper_case_acronyms_aggressive, "upper_case_acronyms_aggressive": bool, false),
     /// Lint: _CARGO_COMMON_METADATA. For internal testing only, ignores the current `publish` settings in the Cargo manifest.
     (cargo_ignore_publish, "cargo_ignore_publish": bool, false),
 }
-- 
cgit 1.4.1-3-g733a5


From 913c71018ca0adfd8c68677d6c4cf5a8acb44de8 Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Wed, 24 Feb 2021 23:41:32 +0100
Subject: upper_case_acronyms: add io-toml tests and bless previous tests

---
 clippy_lints/src/upper_case_acronyms.rs            |  4 +-
 .../toml_unknown_key/conf_unknown_key.stderr       |  2 +-
 .../upper_case_acronyms_aggressive/clippy.toml     |  1 +
 .../upper_case_acronyms.rs                         | 22 +++++++
 .../upper_case_acronyms.stderr                     | 70 ++++++++++++++++++++++
 tests/ui/upper_case_acronyms.rs                    |  7 ++-
 tests/ui/upper_case_acronyms.stderr                | 24 +-------
 7 files changed, 103 insertions(+), 27 deletions(-)
 create mode 100644 tests/ui-toml/upper_case_acronyms_aggressive/clippy.toml
 create mode 100644 tests/ui-toml/upper_case_acronyms_aggressive/upper_case_acronyms.rs
 create mode 100644 tests/ui-toml/upper_case_acronyms_aggressive/upper_case_acronyms.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/upper_case_acronyms.rs b/clippy_lints/src/upper_case_acronyms.rs
index 6995fbce72c..0470e1dbbb8 100644
--- a/clippy_lints/src/upper_case_acronyms.rs
+++ b/clippy_lints/src/upper_case_acronyms.rs
@@ -16,7 +16,7 @@ declare_clippy_lint! {
     /// for more.
     ///
     /// By default, the lint only triggers on fully-capitalized names.
-    /// You can use the `upper_case_acronyms_aggressive: true` config option to enable linting
+    /// You can use the `upper-case-acronyms-aggressive: true` config option to enable linting
     /// on all camel case names
     ///
     /// **Known problems:** When two acronyms are contiguous, the lint can't tell where
@@ -82,7 +82,7 @@ fn check_ident(cx: &EarlyContext<'_>, ident: &Ident, be_aggressive: bool) {
     // (and don't warn)
     if (ident.chars().all(|c| c.is_ascii_uppercase()) && ident.len() > 2)
     // otherwise, warn if we have SOmeTHING lIKE THIs but only warn with the aggressive 
-    // upper_case_acronyms_aggressive config option enabled
+    // upper-case-acronyms-aggressive config option enabled
     || (be_aggressive && ident != &corrected)
     {
         span_lint_and_sugg(
diff --git a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
index 7ccd0b54845..d83080b69f5 100644
--- a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
+++ b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
@@ -1,4 +1,4 @@
-error: error reading Clippy's configuration file `$DIR/clippy.toml`: unknown field `foobar`, expected one of `msrv`, `blacklisted-names`, `cognitive-complexity-threshold`, `cyclomatic-complexity-threshold`, `doc-valid-idents`, `too-many-arguments-threshold`, `type-complexity-threshold`, `single-char-binding-names-threshold`, `too-large-for-stack`, `enum-variant-name-threshold`, `enum-variant-size-threshold`, `verbose-bit-mask-threshold`, `literal-representation-threshold`, `trivial-copy-size-limit`, `pass-by-value-size-limit`, `too-many-lines-threshold`, `array-size-threshold`, `vec-box-size-threshold`, `max-trait-bounds`, `max-struct-bools`, `max-fn-params-bools`, `warn-on-all-wildcard-imports`, `disallowed-methods`, `unreadable-literal-lint-fractions`, `cargo-ignore-publish`, `third-party` at line 5 column 1
+error: error reading Clippy's configuration file `$DIR/clippy.toml`: unknown field `foobar`, expected one of `msrv`, `blacklisted-names`, `cognitive-complexity-threshold`, `cyclomatic-complexity-threshold`, `doc-valid-idents`, `too-many-arguments-threshold`, `type-complexity-threshold`, `single-char-binding-names-threshold`, `too-large-for-stack`, `enum-variant-name-threshold`, `enum-variant-size-threshold`, `verbose-bit-mask-threshold`, `literal-representation-threshold`, `trivial-copy-size-limit`, `pass-by-value-size-limit`, `too-many-lines-threshold`, `array-size-threshold`, `vec-box-size-threshold`, `max-trait-bounds`, `max-struct-bools`, `max-fn-params-bools`, `warn-on-all-wildcard-imports`, `disallowed-methods`, `unreadable-literal-lint-fractions`, `upper-case-acronyms-aggressive`, `cargo-ignore-publish`, `third-party` at line 5 column 1
 
 error: aborting due to previous error
 
diff --git a/tests/ui-toml/upper_case_acronyms_aggressive/clippy.toml b/tests/ui-toml/upper_case_acronyms_aggressive/clippy.toml
new file mode 100644
index 00000000000..cc94ec53e13
--- /dev/null
+++ b/tests/ui-toml/upper_case_acronyms_aggressive/clippy.toml
@@ -0,0 +1 @@
+upper-case-acronyms-aggressive = true
diff --git a/tests/ui-toml/upper_case_acronyms_aggressive/upper_case_acronyms.rs b/tests/ui-toml/upper_case_acronyms_aggressive/upper_case_acronyms.rs
new file mode 100644
index 00000000000..fdf8905f812
--- /dev/null
+++ b/tests/ui-toml/upper_case_acronyms_aggressive/upper_case_acronyms.rs
@@ -0,0 +1,22 @@
+#![warn(clippy::upper_case_acronyms)]
+
+struct HTTPResponse; // not linted by default, but with cfg option
+
+struct CString; // not linted
+
+enum Flags {
+    NS, // not linted
+    CWR,
+    ECE,
+    URG,
+    ACK,
+    PSH,
+    RST,
+    SYN,
+    FIN,
+}
+
+struct GCCLLVMSomething; // linted with cfg option, beware that lint suggests `GccllvmSomething` instead of
+                         // `GccLlvmSomething`
+
+fn main() {}
diff --git a/tests/ui-toml/upper_case_acronyms_aggressive/upper_case_acronyms.stderr b/tests/ui-toml/upper_case_acronyms_aggressive/upper_case_acronyms.stderr
new file mode 100644
index 00000000000..1cc59dc45f2
--- /dev/null
+++ b/tests/ui-toml/upper_case_acronyms_aggressive/upper_case_acronyms.stderr
@@ -0,0 +1,70 @@
+error: name `HTTPResponse` contains a capitalized acronym
+  --> $DIR/upper_case_acronyms.rs:3:8
+   |
+LL | struct HTTPResponse; // not linted by default, but with cfg option
+   |        ^^^^^^^^^^^^ help: consider making the acronym lowercase, except the initial letter: `HttpResponse`
+   |
+   = note: `-D clippy::upper-case-acronyms` implied by `-D warnings`
+
+error: name `NS` contains a capitalized acronym
+  --> $DIR/upper_case_acronyms.rs:8:5
+   |
+LL |     NS, // not linted
+   |     ^^ help: consider making the acronym lowercase, except the initial letter (notice the capitalization): `Ns`
+
+error: name `CWR` contains a capitalized acronym
+  --> $DIR/upper_case_acronyms.rs:9:5
+   |
+LL |     CWR,
+   |     ^^^ help: consider making the acronym lowercase, except the initial letter: `Cwr`
+
+error: name `ECE` contains a capitalized acronym
+  --> $DIR/upper_case_acronyms.rs:10:5
+   |
+LL |     ECE,
+   |     ^^^ help: consider making the acronym lowercase, except the initial letter: `Ece`
+
+error: name `URG` contains a capitalized acronym
+  --> $DIR/upper_case_acronyms.rs:11:5
+   |
+LL |     URG,
+   |     ^^^ help: consider making the acronym lowercase, except the initial letter: `Urg`
+
+error: name `ACK` contains a capitalized acronym
+  --> $DIR/upper_case_acronyms.rs:12:5
+   |
+LL |     ACK,
+   |     ^^^ help: consider making the acronym lowercase, except the initial letter (notice the capitalization): `Ack`
+
+error: name `PSH` contains a capitalized acronym
+  --> $DIR/upper_case_acronyms.rs:13:5
+   |
+LL |     PSH,
+   |     ^^^ help: consider making the acronym lowercase, except the initial letter: `Psh`
+
+error: name `RST` contains a capitalized acronym
+  --> $DIR/upper_case_acronyms.rs:14:5
+   |
+LL |     RST,
+   |     ^^^ help: consider making the acronym lowercase, except the initial letter: `Rst`
+
+error: name `SYN` contains a capitalized acronym
+  --> $DIR/upper_case_acronyms.rs:15:5
+   |
+LL |     SYN,
+   |     ^^^ help: consider making the acronym lowercase, except the initial letter: `Syn`
+
+error: name `FIN` contains a capitalized acronym
+  --> $DIR/upper_case_acronyms.rs:16:5
+   |
+LL |     FIN,
+   |     ^^^ help: consider making the acronym lowercase, except the initial letter: `Fin`
+
+error: name `GCCLLVMSomething` contains a capitalized acronym
+  --> $DIR/upper_case_acronyms.rs:19:8
+   |
+LL | struct GCCLLVMSomething; // linted with cfg option, beware that lint suggests `GccllvmSomething` instead of
+   |        ^^^^^^^^^^^^^^^^ help: consider making the acronym lowercase, except the initial letter: `GccllvmSomething`
+
+error: aborting due to 11 previous errors
+
diff --git a/tests/ui/upper_case_acronyms.rs b/tests/ui/upper_case_acronyms.rs
index af0b5776348..fdf8905f812 100644
--- a/tests/ui/upper_case_acronyms.rs
+++ b/tests/ui/upper_case_acronyms.rs
@@ -1,11 +1,11 @@
 #![warn(clippy::upper_case_acronyms)]
 
-struct HTTPResponse; // linted
+struct HTTPResponse; // not linted by default, but with cfg option
 
 struct CString; // not linted
 
 enum Flags {
-    NS, // linted
+    NS, // not linted
     CWR,
     ECE,
     URG,
@@ -16,6 +16,7 @@ enum Flags {
     FIN,
 }
 
-struct GCCLLVMSomething; // linted, beware that lint suggests `GccllvmSomething` instead of `GccLlvmSomething`
+struct GCCLLVMSomething; // linted with cfg option, beware that lint suggests `GccllvmSomething` instead of
+                         // `GccLlvmSomething`
 
 fn main() {}
diff --git a/tests/ui/upper_case_acronyms.stderr b/tests/ui/upper_case_acronyms.stderr
index 2065fe10bb1..bbe38991e52 100644
--- a/tests/ui/upper_case_acronyms.stderr
+++ b/tests/ui/upper_case_acronyms.stderr
@@ -1,22 +1,10 @@
-error: name `HTTPResponse` contains a capitalized acronym
-  --> $DIR/upper_case_acronyms.rs:3:8
-   |
-LL | struct HTTPResponse; // linted
-   |        ^^^^^^^^^^^^ help: consider making the acronym lowercase, except the initial letter: `HttpResponse`
-   |
-   = note: `-D clippy::upper-case-acronyms` implied by `-D warnings`
-
-error: name `NS` contains a capitalized acronym
-  --> $DIR/upper_case_acronyms.rs:8:5
-   |
-LL |     NS, // linted
-   |     ^^ help: consider making the acronym lowercase, except the initial letter (notice the capitalization): `Ns`
-
 error: name `CWR` contains a capitalized acronym
   --> $DIR/upper_case_acronyms.rs:9:5
    |
 LL |     CWR,
    |     ^^^ help: consider making the acronym lowercase, except the initial letter: `Cwr`
+   |
+   = note: `-D clippy::upper-case-acronyms` implied by `-D warnings`
 
 error: name `ECE` contains a capitalized acronym
   --> $DIR/upper_case_acronyms.rs:10:5
@@ -60,11 +48,5 @@ error: name `FIN` contains a capitalized acronym
 LL |     FIN,
    |     ^^^ help: consider making the acronym lowercase, except the initial letter: `Fin`
 
-error: name `GCCLLVMSomething` contains a capitalized acronym
-  --> $DIR/upper_case_acronyms.rs:19:8
-   |
-LL | struct GCCLLVMSomething; // linted, beware that lint suggests `GccllvmSomething` instead of `GccLlvmSomething`
-   |        ^^^^^^^^^^^^^^^^ help: consider making the acronym lowercase, except the initial letter: `GccllvmSomething`
-
-error: aborting due to 11 previous errors
+error: aborting due to 8 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 2a6b06108d88830d3a6d5a50f733b8f7cf2799ab Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Thu, 25 Feb 2021 00:10:06 +0100
Subject: run cargo dev update_lints

fix sentence / address review comments
---
 clippy_lints/src/lib.rs        | 1 +
 clippy_lints/src/utils/conf.rs | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 15262cfbf54..176eeadcc63 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1716,6 +1716,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&unused_unit::UNUSED_UNIT),
         LintId::of(&unwrap::PANICKING_UNWRAP),
         LintId::of(&unwrap::UNNECESSARY_UNWRAP),
+        LintId::of(&upper_case_acronyms::UPPER_CASE_ACRONYMS),
         LintId::of(&useless_conversion::USELESS_CONVERSION),
         LintId::of(&vec::USELESS_VEC),
         LintId::of(&vec_init_then_push::VEC_INIT_THEN_PUSH),
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 34b9ecf2830..bc241adc7d5 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -173,7 +173,7 @@ define_Conf! {
     (disallowed_methods, "disallowed_methods": Vec<String>, Vec::<String>::new()),
     /// Lint: UNREADABLE_LITERAL. Should the fraction of a decimal be linted to include separators.
     (unreadable_literal_lint_fractions, "unreadable_literal_lint_fractions": bool, true),
-    /// Lint: UPPER_CASE_ACRONYMS. Enabler verbose mode triggers if there is more than one uppercase char next to each other
+    /// Lint: UPPER_CASE_ACRONYMS. Enables verbose mode. Triggers if there is more than one uppercase char next to each other
     (upper_case_acronyms_aggressive, "upper_case_acronyms_aggressive": bool, false),
     /// Lint: _CARGO_COMMON_METADATA. For internal testing only, ignores the current `publish` settings in the Cargo manifest.
     (cargo_ignore_publish, "cargo_ignore_publish": bool, false),
-- 
cgit 1.4.1-3-g733a5


From 2f0e9f7d3afb3cb169e58d65261f04215b017561 Mon Sep 17 00:00:00 2001
From: Mateusz Gacek <96mateusz.gacek@gmail.com>
Date: Wed, 24 Feb 2021 21:06:26 +0100
Subject: or_fun_call: fix suggestion for `or_insert(vec![])`

Applies for `std::collections::hash_map::Entry` and `std::collections::btree_map::Entry`

Example:
Previously, for the following code:
`let _ = hash_map.entry("test".to_owned()).or_insert(vec![]);`
clippy would suggest to use:
`or_insert_with(vec![])`, which causes a compiler error (E0277).

Now clippy suggests:
`or_insert_with(Vec::new)`
---
 clippy_lints/src/methods/mod.rs | 16 +++++++++++++++-
 tests/ui/or_fun_call.fixed      |  6 ++++++
 tests/ui/or_fun_call.rs         |  6 ++++++
 tests/ui/or_fun_call.stderr     | 26 +++++++++++++++++++-------
 4 files changed, 46 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 433f513b1a8..26878d5bba9 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -2005,12 +2005,26 @@ fn lint_or_fun_call<'tcx>(
             if poss.contains(&name);
 
             then {
+                let macro_expanded_snipped;
                 let sugg: Cow<'_, str> = {
                     let (snippet_span, use_lambda) = match (fn_has_arguments, fun_span) {
                         (false, Some(fun_span)) => (fun_span, false),
                         _ => (arg.span, true),
                     };
-                    let snippet = snippet_with_macro_callsite(cx, snippet_span, "..");
+                    let snippet = {
+                        let not_macro_argument_snippet = snippet_with_macro_callsite(cx, snippet_span, "..");
+                        if not_macro_argument_snippet == "vec![]" {
+                            macro_expanded_snipped = snippet(cx, snippet_span, "..");
+                            match macro_expanded_snipped.strip_prefix("$crate::vec::") {
+                                Some(stripped) => Cow::from(stripped),
+                                None => macro_expanded_snipped
+                            }
+                        }
+                        else {
+                            not_macro_argument_snippet
+                        }
+                    };
+
                     if use_lambda {
                         let l_arg = if fn_has_arguments { "_" } else { "" };
                         format!("|{}| {}", l_arg, snippet).into()
diff --git a/tests/ui/or_fun_call.fixed b/tests/ui/or_fun_call.fixed
index 2a63318c8c7..64347cae5da 100644
--- a/tests/ui/or_fun_call.fixed
+++ b/tests/ui/or_fun_call.fixed
@@ -62,9 +62,15 @@ fn or_fun_call() {
     let mut map = HashMap::<u64, String>::new();
     map.entry(42).or_insert_with(String::new);
 
+    let mut map_vec = HashMap::<u64, Vec<i32>>::new();
+    map_vec.entry(42).or_insert_with(Vec::new);
+
     let mut btree = BTreeMap::<u64, String>::new();
     btree.entry(42).or_insert_with(String::new);
 
+    let mut btree_vec = BTreeMap::<u64, Vec<i32>>::new();
+    btree_vec.entry(42).or_insert_with(Vec::new);
+
     let stringy = Some(String::from(""));
     let _ = stringy.unwrap_or_else(|| "".to_owned());
 
diff --git a/tests/ui/or_fun_call.rs b/tests/ui/or_fun_call.rs
index 026ef437caa..7faab0017b2 100644
--- a/tests/ui/or_fun_call.rs
+++ b/tests/ui/or_fun_call.rs
@@ -62,9 +62,15 @@ fn or_fun_call() {
     let mut map = HashMap::<u64, String>::new();
     map.entry(42).or_insert(String::new());
 
+    let mut map_vec = HashMap::<u64, Vec<i32>>::new();
+    map_vec.entry(42).or_insert(vec![]);
+
     let mut btree = BTreeMap::<u64, String>::new();
     btree.entry(42).or_insert(String::new());
 
+    let mut btree_vec = BTreeMap::<u64, Vec<i32>>::new();
+    btree_vec.entry(42).or_insert(vec![]);
+
     let stringy = Some(String::from(""));
     let _ = stringy.unwrap_or("".to_owned());
 
diff --git a/tests/ui/or_fun_call.stderr b/tests/ui/or_fun_call.stderr
index fb8bf339828..1e2bfd490e0 100644
--- a/tests/ui/or_fun_call.stderr
+++ b/tests/ui/or_fun_call.stderr
@@ -67,40 +67,52 @@ LL |     map.entry(42).or_insert(String::new());
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `or_insert_with(String::new)`
 
 error: use of `or_insert` followed by a function call
-  --> $DIR/or_fun_call.rs:66:21
+  --> $DIR/or_fun_call.rs:66:23
+   |
+LL |     map_vec.entry(42).or_insert(vec![]);
+   |                       ^^^^^^^^^^^^^^^^^ help: try this: `or_insert_with(Vec::new)`
+
+error: use of `or_insert` followed by a function call
+  --> $DIR/or_fun_call.rs:69:21
    |
 LL |     btree.entry(42).or_insert(String::new());
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `or_insert_with(String::new)`
 
+error: use of `or_insert` followed by a function call
+  --> $DIR/or_fun_call.rs:72:25
+   |
+LL |     btree_vec.entry(42).or_insert(vec![]);
+   |                         ^^^^^^^^^^^^^^^^^ help: try this: `or_insert_with(Vec::new)`
+
 error: use of `unwrap_or` followed by a function call
-  --> $DIR/or_fun_call.rs:69:21
+  --> $DIR/or_fun_call.rs:75:21
    |
 LL |     let _ = stringy.unwrap_or("".to_owned());
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|| "".to_owned())`
 
 error: use of `unwrap_or` followed by a function call
-  --> $DIR/or_fun_call.rs:77:21
+  --> $DIR/or_fun_call.rs:83:21
    |
 LL |     let _ = Some(1).unwrap_or(map[&1]);
    |                     ^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|| map[&1])`
 
 error: use of `unwrap_or` followed by a function call
-  --> $DIR/or_fun_call.rs:79:21
+  --> $DIR/or_fun_call.rs:85:21
    |
 LL |     let _ = Some(1).unwrap_or(map[&1]);
    |                     ^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|| map[&1])`
 
 error: use of `or` followed by a function call
-  --> $DIR/or_fun_call.rs:103:35
+  --> $DIR/or_fun_call.rs:109:35
    |
 LL |     let _ = Some("a".to_string()).or(Some("b".to_string()));
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `or_else(|| Some("b".to_string()))`
 
 error: use of `or` followed by a function call
-  --> $DIR/or_fun_call.rs:107:10
+  --> $DIR/or_fun_call.rs:113:10
    |
 LL |         .or(Some(Bar(b, Duration::from_secs(2))));
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `or_else(|| Some(Bar(b, Duration::from_secs(2))))`
 
-error: aborting due to 17 previous errors
+error: aborting due to 19 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 5dbd45cbc1c213a4e796a85b281f5bc397bf9000 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Thu, 25 Feb 2021 19:51:49 -0600
Subject: Improve needless_borrowed_ref docs

---
 clippy_lints/src/needless_borrowed_ref.rs | 47 ++++++++++++-------------------
 1 file changed, 18 insertions(+), 29 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/needless_borrowed_ref.rs b/clippy_lints/src/needless_borrowed_ref.rs
index 85184fdea47..f449f397e7d 100644
--- a/clippy_lints/src/needless_borrowed_ref.rs
+++ b/clippy_lints/src/needless_borrowed_ref.rs
@@ -1,7 +1,3 @@
-//! Checks for useless borrowed references.
-//!
-//! This lint is **warn** by default
-
 use crate::utils::{snippet_with_applicability, span_lint_and_then};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
@@ -10,44 +6,37 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for useless borrowed references.
-    ///
-    /// **Why is this bad?** It is mostly useless and make the code look more
-    /// complex than it
-    /// actually is.
+    /// **What it does:** Checks for bindings that destructure a reference and borrow the inner
+    /// value with `&ref`.
     ///
-    /// **Known problems:** It seems that the `&ref` pattern is sometimes useful.
-    /// For instance in the following snippet:
-    /// ```rust,ignore
-    /// enum Animal {
-    ///     Cat(u64),
-    ///     Dog(u64),
-    /// }
+    /// **Why is this bad?** This pattern has no effect in almost all cases.
     ///
-    /// fn foo(a: &Animal, b: &Animal) {
+    /// **Known problems:** In some cases, `&ref` is needed to avoid a lifetime mismatch error.
+    /// Example:
+    /// ```rust
+    /// fn foo(a: &Option<String>, b: &Option<String>) {
     ///     match (a, b) {
-    ///         (&Animal::Cat(v), k) | (k, &Animal::Cat(v)) => (), // lifetime mismatch error
-    ///         (&Animal::Dog(ref c), &Animal::Dog(_)) => ()
-    ///     }
+    ///         (None, &ref c) | (&ref c, None) => (),
+    ///         (&Some(ref c), _) => (),
+    ///     };
     /// }
     /// ```
-    /// There is a lifetime mismatch error for `k` (indeed a and b have distinct
-    /// lifetime).
-    /// This can be fixed by using the `&ref` pattern.
-    /// However, the code can also be fixed by much cleaner ways
     ///
     /// **Example:**
+    /// Bad:
     /// ```rust
     /// let mut v = Vec::<String>::new();
     /// let _ = v.iter_mut().filter(|&ref a| a.is_empty());
     /// ```
-    /// This closure takes a reference on something that has been matched as a
-    /// reference and
-    /// de-referenced.
-    /// As such, it could just be |a| a.is_empty()
+    ///
+    /// Good:
+    /// ```rust
+    /// let mut v = Vec::<String>::new();
+    /// let _ = v.iter_mut().filter(|a| a.is_empty());
+    /// ```
     pub NEEDLESS_BORROWED_REFERENCE,
     complexity,
-    "taking a needless borrowed reference"
+    "destructuring a reference and borrowing the inner value"
 }
 
 declare_lint_pass!(NeedlessBorrowedRef => [NEEDLESS_BORROWED_REFERENCE]);
-- 
cgit 1.4.1-3-g733a5


From 8f47a4214e66b67bbcbcc0a1c1fd3f3d481ed85e Mon Sep 17 00:00:00 2001
From: David Tolnay <dtolnay@gmail.com>
Date: Thu, 25 Feb 2021 20:31:24 -0800
Subject: Downgrade manual_map to nursery

---
 clippy_lints/src/lib.rs        | 3 +--
 clippy_lints/src/manual_map.rs | 4 ++--
 2 files changed, 3 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 176eeadcc63..faec9ec31f3 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1540,7 +1540,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&loops::WHILE_LET_ON_ITERATOR),
         LintId::of(&main_recursion::MAIN_RECURSION),
         LintId::of(&manual_async_fn::MANUAL_ASYNC_FN),
-        LintId::of(&manual_map::MANUAL_MAP),
         LintId::of(&manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE),
         LintId::of(&manual_strip::MANUAL_STRIP),
         LintId::of(&manual_unwrap_or::MANUAL_UNWRAP_OR),
@@ -1771,7 +1770,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&loops::WHILE_LET_ON_ITERATOR),
         LintId::of(&main_recursion::MAIN_RECURSION),
         LintId::of(&manual_async_fn::MANUAL_ASYNC_FN),
-        LintId::of(&manual_map::MANUAL_MAP),
         LintId::of(&manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE),
         LintId::of(&map_clone::MAP_CLONE),
         LintId::of(&matches::INFALLIBLE_DESTRUCTURING_MATCH),
@@ -2047,6 +2045,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&floating_point_arithmetic::SUBOPTIMAL_FLOPS),
         LintId::of(&future_not_send::FUTURE_NOT_SEND),
         LintId::of(&let_if_seq::USELESS_LET_IF_SEQ),
+        LintId::of(&manual_map::MANUAL_MAP),
         LintId::of(&missing_const_for_fn::MISSING_CONST_FOR_FN),
         LintId::of(&mutable_debug_assertion::DEBUG_ASSERT_WITH_MUT_CALL),
         LintId::of(&mutex_atomic::MUTEX_INTEGER),
diff --git a/clippy_lints/src/manual_map.rs b/clippy_lints/src/manual_map.rs
index a50a3943bab..78dc0d54f28 100644
--- a/clippy_lints/src/manual_map.rs
+++ b/clippy_lints/src/manual_map.rs
@@ -19,7 +19,7 @@ declare_clippy_lint! {
     ///
     /// **Why is this bad?** Using the `map` method is clearer and more concise.
     ///
-    /// **Known problems:** None.
+    /// **Known problems:** `map` is not capable of representing some control flow which works fine in `match`.
     ///
     /// **Example:**
     ///
@@ -34,7 +34,7 @@ declare_clippy_lint! {
     /// Some(0).map(|x| x + 1);
     /// ```
     pub MANUAL_MAP,
-    style,
+    nursery,
     "reimplementation of `map`"
 }
 
-- 
cgit 1.4.1-3-g733a5


From 9dba6a9fdeefba74167953fc14610faec387a9c9 Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Fri, 26 Feb 2021 21:22:30 +0100
Subject: upper_case_acronyms: don't warn on public items

Fixes #6803

changelog: upper_case_acronyms: ignore public items
---
 clippy_lints/src/upper_case_acronyms.rs                             | 4 +++-
 tests/ui-toml/upper_case_acronyms_aggressive/upper_case_acronyms.rs | 5 +++++
 tests/ui/upper_case_acronyms.rs                                     | 4 ++++
 3 files changed, 12 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/upper_case_acronyms.rs b/clippy_lints/src/upper_case_acronyms.rs
index 0470e1dbbb8..fea3abaec93 100644
--- a/clippy_lints/src/upper_case_acronyms.rs
+++ b/clippy_lints/src/upper_case_acronyms.rs
@@ -1,7 +1,7 @@
 use crate::utils::span_lint_and_sugg;
 use if_chain::if_chain;
 use itertools::Itertools;
-use rustc_ast::ast::{Item, ItemKind, Variant};
+use rustc_ast::ast::{Item, ItemKind, Variant, VisibilityKind};
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
@@ -105,6 +105,8 @@ impl EarlyLintPass for UpperCaseAcronyms {
                 it.kind,
                 ItemKind::TyAlias(..) | ItemKind::Enum(..) | ItemKind::Struct(..) | ItemKind::Trait(..)
             );
+            // do not lint public items
+            if !matches!(it.vis.kind, VisibilityKind::Public);
             then {
                 check_ident(cx, &it.ident, self.upper_case_acronyms_aggressive);
             }
diff --git a/tests/ui-toml/upper_case_acronyms_aggressive/upper_case_acronyms.rs b/tests/ui-toml/upper_case_acronyms_aggressive/upper_case_acronyms.rs
index fdf8905f812..5d54e083ef0 100644
--- a/tests/ui-toml/upper_case_acronyms_aggressive/upper_case_acronyms.rs
+++ b/tests/ui-toml/upper_case_acronyms_aggressive/upper_case_acronyms.rs
@@ -19,4 +19,9 @@ enum Flags {
 struct GCCLLVMSomething; // linted with cfg option, beware that lint suggests `GccllvmSomething` instead of
                          // `GccLlvmSomething`
 
+// don't warn on public items
+pub struct MIXEDCapital;
+
+pub struct FULLCAPITAL;
+
 fn main() {}
diff --git a/tests/ui/upper_case_acronyms.rs b/tests/ui/upper_case_acronyms.rs
index fdf8905f812..eea125500a2 100644
--- a/tests/ui/upper_case_acronyms.rs
+++ b/tests/ui/upper_case_acronyms.rs
@@ -19,4 +19,8 @@ enum Flags {
 struct GCCLLVMSomething; // linted with cfg option, beware that lint suggests `GccllvmSomething` instead of
                          // `GccLlvmSomething`
 
+// public items must not be linted
+pub struct NOWARNINGHERE;
+pub struct ALSONoWarningHERE;
+
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From ef87e58993ace9e607a43b5581d40b4c0a2e71f6 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Fri, 26 Feb 2021 11:50:12 -0500
Subject: Fix `manual_map`: don't lint when partially moved values are used.
 Fix `manual_map`: don't lint when `return`, `break`, and `continue` are used.

---
 clippy_lints/src/manual_map.rs    | 54 ++++++++++++++++++++++++++++++++++++---
 clippy_utils/src/lib.rs           | 12 +++++++++
 tests/ui/manual_map_option.fixed  | 45 +++++++++++++++++++++++++++++++-
 tests/ui/manual_map_option.rs     | 45 +++++++++++++++++++++++++++++++-
 tests/ui/manual_map_option.stderr | 34 ++++++++++++------------
 5 files changed, 168 insertions(+), 22 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_map.rs b/clippy_lints/src/manual_map.rs
index 78dc0d54f28..bc6544ee79e 100644
--- a/clippy_lints/src/manual_map.rs
+++ b/clippy_lints/src/manual_map.rs
@@ -2,13 +2,17 @@ use crate::{
     map_unit_fn::OPTION_MAP_UNIT_FN,
     matches::MATCH_AS_REF,
     utils::{
-        is_allowed, is_type_diagnostic_item, match_def_path, match_var, paths, peel_hir_expr_refs,
-        peel_mid_ty_refs_is_mutable, snippet_with_applicability, span_lint_and_sugg,
+        can_partially_move_ty, is_allowed, is_type_diagnostic_item, match_def_path, match_var, paths,
+        peel_hir_expr_refs, peel_mid_ty_refs_is_mutable, snippet_with_applicability, span_lint_and_sugg,
     },
 };
 use rustc_ast::util::parser::PREC_POSTFIX;
 use rustc_errors::Applicability;
-use rustc_hir::{Arm, BindingAnnotation, Block, Expr, ExprKind, Mutability, Pat, PatKind, QPath};
+use rustc_hir::{
+    def::Res,
+    intravisit::{walk_expr, ErasedMap, NestedVisitorMap, Visitor},
+    Arm, BindingAnnotation, Block, Expr, ExprKind, Mutability, Pat, PatKind, Path, QPath,
+};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -99,6 +103,10 @@ impl LateLintPass<'_> for ManualMap {
                 return;
             }
 
+            if !can_move_expr_to_closure(cx, some_expr) {
+                return;
+            }
+
             // Determine which binding mode to use.
             let explicit_ref = some_pat.contains_explicit_ref_binding();
             let binding_ref = explicit_ref.or_else(|| (ty_ref_count != pat_ref_count).then(|| ty_mutability));
@@ -171,6 +179,46 @@ impl LateLintPass<'_> for ManualMap {
     }
 }
 
+// Checks if the expression can be moved into a closure as is.
+fn can_move_expr_to_closure(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> bool {
+    struct V<'cx, 'tcx> {
+        cx: &'cx LateContext<'tcx>,
+        make_closure: bool,
+    }
+    impl Visitor<'tcx> for V<'_, 'tcx> {
+        type Map = ErasedMap<'tcx>;
+        fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+            NestedVisitorMap::None
+        }
+
+        fn visit_expr(&mut self, e: &'tcx Expr<'_>) {
+            match e.kind {
+                ExprKind::Break(..) | ExprKind::Continue(_) | ExprKind::Ret(_) => {
+                    self.make_closure = false;
+                },
+                // Accessing a field of a local value can only be done if the type isn't
+                // partially moved.
+                ExprKind::Field(base_expr, _)
+                    if matches!(
+                        base_expr.kind,
+                        ExprKind::Path(QPath::Resolved(_, Path { res: Res::Local(_), .. }))
+                    ) && can_partially_move_ty(self.cx, self.cx.typeck_results().expr_ty(base_expr)) =>
+                {
+                    // TODO: check if the local has been partially moved. Assume it has for now.
+                    self.make_closure = false;
+                    return;
+                }
+                _ => (),
+            };
+            walk_expr(self, e);
+        }
+    }
+
+    let mut v = V { cx, make_closure: true };
+    v.visit_expr(expr);
+    v.make_closure
+}
+
 // Checks whether the expression could be passed as a function, or whether a closure is needed.
 // Returns the function to be passed to `map` if it exists.
 fn can_pass_as_func(cx: &LateContext<'tcx>, binding: Ident, expr: &'tcx Expr<'_>) -> Option<&'tcx Expr<'tcx>> {
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 8e5cf5dc654..05523943511 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -456,6 +456,18 @@ pub fn has_drop<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
     }
 }
 
+/// Checks whether a type can be partially moved.
+pub fn can_partially_move_ty(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
+    if has_drop(cx, ty) || is_copy(cx, ty) {
+        return false;
+    }
+    match ty.kind() {
+        ty::Param(_) => false,
+        ty::Adt(def, subs) => def.all_fields().any(|f| !is_copy(cx, f.ty(cx.tcx, subs))),
+        _ => true,
+    }
+}
+
 /// Returns the method names and argument list of nested method call expressions that make up
 /// `expr`. method/span lists are sorted with the most recent call first.
 pub fn method_calls<'tcx>(
diff --git a/tests/ui/manual_map_option.fixed b/tests/ui/manual_map_option.fixed
index 19350906758..428aac43940 100644
--- a/tests/ui/manual_map_option.fixed
+++ b/tests/ui/manual_map_option.fixed
@@ -1,7 +1,13 @@
 // run-rustfix
 
 #![warn(clippy::manual_map)]
-#![allow(clippy::no_effect, clippy::map_identity, clippy::unit_arg, clippy::match_ref_pats)]
+#![allow(
+    clippy::no_effect,
+    clippy::map_identity,
+    clippy::unit_arg,
+    clippy::match_ref_pats,
+    dead_code
+)]
 
 fn main() {
     Some(0).map(|_| 2);
@@ -67,4 +73,41 @@ fn main() {
         Some(Some((x, 1))) => Some(x),
         _ => None,
     };
+
+    // #6795
+    fn f1() -> Result<(), ()> {
+        let _ = match Some(Ok(())) {
+            Some(x) => Some(x?),
+            None => None,
+        };
+        Ok(())
+    }
+
+    for &x in Some(Some(true)).iter() {
+        let _ = match x {
+            Some(x) => Some(if x { continue } else { x }),
+            None => None,
+        };
+    }
+
+    // #6797
+    let x1 = (Some(String::new()), 0);
+    let x2 = x1.0;
+    match x2 {
+        Some(x) => Some((x, x1.1)),
+        None => None,
+    };
+
+    struct S1 {
+        x: Option<String>,
+        y: u32,
+    }
+    impl S1 {
+        fn f(self) -> Option<(String, u32)> {
+            match self.x {
+                Some(x) => Some((x, self.y)),
+                None => None,
+            }
+        }
+    }
 }
diff --git a/tests/ui/manual_map_option.rs b/tests/ui/manual_map_option.rs
index 8b8187db0a9..0f4a5bb2eb7 100644
--- a/tests/ui/manual_map_option.rs
+++ b/tests/ui/manual_map_option.rs
@@ -1,7 +1,13 @@
 // run-rustfix
 
 #![warn(clippy::manual_map)]
-#![allow(clippy::no_effect, clippy::map_identity, clippy::unit_arg, clippy::match_ref_pats)]
+#![allow(
+    clippy::no_effect,
+    clippy::map_identity,
+    clippy::unit_arg,
+    clippy::match_ref_pats,
+    dead_code
+)]
 
 fn main() {
     match Some(0) {
@@ -119,4 +125,41 @@ fn main() {
         Some(Some((x, 1))) => Some(x),
         _ => None,
     };
+
+    // #6795
+    fn f1() -> Result<(), ()> {
+        let _ = match Some(Ok(())) {
+            Some(x) => Some(x?),
+            None => None,
+        };
+        Ok(())
+    }
+
+    for &x in Some(Some(true)).iter() {
+        let _ = match x {
+            Some(x) => Some(if x { continue } else { x }),
+            None => None,
+        };
+    }
+
+    // #6797
+    let x1 = (Some(String::new()), 0);
+    let x2 = x1.0;
+    match x2 {
+        Some(x) => Some((x, x1.1)),
+        None => None,
+    };
+
+    struct S1 {
+        x: Option<String>,
+        y: u32,
+    }
+    impl S1 {
+        fn f(self) -> Option<(String, u32)> {
+            match self.x {
+                Some(x) => Some((x, self.y)),
+                None => None,
+            }
+        }
+    }
 }
diff --git a/tests/ui/manual_map_option.stderr b/tests/ui/manual_map_option.stderr
index 210a30d05d4..49a51737784 100644
--- a/tests/ui/manual_map_option.stderr
+++ b/tests/ui/manual_map_option.stderr
@@ -1,5 +1,5 @@
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:7:5
+  --> $DIR/manual_map_option.rs:13:5
    |
 LL | /     match Some(0) {
 LL | |         Some(_) => Some(2),
@@ -10,7 +10,7 @@ LL | |     };
    = note: `-D clippy::manual-map` implied by `-D warnings`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:12:5
+  --> $DIR/manual_map_option.rs:18:5
    |
 LL | /     match Some(0) {
 LL | |         Some(x) => Some(x + 1),
@@ -19,7 +19,7 @@ LL | |     };
    | |_____^ help: try this: `Some(0).map(|x| x + 1)`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:17:5
+  --> $DIR/manual_map_option.rs:23:5
    |
 LL | /     match Some("") {
 LL | |         Some(x) => Some(x.is_empty()),
@@ -28,7 +28,7 @@ LL | |     };
    | |_____^ help: try this: `Some("").map(|x| x.is_empty())`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:22:5
+  --> $DIR/manual_map_option.rs:28:5
    |
 LL | /     if let Some(x) = Some(0) {
 LL | |         Some(!x)
@@ -38,7 +38,7 @@ LL | |     };
    | |_____^ help: try this: `Some(0).map(|x| !x)`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:29:5
+  --> $DIR/manual_map_option.rs:35:5
    |
 LL | /     match Some(0) {
 LL | |         Some(x) => { Some(std::convert::identity(x)) }
@@ -47,7 +47,7 @@ LL | |     };
    | |_____^ help: try this: `Some(0).map(std::convert::identity)`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:34:5
+  --> $DIR/manual_map_option.rs:40:5
    |
 LL | /     match Some(&String::new()) {
 LL | |         Some(x) => Some(str::len(x)),
@@ -56,7 +56,7 @@ LL | |     };
    | |_____^ help: try this: `Some(&String::new()).map(|x| str::len(x))`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:44:5
+  --> $DIR/manual_map_option.rs:50:5
    |
 LL | /     match &Some([0, 1]) {
 LL | |         Some(x) => Some(x[0]),
@@ -65,7 +65,7 @@ LL | |     };
    | |_____^ help: try this: `Some([0, 1]).as_ref().map(|x| x[0])`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:49:5
+  --> $DIR/manual_map_option.rs:55:5
    |
 LL | /     match &Some(0) {
 LL | |         &Some(x) => Some(x * 2),
@@ -74,7 +74,7 @@ LL | |     };
    | |_____^ help: try this: `Some(0).map(|x| x * 2)`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:54:5
+  --> $DIR/manual_map_option.rs:60:5
    |
 LL | /     match Some(String::new()) {
 LL | |         Some(ref x) => Some(x.is_empty()),
@@ -83,7 +83,7 @@ LL | |     };
    | |_____^ help: try this: `Some(String::new()).as_ref().map(|x| x.is_empty())`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:59:5
+  --> $DIR/manual_map_option.rs:65:5
    |
 LL | /     match &&Some(String::new()) {
 LL | |         Some(x) => Some(x.len()),
@@ -92,7 +92,7 @@ LL | |     };
    | |_____^ help: try this: `Some(String::new()).as_ref().map(|x| x.len())`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:64:5
+  --> $DIR/manual_map_option.rs:70:5
    |
 LL | /     match &&Some(0) {
 LL | |         &&Some(x) => Some(x + x),
@@ -101,7 +101,7 @@ LL | |     };
    | |_____^ help: try this: `Some(0).map(|x| x + x)`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:77:9
+  --> $DIR/manual_map_option.rs:83:9
    |
 LL | /         match &mut Some(String::new()) {
 LL | |             Some(x) => Some(x.push_str("")),
@@ -110,7 +110,7 @@ LL | |         };
    | |_________^ help: try this: `Some(String::new()).as_mut().map(|x| x.push_str(""))`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:83:5
+  --> $DIR/manual_map_option.rs:89:5
    |
 LL | /     match &mut Some(String::new()) {
 LL | |         Some(ref x) => Some(x.len()),
@@ -119,7 +119,7 @@ LL | |     };
    | |_____^ help: try this: `Some(String::new()).as_ref().map(|x| x.len())`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:88:5
+  --> $DIR/manual_map_option.rs:94:5
    |
 LL | /     match &mut &Some(String::new()) {
 LL | |         Some(x) => Some(x.is_empty()),
@@ -128,7 +128,7 @@ LL | |     };
    | |_____^ help: try this: `Some(String::new()).as_ref().map(|x| x.is_empty())`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:93:5
+  --> $DIR/manual_map_option.rs:99:5
    |
 LL | /     match Some((0, 1, 2)) {
 LL | |         Some((x, y, z)) => Some(x + y + z),
@@ -137,7 +137,7 @@ LL | |     };
    | |_____^ help: try this: `Some((0, 1, 2)).map(|(x, y, z)| x + y + z)`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:98:5
+  --> $DIR/manual_map_option.rs:104:5
    |
 LL | /     match Some([1, 2, 3]) {
 LL | |         Some([first, ..]) => Some(first),
@@ -146,7 +146,7 @@ LL | |     };
    | |_____^ help: try this: `Some([1, 2, 3]).map(|[first, ..]| first)`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:103:5
+  --> $DIR/manual_map_option.rs:109:5
    |
 LL | /     match &Some((String::new(), "test")) {
 LL | |         Some((x, y)) => Some((y, x)),
-- 
cgit 1.4.1-3-g733a5


From 09a827ac735b138a06f3ac140a1c465b05a92ed1 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Fri, 26 Feb 2021 16:27:41 -0500
Subject: Revert #6796: Downgrade manual_map to nursery

---
 clippy_lints/src/lib.rs        | 3 ++-
 clippy_lints/src/manual_map.rs | 4 ++--
 2 files changed, 4 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index faec9ec31f3..176eeadcc63 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1540,6 +1540,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&loops::WHILE_LET_ON_ITERATOR),
         LintId::of(&main_recursion::MAIN_RECURSION),
         LintId::of(&manual_async_fn::MANUAL_ASYNC_FN),
+        LintId::of(&manual_map::MANUAL_MAP),
         LintId::of(&manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE),
         LintId::of(&manual_strip::MANUAL_STRIP),
         LintId::of(&manual_unwrap_or::MANUAL_UNWRAP_OR),
@@ -1770,6 +1771,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&loops::WHILE_LET_ON_ITERATOR),
         LintId::of(&main_recursion::MAIN_RECURSION),
         LintId::of(&manual_async_fn::MANUAL_ASYNC_FN),
+        LintId::of(&manual_map::MANUAL_MAP),
         LintId::of(&manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE),
         LintId::of(&map_clone::MAP_CLONE),
         LintId::of(&matches::INFALLIBLE_DESTRUCTURING_MATCH),
@@ -2045,7 +2047,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&floating_point_arithmetic::SUBOPTIMAL_FLOPS),
         LintId::of(&future_not_send::FUTURE_NOT_SEND),
         LintId::of(&let_if_seq::USELESS_LET_IF_SEQ),
-        LintId::of(&manual_map::MANUAL_MAP),
         LintId::of(&missing_const_for_fn::MISSING_CONST_FOR_FN),
         LintId::of(&mutable_debug_assertion::DEBUG_ASSERT_WITH_MUT_CALL),
         LintId::of(&mutex_atomic::MUTEX_INTEGER),
diff --git a/clippy_lints/src/manual_map.rs b/clippy_lints/src/manual_map.rs
index bc6544ee79e..e6e70004527 100644
--- a/clippy_lints/src/manual_map.rs
+++ b/clippy_lints/src/manual_map.rs
@@ -23,7 +23,7 @@ declare_clippy_lint! {
     ///
     /// **Why is this bad?** Using the `map` method is clearer and more concise.
     ///
-    /// **Known problems:** `map` is not capable of representing some control flow which works fine in `match`.
+    /// **Known problems:** None.
     ///
     /// **Example:**
     ///
@@ -38,7 +38,7 @@ declare_clippy_lint! {
     /// Some(0).map(|x| x + 1);
     /// ```
     pub MANUAL_MAP,
-    nursery,
+    style,
     "reimplementation of `map`"
 }
 
-- 
cgit 1.4.1-3-g733a5


From 3d3cfd3754d616db959015eb7bd3c6238961320a Mon Sep 17 00:00:00 2001
From: Andrea Nall <anall@andreanall.com>
Date: Fri, 12 Feb 2021 04:27:04 +0000
Subject: added new lint `implicit_clone`

---
 CHANGELOG.md                                 |   1 +
 clippy_lints/src/lib.rs                      |   2 +
 clippy_lints/src/methods/implicit_clone.rs   |  32 ++++++++
 clippy_lints/src/methods/mod.rs              |  32 ++++++++
 clippy_utils/src/lib.rs                      |  16 ++++
 tests/ui/cmp_owned/without_suggestion.rs     |   1 +
 tests/ui/cmp_owned/without_suggestion.stderr |   6 +-
 tests/ui/implicit_clone.rs                   | 108 +++++++++++++++++++++++++++
 tests/ui/implicit_clone.stderr               |  64 ++++++++++++++++
 tests/ui/redundant_clone.fixed               |   1 +
 tests/ui/redundant_clone.rs                  |   1 +
 tests/ui/redundant_clone.stderr              |  56 +++++++-------
 12 files changed, 289 insertions(+), 31 deletions(-)
 create mode 100644 clippy_lints/src/methods/implicit_clone.rs
 create mode 100644 tests/ui/implicit_clone.rs
 create mode 100644 tests/ui/implicit_clone.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index d96c74b6e41..687f7447202 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2104,6 +2104,7 @@ Released 2018-09-13
 [`if_not_else`]: https://rust-lang.github.io/rust-clippy/master/index.html#if_not_else
 [`if_same_then_else`]: https://rust-lang.github.io/rust-clippy/master/index.html#if_same_then_else
 [`ifs_same_cond`]: https://rust-lang.github.io/rust-clippy/master/index.html#ifs_same_cond
+[`implicit_clone`]: https://rust-lang.github.io/rust-clippy/master/index.html#implicit_clone
 [`implicit_hasher`]: https://rust-lang.github.io/rust-clippy/master/index.html#implicit_hasher
 [`implicit_return`]: https://rust-lang.github.io/rust-clippy/master/index.html#implicit_return
 [`implicit_saturating_sub`]: https://rust-lang.github.io/rust-clippy/master/index.html#implicit_saturating_sub
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index faec9ec31f3..fa8f03eb445 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -769,6 +769,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &methods::FLAT_MAP_IDENTITY,
         &methods::FROM_ITER_INSTEAD_OF_COLLECT,
         &methods::GET_UNWRAP,
+        &methods::IMPLICIT_CLONE,
         &methods::INEFFICIENT_TO_STRING,
         &methods::INSPECT_FOR_EACH,
         &methods::INTO_ITER_ON_REF,
@@ -1380,6 +1381,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&matches::SINGLE_MATCH_ELSE),
         LintId::of(&methods::FILTER_MAP),
         LintId::of(&methods::FILTER_MAP_NEXT),
+        LintId::of(&methods::IMPLICIT_CLONE),
         LintId::of(&methods::INEFFICIENT_TO_STRING),
         LintId::of(&methods::MAP_FLATTEN),
         LintId::of(&methods::MAP_UNWRAP_OR),
diff --git a/clippy_lints/src/methods/implicit_clone.rs b/clippy_lints/src/methods/implicit_clone.rs
new file mode 100644
index 00000000000..a769493d11d
--- /dev/null
+++ b/clippy_lints/src/methods/implicit_clone.rs
@@ -0,0 +1,32 @@
+use crate::utils::span_lint_and_sugg;
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir as hir;
+use rustc_hir::ExprKind;
+use rustc_lint::LateContext;
+use rustc_middle::ty::TyS;
+use rustc_span::symbol::Symbol;
+
+use super::IMPLICIT_CLONE;
+use clippy_utils::is_diagnostic_assoc_item;
+
+pub fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, trait_diagnostic: Symbol) {
+    if_chain! {
+        if let ExprKind::MethodCall(method_path, _, [arg], _) = &expr.kind;
+        let return_type = cx.typeck_results().expr_ty(&expr);
+        let input_type = cx.typeck_results().expr_ty(arg).peel_refs();
+        if let Some(expr_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
+        if let Some(ty_name) = input_type.ty_adt_def().map(|adt_def| cx.tcx.item_name(adt_def.did));
+        if TyS::same_type(return_type, input_type);
+        if is_diagnostic_assoc_item(cx, expr_def_id, trait_diagnostic);
+        then {
+            span_lint_and_sugg(
+                cx,IMPLICIT_CLONE,method_path.ident.span,
+                &format!("implicitly cloning a `{}` by calling `{}` on its dereferenced type", ty_name, method_path.ident.name),
+                "consider using",
+                "clone".to_string(),
+                Applicability::MachineApplicable
+            );
+        }
+    }
+}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 5fb3ae1890d..6f491144435 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1,6 +1,7 @@
 mod bind_instead_of_map;
 mod bytes_nth;
 mod filter_map_identity;
+mod implicit_clone;
 mod inefficient_to_string;
 mod inspect_for_each;
 mod manual_saturating_arithmetic;
@@ -1513,6 +1514,32 @@ declare_clippy_lint! {
     "replace `.bytes().nth()` with `.as_bytes().get()`"
 }
 
+declare_clippy_lint! {
+    /// **What it does:** Checks for the usage of `_.to_owned()`, `vec.to_vec()`, or similar when calling `_.clone()` would be clearer.
+    ///
+    /// **Why is this bad?** These methods do the same thing as `_.clone()` but may be confusing as
+    /// to why we are calling `to_vec` on something that is already a `Vec` or calling `to_owned` on something that is already owned.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// let a = vec![1, 2, 3];
+    /// let b = a.to_vec();
+    /// let c = a.to_owned();
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// let a = vec![1, 2, 3];
+    /// let b = a.clone();
+    /// let c = a.clone();
+    /// ```
+    pub IMPLICIT_CLONE,
+    pedantic,
+    "implicitly cloning a value by invoking a function on its dereferenced type"
+}
+
 pub struct Methods {
     msrv: Option<RustcVersion>,
 }
@@ -1579,6 +1606,7 @@ impl_lint_pass!(Methods => [
     MAP_COLLECT_RESULT_UNIT,
     FROM_ITER_INSTEAD_OF_COLLECT,
     INSPECT_FOR_EACH,
+    IMPLICIT_CLONE
 ]);
 
 impl<'tcx> LateLintPass<'tcx> for Methods {
@@ -1670,6 +1698,10 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             ["ok_or_else", ..] => unnecessary_lazy_eval::lint(cx, expr, arg_lists[0], "ok_or"),
             ["collect", "map"] => lint_map_collect(cx, expr, arg_lists[1], arg_lists[0]),
             ["for_each", "inspect"] => inspect_for_each::lint(cx, expr, method_spans[1]),
+            ["to_owned", ..] => implicit_clone::check(cx, expr, sym::ToOwned),
+            ["to_os_string", ..] => implicit_clone::check(cx, expr, sym::OsStr),
+            ["to_path_buf", ..] => implicit_clone::check(cx, expr, sym::Path),
+            ["to_vec", ..] => implicit_clone::check(cx, expr, sym::slice),
             _ => {},
         }
 
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 8e5cf5dc654..2380ea4c7bf 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -237,6 +237,22 @@ pub fn match_trait_method(cx: &LateContext<'_>, expr: &Expr<'_>, path: &[&str])
     trt_id.map_or(false, |trt_id| match_def_path(cx, trt_id, path))
 }
 
+/// Checks if the method call given in `expr` belongs to a trait or other container with a given
+/// diagnostic item
+pub fn is_diagnostic_assoc_item(cx: &LateContext<'_>, def_id: DefId, diag_item: Symbol) -> bool {
+    cx.tcx
+        .opt_associated_item(def_id)
+        .and_then(|associated_item| match associated_item.container {
+            ty::TraitContainer(assoc_def_id) => Some(assoc_def_id),
+            ty::ImplContainer(assoc_def_id) => match cx.tcx.type_of(assoc_def_id).kind() {
+                ty::Adt(adt, _) => Some(adt.did),
+                ty::Slice(_) => cx.tcx.get_diagnostic_item(sym::slice), // this isn't perfect but it works
+                _ => None,
+            },
+        })
+        .map_or(false, |assoc_def_id| cx.tcx.is_diagnostic_item(diag_item, assoc_def_id))
+}
+
 /// Checks if an expression references a variable of the given name.
 pub fn match_var(expr: &Expr<'_>, var: Symbol) -> bool {
     if let ExprKind::Path(QPath::Resolved(None, ref path)) = expr.kind {
diff --git a/tests/ui/cmp_owned/without_suggestion.rs b/tests/ui/cmp_owned/without_suggestion.rs
index 9ab8795474c..f44a3901fb4 100644
--- a/tests/ui/cmp_owned/without_suggestion.rs
+++ b/tests/ui/cmp_owned/without_suggestion.rs
@@ -1,4 +1,5 @@
 #[allow(clippy::unnecessary_operation)]
+#[allow(clippy::implicit_clone)]
 
 fn main() {
     let x = &Baz;
diff --git a/tests/ui/cmp_owned/without_suggestion.stderr b/tests/ui/cmp_owned/without_suggestion.stderr
index 6e8a5ad2a17..2ea3d8fac0d 100644
--- a/tests/ui/cmp_owned/without_suggestion.stderr
+++ b/tests/ui/cmp_owned/without_suggestion.stderr
@@ -1,5 +1,5 @@
 error: this creates an owned instance just for comparison
-  --> $DIR/without_suggestion.rs:6:5
+  --> $DIR/without_suggestion.rs:7:5
    |
 LL |     y.to_owned() == *x;
    |     ^^^^^^^^^^^^^^^^^^ try implementing the comparison without allocating
@@ -7,13 +7,13 @@ LL |     y.to_owned() == *x;
    = note: `-D clippy::cmp-owned` implied by `-D warnings`
 
 error: this creates an owned instance just for comparison
-  --> $DIR/without_suggestion.rs:10:5
+  --> $DIR/without_suggestion.rs:11:5
    |
 LL |     y.to_owned() == **x;
    |     ^^^^^^^^^^^^^^^^^^^ try implementing the comparison without allocating
 
 error: this creates an owned instance just for comparison
-  --> $DIR/without_suggestion.rs:17:9
+  --> $DIR/without_suggestion.rs:18:9
    |
 LL |         self.to_owned() == *other
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^ try implementing the comparison without allocating
diff --git a/tests/ui/implicit_clone.rs b/tests/ui/implicit_clone.rs
new file mode 100644
index 00000000000..19101522163
--- /dev/null
+++ b/tests/ui/implicit_clone.rs
@@ -0,0 +1,108 @@
+#![warn(clippy::implicit_clone)]
+#![allow(clippy::redundant_clone)]
+use std::borrow::Borrow;
+use std::ffi::{OsStr, OsString};
+use std::path::PathBuf;
+
+fn return_owned_from_slice(slice: &[u32]) -> Vec<u32> {
+    slice.to_owned()
+}
+
+pub fn own_same<T>(v: T) -> T
+where
+    T: ToOwned<Owned = T>,
+{
+    v.to_owned()
+}
+
+pub fn own_same_from_ref<T>(v: &T) -> T
+where
+    T: ToOwned<Owned = T>,
+{
+    v.to_owned()
+}
+
+pub fn own_different<T, U>(v: T) -> U
+where
+    T: ToOwned<Owned = U>,
+{
+    v.to_owned()
+}
+
+#[derive(Copy, Clone)]
+struct Kitten {}
+impl Kitten {
+    // badly named method
+    fn to_vec(self) -> Kitten {
+        Kitten {}
+    }
+}
+impl Borrow<BorrowedKitten> for Kitten {
+    fn borrow(&self) -> &BorrowedKitten {
+        static VALUE: BorrowedKitten = BorrowedKitten {};
+        &VALUE
+    }
+}
+
+struct BorrowedKitten {}
+impl ToOwned for BorrowedKitten {
+    type Owned = Kitten;
+    fn to_owned(&self) -> Kitten {
+        Kitten {}
+    }
+}
+
+mod weird {
+    #[allow(clippy::ptr_arg)]
+    pub fn to_vec(v: &Vec<u32>) -> Vec<u32> {
+        v.clone()
+    }
+}
+
+fn main() {
+    let vec = vec![5];
+    let _ = return_owned_from_slice(&vec);
+    let _ = vec.to_owned();
+    let _ = vec.to_vec();
+
+    let vec_ref = &vec;
+    let _ = return_owned_from_slice(&vec_ref);
+    let _ = vec_ref.to_owned();
+    let _ = vec_ref.to_vec();
+
+    // we expect no lint for this
+    let _ = weird::to_vec(&vec);
+
+    // we expect no lints for this
+    let slice: &[u32] = &[1, 2, 3, 4, 5];
+    let _ = return_owned_from_slice(slice);
+    let _ = slice.to_owned();
+    let _ = slice.to_vec();
+
+    let str = "hello world".to_string();
+    let _ = str.to_owned();
+
+    // testing w/ an arbitrary type
+    let kitten = Kitten {};
+    let _ = kitten.to_owned();
+    let _ = own_same_from_ref(&kitten);
+    // this shouln't lint
+    let _ = kitten.to_vec();
+
+    // we expect no lints for this
+    let borrowed = BorrowedKitten {};
+    let _ = borrowed.to_owned();
+
+    let pathbuf = PathBuf::new();
+    let _ = pathbuf.to_owned();
+    let _ = pathbuf.to_path_buf();
+
+    let os_string = OsString::from("foo");
+    let _ = os_string.to_owned();
+    let _ = os_string.to_os_string();
+
+    // we expect no lints for this
+    let os_str = OsStr::new("foo");
+    let _ = os_str.to_owned();
+    let _ = os_str.to_os_string();
+}
diff --git a/tests/ui/implicit_clone.stderr b/tests/ui/implicit_clone.stderr
new file mode 100644
index 00000000000..e6f7527b672
--- /dev/null
+++ b/tests/ui/implicit_clone.stderr
@@ -0,0 +1,64 @@
+error: implicitly cloning a `Vec` by calling `to_owned` on its dereferenced type
+  --> $DIR/implicit_clone.rs:65:17
+   |
+LL |     let _ = vec.to_owned();
+   |                 ^^^^^^^^ help: consider using: `clone`
+   |
+   = note: `-D clippy::implicit-clone` implied by `-D warnings`
+
+error: implicitly cloning a `Vec` by calling `to_vec` on its dereferenced type
+  --> $DIR/implicit_clone.rs:66:17
+   |
+LL |     let _ = vec.to_vec();
+   |                 ^^^^^^ help: consider using: `clone`
+
+error: implicitly cloning a `Vec` by calling `to_owned` on its dereferenced type
+  --> $DIR/implicit_clone.rs:70:21
+   |
+LL |     let _ = vec_ref.to_owned();
+   |                     ^^^^^^^^ help: consider using: `clone`
+
+error: implicitly cloning a `Vec` by calling `to_vec` on its dereferenced type
+  --> $DIR/implicit_clone.rs:71:21
+   |
+LL |     let _ = vec_ref.to_vec();
+   |                     ^^^^^^ help: consider using: `clone`
+
+error: implicitly cloning a `String` by calling `to_owned` on its dereferenced type
+  --> $DIR/implicit_clone.rs:83:17
+   |
+LL |     let _ = str.to_owned();
+   |                 ^^^^^^^^ help: consider using: `clone`
+
+error: implicitly cloning a `Kitten` by calling `to_owned` on its dereferenced type
+  --> $DIR/implicit_clone.rs:87:20
+   |
+LL |     let _ = kitten.to_owned();
+   |                    ^^^^^^^^ help: consider using: `clone`
+
+error: implicitly cloning a `PathBuf` by calling `to_owned` on its dereferenced type
+  --> $DIR/implicit_clone.rs:97:21
+   |
+LL |     let _ = pathbuf.to_owned();
+   |                     ^^^^^^^^ help: consider using: `clone`
+
+error: implicitly cloning a `PathBuf` by calling `to_path_buf` on its dereferenced type
+  --> $DIR/implicit_clone.rs:98:21
+   |
+LL |     let _ = pathbuf.to_path_buf();
+   |                     ^^^^^^^^^^^ help: consider using: `clone`
+
+error: implicitly cloning a `OsString` by calling `to_owned` on its dereferenced type
+  --> $DIR/implicit_clone.rs:101:23
+   |
+LL |     let _ = os_string.to_owned();
+   |                       ^^^^^^^^ help: consider using: `clone`
+
+error: implicitly cloning a `OsString` by calling `to_os_string` on its dereferenced type
+  --> $DIR/implicit_clone.rs:102:23
+   |
+LL |     let _ = os_string.to_os_string();
+   |                       ^^^^^^^^^^^^ help: consider using: `clone`
+
+error: aborting due to 10 previous errors
+
diff --git a/tests/ui/redundant_clone.fixed b/tests/ui/redundant_clone.fixed
index cdeefda4c23..a5847e37c97 100644
--- a/tests/ui/redundant_clone.fixed
+++ b/tests/ui/redundant_clone.fixed
@@ -1,6 +1,7 @@
 // run-rustfix
 // rustfix-only-machine-applicable
 
+#![allow(clippy::implicit_clone)]
 use std::ffi::OsString;
 use std::path::Path;
 
diff --git a/tests/ui/redundant_clone.rs b/tests/ui/redundant_clone.rs
index acb7ffb305f..dab8d7fb1c7 100644
--- a/tests/ui/redundant_clone.rs
+++ b/tests/ui/redundant_clone.rs
@@ -1,6 +1,7 @@
 // run-rustfix
 // rustfix-only-machine-applicable
 
+#![allow(clippy::implicit_clone)]
 use std::ffi::OsString;
 use std::path::Path;
 
diff --git a/tests/ui/redundant_clone.stderr b/tests/ui/redundant_clone.stderr
index 89b39254299..87c219316ce 100644
--- a/tests/ui/redundant_clone.stderr
+++ b/tests/ui/redundant_clone.stderr
@@ -1,168 +1,168 @@
 error: redundant clone
-  --> $DIR/redundant_clone.rs:8:42
+  --> $DIR/redundant_clone.rs:9:42
    |
 LL |     let _s = ["lorem", "ipsum"].join(" ").to_string();
    |                                          ^^^^^^^^^^^^ help: remove this
    |
    = note: `-D clippy::redundant-clone` implied by `-D warnings`
 note: this value is dropped without further use
-  --> $DIR/redundant_clone.rs:8:14
+  --> $DIR/redundant_clone.rs:9:14
    |
 LL |     let _s = ["lorem", "ipsum"].join(" ").to_string();
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: redundant clone
-  --> $DIR/redundant_clone.rs:11:15
+  --> $DIR/redundant_clone.rs:12:15
    |
 LL |     let _s = s.clone();
    |               ^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> $DIR/redundant_clone.rs:11:14
+  --> $DIR/redundant_clone.rs:12:14
    |
 LL |     let _s = s.clone();
    |              ^
 
 error: redundant clone
-  --> $DIR/redundant_clone.rs:14:15
+  --> $DIR/redundant_clone.rs:15:15
    |
 LL |     let _s = s.to_string();
    |               ^^^^^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> $DIR/redundant_clone.rs:14:14
+  --> $DIR/redundant_clone.rs:15:14
    |
 LL |     let _s = s.to_string();
    |              ^
 
 error: redundant clone
-  --> $DIR/redundant_clone.rs:17:15
+  --> $DIR/redundant_clone.rs:18:15
    |
 LL |     let _s = s.to_owned();
    |               ^^^^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> $DIR/redundant_clone.rs:17:14
+  --> $DIR/redundant_clone.rs:18:14
    |
 LL |     let _s = s.to_owned();
    |              ^
 
 error: redundant clone
-  --> $DIR/redundant_clone.rs:19:42
+  --> $DIR/redundant_clone.rs:20:42
    |
 LL |     let _s = Path::new("/a/b/").join("c").to_owned();
    |                                          ^^^^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> $DIR/redundant_clone.rs:19:14
+  --> $DIR/redundant_clone.rs:20:14
    |
 LL |     let _s = Path::new("/a/b/").join("c").to_owned();
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: redundant clone
-  --> $DIR/redundant_clone.rs:21:42
+  --> $DIR/redundant_clone.rs:22:42
    |
 LL |     let _s = Path::new("/a/b/").join("c").to_path_buf();
    |                                          ^^^^^^^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> $DIR/redundant_clone.rs:21:14
+  --> $DIR/redundant_clone.rs:22:14
    |
 LL |     let _s = Path::new("/a/b/").join("c").to_path_buf();
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: redundant clone
-  --> $DIR/redundant_clone.rs:23:29
+  --> $DIR/redundant_clone.rs:24:29
    |
 LL |     let _s = OsString::new().to_owned();
    |                             ^^^^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> $DIR/redundant_clone.rs:23:14
+  --> $DIR/redundant_clone.rs:24:14
    |
 LL |     let _s = OsString::new().to_owned();
    |              ^^^^^^^^^^^^^^^
 
 error: redundant clone
-  --> $DIR/redundant_clone.rs:25:29
+  --> $DIR/redundant_clone.rs:26:29
    |
 LL |     let _s = OsString::new().to_os_string();
    |                             ^^^^^^^^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> $DIR/redundant_clone.rs:25:14
+  --> $DIR/redundant_clone.rs:26:14
    |
 LL |     let _s = OsString::new().to_os_string();
    |              ^^^^^^^^^^^^^^^
 
 error: redundant clone
-  --> $DIR/redundant_clone.rs:32:19
+  --> $DIR/redundant_clone.rs:33:19
    |
 LL |     let _t = tup.0.clone();
    |                   ^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> $DIR/redundant_clone.rs:32:14
+  --> $DIR/redundant_clone.rs:33:14
    |
 LL |     let _t = tup.0.clone();
    |              ^^^^^
 
 error: redundant clone
-  --> $DIR/redundant_clone.rs:62:22
+  --> $DIR/redundant_clone.rs:63:22
    |
 LL |         (a.clone(), a.clone())
    |                      ^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> $DIR/redundant_clone.rs:62:21
+  --> $DIR/redundant_clone.rs:63:21
    |
 LL |         (a.clone(), a.clone())
    |                     ^
 
 error: redundant clone
-  --> $DIR/redundant_clone.rs:122:15
+  --> $DIR/redundant_clone.rs:123:15
    |
 LL |     let _s = s.clone();
    |               ^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> $DIR/redundant_clone.rs:122:14
+  --> $DIR/redundant_clone.rs:123:14
    |
 LL |     let _s = s.clone();
    |              ^
 
 error: redundant clone
-  --> $DIR/redundant_clone.rs:123:15
+  --> $DIR/redundant_clone.rs:124:15
    |
 LL |     let _t = t.clone();
    |               ^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> $DIR/redundant_clone.rs:123:14
+  --> $DIR/redundant_clone.rs:124:14
    |
 LL |     let _t = t.clone();
    |              ^
 
 error: redundant clone
-  --> $DIR/redundant_clone.rs:133:19
+  --> $DIR/redundant_clone.rs:134:19
    |
 LL |         let _f = f.clone();
    |                   ^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> $DIR/redundant_clone.rs:133:18
+  --> $DIR/redundant_clone.rs:134:18
    |
 LL |         let _f = f.clone();
    |                  ^
 
 error: redundant clone
-  --> $DIR/redundant_clone.rs:145:14
+  --> $DIR/redundant_clone.rs:146:14
    |
 LL |     let y = x.clone().join("matthias");
    |              ^^^^^^^^ help: remove this
    |
 note: cloned value is neither consumed nor mutated
-  --> $DIR/redundant_clone.rs:145:13
+  --> $DIR/redundant_clone.rs:146:13
    |
 LL |     let y = x.clone().join("matthias");
    |             ^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From 51617b83a18b2a0b1f0f2cae8c43e42043a86b76 Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Thu, 25 Feb 2021 23:06:50 +0900
Subject: new lint: iter_count

---
 CHANGELOG.md                         |  1 +
 clippy_lints/src/lib.rs              |  3 ++
 clippy_lints/src/methods/mod.rs      | 62 ++++++++++++++++++++++++++++++++++++
 tests/ui/auxiliary/option_helpers.rs |  4 +++
 tests/ui/iter_count.fixed            | 58 +++++++++++++++++++++++++++++++++
 tests/ui/iter_count.rs               | 58 +++++++++++++++++++++++++++++++++
 tests/ui/iter_count.stderr           | 52 ++++++++++++++++++++++++++++++
 7 files changed, 238 insertions(+)
 create mode 100644 tests/ui/iter_count.fixed
 create mode 100644 tests/ui/iter_count.rs
 create mode 100644 tests/ui/iter_count.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 687f7447202..41c334c6816 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2135,6 +2135,7 @@ Released 2018-09-13
 [`invisible_characters`]: https://rust-lang.github.io/rust-clippy/master/index.html#invisible_characters
 [`items_after_statements`]: https://rust-lang.github.io/rust-clippy/master/index.html#items_after_statements
 [`iter_cloned_collect`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_cloned_collect
+[`iter_count`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_count
 [`iter_next_loop`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_next_loop
 [`iter_next_slice`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_next_slice
 [`iter_nth`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_nth
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index fa8f03eb445..1ace4c8a10c 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -775,6 +775,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &methods::INTO_ITER_ON_REF,
         &methods::ITERATOR_STEP_BY_ZERO,
         &methods::ITER_CLONED_COLLECT,
+        &methods::ITER_COUNT,
         &methods::ITER_NEXT_SLICE,
         &methods::ITER_NTH,
         &methods::ITER_NTH_ZERO,
@@ -1577,6 +1578,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&methods::INTO_ITER_ON_REF),
         LintId::of(&methods::ITERATOR_STEP_BY_ZERO),
         LintId::of(&methods::ITER_CLONED_COLLECT),
+        LintId::of(&methods::ITER_COUNT),
         LintId::of(&methods::ITER_NEXT_SLICE),
         LintId::of(&methods::ITER_NTH),
         LintId::of(&methods::ITER_NTH_ZERO),
@@ -1881,6 +1883,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&methods::FILTER_NEXT),
         LintId::of(&methods::FLAT_MAP_IDENTITY),
         LintId::of(&methods::INSPECT_FOR_EACH),
+        LintId::of(&methods::ITER_COUNT),
         LintId::of(&methods::MANUAL_FILTER_MAP),
         LintId::of(&methods::MANUAL_FIND_MAP),
         LintId::of(&methods::OPTION_AS_REF_DEREF),
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 6f491144435..17e7f6f662d 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1540,6 +1540,32 @@ declare_clippy_lint! {
     "implicitly cloning a value by invoking a function on its dereferenced type"
 }
 
+declare_clippy_lint! {
+    /// **What it does:** Checks for the use of `.iter().count()`.
+    ///
+    /// **Why is this bad?** `.len()` is more efficient and more
+    /// readable.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// // Bad
+    /// let some_vec = vec![0, 1, 2, 3];
+    /// let _ = some_vec.iter().count();
+    /// let _ = &some_vec[..].iter().count();
+    ///
+    /// // Good
+    /// let some_vec = vec![0, 1, 2, 3];
+    /// let _ = some_vec.len();
+    /// let _ = &some_vec[..].len();
+    /// ```
+    pub ITER_COUNT,
+    complexity,
+    "replace `.iter().count()` with `.len()`"
+}
+
 pub struct Methods {
     msrv: Option<RustcVersion>,
 }
@@ -1585,6 +1611,7 @@ impl_lint_pass!(Methods => [
     MAP_FLATTEN,
     ITERATOR_STEP_BY_ZERO,
     ITER_NEXT_SLICE,
+    ITER_COUNT,
     ITER_NTH,
     ITER_NTH_ZERO,
     BYTES_NTH,
@@ -1664,6 +1691,8 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
                 lint_search_is_some(cx, expr, "rposition", arg_lists[1], arg_lists[0], method_spans[1])
             },
             ["extend", ..] => lint_extend(cx, expr, arg_lists[0]),
+            ["count", "iter"] => lint_iter_count(cx, expr, &arg_lists[1], false),
+            ["count", "iter_mut"] => lint_iter_count(cx, expr, &arg_lists[1], true),
             ["nth", "iter"] => lint_iter_nth(cx, expr, &arg_lists, false),
             ["nth", "iter_mut"] => lint_iter_nth(cx, expr, &arg_lists, true),
             ["nth", "bytes"] => bytes_nth::lints(cx, expr, &arg_lists[1]),
@@ -2632,6 +2661,39 @@ fn lint_iter_next<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, iter_
     }
 }
 
+fn lint_iter_count<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, iter_args: &'tcx [Expr<'tcx>], is_mut: bool) {
+    let mut_str = if is_mut { "_mut" } else { "" };
+    if_chain! {
+        let caller_type = if derefs_to_slice(cx, &iter_args[0], cx.typeck_results().expr_ty(&iter_args[0])).is_some() {
+            Some("slice")
+        } else if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&iter_args[0]), sym::vec_type) {
+            Some("Vec")
+        } else if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&iter_args[0]), sym!(vecdeque_type)) {
+            Some("VecDeque")
+        } else if match_trait_method(cx, expr, &paths::ITERATOR) {
+            Some("std::iter::Iterator")
+        } else {
+            None
+        };
+        if let Some(caller_type) = caller_type;
+        then {
+            let mut applicability = Applicability::MachineApplicable;
+            span_lint_and_sugg(
+                cx,
+                ITER_COUNT,
+                expr.span,
+                &format!("called `.iter{}().count()` on a `{}`", mut_str, caller_type),
+                "try",
+                format!(
+                    "{}.len()",
+                    snippet_with_applicability(cx, iter_args[0].span, "..", &mut applicability),
+                ),
+                applicability,
+            );
+        }
+    }
+}
+
 fn lint_iter_nth<'tcx>(
     cx: &LateContext<'tcx>,
     expr: &hir::Expr<'_>,
diff --git a/tests/ui/auxiliary/option_helpers.rs b/tests/ui/auxiliary/option_helpers.rs
index ed11c41e21c..7dc3f4ebd4d 100644
--- a/tests/ui/auxiliary/option_helpers.rs
+++ b/tests/ui/auxiliary/option_helpers.rs
@@ -48,4 +48,8 @@ impl IteratorFalsePositives {
     pub fn skip_while(self) -> IteratorFalsePositives {
         self
     }
+
+    pub fn count(self) -> usize {
+        self.foo as usize
+    }
 }
diff --git a/tests/ui/iter_count.fixed b/tests/ui/iter_count.fixed
new file mode 100644
index 00000000000..14cae1cd73e
--- /dev/null
+++ b/tests/ui/iter_count.fixed
@@ -0,0 +1,58 @@
+// run-rustfix
+// aux-build:option_helpers.rs
+
+#![warn(clippy::iter_count)]
+#![allow(unused_variables)]
+#![allow(unused_mut)]
+
+extern crate option_helpers;
+
+use option_helpers::IteratorFalsePositives;
+use std::collections::{HashSet, VecDeque};
+
+/// Struct to generate false positives for things with `.iter()`.
+#[derive(Copy, Clone)]
+struct HasIter;
+
+impl HasIter {
+    fn iter(self) -> IteratorFalsePositives {
+        IteratorFalsePositives { foo: 0 }
+    }
+
+    fn iter_mut(self) -> IteratorFalsePositives {
+        IteratorFalsePositives { foo: 0 }
+    }
+}
+
+fn main() {
+    let mut some_vec = vec![0, 1, 2, 3];
+    let mut boxed_slice: Box<[u8]> = Box::new([0, 1, 2, 3]);
+    let mut some_vec_deque: VecDeque<_> = some_vec.iter().cloned().collect();
+    let mut some_hash_set = HashSet::new();
+    some_hash_set.insert(1);
+
+    {
+        // Make sure we lint `.iter()` for relevant types.
+        let bad_vec = some_vec.len();
+        let bad_slice = &some_vec[..].len();
+        let bad_boxed_slice = boxed_slice.len();
+        let bad_vec_deque = some_vec_deque.len();
+        let bad_hash_set = some_hash_set.len();
+    }
+
+    {
+        // Make sure we lint `.iter_mut()` for relevant types.
+        let bad_vec = some_vec.len();
+    }
+    {
+        let bad_slice = &some_vec[..].len();
+    }
+    {
+        let bad_vec_deque = some_vec_deque.len();
+    }
+
+    // Make sure we don't lint for non-relevant types.
+    let false_positive = HasIter;
+    let ok = false_positive.iter().count();
+    let ok_mut = false_positive.iter_mut().count();
+}
diff --git a/tests/ui/iter_count.rs b/tests/ui/iter_count.rs
new file mode 100644
index 00000000000..dfe02e5d53e
--- /dev/null
+++ b/tests/ui/iter_count.rs
@@ -0,0 +1,58 @@
+// run-rustfix
+// aux-build:option_helpers.rs
+
+#![warn(clippy::iter_count)]
+#![allow(unused_variables)]
+#![allow(unused_mut)]
+
+extern crate option_helpers;
+
+use option_helpers::IteratorFalsePositives;
+use std::collections::{HashSet, VecDeque};
+
+/// Struct to generate false positives for things with `.iter()`.
+#[derive(Copy, Clone)]
+struct HasIter;
+
+impl HasIter {
+    fn iter(self) -> IteratorFalsePositives {
+        IteratorFalsePositives { foo: 0 }
+    }
+
+    fn iter_mut(self) -> IteratorFalsePositives {
+        IteratorFalsePositives { foo: 0 }
+    }
+}
+
+fn main() {
+    let mut some_vec = vec![0, 1, 2, 3];
+    let mut boxed_slice: Box<[u8]> = Box::new([0, 1, 2, 3]);
+    let mut some_vec_deque: VecDeque<_> = some_vec.iter().cloned().collect();
+    let mut some_hash_set = HashSet::new();
+    some_hash_set.insert(1);
+
+    {
+        // Make sure we lint `.iter()` for relevant types.
+        let bad_vec = some_vec.iter().count();
+        let bad_slice = &some_vec[..].iter().count();
+        let bad_boxed_slice = boxed_slice.iter().count();
+        let bad_vec_deque = some_vec_deque.iter().count();
+        let bad_hash_set = some_hash_set.iter().count();
+    }
+
+    {
+        // Make sure we lint `.iter_mut()` for relevant types.
+        let bad_vec = some_vec.iter_mut().count();
+    }
+    {
+        let bad_slice = &some_vec[..].iter_mut().count();
+    }
+    {
+        let bad_vec_deque = some_vec_deque.iter_mut().count();
+    }
+
+    // Make sure we don't lint for non-relevant types.
+    let false_positive = HasIter;
+    let ok = false_positive.iter().count();
+    let ok_mut = false_positive.iter_mut().count();
+}
diff --git a/tests/ui/iter_count.stderr b/tests/ui/iter_count.stderr
new file mode 100644
index 00000000000..a465d221994
--- /dev/null
+++ b/tests/ui/iter_count.stderr
@@ -0,0 +1,52 @@
+error: called `.iter().count()` on a `Vec`
+  --> $DIR/iter_count.rs:36:23
+   |
+LL |         let bad_vec = some_vec.iter().count();
+   |                       ^^^^^^^^^^^^^^^^^^^^^^^ help: try: `some_vec.len()`
+   |
+   = note: `-D clippy::iter-count` implied by `-D warnings`
+
+error: called `.iter().count()` on a `slice`
+  --> $DIR/iter_count.rs:37:26
+   |
+LL |         let bad_slice = &some_vec[..].iter().count();
+   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `some_vec[..].len()`
+
+error: called `.iter().count()` on a `slice`
+  --> $DIR/iter_count.rs:38:31
+   |
+LL |         let bad_boxed_slice = boxed_slice.iter().count();
+   |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `boxed_slice.len()`
+
+error: called `.iter().count()` on a `VecDeque`
+  --> $DIR/iter_count.rs:39:29
+   |
+LL |         let bad_vec_deque = some_vec_deque.iter().count();
+   |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `some_vec_deque.len()`
+
+error: called `.iter().count()` on a `std::iter::Iterator`
+  --> $DIR/iter_count.rs:40:28
+   |
+LL |         let bad_hash_set = some_hash_set.iter().count();
+   |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `some_hash_set.len()`
+
+error: called `.iter_mut().count()` on a `Vec`
+  --> $DIR/iter_count.rs:45:23
+   |
+LL |         let bad_vec = some_vec.iter_mut().count();
+   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `some_vec.len()`
+
+error: called `.iter_mut().count()` on a `slice`
+  --> $DIR/iter_count.rs:48:26
+   |
+LL |         let bad_slice = &some_vec[..].iter_mut().count();
+   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `some_vec[..].len()`
+
+error: called `.iter_mut().count()` on a `VecDeque`
+  --> $DIR/iter_count.rs:51:29
+   |
+LL |         let bad_vec_deque = some_vec_deque.iter_mut().count();
+   |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `some_vec_deque.len()`
+
+error: aborting due to 8 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 204b27937c488eb7c1b81c31d56779861ff488c3 Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Fri, 26 Feb 2021 01:54:51 +0900
Subject: lint for `into_iter().count()`

---
 clippy_lints/src/methods/mod.rs | 11 +++++--
 tests/ui/iter_count.fixed       | 58 +++++++++++++++++----------------
 tests/ui/iter_count.rs          | 58 +++++++++++++++++----------------
 tests/ui/iter_count.stderr      | 72 +++++++++++++++++++++++++----------------
 4 files changed, 116 insertions(+), 83 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 17e7f6f662d..e5509ee2c4e 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1691,7 +1691,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
                 lint_search_is_some(cx, expr, "rposition", arg_lists[1], arg_lists[0], method_spans[1])
             },
             ["extend", ..] => lint_extend(cx, expr, arg_lists[0]),
-            ["count", "iter"] => lint_iter_count(cx, expr, &arg_lists[1], false),
+            ["count", "into_iter" | "iter"] => lint_iter_count(cx, expr, &arg_lists[1], false),
             ["count", "iter_mut"] => lint_iter_count(cx, expr, &arg_lists[1], true),
             ["nth", "iter"] => lint_iter_nth(cx, expr, &arg_lists, false),
             ["nth", "iter_mut"] => lint_iter_nth(cx, expr, &arg_lists, true),
@@ -2663,6 +2663,13 @@ fn lint_iter_next<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, iter_
 
 fn lint_iter_count<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, iter_args: &'tcx [Expr<'tcx>], is_mut: bool) {
     let mut_str = if is_mut { "_mut" } else { "" };
+    let iter_method = if method_chain_args(expr, &[format!("iter{}", mut_str).as_str(), "count"]).is_some() {
+        "iter"
+    } else if method_chain_args(expr, &["into_iter", "count"]).is_some() {
+        "into_iter"
+    } else {
+        return;
+    };
     if_chain! {
         let caller_type = if derefs_to_slice(cx, &iter_args[0], cx.typeck_results().expr_ty(&iter_args[0])).is_some() {
             Some("slice")
@@ -2682,7 +2689,7 @@ fn lint_iter_count<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, iter_args: &'t
                 cx,
                 ITER_COUNT,
                 expr.span,
-                &format!("called `.iter{}().count()` on a `{}`", mut_str, caller_type),
+                &format!("called `.{}{}().count()` on a `{}`", iter_method, mut_str, caller_type),
                 "try",
                 format!(
                     "{}.len()",
diff --git a/tests/ui/iter_count.fixed b/tests/ui/iter_count.fixed
index 14cae1cd73e..c8f89640847 100644
--- a/tests/ui/iter_count.fixed
+++ b/tests/ui/iter_count.fixed
@@ -2,8 +2,13 @@
 // aux-build:option_helpers.rs
 
 #![warn(clippy::iter_count)]
-#![allow(unused_variables)]
-#![allow(unused_mut)]
+#![allow(
+    unused_variables,
+    array_into_iter,
+    unused_mut,
+    clippy::into_iter_on_ref,
+    clippy::unnecessary_operation
+)]
 
 extern crate option_helpers;
 
@@ -22,37 +27,36 @@ impl HasIter {
     fn iter_mut(self) -> IteratorFalsePositives {
         IteratorFalsePositives { foo: 0 }
     }
+
+    fn into_iter(self) -> IteratorFalsePositives {
+        IteratorFalsePositives { foo: 0 }
+    }
 }
 
 fn main() {
-    let mut some_vec = vec![0, 1, 2, 3];
+    let mut vec = vec![0, 1, 2, 3];
     let mut boxed_slice: Box<[u8]> = Box::new([0, 1, 2, 3]);
-    let mut some_vec_deque: VecDeque<_> = some_vec.iter().cloned().collect();
-    let mut some_hash_set = HashSet::new();
-    some_hash_set.insert(1);
-
-    {
-        // Make sure we lint `.iter()` for relevant types.
-        let bad_vec = some_vec.len();
-        let bad_slice = &some_vec[..].len();
-        let bad_boxed_slice = boxed_slice.len();
-        let bad_vec_deque = some_vec_deque.len();
-        let bad_hash_set = some_hash_set.len();
-    }
+    let mut vec_deque: VecDeque<_> = vec.iter().cloned().collect();
+    let mut hash_set = HashSet::new();
+    hash_set.insert(1);
 
-    {
-        // Make sure we lint `.iter_mut()` for relevant types.
-        let bad_vec = some_vec.len();
-    }
-    {
-        let bad_slice = &some_vec[..].len();
-    }
-    {
-        let bad_vec_deque = some_vec_deque.len();
-    }
+    &vec[..].len();
+    vec.len();
+    boxed_slice.len();
+    vec_deque.len();
+    hash_set.len();
+
+    vec.len();
+    &vec[..].len();
+    vec_deque.len();
+
+    &vec[..].len();
+    vec.len();
+    vec_deque.len();
 
     // Make sure we don't lint for non-relevant types.
     let false_positive = HasIter;
-    let ok = false_positive.iter().count();
-    let ok_mut = false_positive.iter_mut().count();
+    false_positive.iter().count();
+    false_positive.iter_mut().count();
+    false_positive.into_iter().count();
 }
diff --git a/tests/ui/iter_count.rs b/tests/ui/iter_count.rs
index dfe02e5d53e..8ea17ef34fa 100644
--- a/tests/ui/iter_count.rs
+++ b/tests/ui/iter_count.rs
@@ -2,8 +2,13 @@
 // aux-build:option_helpers.rs
 
 #![warn(clippy::iter_count)]
-#![allow(unused_variables)]
-#![allow(unused_mut)]
+#![allow(
+    unused_variables,
+    array_into_iter,
+    unused_mut,
+    clippy::into_iter_on_ref,
+    clippy::unnecessary_operation
+)]
 
 extern crate option_helpers;
 
@@ -22,37 +27,36 @@ impl HasIter {
     fn iter_mut(self) -> IteratorFalsePositives {
         IteratorFalsePositives { foo: 0 }
     }
+
+    fn into_iter(self) -> IteratorFalsePositives {
+        IteratorFalsePositives { foo: 0 }
+    }
 }
 
 fn main() {
-    let mut some_vec = vec![0, 1, 2, 3];
+    let mut vec = vec![0, 1, 2, 3];
     let mut boxed_slice: Box<[u8]> = Box::new([0, 1, 2, 3]);
-    let mut some_vec_deque: VecDeque<_> = some_vec.iter().cloned().collect();
-    let mut some_hash_set = HashSet::new();
-    some_hash_set.insert(1);
-
-    {
-        // Make sure we lint `.iter()` for relevant types.
-        let bad_vec = some_vec.iter().count();
-        let bad_slice = &some_vec[..].iter().count();
-        let bad_boxed_slice = boxed_slice.iter().count();
-        let bad_vec_deque = some_vec_deque.iter().count();
-        let bad_hash_set = some_hash_set.iter().count();
-    }
+    let mut vec_deque: VecDeque<_> = vec.iter().cloned().collect();
+    let mut hash_set = HashSet::new();
+    hash_set.insert(1);
 
-    {
-        // Make sure we lint `.iter_mut()` for relevant types.
-        let bad_vec = some_vec.iter_mut().count();
-    }
-    {
-        let bad_slice = &some_vec[..].iter_mut().count();
-    }
-    {
-        let bad_vec_deque = some_vec_deque.iter_mut().count();
-    }
+    &vec[..].iter().count();
+    vec.iter().count();
+    boxed_slice.iter().count();
+    vec_deque.iter().count();
+    hash_set.iter().count();
+
+    vec.iter_mut().count();
+    &vec[..].iter_mut().count();
+    vec_deque.iter_mut().count();
+
+    &vec[..].into_iter().count();
+    vec.into_iter().count();
+    vec_deque.into_iter().count();
 
     // Make sure we don't lint for non-relevant types.
     let false_positive = HasIter;
-    let ok = false_positive.iter().count();
-    let ok_mut = false_positive.iter_mut().count();
+    false_positive.iter().count();
+    false_positive.iter_mut().count();
+    false_positive.into_iter().count();
 }
diff --git a/tests/ui/iter_count.stderr b/tests/ui/iter_count.stderr
index a465d221994..0820c001443 100644
--- a/tests/ui/iter_count.stderr
+++ b/tests/ui/iter_count.stderr
@@ -1,52 +1,70 @@
-error: called `.iter().count()` on a `Vec`
-  --> $DIR/iter_count.rs:36:23
+error: called `.iter().count()` on a `slice`
+  --> $DIR/iter_count.rs:43:6
    |
-LL |         let bad_vec = some_vec.iter().count();
-   |                       ^^^^^^^^^^^^^^^^^^^^^^^ help: try: `some_vec.len()`
+LL |     &vec[..].iter().count();
+   |      ^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec[..].len()`
    |
    = note: `-D clippy::iter-count` implied by `-D warnings`
 
-error: called `.iter().count()` on a `slice`
-  --> $DIR/iter_count.rs:37:26
+error: called `.iter().count()` on a `Vec`
+  --> $DIR/iter_count.rs:44:5
    |
-LL |         let bad_slice = &some_vec[..].iter().count();
-   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `some_vec[..].len()`
+LL |     vec.iter().count();
+   |     ^^^^^^^^^^^^^^^^^^ help: try: `vec.len()`
 
 error: called `.iter().count()` on a `slice`
-  --> $DIR/iter_count.rs:38:31
+  --> $DIR/iter_count.rs:45:5
    |
-LL |         let bad_boxed_slice = boxed_slice.iter().count();
-   |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `boxed_slice.len()`
+LL |     boxed_slice.iter().count();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `boxed_slice.len()`
 
 error: called `.iter().count()` on a `VecDeque`
-  --> $DIR/iter_count.rs:39:29
+  --> $DIR/iter_count.rs:46:5
    |
-LL |         let bad_vec_deque = some_vec_deque.iter().count();
-   |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `some_vec_deque.len()`
+LL |     vec_deque.iter().count();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec_deque.len()`
 
 error: called `.iter().count()` on a `std::iter::Iterator`
-  --> $DIR/iter_count.rs:40:28
+  --> $DIR/iter_count.rs:47:5
    |
-LL |         let bad_hash_set = some_hash_set.iter().count();
-   |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `some_hash_set.len()`
+LL |     hash_set.iter().count();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^ help: try: `hash_set.len()`
 
 error: called `.iter_mut().count()` on a `Vec`
-  --> $DIR/iter_count.rs:45:23
+  --> $DIR/iter_count.rs:49:5
    |
-LL |         let bad_vec = some_vec.iter_mut().count();
-   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `some_vec.len()`
+LL |     vec.iter_mut().count();
+   |     ^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.len()`
 
 error: called `.iter_mut().count()` on a `slice`
-  --> $DIR/iter_count.rs:48:26
+  --> $DIR/iter_count.rs:50:6
    |
-LL |         let bad_slice = &some_vec[..].iter_mut().count();
-   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `some_vec[..].len()`
+LL |     &vec[..].iter_mut().count();
+   |      ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec[..].len()`
 
 error: called `.iter_mut().count()` on a `VecDeque`
-  --> $DIR/iter_count.rs:51:29
+  --> $DIR/iter_count.rs:51:5
+   |
+LL |     vec_deque.iter_mut().count();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec_deque.len()`
+
+error: called `.into_iter().count()` on a `slice`
+  --> $DIR/iter_count.rs:53:6
+   |
+LL |     &vec[..].into_iter().count();
+   |      ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec[..].len()`
+
+error: called `.into_iter().count()` on a `Vec`
+  --> $DIR/iter_count.rs:54:5
+   |
+LL |     vec.into_iter().count();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.len()`
+
+error: called `.into_iter().count()` on a `VecDeque`
+  --> $DIR/iter_count.rs:55:5
    |
-LL |         let bad_vec_deque = some_vec_deque.iter_mut().count();
-   |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `some_vec_deque.len()`
+LL |     vec_deque.into_iter().count();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec_deque.len()`
 
-error: aborting due to 8 previous errors
+error: aborting due to 11 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 9958af4229d4bee06ee65b921ac11b1fe498e831 Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Fri, 26 Feb 2021 02:18:52 +0900
Subject: move `lints()` to `iter_count.rs`

---
 clippy_lints/src/methods/iter_count.rs | 51 ++++++++++++++++++
 clippy_lints/src/methods/mod.rs        | 97 ++++------------------------------
 clippy_utils/src/lib.rs                | 40 ++++++++++++++
 3 files changed, 100 insertions(+), 88 deletions(-)
 create mode 100644 clippy_lints/src/methods/iter_count.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/iter_count.rs b/clippy_lints/src/methods/iter_count.rs
new file mode 100644
index 00000000000..ca8723cec94
--- /dev/null
+++ b/clippy_lints/src/methods/iter_count.rs
@@ -0,0 +1,51 @@
+use crate::utils::{
+    derefs_to_slice, is_type_diagnostic_item, match_trait_method, method_chain_args, paths, snippet_with_applicability,
+    span_lint_and_sugg,
+};
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir::Expr;
+use rustc_lint::LateContext;
+use rustc_span::sym;
+
+use super::ITER_COUNT;
+
+pub(crate) fn lints<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, iter_args: &'tcx [Expr<'tcx>], is_mut: bool) {
+    let mut_str = if is_mut { "_mut" } else { "" };
+    let iter_method = if method_chain_args(expr, &[format!("iter{}", mut_str).as_str(), "count"]).is_some() {
+        "iter"
+    } else if method_chain_args(expr, &["into_iter", "count"]).is_some() {
+        "into_iter"
+    } else {
+        return;
+    };
+    if_chain! {
+        let caller_type = if derefs_to_slice(cx, &iter_args[0], cx.typeck_results().expr_ty(&iter_args[0])).is_some() {
+            Some("slice")
+        } else if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&iter_args[0]), sym::vec_type) {
+            Some("Vec")
+        } else if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&iter_args[0]), sym!(vecdeque_type)) {
+            Some("VecDeque")
+        } else if match_trait_method(cx, expr, &paths::ITERATOR) {
+            Some("std::iter::Iterator")
+        } else {
+            None
+        };
+        if let Some(caller_type) = caller_type;
+        then {
+            let mut applicability = Applicability::MachineApplicable;
+            span_lint_and_sugg(
+                cx,
+                ITER_COUNT,
+                expr.span,
+                &format!("called `.{}{}().count()` on a `{}`", iter_method, mut_str, caller_type),
+                "try",
+                format!(
+                    "{}.len()",
+                    snippet_with_applicability(cx, iter_args[0].span, "..", &mut applicability),
+                ),
+                applicability,
+            );
+        }
+    }
+}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index e5509ee2c4e..d2a926d0944 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -4,6 +4,7 @@ mod filter_map_identity;
 mod implicit_clone;
 mod inefficient_to_string;
 mod inspect_for_each;
+mod iter_count;
 mod manual_saturating_arithmetic;
 mod option_map_unwrap_or;
 mod unnecessary_filter_map;
@@ -32,12 +33,12 @@ use crate::consts::{constant, Constant};
 use crate::utils::eager_or_lazy::is_lazyness_candidate;
 use crate::utils::usage::mutated_variables;
 use crate::utils::{
-    contains_return, contains_ty, get_parent_expr, get_trait_def_id, has_iter_method, higher, implements_trait,
-    in_macro, is_copy, is_expn_of, is_type_diagnostic_item, iter_input_pats, last_path_segment, match_def_path,
-    match_qpath, match_trait_method, match_type, meets_msrv, method_calls, method_chain_args, path_to_local_id, paths,
-    remove_blocks, return_ty, single_segment_path, snippet, snippet_with_applicability, snippet_with_macro_callsite,
-    span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then, strip_pat_refs, sugg, walk_ptrs_ty_depth,
-    SpanlessEq,
+    contains_return, contains_ty, derefs_to_slice, get_parent_expr, get_trait_def_id, has_iter_method, higher,
+    implements_trait, in_macro, is_copy, is_expn_of, is_type_diagnostic_item, iter_input_pats, last_path_segment,
+    match_def_path, match_qpath, match_trait_method, match_type, meets_msrv, method_calls, method_chain_args,
+    path_to_local_id, paths, remove_blocks, return_ty, single_segment_path, snippet, snippet_with_applicability,
+    snippet_with_macro_callsite, span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then, strip_pat_refs,
+    sugg, walk_ptrs_ty_depth, SpanlessEq,
 };
 
 declare_clippy_lint! {
@@ -1691,8 +1692,8 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
                 lint_search_is_some(cx, expr, "rposition", arg_lists[1], arg_lists[0], method_spans[1])
             },
             ["extend", ..] => lint_extend(cx, expr, arg_lists[0]),
-            ["count", "into_iter" | "iter"] => lint_iter_count(cx, expr, &arg_lists[1], false),
-            ["count", "iter_mut"] => lint_iter_count(cx, expr, &arg_lists[1], true),
+            ["count", "into_iter" | "iter"] => iter_count::lints(cx, expr, &arg_lists[1], false),
+            ["count", "iter_mut"] => iter_count::lints(cx, expr, &arg_lists[1], true),
             ["nth", "iter"] => lint_iter_nth(cx, expr, &arg_lists, false),
             ["nth", "iter_mut"] => lint_iter_nth(cx, expr, &arg_lists, true),
             ["nth", "bytes"] => bytes_nth::lints(cx, expr, &arg_lists[1]),
@@ -2661,46 +2662,6 @@ fn lint_iter_next<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, iter_
     }
 }
 
-fn lint_iter_count<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, iter_args: &'tcx [Expr<'tcx>], is_mut: bool) {
-    let mut_str = if is_mut { "_mut" } else { "" };
-    let iter_method = if method_chain_args(expr, &[format!("iter{}", mut_str).as_str(), "count"]).is_some() {
-        "iter"
-    } else if method_chain_args(expr, &["into_iter", "count"]).is_some() {
-        "into_iter"
-    } else {
-        return;
-    };
-    if_chain! {
-        let caller_type = if derefs_to_slice(cx, &iter_args[0], cx.typeck_results().expr_ty(&iter_args[0])).is_some() {
-            Some("slice")
-        } else if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&iter_args[0]), sym::vec_type) {
-            Some("Vec")
-        } else if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&iter_args[0]), sym!(vecdeque_type)) {
-            Some("VecDeque")
-        } else if match_trait_method(cx, expr, &paths::ITERATOR) {
-            Some("std::iter::Iterator")
-        } else {
-            None
-        };
-        if let Some(caller_type) = caller_type;
-        then {
-            let mut applicability = Applicability::MachineApplicable;
-            span_lint_and_sugg(
-                cx,
-                ITER_COUNT,
-                expr.span,
-                &format!("called `.{}{}().count()` on a `{}`", iter_method, mut_str, caller_type),
-                "try",
-                format!(
-                    "{}.len()",
-                    snippet_with_applicability(cx, iter_args[0].span, "..", &mut applicability),
-                ),
-                applicability,
-            );
-        }
-    }
-}
-
 fn lint_iter_nth<'tcx>(
     cx: &LateContext<'tcx>,
     expr: &hir::Expr<'_>,
@@ -2841,46 +2802,6 @@ fn lint_iter_skip_next(cx: &LateContext<'_>, expr: &hir::Expr<'_>, skip_args: &[
     }
 }
 
-fn derefs_to_slice<'tcx>(
-    cx: &LateContext<'tcx>,
-    expr: &'tcx hir::Expr<'tcx>,
-    ty: Ty<'tcx>,
-) -> Option<&'tcx hir::Expr<'tcx>> {
-    fn may_slice<'a>(cx: &LateContext<'a>, ty: Ty<'a>) -> bool {
-        match ty.kind() {
-            ty::Slice(_) => true,
-            ty::Adt(def, _) if def.is_box() => may_slice(cx, ty.boxed_ty()),
-            ty::Adt(..) => is_type_diagnostic_item(cx, ty, sym::vec_type),
-            ty::Array(_, size) => size
-                .try_eval_usize(cx.tcx, cx.param_env)
-                .map_or(false, |size| size < 32),
-            ty::Ref(_, inner, _) => may_slice(cx, inner),
-            _ => false,
-        }
-    }
-
-    if let hir::ExprKind::MethodCall(ref path, _, ref args, _) = expr.kind {
-        if path.ident.name == sym::iter && may_slice(cx, cx.typeck_results().expr_ty(&args[0])) {
-            Some(&args[0])
-        } else {
-            None
-        }
-    } else {
-        match ty.kind() {
-            ty::Slice(_) => Some(expr),
-            ty::Adt(def, _) if def.is_box() && may_slice(cx, ty.boxed_ty()) => Some(expr),
-            ty::Ref(_, inner, _) => {
-                if may_slice(cx, inner) {
-                    Some(expr)
-                } else {
-                    None
-                }
-            },
-            _ => None,
-        }
-    }
-}
-
 /// lint use of `unwrap()` for `Option`s and `Result`s
 fn lint_unwrap(cx: &LateContext<'_>, expr: &hir::Expr<'_>, unwrap_args: &[hir::Expr<'_>]) {
     let obj_ty = cx.typeck_results().expr_ty(&unwrap_args[0]).peel_refs();
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 2380ea4c7bf..ec1b189bf77 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -1802,6 +1802,46 @@ pub fn is_some_ctor(cx: &LateContext<'_>, res: Res) -> bool {
     false
 }
 
+pub fn derefs_to_slice<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx hir::Expr<'tcx>,
+    ty: Ty<'tcx>,
+) -> Option<&'tcx hir::Expr<'tcx>> {
+    fn may_slice<'a>(cx: &LateContext<'a>, ty: Ty<'a>) -> bool {
+        match ty.kind() {
+            ty::Slice(_) => true,
+            ty::Adt(def, _) if def.is_box() => may_slice(cx, ty.boxed_ty()),
+            ty::Adt(..) => is_type_diagnostic_item(cx, ty, sym::vec_type),
+            ty::Array(_, size) => size
+                .try_eval_usize(cx.tcx, cx.param_env)
+                .map_or(false, |size| size < 32),
+            ty::Ref(_, inner, _) => may_slice(cx, inner),
+            _ => false,
+        }
+    }
+
+    if let hir::ExprKind::MethodCall(ref path, _, ref args, _) = expr.kind {
+        if path.ident.name == sym::iter && may_slice(cx, cx.typeck_results().expr_ty(&args[0])) {
+            Some(&args[0])
+        } else {
+            None
+        }
+    } else {
+        match ty.kind() {
+            ty::Slice(_) => Some(expr),
+            ty::Adt(def, _) if def.is_box() && may_slice(cx, ty.boxed_ty()) => Some(expr),
+            ty::Ref(_, inner, _) => {
+                if may_slice(cx, inner) {
+                    Some(expr)
+                } else {
+                    None
+                }
+            },
+            _ => None,
+        }
+    }
+}
+
 #[cfg(test)]
 mod test {
     use super::{reindent_multiline, without_block_comments};
-- 
cgit 1.4.1-3-g733a5


From cc2b00055ccc18f4b345a1f6d50865ada9093e88 Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Fri, 26 Feb 2021 04:11:01 +0900
Subject: return when the ty doesn't have `len()`

---
 clippy_lints/src/methods/iter_count.rs |  33 ++++++----
 tests/ui/iter_count.fixed              |  26 +++++++-
 tests/ui/iter_count.rs                 |  26 +++++++-
 tests/ui/iter_count.stderr             | 110 +++++++++++++++++++++++++++++----
 4 files changed, 169 insertions(+), 26 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/iter_count.rs b/clippy_lints/src/methods/iter_count.rs
index ca8723cec94..1bcdb57ad29 100644
--- a/clippy_lints/src/methods/iter_count.rs
+++ b/clippy_lints/src/methods/iter_count.rs
@@ -1,7 +1,8 @@
 use crate::utils::{
-    derefs_to_slice, is_type_diagnostic_item, match_trait_method, method_chain_args, paths, snippet_with_applicability,
+    derefs_to_slice, is_type_diagnostic_item, match_type, method_chain_args, paths, snippet_with_applicability,
     span_lint_and_sugg,
 };
+
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::Expr;
@@ -19,19 +20,29 @@ pub(crate) fn lints<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, iter_args: &'
     } else {
         return;
     };
+    let ty = cx.typeck_results().expr_ty(&iter_args[0]);
     if_chain! {
-        let caller_type = if derefs_to_slice(cx, &iter_args[0], cx.typeck_results().expr_ty(&iter_args[0])).is_some() {
-            Some("slice")
-        } else if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&iter_args[0]), sym::vec_type) {
-            Some("Vec")
-        } else if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&iter_args[0]), sym!(vecdeque_type)) {
-            Some("VecDeque")
-        } else if match_trait_method(cx, expr, &paths::ITERATOR) {
-            Some("std::iter::Iterator")
+        let caller_type = if derefs_to_slice(cx, &iter_args[0], ty).is_some() {
+            "slice"
+        } else if is_type_diagnostic_item(cx, ty, sym::vec_type) {
+            "Vec"
+        } else if is_type_diagnostic_item(cx, ty, sym!(vecdeque_type)) {
+            "VecDeque"
+        } else if is_type_diagnostic_item(cx, ty, sym!(hashset_type)) {
+            "HashSet"
+        } else if is_type_diagnostic_item(cx, ty, sym!(hashmap_type)) {
+            "HashMap"
+        } else if match_type(cx, ty, &paths::BTREEMAP) {
+            "BTreeMap"
+        } else if match_type(cx, ty, &paths::BTREESET) {
+            "BTreeSet"
+        } else if match_type(cx, ty, &paths::LINKED_LIST) {
+            "LinkedList"
+        } else if match_type(cx, ty, &paths::BINARY_HEAP) {
+            "BinaryHeap"
         } else {
-            None
+            return
         };
-        if let Some(caller_type) = caller_type;
         then {
             let mut applicability = Applicability::MachineApplicable;
             span_lint_and_sugg(
diff --git a/tests/ui/iter_count.fixed b/tests/ui/iter_count.fixed
index c8f89640847..b11dadda6c2 100644
--- a/tests/ui/iter_count.fixed
+++ b/tests/ui/iter_count.fixed
@@ -13,7 +13,7 @@
 extern crate option_helpers;
 
 use option_helpers::IteratorFalsePositives;
-use std::collections::{HashSet, VecDeque};
+use std::collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, LinkedList, VecDeque};
 
 /// Struct to generate false positives for things with `.iter()`.
 #[derive(Copy, Clone)]
@@ -38,21 +38,45 @@ fn main() {
     let mut boxed_slice: Box<[u8]> = Box::new([0, 1, 2, 3]);
     let mut vec_deque: VecDeque<_> = vec.iter().cloned().collect();
     let mut hash_set = HashSet::new();
+    let mut hash_map = HashMap::new();
+    let mut b_tree_map = BTreeMap::new();
+    let mut b_tree_set = BTreeSet::new();
+    let mut linked_list = LinkedList::new();
+    let mut binary_heap = BinaryHeap::new();
     hash_set.insert(1);
+    hash_map.insert(1, 2);
+    b_tree_map.insert(1, 2);
+    b_tree_set.insert(1);
+    linked_list.push_back(1);
+    binary_heap.push(1);
 
     &vec[..].len();
     vec.len();
     boxed_slice.len();
     vec_deque.len();
     hash_set.len();
+    hash_map.len();
+    b_tree_map.len();
+    b_tree_set.len();
+    linked_list.len();
+    binary_heap.len();
 
     vec.len();
     &vec[..].len();
     vec_deque.len();
+    hash_map.len();
+    b_tree_map.len();
+    linked_list.len();
 
     &vec[..].len();
     vec.len();
     vec_deque.len();
+    hash_set.len();
+    hash_map.len();
+    b_tree_map.len();
+    b_tree_set.len();
+    linked_list.len();
+    binary_heap.len();
 
     // Make sure we don't lint for non-relevant types.
     let false_positive = HasIter;
diff --git a/tests/ui/iter_count.rs b/tests/ui/iter_count.rs
index 8ea17ef34fa..7d49c6a3dbb 100644
--- a/tests/ui/iter_count.rs
+++ b/tests/ui/iter_count.rs
@@ -13,7 +13,7 @@
 extern crate option_helpers;
 
 use option_helpers::IteratorFalsePositives;
-use std::collections::{HashSet, VecDeque};
+use std::collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, LinkedList, VecDeque};
 
 /// Struct to generate false positives for things with `.iter()`.
 #[derive(Copy, Clone)]
@@ -38,21 +38,45 @@ fn main() {
     let mut boxed_slice: Box<[u8]> = Box::new([0, 1, 2, 3]);
     let mut vec_deque: VecDeque<_> = vec.iter().cloned().collect();
     let mut hash_set = HashSet::new();
+    let mut hash_map = HashMap::new();
+    let mut b_tree_map = BTreeMap::new();
+    let mut b_tree_set = BTreeSet::new();
+    let mut linked_list = LinkedList::new();
+    let mut binary_heap = BinaryHeap::new();
     hash_set.insert(1);
+    hash_map.insert(1, 2);
+    b_tree_map.insert(1, 2);
+    b_tree_set.insert(1);
+    linked_list.push_back(1);
+    binary_heap.push(1);
 
     &vec[..].iter().count();
     vec.iter().count();
     boxed_slice.iter().count();
     vec_deque.iter().count();
     hash_set.iter().count();
+    hash_map.iter().count();
+    b_tree_map.iter().count();
+    b_tree_set.iter().count();
+    linked_list.iter().count();
+    binary_heap.iter().count();
 
     vec.iter_mut().count();
     &vec[..].iter_mut().count();
     vec_deque.iter_mut().count();
+    hash_map.iter_mut().count();
+    b_tree_map.iter_mut().count();
+    linked_list.iter_mut().count();
 
     &vec[..].into_iter().count();
     vec.into_iter().count();
     vec_deque.into_iter().count();
+    hash_set.into_iter().count();
+    hash_map.into_iter().count();
+    b_tree_map.into_iter().count();
+    b_tree_set.into_iter().count();
+    linked_list.into_iter().count();
+    binary_heap.into_iter().count();
 
     // Make sure we don't lint for non-relevant types.
     let false_positive = HasIter;
diff --git a/tests/ui/iter_count.stderr b/tests/ui/iter_count.stderr
index 0820c001443..f3fb98e65b9 100644
--- a/tests/ui/iter_count.stderr
+++ b/tests/ui/iter_count.stderr
@@ -1,5 +1,5 @@
 error: called `.iter().count()` on a `slice`
-  --> $DIR/iter_count.rs:43:6
+  --> $DIR/iter_count.rs:53:6
    |
 LL |     &vec[..].iter().count();
    |      ^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec[..].len()`
@@ -7,64 +7,148 @@ LL |     &vec[..].iter().count();
    = note: `-D clippy::iter-count` implied by `-D warnings`
 
 error: called `.iter().count()` on a `Vec`
-  --> $DIR/iter_count.rs:44:5
+  --> $DIR/iter_count.rs:54:5
    |
 LL |     vec.iter().count();
    |     ^^^^^^^^^^^^^^^^^^ help: try: `vec.len()`
 
 error: called `.iter().count()` on a `slice`
-  --> $DIR/iter_count.rs:45:5
+  --> $DIR/iter_count.rs:55:5
    |
 LL |     boxed_slice.iter().count();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `boxed_slice.len()`
 
 error: called `.iter().count()` on a `VecDeque`
-  --> $DIR/iter_count.rs:46:5
+  --> $DIR/iter_count.rs:56:5
    |
 LL |     vec_deque.iter().count();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec_deque.len()`
 
-error: called `.iter().count()` on a `std::iter::Iterator`
-  --> $DIR/iter_count.rs:47:5
+error: called `.iter().count()` on a `HashSet`
+  --> $DIR/iter_count.rs:57:5
    |
 LL |     hash_set.iter().count();
    |     ^^^^^^^^^^^^^^^^^^^^^^^ help: try: `hash_set.len()`
 
+error: called `.iter().count()` on a `HashMap`
+  --> $DIR/iter_count.rs:58:5
+   |
+LL |     hash_map.iter().count();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^ help: try: `hash_map.len()`
+
+error: called `.iter().count()` on a `BTreeMap`
+  --> $DIR/iter_count.rs:59:5
+   |
+LL |     b_tree_map.iter().count();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `b_tree_map.len()`
+
+error: called `.iter().count()` on a `BTreeSet`
+  --> $DIR/iter_count.rs:60:5
+   |
+LL |     b_tree_set.iter().count();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `b_tree_set.len()`
+
+error: called `.iter().count()` on a `LinkedList`
+  --> $DIR/iter_count.rs:61:5
+   |
+LL |     linked_list.iter().count();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `linked_list.len()`
+
+error: called `.iter().count()` on a `BinaryHeap`
+  --> $DIR/iter_count.rs:62:5
+   |
+LL |     binary_heap.iter().count();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `binary_heap.len()`
+
 error: called `.iter_mut().count()` on a `Vec`
-  --> $DIR/iter_count.rs:49:5
+  --> $DIR/iter_count.rs:64:5
    |
 LL |     vec.iter_mut().count();
    |     ^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.len()`
 
 error: called `.iter_mut().count()` on a `slice`
-  --> $DIR/iter_count.rs:50:6
+  --> $DIR/iter_count.rs:65:6
    |
 LL |     &vec[..].iter_mut().count();
    |      ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec[..].len()`
 
 error: called `.iter_mut().count()` on a `VecDeque`
-  --> $DIR/iter_count.rs:51:5
+  --> $DIR/iter_count.rs:66:5
    |
 LL |     vec_deque.iter_mut().count();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec_deque.len()`
 
+error: called `.iter_mut().count()` on a `HashMap`
+  --> $DIR/iter_count.rs:67:5
+   |
+LL |     hash_map.iter_mut().count();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `hash_map.len()`
+
+error: called `.iter_mut().count()` on a `BTreeMap`
+  --> $DIR/iter_count.rs:68:5
+   |
+LL |     b_tree_map.iter_mut().count();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `b_tree_map.len()`
+
+error: called `.iter_mut().count()` on a `LinkedList`
+  --> $DIR/iter_count.rs:69:5
+   |
+LL |     linked_list.iter_mut().count();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `linked_list.len()`
+
 error: called `.into_iter().count()` on a `slice`
-  --> $DIR/iter_count.rs:53:6
+  --> $DIR/iter_count.rs:71:6
    |
 LL |     &vec[..].into_iter().count();
    |      ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec[..].len()`
 
 error: called `.into_iter().count()` on a `Vec`
-  --> $DIR/iter_count.rs:54:5
+  --> $DIR/iter_count.rs:72:5
    |
 LL |     vec.into_iter().count();
    |     ^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.len()`
 
 error: called `.into_iter().count()` on a `VecDeque`
-  --> $DIR/iter_count.rs:55:5
+  --> $DIR/iter_count.rs:73:5
    |
 LL |     vec_deque.into_iter().count();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec_deque.len()`
 
-error: aborting due to 11 previous errors
+error: called `.into_iter().count()` on a `HashSet`
+  --> $DIR/iter_count.rs:74:5
+   |
+LL |     hash_set.into_iter().count();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `hash_set.len()`
+
+error: called `.into_iter().count()` on a `HashMap`
+  --> $DIR/iter_count.rs:75:5
+   |
+LL |     hash_map.into_iter().count();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `hash_map.len()`
+
+error: called `.into_iter().count()` on a `BTreeMap`
+  --> $DIR/iter_count.rs:76:5
+   |
+LL |     b_tree_map.into_iter().count();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `b_tree_map.len()`
+
+error: called `.into_iter().count()` on a `BTreeSet`
+  --> $DIR/iter_count.rs:77:5
+   |
+LL |     b_tree_set.into_iter().count();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `b_tree_set.len()`
+
+error: called `.into_iter().count()` on a `LinkedList`
+  --> $DIR/iter_count.rs:78:5
+   |
+LL |     linked_list.into_iter().count();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `linked_list.len()`
+
+error: called `.into_iter().count()` on a `BinaryHeap`
+  --> $DIR/iter_count.rs:79:5
+   |
+LL |     binary_heap.into_iter().count();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `binary_heap.len()`
+
+error: aborting due to 25 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 8bae2797067650071b69273ecfbf55240190db07 Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Fri, 26 Feb 2021 15:49:03 +0900
Subject: remove if_chain

---
 clippy_lints/src/methods/iter_count.rs | 72 ++++++++++++++++------------------
 1 file changed, 34 insertions(+), 38 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/iter_count.rs b/clippy_lints/src/methods/iter_count.rs
index 1bcdb57ad29..06ce06126e6 100644
--- a/clippy_lints/src/methods/iter_count.rs
+++ b/clippy_lints/src/methods/iter_count.rs
@@ -21,42 +21,38 @@ pub(crate) fn lints<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, iter_args: &'
         return;
     };
     let ty = cx.typeck_results().expr_ty(&iter_args[0]);
-    if_chain! {
-        let caller_type = if derefs_to_slice(cx, &iter_args[0], ty).is_some() {
-            "slice"
-        } else if is_type_diagnostic_item(cx, ty, sym::vec_type) {
-            "Vec"
-        } else if is_type_diagnostic_item(cx, ty, sym!(vecdeque_type)) {
-            "VecDeque"
-        } else if is_type_diagnostic_item(cx, ty, sym!(hashset_type)) {
-            "HashSet"
-        } else if is_type_diagnostic_item(cx, ty, sym!(hashmap_type)) {
-            "HashMap"
-        } else if match_type(cx, ty, &paths::BTREEMAP) {
-            "BTreeMap"
-        } else if match_type(cx, ty, &paths::BTREESET) {
-            "BTreeSet"
-        } else if match_type(cx, ty, &paths::LINKED_LIST) {
-            "LinkedList"
-        } else if match_type(cx, ty, &paths::BINARY_HEAP) {
-            "BinaryHeap"
-        } else {
-            return
-        };
-        then {
-            let mut applicability = Applicability::MachineApplicable;
-            span_lint_and_sugg(
-                cx,
-                ITER_COUNT,
-                expr.span,
-                &format!("called `.{}{}().count()` on a `{}`", iter_method, mut_str, caller_type),
-                "try",
-                format!(
-                    "{}.len()",
-                    snippet_with_applicability(cx, iter_args[0].span, "..", &mut applicability),
-                ),
-                applicability,
-            );
-        }
-    }
+    let caller_type = if derefs_to_slice(cx, &iter_args[0], ty).is_some() {
+        "slice"
+    } else if is_type_diagnostic_item(cx, ty, sym::vec_type) {
+        "Vec"
+    } else if is_type_diagnostic_item(cx, ty, sym!(vecdeque_type)) {
+        "VecDeque"
+    } else if is_type_diagnostic_item(cx, ty, sym!(hashset_type)) {
+        "HashSet"
+    } else if is_type_diagnostic_item(cx, ty, sym!(hashmap_type)) {
+        "HashMap"
+    } else if match_type(cx, ty, &paths::BTREEMAP) {
+        "BTreeMap"
+    } else if match_type(cx, ty, &paths::BTREESET) {
+        "BTreeSet"
+    } else if match_type(cx, ty, &paths::LINKED_LIST) {
+        "LinkedList"
+    } else if match_type(cx, ty, &paths::BINARY_HEAP) {
+        "BinaryHeap"
+    } else {
+        return;
+    };
+    let mut applicability = Applicability::MachineApplicable;
+    span_lint_and_sugg(
+        cx,
+        ITER_COUNT,
+        expr.span,
+        &format!("called `.{}{}().count()` on a `{}`", iter_method, mut_str, caller_type),
+        "try",
+        format!(
+            "{}.len()",
+            snippet_with_applicability(cx, iter_args[0].span, "..", &mut applicability),
+        ),
+        applicability,
+    );
 }
-- 
cgit 1.4.1-3-g733a5


From 77907e6dab42dd0acc23c0cf1d540d2aa3e32bb8 Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Fri, 26 Feb 2021 16:21:43 +0900
Subject: receive iter method name as an argument

---
 clippy_lints/src/methods/iter_count.rs | 16 +++-------------
 clippy_lints/src/methods/mod.rs        |  5 +++--
 2 files changed, 6 insertions(+), 15 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/iter_count.rs b/clippy_lints/src/methods/iter_count.rs
index 06ce06126e6..ff3aa346e2d 100644
--- a/clippy_lints/src/methods/iter_count.rs
+++ b/clippy_lints/src/methods/iter_count.rs
@@ -1,9 +1,7 @@
 use crate::utils::{
-    derefs_to_slice, is_type_diagnostic_item, match_type, method_chain_args, paths, snippet_with_applicability,
-    span_lint_and_sugg,
+    derefs_to_slice, is_type_diagnostic_item, match_type, paths, snippet_with_applicability, span_lint_and_sugg,
 };
 
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::Expr;
 use rustc_lint::LateContext;
@@ -11,15 +9,7 @@ use rustc_span::sym;
 
 use super::ITER_COUNT;
 
-pub(crate) fn lints<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, iter_args: &'tcx [Expr<'tcx>], is_mut: bool) {
-    let mut_str = if is_mut { "_mut" } else { "" };
-    let iter_method = if method_chain_args(expr, &[format!("iter{}", mut_str).as_str(), "count"]).is_some() {
-        "iter"
-    } else if method_chain_args(expr, &["into_iter", "count"]).is_some() {
-        "into_iter"
-    } else {
-        return;
-    };
+pub(crate) fn lints<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, iter_args: &'tcx [Expr<'tcx>], iter_method: &str) {
     let ty = cx.typeck_results().expr_ty(&iter_args[0]);
     let caller_type = if derefs_to_slice(cx, &iter_args[0], ty).is_some() {
         "slice"
@@ -47,7 +37,7 @@ pub(crate) fn lints<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, iter_args: &'
         cx,
         ITER_COUNT,
         expr.span,
-        &format!("called `.{}{}().count()` on a `{}`", iter_method, mut_str, caller_type),
+        &format!("called `.{}().count()` on a `{}`", iter_method, caller_type),
         "try",
         format!(
             "{}.len()",
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index d2a926d0944..f394e6673d4 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1692,8 +1692,9 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
                 lint_search_is_some(cx, expr, "rposition", arg_lists[1], arg_lists[0], method_spans[1])
             },
             ["extend", ..] => lint_extend(cx, expr, arg_lists[0]),
-            ["count", "into_iter" | "iter"] => iter_count::lints(cx, expr, &arg_lists[1], false),
-            ["count", "iter_mut"] => iter_count::lints(cx, expr, &arg_lists[1], true),
+            ["count", "into_iter"] => iter_count::lints(cx, expr, &arg_lists[1], "into_iter"),
+            ["count", "iter"] => iter_count::lints(cx, expr, &arg_lists[1], "iter"),
+            ["count", "iter_mut"] => iter_count::lints(cx, expr, &arg_lists[1], "iter_mut"),
             ["nth", "iter"] => lint_iter_nth(cx, expr, &arg_lists, false),
             ["nth", "iter_mut"] => lint_iter_nth(cx, expr, &arg_lists, true),
             ["nth", "bytes"] => bytes_nth::lints(cx, expr, &arg_lists[1]),
-- 
cgit 1.4.1-3-g733a5


From c297174adf9468234d0eebad608514879a52b82b Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Fri, 26 Feb 2021 17:07:00 +0900
Subject: export `derefs_to_slice` from methods module

---
 clippy_lints/src/methods/iter_count.rs |  5 ++--
 clippy_lints/src/methods/mod.rs        | 52 ++++++++++++++++++++++++++++++----
 clippy_utils/src/lib.rs                | 40 --------------------------
 3 files changed, 48 insertions(+), 49 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/iter_count.rs b/clippy_lints/src/methods/iter_count.rs
index ff3aa346e2d..1b99bacc3f1 100644
--- a/clippy_lints/src/methods/iter_count.rs
+++ b/clippy_lints/src/methods/iter_count.rs
@@ -1,6 +1,5 @@
-use crate::utils::{
-    derefs_to_slice, is_type_diagnostic_item, match_type, paths, snippet_with_applicability, span_lint_and_sugg,
-};
+use crate::methods::derefs_to_slice;
+use crate::utils::{is_type_diagnostic_item, match_type, paths, snippet_with_applicability, span_lint_and_sugg};
 
 use rustc_errors::Applicability;
 use rustc_hir::Expr;
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index f394e6673d4..30830fb0af6 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -33,12 +33,12 @@ use crate::consts::{constant, Constant};
 use crate::utils::eager_or_lazy::is_lazyness_candidate;
 use crate::utils::usage::mutated_variables;
 use crate::utils::{
-    contains_return, contains_ty, derefs_to_slice, get_parent_expr, get_trait_def_id, has_iter_method, higher,
-    implements_trait, in_macro, is_copy, is_expn_of, is_type_diagnostic_item, iter_input_pats, last_path_segment,
-    match_def_path, match_qpath, match_trait_method, match_type, meets_msrv, method_calls, method_chain_args,
-    path_to_local_id, paths, remove_blocks, return_ty, single_segment_path, snippet, snippet_with_applicability,
-    snippet_with_macro_callsite, span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then, strip_pat_refs,
-    sugg, walk_ptrs_ty_depth, SpanlessEq,
+    contains_return, contains_ty, get_parent_expr, get_trait_def_id, has_iter_method, higher, implements_trait,
+    in_macro, is_copy, is_expn_of, is_type_diagnostic_item, iter_input_pats, last_path_segment, match_def_path,
+    match_qpath, match_trait_method, match_type, meets_msrv, method_calls, method_chain_args, path_to_local_id, paths,
+    remove_blocks, return_ty, single_segment_path, snippet, snippet_with_applicability, snippet_with_macro_callsite,
+    span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then, strip_pat_refs, sugg, walk_ptrs_ty_depth,
+    SpanlessEq,
 };
 
 declare_clippy_lint! {
@@ -2803,6 +2803,46 @@ fn lint_iter_skip_next(cx: &LateContext<'_>, expr: &hir::Expr<'_>, skip_args: &[
     }
 }
 
+pub(crate) fn derefs_to_slice<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx hir::Expr<'tcx>,
+    ty: Ty<'tcx>,
+) -> Option<&'tcx hir::Expr<'tcx>> {
+    fn may_slice<'a>(cx: &LateContext<'a>, ty: Ty<'a>) -> bool {
+        match ty.kind() {
+            ty::Slice(_) => true,
+            ty::Adt(def, _) if def.is_box() => may_slice(cx, ty.boxed_ty()),
+            ty::Adt(..) => is_type_diagnostic_item(cx, ty, sym::vec_type),
+            ty::Array(_, size) => size
+                .try_eval_usize(cx.tcx, cx.param_env)
+                .map_or(false, |size| size < 32),
+            ty::Ref(_, inner, _) => may_slice(cx, inner),
+            _ => false,
+        }
+    }
+
+    if let hir::ExprKind::MethodCall(ref path, _, ref args, _) = expr.kind {
+        if path.ident.name == sym::iter && may_slice(cx, cx.typeck_results().expr_ty(&args[0])) {
+            Some(&args[0])
+        } else {
+            None
+        }
+    } else {
+        match ty.kind() {
+            ty::Slice(_) => Some(expr),
+            ty::Adt(def, _) if def.is_box() && may_slice(cx, ty.boxed_ty()) => Some(expr),
+            ty::Ref(_, inner, _) => {
+                if may_slice(cx, inner) {
+                    Some(expr)
+                } else {
+                    None
+                }
+            },
+            _ => None,
+        }
+    }
+}
+
 /// lint use of `unwrap()` for `Option`s and `Result`s
 fn lint_unwrap(cx: &LateContext<'_>, expr: &hir::Expr<'_>, unwrap_args: &[hir::Expr<'_>]) {
     let obj_ty = cx.typeck_results().expr_ty(&unwrap_args[0]).peel_refs();
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index ec1b189bf77..2380ea4c7bf 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -1802,46 +1802,6 @@ pub fn is_some_ctor(cx: &LateContext<'_>, res: Res) -> bool {
     false
 }
 
-pub fn derefs_to_slice<'tcx>(
-    cx: &LateContext<'tcx>,
-    expr: &'tcx hir::Expr<'tcx>,
-    ty: Ty<'tcx>,
-) -> Option<&'tcx hir::Expr<'tcx>> {
-    fn may_slice<'a>(cx: &LateContext<'a>, ty: Ty<'a>) -> bool {
-        match ty.kind() {
-            ty::Slice(_) => true,
-            ty::Adt(def, _) if def.is_box() => may_slice(cx, ty.boxed_ty()),
-            ty::Adt(..) => is_type_diagnostic_item(cx, ty, sym::vec_type),
-            ty::Array(_, size) => size
-                .try_eval_usize(cx.tcx, cx.param_env)
-                .map_or(false, |size| size < 32),
-            ty::Ref(_, inner, _) => may_slice(cx, inner),
-            _ => false,
-        }
-    }
-
-    if let hir::ExprKind::MethodCall(ref path, _, ref args, _) = expr.kind {
-        if path.ident.name == sym::iter && may_slice(cx, cx.typeck_results().expr_ty(&args[0])) {
-            Some(&args[0])
-        } else {
-            None
-        }
-    } else {
-        match ty.kind() {
-            ty::Slice(_) => Some(expr),
-            ty::Adt(def, _) if def.is_box() && may_slice(cx, ty.boxed_ty()) => Some(expr),
-            ty::Ref(_, inner, _) => {
-                if may_slice(cx, inner) {
-                    Some(expr)
-                } else {
-                    None
-                }
-            },
-            _ => None,
-        }
-    }
-}
-
 #[cfg(test)]
 mod test {
     use super::{reindent_multiline, without_block_comments};
-- 
cgit 1.4.1-3-g733a5


From 6041365f4bae6482467210ea1b60e18101ba6fd0 Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Fri, 26 Feb 2021 17:38:21 +0900
Subject: remove pub(crate)

---
 clippy_lints/src/methods/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 30830fb0af6..4a63de3cf48 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -2803,7 +2803,7 @@ fn lint_iter_skip_next(cx: &LateContext<'_>, expr: &hir::Expr<'_>, skip_args: &[
     }
 }
 
-pub(crate) fn derefs_to_slice<'tcx>(
+fn derefs_to_slice<'tcx>(
     cx: &LateContext<'tcx>,
     expr: &'tcx hir::Expr<'tcx>,
     ty: Ty<'tcx>,
-- 
cgit 1.4.1-3-g733a5


From bdeec5dbd6e484cec26039cb795193ab044cf4d9 Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Sat, 27 Feb 2021 21:52:15 +0900
Subject: Use TypeckResults::expr_ty instead of TyCtxt::type_of to fix "Not a
 type" ICE

---
 clippy_lints/src/default_numeric_fallback.rs        |  5 ++---
 clippy_lints/src/inconsistent_struct_constructor.rs |  3 +--
 tests/ui/crashes/ice-6792.rs                        | 20 ++++++++++++++++++++
 3 files changed, 23 insertions(+), 5 deletions(-)
 create mode 100644 tests/ui/crashes/ice-6792.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/default_numeric_fallback.rs b/clippy_lints/src/default_numeric_fallback.rs
index 6ace9aa6bdf..369efacc9bc 100644
--- a/clippy_lints/src/default_numeric_fallback.rs
+++ b/clippy_lints/src/default_numeric_fallback.rs
@@ -130,10 +130,9 @@ impl<'a, 'tcx> Visitor<'tcx> for NumericFallbackVisitor<'a, 'tcx> {
                 }
             },
 
-            ExprKind::Struct(qpath, fields, base) => {
+            ExprKind::Struct(_, fields, base) => {
                 if_chain! {
-                    if let Some(def_id) = self.cx.qpath_res(qpath, expr.hir_id).opt_def_id();
-                    let ty = self.cx.tcx.type_of(def_id);
+                    let ty = self.cx.typeck_results().expr_ty(expr);
                     if let Some(adt_def) = ty.ty_adt_def();
                     if adt_def.is_struct();
                     if let Some(variant) = adt_def.variants.iter().next();
diff --git a/clippy_lints/src/inconsistent_struct_constructor.rs b/clippy_lints/src/inconsistent_struct_constructor.rs
index c5afdf530eb..4f35e13c85a 100644
--- a/clippy_lints/src/inconsistent_struct_constructor.rs
+++ b/clippy_lints/src/inconsistent_struct_constructor.rs
@@ -66,8 +66,7 @@ impl LateLintPass<'_> for InconsistentStructConstructor {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
         if_chain! {
             if let ExprKind::Struct(qpath, fields, base) = expr.kind;
-            if let Some(def_id)  = cx.qpath_res(qpath, expr.hir_id).opt_def_id();
-            let ty = cx.tcx.type_of(def_id);
+            let ty = cx.typeck_results().expr_ty(expr);
             if let Some(adt_def) = ty.ty_adt_def();
             if adt_def.is_struct();
             if let Some(variant) = adt_def.variants.iter().next();
diff --git a/tests/ui/crashes/ice-6792.rs b/tests/ui/crashes/ice-6792.rs
new file mode 100644
index 00000000000..0e2ab1a39b8
--- /dev/null
+++ b/tests/ui/crashes/ice-6792.rs
@@ -0,0 +1,20 @@
+//! This is a reproducer for the ICE 6792: https://github.com/rust-lang/rust-clippy/issues/6792.
+//! The ICE is caused by using `TyCtxt::type_of(assoc_type_id)`.
+
+trait Trait {
+    type Ty;
+
+    fn broken() -> Self::Ty;
+}
+
+struct Foo {}
+
+impl Trait for Foo {
+    type Ty = Foo;
+
+    fn broken() -> Self::Ty {
+        Self::Ty {}
+    }
+}
+
+fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 8eb2bd13d0dd70131be1e21a0a0261c9dc69937a Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Wed, 24 Feb 2021 14:02:51 +0100
Subject: update the lint messages and tests

---
 clippy_lints/src/assign_ops.rs                     |  2 +-
 clippy_lints/src/attrs.rs                          |  2 +-
 clippy_lints/src/await_holding_invalid.rs          |  4 +-
 clippy_lints/src/comparison_chain.rs               |  2 +-
 clippy_lints/src/drop_forget_ref.rs                |  8 +--
 clippy_lints/src/fallible_impl_from.rs             |  2 +-
 clippy_lints/src/indexing_slicing.rs               | 12 ++--
 clippy_lints/src/integer_division.rs               |  2 +-
 clippy_lints/src/loops.rs                          | 19 +++----
 clippy_lints/src/matches.rs                        |  4 +-
 clippy_lints/src/methods/mod.rs                    |  4 +-
 clippy_lints/src/methods/unnecessary_lazy_eval.rs  |  2 +-
 clippy_lints/src/misc.rs                           |  4 +-
 clippy_lints/src/needless_question_mark.rs         |  2 +-
 clippy_lints/src/ptr.rs                            |  8 +--
 clippy_lints/src/suspicious_operation_groupings.rs |  2 +-
 clippy_lints/src/transmuting_null.rs               |  2 +-
 clippy_lints/src/types.rs                          |  4 +-
 clippy_lints/src/zero_div_zero.rs                  |  2 +-
 tests/lint_message_convention.rs                   |  7 ++-
 tests/ui-toml/vec_box_sized/test.stderr            |  6 +-
 tests/ui/assign_ops2.stderr                        | 18 +++---
 tests/ui/await_holding_lock.stderr                 |  8 +--
 tests/ui/await_holding_refcell_ref.stderr          | 12 ++--
 tests/ui/box_vec.stderr                            |  2 +-
 tests/ui/comparison_chain.stderr                   | 14 ++---
 tests/ui/drop_forget_copy.stderr                   | 12 ++--
 tests/ui/drop_ref.stderr                           | 18 +++---
 tests/ui/explicit_counter_loop.stderr              | 14 ++---
 tests/ui/fallible_impl_from.stderr                 |  8 +--
 tests/ui/filter_map_next.stderr                    |  2 +-
 tests/ui/filter_map_next_fixable.stderr            |  2 +-
 tests/ui/for_loops_over_fallibles.stderr           | 10 ++--
 tests/ui/forget_ref.stderr                         | 18 +++---
 tests/ui/indexing_slicing_index.stderr             | 24 ++++----
 tests/ui/indexing_slicing_slice.stderr             | 48 ++++++++--------
 tests/ui/integer_division.stderr                   |  6 +-
 tests/ui/methods.stderr                            |  2 +-
 tests/ui/methods_fixable.stderr                    |  2 +-
 tests/ui/mismatched_target_os_unix.stderr          | 34 ++++++------
 tests/ui/needless_collect_indirect.stderr          | 10 ++--
 tests/ui/needless_question_mark.stderr             | 28 +++++-----
 tests/ui/needless_range_loop.stderr                | 20 +++----
 tests/ui/needless_range_loop2.stderr               | 16 +++---
 tests/ui/ptr_arg.stderr                            | 24 ++++----
 tests/ui/suspicious_operation_groupings.stderr     | 54 +++++++++---------
 tests/ui/toplevel_ref_arg_non_rustfix.stderr       |  4 +-
 tests/ui/transmuting_null.stderr                   |  6 +-
 tests/ui/unnecessary_lazy_eval.stderr              | 64 +++++++++++-----------
 tests/ui/unnecessary_lazy_eval_unfixable.stderr    |  6 +-
 tests/ui/used_underscore_binding.stderr            | 12 ++--
 tests/ui/vec_box_sized.stderr                      |  8 +--
 tests/ui/wild_in_or_pats.stderr                    | 16 +++---
 tests/ui/zero_div_zero.stderr                      |  8 +--
 54 files changed, 315 insertions(+), 315 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/assign_ops.rs b/clippy_lints/src/assign_ops.rs
index b3185b88840..e13f62d0428 100644
--- a/clippy_lints/src/assign_ops.rs
+++ b/clippy_lints/src/assign_ops.rs
@@ -209,7 +209,7 @@ fn lint_misrefactored_assign_op(
                 diag.span_suggestion(
                     expr.span,
                     &format!(
-                        "Did you mean `{} = {} {} {}` or `{}`? Consider replacing it with",
+                        "did you mean `{} = {} {} {}` or `{}`? Consider replacing it with",
                         snip_a,
                         snip_a,
                         op.node.as_str(),
diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs
index 652d1fa16b6..bb7be3d4724 100644
--- a/clippy_lints/src/attrs.rs
+++ b/clippy_lints/src/attrs.rs
@@ -639,7 +639,7 @@ fn check_mismatched_target_os(cx: &EarlyContext<'_>, attr: &Attribute) {
                     diag.span_suggestion(span, "try", sugg, Applicability::MaybeIncorrect);
 
                     if !unix_suggested && is_unix(os) {
-                        diag.help("Did you mean `unix`?");
+                        diag.help("did you mean `unix`?");
                         unix_suggested = true;
                     }
                 }
diff --git a/clippy_lints/src/await_holding_invalid.rs b/clippy_lints/src/await_holding_invalid.rs
index ae64c688744..fad3aff96cc 100644
--- a/clippy_lints/src/await_holding_invalid.rs
+++ b/clippy_lints/src/await_holding_invalid.rs
@@ -116,7 +116,7 @@ fn check_interior_types(cx: &LateContext<'_>, ty_causes: &[GeneratorInteriorType
                     cx,
                     AWAIT_HOLDING_LOCK,
                     ty_cause.span,
-                    "this MutexGuard is held across an 'await' point. Consider using an async-aware Mutex type or ensuring the MutexGuard is dropped before calling await.",
+                    "this MutexGuard is held across an 'await' point. Consider using an async-aware Mutex type or ensuring the MutexGuard is dropped before calling await",
                     ty_cause.scope_span.or(Some(span)),
                     "these are all the await points this lock is held through",
                 );
@@ -126,7 +126,7 @@ fn check_interior_types(cx: &LateContext<'_>, ty_causes: &[GeneratorInteriorType
                         cx,
                         AWAIT_HOLDING_REFCELL_REF,
                         ty_cause.span,
-                        "this RefCell Ref is held across an 'await' point. Consider ensuring the Ref is dropped before calling await.",
+                        "this RefCell Ref is held across an 'await' point. Consider ensuring the Ref is dropped before calling await",
                         ty_cause.scope_span.or(Some(span)),
                         "these are all the await points this ref is held through",
                     );
diff --git a/clippy_lints/src/comparison_chain.rs b/clippy_lints/src/comparison_chain.rs
index 90d31dece13..e309db25995 100644
--- a/clippy_lints/src/comparison_chain.rs
+++ b/clippy_lints/src/comparison_chain.rs
@@ -117,7 +117,7 @@ impl<'tcx> LateLintPass<'tcx> for ComparisonChain {
             expr.span,
             "`if` chain can be rewritten with `match`",
             None,
-            "Consider rewriting the `if` chain to use `cmp` and `match`.",
+            "consider rewriting the `if` chain to use `cmp` and `match`",
         )
     }
 }
diff --git a/clippy_lints/src/drop_forget_ref.rs b/clippy_lints/src/drop_forget_ref.rs
index a84f9c46287..2aea00d883c 100644
--- a/clippy_lints/src/drop_forget_ref.rs
+++ b/clippy_lints/src/drop_forget_ref.rs
@@ -98,13 +98,13 @@ declare_clippy_lint! {
 }
 
 const DROP_REF_SUMMARY: &str = "calls to `std::mem::drop` with a reference instead of an owned value. \
-                                Dropping a reference does nothing.";
+                                Dropping a reference does nothing";
 const FORGET_REF_SUMMARY: &str = "calls to `std::mem::forget` with a reference instead of an owned value. \
-                                  Forgetting a reference does nothing.";
+                                  Forgetting a reference does nothing";
 const DROP_COPY_SUMMARY: &str = "calls to `std::mem::drop` with a value that implements `Copy`. \
-                                 Dropping a copy leaves the original intact.";
+                                 Dropping a copy leaves the original intact";
 const FORGET_COPY_SUMMARY: &str = "calls to `std::mem::forget` with a value that implements `Copy`. \
-                                   Forgetting a copy leaves the original intact.";
+                                   Forgetting a copy leaves the original intact";
 
 declare_lint_pass!(DropForgetRef => [DROP_REF, FORGET_REF, DROP_COPY, FORGET_COPY]);
 
diff --git a/clippy_lints/src/fallible_impl_from.rs b/clippy_lints/src/fallible_impl_from.rs
index 6d522c7ef33..f466dddc13c 100644
--- a/clippy_lints/src/fallible_impl_from.rs
+++ b/clippy_lints/src/fallible_impl_from.rs
@@ -133,7 +133,7 @@ fn lint_impl_body<'tcx>(cx: &LateContext<'tcx>, impl_span: Span, impl_items: &[h
                         move |diag| {
                             diag.help(
                                 "`From` is intended for infallible conversions only. \
-                                Use `TryFrom` if there's a possibility for the conversion to fail.");
+                                Use `TryFrom` if there's a possibility for the conversion to fail");
                             diag.span_note(fpu.result, "potential failure(s)");
                         });
                 }
diff --git a/clippy_lints/src/indexing_slicing.rs b/clippy_lints/src/indexing_slicing.rs
index 741195f3b10..c919ec097a2 100644
--- a/clippy_lints/src/indexing_slicing.rs
+++ b/clippy_lints/src/indexing_slicing.rs
@@ -132,13 +132,13 @@ impl<'tcx> LateLintPass<'tcx> for IndexingSlicing {
                 }
 
                 let help_msg = match (range.start, range.end) {
-                    (None, Some(_)) => "Consider using `.get(..n)`or `.get_mut(..n)` instead",
-                    (Some(_), None) => "Consider using `.get(n..)` or .get_mut(n..)` instead",
-                    (Some(_), Some(_)) => "Consider using `.get(n..m)` or `.get_mut(n..m)` instead",
+                    (None, Some(_)) => "consider using `.get(..n)`or `.get_mut(..n)` instead",
+                    (Some(_), None) => "consider using `.get(n..)` or .get_mut(n..)` instead",
+                    (Some(_), Some(_)) => "consider using `.get(n..m)` or `.get_mut(n..m)` instead",
                     (None, None) => return, // [..] is ok.
                 };
 
-                span_lint_and_help(cx, INDEXING_SLICING, expr.span, "slicing may panic.", None, help_msg);
+                span_lint_and_help(cx, INDEXING_SLICING, expr.span, "slicing may panic", None, help_msg);
             } else {
                 // Catchall non-range index, i.e., [n] or [n << m]
                 if let ty::Array(..) = ty.kind() {
@@ -153,9 +153,9 @@ impl<'tcx> LateLintPass<'tcx> for IndexingSlicing {
                     cx,
                     INDEXING_SLICING,
                     expr.span,
-                    "indexing may panic.",
+                    "indexing may panic",
                     None,
-                    "Consider using `.get(n)` or `.get_mut(n)` instead",
+                    "consider using `.get(n)` or `.get_mut(n)` instead",
                 );
             }
         }
diff --git a/clippy_lints/src/integer_division.rs b/clippy_lints/src/integer_division.rs
index 31181c10d23..39b4605e72f 100644
--- a/clippy_lints/src/integer_division.rs
+++ b/clippy_lints/src/integer_division.rs
@@ -39,7 +39,7 @@ impl<'tcx> LateLintPass<'tcx> for IntegerDivision {
                 expr.span,
                 "integer division",
                 None,
-                "division of integers may cause loss of precision. consider using floats.",
+                "division of integers may cause loss of precision. consider using floats",
             );
         }
     }
diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 1c9373a756c..3ff9e182121 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -1625,10 +1625,7 @@ fn check_for_loop_range<'tcx>(
                         cx,
                         NEEDLESS_RANGE_LOOP,
                         expr.span,
-                        &format!(
-                            "the loop variable `{}` is only used to index `{}`.",
-                            ident.name, indexed
-                        ),
+                        &format!("the loop variable `{}` is only used to index `{}`", ident.name, indexed),
                         |diag| {
                             multispan_sugg(
                                 diag,
@@ -1763,7 +1760,7 @@ fn check_arg_type(cx: &LateContext<'_>, pat: &Pat<'_>, arg: &Expr<'_>) {
             arg.span,
             &format!(
                 "for loop over `{0}`, which is an `Option`. This is more readably written as an \
-                `if let` statement.",
+                `if let` statement",
                 snippet(cx, arg.span, "_")
             ),
             None,
@@ -1780,7 +1777,7 @@ fn check_arg_type(cx: &LateContext<'_>, pat: &Pat<'_>, arg: &Expr<'_>) {
             arg.span,
             &format!(
                 "for loop over `{0}`, which is a `Result`. This is more readably written as an \
-                `if let` statement.",
+                `if let` statement",
                 snippet(cx, arg.span, "_")
             ),
             None,
@@ -1826,7 +1823,7 @@ fn check_for_loop_explicit_counter<'tcx>(
                         cx,
                         EXPLICIT_COUNTER_LOOP,
                         for_span.with_hi(arg.span.hi()),
-                        &format!("the variable `{}` is used as a loop counter.", name),
+                        &format!("the variable `{}` is used as a loop counter", name),
                         "consider using",
                         format!(
                             "for ({}, {}) in {}.enumerate()",
@@ -3055,16 +3052,16 @@ impl IterFunction {
     fn get_suggestion_text(&self) -> &'static str {
         match &self.func {
             IterFunctionKind::IntoIter => {
-                "Use the original Iterator instead of collecting it and then producing a new one"
+                "use the original Iterator instead of collecting it and then producing a new one"
             },
             IterFunctionKind::Len => {
-                "Take the original Iterator's count instead of collecting it and finding the length"
+                "take the original Iterator's count instead of collecting it and finding the length"
             },
             IterFunctionKind::IsEmpty => {
-                "Check if the original Iterator has anything instead of collecting it and seeing if it's empty"
+                "check if the original Iterator has anything instead of collecting it and seeing if it's empty"
             },
             IterFunctionKind::Contains(_) => {
-                "Check if the original Iterator contains an element instead of collecting then checking"
+                "check if the original Iterator contains an element instead of collecting then checking"
             },
         }
     }
diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index efc8b139425..0d79ffbe944 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -1173,9 +1173,9 @@ fn check_wild_in_or_pats(cx: &LateContext<'_>, arms: &[Arm<'_>]) {
                     cx,
                     WILDCARD_IN_OR_PATTERNS,
                     arm.pat.span,
-                    "wildcard pattern covers any other pattern as it will match anyway.",
+                    "wildcard pattern covers any other pattern as it will match anyway",
                     None,
-                    "Consider handling `_` separately.",
+                    "consider handling `_` separately",
                 );
             }
         }
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 6f491144435..f5c01ac7729 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3081,7 +3081,7 @@ fn lint_filter_next<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, fil
     // lint if caller of `.filter().next()` is an Iterator
     if match_trait_method(cx, expr, &paths::ITERATOR) {
         let msg = "called `filter(..).next()` on an `Iterator`. This is more succinctly expressed by calling \
-                   `.find(..)` instead.";
+                   `.find(..)` instead";
         let filter_snippet = snippet(cx, filter_args[1].span, "..");
         if filter_snippet.lines().count() <= 1 {
             let iter_snippet = snippet(cx, filter_args[0].span, "..");
@@ -3209,7 +3209,7 @@ fn lint_filter_map_next<'tcx>(
         }
 
         let msg = "called `filter_map(..).next()` on an `Iterator`. This is more succinctly expressed by calling \
-                   `.find_map(..)` instead.";
+                   `.find_map(..)` instead";
         let filter_snippet = snippet(cx, filter_args[1].span, "..");
         if filter_snippet.lines().count() <= 1 {
             let iter_snippet = snippet(cx, filter_args[0].span, "..");
diff --git a/clippy_lints/src/methods/unnecessary_lazy_eval.rs b/clippy_lints/src/methods/unnecessary_lazy_eval.rs
index a867bdb326d..40ccb8c80b3 100644
--- a/clippy_lints/src/methods/unnecessary_lazy_eval.rs
+++ b/clippy_lints/src/methods/unnecessary_lazy_eval.rs
@@ -50,7 +50,7 @@ pub(super) fn lint<'tcx>(
                     UNNECESSARY_LAZY_EVALUATIONS,
                     expr.span,
                     msg,
-                    &format!("Use `{}` instead", simplify_using),
+                    &format!("use `{}` instead", simplify_using),
                     format!(
                         "{0}.{1}({2})",
                         snippet(cx, args[0].span, ".."),
diff --git a/clippy_lints/src/misc.rs b/clippy_lints/src/misc.rs
index 2ef5c6aa2a4..12f91d7bf63 100644
--- a/clippy_lints/src/misc.rs
+++ b/clippy_lints/src/misc.rs
@@ -292,7 +292,7 @@ impl<'tcx> LateLintPass<'tcx> for MiscLints {
                     TOPLEVEL_REF_ARG,
                     arg.pat.span,
                     "`ref` directly on a function argument is ignored. \
-                    Consider using a reference type instead.",
+                    Consider using a reference type instead",
                 );
             }
         }
@@ -422,7 +422,7 @@ impl<'tcx> LateLintPass<'tcx> for MiscLints {
                 expr.span,
                 &format!(
                     "used binding `{}` which is prefixed with an underscore. A leading \
-                     underscore signals that a binding will not be used.",
+                     underscore signals that a binding will not be used",
                     binding
                 ),
             );
diff --git a/clippy_lints/src/needless_question_mark.rs b/clippy_lints/src/needless_question_mark.rs
index fe8d4d07abc..a3293f1b361 100644
--- a/clippy_lints/src/needless_question_mark.rs
+++ b/clippy_lints/src/needless_question_mark.rs
@@ -142,7 +142,7 @@ fn emit_lint(cx: &LateContext<'_>, expr: &SomeOkCall<'_>) {
         cx,
         NEEDLESS_QUESTION_MARK,
         entire_expr.span,
-        "Question mark operator is useless here",
+        "question mark operator is useless here",
         "try",
         format!("{}", utils::snippet(cx, inner_expr.span, r#""...""#)),
         Applicability::MachineApplicable,
diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs
index de2fb8decb7..5474fdf30bf 100644
--- a/clippy_lints/src/ptr.rs
+++ b/clippy_lints/src/ptr.rs
@@ -188,7 +188,7 @@ fn check_fn(cx: &LateContext<'_>, decl: &FnDecl<'_>, fn_id: HirId, opt_body_id:
                         PTR_ARG,
                         arg.span,
                         "writing `&Vec<_>` instead of `&[_]` involves one more reference and cannot be used \
-                         with non-Vec-based slices.",
+                         with non-Vec-based slices",
                         |diag| {
                             if let Some(ref snippet) = get_only_generic_arg_snippet(cx, arg) {
                                 diag.span_suggestion(
@@ -217,7 +217,7 @@ fn check_fn(cx: &LateContext<'_>, decl: &FnDecl<'_>, fn_id: HirId, opt_body_id:
                         cx,
                         PTR_ARG,
                         arg.span,
-                        "writing `&String` instead of `&str` involves a new object where a slice will do.",
+                        "writing `&String` instead of `&str` involves a new object where a slice will do",
                         |diag| {
                             diag.span_suggestion(arg.span, "change this to", "&str".into(), Applicability::Unspecified);
                             for (clonespan, suggestion) in spans {
@@ -239,7 +239,7 @@ fn check_fn(cx: &LateContext<'_>, decl: &FnDecl<'_>, fn_id: HirId, opt_body_id:
                         cx,
                         PTR_ARG,
                         arg.span,
-                        "writing `&PathBuf` instead of `&Path` involves a new object where a slice will do.",
+                        "writing `&PathBuf` instead of `&Path` involves a new object where a slice will do",
                         |diag| {
                             diag.span_suggestion(
                                 arg.span,
@@ -278,7 +278,7 @@ fn check_fn(cx: &LateContext<'_>, decl: &FnDecl<'_>, fn_id: HirId, opt_body_id:
                                 cx,
                                 PTR_ARG,
                                 arg.span,
-                                "using a reference to `Cow` is not recommended.",
+                                "using a reference to `Cow` is not recommended",
                                 "change this to",
                                 "&".to_owned() + &r,
                                 Applicability::Unspecified,
diff --git a/clippy_lints/src/suspicious_operation_groupings.rs b/clippy_lints/src/suspicious_operation_groupings.rs
index cccd24ccf94..2ff30698043 100644
--- a/clippy_lints/src/suspicious_operation_groupings.rs
+++ b/clippy_lints/src/suspicious_operation_groupings.rs
@@ -261,7 +261,7 @@ fn emit_suggestion(cx: &EarlyContext<'_>, span: Span, sugg: String, applicabilit
         cx,
         SUSPICIOUS_OPERATION_GROUPINGS,
         span,
-        "This sequence of operators looks suspiciously like a bug.",
+        "this sequence of operators looks suspiciously like a bug",
         "I think you meant",
         sugg,
         applicability,
diff --git a/clippy_lints/src/transmuting_null.rs b/clippy_lints/src/transmuting_null.rs
index 6b171a0fa1a..2ba2b646f00 100644
--- a/clippy_lints/src/transmuting_null.rs
+++ b/clippy_lints/src/transmuting_null.rs
@@ -27,7 +27,7 @@ declare_clippy_lint! {
 
 declare_lint_pass!(TransmutingNull => [TRANSMUTING_NULL]);
 
-const LINT_MSG: &str = "transmuting a known null pointer into a reference.";
+const LINT_MSG: &str = "transmuting a known null pointer into a reference";
 
 impl<'tcx> LateLintPass<'tcx> for TransmutingNull {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs
index af8d6865f93..a18cba6fb44 100644
--- a/clippy_lints/src/types.rs
+++ b/clippy_lints/src/types.rs
@@ -388,7 +388,7 @@ impl Types {
                                 hir_ty.span,
                                 "you seem to be trying to use `Box<Vec<T>>`. Consider using just `Vec<T>`",
                                 None,
-                                "`Vec<T>` is already on the heap, `Box<Vec<T>>` makes an extra allocation.",
+                                "`Vec<T>` is already on the heap, `Box<Vec<T>>` makes an extra allocation",
                             );
                             return; // don't recurse into the type
                         }
@@ -554,7 +554,7 @@ impl Types {
                                     cx,
                                     VEC_BOX,
                                     hir_ty.span,
-                                    "`Vec<T>` is already on the heap, the boxing is unnecessary.",
+                                    "`Vec<T>` is already on the heap, the boxing is unnecessary",
                                     "try",
                                     format!("Vec<{}>", snippet(cx, boxed_ty.span, "..")),
                                     Applicability::MachineApplicable,
diff --git a/clippy_lints/src/zero_div_zero.rs b/clippy_lints/src/zero_div_zero.rs
index 4b81a27632d..11d96e15ff1 100644
--- a/clippy_lints/src/zero_div_zero.rs
+++ b/clippy_lints/src/zero_div_zero.rs
@@ -55,7 +55,7 @@ impl<'tcx> LateLintPass<'tcx> for ZeroDiv {
                     "constant division of `0.0` with `0.0` will always result in NaN",
                     None,
                     &format!(
-                        "Consider using `{}::NAN` if you would like a constant representing NaN",
+                        "consider using `{}::NAN` if you would like a constant representing NaN",
                         float_type,
                     ),
                 );
diff --git a/tests/lint_message_convention.rs b/tests/lint_message_convention.rs
index 493bd3bf56b..e316a884996 100644
--- a/tests/lint_message_convention.rs
+++ b/tests/lint_message_convention.rs
@@ -38,8 +38,11 @@ impl Message {
             r".*the arguments may be inverted...",
             r".*Intel x86 assembly syntax used",
             r".*AT&T x86 assembly syntax used",
-            r".*remove .* the return type...",
+            r".*remove .*the return type...",
             r"note: Clippy version: .*",
+            r"the compiler unexpectedly panicked. this is a bug.",
+            r".*help: I think you meant: .*",
+            r"Iterator.* will panic at runtime",
         ])
         .unwrap();
 
@@ -96,7 +99,7 @@ fn lint_message_convention() {
 
     eprintln!("\n\n\nLint message should not start with a capital letter and should not have punctuation at the end of the message unless multiple sentences are needed.");
     eprintln!("Check out the rustc-dev-guide for more information:");
-    eprintln!("https://rustc-dev-guide.rust-lang.org/diagnostics.html#diagnostic-structure");
+    eprintln!("https://rustc-dev-guide.rust-lang.org/diagnostics.html#diagnostic-structure\n\n\n");
 
     assert!(bad_tests.is_empty());
 }
diff --git a/tests/ui-toml/vec_box_sized/test.stderr b/tests/ui-toml/vec_box_sized/test.stderr
index 3bdeca0bc87..cf194de3c55 100644
--- a/tests/ui-toml/vec_box_sized/test.stderr
+++ b/tests/ui-toml/vec_box_sized/test.stderr
@@ -1,4 +1,4 @@
-error: `Vec<T>` is already on the heap, the boxing is unnecessary.
+error: `Vec<T>` is already on the heap, the boxing is unnecessary
   --> $DIR/test.rs:9:12
    |
 LL | struct Foo(Vec<Box<u8>>);
@@ -6,13 +6,13 @@ LL | struct Foo(Vec<Box<u8>>);
    |
    = note: `-D clippy::vec-box` implied by `-D warnings`
 
-error: `Vec<T>` is already on the heap, the boxing is unnecessary.
+error: `Vec<T>` is already on the heap, the boxing is unnecessary
   --> $DIR/test.rs:10:12
    |
 LL | struct Bar(Vec<Box<u32>>);
    |            ^^^^^^^^^^^^^ help: try: `Vec<u32>`
 
-error: `Vec<T>` is already on the heap, the boxing is unnecessary.
+error: `Vec<T>` is already on the heap, the boxing is unnecessary
   --> $DIR/test.rs:13:18
    |
 LL | struct FooBarBaz(Vec<Box<C>>);
diff --git a/tests/ui/assign_ops2.stderr b/tests/ui/assign_ops2.stderr
index 70b15d18a56..e40668ed339 100644
--- a/tests/ui/assign_ops2.stderr
+++ b/tests/ui/assign_ops2.stderr
@@ -5,7 +5,7 @@ LL |     a += a + 1;
    |     ^^^^^^^^^^
    |
    = note: `-D clippy::misrefactored-assign-op` implied by `-D warnings`
-help: Did you mean `a = a + 1` or `a = a + a + 1`? Consider replacing it with
+help: did you mean `a = a + 1` or `a = a + a + 1`? Consider replacing it with
    |
 LL |     a += 1;
    |     ^^^^^^
@@ -20,7 +20,7 @@ error: variable appears on both sides of an assignment operation
 LL |     a += 1 + a;
    |     ^^^^^^^^^^
    |
-help: Did you mean `a = a + 1` or `a = a + 1 + a`? Consider replacing it with
+help: did you mean `a = a + 1` or `a = a + 1 + a`? Consider replacing it with
    |
 LL |     a += 1;
    |     ^^^^^^
@@ -35,7 +35,7 @@ error: variable appears on both sides of an assignment operation
 LL |     a -= a - 1;
    |     ^^^^^^^^^^
    |
-help: Did you mean `a = a - 1` or `a = a - (a - 1)`? Consider replacing it with
+help: did you mean `a = a - 1` or `a = a - (a - 1)`? Consider replacing it with
    |
 LL |     a -= 1;
    |     ^^^^^^
@@ -50,7 +50,7 @@ error: variable appears on both sides of an assignment operation
 LL |     a *= a * 99;
    |     ^^^^^^^^^^^
    |
-help: Did you mean `a = a * 99` or `a = a * a * 99`? Consider replacing it with
+help: did you mean `a = a * 99` or `a = a * a * 99`? Consider replacing it with
    |
 LL |     a *= 99;
    |     ^^^^^^^
@@ -65,7 +65,7 @@ error: variable appears on both sides of an assignment operation
 LL |     a *= 42 * a;
    |     ^^^^^^^^^^^
    |
-help: Did you mean `a = a * 42` or `a = a * 42 * a`? Consider replacing it with
+help: did you mean `a = a * 42` or `a = a * 42 * a`? Consider replacing it with
    |
 LL |     a *= 42;
    |     ^^^^^^^
@@ -80,7 +80,7 @@ error: variable appears on both sides of an assignment operation
 LL |     a /= a / 2;
    |     ^^^^^^^^^^
    |
-help: Did you mean `a = a / 2` or `a = a / (a / 2)`? Consider replacing it with
+help: did you mean `a = a / 2` or `a = a / (a / 2)`? Consider replacing it with
    |
 LL |     a /= 2;
    |     ^^^^^^
@@ -95,7 +95,7 @@ error: variable appears on both sides of an assignment operation
 LL |     a %= a % 5;
    |     ^^^^^^^^^^
    |
-help: Did you mean `a = a % 5` or `a = a % (a % 5)`? Consider replacing it with
+help: did you mean `a = a % 5` or `a = a % (a % 5)`? Consider replacing it with
    |
 LL |     a %= 5;
    |     ^^^^^^
@@ -110,7 +110,7 @@ error: variable appears on both sides of an assignment operation
 LL |     a &= a & 1;
    |     ^^^^^^^^^^
    |
-help: Did you mean `a = a & 1` or `a = a & a & 1`? Consider replacing it with
+help: did you mean `a = a & 1` or `a = a & a & 1`? Consider replacing it with
    |
 LL |     a &= 1;
    |     ^^^^^^
@@ -125,7 +125,7 @@ error: variable appears on both sides of an assignment operation
 LL |     a *= a * a;
    |     ^^^^^^^^^^
    |
-help: Did you mean `a = a * a` or `a = a * a * a`? Consider replacing it with
+help: did you mean `a = a * a` or `a = a * a * a`? Consider replacing it with
    |
 LL |     a *= a;
    |     ^^^^^^
diff --git a/tests/ui/await_holding_lock.stderr b/tests/ui/await_holding_lock.stderr
index 21bf49d16f0..a5fcff7e0e4 100644
--- a/tests/ui/await_holding_lock.stderr
+++ b/tests/ui/await_holding_lock.stderr
@@ -1,4 +1,4 @@
-error: this MutexGuard is held across an 'await' point. Consider using an async-aware Mutex type or ensuring the MutexGuard is dropped before calling await.
+error: this MutexGuard is held across an 'await' point. Consider using an async-aware Mutex type or ensuring the MutexGuard is dropped before calling await
   --> $DIR/await_holding_lock.rs:7:9
    |
 LL |     let guard = x.lock().unwrap();
@@ -13,7 +13,7 @@ LL | |     baz().await
 LL | | }
    | |_^
 
-error: this MutexGuard is held across an 'await' point. Consider using an async-aware Mutex type or ensuring the MutexGuard is dropped before calling await.
+error: this MutexGuard is held across an 'await' point. Consider using an async-aware Mutex type or ensuring the MutexGuard is dropped before calling await
   --> $DIR/await_holding_lock.rs:28:9
    |
 LL |     let guard = x.lock().unwrap();
@@ -31,7 +31,7 @@ LL | |     first + second + third
 LL | | }
    | |_^
 
-error: this MutexGuard is held across an 'await' point. Consider using an async-aware Mutex type or ensuring the MutexGuard is dropped before calling await.
+error: this MutexGuard is held across an 'await' point. Consider using an async-aware Mutex type or ensuring the MutexGuard is dropped before calling await
   --> $DIR/await_holding_lock.rs:41:13
    |
 LL |         let guard = x.lock().unwrap();
@@ -45,7 +45,7 @@ LL | |         baz().await
 LL | |     };
    | |_____^
 
-error: this MutexGuard is held across an 'await' point. Consider using an async-aware Mutex type or ensuring the MutexGuard is dropped before calling await.
+error: this MutexGuard is held across an 'await' point. Consider using an async-aware Mutex type or ensuring the MutexGuard is dropped before calling await
   --> $DIR/await_holding_lock.rs:53:13
    |
 LL |         let guard = x.lock().unwrap();
diff --git a/tests/ui/await_holding_refcell_ref.stderr b/tests/ui/await_holding_refcell_ref.stderr
index b504f045491..55e41dbca96 100644
--- a/tests/ui/await_holding_refcell_ref.stderr
+++ b/tests/ui/await_holding_refcell_ref.stderr
@@ -1,4 +1,4 @@
-error: this RefCell Ref is held across an 'await' point. Consider ensuring the Ref is dropped before calling await.
+error: this RefCell Ref is held across an 'await' point. Consider ensuring the Ref is dropped before calling await
   --> $DIR/await_holding_refcell_ref.rs:7:9
    |
 LL |     let b = x.borrow();
@@ -13,7 +13,7 @@ LL | |     baz().await
 LL | | }
    | |_^
 
-error: this RefCell Ref is held across an 'await' point. Consider ensuring the Ref is dropped before calling await.
+error: this RefCell Ref is held across an 'await' point. Consider ensuring the Ref is dropped before calling await
   --> $DIR/await_holding_refcell_ref.rs:12:9
    |
 LL |     let b = x.borrow_mut();
@@ -27,7 +27,7 @@ LL | |     baz().await
 LL | | }
    | |_^
 
-error: this RefCell Ref is held across an 'await' point. Consider ensuring the Ref is dropped before calling await.
+error: this RefCell Ref is held across an 'await' point. Consider ensuring the Ref is dropped before calling await
   --> $DIR/await_holding_refcell_ref.rs:33:9
    |
 LL |     let b = x.borrow_mut();
@@ -45,7 +45,7 @@ LL | |     first + second + third
 LL | | }
    | |_^
 
-error: this RefCell Ref is held across an 'await' point. Consider ensuring the Ref is dropped before calling await.
+error: this RefCell Ref is held across an 'await' point. Consider ensuring the Ref is dropped before calling await
   --> $DIR/await_holding_refcell_ref.rs:45:9
    |
 LL |     let b = x.borrow_mut();
@@ -63,7 +63,7 @@ LL | |     first + second + third
 LL | | }
    | |_^
 
-error: this RefCell Ref is held across an 'await' point. Consider ensuring the Ref is dropped before calling await.
+error: this RefCell Ref is held across an 'await' point. Consider ensuring the Ref is dropped before calling await
   --> $DIR/await_holding_refcell_ref.rs:60:13
    |
 LL |         let b = x.borrow_mut();
@@ -77,7 +77,7 @@ LL | |         baz().await
 LL | |     };
    | |_____^
 
-error: this RefCell Ref is held across an 'await' point. Consider ensuring the Ref is dropped before calling await.
+error: this RefCell Ref is held across an 'await' point. Consider ensuring the Ref is dropped before calling await
   --> $DIR/await_holding_refcell_ref.rs:72:13
    |
 LL |         let b = x.borrow_mut();
diff --git a/tests/ui/box_vec.stderr b/tests/ui/box_vec.stderr
index fca12eddd57..9b789334bae 100644
--- a/tests/ui/box_vec.stderr
+++ b/tests/ui/box_vec.stderr
@@ -5,7 +5,7 @@ LL | pub fn test(foo: Box<Vec<bool>>) {
    |                  ^^^^^^^^^^^^^^
    |
    = note: `-D clippy::box-vec` implied by `-D warnings`
-   = help: `Vec<T>` is already on the heap, `Box<Vec<T>>` makes an extra allocation.
+   = help: `Vec<T>` is already on the heap, `Box<Vec<T>>` makes an extra allocation
 
 error: aborting due to previous error
 
diff --git a/tests/ui/comparison_chain.stderr b/tests/ui/comparison_chain.stderr
index 69db88b03b5..be25a80dde0 100644
--- a/tests/ui/comparison_chain.stderr
+++ b/tests/ui/comparison_chain.stderr
@@ -9,7 +9,7 @@ LL | |     }
    | |_____^
    |
    = note: `-D clippy::comparison-chain` implied by `-D warnings`
-   = help: Consider rewriting the `if` chain to use `cmp` and `match`.
+   = help: consider rewriting the `if` chain to use `cmp` and `match`
 
 error: `if` chain can be rewritten with `match`
   --> $DIR/comparison_chain.rs:27:5
@@ -23,7 +23,7 @@ LL | |         c()
 LL | |     }
    | |_____^
    |
-   = help: Consider rewriting the `if` chain to use `cmp` and `match`.
+   = help: consider rewriting the `if` chain to use `cmp` and `match`
 
 error: `if` chain can be rewritten with `match`
   --> $DIR/comparison_chain.rs:35:5
@@ -37,7 +37,7 @@ LL | |         c()
 LL | |     }
    | |_____^
    |
-   = help: Consider rewriting the `if` chain to use `cmp` and `match`.
+   = help: consider rewriting the `if` chain to use `cmp` and `match`
 
 error: `if` chain can be rewritten with `match`
   --> $DIR/comparison_chain.rs:43:5
@@ -51,7 +51,7 @@ LL | |         c()
 LL | |     }
    | |_____^
    |
-   = help: Consider rewriting the `if` chain to use `cmp` and `match`.
+   = help: consider rewriting the `if` chain to use `cmp` and `match`
 
 error: `if` chain can be rewritten with `match`
   --> $DIR/comparison_chain.rs:117:5
@@ -63,7 +63,7 @@ LL | |         b()
 LL | |     }
    | |_____^
    |
-   = help: Consider rewriting the `if` chain to use `cmp` and `match`.
+   = help: consider rewriting the `if` chain to use `cmp` and `match`
 
 error: `if` chain can be rewritten with `match`
   --> $DIR/comparison_chain.rs:123:5
@@ -77,7 +77,7 @@ LL | |         c()
 LL | |     }
    | |_____^
    |
-   = help: Consider rewriting the `if` chain to use `cmp` and `match`.
+   = help: consider rewriting the `if` chain to use `cmp` and `match`
 
 error: `if` chain can be rewritten with `match`
   --> $DIR/comparison_chain.rs:131:5
@@ -91,7 +91,7 @@ LL | |         c()
 LL | |     }
    | |_____^
    |
-   = help: Consider rewriting the `if` chain to use `cmp` and `match`.
+   = help: consider rewriting the `if` chain to use `cmp` and `match`
 
 error: aborting due to 7 previous errors
 
diff --git a/tests/ui/drop_forget_copy.stderr b/tests/ui/drop_forget_copy.stderr
index 82a4f047ba8..01de0be7cae 100644
--- a/tests/ui/drop_forget_copy.stderr
+++ b/tests/ui/drop_forget_copy.stderr
@@ -1,4 +1,4 @@
-error: calls to `std::mem::drop` with a value that implements `Copy`. Dropping a copy leaves the original intact.
+error: calls to `std::mem::drop` with a value that implements `Copy`. Dropping a copy leaves the original intact
   --> $DIR/drop_forget_copy.rs:33:5
    |
 LL |     drop(s1);
@@ -11,7 +11,7 @@ note: argument has type SomeStruct
 LL |     drop(s1);
    |          ^^
 
-error: calls to `std::mem::drop` with a value that implements `Copy`. Dropping a copy leaves the original intact.
+error: calls to `std::mem::drop` with a value that implements `Copy`. Dropping a copy leaves the original intact
   --> $DIR/drop_forget_copy.rs:34:5
    |
 LL |     drop(s2);
@@ -23,7 +23,7 @@ note: argument has type SomeStruct
 LL |     drop(s2);
    |          ^^
 
-error: calls to `std::mem::drop` with a value that implements `Copy`. Dropping a copy leaves the original intact.
+error: calls to `std::mem::drop` with a value that implements `Copy`. Dropping a copy leaves the original intact
   --> $DIR/drop_forget_copy.rs:36:5
    |
 LL |     drop(s4);
@@ -35,7 +35,7 @@ note: argument has type SomeStruct
 LL |     drop(s4);
    |          ^^
 
-error: calls to `std::mem::forget` with a value that implements `Copy`. Forgetting a copy leaves the original intact.
+error: calls to `std::mem::forget` with a value that implements `Copy`. Forgetting a copy leaves the original intact
   --> $DIR/drop_forget_copy.rs:39:5
    |
 LL |     forget(s1);
@@ -48,7 +48,7 @@ note: argument has type SomeStruct
 LL |     forget(s1);
    |            ^^
 
-error: calls to `std::mem::forget` with a value that implements `Copy`. Forgetting a copy leaves the original intact.
+error: calls to `std::mem::forget` with a value that implements `Copy`. Forgetting a copy leaves the original intact
   --> $DIR/drop_forget_copy.rs:40:5
    |
 LL |     forget(s2);
@@ -60,7 +60,7 @@ note: argument has type SomeStruct
 LL |     forget(s2);
    |            ^^
 
-error: calls to `std::mem::forget` with a value that implements `Copy`. Forgetting a copy leaves the original intact.
+error: calls to `std::mem::forget` with a value that implements `Copy`. Forgetting a copy leaves the original intact
   --> $DIR/drop_forget_copy.rs:42:5
    |
 LL |     forget(s4);
diff --git a/tests/ui/drop_ref.stderr b/tests/ui/drop_ref.stderr
index 10087cb4820..531849f0680 100644
--- a/tests/ui/drop_ref.stderr
+++ b/tests/ui/drop_ref.stderr
@@ -1,4 +1,4 @@
-error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing.
+error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing
   --> $DIR/drop_ref.rs:11:5
    |
 LL |     drop(&SomeStruct);
@@ -11,7 +11,7 @@ note: argument has type `&SomeStruct`
 LL |     drop(&SomeStruct);
    |          ^^^^^^^^^^^
 
-error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing.
+error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing
   --> $DIR/drop_ref.rs:14:5
    |
 LL |     drop(&owned1);
@@ -23,7 +23,7 @@ note: argument has type `&SomeStruct`
 LL |     drop(&owned1);
    |          ^^^^^^^
 
-error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing.
+error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing
   --> $DIR/drop_ref.rs:15:5
    |
 LL |     drop(&&owned1);
@@ -35,7 +35,7 @@ note: argument has type `&&SomeStruct`
 LL |     drop(&&owned1);
    |          ^^^^^^^^
 
-error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing.
+error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing
   --> $DIR/drop_ref.rs:16:5
    |
 LL |     drop(&mut owned1);
@@ -47,7 +47,7 @@ note: argument has type `&mut SomeStruct`
 LL |     drop(&mut owned1);
    |          ^^^^^^^^^^^
 
-error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing.
+error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing
   --> $DIR/drop_ref.rs:20:5
    |
 LL |     drop(reference1);
@@ -59,7 +59,7 @@ note: argument has type `&SomeStruct`
 LL |     drop(reference1);
    |          ^^^^^^^^^^
 
-error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing.
+error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing
   --> $DIR/drop_ref.rs:23:5
    |
 LL |     drop(reference2);
@@ -71,7 +71,7 @@ note: argument has type `&mut SomeStruct`
 LL |     drop(reference2);
    |          ^^^^^^^^^^
 
-error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing.
+error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing
   --> $DIR/drop_ref.rs:26:5
    |
 LL |     drop(reference3);
@@ -83,7 +83,7 @@ note: argument has type `&SomeStruct`
 LL |     drop(reference3);
    |          ^^^^^^^^^^
 
-error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing.
+error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing
   --> $DIR/drop_ref.rs:31:5
    |
 LL |     drop(&val);
@@ -95,7 +95,7 @@ note: argument has type `&T`
 LL |     drop(&val);
    |          ^^^^
 
-error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing.
+error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing
   --> $DIR/drop_ref.rs:39:5
    |
 LL |     std::mem::drop(&SomeStruct);
diff --git a/tests/ui/explicit_counter_loop.stderr b/tests/ui/explicit_counter_loop.stderr
index 931af46efe6..4cbacffe87b 100644
--- a/tests/ui/explicit_counter_loop.stderr
+++ b/tests/ui/explicit_counter_loop.stderr
@@ -1,4 +1,4 @@
-error: the variable `_index` is used as a loop counter.
+error: the variable `_index` is used as a loop counter
   --> $DIR/explicit_counter_loop.rs:6:5
    |
 LL |     for _v in &vec {
@@ -6,37 +6,37 @@ LL |     for _v in &vec {
    |
    = note: `-D clippy::explicit-counter-loop` implied by `-D warnings`
 
-error: the variable `_index` is used as a loop counter.
+error: the variable `_index` is used as a loop counter
   --> $DIR/explicit_counter_loop.rs:12:5
    |
 LL |     for _v in &vec {
    |     ^^^^^^^^^^^^^^ help: consider using: `for (_index, _v) in vec.iter().enumerate()`
 
-error: the variable `_index` is used as a loop counter.
+error: the variable `_index` is used as a loop counter
   --> $DIR/explicit_counter_loop.rs:17:5
    |
 LL |     for _v in &mut vec {
    |     ^^^^^^^^^^^^^^^^^^ help: consider using: `for (_index, _v) in vec.iter_mut().enumerate()`
 
-error: the variable `_index` is used as a loop counter.
+error: the variable `_index` is used as a loop counter
   --> $DIR/explicit_counter_loop.rs:22:5
    |
 LL |     for _v in vec {
    |     ^^^^^^^^^^^^^ help: consider using: `for (_index, _v) in vec.into_iter().enumerate()`
 
-error: the variable `count` is used as a loop counter.
+error: the variable `count` is used as a loop counter
   --> $DIR/explicit_counter_loop.rs:61:9
    |
 LL |         for ch in text.chars() {
    |         ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `for (count, ch) in text.chars().enumerate()`
 
-error: the variable `count` is used as a loop counter.
+error: the variable `count` is used as a loop counter
   --> $DIR/explicit_counter_loop.rs:72:9
    |
 LL |         for ch in text.chars() {
    |         ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `for (count, ch) in text.chars().enumerate()`
 
-error: the variable `count` is used as a loop counter.
+error: the variable `count` is used as a loop counter
   --> $DIR/explicit_counter_loop.rs:130:9
    |
 LL |         for _i in 3..10 {
diff --git a/tests/ui/fallible_impl_from.stderr b/tests/ui/fallible_impl_from.stderr
index f787b30bdab..a938d234fa0 100644
--- a/tests/ui/fallible_impl_from.stderr
+++ b/tests/ui/fallible_impl_from.stderr
@@ -13,7 +13,7 @@ note: the lint level is defined here
    |
 LL | #![deny(clippy::fallible_impl_from)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
-   = help: `From` is intended for infallible conversions only. Use `TryFrom` if there's a possibility for the conversion to fail.
+   = help: `From` is intended for infallible conversions only. Use `TryFrom` if there's a possibility for the conversion to fail
 note: potential failure(s)
   --> $DIR/fallible_impl_from.rs:7:13
    |
@@ -32,7 +32,7 @@ LL | |     }
 LL | | }
    | |_^
    |
-   = help: `From` is intended for infallible conversions only. Use `TryFrom` if there's a possibility for the conversion to fail.
+   = help: `From` is intended for infallible conversions only. Use `TryFrom` if there's a possibility for the conversion to fail
 note: potential failure(s)
   --> $DIR/fallible_impl_from.rs:29:13
    |
@@ -52,7 +52,7 @@ LL | |     }
 LL | | }
    | |_^
    |
-   = help: `From` is intended for infallible conversions only. Use `TryFrom` if there's a possibility for the conversion to fail.
+   = help: `From` is intended for infallible conversions only. Use `TryFrom` if there's a possibility for the conversion to fail
 note: potential failure(s)
   --> $DIR/fallible_impl_from.rs:37:17
    |
@@ -79,7 +79,7 @@ LL | |     }
 LL | | }
    | |_^
    |
-   = help: `From` is intended for infallible conversions only. Use `TryFrom` if there's a possibility for the conversion to fail.
+   = help: `From` is intended for infallible conversions only. Use `TryFrom` if there's a possibility for the conversion to fail
 note: potential failure(s)
   --> $DIR/fallible_impl_from.rs:55:12
    |
diff --git a/tests/ui/filter_map_next.stderr b/tests/ui/filter_map_next.stderr
index 45427684d96..ddc982c93fe 100644
--- a/tests/ui/filter_map_next.stderr
+++ b/tests/ui/filter_map_next.stderr
@@ -1,4 +1,4 @@
-error: called `filter_map(..).next()` on an `Iterator`. This is more succinctly expressed by calling `.find_map(..)` instead.
+error: called `filter_map(..).next()` on an `Iterator`. This is more succinctly expressed by calling `.find_map(..)` instead
   --> $DIR/filter_map_next.rs:7:26
    |
 LL |       let _: Option<u32> = vec![1, 2, 3, 4, 5, 6]
diff --git a/tests/ui/filter_map_next_fixable.stderr b/tests/ui/filter_map_next_fixable.stderr
index 6c2530e0379..3bb062ffd7a 100644
--- a/tests/ui/filter_map_next_fixable.stderr
+++ b/tests/ui/filter_map_next_fixable.stderr
@@ -1,4 +1,4 @@
-error: called `filter_map(..).next()` on an `Iterator`. This is more succinctly expressed by calling `.find_map(..)` instead.
+error: called `filter_map(..).next()` on an `Iterator`. This is more succinctly expressed by calling `.find_map(..)` instead
   --> $DIR/filter_map_next_fixable.rs:8:32
    |
 LL |     let element: Option<i32> = a.iter().filter_map(|s| s.parse().ok()).next();
diff --git a/tests/ui/for_loops_over_fallibles.stderr b/tests/ui/for_loops_over_fallibles.stderr
index bef228d4b93..52b94875aec 100644
--- a/tests/ui/for_loops_over_fallibles.stderr
+++ b/tests/ui/for_loops_over_fallibles.stderr
@@ -1,4 +1,4 @@
-error: for loop over `option`, which is an `Option`. This is more readably written as an `if let` statement.
+error: for loop over `option`, which is an `Option`. This is more readably written as an `if let` statement
   --> $DIR/for_loops_over_fallibles.rs:9:14
    |
 LL |     for x in option {
@@ -7,7 +7,7 @@ LL |     for x in option {
    = note: `-D clippy::for-loops-over-fallibles` implied by `-D warnings`
    = help: consider replacing `for x in option` with `if let Some(x) = option`
 
-error: for loop over `result`, which is a `Result`. This is more readably written as an `if let` statement.
+error: for loop over `result`, which is a `Result`. This is more readably written as an `if let` statement
   --> $DIR/for_loops_over_fallibles.rs:14:14
    |
 LL |     for x in result {
@@ -15,7 +15,7 @@ LL |     for x in result {
    |
    = help: consider replacing `for x in result` with `if let Ok(x) = result`
 
-error: for loop over `option.ok_or("x not found")`, which is a `Result`. This is more readably written as an `if let` statement.
+error: for loop over `option.ok_or("x not found")`, which is a `Result`. This is more readably written as an `if let` statement
   --> $DIR/for_loops_over_fallibles.rs:18:14
    |
 LL |     for x in option.ok_or("x not found") {
@@ -31,7 +31,7 @@ LL |     for x in v.iter().next() {
    |
    = note: `#[deny(clippy::iter_next_loop)]` on by default
 
-error: for loop over `v.iter().next().and(Some(0))`, which is an `Option`. This is more readably written as an `if let` statement.
+error: for loop over `v.iter().next().and(Some(0))`, which is an `Option`. This is more readably written as an `if let` statement
   --> $DIR/for_loops_over_fallibles.rs:29:14
    |
 LL |     for x in v.iter().next().and(Some(0)) {
@@ -39,7 +39,7 @@ LL |     for x in v.iter().next().and(Some(0)) {
    |
    = help: consider replacing `for x in v.iter().next().and(Some(0))` with `if let Some(x) = v.iter().next().and(Some(0))`
 
-error: for loop over `v.iter().next().ok_or("x not found")`, which is a `Result`. This is more readably written as an `if let` statement.
+error: for loop over `v.iter().next().ok_or("x not found")`, which is a `Result`. This is more readably written as an `if let` statement
   --> $DIR/for_loops_over_fallibles.rs:33:14
    |
 LL |     for x in v.iter().next().ok_or("x not found") {
diff --git a/tests/ui/forget_ref.stderr b/tests/ui/forget_ref.stderr
index b2c7f2023bf..73409388ed1 100644
--- a/tests/ui/forget_ref.stderr
+++ b/tests/ui/forget_ref.stderr
@@ -1,4 +1,4 @@
-error: calls to `std::mem::forget` with a reference instead of an owned value. Forgetting a reference does nothing.
+error: calls to `std::mem::forget` with a reference instead of an owned value. Forgetting a reference does nothing
   --> $DIR/forget_ref.rs:10:5
    |
 LL |     forget(&SomeStruct);
@@ -11,7 +11,7 @@ note: argument has type `&SomeStruct`
 LL |     forget(&SomeStruct);
    |            ^^^^^^^^^^^
 
-error: calls to `std::mem::forget` with a reference instead of an owned value. Forgetting a reference does nothing.
+error: calls to `std::mem::forget` with a reference instead of an owned value. Forgetting a reference does nothing
   --> $DIR/forget_ref.rs:13:5
    |
 LL |     forget(&owned);
@@ -23,7 +23,7 @@ note: argument has type `&SomeStruct`
 LL |     forget(&owned);
    |            ^^^^^^
 
-error: calls to `std::mem::forget` with a reference instead of an owned value. Forgetting a reference does nothing.
+error: calls to `std::mem::forget` with a reference instead of an owned value. Forgetting a reference does nothing
   --> $DIR/forget_ref.rs:14:5
    |
 LL |     forget(&&owned);
@@ -35,7 +35,7 @@ note: argument has type `&&SomeStruct`
 LL |     forget(&&owned);
    |            ^^^^^^^
 
-error: calls to `std::mem::forget` with a reference instead of an owned value. Forgetting a reference does nothing.
+error: calls to `std::mem::forget` with a reference instead of an owned value. Forgetting a reference does nothing
   --> $DIR/forget_ref.rs:15:5
    |
 LL |     forget(&mut owned);
@@ -47,7 +47,7 @@ note: argument has type `&mut SomeStruct`
 LL |     forget(&mut owned);
    |            ^^^^^^^^^^
 
-error: calls to `std::mem::forget` with a reference instead of an owned value. Forgetting a reference does nothing.
+error: calls to `std::mem::forget` with a reference instead of an owned value. Forgetting a reference does nothing
   --> $DIR/forget_ref.rs:19:5
    |
 LL |     forget(&*reference1);
@@ -59,7 +59,7 @@ note: argument has type `&SomeStruct`
 LL |     forget(&*reference1);
    |            ^^^^^^^^^^^^
 
-error: calls to `std::mem::forget` with a reference instead of an owned value. Forgetting a reference does nothing.
+error: calls to `std::mem::forget` with a reference instead of an owned value. Forgetting a reference does nothing
   --> $DIR/forget_ref.rs:22:5
    |
 LL |     forget(reference2);
@@ -71,7 +71,7 @@ note: argument has type `&mut SomeStruct`
 LL |     forget(reference2);
    |            ^^^^^^^^^^
 
-error: calls to `std::mem::forget` with a reference instead of an owned value. Forgetting a reference does nothing.
+error: calls to `std::mem::forget` with a reference instead of an owned value. Forgetting a reference does nothing
   --> $DIR/forget_ref.rs:25:5
    |
 LL |     forget(reference3);
@@ -83,7 +83,7 @@ note: argument has type `&SomeStruct`
 LL |     forget(reference3);
    |            ^^^^^^^^^^
 
-error: calls to `std::mem::forget` with a reference instead of an owned value. Forgetting a reference does nothing.
+error: calls to `std::mem::forget` with a reference instead of an owned value. Forgetting a reference does nothing
   --> $DIR/forget_ref.rs:30:5
    |
 LL |     forget(&val);
@@ -95,7 +95,7 @@ note: argument has type `&T`
 LL |     forget(&val);
    |            ^^^^
 
-error: calls to `std::mem::forget` with a reference instead of an owned value. Forgetting a reference does nothing.
+error: calls to `std::mem::forget` with a reference instead of an owned value. Forgetting a reference does nothing
   --> $DIR/forget_ref.rs:38:5
    |
 LL |     std::mem::forget(&SomeStruct);
diff --git a/tests/ui/indexing_slicing_index.stderr b/tests/ui/indexing_slicing_index.stderr
index 2f6c9e2f4e5..76ecec33484 100644
--- a/tests/ui/indexing_slicing_index.stderr
+++ b/tests/ui/indexing_slicing_index.stderr
@@ -1,51 +1,51 @@
-error: indexing may panic.
+error: indexing may panic
   --> $DIR/indexing_slicing_index.rs:10:5
    |
 LL |     x[index];
    |     ^^^^^^^^
    |
    = note: `-D clippy::indexing-slicing` implied by `-D warnings`
-   = help: Consider using `.get(n)` or `.get_mut(n)` instead
+   = help: consider using `.get(n)` or `.get_mut(n)` instead
 
-error: indexing may panic.
+error: indexing may panic
   --> $DIR/indexing_slicing_index.rs:22:5
    |
 LL |     v[0];
    |     ^^^^
    |
-   = help: Consider using `.get(n)` or `.get_mut(n)` instead
+   = help: consider using `.get(n)` or `.get_mut(n)` instead
 
-error: indexing may panic.
+error: indexing may panic
   --> $DIR/indexing_slicing_index.rs:23:5
    |
 LL |     v[10];
    |     ^^^^^
    |
-   = help: Consider using `.get(n)` or `.get_mut(n)` instead
+   = help: consider using `.get(n)` or `.get_mut(n)` instead
 
-error: indexing may panic.
+error: indexing may panic
   --> $DIR/indexing_slicing_index.rs:24:5
    |
 LL |     v[1 << 3];
    |     ^^^^^^^^^
    |
-   = help: Consider using `.get(n)` or `.get_mut(n)` instead
+   = help: consider using `.get(n)` or `.get_mut(n)` instead
 
-error: indexing may panic.
+error: indexing may panic
   --> $DIR/indexing_slicing_index.rs:30:5
    |
 LL |     v[N];
    |     ^^^^
    |
-   = help: Consider using `.get(n)` or `.get_mut(n)` instead
+   = help: consider using `.get(n)` or `.get_mut(n)` instead
 
-error: indexing may panic.
+error: indexing may panic
   --> $DIR/indexing_slicing_index.rs:31:5
    |
 LL |     v[M];
    |     ^^^^
    |
-   = help: Consider using `.get(n)` or `.get_mut(n)` instead
+   = help: consider using `.get(n)` or `.get_mut(n)` instead
 
 error: aborting due to 6 previous errors
 
diff --git a/tests/ui/indexing_slicing_slice.stderr b/tests/ui/indexing_slicing_slice.stderr
index 2231deee833..f70722b92a5 100644
--- a/tests/ui/indexing_slicing_slice.stderr
+++ b/tests/ui/indexing_slicing_slice.stderr
@@ -1,51 +1,51 @@
-error: slicing may panic.
+error: slicing may panic
   --> $DIR/indexing_slicing_slice.rs:12:6
    |
 LL |     &x[index..];
    |      ^^^^^^^^^^
    |
    = note: `-D clippy::indexing-slicing` implied by `-D warnings`
-   = help: Consider using `.get(n..)` or .get_mut(n..)` instead
+   = help: consider using `.get(n..)` or .get_mut(n..)` instead
 
-error: slicing may panic.
+error: slicing may panic
   --> $DIR/indexing_slicing_slice.rs:13:6
    |
 LL |     &x[..index];
    |      ^^^^^^^^^^
    |
-   = help: Consider using `.get(..n)`or `.get_mut(..n)` instead
+   = help: consider using `.get(..n)`or `.get_mut(..n)` instead
 
-error: slicing may panic.
+error: slicing may panic
   --> $DIR/indexing_slicing_slice.rs:14:6
    |
 LL |     &x[index_from..index_to];
    |      ^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: Consider using `.get(n..m)` or `.get_mut(n..m)` instead
+   = help: consider using `.get(n..m)` or `.get_mut(n..m)` instead
 
-error: slicing may panic.
+error: slicing may panic
   --> $DIR/indexing_slicing_slice.rs:15:6
    |
 LL |     &x[index_from..][..index_to]; // Two lint reports, one for [index_from..] and another for [..index_to].
    |      ^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: Consider using `.get(..n)`or `.get_mut(..n)` instead
+   = help: consider using `.get(..n)`or `.get_mut(..n)` instead
 
-error: slicing may panic.
+error: slicing may panic
   --> $DIR/indexing_slicing_slice.rs:15:6
    |
 LL |     &x[index_from..][..index_to]; // Two lint reports, one for [index_from..] and another for [..index_to].
    |      ^^^^^^^^^^^^^^^
    |
-   = help: Consider using `.get(n..)` or .get_mut(n..)` instead
+   = help: consider using `.get(n..)` or .get_mut(n..)` instead
 
-error: slicing may panic.
+error: slicing may panic
   --> $DIR/indexing_slicing_slice.rs:16:6
    |
 LL |     &x[5..][..10]; // Two lint reports, one for out of bounds [5..] and another for slicing [..10].
    |      ^^^^^^^^^^^^
    |
-   = help: Consider using `.get(..n)`or `.get_mut(..n)` instead
+   = help: consider using `.get(..n)`or `.get_mut(..n)` instead
 
 error: range is out of bounds
   --> $DIR/indexing_slicing_slice.rs:16:8
@@ -55,21 +55,21 @@ LL |     &x[5..][..10]; // Two lint reports, one for out of bounds [5..] and ano
    |
    = note: `-D clippy::out-of-bounds-indexing` implied by `-D warnings`
 
-error: slicing may panic.
+error: slicing may panic
   --> $DIR/indexing_slicing_slice.rs:17:6
    |
 LL |     &x[0..][..3];
    |      ^^^^^^^^^^^
    |
-   = help: Consider using `.get(..n)`or `.get_mut(..n)` instead
+   = help: consider using `.get(..n)`or `.get_mut(..n)` instead
 
-error: slicing may panic.
+error: slicing may panic
   --> $DIR/indexing_slicing_slice.rs:18:6
    |
 LL |     &x[1..][..5];
    |      ^^^^^^^^^^^
    |
-   = help: Consider using `.get(..n)`or `.get_mut(..n)` instead
+   = help: consider using `.get(..n)`or `.get_mut(..n)` instead
 
 error: range is out of bounds
   --> $DIR/indexing_slicing_slice.rs:25:12
@@ -83,21 +83,21 @@ error: range is out of bounds
 LL |     &y[..=4];
    |           ^
 
-error: slicing may panic.
+error: slicing may panic
   --> $DIR/indexing_slicing_slice.rs:31:6
    |
 LL |     &v[10..100];
    |      ^^^^^^^^^^
    |
-   = help: Consider using `.get(n..m)` or `.get_mut(n..m)` instead
+   = help: consider using `.get(n..m)` or `.get_mut(n..m)` instead
 
-error: slicing may panic.
+error: slicing may panic
   --> $DIR/indexing_slicing_slice.rs:32:6
    |
 LL |     &x[10..][..100]; // Two lint reports, one for [10..] and another for [..100].
    |      ^^^^^^^^^^^^^^
    |
-   = help: Consider using `.get(..n)`or `.get_mut(..n)` instead
+   = help: consider using `.get(..n)`or `.get_mut(..n)` instead
 
 error: range is out of bounds
   --> $DIR/indexing_slicing_slice.rs:32:8
@@ -105,21 +105,21 @@ error: range is out of bounds
 LL |     &x[10..][..100]; // Two lint reports, one for [10..] and another for [..100].
    |        ^^
 
-error: slicing may panic.
+error: slicing may panic
   --> $DIR/indexing_slicing_slice.rs:33:6
    |
 LL |     &v[10..];
    |      ^^^^^^^
    |
-   = help: Consider using `.get(n..)` or .get_mut(n..)` instead
+   = help: consider using `.get(n..)` or .get_mut(n..)` instead
 
-error: slicing may panic.
+error: slicing may panic
   --> $DIR/indexing_slicing_slice.rs:34:6
    |
 LL |     &v[..100];
    |      ^^^^^^^^
    |
-   = help: Consider using `.get(..n)`or `.get_mut(..n)` instead
+   = help: consider using `.get(..n)`or `.get_mut(..n)` instead
 
 error: aborting due to 16 previous errors
 
diff --git a/tests/ui/integer_division.stderr b/tests/ui/integer_division.stderr
index 72a232ef3d7..cbb7f881424 100644
--- a/tests/ui/integer_division.stderr
+++ b/tests/ui/integer_division.stderr
@@ -5,7 +5,7 @@ LL |     let n = 1 / 2;
    |             ^^^^^
    |
    = note: `-D clippy::integer-division` implied by `-D warnings`
-   = help: division of integers may cause loss of precision. consider using floats.
+   = help: division of integers may cause loss of precision. consider using floats
 
 error: integer division
   --> $DIR/integer_division.rs:6:13
@@ -13,7 +13,7 @@ error: integer division
 LL |     let o = 1 / two;
    |             ^^^^^^^
    |
-   = help: division of integers may cause loss of precision. consider using floats.
+   = help: division of integers may cause loss of precision. consider using floats
 
 error: integer division
   --> $DIR/integer_division.rs:7:13
@@ -21,7 +21,7 @@ error: integer division
 LL |     let p = two / 4;
    |             ^^^^^^^
    |
-   = help: division of integers may cause loss of precision. consider using floats.
+   = help: division of integers may cause loss of precision. consider using floats
 
 error: aborting due to 3 previous errors
 
diff --git a/tests/ui/methods.stderr b/tests/ui/methods.stderr
index 33aba630a53..4643e09e270 100644
--- a/tests/ui/methods.stderr
+++ b/tests/ui/methods.stderr
@@ -8,7 +8,7 @@ LL | |     }
    |
    = note: `-D clippy::new-ret-no-self` implied by `-D warnings`
 
-error: called `filter(..).next()` on an `Iterator`. This is more succinctly expressed by calling `.find(..)` instead.
+error: called `filter(..).next()` on an `Iterator`. This is more succinctly expressed by calling `.find(..)` instead
   --> $DIR/methods.rs:126:13
    |
 LL |       let _ = v.iter().filter(|&x| {
diff --git a/tests/ui/methods_fixable.stderr b/tests/ui/methods_fixable.stderr
index 70e7c3dea54..852f48e32d6 100644
--- a/tests/ui/methods_fixable.stderr
+++ b/tests/ui/methods_fixable.stderr
@@ -1,4 +1,4 @@
-error: called `filter(..).next()` on an `Iterator`. This is more succinctly expressed by calling `.find(..)` instead.
+error: called `filter(..).next()` on an `Iterator`. This is more succinctly expressed by calling `.find(..)` instead
   --> $DIR/methods_fixable.rs:10:13
    |
 LL |     let _ = v.iter().filter(|&x| *x < 0).next();
diff --git a/tests/ui/mismatched_target_os_unix.stderr b/tests/ui/mismatched_target_os_unix.stderr
index fe9aeedb59c..ea39f5b5577 100644
--- a/tests/ui/mismatched_target_os_unix.stderr
+++ b/tests/ui/mismatched_target_os_unix.stderr
@@ -7,7 +7,7 @@ LL | #[cfg(linux)]
    |       help: try: `target_os = "linux"`
    |
    = note: `-D clippy::mismatched-target-os` implied by `-D warnings`
-   = help: Did you mean `unix`?
+   = help: did you mean `unix`?
 
 error: operating system used in target family position
   --> $DIR/mismatched_target_os_unix.rs:9:1
@@ -17,7 +17,7 @@ LL | #[cfg(freebsd)]
    |       |
    |       help: try: `target_os = "freebsd"`
    |
-   = help: Did you mean `unix`?
+   = help: did you mean `unix`?
 
 error: operating system used in target family position
   --> $DIR/mismatched_target_os_unix.rs:12:1
@@ -27,7 +27,7 @@ LL | #[cfg(dragonfly)]
    |       |
    |       help: try: `target_os = "dragonfly"`
    |
-   = help: Did you mean `unix`?
+   = help: did you mean `unix`?
 
 error: operating system used in target family position
   --> $DIR/mismatched_target_os_unix.rs:15:1
@@ -37,7 +37,7 @@ LL | #[cfg(openbsd)]
    |       |
    |       help: try: `target_os = "openbsd"`
    |
-   = help: Did you mean `unix`?
+   = help: did you mean `unix`?
 
 error: operating system used in target family position
   --> $DIR/mismatched_target_os_unix.rs:18:1
@@ -47,7 +47,7 @@ LL | #[cfg(netbsd)]
    |       |
    |       help: try: `target_os = "netbsd"`
    |
-   = help: Did you mean `unix`?
+   = help: did you mean `unix`?
 
 error: operating system used in target family position
   --> $DIR/mismatched_target_os_unix.rs:21:1
@@ -57,7 +57,7 @@ LL | #[cfg(macos)]
    |       |
    |       help: try: `target_os = "macos"`
    |
-   = help: Did you mean `unix`?
+   = help: did you mean `unix`?
 
 error: operating system used in target family position
   --> $DIR/mismatched_target_os_unix.rs:24:1
@@ -67,7 +67,7 @@ LL | #[cfg(ios)]
    |       |
    |       help: try: `target_os = "ios"`
    |
-   = help: Did you mean `unix`?
+   = help: did you mean `unix`?
 
 error: operating system used in target family position
   --> $DIR/mismatched_target_os_unix.rs:27:1
@@ -77,7 +77,7 @@ LL | #[cfg(android)]
    |       |
    |       help: try: `target_os = "android"`
    |
-   = help: Did you mean `unix`?
+   = help: did you mean `unix`?
 
 error: operating system used in target family position
   --> $DIR/mismatched_target_os_unix.rs:30:1
@@ -87,7 +87,7 @@ LL | #[cfg(emscripten)]
    |       |
    |       help: try: `target_os = "emscripten"`
    |
-   = help: Did you mean `unix`?
+   = help: did you mean `unix`?
 
 error: operating system used in target family position
   --> $DIR/mismatched_target_os_unix.rs:33:1
@@ -97,7 +97,7 @@ LL | #[cfg(fuchsia)]
    |       |
    |       help: try: `target_os = "fuchsia"`
    |
-   = help: Did you mean `unix`?
+   = help: did you mean `unix`?
 
 error: operating system used in target family position
   --> $DIR/mismatched_target_os_unix.rs:36:1
@@ -107,7 +107,7 @@ LL | #[cfg(haiku)]
    |       |
    |       help: try: `target_os = "haiku"`
    |
-   = help: Did you mean `unix`?
+   = help: did you mean `unix`?
 
 error: operating system used in target family position
   --> $DIR/mismatched_target_os_unix.rs:39:1
@@ -117,7 +117,7 @@ LL | #[cfg(illumos)]
    |       |
    |       help: try: `target_os = "illumos"`
    |
-   = help: Did you mean `unix`?
+   = help: did you mean `unix`?
 
 error: operating system used in target family position
   --> $DIR/mismatched_target_os_unix.rs:42:1
@@ -127,7 +127,7 @@ LL | #[cfg(l4re)]
    |       |
    |       help: try: `target_os = "l4re"`
    |
-   = help: Did you mean `unix`?
+   = help: did you mean `unix`?
 
 error: operating system used in target family position
   --> $DIR/mismatched_target_os_unix.rs:45:1
@@ -137,7 +137,7 @@ LL | #[cfg(redox)]
    |       |
    |       help: try: `target_os = "redox"`
    |
-   = help: Did you mean `unix`?
+   = help: did you mean `unix`?
 
 error: operating system used in target family position
   --> $DIR/mismatched_target_os_unix.rs:48:1
@@ -147,7 +147,7 @@ LL | #[cfg(solaris)]
    |       |
    |       help: try: `target_os = "solaris"`
    |
-   = help: Did you mean `unix`?
+   = help: did you mean `unix`?
 
 error: operating system used in target family position
   --> $DIR/mismatched_target_os_unix.rs:51:1
@@ -157,7 +157,7 @@ LL | #[cfg(vxworks)]
    |       |
    |       help: try: `target_os = "vxworks"`
    |
-   = help: Did you mean `unix`?
+   = help: did you mean `unix`?
 
 error: operating system used in target family position
   --> $DIR/mismatched_target_os_unix.rs:55:1
@@ -165,7 +165,7 @@ error: operating system used in target family position
 LL | #[cfg(all(not(any(solaris, linux)), freebsd))]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: Did you mean `unix`?
+   = help: did you mean `unix`?
 help: try
    |
 LL | #[cfg(all(not(any(target_os = "solaris", linux)), freebsd))]
diff --git a/tests/ui/needless_collect_indirect.stderr b/tests/ui/needless_collect_indirect.stderr
index fb807da5f8a..76e789d9052 100644
--- a/tests/ui/needless_collect_indirect.stderr
+++ b/tests/ui/needless_collect_indirect.stderr
@@ -6,7 +6,7 @@ LL | |     indirect_iter.into_iter().map(|x| (x, x + 1)).collect::<HashMap<_, _>
    | |____^
    |
    = note: `-D clippy::needless-collect` implied by `-D warnings`
-help: Use the original Iterator instead of collecting it and then producing a new one
+help: use the original Iterator instead of collecting it and then producing a new one
    |
 LL |     
 LL |     sample.iter().map(|x| (x, x + 1)).collect::<HashMap<_, _>>();
@@ -19,7 +19,7 @@ LL | /     let indirect_len = sample.iter().collect::<VecDeque<_>>();
 LL | |     indirect_len.len();
    | |____^
    |
-help: Take the original Iterator's count instead of collecting it and finding the length
+help: take the original Iterator's count instead of collecting it and finding the length
    |
 LL |     
 LL |     sample.iter().count();
@@ -32,7 +32,7 @@ LL | /     let indirect_empty = sample.iter().collect::<VecDeque<_>>();
 LL | |     indirect_empty.is_empty();
    | |____^
    |
-help: Check if the original Iterator has anything instead of collecting it and seeing if it's empty
+help: check if the original Iterator has anything instead of collecting it and seeing if it's empty
    |
 LL |     
 LL |     sample.iter().next().is_none();
@@ -45,7 +45,7 @@ LL | /     let indirect_contains = sample.iter().collect::<VecDeque<_>>();
 LL | |     indirect_contains.contains(&&5);
    | |____^
    |
-help: Check if the original Iterator contains an element instead of collecting then checking
+help: check if the original Iterator contains an element instead of collecting then checking
    |
 LL |     
 LL |     sample.iter().any(|x| x == &5);
@@ -58,7 +58,7 @@ LL | /     let non_copy_contains = sample.into_iter().collect::<Vec<_>>();
 LL | |     non_copy_contains.contains(&a);
    | |____^
    |
-help: Check if the original Iterator contains an element instead of collecting then checking
+help: check if the original Iterator contains an element instead of collecting then checking
    |
 LL |     
 LL |     sample.into_iter().any(|x| x == a);
diff --git a/tests/ui/needless_question_mark.stderr b/tests/ui/needless_question_mark.stderr
index 567bc518a3f..983c56031d8 100644
--- a/tests/ui/needless_question_mark.stderr
+++ b/tests/ui/needless_question_mark.stderr
@@ -1,4 +1,4 @@
-error: Question mark operator is useless here
+error: question mark operator is useless here
   --> $DIR/needless_question_mark.rs:23:12
    |
 LL |     return Some(to.magic?);
@@ -6,79 +6,79 @@ LL |     return Some(to.magic?);
    |
    = note: `-D clippy::needless-question-mark` implied by `-D warnings`
 
-error: Question mark operator is useless here
+error: question mark operator is useless here
   --> $DIR/needless_question_mark.rs:31:12
    |
 LL |     return Some(to.magic?)
    |            ^^^^^^^^^^^^^^^ help: try: `to.magic`
 
-error: Question mark operator is useless here
+error: question mark operator is useless here
   --> $DIR/needless_question_mark.rs:36:5
    |
 LL |     Some(to.magic?)
    |     ^^^^^^^^^^^^^^^ help: try: `to.magic`
 
-error: Question mark operator is useless here
+error: question mark operator is useless here
   --> $DIR/needless_question_mark.rs:41:21
    |
 LL |     to.and_then(|t| Some(t.magic?))
    |                     ^^^^^^^^^^^^^^ help: try: `t.magic`
 
-error: Question mark operator is useless here
+error: question mark operator is useless here
   --> $DIR/needless_question_mark.rs:50:9
    |
 LL |         Some(t.magic?)
    |         ^^^^^^^^^^^^^^ help: try: `t.magic`
 
-error: Question mark operator is useless here
+error: question mark operator is useless here
   --> $DIR/needless_question_mark.rs:55:12
    |
 LL |     return Ok(tr.magic?);
    |            ^^^^^^^^^^^^^ help: try: `tr.magic`
 
-error: Question mark operator is useless here
+error: question mark operator is useless here
   --> $DIR/needless_question_mark.rs:62:12
    |
 LL |     return Ok(tr.magic?)
    |            ^^^^^^^^^^^^^ help: try: `tr.magic`
 
-error: Question mark operator is useless here
+error: question mark operator is useless here
   --> $DIR/needless_question_mark.rs:66:5
    |
 LL |     Ok(tr.magic?)
    |     ^^^^^^^^^^^^^ help: try: `tr.magic`
 
-error: Question mark operator is useless here
+error: question mark operator is useless here
   --> $DIR/needless_question_mark.rs:70:21
    |
 LL |     tr.and_then(|t| Ok(t.magic?))
    |                     ^^^^^^^^^^^^ help: try: `t.magic`
 
-error: Question mark operator is useless here
+error: question mark operator is useless here
   --> $DIR/needless_question_mark.rs:78:9
    |
 LL |         Ok(t.magic?)
    |         ^^^^^^^^^^^^ help: try: `t.magic`
 
-error: Question mark operator is useless here
+error: question mark operator is useless here
   --> $DIR/needless_question_mark.rs:85:16
    |
 LL |         return Ok(t.magic?);
    |                ^^^^^^^^^^^^ help: try: `t.magic`
 
-error: Question mark operator is useless here
+error: question mark operator is useless here
   --> $DIR/needless_question_mark.rs:138:9
    |
 LL |         Ok(to.magic?) // should be triggered
    |         ^^^^^^^^^^^^^ help: try: `to.magic`
 
-error: Question mark operator is useless here
+error: question mark operator is useless here
   --> $DIR/needless_question_mark.rs:154:9
    |
 LL |         Some(to.magic?) // should be triggered
    |         ^^^^^^^^^^^^^^^ help: try: `to.magic`
 
-error: Question mark operator is useless here
+error: question mark operator is useless here
   --> $DIR/needless_question_mark.rs:162:9
    |
 LL |         Ok(to.magic?) // should be triggered
diff --git a/tests/ui/needless_range_loop.stderr b/tests/ui/needless_range_loop.stderr
index c50c4931fb4..c898cd64a93 100644
--- a/tests/ui/needless_range_loop.stderr
+++ b/tests/ui/needless_range_loop.stderr
@@ -1,4 +1,4 @@
-error: the loop variable `i` is only used to index `vec`.
+error: the loop variable `i` is only used to index `vec`
   --> $DIR/needless_range_loop.rs:10:14
    |
 LL |     for i in 0..vec.len() {
@@ -10,7 +10,7 @@ help: consider using an iterator
 LL |     for <item> in &vec {
    |         ^^^^^^    ^^^^
 
-error: the loop variable `i` is only used to index `vec`.
+error: the loop variable `i` is only used to index `vec`
   --> $DIR/needless_range_loop.rs:19:14
    |
 LL |     for i in 0..vec.len() {
@@ -21,7 +21,7 @@ help: consider using an iterator
 LL |     for <item> in &vec {
    |         ^^^^^^    ^^^^
 
-error: the loop variable `j` is only used to index `STATIC`.
+error: the loop variable `j` is only used to index `STATIC`
   --> $DIR/needless_range_loop.rs:24:14
    |
 LL |     for j in 0..4 {
@@ -32,7 +32,7 @@ help: consider using an iterator
 LL |     for <item> in &STATIC {
    |         ^^^^^^    ^^^^^^^
 
-error: the loop variable `j` is only used to index `CONST`.
+error: the loop variable `j` is only used to index `CONST`
   --> $DIR/needless_range_loop.rs:28:14
    |
 LL |     for j in 0..4 {
@@ -54,7 +54,7 @@ help: consider using an iterator
 LL |     for (i, <item>) in vec.iter().enumerate() {
    |         ^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^^^^
 
-error: the loop variable `i` is only used to index `vec2`.
+error: the loop variable `i` is only used to index `vec2`
   --> $DIR/needless_range_loop.rs:40:14
    |
 LL |     for i in 0..vec.len() {
@@ -65,7 +65,7 @@ help: consider using an iterator
 LL |     for <item> in vec2.iter().take(vec.len()) {
    |         ^^^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: the loop variable `i` is only used to index `vec`.
+error: the loop variable `i` is only used to index `vec`
   --> $DIR/needless_range_loop.rs:44:14
    |
 LL |     for i in 5..vec.len() {
@@ -76,7 +76,7 @@ help: consider using an iterator
 LL |     for <item> in vec.iter().skip(5) {
    |         ^^^^^^    ^^^^^^^^^^^^^^^^^^
 
-error: the loop variable `i` is only used to index `vec`.
+error: the loop variable `i` is only used to index `vec`
   --> $DIR/needless_range_loop.rs:48:14
    |
 LL |     for i in 0..MAX_LEN {
@@ -87,7 +87,7 @@ help: consider using an iterator
 LL |     for <item> in vec.iter().take(MAX_LEN) {
    |         ^^^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: the loop variable `i` is only used to index `vec`.
+error: the loop variable `i` is only used to index `vec`
   --> $DIR/needless_range_loop.rs:52:14
    |
 LL |     for i in 0..=MAX_LEN {
@@ -98,7 +98,7 @@ help: consider using an iterator
 LL |     for <item> in vec.iter().take(MAX_LEN + 1) {
    |         ^^^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: the loop variable `i` is only used to index `vec`.
+error: the loop variable `i` is only used to index `vec`
   --> $DIR/needless_range_loop.rs:56:14
    |
 LL |     for i in 5..10 {
@@ -109,7 +109,7 @@ help: consider using an iterator
 LL |     for <item> in vec.iter().take(10).skip(5) {
    |         ^^^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: the loop variable `i` is only used to index `vec`.
+error: the loop variable `i` is only used to index `vec`
   --> $DIR/needless_range_loop.rs:60:14
    |
 LL |     for i in 5..=10 {
diff --git a/tests/ui/needless_range_loop2.stderr b/tests/ui/needless_range_loop2.stderr
index c54ab5ec980..2e1f0fd0299 100644
--- a/tests/ui/needless_range_loop2.stderr
+++ b/tests/ui/needless_range_loop2.stderr
@@ -1,4 +1,4 @@
-error: the loop variable `i` is only used to index `ns`.
+error: the loop variable `i` is only used to index `ns`
   --> $DIR/needless_range_loop2.rs:10:14
    |
 LL |     for i in 3..10 {
@@ -10,7 +10,7 @@ help: consider using an iterator
 LL |     for <item> in ns.iter().take(10).skip(3) {
    |         ^^^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: the loop variable `i` is only used to index `ms`.
+error: the loop variable `i` is only used to index `ms`
   --> $DIR/needless_range_loop2.rs:31:14
    |
 LL |     for i in 0..ms.len() {
@@ -21,7 +21,7 @@ help: consider using an iterator
 LL |     for <item> in &mut ms {
    |         ^^^^^^    ^^^^^^^
 
-error: the loop variable `i` is only used to index `ms`.
+error: the loop variable `i` is only used to index `ms`
   --> $DIR/needless_range_loop2.rs:37:14
    |
 LL |     for i in 0..ms.len() {
@@ -32,7 +32,7 @@ help: consider using an iterator
 LL |     for <item> in &mut ms {
    |         ^^^^^^    ^^^^^^^
 
-error: the loop variable `i` is only used to index `vec`.
+error: the loop variable `i` is only used to index `vec`
   --> $DIR/needless_range_loop2.rs:61:14
    |
 LL |     for i in x..x + 4 {
@@ -43,7 +43,7 @@ help: consider using an iterator
 LL |     for <item> in vec.iter_mut().skip(x).take(4) {
    |         ^^^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: the loop variable `i` is only used to index `vec`.
+error: the loop variable `i` is only used to index `vec`
   --> $DIR/needless_range_loop2.rs:68:14
    |
 LL |     for i in x..=x + 4 {
@@ -54,7 +54,7 @@ help: consider using an iterator
 LL |     for <item> in vec.iter_mut().skip(x).take(4 + 1) {
    |         ^^^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: the loop variable `i` is only used to index `arr`.
+error: the loop variable `i` is only used to index `arr`
   --> $DIR/needless_range_loop2.rs:74:14
    |
 LL |     for i in 0..3 {
@@ -65,7 +65,7 @@ help: consider using an iterator
 LL |     for <item> in &arr {
    |         ^^^^^^    ^^^^
 
-error: the loop variable `i` is only used to index `arr`.
+error: the loop variable `i` is only used to index `arr`
   --> $DIR/needless_range_loop2.rs:78:14
    |
 LL |     for i in 0..2 {
@@ -76,7 +76,7 @@ help: consider using an iterator
 LL |     for <item> in arr.iter().take(2) {
    |         ^^^^^^    ^^^^^^^^^^^^^^^^^^
 
-error: the loop variable `i` is only used to index `arr`.
+error: the loop variable `i` is only used to index `arr`
   --> $DIR/needless_range_loop2.rs:82:14
    |
 LL |     for i in 1..3 {
diff --git a/tests/ui/ptr_arg.stderr b/tests/ui/ptr_arg.stderr
index 708318bbe29..d302b16d4b7 100644
--- a/tests/ui/ptr_arg.stderr
+++ b/tests/ui/ptr_arg.stderr
@@ -1,4 +1,4 @@
-error: writing `&Vec<_>` instead of `&[_]` involves one more reference and cannot be used with non-Vec-based slices.
+error: writing `&Vec<_>` instead of `&[_]` involves one more reference and cannot be used with non-Vec-based slices
   --> $DIR/ptr_arg.rs:7:14
    |
 LL | fn do_vec(x: &Vec<i64>) {
@@ -6,25 +6,25 @@ LL | fn do_vec(x: &Vec<i64>) {
    |
    = note: `-D clippy::ptr-arg` implied by `-D warnings`
 
-error: writing `&String` instead of `&str` involves a new object where a slice will do.
+error: writing `&String` instead of `&str` involves a new object where a slice will do
   --> $DIR/ptr_arg.rs:16:14
    |
 LL | fn do_str(x: &String) {
    |              ^^^^^^^ help: change this to: `&str`
 
-error: writing `&PathBuf` instead of `&Path` involves a new object where a slice will do.
+error: writing `&PathBuf` instead of `&Path` involves a new object where a slice will do
   --> $DIR/ptr_arg.rs:25:15
    |
 LL | fn do_path(x: &PathBuf) {
    |               ^^^^^^^^ help: change this to: `&Path`
 
-error: writing `&Vec<_>` instead of `&[_]` involves one more reference and cannot be used with non-Vec-based slices.
+error: writing `&Vec<_>` instead of `&[_]` involves one more reference and cannot be used with non-Vec-based slices
   --> $DIR/ptr_arg.rs:38:18
    |
 LL |     fn do_vec(x: &Vec<i64>);
    |                  ^^^^^^^^^ help: change this to: `&[i64]`
 
-error: writing `&Vec<_>` instead of `&[_]` involves one more reference and cannot be used with non-Vec-based slices.
+error: writing `&Vec<_>` instead of `&[_]` involves one more reference and cannot be used with non-Vec-based slices
   --> $DIR/ptr_arg.rs:51:14
    |
 LL | fn cloned(x: &Vec<u8>) -> Vec<u8> {
@@ -43,7 +43,7 @@ help: change `x.clone()` to
 LL |     x.to_owned()
    |
 
-error: writing `&String` instead of `&str` involves a new object where a slice will do.
+error: writing `&String` instead of `&str` involves a new object where a slice will do
   --> $DIR/ptr_arg.rs:60:18
    |
 LL | fn str_cloned(x: &String) -> String {
@@ -66,7 +66,7 @@ help: change `x.clone()` to
 LL |     x.to_string()
    |
 
-error: writing `&PathBuf` instead of `&Path` involves a new object where a slice will do.
+error: writing `&PathBuf` instead of `&Path` involves a new object where a slice will do
   --> $DIR/ptr_arg.rs:68:19
    |
 LL | fn path_cloned(x: &PathBuf) -> PathBuf {
@@ -89,7 +89,7 @@ help: change `x.clone()` to
 LL |     x.to_path_buf()
    |
 
-error: writing `&String` instead of `&str` involves a new object where a slice will do.
+error: writing `&String` instead of `&str` involves a new object where a slice will do
   --> $DIR/ptr_arg.rs:76:44
    |
 LL | fn false_positive_capacity(x: &Vec<u8>, y: &String) {
@@ -108,13 +108,13 @@ help: change `y.as_str()` to
 LL |     let c = y;
    |             ^
 
-error: using a reference to `Cow` is not recommended.
+error: using a reference to `Cow` is not recommended
   --> $DIR/ptr_arg.rs:90:25
    |
 LL | fn test_cow_with_ref(c: &Cow<[i32]>) {}
    |                         ^^^^^^^^^^^ help: change this to: `&[i32]`
 
-error: writing `&Vec<_>` instead of `&[_]` involves one more reference and cannot be used with non-Vec-based slices.
+error: writing `&Vec<_>` instead of `&[_]` involves one more reference and cannot be used with non-Vec-based slices
   --> $DIR/ptr_arg.rs:143:21
    |
 LL |     fn foo_vec(vec: &Vec<u8>) {
@@ -133,7 +133,7 @@ help: change `vec.clone()` to
 LL |         let _ = vec.to_owned().clone();
    |                 ^^^^^^^^^^^^^^
 
-error: writing `&PathBuf` instead of `&Path` involves a new object where a slice will do.
+error: writing `&PathBuf` instead of `&Path` involves a new object where a slice will do
   --> $DIR/ptr_arg.rs:148:23
    |
 LL |     fn foo_path(path: &PathBuf) {
@@ -152,7 +152,7 @@ help: change `path.clone()` to
 LL |         let _ = path.to_path_buf().clone();
    |                 ^^^^^^^^^^^^^^^^^^
 
-error: writing `&PathBuf` instead of `&Path` involves a new object where a slice will do.
+error: writing `&PathBuf` instead of `&Path` involves a new object where a slice will do
   --> $DIR/ptr_arg.rs:153:21
    |
 LL |     fn foo_str(str: &PathBuf) {
diff --git a/tests/ui/suspicious_operation_groupings.stderr b/tests/ui/suspicious_operation_groupings.stderr
index ce7108217f1..2da05399575 100644
--- a/tests/ui/suspicious_operation_groupings.stderr
+++ b/tests/ui/suspicious_operation_groupings.stderr
@@ -1,4 +1,4 @@
-error: This sequence of operators looks suspiciously like a bug.
+error: this sequence of operators looks suspiciously like a bug
   --> $DIR/suspicious_operation_groupings.rs:14:9
    |
 LL |         self.x == other.y && self.y == other.y && self.z == other.z
@@ -6,157 +6,157 @@ LL |         self.x == other.y && self.y == other.y && self.z == other.z
    |
    = note: `-D clippy::suspicious-operation-groupings` implied by `-D warnings`
 
-error: This sequence of operators looks suspiciously like a bug.
+error: this sequence of operators looks suspiciously like a bug
   --> $DIR/suspicious_operation_groupings.rs:14:9
    |
 LL |         self.x == other.y && self.y == other.y && self.z == other.z
    |         ^^^^^^^^^^^^^^^^^ help: I think you meant: `self.x == other.x`
 
-error: This sequence of operators looks suspiciously like a bug.
+error: this sequence of operators looks suspiciously like a bug
   --> $DIR/suspicious_operation_groupings.rs:27:20
    |
 LL |     s1.a < s2.a && s1.a < s2.b
    |                    ^^^^^^^^^^^ help: I think you meant: `s1.b < s2.b`
 
-error: This sequence of operators looks suspiciously like a bug.
+error: this sequence of operators looks suspiciously like a bug
   --> $DIR/suspicious_operation_groupings.rs:75:33
    |
 LL |     s1.a * s2.a + s1.b * s2.b + s1.c * s2.b + s1.d * s2.d
    |                                 ^^^^^^^^^^^ help: I think you meant: `s1.c * s2.c`
 
-error: This sequence of operators looks suspiciously like a bug.
+error: this sequence of operators looks suspiciously like a bug
   --> $DIR/suspicious_operation_groupings.rs:80:19
    |
 LL |     s1.a * s2.a + s1.b * s2.c + s1.c * s2.c
    |                   ^^^^^^^^^^^ help: I think you meant: `s1.b * s2.b`
 
-error: This sequence of operators looks suspiciously like a bug.
+error: this sequence of operators looks suspiciously like a bug
   --> $DIR/suspicious_operation_groupings.rs:80:19
    |
 LL |     s1.a * s2.a + s1.b * s2.c + s1.c * s2.c
    |                   ^^^^^^^^^^^ help: I think you meant: `s1.b * s2.b`
 
-error: This sequence of operators looks suspiciously like a bug.
+error: this sequence of operators looks suspiciously like a bug
   --> $DIR/suspicious_operation_groupings.rs:85:19
    |
 LL |     s1.a * s2.a + s2.b * s2.b + s1.c * s2.c
    |                   ^^^^^^^^^^^ help: I think you meant: `s1.b * s2.b`
 
-error: This sequence of operators looks suspiciously like a bug.
+error: this sequence of operators looks suspiciously like a bug
   --> $DIR/suspicious_operation_groupings.rs:90:19
    |
 LL |     s1.a * s2.a + s1.b * s1.b + s1.c * s2.c
    |                   ^^^^^^^^^^^ help: I think you meant: `s1.b * s2.b`
 
-error: This sequence of operators looks suspiciously like a bug.
+error: this sequence of operators looks suspiciously like a bug
   --> $DIR/suspicious_operation_groupings.rs:95:5
    |
 LL |     s1.a * s1.a + s1.b * s2.b + s1.c * s2.c
    |     ^^^^^^^^^^^ help: I think you meant: `s1.a * s2.a`
 
-error: This sequence of operators looks suspiciously like a bug.
+error: this sequence of operators looks suspiciously like a bug
   --> $DIR/suspicious_operation_groupings.rs:100:33
    |
 LL |     s1.a * s2.a + s1.b * s2.b + s1.c * s1.c
    |                                 ^^^^^^^^^^^ help: I think you meant: `s1.c * s2.c`
 
-error: This sequence of operators looks suspiciously like a bug.
+error: this sequence of operators looks suspiciously like a bug
   --> $DIR/suspicious_operation_groupings.rs:113:20
    |
 LL |     (s1.a * s2.a + s1.b * s1.b)
    |                    ^^^^^^^^^^^ help: I think you meant: `s1.b * s2.b`
 
-error: This sequence of operators looks suspiciously like a bug.
+error: this sequence of operators looks suspiciously like a bug
   --> $DIR/suspicious_operation_groupings.rs:118:34
    |
 LL |     (s1.a * s2.a + s1.b * s2.b + s1.c * s2.b + s1.d * s2.d)
    |                                  ^^^^^^^^^^^ help: I think you meant: `s1.c * s2.c`
 
-error: This sequence of operators looks suspiciously like a bug.
+error: this sequence of operators looks suspiciously like a bug
   --> $DIR/suspicious_operation_groupings.rs:123:38
    |
 LL |     (s1.a * s2.a) + (s1.b * s2.b) + (s1.c * s2.b) + (s1.d * s2.d)
    |                                      ^^^^^^^^^^^ help: I think you meant: `s1.c * s2.c`
 
-error: This sequence of operators looks suspiciously like a bug.
+error: this sequence of operators looks suspiciously like a bug
   --> $DIR/suspicious_operation_groupings.rs:128:39
    |
 LL |     ((s1.a * s2.a) + (s1.b * s2.b) + (s1.c * s2.b) + (s1.d * s2.d))
    |                                       ^^^^^^^^^^^ help: I think you meant: `s1.c * s2.c`
 
-error: This sequence of operators looks suspiciously like a bug.
+error: this sequence of operators looks suspiciously like a bug
   --> $DIR/suspicious_operation_groupings.rs:133:42
    |
 LL |     (((s1.a * s2.a) + (s1.b * s2.b)) + ((s1.c * s2.b) + (s1.d * s2.d)))
    |                                          ^^^^^^^^^^^ help: I think you meant: `s1.c * s2.c`
 
-error: This sequence of operators looks suspiciously like a bug.
+error: this sequence of operators looks suspiciously like a bug
   --> $DIR/suspicious_operation_groupings.rs:133:42
    |
 LL |     (((s1.a * s2.a) + (s1.b * s2.b)) + ((s1.c * s2.b) + (s1.d * s2.d)))
    |                                          ^^^^^^^^^^^ help: I think you meant: `s1.c * s2.c`
 
-error: This sequence of operators looks suspiciously like a bug.
+error: this sequence of operators looks suspiciously like a bug
   --> $DIR/suspicious_operation_groupings.rs:138:40
    |
 LL |     (((s1.a * s2.a) + (s1.b * s2.b) + (s1.c * s2.b)) + (s1.d * s2.d))
    |                                        ^^^^^^^^^^^ help: I think you meant: `s1.c * s2.c`
 
-error: This sequence of operators looks suspiciously like a bug.
+error: this sequence of operators looks suspiciously like a bug
   --> $DIR/suspicious_operation_groupings.rs:143:40
    |
 LL |     ((s1.a * s2.a) + ((s1.b * s2.b) + (s1.c * s2.b) + (s1.d * s2.d)))
    |                                        ^^^^^^^^^^^ help: I think you meant: `s1.c * s2.c`
 
-error: This sequence of operators looks suspiciously like a bug.
+error: this sequence of operators looks suspiciously like a bug
   --> $DIR/suspicious_operation_groupings.rs:148:20
    |
 LL |     (s1.a * s2.a + s2.b * s2.b) / 2
    |                    ^^^^^^^^^^^ help: I think you meant: `s1.b * s2.b`
 
-error: This sequence of operators looks suspiciously like a bug.
+error: this sequence of operators looks suspiciously like a bug
   --> $DIR/suspicious_operation_groupings.rs:153:35
    |
 LL |     i32::swap_bytes(s1.a * s2.a + s2.b * s2.b)
    |                                   ^^^^^^^^^^^ help: I think you meant: `s1.b * s2.b`
 
-error: This sequence of operators looks suspiciously like a bug.
+error: this sequence of operators looks suspiciously like a bug
   --> $DIR/suspicious_operation_groupings.rs:158:29
    |
 LL |     s1.a > 0 && s1.b > 0 && s1.d == s2.c && s1.d == s2.d
    |                             ^^^^^^^^^^^^ help: I think you meant: `s1.c == s2.c`
 
-error: This sequence of operators looks suspiciously like a bug.
+error: this sequence of operators looks suspiciously like a bug
   --> $DIR/suspicious_operation_groupings.rs:163:17
    |
 LL |     s1.a > 0 && s1.d == s2.c && s1.b > 0 && s1.d == s2.d
    |                 ^^^^^^^^^^^^ help: I think you meant: `s1.c == s2.c`
 
-error: This sequence of operators looks suspiciously like a bug.
+error: this sequence of operators looks suspiciously like a bug
   --> $DIR/suspicious_operation_groupings.rs:172:77
    |
 LL |     (n1.inner.0).0 == (n2.inner.0).0 && (n1.inner.1).0 == (n2.inner.1).0 && (n1.inner.2).0 == (n2.inner.1).0
    |                                                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: I think you meant: `(n1.inner.2).0 == (n2.inner.2).0`
 
-error: This sequence of operators looks suspiciously like a bug.
+error: this sequence of operators looks suspiciously like a bug
   --> $DIR/suspicious_operation_groupings.rs:186:25
    |
 LL |         s1.a <= s2.a && s1.a <= s2.b
    |                         ^^^^^^^^^^^^ help: I think you meant: `s1.b <= s2.b`
 
-error: This sequence of operators looks suspiciously like a bug.
+error: this sequence of operators looks suspiciously like a bug
   --> $DIR/suspicious_operation_groupings.rs:192:23
    |
 LL |     if s1.a < s2.a && s1.a < s2.b {
    |                       ^^^^^^^^^^^ help: I think you meant: `s1.b < s2.b`
 
-error: This sequence of operators looks suspiciously like a bug.
+error: this sequence of operators looks suspiciously like a bug
   --> $DIR/suspicious_operation_groupings.rs:199:48
    |
 LL |     -(-(-s1.a * -s2.a) + (-(-s1.b * -s2.b) + -(-s1.c * -s2.b) + -(-s1.d * -s2.d)))
    |                                                ^^^^^^^^^^^^^ help: I think you meant: `-s1.c * -s2.c`
 
-error: This sequence of operators looks suspiciously like a bug.
+error: this sequence of operators looks suspiciously like a bug
   --> $DIR/suspicious_operation_groupings.rs:204:27
    |
 LL |     -(if -s1.a < -s2.a && -s1.a < -s2.b { s1.c } else { s2.a })
diff --git a/tests/ui/toplevel_ref_arg_non_rustfix.stderr b/tests/ui/toplevel_ref_arg_non_rustfix.stderr
index 6c36141a58c..b8cfd987394 100644
--- a/tests/ui/toplevel_ref_arg_non_rustfix.stderr
+++ b/tests/ui/toplevel_ref_arg_non_rustfix.stderr
@@ -1,4 +1,4 @@
-error: `ref` directly on a function argument is ignored. Consider using a reference type instead.
+error: `ref` directly on a function argument is ignored. Consider using a reference type instead
   --> $DIR/toplevel_ref_arg_non_rustfix.rs:9:15
    |
 LL | fn the_answer(ref mut x: u8) {
@@ -6,7 +6,7 @@ LL | fn the_answer(ref mut x: u8) {
    |
    = note: `-D clippy::toplevel-ref-arg` implied by `-D warnings`
 
-error: `ref` directly on a function argument is ignored. Consider using a reference type instead.
+error: `ref` directly on a function argument is ignored. Consider using a reference type instead
   --> $DIR/toplevel_ref_arg_non_rustfix.rs:15:24
    |
 LL |         fn fun_example(ref _x: usize) {}
diff --git a/tests/ui/transmuting_null.stderr b/tests/ui/transmuting_null.stderr
index 05f91ee2ada..1848fc2490a 100644
--- a/tests/ui/transmuting_null.stderr
+++ b/tests/ui/transmuting_null.stderr
@@ -1,4 +1,4 @@
-error: transmuting a known null pointer into a reference.
+error: transmuting a known null pointer into a reference
   --> $DIR/transmuting_null.rs:10:23
    |
 LL |         let _: &u64 = std::mem::transmute(0 as *const u64);
@@ -6,13 +6,13 @@ LL |         let _: &u64 = std::mem::transmute(0 as *const u64);
    |
    = note: `-D clippy::transmuting-null` implied by `-D warnings`
 
-error: transmuting a known null pointer into a reference.
+error: transmuting a known null pointer into a reference
   --> $DIR/transmuting_null.rs:11:23
    |
 LL |         let _: &u64 = std::mem::transmute(std::ptr::null::<u64>());
    |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: transmuting a known null pointer into a reference.
+error: transmuting a known null pointer into a reference
   --> $DIR/transmuting_null.rs:21:23
    |
 LL |         let _: &u64 = std::mem::transmute(ZPTR);
diff --git a/tests/ui/unnecessary_lazy_eval.stderr b/tests/ui/unnecessary_lazy_eval.stderr
index 44dcd0cafbb..cc94bd5cd9e 100644
--- a/tests/ui/unnecessary_lazy_eval.stderr
+++ b/tests/ui/unnecessary_lazy_eval.stderr
@@ -2,7 +2,7 @@ error: unnecessary closure used to substitute value for `Option::None`
   --> $DIR/unnecessary_lazy_eval.rs:35:13
    |
 LL |     let _ = opt.unwrap_or_else(|| 2);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `unwrap_or` instead: `opt.unwrap_or(2)`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^ help: use `unwrap_or` instead: `opt.unwrap_or(2)`
    |
    = note: `-D clippy::unnecessary-lazy-evaluations` implied by `-D warnings`
 
@@ -10,187 +10,187 @@ error: unnecessary closure used to substitute value for `Option::None`
   --> $DIR/unnecessary_lazy_eval.rs:36:13
    |
 LL |     let _ = opt.unwrap_or_else(|| astronomers_pi);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `unwrap_or` instead: `opt.unwrap_or(astronomers_pi)`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `unwrap_or` instead: `opt.unwrap_or(astronomers_pi)`
 
 error: unnecessary closure used to substitute value for `Option::None`
   --> $DIR/unnecessary_lazy_eval.rs:37:13
    |
 LL |     let _ = opt.unwrap_or_else(|| ext_str.some_field);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `unwrap_or` instead: `opt.unwrap_or(ext_str.some_field)`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `unwrap_or` instead: `opt.unwrap_or(ext_str.some_field)`
 
 error: unnecessary closure used to substitute value for `Option::None`
   --> $DIR/unnecessary_lazy_eval.rs:39:13
    |
 LL |     let _ = opt.and_then(|_| ext_opt);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `and` instead: `opt.and(ext_opt)`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `and` instead: `opt.and(ext_opt)`
 
 error: unnecessary closure used to substitute value for `Option::None`
   --> $DIR/unnecessary_lazy_eval.rs:40:13
    |
 LL |     let _ = opt.or_else(|| ext_opt);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^ help: Use `or` instead: `opt.or(ext_opt)`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^ help: use `or` instead: `opt.or(ext_opt)`
 
 error: unnecessary closure used to substitute value for `Option::None`
   --> $DIR/unnecessary_lazy_eval.rs:41:13
    |
 LL |     let _ = opt.or_else(|| None);
-   |             ^^^^^^^^^^^^^^^^^^^^ help: Use `or` instead: `opt.or(None)`
+   |             ^^^^^^^^^^^^^^^^^^^^ help: use `or` instead: `opt.or(None)`
 
 error: unnecessary closure used to substitute value for `Option::None`
   --> $DIR/unnecessary_lazy_eval.rs:42:13
    |
 LL |     let _ = opt.get_or_insert_with(|| 2);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `get_or_insert` instead: `opt.get_or_insert(2)`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `get_or_insert` instead: `opt.get_or_insert(2)`
 
 error: unnecessary closure used to substitute value for `Option::None`
   --> $DIR/unnecessary_lazy_eval.rs:43:13
    |
 LL |     let _ = opt.ok_or_else(|| 2);
-   |             ^^^^^^^^^^^^^^^^^^^^ help: Use `ok_or` instead: `opt.ok_or(2)`
+   |             ^^^^^^^^^^^^^^^^^^^^ help: use `ok_or` instead: `opt.ok_or(2)`
 
 error: unnecessary closure used to substitute value for `Option::None`
   --> $DIR/unnecessary_lazy_eval.rs:44:13
    |
 LL |     let _ = nested_tuple_opt.unwrap_or_else(|| Some((1, 2)));
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `unwrap_or` instead: `nested_tuple_opt.unwrap_or(Some((1, 2)))`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `unwrap_or` instead: `nested_tuple_opt.unwrap_or(Some((1, 2)))`
 
 error: unnecessary closure used to substitute value for `Option::None`
   --> $DIR/unnecessary_lazy_eval.rs:47:13
    |
 LL |     let _ = Some(10).unwrap_or_else(|| 2);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `unwrap_or` instead: `Some(10).unwrap_or(2)`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `unwrap_or` instead: `Some(10).unwrap_or(2)`
 
 error: unnecessary closure used to substitute value for `Option::None`
   --> $DIR/unnecessary_lazy_eval.rs:48:13
    |
 LL |     let _ = Some(10).and_then(|_| ext_opt);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `and` instead: `Some(10).and(ext_opt)`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `and` instead: `Some(10).and(ext_opt)`
 
 error: unnecessary closure used to substitute value for `Option::None`
   --> $DIR/unnecessary_lazy_eval.rs:49:28
    |
 LL |     let _: Option<usize> = None.or_else(|| ext_opt);
-   |                            ^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `or` instead: `None.or(ext_opt)`
+   |                            ^^^^^^^^^^^^^^^^^^^^^^^^ help: use `or` instead: `None.or(ext_opt)`
 
 error: unnecessary closure used to substitute value for `Option::None`
   --> $DIR/unnecessary_lazy_eval.rs:50:13
    |
 LL |     let _ = None.get_or_insert_with(|| 2);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `get_or_insert` instead: `None.get_or_insert(2)`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `get_or_insert` instead: `None.get_or_insert(2)`
 
 error: unnecessary closure used to substitute value for `Option::None`
   --> $DIR/unnecessary_lazy_eval.rs:51:35
    |
 LL |     let _: Result<usize, usize> = None.ok_or_else(|| 2);
-   |                                   ^^^^^^^^^^^^^^^^^^^^^ help: Use `ok_or` instead: `None.ok_or(2)`
+   |                                   ^^^^^^^^^^^^^^^^^^^^^ help: use `ok_or` instead: `None.ok_or(2)`
 
 error: unnecessary closure used to substitute value for `Option::None`
   --> $DIR/unnecessary_lazy_eval.rs:52:28
    |
 LL |     let _: Option<usize> = None.or_else(|| None);
-   |                            ^^^^^^^^^^^^^^^^^^^^^ help: Use `or` instead: `None.or(None)`
+   |                            ^^^^^^^^^^^^^^^^^^^^^ help: use `or` instead: `None.or(None)`
 
 error: unnecessary closure used to substitute value for `Option::None`
   --> $DIR/unnecessary_lazy_eval.rs:55:13
    |
 LL |     let _ = deep.0.unwrap_or_else(|| 2);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `unwrap_or` instead: `deep.0.unwrap_or(2)`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `unwrap_or` instead: `deep.0.unwrap_or(2)`
 
 error: unnecessary closure used to substitute value for `Option::None`
   --> $DIR/unnecessary_lazy_eval.rs:56:13
    |
 LL |     let _ = deep.0.and_then(|_| ext_opt);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `and` instead: `deep.0.and(ext_opt)`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `and` instead: `deep.0.and(ext_opt)`
 
 error: unnecessary closure used to substitute value for `Option::None`
   --> $DIR/unnecessary_lazy_eval.rs:57:13
    |
 LL |     let _ = deep.0.or_else(|| None);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^ help: Use `or` instead: `deep.0.or(None)`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^ help: use `or` instead: `deep.0.or(None)`
 
 error: unnecessary closure used to substitute value for `Option::None`
   --> $DIR/unnecessary_lazy_eval.rs:58:13
    |
 LL |     let _ = deep.0.get_or_insert_with(|| 2);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `get_or_insert` instead: `deep.0.get_or_insert(2)`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `get_or_insert` instead: `deep.0.get_or_insert(2)`
 
 error: unnecessary closure used to substitute value for `Option::None`
   --> $DIR/unnecessary_lazy_eval.rs:59:13
    |
 LL |     let _ = deep.0.ok_or_else(|| 2);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^ help: Use `ok_or` instead: `deep.0.ok_or(2)`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^ help: use `ok_or` instead: `deep.0.ok_or(2)`
 
 error: unnecessary closure used to substitute value for `Option::None`
   --> $DIR/unnecessary_lazy_eval.rs:79:28
    |
 LL |     let _: Option<usize> = None.or_else(|| Some(3));
-   |                            ^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `or` instead: `None.or(Some(3))`
+   |                            ^^^^^^^^^^^^^^^^^^^^^^^^ help: use `or` instead: `None.or(Some(3))`
 
 error: unnecessary closure used to substitute value for `Option::None`
   --> $DIR/unnecessary_lazy_eval.rs:80:13
    |
 LL |     let _ = deep.0.or_else(|| Some(3));
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `or` instead: `deep.0.or(Some(3))`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `or` instead: `deep.0.or(Some(3))`
 
 error: unnecessary closure used to substitute value for `Option::None`
   --> $DIR/unnecessary_lazy_eval.rs:81:13
    |
 LL |     let _ = opt.or_else(|| Some(3));
-   |             ^^^^^^^^^^^^^^^^^^^^^^^ help: Use `or` instead: `opt.or(Some(3))`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^ help: use `or` instead: `opt.or(Some(3))`
 
 error: unnecessary closure used to substitute value for `Result::Err`
   --> $DIR/unnecessary_lazy_eval.rs:87:13
    |
 LL |     let _ = res2.unwrap_or_else(|_| 2);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `unwrap_or` instead: `res2.unwrap_or(2)`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `unwrap_or` instead: `res2.unwrap_or(2)`
 
 error: unnecessary closure used to substitute value for `Result::Err`
   --> $DIR/unnecessary_lazy_eval.rs:88:13
    |
 LL |     let _ = res2.unwrap_or_else(|_| astronomers_pi);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `unwrap_or` instead: `res2.unwrap_or(astronomers_pi)`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `unwrap_or` instead: `res2.unwrap_or(astronomers_pi)`
 
 error: unnecessary closure used to substitute value for `Result::Err`
   --> $DIR/unnecessary_lazy_eval.rs:89:13
    |
 LL |     let _ = res2.unwrap_or_else(|_| ext_str.some_field);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `unwrap_or` instead: `res2.unwrap_or(ext_str.some_field)`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `unwrap_or` instead: `res2.unwrap_or(ext_str.some_field)`
 
 error: unnecessary closure used to substitute value for `Result::Err`
   --> $DIR/unnecessary_lazy_eval.rs:111:35
    |
 LL |     let _: Result<usize, usize> = res.and_then(|_| Err(2));
-   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `and` instead: `res.and(Err(2))`
+   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^ help: use `and` instead: `res.and(Err(2))`
 
 error: unnecessary closure used to substitute value for `Result::Err`
   --> $DIR/unnecessary_lazy_eval.rs:112:35
    |
 LL |     let _: Result<usize, usize> = res.and_then(|_| Err(astronomers_pi));
-   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `and` instead: `res.and(Err(astronomers_pi))`
+   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `and` instead: `res.and(Err(astronomers_pi))`
 
 error: unnecessary closure used to substitute value for `Result::Err`
   --> $DIR/unnecessary_lazy_eval.rs:113:35
    |
 LL |     let _: Result<usize, usize> = res.and_then(|_| Err(ext_str.some_field));
-   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `and` instead: `res.and(Err(ext_str.some_field))`
+   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `and` instead: `res.and(Err(ext_str.some_field))`
 
 error: unnecessary closure used to substitute value for `Result::Err`
   --> $DIR/unnecessary_lazy_eval.rs:115:35
    |
 LL |     let _: Result<usize, usize> = res.or_else(|_| Ok(2));
-   |                                   ^^^^^^^^^^^^^^^^^^^^^^ help: Use `or` instead: `res.or(Ok(2))`
+   |                                   ^^^^^^^^^^^^^^^^^^^^^^ help: use `or` instead: `res.or(Ok(2))`
 
 error: unnecessary closure used to substitute value for `Result::Err`
   --> $DIR/unnecessary_lazy_eval.rs:116:35
    |
 LL |     let _: Result<usize, usize> = res.or_else(|_| Ok(astronomers_pi));
-   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `or` instead: `res.or(Ok(astronomers_pi))`
+   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `or` instead: `res.or(Ok(astronomers_pi))`
 
 error: unnecessary closure used to substitute value for `Result::Err`
   --> $DIR/unnecessary_lazy_eval.rs:117:35
    |
 LL |     let _: Result<usize, usize> = res.or_else(|_| Ok(ext_str.some_field));
-   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `or` instead: `res.or(Ok(ext_str.some_field))`
+   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `or` instead: `res.or(Ok(ext_str.some_field))`
 
 error: aborting due to 32 previous errors
 
diff --git a/tests/ui/unnecessary_lazy_eval_unfixable.stderr b/tests/ui/unnecessary_lazy_eval_unfixable.stderr
index 581d641cbf5..75674b0a9d2 100644
--- a/tests/ui/unnecessary_lazy_eval_unfixable.stderr
+++ b/tests/ui/unnecessary_lazy_eval_unfixable.stderr
@@ -2,7 +2,7 @@ error: unnecessary closure used to substitute value for `Result::Err`
   --> $DIR/unnecessary_lazy_eval_unfixable.rs:12:13
    |
 LL |     let _ = Ok(1).unwrap_or_else(|()| 2);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `unwrap_or` instead: `Ok(1).unwrap_or(2)`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `unwrap_or` instead: `Ok(1).unwrap_or(2)`
    |
    = note: `-D clippy::unnecessary-lazy-evaluations` implied by `-D warnings`
 
@@ -10,13 +10,13 @@ error: unnecessary closure used to substitute value for `Result::Err`
   --> $DIR/unnecessary_lazy_eval_unfixable.rs:16:13
    |
 LL |     let _ = Ok(1).unwrap_or_else(|e::E| 2);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `unwrap_or` instead: `Ok(1).unwrap_or(2)`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `unwrap_or` instead: `Ok(1).unwrap_or(2)`
 
 error: unnecessary closure used to substitute value for `Result::Err`
   --> $DIR/unnecessary_lazy_eval_unfixable.rs:17:13
    |
 LL |     let _ = Ok(1).unwrap_or_else(|SomeStruct { .. }| 2);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: Use `unwrap_or` instead: `Ok(1).unwrap_or(2)`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `unwrap_or` instead: `Ok(1).unwrap_or(2)`
 
 error: aborting due to 3 previous errors
 
diff --git a/tests/ui/used_underscore_binding.stderr b/tests/ui/used_underscore_binding.stderr
index 68e96148093..2cbfc5ca2e2 100644
--- a/tests/ui/used_underscore_binding.stderr
+++ b/tests/ui/used_underscore_binding.stderr
@@ -1,4 +1,4 @@
-error: used binding `_foo` which is prefixed with an underscore. A leading underscore signals that a binding will not be used.
+error: used binding `_foo` which is prefixed with an underscore. A leading underscore signals that a binding will not be used
   --> $DIR/used_underscore_binding.rs:26:5
    |
 LL |     _foo + 1
@@ -6,31 +6,31 @@ LL |     _foo + 1
    |
    = note: `-D clippy::used-underscore-binding` implied by `-D warnings`
 
-error: used binding `_foo` which is prefixed with an underscore. A leading underscore signals that a binding will not be used.
+error: used binding `_foo` which is prefixed with an underscore. A leading underscore signals that a binding will not be used
   --> $DIR/used_underscore_binding.rs:31:20
    |
 LL |     println!("{}", _foo);
    |                    ^^^^
 
-error: used binding `_foo` which is prefixed with an underscore. A leading underscore signals that a binding will not be used.
+error: used binding `_foo` which is prefixed with an underscore. A leading underscore signals that a binding will not be used
   --> $DIR/used_underscore_binding.rs:32:16
    |
 LL |     assert_eq!(_foo, _foo);
    |                ^^^^
 
-error: used binding `_foo` which is prefixed with an underscore. A leading underscore signals that a binding will not be used.
+error: used binding `_foo` which is prefixed with an underscore. A leading underscore signals that a binding will not be used
   --> $DIR/used_underscore_binding.rs:32:22
    |
 LL |     assert_eq!(_foo, _foo);
    |                      ^^^^
 
-error: used binding `_underscore_field` which is prefixed with an underscore. A leading underscore signals that a binding will not be used.
+error: used binding `_underscore_field` which is prefixed with an underscore. A leading underscore signals that a binding will not be used
   --> $DIR/used_underscore_binding.rs:45:5
    |
 LL |     s._underscore_field += 1;
    |     ^^^^^^^^^^^^^^^^^^^
 
-error: used binding `_i` which is prefixed with an underscore. A leading underscore signals that a binding will not be used.
+error: used binding `_i` which is prefixed with an underscore. A leading underscore signals that a binding will not be used
   --> $DIR/used_underscore_binding.rs:100:16
    |
 LL |         uses_i(_i);
diff --git a/tests/ui/vec_box_sized.stderr b/tests/ui/vec_box_sized.stderr
index 57e2f1fdf9a..83435a40aa1 100644
--- a/tests/ui/vec_box_sized.stderr
+++ b/tests/ui/vec_box_sized.stderr
@@ -1,4 +1,4 @@
-error: `Vec<T>` is already on the heap, the boxing is unnecessary.
+error: `Vec<T>` is already on the heap, the boxing is unnecessary
   --> $DIR/vec_box_sized.rs:14:21
    |
 LL |         sized_type: Vec<Box<SizedStruct>>,
@@ -6,19 +6,19 @@ LL |         sized_type: Vec<Box<SizedStruct>>,
    |
    = note: `-D clippy::vec-box` implied by `-D warnings`
 
-error: `Vec<T>` is already on the heap, the boxing is unnecessary.
+error: `Vec<T>` is already on the heap, the boxing is unnecessary
   --> $DIR/vec_box_sized.rs:17:14
    |
 LL |     struct A(Vec<Box<SizedStruct>>);
    |              ^^^^^^^^^^^^^^^^^^^^^ help: try: `Vec<SizedStruct>`
 
-error: `Vec<T>` is already on the heap, the boxing is unnecessary.
+error: `Vec<T>` is already on the heap, the boxing is unnecessary
   --> $DIR/vec_box_sized.rs:18:18
    |
 LL |     struct B(Vec<Vec<Box<(u32)>>>);
    |                  ^^^^^^^^^^^^^^^ help: try: `Vec<u32>`
 
-error: `Vec<T>` is already on the heap, the boxing is unnecessary.
+error: `Vec<T>` is already on the heap, the boxing is unnecessary
   --> $DIR/vec_box_sized.rs:46:23
    |
 LL |         pub fn f() -> Vec<Box<S>> {
diff --git a/tests/ui/wild_in_or_pats.stderr b/tests/ui/wild_in_or_pats.stderr
index 33c34cbbd40..45b87aa0f20 100644
--- a/tests/ui/wild_in_or_pats.stderr
+++ b/tests/ui/wild_in_or_pats.stderr
@@ -1,35 +1,35 @@
-error: wildcard pattern covers any other pattern as it will match anyway.
+error: wildcard pattern covers any other pattern as it will match anyway
   --> $DIR/wild_in_or_pats.rs:8:9
    |
 LL |         "bar" | _ => {
    |         ^^^^^^^^^
    |
    = note: `-D clippy::wildcard-in-or-patterns` implied by `-D warnings`
-   = help: Consider handling `_` separately.
+   = help: consider handling `_` separately
 
-error: wildcard pattern covers any other pattern as it will match anyway.
+error: wildcard pattern covers any other pattern as it will match anyway
   --> $DIR/wild_in_or_pats.rs:16:9
    |
 LL |         "bar" | "bar2" | _ => {
    |         ^^^^^^^^^^^^^^^^^^
    |
-   = help: Consider handling `_` separately.
+   = help: consider handling `_` separately
 
-error: wildcard pattern covers any other pattern as it will match anyway.
+error: wildcard pattern covers any other pattern as it will match anyway
   --> $DIR/wild_in_or_pats.rs:24:9
    |
 LL |         _ | "bar" | _ => {
    |         ^^^^^^^^^^^^^
    |
-   = help: Consider handling `_` separately.
+   = help: consider handling `_` separately
 
-error: wildcard pattern covers any other pattern as it will match anyway.
+error: wildcard pattern covers any other pattern as it will match anyway
   --> $DIR/wild_in_or_pats.rs:32:9
    |
 LL |         _ | "bar" => {
    |         ^^^^^^^^^
    |
-   = help: Consider handling `_` separately.
+   = help: consider handling `_` separately
 
 error: aborting due to 4 previous errors
 
diff --git a/tests/ui/zero_div_zero.stderr b/tests/ui/zero_div_zero.stderr
index d0e88f3c5a5..0931dd32e7a 100644
--- a/tests/ui/zero_div_zero.stderr
+++ b/tests/ui/zero_div_zero.stderr
@@ -13,7 +13,7 @@ LL |     let nan = 0.0 / 0.0;
    |               ^^^^^^^^^
    |
    = note: `-D clippy::zero-divided-by-zero` implied by `-D warnings`
-   = help: Consider using `f64::NAN` if you would like a constant representing NaN
+   = help: consider using `f64::NAN` if you would like a constant representing NaN
 
 error: equal expressions as operands to `/`
   --> $DIR/zero_div_zero.rs:5:19
@@ -27,7 +27,7 @@ error: constant division of `0.0` with `0.0` will always result in NaN
 LL |     let f64_nan = 0.0 / 0.0f64;
    |                   ^^^^^^^^^^^^
    |
-   = help: Consider using `f64::NAN` if you would like a constant representing NaN
+   = help: consider using `f64::NAN` if you would like a constant representing NaN
 
 error: equal expressions as operands to `/`
   --> $DIR/zero_div_zero.rs:6:25
@@ -41,7 +41,7 @@ error: constant division of `0.0` with `0.0` will always result in NaN
 LL |     let other_f64_nan = 0.0f64 / 0.0;
    |                         ^^^^^^^^^^^^
    |
-   = help: Consider using `f64::NAN` if you would like a constant representing NaN
+   = help: consider using `f64::NAN` if you would like a constant representing NaN
 
 error: equal expressions as operands to `/`
   --> $DIR/zero_div_zero.rs:7:28
@@ -55,7 +55,7 @@ error: constant division of `0.0` with `0.0` will always result in NaN
 LL |     let one_more_f64_nan = 0.0f64 / 0.0f64;
    |                            ^^^^^^^^^^^^^^^
    |
-   = help: Consider using `f64::NAN` if you would like a constant representing NaN
+   = help: consider using `f64::NAN` if you would like a constant representing NaN
 
 error: aborting due to 8 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From e00b1cc73ada33c7ef72702810a74f5abd38b112 Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Fri, 26 Feb 2021 15:49:18 +0100
Subject: change some lint messages and remove old entries from the ignorelist

---
 clippy_lints/src/methods/mod.rs                    |  2 +-
 clippy_lints/src/suspicious_operation_groupings.rs |  2 +-
 clippy_lints/src/types.rs                          |  2 +-
 tests/lint_message_convention.rs                   |  4 --
 tests/ui/dlist.stderr                              | 12 ++---
 tests/ui/iterator_step_by_zero.stderr              | 14 +++---
 tests/ui/suspicious_operation_groupings.stderr     | 54 +++++++++++-----------
 7 files changed, 43 insertions(+), 47 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index f5c01ac7729..b0f8185e331 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -2569,7 +2569,7 @@ fn lint_step_by<'tcx>(cx: &LateContext<'tcx>, expr: &hir::Expr<'_>, args: &'tcx
                 cx,
                 ITERATOR_STEP_BY_ZERO,
                 expr.span,
-                "Iterator::step_by(0) will panic at runtime",
+                "`Iterator::step_by(0)` will panic at runtime",
             );
         }
     }
diff --git a/clippy_lints/src/suspicious_operation_groupings.rs b/clippy_lints/src/suspicious_operation_groupings.rs
index 2ff30698043..44521885d20 100644
--- a/clippy_lints/src/suspicious_operation_groupings.rs
+++ b/clippy_lints/src/suspicious_operation_groupings.rs
@@ -262,7 +262,7 @@ fn emit_suggestion(cx: &EarlyContext<'_>, span: Span, sugg: String, applicabilit
         SUSPICIOUS_OPERATION_GROUPINGS,
         span,
         "this sequence of operators looks suspiciously like a bug",
-        "I think you meant",
+        "did you mean",
         sugg,
         applicability,
     )
diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs
index a18cba6fb44..f71b1651bfe 100644
--- a/clippy_lints/src/types.rs
+++ b/clippy_lints/src/types.rs
@@ -578,7 +578,7 @@ impl Types {
                             cx,
                             LINKEDLIST,
                             hir_ty.span,
-                            "I see you're using a LinkedList! Perhaps you meant some other data structure?",
+                            "you seem to be using a `LinkedList`! Perhaps you meant some other data structure?",
                             None,
                             "a `VecDeque` might work",
                         );
diff --git a/tests/lint_message_convention.rs b/tests/lint_message_convention.rs
index 1606a7881c7..d45d93f8184 100644
--- a/tests/lint_message_convention.rs
+++ b/tests/lint_message_convention.rs
@@ -31,9 +31,7 @@ impl Message {
         // sometimes the first character is capitalized and it is legal (like in "Iterator...") or
         // we want to ask a question ending in "?"
         let exceptions_set: RegexSet = RegexSet::new(&[
-            r".*error: I see you're using a LinkedList! Perhaps you meant some other data structure?",
             r".*C-like enum variant discriminant is not portable to 32-bit targets",
-            r".*Iterator::step_by(0) will panic at runtime",
             r".*did you mean `unix`?",
             r".*the arguments may be inverted...",
             r".*Intel x86 assembly syntax used",
@@ -41,8 +39,6 @@ impl Message {
             r".*remove .*the return type...",
             r"note: Clippy version: .*",
             r"the compiler unexpectedly panicked. this is a bug.",
-            r".*help: I think you meant: .*",
-            r"Iterator.* will panic at runtime",
         ])
         .unwrap();
 
diff --git a/tests/ui/dlist.stderr b/tests/ui/dlist.stderr
index 64fde33c64f..234db33ba12 100644
--- a/tests/ui/dlist.stderr
+++ b/tests/ui/dlist.stderr
@@ -1,4 +1,4 @@
-error: I see you're using a LinkedList! Perhaps you meant some other data structure?
+error: you seem to be using a `LinkedList`! Perhaps you meant some other data structure?
   --> $DIR/dlist.rs:9:16
    |
 LL |     type Baz = LinkedList<u8>;
@@ -7,7 +7,7 @@ LL |     type Baz = LinkedList<u8>;
    = note: `-D clippy::linkedlist` implied by `-D warnings`
    = help: a `VecDeque` might work
 
-error: I see you're using a LinkedList! Perhaps you meant some other data structure?
+error: you seem to be using a `LinkedList`! Perhaps you meant some other data structure?
   --> $DIR/dlist.rs:10:15
    |
 LL |     fn foo(_: LinkedList<u8>);
@@ -15,7 +15,7 @@ LL |     fn foo(_: LinkedList<u8>);
    |
    = help: a `VecDeque` might work
 
-error: I see you're using a LinkedList! Perhaps you meant some other data structure?
+error: you seem to be using a `LinkedList`! Perhaps you meant some other data structure?
   --> $DIR/dlist.rs:11:23
    |
 LL |     const BAR: Option<LinkedList<u8>>;
@@ -23,7 +23,7 @@ LL |     const BAR: Option<LinkedList<u8>>;
    |
    = help: a `VecDeque` might work
 
-error: I see you're using a LinkedList! Perhaps you meant some other data structure?
+error: you seem to be using a `LinkedList`! Perhaps you meant some other data structure?
   --> $DIR/dlist.rs:22:15
    |
 LL |     fn foo(_: LinkedList<u8>) {}
@@ -31,7 +31,7 @@ LL |     fn foo(_: LinkedList<u8>) {}
    |
    = help: a `VecDeque` might work
 
-error: I see you're using a LinkedList! Perhaps you meant some other data structure?
+error: you seem to be using a `LinkedList`! Perhaps you meant some other data structure?
   --> $DIR/dlist.rs:25:39
    |
 LL | pub fn test(my_favourite_linked_list: LinkedList<u8>) {
@@ -39,7 +39,7 @@ LL | pub fn test(my_favourite_linked_list: LinkedList<u8>) {
    |
    = help: a `VecDeque` might work
 
-error: I see you're using a LinkedList! Perhaps you meant some other data structure?
+error: you seem to be using a `LinkedList`! Perhaps you meant some other data structure?
   --> $DIR/dlist.rs:29:29
    |
 LL | pub fn test_ret() -> Option<LinkedList<u8>> {
diff --git a/tests/ui/iterator_step_by_zero.stderr b/tests/ui/iterator_step_by_zero.stderr
index c2c6803b3e6..d792aea11df 100644
--- a/tests/ui/iterator_step_by_zero.stderr
+++ b/tests/ui/iterator_step_by_zero.stderr
@@ -1,4 +1,4 @@
-error: Iterator::step_by(0) will panic at runtime
+error: `Iterator::step_by(0)` will panic at runtime
   --> $DIR/iterator_step_by_zero.rs:3:13
    |
 LL |     let _ = vec!["A", "B", "B"].iter().step_by(0);
@@ -6,37 +6,37 @@ LL |     let _ = vec!["A", "B", "B"].iter().step_by(0);
    |
    = note: `-D clippy::iterator-step-by-zero` implied by `-D warnings`
 
-error: Iterator::step_by(0) will panic at runtime
+error: `Iterator::step_by(0)` will panic at runtime
   --> $DIR/iterator_step_by_zero.rs:4:13
    |
 LL |     let _ = "XXX".chars().step_by(0);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: Iterator::step_by(0) will panic at runtime
+error: `Iterator::step_by(0)` will panic at runtime
   --> $DIR/iterator_step_by_zero.rs:5:13
    |
 LL |     let _ = (0..1).step_by(0);
    |             ^^^^^^^^^^^^^^^^^
 
-error: Iterator::step_by(0) will panic at runtime
+error: `Iterator::step_by(0)` will panic at runtime
   --> $DIR/iterator_step_by_zero.rs:14:13
    |
 LL |     let _ = (1..).step_by(0);
    |             ^^^^^^^^^^^^^^^^
 
-error: Iterator::step_by(0) will panic at runtime
+error: `Iterator::step_by(0)` will panic at runtime
   --> $DIR/iterator_step_by_zero.rs:15:13
    |
 LL |     let _ = (1..=2).step_by(0);
    |             ^^^^^^^^^^^^^^^^^^
 
-error: Iterator::step_by(0) will panic at runtime
+error: `Iterator::step_by(0)` will panic at runtime
   --> $DIR/iterator_step_by_zero.rs:18:13
    |
 LL |     let _ = x.step_by(0);
    |             ^^^^^^^^^^^^
 
-error: Iterator::step_by(0) will panic at runtime
+error: `Iterator::step_by(0)` will panic at runtime
   --> $DIR/iterator_step_by_zero.rs:22:13
    |
 LL |     let _ = v1.iter().step_by(2 / 3);
diff --git a/tests/ui/suspicious_operation_groupings.stderr b/tests/ui/suspicious_operation_groupings.stderr
index 2da05399575..96065699d32 100644
--- a/tests/ui/suspicious_operation_groupings.stderr
+++ b/tests/ui/suspicious_operation_groupings.stderr
@@ -2,7 +2,7 @@ error: this sequence of operators looks suspiciously like a bug
   --> $DIR/suspicious_operation_groupings.rs:14:9
    |
 LL |         self.x == other.y && self.y == other.y && self.z == other.z
-   |         ^^^^^^^^^^^^^^^^^ help: I think you meant: `self.x == other.x`
+   |         ^^^^^^^^^^^^^^^^^ help: did you mean: `self.x == other.x`
    |
    = note: `-D clippy::suspicious-operation-groupings` implied by `-D warnings`
 
@@ -10,157 +10,157 @@ error: this sequence of operators looks suspiciously like a bug
   --> $DIR/suspicious_operation_groupings.rs:14:9
    |
 LL |         self.x == other.y && self.y == other.y && self.z == other.z
-   |         ^^^^^^^^^^^^^^^^^ help: I think you meant: `self.x == other.x`
+   |         ^^^^^^^^^^^^^^^^^ help: did you mean: `self.x == other.x`
 
 error: this sequence of operators looks suspiciously like a bug
   --> $DIR/suspicious_operation_groupings.rs:27:20
    |
 LL |     s1.a < s2.a && s1.a < s2.b
-   |                    ^^^^^^^^^^^ help: I think you meant: `s1.b < s2.b`
+   |                    ^^^^^^^^^^^ help: did you mean: `s1.b < s2.b`
 
 error: this sequence of operators looks suspiciously like a bug
   --> $DIR/suspicious_operation_groupings.rs:75:33
    |
 LL |     s1.a * s2.a + s1.b * s2.b + s1.c * s2.b + s1.d * s2.d
-   |                                 ^^^^^^^^^^^ help: I think you meant: `s1.c * s2.c`
+   |                                 ^^^^^^^^^^^ help: did you mean: `s1.c * s2.c`
 
 error: this sequence of operators looks suspiciously like a bug
   --> $DIR/suspicious_operation_groupings.rs:80:19
    |
 LL |     s1.a * s2.a + s1.b * s2.c + s1.c * s2.c
-   |                   ^^^^^^^^^^^ help: I think you meant: `s1.b * s2.b`
+   |                   ^^^^^^^^^^^ help: did you mean: `s1.b * s2.b`
 
 error: this sequence of operators looks suspiciously like a bug
   --> $DIR/suspicious_operation_groupings.rs:80:19
    |
 LL |     s1.a * s2.a + s1.b * s2.c + s1.c * s2.c
-   |                   ^^^^^^^^^^^ help: I think you meant: `s1.b * s2.b`
+   |                   ^^^^^^^^^^^ help: did you mean: `s1.b * s2.b`
 
 error: this sequence of operators looks suspiciously like a bug
   --> $DIR/suspicious_operation_groupings.rs:85:19
    |
 LL |     s1.a * s2.a + s2.b * s2.b + s1.c * s2.c
-   |                   ^^^^^^^^^^^ help: I think you meant: `s1.b * s2.b`
+   |                   ^^^^^^^^^^^ help: did you mean: `s1.b * s2.b`
 
 error: this sequence of operators looks suspiciously like a bug
   --> $DIR/suspicious_operation_groupings.rs:90:19
    |
 LL |     s1.a * s2.a + s1.b * s1.b + s1.c * s2.c
-   |                   ^^^^^^^^^^^ help: I think you meant: `s1.b * s2.b`
+   |                   ^^^^^^^^^^^ help: did you mean: `s1.b * s2.b`
 
 error: this sequence of operators looks suspiciously like a bug
   --> $DIR/suspicious_operation_groupings.rs:95:5
    |
 LL |     s1.a * s1.a + s1.b * s2.b + s1.c * s2.c
-   |     ^^^^^^^^^^^ help: I think you meant: `s1.a * s2.a`
+   |     ^^^^^^^^^^^ help: did you mean: `s1.a * s2.a`
 
 error: this sequence of operators looks suspiciously like a bug
   --> $DIR/suspicious_operation_groupings.rs:100:33
    |
 LL |     s1.a * s2.a + s1.b * s2.b + s1.c * s1.c
-   |                                 ^^^^^^^^^^^ help: I think you meant: `s1.c * s2.c`
+   |                                 ^^^^^^^^^^^ help: did you mean: `s1.c * s2.c`
 
 error: this sequence of operators looks suspiciously like a bug
   --> $DIR/suspicious_operation_groupings.rs:113:20
    |
 LL |     (s1.a * s2.a + s1.b * s1.b)
-   |                    ^^^^^^^^^^^ help: I think you meant: `s1.b * s2.b`
+   |                    ^^^^^^^^^^^ help: did you mean: `s1.b * s2.b`
 
 error: this sequence of operators looks suspiciously like a bug
   --> $DIR/suspicious_operation_groupings.rs:118:34
    |
 LL |     (s1.a * s2.a + s1.b * s2.b + s1.c * s2.b + s1.d * s2.d)
-   |                                  ^^^^^^^^^^^ help: I think you meant: `s1.c * s2.c`
+   |                                  ^^^^^^^^^^^ help: did you mean: `s1.c * s2.c`
 
 error: this sequence of operators looks suspiciously like a bug
   --> $DIR/suspicious_operation_groupings.rs:123:38
    |
 LL |     (s1.a * s2.a) + (s1.b * s2.b) + (s1.c * s2.b) + (s1.d * s2.d)
-   |                                      ^^^^^^^^^^^ help: I think you meant: `s1.c * s2.c`
+   |                                      ^^^^^^^^^^^ help: did you mean: `s1.c * s2.c`
 
 error: this sequence of operators looks suspiciously like a bug
   --> $DIR/suspicious_operation_groupings.rs:128:39
    |
 LL |     ((s1.a * s2.a) + (s1.b * s2.b) + (s1.c * s2.b) + (s1.d * s2.d))
-   |                                       ^^^^^^^^^^^ help: I think you meant: `s1.c * s2.c`
+   |                                       ^^^^^^^^^^^ help: did you mean: `s1.c * s2.c`
 
 error: this sequence of operators looks suspiciously like a bug
   --> $DIR/suspicious_operation_groupings.rs:133:42
    |
 LL |     (((s1.a * s2.a) + (s1.b * s2.b)) + ((s1.c * s2.b) + (s1.d * s2.d)))
-   |                                          ^^^^^^^^^^^ help: I think you meant: `s1.c * s2.c`
+   |                                          ^^^^^^^^^^^ help: did you mean: `s1.c * s2.c`
 
 error: this sequence of operators looks suspiciously like a bug
   --> $DIR/suspicious_operation_groupings.rs:133:42
    |
 LL |     (((s1.a * s2.a) + (s1.b * s2.b)) + ((s1.c * s2.b) + (s1.d * s2.d)))
-   |                                          ^^^^^^^^^^^ help: I think you meant: `s1.c * s2.c`
+   |                                          ^^^^^^^^^^^ help: did you mean: `s1.c * s2.c`
 
 error: this sequence of operators looks suspiciously like a bug
   --> $DIR/suspicious_operation_groupings.rs:138:40
    |
 LL |     (((s1.a * s2.a) + (s1.b * s2.b) + (s1.c * s2.b)) + (s1.d * s2.d))
-   |                                        ^^^^^^^^^^^ help: I think you meant: `s1.c * s2.c`
+   |                                        ^^^^^^^^^^^ help: did you mean: `s1.c * s2.c`
 
 error: this sequence of operators looks suspiciously like a bug
   --> $DIR/suspicious_operation_groupings.rs:143:40
    |
 LL |     ((s1.a * s2.a) + ((s1.b * s2.b) + (s1.c * s2.b) + (s1.d * s2.d)))
-   |                                        ^^^^^^^^^^^ help: I think you meant: `s1.c * s2.c`
+   |                                        ^^^^^^^^^^^ help: did you mean: `s1.c * s2.c`
 
 error: this sequence of operators looks suspiciously like a bug
   --> $DIR/suspicious_operation_groupings.rs:148:20
    |
 LL |     (s1.a * s2.a + s2.b * s2.b) / 2
-   |                    ^^^^^^^^^^^ help: I think you meant: `s1.b * s2.b`
+   |                    ^^^^^^^^^^^ help: did you mean: `s1.b * s2.b`
 
 error: this sequence of operators looks suspiciously like a bug
   --> $DIR/suspicious_operation_groupings.rs:153:35
    |
 LL |     i32::swap_bytes(s1.a * s2.a + s2.b * s2.b)
-   |                                   ^^^^^^^^^^^ help: I think you meant: `s1.b * s2.b`
+   |                                   ^^^^^^^^^^^ help: did you mean: `s1.b * s2.b`
 
 error: this sequence of operators looks suspiciously like a bug
   --> $DIR/suspicious_operation_groupings.rs:158:29
    |
 LL |     s1.a > 0 && s1.b > 0 && s1.d == s2.c && s1.d == s2.d
-   |                             ^^^^^^^^^^^^ help: I think you meant: `s1.c == s2.c`
+   |                             ^^^^^^^^^^^^ help: did you mean: `s1.c == s2.c`
 
 error: this sequence of operators looks suspiciously like a bug
   --> $DIR/suspicious_operation_groupings.rs:163:17
    |
 LL |     s1.a > 0 && s1.d == s2.c && s1.b > 0 && s1.d == s2.d
-   |                 ^^^^^^^^^^^^ help: I think you meant: `s1.c == s2.c`
+   |                 ^^^^^^^^^^^^ help: did you mean: `s1.c == s2.c`
 
 error: this sequence of operators looks suspiciously like a bug
   --> $DIR/suspicious_operation_groupings.rs:172:77
    |
 LL |     (n1.inner.0).0 == (n2.inner.0).0 && (n1.inner.1).0 == (n2.inner.1).0 && (n1.inner.2).0 == (n2.inner.1).0
-   |                                                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: I think you meant: `(n1.inner.2).0 == (n2.inner.2).0`
+   |                                                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: did you mean: `(n1.inner.2).0 == (n2.inner.2).0`
 
 error: this sequence of operators looks suspiciously like a bug
   --> $DIR/suspicious_operation_groupings.rs:186:25
    |
 LL |         s1.a <= s2.a && s1.a <= s2.b
-   |                         ^^^^^^^^^^^^ help: I think you meant: `s1.b <= s2.b`
+   |                         ^^^^^^^^^^^^ help: did you mean: `s1.b <= s2.b`
 
 error: this sequence of operators looks suspiciously like a bug
   --> $DIR/suspicious_operation_groupings.rs:192:23
    |
 LL |     if s1.a < s2.a && s1.a < s2.b {
-   |                       ^^^^^^^^^^^ help: I think you meant: `s1.b < s2.b`
+   |                       ^^^^^^^^^^^ help: did you mean: `s1.b < s2.b`
 
 error: this sequence of operators looks suspiciously like a bug
   --> $DIR/suspicious_operation_groupings.rs:199:48
    |
 LL |     -(-(-s1.a * -s2.a) + (-(-s1.b * -s2.b) + -(-s1.c * -s2.b) + -(-s1.d * -s2.d)))
-   |                                                ^^^^^^^^^^^^^ help: I think you meant: `-s1.c * -s2.c`
+   |                                                ^^^^^^^^^^^^^ help: did you mean: `-s1.c * -s2.c`
 
 error: this sequence of operators looks suspiciously like a bug
   --> $DIR/suspicious_operation_groupings.rs:204:27
    |
 LL |     -(if -s1.a < -s2.a && -s1.a < -s2.b { s1.c } else { s2.a })
-   |                           ^^^^^^^^^^^^^ help: I think you meant: `-s1.b < -s2.b`
+   |                           ^^^^^^^^^^^^^ help: did you mean: `-s1.b < -s2.b`
 
 error: aborting due to 27 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From da3a57377ea34c1ddb0c0c41defb456b8dceed53 Mon Sep 17 00:00:00 2001
From: hyd-dev <yd-huang@outlook.com>
Date: Sun, 28 Feb 2021 20:44:07 +0800
Subject: Fix false positives on procedural macros of
 `missing_inline_in_public_items` lint

---
 clippy_lints/src/missing_inline.rs    |  8 ++++----
 tests/ui/missing_inline_executable.rs |  5 +++++
 tests/ui/missing_inline_proc_macro.rs | 23 +++++++++++++++++++++++
 3 files changed, 32 insertions(+), 4 deletions(-)
 create mode 100644 tests/ui/missing_inline_executable.rs
 create mode 100644 tests/ui/missing_inline_proc_macro.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/missing_inline.rs b/clippy_lints/src/missing_inline.rs
index 47d7c5306c4..2448325e899 100644
--- a/clippy_lints/src/missing_inline.rs
+++ b/clippy_lints/src/missing_inline.rs
@@ -69,21 +69,21 @@ fn check_missing_inline_attrs(cx: &LateContext<'_>, attrs: &[ast::Attribute], sp
     }
 }
 
-fn is_executable(cx: &LateContext<'_>) -> bool {
+fn is_executable_or_proc_macro(cx: &LateContext<'_>) -> bool {
     use rustc_session::config::CrateType;
 
     cx.tcx
         .sess
         .crate_types()
         .iter()
-        .any(|t: &CrateType| matches!(t, CrateType::Executable))
+        .any(|t: &CrateType| matches!(t, CrateType::Executable | CrateType::ProcMacro))
 }
 
 declare_lint_pass!(MissingInline => [MISSING_INLINE_IN_PUBLIC_ITEMS]);
 
 impl<'tcx> LateLintPass<'tcx> for MissingInline {
     fn check_item(&mut self, cx: &LateContext<'tcx>, it: &'tcx hir::Item<'_>) {
-        if rustc_middle::lint::in_external_macro(cx.sess(), it.span) || is_executable(cx) {
+        if rustc_middle::lint::in_external_macro(cx.sess(), it.span) || is_executable_or_proc_macro(cx) {
             return;
         }
 
@@ -133,7 +133,7 @@ impl<'tcx> LateLintPass<'tcx> for MissingInline {
 
     fn check_impl_item(&mut self, cx: &LateContext<'tcx>, impl_item: &'tcx hir::ImplItem<'_>) {
         use rustc_middle::ty::{ImplContainer, TraitContainer};
-        if rustc_middle::lint::in_external_macro(cx.sess(), impl_item.span) || is_executable(cx) {
+        if rustc_middle::lint::in_external_macro(cx.sess(), impl_item.span) || is_executable_or_proc_macro(cx) {
             return;
         }
 
diff --git a/tests/ui/missing_inline_executable.rs b/tests/ui/missing_inline_executable.rs
new file mode 100644
index 00000000000..6e0400ac935
--- /dev/null
+++ b/tests/ui/missing_inline_executable.rs
@@ -0,0 +1,5 @@
+#![warn(clippy::missing_inline_in_public_items)]
+
+pub fn foo() {}
+
+fn main() {}
diff --git a/tests/ui/missing_inline_proc_macro.rs b/tests/ui/missing_inline_proc_macro.rs
new file mode 100644
index 00000000000..3c68fb905f1
--- /dev/null
+++ b/tests/ui/missing_inline_proc_macro.rs
@@ -0,0 +1,23 @@
+#![warn(clippy::missing_inline_in_public_items)]
+#![crate_type = "proc-macro"]
+
+extern crate proc_macro;
+
+use proc_macro::TokenStream;
+
+fn _foo() {}
+
+#[proc_macro]
+pub fn function_like(_: TokenStream) -> TokenStream {
+    TokenStream::new()
+}
+
+#[proc_macro_attribute]
+pub fn attribute(_: TokenStream, _: TokenStream) -> TokenStream {
+    TokenStream::new()
+}
+
+#[proc_macro_derive(Derive)]
+pub fn derive(_: TokenStream) -> TokenStream {
+    TokenStream::new()
+}
-- 
cgit 1.4.1-3-g733a5


From a3278a16d31198d45c710c3c4dde433fc77d8d90 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sun, 28 Feb 2021 09:03:21 -0500
Subject: Fix `manual_map`: do not expand macros in suggestions

---
 clippy_lints/src/manual_map.rs    | 149 ++++++++++++++++++++------------------
 clippy_utils/src/lib.rs           |  33 ++++++++-
 tests/ui/manual_map_option.fixed  |   5 ++
 tests/ui/manual_map_option.rs     |  11 +++
 tests/ui/manual_map_option.stderr |  20 ++++-
 5 files changed, 146 insertions(+), 72 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_map.rs b/clippy_lints/src/manual_map.rs
index e6e70004527..983a10e8eaa 100644
--- a/clippy_lints/src/manual_map.rs
+++ b/clippy_lints/src/manual_map.rs
@@ -3,7 +3,8 @@ use crate::{
     matches::MATCH_AS_REF,
     utils::{
         can_partially_move_ty, is_allowed, is_type_diagnostic_item, match_def_path, match_var, paths,
-        peel_hir_expr_refs, peel_mid_ty_refs_is_mutable, snippet_with_applicability, span_lint_and_sugg,
+        peel_hir_expr_refs, peel_mid_ty_refs_is_mutable, snippet_with_applicability, snippet_with_context,
+        span_lint_and_sugg,
     },
 };
 use rustc_ast::util::parser::PREC_POSTFIX;
@@ -16,7 +17,10 @@ use rustc_hir::{
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::symbol::{sym, Ident};
+use rustc_span::{
+    symbol::{sym, Ident},
+    SyntaxContext,
+};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for usages of `match` which could be implemented using `map`
@@ -56,43 +60,46 @@ impl LateLintPass<'_> for ManualMap {
         {
             let (scrutinee_ty, ty_ref_count, ty_mutability) =
                 peel_mid_ty_refs_is_mutable(cx.typeck_results().expr_ty(scrutinee));
-            if !is_type_diagnostic_item(cx, scrutinee_ty, sym::option_type)
-                || !is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(expr), sym::option_type)
+            if !(is_type_diagnostic_item(cx, scrutinee_ty, sym::option_type)
+                && is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(expr), sym::option_type))
             {
                 return;
             }
 
-            let (some_expr, some_pat, pat_ref_count, is_wild_none) =
-                match (try_parse_pattern(cx, arm1.pat), try_parse_pattern(cx, arm2.pat)) {
-                    (Some(OptionPat::Wild), Some(OptionPat::Some { pattern, ref_count }))
-                        if is_none_expr(cx, arm1.body) =>
-                    {
-                        (arm2.body, pattern, ref_count, true)
-                    },
-                    (Some(OptionPat::None), Some(OptionPat::Some { pattern, ref_count }))
-                        if is_none_expr(cx, arm1.body) =>
-                    {
-                        (arm2.body, pattern, ref_count, false)
-                    },
-                    (Some(OptionPat::Some { pattern, ref_count }), Some(OptionPat::Wild))
-                        if is_none_expr(cx, arm2.body) =>
-                    {
-                        (arm1.body, pattern, ref_count, true)
-                    },
-                    (Some(OptionPat::Some { pattern, ref_count }), Some(OptionPat::None))
-                        if is_none_expr(cx, arm2.body) =>
-                    {
-                        (arm1.body, pattern, ref_count, false)
-                    },
-                    _ => return,
-                };
+            let expr_ctxt = expr.span.ctxt();
+            let (some_expr, some_pat, pat_ref_count, is_wild_none) = match (
+                try_parse_pattern(cx, arm1.pat, expr_ctxt),
+                try_parse_pattern(cx, arm2.pat, expr_ctxt),
+            ) {
+                (Some(OptionPat::Wild), Some(OptionPat::Some { pattern, ref_count }))
+                    if is_none_expr(cx, arm1.body) =>
+                {
+                    (arm2.body, pattern, ref_count, true)
+                },
+                (Some(OptionPat::None), Some(OptionPat::Some { pattern, ref_count }))
+                    if is_none_expr(cx, arm1.body) =>
+                {
+                    (arm2.body, pattern, ref_count, false)
+                },
+                (Some(OptionPat::Some { pattern, ref_count }), Some(OptionPat::Wild))
+                    if is_none_expr(cx, arm2.body) =>
+                {
+                    (arm1.body, pattern, ref_count, true)
+                },
+                (Some(OptionPat::Some { pattern, ref_count }), Some(OptionPat::None))
+                    if is_none_expr(cx, arm2.body) =>
+                {
+                    (arm1.body, pattern, ref_count, false)
+                },
+                _ => return,
+            };
 
             // Top level or patterns aren't allowed in closures.
             if matches!(some_pat.kind, PatKind::Or(_)) {
                 return;
             }
 
-            let some_expr = match get_some_expr(cx, some_expr) {
+            let some_expr = match get_some_expr(cx, some_expr, expr_ctxt) {
                 Some(expr) => expr,
                 None => return,
             };
@@ -119,47 +126,50 @@ impl LateLintPass<'_> for ManualMap {
 
             let mut app = Applicability::MachineApplicable;
 
-            // Remove address-of expressions from the scrutinee. `as_ref` will be called,
-            // the type is copyable, or the option is being passed by value.
+            // Remove address-of expressions from the scrutinee. Either `as_ref` will be called, or
+            // it's being passed by value.
             let scrutinee = peel_hir_expr_refs(scrutinee).0;
-            let scrutinee_str = snippet_with_applicability(cx, scrutinee.span, "_", &mut app);
-            let scrutinee_str = if expr.precedence().order() < PREC_POSTFIX {
-                // Parens are needed to chain method calls.
-                format!("({})", scrutinee_str)
-            } else {
-                scrutinee_str.into()
-            };
+            let scrutinee_str = snippet_with_context(cx, scrutinee.span, expr_ctxt, "..", &mut app);
+            let scrutinee_str =
+                if scrutinee.span.ctxt() == expr.span.ctxt() && scrutinee.precedence().order() < PREC_POSTFIX {
+                    format!("({})", scrutinee_str)
+                } else {
+                    scrutinee_str.into()
+                };
 
             let body_str = if let PatKind::Binding(annotation, _, some_binding, None) = some_pat.kind {
-                if let Some(func) = can_pass_as_func(cx, some_binding, some_expr) {
-                    snippet_with_applicability(cx, func.span, "..", &mut app).into_owned()
-                } else {
-                    if match_var(some_expr, some_binding.name)
-                        && !is_allowed(cx, MATCH_AS_REF, expr.hir_id)
-                        && binding_ref.is_some()
-                    {
-                        return;
-                    }
+                match can_pass_as_func(cx, some_binding, some_expr) {
+                    Some(func) if func.span.ctxt() == some_expr.span.ctxt() => {
+                        snippet_with_applicability(cx, func.span, "..", &mut app).into_owned()
+                    },
+                    _ => {
+                        if match_var(some_expr, some_binding.name)
+                            && !is_allowed(cx, MATCH_AS_REF, expr.hir_id)
+                            && binding_ref.is_some()
+                        {
+                            return;
+                        }
 
-                    // `ref` and `ref mut` annotations were handled earlier.
-                    let annotation = if matches!(annotation, BindingAnnotation::Mutable) {
-                        "mut "
-                    } else {
-                        ""
-                    };
-                    format!(
-                        "|{}{}| {}",
-                        annotation,
-                        some_binding,
-                        snippet_with_applicability(cx, some_expr.span, "..", &mut app)
-                    )
+                        // `ref` and `ref mut` annotations were handled earlier.
+                        let annotation = if matches!(annotation, BindingAnnotation::Mutable) {
+                            "mut "
+                        } else {
+                            ""
+                        };
+                        format!(
+                            "|{}{}| {}",
+                            annotation,
+                            some_binding,
+                            snippet_with_context(cx, some_expr.span, expr_ctxt, "..", &mut app)
+                        )
+                    },
                 }
             } else if !is_wild_none && explicit_ref.is_none() {
                 // TODO: handle explicit reference annotations.
                 format!(
                     "|{}| {}",
-                    snippet_with_applicability(cx, some_pat.span, "..", &mut app),
-                    snippet_with_applicability(cx, some_expr.span, "..", &mut app)
+                    snippet_with_context(cx, some_pat.span, expr_ctxt, "..", &mut app),
+                    snippet_with_context(cx, some_expr.span, expr_ctxt, "..", &mut app)
                 )
             } else {
                 // Refutable bindings and mixed reference annotations can't be handled by `map`.
@@ -246,11 +256,11 @@ enum OptionPat<'a> {
 
 // Try to parse into a recognized `Option` pattern.
 // i.e. `_`, `None`, `Some(..)`, or a reference to any of those.
-fn try_parse_pattern(cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>) -> Option<OptionPat<'tcx>> {
-    fn f(cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>, ref_count: usize) -> Option<OptionPat<'tcx>> {
+fn try_parse_pattern(cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>, ctxt: SyntaxContext) -> Option<OptionPat<'tcx>> {
+    fn f(cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>, ref_count: usize, ctxt: SyntaxContext) -> Option<OptionPat<'tcx>> {
         match pat.kind {
             PatKind::Wild => Some(OptionPat::Wild),
-            PatKind::Ref(pat, _) => f(cx, pat, ref_count + 1),
+            PatKind::Ref(pat, _) => f(cx, pat, ref_count + 1, ctxt),
             PatKind::Path(QPath::Resolved(None, path))
                 if path
                     .res
@@ -263,18 +273,19 @@ fn try_parse_pattern(cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>) -> Option<Optio
                 if path
                     .res
                     .opt_def_id()
-                    .map_or(false, |id| match_def_path(cx, id, &paths::OPTION_SOME)) =>
+                    .map_or(false, |id| match_def_path(cx, id, &paths::OPTION_SOME))
+                    && pat.span.ctxt() == ctxt =>
             {
                 Some(OptionPat::Some { pattern, ref_count })
             },
             _ => None,
         }
     }
-    f(cx, pat, 0)
+    f(cx, pat, 0, ctxt)
 }
 
 // Checks for an expression wrapped by the `Some` constructor. Returns the contained expression.
-fn get_some_expr(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<&'tcx Expr<'tcx>> {
+fn get_some_expr(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, ctxt: SyntaxContext) -> Option<&'tcx Expr<'tcx>> {
     // TODO: Allow more complex expressions.
     match expr.kind {
         ExprKind::Call(
@@ -283,7 +294,7 @@ fn get_some_expr(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<&'tcx E
                 ..
             },
             [arg],
-        ) => {
+        ) if ctxt == expr.span.ctxt() => {
             if match_def_path(cx, path.res.opt_def_id()?, &paths::OPTION_SOME) {
                 Some(arg)
             } else {
@@ -297,7 +308,7 @@ fn get_some_expr(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<&'tcx E
                 ..
             },
             _,
-        ) => get_some_expr(cx, expr),
+        ) => get_some_expr(cx, expr, ctxt),
         _ => None,
     }
 }
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 05523943511..5d1093ea040 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -73,11 +73,11 @@ use rustc_middle::ty::subst::{GenericArg, GenericArgKind};
 use rustc_middle::ty::{self, layout::IntegerExt, DefIdTree, Ty, TyCtxt, TypeFoldable};
 use rustc_semver::RustcVersion;
 use rustc_session::Session;
-use rustc_span::hygiene::{ExpnKind, MacroKind};
+use rustc_span::hygiene::{self, ExpnKind, MacroKind};
 use rustc_span::source_map::original_sp;
 use rustc_span::sym;
 use rustc_span::symbol::{kw, Symbol};
-use rustc_span::{BytePos, Pos, Span, DUMMY_SP};
+use rustc_span::{BytePos, Pos, Span, SyntaxContext, DUMMY_SP};
 use rustc_target::abi::Integer;
 use rustc_trait_selection::traits::query::normalize::AtExt;
 use smallvec::SmallVec;
@@ -758,6 +758,35 @@ pub fn snippet_block_with_applicability<'a, T: LintContext>(
     reindent_multiline(snip, true, indent)
 }
 
+/// Same as `snippet_with_applicability`, but first walks the span up to the given context. This
+/// will result in the macro call, rather then the expansion, if the span is from a child context.
+/// If the span is not from a child context, it will be used directly instead.
+///
+/// e.g. Given the expression `&vec![]`, getting a snippet from the span for `vec![]` as a HIR node
+/// would result in `box []`. If given the context of the address of expression, this function will
+/// correctly get a snippet of `vec![]`.
+pub fn snippet_with_context(
+    cx: &LateContext<'_>,
+    span: Span,
+    outer: SyntaxContext,
+    default: &'a str,
+    applicability: &mut Applicability,
+) -> Cow<'a, str> {
+    let outer_span = hygiene::walk_chain(span, outer);
+    let span = if outer_span.ctxt() == outer {
+        outer_span
+    } else {
+        // The span is from a macro argument, and the outer context is the macro using the argument
+        if *applicability != Applicability::Unspecified {
+            *applicability = Applicability::MaybeIncorrect;
+        }
+        // TODO: get the argument span.
+        span
+    };
+
+    snippet_with_applicability(cx, span, default, applicability)
+}
+
 /// Returns a new Span that extends the original Span to the first non-whitespace char of the first
 /// line.
 ///
diff --git a/tests/ui/manual_map_option.fixed b/tests/ui/manual_map_option.fixed
index 428aac43940..e6fa10d22e1 100644
--- a/tests/ui/manual_map_option.fixed
+++ b/tests/ui/manual_map_option.fixed
@@ -110,4 +110,9 @@ fn main() {
             }
         }
     }
+
+    // #6811
+    Some(0).map(|x| vec![x]);
+
+    option_env!("").map(String::from);
 }
diff --git a/tests/ui/manual_map_option.rs b/tests/ui/manual_map_option.rs
index 0f4a5bb2eb7..7c2100299a7 100644
--- a/tests/ui/manual_map_option.rs
+++ b/tests/ui/manual_map_option.rs
@@ -162,4 +162,15 @@ fn main() {
             }
         }
     }
+
+    // #6811
+    match Some(0) {
+        Some(x) => Some(vec![x]),
+        None => None,
+    };
+
+    match option_env!("") {
+        Some(x) => Some(String::from(x)),
+        None => None,
+    };
 }
diff --git a/tests/ui/manual_map_option.stderr b/tests/ui/manual_map_option.stderr
index 49a51737784..2d13213cf67 100644
--- a/tests/ui/manual_map_option.stderr
+++ b/tests/ui/manual_map_option.stderr
@@ -154,5 +154,23 @@ LL | |         None => None,
 LL | |     };
    | |_____^ help: try this: `Some((String::new(), "test")).as_ref().map(|(x, y)| (y, x))`
 
-error: aborting due to 17 previous errors
+error: manual implementation of `Option::map`
+  --> $DIR/manual_map_option.rs:167:5
+   |
+LL | /     match Some(0) {
+LL | |         Some(x) => Some(vec![x]),
+LL | |         None => None,
+LL | |     };
+   | |_____^ help: try this: `Some(0).map(|x| vec![x])`
+
+error: manual implementation of `Option::map`
+  --> $DIR/manual_map_option.rs:172:5
+   |
+LL | /     match option_env!("") {
+LL | |         Some(x) => Some(String::from(x)),
+LL | |         None => None,
+LL | |     };
+   | |_____^ help: try this: `option_env!("").map(String::from)`
+
+error: aborting due to 19 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From ada8c72f3f21013f789f774d4c0219c58264e663 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Mon, 1 Mar 2021 11:53:33 -0600
Subject: Add version = "Two" to rustfmt.toml

Ignore UI tests since this change makes rustfmt less friendly with UI
test comments.
---
 clippy_lints/src/await_holding_invalid.rs          | 14 ++---
 clippy_lints/src/float_literal.rs                  |  6 +-
 clippy_lints/src/infinite_iter.rs                  |  6 +-
 clippy_lints/src/inherent_to_string.rs             |  2 +-
 clippy_lints/src/loops.rs                          |  6 +-
 clippy_lints/src/mutable_debug_assertion.rs        |  6 +-
 clippy_lints/src/needless_continue.rs              |  6 +-
 clippy_lints/src/open_options.rs                   | 12 ++--
 clippy_utils/src/camel_case.rs                     |  6 +-
 clippy_utils/src/lib.rs                            | 12 ++--
 clippy_utils/src/ptr.rs                            |  6 +-
 rustfmt.toml                                       |  1 +
 tests/lint_message_convention.rs                   |  4 +-
 .../upper_case_acronyms.rs                         |  5 +-
 .../upper_case_acronyms.stderr                     |  4 +-
 tests/ui/auxiliary/macro_rules.rs                  |  6 +-
 tests/ui/blocks_in_if_conditions.fixed             | 33 ++++------
 tests/ui/blocks_in_if_conditions.rs                | 33 ++++------
 tests/ui/blocks_in_if_conditions.stderr            | 10 +--
 tests/ui/checked_unwrap/simple_conditionals.rs     | 14 +++--
 tests/ui/crashes/ice-6256.rs                       |  1 +
 tests/ui/crashes/ice-6256.stderr                   |  6 +-
 tests/ui/dbg_macro.rs                              |  6 +-
 tests/ui/dbg_macro.stderr                          | 16 ++---
 tests/ui/default_trait_access.fixed                | 20 +-----
 tests/ui/default_trait_access.rs                   | 20 +-----
 tests/ui/doc_panics.rs                             | 12 +---
 tests/ui/doc_panics.stderr                         | 12 ++--
 tests/ui/float_cmp.rs                              | 12 +---
 tests/ui/float_cmp.stderr                          | 12 ++--
 tests/ui/float_cmp_const.rs                        |  6 +-
 tests/ui/float_cmp_const.stderr                    | 16 ++---
 tests/ui/floating_point_abs.fixed                  | 30 ++-------
 tests/ui/floating_point_abs.rs                     | 72 ++++------------------
 tests/ui/floating_point_abs.stderr                 | 70 +++++++--------------
 tests/ui/if_let_some_result.fixed                  | 12 +---
 tests/ui/if_let_some_result.rs                     | 12 +---
 tests/ui/if_let_some_result.stderr                 |  6 +-
 tests/ui/implicit_return.fixed                     |  6 +-
 tests/ui/implicit_return.rs                        |  6 +-
 tests/ui/implicit_return.stderr                    | 28 ++++-----
 tests/ui/needless_lifetimes.rs                     |  6 +-
 tests/ui/needless_lifetimes.stderr                 | 36 +++++------
 tests/ui/redundant_clone.fixed                     |  6 +-
 tests/ui/redundant_clone.rs                        |  6 +-
 tests/ui/redundant_clone.stderr                    | 28 ++++-----
 tests/ui/unnecessary_wraps.rs                      | 36 ++---------
 tests/ui/unnecessary_wraps.stderr                  | 18 +++---
 tests/ui/upper_case_acronyms.rs                    |  5 +-
 tests/ui/use_self.fixed                            |  6 +-
 tests/ui/use_self.rs                               |  6 +-
 tests/ui/use_self.stderr                           |  2 +-
 52 files changed, 225 insertions(+), 503 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/await_holding_invalid.rs b/clippy_lints/src/await_holding_invalid.rs
index fad3aff96cc..112c5bb14e3 100644
--- a/clippy_lints/src/await_holding_invalid.rs
+++ b/clippy_lints/src/await_holding_invalid.rs
@@ -123,13 +123,13 @@ fn check_interior_types(cx: &LateContext<'_>, ty_causes: &[GeneratorInteriorType
             }
             if is_refcell_ref(cx, adt.did) {
                 span_lint_and_note(
-                        cx,
-                        AWAIT_HOLDING_REFCELL_REF,
-                        ty_cause.span,
-                        "this RefCell Ref is held across an 'await' point. Consider ensuring the Ref is dropped before calling await",
-                        ty_cause.scope_span.or(Some(span)),
-                        "these are all the await points this ref is held through",
-                    );
+                    cx,
+                    AWAIT_HOLDING_REFCELL_REF,
+                    ty_cause.span,
+                    "this RefCell Ref is held across an 'await' point. Consider ensuring the Ref is dropped before calling await",
+                    ty_cause.scope_span.or(Some(span)),
+                    "these are all the await points this ref is held through",
+                );
             }
         }
     }
diff --git a/clippy_lints/src/float_literal.rs b/clippy_lints/src/float_literal.rs
index be646cbe4d0..8e256f34684 100644
--- a/clippy_lints/src/float_literal.rs
+++ b/clippy_lints/src/float_literal.rs
@@ -145,11 +145,7 @@ fn count_digits(s: &str) -> usize {
         .take_while(|c| *c != 'e' && *c != 'E')
         .fold(0, |count, c| {
             // leading zeros
-            if c == '0' && count == 0 {
-                count
-            } else {
-                count + 1
-            }
+            if c == '0' && count == 0 { count } else { count + 1 }
         })
 }
 
diff --git a/clippy_lints/src/infinite_iter.rs b/clippy_lints/src/infinite_iter.rs
index 129abd7d897..7040ac3191f 100644
--- a/clippy_lints/src/infinite_iter.rs
+++ b/clippy_lints/src/infinite_iter.rs
@@ -89,11 +89,7 @@ impl Finiteness {
 impl From<bool> for Finiteness {
     #[must_use]
     fn from(b: bool) -> Self {
-        if b {
-            Infinite
-        } else {
-            Finite
-        }
+        if b { Infinite } else { Finite }
     }
 }
 
diff --git a/clippy_lints/src/inherent_to_string.rs b/clippy_lints/src/inherent_to_string.rs
index a95321ea7e2..c1f3e1d9d68 100644
--- a/clippy_lints/src/inherent_to_string.rs
+++ b/clippy_lints/src/inherent_to_string.rs
@@ -139,7 +139,7 @@ fn show_lint(cx: &LateContext<'_>, item: &ImplItem<'_>) {
                 self_type.to_string()
             ),
             None,
-            &format!("remove the inherent method from type `{}`", self_type.to_string())
+            &format!("remove the inherent method from type `{}`", self_type.to_string()),
         );
     } else {
         span_lint_and_help(
diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
index 3ff9e182121..711cd5b3b15 100644
--- a/clippy_lints/src/loops.rs
+++ b/clippy_lints/src/loops.rs
@@ -3158,11 +3158,7 @@ fn detect_iter_and_into_iters<'tcx>(block: &'tcx Block<'tcx>, identifier: Ident)
         seen_other: false,
     };
     visitor.visit_block(block);
-    if visitor.seen_other {
-        None
-    } else {
-        Some(visitor.uses)
-    }
+    if visitor.seen_other { None } else { Some(visitor.uses) }
 }
 
 fn shorten_needless_collect_span(expr: &Expr<'_>) -> Span {
diff --git a/clippy_lints/src/mutable_debug_assertion.rs b/clippy_lints/src/mutable_debug_assertion.rs
index 76417aa7ed0..9ac127abe0a 100644
--- a/clippy_lints/src/mutable_debug_assertion.rs
+++ b/clippy_lints/src/mutable_debug_assertion.rs
@@ -73,11 +73,7 @@ impl<'a, 'tcx> MutArgVisitor<'a, 'tcx> {
     }
 
     fn expr_span(&self) -> Option<Span> {
-        if self.found {
-            self.expr_span
-        } else {
-            None
-        }
+        if self.found { self.expr_span } else { None }
     }
 }
 
diff --git a/clippy_lints/src/needless_continue.rs b/clippy_lints/src/needless_continue.rs
index 603071a5f4a..30fe2d6225c 100644
--- a/clippy_lints/src/needless_continue.rs
+++ b/clippy_lints/src/needless_continue.rs
@@ -416,11 +416,7 @@ fn erode_from_back(s: &str) -> String {
             break;
         }
     }
-    if ret.is_empty() {
-        s.to_string()
-    } else {
-        ret
-    }
+    if ret.is_empty() { s.to_string() } else { ret }
 }
 
 fn span_of_first_expr_in_block(block: &ast::Block) -> Option<Span> {
diff --git a/clippy_lints/src/open_options.rs b/clippy_lints/src/open_options.rs
index 73a99a3a2f8..07ca196990d 100644
--- a/clippy_lints/src/open_options.rs
+++ b/clippy_lints/src/open_options.rs
@@ -69,15 +69,11 @@ fn get_open_options(cx: &LateContext<'_>, argument: &Expr<'_>, options: &mut Vec
                         ..
                     } = *span
                     {
-                        if lit {
-                            Argument::True
-                        } else {
-                            Argument::False
-                        }
+                        if lit { Argument::True } else { Argument::False }
                     } else {
-                        return; // The function is called with a literal
-                                // which is not a boolean literal. This is theoretically
-                                // possible, but not very likely.
+                        // The function is called with a literal which is not a boolean literal.
+                        // This is theoretically possible, but not very likely.
+                        return;
                     }
                 },
                 _ => Argument::Unknown,
diff --git a/clippy_utils/src/camel_case.rs b/clippy_utils/src/camel_case.rs
index ba1c01ebc9f..a6636e39137 100644
--- a/clippy_utils/src/camel_case.rs
+++ b/clippy_utils/src/camel_case.rs
@@ -25,11 +25,7 @@ pub fn until(s: &str) -> usize {
             return i;
         }
     }
-    if up {
-        last_i
-    } else {
-        s.len()
-    }
+    if up { last_i } else { s.len() }
 }
 
 /// Returns index of the last camel-case component of `s`.
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 2380ea4c7bf..fbcc6d8dc4f 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -1563,12 +1563,12 @@ pub fn is_trait_impl_item(cx: &LateContext<'_>, hir_id: HirId) -> bool {
 /// ```
 pub fn fn_has_unsatisfiable_preds(cx: &LateContext<'_>, did: DefId) -> bool {
     use rustc_trait_selection::traits;
-    let predicates =
-        cx.tcx
-            .predicates_of(did)
-            .predicates
-            .iter()
-            .filter_map(|(p, _)| if p.is_global() { Some(*p) } else { None });
+    let predicates = cx
+        .tcx
+        .predicates_of(did)
+        .predicates
+        .iter()
+        .filter_map(|(p, _)| if p.is_global() { Some(*p) } else { None });
     traits::impossible_predicates(
         cx.tcx,
         traits::elaborate_predicates(cx.tcx, predicates)
diff --git a/clippy_utils/src/ptr.rs b/clippy_utils/src/ptr.rs
index baeff08e02c..df6143edbca 100644
--- a/clippy_utils/src/ptr.rs
+++ b/clippy_utils/src/ptr.rs
@@ -36,11 +36,7 @@ fn extract_clone_suggestions<'tcx>(
         abort: false,
     };
     visitor.visit_body(body);
-    if visitor.abort {
-        None
-    } else {
-        Some(visitor.spans)
-    }
+    if visitor.abort { None } else { Some(visitor.spans) }
 }
 
 struct PtrCloneVisitor<'a, 'tcx> {
diff --git a/rustfmt.toml b/rustfmt.toml
index f1241e74b0a..4b415a31b27 100644
--- a/rustfmt.toml
+++ b/rustfmt.toml
@@ -4,3 +4,4 @@ match_block_trailing_comma = true
 wrap_comments = true
 edition = "2018"
 error_on_line_overflow = true
+version = "Two"
diff --git a/tests/lint_message_convention.rs b/tests/lint_message_convention.rs
index 8c07c5b242f..3f754c255b7 100644
--- a/tests/lint_message_convention.rs
+++ b/tests/lint_message_convention.rs
@@ -98,7 +98,9 @@ fn lint_message_convention() {
         eprintln!("\n\n");
     });
 
-    eprintln!("\n\n\nLint message should not start with a capital letter and should not have punctuation at the end of the message unless multiple sentences are needed.");
+    eprintln!(
+        "\n\n\nLint message should not start with a capital letter and should not have punctuation at the end of the message unless multiple sentences are needed."
+    );
     eprintln!("Check out the rustc-dev-guide for more information:");
     eprintln!("https://rustc-dev-guide.rust-lang.org/diagnostics.html#diagnostic-structure\n\n\n");
 
diff --git a/tests/ui-toml/upper_case_acronyms_aggressive/upper_case_acronyms.rs b/tests/ui-toml/upper_case_acronyms_aggressive/upper_case_acronyms.rs
index fdf8905f812..735909887ac 100644
--- a/tests/ui-toml/upper_case_acronyms_aggressive/upper_case_acronyms.rs
+++ b/tests/ui-toml/upper_case_acronyms_aggressive/upper_case_acronyms.rs
@@ -16,7 +16,8 @@ enum Flags {
     FIN,
 }
 
-struct GCCLLVMSomething; // linted with cfg option, beware that lint suggests `GccllvmSomething` instead of
-                         // `GccLlvmSomething`
+// linted with cfg option, beware that lint suggests `GccllvmSomething` instead of
+// `GccLlvmSomething`
+struct GCCLLVMSomething;
 
 fn main() {}
diff --git a/tests/ui-toml/upper_case_acronyms_aggressive/upper_case_acronyms.stderr b/tests/ui-toml/upper_case_acronyms_aggressive/upper_case_acronyms.stderr
index 1cc59dc45f2..38e30683d57 100644
--- a/tests/ui-toml/upper_case_acronyms_aggressive/upper_case_acronyms.stderr
+++ b/tests/ui-toml/upper_case_acronyms_aggressive/upper_case_acronyms.stderr
@@ -61,9 +61,9 @@ LL |     FIN,
    |     ^^^ help: consider making the acronym lowercase, except the initial letter: `Fin`
 
 error: name `GCCLLVMSomething` contains a capitalized acronym
-  --> $DIR/upper_case_acronyms.rs:19:8
+  --> $DIR/upper_case_acronyms.rs:21:8
    |
-LL | struct GCCLLVMSomething; // linted with cfg option, beware that lint suggests `GccllvmSomething` instead of
+LL | struct GCCLLVMSomething;
    |        ^^^^^^^^^^^^^^^^ help: consider making the acronym lowercase, except the initial letter: `GccllvmSomething`
 
 error: aborting due to 11 previous errors
diff --git a/tests/ui/auxiliary/macro_rules.rs b/tests/ui/auxiliary/macro_rules.rs
index d6ecd8568ce..d4470d3f407 100644
--- a/tests/ui/auxiliary/macro_rules.rs
+++ b/tests/ui/auxiliary/macro_rules.rs
@@ -23,11 +23,7 @@ macro_rules! try_err {
         pub fn try_err_fn() -> Result<i32, i32> {
             let err: i32 = 1;
             // To avoid warnings during rustfix
-            if true {
-                Err(err)?
-            } else {
-                Ok(2)
-            }
+            if true { Err(err)? } else { Ok(2) }
         }
     };
 }
diff --git a/tests/ui/blocks_in_if_conditions.fixed b/tests/ui/blocks_in_if_conditions.fixed
index 14562c4d32c..e6e40a9948c 100644
--- a/tests/ui/blocks_in_if_conditions.fixed
+++ b/tests/ui/blocks_in_if_conditions.fixed
@@ -4,9 +4,7 @@
 #![warn(clippy::nonminimal_bool)]
 
 macro_rules! blocky {
-    () => {{
-        true
-    }};
+    () => {{ true }};
 }
 
 macro_rules! blocky_too {
@@ -34,20 +32,12 @@ fn condition_has_block() -> i32 {
 }
 
 fn condition_has_block_with_single_expression() -> i32 {
-    if true {
-        6
-    } else {
-        10
-    }
+    if true { 6 } else { 10 }
 }
 
 fn condition_is_normal() -> i32 {
     let x = 3;
-    if x == 3 {
-        6
-    } else {
-        10
-    }
+    if x == 3 { 6 } else { 10 }
 }
 
 fn condition_is_unsafe_block() {
@@ -61,14 +51,15 @@ fn condition_is_unsafe_block() {
 
 fn block_in_assert() {
     let opt = Some(42);
-    assert!(opt
-        .as_ref()
-        .map(|val| {
-            let mut v = val * 2;
-            v -= 1;
-            v * 3
-        })
-        .is_some());
+    assert!(
+        opt.as_ref()
+            .map(|val| {
+                let mut v = val * 2;
+                v -= 1;
+                v * 3
+            })
+            .is_some()
+    );
 }
 
 fn main() {}
diff --git a/tests/ui/blocks_in_if_conditions.rs b/tests/ui/blocks_in_if_conditions.rs
index bda87650f6d..69387ff5782 100644
--- a/tests/ui/blocks_in_if_conditions.rs
+++ b/tests/ui/blocks_in_if_conditions.rs
@@ -4,9 +4,7 @@
 #![warn(clippy::nonminimal_bool)]
 
 macro_rules! blocky {
-    () => {{
-        true
-    }};
+    () => {{ true }};
 }
 
 macro_rules! blocky_too {
@@ -34,20 +32,12 @@ fn condition_has_block() -> i32 {
 }
 
 fn condition_has_block_with_single_expression() -> i32 {
-    if { true } {
-        6
-    } else {
-        10
-    }
+    if { true } { 6 } else { 10 }
 }
 
 fn condition_is_normal() -> i32 {
     let x = 3;
-    if true && x == 3 {
-        6
-    } else {
-        10
-    }
+    if true && x == 3 { 6 } else { 10 }
 }
 
 fn condition_is_unsafe_block() {
@@ -61,14 +51,15 @@ fn condition_is_unsafe_block() {
 
 fn block_in_assert() {
     let opt = Some(42);
-    assert!(opt
-        .as_ref()
-        .map(|val| {
-            let mut v = val * 2;
-            v -= 1;
-            v * 3
-        })
-        .is_some());
+    assert!(
+        opt.as_ref()
+            .map(|val| {
+                let mut v = val * 2;
+                v -= 1;
+                v * 3
+            })
+            .is_some()
+    );
 }
 
 fn main() {}
diff --git a/tests/ui/blocks_in_if_conditions.stderr b/tests/ui/blocks_in_if_conditions.stderr
index 9bdddc8e152..9328492733f 100644
--- a/tests/ui/blocks_in_if_conditions.stderr
+++ b/tests/ui/blocks_in_if_conditions.stderr
@@ -1,5 +1,5 @@
 error: in an `if` condition, avoid complex blocks or closures with blocks; instead, move the block or closure higher and bind it with a `let`
-  --> $DIR/blocks_in_if_conditions.rs:26:5
+  --> $DIR/blocks_in_if_conditions.rs:24:5
    |
 LL | /     if {
 LL | |         let x = 3;
@@ -17,15 +17,15 @@ LL |     }; if res {
    |
 
 error: omit braces around single expression condition
-  --> $DIR/blocks_in_if_conditions.rs:37:8
+  --> $DIR/blocks_in_if_conditions.rs:35:8
    |
-LL |     if { true } {
+LL |     if { true } { 6 } else { 10 }
    |        ^^^^^^^^ help: try: `true`
 
 error: this boolean expression can be simplified
-  --> $DIR/blocks_in_if_conditions.rs:46:8
+  --> $DIR/blocks_in_if_conditions.rs:40:8
    |
-LL |     if true && x == 3 {
+LL |     if true && x == 3 { 6 } else { 10 }
    |        ^^^^^^^^^^^^^^ help: try: `x == 3`
    |
    = note: `-D clippy::nonminimal-bool` implied by `-D warnings`
diff --git a/tests/ui/checked_unwrap/simple_conditionals.rs b/tests/ui/checked_unwrap/simple_conditionals.rs
index 3e7b4b390ba..36967630834 100644
--- a/tests/ui/checked_unwrap/simple_conditionals.rs
+++ b/tests/ui/checked_unwrap/simple_conditionals.rs
@@ -66,14 +66,16 @@ fn main() {
     }
     if x.is_ok() {
         x = Err(());
-        x.unwrap(); // not unnecessary because of mutation of x
-                    // it will always panic but the lint is not smart enough to see this (it only
-                    // checks if conditions).
+        // not unnecessary because of mutation of x
+        // it will always panic but the lint is not smart enough to see this (it only
+        // checks if conditions).
+        x.unwrap();
     } else {
         x = Ok(());
-        x.unwrap_err(); // not unnecessary because of mutation of x
-                        // it will always panic but the lint is not smart enough to see this (it
-                        // only checks if conditions).
+        // not unnecessary because of mutation of x
+        // it will always panic but the lint is not smart enough to see this (it
+        // only checks if conditions).
+        x.unwrap_err();
     }
 
     assert!(x.is_ok(), "{:?}", x.unwrap_err()); // ok, it's a common test pattern
diff --git a/tests/ui/crashes/ice-6256.rs b/tests/ui/crashes/ice-6256.rs
index 5409f36b3f1..67308263dad 100644
--- a/tests/ui/crashes/ice-6256.rs
+++ b/tests/ui/crashes/ice-6256.rs
@@ -8,6 +8,7 @@ impl dyn TT {
     fn func(&self) {}
 }
 
+#[rustfmt::skip]
 fn main() {
     let f = |x: &dyn TT| x.func(); //[default]~ ERROR: mismatched types
                                    //[nll]~^ ERROR: borrowed data escapes outside of closure
diff --git a/tests/ui/crashes/ice-6256.stderr b/tests/ui/crashes/ice-6256.stderr
index d1a8bdc3c8d..d35d459168f 100644
--- a/tests/ui/crashes/ice-6256.stderr
+++ b/tests/ui/crashes/ice-6256.stderr
@@ -1,13 +1,13 @@
 error[E0308]: mismatched types
-  --> $DIR/ice-6256.rs:12:28
+  --> $DIR/ice-6256.rs:13:28
    |
 LL |     let f = |x: &dyn TT| x.func(); //[default]~ ERROR: mismatched types
    |                            ^^^^ lifetime mismatch
    |
    = note: expected reference `&(dyn TT + 'static)`
               found reference `&dyn TT`
-note: the anonymous lifetime #1 defined on the body at 12:13...
-  --> $DIR/ice-6256.rs:12:13
+note: the anonymous lifetime #1 defined on the body at 13:13...
+  --> $DIR/ice-6256.rs:13:13
    |
 LL |     let f = |x: &dyn TT| x.func(); //[default]~ ERROR: mismatched types
    |             ^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/dbg_macro.rs b/tests/ui/dbg_macro.rs
index d2df7fbd3e8..d74e2611ee1 100644
--- a/tests/ui/dbg_macro.rs
+++ b/tests/ui/dbg_macro.rs
@@ -1,11 +1,7 @@
 #![warn(clippy::dbg_macro)]
 
 fn foo(n: u32) -> u32 {
-    if let Some(n) = dbg!(n.checked_sub(4)) {
-        n
-    } else {
-        n
-    }
+    if let Some(n) = dbg!(n.checked_sub(4)) { n } else { n }
 }
 
 fn factorial(n: u32) -> u32 {
diff --git a/tests/ui/dbg_macro.stderr b/tests/ui/dbg_macro.stderr
index b8aafe96678..bdf372af290 100644
--- a/tests/ui/dbg_macro.stderr
+++ b/tests/ui/dbg_macro.stderr
@@ -1,17 +1,17 @@
 error: `dbg!` macro is intended as a debugging tool
   --> $DIR/dbg_macro.rs:4:22
    |
-LL |     if let Some(n) = dbg!(n.checked_sub(4)) {
+LL |     if let Some(n) = dbg!(n.checked_sub(4)) { n } else { n }
    |                      ^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::dbg-macro` implied by `-D warnings`
 help: ensure to avoid having uses of it in version control
    |
-LL |     if let Some(n) = n.checked_sub(4) {
+LL |     if let Some(n) = n.checked_sub(4) { n } else { n }
    |                      ^^^^^^^^^^^^^^^^
 
 error: `dbg!` macro is intended as a debugging tool
-  --> $DIR/dbg_macro.rs:12:8
+  --> $DIR/dbg_macro.rs:8:8
    |
 LL |     if dbg!(n <= 1) {
    |        ^^^^^^^^^^^^
@@ -22,7 +22,7 @@ LL |     if n <= 1 {
    |        ^^^^^^
 
 error: `dbg!` macro is intended as a debugging tool
-  --> $DIR/dbg_macro.rs:13:9
+  --> $DIR/dbg_macro.rs:9:9
    |
 LL |         dbg!(1)
    |         ^^^^^^^
@@ -33,7 +33,7 @@ LL |         1
    |
 
 error: `dbg!` macro is intended as a debugging tool
-  --> $DIR/dbg_macro.rs:15:9
+  --> $DIR/dbg_macro.rs:11:9
    |
 LL |         dbg!(n * factorial(n - 1))
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -44,7 +44,7 @@ LL |         n * factorial(n - 1)
    |
 
 error: `dbg!` macro is intended as a debugging tool
-  --> $DIR/dbg_macro.rs:20:5
+  --> $DIR/dbg_macro.rs:16:5
    |
 LL |     dbg!(42);
    |     ^^^^^^^^
@@ -55,7 +55,7 @@ LL |     42;
    |     ^^
 
 error: `dbg!` macro is intended as a debugging tool
-  --> $DIR/dbg_macro.rs:21:5
+  --> $DIR/dbg_macro.rs:17:5
    |
 LL |     dbg!(dbg!(dbg!(42)));
    |     ^^^^^^^^^^^^^^^^^^^^
@@ -66,7 +66,7 @@ LL |     dbg!(dbg!(42));
    |     ^^^^^^^^^^^^^^
 
 error: `dbg!` macro is intended as a debugging tool
-  --> $DIR/dbg_macro.rs:22:14
+  --> $DIR/dbg_macro.rs:18:14
    |
 LL |     foo(3) + dbg!(factorial(4));
    |              ^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/default_trait_access.fixed b/tests/ui/default_trait_access.fixed
index d05567a3f82..4c80cabc723 100644
--- a/tests/ui/default_trait_access.fixed
+++ b/tests/ui/default_trait_access.fixed
@@ -48,25 +48,7 @@ fn main() {
 
     println!(
         "[{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}] [{:?}] [{:?}] [{:?}] [{:?}] [{:?}] [{:?}] [{:?}] [{:?}] [{:?}], [{:?}]",
-        s1,
-        s2,
-        s3,
-        s4,
-        s5,
-        s6,
-        s7,
-        s8,
-        s9,
-        s10,
-        s11,
-        s12,
-        s13,
-        s14,
-        s15,
-        s16,
-        s17,
-        s18,
-        s19,
+        s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17, s18, s19,
     );
 }
 
diff --git a/tests/ui/default_trait_access.rs b/tests/ui/default_trait_access.rs
index 447e70c0bbb..a68b6455c04 100644
--- a/tests/ui/default_trait_access.rs
+++ b/tests/ui/default_trait_access.rs
@@ -48,25 +48,7 @@ fn main() {
 
     println!(
         "[{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}] [{:?}] [{:?}] [{:?}] [{:?}] [{:?}] [{:?}] [{:?}] [{:?}] [{:?}], [{:?}]",
-        s1,
-        s2,
-        s3,
-        s4,
-        s5,
-        s6,
-        s7,
-        s8,
-        s9,
-        s10,
-        s11,
-        s12,
-        s13,
-        s14,
-        s15,
-        s16,
-        s17,
-        s18,
-        s19,
+        s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17, s18, s19,
     );
 }
 
diff --git a/tests/ui/doc_panics.rs b/tests/ui/doc_panics.rs
index 3008c2d5b85..17e72353f80 100644
--- a/tests/ui/doc_panics.rs
+++ b/tests/ui/doc_panics.rs
@@ -30,11 +30,7 @@ pub fn inner_body(opt: Option<u32>) {
 
 /// This needs to be documented
 pub fn unreachable_and_panic() {
-    if true {
-        unreachable!()
-    } else {
-        panic!()
-    }
+    if true { unreachable!() } else { panic!() }
 }
 
 /// This is documented
@@ -84,11 +80,7 @@ pub fn todo_documented() {
 ///
 /// We still need to do this part
 pub fn unreachable_amd_panic_documented() {
-    if true {
-        unreachable!()
-    } else {
-        panic!()
-    }
+    if true { unreachable!() } else { panic!() }
 }
 
 /// This is okay because it is private
diff --git a/tests/ui/doc_panics.stderr b/tests/ui/doc_panics.stderr
index 287148690d2..2fa88a2f6ec 100644
--- a/tests/ui/doc_panics.stderr
+++ b/tests/ui/doc_panics.stderr
@@ -67,19 +67,15 @@ error: docs for function which may panic missing `# Panics` section
   --> $DIR/doc_panics.rs:32:1
    |
 LL | / pub fn unreachable_and_panic() {
-LL | |     if true {
-LL | |         unreachable!()
-LL | |     } else {
-LL | |         panic!()
-LL | |     }
+LL | |     if true { unreachable!() } else { panic!() }
 LL | | }
    | |_^
    |
 note: first possible panic found here
-  --> $DIR/doc_panics.rs:36:9
+  --> $DIR/doc_panics.rs:33:39
    |
-LL |         panic!()
-   |         ^^^^^^^^
+LL |     if true { unreachable!() } else { panic!() }
+   |                                       ^^^^^^^^
    = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: aborting due to 5 previous errors
diff --git a/tests/ui/float_cmp.rs b/tests/ui/float_cmp.rs
index 586784b73e6..ad5d1a09c03 100644
--- a/tests/ui/float_cmp.rs
+++ b/tests/ui/float_cmp.rs
@@ -21,19 +21,11 @@ where
 }
 
 fn eq_fl(x: f32, y: f32) -> bool {
-    if x.is_nan() {
-        y.is_nan()
-    } else {
-        x == y
-    } // no error, inside "eq" fn
+    if x.is_nan() { y.is_nan() } else { x == y } // no error, inside "eq" fn
 }
 
 fn fl_eq(x: f32, y: f32) -> bool {
-    if x.is_nan() {
-        y.is_nan()
-    } else {
-        x == y
-    } // no error, inside "eq" fn
+    if x.is_nan() { y.is_nan() } else { x == y } // no error, inside "eq" fn
 }
 
 struct X {
diff --git a/tests/ui/float_cmp.stderr b/tests/ui/float_cmp.stderr
index bb4051c4662..cb5b68b2e95 100644
--- a/tests/ui/float_cmp.stderr
+++ b/tests/ui/float_cmp.stderr
@@ -1,5 +1,5 @@
 error: strict comparison of `f32` or `f64`
-  --> $DIR/float_cmp.rs:66:5
+  --> $DIR/float_cmp.rs:58:5
    |
 LL |     ONE as f64 != 2.0;
    |     ^^^^^^^^^^^^^^^^^ help: consider comparing them within some margin of error: `(ONE as f64 - 2.0).abs() > error_margin`
@@ -8,7 +8,7 @@ LL |     ONE as f64 != 2.0;
    = note: `f32::EPSILON` and `f64::EPSILON` are available for the `error_margin`
 
 error: strict comparison of `f32` or `f64`
-  --> $DIR/float_cmp.rs:71:5
+  --> $DIR/float_cmp.rs:63:5
    |
 LL |     x == 1.0;
    |     ^^^^^^^^ help: consider comparing them within some margin of error: `(x - 1.0).abs() < error_margin`
@@ -16,7 +16,7 @@ LL |     x == 1.0;
    = note: `f32::EPSILON` and `f64::EPSILON` are available for the `error_margin`
 
 error: strict comparison of `f32` or `f64`
-  --> $DIR/float_cmp.rs:74:5
+  --> $DIR/float_cmp.rs:66:5
    |
 LL |     twice(x) != twice(ONE as f64);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider comparing them within some margin of error: `(twice(x) - twice(ONE as f64)).abs() > error_margin`
@@ -24,7 +24,7 @@ LL |     twice(x) != twice(ONE as f64);
    = note: `f32::EPSILON` and `f64::EPSILON` are available for the `error_margin`
 
 error: strict comparison of `f32` or `f64`
-  --> $DIR/float_cmp.rs:94:5
+  --> $DIR/float_cmp.rs:86:5
    |
 LL |     NON_ZERO_ARRAY[i] == NON_ZERO_ARRAY[j];
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider comparing them within some margin of error: `(NON_ZERO_ARRAY[i] - NON_ZERO_ARRAY[j]).abs() < error_margin`
@@ -32,7 +32,7 @@ LL |     NON_ZERO_ARRAY[i] == NON_ZERO_ARRAY[j];
    = note: `f32::EPSILON` and `f64::EPSILON` are available for the `error_margin`
 
 error: strict comparison of `f32` or `f64` arrays
-  --> $DIR/float_cmp.rs:99:5
+  --> $DIR/float_cmp.rs:91:5
    |
 LL |     a1 == a2;
    |     ^^^^^^^^
@@ -40,7 +40,7 @@ LL |     a1 == a2;
    = note: `f32::EPSILON` and `f64::EPSILON` are available for the `error_margin`
 
 error: strict comparison of `f32` or `f64`
-  --> $DIR/float_cmp.rs:100:5
+  --> $DIR/float_cmp.rs:92:5
    |
 LL |     a1[0] == a2[0];
    |     ^^^^^^^^^^^^^^ help: consider comparing them within some margin of error: `(a1[0] - a2[0]).abs() < error_margin`
diff --git a/tests/ui/float_cmp_const.rs b/tests/ui/float_cmp_const.rs
index 263d9a7b92d..86ce3bf3bd9 100644
--- a/tests/ui/float_cmp_const.rs
+++ b/tests/ui/float_cmp_const.rs
@@ -8,11 +8,7 @@ const ONE: f32 = 1.0;
 const TWO: f32 = 2.0;
 
 fn eq_one(x: f32) -> bool {
-    if x.is_nan() {
-        false
-    } else {
-        x == ONE
-    } // no error, inside "eq" fn
+    if x.is_nan() { false } else { x == ONE } // no error, inside "eq" fn
 }
 
 fn main() {
diff --git a/tests/ui/float_cmp_const.stderr b/tests/ui/float_cmp_const.stderr
index 5d0455363e8..d8182cf855b 100644
--- a/tests/ui/float_cmp_const.stderr
+++ b/tests/ui/float_cmp_const.stderr
@@ -1,5 +1,5 @@
 error: strict comparison of `f32` or `f64` constant
-  --> $DIR/float_cmp_const.rs:20:5
+  --> $DIR/float_cmp_const.rs:16:5
    |
 LL |     1f32 == ONE;
    |     ^^^^^^^^^^^ help: consider comparing them within some margin of error: `(1f32 - ONE).abs() < error_margin`
@@ -8,7 +8,7 @@ LL |     1f32 == ONE;
    = note: `f32::EPSILON` and `f64::EPSILON` are available for the `error_margin`
 
 error: strict comparison of `f32` or `f64` constant
-  --> $DIR/float_cmp_const.rs:21:5
+  --> $DIR/float_cmp_const.rs:17:5
    |
 LL |     TWO == ONE;
    |     ^^^^^^^^^^ help: consider comparing them within some margin of error: `(TWO - ONE).abs() < error_margin`
@@ -16,7 +16,7 @@ LL |     TWO == ONE;
    = note: `f32::EPSILON` and `f64::EPSILON` are available for the `error_margin`
 
 error: strict comparison of `f32` or `f64` constant
-  --> $DIR/float_cmp_const.rs:22:5
+  --> $DIR/float_cmp_const.rs:18:5
    |
 LL |     TWO != ONE;
    |     ^^^^^^^^^^ help: consider comparing them within some margin of error: `(TWO - ONE).abs() > error_margin`
@@ -24,7 +24,7 @@ LL |     TWO != ONE;
    = note: `f32::EPSILON` and `f64::EPSILON` are available for the `error_margin`
 
 error: strict comparison of `f32` or `f64` constant
-  --> $DIR/float_cmp_const.rs:23:5
+  --> $DIR/float_cmp_const.rs:19:5
    |
 LL |     ONE + ONE == TWO;
    |     ^^^^^^^^^^^^^^^^ help: consider comparing them within some margin of error: `(ONE + ONE - TWO).abs() < error_margin`
@@ -32,7 +32,7 @@ LL |     ONE + ONE == TWO;
    = note: `f32::EPSILON` and `f64::EPSILON` are available for the `error_margin`
 
 error: strict comparison of `f32` or `f64` constant
-  --> $DIR/float_cmp_const.rs:25:5
+  --> $DIR/float_cmp_const.rs:21:5
    |
 LL |     x as f32 == ONE;
    |     ^^^^^^^^^^^^^^^ help: consider comparing them within some margin of error: `(x as f32 - ONE).abs() < error_margin`
@@ -40,7 +40,7 @@ LL |     x as f32 == ONE;
    = note: `f32::EPSILON` and `f64::EPSILON` are available for the `error_margin`
 
 error: strict comparison of `f32` or `f64` constant
-  --> $DIR/float_cmp_const.rs:28:5
+  --> $DIR/float_cmp_const.rs:24:5
    |
 LL |     v == ONE;
    |     ^^^^^^^^ help: consider comparing them within some margin of error: `(v - ONE).abs() < error_margin`
@@ -48,7 +48,7 @@ LL |     v == ONE;
    = note: `f32::EPSILON` and `f64::EPSILON` are available for the `error_margin`
 
 error: strict comparison of `f32` or `f64` constant
-  --> $DIR/float_cmp_const.rs:29:5
+  --> $DIR/float_cmp_const.rs:25:5
    |
 LL |     v != ONE;
    |     ^^^^^^^^ help: consider comparing them within some margin of error: `(v - ONE).abs() > error_margin`
@@ -56,7 +56,7 @@ LL |     v != ONE;
    = note: `f32::EPSILON` and `f64::EPSILON` are available for the `error_margin`
 
 error: strict comparison of `f32` or `f64` constant arrays
-  --> $DIR/float_cmp_const.rs:61:5
+  --> $DIR/float_cmp_const.rs:57:5
    |
 LL |     NON_ZERO_ARRAY == NON_ZERO_ARRAY2;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/floating_point_abs.fixed b/tests/ui/floating_point_abs.fixed
index b623e4988e7..cea727257c4 100644
--- a/tests/ui/floating_point_abs.fixed
+++ b/tests/ui/floating_point_abs.fixed
@@ -42,43 +42,23 @@ fn fake_nabs3(a: A) -> A {
 }
 
 fn not_fake_abs1(num: f64) -> f64 {
-    if num > 0.0 {
-        num
-    } else {
-        -num - 1f64
-    }
+    if num > 0.0 { num } else { -num - 1f64 }
 }
 
 fn not_fake_abs2(num: f64) -> f64 {
-    if num > 0.0 {
-        num + 1.0
-    } else {
-        -(num + 1.0)
-    }
+    if num > 0.0 { num + 1.0 } else { -(num + 1.0) }
 }
 
 fn not_fake_abs3(num1: f64, num2: f64) -> f64 {
-    if num1 > 0.0 {
-        num2
-    } else {
-        -num2
-    }
+    if num1 > 0.0 { num2 } else { -num2 }
 }
 
 fn not_fake_abs4(a: A) -> f64 {
-    if a.a > 0.0 {
-        a.b
-    } else {
-        -a.b
-    }
+    if a.a > 0.0 { a.b } else { -a.b }
 }
 
 fn not_fake_abs5(a: A) -> f64 {
-    if a.a > 0.0 {
-        a.a
-    } else {
-        -a.b
-    }
+    if a.a > 0.0 { a.a } else { -a.b }
 }
 
 fn main() {
diff --git a/tests/ui/floating_point_abs.rs b/tests/ui/floating_point_abs.rs
index cbf9c94e41e..ba8a8f18fa2 100644
--- a/tests/ui/floating_point_abs.rs
+++ b/tests/ui/floating_point_abs.rs
@@ -7,59 +7,31 @@ struct A {
 }
 
 fn fake_abs1(num: f64) -> f64 {
-    if num >= 0.0 {
-        num
-    } else {
-        -num
-    }
+    if num >= 0.0 { num } else { -num }
 }
 
 fn fake_abs2(num: f64) -> f64 {
-    if 0.0 < num {
-        num
-    } else {
-        -num
-    }
+    if 0.0 < num { num } else { -num }
 }
 
 fn fake_abs3(a: A) -> f64 {
-    if a.a > 0.0 {
-        a.a
-    } else {
-        -a.a
-    }
+    if a.a > 0.0 { a.a } else { -a.a }
 }
 
 fn fake_abs4(num: f64) -> f64 {
-    if 0.0 >= num {
-        -num
-    } else {
-        num
-    }
+    if 0.0 >= num { -num } else { num }
 }
 
 fn fake_abs5(a: A) -> f64 {
-    if a.a < 0.0 {
-        -a.a
-    } else {
-        a.a
-    }
+    if a.a < 0.0 { -a.a } else { a.a }
 }
 
 fn fake_nabs1(num: f64) -> f64 {
-    if num < 0.0 {
-        num
-    } else {
-        -num
-    }
+    if num < 0.0 { num } else { -num }
 }
 
 fn fake_nabs2(num: f64) -> f64 {
-    if 0.0 >= num {
-        num
-    } else {
-        -num
-    }
+    if 0.0 >= num { num } else { -num }
 }
 
 fn fake_nabs3(a: A) -> A {
@@ -70,43 +42,23 @@ fn fake_nabs3(a: A) -> A {
 }
 
 fn not_fake_abs1(num: f64) -> f64 {
-    if num > 0.0 {
-        num
-    } else {
-        -num - 1f64
-    }
+    if num > 0.0 { num } else { -num - 1f64 }
 }
 
 fn not_fake_abs2(num: f64) -> f64 {
-    if num > 0.0 {
-        num + 1.0
-    } else {
-        -(num + 1.0)
-    }
+    if num > 0.0 { num + 1.0 } else { -(num + 1.0) }
 }
 
 fn not_fake_abs3(num1: f64, num2: f64) -> f64 {
-    if num1 > 0.0 {
-        num2
-    } else {
-        -num2
-    }
+    if num1 > 0.0 { num2 } else { -num2 }
 }
 
 fn not_fake_abs4(a: A) -> f64 {
-    if a.a > 0.0 {
-        a.b
-    } else {
-        -a.b
-    }
+    if a.a > 0.0 { a.b } else { -a.b }
 }
 
 fn not_fake_abs5(a: A) -> f64 {
-    if a.a > 0.0 {
-        a.a
-    } else {
-        -a.b
-    }
+    if a.a > 0.0 { a.a } else { -a.b }
 }
 
 fn main() {
diff --git a/tests/ui/floating_point_abs.stderr b/tests/ui/floating_point_abs.stderr
index 74a71f2ca7c..35af70201fa 100644
--- a/tests/ui/floating_point_abs.stderr
+++ b/tests/ui/floating_point_abs.stderr
@@ -1,77 +1,49 @@
 error: manual implementation of `abs` method
   --> $DIR/floating_point_abs.rs:10:5
    |
-LL | /     if num >= 0.0 {
-LL | |         num
-LL | |     } else {
-LL | |         -num
-LL | |     }
-   | |_____^ help: try: `num.abs()`
+LL |     if num >= 0.0 { num } else { -num }
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `num.abs()`
    |
    = note: `-D clippy::suboptimal-flops` implied by `-D warnings`
 
 error: manual implementation of `abs` method
-  --> $DIR/floating_point_abs.rs:18:5
+  --> $DIR/floating_point_abs.rs:14:5
    |
-LL | /     if 0.0 < num {
-LL | |         num
-LL | |     } else {
-LL | |         -num
-LL | |     }
-   | |_____^ help: try: `num.abs()`
+LL |     if 0.0 < num { num } else { -num }
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `num.abs()`
 
 error: manual implementation of `abs` method
-  --> $DIR/floating_point_abs.rs:26:5
+  --> $DIR/floating_point_abs.rs:18:5
    |
-LL | /     if a.a > 0.0 {
-LL | |         a.a
-LL | |     } else {
-LL | |         -a.a
-LL | |     }
-   | |_____^ help: try: `a.a.abs()`
+LL |     if a.a > 0.0 { a.a } else { -a.a }
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `a.a.abs()`
 
 error: manual implementation of `abs` method
-  --> $DIR/floating_point_abs.rs:34:5
+  --> $DIR/floating_point_abs.rs:22:5
    |
-LL | /     if 0.0 >= num {
-LL | |         -num
-LL | |     } else {
-LL | |         num
-LL | |     }
-   | |_____^ help: try: `num.abs()`
+LL |     if 0.0 >= num { -num } else { num }
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `num.abs()`
 
 error: manual implementation of `abs` method
-  --> $DIR/floating_point_abs.rs:42:5
+  --> $DIR/floating_point_abs.rs:26:5
    |
-LL | /     if a.a < 0.0 {
-LL | |         -a.a
-LL | |     } else {
-LL | |         a.a
-LL | |     }
-   | |_____^ help: try: `a.a.abs()`
+LL |     if a.a < 0.0 { -a.a } else { a.a }
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `a.a.abs()`
 
 error: manual implementation of negation of `abs` method
-  --> $DIR/floating_point_abs.rs:50:5
+  --> $DIR/floating_point_abs.rs:30:5
    |
-LL | /     if num < 0.0 {
-LL | |         num
-LL | |     } else {
-LL | |         -num
-LL | |     }
-   | |_____^ help: try: `-num.abs()`
+LL |     if num < 0.0 { num } else { -num }
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `-num.abs()`
 
 error: manual implementation of negation of `abs` method
-  --> $DIR/floating_point_abs.rs:58:5
+  --> $DIR/floating_point_abs.rs:34:5
    |
-LL | /     if 0.0 >= num {
-LL | |         num
-LL | |     } else {
-LL | |         -num
-LL | |     }
-   | |_____^ help: try: `-num.abs()`
+LL |     if 0.0 >= num { num } else { -num }
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `-num.abs()`
 
 error: manual implementation of negation of `abs` method
-  --> $DIR/floating_point_abs.rs:67:12
+  --> $DIR/floating_point_abs.rs:39:12
    |
 LL |         a: if a.a >= 0.0 { -a.a } else { a.a },
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `-a.a.abs()`
diff --git a/tests/ui/if_let_some_result.fixed b/tests/ui/if_let_some_result.fixed
index 80505fd997f..62a25ce2d12 100644
--- a/tests/ui/if_let_some_result.fixed
+++ b/tests/ui/if_let_some_result.fixed
@@ -3,19 +3,11 @@
 #![warn(clippy::if_let_some_result)]
 
 fn str_to_int(x: &str) -> i32 {
-    if let Ok(y) = x.parse() {
-        y
-    } else {
-        0
-    }
+    if let Ok(y) = x.parse() { y } else { 0 }
 }
 
 fn str_to_int_ok(x: &str) -> i32 {
-    if let Ok(y) = x.parse() {
-        y
-    } else {
-        0
-    }
+    if let Ok(y) = x.parse() { y } else { 0 }
 }
 
 #[rustfmt::skip]
diff --git a/tests/ui/if_let_some_result.rs b/tests/ui/if_let_some_result.rs
index ecac1357445..234ff5e9e80 100644
--- a/tests/ui/if_let_some_result.rs
+++ b/tests/ui/if_let_some_result.rs
@@ -3,19 +3,11 @@
 #![warn(clippy::if_let_some_result)]
 
 fn str_to_int(x: &str) -> i32 {
-    if let Some(y) = x.parse().ok() {
-        y
-    } else {
-        0
-    }
+    if let Some(y) = x.parse().ok() { y } else { 0 }
 }
 
 fn str_to_int_ok(x: &str) -> i32 {
-    if let Ok(y) = x.parse() {
-        y
-    } else {
-        0
-    }
+    if let Ok(y) = x.parse() { y } else { 0 }
 }
 
 #[rustfmt::skip]
diff --git a/tests/ui/if_let_some_result.stderr b/tests/ui/if_let_some_result.stderr
index 6afee0f36b9..0646dd27f35 100644
--- a/tests/ui/if_let_some_result.stderr
+++ b/tests/ui/if_let_some_result.stderr
@@ -1,17 +1,17 @@
 error: matching on `Some` with `ok()` is redundant
   --> $DIR/if_let_some_result.rs:6:5
    |
-LL |     if let Some(y) = x.parse().ok() {
+LL |     if let Some(y) = x.parse().ok() { y } else { 0 }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::if-let-some-result` implied by `-D warnings`
 help: consider matching on `Ok(y)` and removing the call to `ok` instead
    |
-LL |     if let Ok(y) = x.parse() {
+LL |     if let Ok(y) = x.parse() { y } else { 0 }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: matching on `Some` with `ok()` is redundant
-  --> $DIR/if_let_some_result.rs:24:9
+  --> $DIR/if_let_some_result.rs:16:9
    |
 LL |         if let Some(y) = x   .   parse()   .   ok   ()    {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/implicit_return.fixed b/tests/ui/implicit_return.fixed
index 9066dc3fedf..59f7ad9c106 100644
--- a/tests/ui/implicit_return.fixed
+++ b/tests/ui/implicit_return.fixed
@@ -14,11 +14,7 @@ fn test_end_of_fn() -> bool {
 
 #[allow(clippy::needless_bool)]
 fn test_if_block() -> bool {
-    if true {
-        return true
-    } else {
-        return false
-    }
+    if true { return true } else { return false }
 }
 
 #[rustfmt::skip]
diff --git a/tests/ui/implicit_return.rs b/tests/ui/implicit_return.rs
index c0d70ecf502..2c1bc046515 100644
--- a/tests/ui/implicit_return.rs
+++ b/tests/ui/implicit_return.rs
@@ -14,11 +14,7 @@ fn test_end_of_fn() -> bool {
 
 #[allow(clippy::needless_bool)]
 fn test_if_block() -> bool {
-    if true {
-        true
-    } else {
-        false
-    }
+    if true { true } else { false }
 }
 
 #[rustfmt::skip]
diff --git a/tests/ui/implicit_return.stderr b/tests/ui/implicit_return.stderr
index fb2ec902764..3608319e5bd 100644
--- a/tests/ui/implicit_return.stderr
+++ b/tests/ui/implicit_return.stderr
@@ -7,61 +7,61 @@ LL |     true
    = note: `-D clippy::implicit-return` implied by `-D warnings`
 
 error: missing `return` statement
-  --> $DIR/implicit_return.rs:18:9
+  --> $DIR/implicit_return.rs:17:15
    |
-LL |         true
-   |         ^^^^ help: add `return` as shown: `return true`
+LL |     if true { true } else { false }
+   |               ^^^^ help: add `return` as shown: `return true`
 
 error: missing `return` statement
-  --> $DIR/implicit_return.rs:20:9
+  --> $DIR/implicit_return.rs:17:29
    |
-LL |         false
-   |         ^^^^^ help: add `return` as shown: `return false`
+LL |     if true { true } else { false }
+   |                             ^^^^^ help: add `return` as shown: `return false`
 
 error: missing `return` statement
-  --> $DIR/implicit_return.rs:27:17
+  --> $DIR/implicit_return.rs:23:17
    |
 LL |         true => false,
    |                 ^^^^^ help: add `return` as shown: `return false`
 
 error: missing `return` statement
-  --> $DIR/implicit_return.rs:28:20
+  --> $DIR/implicit_return.rs:24:20
    |
 LL |         false => { true },
    |                    ^^^^ help: add `return` as shown: `return true`
 
 error: missing `return` statement
-  --> $DIR/implicit_return.rs:43:9
+  --> $DIR/implicit_return.rs:39:9
    |
 LL |         break true;
    |         ^^^^^^^^^^ help: change `break` to `return` as shown: `return true`
 
 error: missing `return` statement
-  --> $DIR/implicit_return.rs:51:13
+  --> $DIR/implicit_return.rs:47:13
    |
 LL |             break true;
    |             ^^^^^^^^^^ help: change `break` to `return` as shown: `return true`
 
 error: missing `return` statement
-  --> $DIR/implicit_return.rs:60:13
+  --> $DIR/implicit_return.rs:56:13
    |
 LL |             break true;
    |             ^^^^^^^^^^ help: change `break` to `return` as shown: `return true`
 
 error: missing `return` statement
-  --> $DIR/implicit_return.rs:78:18
+  --> $DIR/implicit_return.rs:74:18
    |
 LL |     let _ = || { true };
    |                  ^^^^ help: add `return` as shown: `return true`
 
 error: missing `return` statement
-  --> $DIR/implicit_return.rs:79:16
+  --> $DIR/implicit_return.rs:75:16
    |
 LL |     let _ = || true;
    |                ^^^^ help: add `return` as shown: `return true`
 
 error: missing `return` statement
-  --> $DIR/implicit_return.rs:87:5
+  --> $DIR/implicit_return.rs:83:5
    |
 LL |     format!("test {}", "test")
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: add `return` as shown: `return format!("test {}", "test")`
diff --git a/tests/ui/needless_lifetimes.rs b/tests/ui/needless_lifetimes.rs
index 44972c8c639..bda0801e51c 100644
--- a/tests/ui/needless_lifetimes.rs
+++ b/tests/ui/needless_lifetimes.rs
@@ -105,11 +105,7 @@ fn fn_bound_3_cannot_elide() {
 
 // No error; multiple input refs.
 fn fn_bound_4<'a, F: FnOnce() -> &'a ()>(cond: bool, x: &'a (), f: F) -> &'a () {
-    if cond {
-        x
-    } else {
-        f()
-    }
+    if cond { x } else { f() }
 }
 
 struct X {
diff --git a/tests/ui/needless_lifetimes.stderr b/tests/ui/needless_lifetimes.stderr
index c8a2e8b81c0..33a6de1618d 100644
--- a/tests/ui/needless_lifetimes.stderr
+++ b/tests/ui/needless_lifetimes.stderr
@@ -43,109 +43,109 @@ LL | fn fn_bound_2<'a, F, I>(_m: Lt<'a, I>, _f: F) -> Lt<'a, I>
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
-  --> $DIR/needless_lifetimes.rs:120:5
+  --> $DIR/needless_lifetimes.rs:116:5
    |
 LL |     fn self_and_out<'s>(&'s self) -> &'s u8 {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
-  --> $DIR/needless_lifetimes.rs:129:5
+  --> $DIR/needless_lifetimes.rs:125:5
    |
 LL |     fn distinct_self_and_in<'s, 't>(&'s self, _x: &'t u8) {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
-  --> $DIR/needless_lifetimes.rs:148:1
+  --> $DIR/needless_lifetimes.rs:144:1
    |
 LL | fn struct_with_lt<'a>(_foo: Foo<'a>) -> &'a str {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
-  --> $DIR/needless_lifetimes.rs:178:1
+  --> $DIR/needless_lifetimes.rs:174:1
    |
 LL | fn trait_obj_elided2<'a>(_arg: &'a dyn Drop) -> &'a str {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
-  --> $DIR/needless_lifetimes.rs:184:1
+  --> $DIR/needless_lifetimes.rs:180:1
    |
 LL | fn alias_with_lt<'a>(_foo: FooAlias<'a>) -> &'a str {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
-  --> $DIR/needless_lifetimes.rs:203:1
+  --> $DIR/needless_lifetimes.rs:199:1
    |
 LL | fn named_input_elided_output<'a>(_arg: &'a str) -> &str {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
-  --> $DIR/needless_lifetimes.rs:211:1
+  --> $DIR/needless_lifetimes.rs:207:1
    |
 LL | fn trait_bound_ok<'a, T: WithLifetime<'static>>(_: &'a u8, _: T) {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
-  --> $DIR/needless_lifetimes.rs:247:1
+  --> $DIR/needless_lifetimes.rs:243:1
    |
 LL | fn out_return_type_lts<'a>(e: &'a str) -> Cow<'a> {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
-  --> $DIR/needless_lifetimes.rs:254:9
+  --> $DIR/needless_lifetimes.rs:250:9
    |
 LL |         fn needless_lt<'a>(x: &'a u8) {}
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
-  --> $DIR/needless_lifetimes.rs:258:9
+  --> $DIR/needless_lifetimes.rs:254:9
    |
 LL |         fn needless_lt<'a>(_x: &'a u8) {}
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
-  --> $DIR/needless_lifetimes.rs:271:9
+  --> $DIR/needless_lifetimes.rs:267:9
    |
 LL |         fn baz<'a>(&'a self) -> impl Foo + 'a {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
-  --> $DIR/needless_lifetimes.rs:300:5
+  --> $DIR/needless_lifetimes.rs:296:5
    |
 LL |     fn impl_trait_elidable_nested_named_lifetimes<'a>(i: &'a i32, f: impl for<'b> Fn(&'b i32) -> &'b i32) -> &'a i32 {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
-  --> $DIR/needless_lifetimes.rs:303:5
+  --> $DIR/needless_lifetimes.rs:299:5
    |
 LL |     fn impl_trait_elidable_nested_anonymous_lifetimes<'a>(i: &'a i32, f: impl Fn(&i32) -> &i32) -> &'a i32 {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
-  --> $DIR/needless_lifetimes.rs:312:5
+  --> $DIR/needless_lifetimes.rs:308:5
    |
 LL |     fn generics_elidable<'a, T: Fn(&i32) -> &i32>(i: &'a i32, f: T) -> &'a i32 {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
-  --> $DIR/needless_lifetimes.rs:324:5
+  --> $DIR/needless_lifetimes.rs:320:5
    |
 LL |     fn where_clause_elidadable<'a, T>(i: &'a i32, f: T) -> &'a i32
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
-  --> $DIR/needless_lifetimes.rs:339:5
+  --> $DIR/needless_lifetimes.rs:335:5
    |
 LL |     fn pointer_fn_elidable<'a>(i: &'a i32, f: fn(&i32) -> &i32) -> &'a i32 {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
-  --> $DIR/needless_lifetimes.rs:352:5
+  --> $DIR/needless_lifetimes.rs:348:5
    |
 LL |     fn nested_fn_pointer_3<'a>(_: &'a i32) -> fn(fn(&i32) -> &i32) -> i32 {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
-  --> $DIR/needless_lifetimes.rs:355:5
+  --> $DIR/needless_lifetimes.rs:351:5
    |
 LL |     fn nested_fn_pointer_4<'a>(_: &'a i32) -> impl Fn(fn(&i32)) {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/redundant_clone.fixed b/tests/ui/redundant_clone.fixed
index a5847e37c97..ec309109ed5 100644
--- a/tests/ui/redundant_clone.fixed
+++ b/tests/ui/redundant_clone.fixed
@@ -59,11 +59,7 @@ fn main() {
 #[derive(Clone)]
 struct Alpha;
 fn with_branch(a: Alpha, b: bool) -> (Alpha, Alpha) {
-    if b {
-        (a.clone(), a)
-    } else {
-        (Alpha, a)
-    }
+    if b { (a.clone(), a) } else { (Alpha, a) }
 }
 
 fn cannot_double_move(a: Alpha) -> (Alpha, Alpha) {
diff --git a/tests/ui/redundant_clone.rs b/tests/ui/redundant_clone.rs
index dab8d7fb1c7..b57027456e0 100644
--- a/tests/ui/redundant_clone.rs
+++ b/tests/ui/redundant_clone.rs
@@ -59,11 +59,7 @@ fn main() {
 #[derive(Clone)]
 struct Alpha;
 fn with_branch(a: Alpha, b: bool) -> (Alpha, Alpha) {
-    if b {
-        (a.clone(), a.clone())
-    } else {
-        (Alpha, a)
-    }
+    if b { (a.clone(), a.clone()) } else { (Alpha, a) }
 }
 
 fn cannot_double_move(a: Alpha) -> (Alpha, Alpha) {
diff --git a/tests/ui/redundant_clone.stderr b/tests/ui/redundant_clone.stderr
index 87c219316ce..821e7934be8 100644
--- a/tests/ui/redundant_clone.stderr
+++ b/tests/ui/redundant_clone.stderr
@@ -108,61 +108,61 @@ LL |     let _t = tup.0.clone();
    |              ^^^^^
 
 error: redundant clone
-  --> $DIR/redundant_clone.rs:63:22
+  --> $DIR/redundant_clone.rs:62:25
    |
-LL |         (a.clone(), a.clone())
-   |                      ^^^^^^^^ help: remove this
+LL |     if b { (a.clone(), a.clone()) } else { (Alpha, a) }
+   |                         ^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> $DIR/redundant_clone.rs:63:21
+  --> $DIR/redundant_clone.rs:62:24
    |
-LL |         (a.clone(), a.clone())
-   |                     ^
+LL |     if b { (a.clone(), a.clone()) } else { (Alpha, a) }
+   |                        ^
 
 error: redundant clone
-  --> $DIR/redundant_clone.rs:123:15
+  --> $DIR/redundant_clone.rs:119:15
    |
 LL |     let _s = s.clone();
    |               ^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> $DIR/redundant_clone.rs:123:14
+  --> $DIR/redundant_clone.rs:119:14
    |
 LL |     let _s = s.clone();
    |              ^
 
 error: redundant clone
-  --> $DIR/redundant_clone.rs:124:15
+  --> $DIR/redundant_clone.rs:120:15
    |
 LL |     let _t = t.clone();
    |               ^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> $DIR/redundant_clone.rs:124:14
+  --> $DIR/redundant_clone.rs:120:14
    |
 LL |     let _t = t.clone();
    |              ^
 
 error: redundant clone
-  --> $DIR/redundant_clone.rs:134:19
+  --> $DIR/redundant_clone.rs:130:19
    |
 LL |         let _f = f.clone();
    |                   ^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> $DIR/redundant_clone.rs:134:18
+  --> $DIR/redundant_clone.rs:130:18
    |
 LL |         let _f = f.clone();
    |                  ^
 
 error: redundant clone
-  --> $DIR/redundant_clone.rs:146:14
+  --> $DIR/redundant_clone.rs:142:14
    |
 LL |     let y = x.clone().join("matthias");
    |              ^^^^^^^^ help: remove this
    |
 note: cloned value is neither consumed nor mutated
-  --> $DIR/redundant_clone.rs:146:13
+  --> $DIR/redundant_clone.rs:142:13
    |
 LL |     let y = x.clone().join("matthias");
    |             ^^^^^^^^^
diff --git a/tests/ui/unnecessary_wraps.rs b/tests/ui/unnecessary_wraps.rs
index a510263e67d..54f22e3ee6a 100644
--- a/tests/ui/unnecessary_wraps.rs
+++ b/tests/ui/unnecessary_wraps.rs
@@ -22,29 +22,17 @@ fn func2(a: bool, b: bool) -> Option<i32> {
     if a && b {
         return Some(10);
     }
-    if a {
-        Some(20)
-    } else {
-        Some(30)
-    }
+    if a { Some(20) } else { Some(30) }
 }
 
 // public fns should not be linted
 pub fn func3(a: bool) -> Option<i32> {
-    if a {
-        Some(1)
-    } else {
-        Some(1)
-    }
+    if a { Some(1) } else { Some(1) }
 }
 
 // should not be linted
 fn func4(a: bool) -> Option<i32> {
-    if a {
-        Some(1)
-    } else {
-        None
-    }
+    if a { Some(1) } else { None }
 }
 
 // should be linted
@@ -64,11 +52,7 @@ fn func7() -> Result<i32, ()> {
 
 // should not be linted
 fn func8(a: bool) -> Result<i32, ()> {
-    if a {
-        Ok(1)
-    } else {
-        Err(())
-    }
+    if a { Ok(1) } else { Err(()) }
 }
 
 // should not be linted
@@ -143,20 +127,12 @@ fn issue_6640_2(a: bool, b: bool) -> Result<(), i32> {
 
 // should not be linted
 fn issue_6640_3() -> Option<()> {
-    if true {
-        Some(())
-    } else {
-        None
-    }
+    if true { Some(()) } else { None }
 }
 
 // should not be linted
 fn issue_6640_4() -> Result<(), ()> {
-    if true {
-        Ok(())
-    } else {
-        Err(())
-    }
+    if true { Ok(()) } else { Err(()) }
 }
 
 fn main() {
diff --git a/tests/ui/unnecessary_wraps.stderr b/tests/ui/unnecessary_wraps.stderr
index 9a861c61a46..0e570397e2a 100644
--- a/tests/ui/unnecessary_wraps.stderr
+++ b/tests/ui/unnecessary_wraps.stderr
@@ -32,8 +32,7 @@ LL | / fn func2(a: bool, b: bool) -> Option<i32> {
 LL | |     if a && b {
 LL | |         return Some(10);
 LL | |     }
-...  |
-LL | |     }
+LL | |     if a { Some(20) } else { Some(30) }
 LL | | }
    | |_^
    |
@@ -45,14 +44,11 @@ help: ...and then change returning expressions
    |
 LL |         return 10;
 LL |     }
-LL |     if a {
-LL |         20
-LL |     } else {
-LL |         30
+LL |     if a { 20 } else { 30 }
    |
 
 error: this function's return value is unnecessarily wrapped by `Option`
-  --> $DIR/unnecessary_wraps.rs:51:1
+  --> $DIR/unnecessary_wraps.rs:39:1
    |
 LL | / fn func5() -> Option<i32> {
 LL | |     Some(1)
@@ -69,7 +65,7 @@ LL |     1
    |
 
 error: this function's return value is unnecessarily wrapped by `Result`
-  --> $DIR/unnecessary_wraps.rs:61:1
+  --> $DIR/unnecessary_wraps.rs:49:1
    |
 LL | / fn func7() -> Result<i32, ()> {
 LL | |     Ok(1)
@@ -86,7 +82,7 @@ LL |     1
    |
 
 error: this function's return value is unnecessarily wrapped by `Option`
-  --> $DIR/unnecessary_wraps.rs:93:5
+  --> $DIR/unnecessary_wraps.rs:77:5
    |
 LL | /     fn func12() -> Option<i32> {
 LL | |         Some(1)
@@ -103,7 +99,7 @@ LL |         1
    |
 
 error: this function's return value is unnecessary
-  --> $DIR/unnecessary_wraps.rs:120:1
+  --> $DIR/unnecessary_wraps.rs:104:1
    |
 LL | / fn issue_6640_1(a: bool, b: bool) -> Option<()> {
 LL | |     if a && b {
@@ -129,7 +125,7 @@ LL |     } else {
  ...
 
 error: this function's return value is unnecessary
-  --> $DIR/unnecessary_wraps.rs:133:1
+  --> $DIR/unnecessary_wraps.rs:117:1
    |
 LL | / fn issue_6640_2(a: bool, b: bool) -> Result<(), i32> {
 LL | |     if a && b {
diff --git a/tests/ui/upper_case_acronyms.rs b/tests/ui/upper_case_acronyms.rs
index fdf8905f812..735909887ac 100644
--- a/tests/ui/upper_case_acronyms.rs
+++ b/tests/ui/upper_case_acronyms.rs
@@ -16,7 +16,8 @@ enum Flags {
     FIN,
 }
 
-struct GCCLLVMSomething; // linted with cfg option, beware that lint suggests `GccllvmSomething` instead of
-                         // `GccLlvmSomething`
+// linted with cfg option, beware that lint suggests `GccllvmSomething` instead of
+// `GccLlvmSomething`
+struct GCCLLVMSomething;
 
 fn main() {}
diff --git a/tests/ui/use_self.fixed b/tests/ui/use_self.fixed
index 95e7bc75431..2b22a2ed2d5 100644
--- a/tests/ui/use_self.fixed
+++ b/tests/ui/use_self.fixed
@@ -329,11 +329,7 @@ mod issue4140 {
         type To = Self;
 
         fn from(value: bool) -> Self {
-            if value {
-                100
-            } else {
-                0
-            }
+            if value { 100 } else { 0 }
         }
     }
 }
diff --git a/tests/ui/use_self.rs b/tests/ui/use_self.rs
index 75424f34159..609625abdec 100644
--- a/tests/ui/use_self.rs
+++ b/tests/ui/use_self.rs
@@ -329,11 +329,7 @@ mod issue4140 {
         type To = Self;
 
         fn from(value: bool) -> Self {
-            if value {
-                100
-            } else {
-                0
-            }
+            if value { 100 } else { 0 }
         }
     }
 }
diff --git a/tests/ui/use_self.stderr b/tests/ui/use_self.stderr
index 37dfef7cfe0..e1410d2e652 100644
--- a/tests/ui/use_self.stderr
+++ b/tests/ui/use_self.stderr
@@ -169,7 +169,7 @@ LL |         type To = T::To;
    |                   ^^^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:457:13
+  --> $DIR/use_self.rs:453:13
    |
 LL |             A::new::<submod::B>(submod::B {})
    |             ^ help: use the applicable keyword: `Self`
-- 
cgit 1.4.1-3-g733a5


From 2c485e36cdd76bc887278820822ffc053c5b3b83 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Mon, 1 Mar 2021 17:25:23 -0500
Subject: Don't move `yield` or inline assembly into closure

---
 clippy_lints/src/manual_map.rs    |  7 ++++++-
 tests/ui/manual_map_option.fixed  | 13 +++++++++++++
 tests/ui/manual_map_option.rs     | 13 +++++++++++++
 tests/ui/manual_map_option.stderr | 38 +++++++++++++++++++-------------------
 4 files changed, 51 insertions(+), 20 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_map.rs b/clippy_lints/src/manual_map.rs
index 983a10e8eaa..ac1d51e1993 100644
--- a/clippy_lints/src/manual_map.rs
+++ b/clippy_lints/src/manual_map.rs
@@ -203,7 +203,12 @@ fn can_move_expr_to_closure(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> boo
 
         fn visit_expr(&mut self, e: &'tcx Expr<'_>) {
             match e.kind {
-                ExprKind::Break(..) | ExprKind::Continue(_) | ExprKind::Ret(_) => {
+                ExprKind::Break(..)
+                | ExprKind::Continue(_)
+                | ExprKind::Ret(_)
+                | ExprKind::Yield(..)
+                | ExprKind::InlineAsm(_)
+                | ExprKind::LlvmInlineAsm(_) => {
                     self.make_closure = false;
                 },
                 // Accessing a field of a local value can only be done if the type isn't
diff --git a/tests/ui/manual_map_option.fixed b/tests/ui/manual_map_option.fixed
index e6fa10d22e1..9222aaf6c78 100644
--- a/tests/ui/manual_map_option.fixed
+++ b/tests/ui/manual_map_option.fixed
@@ -1,3 +1,4 @@
+// edition:2018
 // run-rustfix
 
 #![warn(clippy::manual_map)]
@@ -115,4 +116,16 @@ fn main() {
     Some(0).map(|x| vec![x]);
 
     option_env!("").map(String::from);
+
+    // #6819
+    async fn f2(x: u32) -> u32 {
+        x
+    }
+
+    async fn f3() {
+        match Some(0) {
+            Some(x) => Some(f2(x).await),
+            None => None,
+        };
+    }
 }
diff --git a/tests/ui/manual_map_option.rs b/tests/ui/manual_map_option.rs
index 7c2100299a7..1ccb450619c 100644
--- a/tests/ui/manual_map_option.rs
+++ b/tests/ui/manual_map_option.rs
@@ -1,3 +1,4 @@
+// edition:2018
 // run-rustfix
 
 #![warn(clippy::manual_map)]
@@ -173,4 +174,16 @@ fn main() {
         Some(x) => Some(String::from(x)),
         None => None,
     };
+
+    // #6819
+    async fn f2(x: u32) -> u32 {
+        x
+    }
+
+    async fn f3() {
+        match Some(0) {
+            Some(x) => Some(f2(x).await),
+            None => None,
+        };
+    }
 }
diff --git a/tests/ui/manual_map_option.stderr b/tests/ui/manual_map_option.stderr
index 2d13213cf67..d9f86eecd93 100644
--- a/tests/ui/manual_map_option.stderr
+++ b/tests/ui/manual_map_option.stderr
@@ -1,5 +1,5 @@
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:13:5
+  --> $DIR/manual_map_option.rs:14:5
    |
 LL | /     match Some(0) {
 LL | |         Some(_) => Some(2),
@@ -10,7 +10,7 @@ LL | |     };
    = note: `-D clippy::manual-map` implied by `-D warnings`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:18:5
+  --> $DIR/manual_map_option.rs:19:5
    |
 LL | /     match Some(0) {
 LL | |         Some(x) => Some(x + 1),
@@ -19,7 +19,7 @@ LL | |     };
    | |_____^ help: try this: `Some(0).map(|x| x + 1)`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:23:5
+  --> $DIR/manual_map_option.rs:24:5
    |
 LL | /     match Some("") {
 LL | |         Some(x) => Some(x.is_empty()),
@@ -28,7 +28,7 @@ LL | |     };
    | |_____^ help: try this: `Some("").map(|x| x.is_empty())`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:28:5
+  --> $DIR/manual_map_option.rs:29:5
    |
 LL | /     if let Some(x) = Some(0) {
 LL | |         Some(!x)
@@ -38,7 +38,7 @@ LL | |     };
    | |_____^ help: try this: `Some(0).map(|x| !x)`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:35:5
+  --> $DIR/manual_map_option.rs:36:5
    |
 LL | /     match Some(0) {
 LL | |         Some(x) => { Some(std::convert::identity(x)) }
@@ -47,7 +47,7 @@ LL | |     };
    | |_____^ help: try this: `Some(0).map(std::convert::identity)`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:40:5
+  --> $DIR/manual_map_option.rs:41:5
    |
 LL | /     match Some(&String::new()) {
 LL | |         Some(x) => Some(str::len(x)),
@@ -56,7 +56,7 @@ LL | |     };
    | |_____^ help: try this: `Some(&String::new()).map(|x| str::len(x))`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:50:5
+  --> $DIR/manual_map_option.rs:51:5
    |
 LL | /     match &Some([0, 1]) {
 LL | |         Some(x) => Some(x[0]),
@@ -65,7 +65,7 @@ LL | |     };
    | |_____^ help: try this: `Some([0, 1]).as_ref().map(|x| x[0])`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:55:5
+  --> $DIR/manual_map_option.rs:56:5
    |
 LL | /     match &Some(0) {
 LL | |         &Some(x) => Some(x * 2),
@@ -74,7 +74,7 @@ LL | |     };
    | |_____^ help: try this: `Some(0).map(|x| x * 2)`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:60:5
+  --> $DIR/manual_map_option.rs:61:5
    |
 LL | /     match Some(String::new()) {
 LL | |         Some(ref x) => Some(x.is_empty()),
@@ -83,7 +83,7 @@ LL | |     };
    | |_____^ help: try this: `Some(String::new()).as_ref().map(|x| x.is_empty())`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:65:5
+  --> $DIR/manual_map_option.rs:66:5
    |
 LL | /     match &&Some(String::new()) {
 LL | |         Some(x) => Some(x.len()),
@@ -92,7 +92,7 @@ LL | |     };
    | |_____^ help: try this: `Some(String::new()).as_ref().map(|x| x.len())`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:70:5
+  --> $DIR/manual_map_option.rs:71:5
    |
 LL | /     match &&Some(0) {
 LL | |         &&Some(x) => Some(x + x),
@@ -101,7 +101,7 @@ LL | |     };
    | |_____^ help: try this: `Some(0).map(|x| x + x)`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:83:9
+  --> $DIR/manual_map_option.rs:84:9
    |
 LL | /         match &mut Some(String::new()) {
 LL | |             Some(x) => Some(x.push_str("")),
@@ -110,7 +110,7 @@ LL | |         };
    | |_________^ help: try this: `Some(String::new()).as_mut().map(|x| x.push_str(""))`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:89:5
+  --> $DIR/manual_map_option.rs:90:5
    |
 LL | /     match &mut Some(String::new()) {
 LL | |         Some(ref x) => Some(x.len()),
@@ -119,7 +119,7 @@ LL | |     };
    | |_____^ help: try this: `Some(String::new()).as_ref().map(|x| x.len())`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:94:5
+  --> $DIR/manual_map_option.rs:95:5
    |
 LL | /     match &mut &Some(String::new()) {
 LL | |         Some(x) => Some(x.is_empty()),
@@ -128,7 +128,7 @@ LL | |     };
    | |_____^ help: try this: `Some(String::new()).as_ref().map(|x| x.is_empty())`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:99:5
+  --> $DIR/manual_map_option.rs:100:5
    |
 LL | /     match Some((0, 1, 2)) {
 LL | |         Some((x, y, z)) => Some(x + y + z),
@@ -137,7 +137,7 @@ LL | |     };
    | |_____^ help: try this: `Some((0, 1, 2)).map(|(x, y, z)| x + y + z)`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:104:5
+  --> $DIR/manual_map_option.rs:105:5
    |
 LL | /     match Some([1, 2, 3]) {
 LL | |         Some([first, ..]) => Some(first),
@@ -146,7 +146,7 @@ LL | |     };
    | |_____^ help: try this: `Some([1, 2, 3]).map(|[first, ..]| first)`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:109:5
+  --> $DIR/manual_map_option.rs:110:5
    |
 LL | /     match &Some((String::new(), "test")) {
 LL | |         Some((x, y)) => Some((y, x)),
@@ -155,7 +155,7 @@ LL | |     };
    | |_____^ help: try this: `Some((String::new(), "test")).as_ref().map(|(x, y)| (y, x))`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:167:5
+  --> $DIR/manual_map_option.rs:168:5
    |
 LL | /     match Some(0) {
 LL | |         Some(x) => Some(vec![x]),
@@ -164,7 +164,7 @@ LL | |     };
    | |_____^ help: try this: `Some(0).map(|x| vec![x])`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:172:5
+  --> $DIR/manual_map_option.rs:173:5
    |
 LL | /     match option_env!("") {
 LL | |         Some(x) => Some(String::from(x)),
-- 
cgit 1.4.1-3-g733a5


From f21320fd74490ba98f1ebca60c85626dd4d9e12d Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Mon, 1 Mar 2021 22:55:26 -0500
Subject: Use diagnostic or language items instead of paths

---
 .../case_sensitive_file_extension_comparisons.rs   |   7 +-
 clippy_lints/src/derive.rs                         |   4 +-
 clippy_lints/src/lifetimes.rs                      |  11 +-
 clippy_lints/src/map_clone.rs                      |   4 +-
 clippy_lints/src/redundant_clone.rs                |   2 +-
 clippy_lints/src/types.rs                          | 127 +++++++++++----------
 clippy_utils/src/lib.rs                            |  26 ++++-
 clippy_utils/src/paths.rs                          |   7 --
 8 files changed, 106 insertions(+), 82 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/case_sensitive_file_extension_comparisons.rs b/clippy_lints/src/case_sensitive_file_extension_comparisons.rs
index 6969ac949d8..b15fe65352a 100644
--- a/clippy_lints/src/case_sensitive_file_extension_comparisons.rs
+++ b/clippy_lints/src/case_sensitive_file_extension_comparisons.rs
@@ -1,12 +1,11 @@
-use crate::utils::paths::STRING;
-use crate::utils::{match_def_path, span_lint_and_help};
+use crate::utils::span_lint_and_help;
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
 use rustc_hir::{Expr, ExprKind, PathSegment};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::{source_map::Spanned, Span};
+use rustc_span::{source_map::Spanned, symbol::sym, Span};
 
 declare_clippy_lint! {
     /// **What it does:**
@@ -59,7 +58,7 @@ fn check_case_sensitive_file_extension_comparison(ctx: &LateContext<'_>, expr: &
                     return Some(span);
                 },
                 ty::Adt(&ty::AdtDef { did, .. }, _) => {
-                    if match_def_path(ctx, did, &STRING) {
+                    if ctx.tcx.is_diagnostic_item(sym::string_type, did) {
                         return Some(span);
                     }
                 },
diff --git a/clippy_lints/src/derive.rs b/clippy_lints/src/derive.rs
index e8510bde9ad..382a045a3f7 100644
--- a/clippy_lints/src/derive.rs
+++ b/clippy_lints/src/derive.rs
@@ -1,6 +1,6 @@
 use crate::utils::paths;
 use crate::utils::{
-    get_trait_def_id, is_allowed, is_automatically_derived, is_copy, match_def_path, match_path, span_lint_and_help,
+    get_trait_def_id, is_allowed, is_automatically_derived, is_copy, match_def_path, span_lint_and_help,
     span_lint_and_note, span_lint_and_then,
 };
 use if_chain::if_chain;
@@ -293,7 +293,7 @@ fn check_ord_partial_ord<'tcx>(
 
 /// Implementation of the `EXPL_IMPL_CLONE_ON_COPY` lint.
 fn check_copy_clone<'tcx>(cx: &LateContext<'tcx>, item: &Item<'_>, trait_ref: &TraitRef<'_>, ty: Ty<'tcx>) {
-    if match_path(&trait_ref.path, &paths::CLONE_TRAIT) {
+    if cx.tcx.lang_items().clone_trait() == trait_ref.trait_def_id() {
         if !is_copy(cx, ty) {
             return;
         }
diff --git a/clippy_lints/src/lifetimes.rs b/clippy_lints/src/lifetimes.rs
index 50e6383263d..5fed58b8210 100644
--- a/clippy_lints/src/lifetimes.rs
+++ b/clippy_lints/src/lifetimes.rs
@@ -1,5 +1,4 @@
-use crate::utils::paths;
-use crate::utils::{get_trait_def_id, in_macro, span_lint, trait_ref_of_method};
+use crate::utils::{in_macro, span_lint, trait_ref_of_method};
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_hir::intravisit::{
     walk_fn_decl, walk_generic_param, walk_generics, walk_item, walk_param_bound, walk_poly_trait_ref, walk_ty,
@@ -8,8 +7,8 @@ use rustc_hir::intravisit::{
 use rustc_hir::FnRetTy::Return;
 use rustc_hir::{
     BareFnTy, BodyId, FnDecl, GenericArg, GenericBound, GenericParam, GenericParamKind, Generics, ImplItem,
-    ImplItemKind, Item, ItemKind, Lifetime, LifetimeName, ParamName, PolyTraitRef, TraitBoundModifier, TraitFn,
-    TraitItem, TraitItemKind, Ty, TyKind, WhereClause, WherePredicate,
+    ImplItemKind, Item, ItemKind, LangItem, Lifetime, LifetimeName, ParamName, PolyTraitRef, TraitBoundModifier,
+    TraitFn, TraitItem, TraitItemKind, Ty, TyKind, WhereClause, WherePredicate,
 };
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::map::Map;
@@ -300,7 +299,7 @@ fn unique_lifetimes(lts: &[RefLt]) -> usize {
     lts.iter().collect::<FxHashSet<_>>().len()
 }
 
-const CLOSURE_TRAIT_BOUNDS: [&[&str]; 3] = [&paths::FN, &paths::FN_MUT, &paths::FN_ONCE];
+const CLOSURE_TRAIT_BOUNDS: [LangItem; 3] = [LangItem::Fn, LangItem::FnMut, LangItem::FnOnce];
 
 /// A visitor usable for `rustc_front::visit::walk_ty()`.
 struct RefVisitor<'a, 'tcx> {
@@ -361,7 +360,7 @@ impl<'a, 'tcx> Visitor<'tcx> for RefVisitor<'a, 'tcx> {
         let trait_ref = &poly_tref.trait_ref;
         if CLOSURE_TRAIT_BOUNDS
             .iter()
-            .any(|trait_path| trait_ref.trait_def_id() == get_trait_def_id(self.cx, trait_path))
+            .any(|&item| trait_ref.trait_def_id() == self.cx.tcx.lang_items().items()[item as usize])
         {
             let mut sub_visitor = RefVisitor::new(self.cx);
             sub_visitor.visit_trait_ref(trait_ref);
diff --git a/clippy_lints/src/map_clone.rs b/clippy_lints/src/map_clone.rs
index bd0be880289..0c358e2e538 100644
--- a/clippy_lints/src/map_clone.rs
+++ b/clippy_lints/src/map_clone.rs
@@ -79,7 +79,9 @@ impl<'tcx> LateLintPass<'tcx> for MapClone {
                             },
                             hir::ExprKind::MethodCall(ref method, _, [obj], _) => if_chain! {
                                 if ident_eq(name, obj) && method.ident.name == sym::clone;
-                                if match_trait_method(cx, closure_expr, &paths::CLONE_TRAIT);
+                                if let Some(fn_id) = cx.typeck_results().type_dependent_def_id(closure_expr.hir_id);
+                                if let Some(trait_id) = cx.tcx.trait_of_item(fn_id);
+                                if Some(trait_id) == cx.tcx.lang_items().clone_trait();
                                 // no autoderefs
                                 if !cx.typeck_results().expr_adjustments(obj).iter()
                                     .any(|a| matches!(a.kind, Adjust::Deref(Some(..))));
diff --git a/clippy_lints/src/redundant_clone.rs b/clippy_lints/src/redundant_clone.rs
index 06adbb523d7..d74ba10ac50 100644
--- a/clippy_lints/src/redundant_clone.rs
+++ b/clippy_lints/src/redundant_clone.rs
@@ -165,7 +165,7 @@ impl<'tcx> LateLintPass<'tcx> for RedundantClone {
                     if let Some((pred_fn_def_id, pred_arg, pred_arg_ty, res)) =
                         is_call_with_ref_arg(cx, mir, &pred_terminator.kind);
                     if res == cloned;
-                    if match_def_path(cx, pred_fn_def_id, &paths::DEREF_TRAIT_METHOD);
+                    if cx.tcx.is_diagnostic_item(sym::deref_method, pred_fn_def_id);
                     if match_type(cx, pred_arg_ty, &paths::PATH_BUF)
                         || match_type(cx, pred_arg_ty, &paths::OS_STRING);
                     then {
diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs
index f71b1651bfe..d1d9ef7d902 100644
--- a/clippy_lints/src/types.rs
+++ b/clippy_lints/src/types.rs
@@ -11,8 +11,8 @@ use rustc_hir as hir;
 use rustc_hir::intravisit::{walk_body, walk_expr, walk_ty, FnKind, NestedVisitorMap, Visitor};
 use rustc_hir::{
     BinOpKind, Block, Body, Expr, ExprKind, FnDecl, FnRetTy, FnSig, GenericArg, GenericBounds, GenericParamKind, HirId,
-    ImplItem, ImplItemKind, Item, ItemKind, Lifetime, Lit, Local, MatchSource, MutTy, Mutability, Node, QPath, Stmt,
-    StmtKind, SyntheticTyParamKind, TraitFn, TraitItem, TraitItemKind, TyKind, UnOp,
+    ImplItem, ImplItemKind, Item, ItemKind, LangItem, Lifetime, Lit, Local, MatchSource, MutTy, Mutability, Node,
+    QPath, Stmt, StmtKind, SyntheticTyParamKind, TraitFn, TraitItem, TraitItemKind, TyKind, UnOp,
 };
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::hir::map::Map;
@@ -23,7 +23,7 @@ use rustc_semver::RustcVersion;
 use rustc_session::{declare_lint_pass, declare_tool_lint, impl_lint_pass};
 use rustc_span::hygiene::{ExpnKind, MacroKind};
 use rustc_span::source_map::Span;
-use rustc_span::symbol::sym;
+use rustc_span::symbol::{sym, Symbol};
 use rustc_target::abi::LayoutOf;
 use rustc_target::spec::abi::Abi;
 use rustc_typeck::hir_ty_to_ty;
@@ -32,9 +32,9 @@ use crate::consts::{constant, Constant};
 use crate::utils::paths;
 use crate::utils::sugg::Sugg;
 use crate::utils::{
-    clip, comparisons, differing_macro_contexts, higher, in_constant, indent_of, int_bits, is_hir_ty_cfg_dependant,
-    is_type_diagnostic_item, last_path_segment, match_def_path, match_path, meets_msrv, method_chain_args,
-    multispan_sugg, numeric_literal::NumericLiteral, reindent_multiline, sext, snippet, snippet_opt,
+    clip, comparisons, differing_macro_contexts, get_qpath_generic_tys, higher, in_constant, indent_of, int_bits,
+    is_hir_ty_cfg_dependant, is_type_diagnostic_item, last_path_segment, match_def_path, match_path, meets_msrv,
+    method_chain_args, multispan_sugg, numeric_literal::NumericLiteral, reindent_multiline, sext, snippet, snippet_opt,
     snippet_with_applicability, snippet_with_macro_callsite, span_lint, span_lint_and_help, span_lint_and_sugg,
     span_lint_and_then, unsext,
 };
@@ -287,37 +287,55 @@ impl<'tcx> LateLintPass<'tcx> for Types {
     }
 }
 
-/// Checks if `qpath` has last segment with type parameter matching `path`
-fn match_type_parameter(cx: &LateContext<'_>, qpath: &QPath<'_>, path: &[&str]) -> Option<Span> {
-    let last = last_path_segment(qpath);
-    if_chain! {
-        if let Some(ref params) = last.args;
-        if !params.parenthesized;
-        if let Some(ty) = params.args.iter().find_map(|arg| match arg {
-            GenericArg::Type(ty) => Some(ty),
-            _ => None,
-        });
-        if let TyKind::Path(ref qpath) = ty.kind;
-        if let Some(did) = cx.qpath_res(qpath, ty.hir_id).opt_def_id();
-        if match_def_path(cx, did, path);
-        then {
-            return Some(ty.span);
-        }
+/// Checks if the first type parameter is a lang item.
+fn is_ty_param_lang_item(cx: &LateContext<'_>, qpath: &QPath<'tcx>, item: LangItem) -> Option<&'tcx hir::Ty<'tcx>> {
+    let ty = get_qpath_generic_tys(qpath).next()?;
+
+    if let TyKind::Path(qpath) = &ty.kind {
+        cx.qpath_res(qpath, ty.hir_id)
+            .opt_def_id()
+            .and_then(|id| (cx.tcx.lang_items().items()[item as usize] == Some(id)).then(|| ty))
+    } else {
+        None
     }
-    None
 }
 
-fn match_buffer_type(cx: &LateContext<'_>, qpath: &QPath<'_>) -> Option<&'static str> {
-    if match_type_parameter(cx, qpath, &paths::STRING).is_some() {
-        return Some("str");
+/// Checks if the first type parameter is a diagnostic item.
+fn is_ty_param_diagnostic_item(cx: &LateContext<'_>, qpath: &QPath<'tcx>, item: Symbol) -> Option<&'tcx hir::Ty<'tcx>> {
+    let ty = get_qpath_generic_tys(qpath).next()?;
+
+    if let TyKind::Path(qpath) = &ty.kind {
+        cx.qpath_res(qpath, ty.hir_id)
+            .opt_def_id()
+            .and_then(|id| cx.tcx.is_diagnostic_item(item, id).then(|| ty))
+    } else {
+        None
     }
-    if match_type_parameter(cx, qpath, &paths::OS_STRING).is_some() {
-        return Some("std::ffi::OsStr");
+}
+
+/// Checks if the first type parameter is a given item.
+fn is_ty_param_path(cx: &LateContext<'_>, qpath: &QPath<'tcx>, path: &[&str]) -> Option<&'tcx hir::Ty<'tcx>> {
+    let ty = get_qpath_generic_tys(qpath).next()?;
+
+    if let TyKind::Path(qpath) = &ty.kind {
+        cx.qpath_res(qpath, ty.hir_id)
+            .opt_def_id()
+            .and_then(|id| match_def_path(cx, id, path).then(|| ty))
+    } else {
+        None
     }
-    if match_type_parameter(cx, qpath, &paths::PATH_BUF).is_some() {
-        return Some("std::path::Path");
+}
+
+fn match_buffer_type(cx: &LateContext<'_>, qpath: &QPath<'_>) -> Option<&'static str> {
+    if is_ty_param_diagnostic_item(cx, qpath, sym::string_type).is_some() {
+        Some("str")
+    } else if is_ty_param_path(cx, qpath, &paths::OS_STRING).is_some() {
+        Some("std::ffi::OsStr")
+    } else if is_ty_param_path(cx, qpath, &paths::PATH_BUF).is_some() {
+        Some("std::path::Path")
+    } else {
+        None
     }
-    None
 }
 
 fn match_borrows_parameter(_cx: &LateContext<'_>, qpath: &QPath<'_>) -> Option<Span> {
@@ -381,7 +399,7 @@ impl Types {
                             );
                             return; // don't recurse into the type
                         }
-                        if match_type_parameter(cx, qpath, &paths::VEC).is_some() {
+                        if is_ty_param_diagnostic_item(cx, qpath, sym::vec_type).is_some() {
                             span_lint_and_help(
                                 cx,
                                 BOX_VEC,
@@ -393,7 +411,7 @@ impl Types {
                             return; // don't recurse into the type
                         }
                     } else if cx.tcx.is_diagnostic_item(sym::Rc, def_id) {
-                        if let Some(span) = match_type_parameter(cx, qpath, &paths::RC) {
+                        if let Some(ty) = is_ty_param_diagnostic_item(cx, qpath, sym::Rc) {
                             let mut applicability = Applicability::MachineApplicable;
                             span_lint_and_sugg(
                                 cx,
@@ -401,21 +419,18 @@ impl Types {
                                 hir_ty.span,
                                 "usage of `Rc<Rc<T>>`",
                                 "try",
-                                snippet_with_applicability(cx, span, "..", &mut applicability).to_string(),
+                                snippet_with_applicability(cx, ty.span, "..", &mut applicability).to_string(),
                                 applicability,
                             );
                             return; // don't recurse into the type
                         }
-                        if match_type_parameter(cx, qpath, &paths::BOX).is_some() {
-                            let box_ty = match &last_path_segment(qpath).args.unwrap().args[0] {
-                                GenericArg::Type(ty) => match &ty.kind {
-                                    TyKind::Path(qpath) => qpath,
-                                    _ => return,
-                                },
+                        if let Some(ty) = is_ty_param_lang_item(cx, qpath, LangItem::OwnedBox) {
+                            let qpath = match &ty.kind {
+                                TyKind::Path(qpath) => qpath,
                                 _ => return,
                             };
-                            let inner_span = match &last_path_segment(&box_ty).args.unwrap().args[0] {
-                                GenericArg::Type(ty) => ty.span,
+                            let inner_span = match get_qpath_generic_tys(qpath).next() {
+                                Some(ty) => ty.span,
                                 _ => return,
                             };
                             let mut applicability = Applicability::MachineApplicable;
@@ -445,16 +460,13 @@ impl Types {
                             );
                             return; // don't recurse into the type
                         }
-                        if match_type_parameter(cx, qpath, &paths::VEC).is_some() {
-                            let vec_ty = match &last_path_segment(qpath).args.unwrap().args[0] {
-                                GenericArg::Type(ty) => match &ty.kind {
-                                    TyKind::Path(qpath) => qpath,
-                                    _ => return,
-                                },
+                        if let Some(ty) = is_ty_param_diagnostic_item(cx, qpath, sym::vec_type) {
+                            let qpath = match &ty.kind {
+                                TyKind::Path(qpath) => qpath,
                                 _ => return,
                             };
-                            let inner_span = match &last_path_segment(&vec_ty).args.unwrap().args[0] {
-                                GenericArg::Type(ty) => ty.span,
+                            let inner_span = match get_qpath_generic_tys(qpath).next() {
+                                Some(ty) => ty.span,
                                 _ => return,
                             };
                             let mut applicability = Applicability::MachineApplicable;
@@ -498,16 +510,13 @@ impl Types {
                             );
                             return; // don't recurse into the type
                         }
-                        if match_type_parameter(cx, qpath, &paths::VEC).is_some() {
-                            let vec_ty = match &last_path_segment(qpath).args.unwrap().args[0] {
-                                GenericArg::Type(ty) => match &ty.kind {
-                                    TyKind::Path(qpath) => qpath,
-                                    _ => return,
-                                },
+                        if let Some(ty) = is_ty_param_diagnostic_item(cx, qpath, sym::vec_type) {
+                            let qpath = match &ty.kind {
+                                TyKind::Path(qpath) => qpath,
                                 _ => return,
                             };
-                            let inner_span = match &last_path_segment(&vec_ty).args.unwrap().args[0] {
-                                GenericArg::Type(ty) => ty.span,
+                            let inner_span = match get_qpath_generic_tys(qpath).next() {
+                                Some(ty) => ty.span,
                                 _ => return,
                             };
                             let mut applicability = Applicability::MachineApplicable;
@@ -563,7 +572,7 @@ impl Types {
                             }
                         }
                     } else if cx.tcx.is_diagnostic_item(sym::option_type, def_id) {
-                        if match_type_parameter(cx, qpath, &paths::OPTION).is_some() {
+                        if is_ty_param_diagnostic_item(cx, qpath, sym::option_type).is_some() {
                             span_lint(
                                 cx,
                                 OPTION_OPTION,
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 2380ea4c7bf..08e260b7d94 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -62,8 +62,9 @@ use rustc_hir::def_id::{DefId, LOCAL_CRATE};
 use rustc_hir::intravisit::{self, NestedVisitorMap, Visitor};
 use rustc_hir::Node;
 use rustc_hir::{
-    def, Arm, Block, Body, Constness, Crate, Expr, ExprKind, FnDecl, HirId, ImplItem, ImplItemKind, Item, ItemKind,
-    MatchSource, Param, Pat, PatKind, Path, PathSegment, QPath, TraitItem, TraitItemKind, TraitRef, TyKind, Unsafety,
+    def, Arm, Block, Body, Constness, Crate, Expr, ExprKind, FnDecl, GenericArgs, HirId, ImplItem, ImplItemKind, Item,
+    ItemKind, MatchSource, Param, Pat, PatKind, Path, PathSegment, QPath, TraitItem, TraitItemKind, TraitRef, TyKind,
+    Unsafety,
 };
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::{LateContext, Level, Lint, LintContext};
@@ -271,6 +272,27 @@ pub fn last_path_segment<'tcx>(path: &QPath<'tcx>) -> &'tcx PathSegment<'tcx> {
     }
 }
 
+pub fn get_qpath_generics(path: &QPath<'tcx>) -> Option<&'tcx GenericArgs<'tcx>> {
+    match path {
+        QPath::Resolved(_, p) => p.segments.last().and_then(|s| s.args),
+        QPath::TypeRelative(_, s) => s.args,
+        QPath::LangItem(..) => None,
+    }
+}
+
+pub fn get_qpath_generic_tys(path: &QPath<'tcx>) -> impl Iterator<Item = &'tcx hir::Ty<'tcx>> {
+    get_qpath_generics(path)
+        .map_or([].as_ref(), |a| a.args)
+        .iter()
+        .filter_map(|a| {
+            if let hir::GenericArg::Type(ty) = a {
+                Some(ty)
+            } else {
+                None
+            }
+        })
+}
+
 pub fn single_segment_path<'tcx>(path: &QPath<'tcx>) -> Option<&'tcx PathSegment<'tcx>> {
     match *path {
         QPath::Resolved(_, ref path) => path.segments.get(0),
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index e6178679647..14c38459dde 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -12,11 +12,9 @@ pub(super) const BEGIN_PANIC: [&str; 3] = ["std", "panicking", "begin_panic"];
 pub(super) const BEGIN_PANIC_FMT: [&str; 3] = ["std", "panicking", "begin_panic_fmt"];
 pub const BINARY_HEAP: [&str; 4] = ["alloc", "collections", "binary_heap", "BinaryHeap"];
 pub const BORROW_TRAIT: [&str; 3] = ["core", "borrow", "Borrow"];
-pub const BOX: [&str; 3] = ["alloc", "boxed", "Box"];
 pub const BTREEMAP: [&str; 5] = ["alloc", "collections", "btree", "map", "BTreeMap"];
 pub const BTREEMAP_ENTRY: [&str; 6] = ["alloc", "collections", "btree", "map", "entry", "Entry"];
 pub const BTREESET: [&str; 5] = ["alloc", "collections", "btree", "set", "BTreeSet"];
-pub const CLONE_TRAIT: [&str; 3] = ["core", "clone", "Clone"];
 pub const CLONE_TRAIT_METHOD: [&str; 4] = ["core", "clone", "Clone", "clone"];
 pub const CMP_MAX: [&str; 3] = ["core", "cmp", "max"];
 pub const CMP_MIN: [&str; 3] = ["core", "cmp", "min"];
@@ -43,9 +41,6 @@ pub const FILE_TYPE: [&str; 3] = ["std", "fs", "FileType"];
 pub const FMT_ARGUMENTS_NEW_V1: [&str; 4] = ["core", "fmt", "Arguments", "new_v1"];
 pub const FMT_ARGUMENTS_NEW_V1_FORMATTED: [&str; 4] = ["core", "fmt", "Arguments", "new_v1_formatted"];
 pub const FMT_ARGUMENTV1_NEW: [&str; 4] = ["core", "fmt", "ArgumentV1", "new"];
-pub const FN: [&str; 3] = ["core", "ops", "Fn"];
-pub const FN_MUT: [&str; 3] = ["core", "ops", "FnMut"];
-pub const FN_ONCE: [&str; 3] = ["core", "ops", "FnOnce"];
 pub const FROM_FROM: [&str; 4] = ["core", "convert", "From", "from"];
 pub const FROM_ITERATOR: [&str; 5] = ["core", "iter", "traits", "collect", "FromIterator"];
 pub const FUTURE_FROM_GENERATOR: [&str; 3] = ["core", "future", "from_generator"];
@@ -114,7 +109,6 @@ pub const PTR_SLICE_FROM_RAW_PARTS_MUT: [&str; 3] = ["core", "ptr", "slice_from_
 pub const PTR_SWAP_NONOVERLAPPING: [&str; 3] = ["core", "ptr", "swap_nonoverlapping"];
 pub const PUSH_STR: [&str; 4] = ["alloc", "string", "String", "push_str"];
 pub const RANGE_ARGUMENT_TRAIT: [&str; 3] = ["core", "ops", "RangeBounds"];
-pub const RC: [&str; 3] = ["alloc", "rc", "Rc"];
 pub const RC_PTR_EQ: [&str; 4] = ["alloc", "rc", "Rc", "ptr_eq"];
 pub const RECEIVER: [&str; 4] = ["std", "sync", "mpsc", "Receiver"];
 pub const REFCELL_REF: [&str; 3] = ["core", "cell", "Ref"];
@@ -143,7 +137,6 @@ pub const STD_CONVERT_IDENTITY: [&str; 3] = ["std", "convert", "identity"];
 pub const STD_FS_CREATE_DIR: [&str; 3] = ["std", "fs", "create_dir"];
 pub const STD_MEM_TRANSMUTE: [&str; 3] = ["std", "mem", "transmute"];
 pub const STD_PTR_NULL: [&str; 3] = ["std", "ptr", "null"];
-pub const STRING: [&str; 3] = ["alloc", "string", "String"];
 pub const STRING_AS_MUT_STR: [&str; 4] = ["alloc", "string", "String", "as_mut_str"];
 pub const STRING_AS_STR: [&str; 4] = ["alloc", "string", "String", "as_str"];
 pub const STR_ENDS_WITH: [&str; 4] = ["core", "str", "<impl str>", "ends_with"];
-- 
cgit 1.4.1-3-g733a5


From 62ac4bd1b2b94cb97f61d7f42fdd4fcd8794d2b0 Mon Sep 17 00:00:00 2001
From: nahuakang <kangnahua@gmail.com>
Date: Sun, 7 Feb 2021 13:35:27 +0100
Subject: create loops dir; arrange manual_flatten lint and utils

---
 clippy_lints/src/loops.rs                | 3173 ------------------------------
 clippy_lints/src/loops/manual_flatten.rs |   78 +
 clippy_lints/src/loops/mod.rs            | 3070 +++++++++++++++++++++++++++++
 clippy_lints/src/loops/utils.rs          |   40 +
 4 files changed, 3188 insertions(+), 3173 deletions(-)
 delete mode 100644 clippy_lints/src/loops.rs
 create mode 100644 clippy_lints/src/loops/manual_flatten.rs
 create mode 100644 clippy_lints/src/loops/mod.rs
 create mode 100644 clippy_lints/src/loops/utils.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
deleted file mode 100644
index 711cd5b3b15..00000000000
--- a/clippy_lints/src/loops.rs
+++ /dev/null
@@ -1,3173 +0,0 @@
-use crate::consts::constant;
-use crate::utils::sugg::Sugg;
-use crate::utils::usage::mutated_variables;
-use crate::utils::visitors::LocalUsedVisitor;
-use crate::utils::{
-    contains_name, get_enclosing_block, get_parent_expr, get_trait_def_id, has_iter_method, higher, implements_trait,
-    indent_of, is_in_panic_handler, is_integer_const, is_no_std_crate, is_ok_ctor, is_refutable, is_some_ctor,
-    is_type_diagnostic_item, last_path_segment, match_trait_method, match_type, multispan_sugg, path_to_local,
-    path_to_local_id, paths, single_segment_path, snippet, snippet_with_applicability, snippet_with_macro_callsite,
-    span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then, sugg, SpanlessEq,
-};
-use if_chain::if_chain;
-use rustc_ast::ast;
-use rustc_data_structures::fx::{FxHashMap, FxHashSet};
-use rustc_errors::Applicability;
-use rustc_hir::def::{DefKind, Res};
-use rustc_hir::intravisit::{walk_block, walk_expr, walk_pat, walk_stmt, NestedVisitorMap, Visitor};
-use rustc_hir::{
-    def_id, BinOpKind, BindingAnnotation, Block, BorrowKind, Expr, ExprKind, GenericArg, HirId, InlineAsmOperand,
-    Local, LoopSource, MatchSource, Mutability, Node, Pat, PatKind, QPath, Stmt, StmtKind,
-};
-use rustc_infer::infer::TyCtxtInferExt;
-use rustc_lint::{LateContext, LateLintPass, LintContext};
-use rustc_middle::hir::map::Map;
-use rustc_middle::lint::in_external_macro;
-use rustc_middle::middle::region;
-use rustc_middle::ty::{self, Ty, TyS};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::source_map::Span;
-use rustc_span::symbol::{sym, Ident, Symbol};
-use rustc_typeck::expr_use_visitor::{ConsumeMode, Delegate, ExprUseVisitor, PlaceBase, PlaceWithHirId};
-use std::iter::{once, Iterator};
-use std::mem;
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for for-loops that manually copy items between
-    /// slices that could be optimized by having a memcpy.
-    ///
-    /// **Why is this bad?** It is not as fast as a memcpy.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    /// ```rust
-    /// # let src = vec![1];
-    /// # let mut dst = vec![0; 65];
-    /// for i in 0..src.len() {
-    ///     dst[i + 64] = src[i];
-    /// }
-    /// ```
-    /// Could be written as:
-    /// ```rust
-    /// # let src = vec![1];
-    /// # let mut dst = vec![0; 65];
-    /// dst[64..(src.len() + 64)].clone_from_slice(&src[..]);
-    /// ```
-    pub MANUAL_MEMCPY,
-    perf,
-    "manually copying items between slices"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for looping over the range of `0..len` of some
-    /// collection just to get the values by index.
-    ///
-    /// **Why is this bad?** Just iterating the collection itself makes the intent
-    /// more clear and is probably faster.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    /// ```rust
-    /// let vec = vec!['a', 'b', 'c'];
-    /// for i in 0..vec.len() {
-    ///     println!("{}", vec[i]);
-    /// }
-    /// ```
-    /// Could be written as:
-    /// ```rust
-    /// let vec = vec!['a', 'b', 'c'];
-    /// for i in vec {
-    ///     println!("{}", i);
-    /// }
-    /// ```
-    pub NEEDLESS_RANGE_LOOP,
-    style,
-    "for-looping over a range of indices where an iterator over items would do"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for loops on `x.iter()` where `&x` will do, and
-    /// suggests the latter.
-    ///
-    /// **Why is this bad?** Readability.
-    ///
-    /// **Known problems:** False negatives. We currently only warn on some known
-    /// types.
-    ///
-    /// **Example:**
-    /// ```rust
-    /// // with `y` a `Vec` or slice:
-    /// # let y = vec![1];
-    /// for x in y.iter() {
-    ///     // ..
-    /// }
-    /// ```
-    /// can be rewritten to
-    /// ```rust
-    /// # let y = vec![1];
-    /// for x in &y {
-    ///     // ..
-    /// }
-    /// ```
-    pub EXPLICIT_ITER_LOOP,
-    pedantic,
-    "for-looping over `_.iter()` or `_.iter_mut()` when `&_` or `&mut _` would do"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for loops on `y.into_iter()` where `y` will do, and
-    /// suggests the latter.
-    ///
-    /// **Why is this bad?** Readability.
-    ///
-    /// **Known problems:** None
-    ///
-    /// **Example:**
-    /// ```rust
-    /// # let y = vec![1];
-    /// // with `y` a `Vec` or slice:
-    /// for x in y.into_iter() {
-    ///     // ..
-    /// }
-    /// ```
-    /// can be rewritten to
-    /// ```rust
-    /// # let y = vec![1];
-    /// for x in y {
-    ///     // ..
-    /// }
-    /// ```
-    pub EXPLICIT_INTO_ITER_LOOP,
-    pedantic,
-    "for-looping over `_.into_iter()` when `_` would do"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for loops on `x.next()`.
-    ///
-    /// **Why is this bad?** `next()` returns either `Some(value)` if there was a
-    /// value, or `None` otherwise. The insidious thing is that `Option<_>`
-    /// implements `IntoIterator`, so that possibly one value will be iterated,
-    /// leading to some hard to find bugs. No one will want to write such code
-    /// [except to win an Underhanded Rust
-    /// Contest](https://www.reddit.com/r/rust/comments/3hb0wm/underhanded_rust_contest/cu5yuhr).
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    /// ```ignore
-    /// for x in y.next() {
-    ///     ..
-    /// }
-    /// ```
-    pub ITER_NEXT_LOOP,
-    correctness,
-    "for-looping over `_.next()` which is probably not intended"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for `for` loops over `Option` or `Result` values.
-    ///
-    /// **Why is this bad?** Readability. This is more clearly expressed as an `if
-    /// let`.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    /// ```rust
-    /// # let opt = Some(1);
-    ///
-    /// // Bad
-    /// for x in opt {
-    ///     // ..
-    /// }
-    ///
-    /// // Good
-    /// if let Some(x) = opt {
-    ///     // ..
-    /// }
-    /// ```
-    ///
-    /// // or
-    ///
-    /// ```rust
-    /// # let res: Result<i32, std::io::Error> = Ok(1);
-    ///
-    /// // Bad
-    /// for x in &res {
-    ///     // ..
-    /// }
-    ///
-    /// // Good
-    /// if let Ok(x) = res {
-    ///     // ..
-    /// }
-    /// ```
-    pub FOR_LOOPS_OVER_FALLIBLES,
-    correctness,
-    "for-looping over an `Option` or a `Result`, which is more clearly expressed as an `if let`"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Detects `loop + match` combinations that are easier
-    /// written as a `while let` loop.
-    ///
-    /// **Why is this bad?** The `while let` loop is usually shorter and more
-    /// readable.
-    ///
-    /// **Known problems:** Sometimes the wrong binding is displayed ([#383](https://github.com/rust-lang/rust-clippy/issues/383)).
-    ///
-    /// **Example:**
-    /// ```rust,no_run
-    /// # let y = Some(1);
-    /// loop {
-    ///     let x = match y {
-    ///         Some(x) => x,
-    ///         None => break,
-    ///     };
-    ///     // .. do something with x
-    /// }
-    /// // is easier written as
-    /// while let Some(x) = y {
-    ///     // .. do something with x
-    /// };
-    /// ```
-    pub WHILE_LET_LOOP,
-    complexity,
-    "`loop { if let { ... } else break }`, which can be written as a `while let` loop"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for functions collecting an iterator when collect
-    /// is not needed.
-    ///
-    /// **Why is this bad?** `collect` causes the allocation of a new data structure,
-    /// when this allocation may not be needed.
-    ///
-    /// **Known problems:**
-    /// None
-    ///
-    /// **Example:**
-    /// ```rust
-    /// # let iterator = vec![1].into_iter();
-    /// let len = iterator.clone().collect::<Vec<_>>().len();
-    /// // should be
-    /// let len = iterator.count();
-    /// ```
-    pub NEEDLESS_COLLECT,
-    perf,
-    "collecting an iterator when collect is not needed"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks `for` loops over slices with an explicit counter
-    /// and suggests the use of `.enumerate()`.
-    ///
-    /// **Why is it bad?** Using `.enumerate()` makes the intent more clear,
-    /// declutters the code and may be faster in some instances.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    /// ```rust
-    /// # let v = vec![1];
-    /// # fn bar(bar: usize, baz: usize) {}
-    /// let mut i = 0;
-    /// for item in &v {
-    ///     bar(i, *item);
-    ///     i += 1;
-    /// }
-    /// ```
-    /// Could be written as
-    /// ```rust
-    /// # let v = vec![1];
-    /// # fn bar(bar: usize, baz: usize) {}
-    /// for (i, item) in v.iter().enumerate() { bar(i, *item); }
-    /// ```
-    pub EXPLICIT_COUNTER_LOOP,
-    complexity,
-    "for-looping with an explicit counter when `_.enumerate()` would do"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for empty `loop` expressions.
-    ///
-    /// **Why is this bad?** These busy loops burn CPU cycles without doing
-    /// anything. It is _almost always_ a better idea to `panic!` than to have
-    /// a busy loop.
-    ///
-    /// If panicking isn't possible, think of the environment and either:
-    ///   - block on something
-    ///   - sleep the thread for some microseconds
-    ///   - yield or pause the thread
-    ///
-    /// For `std` targets, this can be done with
-    /// [`std::thread::sleep`](https://doc.rust-lang.org/std/thread/fn.sleep.html)
-    /// or [`std::thread::yield_now`](https://doc.rust-lang.org/std/thread/fn.yield_now.html).
-    ///
-    /// For `no_std` targets, doing this is more complicated, especially because
-    /// `#[panic_handler]`s can't panic. To stop/pause the thread, you will
-    /// probably need to invoke some target-specific intrinsic. Examples include:
-    ///   - [`x86_64::instructions::hlt`](https://docs.rs/x86_64/0.12.2/x86_64/instructions/fn.hlt.html)
-    ///   - [`cortex_m::asm::wfi`](https://docs.rs/cortex-m/0.6.3/cortex_m/asm/fn.wfi.html)
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    /// ```no_run
-    /// loop {}
-    /// ```
-    pub EMPTY_LOOP,
-    style,
-    "empty `loop {}`, which should block or sleep"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for `while let` expressions on iterators.
-    ///
-    /// **Why is this bad?** Readability. A simple `for` loop is shorter and conveys
-    /// the intent better.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    /// ```ignore
-    /// while let Some(val) = iter() {
-    ///     ..
-    /// }
-    /// ```
-    pub WHILE_LET_ON_ITERATOR,
-    style,
-    "using a `while let` loop instead of a for loop on an iterator"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for iterating a map (`HashMap` or `BTreeMap`) and
-    /// ignoring either the keys or values.
-    ///
-    /// **Why is this bad?** Readability. There are `keys` and `values` methods that
-    /// can be used to express that don't need the values or keys.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    /// ```ignore
-    /// for (k, _) in &map {
-    ///     ..
-    /// }
-    /// ```
-    ///
-    /// could be replaced by
-    ///
-    /// ```ignore
-    /// for k in map.keys() {
-    ///     ..
-    /// }
-    /// ```
-    pub FOR_KV_MAP,
-    style,
-    "looping on a map using `iter` when `keys` or `values` would do"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for loops that will always `break`, `return` or
-    /// `continue` an outer loop.
-    ///
-    /// **Why is this bad?** This loop never loops, all it does is obfuscating the
-    /// code.
-    ///
-    /// **Known problems:** None
-    ///
-    /// **Example:**
-    /// ```rust
-    /// loop {
-    ///     ..;
-    ///     break;
-    /// }
-    /// ```
-    pub NEVER_LOOP,
-    correctness,
-    "any loop that will always `break` or `return`"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for loops which have a range bound that is a mutable variable
-    ///
-    /// **Why is this bad?** One might think that modifying the mutable variable changes the loop bounds
-    ///
-    /// **Known problems:** None
-    ///
-    /// **Example:**
-    /// ```rust
-    /// let mut foo = 42;
-    /// for i in 0..foo {
-    ///     foo -= 1;
-    ///     println!("{}", i); // prints numbers from 0 to 42, not 0 to 21
-    /// }
-    /// ```
-    pub MUT_RANGE_BOUND,
-    complexity,
-    "for loop over a range where one of the bounds is a mutable variable"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks whether variables used within while loop condition
-    /// can be (and are) mutated in the body.
-    ///
-    /// **Why is this bad?** If the condition is unchanged, entering the body of the loop
-    /// will lead to an infinite loop.
-    ///
-    /// **Known problems:** If the `while`-loop is in a closure, the check for mutation of the
-    /// condition variables in the body can cause false negatives. For example when only `Upvar` `a` is
-    /// in the condition and only `Upvar` `b` gets mutated in the body, the lint will not trigger.
-    ///
-    /// **Example:**
-    /// ```rust
-    /// let i = 0;
-    /// while i > 10 {
-    ///     println!("let me loop forever!");
-    /// }
-    /// ```
-    pub WHILE_IMMUTABLE_CONDITION,
-    correctness,
-    "variables used within while expression are not mutated in the body"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks whether a for loop is being used to push a constant
-    /// value into a Vec.
-    ///
-    /// **Why is this bad?** This kind of operation can be expressed more succinctly with
-    /// `vec![item;SIZE]` or `vec.resize(NEW_SIZE, item)` and using these alternatives may also
-    /// have better performance.
-    /// **Known problems:** None
-    ///
-    /// **Example:**
-    /// ```rust
-    /// let item1 = 2;
-    /// let item2 = 3;
-    /// let mut vec: Vec<u8> = Vec::new();
-    /// for _ in 0..20 {
-    ///    vec.push(item1);
-    /// }
-    /// for _ in 0..30 {
-    ///     vec.push(item2);
-    /// }
-    /// ```
-    /// could be written as
-    /// ```rust
-    /// let item1 = 2;
-    /// let item2 = 3;
-    /// let mut vec: Vec<u8> = vec![item1; 20];
-    /// vec.resize(20 + 30, item2);
-    /// ```
-    pub SAME_ITEM_PUSH,
-    style,
-    "the same item is pushed inside of a for loop"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks whether a for loop has a single element.
-    ///
-    /// **Why is this bad?** There is no reason to have a loop of a
-    /// single element.
-    /// **Known problems:** None
-    ///
-    /// **Example:**
-    /// ```rust
-    /// let item1 = 2;
-    /// for item in &[item1] {
-    ///     println!("{}", item);
-    /// }
-    /// ```
-    /// could be written as
-    /// ```rust
-    /// let item1 = 2;
-    /// let item = &item1;
-    /// println!("{}", item);
-    /// ```
-    pub SINGLE_ELEMENT_LOOP,
-    complexity,
-    "there is no reason to have a single element loop"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Check for unnecessary `if let` usage in a for loop
-    /// where only the `Some` or `Ok` variant of the iterator element is used.
-    ///
-    /// **Why is this bad?** It is verbose and can be simplified
-    /// by first calling the `flatten` method on the `Iterator`.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
-    /// ```rust
-    /// let x = vec![Some(1), Some(2), Some(3)];
-    /// for n in x {
-    ///     if let Some(n) = n {
-    ///         println!("{}", n);
-    ///     }
-    /// }
-    /// ```
-    /// Use instead:
-    /// ```rust
-    /// let x = vec![Some(1), Some(2), Some(3)];
-    /// for n in x.into_iter().flatten() {
-    ///     println!("{}", n);
-    /// }
-    /// ```
-    pub MANUAL_FLATTEN,
-    complexity,
-    "for loops over `Option`s or `Result`s with a single expression can be simplified"
-}
-
-declare_lint_pass!(Loops => [
-    MANUAL_MEMCPY,
-    MANUAL_FLATTEN,
-    NEEDLESS_RANGE_LOOP,
-    EXPLICIT_ITER_LOOP,
-    EXPLICIT_INTO_ITER_LOOP,
-    ITER_NEXT_LOOP,
-    FOR_LOOPS_OVER_FALLIBLES,
-    WHILE_LET_LOOP,
-    NEEDLESS_COLLECT,
-    EXPLICIT_COUNTER_LOOP,
-    EMPTY_LOOP,
-    WHILE_LET_ON_ITERATOR,
-    FOR_KV_MAP,
-    NEVER_LOOP,
-    MUT_RANGE_BOUND,
-    WHILE_IMMUTABLE_CONDITION,
-    SAME_ITEM_PUSH,
-    SINGLE_ELEMENT_LOOP,
-]);
-
-impl<'tcx> LateLintPass<'tcx> for Loops {
-    #[allow(clippy::too_many_lines)]
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if let Some((pat, arg, body, span)) = higher::for_loop(expr) {
-            // we don't want to check expanded macros
-            // this check is not at the top of the function
-            // since higher::for_loop expressions are marked as expansions
-            if body.span.from_expansion() {
-                return;
-            }
-            check_for_loop(cx, pat, arg, body, expr, span);
-        }
-
-        // we don't want to check expanded macros
-        if expr.span.from_expansion() {
-            return;
-        }
-
-        // check for never_loop
-        if let ExprKind::Loop(ref block, _, _, _) = expr.kind {
-            match never_loop_block(block, expr.hir_id) {
-                NeverLoopResult::AlwaysBreak => span_lint(cx, NEVER_LOOP, expr.span, "this loop never actually loops"),
-                NeverLoopResult::MayContinueMainLoop | NeverLoopResult::Otherwise => (),
-            }
-        }
-
-        // check for `loop { if let {} else break }` that could be `while let`
-        // (also matches an explicit "match" instead of "if let")
-        // (even if the "match" or "if let" is used for declaration)
-        if let ExprKind::Loop(ref block, _, LoopSource::Loop, _) = expr.kind {
-            // also check for empty `loop {}` statements, skipping those in #[panic_handler]
-            if block.stmts.is_empty() && block.expr.is_none() && !is_in_panic_handler(cx, expr) {
-                let msg = "empty `loop {}` wastes CPU cycles";
-                let help = if is_no_std_crate(cx.tcx.hir().krate()) {
-                    "you should either use `panic!()` or add a call pausing or sleeping the thread to the loop body"
-                } else {
-                    "you should either use `panic!()` or add `std::thread::sleep(..);` to the loop body"
-                };
-                span_lint_and_help(cx, EMPTY_LOOP, expr.span, msg, None, help);
-            }
-
-            // extract the expression from the first statement (if any) in a block
-            let inner_stmt_expr = extract_expr_from_first_stmt(block);
-            // or extract the first expression (if any) from the block
-            if let Some(inner) = inner_stmt_expr.or_else(|| extract_first_expr(block)) {
-                if let ExprKind::Match(ref matchexpr, ref arms, ref source) = inner.kind {
-                    // ensure "if let" compatible match structure
-                    match *source {
-                        MatchSource::Normal | MatchSource::IfLetDesugar { .. } => {
-                            if arms.len() == 2
-                                && arms[0].guard.is_none()
-                                && arms[1].guard.is_none()
-                                && is_simple_break_expr(&arms[1].body)
-                            {
-                                if in_external_macro(cx.sess(), expr.span) {
-                                    return;
-                                }
-
-                                // NOTE: we used to build a body here instead of using
-                                // ellipsis, this was removed because:
-                                // 1) it was ugly with big bodies;
-                                // 2) it was not indented properly;
-                                // 3) it wasn’t very smart (see #675).
-                                let mut applicability = Applicability::HasPlaceholders;
-                                span_lint_and_sugg(
-                                    cx,
-                                    WHILE_LET_LOOP,
-                                    expr.span,
-                                    "this loop could be written as a `while let` loop",
-                                    "try",
-                                    format!(
-                                        "while let {} = {} {{ .. }}",
-                                        snippet_with_applicability(cx, arms[0].pat.span, "..", &mut applicability),
-                                        snippet_with_applicability(cx, matchexpr.span, "..", &mut applicability),
-                                    ),
-                                    applicability,
-                                );
-                            }
-                        },
-                        _ => (),
-                    }
-                }
-            }
-        }
-        if let ExprKind::Match(ref match_expr, ref arms, MatchSource::WhileLetDesugar) = expr.kind {
-            let pat = &arms[0].pat.kind;
-            if let (
-                &PatKind::TupleStruct(ref qpath, ref pat_args, _),
-                &ExprKind::MethodCall(ref method_path, _, ref method_args, _),
-            ) = (pat, &match_expr.kind)
-            {
-                let iter_expr = &method_args[0];
-
-                // Don't lint when the iterator is recreated on every iteration
-                if_chain! {
-                    if let ExprKind::MethodCall(..) | ExprKind::Call(..) = iter_expr.kind;
-                    if let Some(iter_def_id) = get_trait_def_id(cx, &paths::ITERATOR);
-                    if implements_trait(cx, cx.typeck_results().expr_ty(iter_expr), iter_def_id, &[]);
-                    then {
-                        return;
-                    }
-                }
-
-                let lhs_constructor = last_path_segment(qpath);
-                if method_path.ident.name == sym::next
-                    && match_trait_method(cx, match_expr, &paths::ITERATOR)
-                    && lhs_constructor.ident.name == sym::Some
-                    && (pat_args.is_empty()
-                        || !is_refutable(cx, &pat_args[0])
-                            && !is_used_inside(cx, iter_expr, &arms[0].body)
-                            && !is_iterator_used_after_while_let(cx, iter_expr)
-                            && !is_nested(cx, expr, &method_args[0]))
-                {
-                    let mut applicability = Applicability::MachineApplicable;
-                    let iterator = snippet_with_applicability(cx, method_args[0].span, "_", &mut applicability);
-                    let loop_var = if pat_args.is_empty() {
-                        "_".to_string()
-                    } else {
-                        snippet_with_applicability(cx, pat_args[0].span, "_", &mut applicability).into_owned()
-                    };
-                    span_lint_and_sugg(
-                        cx,
-                        WHILE_LET_ON_ITERATOR,
-                        expr.span.with_hi(match_expr.span.hi()),
-                        "this loop could be written as a `for` loop",
-                        "try",
-                        format!("for {} in {}", loop_var, iterator),
-                        applicability,
-                    );
-                }
-            }
-        }
-
-        if let Some((cond, body)) = higher::while_loop(&expr) {
-            check_infinite_loop(cx, cond, body);
-        }
-
-        check_needless_collect(expr, cx);
-    }
-}
-
-enum NeverLoopResult {
-    // A break/return always get triggered but not necessarily for the main loop.
-    AlwaysBreak,
-    // A continue may occur for the main loop.
-    MayContinueMainLoop,
-    Otherwise,
-}
-
-#[must_use]
-fn absorb_break(arg: &NeverLoopResult) -> NeverLoopResult {
-    match *arg {
-        NeverLoopResult::AlwaysBreak | NeverLoopResult::Otherwise => NeverLoopResult::Otherwise,
-        NeverLoopResult::MayContinueMainLoop => NeverLoopResult::MayContinueMainLoop,
-    }
-}
-
-// Combine two results for parts that are called in order.
-#[must_use]
-fn combine_seq(first: NeverLoopResult, second: NeverLoopResult) -> NeverLoopResult {
-    match first {
-        NeverLoopResult::AlwaysBreak | NeverLoopResult::MayContinueMainLoop => first,
-        NeverLoopResult::Otherwise => second,
-    }
-}
-
-// Combine two results where both parts are called but not necessarily in order.
-#[must_use]
-fn combine_both(left: NeverLoopResult, right: NeverLoopResult) -> NeverLoopResult {
-    match (left, right) {
-        (NeverLoopResult::MayContinueMainLoop, _) | (_, NeverLoopResult::MayContinueMainLoop) => {
-            NeverLoopResult::MayContinueMainLoop
-        },
-        (NeverLoopResult::AlwaysBreak, _) | (_, NeverLoopResult::AlwaysBreak) => NeverLoopResult::AlwaysBreak,
-        (NeverLoopResult::Otherwise, NeverLoopResult::Otherwise) => NeverLoopResult::Otherwise,
-    }
-}
-
-// Combine two results where only one of the part may have been executed.
-#[must_use]
-fn combine_branches(b1: NeverLoopResult, b2: NeverLoopResult) -> NeverLoopResult {
-    match (b1, b2) {
-        (NeverLoopResult::AlwaysBreak, NeverLoopResult::AlwaysBreak) => NeverLoopResult::AlwaysBreak,
-        (NeverLoopResult::MayContinueMainLoop, _) | (_, NeverLoopResult::MayContinueMainLoop) => {
-            NeverLoopResult::MayContinueMainLoop
-        },
-        (NeverLoopResult::Otherwise, _) | (_, NeverLoopResult::Otherwise) => NeverLoopResult::Otherwise,
-    }
-}
-
-fn never_loop_block(block: &Block<'_>, main_loop_id: HirId) -> NeverLoopResult {
-    let stmts = block.stmts.iter().map(stmt_to_expr);
-    let expr = once(block.expr.as_deref());
-    let mut iter = stmts.chain(expr).flatten();
-    never_loop_expr_seq(&mut iter, main_loop_id)
-}
-
-fn stmt_to_expr<'tcx>(stmt: &Stmt<'tcx>) -> Option<&'tcx Expr<'tcx>> {
-    match stmt.kind {
-        StmtKind::Semi(ref e, ..) | StmtKind::Expr(ref e, ..) => Some(e),
-        StmtKind::Local(ref local) => local.init.as_deref(),
-        _ => None,
-    }
-}
-
-fn never_loop_expr(expr: &Expr<'_>, main_loop_id: HirId) -> NeverLoopResult {
-    match expr.kind {
-        ExprKind::Box(ref e)
-        | ExprKind::Unary(_, ref e)
-        | ExprKind::Cast(ref e, _)
-        | ExprKind::Type(ref e, _)
-        | ExprKind::Field(ref e, _)
-        | ExprKind::AddrOf(_, _, ref e)
-        | ExprKind::Struct(_, _, Some(ref e))
-        | ExprKind::Repeat(ref e, _)
-        | ExprKind::DropTemps(ref e) => never_loop_expr(e, main_loop_id),
-        ExprKind::Array(ref es) | ExprKind::MethodCall(_, _, ref es, _) | ExprKind::Tup(ref es) => {
-            never_loop_expr_all(&mut es.iter(), main_loop_id)
-        },
-        ExprKind::Call(ref e, ref es) => never_loop_expr_all(&mut once(&**e).chain(es.iter()), main_loop_id),
-        ExprKind::Binary(_, ref e1, ref e2)
-        | ExprKind::Assign(ref e1, ref e2, _)
-        | ExprKind::AssignOp(_, ref e1, ref e2)
-        | ExprKind::Index(ref e1, ref e2) => never_loop_expr_all(&mut [&**e1, &**e2].iter().cloned(), main_loop_id),
-        ExprKind::Loop(ref b, _, _, _) => {
-            // Break can come from the inner loop so remove them.
-            absorb_break(&never_loop_block(b, main_loop_id))
-        },
-        ExprKind::If(ref e, ref e2, ref e3) => {
-            let e1 = never_loop_expr(e, main_loop_id);
-            let e2 = never_loop_expr(e2, main_loop_id);
-            let e3 = e3
-                .as_ref()
-                .map_or(NeverLoopResult::Otherwise, |e| never_loop_expr(e, main_loop_id));
-            combine_seq(e1, combine_branches(e2, e3))
-        },
-        ExprKind::Match(ref e, ref arms, _) => {
-            let e = never_loop_expr(e, main_loop_id);
-            if arms.is_empty() {
-                e
-            } else {
-                let arms = never_loop_expr_branch(&mut arms.iter().map(|a| &*a.body), main_loop_id);
-                combine_seq(e, arms)
-            }
-        },
-        ExprKind::Block(ref b, _) => never_loop_block(b, main_loop_id),
-        ExprKind::Continue(d) => {
-            let id = d
-                .target_id
-                .expect("target ID can only be missing in the presence of compilation errors");
-            if id == main_loop_id {
-                NeverLoopResult::MayContinueMainLoop
-            } else {
-                NeverLoopResult::AlwaysBreak
-            }
-        },
-        ExprKind::Break(_, ref e) | ExprKind::Ret(ref e) => e.as_ref().map_or(NeverLoopResult::AlwaysBreak, |e| {
-            combine_seq(never_loop_expr(e, main_loop_id), NeverLoopResult::AlwaysBreak)
-        }),
-        ExprKind::InlineAsm(ref asm) => asm
-            .operands
-            .iter()
-            .map(|(o, _)| match o {
-                InlineAsmOperand::In { expr, .. }
-                | InlineAsmOperand::InOut { expr, .. }
-                | InlineAsmOperand::Const { expr }
-                | InlineAsmOperand::Sym { expr } => never_loop_expr(expr, main_loop_id),
-                InlineAsmOperand::Out { expr, .. } => never_loop_expr_all(&mut expr.iter(), main_loop_id),
-                InlineAsmOperand::SplitInOut { in_expr, out_expr, .. } => {
-                    never_loop_expr_all(&mut once(in_expr).chain(out_expr.iter()), main_loop_id)
-                },
-            })
-            .fold(NeverLoopResult::Otherwise, combine_both),
-        ExprKind::Struct(_, _, None)
-        | ExprKind::Yield(_, _)
-        | ExprKind::Closure(_, _, _, _, _)
-        | ExprKind::LlvmInlineAsm(_)
-        | ExprKind::Path(_)
-        | ExprKind::ConstBlock(_)
-        | ExprKind::Lit(_)
-        | ExprKind::Err => NeverLoopResult::Otherwise,
-    }
-}
-
-fn never_loop_expr_seq<'a, T: Iterator<Item = &'a Expr<'a>>>(es: &mut T, main_loop_id: HirId) -> NeverLoopResult {
-    es.map(|e| never_loop_expr(e, main_loop_id))
-        .fold(NeverLoopResult::Otherwise, combine_seq)
-}
-
-fn never_loop_expr_all<'a, T: Iterator<Item = &'a Expr<'a>>>(es: &mut T, main_loop_id: HirId) -> NeverLoopResult {
-    es.map(|e| never_loop_expr(e, main_loop_id))
-        .fold(NeverLoopResult::Otherwise, combine_both)
-}
-
-fn never_loop_expr_branch<'a, T: Iterator<Item = &'a Expr<'a>>>(e: &mut T, main_loop_id: HirId) -> NeverLoopResult {
-    e.map(|e| never_loop_expr(e, main_loop_id))
-        .fold(NeverLoopResult::AlwaysBreak, combine_branches)
-}
-
-fn check_for_loop<'tcx>(
-    cx: &LateContext<'tcx>,
-    pat: &'tcx Pat<'_>,
-    arg: &'tcx Expr<'_>,
-    body: &'tcx Expr<'_>,
-    expr: &'tcx Expr<'_>,
-    span: Span,
-) {
-    let is_manual_memcpy_triggered = detect_manual_memcpy(cx, pat, arg, body, expr);
-    if !is_manual_memcpy_triggered {
-        check_for_loop_range(cx, pat, arg, body, expr);
-        check_for_loop_explicit_counter(cx, pat, arg, body, expr);
-    }
-    check_for_loop_arg(cx, pat, arg, expr);
-    check_for_loop_over_map_kv(cx, pat, arg, body, expr);
-    check_for_mut_range_bound(cx, arg, body);
-    check_for_single_element_loop(cx, pat, arg, body, expr);
-    detect_same_item_push(cx, pat, arg, body, expr);
-    check_manual_flatten(cx, pat, arg, body, span);
-}
-
-// this function assumes the given expression is a `for` loop.
-fn get_span_of_entire_for_loop(expr: &Expr<'_>) -> Span {
-    // for some reason this is the only way to get the `Span`
-    // of the entire `for` loop
-    if let ExprKind::Match(_, arms, _) = &expr.kind {
-        arms[0].body.span
-    } else {
-        unreachable!()
-    }
-}
-
-/// a wrapper of `Sugg`. Besides what `Sugg` do, this removes unnecessary `0`;
-/// and also, it avoids subtracting a variable from the same one by replacing it with `0`.
-/// it exists for the convenience of the overloaded operators while normal functions can do the
-/// same.
-#[derive(Clone)]
-struct MinifyingSugg<'a>(Sugg<'a>);
-
-impl<'a> MinifyingSugg<'a> {
-    fn as_str(&self) -> &str {
-        let Sugg::NonParen(s) | Sugg::MaybeParen(s) | Sugg::BinOp(_, s) = &self.0;
-        s.as_ref()
-    }
-
-    fn into_sugg(self) -> Sugg<'a> {
-        self.0
-    }
-}
-
-impl<'a> From<Sugg<'a>> for MinifyingSugg<'a> {
-    fn from(sugg: Sugg<'a>) -> Self {
-        Self(sugg)
-    }
-}
-
-impl std::ops::Add for &MinifyingSugg<'static> {
-    type Output = MinifyingSugg<'static>;
-    fn add(self, rhs: &MinifyingSugg<'static>) -> MinifyingSugg<'static> {
-        match (self.as_str(), rhs.as_str()) {
-            ("0", _) => rhs.clone(),
-            (_, "0") => self.clone(),
-            (_, _) => (&self.0 + &rhs.0).into(),
-        }
-    }
-}
-
-impl std::ops::Sub for &MinifyingSugg<'static> {
-    type Output = MinifyingSugg<'static>;
-    fn sub(self, rhs: &MinifyingSugg<'static>) -> MinifyingSugg<'static> {
-        match (self.as_str(), rhs.as_str()) {
-            (_, "0") => self.clone(),
-            ("0", _) => (-rhs.0.clone()).into(),
-            (x, y) if x == y => sugg::ZERO.into(),
-            (_, _) => (&self.0 - &rhs.0).into(),
-        }
-    }
-}
-
-impl std::ops::Add<&MinifyingSugg<'static>> for MinifyingSugg<'static> {
-    type Output = MinifyingSugg<'static>;
-    fn add(self, rhs: &MinifyingSugg<'static>) -> MinifyingSugg<'static> {
-        match (self.as_str(), rhs.as_str()) {
-            ("0", _) => rhs.clone(),
-            (_, "0") => self,
-            (_, _) => (self.0 + &rhs.0).into(),
-        }
-    }
-}
-
-impl std::ops::Sub<&MinifyingSugg<'static>> for MinifyingSugg<'static> {
-    type Output = MinifyingSugg<'static>;
-    fn sub(self, rhs: &MinifyingSugg<'static>) -> MinifyingSugg<'static> {
-        match (self.as_str(), rhs.as_str()) {
-            (_, "0") => self,
-            ("0", _) => (-rhs.0.clone()).into(),
-            (x, y) if x == y => sugg::ZERO.into(),
-            (_, _) => (self.0 - &rhs.0).into(),
-        }
-    }
-}
-
-/// a wrapper around `MinifyingSugg`, which carries a operator like currying
-/// so that the suggested code become more efficient (e.g. `foo + -bar` `foo - bar`).
-struct Offset {
-    value: MinifyingSugg<'static>,
-    sign: OffsetSign,
-}
-
-#[derive(Clone, Copy)]
-enum OffsetSign {
-    Positive,
-    Negative,
-}
-
-impl Offset {
-    fn negative(value: Sugg<'static>) -> Self {
-        Self {
-            value: value.into(),
-            sign: OffsetSign::Negative,
-        }
-    }
-
-    fn positive(value: Sugg<'static>) -> Self {
-        Self {
-            value: value.into(),
-            sign: OffsetSign::Positive,
-        }
-    }
-
-    fn empty() -> Self {
-        Self::positive(sugg::ZERO)
-    }
-}
-
-fn apply_offset(lhs: &MinifyingSugg<'static>, rhs: &Offset) -> MinifyingSugg<'static> {
-    match rhs.sign {
-        OffsetSign::Positive => lhs + &rhs.value,
-        OffsetSign::Negative => lhs - &rhs.value,
-    }
-}
-
-#[derive(Debug, Clone, Copy)]
-enum StartKind<'hir> {
-    Range,
-    Counter { initializer: &'hir Expr<'hir> },
-}
-
-struct IndexExpr<'hir> {
-    base: &'hir Expr<'hir>,
-    idx: StartKind<'hir>,
-    idx_offset: Offset,
-}
-
-struct Start<'hir> {
-    id: HirId,
-    kind: StartKind<'hir>,
-}
-
-fn is_slice_like<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'_>) -> bool {
-    let is_slice = match ty.kind() {
-        ty::Ref(_, subty, _) => is_slice_like(cx, subty),
-        ty::Slice(..) | ty::Array(..) => true,
-        _ => false,
-    };
-
-    is_slice || is_type_diagnostic_item(cx, ty, sym::vec_type) || is_type_diagnostic_item(cx, ty, sym!(vecdeque_type))
-}
-
-fn fetch_cloned_expr<'tcx>(expr: &'tcx Expr<'tcx>) -> &'tcx Expr<'tcx> {
-    if_chain! {
-        if let ExprKind::MethodCall(method, _, args, _) = expr.kind;
-        if method.ident.name == sym::clone;
-        if args.len() == 1;
-        if let Some(arg) = args.get(0);
-        then { arg } else { expr }
-    }
-}
-
-fn get_details_from_idx<'tcx>(
-    cx: &LateContext<'tcx>,
-    idx: &Expr<'_>,
-    starts: &[Start<'tcx>],
-) -> Option<(StartKind<'tcx>, Offset)> {
-    fn get_start<'tcx>(e: &Expr<'_>, starts: &[Start<'tcx>]) -> Option<StartKind<'tcx>> {
-        let id = path_to_local(e)?;
-        starts.iter().find(|start| start.id == id).map(|start| start.kind)
-    }
-
-    fn get_offset<'tcx>(cx: &LateContext<'tcx>, e: &Expr<'_>, starts: &[Start<'tcx>]) -> Option<Sugg<'static>> {
-        match &e.kind {
-            ExprKind::Lit(l) => match l.node {
-                ast::LitKind::Int(x, _ty) => Some(Sugg::NonParen(x.to_string().into())),
-                _ => None,
-            },
-            ExprKind::Path(..) if get_start(e, starts).is_none() => Some(Sugg::hir(cx, e, "???")),
-            _ => None,
-        }
-    }
-
-    match idx.kind {
-        ExprKind::Binary(op, lhs, rhs) => match op.node {
-            BinOpKind::Add => {
-                let offset_opt = get_start(lhs, starts)
-                    .and_then(|s| get_offset(cx, rhs, starts).map(|o| (s, o)))
-                    .or_else(|| get_start(rhs, starts).and_then(|s| get_offset(cx, lhs, starts).map(|o| (s, o))));
-
-                offset_opt.map(|(s, o)| (s, Offset::positive(o)))
-            },
-            BinOpKind::Sub => {
-                get_start(lhs, starts).and_then(|s| get_offset(cx, rhs, starts).map(|o| (s, Offset::negative(o))))
-            },
-            _ => None,
-        },
-        ExprKind::Path(..) => get_start(idx, starts).map(|s| (s, Offset::empty())),
-        _ => None,
-    }
-}
-
-fn get_assignment<'tcx>(e: &'tcx Expr<'tcx>) -> Option<(&'tcx Expr<'tcx>, &'tcx Expr<'tcx>)> {
-    if let ExprKind::Assign(lhs, rhs, _) = e.kind {
-        Some((lhs, rhs))
-    } else {
-        None
-    }
-}
-
-/// Get assignments from the given block.
-/// The returned iterator yields `None` if no assignment expressions are there,
-/// filtering out the increments of the given whitelisted loop counters;
-/// because its job is to make sure there's nothing other than assignments and the increments.
-fn get_assignments<'a, 'tcx>(
-    Block { stmts, expr, .. }: &'tcx Block<'tcx>,
-    loop_counters: &'a [Start<'tcx>],
-) -> impl Iterator<Item = Option<(&'tcx Expr<'tcx>, &'tcx Expr<'tcx>)>> + 'a {
-    // As the `filter` and `map` below do different things, I think putting together
-    // just increases complexity. (cc #3188 and #4193)
-    stmts
-        .iter()
-        .filter_map(move |stmt| match stmt.kind {
-            StmtKind::Local(..) | StmtKind::Item(..) => None,
-            StmtKind::Expr(e) | StmtKind::Semi(e) => Some(e),
-        })
-        .chain((*expr).into_iter())
-        .filter(move |e| {
-            if let ExprKind::AssignOp(_, place, _) = e.kind {
-                path_to_local(place).map_or(false, |id| {
-                    !loop_counters
-                        .iter()
-                        // skip the first item which should be `StartKind::Range`
-                        // this makes it possible to use the slice with `StartKind::Range` in the same iterator loop.
-                        .skip(1)
-                        .any(|counter| counter.id == id)
-                })
-            } else {
-                true
-            }
-        })
-        .map(get_assignment)
-}
-
-fn get_loop_counters<'a, 'tcx>(
-    cx: &'a LateContext<'tcx>,
-    body: &'tcx Block<'tcx>,
-    expr: &'tcx Expr<'_>,
-) -> Option<impl Iterator<Item = Start<'tcx>> + 'a> {
-    // Look for variables that are incremented once per loop iteration.
-    let mut increment_visitor = IncrementVisitor::new(cx);
-    walk_block(&mut increment_visitor, body);
-
-    // For each candidate, check the parent block to see if
-    // it's initialized to zero at the start of the loop.
-    get_enclosing_block(&cx, expr.hir_id).and_then(|block| {
-        increment_visitor
-            .into_results()
-            .filter_map(move |var_id| {
-                let mut initialize_visitor = InitializeVisitor::new(cx, expr, var_id);
-                walk_block(&mut initialize_visitor, block);
-
-                initialize_visitor.get_result().map(|(_, initializer)| Start {
-                    id: var_id,
-                    kind: StartKind::Counter { initializer },
-                })
-            })
-            .into()
-    })
-}
-
-fn build_manual_memcpy_suggestion<'tcx>(
-    cx: &LateContext<'tcx>,
-    start: &Expr<'_>,
-    end: &Expr<'_>,
-    limits: ast::RangeLimits,
-    dst: &IndexExpr<'_>,
-    src: &IndexExpr<'_>,
-) -> String {
-    fn print_offset(offset: MinifyingSugg<'static>) -> MinifyingSugg<'static> {
-        if offset.as_str() == "0" {
-            sugg::EMPTY.into()
-        } else {
-            offset
-        }
-    }
-
-    let print_limit = |end: &Expr<'_>, end_str: &str, base: &Expr<'_>, sugg: MinifyingSugg<'static>| {
-        if_chain! {
-            if let ExprKind::MethodCall(method, _, len_args, _) = end.kind;
-            if method.ident.name == sym!(len);
-            if len_args.len() == 1;
-            if let Some(arg) = len_args.get(0);
-            if path_to_local(arg) == path_to_local(base);
-            then {
-                if sugg.as_str() == end_str {
-                    sugg::EMPTY.into()
-                } else {
-                    sugg
-                }
-            } else {
-                match limits {
-                    ast::RangeLimits::Closed => {
-                        sugg + &sugg::ONE.into()
-                    },
-                    ast::RangeLimits::HalfOpen => sugg,
-                }
-            }
-        }
-    };
-
-    let start_str = Sugg::hir(cx, start, "").into();
-    let end_str: MinifyingSugg<'_> = Sugg::hir(cx, end, "").into();
-
-    let print_offset_and_limit = |idx_expr: &IndexExpr<'_>| match idx_expr.idx {
-        StartKind::Range => (
-            print_offset(apply_offset(&start_str, &idx_expr.idx_offset)).into_sugg(),
-            print_limit(
-                end,
-                end_str.as_str(),
-                idx_expr.base,
-                apply_offset(&end_str, &idx_expr.idx_offset),
-            )
-            .into_sugg(),
-        ),
-        StartKind::Counter { initializer } => {
-            let counter_start = Sugg::hir(cx, initializer, "").into();
-            (
-                print_offset(apply_offset(&counter_start, &idx_expr.idx_offset)).into_sugg(),
-                print_limit(
-                    end,
-                    end_str.as_str(),
-                    idx_expr.base,
-                    apply_offset(&end_str, &idx_expr.idx_offset) + &counter_start - &start_str,
-                )
-                .into_sugg(),
-            )
-        },
-    };
-
-    let (dst_offset, dst_limit) = print_offset_and_limit(&dst);
-    let (src_offset, src_limit) = print_offset_and_limit(&src);
-
-    let dst_base_str = snippet(cx, dst.base.span, "???");
-    let src_base_str = snippet(cx, src.base.span, "???");
-
-    let dst = if dst_offset == sugg::EMPTY && dst_limit == sugg::EMPTY {
-        dst_base_str
-    } else {
-        format!(
-            "{}[{}..{}]",
-            dst_base_str,
-            dst_offset.maybe_par(),
-            dst_limit.maybe_par()
-        )
-        .into()
-    };
-
-    format!(
-        "{}.clone_from_slice(&{}[{}..{}]);",
-        dst,
-        src_base_str,
-        src_offset.maybe_par(),
-        src_limit.maybe_par()
-    )
-}
-
-/// Checks for for loops that sequentially copy items from one slice-like
-/// object to another.
-fn detect_manual_memcpy<'tcx>(
-    cx: &LateContext<'tcx>,
-    pat: &'tcx Pat<'_>,
-    arg: &'tcx Expr<'_>,
-    body: &'tcx Expr<'_>,
-    expr: &'tcx Expr<'_>,
-) -> bool {
-    if let Some(higher::Range {
-        start: Some(start),
-        end: Some(end),
-        limits,
-    }) = higher::range(arg)
-    {
-        // the var must be a single name
-        if let PatKind::Binding(_, canonical_id, _, _) = pat.kind {
-            let mut starts = vec![Start {
-                id: canonical_id,
-                kind: StartKind::Range,
-            }];
-
-            // This is one of few ways to return different iterators
-            // derived from: https://stackoverflow.com/questions/29760668/conditionally-iterate-over-one-of-several-possible-iterators/52064434#52064434
-            let mut iter_a = None;
-            let mut iter_b = None;
-
-            if let ExprKind::Block(block, _) = body.kind {
-                if let Some(loop_counters) = get_loop_counters(cx, block, expr) {
-                    starts.extend(loop_counters);
-                }
-                iter_a = Some(get_assignments(block, &starts));
-            } else {
-                iter_b = Some(get_assignment(body));
-            }
-
-            let assignments = iter_a.into_iter().flatten().chain(iter_b.into_iter());
-
-            let big_sugg = assignments
-                // The only statements in the for loops can be indexed assignments from
-                // indexed retrievals (except increments of loop counters).
-                .map(|o| {
-                    o.and_then(|(lhs, rhs)| {
-                        let rhs = fetch_cloned_expr(rhs);
-                        if_chain! {
-                            if let ExprKind::Index(base_left, idx_left) = lhs.kind;
-                            if let ExprKind::Index(base_right, idx_right) = rhs.kind;
-                            if is_slice_like(cx, cx.typeck_results().expr_ty(base_left))
-                                && is_slice_like(cx, cx.typeck_results().expr_ty(base_right));
-                            if let Some((start_left, offset_left)) = get_details_from_idx(cx, &idx_left, &starts);
-                            if let Some((start_right, offset_right)) = get_details_from_idx(cx, &idx_right, &starts);
-
-                            // Source and destination must be different
-                            if path_to_local(base_left) != path_to_local(base_right);
-                            then {
-                                Some((IndexExpr { base: base_left, idx: start_left, idx_offset: offset_left },
-                                    IndexExpr { base: base_right, idx: start_right, idx_offset: offset_right }))
-                            } else {
-                                None
-                            }
-                        }
-                    })
-                })
-                .map(|o| o.map(|(dst, src)| build_manual_memcpy_suggestion(cx, start, end, limits, &dst, &src)))
-                .collect::<Option<Vec<_>>>()
-                .filter(|v| !v.is_empty())
-                .map(|v| v.join("\n    "));
-
-            if let Some(big_sugg) = big_sugg {
-                span_lint_and_sugg(
-                    cx,
-                    MANUAL_MEMCPY,
-                    get_span_of_entire_for_loop(expr),
-                    "it looks like you're manually copying between slices",
-                    "try replacing the loop by",
-                    big_sugg,
-                    Applicability::Unspecified,
-                );
-                return true;
-            }
-        }
-    }
-    false
-}
-
-// Scans the body of the for loop and determines whether lint should be given
-struct SameItemPushVisitor<'a, 'tcx> {
-    should_lint: bool,
-    // this field holds the last vec push operation visited, which should be the only push seen
-    vec_push: Option<(&'tcx Expr<'tcx>, &'tcx Expr<'tcx>)>,
-    cx: &'a LateContext<'tcx>,
-}
-
-impl<'a, 'tcx> Visitor<'tcx> for SameItemPushVisitor<'a, 'tcx> {
-    type Map = Map<'tcx>;
-
-    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
-        match &expr.kind {
-            // Non-determinism may occur ... don't give a lint
-            ExprKind::Loop(..) | ExprKind::Match(..) => self.should_lint = false,
-            ExprKind::Block(block, _) => self.visit_block(block),
-            _ => {},
-        }
-    }
-
-    fn visit_block(&mut self, b: &'tcx Block<'_>) {
-        for stmt in b.stmts.iter() {
-            self.visit_stmt(stmt);
-        }
-    }
-
-    fn visit_stmt(&mut self, s: &'tcx Stmt<'_>) {
-        let vec_push_option = get_vec_push(self.cx, s);
-        if vec_push_option.is_none() {
-            // Current statement is not a push so visit inside
-            match &s.kind {
-                StmtKind::Expr(expr) | StmtKind::Semi(expr) => self.visit_expr(&expr),
-                _ => {},
-            }
-        } else {
-            // Current statement is a push ...check whether another
-            // push had been previously done
-            if self.vec_push.is_none() {
-                self.vec_push = vec_push_option;
-            } else {
-                // There are multiple pushes ... don't lint
-                self.should_lint = false;
-            }
-        }
-    }
-
-    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-        NestedVisitorMap::None
-    }
-}
-
-// Given some statement, determine if that statement is a push on a Vec. If it is, return
-// the Vec being pushed into and the item being pushed
-fn get_vec_push<'tcx>(cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) -> Option<(&'tcx Expr<'tcx>, &'tcx Expr<'tcx>)> {
-    if_chain! {
-            // Extract method being called
-            if let StmtKind::Semi(semi_stmt) = &stmt.kind;
-            if let ExprKind::MethodCall(path, _, args, _) = &semi_stmt.kind;
-            // Figure out the parameters for the method call
-            if let Some(self_expr) = args.get(0);
-            if let Some(pushed_item) = args.get(1);
-            // Check that the method being called is push() on a Vec
-            if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(self_expr), sym::vec_type);
-            if path.ident.name.as_str() == "push";
-            then {
-                return Some((self_expr, pushed_item))
-            }
-    }
-    None
-}
-
-/// Detects for loop pushing the same item into a Vec
-fn detect_same_item_push<'tcx>(
-    cx: &LateContext<'tcx>,
-    pat: &'tcx Pat<'_>,
-    _: &'tcx Expr<'_>,
-    body: &'tcx Expr<'_>,
-    _: &'tcx Expr<'_>,
-) {
-    fn emit_lint(cx: &LateContext<'_>, vec: &Expr<'_>, pushed_item: &Expr<'_>) {
-        let vec_str = snippet_with_macro_callsite(cx, vec.span, "");
-        let item_str = snippet_with_macro_callsite(cx, pushed_item.span, "");
-
-        span_lint_and_help(
-            cx,
-            SAME_ITEM_PUSH,
-            vec.span,
-            "it looks like the same item is being pushed into this Vec",
-            None,
-            &format!(
-                "try using vec![{};SIZE] or {}.resize(NEW_SIZE, {})",
-                item_str, vec_str, item_str
-            ),
-        )
-    }
-
-    if !matches!(pat.kind, PatKind::Wild) {
-        return;
-    }
-
-    // Determine whether it is safe to lint the body
-    let mut same_item_push_visitor = SameItemPushVisitor {
-        should_lint: true,
-        vec_push: None,
-        cx,
-    };
-    walk_expr(&mut same_item_push_visitor, body);
-    if same_item_push_visitor.should_lint {
-        if let Some((vec, pushed_item)) = same_item_push_visitor.vec_push {
-            let vec_ty = cx.typeck_results().expr_ty(vec);
-            let ty = vec_ty.walk().nth(1).unwrap().expect_ty();
-            if cx
-                .tcx
-                .lang_items()
-                .clone_trait()
-                .map_or(false, |id| implements_trait(cx, ty, id, &[]))
-            {
-                // Make sure that the push does not involve possibly mutating values
-                match pushed_item.kind {
-                    ExprKind::Path(ref qpath) => {
-                        match cx.qpath_res(qpath, pushed_item.hir_id) {
-                            // immutable bindings that are initialized with literal or constant
-                            Res::Local(hir_id) => {
-                                if_chain! {
-                                    let node = cx.tcx.hir().get(hir_id);
-                                    if let Node::Binding(pat) = node;
-                                    if let PatKind::Binding(bind_ann, ..) = pat.kind;
-                                    if !matches!(bind_ann, BindingAnnotation::RefMut | BindingAnnotation::Mutable);
-                                    let parent_node = cx.tcx.hir().get_parent_node(hir_id);
-                                    if let Some(Node::Local(parent_let_expr)) = cx.tcx.hir().find(parent_node);
-                                    if let Some(init) = parent_let_expr.init;
-                                    then {
-                                        match init.kind {
-                                            // immutable bindings that are initialized with literal
-                                            ExprKind::Lit(..) => emit_lint(cx, vec, pushed_item),
-                                            // immutable bindings that are initialized with constant
-                                            ExprKind::Path(ref path) => {
-                                                if let Res::Def(DefKind::Const, ..) = cx.qpath_res(path, init.hir_id) {
-                                                    emit_lint(cx, vec, pushed_item);
-                                                }
-                                            }
-                                            _ => {},
-                                        }
-                                    }
-                                }
-                            },
-                            // constant
-                            Res::Def(DefKind::Const, ..) => emit_lint(cx, vec, pushed_item),
-                            _ => {},
-                        }
-                    },
-                    ExprKind::Lit(..) => emit_lint(cx, vec, pushed_item),
-                    _ => {},
-                }
-            }
-        }
-    }
-}
-
-/// Checks for looping over a range and then indexing a sequence with it.
-/// The iteratee must be a range literal.
-#[allow(clippy::too_many_lines)]
-fn check_for_loop_range<'tcx>(
-    cx: &LateContext<'tcx>,
-    pat: &'tcx Pat<'_>,
-    arg: &'tcx Expr<'_>,
-    body: &'tcx Expr<'_>,
-    expr: &'tcx Expr<'_>,
-) {
-    if let Some(higher::Range {
-        start: Some(start),
-        ref end,
-        limits,
-    }) = higher::range(arg)
-    {
-        // the var must be a single name
-        if let PatKind::Binding(_, canonical_id, ident, _) = pat.kind {
-            let mut visitor = VarVisitor {
-                cx,
-                var: canonical_id,
-                indexed_mut: FxHashSet::default(),
-                indexed_indirectly: FxHashMap::default(),
-                indexed_directly: FxHashMap::default(),
-                referenced: FxHashSet::default(),
-                nonindex: false,
-                prefer_mutable: false,
-            };
-            walk_expr(&mut visitor, body);
-
-            // linting condition: we only indexed one variable, and indexed it directly
-            if visitor.indexed_indirectly.is_empty() && visitor.indexed_directly.len() == 1 {
-                let (indexed, (indexed_extent, indexed_ty)) = visitor
-                    .indexed_directly
-                    .into_iter()
-                    .next()
-                    .expect("already checked that we have exactly 1 element");
-
-                // ensure that the indexed variable was declared before the loop, see #601
-                if let Some(indexed_extent) = indexed_extent {
-                    let parent_id = cx.tcx.hir().get_parent_item(expr.hir_id);
-                    let parent_def_id = cx.tcx.hir().local_def_id(parent_id);
-                    let region_scope_tree = cx.tcx.region_scope_tree(parent_def_id);
-                    let pat_extent = region_scope_tree.var_scope(pat.hir_id.local_id);
-                    if region_scope_tree.is_subscope_of(indexed_extent, pat_extent) {
-                        return;
-                    }
-                }
-
-                // don't lint if the container that is indexed does not have .iter() method
-                let has_iter = has_iter_method(cx, indexed_ty);
-                if has_iter.is_none() {
-                    return;
-                }
-
-                // don't lint if the container that is indexed into is also used without
-                // indexing
-                if visitor.referenced.contains(&indexed) {
-                    return;
-                }
-
-                let starts_at_zero = is_integer_const(cx, start, 0);
-
-                let skip = if starts_at_zero {
-                    String::new()
-                } else if visitor.indexed_mut.contains(&indexed) && contains_name(indexed, start) {
-                    return;
-                } else {
-                    format!(".skip({})", snippet(cx, start.span, ".."))
-                };
-
-                let mut end_is_start_plus_val = false;
-
-                let take = if let Some(end) = *end {
-                    let mut take_expr = end;
-
-                    if let ExprKind::Binary(ref op, ref left, ref right) = end.kind {
-                        if let BinOpKind::Add = op.node {
-                            let start_equal_left = SpanlessEq::new(cx).eq_expr(start, left);
-                            let start_equal_right = SpanlessEq::new(cx).eq_expr(start, right);
-
-                            if start_equal_left {
-                                take_expr = right;
-                            } else if start_equal_right {
-                                take_expr = left;
-                            }
-
-                            end_is_start_plus_val = start_equal_left | start_equal_right;
-                        }
-                    }
-
-                    if is_len_call(end, indexed) || is_end_eq_array_len(cx, end, limits, indexed_ty) {
-                        String::new()
-                    } else if visitor.indexed_mut.contains(&indexed) && contains_name(indexed, take_expr) {
-                        return;
-                    } else {
-                        match limits {
-                            ast::RangeLimits::Closed => {
-                                let take_expr = sugg::Sugg::hir(cx, take_expr, "<count>");
-                                format!(".take({})", take_expr + sugg::ONE)
-                            },
-                            ast::RangeLimits::HalfOpen => format!(".take({})", snippet(cx, take_expr.span, "..")),
-                        }
-                    }
-                } else {
-                    String::new()
-                };
-
-                let (ref_mut, method) = if visitor.indexed_mut.contains(&indexed) {
-                    ("mut ", "iter_mut")
-                } else {
-                    ("", "iter")
-                };
-
-                let take_is_empty = take.is_empty();
-                let mut method_1 = take;
-                let mut method_2 = skip;
-
-                if end_is_start_plus_val {
-                    mem::swap(&mut method_1, &mut method_2);
-                }
-
-                if visitor.nonindex {
-                    span_lint_and_then(
-                        cx,
-                        NEEDLESS_RANGE_LOOP,
-                        expr.span,
-                        &format!("the loop variable `{}` is used to index `{}`", ident.name, indexed),
-                        |diag| {
-                            multispan_sugg(
-                                diag,
-                                "consider using an iterator",
-                                vec![
-                                    (pat.span, format!("({}, <item>)", ident.name)),
-                                    (
-                                        arg.span,
-                                        format!("{}.{}().enumerate(){}{}", indexed, method, method_1, method_2),
-                                    ),
-                                ],
-                            );
-                        },
-                    );
-                } else {
-                    let repl = if starts_at_zero && take_is_empty {
-                        format!("&{}{}", ref_mut, indexed)
-                    } else {
-                        format!("{}.{}(){}{}", indexed, method, method_1, method_2)
-                    };
-
-                    span_lint_and_then(
-                        cx,
-                        NEEDLESS_RANGE_LOOP,
-                        expr.span,
-                        &format!("the loop variable `{}` is only used to index `{}`", ident.name, indexed),
-                        |diag| {
-                            multispan_sugg(
-                                diag,
-                                "consider using an iterator",
-                                vec![(pat.span, "<item>".to_string()), (arg.span, repl)],
-                            );
-                        },
-                    );
-                }
-            }
-        }
-    }
-}
-
-fn is_len_call(expr: &Expr<'_>, var: Symbol) -> bool {
-    if_chain! {
-        if let ExprKind::MethodCall(ref method, _, ref len_args, _) = expr.kind;
-        if len_args.len() == 1;
-        if method.ident.name == sym!(len);
-        if let ExprKind::Path(QPath::Resolved(_, ref path)) = len_args[0].kind;
-        if path.segments.len() == 1;
-        if path.segments[0].ident.name == var;
-        then {
-            return true;
-        }
-    }
-
-    false
-}
-
-fn is_end_eq_array_len<'tcx>(
-    cx: &LateContext<'tcx>,
-    end: &Expr<'_>,
-    limits: ast::RangeLimits,
-    indexed_ty: Ty<'tcx>,
-) -> bool {
-    if_chain! {
-        if let ExprKind::Lit(ref lit) = end.kind;
-        if let ast::LitKind::Int(end_int, _) = lit.node;
-        if let ty::Array(_, arr_len_const) = indexed_ty.kind();
-        if let Some(arr_len) = arr_len_const.try_eval_usize(cx.tcx, cx.param_env);
-        then {
-            return match limits {
-                ast::RangeLimits::Closed => end_int + 1 >= arr_len.into(),
-                ast::RangeLimits::HalfOpen => end_int >= arr_len.into(),
-            };
-        }
-    }
-
-    false
-}
-
-fn lint_iter_method(cx: &LateContext<'_>, args: &[Expr<'_>], arg: &Expr<'_>, method_name: &str) {
-    let mut applicability = Applicability::MachineApplicable;
-    let object = snippet_with_applicability(cx, args[0].span, "_", &mut applicability);
-    let muta = if method_name == "iter_mut" { "mut " } else { "" };
-    span_lint_and_sugg(
-        cx,
-        EXPLICIT_ITER_LOOP,
-        arg.span,
-        "it is more concise to loop over references to containers instead of using explicit \
-         iteration methods",
-        "to write this more concisely, try",
-        format!("&{}{}", muta, object),
-        applicability,
-    )
-}
-
-fn check_for_loop_arg(cx: &LateContext<'_>, pat: &Pat<'_>, arg: &Expr<'_>, expr: &Expr<'_>) {
-    let mut next_loop_linted = false; // whether or not ITER_NEXT_LOOP lint was used
-    if let ExprKind::MethodCall(ref method, _, ref args, _) = arg.kind {
-        // just the receiver, no arguments
-        if args.len() == 1 {
-            let method_name = &*method.ident.as_str();
-            // check for looping over x.iter() or x.iter_mut(), could use &x or &mut x
-            if method_name == "iter" || method_name == "iter_mut" {
-                if is_ref_iterable_type(cx, &args[0]) {
-                    lint_iter_method(cx, args, arg, method_name);
-                }
-            } else if method_name == "into_iter" && match_trait_method(cx, arg, &paths::INTO_ITERATOR) {
-                let receiver_ty = cx.typeck_results().expr_ty(&args[0]);
-                let receiver_ty_adjusted = cx.typeck_results().expr_ty_adjusted(&args[0]);
-                if TyS::same_type(receiver_ty, receiver_ty_adjusted) {
-                    let mut applicability = Applicability::MachineApplicable;
-                    let object = snippet_with_applicability(cx, args[0].span, "_", &mut applicability);
-                    span_lint_and_sugg(
-                        cx,
-                        EXPLICIT_INTO_ITER_LOOP,
-                        arg.span,
-                        "it is more concise to loop over containers instead of using explicit \
-                         iteration methods",
-                        "to write this more concisely, try",
-                        object.to_string(),
-                        applicability,
-                    );
-                } else {
-                    let ref_receiver_ty = cx.tcx.mk_ref(
-                        cx.tcx.lifetimes.re_erased,
-                        ty::TypeAndMut {
-                            ty: receiver_ty,
-                            mutbl: Mutability::Not,
-                        },
-                    );
-                    if TyS::same_type(receiver_ty_adjusted, ref_receiver_ty) {
-                        lint_iter_method(cx, args, arg, method_name)
-                    }
-                }
-            } else if method_name == "next" && match_trait_method(cx, arg, &paths::ITERATOR) {
-                span_lint(
-                    cx,
-                    ITER_NEXT_LOOP,
-                    expr.span,
-                    "you are iterating over `Iterator::next()` which is an Option; this will compile but is \
-                    probably not what you want",
-                );
-                next_loop_linted = true;
-            }
-        }
-    }
-    if !next_loop_linted {
-        check_arg_type(cx, pat, arg);
-    }
-}
-
-/// Checks for `for` loops over `Option`s and `Result`s.
-fn check_arg_type(cx: &LateContext<'_>, pat: &Pat<'_>, arg: &Expr<'_>) {
-    let ty = cx.typeck_results().expr_ty(arg);
-    if is_type_diagnostic_item(cx, ty, sym::option_type) {
-        span_lint_and_help(
-            cx,
-            FOR_LOOPS_OVER_FALLIBLES,
-            arg.span,
-            &format!(
-                "for loop over `{0}`, which is an `Option`. This is more readably written as an \
-                `if let` statement",
-                snippet(cx, arg.span, "_")
-            ),
-            None,
-            &format!(
-                "consider replacing `for {0} in {1}` with `if let Some({0}) = {1}`",
-                snippet(cx, pat.span, "_"),
-                snippet(cx, arg.span, "_")
-            ),
-        );
-    } else if is_type_diagnostic_item(cx, ty, sym::result_type) {
-        span_lint_and_help(
-            cx,
-            FOR_LOOPS_OVER_FALLIBLES,
-            arg.span,
-            &format!(
-                "for loop over `{0}`, which is a `Result`. This is more readably written as an \
-                `if let` statement",
-                snippet(cx, arg.span, "_")
-            ),
-            None,
-            &format!(
-                "consider replacing `for {0} in {1}` with `if let Ok({0}) = {1}`",
-                snippet(cx, pat.span, "_"),
-                snippet(cx, arg.span, "_")
-            ),
-        );
-    }
-}
-
-// To trigger the EXPLICIT_COUNTER_LOOP lint, a variable must be
-// incremented exactly once in the loop body, and initialized to zero
-// at the start of the loop.
-fn check_for_loop_explicit_counter<'tcx>(
-    cx: &LateContext<'tcx>,
-    pat: &'tcx Pat<'_>,
-    arg: &'tcx Expr<'_>,
-    body: &'tcx Expr<'_>,
-    expr: &'tcx Expr<'_>,
-) {
-    // Look for variables that are incremented once per loop iteration.
-    let mut increment_visitor = IncrementVisitor::new(cx);
-    walk_expr(&mut increment_visitor, body);
-
-    // For each candidate, check the parent block to see if
-    // it's initialized to zero at the start of the loop.
-    if let Some(block) = get_enclosing_block(&cx, expr.hir_id) {
-        for id in increment_visitor.into_results() {
-            let mut initialize_visitor = InitializeVisitor::new(cx, expr, id);
-            walk_block(&mut initialize_visitor, block);
-
-            if_chain! {
-                if let Some((name, initializer)) = initialize_visitor.get_result();
-                if is_integer_const(cx, initializer, 0);
-                then {
-                    let mut applicability = Applicability::MachineApplicable;
-
-                    let for_span = get_span_of_entire_for_loop(expr);
-
-                    span_lint_and_sugg(
-                        cx,
-                        EXPLICIT_COUNTER_LOOP,
-                        for_span.with_hi(arg.span.hi()),
-                        &format!("the variable `{}` is used as a loop counter", name),
-                        "consider using",
-                        format!(
-                            "for ({}, {}) in {}.enumerate()",
-                            name,
-                            snippet_with_applicability(cx, pat.span, "item", &mut applicability),
-                            make_iterator_snippet(cx, arg, &mut applicability),
-                        ),
-                        applicability,
-                    );
-                }
-            }
-        }
-    }
-}
-
-/// If `arg` was the argument to a `for` loop, return the "cleanest" way of writing the
-/// actual `Iterator` that the loop uses.
-fn make_iterator_snippet(cx: &LateContext<'_>, arg: &Expr<'_>, applic_ref: &mut Applicability) -> String {
-    let impls_iterator = get_trait_def_id(cx, &paths::ITERATOR).map_or(false, |id| {
-        implements_trait(cx, cx.typeck_results().expr_ty(arg), id, &[])
-    });
-    if impls_iterator {
-        format!(
-            "{}",
-            sugg::Sugg::hir_with_applicability(cx, arg, "_", applic_ref).maybe_par()
-        )
-    } else {
-        // (&x).into_iter() ==> x.iter()
-        // (&mut x).into_iter() ==> x.iter_mut()
-        match &arg.kind {
-            ExprKind::AddrOf(BorrowKind::Ref, mutability, arg_inner)
-                if has_iter_method(cx, cx.typeck_results().expr_ty(&arg_inner)).is_some() =>
-            {
-                let meth_name = match mutability {
-                    Mutability::Mut => "iter_mut",
-                    Mutability::Not => "iter",
-                };
-                format!(
-                    "{}.{}()",
-                    sugg::Sugg::hir_with_applicability(cx, &arg_inner, "_", applic_ref).maybe_par(),
-                    meth_name,
-                )
-            }
-            _ => format!(
-                "{}.into_iter()",
-                sugg::Sugg::hir_with_applicability(cx, arg, "_", applic_ref).maybe_par()
-            ),
-        }
-    }
-}
-
-/// Checks for the `FOR_KV_MAP` lint.
-fn check_for_loop_over_map_kv<'tcx>(
-    cx: &LateContext<'tcx>,
-    pat: &'tcx Pat<'_>,
-    arg: &'tcx Expr<'_>,
-    body: &'tcx Expr<'_>,
-    expr: &'tcx Expr<'_>,
-) {
-    let pat_span = pat.span;
-
-    if let PatKind::Tuple(ref pat, _) = pat.kind {
-        if pat.len() == 2 {
-            let arg_span = arg.span;
-            let (new_pat_span, kind, ty, mutbl) = match *cx.typeck_results().expr_ty(arg).kind() {
-                ty::Ref(_, ty, mutbl) => match (&pat[0].kind, &pat[1].kind) {
-                    (key, _) if pat_is_wild(cx, key, body) => (pat[1].span, "value", ty, mutbl),
-                    (_, value) if pat_is_wild(cx, value, body) => (pat[0].span, "key", ty, Mutability::Not),
-                    _ => return,
-                },
-                _ => return,
-            };
-            let mutbl = match mutbl {
-                Mutability::Not => "",
-                Mutability::Mut => "_mut",
-            };
-            let arg = match arg.kind {
-                ExprKind::AddrOf(BorrowKind::Ref, _, ref expr) => &**expr,
-                _ => arg,
-            };
-
-            if is_type_diagnostic_item(cx, ty, sym!(hashmap_type)) || match_type(cx, ty, &paths::BTREEMAP) {
-                span_lint_and_then(
-                    cx,
-                    FOR_KV_MAP,
-                    expr.span,
-                    &format!("you seem to want to iterate on a map's {}s", kind),
-                    |diag| {
-                        let map = sugg::Sugg::hir(cx, arg, "map");
-                        multispan_sugg(
-                            diag,
-                            "use the corresponding method",
-                            vec![
-                                (pat_span, snippet(cx, new_pat_span, kind).into_owned()),
-                                (arg_span, format!("{}.{}s{}()", map.maybe_par(), kind, mutbl)),
-                            ],
-                        );
-                    },
-                );
-            }
-        }
-    }
-}
-
-fn check_for_single_element_loop<'tcx>(
-    cx: &LateContext<'tcx>,
-    pat: &'tcx Pat<'_>,
-    arg: &'tcx Expr<'_>,
-    body: &'tcx Expr<'_>,
-    expr: &'tcx Expr<'_>,
-) {
-    if_chain! {
-        if let ExprKind::AddrOf(BorrowKind::Ref, _, ref arg_expr) = arg.kind;
-        if let PatKind::Binding(.., target, _) = pat.kind;
-        if let ExprKind::Array([arg_expression]) = arg_expr.kind;
-        if let ExprKind::Path(ref list_item) = arg_expression.kind;
-        if let Some(list_item_name) = single_segment_path(list_item).map(|ps| ps.ident.name);
-        if let ExprKind::Block(ref block, _) = body.kind;
-        if !block.stmts.is_empty();
-
-        then {
-            let for_span = get_span_of_entire_for_loop(expr);
-            let mut block_str = snippet(cx, block.span, "..").into_owned();
-            block_str.remove(0);
-            block_str.pop();
-
-
-            span_lint_and_sugg(
-                cx,
-                SINGLE_ELEMENT_LOOP,
-                for_span,
-                "for loop over a single element",
-                "try",
-                format!("{{\n{}let {} = &{};{}}}", " ".repeat(indent_of(cx, block.stmts[0].span).unwrap_or(0)), target.name, list_item_name, block_str),
-                Applicability::MachineApplicable
-            )
-        }
-    }
-}
-
-/// Check for unnecessary `if let` usage in a for loop where only the `Some` or `Ok` variant of the
-/// iterator element is used.
-fn check_manual_flatten<'tcx>(
-    cx: &LateContext<'tcx>,
-    pat: &'tcx Pat<'_>,
-    arg: &'tcx Expr<'_>,
-    body: &'tcx Expr<'_>,
-    span: Span,
-) {
-    if let ExprKind::Block(ref block, _) = body.kind {
-        // Ensure the `if let` statement is the only expression or statement in the for-loop
-        let inner_expr = if block.stmts.len() == 1 && block.expr.is_none() {
-            let match_stmt = &block.stmts[0];
-            if let StmtKind::Semi(inner_expr) = match_stmt.kind {
-                Some(inner_expr)
-            } else {
-                None
-            }
-        } else if block.stmts.is_empty() {
-            block.expr
-        } else {
-            None
-        };
-
-        if_chain! {
-            if let Some(inner_expr) = inner_expr;
-            if let ExprKind::Match(
-                ref match_expr, ref match_arms, MatchSource::IfLetDesugar{ contains_else_clause: false }
-            ) = inner_expr.kind;
-            // Ensure match_expr in `if let` statement is the same as the pat from the for-loop
-            if let PatKind::Binding(_, pat_hir_id, _, _) = pat.kind;
-            if path_to_local_id(match_expr, pat_hir_id);
-            // Ensure the `if let` statement is for the `Some` variant of `Option` or the `Ok` variant of `Result`
-            if let PatKind::TupleStruct(QPath::Resolved(None, path), _, _) = match_arms[0].pat.kind;
-            let some_ctor = is_some_ctor(cx, path.res);
-            let ok_ctor = is_ok_ctor(cx, path.res);
-            if some_ctor || ok_ctor;
-            let if_let_type = if some_ctor { "Some" } else { "Ok" };
-
-            then {
-                // Prepare the error message
-                let msg = format!("unnecessary `if let` since only the `{}` variant of the iterator element is used", if_let_type);
-
-                // Prepare the help message
-                let mut applicability = Applicability::MaybeIncorrect;
-                let arg_snippet = make_iterator_snippet(cx, arg, &mut applicability);
-
-                span_lint_and_then(
-                    cx,
-                    MANUAL_FLATTEN,
-                    span,
-                    &msg,
-                    |diag| {
-                        let sugg = format!("{}.flatten()", arg_snippet);
-                        diag.span_suggestion(
-                            arg.span,
-                            "try",
-                            sugg,
-                            Applicability::MaybeIncorrect,
-                        );
-                        diag.span_help(
-                            inner_expr.span,
-                            "...and remove the `if let` statement in the for loop",
-                        );
-                    }
-                );
-            }
-        }
-    }
-}
-
-struct MutatePairDelegate<'a, 'tcx> {
-    cx: &'a LateContext<'tcx>,
-    hir_id_low: Option<HirId>,
-    hir_id_high: Option<HirId>,
-    span_low: Option<Span>,
-    span_high: Option<Span>,
-}
-
-impl<'tcx> Delegate<'tcx> for MutatePairDelegate<'_, 'tcx> {
-    fn consume(&mut self, _: &PlaceWithHirId<'tcx>, _: HirId, _: ConsumeMode) {}
-
-    fn borrow(&mut self, cmt: &PlaceWithHirId<'tcx>, diag_expr_id: HirId, bk: ty::BorrowKind) {
-        if let ty::BorrowKind::MutBorrow = bk {
-            if let PlaceBase::Local(id) = cmt.place.base {
-                if Some(id) == self.hir_id_low {
-                    self.span_low = Some(self.cx.tcx.hir().span(diag_expr_id))
-                }
-                if Some(id) == self.hir_id_high {
-                    self.span_high = Some(self.cx.tcx.hir().span(diag_expr_id))
-                }
-            }
-        }
-    }
-
-    fn mutate(&mut self, cmt: &PlaceWithHirId<'tcx>, diag_expr_id: HirId) {
-        if let PlaceBase::Local(id) = cmt.place.base {
-            if Some(id) == self.hir_id_low {
-                self.span_low = Some(self.cx.tcx.hir().span(diag_expr_id))
-            }
-            if Some(id) == self.hir_id_high {
-                self.span_high = Some(self.cx.tcx.hir().span(diag_expr_id))
-            }
-        }
-    }
-}
-
-impl MutatePairDelegate<'_, '_> {
-    fn mutation_span(&self) -> (Option<Span>, Option<Span>) {
-        (self.span_low, self.span_high)
-    }
-}
-
-fn check_for_mut_range_bound(cx: &LateContext<'_>, arg: &Expr<'_>, body: &Expr<'_>) {
-    if let Some(higher::Range {
-        start: Some(start),
-        end: Some(end),
-        ..
-    }) = higher::range(arg)
-    {
-        let mut_ids = vec![check_for_mutability(cx, start), check_for_mutability(cx, end)];
-        if mut_ids[0].is_some() || mut_ids[1].is_some() {
-            let (span_low, span_high) = check_for_mutation(cx, body, &mut_ids);
-            mut_warn_with_span(cx, span_low);
-            mut_warn_with_span(cx, span_high);
-        }
-    }
-}
-
-fn mut_warn_with_span(cx: &LateContext<'_>, span: Option<Span>) {
-    if let Some(sp) = span {
-        span_lint(
-            cx,
-            MUT_RANGE_BOUND,
-            sp,
-            "attempt to mutate range bound within loop; note that the range of the loop is unchanged",
-        );
-    }
-}
-
-fn check_for_mutability(cx: &LateContext<'_>, bound: &Expr<'_>) -> Option<HirId> {
-    if_chain! {
-        if let Some(hir_id) = path_to_local(bound);
-        if let Node::Binding(pat) = cx.tcx.hir().get(hir_id);
-        if let PatKind::Binding(BindingAnnotation::Mutable, ..) = pat.kind;
-        then {
-            return Some(hir_id);
-        }
-    }
-    None
-}
-
-fn check_for_mutation<'tcx>(
-    cx: &LateContext<'tcx>,
-    body: &Expr<'_>,
-    bound_ids: &[Option<HirId>],
-) -> (Option<Span>, Option<Span>) {
-    let mut delegate = MutatePairDelegate {
-        cx,
-        hir_id_low: bound_ids[0],
-        hir_id_high: bound_ids[1],
-        span_low: None,
-        span_high: None,
-    };
-    cx.tcx.infer_ctxt().enter(|infcx| {
-        ExprUseVisitor::new(
-            &mut delegate,
-            &infcx,
-            body.hir_id.owner,
-            cx.param_env,
-            cx.typeck_results(),
-        )
-        .walk_expr(body);
-    });
-    delegate.mutation_span()
-}
-
-/// Returns `true` if the pattern is a `PatWild` or an ident prefixed with `_`.
-fn pat_is_wild<'tcx>(cx: &LateContext<'tcx>, pat: &'tcx PatKind<'_>, body: &'tcx Expr<'_>) -> bool {
-    match *pat {
-        PatKind::Wild => true,
-        PatKind::Binding(_, id, ident, None) if ident.as_str().starts_with('_') => {
-            !LocalUsedVisitor::new(cx, id).check_expr(body)
-        },
-        _ => false,
-    }
-}
-
-struct VarVisitor<'a, 'tcx> {
-    /// context reference
-    cx: &'a LateContext<'tcx>,
-    /// var name to look for as index
-    var: HirId,
-    /// indexed variables that are used mutably
-    indexed_mut: FxHashSet<Symbol>,
-    /// indirectly indexed variables (`v[(i + 4) % N]`), the extend is `None` for global
-    indexed_indirectly: FxHashMap<Symbol, Option<region::Scope>>,
-    /// subset of `indexed` of vars that are indexed directly: `v[i]`
-    /// this will not contain cases like `v[calc_index(i)]` or `v[(i + 4) % N]`
-    indexed_directly: FxHashMap<Symbol, (Option<region::Scope>, Ty<'tcx>)>,
-    /// Any names that are used outside an index operation.
-    /// Used to detect things like `&mut vec` used together with `vec[i]`
-    referenced: FxHashSet<Symbol>,
-    /// has the loop variable been used in expressions other than the index of
-    /// an index op?
-    nonindex: bool,
-    /// Whether we are inside the `$` in `&mut $` or `$ = foo` or `$.bar`, where bar
-    /// takes `&mut self`
-    prefer_mutable: bool,
-}
-
-impl<'a, 'tcx> VarVisitor<'a, 'tcx> {
-    fn check(&mut self, idx: &'tcx Expr<'_>, seqexpr: &'tcx Expr<'_>, expr: &'tcx Expr<'_>) -> bool {
-        if_chain! {
-            // the indexed container is referenced by a name
-            if let ExprKind::Path(ref seqpath) = seqexpr.kind;
-            if let QPath::Resolved(None, ref seqvar) = *seqpath;
-            if seqvar.segments.len() == 1;
-            then {
-                let index_used_directly = path_to_local_id(idx, self.var);
-                let indexed_indirectly = {
-                    let mut used_visitor = LocalUsedVisitor::new(self.cx, self.var);
-                    walk_expr(&mut used_visitor, idx);
-                    used_visitor.used
-                };
-
-                if indexed_indirectly || index_used_directly {
-                    if self.prefer_mutable {
-                        self.indexed_mut.insert(seqvar.segments[0].ident.name);
-                    }
-                    let res = self.cx.qpath_res(seqpath, seqexpr.hir_id);
-                    match res {
-                        Res::Local(hir_id) => {
-                            let parent_id = self.cx.tcx.hir().get_parent_item(expr.hir_id);
-                            let parent_def_id = self.cx.tcx.hir().local_def_id(parent_id);
-                            let extent = self.cx.tcx.region_scope_tree(parent_def_id).var_scope(hir_id.local_id);
-                            if indexed_indirectly {
-                                self.indexed_indirectly.insert(seqvar.segments[0].ident.name, Some(extent));
-                            }
-                            if index_used_directly {
-                                self.indexed_directly.insert(
-                                    seqvar.segments[0].ident.name,
-                                    (Some(extent), self.cx.typeck_results().node_type(seqexpr.hir_id)),
-                                );
-                            }
-                            return false;  // no need to walk further *on the variable*
-                        }
-                        Res::Def(DefKind::Static | DefKind::Const, ..) => {
-                            if indexed_indirectly {
-                                self.indexed_indirectly.insert(seqvar.segments[0].ident.name, None);
-                            }
-                            if index_used_directly {
-                                self.indexed_directly.insert(
-                                    seqvar.segments[0].ident.name,
-                                    (None, self.cx.typeck_results().node_type(seqexpr.hir_id)),
-                                );
-                            }
-                            return false;  // no need to walk further *on the variable*
-                        }
-                        _ => (),
-                    }
-                }
-            }
-        }
-        true
-    }
-}
-
-impl<'a, 'tcx> Visitor<'tcx> for VarVisitor<'a, 'tcx> {
-    type Map = Map<'tcx>;
-
-    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
-        if_chain! {
-            // a range index op
-            if let ExprKind::MethodCall(ref meth, _, ref args, _) = expr.kind;
-            if (meth.ident.name == sym::index && match_trait_method(self.cx, expr, &paths::INDEX))
-                || (meth.ident.name == sym::index_mut && match_trait_method(self.cx, expr, &paths::INDEX_MUT));
-            if !self.check(&args[1], &args[0], expr);
-            then { return }
-        }
-
-        if_chain! {
-            // an index op
-            if let ExprKind::Index(ref seqexpr, ref idx) = expr.kind;
-            if !self.check(idx, seqexpr, expr);
-            then { return }
-        }
-
-        if_chain! {
-            // directly using a variable
-            if let ExprKind::Path(QPath::Resolved(None, path)) = expr.kind;
-            if let Res::Local(local_id) = path.res;
-            then {
-                if local_id == self.var {
-                    self.nonindex = true;
-                } else {
-                    // not the correct variable, but still a variable
-                    self.referenced.insert(path.segments[0].ident.name);
-                }
-            }
-        }
-
-        let old = self.prefer_mutable;
-        match expr.kind {
-            ExprKind::AssignOp(_, ref lhs, ref rhs) | ExprKind::Assign(ref lhs, ref rhs, _) => {
-                self.prefer_mutable = true;
-                self.visit_expr(lhs);
-                self.prefer_mutable = false;
-                self.visit_expr(rhs);
-            },
-            ExprKind::AddrOf(BorrowKind::Ref, mutbl, ref expr) => {
-                if mutbl == Mutability::Mut {
-                    self.prefer_mutable = true;
-                }
-                self.visit_expr(expr);
-            },
-            ExprKind::Call(ref f, args) => {
-                self.visit_expr(f);
-                for expr in args {
-                    let ty = self.cx.typeck_results().expr_ty_adjusted(expr);
-                    self.prefer_mutable = false;
-                    if let ty::Ref(_, _, mutbl) = *ty.kind() {
-                        if mutbl == Mutability::Mut {
-                            self.prefer_mutable = true;
-                        }
-                    }
-                    self.visit_expr(expr);
-                }
-            },
-            ExprKind::MethodCall(_, _, args, _) => {
-                let def_id = self.cx.typeck_results().type_dependent_def_id(expr.hir_id).unwrap();
-                for (ty, expr) in self.cx.tcx.fn_sig(def_id).inputs().skip_binder().iter().zip(args) {
-                    self.prefer_mutable = false;
-                    if let ty::Ref(_, _, mutbl) = *ty.kind() {
-                        if mutbl == Mutability::Mut {
-                            self.prefer_mutable = true;
-                        }
-                    }
-                    self.visit_expr(expr);
-                }
-            },
-            ExprKind::Closure(_, _, body_id, ..) => {
-                let body = self.cx.tcx.hir().body(body_id);
-                self.visit_expr(&body.value);
-            },
-            _ => walk_expr(self, expr),
-        }
-        self.prefer_mutable = old;
-    }
-    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-        NestedVisitorMap::None
-    }
-}
-
-fn is_used_inside<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, container: &'tcx Expr<'_>) -> bool {
-    let def_id = match path_to_local(expr) {
-        Some(id) => id,
-        None => return false,
-    };
-    if let Some(used_mutably) = mutated_variables(container, cx) {
-        if used_mutably.contains(&def_id) {
-            return true;
-        }
-    }
-    false
-}
-
-fn is_iterator_used_after_while_let<'tcx>(cx: &LateContext<'tcx>, iter_expr: &'tcx Expr<'_>) -> bool {
-    let def_id = match path_to_local(iter_expr) {
-        Some(id) => id,
-        None => return false,
-    };
-    let mut visitor = VarUsedAfterLoopVisitor {
-        def_id,
-        iter_expr_id: iter_expr.hir_id,
-        past_while_let: false,
-        var_used_after_while_let: false,
-    };
-    if let Some(enclosing_block) = get_enclosing_block(cx, def_id) {
-        walk_block(&mut visitor, enclosing_block);
-    }
-    visitor.var_used_after_while_let
-}
-
-struct VarUsedAfterLoopVisitor {
-    def_id: HirId,
-    iter_expr_id: HirId,
-    past_while_let: bool,
-    var_used_after_while_let: bool,
-}
-
-impl<'tcx> Visitor<'tcx> for VarUsedAfterLoopVisitor {
-    type Map = Map<'tcx>;
-
-    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
-        if self.past_while_let {
-            if path_to_local_id(expr, self.def_id) {
-                self.var_used_after_while_let = true;
-            }
-        } else if self.iter_expr_id == expr.hir_id {
-            self.past_while_let = true;
-        }
-        walk_expr(self, expr);
-    }
-    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-        NestedVisitorMap::None
-    }
-}
-
-/// Returns `true` if the type of expr is one that provides `IntoIterator` impls
-/// for `&T` and `&mut T`, such as `Vec`.
-#[rustfmt::skip]
-fn is_ref_iterable_type(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
-    // no walk_ptrs_ty: calling iter() on a reference can make sense because it
-    // will allow further borrows afterwards
-    let ty = cx.typeck_results().expr_ty(e);
-    is_iterable_array(ty, cx) ||
-    is_type_diagnostic_item(cx, ty, sym::vec_type) ||
-    match_type(cx, ty, &paths::LINKED_LIST) ||
-    is_type_diagnostic_item(cx, ty, sym!(hashmap_type)) ||
-    is_type_diagnostic_item(cx, ty, sym!(hashset_type)) ||
-    is_type_diagnostic_item(cx, ty, sym!(vecdeque_type)) ||
-    match_type(cx, ty, &paths::BINARY_HEAP) ||
-    match_type(cx, ty, &paths::BTREEMAP) ||
-    match_type(cx, ty, &paths::BTREESET)
-}
-
-fn is_iterable_array<'tcx>(ty: Ty<'tcx>, cx: &LateContext<'tcx>) -> bool {
-    // IntoIterator is currently only implemented for array sizes <= 32 in rustc
-    match ty.kind() {
-        ty::Array(_, n) => n
-            .try_eval_usize(cx.tcx, cx.param_env)
-            .map_or(false, |val| (0..=32).contains(&val)),
-        _ => false,
-    }
-}
-
-/// If a block begins with a statement (possibly a `let` binding) and has an
-/// expression, return it.
-fn extract_expr_from_first_stmt<'tcx>(block: &Block<'tcx>) -> Option<&'tcx Expr<'tcx>> {
-    if block.stmts.is_empty() {
-        return None;
-    }
-    if let StmtKind::Local(ref local) = block.stmts[0].kind {
-        local.init //.map(|expr| expr)
-    } else {
-        None
-    }
-}
-
-/// If a block begins with an expression (with or without semicolon), return it.
-fn extract_first_expr<'tcx>(block: &Block<'tcx>) -> Option<&'tcx Expr<'tcx>> {
-    match block.expr {
-        Some(ref expr) if block.stmts.is_empty() => Some(expr),
-        None if !block.stmts.is_empty() => match block.stmts[0].kind {
-            StmtKind::Expr(ref expr) | StmtKind::Semi(ref expr) => Some(expr),
-            StmtKind::Local(..) | StmtKind::Item(..) => None,
-        },
-        _ => None,
-    }
-}
-
-/// Returns `true` if expr contains a single break expr without destination label
-/// and
-/// passed expression. The expression may be within a block.
-fn is_simple_break_expr(expr: &Expr<'_>) -> bool {
-    match expr.kind {
-        ExprKind::Break(dest, ref passed_expr) if dest.label.is_none() && passed_expr.is_none() => true,
-        ExprKind::Block(ref b, _) => extract_first_expr(b).map_or(false, |subexpr| is_simple_break_expr(subexpr)),
-        _ => false,
-    }
-}
-
-#[derive(Debug, PartialEq)]
-enum IncrementVisitorVarState {
-    Initial,  // Not examined yet
-    IncrOnce, // Incremented exactly once, may be a loop counter
-    DontWarn,
-}
-
-/// Scan a for loop for variables that are incremented exactly once and not used after that.
-struct IncrementVisitor<'a, 'tcx> {
-    cx: &'a LateContext<'tcx>,                          // context reference
-    states: FxHashMap<HirId, IncrementVisitorVarState>, // incremented variables
-    depth: u32,                                         // depth of conditional expressions
-    done: bool,
-}
-
-impl<'a, 'tcx> IncrementVisitor<'a, 'tcx> {
-    fn new(cx: &'a LateContext<'tcx>) -> Self {
-        Self {
-            cx,
-            states: FxHashMap::default(),
-            depth: 0,
-            done: false,
-        }
-    }
-
-    fn into_results(self) -> impl Iterator<Item = HirId> {
-        self.states.into_iter().filter_map(|(id, state)| {
-            if state == IncrementVisitorVarState::IncrOnce {
-                Some(id)
-            } else {
-                None
-            }
-        })
-    }
-}
-
-impl<'a, 'tcx> Visitor<'tcx> for IncrementVisitor<'a, 'tcx> {
-    type Map = Map<'tcx>;
-
-    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
-        if self.done {
-            return;
-        }
-
-        // If node is a variable
-        if let Some(def_id) = path_to_local(expr) {
-            if let Some(parent) = get_parent_expr(self.cx, expr) {
-                let state = self.states.entry(def_id).or_insert(IncrementVisitorVarState::Initial);
-                if *state == IncrementVisitorVarState::IncrOnce {
-                    *state = IncrementVisitorVarState::DontWarn;
-                    return;
-                }
-
-                match parent.kind {
-                    ExprKind::AssignOp(op, ref lhs, ref rhs) => {
-                        if lhs.hir_id == expr.hir_id {
-                            *state = if op.node == BinOpKind::Add
-                                && is_integer_const(self.cx, rhs, 1)
-                                && *state == IncrementVisitorVarState::Initial
-                                && self.depth == 0
-                            {
-                                IncrementVisitorVarState::IncrOnce
-                            } else {
-                                // Assigned some other value or assigned multiple times
-                                IncrementVisitorVarState::DontWarn
-                            };
-                        }
-                    },
-                    ExprKind::Assign(ref lhs, _, _) if lhs.hir_id == expr.hir_id => {
-                        *state = IncrementVisitorVarState::DontWarn
-                    },
-                    ExprKind::AddrOf(BorrowKind::Ref, mutability, _) if mutability == Mutability::Mut => {
-                        *state = IncrementVisitorVarState::DontWarn
-                    },
-                    _ => (),
-                }
-            }
-
-            walk_expr(self, expr);
-        } else if is_loop(expr) || is_conditional(expr) {
-            self.depth += 1;
-            walk_expr(self, expr);
-            self.depth -= 1;
-        } else if let ExprKind::Continue(_) = expr.kind {
-            self.done = true;
-        } else {
-            walk_expr(self, expr);
-        }
-    }
-    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-        NestedVisitorMap::None
-    }
-}
-
-enum InitializeVisitorState<'hir> {
-    Initial,          // Not examined yet
-    Declared(Symbol), // Declared but not (yet) initialized
-    Initialized {
-        name: Symbol,
-        initializer: &'hir Expr<'hir>,
-    },
-    DontWarn,
-}
-
-/// Checks whether a variable is initialized at the start of a loop and not modified
-/// and used after the loop.
-struct InitializeVisitor<'a, 'tcx> {
-    cx: &'a LateContext<'tcx>,  // context reference
-    end_expr: &'tcx Expr<'tcx>, // the for loop. Stop scanning here.
-    var_id: HirId,
-    state: InitializeVisitorState<'tcx>,
-    depth: u32, // depth of conditional expressions
-    past_loop: bool,
-}
-
-impl<'a, 'tcx> InitializeVisitor<'a, 'tcx> {
-    fn new(cx: &'a LateContext<'tcx>, end_expr: &'tcx Expr<'tcx>, var_id: HirId) -> Self {
-        Self {
-            cx,
-            end_expr,
-            var_id,
-            state: InitializeVisitorState::Initial,
-            depth: 0,
-            past_loop: false,
-        }
-    }
-
-    fn get_result(&self) -> Option<(Symbol, &'tcx Expr<'tcx>)> {
-        if let InitializeVisitorState::Initialized { name, initializer } = self.state {
-            Some((name, initializer))
-        } else {
-            None
-        }
-    }
-}
-
-impl<'a, 'tcx> Visitor<'tcx> for InitializeVisitor<'a, 'tcx> {
-    type Map = Map<'tcx>;
-
-    fn visit_stmt(&mut self, stmt: &'tcx Stmt<'_>) {
-        // Look for declarations of the variable
-        if_chain! {
-            if let StmtKind::Local(ref local) = stmt.kind;
-            if local.pat.hir_id == self.var_id;
-            if let PatKind::Binding(.., ident, _) = local.pat.kind;
-            then {
-                self.state = local.init.map_or(InitializeVisitorState::Declared(ident.name), |init| {
-                    InitializeVisitorState::Initialized {
-                        initializer: init,
-                        name: ident.name,
-                    }
-                })
-            }
-        }
-        walk_stmt(self, stmt);
-    }
-
-    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
-        if matches!(self.state, InitializeVisitorState::DontWarn) {
-            return;
-        }
-        if expr.hir_id == self.end_expr.hir_id {
-            self.past_loop = true;
-            return;
-        }
-        // No need to visit expressions before the variable is
-        // declared
-        if matches!(self.state, InitializeVisitorState::Initial) {
-            return;
-        }
-
-        // If node is the desired variable, see how it's used
-        if path_to_local_id(expr, self.var_id) {
-            if self.past_loop {
-                self.state = InitializeVisitorState::DontWarn;
-                return;
-            }
-
-            if let Some(parent) = get_parent_expr(self.cx, expr) {
-                match parent.kind {
-                    ExprKind::AssignOp(_, ref lhs, _) if lhs.hir_id == expr.hir_id => {
-                        self.state = InitializeVisitorState::DontWarn;
-                    },
-                    ExprKind::Assign(ref lhs, ref rhs, _) if lhs.hir_id == expr.hir_id => {
-                        self.state = if_chain! {
-                            if self.depth == 0;
-                            if let InitializeVisitorState::Declared(name)
-                                | InitializeVisitorState::Initialized { name, ..} = self.state;
-                            then {
-                                InitializeVisitorState::Initialized { initializer: rhs, name }
-                            } else {
-                                InitializeVisitorState::DontWarn
-                            }
-                        }
-                    },
-                    ExprKind::AddrOf(BorrowKind::Ref, mutability, _) if mutability == Mutability::Mut => {
-                        self.state = InitializeVisitorState::DontWarn
-                    },
-                    _ => (),
-                }
-            }
-
-            walk_expr(self, expr);
-        } else if !self.past_loop && is_loop(expr) {
-            self.state = InitializeVisitorState::DontWarn;
-        } else if is_conditional(expr) {
-            self.depth += 1;
-            walk_expr(self, expr);
-            self.depth -= 1;
-        } else {
-            walk_expr(self, expr);
-        }
-    }
-
-    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-        NestedVisitorMap::OnlyBodies(self.cx.tcx.hir())
-    }
-}
-
-fn is_loop(expr: &Expr<'_>) -> bool {
-    matches!(expr.kind, ExprKind::Loop(..))
-}
-
-fn is_conditional(expr: &Expr<'_>) -> bool {
-    matches!(expr.kind, ExprKind::If(..) | ExprKind::Match(..))
-}
-
-fn is_nested(cx: &LateContext<'_>, match_expr: &Expr<'_>, iter_expr: &Expr<'_>) -> bool {
-    if_chain! {
-        if let Some(loop_block) = get_enclosing_block(cx, match_expr.hir_id);
-        let parent_node = cx.tcx.hir().get_parent_node(loop_block.hir_id);
-        if let Some(Node::Expr(loop_expr)) = cx.tcx.hir().find(parent_node);
-        then {
-            return is_loop_nested(cx, loop_expr, iter_expr)
-        }
-    }
-    false
-}
-
-fn is_loop_nested(cx: &LateContext<'_>, loop_expr: &Expr<'_>, iter_expr: &Expr<'_>) -> bool {
-    let mut id = loop_expr.hir_id;
-    let iter_id = if let Some(id) = path_to_local(iter_expr) {
-        id
-    } else {
-        return true;
-    };
-    loop {
-        let parent = cx.tcx.hir().get_parent_node(id);
-        if parent == id {
-            return false;
-        }
-        match cx.tcx.hir().find(parent) {
-            Some(Node::Expr(expr)) => {
-                if let ExprKind::Loop(..) = expr.kind {
-                    return true;
-                };
-            },
-            Some(Node::Block(block)) => {
-                let mut block_visitor = LoopNestVisitor {
-                    hir_id: id,
-                    iterator: iter_id,
-                    nesting: Unknown,
-                };
-                walk_block(&mut block_visitor, block);
-                if block_visitor.nesting == RuledOut {
-                    return false;
-                }
-            },
-            Some(Node::Stmt(_)) => (),
-            _ => {
-                return false;
-            },
-        }
-        id = parent;
-    }
-}
-
-#[derive(PartialEq, Eq)]
-enum Nesting {
-    Unknown,     // no nesting detected yet
-    RuledOut,    // the iterator is initialized or assigned within scope
-    LookFurther, // no nesting detected, no further walk required
-}
-
-use self::Nesting::{LookFurther, RuledOut, Unknown};
-
-struct LoopNestVisitor {
-    hir_id: HirId,
-    iterator: HirId,
-    nesting: Nesting,
-}
-
-impl<'tcx> Visitor<'tcx> for LoopNestVisitor {
-    type Map = Map<'tcx>;
-
-    fn visit_stmt(&mut self, stmt: &'tcx Stmt<'_>) {
-        if stmt.hir_id == self.hir_id {
-            self.nesting = LookFurther;
-        } else if self.nesting == Unknown {
-            walk_stmt(self, stmt);
-        }
-    }
-
-    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
-        if self.nesting != Unknown {
-            return;
-        }
-        if expr.hir_id == self.hir_id {
-            self.nesting = LookFurther;
-            return;
-        }
-        match expr.kind {
-            ExprKind::Assign(ref path, _, _) | ExprKind::AssignOp(_, ref path, _) => {
-                if path_to_local_id(path, self.iterator) {
-                    self.nesting = RuledOut;
-                }
-            },
-            _ => walk_expr(self, expr),
-        }
-    }
-
-    fn visit_pat(&mut self, pat: &'tcx Pat<'_>) {
-        if self.nesting != Unknown {
-            return;
-        }
-        if let PatKind::Binding(_, id, ..) = pat.kind {
-            if id == self.iterator {
-                self.nesting = RuledOut;
-                return;
-            }
-        }
-        walk_pat(self, pat)
-    }
-
-    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-        NestedVisitorMap::None
-    }
-}
-
-fn check_infinite_loop<'tcx>(cx: &LateContext<'tcx>, cond: &'tcx Expr<'_>, expr: &'tcx Expr<'_>) {
-    if constant(cx, cx.typeck_results(), cond).is_some() {
-        // A pure constant condition (e.g., `while false`) is not linted.
-        return;
-    }
-
-    let mut var_visitor = VarCollectorVisitor {
-        cx,
-        ids: FxHashSet::default(),
-        def_ids: FxHashMap::default(),
-        skip: false,
-    };
-    var_visitor.visit_expr(cond);
-    if var_visitor.skip {
-        return;
-    }
-    let used_in_condition = &var_visitor.ids;
-    let no_cond_variable_mutated = if let Some(used_mutably) = mutated_variables(expr, cx) {
-        used_in_condition.is_disjoint(&used_mutably)
-    } else {
-        return;
-    };
-    let mutable_static_in_cond = var_visitor.def_ids.iter().any(|(_, v)| *v);
-
-    let mut has_break_or_return_visitor = HasBreakOrReturnVisitor {
-        has_break_or_return: false,
-    };
-    has_break_or_return_visitor.visit_expr(expr);
-    let has_break_or_return = has_break_or_return_visitor.has_break_or_return;
-
-    if no_cond_variable_mutated && !mutable_static_in_cond {
-        span_lint_and_then(
-            cx,
-            WHILE_IMMUTABLE_CONDITION,
-            cond.span,
-            "variables in the condition are not mutated in the loop body",
-            |diag| {
-                diag.note("this may lead to an infinite or to a never running loop");
-
-                if has_break_or_return {
-                    diag.note("this loop contains `return`s or `break`s");
-                    diag.help("rewrite it as `if cond { loop { } }`");
-                }
-            },
-        );
-    }
-}
-
-struct HasBreakOrReturnVisitor {
-    has_break_or_return: bool,
-}
-
-impl<'tcx> Visitor<'tcx> for HasBreakOrReturnVisitor {
-    type Map = Map<'tcx>;
-
-    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
-        if self.has_break_or_return {
-            return;
-        }
-
-        match expr.kind {
-            ExprKind::Ret(_) | ExprKind::Break(_, _) => {
-                self.has_break_or_return = true;
-                return;
-            },
-            _ => {},
-        }
-
-        walk_expr(self, expr);
-    }
-
-    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-        NestedVisitorMap::None
-    }
-}
-
-/// Collects the set of variables in an expression
-/// Stops analysis if a function call is found
-/// Note: In some cases such as `self`, there are no mutable annotation,
-/// All variables definition IDs are collected
-struct VarCollectorVisitor<'a, 'tcx> {
-    cx: &'a LateContext<'tcx>,
-    ids: FxHashSet<HirId>,
-    def_ids: FxHashMap<def_id::DefId, bool>,
-    skip: bool,
-}
-
-impl<'a, 'tcx> VarCollectorVisitor<'a, 'tcx> {
-    fn insert_def_id(&mut self, ex: &'tcx Expr<'_>) {
-        if_chain! {
-            if let ExprKind::Path(ref qpath) = ex.kind;
-            if let QPath::Resolved(None, _) = *qpath;
-            let res = self.cx.qpath_res(qpath, ex.hir_id);
-            then {
-                match res {
-                    Res::Local(hir_id) => {
-                        self.ids.insert(hir_id);
-                    },
-                    Res::Def(DefKind::Static, def_id) => {
-                        let mutable = self.cx.tcx.is_mutable_static(def_id);
-                        self.def_ids.insert(def_id, mutable);
-                    },
-                    _ => {},
-                }
-            }
-        }
-    }
-}
-
-impl<'a, 'tcx> Visitor<'tcx> for VarCollectorVisitor<'a, 'tcx> {
-    type Map = Map<'tcx>;
-
-    fn visit_expr(&mut self, ex: &'tcx Expr<'_>) {
-        match ex.kind {
-            ExprKind::Path(_) => self.insert_def_id(ex),
-            // If there is any function/method call… we just stop analysis
-            ExprKind::Call(..) | ExprKind::MethodCall(..) => self.skip = true,
-
-            _ => walk_expr(self, ex),
-        }
-    }
-
-    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-        NestedVisitorMap::None
-    }
-}
-
-const NEEDLESS_COLLECT_MSG: &str = "avoid using `collect()` when not needed";
-
-fn check_needless_collect<'tcx>(expr: &'tcx Expr<'_>, cx: &LateContext<'tcx>) {
-    check_needless_collect_direct_usage(expr, cx);
-    check_needless_collect_indirect_usage(expr, cx);
-}
-fn check_needless_collect_direct_usage<'tcx>(expr: &'tcx Expr<'_>, cx: &LateContext<'tcx>) {
-    if_chain! {
-        if let ExprKind::MethodCall(ref method, _, ref args, _) = expr.kind;
-        if let ExprKind::MethodCall(ref chain_method, _, _, _) = args[0].kind;
-        if chain_method.ident.name == sym!(collect) && match_trait_method(cx, &args[0], &paths::ITERATOR);
-        if let Some(ref generic_args) = chain_method.args;
-        if let Some(GenericArg::Type(ref ty)) = generic_args.args.get(0);
-        then {
-            let ty = cx.typeck_results().node_type(ty.hir_id);
-            if is_type_diagnostic_item(cx, ty, sym::vec_type) ||
-                is_type_diagnostic_item(cx, ty, sym!(vecdeque_type)) ||
-                match_type(cx, ty, &paths::BTREEMAP) ||
-                is_type_diagnostic_item(cx, ty, sym!(hashmap_type)) {
-                if method.ident.name == sym!(len) {
-                    let span = shorten_needless_collect_span(expr);
-                    span_lint_and_sugg(
-                        cx,
-                        NEEDLESS_COLLECT,
-                        span,
-                        NEEDLESS_COLLECT_MSG,
-                        "replace with",
-                        "count()".to_string(),
-                        Applicability::MachineApplicable,
-                    );
-                }
-                if method.ident.name == sym!(is_empty) {
-                    let span = shorten_needless_collect_span(expr);
-                    span_lint_and_sugg(
-                        cx,
-                        NEEDLESS_COLLECT,
-                        span,
-                        NEEDLESS_COLLECT_MSG,
-                        "replace with",
-                        "next().is_none()".to_string(),
-                        Applicability::MachineApplicable,
-                    );
-                }
-                if method.ident.name == sym!(contains) {
-                    let contains_arg = snippet(cx, args[1].span, "??");
-                    let span = shorten_needless_collect_span(expr);
-                    span_lint_and_then(
-                        cx,
-                        NEEDLESS_COLLECT,
-                        span,
-                        NEEDLESS_COLLECT_MSG,
-                        |diag| {
-                            let (arg, pred) = contains_arg
-                                    .strip_prefix('&')
-                                    .map_or(("&x", &*contains_arg), |s| ("x", s));
-                            diag.span_suggestion(
-                                span,
-                                "replace with",
-                                format!(
-                                    "any(|{}| x == {})",
-                                    arg, pred
-                                ),
-                                Applicability::MachineApplicable,
-                            );
-                        }
-                    );
-                }
-            }
-        }
-    }
-}
-
-fn check_needless_collect_indirect_usage<'tcx>(expr: &'tcx Expr<'_>, cx: &LateContext<'tcx>) {
-    if let ExprKind::Block(ref block, _) = expr.kind {
-        for ref stmt in block.stmts {
-            if_chain! {
-                if let StmtKind::Local(
-                    Local { pat: Pat { hir_id: pat_id, kind: PatKind::Binding(_, _, ident, .. ), .. },
-                    init: Some(ref init_expr), .. }
-                ) = stmt.kind;
-                if let ExprKind::MethodCall(ref method_name, _, &[ref iter_source], ..) = init_expr.kind;
-                if method_name.ident.name == sym!(collect) && match_trait_method(cx, &init_expr, &paths::ITERATOR);
-                if let Some(ref generic_args) = method_name.args;
-                if let Some(GenericArg::Type(ref ty)) = generic_args.args.get(0);
-                if let ty = cx.typeck_results().node_type(ty.hir_id);
-                if is_type_diagnostic_item(cx, ty, sym::vec_type) ||
-                    is_type_diagnostic_item(cx, ty, sym!(vecdeque_type)) ||
-                    match_type(cx, ty, &paths::LINKED_LIST);
-                if let Some(iter_calls) = detect_iter_and_into_iters(block, *ident);
-                if iter_calls.len() == 1;
-                then {
-                    let mut used_count_visitor = UsedCountVisitor {
-                        cx,
-                        id: *pat_id,
-                        count: 0,
-                    };
-                    walk_block(&mut used_count_visitor, block);
-                    if used_count_visitor.count > 1 {
-                        return;
-                    }
-
-                    // Suggest replacing iter_call with iter_replacement, and removing stmt
-                    let iter_call = &iter_calls[0];
-                    span_lint_and_then(
-                        cx,
-                        NEEDLESS_COLLECT,
-                        stmt.span.until(iter_call.span),
-                        NEEDLESS_COLLECT_MSG,
-                        |diag| {
-                            let iter_replacement = format!("{}{}", Sugg::hir(cx, iter_source, ".."), iter_call.get_iter_method(cx));
-                            diag.multipart_suggestion(
-                                iter_call.get_suggestion_text(),
-                                vec![
-                                    (stmt.span, String::new()),
-                                    (iter_call.span, iter_replacement)
-                                ],
-                                Applicability::MachineApplicable,// MaybeIncorrect,
-                            ).emit();
-                        },
-                    );
-                }
-            }
-        }
-    }
-}
-
-struct IterFunction {
-    func: IterFunctionKind,
-    span: Span,
-}
-impl IterFunction {
-    fn get_iter_method(&self, cx: &LateContext<'_>) -> String {
-        match &self.func {
-            IterFunctionKind::IntoIter => String::new(),
-            IterFunctionKind::Len => String::from(".count()"),
-            IterFunctionKind::IsEmpty => String::from(".next().is_none()"),
-            IterFunctionKind::Contains(span) => {
-                let s = snippet(cx, *span, "..");
-                if let Some(stripped) = s.strip_prefix('&') {
-                    format!(".any(|x| x == {})", stripped)
-                } else {
-                    format!(".any(|x| x == *{})", s)
-                }
-            },
-        }
-    }
-    fn get_suggestion_text(&self) -> &'static str {
-        match &self.func {
-            IterFunctionKind::IntoIter => {
-                "use the original Iterator instead of collecting it and then producing a new one"
-            },
-            IterFunctionKind::Len => {
-                "take the original Iterator's count instead of collecting it and finding the length"
-            },
-            IterFunctionKind::IsEmpty => {
-                "check if the original Iterator has anything instead of collecting it and seeing if it's empty"
-            },
-            IterFunctionKind::Contains(_) => {
-                "check if the original Iterator contains an element instead of collecting then checking"
-            },
-        }
-    }
-}
-enum IterFunctionKind {
-    IntoIter,
-    Len,
-    IsEmpty,
-    Contains(Span),
-}
-
-struct IterFunctionVisitor {
-    uses: Vec<IterFunction>,
-    seen_other: bool,
-    target: Ident,
-}
-impl<'tcx> Visitor<'tcx> for IterFunctionVisitor {
-    fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) {
-        // Check function calls on our collection
-        if_chain! {
-            if let ExprKind::MethodCall(method_name, _, ref args, _) = &expr.kind;
-            if let Some(Expr { kind: ExprKind::Path(QPath::Resolved(_, ref path)), .. }) = args.get(0);
-            if let &[name] = &path.segments;
-            if name.ident == self.target;
-            then {
-                let len = sym!(len);
-                let is_empty = sym!(is_empty);
-                let contains = sym!(contains);
-                match method_name.ident.name {
-                    sym::into_iter => self.uses.push(
-                        IterFunction { func: IterFunctionKind::IntoIter, span: expr.span }
-                    ),
-                    name if name == len => self.uses.push(
-                        IterFunction { func: IterFunctionKind::Len, span: expr.span }
-                    ),
-                    name if name == is_empty => self.uses.push(
-                        IterFunction { func: IterFunctionKind::IsEmpty, span: expr.span }
-                    ),
-                    name if name == contains => self.uses.push(
-                        IterFunction { func: IterFunctionKind::Contains(args[1].span), span: expr.span }
-                    ),
-                    _ => self.seen_other = true,
-                }
-                return
-            }
-        }
-        // Check if the collection is used for anything else
-        if_chain! {
-            if let Expr { kind: ExprKind::Path(QPath::Resolved(_, ref path)), .. } = expr;
-            if let &[name] = &path.segments;
-            if name.ident == self.target;
-            then {
-                self.seen_other = true;
-            } else {
-                walk_expr(self, expr);
-            }
-        }
-    }
-
-    type Map = Map<'tcx>;
-    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-        NestedVisitorMap::None
-    }
-}
-
-struct UsedCountVisitor<'a, 'tcx> {
-    cx: &'a LateContext<'tcx>,
-    id: HirId,
-    count: usize,
-}
-
-impl<'a, 'tcx> Visitor<'tcx> for UsedCountVisitor<'a, 'tcx> {
-    type Map = Map<'tcx>;
-
-    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
-        if path_to_local_id(expr, self.id) {
-            self.count += 1;
-        } else {
-            walk_expr(self, expr);
-        }
-    }
-
-    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-        NestedVisitorMap::OnlyBodies(self.cx.tcx.hir())
-    }
-}
-
-/// Detect the occurrences of calls to `iter` or `into_iter` for the
-/// given identifier
-fn detect_iter_and_into_iters<'tcx>(block: &'tcx Block<'tcx>, identifier: Ident) -> Option<Vec<IterFunction>> {
-    let mut visitor = IterFunctionVisitor {
-        uses: Vec::new(),
-        target: identifier,
-        seen_other: false,
-    };
-    visitor.visit_block(block);
-    if visitor.seen_other { None } else { Some(visitor.uses) }
-}
-
-fn shorten_needless_collect_span(expr: &Expr<'_>) -> Span {
-    if_chain! {
-        if let ExprKind::MethodCall(.., args, _) = &expr.kind;
-        if let ExprKind::MethodCall(_, span, ..) = &args[0].kind;
-        then {
-            return expr.span.with_lo(span.lo());
-        }
-    }
-    unreachable!();
-}
diff --git a/clippy_lints/src/loops/manual_flatten.rs b/clippy_lints/src/loops/manual_flatten.rs
new file mode 100644
index 00000000000..b5881a1b8c4
--- /dev/null
+++ b/clippy_lints/src/loops/manual_flatten.rs
@@ -0,0 +1,78 @@
+use super::utils::make_iterator_snippet;
+use crate::utils::{is_ok_ctor, is_some_ctor, path_to_local_id, span_lint_and_then};
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind, MatchSource, Pat, PatKind, QPath, StmtKind};
+use rustc_lint::LateContext;
+use rustc_span::source_map::Span;
+
+/// Check for unnecessary `if let` usage in a for loop where only the `Some` or `Ok` variant of the
+/// iterator element is used.
+pub(super) fn lint<'tcx>(
+    cx: &LateContext<'tcx>,
+    pat: &'tcx Pat<'_>,
+    arg: &'tcx Expr<'_>,
+    body: &'tcx Expr<'_>,
+    span: Span,
+) {
+    if let ExprKind::Block(ref block, _) = body.kind {
+        // Ensure the `if let` statement is the only expression or statement in the for-loop
+        let inner_expr = if block.stmts.len() == 1 && block.expr.is_none() {
+            let match_stmt = &block.stmts[0];
+            if let StmtKind::Semi(inner_expr) = match_stmt.kind {
+                Some(inner_expr)
+            } else {
+                None
+            }
+        } else if block.stmts.is_empty() {
+            block.expr
+        } else {
+            None
+        };
+
+        if_chain! {
+            if let Some(inner_expr) = inner_expr;
+            if let ExprKind::Match(
+                ref match_expr, ref match_arms, MatchSource::IfLetDesugar{ contains_else_clause: false }
+            ) = inner_expr.kind;
+            // Ensure match_expr in `if let` statement is the same as the pat from the for-loop
+            if let PatKind::Binding(_, pat_hir_id, _, _) = pat.kind;
+            if path_to_local_id(match_expr, pat_hir_id);
+            // Ensure the `if let` statement is for the `Some` variant of `Option` or the `Ok` variant of `Result`
+            if let PatKind::TupleStruct(QPath::Resolved(None, path), _, _) = match_arms[0].pat.kind;
+            let some_ctor = is_some_ctor(cx, path.res);
+            let ok_ctor = is_ok_ctor(cx, path.res);
+            if some_ctor || ok_ctor;
+            let if_let_type = if some_ctor { "Some" } else { "Ok" };
+
+            then {
+                // Prepare the error message
+                let msg = format!("unnecessary `if let` since only the `{}` variant of the iterator element is used", if_let_type);
+
+                // Prepare the help message
+                let mut applicability = Applicability::MaybeIncorrect;
+                let arg_snippet = make_iterator_snippet(cx, arg, &mut applicability);
+
+                span_lint_and_then(
+                    cx,
+                    super::MANUAL_FLATTEN,
+                    span,
+                    &msg,
+                    |diag| {
+                        let sugg = format!("{}.flatten()", arg_snippet);
+                        diag.span_suggestion(
+                            arg.span,
+                            "try",
+                            sugg,
+                            Applicability::MaybeIncorrect,
+                        );
+                        diag.span_help(
+                            inner_expr.span,
+                            "...and remove the `if let` statement in the for loop",
+                        );
+                    }
+                );
+            }
+        }
+    }
+}
diff --git a/clippy_lints/src/loops/mod.rs b/clippy_lints/src/loops/mod.rs
new file mode 100644
index 00000000000..18b7e96d42c
--- /dev/null
+++ b/clippy_lints/src/loops/mod.rs
@@ -0,0 +1,3070 @@
+mod manual_flatten;
+mod utils;
+
+use crate::consts::constant;
+use crate::utils::sugg::Sugg;
+use crate::utils::usage::mutated_variables;
+use crate::utils::visitors::LocalUsedVisitor;
+use crate::utils::{
+    contains_name, get_enclosing_block, get_parent_expr, get_trait_def_id, has_iter_method, higher, implements_trait,
+    indent_of, is_in_panic_handler, is_integer_const, is_no_std_crate, is_refutable, is_type_diagnostic_item,
+    last_path_segment, match_trait_method, match_type, multispan_sugg, path_to_local, path_to_local_id, paths,
+    single_segment_path, snippet, snippet_with_applicability, snippet_with_macro_callsite, span_lint,
+    span_lint_and_help, span_lint_and_sugg, span_lint_and_then, sugg, SpanlessEq,
+};
+use if_chain::if_chain;
+use rustc_ast::ast;
+use rustc_data_structures::fx::{FxHashMap, FxHashSet};
+use rustc_errors::Applicability;
+use rustc_hir::def::{DefKind, Res};
+use rustc_hir::intravisit::{walk_block, walk_expr, walk_pat, walk_stmt, NestedVisitorMap, Visitor};
+use rustc_hir::{
+    def_id, BinOpKind, BindingAnnotation, Block, BorrowKind, Expr, ExprKind, GenericArg, HirId, InlineAsmOperand,
+    Local, LoopSource, MatchSource, Mutability, Node, Pat, PatKind, QPath, Stmt, StmtKind,
+};
+use rustc_infer::infer::TyCtxtInferExt;
+use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_middle::hir::map::Map;
+use rustc_middle::lint::in_external_macro;
+use rustc_middle::middle::region;
+use rustc_middle::ty::{self, Ty, TyS};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::source_map::Span;
+use rustc_span::symbol::{sym, Ident, Symbol};
+use rustc_typeck::expr_use_visitor::{ConsumeMode, Delegate, ExprUseVisitor, PlaceBase, PlaceWithHirId};
+use std::iter::{once, Iterator};
+use std::mem;
+use utils::make_iterator_snippet;
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for for-loops that manually copy items between
+    /// slices that could be optimized by having a memcpy.
+    ///
+    /// **Why is this bad?** It is not as fast as a memcpy.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// ```rust
+    /// # let src = vec![1];
+    /// # let mut dst = vec![0; 65];
+    /// for i in 0..src.len() {
+    ///     dst[i + 64] = src[i];
+    /// }
+    /// ```
+    /// Could be written as:
+    /// ```rust
+    /// # let src = vec![1];
+    /// # let mut dst = vec![0; 65];
+    /// dst[64..(src.len() + 64)].clone_from_slice(&src[..]);
+    /// ```
+    pub MANUAL_MEMCPY,
+    perf,
+    "manually copying items between slices"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for looping over the range of `0..len` of some
+    /// collection just to get the values by index.
+    ///
+    /// **Why is this bad?** Just iterating the collection itself makes the intent
+    /// more clear and is probably faster.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// ```rust
+    /// let vec = vec!['a', 'b', 'c'];
+    /// for i in 0..vec.len() {
+    ///     println!("{}", vec[i]);
+    /// }
+    /// ```
+    /// Could be written as:
+    /// ```rust
+    /// let vec = vec!['a', 'b', 'c'];
+    /// for i in vec {
+    ///     println!("{}", i);
+    /// }
+    /// ```
+    pub NEEDLESS_RANGE_LOOP,
+    style,
+    "for-looping over a range of indices where an iterator over items would do"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for loops on `x.iter()` where `&x` will do, and
+    /// suggests the latter.
+    ///
+    /// **Why is this bad?** Readability.
+    ///
+    /// **Known problems:** False negatives. We currently only warn on some known
+    /// types.
+    ///
+    /// **Example:**
+    /// ```rust
+    /// // with `y` a `Vec` or slice:
+    /// # let y = vec![1];
+    /// for x in y.iter() {
+    ///     // ..
+    /// }
+    /// ```
+    /// can be rewritten to
+    /// ```rust
+    /// # let y = vec![1];
+    /// for x in &y {
+    ///     // ..
+    /// }
+    /// ```
+    pub EXPLICIT_ITER_LOOP,
+    pedantic,
+    "for-looping over `_.iter()` or `_.iter_mut()` when `&_` or `&mut _` would do"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for loops on `y.into_iter()` where `y` will do, and
+    /// suggests the latter.
+    ///
+    /// **Why is this bad?** Readability.
+    ///
+    /// **Known problems:** None
+    ///
+    /// **Example:**
+    /// ```rust
+    /// # let y = vec![1];
+    /// // with `y` a `Vec` or slice:
+    /// for x in y.into_iter() {
+    ///     // ..
+    /// }
+    /// ```
+    /// can be rewritten to
+    /// ```rust
+    /// # let y = vec![1];
+    /// for x in y {
+    ///     // ..
+    /// }
+    /// ```
+    pub EXPLICIT_INTO_ITER_LOOP,
+    pedantic,
+    "for-looping over `_.into_iter()` when `_` would do"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for loops on `x.next()`.
+    ///
+    /// **Why is this bad?** `next()` returns either `Some(value)` if there was a
+    /// value, or `None` otherwise. The insidious thing is that `Option<_>`
+    /// implements `IntoIterator`, so that possibly one value will be iterated,
+    /// leading to some hard to find bugs. No one will want to write such code
+    /// [except to win an Underhanded Rust
+    /// Contest](https://www.reddit.com/r/rust/comments/3hb0wm/underhanded_rust_contest/cu5yuhr).
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// ```ignore
+    /// for x in y.next() {
+    ///     ..
+    /// }
+    /// ```
+    pub ITER_NEXT_LOOP,
+    correctness,
+    "for-looping over `_.next()` which is probably not intended"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for `for` loops over `Option` or `Result` values.
+    ///
+    /// **Why is this bad?** Readability. This is more clearly expressed as an `if
+    /// let`.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// ```rust
+    /// # let opt = Some(1);
+    ///
+    /// // Bad
+    /// for x in opt {
+    ///     // ..
+    /// }
+    ///
+    /// // Good
+    /// if let Some(x) = opt {
+    ///     // ..
+    /// }
+    /// ```
+    ///
+    /// // or
+    ///
+    /// ```rust
+    /// # let res: Result<i32, std::io::Error> = Ok(1);
+    ///
+    /// // Bad
+    /// for x in &res {
+    ///     // ..
+    /// }
+    ///
+    /// // Good
+    /// if let Ok(x) = res {
+    ///     // ..
+    /// }
+    /// ```
+    pub FOR_LOOPS_OVER_FALLIBLES,
+    correctness,
+    "for-looping over an `Option` or a `Result`, which is more clearly expressed as an `if let`"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Detects `loop + match` combinations that are easier
+    /// written as a `while let` loop.
+    ///
+    /// **Why is this bad?** The `while let` loop is usually shorter and more
+    /// readable.
+    ///
+    /// **Known problems:** Sometimes the wrong binding is displayed ([#383](https://github.com/rust-lang/rust-clippy/issues/383)).
+    ///
+    /// **Example:**
+    /// ```rust,no_run
+    /// # let y = Some(1);
+    /// loop {
+    ///     let x = match y {
+    ///         Some(x) => x,
+    ///         None => break,
+    ///     };
+    ///     // .. do something with x
+    /// }
+    /// // is easier written as
+    /// while let Some(x) = y {
+    ///     // .. do something with x
+    /// };
+    /// ```
+    pub WHILE_LET_LOOP,
+    complexity,
+    "`loop { if let { ... } else break }`, which can be written as a `while let` loop"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for functions collecting an iterator when collect
+    /// is not needed.
+    ///
+    /// **Why is this bad?** `collect` causes the allocation of a new data structure,
+    /// when this allocation may not be needed.
+    ///
+    /// **Known problems:**
+    /// None
+    ///
+    /// **Example:**
+    /// ```rust
+    /// # let iterator = vec![1].into_iter();
+    /// let len = iterator.clone().collect::<Vec<_>>().len();
+    /// // should be
+    /// let len = iterator.count();
+    /// ```
+    pub NEEDLESS_COLLECT,
+    perf,
+    "collecting an iterator when collect is not needed"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks `for` loops over slices with an explicit counter
+    /// and suggests the use of `.enumerate()`.
+    ///
+    /// **Why is it bad?** Using `.enumerate()` makes the intent more clear,
+    /// declutters the code and may be faster in some instances.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// ```rust
+    /// # let v = vec![1];
+    /// # fn bar(bar: usize, baz: usize) {}
+    /// let mut i = 0;
+    /// for item in &v {
+    ///     bar(i, *item);
+    ///     i += 1;
+    /// }
+    /// ```
+    /// Could be written as
+    /// ```rust
+    /// # let v = vec![1];
+    /// # fn bar(bar: usize, baz: usize) {}
+    /// for (i, item) in v.iter().enumerate() { bar(i, *item); }
+    /// ```
+    pub EXPLICIT_COUNTER_LOOP,
+    complexity,
+    "for-looping with an explicit counter when `_.enumerate()` would do"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for empty `loop` expressions.
+    ///
+    /// **Why is this bad?** These busy loops burn CPU cycles without doing
+    /// anything. It is _almost always_ a better idea to `panic!` than to have
+    /// a busy loop.
+    ///
+    /// If panicking isn't possible, think of the environment and either:
+    ///   - block on something
+    ///   - sleep the thread for some microseconds
+    ///   - yield or pause the thread
+    ///
+    /// For `std` targets, this can be done with
+    /// [`std::thread::sleep`](https://doc.rust-lang.org/std/thread/fn.sleep.html)
+    /// or [`std::thread::yield_now`](https://doc.rust-lang.org/std/thread/fn.yield_now.html).
+    ///
+    /// For `no_std` targets, doing this is more complicated, especially because
+    /// `#[panic_handler]`s can't panic. To stop/pause the thread, you will
+    /// probably need to invoke some target-specific intrinsic. Examples include:
+    ///   - [`x86_64::instructions::hlt`](https://docs.rs/x86_64/0.12.2/x86_64/instructions/fn.hlt.html)
+    ///   - [`cortex_m::asm::wfi`](https://docs.rs/cortex-m/0.6.3/cortex_m/asm/fn.wfi.html)
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// ```no_run
+    /// loop {}
+    /// ```
+    pub EMPTY_LOOP,
+    style,
+    "empty `loop {}`, which should block or sleep"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for `while let` expressions on iterators.
+    ///
+    /// **Why is this bad?** Readability. A simple `for` loop is shorter and conveys
+    /// the intent better.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// ```ignore
+    /// while let Some(val) = iter() {
+    ///     ..
+    /// }
+    /// ```
+    pub WHILE_LET_ON_ITERATOR,
+    style,
+    "using a `while let` loop instead of a for loop on an iterator"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for iterating a map (`HashMap` or `BTreeMap`) and
+    /// ignoring either the keys or values.
+    ///
+    /// **Why is this bad?** Readability. There are `keys` and `values` methods that
+    /// can be used to express that don't need the values or keys.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// ```ignore
+    /// for (k, _) in &map {
+    ///     ..
+    /// }
+    /// ```
+    ///
+    /// could be replaced by
+    ///
+    /// ```ignore
+    /// for k in map.keys() {
+    ///     ..
+    /// }
+    /// ```
+    pub FOR_KV_MAP,
+    style,
+    "looping on a map using `iter` when `keys` or `values` would do"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for loops that will always `break`, `return` or
+    /// `continue` an outer loop.
+    ///
+    /// **Why is this bad?** This loop never loops, all it does is obfuscating the
+    /// code.
+    ///
+    /// **Known problems:** None
+    ///
+    /// **Example:**
+    /// ```rust
+    /// loop {
+    ///     ..;
+    ///     break;
+    /// }
+    /// ```
+    pub NEVER_LOOP,
+    correctness,
+    "any loop that will always `break` or `return`"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for loops which have a range bound that is a mutable variable
+    ///
+    /// **Why is this bad?** One might think that modifying the mutable variable changes the loop bounds
+    ///
+    /// **Known problems:** None
+    ///
+    /// **Example:**
+    /// ```rust
+    /// let mut foo = 42;
+    /// for i in 0..foo {
+    ///     foo -= 1;
+    ///     println!("{}", i); // prints numbers from 0 to 42, not 0 to 21
+    /// }
+    /// ```
+    pub MUT_RANGE_BOUND,
+    complexity,
+    "for loop over a range where one of the bounds is a mutable variable"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks whether variables used within while loop condition
+    /// can be (and are) mutated in the body.
+    ///
+    /// **Why is this bad?** If the condition is unchanged, entering the body of the loop
+    /// will lead to an infinite loop.
+    ///
+    /// **Known problems:** If the `while`-loop is in a closure, the check for mutation of the
+    /// condition variables in the body can cause false negatives. For example when only `Upvar` `a` is
+    /// in the condition and only `Upvar` `b` gets mutated in the body, the lint will not trigger.
+    ///
+    /// **Example:**
+    /// ```rust
+    /// let i = 0;
+    /// while i > 10 {
+    ///     println!("let me loop forever!");
+    /// }
+    /// ```
+    pub WHILE_IMMUTABLE_CONDITION,
+    correctness,
+    "variables used within while expression are not mutated in the body"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks whether a for loop is being used to push a constant
+    /// value into a Vec.
+    ///
+    /// **Why is this bad?** This kind of operation can be expressed more succinctly with
+    /// `vec![item;SIZE]` or `vec.resize(NEW_SIZE, item)` and using these alternatives may also
+    /// have better performance.
+    /// **Known problems:** None
+    ///
+    /// **Example:**
+    /// ```rust
+    /// let item1 = 2;
+    /// let item2 = 3;
+    /// let mut vec: Vec<u8> = Vec::new();
+    /// for _ in 0..20 {
+    ///    vec.push(item1);
+    /// }
+    /// for _ in 0..30 {
+    ///     vec.push(item2);
+    /// }
+    /// ```
+    /// could be written as
+    /// ```rust
+    /// let item1 = 2;
+    /// let item2 = 3;
+    /// let mut vec: Vec<u8> = vec![item1; 20];
+    /// vec.resize(20 + 30, item2);
+    /// ```
+    pub SAME_ITEM_PUSH,
+    style,
+    "the same item is pushed inside of a for loop"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks whether a for loop has a single element.
+    ///
+    /// **Why is this bad?** There is no reason to have a loop of a
+    /// single element.
+    /// **Known problems:** None
+    ///
+    /// **Example:**
+    /// ```rust
+    /// let item1 = 2;
+    /// for item in &[item1] {
+    ///     println!("{}", item);
+    /// }
+    /// ```
+    /// could be written as
+    /// ```rust
+    /// let item1 = 2;
+    /// let item = &item1;
+    /// println!("{}", item);
+    /// ```
+    pub SINGLE_ELEMENT_LOOP,
+    complexity,
+    "there is no reason to have a single element loop"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Check for unnecessary `if let` usage in a for loop
+    /// where only the `Some` or `Ok` variant of the iterator element is used.
+    ///
+    /// **Why is this bad?** It is verbose and can be simplified
+    /// by first calling the `flatten` method on the `Iterator`.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// let x = vec![Some(1), Some(2), Some(3)];
+    /// for n in x {
+    ///     if let Some(n) = n {
+    ///         println!("{}", n);
+    ///     }
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// let x = vec![Some(1), Some(2), Some(3)];
+    /// for n in x.into_iter().flatten() {
+    ///     println!("{}", n);
+    /// }
+    /// ```
+    pub MANUAL_FLATTEN,
+    complexity,
+    "for loops over `Option`s or `Result`s with a single expression can be simplified"
+}
+
+declare_lint_pass!(Loops => [
+    MANUAL_MEMCPY,
+    MANUAL_FLATTEN,
+    NEEDLESS_RANGE_LOOP,
+    EXPLICIT_ITER_LOOP,
+    EXPLICIT_INTO_ITER_LOOP,
+    ITER_NEXT_LOOP,
+    FOR_LOOPS_OVER_FALLIBLES,
+    WHILE_LET_LOOP,
+    NEEDLESS_COLLECT,
+    EXPLICIT_COUNTER_LOOP,
+    EMPTY_LOOP,
+    WHILE_LET_ON_ITERATOR,
+    FOR_KV_MAP,
+    NEVER_LOOP,
+    MUT_RANGE_BOUND,
+    WHILE_IMMUTABLE_CONDITION,
+    SAME_ITEM_PUSH,
+    SINGLE_ELEMENT_LOOP,
+]);
+
+impl<'tcx> LateLintPass<'tcx> for Loops {
+    #[allow(clippy::too_many_lines)]
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        if let Some((pat, arg, body, span)) = higher::for_loop(expr) {
+            // we don't want to check expanded macros
+            // this check is not at the top of the function
+            // since higher::for_loop expressions are marked as expansions
+            if body.span.from_expansion() {
+                return;
+            }
+            check_for_loop(cx, pat, arg, body, expr, span);
+        }
+
+        // we don't want to check expanded macros
+        if expr.span.from_expansion() {
+            return;
+        }
+
+        // check for never_loop
+        if let ExprKind::Loop(ref block, _, _, _) = expr.kind {
+            match never_loop_block(block, expr.hir_id) {
+                NeverLoopResult::AlwaysBreak => span_lint(cx, NEVER_LOOP, expr.span, "this loop never actually loops"),
+                NeverLoopResult::MayContinueMainLoop | NeverLoopResult::Otherwise => (),
+            }
+        }
+
+        // check for `loop { if let {} else break }` that could be `while let`
+        // (also matches an explicit "match" instead of "if let")
+        // (even if the "match" or "if let" is used for declaration)
+        if let ExprKind::Loop(ref block, _, LoopSource::Loop, _) = expr.kind {
+            // also check for empty `loop {}` statements, skipping those in #[panic_handler]
+            if block.stmts.is_empty() && block.expr.is_none() && !is_in_panic_handler(cx, expr) {
+                let msg = "empty `loop {}` wastes CPU cycles";
+                let help = if is_no_std_crate(cx.tcx.hir().krate()) {
+                    "you should either use `panic!()` or add a call pausing or sleeping the thread to the loop body"
+                } else {
+                    "you should either use `panic!()` or add `std::thread::sleep(..);` to the loop body"
+                };
+                span_lint_and_help(cx, EMPTY_LOOP, expr.span, msg, None, help);
+            }
+
+            // extract the expression from the first statement (if any) in a block
+            let inner_stmt_expr = extract_expr_from_first_stmt(block);
+            // or extract the first expression (if any) from the block
+            if let Some(inner) = inner_stmt_expr.or_else(|| extract_first_expr(block)) {
+                if let ExprKind::Match(ref matchexpr, ref arms, ref source) = inner.kind {
+                    // ensure "if let" compatible match structure
+                    match *source {
+                        MatchSource::Normal | MatchSource::IfLetDesugar { .. } => {
+                            if arms.len() == 2
+                                && arms[0].guard.is_none()
+                                && arms[1].guard.is_none()
+                                && is_simple_break_expr(&arms[1].body)
+                            {
+                                if in_external_macro(cx.sess(), expr.span) {
+                                    return;
+                                }
+
+                                // NOTE: we used to build a body here instead of using
+                                // ellipsis, this was removed because:
+                                // 1) it was ugly with big bodies;
+                                // 2) it was not indented properly;
+                                // 3) it wasn’t very smart (see #675).
+                                let mut applicability = Applicability::HasPlaceholders;
+                                span_lint_and_sugg(
+                                    cx,
+                                    WHILE_LET_LOOP,
+                                    expr.span,
+                                    "this loop could be written as a `while let` loop",
+                                    "try",
+                                    format!(
+                                        "while let {} = {} {{ .. }}",
+                                        snippet_with_applicability(cx, arms[0].pat.span, "..", &mut applicability),
+                                        snippet_with_applicability(cx, matchexpr.span, "..", &mut applicability),
+                                    ),
+                                    applicability,
+                                );
+                            }
+                        },
+                        _ => (),
+                    }
+                }
+            }
+        }
+        if let ExprKind::Match(ref match_expr, ref arms, MatchSource::WhileLetDesugar) = expr.kind {
+            let pat = &arms[0].pat.kind;
+            if let (
+                &PatKind::TupleStruct(ref qpath, ref pat_args, _),
+                &ExprKind::MethodCall(ref method_path, _, ref method_args, _),
+            ) = (pat, &match_expr.kind)
+            {
+                let iter_expr = &method_args[0];
+
+                // Don't lint when the iterator is recreated on every iteration
+                if_chain! {
+                    if let ExprKind::MethodCall(..) | ExprKind::Call(..) = iter_expr.kind;
+                    if let Some(iter_def_id) = get_trait_def_id(cx, &paths::ITERATOR);
+                    if implements_trait(cx, cx.typeck_results().expr_ty(iter_expr), iter_def_id, &[]);
+                    then {
+                        return;
+                    }
+                }
+
+                let lhs_constructor = last_path_segment(qpath);
+                if method_path.ident.name == sym::next
+                    && match_trait_method(cx, match_expr, &paths::ITERATOR)
+                    && lhs_constructor.ident.name == sym::Some
+                    && (pat_args.is_empty()
+                        || !is_refutable(cx, &pat_args[0])
+                            && !is_used_inside(cx, iter_expr, &arms[0].body)
+                            && !is_iterator_used_after_while_let(cx, iter_expr)
+                            && !is_nested(cx, expr, &method_args[0]))
+                {
+                    let mut applicability = Applicability::MachineApplicable;
+                    let iterator = snippet_with_applicability(cx, method_args[0].span, "_", &mut applicability);
+                    let loop_var = if pat_args.is_empty() {
+                        "_".to_string()
+                    } else {
+                        snippet_with_applicability(cx, pat_args[0].span, "_", &mut applicability).into_owned()
+                    };
+                    span_lint_and_sugg(
+                        cx,
+                        WHILE_LET_ON_ITERATOR,
+                        expr.span.with_hi(match_expr.span.hi()),
+                        "this loop could be written as a `for` loop",
+                        "try",
+                        format!("for {} in {}", loop_var, iterator),
+                        applicability,
+                    );
+                }
+            }
+        }
+
+        if let Some((cond, body)) = higher::while_loop(&expr) {
+            check_infinite_loop(cx, cond, body);
+        }
+
+        check_needless_collect(expr, cx);
+    }
+}
+
+enum NeverLoopResult {
+    // A break/return always get triggered but not necessarily for the main loop.
+    AlwaysBreak,
+    // A continue may occur for the main loop.
+    MayContinueMainLoop,
+    Otherwise,
+}
+
+#[must_use]
+fn absorb_break(arg: &NeverLoopResult) -> NeverLoopResult {
+    match *arg {
+        NeverLoopResult::AlwaysBreak | NeverLoopResult::Otherwise => NeverLoopResult::Otherwise,
+        NeverLoopResult::MayContinueMainLoop => NeverLoopResult::MayContinueMainLoop,
+    }
+}
+
+// Combine two results for parts that are called in order.
+#[must_use]
+fn combine_seq(first: NeverLoopResult, second: NeverLoopResult) -> NeverLoopResult {
+    match first {
+        NeverLoopResult::AlwaysBreak | NeverLoopResult::MayContinueMainLoop => first,
+        NeverLoopResult::Otherwise => second,
+    }
+}
+
+// Combine two results where both parts are called but not necessarily in order.
+#[must_use]
+fn combine_both(left: NeverLoopResult, right: NeverLoopResult) -> NeverLoopResult {
+    match (left, right) {
+        (NeverLoopResult::MayContinueMainLoop, _) | (_, NeverLoopResult::MayContinueMainLoop) => {
+            NeverLoopResult::MayContinueMainLoop
+        },
+        (NeverLoopResult::AlwaysBreak, _) | (_, NeverLoopResult::AlwaysBreak) => NeverLoopResult::AlwaysBreak,
+        (NeverLoopResult::Otherwise, NeverLoopResult::Otherwise) => NeverLoopResult::Otherwise,
+    }
+}
+
+// Combine two results where only one of the part may have been executed.
+#[must_use]
+fn combine_branches(b1: NeverLoopResult, b2: NeverLoopResult) -> NeverLoopResult {
+    match (b1, b2) {
+        (NeverLoopResult::AlwaysBreak, NeverLoopResult::AlwaysBreak) => NeverLoopResult::AlwaysBreak,
+        (NeverLoopResult::MayContinueMainLoop, _) | (_, NeverLoopResult::MayContinueMainLoop) => {
+            NeverLoopResult::MayContinueMainLoop
+        },
+        (NeverLoopResult::Otherwise, _) | (_, NeverLoopResult::Otherwise) => NeverLoopResult::Otherwise,
+    }
+}
+
+fn never_loop_block(block: &Block<'_>, main_loop_id: HirId) -> NeverLoopResult {
+    let stmts = block.stmts.iter().map(stmt_to_expr);
+    let expr = once(block.expr.as_deref());
+    let mut iter = stmts.chain(expr).flatten();
+    never_loop_expr_seq(&mut iter, main_loop_id)
+}
+
+fn stmt_to_expr<'tcx>(stmt: &Stmt<'tcx>) -> Option<&'tcx Expr<'tcx>> {
+    match stmt.kind {
+        StmtKind::Semi(ref e, ..) | StmtKind::Expr(ref e, ..) => Some(e),
+        StmtKind::Local(ref local) => local.init.as_deref(),
+        _ => None,
+    }
+}
+
+fn never_loop_expr(expr: &Expr<'_>, main_loop_id: HirId) -> NeverLoopResult {
+    match expr.kind {
+        ExprKind::Box(ref e)
+        | ExprKind::Unary(_, ref e)
+        | ExprKind::Cast(ref e, _)
+        | ExprKind::Type(ref e, _)
+        | ExprKind::Field(ref e, _)
+        | ExprKind::AddrOf(_, _, ref e)
+        | ExprKind::Struct(_, _, Some(ref e))
+        | ExprKind::Repeat(ref e, _)
+        | ExprKind::DropTemps(ref e) => never_loop_expr(e, main_loop_id),
+        ExprKind::Array(ref es) | ExprKind::MethodCall(_, _, ref es, _) | ExprKind::Tup(ref es) => {
+            never_loop_expr_all(&mut es.iter(), main_loop_id)
+        },
+        ExprKind::Call(ref e, ref es) => never_loop_expr_all(&mut once(&**e).chain(es.iter()), main_loop_id),
+        ExprKind::Binary(_, ref e1, ref e2)
+        | ExprKind::Assign(ref e1, ref e2, _)
+        | ExprKind::AssignOp(_, ref e1, ref e2)
+        | ExprKind::Index(ref e1, ref e2) => never_loop_expr_all(&mut [&**e1, &**e2].iter().cloned(), main_loop_id),
+        ExprKind::Loop(ref b, _, _, _) => {
+            // Break can come from the inner loop so remove them.
+            absorb_break(&never_loop_block(b, main_loop_id))
+        },
+        ExprKind::If(ref e, ref e2, ref e3) => {
+            let e1 = never_loop_expr(e, main_loop_id);
+            let e2 = never_loop_expr(e2, main_loop_id);
+            let e3 = e3
+                .as_ref()
+                .map_or(NeverLoopResult::Otherwise, |e| never_loop_expr(e, main_loop_id));
+            combine_seq(e1, combine_branches(e2, e3))
+        },
+        ExprKind::Match(ref e, ref arms, _) => {
+            let e = never_loop_expr(e, main_loop_id);
+            if arms.is_empty() {
+                e
+            } else {
+                let arms = never_loop_expr_branch(&mut arms.iter().map(|a| &*a.body), main_loop_id);
+                combine_seq(e, arms)
+            }
+        },
+        ExprKind::Block(ref b, _) => never_loop_block(b, main_loop_id),
+        ExprKind::Continue(d) => {
+            let id = d
+                .target_id
+                .expect("target ID can only be missing in the presence of compilation errors");
+            if id == main_loop_id {
+                NeverLoopResult::MayContinueMainLoop
+            } else {
+                NeverLoopResult::AlwaysBreak
+            }
+        },
+        ExprKind::Break(_, ref e) | ExprKind::Ret(ref e) => e.as_ref().map_or(NeverLoopResult::AlwaysBreak, |e| {
+            combine_seq(never_loop_expr(e, main_loop_id), NeverLoopResult::AlwaysBreak)
+        }),
+        ExprKind::InlineAsm(ref asm) => asm
+            .operands
+            .iter()
+            .map(|(o, _)| match o {
+                InlineAsmOperand::In { expr, .. }
+                | InlineAsmOperand::InOut { expr, .. }
+                | InlineAsmOperand::Const { expr }
+                | InlineAsmOperand::Sym { expr } => never_loop_expr(expr, main_loop_id),
+                InlineAsmOperand::Out { expr, .. } => never_loop_expr_all(&mut expr.iter(), main_loop_id),
+                InlineAsmOperand::SplitInOut { in_expr, out_expr, .. } => {
+                    never_loop_expr_all(&mut once(in_expr).chain(out_expr.iter()), main_loop_id)
+                },
+            })
+            .fold(NeverLoopResult::Otherwise, combine_both),
+        ExprKind::Struct(_, _, None)
+        | ExprKind::Yield(_, _)
+        | ExprKind::Closure(_, _, _, _, _)
+        | ExprKind::LlvmInlineAsm(_)
+        | ExprKind::Path(_)
+        | ExprKind::ConstBlock(_)
+        | ExprKind::Lit(_)
+        | ExprKind::Err => NeverLoopResult::Otherwise,
+    }
+}
+
+fn never_loop_expr_seq<'a, T: Iterator<Item = &'a Expr<'a>>>(es: &mut T, main_loop_id: HirId) -> NeverLoopResult {
+    es.map(|e| never_loop_expr(e, main_loop_id))
+        .fold(NeverLoopResult::Otherwise, combine_seq)
+}
+
+fn never_loop_expr_all<'a, T: Iterator<Item = &'a Expr<'a>>>(es: &mut T, main_loop_id: HirId) -> NeverLoopResult {
+    es.map(|e| never_loop_expr(e, main_loop_id))
+        .fold(NeverLoopResult::Otherwise, combine_both)
+}
+
+fn never_loop_expr_branch<'a, T: Iterator<Item = &'a Expr<'a>>>(e: &mut T, main_loop_id: HirId) -> NeverLoopResult {
+    e.map(|e| never_loop_expr(e, main_loop_id))
+        .fold(NeverLoopResult::AlwaysBreak, combine_branches)
+}
+
+fn check_for_loop<'tcx>(
+    cx: &LateContext<'tcx>,
+    pat: &'tcx Pat<'_>,
+    arg: &'tcx Expr<'_>,
+    body: &'tcx Expr<'_>,
+    expr: &'tcx Expr<'_>,
+    span: Span,
+) {
+    let is_manual_memcpy_triggered = detect_manual_memcpy(cx, pat, arg, body, expr);
+    if !is_manual_memcpy_triggered {
+        check_for_loop_range(cx, pat, arg, body, expr);
+        check_for_loop_explicit_counter(cx, pat, arg, body, expr);
+    }
+    check_for_loop_arg(cx, pat, arg, expr);
+    check_for_loop_over_map_kv(cx, pat, arg, body, expr);
+    check_for_mut_range_bound(cx, arg, body);
+    check_for_single_element_loop(cx, pat, arg, body, expr);
+    detect_same_item_push(cx, pat, arg, body, expr);
+    manual_flatten::lint(cx, pat, arg, body, span);
+}
+
+// this function assumes the given expression is a `for` loop.
+fn get_span_of_entire_for_loop(expr: &Expr<'_>) -> Span {
+    // for some reason this is the only way to get the `Span`
+    // of the entire `for` loop
+    if let ExprKind::Match(_, arms, _) = &expr.kind {
+        arms[0].body.span
+    } else {
+        unreachable!()
+    }
+}
+
+/// a wrapper of `Sugg`. Besides what `Sugg` do, this removes unnecessary `0`;
+/// and also, it avoids subtracting a variable from the same one by replacing it with `0`.
+/// it exists for the convenience of the overloaded operators while normal functions can do the
+/// same.
+#[derive(Clone)]
+struct MinifyingSugg<'a>(Sugg<'a>);
+
+impl<'a> MinifyingSugg<'a> {
+    fn as_str(&self) -> &str {
+        let Sugg::NonParen(s) | Sugg::MaybeParen(s) | Sugg::BinOp(_, s) = &self.0;
+        s.as_ref()
+    }
+
+    fn into_sugg(self) -> Sugg<'a> {
+        self.0
+    }
+}
+
+impl<'a> From<Sugg<'a>> for MinifyingSugg<'a> {
+    fn from(sugg: Sugg<'a>) -> Self {
+        Self(sugg)
+    }
+}
+
+impl std::ops::Add for &MinifyingSugg<'static> {
+    type Output = MinifyingSugg<'static>;
+    fn add(self, rhs: &MinifyingSugg<'static>) -> MinifyingSugg<'static> {
+        match (self.as_str(), rhs.as_str()) {
+            ("0", _) => rhs.clone(),
+            (_, "0") => self.clone(),
+            (_, _) => (&self.0 + &rhs.0).into(),
+        }
+    }
+}
+
+impl std::ops::Sub for &MinifyingSugg<'static> {
+    type Output = MinifyingSugg<'static>;
+    fn sub(self, rhs: &MinifyingSugg<'static>) -> MinifyingSugg<'static> {
+        match (self.as_str(), rhs.as_str()) {
+            (_, "0") => self.clone(),
+            ("0", _) => (-rhs.0.clone()).into(),
+            (x, y) if x == y => sugg::ZERO.into(),
+            (_, _) => (&self.0 - &rhs.0).into(),
+        }
+    }
+}
+
+impl std::ops::Add<&MinifyingSugg<'static>> for MinifyingSugg<'static> {
+    type Output = MinifyingSugg<'static>;
+    fn add(self, rhs: &MinifyingSugg<'static>) -> MinifyingSugg<'static> {
+        match (self.as_str(), rhs.as_str()) {
+            ("0", _) => rhs.clone(),
+            (_, "0") => self,
+            (_, _) => (self.0 + &rhs.0).into(),
+        }
+    }
+}
+
+impl std::ops::Sub<&MinifyingSugg<'static>> for MinifyingSugg<'static> {
+    type Output = MinifyingSugg<'static>;
+    fn sub(self, rhs: &MinifyingSugg<'static>) -> MinifyingSugg<'static> {
+        match (self.as_str(), rhs.as_str()) {
+            (_, "0") => self,
+            ("0", _) => (-rhs.0.clone()).into(),
+            (x, y) if x == y => sugg::ZERO.into(),
+            (_, _) => (self.0 - &rhs.0).into(),
+        }
+    }
+}
+
+/// a wrapper around `MinifyingSugg`, which carries a operator like currying
+/// so that the suggested code become more efficient (e.g. `foo + -bar` `foo - bar`).
+struct Offset {
+    value: MinifyingSugg<'static>,
+    sign: OffsetSign,
+}
+
+#[derive(Clone, Copy)]
+enum OffsetSign {
+    Positive,
+    Negative,
+}
+
+impl Offset {
+    fn negative(value: Sugg<'static>) -> Self {
+        Self {
+            value: value.into(),
+            sign: OffsetSign::Negative,
+        }
+    }
+
+    fn positive(value: Sugg<'static>) -> Self {
+        Self {
+            value: value.into(),
+            sign: OffsetSign::Positive,
+        }
+    }
+
+    fn empty() -> Self {
+        Self::positive(sugg::ZERO)
+    }
+}
+
+fn apply_offset(lhs: &MinifyingSugg<'static>, rhs: &Offset) -> MinifyingSugg<'static> {
+    match rhs.sign {
+        OffsetSign::Positive => lhs + &rhs.value,
+        OffsetSign::Negative => lhs - &rhs.value,
+    }
+}
+
+#[derive(Debug, Clone, Copy)]
+enum StartKind<'hir> {
+    Range,
+    Counter { initializer: &'hir Expr<'hir> },
+}
+
+struct IndexExpr<'hir> {
+    base: &'hir Expr<'hir>,
+    idx: StartKind<'hir>,
+    idx_offset: Offset,
+}
+
+struct Start<'hir> {
+    id: HirId,
+    kind: StartKind<'hir>,
+}
+
+fn is_slice_like<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'_>) -> bool {
+    let is_slice = match ty.kind() {
+        ty::Ref(_, subty, _) => is_slice_like(cx, subty),
+        ty::Slice(..) | ty::Array(..) => true,
+        _ => false,
+    };
+
+    is_slice || is_type_diagnostic_item(cx, ty, sym::vec_type) || is_type_diagnostic_item(cx, ty, sym!(vecdeque_type))
+}
+
+fn fetch_cloned_expr<'tcx>(expr: &'tcx Expr<'tcx>) -> &'tcx Expr<'tcx> {
+    if_chain! {
+        if let ExprKind::MethodCall(method, _, args, _) = expr.kind;
+        if method.ident.name == sym::clone;
+        if args.len() == 1;
+        if let Some(arg) = args.get(0);
+        then { arg } else { expr }
+    }
+}
+
+fn get_details_from_idx<'tcx>(
+    cx: &LateContext<'tcx>,
+    idx: &Expr<'_>,
+    starts: &[Start<'tcx>],
+) -> Option<(StartKind<'tcx>, Offset)> {
+    fn get_start<'tcx>(e: &Expr<'_>, starts: &[Start<'tcx>]) -> Option<StartKind<'tcx>> {
+        let id = path_to_local(e)?;
+        starts.iter().find(|start| start.id == id).map(|start| start.kind)
+    }
+
+    fn get_offset<'tcx>(cx: &LateContext<'tcx>, e: &Expr<'_>, starts: &[Start<'tcx>]) -> Option<Sugg<'static>> {
+        match &e.kind {
+            ExprKind::Lit(l) => match l.node {
+                ast::LitKind::Int(x, _ty) => Some(Sugg::NonParen(x.to_string().into())),
+                _ => None,
+            },
+            ExprKind::Path(..) if get_start(e, starts).is_none() => Some(Sugg::hir(cx, e, "???")),
+            _ => None,
+        }
+    }
+
+    match idx.kind {
+        ExprKind::Binary(op, lhs, rhs) => match op.node {
+            BinOpKind::Add => {
+                let offset_opt = get_start(lhs, starts)
+                    .and_then(|s| get_offset(cx, rhs, starts).map(|o| (s, o)))
+                    .or_else(|| get_start(rhs, starts).and_then(|s| get_offset(cx, lhs, starts).map(|o| (s, o))));
+
+                offset_opt.map(|(s, o)| (s, Offset::positive(o)))
+            },
+            BinOpKind::Sub => {
+                get_start(lhs, starts).and_then(|s| get_offset(cx, rhs, starts).map(|o| (s, Offset::negative(o))))
+            },
+            _ => None,
+        },
+        ExprKind::Path(..) => get_start(idx, starts).map(|s| (s, Offset::empty())),
+        _ => None,
+    }
+}
+
+fn get_assignment<'tcx>(e: &'tcx Expr<'tcx>) -> Option<(&'tcx Expr<'tcx>, &'tcx Expr<'tcx>)> {
+    if let ExprKind::Assign(lhs, rhs, _) = e.kind {
+        Some((lhs, rhs))
+    } else {
+        None
+    }
+}
+
+/// Get assignments from the given block.
+/// The returned iterator yields `None` if no assignment expressions are there,
+/// filtering out the increments of the given whitelisted loop counters;
+/// because its job is to make sure there's nothing other than assignments and the increments.
+fn get_assignments<'a, 'tcx>(
+    Block { stmts, expr, .. }: &'tcx Block<'tcx>,
+    loop_counters: &'a [Start<'tcx>],
+) -> impl Iterator<Item = Option<(&'tcx Expr<'tcx>, &'tcx Expr<'tcx>)>> + 'a {
+    // As the `filter` and `map` below do different things, I think putting together
+    // just increases complexity. (cc #3188 and #4193)
+    stmts
+        .iter()
+        .filter_map(move |stmt| match stmt.kind {
+            StmtKind::Local(..) | StmtKind::Item(..) => None,
+            StmtKind::Expr(e) | StmtKind::Semi(e) => Some(e),
+        })
+        .chain((*expr).into_iter())
+        .filter(move |e| {
+            if let ExprKind::AssignOp(_, place, _) = e.kind {
+                path_to_local(place).map_or(false, |id| {
+                    !loop_counters
+                        .iter()
+                        // skip the first item which should be `StartKind::Range`
+                        // this makes it possible to use the slice with `StartKind::Range` in the same iterator loop.
+                        .skip(1)
+                        .any(|counter| counter.id == id)
+                })
+            } else {
+                true
+            }
+        })
+        .map(get_assignment)
+}
+
+fn get_loop_counters<'a, 'tcx>(
+    cx: &'a LateContext<'tcx>,
+    body: &'tcx Block<'tcx>,
+    expr: &'tcx Expr<'_>,
+) -> Option<impl Iterator<Item = Start<'tcx>> + 'a> {
+    // Look for variables that are incremented once per loop iteration.
+    let mut increment_visitor = IncrementVisitor::new(cx);
+    walk_block(&mut increment_visitor, body);
+
+    // For each candidate, check the parent block to see if
+    // it's initialized to zero at the start of the loop.
+    get_enclosing_block(&cx, expr.hir_id).and_then(|block| {
+        increment_visitor
+            .into_results()
+            .filter_map(move |var_id| {
+                let mut initialize_visitor = InitializeVisitor::new(cx, expr, var_id);
+                walk_block(&mut initialize_visitor, block);
+
+                initialize_visitor.get_result().map(|(_, initializer)| Start {
+                    id: var_id,
+                    kind: StartKind::Counter { initializer },
+                })
+            })
+            .into()
+    })
+}
+
+fn build_manual_memcpy_suggestion<'tcx>(
+    cx: &LateContext<'tcx>,
+    start: &Expr<'_>,
+    end: &Expr<'_>,
+    limits: ast::RangeLimits,
+    dst: &IndexExpr<'_>,
+    src: &IndexExpr<'_>,
+) -> String {
+    fn print_offset(offset: MinifyingSugg<'static>) -> MinifyingSugg<'static> {
+        if offset.as_str() == "0" {
+            sugg::EMPTY.into()
+        } else {
+            offset
+        }
+    }
+
+    let print_limit = |end: &Expr<'_>, end_str: &str, base: &Expr<'_>, sugg: MinifyingSugg<'static>| {
+        if_chain! {
+            if let ExprKind::MethodCall(method, _, len_args, _) = end.kind;
+            if method.ident.name == sym!(len);
+            if len_args.len() == 1;
+            if let Some(arg) = len_args.get(0);
+            if path_to_local(arg) == path_to_local(base);
+            then {
+                if sugg.as_str() == end_str {
+                    sugg::EMPTY.into()
+                } else {
+                    sugg
+                }
+            } else {
+                match limits {
+                    ast::RangeLimits::Closed => {
+                        sugg + &sugg::ONE.into()
+                    },
+                    ast::RangeLimits::HalfOpen => sugg,
+                }
+            }
+        }
+    };
+
+    let start_str = Sugg::hir(cx, start, "").into();
+    let end_str: MinifyingSugg<'_> = Sugg::hir(cx, end, "").into();
+
+    let print_offset_and_limit = |idx_expr: &IndexExpr<'_>| match idx_expr.idx {
+        StartKind::Range => (
+            print_offset(apply_offset(&start_str, &idx_expr.idx_offset)).into_sugg(),
+            print_limit(
+                end,
+                end_str.as_str(),
+                idx_expr.base,
+                apply_offset(&end_str, &idx_expr.idx_offset),
+            )
+            .into_sugg(),
+        ),
+        StartKind::Counter { initializer } => {
+            let counter_start = Sugg::hir(cx, initializer, "").into();
+            (
+                print_offset(apply_offset(&counter_start, &idx_expr.idx_offset)).into_sugg(),
+                print_limit(
+                    end,
+                    end_str.as_str(),
+                    idx_expr.base,
+                    apply_offset(&end_str, &idx_expr.idx_offset) + &counter_start - &start_str,
+                )
+                .into_sugg(),
+            )
+        },
+    };
+
+    let (dst_offset, dst_limit) = print_offset_and_limit(&dst);
+    let (src_offset, src_limit) = print_offset_and_limit(&src);
+
+    let dst_base_str = snippet(cx, dst.base.span, "???");
+    let src_base_str = snippet(cx, src.base.span, "???");
+
+    let dst = if dst_offset == sugg::EMPTY && dst_limit == sugg::EMPTY {
+        dst_base_str
+    } else {
+        format!(
+            "{}[{}..{}]",
+            dst_base_str,
+            dst_offset.maybe_par(),
+            dst_limit.maybe_par()
+        )
+        .into()
+    };
+
+    format!(
+        "{}.clone_from_slice(&{}[{}..{}]);",
+        dst,
+        src_base_str,
+        src_offset.maybe_par(),
+        src_limit.maybe_par()
+    )
+}
+
+/// Checks for for loops that sequentially copy items from one slice-like
+/// object to another.
+fn detect_manual_memcpy<'tcx>(
+    cx: &LateContext<'tcx>,
+    pat: &'tcx Pat<'_>,
+    arg: &'tcx Expr<'_>,
+    body: &'tcx Expr<'_>,
+    expr: &'tcx Expr<'_>,
+) -> bool {
+    if let Some(higher::Range {
+        start: Some(start),
+        end: Some(end),
+        limits,
+    }) = higher::range(arg)
+    {
+        // the var must be a single name
+        if let PatKind::Binding(_, canonical_id, _, _) = pat.kind {
+            let mut starts = vec![Start {
+                id: canonical_id,
+                kind: StartKind::Range,
+            }];
+
+            // This is one of few ways to return different iterators
+            // derived from: https://stackoverflow.com/questions/29760668/conditionally-iterate-over-one-of-several-possible-iterators/52064434#52064434
+            let mut iter_a = None;
+            let mut iter_b = None;
+
+            if let ExprKind::Block(block, _) = body.kind {
+                if let Some(loop_counters) = get_loop_counters(cx, block, expr) {
+                    starts.extend(loop_counters);
+                }
+                iter_a = Some(get_assignments(block, &starts));
+            } else {
+                iter_b = Some(get_assignment(body));
+            }
+
+            let assignments = iter_a.into_iter().flatten().chain(iter_b.into_iter());
+
+            let big_sugg = assignments
+                // The only statements in the for loops can be indexed assignments from
+                // indexed retrievals (except increments of loop counters).
+                .map(|o| {
+                    o.and_then(|(lhs, rhs)| {
+                        let rhs = fetch_cloned_expr(rhs);
+                        if_chain! {
+                            if let ExprKind::Index(base_left, idx_left) = lhs.kind;
+                            if let ExprKind::Index(base_right, idx_right) = rhs.kind;
+                            if is_slice_like(cx, cx.typeck_results().expr_ty(base_left))
+                                && is_slice_like(cx, cx.typeck_results().expr_ty(base_right));
+                            if let Some((start_left, offset_left)) = get_details_from_idx(cx, &idx_left, &starts);
+                            if let Some((start_right, offset_right)) = get_details_from_idx(cx, &idx_right, &starts);
+
+                            // Source and destination must be different
+                            if path_to_local(base_left) != path_to_local(base_right);
+                            then {
+                                Some((IndexExpr { base: base_left, idx: start_left, idx_offset: offset_left },
+                                    IndexExpr { base: base_right, idx: start_right, idx_offset: offset_right }))
+                            } else {
+                                None
+                            }
+                        }
+                    })
+                })
+                .map(|o| o.map(|(dst, src)| build_manual_memcpy_suggestion(cx, start, end, limits, &dst, &src)))
+                .collect::<Option<Vec<_>>>()
+                .filter(|v| !v.is_empty())
+                .map(|v| v.join("\n    "));
+
+            if let Some(big_sugg) = big_sugg {
+                span_lint_and_sugg(
+                    cx,
+                    MANUAL_MEMCPY,
+                    get_span_of_entire_for_loop(expr),
+                    "it looks like you're manually copying between slices",
+                    "try replacing the loop by",
+                    big_sugg,
+                    Applicability::Unspecified,
+                );
+                return true;
+            }
+        }
+    }
+    false
+}
+
+// Scans the body of the for loop and determines whether lint should be given
+struct SameItemPushVisitor<'a, 'tcx> {
+    should_lint: bool,
+    // this field holds the last vec push operation visited, which should be the only push seen
+    vec_push: Option<(&'tcx Expr<'tcx>, &'tcx Expr<'tcx>)>,
+    cx: &'a LateContext<'tcx>,
+}
+
+impl<'a, 'tcx> Visitor<'tcx> for SameItemPushVisitor<'a, 'tcx> {
+    type Map = Map<'tcx>;
+
+    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
+        match &expr.kind {
+            // Non-determinism may occur ... don't give a lint
+            ExprKind::Loop(..) | ExprKind::Match(..) => self.should_lint = false,
+            ExprKind::Block(block, _) => self.visit_block(block),
+            _ => {},
+        }
+    }
+
+    fn visit_block(&mut self, b: &'tcx Block<'_>) {
+        for stmt in b.stmts.iter() {
+            self.visit_stmt(stmt);
+        }
+    }
+
+    fn visit_stmt(&mut self, s: &'tcx Stmt<'_>) {
+        let vec_push_option = get_vec_push(self.cx, s);
+        if vec_push_option.is_none() {
+            // Current statement is not a push so visit inside
+            match &s.kind {
+                StmtKind::Expr(expr) | StmtKind::Semi(expr) => self.visit_expr(&expr),
+                _ => {},
+            }
+        } else {
+            // Current statement is a push ...check whether another
+            // push had been previously done
+            if self.vec_push.is_none() {
+                self.vec_push = vec_push_option;
+            } else {
+                // There are multiple pushes ... don't lint
+                self.should_lint = false;
+            }
+        }
+    }
+
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::None
+    }
+}
+
+// Given some statement, determine if that statement is a push on a Vec. If it is, return
+// the Vec being pushed into and the item being pushed
+fn get_vec_push<'tcx>(cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) -> Option<(&'tcx Expr<'tcx>, &'tcx Expr<'tcx>)> {
+    if_chain! {
+            // Extract method being called
+            if let StmtKind::Semi(semi_stmt) = &stmt.kind;
+            if let ExprKind::MethodCall(path, _, args, _) = &semi_stmt.kind;
+            // Figure out the parameters for the method call
+            if let Some(self_expr) = args.get(0);
+            if let Some(pushed_item) = args.get(1);
+            // Check that the method being called is push() on a Vec
+            if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(self_expr), sym::vec_type);
+            if path.ident.name.as_str() == "push";
+            then {
+                return Some((self_expr, pushed_item))
+            }
+    }
+    None
+}
+
+/// Detects for loop pushing the same item into a Vec
+fn detect_same_item_push<'tcx>(
+    cx: &LateContext<'tcx>,
+    pat: &'tcx Pat<'_>,
+    _: &'tcx Expr<'_>,
+    body: &'tcx Expr<'_>,
+    _: &'tcx Expr<'_>,
+) {
+    fn emit_lint(cx: &LateContext<'_>, vec: &Expr<'_>, pushed_item: &Expr<'_>) {
+        let vec_str = snippet_with_macro_callsite(cx, vec.span, "");
+        let item_str = snippet_with_macro_callsite(cx, pushed_item.span, "");
+
+        span_lint_and_help(
+            cx,
+            SAME_ITEM_PUSH,
+            vec.span,
+            "it looks like the same item is being pushed into this Vec",
+            None,
+            &format!(
+                "try using vec![{};SIZE] or {}.resize(NEW_SIZE, {})",
+                item_str, vec_str, item_str
+            ),
+        )
+    }
+
+    if !matches!(pat.kind, PatKind::Wild) {
+        return;
+    }
+
+    // Determine whether it is safe to lint the body
+    let mut same_item_push_visitor = SameItemPushVisitor {
+        should_lint: true,
+        vec_push: None,
+        cx,
+    };
+    walk_expr(&mut same_item_push_visitor, body);
+    if same_item_push_visitor.should_lint {
+        if let Some((vec, pushed_item)) = same_item_push_visitor.vec_push {
+            let vec_ty = cx.typeck_results().expr_ty(vec);
+            let ty = vec_ty.walk().nth(1).unwrap().expect_ty();
+            if cx
+                .tcx
+                .lang_items()
+                .clone_trait()
+                .map_or(false, |id| implements_trait(cx, ty, id, &[]))
+            {
+                // Make sure that the push does not involve possibly mutating values
+                match pushed_item.kind {
+                    ExprKind::Path(ref qpath) => {
+                        match cx.qpath_res(qpath, pushed_item.hir_id) {
+                            // immutable bindings that are initialized with literal or constant
+                            Res::Local(hir_id) => {
+                                if_chain! {
+                                    let node = cx.tcx.hir().get(hir_id);
+                                    if let Node::Binding(pat) = node;
+                                    if let PatKind::Binding(bind_ann, ..) = pat.kind;
+                                    if !matches!(bind_ann, BindingAnnotation::RefMut | BindingAnnotation::Mutable);
+                                    let parent_node = cx.tcx.hir().get_parent_node(hir_id);
+                                    if let Some(Node::Local(parent_let_expr)) = cx.tcx.hir().find(parent_node);
+                                    if let Some(init) = parent_let_expr.init;
+                                    then {
+                                        match init.kind {
+                                            // immutable bindings that are initialized with literal
+                                            ExprKind::Lit(..) => emit_lint(cx, vec, pushed_item),
+                                            // immutable bindings that are initialized with constant
+                                            ExprKind::Path(ref path) => {
+                                                if let Res::Def(DefKind::Const, ..) = cx.qpath_res(path, init.hir_id) {
+                                                    emit_lint(cx, vec, pushed_item);
+                                                }
+                                            }
+                                            _ => {},
+                                        }
+                                    }
+                                }
+                            },
+                            // constant
+                            Res::Def(DefKind::Const, ..) => emit_lint(cx, vec, pushed_item),
+                            _ => {},
+                        }
+                    },
+                    ExprKind::Lit(..) => emit_lint(cx, vec, pushed_item),
+                    _ => {},
+                }
+            }
+        }
+    }
+}
+
+/// Checks for looping over a range and then indexing a sequence with it.
+/// The iteratee must be a range literal.
+#[allow(clippy::too_many_lines)]
+fn check_for_loop_range<'tcx>(
+    cx: &LateContext<'tcx>,
+    pat: &'tcx Pat<'_>,
+    arg: &'tcx Expr<'_>,
+    body: &'tcx Expr<'_>,
+    expr: &'tcx Expr<'_>,
+) {
+    if let Some(higher::Range {
+        start: Some(start),
+        ref end,
+        limits,
+    }) = higher::range(arg)
+    {
+        // the var must be a single name
+        if let PatKind::Binding(_, canonical_id, ident, _) = pat.kind {
+            let mut visitor = VarVisitor {
+                cx,
+                var: canonical_id,
+                indexed_mut: FxHashSet::default(),
+                indexed_indirectly: FxHashMap::default(),
+                indexed_directly: FxHashMap::default(),
+                referenced: FxHashSet::default(),
+                nonindex: false,
+                prefer_mutable: false,
+            };
+            walk_expr(&mut visitor, body);
+
+            // linting condition: we only indexed one variable, and indexed it directly
+            if visitor.indexed_indirectly.is_empty() && visitor.indexed_directly.len() == 1 {
+                let (indexed, (indexed_extent, indexed_ty)) = visitor
+                    .indexed_directly
+                    .into_iter()
+                    .next()
+                    .expect("already checked that we have exactly 1 element");
+
+                // ensure that the indexed variable was declared before the loop, see #601
+                if let Some(indexed_extent) = indexed_extent {
+                    let parent_id = cx.tcx.hir().get_parent_item(expr.hir_id);
+                    let parent_def_id = cx.tcx.hir().local_def_id(parent_id);
+                    let region_scope_tree = cx.tcx.region_scope_tree(parent_def_id);
+                    let pat_extent = region_scope_tree.var_scope(pat.hir_id.local_id);
+                    if region_scope_tree.is_subscope_of(indexed_extent, pat_extent) {
+                        return;
+                    }
+                }
+
+                // don't lint if the container that is indexed does not have .iter() method
+                let has_iter = has_iter_method(cx, indexed_ty);
+                if has_iter.is_none() {
+                    return;
+                }
+
+                // don't lint if the container that is indexed into is also used without
+                // indexing
+                if visitor.referenced.contains(&indexed) {
+                    return;
+                }
+
+                let starts_at_zero = is_integer_const(cx, start, 0);
+
+                let skip = if starts_at_zero {
+                    String::new()
+                } else if visitor.indexed_mut.contains(&indexed) && contains_name(indexed, start) {
+                    return;
+                } else {
+                    format!(".skip({})", snippet(cx, start.span, ".."))
+                };
+
+                let mut end_is_start_plus_val = false;
+
+                let take = if let Some(end) = *end {
+                    let mut take_expr = end;
+
+                    if let ExprKind::Binary(ref op, ref left, ref right) = end.kind {
+                        if let BinOpKind::Add = op.node {
+                            let start_equal_left = SpanlessEq::new(cx).eq_expr(start, left);
+                            let start_equal_right = SpanlessEq::new(cx).eq_expr(start, right);
+
+                            if start_equal_left {
+                                take_expr = right;
+                            } else if start_equal_right {
+                                take_expr = left;
+                            }
+
+                            end_is_start_plus_val = start_equal_left | start_equal_right;
+                        }
+                    }
+
+                    if is_len_call(end, indexed) || is_end_eq_array_len(cx, end, limits, indexed_ty) {
+                        String::new()
+                    } else if visitor.indexed_mut.contains(&indexed) && contains_name(indexed, take_expr) {
+                        return;
+                    } else {
+                        match limits {
+                            ast::RangeLimits::Closed => {
+                                let take_expr = sugg::Sugg::hir(cx, take_expr, "<count>");
+                                format!(".take({})", take_expr + sugg::ONE)
+                            },
+                            ast::RangeLimits::HalfOpen => format!(".take({})", snippet(cx, take_expr.span, "..")),
+                        }
+                    }
+                } else {
+                    String::new()
+                };
+
+                let (ref_mut, method) = if visitor.indexed_mut.contains(&indexed) {
+                    ("mut ", "iter_mut")
+                } else {
+                    ("", "iter")
+                };
+
+                let take_is_empty = take.is_empty();
+                let mut method_1 = take;
+                let mut method_2 = skip;
+
+                if end_is_start_plus_val {
+                    mem::swap(&mut method_1, &mut method_2);
+                }
+
+                if visitor.nonindex {
+                    span_lint_and_then(
+                        cx,
+                        NEEDLESS_RANGE_LOOP,
+                        expr.span,
+                        &format!("the loop variable `{}` is used to index `{}`", ident.name, indexed),
+                        |diag| {
+                            multispan_sugg(
+                                diag,
+                                "consider using an iterator",
+                                vec![
+                                    (pat.span, format!("({}, <item>)", ident.name)),
+                                    (
+                                        arg.span,
+                                        format!("{}.{}().enumerate(){}{}", indexed, method, method_1, method_2),
+                                    ),
+                                ],
+                            );
+                        },
+                    );
+                } else {
+                    let repl = if starts_at_zero && take_is_empty {
+                        format!("&{}{}", ref_mut, indexed)
+                    } else {
+                        format!("{}.{}(){}{}", indexed, method, method_1, method_2)
+                    };
+
+                    span_lint_and_then(
+                        cx,
+                        NEEDLESS_RANGE_LOOP,
+                        expr.span,
+                        &format!("the loop variable `{}` is only used to index `{}`", ident.name, indexed),
+                        |diag| {
+                            multispan_sugg(
+                                diag,
+                                "consider using an iterator",
+                                vec![(pat.span, "<item>".to_string()), (arg.span, repl)],
+                            );
+                        },
+                    );
+                }
+            }
+        }
+    }
+}
+
+fn is_len_call(expr: &Expr<'_>, var: Symbol) -> bool {
+    if_chain! {
+        if let ExprKind::MethodCall(ref method, _, ref len_args, _) = expr.kind;
+        if len_args.len() == 1;
+        if method.ident.name == sym!(len);
+        if let ExprKind::Path(QPath::Resolved(_, ref path)) = len_args[0].kind;
+        if path.segments.len() == 1;
+        if path.segments[0].ident.name == var;
+        then {
+            return true;
+        }
+    }
+
+    false
+}
+
+fn is_end_eq_array_len<'tcx>(
+    cx: &LateContext<'tcx>,
+    end: &Expr<'_>,
+    limits: ast::RangeLimits,
+    indexed_ty: Ty<'tcx>,
+) -> bool {
+    if_chain! {
+        if let ExprKind::Lit(ref lit) = end.kind;
+        if let ast::LitKind::Int(end_int, _) = lit.node;
+        if let ty::Array(_, arr_len_const) = indexed_ty.kind();
+        if let Some(arr_len) = arr_len_const.try_eval_usize(cx.tcx, cx.param_env);
+        then {
+            return match limits {
+                ast::RangeLimits::Closed => end_int + 1 >= arr_len.into(),
+                ast::RangeLimits::HalfOpen => end_int >= arr_len.into(),
+            };
+        }
+    }
+
+    false
+}
+
+fn lint_iter_method(cx: &LateContext<'_>, args: &[Expr<'_>], arg: &Expr<'_>, method_name: &str) {
+    let mut applicability = Applicability::MachineApplicable;
+    let object = snippet_with_applicability(cx, args[0].span, "_", &mut applicability);
+    let muta = if method_name == "iter_mut" { "mut " } else { "" };
+    span_lint_and_sugg(
+        cx,
+        EXPLICIT_ITER_LOOP,
+        arg.span,
+        "it is more concise to loop over references to containers instead of using explicit \
+         iteration methods",
+        "to write this more concisely, try",
+        format!("&{}{}", muta, object),
+        applicability,
+    )
+}
+
+fn check_for_loop_arg(cx: &LateContext<'_>, pat: &Pat<'_>, arg: &Expr<'_>, expr: &Expr<'_>) {
+    let mut next_loop_linted = false; // whether or not ITER_NEXT_LOOP lint was used
+    if let ExprKind::MethodCall(ref method, _, ref args, _) = arg.kind {
+        // just the receiver, no arguments
+        if args.len() == 1 {
+            let method_name = &*method.ident.as_str();
+            // check for looping over x.iter() or x.iter_mut(), could use &x or &mut x
+            if method_name == "iter" || method_name == "iter_mut" {
+                if is_ref_iterable_type(cx, &args[0]) {
+                    lint_iter_method(cx, args, arg, method_name);
+                }
+            } else if method_name == "into_iter" && match_trait_method(cx, arg, &paths::INTO_ITERATOR) {
+                let receiver_ty = cx.typeck_results().expr_ty(&args[0]);
+                let receiver_ty_adjusted = cx.typeck_results().expr_ty_adjusted(&args[0]);
+                if TyS::same_type(receiver_ty, receiver_ty_adjusted) {
+                    let mut applicability = Applicability::MachineApplicable;
+                    let object = snippet_with_applicability(cx, args[0].span, "_", &mut applicability);
+                    span_lint_and_sugg(
+                        cx,
+                        EXPLICIT_INTO_ITER_LOOP,
+                        arg.span,
+                        "it is more concise to loop over containers instead of using explicit \
+                         iteration methods",
+                        "to write this more concisely, try",
+                        object.to_string(),
+                        applicability,
+                    );
+                } else {
+                    let ref_receiver_ty = cx.tcx.mk_ref(
+                        cx.tcx.lifetimes.re_erased,
+                        ty::TypeAndMut {
+                            ty: receiver_ty,
+                            mutbl: Mutability::Not,
+                        },
+                    );
+                    if TyS::same_type(receiver_ty_adjusted, ref_receiver_ty) {
+                        lint_iter_method(cx, args, arg, method_name)
+                    }
+                }
+            } else if method_name == "next" && match_trait_method(cx, arg, &paths::ITERATOR) {
+                span_lint(
+                    cx,
+                    ITER_NEXT_LOOP,
+                    expr.span,
+                    "you are iterating over `Iterator::next()` which is an Option; this will compile but is \
+                    probably not what you want",
+                );
+                next_loop_linted = true;
+            }
+        }
+    }
+    if !next_loop_linted {
+        check_arg_type(cx, pat, arg);
+    }
+}
+
+/// Checks for `for` loops over `Option`s and `Result`s.
+fn check_arg_type(cx: &LateContext<'_>, pat: &Pat<'_>, arg: &Expr<'_>) {
+    let ty = cx.typeck_results().expr_ty(arg);
+    if is_type_diagnostic_item(cx, ty, sym::option_type) {
+        span_lint_and_help(
+            cx,
+            FOR_LOOPS_OVER_FALLIBLES,
+            arg.span,
+            &format!(
+                "for loop over `{0}`, which is an `Option`. This is more readably written as an \
+                `if let` statement",
+                snippet(cx, arg.span, "_")
+            ),
+            None,
+            &format!(
+                "consider replacing `for {0} in {1}` with `if let Some({0}) = {1}`",
+                snippet(cx, pat.span, "_"),
+                snippet(cx, arg.span, "_")
+            ),
+        );
+    } else if is_type_diagnostic_item(cx, ty, sym::result_type) {
+        span_lint_and_help(
+            cx,
+            FOR_LOOPS_OVER_FALLIBLES,
+            arg.span,
+            &format!(
+                "for loop over `{0}`, which is a `Result`. This is more readably written as an \
+                `if let` statement",
+                snippet(cx, arg.span, "_")
+            ),
+            None,
+            &format!(
+                "consider replacing `for {0} in {1}` with `if let Ok({0}) = {1}`",
+                snippet(cx, pat.span, "_"),
+                snippet(cx, arg.span, "_")
+            ),
+        );
+    }
+}
+
+// To trigger the EXPLICIT_COUNTER_LOOP lint, a variable must be
+// incremented exactly once in the loop body, and initialized to zero
+// at the start of the loop.
+fn check_for_loop_explicit_counter<'tcx>(
+    cx: &LateContext<'tcx>,
+    pat: &'tcx Pat<'_>,
+    arg: &'tcx Expr<'_>,
+    body: &'tcx Expr<'_>,
+    expr: &'tcx Expr<'_>,
+) {
+    // Look for variables that are incremented once per loop iteration.
+    let mut increment_visitor = IncrementVisitor::new(cx);
+    walk_expr(&mut increment_visitor, body);
+
+    // For each candidate, check the parent block to see if
+    // it's initialized to zero at the start of the loop.
+    if let Some(block) = get_enclosing_block(&cx, expr.hir_id) {
+        for id in increment_visitor.into_results() {
+            let mut initialize_visitor = InitializeVisitor::new(cx, expr, id);
+            walk_block(&mut initialize_visitor, block);
+
+            if_chain! {
+                if let Some((name, initializer)) = initialize_visitor.get_result();
+                if is_integer_const(cx, initializer, 0);
+                then {
+                    let mut applicability = Applicability::MachineApplicable;
+
+                    let for_span = get_span_of_entire_for_loop(expr);
+
+                    span_lint_and_sugg(
+                        cx,
+                        EXPLICIT_COUNTER_LOOP,
+                        for_span.with_hi(arg.span.hi()),
+                        &format!("the variable `{}` is used as a loop counter", name),
+                        "consider using",
+                        format!(
+                            "for ({}, {}) in {}.enumerate()",
+                            name,
+                            snippet_with_applicability(cx, pat.span, "item", &mut applicability),
+                            make_iterator_snippet(cx, arg, &mut applicability),
+                        ),
+                        applicability,
+                    );
+                }
+            }
+        }
+    }
+}
+
+/// Checks for the `FOR_KV_MAP` lint.
+fn check_for_loop_over_map_kv<'tcx>(
+    cx: &LateContext<'tcx>,
+    pat: &'tcx Pat<'_>,
+    arg: &'tcx Expr<'_>,
+    body: &'tcx Expr<'_>,
+    expr: &'tcx Expr<'_>,
+) {
+    let pat_span = pat.span;
+
+    if let PatKind::Tuple(ref pat, _) = pat.kind {
+        if pat.len() == 2 {
+            let arg_span = arg.span;
+            let (new_pat_span, kind, ty, mutbl) = match *cx.typeck_results().expr_ty(arg).kind() {
+                ty::Ref(_, ty, mutbl) => match (&pat[0].kind, &pat[1].kind) {
+                    (key, _) if pat_is_wild(cx, key, body) => (pat[1].span, "value", ty, mutbl),
+                    (_, value) if pat_is_wild(cx, value, body) => (pat[0].span, "key", ty, Mutability::Not),
+                    _ => return,
+                },
+                _ => return,
+            };
+            let mutbl = match mutbl {
+                Mutability::Not => "",
+                Mutability::Mut => "_mut",
+            };
+            let arg = match arg.kind {
+                ExprKind::AddrOf(BorrowKind::Ref, _, ref expr) => &**expr,
+                _ => arg,
+            };
+
+            if is_type_diagnostic_item(cx, ty, sym!(hashmap_type)) || match_type(cx, ty, &paths::BTREEMAP) {
+                span_lint_and_then(
+                    cx,
+                    FOR_KV_MAP,
+                    expr.span,
+                    &format!("you seem to want to iterate on a map's {}s", kind),
+                    |diag| {
+                        let map = sugg::Sugg::hir(cx, arg, "map");
+                        multispan_sugg(
+                            diag,
+                            "use the corresponding method",
+                            vec![
+                                (pat_span, snippet(cx, new_pat_span, kind).into_owned()),
+                                (arg_span, format!("{}.{}s{}()", map.maybe_par(), kind, mutbl)),
+                            ],
+                        );
+                    },
+                );
+            }
+        }
+    }
+}
+
+fn check_for_single_element_loop<'tcx>(
+    cx: &LateContext<'tcx>,
+    pat: &'tcx Pat<'_>,
+    arg: &'tcx Expr<'_>,
+    body: &'tcx Expr<'_>,
+    expr: &'tcx Expr<'_>,
+) {
+    if_chain! {
+        if let ExprKind::AddrOf(BorrowKind::Ref, _, ref arg_expr) = arg.kind;
+        if let PatKind::Binding(.., target, _) = pat.kind;
+        if let ExprKind::Array([arg_expression]) = arg_expr.kind;
+        if let ExprKind::Path(ref list_item) = arg_expression.kind;
+        if let Some(list_item_name) = single_segment_path(list_item).map(|ps| ps.ident.name);
+        if let ExprKind::Block(ref block, _) = body.kind;
+        if !block.stmts.is_empty();
+
+        then {
+            let for_span = get_span_of_entire_for_loop(expr);
+            let mut block_str = snippet(cx, block.span, "..").into_owned();
+            block_str.remove(0);
+            block_str.pop();
+
+
+            span_lint_and_sugg(
+                cx,
+                SINGLE_ELEMENT_LOOP,
+                for_span,
+                "for loop over a single element",
+                "try",
+                format!("{{\n{}let {} = &{};{}}}", " ".repeat(indent_of(cx, block.stmts[0].span).unwrap_or(0)), target.name, list_item_name, block_str),
+                Applicability::MachineApplicable
+            )
+        }
+    }
+}
+
+struct MutatePairDelegate<'a, 'tcx> {
+    cx: &'a LateContext<'tcx>,
+    hir_id_low: Option<HirId>,
+    hir_id_high: Option<HirId>,
+    span_low: Option<Span>,
+    span_high: Option<Span>,
+}
+
+impl<'tcx> Delegate<'tcx> for MutatePairDelegate<'_, 'tcx> {
+    fn consume(&mut self, _: &PlaceWithHirId<'tcx>, _: HirId, _: ConsumeMode) {}
+
+    fn borrow(&mut self, cmt: &PlaceWithHirId<'tcx>, diag_expr_id: HirId, bk: ty::BorrowKind) {
+        if let ty::BorrowKind::MutBorrow = bk {
+            if let PlaceBase::Local(id) = cmt.place.base {
+                if Some(id) == self.hir_id_low {
+                    self.span_low = Some(self.cx.tcx.hir().span(diag_expr_id))
+                }
+                if Some(id) == self.hir_id_high {
+                    self.span_high = Some(self.cx.tcx.hir().span(diag_expr_id))
+                }
+            }
+        }
+    }
+
+    fn mutate(&mut self, cmt: &PlaceWithHirId<'tcx>, diag_expr_id: HirId) {
+        if let PlaceBase::Local(id) = cmt.place.base {
+            if Some(id) == self.hir_id_low {
+                self.span_low = Some(self.cx.tcx.hir().span(diag_expr_id))
+            }
+            if Some(id) == self.hir_id_high {
+                self.span_high = Some(self.cx.tcx.hir().span(diag_expr_id))
+            }
+        }
+    }
+}
+
+impl MutatePairDelegate<'_, '_> {
+    fn mutation_span(&self) -> (Option<Span>, Option<Span>) {
+        (self.span_low, self.span_high)
+    }
+}
+
+fn check_for_mut_range_bound(cx: &LateContext<'_>, arg: &Expr<'_>, body: &Expr<'_>) {
+    if let Some(higher::Range {
+        start: Some(start),
+        end: Some(end),
+        ..
+    }) = higher::range(arg)
+    {
+        let mut_ids = vec![check_for_mutability(cx, start), check_for_mutability(cx, end)];
+        if mut_ids[0].is_some() || mut_ids[1].is_some() {
+            let (span_low, span_high) = check_for_mutation(cx, body, &mut_ids);
+            mut_warn_with_span(cx, span_low);
+            mut_warn_with_span(cx, span_high);
+        }
+    }
+}
+
+fn mut_warn_with_span(cx: &LateContext<'_>, span: Option<Span>) {
+    if let Some(sp) = span {
+        span_lint(
+            cx,
+            MUT_RANGE_BOUND,
+            sp,
+            "attempt to mutate range bound within loop; note that the range of the loop is unchanged",
+        );
+    }
+}
+
+fn check_for_mutability(cx: &LateContext<'_>, bound: &Expr<'_>) -> Option<HirId> {
+    if_chain! {
+        if let Some(hir_id) = path_to_local(bound);
+        if let Node::Binding(pat) = cx.tcx.hir().get(hir_id);
+        if let PatKind::Binding(BindingAnnotation::Mutable, ..) = pat.kind;
+        then {
+            return Some(hir_id);
+        }
+    }
+    None
+}
+
+fn check_for_mutation<'tcx>(
+    cx: &LateContext<'tcx>,
+    body: &Expr<'_>,
+    bound_ids: &[Option<HirId>],
+) -> (Option<Span>, Option<Span>) {
+    let mut delegate = MutatePairDelegate {
+        cx,
+        hir_id_low: bound_ids[0],
+        hir_id_high: bound_ids[1],
+        span_low: None,
+        span_high: None,
+    };
+    cx.tcx.infer_ctxt().enter(|infcx| {
+        ExprUseVisitor::new(
+            &mut delegate,
+            &infcx,
+            body.hir_id.owner,
+            cx.param_env,
+            cx.typeck_results(),
+        )
+        .walk_expr(body);
+    });
+    delegate.mutation_span()
+}
+
+/// Returns `true` if the pattern is a `PatWild` or an ident prefixed with `_`.
+fn pat_is_wild<'tcx>(cx: &LateContext<'tcx>, pat: &'tcx PatKind<'_>, body: &'tcx Expr<'_>) -> bool {
+    match *pat {
+        PatKind::Wild => true,
+        PatKind::Binding(_, id, ident, None) if ident.as_str().starts_with('_') => {
+            !LocalUsedVisitor::new(cx, id).check_expr(body)
+        },
+        _ => false,
+    }
+}
+
+struct VarVisitor<'a, 'tcx> {
+    /// context reference
+    cx: &'a LateContext<'tcx>,
+    /// var name to look for as index
+    var: HirId,
+    /// indexed variables that are used mutably
+    indexed_mut: FxHashSet<Symbol>,
+    /// indirectly indexed variables (`v[(i + 4) % N]`), the extend is `None` for global
+    indexed_indirectly: FxHashMap<Symbol, Option<region::Scope>>,
+    /// subset of `indexed` of vars that are indexed directly: `v[i]`
+    /// this will not contain cases like `v[calc_index(i)]` or `v[(i + 4) % N]`
+    indexed_directly: FxHashMap<Symbol, (Option<region::Scope>, Ty<'tcx>)>,
+    /// Any names that are used outside an index operation.
+    /// Used to detect things like `&mut vec` used together with `vec[i]`
+    referenced: FxHashSet<Symbol>,
+    /// has the loop variable been used in expressions other than the index of
+    /// an index op?
+    nonindex: bool,
+    /// Whether we are inside the `$` in `&mut $` or `$ = foo` or `$.bar`, where bar
+    /// takes `&mut self`
+    prefer_mutable: bool,
+}
+
+impl<'a, 'tcx> VarVisitor<'a, 'tcx> {
+    fn check(&mut self, idx: &'tcx Expr<'_>, seqexpr: &'tcx Expr<'_>, expr: &'tcx Expr<'_>) -> bool {
+        if_chain! {
+            // the indexed container is referenced by a name
+            if let ExprKind::Path(ref seqpath) = seqexpr.kind;
+            if let QPath::Resolved(None, ref seqvar) = *seqpath;
+            if seqvar.segments.len() == 1;
+            then {
+                let index_used_directly = path_to_local_id(idx, self.var);
+                let indexed_indirectly = {
+                    let mut used_visitor = LocalUsedVisitor::new(self.cx, self.var);
+                    walk_expr(&mut used_visitor, idx);
+                    used_visitor.used
+                };
+
+                if indexed_indirectly || index_used_directly {
+                    if self.prefer_mutable {
+                        self.indexed_mut.insert(seqvar.segments[0].ident.name);
+                    }
+                    let res = self.cx.qpath_res(seqpath, seqexpr.hir_id);
+                    match res {
+                        Res::Local(hir_id) => {
+                            let parent_id = self.cx.tcx.hir().get_parent_item(expr.hir_id);
+                            let parent_def_id = self.cx.tcx.hir().local_def_id(parent_id);
+                            let extent = self.cx.tcx.region_scope_tree(parent_def_id).var_scope(hir_id.local_id);
+                            if indexed_indirectly {
+                                self.indexed_indirectly.insert(seqvar.segments[0].ident.name, Some(extent));
+                            }
+                            if index_used_directly {
+                                self.indexed_directly.insert(
+                                    seqvar.segments[0].ident.name,
+                                    (Some(extent), self.cx.typeck_results().node_type(seqexpr.hir_id)),
+                                );
+                            }
+                            return false;  // no need to walk further *on the variable*
+                        }
+                        Res::Def(DefKind::Static | DefKind::Const, ..) => {
+                            if indexed_indirectly {
+                                self.indexed_indirectly.insert(seqvar.segments[0].ident.name, None);
+                            }
+                            if index_used_directly {
+                                self.indexed_directly.insert(
+                                    seqvar.segments[0].ident.name,
+                                    (None, self.cx.typeck_results().node_type(seqexpr.hir_id)),
+                                );
+                            }
+                            return false;  // no need to walk further *on the variable*
+                        }
+                        _ => (),
+                    }
+                }
+            }
+        }
+        true
+    }
+}
+
+impl<'a, 'tcx> Visitor<'tcx> for VarVisitor<'a, 'tcx> {
+    type Map = Map<'tcx>;
+
+    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
+        if_chain! {
+            // a range index op
+            if let ExprKind::MethodCall(ref meth, _, ref args, _) = expr.kind;
+            if (meth.ident.name == sym::index && match_trait_method(self.cx, expr, &paths::INDEX))
+                || (meth.ident.name == sym::index_mut && match_trait_method(self.cx, expr, &paths::INDEX_MUT));
+            if !self.check(&args[1], &args[0], expr);
+            then { return }
+        }
+
+        if_chain! {
+            // an index op
+            if let ExprKind::Index(ref seqexpr, ref idx) = expr.kind;
+            if !self.check(idx, seqexpr, expr);
+            then { return }
+        }
+
+        if_chain! {
+            // directly using a variable
+            if let ExprKind::Path(QPath::Resolved(None, path)) = expr.kind;
+            if let Res::Local(local_id) = path.res;
+            then {
+                if local_id == self.var {
+                    self.nonindex = true;
+                } else {
+                    // not the correct variable, but still a variable
+                    self.referenced.insert(path.segments[0].ident.name);
+                }
+            }
+        }
+
+        let old = self.prefer_mutable;
+        match expr.kind {
+            ExprKind::AssignOp(_, ref lhs, ref rhs) | ExprKind::Assign(ref lhs, ref rhs, _) => {
+                self.prefer_mutable = true;
+                self.visit_expr(lhs);
+                self.prefer_mutable = false;
+                self.visit_expr(rhs);
+            },
+            ExprKind::AddrOf(BorrowKind::Ref, mutbl, ref expr) => {
+                if mutbl == Mutability::Mut {
+                    self.prefer_mutable = true;
+                }
+                self.visit_expr(expr);
+            },
+            ExprKind::Call(ref f, args) => {
+                self.visit_expr(f);
+                for expr in args {
+                    let ty = self.cx.typeck_results().expr_ty_adjusted(expr);
+                    self.prefer_mutable = false;
+                    if let ty::Ref(_, _, mutbl) = *ty.kind() {
+                        if mutbl == Mutability::Mut {
+                            self.prefer_mutable = true;
+                        }
+                    }
+                    self.visit_expr(expr);
+                }
+            },
+            ExprKind::MethodCall(_, _, args, _) => {
+                let def_id = self.cx.typeck_results().type_dependent_def_id(expr.hir_id).unwrap();
+                for (ty, expr) in self.cx.tcx.fn_sig(def_id).inputs().skip_binder().iter().zip(args) {
+                    self.prefer_mutable = false;
+                    if let ty::Ref(_, _, mutbl) = *ty.kind() {
+                        if mutbl == Mutability::Mut {
+                            self.prefer_mutable = true;
+                        }
+                    }
+                    self.visit_expr(expr);
+                }
+            },
+            ExprKind::Closure(_, _, body_id, ..) => {
+                let body = self.cx.tcx.hir().body(body_id);
+                self.visit_expr(&body.value);
+            },
+            _ => walk_expr(self, expr),
+        }
+        self.prefer_mutable = old;
+    }
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::None
+    }
+}
+
+fn is_used_inside<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, container: &'tcx Expr<'_>) -> bool {
+    let def_id = match path_to_local(expr) {
+        Some(id) => id,
+        None => return false,
+    };
+    if let Some(used_mutably) = mutated_variables(container, cx) {
+        if used_mutably.contains(&def_id) {
+            return true;
+        }
+    }
+    false
+}
+
+fn is_iterator_used_after_while_let<'tcx>(cx: &LateContext<'tcx>, iter_expr: &'tcx Expr<'_>) -> bool {
+    let def_id = match path_to_local(iter_expr) {
+        Some(id) => id,
+        None => return false,
+    };
+    let mut visitor = VarUsedAfterLoopVisitor {
+        def_id,
+        iter_expr_id: iter_expr.hir_id,
+        past_while_let: false,
+        var_used_after_while_let: false,
+    };
+    if let Some(enclosing_block) = get_enclosing_block(cx, def_id) {
+        walk_block(&mut visitor, enclosing_block);
+    }
+    visitor.var_used_after_while_let
+}
+
+struct VarUsedAfterLoopVisitor {
+    def_id: HirId,
+    iter_expr_id: HirId,
+    past_while_let: bool,
+    var_used_after_while_let: bool,
+}
+
+impl<'tcx> Visitor<'tcx> for VarUsedAfterLoopVisitor {
+    type Map = Map<'tcx>;
+
+    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
+        if self.past_while_let {
+            if path_to_local_id(expr, self.def_id) {
+                self.var_used_after_while_let = true;
+            }
+        } else if self.iter_expr_id == expr.hir_id {
+            self.past_while_let = true;
+        }
+        walk_expr(self, expr);
+    }
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::None
+    }
+}
+
+/// Returns `true` if the type of expr is one that provides `IntoIterator` impls
+/// for `&T` and `&mut T`, such as `Vec`.
+#[rustfmt::skip]
+fn is_ref_iterable_type(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
+    // no walk_ptrs_ty: calling iter() on a reference can make sense because it
+    // will allow further borrows afterwards
+    let ty = cx.typeck_results().expr_ty(e);
+    is_iterable_array(ty, cx) ||
+    is_type_diagnostic_item(cx, ty, sym::vec_type) ||
+    match_type(cx, ty, &paths::LINKED_LIST) ||
+    is_type_diagnostic_item(cx, ty, sym!(hashmap_type)) ||
+    is_type_diagnostic_item(cx, ty, sym!(hashset_type)) ||
+    is_type_diagnostic_item(cx, ty, sym!(vecdeque_type)) ||
+    match_type(cx, ty, &paths::BINARY_HEAP) ||
+    match_type(cx, ty, &paths::BTREEMAP) ||
+    match_type(cx, ty, &paths::BTREESET)
+}
+
+fn is_iterable_array<'tcx>(ty: Ty<'tcx>, cx: &LateContext<'tcx>) -> bool {
+    // IntoIterator is currently only implemented for array sizes <= 32 in rustc
+    match ty.kind() {
+        ty::Array(_, n) => n
+            .try_eval_usize(cx.tcx, cx.param_env)
+            .map_or(false, |val| (0..=32).contains(&val)),
+        _ => false,
+    }
+}
+
+/// If a block begins with a statement (possibly a `let` binding) and has an
+/// expression, return it.
+fn extract_expr_from_first_stmt<'tcx>(block: &Block<'tcx>) -> Option<&'tcx Expr<'tcx>> {
+    if block.stmts.is_empty() {
+        return None;
+    }
+    if let StmtKind::Local(ref local) = block.stmts[0].kind {
+        local.init //.map(|expr| expr)
+    } else {
+        None
+    }
+}
+
+/// If a block begins with an expression (with or without semicolon), return it.
+fn extract_first_expr<'tcx>(block: &Block<'tcx>) -> Option<&'tcx Expr<'tcx>> {
+    match block.expr {
+        Some(ref expr) if block.stmts.is_empty() => Some(expr),
+        None if !block.stmts.is_empty() => match block.stmts[0].kind {
+            StmtKind::Expr(ref expr) | StmtKind::Semi(ref expr) => Some(expr),
+            StmtKind::Local(..) | StmtKind::Item(..) => None,
+        },
+        _ => None,
+    }
+}
+
+/// Returns `true` if expr contains a single break expr without destination label
+/// and
+/// passed expression. The expression may be within a block.
+fn is_simple_break_expr(expr: &Expr<'_>) -> bool {
+    match expr.kind {
+        ExprKind::Break(dest, ref passed_expr) if dest.label.is_none() && passed_expr.is_none() => true,
+        ExprKind::Block(ref b, _) => extract_first_expr(b).map_or(false, |subexpr| is_simple_break_expr(subexpr)),
+        _ => false,
+    }
+}
+
+#[derive(Debug, PartialEq)]
+enum IncrementVisitorVarState {
+    Initial,  // Not examined yet
+    IncrOnce, // Incremented exactly once, may be a loop counter
+    DontWarn,
+}
+
+/// Scan a for loop for variables that are incremented exactly once and not used after that.
+struct IncrementVisitor<'a, 'tcx> {
+    cx: &'a LateContext<'tcx>,                          // context reference
+    states: FxHashMap<HirId, IncrementVisitorVarState>, // incremented variables
+    depth: u32,                                         // depth of conditional expressions
+    done: bool,
+}
+
+impl<'a, 'tcx> IncrementVisitor<'a, 'tcx> {
+    fn new(cx: &'a LateContext<'tcx>) -> Self {
+        Self {
+            cx,
+            states: FxHashMap::default(),
+            depth: 0,
+            done: false,
+        }
+    }
+
+    fn into_results(self) -> impl Iterator<Item = HirId> {
+        self.states.into_iter().filter_map(|(id, state)| {
+            if state == IncrementVisitorVarState::IncrOnce {
+                Some(id)
+            } else {
+                None
+            }
+        })
+    }
+}
+
+impl<'a, 'tcx> Visitor<'tcx> for IncrementVisitor<'a, 'tcx> {
+    type Map = Map<'tcx>;
+
+    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
+        if self.done {
+            return;
+        }
+
+        // If node is a variable
+        if let Some(def_id) = path_to_local(expr) {
+            if let Some(parent) = get_parent_expr(self.cx, expr) {
+                let state = self.states.entry(def_id).or_insert(IncrementVisitorVarState::Initial);
+                if *state == IncrementVisitorVarState::IncrOnce {
+                    *state = IncrementVisitorVarState::DontWarn;
+                    return;
+                }
+
+                match parent.kind {
+                    ExprKind::AssignOp(op, ref lhs, ref rhs) => {
+                        if lhs.hir_id == expr.hir_id {
+                            *state = if op.node == BinOpKind::Add
+                                && is_integer_const(self.cx, rhs, 1)
+                                && *state == IncrementVisitorVarState::Initial
+                                && self.depth == 0
+                            {
+                                IncrementVisitorVarState::IncrOnce
+                            } else {
+                                // Assigned some other value or assigned multiple times
+                                IncrementVisitorVarState::DontWarn
+                            };
+                        }
+                    },
+                    ExprKind::Assign(ref lhs, _, _) if lhs.hir_id == expr.hir_id => {
+                        *state = IncrementVisitorVarState::DontWarn
+                    },
+                    ExprKind::AddrOf(BorrowKind::Ref, mutability, _) if mutability == Mutability::Mut => {
+                        *state = IncrementVisitorVarState::DontWarn
+                    },
+                    _ => (),
+                }
+            }
+
+            walk_expr(self, expr);
+        } else if is_loop(expr) || is_conditional(expr) {
+            self.depth += 1;
+            walk_expr(self, expr);
+            self.depth -= 1;
+        } else if let ExprKind::Continue(_) = expr.kind {
+            self.done = true;
+        } else {
+            walk_expr(self, expr);
+        }
+    }
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::None
+    }
+}
+
+enum InitializeVisitorState<'hir> {
+    Initial,          // Not examined yet
+    Declared(Symbol), // Declared but not (yet) initialized
+    Initialized {
+        name: Symbol,
+        initializer: &'hir Expr<'hir>,
+    },
+    DontWarn,
+}
+
+/// Checks whether a variable is initialized at the start of a loop and not modified
+/// and used after the loop.
+struct InitializeVisitor<'a, 'tcx> {
+    cx: &'a LateContext<'tcx>,  // context reference
+    end_expr: &'tcx Expr<'tcx>, // the for loop. Stop scanning here.
+    var_id: HirId,
+    state: InitializeVisitorState<'tcx>,
+    depth: u32, // depth of conditional expressions
+    past_loop: bool,
+}
+
+impl<'a, 'tcx> InitializeVisitor<'a, 'tcx> {
+    fn new(cx: &'a LateContext<'tcx>, end_expr: &'tcx Expr<'tcx>, var_id: HirId) -> Self {
+        Self {
+            cx,
+            end_expr,
+            var_id,
+            state: InitializeVisitorState::Initial,
+            depth: 0,
+            past_loop: false,
+        }
+    }
+
+    fn get_result(&self) -> Option<(Symbol, &'tcx Expr<'tcx>)> {
+        if let InitializeVisitorState::Initialized { name, initializer } = self.state {
+            Some((name, initializer))
+        } else {
+            None
+        }
+    }
+}
+
+impl<'a, 'tcx> Visitor<'tcx> for InitializeVisitor<'a, 'tcx> {
+    type Map = Map<'tcx>;
+
+    fn visit_stmt(&mut self, stmt: &'tcx Stmt<'_>) {
+        // Look for declarations of the variable
+        if_chain! {
+            if let StmtKind::Local(ref local) = stmt.kind;
+            if local.pat.hir_id == self.var_id;
+            if let PatKind::Binding(.., ident, _) = local.pat.kind;
+            then {
+                self.state = local.init.map_or(InitializeVisitorState::Declared(ident.name), |init| {
+                    InitializeVisitorState::Initialized {
+                        initializer: init,
+                        name: ident.name,
+                    }
+                })
+            }
+        }
+        walk_stmt(self, stmt);
+    }
+
+    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
+        if matches!(self.state, InitializeVisitorState::DontWarn) {
+            return;
+        }
+        if expr.hir_id == self.end_expr.hir_id {
+            self.past_loop = true;
+            return;
+        }
+        // No need to visit expressions before the variable is
+        // declared
+        if matches!(self.state, InitializeVisitorState::Initial) {
+            return;
+        }
+
+        // If node is the desired variable, see how it's used
+        if path_to_local_id(expr, self.var_id) {
+            if self.past_loop {
+                self.state = InitializeVisitorState::DontWarn;
+                return;
+            }
+
+            if let Some(parent) = get_parent_expr(self.cx, expr) {
+                match parent.kind {
+                    ExprKind::AssignOp(_, ref lhs, _) if lhs.hir_id == expr.hir_id => {
+                        self.state = InitializeVisitorState::DontWarn;
+                    },
+                    ExprKind::Assign(ref lhs, ref rhs, _) if lhs.hir_id == expr.hir_id => {
+                        self.state = if_chain! {
+                            if self.depth == 0;
+                            if let InitializeVisitorState::Declared(name)
+                                | InitializeVisitorState::Initialized { name, ..} = self.state;
+                            then {
+                                InitializeVisitorState::Initialized { initializer: rhs, name }
+                            } else {
+                                InitializeVisitorState::DontWarn
+                            }
+                        }
+                    },
+                    ExprKind::AddrOf(BorrowKind::Ref, mutability, _) if mutability == Mutability::Mut => {
+                        self.state = InitializeVisitorState::DontWarn
+                    },
+                    _ => (),
+                }
+            }
+
+            walk_expr(self, expr);
+        } else if !self.past_loop && is_loop(expr) {
+            self.state = InitializeVisitorState::DontWarn;
+        } else if is_conditional(expr) {
+            self.depth += 1;
+            walk_expr(self, expr);
+            self.depth -= 1;
+        } else {
+            walk_expr(self, expr);
+        }
+    }
+
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::OnlyBodies(self.cx.tcx.hir())
+    }
+}
+
+fn is_loop(expr: &Expr<'_>) -> bool {
+    matches!(expr.kind, ExprKind::Loop(..))
+}
+
+fn is_conditional(expr: &Expr<'_>) -> bool {
+    matches!(expr.kind, ExprKind::If(..) | ExprKind::Match(..))
+}
+
+fn is_nested(cx: &LateContext<'_>, match_expr: &Expr<'_>, iter_expr: &Expr<'_>) -> bool {
+    if_chain! {
+        if let Some(loop_block) = get_enclosing_block(cx, match_expr.hir_id);
+        let parent_node = cx.tcx.hir().get_parent_node(loop_block.hir_id);
+        if let Some(Node::Expr(loop_expr)) = cx.tcx.hir().find(parent_node);
+        then {
+            return is_loop_nested(cx, loop_expr, iter_expr)
+        }
+    }
+    false
+}
+
+fn is_loop_nested(cx: &LateContext<'_>, loop_expr: &Expr<'_>, iter_expr: &Expr<'_>) -> bool {
+    let mut id = loop_expr.hir_id;
+    let iter_id = if let Some(id) = path_to_local(iter_expr) {
+        id
+    } else {
+        return true;
+    };
+    loop {
+        let parent = cx.tcx.hir().get_parent_node(id);
+        if parent == id {
+            return false;
+        }
+        match cx.tcx.hir().find(parent) {
+            Some(Node::Expr(expr)) => {
+                if let ExprKind::Loop(..) = expr.kind {
+                    return true;
+                };
+            },
+            Some(Node::Block(block)) => {
+                let mut block_visitor = LoopNestVisitor {
+                    hir_id: id,
+                    iterator: iter_id,
+                    nesting: Unknown,
+                };
+                walk_block(&mut block_visitor, block);
+                if block_visitor.nesting == RuledOut {
+                    return false;
+                }
+            },
+            Some(Node::Stmt(_)) => (),
+            _ => {
+                return false;
+            },
+        }
+        id = parent;
+    }
+}
+
+#[derive(PartialEq, Eq)]
+enum Nesting {
+    Unknown,     // no nesting detected yet
+    RuledOut,    // the iterator is initialized or assigned within scope
+    LookFurther, // no nesting detected, no further walk required
+}
+
+use self::Nesting::{LookFurther, RuledOut, Unknown};
+
+struct LoopNestVisitor {
+    hir_id: HirId,
+    iterator: HirId,
+    nesting: Nesting,
+}
+
+impl<'tcx> Visitor<'tcx> for LoopNestVisitor {
+    type Map = Map<'tcx>;
+
+    fn visit_stmt(&mut self, stmt: &'tcx Stmt<'_>) {
+        if stmt.hir_id == self.hir_id {
+            self.nesting = LookFurther;
+        } else if self.nesting == Unknown {
+            walk_stmt(self, stmt);
+        }
+    }
+
+    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
+        if self.nesting != Unknown {
+            return;
+        }
+        if expr.hir_id == self.hir_id {
+            self.nesting = LookFurther;
+            return;
+        }
+        match expr.kind {
+            ExprKind::Assign(ref path, _, _) | ExprKind::AssignOp(_, ref path, _) => {
+                if path_to_local_id(path, self.iterator) {
+                    self.nesting = RuledOut;
+                }
+            },
+            _ => walk_expr(self, expr),
+        }
+    }
+
+    fn visit_pat(&mut self, pat: &'tcx Pat<'_>) {
+        if self.nesting != Unknown {
+            return;
+        }
+        if let PatKind::Binding(_, id, ..) = pat.kind {
+            if id == self.iterator {
+                self.nesting = RuledOut;
+                return;
+            }
+        }
+        walk_pat(self, pat)
+    }
+
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::None
+    }
+}
+
+fn check_infinite_loop<'tcx>(cx: &LateContext<'tcx>, cond: &'tcx Expr<'_>, expr: &'tcx Expr<'_>) {
+    if constant(cx, cx.typeck_results(), cond).is_some() {
+        // A pure constant condition (e.g., `while false`) is not linted.
+        return;
+    }
+
+    let mut var_visitor = VarCollectorVisitor {
+        cx,
+        ids: FxHashSet::default(),
+        def_ids: FxHashMap::default(),
+        skip: false,
+    };
+    var_visitor.visit_expr(cond);
+    if var_visitor.skip {
+        return;
+    }
+    let used_in_condition = &var_visitor.ids;
+    let no_cond_variable_mutated = if let Some(used_mutably) = mutated_variables(expr, cx) {
+        used_in_condition.is_disjoint(&used_mutably)
+    } else {
+        return;
+    };
+    let mutable_static_in_cond = var_visitor.def_ids.iter().any(|(_, v)| *v);
+
+    let mut has_break_or_return_visitor = HasBreakOrReturnVisitor {
+        has_break_or_return: false,
+    };
+    has_break_or_return_visitor.visit_expr(expr);
+    let has_break_or_return = has_break_or_return_visitor.has_break_or_return;
+
+    if no_cond_variable_mutated && !mutable_static_in_cond {
+        span_lint_and_then(
+            cx,
+            WHILE_IMMUTABLE_CONDITION,
+            cond.span,
+            "variables in the condition are not mutated in the loop body",
+            |diag| {
+                diag.note("this may lead to an infinite or to a never running loop");
+
+                if has_break_or_return {
+                    diag.note("this loop contains `return`s or `break`s");
+                    diag.help("rewrite it as `if cond { loop { } }`");
+                }
+            },
+        );
+    }
+}
+
+struct HasBreakOrReturnVisitor {
+    has_break_or_return: bool,
+}
+
+impl<'tcx> Visitor<'tcx> for HasBreakOrReturnVisitor {
+    type Map = Map<'tcx>;
+
+    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
+        if self.has_break_or_return {
+            return;
+        }
+
+        match expr.kind {
+            ExprKind::Ret(_) | ExprKind::Break(_, _) => {
+                self.has_break_or_return = true;
+                return;
+            },
+            _ => {},
+        }
+
+        walk_expr(self, expr);
+    }
+
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::None
+    }
+}
+
+/// Collects the set of variables in an expression
+/// Stops analysis if a function call is found
+/// Note: In some cases such as `self`, there are no mutable annotation,
+/// All variables definition IDs are collected
+struct VarCollectorVisitor<'a, 'tcx> {
+    cx: &'a LateContext<'tcx>,
+    ids: FxHashSet<HirId>,
+    def_ids: FxHashMap<def_id::DefId, bool>,
+    skip: bool,
+}
+
+impl<'a, 'tcx> VarCollectorVisitor<'a, 'tcx> {
+    fn insert_def_id(&mut self, ex: &'tcx Expr<'_>) {
+        if_chain! {
+            if let ExprKind::Path(ref qpath) = ex.kind;
+            if let QPath::Resolved(None, _) = *qpath;
+            let res = self.cx.qpath_res(qpath, ex.hir_id);
+            then {
+                match res {
+                    Res::Local(hir_id) => {
+                        self.ids.insert(hir_id);
+                    },
+                    Res::Def(DefKind::Static, def_id) => {
+                        let mutable = self.cx.tcx.is_mutable_static(def_id);
+                        self.def_ids.insert(def_id, mutable);
+                    },
+                    _ => {},
+                }
+            }
+        }
+    }
+}
+
+impl<'a, 'tcx> Visitor<'tcx> for VarCollectorVisitor<'a, 'tcx> {
+    type Map = Map<'tcx>;
+
+    fn visit_expr(&mut self, ex: &'tcx Expr<'_>) {
+        match ex.kind {
+            ExprKind::Path(_) => self.insert_def_id(ex),
+            // If there is any function/method call… we just stop analysis
+            ExprKind::Call(..) | ExprKind::MethodCall(..) => self.skip = true,
+
+            _ => walk_expr(self, ex),
+        }
+    }
+
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::None
+    }
+}
+
+const NEEDLESS_COLLECT_MSG: &str = "avoid using `collect()` when not needed";
+
+fn check_needless_collect<'tcx>(expr: &'tcx Expr<'_>, cx: &LateContext<'tcx>) {
+    check_needless_collect_direct_usage(expr, cx);
+    check_needless_collect_indirect_usage(expr, cx);
+}
+fn check_needless_collect_direct_usage<'tcx>(expr: &'tcx Expr<'_>, cx: &LateContext<'tcx>) {
+    if_chain! {
+        if let ExprKind::MethodCall(ref method, _, ref args, _) = expr.kind;
+        if let ExprKind::MethodCall(ref chain_method, _, _, _) = args[0].kind;
+        if chain_method.ident.name == sym!(collect) && match_trait_method(cx, &args[0], &paths::ITERATOR);
+        if let Some(ref generic_args) = chain_method.args;
+        if let Some(GenericArg::Type(ref ty)) = generic_args.args.get(0);
+        then {
+            let ty = cx.typeck_results().node_type(ty.hir_id);
+            if is_type_diagnostic_item(cx, ty, sym::vec_type) ||
+                is_type_diagnostic_item(cx, ty, sym!(vecdeque_type)) ||
+                match_type(cx, ty, &paths::BTREEMAP) ||
+                is_type_diagnostic_item(cx, ty, sym!(hashmap_type)) {
+                if method.ident.name == sym!(len) {
+                    let span = shorten_needless_collect_span(expr);
+                    span_lint_and_sugg(
+                        cx,
+                        NEEDLESS_COLLECT,
+                        span,
+                        NEEDLESS_COLLECT_MSG,
+                        "replace with",
+                        "count()".to_string(),
+                        Applicability::MachineApplicable,
+                    );
+                }
+                if method.ident.name == sym!(is_empty) {
+                    let span = shorten_needless_collect_span(expr);
+                    span_lint_and_sugg(
+                        cx,
+                        NEEDLESS_COLLECT,
+                        span,
+                        NEEDLESS_COLLECT_MSG,
+                        "replace with",
+                        "next().is_none()".to_string(),
+                        Applicability::MachineApplicable,
+                    );
+                }
+                if method.ident.name == sym!(contains) {
+                    let contains_arg = snippet(cx, args[1].span, "??");
+                    let span = shorten_needless_collect_span(expr);
+                    span_lint_and_then(
+                        cx,
+                        NEEDLESS_COLLECT,
+                        span,
+                        NEEDLESS_COLLECT_MSG,
+                        |diag| {
+                            let (arg, pred) = contains_arg
+                                    .strip_prefix('&')
+                                    .map_or(("&x", &*contains_arg), |s| ("x", s));
+                            diag.span_suggestion(
+                                span,
+                                "replace with",
+                                format!(
+                                    "any(|{}| x == {})",
+                                    arg, pred
+                                ),
+                                Applicability::MachineApplicable,
+                            );
+                        }
+                    );
+                }
+            }
+        }
+    }
+}
+
+fn check_needless_collect_indirect_usage<'tcx>(expr: &'tcx Expr<'_>, cx: &LateContext<'tcx>) {
+    if let ExprKind::Block(ref block, _) = expr.kind {
+        for ref stmt in block.stmts {
+            if_chain! {
+                if let StmtKind::Local(
+                    Local { pat: Pat { hir_id: pat_id, kind: PatKind::Binding(_, _, ident, .. ), .. },
+                    init: Some(ref init_expr), .. }
+                ) = stmt.kind;
+                if let ExprKind::MethodCall(ref method_name, _, &[ref iter_source], ..) = init_expr.kind;
+                if method_name.ident.name == sym!(collect) && match_trait_method(cx, &init_expr, &paths::ITERATOR);
+                if let Some(ref generic_args) = method_name.args;
+                if let Some(GenericArg::Type(ref ty)) = generic_args.args.get(0);
+                if let ty = cx.typeck_results().node_type(ty.hir_id);
+                if is_type_diagnostic_item(cx, ty, sym::vec_type) ||
+                    is_type_diagnostic_item(cx, ty, sym!(vecdeque_type)) ||
+                    match_type(cx, ty, &paths::LINKED_LIST);
+                if let Some(iter_calls) = detect_iter_and_into_iters(block, *ident);
+                if iter_calls.len() == 1;
+                then {
+                    let mut used_count_visitor = UsedCountVisitor {
+                        cx,
+                        id: *pat_id,
+                        count: 0,
+                    };
+                    walk_block(&mut used_count_visitor, block);
+                    if used_count_visitor.count > 1 {
+                        return;
+                    }
+
+                    // Suggest replacing iter_call with iter_replacement, and removing stmt
+                    let iter_call = &iter_calls[0];
+                    span_lint_and_then(
+                        cx,
+                        NEEDLESS_COLLECT,
+                        stmt.span.until(iter_call.span),
+                        NEEDLESS_COLLECT_MSG,
+                        |diag| {
+                            let iter_replacement = format!("{}{}", Sugg::hir(cx, iter_source, ".."), iter_call.get_iter_method(cx));
+                            diag.multipart_suggestion(
+                                iter_call.get_suggestion_text(),
+                                vec![
+                                    (stmt.span, String::new()),
+                                    (iter_call.span, iter_replacement)
+                                ],
+                                Applicability::MachineApplicable,// MaybeIncorrect,
+                            ).emit();
+                        },
+                    );
+                }
+            }
+        }
+    }
+}
+
+struct IterFunction {
+    func: IterFunctionKind,
+    span: Span,
+}
+impl IterFunction {
+    fn get_iter_method(&self, cx: &LateContext<'_>) -> String {
+        match &self.func {
+            IterFunctionKind::IntoIter => String::new(),
+            IterFunctionKind::Len => String::from(".count()"),
+            IterFunctionKind::IsEmpty => String::from(".next().is_none()"),
+            IterFunctionKind::Contains(span) => {
+                let s = snippet(cx, *span, "..");
+                if let Some(stripped) = s.strip_prefix('&') {
+                    format!(".any(|x| x == {})", stripped)
+                } else {
+                    format!(".any(|x| x == *{})", s)
+                }
+            },
+        }
+    }
+    fn get_suggestion_text(&self) -> &'static str {
+        match &self.func {
+            IterFunctionKind::IntoIter => {
+                "use the original Iterator instead of collecting it and then producing a new one"
+            },
+            IterFunctionKind::Len => {
+                "take the original Iterator's count instead of collecting it and finding the length"
+            },
+            IterFunctionKind::IsEmpty => {
+                "check if the original Iterator has anything instead of collecting it and seeing if it's empty"
+            },
+            IterFunctionKind::Contains(_) => {
+                "check if the original Iterator contains an element instead of collecting then checking"
+            },
+        }
+    }
+}
+enum IterFunctionKind {
+    IntoIter,
+    Len,
+    IsEmpty,
+    Contains(Span),
+}
+
+struct IterFunctionVisitor {
+    uses: Vec<IterFunction>,
+    seen_other: bool,
+    target: Ident,
+}
+impl<'tcx> Visitor<'tcx> for IterFunctionVisitor {
+    fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) {
+        // Check function calls on our collection
+        if_chain! {
+            if let ExprKind::MethodCall(method_name, _, ref args, _) = &expr.kind;
+            if let Some(Expr { kind: ExprKind::Path(QPath::Resolved(_, ref path)), .. }) = args.get(0);
+            if let &[name] = &path.segments;
+            if name.ident == self.target;
+            then {
+                let len = sym!(len);
+                let is_empty = sym!(is_empty);
+                let contains = sym!(contains);
+                match method_name.ident.name {
+                    sym::into_iter => self.uses.push(
+                        IterFunction { func: IterFunctionKind::IntoIter, span: expr.span }
+                    ),
+                    name if name == len => self.uses.push(
+                        IterFunction { func: IterFunctionKind::Len, span: expr.span }
+                    ),
+                    name if name == is_empty => self.uses.push(
+                        IterFunction { func: IterFunctionKind::IsEmpty, span: expr.span }
+                    ),
+                    name if name == contains => self.uses.push(
+                        IterFunction { func: IterFunctionKind::Contains(args[1].span), span: expr.span }
+                    ),
+                    _ => self.seen_other = true,
+                }
+                return
+            }
+        }
+        // Check if the collection is used for anything else
+        if_chain! {
+            if let Expr { kind: ExprKind::Path(QPath::Resolved(_, ref path)), .. } = expr;
+            if let &[name] = &path.segments;
+            if name.ident == self.target;
+            then {
+                self.seen_other = true;
+            } else {
+                walk_expr(self, expr);
+            }
+        }
+    }
+
+    type Map = Map<'tcx>;
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::None
+    }
+}
+
+struct UsedCountVisitor<'a, 'tcx> {
+    cx: &'a LateContext<'tcx>,
+    id: HirId,
+    count: usize,
+}
+
+impl<'a, 'tcx> Visitor<'tcx> for UsedCountVisitor<'a, 'tcx> {
+    type Map = Map<'tcx>;
+
+    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
+        if path_to_local_id(expr, self.id) {
+            self.count += 1;
+        } else {
+            walk_expr(self, expr);
+        }
+    }
+
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::OnlyBodies(self.cx.tcx.hir())
+    }
+}
+
+/// Detect the occurrences of calls to `iter` or `into_iter` for the
+/// given identifier
+fn detect_iter_and_into_iters<'tcx>(block: &'tcx Block<'tcx>, identifier: Ident) -> Option<Vec<IterFunction>> {
+    let mut visitor = IterFunctionVisitor {
+        uses: Vec::new(),
+        target: identifier,
+        seen_other: false,
+    };
+    visitor.visit_block(block);
+    if visitor.seen_other { None } else { Some(visitor.uses) }
+}
+
+fn shorten_needless_collect_span(expr: &Expr<'_>) -> Span {
+    if_chain! {
+        if let ExprKind::MethodCall(.., args, _) = &expr.kind;
+        if let ExprKind::MethodCall(_, span, ..) = &args[0].kind;
+        then {
+            return expr.span.with_lo(span.lo());
+        }
+    }
+    unreachable!();
+}
diff --git a/clippy_lints/src/loops/utils.rs b/clippy_lints/src/loops/utils.rs
new file mode 100644
index 00000000000..b06df2d75f3
--- /dev/null
+++ b/clippy_lints/src/loops/utils.rs
@@ -0,0 +1,40 @@
+use crate::utils::{get_trait_def_id, has_iter_method, implements_trait, paths, sugg};
+use rustc_errors::Applicability;
+use rustc_hir::{BorrowKind, Expr, ExprKind, Mutability};
+use rustc_lint::LateContext;
+
+/// If `arg` was the argument to a `for` loop, return the "cleanest" way of writing the
+/// actual `Iterator` that the loop uses.
+pub(super) fn make_iterator_snippet(cx: &LateContext<'_>, arg: &Expr<'_>, applic_ref: &mut Applicability) -> String {
+    let impls_iterator = get_trait_def_id(cx, &paths::ITERATOR).map_or(false, |id| {
+        implements_trait(cx, cx.typeck_results().expr_ty(arg), id, &[])
+    });
+    if impls_iterator {
+        format!(
+            "{}",
+            sugg::Sugg::hir_with_applicability(cx, arg, "_", applic_ref).maybe_par()
+        )
+    } else {
+        // (&x).into_iter() ==> x.iter()
+        // (&mut x).into_iter() ==> x.iter_mut()
+        match &arg.kind {
+            ExprKind::AddrOf(BorrowKind::Ref, mutability, arg_inner)
+                if has_iter_method(cx, cx.typeck_results().expr_ty(&arg_inner)).is_some() =>
+            {
+                let meth_name = match mutability {
+                    Mutability::Mut => "iter_mut",
+                    Mutability::Not => "iter",
+                };
+                format!(
+                    "{}.{}()",
+                    sugg::Sugg::hir_with_applicability(cx, &arg_inner, "_", applic_ref).maybe_par(),
+                    meth_name,
+                )
+            }
+            _ => format!(
+                "{}.into_iter()",
+                sugg::Sugg::hir_with_applicability(cx, arg, "_", applic_ref).maybe_par()
+            ),
+        }
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 408368a82c2c394b65524cb995e01ecfc3c1867c Mon Sep 17 00:00:00 2001
From: nahuakang <kangnahua@gmail.com>
Date: Mon, 8 Feb 2021 20:47:35 +0100
Subject: Refactor check_for_loop_arg; rename manual_flatten's lint back to
 check_manual_flatten

---
 clippy_lints/src/loops/for_loop_arg.rs   | 149 +++++++++++++++++++++++++++++++
 clippy_lints/src/loops/manual_flatten.rs |   2 +-
 clippy_lints/src/loops/mod.rs            | 147 +-----------------------------
 3 files changed, 154 insertions(+), 144 deletions(-)
 create mode 100644 clippy_lints/src/loops/for_loop_arg.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/for_loop_arg.rs b/clippy_lints/src/loops/for_loop_arg.rs
new file mode 100644
index 00000000000..b33e7183984
--- /dev/null
+++ b/clippy_lints/src/loops/for_loop_arg.rs
@@ -0,0 +1,149 @@
+use crate::utils::{
+    is_type_diagnostic_item, match_trait_method, match_type, paths, snippet, snippet_with_applicability, span_lint,
+    span_lint_and_help, span_lint_and_sugg,
+};
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind, Mutability, Pat};
+use rustc_lint::LateContext;
+use rustc_middle::ty::{self, Ty, TyS};
+use rustc_span::symbol::sym;
+
+pub(super) fn check_for_loop_arg(cx: &LateContext<'_>, pat: &Pat<'_>, arg: &Expr<'_>, expr: &Expr<'_>) {
+    let mut next_loop_linted = false; // whether or not ITER_NEXT_LOOP lint was used
+    if let ExprKind::MethodCall(ref method, _, ref args, _) = arg.kind {
+        // just the receiver, no arguments
+        if args.len() == 1 {
+            let method_name = &*method.ident.as_str();
+            // check for looping over x.iter() or x.iter_mut(), could use &x or &mut x
+            if method_name == "iter" || method_name == "iter_mut" {
+                if is_ref_iterable_type(cx, &args[0]) {
+                    lint_iter_method(cx, args, arg, method_name);
+                }
+            } else if method_name == "into_iter" && match_trait_method(cx, arg, &paths::INTO_ITERATOR) {
+                let receiver_ty = cx.typeck_results().expr_ty(&args[0]);
+                let receiver_ty_adjusted = cx.typeck_results().expr_ty_adjusted(&args[0]);
+                if TyS::same_type(receiver_ty, receiver_ty_adjusted) {
+                    let mut applicability = Applicability::MachineApplicable;
+                    let object = snippet_with_applicability(cx, args[0].span, "_", &mut applicability);
+                    span_lint_and_sugg(
+                        cx,
+                        super::EXPLICIT_INTO_ITER_LOOP,
+                        arg.span,
+                        "it is more concise to loop over containers instead of using explicit \
+                         iteration methods",
+                        "to write this more concisely, try",
+                        object.to_string(),
+                        applicability,
+                    );
+                } else {
+                    let ref_receiver_ty = cx.tcx.mk_ref(
+                        cx.tcx.lifetimes.re_erased,
+                        ty::TypeAndMut {
+                            ty: receiver_ty,
+                            mutbl: Mutability::Not,
+                        },
+                    );
+                    if TyS::same_type(receiver_ty_adjusted, ref_receiver_ty) {
+                        lint_iter_method(cx, args, arg, method_name)
+                    }
+                }
+            } else if method_name == "next" && match_trait_method(cx, arg, &paths::ITERATOR) {
+                span_lint(
+                    cx,
+                    super::ITER_NEXT_LOOP,
+                    expr.span,
+                    "you are iterating over `Iterator::next()` which is an Option; this will compile but is \
+                    probably not what you want",
+                );
+                next_loop_linted = true;
+            }
+        }
+    }
+    if !next_loop_linted {
+        check_arg_type(cx, pat, arg);
+    }
+}
+
+/// Checks for `for` loops over `Option`s and `Result`s.
+fn check_arg_type(cx: &LateContext<'_>, pat: &Pat<'_>, arg: &Expr<'_>) {
+    let ty = cx.typeck_results().expr_ty(arg);
+    if is_type_diagnostic_item(cx, ty, sym::option_type) {
+        span_lint_and_help(
+            cx,
+            super::FOR_LOOPS_OVER_FALLIBLES,
+            arg.span,
+            &format!(
+                "for loop over `{0}`, which is an `Option`. This is more readably written as an \
+                `if let` statement",
+                snippet(cx, arg.span, "_")
+            ),
+            None,
+            &format!(
+                "consider replacing `for {0} in {1}` with `if let Some({0}) = {1}`",
+                snippet(cx, pat.span, "_"),
+                snippet(cx, arg.span, "_")
+            ),
+        );
+    } else if is_type_diagnostic_item(cx, ty, sym::result_type) {
+        span_lint_and_help(
+            cx,
+            super::FOR_LOOPS_OVER_FALLIBLES,
+            arg.span,
+            &format!(
+                "for loop over `{0}`, which is a `Result`. This is more readably written as an \
+                `if let` statement",
+                snippet(cx, arg.span, "_")
+            ),
+            None,
+            &format!(
+                "consider replacing `for {0} in {1}` with `if let Ok({0}) = {1}`",
+                snippet(cx, pat.span, "_"),
+                snippet(cx, arg.span, "_")
+            ),
+        );
+    }
+}
+
+fn lint_iter_method(cx: &LateContext<'_>, args: &[Expr<'_>], arg: &Expr<'_>, method_name: &str) {
+    let mut applicability = Applicability::MachineApplicable;
+    let object = snippet_with_applicability(cx, args[0].span, "_", &mut applicability);
+    let muta = if method_name == "iter_mut" { "mut " } else { "" };
+    span_lint_and_sugg(
+        cx,
+        super::EXPLICIT_ITER_LOOP,
+        arg.span,
+        "it is more concise to loop over references to containers instead of using explicit \
+         iteration methods",
+        "to write this more concisely, try",
+        format!("&{}{}", muta, object),
+        applicability,
+    )
+}
+
+/// Returns `true` if the type of expr is one that provides `IntoIterator` impls
+/// for `&T` and `&mut T`, such as `Vec`.
+#[rustfmt::skip]
+fn is_ref_iterable_type(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
+    // no walk_ptrs_ty: calling iter() on a reference can make sense because it
+    // will allow further borrows afterwards
+    let ty = cx.typeck_results().expr_ty(e);
+    is_iterable_array(ty, cx) ||
+    is_type_diagnostic_item(cx, ty, sym::vec_type) ||
+    match_type(cx, ty, &paths::LINKED_LIST) ||
+    is_type_diagnostic_item(cx, ty, sym!(hashmap_type)) ||
+    is_type_diagnostic_item(cx, ty, sym!(hashset_type)) ||
+    is_type_diagnostic_item(cx, ty, sym!(vecdeque_type)) ||
+    match_type(cx, ty, &paths::BINARY_HEAP) ||
+    match_type(cx, ty, &paths::BTREEMAP) ||
+    match_type(cx, ty, &paths::BTREESET)
+}
+
+fn is_iterable_array<'tcx>(ty: Ty<'tcx>, cx: &LateContext<'tcx>) -> bool {
+    // IntoIterator is currently only implemented for array sizes <= 32 in rustc
+    match ty.kind() {
+        ty::Array(_, n) => n
+            .try_eval_usize(cx.tcx, cx.param_env)
+            .map_or(false, |val| (0..=32).contains(&val)),
+        _ => false,
+    }
+}
diff --git a/clippy_lints/src/loops/manual_flatten.rs b/clippy_lints/src/loops/manual_flatten.rs
index b5881a1b8c4..db90d2c0468 100644
--- a/clippy_lints/src/loops/manual_flatten.rs
+++ b/clippy_lints/src/loops/manual_flatten.rs
@@ -8,7 +8,7 @@ use rustc_span::source_map::Span;
 
 /// Check for unnecessary `if let` usage in a for loop where only the `Some` or `Ok` variant of the
 /// iterator element is used.
-pub(super) fn lint<'tcx>(
+pub(super) fn check_manual_flatten<'tcx>(
     cx: &LateContext<'tcx>,
     pat: &'tcx Pat<'_>,
     arg: &'tcx Expr<'_>,
diff --git a/clippy_lints/src/loops/mod.rs b/clippy_lints/src/loops/mod.rs
index 18b7e96d42c..63eeb3607b6 100644
--- a/clippy_lints/src/loops/mod.rs
+++ b/clippy_lints/src/loops/mod.rs
@@ -1,3 +1,4 @@
+mod for_loop_arg;
 mod manual_flatten;
 mod utils;
 
@@ -27,7 +28,7 @@ use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::hir::map::Map;
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::middle::region;
-use rustc_middle::ty::{self, Ty, TyS};
+use rustc_middle::ty::{self, Ty};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
 use rustc_span::symbol::{sym, Ident, Symbol};
@@ -861,12 +862,12 @@ fn check_for_loop<'tcx>(
         check_for_loop_range(cx, pat, arg, body, expr);
         check_for_loop_explicit_counter(cx, pat, arg, body, expr);
     }
-    check_for_loop_arg(cx, pat, arg, expr);
+    for_loop_arg::check_for_loop_arg(cx, pat, arg, expr);
     check_for_loop_over_map_kv(cx, pat, arg, body, expr);
     check_for_mut_range_bound(cx, arg, body);
     check_for_single_element_loop(cx, pat, arg, body, expr);
     detect_same_item_push(cx, pat, arg, body, expr);
-    manual_flatten::lint(cx, pat, arg, body, span);
+    manual_flatten::check_manual_flatten(cx, pat, arg, body, span);
 }
 
 // this function assumes the given expression is a `for` loop.
@@ -1682,118 +1683,6 @@ fn is_end_eq_array_len<'tcx>(
     false
 }
 
-fn lint_iter_method(cx: &LateContext<'_>, args: &[Expr<'_>], arg: &Expr<'_>, method_name: &str) {
-    let mut applicability = Applicability::MachineApplicable;
-    let object = snippet_with_applicability(cx, args[0].span, "_", &mut applicability);
-    let muta = if method_name == "iter_mut" { "mut " } else { "" };
-    span_lint_and_sugg(
-        cx,
-        EXPLICIT_ITER_LOOP,
-        arg.span,
-        "it is more concise to loop over references to containers instead of using explicit \
-         iteration methods",
-        "to write this more concisely, try",
-        format!("&{}{}", muta, object),
-        applicability,
-    )
-}
-
-fn check_for_loop_arg(cx: &LateContext<'_>, pat: &Pat<'_>, arg: &Expr<'_>, expr: &Expr<'_>) {
-    let mut next_loop_linted = false; // whether or not ITER_NEXT_LOOP lint was used
-    if let ExprKind::MethodCall(ref method, _, ref args, _) = arg.kind {
-        // just the receiver, no arguments
-        if args.len() == 1 {
-            let method_name = &*method.ident.as_str();
-            // check for looping over x.iter() or x.iter_mut(), could use &x or &mut x
-            if method_name == "iter" || method_name == "iter_mut" {
-                if is_ref_iterable_type(cx, &args[0]) {
-                    lint_iter_method(cx, args, arg, method_name);
-                }
-            } else if method_name == "into_iter" && match_trait_method(cx, arg, &paths::INTO_ITERATOR) {
-                let receiver_ty = cx.typeck_results().expr_ty(&args[0]);
-                let receiver_ty_adjusted = cx.typeck_results().expr_ty_adjusted(&args[0]);
-                if TyS::same_type(receiver_ty, receiver_ty_adjusted) {
-                    let mut applicability = Applicability::MachineApplicable;
-                    let object = snippet_with_applicability(cx, args[0].span, "_", &mut applicability);
-                    span_lint_and_sugg(
-                        cx,
-                        EXPLICIT_INTO_ITER_LOOP,
-                        arg.span,
-                        "it is more concise to loop over containers instead of using explicit \
-                         iteration methods",
-                        "to write this more concisely, try",
-                        object.to_string(),
-                        applicability,
-                    );
-                } else {
-                    let ref_receiver_ty = cx.tcx.mk_ref(
-                        cx.tcx.lifetimes.re_erased,
-                        ty::TypeAndMut {
-                            ty: receiver_ty,
-                            mutbl: Mutability::Not,
-                        },
-                    );
-                    if TyS::same_type(receiver_ty_adjusted, ref_receiver_ty) {
-                        lint_iter_method(cx, args, arg, method_name)
-                    }
-                }
-            } else if method_name == "next" && match_trait_method(cx, arg, &paths::ITERATOR) {
-                span_lint(
-                    cx,
-                    ITER_NEXT_LOOP,
-                    expr.span,
-                    "you are iterating over `Iterator::next()` which is an Option; this will compile but is \
-                    probably not what you want",
-                );
-                next_loop_linted = true;
-            }
-        }
-    }
-    if !next_loop_linted {
-        check_arg_type(cx, pat, arg);
-    }
-}
-
-/// Checks for `for` loops over `Option`s and `Result`s.
-fn check_arg_type(cx: &LateContext<'_>, pat: &Pat<'_>, arg: &Expr<'_>) {
-    let ty = cx.typeck_results().expr_ty(arg);
-    if is_type_diagnostic_item(cx, ty, sym::option_type) {
-        span_lint_and_help(
-            cx,
-            FOR_LOOPS_OVER_FALLIBLES,
-            arg.span,
-            &format!(
-                "for loop over `{0}`, which is an `Option`. This is more readably written as an \
-                `if let` statement",
-                snippet(cx, arg.span, "_")
-            ),
-            None,
-            &format!(
-                "consider replacing `for {0} in {1}` with `if let Some({0}) = {1}`",
-                snippet(cx, pat.span, "_"),
-                snippet(cx, arg.span, "_")
-            ),
-        );
-    } else if is_type_diagnostic_item(cx, ty, sym::result_type) {
-        span_lint_and_help(
-            cx,
-            FOR_LOOPS_OVER_FALLIBLES,
-            arg.span,
-            &format!(
-                "for loop over `{0}`, which is a `Result`. This is more readably written as an \
-                `if let` statement",
-                snippet(cx, arg.span, "_")
-            ),
-            None,
-            &format!(
-                "consider replacing `for {0} in {1}` with `if let Ok({0}) = {1}`",
-                snippet(cx, pat.span, "_"),
-                snippet(cx, arg.span, "_")
-            ),
-        );
-    }
-}
-
 // To trigger the EXPLICIT_COUNTER_LOOP lint, a variable must be
 // incremented exactly once in the loop body, and initialized to zero
 // at the start of the loop.
@@ -2270,34 +2159,6 @@ impl<'tcx> Visitor<'tcx> for VarUsedAfterLoopVisitor {
     }
 }
 
-/// Returns `true` if the type of expr is one that provides `IntoIterator` impls
-/// for `&T` and `&mut T`, such as `Vec`.
-#[rustfmt::skip]
-fn is_ref_iterable_type(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
-    // no walk_ptrs_ty: calling iter() on a reference can make sense because it
-    // will allow further borrows afterwards
-    let ty = cx.typeck_results().expr_ty(e);
-    is_iterable_array(ty, cx) ||
-    is_type_diagnostic_item(cx, ty, sym::vec_type) ||
-    match_type(cx, ty, &paths::LINKED_LIST) ||
-    is_type_diagnostic_item(cx, ty, sym!(hashmap_type)) ||
-    is_type_diagnostic_item(cx, ty, sym!(hashset_type)) ||
-    is_type_diagnostic_item(cx, ty, sym!(vecdeque_type)) ||
-    match_type(cx, ty, &paths::BINARY_HEAP) ||
-    match_type(cx, ty, &paths::BTREEMAP) ||
-    match_type(cx, ty, &paths::BTREESET)
-}
-
-fn is_iterable_array<'tcx>(ty: Ty<'tcx>, cx: &LateContext<'tcx>) -> bool {
-    // IntoIterator is currently only implemented for array sizes <= 32 in rustc
-    match ty.kind() {
-        ty::Array(_, n) => n
-            .try_eval_usize(cx.tcx, cx.param_env)
-            .map_or(false, |val| (0..=32).contains(&val)),
-        _ => false,
-    }
-}
-
 /// If a block begins with a statement (possibly a `let` binding) and has an
 /// expression, return it.
 fn extract_expr_from_first_stmt<'tcx>(block: &Block<'tcx>) -> Option<&'tcx Expr<'tcx>> {
-- 
cgit 1.4.1-3-g733a5


From 7b0f588b7706f4ec212e7772084eb7c0e90cfb56 Mon Sep 17 00:00:00 2001
From: nahuakang <kangnahua@gmail.com>
Date: Mon, 8 Feb 2021 21:04:33 +0100
Subject: Refactor check_for_loop_over_map_kv to its own module

---
 clippy_lints/src/loops/for_loop_over_map_kv.rs | 69 ++++++++++++++++++++++++++
 clippy_lints/src/loops/mod.rs                  | 67 +------------------------
 2 files changed, 71 insertions(+), 65 deletions(-)
 create mode 100644 clippy_lints/src/loops/for_loop_over_map_kv.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/for_loop_over_map_kv.rs b/clippy_lints/src/loops/for_loop_over_map_kv.rs
new file mode 100644
index 00000000000..c5f0b0909ba
--- /dev/null
+++ b/clippy_lints/src/loops/for_loop_over_map_kv.rs
@@ -0,0 +1,69 @@
+use crate::utils::visitors::LocalUsedVisitor;
+use crate::utils::{is_type_diagnostic_item, match_type, multispan_sugg, paths, snippet, span_lint_and_then, sugg};
+use rustc_hir::{BorrowKind, Expr, ExprKind, Mutability, Pat, PatKind};
+use rustc_lint::LateContext;
+use rustc_middle::ty;
+
+/// Checks for the `FOR_KV_MAP` lint.
+pub(super) fn check_for_loop_over_map_kv<'tcx>(
+    cx: &LateContext<'tcx>,
+    pat: &'tcx Pat<'_>,
+    arg: &'tcx Expr<'_>,
+    body: &'tcx Expr<'_>,
+    expr: &'tcx Expr<'_>,
+) {
+    let pat_span = pat.span;
+
+    if let PatKind::Tuple(ref pat, _) = pat.kind {
+        if pat.len() == 2 {
+            let arg_span = arg.span;
+            let (new_pat_span, kind, ty, mutbl) = match *cx.typeck_results().expr_ty(arg).kind() {
+                ty::Ref(_, ty, mutbl) => match (&pat[0].kind, &pat[1].kind) {
+                    (key, _) if pat_is_wild(key, body) => (pat[1].span, "value", ty, mutbl),
+                    (_, value) if pat_is_wild(value, body) => (pat[0].span, "key", ty, Mutability::Not),
+                    _ => return,
+                },
+                _ => return,
+            };
+            let mutbl = match mutbl {
+                Mutability::Not => "",
+                Mutability::Mut => "_mut",
+            };
+            let arg = match arg.kind {
+                ExprKind::AddrOf(BorrowKind::Ref, _, ref expr) => &**expr,
+                _ => arg,
+            };
+
+            if is_type_diagnostic_item(cx, ty, sym!(hashmap_type)) || match_type(cx, ty, &paths::BTREEMAP) {
+                span_lint_and_then(
+                    cx,
+                    super::FOR_KV_MAP,
+                    expr.span,
+                    &format!("you seem to want to iterate on a map's {}s", kind),
+                    |diag| {
+                        let map = sugg::Sugg::hir(cx, arg, "map");
+                        multispan_sugg(
+                            diag,
+                            "use the corresponding method",
+                            vec![
+                                (pat_span, snippet(cx, new_pat_span, kind).into_owned()),
+                                (arg_span, format!("{}.{}s{}()", map.maybe_par(), kind, mutbl)),
+                            ],
+                        );
+                    },
+                );
+            }
+        }
+    }
+}
+
+/// Returns `true` if the pattern is a `PatWild` or an ident prefixed with `_`.
+fn pat_is_wild<'tcx>(pat: &'tcx PatKind<'_>, body: &'tcx Expr<'_>) -> bool {
+    match *pat {
+        PatKind::Wild => true,
+        PatKind::Binding(_, id, ident, None) if ident.as_str().starts_with('_') => {
+            !LocalUsedVisitor::new(id).check_expr(body)
+        },
+        _ => false,
+    }
+}
diff --git a/clippy_lints/src/loops/mod.rs b/clippy_lints/src/loops/mod.rs
index 63eeb3607b6..672f0731859 100644
--- a/clippy_lints/src/loops/mod.rs
+++ b/clippy_lints/src/loops/mod.rs
@@ -1,4 +1,5 @@
 mod for_loop_arg;
+mod for_loop_over_map_kv;
 mod manual_flatten;
 mod utils;
 
@@ -863,7 +864,7 @@ fn check_for_loop<'tcx>(
         check_for_loop_explicit_counter(cx, pat, arg, body, expr);
     }
     for_loop_arg::check_for_loop_arg(cx, pat, arg, expr);
-    check_for_loop_over_map_kv(cx, pat, arg, body, expr);
+    for_loop_over_map_kv::check_for_loop_over_map_kv(cx, pat, arg, body, expr);
     check_for_mut_range_bound(cx, arg, body);
     check_for_single_element_loop(cx, pat, arg, body, expr);
     detect_same_item_push(cx, pat, arg, body, expr);
@@ -1732,59 +1733,6 @@ fn check_for_loop_explicit_counter<'tcx>(
     }
 }
 
-/// Checks for the `FOR_KV_MAP` lint.
-fn check_for_loop_over_map_kv<'tcx>(
-    cx: &LateContext<'tcx>,
-    pat: &'tcx Pat<'_>,
-    arg: &'tcx Expr<'_>,
-    body: &'tcx Expr<'_>,
-    expr: &'tcx Expr<'_>,
-) {
-    let pat_span = pat.span;
-
-    if let PatKind::Tuple(ref pat, _) = pat.kind {
-        if pat.len() == 2 {
-            let arg_span = arg.span;
-            let (new_pat_span, kind, ty, mutbl) = match *cx.typeck_results().expr_ty(arg).kind() {
-                ty::Ref(_, ty, mutbl) => match (&pat[0].kind, &pat[1].kind) {
-                    (key, _) if pat_is_wild(cx, key, body) => (pat[1].span, "value", ty, mutbl),
-                    (_, value) if pat_is_wild(cx, value, body) => (pat[0].span, "key", ty, Mutability::Not),
-                    _ => return,
-                },
-                _ => return,
-            };
-            let mutbl = match mutbl {
-                Mutability::Not => "",
-                Mutability::Mut => "_mut",
-            };
-            let arg = match arg.kind {
-                ExprKind::AddrOf(BorrowKind::Ref, _, ref expr) => &**expr,
-                _ => arg,
-            };
-
-            if is_type_diagnostic_item(cx, ty, sym!(hashmap_type)) || match_type(cx, ty, &paths::BTREEMAP) {
-                span_lint_and_then(
-                    cx,
-                    FOR_KV_MAP,
-                    expr.span,
-                    &format!("you seem to want to iterate on a map's {}s", kind),
-                    |diag| {
-                        let map = sugg::Sugg::hir(cx, arg, "map");
-                        multispan_sugg(
-                            diag,
-                            "use the corresponding method",
-                            vec![
-                                (pat_span, snippet(cx, new_pat_span, kind).into_owned()),
-                                (arg_span, format!("{}.{}s{}()", map.maybe_par(), kind, mutbl)),
-                            ],
-                        );
-                    },
-                );
-            }
-        }
-    }
-}
-
 fn check_for_single_element_loop<'tcx>(
     cx: &LateContext<'tcx>,
     pat: &'tcx Pat<'_>,
@@ -1927,17 +1875,6 @@ fn check_for_mutation<'tcx>(
     delegate.mutation_span()
 }
 
-/// Returns `true` if the pattern is a `PatWild` or an ident prefixed with `_`.
-fn pat_is_wild<'tcx>(cx: &LateContext<'tcx>, pat: &'tcx PatKind<'_>, body: &'tcx Expr<'_>) -> bool {
-    match *pat {
-        PatKind::Wild => true,
-        PatKind::Binding(_, id, ident, None) if ident.as_str().starts_with('_') => {
-            !LocalUsedVisitor::new(cx, id).check_expr(body)
-        },
-        _ => false,
-    }
-}
-
 struct VarVisitor<'a, 'tcx> {
     /// context reference
     cx: &'a LateContext<'tcx>,
-- 
cgit 1.4.1-3-g733a5


From 6e4663dedf92f871471cc240069d270b65a8160b Mon Sep 17 00:00:00 2001
From: nahuakang <kangnahua@gmail.com>
Date: Mon, 8 Feb 2021 21:20:23 +0100
Subject: Refactor check_for_mut_range_bound to its own module

---
 clippy_lints/src/loops/for_mut_range_bound.rs | 114 ++++++++++++++++++++++++++
 clippy_lints/src/loops/mod.rs                 | 111 +------------------------
 2 files changed, 116 insertions(+), 109 deletions(-)
 create mode 100644 clippy_lints/src/loops/for_mut_range_bound.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/for_mut_range_bound.rs b/clippy_lints/src/loops/for_mut_range_bound.rs
new file mode 100644
index 00000000000..d305c55cb95
--- /dev/null
+++ b/clippy_lints/src/loops/for_mut_range_bound.rs
@@ -0,0 +1,114 @@
+use crate::utils::{higher, path_to_local, span_lint};
+use if_chain::if_chain;
+use rustc_hir::{BindingAnnotation, Expr, HirId, Node, PatKind};
+use rustc_infer::infer::TyCtxtInferExt;
+use rustc_lint::LateContext;
+use rustc_middle::ty;
+use rustc_span::source_map::Span;
+use rustc_typeck::expr_use_visitor::{ConsumeMode, Delegate, ExprUseVisitor, PlaceBase, PlaceWithHirId};
+
+pub(super) fn check_for_mut_range_bound(cx: &LateContext<'_>, arg: &Expr<'_>, body: &Expr<'_>) {
+    if let Some(higher::Range {
+        start: Some(start),
+        end: Some(end),
+        ..
+    }) = higher::range(arg)
+    {
+        let mut_ids = vec![check_for_mutability(cx, start), check_for_mutability(cx, end)];
+        if mut_ids[0].is_some() || mut_ids[1].is_some() {
+            let (span_low, span_high) = check_for_mutation(cx, body, &mut_ids);
+            mut_warn_with_span(cx, span_low);
+            mut_warn_with_span(cx, span_high);
+        }
+    }
+}
+
+fn mut_warn_with_span(cx: &LateContext<'_>, span: Option<Span>) {
+    if let Some(sp) = span {
+        span_lint(
+            cx,
+            super::MUT_RANGE_BOUND,
+            sp,
+            "attempt to mutate range bound within loop; note that the range of the loop is unchanged",
+        );
+    }
+}
+
+fn check_for_mutability(cx: &LateContext<'_>, bound: &Expr<'_>) -> Option<HirId> {
+    if_chain! {
+        if let Some(hir_id) = path_to_local(bound);
+        if let Node::Binding(pat) = cx.tcx.hir().get(hir_id);
+        if let PatKind::Binding(BindingAnnotation::Mutable, ..) = pat.kind;
+        then {
+            return Some(hir_id);
+        }
+    }
+    None
+}
+
+fn check_for_mutation<'tcx>(
+    cx: &LateContext<'tcx>,
+    body: &Expr<'_>,
+    bound_ids: &[Option<HirId>],
+) -> (Option<Span>, Option<Span>) {
+    let mut delegate = MutatePairDelegate {
+        cx,
+        hir_id_low: bound_ids[0],
+        hir_id_high: bound_ids[1],
+        span_low: None,
+        span_high: None,
+    };
+    cx.tcx.infer_ctxt().enter(|infcx| {
+        ExprUseVisitor::new(
+            &mut delegate,
+            &infcx,
+            body.hir_id.owner,
+            cx.param_env,
+            cx.typeck_results(),
+        )
+        .walk_expr(body);
+    });
+    delegate.mutation_span()
+}
+
+struct MutatePairDelegate<'a, 'tcx> {
+    cx: &'a LateContext<'tcx>,
+    hir_id_low: Option<HirId>,
+    hir_id_high: Option<HirId>,
+    span_low: Option<Span>,
+    span_high: Option<Span>,
+}
+
+impl<'tcx> Delegate<'tcx> for MutatePairDelegate<'_, 'tcx> {
+    fn consume(&mut self, _: &PlaceWithHirId<'tcx>, _: HirId, _: ConsumeMode) {}
+
+    fn borrow(&mut self, cmt: &PlaceWithHirId<'tcx>, diag_expr_id: HirId, bk: ty::BorrowKind) {
+        if let ty::BorrowKind::MutBorrow = bk {
+            if let PlaceBase::Local(id) = cmt.place.base {
+                if Some(id) == self.hir_id_low {
+                    self.span_low = Some(self.cx.tcx.hir().span(diag_expr_id))
+                }
+                if Some(id) == self.hir_id_high {
+                    self.span_high = Some(self.cx.tcx.hir().span(diag_expr_id))
+                }
+            }
+        }
+    }
+
+    fn mutate(&mut self, cmt: &PlaceWithHirId<'tcx>, diag_expr_id: HirId) {
+        if let PlaceBase::Local(id) = cmt.place.base {
+            if Some(id) == self.hir_id_low {
+                self.span_low = Some(self.cx.tcx.hir().span(diag_expr_id))
+            }
+            if Some(id) == self.hir_id_high {
+                self.span_high = Some(self.cx.tcx.hir().span(diag_expr_id))
+            }
+        }
+    }
+}
+
+impl MutatePairDelegate<'_, '_> {
+    fn mutation_span(&self) -> (Option<Span>, Option<Span>) {
+        (self.span_low, self.span_high)
+    }
+}
diff --git a/clippy_lints/src/loops/mod.rs b/clippy_lints/src/loops/mod.rs
index 672f0731859..20f0090ebb4 100644
--- a/clippy_lints/src/loops/mod.rs
+++ b/clippy_lints/src/loops/mod.rs
@@ -1,5 +1,6 @@
 mod for_loop_arg;
 mod for_loop_over_map_kv;
+mod for_mut_range_bound;
 mod manual_flatten;
 mod utils;
 
@@ -24,7 +25,6 @@ use rustc_hir::{
     def_id, BinOpKind, BindingAnnotation, Block, BorrowKind, Expr, ExprKind, GenericArg, HirId, InlineAsmOperand,
     Local, LoopSource, MatchSource, Mutability, Node, Pat, PatKind, QPath, Stmt, StmtKind,
 };
-use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::hir::map::Map;
 use rustc_middle::lint::in_external_macro;
@@ -33,7 +33,6 @@ use rustc_middle::ty::{self, Ty};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
 use rustc_span::symbol::{sym, Ident, Symbol};
-use rustc_typeck::expr_use_visitor::{ConsumeMode, Delegate, ExprUseVisitor, PlaceBase, PlaceWithHirId};
 use std::iter::{once, Iterator};
 use std::mem;
 use utils::make_iterator_snippet;
@@ -865,7 +864,7 @@ fn check_for_loop<'tcx>(
     }
     for_loop_arg::check_for_loop_arg(cx, pat, arg, expr);
     for_loop_over_map_kv::check_for_loop_over_map_kv(cx, pat, arg, body, expr);
-    check_for_mut_range_bound(cx, arg, body);
+    for_mut_range_bound::check_for_mut_range_bound(cx, arg, body);
     check_for_single_element_loop(cx, pat, arg, body, expr);
     detect_same_item_push(cx, pat, arg, body, expr);
     manual_flatten::check_manual_flatten(cx, pat, arg, body, span);
@@ -1769,112 +1768,6 @@ fn check_for_single_element_loop<'tcx>(
     }
 }
 
-struct MutatePairDelegate<'a, 'tcx> {
-    cx: &'a LateContext<'tcx>,
-    hir_id_low: Option<HirId>,
-    hir_id_high: Option<HirId>,
-    span_low: Option<Span>,
-    span_high: Option<Span>,
-}
-
-impl<'tcx> Delegate<'tcx> for MutatePairDelegate<'_, 'tcx> {
-    fn consume(&mut self, _: &PlaceWithHirId<'tcx>, _: HirId, _: ConsumeMode) {}
-
-    fn borrow(&mut self, cmt: &PlaceWithHirId<'tcx>, diag_expr_id: HirId, bk: ty::BorrowKind) {
-        if let ty::BorrowKind::MutBorrow = bk {
-            if let PlaceBase::Local(id) = cmt.place.base {
-                if Some(id) == self.hir_id_low {
-                    self.span_low = Some(self.cx.tcx.hir().span(diag_expr_id))
-                }
-                if Some(id) == self.hir_id_high {
-                    self.span_high = Some(self.cx.tcx.hir().span(diag_expr_id))
-                }
-            }
-        }
-    }
-
-    fn mutate(&mut self, cmt: &PlaceWithHirId<'tcx>, diag_expr_id: HirId) {
-        if let PlaceBase::Local(id) = cmt.place.base {
-            if Some(id) == self.hir_id_low {
-                self.span_low = Some(self.cx.tcx.hir().span(diag_expr_id))
-            }
-            if Some(id) == self.hir_id_high {
-                self.span_high = Some(self.cx.tcx.hir().span(diag_expr_id))
-            }
-        }
-    }
-}
-
-impl MutatePairDelegate<'_, '_> {
-    fn mutation_span(&self) -> (Option<Span>, Option<Span>) {
-        (self.span_low, self.span_high)
-    }
-}
-
-fn check_for_mut_range_bound(cx: &LateContext<'_>, arg: &Expr<'_>, body: &Expr<'_>) {
-    if let Some(higher::Range {
-        start: Some(start),
-        end: Some(end),
-        ..
-    }) = higher::range(arg)
-    {
-        let mut_ids = vec![check_for_mutability(cx, start), check_for_mutability(cx, end)];
-        if mut_ids[0].is_some() || mut_ids[1].is_some() {
-            let (span_low, span_high) = check_for_mutation(cx, body, &mut_ids);
-            mut_warn_with_span(cx, span_low);
-            mut_warn_with_span(cx, span_high);
-        }
-    }
-}
-
-fn mut_warn_with_span(cx: &LateContext<'_>, span: Option<Span>) {
-    if let Some(sp) = span {
-        span_lint(
-            cx,
-            MUT_RANGE_BOUND,
-            sp,
-            "attempt to mutate range bound within loop; note that the range of the loop is unchanged",
-        );
-    }
-}
-
-fn check_for_mutability(cx: &LateContext<'_>, bound: &Expr<'_>) -> Option<HirId> {
-    if_chain! {
-        if let Some(hir_id) = path_to_local(bound);
-        if let Node::Binding(pat) = cx.tcx.hir().get(hir_id);
-        if let PatKind::Binding(BindingAnnotation::Mutable, ..) = pat.kind;
-        then {
-            return Some(hir_id);
-        }
-    }
-    None
-}
-
-fn check_for_mutation<'tcx>(
-    cx: &LateContext<'tcx>,
-    body: &Expr<'_>,
-    bound_ids: &[Option<HirId>],
-) -> (Option<Span>, Option<Span>) {
-    let mut delegate = MutatePairDelegate {
-        cx,
-        hir_id_low: bound_ids[0],
-        hir_id_high: bound_ids[1],
-        span_low: None,
-        span_high: None,
-    };
-    cx.tcx.infer_ctxt().enter(|infcx| {
-        ExprUseVisitor::new(
-            &mut delegate,
-            &infcx,
-            body.hir_id.owner,
-            cx.param_env,
-            cx.typeck_results(),
-        )
-        .walk_expr(body);
-    });
-    delegate.mutation_span()
-}
-
 struct VarVisitor<'a, 'tcx> {
     /// context reference
     cx: &'a LateContext<'tcx>,
-- 
cgit 1.4.1-3-g733a5


From 71c9fdf8b136cf9f879d5ca99615043ef6d09e68 Mon Sep 17 00:00:00 2001
From: nahuakang <kangnahua@gmail.com>
Date: Mon, 8 Feb 2021 21:38:00 +0100
Subject: Refactor check_for_loop_range into its module

---
 clippy_lints/src/loops/for_loop_range.rs | 390 +++++++++++++++++++++++++++++++
 clippy_lints/src/loops/mod.rs            | 387 +-----------------------------
 2 files changed, 396 insertions(+), 381 deletions(-)
 create mode 100644 clippy_lints/src/loops/for_loop_range.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/for_loop_range.rs b/clippy_lints/src/loops/for_loop_range.rs
new file mode 100644
index 00000000000..43560abb7f2
--- /dev/null
+++ b/clippy_lints/src/loops/for_loop_range.rs
@@ -0,0 +1,390 @@
+use crate::utils::visitors::LocalUsedVisitor;
+use crate::utils::{
+    contains_name, has_iter_method, higher, is_integer_const, match_trait_method, multispan_sugg, path_to_local_id,
+    paths, snippet, span_lint_and_then, sugg, SpanlessEq,
+};
+use if_chain::if_chain;
+use rustc_ast::ast;
+use rustc_data_structures::fx::{FxHashMap, FxHashSet};
+use rustc_hir::def::{DefKind, Res};
+use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
+use rustc_hir::{BinOpKind, BorrowKind, Expr, ExprKind, HirId, Mutability, Pat, PatKind, QPath};
+use rustc_lint::LateContext;
+use rustc_middle::hir::map::Map;
+use rustc_middle::middle::region;
+use rustc_middle::ty::{self, Ty};
+use rustc_span::symbol::{sym, Symbol};
+use std::iter::Iterator;
+use std::mem;
+
+/// Checks for looping over a range and then indexing a sequence with it.
+/// The iteratee must be a range literal.
+#[allow(clippy::too_many_lines)]
+pub(super) fn check_for_loop_range<'tcx>(
+    cx: &LateContext<'tcx>,
+    pat: &'tcx Pat<'_>,
+    arg: &'tcx Expr<'_>,
+    body: &'tcx Expr<'_>,
+    expr: &'tcx Expr<'_>,
+) {
+    if let Some(higher::Range {
+        start: Some(start),
+        ref end,
+        limits,
+    }) = higher::range(arg)
+    {
+        // the var must be a single name
+        if let PatKind::Binding(_, canonical_id, ident, _) = pat.kind {
+            let mut visitor = VarVisitor {
+                cx,
+                var: canonical_id,
+                indexed_mut: FxHashSet::default(),
+                indexed_indirectly: FxHashMap::default(),
+                indexed_directly: FxHashMap::default(),
+                referenced: FxHashSet::default(),
+                nonindex: false,
+                prefer_mutable: false,
+            };
+            walk_expr(&mut visitor, body);
+
+            // linting condition: we only indexed one variable, and indexed it directly
+            if visitor.indexed_indirectly.is_empty() && visitor.indexed_directly.len() == 1 {
+                let (indexed, (indexed_extent, indexed_ty)) = visitor
+                    .indexed_directly
+                    .into_iter()
+                    .next()
+                    .expect("already checked that we have exactly 1 element");
+
+                // ensure that the indexed variable was declared before the loop, see #601
+                if let Some(indexed_extent) = indexed_extent {
+                    let parent_id = cx.tcx.hir().get_parent_item(expr.hir_id);
+                    let parent_def_id = cx.tcx.hir().local_def_id(parent_id);
+                    let region_scope_tree = cx.tcx.region_scope_tree(parent_def_id);
+                    let pat_extent = region_scope_tree.var_scope(pat.hir_id.local_id);
+                    if region_scope_tree.is_subscope_of(indexed_extent, pat_extent) {
+                        return;
+                    }
+                }
+
+                // don't lint if the container that is indexed does not have .iter() method
+                let has_iter = has_iter_method(cx, indexed_ty);
+                if has_iter.is_none() {
+                    return;
+                }
+
+                // don't lint if the container that is indexed into is also used without
+                // indexing
+                if visitor.referenced.contains(&indexed) {
+                    return;
+                }
+
+                let starts_at_zero = is_integer_const(cx, start, 0);
+
+                let skip = if starts_at_zero {
+                    String::new()
+                } else if visitor.indexed_mut.contains(&indexed) && contains_name(indexed, start) {
+                    return;
+                } else {
+                    format!(".skip({})", snippet(cx, start.span, ".."))
+                };
+
+                let mut end_is_start_plus_val = false;
+
+                let take = if let Some(end) = *end {
+                    let mut take_expr = end;
+
+                    if let ExprKind::Binary(ref op, ref left, ref right) = end.kind {
+                        if let BinOpKind::Add = op.node {
+                            let start_equal_left = SpanlessEq::new(cx).eq_expr(start, left);
+                            let start_equal_right = SpanlessEq::new(cx).eq_expr(start, right);
+
+                            if start_equal_left {
+                                take_expr = right;
+                            } else if start_equal_right {
+                                take_expr = left;
+                            }
+
+                            end_is_start_plus_val = start_equal_left | start_equal_right;
+                        }
+                    }
+
+                    if is_len_call(end, indexed) || is_end_eq_array_len(cx, end, limits, indexed_ty) {
+                        String::new()
+                    } else if visitor.indexed_mut.contains(&indexed) && contains_name(indexed, take_expr) {
+                        return;
+                    } else {
+                        match limits {
+                            ast::RangeLimits::Closed => {
+                                let take_expr = sugg::Sugg::hir(cx, take_expr, "<count>");
+                                format!(".take({})", take_expr + sugg::ONE)
+                            },
+                            ast::RangeLimits::HalfOpen => format!(".take({})", snippet(cx, take_expr.span, "..")),
+                        }
+                    }
+                } else {
+                    String::new()
+                };
+
+                let (ref_mut, method) = if visitor.indexed_mut.contains(&indexed) {
+                    ("mut ", "iter_mut")
+                } else {
+                    ("", "iter")
+                };
+
+                let take_is_empty = take.is_empty();
+                let mut method_1 = take;
+                let mut method_2 = skip;
+
+                if end_is_start_plus_val {
+                    mem::swap(&mut method_1, &mut method_2);
+                }
+
+                if visitor.nonindex {
+                    span_lint_and_then(
+                        cx,
+                        super::NEEDLESS_RANGE_LOOP,
+                        expr.span,
+                        &format!("the loop variable `{}` is used to index `{}`", ident.name, indexed),
+                        |diag| {
+                            multispan_sugg(
+                                diag,
+                                "consider using an iterator",
+                                vec![
+                                    (pat.span, format!("({}, <item>)", ident.name)),
+                                    (
+                                        arg.span,
+                                        format!("{}.{}().enumerate(){}{}", indexed, method, method_1, method_2),
+                                    ),
+                                ],
+                            );
+                        },
+                    );
+                } else {
+                    let repl = if starts_at_zero && take_is_empty {
+                        format!("&{}{}", ref_mut, indexed)
+                    } else {
+                        format!("{}.{}(){}{}", indexed, method, method_1, method_2)
+                    };
+
+                    span_lint_and_then(
+                        cx,
+                        super::NEEDLESS_RANGE_LOOP,
+                        expr.span,
+                        &format!("the loop variable `{}` is only used to index `{}`", ident.name, indexed),
+                        |diag| {
+                            multispan_sugg(
+                                diag,
+                                "consider using an iterator",
+                                vec![(pat.span, "<item>".to_string()), (arg.span, repl)],
+                            );
+                        },
+                    );
+                }
+            }
+        }
+    }
+}
+
+fn is_len_call(expr: &Expr<'_>, var: Symbol) -> bool {
+    if_chain! {
+        if let ExprKind::MethodCall(ref method, _, ref len_args, _) = expr.kind;
+        if len_args.len() == 1;
+        if method.ident.name == sym!(len);
+        if let ExprKind::Path(QPath::Resolved(_, ref path)) = len_args[0].kind;
+        if path.segments.len() == 1;
+        if path.segments[0].ident.name == var;
+        then {
+            return true;
+        }
+    }
+
+    false
+}
+
+fn is_end_eq_array_len<'tcx>(
+    cx: &LateContext<'tcx>,
+    end: &Expr<'_>,
+    limits: ast::RangeLimits,
+    indexed_ty: Ty<'tcx>,
+) -> bool {
+    if_chain! {
+        if let ExprKind::Lit(ref lit) = end.kind;
+        if let ast::LitKind::Int(end_int, _) = lit.node;
+        if let ty::Array(_, arr_len_const) = indexed_ty.kind();
+        if let Some(arr_len) = arr_len_const.try_eval_usize(cx.tcx, cx.param_env);
+        then {
+            return match limits {
+                ast::RangeLimits::Closed => end_int + 1 >= arr_len.into(),
+                ast::RangeLimits::HalfOpen => end_int >= arr_len.into(),
+            };
+        }
+    }
+
+    false
+}
+
+struct VarVisitor<'a, 'tcx> {
+    /// context reference
+    cx: &'a LateContext<'tcx>,
+    /// var name to look for as index
+    var: HirId,
+    /// indexed variables that are used mutably
+    indexed_mut: FxHashSet<Symbol>,
+    /// indirectly indexed variables (`v[(i + 4) % N]`), the extend is `None` for global
+    indexed_indirectly: FxHashMap<Symbol, Option<region::Scope>>,
+    /// subset of `indexed` of vars that are indexed directly: `v[i]`
+    /// this will not contain cases like `v[calc_index(i)]` or `v[(i + 4) % N]`
+    indexed_directly: FxHashMap<Symbol, (Option<region::Scope>, Ty<'tcx>)>,
+    /// Any names that are used outside an index operation.
+    /// Used to detect things like `&mut vec` used together with `vec[i]`
+    referenced: FxHashSet<Symbol>,
+    /// has the loop variable been used in expressions other than the index of
+    /// an index op?
+    nonindex: bool,
+    /// Whether we are inside the `$` in `&mut $` or `$ = foo` or `$.bar`, where bar
+    /// takes `&mut self`
+    prefer_mutable: bool,
+}
+
+impl<'a, 'tcx> VarVisitor<'a, 'tcx> {
+    fn check(&mut self, idx: &'tcx Expr<'_>, seqexpr: &'tcx Expr<'_>, expr: &'tcx Expr<'_>) -> bool {
+        if_chain! {
+            // the indexed container is referenced by a name
+            if let ExprKind::Path(ref seqpath) = seqexpr.kind;
+            if let QPath::Resolved(None, ref seqvar) = *seqpath;
+            if seqvar.segments.len() == 1;
+            then {
+                let index_used_directly = path_to_local_id(idx, self.var);
+                let indexed_indirectly = {
+                    let mut used_visitor = LocalUsedVisitor::new(self.var);
+                    walk_expr(&mut used_visitor, idx);
+                    used_visitor.used
+                };
+
+                if indexed_indirectly || index_used_directly {
+                    if self.prefer_mutable {
+                        self.indexed_mut.insert(seqvar.segments[0].ident.name);
+                    }
+                    let res = self.cx.qpath_res(seqpath, seqexpr.hir_id);
+                    match res {
+                        Res::Local(hir_id) => {
+                            let parent_id = self.cx.tcx.hir().get_parent_item(expr.hir_id);
+                            let parent_def_id = self.cx.tcx.hir().local_def_id(parent_id);
+                            let extent = self.cx.tcx.region_scope_tree(parent_def_id).var_scope(hir_id.local_id);
+                            if indexed_indirectly {
+                                self.indexed_indirectly.insert(seqvar.segments[0].ident.name, Some(extent));
+                            }
+                            if index_used_directly {
+                                self.indexed_directly.insert(
+                                    seqvar.segments[0].ident.name,
+                                    (Some(extent), self.cx.typeck_results().node_type(seqexpr.hir_id)),
+                                );
+                            }
+                            return false;  // no need to walk further *on the variable*
+                        }
+                        Res::Def(DefKind::Static | DefKind::Const, ..) => {
+                            if indexed_indirectly {
+                                self.indexed_indirectly.insert(seqvar.segments[0].ident.name, None);
+                            }
+                            if index_used_directly {
+                                self.indexed_directly.insert(
+                                    seqvar.segments[0].ident.name,
+                                    (None, self.cx.typeck_results().node_type(seqexpr.hir_id)),
+                                );
+                            }
+                            return false;  // no need to walk further *on the variable*
+                        }
+                        _ => (),
+                    }
+                }
+            }
+        }
+        true
+    }
+}
+
+impl<'a, 'tcx> Visitor<'tcx> for VarVisitor<'a, 'tcx> {
+    type Map = Map<'tcx>;
+
+    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
+        if_chain! {
+            // a range index op
+            if let ExprKind::MethodCall(ref meth, _, ref args, _) = expr.kind;
+            if (meth.ident.name == sym::index && match_trait_method(self.cx, expr, &paths::INDEX))
+                || (meth.ident.name == sym::index_mut && match_trait_method(self.cx, expr, &paths::INDEX_MUT));
+            if !self.check(&args[1], &args[0], expr);
+            then { return }
+        }
+
+        if_chain! {
+            // an index op
+            if let ExprKind::Index(ref seqexpr, ref idx) = expr.kind;
+            if !self.check(idx, seqexpr, expr);
+            then { return }
+        }
+
+        if_chain! {
+            // directly using a variable
+            if let ExprKind::Path(QPath::Resolved(None, path)) = expr.kind;
+            if let Res::Local(local_id) = path.res;
+            then {
+                if local_id == self.var {
+                    self.nonindex = true;
+                } else {
+                    // not the correct variable, but still a variable
+                    self.referenced.insert(path.segments[0].ident.name);
+                }
+            }
+        }
+
+        let old = self.prefer_mutable;
+        match expr.kind {
+            ExprKind::AssignOp(_, ref lhs, ref rhs) | ExprKind::Assign(ref lhs, ref rhs, _) => {
+                self.prefer_mutable = true;
+                self.visit_expr(lhs);
+                self.prefer_mutable = false;
+                self.visit_expr(rhs);
+            },
+            ExprKind::AddrOf(BorrowKind::Ref, mutbl, ref expr) => {
+                if mutbl == Mutability::Mut {
+                    self.prefer_mutable = true;
+                }
+                self.visit_expr(expr);
+            },
+            ExprKind::Call(ref f, args) => {
+                self.visit_expr(f);
+                for expr in args {
+                    let ty = self.cx.typeck_results().expr_ty_adjusted(expr);
+                    self.prefer_mutable = false;
+                    if let ty::Ref(_, _, mutbl) = *ty.kind() {
+                        if mutbl == Mutability::Mut {
+                            self.prefer_mutable = true;
+                        }
+                    }
+                    self.visit_expr(expr);
+                }
+            },
+            ExprKind::MethodCall(_, _, args, _) => {
+                let def_id = self.cx.typeck_results().type_dependent_def_id(expr.hir_id).unwrap();
+                for (ty, expr) in self.cx.tcx.fn_sig(def_id).inputs().skip_binder().iter().zip(args) {
+                    self.prefer_mutable = false;
+                    if let ty::Ref(_, _, mutbl) = *ty.kind() {
+                        if mutbl == Mutability::Mut {
+                            self.prefer_mutable = true;
+                        }
+                    }
+                    self.visit_expr(expr);
+                }
+            },
+            ExprKind::Closure(_, _, body_id, ..) => {
+                let body = self.cx.tcx.hir().body(body_id);
+                self.visit_expr(&body.value);
+            },
+            _ => walk_expr(self, expr),
+        }
+        self.prefer_mutable = old;
+    }
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::None
+    }
+}
diff --git a/clippy_lints/src/loops/mod.rs b/clippy_lints/src/loops/mod.rs
index 20f0090ebb4..204f9f9b255 100644
--- a/clippy_lints/src/loops/mod.rs
+++ b/clippy_lints/src/loops/mod.rs
@@ -1,5 +1,6 @@
 mod for_loop_arg;
 mod for_loop_over_map_kv;
+mod for_loop_range;
 mod for_mut_range_bound;
 mod manual_flatten;
 mod utils;
@@ -7,13 +8,11 @@ mod utils;
 use crate::consts::constant;
 use crate::utils::sugg::Sugg;
 use crate::utils::usage::mutated_variables;
-use crate::utils::visitors::LocalUsedVisitor;
 use crate::utils::{
-    contains_name, get_enclosing_block, get_parent_expr, get_trait_def_id, has_iter_method, higher, implements_trait,
-    indent_of, is_in_panic_handler, is_integer_const, is_no_std_crate, is_refutable, is_type_diagnostic_item,
-    last_path_segment, match_trait_method, match_type, multispan_sugg, path_to_local, path_to_local_id, paths,
-    single_segment_path, snippet, snippet_with_applicability, snippet_with_macro_callsite, span_lint,
-    span_lint_and_help, span_lint_and_sugg, span_lint_and_then, sugg, SpanlessEq,
+    get_enclosing_block, get_parent_expr, get_trait_def_id, higher, implements_trait, indent_of, is_in_panic_handler,
+    is_integer_const, is_no_std_crate, is_refutable, is_type_diagnostic_item, last_path_segment, match_trait_method,
+    match_type, path_to_local, path_to_local_id, paths, single_segment_path, snippet, snippet_with_applicability,
+    snippet_with_macro_callsite, span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then, sugg,
 };
 use if_chain::if_chain;
 use rustc_ast::ast;
@@ -28,13 +27,11 @@ use rustc_hir::{
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::hir::map::Map;
 use rustc_middle::lint::in_external_macro;
-use rustc_middle::middle::region;
 use rustc_middle::ty::{self, Ty};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
 use rustc_span::symbol::{sym, Ident, Symbol};
 use std::iter::{once, Iterator};
-use std::mem;
 use utils::make_iterator_snippet;
 
 declare_clippy_lint! {
@@ -859,7 +856,7 @@ fn check_for_loop<'tcx>(
 ) {
     let is_manual_memcpy_triggered = detect_manual_memcpy(cx, pat, arg, body, expr);
     if !is_manual_memcpy_triggered {
-        check_for_loop_range(cx, pat, arg, body, expr);
+        for_loop_range::check_for_loop_range(cx, pat, arg, body, expr);
         check_for_loop_explicit_counter(cx, pat, arg, body, expr);
     }
     for_loop_arg::check_for_loop_arg(cx, pat, arg, expr);
@@ -1477,212 +1474,6 @@ fn detect_same_item_push<'tcx>(
     }
 }
 
-/// Checks for looping over a range and then indexing a sequence with it.
-/// The iteratee must be a range literal.
-#[allow(clippy::too_many_lines)]
-fn check_for_loop_range<'tcx>(
-    cx: &LateContext<'tcx>,
-    pat: &'tcx Pat<'_>,
-    arg: &'tcx Expr<'_>,
-    body: &'tcx Expr<'_>,
-    expr: &'tcx Expr<'_>,
-) {
-    if let Some(higher::Range {
-        start: Some(start),
-        ref end,
-        limits,
-    }) = higher::range(arg)
-    {
-        // the var must be a single name
-        if let PatKind::Binding(_, canonical_id, ident, _) = pat.kind {
-            let mut visitor = VarVisitor {
-                cx,
-                var: canonical_id,
-                indexed_mut: FxHashSet::default(),
-                indexed_indirectly: FxHashMap::default(),
-                indexed_directly: FxHashMap::default(),
-                referenced: FxHashSet::default(),
-                nonindex: false,
-                prefer_mutable: false,
-            };
-            walk_expr(&mut visitor, body);
-
-            // linting condition: we only indexed one variable, and indexed it directly
-            if visitor.indexed_indirectly.is_empty() && visitor.indexed_directly.len() == 1 {
-                let (indexed, (indexed_extent, indexed_ty)) = visitor
-                    .indexed_directly
-                    .into_iter()
-                    .next()
-                    .expect("already checked that we have exactly 1 element");
-
-                // ensure that the indexed variable was declared before the loop, see #601
-                if let Some(indexed_extent) = indexed_extent {
-                    let parent_id = cx.tcx.hir().get_parent_item(expr.hir_id);
-                    let parent_def_id = cx.tcx.hir().local_def_id(parent_id);
-                    let region_scope_tree = cx.tcx.region_scope_tree(parent_def_id);
-                    let pat_extent = region_scope_tree.var_scope(pat.hir_id.local_id);
-                    if region_scope_tree.is_subscope_of(indexed_extent, pat_extent) {
-                        return;
-                    }
-                }
-
-                // don't lint if the container that is indexed does not have .iter() method
-                let has_iter = has_iter_method(cx, indexed_ty);
-                if has_iter.is_none() {
-                    return;
-                }
-
-                // don't lint if the container that is indexed into is also used without
-                // indexing
-                if visitor.referenced.contains(&indexed) {
-                    return;
-                }
-
-                let starts_at_zero = is_integer_const(cx, start, 0);
-
-                let skip = if starts_at_zero {
-                    String::new()
-                } else if visitor.indexed_mut.contains(&indexed) && contains_name(indexed, start) {
-                    return;
-                } else {
-                    format!(".skip({})", snippet(cx, start.span, ".."))
-                };
-
-                let mut end_is_start_plus_val = false;
-
-                let take = if let Some(end) = *end {
-                    let mut take_expr = end;
-
-                    if let ExprKind::Binary(ref op, ref left, ref right) = end.kind {
-                        if let BinOpKind::Add = op.node {
-                            let start_equal_left = SpanlessEq::new(cx).eq_expr(start, left);
-                            let start_equal_right = SpanlessEq::new(cx).eq_expr(start, right);
-
-                            if start_equal_left {
-                                take_expr = right;
-                            } else if start_equal_right {
-                                take_expr = left;
-                            }
-
-                            end_is_start_plus_val = start_equal_left | start_equal_right;
-                        }
-                    }
-
-                    if is_len_call(end, indexed) || is_end_eq_array_len(cx, end, limits, indexed_ty) {
-                        String::new()
-                    } else if visitor.indexed_mut.contains(&indexed) && contains_name(indexed, take_expr) {
-                        return;
-                    } else {
-                        match limits {
-                            ast::RangeLimits::Closed => {
-                                let take_expr = sugg::Sugg::hir(cx, take_expr, "<count>");
-                                format!(".take({})", take_expr + sugg::ONE)
-                            },
-                            ast::RangeLimits::HalfOpen => format!(".take({})", snippet(cx, take_expr.span, "..")),
-                        }
-                    }
-                } else {
-                    String::new()
-                };
-
-                let (ref_mut, method) = if visitor.indexed_mut.contains(&indexed) {
-                    ("mut ", "iter_mut")
-                } else {
-                    ("", "iter")
-                };
-
-                let take_is_empty = take.is_empty();
-                let mut method_1 = take;
-                let mut method_2 = skip;
-
-                if end_is_start_plus_val {
-                    mem::swap(&mut method_1, &mut method_2);
-                }
-
-                if visitor.nonindex {
-                    span_lint_and_then(
-                        cx,
-                        NEEDLESS_RANGE_LOOP,
-                        expr.span,
-                        &format!("the loop variable `{}` is used to index `{}`", ident.name, indexed),
-                        |diag| {
-                            multispan_sugg(
-                                diag,
-                                "consider using an iterator",
-                                vec![
-                                    (pat.span, format!("({}, <item>)", ident.name)),
-                                    (
-                                        arg.span,
-                                        format!("{}.{}().enumerate(){}{}", indexed, method, method_1, method_2),
-                                    ),
-                                ],
-                            );
-                        },
-                    );
-                } else {
-                    let repl = if starts_at_zero && take_is_empty {
-                        format!("&{}{}", ref_mut, indexed)
-                    } else {
-                        format!("{}.{}(){}{}", indexed, method, method_1, method_2)
-                    };
-
-                    span_lint_and_then(
-                        cx,
-                        NEEDLESS_RANGE_LOOP,
-                        expr.span,
-                        &format!("the loop variable `{}` is only used to index `{}`", ident.name, indexed),
-                        |diag| {
-                            multispan_sugg(
-                                diag,
-                                "consider using an iterator",
-                                vec![(pat.span, "<item>".to_string()), (arg.span, repl)],
-                            );
-                        },
-                    );
-                }
-            }
-        }
-    }
-}
-
-fn is_len_call(expr: &Expr<'_>, var: Symbol) -> bool {
-    if_chain! {
-        if let ExprKind::MethodCall(ref method, _, ref len_args, _) = expr.kind;
-        if len_args.len() == 1;
-        if method.ident.name == sym!(len);
-        if let ExprKind::Path(QPath::Resolved(_, ref path)) = len_args[0].kind;
-        if path.segments.len() == 1;
-        if path.segments[0].ident.name == var;
-        then {
-            return true;
-        }
-    }
-
-    false
-}
-
-fn is_end_eq_array_len<'tcx>(
-    cx: &LateContext<'tcx>,
-    end: &Expr<'_>,
-    limits: ast::RangeLimits,
-    indexed_ty: Ty<'tcx>,
-) -> bool {
-    if_chain! {
-        if let ExprKind::Lit(ref lit) = end.kind;
-        if let ast::LitKind::Int(end_int, _) = lit.node;
-        if let ty::Array(_, arr_len_const) = indexed_ty.kind();
-        if let Some(arr_len) = arr_len_const.try_eval_usize(cx.tcx, cx.param_env);
-        then {
-            return match limits {
-                ast::RangeLimits::Closed => end_int + 1 >= arr_len.into(),
-                ast::RangeLimits::HalfOpen => end_int >= arr_len.into(),
-            };
-        }
-    }
-
-    false
-}
-
 // To trigger the EXPLICIT_COUNTER_LOOP lint, a variable must be
 // incremented exactly once in the loop body, and initialized to zero
 // at the start of the loop.
@@ -1768,172 +1559,6 @@ fn check_for_single_element_loop<'tcx>(
     }
 }
 
-struct VarVisitor<'a, 'tcx> {
-    /// context reference
-    cx: &'a LateContext<'tcx>,
-    /// var name to look for as index
-    var: HirId,
-    /// indexed variables that are used mutably
-    indexed_mut: FxHashSet<Symbol>,
-    /// indirectly indexed variables (`v[(i + 4) % N]`), the extend is `None` for global
-    indexed_indirectly: FxHashMap<Symbol, Option<region::Scope>>,
-    /// subset of `indexed` of vars that are indexed directly: `v[i]`
-    /// this will not contain cases like `v[calc_index(i)]` or `v[(i + 4) % N]`
-    indexed_directly: FxHashMap<Symbol, (Option<region::Scope>, Ty<'tcx>)>,
-    /// Any names that are used outside an index operation.
-    /// Used to detect things like `&mut vec` used together with `vec[i]`
-    referenced: FxHashSet<Symbol>,
-    /// has the loop variable been used in expressions other than the index of
-    /// an index op?
-    nonindex: bool,
-    /// Whether we are inside the `$` in `&mut $` or `$ = foo` or `$.bar`, where bar
-    /// takes `&mut self`
-    prefer_mutable: bool,
-}
-
-impl<'a, 'tcx> VarVisitor<'a, 'tcx> {
-    fn check(&mut self, idx: &'tcx Expr<'_>, seqexpr: &'tcx Expr<'_>, expr: &'tcx Expr<'_>) -> bool {
-        if_chain! {
-            // the indexed container is referenced by a name
-            if let ExprKind::Path(ref seqpath) = seqexpr.kind;
-            if let QPath::Resolved(None, ref seqvar) = *seqpath;
-            if seqvar.segments.len() == 1;
-            then {
-                let index_used_directly = path_to_local_id(idx, self.var);
-                let indexed_indirectly = {
-                    let mut used_visitor = LocalUsedVisitor::new(self.cx, self.var);
-                    walk_expr(&mut used_visitor, idx);
-                    used_visitor.used
-                };
-
-                if indexed_indirectly || index_used_directly {
-                    if self.prefer_mutable {
-                        self.indexed_mut.insert(seqvar.segments[0].ident.name);
-                    }
-                    let res = self.cx.qpath_res(seqpath, seqexpr.hir_id);
-                    match res {
-                        Res::Local(hir_id) => {
-                            let parent_id = self.cx.tcx.hir().get_parent_item(expr.hir_id);
-                            let parent_def_id = self.cx.tcx.hir().local_def_id(parent_id);
-                            let extent = self.cx.tcx.region_scope_tree(parent_def_id).var_scope(hir_id.local_id);
-                            if indexed_indirectly {
-                                self.indexed_indirectly.insert(seqvar.segments[0].ident.name, Some(extent));
-                            }
-                            if index_used_directly {
-                                self.indexed_directly.insert(
-                                    seqvar.segments[0].ident.name,
-                                    (Some(extent), self.cx.typeck_results().node_type(seqexpr.hir_id)),
-                                );
-                            }
-                            return false;  // no need to walk further *on the variable*
-                        }
-                        Res::Def(DefKind::Static | DefKind::Const, ..) => {
-                            if indexed_indirectly {
-                                self.indexed_indirectly.insert(seqvar.segments[0].ident.name, None);
-                            }
-                            if index_used_directly {
-                                self.indexed_directly.insert(
-                                    seqvar.segments[0].ident.name,
-                                    (None, self.cx.typeck_results().node_type(seqexpr.hir_id)),
-                                );
-                            }
-                            return false;  // no need to walk further *on the variable*
-                        }
-                        _ => (),
-                    }
-                }
-            }
-        }
-        true
-    }
-}
-
-impl<'a, 'tcx> Visitor<'tcx> for VarVisitor<'a, 'tcx> {
-    type Map = Map<'tcx>;
-
-    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
-        if_chain! {
-            // a range index op
-            if let ExprKind::MethodCall(ref meth, _, ref args, _) = expr.kind;
-            if (meth.ident.name == sym::index && match_trait_method(self.cx, expr, &paths::INDEX))
-                || (meth.ident.name == sym::index_mut && match_trait_method(self.cx, expr, &paths::INDEX_MUT));
-            if !self.check(&args[1], &args[0], expr);
-            then { return }
-        }
-
-        if_chain! {
-            // an index op
-            if let ExprKind::Index(ref seqexpr, ref idx) = expr.kind;
-            if !self.check(idx, seqexpr, expr);
-            then { return }
-        }
-
-        if_chain! {
-            // directly using a variable
-            if let ExprKind::Path(QPath::Resolved(None, path)) = expr.kind;
-            if let Res::Local(local_id) = path.res;
-            then {
-                if local_id == self.var {
-                    self.nonindex = true;
-                } else {
-                    // not the correct variable, but still a variable
-                    self.referenced.insert(path.segments[0].ident.name);
-                }
-            }
-        }
-
-        let old = self.prefer_mutable;
-        match expr.kind {
-            ExprKind::AssignOp(_, ref lhs, ref rhs) | ExprKind::Assign(ref lhs, ref rhs, _) => {
-                self.prefer_mutable = true;
-                self.visit_expr(lhs);
-                self.prefer_mutable = false;
-                self.visit_expr(rhs);
-            },
-            ExprKind::AddrOf(BorrowKind::Ref, mutbl, ref expr) => {
-                if mutbl == Mutability::Mut {
-                    self.prefer_mutable = true;
-                }
-                self.visit_expr(expr);
-            },
-            ExprKind::Call(ref f, args) => {
-                self.visit_expr(f);
-                for expr in args {
-                    let ty = self.cx.typeck_results().expr_ty_adjusted(expr);
-                    self.prefer_mutable = false;
-                    if let ty::Ref(_, _, mutbl) = *ty.kind() {
-                        if mutbl == Mutability::Mut {
-                            self.prefer_mutable = true;
-                        }
-                    }
-                    self.visit_expr(expr);
-                }
-            },
-            ExprKind::MethodCall(_, _, args, _) => {
-                let def_id = self.cx.typeck_results().type_dependent_def_id(expr.hir_id).unwrap();
-                for (ty, expr) in self.cx.tcx.fn_sig(def_id).inputs().skip_binder().iter().zip(args) {
-                    self.prefer_mutable = false;
-                    if let ty::Ref(_, _, mutbl) = *ty.kind() {
-                        if mutbl == Mutability::Mut {
-                            self.prefer_mutable = true;
-                        }
-                    }
-                    self.visit_expr(expr);
-                }
-            },
-            ExprKind::Closure(_, _, body_id, ..) => {
-                let body = self.cx.tcx.hir().body(body_id);
-                self.visit_expr(&body.value);
-            },
-            _ => walk_expr(self, expr),
-        }
-        self.prefer_mutable = old;
-    }
-    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-        NestedVisitorMap::None
-    }
-}
-
 fn is_used_inside<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, container: &'tcx Expr<'_>) -> bool {
     let def_id = match path_to_local(expr) {
         Some(id) => id,
-- 
cgit 1.4.1-3-g733a5


From 71026cad541615875fc2570bd3eb51c30ce2151d Mon Sep 17 00:00:00 2001
From: nahuakang <kangnahua@gmail.com>
Date: Mon, 8 Feb 2021 22:01:05 +0100
Subject: Refactor check_for_loop_explicit_counter to its own module

---
 .../src/loops/for_loop_explicit_counter.rs         | 56 +++++++++++++++++++
 clippy_lints/src/loops/mod.rs                      | 65 +---------------------
 clippy_lints/src/loops/utils.rs                    | 12 ++++
 3 files changed, 71 insertions(+), 62 deletions(-)
 create mode 100644 clippy_lints/src/loops/for_loop_explicit_counter.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/for_loop_explicit_counter.rs b/clippy_lints/src/loops/for_loop_explicit_counter.rs
new file mode 100644
index 00000000000..68fee269eb1
--- /dev/null
+++ b/clippy_lints/src/loops/for_loop_explicit_counter.rs
@@ -0,0 +1,56 @@
+use super::{get_span_of_entire_for_loop, make_iterator_snippet, IncrementVisitor, InitializeVisitor};
+use crate::utils::{get_enclosing_block, is_integer_const, snippet_with_applicability, span_lint_and_sugg};
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir::intravisit::{walk_block, walk_expr};
+use rustc_hir::{Expr, Pat};
+use rustc_lint::LateContext;
+
+// To trigger the EXPLICIT_COUNTER_LOOP lint, a variable must be
+// incremented exactly once in the loop body, and initialized to zero
+// at the start of the loop.
+pub(super) fn check_for_loop_explicit_counter<'tcx>(
+    cx: &LateContext<'tcx>,
+    pat: &'tcx Pat<'_>,
+    arg: &'tcx Expr<'_>,
+    body: &'tcx Expr<'_>,
+    expr: &'tcx Expr<'_>,
+) {
+    // Look for variables that are incremented once per loop iteration.
+    let mut increment_visitor = IncrementVisitor::new(cx);
+    walk_expr(&mut increment_visitor, body);
+
+    // For each candidate, check the parent block to see if
+    // it's initialized to zero at the start of the loop.
+    if let Some(block) = get_enclosing_block(&cx, expr.hir_id) {
+        for id in increment_visitor.into_results() {
+            let mut initialize_visitor = InitializeVisitor::new(cx, expr, id);
+            walk_block(&mut initialize_visitor, block);
+
+            if_chain! {
+                if let Some((name, initializer)) = initialize_visitor.get_result();
+                if is_integer_const(cx, initializer, 0);
+                then {
+                    let mut applicability = Applicability::MachineApplicable;
+
+                    let for_span = get_span_of_entire_for_loop(expr);
+
+                    span_lint_and_sugg(
+                        cx,
+                        super::EXPLICIT_COUNTER_LOOP,
+                        for_span.with_hi(arg.span.hi()),
+                        &format!("the variable `{}` is used as a loop counter", name),
+                        "consider using",
+                        format!(
+                            "for ({}, {}) in {}.enumerate()",
+                            name,
+                            snippet_with_applicability(cx, pat.span, "item", &mut applicability),
+                            make_iterator_snippet(cx, arg, &mut applicability),
+                        ),
+                        applicability,
+                    );
+                }
+            }
+        }
+    }
+}
diff --git a/clippy_lints/src/loops/mod.rs b/clippy_lints/src/loops/mod.rs
index 204f9f9b255..f06b3ae4c9f 100644
--- a/clippy_lints/src/loops/mod.rs
+++ b/clippy_lints/src/loops/mod.rs
@@ -1,4 +1,5 @@
 mod for_loop_arg;
+mod for_loop_explicit_counter;
 mod for_loop_over_map_kv;
 mod for_loop_range;
 mod for_mut_range_bound;
@@ -32,7 +33,7 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
 use rustc_span::symbol::{sym, Ident, Symbol};
 use std::iter::{once, Iterator};
-use utils::make_iterator_snippet;
+use utils::{get_span_of_entire_for_loop, make_iterator_snippet};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for for-loops that manually copy items between
@@ -857,7 +858,7 @@ fn check_for_loop<'tcx>(
     let is_manual_memcpy_triggered = detect_manual_memcpy(cx, pat, arg, body, expr);
     if !is_manual_memcpy_triggered {
         for_loop_range::check_for_loop_range(cx, pat, arg, body, expr);
-        check_for_loop_explicit_counter(cx, pat, arg, body, expr);
+        for_loop_explicit_counter::check_for_loop_explicit_counter(cx, pat, arg, body, expr);
     }
     for_loop_arg::check_for_loop_arg(cx, pat, arg, expr);
     for_loop_over_map_kv::check_for_loop_over_map_kv(cx, pat, arg, body, expr);
@@ -867,17 +868,6 @@ fn check_for_loop<'tcx>(
     manual_flatten::check_manual_flatten(cx, pat, arg, body, span);
 }
 
-// this function assumes the given expression is a `for` loop.
-fn get_span_of_entire_for_loop(expr: &Expr<'_>) -> Span {
-    // for some reason this is the only way to get the `Span`
-    // of the entire `for` loop
-    if let ExprKind::Match(_, arms, _) = &expr.kind {
-        arms[0].body.span
-    } else {
-        unreachable!()
-    }
-}
-
 /// a wrapper of `Sugg`. Besides what `Sugg` do, this removes unnecessary `0`;
 /// and also, it avoids subtracting a variable from the same one by replacing it with `0`.
 /// it exists for the convenience of the overloaded operators while normal functions can do the
@@ -1474,55 +1464,6 @@ fn detect_same_item_push<'tcx>(
     }
 }
 
-// To trigger the EXPLICIT_COUNTER_LOOP lint, a variable must be
-// incremented exactly once in the loop body, and initialized to zero
-// at the start of the loop.
-fn check_for_loop_explicit_counter<'tcx>(
-    cx: &LateContext<'tcx>,
-    pat: &'tcx Pat<'_>,
-    arg: &'tcx Expr<'_>,
-    body: &'tcx Expr<'_>,
-    expr: &'tcx Expr<'_>,
-) {
-    // Look for variables that are incremented once per loop iteration.
-    let mut increment_visitor = IncrementVisitor::new(cx);
-    walk_expr(&mut increment_visitor, body);
-
-    // For each candidate, check the parent block to see if
-    // it's initialized to zero at the start of the loop.
-    if let Some(block) = get_enclosing_block(&cx, expr.hir_id) {
-        for id in increment_visitor.into_results() {
-            let mut initialize_visitor = InitializeVisitor::new(cx, expr, id);
-            walk_block(&mut initialize_visitor, block);
-
-            if_chain! {
-                if let Some((name, initializer)) = initialize_visitor.get_result();
-                if is_integer_const(cx, initializer, 0);
-                then {
-                    let mut applicability = Applicability::MachineApplicable;
-
-                    let for_span = get_span_of_entire_for_loop(expr);
-
-                    span_lint_and_sugg(
-                        cx,
-                        EXPLICIT_COUNTER_LOOP,
-                        for_span.with_hi(arg.span.hi()),
-                        &format!("the variable `{}` is used as a loop counter", name),
-                        "consider using",
-                        format!(
-                            "for ({}, {}) in {}.enumerate()",
-                            name,
-                            snippet_with_applicability(cx, pat.span, "item", &mut applicability),
-                            make_iterator_snippet(cx, arg, &mut applicability),
-                        ),
-                        applicability,
-                    );
-                }
-            }
-        }
-    }
-}
-
 fn check_for_single_element_loop<'tcx>(
     cx: &LateContext<'tcx>,
     pat: &'tcx Pat<'_>,
diff --git a/clippy_lints/src/loops/utils.rs b/clippy_lints/src/loops/utils.rs
index b06df2d75f3..b9c934d5e54 100644
--- a/clippy_lints/src/loops/utils.rs
+++ b/clippy_lints/src/loops/utils.rs
@@ -2,6 +2,18 @@ use crate::utils::{get_trait_def_id, has_iter_method, implements_trait, paths, s
 use rustc_errors::Applicability;
 use rustc_hir::{BorrowKind, Expr, ExprKind, Mutability};
 use rustc_lint::LateContext;
+use rustc_span::source_map::Span;
+
+// this function assumes the given expression is a `for` loop.
+pub(super) fn get_span_of_entire_for_loop(expr: &Expr<'_>) -> Span {
+    // for some reason this is the only way to get the `Span`
+    // of the entire `for` loop
+    if let ExprKind::Match(_, arms, _) = &expr.kind {
+        arms[0].body.span
+    } else {
+        unreachable!()
+    }
+}
 
 /// If `arg` was the argument to a `for` loop, return the "cleanest" way of writing the
 /// actual `Iterator` that the loop uses.
-- 
cgit 1.4.1-3-g733a5


From 1e5e541ac57e6757fe8c6c3b316a750730ba7f8c Mon Sep 17 00:00:00 2001
From: nahuakang <kangnahua@gmail.com>
Date: Mon, 8 Feb 2021 22:12:32 +0100
Subject: Refactor check_for_single_element_loop to its own module

---
 clippy_lints/src/loops/for_single_element_loop.rs | 42 ++++++++++++++++++++++
 clippy_lints/src/loops/mod.rs                     | 43 +++--------------------
 2 files changed, 46 insertions(+), 39 deletions(-)
 create mode 100644 clippy_lints/src/loops/for_single_element_loop.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/for_single_element_loop.rs b/clippy_lints/src/loops/for_single_element_loop.rs
new file mode 100644
index 00000000000..8ba19a2233a
--- /dev/null
+++ b/clippy_lints/src/loops/for_single_element_loop.rs
@@ -0,0 +1,42 @@
+use super::get_span_of_entire_for_loop;
+use crate::utils::{indent_of, single_segment_path, snippet, span_lint_and_sugg};
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir::{BorrowKind, Expr, ExprKind, Pat, PatKind};
+use rustc_lint::LateContext;
+
+pub(super) fn check_for_single_element_loop<'tcx>(
+    cx: &LateContext<'tcx>,
+    pat: &'tcx Pat<'_>,
+    arg: &'tcx Expr<'_>,
+    body: &'tcx Expr<'_>,
+    expr: &'tcx Expr<'_>,
+) {
+    if_chain! {
+        if let ExprKind::AddrOf(BorrowKind::Ref, _, ref arg_expr) = arg.kind;
+        if let PatKind::Binding(.., target, _) = pat.kind;
+        if let ExprKind::Array([arg_expression]) = arg_expr.kind;
+        if let ExprKind::Path(ref list_item) = arg_expression.kind;
+        if let Some(list_item_name) = single_segment_path(list_item).map(|ps| ps.ident.name);
+        if let ExprKind::Block(ref block, _) = body.kind;
+        if !block.stmts.is_empty();
+
+        then {
+            let for_span = get_span_of_entire_for_loop(expr);
+            let mut block_str = snippet(cx, block.span, "..").into_owned();
+            block_str.remove(0);
+            block_str.pop();
+
+
+            span_lint_and_sugg(
+                cx,
+                super::SINGLE_ELEMENT_LOOP,
+                for_span,
+                "for loop over a single element",
+                "try",
+                format!("{{\n{}let {} = &{};{}}}", " ".repeat(indent_of(cx, block.stmts[0].span).unwrap_or(0)), target.name, list_item_name, block_str),
+                Applicability::MachineApplicable
+            )
+        }
+    }
+}
diff --git a/clippy_lints/src/loops/mod.rs b/clippy_lints/src/loops/mod.rs
index f06b3ae4c9f..d434762bc22 100644
--- a/clippy_lints/src/loops/mod.rs
+++ b/clippy_lints/src/loops/mod.rs
@@ -3,6 +3,7 @@ mod for_loop_explicit_counter;
 mod for_loop_over_map_kv;
 mod for_loop_range;
 mod for_mut_range_bound;
+mod for_single_element_loop;
 mod manual_flatten;
 mod utils;
 
@@ -10,9 +11,9 @@ use crate::consts::constant;
 use crate::utils::sugg::Sugg;
 use crate::utils::usage::mutated_variables;
 use crate::utils::{
-    get_enclosing_block, get_parent_expr, get_trait_def_id, higher, implements_trait, indent_of, is_in_panic_handler,
+    get_enclosing_block, get_parent_expr, get_trait_def_id, higher, implements_trait, is_in_panic_handler,
     is_integer_const, is_no_std_crate, is_refutable, is_type_diagnostic_item, last_path_segment, match_trait_method,
-    match_type, path_to_local, path_to_local_id, paths, single_segment_path, snippet, snippet_with_applicability,
+    match_type, path_to_local, path_to_local_id, paths, snippet, snippet_with_applicability,
     snippet_with_macro_callsite, span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then, sugg,
 };
 use if_chain::if_chain;
@@ -863,7 +864,7 @@ fn check_for_loop<'tcx>(
     for_loop_arg::check_for_loop_arg(cx, pat, arg, expr);
     for_loop_over_map_kv::check_for_loop_over_map_kv(cx, pat, arg, body, expr);
     for_mut_range_bound::check_for_mut_range_bound(cx, arg, body);
-    check_for_single_element_loop(cx, pat, arg, body, expr);
+    for_single_element_loop::check_for_single_element_loop(cx, pat, arg, body, expr);
     detect_same_item_push(cx, pat, arg, body, expr);
     manual_flatten::check_manual_flatten(cx, pat, arg, body, span);
 }
@@ -1464,42 +1465,6 @@ fn detect_same_item_push<'tcx>(
     }
 }
 
-fn check_for_single_element_loop<'tcx>(
-    cx: &LateContext<'tcx>,
-    pat: &'tcx Pat<'_>,
-    arg: &'tcx Expr<'_>,
-    body: &'tcx Expr<'_>,
-    expr: &'tcx Expr<'_>,
-) {
-    if_chain! {
-        if let ExprKind::AddrOf(BorrowKind::Ref, _, ref arg_expr) = arg.kind;
-        if let PatKind::Binding(.., target, _) = pat.kind;
-        if let ExprKind::Array([arg_expression]) = arg_expr.kind;
-        if let ExprKind::Path(ref list_item) = arg_expression.kind;
-        if let Some(list_item_name) = single_segment_path(list_item).map(|ps| ps.ident.name);
-        if let ExprKind::Block(ref block, _) = body.kind;
-        if !block.stmts.is_empty();
-
-        then {
-            let for_span = get_span_of_entire_for_loop(expr);
-            let mut block_str = snippet(cx, block.span, "..").into_owned();
-            block_str.remove(0);
-            block_str.pop();
-
-
-            span_lint_and_sugg(
-                cx,
-                SINGLE_ELEMENT_LOOP,
-                for_span,
-                "for loop over a single element",
-                "try",
-                format!("{{\n{}let {} = &{};{}}}", " ".repeat(indent_of(cx, block.stmts[0].span).unwrap_or(0)), target.name, list_item_name, block_str),
-                Applicability::MachineApplicable
-            )
-        }
-    }
-}
-
 fn is_used_inside<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, container: &'tcx Expr<'_>) -> bool {
     let def_id = match path_to_local(expr) {
         Some(id) => id,
-- 
cgit 1.4.1-3-g733a5


From 9520cba554e2844c92ede32066138c38de3d327f Mon Sep 17 00:00:00 2001
From: nahuakang <kangnahua@gmail.com>
Date: Tue, 9 Feb 2021 20:21:22 +0100
Subject: Add check_infinite_loop to its own module

---
 clippy_lints/src/loops/infinite_loop.rs | 138 ++++++++++++++++++++++++++++++++
 clippy_lints/src/loops/mod.rs           | 137 ++-----------------------------
 2 files changed, 143 insertions(+), 132 deletions(-)
 create mode 100644 clippy_lints/src/loops/infinite_loop.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/infinite_loop.rs b/clippy_lints/src/loops/infinite_loop.rs
new file mode 100644
index 00000000000..b89942fb647
--- /dev/null
+++ b/clippy_lints/src/loops/infinite_loop.rs
@@ -0,0 +1,138 @@
+use crate::consts::constant;
+use crate::utils::span_lint_and_then;
+use crate::utils::usage::mutated_variables;
+use if_chain::if_chain;
+use rustc_data_structures::fx::{FxHashMap, FxHashSet};
+use rustc_hir::def::{DefKind, Res};
+use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
+use rustc_hir::{def_id, Expr, ExprKind, HirId, QPath};
+use rustc_lint::LateContext;
+use rustc_middle::hir::map::Map;
+use std::iter::Iterator;
+
+pub(super) fn check_infinite_loop<'tcx>(cx: &LateContext<'tcx>, cond: &'tcx Expr<'_>, expr: &'tcx Expr<'_>) {
+    if constant(cx, cx.typeck_results(), cond).is_some() {
+        // A pure constant condition (e.g., `while false`) is not linted.
+        return;
+    }
+
+    let mut var_visitor = VarCollectorVisitor {
+        cx,
+        ids: FxHashSet::default(),
+        def_ids: FxHashMap::default(),
+        skip: false,
+    };
+    var_visitor.visit_expr(cond);
+    if var_visitor.skip {
+        return;
+    }
+    let used_in_condition = &var_visitor.ids;
+    let no_cond_variable_mutated = if let Some(used_mutably) = mutated_variables(expr, cx) {
+        used_in_condition.is_disjoint(&used_mutably)
+    } else {
+        return;
+    };
+    let mutable_static_in_cond = var_visitor.def_ids.iter().any(|(_, v)| *v);
+
+    let mut has_break_or_return_visitor = HasBreakOrReturnVisitor {
+        has_break_or_return: false,
+    };
+    has_break_or_return_visitor.visit_expr(expr);
+    let has_break_or_return = has_break_or_return_visitor.has_break_or_return;
+
+    if no_cond_variable_mutated && !mutable_static_in_cond {
+        span_lint_and_then(
+            cx,
+            super::WHILE_IMMUTABLE_CONDITION,
+            cond.span,
+            "variables in the condition are not mutated in the loop body",
+            |diag| {
+                diag.note("this may lead to an infinite or to a never running loop");
+
+                if has_break_or_return {
+                    diag.note("this loop contains `return`s or `break`s");
+                    diag.help("rewrite it as `if cond { loop { } }`");
+                }
+            },
+        );
+    }
+}
+
+struct HasBreakOrReturnVisitor {
+    has_break_or_return: bool,
+}
+
+impl<'tcx> Visitor<'tcx> for HasBreakOrReturnVisitor {
+    type Map = Map<'tcx>;
+
+    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
+        if self.has_break_or_return {
+            return;
+        }
+
+        match expr.kind {
+            ExprKind::Ret(_) | ExprKind::Break(_, _) => {
+                self.has_break_or_return = true;
+                return;
+            },
+            _ => {},
+        }
+
+        walk_expr(self, expr);
+    }
+
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::None
+    }
+}
+
+/// Collects the set of variables in an expression
+/// Stops analysis if a function call is found
+/// Note: In some cases such as `self`, there are no mutable annotation,
+/// All variables definition IDs are collected
+struct VarCollectorVisitor<'a, 'tcx> {
+    cx: &'a LateContext<'tcx>,
+    ids: FxHashSet<HirId>,
+    def_ids: FxHashMap<def_id::DefId, bool>,
+    skip: bool,
+}
+
+impl<'a, 'tcx> VarCollectorVisitor<'a, 'tcx> {
+    fn insert_def_id(&mut self, ex: &'tcx Expr<'_>) {
+        if_chain! {
+            if let ExprKind::Path(ref qpath) = ex.kind;
+            if let QPath::Resolved(None, _) = *qpath;
+            let res = self.cx.qpath_res(qpath, ex.hir_id);
+            then {
+                match res {
+                    Res::Local(hir_id) => {
+                        self.ids.insert(hir_id);
+                    },
+                    Res::Def(DefKind::Static, def_id) => {
+                        let mutable = self.cx.tcx.is_mutable_static(def_id);
+                        self.def_ids.insert(def_id, mutable);
+                    },
+                    _ => {},
+                }
+            }
+        }
+    }
+}
+
+impl<'a, 'tcx> Visitor<'tcx> for VarCollectorVisitor<'a, 'tcx> {
+    type Map = Map<'tcx>;
+
+    fn visit_expr(&mut self, ex: &'tcx Expr<'_>) {
+        match ex.kind {
+            ExprKind::Path(_) => self.insert_def_id(ex),
+            // If there is any function/method call… we just stop analysis
+            ExprKind::Call(..) | ExprKind::MethodCall(..) => self.skip = true,
+
+            _ => walk_expr(self, ex),
+        }
+    }
+
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::None
+    }
+}
diff --git a/clippy_lints/src/loops/mod.rs b/clippy_lints/src/loops/mod.rs
index d434762bc22..6adfbb6b955 100644
--- a/clippy_lints/src/loops/mod.rs
+++ b/clippy_lints/src/loops/mod.rs
@@ -4,10 +4,10 @@ mod for_loop_over_map_kv;
 mod for_loop_range;
 mod for_mut_range_bound;
 mod for_single_element_loop;
+mod infinite_loop;
 mod manual_flatten;
 mod utils;
 
-use crate::consts::constant;
 use crate::utils::sugg::Sugg;
 use crate::utils::usage::mutated_variables;
 use crate::utils::{
@@ -18,13 +18,13 @@ use crate::utils::{
 };
 use if_chain::if_chain;
 use rustc_ast::ast;
-use rustc_data_structures::fx::{FxHashMap, FxHashSet};
+use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::Applicability;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::intravisit::{walk_block, walk_expr, walk_pat, walk_stmt, NestedVisitorMap, Visitor};
 use rustc_hir::{
-    def_id, BinOpKind, BindingAnnotation, Block, BorrowKind, Expr, ExprKind, GenericArg, HirId, InlineAsmOperand,
-    Local, LoopSource, MatchSource, Mutability, Node, Pat, PatKind, QPath, Stmt, StmtKind,
+    BinOpKind, BindingAnnotation, Block, BorrowKind, Expr, ExprKind, GenericArg, HirId, InlineAsmOperand, Local,
+    LoopSource, MatchSource, Mutability, Node, Pat, PatKind, QPath, Stmt, StmtKind,
 };
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::hir::map::Map;
@@ -683,7 +683,7 @@ impl<'tcx> LateLintPass<'tcx> for Loops {
         }
 
         if let Some((cond, body)) = higher::while_loop(&expr) {
-            check_infinite_loop(cx, cond, body);
+            infinite_loop::check_infinite_loop(cx, cond, body);
         }
 
         check_needless_collect(expr, cx);
@@ -1895,133 +1895,6 @@ impl<'tcx> Visitor<'tcx> for LoopNestVisitor {
     }
 }
 
-fn check_infinite_loop<'tcx>(cx: &LateContext<'tcx>, cond: &'tcx Expr<'_>, expr: &'tcx Expr<'_>) {
-    if constant(cx, cx.typeck_results(), cond).is_some() {
-        // A pure constant condition (e.g., `while false`) is not linted.
-        return;
-    }
-
-    let mut var_visitor = VarCollectorVisitor {
-        cx,
-        ids: FxHashSet::default(),
-        def_ids: FxHashMap::default(),
-        skip: false,
-    };
-    var_visitor.visit_expr(cond);
-    if var_visitor.skip {
-        return;
-    }
-    let used_in_condition = &var_visitor.ids;
-    let no_cond_variable_mutated = if let Some(used_mutably) = mutated_variables(expr, cx) {
-        used_in_condition.is_disjoint(&used_mutably)
-    } else {
-        return;
-    };
-    let mutable_static_in_cond = var_visitor.def_ids.iter().any(|(_, v)| *v);
-
-    let mut has_break_or_return_visitor = HasBreakOrReturnVisitor {
-        has_break_or_return: false,
-    };
-    has_break_or_return_visitor.visit_expr(expr);
-    let has_break_or_return = has_break_or_return_visitor.has_break_or_return;
-
-    if no_cond_variable_mutated && !mutable_static_in_cond {
-        span_lint_and_then(
-            cx,
-            WHILE_IMMUTABLE_CONDITION,
-            cond.span,
-            "variables in the condition are not mutated in the loop body",
-            |diag| {
-                diag.note("this may lead to an infinite or to a never running loop");
-
-                if has_break_or_return {
-                    diag.note("this loop contains `return`s or `break`s");
-                    diag.help("rewrite it as `if cond { loop { } }`");
-                }
-            },
-        );
-    }
-}
-
-struct HasBreakOrReturnVisitor {
-    has_break_or_return: bool,
-}
-
-impl<'tcx> Visitor<'tcx> for HasBreakOrReturnVisitor {
-    type Map = Map<'tcx>;
-
-    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
-        if self.has_break_or_return {
-            return;
-        }
-
-        match expr.kind {
-            ExprKind::Ret(_) | ExprKind::Break(_, _) => {
-                self.has_break_or_return = true;
-                return;
-            },
-            _ => {},
-        }
-
-        walk_expr(self, expr);
-    }
-
-    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-        NestedVisitorMap::None
-    }
-}
-
-/// Collects the set of variables in an expression
-/// Stops analysis if a function call is found
-/// Note: In some cases such as `self`, there are no mutable annotation,
-/// All variables definition IDs are collected
-struct VarCollectorVisitor<'a, 'tcx> {
-    cx: &'a LateContext<'tcx>,
-    ids: FxHashSet<HirId>,
-    def_ids: FxHashMap<def_id::DefId, bool>,
-    skip: bool,
-}
-
-impl<'a, 'tcx> VarCollectorVisitor<'a, 'tcx> {
-    fn insert_def_id(&mut self, ex: &'tcx Expr<'_>) {
-        if_chain! {
-            if let ExprKind::Path(ref qpath) = ex.kind;
-            if let QPath::Resolved(None, _) = *qpath;
-            let res = self.cx.qpath_res(qpath, ex.hir_id);
-            then {
-                match res {
-                    Res::Local(hir_id) => {
-                        self.ids.insert(hir_id);
-                    },
-                    Res::Def(DefKind::Static, def_id) => {
-                        let mutable = self.cx.tcx.is_mutable_static(def_id);
-                        self.def_ids.insert(def_id, mutable);
-                    },
-                    _ => {},
-                }
-            }
-        }
-    }
-}
-
-impl<'a, 'tcx> Visitor<'tcx> for VarCollectorVisitor<'a, 'tcx> {
-    type Map = Map<'tcx>;
-
-    fn visit_expr(&mut self, ex: &'tcx Expr<'_>) {
-        match ex.kind {
-            ExprKind::Path(_) => self.insert_def_id(ex),
-            // If there is any function/method call… we just stop analysis
-            ExprKind::Call(..) | ExprKind::MethodCall(..) => self.skip = true,
-
-            _ => walk_expr(self, ex),
-        }
-    }
-
-    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-        NestedVisitorMap::None
-    }
-}
-
 const NEEDLESS_COLLECT_MSG: &str = "avoid using `collect()` when not needed";
 
 fn check_needless_collect<'tcx>(expr: &'tcx Expr<'_>, cx: &LateContext<'tcx>) {
-- 
cgit 1.4.1-3-g733a5


From 453e6b97ace822f715b6118a60ec9b33e0ae87ec Mon Sep 17 00:00:00 2001
From: nahuakang <kangnahua@gmail.com>
Date: Tue, 9 Feb 2021 21:26:46 +0100
Subject: Add check_needless_collect to its own module

---
 clippy_lints/src/loops/mod.rs              | 282 +----------------------------
 clippy_lints/src/loops/needless_collect.rs | 282 +++++++++++++++++++++++++++++
 2 files changed, 289 insertions(+), 275 deletions(-)
 create mode 100644 clippy_lints/src/loops/needless_collect.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/mod.rs b/clippy_lints/src/loops/mod.rs
index 6adfbb6b955..043bbc9d1c5 100644
--- a/clippy_lints/src/loops/mod.rs
+++ b/clippy_lints/src/loops/mod.rs
@@ -6,6 +6,7 @@ mod for_mut_range_bound;
 mod for_single_element_loop;
 mod infinite_loop;
 mod manual_flatten;
+mod needless_collect;
 mod utils;
 
 use crate::utils::sugg::Sugg;
@@ -13,8 +14,8 @@ use crate::utils::usage::mutated_variables;
 use crate::utils::{
     get_enclosing_block, get_parent_expr, get_trait_def_id, higher, implements_trait, is_in_panic_handler,
     is_integer_const, is_no_std_crate, is_refutable, is_type_diagnostic_item, last_path_segment, match_trait_method,
-    match_type, path_to_local, path_to_local_id, paths, snippet, snippet_with_applicability,
-    snippet_with_macro_callsite, span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then, sugg,
+    path_to_local, path_to_local_id, paths, snippet, snippet_with_applicability, snippet_with_macro_callsite,
+    span_lint, span_lint_and_help, span_lint_and_sugg, sugg,
 };
 use if_chain::if_chain;
 use rustc_ast::ast;
@@ -23,8 +24,8 @@ use rustc_errors::Applicability;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::intravisit::{walk_block, walk_expr, walk_pat, walk_stmt, NestedVisitorMap, Visitor};
 use rustc_hir::{
-    BinOpKind, BindingAnnotation, Block, BorrowKind, Expr, ExprKind, GenericArg, HirId, InlineAsmOperand, Local,
-    LoopSource, MatchSource, Mutability, Node, Pat, PatKind, QPath, Stmt, StmtKind,
+    BinOpKind, BindingAnnotation, Block, BorrowKind, Expr, ExprKind, HirId, InlineAsmOperand, LoopSource, MatchSource,
+    Mutability, Node, Pat, PatKind, Stmt, StmtKind,
 };
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::hir::map::Map;
@@ -32,7 +33,7 @@ use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::{self, Ty};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
-use rustc_span::symbol::{sym, Ident, Symbol};
+use rustc_span::symbol::{sym, Symbol};
 use std::iter::{once, Iterator};
 use utils::{get_span_of_entire_for_loop, make_iterator_snippet};
 
@@ -686,7 +687,7 @@ impl<'tcx> LateLintPass<'tcx> for Loops {
             infinite_loop::check_infinite_loop(cx, cond, body);
         }
 
-        check_needless_collect(expr, cx);
+        needless_collect::check_needless_collect(expr, cx);
     }
 }
 
@@ -1894,272 +1895,3 @@ impl<'tcx> Visitor<'tcx> for LoopNestVisitor {
         NestedVisitorMap::None
     }
 }
-
-const NEEDLESS_COLLECT_MSG: &str = "avoid using `collect()` when not needed";
-
-fn check_needless_collect<'tcx>(expr: &'tcx Expr<'_>, cx: &LateContext<'tcx>) {
-    check_needless_collect_direct_usage(expr, cx);
-    check_needless_collect_indirect_usage(expr, cx);
-}
-fn check_needless_collect_direct_usage<'tcx>(expr: &'tcx Expr<'_>, cx: &LateContext<'tcx>) {
-    if_chain! {
-        if let ExprKind::MethodCall(ref method, _, ref args, _) = expr.kind;
-        if let ExprKind::MethodCall(ref chain_method, _, _, _) = args[0].kind;
-        if chain_method.ident.name == sym!(collect) && match_trait_method(cx, &args[0], &paths::ITERATOR);
-        if let Some(ref generic_args) = chain_method.args;
-        if let Some(GenericArg::Type(ref ty)) = generic_args.args.get(0);
-        then {
-            let ty = cx.typeck_results().node_type(ty.hir_id);
-            if is_type_diagnostic_item(cx, ty, sym::vec_type) ||
-                is_type_diagnostic_item(cx, ty, sym!(vecdeque_type)) ||
-                match_type(cx, ty, &paths::BTREEMAP) ||
-                is_type_diagnostic_item(cx, ty, sym!(hashmap_type)) {
-                if method.ident.name == sym!(len) {
-                    let span = shorten_needless_collect_span(expr);
-                    span_lint_and_sugg(
-                        cx,
-                        NEEDLESS_COLLECT,
-                        span,
-                        NEEDLESS_COLLECT_MSG,
-                        "replace with",
-                        "count()".to_string(),
-                        Applicability::MachineApplicable,
-                    );
-                }
-                if method.ident.name == sym!(is_empty) {
-                    let span = shorten_needless_collect_span(expr);
-                    span_lint_and_sugg(
-                        cx,
-                        NEEDLESS_COLLECT,
-                        span,
-                        NEEDLESS_COLLECT_MSG,
-                        "replace with",
-                        "next().is_none()".to_string(),
-                        Applicability::MachineApplicable,
-                    );
-                }
-                if method.ident.name == sym!(contains) {
-                    let contains_arg = snippet(cx, args[1].span, "??");
-                    let span = shorten_needless_collect_span(expr);
-                    span_lint_and_then(
-                        cx,
-                        NEEDLESS_COLLECT,
-                        span,
-                        NEEDLESS_COLLECT_MSG,
-                        |diag| {
-                            let (arg, pred) = contains_arg
-                                    .strip_prefix('&')
-                                    .map_or(("&x", &*contains_arg), |s| ("x", s));
-                            diag.span_suggestion(
-                                span,
-                                "replace with",
-                                format!(
-                                    "any(|{}| x == {})",
-                                    arg, pred
-                                ),
-                                Applicability::MachineApplicable,
-                            );
-                        }
-                    );
-                }
-            }
-        }
-    }
-}
-
-fn check_needless_collect_indirect_usage<'tcx>(expr: &'tcx Expr<'_>, cx: &LateContext<'tcx>) {
-    if let ExprKind::Block(ref block, _) = expr.kind {
-        for ref stmt in block.stmts {
-            if_chain! {
-                if let StmtKind::Local(
-                    Local { pat: Pat { hir_id: pat_id, kind: PatKind::Binding(_, _, ident, .. ), .. },
-                    init: Some(ref init_expr), .. }
-                ) = stmt.kind;
-                if let ExprKind::MethodCall(ref method_name, _, &[ref iter_source], ..) = init_expr.kind;
-                if method_name.ident.name == sym!(collect) && match_trait_method(cx, &init_expr, &paths::ITERATOR);
-                if let Some(ref generic_args) = method_name.args;
-                if let Some(GenericArg::Type(ref ty)) = generic_args.args.get(0);
-                if let ty = cx.typeck_results().node_type(ty.hir_id);
-                if is_type_diagnostic_item(cx, ty, sym::vec_type) ||
-                    is_type_diagnostic_item(cx, ty, sym!(vecdeque_type)) ||
-                    match_type(cx, ty, &paths::LINKED_LIST);
-                if let Some(iter_calls) = detect_iter_and_into_iters(block, *ident);
-                if iter_calls.len() == 1;
-                then {
-                    let mut used_count_visitor = UsedCountVisitor {
-                        cx,
-                        id: *pat_id,
-                        count: 0,
-                    };
-                    walk_block(&mut used_count_visitor, block);
-                    if used_count_visitor.count > 1 {
-                        return;
-                    }
-
-                    // Suggest replacing iter_call with iter_replacement, and removing stmt
-                    let iter_call = &iter_calls[0];
-                    span_lint_and_then(
-                        cx,
-                        NEEDLESS_COLLECT,
-                        stmt.span.until(iter_call.span),
-                        NEEDLESS_COLLECT_MSG,
-                        |diag| {
-                            let iter_replacement = format!("{}{}", Sugg::hir(cx, iter_source, ".."), iter_call.get_iter_method(cx));
-                            diag.multipart_suggestion(
-                                iter_call.get_suggestion_text(),
-                                vec![
-                                    (stmt.span, String::new()),
-                                    (iter_call.span, iter_replacement)
-                                ],
-                                Applicability::MachineApplicable,// MaybeIncorrect,
-                            ).emit();
-                        },
-                    );
-                }
-            }
-        }
-    }
-}
-
-struct IterFunction {
-    func: IterFunctionKind,
-    span: Span,
-}
-impl IterFunction {
-    fn get_iter_method(&self, cx: &LateContext<'_>) -> String {
-        match &self.func {
-            IterFunctionKind::IntoIter => String::new(),
-            IterFunctionKind::Len => String::from(".count()"),
-            IterFunctionKind::IsEmpty => String::from(".next().is_none()"),
-            IterFunctionKind::Contains(span) => {
-                let s = snippet(cx, *span, "..");
-                if let Some(stripped) = s.strip_prefix('&') {
-                    format!(".any(|x| x == {})", stripped)
-                } else {
-                    format!(".any(|x| x == *{})", s)
-                }
-            },
-        }
-    }
-    fn get_suggestion_text(&self) -> &'static str {
-        match &self.func {
-            IterFunctionKind::IntoIter => {
-                "use the original Iterator instead of collecting it and then producing a new one"
-            },
-            IterFunctionKind::Len => {
-                "take the original Iterator's count instead of collecting it and finding the length"
-            },
-            IterFunctionKind::IsEmpty => {
-                "check if the original Iterator has anything instead of collecting it and seeing if it's empty"
-            },
-            IterFunctionKind::Contains(_) => {
-                "check if the original Iterator contains an element instead of collecting then checking"
-            },
-        }
-    }
-}
-enum IterFunctionKind {
-    IntoIter,
-    Len,
-    IsEmpty,
-    Contains(Span),
-}
-
-struct IterFunctionVisitor {
-    uses: Vec<IterFunction>,
-    seen_other: bool,
-    target: Ident,
-}
-impl<'tcx> Visitor<'tcx> for IterFunctionVisitor {
-    fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) {
-        // Check function calls on our collection
-        if_chain! {
-            if let ExprKind::MethodCall(method_name, _, ref args, _) = &expr.kind;
-            if let Some(Expr { kind: ExprKind::Path(QPath::Resolved(_, ref path)), .. }) = args.get(0);
-            if let &[name] = &path.segments;
-            if name.ident == self.target;
-            then {
-                let len = sym!(len);
-                let is_empty = sym!(is_empty);
-                let contains = sym!(contains);
-                match method_name.ident.name {
-                    sym::into_iter => self.uses.push(
-                        IterFunction { func: IterFunctionKind::IntoIter, span: expr.span }
-                    ),
-                    name if name == len => self.uses.push(
-                        IterFunction { func: IterFunctionKind::Len, span: expr.span }
-                    ),
-                    name if name == is_empty => self.uses.push(
-                        IterFunction { func: IterFunctionKind::IsEmpty, span: expr.span }
-                    ),
-                    name if name == contains => self.uses.push(
-                        IterFunction { func: IterFunctionKind::Contains(args[1].span), span: expr.span }
-                    ),
-                    _ => self.seen_other = true,
-                }
-                return
-            }
-        }
-        // Check if the collection is used for anything else
-        if_chain! {
-            if let Expr { kind: ExprKind::Path(QPath::Resolved(_, ref path)), .. } = expr;
-            if let &[name] = &path.segments;
-            if name.ident == self.target;
-            then {
-                self.seen_other = true;
-            } else {
-                walk_expr(self, expr);
-            }
-        }
-    }
-
-    type Map = Map<'tcx>;
-    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-        NestedVisitorMap::None
-    }
-}
-
-struct UsedCountVisitor<'a, 'tcx> {
-    cx: &'a LateContext<'tcx>,
-    id: HirId,
-    count: usize,
-}
-
-impl<'a, 'tcx> Visitor<'tcx> for UsedCountVisitor<'a, 'tcx> {
-    type Map = Map<'tcx>;
-
-    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
-        if path_to_local_id(expr, self.id) {
-            self.count += 1;
-        } else {
-            walk_expr(self, expr);
-        }
-    }
-
-    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-        NestedVisitorMap::OnlyBodies(self.cx.tcx.hir())
-    }
-}
-
-/// Detect the occurrences of calls to `iter` or `into_iter` for the
-/// given identifier
-fn detect_iter_and_into_iters<'tcx>(block: &'tcx Block<'tcx>, identifier: Ident) -> Option<Vec<IterFunction>> {
-    let mut visitor = IterFunctionVisitor {
-        uses: Vec::new(),
-        target: identifier,
-        seen_other: false,
-    };
-    visitor.visit_block(block);
-    if visitor.seen_other { None } else { Some(visitor.uses) }
-}
-
-fn shorten_needless_collect_span(expr: &Expr<'_>) -> Span {
-    if_chain! {
-        if let ExprKind::MethodCall(.., args, _) = &expr.kind;
-        if let ExprKind::MethodCall(_, span, ..) = &args[0].kind;
-        then {
-            return expr.span.with_lo(span.lo());
-        }
-    }
-    unreachable!();
-}
diff --git a/clippy_lints/src/loops/needless_collect.rs b/clippy_lints/src/loops/needless_collect.rs
new file mode 100644
index 00000000000..cc2e2975492
--- /dev/null
+++ b/clippy_lints/src/loops/needless_collect.rs
@@ -0,0 +1,282 @@
+use crate::utils::sugg::Sugg;
+use crate::utils::{
+    is_type_diagnostic_item, match_trait_method, match_type, path_to_local_id, paths, snippet, span_lint_and_sugg,
+    span_lint_and_then,
+};
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir::intravisit::{walk_block, walk_expr, NestedVisitorMap, Visitor};
+use rustc_hir::{Block, Expr, ExprKind, GenericArg, HirId, Local, Pat, PatKind, QPath, StmtKind};
+use rustc_lint::LateContext;
+use rustc_middle::hir::map::Map;
+use rustc_span::source_map::Span;
+use rustc_span::symbol::{sym, Ident};
+
+const NEEDLESS_COLLECT_MSG: &str = "avoid using `collect()` when not needed";
+
+pub(super) fn check_needless_collect<'tcx>(expr: &'tcx Expr<'_>, cx: &LateContext<'tcx>) {
+    check_needless_collect_direct_usage(expr, cx);
+    check_needless_collect_indirect_usage(expr, cx);
+}
+fn check_needless_collect_direct_usage<'tcx>(expr: &'tcx Expr<'_>, cx: &LateContext<'tcx>) {
+    if_chain! {
+        if let ExprKind::MethodCall(ref method, _, ref args, _) = expr.kind;
+        if let ExprKind::MethodCall(ref chain_method, _, _, _) = args[0].kind;
+        if chain_method.ident.name == sym!(collect) && match_trait_method(cx, &args[0], &paths::ITERATOR);
+        if let Some(ref generic_args) = chain_method.args;
+        if let Some(GenericArg::Type(ref ty)) = generic_args.args.get(0);
+        then {
+            let ty = cx.typeck_results().node_type(ty.hir_id);
+            if is_type_diagnostic_item(cx, ty, sym::vec_type) ||
+                is_type_diagnostic_item(cx, ty, sym!(vecdeque_type)) ||
+                match_type(cx, ty, &paths::BTREEMAP) ||
+                is_type_diagnostic_item(cx, ty, sym!(hashmap_type)) {
+                if method.ident.name == sym!(len) {
+                    let span = shorten_needless_collect_span(expr);
+                    span_lint_and_sugg(
+                        cx,
+                        super::NEEDLESS_COLLECT,
+                        span,
+                        NEEDLESS_COLLECT_MSG,
+                        "replace with",
+                        "count()".to_string(),
+                        Applicability::MachineApplicable,
+                    );
+                }
+                if method.ident.name == sym!(is_empty) {
+                    let span = shorten_needless_collect_span(expr);
+                    span_lint_and_sugg(
+                        cx,
+                        super::NEEDLESS_COLLECT,
+                        span,
+                        NEEDLESS_COLLECT_MSG,
+                        "replace with",
+                        "next().is_none()".to_string(),
+                        Applicability::MachineApplicable,
+                    );
+                }
+                if method.ident.name == sym!(contains) {
+                    let contains_arg = snippet(cx, args[1].span, "??");
+                    let span = shorten_needless_collect_span(expr);
+                    span_lint_and_then(
+                        cx,
+                        super::NEEDLESS_COLLECT,
+                        span,
+                        NEEDLESS_COLLECT_MSG,
+                        |diag| {
+                            let (arg, pred) = contains_arg
+                                    .strip_prefix('&')
+                                    .map_or(("&x", &*contains_arg), |s| ("x", s));
+                            diag.span_suggestion(
+                                span,
+                                "replace with",
+                                format!(
+                                    "any(|{}| x == {})",
+                                    arg, pred
+                                ),
+                                Applicability::MachineApplicable,
+                            );
+                        }
+                    );
+                }
+            }
+        }
+    }
+}
+
+fn check_needless_collect_indirect_usage<'tcx>(expr: &'tcx Expr<'_>, cx: &LateContext<'tcx>) {
+    if let ExprKind::Block(ref block, _) = expr.kind {
+        for ref stmt in block.stmts {
+            if_chain! {
+                if let StmtKind::Local(
+                    Local { pat: Pat { hir_id: pat_id, kind: PatKind::Binding(_, _, ident, .. ), .. },
+                    init: Some(ref init_expr), .. }
+                ) = stmt.kind;
+                if let ExprKind::MethodCall(ref method_name, _, &[ref iter_source], ..) = init_expr.kind;
+                if method_name.ident.name == sym!(collect) && match_trait_method(cx, &init_expr, &paths::ITERATOR);
+                if let Some(ref generic_args) = method_name.args;
+                if let Some(GenericArg::Type(ref ty)) = generic_args.args.get(0);
+                if let ty = cx.typeck_results().node_type(ty.hir_id);
+                if is_type_diagnostic_item(cx, ty, sym::vec_type) ||
+                    is_type_diagnostic_item(cx, ty, sym!(vecdeque_type)) ||
+                    match_type(cx, ty, &paths::LINKED_LIST);
+                if let Some(iter_calls) = detect_iter_and_into_iters(block, *ident);
+                if iter_calls.len() == 1;
+                then {
+                    let mut used_count_visitor = UsedCountVisitor {
+                        cx,
+                        id: *pat_id,
+                        count: 0,
+                    };
+                    walk_block(&mut used_count_visitor, block);
+                    if used_count_visitor.count > 1 {
+                        return;
+                    }
+
+                    // Suggest replacing iter_call with iter_replacement, and removing stmt
+                    let iter_call = &iter_calls[0];
+                    span_lint_and_then(
+                        cx,
+                        super::NEEDLESS_COLLECT,
+                        stmt.span.until(iter_call.span),
+                        NEEDLESS_COLLECT_MSG,
+                        |diag| {
+                            let iter_replacement = format!("{}{}", Sugg::hir(cx, iter_source, ".."), iter_call.get_iter_method(cx));
+                            diag.multipart_suggestion(
+                                iter_call.get_suggestion_text(),
+                                vec![
+                                    (stmt.span, String::new()),
+                                    (iter_call.span, iter_replacement)
+                                ],
+                                Applicability::MachineApplicable,// MaybeIncorrect,
+                            ).emit();
+                        },
+                    );
+                }
+            }
+        }
+    }
+}
+
+struct IterFunction {
+    func: IterFunctionKind,
+    span: Span,
+}
+impl IterFunction {
+    fn get_iter_method(&self, cx: &LateContext<'_>) -> String {
+        match &self.func {
+            IterFunctionKind::IntoIter => String::new(),
+            IterFunctionKind::Len => String::from(".count()"),
+            IterFunctionKind::IsEmpty => String::from(".next().is_none()"),
+            IterFunctionKind::Contains(span) => {
+                let s = snippet(cx, *span, "..");
+                if let Some(stripped) = s.strip_prefix('&') {
+                    format!(".any(|x| x == {})", stripped)
+                } else {
+                    format!(".any(|x| x == *{})", s)
+                }
+            },
+        }
+    }
+    fn get_suggestion_text(&self) -> &'static str {
+        match &self.func {
+            IterFunctionKind::IntoIter => {
+                "use the original Iterator instead of collecting it and then producing a new one"
+            },
+            IterFunctionKind::Len => {
+                "take the original Iterator's count instead of collecting it and finding the length"
+            },
+            IterFunctionKind::IsEmpty => {
+                "check if the original Iterator has anything instead of collecting it and seeing if it's empty"
+            },
+            IterFunctionKind::Contains(_) => {
+                "check if the original Iterator contains an element instead of collecting then checking"
+            },
+        }
+    }
+}
+enum IterFunctionKind {
+    IntoIter,
+    Len,
+    IsEmpty,
+    Contains(Span),
+}
+
+struct IterFunctionVisitor {
+    uses: Vec<IterFunction>,
+    seen_other: bool,
+    target: Ident,
+}
+impl<'tcx> Visitor<'tcx> for IterFunctionVisitor {
+    fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) {
+        // Check function calls on our collection
+        if_chain! {
+            if let ExprKind::MethodCall(method_name, _, ref args, _) = &expr.kind;
+            if let Some(Expr { kind: ExprKind::Path(QPath::Resolved(_, ref path)), .. }) = args.get(0);
+            if let &[name] = &path.segments;
+            if name.ident == self.target;
+            then {
+                let len = sym!(len);
+                let is_empty = sym!(is_empty);
+                let contains = sym!(contains);
+                match method_name.ident.name {
+                    sym::into_iter => self.uses.push(
+                        IterFunction { func: IterFunctionKind::IntoIter, span: expr.span }
+                    ),
+                    name if name == len => self.uses.push(
+                        IterFunction { func: IterFunctionKind::Len, span: expr.span }
+                    ),
+                    name if name == is_empty => self.uses.push(
+                        IterFunction { func: IterFunctionKind::IsEmpty, span: expr.span }
+                    ),
+                    name if name == contains => self.uses.push(
+                        IterFunction { func: IterFunctionKind::Contains(args[1].span), span: expr.span }
+                    ),
+                    _ => self.seen_other = true,
+                }
+                return
+            }
+        }
+        // Check if the collection is used for anything else
+        if_chain! {
+            if let Expr { kind: ExprKind::Path(QPath::Resolved(_, ref path)), .. } = expr;
+            if let &[name] = &path.segments;
+            if name.ident == self.target;
+            then {
+                self.seen_other = true;
+            } else {
+                walk_expr(self, expr);
+            }
+        }
+    }
+
+    type Map = Map<'tcx>;
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::None
+    }
+}
+
+struct UsedCountVisitor<'a, 'tcx> {
+    cx: &'a LateContext<'tcx>,
+    id: HirId,
+    count: usize,
+}
+
+impl<'a, 'tcx> Visitor<'tcx> for UsedCountVisitor<'a, 'tcx> {
+    type Map = Map<'tcx>;
+
+    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
+        if path_to_local_id(expr, self.id) {
+            self.count += 1;
+        } else {
+            walk_expr(self, expr);
+        }
+    }
+
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::OnlyBodies(self.cx.tcx.hir())
+    }
+}
+
+/// Detect the occurrences of calls to `iter` or `into_iter` for the
+/// given identifier
+fn detect_iter_and_into_iters<'tcx>(block: &'tcx Block<'tcx>, identifier: Ident) -> Option<Vec<IterFunction>> {
+    let mut visitor = IterFunctionVisitor {
+        uses: Vec::new(),
+        target: identifier,
+        seen_other: false,
+    };
+    visitor.visit_block(block);
+    if visitor.seen_other { None } else { Some(visitor.uses) }
+}
+
+fn shorten_needless_collect_span(expr: &Expr<'_>) -> Span {
+    if_chain! {
+        if let ExprKind::MethodCall(.., args, _) = &expr.kind;
+        if let ExprKind::MethodCall(_, span, ..) = &args[0].kind;
+        then {
+            return expr.span.with_lo(span.lo());
+        }
+    }
+    unreachable!();
+}
-- 
cgit 1.4.1-3-g733a5


From 2c1f676bfe831f488cbd8e07d46b7b9be727ca24 Mon Sep 17 00:00:00 2001
From: nahuakang <kangnahua@gmail.com>
Date: Tue, 9 Feb 2021 21:58:10 +0100
Subject: Add detect_same_item_push to its own module

---
 clippy_lints/src/loops/mod.rs            | 171 ++-----------------------------
 clippy_lints/src/loops/same_item_push.rs | 168 ++++++++++++++++++++++++++++++
 2 files changed, 174 insertions(+), 165 deletions(-)
 create mode 100644 clippy_lints/src/loops/same_item_push.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/mod.rs b/clippy_lints/src/loops/mod.rs
index 043bbc9d1c5..66b71a7202e 100644
--- a/clippy_lints/src/loops/mod.rs
+++ b/clippy_lints/src/loops/mod.rs
@@ -7,6 +7,7 @@ mod for_single_element_loop;
 mod infinite_loop;
 mod manual_flatten;
 mod needless_collect;
+mod same_item_push;
 mod utils;
 
 use crate::utils::sugg::Sugg;
@@ -14,18 +15,17 @@ use crate::utils::usage::mutated_variables;
 use crate::utils::{
     get_enclosing_block, get_parent_expr, get_trait_def_id, higher, implements_trait, is_in_panic_handler,
     is_integer_const, is_no_std_crate, is_refutable, is_type_diagnostic_item, last_path_segment, match_trait_method,
-    path_to_local, path_to_local_id, paths, snippet, snippet_with_applicability, snippet_with_macro_callsite,
-    span_lint, span_lint_and_help, span_lint_and_sugg, sugg,
+    path_to_local, path_to_local_id, paths, snippet, snippet_with_applicability, span_lint, span_lint_and_help,
+    span_lint_and_sugg, sugg,
 };
 use if_chain::if_chain;
 use rustc_ast::ast;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::Applicability;
-use rustc_hir::def::{DefKind, Res};
 use rustc_hir::intravisit::{walk_block, walk_expr, walk_pat, walk_stmt, NestedVisitorMap, Visitor};
 use rustc_hir::{
-    BinOpKind, BindingAnnotation, Block, BorrowKind, Expr, ExprKind, HirId, InlineAsmOperand, LoopSource, MatchSource,
-    Mutability, Node, Pat, PatKind, Stmt, StmtKind,
+    BinOpKind, Block, BorrowKind, Expr, ExprKind, HirId, InlineAsmOperand, LoopSource, MatchSource, Mutability, Node,
+    Pat, PatKind, Stmt, StmtKind,
 };
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::hir::map::Map;
@@ -866,7 +866,7 @@ fn check_for_loop<'tcx>(
     for_loop_over_map_kv::check_for_loop_over_map_kv(cx, pat, arg, body, expr);
     for_mut_range_bound::check_for_mut_range_bound(cx, arg, body);
     for_single_element_loop::check_for_single_element_loop(cx, pat, arg, body, expr);
-    detect_same_item_push(cx, pat, arg, body, expr);
+    same_item_push::detect_same_item_push(cx, pat, arg, body, expr);
     manual_flatten::check_manual_flatten(cx, pat, arg, body, span);
 }
 
@@ -1307,165 +1307,6 @@ fn detect_manual_memcpy<'tcx>(
     false
 }
 
-// Scans the body of the for loop and determines whether lint should be given
-struct SameItemPushVisitor<'a, 'tcx> {
-    should_lint: bool,
-    // this field holds the last vec push operation visited, which should be the only push seen
-    vec_push: Option<(&'tcx Expr<'tcx>, &'tcx Expr<'tcx>)>,
-    cx: &'a LateContext<'tcx>,
-}
-
-impl<'a, 'tcx> Visitor<'tcx> for SameItemPushVisitor<'a, 'tcx> {
-    type Map = Map<'tcx>;
-
-    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
-        match &expr.kind {
-            // Non-determinism may occur ... don't give a lint
-            ExprKind::Loop(..) | ExprKind::Match(..) => self.should_lint = false,
-            ExprKind::Block(block, _) => self.visit_block(block),
-            _ => {},
-        }
-    }
-
-    fn visit_block(&mut self, b: &'tcx Block<'_>) {
-        for stmt in b.stmts.iter() {
-            self.visit_stmt(stmt);
-        }
-    }
-
-    fn visit_stmt(&mut self, s: &'tcx Stmt<'_>) {
-        let vec_push_option = get_vec_push(self.cx, s);
-        if vec_push_option.is_none() {
-            // Current statement is not a push so visit inside
-            match &s.kind {
-                StmtKind::Expr(expr) | StmtKind::Semi(expr) => self.visit_expr(&expr),
-                _ => {},
-            }
-        } else {
-            // Current statement is a push ...check whether another
-            // push had been previously done
-            if self.vec_push.is_none() {
-                self.vec_push = vec_push_option;
-            } else {
-                // There are multiple pushes ... don't lint
-                self.should_lint = false;
-            }
-        }
-    }
-
-    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-        NestedVisitorMap::None
-    }
-}
-
-// Given some statement, determine if that statement is a push on a Vec. If it is, return
-// the Vec being pushed into and the item being pushed
-fn get_vec_push<'tcx>(cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) -> Option<(&'tcx Expr<'tcx>, &'tcx Expr<'tcx>)> {
-    if_chain! {
-            // Extract method being called
-            if let StmtKind::Semi(semi_stmt) = &stmt.kind;
-            if let ExprKind::MethodCall(path, _, args, _) = &semi_stmt.kind;
-            // Figure out the parameters for the method call
-            if let Some(self_expr) = args.get(0);
-            if let Some(pushed_item) = args.get(1);
-            // Check that the method being called is push() on a Vec
-            if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(self_expr), sym::vec_type);
-            if path.ident.name.as_str() == "push";
-            then {
-                return Some((self_expr, pushed_item))
-            }
-    }
-    None
-}
-
-/// Detects for loop pushing the same item into a Vec
-fn detect_same_item_push<'tcx>(
-    cx: &LateContext<'tcx>,
-    pat: &'tcx Pat<'_>,
-    _: &'tcx Expr<'_>,
-    body: &'tcx Expr<'_>,
-    _: &'tcx Expr<'_>,
-) {
-    fn emit_lint(cx: &LateContext<'_>, vec: &Expr<'_>, pushed_item: &Expr<'_>) {
-        let vec_str = snippet_with_macro_callsite(cx, vec.span, "");
-        let item_str = snippet_with_macro_callsite(cx, pushed_item.span, "");
-
-        span_lint_and_help(
-            cx,
-            SAME_ITEM_PUSH,
-            vec.span,
-            "it looks like the same item is being pushed into this Vec",
-            None,
-            &format!(
-                "try using vec![{};SIZE] or {}.resize(NEW_SIZE, {})",
-                item_str, vec_str, item_str
-            ),
-        )
-    }
-
-    if !matches!(pat.kind, PatKind::Wild) {
-        return;
-    }
-
-    // Determine whether it is safe to lint the body
-    let mut same_item_push_visitor = SameItemPushVisitor {
-        should_lint: true,
-        vec_push: None,
-        cx,
-    };
-    walk_expr(&mut same_item_push_visitor, body);
-    if same_item_push_visitor.should_lint {
-        if let Some((vec, pushed_item)) = same_item_push_visitor.vec_push {
-            let vec_ty = cx.typeck_results().expr_ty(vec);
-            let ty = vec_ty.walk().nth(1).unwrap().expect_ty();
-            if cx
-                .tcx
-                .lang_items()
-                .clone_trait()
-                .map_or(false, |id| implements_trait(cx, ty, id, &[]))
-            {
-                // Make sure that the push does not involve possibly mutating values
-                match pushed_item.kind {
-                    ExprKind::Path(ref qpath) => {
-                        match cx.qpath_res(qpath, pushed_item.hir_id) {
-                            // immutable bindings that are initialized with literal or constant
-                            Res::Local(hir_id) => {
-                                if_chain! {
-                                    let node = cx.tcx.hir().get(hir_id);
-                                    if let Node::Binding(pat) = node;
-                                    if let PatKind::Binding(bind_ann, ..) = pat.kind;
-                                    if !matches!(bind_ann, BindingAnnotation::RefMut | BindingAnnotation::Mutable);
-                                    let parent_node = cx.tcx.hir().get_parent_node(hir_id);
-                                    if let Some(Node::Local(parent_let_expr)) = cx.tcx.hir().find(parent_node);
-                                    if let Some(init) = parent_let_expr.init;
-                                    then {
-                                        match init.kind {
-                                            // immutable bindings that are initialized with literal
-                                            ExprKind::Lit(..) => emit_lint(cx, vec, pushed_item),
-                                            // immutable bindings that are initialized with constant
-                                            ExprKind::Path(ref path) => {
-                                                if let Res::Def(DefKind::Const, ..) = cx.qpath_res(path, init.hir_id) {
-                                                    emit_lint(cx, vec, pushed_item);
-                                                }
-                                            }
-                                            _ => {},
-                                        }
-                                    }
-                                }
-                            },
-                            // constant
-                            Res::Def(DefKind::Const, ..) => emit_lint(cx, vec, pushed_item),
-                            _ => {},
-                        }
-                    },
-                    ExprKind::Lit(..) => emit_lint(cx, vec, pushed_item),
-                    _ => {},
-                }
-            }
-        }
-    }
-}
-
 fn is_used_inside<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, container: &'tcx Expr<'_>) -> bool {
     let def_id = match path_to_local(expr) {
         Some(id) => id,
diff --git a/clippy_lints/src/loops/same_item_push.rs b/clippy_lints/src/loops/same_item_push.rs
new file mode 100644
index 00000000000..62efb58a38f
--- /dev/null
+++ b/clippy_lints/src/loops/same_item_push.rs
@@ -0,0 +1,168 @@
+use crate::utils::{implements_trait, is_type_diagnostic_item, snippet_with_macro_callsite, span_lint_and_help};
+use if_chain::if_chain;
+use rustc_hir::def::{DefKind, Res};
+use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
+use rustc_hir::{BindingAnnotation, Block, Expr, ExprKind, Node, Pat, PatKind, Stmt, StmtKind};
+use rustc_lint::LateContext;
+use rustc_middle::hir::map::Map;
+use rustc_span::symbol::sym;
+use std::iter::Iterator;
+
+/// Detects for loop pushing the same item into a Vec
+pub(super) fn detect_same_item_push<'tcx>(
+    cx: &LateContext<'tcx>,
+    pat: &'tcx Pat<'_>,
+    _: &'tcx Expr<'_>,
+    body: &'tcx Expr<'_>,
+    _: &'tcx Expr<'_>,
+) {
+    fn emit_lint(cx: &LateContext<'_>, vec: &Expr<'_>, pushed_item: &Expr<'_>) {
+        let vec_str = snippet_with_macro_callsite(cx, vec.span, "");
+        let item_str = snippet_with_macro_callsite(cx, pushed_item.span, "");
+
+        span_lint_and_help(
+            cx,
+            super::SAME_ITEM_PUSH,
+            vec.span,
+            "it looks like the same item is being pushed into this Vec",
+            None,
+            &format!(
+                "try using vec![{};SIZE] or {}.resize(NEW_SIZE, {})",
+                item_str, vec_str, item_str
+            ),
+        )
+    }
+
+    if !matches!(pat.kind, PatKind::Wild) {
+        return;
+    }
+
+    // Determine whether it is safe to lint the body
+    let mut same_item_push_visitor = SameItemPushVisitor {
+        should_lint: true,
+        vec_push: None,
+        cx,
+    };
+    walk_expr(&mut same_item_push_visitor, body);
+    if same_item_push_visitor.should_lint {
+        if let Some((vec, pushed_item)) = same_item_push_visitor.vec_push {
+            let vec_ty = cx.typeck_results().expr_ty(vec);
+            let ty = vec_ty.walk().nth(1).unwrap().expect_ty();
+            if cx
+                .tcx
+                .lang_items()
+                .clone_trait()
+                .map_or(false, |id| implements_trait(cx, ty, id, &[]))
+            {
+                // Make sure that the push does not involve possibly mutating values
+                match pushed_item.kind {
+                    ExprKind::Path(ref qpath) => {
+                        match cx.qpath_res(qpath, pushed_item.hir_id) {
+                            // immutable bindings that are initialized with literal or constant
+                            Res::Local(hir_id) => {
+                                if_chain! {
+                                    let node = cx.tcx.hir().get(hir_id);
+                                    if let Node::Binding(pat) = node;
+                                    if let PatKind::Binding(bind_ann, ..) = pat.kind;
+                                    if !matches!(bind_ann, BindingAnnotation::RefMut | BindingAnnotation::Mutable);
+                                    let parent_node = cx.tcx.hir().get_parent_node(hir_id);
+                                    if let Some(Node::Local(parent_let_expr)) = cx.tcx.hir().find(parent_node);
+                                    if let Some(init) = parent_let_expr.init;
+                                    then {
+                                        match init.kind {
+                                            // immutable bindings that are initialized with literal
+                                            ExprKind::Lit(..) => emit_lint(cx, vec, pushed_item),
+                                            // immutable bindings that are initialized with constant
+                                            ExprKind::Path(ref path) => {
+                                                if let Res::Def(DefKind::Const, ..) = cx.qpath_res(path, init.hir_id) {
+                                                    emit_lint(cx, vec, pushed_item);
+                                                }
+                                            }
+                                            _ => {},
+                                        }
+                                    }
+                                }
+                            },
+                            // constant
+                            Res::Def(DefKind::Const, ..) => emit_lint(cx, vec, pushed_item),
+                            _ => {},
+                        }
+                    },
+                    ExprKind::Lit(..) => emit_lint(cx, vec, pushed_item),
+                    _ => {},
+                }
+            }
+        }
+    }
+}
+
+// Scans the body of the for loop and determines whether lint should be given
+struct SameItemPushVisitor<'a, 'tcx> {
+    should_lint: bool,
+    // this field holds the last vec push operation visited, which should be the only push seen
+    vec_push: Option<(&'tcx Expr<'tcx>, &'tcx Expr<'tcx>)>,
+    cx: &'a LateContext<'tcx>,
+}
+
+impl<'a, 'tcx> Visitor<'tcx> for SameItemPushVisitor<'a, 'tcx> {
+    type Map = Map<'tcx>;
+
+    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
+        match &expr.kind {
+            // Non-determinism may occur ... don't give a lint
+            ExprKind::Loop(..) | ExprKind::Match(..) => self.should_lint = false,
+            ExprKind::Block(block, _) => self.visit_block(block),
+            _ => {},
+        }
+    }
+
+    fn visit_block(&mut self, b: &'tcx Block<'_>) {
+        for stmt in b.stmts.iter() {
+            self.visit_stmt(stmt);
+        }
+    }
+
+    fn visit_stmt(&mut self, s: &'tcx Stmt<'_>) {
+        let vec_push_option = get_vec_push(self.cx, s);
+        if vec_push_option.is_none() {
+            // Current statement is not a push so visit inside
+            match &s.kind {
+                StmtKind::Expr(expr) | StmtKind::Semi(expr) => self.visit_expr(&expr),
+                _ => {},
+            }
+        } else {
+            // Current statement is a push ...check whether another
+            // push had been previously done
+            if self.vec_push.is_none() {
+                self.vec_push = vec_push_option;
+            } else {
+                // There are multiple pushes ... don't lint
+                self.should_lint = false;
+            }
+        }
+    }
+
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::None
+    }
+}
+
+// Given some statement, determine if that statement is a push on a Vec. If it is, return
+// the Vec being pushed into and the item being pushed
+fn get_vec_push<'tcx>(cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) -> Option<(&'tcx Expr<'tcx>, &'tcx Expr<'tcx>)> {
+    if_chain! {
+            // Extract method being called
+            if let StmtKind::Semi(semi_stmt) = &stmt.kind;
+            if let ExprKind::MethodCall(path, _, args, _) = &semi_stmt.kind;
+            // Figure out the parameters for the method call
+            if let Some(self_expr) = args.get(0);
+            if let Some(pushed_item) = args.get(1);
+            // Check that the method being called is push() on a Vec
+            if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(self_expr), sym::vec_type);
+            if path.ident.name.as_str() == "push";
+            then {
+                return Some((self_expr, pushed_item))
+            }
+    }
+    None
+}
-- 
cgit 1.4.1-3-g733a5


From 5b870e1b36e781d842c7c84290707f2aaf5dc8cf Mon Sep 17 00:00:00 2001
From: nahuakang <kangnahua@gmail.com>
Date: Tue, 9 Feb 2021 23:27:03 +0100
Subject: Move detect_manual_memcpy to its module; split up utils structs

---
 clippy_lints/src/loops/manual_memcpy.rs | 381 ++++++++++++++++++
 clippy_lints/src/loops/mod.rs           | 684 +-------------------------------
 clippy_lints/src/loops/utils.rs         | 302 +++++++++++++-
 3 files changed, 694 insertions(+), 673 deletions(-)
 create mode 100644 clippy_lints/src/loops/manual_memcpy.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/manual_memcpy.rs b/clippy_lints/src/loops/manual_memcpy.rs
new file mode 100644
index 00000000000..85b3dfaece7
--- /dev/null
+++ b/clippy_lints/src/loops/manual_memcpy.rs
@@ -0,0 +1,381 @@
+use super::{get_span_of_entire_for_loop, IncrementVisitor, InitializeVisitor, MinifyingSugg};
+use crate::utils::sugg::Sugg;
+use crate::utils::{
+    get_enclosing_block, higher, is_type_diagnostic_item, path_to_local, snippet, span_lint_and_sugg, sugg,
+};
+use if_chain::if_chain;
+use rustc_ast::ast;
+use rustc_errors::Applicability;
+use rustc_hir::intravisit::walk_block;
+use rustc_hir::{BinOpKind, Block, Expr, ExprKind, HirId, Pat, PatKind, StmtKind};
+use rustc_lint::LateContext;
+use rustc_middle::ty::{self, Ty};
+use rustc_span::symbol::sym;
+use std::iter::Iterator;
+
+/// Checks for for loops that sequentially copy items from one slice-like
+/// object to another.
+pub(super) fn detect_manual_memcpy<'tcx>(
+    cx: &LateContext<'tcx>,
+    pat: &'tcx Pat<'_>,
+    arg: &'tcx Expr<'_>,
+    body: &'tcx Expr<'_>,
+    expr: &'tcx Expr<'_>,
+) -> bool {
+    if let Some(higher::Range {
+        start: Some(start),
+        end: Some(end),
+        limits,
+    }) = higher::range(arg)
+    {
+        // the var must be a single name
+        if let PatKind::Binding(_, canonical_id, _, _) = pat.kind {
+            let mut starts = vec![Start {
+                id: canonical_id,
+                kind: StartKind::Range,
+            }];
+
+            // This is one of few ways to return different iterators
+            // derived from: https://stackoverflow.com/questions/29760668/conditionally-iterate-over-one-of-several-possible-iterators/52064434#52064434
+            let mut iter_a = None;
+            let mut iter_b = None;
+
+            if let ExprKind::Block(block, _) = body.kind {
+                if let Some(loop_counters) = get_loop_counters(cx, block, expr) {
+                    starts.extend(loop_counters);
+                }
+                iter_a = Some(get_assignments(block, &starts));
+            } else {
+                iter_b = Some(get_assignment(body));
+            }
+
+            let assignments = iter_a.into_iter().flatten().chain(iter_b.into_iter());
+
+            let big_sugg = assignments
+                // The only statements in the for loops can be indexed assignments from
+                // indexed retrievals (except increments of loop counters).
+                .map(|o| {
+                    o.and_then(|(lhs, rhs)| {
+                        let rhs = fetch_cloned_expr(rhs);
+                        if_chain! {
+                            if let ExprKind::Index(base_left, idx_left) = lhs.kind;
+                            if let ExprKind::Index(base_right, idx_right) = rhs.kind;
+                            if is_slice_like(cx, cx.typeck_results().expr_ty(base_left))
+                                && is_slice_like(cx, cx.typeck_results().expr_ty(base_right));
+                            if let Some((start_left, offset_left)) = get_details_from_idx(cx, &idx_left, &starts);
+                            if let Some((start_right, offset_right)) = get_details_from_idx(cx, &idx_right, &starts);
+
+                            // Source and destination must be different
+                            if path_to_local(base_left) != path_to_local(base_right);
+                            then {
+                                Some((IndexExpr { base: base_left, idx: start_left, idx_offset: offset_left },
+                                    IndexExpr { base: base_right, idx: start_right, idx_offset: offset_right }))
+                            } else {
+                                None
+                            }
+                        }
+                    })
+                })
+                .map(|o| o.map(|(dst, src)| build_manual_memcpy_suggestion(cx, start, end, limits, &dst, &src)))
+                .collect::<Option<Vec<_>>>()
+                .filter(|v| !v.is_empty())
+                .map(|v| v.join("\n    "));
+
+            if let Some(big_sugg) = big_sugg {
+                span_lint_and_sugg(
+                    cx,
+                    super::MANUAL_MEMCPY,
+                    get_span_of_entire_for_loop(expr),
+                    "it looks like you're manually copying between slices",
+                    "try replacing the loop by",
+                    big_sugg,
+                    Applicability::Unspecified,
+                );
+                return true;
+            }
+        }
+    }
+    false
+}
+
+fn build_manual_memcpy_suggestion<'tcx>(
+    cx: &LateContext<'tcx>,
+    start: &Expr<'_>,
+    end: &Expr<'_>,
+    limits: ast::RangeLimits,
+    dst: &IndexExpr<'_>,
+    src: &IndexExpr<'_>,
+) -> String {
+    fn print_offset(offset: MinifyingSugg<'static>) -> MinifyingSugg<'static> {
+        if offset.as_str() == "0" {
+            sugg::EMPTY.into()
+        } else {
+            offset
+        }
+    }
+
+    let print_limit = |end: &Expr<'_>, end_str: &str, base: &Expr<'_>, sugg: MinifyingSugg<'static>| {
+        if_chain! {
+            if let ExprKind::MethodCall(method, _, len_args, _) = end.kind;
+            if method.ident.name == sym!(len);
+            if len_args.len() == 1;
+            if let Some(arg) = len_args.get(0);
+            if path_to_local(arg) == path_to_local(base);
+            then {
+                if sugg.as_str() == end_str {
+                    sugg::EMPTY.into()
+                } else {
+                    sugg
+                }
+            } else {
+                match limits {
+                    ast::RangeLimits::Closed => {
+                        sugg + &sugg::ONE.into()
+                    },
+                    ast::RangeLimits::HalfOpen => sugg,
+                }
+            }
+        }
+    };
+
+    let start_str = Sugg::hir(cx, start, "").into();
+    let end_str: MinifyingSugg<'_> = Sugg::hir(cx, end, "").into();
+
+    let print_offset_and_limit = |idx_expr: &IndexExpr<'_>| match idx_expr.idx {
+        StartKind::Range => (
+            print_offset(apply_offset(&start_str, &idx_expr.idx_offset)).into_sugg(),
+            print_limit(
+                end,
+                end_str.as_str(),
+                idx_expr.base,
+                apply_offset(&end_str, &idx_expr.idx_offset),
+            )
+            .into_sugg(),
+        ),
+        StartKind::Counter { initializer } => {
+            let counter_start = Sugg::hir(cx, initializer, "").into();
+            (
+                print_offset(apply_offset(&counter_start, &idx_expr.idx_offset)).into_sugg(),
+                print_limit(
+                    end,
+                    end_str.as_str(),
+                    idx_expr.base,
+                    apply_offset(&end_str, &idx_expr.idx_offset) + &counter_start - &start_str,
+                )
+                .into_sugg(),
+            )
+        },
+    };
+
+    let (dst_offset, dst_limit) = print_offset_and_limit(&dst);
+    let (src_offset, src_limit) = print_offset_and_limit(&src);
+
+    let dst_base_str = snippet(cx, dst.base.span, "???");
+    let src_base_str = snippet(cx, src.base.span, "???");
+
+    let dst = if dst_offset == sugg::EMPTY && dst_limit == sugg::EMPTY {
+        dst_base_str
+    } else {
+        format!(
+            "{}[{}..{}]",
+            dst_base_str,
+            dst_offset.maybe_par(),
+            dst_limit.maybe_par()
+        )
+        .into()
+    };
+
+    format!(
+        "{}.clone_from_slice(&{}[{}..{}]);",
+        dst,
+        src_base_str,
+        src_offset.maybe_par(),
+        src_limit.maybe_par()
+    )
+}
+
+/// a wrapper around `MinifyingSugg`, which carries a operator like currying
+/// so that the suggested code become more efficient (e.g. `foo + -bar` `foo - bar`).
+struct Offset {
+    value: MinifyingSugg<'static>,
+    sign: OffsetSign,
+}
+
+#[derive(Clone, Copy)]
+enum OffsetSign {
+    Positive,
+    Negative,
+}
+
+impl Offset {
+    fn negative(value: Sugg<'static>) -> Self {
+        Self {
+            value: value.into(),
+            sign: OffsetSign::Negative,
+        }
+    }
+
+    fn positive(value: Sugg<'static>) -> Self {
+        Self {
+            value: value.into(),
+            sign: OffsetSign::Positive,
+        }
+    }
+
+    fn empty() -> Self {
+        Self::positive(sugg::ZERO)
+    }
+}
+
+fn apply_offset(lhs: &MinifyingSugg<'static>, rhs: &Offset) -> MinifyingSugg<'static> {
+    match rhs.sign {
+        OffsetSign::Positive => lhs + &rhs.value,
+        OffsetSign::Negative => lhs - &rhs.value,
+    }
+}
+
+#[derive(Debug, Clone, Copy)]
+enum StartKind<'hir> {
+    Range,
+    Counter { initializer: &'hir Expr<'hir> },
+}
+
+struct IndexExpr<'hir> {
+    base: &'hir Expr<'hir>,
+    idx: StartKind<'hir>,
+    idx_offset: Offset,
+}
+
+struct Start<'hir> {
+    id: HirId,
+    kind: StartKind<'hir>,
+}
+
+fn is_slice_like<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'_>) -> bool {
+    let is_slice = match ty.kind() {
+        ty::Ref(_, subty, _) => is_slice_like(cx, subty),
+        ty::Slice(..) | ty::Array(..) => true,
+        _ => false,
+    };
+
+    is_slice || is_type_diagnostic_item(cx, ty, sym::vec_type) || is_type_diagnostic_item(cx, ty, sym!(vecdeque_type))
+}
+
+fn fetch_cloned_expr<'tcx>(expr: &'tcx Expr<'tcx>) -> &'tcx Expr<'tcx> {
+    if_chain! {
+        if let ExprKind::MethodCall(method, _, args, _) = expr.kind;
+        if method.ident.name == sym::clone;
+        if args.len() == 1;
+        if let Some(arg) = args.get(0);
+        then { arg } else { expr }
+    }
+}
+
+fn get_details_from_idx<'tcx>(
+    cx: &LateContext<'tcx>,
+    idx: &Expr<'_>,
+    starts: &[Start<'tcx>],
+) -> Option<(StartKind<'tcx>, Offset)> {
+    fn get_start<'tcx>(e: &Expr<'_>, starts: &[Start<'tcx>]) -> Option<StartKind<'tcx>> {
+        let id = path_to_local(e)?;
+        starts.iter().find(|start| start.id == id).map(|start| start.kind)
+    }
+
+    fn get_offset<'tcx>(cx: &LateContext<'tcx>, e: &Expr<'_>, starts: &[Start<'tcx>]) -> Option<Sugg<'static>> {
+        match &e.kind {
+            ExprKind::Lit(l) => match l.node {
+                ast::LitKind::Int(x, _ty) => Some(Sugg::NonParen(x.to_string().into())),
+                _ => None,
+            },
+            ExprKind::Path(..) if get_start(e, starts).is_none() => Some(Sugg::hir(cx, e, "???")),
+            _ => None,
+        }
+    }
+
+    match idx.kind {
+        ExprKind::Binary(op, lhs, rhs) => match op.node {
+            BinOpKind::Add => {
+                let offset_opt = get_start(lhs, starts)
+                    .and_then(|s| get_offset(cx, rhs, starts).map(|o| (s, o)))
+                    .or_else(|| get_start(rhs, starts).and_then(|s| get_offset(cx, lhs, starts).map(|o| (s, o))));
+
+                offset_opt.map(|(s, o)| (s, Offset::positive(o)))
+            },
+            BinOpKind::Sub => {
+                get_start(lhs, starts).and_then(|s| get_offset(cx, rhs, starts).map(|o| (s, Offset::negative(o))))
+            },
+            _ => None,
+        },
+        ExprKind::Path(..) => get_start(idx, starts).map(|s| (s, Offset::empty())),
+        _ => None,
+    }
+}
+
+fn get_assignment<'tcx>(e: &'tcx Expr<'tcx>) -> Option<(&'tcx Expr<'tcx>, &'tcx Expr<'tcx>)> {
+    if let ExprKind::Assign(lhs, rhs, _) = e.kind {
+        Some((lhs, rhs))
+    } else {
+        None
+    }
+}
+
+/// Get assignments from the given block.
+/// The returned iterator yields `None` if no assignment expressions are there,
+/// filtering out the increments of the given whitelisted loop counters;
+/// because its job is to make sure there's nothing other than assignments and the increments.
+fn get_assignments<'a, 'tcx>(
+    Block { stmts, expr, .. }: &'tcx Block<'tcx>,
+    loop_counters: &'a [Start<'tcx>],
+) -> impl Iterator<Item = Option<(&'tcx Expr<'tcx>, &'tcx Expr<'tcx>)>> + 'a {
+    // As the `filter` and `map` below do different things, I think putting together
+    // just increases complexity. (cc #3188 and #4193)
+    stmts
+        .iter()
+        .filter_map(move |stmt| match stmt.kind {
+            StmtKind::Local(..) | StmtKind::Item(..) => None,
+            StmtKind::Expr(e) | StmtKind::Semi(e) => Some(e),
+        })
+        .chain((*expr).into_iter())
+        .filter(move |e| {
+            if let ExprKind::AssignOp(_, place, _) = e.kind {
+                path_to_local(place).map_or(false, |id| {
+                    !loop_counters
+                        .iter()
+                        // skip the first item which should be `StartKind::Range`
+                        // this makes it possible to use the slice with `StartKind::Range` in the same iterator loop.
+                        .skip(1)
+                        .any(|counter| counter.id == id)
+                })
+            } else {
+                true
+            }
+        })
+        .map(get_assignment)
+}
+
+fn get_loop_counters<'a, 'tcx>(
+    cx: &'a LateContext<'tcx>,
+    body: &'tcx Block<'tcx>,
+    expr: &'tcx Expr<'_>,
+) -> Option<impl Iterator<Item = Start<'tcx>> + 'a> {
+    // Look for variables that are incremented once per loop iteration.
+    let mut increment_visitor = IncrementVisitor::new(cx);
+    walk_block(&mut increment_visitor, body);
+
+    // For each candidate, check the parent block to see if
+    // it's initialized to zero at the start of the loop.
+    get_enclosing_block(&cx, expr.hir_id).and_then(|block| {
+        increment_visitor
+            .into_results()
+            .filter_map(move |var_id| {
+                let mut initialize_visitor = InitializeVisitor::new(cx, expr, var_id);
+                walk_block(&mut initialize_visitor, block);
+
+                initialize_visitor.get_result().map(|(_, initializer)| Start {
+                    id: var_id,
+                    kind: StartKind::Counter { initializer },
+                })
+            })
+            .into()
+    })
+}
diff --git a/clippy_lints/src/loops/mod.rs b/clippy_lints/src/loops/mod.rs
index 66b71a7202e..c6055e34eb2 100644
--- a/clippy_lints/src/loops/mod.rs
+++ b/clippy_lints/src/loops/mod.rs
@@ -6,6 +6,7 @@ mod for_mut_range_bound;
 mod for_single_element_loop;
 mod infinite_loop;
 mod manual_flatten;
+mod manual_memcpy;
 mod needless_collect;
 mod same_item_push;
 mod utils;
@@ -13,29 +14,26 @@ mod utils;
 use crate::utils::sugg::Sugg;
 use crate::utils::usage::mutated_variables;
 use crate::utils::{
-    get_enclosing_block, get_parent_expr, get_trait_def_id, higher, implements_trait, is_in_panic_handler,
-    is_integer_const, is_no_std_crate, is_refutable, is_type_diagnostic_item, last_path_segment, match_trait_method,
-    path_to_local, path_to_local_id, paths, snippet, snippet_with_applicability, span_lint, span_lint_and_help,
-    span_lint_and_sugg, sugg,
+    get_enclosing_block, get_trait_def_id, higher, implements_trait, is_in_panic_handler, is_no_std_crate,
+    is_refutable, last_path_segment, match_trait_method, path_to_local, path_to_local_id, paths,
+    snippet_with_applicability, span_lint, span_lint_and_help, span_lint_and_sugg, sugg,
 };
 use if_chain::if_chain;
-use rustc_ast::ast;
-use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::Applicability;
-use rustc_hir::intravisit::{walk_block, walk_expr, walk_pat, walk_stmt, NestedVisitorMap, Visitor};
+use rustc_hir::intravisit::{walk_block, walk_expr, NestedVisitorMap, Visitor};
 use rustc_hir::{
-    BinOpKind, Block, BorrowKind, Expr, ExprKind, HirId, InlineAsmOperand, LoopSource, MatchSource, Mutability, Node,
-    Pat, PatKind, Stmt, StmtKind,
+    Block, Expr, ExprKind, HirId, InlineAsmOperand, LoopSource, MatchSource, Node, Pat, PatKind, Stmt, StmtKind,
 };
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::hir::map::Map;
 use rustc_middle::lint::in_external_macro;
-use rustc_middle::ty::{self, Ty};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
-use rustc_span::symbol::{sym, Symbol};
+use rustc_span::symbol::sym;
 use std::iter::{once, Iterator};
-use utils::{get_span_of_entire_for_loop, make_iterator_snippet};
+use utils::{
+    get_span_of_entire_for_loop, make_iterator_snippet, IncrementVisitor, InitializeVisitor, LoopNestVisitor, Nesting,
+};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for for-loops that manually copy items between
@@ -857,7 +855,7 @@ fn check_for_loop<'tcx>(
     expr: &'tcx Expr<'_>,
     span: Span,
 ) {
-    let is_manual_memcpy_triggered = detect_manual_memcpy(cx, pat, arg, body, expr);
+    let is_manual_memcpy_triggered = manual_memcpy::detect_manual_memcpy(cx, pat, arg, body, expr);
     if !is_manual_memcpy_triggered {
         for_loop_range::check_for_loop_range(cx, pat, arg, body, expr);
         for_loop_explicit_counter::check_for_loop_explicit_counter(cx, pat, arg, body, expr);
@@ -940,373 +938,6 @@ impl std::ops::Sub<&MinifyingSugg<'static>> for MinifyingSugg<'static> {
     }
 }
 
-/// a wrapper around `MinifyingSugg`, which carries a operator like currying
-/// so that the suggested code become more efficient (e.g. `foo + -bar` `foo - bar`).
-struct Offset {
-    value: MinifyingSugg<'static>,
-    sign: OffsetSign,
-}
-
-#[derive(Clone, Copy)]
-enum OffsetSign {
-    Positive,
-    Negative,
-}
-
-impl Offset {
-    fn negative(value: Sugg<'static>) -> Self {
-        Self {
-            value: value.into(),
-            sign: OffsetSign::Negative,
-        }
-    }
-
-    fn positive(value: Sugg<'static>) -> Self {
-        Self {
-            value: value.into(),
-            sign: OffsetSign::Positive,
-        }
-    }
-
-    fn empty() -> Self {
-        Self::positive(sugg::ZERO)
-    }
-}
-
-fn apply_offset(lhs: &MinifyingSugg<'static>, rhs: &Offset) -> MinifyingSugg<'static> {
-    match rhs.sign {
-        OffsetSign::Positive => lhs + &rhs.value,
-        OffsetSign::Negative => lhs - &rhs.value,
-    }
-}
-
-#[derive(Debug, Clone, Copy)]
-enum StartKind<'hir> {
-    Range,
-    Counter { initializer: &'hir Expr<'hir> },
-}
-
-struct IndexExpr<'hir> {
-    base: &'hir Expr<'hir>,
-    idx: StartKind<'hir>,
-    idx_offset: Offset,
-}
-
-struct Start<'hir> {
-    id: HirId,
-    kind: StartKind<'hir>,
-}
-
-fn is_slice_like<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'_>) -> bool {
-    let is_slice = match ty.kind() {
-        ty::Ref(_, subty, _) => is_slice_like(cx, subty),
-        ty::Slice(..) | ty::Array(..) => true,
-        _ => false,
-    };
-
-    is_slice || is_type_diagnostic_item(cx, ty, sym::vec_type) || is_type_diagnostic_item(cx, ty, sym!(vecdeque_type))
-}
-
-fn fetch_cloned_expr<'tcx>(expr: &'tcx Expr<'tcx>) -> &'tcx Expr<'tcx> {
-    if_chain! {
-        if let ExprKind::MethodCall(method, _, args, _) = expr.kind;
-        if method.ident.name == sym::clone;
-        if args.len() == 1;
-        if let Some(arg) = args.get(0);
-        then { arg } else { expr }
-    }
-}
-
-fn get_details_from_idx<'tcx>(
-    cx: &LateContext<'tcx>,
-    idx: &Expr<'_>,
-    starts: &[Start<'tcx>],
-) -> Option<(StartKind<'tcx>, Offset)> {
-    fn get_start<'tcx>(e: &Expr<'_>, starts: &[Start<'tcx>]) -> Option<StartKind<'tcx>> {
-        let id = path_to_local(e)?;
-        starts.iter().find(|start| start.id == id).map(|start| start.kind)
-    }
-
-    fn get_offset<'tcx>(cx: &LateContext<'tcx>, e: &Expr<'_>, starts: &[Start<'tcx>]) -> Option<Sugg<'static>> {
-        match &e.kind {
-            ExprKind::Lit(l) => match l.node {
-                ast::LitKind::Int(x, _ty) => Some(Sugg::NonParen(x.to_string().into())),
-                _ => None,
-            },
-            ExprKind::Path(..) if get_start(e, starts).is_none() => Some(Sugg::hir(cx, e, "???")),
-            _ => None,
-        }
-    }
-
-    match idx.kind {
-        ExprKind::Binary(op, lhs, rhs) => match op.node {
-            BinOpKind::Add => {
-                let offset_opt = get_start(lhs, starts)
-                    .and_then(|s| get_offset(cx, rhs, starts).map(|o| (s, o)))
-                    .or_else(|| get_start(rhs, starts).and_then(|s| get_offset(cx, lhs, starts).map(|o| (s, o))));
-
-                offset_opt.map(|(s, o)| (s, Offset::positive(o)))
-            },
-            BinOpKind::Sub => {
-                get_start(lhs, starts).and_then(|s| get_offset(cx, rhs, starts).map(|o| (s, Offset::negative(o))))
-            },
-            _ => None,
-        },
-        ExprKind::Path(..) => get_start(idx, starts).map(|s| (s, Offset::empty())),
-        _ => None,
-    }
-}
-
-fn get_assignment<'tcx>(e: &'tcx Expr<'tcx>) -> Option<(&'tcx Expr<'tcx>, &'tcx Expr<'tcx>)> {
-    if let ExprKind::Assign(lhs, rhs, _) = e.kind {
-        Some((lhs, rhs))
-    } else {
-        None
-    }
-}
-
-/// Get assignments from the given block.
-/// The returned iterator yields `None` if no assignment expressions are there,
-/// filtering out the increments of the given whitelisted loop counters;
-/// because its job is to make sure there's nothing other than assignments and the increments.
-fn get_assignments<'a, 'tcx>(
-    Block { stmts, expr, .. }: &'tcx Block<'tcx>,
-    loop_counters: &'a [Start<'tcx>],
-) -> impl Iterator<Item = Option<(&'tcx Expr<'tcx>, &'tcx Expr<'tcx>)>> + 'a {
-    // As the `filter` and `map` below do different things, I think putting together
-    // just increases complexity. (cc #3188 and #4193)
-    stmts
-        .iter()
-        .filter_map(move |stmt| match stmt.kind {
-            StmtKind::Local(..) | StmtKind::Item(..) => None,
-            StmtKind::Expr(e) | StmtKind::Semi(e) => Some(e),
-        })
-        .chain((*expr).into_iter())
-        .filter(move |e| {
-            if let ExprKind::AssignOp(_, place, _) = e.kind {
-                path_to_local(place).map_or(false, |id| {
-                    !loop_counters
-                        .iter()
-                        // skip the first item which should be `StartKind::Range`
-                        // this makes it possible to use the slice with `StartKind::Range` in the same iterator loop.
-                        .skip(1)
-                        .any(|counter| counter.id == id)
-                })
-            } else {
-                true
-            }
-        })
-        .map(get_assignment)
-}
-
-fn get_loop_counters<'a, 'tcx>(
-    cx: &'a LateContext<'tcx>,
-    body: &'tcx Block<'tcx>,
-    expr: &'tcx Expr<'_>,
-) -> Option<impl Iterator<Item = Start<'tcx>> + 'a> {
-    // Look for variables that are incremented once per loop iteration.
-    let mut increment_visitor = IncrementVisitor::new(cx);
-    walk_block(&mut increment_visitor, body);
-
-    // For each candidate, check the parent block to see if
-    // it's initialized to zero at the start of the loop.
-    get_enclosing_block(&cx, expr.hir_id).and_then(|block| {
-        increment_visitor
-            .into_results()
-            .filter_map(move |var_id| {
-                let mut initialize_visitor = InitializeVisitor::new(cx, expr, var_id);
-                walk_block(&mut initialize_visitor, block);
-
-                initialize_visitor.get_result().map(|(_, initializer)| Start {
-                    id: var_id,
-                    kind: StartKind::Counter { initializer },
-                })
-            })
-            .into()
-    })
-}
-
-fn build_manual_memcpy_suggestion<'tcx>(
-    cx: &LateContext<'tcx>,
-    start: &Expr<'_>,
-    end: &Expr<'_>,
-    limits: ast::RangeLimits,
-    dst: &IndexExpr<'_>,
-    src: &IndexExpr<'_>,
-) -> String {
-    fn print_offset(offset: MinifyingSugg<'static>) -> MinifyingSugg<'static> {
-        if offset.as_str() == "0" {
-            sugg::EMPTY.into()
-        } else {
-            offset
-        }
-    }
-
-    let print_limit = |end: &Expr<'_>, end_str: &str, base: &Expr<'_>, sugg: MinifyingSugg<'static>| {
-        if_chain! {
-            if let ExprKind::MethodCall(method, _, len_args, _) = end.kind;
-            if method.ident.name == sym!(len);
-            if len_args.len() == 1;
-            if let Some(arg) = len_args.get(0);
-            if path_to_local(arg) == path_to_local(base);
-            then {
-                if sugg.as_str() == end_str {
-                    sugg::EMPTY.into()
-                } else {
-                    sugg
-                }
-            } else {
-                match limits {
-                    ast::RangeLimits::Closed => {
-                        sugg + &sugg::ONE.into()
-                    },
-                    ast::RangeLimits::HalfOpen => sugg,
-                }
-            }
-        }
-    };
-
-    let start_str = Sugg::hir(cx, start, "").into();
-    let end_str: MinifyingSugg<'_> = Sugg::hir(cx, end, "").into();
-
-    let print_offset_and_limit = |idx_expr: &IndexExpr<'_>| match idx_expr.idx {
-        StartKind::Range => (
-            print_offset(apply_offset(&start_str, &idx_expr.idx_offset)).into_sugg(),
-            print_limit(
-                end,
-                end_str.as_str(),
-                idx_expr.base,
-                apply_offset(&end_str, &idx_expr.idx_offset),
-            )
-            .into_sugg(),
-        ),
-        StartKind::Counter { initializer } => {
-            let counter_start = Sugg::hir(cx, initializer, "").into();
-            (
-                print_offset(apply_offset(&counter_start, &idx_expr.idx_offset)).into_sugg(),
-                print_limit(
-                    end,
-                    end_str.as_str(),
-                    idx_expr.base,
-                    apply_offset(&end_str, &idx_expr.idx_offset) + &counter_start - &start_str,
-                )
-                .into_sugg(),
-            )
-        },
-    };
-
-    let (dst_offset, dst_limit) = print_offset_and_limit(&dst);
-    let (src_offset, src_limit) = print_offset_and_limit(&src);
-
-    let dst_base_str = snippet(cx, dst.base.span, "???");
-    let src_base_str = snippet(cx, src.base.span, "???");
-
-    let dst = if dst_offset == sugg::EMPTY && dst_limit == sugg::EMPTY {
-        dst_base_str
-    } else {
-        format!(
-            "{}[{}..{}]",
-            dst_base_str,
-            dst_offset.maybe_par(),
-            dst_limit.maybe_par()
-        )
-        .into()
-    };
-
-    format!(
-        "{}.clone_from_slice(&{}[{}..{}]);",
-        dst,
-        src_base_str,
-        src_offset.maybe_par(),
-        src_limit.maybe_par()
-    )
-}
-
-/// Checks for for loops that sequentially copy items from one slice-like
-/// object to another.
-fn detect_manual_memcpy<'tcx>(
-    cx: &LateContext<'tcx>,
-    pat: &'tcx Pat<'_>,
-    arg: &'tcx Expr<'_>,
-    body: &'tcx Expr<'_>,
-    expr: &'tcx Expr<'_>,
-) -> bool {
-    if let Some(higher::Range {
-        start: Some(start),
-        end: Some(end),
-        limits,
-    }) = higher::range(arg)
-    {
-        // the var must be a single name
-        if let PatKind::Binding(_, canonical_id, _, _) = pat.kind {
-            let mut starts = vec![Start {
-                id: canonical_id,
-                kind: StartKind::Range,
-            }];
-
-            // This is one of few ways to return different iterators
-            // derived from: https://stackoverflow.com/questions/29760668/conditionally-iterate-over-one-of-several-possible-iterators/52064434#52064434
-            let mut iter_a = None;
-            let mut iter_b = None;
-
-            if let ExprKind::Block(block, _) = body.kind {
-                if let Some(loop_counters) = get_loop_counters(cx, block, expr) {
-                    starts.extend(loop_counters);
-                }
-                iter_a = Some(get_assignments(block, &starts));
-            } else {
-                iter_b = Some(get_assignment(body));
-            }
-
-            let assignments = iter_a.into_iter().flatten().chain(iter_b.into_iter());
-
-            let big_sugg = assignments
-                // The only statements in the for loops can be indexed assignments from
-                // indexed retrievals (except increments of loop counters).
-                .map(|o| {
-                    o.and_then(|(lhs, rhs)| {
-                        let rhs = fetch_cloned_expr(rhs);
-                        if_chain! {
-                            if let ExprKind::Index(base_left, idx_left) = lhs.kind;
-                            if let ExprKind::Index(base_right, idx_right) = rhs.kind;
-                            if is_slice_like(cx, cx.typeck_results().expr_ty(base_left))
-                                && is_slice_like(cx, cx.typeck_results().expr_ty(base_right));
-                            if let Some((start_left, offset_left)) = get_details_from_idx(cx, &idx_left, &starts);
-                            if let Some((start_right, offset_right)) = get_details_from_idx(cx, &idx_right, &starts);
-
-                            // Source and destination must be different
-                            if path_to_local(base_left) != path_to_local(base_right);
-                            then {
-                                Some((IndexExpr { base: base_left, idx: start_left, idx_offset: offset_left },
-                                    IndexExpr { base: base_right, idx: start_right, idx_offset: offset_right }))
-                            } else {
-                                None
-                            }
-                        }
-                    })
-                })
-                .map(|o| o.map(|(dst, src)| build_manual_memcpy_suggestion(cx, start, end, limits, &dst, &src)))
-                .collect::<Option<Vec<_>>>()
-                .filter(|v| !v.is_empty())
-                .map(|v| v.join("\n    "));
-
-            if let Some(big_sugg) = big_sugg {
-                span_lint_and_sugg(
-                    cx,
-                    MANUAL_MEMCPY,
-                    get_span_of_entire_for_loop(expr),
-                    "it looks like you're manually copying between slices",
-                    "try replacing the loop by",
-                    big_sugg,
-                    Applicability::Unspecified,
-                );
-                return true;
-            }
-        }
-    }
-    false
-}
-
 fn is_used_inside<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, container: &'tcx Expr<'_>) -> bool {
     let def_id = match path_to_local(expr) {
         Some(id) => id,
@@ -1398,233 +1029,6 @@ fn is_simple_break_expr(expr: &Expr<'_>) -> bool {
     }
 }
 
-#[derive(Debug, PartialEq)]
-enum IncrementVisitorVarState {
-    Initial,  // Not examined yet
-    IncrOnce, // Incremented exactly once, may be a loop counter
-    DontWarn,
-}
-
-/// Scan a for loop for variables that are incremented exactly once and not used after that.
-struct IncrementVisitor<'a, 'tcx> {
-    cx: &'a LateContext<'tcx>,                          // context reference
-    states: FxHashMap<HirId, IncrementVisitorVarState>, // incremented variables
-    depth: u32,                                         // depth of conditional expressions
-    done: bool,
-}
-
-impl<'a, 'tcx> IncrementVisitor<'a, 'tcx> {
-    fn new(cx: &'a LateContext<'tcx>) -> Self {
-        Self {
-            cx,
-            states: FxHashMap::default(),
-            depth: 0,
-            done: false,
-        }
-    }
-
-    fn into_results(self) -> impl Iterator<Item = HirId> {
-        self.states.into_iter().filter_map(|(id, state)| {
-            if state == IncrementVisitorVarState::IncrOnce {
-                Some(id)
-            } else {
-                None
-            }
-        })
-    }
-}
-
-impl<'a, 'tcx> Visitor<'tcx> for IncrementVisitor<'a, 'tcx> {
-    type Map = Map<'tcx>;
-
-    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
-        if self.done {
-            return;
-        }
-
-        // If node is a variable
-        if let Some(def_id) = path_to_local(expr) {
-            if let Some(parent) = get_parent_expr(self.cx, expr) {
-                let state = self.states.entry(def_id).or_insert(IncrementVisitorVarState::Initial);
-                if *state == IncrementVisitorVarState::IncrOnce {
-                    *state = IncrementVisitorVarState::DontWarn;
-                    return;
-                }
-
-                match parent.kind {
-                    ExprKind::AssignOp(op, ref lhs, ref rhs) => {
-                        if lhs.hir_id == expr.hir_id {
-                            *state = if op.node == BinOpKind::Add
-                                && is_integer_const(self.cx, rhs, 1)
-                                && *state == IncrementVisitorVarState::Initial
-                                && self.depth == 0
-                            {
-                                IncrementVisitorVarState::IncrOnce
-                            } else {
-                                // Assigned some other value or assigned multiple times
-                                IncrementVisitorVarState::DontWarn
-                            };
-                        }
-                    },
-                    ExprKind::Assign(ref lhs, _, _) if lhs.hir_id == expr.hir_id => {
-                        *state = IncrementVisitorVarState::DontWarn
-                    },
-                    ExprKind::AddrOf(BorrowKind::Ref, mutability, _) if mutability == Mutability::Mut => {
-                        *state = IncrementVisitorVarState::DontWarn
-                    },
-                    _ => (),
-                }
-            }
-
-            walk_expr(self, expr);
-        } else if is_loop(expr) || is_conditional(expr) {
-            self.depth += 1;
-            walk_expr(self, expr);
-            self.depth -= 1;
-        } else if let ExprKind::Continue(_) = expr.kind {
-            self.done = true;
-        } else {
-            walk_expr(self, expr);
-        }
-    }
-    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-        NestedVisitorMap::None
-    }
-}
-
-enum InitializeVisitorState<'hir> {
-    Initial,          // Not examined yet
-    Declared(Symbol), // Declared but not (yet) initialized
-    Initialized {
-        name: Symbol,
-        initializer: &'hir Expr<'hir>,
-    },
-    DontWarn,
-}
-
-/// Checks whether a variable is initialized at the start of a loop and not modified
-/// and used after the loop.
-struct InitializeVisitor<'a, 'tcx> {
-    cx: &'a LateContext<'tcx>,  // context reference
-    end_expr: &'tcx Expr<'tcx>, // the for loop. Stop scanning here.
-    var_id: HirId,
-    state: InitializeVisitorState<'tcx>,
-    depth: u32, // depth of conditional expressions
-    past_loop: bool,
-}
-
-impl<'a, 'tcx> InitializeVisitor<'a, 'tcx> {
-    fn new(cx: &'a LateContext<'tcx>, end_expr: &'tcx Expr<'tcx>, var_id: HirId) -> Self {
-        Self {
-            cx,
-            end_expr,
-            var_id,
-            state: InitializeVisitorState::Initial,
-            depth: 0,
-            past_loop: false,
-        }
-    }
-
-    fn get_result(&self) -> Option<(Symbol, &'tcx Expr<'tcx>)> {
-        if let InitializeVisitorState::Initialized { name, initializer } = self.state {
-            Some((name, initializer))
-        } else {
-            None
-        }
-    }
-}
-
-impl<'a, 'tcx> Visitor<'tcx> for InitializeVisitor<'a, 'tcx> {
-    type Map = Map<'tcx>;
-
-    fn visit_stmt(&mut self, stmt: &'tcx Stmt<'_>) {
-        // Look for declarations of the variable
-        if_chain! {
-            if let StmtKind::Local(ref local) = stmt.kind;
-            if local.pat.hir_id == self.var_id;
-            if let PatKind::Binding(.., ident, _) = local.pat.kind;
-            then {
-                self.state = local.init.map_or(InitializeVisitorState::Declared(ident.name), |init| {
-                    InitializeVisitorState::Initialized {
-                        initializer: init,
-                        name: ident.name,
-                    }
-                })
-            }
-        }
-        walk_stmt(self, stmt);
-    }
-
-    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
-        if matches!(self.state, InitializeVisitorState::DontWarn) {
-            return;
-        }
-        if expr.hir_id == self.end_expr.hir_id {
-            self.past_loop = true;
-            return;
-        }
-        // No need to visit expressions before the variable is
-        // declared
-        if matches!(self.state, InitializeVisitorState::Initial) {
-            return;
-        }
-
-        // If node is the desired variable, see how it's used
-        if path_to_local_id(expr, self.var_id) {
-            if self.past_loop {
-                self.state = InitializeVisitorState::DontWarn;
-                return;
-            }
-
-            if let Some(parent) = get_parent_expr(self.cx, expr) {
-                match parent.kind {
-                    ExprKind::AssignOp(_, ref lhs, _) if lhs.hir_id == expr.hir_id => {
-                        self.state = InitializeVisitorState::DontWarn;
-                    },
-                    ExprKind::Assign(ref lhs, ref rhs, _) if lhs.hir_id == expr.hir_id => {
-                        self.state = if_chain! {
-                            if self.depth == 0;
-                            if let InitializeVisitorState::Declared(name)
-                                | InitializeVisitorState::Initialized { name, ..} = self.state;
-                            then {
-                                InitializeVisitorState::Initialized { initializer: rhs, name }
-                            } else {
-                                InitializeVisitorState::DontWarn
-                            }
-                        }
-                    },
-                    ExprKind::AddrOf(BorrowKind::Ref, mutability, _) if mutability == Mutability::Mut => {
-                        self.state = InitializeVisitorState::DontWarn
-                    },
-                    _ => (),
-                }
-            }
-
-            walk_expr(self, expr);
-        } else if !self.past_loop && is_loop(expr) {
-            self.state = InitializeVisitorState::DontWarn;
-        } else if is_conditional(expr) {
-            self.depth += 1;
-            walk_expr(self, expr);
-            self.depth -= 1;
-        } else {
-            walk_expr(self, expr);
-        }
-    }
-
-    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-        NestedVisitorMap::OnlyBodies(self.cx.tcx.hir())
-    }
-}
-
-fn is_loop(expr: &Expr<'_>) -> bool {
-    matches!(expr.kind, ExprKind::Loop(..))
-}
-
-fn is_conditional(expr: &Expr<'_>) -> bool {
-    matches!(expr.kind, ExprKind::If(..) | ExprKind::Match(..))
-}
-
 fn is_nested(cx: &LateContext<'_>, match_expr: &Expr<'_>, iter_expr: &Expr<'_>) -> bool {
     if_chain! {
         if let Some(loop_block) = get_enclosing_block(cx, match_expr.hir_id);
@@ -1659,10 +1063,10 @@ fn is_loop_nested(cx: &LateContext<'_>, loop_expr: &Expr<'_>, iter_expr: &Expr<'
                 let mut block_visitor = LoopNestVisitor {
                     hir_id: id,
                     iterator: iter_id,
-                    nesting: Unknown,
+                    nesting: Nesting::Unknown,
                 };
                 walk_block(&mut block_visitor, block);
-                if block_visitor.nesting == RuledOut {
+                if block_visitor.nesting == Nesting::RuledOut {
                     return false;
                 }
             },
@@ -1674,65 +1078,3 @@ fn is_loop_nested(cx: &LateContext<'_>, loop_expr: &Expr<'_>, iter_expr: &Expr<'
         id = parent;
     }
 }
-
-#[derive(PartialEq, Eq)]
-enum Nesting {
-    Unknown,     // no nesting detected yet
-    RuledOut,    // the iterator is initialized or assigned within scope
-    LookFurther, // no nesting detected, no further walk required
-}
-
-use self::Nesting::{LookFurther, RuledOut, Unknown};
-
-struct LoopNestVisitor {
-    hir_id: HirId,
-    iterator: HirId,
-    nesting: Nesting,
-}
-
-impl<'tcx> Visitor<'tcx> for LoopNestVisitor {
-    type Map = Map<'tcx>;
-
-    fn visit_stmt(&mut self, stmt: &'tcx Stmt<'_>) {
-        if stmt.hir_id == self.hir_id {
-            self.nesting = LookFurther;
-        } else if self.nesting == Unknown {
-            walk_stmt(self, stmt);
-        }
-    }
-
-    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
-        if self.nesting != Unknown {
-            return;
-        }
-        if expr.hir_id == self.hir_id {
-            self.nesting = LookFurther;
-            return;
-        }
-        match expr.kind {
-            ExprKind::Assign(ref path, _, _) | ExprKind::AssignOp(_, ref path, _) => {
-                if path_to_local_id(path, self.iterator) {
-                    self.nesting = RuledOut;
-                }
-            },
-            _ => walk_expr(self, expr),
-        }
-    }
-
-    fn visit_pat(&mut self, pat: &'tcx Pat<'_>) {
-        if self.nesting != Unknown {
-            return;
-        }
-        if let PatKind::Binding(_, id, ..) = pat.kind {
-            if id == self.iterator {
-                self.nesting = RuledOut;
-                return;
-            }
-        }
-        walk_pat(self, pat)
-    }
-
-    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-        NestedVisitorMap::None
-    }
-}
diff --git a/clippy_lints/src/loops/utils.rs b/clippy_lints/src/loops/utils.rs
index b9c934d5e54..9e38e17719a 100644
--- a/clippy_lints/src/loops/utils.rs
+++ b/clippy_lints/src/loops/utils.rs
@@ -1,8 +1,306 @@
-use crate::utils::{get_trait_def_id, has_iter_method, implements_trait, paths, sugg};
+use crate::utils::{
+    get_parent_expr, get_trait_def_id, has_iter_method, implements_trait, is_integer_const, path_to_local,
+    path_to_local_id, paths, sugg,
+};
+use if_chain::if_chain;
+use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::Applicability;
-use rustc_hir::{BorrowKind, Expr, ExprKind, Mutability};
+use rustc_hir::intravisit::{walk_expr, walk_pat, walk_stmt, NestedVisitorMap, Visitor};
+use rustc_hir::{BinOpKind, BorrowKind, Expr, ExprKind, HirId, Mutability, Pat, PatKind, Stmt, StmtKind};
 use rustc_lint::LateContext;
+use rustc_middle::hir::map::Map;
 use rustc_span::source_map::Span;
+use rustc_span::symbol::Symbol;
+use std::iter::Iterator;
+
+#[derive(Debug, PartialEq)]
+enum IncrementVisitorVarState {
+    Initial,  // Not examined yet
+    IncrOnce, // Incremented exactly once, may be a loop counter
+    DontWarn,
+}
+
+/// Scan a for loop for variables that are incremented exactly once and not used after that.
+pub(super) struct IncrementVisitor<'a, 'tcx> {
+    cx: &'a LateContext<'tcx>,                          // context reference
+    states: FxHashMap<HirId, IncrementVisitorVarState>, // incremented variables
+    depth: u32,                                         // depth of conditional expressions
+    done: bool,
+}
+
+impl<'a, 'tcx> IncrementVisitor<'a, 'tcx> {
+    pub(super) fn new(cx: &'a LateContext<'tcx>) -> Self {
+        Self {
+            cx,
+            states: FxHashMap::default(),
+            depth: 0,
+            done: false,
+        }
+    }
+
+    pub(super) fn into_results(self) -> impl Iterator<Item = HirId> {
+        self.states.into_iter().filter_map(|(id, state)| {
+            if state == IncrementVisitorVarState::IncrOnce {
+                Some(id)
+            } else {
+                None
+            }
+        })
+    }
+}
+
+impl<'a, 'tcx> Visitor<'tcx> for IncrementVisitor<'a, 'tcx> {
+    type Map = Map<'tcx>;
+
+    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
+        if self.done {
+            return;
+        }
+
+        // If node is a variable
+        if let Some(def_id) = path_to_local(expr) {
+            if let Some(parent) = get_parent_expr(self.cx, expr) {
+                let state = self.states.entry(def_id).or_insert(IncrementVisitorVarState::Initial);
+                if *state == IncrementVisitorVarState::IncrOnce {
+                    *state = IncrementVisitorVarState::DontWarn;
+                    return;
+                }
+
+                match parent.kind {
+                    ExprKind::AssignOp(op, ref lhs, ref rhs) => {
+                        if lhs.hir_id == expr.hir_id {
+                            *state = if op.node == BinOpKind::Add
+                                && is_integer_const(self.cx, rhs, 1)
+                                && *state == IncrementVisitorVarState::Initial
+                                && self.depth == 0
+                            {
+                                IncrementVisitorVarState::IncrOnce
+                            } else {
+                                // Assigned some other value or assigned multiple times
+                                IncrementVisitorVarState::DontWarn
+                            };
+                        }
+                    },
+                    ExprKind::Assign(ref lhs, _, _) if lhs.hir_id == expr.hir_id => {
+                        *state = IncrementVisitorVarState::DontWarn
+                    },
+                    ExprKind::AddrOf(BorrowKind::Ref, mutability, _) if mutability == Mutability::Mut => {
+                        *state = IncrementVisitorVarState::DontWarn
+                    },
+                    _ => (),
+                }
+            }
+
+            walk_expr(self, expr);
+        } else if is_loop(expr) || is_conditional(expr) {
+            self.depth += 1;
+            walk_expr(self, expr);
+            self.depth -= 1;
+        } else if let ExprKind::Continue(_) = expr.kind {
+            self.done = true;
+        } else {
+            walk_expr(self, expr);
+        }
+    }
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::None
+    }
+}
+
+enum InitializeVisitorState<'hir> {
+    Initial,          // Not examined yet
+    Declared(Symbol), // Declared but not (yet) initialized
+    Initialized {
+        name: Symbol,
+        initializer: &'hir Expr<'hir>,
+    },
+    DontWarn,
+}
+
+/// Checks whether a variable is initialized at the start of a loop and not modified
+/// and used after the loop.
+pub(super) struct InitializeVisitor<'a, 'tcx> {
+    cx: &'a LateContext<'tcx>,  // context reference
+    end_expr: &'tcx Expr<'tcx>, // the for loop. Stop scanning here.
+    var_id: HirId,
+    state: InitializeVisitorState<'tcx>,
+    depth: u32, // depth of conditional expressions
+    past_loop: bool,
+}
+
+impl<'a, 'tcx> InitializeVisitor<'a, 'tcx> {
+    pub(super) fn new(cx: &'a LateContext<'tcx>, end_expr: &'tcx Expr<'tcx>, var_id: HirId) -> Self {
+        Self {
+            cx,
+            end_expr,
+            var_id,
+            state: InitializeVisitorState::Initial,
+            depth: 0,
+            past_loop: false,
+        }
+    }
+
+    pub(super) fn get_result(&self) -> Option<(Symbol, &'tcx Expr<'tcx>)> {
+        if let InitializeVisitorState::Initialized { name, initializer } = self.state {
+            Some((name, initializer))
+        } else {
+            None
+        }
+    }
+}
+
+impl<'a, 'tcx> Visitor<'tcx> for InitializeVisitor<'a, 'tcx> {
+    type Map = Map<'tcx>;
+
+    fn visit_stmt(&mut self, stmt: &'tcx Stmt<'_>) {
+        // Look for declarations of the variable
+        if_chain! {
+            if let StmtKind::Local(ref local) = stmt.kind;
+            if local.pat.hir_id == self.var_id;
+            if let PatKind::Binding(.., ident, _) = local.pat.kind;
+            then {
+                self.state = local.init.map_or(InitializeVisitorState::Declared(ident.name), |init| {
+                    InitializeVisitorState::Initialized {
+                        initializer: init,
+                        name: ident.name,
+                    }
+                })
+            }
+        }
+        walk_stmt(self, stmt);
+    }
+
+    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
+        if matches!(self.state, InitializeVisitorState::DontWarn) {
+            return;
+        }
+        if expr.hir_id == self.end_expr.hir_id {
+            self.past_loop = true;
+            return;
+        }
+        // No need to visit expressions before the variable is
+        // declared
+        if matches!(self.state, InitializeVisitorState::Initial) {
+            return;
+        }
+
+        // If node is the desired variable, see how it's used
+        if path_to_local_id(expr, self.var_id) {
+            if self.past_loop {
+                self.state = InitializeVisitorState::DontWarn;
+                return;
+            }
+
+            if let Some(parent) = get_parent_expr(self.cx, expr) {
+                match parent.kind {
+                    ExprKind::AssignOp(_, ref lhs, _) if lhs.hir_id == expr.hir_id => {
+                        self.state = InitializeVisitorState::DontWarn;
+                    },
+                    ExprKind::Assign(ref lhs, ref rhs, _) if lhs.hir_id == expr.hir_id => {
+                        self.state = if_chain! {
+                            if self.depth == 0;
+                            if let InitializeVisitorState::Declared(name)
+                                | InitializeVisitorState::Initialized { name, ..} = self.state;
+                            then {
+                                InitializeVisitorState::Initialized { initializer: rhs, name }
+                            } else {
+                                InitializeVisitorState::DontWarn
+                            }
+                        }
+                    },
+                    ExprKind::AddrOf(BorrowKind::Ref, mutability, _) if mutability == Mutability::Mut => {
+                        self.state = InitializeVisitorState::DontWarn
+                    },
+                    _ => (),
+                }
+            }
+
+            walk_expr(self, expr);
+        } else if !self.past_loop && is_loop(expr) {
+            self.state = InitializeVisitorState::DontWarn;
+        } else if is_conditional(expr) {
+            self.depth += 1;
+            walk_expr(self, expr);
+            self.depth -= 1;
+        } else {
+            walk_expr(self, expr);
+        }
+    }
+
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::OnlyBodies(self.cx.tcx.hir())
+    }
+}
+
+fn is_loop(expr: &Expr<'_>) -> bool {
+    matches!(expr.kind, ExprKind::Loop(..))
+}
+
+fn is_conditional(expr: &Expr<'_>) -> bool {
+    matches!(expr.kind, ExprKind::If(..) | ExprKind::Match(..))
+}
+
+#[derive(PartialEq, Eq)]
+pub(super) enum Nesting {
+    Unknown,     // no nesting detected yet
+    RuledOut,    // the iterator is initialized or assigned within scope
+    LookFurther, // no nesting detected, no further walk required
+}
+
+use self::Nesting::{LookFurther, RuledOut, Unknown};
+
+pub(super) struct LoopNestVisitor {
+    pub(super) hir_id: HirId,
+    pub(super) iterator: HirId,
+    pub(super) nesting: Nesting,
+}
+
+impl<'tcx> Visitor<'tcx> for LoopNestVisitor {
+    type Map = Map<'tcx>;
+
+    fn visit_stmt(&mut self, stmt: &'tcx Stmt<'_>) {
+        if stmt.hir_id == self.hir_id {
+            self.nesting = LookFurther;
+        } else if self.nesting == Unknown {
+            walk_stmt(self, stmt);
+        }
+    }
+
+    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
+        if self.nesting != Unknown {
+            return;
+        }
+        if expr.hir_id == self.hir_id {
+            self.nesting = LookFurther;
+            return;
+        }
+        match expr.kind {
+            ExprKind::Assign(ref path, _, _) | ExprKind::AssignOp(_, ref path, _) => {
+                if path_to_local_id(path, self.iterator) {
+                    self.nesting = RuledOut;
+                }
+            },
+            _ => walk_expr(self, expr),
+        }
+    }
+
+    fn visit_pat(&mut self, pat: &'tcx Pat<'_>) {
+        if self.nesting != Unknown {
+            return;
+        }
+        if let PatKind::Binding(_, id, ..) = pat.kind {
+            if id == self.iterator {
+                self.nesting = RuledOut;
+                return;
+            }
+        }
+        walk_pat(self, pat)
+    }
+
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::None
+    }
+}
 
 // this function assumes the given expression is a `for` loop.
 pub(super) fn get_span_of_entire_for_loop(expr: &Expr<'_>) -> Span {
-- 
cgit 1.4.1-3-g733a5


From 455d0476b11c1a1a2ae8005e781c6ea9b2f4d2ac Mon Sep 17 00:00:00 2001
From: nahuakang <kangnahua@gmail.com>
Date: Sun, 21 Feb 2021 15:58:05 +0100
Subject: Refactor never loop to its own module

---
 clippy_lints/src/loops/mod.rs        | 173 +----------------------------------
 clippy_lints/src/loops/never_loop.rs | 172 ++++++++++++++++++++++++++++++++++
 2 files changed, 176 insertions(+), 169 deletions(-)
 create mode 100644 clippy_lints/src/loops/never_loop.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/mod.rs b/clippy_lints/src/loops/mod.rs
index c6055e34eb2..9a4cbf27c49 100644
--- a/clippy_lints/src/loops/mod.rs
+++ b/clippy_lints/src/loops/mod.rs
@@ -8,6 +8,7 @@ mod infinite_loop;
 mod manual_flatten;
 mod manual_memcpy;
 mod needless_collect;
+mod never_loop;
 mod same_item_push;
 mod utils;
 
@@ -16,21 +17,18 @@ use crate::utils::usage::mutated_variables;
 use crate::utils::{
     get_enclosing_block, get_trait_def_id, higher, implements_trait, is_in_panic_handler, is_no_std_crate,
     is_refutable, last_path_segment, match_trait_method, path_to_local, path_to_local_id, paths,
-    snippet_with_applicability, span_lint, span_lint_and_help, span_lint_and_sugg, sugg,
+    snippet_with_applicability, span_lint_and_help, span_lint_and_sugg, sugg,
 };
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_block, walk_expr, NestedVisitorMap, Visitor};
-use rustc_hir::{
-    Block, Expr, ExprKind, HirId, InlineAsmOperand, LoopSource, MatchSource, Node, Pat, PatKind, Stmt, StmtKind,
-};
+use rustc_hir::{Block, Expr, ExprKind, HirId, LoopSource, MatchSource, Node, Pat, PatKind, StmtKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::hir::map::Map;
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
 use rustc_span::symbol::sym;
-use std::iter::{once, Iterator};
 use utils::{
     get_span_of_entire_for_loop, make_iterator_snippet, IncrementVisitor, InitializeVisitor, LoopNestVisitor, Nesting,
 };
@@ -567,12 +565,7 @@ impl<'tcx> LateLintPass<'tcx> for Loops {
         }
 
         // check for never_loop
-        if let ExprKind::Loop(ref block, _, _, _) = expr.kind {
-            match never_loop_block(block, expr.hir_id) {
-                NeverLoopResult::AlwaysBreak => span_lint(cx, NEVER_LOOP, expr.span, "this loop never actually loops"),
-                NeverLoopResult::MayContinueMainLoop | NeverLoopResult::Otherwise => (),
-            }
-        }
+        never_loop::check_never_loop(cx, expr);
 
         // check for `loop { if let {} else break }` that could be `while let`
         // (also matches an explicit "match" instead of "if let")
@@ -689,164 +682,6 @@ impl<'tcx> LateLintPass<'tcx> for Loops {
     }
 }
 
-enum NeverLoopResult {
-    // A break/return always get triggered but not necessarily for the main loop.
-    AlwaysBreak,
-    // A continue may occur for the main loop.
-    MayContinueMainLoop,
-    Otherwise,
-}
-
-#[must_use]
-fn absorb_break(arg: &NeverLoopResult) -> NeverLoopResult {
-    match *arg {
-        NeverLoopResult::AlwaysBreak | NeverLoopResult::Otherwise => NeverLoopResult::Otherwise,
-        NeverLoopResult::MayContinueMainLoop => NeverLoopResult::MayContinueMainLoop,
-    }
-}
-
-// Combine two results for parts that are called in order.
-#[must_use]
-fn combine_seq(first: NeverLoopResult, second: NeverLoopResult) -> NeverLoopResult {
-    match first {
-        NeverLoopResult::AlwaysBreak | NeverLoopResult::MayContinueMainLoop => first,
-        NeverLoopResult::Otherwise => second,
-    }
-}
-
-// Combine two results where both parts are called but not necessarily in order.
-#[must_use]
-fn combine_both(left: NeverLoopResult, right: NeverLoopResult) -> NeverLoopResult {
-    match (left, right) {
-        (NeverLoopResult::MayContinueMainLoop, _) | (_, NeverLoopResult::MayContinueMainLoop) => {
-            NeverLoopResult::MayContinueMainLoop
-        },
-        (NeverLoopResult::AlwaysBreak, _) | (_, NeverLoopResult::AlwaysBreak) => NeverLoopResult::AlwaysBreak,
-        (NeverLoopResult::Otherwise, NeverLoopResult::Otherwise) => NeverLoopResult::Otherwise,
-    }
-}
-
-// Combine two results where only one of the part may have been executed.
-#[must_use]
-fn combine_branches(b1: NeverLoopResult, b2: NeverLoopResult) -> NeverLoopResult {
-    match (b1, b2) {
-        (NeverLoopResult::AlwaysBreak, NeverLoopResult::AlwaysBreak) => NeverLoopResult::AlwaysBreak,
-        (NeverLoopResult::MayContinueMainLoop, _) | (_, NeverLoopResult::MayContinueMainLoop) => {
-            NeverLoopResult::MayContinueMainLoop
-        },
-        (NeverLoopResult::Otherwise, _) | (_, NeverLoopResult::Otherwise) => NeverLoopResult::Otherwise,
-    }
-}
-
-fn never_loop_block(block: &Block<'_>, main_loop_id: HirId) -> NeverLoopResult {
-    let stmts = block.stmts.iter().map(stmt_to_expr);
-    let expr = once(block.expr.as_deref());
-    let mut iter = stmts.chain(expr).flatten();
-    never_loop_expr_seq(&mut iter, main_loop_id)
-}
-
-fn stmt_to_expr<'tcx>(stmt: &Stmt<'tcx>) -> Option<&'tcx Expr<'tcx>> {
-    match stmt.kind {
-        StmtKind::Semi(ref e, ..) | StmtKind::Expr(ref e, ..) => Some(e),
-        StmtKind::Local(ref local) => local.init.as_deref(),
-        _ => None,
-    }
-}
-
-fn never_loop_expr(expr: &Expr<'_>, main_loop_id: HirId) -> NeverLoopResult {
-    match expr.kind {
-        ExprKind::Box(ref e)
-        | ExprKind::Unary(_, ref e)
-        | ExprKind::Cast(ref e, _)
-        | ExprKind::Type(ref e, _)
-        | ExprKind::Field(ref e, _)
-        | ExprKind::AddrOf(_, _, ref e)
-        | ExprKind::Struct(_, _, Some(ref e))
-        | ExprKind::Repeat(ref e, _)
-        | ExprKind::DropTemps(ref e) => never_loop_expr(e, main_loop_id),
-        ExprKind::Array(ref es) | ExprKind::MethodCall(_, _, ref es, _) | ExprKind::Tup(ref es) => {
-            never_loop_expr_all(&mut es.iter(), main_loop_id)
-        },
-        ExprKind::Call(ref e, ref es) => never_loop_expr_all(&mut once(&**e).chain(es.iter()), main_loop_id),
-        ExprKind::Binary(_, ref e1, ref e2)
-        | ExprKind::Assign(ref e1, ref e2, _)
-        | ExprKind::AssignOp(_, ref e1, ref e2)
-        | ExprKind::Index(ref e1, ref e2) => never_loop_expr_all(&mut [&**e1, &**e2].iter().cloned(), main_loop_id),
-        ExprKind::Loop(ref b, _, _, _) => {
-            // Break can come from the inner loop so remove them.
-            absorb_break(&never_loop_block(b, main_loop_id))
-        },
-        ExprKind::If(ref e, ref e2, ref e3) => {
-            let e1 = never_loop_expr(e, main_loop_id);
-            let e2 = never_loop_expr(e2, main_loop_id);
-            let e3 = e3
-                .as_ref()
-                .map_or(NeverLoopResult::Otherwise, |e| never_loop_expr(e, main_loop_id));
-            combine_seq(e1, combine_branches(e2, e3))
-        },
-        ExprKind::Match(ref e, ref arms, _) => {
-            let e = never_loop_expr(e, main_loop_id);
-            if arms.is_empty() {
-                e
-            } else {
-                let arms = never_loop_expr_branch(&mut arms.iter().map(|a| &*a.body), main_loop_id);
-                combine_seq(e, arms)
-            }
-        },
-        ExprKind::Block(ref b, _) => never_loop_block(b, main_loop_id),
-        ExprKind::Continue(d) => {
-            let id = d
-                .target_id
-                .expect("target ID can only be missing in the presence of compilation errors");
-            if id == main_loop_id {
-                NeverLoopResult::MayContinueMainLoop
-            } else {
-                NeverLoopResult::AlwaysBreak
-            }
-        },
-        ExprKind::Break(_, ref e) | ExprKind::Ret(ref e) => e.as_ref().map_or(NeverLoopResult::AlwaysBreak, |e| {
-            combine_seq(never_loop_expr(e, main_loop_id), NeverLoopResult::AlwaysBreak)
-        }),
-        ExprKind::InlineAsm(ref asm) => asm
-            .operands
-            .iter()
-            .map(|(o, _)| match o {
-                InlineAsmOperand::In { expr, .. }
-                | InlineAsmOperand::InOut { expr, .. }
-                | InlineAsmOperand::Const { expr }
-                | InlineAsmOperand::Sym { expr } => never_loop_expr(expr, main_loop_id),
-                InlineAsmOperand::Out { expr, .. } => never_loop_expr_all(&mut expr.iter(), main_loop_id),
-                InlineAsmOperand::SplitInOut { in_expr, out_expr, .. } => {
-                    never_loop_expr_all(&mut once(in_expr).chain(out_expr.iter()), main_loop_id)
-                },
-            })
-            .fold(NeverLoopResult::Otherwise, combine_both),
-        ExprKind::Struct(_, _, None)
-        | ExprKind::Yield(_, _)
-        | ExprKind::Closure(_, _, _, _, _)
-        | ExprKind::LlvmInlineAsm(_)
-        | ExprKind::Path(_)
-        | ExprKind::ConstBlock(_)
-        | ExprKind::Lit(_)
-        | ExprKind::Err => NeverLoopResult::Otherwise,
-    }
-}
-
-fn never_loop_expr_seq<'a, T: Iterator<Item = &'a Expr<'a>>>(es: &mut T, main_loop_id: HirId) -> NeverLoopResult {
-    es.map(|e| never_loop_expr(e, main_loop_id))
-        .fold(NeverLoopResult::Otherwise, combine_seq)
-}
-
-fn never_loop_expr_all<'a, T: Iterator<Item = &'a Expr<'a>>>(es: &mut T, main_loop_id: HirId) -> NeverLoopResult {
-    es.map(|e| never_loop_expr(e, main_loop_id))
-        .fold(NeverLoopResult::Otherwise, combine_both)
-}
-
-fn never_loop_expr_branch<'a, T: Iterator<Item = &'a Expr<'a>>>(e: &mut T, main_loop_id: HirId) -> NeverLoopResult {
-    e.map(|e| never_loop_expr(e, main_loop_id))
-        .fold(NeverLoopResult::AlwaysBreak, combine_branches)
-}
-
 fn check_for_loop<'tcx>(
     cx: &LateContext<'tcx>,
     pat: &'tcx Pat<'_>,
diff --git a/clippy_lints/src/loops/never_loop.rs b/clippy_lints/src/loops/never_loop.rs
new file mode 100644
index 00000000000..d51ff81103f
--- /dev/null
+++ b/clippy_lints/src/loops/never_loop.rs
@@ -0,0 +1,172 @@
+use super::NEVER_LOOP;
+use crate::utils::span_lint;
+use rustc_hir::{Block, Expr, ExprKind, HirId, InlineAsmOperand, Stmt, StmtKind};
+use rustc_lint::LateContext;
+use std::iter::{once, Iterator};
+
+pub(super) fn check_never_loop(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+    if let ExprKind::Loop(ref block, _, _, _) = expr.kind {
+        match never_loop_block(block, expr.hir_id) {
+            NeverLoopResult::AlwaysBreak => span_lint(cx, NEVER_LOOP, expr.span, "this loop never actually loops"),
+            NeverLoopResult::MayContinueMainLoop | NeverLoopResult::Otherwise => (),
+        }
+    }
+}
+
+enum NeverLoopResult {
+    // A break/return always get triggered but not necessarily for the main loop.
+    AlwaysBreak,
+    // A continue may occur for the main loop.
+    MayContinueMainLoop,
+    Otherwise,
+}
+
+#[must_use]
+fn absorb_break(arg: &NeverLoopResult) -> NeverLoopResult {
+    match *arg {
+        NeverLoopResult::AlwaysBreak | NeverLoopResult::Otherwise => NeverLoopResult::Otherwise,
+        NeverLoopResult::MayContinueMainLoop => NeverLoopResult::MayContinueMainLoop,
+    }
+}
+
+// Combine two results for parts that are called in order.
+#[must_use]
+fn combine_seq(first: NeverLoopResult, second: NeverLoopResult) -> NeverLoopResult {
+    match first {
+        NeverLoopResult::AlwaysBreak | NeverLoopResult::MayContinueMainLoop => first,
+        NeverLoopResult::Otherwise => second,
+    }
+}
+
+// Combine two results where both parts are called but not necessarily in order.
+#[must_use]
+fn combine_both(left: NeverLoopResult, right: NeverLoopResult) -> NeverLoopResult {
+    match (left, right) {
+        (NeverLoopResult::MayContinueMainLoop, _) | (_, NeverLoopResult::MayContinueMainLoop) => {
+            NeverLoopResult::MayContinueMainLoop
+        },
+        (NeverLoopResult::AlwaysBreak, _) | (_, NeverLoopResult::AlwaysBreak) => NeverLoopResult::AlwaysBreak,
+        (NeverLoopResult::Otherwise, NeverLoopResult::Otherwise) => NeverLoopResult::Otherwise,
+    }
+}
+
+// Combine two results where only one of the part may have been executed.
+#[must_use]
+fn combine_branches(b1: NeverLoopResult, b2: NeverLoopResult) -> NeverLoopResult {
+    match (b1, b2) {
+        (NeverLoopResult::AlwaysBreak, NeverLoopResult::AlwaysBreak) => NeverLoopResult::AlwaysBreak,
+        (NeverLoopResult::MayContinueMainLoop, _) | (_, NeverLoopResult::MayContinueMainLoop) => {
+            NeverLoopResult::MayContinueMainLoop
+        },
+        (NeverLoopResult::Otherwise, _) | (_, NeverLoopResult::Otherwise) => NeverLoopResult::Otherwise,
+    }
+}
+
+fn never_loop_block(block: &Block<'_>, main_loop_id: HirId) -> NeverLoopResult {
+    let stmts = block.stmts.iter().map(stmt_to_expr);
+    let expr = once(block.expr.as_deref());
+    let mut iter = stmts.chain(expr).flatten();
+    never_loop_expr_seq(&mut iter, main_loop_id)
+}
+
+fn never_loop_expr_seq<'a, T: Iterator<Item = &'a Expr<'a>>>(es: &mut T, main_loop_id: HirId) -> NeverLoopResult {
+    es.map(|e| never_loop_expr(e, main_loop_id))
+        .fold(NeverLoopResult::Otherwise, combine_seq)
+}
+
+fn stmt_to_expr<'tcx>(stmt: &Stmt<'tcx>) -> Option<&'tcx Expr<'tcx>> {
+    match stmt.kind {
+        StmtKind::Semi(ref e, ..) | StmtKind::Expr(ref e, ..) => Some(e),
+        StmtKind::Local(ref local) => local.init.as_deref(),
+        _ => None,
+    }
+}
+
+fn never_loop_expr(expr: &Expr<'_>, main_loop_id: HirId) -> NeverLoopResult {
+    match expr.kind {
+        ExprKind::Box(ref e)
+        | ExprKind::Unary(_, ref e)
+        | ExprKind::Cast(ref e, _)
+        | ExprKind::Type(ref e, _)
+        | ExprKind::Field(ref e, _)
+        | ExprKind::AddrOf(_, _, ref e)
+        | ExprKind::Struct(_, _, Some(ref e))
+        | ExprKind::Repeat(ref e, _)
+        | ExprKind::DropTemps(ref e) => never_loop_expr(e, main_loop_id),
+        ExprKind::Array(ref es) | ExprKind::MethodCall(_, _, ref es, _) | ExprKind::Tup(ref es) => {
+            never_loop_expr_all(&mut es.iter(), main_loop_id)
+        },
+        ExprKind::Call(ref e, ref es) => never_loop_expr_all(&mut once(&**e).chain(es.iter()), main_loop_id),
+        ExprKind::Binary(_, ref e1, ref e2)
+        | ExprKind::Assign(ref e1, ref e2, _)
+        | ExprKind::AssignOp(_, ref e1, ref e2)
+        | ExprKind::Index(ref e1, ref e2) => never_loop_expr_all(&mut [&**e1, &**e2].iter().cloned(), main_loop_id),
+        ExprKind::Loop(ref b, _, _, _) => {
+            // Break can come from the inner loop so remove them.
+            absorb_break(&never_loop_block(b, main_loop_id))
+        },
+        ExprKind::If(ref e, ref e2, ref e3) => {
+            let e1 = never_loop_expr(e, main_loop_id);
+            let e2 = never_loop_expr(e2, main_loop_id);
+            let e3 = e3
+                .as_ref()
+                .map_or(NeverLoopResult::Otherwise, |e| never_loop_expr(e, main_loop_id));
+            combine_seq(e1, combine_branches(e2, e3))
+        },
+        ExprKind::Match(ref e, ref arms, _) => {
+            let e = never_loop_expr(e, main_loop_id);
+            if arms.is_empty() {
+                e
+            } else {
+                let arms = never_loop_expr_branch(&mut arms.iter().map(|a| &*a.body), main_loop_id);
+                combine_seq(e, arms)
+            }
+        },
+        ExprKind::Block(ref b, _) => never_loop_block(b, main_loop_id),
+        ExprKind::Continue(d) => {
+            let id = d
+                .target_id
+                .expect("target ID can only be missing in the presence of compilation errors");
+            if id == main_loop_id {
+                NeverLoopResult::MayContinueMainLoop
+            } else {
+                NeverLoopResult::AlwaysBreak
+            }
+        },
+        ExprKind::Break(_, ref e) | ExprKind::Ret(ref e) => e.as_ref().map_or(NeverLoopResult::AlwaysBreak, |e| {
+            combine_seq(never_loop_expr(e, main_loop_id), NeverLoopResult::AlwaysBreak)
+        }),
+        ExprKind::InlineAsm(ref asm) => asm
+            .operands
+            .iter()
+            .map(|(o, _)| match o {
+                InlineAsmOperand::In { expr, .. }
+                | InlineAsmOperand::InOut { expr, .. }
+                | InlineAsmOperand::Const { expr }
+                | InlineAsmOperand::Sym { expr } => never_loop_expr(expr, main_loop_id),
+                InlineAsmOperand::Out { expr, .. } => never_loop_expr_all(&mut expr.iter(), main_loop_id),
+                InlineAsmOperand::SplitInOut { in_expr, out_expr, .. } => {
+                    never_loop_expr_all(&mut once(in_expr).chain(out_expr.iter()), main_loop_id)
+                },
+            })
+            .fold(NeverLoopResult::Otherwise, combine_both),
+        ExprKind::Struct(_, _, None)
+        | ExprKind::Yield(_, _)
+        | ExprKind::Closure(_, _, _, _, _)
+        | ExprKind::LlvmInlineAsm(_)
+        | ExprKind::Path(_)
+        | ExprKind::ConstBlock(_)
+        | ExprKind::Lit(_)
+        | ExprKind::Err => NeverLoopResult::Otherwise,
+    }
+}
+
+fn never_loop_expr_all<'a, T: Iterator<Item = &'a Expr<'a>>>(es: &mut T, main_loop_id: HirId) -> NeverLoopResult {
+    es.map(|e| never_loop_expr(e, main_loop_id))
+        .fold(NeverLoopResult::Otherwise, combine_both)
+}
+
+fn never_loop_expr_branch<'a, T: Iterator<Item = &'a Expr<'a>>>(e: &mut T, main_loop_id: HirId) -> NeverLoopResult {
+    e.map(|e| never_loop_expr(e, main_loop_id))
+        .fold(NeverLoopResult::AlwaysBreak, combine_branches)
+}
-- 
cgit 1.4.1-3-g733a5


From d0b657c0b7335ccb4a594af100ab49d8bd660e97 Mon Sep 17 00:00:00 2001
From: nahuakang <kangnahua@gmail.com>
Date: Sun, 21 Feb 2021 16:37:09 +0100
Subject: Refactor while let on iterator lint to its module; rename for loop
 explicit counter to explicit counter loop

---
 clippy_lints/src/loops/explicit_counter_loop.rs    |  56 +++++++
 .../src/loops/for_loop_explicit_counter.rs         |  56 -------
 clippy_lints/src/loops/mod.rs                      | 174 +--------------------
 clippy_lints/src/loops/while_let_on_iterator.rs    | 171 ++++++++++++++++++++
 4 files changed, 235 insertions(+), 222 deletions(-)
 create mode 100644 clippy_lints/src/loops/explicit_counter_loop.rs
 delete mode 100644 clippy_lints/src/loops/for_loop_explicit_counter.rs
 create mode 100644 clippy_lints/src/loops/while_let_on_iterator.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/explicit_counter_loop.rs b/clippy_lints/src/loops/explicit_counter_loop.rs
new file mode 100644
index 00000000000..68fee269eb1
--- /dev/null
+++ b/clippy_lints/src/loops/explicit_counter_loop.rs
@@ -0,0 +1,56 @@
+use super::{get_span_of_entire_for_loop, make_iterator_snippet, IncrementVisitor, InitializeVisitor};
+use crate::utils::{get_enclosing_block, is_integer_const, snippet_with_applicability, span_lint_and_sugg};
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir::intravisit::{walk_block, walk_expr};
+use rustc_hir::{Expr, Pat};
+use rustc_lint::LateContext;
+
+// To trigger the EXPLICIT_COUNTER_LOOP lint, a variable must be
+// incremented exactly once in the loop body, and initialized to zero
+// at the start of the loop.
+pub(super) fn check_for_loop_explicit_counter<'tcx>(
+    cx: &LateContext<'tcx>,
+    pat: &'tcx Pat<'_>,
+    arg: &'tcx Expr<'_>,
+    body: &'tcx Expr<'_>,
+    expr: &'tcx Expr<'_>,
+) {
+    // Look for variables that are incremented once per loop iteration.
+    let mut increment_visitor = IncrementVisitor::new(cx);
+    walk_expr(&mut increment_visitor, body);
+
+    // For each candidate, check the parent block to see if
+    // it's initialized to zero at the start of the loop.
+    if let Some(block) = get_enclosing_block(&cx, expr.hir_id) {
+        for id in increment_visitor.into_results() {
+            let mut initialize_visitor = InitializeVisitor::new(cx, expr, id);
+            walk_block(&mut initialize_visitor, block);
+
+            if_chain! {
+                if let Some((name, initializer)) = initialize_visitor.get_result();
+                if is_integer_const(cx, initializer, 0);
+                then {
+                    let mut applicability = Applicability::MachineApplicable;
+
+                    let for_span = get_span_of_entire_for_loop(expr);
+
+                    span_lint_and_sugg(
+                        cx,
+                        super::EXPLICIT_COUNTER_LOOP,
+                        for_span.with_hi(arg.span.hi()),
+                        &format!("the variable `{}` is used as a loop counter", name),
+                        "consider using",
+                        format!(
+                            "for ({}, {}) in {}.enumerate()",
+                            name,
+                            snippet_with_applicability(cx, pat.span, "item", &mut applicability),
+                            make_iterator_snippet(cx, arg, &mut applicability),
+                        ),
+                        applicability,
+                    );
+                }
+            }
+        }
+    }
+}
diff --git a/clippy_lints/src/loops/for_loop_explicit_counter.rs b/clippy_lints/src/loops/for_loop_explicit_counter.rs
deleted file mode 100644
index 68fee269eb1..00000000000
--- a/clippy_lints/src/loops/for_loop_explicit_counter.rs
+++ /dev/null
@@ -1,56 +0,0 @@
-use super::{get_span_of_entire_for_loop, make_iterator_snippet, IncrementVisitor, InitializeVisitor};
-use crate::utils::{get_enclosing_block, is_integer_const, snippet_with_applicability, span_lint_and_sugg};
-use if_chain::if_chain;
-use rustc_errors::Applicability;
-use rustc_hir::intravisit::{walk_block, walk_expr};
-use rustc_hir::{Expr, Pat};
-use rustc_lint::LateContext;
-
-// To trigger the EXPLICIT_COUNTER_LOOP lint, a variable must be
-// incremented exactly once in the loop body, and initialized to zero
-// at the start of the loop.
-pub(super) fn check_for_loop_explicit_counter<'tcx>(
-    cx: &LateContext<'tcx>,
-    pat: &'tcx Pat<'_>,
-    arg: &'tcx Expr<'_>,
-    body: &'tcx Expr<'_>,
-    expr: &'tcx Expr<'_>,
-) {
-    // Look for variables that are incremented once per loop iteration.
-    let mut increment_visitor = IncrementVisitor::new(cx);
-    walk_expr(&mut increment_visitor, body);
-
-    // For each candidate, check the parent block to see if
-    // it's initialized to zero at the start of the loop.
-    if let Some(block) = get_enclosing_block(&cx, expr.hir_id) {
-        for id in increment_visitor.into_results() {
-            let mut initialize_visitor = InitializeVisitor::new(cx, expr, id);
-            walk_block(&mut initialize_visitor, block);
-
-            if_chain! {
-                if let Some((name, initializer)) = initialize_visitor.get_result();
-                if is_integer_const(cx, initializer, 0);
-                then {
-                    let mut applicability = Applicability::MachineApplicable;
-
-                    let for_span = get_span_of_entire_for_loop(expr);
-
-                    span_lint_and_sugg(
-                        cx,
-                        super::EXPLICIT_COUNTER_LOOP,
-                        for_span.with_hi(arg.span.hi()),
-                        &format!("the variable `{}` is used as a loop counter", name),
-                        "consider using",
-                        format!(
-                            "for ({}, {}) in {}.enumerate()",
-                            name,
-                            snippet_with_applicability(cx, pat.span, "item", &mut applicability),
-                            make_iterator_snippet(cx, arg, &mut applicability),
-                        ),
-                        applicability,
-                    );
-                }
-            }
-        }
-    }
-}
diff --git a/clippy_lints/src/loops/mod.rs b/clippy_lints/src/loops/mod.rs
index 9a4cbf27c49..cadf9241256 100644
--- a/clippy_lints/src/loops/mod.rs
+++ b/clippy_lints/src/loops/mod.rs
@@ -1,5 +1,5 @@
+mod explicit_counter_loop;
 mod for_loop_arg;
-mod for_loop_explicit_counter;
 mod for_loop_over_map_kv;
 mod for_loop_range;
 mod for_mut_range_bound;
@@ -11,27 +11,20 @@ mod needless_collect;
 mod never_loop;
 mod same_item_push;
 mod utils;
+mod while_let_on_iterator;
 
 use crate::utils::sugg::Sugg;
-use crate::utils::usage::mutated_variables;
 use crate::utils::{
-    get_enclosing_block, get_trait_def_id, higher, implements_trait, is_in_panic_handler, is_no_std_crate,
-    is_refutable, last_path_segment, match_trait_method, path_to_local, path_to_local_id, paths,
-    snippet_with_applicability, span_lint_and_help, span_lint_and_sugg, sugg,
+    higher, is_in_panic_handler, is_no_std_crate, snippet_with_applicability, span_lint_and_help, span_lint_and_sugg,
+    sugg,
 };
-use if_chain::if_chain;
 use rustc_errors::Applicability;
-use rustc_hir::intravisit::{walk_block, walk_expr, NestedVisitorMap, Visitor};
-use rustc_hir::{Block, Expr, ExprKind, HirId, LoopSource, MatchSource, Node, Pat, PatKind, StmtKind};
+use rustc_hir::{Block, Expr, ExprKind, LoopSource, MatchSource, Pat, StmtKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
-use rustc_middle::hir::map::Map;
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
-use rustc_span::symbol::sym;
-use utils::{
-    get_span_of_entire_for_loop, make_iterator_snippet, IncrementVisitor, InitializeVisitor, LoopNestVisitor, Nesting,
-};
+use utils::{get_span_of_entire_for_loop, make_iterator_snippet, IncrementVisitor, InitializeVisitor};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for for-loops that manually copy items between
@@ -625,54 +618,8 @@ impl<'tcx> LateLintPass<'tcx> for Loops {
                 }
             }
         }
-        if let ExprKind::Match(ref match_expr, ref arms, MatchSource::WhileLetDesugar) = expr.kind {
-            let pat = &arms[0].pat.kind;
-            if let (
-                &PatKind::TupleStruct(ref qpath, ref pat_args, _),
-                &ExprKind::MethodCall(ref method_path, _, ref method_args, _),
-            ) = (pat, &match_expr.kind)
-            {
-                let iter_expr = &method_args[0];
-
-                // Don't lint when the iterator is recreated on every iteration
-                if_chain! {
-                    if let ExprKind::MethodCall(..) | ExprKind::Call(..) = iter_expr.kind;
-                    if let Some(iter_def_id) = get_trait_def_id(cx, &paths::ITERATOR);
-                    if implements_trait(cx, cx.typeck_results().expr_ty(iter_expr), iter_def_id, &[]);
-                    then {
-                        return;
-                    }
-                }
 
-                let lhs_constructor = last_path_segment(qpath);
-                if method_path.ident.name == sym::next
-                    && match_trait_method(cx, match_expr, &paths::ITERATOR)
-                    && lhs_constructor.ident.name == sym::Some
-                    && (pat_args.is_empty()
-                        || !is_refutable(cx, &pat_args[0])
-                            && !is_used_inside(cx, iter_expr, &arms[0].body)
-                            && !is_iterator_used_after_while_let(cx, iter_expr)
-                            && !is_nested(cx, expr, &method_args[0]))
-                {
-                    let mut applicability = Applicability::MachineApplicable;
-                    let iterator = snippet_with_applicability(cx, method_args[0].span, "_", &mut applicability);
-                    let loop_var = if pat_args.is_empty() {
-                        "_".to_string()
-                    } else {
-                        snippet_with_applicability(cx, pat_args[0].span, "_", &mut applicability).into_owned()
-                    };
-                    span_lint_and_sugg(
-                        cx,
-                        WHILE_LET_ON_ITERATOR,
-                        expr.span.with_hi(match_expr.span.hi()),
-                        "this loop could be written as a `for` loop",
-                        "try",
-                        format!("for {} in {}", loop_var, iterator),
-                        applicability,
-                    );
-                }
-            }
-        }
+        while_let_on_iterator::check_while_let_on_iterator(cx, expr);
 
         if let Some((cond, body)) = higher::while_loop(&expr) {
             infinite_loop::check_infinite_loop(cx, cond, body);
@@ -693,7 +640,7 @@ fn check_for_loop<'tcx>(
     let is_manual_memcpy_triggered = manual_memcpy::detect_manual_memcpy(cx, pat, arg, body, expr);
     if !is_manual_memcpy_triggered {
         for_loop_range::check_for_loop_range(cx, pat, arg, body, expr);
-        for_loop_explicit_counter::check_for_loop_explicit_counter(cx, pat, arg, body, expr);
+        explicit_counter_loop::check_for_loop_explicit_counter(cx, pat, arg, body, expr);
     }
     for_loop_arg::check_for_loop_arg(cx, pat, arg, expr);
     for_loop_over_map_kv::check_for_loop_over_map_kv(cx, pat, arg, body, expr);
@@ -773,61 +720,6 @@ impl std::ops::Sub<&MinifyingSugg<'static>> for MinifyingSugg<'static> {
     }
 }
 
-fn is_used_inside<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, container: &'tcx Expr<'_>) -> bool {
-    let def_id = match path_to_local(expr) {
-        Some(id) => id,
-        None => return false,
-    };
-    if let Some(used_mutably) = mutated_variables(container, cx) {
-        if used_mutably.contains(&def_id) {
-            return true;
-        }
-    }
-    false
-}
-
-fn is_iterator_used_after_while_let<'tcx>(cx: &LateContext<'tcx>, iter_expr: &'tcx Expr<'_>) -> bool {
-    let def_id = match path_to_local(iter_expr) {
-        Some(id) => id,
-        None => return false,
-    };
-    let mut visitor = VarUsedAfterLoopVisitor {
-        def_id,
-        iter_expr_id: iter_expr.hir_id,
-        past_while_let: false,
-        var_used_after_while_let: false,
-    };
-    if let Some(enclosing_block) = get_enclosing_block(cx, def_id) {
-        walk_block(&mut visitor, enclosing_block);
-    }
-    visitor.var_used_after_while_let
-}
-
-struct VarUsedAfterLoopVisitor {
-    def_id: HirId,
-    iter_expr_id: HirId,
-    past_while_let: bool,
-    var_used_after_while_let: bool,
-}
-
-impl<'tcx> Visitor<'tcx> for VarUsedAfterLoopVisitor {
-    type Map = Map<'tcx>;
-
-    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
-        if self.past_while_let {
-            if path_to_local_id(expr, self.def_id) {
-                self.var_used_after_while_let = true;
-            }
-        } else if self.iter_expr_id == expr.hir_id {
-            self.past_while_let = true;
-        }
-        walk_expr(self, expr);
-    }
-    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-        NestedVisitorMap::None
-    }
-}
-
 /// If a block begins with a statement (possibly a `let` binding) and has an
 /// expression, return it.
 fn extract_expr_from_first_stmt<'tcx>(block: &Block<'tcx>) -> Option<&'tcx Expr<'tcx>> {
@@ -863,53 +755,3 @@ fn is_simple_break_expr(expr: &Expr<'_>) -> bool {
         _ => false,
     }
 }
-
-fn is_nested(cx: &LateContext<'_>, match_expr: &Expr<'_>, iter_expr: &Expr<'_>) -> bool {
-    if_chain! {
-        if let Some(loop_block) = get_enclosing_block(cx, match_expr.hir_id);
-        let parent_node = cx.tcx.hir().get_parent_node(loop_block.hir_id);
-        if let Some(Node::Expr(loop_expr)) = cx.tcx.hir().find(parent_node);
-        then {
-            return is_loop_nested(cx, loop_expr, iter_expr)
-        }
-    }
-    false
-}
-
-fn is_loop_nested(cx: &LateContext<'_>, loop_expr: &Expr<'_>, iter_expr: &Expr<'_>) -> bool {
-    let mut id = loop_expr.hir_id;
-    let iter_id = if let Some(id) = path_to_local(iter_expr) {
-        id
-    } else {
-        return true;
-    };
-    loop {
-        let parent = cx.tcx.hir().get_parent_node(id);
-        if parent == id {
-            return false;
-        }
-        match cx.tcx.hir().find(parent) {
-            Some(Node::Expr(expr)) => {
-                if let ExprKind::Loop(..) = expr.kind {
-                    return true;
-                };
-            },
-            Some(Node::Block(block)) => {
-                let mut block_visitor = LoopNestVisitor {
-                    hir_id: id,
-                    iterator: iter_id,
-                    nesting: Nesting::Unknown,
-                };
-                walk_block(&mut block_visitor, block);
-                if block_visitor.nesting == Nesting::RuledOut {
-                    return false;
-                }
-            },
-            Some(Node::Stmt(_)) => (),
-            _ => {
-                return false;
-            },
-        }
-        id = parent;
-    }
-}
diff --git a/clippy_lints/src/loops/while_let_on_iterator.rs b/clippy_lints/src/loops/while_let_on_iterator.rs
new file mode 100644
index 00000000000..090c8ceba97
--- /dev/null
+++ b/clippy_lints/src/loops/while_let_on_iterator.rs
@@ -0,0 +1,171 @@
+use super::utils::{LoopNestVisitor, Nesting};
+use super::WHILE_LET_ON_ITERATOR;
+use crate::utils::usage::mutated_variables;
+use crate::utils::{
+    get_enclosing_block, get_trait_def_id, implements_trait, is_refutable, last_path_segment, match_trait_method,
+    path_to_local, path_to_local_id, paths, snippet_with_applicability, span_lint_and_sugg,
+};
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir::intravisit::{walk_block, walk_expr, NestedVisitorMap, Visitor};
+use rustc_hir::{Expr, ExprKind, HirId, MatchSource, Node, PatKind};
+use rustc_lint::LateContext;
+use rustc_middle::hir::map::Map;
+
+use rustc_span::symbol::sym;
+
+pub(super) fn check_while_let_on_iterator(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+    if let ExprKind::Match(ref match_expr, ref arms, MatchSource::WhileLetDesugar) = expr.kind {
+        let pat = &arms[0].pat.kind;
+        if let (
+            &PatKind::TupleStruct(ref qpath, ref pat_args, _),
+            &ExprKind::MethodCall(ref method_path, _, ref method_args, _),
+        ) = (pat, &match_expr.kind)
+        {
+            let iter_expr = &method_args[0];
+
+            // Don't lint when the iterator is recreated on every iteration
+            if_chain! {
+                if let ExprKind::MethodCall(..) | ExprKind::Call(..) = iter_expr.kind;
+                if let Some(iter_def_id) = get_trait_def_id(cx, &paths::ITERATOR);
+                if implements_trait(cx, cx.typeck_results().expr_ty(iter_expr), iter_def_id, &[]);
+                then {
+                    return;
+                }
+            }
+
+            let lhs_constructor = last_path_segment(qpath);
+            if method_path.ident.name == sym::next
+                && match_trait_method(cx, match_expr, &paths::ITERATOR)
+                && lhs_constructor.ident.name == sym::Some
+                && (pat_args.is_empty()
+                    || !is_refutable(cx, &pat_args[0])
+                        && !is_used_inside(cx, iter_expr, &arms[0].body)
+                        && !is_iterator_used_after_while_let(cx, iter_expr)
+                        && !is_nested(cx, expr, &method_args[0]))
+            {
+                let mut applicability = Applicability::MachineApplicable;
+                let iterator = snippet_with_applicability(cx, method_args[0].span, "_", &mut applicability);
+                let loop_var = if pat_args.is_empty() {
+                    "_".to_string()
+                } else {
+                    snippet_with_applicability(cx, pat_args[0].span, "_", &mut applicability).into_owned()
+                };
+                span_lint_and_sugg(
+                    cx,
+                    WHILE_LET_ON_ITERATOR,
+                    expr.span.with_hi(match_expr.span.hi()),
+                    "this loop could be written as a `for` loop",
+                    "try",
+                    format!("for {} in {}", loop_var, iterator),
+                    applicability,
+                );
+            }
+        }
+    }
+}
+
+fn is_used_inside<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, container: &'tcx Expr<'_>) -> bool {
+    let def_id = match path_to_local(expr) {
+        Some(id) => id,
+        None => return false,
+    };
+    if let Some(used_mutably) = mutated_variables(container, cx) {
+        if used_mutably.contains(&def_id) {
+            return true;
+        }
+    }
+    false
+}
+
+fn is_iterator_used_after_while_let<'tcx>(cx: &LateContext<'tcx>, iter_expr: &'tcx Expr<'_>) -> bool {
+    let def_id = match path_to_local(iter_expr) {
+        Some(id) => id,
+        None => return false,
+    };
+    let mut visitor = VarUsedAfterLoopVisitor {
+        def_id,
+        iter_expr_id: iter_expr.hir_id,
+        past_while_let: false,
+        var_used_after_while_let: false,
+    };
+    if let Some(enclosing_block) = get_enclosing_block(cx, def_id) {
+        walk_block(&mut visitor, enclosing_block);
+    }
+    visitor.var_used_after_while_let
+}
+
+fn is_nested(cx: &LateContext<'_>, match_expr: &Expr<'_>, iter_expr: &Expr<'_>) -> bool {
+    if_chain! {
+        if let Some(loop_block) = get_enclosing_block(cx, match_expr.hir_id);
+        let parent_node = cx.tcx.hir().get_parent_node(loop_block.hir_id);
+        if let Some(Node::Expr(loop_expr)) = cx.tcx.hir().find(parent_node);
+        then {
+            return is_loop_nested(cx, loop_expr, iter_expr)
+        }
+    }
+    false
+}
+
+fn is_loop_nested(cx: &LateContext<'_>, loop_expr: &Expr<'_>, iter_expr: &Expr<'_>) -> bool {
+    let mut id = loop_expr.hir_id;
+    let iter_id = if let Some(id) = path_to_local(iter_expr) {
+        id
+    } else {
+        return true;
+    };
+    loop {
+        let parent = cx.tcx.hir().get_parent_node(id);
+        if parent == id {
+            return false;
+        }
+        match cx.tcx.hir().find(parent) {
+            Some(Node::Expr(expr)) => {
+                if let ExprKind::Loop(..) = expr.kind {
+                    return true;
+                };
+            },
+            Some(Node::Block(block)) => {
+                let mut block_visitor = LoopNestVisitor {
+                    hir_id: id,
+                    iterator: iter_id,
+                    nesting: Nesting::Unknown,
+                };
+                walk_block(&mut block_visitor, block);
+                if block_visitor.nesting == Nesting::RuledOut {
+                    return false;
+                }
+            },
+            Some(Node::Stmt(_)) => (),
+            _ => {
+                return false;
+            },
+        }
+        id = parent;
+    }
+}
+
+struct VarUsedAfterLoopVisitor {
+    def_id: HirId,
+    iter_expr_id: HirId,
+    past_while_let: bool,
+    var_used_after_while_let: bool,
+}
+
+impl<'tcx> Visitor<'tcx> for VarUsedAfterLoopVisitor {
+    type Map = Map<'tcx>;
+
+    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
+        if self.past_while_let {
+            if path_to_local_id(expr, self.def_id) {
+                self.var_used_after_while_let = true;
+            }
+        } else if self.iter_expr_id == expr.hir_id {
+            self.past_while_let = true;
+        }
+        walk_expr(self, expr);
+    }
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::None
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 287a4f8ab176a95cff2b82f6414d37e33809110a Mon Sep 17 00:00:00 2001
From: nahuakang <kangnahua@gmail.com>
Date: Sun, 21 Feb 2021 16:48:16 +0100
Subject: Refactor empty loop to its own module

---
 clippy_lints/src/loops/empty_loop.rs | 17 +++++++++++++++++
 clippy_lints/src/loops/mod.rs        | 16 +++-------------
 2 files changed, 20 insertions(+), 13 deletions(-)
 create mode 100644 clippy_lints/src/loops/empty_loop.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/empty_loop.rs b/clippy_lints/src/loops/empty_loop.rs
new file mode 100644
index 00000000000..fdc99e190e3
--- /dev/null
+++ b/clippy_lints/src/loops/empty_loop.rs
@@ -0,0 +1,17 @@
+use super::EMPTY_LOOP;
+use crate::utils::{is_in_panic_handler, is_no_std_crate, span_lint_and_help};
+
+use rustc_hir::{Block, Expr};
+use rustc_lint::LateContext;
+
+pub(super) fn check_empty_loop(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, loop_block: &'tcx Block<'_>) {
+    if loop_block.stmts.is_empty() && loop_block.expr.is_none() && !is_in_panic_handler(cx, expr) {
+        let msg = "empty `loop {}` wastes CPU cycles";
+        let help = if is_no_std_crate(cx.tcx.hir().krate()) {
+            "you should either use `panic!()` or add a call pausing or sleeping the thread to the loop body"
+        } else {
+            "you should either use `panic!()` or add `std::thread::sleep(..);` to the loop body"
+        };
+        span_lint_and_help(cx, EMPTY_LOOP, expr.span, msg, None, help);
+    }
+}
diff --git a/clippy_lints/src/loops/mod.rs b/clippy_lints/src/loops/mod.rs
index cadf9241256..d205f053679 100644
--- a/clippy_lints/src/loops/mod.rs
+++ b/clippy_lints/src/loops/mod.rs
@@ -1,3 +1,4 @@
+mod empty_loop;
 mod explicit_counter_loop;
 mod for_loop_arg;
 mod for_loop_over_map_kv;
@@ -14,10 +15,7 @@ mod utils;
 mod while_let_on_iterator;
 
 use crate::utils::sugg::Sugg;
-use crate::utils::{
-    higher, is_in_panic_handler, is_no_std_crate, snippet_with_applicability, span_lint_and_help, span_lint_and_sugg,
-    sugg,
-};
+use crate::utils::{higher, snippet_with_applicability, span_lint_and_sugg, sugg};
 use rustc_errors::Applicability;
 use rustc_hir::{Block, Expr, ExprKind, LoopSource, MatchSource, Pat, StmtKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
@@ -565,15 +563,7 @@ impl<'tcx> LateLintPass<'tcx> for Loops {
         // (even if the "match" or "if let" is used for declaration)
         if let ExprKind::Loop(ref block, _, LoopSource::Loop, _) = expr.kind {
             // also check for empty `loop {}` statements, skipping those in #[panic_handler]
-            if block.stmts.is_empty() && block.expr.is_none() && !is_in_panic_handler(cx, expr) {
-                let msg = "empty `loop {}` wastes CPU cycles";
-                let help = if is_no_std_crate(cx.tcx.hir().krate()) {
-                    "you should either use `panic!()` or add a call pausing or sleeping the thread to the loop body"
-                } else {
-                    "you should either use `panic!()` or add `std::thread::sleep(..);` to the loop body"
-                };
-                span_lint_and_help(cx, EMPTY_LOOP, expr.span, msg, None, help);
-            }
+            empty_loop::check_empty_loop(cx, expr, block);
 
             // extract the expression from the first statement (if any) in a block
             let inner_stmt_expr = extract_expr_from_first_stmt(block);
-- 
cgit 1.4.1-3-g733a5


From 7158c944a4f033f6feb57fbcdbf3453333d892b7 Mon Sep 17 00:00:00 2001
From: nahuakang <kangnahua@gmail.com>
Date: Sun, 21 Feb 2021 17:01:49 +0100
Subject: Refactor while let loop to its own module

---
 clippy_lints/src/loops/mod.rs            | 89 ++------------------------------
 clippy_lints/src/loops/while_let_loop.rs | 87 +++++++++++++++++++++++++++++++
 2 files changed, 92 insertions(+), 84 deletions(-)
 create mode 100644 clippy_lints/src/loops/while_let_loop.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/mod.rs b/clippy_lints/src/loops/mod.rs
index d205f053679..9076e48584a 100644
--- a/clippy_lints/src/loops/mod.rs
+++ b/clippy_lints/src/loops/mod.rs
@@ -12,14 +12,13 @@ mod needless_collect;
 mod never_loop;
 mod same_item_push;
 mod utils;
+mod while_let_loop;
 mod while_let_on_iterator;
 
 use crate::utils::sugg::Sugg;
-use crate::utils::{higher, snippet_with_applicability, span_lint_and_sugg, sugg};
-use rustc_errors::Applicability;
-use rustc_hir::{Block, Expr, ExprKind, LoopSource, MatchSource, Pat, StmtKind};
-use rustc_lint::{LateContext, LateLintPass, LintContext};
-use rustc_middle::lint::in_external_macro;
+use crate::utils::{higher, sugg};
+use rustc_hir::{Expr, ExprKind, LoopSource, Pat};
+use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
 use utils::{get_span_of_entire_for_loop, make_iterator_snippet, IncrementVisitor, InitializeVisitor};
@@ -564,49 +563,7 @@ impl<'tcx> LateLintPass<'tcx> for Loops {
         if let ExprKind::Loop(ref block, _, LoopSource::Loop, _) = expr.kind {
             // also check for empty `loop {}` statements, skipping those in #[panic_handler]
             empty_loop::check_empty_loop(cx, expr, block);
-
-            // extract the expression from the first statement (if any) in a block
-            let inner_stmt_expr = extract_expr_from_first_stmt(block);
-            // or extract the first expression (if any) from the block
-            if let Some(inner) = inner_stmt_expr.or_else(|| extract_first_expr(block)) {
-                if let ExprKind::Match(ref matchexpr, ref arms, ref source) = inner.kind {
-                    // ensure "if let" compatible match structure
-                    match *source {
-                        MatchSource::Normal | MatchSource::IfLetDesugar { .. } => {
-                            if arms.len() == 2
-                                && arms[0].guard.is_none()
-                                && arms[1].guard.is_none()
-                                && is_simple_break_expr(&arms[1].body)
-                            {
-                                if in_external_macro(cx.sess(), expr.span) {
-                                    return;
-                                }
-
-                                // NOTE: we used to build a body here instead of using
-                                // ellipsis, this was removed because:
-                                // 1) it was ugly with big bodies;
-                                // 2) it was not indented properly;
-                                // 3) it wasn’t very smart (see #675).
-                                let mut applicability = Applicability::HasPlaceholders;
-                                span_lint_and_sugg(
-                                    cx,
-                                    WHILE_LET_LOOP,
-                                    expr.span,
-                                    "this loop could be written as a `while let` loop",
-                                    "try",
-                                    format!(
-                                        "while let {} = {} {{ .. }}",
-                                        snippet_with_applicability(cx, arms[0].pat.span, "..", &mut applicability),
-                                        snippet_with_applicability(cx, matchexpr.span, "..", &mut applicability),
-                                    ),
-                                    applicability,
-                                );
-                            }
-                        },
-                        _ => (),
-                    }
-                }
-            }
+            while_let_loop::check_while_let_loop(cx, expr, block);
         }
 
         while_let_on_iterator::check_while_let_on_iterator(cx, expr);
@@ -709,39 +666,3 @@ impl std::ops::Sub<&MinifyingSugg<'static>> for MinifyingSugg<'static> {
         }
     }
 }
-
-/// If a block begins with a statement (possibly a `let` binding) and has an
-/// expression, return it.
-fn extract_expr_from_first_stmt<'tcx>(block: &Block<'tcx>) -> Option<&'tcx Expr<'tcx>> {
-    if block.stmts.is_empty() {
-        return None;
-    }
-    if let StmtKind::Local(ref local) = block.stmts[0].kind {
-        local.init //.map(|expr| expr)
-    } else {
-        None
-    }
-}
-
-/// If a block begins with an expression (with or without semicolon), return it.
-fn extract_first_expr<'tcx>(block: &Block<'tcx>) -> Option<&'tcx Expr<'tcx>> {
-    match block.expr {
-        Some(ref expr) if block.stmts.is_empty() => Some(expr),
-        None if !block.stmts.is_empty() => match block.stmts[0].kind {
-            StmtKind::Expr(ref expr) | StmtKind::Semi(ref expr) => Some(expr),
-            StmtKind::Local(..) | StmtKind::Item(..) => None,
-        },
-        _ => None,
-    }
-}
-
-/// Returns `true` if expr contains a single break expr without destination label
-/// and
-/// passed expression. The expression may be within a block.
-fn is_simple_break_expr(expr: &Expr<'_>) -> bool {
-    match expr.kind {
-        ExprKind::Break(dest, ref passed_expr) if dest.label.is_none() && passed_expr.is_none() => true,
-        ExprKind::Block(ref b, _) => extract_first_expr(b).map_or(false, |subexpr| is_simple_break_expr(subexpr)),
-        _ => false,
-    }
-}
diff --git a/clippy_lints/src/loops/while_let_loop.rs b/clippy_lints/src/loops/while_let_loop.rs
new file mode 100644
index 00000000000..0c957986964
--- /dev/null
+++ b/clippy_lints/src/loops/while_let_loop.rs
@@ -0,0 +1,87 @@
+use super::WHILE_LET_LOOP;
+use crate::utils::{snippet_with_applicability, span_lint_and_sugg};
+use rustc_errors::Applicability;
+use rustc_hir::{Block, Expr, ExprKind, MatchSource, StmtKind};
+use rustc_lint::{LateContext, LintContext};
+use rustc_middle::lint::in_external_macro;
+
+pub(super) fn check_while_let_loop(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, loop_block: &'tcx Block<'_>) {
+    // extract the expression from the first statement (if any) in a block
+    let inner_stmt_expr = extract_expr_from_first_stmt(loop_block);
+    // or extract the first expression (if any) from the block
+    if let Some(inner) = inner_stmt_expr.or_else(|| extract_first_expr(loop_block)) {
+        if let ExprKind::Match(ref matchexpr, ref arms, ref source) = inner.kind {
+            // ensure "if let" compatible match structure
+            match *source {
+                MatchSource::Normal | MatchSource::IfLetDesugar { .. } => {
+                    if arms.len() == 2
+                        && arms[0].guard.is_none()
+                        && arms[1].guard.is_none()
+                        && is_simple_break_expr(&arms[1].body)
+                    {
+                        if in_external_macro(cx.sess(), expr.span) {
+                            return;
+                        }
+
+                        // NOTE: we used to build a body here instead of using
+                        // ellipsis, this was removed because:
+                        // 1) it was ugly with big bodies;
+                        // 2) it was not indented properly;
+                        // 3) it wasn’t very smart (see #675).
+                        let mut applicability = Applicability::HasPlaceholders;
+                        span_lint_and_sugg(
+                            cx,
+                            WHILE_LET_LOOP,
+                            expr.span,
+                            "this loop could be written as a `while let` loop",
+                            "try",
+                            format!(
+                                "while let {} = {} {{ .. }}",
+                                snippet_with_applicability(cx, arms[0].pat.span, "..", &mut applicability),
+                                snippet_with_applicability(cx, matchexpr.span, "..", &mut applicability),
+                            ),
+                            applicability,
+                        );
+                    }
+                },
+                _ => (),
+            }
+        }
+    }
+}
+
+/// If a block begins with a statement (possibly a `let` binding) and has an
+/// expression, return it.
+fn extract_expr_from_first_stmt<'tcx>(block: &Block<'tcx>) -> Option<&'tcx Expr<'tcx>> {
+    if block.stmts.is_empty() {
+        return None;
+    }
+    if let StmtKind::Local(ref local) = block.stmts[0].kind {
+        local.init //.map(|expr| expr)
+    } else {
+        None
+    }
+}
+
+/// If a block begins with an expression (with or without semicolon), return it.
+fn extract_first_expr<'tcx>(block: &Block<'tcx>) -> Option<&'tcx Expr<'tcx>> {
+    match block.expr {
+        Some(ref expr) if block.stmts.is_empty() => Some(expr),
+        None if !block.stmts.is_empty() => match block.stmts[0].kind {
+            StmtKind::Expr(ref expr) | StmtKind::Semi(ref expr) => Some(expr),
+            StmtKind::Local(..) | StmtKind::Item(..) => None,
+        },
+        _ => None,
+    }
+}
+
+/// Returns `true` if expr contains a single break expr without destination label
+/// and
+/// passed expression. The expression may be within a block.
+fn is_simple_break_expr(expr: &Expr<'_>) -> bool {
+    match expr.kind {
+        ExprKind::Break(dest, ref passed_expr) if dest.label.is_none() && passed_expr.is_none() => true,
+        ExprKind::Block(ref b, _) => extract_first_expr(b).map_or(false, |subexpr| is_simple_break_expr(subexpr)),
+        _ => false,
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 7cfdef6de19a0aaddcc3018baf1031ae54c419f6 Mon Sep 17 00:00:00 2001
From: nahuakang <kangnahua@gmail.com>
Date: Sun, 21 Feb 2021 17:10:07 +0100
Subject: Move MinifyingSugg into manual_memcpy

---
 clippy_lints/src/loops/manual_memcpy.rs | 72 +++++++++++++++++++++++++++++++-
 clippy_lints/src/loops/mod.rs           | 73 +--------------------------------
 2 files changed, 72 insertions(+), 73 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/manual_memcpy.rs b/clippy_lints/src/loops/manual_memcpy.rs
index 85b3dfaece7..13a434aa210 100644
--- a/clippy_lints/src/loops/manual_memcpy.rs
+++ b/clippy_lints/src/loops/manual_memcpy.rs
@@ -1,4 +1,4 @@
-use super::{get_span_of_entire_for_loop, IncrementVisitor, InitializeVisitor, MinifyingSugg};
+use super::{get_span_of_entire_for_loop, IncrementVisitor, InitializeVisitor};
 use crate::utils::sugg::Sugg;
 use crate::utils::{
     get_enclosing_block, higher, is_type_diagnostic_item, path_to_local, snippet, span_lint_and_sugg, sugg,
@@ -194,6 +194,76 @@ fn build_manual_memcpy_suggestion<'tcx>(
     )
 }
 
+/// a wrapper of `Sugg`. Besides what `Sugg` do, this removes unnecessary `0`;
+/// and also, it avoids subtracting a variable from the same one by replacing it with `0`.
+/// it exists for the convenience of the overloaded operators while normal functions can do the
+/// same.
+#[derive(Clone)]
+struct MinifyingSugg<'a>(Sugg<'a>);
+
+impl<'a> MinifyingSugg<'a> {
+    fn as_str(&self) -> &str {
+        let Sugg::NonParen(s) | Sugg::MaybeParen(s) | Sugg::BinOp(_, s) = &self.0;
+        s.as_ref()
+    }
+
+    fn into_sugg(self) -> Sugg<'a> {
+        self.0
+    }
+}
+
+impl<'a> From<Sugg<'a>> for MinifyingSugg<'a> {
+    fn from(sugg: Sugg<'a>) -> Self {
+        Self(sugg)
+    }
+}
+
+impl std::ops::Add for &MinifyingSugg<'static> {
+    type Output = MinifyingSugg<'static>;
+    fn add(self, rhs: &MinifyingSugg<'static>) -> MinifyingSugg<'static> {
+        match (self.as_str(), rhs.as_str()) {
+            ("0", _) => rhs.clone(),
+            (_, "0") => self.clone(),
+            (_, _) => (&self.0 + &rhs.0).into(),
+        }
+    }
+}
+
+impl std::ops::Sub for &MinifyingSugg<'static> {
+    type Output = MinifyingSugg<'static>;
+    fn sub(self, rhs: &MinifyingSugg<'static>) -> MinifyingSugg<'static> {
+        match (self.as_str(), rhs.as_str()) {
+            (_, "0") => self.clone(),
+            ("0", _) => (-rhs.0.clone()).into(),
+            (x, y) if x == y => sugg::ZERO.into(),
+            (_, _) => (&self.0 - &rhs.0).into(),
+        }
+    }
+}
+
+impl std::ops::Add<&MinifyingSugg<'static>> for MinifyingSugg<'static> {
+    type Output = MinifyingSugg<'static>;
+    fn add(self, rhs: &MinifyingSugg<'static>) -> MinifyingSugg<'static> {
+        match (self.as_str(), rhs.as_str()) {
+            ("0", _) => rhs.clone(),
+            (_, "0") => self,
+            (_, _) => (self.0 + &rhs.0).into(),
+        }
+    }
+}
+
+impl std::ops::Sub<&MinifyingSugg<'static>> for MinifyingSugg<'static> {
+    type Output = MinifyingSugg<'static>;
+    fn sub(self, rhs: &MinifyingSugg<'static>) -> MinifyingSugg<'static> {
+        match (self.as_str(), rhs.as_str()) {
+            (_, "0") => self,
+            ("0", _) => (-rhs.0.clone()).into(),
+            (x, y) if x == y => sugg::ZERO.into(),
+            (_, _) => (self.0 - &rhs.0).into(),
+        }
+    }
+}
+
 /// a wrapper around `MinifyingSugg`, which carries a operator like currying
 /// so that the suggested code become more efficient (e.g. `foo + -bar` `foo - bar`).
 struct Offset {
diff --git a/clippy_lints/src/loops/mod.rs b/clippy_lints/src/loops/mod.rs
index 9076e48584a..c0191e43dea 100644
--- a/clippy_lints/src/loops/mod.rs
+++ b/clippy_lints/src/loops/mod.rs
@@ -15,8 +15,7 @@ mod utils;
 mod while_let_loop;
 mod while_let_on_iterator;
 
-use crate::utils::sugg::Sugg;
-use crate::utils::{higher, sugg};
+use crate::utils::higher;
 use rustc_hir::{Expr, ExprKind, LoopSource, Pat};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -596,73 +595,3 @@ fn check_for_loop<'tcx>(
     same_item_push::detect_same_item_push(cx, pat, arg, body, expr);
     manual_flatten::check_manual_flatten(cx, pat, arg, body, span);
 }
-
-/// a wrapper of `Sugg`. Besides what `Sugg` do, this removes unnecessary `0`;
-/// and also, it avoids subtracting a variable from the same one by replacing it with `0`.
-/// it exists for the convenience of the overloaded operators while normal functions can do the
-/// same.
-#[derive(Clone)]
-struct MinifyingSugg<'a>(Sugg<'a>);
-
-impl<'a> MinifyingSugg<'a> {
-    fn as_str(&self) -> &str {
-        let Sugg::NonParen(s) | Sugg::MaybeParen(s) | Sugg::BinOp(_, s) = &self.0;
-        s.as_ref()
-    }
-
-    fn into_sugg(self) -> Sugg<'a> {
-        self.0
-    }
-}
-
-impl<'a> From<Sugg<'a>> for MinifyingSugg<'a> {
-    fn from(sugg: Sugg<'a>) -> Self {
-        Self(sugg)
-    }
-}
-
-impl std::ops::Add for &MinifyingSugg<'static> {
-    type Output = MinifyingSugg<'static>;
-    fn add(self, rhs: &MinifyingSugg<'static>) -> MinifyingSugg<'static> {
-        match (self.as_str(), rhs.as_str()) {
-            ("0", _) => rhs.clone(),
-            (_, "0") => self.clone(),
-            (_, _) => (&self.0 + &rhs.0).into(),
-        }
-    }
-}
-
-impl std::ops::Sub for &MinifyingSugg<'static> {
-    type Output = MinifyingSugg<'static>;
-    fn sub(self, rhs: &MinifyingSugg<'static>) -> MinifyingSugg<'static> {
-        match (self.as_str(), rhs.as_str()) {
-            (_, "0") => self.clone(),
-            ("0", _) => (-rhs.0.clone()).into(),
-            (x, y) if x == y => sugg::ZERO.into(),
-            (_, _) => (&self.0 - &rhs.0).into(),
-        }
-    }
-}
-
-impl std::ops::Add<&MinifyingSugg<'static>> for MinifyingSugg<'static> {
-    type Output = MinifyingSugg<'static>;
-    fn add(self, rhs: &MinifyingSugg<'static>) -> MinifyingSugg<'static> {
-        match (self.as_str(), rhs.as_str()) {
-            ("0", _) => rhs.clone(),
-            (_, "0") => self,
-            (_, _) => (self.0 + &rhs.0).into(),
-        }
-    }
-}
-
-impl std::ops::Sub<&MinifyingSugg<'static>> for MinifyingSugg<'static> {
-    type Output = MinifyingSugg<'static>;
-    fn sub(self, rhs: &MinifyingSugg<'static>) -> MinifyingSugg<'static> {
-        match (self.as_str(), rhs.as_str()) {
-            (_, "0") => self,
-            ("0", _) => (-rhs.0.clone()).into(),
-            (x, y) if x == y => sugg::ZERO.into(),
-            (_, _) => (self.0 - &rhs.0).into(),
-        }
-    }
-}
-- 
cgit 1.4.1-3-g733a5


From ecebfe0c9cee0694e986af63a446031606825d18 Mon Sep 17 00:00:00 2001
From: nahuakang <kangnahua@gmail.com>
Date: Sun, 21 Feb 2021 18:12:17 +0100
Subject: Move check_for_loop_arg back to mod; split into 4 lint files

---
 clippy_lints/src/loops/explicit_into_iter_loop.rs  | 20 ++++++
 clippy_lints/src/loops/explicit_iter_loop.rs       | 21 ++++++
 clippy_lints/src/loops/for_loops_over_fallibles.rs | 45 ++++++++++++
 clippy_lints/src/loops/iter_next_loop.rs           | 14 ++++
 clippy_lints/src/loops/mod.rs                      | 80 ++++++++++++++++++++--
 5 files changed, 176 insertions(+), 4 deletions(-)
 create mode 100644 clippy_lints/src/loops/explicit_into_iter_loop.rs
 create mode 100644 clippy_lints/src/loops/explicit_iter_loop.rs
 create mode 100644 clippy_lints/src/loops/for_loops_over_fallibles.rs
 create mode 100644 clippy_lints/src/loops/iter_next_loop.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/explicit_into_iter_loop.rs b/clippy_lints/src/loops/explicit_into_iter_loop.rs
new file mode 100644
index 00000000000..d5d2bedaf1b
--- /dev/null
+++ b/clippy_lints/src/loops/explicit_into_iter_loop.rs
@@ -0,0 +1,20 @@
+use super::EXPLICIT_INTO_ITER_LOOP;
+use crate::utils::{snippet_with_applicability, span_lint_and_sugg};
+use rustc_errors::Applicability;
+use rustc_hir::Expr;
+use rustc_lint::LateContext;
+
+pub(super) fn check_explicit_into_iter_loop(cx: &LateContext<'_>, method_args: &'hir [Expr<'hir>], arg: &Expr<'_>) {
+    let mut applicability = Applicability::MachineApplicable;
+    let object = snippet_with_applicability(cx, method_args[0].span, "_", &mut applicability);
+    span_lint_and_sugg(
+        cx,
+        EXPLICIT_INTO_ITER_LOOP,
+        arg.span,
+        "it is more concise to loop over containers instead of using explicit \
+            iteration methods",
+        "to write this more concisely, try",
+        object.to_string(),
+        applicability,
+    );
+}
diff --git a/clippy_lints/src/loops/explicit_iter_loop.rs b/clippy_lints/src/loops/explicit_iter_loop.rs
new file mode 100644
index 00000000000..14184865da3
--- /dev/null
+++ b/clippy_lints/src/loops/explicit_iter_loop.rs
@@ -0,0 +1,21 @@
+use super::EXPLICIT_ITER_LOOP;
+use crate::utils::{snippet_with_applicability, span_lint_and_sugg};
+use rustc_errors::Applicability;
+use rustc_hir::Expr;
+use rustc_lint::LateContext;
+
+pub(super) fn lint_iter_method(cx: &LateContext<'_>, args: &[Expr<'_>], arg: &Expr<'_>, method_name: &str) {
+    let mut applicability = Applicability::MachineApplicable;
+    let object = snippet_with_applicability(cx, args[0].span, "_", &mut applicability);
+    let muta = if method_name == "iter_mut" { "mut " } else { "" };
+    span_lint_and_sugg(
+        cx,
+        EXPLICIT_ITER_LOOP,
+        arg.span,
+        "it is more concise to loop over references to containers instead of using explicit \
+         iteration methods",
+        "to write this more concisely, try",
+        format!("&{}{}", muta, object),
+        applicability,
+    )
+}
diff --git a/clippy_lints/src/loops/for_loops_over_fallibles.rs b/clippy_lints/src/loops/for_loops_over_fallibles.rs
new file mode 100644
index 00000000000..1339af33759
--- /dev/null
+++ b/clippy_lints/src/loops/for_loops_over_fallibles.rs
@@ -0,0 +1,45 @@
+use super::FOR_LOOPS_OVER_FALLIBLES;
+use crate::utils::{is_type_diagnostic_item, snippet, span_lint_and_help};
+use rustc_hir::{Expr, Pat};
+use rustc_lint::LateContext;
+use rustc_span::symbol::sym;
+
+/// Checks for `for` loops over `Option`s and `Result`s.
+pub(super) fn check_arg_type(cx: &LateContext<'_>, pat: &Pat<'_>, arg: &Expr<'_>) {
+    let ty = cx.typeck_results().expr_ty(arg);
+    if is_type_diagnostic_item(cx, ty, sym::option_type) {
+        span_lint_and_help(
+            cx,
+            FOR_LOOPS_OVER_FALLIBLES,
+            arg.span,
+            &format!(
+                "for loop over `{0}`, which is an `Option`. This is more readably written as an \
+                `if let` statement",
+                snippet(cx, arg.span, "_")
+            ),
+            None,
+            &format!(
+                "consider replacing `for {0} in {1}` with `if let Some({0}) = {1}`",
+                snippet(cx, pat.span, "_"),
+                snippet(cx, arg.span, "_")
+            ),
+        );
+    } else if is_type_diagnostic_item(cx, ty, sym::result_type) {
+        span_lint_and_help(
+            cx,
+            FOR_LOOPS_OVER_FALLIBLES,
+            arg.span,
+            &format!(
+                "for loop over `{0}`, which is a `Result`. This is more readably written as an \
+                `if let` statement",
+                snippet(cx, arg.span, "_")
+            ),
+            None,
+            &format!(
+                "consider replacing `for {0} in {1}` with `if let Ok({0}) = {1}`",
+                snippet(cx, pat.span, "_"),
+                snippet(cx, arg.span, "_")
+            ),
+        );
+    }
+}
diff --git a/clippy_lints/src/loops/iter_next_loop.rs b/clippy_lints/src/loops/iter_next_loop.rs
new file mode 100644
index 00000000000..7a5a873a358
--- /dev/null
+++ b/clippy_lints/src/loops/iter_next_loop.rs
@@ -0,0 +1,14 @@
+use super::ITER_NEXT_LOOP;
+use crate::utils::span_lint;
+use rustc_hir::Expr;
+use rustc_lint::LateContext;
+
+pub(super) fn lint(cx: &LateContext<'_>, expr: &Expr<'_>) {
+    span_lint(
+        cx,
+        ITER_NEXT_LOOP,
+        expr.span,
+        "you are iterating over `Iterator::next()` which is an Option; this will compile but is \
+        probably not what you want",
+    );
+}
diff --git a/clippy_lints/src/loops/mod.rs b/clippy_lints/src/loops/mod.rs
index c0191e43dea..4594afc2332 100644
--- a/clippy_lints/src/loops/mod.rs
+++ b/clippy_lints/src/loops/mod.rs
@@ -1,11 +1,14 @@
 mod empty_loop;
 mod explicit_counter_loop;
-mod for_loop_arg;
+mod explicit_into_iter_loop;
+mod explicit_iter_loop;
 mod for_loop_over_map_kv;
 mod for_loop_range;
+mod for_loops_over_fallibles;
 mod for_mut_range_bound;
 mod for_single_element_loop;
 mod infinite_loop;
+mod iter_next_loop;
 mod manual_flatten;
 mod manual_memcpy;
 mod needless_collect;
@@ -15,11 +18,13 @@ mod utils;
 mod while_let_loop;
 mod while_let_on_iterator;
 
-use crate::utils::higher;
-use rustc_hir::{Expr, ExprKind, LoopSource, Pat};
+use crate::utils::{higher, is_type_diagnostic_item, match_trait_method, match_type, paths};
+use rustc_hir::{Expr, ExprKind, LoopSource, Mutability, Pat};
 use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::{self, Ty, TyS};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
+use rustc_span::symbol::sym;
 use utils::{get_span_of_entire_for_loop, make_iterator_snippet, IncrementVisitor, InitializeVisitor};
 
 declare_clippy_lint! {
@@ -588,10 +593,77 @@ fn check_for_loop<'tcx>(
         for_loop_range::check_for_loop_range(cx, pat, arg, body, expr);
         explicit_counter_loop::check_for_loop_explicit_counter(cx, pat, arg, body, expr);
     }
-    for_loop_arg::check_for_loop_arg(cx, pat, arg, expr);
+    check_for_loop_arg(cx, pat, arg, expr);
     for_loop_over_map_kv::check_for_loop_over_map_kv(cx, pat, arg, body, expr);
     for_mut_range_bound::check_for_mut_range_bound(cx, arg, body);
     for_single_element_loop::check_for_single_element_loop(cx, pat, arg, body, expr);
     same_item_push::detect_same_item_push(cx, pat, arg, body, expr);
     manual_flatten::check_manual_flatten(cx, pat, arg, body, span);
 }
+
+fn check_for_loop_arg(cx: &LateContext<'_>, pat: &Pat<'_>, arg: &Expr<'_>, expr: &Expr<'_>) {
+    let mut next_loop_linted = false; // whether or not ITER_NEXT_LOOP lint was used
+    if let ExprKind::MethodCall(ref method, _, ref args, _) = arg.kind {
+        // just the receiver, no arguments
+        if args.len() == 1 {
+            let method_name = &*method.ident.as_str();
+            // check for looping over x.iter() or x.iter_mut(), could use &x or &mut x
+            if method_name == "iter" || method_name == "iter_mut" {
+                if is_ref_iterable_type(cx, &args[0]) {
+                    explicit_iter_loop::lint_iter_method(cx, args, arg, method_name);
+                }
+            } else if method_name == "into_iter" && match_trait_method(cx, arg, &paths::INTO_ITERATOR) {
+                let receiver_ty = cx.typeck_results().expr_ty(&args[0]);
+                let receiver_ty_adjusted = cx.typeck_results().expr_ty_adjusted(&args[0]);
+                if TyS::same_type(receiver_ty, receiver_ty_adjusted) {
+                    explicit_into_iter_loop::check_explicit_into_iter_loop(cx, args, arg);
+                } else {
+                    let ref_receiver_ty = cx.tcx.mk_ref(
+                        cx.tcx.lifetimes.re_erased,
+                        ty::TypeAndMut {
+                            ty: receiver_ty,
+                            mutbl: Mutability::Not,
+                        },
+                    );
+                    if TyS::same_type(receiver_ty_adjusted, ref_receiver_ty) {
+                        explicit_iter_loop::lint_iter_method(cx, args, arg, method_name)
+                    }
+                }
+            } else if method_name == "next" && match_trait_method(cx, arg, &paths::ITERATOR) {
+                iter_next_loop::lint(cx, expr);
+                next_loop_linted = true;
+            }
+        }
+    }
+    if !next_loop_linted {
+        for_loops_over_fallibles::check_arg_type(cx, pat, arg);
+    }
+}
+
+/// Returns `true` if the type of expr is one that provides `IntoIterator` impls
+/// for `&T` and `&mut T`, such as `Vec`.
+#[rustfmt::skip]
+fn is_ref_iterable_type(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
+    // no walk_ptrs_ty: calling iter() on a reference can make sense because it
+    // will allow further borrows afterwards
+    let ty = cx.typeck_results().expr_ty(e);
+    is_iterable_array(ty, cx) ||
+    is_type_diagnostic_item(cx, ty, sym::vec_type) ||
+    match_type(cx, ty, &paths::LINKED_LIST) ||
+    is_type_diagnostic_item(cx, ty, sym!(hashmap_type)) ||
+    is_type_diagnostic_item(cx, ty, sym!(hashset_type)) ||
+    is_type_diagnostic_item(cx, ty, sym!(vecdeque_type)) ||
+    match_type(cx, ty, &paths::BINARY_HEAP) ||
+    match_type(cx, ty, &paths::BTREEMAP) ||
+    match_type(cx, ty, &paths::BTREESET)
+}
+
+fn is_iterable_array<'tcx>(ty: Ty<'tcx>, cx: &LateContext<'tcx>) -> bool {
+    // IntoIterator is currently only implemented for array sizes <= 32 in rustc
+    match ty.kind() {
+        ty::Array(_, n) => n
+            .try_eval_usize(cx.tcx, cx.param_env)
+            .map_or(false, |val| (0..=32).contains(&val)),
+        _ => false,
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 2229a0839efe52a3014133db5e469770000341c4 Mon Sep 17 00:00:00 2001
From: nahuakang <kangnahua@gmail.com>
Date: Sun, 21 Feb 2021 18:25:50 +0100
Subject: Clean up: Rename some files to be consistent with lint names; import
 lints to each file

---
 clippy_lints/src/loops/explicit_counter_loop.rs    |   6 +-
 clippy_lints/src/loops/for_kv_map.rs               |  70 ++++
 clippy_lints/src/loops/for_loop_over_map_kv.rs     |  69 ----
 clippy_lints/src/loops/for_loop_range.rs           | 390 --------------------
 clippy_lints/src/loops/for_mut_range_bound.rs      | 114 ------
 clippy_lints/src/loops/for_single_element_loop.rs  |  42 ---
 clippy_lints/src/loops/infinite_loop.rs            | 138 --------
 clippy_lints/src/loops/manual_flatten.rs           |   3 +-
 clippy_lints/src/loops/manual_memcpy.rs            |   4 +-
 clippy_lints/src/loops/mod.rs                      |  20 +-
 clippy_lints/src/loops/mut_range_bound.rs          | 115 ++++++
 clippy_lints/src/loops/needless_collect.rs         |   7 +-
 clippy_lints/src/loops/needless_range_loop.rs      | 391 +++++++++++++++++++++
 clippy_lints/src/loops/same_item_push.rs           |   3 +-
 clippy_lints/src/loops/single_element_loop.rs      |  42 +++
 .../src/loops/while_immutable_condition.rs         | 139 ++++++++
 16 files changed, 781 insertions(+), 772 deletions(-)
 create mode 100644 clippy_lints/src/loops/for_kv_map.rs
 delete mode 100644 clippy_lints/src/loops/for_loop_over_map_kv.rs
 delete mode 100644 clippy_lints/src/loops/for_loop_range.rs
 delete mode 100644 clippy_lints/src/loops/for_mut_range_bound.rs
 delete mode 100644 clippy_lints/src/loops/for_single_element_loop.rs
 delete mode 100644 clippy_lints/src/loops/infinite_loop.rs
 create mode 100644 clippy_lints/src/loops/mut_range_bound.rs
 create mode 100644 clippy_lints/src/loops/needless_range_loop.rs
 create mode 100644 clippy_lints/src/loops/single_element_loop.rs
 create mode 100644 clippy_lints/src/loops/while_immutable_condition.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/explicit_counter_loop.rs b/clippy_lints/src/loops/explicit_counter_loop.rs
index 68fee269eb1..59116032f66 100644
--- a/clippy_lints/src/loops/explicit_counter_loop.rs
+++ b/clippy_lints/src/loops/explicit_counter_loop.rs
@@ -1,4 +1,6 @@
-use super::{get_span_of_entire_for_loop, make_iterator_snippet, IncrementVisitor, InitializeVisitor};
+use super::{
+    get_span_of_entire_for_loop, make_iterator_snippet, IncrementVisitor, InitializeVisitor, EXPLICIT_COUNTER_LOOP,
+};
 use crate::utils::{get_enclosing_block, is_integer_const, snippet_with_applicability, span_lint_and_sugg};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
@@ -37,7 +39,7 @@ pub(super) fn check_for_loop_explicit_counter<'tcx>(
 
                     span_lint_and_sugg(
                         cx,
-                        super::EXPLICIT_COUNTER_LOOP,
+                        EXPLICIT_COUNTER_LOOP,
                         for_span.with_hi(arg.span.hi()),
                         &format!("the variable `{}` is used as a loop counter", name),
                         "consider using",
diff --git a/clippy_lints/src/loops/for_kv_map.rs b/clippy_lints/src/loops/for_kv_map.rs
new file mode 100644
index 00000000000..228d462f6e1
--- /dev/null
+++ b/clippy_lints/src/loops/for_kv_map.rs
@@ -0,0 +1,70 @@
+use super::FOR_KV_MAP;
+use crate::utils::visitors::LocalUsedVisitor;
+use crate::utils::{is_type_diagnostic_item, match_type, multispan_sugg, paths, snippet, span_lint_and_then, sugg};
+use rustc_hir::{BorrowKind, Expr, ExprKind, Mutability, Pat, PatKind};
+use rustc_lint::LateContext;
+use rustc_middle::ty;
+
+/// Checks for the `FOR_KV_MAP` lint.
+pub(super) fn check_for_loop_over_map_kv<'tcx>(
+    cx: &LateContext<'tcx>,
+    pat: &'tcx Pat<'_>,
+    arg: &'tcx Expr<'_>,
+    body: &'tcx Expr<'_>,
+    expr: &'tcx Expr<'_>,
+) {
+    let pat_span = pat.span;
+
+    if let PatKind::Tuple(ref pat, _) = pat.kind {
+        if pat.len() == 2 {
+            let arg_span = arg.span;
+            let (new_pat_span, kind, ty, mutbl) = match *cx.typeck_results().expr_ty(arg).kind() {
+                ty::Ref(_, ty, mutbl) => match (&pat[0].kind, &pat[1].kind) {
+                    (key, _) if pat_is_wild(key, body) => (pat[1].span, "value", ty, mutbl),
+                    (_, value) if pat_is_wild(value, body) => (pat[0].span, "key", ty, Mutability::Not),
+                    _ => return,
+                },
+                _ => return,
+            };
+            let mutbl = match mutbl {
+                Mutability::Not => "",
+                Mutability::Mut => "_mut",
+            };
+            let arg = match arg.kind {
+                ExprKind::AddrOf(BorrowKind::Ref, _, ref expr) => &**expr,
+                _ => arg,
+            };
+
+            if is_type_diagnostic_item(cx, ty, sym!(hashmap_type)) || match_type(cx, ty, &paths::BTREEMAP) {
+                span_lint_and_then(
+                    cx,
+                    FOR_KV_MAP,
+                    expr.span,
+                    &format!("you seem to want to iterate on a map's {}s", kind),
+                    |diag| {
+                        let map = sugg::Sugg::hir(cx, arg, "map");
+                        multispan_sugg(
+                            diag,
+                            "use the corresponding method",
+                            vec![
+                                (pat_span, snippet(cx, new_pat_span, kind).into_owned()),
+                                (arg_span, format!("{}.{}s{}()", map.maybe_par(), kind, mutbl)),
+                            ],
+                        );
+                    },
+                );
+            }
+        }
+    }
+}
+
+/// Returns `true` if the pattern is a `PatWild` or an ident prefixed with `_`.
+fn pat_is_wild<'tcx>(pat: &'tcx PatKind<'_>, body: &'tcx Expr<'_>) -> bool {
+    match *pat {
+        PatKind::Wild => true,
+        PatKind::Binding(_, id, ident, None) if ident.as_str().starts_with('_') => {
+            !LocalUsedVisitor::new(id).check_expr(body)
+        },
+        _ => false,
+    }
+}
diff --git a/clippy_lints/src/loops/for_loop_over_map_kv.rs b/clippy_lints/src/loops/for_loop_over_map_kv.rs
deleted file mode 100644
index c5f0b0909ba..00000000000
--- a/clippy_lints/src/loops/for_loop_over_map_kv.rs
+++ /dev/null
@@ -1,69 +0,0 @@
-use crate::utils::visitors::LocalUsedVisitor;
-use crate::utils::{is_type_diagnostic_item, match_type, multispan_sugg, paths, snippet, span_lint_and_then, sugg};
-use rustc_hir::{BorrowKind, Expr, ExprKind, Mutability, Pat, PatKind};
-use rustc_lint::LateContext;
-use rustc_middle::ty;
-
-/// Checks for the `FOR_KV_MAP` lint.
-pub(super) fn check_for_loop_over_map_kv<'tcx>(
-    cx: &LateContext<'tcx>,
-    pat: &'tcx Pat<'_>,
-    arg: &'tcx Expr<'_>,
-    body: &'tcx Expr<'_>,
-    expr: &'tcx Expr<'_>,
-) {
-    let pat_span = pat.span;
-
-    if let PatKind::Tuple(ref pat, _) = pat.kind {
-        if pat.len() == 2 {
-            let arg_span = arg.span;
-            let (new_pat_span, kind, ty, mutbl) = match *cx.typeck_results().expr_ty(arg).kind() {
-                ty::Ref(_, ty, mutbl) => match (&pat[0].kind, &pat[1].kind) {
-                    (key, _) if pat_is_wild(key, body) => (pat[1].span, "value", ty, mutbl),
-                    (_, value) if pat_is_wild(value, body) => (pat[0].span, "key", ty, Mutability::Not),
-                    _ => return,
-                },
-                _ => return,
-            };
-            let mutbl = match mutbl {
-                Mutability::Not => "",
-                Mutability::Mut => "_mut",
-            };
-            let arg = match arg.kind {
-                ExprKind::AddrOf(BorrowKind::Ref, _, ref expr) => &**expr,
-                _ => arg,
-            };
-
-            if is_type_diagnostic_item(cx, ty, sym!(hashmap_type)) || match_type(cx, ty, &paths::BTREEMAP) {
-                span_lint_and_then(
-                    cx,
-                    super::FOR_KV_MAP,
-                    expr.span,
-                    &format!("you seem to want to iterate on a map's {}s", kind),
-                    |diag| {
-                        let map = sugg::Sugg::hir(cx, arg, "map");
-                        multispan_sugg(
-                            diag,
-                            "use the corresponding method",
-                            vec![
-                                (pat_span, snippet(cx, new_pat_span, kind).into_owned()),
-                                (arg_span, format!("{}.{}s{}()", map.maybe_par(), kind, mutbl)),
-                            ],
-                        );
-                    },
-                );
-            }
-        }
-    }
-}
-
-/// Returns `true` if the pattern is a `PatWild` or an ident prefixed with `_`.
-fn pat_is_wild<'tcx>(pat: &'tcx PatKind<'_>, body: &'tcx Expr<'_>) -> bool {
-    match *pat {
-        PatKind::Wild => true,
-        PatKind::Binding(_, id, ident, None) if ident.as_str().starts_with('_') => {
-            !LocalUsedVisitor::new(id).check_expr(body)
-        },
-        _ => false,
-    }
-}
diff --git a/clippy_lints/src/loops/for_loop_range.rs b/clippy_lints/src/loops/for_loop_range.rs
deleted file mode 100644
index 43560abb7f2..00000000000
--- a/clippy_lints/src/loops/for_loop_range.rs
+++ /dev/null
@@ -1,390 +0,0 @@
-use crate::utils::visitors::LocalUsedVisitor;
-use crate::utils::{
-    contains_name, has_iter_method, higher, is_integer_const, match_trait_method, multispan_sugg, path_to_local_id,
-    paths, snippet, span_lint_and_then, sugg, SpanlessEq,
-};
-use if_chain::if_chain;
-use rustc_ast::ast;
-use rustc_data_structures::fx::{FxHashMap, FxHashSet};
-use rustc_hir::def::{DefKind, Res};
-use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
-use rustc_hir::{BinOpKind, BorrowKind, Expr, ExprKind, HirId, Mutability, Pat, PatKind, QPath};
-use rustc_lint::LateContext;
-use rustc_middle::hir::map::Map;
-use rustc_middle::middle::region;
-use rustc_middle::ty::{self, Ty};
-use rustc_span::symbol::{sym, Symbol};
-use std::iter::Iterator;
-use std::mem;
-
-/// Checks for looping over a range and then indexing a sequence with it.
-/// The iteratee must be a range literal.
-#[allow(clippy::too_many_lines)]
-pub(super) fn check_for_loop_range<'tcx>(
-    cx: &LateContext<'tcx>,
-    pat: &'tcx Pat<'_>,
-    arg: &'tcx Expr<'_>,
-    body: &'tcx Expr<'_>,
-    expr: &'tcx Expr<'_>,
-) {
-    if let Some(higher::Range {
-        start: Some(start),
-        ref end,
-        limits,
-    }) = higher::range(arg)
-    {
-        // the var must be a single name
-        if let PatKind::Binding(_, canonical_id, ident, _) = pat.kind {
-            let mut visitor = VarVisitor {
-                cx,
-                var: canonical_id,
-                indexed_mut: FxHashSet::default(),
-                indexed_indirectly: FxHashMap::default(),
-                indexed_directly: FxHashMap::default(),
-                referenced: FxHashSet::default(),
-                nonindex: false,
-                prefer_mutable: false,
-            };
-            walk_expr(&mut visitor, body);
-
-            // linting condition: we only indexed one variable, and indexed it directly
-            if visitor.indexed_indirectly.is_empty() && visitor.indexed_directly.len() == 1 {
-                let (indexed, (indexed_extent, indexed_ty)) = visitor
-                    .indexed_directly
-                    .into_iter()
-                    .next()
-                    .expect("already checked that we have exactly 1 element");
-
-                // ensure that the indexed variable was declared before the loop, see #601
-                if let Some(indexed_extent) = indexed_extent {
-                    let parent_id = cx.tcx.hir().get_parent_item(expr.hir_id);
-                    let parent_def_id = cx.tcx.hir().local_def_id(parent_id);
-                    let region_scope_tree = cx.tcx.region_scope_tree(parent_def_id);
-                    let pat_extent = region_scope_tree.var_scope(pat.hir_id.local_id);
-                    if region_scope_tree.is_subscope_of(indexed_extent, pat_extent) {
-                        return;
-                    }
-                }
-
-                // don't lint if the container that is indexed does not have .iter() method
-                let has_iter = has_iter_method(cx, indexed_ty);
-                if has_iter.is_none() {
-                    return;
-                }
-
-                // don't lint if the container that is indexed into is also used without
-                // indexing
-                if visitor.referenced.contains(&indexed) {
-                    return;
-                }
-
-                let starts_at_zero = is_integer_const(cx, start, 0);
-
-                let skip = if starts_at_zero {
-                    String::new()
-                } else if visitor.indexed_mut.contains(&indexed) && contains_name(indexed, start) {
-                    return;
-                } else {
-                    format!(".skip({})", snippet(cx, start.span, ".."))
-                };
-
-                let mut end_is_start_plus_val = false;
-
-                let take = if let Some(end) = *end {
-                    let mut take_expr = end;
-
-                    if let ExprKind::Binary(ref op, ref left, ref right) = end.kind {
-                        if let BinOpKind::Add = op.node {
-                            let start_equal_left = SpanlessEq::new(cx).eq_expr(start, left);
-                            let start_equal_right = SpanlessEq::new(cx).eq_expr(start, right);
-
-                            if start_equal_left {
-                                take_expr = right;
-                            } else if start_equal_right {
-                                take_expr = left;
-                            }
-
-                            end_is_start_plus_val = start_equal_left | start_equal_right;
-                        }
-                    }
-
-                    if is_len_call(end, indexed) || is_end_eq_array_len(cx, end, limits, indexed_ty) {
-                        String::new()
-                    } else if visitor.indexed_mut.contains(&indexed) && contains_name(indexed, take_expr) {
-                        return;
-                    } else {
-                        match limits {
-                            ast::RangeLimits::Closed => {
-                                let take_expr = sugg::Sugg::hir(cx, take_expr, "<count>");
-                                format!(".take({})", take_expr + sugg::ONE)
-                            },
-                            ast::RangeLimits::HalfOpen => format!(".take({})", snippet(cx, take_expr.span, "..")),
-                        }
-                    }
-                } else {
-                    String::new()
-                };
-
-                let (ref_mut, method) = if visitor.indexed_mut.contains(&indexed) {
-                    ("mut ", "iter_mut")
-                } else {
-                    ("", "iter")
-                };
-
-                let take_is_empty = take.is_empty();
-                let mut method_1 = take;
-                let mut method_2 = skip;
-
-                if end_is_start_plus_val {
-                    mem::swap(&mut method_1, &mut method_2);
-                }
-
-                if visitor.nonindex {
-                    span_lint_and_then(
-                        cx,
-                        super::NEEDLESS_RANGE_LOOP,
-                        expr.span,
-                        &format!("the loop variable `{}` is used to index `{}`", ident.name, indexed),
-                        |diag| {
-                            multispan_sugg(
-                                diag,
-                                "consider using an iterator",
-                                vec![
-                                    (pat.span, format!("({}, <item>)", ident.name)),
-                                    (
-                                        arg.span,
-                                        format!("{}.{}().enumerate(){}{}", indexed, method, method_1, method_2),
-                                    ),
-                                ],
-                            );
-                        },
-                    );
-                } else {
-                    let repl = if starts_at_zero && take_is_empty {
-                        format!("&{}{}", ref_mut, indexed)
-                    } else {
-                        format!("{}.{}(){}{}", indexed, method, method_1, method_2)
-                    };
-
-                    span_lint_and_then(
-                        cx,
-                        super::NEEDLESS_RANGE_LOOP,
-                        expr.span,
-                        &format!("the loop variable `{}` is only used to index `{}`", ident.name, indexed),
-                        |diag| {
-                            multispan_sugg(
-                                diag,
-                                "consider using an iterator",
-                                vec![(pat.span, "<item>".to_string()), (arg.span, repl)],
-                            );
-                        },
-                    );
-                }
-            }
-        }
-    }
-}
-
-fn is_len_call(expr: &Expr<'_>, var: Symbol) -> bool {
-    if_chain! {
-        if let ExprKind::MethodCall(ref method, _, ref len_args, _) = expr.kind;
-        if len_args.len() == 1;
-        if method.ident.name == sym!(len);
-        if let ExprKind::Path(QPath::Resolved(_, ref path)) = len_args[0].kind;
-        if path.segments.len() == 1;
-        if path.segments[0].ident.name == var;
-        then {
-            return true;
-        }
-    }
-
-    false
-}
-
-fn is_end_eq_array_len<'tcx>(
-    cx: &LateContext<'tcx>,
-    end: &Expr<'_>,
-    limits: ast::RangeLimits,
-    indexed_ty: Ty<'tcx>,
-) -> bool {
-    if_chain! {
-        if let ExprKind::Lit(ref lit) = end.kind;
-        if let ast::LitKind::Int(end_int, _) = lit.node;
-        if let ty::Array(_, arr_len_const) = indexed_ty.kind();
-        if let Some(arr_len) = arr_len_const.try_eval_usize(cx.tcx, cx.param_env);
-        then {
-            return match limits {
-                ast::RangeLimits::Closed => end_int + 1 >= arr_len.into(),
-                ast::RangeLimits::HalfOpen => end_int >= arr_len.into(),
-            };
-        }
-    }
-
-    false
-}
-
-struct VarVisitor<'a, 'tcx> {
-    /// context reference
-    cx: &'a LateContext<'tcx>,
-    /// var name to look for as index
-    var: HirId,
-    /// indexed variables that are used mutably
-    indexed_mut: FxHashSet<Symbol>,
-    /// indirectly indexed variables (`v[(i + 4) % N]`), the extend is `None` for global
-    indexed_indirectly: FxHashMap<Symbol, Option<region::Scope>>,
-    /// subset of `indexed` of vars that are indexed directly: `v[i]`
-    /// this will not contain cases like `v[calc_index(i)]` or `v[(i + 4) % N]`
-    indexed_directly: FxHashMap<Symbol, (Option<region::Scope>, Ty<'tcx>)>,
-    /// Any names that are used outside an index operation.
-    /// Used to detect things like `&mut vec` used together with `vec[i]`
-    referenced: FxHashSet<Symbol>,
-    /// has the loop variable been used in expressions other than the index of
-    /// an index op?
-    nonindex: bool,
-    /// Whether we are inside the `$` in `&mut $` or `$ = foo` or `$.bar`, where bar
-    /// takes `&mut self`
-    prefer_mutable: bool,
-}
-
-impl<'a, 'tcx> VarVisitor<'a, 'tcx> {
-    fn check(&mut self, idx: &'tcx Expr<'_>, seqexpr: &'tcx Expr<'_>, expr: &'tcx Expr<'_>) -> bool {
-        if_chain! {
-            // the indexed container is referenced by a name
-            if let ExprKind::Path(ref seqpath) = seqexpr.kind;
-            if let QPath::Resolved(None, ref seqvar) = *seqpath;
-            if seqvar.segments.len() == 1;
-            then {
-                let index_used_directly = path_to_local_id(idx, self.var);
-                let indexed_indirectly = {
-                    let mut used_visitor = LocalUsedVisitor::new(self.var);
-                    walk_expr(&mut used_visitor, idx);
-                    used_visitor.used
-                };
-
-                if indexed_indirectly || index_used_directly {
-                    if self.prefer_mutable {
-                        self.indexed_mut.insert(seqvar.segments[0].ident.name);
-                    }
-                    let res = self.cx.qpath_res(seqpath, seqexpr.hir_id);
-                    match res {
-                        Res::Local(hir_id) => {
-                            let parent_id = self.cx.tcx.hir().get_parent_item(expr.hir_id);
-                            let parent_def_id = self.cx.tcx.hir().local_def_id(parent_id);
-                            let extent = self.cx.tcx.region_scope_tree(parent_def_id).var_scope(hir_id.local_id);
-                            if indexed_indirectly {
-                                self.indexed_indirectly.insert(seqvar.segments[0].ident.name, Some(extent));
-                            }
-                            if index_used_directly {
-                                self.indexed_directly.insert(
-                                    seqvar.segments[0].ident.name,
-                                    (Some(extent), self.cx.typeck_results().node_type(seqexpr.hir_id)),
-                                );
-                            }
-                            return false;  // no need to walk further *on the variable*
-                        }
-                        Res::Def(DefKind::Static | DefKind::Const, ..) => {
-                            if indexed_indirectly {
-                                self.indexed_indirectly.insert(seqvar.segments[0].ident.name, None);
-                            }
-                            if index_used_directly {
-                                self.indexed_directly.insert(
-                                    seqvar.segments[0].ident.name,
-                                    (None, self.cx.typeck_results().node_type(seqexpr.hir_id)),
-                                );
-                            }
-                            return false;  // no need to walk further *on the variable*
-                        }
-                        _ => (),
-                    }
-                }
-            }
-        }
-        true
-    }
-}
-
-impl<'a, 'tcx> Visitor<'tcx> for VarVisitor<'a, 'tcx> {
-    type Map = Map<'tcx>;
-
-    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
-        if_chain! {
-            // a range index op
-            if let ExprKind::MethodCall(ref meth, _, ref args, _) = expr.kind;
-            if (meth.ident.name == sym::index && match_trait_method(self.cx, expr, &paths::INDEX))
-                || (meth.ident.name == sym::index_mut && match_trait_method(self.cx, expr, &paths::INDEX_MUT));
-            if !self.check(&args[1], &args[0], expr);
-            then { return }
-        }
-
-        if_chain! {
-            // an index op
-            if let ExprKind::Index(ref seqexpr, ref idx) = expr.kind;
-            if !self.check(idx, seqexpr, expr);
-            then { return }
-        }
-
-        if_chain! {
-            // directly using a variable
-            if let ExprKind::Path(QPath::Resolved(None, path)) = expr.kind;
-            if let Res::Local(local_id) = path.res;
-            then {
-                if local_id == self.var {
-                    self.nonindex = true;
-                } else {
-                    // not the correct variable, but still a variable
-                    self.referenced.insert(path.segments[0].ident.name);
-                }
-            }
-        }
-
-        let old = self.prefer_mutable;
-        match expr.kind {
-            ExprKind::AssignOp(_, ref lhs, ref rhs) | ExprKind::Assign(ref lhs, ref rhs, _) => {
-                self.prefer_mutable = true;
-                self.visit_expr(lhs);
-                self.prefer_mutable = false;
-                self.visit_expr(rhs);
-            },
-            ExprKind::AddrOf(BorrowKind::Ref, mutbl, ref expr) => {
-                if mutbl == Mutability::Mut {
-                    self.prefer_mutable = true;
-                }
-                self.visit_expr(expr);
-            },
-            ExprKind::Call(ref f, args) => {
-                self.visit_expr(f);
-                for expr in args {
-                    let ty = self.cx.typeck_results().expr_ty_adjusted(expr);
-                    self.prefer_mutable = false;
-                    if let ty::Ref(_, _, mutbl) = *ty.kind() {
-                        if mutbl == Mutability::Mut {
-                            self.prefer_mutable = true;
-                        }
-                    }
-                    self.visit_expr(expr);
-                }
-            },
-            ExprKind::MethodCall(_, _, args, _) => {
-                let def_id = self.cx.typeck_results().type_dependent_def_id(expr.hir_id).unwrap();
-                for (ty, expr) in self.cx.tcx.fn_sig(def_id).inputs().skip_binder().iter().zip(args) {
-                    self.prefer_mutable = false;
-                    if let ty::Ref(_, _, mutbl) = *ty.kind() {
-                        if mutbl == Mutability::Mut {
-                            self.prefer_mutable = true;
-                        }
-                    }
-                    self.visit_expr(expr);
-                }
-            },
-            ExprKind::Closure(_, _, body_id, ..) => {
-                let body = self.cx.tcx.hir().body(body_id);
-                self.visit_expr(&body.value);
-            },
-            _ => walk_expr(self, expr),
-        }
-        self.prefer_mutable = old;
-    }
-    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-        NestedVisitorMap::None
-    }
-}
diff --git a/clippy_lints/src/loops/for_mut_range_bound.rs b/clippy_lints/src/loops/for_mut_range_bound.rs
deleted file mode 100644
index d305c55cb95..00000000000
--- a/clippy_lints/src/loops/for_mut_range_bound.rs
+++ /dev/null
@@ -1,114 +0,0 @@
-use crate::utils::{higher, path_to_local, span_lint};
-use if_chain::if_chain;
-use rustc_hir::{BindingAnnotation, Expr, HirId, Node, PatKind};
-use rustc_infer::infer::TyCtxtInferExt;
-use rustc_lint::LateContext;
-use rustc_middle::ty;
-use rustc_span::source_map::Span;
-use rustc_typeck::expr_use_visitor::{ConsumeMode, Delegate, ExprUseVisitor, PlaceBase, PlaceWithHirId};
-
-pub(super) fn check_for_mut_range_bound(cx: &LateContext<'_>, arg: &Expr<'_>, body: &Expr<'_>) {
-    if let Some(higher::Range {
-        start: Some(start),
-        end: Some(end),
-        ..
-    }) = higher::range(arg)
-    {
-        let mut_ids = vec![check_for_mutability(cx, start), check_for_mutability(cx, end)];
-        if mut_ids[0].is_some() || mut_ids[1].is_some() {
-            let (span_low, span_high) = check_for_mutation(cx, body, &mut_ids);
-            mut_warn_with_span(cx, span_low);
-            mut_warn_with_span(cx, span_high);
-        }
-    }
-}
-
-fn mut_warn_with_span(cx: &LateContext<'_>, span: Option<Span>) {
-    if let Some(sp) = span {
-        span_lint(
-            cx,
-            super::MUT_RANGE_BOUND,
-            sp,
-            "attempt to mutate range bound within loop; note that the range of the loop is unchanged",
-        );
-    }
-}
-
-fn check_for_mutability(cx: &LateContext<'_>, bound: &Expr<'_>) -> Option<HirId> {
-    if_chain! {
-        if let Some(hir_id) = path_to_local(bound);
-        if let Node::Binding(pat) = cx.tcx.hir().get(hir_id);
-        if let PatKind::Binding(BindingAnnotation::Mutable, ..) = pat.kind;
-        then {
-            return Some(hir_id);
-        }
-    }
-    None
-}
-
-fn check_for_mutation<'tcx>(
-    cx: &LateContext<'tcx>,
-    body: &Expr<'_>,
-    bound_ids: &[Option<HirId>],
-) -> (Option<Span>, Option<Span>) {
-    let mut delegate = MutatePairDelegate {
-        cx,
-        hir_id_low: bound_ids[0],
-        hir_id_high: bound_ids[1],
-        span_low: None,
-        span_high: None,
-    };
-    cx.tcx.infer_ctxt().enter(|infcx| {
-        ExprUseVisitor::new(
-            &mut delegate,
-            &infcx,
-            body.hir_id.owner,
-            cx.param_env,
-            cx.typeck_results(),
-        )
-        .walk_expr(body);
-    });
-    delegate.mutation_span()
-}
-
-struct MutatePairDelegate<'a, 'tcx> {
-    cx: &'a LateContext<'tcx>,
-    hir_id_low: Option<HirId>,
-    hir_id_high: Option<HirId>,
-    span_low: Option<Span>,
-    span_high: Option<Span>,
-}
-
-impl<'tcx> Delegate<'tcx> for MutatePairDelegate<'_, 'tcx> {
-    fn consume(&mut self, _: &PlaceWithHirId<'tcx>, _: HirId, _: ConsumeMode) {}
-
-    fn borrow(&mut self, cmt: &PlaceWithHirId<'tcx>, diag_expr_id: HirId, bk: ty::BorrowKind) {
-        if let ty::BorrowKind::MutBorrow = bk {
-            if let PlaceBase::Local(id) = cmt.place.base {
-                if Some(id) == self.hir_id_low {
-                    self.span_low = Some(self.cx.tcx.hir().span(diag_expr_id))
-                }
-                if Some(id) == self.hir_id_high {
-                    self.span_high = Some(self.cx.tcx.hir().span(diag_expr_id))
-                }
-            }
-        }
-    }
-
-    fn mutate(&mut self, cmt: &PlaceWithHirId<'tcx>, diag_expr_id: HirId) {
-        if let PlaceBase::Local(id) = cmt.place.base {
-            if Some(id) == self.hir_id_low {
-                self.span_low = Some(self.cx.tcx.hir().span(diag_expr_id))
-            }
-            if Some(id) == self.hir_id_high {
-                self.span_high = Some(self.cx.tcx.hir().span(diag_expr_id))
-            }
-        }
-    }
-}
-
-impl MutatePairDelegate<'_, '_> {
-    fn mutation_span(&self) -> (Option<Span>, Option<Span>) {
-        (self.span_low, self.span_high)
-    }
-}
diff --git a/clippy_lints/src/loops/for_single_element_loop.rs b/clippy_lints/src/loops/for_single_element_loop.rs
deleted file mode 100644
index 8ba19a2233a..00000000000
--- a/clippy_lints/src/loops/for_single_element_loop.rs
+++ /dev/null
@@ -1,42 +0,0 @@
-use super::get_span_of_entire_for_loop;
-use crate::utils::{indent_of, single_segment_path, snippet, span_lint_and_sugg};
-use if_chain::if_chain;
-use rustc_errors::Applicability;
-use rustc_hir::{BorrowKind, Expr, ExprKind, Pat, PatKind};
-use rustc_lint::LateContext;
-
-pub(super) fn check_for_single_element_loop<'tcx>(
-    cx: &LateContext<'tcx>,
-    pat: &'tcx Pat<'_>,
-    arg: &'tcx Expr<'_>,
-    body: &'tcx Expr<'_>,
-    expr: &'tcx Expr<'_>,
-) {
-    if_chain! {
-        if let ExprKind::AddrOf(BorrowKind::Ref, _, ref arg_expr) = arg.kind;
-        if let PatKind::Binding(.., target, _) = pat.kind;
-        if let ExprKind::Array([arg_expression]) = arg_expr.kind;
-        if let ExprKind::Path(ref list_item) = arg_expression.kind;
-        if let Some(list_item_name) = single_segment_path(list_item).map(|ps| ps.ident.name);
-        if let ExprKind::Block(ref block, _) = body.kind;
-        if !block.stmts.is_empty();
-
-        then {
-            let for_span = get_span_of_entire_for_loop(expr);
-            let mut block_str = snippet(cx, block.span, "..").into_owned();
-            block_str.remove(0);
-            block_str.pop();
-
-
-            span_lint_and_sugg(
-                cx,
-                super::SINGLE_ELEMENT_LOOP,
-                for_span,
-                "for loop over a single element",
-                "try",
-                format!("{{\n{}let {} = &{};{}}}", " ".repeat(indent_of(cx, block.stmts[0].span).unwrap_or(0)), target.name, list_item_name, block_str),
-                Applicability::MachineApplicable
-            )
-        }
-    }
-}
diff --git a/clippy_lints/src/loops/infinite_loop.rs b/clippy_lints/src/loops/infinite_loop.rs
deleted file mode 100644
index b89942fb647..00000000000
--- a/clippy_lints/src/loops/infinite_loop.rs
+++ /dev/null
@@ -1,138 +0,0 @@
-use crate::consts::constant;
-use crate::utils::span_lint_and_then;
-use crate::utils::usage::mutated_variables;
-use if_chain::if_chain;
-use rustc_data_structures::fx::{FxHashMap, FxHashSet};
-use rustc_hir::def::{DefKind, Res};
-use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
-use rustc_hir::{def_id, Expr, ExprKind, HirId, QPath};
-use rustc_lint::LateContext;
-use rustc_middle::hir::map::Map;
-use std::iter::Iterator;
-
-pub(super) fn check_infinite_loop<'tcx>(cx: &LateContext<'tcx>, cond: &'tcx Expr<'_>, expr: &'tcx Expr<'_>) {
-    if constant(cx, cx.typeck_results(), cond).is_some() {
-        // A pure constant condition (e.g., `while false`) is not linted.
-        return;
-    }
-
-    let mut var_visitor = VarCollectorVisitor {
-        cx,
-        ids: FxHashSet::default(),
-        def_ids: FxHashMap::default(),
-        skip: false,
-    };
-    var_visitor.visit_expr(cond);
-    if var_visitor.skip {
-        return;
-    }
-    let used_in_condition = &var_visitor.ids;
-    let no_cond_variable_mutated = if let Some(used_mutably) = mutated_variables(expr, cx) {
-        used_in_condition.is_disjoint(&used_mutably)
-    } else {
-        return;
-    };
-    let mutable_static_in_cond = var_visitor.def_ids.iter().any(|(_, v)| *v);
-
-    let mut has_break_or_return_visitor = HasBreakOrReturnVisitor {
-        has_break_or_return: false,
-    };
-    has_break_or_return_visitor.visit_expr(expr);
-    let has_break_or_return = has_break_or_return_visitor.has_break_or_return;
-
-    if no_cond_variable_mutated && !mutable_static_in_cond {
-        span_lint_and_then(
-            cx,
-            super::WHILE_IMMUTABLE_CONDITION,
-            cond.span,
-            "variables in the condition are not mutated in the loop body",
-            |diag| {
-                diag.note("this may lead to an infinite or to a never running loop");
-
-                if has_break_or_return {
-                    diag.note("this loop contains `return`s or `break`s");
-                    diag.help("rewrite it as `if cond { loop { } }`");
-                }
-            },
-        );
-    }
-}
-
-struct HasBreakOrReturnVisitor {
-    has_break_or_return: bool,
-}
-
-impl<'tcx> Visitor<'tcx> for HasBreakOrReturnVisitor {
-    type Map = Map<'tcx>;
-
-    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
-        if self.has_break_or_return {
-            return;
-        }
-
-        match expr.kind {
-            ExprKind::Ret(_) | ExprKind::Break(_, _) => {
-                self.has_break_or_return = true;
-                return;
-            },
-            _ => {},
-        }
-
-        walk_expr(self, expr);
-    }
-
-    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-        NestedVisitorMap::None
-    }
-}
-
-/// Collects the set of variables in an expression
-/// Stops analysis if a function call is found
-/// Note: In some cases such as `self`, there are no mutable annotation,
-/// All variables definition IDs are collected
-struct VarCollectorVisitor<'a, 'tcx> {
-    cx: &'a LateContext<'tcx>,
-    ids: FxHashSet<HirId>,
-    def_ids: FxHashMap<def_id::DefId, bool>,
-    skip: bool,
-}
-
-impl<'a, 'tcx> VarCollectorVisitor<'a, 'tcx> {
-    fn insert_def_id(&mut self, ex: &'tcx Expr<'_>) {
-        if_chain! {
-            if let ExprKind::Path(ref qpath) = ex.kind;
-            if let QPath::Resolved(None, _) = *qpath;
-            let res = self.cx.qpath_res(qpath, ex.hir_id);
-            then {
-                match res {
-                    Res::Local(hir_id) => {
-                        self.ids.insert(hir_id);
-                    },
-                    Res::Def(DefKind::Static, def_id) => {
-                        let mutable = self.cx.tcx.is_mutable_static(def_id);
-                        self.def_ids.insert(def_id, mutable);
-                    },
-                    _ => {},
-                }
-            }
-        }
-    }
-}
-
-impl<'a, 'tcx> Visitor<'tcx> for VarCollectorVisitor<'a, 'tcx> {
-    type Map = Map<'tcx>;
-
-    fn visit_expr(&mut self, ex: &'tcx Expr<'_>) {
-        match ex.kind {
-            ExprKind::Path(_) => self.insert_def_id(ex),
-            // If there is any function/method call… we just stop analysis
-            ExprKind::Call(..) | ExprKind::MethodCall(..) => self.skip = true,
-
-            _ => walk_expr(self, ex),
-        }
-    }
-
-    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-        NestedVisitorMap::None
-    }
-}
diff --git a/clippy_lints/src/loops/manual_flatten.rs b/clippy_lints/src/loops/manual_flatten.rs
index db90d2c0468..efacda77284 100644
--- a/clippy_lints/src/loops/manual_flatten.rs
+++ b/clippy_lints/src/loops/manual_flatten.rs
@@ -1,4 +1,5 @@
 use super::utils::make_iterator_snippet;
+use super::MANUAL_FLATTEN;
 use crate::utils::{is_ok_ctor, is_some_ctor, path_to_local_id, span_lint_and_then};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
@@ -55,7 +56,7 @@ pub(super) fn check_manual_flatten<'tcx>(
 
                 span_lint_and_then(
                     cx,
-                    super::MANUAL_FLATTEN,
+                    MANUAL_FLATTEN,
                     span,
                     &msg,
                     |diag| {
diff --git a/clippy_lints/src/loops/manual_memcpy.rs b/clippy_lints/src/loops/manual_memcpy.rs
index 13a434aa210..e3080d9f556 100644
--- a/clippy_lints/src/loops/manual_memcpy.rs
+++ b/clippy_lints/src/loops/manual_memcpy.rs
@@ -1,4 +1,4 @@
-use super::{get_span_of_entire_for_loop, IncrementVisitor, InitializeVisitor};
+use super::{get_span_of_entire_for_loop, IncrementVisitor, InitializeVisitor, MANUAL_MEMCPY};
 use crate::utils::sugg::Sugg;
 use crate::utils::{
     get_enclosing_block, higher, is_type_diagnostic_item, path_to_local, snippet, span_lint_and_sugg, sugg,
@@ -84,7 +84,7 @@ pub(super) fn detect_manual_memcpy<'tcx>(
             if let Some(big_sugg) = big_sugg {
                 span_lint_and_sugg(
                     cx,
-                    super::MANUAL_MEMCPY,
+                    MANUAL_MEMCPY,
                     get_span_of_entire_for_loop(expr),
                     "it looks like you're manually copying between slices",
                     "try replacing the loop by",
diff --git a/clippy_lints/src/loops/mod.rs b/clippy_lints/src/loops/mod.rs
index 4594afc2332..0d408698fc9 100644
--- a/clippy_lints/src/loops/mod.rs
+++ b/clippy_lints/src/loops/mod.rs
@@ -2,19 +2,19 @@ mod empty_loop;
 mod explicit_counter_loop;
 mod explicit_into_iter_loop;
 mod explicit_iter_loop;
-mod for_loop_over_map_kv;
-mod for_loop_range;
+mod for_kv_map;
 mod for_loops_over_fallibles;
-mod for_mut_range_bound;
-mod for_single_element_loop;
-mod infinite_loop;
 mod iter_next_loop;
 mod manual_flatten;
 mod manual_memcpy;
+mod mut_range_bound;
 mod needless_collect;
+mod needless_range_loop;
 mod never_loop;
 mod same_item_push;
+mod single_element_loop;
 mod utils;
+mod while_immutable_condition;
 mod while_let_loop;
 mod while_let_on_iterator;
 
@@ -573,7 +573,7 @@ impl<'tcx> LateLintPass<'tcx> for Loops {
         while_let_on_iterator::check_while_let_on_iterator(cx, expr);
 
         if let Some((cond, body)) = higher::while_loop(&expr) {
-            infinite_loop::check_infinite_loop(cx, cond, body);
+            while_immutable_condition::check_infinite_loop(cx, cond, body);
         }
 
         needless_collect::check_needless_collect(expr, cx);
@@ -590,13 +590,13 @@ fn check_for_loop<'tcx>(
 ) {
     let is_manual_memcpy_triggered = manual_memcpy::detect_manual_memcpy(cx, pat, arg, body, expr);
     if !is_manual_memcpy_triggered {
-        for_loop_range::check_for_loop_range(cx, pat, arg, body, expr);
+        needless_range_loop::check_for_loop_range(cx, pat, arg, body, expr);
         explicit_counter_loop::check_for_loop_explicit_counter(cx, pat, arg, body, expr);
     }
     check_for_loop_arg(cx, pat, arg, expr);
-    for_loop_over_map_kv::check_for_loop_over_map_kv(cx, pat, arg, body, expr);
-    for_mut_range_bound::check_for_mut_range_bound(cx, arg, body);
-    for_single_element_loop::check_for_single_element_loop(cx, pat, arg, body, expr);
+    for_kv_map::check_for_loop_over_map_kv(cx, pat, arg, body, expr);
+    mut_range_bound::check_for_mut_range_bound(cx, arg, body);
+    single_element_loop::check_for_single_element_loop(cx, pat, arg, body, expr);
     same_item_push::detect_same_item_push(cx, pat, arg, body, expr);
     manual_flatten::check_manual_flatten(cx, pat, arg, body, span);
 }
diff --git a/clippy_lints/src/loops/mut_range_bound.rs b/clippy_lints/src/loops/mut_range_bound.rs
new file mode 100644
index 00000000000..9f31617edeb
--- /dev/null
+++ b/clippy_lints/src/loops/mut_range_bound.rs
@@ -0,0 +1,115 @@
+use super::MUT_RANGE_BOUND;
+use crate::utils::{higher, path_to_local, span_lint};
+use if_chain::if_chain;
+use rustc_hir::{BindingAnnotation, Expr, HirId, Node, PatKind};
+use rustc_infer::infer::TyCtxtInferExt;
+use rustc_lint::LateContext;
+use rustc_middle::ty;
+use rustc_span::source_map::Span;
+use rustc_typeck::expr_use_visitor::{ConsumeMode, Delegate, ExprUseVisitor, PlaceBase, PlaceWithHirId};
+
+pub(super) fn check_for_mut_range_bound(cx: &LateContext<'_>, arg: &Expr<'_>, body: &Expr<'_>) {
+    if let Some(higher::Range {
+        start: Some(start),
+        end: Some(end),
+        ..
+    }) = higher::range(arg)
+    {
+        let mut_ids = vec![check_for_mutability(cx, start), check_for_mutability(cx, end)];
+        if mut_ids[0].is_some() || mut_ids[1].is_some() {
+            let (span_low, span_high) = check_for_mutation(cx, body, &mut_ids);
+            mut_warn_with_span(cx, span_low);
+            mut_warn_with_span(cx, span_high);
+        }
+    }
+}
+
+fn mut_warn_with_span(cx: &LateContext<'_>, span: Option<Span>) {
+    if let Some(sp) = span {
+        span_lint(
+            cx,
+            MUT_RANGE_BOUND,
+            sp,
+            "attempt to mutate range bound within loop; note that the range of the loop is unchanged",
+        );
+    }
+}
+
+fn check_for_mutability(cx: &LateContext<'_>, bound: &Expr<'_>) -> Option<HirId> {
+    if_chain! {
+        if let Some(hir_id) = path_to_local(bound);
+        if let Node::Binding(pat) = cx.tcx.hir().get(hir_id);
+        if let PatKind::Binding(BindingAnnotation::Mutable, ..) = pat.kind;
+        then {
+            return Some(hir_id);
+        }
+    }
+    None
+}
+
+fn check_for_mutation<'tcx>(
+    cx: &LateContext<'tcx>,
+    body: &Expr<'_>,
+    bound_ids: &[Option<HirId>],
+) -> (Option<Span>, Option<Span>) {
+    let mut delegate = MutatePairDelegate {
+        cx,
+        hir_id_low: bound_ids[0],
+        hir_id_high: bound_ids[1],
+        span_low: None,
+        span_high: None,
+    };
+    cx.tcx.infer_ctxt().enter(|infcx| {
+        ExprUseVisitor::new(
+            &mut delegate,
+            &infcx,
+            body.hir_id.owner,
+            cx.param_env,
+            cx.typeck_results(),
+        )
+        .walk_expr(body);
+    });
+    delegate.mutation_span()
+}
+
+struct MutatePairDelegate<'a, 'tcx> {
+    cx: &'a LateContext<'tcx>,
+    hir_id_low: Option<HirId>,
+    hir_id_high: Option<HirId>,
+    span_low: Option<Span>,
+    span_high: Option<Span>,
+}
+
+impl<'tcx> Delegate<'tcx> for MutatePairDelegate<'_, 'tcx> {
+    fn consume(&mut self, _: &PlaceWithHirId<'tcx>, _: HirId, _: ConsumeMode) {}
+
+    fn borrow(&mut self, cmt: &PlaceWithHirId<'tcx>, diag_expr_id: HirId, bk: ty::BorrowKind) {
+        if let ty::BorrowKind::MutBorrow = bk {
+            if let PlaceBase::Local(id) = cmt.place.base {
+                if Some(id) == self.hir_id_low {
+                    self.span_low = Some(self.cx.tcx.hir().span(diag_expr_id))
+                }
+                if Some(id) == self.hir_id_high {
+                    self.span_high = Some(self.cx.tcx.hir().span(diag_expr_id))
+                }
+            }
+        }
+    }
+
+    fn mutate(&mut self, cmt: &PlaceWithHirId<'tcx>, diag_expr_id: HirId) {
+        if let PlaceBase::Local(id) = cmt.place.base {
+            if Some(id) == self.hir_id_low {
+                self.span_low = Some(self.cx.tcx.hir().span(diag_expr_id))
+            }
+            if Some(id) == self.hir_id_high {
+                self.span_high = Some(self.cx.tcx.hir().span(diag_expr_id))
+            }
+        }
+    }
+}
+
+impl MutatePairDelegate<'_, '_> {
+    fn mutation_span(&self) -> (Option<Span>, Option<Span>) {
+        (self.span_low, self.span_high)
+    }
+}
diff --git a/clippy_lints/src/loops/needless_collect.rs b/clippy_lints/src/loops/needless_collect.rs
index cc2e2975492..d1ce055445b 100644
--- a/clippy_lints/src/loops/needless_collect.rs
+++ b/clippy_lints/src/loops/needless_collect.rs
@@ -1,3 +1,4 @@
+use super::NEEDLESS_COLLECT;
 use crate::utils::sugg::Sugg;
 use crate::utils::{
     is_type_diagnostic_item, match_trait_method, match_type, path_to_local_id, paths, snippet, span_lint_and_sugg,
@@ -35,7 +36,7 @@ fn check_needless_collect_direct_usage<'tcx>(expr: &'tcx Expr<'_>, cx: &LateCont
                     let span = shorten_needless_collect_span(expr);
                     span_lint_and_sugg(
                         cx,
-                        super::NEEDLESS_COLLECT,
+                        NEEDLESS_COLLECT,
                         span,
                         NEEDLESS_COLLECT_MSG,
                         "replace with",
@@ -47,7 +48,7 @@ fn check_needless_collect_direct_usage<'tcx>(expr: &'tcx Expr<'_>, cx: &LateCont
                     let span = shorten_needless_collect_span(expr);
                     span_lint_and_sugg(
                         cx,
-                        super::NEEDLESS_COLLECT,
+                        NEEDLESS_COLLECT,
                         span,
                         NEEDLESS_COLLECT_MSG,
                         "replace with",
@@ -60,7 +61,7 @@ fn check_needless_collect_direct_usage<'tcx>(expr: &'tcx Expr<'_>, cx: &LateCont
                     let span = shorten_needless_collect_span(expr);
                     span_lint_and_then(
                         cx,
-                        super::NEEDLESS_COLLECT,
+                        NEEDLESS_COLLECT,
                         span,
                         NEEDLESS_COLLECT_MSG,
                         |diag| {
diff --git a/clippy_lints/src/loops/needless_range_loop.rs b/clippy_lints/src/loops/needless_range_loop.rs
new file mode 100644
index 00000000000..298753cc031
--- /dev/null
+++ b/clippy_lints/src/loops/needless_range_loop.rs
@@ -0,0 +1,391 @@
+use super::NEEDLESS_RANGE_LOOP;
+use crate::utils::visitors::LocalUsedVisitor;
+use crate::utils::{
+    contains_name, has_iter_method, higher, is_integer_const, match_trait_method, multispan_sugg, path_to_local_id,
+    paths, snippet, span_lint_and_then, sugg, SpanlessEq,
+};
+use if_chain::if_chain;
+use rustc_ast::ast;
+use rustc_data_structures::fx::{FxHashMap, FxHashSet};
+use rustc_hir::def::{DefKind, Res};
+use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
+use rustc_hir::{BinOpKind, BorrowKind, Expr, ExprKind, HirId, Mutability, Pat, PatKind, QPath};
+use rustc_lint::LateContext;
+use rustc_middle::hir::map::Map;
+use rustc_middle::middle::region;
+use rustc_middle::ty::{self, Ty};
+use rustc_span::symbol::{sym, Symbol};
+use std::iter::Iterator;
+use std::mem;
+
+/// Checks for looping over a range and then indexing a sequence with it.
+/// The iteratee must be a range literal.
+#[allow(clippy::too_many_lines)]
+pub(super) fn check_for_loop_range<'tcx>(
+    cx: &LateContext<'tcx>,
+    pat: &'tcx Pat<'_>,
+    arg: &'tcx Expr<'_>,
+    body: &'tcx Expr<'_>,
+    expr: &'tcx Expr<'_>,
+) {
+    if let Some(higher::Range {
+        start: Some(start),
+        ref end,
+        limits,
+    }) = higher::range(arg)
+    {
+        // the var must be a single name
+        if let PatKind::Binding(_, canonical_id, ident, _) = pat.kind {
+            let mut visitor = VarVisitor {
+                cx,
+                var: canonical_id,
+                indexed_mut: FxHashSet::default(),
+                indexed_indirectly: FxHashMap::default(),
+                indexed_directly: FxHashMap::default(),
+                referenced: FxHashSet::default(),
+                nonindex: false,
+                prefer_mutable: false,
+            };
+            walk_expr(&mut visitor, body);
+
+            // linting condition: we only indexed one variable, and indexed it directly
+            if visitor.indexed_indirectly.is_empty() && visitor.indexed_directly.len() == 1 {
+                let (indexed, (indexed_extent, indexed_ty)) = visitor
+                    .indexed_directly
+                    .into_iter()
+                    .next()
+                    .expect("already checked that we have exactly 1 element");
+
+                // ensure that the indexed variable was declared before the loop, see #601
+                if let Some(indexed_extent) = indexed_extent {
+                    let parent_id = cx.tcx.hir().get_parent_item(expr.hir_id);
+                    let parent_def_id = cx.tcx.hir().local_def_id(parent_id);
+                    let region_scope_tree = cx.tcx.region_scope_tree(parent_def_id);
+                    let pat_extent = region_scope_tree.var_scope(pat.hir_id.local_id);
+                    if region_scope_tree.is_subscope_of(indexed_extent, pat_extent) {
+                        return;
+                    }
+                }
+
+                // don't lint if the container that is indexed does not have .iter() method
+                let has_iter = has_iter_method(cx, indexed_ty);
+                if has_iter.is_none() {
+                    return;
+                }
+
+                // don't lint if the container that is indexed into is also used without
+                // indexing
+                if visitor.referenced.contains(&indexed) {
+                    return;
+                }
+
+                let starts_at_zero = is_integer_const(cx, start, 0);
+
+                let skip = if starts_at_zero {
+                    String::new()
+                } else if visitor.indexed_mut.contains(&indexed) && contains_name(indexed, start) {
+                    return;
+                } else {
+                    format!(".skip({})", snippet(cx, start.span, ".."))
+                };
+
+                let mut end_is_start_plus_val = false;
+
+                let take = if let Some(end) = *end {
+                    let mut take_expr = end;
+
+                    if let ExprKind::Binary(ref op, ref left, ref right) = end.kind {
+                        if let BinOpKind::Add = op.node {
+                            let start_equal_left = SpanlessEq::new(cx).eq_expr(start, left);
+                            let start_equal_right = SpanlessEq::new(cx).eq_expr(start, right);
+
+                            if start_equal_left {
+                                take_expr = right;
+                            } else if start_equal_right {
+                                take_expr = left;
+                            }
+
+                            end_is_start_plus_val = start_equal_left | start_equal_right;
+                        }
+                    }
+
+                    if is_len_call(end, indexed) || is_end_eq_array_len(cx, end, limits, indexed_ty) {
+                        String::new()
+                    } else if visitor.indexed_mut.contains(&indexed) && contains_name(indexed, take_expr) {
+                        return;
+                    } else {
+                        match limits {
+                            ast::RangeLimits::Closed => {
+                                let take_expr = sugg::Sugg::hir(cx, take_expr, "<count>");
+                                format!(".take({})", take_expr + sugg::ONE)
+                            },
+                            ast::RangeLimits::HalfOpen => format!(".take({})", snippet(cx, take_expr.span, "..")),
+                        }
+                    }
+                } else {
+                    String::new()
+                };
+
+                let (ref_mut, method) = if visitor.indexed_mut.contains(&indexed) {
+                    ("mut ", "iter_mut")
+                } else {
+                    ("", "iter")
+                };
+
+                let take_is_empty = take.is_empty();
+                let mut method_1 = take;
+                let mut method_2 = skip;
+
+                if end_is_start_plus_val {
+                    mem::swap(&mut method_1, &mut method_2);
+                }
+
+                if visitor.nonindex {
+                    span_lint_and_then(
+                        cx,
+                        NEEDLESS_RANGE_LOOP,
+                        expr.span,
+                        &format!("the loop variable `{}` is used to index `{}`", ident.name, indexed),
+                        |diag| {
+                            multispan_sugg(
+                                diag,
+                                "consider using an iterator",
+                                vec![
+                                    (pat.span, format!("({}, <item>)", ident.name)),
+                                    (
+                                        arg.span,
+                                        format!("{}.{}().enumerate(){}{}", indexed, method, method_1, method_2),
+                                    ),
+                                ],
+                            );
+                        },
+                    );
+                } else {
+                    let repl = if starts_at_zero && take_is_empty {
+                        format!("&{}{}", ref_mut, indexed)
+                    } else {
+                        format!("{}.{}(){}{}", indexed, method, method_1, method_2)
+                    };
+
+                    span_lint_and_then(
+                        cx,
+                        NEEDLESS_RANGE_LOOP,
+                        expr.span,
+                        &format!("the loop variable `{}` is only used to index `{}`", ident.name, indexed),
+                        |diag| {
+                            multispan_sugg(
+                                diag,
+                                "consider using an iterator",
+                                vec![(pat.span, "<item>".to_string()), (arg.span, repl)],
+                            );
+                        },
+                    );
+                }
+            }
+        }
+    }
+}
+
+fn is_len_call(expr: &Expr<'_>, var: Symbol) -> bool {
+    if_chain! {
+        if let ExprKind::MethodCall(ref method, _, ref len_args, _) = expr.kind;
+        if len_args.len() == 1;
+        if method.ident.name == sym!(len);
+        if let ExprKind::Path(QPath::Resolved(_, ref path)) = len_args[0].kind;
+        if path.segments.len() == 1;
+        if path.segments[0].ident.name == var;
+        then {
+            return true;
+        }
+    }
+
+    false
+}
+
+fn is_end_eq_array_len<'tcx>(
+    cx: &LateContext<'tcx>,
+    end: &Expr<'_>,
+    limits: ast::RangeLimits,
+    indexed_ty: Ty<'tcx>,
+) -> bool {
+    if_chain! {
+        if let ExprKind::Lit(ref lit) = end.kind;
+        if let ast::LitKind::Int(end_int, _) = lit.node;
+        if let ty::Array(_, arr_len_const) = indexed_ty.kind();
+        if let Some(arr_len) = arr_len_const.try_eval_usize(cx.tcx, cx.param_env);
+        then {
+            return match limits {
+                ast::RangeLimits::Closed => end_int + 1 >= arr_len.into(),
+                ast::RangeLimits::HalfOpen => end_int >= arr_len.into(),
+            };
+        }
+    }
+
+    false
+}
+
+struct VarVisitor<'a, 'tcx> {
+    /// context reference
+    cx: &'a LateContext<'tcx>,
+    /// var name to look for as index
+    var: HirId,
+    /// indexed variables that are used mutably
+    indexed_mut: FxHashSet<Symbol>,
+    /// indirectly indexed variables (`v[(i + 4) % N]`), the extend is `None` for global
+    indexed_indirectly: FxHashMap<Symbol, Option<region::Scope>>,
+    /// subset of `indexed` of vars that are indexed directly: `v[i]`
+    /// this will not contain cases like `v[calc_index(i)]` or `v[(i + 4) % N]`
+    indexed_directly: FxHashMap<Symbol, (Option<region::Scope>, Ty<'tcx>)>,
+    /// Any names that are used outside an index operation.
+    /// Used to detect things like `&mut vec` used together with `vec[i]`
+    referenced: FxHashSet<Symbol>,
+    /// has the loop variable been used in expressions other than the index of
+    /// an index op?
+    nonindex: bool,
+    /// Whether we are inside the `$` in `&mut $` or `$ = foo` or `$.bar`, where bar
+    /// takes `&mut self`
+    prefer_mutable: bool,
+}
+
+impl<'a, 'tcx> VarVisitor<'a, 'tcx> {
+    fn check(&mut self, idx: &'tcx Expr<'_>, seqexpr: &'tcx Expr<'_>, expr: &'tcx Expr<'_>) -> bool {
+        if_chain! {
+            // the indexed container is referenced by a name
+            if let ExprKind::Path(ref seqpath) = seqexpr.kind;
+            if let QPath::Resolved(None, ref seqvar) = *seqpath;
+            if seqvar.segments.len() == 1;
+            then {
+                let index_used_directly = path_to_local_id(idx, self.var);
+                let indexed_indirectly = {
+                    let mut used_visitor = LocalUsedVisitor::new(self.var);
+                    walk_expr(&mut used_visitor, idx);
+                    used_visitor.used
+                };
+
+                if indexed_indirectly || index_used_directly {
+                    if self.prefer_mutable {
+                        self.indexed_mut.insert(seqvar.segments[0].ident.name);
+                    }
+                    let res = self.cx.qpath_res(seqpath, seqexpr.hir_id);
+                    match res {
+                        Res::Local(hir_id) => {
+                            let parent_id = self.cx.tcx.hir().get_parent_item(expr.hir_id);
+                            let parent_def_id = self.cx.tcx.hir().local_def_id(parent_id);
+                            let extent = self.cx.tcx.region_scope_tree(parent_def_id).var_scope(hir_id.local_id);
+                            if indexed_indirectly {
+                                self.indexed_indirectly.insert(seqvar.segments[0].ident.name, Some(extent));
+                            }
+                            if index_used_directly {
+                                self.indexed_directly.insert(
+                                    seqvar.segments[0].ident.name,
+                                    (Some(extent), self.cx.typeck_results().node_type(seqexpr.hir_id)),
+                                );
+                            }
+                            return false;  // no need to walk further *on the variable*
+                        }
+                        Res::Def(DefKind::Static | DefKind::Const, ..) => {
+                            if indexed_indirectly {
+                                self.indexed_indirectly.insert(seqvar.segments[0].ident.name, None);
+                            }
+                            if index_used_directly {
+                                self.indexed_directly.insert(
+                                    seqvar.segments[0].ident.name,
+                                    (None, self.cx.typeck_results().node_type(seqexpr.hir_id)),
+                                );
+                            }
+                            return false;  // no need to walk further *on the variable*
+                        }
+                        _ => (),
+                    }
+                }
+            }
+        }
+        true
+    }
+}
+
+impl<'a, 'tcx> Visitor<'tcx> for VarVisitor<'a, 'tcx> {
+    type Map = Map<'tcx>;
+
+    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
+        if_chain! {
+            // a range index op
+            if let ExprKind::MethodCall(ref meth, _, ref args, _) = expr.kind;
+            if (meth.ident.name == sym::index && match_trait_method(self.cx, expr, &paths::INDEX))
+                || (meth.ident.name == sym::index_mut && match_trait_method(self.cx, expr, &paths::INDEX_MUT));
+            if !self.check(&args[1], &args[0], expr);
+            then { return }
+        }
+
+        if_chain! {
+            // an index op
+            if let ExprKind::Index(ref seqexpr, ref idx) = expr.kind;
+            if !self.check(idx, seqexpr, expr);
+            then { return }
+        }
+
+        if_chain! {
+            // directly using a variable
+            if let ExprKind::Path(QPath::Resolved(None, path)) = expr.kind;
+            if let Res::Local(local_id) = path.res;
+            then {
+                if local_id == self.var {
+                    self.nonindex = true;
+                } else {
+                    // not the correct variable, but still a variable
+                    self.referenced.insert(path.segments[0].ident.name);
+                }
+            }
+        }
+
+        let old = self.prefer_mutable;
+        match expr.kind {
+            ExprKind::AssignOp(_, ref lhs, ref rhs) | ExprKind::Assign(ref lhs, ref rhs, _) => {
+                self.prefer_mutable = true;
+                self.visit_expr(lhs);
+                self.prefer_mutable = false;
+                self.visit_expr(rhs);
+            },
+            ExprKind::AddrOf(BorrowKind::Ref, mutbl, ref expr) => {
+                if mutbl == Mutability::Mut {
+                    self.prefer_mutable = true;
+                }
+                self.visit_expr(expr);
+            },
+            ExprKind::Call(ref f, args) => {
+                self.visit_expr(f);
+                for expr in args {
+                    let ty = self.cx.typeck_results().expr_ty_adjusted(expr);
+                    self.prefer_mutable = false;
+                    if let ty::Ref(_, _, mutbl) = *ty.kind() {
+                        if mutbl == Mutability::Mut {
+                            self.prefer_mutable = true;
+                        }
+                    }
+                    self.visit_expr(expr);
+                }
+            },
+            ExprKind::MethodCall(_, _, args, _) => {
+                let def_id = self.cx.typeck_results().type_dependent_def_id(expr.hir_id).unwrap();
+                for (ty, expr) in self.cx.tcx.fn_sig(def_id).inputs().skip_binder().iter().zip(args) {
+                    self.prefer_mutable = false;
+                    if let ty::Ref(_, _, mutbl) = *ty.kind() {
+                        if mutbl == Mutability::Mut {
+                            self.prefer_mutable = true;
+                        }
+                    }
+                    self.visit_expr(expr);
+                }
+            },
+            ExprKind::Closure(_, _, body_id, ..) => {
+                let body = self.cx.tcx.hir().body(body_id);
+                self.visit_expr(&body.value);
+            },
+            _ => walk_expr(self, expr),
+        }
+        self.prefer_mutable = old;
+    }
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::None
+    }
+}
diff --git a/clippy_lints/src/loops/same_item_push.rs b/clippy_lints/src/loops/same_item_push.rs
index 62efb58a38f..c1d5f8b7186 100644
--- a/clippy_lints/src/loops/same_item_push.rs
+++ b/clippy_lints/src/loops/same_item_push.rs
@@ -1,3 +1,4 @@
+use super::SAME_ITEM_PUSH;
 use crate::utils::{implements_trait, is_type_diagnostic_item, snippet_with_macro_callsite, span_lint_and_help};
 use if_chain::if_chain;
 use rustc_hir::def::{DefKind, Res};
@@ -22,7 +23,7 @@ pub(super) fn detect_same_item_push<'tcx>(
 
         span_lint_and_help(
             cx,
-            super::SAME_ITEM_PUSH,
+            SAME_ITEM_PUSH,
             vec.span,
             "it looks like the same item is being pushed into this Vec",
             None,
diff --git a/clippy_lints/src/loops/single_element_loop.rs b/clippy_lints/src/loops/single_element_loop.rs
new file mode 100644
index 00000000000..9e2697186db
--- /dev/null
+++ b/clippy_lints/src/loops/single_element_loop.rs
@@ -0,0 +1,42 @@
+use super::{get_span_of_entire_for_loop, SINGLE_ELEMENT_LOOP};
+use crate::utils::{indent_of, single_segment_path, snippet, span_lint_and_sugg};
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir::{BorrowKind, Expr, ExprKind, Pat, PatKind};
+use rustc_lint::LateContext;
+
+pub(super) fn check_for_single_element_loop<'tcx>(
+    cx: &LateContext<'tcx>,
+    pat: &'tcx Pat<'_>,
+    arg: &'tcx Expr<'_>,
+    body: &'tcx Expr<'_>,
+    expr: &'tcx Expr<'_>,
+) {
+    if_chain! {
+        if let ExprKind::AddrOf(BorrowKind::Ref, _, ref arg_expr) = arg.kind;
+        if let PatKind::Binding(.., target, _) = pat.kind;
+        if let ExprKind::Array([arg_expression]) = arg_expr.kind;
+        if let ExprKind::Path(ref list_item) = arg_expression.kind;
+        if let Some(list_item_name) = single_segment_path(list_item).map(|ps| ps.ident.name);
+        if let ExprKind::Block(ref block, _) = body.kind;
+        if !block.stmts.is_empty();
+
+        then {
+            let for_span = get_span_of_entire_for_loop(expr);
+            let mut block_str = snippet(cx, block.span, "..").into_owned();
+            block_str.remove(0);
+            block_str.pop();
+
+
+            span_lint_and_sugg(
+                cx,
+                SINGLE_ELEMENT_LOOP,
+                for_span,
+                "for loop over a single element",
+                "try",
+                format!("{{\n{}let {} = &{};{}}}", " ".repeat(indent_of(cx, block.stmts[0].span).unwrap_or(0)), target.name, list_item_name, block_str),
+                Applicability::MachineApplicable
+            )
+        }
+    }
+}
diff --git a/clippy_lints/src/loops/while_immutable_condition.rs b/clippy_lints/src/loops/while_immutable_condition.rs
new file mode 100644
index 00000000000..42e6551b681
--- /dev/null
+++ b/clippy_lints/src/loops/while_immutable_condition.rs
@@ -0,0 +1,139 @@
+use super::WHILE_IMMUTABLE_CONDITION;
+use crate::consts::constant;
+use crate::utils::span_lint_and_then;
+use crate::utils::usage::mutated_variables;
+use if_chain::if_chain;
+use rustc_data_structures::fx::{FxHashMap, FxHashSet};
+use rustc_hir::def::{DefKind, Res};
+use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
+use rustc_hir::{def_id, Expr, ExprKind, HirId, QPath};
+use rustc_lint::LateContext;
+use rustc_middle::hir::map::Map;
+use std::iter::Iterator;
+
+pub(super) fn check_infinite_loop<'tcx>(cx: &LateContext<'tcx>, cond: &'tcx Expr<'_>, expr: &'tcx Expr<'_>) {
+    if constant(cx, cx.typeck_results(), cond).is_some() {
+        // A pure constant condition (e.g., `while false`) is not linted.
+        return;
+    }
+
+    let mut var_visitor = VarCollectorVisitor {
+        cx,
+        ids: FxHashSet::default(),
+        def_ids: FxHashMap::default(),
+        skip: false,
+    };
+    var_visitor.visit_expr(cond);
+    if var_visitor.skip {
+        return;
+    }
+    let used_in_condition = &var_visitor.ids;
+    let no_cond_variable_mutated = if let Some(used_mutably) = mutated_variables(expr, cx) {
+        used_in_condition.is_disjoint(&used_mutably)
+    } else {
+        return;
+    };
+    let mutable_static_in_cond = var_visitor.def_ids.iter().any(|(_, v)| *v);
+
+    let mut has_break_or_return_visitor = HasBreakOrReturnVisitor {
+        has_break_or_return: false,
+    };
+    has_break_or_return_visitor.visit_expr(expr);
+    let has_break_or_return = has_break_or_return_visitor.has_break_or_return;
+
+    if no_cond_variable_mutated && !mutable_static_in_cond {
+        span_lint_and_then(
+            cx,
+            WHILE_IMMUTABLE_CONDITION,
+            cond.span,
+            "variables in the condition are not mutated in the loop body",
+            |diag| {
+                diag.note("this may lead to an infinite or to a never running loop");
+
+                if has_break_or_return {
+                    diag.note("this loop contains `return`s or `break`s");
+                    diag.help("rewrite it as `if cond { loop { } }`");
+                }
+            },
+        );
+    }
+}
+
+struct HasBreakOrReturnVisitor {
+    has_break_or_return: bool,
+}
+
+impl<'tcx> Visitor<'tcx> for HasBreakOrReturnVisitor {
+    type Map = Map<'tcx>;
+
+    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
+        if self.has_break_or_return {
+            return;
+        }
+
+        match expr.kind {
+            ExprKind::Ret(_) | ExprKind::Break(_, _) => {
+                self.has_break_or_return = true;
+                return;
+            },
+            _ => {},
+        }
+
+        walk_expr(self, expr);
+    }
+
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::None
+    }
+}
+
+/// Collects the set of variables in an expression
+/// Stops analysis if a function call is found
+/// Note: In some cases such as `self`, there are no mutable annotation,
+/// All variables definition IDs are collected
+struct VarCollectorVisitor<'a, 'tcx> {
+    cx: &'a LateContext<'tcx>,
+    ids: FxHashSet<HirId>,
+    def_ids: FxHashMap<def_id::DefId, bool>,
+    skip: bool,
+}
+
+impl<'a, 'tcx> VarCollectorVisitor<'a, 'tcx> {
+    fn insert_def_id(&mut self, ex: &'tcx Expr<'_>) {
+        if_chain! {
+            if let ExprKind::Path(ref qpath) = ex.kind;
+            if let QPath::Resolved(None, _) = *qpath;
+            let res = self.cx.qpath_res(qpath, ex.hir_id);
+            then {
+                match res {
+                    Res::Local(hir_id) => {
+                        self.ids.insert(hir_id);
+                    },
+                    Res::Def(DefKind::Static, def_id) => {
+                        let mutable = self.cx.tcx.is_mutable_static(def_id);
+                        self.def_ids.insert(def_id, mutable);
+                    },
+                    _ => {},
+                }
+            }
+        }
+    }
+}
+
+impl<'a, 'tcx> Visitor<'tcx> for VarCollectorVisitor<'a, 'tcx> {
+    type Map = Map<'tcx>;
+
+    fn visit_expr(&mut self, ex: &'tcx Expr<'_>) {
+        match ex.kind {
+            ExprKind::Path(_) => self.insert_def_id(ex),
+            // If there is any function/method call… we just stop analysis
+            ExprKind::Call(..) | ExprKind::MethodCall(..) => self.skip = true,
+
+            _ => walk_expr(self, ex),
+        }
+    }
+
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::None
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 845a3a061c541a4c2b2293022113cbfd3e6e9cb2 Mon Sep 17 00:00:00 2001
From: nahuakang <kangnahua@gmail.com>
Date: Mon, 22 Feb 2021 16:24:25 +0100
Subject: Include loops.rs changes from PR#6698

---
 clippy_lints/src/loops/for_kv_map.rs          | 8 ++++----
 clippy_lints/src/loops/needless_range_loop.rs | 2 +-
 2 files changed, 5 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/for_kv_map.rs b/clippy_lints/src/loops/for_kv_map.rs
index 228d462f6e1..a5aaf082dd8 100644
--- a/clippy_lints/src/loops/for_kv_map.rs
+++ b/clippy_lints/src/loops/for_kv_map.rs
@@ -20,8 +20,8 @@ pub(super) fn check_for_loop_over_map_kv<'tcx>(
             let arg_span = arg.span;
             let (new_pat_span, kind, ty, mutbl) = match *cx.typeck_results().expr_ty(arg).kind() {
                 ty::Ref(_, ty, mutbl) => match (&pat[0].kind, &pat[1].kind) {
-                    (key, _) if pat_is_wild(key, body) => (pat[1].span, "value", ty, mutbl),
-                    (_, value) if pat_is_wild(value, body) => (pat[0].span, "key", ty, Mutability::Not),
+                    (key, _) if pat_is_wild(cx, key, body) => (pat[1].span, "value", ty, mutbl),
+                    (_, value) if pat_is_wild(cx, value, body) => (pat[0].span, "key", ty, Mutability::Not),
                     _ => return,
                 },
                 _ => return,
@@ -59,11 +59,11 @@ pub(super) fn check_for_loop_over_map_kv<'tcx>(
 }
 
 /// Returns `true` if the pattern is a `PatWild` or an ident prefixed with `_`.
-fn pat_is_wild<'tcx>(pat: &'tcx PatKind<'_>, body: &'tcx Expr<'_>) -> bool {
+fn pat_is_wild<'tcx>(cx: &LateContext<'tcx>, pat: &'tcx PatKind<'_>, body: &'tcx Expr<'_>) -> bool {
     match *pat {
         PatKind::Wild => true,
         PatKind::Binding(_, id, ident, None) if ident.as_str().starts_with('_') => {
-            !LocalUsedVisitor::new(id).check_expr(body)
+            !LocalUsedVisitor::new(cx, id).check_expr(body)
         },
         _ => false,
     }
diff --git a/clippy_lints/src/loops/needless_range_loop.rs b/clippy_lints/src/loops/needless_range_loop.rs
index 298753cc031..ee275bc5bd6 100644
--- a/clippy_lints/src/loops/needless_range_loop.rs
+++ b/clippy_lints/src/loops/needless_range_loop.rs
@@ -257,7 +257,7 @@ impl<'a, 'tcx> VarVisitor<'a, 'tcx> {
             then {
                 let index_used_directly = path_to_local_id(idx, self.var);
                 let indexed_indirectly = {
-                    let mut used_visitor = LocalUsedVisitor::new(self.var);
+                    let mut used_visitor = LocalUsedVisitor::new(self.cx, self.var);
                     walk_expr(&mut used_visitor, idx);
                     used_visitor.used
                 };
-- 
cgit 1.4.1-3-g733a5


From eaf63d6df75e0a046ba65d8b3cad0314b447f63e Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Tue, 2 Mar 2021 11:49:14 +0900
Subject: Unify names of lint entry functions in loops to 'check'

---
 clippy_lints/src/loops/empty_loop.rs               |  2 +-
 clippy_lints/src/loops/explicit_counter_loop.rs    |  2 +-
 clippy_lints/src/loops/explicit_into_iter_loop.rs  |  2 +-
 clippy_lints/src/loops/explicit_iter_loop.rs       |  2 +-
 clippy_lints/src/loops/for_kv_map.rs               |  2 +-
 clippy_lints/src/loops/for_loops_over_fallibles.rs |  2 +-
 clippy_lints/src/loops/iter_next_loop.rs           |  2 +-
 clippy_lints/src/loops/manual_flatten.rs           |  2 +-
 clippy_lints/src/loops/manual_memcpy.rs            |  2 +-
 clippy_lints/src/loops/mod.rs                      | 38 +++++++++++-----------
 clippy_lints/src/loops/mut_range_bound.rs          |  2 +-
 clippy_lints/src/loops/needless_collect.rs         |  2 +-
 clippy_lints/src/loops/needless_range_loop.rs      |  2 +-
 clippy_lints/src/loops/never_loop.rs               |  2 +-
 clippy_lints/src/loops/same_item_push.rs           |  2 +-
 clippy_lints/src/loops/single_element_loop.rs      |  2 +-
 .../src/loops/while_immutable_condition.rs         |  2 +-
 clippy_lints/src/loops/while_let_loop.rs           |  2 +-
 clippy_lints/src/loops/while_let_on_iterator.rs    |  2 +-
 19 files changed, 37 insertions(+), 37 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/empty_loop.rs b/clippy_lints/src/loops/empty_loop.rs
index fdc99e190e3..67d1ac89b97 100644
--- a/clippy_lints/src/loops/empty_loop.rs
+++ b/clippy_lints/src/loops/empty_loop.rs
@@ -4,7 +4,7 @@ use crate::utils::{is_in_panic_handler, is_no_std_crate, span_lint_and_help};
 use rustc_hir::{Block, Expr};
 use rustc_lint::LateContext;
 
-pub(super) fn check_empty_loop(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, loop_block: &'tcx Block<'_>) {
+pub(super) fn check(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, loop_block: &'tcx Block<'_>) {
     if loop_block.stmts.is_empty() && loop_block.expr.is_none() && !is_in_panic_handler(cx, expr) {
         let msg = "empty `loop {}` wastes CPU cycles";
         let help = if is_no_std_crate(cx.tcx.hir().krate()) {
diff --git a/clippy_lints/src/loops/explicit_counter_loop.rs b/clippy_lints/src/loops/explicit_counter_loop.rs
index 59116032f66..8d98b940c66 100644
--- a/clippy_lints/src/loops/explicit_counter_loop.rs
+++ b/clippy_lints/src/loops/explicit_counter_loop.rs
@@ -11,7 +11,7 @@ use rustc_lint::LateContext;
 // To trigger the EXPLICIT_COUNTER_LOOP lint, a variable must be
 // incremented exactly once in the loop body, and initialized to zero
 // at the start of the loop.
-pub(super) fn check_for_loop_explicit_counter<'tcx>(
+pub(super) fn check<'tcx>(
     cx: &LateContext<'tcx>,
     pat: &'tcx Pat<'_>,
     arg: &'tcx Expr<'_>,
diff --git a/clippy_lints/src/loops/explicit_into_iter_loop.rs b/clippy_lints/src/loops/explicit_into_iter_loop.rs
index d5d2bedaf1b..f89c4b85103 100644
--- a/clippy_lints/src/loops/explicit_into_iter_loop.rs
+++ b/clippy_lints/src/loops/explicit_into_iter_loop.rs
@@ -4,7 +4,7 @@ use rustc_errors::Applicability;
 use rustc_hir::Expr;
 use rustc_lint::LateContext;
 
-pub(super) fn check_explicit_into_iter_loop(cx: &LateContext<'_>, method_args: &'hir [Expr<'hir>], arg: &Expr<'_>) {
+pub(super) fn check(cx: &LateContext<'_>, method_args: &'hir [Expr<'hir>], arg: &Expr<'_>) {
     let mut applicability = Applicability::MachineApplicable;
     let object = snippet_with_applicability(cx, method_args[0].span, "_", &mut applicability);
     span_lint_and_sugg(
diff --git a/clippy_lints/src/loops/explicit_iter_loop.rs b/clippy_lints/src/loops/explicit_iter_loop.rs
index 14184865da3..0836054796a 100644
--- a/clippy_lints/src/loops/explicit_iter_loop.rs
+++ b/clippy_lints/src/loops/explicit_iter_loop.rs
@@ -4,7 +4,7 @@ use rustc_errors::Applicability;
 use rustc_hir::Expr;
 use rustc_lint::LateContext;
 
-pub(super) fn lint_iter_method(cx: &LateContext<'_>, args: &[Expr<'_>], arg: &Expr<'_>, method_name: &str) {
+pub(super) fn check(cx: &LateContext<'_>, args: &[Expr<'_>], arg: &Expr<'_>, method_name: &str) {
     let mut applicability = Applicability::MachineApplicable;
     let object = snippet_with_applicability(cx, args[0].span, "_", &mut applicability);
     let muta = if method_name == "iter_mut" { "mut " } else { "" };
diff --git a/clippy_lints/src/loops/for_kv_map.rs b/clippy_lints/src/loops/for_kv_map.rs
index a5aaf082dd8..eb53c3179ca 100644
--- a/clippy_lints/src/loops/for_kv_map.rs
+++ b/clippy_lints/src/loops/for_kv_map.rs
@@ -6,7 +6,7 @@ use rustc_lint::LateContext;
 use rustc_middle::ty;
 
 /// Checks for the `FOR_KV_MAP` lint.
-pub(super) fn check_for_loop_over_map_kv<'tcx>(
+pub(super) fn check<'tcx>(
     cx: &LateContext<'tcx>,
     pat: &'tcx Pat<'_>,
     arg: &'tcx Expr<'_>,
diff --git a/clippy_lints/src/loops/for_loops_over_fallibles.rs b/clippy_lints/src/loops/for_loops_over_fallibles.rs
index 1339af33759..db22d90a304 100644
--- a/clippy_lints/src/loops/for_loops_over_fallibles.rs
+++ b/clippy_lints/src/loops/for_loops_over_fallibles.rs
@@ -5,7 +5,7 @@ use rustc_lint::LateContext;
 use rustc_span::symbol::sym;
 
 /// Checks for `for` loops over `Option`s and `Result`s.
-pub(super) fn check_arg_type(cx: &LateContext<'_>, pat: &Pat<'_>, arg: &Expr<'_>) {
+pub(super) fn check(cx: &LateContext<'_>, pat: &Pat<'_>, arg: &Expr<'_>) {
     let ty = cx.typeck_results().expr_ty(arg);
     if is_type_diagnostic_item(cx, ty, sym::option_type) {
         span_lint_and_help(
diff --git a/clippy_lints/src/loops/iter_next_loop.rs b/clippy_lints/src/loops/iter_next_loop.rs
index 7a5a873a358..cb9916deb62 100644
--- a/clippy_lints/src/loops/iter_next_loop.rs
+++ b/clippy_lints/src/loops/iter_next_loop.rs
@@ -3,7 +3,7 @@ use crate::utils::span_lint;
 use rustc_hir::Expr;
 use rustc_lint::LateContext;
 
-pub(super) fn lint(cx: &LateContext<'_>, expr: &Expr<'_>) {
+pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>) {
     span_lint(
         cx,
         ITER_NEXT_LOOP,
diff --git a/clippy_lints/src/loops/manual_flatten.rs b/clippy_lints/src/loops/manual_flatten.rs
index efacda77284..3d3ae6f3152 100644
--- a/clippy_lints/src/loops/manual_flatten.rs
+++ b/clippy_lints/src/loops/manual_flatten.rs
@@ -9,7 +9,7 @@ use rustc_span::source_map::Span;
 
 /// Check for unnecessary `if let` usage in a for loop where only the `Some` or `Ok` variant of the
 /// iterator element is used.
-pub(super) fn check_manual_flatten<'tcx>(
+pub(super) fn check<'tcx>(
     cx: &LateContext<'tcx>,
     pat: &'tcx Pat<'_>,
     arg: &'tcx Expr<'_>,
diff --git a/clippy_lints/src/loops/manual_memcpy.rs b/clippy_lints/src/loops/manual_memcpy.rs
index e3080d9f556..bf0b8cc2459 100644
--- a/clippy_lints/src/loops/manual_memcpy.rs
+++ b/clippy_lints/src/loops/manual_memcpy.rs
@@ -15,7 +15,7 @@ use std::iter::Iterator;
 
 /// Checks for for loops that sequentially copy items from one slice-like
 /// object to another.
-pub(super) fn detect_manual_memcpy<'tcx>(
+pub(super) fn check<'tcx>(
     cx: &LateContext<'tcx>,
     pat: &'tcx Pat<'_>,
     arg: &'tcx Expr<'_>,
diff --git a/clippy_lints/src/loops/mod.rs b/clippy_lints/src/loops/mod.rs
index 0d408698fc9..5c96128c6a4 100644
--- a/clippy_lints/src/loops/mod.rs
+++ b/clippy_lints/src/loops/mod.rs
@@ -559,24 +559,24 @@ impl<'tcx> LateLintPass<'tcx> for Loops {
         }
 
         // check for never_loop
-        never_loop::check_never_loop(cx, expr);
+        never_loop::check(cx, expr);
 
         // check for `loop { if let {} else break }` that could be `while let`
         // (also matches an explicit "match" instead of "if let")
         // (even if the "match" or "if let" is used for declaration)
         if let ExprKind::Loop(ref block, _, LoopSource::Loop, _) = expr.kind {
             // also check for empty `loop {}` statements, skipping those in #[panic_handler]
-            empty_loop::check_empty_loop(cx, expr, block);
-            while_let_loop::check_while_let_loop(cx, expr, block);
+            empty_loop::check(cx, expr, block);
+            while_let_loop::check(cx, expr, block);
         }
 
-        while_let_on_iterator::check_while_let_on_iterator(cx, expr);
+        while_let_on_iterator::check(cx, expr);
 
         if let Some((cond, body)) = higher::while_loop(&expr) {
-            while_immutable_condition::check_infinite_loop(cx, cond, body);
+            while_immutable_condition::check(cx, cond, body);
         }
 
-        needless_collect::check_needless_collect(expr, cx);
+        needless_collect::check(expr, cx);
     }
 }
 
@@ -588,17 +588,17 @@ fn check_for_loop<'tcx>(
     expr: &'tcx Expr<'_>,
     span: Span,
 ) {
-    let is_manual_memcpy_triggered = manual_memcpy::detect_manual_memcpy(cx, pat, arg, body, expr);
+    let is_manual_memcpy_triggered = manual_memcpy::check(cx, pat, arg, body, expr);
     if !is_manual_memcpy_triggered {
-        needless_range_loop::check_for_loop_range(cx, pat, arg, body, expr);
-        explicit_counter_loop::check_for_loop_explicit_counter(cx, pat, arg, body, expr);
+        needless_range_loop::check(cx, pat, arg, body, expr);
+        explicit_counter_loop::check(cx, pat, arg, body, expr);
     }
     check_for_loop_arg(cx, pat, arg, expr);
-    for_kv_map::check_for_loop_over_map_kv(cx, pat, arg, body, expr);
-    mut_range_bound::check_for_mut_range_bound(cx, arg, body);
-    single_element_loop::check_for_single_element_loop(cx, pat, arg, body, expr);
-    same_item_push::detect_same_item_push(cx, pat, arg, body, expr);
-    manual_flatten::check_manual_flatten(cx, pat, arg, body, span);
+    for_kv_map::check(cx, pat, arg, body, expr);
+    mut_range_bound::check(cx, arg, body);
+    single_element_loop::check(cx, pat, arg, body, expr);
+    same_item_push::check(cx, pat, arg, body, expr);
+    manual_flatten::check(cx, pat, arg, body, span);
 }
 
 fn check_for_loop_arg(cx: &LateContext<'_>, pat: &Pat<'_>, arg: &Expr<'_>, expr: &Expr<'_>) {
@@ -610,13 +610,13 @@ fn check_for_loop_arg(cx: &LateContext<'_>, pat: &Pat<'_>, arg: &Expr<'_>, expr:
             // check for looping over x.iter() or x.iter_mut(), could use &x or &mut x
             if method_name == "iter" || method_name == "iter_mut" {
                 if is_ref_iterable_type(cx, &args[0]) {
-                    explicit_iter_loop::lint_iter_method(cx, args, arg, method_name);
+                    explicit_iter_loop::check(cx, args, arg, method_name);
                 }
             } else if method_name == "into_iter" && match_trait_method(cx, arg, &paths::INTO_ITERATOR) {
                 let receiver_ty = cx.typeck_results().expr_ty(&args[0]);
                 let receiver_ty_adjusted = cx.typeck_results().expr_ty_adjusted(&args[0]);
                 if TyS::same_type(receiver_ty, receiver_ty_adjusted) {
-                    explicit_into_iter_loop::check_explicit_into_iter_loop(cx, args, arg);
+                    explicit_into_iter_loop::check(cx, args, arg);
                 } else {
                     let ref_receiver_ty = cx.tcx.mk_ref(
                         cx.tcx.lifetimes.re_erased,
@@ -626,17 +626,17 @@ fn check_for_loop_arg(cx: &LateContext<'_>, pat: &Pat<'_>, arg: &Expr<'_>, expr:
                         },
                     );
                     if TyS::same_type(receiver_ty_adjusted, ref_receiver_ty) {
-                        explicit_iter_loop::lint_iter_method(cx, args, arg, method_name)
+                        explicit_iter_loop::check(cx, args, arg, method_name)
                     }
                 }
             } else if method_name == "next" && match_trait_method(cx, arg, &paths::ITERATOR) {
-                iter_next_loop::lint(cx, expr);
+                iter_next_loop::check(cx, expr);
                 next_loop_linted = true;
             }
         }
     }
     if !next_loop_linted {
-        for_loops_over_fallibles::check_arg_type(cx, pat, arg);
+        for_loops_over_fallibles::check(cx, pat, arg);
     }
 }
 
diff --git a/clippy_lints/src/loops/mut_range_bound.rs b/clippy_lints/src/loops/mut_range_bound.rs
index 9f31617edeb..3ae592950f1 100644
--- a/clippy_lints/src/loops/mut_range_bound.rs
+++ b/clippy_lints/src/loops/mut_range_bound.rs
@@ -8,7 +8,7 @@ use rustc_middle::ty;
 use rustc_span::source_map::Span;
 use rustc_typeck::expr_use_visitor::{ConsumeMode, Delegate, ExprUseVisitor, PlaceBase, PlaceWithHirId};
 
-pub(super) fn check_for_mut_range_bound(cx: &LateContext<'_>, arg: &Expr<'_>, body: &Expr<'_>) {
+pub(super) fn check(cx: &LateContext<'_>, arg: &Expr<'_>, body: &Expr<'_>) {
     if let Some(higher::Range {
         start: Some(start),
         end: Some(end),
diff --git a/clippy_lints/src/loops/needless_collect.rs b/clippy_lints/src/loops/needless_collect.rs
index d1ce055445b..6f271309105 100644
--- a/clippy_lints/src/loops/needless_collect.rs
+++ b/clippy_lints/src/loops/needless_collect.rs
@@ -15,7 +15,7 @@ use rustc_span::symbol::{sym, Ident};
 
 const NEEDLESS_COLLECT_MSG: &str = "avoid using `collect()` when not needed";
 
-pub(super) fn check_needless_collect<'tcx>(expr: &'tcx Expr<'_>, cx: &LateContext<'tcx>) {
+pub(super) fn check<'tcx>(expr: &'tcx Expr<'_>, cx: &LateContext<'tcx>) {
     check_needless_collect_direct_usage(expr, cx);
     check_needless_collect_indirect_usage(expr, cx);
 }
diff --git a/clippy_lints/src/loops/needless_range_loop.rs b/clippy_lints/src/loops/needless_range_loop.rs
index ee275bc5bd6..5f02e4b9d87 100644
--- a/clippy_lints/src/loops/needless_range_loop.rs
+++ b/clippy_lints/src/loops/needless_range_loop.rs
@@ -21,7 +21,7 @@ use std::mem;
 /// Checks for looping over a range and then indexing a sequence with it.
 /// The iteratee must be a range literal.
 #[allow(clippy::too_many_lines)]
-pub(super) fn check_for_loop_range<'tcx>(
+pub(super) fn check<'tcx>(
     cx: &LateContext<'tcx>,
     pat: &'tcx Pat<'_>,
     arg: &'tcx Expr<'_>,
diff --git a/clippy_lints/src/loops/never_loop.rs b/clippy_lints/src/loops/never_loop.rs
index d51ff81103f..45e1001d755 100644
--- a/clippy_lints/src/loops/never_loop.rs
+++ b/clippy_lints/src/loops/never_loop.rs
@@ -4,7 +4,7 @@ use rustc_hir::{Block, Expr, ExprKind, HirId, InlineAsmOperand, Stmt, StmtKind};
 use rustc_lint::LateContext;
 use std::iter::{once, Iterator};
 
-pub(super) fn check_never_loop(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+pub(super) fn check(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
     if let ExprKind::Loop(ref block, _, _, _) = expr.kind {
         match never_loop_block(block, expr.hir_id) {
             NeverLoopResult::AlwaysBreak => span_lint(cx, NEVER_LOOP, expr.span, "this loop never actually loops"),
diff --git a/clippy_lints/src/loops/same_item_push.rs b/clippy_lints/src/loops/same_item_push.rs
index c1d5f8b7186..f3585830e4a 100644
--- a/clippy_lints/src/loops/same_item_push.rs
+++ b/clippy_lints/src/loops/same_item_push.rs
@@ -10,7 +10,7 @@ use rustc_span::symbol::sym;
 use std::iter::Iterator;
 
 /// Detects for loop pushing the same item into a Vec
-pub(super) fn detect_same_item_push<'tcx>(
+pub(super) fn check<'tcx>(
     cx: &LateContext<'tcx>,
     pat: &'tcx Pat<'_>,
     _: &'tcx Expr<'_>,
diff --git a/clippy_lints/src/loops/single_element_loop.rs b/clippy_lints/src/loops/single_element_loop.rs
index 9e2697186db..38400c93c9a 100644
--- a/clippy_lints/src/loops/single_element_loop.rs
+++ b/clippy_lints/src/loops/single_element_loop.rs
@@ -5,7 +5,7 @@ use rustc_errors::Applicability;
 use rustc_hir::{BorrowKind, Expr, ExprKind, Pat, PatKind};
 use rustc_lint::LateContext;
 
-pub(super) fn check_for_single_element_loop<'tcx>(
+pub(super) fn check<'tcx>(
     cx: &LateContext<'tcx>,
     pat: &'tcx Pat<'_>,
     arg: &'tcx Expr<'_>,
diff --git a/clippy_lints/src/loops/while_immutable_condition.rs b/clippy_lints/src/loops/while_immutable_condition.rs
index 42e6551b681..05e0a722563 100644
--- a/clippy_lints/src/loops/while_immutable_condition.rs
+++ b/clippy_lints/src/loops/while_immutable_condition.rs
@@ -11,7 +11,7 @@ use rustc_lint::LateContext;
 use rustc_middle::hir::map::Map;
 use std::iter::Iterator;
 
-pub(super) fn check_infinite_loop<'tcx>(cx: &LateContext<'tcx>, cond: &'tcx Expr<'_>, expr: &'tcx Expr<'_>) {
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, cond: &'tcx Expr<'_>, expr: &'tcx Expr<'_>) {
     if constant(cx, cx.typeck_results(), cond).is_some() {
         // A pure constant condition (e.g., `while false`) is not linted.
         return;
diff --git a/clippy_lints/src/loops/while_let_loop.rs b/clippy_lints/src/loops/while_let_loop.rs
index 0c957986964..65d8f2f1111 100644
--- a/clippy_lints/src/loops/while_let_loop.rs
+++ b/clippy_lints/src/loops/while_let_loop.rs
@@ -5,7 +5,7 @@ use rustc_hir::{Block, Expr, ExprKind, MatchSource, StmtKind};
 use rustc_lint::{LateContext, LintContext};
 use rustc_middle::lint::in_external_macro;
 
-pub(super) fn check_while_let_loop(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, loop_block: &'tcx Block<'_>) {
+pub(super) fn check(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, loop_block: &'tcx Block<'_>) {
     // extract the expression from the first statement (if any) in a block
     let inner_stmt_expr = extract_expr_from_first_stmt(loop_block);
     // or extract the first expression (if any) from the block
diff --git a/clippy_lints/src/loops/while_let_on_iterator.rs b/clippy_lints/src/loops/while_let_on_iterator.rs
index 090c8ceba97..e5a47694faa 100644
--- a/clippy_lints/src/loops/while_let_on_iterator.rs
+++ b/clippy_lints/src/loops/while_let_on_iterator.rs
@@ -14,7 +14,7 @@ use rustc_middle::hir::map::Map;
 
 use rustc_span::symbol::sym;
 
-pub(super) fn check_while_let_on_iterator(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+pub(super) fn check(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
     if let ExprKind::Match(ref match_expr, ref arms, MatchSource::WhileLetDesugar) = expr.kind {
         let pat = &arms[0].pat.kind;
         if let (
-- 
cgit 1.4.1-3-g733a5


From 74bd806b05b16528ff773e469145df215760a88b Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Tue, 2 Mar 2021 12:41:06 +0900
Subject: Simplify check_for_loop_arg

---
 clippy_lints/src/loops/explicit_into_iter_loop.rs | 11 +++-
 clippy_lints/src/loops/explicit_iter_loop.rs      | 57 +++++++++++++++++++-
 clippy_lints/src/loops/iter_next_loop.rs          | 23 ++++----
 clippy_lints/src/loops/mod.rs                     | 66 +++++------------------
 4 files changed, 90 insertions(+), 67 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/explicit_into_iter_loop.rs b/clippy_lints/src/loops/explicit_into_iter_loop.rs
index f89c4b85103..1d778205a2a 100644
--- a/clippy_lints/src/loops/explicit_into_iter_loop.rs
+++ b/clippy_lints/src/loops/explicit_into_iter_loop.rs
@@ -3,10 +3,17 @@ use crate::utils::{snippet_with_applicability, span_lint_and_sugg};
 use rustc_errors::Applicability;
 use rustc_hir::Expr;
 use rustc_lint::LateContext;
+use rustc_middle::ty::TyS;
+
+pub(super) fn check(cx: &LateContext<'_>, args: &'hir [Expr<'hir>], arg: &Expr<'_>) {
+    let receiver_ty = cx.typeck_results().expr_ty(&args[0]);
+    let receiver_ty_adjusted = cx.typeck_results().expr_ty_adjusted(&args[0]);
+    if !TyS::same_type(receiver_ty, receiver_ty_adjusted) {
+        return;
+    }
 
-pub(super) fn check(cx: &LateContext<'_>, method_args: &'hir [Expr<'hir>], arg: &Expr<'_>) {
     let mut applicability = Applicability::MachineApplicable;
-    let object = snippet_with_applicability(cx, method_args[0].span, "_", &mut applicability);
+    let object = snippet_with_applicability(cx, args[0].span, "_", &mut applicability);
     span_lint_and_sugg(
         cx,
         EXPLICIT_INTO_ITER_LOOP,
diff --git a/clippy_lints/src/loops/explicit_iter_loop.rs b/clippy_lints/src/loops/explicit_iter_loop.rs
index 0836054796a..44d08916891 100644
--- a/clippy_lints/src/loops/explicit_iter_loop.rs
+++ b/clippy_lints/src/loops/explicit_iter_loop.rs
@@ -1,10 +1,35 @@
 use super::EXPLICIT_ITER_LOOP;
-use crate::utils::{snippet_with_applicability, span_lint_and_sugg};
+use crate::utils::{match_trait_method, snippet_with_applicability, span_lint_and_sugg};
 use rustc_errors::Applicability;
-use rustc_hir::Expr;
+use rustc_hir::{Expr, Mutability};
 use rustc_lint::LateContext;
+use rustc_middle::ty::{self, Ty, TyS};
+use rustc_span::symbol::sym;
+
+use crate::utils::{is_type_diagnostic_item, match_type, paths};
 
 pub(super) fn check(cx: &LateContext<'_>, args: &[Expr<'_>], arg: &Expr<'_>, method_name: &str) {
+    let should_lint = match method_name {
+        "iter" | "iter_mut" => is_ref_iterable_type(cx, &args[0]),
+        "into_iter" if match_trait_method(cx, arg, &paths::INTO_ITERATOR) => {
+            let receiver_ty = cx.typeck_results().expr_ty(&args[0]);
+            let receiver_ty_adjusted = cx.typeck_results().expr_ty_adjusted(&args[0]);
+            let ref_receiver_ty = cx.tcx.mk_ref(
+                cx.tcx.lifetimes.re_erased,
+                ty::TypeAndMut {
+                    ty: receiver_ty,
+                    mutbl: Mutability::Not,
+                },
+            );
+            TyS::same_type(receiver_ty_adjusted, ref_receiver_ty)
+        },
+        _ => false,
+    };
+
+    if !should_lint {
+        return;
+    }
+
     let mut applicability = Applicability::MachineApplicable;
     let object = snippet_with_applicability(cx, args[0].span, "_", &mut applicability);
     let muta = if method_name == "iter_mut" { "mut " } else { "" };
@@ -19,3 +44,31 @@ pub(super) fn check(cx: &LateContext<'_>, args: &[Expr<'_>], arg: &Expr<'_>, met
         applicability,
     )
 }
+
+/// Returns `true` if the type of expr is one that provides `IntoIterator` impls
+/// for `&T` and `&mut T`, such as `Vec`.
+#[rustfmt::skip]
+fn is_ref_iterable_type(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
+    // no walk_ptrs_ty: calling iter() on a reference can make sense because it
+    // will allow further borrows afterwards
+    let ty = cx.typeck_results().expr_ty(e);
+    is_iterable_array(ty, cx) ||
+    is_type_diagnostic_item(cx, ty, sym::vec_type) ||
+    match_type(cx, ty, &paths::LINKED_LIST) ||
+    is_type_diagnostic_item(cx, ty, sym!(hashmap_type)) ||
+    is_type_diagnostic_item(cx, ty, sym!(hashset_type)) ||
+    is_type_diagnostic_item(cx, ty, sym!(vecdeque_type)) ||
+    match_type(cx, ty, &paths::BINARY_HEAP) ||
+    match_type(cx, ty, &paths::BTREEMAP) ||
+    match_type(cx, ty, &paths::BTREESET)
+}
+
+fn is_iterable_array<'tcx>(ty: Ty<'tcx>, cx: &LateContext<'tcx>) -> bool {
+    // IntoIterator is currently only implemented for array sizes <= 32 in rustc
+    match ty.kind() {
+        ty::Array(_, n) => n
+            .try_eval_usize(cx.tcx, cx.param_env)
+            .map_or(false, |val| (0..=32).contains(&val)),
+        _ => false,
+    }
+}
diff --git a/clippy_lints/src/loops/iter_next_loop.rs b/clippy_lints/src/loops/iter_next_loop.rs
index cb9916deb62..cf78bbc49a3 100644
--- a/clippy_lints/src/loops/iter_next_loop.rs
+++ b/clippy_lints/src/loops/iter_next_loop.rs
@@ -1,14 +1,19 @@
 use super::ITER_NEXT_LOOP;
-use crate::utils::span_lint;
+use crate::utils::{match_trait_method, paths, span_lint};
 use rustc_hir::Expr;
 use rustc_lint::LateContext;
 
-pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>) {
-    span_lint(
-        cx,
-        ITER_NEXT_LOOP,
-        expr.span,
-        "you are iterating over `Iterator::next()` which is an Option; this will compile but is \
-        probably not what you want",
-    );
+pub(super) fn check(cx: &LateContext<'_>, arg: &Expr<'_>, expr: &Expr<'_>) -> bool {
+    if match_trait_method(cx, arg, &paths::ITERATOR) {
+        span_lint(
+            cx,
+            ITER_NEXT_LOOP,
+            expr.span,
+            "you are iterating over `Iterator::next()` which is an Option; this will compile but is \
+            probably not what you want",
+        );
+        true
+    } else {
+        false
+    }
 }
diff --git a/clippy_lints/src/loops/mod.rs b/clippy_lints/src/loops/mod.rs
index 5c96128c6a4..2a372c6307e 100644
--- a/clippy_lints/src/loops/mod.rs
+++ b/clippy_lints/src/loops/mod.rs
@@ -18,13 +18,11 @@ mod while_immutable_condition;
 mod while_let_loop;
 mod while_let_on_iterator;
 
-use crate::utils::{higher, is_type_diagnostic_item, match_trait_method, match_type, paths};
-use rustc_hir::{Expr, ExprKind, LoopSource, Mutability, Pat};
+use crate::utils::higher;
+use rustc_hir::{Expr, ExprKind, LoopSource, Pat};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty::{self, Ty, TyS};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
-use rustc_span::symbol::sym;
 use utils::{get_span_of_entire_for_loop, make_iterator_snippet, IncrementVisitor, InitializeVisitor};
 
 declare_clippy_lint! {
@@ -603,67 +601,27 @@ fn check_for_loop<'tcx>(
 
 fn check_for_loop_arg(cx: &LateContext<'_>, pat: &Pat<'_>, arg: &Expr<'_>, expr: &Expr<'_>) {
     let mut next_loop_linted = false; // whether or not ITER_NEXT_LOOP lint was used
+
     if let ExprKind::MethodCall(ref method, _, ref args, _) = arg.kind {
         // just the receiver, no arguments
         if args.len() == 1 {
             let method_name = &*method.ident.as_str();
             // check for looping over x.iter() or x.iter_mut(), could use &x or &mut x
-            if method_name == "iter" || method_name == "iter_mut" {
-                if is_ref_iterable_type(cx, &args[0]) {
+            match method_name {
+                "iter" | "iter_mut" => explicit_iter_loop::check(cx, args, arg, method_name),
+                "into_iter" => {
                     explicit_iter_loop::check(cx, args, arg, method_name);
-                }
-            } else if method_name == "into_iter" && match_trait_method(cx, arg, &paths::INTO_ITERATOR) {
-                let receiver_ty = cx.typeck_results().expr_ty(&args[0]);
-                let receiver_ty_adjusted = cx.typeck_results().expr_ty_adjusted(&args[0]);
-                if TyS::same_type(receiver_ty, receiver_ty_adjusted) {
                     explicit_into_iter_loop::check(cx, args, arg);
-                } else {
-                    let ref_receiver_ty = cx.tcx.mk_ref(
-                        cx.tcx.lifetimes.re_erased,
-                        ty::TypeAndMut {
-                            ty: receiver_ty,
-                            mutbl: Mutability::Not,
-                        },
-                    );
-                    if TyS::same_type(receiver_ty_adjusted, ref_receiver_ty) {
-                        explicit_iter_loop::check(cx, args, arg, method_name)
-                    }
-                }
-            } else if method_name == "next" && match_trait_method(cx, arg, &paths::ITERATOR) {
-                iter_next_loop::check(cx, expr);
-                next_loop_linted = true;
+                },
+                "next" => {
+                    next_loop_linted = iter_next_loop::check(cx, arg, expr);
+                },
+                _ => {},
             }
         }
     }
+
     if !next_loop_linted {
         for_loops_over_fallibles::check(cx, pat, arg);
     }
 }
-
-/// Returns `true` if the type of expr is one that provides `IntoIterator` impls
-/// for `&T` and `&mut T`, such as `Vec`.
-#[rustfmt::skip]
-fn is_ref_iterable_type(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
-    // no walk_ptrs_ty: calling iter() on a reference can make sense because it
-    // will allow further borrows afterwards
-    let ty = cx.typeck_results().expr_ty(e);
-    is_iterable_array(ty, cx) ||
-    is_type_diagnostic_item(cx, ty, sym::vec_type) ||
-    match_type(cx, ty, &paths::LINKED_LIST) ||
-    is_type_diagnostic_item(cx, ty, sym!(hashmap_type)) ||
-    is_type_diagnostic_item(cx, ty, sym!(hashset_type)) ||
-    is_type_diagnostic_item(cx, ty, sym!(vecdeque_type)) ||
-    match_type(cx, ty, &paths::BINARY_HEAP) ||
-    match_type(cx, ty, &paths::BTREEMAP) ||
-    match_type(cx, ty, &paths::BTREESET)
-}
-
-fn is_iterable_array<'tcx>(ty: Ty<'tcx>, cx: &LateContext<'tcx>) -> bool {
-    // IntoIterator is currently only implemented for array sizes <= 32 in rustc
-    match ty.kind() {
-        ty::Array(_, n) => n
-            .try_eval_usize(cx.tcx, cx.param_env)
-            .map_or(false, |val| (0..=32).contains(&val)),
-        _ => false,
-    }
-}
-- 
cgit 1.4.1-3-g733a5


From 306545ff9653a8e1d00c4f381c8e609d3ad49adb Mon Sep 17 00:00:00 2001
From: Yusuke Tanaka <yusuktan@maguro.dev>
Date: Wed, 10 Feb 2021 22:59:08 +0900
Subject: Create transmute directory

---
 clippy_lints/src/transmute.rs     | 763 --------------------------------------
 clippy_lints/src/transmute/mod.rs | 763 ++++++++++++++++++++++++++++++++++++++
 2 files changed, 763 insertions(+), 763 deletions(-)
 delete mode 100644 clippy_lints/src/transmute.rs
 create mode 100644 clippy_lints/src/transmute/mod.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/transmute.rs b/clippy_lints/src/transmute.rs
deleted file mode 100644
index dc938ed0238..00000000000
--- a/clippy_lints/src/transmute.rs
+++ /dev/null
@@ -1,763 +0,0 @@
-use crate::utils::{
-    in_constant, is_normalizable, last_path_segment, match_def_path, paths, snippet, span_lint, span_lint_and_sugg,
-    span_lint_and_then, sugg,
-};
-use if_chain::if_chain;
-use rustc_ast as ast;
-use rustc_errors::Applicability;
-use rustc_hir::{Expr, ExprKind, GenericArg, Mutability, QPath, TyKind, UnOp};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty::{self, cast::CastKind, Ty};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::DUMMY_SP;
-use rustc_typeck::check::{cast::CastCheck, FnCtxt, Inherited};
-use std::borrow::Cow;
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for transmutes that can't ever be correct on any
-    /// architecture.
-    ///
-    /// **Why is this bad?** It's basically guaranteed to be undefined behaviour.
-    ///
-    /// **Known problems:** When accessing C, users might want to store pointer
-    /// sized objects in `extradata` arguments to save an allocation.
-    ///
-    /// **Example:**
-    /// ```ignore
-    /// let ptr: *const T = core::intrinsics::transmute('x')
-    /// ```
-    pub WRONG_TRANSMUTE,
-    correctness,
-    "transmutes that are confusing at best, undefined behaviour at worst and always useless"
-}
-
-// FIXME: Move this to `complexity` again, after #5343 is fixed
-declare_clippy_lint! {
-    /// **What it does:** Checks for transmutes to the original type of the object
-    /// and transmutes that could be a cast.
-    ///
-    /// **Why is this bad?** Readability. The code tricks people into thinking that
-    /// something complex is going on.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    /// ```rust,ignore
-    /// core::intrinsics::transmute(t); // where the result type is the same as `t`'s
-    /// ```
-    pub USELESS_TRANSMUTE,
-    nursery,
-    "transmutes that have the same to and from types or could be a cast/coercion"
-}
-
-// FIXME: Merge this lint with USELESS_TRANSMUTE once that is out of the nursery.
-declare_clippy_lint! {
-    /// **What it does:**Checks for transmutes that could be a pointer cast.
-    ///
-    /// **Why is this bad?** Readability. The code tricks people into thinking that
-    /// something complex is going on.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
-    /// ```rust
-    /// # let p: *const [i32] = &[];
-    /// unsafe { std::mem::transmute::<*const [i32], *const [u16]>(p) };
-    /// ```
-    /// Use instead:
-    /// ```rust
-    /// # let p: *const [i32] = &[];
-    /// p as *const [u16];
-    /// ```
-    pub TRANSMUTES_EXPRESSIBLE_AS_PTR_CASTS,
-    complexity,
-    "transmutes that could be a pointer cast"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for transmutes between a type `T` and `*T`.
-    ///
-    /// **Why is this bad?** It's easy to mistakenly transmute between a type and a
-    /// pointer to that type.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    /// ```rust,ignore
-    /// core::intrinsics::transmute(t) // where the result type is the same as
-    ///                                // `*t` or `&t`'s
-    /// ```
-    pub CROSSPOINTER_TRANSMUTE,
-    complexity,
-    "transmutes that have to or from types that are a pointer to the other"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for transmutes from a pointer to a reference.
-    ///
-    /// **Why is this bad?** This can always be rewritten with `&` and `*`.
-    ///
-    /// **Known problems:**
-    /// - `mem::transmute` in statics and constants is stable from Rust 1.46.0,
-    /// while dereferencing raw pointer is not stable yet.
-    /// If you need to do this in those places,
-    /// you would have to use `transmute` instead.
-    ///
-    /// **Example:**
-    /// ```rust,ignore
-    /// unsafe {
-    ///     let _: &T = std::mem::transmute(p); // where p: *const T
-    /// }
-    ///
-    /// // can be written:
-    /// let _: &T = &*p;
-    /// ```
-    pub TRANSMUTE_PTR_TO_REF,
-    complexity,
-    "transmutes from a pointer to a reference type"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for transmutes from an integer to a `char`.
-    ///
-    /// **Why is this bad?** Not every integer is a Unicode scalar value.
-    ///
-    /// **Known problems:**
-    /// - [`from_u32`] which this lint suggests using is slower than `transmute`
-    /// as it needs to validate the input.
-    /// If you are certain that the input is always a valid Unicode scalar value,
-    /// use [`from_u32_unchecked`] which is as fast as `transmute`
-    /// but has a semantically meaningful name.
-    /// - You might want to handle `None` returned from [`from_u32`] instead of calling `unwrap`.
-    ///
-    /// [`from_u32`]: https://doc.rust-lang.org/std/char/fn.from_u32.html
-    /// [`from_u32_unchecked`]: https://doc.rust-lang.org/std/char/fn.from_u32_unchecked.html
-    ///
-    /// **Example:**
-    /// ```rust
-    /// let x = 1_u32;
-    /// unsafe {
-    ///     let _: char = std::mem::transmute(x); // where x: u32
-    /// }
-    ///
-    /// // should be:
-    /// let _ = std::char::from_u32(x).unwrap();
-    /// ```
-    pub TRANSMUTE_INT_TO_CHAR,
-    complexity,
-    "transmutes from an integer to a `char`"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for transmutes from a `&[u8]` to a `&str`.
-    ///
-    /// **Why is this bad?** Not every byte slice is a valid UTF-8 string.
-    ///
-    /// **Known problems:**
-    /// - [`from_utf8`] which this lint suggests using is slower than `transmute`
-    /// as it needs to validate the input.
-    /// If you are certain that the input is always a valid UTF-8,
-    /// use [`from_utf8_unchecked`] which is as fast as `transmute`
-    /// but has a semantically meaningful name.
-    /// - You might want to handle errors returned from [`from_utf8`] instead of calling `unwrap`.
-    ///
-    /// [`from_utf8`]: https://doc.rust-lang.org/std/str/fn.from_utf8.html
-    /// [`from_utf8_unchecked`]: https://doc.rust-lang.org/std/str/fn.from_utf8_unchecked.html
-    ///
-    /// **Example:**
-    /// ```rust
-    /// let b: &[u8] = &[1_u8, 2_u8];
-    /// unsafe {
-    ///     let _: &str = std::mem::transmute(b); // where b: &[u8]
-    /// }
-    ///
-    /// // should be:
-    /// let _ = std::str::from_utf8(b).unwrap();
-    /// ```
-    pub TRANSMUTE_BYTES_TO_STR,
-    complexity,
-    "transmutes from a `&[u8]` to a `&str`"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for transmutes from an integer to a `bool`.
-    ///
-    /// **Why is this bad?** This might result in an invalid in-memory representation of a `bool`.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    /// ```rust
-    /// let x = 1_u8;
-    /// unsafe {
-    ///     let _: bool = std::mem::transmute(x); // where x: u8
-    /// }
-    ///
-    /// // should be:
-    /// let _: bool = x != 0;
-    /// ```
-    pub TRANSMUTE_INT_TO_BOOL,
-    complexity,
-    "transmutes from an integer to a `bool`"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for transmutes from an integer to a float.
-    ///
-    /// **Why is this bad?** Transmutes are dangerous and error-prone, whereas `from_bits` is intuitive
-    /// and safe.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    /// ```rust
-    /// unsafe {
-    ///     let _: f32 = std::mem::transmute(1_u32); // where x: u32
-    /// }
-    ///
-    /// // should be:
-    /// let _: f32 = f32::from_bits(1_u32);
-    /// ```
-    pub TRANSMUTE_INT_TO_FLOAT,
-    complexity,
-    "transmutes from an integer to a float"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for transmutes from a float to an integer.
-    ///
-    /// **Why is this bad?** Transmutes are dangerous and error-prone, whereas `to_bits` is intuitive
-    /// and safe.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    /// ```rust
-    /// unsafe {
-    ///     let _: u32 = std::mem::transmute(1f32);
-    /// }
-    ///
-    /// // should be:
-    /// let _: u32 = 1f32.to_bits();
-    /// ```
-    pub TRANSMUTE_FLOAT_TO_INT,
-    complexity,
-    "transmutes from a float to an integer"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for transmutes from a pointer to a pointer, or
-    /// from a reference to a reference.
-    ///
-    /// **Why is this bad?** Transmutes are dangerous, and these can instead be
-    /// written as casts.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    /// ```rust
-    /// let ptr = &1u32 as *const u32;
-    /// unsafe {
-    ///     // pointer-to-pointer transmute
-    ///     let _: *const f32 = std::mem::transmute(ptr);
-    ///     // ref-ref transmute
-    ///     let _: &f32 = std::mem::transmute(&1u32);
-    /// }
-    /// // These can be respectively written:
-    /// let _ = ptr as *const f32;
-    /// let _ = unsafe{ &*(&1u32 as *const u32 as *const f32) };
-    /// ```
-    pub TRANSMUTE_PTR_TO_PTR,
-    complexity,
-    "transmutes from a pointer to a pointer / a reference to a reference"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for transmutes between collections whose
-    /// types have different ABI, size or alignment.
-    ///
-    /// **Why is this bad?** This is undefined behavior.
-    ///
-    /// **Known problems:** Currently, we cannot know whether a type is a
-    /// collection, so we just lint the ones that come with `std`.
-    ///
-    /// **Example:**
-    /// ```rust
-    /// // different size, therefore likely out-of-bounds memory access
-    /// // You absolutely do not want this in your code!
-    /// unsafe {
-    ///     std::mem::transmute::<_, Vec<u32>>(vec![2_u16])
-    /// };
-    /// ```
-    ///
-    /// You must always iterate, map and collect the values:
-    ///
-    /// ```rust
-    /// vec![2_u16].into_iter().map(u32::from).collect::<Vec<_>>();
-    /// ```
-    pub UNSOUND_COLLECTION_TRANSMUTE,
-    correctness,
-    "transmute between collections of layout-incompatible types"
-}
-
-declare_lint_pass!(Transmute => [
-    CROSSPOINTER_TRANSMUTE,
-    TRANSMUTE_PTR_TO_REF,
-    TRANSMUTE_PTR_TO_PTR,
-    USELESS_TRANSMUTE,
-    WRONG_TRANSMUTE,
-    TRANSMUTE_INT_TO_CHAR,
-    TRANSMUTE_BYTES_TO_STR,
-    TRANSMUTE_INT_TO_BOOL,
-    TRANSMUTE_INT_TO_FLOAT,
-    TRANSMUTE_FLOAT_TO_INT,
-    UNSOUND_COLLECTION_TRANSMUTE,
-    TRANSMUTES_EXPRESSIBLE_AS_PTR_CASTS,
-]);
-
-// used to check for UNSOUND_COLLECTION_TRANSMUTE
-static COLLECTIONS: &[&[&str]] = &[
-    &paths::VEC,
-    &paths::VEC_DEQUE,
-    &paths::BINARY_HEAP,
-    &paths::BTREESET,
-    &paths::BTREEMAP,
-    &paths::HASHSET,
-    &paths::HASHMAP,
-];
-impl<'tcx> LateLintPass<'tcx> for Transmute {
-    #[allow(clippy::similar_names, clippy::too_many_lines)]
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
-        if_chain! {
-            if let ExprKind::Call(ref path_expr, ref args) = e.kind;
-            if let ExprKind::Path(ref qpath) = path_expr.kind;
-            if let Some(def_id) = cx.qpath_res(qpath, path_expr.hir_id).opt_def_id();
-            if match_def_path(cx, def_id, &paths::TRANSMUTE);
-            then {
-                // Avoid suggesting from/to bits and dereferencing raw pointers in const contexts.
-                // See https://github.com/rust-lang/rust/issues/73736 for progress on making them `const fn`.
-                // And see https://github.com/rust-lang/rust/issues/51911 for dereferencing raw pointers.
-                let const_context = in_constant(cx, e.hir_id);
-
-                let from_ty = cx.typeck_results().expr_ty(&args[0]);
-                let to_ty = cx.typeck_results().expr_ty(e);
-
-                match (&from_ty.kind(), &to_ty.kind()) {
-                    _ if from_ty == to_ty => span_lint(
-                        cx,
-                        USELESS_TRANSMUTE,
-                        e.span,
-                        &format!("transmute from a type (`{}`) to itself", from_ty),
-                    ),
-                    (ty::Ref(_, rty, rty_mutbl), ty::RawPtr(ptr_ty)) => span_lint_and_then(
-                        cx,
-                        USELESS_TRANSMUTE,
-                        e.span,
-                        "transmute from a reference to a pointer",
-                        |diag| {
-                            if let Some(arg) = sugg::Sugg::hir_opt(cx, &args[0]) {
-                                let rty_and_mut = ty::TypeAndMut {
-                                    ty: rty,
-                                    mutbl: *rty_mutbl,
-                                };
-
-                                let sugg = if *ptr_ty == rty_and_mut {
-                                    arg.as_ty(to_ty)
-                                } else {
-                                    arg.as_ty(cx.tcx.mk_ptr(rty_and_mut)).as_ty(to_ty)
-                                };
-
-                                diag.span_suggestion(e.span, "try", sugg.to_string(), Applicability::Unspecified);
-                            }
-                        },
-                    ),
-                    (ty::Int(_) | ty::Uint(_), ty::RawPtr(_)) => span_lint_and_then(
-                        cx,
-                        USELESS_TRANSMUTE,
-                        e.span,
-                        "transmute from an integer to a pointer",
-                        |diag| {
-                            if let Some(arg) = sugg::Sugg::hir_opt(cx, &args[0]) {
-                                diag.span_suggestion(
-                                    e.span,
-                                    "try",
-                                    arg.as_ty(&to_ty.to_string()).to_string(),
-                                    Applicability::Unspecified,
-                                );
-                            }
-                        },
-                    ),
-                    (ty::Float(_) | ty::Char, ty::Ref(..) | ty::RawPtr(_)) => span_lint(
-                        cx,
-                        WRONG_TRANSMUTE,
-                        e.span,
-                        &format!("transmute from a `{}` to a pointer", from_ty),
-                    ),
-                    (ty::RawPtr(from_ptr), _) if from_ptr.ty == to_ty => span_lint(
-                        cx,
-                        CROSSPOINTER_TRANSMUTE,
-                        e.span,
-                        &format!(
-                            "transmute from a type (`{}`) to the type that it points to (`{}`)",
-                            from_ty, to_ty
-                        ),
-                    ),
-                    (_, ty::RawPtr(to_ptr)) if to_ptr.ty == from_ty => span_lint(
-                        cx,
-                        CROSSPOINTER_TRANSMUTE,
-                        e.span,
-                        &format!(
-                            "transmute from a type (`{}`) to a pointer to that type (`{}`)",
-                            from_ty, to_ty
-                        ),
-                    ),
-                    (ty::RawPtr(from_pty), ty::Ref(_, to_ref_ty, mutbl)) => span_lint_and_then(
-                        cx,
-                        TRANSMUTE_PTR_TO_REF,
-                        e.span,
-                        &format!(
-                            "transmute from a pointer type (`{}`) to a reference type \
-                             (`{}`)",
-                            from_ty, to_ty
-                        ),
-                        |diag| {
-                            let arg = sugg::Sugg::hir(cx, &args[0], "..");
-                            let (deref, cast) = if *mutbl == Mutability::Mut {
-                                ("&mut *", "*mut")
-                            } else {
-                                ("&*", "*const")
-                            };
-
-                            let arg = if from_pty.ty == *to_ref_ty {
-                                arg
-                            } else {
-                                arg.as_ty(&format!("{} {}", cast, get_type_snippet(cx, qpath, to_ref_ty)))
-                            };
-
-                            diag.span_suggestion(
-                                e.span,
-                                "try",
-                                sugg::make_unop(deref, arg).to_string(),
-                                Applicability::Unspecified,
-                            );
-                        },
-                    ),
-                    (ty::Int(ty::IntTy::I32) | ty::Uint(ty::UintTy::U32), &ty::Char) => {
-                        span_lint_and_then(
-                            cx,
-                            TRANSMUTE_INT_TO_CHAR,
-                            e.span,
-                            &format!("transmute from a `{}` to a `char`", from_ty),
-                            |diag| {
-                                let arg = sugg::Sugg::hir(cx, &args[0], "..");
-                                let arg = if let ty::Int(_) = from_ty.kind() {
-                                    arg.as_ty(ast::UintTy::U32.name_str())
-                                } else {
-                                    arg
-                                };
-                                diag.span_suggestion(
-                                    e.span,
-                                    "consider using",
-                                    format!("std::char::from_u32({}).unwrap()", arg.to_string()),
-                                    Applicability::Unspecified,
-                                );
-                            },
-                        )
-                    },
-                    (ty::Ref(_, ty_from, from_mutbl), ty::Ref(_, ty_to, to_mutbl)) => {
-                        if_chain! {
-                            if let (&ty::Slice(slice_ty), &ty::Str) = (&ty_from.kind(), &ty_to.kind());
-                            if let ty::Uint(ty::UintTy::U8) = slice_ty.kind();
-                            if from_mutbl == to_mutbl;
-                            then {
-                                let postfix = if *from_mutbl == Mutability::Mut {
-                                    "_mut"
-                                } else {
-                                    ""
-                                };
-
-                                span_lint_and_sugg(
-                                    cx,
-                                    TRANSMUTE_BYTES_TO_STR,
-                                    e.span,
-                                    &format!("transmute from a `{}` to a `{}`", from_ty, to_ty),
-                                    "consider using",
-                                    format!(
-                                        "std::str::from_utf8{}({}).unwrap()",
-                                        postfix,
-                                        snippet(cx, args[0].span, ".."),
-                                    ),
-                                    Applicability::Unspecified,
-                                );
-                            } else {
-                                if (cx.tcx.erase_regions(from_ty) != cx.tcx.erase_regions(to_ty))
-                                    && !const_context {
-                                    span_lint_and_then(
-                                        cx,
-                                        TRANSMUTE_PTR_TO_PTR,
-                                        e.span,
-                                        "transmute from a reference to a reference",
-                                        |diag| if let Some(arg) = sugg::Sugg::hir_opt(cx, &args[0]) {
-                                            let ty_from_and_mut = ty::TypeAndMut {
-                                                ty: ty_from,
-                                                mutbl: *from_mutbl
-                                            };
-                                            let ty_to_and_mut = ty::TypeAndMut { ty: ty_to, mutbl: *to_mutbl };
-                                            let sugg_paren = arg
-                                                .as_ty(cx.tcx.mk_ptr(ty_from_and_mut))
-                                                .as_ty(cx.tcx.mk_ptr(ty_to_and_mut));
-                                            let sugg = if *to_mutbl == Mutability::Mut {
-                                                sugg_paren.mut_addr_deref()
-                                            } else {
-                                                sugg_paren.addr_deref()
-                                            };
-                                            diag.span_suggestion(
-                                                e.span,
-                                                "try",
-                                                sugg.to_string(),
-                                                Applicability::Unspecified,
-                                            );
-                                        },
-                                    )
-                                }
-                            }
-                        }
-                    },
-                    (ty::RawPtr(_), ty::RawPtr(to_ty)) => span_lint_and_then(
-                        cx,
-                        TRANSMUTE_PTR_TO_PTR,
-                        e.span,
-                        "transmute from a pointer to a pointer",
-                        |diag| {
-                            if let Some(arg) = sugg::Sugg::hir_opt(cx, &args[0]) {
-                                let sugg = arg.as_ty(cx.tcx.mk_ptr(*to_ty));
-                                diag.span_suggestion(e.span, "try", sugg.to_string(), Applicability::Unspecified);
-                            }
-                        },
-                    ),
-                    (ty::Int(ty::IntTy::I8) | ty::Uint(ty::UintTy::U8), ty::Bool) => {
-                        span_lint_and_then(
-                            cx,
-                            TRANSMUTE_INT_TO_BOOL,
-                            e.span,
-                            &format!("transmute from a `{}` to a `bool`", from_ty),
-                            |diag| {
-                                let arg = sugg::Sugg::hir(cx, &args[0], "..");
-                                let zero = sugg::Sugg::NonParen(Cow::from("0"));
-                                diag.span_suggestion(
-                                    e.span,
-                                    "consider using",
-                                    sugg::make_binop(ast::BinOpKind::Ne, &arg, &zero).to_string(),
-                                    Applicability::Unspecified,
-                                );
-                            },
-                        )
-                    },
-                    (ty::Int(_) | ty::Uint(_), ty::Float(_)) if !const_context => span_lint_and_then(
-                        cx,
-                        TRANSMUTE_INT_TO_FLOAT,
-                        e.span,
-                        &format!("transmute from a `{}` to a `{}`", from_ty, to_ty),
-                        |diag| {
-                            let arg = sugg::Sugg::hir(cx, &args[0], "..");
-                            let arg = if let ty::Int(int_ty) = from_ty.kind() {
-                                arg.as_ty(format!(
-                                    "u{}",
-                                    int_ty.bit_width().map_or_else(|| "size".to_string(), |v| v.to_string())
-                                ))
-                            } else {
-                                arg
-                            };
-                            diag.span_suggestion(
-                                e.span,
-                                "consider using",
-                                format!("{}::from_bits({})", to_ty, arg.to_string()),
-                                Applicability::Unspecified,
-                            );
-                        },
-                    ),
-                    (ty::Float(float_ty), ty::Int(_) | ty::Uint(_)) if !const_context => span_lint_and_then(
-                        cx,
-                        TRANSMUTE_FLOAT_TO_INT,
-                        e.span,
-                        &format!("transmute from a `{}` to a `{}`", from_ty, to_ty),
-                        |diag| {
-                            let mut expr = &args[0];
-                            let mut arg = sugg::Sugg::hir(cx, expr, "..");
-
-                            if let ExprKind::Unary(UnOp::Neg, inner_expr) = &expr.kind {
-                                expr = &inner_expr;
-                            }
-
-                            if_chain! {
-                                // if the expression is a float literal and it is unsuffixed then
-                                // add a suffix so the suggestion is valid and unambiguous
-                                let op = format!("{}{}", arg, float_ty.name_str()).into();
-                                if let ExprKind::Lit(lit) = &expr.kind;
-                                if let ast::LitKind::Float(_, ast::LitFloatType::Unsuffixed) = lit.node;
-                                then {
-                                    match arg {
-                                        sugg::Sugg::MaybeParen(_) => arg = sugg::Sugg::MaybeParen(op),
-                                        _ => arg = sugg::Sugg::NonParen(op)
-                                    }
-                                }
-                            }
-
-                            arg = sugg::Sugg::NonParen(format!("{}.to_bits()", arg.maybe_par()).into());
-
-                            // cast the result of `to_bits` if `to_ty` is signed
-                            arg = if let ty::Int(int_ty) = to_ty.kind() {
-                                arg.as_ty(int_ty.name_str().to_string())
-                            } else {
-                                arg
-                            };
-
-                            diag.span_suggestion(
-                                e.span,
-                                "consider using",
-                                arg.to_string(),
-                                Applicability::Unspecified,
-                            );
-                        },
-                    ),
-                    (ty::Adt(from_adt, from_substs), ty::Adt(to_adt, to_substs)) => {
-                        if from_adt.did != to_adt.did ||
-                                !COLLECTIONS.iter().any(|path| match_def_path(cx, to_adt.did, path)) {
-                            return;
-                        }
-                        if from_substs.types().zip(to_substs.types())
-                                              .any(|(from_ty, to_ty)| is_layout_incompatible(cx, from_ty, to_ty)) {
-                            span_lint(
-                                cx,
-                                UNSOUND_COLLECTION_TRANSMUTE,
-                                e.span,
-                                &format!(
-                                    "transmute from `{}` to `{}` with mismatched layout is unsound",
-                                    from_ty,
-                                    to_ty
-                                )
-                            );
-                        }
-                    },
-                    (_, _) if can_be_expressed_as_pointer_cast(cx, e, from_ty, to_ty) => span_lint_and_then(
-                        cx,
-                        TRANSMUTES_EXPRESSIBLE_AS_PTR_CASTS,
-                        e.span,
-                        &format!(
-                            "transmute from `{}` to `{}` which could be expressed as a pointer cast instead",
-                            from_ty,
-                            to_ty
-                        ),
-                        |diag| {
-                            if let Some(arg) = sugg::Sugg::hir_opt(cx, &args[0]) {
-                                let sugg = arg.as_ty(&to_ty.to_string()).to_string();
-                                diag.span_suggestion(e.span, "try", sugg, Applicability::MachineApplicable);
-                            }
-                        }
-                    ),
-                    _ => {
-                        return;
-                    },
-                }
-            }
-        }
-    }
-}
-
-/// Gets the snippet of `Bar` in `…::transmute<Foo, &Bar>`. If that snippet is
-/// not available , use
-/// the type's `ToString` implementation. In weird cases it could lead to types
-/// with invalid `'_`
-/// lifetime, but it should be rare.
-fn get_type_snippet(cx: &LateContext<'_>, path: &QPath<'_>, to_ref_ty: Ty<'_>) -> String {
-    let seg = last_path_segment(path);
-    if_chain! {
-        if let Some(ref params) = seg.args;
-        if !params.parenthesized;
-        if let Some(to_ty) = params.args.iter().filter_map(|arg| match arg {
-            GenericArg::Type(ty) => Some(ty),
-            _ => None,
-        }).nth(1);
-        if let TyKind::Rptr(_, ref to_ty) = to_ty.kind;
-        then {
-            return snippet(cx, to_ty.ty.span, &to_ref_ty.to_string()).to_string();
-        }
-    }
-
-    to_ref_ty.to_string()
-}
-
-// check if the component types of the transmuted collection and the result have different ABI,
-// size or alignment
-fn is_layout_incompatible<'tcx>(cx: &LateContext<'tcx>, from: Ty<'tcx>, to: Ty<'tcx>) -> bool {
-    let empty_param_env = ty::ParamEnv::empty();
-    // check if `from` and `to` are normalizable to avoid ICE (#4968)
-    if !(is_normalizable(cx, empty_param_env, from) && is_normalizable(cx, empty_param_env, to)) {
-        return false;
-    }
-    let from_ty_layout = cx.tcx.layout_of(empty_param_env.and(from));
-    let to_ty_layout = cx.tcx.layout_of(empty_param_env.and(to));
-    if let (Ok(from_layout), Ok(to_layout)) = (from_ty_layout, to_ty_layout) {
-        from_layout.size != to_layout.size || from_layout.align != to_layout.align || from_layout.abi != to_layout.abi
-    } else {
-        // no idea about layout, so don't lint
-        false
-    }
-}
-
-/// Check if the type conversion can be expressed as a pointer cast, instead of
-/// a transmute. In certain cases, including some invalid casts from array
-/// references to pointers, this may cause additional errors to be emitted and/or
-/// ICE error messages. This function will panic if that occurs.
-fn can_be_expressed_as_pointer_cast<'tcx>(
-    cx: &LateContext<'tcx>,
-    e: &'tcx Expr<'_>,
-    from_ty: Ty<'tcx>,
-    to_ty: Ty<'tcx>,
-) -> bool {
-    use CastKind::{AddrPtrCast, ArrayPtrCast, FnPtrAddrCast, FnPtrPtrCast, PtrAddrCast, PtrPtrCast};
-    matches!(
-        check_cast(cx, e, from_ty, to_ty),
-        Some(PtrPtrCast | PtrAddrCast | AddrPtrCast | ArrayPtrCast | FnPtrPtrCast | FnPtrAddrCast)
-    )
-}
-
-/// If a cast from `from_ty` to `to_ty` is valid, returns an Ok containing the kind of
-/// the cast. In certain cases, including some invalid casts from array references
-/// to pointers, this may cause additional errors to be emitted and/or ICE error
-/// messages. This function will panic if that occurs.
-fn check_cast<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>, from_ty: Ty<'tcx>, to_ty: Ty<'tcx>) -> Option<CastKind> {
-    let hir_id = e.hir_id;
-    let local_def_id = hir_id.owner;
-
-    Inherited::build(cx.tcx, local_def_id).enter(|inherited| {
-        let fn_ctxt = FnCtxt::new(&inherited, cx.param_env, hir_id);
-
-        // If we already have errors, we can't be sure we can pointer cast.
-        assert!(
-            !fn_ctxt.errors_reported_since_creation(),
-            "Newly created FnCtxt contained errors"
-        );
-
-        if let Ok(check) = CastCheck::new(
-            &fn_ctxt, e, from_ty, to_ty,
-            // We won't show any error to the user, so we don't care what the span is here.
-            DUMMY_SP, DUMMY_SP,
-        ) {
-            let res = check.do_check(&fn_ctxt);
-
-            // do_check's documentation says that it might return Ok and create
-            // errors in the fcx instead of returing Err in some cases. Those cases
-            // should be filtered out before getting here.
-            assert!(
-                !fn_ctxt.errors_reported_since_creation(),
-                "`fn_ctxt` contained errors after cast check!"
-            );
-
-            res.ok()
-        } else {
-            None
-        }
-    })
-}
diff --git a/clippy_lints/src/transmute/mod.rs b/clippy_lints/src/transmute/mod.rs
new file mode 100644
index 00000000000..dc938ed0238
--- /dev/null
+++ b/clippy_lints/src/transmute/mod.rs
@@ -0,0 +1,763 @@
+use crate::utils::{
+    in_constant, is_normalizable, last_path_segment, match_def_path, paths, snippet, span_lint, span_lint_and_sugg,
+    span_lint_and_then, sugg,
+};
+use if_chain::if_chain;
+use rustc_ast as ast;
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind, GenericArg, Mutability, QPath, TyKind, UnOp};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::{self, cast::CastKind, Ty};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::DUMMY_SP;
+use rustc_typeck::check::{cast::CastCheck, FnCtxt, Inherited};
+use std::borrow::Cow;
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for transmutes that can't ever be correct on any
+    /// architecture.
+    ///
+    /// **Why is this bad?** It's basically guaranteed to be undefined behaviour.
+    ///
+    /// **Known problems:** When accessing C, users might want to store pointer
+    /// sized objects in `extradata` arguments to save an allocation.
+    ///
+    /// **Example:**
+    /// ```ignore
+    /// let ptr: *const T = core::intrinsics::transmute('x')
+    /// ```
+    pub WRONG_TRANSMUTE,
+    correctness,
+    "transmutes that are confusing at best, undefined behaviour at worst and always useless"
+}
+
+// FIXME: Move this to `complexity` again, after #5343 is fixed
+declare_clippy_lint! {
+    /// **What it does:** Checks for transmutes to the original type of the object
+    /// and transmutes that could be a cast.
+    ///
+    /// **Why is this bad?** Readability. The code tricks people into thinking that
+    /// something complex is going on.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// ```rust,ignore
+    /// core::intrinsics::transmute(t); // where the result type is the same as `t`'s
+    /// ```
+    pub USELESS_TRANSMUTE,
+    nursery,
+    "transmutes that have the same to and from types or could be a cast/coercion"
+}
+
+// FIXME: Merge this lint with USELESS_TRANSMUTE once that is out of the nursery.
+declare_clippy_lint! {
+    /// **What it does:**Checks for transmutes that could be a pointer cast.
+    ///
+    /// **Why is this bad?** Readability. The code tricks people into thinking that
+    /// something complex is going on.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// # let p: *const [i32] = &[];
+    /// unsafe { std::mem::transmute::<*const [i32], *const [u16]>(p) };
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// # let p: *const [i32] = &[];
+    /// p as *const [u16];
+    /// ```
+    pub TRANSMUTES_EXPRESSIBLE_AS_PTR_CASTS,
+    complexity,
+    "transmutes that could be a pointer cast"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for transmutes between a type `T` and `*T`.
+    ///
+    /// **Why is this bad?** It's easy to mistakenly transmute between a type and a
+    /// pointer to that type.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// ```rust,ignore
+    /// core::intrinsics::transmute(t) // where the result type is the same as
+    ///                                // `*t` or `&t`'s
+    /// ```
+    pub CROSSPOINTER_TRANSMUTE,
+    complexity,
+    "transmutes that have to or from types that are a pointer to the other"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for transmutes from a pointer to a reference.
+    ///
+    /// **Why is this bad?** This can always be rewritten with `&` and `*`.
+    ///
+    /// **Known problems:**
+    /// - `mem::transmute` in statics and constants is stable from Rust 1.46.0,
+    /// while dereferencing raw pointer is not stable yet.
+    /// If you need to do this in those places,
+    /// you would have to use `transmute` instead.
+    ///
+    /// **Example:**
+    /// ```rust,ignore
+    /// unsafe {
+    ///     let _: &T = std::mem::transmute(p); // where p: *const T
+    /// }
+    ///
+    /// // can be written:
+    /// let _: &T = &*p;
+    /// ```
+    pub TRANSMUTE_PTR_TO_REF,
+    complexity,
+    "transmutes from a pointer to a reference type"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for transmutes from an integer to a `char`.
+    ///
+    /// **Why is this bad?** Not every integer is a Unicode scalar value.
+    ///
+    /// **Known problems:**
+    /// - [`from_u32`] which this lint suggests using is slower than `transmute`
+    /// as it needs to validate the input.
+    /// If you are certain that the input is always a valid Unicode scalar value,
+    /// use [`from_u32_unchecked`] which is as fast as `transmute`
+    /// but has a semantically meaningful name.
+    /// - You might want to handle `None` returned from [`from_u32`] instead of calling `unwrap`.
+    ///
+    /// [`from_u32`]: https://doc.rust-lang.org/std/char/fn.from_u32.html
+    /// [`from_u32_unchecked`]: https://doc.rust-lang.org/std/char/fn.from_u32_unchecked.html
+    ///
+    /// **Example:**
+    /// ```rust
+    /// let x = 1_u32;
+    /// unsafe {
+    ///     let _: char = std::mem::transmute(x); // where x: u32
+    /// }
+    ///
+    /// // should be:
+    /// let _ = std::char::from_u32(x).unwrap();
+    /// ```
+    pub TRANSMUTE_INT_TO_CHAR,
+    complexity,
+    "transmutes from an integer to a `char`"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for transmutes from a `&[u8]` to a `&str`.
+    ///
+    /// **Why is this bad?** Not every byte slice is a valid UTF-8 string.
+    ///
+    /// **Known problems:**
+    /// - [`from_utf8`] which this lint suggests using is slower than `transmute`
+    /// as it needs to validate the input.
+    /// If you are certain that the input is always a valid UTF-8,
+    /// use [`from_utf8_unchecked`] which is as fast as `transmute`
+    /// but has a semantically meaningful name.
+    /// - You might want to handle errors returned from [`from_utf8`] instead of calling `unwrap`.
+    ///
+    /// [`from_utf8`]: https://doc.rust-lang.org/std/str/fn.from_utf8.html
+    /// [`from_utf8_unchecked`]: https://doc.rust-lang.org/std/str/fn.from_utf8_unchecked.html
+    ///
+    /// **Example:**
+    /// ```rust
+    /// let b: &[u8] = &[1_u8, 2_u8];
+    /// unsafe {
+    ///     let _: &str = std::mem::transmute(b); // where b: &[u8]
+    /// }
+    ///
+    /// // should be:
+    /// let _ = std::str::from_utf8(b).unwrap();
+    /// ```
+    pub TRANSMUTE_BYTES_TO_STR,
+    complexity,
+    "transmutes from a `&[u8]` to a `&str`"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for transmutes from an integer to a `bool`.
+    ///
+    /// **Why is this bad?** This might result in an invalid in-memory representation of a `bool`.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// ```rust
+    /// let x = 1_u8;
+    /// unsafe {
+    ///     let _: bool = std::mem::transmute(x); // where x: u8
+    /// }
+    ///
+    /// // should be:
+    /// let _: bool = x != 0;
+    /// ```
+    pub TRANSMUTE_INT_TO_BOOL,
+    complexity,
+    "transmutes from an integer to a `bool`"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for transmutes from an integer to a float.
+    ///
+    /// **Why is this bad?** Transmutes are dangerous and error-prone, whereas `from_bits` is intuitive
+    /// and safe.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// ```rust
+    /// unsafe {
+    ///     let _: f32 = std::mem::transmute(1_u32); // where x: u32
+    /// }
+    ///
+    /// // should be:
+    /// let _: f32 = f32::from_bits(1_u32);
+    /// ```
+    pub TRANSMUTE_INT_TO_FLOAT,
+    complexity,
+    "transmutes from an integer to a float"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for transmutes from a float to an integer.
+    ///
+    /// **Why is this bad?** Transmutes are dangerous and error-prone, whereas `to_bits` is intuitive
+    /// and safe.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// ```rust
+    /// unsafe {
+    ///     let _: u32 = std::mem::transmute(1f32);
+    /// }
+    ///
+    /// // should be:
+    /// let _: u32 = 1f32.to_bits();
+    /// ```
+    pub TRANSMUTE_FLOAT_TO_INT,
+    complexity,
+    "transmutes from a float to an integer"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for transmutes from a pointer to a pointer, or
+    /// from a reference to a reference.
+    ///
+    /// **Why is this bad?** Transmutes are dangerous, and these can instead be
+    /// written as casts.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// ```rust
+    /// let ptr = &1u32 as *const u32;
+    /// unsafe {
+    ///     // pointer-to-pointer transmute
+    ///     let _: *const f32 = std::mem::transmute(ptr);
+    ///     // ref-ref transmute
+    ///     let _: &f32 = std::mem::transmute(&1u32);
+    /// }
+    /// // These can be respectively written:
+    /// let _ = ptr as *const f32;
+    /// let _ = unsafe{ &*(&1u32 as *const u32 as *const f32) };
+    /// ```
+    pub TRANSMUTE_PTR_TO_PTR,
+    complexity,
+    "transmutes from a pointer to a pointer / a reference to a reference"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for transmutes between collections whose
+    /// types have different ABI, size or alignment.
+    ///
+    /// **Why is this bad?** This is undefined behavior.
+    ///
+    /// **Known problems:** Currently, we cannot know whether a type is a
+    /// collection, so we just lint the ones that come with `std`.
+    ///
+    /// **Example:**
+    /// ```rust
+    /// // different size, therefore likely out-of-bounds memory access
+    /// // You absolutely do not want this in your code!
+    /// unsafe {
+    ///     std::mem::transmute::<_, Vec<u32>>(vec![2_u16])
+    /// };
+    /// ```
+    ///
+    /// You must always iterate, map and collect the values:
+    ///
+    /// ```rust
+    /// vec![2_u16].into_iter().map(u32::from).collect::<Vec<_>>();
+    /// ```
+    pub UNSOUND_COLLECTION_TRANSMUTE,
+    correctness,
+    "transmute between collections of layout-incompatible types"
+}
+
+declare_lint_pass!(Transmute => [
+    CROSSPOINTER_TRANSMUTE,
+    TRANSMUTE_PTR_TO_REF,
+    TRANSMUTE_PTR_TO_PTR,
+    USELESS_TRANSMUTE,
+    WRONG_TRANSMUTE,
+    TRANSMUTE_INT_TO_CHAR,
+    TRANSMUTE_BYTES_TO_STR,
+    TRANSMUTE_INT_TO_BOOL,
+    TRANSMUTE_INT_TO_FLOAT,
+    TRANSMUTE_FLOAT_TO_INT,
+    UNSOUND_COLLECTION_TRANSMUTE,
+    TRANSMUTES_EXPRESSIBLE_AS_PTR_CASTS,
+]);
+
+// used to check for UNSOUND_COLLECTION_TRANSMUTE
+static COLLECTIONS: &[&[&str]] = &[
+    &paths::VEC,
+    &paths::VEC_DEQUE,
+    &paths::BINARY_HEAP,
+    &paths::BTREESET,
+    &paths::BTREEMAP,
+    &paths::HASHSET,
+    &paths::HASHMAP,
+];
+impl<'tcx> LateLintPass<'tcx> for Transmute {
+    #[allow(clippy::similar_names, clippy::too_many_lines)]
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
+        if_chain! {
+            if let ExprKind::Call(ref path_expr, ref args) = e.kind;
+            if let ExprKind::Path(ref qpath) = path_expr.kind;
+            if let Some(def_id) = cx.qpath_res(qpath, path_expr.hir_id).opt_def_id();
+            if match_def_path(cx, def_id, &paths::TRANSMUTE);
+            then {
+                // Avoid suggesting from/to bits and dereferencing raw pointers in const contexts.
+                // See https://github.com/rust-lang/rust/issues/73736 for progress on making them `const fn`.
+                // And see https://github.com/rust-lang/rust/issues/51911 for dereferencing raw pointers.
+                let const_context = in_constant(cx, e.hir_id);
+
+                let from_ty = cx.typeck_results().expr_ty(&args[0]);
+                let to_ty = cx.typeck_results().expr_ty(e);
+
+                match (&from_ty.kind(), &to_ty.kind()) {
+                    _ if from_ty == to_ty => span_lint(
+                        cx,
+                        USELESS_TRANSMUTE,
+                        e.span,
+                        &format!("transmute from a type (`{}`) to itself", from_ty),
+                    ),
+                    (ty::Ref(_, rty, rty_mutbl), ty::RawPtr(ptr_ty)) => span_lint_and_then(
+                        cx,
+                        USELESS_TRANSMUTE,
+                        e.span,
+                        "transmute from a reference to a pointer",
+                        |diag| {
+                            if let Some(arg) = sugg::Sugg::hir_opt(cx, &args[0]) {
+                                let rty_and_mut = ty::TypeAndMut {
+                                    ty: rty,
+                                    mutbl: *rty_mutbl,
+                                };
+
+                                let sugg = if *ptr_ty == rty_and_mut {
+                                    arg.as_ty(to_ty)
+                                } else {
+                                    arg.as_ty(cx.tcx.mk_ptr(rty_and_mut)).as_ty(to_ty)
+                                };
+
+                                diag.span_suggestion(e.span, "try", sugg.to_string(), Applicability::Unspecified);
+                            }
+                        },
+                    ),
+                    (ty::Int(_) | ty::Uint(_), ty::RawPtr(_)) => span_lint_and_then(
+                        cx,
+                        USELESS_TRANSMUTE,
+                        e.span,
+                        "transmute from an integer to a pointer",
+                        |diag| {
+                            if let Some(arg) = sugg::Sugg::hir_opt(cx, &args[0]) {
+                                diag.span_suggestion(
+                                    e.span,
+                                    "try",
+                                    arg.as_ty(&to_ty.to_string()).to_string(),
+                                    Applicability::Unspecified,
+                                );
+                            }
+                        },
+                    ),
+                    (ty::Float(_) | ty::Char, ty::Ref(..) | ty::RawPtr(_)) => span_lint(
+                        cx,
+                        WRONG_TRANSMUTE,
+                        e.span,
+                        &format!("transmute from a `{}` to a pointer", from_ty),
+                    ),
+                    (ty::RawPtr(from_ptr), _) if from_ptr.ty == to_ty => span_lint(
+                        cx,
+                        CROSSPOINTER_TRANSMUTE,
+                        e.span,
+                        &format!(
+                            "transmute from a type (`{}`) to the type that it points to (`{}`)",
+                            from_ty, to_ty
+                        ),
+                    ),
+                    (_, ty::RawPtr(to_ptr)) if to_ptr.ty == from_ty => span_lint(
+                        cx,
+                        CROSSPOINTER_TRANSMUTE,
+                        e.span,
+                        &format!(
+                            "transmute from a type (`{}`) to a pointer to that type (`{}`)",
+                            from_ty, to_ty
+                        ),
+                    ),
+                    (ty::RawPtr(from_pty), ty::Ref(_, to_ref_ty, mutbl)) => span_lint_and_then(
+                        cx,
+                        TRANSMUTE_PTR_TO_REF,
+                        e.span,
+                        &format!(
+                            "transmute from a pointer type (`{}`) to a reference type \
+                             (`{}`)",
+                            from_ty, to_ty
+                        ),
+                        |diag| {
+                            let arg = sugg::Sugg::hir(cx, &args[0], "..");
+                            let (deref, cast) = if *mutbl == Mutability::Mut {
+                                ("&mut *", "*mut")
+                            } else {
+                                ("&*", "*const")
+                            };
+
+                            let arg = if from_pty.ty == *to_ref_ty {
+                                arg
+                            } else {
+                                arg.as_ty(&format!("{} {}", cast, get_type_snippet(cx, qpath, to_ref_ty)))
+                            };
+
+                            diag.span_suggestion(
+                                e.span,
+                                "try",
+                                sugg::make_unop(deref, arg).to_string(),
+                                Applicability::Unspecified,
+                            );
+                        },
+                    ),
+                    (ty::Int(ty::IntTy::I32) | ty::Uint(ty::UintTy::U32), &ty::Char) => {
+                        span_lint_and_then(
+                            cx,
+                            TRANSMUTE_INT_TO_CHAR,
+                            e.span,
+                            &format!("transmute from a `{}` to a `char`", from_ty),
+                            |diag| {
+                                let arg = sugg::Sugg::hir(cx, &args[0], "..");
+                                let arg = if let ty::Int(_) = from_ty.kind() {
+                                    arg.as_ty(ast::UintTy::U32.name_str())
+                                } else {
+                                    arg
+                                };
+                                diag.span_suggestion(
+                                    e.span,
+                                    "consider using",
+                                    format!("std::char::from_u32({}).unwrap()", arg.to_string()),
+                                    Applicability::Unspecified,
+                                );
+                            },
+                        )
+                    },
+                    (ty::Ref(_, ty_from, from_mutbl), ty::Ref(_, ty_to, to_mutbl)) => {
+                        if_chain! {
+                            if let (&ty::Slice(slice_ty), &ty::Str) = (&ty_from.kind(), &ty_to.kind());
+                            if let ty::Uint(ty::UintTy::U8) = slice_ty.kind();
+                            if from_mutbl == to_mutbl;
+                            then {
+                                let postfix = if *from_mutbl == Mutability::Mut {
+                                    "_mut"
+                                } else {
+                                    ""
+                                };
+
+                                span_lint_and_sugg(
+                                    cx,
+                                    TRANSMUTE_BYTES_TO_STR,
+                                    e.span,
+                                    &format!("transmute from a `{}` to a `{}`", from_ty, to_ty),
+                                    "consider using",
+                                    format!(
+                                        "std::str::from_utf8{}({}).unwrap()",
+                                        postfix,
+                                        snippet(cx, args[0].span, ".."),
+                                    ),
+                                    Applicability::Unspecified,
+                                );
+                            } else {
+                                if (cx.tcx.erase_regions(from_ty) != cx.tcx.erase_regions(to_ty))
+                                    && !const_context {
+                                    span_lint_and_then(
+                                        cx,
+                                        TRANSMUTE_PTR_TO_PTR,
+                                        e.span,
+                                        "transmute from a reference to a reference",
+                                        |diag| if let Some(arg) = sugg::Sugg::hir_opt(cx, &args[0]) {
+                                            let ty_from_and_mut = ty::TypeAndMut {
+                                                ty: ty_from,
+                                                mutbl: *from_mutbl
+                                            };
+                                            let ty_to_and_mut = ty::TypeAndMut { ty: ty_to, mutbl: *to_mutbl };
+                                            let sugg_paren = arg
+                                                .as_ty(cx.tcx.mk_ptr(ty_from_and_mut))
+                                                .as_ty(cx.tcx.mk_ptr(ty_to_and_mut));
+                                            let sugg = if *to_mutbl == Mutability::Mut {
+                                                sugg_paren.mut_addr_deref()
+                                            } else {
+                                                sugg_paren.addr_deref()
+                                            };
+                                            diag.span_suggestion(
+                                                e.span,
+                                                "try",
+                                                sugg.to_string(),
+                                                Applicability::Unspecified,
+                                            );
+                                        },
+                                    )
+                                }
+                            }
+                        }
+                    },
+                    (ty::RawPtr(_), ty::RawPtr(to_ty)) => span_lint_and_then(
+                        cx,
+                        TRANSMUTE_PTR_TO_PTR,
+                        e.span,
+                        "transmute from a pointer to a pointer",
+                        |diag| {
+                            if let Some(arg) = sugg::Sugg::hir_opt(cx, &args[0]) {
+                                let sugg = arg.as_ty(cx.tcx.mk_ptr(*to_ty));
+                                diag.span_suggestion(e.span, "try", sugg.to_string(), Applicability::Unspecified);
+                            }
+                        },
+                    ),
+                    (ty::Int(ty::IntTy::I8) | ty::Uint(ty::UintTy::U8), ty::Bool) => {
+                        span_lint_and_then(
+                            cx,
+                            TRANSMUTE_INT_TO_BOOL,
+                            e.span,
+                            &format!("transmute from a `{}` to a `bool`", from_ty),
+                            |diag| {
+                                let arg = sugg::Sugg::hir(cx, &args[0], "..");
+                                let zero = sugg::Sugg::NonParen(Cow::from("0"));
+                                diag.span_suggestion(
+                                    e.span,
+                                    "consider using",
+                                    sugg::make_binop(ast::BinOpKind::Ne, &arg, &zero).to_string(),
+                                    Applicability::Unspecified,
+                                );
+                            },
+                        )
+                    },
+                    (ty::Int(_) | ty::Uint(_), ty::Float(_)) if !const_context => span_lint_and_then(
+                        cx,
+                        TRANSMUTE_INT_TO_FLOAT,
+                        e.span,
+                        &format!("transmute from a `{}` to a `{}`", from_ty, to_ty),
+                        |diag| {
+                            let arg = sugg::Sugg::hir(cx, &args[0], "..");
+                            let arg = if let ty::Int(int_ty) = from_ty.kind() {
+                                arg.as_ty(format!(
+                                    "u{}",
+                                    int_ty.bit_width().map_or_else(|| "size".to_string(), |v| v.to_string())
+                                ))
+                            } else {
+                                arg
+                            };
+                            diag.span_suggestion(
+                                e.span,
+                                "consider using",
+                                format!("{}::from_bits({})", to_ty, arg.to_string()),
+                                Applicability::Unspecified,
+                            );
+                        },
+                    ),
+                    (ty::Float(float_ty), ty::Int(_) | ty::Uint(_)) if !const_context => span_lint_and_then(
+                        cx,
+                        TRANSMUTE_FLOAT_TO_INT,
+                        e.span,
+                        &format!("transmute from a `{}` to a `{}`", from_ty, to_ty),
+                        |diag| {
+                            let mut expr = &args[0];
+                            let mut arg = sugg::Sugg::hir(cx, expr, "..");
+
+                            if let ExprKind::Unary(UnOp::Neg, inner_expr) = &expr.kind {
+                                expr = &inner_expr;
+                            }
+
+                            if_chain! {
+                                // if the expression is a float literal and it is unsuffixed then
+                                // add a suffix so the suggestion is valid and unambiguous
+                                let op = format!("{}{}", arg, float_ty.name_str()).into();
+                                if let ExprKind::Lit(lit) = &expr.kind;
+                                if let ast::LitKind::Float(_, ast::LitFloatType::Unsuffixed) = lit.node;
+                                then {
+                                    match arg {
+                                        sugg::Sugg::MaybeParen(_) => arg = sugg::Sugg::MaybeParen(op),
+                                        _ => arg = sugg::Sugg::NonParen(op)
+                                    }
+                                }
+                            }
+
+                            arg = sugg::Sugg::NonParen(format!("{}.to_bits()", arg.maybe_par()).into());
+
+                            // cast the result of `to_bits` if `to_ty` is signed
+                            arg = if let ty::Int(int_ty) = to_ty.kind() {
+                                arg.as_ty(int_ty.name_str().to_string())
+                            } else {
+                                arg
+                            };
+
+                            diag.span_suggestion(
+                                e.span,
+                                "consider using",
+                                arg.to_string(),
+                                Applicability::Unspecified,
+                            );
+                        },
+                    ),
+                    (ty::Adt(from_adt, from_substs), ty::Adt(to_adt, to_substs)) => {
+                        if from_adt.did != to_adt.did ||
+                                !COLLECTIONS.iter().any(|path| match_def_path(cx, to_adt.did, path)) {
+                            return;
+                        }
+                        if from_substs.types().zip(to_substs.types())
+                                              .any(|(from_ty, to_ty)| is_layout_incompatible(cx, from_ty, to_ty)) {
+                            span_lint(
+                                cx,
+                                UNSOUND_COLLECTION_TRANSMUTE,
+                                e.span,
+                                &format!(
+                                    "transmute from `{}` to `{}` with mismatched layout is unsound",
+                                    from_ty,
+                                    to_ty
+                                )
+                            );
+                        }
+                    },
+                    (_, _) if can_be_expressed_as_pointer_cast(cx, e, from_ty, to_ty) => span_lint_and_then(
+                        cx,
+                        TRANSMUTES_EXPRESSIBLE_AS_PTR_CASTS,
+                        e.span,
+                        &format!(
+                            "transmute from `{}` to `{}` which could be expressed as a pointer cast instead",
+                            from_ty,
+                            to_ty
+                        ),
+                        |diag| {
+                            if let Some(arg) = sugg::Sugg::hir_opt(cx, &args[0]) {
+                                let sugg = arg.as_ty(&to_ty.to_string()).to_string();
+                                diag.span_suggestion(e.span, "try", sugg, Applicability::MachineApplicable);
+                            }
+                        }
+                    ),
+                    _ => {
+                        return;
+                    },
+                }
+            }
+        }
+    }
+}
+
+/// Gets the snippet of `Bar` in `…::transmute<Foo, &Bar>`. If that snippet is
+/// not available , use
+/// the type's `ToString` implementation. In weird cases it could lead to types
+/// with invalid `'_`
+/// lifetime, but it should be rare.
+fn get_type_snippet(cx: &LateContext<'_>, path: &QPath<'_>, to_ref_ty: Ty<'_>) -> String {
+    let seg = last_path_segment(path);
+    if_chain! {
+        if let Some(ref params) = seg.args;
+        if !params.parenthesized;
+        if let Some(to_ty) = params.args.iter().filter_map(|arg| match arg {
+            GenericArg::Type(ty) => Some(ty),
+            _ => None,
+        }).nth(1);
+        if let TyKind::Rptr(_, ref to_ty) = to_ty.kind;
+        then {
+            return snippet(cx, to_ty.ty.span, &to_ref_ty.to_string()).to_string();
+        }
+    }
+
+    to_ref_ty.to_string()
+}
+
+// check if the component types of the transmuted collection and the result have different ABI,
+// size or alignment
+fn is_layout_incompatible<'tcx>(cx: &LateContext<'tcx>, from: Ty<'tcx>, to: Ty<'tcx>) -> bool {
+    let empty_param_env = ty::ParamEnv::empty();
+    // check if `from` and `to` are normalizable to avoid ICE (#4968)
+    if !(is_normalizable(cx, empty_param_env, from) && is_normalizable(cx, empty_param_env, to)) {
+        return false;
+    }
+    let from_ty_layout = cx.tcx.layout_of(empty_param_env.and(from));
+    let to_ty_layout = cx.tcx.layout_of(empty_param_env.and(to));
+    if let (Ok(from_layout), Ok(to_layout)) = (from_ty_layout, to_ty_layout) {
+        from_layout.size != to_layout.size || from_layout.align != to_layout.align || from_layout.abi != to_layout.abi
+    } else {
+        // no idea about layout, so don't lint
+        false
+    }
+}
+
+/// Check if the type conversion can be expressed as a pointer cast, instead of
+/// a transmute. In certain cases, including some invalid casts from array
+/// references to pointers, this may cause additional errors to be emitted and/or
+/// ICE error messages. This function will panic if that occurs.
+fn can_be_expressed_as_pointer_cast<'tcx>(
+    cx: &LateContext<'tcx>,
+    e: &'tcx Expr<'_>,
+    from_ty: Ty<'tcx>,
+    to_ty: Ty<'tcx>,
+) -> bool {
+    use CastKind::{AddrPtrCast, ArrayPtrCast, FnPtrAddrCast, FnPtrPtrCast, PtrAddrCast, PtrPtrCast};
+    matches!(
+        check_cast(cx, e, from_ty, to_ty),
+        Some(PtrPtrCast | PtrAddrCast | AddrPtrCast | ArrayPtrCast | FnPtrPtrCast | FnPtrAddrCast)
+    )
+}
+
+/// If a cast from `from_ty` to `to_ty` is valid, returns an Ok containing the kind of
+/// the cast. In certain cases, including some invalid casts from array references
+/// to pointers, this may cause additional errors to be emitted and/or ICE error
+/// messages. This function will panic if that occurs.
+fn check_cast<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>, from_ty: Ty<'tcx>, to_ty: Ty<'tcx>) -> Option<CastKind> {
+    let hir_id = e.hir_id;
+    let local_def_id = hir_id.owner;
+
+    Inherited::build(cx.tcx, local_def_id).enter(|inherited| {
+        let fn_ctxt = FnCtxt::new(&inherited, cx.param_env, hir_id);
+
+        // If we already have errors, we can't be sure we can pointer cast.
+        assert!(
+            !fn_ctxt.errors_reported_since_creation(),
+            "Newly created FnCtxt contained errors"
+        );
+
+        if let Ok(check) = CastCheck::new(
+            &fn_ctxt, e, from_ty, to_ty,
+            // We won't show any error to the user, so we don't care what the span is here.
+            DUMMY_SP, DUMMY_SP,
+        ) {
+            let res = check.do_check(&fn_ctxt);
+
+            // do_check's documentation says that it might return Ok and create
+            // errors in the fcx instead of returing Err in some cases. Those cases
+            // should be filtered out before getting here.
+            assert!(
+                !fn_ctxt.errors_reported_since_creation(),
+                "`fn_ctxt` contained errors after cast check!"
+            );
+
+            res.ok()
+        } else {
+            None
+        }
+    })
+}
-- 
cgit 1.4.1-3-g733a5


From 4ac438bfed36c1de307cac0f86d8d4938157ac50 Mon Sep 17 00:00:00 2001
From: Yusuke Tanaka <yusuktan@maguro.dev>
Date: Wed, 10 Feb 2021 23:15:06 +0900
Subject: Add transmute/utils.rs

---
 clippy_lints/src/transmute/mod.rs   | 110 +++---------------------------------
 clippy_lints/src/transmute/utils.rs | 109 +++++++++++++++++++++++++++++++++++
 2 files changed, 116 insertions(+), 103 deletions(-)
 create mode 100644 clippy_lints/src/transmute/utils.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/transmute/mod.rs b/clippy_lints/src/transmute/mod.rs
index dc938ed0238..0258244a07b 100644
--- a/clippy_lints/src/transmute/mod.rs
+++ b/clippy_lints/src/transmute/mod.rs
@@ -1,16 +1,16 @@
+mod utils;
+use utils::*;
+
 use crate::utils::{
-    in_constant, is_normalizable, last_path_segment, match_def_path, paths, snippet, span_lint, span_lint_and_sugg,
-    span_lint_and_then, sugg,
+    in_constant, match_def_path, paths, snippet, span_lint, span_lint_and_sugg, span_lint_and_then, sugg,
 };
 use if_chain::if_chain;
 use rustc_ast as ast;
 use rustc_errors::Applicability;
-use rustc_hir::{Expr, ExprKind, GenericArg, Mutability, QPath, TyKind, UnOp};
+use rustc_hir::{Expr, ExprKind, Mutability, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty::{self, cast::CastKind, Ty};
+use rustc_middle::ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::DUMMY_SP;
-use rustc_typeck::check::{cast::CastCheck, FnCtxt, Inherited};
 use std::borrow::Cow;
 
 declare_clippy_lint! {
@@ -326,6 +326,7 @@ static COLLECTIONS: &[&[&str]] = &[
     &paths::HASHSET,
     &paths::HASHMAP,
 ];
+
 impl<'tcx> LateLintPass<'tcx> for Transmute {
     #[allow(clippy::similar_names, clippy::too_many_lines)]
     fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
@@ -664,100 +665,3 @@ impl<'tcx> LateLintPass<'tcx> for Transmute {
         }
     }
 }
-
-/// Gets the snippet of `Bar` in `…::transmute<Foo, &Bar>`. If that snippet is
-/// not available , use
-/// the type's `ToString` implementation. In weird cases it could lead to types
-/// with invalid `'_`
-/// lifetime, but it should be rare.
-fn get_type_snippet(cx: &LateContext<'_>, path: &QPath<'_>, to_ref_ty: Ty<'_>) -> String {
-    let seg = last_path_segment(path);
-    if_chain! {
-        if let Some(ref params) = seg.args;
-        if !params.parenthesized;
-        if let Some(to_ty) = params.args.iter().filter_map(|arg| match arg {
-            GenericArg::Type(ty) => Some(ty),
-            _ => None,
-        }).nth(1);
-        if let TyKind::Rptr(_, ref to_ty) = to_ty.kind;
-        then {
-            return snippet(cx, to_ty.ty.span, &to_ref_ty.to_string()).to_string();
-        }
-    }
-
-    to_ref_ty.to_string()
-}
-
-// check if the component types of the transmuted collection and the result have different ABI,
-// size or alignment
-fn is_layout_incompatible<'tcx>(cx: &LateContext<'tcx>, from: Ty<'tcx>, to: Ty<'tcx>) -> bool {
-    let empty_param_env = ty::ParamEnv::empty();
-    // check if `from` and `to` are normalizable to avoid ICE (#4968)
-    if !(is_normalizable(cx, empty_param_env, from) && is_normalizable(cx, empty_param_env, to)) {
-        return false;
-    }
-    let from_ty_layout = cx.tcx.layout_of(empty_param_env.and(from));
-    let to_ty_layout = cx.tcx.layout_of(empty_param_env.and(to));
-    if let (Ok(from_layout), Ok(to_layout)) = (from_ty_layout, to_ty_layout) {
-        from_layout.size != to_layout.size || from_layout.align != to_layout.align || from_layout.abi != to_layout.abi
-    } else {
-        // no idea about layout, so don't lint
-        false
-    }
-}
-
-/// Check if the type conversion can be expressed as a pointer cast, instead of
-/// a transmute. In certain cases, including some invalid casts from array
-/// references to pointers, this may cause additional errors to be emitted and/or
-/// ICE error messages. This function will panic if that occurs.
-fn can_be_expressed_as_pointer_cast<'tcx>(
-    cx: &LateContext<'tcx>,
-    e: &'tcx Expr<'_>,
-    from_ty: Ty<'tcx>,
-    to_ty: Ty<'tcx>,
-) -> bool {
-    use CastKind::{AddrPtrCast, ArrayPtrCast, FnPtrAddrCast, FnPtrPtrCast, PtrAddrCast, PtrPtrCast};
-    matches!(
-        check_cast(cx, e, from_ty, to_ty),
-        Some(PtrPtrCast | PtrAddrCast | AddrPtrCast | ArrayPtrCast | FnPtrPtrCast | FnPtrAddrCast)
-    )
-}
-
-/// If a cast from `from_ty` to `to_ty` is valid, returns an Ok containing the kind of
-/// the cast. In certain cases, including some invalid casts from array references
-/// to pointers, this may cause additional errors to be emitted and/or ICE error
-/// messages. This function will panic if that occurs.
-fn check_cast<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>, from_ty: Ty<'tcx>, to_ty: Ty<'tcx>) -> Option<CastKind> {
-    let hir_id = e.hir_id;
-    let local_def_id = hir_id.owner;
-
-    Inherited::build(cx.tcx, local_def_id).enter(|inherited| {
-        let fn_ctxt = FnCtxt::new(&inherited, cx.param_env, hir_id);
-
-        // If we already have errors, we can't be sure we can pointer cast.
-        assert!(
-            !fn_ctxt.errors_reported_since_creation(),
-            "Newly created FnCtxt contained errors"
-        );
-
-        if let Ok(check) = CastCheck::new(
-            &fn_ctxt, e, from_ty, to_ty,
-            // We won't show any error to the user, so we don't care what the span is here.
-            DUMMY_SP, DUMMY_SP,
-        ) {
-            let res = check.do_check(&fn_ctxt);
-
-            // do_check's documentation says that it might return Ok and create
-            // errors in the fcx instead of returing Err in some cases. Those cases
-            // should be filtered out before getting here.
-            assert!(
-                !fn_ctxt.errors_reported_since_creation(),
-                "`fn_ctxt` contained errors after cast check!"
-            );
-
-            res.ok()
-        } else {
-            None
-        }
-    })
-}
diff --git a/clippy_lints/src/transmute/utils.rs b/clippy_lints/src/transmute/utils.rs
new file mode 100644
index 00000000000..734a92d50d2
--- /dev/null
+++ b/clippy_lints/src/transmute/utils.rs
@@ -0,0 +1,109 @@
+use crate::utils::{is_normalizable, last_path_segment, snippet};
+use if_chain::if_chain;
+use rustc_hir::{Expr, GenericArg, QPath, TyKind};
+use rustc_lint::LateContext;
+use rustc_middle::ty::{self, cast::CastKind, Ty};
+use rustc_span::DUMMY_SP;
+use rustc_typeck::check::{cast::CastCheck, FnCtxt, Inherited};
+
+/// Gets the snippet of `Bar` in `…::transmute<Foo, &Bar>`. If that snippet is
+/// not available , use
+/// the type's `ToString` implementation. In weird cases it could lead to types
+/// with invalid `'_`
+/// lifetime, but it should be rare.
+pub(super) fn get_type_snippet(cx: &LateContext<'_>, path: &QPath<'_>, to_ref_ty: Ty<'_>) -> String {
+    let seg = last_path_segment(path);
+    if_chain! {
+        if let Some(ref params) = seg.args;
+        if !params.parenthesized;
+        if let Some(to_ty) = params.args.iter().filter_map(|arg| match arg {
+            GenericArg::Type(ty) => Some(ty),
+            _ => None,
+        }).nth(1);
+        if let TyKind::Rptr(_, ref to_ty) = to_ty.kind;
+        then {
+            return snippet(cx, to_ty.ty.span, &to_ref_ty.to_string()).to_string();
+        }
+    }
+
+    to_ref_ty.to_string()
+}
+
+// check if the component types of the transmuted collection and the result have different ABI,
+// size or alignment
+pub(super) fn is_layout_incompatible<'tcx>(cx: &LateContext<'tcx>, from: Ty<'tcx>, to: Ty<'tcx>) -> bool {
+    let empty_param_env = ty::ParamEnv::empty();
+    // check if `from` and `to` are normalizable to avoid ICE (#4968)
+    if !(is_normalizable(cx, empty_param_env, from) && is_normalizable(cx, empty_param_env, to)) {
+        return false;
+    }
+    let from_ty_layout = cx.tcx.layout_of(empty_param_env.and(from));
+    let to_ty_layout = cx.tcx.layout_of(empty_param_env.and(to));
+    if let (Ok(from_layout), Ok(to_layout)) = (from_ty_layout, to_ty_layout) {
+        from_layout.size != to_layout.size || from_layout.align != to_layout.align || from_layout.abi != to_layout.abi
+    } else {
+        // no idea about layout, so don't lint
+        false
+    }
+}
+
+/// Check if the type conversion can be expressed as a pointer cast, instead of
+/// a transmute. In certain cases, including some invalid casts from array
+/// references to pointers, this may cause additional errors to be emitted and/or
+/// ICE error messages. This function will panic if that occurs.
+pub(super) fn can_be_expressed_as_pointer_cast<'tcx>(
+    cx: &LateContext<'tcx>,
+    e: &'tcx Expr<'_>,
+    from_ty: Ty<'tcx>,
+    to_ty: Ty<'tcx>,
+) -> bool {
+    use CastKind::{AddrPtrCast, ArrayPtrCast, FnPtrAddrCast, FnPtrPtrCast, PtrAddrCast, PtrPtrCast};
+    matches!(
+        check_cast(cx, e, from_ty, to_ty),
+        Some(PtrPtrCast | PtrAddrCast | AddrPtrCast | ArrayPtrCast | FnPtrPtrCast | FnPtrAddrCast)
+    )
+}
+
+/// If a cast from `from_ty` to `to_ty` is valid, returns an Ok containing the kind of
+/// the cast. In certain cases, including some invalid casts from array references
+/// to pointers, this may cause additional errors to be emitted and/or ICE error
+/// messages. This function will panic if that occurs.
+pub(super) fn check_cast<'tcx>(
+    cx: &LateContext<'tcx>,
+    e: &'tcx Expr<'_>,
+    from_ty: Ty<'tcx>,
+    to_ty: Ty<'tcx>,
+) -> Option<CastKind> {
+    let hir_id = e.hir_id;
+    let local_def_id = hir_id.owner;
+
+    Inherited::build(cx.tcx, local_def_id).enter(|inherited| {
+        let fn_ctxt = FnCtxt::new(&inherited, cx.param_env, hir_id);
+
+        // If we already have errors, we can't be sure we can pointer cast.
+        assert!(
+            !fn_ctxt.errors_reported_since_creation(),
+            "Newly created FnCtxt contained errors"
+        );
+
+        if let Ok(check) = CastCheck::new(
+            &fn_ctxt, e, from_ty, to_ty,
+            // We won't show any error to the user, so we don't care what the span is here.
+            DUMMY_SP, DUMMY_SP,
+        ) {
+            let res = check.do_check(&fn_ctxt);
+
+            // do_check's documentation says that it might return Ok and create
+            // errors in the fcx instead of returing Err in some cases. Those cases
+            // should be filtered out before getting here.
+            assert!(
+                !fn_ctxt.errors_reported_since_creation(),
+                "`fn_ctxt` contained errors after cast check!"
+            );
+
+            res.ok()
+        } else {
+            None
+        }
+    })
+}
-- 
cgit 1.4.1-3-g733a5


From 0d7dd00860e5a2b8b7c7a34daaa5553ff2e542f3 Mon Sep 17 00:00:00 2001
From: Yusuke Tanaka <yusuktan@maguro.dev>
Date: Wed, 10 Feb 2021 23:54:11 +0900
Subject: Move useless_transmute to its own module

---
 clippy_lints/src/transmute/mod.rs               | 51 +++--------------
 clippy_lints/src/transmute/useless_transmute.rs | 74 +++++++++++++++++++++++++
 2 files changed, 81 insertions(+), 44 deletions(-)
 create mode 100644 clippy_lints/src/transmute/useless_transmute.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/transmute/mod.rs b/clippy_lints/src/transmute/mod.rs
index 0258244a07b..4897934376f 100644
--- a/clippy_lints/src/transmute/mod.rs
+++ b/clippy_lints/src/transmute/mod.rs
@@ -1,4 +1,6 @@
+mod useless_transmute;
 mod utils;
+
 use utils::*;
 
 use crate::utils::{
@@ -344,51 +346,12 @@ impl<'tcx> LateLintPass<'tcx> for Transmute {
                 let from_ty = cx.typeck_results().expr_ty(&args[0]);
                 let to_ty = cx.typeck_results().expr_ty(e);
 
-                match (&from_ty.kind(), &to_ty.kind()) {
-                    _ if from_ty == to_ty => span_lint(
-                        cx,
-                        USELESS_TRANSMUTE,
-                        e.span,
-                        &format!("transmute from a type (`{}`) to itself", from_ty),
-                    ),
-                    (ty::Ref(_, rty, rty_mutbl), ty::RawPtr(ptr_ty)) => span_lint_and_then(
-                        cx,
-                        USELESS_TRANSMUTE,
-                        e.span,
-                        "transmute from a reference to a pointer",
-                        |diag| {
-                            if let Some(arg) = sugg::Sugg::hir_opt(cx, &args[0]) {
-                                let rty_and_mut = ty::TypeAndMut {
-                                    ty: rty,
-                                    mutbl: *rty_mutbl,
-                                };
-
-                                let sugg = if *ptr_ty == rty_and_mut {
-                                    arg.as_ty(to_ty)
-                                } else {
-                                    arg.as_ty(cx.tcx.mk_ptr(rty_and_mut)).as_ty(to_ty)
-                                };
+                let triggered = useless_transmute::check(cx, e, from_ty, to_ty, args);
+                if triggered {
+                    return;
+                }
 
-                                diag.span_suggestion(e.span, "try", sugg.to_string(), Applicability::Unspecified);
-                            }
-                        },
-                    ),
-                    (ty::Int(_) | ty::Uint(_), ty::RawPtr(_)) => span_lint_and_then(
-                        cx,
-                        USELESS_TRANSMUTE,
-                        e.span,
-                        "transmute from an integer to a pointer",
-                        |diag| {
-                            if let Some(arg) = sugg::Sugg::hir_opt(cx, &args[0]) {
-                                diag.span_suggestion(
-                                    e.span,
-                                    "try",
-                                    arg.as_ty(&to_ty.to_string()).to_string(),
-                                    Applicability::Unspecified,
-                                );
-                            }
-                        },
-                    ),
+                match (&from_ty.kind(), &to_ty.kind()) {
                     (ty::Float(_) | ty::Char, ty::Ref(..) | ty::RawPtr(_)) => span_lint(
                         cx,
                         WRONG_TRANSMUTE,
diff --git a/clippy_lints/src/transmute/useless_transmute.rs b/clippy_lints/src/transmute/useless_transmute.rs
new file mode 100644
index 00000000000..86d75fd2ee0
--- /dev/null
+++ b/clippy_lints/src/transmute/useless_transmute.rs
@@ -0,0 +1,74 @@
+use super::USELESS_TRANSMUTE;
+use crate::utils::{span_lint, span_lint_and_then, sugg};
+use rustc_errors::Applicability;
+use rustc_hir::Expr;
+use rustc_lint::LateContext;
+use rustc_middle::ty;
+use rustc_middle::ty::Ty;
+
+/// Checks for `useless_transmute` lint.
+/// Returns `true` if it's triggered, otherwise returns `false`.
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    e: &'tcx Expr<'_>,
+    from_ty: Ty<'tcx>,
+    to_ty: Ty<'tcx>,
+    args: &'tcx [Expr<'_>],
+) -> bool {
+    match (&from_ty.kind(), &to_ty.kind()) {
+        _ if from_ty == to_ty => {
+            span_lint(
+                cx,
+                USELESS_TRANSMUTE,
+                e.span,
+                &format!("transmute from a type (`{}`) to itself", from_ty),
+            );
+            true
+        },
+        (ty::Ref(_, rty, rty_mutbl), ty::RawPtr(ptr_ty)) => {
+            span_lint_and_then(
+                cx,
+                USELESS_TRANSMUTE,
+                e.span,
+                "transmute from a reference to a pointer",
+                |diag| {
+                    if let Some(arg) = sugg::Sugg::hir_opt(cx, &args[0]) {
+                        let rty_and_mut = ty::TypeAndMut {
+                            ty: rty,
+                            mutbl: *rty_mutbl,
+                        };
+
+                        let sugg = if *ptr_ty == rty_and_mut {
+                            arg.as_ty(to_ty)
+                        } else {
+                            arg.as_ty(cx.tcx.mk_ptr(rty_and_mut)).as_ty(to_ty)
+                        };
+
+                        diag.span_suggestion(e.span, "try", sugg.to_string(), Applicability::Unspecified);
+                    }
+                },
+            );
+            true
+        },
+        (ty::Int(_) | ty::Uint(_), ty::RawPtr(_)) => {
+            span_lint_and_then(
+                cx,
+                USELESS_TRANSMUTE,
+                e.span,
+                "transmute from an integer to a pointer",
+                |diag| {
+                    if let Some(arg) = sugg::Sugg::hir_opt(cx, &args[0]) {
+                        diag.span_suggestion(
+                            e.span,
+                            "try",
+                            arg.as_ty(&to_ty.to_string()).to_string(),
+                            Applicability::Unspecified,
+                        );
+                    }
+                },
+            );
+            true
+        },
+        _ => false,
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From ef97764dcc45493eebe0332acf4b2410583af5e4 Mon Sep 17 00:00:00 2001
From: Yusuke Tanaka <yusuktan@maguro.dev>
Date: Wed, 10 Feb 2021 23:57:56 +0900
Subject: Move wrong_transmute to its own module

---
 clippy_lints/src/transmute/mod.rs             | 11 +++++------
 clippy_lints/src/transmute/wrong_transmute.rs | 23 +++++++++++++++++++++++
 2 files changed, 28 insertions(+), 6 deletions(-)
 create mode 100644 clippy_lints/src/transmute/wrong_transmute.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/transmute/mod.rs b/clippy_lints/src/transmute/mod.rs
index 4897934376f..09e0fe257a5 100644
--- a/clippy_lints/src/transmute/mod.rs
+++ b/clippy_lints/src/transmute/mod.rs
@@ -1,5 +1,6 @@
 mod useless_transmute;
 mod utils;
+mod wrong_transmute;
 
 use utils::*;
 
@@ -350,14 +351,12 @@ impl<'tcx> LateLintPass<'tcx> for Transmute {
                 if triggered {
                     return;
                 }
+                let triggered = wrong_transmute::check(cx, e, from_ty, to_ty);
+                if triggered {
+                    return;
+                }
 
                 match (&from_ty.kind(), &to_ty.kind()) {
-                    (ty::Float(_) | ty::Char, ty::Ref(..) | ty::RawPtr(_)) => span_lint(
-                        cx,
-                        WRONG_TRANSMUTE,
-                        e.span,
-                        &format!("transmute from a `{}` to a pointer", from_ty),
-                    ),
                     (ty::RawPtr(from_ptr), _) if from_ptr.ty == to_ty => span_lint(
                         cx,
                         CROSSPOINTER_TRANSMUTE,
diff --git a/clippy_lints/src/transmute/wrong_transmute.rs b/clippy_lints/src/transmute/wrong_transmute.rs
new file mode 100644
index 00000000000..d2d3f0a9c89
--- /dev/null
+++ b/clippy_lints/src/transmute/wrong_transmute.rs
@@ -0,0 +1,23 @@
+use super::WRONG_TRANSMUTE;
+use crate::utils::span_lint;
+use rustc_hir::Expr;
+use rustc_lint::LateContext;
+use rustc_middle::ty;
+use rustc_middle::ty::Ty;
+
+/// Checks for `wrong_transmute` lint.
+/// Returns `true` if it's triggered, otherwise returns `false`.
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>, from_ty: Ty<'tcx>, to_ty: Ty<'tcx>) -> bool {
+    match (&from_ty.kind(), &to_ty.kind()) {
+        (ty::Float(_) | ty::Char, ty::Ref(..) | ty::RawPtr(_)) => {
+            span_lint(
+                cx,
+                WRONG_TRANSMUTE,
+                e.span,
+                &format!("transmute from a `{}` to a pointer", from_ty),
+            );
+            true
+        },
+        _ => false,
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From afc9275928905d2142da027815aac67b81d0a89b Mon Sep 17 00:00:00 2001
From: Yusuke Tanaka <yusuktan@maguro.dev>
Date: Thu, 11 Feb 2021 00:02:21 +0900
Subject: Move crosspointer_transmute to its own module

---
 .../src/transmute/crosspointer_transmute.rs        | 38 ++++++++++++++++++++++
 clippy_lints/src/transmute/mod.rs                  | 23 +++----------
 2 files changed, 43 insertions(+), 18 deletions(-)
 create mode 100644 clippy_lints/src/transmute/crosspointer_transmute.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/transmute/crosspointer_transmute.rs b/clippy_lints/src/transmute/crosspointer_transmute.rs
new file mode 100644
index 00000000000..b570bb3a396
--- /dev/null
+++ b/clippy_lints/src/transmute/crosspointer_transmute.rs
@@ -0,0 +1,38 @@
+use super::CROSSPOINTER_TRANSMUTE;
+use crate::utils::span_lint;
+use rustc_hir::Expr;
+use rustc_lint::LateContext;
+use rustc_middle::ty;
+use rustc_middle::ty::Ty;
+
+/// Checks for `crosspointer_transmute` lint.
+/// Returns `true` if it's triggered, otherwise returns `false`.
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>, from_ty: Ty<'tcx>, to_ty: Ty<'tcx>) -> bool {
+    match (&from_ty.kind(), &to_ty.kind()) {
+        (ty::RawPtr(from_ptr), _) if from_ptr.ty == to_ty => {
+            span_lint(
+                cx,
+                CROSSPOINTER_TRANSMUTE,
+                e.span,
+                &format!(
+                    "transmute from a type (`{}`) to the type that it points to (`{}`)",
+                    from_ty, to_ty
+                ),
+            );
+            true
+        },
+        (_, ty::RawPtr(to_ptr)) if to_ptr.ty == from_ty => {
+            span_lint(
+                cx,
+                CROSSPOINTER_TRANSMUTE,
+                e.span,
+                &format!(
+                    "transmute from a type (`{}`) to a pointer to that type (`{}`)",
+                    from_ty, to_ty
+                ),
+            );
+            true
+        },
+        _ => false,
+    }
+}
diff --git a/clippy_lints/src/transmute/mod.rs b/clippy_lints/src/transmute/mod.rs
index 09e0fe257a5..7e05771c885 100644
--- a/clippy_lints/src/transmute/mod.rs
+++ b/clippy_lints/src/transmute/mod.rs
@@ -1,3 +1,4 @@
+mod crosspointer_transmute;
 mod useless_transmute;
 mod utils;
 mod wrong_transmute;
@@ -355,26 +356,12 @@ impl<'tcx> LateLintPass<'tcx> for Transmute {
                 if triggered {
                     return;
                 }
+                let triggered = crosspointer_transmute::check(cx, e, from_ty, to_ty);
+                if triggered {
+                    return;
+                }
 
                 match (&from_ty.kind(), &to_ty.kind()) {
-                    (ty::RawPtr(from_ptr), _) if from_ptr.ty == to_ty => span_lint(
-                        cx,
-                        CROSSPOINTER_TRANSMUTE,
-                        e.span,
-                        &format!(
-                            "transmute from a type (`{}`) to the type that it points to (`{}`)",
-                            from_ty, to_ty
-                        ),
-                    ),
-                    (_, ty::RawPtr(to_ptr)) if to_ptr.ty == from_ty => span_lint(
-                        cx,
-                        CROSSPOINTER_TRANSMUTE,
-                        e.span,
-                        &format!(
-                            "transmute from a type (`{}`) to a pointer to that type (`{}`)",
-                            from_ty, to_ty
-                        ),
-                    ),
                     (ty::RawPtr(from_pty), ty::Ref(_, to_ref_ty, mutbl)) => span_lint_and_then(
                         cx,
                         TRANSMUTE_PTR_TO_REF,
-- 
cgit 1.4.1-3-g733a5


From 6442d45d3a55cee14ccee14c004ea344072d54cd Mon Sep 17 00:00:00 2001
From: Yusuke Tanaka <yusuktan@maguro.dev>
Date: Thu, 11 Feb 2021 00:10:19 +0900
Subject: Move transmute_ptr_to_ref to its own module

---
 clippy_lints/src/transmute/mod.rs                  | 36 ++------------
 clippy_lints/src/transmute/transmute_ptr_to_ref.rs | 56 ++++++++++++++++++++++
 2 files changed, 61 insertions(+), 31 deletions(-)
 create mode 100644 clippy_lints/src/transmute/transmute_ptr_to_ref.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/transmute/mod.rs b/clippy_lints/src/transmute/mod.rs
index 7e05771c885..f00cb9b935c 100644
--- a/clippy_lints/src/transmute/mod.rs
+++ b/clippy_lints/src/transmute/mod.rs
@@ -1,4 +1,5 @@
 mod crosspointer_transmute;
+mod transmute_ptr_to_ref;
 mod useless_transmute;
 mod utils;
 mod wrong_transmute;
@@ -360,39 +361,12 @@ impl<'tcx> LateLintPass<'tcx> for Transmute {
                 if triggered {
                     return;
                 }
+                let triggered = transmute_ptr_to_ref::check(cx, e, from_ty, to_ty, args, qpath);
+                if triggered {
+                    return;
+                }
 
                 match (&from_ty.kind(), &to_ty.kind()) {
-                    (ty::RawPtr(from_pty), ty::Ref(_, to_ref_ty, mutbl)) => span_lint_and_then(
-                        cx,
-                        TRANSMUTE_PTR_TO_REF,
-                        e.span,
-                        &format!(
-                            "transmute from a pointer type (`{}`) to a reference type \
-                             (`{}`)",
-                            from_ty, to_ty
-                        ),
-                        |diag| {
-                            let arg = sugg::Sugg::hir(cx, &args[0], "..");
-                            let (deref, cast) = if *mutbl == Mutability::Mut {
-                                ("&mut *", "*mut")
-                            } else {
-                                ("&*", "*const")
-                            };
-
-                            let arg = if from_pty.ty == *to_ref_ty {
-                                arg
-                            } else {
-                                arg.as_ty(&format!("{} {}", cast, get_type_snippet(cx, qpath, to_ref_ty)))
-                            };
-
-                            diag.span_suggestion(
-                                e.span,
-                                "try",
-                                sugg::make_unop(deref, arg).to_string(),
-                                Applicability::Unspecified,
-                            );
-                        },
-                    ),
                     (ty::Int(ty::IntTy::I32) | ty::Uint(ty::UintTy::U32), &ty::Char) => {
                         span_lint_and_then(
                             cx,
diff --git a/clippy_lints/src/transmute/transmute_ptr_to_ref.rs b/clippy_lints/src/transmute/transmute_ptr_to_ref.rs
new file mode 100644
index 00000000000..7be47da35da
--- /dev/null
+++ b/clippy_lints/src/transmute/transmute_ptr_to_ref.rs
@@ -0,0 +1,56 @@
+use super::utils::get_type_snippet;
+use super::TRANSMUTE_PTR_TO_REF;
+use crate::utils::{span_lint_and_then, sugg};
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, Mutability, QPath};
+use rustc_lint::LateContext;
+use rustc_middle::ty;
+use rustc_middle::ty::Ty;
+
+/// Checks for `transmute_ptr_to_ref` lint.
+/// Returns `true` if it's triggered, otherwise returns `false`.
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    e: &'tcx Expr<'_>,
+    from_ty: Ty<'tcx>,
+    to_ty: Ty<'tcx>,
+    args: &'tcx [Expr<'_>],
+    qpath: &'tcx QPath<'_>,
+) -> bool {
+    match (&from_ty.kind(), &to_ty.kind()) {
+        (ty::RawPtr(from_pty), ty::Ref(_, to_ref_ty, mutbl)) => {
+            span_lint_and_then(
+                cx,
+                TRANSMUTE_PTR_TO_REF,
+                e.span,
+                &format!(
+                    "transmute from a pointer type (`{}`) to a reference type (`{}`)",
+                    from_ty, to_ty
+                ),
+                |diag| {
+                    let arg = sugg::Sugg::hir(cx, &args[0], "..");
+                    let (deref, cast) = if *mutbl == Mutability::Mut {
+                        ("&mut *", "*mut")
+                    } else {
+                        ("&*", "*const")
+                    };
+
+                    let arg = if from_pty.ty == *to_ref_ty {
+                        arg
+                    } else {
+                        arg.as_ty(&format!("{} {}", cast, get_type_snippet(cx, qpath, to_ref_ty)))
+                    };
+
+                    diag.span_suggestion(
+                        e.span,
+                        "try",
+                        sugg::make_unop(deref, arg).to_string(),
+                        Applicability::Unspecified,
+                    );
+                },
+            );
+            true
+        },
+        _ => false,
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 4c6522118802b5fd98337eeb57d3d81268069385 Mon Sep 17 00:00:00 2001
From: Yusuke Tanaka <yusuktan@maguro.dev>
Date: Thu, 11 Feb 2021 00:18:45 +0900
Subject: Move transmute_int_to_char to its own module

---
 clippy_lints/src/transmute/mod.rs                  | 27 +++----------
 .../src/transmute/transmute_int_to_char.rs         | 47 ++++++++++++++++++++++
 2 files changed, 52 insertions(+), 22 deletions(-)
 create mode 100644 clippy_lints/src/transmute/transmute_int_to_char.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/transmute/mod.rs b/clippy_lints/src/transmute/mod.rs
index f00cb9b935c..376f9bd78c0 100644
--- a/clippy_lints/src/transmute/mod.rs
+++ b/clippy_lints/src/transmute/mod.rs
@@ -1,4 +1,5 @@
 mod crosspointer_transmute;
+mod transmute_int_to_char;
 mod transmute_ptr_to_ref;
 mod useless_transmute;
 mod utils;
@@ -365,30 +366,12 @@ impl<'tcx> LateLintPass<'tcx> for Transmute {
                 if triggered {
                     return;
                 }
+                let triggered = transmute_int_to_char::check(cx, e, from_ty, to_ty, args);
+                if triggered {
+                    return;
+                }
 
                 match (&from_ty.kind(), &to_ty.kind()) {
-                    (ty::Int(ty::IntTy::I32) | ty::Uint(ty::UintTy::U32), &ty::Char) => {
-                        span_lint_and_then(
-                            cx,
-                            TRANSMUTE_INT_TO_CHAR,
-                            e.span,
-                            &format!("transmute from a `{}` to a `char`", from_ty),
-                            |diag| {
-                                let arg = sugg::Sugg::hir(cx, &args[0], "..");
-                                let arg = if let ty::Int(_) = from_ty.kind() {
-                                    arg.as_ty(ast::UintTy::U32.name_str())
-                                } else {
-                                    arg
-                                };
-                                diag.span_suggestion(
-                                    e.span,
-                                    "consider using",
-                                    format!("std::char::from_u32({}).unwrap()", arg.to_string()),
-                                    Applicability::Unspecified,
-                                );
-                            },
-                        )
-                    },
                     (ty::Ref(_, ty_from, from_mutbl), ty::Ref(_, ty_to, to_mutbl)) => {
                         if_chain! {
                             if let (&ty::Slice(slice_ty), &ty::Str) = (&ty_from.kind(), &ty_to.kind());
diff --git a/clippy_lints/src/transmute/transmute_int_to_char.rs b/clippy_lints/src/transmute/transmute_int_to_char.rs
new file mode 100644
index 00000000000..179627d9964
--- /dev/null
+++ b/clippy_lints/src/transmute/transmute_int_to_char.rs
@@ -0,0 +1,47 @@
+use super::TRANSMUTE_INT_TO_CHAR;
+use crate::utils::{span_lint_and_then, sugg};
+use rustc_ast as ast;
+use rustc_errors::Applicability;
+use rustc_hir::Expr;
+use rustc_lint::LateContext;
+use rustc_middle::ty;
+use rustc_middle::ty::Ty;
+
+/// Checks for `transmute_int_to_char` lint.
+/// Returns `true` if it's triggered, otherwise returns `false`.
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    e: &'tcx Expr<'_>,
+    from_ty: Ty<'tcx>,
+    to_ty: Ty<'tcx>,
+    args: &'tcx [Expr<'_>],
+) -> bool {
+    match (&from_ty.kind(), &to_ty.kind()) {
+        (ty::Int(ty::IntTy::I32) | ty::Uint(ty::UintTy::U32), &ty::Char) => {
+            {
+                span_lint_and_then(
+                    cx,
+                    TRANSMUTE_INT_TO_CHAR,
+                    e.span,
+                    &format!("transmute from a `{}` to a `char`", from_ty),
+                    |diag| {
+                        let arg = sugg::Sugg::hir(cx, &args[0], "..");
+                        let arg = if let ty::Int(_) = from_ty.kind() {
+                            arg.as_ty(ast::UintTy::U32.name_str())
+                        } else {
+                            arg
+                        };
+                        diag.span_suggestion(
+                            e.span,
+                            "consider using",
+                            format!("std::char::from_u32({}).unwrap()", arg.to_string()),
+                            Applicability::Unspecified,
+                        );
+                    },
+                )
+            };
+            true
+        },
+        _ => false,
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 7af3458b5458ad99dc900b9fe744f39b9dae449e Mon Sep 17 00:00:00 2001
From: Yusuke Tanaka <yusuktan@maguro.dev>
Date: Thu, 11 Feb 2021 00:40:57 +0900
Subject: Move transmute_bytes_to_str and transmute_ptr_to_ptr to
 transmute_ref_to_ref module

---
 clippy_lints/src/transmute/mod.rs                  | 64 ++--------------
 clippy_lints/src/transmute/transmute_ref_to_ref.rs | 89 ++++++++++++++++++++++
 2 files changed, 94 insertions(+), 59 deletions(-)
 create mode 100644 clippy_lints/src/transmute/transmute_ref_to_ref.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/transmute/mod.rs b/clippy_lints/src/transmute/mod.rs
index 376f9bd78c0..8a0c83789d5 100644
--- a/clippy_lints/src/transmute/mod.rs
+++ b/clippy_lints/src/transmute/mod.rs
@@ -1,6 +1,7 @@
 mod crosspointer_transmute;
 mod transmute_int_to_char;
 mod transmute_ptr_to_ref;
+mod transmute_ref_to_ref;
 mod useless_transmute;
 mod utils;
 mod wrong_transmute;
@@ -370,67 +371,12 @@ impl<'tcx> LateLintPass<'tcx> for Transmute {
                 if triggered {
                     return;
                 }
+                let triggered = transmute_ref_to_ref::check(cx, e, from_ty, to_ty, args, const_context);
+                if triggered {
+                    return;
+                }
 
                 match (&from_ty.kind(), &to_ty.kind()) {
-                    (ty::Ref(_, ty_from, from_mutbl), ty::Ref(_, ty_to, to_mutbl)) => {
-                        if_chain! {
-                            if let (&ty::Slice(slice_ty), &ty::Str) = (&ty_from.kind(), &ty_to.kind());
-                            if let ty::Uint(ty::UintTy::U8) = slice_ty.kind();
-                            if from_mutbl == to_mutbl;
-                            then {
-                                let postfix = if *from_mutbl == Mutability::Mut {
-                                    "_mut"
-                                } else {
-                                    ""
-                                };
-
-                                span_lint_and_sugg(
-                                    cx,
-                                    TRANSMUTE_BYTES_TO_STR,
-                                    e.span,
-                                    &format!("transmute from a `{}` to a `{}`", from_ty, to_ty),
-                                    "consider using",
-                                    format!(
-                                        "std::str::from_utf8{}({}).unwrap()",
-                                        postfix,
-                                        snippet(cx, args[0].span, ".."),
-                                    ),
-                                    Applicability::Unspecified,
-                                );
-                            } else {
-                                if (cx.tcx.erase_regions(from_ty) != cx.tcx.erase_regions(to_ty))
-                                    && !const_context {
-                                    span_lint_and_then(
-                                        cx,
-                                        TRANSMUTE_PTR_TO_PTR,
-                                        e.span,
-                                        "transmute from a reference to a reference",
-                                        |diag| if let Some(arg) = sugg::Sugg::hir_opt(cx, &args[0]) {
-                                            let ty_from_and_mut = ty::TypeAndMut {
-                                                ty: ty_from,
-                                                mutbl: *from_mutbl
-                                            };
-                                            let ty_to_and_mut = ty::TypeAndMut { ty: ty_to, mutbl: *to_mutbl };
-                                            let sugg_paren = arg
-                                                .as_ty(cx.tcx.mk_ptr(ty_from_and_mut))
-                                                .as_ty(cx.tcx.mk_ptr(ty_to_and_mut));
-                                            let sugg = if *to_mutbl == Mutability::Mut {
-                                                sugg_paren.mut_addr_deref()
-                                            } else {
-                                                sugg_paren.addr_deref()
-                                            };
-                                            diag.span_suggestion(
-                                                e.span,
-                                                "try",
-                                                sugg.to_string(),
-                                                Applicability::Unspecified,
-                                            );
-                                        },
-                                    )
-                                }
-                            }
-                        }
-                    },
                     (ty::RawPtr(_), ty::RawPtr(to_ty)) => span_lint_and_then(
                         cx,
                         TRANSMUTE_PTR_TO_PTR,
diff --git a/clippy_lints/src/transmute/transmute_ref_to_ref.rs b/clippy_lints/src/transmute/transmute_ref_to_ref.rs
new file mode 100644
index 00000000000..a9e3385664b
--- /dev/null
+++ b/clippy_lints/src/transmute/transmute_ref_to_ref.rs
@@ -0,0 +1,89 @@
+use super::{TRANSMUTE_BYTES_TO_STR, TRANSMUTE_PTR_TO_PTR};
+use crate::utils::{snippet, span_lint_and_sugg, span_lint_and_then, sugg};
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, Mutability};
+use rustc_lint::LateContext;
+use rustc_middle::ty;
+use rustc_middle::ty::Ty;
+
+/// Checks for `transmute_bytes_to_str` and `transmute_ptr_to_ptr` lints.
+/// Returns `true` if either one triggered, otherwise returns `false`.
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    e: &'tcx Expr<'_>,
+    from_ty: Ty<'tcx>,
+    to_ty: Ty<'tcx>,
+    args: &'tcx [Expr<'_>],
+    const_context: bool,
+) -> bool {
+    let mut triggered = false;
+
+    match (&from_ty.kind(), &to_ty.kind()) {
+        (ty::Ref(_, ty_from, from_mutbl), ty::Ref(_, ty_to, to_mutbl)) => {
+            if_chain! {
+                if let (&ty::Slice(slice_ty), &ty::Str) = (&ty_from.kind(), &ty_to.kind());
+                if let ty::Uint(ty::UintTy::U8) = slice_ty.kind();
+                if from_mutbl == to_mutbl;
+                then {
+                    let postfix = if *from_mutbl == Mutability::Mut {
+                        "_mut"
+                    } else {
+                        ""
+                    };
+
+                    span_lint_and_sugg(
+                        cx,
+                        TRANSMUTE_BYTES_TO_STR,
+                        e.span,
+                        &format!("transmute from a `{}` to a `{}`", from_ty, to_ty),
+                        "consider using",
+                        format!(
+                            "std::str::from_utf8{}({}).unwrap()",
+                            postfix,
+                            snippet(cx, args[0].span, ".."),
+                        ),
+                        Applicability::Unspecified,
+                    );
+                    triggered = true;
+                } else {
+                    if (cx.tcx.erase_regions(from_ty) != cx.tcx.erase_regions(to_ty))
+                        && !const_context {
+                        span_lint_and_then(
+                            cx,
+                            TRANSMUTE_PTR_TO_PTR,
+                            e.span,
+                            "transmute from a reference to a reference",
+                            |diag| if let Some(arg) = sugg::Sugg::hir_opt(cx, &args[0]) {
+                                let ty_from_and_mut = ty::TypeAndMut {
+                                    ty: ty_from,
+                                    mutbl: *from_mutbl
+                                };
+                                let ty_to_and_mut = ty::TypeAndMut { ty: ty_to, mutbl: *to_mutbl };
+                                let sugg_paren = arg
+                                    .as_ty(cx.tcx.mk_ptr(ty_from_and_mut))
+                                    .as_ty(cx.tcx.mk_ptr(ty_to_and_mut));
+                                let sugg = if *to_mutbl == Mutability::Mut {
+                                    sugg_paren.mut_addr_deref()
+                                } else {
+                                    sugg_paren.addr_deref()
+                                };
+                                diag.span_suggestion(
+                                    e.span,
+                                    "try",
+                                    sugg.to_string(),
+                                    Applicability::Unspecified,
+                                );
+                            },
+                        );
+
+                        triggered = true;
+                    }
+                }
+            }
+        },
+        _ => {},
+    }
+
+    triggered
+}
-- 
cgit 1.4.1-3-g733a5


From f8bc0e249c532ceacc9897ea08f7b97ecba5408e Mon Sep 17 00:00:00 2001
From: Yusuke Tanaka <yusuktan@maguro.dev>
Date: Thu, 11 Feb 2021 00:50:09 +0900
Subject: Move transmute_ptr_to_ptr to its own module

---
 clippy_lints/src/transmute/mod.rs                  | 17 +++-------
 clippy_lints/src/transmute/transmute_ptr_to_ptr.rs | 36 ++++++++++++++++++++++
 2 files changed, 41 insertions(+), 12 deletions(-)
 create mode 100644 clippy_lints/src/transmute/transmute_ptr_to_ptr.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/transmute/mod.rs b/clippy_lints/src/transmute/mod.rs
index 8a0c83789d5..e144c96498b 100644
--- a/clippy_lints/src/transmute/mod.rs
+++ b/clippy_lints/src/transmute/mod.rs
@@ -1,5 +1,6 @@
 mod crosspointer_transmute;
 mod transmute_int_to_char;
+mod transmute_ptr_to_ptr;
 mod transmute_ptr_to_ref;
 mod transmute_ref_to_ref;
 mod useless_transmute;
@@ -375,20 +376,12 @@ impl<'tcx> LateLintPass<'tcx> for Transmute {
                 if triggered {
                     return;
                 }
+                let triggered = transmute_ptr_to_ptr::check(cx, e, from_ty, to_ty, args);
+                if triggered {
+                    return;
+                }
 
                 match (&from_ty.kind(), &to_ty.kind()) {
-                    (ty::RawPtr(_), ty::RawPtr(to_ty)) => span_lint_and_then(
-                        cx,
-                        TRANSMUTE_PTR_TO_PTR,
-                        e.span,
-                        "transmute from a pointer to a pointer",
-                        |diag| {
-                            if let Some(arg) = sugg::Sugg::hir_opt(cx, &args[0]) {
-                                let sugg = arg.as_ty(cx.tcx.mk_ptr(*to_ty));
-                                diag.span_suggestion(e.span, "try", sugg.to_string(), Applicability::Unspecified);
-                            }
-                        },
-                    ),
                     (ty::Int(ty::IntTy::I8) | ty::Uint(ty::UintTy::U8), ty::Bool) => {
                         span_lint_and_then(
                             cx,
diff --git a/clippy_lints/src/transmute/transmute_ptr_to_ptr.rs b/clippy_lints/src/transmute/transmute_ptr_to_ptr.rs
new file mode 100644
index 00000000000..68668ec30db
--- /dev/null
+++ b/clippy_lints/src/transmute/transmute_ptr_to_ptr.rs
@@ -0,0 +1,36 @@
+use super::TRANSMUTE_PTR_TO_PTR;
+use crate::utils::{span_lint_and_then, sugg};
+use rustc_errors::Applicability;
+use rustc_hir::Expr;
+use rustc_lint::LateContext;
+use rustc_middle::ty;
+use rustc_middle::ty::Ty;
+
+/// Checks for `transmute_ptr_to_ptr` lint.
+/// Returns `true` if it's triggered, otherwise returns `false`.
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    e: &'tcx Expr<'_>,
+    from_ty: Ty<'tcx>,
+    to_ty: Ty<'tcx>,
+    args: &'tcx [Expr<'_>],
+) -> bool {
+    match (&from_ty.kind(), &to_ty.kind()) {
+        (ty::RawPtr(_), ty::RawPtr(to_ty)) => {
+            span_lint_and_then(
+                cx,
+                TRANSMUTE_PTR_TO_PTR,
+                e.span,
+                "transmute from a pointer to a pointer",
+                |diag| {
+                    if let Some(arg) = sugg::Sugg::hir_opt(cx, &args[0]) {
+                        let sugg = arg.as_ty(cx.tcx.mk_ptr(*to_ty));
+                        diag.span_suggestion(e.span, "try", sugg.to_string(), Applicability::Unspecified);
+                    }
+                },
+            );
+            true
+        },
+        _ => false,
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From d04ea41d1fbf8c60115bf0746fd9756ff17183c2 Mon Sep 17 00:00:00 2001
From: Yusuke Tanaka <yusuktan@maguro.dev>
Date: Thu, 11 Feb 2021 00:55:32 +0900
Subject: Move transmute_int_to_bool to its own module

---
 clippy_lints/src/transmute/mod.rs                  | 23 +++---------
 .../src/transmute/transmute_int_to_bool.rs         | 42 ++++++++++++++++++++++
 2 files changed, 47 insertions(+), 18 deletions(-)
 create mode 100644 clippy_lints/src/transmute/transmute_int_to_bool.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/transmute/mod.rs b/clippy_lints/src/transmute/mod.rs
index e144c96498b..fa9edc9ae2c 100644
--- a/clippy_lints/src/transmute/mod.rs
+++ b/clippy_lints/src/transmute/mod.rs
@@ -1,4 +1,5 @@
 mod crosspointer_transmute;
+mod transmute_int_to_bool;
 mod transmute_int_to_char;
 mod transmute_ptr_to_ptr;
 mod transmute_ptr_to_ref;
@@ -380,26 +381,12 @@ impl<'tcx> LateLintPass<'tcx> for Transmute {
                 if triggered {
                     return;
                 }
+                let triggered = transmute_int_to_bool::check(cx, e, from_ty, to_ty, args);
+                if triggered {
+                    return;
+                }
 
                 match (&from_ty.kind(), &to_ty.kind()) {
-                    (ty::Int(ty::IntTy::I8) | ty::Uint(ty::UintTy::U8), ty::Bool) => {
-                        span_lint_and_then(
-                            cx,
-                            TRANSMUTE_INT_TO_BOOL,
-                            e.span,
-                            &format!("transmute from a `{}` to a `bool`", from_ty),
-                            |diag| {
-                                let arg = sugg::Sugg::hir(cx, &args[0], "..");
-                                let zero = sugg::Sugg::NonParen(Cow::from("0"));
-                                diag.span_suggestion(
-                                    e.span,
-                                    "consider using",
-                                    sugg::make_binop(ast::BinOpKind::Ne, &arg, &zero).to_string(),
-                                    Applicability::Unspecified,
-                                );
-                            },
-                        )
-                    },
                     (ty::Int(_) | ty::Uint(_), ty::Float(_)) if !const_context => span_lint_and_then(
                         cx,
                         TRANSMUTE_INT_TO_FLOAT,
diff --git a/clippy_lints/src/transmute/transmute_int_to_bool.rs b/clippy_lints/src/transmute/transmute_int_to_bool.rs
new file mode 100644
index 00000000000..c66c7bff232
--- /dev/null
+++ b/clippy_lints/src/transmute/transmute_int_to_bool.rs
@@ -0,0 +1,42 @@
+use super::TRANSMUTE_INT_TO_BOOL;
+use crate::utils::{span_lint_and_then, sugg};
+use rustc_ast as ast;
+use rustc_errors::Applicability;
+use rustc_hir::Expr;
+use rustc_lint::LateContext;
+use rustc_middle::ty;
+use rustc_middle::ty::Ty;
+use std::borrow::Cow;
+
+/// Checks for `transmute_int_to_bool` lint.
+/// Returns `true` if it's triggered, otherwise returns `false`.
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    e: &'tcx Expr<'_>,
+    from_ty: Ty<'tcx>,
+    to_ty: Ty<'tcx>,
+    args: &'tcx [Expr<'_>],
+) -> bool {
+    match (&from_ty.kind(), &to_ty.kind()) {
+        (ty::Int(ty::IntTy::I8) | ty::Uint(ty::UintTy::U8), ty::Bool) => {
+            span_lint_and_then(
+                cx,
+                TRANSMUTE_INT_TO_BOOL,
+                e.span,
+                &format!("transmute from a `{}` to a `bool`", from_ty),
+                |diag| {
+                    let arg = sugg::Sugg::hir(cx, &args[0], "..");
+                    let zero = sugg::Sugg::NonParen(Cow::from("0"));
+                    diag.span_suggestion(
+                        e.span,
+                        "consider using",
+                        sugg::make_binop(ast::BinOpKind::Ne, &arg, &zero).to_string(),
+                        Applicability::Unspecified,
+                    );
+                },
+            );
+            true
+        },
+        _ => false,
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From acedc7b8f261e97ea544b7d43a053312e55e6ebf Mon Sep 17 00:00:00 2001
From: Yusuke Tanaka <yusuktan@maguro.dev>
Date: Thu, 11 Feb 2021 01:03:08 +0900
Subject: Move transmute_int_to_float to its own module

---
 clippy_lints/src/transmute/mod.rs                  | 28 +++----------
 .../src/transmute/transmute_int_to_float.rs        | 48 ++++++++++++++++++++++
 2 files changed, 53 insertions(+), 23 deletions(-)
 create mode 100644 clippy_lints/src/transmute/transmute_int_to_float.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/transmute/mod.rs b/clippy_lints/src/transmute/mod.rs
index fa9edc9ae2c..6e1207abd52 100644
--- a/clippy_lints/src/transmute/mod.rs
+++ b/clippy_lints/src/transmute/mod.rs
@@ -1,6 +1,7 @@
 mod crosspointer_transmute;
 mod transmute_int_to_bool;
 mod transmute_int_to_char;
+mod transmute_int_to_float;
 mod transmute_ptr_to_ptr;
 mod transmute_ptr_to_ref;
 mod transmute_ref_to_ref;
@@ -385,31 +386,12 @@ impl<'tcx> LateLintPass<'tcx> for Transmute {
                 if triggered {
                     return;
                 }
+                let triggered = transmute_int_to_float::check(cx, e, from_ty, to_ty, args, const_context);
+                if triggered {
+                    return;
+                }
 
                 match (&from_ty.kind(), &to_ty.kind()) {
-                    (ty::Int(_) | ty::Uint(_), ty::Float(_)) if !const_context => span_lint_and_then(
-                        cx,
-                        TRANSMUTE_INT_TO_FLOAT,
-                        e.span,
-                        &format!("transmute from a `{}` to a `{}`", from_ty, to_ty),
-                        |diag| {
-                            let arg = sugg::Sugg::hir(cx, &args[0], "..");
-                            let arg = if let ty::Int(int_ty) = from_ty.kind() {
-                                arg.as_ty(format!(
-                                    "u{}",
-                                    int_ty.bit_width().map_or_else(|| "size".to_string(), |v| v.to_string())
-                                ))
-                            } else {
-                                arg
-                            };
-                            diag.span_suggestion(
-                                e.span,
-                                "consider using",
-                                format!("{}::from_bits({})", to_ty, arg.to_string()),
-                                Applicability::Unspecified,
-                            );
-                        },
-                    ),
                     (ty::Float(float_ty), ty::Int(_) | ty::Uint(_)) if !const_context => span_lint_and_then(
                         cx,
                         TRANSMUTE_FLOAT_TO_INT,
diff --git a/clippy_lints/src/transmute/transmute_int_to_float.rs b/clippy_lints/src/transmute/transmute_int_to_float.rs
new file mode 100644
index 00000000000..564a27df562
--- /dev/null
+++ b/clippy_lints/src/transmute/transmute_int_to_float.rs
@@ -0,0 +1,48 @@
+use super::TRANSMUTE_INT_TO_FLOAT;
+use crate::utils::{span_lint_and_then, sugg};
+use rustc_errors::Applicability;
+use rustc_hir::Expr;
+use rustc_lint::LateContext;
+use rustc_middle::ty;
+use rustc_middle::ty::Ty;
+
+/// Checks for `transmute_int_to_float` lint.
+/// Returns `true` if it's triggered, otherwise returns `false`.
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    e: &'tcx Expr<'_>,
+    from_ty: Ty<'tcx>,
+    to_ty: Ty<'tcx>,
+    args: &'tcx [Expr<'_>],
+    const_context: bool,
+) -> bool {
+    match (&from_ty.kind(), &to_ty.kind()) {
+        (ty::Int(_) | ty::Uint(_), ty::Float(_)) if !const_context => {
+            span_lint_and_then(
+                cx,
+                TRANSMUTE_INT_TO_FLOAT,
+                e.span,
+                &format!("transmute from a `{}` to a `{}`", from_ty, to_ty),
+                |diag| {
+                    let arg = sugg::Sugg::hir(cx, &args[0], "..");
+                    let arg = if let ty::Int(int_ty) = from_ty.kind() {
+                        arg.as_ty(format!(
+                            "u{}",
+                            int_ty.bit_width().map_or_else(|| "size".to_string(), |v| v.to_string())
+                        ))
+                    } else {
+                        arg
+                    };
+                    diag.span_suggestion(
+                        e.span,
+                        "consider using",
+                        format!("{}::from_bits({})", to_ty, arg.to_string()),
+                        Applicability::Unspecified,
+                    );
+                },
+            );
+            true
+        },
+        _ => false,
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From e7d2393d0182f9837897723e1541c0404bdcd55b Mon Sep 17 00:00:00 2001
From: Yusuke Tanaka <yusuktan@maguro.dev>
Date: Thu, 11 Feb 2021 01:08:48 +0900
Subject: Move transmute_float_to_int to its own module

---
 clippy_lints/src/transmute/mod.rs                  | 49 ++--------------
 .../src/transmute/transmute_float_to_int.rs        | 66 ++++++++++++++++++++++
 2 files changed, 71 insertions(+), 44 deletions(-)
 create mode 100644 clippy_lints/src/transmute/transmute_float_to_int.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/transmute/mod.rs b/clippy_lints/src/transmute/mod.rs
index 6e1207abd52..3ba0872393d 100644
--- a/clippy_lints/src/transmute/mod.rs
+++ b/clippy_lints/src/transmute/mod.rs
@@ -1,4 +1,5 @@
 mod crosspointer_transmute;
+mod transmute_float_to_int;
 mod transmute_int_to_bool;
 mod transmute_int_to_char;
 mod transmute_int_to_float;
@@ -390,52 +391,12 @@ impl<'tcx> LateLintPass<'tcx> for Transmute {
                 if triggered {
                     return;
                 }
+                let triggered = transmute_float_to_int::check(cx, e, from_ty, to_ty, args, const_context);
+                if triggered {
+                    return;
+                }
 
                 match (&from_ty.kind(), &to_ty.kind()) {
-                    (ty::Float(float_ty), ty::Int(_) | ty::Uint(_)) if !const_context => span_lint_and_then(
-                        cx,
-                        TRANSMUTE_FLOAT_TO_INT,
-                        e.span,
-                        &format!("transmute from a `{}` to a `{}`", from_ty, to_ty),
-                        |diag| {
-                            let mut expr = &args[0];
-                            let mut arg = sugg::Sugg::hir(cx, expr, "..");
-
-                            if let ExprKind::Unary(UnOp::Neg, inner_expr) = &expr.kind {
-                                expr = &inner_expr;
-                            }
-
-                            if_chain! {
-                                // if the expression is a float literal and it is unsuffixed then
-                                // add a suffix so the suggestion is valid and unambiguous
-                                let op = format!("{}{}", arg, float_ty.name_str()).into();
-                                if let ExprKind::Lit(lit) = &expr.kind;
-                                if let ast::LitKind::Float(_, ast::LitFloatType::Unsuffixed) = lit.node;
-                                then {
-                                    match arg {
-                                        sugg::Sugg::MaybeParen(_) => arg = sugg::Sugg::MaybeParen(op),
-                                        _ => arg = sugg::Sugg::NonParen(op)
-                                    }
-                                }
-                            }
-
-                            arg = sugg::Sugg::NonParen(format!("{}.to_bits()", arg.maybe_par()).into());
-
-                            // cast the result of `to_bits` if `to_ty` is signed
-                            arg = if let ty::Int(int_ty) = to_ty.kind() {
-                                arg.as_ty(int_ty.name_str().to_string())
-                            } else {
-                                arg
-                            };
-
-                            diag.span_suggestion(
-                                e.span,
-                                "consider using",
-                                arg.to_string(),
-                                Applicability::Unspecified,
-                            );
-                        },
-                    ),
                     (ty::Adt(from_adt, from_substs), ty::Adt(to_adt, to_substs)) => {
                         if from_adt.did != to_adt.did ||
                                 !COLLECTIONS.iter().any(|path| match_def_path(cx, to_adt.did, path)) {
diff --git a/clippy_lints/src/transmute/transmute_float_to_int.rs b/clippy_lints/src/transmute/transmute_float_to_int.rs
new file mode 100644
index 00000000000..58cd0e21792
--- /dev/null
+++ b/clippy_lints/src/transmute/transmute_float_to_int.rs
@@ -0,0 +1,66 @@
+use super::TRANSMUTE_FLOAT_TO_INT;
+use crate::utils::{span_lint_and_then, sugg};
+use if_chain::if_chain;
+use rustc_ast as ast;
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind, UnOp};
+use rustc_lint::LateContext;
+use rustc_middle::ty;
+use rustc_middle::ty::Ty;
+
+/// Checks for `transmute_float_to_int` lint.
+/// Returns `true` if it's triggered, otherwise returns `false`.
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    e: &'tcx Expr<'_>,
+    from_ty: Ty<'tcx>,
+    to_ty: Ty<'tcx>,
+    args: &'tcx [Expr<'_>],
+    const_context: bool,
+) -> bool {
+    match (&from_ty.kind(), &to_ty.kind()) {
+        (ty::Float(float_ty), ty::Int(_) | ty::Uint(_)) if !const_context => {
+            span_lint_and_then(
+                cx,
+                TRANSMUTE_FLOAT_TO_INT,
+                e.span,
+                &format!("transmute from a `{}` to a `{}`", from_ty, to_ty),
+                |diag| {
+                    let mut expr = &args[0];
+                    let mut arg = sugg::Sugg::hir(cx, expr, "..");
+
+                    if let ExprKind::Unary(UnOp::Neg, inner_expr) = &expr.kind {
+                        expr = &inner_expr;
+                    }
+
+                    if_chain! {
+                        // if the expression is a float literal and it is unsuffixed then
+                        // add a suffix so the suggestion is valid and unambiguous
+                        let op = format!("{}{}", arg, float_ty.name_str()).into();
+                        if let ExprKind::Lit(lit) = &expr.kind;
+                        if let ast::LitKind::Float(_, ast::LitFloatType::Unsuffixed) = lit.node;
+                        then {
+                            match arg {
+                                sugg::Sugg::MaybeParen(_) => arg = sugg::Sugg::MaybeParen(op),
+                                _ => arg = sugg::Sugg::NonParen(op)
+                            }
+                        }
+                    }
+
+                    arg = sugg::Sugg::NonParen(format!("{}.to_bits()", arg.maybe_par()).into());
+
+                    // cast the result of `to_bits` if `to_ty` is signed
+                    arg = if let ty::Int(int_ty) = to_ty.kind() {
+                        arg.as_ty(int_ty.name_str().to_string())
+                    } else {
+                        arg
+                    };
+
+                    diag.span_suggestion(e.span, "consider using", arg.to_string(), Applicability::Unspecified);
+                },
+            );
+            true
+        },
+        _ => false,
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From c57a8260f22d4968f8c802ce92593a32e1e27f4c Mon Sep 17 00:00:00 2001
From: Yusuke Tanaka <yusuktan@maguro.dev>
Date: Thu, 11 Feb 2021 01:21:38 +0900
Subject: Move unsound_collection_transmute to its own module

---
 clippy_lints/src/transmute/mod.rs                  | 35 +++-------------
 .../src/transmute/unsound_collection_transmute.rs  | 49 ++++++++++++++++++++++
 2 files changed, 54 insertions(+), 30 deletions(-)
 create mode 100644 clippy_lints/src/transmute/unsound_collection_transmute.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/transmute/mod.rs b/clippy_lints/src/transmute/mod.rs
index 3ba0872393d..8cb4f650057 100644
--- a/clippy_lints/src/transmute/mod.rs
+++ b/clippy_lints/src/transmute/mod.rs
@@ -6,6 +6,7 @@ mod transmute_int_to_float;
 mod transmute_ptr_to_ptr;
 mod transmute_ptr_to_ref;
 mod transmute_ref_to_ref;
+mod unsound_collection_transmute;
 mod useless_transmute;
 mod utils;
 mod wrong_transmute;
@@ -327,17 +328,6 @@ declare_lint_pass!(Transmute => [
     TRANSMUTES_EXPRESSIBLE_AS_PTR_CASTS,
 ]);
 
-// used to check for UNSOUND_COLLECTION_TRANSMUTE
-static COLLECTIONS: &[&[&str]] = &[
-    &paths::VEC,
-    &paths::VEC_DEQUE,
-    &paths::BINARY_HEAP,
-    &paths::BTREESET,
-    &paths::BTREEMAP,
-    &paths::HASHSET,
-    &paths::HASHMAP,
-];
-
 impl<'tcx> LateLintPass<'tcx> for Transmute {
     #[allow(clippy::similar_names, clippy::too_many_lines)]
     fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
@@ -395,27 +385,12 @@ impl<'tcx> LateLintPass<'tcx> for Transmute {
                 if triggered {
                     return;
                 }
+                let triggered = unsound_collection_transmute::check(cx, e, from_ty, to_ty);
+                if triggered {
+                    return;
+                }
 
                 match (&from_ty.kind(), &to_ty.kind()) {
-                    (ty::Adt(from_adt, from_substs), ty::Adt(to_adt, to_substs)) => {
-                        if from_adt.did != to_adt.did ||
-                                !COLLECTIONS.iter().any(|path| match_def_path(cx, to_adt.did, path)) {
-                            return;
-                        }
-                        if from_substs.types().zip(to_substs.types())
-                                              .any(|(from_ty, to_ty)| is_layout_incompatible(cx, from_ty, to_ty)) {
-                            span_lint(
-                                cx,
-                                UNSOUND_COLLECTION_TRANSMUTE,
-                                e.span,
-                                &format!(
-                                    "transmute from `{}` to `{}` with mismatched layout is unsound",
-                                    from_ty,
-                                    to_ty
-                                )
-                            );
-                        }
-                    },
                     (_, _) if can_be_expressed_as_pointer_cast(cx, e, from_ty, to_ty) => span_lint_and_then(
                         cx,
                         TRANSMUTES_EXPRESSIBLE_AS_PTR_CASTS,
diff --git a/clippy_lints/src/transmute/unsound_collection_transmute.rs b/clippy_lints/src/transmute/unsound_collection_transmute.rs
new file mode 100644
index 00000000000..3ce6bcd3ea0
--- /dev/null
+++ b/clippy_lints/src/transmute/unsound_collection_transmute.rs
@@ -0,0 +1,49 @@
+use super::utils::is_layout_incompatible;
+use super::UNSOUND_COLLECTION_TRANSMUTE;
+use crate::utils::{match_def_path, paths, span_lint};
+use rustc_hir::Expr;
+use rustc_lint::LateContext;
+use rustc_middle::ty;
+use rustc_middle::ty::Ty;
+
+// used to check for UNSOUND_COLLECTION_TRANSMUTE
+static COLLECTIONS: &[&[&str]] = &[
+    &paths::VEC,
+    &paths::VEC_DEQUE,
+    &paths::BINARY_HEAP,
+    &paths::BTREESET,
+    &paths::BTREEMAP,
+    &paths::HASHSET,
+    &paths::HASHMAP,
+];
+
+/// Checks for `unsound_collection_transmute` lint.
+/// Returns `true` if it's triggered, otherwise returns `false`.
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>, from_ty: Ty<'tcx>, to_ty: Ty<'tcx>) -> bool {
+    match (&from_ty.kind(), &to_ty.kind()) {
+        (ty::Adt(from_adt, from_substs), ty::Adt(to_adt, to_substs)) => {
+            if from_adt.did != to_adt.did || !COLLECTIONS.iter().any(|path| match_def_path(cx, to_adt.did, path)) {
+                return false;
+            }
+            if from_substs
+                .types()
+                .zip(to_substs.types())
+                .any(|(from_ty, to_ty)| is_layout_incompatible(cx, from_ty, to_ty))
+            {
+                span_lint(
+                    cx,
+                    UNSOUND_COLLECTION_TRANSMUTE,
+                    e.span,
+                    &format!(
+                        "transmute from `{}` to `{}` with mismatched layout is unsound",
+                        from_ty, to_ty
+                    ),
+                );
+                true
+            } else {
+                false
+            }
+        },
+        _ => false,
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 25c221ec92bdf7be29335f4ea830edb9509a8ce9 Mon Sep 17 00:00:00 2001
From: Yusuke Tanaka <yusuktan@maguro.dev>
Date: Thu, 11 Feb 2021 01:27:44 +0900
Subject: Move transmutes_expressible_as_ptr_casts to its own module

---
 clippy_lints/src/transmute/mod.rs                  | 25 +++-----------
 .../transmutes_expressible_as_ptr_casts.rs         | 38 ++++++++++++++++++++++
 2 files changed, 42 insertions(+), 21 deletions(-)
 create mode 100644 clippy_lints/src/transmute/transmutes_expressible_as_ptr_casts.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/transmute/mod.rs b/clippy_lints/src/transmute/mod.rs
index 8cb4f650057..3b010f39c8a 100644
--- a/clippy_lints/src/transmute/mod.rs
+++ b/clippy_lints/src/transmute/mod.rs
@@ -6,6 +6,7 @@ mod transmute_int_to_float;
 mod transmute_ptr_to_ptr;
 mod transmute_ptr_to_ref;
 mod transmute_ref_to_ref;
+mod transmutes_expressible_as_ptr_casts;
 mod unsound_collection_transmute;
 mod useless_transmute;
 mod utils;
@@ -389,27 +390,9 @@ impl<'tcx> LateLintPass<'tcx> for Transmute {
                 if triggered {
                     return;
                 }
-
-                match (&from_ty.kind(), &to_ty.kind()) {
-                    (_, _) if can_be_expressed_as_pointer_cast(cx, e, from_ty, to_ty) => span_lint_and_then(
-                        cx,
-                        TRANSMUTES_EXPRESSIBLE_AS_PTR_CASTS,
-                        e.span,
-                        &format!(
-                            "transmute from `{}` to `{}` which could be expressed as a pointer cast instead",
-                            from_ty,
-                            to_ty
-                        ),
-                        |diag| {
-                            if let Some(arg) = sugg::Sugg::hir_opt(cx, &args[0]) {
-                                let sugg = arg.as_ty(&to_ty.to_string()).to_string();
-                                diag.span_suggestion(e.span, "try", sugg, Applicability::MachineApplicable);
-                            }
-                        }
-                    ),
-                    _ => {
-                        return;
-                    },
+                let triggered = transmutes_expressible_as_ptr_casts::check(cx, e, from_ty, to_ty, args);
+                if triggered {
+                    return;
                 }
             }
         }
diff --git a/clippy_lints/src/transmute/transmutes_expressible_as_ptr_casts.rs b/clippy_lints/src/transmute/transmutes_expressible_as_ptr_casts.rs
new file mode 100644
index 00000000000..dea896622f1
--- /dev/null
+++ b/clippy_lints/src/transmute/transmutes_expressible_as_ptr_casts.rs
@@ -0,0 +1,38 @@
+use super::utils::can_be_expressed_as_pointer_cast;
+use super::TRANSMUTES_EXPRESSIBLE_AS_PTR_CASTS;
+use crate::utils::{span_lint_and_then, sugg};
+use rustc_errors::Applicability;
+use rustc_hir::Expr;
+use rustc_lint::LateContext;
+use rustc_middle::ty::Ty;
+
+/// Checks for `transmutes_expressible_as_ptr_casts` lint.
+/// Returns `true` if it's triggered, otherwise returns `false`.
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    e: &'tcx Expr<'_>,
+    from_ty: Ty<'tcx>,
+    to_ty: Ty<'tcx>,
+    args: &'tcx [Expr<'_>],
+) -> bool {
+    if can_be_expressed_as_pointer_cast(cx, e, from_ty, to_ty) {
+        span_lint_and_then(
+            cx,
+            TRANSMUTES_EXPRESSIBLE_AS_PTR_CASTS,
+            e.span,
+            &format!(
+                "transmute from `{}` to `{}` which could be expressed as a pointer cast instead",
+                from_ty, to_ty
+            ),
+            |diag| {
+                if let Some(arg) = sugg::Sugg::hir_opt(cx, &args[0]) {
+                    let sugg = arg.as_ty(&to_ty.to_string()).to_string();
+                    diag.span_suggestion(e.span, "try", sugg, Applicability::MachineApplicable);
+                }
+            },
+        );
+        true
+    } else {
+        false
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 89ef26a68131d846b07e339e277232ff8737be3e Mon Sep 17 00:00:00 2001
From: Yusuke Tanaka <yusuktan@maguro.dev>
Date: Thu, 11 Feb 2021 01:29:45 +0900
Subject: Cleanup imports

---
 clippy_lints/src/transmute/crosspointer_transmute.rs       |  3 +--
 clippy_lints/src/transmute/mod.rs                          | 12 ++----------
 clippy_lints/src/transmute/transmute_float_to_int.rs       |  3 +--
 clippy_lints/src/transmute/transmute_int_to_bool.rs        |  3 +--
 clippy_lints/src/transmute/transmute_int_to_char.rs        |  3 +--
 clippy_lints/src/transmute/transmute_int_to_float.rs       |  3 +--
 clippy_lints/src/transmute/transmute_ptr_to_ptr.rs         |  3 +--
 clippy_lints/src/transmute/transmute_ptr_to_ref.rs         |  3 +--
 clippy_lints/src/transmute/transmute_ref_to_ref.rs         |  3 +--
 clippy_lints/src/transmute/unsound_collection_transmute.rs |  3 +--
 clippy_lints/src/transmute/useless_transmute.rs            |  3 +--
 clippy_lints/src/transmute/wrong_transmute.rs              |  3 +--
 12 files changed, 13 insertions(+), 32 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/transmute/crosspointer_transmute.rs b/clippy_lints/src/transmute/crosspointer_transmute.rs
index b570bb3a396..ce87defaa94 100644
--- a/clippy_lints/src/transmute/crosspointer_transmute.rs
+++ b/clippy_lints/src/transmute/crosspointer_transmute.rs
@@ -2,8 +2,7 @@ use super::CROSSPOINTER_TRANSMUTE;
 use crate::utils::span_lint;
 use rustc_hir::Expr;
 use rustc_lint::LateContext;
-use rustc_middle::ty;
-use rustc_middle::ty::Ty;
+use rustc_middle::ty::{self, Ty};
 
 /// Checks for `crosspointer_transmute` lint.
 /// Returns `true` if it's triggered, otherwise returns `false`.
diff --git a/clippy_lints/src/transmute/mod.rs b/clippy_lints/src/transmute/mod.rs
index 3b010f39c8a..e16dfa87229 100644
--- a/clippy_lints/src/transmute/mod.rs
+++ b/clippy_lints/src/transmute/mod.rs
@@ -12,19 +12,11 @@ mod useless_transmute;
 mod utils;
 mod wrong_transmute;
 
-use utils::*;
-
-use crate::utils::{
-    in_constant, match_def_path, paths, snippet, span_lint, span_lint_and_sugg, span_lint_and_then, sugg,
-};
+use crate::utils::{in_constant, match_def_path, paths};
 use if_chain::if_chain;
-use rustc_ast as ast;
-use rustc_errors::Applicability;
-use rustc_hir::{Expr, ExprKind, Mutability, UnOp};
+use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use std::borrow::Cow;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for transmutes that can't ever be correct on any
diff --git a/clippy_lints/src/transmute/transmute_float_to_int.rs b/clippy_lints/src/transmute/transmute_float_to_int.rs
index 58cd0e21792..562d880e39a 100644
--- a/clippy_lints/src/transmute/transmute_float_to_int.rs
+++ b/clippy_lints/src/transmute/transmute_float_to_int.rs
@@ -5,8 +5,7 @@ use rustc_ast as ast;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, UnOp};
 use rustc_lint::LateContext;
-use rustc_middle::ty;
-use rustc_middle::ty::Ty;
+use rustc_middle::ty::{self, Ty};
 
 /// Checks for `transmute_float_to_int` lint.
 /// Returns `true` if it's triggered, otherwise returns `false`.
diff --git a/clippy_lints/src/transmute/transmute_int_to_bool.rs b/clippy_lints/src/transmute/transmute_int_to_bool.rs
index c66c7bff232..5b609f906a3 100644
--- a/clippy_lints/src/transmute/transmute_int_to_bool.rs
+++ b/clippy_lints/src/transmute/transmute_int_to_bool.rs
@@ -4,8 +4,7 @@ use rustc_ast as ast;
 use rustc_errors::Applicability;
 use rustc_hir::Expr;
 use rustc_lint::LateContext;
-use rustc_middle::ty;
-use rustc_middle::ty::Ty;
+use rustc_middle::ty::{self, Ty};
 use std::borrow::Cow;
 
 /// Checks for `transmute_int_to_bool` lint.
diff --git a/clippy_lints/src/transmute/transmute_int_to_char.rs b/clippy_lints/src/transmute/transmute_int_to_char.rs
index 179627d9964..48473e0d799 100644
--- a/clippy_lints/src/transmute/transmute_int_to_char.rs
+++ b/clippy_lints/src/transmute/transmute_int_to_char.rs
@@ -4,8 +4,7 @@ use rustc_ast as ast;
 use rustc_errors::Applicability;
 use rustc_hir::Expr;
 use rustc_lint::LateContext;
-use rustc_middle::ty;
-use rustc_middle::ty::Ty;
+use rustc_middle::ty::{self, Ty};
 
 /// Checks for `transmute_int_to_char` lint.
 /// Returns `true` if it's triggered, otherwise returns `false`.
diff --git a/clippy_lints/src/transmute/transmute_int_to_float.rs b/clippy_lints/src/transmute/transmute_int_to_float.rs
index 564a27df562..f83fba8966a 100644
--- a/clippy_lints/src/transmute/transmute_int_to_float.rs
+++ b/clippy_lints/src/transmute/transmute_int_to_float.rs
@@ -3,8 +3,7 @@ use crate::utils::{span_lint_and_then, sugg};
 use rustc_errors::Applicability;
 use rustc_hir::Expr;
 use rustc_lint::LateContext;
-use rustc_middle::ty;
-use rustc_middle::ty::Ty;
+use rustc_middle::ty::{self, Ty};
 
 /// Checks for `transmute_int_to_float` lint.
 /// Returns `true` if it's triggered, otherwise returns `false`.
diff --git a/clippy_lints/src/transmute/transmute_ptr_to_ptr.rs b/clippy_lints/src/transmute/transmute_ptr_to_ptr.rs
index 68668ec30db..f4e60a3020c 100644
--- a/clippy_lints/src/transmute/transmute_ptr_to_ptr.rs
+++ b/clippy_lints/src/transmute/transmute_ptr_to_ptr.rs
@@ -3,8 +3,7 @@ use crate::utils::{span_lint_and_then, sugg};
 use rustc_errors::Applicability;
 use rustc_hir::Expr;
 use rustc_lint::LateContext;
-use rustc_middle::ty;
-use rustc_middle::ty::Ty;
+use rustc_middle::ty::{self, Ty};
 
 /// Checks for `transmute_ptr_to_ptr` lint.
 /// Returns `true` if it's triggered, otherwise returns `false`.
diff --git a/clippy_lints/src/transmute/transmute_ptr_to_ref.rs b/clippy_lints/src/transmute/transmute_ptr_to_ref.rs
index 7be47da35da..a6719b68098 100644
--- a/clippy_lints/src/transmute/transmute_ptr_to_ref.rs
+++ b/clippy_lints/src/transmute/transmute_ptr_to_ref.rs
@@ -4,8 +4,7 @@ use crate::utils::{span_lint_and_then, sugg};
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, Mutability, QPath};
 use rustc_lint::LateContext;
-use rustc_middle::ty;
-use rustc_middle::ty::Ty;
+use rustc_middle::ty::{self, Ty};
 
 /// Checks for `transmute_ptr_to_ref` lint.
 /// Returns `true` if it's triggered, otherwise returns `false`.
diff --git a/clippy_lints/src/transmute/transmute_ref_to_ref.rs b/clippy_lints/src/transmute/transmute_ref_to_ref.rs
index a9e3385664b..ccfcb03e87a 100644
--- a/clippy_lints/src/transmute/transmute_ref_to_ref.rs
+++ b/clippy_lints/src/transmute/transmute_ref_to_ref.rs
@@ -4,8 +4,7 @@ use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, Mutability};
 use rustc_lint::LateContext;
-use rustc_middle::ty;
-use rustc_middle::ty::Ty;
+use rustc_middle::ty::{self, Ty};
 
 /// Checks for `transmute_bytes_to_str` and `transmute_ptr_to_ptr` lints.
 /// Returns `true` if either one triggered, otherwise returns `false`.
diff --git a/clippy_lints/src/transmute/unsound_collection_transmute.rs b/clippy_lints/src/transmute/unsound_collection_transmute.rs
index 3ce6bcd3ea0..503c5e0ff38 100644
--- a/clippy_lints/src/transmute/unsound_collection_transmute.rs
+++ b/clippy_lints/src/transmute/unsound_collection_transmute.rs
@@ -3,8 +3,7 @@ use super::UNSOUND_COLLECTION_TRANSMUTE;
 use crate::utils::{match_def_path, paths, span_lint};
 use rustc_hir::Expr;
 use rustc_lint::LateContext;
-use rustc_middle::ty;
-use rustc_middle::ty::Ty;
+use rustc_middle::ty::{self, Ty};
 
 // used to check for UNSOUND_COLLECTION_TRANSMUTE
 static COLLECTIONS: &[&[&str]] = &[
diff --git a/clippy_lints/src/transmute/useless_transmute.rs b/clippy_lints/src/transmute/useless_transmute.rs
index 86d75fd2ee0..83441514af0 100644
--- a/clippy_lints/src/transmute/useless_transmute.rs
+++ b/clippy_lints/src/transmute/useless_transmute.rs
@@ -3,8 +3,7 @@ use crate::utils::{span_lint, span_lint_and_then, sugg};
 use rustc_errors::Applicability;
 use rustc_hir::Expr;
 use rustc_lint::LateContext;
-use rustc_middle::ty;
-use rustc_middle::ty::Ty;
+use rustc_middle::ty::{self, Ty};
 
 /// Checks for `useless_transmute` lint.
 /// Returns `true` if it's triggered, otherwise returns `false`.
diff --git a/clippy_lints/src/transmute/wrong_transmute.rs b/clippy_lints/src/transmute/wrong_transmute.rs
index d2d3f0a9c89..d6d77f2c834 100644
--- a/clippy_lints/src/transmute/wrong_transmute.rs
+++ b/clippy_lints/src/transmute/wrong_transmute.rs
@@ -2,8 +2,7 @@ use super::WRONG_TRANSMUTE;
 use crate::utils::span_lint;
 use rustc_hir::Expr;
 use rustc_lint::LateContext;
-use rustc_middle::ty;
-use rustc_middle::ty::Ty;
+use rustc_middle::ty::{self, Ty};
 
 /// Checks for `wrong_transmute` lint.
 /// Returns `true` if it's triggered, otherwise returns `false`.
-- 
cgit 1.4.1-3-g733a5


From 8a8f7b4cf5c7642e72b0c0e40586a9310b1ca48b Mon Sep 17 00:00:00 2001
From: Yusuke Tanaka <yusuktan@maguro.dev>
Date: Thu, 11 Feb 2021 01:41:52 +0900
Subject: Refactor calls to lint check functions

---
 clippy_lints/src/transmute/mod.rs | 61 ++++++++++-----------------------------
 1 file changed, 16 insertions(+), 45 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/transmute/mod.rs b/clippy_lints/src/transmute/mod.rs
index e16dfa87229..c1870f5208b 100644
--- a/clippy_lints/src/transmute/mod.rs
+++ b/clippy_lints/src/transmute/mod.rs
@@ -338,53 +338,24 @@ impl<'tcx> LateLintPass<'tcx> for Transmute {
                 let from_ty = cx.typeck_results().expr_ty(&args[0]);
                 let to_ty = cx.typeck_results().expr_ty(e);
 
-                let triggered = useless_transmute::check(cx, e, from_ty, to_ty, args);
-                if triggered {
+                // If useless_transmute is triggered, the other lints can be skipped.
+                if useless_transmute::check(cx, e, from_ty, to_ty, args) {
                     return;
                 }
-                let triggered = wrong_transmute::check(cx, e, from_ty, to_ty);
-                if triggered {
-                    return;
-                }
-                let triggered = crosspointer_transmute::check(cx, e, from_ty, to_ty);
-                if triggered {
-                    return;
-                }
-                let triggered = transmute_ptr_to_ref::check(cx, e, from_ty, to_ty, args, qpath);
-                if triggered {
-                    return;
-                }
-                let triggered = transmute_int_to_char::check(cx, e, from_ty, to_ty, args);
-                if triggered {
-                    return;
-                }
-                let triggered = transmute_ref_to_ref::check(cx, e, from_ty, to_ty, args, const_context);
-                if triggered {
-                    return;
-                }
-                let triggered = transmute_ptr_to_ptr::check(cx, e, from_ty, to_ty, args);
-                if triggered {
-                    return;
-                }
-                let triggered = transmute_int_to_bool::check(cx, e, from_ty, to_ty, args);
-                if triggered {
-                    return;
-                }
-                let triggered = transmute_int_to_float::check(cx, e, from_ty, to_ty, args, const_context);
-                if triggered {
-                    return;
-                }
-                let triggered = transmute_float_to_int::check(cx, e, from_ty, to_ty, args, const_context);
-                if triggered {
-                    return;
-                }
-                let triggered = unsound_collection_transmute::check(cx, e, from_ty, to_ty);
-                if triggered {
-                    return;
-                }
-                let triggered = transmutes_expressible_as_ptr_casts::check(cx, e, from_ty, to_ty, args);
-                if triggered {
-                    return;
+
+                let mut linted = wrong_transmute::check(cx, e, from_ty, to_ty);
+                linted |= crosspointer_transmute::check(cx, e, from_ty, to_ty);
+                linted |= transmute_ptr_to_ref::check(cx, e, from_ty, to_ty, args, qpath);
+                linted |= transmute_int_to_char::check(cx, e, from_ty, to_ty, args);
+                linted |= transmute_ref_to_ref::check(cx, e, from_ty, to_ty, args, const_context);
+                linted |= transmute_ptr_to_ptr::check(cx, e, from_ty, to_ty, args);
+                linted |= transmute_int_to_bool::check(cx, e, from_ty, to_ty, args);
+                linted |= transmute_int_to_float::check(cx, e, from_ty, to_ty, args, const_context);
+                linted |= transmute_float_to_int::check(cx, e, from_ty, to_ty, args, const_context);
+                linted |= unsound_collection_transmute::check(cx, e, from_ty, to_ty);
+
+                if !linted {
+                    transmutes_expressible_as_ptr_casts::check(cx, e, from_ty, to_ty, args);
                 }
             }
         }
-- 
cgit 1.4.1-3-g733a5


From bf000985f50af1e506709ea5d735a35fac13925c Mon Sep 17 00:00:00 2001
From: Yusuke Tanaka <yusuktan@maguro.dev>
Date: Thu, 11 Feb 2021 01:42:12 +0900
Subject: Make check_cast private

---
 clippy_lints/src/transmute/utils.rs | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/transmute/utils.rs b/clippy_lints/src/transmute/utils.rs
index 734a92d50d2..55008d8ec3f 100644
--- a/clippy_lints/src/transmute/utils.rs
+++ b/clippy_lints/src/transmute/utils.rs
@@ -68,12 +68,7 @@ pub(super) fn can_be_expressed_as_pointer_cast<'tcx>(
 /// the cast. In certain cases, including some invalid casts from array references
 /// to pointers, this may cause additional errors to be emitted and/or ICE error
 /// messages. This function will panic if that occurs.
-pub(super) fn check_cast<'tcx>(
-    cx: &LateContext<'tcx>,
-    e: &'tcx Expr<'_>,
-    from_ty: Ty<'tcx>,
-    to_ty: Ty<'tcx>,
-) -> Option<CastKind> {
+fn check_cast<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>, from_ty: Ty<'tcx>, to_ty: Ty<'tcx>) -> Option<CastKind> {
     let hir_id = e.hir_id;
     let local_def_id = hir_id.owner;
 
-- 
cgit 1.4.1-3-g733a5


From 19c886b4076ebf264ef919b1fd78ebb9f193476c Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Tue, 2 Mar 2021 21:09:04 +0900
Subject: Remove "for_loop_arg.rs"

---
 clippy_lints/src/loops/for_loop_arg.rs | 149 ---------------------------------
 1 file changed, 149 deletions(-)
 delete mode 100644 clippy_lints/src/loops/for_loop_arg.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/for_loop_arg.rs b/clippy_lints/src/loops/for_loop_arg.rs
deleted file mode 100644
index b33e7183984..00000000000
--- a/clippy_lints/src/loops/for_loop_arg.rs
+++ /dev/null
@@ -1,149 +0,0 @@
-use crate::utils::{
-    is_type_diagnostic_item, match_trait_method, match_type, paths, snippet, snippet_with_applicability, span_lint,
-    span_lint_and_help, span_lint_and_sugg,
-};
-use rustc_errors::Applicability;
-use rustc_hir::{Expr, ExprKind, Mutability, Pat};
-use rustc_lint::LateContext;
-use rustc_middle::ty::{self, Ty, TyS};
-use rustc_span::symbol::sym;
-
-pub(super) fn check_for_loop_arg(cx: &LateContext<'_>, pat: &Pat<'_>, arg: &Expr<'_>, expr: &Expr<'_>) {
-    let mut next_loop_linted = false; // whether or not ITER_NEXT_LOOP lint was used
-    if let ExprKind::MethodCall(ref method, _, ref args, _) = arg.kind {
-        // just the receiver, no arguments
-        if args.len() == 1 {
-            let method_name = &*method.ident.as_str();
-            // check for looping over x.iter() or x.iter_mut(), could use &x or &mut x
-            if method_name == "iter" || method_name == "iter_mut" {
-                if is_ref_iterable_type(cx, &args[0]) {
-                    lint_iter_method(cx, args, arg, method_name);
-                }
-            } else if method_name == "into_iter" && match_trait_method(cx, arg, &paths::INTO_ITERATOR) {
-                let receiver_ty = cx.typeck_results().expr_ty(&args[0]);
-                let receiver_ty_adjusted = cx.typeck_results().expr_ty_adjusted(&args[0]);
-                if TyS::same_type(receiver_ty, receiver_ty_adjusted) {
-                    let mut applicability = Applicability::MachineApplicable;
-                    let object = snippet_with_applicability(cx, args[0].span, "_", &mut applicability);
-                    span_lint_and_sugg(
-                        cx,
-                        super::EXPLICIT_INTO_ITER_LOOP,
-                        arg.span,
-                        "it is more concise to loop over containers instead of using explicit \
-                         iteration methods",
-                        "to write this more concisely, try",
-                        object.to_string(),
-                        applicability,
-                    );
-                } else {
-                    let ref_receiver_ty = cx.tcx.mk_ref(
-                        cx.tcx.lifetimes.re_erased,
-                        ty::TypeAndMut {
-                            ty: receiver_ty,
-                            mutbl: Mutability::Not,
-                        },
-                    );
-                    if TyS::same_type(receiver_ty_adjusted, ref_receiver_ty) {
-                        lint_iter_method(cx, args, arg, method_name)
-                    }
-                }
-            } else if method_name == "next" && match_trait_method(cx, arg, &paths::ITERATOR) {
-                span_lint(
-                    cx,
-                    super::ITER_NEXT_LOOP,
-                    expr.span,
-                    "you are iterating over `Iterator::next()` which is an Option; this will compile but is \
-                    probably not what you want",
-                );
-                next_loop_linted = true;
-            }
-        }
-    }
-    if !next_loop_linted {
-        check_arg_type(cx, pat, arg);
-    }
-}
-
-/// Checks for `for` loops over `Option`s and `Result`s.
-fn check_arg_type(cx: &LateContext<'_>, pat: &Pat<'_>, arg: &Expr<'_>) {
-    let ty = cx.typeck_results().expr_ty(arg);
-    if is_type_diagnostic_item(cx, ty, sym::option_type) {
-        span_lint_and_help(
-            cx,
-            super::FOR_LOOPS_OVER_FALLIBLES,
-            arg.span,
-            &format!(
-                "for loop over `{0}`, which is an `Option`. This is more readably written as an \
-                `if let` statement",
-                snippet(cx, arg.span, "_")
-            ),
-            None,
-            &format!(
-                "consider replacing `for {0} in {1}` with `if let Some({0}) = {1}`",
-                snippet(cx, pat.span, "_"),
-                snippet(cx, arg.span, "_")
-            ),
-        );
-    } else if is_type_diagnostic_item(cx, ty, sym::result_type) {
-        span_lint_and_help(
-            cx,
-            super::FOR_LOOPS_OVER_FALLIBLES,
-            arg.span,
-            &format!(
-                "for loop over `{0}`, which is a `Result`. This is more readably written as an \
-                `if let` statement",
-                snippet(cx, arg.span, "_")
-            ),
-            None,
-            &format!(
-                "consider replacing `for {0} in {1}` with `if let Ok({0}) = {1}`",
-                snippet(cx, pat.span, "_"),
-                snippet(cx, arg.span, "_")
-            ),
-        );
-    }
-}
-
-fn lint_iter_method(cx: &LateContext<'_>, args: &[Expr<'_>], arg: &Expr<'_>, method_name: &str) {
-    let mut applicability = Applicability::MachineApplicable;
-    let object = snippet_with_applicability(cx, args[0].span, "_", &mut applicability);
-    let muta = if method_name == "iter_mut" { "mut " } else { "" };
-    span_lint_and_sugg(
-        cx,
-        super::EXPLICIT_ITER_LOOP,
-        arg.span,
-        "it is more concise to loop over references to containers instead of using explicit \
-         iteration methods",
-        "to write this more concisely, try",
-        format!("&{}{}", muta, object),
-        applicability,
-    )
-}
-
-/// Returns `true` if the type of expr is one that provides `IntoIterator` impls
-/// for `&T` and `&mut T`, such as `Vec`.
-#[rustfmt::skip]
-fn is_ref_iterable_type(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
-    // no walk_ptrs_ty: calling iter() on a reference can make sense because it
-    // will allow further borrows afterwards
-    let ty = cx.typeck_results().expr_ty(e);
-    is_iterable_array(ty, cx) ||
-    is_type_diagnostic_item(cx, ty, sym::vec_type) ||
-    match_type(cx, ty, &paths::LINKED_LIST) ||
-    is_type_diagnostic_item(cx, ty, sym!(hashmap_type)) ||
-    is_type_diagnostic_item(cx, ty, sym!(hashset_type)) ||
-    is_type_diagnostic_item(cx, ty, sym!(vecdeque_type)) ||
-    match_type(cx, ty, &paths::BINARY_HEAP) ||
-    match_type(cx, ty, &paths::BTREEMAP) ||
-    match_type(cx, ty, &paths::BTREESET)
-}
-
-fn is_iterable_array<'tcx>(ty: Ty<'tcx>, cx: &LateContext<'tcx>) -> bool {
-    // IntoIterator is currently only implemented for array sizes <= 32 in rustc
-    match ty.kind() {
-        ty::Array(_, n) => n
-            .try_eval_usize(cx.tcx, cx.param_env)
-            .map_or(false, |val| (0..=32).contains(&val)),
-        _ => false,
-    }
-}
-- 
cgit 1.4.1-3-g733a5


From 9e4a064f0878215fccaa3bebdfaf4459db984da3 Mon Sep 17 00:00:00 2001
From: Dirkjan Ochtman <dirkjan@ochtman.nl>
Date: Tue, 2 Mar 2021 14:26:23 +0100
Subject: Move naive_bytecount to pedantic

As discussed on Zulip, current best practice is to avoid recommending
external crates. This lint is from before that was enforced. Move it
to the pedantic group to avoid enabling it by default.

https://rust-lang.zulipchat.com/#narrow/stream/257328-clippy/topic/naive_bytecount.20suggesting.20extra.20dependency
---
 clippy_lints/src/bytecount.rs | 2 +-
 clippy_lints/src/lib.rs       | 3 +--
 2 files changed, 2 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/bytecount.rs b/clippy_lints/src/bytecount.rs
index b8828719f62..eb5dc7ceecd 100644
--- a/clippy_lints/src/bytecount.rs
+++ b/clippy_lints/src/bytecount.rs
@@ -28,7 +28,7 @@ declare_clippy_lint! {
     /// &vec.iter().filter(|x| **x == 0u8).count(); // use bytecount::count instead
     /// ```
     pub NAIVE_BYTECOUNT,
-    perf,
+    pedantic,
     "use of naive `<slice>.filter(|&x| x == y).count()` to count byte values"
 }
 
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 1ace4c8a10c..4a19da60c02 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1343,6 +1343,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&await_holding_invalid::AWAIT_HOLDING_LOCK),
         LintId::of(&await_holding_invalid::AWAIT_HOLDING_REFCELL_REF),
         LintId::of(&bit_mask::VERBOSE_BIT_MASK),
+        LintId::of(&bytecount::NAIVE_BYTECOUNT),
         LintId::of(&case_sensitive_file_extension_comparisons::CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS),
         LintId::of(&checked_conversions::CHECKED_CONVERSIONS),
         LintId::of(&copies::SAME_FUNCTIONS_IN_IF_CONDITION),
@@ -1458,7 +1459,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&blocks_in_if_conditions::BLOCKS_IN_IF_CONDITIONS),
         LintId::of(&booleans::LOGIC_BUG),
         LintId::of(&booleans::NONMINIMAL_BOOL),
-        LintId::of(&bytecount::NAIVE_BYTECOUNT),
         LintId::of(&collapsible_if::COLLAPSIBLE_ELSE_IF),
         LintId::of(&collapsible_if::COLLAPSIBLE_IF),
         LintId::of(&collapsible_match::COLLAPSIBLE_MATCH),
@@ -2013,7 +2013,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     ]);
 
     store.register_group(true, "clippy::perf", Some("clippy_perf"), vec![
-        LintId::of(&bytecount::NAIVE_BYTECOUNT),
         LintId::of(&entry::MAP_ENTRY),
         LintId::of(&escape::BOXED_LOCAL),
         LintId::of(&large_const_arrays::LARGE_CONST_ARRAYS),
-- 
cgit 1.4.1-3-g733a5


From 5656510eed663b5d5be6b6df3d033b836da5f759 Mon Sep 17 00:00:00 2001
From: daxpedda <daxpedda@gmail.com>
Date: Wed, 3 Mar 2021 17:32:49 +0100
Subject: Fix false-positive in `use_self`

---
 clippy_lints/src/use_self.rs | 17 +++++++++++------
 tests/ui/use_self.fixed      |  7 +++++++
 tests/ui/use_self.rs         |  7 +++++++
 3 files changed, 25 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/use_self.rs b/clippy_lints/src/use_self.rs
index be7b9e9ff2d..c262ec993b1 100644
--- a/clippy_lints/src/use_self.rs
+++ b/clippy_lints/src/use_self.rs
@@ -262,12 +262,17 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
             // FIXME: this span manipulation should not be necessary
             // @flip1995 found an ast lowering issue in
             // https://github.com/rust-lang/rust/blob/master/src/librustc_ast_lowering/path.rs#l142-l162
-            match cx.tcx.hir().find(cx.tcx.hir().get_parent_node(hir_ty.hir_id)) {
-                Some(Node::Expr(Expr {
-                    kind: ExprKind::Path(QPath::TypeRelative(_, segment)),
-                    ..
-                })) => span_lint_until_last_segment(cx, hir_ty.span, segment),
-                _ => span_lint(cx, hir_ty.span),
+            let hir = cx.tcx.hir();
+            let id = hir.get_parent_node(hir_ty.hir_id);
+
+            if !hir.opt_span(id).map(in_macro).unwrap_or(false) {
+                match hir.find(id) {
+                    Some(Node::Expr(Expr {
+                        kind: ExprKind::Path(QPath::TypeRelative(_, segment)),
+                        ..
+                    })) => span_lint_until_last_segment(cx, hir_ty.span, segment),
+                    _ => span_lint(cx, hir_ty.span),
+                }
             }
         }
     }
diff --git a/tests/ui/use_self.fixed b/tests/ui/use_self.fixed
index 2b22a2ed2d5..a630936e3b1 100644
--- a/tests/ui/use_self.fixed
+++ b/tests/ui/use_self.fixed
@@ -454,3 +454,10 @@ mod nested_paths {
         }
     }
 }
+
+mod issue6818 {
+    #[derive(serde::Deserialize)]
+    struct A {
+        a: i32,
+    }
+}
diff --git a/tests/ui/use_self.rs b/tests/ui/use_self.rs
index 609625abdec..f3e081dd203 100644
--- a/tests/ui/use_self.rs
+++ b/tests/ui/use_self.rs
@@ -454,3 +454,10 @@ mod nested_paths {
         }
     }
 }
+
+mod issue6818 {
+    #[derive(serde::Deserialize)]
+    struct A {
+        a: i32,
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 1d71d9a106e12bd90f0f3be86e43736f89acc975 Mon Sep 17 00:00:00 2001
From: flip1995 <philipp.krones@embecosm.com>
Date: Fri, 5 Mar 2021 11:08:25 +0100
Subject: Fix dogfood errors in clippy_lints

---
 .../src/transmute/transmute_int_to_char.rs         |  42 ++++----
 clippy_lints/src/transmute/transmute_ptr_to_ref.rs |   4 +-
 clippy_lints/src/transmute/transmute_ref_to_ref.rs | 111 ++++++++++-----------
 clippy_lints/src/use_self.rs                       |   2 +-
 4 files changed, 77 insertions(+), 82 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/transmute/transmute_int_to_char.rs b/clippy_lints/src/transmute/transmute_int_to_char.rs
index 48473e0d799..29d2450618a 100644
--- a/clippy_lints/src/transmute/transmute_int_to_char.rs
+++ b/clippy_lints/src/transmute/transmute_int_to_char.rs
@@ -17,28 +17,26 @@ pub(super) fn check<'tcx>(
 ) -> bool {
     match (&from_ty.kind(), &to_ty.kind()) {
         (ty::Int(ty::IntTy::I32) | ty::Uint(ty::UintTy::U32), &ty::Char) => {
-            {
-                span_lint_and_then(
-                    cx,
-                    TRANSMUTE_INT_TO_CHAR,
-                    e.span,
-                    &format!("transmute from a `{}` to a `char`", from_ty),
-                    |diag| {
-                        let arg = sugg::Sugg::hir(cx, &args[0], "..");
-                        let arg = if let ty::Int(_) = from_ty.kind() {
-                            arg.as_ty(ast::UintTy::U32.name_str())
-                        } else {
-                            arg
-                        };
-                        diag.span_suggestion(
-                            e.span,
-                            "consider using",
-                            format!("std::char::from_u32({}).unwrap()", arg.to_string()),
-                            Applicability::Unspecified,
-                        );
-                    },
-                )
-            };
+            span_lint_and_then(
+                cx,
+                TRANSMUTE_INT_TO_CHAR,
+                e.span,
+                &format!("transmute from a `{}` to a `char`", from_ty),
+                |diag| {
+                    let arg = sugg::Sugg::hir(cx, &args[0], "..");
+                    let arg = if let ty::Int(_) = from_ty.kind() {
+                        arg.as_ty(ast::UintTy::U32.name_str())
+                    } else {
+                        arg
+                    };
+                    diag.span_suggestion(
+                        e.span,
+                        "consider using",
+                        format!("std::char::from_u32({}).unwrap()", arg.to_string()),
+                        Applicability::Unspecified,
+                    );
+                },
+            );
             true
         },
         _ => false,
diff --git a/clippy_lints/src/transmute/transmute_ptr_to_ref.rs b/clippy_lints/src/transmute/transmute_ptr_to_ref.rs
index a6719b68098..f5dbbbe33bc 100644
--- a/clippy_lints/src/transmute/transmute_ptr_to_ref.rs
+++ b/clippy_lints/src/transmute/transmute_ptr_to_ref.rs
@@ -17,7 +17,7 @@ pub(super) fn check<'tcx>(
     qpath: &'tcx QPath<'_>,
 ) -> bool {
     match (&from_ty.kind(), &to_ty.kind()) {
-        (ty::RawPtr(from_pty), ty::Ref(_, to_ref_ty, mutbl)) => {
+        (ty::RawPtr(from_ptr_ty), ty::Ref(_, to_ref_ty, mutbl)) => {
             span_lint_and_then(
                 cx,
                 TRANSMUTE_PTR_TO_REF,
@@ -34,7 +34,7 @@ pub(super) fn check<'tcx>(
                         ("&*", "*const")
                     };
 
-                    let arg = if from_pty.ty == *to_ref_ty {
+                    let arg = if from_ptr_ty.ty == *to_ref_ty {
                         arg
                     } else {
                         arg.as_ty(&format!("{} {}", cast, get_type_snippet(cx, qpath, to_ref_ty)))
diff --git a/clippy_lints/src/transmute/transmute_ref_to_ref.rs b/clippy_lints/src/transmute/transmute_ref_to_ref.rs
index ccfcb03e87a..01b00bb0a22 100644
--- a/clippy_lints/src/transmute/transmute_ref_to_ref.rs
+++ b/clippy_lints/src/transmute/transmute_ref_to_ref.rs
@@ -18,70 +18,67 @@ pub(super) fn check<'tcx>(
 ) -> bool {
     let mut triggered = false;
 
-    match (&from_ty.kind(), &to_ty.kind()) {
-        (ty::Ref(_, ty_from, from_mutbl), ty::Ref(_, ty_to, to_mutbl)) => {
-            if_chain! {
-                if let (&ty::Slice(slice_ty), &ty::Str) = (&ty_from.kind(), &ty_to.kind());
-                if let ty::Uint(ty::UintTy::U8) = slice_ty.kind();
-                if from_mutbl == to_mutbl;
-                then {
-                    let postfix = if *from_mutbl == Mutability::Mut {
-                        "_mut"
-                    } else {
-                        ""
-                    };
+    if let (ty::Ref(_, ty_from, from_mutbl), ty::Ref(_, ty_to, to_mutbl)) = (&from_ty.kind(), &to_ty.kind()) {
+        if_chain! {
+            if let (&ty::Slice(slice_ty), &ty::Str) = (&ty_from.kind(), &ty_to.kind());
+            if let ty::Uint(ty::UintTy::U8) = slice_ty.kind();
+            if from_mutbl == to_mutbl;
+            then {
+                let postfix = if *from_mutbl == Mutability::Mut {
+                    "_mut"
+                } else {
+                    ""
+                };
 
-                    span_lint_and_sugg(
+                span_lint_and_sugg(
+                    cx,
+                    TRANSMUTE_BYTES_TO_STR,
+                    e.span,
+                    &format!("transmute from a `{}` to a `{}`", from_ty, to_ty),
+                    "consider using",
+                    format!(
+                        "std::str::from_utf8{}({}).unwrap()",
+                        postfix,
+                        snippet(cx, args[0].span, ".."),
+                    ),
+                    Applicability::Unspecified,
+                );
+                triggered = true;
+            } else {
+                if (cx.tcx.erase_regions(from_ty) != cx.tcx.erase_regions(to_ty))
+                    && !const_context {
+                    span_lint_and_then(
                         cx,
-                        TRANSMUTE_BYTES_TO_STR,
+                        TRANSMUTE_PTR_TO_PTR,
                         e.span,
-                        &format!("transmute from a `{}` to a `{}`", from_ty, to_ty),
-                        "consider using",
-                        format!(
-                            "std::str::from_utf8{}({}).unwrap()",
-                            postfix,
-                            snippet(cx, args[0].span, ".."),
-                        ),
-                        Applicability::Unspecified,
+                        "transmute from a reference to a reference",
+                        |diag| if let Some(arg) = sugg::Sugg::hir_opt(cx, &args[0]) {
+                            let ty_from_and_mut = ty::TypeAndMut {
+                                ty: ty_from,
+                                mutbl: *from_mutbl
+                            };
+                            let ty_to_and_mut = ty::TypeAndMut { ty: ty_to, mutbl: *to_mutbl };
+                            let sugg_paren = arg
+                                .as_ty(cx.tcx.mk_ptr(ty_from_and_mut))
+                                .as_ty(cx.tcx.mk_ptr(ty_to_and_mut));
+                            let sugg = if *to_mutbl == Mutability::Mut {
+                                sugg_paren.mut_addr_deref()
+                            } else {
+                                sugg_paren.addr_deref()
+                            };
+                            diag.span_suggestion(
+                                e.span,
+                                "try",
+                                sugg.to_string(),
+                                Applicability::Unspecified,
+                            );
+                        },
                     );
-                    triggered = true;
-                } else {
-                    if (cx.tcx.erase_regions(from_ty) != cx.tcx.erase_regions(to_ty))
-                        && !const_context {
-                        span_lint_and_then(
-                            cx,
-                            TRANSMUTE_PTR_TO_PTR,
-                            e.span,
-                            "transmute from a reference to a reference",
-                            |diag| if let Some(arg) = sugg::Sugg::hir_opt(cx, &args[0]) {
-                                let ty_from_and_mut = ty::TypeAndMut {
-                                    ty: ty_from,
-                                    mutbl: *from_mutbl
-                                };
-                                let ty_to_and_mut = ty::TypeAndMut { ty: ty_to, mutbl: *to_mutbl };
-                                let sugg_paren = arg
-                                    .as_ty(cx.tcx.mk_ptr(ty_from_and_mut))
-                                    .as_ty(cx.tcx.mk_ptr(ty_to_and_mut));
-                                let sugg = if *to_mutbl == Mutability::Mut {
-                                    sugg_paren.mut_addr_deref()
-                                } else {
-                                    sugg_paren.addr_deref()
-                                };
-                                diag.span_suggestion(
-                                    e.span,
-                                    "try",
-                                    sugg.to_string(),
-                                    Applicability::Unspecified,
-                                );
-                            },
-                        );
 
-                        triggered = true;
-                    }
+                    triggered = true;
                 }
             }
-        },
-        _ => {},
+        }
     }
 
     triggered
diff --git a/clippy_lints/src/use_self.rs b/clippy_lints/src/use_self.rs
index c262ec993b1..f0523cec621 100644
--- a/clippy_lints/src/use_self.rs
+++ b/clippy_lints/src/use_self.rs
@@ -265,7 +265,7 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
             let hir = cx.tcx.hir();
             let id = hir.get_parent_node(hir_ty.hir_id);
 
-            if !hir.opt_span(id).map(in_macro).unwrap_or(false) {
+            if !hir.opt_span(id).map_or(false, in_macro) {
                 match hir.find(id) {
                     Some(Node::Expr(Expr {
                         kind: ExprKind::Path(QPath::TypeRelative(_, segment)),
-- 
cgit 1.4.1-3-g733a5


From 45454f073894d9e211d086d0c5a0c91fa54f67a9 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Fri, 5 Mar 2021 10:13:59 -0600
Subject: Avoid mir in implicit_return

---
 clippy_lints/src/implicit_return.rs | 18 ++++++------------
 1 file changed, 6 insertions(+), 12 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/implicit_return.rs b/clippy_lints/src/implicit_return.rs
index 109d90ff772..b4f814e1dcc 100644
--- a/clippy_lints/src/implicit_return.rs
+++ b/clippy_lints/src/implicit_return.rs
@@ -1,4 +1,4 @@
-use crate::utils::{fn_has_unsatisfiable_preds, match_panic_def_id, snippet_opt, span_lint_and_then};
+use crate::utils::{match_panic_def_id, snippet_opt, span_lint_and_then};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::FnKind;
@@ -133,19 +133,13 @@ impl<'tcx> LateLintPass<'tcx> for ImplicitReturn {
         span: Span,
         _: HirId,
     ) {
-        let def_id = cx.tcx.hir().body_owner_def_id(body.id());
-
-        // Building MIR for `fn`s with unsatisfiable preds results in ICE.
-        if fn_has_unsatisfiable_preds(cx, def_id.to_def_id()) {
+        if span.from_expansion() {
             return;
         }
-
-        let mir = cx.tcx.optimized_mir(def_id.to_def_id());
-
-        // checking return type through MIR, HIR is not able to determine inferred closure return types
-        // make sure it's not a macro
-        if !mir.return_ty().is_unit() && !span.from_expansion() {
-            expr_match(cx, &body.value);
+        let body = cx.tcx.hir().body(body.id());
+        if cx.typeck_results().expr_ty(&body.value).is_unit() {
+            return;
         }
+        expr_match(cx, &body.value);
     }
 }
-- 
cgit 1.4.1-3-g733a5


From ae8ec07d2e4a4b97168bc02e9bbebb50dd695c1e Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Fri, 5 Mar 2021 10:32:15 -0600
Subject: Avoid mir in missing_errors_doc

---
 clippy_lints/src/doc.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/doc.rs b/clippy_lints/src/doc.rs
index 39a202f281c..99c084af1b0 100644
--- a/clippy_lints/src/doc.rs
+++ b/clippy_lints/src/doc.rs
@@ -325,9 +325,9 @@ fn lint_for_missing_headers<'tcx>(
             if_chain! {
                 if let Some(body_id) = body_id;
                 if let Some(future) = cx.tcx.lang_items().future_trait();
-                let def_id = cx.tcx.hir().body_owner_def_id(body_id);
-                let mir = cx.tcx.optimized_mir(def_id.to_def_id());
-                let ret_ty = mir.return_ty();
+                let typeck = cx.tcx.typeck_body(body_id);
+                let body = cx.tcx.hir().body(body_id);
+                let ret_ty = typeck.expr_ty(&body.value);
                 if implements_trait(cx, ret_ty, future, &[]);
                 if let ty::Opaque(_, subs) = ret_ty.kind();
                 if let Some(gen) = subs.types().next();
-- 
cgit 1.4.1-3-g733a5


From 5abd8c599505e637c3ea43605abfbb55da6e6849 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Fri, 5 Mar 2021 10:35:39 -0600
Subject: Use typeck_body

---
 clippy_lints/src/async_yields_async.rs    | 3 +--
 clippy_lints/src/await_holding_invalid.rs | 3 +--
 2 files changed, 2 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/async_yields_async.rs b/clippy_lints/src/async_yields_async.rs
index 88d9d3b5a26..869a5c28d05 100644
--- a/clippy_lints/src/async_yields_async.rs
+++ b/clippy_lints/src/async_yields_async.rs
@@ -50,8 +50,7 @@ impl<'tcx> LateLintPass<'tcx> for AsyncYieldsAsync {
                 let body_id = BodyId {
                     hir_id: body.value.hir_id,
                 };
-                let def_id = cx.tcx.hir().body_owner_def_id(body_id);
-                let typeck_results = cx.tcx.typeck(def_id);
+                let typeck_results = cx.tcx.typeck_body(body_id);
                 let expr_ty = typeck_results.expr_ty(&body.value);
 
                 if implements_trait(cx, expr_ty, future_trait_def_id, &[]) {
diff --git a/clippy_lints/src/await_holding_invalid.rs b/clippy_lints/src/await_holding_invalid.rs
index 112c5bb14e3..14b6a156c62 100644
--- a/clippy_lints/src/await_holding_invalid.rs
+++ b/clippy_lints/src/await_holding_invalid.rs
@@ -97,8 +97,7 @@ impl LateLintPass<'_> for AwaitHolding {
             let body_id = BodyId {
                 hir_id: body.value.hir_id,
             };
-            let def_id = cx.tcx.hir().body_owner_def_id(body_id);
-            let typeck_results = cx.tcx.typeck(def_id);
+            let typeck_results = cx.tcx.typeck_body(body_id);
             check_interior_types(
                 cx,
                 &typeck_results.generator_interior_types.as_ref().skip_binder(),
-- 
cgit 1.4.1-3-g733a5


From a0b7f9b3a09c9dbb3a773b1b584abbf3c6f031c7 Mon Sep 17 00:00:00 2001
From: Mateusz Gacek <96mateusz.gacek@gmail.com>
Date: Fri, 5 Mar 2021 12:11:31 -0800
Subject: useless_format: fix examples in the description

"Good" example was something not acceptable by the useless_format lint.
---
 clippy_lints/src/format.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/format.rs b/clippy_lints/src/format.rs
index 8e41e0e34da..fd6bf19db94 100644
--- a/clippy_lints/src/format.rs
+++ b/clippy_lints/src/format.rs
@@ -28,11 +28,11 @@ declare_clippy_lint! {
     /// ```rust
     ///
     /// // Bad
-    /// # let foo = "foo";
+    /// let foo = "foo";
     /// format!("{}", foo);
     ///
     /// // Good
-    /// format!("foo");
+    /// foo.to_owned();
     /// ```
     pub USELESS_FORMAT,
     complexity,
-- 
cgit 1.4.1-3-g733a5


From a672d335a248034369cd41d4e08e02cf378c0e4b Mon Sep 17 00:00:00 2001
From: Yusuke Tanaka <yusuktan@maguro.dev>
Date: Sun, 7 Mar 2021 02:08:46 +0900
Subject: Implement new lint: if_then_some_else_none

---
 CHANGELOG.md                               |  1 +
 clippy_lints/src/if_then_some_else_none.rs | 88 ++++++++++++++++++++++++++++++
 clippy_lints/src/lib.rs                    |  4 ++
 tests/ui/if_then_some_else_none.rs         | 66 ++++++++++++++++++++++
 tests/ui/if_then_some_else_none.stderr     | 16 ++++++
 5 files changed, 175 insertions(+)
 create mode 100644 clippy_lints/src/if_then_some_else_none.rs
 create mode 100644 tests/ui/if_then_some_else_none.rs
 create mode 100644 tests/ui/if_then_some_else_none.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 41c334c6816..f7916511edf 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2103,6 +2103,7 @@ Released 2018-09-13
 [`if_let_some_result`]: https://rust-lang.github.io/rust-clippy/master/index.html#if_let_some_result
 [`if_not_else`]: https://rust-lang.github.io/rust-clippy/master/index.html#if_not_else
 [`if_same_then_else`]: https://rust-lang.github.io/rust-clippy/master/index.html#if_same_then_else
+[`if_then_some_else_none`]: https://rust-lang.github.io/rust-clippy/master/index.html#if_then_some_else_none
 [`ifs_same_cond`]: https://rust-lang.github.io/rust-clippy/master/index.html#ifs_same_cond
 [`implicit_clone`]: https://rust-lang.github.io/rust-clippy/master/index.html#implicit_clone
 [`implicit_hasher`]: https://rust-lang.github.io/rust-clippy/master/index.html#implicit_hasher
diff --git a/clippy_lints/src/if_then_some_else_none.rs b/clippy_lints/src/if_then_some_else_none.rs
new file mode 100644
index 00000000000..0bd393f8996
--- /dev/null
+++ b/clippy_lints/src/if_then_some_else_none.rs
@@ -0,0 +1,88 @@
+use crate::utils;
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_middle::lint::in_external_macro;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for if-else that could be written to `bool::then`.
+    ///
+    /// **Why is this bad?** Looks a little redundant. Using `bool::then` helps it have less lines of code.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// # let v = vec![0];
+    /// let a = if v.is_empty() {
+    ///     println!("true!");
+    ///     Some(42)
+    /// } else {
+    ///     None
+    /// };
+    /// ```
+    ///
+    /// Could be written:
+    ///
+    /// ```rust
+    /// # let v = vec![0];
+    /// let a = v.is_empty().then(|| {
+    ///     println!("true!");
+    ///     42
+    /// });
+    /// ```
+    pub IF_THEN_SOME_ELSE_NONE,
+    restriction,
+    "Finds if-else that could be written using `bool::then`"
+}
+
+declare_lint_pass!(IfThenSomeElseNone => [IF_THEN_SOME_ELSE_NONE]);
+
+impl LateLintPass<'_> for IfThenSomeElseNone {
+    fn check_expr(&mut self, cx: &LateContext<'_>, expr: &'tcx Expr<'_>) {
+        if in_external_macro(cx.sess(), expr.span) {
+            return;
+        }
+
+        // We only care about the top-most `if` in the chain
+        if utils::parent_node_is_if_expr(expr, cx) {
+            return;
+        }
+
+        if_chain! {
+            if let ExprKind::If(ref cond, ref then, Some(ref els)) = expr.kind;
+            if let ExprKind::Block(ref then_block, _) = then.kind;
+            if let Some(ref then_expr) = then_block.expr;
+            if let ExprKind::Call(ref then_call, [then_arg]) = then_expr.kind;
+            if let ExprKind::Path(ref then_call_qpath) = then_call.kind;
+            if utils::match_qpath(then_call_qpath, &utils::paths::OPTION_SOME);
+            if let ExprKind::Block(ref els_block, _) = els.kind;
+            if els_block.stmts.is_empty();
+            if let Some(ref els_expr) = els_block.expr;
+            if let ExprKind::Path(ref els_call_qpath) = els_expr.kind;
+            if utils::match_qpath(els_call_qpath, &utils::paths::OPTION_NONE);
+            then {
+                let mut applicability = Applicability::MachineApplicable;
+                let cond_snip = utils::snippet_with_applicability(cx, cond.span, "[condition]", &mut applicability);
+                let arg_snip = utils::snippet_with_applicability(cx, then_arg.span, "", &mut applicability);
+                let sugg = format!(
+                    "{}.then(|| {{ /* snippet */ {} }})",
+                    cond_snip,
+                    arg_snip,
+                );
+                utils::span_lint_and_sugg(
+                    cx,
+                    IF_THEN_SOME_ELSE_NONE,
+                    expr.span,
+                    "this could be simplified with `bool::then`",
+                    "try this",
+                    sugg,
+                    applicability,
+                );
+            }
+        }
+    }
+}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 8259fd3c320..9a7dedf416e 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -230,6 +230,7 @@ mod identity_op;
 mod if_let_mutex;
 mod if_let_some_result;
 mod if_not_else;
+mod if_then_some_else_none;
 mod implicit_return;
 mod implicit_saturating_sub;
 mod inconsistent_struct_constructor;
@@ -667,6 +668,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &if_let_mutex::IF_LET_MUTEX,
         &if_let_some_result::IF_LET_SOME_RESULT,
         &if_not_else::IF_NOT_ELSE,
+        &if_then_some_else_none::IF_THEN_SOME_ELSE_NONE,
         &implicit_return::IMPLICIT_RETURN,
         &implicit_saturating_sub::IMPLICIT_SATURATING_SUB,
         &inconsistent_struct_constructor::INCONSISTENT_STRUCT_CONSTRUCTOR,
@@ -1282,6 +1284,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box redundant_slicing::RedundantSlicing);
     store.register_late_pass(|| box from_str_radix_10::FromStrRadix10);
     store.register_late_pass(|| box manual_map::ManualMap);
+    store.register_late_pass(|| box if_then_some_else_none::IfThenSomeElseNone);
 
     store.register_group(true, "clippy::restriction", Some("clippy_restriction"), vec![
         LintId::of(&arithmetic::FLOAT_ARITHMETIC),
@@ -1297,6 +1300,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&exhaustive_items::EXHAUSTIVE_STRUCTS),
         LintId::of(&exit::EXIT),
         LintId::of(&float_literal::LOSSY_FLOAT_LITERAL),
+        LintId::of(&if_then_some_else_none::IF_THEN_SOME_ELSE_NONE),
         LintId::of(&implicit_return::IMPLICIT_RETURN),
         LintId::of(&indexing_slicing::INDEXING_SLICING),
         LintId::of(&inherent_impl::MULTIPLE_INHERENT_IMPL),
diff --git a/tests/ui/if_then_some_else_none.rs b/tests/ui/if_then_some_else_none.rs
new file mode 100644
index 00000000000..b19e2a50010
--- /dev/null
+++ b/tests/ui/if_then_some_else_none.rs
@@ -0,0 +1,66 @@
+#![warn(clippy::if_then_some_else_none)]
+
+fn main() {
+    // Should issue an error.
+    let _ = if foo() {
+        println!("true!");
+        Some("foo")
+    } else {
+        None
+    };
+
+    // Should not issue an error since the `else` block has a statement besides `None`.
+    let _ = if foo() {
+        println!("true!");
+        Some("foo")
+    } else {
+        eprintln!("false...");
+        None
+    };
+
+    // Should not issue an error since there are more than 2 blocks in the if-else chain.
+    let _ = if foo() {
+        println!("foo true!");
+        Some("foo")
+    } else if bar() {
+        println!("bar true!");
+        Some("bar")
+    } else {
+        None
+    };
+
+    let _ = if foo() {
+        println!("foo true!");
+        Some("foo")
+    } else {
+        bar().then(|| {
+            println!("bar true!");
+            "bar"
+        })
+    };
+
+    // Should not issue an error since the `then` block has `None`, not `Some`.
+    let _ = if foo() { None } else { Some("foo is false") };
+
+    // Should not issue an error since the `else` block doesn't use `None` directly.
+    let _ = if foo() { Some("foo is true") } else { into_none() };
+
+    // Should not issue an error since the `then` block doesn't use `Some` directly.
+    let _ = if foo() { into_some("foo") } else { None };
+}
+
+fn foo() -> bool {
+    unimplemented!()
+}
+
+fn bar() -> bool {
+    unimplemented!()
+}
+
+fn into_some<T>(v: T) -> Option<T> {
+    Some(v)
+}
+
+fn into_none<T>() -> Option<T> {
+    None
+}
diff --git a/tests/ui/if_then_some_else_none.stderr b/tests/ui/if_then_some_else_none.stderr
new file mode 100644
index 00000000000..7ad9c4ce79d
--- /dev/null
+++ b/tests/ui/if_then_some_else_none.stderr
@@ -0,0 +1,16 @@
+error: this could be simplified with `bool::then`
+  --> $DIR/if_then_some_else_none.rs:5:13
+   |
+LL |       let _ = if foo() {
+   |  _____________^
+LL | |         println!("true!");
+LL | |         Some("foo")
+LL | |     } else {
+LL | |         None
+LL | |     };
+   | |_____^ help: try this: `foo().then(|| { /* snippet */ "foo" })`
+   |
+   = note: `-D clippy::if-then-some-else-none` implied by `-D warnings`
+
+error: aborting due to previous error
+
-- 
cgit 1.4.1-3-g733a5


From e4ffff9e72f155dfcd1fda6042b725007973835d Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Tue, 2 Mar 2021 13:06:30 -0500
Subject: Use `LanguageItems::require`

---
 clippy_lints/src/lifetimes.rs | 2 +-
 clippy_lints/src/types.rs     | 8 ++++----
 2 files changed, 5 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lifetimes.rs b/clippy_lints/src/lifetimes.rs
index 5fed58b8210..3807d346f68 100644
--- a/clippy_lints/src/lifetimes.rs
+++ b/clippy_lints/src/lifetimes.rs
@@ -360,7 +360,7 @@ impl<'a, 'tcx> Visitor<'tcx> for RefVisitor<'a, 'tcx> {
         let trait_ref = &poly_tref.trait_ref;
         if CLOSURE_TRAIT_BOUNDS
             .iter()
-            .any(|&item| trait_ref.trait_def_id() == self.cx.tcx.lang_items().items()[item as usize])
+            .any(|&item| trait_ref.trait_def_id() == self.cx.tcx.lang_items().require(item).ok())
         {
             let mut sub_visitor = RefVisitor::new(self.cx);
             sub_visitor.visit_trait_ref(trait_ref);
diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs
index d1d9ef7d902..c420be26fc6 100644
--- a/clippy_lints/src/types.rs
+++ b/clippy_lints/src/types.rs
@@ -294,7 +294,7 @@ fn is_ty_param_lang_item(cx: &LateContext<'_>, qpath: &QPath<'tcx>, item: LangIt
     if let TyKind::Path(qpath) = &ty.kind {
         cx.qpath_res(qpath, ty.hir_id)
             .opt_def_id()
-            .and_then(|id| (cx.tcx.lang_items().items()[item as usize] == Some(id)).then(|| ty))
+            .and_then(|id| (cx.tcx.lang_items().require(item) == Ok(id)).then(|| ty))
     } else {
         None
     }
@@ -431,7 +431,7 @@ impl Types {
                             };
                             let inner_span = match get_qpath_generic_tys(qpath).next() {
                                 Some(ty) => ty.span,
-                                _ => return,
+                                None => return,
                             };
                             let mut applicability = Applicability::MachineApplicable;
                             span_lint_and_sugg(
@@ -467,7 +467,7 @@ impl Types {
                             };
                             let inner_span = match get_qpath_generic_tys(qpath).next() {
                                 Some(ty) => ty.span,
-                                _ => return,
+                                None => return,
                             };
                             let mut applicability = Applicability::MachineApplicable;
                             span_lint_and_sugg(
@@ -517,7 +517,7 @@ impl Types {
                             };
                             let inner_span = match get_qpath_generic_tys(qpath).next() {
                                 Some(ty) => ty.span,
-                                _ => return,
+                                None => return,
                             };
                             let mut applicability = Applicability::MachineApplicable;
                             span_lint_and_sugg(
-- 
cgit 1.4.1-3-g733a5


From 47145dec36fbe99960f45ee7065261e2dcfed152 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Fri, 5 Mar 2021 13:01:13 -0500
Subject: `len_without_is_empty` will now consider multiple impl blocks
 `len_without_is_empty` will now consider `#[allow]` on both the `len` method,
 and the type definition

---
 clippy_lints/src/len_zero.rs         | 166 ++++++++++++++++++++++++++---------
 clippy_utils/src/lib.rs              |  21 ++++-
 tests/ui/len_without_is_empty.rs     |  45 ++++++++++
 tests/ui/len_without_is_empty.stderr |  76 +++++++++-------
 4 files changed, 231 insertions(+), 77 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/len_zero.rs b/clippy_lints/src/len_zero.rs
index dab3e0565ca..1e1023b2743 100644
--- a/clippy_lints/src/len_zero.rs
+++ b/clippy_lints/src/len_zero.rs
@@ -1,11 +1,17 @@
-use crate::utils::{get_item_name, snippet_with_applicability, span_lint, span_lint_and_sugg};
+use crate::utils::{
+    get_item_name, get_parent_as_impl, is_allowed, snippet_with_applicability, span_lint, span_lint_and_sugg,
+    span_lint_and_then,
+};
+use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Applicability;
-use rustc_hir::def_id::DefId;
-use rustc_hir::{AssocItemKind, BinOpKind, Expr, ExprKind, Impl, ImplItemRef, Item, ItemKind, TraitItemRef};
+use rustc_hir::{
+    def_id::DefId, AssocItemKind, BinOpKind, Expr, ExprKind, FnRetTy, ImplItem, ImplItemKind, ImplicitSelfKind, Item,
+    ItemKind, Mutability, Node, TraitItemRef, TyKind,
+};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty;
+use rustc_middle::ty::{self, AssocKind, FnSig};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::{Span, Spanned, Symbol};
 
@@ -113,14 +119,38 @@ impl<'tcx> LateLintPass<'tcx> for LenZero {
             return;
         }
 
-        match item.kind {
-            ItemKind::Trait(_, _, _, _, ref trait_items) => check_trait_items(cx, item, trait_items),
-            ItemKind::Impl(Impl {
-                of_trait: None,
-                items: ref impl_items,
-                ..
-            }) => check_impl_items(cx, item, impl_items),
-            _ => (),
+        if let ItemKind::Trait(_, _, _, _, ref trait_items) = item.kind {
+            check_trait_items(cx, item, trait_items);
+        }
+    }
+
+    fn check_impl_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx ImplItem<'_>) {
+        if_chain! {
+            if item.ident.as_str() == "len";
+            if let ImplItemKind::Fn(sig, _) = &item.kind;
+            if sig.decl.implicit_self.has_implicit_self();
+            if cx.access_levels.is_exported(item.hir_id());
+            if matches!(sig.decl.output, FnRetTy::Return(_));
+            if let Some(imp) = get_parent_as_impl(cx.tcx, item.hir_id());
+            if imp.of_trait.is_none();
+            if let TyKind::Path(ty_path) = &imp.self_ty.kind;
+            if let Some(ty_id) = cx.qpath_res(ty_path, imp.self_ty.hir_id).opt_def_id();
+            if let Some(local_id) = ty_id.as_local();
+            let ty_hir_id = cx.tcx.hir().local_def_id_to_hir_id(local_id);
+            if !is_allowed(cx, LEN_WITHOUT_IS_EMPTY, ty_hir_id);
+            then {
+                let (name, kind) = match cx.tcx.hir().find(ty_hir_id) {
+                    Some(Node::ForeignItem(x)) => (x.ident.name, "extern type"),
+                    Some(Node::Item(x)) => match x.kind {
+                        ItemKind::Struct(..) => (x.ident.name, "struct"),
+                        ItemKind::Enum(..) => (x.ident.name, "enum"),
+                        ItemKind::Union(..) => (x.ident.name, "union"),
+                        _ => (x.ident.name, "type"),
+                    }
+                    _ => return,
+                };
+                check_for_is_empty(cx, sig.span, sig.decl.implicit_self, ty_id, name, kind)
+            }
         }
     }
 
@@ -202,40 +232,94 @@ fn check_trait_items(cx: &LateContext<'_>, visited_trait: &Item<'_>, trait_items
     }
 }
 
-fn check_impl_items(cx: &LateContext<'_>, item: &Item<'_>, impl_items: &[ImplItemRef<'_>]) {
-    fn is_named_self(cx: &LateContext<'_>, item: &ImplItemRef<'_>, name: &str) -> bool {
-        item.ident.name.as_str() == name
-            && if let AssocItemKind::Fn { has_self } = item.kind {
-                has_self && cx.tcx.fn_sig(item.id.def_id).inputs().skip_binder().len() == 1
-            } else {
-                false
-            }
+/// Checks if the given signature matches the expectations for `is_empty`
+fn check_is_empty_sig(cx: &LateContext<'_>, sig: FnSig<'_>, self_kind: ImplicitSelfKind) -> bool {
+    match &**sig.inputs_and_output {
+        [arg, res] if *res == cx.tcx.types.bool => {
+            matches!(
+                (arg.kind(), self_kind),
+                (ty::Ref(_, _, Mutability::Not), ImplicitSelfKind::ImmRef)
+                    | (ty::Ref(_, _, Mutability::Mut), ImplicitSelfKind::MutRef)
+            ) || (!arg.is_ref() && matches!(self_kind, ImplicitSelfKind::Imm | ImplicitSelfKind::Mut))
+        },
+        _ => false,
     }
+}
 
-    let is_empty = if let Some(is_empty) = impl_items.iter().find(|i| is_named_self(cx, i, "is_empty")) {
-        if cx.access_levels.is_exported(is_empty.id.hir_id()) {
-            return;
-        }
-        "a private"
-    } else {
-        "no corresponding"
-    };
-
-    if let Some(i) = impl_items.iter().find(|i| is_named_self(cx, i, "len")) {
-        if cx.access_levels.is_exported(i.id.hir_id()) {
-            let ty = cx.tcx.type_of(item.def_id);
+/// Checks if the given type has an `is_empty` method with the appropriate signature.
+fn check_for_is_empty(
+    cx: &LateContext<'_>,
+    span: Span,
+    self_kind: ImplicitSelfKind,
+    impl_ty: DefId,
+    item_name: Symbol,
+    item_kind: &str,
+) {
+    let is_empty = Symbol::intern("is_empty");
+    let is_empty = cx
+        .tcx
+        .inherent_impls(impl_ty)
+        .iter()
+        .flat_map(|&id| cx.tcx.associated_items(id).filter_by_name_unhygienic(is_empty))
+        .find(|item| item.kind == AssocKind::Fn);
 
-            span_lint(
-                cx,
-                LEN_WITHOUT_IS_EMPTY,
-                item.span,
-                &format!(
-                    "item `{}` has a public `len` method but {} `is_empty` method",
-                    ty, is_empty
+    let (msg, is_empty_span, self_kind) = match is_empty {
+        None => (
+            format!(
+                "{} `{}` has a public `len` method, but no `is_empty` method",
+                item_kind,
+                item_name.as_str(),
+            ),
+            None,
+            None,
+        ),
+        Some(is_empty)
+            if !cx
+                .access_levels
+                .is_exported(cx.tcx.hir().local_def_id_to_hir_id(is_empty.def_id.expect_local())) =>
+        {
+            (
+                format!(
+                    "{} `{}` has a public `len` method, but a private `is_empty` method",
+                    item_kind,
+                    item_name.as_str(),
                 ),
-            );
+                Some(cx.tcx.def_span(is_empty.def_id)),
+                None,
+            )
+        },
+        Some(is_empty)
+            if !(is_empty.fn_has_self_parameter
+                && check_is_empty_sig(cx, cx.tcx.fn_sig(is_empty.def_id).skip_binder(), self_kind)) =>
+        {
+            (
+                format!(
+                    "{} `{}` has a public `len` method, but the `is_empty` method has an unexpected signature",
+                    item_kind,
+                    item_name.as_str(),
+                ),
+                Some(cx.tcx.def_span(is_empty.def_id)),
+                Some(self_kind),
+            )
+        },
+        Some(_) => return,
+    };
+
+    span_lint_and_then(cx, LEN_WITHOUT_IS_EMPTY, span, &msg, |db| {
+        if let Some(span) = is_empty_span {
+            db.span_note(span, "`is_empty` defined here");
         }
-    }
+        if let Some(self_kind) = self_kind {
+            db.note(&format!(
+                "expected signature: `({}self) -> bool`",
+                match self_kind {
+                    ImplicitSelfKind::ImmRef => "&",
+                    ImplicitSelfKind::MutRef => "&mut ",
+                    _ => "",
+                }
+            ));
+        }
+    });
 }
 
 fn check_cmp(cx: &LateContext<'_>, span: Span, method: &Expr<'_>, lit: &Expr<'_>, op: &str, compare_to: u32) {
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index daeced6bad4..6582ad71707 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -63,9 +63,9 @@ use rustc_hir::def_id::{DefId, LOCAL_CRATE};
 use rustc_hir::intravisit::{self, NestedVisitorMap, Visitor};
 use rustc_hir::Node;
 use rustc_hir::{
-    def, Arm, Block, Body, Constness, Crate, Expr, ExprKind, FnDecl, GenericArgs, HirId, ImplItem, ImplItemKind, Item,
-    ItemKind, MatchSource, Param, Pat, PatKind, Path, PathSegment, QPath, TraitItem, TraitItemKind, TraitRef, TyKind,
-    Unsafety,
+    def, Arm, Block, Body, Constness, Crate, Expr, ExprKind, FnDecl, GenericArgs, HirId, Impl, ImplItem, ImplItemKind,
+    Item, ItemKind, MatchSource, Param, Pat, PatKind, Path, PathSegment, QPath, TraitItem, TraitItemKind, TraitRef,
+    TyKind, Unsafety,
 };
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::{LateContext, Level, Lint, LintContext};
@@ -1004,6 +1004,21 @@ pub fn get_enclosing_block<'tcx>(cx: &LateContext<'tcx>, hir_id: HirId) -> Optio
     })
 }
 
+/// Gets the parent node if it's an impl block.
+pub fn get_parent_as_impl(tcx: TyCtxt<'_>, id: HirId) -> Option<&Impl<'_>> {
+    let map = tcx.hir();
+    match map.parent_iter(id).next() {
+        Some((
+            _,
+            Node::Item(Item {
+                kind: ItemKind::Impl(imp),
+                ..
+            }),
+        )) => Some(imp),
+        _ => None,
+    }
+}
+
 /// Returns the base type for HIR references and pointers.
 pub fn walk_ptrs_hir_ty<'tcx>(ty: &'tcx hir::Ty<'tcx>) -> &'tcx hir::Ty<'tcx> {
     match ty.kind {
diff --git a/tests/ui/len_without_is_empty.rs b/tests/ui/len_without_is_empty.rs
index b5211318a15..6b3636a482e 100644
--- a/tests/ui/len_without_is_empty.rs
+++ b/tests/ui/len_without_is_empty.rs
@@ -34,6 +34,24 @@ impl PubAllowed {
     }
 }
 
+pub struct PubAllowedFn;
+
+impl PubAllowedFn {
+    #[allow(clippy::len_without_is_empty)]
+    pub fn len(&self) -> isize {
+        1
+    }
+}
+
+#[allow(clippy::len_without_is_empty)]
+pub struct PubAllowedStruct;
+
+impl PubAllowedStruct {
+    pub fn len(&self) -> isize {
+        1
+    }
+}
+
 pub trait PubTraitsToo {
     fn len(&self) -> isize;
 }
@@ -68,6 +86,18 @@ impl HasWrongIsEmpty {
     }
 }
 
+pub struct MismatchedSelf;
+
+impl MismatchedSelf {
+    pub fn len(self) -> isize {
+        1
+    }
+
+    pub fn is_empty(&self) -> bool {
+        false
+    }
+}
+
 struct NotPubOne;
 
 impl NotPubOne {
@@ -142,4 +172,19 @@ pub trait DependsOnFoo: Foo {
     fn len(&mut self) -> usize;
 }
 
+pub struct MultipleImpls;
+
+// issue #1562
+impl MultipleImpls {
+    pub fn len(&self) -> usize {
+        1
+    }
+}
+
+impl MultipleImpls {
+    pub fn is_empty(&self) -> bool {
+        false
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/len_without_is_empty.stderr b/tests/ui/len_without_is_empty.stderr
index d79c300c074..f106506faf4 100644
--- a/tests/ui/len_without_is_empty.stderr
+++ b/tests/ui/len_without_is_empty.stderr
@@ -1,54 +1,64 @@
-error: item `PubOne` has a public `len` method but no corresponding `is_empty` method
-  --> $DIR/len_without_is_empty.rs:6:1
+error: struct `PubOne` has a public `len` method, but no `is_empty` method
+  --> $DIR/len_without_is_empty.rs:7:5
    |
-LL | / impl PubOne {
-LL | |     pub fn len(&self) -> isize {
-LL | |         1
-LL | |     }
-LL | | }
-   | |_^
+LL |     pub fn len(&self) -> isize {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::len-without-is-empty` implied by `-D warnings`
 
 error: trait `PubTraitsToo` has a `len` method but no (possibly inherited) `is_empty` method
-  --> $DIR/len_without_is_empty.rs:37:1
+  --> $DIR/len_without_is_empty.rs:55:1
    |
 LL | / pub trait PubTraitsToo {
 LL | |     fn len(&self) -> isize;
 LL | | }
    | |_^
 
-error: item `HasIsEmpty` has a public `len` method but a private `is_empty` method
-  --> $DIR/len_without_is_empty.rs:49:1
-   |
-LL | / impl HasIsEmpty {
-LL | |     pub fn len(&self) -> isize {
-LL | |         1
-LL | |     }
-...  |
-LL | |     }
-LL | | }
-   | |_^
+error: struct `HasIsEmpty` has a public `len` method, but a private `is_empty` method
+  --> $DIR/len_without_is_empty.rs:68:5
+   |
+LL |     pub fn len(&self) -> isize {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: `is_empty` defined here
+  --> $DIR/len_without_is_empty.rs:72:5
+   |
+LL |     fn is_empty(&self) -> bool {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: item `HasWrongIsEmpty` has a public `len` method but no corresponding `is_empty` method
-  --> $DIR/len_without_is_empty.rs:61:1
-   |
-LL | / impl HasWrongIsEmpty {
-LL | |     pub fn len(&self) -> isize {
-LL | |         1
-LL | |     }
-...  |
-LL | |     }
-LL | | }
-   | |_^
+error: struct `HasWrongIsEmpty` has a public `len` method, but the `is_empty` method has an unexpected signature
+  --> $DIR/len_without_is_empty.rs:80:5
+   |
+LL |     pub fn len(&self) -> isize {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: `is_empty` defined here
+  --> $DIR/len_without_is_empty.rs:84:5
+   |
+LL |     pub fn is_empty(&self, x: u32) -> bool {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   = note: expected signature: `(&self) -> bool`
+
+error: struct `MismatchedSelf` has a public `len` method, but the `is_empty` method has an unexpected signature
+  --> $DIR/len_without_is_empty.rs:92:5
+   |
+LL |     pub fn len(self) -> isize {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: `is_empty` defined here
+  --> $DIR/len_without_is_empty.rs:96:5
+   |
+LL |     pub fn is_empty(&self) -> bool {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   = note: expected signature: `(self) -> bool`
 
 error: trait `DependsOnFoo` has a `len` method but no (possibly inherited) `is_empty` method
-  --> $DIR/len_without_is_empty.rs:141:1
+  --> $DIR/len_without_is_empty.rs:171:1
    |
 LL | / pub trait DependsOnFoo: Foo {
 LL | |     fn len(&mut self) -> usize;
 LL | | }
    | |_^
 
-error: aborting due to 5 previous errors
+error: aborting due to 6 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 3877a410beac040c0cea3dfa5402d7a2da19df40 Mon Sep 17 00:00:00 2001
From: Andrea Nall <anall@andreanall.com>
Date: Fri, 26 Feb 2021 19:10:17 -0600
Subject: migrate paths to newly-added diagnostic items

This gets rid of the following paths:
  * OS_STRING
  * TO_OWNED
  * TO_STRING

Also removes some usages of:
  * PATH_BUF

And the now completely unused `clippy_lints::types::is_ty_param_path`
---
 clippy_lints/src/misc.rs                    | 20 +++++++++++++-------
 clippy_lints/src/path_buf_push_overwrite.rs |  5 +++--
 clippy_lints/src/ptr.rs                     |  2 +-
 clippy_lints/src/redundant_clone.rs         |  8 ++++----
 clippy_lints/src/to_string_in_display.rs    |  6 ++++--
 clippy_lints/src/types.rs                   | 17 ++---------------
 clippy_utils/src/paths.rs                   |  3 ---
 7 files changed, 27 insertions(+), 34 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/misc.rs b/clippy_lints/src/misc.rs
index 12f91d7bf63..b9be1f7e60c 100644
--- a/clippy_lints/src/misc.rs
+++ b/clippy_lints/src/misc.rs
@@ -12,12 +12,13 @@ use rustc_middle::ty::{self, Ty};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::hygiene::DesugaringKind;
 use rustc_span::source_map::{ExpnKind, Span};
+use rustc_span::symbol::sym;
 
 use crate::consts::{constant, Constant};
 use crate::utils::sugg::Sugg;
 use crate::utils::{
-    get_item_name, get_parent_expr, higher, implements_trait, in_constant, is_integer_const, iter_input_pats,
-    last_path_segment, match_qpath, match_trait_method, paths, snippet, snippet_opt, span_lint, span_lint_and_sugg,
+    get_item_name, get_parent_expr, higher, implements_trait, in_constant, is_diagnostic_assoc_item, is_integer_const,
+    iter_input_pats, last_path_segment, match_qpath, snippet, snippet_opt, span_lint, span_lint_and_sugg,
     span_lint_and_then, span_lint_hir_and_then, unsext, SpanlessEq,
 };
 
@@ -554,11 +555,16 @@ fn check_to_owned(cx: &LateContext<'_>, expr: &Expr<'_>, other: &Expr<'_>, left:
 
     let (arg_ty, snip) = match expr.kind {
         ExprKind::MethodCall(.., ref args, _) if args.len() == 1 => {
-            if match_trait_method(cx, expr, &paths::TO_STRING) || match_trait_method(cx, expr, &paths::TO_OWNED) {
-                (cx.typeck_results().expr_ty(&args[0]), snippet(cx, args[0].span, ".."))
-            } else {
-                return;
-            }
+            if_chain!(
+                if let Some(expr_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
+                if is_diagnostic_assoc_item(cx, expr_def_id, sym::ToString)
+                    || is_diagnostic_assoc_item(cx, expr_def_id, sym::ToOwned);
+                then {
+                    (cx.typeck_results().expr_ty(&args[0]), snippet(cx, args[0].span, ".."))
+                } else {
+                    return;
+                }
+            )
         },
         ExprKind::Call(ref path, ref v) if v.len() == 1 => {
             if let ExprKind::Path(ref path) = path.kind {
diff --git a/clippy_lints/src/path_buf_push_overwrite.rs b/clippy_lints/src/path_buf_push_overwrite.rs
index 6eeb031d383..4a7b0ad07aa 100644
--- a/clippy_lints/src/path_buf_push_overwrite.rs
+++ b/clippy_lints/src/path_buf_push_overwrite.rs
@@ -1,10 +1,11 @@
-use crate::utils::{match_type, paths, span_lint_and_sugg};
+use crate::utils::{is_type_diagnostic_item, span_lint_and_sugg};
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::symbol::sym;
 use std::path::{Component, Path};
 
 declare_clippy_lint! {
@@ -46,7 +47,7 @@ impl<'tcx> LateLintPass<'tcx> for PathBufPushOverwrite {
             if let ExprKind::MethodCall(ref path, _, ref args, _) = expr.kind;
             if path.ident.name == sym!(push);
             if args.len() == 2;
-            if match_type(cx, cx.typeck_results().expr_ty(&args[0]).peel_refs(), &paths::PATH_BUF);
+            if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&args[0]).peel_refs(), sym::PathBuf);
             if let Some(get_index_arg) = args.get(1);
             if let ExprKind::Lit(ref lit) = get_index_arg.kind;
             if let LitKind::Str(ref path_lit, _) = lit.node;
diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs
index 5474fdf30bf..6ea2d8b06d8 100644
--- a/clippy_lints/src/ptr.rs
+++ b/clippy_lints/src/ptr.rs
@@ -233,7 +233,7 @@ fn check_fn(cx: &LateContext<'_>, decl: &FnDecl<'_>, fn_id: HirId, opt_body_id:
                         },
                     );
                 }
-            } else if match_type(cx, ty, &paths::PATH_BUF) {
+            } else if is_type_diagnostic_item(cx, ty, sym::PathBuf) {
                 if let Some(spans) = get_spans(cx, opt_body_id, idx, &[("clone", ".to_path_buf()"), ("as_path", "")]) {
                     span_lint_and_then(
                         cx,
diff --git a/clippy_lints/src/redundant_clone.rs b/clippy_lints/src/redundant_clone.rs
index d74ba10ac50..99263bf8b5c 100644
--- a/clippy_lints/src/redundant_clone.rs
+++ b/clippy_lints/src/redundant_clone.rs
@@ -1,6 +1,6 @@
 use crate::utils::{
-    fn_has_unsatisfiable_preds, has_drop, is_copy, is_type_diagnostic_item, match_def_path, match_type, paths,
-    snippet_opt, span_lint_hir, span_lint_hir_and_then, walk_ptrs_ty_depth,
+    fn_has_unsatisfiable_preds, has_drop, is_copy, is_type_diagnostic_item, match_def_path, paths, snippet_opt,
+    span_lint_hir, span_lint_hir_and_then, walk_ptrs_ty_depth,
 };
 use if_chain::if_chain;
 use rustc_data_structures::{fx::FxHashMap, transitive_relation::TransitiveRelation};
@@ -166,8 +166,8 @@ impl<'tcx> LateLintPass<'tcx> for RedundantClone {
                         is_call_with_ref_arg(cx, mir, &pred_terminator.kind);
                     if res == cloned;
                     if cx.tcx.is_diagnostic_item(sym::deref_method, pred_fn_def_id);
-                    if match_type(cx, pred_arg_ty, &paths::PATH_BUF)
-                        || match_type(cx, pred_arg_ty, &paths::OS_STRING);
+                    if is_type_diagnostic_item(cx, pred_arg_ty, sym::PathBuf)
+                        || is_type_diagnostic_item(cx, pred_arg_ty, sym::OsString);
                     then {
                         (pred_arg, res)
                     } else {
diff --git a/clippy_lints/src/to_string_in_display.rs b/clippy_lints/src/to_string_in_display.rs
index fdd105e6246..84ec2aa18ab 100644
--- a/clippy_lints/src/to_string_in_display.rs
+++ b/clippy_lints/src/to_string_in_display.rs
@@ -1,8 +1,9 @@
-use crate::utils::{match_def_path, match_trait_method, path_to_local_id, paths, span_lint};
+use crate::utils::{is_diagnostic_assoc_item, match_def_path, path_to_local_id, paths, span_lint};
 use if_chain::if_chain;
 use rustc_hir::{Expr, ExprKind, HirId, Impl, ImplItem, ImplItemKind, Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::symbol::sym;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for uses of `to_string()` in `Display` traits.
@@ -92,7 +93,8 @@ impl LateLintPass<'_> for ToStringInDisplay {
             if let Some(self_hir_id) = self.self_hir_id;
             if let ExprKind::MethodCall(ref path, _, args, _) = expr.kind;
             if path.ident.name == sym!(to_string);
-            if match_trait_method(cx, expr, &paths::TO_STRING);
+            if let Some(expr_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
+            if is_diagnostic_assoc_item(cx, expr_def_id, sym::ToString);
             if path_to_local_id(&args[0], self_hir_id);
             then {
                 span_lint(
diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs
index c420be26fc6..827c4a2aaf6 100644
--- a/clippy_lints/src/types.rs
+++ b/clippy_lints/src/types.rs
@@ -313,25 +313,12 @@ fn is_ty_param_diagnostic_item(cx: &LateContext<'_>, qpath: &QPath<'tcx>, item:
     }
 }
 
-/// Checks if the first type parameter is a given item.
-fn is_ty_param_path(cx: &LateContext<'_>, qpath: &QPath<'tcx>, path: &[&str]) -> Option<&'tcx hir::Ty<'tcx>> {
-    let ty = get_qpath_generic_tys(qpath).next()?;
-
-    if let TyKind::Path(qpath) = &ty.kind {
-        cx.qpath_res(qpath, ty.hir_id)
-            .opt_def_id()
-            .and_then(|id| match_def_path(cx, id, path).then(|| ty))
-    } else {
-        None
-    }
-}
-
 fn match_buffer_type(cx: &LateContext<'_>, qpath: &QPath<'_>) -> Option<&'static str> {
     if is_ty_param_diagnostic_item(cx, qpath, sym::string_type).is_some() {
         Some("str")
-    } else if is_ty_param_path(cx, qpath, &paths::OS_STRING).is_some() {
+    } else if is_ty_param_diagnostic_item(cx, qpath, sym::OsString).is_some() {
         Some("std::ffi::OsStr")
-    } else if is_ty_param_path(cx, qpath, &paths::PATH_BUF).is_some() {
+    } else if is_ty_param_diagnostic_item(cx, qpath, sym::PathBuf).is_some() {
         Some("std::path::Path")
     } else {
         None
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index 14c38459dde..3e79646da3f 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -84,7 +84,6 @@ pub const OPTION: [&str; 3] = ["core", "option", "Option"];
 pub const OPTION_NONE: [&str; 4] = ["core", "option", "Option", "None"];
 pub const OPTION_SOME: [&str; 4] = ["core", "option", "Option", "Some"];
 pub const ORD: [&str; 3] = ["core", "cmp", "Ord"];
-pub const OS_STRING: [&str; 4] = ["std", "ffi", "os_str", "OsString"];
 pub const OS_STRING_AS_OS_STR: [&str; 5] = ["std", "ffi", "os_str", "OsString", "as_os_str"];
 pub const OS_STR_TO_OS_STRING: [&str; 5] = ["std", "ffi", "os_str", "OsStr", "to_os_string"];
 pub(super) const PANICKING_PANIC: [&str; 3] = ["core", "panicking", "panic"];
@@ -155,9 +154,7 @@ pub const SYMBOL_TO_IDENT_STRING: [&str; 4] = ["rustc_span", "symbol", "Symbol",
 pub const SYM_MODULE: [&str; 3] = ["rustc_span", "symbol", "sym"];
 #[cfg(feature = "internal-lints")]
 pub const SYNTAX_CONTEXT: [&str; 3] = ["rustc_span", "hygiene", "SyntaxContext"];
-pub const TO_OWNED: [&str; 3] = ["alloc", "borrow", "ToOwned"];
 pub const TO_OWNED_METHOD: [&str; 4] = ["alloc", "borrow", "ToOwned", "to_owned"];
-pub const TO_STRING: [&str; 3] = ["alloc", "string", "ToString"];
 pub const TO_STRING_METHOD: [&str; 4] = ["alloc", "string", "ToString", "to_string"];
 pub const TRANSMUTE: [&str; 4] = ["core", "intrinsics", "", "transmute"];
 pub const TRY_FROM: [&str; 4] = ["core", "convert", "TryFrom", "try_from"];
-- 
cgit 1.4.1-3-g733a5


From 9bdc273f038dfa573d8fbd377c063f330922a048 Mon Sep 17 00:00:00 2001
From: Andrea Nall <anall@andreanall.com>
Date: Sun, 7 Mar 2021 17:58:39 -0600
Subject: relocate functions from `clippy_lints::types`

relocate `is_ty_param_lang_item` and `is_ty_param_diagnostic_item` to `clippy_utils`
---
 clippy_lints/src/types.rs | 36 +++++-------------------------------
 clippy_utils/src/lib.rs   | 34 ++++++++++++++++++++++++++++++++--
 2 files changed, 37 insertions(+), 33 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs
index 827c4a2aaf6..ce201b956d8 100644
--- a/clippy_lints/src/types.rs
+++ b/clippy_lints/src/types.rs
@@ -23,7 +23,7 @@ use rustc_semver::RustcVersion;
 use rustc_session::{declare_lint_pass, declare_tool_lint, impl_lint_pass};
 use rustc_span::hygiene::{ExpnKind, MacroKind};
 use rustc_span::source_map::Span;
-use rustc_span::symbol::{sym, Symbol};
+use rustc_span::symbol::sym;
 use rustc_target::abi::LayoutOf;
 use rustc_target::spec::abi::Abi;
 use rustc_typeck::hir_ty_to_ty;
@@ -33,10 +33,10 @@ use crate::utils::paths;
 use crate::utils::sugg::Sugg;
 use crate::utils::{
     clip, comparisons, differing_macro_contexts, get_qpath_generic_tys, higher, in_constant, indent_of, int_bits,
-    is_hir_ty_cfg_dependant, is_type_diagnostic_item, last_path_segment, match_def_path, match_path, meets_msrv,
-    method_chain_args, multispan_sugg, numeric_literal::NumericLiteral, reindent_multiline, sext, snippet, snippet_opt,
-    snippet_with_applicability, snippet_with_macro_callsite, span_lint, span_lint_and_help, span_lint_and_sugg,
-    span_lint_and_then, unsext,
+    is_hir_ty_cfg_dependant, is_ty_param_diagnostic_item, is_ty_param_lang_item, is_type_diagnostic_item,
+    last_path_segment, match_def_path, match_path, meets_msrv, method_chain_args, multispan_sugg,
+    numeric_literal::NumericLiteral, reindent_multiline, sext, snippet, snippet_opt, snippet_with_applicability,
+    snippet_with_macro_callsite, span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then, unsext,
 };
 
 declare_clippy_lint! {
@@ -287,32 +287,6 @@ impl<'tcx> LateLintPass<'tcx> for Types {
     }
 }
 
-/// Checks if the first type parameter is a lang item.
-fn is_ty_param_lang_item(cx: &LateContext<'_>, qpath: &QPath<'tcx>, item: LangItem) -> Option<&'tcx hir::Ty<'tcx>> {
-    let ty = get_qpath_generic_tys(qpath).next()?;
-
-    if let TyKind::Path(qpath) = &ty.kind {
-        cx.qpath_res(qpath, ty.hir_id)
-            .opt_def_id()
-            .and_then(|id| (cx.tcx.lang_items().require(item) == Ok(id)).then(|| ty))
-    } else {
-        None
-    }
-}
-
-/// Checks if the first type parameter is a diagnostic item.
-fn is_ty_param_diagnostic_item(cx: &LateContext<'_>, qpath: &QPath<'tcx>, item: Symbol) -> Option<&'tcx hir::Ty<'tcx>> {
-    let ty = get_qpath_generic_tys(qpath).next()?;
-
-    if let TyKind::Path(qpath) = &ty.kind {
-        cx.qpath_res(qpath, ty.hir_id)
-            .opt_def_id()
-            .and_then(|id| cx.tcx.is_diagnostic_item(item, id).then(|| ty))
-    } else {
-        None
-    }
-}
-
 fn match_buffer_type(cx: &LateContext<'_>, qpath: &QPath<'_>) -> Option<&'static str> {
     if is_ty_param_diagnostic_item(cx, qpath, sym::string_type).is_some() {
         Some("str")
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 6582ad71707..3845667802d 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -64,8 +64,8 @@ use rustc_hir::intravisit::{self, NestedVisitorMap, Visitor};
 use rustc_hir::Node;
 use rustc_hir::{
     def, Arm, Block, Body, Constness, Crate, Expr, ExprKind, FnDecl, GenericArgs, HirId, Impl, ImplItem, ImplItemKind,
-    Item, ItemKind, MatchSource, Param, Pat, PatKind, Path, PathSegment, QPath, TraitItem, TraitItemKind, TraitRef,
-    TyKind, Unsafety,
+    Item, ItemKind, LangItem, MatchSource, Param, Pat, PatKind, Path, PathSegment, QPath, TraitItem, TraitItemKind,
+    TraitRef, TyKind, Unsafety,
 };
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::{LateContext, Level, Lint, LintContext};
@@ -232,6 +232,36 @@ pub fn is_type_lang_item(cx: &LateContext<'_>, ty: Ty<'_>, lang_item: hir::LangI
     }
 }
 
+/// Checks if the first type parameter is a lang item.
+pub fn is_ty_param_lang_item(cx: &LateContext<'_>, qpath: &QPath<'tcx>, item: LangItem) -> Option<&'tcx hir::Ty<'tcx>> {
+    let ty = get_qpath_generic_tys(qpath).next()?;
+
+    if let TyKind::Path(qpath) = &ty.kind {
+        cx.qpath_res(qpath, ty.hir_id)
+            .opt_def_id()
+            .and_then(|id| (cx.tcx.lang_items().require(item) == Ok(id)).then(|| ty))
+    } else {
+        None
+    }
+}
+
+/// Checks if the first type parameter is a diagnostic item.
+pub fn is_ty_param_diagnostic_item(
+    cx: &LateContext<'_>,
+    qpath: &QPath<'tcx>,
+    item: Symbol,
+) -> Option<&'tcx hir::Ty<'tcx>> {
+    let ty = get_qpath_generic_tys(qpath).next()?;
+
+    if let TyKind::Path(qpath) = &ty.kind {
+        cx.qpath_res(qpath, ty.hir_id)
+            .opt_def_id()
+            .and_then(|id| cx.tcx.is_diagnostic_item(item, id).then(|| ty))
+    } else {
+        None
+    }
+}
+
 /// Checks if the method call given in `expr` belongs to the given trait.
 pub fn match_trait_method(cx: &LateContext<'_>, expr: &Expr<'_>, path: &[&str]) -> bool {
     let def_id = cx.typeck_results().type_dependent_def_id(expr.hir_id).unwrap();
-- 
cgit 1.4.1-3-g733a5


From f2a85cb42ae64bc5a82eaee49d92b6f9d93153fe Mon Sep 17 00:00:00 2001
From: Yusuke Tanaka <yusuktan@maguro.dev>
Date: Mon, 8 Mar 2021 22:52:03 +0900
Subject: Set 1.50 as msrv of if_then_some_else_none

---
 clippy_lints/src/if_then_some_else_none.rs | 24 ++++++++++++++++++++++--
 clippy_lints/src/lib.rs                    |  2 +-
 tests/ui/if_then_some_else_none.rs         | 22 ++++++++++++++++++++++
 tests/ui/if_then_some_else_none.stderr     | 16 ++++++++++++++--
 4 files changed, 59 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/if_then_some_else_none.rs b/clippy_lints/src/if_then_some_else_none.rs
index 0bd393f8996..aadadd0d934 100644
--- a/clippy_lints/src/if_then_some_else_none.rs
+++ b/clippy_lints/src/if_then_some_else_none.rs
@@ -4,7 +4,10 @@ use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_semver::RustcVersion;
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+
+const IF_THEN_SOME_ELSE_NONE_MSRV: RustcVersion = RustcVersion::new(1, 50, 0);
 
 declare_clippy_lint! {
     /// **What it does:** Checks for if-else that could be written to `bool::then`.
@@ -39,10 +42,25 @@ declare_clippy_lint! {
     "Finds if-else that could be written using `bool::then`"
 }
 
-declare_lint_pass!(IfThenSomeElseNone => [IF_THEN_SOME_ELSE_NONE]);
+pub struct IfThenSomeElseNone {
+    msrv: Option<RustcVersion>,
+}
+
+impl IfThenSomeElseNone {
+    #[must_use]
+    pub fn new(msrv: Option<RustcVersion>) -> Self {
+        Self { msrv }
+    }
+}
+
+impl_lint_pass!(IfThenSomeElseNone => [IF_THEN_SOME_ELSE_NONE]);
 
 impl LateLintPass<'_> for IfThenSomeElseNone {
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &'tcx Expr<'_>) {
+        if !utils::meets_msrv(self.msrv.as_ref(), &IF_THEN_SOME_ELSE_NONE_MSRV) {
+            return;
+        }
+
         if in_external_macro(cx.sess(), expr.span) {
             return;
         }
@@ -85,4 +103,6 @@ impl LateLintPass<'_> for IfThenSomeElseNone {
             }
         }
     }
+
+    extract_msrv_attr!(LateContext);
 }
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 9a7dedf416e..2e4c1e3bdf8 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1284,7 +1284,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box redundant_slicing::RedundantSlicing);
     store.register_late_pass(|| box from_str_radix_10::FromStrRadix10);
     store.register_late_pass(|| box manual_map::ManualMap);
-    store.register_late_pass(|| box if_then_some_else_none::IfThenSomeElseNone);
+    store.register_late_pass(move || box if_then_some_else_none::IfThenSomeElseNone::new(msrv));
 
     store.register_group(true, "clippy::restriction", Some("clippy_restriction"), vec![
         LintId::of(&arithmetic::FLOAT_ARITHMETIC),
diff --git a/tests/ui/if_then_some_else_none.rs b/tests/ui/if_then_some_else_none.rs
index b19e2a50010..337292fd9b3 100644
--- a/tests/ui/if_then_some_else_none.rs
+++ b/tests/ui/if_then_some_else_none.rs
@@ -1,4 +1,5 @@
 #![warn(clippy::if_then_some_else_none)]
+#![feature(custom_inner_attributes)]
 
 fn main() {
     // Should issue an error.
@@ -49,6 +50,27 @@ fn main() {
     let _ = if foo() { into_some("foo") } else { None };
 }
 
+fn _msrv_1_49() {
+    #![clippy::msrv = "1.49"]
+    // `bool::then` was stabilized in 1.50. Do not lint this
+    let _ = if foo() {
+        println!("true!");
+        Some("foo")
+    } else {
+        None
+    };
+}
+
+fn _msrv_1_50() {
+    #![clippy::msrv = "1.50"]
+    let _ = if foo() {
+        println!("true!");
+        Some("foo")
+    } else {
+        None
+    };
+}
+
 fn foo() -> bool {
     unimplemented!()
 }
diff --git a/tests/ui/if_then_some_else_none.stderr b/tests/ui/if_then_some_else_none.stderr
index 7ad9c4ce79d..19c96f900a3 100644
--- a/tests/ui/if_then_some_else_none.stderr
+++ b/tests/ui/if_then_some_else_none.stderr
@@ -1,5 +1,5 @@
 error: this could be simplified with `bool::then`
-  --> $DIR/if_then_some_else_none.rs:5:13
+  --> $DIR/if_then_some_else_none.rs:6:13
    |
 LL |       let _ = if foo() {
    |  _____________^
@@ -12,5 +12,17 @@ LL | |     };
    |
    = note: `-D clippy::if-then-some-else-none` implied by `-D warnings`
 
-error: aborting due to previous error
+error: this could be simplified with `bool::then`
+  --> $DIR/if_then_some_else_none.rs:66:13
+   |
+LL |       let _ = if foo() {
+   |  _____________^
+LL | |         println!("true!");
+LL | |         Some("foo")
+LL | |     } else {
+LL | |         None
+LL | |     };
+   | |_____^ help: try this: `foo().then(|| { /* snippet */ "foo" })`
+
+error: aborting due to 2 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 0327c2e04106e258949dbf96e58bb582e2960c6b Mon Sep 17 00:00:00 2001
From: Yusuke Tanaka <yusuktan@maguro.dev>
Date: Mon, 8 Mar 2021 23:19:57 +0900
Subject: Output help instead of suggestion in `if_then_some_else_none`
 diagnose

---
 clippy_lints/src/if_then_some_else_none.rs | 17 +++++++----------
 tests/ui/if_then_some_else_none.rs         |  4 ++--
 tests/ui/if_then_some_else_none.stderr     |  9 ++++++---
 3 files changed, 15 insertions(+), 15 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/if_then_some_else_none.rs b/clippy_lints/src/if_then_some_else_none.rs
index aadadd0d934..569a7f06f95 100644
--- a/clippy_lints/src/if_then_some_else_none.rs
+++ b/clippy_lints/src/if_then_some_else_none.rs
@@ -1,6 +1,5 @@
 use crate::utils;
 use if_chain::if_chain;
-use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
@@ -83,22 +82,20 @@ impl LateLintPass<'_> for IfThenSomeElseNone {
             if let ExprKind::Path(ref els_call_qpath) = els_expr.kind;
             if utils::match_qpath(els_call_qpath, &utils::paths::OPTION_NONE);
             then {
-                let mut applicability = Applicability::MachineApplicable;
-                let cond_snip = utils::snippet_with_applicability(cx, cond.span, "[condition]", &mut applicability);
-                let arg_snip = utils::snippet_with_applicability(cx, then_arg.span, "", &mut applicability);
-                let sugg = format!(
-                    "{}.then(|| {{ /* snippet */ {} }})",
+                let cond_snip = utils::snippet(cx, cond.span, "[condition]");
+                let arg_snip = utils::snippet(cx, then_arg.span, "");
+                let help = format!(
+                    "consider using `bool::then` like: `{}.then(|| {{ /* snippet */ {} }})`",
                     cond_snip,
                     arg_snip,
                 );
-                utils::span_lint_and_sugg(
+                utils::span_lint_and_help(
                     cx,
                     IF_THEN_SOME_ELSE_NONE,
                     expr.span,
                     "this could be simplified with `bool::then`",
-                    "try this",
-                    sugg,
-                    applicability,
+                    None,
+                    &help,
                 );
             }
         }
diff --git a/tests/ui/if_then_some_else_none.rs b/tests/ui/if_then_some_else_none.rs
index 337292fd9b3..14a5fe76245 100644
--- a/tests/ui/if_then_some_else_none.rs
+++ b/tests/ui/if_then_some_else_none.rs
@@ -55,7 +55,7 @@ fn _msrv_1_49() {
     // `bool::then` was stabilized in 1.50. Do not lint this
     let _ = if foo() {
         println!("true!");
-        Some("foo")
+        Some(149)
     } else {
         None
     };
@@ -65,7 +65,7 @@ fn _msrv_1_50() {
     #![clippy::msrv = "1.50"]
     let _ = if foo() {
         println!("true!");
-        Some("foo")
+        Some(150)
     } else {
         None
     };
diff --git a/tests/ui/if_then_some_else_none.stderr b/tests/ui/if_then_some_else_none.stderr
index 19c96f900a3..722c52b1cb4 100644
--- a/tests/ui/if_then_some_else_none.stderr
+++ b/tests/ui/if_then_some_else_none.stderr
@@ -8,9 +8,10 @@ LL | |         Some("foo")
 LL | |     } else {
 LL | |         None
 LL | |     };
-   | |_____^ help: try this: `foo().then(|| { /* snippet */ "foo" })`
+   | |_____^
    |
    = note: `-D clippy::if-then-some-else-none` implied by `-D warnings`
+   = help: consider using `bool::then` like: `foo().then(|| { /* snippet */ "foo" })`
 
 error: this could be simplified with `bool::then`
   --> $DIR/if_then_some_else_none.rs:66:13
@@ -18,11 +19,13 @@ error: this could be simplified with `bool::then`
 LL |       let _ = if foo() {
    |  _____________^
 LL | |         println!("true!");
-LL | |         Some("foo")
+LL | |         Some(150)
 LL | |     } else {
 LL | |         None
 LL | |     };
-   | |_____^ help: try this: `foo().then(|| { /* snippet */ "foo" })`
+   | |_____^
+   |
+   = help: consider using `bool::then` like: `foo().then(|| { /* snippet */ 150 })`
 
 error: aborting due to 2 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 714a826439b4e61485e3afdfae8c08924120960a Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Thu, 11 Feb 2021 13:54:35 +0900
Subject: Create types dir and move old module under it

---
 clippy_lints/src/types.rs     | 2952 -----------------------------------------
 clippy_lints/src/types/mod.rs | 2952 +++++++++++++++++++++++++++++++++++++++++
 2 files changed, 2952 insertions(+), 2952 deletions(-)
 delete mode 100644 clippy_lints/src/types.rs
 create mode 100644 clippy_lints/src/types/mod.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs
deleted file mode 100644
index ce201b956d8..00000000000
--- a/clippy_lints/src/types.rs
+++ /dev/null
@@ -1,2952 +0,0 @@
-#![allow(rustc::default_hash_types)]
-
-use std::borrow::Cow;
-use std::cmp::Ordering;
-use std::collections::BTreeMap;
-
-use if_chain::if_chain;
-use rustc_ast::{LitFloatType, LitIntType, LitKind};
-use rustc_errors::{Applicability, DiagnosticBuilder};
-use rustc_hir as hir;
-use rustc_hir::intravisit::{walk_body, walk_expr, walk_ty, FnKind, NestedVisitorMap, Visitor};
-use rustc_hir::{
-    BinOpKind, Block, Body, Expr, ExprKind, FnDecl, FnRetTy, FnSig, GenericArg, GenericBounds, GenericParamKind, HirId,
-    ImplItem, ImplItemKind, Item, ItemKind, LangItem, Lifetime, Lit, Local, MatchSource, MutTy, Mutability, Node,
-    QPath, Stmt, StmtKind, SyntheticTyParamKind, TraitFn, TraitItem, TraitItemKind, TyKind, UnOp,
-};
-use rustc_lint::{LateContext, LateLintPass, LintContext};
-use rustc_middle::hir::map::Map;
-use rustc_middle::lint::in_external_macro;
-use rustc_middle::ty::TypeFoldable;
-use rustc_middle::ty::{self, FloatTy, InferTy, IntTy, Ty, TyCtxt, TyS, TypeAndMut, TypeckResults, UintTy};
-use rustc_semver::RustcVersion;
-use rustc_session::{declare_lint_pass, declare_tool_lint, impl_lint_pass};
-use rustc_span::hygiene::{ExpnKind, MacroKind};
-use rustc_span::source_map::Span;
-use rustc_span::symbol::sym;
-use rustc_target::abi::LayoutOf;
-use rustc_target::spec::abi::Abi;
-use rustc_typeck::hir_ty_to_ty;
-
-use crate::consts::{constant, Constant};
-use crate::utils::paths;
-use crate::utils::sugg::Sugg;
-use crate::utils::{
-    clip, comparisons, differing_macro_contexts, get_qpath_generic_tys, higher, in_constant, indent_of, int_bits,
-    is_hir_ty_cfg_dependant, is_ty_param_diagnostic_item, is_ty_param_lang_item, is_type_diagnostic_item,
-    last_path_segment, match_def_path, match_path, meets_msrv, method_chain_args, multispan_sugg,
-    numeric_literal::NumericLiteral, reindent_multiline, sext, snippet, snippet_opt, snippet_with_applicability,
-    snippet_with_macro_callsite, span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then, unsext,
-};
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for use of `Box<Vec<_>>` anywhere in the code.
-    /// Check the [Box documentation](https://doc.rust-lang.org/std/boxed/index.html) for more information.
-    ///
-    /// **Why is this bad?** `Vec` already keeps its contents in a separate area on
-    /// the heap. So if you `Box` it, you just add another level of indirection
-    /// without any benefit whatsoever.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    /// ```rust,ignore
-    /// struct X {
-    ///     values: Box<Vec<Foo>>,
-    /// }
-    /// ```
-    ///
-    /// Better:
-    ///
-    /// ```rust,ignore
-    /// struct X {
-    ///     values: Vec<Foo>,
-    /// }
-    /// ```
-    pub BOX_VEC,
-    perf,
-    "usage of `Box<Vec<T>>`, vector elements are already on the heap"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for use of `Vec<Box<T>>` where T: Sized anywhere in the code.
-    /// Check the [Box documentation](https://doc.rust-lang.org/std/boxed/index.html) for more information.
-    ///
-    /// **Why is this bad?** `Vec` already keeps its contents in a separate area on
-    /// the heap. So if you `Box` its contents, you just add another level of indirection.
-    ///
-    /// **Known problems:** Vec<Box<T: Sized>> makes sense if T is a large type (see [#3530](https://github.com/rust-lang/rust-clippy/issues/3530),
-    /// 1st comment).
-    ///
-    /// **Example:**
-    /// ```rust
-    /// struct X {
-    ///     values: Vec<Box<i32>>,
-    /// }
-    /// ```
-    ///
-    /// Better:
-    ///
-    /// ```rust
-    /// struct X {
-    ///     values: Vec<i32>,
-    /// }
-    /// ```
-    pub VEC_BOX,
-    complexity,
-    "usage of `Vec<Box<T>>` where T: Sized, vector elements are already on the heap"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for use of `Option<Option<_>>` in function signatures and type
-    /// definitions
-    ///
-    /// **Why is this bad?** `Option<_>` represents an optional value. `Option<Option<_>>`
-    /// represents an optional optional value which is logically the same thing as an optional
-    /// value but has an unneeded extra level of wrapping.
-    ///
-    /// If you have a case where `Some(Some(_))`, `Some(None)` and `None` are distinct cases,
-    /// consider a custom `enum` instead, with clear names for each case.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example**
-    /// ```rust
-    /// fn get_data() -> Option<Option<u32>> {
-    ///     None
-    /// }
-    /// ```
-    ///
-    /// Better:
-    ///
-    /// ```rust
-    /// pub enum Contents {
-    ///     Data(Vec<u8>), // Was Some(Some(Vec<u8>))
-    ///     NotYetFetched, // Was Some(None)
-    ///     None,          // Was None
-    /// }
-    ///
-    /// fn get_data() -> Contents {
-    ///     Contents::None
-    /// }
-    /// ```
-    pub OPTION_OPTION,
-    pedantic,
-    "usage of `Option<Option<T>>`"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for usage of any `LinkedList`, suggesting to use a
-    /// `Vec` or a `VecDeque` (formerly called `RingBuf`).
-    ///
-    /// **Why is this bad?** Gankro says:
-    ///
-    /// > The TL;DR of `LinkedList` is that it's built on a massive amount of
-    /// pointers and indirection.
-    /// > It wastes memory, it has terrible cache locality, and is all-around slow.
-    /// `RingBuf`, while
-    /// > "only" amortized for push/pop, should be faster in the general case for
-    /// almost every possible
-    /// > workload, and isn't even amortized at all if you can predict the capacity
-    /// you need.
-    /// >
-    /// > `LinkedList`s are only really good if you're doing a lot of merging or
-    /// splitting of lists.
-    /// > This is because they can just mangle some pointers instead of actually
-    /// copying the data. Even
-    /// > if you're doing a lot of insertion in the middle of the list, `RingBuf`
-    /// can still be better
-    /// > because of how expensive it is to seek to the middle of a `LinkedList`.
-    ///
-    /// **Known problems:** False positives – the instances where using a
-    /// `LinkedList` makes sense are few and far between, but they can still happen.
-    ///
-    /// **Example:**
-    /// ```rust
-    /// # use std::collections::LinkedList;
-    /// let x: LinkedList<usize> = LinkedList::new();
-    /// ```
-    pub LINKEDLIST,
-    pedantic,
-    "usage of LinkedList, usually a vector is faster, or a more specialized data structure like a `VecDeque`"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for use of `&Box<T>` anywhere in the code.
-    /// Check the [Box documentation](https://doc.rust-lang.org/std/boxed/index.html) for more information.
-    ///
-    /// **Why is this bad?** Any `&Box<T>` can also be a `&T`, which is more
-    /// general.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    /// ```rust,ignore
-    /// fn foo(bar: &Box<T>) { ... }
-    /// ```
-    ///
-    /// Better:
-    ///
-    /// ```rust,ignore
-    /// fn foo(bar: &T) { ... }
-    /// ```
-    pub BORROWED_BOX,
-    complexity,
-    "a borrow of a boxed type"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for use of redundant allocations anywhere in the code.
-    ///
-    /// **Why is this bad?** Expressions such as `Rc<&T>`, `Rc<Rc<T>>`, `Rc<Box<T>>`, `Box<&T>`
-    /// add an unnecessary level of indirection.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    /// ```rust
-    /// # use std::rc::Rc;
-    /// fn foo(bar: Rc<&usize>) {}
-    /// ```
-    ///
-    /// Better:
-    ///
-    /// ```rust
-    /// fn foo(bar: &usize) {}
-    /// ```
-    pub REDUNDANT_ALLOCATION,
-    perf,
-    "redundant allocation"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for `Rc<T>` and `Arc<T>` when `T` is a mutable buffer type such as `String` or `Vec`.
-    ///
-    /// **Why is this bad?** Expressions such as `Rc<String>` usually have no advantage over `Rc<str>`, since
-    /// it is larger and involves an extra level of indirection, and doesn't implement `Borrow<str>`.
-    ///
-    /// While mutating a buffer type would still be possible with `Rc::get_mut()`, it only
-    /// works if there are no additional references yet, which usually defeats the purpose of
-    /// enclosing it in a shared ownership type. Instead, additionally wrapping the inner
-    /// type with an interior mutable container (such as `RefCell` or `Mutex`) would normally
-    /// be used.
-    ///
-    /// **Known problems:** This pattern can be desirable to avoid the overhead of a `RefCell` or `Mutex` for
-    /// cases where mutation only happens before there are any additional references.
-    ///
-    /// **Example:**
-    /// ```rust,ignore
-    /// # use std::rc::Rc;
-    /// fn foo(interned: Rc<String>) { ... }
-    /// ```
-    ///
-    /// Better:
-    ///
-    /// ```rust,ignore
-    /// fn foo(interned: Rc<str>) { ... }
-    /// ```
-    pub RC_BUFFER,
-    restriction,
-    "shared ownership of a buffer type"
-}
-
-pub struct Types {
-    vec_box_size_threshold: u64,
-}
-
-impl_lint_pass!(Types => [BOX_VEC, VEC_BOX, OPTION_OPTION, LINKEDLIST, BORROWED_BOX, REDUNDANT_ALLOCATION, RC_BUFFER]);
-
-impl<'tcx> LateLintPass<'tcx> for Types {
-    fn check_fn(&mut self, cx: &LateContext<'_>, _: FnKind<'_>, decl: &FnDecl<'_>, _: &Body<'_>, _: Span, id: HirId) {
-        // Skip trait implementations; see issue #605.
-        if let Some(hir::Node::Item(item)) = cx.tcx.hir().find(cx.tcx.hir().get_parent_item(id)) {
-            if let ItemKind::Impl(hir::Impl { of_trait: Some(_), .. }) = item.kind {
-                return;
-            }
-        }
-
-        self.check_fn_decl(cx, decl);
-    }
-
-    fn check_struct_field(&mut self, cx: &LateContext<'_>, field: &hir::StructField<'_>) {
-        self.check_ty(cx, &field.ty, false);
-    }
-
-    fn check_trait_item(&mut self, cx: &LateContext<'_>, item: &TraitItem<'_>) {
-        match item.kind {
-            TraitItemKind::Const(ref ty, _) | TraitItemKind::Type(_, Some(ref ty)) => self.check_ty(cx, ty, false),
-            TraitItemKind::Fn(ref sig, _) => self.check_fn_decl(cx, &sig.decl),
-            _ => (),
-        }
-    }
-
-    fn check_local(&mut self, cx: &LateContext<'_>, local: &Local<'_>) {
-        if let Some(ref ty) = local.ty {
-            self.check_ty(cx, ty, true);
-        }
-    }
-}
-
-fn match_buffer_type(cx: &LateContext<'_>, qpath: &QPath<'_>) -> Option<&'static str> {
-    if is_ty_param_diagnostic_item(cx, qpath, sym::string_type).is_some() {
-        Some("str")
-    } else if is_ty_param_diagnostic_item(cx, qpath, sym::OsString).is_some() {
-        Some("std::ffi::OsStr")
-    } else if is_ty_param_diagnostic_item(cx, qpath, sym::PathBuf).is_some() {
-        Some("std::path::Path")
-    } else {
-        None
-    }
-}
-
-fn match_borrows_parameter(_cx: &LateContext<'_>, qpath: &QPath<'_>) -> Option<Span> {
-    let last = last_path_segment(qpath);
-    if_chain! {
-        if let Some(ref params) = last.args;
-        if !params.parenthesized;
-        if let Some(ty) = params.args.iter().find_map(|arg| match arg {
-            GenericArg::Type(ty) => Some(ty),
-            _ => None,
-        });
-        if let TyKind::Rptr(..) = ty.kind;
-        then {
-            return Some(ty.span);
-        }
-    }
-    None
-}
-
-impl Types {
-    pub fn new(vec_box_size_threshold: u64) -> Self {
-        Self { vec_box_size_threshold }
-    }
-
-    fn check_fn_decl(&mut self, cx: &LateContext<'_>, decl: &FnDecl<'_>) {
-        for input in decl.inputs {
-            self.check_ty(cx, input, false);
-        }
-
-        if let FnRetTy::Return(ref ty) = decl.output {
-            self.check_ty(cx, ty, false);
-        }
-    }
-
-    /// Recursively check for `TypePass` lints in the given type. Stop at the first
-    /// lint found.
-    ///
-    /// The parameter `is_local` distinguishes the context of the type; types from
-    /// local bindings should only be checked for the `BORROWED_BOX` lint.
-    #[allow(clippy::too_many_lines)]
-    fn check_ty(&mut self, cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, is_local: bool) {
-        if hir_ty.span.from_expansion() {
-            return;
-        }
-        match hir_ty.kind {
-            TyKind::Path(ref qpath) if !is_local => {
-                let hir_id = hir_ty.hir_id;
-                let res = cx.qpath_res(qpath, hir_id);
-                if let Some(def_id) = res.opt_def_id() {
-                    if Some(def_id) == cx.tcx.lang_items().owned_box() {
-                        if let Some(span) = match_borrows_parameter(cx, qpath) {
-                            let mut applicability = Applicability::MachineApplicable;
-                            span_lint_and_sugg(
-                                cx,
-                                REDUNDANT_ALLOCATION,
-                                hir_ty.span,
-                                "usage of `Box<&T>`",
-                                "try",
-                                snippet_with_applicability(cx, span, "..", &mut applicability).to_string(),
-                                applicability,
-                            );
-                            return; // don't recurse into the type
-                        }
-                        if is_ty_param_diagnostic_item(cx, qpath, sym::vec_type).is_some() {
-                            span_lint_and_help(
-                                cx,
-                                BOX_VEC,
-                                hir_ty.span,
-                                "you seem to be trying to use `Box<Vec<T>>`. Consider using just `Vec<T>`",
-                                None,
-                                "`Vec<T>` is already on the heap, `Box<Vec<T>>` makes an extra allocation",
-                            );
-                            return; // don't recurse into the type
-                        }
-                    } else if cx.tcx.is_diagnostic_item(sym::Rc, def_id) {
-                        if let Some(ty) = is_ty_param_diagnostic_item(cx, qpath, sym::Rc) {
-                            let mut applicability = Applicability::MachineApplicable;
-                            span_lint_and_sugg(
-                                cx,
-                                REDUNDANT_ALLOCATION,
-                                hir_ty.span,
-                                "usage of `Rc<Rc<T>>`",
-                                "try",
-                                snippet_with_applicability(cx, ty.span, "..", &mut applicability).to_string(),
-                                applicability,
-                            );
-                            return; // don't recurse into the type
-                        }
-                        if let Some(ty) = is_ty_param_lang_item(cx, qpath, LangItem::OwnedBox) {
-                            let qpath = match &ty.kind {
-                                TyKind::Path(qpath) => qpath,
-                                _ => return,
-                            };
-                            let inner_span = match get_qpath_generic_tys(qpath).next() {
-                                Some(ty) => ty.span,
-                                None => return,
-                            };
-                            let mut applicability = Applicability::MachineApplicable;
-                            span_lint_and_sugg(
-                                cx,
-                                REDUNDANT_ALLOCATION,
-                                hir_ty.span,
-                                "usage of `Rc<Box<T>>`",
-                                "try",
-                                format!(
-                                    "Rc<{}>",
-                                    snippet_with_applicability(cx, inner_span, "..", &mut applicability)
-                                ),
-                                applicability,
-                            );
-                            return; // don't recurse into the type
-                        }
-                        if let Some(alternate) = match_buffer_type(cx, qpath) {
-                            span_lint_and_sugg(
-                                cx,
-                                RC_BUFFER,
-                                hir_ty.span,
-                                "usage of `Rc<T>` when T is a buffer type",
-                                "try",
-                                format!("Rc<{}>", alternate),
-                                Applicability::MachineApplicable,
-                            );
-                            return; // don't recurse into the type
-                        }
-                        if let Some(ty) = is_ty_param_diagnostic_item(cx, qpath, sym::vec_type) {
-                            let qpath = match &ty.kind {
-                                TyKind::Path(qpath) => qpath,
-                                _ => return,
-                            };
-                            let inner_span = match get_qpath_generic_tys(qpath).next() {
-                                Some(ty) => ty.span,
-                                None => return,
-                            };
-                            let mut applicability = Applicability::MachineApplicable;
-                            span_lint_and_sugg(
-                                cx,
-                                RC_BUFFER,
-                                hir_ty.span,
-                                "usage of `Rc<T>` when T is a buffer type",
-                                "try",
-                                format!(
-                                    "Rc<[{}]>",
-                                    snippet_with_applicability(cx, inner_span, "..", &mut applicability)
-                                ),
-                                Applicability::MachineApplicable,
-                            );
-                            return; // don't recurse into the type
-                        }
-                        if let Some(span) = match_borrows_parameter(cx, qpath) {
-                            let mut applicability = Applicability::MachineApplicable;
-                            span_lint_and_sugg(
-                                cx,
-                                REDUNDANT_ALLOCATION,
-                                hir_ty.span,
-                                "usage of `Rc<&T>`",
-                                "try",
-                                snippet_with_applicability(cx, span, "..", &mut applicability).to_string(),
-                                applicability,
-                            );
-                            return; // don't recurse into the type
-                        }
-                    } else if cx.tcx.is_diagnostic_item(sym::Arc, def_id) {
-                        if let Some(alternate) = match_buffer_type(cx, qpath) {
-                            span_lint_and_sugg(
-                                cx,
-                                RC_BUFFER,
-                                hir_ty.span,
-                                "usage of `Arc<T>` when T is a buffer type",
-                                "try",
-                                format!("Arc<{}>", alternate),
-                                Applicability::MachineApplicable,
-                            );
-                            return; // don't recurse into the type
-                        }
-                        if let Some(ty) = is_ty_param_diagnostic_item(cx, qpath, sym::vec_type) {
-                            let qpath = match &ty.kind {
-                                TyKind::Path(qpath) => qpath,
-                                _ => return,
-                            };
-                            let inner_span = match get_qpath_generic_tys(qpath).next() {
-                                Some(ty) => ty.span,
-                                None => return,
-                            };
-                            let mut applicability = Applicability::MachineApplicable;
-                            span_lint_and_sugg(
-                                cx,
-                                RC_BUFFER,
-                                hir_ty.span,
-                                "usage of `Arc<T>` when T is a buffer type",
-                                "try",
-                                format!(
-                                    "Arc<[{}]>",
-                                    snippet_with_applicability(cx, inner_span, "..", &mut applicability)
-                                ),
-                                Applicability::MachineApplicable,
-                            );
-                            return; // don't recurse into the type
-                        }
-                    } else if cx.tcx.is_diagnostic_item(sym::vec_type, def_id) {
-                        if_chain! {
-                            // Get the _ part of Vec<_>
-                            if let Some(ref last) = last_path_segment(qpath).args;
-                            if let Some(ty) = last.args.iter().find_map(|arg| match arg {
-                                GenericArg::Type(ty) => Some(ty),
-                                _ => None,
-                            });
-                            // ty is now _ at this point
-                            if let TyKind::Path(ref ty_qpath) = ty.kind;
-                            let res = cx.qpath_res(ty_qpath, ty.hir_id);
-                            if let Some(def_id) = res.opt_def_id();
-                            if Some(def_id) == cx.tcx.lang_items().owned_box();
-                            // At this point, we know ty is Box<T>, now get T
-                            if let Some(ref last) = last_path_segment(ty_qpath).args;
-                            if let Some(boxed_ty) = last.args.iter().find_map(|arg| match arg {
-                                GenericArg::Type(ty) => Some(ty),
-                                _ => None,
-                            });
-                            let ty_ty = hir_ty_to_ty(cx.tcx, boxed_ty);
-                            if !ty_ty.has_escaping_bound_vars();
-                            if ty_ty.is_sized(cx.tcx.at(ty.span), cx.param_env);
-                            if let Ok(ty_ty_size) = cx.layout_of(ty_ty).map(|l| l.size.bytes());
-                            if ty_ty_size <= self.vec_box_size_threshold;
-                            then {
-                                span_lint_and_sugg(
-                                    cx,
-                                    VEC_BOX,
-                                    hir_ty.span,
-                                    "`Vec<T>` is already on the heap, the boxing is unnecessary",
-                                    "try",
-                                    format!("Vec<{}>", snippet(cx, boxed_ty.span, "..")),
-                                    Applicability::MachineApplicable,
-                                );
-                                return; // don't recurse into the type
-                            }
-                        }
-                    } else if cx.tcx.is_diagnostic_item(sym::option_type, def_id) {
-                        if is_ty_param_diagnostic_item(cx, qpath, sym::option_type).is_some() {
-                            span_lint(
-                                cx,
-                                OPTION_OPTION,
-                                hir_ty.span,
-                                "consider using `Option<T>` instead of `Option<Option<T>>` or a custom \
-                                 enum if you need to distinguish all 3 cases",
-                            );
-                            return; // don't recurse into the type
-                        }
-                    } else if match_def_path(cx, def_id, &paths::LINKED_LIST) {
-                        span_lint_and_help(
-                            cx,
-                            LINKEDLIST,
-                            hir_ty.span,
-                            "you seem to be using a `LinkedList`! Perhaps you meant some other data structure?",
-                            None,
-                            "a `VecDeque` might work",
-                        );
-                        return; // don't recurse into the type
-                    }
-                }
-                match *qpath {
-                    QPath::Resolved(Some(ref ty), ref p) => {
-                        self.check_ty(cx, ty, is_local);
-                        for ty in p.segments.iter().flat_map(|seg| {
-                            seg.args
-                                .as_ref()
-                                .map_or_else(|| [].iter(), |params| params.args.iter())
-                                .filter_map(|arg| match arg {
-                                    GenericArg::Type(ty) => Some(ty),
-                                    _ => None,
-                                })
-                        }) {
-                            self.check_ty(cx, ty, is_local);
-                        }
-                    },
-                    QPath::Resolved(None, ref p) => {
-                        for ty in p.segments.iter().flat_map(|seg| {
-                            seg.args
-                                .as_ref()
-                                .map_or_else(|| [].iter(), |params| params.args.iter())
-                                .filter_map(|arg| match arg {
-                                    GenericArg::Type(ty) => Some(ty),
-                                    _ => None,
-                                })
-                        }) {
-                            self.check_ty(cx, ty, is_local);
-                        }
-                    },
-                    QPath::TypeRelative(ref ty, ref seg) => {
-                        self.check_ty(cx, ty, is_local);
-                        if let Some(ref params) = seg.args {
-                            for ty in params.args.iter().filter_map(|arg| match arg {
-                                GenericArg::Type(ty) => Some(ty),
-                                _ => None,
-                            }) {
-                                self.check_ty(cx, ty, is_local);
-                            }
-                        }
-                    },
-                    QPath::LangItem(..) => {},
-                }
-            },
-            TyKind::Rptr(ref lt, ref mut_ty) => self.check_ty_rptr(cx, hir_ty, is_local, lt, mut_ty),
-            // recurse
-            TyKind::Slice(ref ty) | TyKind::Array(ref ty, _) | TyKind::Ptr(MutTy { ref ty, .. }) => {
-                self.check_ty(cx, ty, is_local)
-            },
-            TyKind::Tup(tys) => {
-                for ty in tys {
-                    self.check_ty(cx, ty, is_local);
-                }
-            },
-            _ => {},
-        }
-    }
-
-    fn check_ty_rptr(
-        &mut self,
-        cx: &LateContext<'_>,
-        hir_ty: &hir::Ty<'_>,
-        is_local: bool,
-        lt: &Lifetime,
-        mut_ty: &MutTy<'_>,
-    ) {
-        match mut_ty.ty.kind {
-            TyKind::Path(ref qpath) => {
-                let hir_id = mut_ty.ty.hir_id;
-                let def = cx.qpath_res(qpath, hir_id);
-                if_chain! {
-                    if let Some(def_id) = def.opt_def_id();
-                    if Some(def_id) == cx.tcx.lang_items().owned_box();
-                    if let QPath::Resolved(None, ref path) = *qpath;
-                    if let [ref bx] = *path.segments;
-                    if let Some(ref params) = bx.args;
-                    if !params.parenthesized;
-                    if let Some(inner) = params.args.iter().find_map(|arg| match arg {
-                        GenericArg::Type(ty) => Some(ty),
-                        _ => None,
-                    });
-                    then {
-                        if is_any_trait(inner) {
-                            // Ignore `Box<Any>` types; see issue #1884 for details.
-                            return;
-                        }
-
-                        let ltopt = if lt.is_elided() {
-                            String::new()
-                        } else {
-                            format!("{} ", lt.name.ident().as_str())
-                        };
-
-                        if mut_ty.mutbl == Mutability::Mut {
-                            // Ignore `&mut Box<T>` types; see issue #2907 for
-                            // details.
-                            return;
-                        }
-
-                        // When trait objects or opaque types have lifetime or auto-trait bounds,
-                        // we need to add parentheses to avoid a syntax error due to its ambiguity.
-                        // Originally reported as the issue #3128.
-                        let inner_snippet = snippet(cx, inner.span, "..");
-                        let suggestion = match &inner.kind {
-                            TyKind::TraitObject(bounds, lt_bound) if bounds.len() > 1 || !lt_bound.is_elided() => {
-                                format!("&{}({})", ltopt, &inner_snippet)
-                            },
-                            TyKind::Path(qpath)
-                                if get_bounds_if_impl_trait(cx, qpath, inner.hir_id)
-                                    .map_or(false, |bounds| bounds.len() > 1) =>
-                            {
-                                format!("&{}({})", ltopt, &inner_snippet)
-                            },
-                            _ => format!("&{}{}", ltopt, &inner_snippet),
-                        };
-                        span_lint_and_sugg(
-                            cx,
-                            BORROWED_BOX,
-                            hir_ty.span,
-                            "you seem to be trying to use `&Box<T>`. Consider using just `&T`",
-                            "try",
-                            suggestion,
-                            // To make this `MachineApplicable`, at least one needs to check if it isn't a trait item
-                            // because the trait impls of it will break otherwise;
-                            // and there may be other cases that result in invalid code.
-                            // For example, type coercion doesn't work nicely.
-                            Applicability::Unspecified,
-                        );
-                        return; // don't recurse into the type
-                    }
-                };
-                self.check_ty(cx, &mut_ty.ty, is_local);
-            },
-            _ => self.check_ty(cx, &mut_ty.ty, is_local),
-        }
-    }
-}
-
-// Returns true if given type is `Any` trait.
-fn is_any_trait(t: &hir::Ty<'_>) -> bool {
-    if_chain! {
-        if let TyKind::TraitObject(ref traits, _) = t.kind;
-        if !traits.is_empty();
-        // Only Send/Sync can be used as additional traits, so it is enough to
-        // check only the first trait.
-        if match_path(&traits[0].trait_ref.path, &paths::ANY_TRAIT);
-        then {
-            return true;
-        }
-    }
-
-    false
-}
-
-fn get_bounds_if_impl_trait<'tcx>(cx: &LateContext<'tcx>, qpath: &QPath<'_>, id: HirId) -> Option<GenericBounds<'tcx>> {
-    if_chain! {
-        if let Some(did) = cx.qpath_res(qpath, id).opt_def_id();
-        if let Some(Node::GenericParam(generic_param)) = cx.tcx.hir().get_if_local(did);
-        if let GenericParamKind::Type { synthetic, .. } = generic_param.kind;
-        if synthetic == Some(SyntheticTyParamKind::ImplTrait);
-        then {
-            Some(generic_param.bounds)
-        } else {
-            None
-        }
-    }
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for binding a unit value.
-    ///
-    /// **Why is this bad?** A unit value cannot usefully be used anywhere. So
-    /// binding one is kind of pointless.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    /// ```rust
-    /// let x = {
-    ///     1;
-    /// };
-    /// ```
-    pub LET_UNIT_VALUE,
-    pedantic,
-    "creating a `let` binding to a value of unit type, which usually can't be used afterwards"
-}
-
-declare_lint_pass!(LetUnitValue => [LET_UNIT_VALUE]);
-
-impl<'tcx> LateLintPass<'tcx> for LetUnitValue {
-    fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) {
-        if let StmtKind::Local(ref local) = stmt.kind {
-            if is_unit(cx.typeck_results().pat_ty(&local.pat)) {
-                if in_external_macro(cx.sess(), stmt.span) || local.pat.span.from_expansion() {
-                    return;
-                }
-                if higher::is_from_for_desugar(local) {
-                    return;
-                }
-                span_lint_and_then(
-                    cx,
-                    LET_UNIT_VALUE,
-                    stmt.span,
-                    "this let-binding has unit value",
-                    |diag| {
-                        if let Some(expr) = &local.init {
-                            let snip = snippet_with_macro_callsite(cx, expr.span, "()");
-                            diag.span_suggestion(
-                                stmt.span,
-                                "omit the `let` binding",
-                                format!("{};", snip),
-                                Applicability::MachineApplicable, // snippet
-                            );
-                        }
-                    },
-                );
-            }
-        }
-    }
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for comparisons to unit. This includes all binary
-    /// comparisons (like `==` and `<`) and asserts.
-    ///
-    /// **Why is this bad?** Unit is always equal to itself, and thus is just a
-    /// clumsily written constant. Mostly this happens when someone accidentally
-    /// adds semicolons at the end of the operands.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    /// ```rust
-    /// # fn foo() {};
-    /// # fn bar() {};
-    /// # fn baz() {};
-    /// if {
-    ///     foo();
-    /// } == {
-    ///     bar();
-    /// } {
-    ///     baz();
-    /// }
-    /// ```
-    /// is equal to
-    /// ```rust
-    /// # fn foo() {};
-    /// # fn bar() {};
-    /// # fn baz() {};
-    /// {
-    ///     foo();
-    ///     bar();
-    ///     baz();
-    /// }
-    /// ```
-    ///
-    /// For asserts:
-    /// ```rust
-    /// # fn foo() {};
-    /// # fn bar() {};
-    /// assert_eq!({ foo(); }, { bar(); });
-    /// ```
-    /// will always succeed
-    pub UNIT_CMP,
-    correctness,
-    "comparing unit values"
-}
-
-declare_lint_pass!(UnitCmp => [UNIT_CMP]);
-
-impl<'tcx> LateLintPass<'tcx> for UnitCmp {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
-        if expr.span.from_expansion() {
-            if let Some(callee) = expr.span.source_callee() {
-                if let ExpnKind::Macro(MacroKind::Bang, symbol) = callee.kind {
-                    if let ExprKind::Binary(ref cmp, ref left, _) = expr.kind {
-                        let op = cmp.node;
-                        if op.is_comparison() && is_unit(cx.typeck_results().expr_ty(left)) {
-                            let result = match &*symbol.as_str() {
-                                "assert_eq" | "debug_assert_eq" => "succeed",
-                                "assert_ne" | "debug_assert_ne" => "fail",
-                                _ => return,
-                            };
-                            span_lint(
-                                cx,
-                                UNIT_CMP,
-                                expr.span,
-                                &format!(
-                                    "`{}` of unit values detected. This will always {}",
-                                    symbol.as_str(),
-                                    result
-                                ),
-                            );
-                        }
-                    }
-                }
-            }
-            return;
-        }
-        if let ExprKind::Binary(ref cmp, ref left, _) = expr.kind {
-            let op = cmp.node;
-            if op.is_comparison() && is_unit(cx.typeck_results().expr_ty(left)) {
-                let result = match op {
-                    BinOpKind::Eq | BinOpKind::Le | BinOpKind::Ge => "true",
-                    _ => "false",
-                };
-                span_lint(
-                    cx,
-                    UNIT_CMP,
-                    expr.span,
-                    &format!(
-                        "{}-comparison of unit values detected. This will always be {}",
-                        op.as_str(),
-                        result
-                    ),
-                );
-            }
-        }
-    }
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for passing a unit value as an argument to a function without using a
-    /// unit literal (`()`).
-    ///
-    /// **Why is this bad?** This is likely the result of an accidental semicolon.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    /// ```rust,ignore
-    /// foo({
-    ///     let a = bar();
-    ///     baz(a);
-    /// })
-    /// ```
-    pub UNIT_ARG,
-    complexity,
-    "passing unit to a function"
-}
-
-declare_lint_pass!(UnitArg => [UNIT_ARG]);
-
-impl<'tcx> LateLintPass<'tcx> for UnitArg {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if expr.span.from_expansion() {
-            return;
-        }
-
-        // apparently stuff in the desugaring of `?` can trigger this
-        // so check for that here
-        // only the calls to `Try::from_error` is marked as desugared,
-        // so we need to check both the current Expr and its parent.
-        if is_questionmark_desugar_marked_call(expr) {
-            return;
-        }
-        if_chain! {
-            let map = &cx.tcx.hir();
-            let opt_parent_node = map.find(map.get_parent_node(expr.hir_id));
-            if let Some(hir::Node::Expr(parent_expr)) = opt_parent_node;
-            if is_questionmark_desugar_marked_call(parent_expr);
-            then {
-                return;
-            }
-        }
-
-        match expr.kind {
-            ExprKind::Call(_, args) | ExprKind::MethodCall(_, _, args, _) => {
-                let args_to_recover = args
-                    .iter()
-                    .filter(|arg| {
-                        if is_unit(cx.typeck_results().expr_ty(arg)) && !is_unit_literal(arg) {
-                            !matches!(
-                                &arg.kind,
-                                ExprKind::Match(.., MatchSource::TryDesugar) | ExprKind::Path(..)
-                            )
-                        } else {
-                            false
-                        }
-                    })
-                    .collect::<Vec<_>>();
-                if !args_to_recover.is_empty() {
-                    lint_unit_args(cx, expr, &args_to_recover);
-                }
-            },
-            _ => (),
-        }
-    }
-}
-
-fn fmt_stmts_and_call(
-    cx: &LateContext<'_>,
-    call_expr: &Expr<'_>,
-    call_snippet: &str,
-    args_snippets: &[impl AsRef<str>],
-    non_empty_block_args_snippets: &[impl AsRef<str>],
-) -> String {
-    let call_expr_indent = indent_of(cx, call_expr.span).unwrap_or(0);
-    let call_snippet_with_replacements = args_snippets
-        .iter()
-        .fold(call_snippet.to_owned(), |acc, arg| acc.replacen(arg.as_ref(), "()", 1));
-
-    let mut stmts_and_call = non_empty_block_args_snippets
-        .iter()
-        .map(|it| it.as_ref().to_owned())
-        .collect::<Vec<_>>();
-    stmts_and_call.push(call_snippet_with_replacements);
-    stmts_and_call = stmts_and_call
-        .into_iter()
-        .map(|v| reindent_multiline(v.into(), true, Some(call_expr_indent)).into_owned())
-        .collect();
-
-    let mut stmts_and_call_snippet = stmts_and_call.join(&format!("{}{}", ";\n", " ".repeat(call_expr_indent)));
-    // expr is not in a block statement or result expression position, wrap in a block
-    let parent_node = cx.tcx.hir().find(cx.tcx.hir().get_parent_node(call_expr.hir_id));
-    if !matches!(parent_node, Some(Node::Block(_))) && !matches!(parent_node, Some(Node::Stmt(_))) {
-        let block_indent = call_expr_indent + 4;
-        stmts_and_call_snippet =
-            reindent_multiline(stmts_and_call_snippet.into(), true, Some(block_indent)).into_owned();
-        stmts_and_call_snippet = format!(
-            "{{\n{}{}\n{}}}",
-            " ".repeat(block_indent),
-            &stmts_and_call_snippet,
-            " ".repeat(call_expr_indent)
-        );
-    }
-    stmts_and_call_snippet
-}
-
-fn lint_unit_args(cx: &LateContext<'_>, expr: &Expr<'_>, args_to_recover: &[&Expr<'_>]) {
-    let mut applicability = Applicability::MachineApplicable;
-    let (singular, plural) = if args_to_recover.len() > 1 {
-        ("", "s")
-    } else {
-        ("a ", "")
-    };
-    span_lint_and_then(
-        cx,
-        UNIT_ARG,
-        expr.span,
-        &format!("passing {}unit value{} to a function", singular, plural),
-        |db| {
-            let mut or = "";
-            args_to_recover
-                .iter()
-                .filter_map(|arg| {
-                    if_chain! {
-                        if let ExprKind::Block(block, _) = arg.kind;
-                        if block.expr.is_none();
-                        if let Some(last_stmt) = block.stmts.iter().last();
-                        if let StmtKind::Semi(last_expr) = last_stmt.kind;
-                        if let Some(snip) = snippet_opt(cx, last_expr.span);
-                        then {
-                            Some((
-                                last_stmt.span,
-                                snip,
-                            ))
-                        }
-                        else {
-                            None
-                        }
-                    }
-                })
-                .for_each(|(span, sugg)| {
-                    db.span_suggestion(
-                        span,
-                        "remove the semicolon from the last statement in the block",
-                        sugg,
-                        Applicability::MaybeIncorrect,
-                    );
-                    or = "or ";
-                    applicability = Applicability::MaybeIncorrect;
-                });
-
-            let arg_snippets: Vec<String> = args_to_recover
-                .iter()
-                .filter_map(|arg| snippet_opt(cx, arg.span))
-                .collect();
-            let arg_snippets_without_empty_blocks: Vec<String> = args_to_recover
-                .iter()
-                .filter(|arg| !is_empty_block(arg))
-                .filter_map(|arg| snippet_opt(cx, arg.span))
-                .collect();
-
-            if let Some(call_snippet) = snippet_opt(cx, expr.span) {
-                let sugg = fmt_stmts_and_call(
-                    cx,
-                    expr,
-                    &call_snippet,
-                    &arg_snippets,
-                    &arg_snippets_without_empty_blocks,
-                );
-
-                if arg_snippets_without_empty_blocks.is_empty() {
-                    db.multipart_suggestion(
-                        &format!("use {}unit literal{} instead", singular, plural),
-                        args_to_recover
-                            .iter()
-                            .map(|arg| (arg.span, "()".to_string()))
-                            .collect::<Vec<_>>(),
-                        applicability,
-                    );
-                } else {
-                    let plural = arg_snippets_without_empty_blocks.len() > 1;
-                    let empty_or_s = if plural { "s" } else { "" };
-                    let it_or_them = if plural { "them" } else { "it" };
-                    db.span_suggestion(
-                        expr.span,
-                        &format!(
-                            "{}move the expression{} in front of the call and replace {} with the unit literal `()`",
-                            or, empty_or_s, it_or_them
-                        ),
-                        sugg,
-                        applicability,
-                    );
-                }
-            }
-        },
-    );
-}
-
-fn is_empty_block(expr: &Expr<'_>) -> bool {
-    matches!(
-        expr.kind,
-        ExprKind::Block(
-            Block {
-                stmts: &[],
-                expr: None,
-                ..
-            },
-            _,
-        )
-    )
-}
-
-fn is_questionmark_desugar_marked_call(expr: &Expr<'_>) -> bool {
-    use rustc_span::hygiene::DesugaringKind;
-    if let ExprKind::Call(ref callee, _) = expr.kind {
-        callee.span.is_desugaring(DesugaringKind::QuestionMark)
-    } else {
-        false
-    }
-}
-
-fn is_unit(ty: Ty<'_>) -> bool {
-    matches!(ty.kind(), ty::Tuple(slice) if slice.is_empty())
-}
-
-fn is_unit_literal(expr: &Expr<'_>) -> bool {
-    matches!(expr.kind, ExprKind::Tup(ref slice) if slice.is_empty())
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for casts from any numerical to a float type where
-    /// the receiving type cannot store all values from the original type without
-    /// rounding errors. This possible rounding is to be expected, so this lint is
-    /// `Allow` by default.
-    ///
-    /// Basically, this warns on casting any integer with 32 or more bits to `f32`
-    /// or any 64-bit integer to `f64`.
-    ///
-    /// **Why is this bad?** It's not bad at all. But in some applications it can be
-    /// helpful to know where precision loss can take place. This lint can help find
-    /// those places in the code.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    /// ```rust
-    /// let x = u64::MAX;
-    /// x as f64;
-    /// ```
-    pub CAST_PRECISION_LOSS,
-    pedantic,
-    "casts that cause loss of precision, e.g., `x as f32` where `x: u64`"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for casts from a signed to an unsigned numerical
-    /// type. In this case, negative values wrap around to large positive values,
-    /// which can be quite surprising in practice. However, as the cast works as
-    /// defined, this lint is `Allow` by default.
-    ///
-    /// **Why is this bad?** Possibly surprising results. You can activate this lint
-    /// as a one-time check to see where numerical wrapping can arise.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    /// ```rust
-    /// let y: i8 = -1;
-    /// y as u128; // will return 18446744073709551615
-    /// ```
-    pub CAST_SIGN_LOSS,
-    pedantic,
-    "casts from signed types to unsigned types, e.g., `x as u32` where `x: i32`"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for casts between numerical types that may
-    /// truncate large values. This is expected behavior, so the cast is `Allow` by
-    /// default.
-    ///
-    /// **Why is this bad?** In some problem domains, it is good practice to avoid
-    /// truncation. This lint can be activated to help assess where additional
-    /// checks could be beneficial.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    /// ```rust
-    /// fn as_u8(x: u64) -> u8 {
-    ///     x as u8
-    /// }
-    /// ```
-    pub CAST_POSSIBLE_TRUNCATION,
-    pedantic,
-    "casts that may cause truncation of the value, e.g., `x as u8` where `x: u32`, or `x as i32` where `x: f32`"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for casts from an unsigned type to a signed type of
-    /// the same size. Performing such a cast is a 'no-op' for the compiler,
-    /// i.e., nothing is changed at the bit level, and the binary representation of
-    /// the value is reinterpreted. This can cause wrapping if the value is too big
-    /// for the target signed type. However, the cast works as defined, so this lint
-    /// is `Allow` by default.
-    ///
-    /// **Why is this bad?** While such a cast is not bad in itself, the results can
-    /// be surprising when this is not the intended behavior, as demonstrated by the
-    /// example below.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    /// ```rust
-    /// u32::MAX as i32; // will yield a value of `-1`
-    /// ```
-    pub CAST_POSSIBLE_WRAP,
-    pedantic,
-    "casts that may cause wrapping around the value, e.g., `x as i32` where `x: u32` and `x > i32::MAX`"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for casts between numerical types that may
-    /// be replaced by safe conversion functions.
-    ///
-    /// **Why is this bad?** Rust's `as` keyword will perform many kinds of
-    /// conversions, including silently lossy conversions. Conversion functions such
-    /// as `i32::from` will only perform lossless conversions. Using the conversion
-    /// functions prevents conversions from turning into silent lossy conversions if
-    /// the types of the input expressions ever change, and make it easier for
-    /// people reading the code to know that the conversion is lossless.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    /// ```rust
-    /// fn as_u64(x: u8) -> u64 {
-    ///     x as u64
-    /// }
-    /// ```
-    ///
-    /// Using `::from` would look like this:
-    ///
-    /// ```rust
-    /// fn as_u64(x: u8) -> u64 {
-    ///     u64::from(x)
-    /// }
-    /// ```
-    pub CAST_LOSSLESS,
-    pedantic,
-    "casts using `as` that are known to be lossless, e.g., `x as u64` where `x: u8`"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for casts to the same type, casts of int literals to integer types
-    /// and casts of float literals to float types.
-    ///
-    /// **Why is this bad?** It's just unnecessary.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    /// ```rust
-    /// let _ = 2i32 as i32;
-    /// let _ = 0.5 as f32;
-    /// ```
-    ///
-    /// Better:
-    ///
-    /// ```rust
-    /// let _ = 2_i32;
-    /// let _ = 0.5_f32;
-    /// ```
-    pub UNNECESSARY_CAST,
-    complexity,
-    "cast to the same type, e.g., `x as i32` where `x: i32`"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for casts, using `as` or `pointer::cast`,
-    /// from a less-strictly-aligned pointer to a more-strictly-aligned pointer
-    ///
-    /// **Why is this bad?** Dereferencing the resulting pointer may be undefined
-    /// behavior.
-    ///
-    /// **Known problems:** Using `std::ptr::read_unaligned` and `std::ptr::write_unaligned` or similar
-    /// on the resulting pointer is fine. Is over-zealous: Casts with manual alignment checks or casts like
-    /// u64-> u8 -> u16 can be fine. Miri is able to do a more in-depth analysis.
-    ///
-    /// **Example:**
-    /// ```rust
-    /// let _ = (&1u8 as *const u8) as *const u16;
-    /// let _ = (&mut 1u8 as *mut u8) as *mut u16;
-    ///
-    /// (&1u8 as *const u8).cast::<u16>();
-    /// (&mut 1u8 as *mut u8).cast::<u16>();
-    /// ```
-    pub CAST_PTR_ALIGNMENT,
-    pedantic,
-    "cast from a pointer to a more-strictly-aligned pointer"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for casts of function pointers to something other than usize
-    ///
-    /// **Why is this bad?**
-    /// Casting a function pointer to anything other than usize/isize is not portable across
-    /// architectures, because you end up losing bits if the target type is too small or end up with a
-    /// bunch of extra bits that waste space and add more instructions to the final binary than
-    /// strictly necessary for the problem
-    ///
-    /// Casting to isize also doesn't make sense since there are no signed addresses.
-    ///
-    /// **Example**
-    ///
-    /// ```rust
-    /// // Bad
-    /// fn fun() -> i32 { 1 }
-    /// let a = fun as i64;
-    ///
-    /// // Good
-    /// fn fun2() -> i32 { 1 }
-    /// let a = fun2 as usize;
-    /// ```
-    pub FN_TO_NUMERIC_CAST,
-    style,
-    "casting a function pointer to a numeric type other than usize"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for casts of a function pointer to a numeric type not wide enough to
-    /// store address.
-    ///
-    /// **Why is this bad?**
-    /// Such a cast discards some bits of the function's address. If this is intended, it would be more
-    /// clearly expressed by casting to usize first, then casting the usize to the intended type (with
-    /// a comment) to perform the truncation.
-    ///
-    /// **Example**
-    ///
-    /// ```rust
-    /// // Bad
-    /// fn fn1() -> i16 {
-    ///     1
-    /// };
-    /// let _ = fn1 as i32;
-    ///
-    /// // Better: Cast to usize first, then comment with the reason for the truncation
-    /// fn fn2() -> i16 {
-    ///     1
-    /// };
-    /// let fn_ptr = fn2 as usize;
-    /// let fn_ptr_truncated = fn_ptr as i32;
-    /// ```
-    pub FN_TO_NUMERIC_CAST_WITH_TRUNCATION,
-    style,
-    "casting a function pointer to a numeric type not wide enough to store the address"
-}
-
-/// Returns the size in bits of an integral type.
-/// Will return 0 if the type is not an int or uint variant
-fn int_ty_to_nbits(typ: Ty<'_>, tcx: TyCtxt<'_>) -> u64 {
-    match typ.kind() {
-        ty::Int(i) => match i {
-            IntTy::Isize => tcx.data_layout.pointer_size.bits(),
-            IntTy::I8 => 8,
-            IntTy::I16 => 16,
-            IntTy::I32 => 32,
-            IntTy::I64 => 64,
-            IntTy::I128 => 128,
-        },
-        ty::Uint(i) => match i {
-            UintTy::Usize => tcx.data_layout.pointer_size.bits(),
-            UintTy::U8 => 8,
-            UintTy::U16 => 16,
-            UintTy::U32 => 32,
-            UintTy::U64 => 64,
-            UintTy::U128 => 128,
-        },
-        _ => 0,
-    }
-}
-
-fn is_isize_or_usize(typ: Ty<'_>) -> bool {
-    matches!(typ.kind(), ty::Int(IntTy::Isize) | ty::Uint(UintTy::Usize))
-}
-
-fn span_precision_loss_lint(cx: &LateContext<'_>, expr: &Expr<'_>, cast_from: Ty<'_>, cast_to_f64: bool) {
-    let mantissa_nbits = if cast_to_f64 { 52 } else { 23 };
-    let arch_dependent = is_isize_or_usize(cast_from) && cast_to_f64;
-    let arch_dependent_str = "on targets with 64-bit wide pointers ";
-    let from_nbits_str = if arch_dependent {
-        "64".to_owned()
-    } else if is_isize_or_usize(cast_from) {
-        "32 or 64".to_owned()
-    } else {
-        int_ty_to_nbits(cast_from, cx.tcx).to_string()
-    };
-    span_lint(
-        cx,
-        CAST_PRECISION_LOSS,
-        expr.span,
-        &format!(
-            "casting `{0}` to `{1}` causes a loss of precision {2}(`{0}` is {3} bits wide, \
-             but `{1}`'s mantissa is only {4} bits wide)",
-            cast_from,
-            if cast_to_f64 { "f64" } else { "f32" },
-            if arch_dependent { arch_dependent_str } else { "" },
-            from_nbits_str,
-            mantissa_nbits
-        ),
-    );
-}
-
-fn should_strip_parens(op: &Expr<'_>, snip: &str) -> bool {
-    if let ExprKind::Binary(_, _, _) = op.kind {
-        if snip.starts_with('(') && snip.ends_with(')') {
-            return true;
-        }
-    }
-    false
-}
-
-fn span_lossless_lint(cx: &LateContext<'_>, expr: &Expr<'_>, op: &Expr<'_>, cast_from: Ty<'_>, cast_to: Ty<'_>) {
-    // Do not suggest using From in consts/statics until it is valid to do so (see #2267).
-    if in_constant(cx, expr.hir_id) {
-        return;
-    }
-    // The suggestion is to use a function call, so if the original expression
-    // has parens on the outside, they are no longer needed.
-    let mut applicability = Applicability::MachineApplicable;
-    let opt = snippet_opt(cx, op.span);
-    let sugg = opt.as_ref().map_or_else(
-        || {
-            applicability = Applicability::HasPlaceholders;
-            ".."
-        },
-        |snip| {
-            if should_strip_parens(op, snip) {
-                &snip[1..snip.len() - 1]
-            } else {
-                snip.as_str()
-            }
-        },
-    );
-
-    span_lint_and_sugg(
-        cx,
-        CAST_LOSSLESS,
-        expr.span,
-        &format!(
-            "casting `{}` to `{}` may become silently lossy if you later change the type",
-            cast_from, cast_to
-        ),
-        "try",
-        format!("{}::from({})", cast_to, sugg),
-        applicability,
-    );
-}
-
-enum ArchSuffix {
-    _32,
-    _64,
-    None,
-}
-
-fn check_loss_of_sign(cx: &LateContext<'_>, expr: &Expr<'_>, op: &Expr<'_>, cast_from: Ty<'_>, cast_to: Ty<'_>) {
-    if !cast_from.is_signed() || cast_to.is_signed() {
-        return;
-    }
-
-    // don't lint for positive constants
-    let const_val = constant(cx, &cx.typeck_results(), op);
-    if_chain! {
-        if let Some((Constant::Int(n), _)) = const_val;
-        if let ty::Int(ity) = *cast_from.kind();
-        if sext(cx.tcx, n, ity) >= 0;
-        then {
-            return
-        }
-    }
-
-    // don't lint for the result of methods that always return non-negative values
-    if let ExprKind::MethodCall(ref path, _, _, _) = op.kind {
-        let mut method_name = path.ident.name.as_str();
-        let allowed_methods = ["abs", "checked_abs", "rem_euclid", "checked_rem_euclid"];
-
-        if_chain! {
-            if method_name == "unwrap";
-            if let Some(arglist) = method_chain_args(op, &["unwrap"]);
-            if let ExprKind::MethodCall(ref inner_path, _, _, _) = &arglist[0][0].kind;
-            then {
-                method_name = inner_path.ident.name.as_str();
-            }
-        }
-
-        if allowed_methods.iter().any(|&name| method_name == name) {
-            return;
-        }
-    }
-
-    span_lint(
-        cx,
-        CAST_SIGN_LOSS,
-        expr.span,
-        &format!(
-            "casting `{}` to `{}` may lose the sign of the value",
-            cast_from, cast_to
-        ),
-    );
-}
-
-fn check_truncation_and_wrapping(cx: &LateContext<'_>, expr: &Expr<'_>, cast_from: Ty<'_>, cast_to: Ty<'_>) {
-    let arch_64_suffix = " on targets with 64-bit wide pointers";
-    let arch_32_suffix = " on targets with 32-bit wide pointers";
-    let cast_unsigned_to_signed = !cast_from.is_signed() && cast_to.is_signed();
-    let from_nbits = int_ty_to_nbits(cast_from, cx.tcx);
-    let to_nbits = int_ty_to_nbits(cast_to, cx.tcx);
-    let (span_truncation, suffix_truncation, span_wrap, suffix_wrap) =
-        match (is_isize_or_usize(cast_from), is_isize_or_usize(cast_to)) {
-            (true, true) | (false, false) => (
-                to_nbits < from_nbits,
-                ArchSuffix::None,
-                to_nbits == from_nbits && cast_unsigned_to_signed,
-                ArchSuffix::None,
-            ),
-            (true, false) => (
-                to_nbits <= 32,
-                if to_nbits == 32 {
-                    ArchSuffix::_64
-                } else {
-                    ArchSuffix::None
-                },
-                to_nbits <= 32 && cast_unsigned_to_signed,
-                ArchSuffix::_32,
-            ),
-            (false, true) => (
-                from_nbits == 64,
-                ArchSuffix::_32,
-                cast_unsigned_to_signed,
-                if from_nbits == 64 {
-                    ArchSuffix::_64
-                } else {
-                    ArchSuffix::_32
-                },
-            ),
-        };
-    if span_truncation {
-        span_lint(
-            cx,
-            CAST_POSSIBLE_TRUNCATION,
-            expr.span,
-            &format!(
-                "casting `{}` to `{}` may truncate the value{}",
-                cast_from,
-                cast_to,
-                match suffix_truncation {
-                    ArchSuffix::_32 => arch_32_suffix,
-                    ArchSuffix::_64 => arch_64_suffix,
-                    ArchSuffix::None => "",
-                }
-            ),
-        );
-    }
-    if span_wrap {
-        span_lint(
-            cx,
-            CAST_POSSIBLE_WRAP,
-            expr.span,
-            &format!(
-                "casting `{}` to `{}` may wrap around the value{}",
-                cast_from,
-                cast_to,
-                match suffix_wrap {
-                    ArchSuffix::_32 => arch_32_suffix,
-                    ArchSuffix::_64 => arch_64_suffix,
-                    ArchSuffix::None => "",
-                }
-            ),
-        );
-    }
-}
-
-fn check_lossless(cx: &LateContext<'_>, expr: &Expr<'_>, op: &Expr<'_>, cast_from: Ty<'_>, cast_to: Ty<'_>) {
-    let cast_signed_to_unsigned = cast_from.is_signed() && !cast_to.is_signed();
-    let from_nbits = int_ty_to_nbits(cast_from, cx.tcx);
-    let to_nbits = int_ty_to_nbits(cast_to, cx.tcx);
-    if !is_isize_or_usize(cast_from) && !is_isize_or_usize(cast_to) && from_nbits < to_nbits && !cast_signed_to_unsigned
-    {
-        span_lossless_lint(cx, expr, op, cast_from, cast_to);
-    }
-}
-
-declare_lint_pass!(Casts => [
-    CAST_PRECISION_LOSS,
-    CAST_SIGN_LOSS,
-    CAST_POSSIBLE_TRUNCATION,
-    CAST_POSSIBLE_WRAP,
-    CAST_LOSSLESS,
-    UNNECESSARY_CAST,
-    CAST_PTR_ALIGNMENT,
-    FN_TO_NUMERIC_CAST,
-    FN_TO_NUMERIC_CAST_WITH_TRUNCATION,
-]);
-
-// Check if the given type is either `core::ffi::c_void` or
-// one of the platform specific `libc::<platform>::c_void` of libc.
-fn is_c_void(cx: &LateContext<'_>, ty: Ty<'_>) -> bool {
-    if let ty::Adt(adt, _) = ty.kind() {
-        let names = cx.get_def_path(adt.did);
-
-        if names.is_empty() {
-            return false;
-        }
-        if names[0] == sym::libc || names[0] == sym::core && *names.last().unwrap() == sym!(c_void) {
-            return true;
-        }
-    }
-    false
-}
-
-/// Returns the mantissa bits wide of a fp type.
-/// Will return 0 if the type is not a fp
-fn fp_ty_mantissa_nbits(typ: Ty<'_>) -> u32 {
-    match typ.kind() {
-        ty::Float(FloatTy::F32) => 23,
-        ty::Float(FloatTy::F64) | ty::Infer(InferTy::FloatVar(_)) => 52,
-        _ => 0,
-    }
-}
-
-impl<'tcx> LateLintPass<'tcx> for Casts {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if expr.span.from_expansion() {
-            return;
-        }
-        if let ExprKind::Cast(ref ex, cast_to) = expr.kind {
-            if is_hir_ty_cfg_dependant(cx, cast_to) {
-                return;
-            }
-            let (cast_from, cast_to) = (cx.typeck_results().expr_ty(ex), cx.typeck_results().expr_ty(expr));
-            lint_fn_to_numeric_cast(cx, expr, ex, cast_from, cast_to);
-            if let Some(lit) = get_numeric_literal(ex) {
-                let literal_str = snippet_opt(cx, ex.span).unwrap_or_default();
-
-                if_chain! {
-                    if let LitKind::Int(n, _) = lit.node;
-                    if let Some(src) = snippet_opt(cx, lit.span);
-                    if cast_to.is_floating_point();
-                    if let Some(num_lit) = NumericLiteral::from_lit_kind(&src, &lit.node);
-                    let from_nbits = 128 - n.leading_zeros();
-                    let to_nbits = fp_ty_mantissa_nbits(cast_to);
-                    if from_nbits != 0 && to_nbits != 0 && from_nbits <= to_nbits && num_lit.is_decimal();
-                    then {
-                        let literal_str = if is_unary_neg(ex) { format!("-{}", num_lit.integer) } else { num_lit.integer.into() };
-                        show_unnecessary_cast(cx, expr, &literal_str, cast_from, cast_to);
-                        return;
-                    }
-                }
-
-                match lit.node {
-                    LitKind::Int(_, LitIntType::Unsuffixed) if cast_to.is_integral() => {
-                        show_unnecessary_cast(cx, expr, &literal_str, cast_from, cast_to);
-                    },
-                    LitKind::Float(_, LitFloatType::Unsuffixed) if cast_to.is_floating_point() => {
-                        show_unnecessary_cast(cx, expr, &literal_str, cast_from, cast_to);
-                    },
-                    LitKind::Int(_, LitIntType::Unsuffixed) | LitKind::Float(_, LitFloatType::Unsuffixed) => {},
-                    _ => {
-                        if cast_from.kind() == cast_to.kind() && !in_external_macro(cx.sess(), expr.span) {
-                            span_lint(
-                                cx,
-                                UNNECESSARY_CAST,
-                                expr.span,
-                                &format!(
-                                    "casting to the same type is unnecessary (`{}` -> `{}`)",
-                                    cast_from, cast_to
-                                ),
-                            );
-                        }
-                    },
-                }
-            }
-            if cast_from.is_numeric() && cast_to.is_numeric() && !in_external_macro(cx.sess(), expr.span) {
-                lint_numeric_casts(cx, expr, ex, cast_from, cast_to);
-            }
-
-            lint_cast_ptr_alignment(cx, expr, cast_from, cast_to);
-        } else if let ExprKind::MethodCall(method_path, _, args, _) = expr.kind {
-            if_chain! {
-            if method_path.ident.name == sym!(cast);
-            if let Some(generic_args) = method_path.args;
-            if let [GenericArg::Type(cast_to)] = generic_args.args;
-            // There probably is no obvious reason to do this, just to be consistent with `as` cases.
-            if !is_hir_ty_cfg_dependant(cx, cast_to);
-            then {
-                let (cast_from, cast_to) =
-                    (cx.typeck_results().expr_ty(&args[0]), cx.typeck_results().expr_ty(expr));
-                lint_cast_ptr_alignment(cx, expr, cast_from, cast_to);
-            }
-            }
-        }
-    }
-}
-
-fn is_unary_neg(expr: &Expr<'_>) -> bool {
-    matches!(expr.kind, ExprKind::Unary(UnOp::Neg, _))
-}
-
-fn get_numeric_literal<'e>(expr: &'e Expr<'e>) -> Option<&'e Lit> {
-    match expr.kind {
-        ExprKind::Lit(ref lit) => Some(lit),
-        ExprKind::Unary(UnOp::Neg, e) => {
-            if let ExprKind::Lit(ref lit) = e.kind {
-                Some(lit)
-            } else {
-                None
-            }
-        },
-        _ => None,
-    }
-}
-
-fn show_unnecessary_cast(cx: &LateContext<'_>, expr: &Expr<'_>, literal_str: &str, cast_from: Ty<'_>, cast_to: Ty<'_>) {
-    let literal_kind_name = if cast_from.is_integral() { "integer" } else { "float" };
-    span_lint_and_sugg(
-        cx,
-        UNNECESSARY_CAST,
-        expr.span,
-        &format!("casting {} literal to `{}` is unnecessary", literal_kind_name, cast_to),
-        "try",
-        format!("{}_{}", literal_str.trim_end_matches('.'), cast_to),
-        Applicability::MachineApplicable,
-    );
-}
-
-fn lint_numeric_casts<'tcx>(
-    cx: &LateContext<'tcx>,
-    expr: &Expr<'tcx>,
-    cast_expr: &Expr<'_>,
-    cast_from: Ty<'tcx>,
-    cast_to: Ty<'tcx>,
-) {
-    match (cast_from.is_integral(), cast_to.is_integral()) {
-        (true, false) => {
-            let from_nbits = int_ty_to_nbits(cast_from, cx.tcx);
-            let to_nbits = if let ty::Float(FloatTy::F32) = cast_to.kind() {
-                32
-            } else {
-                64
-            };
-            if is_isize_or_usize(cast_from) || from_nbits >= to_nbits {
-                span_precision_loss_lint(cx, expr, cast_from, to_nbits == 64);
-            }
-            if from_nbits < to_nbits {
-                span_lossless_lint(cx, expr, cast_expr, cast_from, cast_to);
-            }
-        },
-        (false, true) => {
-            span_lint(
-                cx,
-                CAST_POSSIBLE_TRUNCATION,
-                expr.span,
-                &format!("casting `{}` to `{}` may truncate the value", cast_from, cast_to),
-            );
-            if !cast_to.is_signed() {
-                span_lint(
-                    cx,
-                    CAST_SIGN_LOSS,
-                    expr.span,
-                    &format!(
-                        "casting `{}` to `{}` may lose the sign of the value",
-                        cast_from, cast_to
-                    ),
-                );
-            }
-        },
-        (true, true) => {
-            check_loss_of_sign(cx, expr, cast_expr, cast_from, cast_to);
-            check_truncation_and_wrapping(cx, expr, cast_from, cast_to);
-            check_lossless(cx, expr, cast_expr, cast_from, cast_to);
-        },
-        (false, false) => {
-            if let (&ty::Float(FloatTy::F64), &ty::Float(FloatTy::F32)) = (&cast_from.kind(), &cast_to.kind()) {
-                span_lint(
-                    cx,
-                    CAST_POSSIBLE_TRUNCATION,
-                    expr.span,
-                    "casting `f64` to `f32` may truncate the value",
-                );
-            }
-            if let (&ty::Float(FloatTy::F32), &ty::Float(FloatTy::F64)) = (&cast_from.kind(), &cast_to.kind()) {
-                span_lossless_lint(cx, expr, cast_expr, cast_from, cast_to);
-            }
-        },
-    }
-}
-
-fn lint_cast_ptr_alignment<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, cast_from: Ty<'tcx>, cast_to: Ty<'tcx>) {
-    if_chain! {
-        if let ty::RawPtr(from_ptr_ty) = &cast_from.kind();
-        if let ty::RawPtr(to_ptr_ty) = &cast_to.kind();
-        if let Ok(from_layout) = cx.layout_of(from_ptr_ty.ty);
-        if let Ok(to_layout) = cx.layout_of(to_ptr_ty.ty);
-        if from_layout.align.abi < to_layout.align.abi;
-        // with c_void, we inherently need to trust the user
-        if !is_c_void(cx, from_ptr_ty.ty);
-        // when casting from a ZST, we don't know enough to properly lint
-        if !from_layout.is_zst();
-        then {
-            span_lint(
-                cx,
-                CAST_PTR_ALIGNMENT,
-                expr.span,
-                &format!(
-                    "casting from `{}` to a more-strictly-aligned pointer (`{}`) ({} < {} bytes)",
-                    cast_from,
-                    cast_to,
-                    from_layout.align.abi.bytes(),
-                    to_layout.align.abi.bytes(),
-                ),
-            );
-        }
-    }
-}
-
-fn lint_fn_to_numeric_cast(
-    cx: &LateContext<'_>,
-    expr: &Expr<'_>,
-    cast_expr: &Expr<'_>,
-    cast_from: Ty<'_>,
-    cast_to: Ty<'_>,
-) {
-    // We only want to check casts to `ty::Uint` or `ty::Int`
-    match cast_to.kind() {
-        ty::Uint(_) | ty::Int(..) => { /* continue on */ },
-        _ => return,
-    }
-    match cast_from.kind() {
-        ty::FnDef(..) | ty::FnPtr(_) => {
-            let mut applicability = Applicability::MaybeIncorrect;
-            let from_snippet = snippet_with_applicability(cx, cast_expr.span, "x", &mut applicability);
-
-            let to_nbits = int_ty_to_nbits(cast_to, cx.tcx);
-            if to_nbits < cx.tcx.data_layout.pointer_size.bits() {
-                span_lint_and_sugg(
-                    cx,
-                    FN_TO_NUMERIC_CAST_WITH_TRUNCATION,
-                    expr.span,
-                    &format!(
-                        "casting function pointer `{}` to `{}`, which truncates the value",
-                        from_snippet, cast_to
-                    ),
-                    "try",
-                    format!("{} as usize", from_snippet),
-                    applicability,
-                );
-            } else if *cast_to.kind() != ty::Uint(UintTy::Usize) {
-                span_lint_and_sugg(
-                    cx,
-                    FN_TO_NUMERIC_CAST,
-                    expr.span,
-                    &format!("casting function pointer `{}` to `{}`", from_snippet, cast_to),
-                    "try",
-                    format!("{} as usize", from_snippet),
-                    applicability,
-                );
-            }
-        },
-        _ => {},
-    }
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for types used in structs, parameters and `let`
-    /// declarations above a certain complexity threshold.
-    ///
-    /// **Why is this bad?** Too complex types make the code less readable. Consider
-    /// using a `type` definition to simplify them.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    /// ```rust
-    /// # use std::rc::Rc;
-    /// struct Foo {
-    ///     inner: Rc<Vec<Vec<Box<(u32, u32, u32, u32)>>>>,
-    /// }
-    /// ```
-    pub TYPE_COMPLEXITY,
-    complexity,
-    "usage of very complex types that might be better factored into `type` definitions"
-}
-
-pub struct TypeComplexity {
-    threshold: u64,
-}
-
-impl TypeComplexity {
-    #[must_use]
-    pub fn new(threshold: u64) -> Self {
-        Self { threshold }
-    }
-}
-
-impl_lint_pass!(TypeComplexity => [TYPE_COMPLEXITY]);
-
-impl<'tcx> LateLintPass<'tcx> for TypeComplexity {
-    fn check_fn(
-        &mut self,
-        cx: &LateContext<'tcx>,
-        _: FnKind<'tcx>,
-        decl: &'tcx FnDecl<'_>,
-        _: &'tcx Body<'_>,
-        _: Span,
-        _: HirId,
-    ) {
-        self.check_fndecl(cx, decl);
-    }
-
-    fn check_struct_field(&mut self, cx: &LateContext<'tcx>, field: &'tcx hir::StructField<'_>) {
-        // enum variants are also struct fields now
-        self.check_type(cx, &field.ty);
-    }
-
-    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
-        match item.kind {
-            ItemKind::Static(ref ty, _, _) | ItemKind::Const(ref ty, _) => self.check_type(cx, ty),
-            // functions, enums, structs, impls and traits are covered
-            _ => (),
-        }
-    }
-
-    fn check_trait_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx TraitItem<'_>) {
-        match item.kind {
-            TraitItemKind::Const(ref ty, _) | TraitItemKind::Type(_, Some(ref ty)) => self.check_type(cx, ty),
-            TraitItemKind::Fn(FnSig { ref decl, .. }, TraitFn::Required(_)) => self.check_fndecl(cx, decl),
-            // methods with default impl are covered by check_fn
-            _ => (),
-        }
-    }
-
-    fn check_impl_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx ImplItem<'_>) {
-        match item.kind {
-            ImplItemKind::Const(ref ty, _) | ImplItemKind::TyAlias(ref ty) => self.check_type(cx, ty),
-            // methods are covered by check_fn
-            _ => (),
-        }
-    }
-
-    fn check_local(&mut self, cx: &LateContext<'tcx>, local: &'tcx Local<'_>) {
-        if let Some(ref ty) = local.ty {
-            self.check_type(cx, ty);
-        }
-    }
-}
-
-impl<'tcx> TypeComplexity {
-    fn check_fndecl(&self, cx: &LateContext<'tcx>, decl: &'tcx FnDecl<'_>) {
-        for arg in decl.inputs {
-            self.check_type(cx, arg);
-        }
-        if let FnRetTy::Return(ref ty) = decl.output {
-            self.check_type(cx, ty);
-        }
-    }
-
-    fn check_type(&self, cx: &LateContext<'_>, ty: &hir::Ty<'_>) {
-        if ty.span.from_expansion() {
-            return;
-        }
-        let score = {
-            let mut visitor = TypeComplexityVisitor { score: 0, nest: 1 };
-            visitor.visit_ty(ty);
-            visitor.score
-        };
-
-        if score > self.threshold {
-            span_lint(
-                cx,
-                TYPE_COMPLEXITY,
-                ty.span,
-                "very complex type used. Consider factoring parts into `type` definitions",
-            );
-        }
-    }
-}
-
-/// Walks a type and assigns a complexity score to it.
-struct TypeComplexityVisitor {
-    /// total complexity score of the type
-    score: u64,
-    /// current nesting level
-    nest: u64,
-}
-
-impl<'tcx> Visitor<'tcx> for TypeComplexityVisitor {
-    type Map = Map<'tcx>;
-
-    fn visit_ty(&mut self, ty: &'tcx hir::Ty<'_>) {
-        let (add_score, sub_nest) = match ty.kind {
-            // _, &x and *x have only small overhead; don't mess with nesting level
-            TyKind::Infer | TyKind::Ptr(..) | TyKind::Rptr(..) => (1, 0),
-
-            // the "normal" components of a type: named types, arrays/tuples
-            TyKind::Path(..) | TyKind::Slice(..) | TyKind::Tup(..) | TyKind::Array(..) => (10 * self.nest, 1),
-
-            // function types bring a lot of overhead
-            TyKind::BareFn(ref bare) if bare.abi == Abi::Rust => (50 * self.nest, 1),
-
-            TyKind::TraitObject(ref param_bounds, _) => {
-                let has_lifetime_parameters = param_bounds.iter().any(|bound| {
-                    bound
-                        .bound_generic_params
-                        .iter()
-                        .any(|gen| matches!(gen.kind, GenericParamKind::Lifetime { .. }))
-                });
-                if has_lifetime_parameters {
-                    // complex trait bounds like A<'a, 'b>
-                    (50 * self.nest, 1)
-                } else {
-                    // simple trait bounds like A + B
-                    (20 * self.nest, 0)
-                }
-            },
-
-            _ => (0, 0),
-        };
-        self.score += add_score;
-        self.nest += sub_nest;
-        walk_ty(self, ty);
-        self.nest -= sub_nest;
-    }
-    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-        NestedVisitorMap::None
-    }
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for expressions where a character literal is cast
-    /// to `u8` and suggests using a byte literal instead.
-    ///
-    /// **Why is this bad?** In general, casting values to smaller types is
-    /// error-prone and should be avoided where possible. In the particular case of
-    /// converting a character literal to u8, it is easy to avoid by just using a
-    /// byte literal instead. As an added bonus, `b'a'` is even slightly shorter
-    /// than `'a' as u8`.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    /// ```rust,ignore
-    /// 'x' as u8
-    /// ```
-    ///
-    /// A better version, using the byte literal:
-    ///
-    /// ```rust,ignore
-    /// b'x'
-    /// ```
-    pub CHAR_LIT_AS_U8,
-    complexity,
-    "casting a character literal to `u8` truncates"
-}
-
-declare_lint_pass!(CharLitAsU8 => [CHAR_LIT_AS_U8]);
-
-impl<'tcx> LateLintPass<'tcx> for CharLitAsU8 {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if_chain! {
-            if !expr.span.from_expansion();
-            if let ExprKind::Cast(e, _) = &expr.kind;
-            if let ExprKind::Lit(l) = &e.kind;
-            if let LitKind::Char(c) = l.node;
-            if ty::Uint(UintTy::U8) == *cx.typeck_results().expr_ty(expr).kind();
-            then {
-                let mut applicability = Applicability::MachineApplicable;
-                let snippet = snippet_with_applicability(cx, e.span, "'x'", &mut applicability);
-
-                span_lint_and_then(
-                    cx,
-                    CHAR_LIT_AS_U8,
-                    expr.span,
-                    "casting a character literal to `u8` truncates",
-                    |diag| {
-                        diag.note("`char` is four bytes wide, but `u8` is a single byte");
-
-                        if c.is_ascii() {
-                            diag.span_suggestion(
-                                expr.span,
-                                "use a byte literal instead",
-                                format!("b{}", snippet),
-                                applicability,
-                            );
-                        }
-                });
-            }
-        }
-    }
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for comparisons where one side of the relation is
-    /// either the minimum or maximum value for its type and warns if it involves a
-    /// case that is always true or always false. Only integer and boolean types are
-    /// checked.
-    ///
-    /// **Why is this bad?** An expression like `min <= x` may misleadingly imply
-    /// that it is possible for `x` to be less than the minimum. Expressions like
-    /// `max < x` are probably mistakes.
-    ///
-    /// **Known problems:** For `usize` the size of the current compile target will
-    /// be assumed (e.g., 64 bits on 64 bit systems). This means code that uses such
-    /// a comparison to detect target pointer width will trigger this lint. One can
-    /// use `mem::sizeof` and compare its value or conditional compilation
-    /// attributes
-    /// like `#[cfg(target_pointer_width = "64")] ..` instead.
-    ///
-    /// **Example:**
-    ///
-    /// ```rust
-    /// let vec: Vec<isize> = Vec::new();
-    /// if vec.len() <= 0 {}
-    /// if 100 > i32::MAX {}
-    /// ```
-    pub ABSURD_EXTREME_COMPARISONS,
-    correctness,
-    "a comparison with a maximum or minimum value that is always true or false"
-}
-
-declare_lint_pass!(AbsurdExtremeComparisons => [ABSURD_EXTREME_COMPARISONS]);
-
-enum ExtremeType {
-    Minimum,
-    Maximum,
-}
-
-struct ExtremeExpr<'a> {
-    which: ExtremeType,
-    expr: &'a Expr<'a>,
-}
-
-enum AbsurdComparisonResult {
-    AlwaysFalse,
-    AlwaysTrue,
-    InequalityImpossible,
-}
-
-fn is_cast_between_fixed_and_target<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
-    if let ExprKind::Cast(ref cast_exp, _) = expr.kind {
-        let precast_ty = cx.typeck_results().expr_ty(cast_exp);
-        let cast_ty = cx.typeck_results().expr_ty(expr);
-
-        return is_isize_or_usize(precast_ty) != is_isize_or_usize(cast_ty);
-    }
-
-    false
-}
-
-fn detect_absurd_comparison<'tcx>(
-    cx: &LateContext<'tcx>,
-    op: BinOpKind,
-    lhs: &'tcx Expr<'_>,
-    rhs: &'tcx Expr<'_>,
-) -> Option<(ExtremeExpr<'tcx>, AbsurdComparisonResult)> {
-    use crate::types::AbsurdComparisonResult::{AlwaysFalse, AlwaysTrue, InequalityImpossible};
-    use crate::types::ExtremeType::{Maximum, Minimum};
-    use crate::utils::comparisons::{normalize_comparison, Rel};
-
-    // absurd comparison only makes sense on primitive types
-    // primitive types don't implement comparison operators with each other
-    if cx.typeck_results().expr_ty(lhs) != cx.typeck_results().expr_ty(rhs) {
-        return None;
-    }
-
-    // comparisons between fix sized types and target sized types are considered unanalyzable
-    if is_cast_between_fixed_and_target(cx, lhs) || is_cast_between_fixed_and_target(cx, rhs) {
-        return None;
-    }
-
-    let (rel, normalized_lhs, normalized_rhs) = normalize_comparison(op, lhs, rhs)?;
-
-    let lx = detect_extreme_expr(cx, normalized_lhs);
-    let rx = detect_extreme_expr(cx, normalized_rhs);
-
-    Some(match rel {
-        Rel::Lt => {
-            match (lx, rx) {
-                (Some(l @ ExtremeExpr { which: Maximum, .. }), _) => (l, AlwaysFalse), // max < x
-                (_, Some(r @ ExtremeExpr { which: Minimum, .. })) => (r, AlwaysFalse), // x < min
-                _ => return None,
-            }
-        },
-        Rel::Le => {
-            match (lx, rx) {
-                (Some(l @ ExtremeExpr { which: Minimum, .. }), _) => (l, AlwaysTrue), // min <= x
-                (Some(l @ ExtremeExpr { which: Maximum, .. }), _) => (l, InequalityImpossible), // max <= x
-                (_, Some(r @ ExtremeExpr { which: Minimum, .. })) => (r, InequalityImpossible), // x <= min
-                (_, Some(r @ ExtremeExpr { which: Maximum, .. })) => (r, AlwaysTrue), // x <= max
-                _ => return None,
-            }
-        },
-        Rel::Ne | Rel::Eq => return None,
-    })
-}
-
-fn detect_extreme_expr<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<ExtremeExpr<'tcx>> {
-    use crate::types::ExtremeType::{Maximum, Minimum};
-
-    let ty = cx.typeck_results().expr_ty(expr);
-
-    let cv = constant(cx, cx.typeck_results(), expr)?.0;
-
-    let which = match (ty.kind(), cv) {
-        (&ty::Bool, Constant::Bool(false)) | (&ty::Uint(_), Constant::Int(0)) => Minimum,
-        (&ty::Int(ity), Constant::Int(i)) if i == unsext(cx.tcx, i128::MIN >> (128 - int_bits(cx.tcx, ity)), ity) => {
-            Minimum
-        },
-
-        (&ty::Bool, Constant::Bool(true)) => Maximum,
-        (&ty::Int(ity), Constant::Int(i)) if i == unsext(cx.tcx, i128::MAX >> (128 - int_bits(cx.tcx, ity)), ity) => {
-            Maximum
-        },
-        (&ty::Uint(uty), Constant::Int(i)) if clip(cx.tcx, u128::MAX, uty) == i => Maximum,
-
-        _ => return None,
-    };
-    Some(ExtremeExpr { which, expr })
-}
-
-impl<'tcx> LateLintPass<'tcx> for AbsurdExtremeComparisons {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        use crate::types::AbsurdComparisonResult::{AlwaysFalse, AlwaysTrue, InequalityImpossible};
-        use crate::types::ExtremeType::{Maximum, Minimum};
-
-        if let ExprKind::Binary(ref cmp, ref lhs, ref rhs) = expr.kind {
-            if let Some((culprit, result)) = detect_absurd_comparison(cx, cmp.node, lhs, rhs) {
-                if !expr.span.from_expansion() {
-                    let msg = "this comparison involving the minimum or maximum element for this \
-                               type contains a case that is always true or always false";
-
-                    let conclusion = match result {
-                        AlwaysFalse => "this comparison is always false".to_owned(),
-                        AlwaysTrue => "this comparison is always true".to_owned(),
-                        InequalityImpossible => format!(
-                            "the case where the two sides are not equal never occurs, consider using `{} == {}` \
-                             instead",
-                            snippet(cx, lhs.span, "lhs"),
-                            snippet(cx, rhs.span, "rhs")
-                        ),
-                    };
-
-                    let help = format!(
-                        "because `{}` is the {} value for this type, {}",
-                        snippet(cx, culprit.expr.span, "x"),
-                        match culprit.which {
-                            Minimum => "minimum",
-                            Maximum => "maximum",
-                        },
-                        conclusion
-                    );
-
-                    span_lint_and_help(cx, ABSURD_EXTREME_COMPARISONS, expr.span, msg, None, &help);
-                }
-            }
-        }
-    }
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for comparisons where the relation is always either
-    /// true or false, but where one side has been upcast so that the comparison is
-    /// necessary. Only integer types are checked.
-    ///
-    /// **Why is this bad?** An expression like `let x : u8 = ...; (x as u32) > 300`
-    /// will mistakenly imply that it is possible for `x` to be outside the range of
-    /// `u8`.
-    ///
-    /// **Known problems:**
-    /// https://github.com/rust-lang/rust-clippy/issues/886
-    ///
-    /// **Example:**
-    /// ```rust
-    /// let x: u8 = 1;
-    /// (x as u32) > 300;
-    /// ```
-    pub INVALID_UPCAST_COMPARISONS,
-    pedantic,
-    "a comparison involving an upcast which is always true or false"
-}
-
-declare_lint_pass!(InvalidUpcastComparisons => [INVALID_UPCAST_COMPARISONS]);
-
-#[derive(Copy, Clone, Debug, Eq)]
-enum FullInt {
-    S(i128),
-    U(u128),
-}
-
-impl FullInt {
-    #[allow(clippy::cast_sign_loss)]
-    #[must_use]
-    fn cmp_s_u(s: i128, u: u128) -> Ordering {
-        if s < 0 {
-            Ordering::Less
-        } else if u > (i128::MAX as u128) {
-            Ordering::Greater
-        } else {
-            (s as u128).cmp(&u)
-        }
-    }
-}
-
-impl PartialEq for FullInt {
-    #[must_use]
-    fn eq(&self, other: &Self) -> bool {
-        self.partial_cmp(other).expect("`partial_cmp` only returns `Some(_)`") == Ordering::Equal
-    }
-}
-
-impl PartialOrd for FullInt {
-    #[must_use]
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        Some(match (self, other) {
-            (&Self::S(s), &Self::S(o)) => s.cmp(&o),
-            (&Self::U(s), &Self::U(o)) => s.cmp(&o),
-            (&Self::S(s), &Self::U(o)) => Self::cmp_s_u(s, o),
-            (&Self::U(s), &Self::S(o)) => Self::cmp_s_u(o, s).reverse(),
-        })
-    }
-}
-
-impl Ord for FullInt {
-    #[must_use]
-    fn cmp(&self, other: &Self) -> Ordering {
-        self.partial_cmp(other)
-            .expect("`partial_cmp` for FullInt can never return `None`")
-    }
-}
-
-fn numeric_cast_precast_bounds<'a>(cx: &LateContext<'_>, expr: &'a Expr<'_>) -> Option<(FullInt, FullInt)> {
-    if let ExprKind::Cast(ref cast_exp, _) = expr.kind {
-        let pre_cast_ty = cx.typeck_results().expr_ty(cast_exp);
-        let cast_ty = cx.typeck_results().expr_ty(expr);
-        // if it's a cast from i32 to u32 wrapping will invalidate all these checks
-        if cx.layout_of(pre_cast_ty).ok().map(|l| l.size) == cx.layout_of(cast_ty).ok().map(|l| l.size) {
-            return None;
-        }
-        match pre_cast_ty.kind() {
-            ty::Int(int_ty) => Some(match int_ty {
-                IntTy::I8 => (FullInt::S(i128::from(i8::MIN)), FullInt::S(i128::from(i8::MAX))),
-                IntTy::I16 => (FullInt::S(i128::from(i16::MIN)), FullInt::S(i128::from(i16::MAX))),
-                IntTy::I32 => (FullInt::S(i128::from(i32::MIN)), FullInt::S(i128::from(i32::MAX))),
-                IntTy::I64 => (FullInt::S(i128::from(i64::MIN)), FullInt::S(i128::from(i64::MAX))),
-                IntTy::I128 => (FullInt::S(i128::MIN), FullInt::S(i128::MAX)),
-                IntTy::Isize => (FullInt::S(isize::MIN as i128), FullInt::S(isize::MAX as i128)),
-            }),
-            ty::Uint(uint_ty) => Some(match uint_ty {
-                UintTy::U8 => (FullInt::U(u128::from(u8::MIN)), FullInt::U(u128::from(u8::MAX))),
-                UintTy::U16 => (FullInt::U(u128::from(u16::MIN)), FullInt::U(u128::from(u16::MAX))),
-                UintTy::U32 => (FullInt::U(u128::from(u32::MIN)), FullInt::U(u128::from(u32::MAX))),
-                UintTy::U64 => (FullInt::U(u128::from(u64::MIN)), FullInt::U(u128::from(u64::MAX))),
-                UintTy::U128 => (FullInt::U(u128::MIN), FullInt::U(u128::MAX)),
-                UintTy::Usize => (FullInt::U(usize::MIN as u128), FullInt::U(usize::MAX as u128)),
-            }),
-            _ => None,
-        }
-    } else {
-        None
-    }
-}
-
-fn node_as_const_fullint<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<FullInt> {
-    let val = constant(cx, cx.typeck_results(), expr)?.0;
-    if let Constant::Int(const_int) = val {
-        match *cx.typeck_results().expr_ty(expr).kind() {
-            ty::Int(ity) => Some(FullInt::S(sext(cx.tcx, const_int, ity))),
-            ty::Uint(_) => Some(FullInt::U(const_int)),
-            _ => None,
-        }
-    } else {
-        None
-    }
-}
-
-fn err_upcast_comparison(cx: &LateContext<'_>, span: Span, expr: &Expr<'_>, always: bool) {
-    if let ExprKind::Cast(ref cast_val, _) = expr.kind {
-        span_lint(
-            cx,
-            INVALID_UPCAST_COMPARISONS,
-            span,
-            &format!(
-                "because of the numeric bounds on `{}` prior to casting, this expression is always {}",
-                snippet(cx, cast_val.span, "the expression"),
-                if always { "true" } else { "false" },
-            ),
-        );
-    }
-}
-
-fn upcast_comparison_bounds_err<'tcx>(
-    cx: &LateContext<'tcx>,
-    span: Span,
-    rel: comparisons::Rel,
-    lhs_bounds: Option<(FullInt, FullInt)>,
-    lhs: &'tcx Expr<'_>,
-    rhs: &'tcx Expr<'_>,
-    invert: bool,
-) {
-    use crate::utils::comparisons::Rel;
-
-    if let Some((lb, ub)) = lhs_bounds {
-        if let Some(norm_rhs_val) = node_as_const_fullint(cx, rhs) {
-            if rel == Rel::Eq || rel == Rel::Ne {
-                if norm_rhs_val < lb || norm_rhs_val > ub {
-                    err_upcast_comparison(cx, span, lhs, rel == Rel::Ne);
-                }
-            } else if match rel {
-                Rel::Lt => {
-                    if invert {
-                        norm_rhs_val < lb
-                    } else {
-                        ub < norm_rhs_val
-                    }
-                },
-                Rel::Le => {
-                    if invert {
-                        norm_rhs_val <= lb
-                    } else {
-                        ub <= norm_rhs_val
-                    }
-                },
-                Rel::Eq | Rel::Ne => unreachable!(),
-            } {
-                err_upcast_comparison(cx, span, lhs, true)
-            } else if match rel {
-                Rel::Lt => {
-                    if invert {
-                        norm_rhs_val >= ub
-                    } else {
-                        lb >= norm_rhs_val
-                    }
-                },
-                Rel::Le => {
-                    if invert {
-                        norm_rhs_val > ub
-                    } else {
-                        lb > norm_rhs_val
-                    }
-                },
-                Rel::Eq | Rel::Ne => unreachable!(),
-            } {
-                err_upcast_comparison(cx, span, lhs, false)
-            }
-        }
-    }
-}
-
-impl<'tcx> LateLintPass<'tcx> for InvalidUpcastComparisons {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if let ExprKind::Binary(ref cmp, ref lhs, ref rhs) = expr.kind {
-            let normalized = comparisons::normalize_comparison(cmp.node, lhs, rhs);
-            let (rel, normalized_lhs, normalized_rhs) = if let Some(val) = normalized {
-                val
-            } else {
-                return;
-            };
-
-            let lhs_bounds = numeric_cast_precast_bounds(cx, normalized_lhs);
-            let rhs_bounds = numeric_cast_precast_bounds(cx, normalized_rhs);
-
-            upcast_comparison_bounds_err(cx, expr.span, rel, lhs_bounds, normalized_lhs, normalized_rhs, false);
-            upcast_comparison_bounds_err(cx, expr.span, rel, rhs_bounds, normalized_rhs, normalized_lhs, true);
-        }
-    }
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for public `impl` or `fn` missing generalization
-    /// over different hashers and implicitly defaulting to the default hashing
-    /// algorithm (`SipHash`).
-    ///
-    /// **Why is this bad?** `HashMap` or `HashSet` with custom hashers cannot be
-    /// used with them.
-    ///
-    /// **Known problems:** Suggestions for replacing constructors can contain
-    /// false-positives. Also applying suggestions can require modification of other
-    /// pieces of code, possibly including external crates.
-    ///
-    /// **Example:**
-    /// ```rust
-    /// # use std::collections::HashMap;
-    /// # use std::hash::{Hash, BuildHasher};
-    /// # trait Serialize {};
-    /// impl<K: Hash + Eq, V> Serialize for HashMap<K, V> { }
-    ///
-    /// pub fn foo(map: &mut HashMap<i32, i32>) { }
-    /// ```
-    /// could be rewritten as
-    /// ```rust
-    /// # use std::collections::HashMap;
-    /// # use std::hash::{Hash, BuildHasher};
-    /// # trait Serialize {};
-    /// impl<K: Hash + Eq, V, S: BuildHasher> Serialize for HashMap<K, V, S> { }
-    ///
-    /// pub fn foo<S: BuildHasher>(map: &mut HashMap<i32, i32, S>) { }
-    /// ```
-    pub IMPLICIT_HASHER,
-    pedantic,
-    "missing generalization over different hashers"
-}
-
-declare_lint_pass!(ImplicitHasher => [IMPLICIT_HASHER]);
-
-impl<'tcx> LateLintPass<'tcx> for ImplicitHasher {
-    #[allow(clippy::cast_possible_truncation, clippy::too_many_lines)]
-    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
-        use rustc_span::BytePos;
-
-        fn suggestion<'tcx>(
-            cx: &LateContext<'tcx>,
-            diag: &mut DiagnosticBuilder<'_>,
-            generics_span: Span,
-            generics_suggestion_span: Span,
-            target: &ImplicitHasherType<'_>,
-            vis: ImplicitHasherConstructorVisitor<'_, '_, '_>,
-        ) {
-            let generics_snip = snippet(cx, generics_span, "");
-            // trim `<` `>`
-            let generics_snip = if generics_snip.is_empty() {
-                ""
-            } else {
-                &generics_snip[1..generics_snip.len() - 1]
-            };
-
-            multispan_sugg(
-                diag,
-                "consider adding a type parameter",
-                vec![
-                    (
-                        generics_suggestion_span,
-                        format!(
-                            "<{}{}S: ::std::hash::BuildHasher{}>",
-                            generics_snip,
-                            if generics_snip.is_empty() { "" } else { ", " },
-                            if vis.suggestions.is_empty() {
-                                ""
-                            } else {
-                                // request users to add `Default` bound so that generic constructors can be used
-                                " + Default"
-                            },
-                        ),
-                    ),
-                    (
-                        target.span(),
-                        format!("{}<{}, S>", target.type_name(), target.type_arguments(),),
-                    ),
-                ],
-            );
-
-            if !vis.suggestions.is_empty() {
-                multispan_sugg(diag, "...and use generic constructor", vis.suggestions);
-            }
-        }
-
-        if !cx.access_levels.is_exported(item.hir_id()) {
-            return;
-        }
-
-        match item.kind {
-            ItemKind::Impl(ref impl_) => {
-                let mut vis = ImplicitHasherTypeVisitor::new(cx);
-                vis.visit_ty(impl_.self_ty);
-
-                for target in &vis.found {
-                    if differing_macro_contexts(item.span, target.span()) {
-                        return;
-                    }
-
-                    let generics_suggestion_span = impl_.generics.span.substitute_dummy({
-                        let pos = snippet_opt(cx, item.span.until(target.span()))
-                            .and_then(|snip| Some(item.span.lo() + BytePos(snip.find("impl")? as u32 + 4)));
-                        if let Some(pos) = pos {
-                            Span::new(pos, pos, item.span.data().ctxt)
-                        } else {
-                            return;
-                        }
-                    });
-
-                    let mut ctr_vis = ImplicitHasherConstructorVisitor::new(cx, target);
-                    for item in impl_.items.iter().map(|item| cx.tcx.hir().impl_item(item.id)) {
-                        ctr_vis.visit_impl_item(item);
-                    }
-
-                    span_lint_and_then(
-                        cx,
-                        IMPLICIT_HASHER,
-                        target.span(),
-                        &format!(
-                            "impl for `{}` should be generalized over different hashers",
-                            target.type_name()
-                        ),
-                        move |diag| {
-                            suggestion(cx, diag, impl_.generics.span, generics_suggestion_span, target, ctr_vis);
-                        },
-                    );
-                }
-            },
-            ItemKind::Fn(ref sig, ref generics, body_id) => {
-                let body = cx.tcx.hir().body(body_id);
-
-                for ty in sig.decl.inputs {
-                    let mut vis = ImplicitHasherTypeVisitor::new(cx);
-                    vis.visit_ty(ty);
-
-                    for target in &vis.found {
-                        if in_external_macro(cx.sess(), generics.span) {
-                            continue;
-                        }
-                        let generics_suggestion_span = generics.span.substitute_dummy({
-                            let pos = snippet_opt(cx, item.span.until(body.params[0].pat.span))
-                                .and_then(|snip| {
-                                    let i = snip.find("fn")?;
-                                    Some(item.span.lo() + BytePos((i + (&snip[i..]).find('(')?) as u32))
-                                })
-                                .expect("failed to create span for type parameters");
-                            Span::new(pos, pos, item.span.data().ctxt)
-                        });
-
-                        let mut ctr_vis = ImplicitHasherConstructorVisitor::new(cx, target);
-                        ctr_vis.visit_body(body);
-
-                        span_lint_and_then(
-                            cx,
-                            IMPLICIT_HASHER,
-                            target.span(),
-                            &format!(
-                                "parameter of type `{}` should be generalized over different hashers",
-                                target.type_name()
-                            ),
-                            move |diag| {
-                                suggestion(cx, diag, generics.span, generics_suggestion_span, target, ctr_vis);
-                            },
-                        );
-                    }
-                }
-            },
-            _ => {},
-        }
-    }
-}
-
-enum ImplicitHasherType<'tcx> {
-    HashMap(Span, Ty<'tcx>, Cow<'static, str>, Cow<'static, str>),
-    HashSet(Span, Ty<'tcx>, Cow<'static, str>),
-}
-
-impl<'tcx> ImplicitHasherType<'tcx> {
-    /// Checks that `ty` is a target type without a `BuildHasher`.
-    fn new(cx: &LateContext<'tcx>, hir_ty: &hir::Ty<'_>) -> Option<Self> {
-        if let TyKind::Path(QPath::Resolved(None, ref path)) = hir_ty.kind {
-            let params: Vec<_> = path
-                .segments
-                .last()
-                .as_ref()?
-                .args
-                .as_ref()?
-                .args
-                .iter()
-                .filter_map(|arg| match arg {
-                    GenericArg::Type(ty) => Some(ty),
-                    _ => None,
-                })
-                .collect();
-            let params_len = params.len();
-
-            let ty = hir_ty_to_ty(cx.tcx, hir_ty);
-
-            if is_type_diagnostic_item(cx, ty, sym!(hashmap_type)) && params_len == 2 {
-                Some(ImplicitHasherType::HashMap(
-                    hir_ty.span,
-                    ty,
-                    snippet(cx, params[0].span, "K"),
-                    snippet(cx, params[1].span, "V"),
-                ))
-            } else if is_type_diagnostic_item(cx, ty, sym!(hashset_type)) && params_len == 1 {
-                Some(ImplicitHasherType::HashSet(
-                    hir_ty.span,
-                    ty,
-                    snippet(cx, params[0].span, "T"),
-                ))
-            } else {
-                None
-            }
-        } else {
-            None
-        }
-    }
-
-    fn type_name(&self) -> &'static str {
-        match *self {
-            ImplicitHasherType::HashMap(..) => "HashMap",
-            ImplicitHasherType::HashSet(..) => "HashSet",
-        }
-    }
-
-    fn type_arguments(&self) -> String {
-        match *self {
-            ImplicitHasherType::HashMap(.., ref k, ref v) => format!("{}, {}", k, v),
-            ImplicitHasherType::HashSet(.., ref t) => format!("{}", t),
-        }
-    }
-
-    fn ty(&self) -> Ty<'tcx> {
-        match *self {
-            ImplicitHasherType::HashMap(_, ty, ..) | ImplicitHasherType::HashSet(_, ty, ..) => ty,
-        }
-    }
-
-    fn span(&self) -> Span {
-        match *self {
-            ImplicitHasherType::HashMap(span, ..) | ImplicitHasherType::HashSet(span, ..) => span,
-        }
-    }
-}
-
-struct ImplicitHasherTypeVisitor<'a, 'tcx> {
-    cx: &'a LateContext<'tcx>,
-    found: Vec<ImplicitHasherType<'tcx>>,
-}
-
-impl<'a, 'tcx> ImplicitHasherTypeVisitor<'a, 'tcx> {
-    fn new(cx: &'a LateContext<'tcx>) -> Self {
-        Self { cx, found: vec![] }
-    }
-}
-
-impl<'a, 'tcx> Visitor<'tcx> for ImplicitHasherTypeVisitor<'a, 'tcx> {
-    type Map = Map<'tcx>;
-
-    fn visit_ty(&mut self, t: &'tcx hir::Ty<'_>) {
-        if let Some(target) = ImplicitHasherType::new(self.cx, t) {
-            self.found.push(target);
-        }
-
-        walk_ty(self, t);
-    }
-
-    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-        NestedVisitorMap::None
-    }
-}
-
-/// Looks for default-hasher-dependent constructors like `HashMap::new`.
-struct ImplicitHasherConstructorVisitor<'a, 'b, 'tcx> {
-    cx: &'a LateContext<'tcx>,
-    maybe_typeck_results: Option<&'tcx TypeckResults<'tcx>>,
-    target: &'b ImplicitHasherType<'tcx>,
-    suggestions: BTreeMap<Span, String>,
-}
-
-impl<'a, 'b, 'tcx> ImplicitHasherConstructorVisitor<'a, 'b, 'tcx> {
-    fn new(cx: &'a LateContext<'tcx>, target: &'b ImplicitHasherType<'tcx>) -> Self {
-        Self {
-            cx,
-            maybe_typeck_results: cx.maybe_typeck_results(),
-            target,
-            suggestions: BTreeMap::new(),
-        }
-    }
-}
-
-impl<'a, 'b, 'tcx> Visitor<'tcx> for ImplicitHasherConstructorVisitor<'a, 'b, 'tcx> {
-    type Map = Map<'tcx>;
-
-    fn visit_body(&mut self, body: &'tcx Body<'_>) {
-        let old_maybe_typeck_results = self.maybe_typeck_results.replace(self.cx.tcx.typeck_body(body.id()));
-        walk_body(self, body);
-        self.maybe_typeck_results = old_maybe_typeck_results;
-    }
-
-    fn visit_expr(&mut self, e: &'tcx Expr<'_>) {
-        if_chain! {
-            if let ExprKind::Call(ref fun, ref args) = e.kind;
-            if let ExprKind::Path(QPath::TypeRelative(ref ty, ref method)) = fun.kind;
-            if let TyKind::Path(QPath::Resolved(None, ty_path)) = ty.kind;
-            then {
-                if !TyS::same_type(self.target.ty(), self.maybe_typeck_results.unwrap().expr_ty(e)) {
-                    return;
-                }
-
-                if match_path(ty_path, &paths::HASHMAP) {
-                    if method.ident.name == sym::new {
-                        self.suggestions
-                            .insert(e.span, "HashMap::default()".to_string());
-                    } else if method.ident.name == sym!(with_capacity) {
-                        self.suggestions.insert(
-                            e.span,
-                            format!(
-                                "HashMap::with_capacity_and_hasher({}, Default::default())",
-                                snippet(self.cx, args[0].span, "capacity"),
-                            ),
-                        );
-                    }
-                } else if match_path(ty_path, &paths::HASHSET) {
-                    if method.ident.name == sym::new {
-                        self.suggestions
-                            .insert(e.span, "HashSet::default()".to_string());
-                    } else if method.ident.name == sym!(with_capacity) {
-                        self.suggestions.insert(
-                            e.span,
-                            format!(
-                                "HashSet::with_capacity_and_hasher({}, Default::default())",
-                                snippet(self.cx, args[0].span, "capacity"),
-                            ),
-                        );
-                    }
-                }
-            }
-        }
-
-        walk_expr(self, e);
-    }
-
-    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-        NestedVisitorMap::OnlyBodies(self.cx.tcx.hir())
-    }
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for casts of `&T` to `&mut T` anywhere in the code.
-    ///
-    /// **Why is this bad?** It’s basically guaranteed to be undefined behaviour.
-    /// `UnsafeCell` is the only way to obtain aliasable data that is considered
-    /// mutable.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    /// ```rust,ignore
-    /// fn x(r: &i32) {
-    ///     unsafe {
-    ///         *(r as *const _ as *mut _) += 1;
-    ///     }
-    /// }
-    /// ```
-    ///
-    /// Instead consider using interior mutability types.
-    ///
-    /// ```rust
-    /// use std::cell::UnsafeCell;
-    ///
-    /// fn x(r: &UnsafeCell<i32>) {
-    ///     unsafe {
-    ///         *r.get() += 1;
-    ///     }
-    /// }
-    /// ```
-    pub CAST_REF_TO_MUT,
-    correctness,
-    "a cast of reference to a mutable pointer"
-}
-
-declare_lint_pass!(RefToMut => [CAST_REF_TO_MUT]);
-
-impl<'tcx> LateLintPass<'tcx> for RefToMut {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if_chain! {
-            if let ExprKind::Unary(UnOp::Deref, e) = &expr.kind;
-            if let ExprKind::Cast(e, t) = &e.kind;
-            if let TyKind::Ptr(MutTy { mutbl: Mutability::Mut, .. }) = t.kind;
-            if let ExprKind::Cast(e, t) = &e.kind;
-            if let TyKind::Ptr(MutTy { mutbl: Mutability::Not, .. }) = t.kind;
-            if let ty::Ref(..) = cx.typeck_results().node_type(e.hir_id).kind();
-            then {
-                span_lint(
-                    cx,
-                    CAST_REF_TO_MUT,
-                    expr.span,
-                    "casting `&T` to `&mut T` may cause undefined behavior, consider instead using an `UnsafeCell`",
-                );
-            }
-        }
-    }
-}
-
-const PTR_AS_PTR_MSRV: RustcVersion = RustcVersion::new(1, 38, 0);
-
-declare_clippy_lint! {
-    /// **What it does:**
-    /// Checks for `as` casts between raw pointers without changing its mutability,
-    /// namely `*const T` to `*const U` and `*mut T` to `*mut U`.
-    ///
-    /// **Why is this bad?**
-    /// Though `as` casts between raw pointers is not terrible, `pointer::cast` is safer because
-    /// it cannot accidentally change the pointer's mutability nor cast the pointer to other types like `usize`.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
-    /// ```rust
-    /// let ptr: *const u32 = &42_u32;
-    /// let mut_ptr: *mut u32 = &mut 42_u32;
-    /// let _ = ptr as *const i32;
-    /// let _ = mut_ptr as *mut i32;
-    /// ```
-    /// Use instead:
-    /// ```rust
-    /// let ptr: *const u32 = &42_u32;
-    /// let mut_ptr: *mut u32 = &mut 42_u32;
-    /// let _ = ptr.cast::<i32>();
-    /// let _ = mut_ptr.cast::<i32>();
-    /// ```
-    pub PTR_AS_PTR,
-    pedantic,
-    "casting using `as` from and to raw pointers that doesn't change its mutability, where `pointer::cast` could take the place of `as`"
-}
-
-pub struct PtrAsPtr {
-    msrv: Option<RustcVersion>,
-}
-
-impl PtrAsPtr {
-    #[must_use]
-    pub fn new(msrv: Option<RustcVersion>) -> Self {
-        Self { msrv }
-    }
-}
-
-impl_lint_pass!(PtrAsPtr => [PTR_AS_PTR]);
-
-impl<'tcx> LateLintPass<'tcx> for PtrAsPtr {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if !meets_msrv(self.msrv.as_ref(), &PTR_AS_PTR_MSRV) {
-            return;
-        }
-
-        if expr.span.from_expansion() {
-            return;
-        }
-
-        if_chain! {
-            if let ExprKind::Cast(cast_expr, cast_to_hir_ty) = expr.kind;
-            let (cast_from, cast_to) = (cx.typeck_results().expr_ty(cast_expr), cx.typeck_results().expr_ty(expr));
-            if let ty::RawPtr(TypeAndMut { mutbl: from_mutbl, .. }) = cast_from.kind();
-            if let ty::RawPtr(TypeAndMut { ty: to_pointee_ty, mutbl: to_mutbl }) = cast_to.kind();
-            if matches!((from_mutbl, to_mutbl),
-                (Mutability::Not, Mutability::Not) | (Mutability::Mut, Mutability::Mut));
-            // The `U` in `pointer::cast` have to be `Sized`
-            // as explained here: https://github.com/rust-lang/rust/issues/60602.
-            if to_pointee_ty.is_sized(cx.tcx.at(expr.span), cx.param_env);
-            then {
-                let mut applicability = Applicability::MachineApplicable;
-                let cast_expr_sugg = Sugg::hir_with_applicability(cx, cast_expr, "_", &mut applicability);
-                let turbofish = match &cast_to_hir_ty.kind {
-                        TyKind::Infer => Cow::Borrowed(""),
-                        TyKind::Ptr(mut_ty) if matches!(mut_ty.ty.kind, TyKind::Infer) => Cow::Borrowed(""),
-                        _ => Cow::Owned(format!("::<{}>", to_pointee_ty)),
-                    };
-                span_lint_and_sugg(
-                    cx,
-                    PTR_AS_PTR,
-                    expr.span,
-                    "`as` casting between raw pointers without changing its mutability",
-                    "try `pointer::cast`, a safer alternative",
-                    format!("{}.cast{}()", cast_expr_sugg.maybe_par(), turbofish),
-                    applicability,
-                );
-            }
-        }
-    }
-
-    extract_msrv_attr!(LateContext);
-}
diff --git a/clippy_lints/src/types/mod.rs b/clippy_lints/src/types/mod.rs
new file mode 100644
index 00000000000..ce201b956d8
--- /dev/null
+++ b/clippy_lints/src/types/mod.rs
@@ -0,0 +1,2952 @@
+#![allow(rustc::default_hash_types)]
+
+use std::borrow::Cow;
+use std::cmp::Ordering;
+use std::collections::BTreeMap;
+
+use if_chain::if_chain;
+use rustc_ast::{LitFloatType, LitIntType, LitKind};
+use rustc_errors::{Applicability, DiagnosticBuilder};
+use rustc_hir as hir;
+use rustc_hir::intravisit::{walk_body, walk_expr, walk_ty, FnKind, NestedVisitorMap, Visitor};
+use rustc_hir::{
+    BinOpKind, Block, Body, Expr, ExprKind, FnDecl, FnRetTy, FnSig, GenericArg, GenericBounds, GenericParamKind, HirId,
+    ImplItem, ImplItemKind, Item, ItemKind, LangItem, Lifetime, Lit, Local, MatchSource, MutTy, Mutability, Node,
+    QPath, Stmt, StmtKind, SyntheticTyParamKind, TraitFn, TraitItem, TraitItemKind, TyKind, UnOp,
+};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_middle::hir::map::Map;
+use rustc_middle::lint::in_external_macro;
+use rustc_middle::ty::TypeFoldable;
+use rustc_middle::ty::{self, FloatTy, InferTy, IntTy, Ty, TyCtxt, TyS, TypeAndMut, TypeckResults, UintTy};
+use rustc_semver::RustcVersion;
+use rustc_session::{declare_lint_pass, declare_tool_lint, impl_lint_pass};
+use rustc_span::hygiene::{ExpnKind, MacroKind};
+use rustc_span::source_map::Span;
+use rustc_span::symbol::sym;
+use rustc_target::abi::LayoutOf;
+use rustc_target::spec::abi::Abi;
+use rustc_typeck::hir_ty_to_ty;
+
+use crate::consts::{constant, Constant};
+use crate::utils::paths;
+use crate::utils::sugg::Sugg;
+use crate::utils::{
+    clip, comparisons, differing_macro_contexts, get_qpath_generic_tys, higher, in_constant, indent_of, int_bits,
+    is_hir_ty_cfg_dependant, is_ty_param_diagnostic_item, is_ty_param_lang_item, is_type_diagnostic_item,
+    last_path_segment, match_def_path, match_path, meets_msrv, method_chain_args, multispan_sugg,
+    numeric_literal::NumericLiteral, reindent_multiline, sext, snippet, snippet_opt, snippet_with_applicability,
+    snippet_with_macro_callsite, span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then, unsext,
+};
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for use of `Box<Vec<_>>` anywhere in the code.
+    /// Check the [Box documentation](https://doc.rust-lang.org/std/boxed/index.html) for more information.
+    ///
+    /// **Why is this bad?** `Vec` already keeps its contents in a separate area on
+    /// the heap. So if you `Box` it, you just add another level of indirection
+    /// without any benefit whatsoever.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// ```rust,ignore
+    /// struct X {
+    ///     values: Box<Vec<Foo>>,
+    /// }
+    /// ```
+    ///
+    /// Better:
+    ///
+    /// ```rust,ignore
+    /// struct X {
+    ///     values: Vec<Foo>,
+    /// }
+    /// ```
+    pub BOX_VEC,
+    perf,
+    "usage of `Box<Vec<T>>`, vector elements are already on the heap"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for use of `Vec<Box<T>>` where T: Sized anywhere in the code.
+    /// Check the [Box documentation](https://doc.rust-lang.org/std/boxed/index.html) for more information.
+    ///
+    /// **Why is this bad?** `Vec` already keeps its contents in a separate area on
+    /// the heap. So if you `Box` its contents, you just add another level of indirection.
+    ///
+    /// **Known problems:** Vec<Box<T: Sized>> makes sense if T is a large type (see [#3530](https://github.com/rust-lang/rust-clippy/issues/3530),
+    /// 1st comment).
+    ///
+    /// **Example:**
+    /// ```rust
+    /// struct X {
+    ///     values: Vec<Box<i32>>,
+    /// }
+    /// ```
+    ///
+    /// Better:
+    ///
+    /// ```rust
+    /// struct X {
+    ///     values: Vec<i32>,
+    /// }
+    /// ```
+    pub VEC_BOX,
+    complexity,
+    "usage of `Vec<Box<T>>` where T: Sized, vector elements are already on the heap"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for use of `Option<Option<_>>` in function signatures and type
+    /// definitions
+    ///
+    /// **Why is this bad?** `Option<_>` represents an optional value. `Option<Option<_>>`
+    /// represents an optional optional value which is logically the same thing as an optional
+    /// value but has an unneeded extra level of wrapping.
+    ///
+    /// If you have a case where `Some(Some(_))`, `Some(None)` and `None` are distinct cases,
+    /// consider a custom `enum` instead, with clear names for each case.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example**
+    /// ```rust
+    /// fn get_data() -> Option<Option<u32>> {
+    ///     None
+    /// }
+    /// ```
+    ///
+    /// Better:
+    ///
+    /// ```rust
+    /// pub enum Contents {
+    ///     Data(Vec<u8>), // Was Some(Some(Vec<u8>))
+    ///     NotYetFetched, // Was Some(None)
+    ///     None,          // Was None
+    /// }
+    ///
+    /// fn get_data() -> Contents {
+    ///     Contents::None
+    /// }
+    /// ```
+    pub OPTION_OPTION,
+    pedantic,
+    "usage of `Option<Option<T>>`"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for usage of any `LinkedList`, suggesting to use a
+    /// `Vec` or a `VecDeque` (formerly called `RingBuf`).
+    ///
+    /// **Why is this bad?** Gankro says:
+    ///
+    /// > The TL;DR of `LinkedList` is that it's built on a massive amount of
+    /// pointers and indirection.
+    /// > It wastes memory, it has terrible cache locality, and is all-around slow.
+    /// `RingBuf`, while
+    /// > "only" amortized for push/pop, should be faster in the general case for
+    /// almost every possible
+    /// > workload, and isn't even amortized at all if you can predict the capacity
+    /// you need.
+    /// >
+    /// > `LinkedList`s are only really good if you're doing a lot of merging or
+    /// splitting of lists.
+    /// > This is because they can just mangle some pointers instead of actually
+    /// copying the data. Even
+    /// > if you're doing a lot of insertion in the middle of the list, `RingBuf`
+    /// can still be better
+    /// > because of how expensive it is to seek to the middle of a `LinkedList`.
+    ///
+    /// **Known problems:** False positives – the instances where using a
+    /// `LinkedList` makes sense are few and far between, but they can still happen.
+    ///
+    /// **Example:**
+    /// ```rust
+    /// # use std::collections::LinkedList;
+    /// let x: LinkedList<usize> = LinkedList::new();
+    /// ```
+    pub LINKEDLIST,
+    pedantic,
+    "usage of LinkedList, usually a vector is faster, or a more specialized data structure like a `VecDeque`"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for use of `&Box<T>` anywhere in the code.
+    /// Check the [Box documentation](https://doc.rust-lang.org/std/boxed/index.html) for more information.
+    ///
+    /// **Why is this bad?** Any `&Box<T>` can also be a `&T`, which is more
+    /// general.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// ```rust,ignore
+    /// fn foo(bar: &Box<T>) { ... }
+    /// ```
+    ///
+    /// Better:
+    ///
+    /// ```rust,ignore
+    /// fn foo(bar: &T) { ... }
+    /// ```
+    pub BORROWED_BOX,
+    complexity,
+    "a borrow of a boxed type"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for use of redundant allocations anywhere in the code.
+    ///
+    /// **Why is this bad?** Expressions such as `Rc<&T>`, `Rc<Rc<T>>`, `Rc<Box<T>>`, `Box<&T>`
+    /// add an unnecessary level of indirection.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// ```rust
+    /// # use std::rc::Rc;
+    /// fn foo(bar: Rc<&usize>) {}
+    /// ```
+    ///
+    /// Better:
+    ///
+    /// ```rust
+    /// fn foo(bar: &usize) {}
+    /// ```
+    pub REDUNDANT_ALLOCATION,
+    perf,
+    "redundant allocation"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for `Rc<T>` and `Arc<T>` when `T` is a mutable buffer type such as `String` or `Vec`.
+    ///
+    /// **Why is this bad?** Expressions such as `Rc<String>` usually have no advantage over `Rc<str>`, since
+    /// it is larger and involves an extra level of indirection, and doesn't implement `Borrow<str>`.
+    ///
+    /// While mutating a buffer type would still be possible with `Rc::get_mut()`, it only
+    /// works if there are no additional references yet, which usually defeats the purpose of
+    /// enclosing it in a shared ownership type. Instead, additionally wrapping the inner
+    /// type with an interior mutable container (such as `RefCell` or `Mutex`) would normally
+    /// be used.
+    ///
+    /// **Known problems:** This pattern can be desirable to avoid the overhead of a `RefCell` or `Mutex` for
+    /// cases where mutation only happens before there are any additional references.
+    ///
+    /// **Example:**
+    /// ```rust,ignore
+    /// # use std::rc::Rc;
+    /// fn foo(interned: Rc<String>) { ... }
+    /// ```
+    ///
+    /// Better:
+    ///
+    /// ```rust,ignore
+    /// fn foo(interned: Rc<str>) { ... }
+    /// ```
+    pub RC_BUFFER,
+    restriction,
+    "shared ownership of a buffer type"
+}
+
+pub struct Types {
+    vec_box_size_threshold: u64,
+}
+
+impl_lint_pass!(Types => [BOX_VEC, VEC_BOX, OPTION_OPTION, LINKEDLIST, BORROWED_BOX, REDUNDANT_ALLOCATION, RC_BUFFER]);
+
+impl<'tcx> LateLintPass<'tcx> for Types {
+    fn check_fn(&mut self, cx: &LateContext<'_>, _: FnKind<'_>, decl: &FnDecl<'_>, _: &Body<'_>, _: Span, id: HirId) {
+        // Skip trait implementations; see issue #605.
+        if let Some(hir::Node::Item(item)) = cx.tcx.hir().find(cx.tcx.hir().get_parent_item(id)) {
+            if let ItemKind::Impl(hir::Impl { of_trait: Some(_), .. }) = item.kind {
+                return;
+            }
+        }
+
+        self.check_fn_decl(cx, decl);
+    }
+
+    fn check_struct_field(&mut self, cx: &LateContext<'_>, field: &hir::StructField<'_>) {
+        self.check_ty(cx, &field.ty, false);
+    }
+
+    fn check_trait_item(&mut self, cx: &LateContext<'_>, item: &TraitItem<'_>) {
+        match item.kind {
+            TraitItemKind::Const(ref ty, _) | TraitItemKind::Type(_, Some(ref ty)) => self.check_ty(cx, ty, false),
+            TraitItemKind::Fn(ref sig, _) => self.check_fn_decl(cx, &sig.decl),
+            _ => (),
+        }
+    }
+
+    fn check_local(&mut self, cx: &LateContext<'_>, local: &Local<'_>) {
+        if let Some(ref ty) = local.ty {
+            self.check_ty(cx, ty, true);
+        }
+    }
+}
+
+fn match_buffer_type(cx: &LateContext<'_>, qpath: &QPath<'_>) -> Option<&'static str> {
+    if is_ty_param_diagnostic_item(cx, qpath, sym::string_type).is_some() {
+        Some("str")
+    } else if is_ty_param_diagnostic_item(cx, qpath, sym::OsString).is_some() {
+        Some("std::ffi::OsStr")
+    } else if is_ty_param_diagnostic_item(cx, qpath, sym::PathBuf).is_some() {
+        Some("std::path::Path")
+    } else {
+        None
+    }
+}
+
+fn match_borrows_parameter(_cx: &LateContext<'_>, qpath: &QPath<'_>) -> Option<Span> {
+    let last = last_path_segment(qpath);
+    if_chain! {
+        if let Some(ref params) = last.args;
+        if !params.parenthesized;
+        if let Some(ty) = params.args.iter().find_map(|arg| match arg {
+            GenericArg::Type(ty) => Some(ty),
+            _ => None,
+        });
+        if let TyKind::Rptr(..) = ty.kind;
+        then {
+            return Some(ty.span);
+        }
+    }
+    None
+}
+
+impl Types {
+    pub fn new(vec_box_size_threshold: u64) -> Self {
+        Self { vec_box_size_threshold }
+    }
+
+    fn check_fn_decl(&mut self, cx: &LateContext<'_>, decl: &FnDecl<'_>) {
+        for input in decl.inputs {
+            self.check_ty(cx, input, false);
+        }
+
+        if let FnRetTy::Return(ref ty) = decl.output {
+            self.check_ty(cx, ty, false);
+        }
+    }
+
+    /// Recursively check for `TypePass` lints in the given type. Stop at the first
+    /// lint found.
+    ///
+    /// The parameter `is_local` distinguishes the context of the type; types from
+    /// local bindings should only be checked for the `BORROWED_BOX` lint.
+    #[allow(clippy::too_many_lines)]
+    fn check_ty(&mut self, cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, is_local: bool) {
+        if hir_ty.span.from_expansion() {
+            return;
+        }
+        match hir_ty.kind {
+            TyKind::Path(ref qpath) if !is_local => {
+                let hir_id = hir_ty.hir_id;
+                let res = cx.qpath_res(qpath, hir_id);
+                if let Some(def_id) = res.opt_def_id() {
+                    if Some(def_id) == cx.tcx.lang_items().owned_box() {
+                        if let Some(span) = match_borrows_parameter(cx, qpath) {
+                            let mut applicability = Applicability::MachineApplicable;
+                            span_lint_and_sugg(
+                                cx,
+                                REDUNDANT_ALLOCATION,
+                                hir_ty.span,
+                                "usage of `Box<&T>`",
+                                "try",
+                                snippet_with_applicability(cx, span, "..", &mut applicability).to_string(),
+                                applicability,
+                            );
+                            return; // don't recurse into the type
+                        }
+                        if is_ty_param_diagnostic_item(cx, qpath, sym::vec_type).is_some() {
+                            span_lint_and_help(
+                                cx,
+                                BOX_VEC,
+                                hir_ty.span,
+                                "you seem to be trying to use `Box<Vec<T>>`. Consider using just `Vec<T>`",
+                                None,
+                                "`Vec<T>` is already on the heap, `Box<Vec<T>>` makes an extra allocation",
+                            );
+                            return; // don't recurse into the type
+                        }
+                    } else if cx.tcx.is_diagnostic_item(sym::Rc, def_id) {
+                        if let Some(ty) = is_ty_param_diagnostic_item(cx, qpath, sym::Rc) {
+                            let mut applicability = Applicability::MachineApplicable;
+                            span_lint_and_sugg(
+                                cx,
+                                REDUNDANT_ALLOCATION,
+                                hir_ty.span,
+                                "usage of `Rc<Rc<T>>`",
+                                "try",
+                                snippet_with_applicability(cx, ty.span, "..", &mut applicability).to_string(),
+                                applicability,
+                            );
+                            return; // don't recurse into the type
+                        }
+                        if let Some(ty) = is_ty_param_lang_item(cx, qpath, LangItem::OwnedBox) {
+                            let qpath = match &ty.kind {
+                                TyKind::Path(qpath) => qpath,
+                                _ => return,
+                            };
+                            let inner_span = match get_qpath_generic_tys(qpath).next() {
+                                Some(ty) => ty.span,
+                                None => return,
+                            };
+                            let mut applicability = Applicability::MachineApplicable;
+                            span_lint_and_sugg(
+                                cx,
+                                REDUNDANT_ALLOCATION,
+                                hir_ty.span,
+                                "usage of `Rc<Box<T>>`",
+                                "try",
+                                format!(
+                                    "Rc<{}>",
+                                    snippet_with_applicability(cx, inner_span, "..", &mut applicability)
+                                ),
+                                applicability,
+                            );
+                            return; // don't recurse into the type
+                        }
+                        if let Some(alternate) = match_buffer_type(cx, qpath) {
+                            span_lint_and_sugg(
+                                cx,
+                                RC_BUFFER,
+                                hir_ty.span,
+                                "usage of `Rc<T>` when T is a buffer type",
+                                "try",
+                                format!("Rc<{}>", alternate),
+                                Applicability::MachineApplicable,
+                            );
+                            return; // don't recurse into the type
+                        }
+                        if let Some(ty) = is_ty_param_diagnostic_item(cx, qpath, sym::vec_type) {
+                            let qpath = match &ty.kind {
+                                TyKind::Path(qpath) => qpath,
+                                _ => return,
+                            };
+                            let inner_span = match get_qpath_generic_tys(qpath).next() {
+                                Some(ty) => ty.span,
+                                None => return,
+                            };
+                            let mut applicability = Applicability::MachineApplicable;
+                            span_lint_and_sugg(
+                                cx,
+                                RC_BUFFER,
+                                hir_ty.span,
+                                "usage of `Rc<T>` when T is a buffer type",
+                                "try",
+                                format!(
+                                    "Rc<[{}]>",
+                                    snippet_with_applicability(cx, inner_span, "..", &mut applicability)
+                                ),
+                                Applicability::MachineApplicable,
+                            );
+                            return; // don't recurse into the type
+                        }
+                        if let Some(span) = match_borrows_parameter(cx, qpath) {
+                            let mut applicability = Applicability::MachineApplicable;
+                            span_lint_and_sugg(
+                                cx,
+                                REDUNDANT_ALLOCATION,
+                                hir_ty.span,
+                                "usage of `Rc<&T>`",
+                                "try",
+                                snippet_with_applicability(cx, span, "..", &mut applicability).to_string(),
+                                applicability,
+                            );
+                            return; // don't recurse into the type
+                        }
+                    } else if cx.tcx.is_diagnostic_item(sym::Arc, def_id) {
+                        if let Some(alternate) = match_buffer_type(cx, qpath) {
+                            span_lint_and_sugg(
+                                cx,
+                                RC_BUFFER,
+                                hir_ty.span,
+                                "usage of `Arc<T>` when T is a buffer type",
+                                "try",
+                                format!("Arc<{}>", alternate),
+                                Applicability::MachineApplicable,
+                            );
+                            return; // don't recurse into the type
+                        }
+                        if let Some(ty) = is_ty_param_diagnostic_item(cx, qpath, sym::vec_type) {
+                            let qpath = match &ty.kind {
+                                TyKind::Path(qpath) => qpath,
+                                _ => return,
+                            };
+                            let inner_span = match get_qpath_generic_tys(qpath).next() {
+                                Some(ty) => ty.span,
+                                None => return,
+                            };
+                            let mut applicability = Applicability::MachineApplicable;
+                            span_lint_and_sugg(
+                                cx,
+                                RC_BUFFER,
+                                hir_ty.span,
+                                "usage of `Arc<T>` when T is a buffer type",
+                                "try",
+                                format!(
+                                    "Arc<[{}]>",
+                                    snippet_with_applicability(cx, inner_span, "..", &mut applicability)
+                                ),
+                                Applicability::MachineApplicable,
+                            );
+                            return; // don't recurse into the type
+                        }
+                    } else if cx.tcx.is_diagnostic_item(sym::vec_type, def_id) {
+                        if_chain! {
+                            // Get the _ part of Vec<_>
+                            if let Some(ref last) = last_path_segment(qpath).args;
+                            if let Some(ty) = last.args.iter().find_map(|arg| match arg {
+                                GenericArg::Type(ty) => Some(ty),
+                                _ => None,
+                            });
+                            // ty is now _ at this point
+                            if let TyKind::Path(ref ty_qpath) = ty.kind;
+                            let res = cx.qpath_res(ty_qpath, ty.hir_id);
+                            if let Some(def_id) = res.opt_def_id();
+                            if Some(def_id) == cx.tcx.lang_items().owned_box();
+                            // At this point, we know ty is Box<T>, now get T
+                            if let Some(ref last) = last_path_segment(ty_qpath).args;
+                            if let Some(boxed_ty) = last.args.iter().find_map(|arg| match arg {
+                                GenericArg::Type(ty) => Some(ty),
+                                _ => None,
+                            });
+                            let ty_ty = hir_ty_to_ty(cx.tcx, boxed_ty);
+                            if !ty_ty.has_escaping_bound_vars();
+                            if ty_ty.is_sized(cx.tcx.at(ty.span), cx.param_env);
+                            if let Ok(ty_ty_size) = cx.layout_of(ty_ty).map(|l| l.size.bytes());
+                            if ty_ty_size <= self.vec_box_size_threshold;
+                            then {
+                                span_lint_and_sugg(
+                                    cx,
+                                    VEC_BOX,
+                                    hir_ty.span,
+                                    "`Vec<T>` is already on the heap, the boxing is unnecessary",
+                                    "try",
+                                    format!("Vec<{}>", snippet(cx, boxed_ty.span, "..")),
+                                    Applicability::MachineApplicable,
+                                );
+                                return; // don't recurse into the type
+                            }
+                        }
+                    } else if cx.tcx.is_diagnostic_item(sym::option_type, def_id) {
+                        if is_ty_param_diagnostic_item(cx, qpath, sym::option_type).is_some() {
+                            span_lint(
+                                cx,
+                                OPTION_OPTION,
+                                hir_ty.span,
+                                "consider using `Option<T>` instead of `Option<Option<T>>` or a custom \
+                                 enum if you need to distinguish all 3 cases",
+                            );
+                            return; // don't recurse into the type
+                        }
+                    } else if match_def_path(cx, def_id, &paths::LINKED_LIST) {
+                        span_lint_and_help(
+                            cx,
+                            LINKEDLIST,
+                            hir_ty.span,
+                            "you seem to be using a `LinkedList`! Perhaps you meant some other data structure?",
+                            None,
+                            "a `VecDeque` might work",
+                        );
+                        return; // don't recurse into the type
+                    }
+                }
+                match *qpath {
+                    QPath::Resolved(Some(ref ty), ref p) => {
+                        self.check_ty(cx, ty, is_local);
+                        for ty in p.segments.iter().flat_map(|seg| {
+                            seg.args
+                                .as_ref()
+                                .map_or_else(|| [].iter(), |params| params.args.iter())
+                                .filter_map(|arg| match arg {
+                                    GenericArg::Type(ty) => Some(ty),
+                                    _ => None,
+                                })
+                        }) {
+                            self.check_ty(cx, ty, is_local);
+                        }
+                    },
+                    QPath::Resolved(None, ref p) => {
+                        for ty in p.segments.iter().flat_map(|seg| {
+                            seg.args
+                                .as_ref()
+                                .map_or_else(|| [].iter(), |params| params.args.iter())
+                                .filter_map(|arg| match arg {
+                                    GenericArg::Type(ty) => Some(ty),
+                                    _ => None,
+                                })
+                        }) {
+                            self.check_ty(cx, ty, is_local);
+                        }
+                    },
+                    QPath::TypeRelative(ref ty, ref seg) => {
+                        self.check_ty(cx, ty, is_local);
+                        if let Some(ref params) = seg.args {
+                            for ty in params.args.iter().filter_map(|arg| match arg {
+                                GenericArg::Type(ty) => Some(ty),
+                                _ => None,
+                            }) {
+                                self.check_ty(cx, ty, is_local);
+                            }
+                        }
+                    },
+                    QPath::LangItem(..) => {},
+                }
+            },
+            TyKind::Rptr(ref lt, ref mut_ty) => self.check_ty_rptr(cx, hir_ty, is_local, lt, mut_ty),
+            // recurse
+            TyKind::Slice(ref ty) | TyKind::Array(ref ty, _) | TyKind::Ptr(MutTy { ref ty, .. }) => {
+                self.check_ty(cx, ty, is_local)
+            },
+            TyKind::Tup(tys) => {
+                for ty in tys {
+                    self.check_ty(cx, ty, is_local);
+                }
+            },
+            _ => {},
+        }
+    }
+
+    fn check_ty_rptr(
+        &mut self,
+        cx: &LateContext<'_>,
+        hir_ty: &hir::Ty<'_>,
+        is_local: bool,
+        lt: &Lifetime,
+        mut_ty: &MutTy<'_>,
+    ) {
+        match mut_ty.ty.kind {
+            TyKind::Path(ref qpath) => {
+                let hir_id = mut_ty.ty.hir_id;
+                let def = cx.qpath_res(qpath, hir_id);
+                if_chain! {
+                    if let Some(def_id) = def.opt_def_id();
+                    if Some(def_id) == cx.tcx.lang_items().owned_box();
+                    if let QPath::Resolved(None, ref path) = *qpath;
+                    if let [ref bx] = *path.segments;
+                    if let Some(ref params) = bx.args;
+                    if !params.parenthesized;
+                    if let Some(inner) = params.args.iter().find_map(|arg| match arg {
+                        GenericArg::Type(ty) => Some(ty),
+                        _ => None,
+                    });
+                    then {
+                        if is_any_trait(inner) {
+                            // Ignore `Box<Any>` types; see issue #1884 for details.
+                            return;
+                        }
+
+                        let ltopt = if lt.is_elided() {
+                            String::new()
+                        } else {
+                            format!("{} ", lt.name.ident().as_str())
+                        };
+
+                        if mut_ty.mutbl == Mutability::Mut {
+                            // Ignore `&mut Box<T>` types; see issue #2907 for
+                            // details.
+                            return;
+                        }
+
+                        // When trait objects or opaque types have lifetime or auto-trait bounds,
+                        // we need to add parentheses to avoid a syntax error due to its ambiguity.
+                        // Originally reported as the issue #3128.
+                        let inner_snippet = snippet(cx, inner.span, "..");
+                        let suggestion = match &inner.kind {
+                            TyKind::TraitObject(bounds, lt_bound) if bounds.len() > 1 || !lt_bound.is_elided() => {
+                                format!("&{}({})", ltopt, &inner_snippet)
+                            },
+                            TyKind::Path(qpath)
+                                if get_bounds_if_impl_trait(cx, qpath, inner.hir_id)
+                                    .map_or(false, |bounds| bounds.len() > 1) =>
+                            {
+                                format!("&{}({})", ltopt, &inner_snippet)
+                            },
+                            _ => format!("&{}{}", ltopt, &inner_snippet),
+                        };
+                        span_lint_and_sugg(
+                            cx,
+                            BORROWED_BOX,
+                            hir_ty.span,
+                            "you seem to be trying to use `&Box<T>`. Consider using just `&T`",
+                            "try",
+                            suggestion,
+                            // To make this `MachineApplicable`, at least one needs to check if it isn't a trait item
+                            // because the trait impls of it will break otherwise;
+                            // and there may be other cases that result in invalid code.
+                            // For example, type coercion doesn't work nicely.
+                            Applicability::Unspecified,
+                        );
+                        return; // don't recurse into the type
+                    }
+                };
+                self.check_ty(cx, &mut_ty.ty, is_local);
+            },
+            _ => self.check_ty(cx, &mut_ty.ty, is_local),
+        }
+    }
+}
+
+// Returns true if given type is `Any` trait.
+fn is_any_trait(t: &hir::Ty<'_>) -> bool {
+    if_chain! {
+        if let TyKind::TraitObject(ref traits, _) = t.kind;
+        if !traits.is_empty();
+        // Only Send/Sync can be used as additional traits, so it is enough to
+        // check only the first trait.
+        if match_path(&traits[0].trait_ref.path, &paths::ANY_TRAIT);
+        then {
+            return true;
+        }
+    }
+
+    false
+}
+
+fn get_bounds_if_impl_trait<'tcx>(cx: &LateContext<'tcx>, qpath: &QPath<'_>, id: HirId) -> Option<GenericBounds<'tcx>> {
+    if_chain! {
+        if let Some(did) = cx.qpath_res(qpath, id).opt_def_id();
+        if let Some(Node::GenericParam(generic_param)) = cx.tcx.hir().get_if_local(did);
+        if let GenericParamKind::Type { synthetic, .. } = generic_param.kind;
+        if synthetic == Some(SyntheticTyParamKind::ImplTrait);
+        then {
+            Some(generic_param.bounds)
+        } else {
+            None
+        }
+    }
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for binding a unit value.
+    ///
+    /// **Why is this bad?** A unit value cannot usefully be used anywhere. So
+    /// binding one is kind of pointless.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// ```rust
+    /// let x = {
+    ///     1;
+    /// };
+    /// ```
+    pub LET_UNIT_VALUE,
+    pedantic,
+    "creating a `let` binding to a value of unit type, which usually can't be used afterwards"
+}
+
+declare_lint_pass!(LetUnitValue => [LET_UNIT_VALUE]);
+
+impl<'tcx> LateLintPass<'tcx> for LetUnitValue {
+    fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) {
+        if let StmtKind::Local(ref local) = stmt.kind {
+            if is_unit(cx.typeck_results().pat_ty(&local.pat)) {
+                if in_external_macro(cx.sess(), stmt.span) || local.pat.span.from_expansion() {
+                    return;
+                }
+                if higher::is_from_for_desugar(local) {
+                    return;
+                }
+                span_lint_and_then(
+                    cx,
+                    LET_UNIT_VALUE,
+                    stmt.span,
+                    "this let-binding has unit value",
+                    |diag| {
+                        if let Some(expr) = &local.init {
+                            let snip = snippet_with_macro_callsite(cx, expr.span, "()");
+                            diag.span_suggestion(
+                                stmt.span,
+                                "omit the `let` binding",
+                                format!("{};", snip),
+                                Applicability::MachineApplicable, // snippet
+                            );
+                        }
+                    },
+                );
+            }
+        }
+    }
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for comparisons to unit. This includes all binary
+    /// comparisons (like `==` and `<`) and asserts.
+    ///
+    /// **Why is this bad?** Unit is always equal to itself, and thus is just a
+    /// clumsily written constant. Mostly this happens when someone accidentally
+    /// adds semicolons at the end of the operands.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// ```rust
+    /// # fn foo() {};
+    /// # fn bar() {};
+    /// # fn baz() {};
+    /// if {
+    ///     foo();
+    /// } == {
+    ///     bar();
+    /// } {
+    ///     baz();
+    /// }
+    /// ```
+    /// is equal to
+    /// ```rust
+    /// # fn foo() {};
+    /// # fn bar() {};
+    /// # fn baz() {};
+    /// {
+    ///     foo();
+    ///     bar();
+    ///     baz();
+    /// }
+    /// ```
+    ///
+    /// For asserts:
+    /// ```rust
+    /// # fn foo() {};
+    /// # fn bar() {};
+    /// assert_eq!({ foo(); }, { bar(); });
+    /// ```
+    /// will always succeed
+    pub UNIT_CMP,
+    correctness,
+    "comparing unit values"
+}
+
+declare_lint_pass!(UnitCmp => [UNIT_CMP]);
+
+impl<'tcx> LateLintPass<'tcx> for UnitCmp {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
+        if expr.span.from_expansion() {
+            if let Some(callee) = expr.span.source_callee() {
+                if let ExpnKind::Macro(MacroKind::Bang, symbol) = callee.kind {
+                    if let ExprKind::Binary(ref cmp, ref left, _) = expr.kind {
+                        let op = cmp.node;
+                        if op.is_comparison() && is_unit(cx.typeck_results().expr_ty(left)) {
+                            let result = match &*symbol.as_str() {
+                                "assert_eq" | "debug_assert_eq" => "succeed",
+                                "assert_ne" | "debug_assert_ne" => "fail",
+                                _ => return,
+                            };
+                            span_lint(
+                                cx,
+                                UNIT_CMP,
+                                expr.span,
+                                &format!(
+                                    "`{}` of unit values detected. This will always {}",
+                                    symbol.as_str(),
+                                    result
+                                ),
+                            );
+                        }
+                    }
+                }
+            }
+            return;
+        }
+        if let ExprKind::Binary(ref cmp, ref left, _) = expr.kind {
+            let op = cmp.node;
+            if op.is_comparison() && is_unit(cx.typeck_results().expr_ty(left)) {
+                let result = match op {
+                    BinOpKind::Eq | BinOpKind::Le | BinOpKind::Ge => "true",
+                    _ => "false",
+                };
+                span_lint(
+                    cx,
+                    UNIT_CMP,
+                    expr.span,
+                    &format!(
+                        "{}-comparison of unit values detected. This will always be {}",
+                        op.as_str(),
+                        result
+                    ),
+                );
+            }
+        }
+    }
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for passing a unit value as an argument to a function without using a
+    /// unit literal (`()`).
+    ///
+    /// **Why is this bad?** This is likely the result of an accidental semicolon.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// ```rust,ignore
+    /// foo({
+    ///     let a = bar();
+    ///     baz(a);
+    /// })
+    /// ```
+    pub UNIT_ARG,
+    complexity,
+    "passing unit to a function"
+}
+
+declare_lint_pass!(UnitArg => [UNIT_ARG]);
+
+impl<'tcx> LateLintPass<'tcx> for UnitArg {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        if expr.span.from_expansion() {
+            return;
+        }
+
+        // apparently stuff in the desugaring of `?` can trigger this
+        // so check for that here
+        // only the calls to `Try::from_error` is marked as desugared,
+        // so we need to check both the current Expr and its parent.
+        if is_questionmark_desugar_marked_call(expr) {
+            return;
+        }
+        if_chain! {
+            let map = &cx.tcx.hir();
+            let opt_parent_node = map.find(map.get_parent_node(expr.hir_id));
+            if let Some(hir::Node::Expr(parent_expr)) = opt_parent_node;
+            if is_questionmark_desugar_marked_call(parent_expr);
+            then {
+                return;
+            }
+        }
+
+        match expr.kind {
+            ExprKind::Call(_, args) | ExprKind::MethodCall(_, _, args, _) => {
+                let args_to_recover = args
+                    .iter()
+                    .filter(|arg| {
+                        if is_unit(cx.typeck_results().expr_ty(arg)) && !is_unit_literal(arg) {
+                            !matches!(
+                                &arg.kind,
+                                ExprKind::Match(.., MatchSource::TryDesugar) | ExprKind::Path(..)
+                            )
+                        } else {
+                            false
+                        }
+                    })
+                    .collect::<Vec<_>>();
+                if !args_to_recover.is_empty() {
+                    lint_unit_args(cx, expr, &args_to_recover);
+                }
+            },
+            _ => (),
+        }
+    }
+}
+
+fn fmt_stmts_and_call(
+    cx: &LateContext<'_>,
+    call_expr: &Expr<'_>,
+    call_snippet: &str,
+    args_snippets: &[impl AsRef<str>],
+    non_empty_block_args_snippets: &[impl AsRef<str>],
+) -> String {
+    let call_expr_indent = indent_of(cx, call_expr.span).unwrap_or(0);
+    let call_snippet_with_replacements = args_snippets
+        .iter()
+        .fold(call_snippet.to_owned(), |acc, arg| acc.replacen(arg.as_ref(), "()", 1));
+
+    let mut stmts_and_call = non_empty_block_args_snippets
+        .iter()
+        .map(|it| it.as_ref().to_owned())
+        .collect::<Vec<_>>();
+    stmts_and_call.push(call_snippet_with_replacements);
+    stmts_and_call = stmts_and_call
+        .into_iter()
+        .map(|v| reindent_multiline(v.into(), true, Some(call_expr_indent)).into_owned())
+        .collect();
+
+    let mut stmts_and_call_snippet = stmts_and_call.join(&format!("{}{}", ";\n", " ".repeat(call_expr_indent)));
+    // expr is not in a block statement or result expression position, wrap in a block
+    let parent_node = cx.tcx.hir().find(cx.tcx.hir().get_parent_node(call_expr.hir_id));
+    if !matches!(parent_node, Some(Node::Block(_))) && !matches!(parent_node, Some(Node::Stmt(_))) {
+        let block_indent = call_expr_indent + 4;
+        stmts_and_call_snippet =
+            reindent_multiline(stmts_and_call_snippet.into(), true, Some(block_indent)).into_owned();
+        stmts_and_call_snippet = format!(
+            "{{\n{}{}\n{}}}",
+            " ".repeat(block_indent),
+            &stmts_and_call_snippet,
+            " ".repeat(call_expr_indent)
+        );
+    }
+    stmts_and_call_snippet
+}
+
+fn lint_unit_args(cx: &LateContext<'_>, expr: &Expr<'_>, args_to_recover: &[&Expr<'_>]) {
+    let mut applicability = Applicability::MachineApplicable;
+    let (singular, plural) = if args_to_recover.len() > 1 {
+        ("", "s")
+    } else {
+        ("a ", "")
+    };
+    span_lint_and_then(
+        cx,
+        UNIT_ARG,
+        expr.span,
+        &format!("passing {}unit value{} to a function", singular, plural),
+        |db| {
+            let mut or = "";
+            args_to_recover
+                .iter()
+                .filter_map(|arg| {
+                    if_chain! {
+                        if let ExprKind::Block(block, _) = arg.kind;
+                        if block.expr.is_none();
+                        if let Some(last_stmt) = block.stmts.iter().last();
+                        if let StmtKind::Semi(last_expr) = last_stmt.kind;
+                        if let Some(snip) = snippet_opt(cx, last_expr.span);
+                        then {
+                            Some((
+                                last_stmt.span,
+                                snip,
+                            ))
+                        }
+                        else {
+                            None
+                        }
+                    }
+                })
+                .for_each(|(span, sugg)| {
+                    db.span_suggestion(
+                        span,
+                        "remove the semicolon from the last statement in the block",
+                        sugg,
+                        Applicability::MaybeIncorrect,
+                    );
+                    or = "or ";
+                    applicability = Applicability::MaybeIncorrect;
+                });
+
+            let arg_snippets: Vec<String> = args_to_recover
+                .iter()
+                .filter_map(|arg| snippet_opt(cx, arg.span))
+                .collect();
+            let arg_snippets_without_empty_blocks: Vec<String> = args_to_recover
+                .iter()
+                .filter(|arg| !is_empty_block(arg))
+                .filter_map(|arg| snippet_opt(cx, arg.span))
+                .collect();
+
+            if let Some(call_snippet) = snippet_opt(cx, expr.span) {
+                let sugg = fmt_stmts_and_call(
+                    cx,
+                    expr,
+                    &call_snippet,
+                    &arg_snippets,
+                    &arg_snippets_without_empty_blocks,
+                );
+
+                if arg_snippets_without_empty_blocks.is_empty() {
+                    db.multipart_suggestion(
+                        &format!("use {}unit literal{} instead", singular, plural),
+                        args_to_recover
+                            .iter()
+                            .map(|arg| (arg.span, "()".to_string()))
+                            .collect::<Vec<_>>(),
+                        applicability,
+                    );
+                } else {
+                    let plural = arg_snippets_without_empty_blocks.len() > 1;
+                    let empty_or_s = if plural { "s" } else { "" };
+                    let it_or_them = if plural { "them" } else { "it" };
+                    db.span_suggestion(
+                        expr.span,
+                        &format!(
+                            "{}move the expression{} in front of the call and replace {} with the unit literal `()`",
+                            or, empty_or_s, it_or_them
+                        ),
+                        sugg,
+                        applicability,
+                    );
+                }
+            }
+        },
+    );
+}
+
+fn is_empty_block(expr: &Expr<'_>) -> bool {
+    matches!(
+        expr.kind,
+        ExprKind::Block(
+            Block {
+                stmts: &[],
+                expr: None,
+                ..
+            },
+            _,
+        )
+    )
+}
+
+fn is_questionmark_desugar_marked_call(expr: &Expr<'_>) -> bool {
+    use rustc_span::hygiene::DesugaringKind;
+    if let ExprKind::Call(ref callee, _) = expr.kind {
+        callee.span.is_desugaring(DesugaringKind::QuestionMark)
+    } else {
+        false
+    }
+}
+
+fn is_unit(ty: Ty<'_>) -> bool {
+    matches!(ty.kind(), ty::Tuple(slice) if slice.is_empty())
+}
+
+fn is_unit_literal(expr: &Expr<'_>) -> bool {
+    matches!(expr.kind, ExprKind::Tup(ref slice) if slice.is_empty())
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for casts from any numerical to a float type where
+    /// the receiving type cannot store all values from the original type without
+    /// rounding errors. This possible rounding is to be expected, so this lint is
+    /// `Allow` by default.
+    ///
+    /// Basically, this warns on casting any integer with 32 or more bits to `f32`
+    /// or any 64-bit integer to `f64`.
+    ///
+    /// **Why is this bad?** It's not bad at all. But in some applications it can be
+    /// helpful to know where precision loss can take place. This lint can help find
+    /// those places in the code.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// ```rust
+    /// let x = u64::MAX;
+    /// x as f64;
+    /// ```
+    pub CAST_PRECISION_LOSS,
+    pedantic,
+    "casts that cause loss of precision, e.g., `x as f32` where `x: u64`"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for casts from a signed to an unsigned numerical
+    /// type. In this case, negative values wrap around to large positive values,
+    /// which can be quite surprising in practice. However, as the cast works as
+    /// defined, this lint is `Allow` by default.
+    ///
+    /// **Why is this bad?** Possibly surprising results. You can activate this lint
+    /// as a one-time check to see where numerical wrapping can arise.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// ```rust
+    /// let y: i8 = -1;
+    /// y as u128; // will return 18446744073709551615
+    /// ```
+    pub CAST_SIGN_LOSS,
+    pedantic,
+    "casts from signed types to unsigned types, e.g., `x as u32` where `x: i32`"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for casts between numerical types that may
+    /// truncate large values. This is expected behavior, so the cast is `Allow` by
+    /// default.
+    ///
+    /// **Why is this bad?** In some problem domains, it is good practice to avoid
+    /// truncation. This lint can be activated to help assess where additional
+    /// checks could be beneficial.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// ```rust
+    /// fn as_u8(x: u64) -> u8 {
+    ///     x as u8
+    /// }
+    /// ```
+    pub CAST_POSSIBLE_TRUNCATION,
+    pedantic,
+    "casts that may cause truncation of the value, e.g., `x as u8` where `x: u32`, or `x as i32` where `x: f32`"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for casts from an unsigned type to a signed type of
+    /// the same size. Performing such a cast is a 'no-op' for the compiler,
+    /// i.e., nothing is changed at the bit level, and the binary representation of
+    /// the value is reinterpreted. This can cause wrapping if the value is too big
+    /// for the target signed type. However, the cast works as defined, so this lint
+    /// is `Allow` by default.
+    ///
+    /// **Why is this bad?** While such a cast is not bad in itself, the results can
+    /// be surprising when this is not the intended behavior, as demonstrated by the
+    /// example below.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// ```rust
+    /// u32::MAX as i32; // will yield a value of `-1`
+    /// ```
+    pub CAST_POSSIBLE_WRAP,
+    pedantic,
+    "casts that may cause wrapping around the value, e.g., `x as i32` where `x: u32` and `x > i32::MAX`"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for casts between numerical types that may
+    /// be replaced by safe conversion functions.
+    ///
+    /// **Why is this bad?** Rust's `as` keyword will perform many kinds of
+    /// conversions, including silently lossy conversions. Conversion functions such
+    /// as `i32::from` will only perform lossless conversions. Using the conversion
+    /// functions prevents conversions from turning into silent lossy conversions if
+    /// the types of the input expressions ever change, and make it easier for
+    /// people reading the code to know that the conversion is lossless.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// ```rust
+    /// fn as_u64(x: u8) -> u64 {
+    ///     x as u64
+    /// }
+    /// ```
+    ///
+    /// Using `::from` would look like this:
+    ///
+    /// ```rust
+    /// fn as_u64(x: u8) -> u64 {
+    ///     u64::from(x)
+    /// }
+    /// ```
+    pub CAST_LOSSLESS,
+    pedantic,
+    "casts using `as` that are known to be lossless, e.g., `x as u64` where `x: u8`"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for casts to the same type, casts of int literals to integer types
+    /// and casts of float literals to float types.
+    ///
+    /// **Why is this bad?** It's just unnecessary.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// ```rust
+    /// let _ = 2i32 as i32;
+    /// let _ = 0.5 as f32;
+    /// ```
+    ///
+    /// Better:
+    ///
+    /// ```rust
+    /// let _ = 2_i32;
+    /// let _ = 0.5_f32;
+    /// ```
+    pub UNNECESSARY_CAST,
+    complexity,
+    "cast to the same type, e.g., `x as i32` where `x: i32`"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for casts, using `as` or `pointer::cast`,
+    /// from a less-strictly-aligned pointer to a more-strictly-aligned pointer
+    ///
+    /// **Why is this bad?** Dereferencing the resulting pointer may be undefined
+    /// behavior.
+    ///
+    /// **Known problems:** Using `std::ptr::read_unaligned` and `std::ptr::write_unaligned` or similar
+    /// on the resulting pointer is fine. Is over-zealous: Casts with manual alignment checks or casts like
+    /// u64-> u8 -> u16 can be fine. Miri is able to do a more in-depth analysis.
+    ///
+    /// **Example:**
+    /// ```rust
+    /// let _ = (&1u8 as *const u8) as *const u16;
+    /// let _ = (&mut 1u8 as *mut u8) as *mut u16;
+    ///
+    /// (&1u8 as *const u8).cast::<u16>();
+    /// (&mut 1u8 as *mut u8).cast::<u16>();
+    /// ```
+    pub CAST_PTR_ALIGNMENT,
+    pedantic,
+    "cast from a pointer to a more-strictly-aligned pointer"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for casts of function pointers to something other than usize
+    ///
+    /// **Why is this bad?**
+    /// Casting a function pointer to anything other than usize/isize is not portable across
+    /// architectures, because you end up losing bits if the target type is too small or end up with a
+    /// bunch of extra bits that waste space and add more instructions to the final binary than
+    /// strictly necessary for the problem
+    ///
+    /// Casting to isize also doesn't make sense since there are no signed addresses.
+    ///
+    /// **Example**
+    ///
+    /// ```rust
+    /// // Bad
+    /// fn fun() -> i32 { 1 }
+    /// let a = fun as i64;
+    ///
+    /// // Good
+    /// fn fun2() -> i32 { 1 }
+    /// let a = fun2 as usize;
+    /// ```
+    pub FN_TO_NUMERIC_CAST,
+    style,
+    "casting a function pointer to a numeric type other than usize"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for casts of a function pointer to a numeric type not wide enough to
+    /// store address.
+    ///
+    /// **Why is this bad?**
+    /// Such a cast discards some bits of the function's address. If this is intended, it would be more
+    /// clearly expressed by casting to usize first, then casting the usize to the intended type (with
+    /// a comment) to perform the truncation.
+    ///
+    /// **Example**
+    ///
+    /// ```rust
+    /// // Bad
+    /// fn fn1() -> i16 {
+    ///     1
+    /// };
+    /// let _ = fn1 as i32;
+    ///
+    /// // Better: Cast to usize first, then comment with the reason for the truncation
+    /// fn fn2() -> i16 {
+    ///     1
+    /// };
+    /// let fn_ptr = fn2 as usize;
+    /// let fn_ptr_truncated = fn_ptr as i32;
+    /// ```
+    pub FN_TO_NUMERIC_CAST_WITH_TRUNCATION,
+    style,
+    "casting a function pointer to a numeric type not wide enough to store the address"
+}
+
+/// Returns the size in bits of an integral type.
+/// Will return 0 if the type is not an int or uint variant
+fn int_ty_to_nbits(typ: Ty<'_>, tcx: TyCtxt<'_>) -> u64 {
+    match typ.kind() {
+        ty::Int(i) => match i {
+            IntTy::Isize => tcx.data_layout.pointer_size.bits(),
+            IntTy::I8 => 8,
+            IntTy::I16 => 16,
+            IntTy::I32 => 32,
+            IntTy::I64 => 64,
+            IntTy::I128 => 128,
+        },
+        ty::Uint(i) => match i {
+            UintTy::Usize => tcx.data_layout.pointer_size.bits(),
+            UintTy::U8 => 8,
+            UintTy::U16 => 16,
+            UintTy::U32 => 32,
+            UintTy::U64 => 64,
+            UintTy::U128 => 128,
+        },
+        _ => 0,
+    }
+}
+
+fn is_isize_or_usize(typ: Ty<'_>) -> bool {
+    matches!(typ.kind(), ty::Int(IntTy::Isize) | ty::Uint(UintTy::Usize))
+}
+
+fn span_precision_loss_lint(cx: &LateContext<'_>, expr: &Expr<'_>, cast_from: Ty<'_>, cast_to_f64: bool) {
+    let mantissa_nbits = if cast_to_f64 { 52 } else { 23 };
+    let arch_dependent = is_isize_or_usize(cast_from) && cast_to_f64;
+    let arch_dependent_str = "on targets with 64-bit wide pointers ";
+    let from_nbits_str = if arch_dependent {
+        "64".to_owned()
+    } else if is_isize_or_usize(cast_from) {
+        "32 or 64".to_owned()
+    } else {
+        int_ty_to_nbits(cast_from, cx.tcx).to_string()
+    };
+    span_lint(
+        cx,
+        CAST_PRECISION_LOSS,
+        expr.span,
+        &format!(
+            "casting `{0}` to `{1}` causes a loss of precision {2}(`{0}` is {3} bits wide, \
+             but `{1}`'s mantissa is only {4} bits wide)",
+            cast_from,
+            if cast_to_f64 { "f64" } else { "f32" },
+            if arch_dependent { arch_dependent_str } else { "" },
+            from_nbits_str,
+            mantissa_nbits
+        ),
+    );
+}
+
+fn should_strip_parens(op: &Expr<'_>, snip: &str) -> bool {
+    if let ExprKind::Binary(_, _, _) = op.kind {
+        if snip.starts_with('(') && snip.ends_with(')') {
+            return true;
+        }
+    }
+    false
+}
+
+fn span_lossless_lint(cx: &LateContext<'_>, expr: &Expr<'_>, op: &Expr<'_>, cast_from: Ty<'_>, cast_to: Ty<'_>) {
+    // Do not suggest using From in consts/statics until it is valid to do so (see #2267).
+    if in_constant(cx, expr.hir_id) {
+        return;
+    }
+    // The suggestion is to use a function call, so if the original expression
+    // has parens on the outside, they are no longer needed.
+    let mut applicability = Applicability::MachineApplicable;
+    let opt = snippet_opt(cx, op.span);
+    let sugg = opt.as_ref().map_or_else(
+        || {
+            applicability = Applicability::HasPlaceholders;
+            ".."
+        },
+        |snip| {
+            if should_strip_parens(op, snip) {
+                &snip[1..snip.len() - 1]
+            } else {
+                snip.as_str()
+            }
+        },
+    );
+
+    span_lint_and_sugg(
+        cx,
+        CAST_LOSSLESS,
+        expr.span,
+        &format!(
+            "casting `{}` to `{}` may become silently lossy if you later change the type",
+            cast_from, cast_to
+        ),
+        "try",
+        format!("{}::from({})", cast_to, sugg),
+        applicability,
+    );
+}
+
+enum ArchSuffix {
+    _32,
+    _64,
+    None,
+}
+
+fn check_loss_of_sign(cx: &LateContext<'_>, expr: &Expr<'_>, op: &Expr<'_>, cast_from: Ty<'_>, cast_to: Ty<'_>) {
+    if !cast_from.is_signed() || cast_to.is_signed() {
+        return;
+    }
+
+    // don't lint for positive constants
+    let const_val = constant(cx, &cx.typeck_results(), op);
+    if_chain! {
+        if let Some((Constant::Int(n), _)) = const_val;
+        if let ty::Int(ity) = *cast_from.kind();
+        if sext(cx.tcx, n, ity) >= 0;
+        then {
+            return
+        }
+    }
+
+    // don't lint for the result of methods that always return non-negative values
+    if let ExprKind::MethodCall(ref path, _, _, _) = op.kind {
+        let mut method_name = path.ident.name.as_str();
+        let allowed_methods = ["abs", "checked_abs", "rem_euclid", "checked_rem_euclid"];
+
+        if_chain! {
+            if method_name == "unwrap";
+            if let Some(arglist) = method_chain_args(op, &["unwrap"]);
+            if let ExprKind::MethodCall(ref inner_path, _, _, _) = &arglist[0][0].kind;
+            then {
+                method_name = inner_path.ident.name.as_str();
+            }
+        }
+
+        if allowed_methods.iter().any(|&name| method_name == name) {
+            return;
+        }
+    }
+
+    span_lint(
+        cx,
+        CAST_SIGN_LOSS,
+        expr.span,
+        &format!(
+            "casting `{}` to `{}` may lose the sign of the value",
+            cast_from, cast_to
+        ),
+    );
+}
+
+fn check_truncation_and_wrapping(cx: &LateContext<'_>, expr: &Expr<'_>, cast_from: Ty<'_>, cast_to: Ty<'_>) {
+    let arch_64_suffix = " on targets with 64-bit wide pointers";
+    let arch_32_suffix = " on targets with 32-bit wide pointers";
+    let cast_unsigned_to_signed = !cast_from.is_signed() && cast_to.is_signed();
+    let from_nbits = int_ty_to_nbits(cast_from, cx.tcx);
+    let to_nbits = int_ty_to_nbits(cast_to, cx.tcx);
+    let (span_truncation, suffix_truncation, span_wrap, suffix_wrap) =
+        match (is_isize_or_usize(cast_from), is_isize_or_usize(cast_to)) {
+            (true, true) | (false, false) => (
+                to_nbits < from_nbits,
+                ArchSuffix::None,
+                to_nbits == from_nbits && cast_unsigned_to_signed,
+                ArchSuffix::None,
+            ),
+            (true, false) => (
+                to_nbits <= 32,
+                if to_nbits == 32 {
+                    ArchSuffix::_64
+                } else {
+                    ArchSuffix::None
+                },
+                to_nbits <= 32 && cast_unsigned_to_signed,
+                ArchSuffix::_32,
+            ),
+            (false, true) => (
+                from_nbits == 64,
+                ArchSuffix::_32,
+                cast_unsigned_to_signed,
+                if from_nbits == 64 {
+                    ArchSuffix::_64
+                } else {
+                    ArchSuffix::_32
+                },
+            ),
+        };
+    if span_truncation {
+        span_lint(
+            cx,
+            CAST_POSSIBLE_TRUNCATION,
+            expr.span,
+            &format!(
+                "casting `{}` to `{}` may truncate the value{}",
+                cast_from,
+                cast_to,
+                match suffix_truncation {
+                    ArchSuffix::_32 => arch_32_suffix,
+                    ArchSuffix::_64 => arch_64_suffix,
+                    ArchSuffix::None => "",
+                }
+            ),
+        );
+    }
+    if span_wrap {
+        span_lint(
+            cx,
+            CAST_POSSIBLE_WRAP,
+            expr.span,
+            &format!(
+                "casting `{}` to `{}` may wrap around the value{}",
+                cast_from,
+                cast_to,
+                match suffix_wrap {
+                    ArchSuffix::_32 => arch_32_suffix,
+                    ArchSuffix::_64 => arch_64_suffix,
+                    ArchSuffix::None => "",
+                }
+            ),
+        );
+    }
+}
+
+fn check_lossless(cx: &LateContext<'_>, expr: &Expr<'_>, op: &Expr<'_>, cast_from: Ty<'_>, cast_to: Ty<'_>) {
+    let cast_signed_to_unsigned = cast_from.is_signed() && !cast_to.is_signed();
+    let from_nbits = int_ty_to_nbits(cast_from, cx.tcx);
+    let to_nbits = int_ty_to_nbits(cast_to, cx.tcx);
+    if !is_isize_or_usize(cast_from) && !is_isize_or_usize(cast_to) && from_nbits < to_nbits && !cast_signed_to_unsigned
+    {
+        span_lossless_lint(cx, expr, op, cast_from, cast_to);
+    }
+}
+
+declare_lint_pass!(Casts => [
+    CAST_PRECISION_LOSS,
+    CAST_SIGN_LOSS,
+    CAST_POSSIBLE_TRUNCATION,
+    CAST_POSSIBLE_WRAP,
+    CAST_LOSSLESS,
+    UNNECESSARY_CAST,
+    CAST_PTR_ALIGNMENT,
+    FN_TO_NUMERIC_CAST,
+    FN_TO_NUMERIC_CAST_WITH_TRUNCATION,
+]);
+
+// Check if the given type is either `core::ffi::c_void` or
+// one of the platform specific `libc::<platform>::c_void` of libc.
+fn is_c_void(cx: &LateContext<'_>, ty: Ty<'_>) -> bool {
+    if let ty::Adt(adt, _) = ty.kind() {
+        let names = cx.get_def_path(adt.did);
+
+        if names.is_empty() {
+            return false;
+        }
+        if names[0] == sym::libc || names[0] == sym::core && *names.last().unwrap() == sym!(c_void) {
+            return true;
+        }
+    }
+    false
+}
+
+/// Returns the mantissa bits wide of a fp type.
+/// Will return 0 if the type is not a fp
+fn fp_ty_mantissa_nbits(typ: Ty<'_>) -> u32 {
+    match typ.kind() {
+        ty::Float(FloatTy::F32) => 23,
+        ty::Float(FloatTy::F64) | ty::Infer(InferTy::FloatVar(_)) => 52,
+        _ => 0,
+    }
+}
+
+impl<'tcx> LateLintPass<'tcx> for Casts {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        if expr.span.from_expansion() {
+            return;
+        }
+        if let ExprKind::Cast(ref ex, cast_to) = expr.kind {
+            if is_hir_ty_cfg_dependant(cx, cast_to) {
+                return;
+            }
+            let (cast_from, cast_to) = (cx.typeck_results().expr_ty(ex), cx.typeck_results().expr_ty(expr));
+            lint_fn_to_numeric_cast(cx, expr, ex, cast_from, cast_to);
+            if let Some(lit) = get_numeric_literal(ex) {
+                let literal_str = snippet_opt(cx, ex.span).unwrap_or_default();
+
+                if_chain! {
+                    if let LitKind::Int(n, _) = lit.node;
+                    if let Some(src) = snippet_opt(cx, lit.span);
+                    if cast_to.is_floating_point();
+                    if let Some(num_lit) = NumericLiteral::from_lit_kind(&src, &lit.node);
+                    let from_nbits = 128 - n.leading_zeros();
+                    let to_nbits = fp_ty_mantissa_nbits(cast_to);
+                    if from_nbits != 0 && to_nbits != 0 && from_nbits <= to_nbits && num_lit.is_decimal();
+                    then {
+                        let literal_str = if is_unary_neg(ex) { format!("-{}", num_lit.integer) } else { num_lit.integer.into() };
+                        show_unnecessary_cast(cx, expr, &literal_str, cast_from, cast_to);
+                        return;
+                    }
+                }
+
+                match lit.node {
+                    LitKind::Int(_, LitIntType::Unsuffixed) if cast_to.is_integral() => {
+                        show_unnecessary_cast(cx, expr, &literal_str, cast_from, cast_to);
+                    },
+                    LitKind::Float(_, LitFloatType::Unsuffixed) if cast_to.is_floating_point() => {
+                        show_unnecessary_cast(cx, expr, &literal_str, cast_from, cast_to);
+                    },
+                    LitKind::Int(_, LitIntType::Unsuffixed) | LitKind::Float(_, LitFloatType::Unsuffixed) => {},
+                    _ => {
+                        if cast_from.kind() == cast_to.kind() && !in_external_macro(cx.sess(), expr.span) {
+                            span_lint(
+                                cx,
+                                UNNECESSARY_CAST,
+                                expr.span,
+                                &format!(
+                                    "casting to the same type is unnecessary (`{}` -> `{}`)",
+                                    cast_from, cast_to
+                                ),
+                            );
+                        }
+                    },
+                }
+            }
+            if cast_from.is_numeric() && cast_to.is_numeric() && !in_external_macro(cx.sess(), expr.span) {
+                lint_numeric_casts(cx, expr, ex, cast_from, cast_to);
+            }
+
+            lint_cast_ptr_alignment(cx, expr, cast_from, cast_to);
+        } else if let ExprKind::MethodCall(method_path, _, args, _) = expr.kind {
+            if_chain! {
+            if method_path.ident.name == sym!(cast);
+            if let Some(generic_args) = method_path.args;
+            if let [GenericArg::Type(cast_to)] = generic_args.args;
+            // There probably is no obvious reason to do this, just to be consistent with `as` cases.
+            if !is_hir_ty_cfg_dependant(cx, cast_to);
+            then {
+                let (cast_from, cast_to) =
+                    (cx.typeck_results().expr_ty(&args[0]), cx.typeck_results().expr_ty(expr));
+                lint_cast_ptr_alignment(cx, expr, cast_from, cast_to);
+            }
+            }
+        }
+    }
+}
+
+fn is_unary_neg(expr: &Expr<'_>) -> bool {
+    matches!(expr.kind, ExprKind::Unary(UnOp::Neg, _))
+}
+
+fn get_numeric_literal<'e>(expr: &'e Expr<'e>) -> Option<&'e Lit> {
+    match expr.kind {
+        ExprKind::Lit(ref lit) => Some(lit),
+        ExprKind::Unary(UnOp::Neg, e) => {
+            if let ExprKind::Lit(ref lit) = e.kind {
+                Some(lit)
+            } else {
+                None
+            }
+        },
+        _ => None,
+    }
+}
+
+fn show_unnecessary_cast(cx: &LateContext<'_>, expr: &Expr<'_>, literal_str: &str, cast_from: Ty<'_>, cast_to: Ty<'_>) {
+    let literal_kind_name = if cast_from.is_integral() { "integer" } else { "float" };
+    span_lint_and_sugg(
+        cx,
+        UNNECESSARY_CAST,
+        expr.span,
+        &format!("casting {} literal to `{}` is unnecessary", literal_kind_name, cast_to),
+        "try",
+        format!("{}_{}", literal_str.trim_end_matches('.'), cast_to),
+        Applicability::MachineApplicable,
+    );
+}
+
+fn lint_numeric_casts<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &Expr<'tcx>,
+    cast_expr: &Expr<'_>,
+    cast_from: Ty<'tcx>,
+    cast_to: Ty<'tcx>,
+) {
+    match (cast_from.is_integral(), cast_to.is_integral()) {
+        (true, false) => {
+            let from_nbits = int_ty_to_nbits(cast_from, cx.tcx);
+            let to_nbits = if let ty::Float(FloatTy::F32) = cast_to.kind() {
+                32
+            } else {
+                64
+            };
+            if is_isize_or_usize(cast_from) || from_nbits >= to_nbits {
+                span_precision_loss_lint(cx, expr, cast_from, to_nbits == 64);
+            }
+            if from_nbits < to_nbits {
+                span_lossless_lint(cx, expr, cast_expr, cast_from, cast_to);
+            }
+        },
+        (false, true) => {
+            span_lint(
+                cx,
+                CAST_POSSIBLE_TRUNCATION,
+                expr.span,
+                &format!("casting `{}` to `{}` may truncate the value", cast_from, cast_to),
+            );
+            if !cast_to.is_signed() {
+                span_lint(
+                    cx,
+                    CAST_SIGN_LOSS,
+                    expr.span,
+                    &format!(
+                        "casting `{}` to `{}` may lose the sign of the value",
+                        cast_from, cast_to
+                    ),
+                );
+            }
+        },
+        (true, true) => {
+            check_loss_of_sign(cx, expr, cast_expr, cast_from, cast_to);
+            check_truncation_and_wrapping(cx, expr, cast_from, cast_to);
+            check_lossless(cx, expr, cast_expr, cast_from, cast_to);
+        },
+        (false, false) => {
+            if let (&ty::Float(FloatTy::F64), &ty::Float(FloatTy::F32)) = (&cast_from.kind(), &cast_to.kind()) {
+                span_lint(
+                    cx,
+                    CAST_POSSIBLE_TRUNCATION,
+                    expr.span,
+                    "casting `f64` to `f32` may truncate the value",
+                );
+            }
+            if let (&ty::Float(FloatTy::F32), &ty::Float(FloatTy::F64)) = (&cast_from.kind(), &cast_to.kind()) {
+                span_lossless_lint(cx, expr, cast_expr, cast_from, cast_to);
+            }
+        },
+    }
+}
+
+fn lint_cast_ptr_alignment<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, cast_from: Ty<'tcx>, cast_to: Ty<'tcx>) {
+    if_chain! {
+        if let ty::RawPtr(from_ptr_ty) = &cast_from.kind();
+        if let ty::RawPtr(to_ptr_ty) = &cast_to.kind();
+        if let Ok(from_layout) = cx.layout_of(from_ptr_ty.ty);
+        if let Ok(to_layout) = cx.layout_of(to_ptr_ty.ty);
+        if from_layout.align.abi < to_layout.align.abi;
+        // with c_void, we inherently need to trust the user
+        if !is_c_void(cx, from_ptr_ty.ty);
+        // when casting from a ZST, we don't know enough to properly lint
+        if !from_layout.is_zst();
+        then {
+            span_lint(
+                cx,
+                CAST_PTR_ALIGNMENT,
+                expr.span,
+                &format!(
+                    "casting from `{}` to a more-strictly-aligned pointer (`{}`) ({} < {} bytes)",
+                    cast_from,
+                    cast_to,
+                    from_layout.align.abi.bytes(),
+                    to_layout.align.abi.bytes(),
+                ),
+            );
+        }
+    }
+}
+
+fn lint_fn_to_numeric_cast(
+    cx: &LateContext<'_>,
+    expr: &Expr<'_>,
+    cast_expr: &Expr<'_>,
+    cast_from: Ty<'_>,
+    cast_to: Ty<'_>,
+) {
+    // We only want to check casts to `ty::Uint` or `ty::Int`
+    match cast_to.kind() {
+        ty::Uint(_) | ty::Int(..) => { /* continue on */ },
+        _ => return,
+    }
+    match cast_from.kind() {
+        ty::FnDef(..) | ty::FnPtr(_) => {
+            let mut applicability = Applicability::MaybeIncorrect;
+            let from_snippet = snippet_with_applicability(cx, cast_expr.span, "x", &mut applicability);
+
+            let to_nbits = int_ty_to_nbits(cast_to, cx.tcx);
+            if to_nbits < cx.tcx.data_layout.pointer_size.bits() {
+                span_lint_and_sugg(
+                    cx,
+                    FN_TO_NUMERIC_CAST_WITH_TRUNCATION,
+                    expr.span,
+                    &format!(
+                        "casting function pointer `{}` to `{}`, which truncates the value",
+                        from_snippet, cast_to
+                    ),
+                    "try",
+                    format!("{} as usize", from_snippet),
+                    applicability,
+                );
+            } else if *cast_to.kind() != ty::Uint(UintTy::Usize) {
+                span_lint_and_sugg(
+                    cx,
+                    FN_TO_NUMERIC_CAST,
+                    expr.span,
+                    &format!("casting function pointer `{}` to `{}`", from_snippet, cast_to),
+                    "try",
+                    format!("{} as usize", from_snippet),
+                    applicability,
+                );
+            }
+        },
+        _ => {},
+    }
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for types used in structs, parameters and `let`
+    /// declarations above a certain complexity threshold.
+    ///
+    /// **Why is this bad?** Too complex types make the code less readable. Consider
+    /// using a `type` definition to simplify them.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// ```rust
+    /// # use std::rc::Rc;
+    /// struct Foo {
+    ///     inner: Rc<Vec<Vec<Box<(u32, u32, u32, u32)>>>>,
+    /// }
+    /// ```
+    pub TYPE_COMPLEXITY,
+    complexity,
+    "usage of very complex types that might be better factored into `type` definitions"
+}
+
+pub struct TypeComplexity {
+    threshold: u64,
+}
+
+impl TypeComplexity {
+    #[must_use]
+    pub fn new(threshold: u64) -> Self {
+        Self { threshold }
+    }
+}
+
+impl_lint_pass!(TypeComplexity => [TYPE_COMPLEXITY]);
+
+impl<'tcx> LateLintPass<'tcx> for TypeComplexity {
+    fn check_fn(
+        &mut self,
+        cx: &LateContext<'tcx>,
+        _: FnKind<'tcx>,
+        decl: &'tcx FnDecl<'_>,
+        _: &'tcx Body<'_>,
+        _: Span,
+        _: HirId,
+    ) {
+        self.check_fndecl(cx, decl);
+    }
+
+    fn check_struct_field(&mut self, cx: &LateContext<'tcx>, field: &'tcx hir::StructField<'_>) {
+        // enum variants are also struct fields now
+        self.check_type(cx, &field.ty);
+    }
+
+    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
+        match item.kind {
+            ItemKind::Static(ref ty, _, _) | ItemKind::Const(ref ty, _) => self.check_type(cx, ty),
+            // functions, enums, structs, impls and traits are covered
+            _ => (),
+        }
+    }
+
+    fn check_trait_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx TraitItem<'_>) {
+        match item.kind {
+            TraitItemKind::Const(ref ty, _) | TraitItemKind::Type(_, Some(ref ty)) => self.check_type(cx, ty),
+            TraitItemKind::Fn(FnSig { ref decl, .. }, TraitFn::Required(_)) => self.check_fndecl(cx, decl),
+            // methods with default impl are covered by check_fn
+            _ => (),
+        }
+    }
+
+    fn check_impl_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx ImplItem<'_>) {
+        match item.kind {
+            ImplItemKind::Const(ref ty, _) | ImplItemKind::TyAlias(ref ty) => self.check_type(cx, ty),
+            // methods are covered by check_fn
+            _ => (),
+        }
+    }
+
+    fn check_local(&mut self, cx: &LateContext<'tcx>, local: &'tcx Local<'_>) {
+        if let Some(ref ty) = local.ty {
+            self.check_type(cx, ty);
+        }
+    }
+}
+
+impl<'tcx> TypeComplexity {
+    fn check_fndecl(&self, cx: &LateContext<'tcx>, decl: &'tcx FnDecl<'_>) {
+        for arg in decl.inputs {
+            self.check_type(cx, arg);
+        }
+        if let FnRetTy::Return(ref ty) = decl.output {
+            self.check_type(cx, ty);
+        }
+    }
+
+    fn check_type(&self, cx: &LateContext<'_>, ty: &hir::Ty<'_>) {
+        if ty.span.from_expansion() {
+            return;
+        }
+        let score = {
+            let mut visitor = TypeComplexityVisitor { score: 0, nest: 1 };
+            visitor.visit_ty(ty);
+            visitor.score
+        };
+
+        if score > self.threshold {
+            span_lint(
+                cx,
+                TYPE_COMPLEXITY,
+                ty.span,
+                "very complex type used. Consider factoring parts into `type` definitions",
+            );
+        }
+    }
+}
+
+/// Walks a type and assigns a complexity score to it.
+struct TypeComplexityVisitor {
+    /// total complexity score of the type
+    score: u64,
+    /// current nesting level
+    nest: u64,
+}
+
+impl<'tcx> Visitor<'tcx> for TypeComplexityVisitor {
+    type Map = Map<'tcx>;
+
+    fn visit_ty(&mut self, ty: &'tcx hir::Ty<'_>) {
+        let (add_score, sub_nest) = match ty.kind {
+            // _, &x and *x have only small overhead; don't mess with nesting level
+            TyKind::Infer | TyKind::Ptr(..) | TyKind::Rptr(..) => (1, 0),
+
+            // the "normal" components of a type: named types, arrays/tuples
+            TyKind::Path(..) | TyKind::Slice(..) | TyKind::Tup(..) | TyKind::Array(..) => (10 * self.nest, 1),
+
+            // function types bring a lot of overhead
+            TyKind::BareFn(ref bare) if bare.abi == Abi::Rust => (50 * self.nest, 1),
+
+            TyKind::TraitObject(ref param_bounds, _) => {
+                let has_lifetime_parameters = param_bounds.iter().any(|bound| {
+                    bound
+                        .bound_generic_params
+                        .iter()
+                        .any(|gen| matches!(gen.kind, GenericParamKind::Lifetime { .. }))
+                });
+                if has_lifetime_parameters {
+                    // complex trait bounds like A<'a, 'b>
+                    (50 * self.nest, 1)
+                } else {
+                    // simple trait bounds like A + B
+                    (20 * self.nest, 0)
+                }
+            },
+
+            _ => (0, 0),
+        };
+        self.score += add_score;
+        self.nest += sub_nest;
+        walk_ty(self, ty);
+        self.nest -= sub_nest;
+    }
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::None
+    }
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for expressions where a character literal is cast
+    /// to `u8` and suggests using a byte literal instead.
+    ///
+    /// **Why is this bad?** In general, casting values to smaller types is
+    /// error-prone and should be avoided where possible. In the particular case of
+    /// converting a character literal to u8, it is easy to avoid by just using a
+    /// byte literal instead. As an added bonus, `b'a'` is even slightly shorter
+    /// than `'a' as u8`.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// ```rust,ignore
+    /// 'x' as u8
+    /// ```
+    ///
+    /// A better version, using the byte literal:
+    ///
+    /// ```rust,ignore
+    /// b'x'
+    /// ```
+    pub CHAR_LIT_AS_U8,
+    complexity,
+    "casting a character literal to `u8` truncates"
+}
+
+declare_lint_pass!(CharLitAsU8 => [CHAR_LIT_AS_U8]);
+
+impl<'tcx> LateLintPass<'tcx> for CharLitAsU8 {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        if_chain! {
+            if !expr.span.from_expansion();
+            if let ExprKind::Cast(e, _) = &expr.kind;
+            if let ExprKind::Lit(l) = &e.kind;
+            if let LitKind::Char(c) = l.node;
+            if ty::Uint(UintTy::U8) == *cx.typeck_results().expr_ty(expr).kind();
+            then {
+                let mut applicability = Applicability::MachineApplicable;
+                let snippet = snippet_with_applicability(cx, e.span, "'x'", &mut applicability);
+
+                span_lint_and_then(
+                    cx,
+                    CHAR_LIT_AS_U8,
+                    expr.span,
+                    "casting a character literal to `u8` truncates",
+                    |diag| {
+                        diag.note("`char` is four bytes wide, but `u8` is a single byte");
+
+                        if c.is_ascii() {
+                            diag.span_suggestion(
+                                expr.span,
+                                "use a byte literal instead",
+                                format!("b{}", snippet),
+                                applicability,
+                            );
+                        }
+                });
+            }
+        }
+    }
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for comparisons where one side of the relation is
+    /// either the minimum or maximum value for its type and warns if it involves a
+    /// case that is always true or always false. Only integer and boolean types are
+    /// checked.
+    ///
+    /// **Why is this bad?** An expression like `min <= x` may misleadingly imply
+    /// that it is possible for `x` to be less than the minimum. Expressions like
+    /// `max < x` are probably mistakes.
+    ///
+    /// **Known problems:** For `usize` the size of the current compile target will
+    /// be assumed (e.g., 64 bits on 64 bit systems). This means code that uses such
+    /// a comparison to detect target pointer width will trigger this lint. One can
+    /// use `mem::sizeof` and compare its value or conditional compilation
+    /// attributes
+    /// like `#[cfg(target_pointer_width = "64")] ..` instead.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// let vec: Vec<isize> = Vec::new();
+    /// if vec.len() <= 0 {}
+    /// if 100 > i32::MAX {}
+    /// ```
+    pub ABSURD_EXTREME_COMPARISONS,
+    correctness,
+    "a comparison with a maximum or minimum value that is always true or false"
+}
+
+declare_lint_pass!(AbsurdExtremeComparisons => [ABSURD_EXTREME_COMPARISONS]);
+
+enum ExtremeType {
+    Minimum,
+    Maximum,
+}
+
+struct ExtremeExpr<'a> {
+    which: ExtremeType,
+    expr: &'a Expr<'a>,
+}
+
+enum AbsurdComparisonResult {
+    AlwaysFalse,
+    AlwaysTrue,
+    InequalityImpossible,
+}
+
+fn is_cast_between_fixed_and_target<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
+    if let ExprKind::Cast(ref cast_exp, _) = expr.kind {
+        let precast_ty = cx.typeck_results().expr_ty(cast_exp);
+        let cast_ty = cx.typeck_results().expr_ty(expr);
+
+        return is_isize_or_usize(precast_ty) != is_isize_or_usize(cast_ty);
+    }
+
+    false
+}
+
+fn detect_absurd_comparison<'tcx>(
+    cx: &LateContext<'tcx>,
+    op: BinOpKind,
+    lhs: &'tcx Expr<'_>,
+    rhs: &'tcx Expr<'_>,
+) -> Option<(ExtremeExpr<'tcx>, AbsurdComparisonResult)> {
+    use crate::types::AbsurdComparisonResult::{AlwaysFalse, AlwaysTrue, InequalityImpossible};
+    use crate::types::ExtremeType::{Maximum, Minimum};
+    use crate::utils::comparisons::{normalize_comparison, Rel};
+
+    // absurd comparison only makes sense on primitive types
+    // primitive types don't implement comparison operators with each other
+    if cx.typeck_results().expr_ty(lhs) != cx.typeck_results().expr_ty(rhs) {
+        return None;
+    }
+
+    // comparisons between fix sized types and target sized types are considered unanalyzable
+    if is_cast_between_fixed_and_target(cx, lhs) || is_cast_between_fixed_and_target(cx, rhs) {
+        return None;
+    }
+
+    let (rel, normalized_lhs, normalized_rhs) = normalize_comparison(op, lhs, rhs)?;
+
+    let lx = detect_extreme_expr(cx, normalized_lhs);
+    let rx = detect_extreme_expr(cx, normalized_rhs);
+
+    Some(match rel {
+        Rel::Lt => {
+            match (lx, rx) {
+                (Some(l @ ExtremeExpr { which: Maximum, .. }), _) => (l, AlwaysFalse), // max < x
+                (_, Some(r @ ExtremeExpr { which: Minimum, .. })) => (r, AlwaysFalse), // x < min
+                _ => return None,
+            }
+        },
+        Rel::Le => {
+            match (lx, rx) {
+                (Some(l @ ExtremeExpr { which: Minimum, .. }), _) => (l, AlwaysTrue), // min <= x
+                (Some(l @ ExtremeExpr { which: Maximum, .. }), _) => (l, InequalityImpossible), // max <= x
+                (_, Some(r @ ExtremeExpr { which: Minimum, .. })) => (r, InequalityImpossible), // x <= min
+                (_, Some(r @ ExtremeExpr { which: Maximum, .. })) => (r, AlwaysTrue), // x <= max
+                _ => return None,
+            }
+        },
+        Rel::Ne | Rel::Eq => return None,
+    })
+}
+
+fn detect_extreme_expr<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<ExtremeExpr<'tcx>> {
+    use crate::types::ExtremeType::{Maximum, Minimum};
+
+    let ty = cx.typeck_results().expr_ty(expr);
+
+    let cv = constant(cx, cx.typeck_results(), expr)?.0;
+
+    let which = match (ty.kind(), cv) {
+        (&ty::Bool, Constant::Bool(false)) | (&ty::Uint(_), Constant::Int(0)) => Minimum,
+        (&ty::Int(ity), Constant::Int(i)) if i == unsext(cx.tcx, i128::MIN >> (128 - int_bits(cx.tcx, ity)), ity) => {
+            Minimum
+        },
+
+        (&ty::Bool, Constant::Bool(true)) => Maximum,
+        (&ty::Int(ity), Constant::Int(i)) if i == unsext(cx.tcx, i128::MAX >> (128 - int_bits(cx.tcx, ity)), ity) => {
+            Maximum
+        },
+        (&ty::Uint(uty), Constant::Int(i)) if clip(cx.tcx, u128::MAX, uty) == i => Maximum,
+
+        _ => return None,
+    };
+    Some(ExtremeExpr { which, expr })
+}
+
+impl<'tcx> LateLintPass<'tcx> for AbsurdExtremeComparisons {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        use crate::types::AbsurdComparisonResult::{AlwaysFalse, AlwaysTrue, InequalityImpossible};
+        use crate::types::ExtremeType::{Maximum, Minimum};
+
+        if let ExprKind::Binary(ref cmp, ref lhs, ref rhs) = expr.kind {
+            if let Some((culprit, result)) = detect_absurd_comparison(cx, cmp.node, lhs, rhs) {
+                if !expr.span.from_expansion() {
+                    let msg = "this comparison involving the minimum or maximum element for this \
+                               type contains a case that is always true or always false";
+
+                    let conclusion = match result {
+                        AlwaysFalse => "this comparison is always false".to_owned(),
+                        AlwaysTrue => "this comparison is always true".to_owned(),
+                        InequalityImpossible => format!(
+                            "the case where the two sides are not equal never occurs, consider using `{} == {}` \
+                             instead",
+                            snippet(cx, lhs.span, "lhs"),
+                            snippet(cx, rhs.span, "rhs")
+                        ),
+                    };
+
+                    let help = format!(
+                        "because `{}` is the {} value for this type, {}",
+                        snippet(cx, culprit.expr.span, "x"),
+                        match culprit.which {
+                            Minimum => "minimum",
+                            Maximum => "maximum",
+                        },
+                        conclusion
+                    );
+
+                    span_lint_and_help(cx, ABSURD_EXTREME_COMPARISONS, expr.span, msg, None, &help);
+                }
+            }
+        }
+    }
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for comparisons where the relation is always either
+    /// true or false, but where one side has been upcast so that the comparison is
+    /// necessary. Only integer types are checked.
+    ///
+    /// **Why is this bad?** An expression like `let x : u8 = ...; (x as u32) > 300`
+    /// will mistakenly imply that it is possible for `x` to be outside the range of
+    /// `u8`.
+    ///
+    /// **Known problems:**
+    /// https://github.com/rust-lang/rust-clippy/issues/886
+    ///
+    /// **Example:**
+    /// ```rust
+    /// let x: u8 = 1;
+    /// (x as u32) > 300;
+    /// ```
+    pub INVALID_UPCAST_COMPARISONS,
+    pedantic,
+    "a comparison involving an upcast which is always true or false"
+}
+
+declare_lint_pass!(InvalidUpcastComparisons => [INVALID_UPCAST_COMPARISONS]);
+
+#[derive(Copy, Clone, Debug, Eq)]
+enum FullInt {
+    S(i128),
+    U(u128),
+}
+
+impl FullInt {
+    #[allow(clippy::cast_sign_loss)]
+    #[must_use]
+    fn cmp_s_u(s: i128, u: u128) -> Ordering {
+        if s < 0 {
+            Ordering::Less
+        } else if u > (i128::MAX as u128) {
+            Ordering::Greater
+        } else {
+            (s as u128).cmp(&u)
+        }
+    }
+}
+
+impl PartialEq for FullInt {
+    #[must_use]
+    fn eq(&self, other: &Self) -> bool {
+        self.partial_cmp(other).expect("`partial_cmp` only returns `Some(_)`") == Ordering::Equal
+    }
+}
+
+impl PartialOrd for FullInt {
+    #[must_use]
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(match (self, other) {
+            (&Self::S(s), &Self::S(o)) => s.cmp(&o),
+            (&Self::U(s), &Self::U(o)) => s.cmp(&o),
+            (&Self::S(s), &Self::U(o)) => Self::cmp_s_u(s, o),
+            (&Self::U(s), &Self::S(o)) => Self::cmp_s_u(o, s).reverse(),
+        })
+    }
+}
+
+impl Ord for FullInt {
+    #[must_use]
+    fn cmp(&self, other: &Self) -> Ordering {
+        self.partial_cmp(other)
+            .expect("`partial_cmp` for FullInt can never return `None`")
+    }
+}
+
+fn numeric_cast_precast_bounds<'a>(cx: &LateContext<'_>, expr: &'a Expr<'_>) -> Option<(FullInt, FullInt)> {
+    if let ExprKind::Cast(ref cast_exp, _) = expr.kind {
+        let pre_cast_ty = cx.typeck_results().expr_ty(cast_exp);
+        let cast_ty = cx.typeck_results().expr_ty(expr);
+        // if it's a cast from i32 to u32 wrapping will invalidate all these checks
+        if cx.layout_of(pre_cast_ty).ok().map(|l| l.size) == cx.layout_of(cast_ty).ok().map(|l| l.size) {
+            return None;
+        }
+        match pre_cast_ty.kind() {
+            ty::Int(int_ty) => Some(match int_ty {
+                IntTy::I8 => (FullInt::S(i128::from(i8::MIN)), FullInt::S(i128::from(i8::MAX))),
+                IntTy::I16 => (FullInt::S(i128::from(i16::MIN)), FullInt::S(i128::from(i16::MAX))),
+                IntTy::I32 => (FullInt::S(i128::from(i32::MIN)), FullInt::S(i128::from(i32::MAX))),
+                IntTy::I64 => (FullInt::S(i128::from(i64::MIN)), FullInt::S(i128::from(i64::MAX))),
+                IntTy::I128 => (FullInt::S(i128::MIN), FullInt::S(i128::MAX)),
+                IntTy::Isize => (FullInt::S(isize::MIN as i128), FullInt::S(isize::MAX as i128)),
+            }),
+            ty::Uint(uint_ty) => Some(match uint_ty {
+                UintTy::U8 => (FullInt::U(u128::from(u8::MIN)), FullInt::U(u128::from(u8::MAX))),
+                UintTy::U16 => (FullInt::U(u128::from(u16::MIN)), FullInt::U(u128::from(u16::MAX))),
+                UintTy::U32 => (FullInt::U(u128::from(u32::MIN)), FullInt::U(u128::from(u32::MAX))),
+                UintTy::U64 => (FullInt::U(u128::from(u64::MIN)), FullInt::U(u128::from(u64::MAX))),
+                UintTy::U128 => (FullInt::U(u128::MIN), FullInt::U(u128::MAX)),
+                UintTy::Usize => (FullInt::U(usize::MIN as u128), FullInt::U(usize::MAX as u128)),
+            }),
+            _ => None,
+        }
+    } else {
+        None
+    }
+}
+
+fn node_as_const_fullint<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<FullInt> {
+    let val = constant(cx, cx.typeck_results(), expr)?.0;
+    if let Constant::Int(const_int) = val {
+        match *cx.typeck_results().expr_ty(expr).kind() {
+            ty::Int(ity) => Some(FullInt::S(sext(cx.tcx, const_int, ity))),
+            ty::Uint(_) => Some(FullInt::U(const_int)),
+            _ => None,
+        }
+    } else {
+        None
+    }
+}
+
+fn err_upcast_comparison(cx: &LateContext<'_>, span: Span, expr: &Expr<'_>, always: bool) {
+    if let ExprKind::Cast(ref cast_val, _) = expr.kind {
+        span_lint(
+            cx,
+            INVALID_UPCAST_COMPARISONS,
+            span,
+            &format!(
+                "because of the numeric bounds on `{}` prior to casting, this expression is always {}",
+                snippet(cx, cast_val.span, "the expression"),
+                if always { "true" } else { "false" },
+            ),
+        );
+    }
+}
+
+fn upcast_comparison_bounds_err<'tcx>(
+    cx: &LateContext<'tcx>,
+    span: Span,
+    rel: comparisons::Rel,
+    lhs_bounds: Option<(FullInt, FullInt)>,
+    lhs: &'tcx Expr<'_>,
+    rhs: &'tcx Expr<'_>,
+    invert: bool,
+) {
+    use crate::utils::comparisons::Rel;
+
+    if let Some((lb, ub)) = lhs_bounds {
+        if let Some(norm_rhs_val) = node_as_const_fullint(cx, rhs) {
+            if rel == Rel::Eq || rel == Rel::Ne {
+                if norm_rhs_val < lb || norm_rhs_val > ub {
+                    err_upcast_comparison(cx, span, lhs, rel == Rel::Ne);
+                }
+            } else if match rel {
+                Rel::Lt => {
+                    if invert {
+                        norm_rhs_val < lb
+                    } else {
+                        ub < norm_rhs_val
+                    }
+                },
+                Rel::Le => {
+                    if invert {
+                        norm_rhs_val <= lb
+                    } else {
+                        ub <= norm_rhs_val
+                    }
+                },
+                Rel::Eq | Rel::Ne => unreachable!(),
+            } {
+                err_upcast_comparison(cx, span, lhs, true)
+            } else if match rel {
+                Rel::Lt => {
+                    if invert {
+                        norm_rhs_val >= ub
+                    } else {
+                        lb >= norm_rhs_val
+                    }
+                },
+                Rel::Le => {
+                    if invert {
+                        norm_rhs_val > ub
+                    } else {
+                        lb > norm_rhs_val
+                    }
+                },
+                Rel::Eq | Rel::Ne => unreachable!(),
+            } {
+                err_upcast_comparison(cx, span, lhs, false)
+            }
+        }
+    }
+}
+
+impl<'tcx> LateLintPass<'tcx> for InvalidUpcastComparisons {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        if let ExprKind::Binary(ref cmp, ref lhs, ref rhs) = expr.kind {
+            let normalized = comparisons::normalize_comparison(cmp.node, lhs, rhs);
+            let (rel, normalized_lhs, normalized_rhs) = if let Some(val) = normalized {
+                val
+            } else {
+                return;
+            };
+
+            let lhs_bounds = numeric_cast_precast_bounds(cx, normalized_lhs);
+            let rhs_bounds = numeric_cast_precast_bounds(cx, normalized_rhs);
+
+            upcast_comparison_bounds_err(cx, expr.span, rel, lhs_bounds, normalized_lhs, normalized_rhs, false);
+            upcast_comparison_bounds_err(cx, expr.span, rel, rhs_bounds, normalized_rhs, normalized_lhs, true);
+        }
+    }
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for public `impl` or `fn` missing generalization
+    /// over different hashers and implicitly defaulting to the default hashing
+    /// algorithm (`SipHash`).
+    ///
+    /// **Why is this bad?** `HashMap` or `HashSet` with custom hashers cannot be
+    /// used with them.
+    ///
+    /// **Known problems:** Suggestions for replacing constructors can contain
+    /// false-positives. Also applying suggestions can require modification of other
+    /// pieces of code, possibly including external crates.
+    ///
+    /// **Example:**
+    /// ```rust
+    /// # use std::collections::HashMap;
+    /// # use std::hash::{Hash, BuildHasher};
+    /// # trait Serialize {};
+    /// impl<K: Hash + Eq, V> Serialize for HashMap<K, V> { }
+    ///
+    /// pub fn foo(map: &mut HashMap<i32, i32>) { }
+    /// ```
+    /// could be rewritten as
+    /// ```rust
+    /// # use std::collections::HashMap;
+    /// # use std::hash::{Hash, BuildHasher};
+    /// # trait Serialize {};
+    /// impl<K: Hash + Eq, V, S: BuildHasher> Serialize for HashMap<K, V, S> { }
+    ///
+    /// pub fn foo<S: BuildHasher>(map: &mut HashMap<i32, i32, S>) { }
+    /// ```
+    pub IMPLICIT_HASHER,
+    pedantic,
+    "missing generalization over different hashers"
+}
+
+declare_lint_pass!(ImplicitHasher => [IMPLICIT_HASHER]);
+
+impl<'tcx> LateLintPass<'tcx> for ImplicitHasher {
+    #[allow(clippy::cast_possible_truncation, clippy::too_many_lines)]
+    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
+        use rustc_span::BytePos;
+
+        fn suggestion<'tcx>(
+            cx: &LateContext<'tcx>,
+            diag: &mut DiagnosticBuilder<'_>,
+            generics_span: Span,
+            generics_suggestion_span: Span,
+            target: &ImplicitHasherType<'_>,
+            vis: ImplicitHasherConstructorVisitor<'_, '_, '_>,
+        ) {
+            let generics_snip = snippet(cx, generics_span, "");
+            // trim `<` `>`
+            let generics_snip = if generics_snip.is_empty() {
+                ""
+            } else {
+                &generics_snip[1..generics_snip.len() - 1]
+            };
+
+            multispan_sugg(
+                diag,
+                "consider adding a type parameter",
+                vec![
+                    (
+                        generics_suggestion_span,
+                        format!(
+                            "<{}{}S: ::std::hash::BuildHasher{}>",
+                            generics_snip,
+                            if generics_snip.is_empty() { "" } else { ", " },
+                            if vis.suggestions.is_empty() {
+                                ""
+                            } else {
+                                // request users to add `Default` bound so that generic constructors can be used
+                                " + Default"
+                            },
+                        ),
+                    ),
+                    (
+                        target.span(),
+                        format!("{}<{}, S>", target.type_name(), target.type_arguments(),),
+                    ),
+                ],
+            );
+
+            if !vis.suggestions.is_empty() {
+                multispan_sugg(diag, "...and use generic constructor", vis.suggestions);
+            }
+        }
+
+        if !cx.access_levels.is_exported(item.hir_id()) {
+            return;
+        }
+
+        match item.kind {
+            ItemKind::Impl(ref impl_) => {
+                let mut vis = ImplicitHasherTypeVisitor::new(cx);
+                vis.visit_ty(impl_.self_ty);
+
+                for target in &vis.found {
+                    if differing_macro_contexts(item.span, target.span()) {
+                        return;
+                    }
+
+                    let generics_suggestion_span = impl_.generics.span.substitute_dummy({
+                        let pos = snippet_opt(cx, item.span.until(target.span()))
+                            .and_then(|snip| Some(item.span.lo() + BytePos(snip.find("impl")? as u32 + 4)));
+                        if let Some(pos) = pos {
+                            Span::new(pos, pos, item.span.data().ctxt)
+                        } else {
+                            return;
+                        }
+                    });
+
+                    let mut ctr_vis = ImplicitHasherConstructorVisitor::new(cx, target);
+                    for item in impl_.items.iter().map(|item| cx.tcx.hir().impl_item(item.id)) {
+                        ctr_vis.visit_impl_item(item);
+                    }
+
+                    span_lint_and_then(
+                        cx,
+                        IMPLICIT_HASHER,
+                        target.span(),
+                        &format!(
+                            "impl for `{}` should be generalized over different hashers",
+                            target.type_name()
+                        ),
+                        move |diag| {
+                            suggestion(cx, diag, impl_.generics.span, generics_suggestion_span, target, ctr_vis);
+                        },
+                    );
+                }
+            },
+            ItemKind::Fn(ref sig, ref generics, body_id) => {
+                let body = cx.tcx.hir().body(body_id);
+
+                for ty in sig.decl.inputs {
+                    let mut vis = ImplicitHasherTypeVisitor::new(cx);
+                    vis.visit_ty(ty);
+
+                    for target in &vis.found {
+                        if in_external_macro(cx.sess(), generics.span) {
+                            continue;
+                        }
+                        let generics_suggestion_span = generics.span.substitute_dummy({
+                            let pos = snippet_opt(cx, item.span.until(body.params[0].pat.span))
+                                .and_then(|snip| {
+                                    let i = snip.find("fn")?;
+                                    Some(item.span.lo() + BytePos((i + (&snip[i..]).find('(')?) as u32))
+                                })
+                                .expect("failed to create span for type parameters");
+                            Span::new(pos, pos, item.span.data().ctxt)
+                        });
+
+                        let mut ctr_vis = ImplicitHasherConstructorVisitor::new(cx, target);
+                        ctr_vis.visit_body(body);
+
+                        span_lint_and_then(
+                            cx,
+                            IMPLICIT_HASHER,
+                            target.span(),
+                            &format!(
+                                "parameter of type `{}` should be generalized over different hashers",
+                                target.type_name()
+                            ),
+                            move |diag| {
+                                suggestion(cx, diag, generics.span, generics_suggestion_span, target, ctr_vis);
+                            },
+                        );
+                    }
+                }
+            },
+            _ => {},
+        }
+    }
+}
+
+enum ImplicitHasherType<'tcx> {
+    HashMap(Span, Ty<'tcx>, Cow<'static, str>, Cow<'static, str>),
+    HashSet(Span, Ty<'tcx>, Cow<'static, str>),
+}
+
+impl<'tcx> ImplicitHasherType<'tcx> {
+    /// Checks that `ty` is a target type without a `BuildHasher`.
+    fn new(cx: &LateContext<'tcx>, hir_ty: &hir::Ty<'_>) -> Option<Self> {
+        if let TyKind::Path(QPath::Resolved(None, ref path)) = hir_ty.kind {
+            let params: Vec<_> = path
+                .segments
+                .last()
+                .as_ref()?
+                .args
+                .as_ref()?
+                .args
+                .iter()
+                .filter_map(|arg| match arg {
+                    GenericArg::Type(ty) => Some(ty),
+                    _ => None,
+                })
+                .collect();
+            let params_len = params.len();
+
+            let ty = hir_ty_to_ty(cx.tcx, hir_ty);
+
+            if is_type_diagnostic_item(cx, ty, sym!(hashmap_type)) && params_len == 2 {
+                Some(ImplicitHasherType::HashMap(
+                    hir_ty.span,
+                    ty,
+                    snippet(cx, params[0].span, "K"),
+                    snippet(cx, params[1].span, "V"),
+                ))
+            } else if is_type_diagnostic_item(cx, ty, sym!(hashset_type)) && params_len == 1 {
+                Some(ImplicitHasherType::HashSet(
+                    hir_ty.span,
+                    ty,
+                    snippet(cx, params[0].span, "T"),
+                ))
+            } else {
+                None
+            }
+        } else {
+            None
+        }
+    }
+
+    fn type_name(&self) -> &'static str {
+        match *self {
+            ImplicitHasherType::HashMap(..) => "HashMap",
+            ImplicitHasherType::HashSet(..) => "HashSet",
+        }
+    }
+
+    fn type_arguments(&self) -> String {
+        match *self {
+            ImplicitHasherType::HashMap(.., ref k, ref v) => format!("{}, {}", k, v),
+            ImplicitHasherType::HashSet(.., ref t) => format!("{}", t),
+        }
+    }
+
+    fn ty(&self) -> Ty<'tcx> {
+        match *self {
+            ImplicitHasherType::HashMap(_, ty, ..) | ImplicitHasherType::HashSet(_, ty, ..) => ty,
+        }
+    }
+
+    fn span(&self) -> Span {
+        match *self {
+            ImplicitHasherType::HashMap(span, ..) | ImplicitHasherType::HashSet(span, ..) => span,
+        }
+    }
+}
+
+struct ImplicitHasherTypeVisitor<'a, 'tcx> {
+    cx: &'a LateContext<'tcx>,
+    found: Vec<ImplicitHasherType<'tcx>>,
+}
+
+impl<'a, 'tcx> ImplicitHasherTypeVisitor<'a, 'tcx> {
+    fn new(cx: &'a LateContext<'tcx>) -> Self {
+        Self { cx, found: vec![] }
+    }
+}
+
+impl<'a, 'tcx> Visitor<'tcx> for ImplicitHasherTypeVisitor<'a, 'tcx> {
+    type Map = Map<'tcx>;
+
+    fn visit_ty(&mut self, t: &'tcx hir::Ty<'_>) {
+        if let Some(target) = ImplicitHasherType::new(self.cx, t) {
+            self.found.push(target);
+        }
+
+        walk_ty(self, t);
+    }
+
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::None
+    }
+}
+
+/// Looks for default-hasher-dependent constructors like `HashMap::new`.
+struct ImplicitHasherConstructorVisitor<'a, 'b, 'tcx> {
+    cx: &'a LateContext<'tcx>,
+    maybe_typeck_results: Option<&'tcx TypeckResults<'tcx>>,
+    target: &'b ImplicitHasherType<'tcx>,
+    suggestions: BTreeMap<Span, String>,
+}
+
+impl<'a, 'b, 'tcx> ImplicitHasherConstructorVisitor<'a, 'b, 'tcx> {
+    fn new(cx: &'a LateContext<'tcx>, target: &'b ImplicitHasherType<'tcx>) -> Self {
+        Self {
+            cx,
+            maybe_typeck_results: cx.maybe_typeck_results(),
+            target,
+            suggestions: BTreeMap::new(),
+        }
+    }
+}
+
+impl<'a, 'b, 'tcx> Visitor<'tcx> for ImplicitHasherConstructorVisitor<'a, 'b, 'tcx> {
+    type Map = Map<'tcx>;
+
+    fn visit_body(&mut self, body: &'tcx Body<'_>) {
+        let old_maybe_typeck_results = self.maybe_typeck_results.replace(self.cx.tcx.typeck_body(body.id()));
+        walk_body(self, body);
+        self.maybe_typeck_results = old_maybe_typeck_results;
+    }
+
+    fn visit_expr(&mut self, e: &'tcx Expr<'_>) {
+        if_chain! {
+            if let ExprKind::Call(ref fun, ref args) = e.kind;
+            if let ExprKind::Path(QPath::TypeRelative(ref ty, ref method)) = fun.kind;
+            if let TyKind::Path(QPath::Resolved(None, ty_path)) = ty.kind;
+            then {
+                if !TyS::same_type(self.target.ty(), self.maybe_typeck_results.unwrap().expr_ty(e)) {
+                    return;
+                }
+
+                if match_path(ty_path, &paths::HASHMAP) {
+                    if method.ident.name == sym::new {
+                        self.suggestions
+                            .insert(e.span, "HashMap::default()".to_string());
+                    } else if method.ident.name == sym!(with_capacity) {
+                        self.suggestions.insert(
+                            e.span,
+                            format!(
+                                "HashMap::with_capacity_and_hasher({}, Default::default())",
+                                snippet(self.cx, args[0].span, "capacity"),
+                            ),
+                        );
+                    }
+                } else if match_path(ty_path, &paths::HASHSET) {
+                    if method.ident.name == sym::new {
+                        self.suggestions
+                            .insert(e.span, "HashSet::default()".to_string());
+                    } else if method.ident.name == sym!(with_capacity) {
+                        self.suggestions.insert(
+                            e.span,
+                            format!(
+                                "HashSet::with_capacity_and_hasher({}, Default::default())",
+                                snippet(self.cx, args[0].span, "capacity"),
+                            ),
+                        );
+                    }
+                }
+            }
+        }
+
+        walk_expr(self, e);
+    }
+
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::OnlyBodies(self.cx.tcx.hir())
+    }
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for casts of `&T` to `&mut T` anywhere in the code.
+    ///
+    /// **Why is this bad?** It’s basically guaranteed to be undefined behaviour.
+    /// `UnsafeCell` is the only way to obtain aliasable data that is considered
+    /// mutable.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// ```rust,ignore
+    /// fn x(r: &i32) {
+    ///     unsafe {
+    ///         *(r as *const _ as *mut _) += 1;
+    ///     }
+    /// }
+    /// ```
+    ///
+    /// Instead consider using interior mutability types.
+    ///
+    /// ```rust
+    /// use std::cell::UnsafeCell;
+    ///
+    /// fn x(r: &UnsafeCell<i32>) {
+    ///     unsafe {
+    ///         *r.get() += 1;
+    ///     }
+    /// }
+    /// ```
+    pub CAST_REF_TO_MUT,
+    correctness,
+    "a cast of reference to a mutable pointer"
+}
+
+declare_lint_pass!(RefToMut => [CAST_REF_TO_MUT]);
+
+impl<'tcx> LateLintPass<'tcx> for RefToMut {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        if_chain! {
+            if let ExprKind::Unary(UnOp::Deref, e) = &expr.kind;
+            if let ExprKind::Cast(e, t) = &e.kind;
+            if let TyKind::Ptr(MutTy { mutbl: Mutability::Mut, .. }) = t.kind;
+            if let ExprKind::Cast(e, t) = &e.kind;
+            if let TyKind::Ptr(MutTy { mutbl: Mutability::Not, .. }) = t.kind;
+            if let ty::Ref(..) = cx.typeck_results().node_type(e.hir_id).kind();
+            then {
+                span_lint(
+                    cx,
+                    CAST_REF_TO_MUT,
+                    expr.span,
+                    "casting `&T` to `&mut T` may cause undefined behavior, consider instead using an `UnsafeCell`",
+                );
+            }
+        }
+    }
+}
+
+const PTR_AS_PTR_MSRV: RustcVersion = RustcVersion::new(1, 38, 0);
+
+declare_clippy_lint! {
+    /// **What it does:**
+    /// Checks for `as` casts between raw pointers without changing its mutability,
+    /// namely `*const T` to `*const U` and `*mut T` to `*mut U`.
+    ///
+    /// **Why is this bad?**
+    /// Though `as` casts between raw pointers is not terrible, `pointer::cast` is safer because
+    /// it cannot accidentally change the pointer's mutability nor cast the pointer to other types like `usize`.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// let ptr: *const u32 = &42_u32;
+    /// let mut_ptr: *mut u32 = &mut 42_u32;
+    /// let _ = ptr as *const i32;
+    /// let _ = mut_ptr as *mut i32;
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// let ptr: *const u32 = &42_u32;
+    /// let mut_ptr: *mut u32 = &mut 42_u32;
+    /// let _ = ptr.cast::<i32>();
+    /// let _ = mut_ptr.cast::<i32>();
+    /// ```
+    pub PTR_AS_PTR,
+    pedantic,
+    "casting using `as` from and to raw pointers that doesn't change its mutability, where `pointer::cast` could take the place of `as`"
+}
+
+pub struct PtrAsPtr {
+    msrv: Option<RustcVersion>,
+}
+
+impl PtrAsPtr {
+    #[must_use]
+    pub fn new(msrv: Option<RustcVersion>) -> Self {
+        Self { msrv }
+    }
+}
+
+impl_lint_pass!(PtrAsPtr => [PTR_AS_PTR]);
+
+impl<'tcx> LateLintPass<'tcx> for PtrAsPtr {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        if !meets_msrv(self.msrv.as_ref(), &PTR_AS_PTR_MSRV) {
+            return;
+        }
+
+        if expr.span.from_expansion() {
+            return;
+        }
+
+        if_chain! {
+            if let ExprKind::Cast(cast_expr, cast_to_hir_ty) = expr.kind;
+            let (cast_from, cast_to) = (cx.typeck_results().expr_ty(cast_expr), cx.typeck_results().expr_ty(expr));
+            if let ty::RawPtr(TypeAndMut { mutbl: from_mutbl, .. }) = cast_from.kind();
+            if let ty::RawPtr(TypeAndMut { ty: to_pointee_ty, mutbl: to_mutbl }) = cast_to.kind();
+            if matches!((from_mutbl, to_mutbl),
+                (Mutability::Not, Mutability::Not) | (Mutability::Mut, Mutability::Mut));
+            // The `U` in `pointer::cast` have to be `Sized`
+            // as explained here: https://github.com/rust-lang/rust/issues/60602.
+            if to_pointee_ty.is_sized(cx.tcx.at(expr.span), cx.param_env);
+            then {
+                let mut applicability = Applicability::MachineApplicable;
+                let cast_expr_sugg = Sugg::hir_with_applicability(cx, cast_expr, "_", &mut applicability);
+                let turbofish = match &cast_to_hir_ty.kind {
+                        TyKind::Infer => Cow::Borrowed(""),
+                        TyKind::Ptr(mut_ty) if matches!(mut_ty.ty.kind, TyKind::Infer) => Cow::Borrowed(""),
+                        _ => Cow::Owned(format!("::<{}>", to_pointee_ty)),
+                    };
+                span_lint_and_sugg(
+                    cx,
+                    PTR_AS_PTR,
+                    expr.span,
+                    "`as` casting between raw pointers without changing its mutability",
+                    "try `pointer::cast`, a safer alternative",
+                    format!("{}.cast{}()", cast_expr_sugg.maybe_par(), turbofish),
+                    applicability,
+                );
+            }
+        }
+    }
+
+    extract_msrv_attr!(LateContext);
+}
-- 
cgit 1.4.1-3-g733a5


From df307c0ce73552045e81ee8237d3cb582af0e7e7 Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Thu, 11 Feb 2021 17:32:46 +0900
Subject: Move box_vec to its own module

---
 clippy_lints/src/types/box_vec.rs | 22 ++++++++++++++++++++++
 clippy_lints/src/types/mod.rs     | 14 +++-----------
 2 files changed, 25 insertions(+), 11 deletions(-)
 create mode 100644 clippy_lints/src/types/box_vec.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types/box_vec.rs b/clippy_lints/src/types/box_vec.rs
new file mode 100644
index 00000000000..14f09ab837f
--- /dev/null
+++ b/clippy_lints/src/types/box_vec.rs
@@ -0,0 +1,22 @@
+use rustc_hir::{self as hir, def_id::DefId, QPath};
+use rustc_lint::LateContext;
+use rustc_span::symbol::sym;
+
+use crate::utils::{is_ty_param_diagnostic_item, span_lint_and_help};
+
+use super::BOX_VEC;
+
+pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_>, def_id: DefId) {
+    if Some(def_id) == cx.tcx.lang_items().owned_box() {
+        if is_ty_param_diagnostic_item(cx, qpath, sym::vec_type).is_some() {
+            span_lint_and_help(
+                cx,
+                BOX_VEC,
+                hir_ty.span,
+                "you seem to be trying to use `Box<Vec<T>>`. Consider using just `Vec<T>`",
+                None,
+                "`Vec<T>` is already on the heap, `Box<Vec<T>>` makes an extra allocation",
+            );
+        }
+    }
+}
diff --git a/clippy_lints/src/types/mod.rs b/clippy_lints/src/types/mod.rs
index ce201b956d8..b5ba2c58a81 100644
--- a/clippy_lints/src/types/mod.rs
+++ b/clippy_lints/src/types/mod.rs
@@ -1,5 +1,7 @@
 #![allow(rustc::default_hash_types)]
 
+mod box_vec;
+
 use std::borrow::Cow;
 use std::cmp::Ordering;
 use std::collections::BTreeMap;
@@ -346,6 +348,7 @@ impl Types {
                 let hir_id = hir_ty.hir_id;
                 let res = cx.qpath_res(qpath, hir_id);
                 if let Some(def_id) = res.opt_def_id() {
+                    box_vec::check(cx, hir_ty, qpath, def_id);
                     if Some(def_id) == cx.tcx.lang_items().owned_box() {
                         if let Some(span) = match_borrows_parameter(cx, qpath) {
                             let mut applicability = Applicability::MachineApplicable;
@@ -360,17 +363,6 @@ impl Types {
                             );
                             return; // don't recurse into the type
                         }
-                        if is_ty_param_diagnostic_item(cx, qpath, sym::vec_type).is_some() {
-                            span_lint_and_help(
-                                cx,
-                                BOX_VEC,
-                                hir_ty.span,
-                                "you seem to be trying to use `Box<Vec<T>>`. Consider using just `Vec<T>`",
-                                None,
-                                "`Vec<T>` is already on the heap, `Box<Vec<T>>` makes an extra allocation",
-                            );
-                            return; // don't recurse into the type
-                        }
                     } else if cx.tcx.is_diagnostic_item(sym::Rc, def_id) {
                         if let Some(ty) = is_ty_param_diagnostic_item(cx, qpath, sym::Rc) {
                             let mut applicability = Applicability::MachineApplicable;
-- 
cgit 1.4.1-3-g733a5


From 128f1f5e2eb717fd5d8c68b6ec772fe4b808cd20 Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Thu, 11 Feb 2021 17:41:14 +0900
Subject: Move redundant_allocation to its own module

---
 clippy_lints/src/types/mod.rs                  | 98 +++-----------------------
 clippy_lints/src/types/redundant_allocation.rs | 78 ++++++++++++++++++++
 clippy_lints/src/types/utils.rs                | 24 +++++++
 3 files changed, 112 insertions(+), 88 deletions(-)
 create mode 100644 clippy_lints/src/types/redundant_allocation.rs
 create mode 100644 clippy_lints/src/types/utils.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types/mod.rs b/clippy_lints/src/types/mod.rs
index b5ba2c58a81..cc6ff731ffc 100644
--- a/clippy_lints/src/types/mod.rs
+++ b/clippy_lints/src/types/mod.rs
@@ -1,6 +1,8 @@
 #![allow(rustc::default_hash_types)]
 
 mod box_vec;
+mod redundant_allocation;
+mod utils;
 
 use std::borrow::Cow;
 use std::cmp::Ordering;
@@ -13,8 +15,8 @@ use rustc_hir as hir;
 use rustc_hir::intravisit::{walk_body, walk_expr, walk_ty, FnKind, NestedVisitorMap, Visitor};
 use rustc_hir::{
     BinOpKind, Block, Body, Expr, ExprKind, FnDecl, FnRetTy, FnSig, GenericArg, GenericBounds, GenericParamKind, HirId,
-    ImplItem, ImplItemKind, Item, ItemKind, LangItem, Lifetime, Lit, Local, MatchSource, MutTy, Mutability, Node,
-    QPath, Stmt, StmtKind, SyntheticTyParamKind, TraitFn, TraitItem, TraitItemKind, TyKind, UnOp,
+    ImplItem, ImplItemKind, Item, ItemKind, Lifetime, Lit, Local, MatchSource, MutTy, Mutability, Node, QPath, Stmt,
+    StmtKind, SyntheticTyParamKind, TraitFn, TraitItem, TraitItemKind, TyKind, UnOp,
 };
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::hir::map::Map;
@@ -35,10 +37,10 @@ use crate::utils::paths;
 use crate::utils::sugg::Sugg;
 use crate::utils::{
     clip, comparisons, differing_macro_contexts, get_qpath_generic_tys, higher, in_constant, indent_of, int_bits,
-    is_hir_ty_cfg_dependant, is_ty_param_diagnostic_item, is_ty_param_lang_item, is_type_diagnostic_item,
-    last_path_segment, match_def_path, match_path, meets_msrv, method_chain_args, multispan_sugg,
-    numeric_literal::NumericLiteral, reindent_multiline, sext, snippet, snippet_opt, snippet_with_applicability,
-    snippet_with_macro_callsite, span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then, unsext,
+    is_hir_ty_cfg_dependant, is_ty_param_diagnostic_item, is_type_diagnostic_item, last_path_segment, match_def_path,
+    match_path, meets_msrv, method_chain_args, multispan_sugg, numeric_literal::NumericLiteral, reindent_multiline,
+    sext, snippet, snippet_opt, snippet_with_applicability, snippet_with_macro_callsite, span_lint, span_lint_and_help,
+    span_lint_and_sugg, span_lint_and_then, unsext,
 };
 
 declare_clippy_lint! {
@@ -301,23 +303,6 @@ fn match_buffer_type(cx: &LateContext<'_>, qpath: &QPath<'_>) -> Option<&'static
     }
 }
 
-fn match_borrows_parameter(_cx: &LateContext<'_>, qpath: &QPath<'_>) -> Option<Span> {
-    let last = last_path_segment(qpath);
-    if_chain! {
-        if let Some(ref params) = last.args;
-        if !params.parenthesized;
-        if let Some(ty) = params.args.iter().find_map(|arg| match arg {
-            GenericArg::Type(ty) => Some(ty),
-            _ => None,
-        });
-        if let TyKind::Rptr(..) = ty.kind;
-        then {
-            return Some(ty.span);
-        }
-    }
-    None
-}
-
 impl Types {
     pub fn new(vec_box_size_threshold: u64) -> Self {
         Self { vec_box_size_threshold }
@@ -349,58 +334,8 @@ impl Types {
                 let res = cx.qpath_res(qpath, hir_id);
                 if let Some(def_id) = res.opt_def_id() {
                     box_vec::check(cx, hir_ty, qpath, def_id);
-                    if Some(def_id) == cx.tcx.lang_items().owned_box() {
-                        if let Some(span) = match_borrows_parameter(cx, qpath) {
-                            let mut applicability = Applicability::MachineApplicable;
-                            span_lint_and_sugg(
-                                cx,
-                                REDUNDANT_ALLOCATION,
-                                hir_ty.span,
-                                "usage of `Box<&T>`",
-                                "try",
-                                snippet_with_applicability(cx, span, "..", &mut applicability).to_string(),
-                                applicability,
-                            );
-                            return; // don't recurse into the type
-                        }
-                    } else if cx.tcx.is_diagnostic_item(sym::Rc, def_id) {
-                        if let Some(ty) = is_ty_param_diagnostic_item(cx, qpath, sym::Rc) {
-                            let mut applicability = Applicability::MachineApplicable;
-                            span_lint_and_sugg(
-                                cx,
-                                REDUNDANT_ALLOCATION,
-                                hir_ty.span,
-                                "usage of `Rc<Rc<T>>`",
-                                "try",
-                                snippet_with_applicability(cx, ty.span, "..", &mut applicability).to_string(),
-                                applicability,
-                            );
-                            return; // don't recurse into the type
-                        }
-                        if let Some(ty) = is_ty_param_lang_item(cx, qpath, LangItem::OwnedBox) {
-                            let qpath = match &ty.kind {
-                                TyKind::Path(qpath) => qpath,
-                                _ => return,
-                            };
-                            let inner_span = match get_qpath_generic_tys(qpath).next() {
-                                Some(ty) => ty.span,
-                                None => return,
-                            };
-                            let mut applicability = Applicability::MachineApplicable;
-                            span_lint_and_sugg(
-                                cx,
-                                REDUNDANT_ALLOCATION,
-                                hir_ty.span,
-                                "usage of `Rc<Box<T>>`",
-                                "try",
-                                format!(
-                                    "Rc<{}>",
-                                    snippet_with_applicability(cx, inner_span, "..", &mut applicability)
-                                ),
-                                applicability,
-                            );
-                            return; // don't recurse into the type
-                        }
+                    redundant_allocation::check(cx, hir_ty, qpath, def_id);
+                    if cx.tcx.is_diagnostic_item(sym::Rc, def_id) {
                         if let Some(alternate) = match_buffer_type(cx, qpath) {
                             span_lint_and_sugg(
                                 cx,
@@ -437,19 +372,6 @@ impl Types {
                             );
                             return; // don't recurse into the type
                         }
-                        if let Some(span) = match_borrows_parameter(cx, qpath) {
-                            let mut applicability = Applicability::MachineApplicable;
-                            span_lint_and_sugg(
-                                cx,
-                                REDUNDANT_ALLOCATION,
-                                hir_ty.span,
-                                "usage of `Rc<&T>`",
-                                "try",
-                                snippet_with_applicability(cx, span, "..", &mut applicability).to_string(),
-                                applicability,
-                            );
-                            return; // don't recurse into the type
-                        }
                     } else if cx.tcx.is_diagnostic_item(sym::Arc, def_id) {
                         if let Some(alternate) = match_buffer_type(cx, qpath) {
                             span_lint_and_sugg(
diff --git a/clippy_lints/src/types/redundant_allocation.rs b/clippy_lints/src/types/redundant_allocation.rs
new file mode 100644
index 00000000000..8280b2c5629
--- /dev/null
+++ b/clippy_lints/src/types/redundant_allocation.rs
@@ -0,0 +1,78 @@
+use rustc_errors::Applicability;
+use rustc_hir::{self as hir, def_id::DefId, LangItem, QPath, TyKind};
+use rustc_lint::LateContext;
+use rustc_span::symbol::sym;
+
+use crate::utils::{
+    get_qpath_generic_tys, is_ty_param_diagnostic_item, is_ty_param_lang_item, snippet_with_applicability,
+    span_lint_and_sugg,
+};
+
+use super::{utils, REDUNDANT_ALLOCATION};
+
+pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_>, def_id: DefId) {
+    if Some(def_id) == cx.tcx.lang_items().owned_box() {
+        if let Some(span) = utils::match_borrows_parameter(cx, qpath) {
+            let mut applicability = Applicability::MachineApplicable;
+            span_lint_and_sugg(
+                cx,
+                REDUNDANT_ALLOCATION,
+                hir_ty.span,
+                "usage of `Box<&T>`",
+                "try",
+                snippet_with_applicability(cx, span, "..", &mut applicability).to_string(),
+                applicability,
+            );
+            return;
+        }
+    }
+
+    if cx.tcx.is_diagnostic_item(sym::Rc, def_id) {
+        if let Some(ty) = is_ty_param_diagnostic_item(cx, qpath, sym::Rc) {
+            let mut applicability = Applicability::MachineApplicable;
+            span_lint_and_sugg(
+                cx,
+                REDUNDANT_ALLOCATION,
+                hir_ty.span,
+                "usage of `Rc<Rc<T>>`",
+                "try",
+                snippet_with_applicability(cx, ty.span, "..", &mut applicability).to_string(),
+                applicability,
+            );
+        } else if let Some(ty) = is_ty_param_lang_item(cx, qpath, LangItem::OwnedBox) {
+            let qpath = match &ty.kind {
+                TyKind::Path(qpath) => qpath,
+                _ => return,
+            };
+            let inner_span = match get_qpath_generic_tys(qpath).next() {
+                Some(ty) => ty.span,
+                None => return,
+            };
+            let mut applicability = Applicability::MachineApplicable;
+            span_lint_and_sugg(
+                cx,
+                REDUNDANT_ALLOCATION,
+                hir_ty.span,
+                "usage of `Rc<Box<T>>`",
+                "try",
+                format!(
+                    "Rc<{}>",
+                    snippet_with_applicability(cx, inner_span, "..", &mut applicability)
+                ),
+                applicability,
+            );
+        } else if let Some(span) = utils::match_borrows_parameter(cx, qpath) {
+            let mut applicability = Applicability::MachineApplicable;
+            span_lint_and_sugg(
+                cx,
+                REDUNDANT_ALLOCATION,
+                hir_ty.span,
+                "usage of `Rc<&T>`",
+                "try",
+                snippet_with_applicability(cx, span, "..", &mut applicability).to_string(),
+                applicability,
+            );
+            return; // don't recurse into the type
+        }
+    }
+}
diff --git a/clippy_lints/src/types/utils.rs b/clippy_lints/src/types/utils.rs
new file mode 100644
index 00000000000..4d64748f998
--- /dev/null
+++ b/clippy_lints/src/types/utils.rs
@@ -0,0 +1,24 @@
+use rustc_hir::{GenericArg, QPath, TyKind};
+use rustc_lint::LateContext;
+use rustc_span::source_map::Span;
+
+use crate::utils::last_path_segment;
+
+use if_chain::if_chain;
+
+pub(super) fn match_borrows_parameter(_cx: &LateContext<'_>, qpath: &QPath<'_>) -> Option<Span> {
+    let last = last_path_segment(qpath);
+    if_chain! {
+        if let Some(ref params) = last.args;
+        if !params.parenthesized;
+        if let Some(ty) = params.args.iter().find_map(|arg| match arg {
+            GenericArg::Type(ty) => Some(ty),
+            _ => None,
+        });
+        if let TyKind::Rptr(..) = ty.kind;
+        then {
+            return Some(ty.span);
+        }
+    }
+    None
+}
-- 
cgit 1.4.1-3-g733a5


From f110c5e6f51eea87e37503819addbd1bd054416a Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Fri, 12 Feb 2021 12:09:36 +0900
Subject: Move rc_buffer to its own module

---
 clippy_lints/src/types/mod.rs       | 100 +++---------------------------------
 clippy_lints/src/types/rc_buffer.rs |  94 +++++++++++++++++++++++++++++++++
 2 files changed, 102 insertions(+), 92 deletions(-)
 create mode 100644 clippy_lints/src/types/rc_buffer.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types/mod.rs b/clippy_lints/src/types/mod.rs
index cc6ff731ffc..6c6e204257f 100644
--- a/clippy_lints/src/types/mod.rs
+++ b/clippy_lints/src/types/mod.rs
@@ -1,6 +1,7 @@
 #![allow(rustc::default_hash_types)]
 
 mod box_vec;
+mod rc_buffer;
 mod redundant_allocation;
 mod utils;
 
@@ -36,11 +37,11 @@ use crate::consts::{constant, Constant};
 use crate::utils::paths;
 use crate::utils::sugg::Sugg;
 use crate::utils::{
-    clip, comparisons, differing_macro_contexts, get_qpath_generic_tys, higher, in_constant, indent_of, int_bits,
-    is_hir_ty_cfg_dependant, is_ty_param_diagnostic_item, is_type_diagnostic_item, last_path_segment, match_def_path,
-    match_path, meets_msrv, method_chain_args, multispan_sugg, numeric_literal::NumericLiteral, reindent_multiline,
-    sext, snippet, snippet_opt, snippet_with_applicability, snippet_with_macro_callsite, span_lint, span_lint_and_help,
-    span_lint_and_sugg, span_lint_and_then, unsext,
+    clip, comparisons, differing_macro_contexts, higher, in_constant, indent_of, int_bits, is_hir_ty_cfg_dependant,
+    is_ty_param_diagnostic_item, is_type_diagnostic_item, last_path_segment, match_def_path, match_path, meets_msrv,
+    method_chain_args, multispan_sugg, numeric_literal::NumericLiteral, reindent_multiline, sext, snippet, snippet_opt,
+    snippet_with_applicability, snippet_with_macro_callsite, span_lint, span_lint_and_help, span_lint_and_sugg,
+    span_lint_and_then, unsext,
 };
 
 declare_clippy_lint! {
@@ -291,18 +292,6 @@ impl<'tcx> LateLintPass<'tcx> for Types {
     }
 }
 
-fn match_buffer_type(cx: &LateContext<'_>, qpath: &QPath<'_>) -> Option<&'static str> {
-    if is_ty_param_diagnostic_item(cx, qpath, sym::string_type).is_some() {
-        Some("str")
-    } else if is_ty_param_diagnostic_item(cx, qpath, sym::OsString).is_some() {
-        Some("std::ffi::OsStr")
-    } else if is_ty_param_diagnostic_item(cx, qpath, sym::PathBuf).is_some() {
-        Some("std::path::Path")
-    } else {
-        None
-    }
-}
-
 impl Types {
     pub fn new(vec_box_size_threshold: u64) -> Self {
         Self { vec_box_size_threshold }
@@ -335,81 +324,8 @@ impl Types {
                 if let Some(def_id) = res.opt_def_id() {
                     box_vec::check(cx, hir_ty, qpath, def_id);
                     redundant_allocation::check(cx, hir_ty, qpath, def_id);
-                    if cx.tcx.is_diagnostic_item(sym::Rc, def_id) {
-                        if let Some(alternate) = match_buffer_type(cx, qpath) {
-                            span_lint_and_sugg(
-                                cx,
-                                RC_BUFFER,
-                                hir_ty.span,
-                                "usage of `Rc<T>` when T is a buffer type",
-                                "try",
-                                format!("Rc<{}>", alternate),
-                                Applicability::MachineApplicable,
-                            );
-                            return; // don't recurse into the type
-                        }
-                        if let Some(ty) = is_ty_param_diagnostic_item(cx, qpath, sym::vec_type) {
-                            let qpath = match &ty.kind {
-                                TyKind::Path(qpath) => qpath,
-                                _ => return,
-                            };
-                            let inner_span = match get_qpath_generic_tys(qpath).next() {
-                                Some(ty) => ty.span,
-                                None => return,
-                            };
-                            let mut applicability = Applicability::MachineApplicable;
-                            span_lint_and_sugg(
-                                cx,
-                                RC_BUFFER,
-                                hir_ty.span,
-                                "usage of `Rc<T>` when T is a buffer type",
-                                "try",
-                                format!(
-                                    "Rc<[{}]>",
-                                    snippet_with_applicability(cx, inner_span, "..", &mut applicability)
-                                ),
-                                Applicability::MachineApplicable,
-                            );
-                            return; // don't recurse into the type
-                        }
-                    } else if cx.tcx.is_diagnostic_item(sym::Arc, def_id) {
-                        if let Some(alternate) = match_buffer_type(cx, qpath) {
-                            span_lint_and_sugg(
-                                cx,
-                                RC_BUFFER,
-                                hir_ty.span,
-                                "usage of `Arc<T>` when T is a buffer type",
-                                "try",
-                                format!("Arc<{}>", alternate),
-                                Applicability::MachineApplicable,
-                            );
-                            return; // don't recurse into the type
-                        }
-                        if let Some(ty) = is_ty_param_diagnostic_item(cx, qpath, sym::vec_type) {
-                            let qpath = match &ty.kind {
-                                TyKind::Path(qpath) => qpath,
-                                _ => return,
-                            };
-                            let inner_span = match get_qpath_generic_tys(qpath).next() {
-                                Some(ty) => ty.span,
-                                None => return,
-                            };
-                            let mut applicability = Applicability::MachineApplicable;
-                            span_lint_and_sugg(
-                                cx,
-                                RC_BUFFER,
-                                hir_ty.span,
-                                "usage of `Arc<T>` when T is a buffer type",
-                                "try",
-                                format!(
-                                    "Arc<[{}]>",
-                                    snippet_with_applicability(cx, inner_span, "..", &mut applicability)
-                                ),
-                                Applicability::MachineApplicable,
-                            );
-                            return; // don't recurse into the type
-                        }
-                    } else if cx.tcx.is_diagnostic_item(sym::vec_type, def_id) {
+                    rc_buffer::check(cx, hir_ty, qpath, def_id);
+                    if cx.tcx.is_diagnostic_item(sym::vec_type, def_id) {
                         if_chain! {
                             // Get the _ part of Vec<_>
                             if let Some(ref last) = last_path_segment(qpath).args;
diff --git a/clippy_lints/src/types/rc_buffer.rs b/clippy_lints/src/types/rc_buffer.rs
new file mode 100644
index 00000000000..11e25c8bdcb
--- /dev/null
+++ b/clippy_lints/src/types/rc_buffer.rs
@@ -0,0 +1,94 @@
+use rustc_errors::Applicability;
+use rustc_hir::{self as hir, def_id::DefId, QPath, TyKind};
+use rustc_lint::LateContext;
+use rustc_span::symbol::sym;
+
+use crate::utils::{
+    get_qpath_generic_tys, is_ty_param_diagnostic_item, snippet_with_applicability, span_lint_and_sugg,
+};
+
+use super::RC_BUFFER;
+
+pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_>, def_id: DefId) {
+    if cx.tcx.is_diagnostic_item(sym::Rc, def_id) {
+        if let Some(alternate) = match_buffer_type(cx, qpath) {
+            span_lint_and_sugg(
+                cx,
+                RC_BUFFER,
+                hir_ty.span,
+                "usage of `Rc<T>` when T is a buffer type",
+                "try",
+                format!("Rc<{}>", alternate),
+                Applicability::MachineApplicable,
+            );
+        } else if let Some(ty) = is_ty_param_diagnostic_item(cx, qpath, sym::vec_type) {
+            let qpath = match &ty.kind {
+                TyKind::Path(qpath) => qpath,
+                _ => return,
+            };
+            let inner_span = match get_qpath_generic_tys(qpath).next() {
+                Some(ty) => ty.span,
+                None => return,
+            };
+            let mut applicability = Applicability::MachineApplicable;
+            span_lint_and_sugg(
+                cx,
+                RC_BUFFER,
+                hir_ty.span,
+                "usage of `Rc<T>` when T is a buffer type",
+                "try",
+                format!(
+                    "Rc<[{}]>",
+                    snippet_with_applicability(cx, inner_span, "..", &mut applicability)
+                ),
+                Applicability::MachineApplicable,
+            );
+        }
+    } else if cx.tcx.is_diagnostic_item(sym::Arc, def_id) {
+        if let Some(alternate) = match_buffer_type(cx, qpath) {
+            span_lint_and_sugg(
+                cx,
+                RC_BUFFER,
+                hir_ty.span,
+                "usage of `Arc<T>` when T is a buffer type",
+                "try",
+                format!("Arc<{}>", alternate),
+                Applicability::MachineApplicable,
+            );
+        } else if let Some(ty) = is_ty_param_diagnostic_item(cx, qpath, sym::vec_type) {
+            let qpath = match &ty.kind {
+                TyKind::Path(qpath) => qpath,
+                _ => return,
+            };
+            let inner_span = match get_qpath_generic_tys(qpath).next() {
+                Some(ty) => ty.span,
+                None => return,
+            };
+            let mut applicability = Applicability::MachineApplicable;
+            span_lint_and_sugg(
+                cx,
+                RC_BUFFER,
+                hir_ty.span,
+                "usage of `Arc<T>` when T is a buffer type",
+                "try",
+                format!(
+                    "Arc<[{}]>",
+                    snippet_with_applicability(cx, inner_span, "..", &mut applicability)
+                ),
+                Applicability::MachineApplicable,
+            );
+        }
+    }
+}
+
+fn match_buffer_type(cx: &LateContext<'_>, qpath: &QPath<'_>) -> Option<&'static str> {
+    if is_ty_param_diagnostic_item(cx, qpath, sym::string_type).is_some() {
+        Some("str")
+    } else if is_ty_param_diagnostic_item(cx, qpath, sym::OsString).is_some() {
+        Some("std::ffi::OsStr")
+    } else if is_ty_param_diagnostic_item(cx, qpath, sym::PathBuf).is_some() {
+        Some("std::path::Path")
+    } else {
+        None
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 2c2fb3996f8b0db6537a2a9d193af89304cd62ed Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Fri, 12 Feb 2021 14:00:17 +0900
Subject: Move vec_box to its own module

---
 clippy_lints/src/types/mod.rs     | 47 ++++---------------------------
 clippy_lints/src/types/vec_box.rs | 59 +++++++++++++++++++++++++++++++++++++++
 2 files changed, 65 insertions(+), 41 deletions(-)
 create mode 100644 clippy_lints/src/types/vec_box.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types/mod.rs b/clippy_lints/src/types/mod.rs
index 6c6e204257f..8d866568df9 100644
--- a/clippy_lints/src/types/mod.rs
+++ b/clippy_lints/src/types/mod.rs
@@ -4,6 +4,7 @@ mod box_vec;
 mod rc_buffer;
 mod redundant_allocation;
 mod utils;
+mod vec_box;
 
 use std::borrow::Cow;
 use std::cmp::Ordering;
@@ -22,7 +23,6 @@ use rustc_hir::{
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::hir::map::Map;
 use rustc_middle::lint::in_external_macro;
-use rustc_middle::ty::TypeFoldable;
 use rustc_middle::ty::{self, FloatTy, InferTy, IntTy, Ty, TyCtxt, TyS, TypeAndMut, TypeckResults, UintTy};
 use rustc_semver::RustcVersion;
 use rustc_session::{declare_lint_pass, declare_tool_lint, impl_lint_pass};
@@ -38,8 +38,8 @@ use crate::utils::paths;
 use crate::utils::sugg::Sugg;
 use crate::utils::{
     clip, comparisons, differing_macro_contexts, higher, in_constant, indent_of, int_bits, is_hir_ty_cfg_dependant,
-    is_ty_param_diagnostic_item, is_type_diagnostic_item, last_path_segment, match_def_path, match_path, meets_msrv,
-    method_chain_args, multispan_sugg, numeric_literal::NumericLiteral, reindent_multiline, sext, snippet, snippet_opt,
+    is_ty_param_diagnostic_item, is_type_diagnostic_item, match_def_path, match_path, meets_msrv, method_chain_args,
+    multispan_sugg, numeric_literal::NumericLiteral, reindent_multiline, sext, snippet, snippet_opt,
     snippet_with_applicability, snippet_with_macro_callsite, span_lint, span_lint_and_help, span_lint_and_sugg,
     span_lint_and_then, unsext,
 };
@@ -325,44 +325,9 @@ impl Types {
                     box_vec::check(cx, hir_ty, qpath, def_id);
                     redundant_allocation::check(cx, hir_ty, qpath, def_id);
                     rc_buffer::check(cx, hir_ty, qpath, def_id);
-                    if cx.tcx.is_diagnostic_item(sym::vec_type, def_id) {
-                        if_chain! {
-                            // Get the _ part of Vec<_>
-                            if let Some(ref last) = last_path_segment(qpath).args;
-                            if let Some(ty) = last.args.iter().find_map(|arg| match arg {
-                                GenericArg::Type(ty) => Some(ty),
-                                _ => None,
-                            });
-                            // ty is now _ at this point
-                            if let TyKind::Path(ref ty_qpath) = ty.kind;
-                            let res = cx.qpath_res(ty_qpath, ty.hir_id);
-                            if let Some(def_id) = res.opt_def_id();
-                            if Some(def_id) == cx.tcx.lang_items().owned_box();
-                            // At this point, we know ty is Box<T>, now get T
-                            if let Some(ref last) = last_path_segment(ty_qpath).args;
-                            if let Some(boxed_ty) = last.args.iter().find_map(|arg| match arg {
-                                GenericArg::Type(ty) => Some(ty),
-                                _ => None,
-                            });
-                            let ty_ty = hir_ty_to_ty(cx.tcx, boxed_ty);
-                            if !ty_ty.has_escaping_bound_vars();
-                            if ty_ty.is_sized(cx.tcx.at(ty.span), cx.param_env);
-                            if let Ok(ty_ty_size) = cx.layout_of(ty_ty).map(|l| l.size.bytes());
-                            if ty_ty_size <= self.vec_box_size_threshold;
-                            then {
-                                span_lint_and_sugg(
-                                    cx,
-                                    VEC_BOX,
-                                    hir_ty.span,
-                                    "`Vec<T>` is already on the heap, the boxing is unnecessary",
-                                    "try",
-                                    format!("Vec<{}>", snippet(cx, boxed_ty.span, "..")),
-                                    Applicability::MachineApplicable,
-                                );
-                                return; // don't recurse into the type
-                            }
-                        }
-                    } else if cx.tcx.is_diagnostic_item(sym::option_type, def_id) {
+                    vec_box::check(cx, hir_ty, qpath, def_id, self.vec_box_size_threshold);
+
+                    if cx.tcx.is_diagnostic_item(sym::option_type, def_id) {
                         if is_ty_param_diagnostic_item(cx, qpath, sym::option_type).is_some() {
                             span_lint(
                                 cx,
diff --git a/clippy_lints/src/types/vec_box.rs b/clippy_lints/src/types/vec_box.rs
new file mode 100644
index 00000000000..2964abf3492
--- /dev/null
+++ b/clippy_lints/src/types/vec_box.rs
@@ -0,0 +1,59 @@
+use rustc_errors::Applicability;
+use rustc_hir::{self as hir, def_id::DefId, GenericArg, QPath, TyKind};
+use rustc_lint::LateContext;
+use rustc_middle::ty::TypeFoldable;
+use rustc_span::symbol::sym;
+use rustc_target::abi::LayoutOf;
+use rustc_typeck::hir_ty_to_ty;
+
+use if_chain::if_chain;
+
+use crate::utils::{last_path_segment, snippet, span_lint_and_sugg};
+
+use super::VEC_BOX;
+
+pub(super) fn check(
+    cx: &LateContext<'_>,
+    hir_ty: &hir::Ty<'_>,
+    qpath: &QPath<'_>,
+    def_id: DefId,
+    box_size_threshold: u64,
+) {
+    if cx.tcx.is_diagnostic_item(sym::vec_type, def_id) {
+        if_chain! {
+            // Get the _ part of Vec<_>
+            if let Some(ref last) = last_path_segment(qpath).args;
+            if let Some(ty) = last.args.iter().find_map(|arg| match arg {
+                GenericArg::Type(ty) => Some(ty),
+                _ => None,
+            });
+            // ty is now _ at this point
+            if let TyKind::Path(ref ty_qpath) = ty.kind;
+            let res = cx.qpath_res(ty_qpath, ty.hir_id);
+            if let Some(def_id) = res.opt_def_id();
+            if Some(def_id) == cx.tcx.lang_items().owned_box();
+            // At this point, we know ty is Box<T>, now get T
+            if let Some(ref last) = last_path_segment(ty_qpath).args;
+            if let Some(boxed_ty) = last.args.iter().find_map(|arg| match arg {
+                GenericArg::Type(ty) => Some(ty),
+                _ => None,
+            });
+            let ty_ty = hir_ty_to_ty(cx.tcx, boxed_ty);
+            if !ty_ty.has_escaping_bound_vars();
+            if ty_ty.is_sized(cx.tcx.at(ty.span), cx.param_env);
+            if let Ok(ty_ty_size) = cx.layout_of(ty_ty).map(|l| l.size.bytes());
+            if ty_ty_size <= box_size_threshold;
+            then {
+                span_lint_and_sugg(
+                    cx,
+                    VEC_BOX,
+                    hir_ty.span,
+                    "`Vec<T>` is already on the heap, the boxing is unnecessary",
+                    "try",
+                    format!("Vec<{}>", snippet(cx, boxed_ty.span, "..")),
+                    Applicability::MachineApplicable,
+                );
+            }
+        }
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From fbd25e93a4ab7b7d357452f7c59f846e984b5d74 Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Fri, 12 Feb 2021 14:11:04 +0900
Subject: Add flags to detect lints are triggered

---
 clippy_lints/src/types/box_vec.rs              |  4 +++-
 clippy_lints/src/types/mod.rs                  | 13 +++++++++----
 clippy_lints/src/types/rc_buffer.rs            | 14 +++++++++-----
 clippy_lints/src/types/redundant_allocation.rs | 16 +++++++++++-----
 clippy_lints/src/types/vec_box.rs              |  7 ++++++-
 5 files changed, 38 insertions(+), 16 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types/box_vec.rs b/clippy_lints/src/types/box_vec.rs
index 14f09ab837f..4eb032cae6b 100644
--- a/clippy_lints/src/types/box_vec.rs
+++ b/clippy_lints/src/types/box_vec.rs
@@ -6,7 +6,7 @@ use crate::utils::{is_ty_param_diagnostic_item, span_lint_and_help};
 
 use super::BOX_VEC;
 
-pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_>, def_id: DefId) {
+pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_>, def_id: DefId) -> bool {
     if Some(def_id) == cx.tcx.lang_items().owned_box() {
         if is_ty_param_diagnostic_item(cx, qpath, sym::vec_type).is_some() {
             span_lint_and_help(
@@ -17,6 +17,8 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_
                 None,
                 "`Vec<T>` is already on the heap, `Box<Vec<T>>` makes an extra allocation",
             );
+            return true;
         }
     }
+    false
 }
diff --git a/clippy_lints/src/types/mod.rs b/clippy_lints/src/types/mod.rs
index 8d866568df9..8506f362517 100644
--- a/clippy_lints/src/types/mod.rs
+++ b/clippy_lints/src/types/mod.rs
@@ -322,10 +322,11 @@ impl Types {
                 let hir_id = hir_ty.hir_id;
                 let res = cx.qpath_res(qpath, hir_id);
                 if let Some(def_id) = res.opt_def_id() {
-                    box_vec::check(cx, hir_ty, qpath, def_id);
-                    redundant_allocation::check(cx, hir_ty, qpath, def_id);
-                    rc_buffer::check(cx, hir_ty, qpath, def_id);
-                    vec_box::check(cx, hir_ty, qpath, def_id, self.vec_box_size_threshold);
+                    let mut triggered = false;
+                    triggered |= box_vec::check(cx, hir_ty, qpath, def_id);
+                    triggered |= redundant_allocation::check(cx, hir_ty, qpath, def_id);
+                    triggered |= rc_buffer::check(cx, hir_ty, qpath, def_id);
+                    triggered |= vec_box::check(cx, hir_ty, qpath, def_id, self.vec_box_size_threshold);
 
                     if cx.tcx.is_diagnostic_item(sym::option_type, def_id) {
                         if is_ty_param_diagnostic_item(cx, qpath, sym::option_type).is_some() {
@@ -349,6 +350,10 @@ impl Types {
                         );
                         return; // don't recurse into the type
                     }
+
+                    if triggered {
+                        return;
+                    }
                 }
                 match *qpath {
                     QPath::Resolved(Some(ref ty), ref p) => {
diff --git a/clippy_lints/src/types/rc_buffer.rs b/clippy_lints/src/types/rc_buffer.rs
index 11e25c8bdcb..e34b95147e1 100644
--- a/clippy_lints/src/types/rc_buffer.rs
+++ b/clippy_lints/src/types/rc_buffer.rs
@@ -9,7 +9,7 @@ use crate::utils::{
 
 use super::RC_BUFFER;
 
-pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_>, def_id: DefId) {
+pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_>, def_id: DefId) -> bool {
     if cx.tcx.is_diagnostic_item(sym::Rc, def_id) {
         if let Some(alternate) = match_buffer_type(cx, qpath) {
             span_lint_and_sugg(
@@ -24,11 +24,11 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_
         } else if let Some(ty) = is_ty_param_diagnostic_item(cx, qpath, sym::vec_type) {
             let qpath = match &ty.kind {
                 TyKind::Path(qpath) => qpath,
-                _ => return,
+                _ => return false,
             };
             let inner_span = match get_qpath_generic_tys(qpath).next() {
                 Some(ty) => ty.span,
-                None => return,
+                None => return false,
             };
             let mut applicability = Applicability::MachineApplicable;
             span_lint_and_sugg(
@@ -43,6 +43,7 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_
                 ),
                 Applicability::MachineApplicable,
             );
+            return true;
         }
     } else if cx.tcx.is_diagnostic_item(sym::Arc, def_id) {
         if let Some(alternate) = match_buffer_type(cx, qpath) {
@@ -58,11 +59,11 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_
         } else if let Some(ty) = is_ty_param_diagnostic_item(cx, qpath, sym::vec_type) {
             let qpath = match &ty.kind {
                 TyKind::Path(qpath) => qpath,
-                _ => return,
+                _ => return false,
             };
             let inner_span = match get_qpath_generic_tys(qpath).next() {
                 Some(ty) => ty.span,
-                None => return,
+                None => return false,
             };
             let mut applicability = Applicability::MachineApplicable;
             span_lint_and_sugg(
@@ -77,8 +78,11 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_
                 ),
                 Applicability::MachineApplicable,
             );
+            return true;
         }
     }
+
+    false
 }
 
 fn match_buffer_type(cx: &LateContext<'_>, qpath: &QPath<'_>) -> Option<&'static str> {
diff --git a/clippy_lints/src/types/redundant_allocation.rs b/clippy_lints/src/types/redundant_allocation.rs
index 8280b2c5629..ea5a675827a 100644
--- a/clippy_lints/src/types/redundant_allocation.rs
+++ b/clippy_lints/src/types/redundant_allocation.rs
@@ -10,7 +10,7 @@ use crate::utils::{
 
 use super::{utils, REDUNDANT_ALLOCATION};
 
-pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_>, def_id: DefId) {
+pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_>, def_id: DefId) -> bool {
     if Some(def_id) == cx.tcx.lang_items().owned_box() {
         if let Some(span) = utils::match_borrows_parameter(cx, qpath) {
             let mut applicability = Applicability::MachineApplicable;
@@ -23,7 +23,7 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_
                 snippet_with_applicability(cx, span, "..", &mut applicability).to_string(),
                 applicability,
             );
-            return;
+            return true;
         }
     }
 
@@ -39,14 +39,15 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_
                 snippet_with_applicability(cx, ty.span, "..", &mut applicability).to_string(),
                 applicability,
             );
+            true
         } else if let Some(ty) = is_ty_param_lang_item(cx, qpath, LangItem::OwnedBox) {
             let qpath = match &ty.kind {
                 TyKind::Path(qpath) => qpath,
-                _ => return,
+                _ => return false,
             };
             let inner_span = match get_qpath_generic_tys(qpath).next() {
                 Some(ty) => ty.span,
-                None => return,
+                None => return false,
             };
             let mut applicability = Applicability::MachineApplicable;
             span_lint_and_sugg(
@@ -61,6 +62,7 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_
                 ),
                 applicability,
             );
+            true
         } else if let Some(span) = utils::match_borrows_parameter(cx, qpath) {
             let mut applicability = Applicability::MachineApplicable;
             span_lint_and_sugg(
@@ -72,7 +74,11 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_
                 snippet_with_applicability(cx, span, "..", &mut applicability).to_string(),
                 applicability,
             );
-            return; // don't recurse into the type
+            true
+        } else {
+            false
         }
+    } else {
+        false
     }
 }
diff --git a/clippy_lints/src/types/vec_box.rs b/clippy_lints/src/types/vec_box.rs
index 2964abf3492..2530cc133c6 100644
--- a/clippy_lints/src/types/vec_box.rs
+++ b/clippy_lints/src/types/vec_box.rs
@@ -18,7 +18,7 @@ pub(super) fn check(
     qpath: &QPath<'_>,
     def_id: DefId,
     box_size_threshold: u64,
-) {
+) -> bool {
     if cx.tcx.is_diagnostic_item(sym::vec_type, def_id) {
         if_chain! {
             // Get the _ part of Vec<_>
@@ -53,7 +53,12 @@ pub(super) fn check(
                     format!("Vec<{}>", snippet(cx, boxed_ty.span, "..")),
                     Applicability::MachineApplicable,
                 );
+                true
+            } else {
+                false
             }
         }
+    } else {
+        false
     }
 }
-- 
cgit 1.4.1-3-g733a5


From b59c879fc9e508b4e9a08babf2e4004f396833bb Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Fri, 12 Feb 2021 14:24:02 +0900
Subject: Move option_option to its own module

---
 clippy_lints/src/types/mod.rs           | 15 +++------------
 clippy_lints/src/types/option_option.rs | 23 +++++++++++++++++++++++
 2 files changed, 26 insertions(+), 12 deletions(-)
 create mode 100644 clippy_lints/src/types/option_option.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types/mod.rs b/clippy_lints/src/types/mod.rs
index 8506f362517..55f1d86bc56 100644
--- a/clippy_lints/src/types/mod.rs
+++ b/clippy_lints/src/types/mod.rs
@@ -1,6 +1,7 @@
 #![allow(rustc::default_hash_types)]
 
 mod box_vec;
+mod option_option;
 mod rc_buffer;
 mod redundant_allocation;
 mod utils;
@@ -327,19 +328,9 @@ impl Types {
                     triggered |= redundant_allocation::check(cx, hir_ty, qpath, def_id);
                     triggered |= rc_buffer::check(cx, hir_ty, qpath, def_id);
                     triggered |= vec_box::check(cx, hir_ty, qpath, def_id, self.vec_box_size_threshold);
+                    triggered |= option_option::check(cx, hir_ty, qpath, def_id);
 
-                    if cx.tcx.is_diagnostic_item(sym::option_type, def_id) {
-                        if is_ty_param_diagnostic_item(cx, qpath, sym::option_type).is_some() {
-                            span_lint(
-                                cx,
-                                OPTION_OPTION,
-                                hir_ty.span,
-                                "consider using `Option<T>` instead of `Option<Option<T>>` or a custom \
-                                 enum if you need to distinguish all 3 cases",
-                            );
-                            return; // don't recurse into the type
-                        }
-                    } else if match_def_path(cx, def_id, &paths::LINKED_LIST) {
+                    if match_def_path(cx, def_id, &paths::LINKED_LIST) {
                         span_lint_and_help(
                             cx,
                             LINKEDLIST,
diff --git a/clippy_lints/src/types/option_option.rs b/clippy_lints/src/types/option_option.rs
new file mode 100644
index 00000000000..42aad70438b
--- /dev/null
+++ b/clippy_lints/src/types/option_option.rs
@@ -0,0 +1,23 @@
+use rustc_hir::{self as hir, def_id::DefId, QPath};
+use rustc_lint::LateContext;
+use rustc_span::symbol::sym;
+
+use crate::utils::span_lint;
+
+use super::utils;
+
+pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_>, def_id: DefId) -> bool {
+    if cx.tcx.is_diagnostic_item(sym::option_type, def_id) {
+        if utils::is_ty_param_diagnostic_item(cx, qpath, sym::option_type).is_some() {
+            span_lint(
+                cx,
+                super::OPTION_OPTION,
+                hir_ty.span,
+                "consider using `Option<T>` instead of `Option<Option<T>>` or a custom \
+                                 enum if you need to distinguish all 3 cases",
+            );
+            return true;
+        }
+    }
+    false
+}
-- 
cgit 1.4.1-3-g733a5


From cc3ab1c0ec8c94920fea7aab6c912297f489ff49 Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Fri, 12 Feb 2021 14:28:17 +0900
Subject: Move linked_list to its own module

---
 clippy_lints/src/types/linked_list.rs   | 20 ++++++++++++++++++++
 clippy_lints/src/types/mod.rs           | 23 +++++------------------
 clippy_lints/src/types/option_option.rs |  6 ++----
 3 files changed, 27 insertions(+), 22 deletions(-)
 create mode 100644 clippy_lints/src/types/linked_list.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types/linked_list.rs b/clippy_lints/src/types/linked_list.rs
new file mode 100644
index 00000000000..74be8959fa4
--- /dev/null
+++ b/clippy_lints/src/types/linked_list.rs
@@ -0,0 +1,20 @@
+use rustc_hir::{self as hir, def_id::DefId};
+use rustc_lint::LateContext;
+
+use crate::utils::{match_def_path, paths, span_lint_and_help};
+
+pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, def_id: DefId) -> bool {
+    if match_def_path(cx, def_id, &paths::LINKED_LIST) {
+        span_lint_and_help(
+            cx,
+            super::LINKEDLIST,
+            hir_ty.span,
+            "you seem to be using a `LinkedList`! Perhaps you meant some other data structure?",
+            None,
+            "a `VecDeque` might work",
+        );
+        true
+    } else {
+        false
+    }
+}
diff --git a/clippy_lints/src/types/mod.rs b/clippy_lints/src/types/mod.rs
index 55f1d86bc56..86a12b8ffa9 100644
--- a/clippy_lints/src/types/mod.rs
+++ b/clippy_lints/src/types/mod.rs
@@ -1,6 +1,7 @@
 #![allow(rustc::default_hash_types)]
 
 mod box_vec;
+mod linked_list;
 mod option_option;
 mod rc_buffer;
 mod redundant_allocation;
@@ -39,10 +40,9 @@ use crate::utils::paths;
 use crate::utils::sugg::Sugg;
 use crate::utils::{
     clip, comparisons, differing_macro_contexts, higher, in_constant, indent_of, int_bits, is_hir_ty_cfg_dependant,
-    is_ty_param_diagnostic_item, is_type_diagnostic_item, match_def_path, match_path, meets_msrv, method_chain_args,
-    multispan_sugg, numeric_literal::NumericLiteral, reindent_multiline, sext, snippet, snippet_opt,
-    snippet_with_applicability, snippet_with_macro_callsite, span_lint, span_lint_and_help, span_lint_and_sugg,
-    span_lint_and_then, unsext,
+    is_type_diagnostic_item, match_path, meets_msrv, method_chain_args, multispan_sugg,
+    numeric_literal::NumericLiteral, reindent_multiline, sext, snippet, snippet_opt, snippet_with_applicability,
+    snippet_with_macro_callsite, span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then, unsext,
 };
 
 declare_clippy_lint! {
@@ -313,7 +313,6 @@ impl Types {
     ///
     /// The parameter `is_local` distinguishes the context of the type; types from
     /// local bindings should only be checked for the `BORROWED_BOX` lint.
-    #[allow(clippy::too_many_lines)]
     fn check_ty(&mut self, cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, is_local: bool) {
         if hir_ty.span.from_expansion() {
             return;
@@ -329,18 +328,7 @@ impl Types {
                     triggered |= rc_buffer::check(cx, hir_ty, qpath, def_id);
                     triggered |= vec_box::check(cx, hir_ty, qpath, def_id, self.vec_box_size_threshold);
                     triggered |= option_option::check(cx, hir_ty, qpath, def_id);
-
-                    if match_def_path(cx, def_id, &paths::LINKED_LIST) {
-                        span_lint_and_help(
-                            cx,
-                            LINKEDLIST,
-                            hir_ty.span,
-                            "you seem to be using a `LinkedList`! Perhaps you meant some other data structure?",
-                            None,
-                            "a `VecDeque` might work",
-                        );
-                        return; // don't recurse into the type
-                    }
+                    triggered |= linked_list::check(cx, hir_ty, def_id);
 
                     if triggered {
                         return;
@@ -389,7 +377,6 @@ impl Types {
                 }
             },
             TyKind::Rptr(ref lt, ref mut_ty) => self.check_ty_rptr(cx, hir_ty, is_local, lt, mut_ty),
-            // recurse
             TyKind::Slice(ref ty) | TyKind::Array(ref ty, _) | TyKind::Ptr(MutTy { ref ty, .. }) => {
                 self.check_ty(cx, ty, is_local)
             },
diff --git a/clippy_lints/src/types/option_option.rs b/clippy_lints/src/types/option_option.rs
index 42aad70438b..d91132aaeb2 100644
--- a/clippy_lints/src/types/option_option.rs
+++ b/clippy_lints/src/types/option_option.rs
@@ -2,13 +2,11 @@ use rustc_hir::{self as hir, def_id::DefId, QPath};
 use rustc_lint::LateContext;
 use rustc_span::symbol::sym;
 
-use crate::utils::span_lint;
-
-use super::utils;
+use crate::utils::{is_ty_param_diagnostic_item, span_lint};
 
 pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_>, def_id: DefId) -> bool {
     if cx.tcx.is_diagnostic_item(sym::option_type, def_id) {
-        if utils::is_ty_param_diagnostic_item(cx, qpath, sym::option_type).is_some() {
+        if is_ty_param_diagnostic_item(cx, qpath, sym::option_type).is_some() {
             span_lint(
                 cx,
                 super::OPTION_OPTION,
-- 
cgit 1.4.1-3-g733a5


From 53d3ffe5395da729bbfed53dee826ad4ad1feb63 Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Fri, 12 Feb 2021 15:22:07 +0900
Subject: Move borrowed_box to its own module

---
 clippy_lints/src/types/borrowed_box.rs | 118 +++++++++++++++++++++++++++++++
 clippy_lints/src/types/mod.rs          | 122 +++------------------------------
 2 files changed, 127 insertions(+), 113 deletions(-)
 create mode 100644 clippy_lints/src/types/borrowed_box.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types/borrowed_box.rs b/clippy_lints/src/types/borrowed_box.rs
new file mode 100644
index 00000000000..4c2cad0ee94
--- /dev/null
+++ b/clippy_lints/src/types/borrowed_box.rs
@@ -0,0 +1,118 @@
+use rustc_errors::Applicability;
+use rustc_hir::{
+    self as hir, GenericArg, GenericBounds, GenericParamKind, HirId, Lifetime, MutTy, Mutability, Node, QPath,
+    SyntheticTyParamKind, TyKind,
+};
+use rustc_lint::LateContext;
+
+use if_chain::if_chain;
+
+use crate::utils::{match_path, paths, snippet, span_lint_and_sugg};
+
+pub(super) fn check(
+    cx: &LateContext<'_>,
+    hir_ty: &hir::Ty<'_>,
+    is_local: bool,
+    lt: &Lifetime,
+    mut_ty: &MutTy<'_>,
+) -> bool {
+    match mut_ty.ty.kind {
+        TyKind::Path(ref qpath) => {
+            let hir_id = mut_ty.ty.hir_id;
+            let def = cx.qpath_res(qpath, hir_id);
+            if_chain! {
+                if let Some(def_id) = def.opt_def_id();
+                if Some(def_id) == cx.tcx.lang_items().owned_box();
+                if let QPath::Resolved(None, ref path) = *qpath;
+                if let [ref bx] = *path.segments;
+                if let Some(ref params) = bx.args;
+                if !params.parenthesized;
+                if let Some(inner) = params.args.iter().find_map(|arg| match arg {
+                    GenericArg::Type(ty) => Some(ty),
+                    _ => None,
+                });
+                then {
+                    if is_any_trait(inner) {
+                        // Ignore `Box<Any>` types; see issue #1884 for details.
+                        return false;
+                    }
+
+                    let ltopt = if lt.is_elided() {
+                        String::new()
+                    } else {
+                        format!("{} ", lt.name.ident().as_str())
+                    };
+
+                    if mut_ty.mutbl == Mutability::Mut {
+                        // Ignore `&mut Box<T>` types; see issue #2907 for
+                        // details.
+                        return false;
+                    }
+
+                    // When trait objects or opaque types have lifetime or auto-trait bounds,
+                    // we need to add parentheses to avoid a syntax error due to its ambiguity.
+                    // Originally reported as the issue #3128.
+                    let inner_snippet = snippet(cx, inner.span, "..");
+                    let suggestion = match &inner.kind {
+                        TyKind::TraitObject(bounds, lt_bound) if bounds.len() > 1 || !lt_bound.is_elided() => {
+                            format!("&{}({})", ltopt, &inner_snippet)
+                        },
+                        TyKind::Path(qpath)
+                            if get_bounds_if_impl_trait(cx, qpath, inner.hir_id)
+                                .map_or(false, |bounds| bounds.len() > 1) =>
+                        {
+                            format!("&{}({})", ltopt, &inner_snippet)
+                        },
+                        _ => format!("&{}{}", ltopt, &inner_snippet),
+                    };
+                    span_lint_and_sugg(
+                        cx,
+                        super::BORROWED_BOX,
+                        hir_ty.span,
+                        "you seem to be trying to use `&Box<T>`. Consider using just `&T`",
+                        "try",
+                        suggestion,
+                        // To make this `MachineApplicable`, at least one needs to check if it isn't a trait item
+                        // because the trait impls of it will break otherwise;
+                        // and there may be other cases that result in invalid code.
+                        // For example, type coercion doesn't work nicely.
+                        Applicability::Unspecified,
+                    );
+                    return true;
+                }
+            };
+            false
+        },
+        _ => false,
+    }
+}
+
+// Returns true if given type is `Any` trait.
+fn is_any_trait(t: &hir::Ty<'_>) -> bool {
+    if_chain! {
+        if let TyKind::TraitObject(ref traits, _) = t.kind;
+        if !traits.is_empty();
+        // Only Send/Sync can be used as additional traits, so it is enough to
+        // check only the first trait.
+        if match_path(&traits[0].trait_ref.path, &paths::ANY_TRAIT);
+        then {
+            return true;
+        }
+    }
+
+    false
+}
+
+fn get_bounds_if_impl_trait<'tcx>(cx: &LateContext<'tcx>, qpath: &QPath<'_>, id: HirId) -> Option<GenericBounds<'tcx>> {
+    if_chain! {
+        if let Some(did) = cx.qpath_res(qpath, id).opt_def_id();
+        if let Some(Node::GenericParam(generic_param)) = cx.tcx.hir().get_if_local(did);
+        if let GenericParamKind::Type { synthetic, .. } = generic_param.kind;
+        if synthetic == Some(SyntheticTyParamKind::ImplTrait);
+        then {
+            Some(generic_param.bounds)
+        } else {
+            None
+        }
+    }
+}
diff --git a/clippy_lints/src/types/mod.rs b/clippy_lints/src/types/mod.rs
index 86a12b8ffa9..8c2fc553085 100644
--- a/clippy_lints/src/types/mod.rs
+++ b/clippy_lints/src/types/mod.rs
@@ -1,5 +1,6 @@
 #![allow(rustc::default_hash_types)]
 
+mod borrowed_box;
 mod box_vec;
 mod linked_list;
 mod option_option;
@@ -18,9 +19,9 @@ use rustc_errors::{Applicability, DiagnosticBuilder};
 use rustc_hir as hir;
 use rustc_hir::intravisit::{walk_body, walk_expr, walk_ty, FnKind, NestedVisitorMap, Visitor};
 use rustc_hir::{
-    BinOpKind, Block, Body, Expr, ExprKind, FnDecl, FnRetTy, FnSig, GenericArg, GenericBounds, GenericParamKind, HirId,
-    ImplItem, ImplItemKind, Item, ItemKind, Lifetime, Lit, Local, MatchSource, MutTy, Mutability, Node, QPath, Stmt,
-    StmtKind, SyntheticTyParamKind, TraitFn, TraitItem, TraitItemKind, TyKind, UnOp,
+    BinOpKind, Block, Body, Expr, ExprKind, FnDecl, FnRetTy, FnSig, GenericArg, GenericParamKind, HirId, ImplItem,
+    ImplItemKind, Item, ItemKind, Lit, Local, MatchSource, MutTy, Mutability, Node, QPath, Stmt, StmtKind, TraitFn,
+    TraitItem, TraitItemKind, TyKind, UnOp,
 };
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::hir::map::Map;
@@ -376,7 +377,11 @@ impl Types {
                     QPath::LangItem(..) => {},
                 }
             },
-            TyKind::Rptr(ref lt, ref mut_ty) => self.check_ty_rptr(cx, hir_ty, is_local, lt, mut_ty),
+            TyKind::Rptr(ref lt, ref mut_ty) => {
+                if !borrowed_box::check(cx, hir_ty, is_local, lt, mut_ty) {
+                    self.check_ty(cx, &mut_ty.ty, is_local);
+                }
+            },
             TyKind::Slice(ref ty) | TyKind::Array(ref ty, _) | TyKind::Ptr(MutTy { ref ty, .. }) => {
                 self.check_ty(cx, ty, is_local)
             },
@@ -388,115 +393,6 @@ impl Types {
             _ => {},
         }
     }
-
-    fn check_ty_rptr(
-        &mut self,
-        cx: &LateContext<'_>,
-        hir_ty: &hir::Ty<'_>,
-        is_local: bool,
-        lt: &Lifetime,
-        mut_ty: &MutTy<'_>,
-    ) {
-        match mut_ty.ty.kind {
-            TyKind::Path(ref qpath) => {
-                let hir_id = mut_ty.ty.hir_id;
-                let def = cx.qpath_res(qpath, hir_id);
-                if_chain! {
-                    if let Some(def_id) = def.opt_def_id();
-                    if Some(def_id) == cx.tcx.lang_items().owned_box();
-                    if let QPath::Resolved(None, ref path) = *qpath;
-                    if let [ref bx] = *path.segments;
-                    if let Some(ref params) = bx.args;
-                    if !params.parenthesized;
-                    if let Some(inner) = params.args.iter().find_map(|arg| match arg {
-                        GenericArg::Type(ty) => Some(ty),
-                        _ => None,
-                    });
-                    then {
-                        if is_any_trait(inner) {
-                            // Ignore `Box<Any>` types; see issue #1884 for details.
-                            return;
-                        }
-
-                        let ltopt = if lt.is_elided() {
-                            String::new()
-                        } else {
-                            format!("{} ", lt.name.ident().as_str())
-                        };
-
-                        if mut_ty.mutbl == Mutability::Mut {
-                            // Ignore `&mut Box<T>` types; see issue #2907 for
-                            // details.
-                            return;
-                        }
-
-                        // When trait objects or opaque types have lifetime or auto-trait bounds,
-                        // we need to add parentheses to avoid a syntax error due to its ambiguity.
-                        // Originally reported as the issue #3128.
-                        let inner_snippet = snippet(cx, inner.span, "..");
-                        let suggestion = match &inner.kind {
-                            TyKind::TraitObject(bounds, lt_bound) if bounds.len() > 1 || !lt_bound.is_elided() => {
-                                format!("&{}({})", ltopt, &inner_snippet)
-                            },
-                            TyKind::Path(qpath)
-                                if get_bounds_if_impl_trait(cx, qpath, inner.hir_id)
-                                    .map_or(false, |bounds| bounds.len() > 1) =>
-                            {
-                                format!("&{}({})", ltopt, &inner_snippet)
-                            },
-                            _ => format!("&{}{}", ltopt, &inner_snippet),
-                        };
-                        span_lint_and_sugg(
-                            cx,
-                            BORROWED_BOX,
-                            hir_ty.span,
-                            "you seem to be trying to use `&Box<T>`. Consider using just `&T`",
-                            "try",
-                            suggestion,
-                            // To make this `MachineApplicable`, at least one needs to check if it isn't a trait item
-                            // because the trait impls of it will break otherwise;
-                            // and there may be other cases that result in invalid code.
-                            // For example, type coercion doesn't work nicely.
-                            Applicability::Unspecified,
-                        );
-                        return; // don't recurse into the type
-                    }
-                };
-                self.check_ty(cx, &mut_ty.ty, is_local);
-            },
-            _ => self.check_ty(cx, &mut_ty.ty, is_local),
-        }
-    }
-}
-
-// Returns true if given type is `Any` trait.
-fn is_any_trait(t: &hir::Ty<'_>) -> bool {
-    if_chain! {
-        if let TyKind::TraitObject(ref traits, _) = t.kind;
-        if !traits.is_empty();
-        // Only Send/Sync can be used as additional traits, so it is enough to
-        // check only the first trait.
-        if match_path(&traits[0].trait_ref.path, &paths::ANY_TRAIT);
-        then {
-            return true;
-        }
-    }
-
-    false
-}
-
-fn get_bounds_if_impl_trait<'tcx>(cx: &LateContext<'tcx>, qpath: &QPath<'_>, id: HirId) -> Option<GenericBounds<'tcx>> {
-    if_chain! {
-        if let Some(did) = cx.qpath_res(qpath, id).opt_def_id();
-        if let Some(Node::GenericParam(generic_param)) = cx.tcx.hir().get_if_local(did);
-        if let GenericParamKind::Type { synthetic, .. } = generic_param.kind;
-        if synthetic == Some(SyntheticTyParamKind::ImplTrait);
-        then {
-            Some(generic_param.bounds)
-        } else {
-            None
-        }
-    }
 }
 
 declare_clippy_lint! {
-- 
cgit 1.4.1-3-g733a5


From 2afa7df564e6b6d2126578fd9b997d6c2abc4935 Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Fri, 12 Feb 2021 15:26:36 +0900
Subject: Remove unused is_local from borrowed_box

---
 clippy_lints/src/types/borrowed_box.rs | 8 +-------
 clippy_lints/src/types/mod.rs          | 5 ++---
 2 files changed, 3 insertions(+), 10 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types/borrowed_box.rs b/clippy_lints/src/types/borrowed_box.rs
index 4c2cad0ee94..c9b96a7d325 100644
--- a/clippy_lints/src/types/borrowed_box.rs
+++ b/clippy_lints/src/types/borrowed_box.rs
@@ -9,13 +9,7 @@ use if_chain::if_chain;
 
 use crate::utils::{match_path, paths, snippet, span_lint_and_sugg};
 
-pub(super) fn check(
-    cx: &LateContext<'_>,
-    hir_ty: &hir::Ty<'_>,
-    is_local: bool,
-    lt: &Lifetime,
-    mut_ty: &MutTy<'_>,
-) -> bool {
+pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, lt: &Lifetime, mut_ty: &MutTy<'_>) -> bool {
     match mut_ty.ty.kind {
         TyKind::Path(ref qpath) => {
             let hir_id = mut_ty.ty.hir_id;
diff --git a/clippy_lints/src/types/mod.rs b/clippy_lints/src/types/mod.rs
index 8c2fc553085..25cc40917c3 100644
--- a/clippy_lints/src/types/mod.rs
+++ b/clippy_lints/src/types/mod.rs
@@ -312,8 +312,7 @@ impl Types {
     /// Recursively check for `TypePass` lints in the given type. Stop at the first
     /// lint found.
     ///
-    /// The parameter `is_local` distinguishes the context of the type; types from
-    /// local bindings should only be checked for the `BORROWED_BOX` lint.
+    /// The parameter `is_local` distinguishes the context of the type.
     fn check_ty(&mut self, cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, is_local: bool) {
         if hir_ty.span.from_expansion() {
             return;
@@ -378,7 +377,7 @@ impl Types {
                 }
             },
             TyKind::Rptr(ref lt, ref mut_ty) => {
-                if !borrowed_box::check(cx, hir_ty, is_local, lt, mut_ty) {
+                if !borrowed_box::check(cx, hir_ty, lt, mut_ty) {
                     self.check_ty(cx, &mut_ty.ty, is_local);
                 }
             },
-- 
cgit 1.4.1-3-g733a5


From bb8208da2beba7782d741edfc2b1027ffa823ba5 Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Tue, 16 Feb 2021 22:18:53 +0900
Subject: Import declared lints at the top of the file

---
 clippy_lints/src/types/borrowed_box.rs  | 4 +++-
 clippy_lints/src/types/linked_list.rs   | 4 +++-
 clippy_lints/src/types/option_option.rs | 4 +++-
 3 files changed, 9 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types/borrowed_box.rs b/clippy_lints/src/types/borrowed_box.rs
index c9b96a7d325..a7a511b21cf 100644
--- a/clippy_lints/src/types/borrowed_box.rs
+++ b/clippy_lints/src/types/borrowed_box.rs
@@ -9,6 +9,8 @@ use if_chain::if_chain;
 
 use crate::utils::{match_path, paths, snippet, span_lint_and_sugg};
 
+use super::BORROWED_BOX;
+
 pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, lt: &Lifetime, mut_ty: &MutTy<'_>) -> bool {
     match mut_ty.ty.kind {
         TyKind::Path(ref qpath) => {
@@ -61,7 +63,7 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, lt: &Lifetime, m
                     };
                     span_lint_and_sugg(
                         cx,
-                        super::BORROWED_BOX,
+                        BORROWED_BOX,
                         hir_ty.span,
                         "you seem to be trying to use `&Box<T>`. Consider using just `&T`",
                         "try",
diff --git a/clippy_lints/src/types/linked_list.rs b/clippy_lints/src/types/linked_list.rs
index 74be8959fa4..47eb4ede4e4 100644
--- a/clippy_lints/src/types/linked_list.rs
+++ b/clippy_lints/src/types/linked_list.rs
@@ -3,11 +3,13 @@ use rustc_lint::LateContext;
 
 use crate::utils::{match_def_path, paths, span_lint_and_help};
 
+use super::LINKEDLIST;
+
 pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, def_id: DefId) -> bool {
     if match_def_path(cx, def_id, &paths::LINKED_LIST) {
         span_lint_and_help(
             cx,
-            super::LINKEDLIST,
+            LINKEDLIST,
             hir_ty.span,
             "you seem to be using a `LinkedList`! Perhaps you meant some other data structure?",
             None,
diff --git a/clippy_lints/src/types/option_option.rs b/clippy_lints/src/types/option_option.rs
index d91132aaeb2..a1fc26f7865 100644
--- a/clippy_lints/src/types/option_option.rs
+++ b/clippy_lints/src/types/option_option.rs
@@ -4,12 +4,14 @@ use rustc_span::symbol::sym;
 
 use crate::utils::{is_ty_param_diagnostic_item, span_lint};
 
+use super::OPTION_OPTION;
+
 pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_>, def_id: DefId) -> bool {
     if cx.tcx.is_diagnostic_item(sym::option_type, def_id) {
         if is_ty_param_diagnostic_item(cx, qpath, sym::option_type).is_some() {
             span_lint(
                 cx,
-                super::OPTION_OPTION,
+                OPTION_OPTION,
                 hir_ty.span,
                 "consider using `Option<T>` instead of `Option<Option<T>>` or a custom \
                                  enum if you need to distinguish all 3 cases",
-- 
cgit 1.4.1-3-g733a5


From db59c35b7eb6cebe7e392fad3f223eb458d80a5d Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Fri, 26 Feb 2021 01:06:15 +0900
Subject: Fix some lints in types that fail dogfood

---
 clippy_lints/src/types/box_vec.rs              | 27 +++++++++++++-------------
 clippy_lints/src/types/option_option.rs        | 23 +++++++++++-----------
 clippy_lints/src/types/redundant_allocation.rs | 26 ++++++++++++-------------
 3 files changed, 39 insertions(+), 37 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types/box_vec.rs b/clippy_lints/src/types/box_vec.rs
index 4eb032cae6b..6aa98e435e1 100644
--- a/clippy_lints/src/types/box_vec.rs
+++ b/clippy_lints/src/types/box_vec.rs
@@ -7,18 +7,19 @@ use crate::utils::{is_ty_param_diagnostic_item, span_lint_and_help};
 use super::BOX_VEC;
 
 pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_>, def_id: DefId) -> bool {
-    if Some(def_id) == cx.tcx.lang_items().owned_box() {
-        if is_ty_param_diagnostic_item(cx, qpath, sym::vec_type).is_some() {
-            span_lint_and_help(
-                cx,
-                BOX_VEC,
-                hir_ty.span,
-                "you seem to be trying to use `Box<Vec<T>>`. Consider using just `Vec<T>`",
-                None,
-                "`Vec<T>` is already on the heap, `Box<Vec<T>>` makes an extra allocation",
-            );
-            return true;
-        }
+    if Some(def_id) == cx.tcx.lang_items().owned_box()
+        && is_ty_param_diagnostic_item(cx, qpath, sym::vec_type).is_some()
+    {
+        span_lint_and_help(
+            cx,
+            BOX_VEC,
+            hir_ty.span,
+            "you seem to be trying to use `Box<Vec<T>>`. Consider using just `Vec<T>`",
+            None,
+            "`Vec<T>` is already on the heap, `Box<Vec<T>>` makes an extra allocation",
+        );
+        true
+    } else {
+        false
     }
-    false
 }
diff --git a/clippy_lints/src/types/option_option.rs b/clippy_lints/src/types/option_option.rs
index a1fc26f7865..dc5db963b4e 100644
--- a/clippy_lints/src/types/option_option.rs
+++ b/clippy_lints/src/types/option_option.rs
@@ -7,17 +7,18 @@ use crate::utils::{is_ty_param_diagnostic_item, span_lint};
 use super::OPTION_OPTION;
 
 pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_>, def_id: DefId) -> bool {
-    if cx.tcx.is_diagnostic_item(sym::option_type, def_id) {
-        if is_ty_param_diagnostic_item(cx, qpath, sym::option_type).is_some() {
-            span_lint(
-                cx,
-                OPTION_OPTION,
-                hir_ty.span,
-                "consider using `Option<T>` instead of `Option<Option<T>>` or a custom \
+    if cx.tcx.is_diagnostic_item(sym::option_type, def_id)
+        && is_ty_param_diagnostic_item(cx, qpath, sym::option_type).is_some()
+    {
+        span_lint(
+            cx,
+            OPTION_OPTION,
+            hir_ty.span,
+            "consider using `Option<T>` instead of `Option<Option<T>>` or a custom \
                                  enum if you need to distinguish all 3 cases",
-            );
-            return true;
-        }
+        );
+        true
+    } else {
+        false
     }
-    false
 }
diff --git a/clippy_lints/src/types/redundant_allocation.rs b/clippy_lints/src/types/redundant_allocation.rs
index ea5a675827a..5da6db179c4 100644
--- a/clippy_lints/src/types/redundant_allocation.rs
+++ b/clippy_lints/src/types/redundant_allocation.rs
@@ -63,20 +63,20 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_
                 applicability,
             );
             true
-        } else if let Some(span) = utils::match_borrows_parameter(cx, qpath) {
-            let mut applicability = Applicability::MachineApplicable;
-            span_lint_and_sugg(
-                cx,
-                REDUNDANT_ALLOCATION,
-                hir_ty.span,
-                "usage of `Rc<&T>`",
-                "try",
-                snippet_with_applicability(cx, span, "..", &mut applicability).to_string(),
-                applicability,
-            );
-            true
         } else {
-            false
+            utils::match_borrows_parameter(cx, qpath).map_or(false, |span| {
+                let mut applicability = Applicability::MachineApplicable;
+                span_lint_and_sugg(
+                    cx,
+                    REDUNDANT_ALLOCATION,
+                    hir_ty.span,
+                    "usage of `Rc<&T>`",
+                    "try",
+                    snippet_with_applicability(cx, span, "..", &mut applicability).to_string(),
+                    applicability,
+                );
+                true
+            })
         }
     } else {
         false
-- 
cgit 1.4.1-3-g733a5


From f2d917e3b1e6c91fe005e2dabc7cb5627de6d813 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Mon, 8 Mar 2021 11:08:52 -0500
Subject: Don't assume lang items will exist.

---
 clippy_lints/src/derive.rs    |  7 ++++++-
 clippy_lints/src/lifetimes.rs | 11 +++++++----
 clippy_lints/src/map_clone.rs |  2 +-
 clippy_utils/src/lib.rs       |  8 ++++++--
 4 files changed, 20 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/derive.rs b/clippy_lints/src/derive.rs
index 382a045a3f7..594c370f660 100644
--- a/clippy_lints/src/derive.rs
+++ b/clippy_lints/src/derive.rs
@@ -293,7 +293,12 @@ fn check_ord_partial_ord<'tcx>(
 
 /// Implementation of the `EXPL_IMPL_CLONE_ON_COPY` lint.
 fn check_copy_clone<'tcx>(cx: &LateContext<'tcx>, item: &Item<'_>, trait_ref: &TraitRef<'_>, ty: Ty<'tcx>) {
-    if cx.tcx.lang_items().clone_trait() == trait_ref.trait_def_id() {
+    if cx
+        .tcx
+        .lang_items()
+        .clone_trait()
+        .map_or(false, |id| Some(id) == trait_ref.trait_def_id())
+    {
         if !is_copy(cx, ty) {
             return;
         }
diff --git a/clippy_lints/src/lifetimes.rs b/clippy_lints/src/lifetimes.rs
index 3807d346f68..33ff01a30e8 100644
--- a/clippy_lints/src/lifetimes.rs
+++ b/clippy_lints/src/lifetimes.rs
@@ -358,10 +358,13 @@ impl<'a, 'tcx> Visitor<'tcx> for RefVisitor<'a, 'tcx> {
 
     fn visit_poly_trait_ref(&mut self, poly_tref: &'tcx PolyTraitRef<'tcx>, tbm: TraitBoundModifier) {
         let trait_ref = &poly_tref.trait_ref;
-        if CLOSURE_TRAIT_BOUNDS
-            .iter()
-            .any(|&item| trait_ref.trait_def_id() == self.cx.tcx.lang_items().require(item).ok())
-        {
+        if CLOSURE_TRAIT_BOUNDS.iter().any(|&item| {
+            self.cx
+                .tcx
+                .lang_items()
+                .require(item)
+                .map_or(false, |id| Some(id) == trait_ref.trait_def_id())
+        }) {
             let mut sub_visitor = RefVisitor::new(self.cx);
             sub_visitor.visit_trait_ref(trait_ref);
             self.nested_elision_site_lts.append(&mut sub_visitor.all_lts());
diff --git a/clippy_lints/src/map_clone.rs b/clippy_lints/src/map_clone.rs
index 0c358e2e538..4b685c09a05 100644
--- a/clippy_lints/src/map_clone.rs
+++ b/clippy_lints/src/map_clone.rs
@@ -81,7 +81,7 @@ impl<'tcx> LateLintPass<'tcx> for MapClone {
                                 if ident_eq(name, obj) && method.ident.name == sym::clone;
                                 if let Some(fn_id) = cx.typeck_results().type_dependent_def_id(closure_expr.hir_id);
                                 if let Some(trait_id) = cx.tcx.trait_of_item(fn_id);
-                                if Some(trait_id) == cx.tcx.lang_items().clone_trait();
+                                if cx.tcx.lang_items().clone_trait().map_or(false, |id| id == trait_id);
                                 // no autoderefs
                                 if !cx.typeck_results().expr_adjustments(obj).iter()
                                     .any(|a| matches!(a.kind, Adjust::Deref(Some(..))));
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 3845667802d..1f62cf5ae7f 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -239,7 +239,10 @@ pub fn is_ty_param_lang_item(cx: &LateContext<'_>, qpath: &QPath<'tcx>, item: La
     if let TyKind::Path(qpath) = &ty.kind {
         cx.qpath_res(qpath, ty.hir_id)
             .opt_def_id()
-            .and_then(|id| (cx.tcx.lang_items().require(item) == Ok(id)).then(|| ty))
+            .map_or(false, |id| {
+                cx.tcx.lang_items().require(item).map_or(false, |lang_id| id == lang_id)
+            })
+            .then(|| ty)
     } else {
         None
     }
@@ -256,7 +259,8 @@ pub fn is_ty_param_diagnostic_item(
     if let TyKind::Path(qpath) = &ty.kind {
         cx.qpath_res(qpath, ty.hir_id)
             .opt_def_id()
-            .and_then(|id| cx.tcx.is_diagnostic_item(item, id).then(|| ty))
+            .map_or(false, |id| cx.tcx.is_diagnostic_item(item, id))
+            .then(|| ty)
     } else {
         None
     }
-- 
cgit 1.4.1-3-g733a5


From bf98aa6fb8e02db15ad18d517145f13a5bed2921 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Mon, 8 Mar 2021 12:59:58 -0600
Subject: Fix redundant closure with macros

---
 clippy_lints/src/eta_reduction.rs | 24 +++++++++++++++++++++++-
 tests/ui/eta.fixed                | 15 +++++++++++++++
 tests/ui/eta.rs                   | 15 +++++++++++++++
 tests/ui/eta.stderr               | 32 +++++++++++++++++++-------------
 4 files changed, 72 insertions(+), 14 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/eta_reduction.rs b/clippy_lints/src/eta_reduction.rs
index 1a722d39f73..ab385fc1f8a 100644
--- a/clippy_lints/src/eta_reduction.rs
+++ b/clippy_lints/src/eta_reduction.rs
@@ -10,6 +10,8 @@ use crate::utils::{
     implements_trait, is_adjusted, iter_input_pats, snippet_opt, span_lint_and_sugg, span_lint_and_then,
     type_is_unsafe_function,
 };
+use clippy_utils::higher;
+use clippy_utils::higher::VecArgs;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for closures which just call another function where
@@ -74,7 +76,10 @@ impl<'tcx> LateLintPass<'tcx> for EtaReduction {
         match expr.kind {
             ExprKind::Call(_, args) | ExprKind::MethodCall(_, _, args, _) => {
                 for arg in args {
-                    check_closure(cx, arg)
+                    // skip `foo(macro!())`
+                    if arg.span.ctxt() == expr.span.ctxt() {
+                        check_closure(cx, arg)
+                    }
                 }
             },
             _ => (),
@@ -87,6 +92,23 @@ fn check_closure(cx: &LateContext<'_>, expr: &Expr<'_>) {
         let body = cx.tcx.hir().body(eid);
         let ex = &body.value;
 
+        if ex.span.ctxt() != expr.span.ctxt() {
+            if let Some(VecArgs::Vec(&[])) = higher::vec_macro(cx, ex) {
+                // replace `|| vec![]` with `Vec::new`
+                span_lint_and_sugg(
+                    cx,
+                    REDUNDANT_CLOSURE,
+                    expr.span,
+                    "redundant closure found",
+                    "remove closure as shown",
+                    "std::vec::Vec::new".into(),
+                    Applicability::MachineApplicable,
+                );
+            }
+            // skip `foo(|| macro!())`
+            return;
+        }
+
         if_chain!(
             if let ExprKind::Call(ref caller, ref args) = ex.kind;
 
diff --git a/tests/ui/eta.fixed b/tests/ui/eta.fixed
index 1b34c2f74eb..2be2283e3fd 100644
--- a/tests/ui/eta.fixed
+++ b/tests/ui/eta.fixed
@@ -16,10 +16,25 @@
 
 use std::path::PathBuf;
 
+macro_rules! mac {
+    () => {
+        foobar()
+    };
+}
+
+macro_rules! closure_mac {
+    () => {
+        |n| foo(n)
+    };
+}
+
 fn main() {
     let a = Some(1u8).map(foo);
     meta(foo);
     let c = Some(1u8).map(|a| {1+2; foo}(a));
+    true.then(|| mac!()); // don't lint function in macro expansion
+    Some(1).map(closure_mac!()); // don't lint closure in macro expansion
+    let _: Option<Vec<u8>> = true.then(std::vec::Vec::new); // special case vec!
     let d = Some(1u8).map(|a| foo((|b| foo2(b))(a))); //is adjusted?
     all(&[1, 2, 3], &2, |x, y| below(x, y)); //is adjusted
     unsafe {
diff --git a/tests/ui/eta.rs b/tests/ui/eta.rs
index 4f050bd8479..f0373f9ccf6 100644
--- a/tests/ui/eta.rs
+++ b/tests/ui/eta.rs
@@ -16,10 +16,25 @@
 
 use std::path::PathBuf;
 
+macro_rules! mac {
+    () => {
+        foobar()
+    };
+}
+
+macro_rules! closure_mac {
+    () => {
+        |n| foo(n)
+    };
+}
+
 fn main() {
     let a = Some(1u8).map(|a| foo(a));
     meta(|a| foo(a));
     let c = Some(1u8).map(|a| {1+2; foo}(a));
+    true.then(|| mac!()); // don't lint function in macro expansion
+    Some(1).map(closure_mac!()); // don't lint closure in macro expansion
+    let _: Option<Vec<u8>> = true.then(|| vec![]); // special case vec!
     let d = Some(1u8).map(|a| foo((|b| foo2(b))(a))); //is adjusted?
     all(&[1, 2, 3], &&2, |x, y| below(x, y)); //is adjusted
     unsafe {
diff --git a/tests/ui/eta.stderr b/tests/ui/eta.stderr
index 16aa1b07733..34d6dd46311 100644
--- a/tests/ui/eta.stderr
+++ b/tests/ui/eta.stderr
@@ -1,5 +1,5 @@
 error: redundant closure found
-  --> $DIR/eta.rs:20:27
+  --> $DIR/eta.rs:32:27
    |
 LL |     let a = Some(1u8).map(|a| foo(a));
    |                           ^^^^^^^^^^ help: remove closure as shown: `foo`
@@ -7,13 +7,19 @@ LL |     let a = Some(1u8).map(|a| foo(a));
    = note: `-D clippy::redundant-closure` implied by `-D warnings`
 
 error: redundant closure found
-  --> $DIR/eta.rs:21:10
+  --> $DIR/eta.rs:33:10
    |
 LL |     meta(|a| foo(a));
    |          ^^^^^^^^^^ help: remove closure as shown: `foo`
 
+error: redundant closure found
+  --> $DIR/eta.rs:37:40
+   |
+LL |     let _: Option<Vec<u8>> = true.then(|| vec![]); // special case vec!
+   |                                        ^^^^^^^^^ help: remove closure as shown: `std::vec::Vec::new`
+
 error: this expression borrows a reference (`&u8`) that is immediately dereferenced by the compiler
-  --> $DIR/eta.rs:24:21
+  --> $DIR/eta.rs:39:21
    |
 LL |     all(&[1, 2, 3], &&2, |x, y| below(x, y)); //is adjusted
    |                     ^^^ help: change this to: `&2`
@@ -21,13 +27,13 @@ LL |     all(&[1, 2, 3], &&2, |x, y| below(x, y)); //is adjusted
    = note: `-D clippy::needless-borrow` implied by `-D warnings`
 
 error: redundant closure found
-  --> $DIR/eta.rs:31:27
+  --> $DIR/eta.rs:46:27
    |
 LL |     let e = Some(1u8).map(|a| generic(a));
    |                           ^^^^^^^^^^^^^^ help: remove closure as shown: `generic`
 
 error: redundant closure found
-  --> $DIR/eta.rs:74:51
+  --> $DIR/eta.rs:89:51
    |
 LL |     let e = Some(TestStruct { some_ref: &i }).map(|a| a.foo());
    |                                                   ^^^^^^^^^^^ help: remove closure as shown: `TestStruct::foo`
@@ -35,46 +41,46 @@ LL |     let e = Some(TestStruct { some_ref: &i }).map(|a| a.foo());
    = note: `-D clippy::redundant-closure-for-method-calls` implied by `-D warnings`
 
 error: redundant closure found
-  --> $DIR/eta.rs:76:51
+  --> $DIR/eta.rs:91:51
    |
 LL |     let e = Some(TestStruct { some_ref: &i }).map(|a| a.trait_foo());
    |                                                   ^^^^^^^^^^^^^^^^^ help: remove closure as shown: `TestTrait::trait_foo`
 
 error: redundant closure found
-  --> $DIR/eta.rs:79:42
+  --> $DIR/eta.rs:94:42
    |
 LL |     let e = Some(&mut vec![1, 2, 3]).map(|v| v.clear());
    |                                          ^^^^^^^^^^^^^ help: remove closure as shown: `std::vec::Vec::clear`
 
 error: redundant closure found
-  --> $DIR/eta.rs:84:29
+  --> $DIR/eta.rs:99:29
    |
 LL |     let e = Some("str").map(|s| s.to_string());
    |                             ^^^^^^^^^^^^^^^^^ help: remove closure as shown: `std::string::ToString::to_string`
 
 error: redundant closure found
-  --> $DIR/eta.rs:86:27
+  --> $DIR/eta.rs:101:27
    |
 LL |     let e = Some('a').map(|s| s.to_uppercase());
    |                           ^^^^^^^^^^^^^^^^^^^^ help: remove closure as shown: `char::to_uppercase`
 
 error: redundant closure found
-  --> $DIR/eta.rs:89:65
+  --> $DIR/eta.rs:104:65
    |
 LL |     let e: std::vec::Vec<char> = vec!['a', 'b', 'c'].iter().map(|c| c.to_ascii_uppercase()).collect();
    |                                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove closure as shown: `char::to_ascii_uppercase`
 
 error: redundant closure found
-  --> $DIR/eta.rs:172:27
+  --> $DIR/eta.rs:187:27
    |
 LL |     let a = Some(1u8).map(|a| foo_ptr(a));
    |                           ^^^^^^^^^^^^^^ help: remove closure as shown: `foo_ptr`
 
 error: redundant closure found
-  --> $DIR/eta.rs:177:27
+  --> $DIR/eta.rs:192:27
    |
 LL |     let a = Some(1u8).map(|a| closure(a));
    |                           ^^^^^^^^^^^^^^ help: remove closure as shown: `closure`
 
-error: aborting due to 12 previous errors
+error: aborting due to 13 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 8c540dcd2d1d240219c1a4aa28dd745ea010b501 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Mon, 8 Mar 2021 13:05:13 -0600
Subject: Improve the redundant_closure message

---
 clippy_lints/src/eta_reduction.rs | 12 +++++-----
 tests/ui/eta.stderr               | 48 +++++++++++++++++++--------------------
 2 files changed, 30 insertions(+), 30 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/eta_reduction.rs b/clippy_lints/src/eta_reduction.rs
index ab385fc1f8a..c461732fd36 100644
--- a/clippy_lints/src/eta_reduction.rs
+++ b/clippy_lints/src/eta_reduction.rs
@@ -99,8 +99,8 @@ fn check_closure(cx: &LateContext<'_>, expr: &Expr<'_>) {
                     cx,
                     REDUNDANT_CLOSURE,
                     expr.span,
-                    "redundant closure found",
-                    "remove closure as shown",
+                    "redundant closure",
+                    "replace the closure with `Vec::new`",
                     "std::vec::Vec::new".into(),
                     Applicability::MachineApplicable,
                 );
@@ -129,11 +129,11 @@ fn check_closure(cx: &LateContext<'_>, expr: &Expr<'_>) {
             if compare_inputs(&mut iter_input_pats(decl, body), &mut args.iter());
 
             then {
-                span_lint_and_then(cx, REDUNDANT_CLOSURE, expr.span, "redundant closure found", |diag| {
+                span_lint_and_then(cx, REDUNDANT_CLOSURE, expr.span, "redundant closure", |diag| {
                     if let Some(snippet) = snippet_opt(cx, caller.span) {
                         diag.span_suggestion(
                             expr.span,
-                            "remove closure as shown",
+                            "replace the closure with the function itself",
                             snippet,
                             Applicability::MachineApplicable,
                         );
@@ -163,8 +163,8 @@ fn check_closure(cx: &LateContext<'_>, expr: &Expr<'_>) {
                     cx,
                     REDUNDANT_CLOSURE_FOR_METHOD_CALLS,
                     expr.span,
-                    "redundant closure found",
-                    "remove closure as shown",
+                    "redundant closure",
+                    "replace the closure with the method itself",
                     format!("{}::{}", name, path.ident.name),
                     Applicability::MachineApplicable,
                 );
diff --git a/tests/ui/eta.stderr b/tests/ui/eta.stderr
index 34d6dd46311..57ed6527966 100644
--- a/tests/ui/eta.stderr
+++ b/tests/ui/eta.stderr
@@ -1,22 +1,22 @@
-error: redundant closure found
+error: redundant closure
   --> $DIR/eta.rs:32:27
    |
 LL |     let a = Some(1u8).map(|a| foo(a));
-   |                           ^^^^^^^^^^ help: remove closure as shown: `foo`
+   |                           ^^^^^^^^^^ help: replace the closure with the function itself: `foo`
    |
    = note: `-D clippy::redundant-closure` implied by `-D warnings`
 
-error: redundant closure found
+error: redundant closure
   --> $DIR/eta.rs:33:10
    |
 LL |     meta(|a| foo(a));
-   |          ^^^^^^^^^^ help: remove closure as shown: `foo`
+   |          ^^^^^^^^^^ help: replace the closure with the function itself: `foo`
 
-error: redundant closure found
+error: redundant closure
   --> $DIR/eta.rs:37:40
    |
 LL |     let _: Option<Vec<u8>> = true.then(|| vec![]); // special case vec!
-   |                                        ^^^^^^^^^ help: remove closure as shown: `std::vec::Vec::new`
+   |                                        ^^^^^^^^^ help: replace the closure with `Vec::new`: `std::vec::Vec::new`
 
 error: this expression borrows a reference (`&u8`) that is immediately dereferenced by the compiler
   --> $DIR/eta.rs:39:21
@@ -26,61 +26,61 @@ LL |     all(&[1, 2, 3], &&2, |x, y| below(x, y)); //is adjusted
    |
    = note: `-D clippy::needless-borrow` implied by `-D warnings`
 
-error: redundant closure found
+error: redundant closure
   --> $DIR/eta.rs:46:27
    |
 LL |     let e = Some(1u8).map(|a| generic(a));
-   |                           ^^^^^^^^^^^^^^ help: remove closure as shown: `generic`
+   |                           ^^^^^^^^^^^^^^ help: replace the closure with the function itself: `generic`
 
-error: redundant closure found
+error: redundant closure
   --> $DIR/eta.rs:89:51
    |
 LL |     let e = Some(TestStruct { some_ref: &i }).map(|a| a.foo());
-   |                                                   ^^^^^^^^^^^ help: remove closure as shown: `TestStruct::foo`
+   |                                                   ^^^^^^^^^^^ help: replace the closure with the method itself: `TestStruct::foo`
    |
    = note: `-D clippy::redundant-closure-for-method-calls` implied by `-D warnings`
 
-error: redundant closure found
+error: redundant closure
   --> $DIR/eta.rs:91:51
    |
 LL |     let e = Some(TestStruct { some_ref: &i }).map(|a| a.trait_foo());
-   |                                                   ^^^^^^^^^^^^^^^^^ help: remove closure as shown: `TestTrait::trait_foo`
+   |                                                   ^^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `TestTrait::trait_foo`
 
-error: redundant closure found
+error: redundant closure
   --> $DIR/eta.rs:94:42
    |
 LL |     let e = Some(&mut vec![1, 2, 3]).map(|v| v.clear());
-   |                                          ^^^^^^^^^^^^^ help: remove closure as shown: `std::vec::Vec::clear`
+   |                                          ^^^^^^^^^^^^^ help: replace the closure with the method itself: `std::vec::Vec::clear`
 
-error: redundant closure found
+error: redundant closure
   --> $DIR/eta.rs:99:29
    |
 LL |     let e = Some("str").map(|s| s.to_string());
-   |                             ^^^^^^^^^^^^^^^^^ help: remove closure as shown: `std::string::ToString::to_string`
+   |                             ^^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `std::string::ToString::to_string`
 
-error: redundant closure found
+error: redundant closure
   --> $DIR/eta.rs:101:27
    |
 LL |     let e = Some('a').map(|s| s.to_uppercase());
-   |                           ^^^^^^^^^^^^^^^^^^^^ help: remove closure as shown: `char::to_uppercase`
+   |                           ^^^^^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `char::to_uppercase`
 
-error: redundant closure found
+error: redundant closure
   --> $DIR/eta.rs:104:65
    |
 LL |     let e: std::vec::Vec<char> = vec!['a', 'b', 'c'].iter().map(|c| c.to_ascii_uppercase()).collect();
-   |                                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove closure as shown: `char::to_ascii_uppercase`
+   |                                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `char::to_ascii_uppercase`
 
-error: redundant closure found
+error: redundant closure
   --> $DIR/eta.rs:187:27
    |
 LL |     let a = Some(1u8).map(|a| foo_ptr(a));
-   |                           ^^^^^^^^^^^^^^ help: remove closure as shown: `foo_ptr`
+   |                           ^^^^^^^^^^^^^^ help: replace the closure with the function itself: `foo_ptr`
 
-error: redundant closure found
+error: redundant closure
   --> $DIR/eta.rs:192:27
    |
 LL |     let a = Some(1u8).map(|a| closure(a));
-   |                           ^^^^^^^^^^^^^^ help: remove closure as shown: `closure`
+   |                           ^^^^^^^^^^^^^^ help: replace the closure with the function itself: `closure`
 
 error: aborting due to 13 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From f098007caaebe660b06ee7c43cd30006807a2a8c Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Tue, 9 Mar 2021 10:57:25 +0900
Subject: Separate lints of casts group from types group

---
 clippy_lints/src/casts/mod.rs | 973 ++++++++++++++++++++++++++++++++++++++++++
 clippy_lints/src/lib.rs       |  67 +--
 clippy_lints/src/types/mod.rs | 969 +----------------------------------------
 3 files changed, 1015 insertions(+), 994 deletions(-)
 create mode 100644 clippy_lints/src/casts/mod.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
new file mode 100644
index 00000000000..d8245a3b88f
--- /dev/null
+++ b/clippy_lints/src/casts/mod.rs
@@ -0,0 +1,973 @@
+use std::borrow::Cow;
+
+use if_chain::if_chain;
+use rustc_ast::{LitFloatType, LitIntType, LitKind};
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind, GenericArg, Lit, MutTy, Mutability, TyKind, UnOp};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_middle::lint::in_external_macro;
+use rustc_middle::ty::{self, FloatTy, InferTy, IntTy, Ty, TyCtxt, TypeAndMut, UintTy};
+use rustc_semver::RustcVersion;
+use rustc_session::{declare_lint_pass, declare_tool_lint, impl_lint_pass};
+use rustc_span::symbol::sym;
+use rustc_target::abi::LayoutOf;
+
+use crate::consts::{constant, Constant};
+use crate::utils::sugg::Sugg;
+use crate::utils::{
+    in_constant, is_hir_ty_cfg_dependant, meets_msrv, method_chain_args, numeric_literal::NumericLiteral, sext,
+    snippet_opt, snippet_with_applicability, span_lint, span_lint_and_sugg, span_lint_and_then,
+};
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for casts from any numerical to a float type where
+    /// the receiving type cannot store all values from the original type without
+    /// rounding errors. This possible rounding is to be expected, so this lint is
+    /// `Allow` by default.
+    ///
+    /// Basically, this warns on casting any integer with 32 or more bits to `f32`
+    /// or any 64-bit integer to `f64`.
+    ///
+    /// **Why is this bad?** It's not bad at all. But in some applications it can be
+    /// helpful to know where precision loss can take place. This lint can help find
+    /// those places in the code.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// ```rust
+    /// let x = u64::MAX;
+    /// x as f64;
+    /// ```
+    pub CAST_PRECISION_LOSS,
+    pedantic,
+    "casts that cause loss of precision, e.g., `x as f32` where `x: u64`"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for casts from a signed to an unsigned numerical
+    /// type. In this case, negative values wrap around to large positive values,
+    /// which can be quite surprising in practice. However, as the cast works as
+    /// defined, this lint is `Allow` by default.
+    ///
+    /// **Why is this bad?** Possibly surprising results. You can activate this lint
+    /// as a one-time check to see where numerical wrapping can arise.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// ```rust
+    /// let y: i8 = -1;
+    /// y as u128; // will return 18446744073709551615
+    /// ```
+    pub CAST_SIGN_LOSS,
+    pedantic,
+    "casts from signed types to unsigned types, e.g., `x as u32` where `x: i32`"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for casts between numerical types that may
+    /// truncate large values. This is expected behavior, so the cast is `Allow` by
+    /// default.
+    ///
+    /// **Why is this bad?** In some problem domains, it is good practice to avoid
+    /// truncation. This lint can be activated to help assess where additional
+    /// checks could be beneficial.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// ```rust
+    /// fn as_u8(x: u64) -> u8 {
+    ///     x as u8
+    /// }
+    /// ```
+    pub CAST_POSSIBLE_TRUNCATION,
+    pedantic,
+    "casts that may cause truncation of the value, e.g., `x as u8` where `x: u32`, or `x as i32` where `x: f32`"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for casts from an unsigned type to a signed type of
+    /// the same size. Performing such a cast is a 'no-op' for the compiler,
+    /// i.e., nothing is changed at the bit level, and the binary representation of
+    /// the value is reinterpreted. This can cause wrapping if the value is too big
+    /// for the target signed type. However, the cast works as defined, so this lint
+    /// is `Allow` by default.
+    ///
+    /// **Why is this bad?** While such a cast is not bad in itself, the results can
+    /// be surprising when this is not the intended behavior, as demonstrated by the
+    /// example below.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// ```rust
+    /// u32::MAX as i32; // will yield a value of `-1`
+    /// ```
+    pub CAST_POSSIBLE_WRAP,
+    pedantic,
+    "casts that may cause wrapping around the value, e.g., `x as i32` where `x: u32` and `x > i32::MAX`"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for casts between numerical types that may
+    /// be replaced by safe conversion functions.
+    ///
+    /// **Why is this bad?** Rust's `as` keyword will perform many kinds of
+    /// conversions, including silently lossy conversions. Conversion functions such
+    /// as `i32::from` will only perform lossless conversions. Using the conversion
+    /// functions prevents conversions from turning into silent lossy conversions if
+    /// the types of the input expressions ever change, and make it easier for
+    /// people reading the code to know that the conversion is lossless.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// ```rust
+    /// fn as_u64(x: u8) -> u64 {
+    ///     x as u64
+    /// }
+    /// ```
+    ///
+    /// Using `::from` would look like this:
+    ///
+    /// ```rust
+    /// fn as_u64(x: u8) -> u64 {
+    ///     u64::from(x)
+    /// }
+    /// ```
+    pub CAST_LOSSLESS,
+    pedantic,
+    "casts using `as` that are known to be lossless, e.g., `x as u64` where `x: u8`"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for casts to the same type, casts of int literals to integer types
+    /// and casts of float literals to float types.
+    ///
+    /// **Why is this bad?** It's just unnecessary.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// ```rust
+    /// let _ = 2i32 as i32;
+    /// let _ = 0.5 as f32;
+    /// ```
+    ///
+    /// Better:
+    ///
+    /// ```rust
+    /// let _ = 2_i32;
+    /// let _ = 0.5_f32;
+    /// ```
+    pub UNNECESSARY_CAST,
+    complexity,
+    "cast to the same type, e.g., `x as i32` where `x: i32`"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for casts, using `as` or `pointer::cast`,
+    /// from a less-strictly-aligned pointer to a more-strictly-aligned pointer
+    ///
+    /// **Why is this bad?** Dereferencing the resulting pointer may be undefined
+    /// behavior.
+    ///
+    /// **Known problems:** Using `std::ptr::read_unaligned` and `std::ptr::write_unaligned` or similar
+    /// on the resulting pointer is fine. Is over-zealous: Casts with manual alignment checks or casts like
+    /// u64-> u8 -> u16 can be fine. Miri is able to do a more in-depth analysis.
+    ///
+    /// **Example:**
+    /// ```rust
+    /// let _ = (&1u8 as *const u8) as *const u16;
+    /// let _ = (&mut 1u8 as *mut u8) as *mut u16;
+    ///
+    /// (&1u8 as *const u8).cast::<u16>();
+    /// (&mut 1u8 as *mut u8).cast::<u16>();
+    /// ```
+    pub CAST_PTR_ALIGNMENT,
+    pedantic,
+    "cast from a pointer to a more-strictly-aligned pointer"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for casts of function pointers to something other than usize
+    ///
+    /// **Why is this bad?**
+    /// Casting a function pointer to anything other than usize/isize is not portable across
+    /// architectures, because you end up losing bits if the target type is too small or end up with a
+    /// bunch of extra bits that waste space and add more instructions to the final binary than
+    /// strictly necessary for the problem
+    ///
+    /// Casting to isize also doesn't make sense since there are no signed addresses.
+    ///
+    /// **Example**
+    ///
+    /// ```rust
+    /// // Bad
+    /// fn fun() -> i32 { 1 }
+    /// let a = fun as i64;
+    ///
+    /// // Good
+    /// fn fun2() -> i32 { 1 }
+    /// let a = fun2 as usize;
+    /// ```
+    pub FN_TO_NUMERIC_CAST,
+    style,
+    "casting a function pointer to a numeric type other than usize"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for casts of a function pointer to a numeric type not wide enough to
+    /// store address.
+    ///
+    /// **Why is this bad?**
+    /// Such a cast discards some bits of the function's address. If this is intended, it would be more
+    /// clearly expressed by casting to usize first, then casting the usize to the intended type (with
+    /// a comment) to perform the truncation.
+    ///
+    /// **Example**
+    ///
+    /// ```rust
+    /// // Bad
+    /// fn fn1() -> i16 {
+    ///     1
+    /// };
+    /// let _ = fn1 as i32;
+    ///
+    /// // Better: Cast to usize first, then comment with the reason for the truncation
+    /// fn fn2() -> i16 {
+    ///     1
+    /// };
+    /// let fn_ptr = fn2 as usize;
+    /// let fn_ptr_truncated = fn_ptr as i32;
+    /// ```
+    pub FN_TO_NUMERIC_CAST_WITH_TRUNCATION,
+    style,
+    "casting a function pointer to a numeric type not wide enough to store the address"
+}
+
+/// Returns the size in bits of an integral type.
+/// Will return 0 if the type is not an int or uint variant
+fn int_ty_to_nbits(typ: Ty<'_>, tcx: TyCtxt<'_>) -> u64 {
+    match typ.kind() {
+        ty::Int(i) => match i {
+            IntTy::Isize => tcx.data_layout.pointer_size.bits(),
+            IntTy::I8 => 8,
+            IntTy::I16 => 16,
+            IntTy::I32 => 32,
+            IntTy::I64 => 64,
+            IntTy::I128 => 128,
+        },
+        ty::Uint(i) => match i {
+            UintTy::Usize => tcx.data_layout.pointer_size.bits(),
+            UintTy::U8 => 8,
+            UintTy::U16 => 16,
+            UintTy::U32 => 32,
+            UintTy::U64 => 64,
+            UintTy::U128 => 128,
+        },
+        _ => 0,
+    }
+}
+
+fn span_precision_loss_lint(cx: &LateContext<'_>, expr: &Expr<'_>, cast_from: Ty<'_>, cast_to_f64: bool) {
+    let mantissa_nbits = if cast_to_f64 { 52 } else { 23 };
+    let arch_dependent = is_isize_or_usize(cast_from) && cast_to_f64;
+    let arch_dependent_str = "on targets with 64-bit wide pointers ";
+    let from_nbits_str = if arch_dependent {
+        "64".to_owned()
+    } else if is_isize_or_usize(cast_from) {
+        "32 or 64".to_owned()
+    } else {
+        int_ty_to_nbits(cast_from, cx.tcx).to_string()
+    };
+    span_lint(
+        cx,
+        CAST_PRECISION_LOSS,
+        expr.span,
+        &format!(
+            "casting `{0}` to `{1}` causes a loss of precision {2}(`{0}` is {3} bits wide, \
+             but `{1}`'s mantissa is only {4} bits wide)",
+            cast_from,
+            if cast_to_f64 { "f64" } else { "f32" },
+            if arch_dependent { arch_dependent_str } else { "" },
+            from_nbits_str,
+            mantissa_nbits
+        ),
+    );
+}
+
+fn should_strip_parens(op: &Expr<'_>, snip: &str) -> bool {
+    if let ExprKind::Binary(_, _, _) = op.kind {
+        if snip.starts_with('(') && snip.ends_with(')') {
+            return true;
+        }
+    }
+    false
+}
+
+fn span_lossless_lint(cx: &LateContext<'_>, expr: &Expr<'_>, op: &Expr<'_>, cast_from: Ty<'_>, cast_to: Ty<'_>) {
+    // Do not suggest using From in consts/statics until it is valid to do so (see #2267).
+    if in_constant(cx, expr.hir_id) {
+        return;
+    }
+    // The suggestion is to use a function call, so if the original expression
+    // has parens on the outside, they are no longer needed.
+    let mut applicability = Applicability::MachineApplicable;
+    let opt = snippet_opt(cx, op.span);
+    let sugg = opt.as_ref().map_or_else(
+        || {
+            applicability = Applicability::HasPlaceholders;
+            ".."
+        },
+        |snip| {
+            if should_strip_parens(op, snip) {
+                &snip[1..snip.len() - 1]
+            } else {
+                snip.as_str()
+            }
+        },
+    );
+
+    span_lint_and_sugg(
+        cx,
+        CAST_LOSSLESS,
+        expr.span,
+        &format!(
+            "casting `{}` to `{}` may become silently lossy if you later change the type",
+            cast_from, cast_to
+        ),
+        "try",
+        format!("{}::from({})", cast_to, sugg),
+        applicability,
+    );
+}
+
+enum ArchSuffix {
+    _32,
+    _64,
+    None,
+}
+
+fn check_loss_of_sign(cx: &LateContext<'_>, expr: &Expr<'_>, op: &Expr<'_>, cast_from: Ty<'_>, cast_to: Ty<'_>) {
+    if !cast_from.is_signed() || cast_to.is_signed() {
+        return;
+    }
+
+    // don't lint for positive constants
+    let const_val = constant(cx, &cx.typeck_results(), op);
+    if_chain! {
+        if let Some((Constant::Int(n), _)) = const_val;
+        if let ty::Int(ity) = *cast_from.kind();
+        if sext(cx.tcx, n, ity) >= 0;
+        then {
+            return
+        }
+    }
+
+    // don't lint for the result of methods that always return non-negative values
+    if let ExprKind::MethodCall(ref path, _, _, _) = op.kind {
+        let mut method_name = path.ident.name.as_str();
+        let allowed_methods = ["abs", "checked_abs", "rem_euclid", "checked_rem_euclid"];
+
+        if_chain! {
+            if method_name == "unwrap";
+            if let Some(arglist) = method_chain_args(op, &["unwrap"]);
+            if let ExprKind::MethodCall(ref inner_path, _, _, _) = &arglist[0][0].kind;
+            then {
+                method_name = inner_path.ident.name.as_str();
+            }
+        }
+
+        if allowed_methods.iter().any(|&name| method_name == name) {
+            return;
+        }
+    }
+
+    span_lint(
+        cx,
+        CAST_SIGN_LOSS,
+        expr.span,
+        &format!(
+            "casting `{}` to `{}` may lose the sign of the value",
+            cast_from, cast_to
+        ),
+    );
+}
+
+fn check_truncation_and_wrapping(cx: &LateContext<'_>, expr: &Expr<'_>, cast_from: Ty<'_>, cast_to: Ty<'_>) {
+    let arch_64_suffix = " on targets with 64-bit wide pointers";
+    let arch_32_suffix = " on targets with 32-bit wide pointers";
+    let cast_unsigned_to_signed = !cast_from.is_signed() && cast_to.is_signed();
+    let from_nbits = int_ty_to_nbits(cast_from, cx.tcx);
+    let to_nbits = int_ty_to_nbits(cast_to, cx.tcx);
+    let (span_truncation, suffix_truncation, span_wrap, suffix_wrap) =
+        match (is_isize_or_usize(cast_from), is_isize_or_usize(cast_to)) {
+            (true, true) | (false, false) => (
+                to_nbits < from_nbits,
+                ArchSuffix::None,
+                to_nbits == from_nbits && cast_unsigned_to_signed,
+                ArchSuffix::None,
+            ),
+            (true, false) => (
+                to_nbits <= 32,
+                if to_nbits == 32 {
+                    ArchSuffix::_64
+                } else {
+                    ArchSuffix::None
+                },
+                to_nbits <= 32 && cast_unsigned_to_signed,
+                ArchSuffix::_32,
+            ),
+            (false, true) => (
+                from_nbits == 64,
+                ArchSuffix::_32,
+                cast_unsigned_to_signed,
+                if from_nbits == 64 {
+                    ArchSuffix::_64
+                } else {
+                    ArchSuffix::_32
+                },
+            ),
+        };
+    if span_truncation {
+        span_lint(
+            cx,
+            CAST_POSSIBLE_TRUNCATION,
+            expr.span,
+            &format!(
+                "casting `{}` to `{}` may truncate the value{}",
+                cast_from,
+                cast_to,
+                match suffix_truncation {
+                    ArchSuffix::_32 => arch_32_suffix,
+                    ArchSuffix::_64 => arch_64_suffix,
+                    ArchSuffix::None => "",
+                }
+            ),
+        );
+    }
+    if span_wrap {
+        span_lint(
+            cx,
+            CAST_POSSIBLE_WRAP,
+            expr.span,
+            &format!(
+                "casting `{}` to `{}` may wrap around the value{}",
+                cast_from,
+                cast_to,
+                match suffix_wrap {
+                    ArchSuffix::_32 => arch_32_suffix,
+                    ArchSuffix::_64 => arch_64_suffix,
+                    ArchSuffix::None => "",
+                }
+            ),
+        );
+    }
+}
+
+fn check_lossless(cx: &LateContext<'_>, expr: &Expr<'_>, op: &Expr<'_>, cast_from: Ty<'_>, cast_to: Ty<'_>) {
+    let cast_signed_to_unsigned = cast_from.is_signed() && !cast_to.is_signed();
+    let from_nbits = int_ty_to_nbits(cast_from, cx.tcx);
+    let to_nbits = int_ty_to_nbits(cast_to, cx.tcx);
+    if !is_isize_or_usize(cast_from) && !is_isize_or_usize(cast_to) && from_nbits < to_nbits && !cast_signed_to_unsigned
+    {
+        span_lossless_lint(cx, expr, op, cast_from, cast_to);
+    }
+}
+
+declare_lint_pass!(Casts => [
+    CAST_PRECISION_LOSS,
+    CAST_SIGN_LOSS,
+    CAST_POSSIBLE_TRUNCATION,
+    CAST_POSSIBLE_WRAP,
+    CAST_LOSSLESS,
+    UNNECESSARY_CAST,
+    CAST_PTR_ALIGNMENT,
+    FN_TO_NUMERIC_CAST,
+    FN_TO_NUMERIC_CAST_WITH_TRUNCATION,
+]);
+
+/// Check if the given type is either `core::ffi::c_void` or
+/// one of the platform specific `libc::<platform>::c_void` of libc.
+fn is_c_void(cx: &LateContext<'_>, ty: Ty<'_>) -> bool {
+    if let ty::Adt(adt, _) = ty.kind() {
+        let names = cx.get_def_path(adt.did);
+
+        if names.is_empty() {
+            return false;
+        }
+        if names[0] == sym::libc || names[0] == sym::core && *names.last().unwrap() == sym!(c_void) {
+            return true;
+        }
+    }
+    false
+}
+
+/// Returns the mantissa bits wide of a fp type.
+/// Will return 0 if the type is not a fp
+fn fp_ty_mantissa_nbits(typ: Ty<'_>) -> u32 {
+    match typ.kind() {
+        ty::Float(FloatTy::F32) => 23,
+        ty::Float(FloatTy::F64) | ty::Infer(InferTy::FloatVar(_)) => 52,
+        _ => 0,
+    }
+}
+
+impl<'tcx> LateLintPass<'tcx> for Casts {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        if expr.span.from_expansion() {
+            return;
+        }
+        if let ExprKind::Cast(ref ex, cast_to) = expr.kind {
+            if is_hir_ty_cfg_dependant(cx, cast_to) {
+                return;
+            }
+            let (cast_from, cast_to) = (cx.typeck_results().expr_ty(ex), cx.typeck_results().expr_ty(expr));
+            lint_fn_to_numeric_cast(cx, expr, ex, cast_from, cast_to);
+            if let Some(lit) = get_numeric_literal(ex) {
+                let literal_str = snippet_opt(cx, ex.span).unwrap_or_default();
+
+                if_chain! {
+                    if let LitKind::Int(n, _) = lit.node;
+                    if let Some(src) = snippet_opt(cx, lit.span);
+                    if cast_to.is_floating_point();
+                    if let Some(num_lit) = NumericLiteral::from_lit_kind(&src, &lit.node);
+                    let from_nbits = 128 - n.leading_zeros();
+                    let to_nbits = fp_ty_mantissa_nbits(cast_to);
+                    if from_nbits != 0 && to_nbits != 0 && from_nbits <= to_nbits && num_lit.is_decimal();
+                    then {
+                        let literal_str = if is_unary_neg(ex) { format!("-{}", num_lit.integer) } else { num_lit.integer.into() };
+                        show_unnecessary_cast(cx, expr, &literal_str, cast_from, cast_to);
+                        return;
+                    }
+                }
+
+                match lit.node {
+                    LitKind::Int(_, LitIntType::Unsuffixed) if cast_to.is_integral() => {
+                        show_unnecessary_cast(cx, expr, &literal_str, cast_from, cast_to);
+                    },
+                    LitKind::Float(_, LitFloatType::Unsuffixed) if cast_to.is_floating_point() => {
+                        show_unnecessary_cast(cx, expr, &literal_str, cast_from, cast_to);
+                    },
+                    LitKind::Int(_, LitIntType::Unsuffixed) | LitKind::Float(_, LitFloatType::Unsuffixed) => {},
+                    _ => {
+                        if cast_from.kind() == cast_to.kind() && !in_external_macro(cx.sess(), expr.span) {
+                            span_lint(
+                                cx,
+                                UNNECESSARY_CAST,
+                                expr.span,
+                                &format!(
+                                    "casting to the same type is unnecessary (`{}` -> `{}`)",
+                                    cast_from, cast_to
+                                ),
+                            );
+                        }
+                    },
+                }
+            }
+            if cast_from.is_numeric() && cast_to.is_numeric() && !in_external_macro(cx.sess(), expr.span) {
+                lint_numeric_casts(cx, expr, ex, cast_from, cast_to);
+            }
+
+            lint_cast_ptr_alignment(cx, expr, cast_from, cast_to);
+        } else if let ExprKind::MethodCall(method_path, _, args, _) = expr.kind {
+            if_chain! {
+            if method_path.ident.name == sym!(cast);
+            if let Some(generic_args) = method_path.args;
+            if let [GenericArg::Type(cast_to)] = generic_args.args;
+            // There probably is no obvious reason to do this, just to be consistent with `as` cases.
+            if !is_hir_ty_cfg_dependant(cx, cast_to);
+            then {
+                let (cast_from, cast_to) =
+                    (cx.typeck_results().expr_ty(&args[0]), cx.typeck_results().expr_ty(expr));
+                lint_cast_ptr_alignment(cx, expr, cast_from, cast_to);
+            }
+            }
+        }
+    }
+}
+
+fn is_unary_neg(expr: &Expr<'_>) -> bool {
+    matches!(expr.kind, ExprKind::Unary(UnOp::Neg, _))
+}
+
+fn get_numeric_literal<'e>(expr: &'e Expr<'e>) -> Option<&'e Lit> {
+    match expr.kind {
+        ExprKind::Lit(ref lit) => Some(lit),
+        ExprKind::Unary(UnOp::Neg, e) => {
+            if let ExprKind::Lit(ref lit) = e.kind {
+                Some(lit)
+            } else {
+                None
+            }
+        },
+        _ => None,
+    }
+}
+
+fn show_unnecessary_cast(cx: &LateContext<'_>, expr: &Expr<'_>, literal_str: &str, cast_from: Ty<'_>, cast_to: Ty<'_>) {
+    let literal_kind_name = if cast_from.is_integral() { "integer" } else { "float" };
+    span_lint_and_sugg(
+        cx,
+        UNNECESSARY_CAST,
+        expr.span,
+        &format!("casting {} literal to `{}` is unnecessary", literal_kind_name, cast_to),
+        "try",
+        format!("{}_{}", literal_str.trim_end_matches('.'), cast_to),
+        Applicability::MachineApplicable,
+    );
+}
+
+fn lint_numeric_casts<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &Expr<'tcx>,
+    cast_expr: &Expr<'_>,
+    cast_from: Ty<'tcx>,
+    cast_to: Ty<'tcx>,
+) {
+    match (cast_from.is_integral(), cast_to.is_integral()) {
+        (true, false) => {
+            let from_nbits = int_ty_to_nbits(cast_from, cx.tcx);
+            let to_nbits = if let ty::Float(FloatTy::F32) = cast_to.kind() {
+                32
+            } else {
+                64
+            };
+            if is_isize_or_usize(cast_from) || from_nbits >= to_nbits {
+                span_precision_loss_lint(cx, expr, cast_from, to_nbits == 64);
+            }
+            if from_nbits < to_nbits {
+                span_lossless_lint(cx, expr, cast_expr, cast_from, cast_to);
+            }
+        },
+        (false, true) => {
+            span_lint(
+                cx,
+                CAST_POSSIBLE_TRUNCATION,
+                expr.span,
+                &format!("casting `{}` to `{}` may truncate the value", cast_from, cast_to),
+            );
+            if !cast_to.is_signed() {
+                span_lint(
+                    cx,
+                    CAST_SIGN_LOSS,
+                    expr.span,
+                    &format!(
+                        "casting `{}` to `{}` may lose the sign of the value",
+                        cast_from, cast_to
+                    ),
+                );
+            }
+        },
+        (true, true) => {
+            check_loss_of_sign(cx, expr, cast_expr, cast_from, cast_to);
+            check_truncation_and_wrapping(cx, expr, cast_from, cast_to);
+            check_lossless(cx, expr, cast_expr, cast_from, cast_to);
+        },
+        (false, false) => {
+            if let (&ty::Float(FloatTy::F64), &ty::Float(FloatTy::F32)) = (&cast_from.kind(), &cast_to.kind()) {
+                span_lint(
+                    cx,
+                    CAST_POSSIBLE_TRUNCATION,
+                    expr.span,
+                    "casting `f64` to `f32` may truncate the value",
+                );
+            }
+            if let (&ty::Float(FloatTy::F32), &ty::Float(FloatTy::F64)) = (&cast_from.kind(), &cast_to.kind()) {
+                span_lossless_lint(cx, expr, cast_expr, cast_from, cast_to);
+            }
+        },
+    }
+}
+
+fn lint_cast_ptr_alignment<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, cast_from: Ty<'tcx>, cast_to: Ty<'tcx>) {
+    if_chain! {
+        if let ty::RawPtr(from_ptr_ty) = &cast_from.kind();
+        if let ty::RawPtr(to_ptr_ty) = &cast_to.kind();
+        if let Ok(from_layout) = cx.layout_of(from_ptr_ty.ty);
+        if let Ok(to_layout) = cx.layout_of(to_ptr_ty.ty);
+        if from_layout.align.abi < to_layout.align.abi;
+        // with c_void, we inherently need to trust the user
+        if !is_c_void(cx, from_ptr_ty.ty);
+        // when casting from a ZST, we don't know enough to properly lint
+        if !from_layout.is_zst();
+        then {
+            span_lint(
+                cx,
+                CAST_PTR_ALIGNMENT,
+                expr.span,
+                &format!(
+                    "casting from `{}` to a more-strictly-aligned pointer (`{}`) ({} < {} bytes)",
+                    cast_from,
+                    cast_to,
+                    from_layout.align.abi.bytes(),
+                    to_layout.align.abi.bytes(),
+                ),
+            );
+        }
+    }
+}
+
+fn lint_fn_to_numeric_cast(
+    cx: &LateContext<'_>,
+    expr: &Expr<'_>,
+    cast_expr: &Expr<'_>,
+    cast_from: Ty<'_>,
+    cast_to: Ty<'_>,
+) {
+    // We only want to check casts to `ty::Uint` or `ty::Int`
+    match cast_to.kind() {
+        ty::Uint(_) | ty::Int(..) => { /* continue on */ },
+        _ => return,
+    }
+    match cast_from.kind() {
+        ty::FnDef(..) | ty::FnPtr(_) => {
+            let mut applicability = Applicability::MaybeIncorrect;
+            let from_snippet = snippet_with_applicability(cx, cast_expr.span, "x", &mut applicability);
+
+            let to_nbits = int_ty_to_nbits(cast_to, cx.tcx);
+            if to_nbits < cx.tcx.data_layout.pointer_size.bits() {
+                span_lint_and_sugg(
+                    cx,
+                    FN_TO_NUMERIC_CAST_WITH_TRUNCATION,
+                    expr.span,
+                    &format!(
+                        "casting function pointer `{}` to `{}`, which truncates the value",
+                        from_snippet, cast_to
+                    ),
+                    "try",
+                    format!("{} as usize", from_snippet),
+                    applicability,
+                );
+            } else if *cast_to.kind() != ty::Uint(UintTy::Usize) {
+                span_lint_and_sugg(
+                    cx,
+                    FN_TO_NUMERIC_CAST,
+                    expr.span,
+                    &format!("casting function pointer `{}` to `{}`", from_snippet, cast_to),
+                    "try",
+                    format!("{} as usize", from_snippet),
+                    applicability,
+                );
+            }
+        },
+        _ => {},
+    }
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for casts of `&T` to `&mut T` anywhere in the code.
+    ///
+    /// **Why is this bad?** It’s basically guaranteed to be undefined behaviour.
+    /// `UnsafeCell` is the only way to obtain aliasable data that is considered
+    /// mutable.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// ```rust,ignore
+    /// fn x(r: &i32) {
+    ///     unsafe {
+    ///         *(r as *const _ as *mut _) += 1;
+    ///     }
+    /// }
+    /// ```
+    ///
+    /// Instead consider using interior mutability types.
+    ///
+    /// ```rust
+    /// use std::cell::UnsafeCell;
+    ///
+    /// fn x(r: &UnsafeCell<i32>) {
+    ///     unsafe {
+    ///         *r.get() += 1;
+    ///     }
+    /// }
+    /// ```
+    pub CAST_REF_TO_MUT,
+    correctness,
+    "a cast of reference to a mutable pointer"
+}
+
+declare_lint_pass!(RefToMut => [CAST_REF_TO_MUT]);
+
+impl<'tcx> LateLintPass<'tcx> for RefToMut {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        if_chain! {
+            if let ExprKind::Unary(UnOp::Deref, e) = &expr.kind;
+            if let ExprKind::Cast(e, t) = &e.kind;
+            if let TyKind::Ptr(MutTy { mutbl: Mutability::Mut, .. }) = t.kind;
+            if let ExprKind::Cast(e, t) = &e.kind;
+            if let TyKind::Ptr(MutTy { mutbl: Mutability::Not, .. }) = t.kind;
+            if let ty::Ref(..) = cx.typeck_results().node_type(e.hir_id).kind();
+            then {
+                span_lint(
+                    cx,
+                    CAST_REF_TO_MUT,
+                    expr.span,
+                    "casting `&T` to `&mut T` may cause undefined behavior, consider instead using an `UnsafeCell`",
+                );
+            }
+        }
+    }
+}
+
+const PTR_AS_PTR_MSRV: RustcVersion = RustcVersion::new(1, 38, 0);
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for expressions where a character literal is cast
+    /// to `u8` and suggests using a byte literal instead.
+    ///
+    /// **Why is this bad?** In general, casting values to smaller types is
+    /// error-prone and should be avoided where possible. In the particular case of
+    /// converting a character literal to u8, it is easy to avoid by just using a
+    /// byte literal instead. As an added bonus, `b'a'` is even slightly shorter
+    /// than `'a' as u8`.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// ```rust,ignore
+    /// 'x' as u8
+    /// ```
+    ///
+    /// A better version, using the byte literal:
+    ///
+    /// ```rust,ignore
+    /// b'x'
+    /// ```
+    pub CHAR_LIT_AS_U8,
+    complexity,
+    "casting a character literal to `u8` truncates"
+}
+
+declare_lint_pass!(CharLitAsU8 => [CHAR_LIT_AS_U8]);
+
+impl<'tcx> LateLintPass<'tcx> for CharLitAsU8 {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        if_chain! {
+            if !expr.span.from_expansion();
+            if let ExprKind::Cast(e, _) = &expr.kind;
+            if let ExprKind::Lit(l) = &e.kind;
+            if let LitKind::Char(c) = l.node;
+            if ty::Uint(UintTy::U8) == *cx.typeck_results().expr_ty(expr).kind();
+            then {
+                let mut applicability = Applicability::MachineApplicable;
+                let snippet = snippet_with_applicability(cx, e.span, "'x'", &mut applicability);
+
+                span_lint_and_then(
+                    cx,
+                    CHAR_LIT_AS_U8,
+                    expr.span,
+                    "casting a character literal to `u8` truncates",
+                    |diag| {
+                        diag.note("`char` is four bytes wide, but `u8` is a single byte");
+
+                        if c.is_ascii() {
+                            diag.span_suggestion(
+                                expr.span,
+                                "use a byte literal instead",
+                                format!("b{}", snippet),
+                                applicability,
+                            );
+                        }
+                });
+            }
+        }
+    }
+}
+
+declare_clippy_lint! {
+    /// **What it does:**
+    /// Checks for `as` casts between raw pointers without changing its mutability,
+    /// namely `*const T` to `*const U` and `*mut T` to `*mut U`.
+    ///
+    /// **Why is this bad?**
+    /// Though `as` casts between raw pointers is not terrible, `pointer::cast` is safer because
+    /// it cannot accidentally change the pointer's mutability nor cast the pointer to other types like `usize`.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// let ptr: *const u32 = &42_u32;
+    /// let mut_ptr: *mut u32 = &mut 42_u32;
+    /// let _ = ptr as *const i32;
+    /// let _ = mut_ptr as *mut i32;
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// let ptr: *const u32 = &42_u32;
+    /// let mut_ptr: *mut u32 = &mut 42_u32;
+    /// let _ = ptr.cast::<i32>();
+    /// let _ = mut_ptr.cast::<i32>();
+    /// ```
+    pub PTR_AS_PTR,
+    pedantic,
+    "casting using `as` from and to raw pointers that doesn't change its mutability, where `pointer::cast` could take the place of `as`"
+}
+
+pub struct PtrAsPtr {
+    msrv: Option<RustcVersion>,
+}
+
+impl PtrAsPtr {
+    #[must_use]
+    pub fn new(msrv: Option<RustcVersion>) -> Self {
+        Self { msrv }
+    }
+}
+
+impl_lint_pass!(PtrAsPtr => [PTR_AS_PTR]);
+
+impl<'tcx> LateLintPass<'tcx> for PtrAsPtr {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        if !meets_msrv(self.msrv.as_ref(), &PTR_AS_PTR_MSRV) {
+            return;
+        }
+
+        if expr.span.from_expansion() {
+            return;
+        }
+
+        if_chain! {
+            if let ExprKind::Cast(cast_expr, cast_to_hir_ty) = expr.kind;
+            let (cast_from, cast_to) = (cx.typeck_results().expr_ty(cast_expr), cx.typeck_results().expr_ty(expr));
+            if let ty::RawPtr(TypeAndMut { mutbl: from_mutbl, .. }) = cast_from.kind();
+            if let ty::RawPtr(TypeAndMut { ty: to_pointee_ty, mutbl: to_mutbl }) = cast_to.kind();
+            if matches!((from_mutbl, to_mutbl),
+                (Mutability::Not, Mutability::Not) | (Mutability::Mut, Mutability::Mut));
+            // The `U` in `pointer::cast` have to be `Sized`
+            // as explained here: https://github.com/rust-lang/rust/issues/60602.
+            if to_pointee_ty.is_sized(cx.tcx.at(expr.span), cx.param_env);
+            then {
+                let mut applicability = Applicability::MachineApplicable;
+                let cast_expr_sugg = Sugg::hir_with_applicability(cx, cast_expr, "_", &mut applicability);
+                let turbofish = match &cast_to_hir_ty.kind {
+                        TyKind::Infer => Cow::Borrowed(""),
+                        TyKind::Ptr(mut_ty) if matches!(mut_ty.ty.kind, TyKind::Infer) => Cow::Borrowed(""),
+                        _ => Cow::Owned(format!("::<{}>", to_pointee_ty)),
+                    };
+                span_lint_and_sugg(
+                    cx,
+                    PTR_AS_PTR,
+                    expr.span,
+                    "`as` casting between raw pointers without changing its mutability",
+                    "try `pointer::cast`, a safer alternative",
+                    format!("{}.cast{}()", cast_expr_sugg.maybe_par(), turbofish),
+                    applicability,
+                );
+            }
+        }
+    }
+
+    extract_msrv_attr!(LateContext);
+}
+
+fn is_isize_or_usize(typ: Ty<'_>) -> bool {
+    matches!(typ.kind(), ty::Int(IntTy::Isize) | ty::Uint(UintTy::Usize))
+}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 8259fd3c320..a46c56a01d5 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -182,6 +182,7 @@ mod booleans;
 mod bytecount;
 mod cargo_common_metadata;
 mod case_sensitive_file_extension_comparisons;
+mod casts;
 mod checked_conversions;
 mod cognitive_complexity;
 mod collapsible_if;
@@ -586,6 +587,18 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &bytecount::NAIVE_BYTECOUNT,
         &cargo_common_metadata::CARGO_COMMON_METADATA,
         &case_sensitive_file_extension_comparisons::CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS,
+        &casts::CAST_LOSSLESS,
+        &casts::CAST_POSSIBLE_TRUNCATION,
+        &casts::CAST_POSSIBLE_WRAP,
+        &casts::CAST_PRECISION_LOSS,
+        &casts::CAST_PTR_ALIGNMENT,
+        &casts::CAST_REF_TO_MUT,
+        &casts::CAST_SIGN_LOSS,
+        &casts::CHAR_LIT_AS_U8,
+        &casts::FN_TO_NUMERIC_CAST,
+        &casts::FN_TO_NUMERIC_CAST_WITH_TRUNCATION,
+        &casts::PTR_AS_PTR,
+        &casts::UNNECESSARY_CAST,
         &checked_conversions::CHECKED_CONVERSIONS,
         &cognitive_complexity::COGNITIVE_COMPLEXITY,
         &collapsible_if::COLLAPSIBLE_ELSE_IF,
@@ -943,28 +956,16 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &types::ABSURD_EXTREME_COMPARISONS,
         &types::BORROWED_BOX,
         &types::BOX_VEC,
-        &types::CAST_LOSSLESS,
-        &types::CAST_POSSIBLE_TRUNCATION,
-        &types::CAST_POSSIBLE_WRAP,
-        &types::CAST_PRECISION_LOSS,
-        &types::CAST_PTR_ALIGNMENT,
-        &types::CAST_REF_TO_MUT,
-        &types::CAST_SIGN_LOSS,
-        &types::CHAR_LIT_AS_U8,
-        &types::FN_TO_NUMERIC_CAST,
-        &types::FN_TO_NUMERIC_CAST_WITH_TRUNCATION,
         &types::IMPLICIT_HASHER,
         &types::INVALID_UPCAST_COMPARISONS,
         &types::LET_UNIT_VALUE,
         &types::LINKEDLIST,
         &types::OPTION_OPTION,
-        &types::PTR_AS_PTR,
         &types::RC_BUFFER,
         &types::REDUNDANT_ALLOCATION,
         &types::TYPE_COMPLEXITY,
         &types::UNIT_ARG,
         &types::UNIT_CMP,
-        &types::UNNECESSARY_CAST,
         &types::VEC_BOX,
         &undropped_manually_drops::UNDROPPED_MANUALLY_DROPS,
         &unicode::INVISIBLE_CHARACTERS,
@@ -1086,7 +1087,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box main_recursion::MainRecursion::default());
     store.register_late_pass(|| box lifetimes::Lifetimes);
     store.register_late_pass(|| box entry::HashMapPass);
-    store.register_late_pass(|| box types::Casts);
+    store.register_late_pass(|| box casts::Casts);
     let type_complexity_threshold = conf.type_complexity_threshold;
     store.register_late_pass(move || box types::TypeComplexity::new(type_complexity_threshold));
     store.register_late_pass(|| box minmax::MinMaxPass);
@@ -1107,7 +1108,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box panic_unimplemented::PanicUnimplemented);
     store.register_late_pass(|| box strings::StringLitAsBytes);
     store.register_late_pass(|| box derive::Derive);
-    store.register_late_pass(|| box types::CharLitAsU8);
+    store.register_late_pass(|| box casts::CharLitAsU8);
     store.register_late_pass(|| box get_last_with_len::GetLastWithLen);
     store.register_late_pass(|| box drop_forget_ref::DropForgetRef);
     store.register_late_pass(|| box empty_enum::EmptyEnum);
@@ -1175,7 +1176,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box slow_vector_initialization::SlowVectorInit);
     store.register_late_pass(|| box unnecessary_sort_by::UnnecessarySortBy);
     store.register_late_pass(|| box unnecessary_wraps::UnnecessaryWraps);
-    store.register_late_pass(|| box types::RefToMut);
+    store.register_late_pass(|| box casts::RefToMut);
     store.register_late_pass(|| box assertions_on_constants::AssertionsOnConstants);
     store.register_late_pass(|| box transmuting_null::TransmutingNull);
     store.register_late_pass(|| box path_buf_push_overwrite::PathBufPushOverwrite);
@@ -1277,7 +1278,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box strings::StringToString);
     store.register_late_pass(|| box zero_sized_map_values::ZeroSizedMapValues);
     store.register_late_pass(|| box vec_init_then_push::VecInitThenPush::default());
-    store.register_late_pass(move || box types::PtrAsPtr::new(msrv));
+    store.register_late_pass(move || box casts::PtrAsPtr::new(msrv));
     store.register_late_pass(|| box case_sensitive_file_extension_comparisons::CaseSensitiveFileExtensionComparisons);
     store.register_late_pass(|| box redundant_slicing::RedundantSlicing);
     store.register_late_pass(|| box from_str_radix_10::FromStrRadix10);
@@ -1345,6 +1346,13 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&bit_mask::VERBOSE_BIT_MASK),
         LintId::of(&bytecount::NAIVE_BYTECOUNT),
         LintId::of(&case_sensitive_file_extension_comparisons::CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS),
+        LintId::of(&casts::CAST_LOSSLESS),
+        LintId::of(&casts::CAST_POSSIBLE_TRUNCATION),
+        LintId::of(&casts::CAST_POSSIBLE_WRAP),
+        LintId::of(&casts::CAST_PRECISION_LOSS),
+        LintId::of(&casts::CAST_PTR_ALIGNMENT),
+        LintId::of(&casts::CAST_SIGN_LOSS),
+        LintId::of(&casts::PTR_AS_PTR),
         LintId::of(&checked_conversions::CHECKED_CONVERSIONS),
         LintId::of(&copies::SAME_FUNCTIONS_IN_IF_CONDITION),
         LintId::of(&copy_iterator::COPY_ITERATOR),
@@ -1404,18 +1412,11 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&strings::STRING_ADD_ASSIGN),
         LintId::of(&trait_bounds::TRAIT_DUPLICATION_IN_BOUNDS),
         LintId::of(&trait_bounds::TYPE_REPETITION_IN_BOUNDS),
-        LintId::of(&types::CAST_LOSSLESS),
-        LintId::of(&types::CAST_POSSIBLE_TRUNCATION),
-        LintId::of(&types::CAST_POSSIBLE_WRAP),
-        LintId::of(&types::CAST_PRECISION_LOSS),
-        LintId::of(&types::CAST_PTR_ALIGNMENT),
-        LintId::of(&types::CAST_SIGN_LOSS),
         LintId::of(&types::IMPLICIT_HASHER),
         LintId::of(&types::INVALID_UPCAST_COMPARISONS),
         LintId::of(&types::LET_UNIT_VALUE),
         LintId::of(&types::LINKEDLIST),
         LintId::of(&types::OPTION_OPTION),
-        LintId::of(&types::PTR_AS_PTR),
         LintId::of(&unicode::NON_ASCII_LITERAL),
         LintId::of(&unicode::UNICODE_NOT_NFC),
         LintId::of(&unnecessary_wraps::UNNECESSARY_WRAPS),
@@ -1459,6 +1460,11 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&blocks_in_if_conditions::BLOCKS_IN_IF_CONDITIONS),
         LintId::of(&booleans::LOGIC_BUG),
         LintId::of(&booleans::NONMINIMAL_BOOL),
+        LintId::of(&casts::CAST_REF_TO_MUT),
+        LintId::of(&casts::CHAR_LIT_AS_U8),
+        LintId::of(&casts::FN_TO_NUMERIC_CAST),
+        LintId::of(&casts::FN_TO_NUMERIC_CAST_WITH_TRUNCATION),
+        LintId::of(&casts::UNNECESSARY_CAST),
         LintId::of(&collapsible_if::COLLAPSIBLE_ELSE_IF),
         LintId::of(&collapsible_if::COLLAPSIBLE_IF),
         LintId::of(&collapsible_match::COLLAPSIBLE_MATCH),
@@ -1699,15 +1705,10 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&types::ABSURD_EXTREME_COMPARISONS),
         LintId::of(&types::BORROWED_BOX),
         LintId::of(&types::BOX_VEC),
-        LintId::of(&types::CAST_REF_TO_MUT),
-        LintId::of(&types::CHAR_LIT_AS_U8),
-        LintId::of(&types::FN_TO_NUMERIC_CAST),
-        LintId::of(&types::FN_TO_NUMERIC_CAST_WITH_TRUNCATION),
         LintId::of(&types::REDUNDANT_ALLOCATION),
         LintId::of(&types::TYPE_COMPLEXITY),
         LintId::of(&types::UNIT_ARG),
         LintId::of(&types::UNIT_CMP),
-        LintId::of(&types::UNNECESSARY_CAST),
         LintId::of(&types::VEC_BOX),
         LintId::of(&undropped_manually_drops::UNDROPPED_MANUALLY_DROPS),
         LintId::of(&unicode::INVISIBLE_CHARACTERS),
@@ -1740,6 +1741,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&attrs::BLANKET_CLIPPY_RESTRICTION_LINTS),
         LintId::of(&blacklisted_name::BLACKLISTED_NAME),
         LintId::of(&blocks_in_if_conditions::BLOCKS_IN_IF_CONDITIONS),
+        LintId::of(&casts::FN_TO_NUMERIC_CAST),
+        LintId::of(&casts::FN_TO_NUMERIC_CAST_WITH_TRUNCATION),
         LintId::of(&collapsible_if::COLLAPSIBLE_ELSE_IF),
         LintId::of(&collapsible_if::COLLAPSIBLE_IF),
         LintId::of(&collapsible_match::COLLAPSIBLE_MATCH),
@@ -1836,8 +1839,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&tabs_in_doc_comments::TABS_IN_DOC_COMMENTS),
         LintId::of(&to_digit_is_some::TO_DIGIT_IS_SOME),
         LintId::of(&try_err::TRY_ERR),
-        LintId::of(&types::FN_TO_NUMERIC_CAST),
-        LintId::of(&types::FN_TO_NUMERIC_CAST_WITH_TRUNCATION),
         LintId::of(&unsafe_removed_from_name::UNSAFE_REMOVED_FROM_NAME),
         LintId::of(&unused_unit::UNUSED_UNIT),
         LintId::of(&upper_case_acronyms::UPPER_CASE_ACRONYMS),
@@ -1853,6 +1854,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&assign_ops::MISREFACTORED_ASSIGN_OP),
         LintId::of(&attrs::DEPRECATED_CFG_ATTR),
         LintId::of(&booleans::NONMINIMAL_BOOL),
+        LintId::of(&casts::CHAR_LIT_AS_U8),
+        LintId::of(&casts::UNNECESSARY_CAST),
         LintId::of(&double_comparison::DOUBLE_COMPARISONS),
         LintId::of(&double_parens::DOUBLE_PARENS),
         LintId::of(&duration_subsec::DURATION_SUBSEC),
@@ -1929,10 +1932,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&transmute::TRANSMUTE_PTR_TO_PTR),
         LintId::of(&transmute::TRANSMUTE_PTR_TO_REF),
         LintId::of(&types::BORROWED_BOX),
-        LintId::of(&types::CHAR_LIT_AS_U8),
         LintId::of(&types::TYPE_COMPLEXITY),
         LintId::of(&types::UNIT_ARG),
-        LintId::of(&types::UNNECESSARY_CAST),
         LintId::of(&types::VEC_BOX),
         LintId::of(&unnecessary_sort_by::UNNECESSARY_SORT_BY),
         LintId::of(&unwrap::UNNECESSARY_UNWRAP),
@@ -1950,6 +1951,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&bit_mask::BAD_BIT_MASK),
         LintId::of(&bit_mask::INEFFECTIVE_BIT_MASK),
         LintId::of(&booleans::LOGIC_BUG),
+        LintId::of(&casts::CAST_REF_TO_MUT),
         LintId::of(&copies::IFS_SAME_COND),
         LintId::of(&copies::IF_SAME_THEN_ELSE),
         LintId::of(&derive::DERIVE_HASH_XOR_EQ),
@@ -2002,7 +2004,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&transmute::WRONG_TRANSMUTE),
         LintId::of(&transmuting_null::TRANSMUTING_NULL),
         LintId::of(&types::ABSURD_EXTREME_COMPARISONS),
-        LintId::of(&types::CAST_REF_TO_MUT),
         LintId::of(&types::UNIT_CMP),
         LintId::of(&undropped_manually_drops::UNDROPPED_MANUALLY_DROPS),
         LintId::of(&unicode::INVISIBLE_CHARACTERS),
diff --git a/clippy_lints/src/types/mod.rs b/clippy_lints/src/types/mod.rs
index 25cc40917c3..3e7aa53d5bc 100644
--- a/clippy_lints/src/types/mod.rs
+++ b/clippy_lints/src/types/mod.rs
@@ -14,20 +14,18 @@ use std::cmp::Ordering;
 use std::collections::BTreeMap;
 
 use if_chain::if_chain;
-use rustc_ast::{LitFloatType, LitIntType, LitKind};
 use rustc_errors::{Applicability, DiagnosticBuilder};
 use rustc_hir as hir;
 use rustc_hir::intravisit::{walk_body, walk_expr, walk_ty, FnKind, NestedVisitorMap, Visitor};
 use rustc_hir::{
     BinOpKind, Block, Body, Expr, ExprKind, FnDecl, FnRetTy, FnSig, GenericArg, GenericParamKind, HirId, ImplItem,
-    ImplItemKind, Item, ItemKind, Lit, Local, MatchSource, MutTy, Mutability, Node, QPath, Stmt, StmtKind, TraitFn,
-    TraitItem, TraitItemKind, TyKind, UnOp,
+    ImplItemKind, Item, ItemKind, Local, MatchSource, MutTy, Node, QPath, Stmt, StmtKind, TraitFn, TraitItem,
+    TraitItemKind, TyKind,
 };
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::hir::map::Map;
 use rustc_middle::lint::in_external_macro;
-use rustc_middle::ty::{self, FloatTy, InferTy, IntTy, Ty, TyCtxt, TyS, TypeAndMut, TypeckResults, UintTy};
-use rustc_semver::RustcVersion;
+use rustc_middle::ty::{self, IntTy, Ty, TyS, TypeckResults, UintTy};
 use rustc_session::{declare_lint_pass, declare_tool_lint, impl_lint_pass};
 use rustc_span::hygiene::{ExpnKind, MacroKind};
 use rustc_span::source_map::Span;
@@ -38,12 +36,10 @@ use rustc_typeck::hir_ty_to_ty;
 
 use crate::consts::{constant, Constant};
 use crate::utils::paths;
-use crate::utils::sugg::Sugg;
 use crate::utils::{
-    clip, comparisons, differing_macro_contexts, higher, in_constant, indent_of, int_bits, is_hir_ty_cfg_dependant,
-    is_type_diagnostic_item, match_path, meets_msrv, method_chain_args, multispan_sugg,
-    numeric_literal::NumericLiteral, reindent_multiline, sext, snippet, snippet_opt, snippet_with_applicability,
-    snippet_with_macro_callsite, span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then, unsext,
+    clip, comparisons, differing_macro_contexts, higher, indent_of, int_bits, is_type_diagnostic_item, match_path,
+    multispan_sugg, reindent_multiline, sext, snippet, snippet_opt, snippet_with_macro_callsite, span_lint,
+    span_lint_and_help, span_lint_and_then, unsext,
 };
 
 declare_clippy_lint! {
@@ -778,749 +774,6 @@ fn is_unit_literal(expr: &Expr<'_>) -> bool {
     matches!(expr.kind, ExprKind::Tup(ref slice) if slice.is_empty())
 }
 
-declare_clippy_lint! {
-    /// **What it does:** Checks for casts from any numerical to a float type where
-    /// the receiving type cannot store all values from the original type without
-    /// rounding errors. This possible rounding is to be expected, so this lint is
-    /// `Allow` by default.
-    ///
-    /// Basically, this warns on casting any integer with 32 or more bits to `f32`
-    /// or any 64-bit integer to `f64`.
-    ///
-    /// **Why is this bad?** It's not bad at all. But in some applications it can be
-    /// helpful to know where precision loss can take place. This lint can help find
-    /// those places in the code.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    /// ```rust
-    /// let x = u64::MAX;
-    /// x as f64;
-    /// ```
-    pub CAST_PRECISION_LOSS,
-    pedantic,
-    "casts that cause loss of precision, e.g., `x as f32` where `x: u64`"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for casts from a signed to an unsigned numerical
-    /// type. In this case, negative values wrap around to large positive values,
-    /// which can be quite surprising in practice. However, as the cast works as
-    /// defined, this lint is `Allow` by default.
-    ///
-    /// **Why is this bad?** Possibly surprising results. You can activate this lint
-    /// as a one-time check to see where numerical wrapping can arise.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    /// ```rust
-    /// let y: i8 = -1;
-    /// y as u128; // will return 18446744073709551615
-    /// ```
-    pub CAST_SIGN_LOSS,
-    pedantic,
-    "casts from signed types to unsigned types, e.g., `x as u32` where `x: i32`"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for casts between numerical types that may
-    /// truncate large values. This is expected behavior, so the cast is `Allow` by
-    /// default.
-    ///
-    /// **Why is this bad?** In some problem domains, it is good practice to avoid
-    /// truncation. This lint can be activated to help assess where additional
-    /// checks could be beneficial.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    /// ```rust
-    /// fn as_u8(x: u64) -> u8 {
-    ///     x as u8
-    /// }
-    /// ```
-    pub CAST_POSSIBLE_TRUNCATION,
-    pedantic,
-    "casts that may cause truncation of the value, e.g., `x as u8` where `x: u32`, or `x as i32` where `x: f32`"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for casts from an unsigned type to a signed type of
-    /// the same size. Performing such a cast is a 'no-op' for the compiler,
-    /// i.e., nothing is changed at the bit level, and the binary representation of
-    /// the value is reinterpreted. This can cause wrapping if the value is too big
-    /// for the target signed type. However, the cast works as defined, so this lint
-    /// is `Allow` by default.
-    ///
-    /// **Why is this bad?** While such a cast is not bad in itself, the results can
-    /// be surprising when this is not the intended behavior, as demonstrated by the
-    /// example below.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    /// ```rust
-    /// u32::MAX as i32; // will yield a value of `-1`
-    /// ```
-    pub CAST_POSSIBLE_WRAP,
-    pedantic,
-    "casts that may cause wrapping around the value, e.g., `x as i32` where `x: u32` and `x > i32::MAX`"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for casts between numerical types that may
-    /// be replaced by safe conversion functions.
-    ///
-    /// **Why is this bad?** Rust's `as` keyword will perform many kinds of
-    /// conversions, including silently lossy conversions. Conversion functions such
-    /// as `i32::from` will only perform lossless conversions. Using the conversion
-    /// functions prevents conversions from turning into silent lossy conversions if
-    /// the types of the input expressions ever change, and make it easier for
-    /// people reading the code to know that the conversion is lossless.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    /// ```rust
-    /// fn as_u64(x: u8) -> u64 {
-    ///     x as u64
-    /// }
-    /// ```
-    ///
-    /// Using `::from` would look like this:
-    ///
-    /// ```rust
-    /// fn as_u64(x: u8) -> u64 {
-    ///     u64::from(x)
-    /// }
-    /// ```
-    pub CAST_LOSSLESS,
-    pedantic,
-    "casts using `as` that are known to be lossless, e.g., `x as u64` where `x: u8`"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for casts to the same type, casts of int literals to integer types
-    /// and casts of float literals to float types.
-    ///
-    /// **Why is this bad?** It's just unnecessary.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    /// ```rust
-    /// let _ = 2i32 as i32;
-    /// let _ = 0.5 as f32;
-    /// ```
-    ///
-    /// Better:
-    ///
-    /// ```rust
-    /// let _ = 2_i32;
-    /// let _ = 0.5_f32;
-    /// ```
-    pub UNNECESSARY_CAST,
-    complexity,
-    "cast to the same type, e.g., `x as i32` where `x: i32`"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for casts, using `as` or `pointer::cast`,
-    /// from a less-strictly-aligned pointer to a more-strictly-aligned pointer
-    ///
-    /// **Why is this bad?** Dereferencing the resulting pointer may be undefined
-    /// behavior.
-    ///
-    /// **Known problems:** Using `std::ptr::read_unaligned` and `std::ptr::write_unaligned` or similar
-    /// on the resulting pointer is fine. Is over-zealous: Casts with manual alignment checks or casts like
-    /// u64-> u8 -> u16 can be fine. Miri is able to do a more in-depth analysis.
-    ///
-    /// **Example:**
-    /// ```rust
-    /// let _ = (&1u8 as *const u8) as *const u16;
-    /// let _ = (&mut 1u8 as *mut u8) as *mut u16;
-    ///
-    /// (&1u8 as *const u8).cast::<u16>();
-    /// (&mut 1u8 as *mut u8).cast::<u16>();
-    /// ```
-    pub CAST_PTR_ALIGNMENT,
-    pedantic,
-    "cast from a pointer to a more-strictly-aligned pointer"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for casts of function pointers to something other than usize
-    ///
-    /// **Why is this bad?**
-    /// Casting a function pointer to anything other than usize/isize is not portable across
-    /// architectures, because you end up losing bits if the target type is too small or end up with a
-    /// bunch of extra bits that waste space and add more instructions to the final binary than
-    /// strictly necessary for the problem
-    ///
-    /// Casting to isize also doesn't make sense since there are no signed addresses.
-    ///
-    /// **Example**
-    ///
-    /// ```rust
-    /// // Bad
-    /// fn fun() -> i32 { 1 }
-    /// let a = fun as i64;
-    ///
-    /// // Good
-    /// fn fun2() -> i32 { 1 }
-    /// let a = fun2 as usize;
-    /// ```
-    pub FN_TO_NUMERIC_CAST,
-    style,
-    "casting a function pointer to a numeric type other than usize"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for casts of a function pointer to a numeric type not wide enough to
-    /// store address.
-    ///
-    /// **Why is this bad?**
-    /// Such a cast discards some bits of the function's address. If this is intended, it would be more
-    /// clearly expressed by casting to usize first, then casting the usize to the intended type (with
-    /// a comment) to perform the truncation.
-    ///
-    /// **Example**
-    ///
-    /// ```rust
-    /// // Bad
-    /// fn fn1() -> i16 {
-    ///     1
-    /// };
-    /// let _ = fn1 as i32;
-    ///
-    /// // Better: Cast to usize first, then comment with the reason for the truncation
-    /// fn fn2() -> i16 {
-    ///     1
-    /// };
-    /// let fn_ptr = fn2 as usize;
-    /// let fn_ptr_truncated = fn_ptr as i32;
-    /// ```
-    pub FN_TO_NUMERIC_CAST_WITH_TRUNCATION,
-    style,
-    "casting a function pointer to a numeric type not wide enough to store the address"
-}
-
-/// Returns the size in bits of an integral type.
-/// Will return 0 if the type is not an int or uint variant
-fn int_ty_to_nbits(typ: Ty<'_>, tcx: TyCtxt<'_>) -> u64 {
-    match typ.kind() {
-        ty::Int(i) => match i {
-            IntTy::Isize => tcx.data_layout.pointer_size.bits(),
-            IntTy::I8 => 8,
-            IntTy::I16 => 16,
-            IntTy::I32 => 32,
-            IntTy::I64 => 64,
-            IntTy::I128 => 128,
-        },
-        ty::Uint(i) => match i {
-            UintTy::Usize => tcx.data_layout.pointer_size.bits(),
-            UintTy::U8 => 8,
-            UintTy::U16 => 16,
-            UintTy::U32 => 32,
-            UintTy::U64 => 64,
-            UintTy::U128 => 128,
-        },
-        _ => 0,
-    }
-}
-
-fn is_isize_or_usize(typ: Ty<'_>) -> bool {
-    matches!(typ.kind(), ty::Int(IntTy::Isize) | ty::Uint(UintTy::Usize))
-}
-
-fn span_precision_loss_lint(cx: &LateContext<'_>, expr: &Expr<'_>, cast_from: Ty<'_>, cast_to_f64: bool) {
-    let mantissa_nbits = if cast_to_f64 { 52 } else { 23 };
-    let arch_dependent = is_isize_or_usize(cast_from) && cast_to_f64;
-    let arch_dependent_str = "on targets with 64-bit wide pointers ";
-    let from_nbits_str = if arch_dependent {
-        "64".to_owned()
-    } else if is_isize_or_usize(cast_from) {
-        "32 or 64".to_owned()
-    } else {
-        int_ty_to_nbits(cast_from, cx.tcx).to_string()
-    };
-    span_lint(
-        cx,
-        CAST_PRECISION_LOSS,
-        expr.span,
-        &format!(
-            "casting `{0}` to `{1}` causes a loss of precision {2}(`{0}` is {3} bits wide, \
-             but `{1}`'s mantissa is only {4} bits wide)",
-            cast_from,
-            if cast_to_f64 { "f64" } else { "f32" },
-            if arch_dependent { arch_dependent_str } else { "" },
-            from_nbits_str,
-            mantissa_nbits
-        ),
-    );
-}
-
-fn should_strip_parens(op: &Expr<'_>, snip: &str) -> bool {
-    if let ExprKind::Binary(_, _, _) = op.kind {
-        if snip.starts_with('(') && snip.ends_with(')') {
-            return true;
-        }
-    }
-    false
-}
-
-fn span_lossless_lint(cx: &LateContext<'_>, expr: &Expr<'_>, op: &Expr<'_>, cast_from: Ty<'_>, cast_to: Ty<'_>) {
-    // Do not suggest using From in consts/statics until it is valid to do so (see #2267).
-    if in_constant(cx, expr.hir_id) {
-        return;
-    }
-    // The suggestion is to use a function call, so if the original expression
-    // has parens on the outside, they are no longer needed.
-    let mut applicability = Applicability::MachineApplicable;
-    let opt = snippet_opt(cx, op.span);
-    let sugg = opt.as_ref().map_or_else(
-        || {
-            applicability = Applicability::HasPlaceholders;
-            ".."
-        },
-        |snip| {
-            if should_strip_parens(op, snip) {
-                &snip[1..snip.len() - 1]
-            } else {
-                snip.as_str()
-            }
-        },
-    );
-
-    span_lint_and_sugg(
-        cx,
-        CAST_LOSSLESS,
-        expr.span,
-        &format!(
-            "casting `{}` to `{}` may become silently lossy if you later change the type",
-            cast_from, cast_to
-        ),
-        "try",
-        format!("{}::from({})", cast_to, sugg),
-        applicability,
-    );
-}
-
-enum ArchSuffix {
-    _32,
-    _64,
-    None,
-}
-
-fn check_loss_of_sign(cx: &LateContext<'_>, expr: &Expr<'_>, op: &Expr<'_>, cast_from: Ty<'_>, cast_to: Ty<'_>) {
-    if !cast_from.is_signed() || cast_to.is_signed() {
-        return;
-    }
-
-    // don't lint for positive constants
-    let const_val = constant(cx, &cx.typeck_results(), op);
-    if_chain! {
-        if let Some((Constant::Int(n), _)) = const_val;
-        if let ty::Int(ity) = *cast_from.kind();
-        if sext(cx.tcx, n, ity) >= 0;
-        then {
-            return
-        }
-    }
-
-    // don't lint for the result of methods that always return non-negative values
-    if let ExprKind::MethodCall(ref path, _, _, _) = op.kind {
-        let mut method_name = path.ident.name.as_str();
-        let allowed_methods = ["abs", "checked_abs", "rem_euclid", "checked_rem_euclid"];
-
-        if_chain! {
-            if method_name == "unwrap";
-            if let Some(arglist) = method_chain_args(op, &["unwrap"]);
-            if let ExprKind::MethodCall(ref inner_path, _, _, _) = &arglist[0][0].kind;
-            then {
-                method_name = inner_path.ident.name.as_str();
-            }
-        }
-
-        if allowed_methods.iter().any(|&name| method_name == name) {
-            return;
-        }
-    }
-
-    span_lint(
-        cx,
-        CAST_SIGN_LOSS,
-        expr.span,
-        &format!(
-            "casting `{}` to `{}` may lose the sign of the value",
-            cast_from, cast_to
-        ),
-    );
-}
-
-fn check_truncation_and_wrapping(cx: &LateContext<'_>, expr: &Expr<'_>, cast_from: Ty<'_>, cast_to: Ty<'_>) {
-    let arch_64_suffix = " on targets with 64-bit wide pointers";
-    let arch_32_suffix = " on targets with 32-bit wide pointers";
-    let cast_unsigned_to_signed = !cast_from.is_signed() && cast_to.is_signed();
-    let from_nbits = int_ty_to_nbits(cast_from, cx.tcx);
-    let to_nbits = int_ty_to_nbits(cast_to, cx.tcx);
-    let (span_truncation, suffix_truncation, span_wrap, suffix_wrap) =
-        match (is_isize_or_usize(cast_from), is_isize_or_usize(cast_to)) {
-            (true, true) | (false, false) => (
-                to_nbits < from_nbits,
-                ArchSuffix::None,
-                to_nbits == from_nbits && cast_unsigned_to_signed,
-                ArchSuffix::None,
-            ),
-            (true, false) => (
-                to_nbits <= 32,
-                if to_nbits == 32 {
-                    ArchSuffix::_64
-                } else {
-                    ArchSuffix::None
-                },
-                to_nbits <= 32 && cast_unsigned_to_signed,
-                ArchSuffix::_32,
-            ),
-            (false, true) => (
-                from_nbits == 64,
-                ArchSuffix::_32,
-                cast_unsigned_to_signed,
-                if from_nbits == 64 {
-                    ArchSuffix::_64
-                } else {
-                    ArchSuffix::_32
-                },
-            ),
-        };
-    if span_truncation {
-        span_lint(
-            cx,
-            CAST_POSSIBLE_TRUNCATION,
-            expr.span,
-            &format!(
-                "casting `{}` to `{}` may truncate the value{}",
-                cast_from,
-                cast_to,
-                match suffix_truncation {
-                    ArchSuffix::_32 => arch_32_suffix,
-                    ArchSuffix::_64 => arch_64_suffix,
-                    ArchSuffix::None => "",
-                }
-            ),
-        );
-    }
-    if span_wrap {
-        span_lint(
-            cx,
-            CAST_POSSIBLE_WRAP,
-            expr.span,
-            &format!(
-                "casting `{}` to `{}` may wrap around the value{}",
-                cast_from,
-                cast_to,
-                match suffix_wrap {
-                    ArchSuffix::_32 => arch_32_suffix,
-                    ArchSuffix::_64 => arch_64_suffix,
-                    ArchSuffix::None => "",
-                }
-            ),
-        );
-    }
-}
-
-fn check_lossless(cx: &LateContext<'_>, expr: &Expr<'_>, op: &Expr<'_>, cast_from: Ty<'_>, cast_to: Ty<'_>) {
-    let cast_signed_to_unsigned = cast_from.is_signed() && !cast_to.is_signed();
-    let from_nbits = int_ty_to_nbits(cast_from, cx.tcx);
-    let to_nbits = int_ty_to_nbits(cast_to, cx.tcx);
-    if !is_isize_or_usize(cast_from) && !is_isize_or_usize(cast_to) && from_nbits < to_nbits && !cast_signed_to_unsigned
-    {
-        span_lossless_lint(cx, expr, op, cast_from, cast_to);
-    }
-}
-
-declare_lint_pass!(Casts => [
-    CAST_PRECISION_LOSS,
-    CAST_SIGN_LOSS,
-    CAST_POSSIBLE_TRUNCATION,
-    CAST_POSSIBLE_WRAP,
-    CAST_LOSSLESS,
-    UNNECESSARY_CAST,
-    CAST_PTR_ALIGNMENT,
-    FN_TO_NUMERIC_CAST,
-    FN_TO_NUMERIC_CAST_WITH_TRUNCATION,
-]);
-
-// Check if the given type is either `core::ffi::c_void` or
-// one of the platform specific `libc::<platform>::c_void` of libc.
-fn is_c_void(cx: &LateContext<'_>, ty: Ty<'_>) -> bool {
-    if let ty::Adt(adt, _) = ty.kind() {
-        let names = cx.get_def_path(adt.did);
-
-        if names.is_empty() {
-            return false;
-        }
-        if names[0] == sym::libc || names[0] == sym::core && *names.last().unwrap() == sym!(c_void) {
-            return true;
-        }
-    }
-    false
-}
-
-/// Returns the mantissa bits wide of a fp type.
-/// Will return 0 if the type is not a fp
-fn fp_ty_mantissa_nbits(typ: Ty<'_>) -> u32 {
-    match typ.kind() {
-        ty::Float(FloatTy::F32) => 23,
-        ty::Float(FloatTy::F64) | ty::Infer(InferTy::FloatVar(_)) => 52,
-        _ => 0,
-    }
-}
-
-impl<'tcx> LateLintPass<'tcx> for Casts {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if expr.span.from_expansion() {
-            return;
-        }
-        if let ExprKind::Cast(ref ex, cast_to) = expr.kind {
-            if is_hir_ty_cfg_dependant(cx, cast_to) {
-                return;
-            }
-            let (cast_from, cast_to) = (cx.typeck_results().expr_ty(ex), cx.typeck_results().expr_ty(expr));
-            lint_fn_to_numeric_cast(cx, expr, ex, cast_from, cast_to);
-            if let Some(lit) = get_numeric_literal(ex) {
-                let literal_str = snippet_opt(cx, ex.span).unwrap_or_default();
-
-                if_chain! {
-                    if let LitKind::Int(n, _) = lit.node;
-                    if let Some(src) = snippet_opt(cx, lit.span);
-                    if cast_to.is_floating_point();
-                    if let Some(num_lit) = NumericLiteral::from_lit_kind(&src, &lit.node);
-                    let from_nbits = 128 - n.leading_zeros();
-                    let to_nbits = fp_ty_mantissa_nbits(cast_to);
-                    if from_nbits != 0 && to_nbits != 0 && from_nbits <= to_nbits && num_lit.is_decimal();
-                    then {
-                        let literal_str = if is_unary_neg(ex) { format!("-{}", num_lit.integer) } else { num_lit.integer.into() };
-                        show_unnecessary_cast(cx, expr, &literal_str, cast_from, cast_to);
-                        return;
-                    }
-                }
-
-                match lit.node {
-                    LitKind::Int(_, LitIntType::Unsuffixed) if cast_to.is_integral() => {
-                        show_unnecessary_cast(cx, expr, &literal_str, cast_from, cast_to);
-                    },
-                    LitKind::Float(_, LitFloatType::Unsuffixed) if cast_to.is_floating_point() => {
-                        show_unnecessary_cast(cx, expr, &literal_str, cast_from, cast_to);
-                    },
-                    LitKind::Int(_, LitIntType::Unsuffixed) | LitKind::Float(_, LitFloatType::Unsuffixed) => {},
-                    _ => {
-                        if cast_from.kind() == cast_to.kind() && !in_external_macro(cx.sess(), expr.span) {
-                            span_lint(
-                                cx,
-                                UNNECESSARY_CAST,
-                                expr.span,
-                                &format!(
-                                    "casting to the same type is unnecessary (`{}` -> `{}`)",
-                                    cast_from, cast_to
-                                ),
-                            );
-                        }
-                    },
-                }
-            }
-            if cast_from.is_numeric() && cast_to.is_numeric() && !in_external_macro(cx.sess(), expr.span) {
-                lint_numeric_casts(cx, expr, ex, cast_from, cast_to);
-            }
-
-            lint_cast_ptr_alignment(cx, expr, cast_from, cast_to);
-        } else if let ExprKind::MethodCall(method_path, _, args, _) = expr.kind {
-            if_chain! {
-            if method_path.ident.name == sym!(cast);
-            if let Some(generic_args) = method_path.args;
-            if let [GenericArg::Type(cast_to)] = generic_args.args;
-            // There probably is no obvious reason to do this, just to be consistent with `as` cases.
-            if !is_hir_ty_cfg_dependant(cx, cast_to);
-            then {
-                let (cast_from, cast_to) =
-                    (cx.typeck_results().expr_ty(&args[0]), cx.typeck_results().expr_ty(expr));
-                lint_cast_ptr_alignment(cx, expr, cast_from, cast_to);
-            }
-            }
-        }
-    }
-}
-
-fn is_unary_neg(expr: &Expr<'_>) -> bool {
-    matches!(expr.kind, ExprKind::Unary(UnOp::Neg, _))
-}
-
-fn get_numeric_literal<'e>(expr: &'e Expr<'e>) -> Option<&'e Lit> {
-    match expr.kind {
-        ExprKind::Lit(ref lit) => Some(lit),
-        ExprKind::Unary(UnOp::Neg, e) => {
-            if let ExprKind::Lit(ref lit) = e.kind {
-                Some(lit)
-            } else {
-                None
-            }
-        },
-        _ => None,
-    }
-}
-
-fn show_unnecessary_cast(cx: &LateContext<'_>, expr: &Expr<'_>, literal_str: &str, cast_from: Ty<'_>, cast_to: Ty<'_>) {
-    let literal_kind_name = if cast_from.is_integral() { "integer" } else { "float" };
-    span_lint_and_sugg(
-        cx,
-        UNNECESSARY_CAST,
-        expr.span,
-        &format!("casting {} literal to `{}` is unnecessary", literal_kind_name, cast_to),
-        "try",
-        format!("{}_{}", literal_str.trim_end_matches('.'), cast_to),
-        Applicability::MachineApplicable,
-    );
-}
-
-fn lint_numeric_casts<'tcx>(
-    cx: &LateContext<'tcx>,
-    expr: &Expr<'tcx>,
-    cast_expr: &Expr<'_>,
-    cast_from: Ty<'tcx>,
-    cast_to: Ty<'tcx>,
-) {
-    match (cast_from.is_integral(), cast_to.is_integral()) {
-        (true, false) => {
-            let from_nbits = int_ty_to_nbits(cast_from, cx.tcx);
-            let to_nbits = if let ty::Float(FloatTy::F32) = cast_to.kind() {
-                32
-            } else {
-                64
-            };
-            if is_isize_or_usize(cast_from) || from_nbits >= to_nbits {
-                span_precision_loss_lint(cx, expr, cast_from, to_nbits == 64);
-            }
-            if from_nbits < to_nbits {
-                span_lossless_lint(cx, expr, cast_expr, cast_from, cast_to);
-            }
-        },
-        (false, true) => {
-            span_lint(
-                cx,
-                CAST_POSSIBLE_TRUNCATION,
-                expr.span,
-                &format!("casting `{}` to `{}` may truncate the value", cast_from, cast_to),
-            );
-            if !cast_to.is_signed() {
-                span_lint(
-                    cx,
-                    CAST_SIGN_LOSS,
-                    expr.span,
-                    &format!(
-                        "casting `{}` to `{}` may lose the sign of the value",
-                        cast_from, cast_to
-                    ),
-                );
-            }
-        },
-        (true, true) => {
-            check_loss_of_sign(cx, expr, cast_expr, cast_from, cast_to);
-            check_truncation_and_wrapping(cx, expr, cast_from, cast_to);
-            check_lossless(cx, expr, cast_expr, cast_from, cast_to);
-        },
-        (false, false) => {
-            if let (&ty::Float(FloatTy::F64), &ty::Float(FloatTy::F32)) = (&cast_from.kind(), &cast_to.kind()) {
-                span_lint(
-                    cx,
-                    CAST_POSSIBLE_TRUNCATION,
-                    expr.span,
-                    "casting `f64` to `f32` may truncate the value",
-                );
-            }
-            if let (&ty::Float(FloatTy::F32), &ty::Float(FloatTy::F64)) = (&cast_from.kind(), &cast_to.kind()) {
-                span_lossless_lint(cx, expr, cast_expr, cast_from, cast_to);
-            }
-        },
-    }
-}
-
-fn lint_cast_ptr_alignment<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, cast_from: Ty<'tcx>, cast_to: Ty<'tcx>) {
-    if_chain! {
-        if let ty::RawPtr(from_ptr_ty) = &cast_from.kind();
-        if let ty::RawPtr(to_ptr_ty) = &cast_to.kind();
-        if let Ok(from_layout) = cx.layout_of(from_ptr_ty.ty);
-        if let Ok(to_layout) = cx.layout_of(to_ptr_ty.ty);
-        if from_layout.align.abi < to_layout.align.abi;
-        // with c_void, we inherently need to trust the user
-        if !is_c_void(cx, from_ptr_ty.ty);
-        // when casting from a ZST, we don't know enough to properly lint
-        if !from_layout.is_zst();
-        then {
-            span_lint(
-                cx,
-                CAST_PTR_ALIGNMENT,
-                expr.span,
-                &format!(
-                    "casting from `{}` to a more-strictly-aligned pointer (`{}`) ({} < {} bytes)",
-                    cast_from,
-                    cast_to,
-                    from_layout.align.abi.bytes(),
-                    to_layout.align.abi.bytes(),
-                ),
-            );
-        }
-    }
-}
-
-fn lint_fn_to_numeric_cast(
-    cx: &LateContext<'_>,
-    expr: &Expr<'_>,
-    cast_expr: &Expr<'_>,
-    cast_from: Ty<'_>,
-    cast_to: Ty<'_>,
-) {
-    // We only want to check casts to `ty::Uint` or `ty::Int`
-    match cast_to.kind() {
-        ty::Uint(_) | ty::Int(..) => { /* continue on */ },
-        _ => return,
-    }
-    match cast_from.kind() {
-        ty::FnDef(..) | ty::FnPtr(_) => {
-            let mut applicability = Applicability::MaybeIncorrect;
-            let from_snippet = snippet_with_applicability(cx, cast_expr.span, "x", &mut applicability);
-
-            let to_nbits = int_ty_to_nbits(cast_to, cx.tcx);
-            if to_nbits < cx.tcx.data_layout.pointer_size.bits() {
-                span_lint_and_sugg(
-                    cx,
-                    FN_TO_NUMERIC_CAST_WITH_TRUNCATION,
-                    expr.span,
-                    &format!(
-                        "casting function pointer `{}` to `{}`, which truncates the value",
-                        from_snippet, cast_to
-                    ),
-                    "try",
-                    format!("{} as usize", from_snippet),
-                    applicability,
-                );
-            } else if *cast_to.kind() != ty::Uint(UintTy::Usize) {
-                span_lint_and_sugg(
-                    cx,
-                    FN_TO_NUMERIC_CAST,
-                    expr.span,
-                    &format!("casting function pointer `{}` to `{}`", from_snippet, cast_to),
-                    "try",
-                    format!("{} as usize", from_snippet),
-                    applicability,
-                );
-            }
-        },
-        _ => {},
-    }
-}
-
 declare_clippy_lint! {
     /// **What it does:** Checks for types used in structs, parameters and `let`
     /// declarations above a certain complexity threshold.
@@ -1686,69 +939,6 @@ impl<'tcx> Visitor<'tcx> for TypeComplexityVisitor {
     }
 }
 
-declare_clippy_lint! {
-    /// **What it does:** Checks for expressions where a character literal is cast
-    /// to `u8` and suggests using a byte literal instead.
-    ///
-    /// **Why is this bad?** In general, casting values to smaller types is
-    /// error-prone and should be avoided where possible. In the particular case of
-    /// converting a character literal to u8, it is easy to avoid by just using a
-    /// byte literal instead. As an added bonus, `b'a'` is even slightly shorter
-    /// than `'a' as u8`.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    /// ```rust,ignore
-    /// 'x' as u8
-    /// ```
-    ///
-    /// A better version, using the byte literal:
-    ///
-    /// ```rust,ignore
-    /// b'x'
-    /// ```
-    pub CHAR_LIT_AS_U8,
-    complexity,
-    "casting a character literal to `u8` truncates"
-}
-
-declare_lint_pass!(CharLitAsU8 => [CHAR_LIT_AS_U8]);
-
-impl<'tcx> LateLintPass<'tcx> for CharLitAsU8 {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if_chain! {
-            if !expr.span.from_expansion();
-            if let ExprKind::Cast(e, _) = &expr.kind;
-            if let ExprKind::Lit(l) = &e.kind;
-            if let LitKind::Char(c) = l.node;
-            if ty::Uint(UintTy::U8) == *cx.typeck_results().expr_ty(expr).kind();
-            then {
-                let mut applicability = Applicability::MachineApplicable;
-                let snippet = snippet_with_applicability(cx, e.span, "'x'", &mut applicability);
-
-                span_lint_and_then(
-                    cx,
-                    CHAR_LIT_AS_U8,
-                    expr.span,
-                    "casting a character literal to `u8` truncates",
-                    |diag| {
-                        diag.note("`char` is four bytes wide, but `u8` is a single byte");
-
-                        if c.is_ascii() {
-                            diag.span_suggestion(
-                                expr.span,
-                                "use a byte literal instead",
-                                format!("b{}", snippet),
-                                applicability,
-                            );
-                        }
-                });
-            }
-        }
-    }
-}
-
 declare_clippy_lint! {
     /// **What it does:** Checks for comparisons where one side of the relation is
     /// either the minimum or maximum value for its type and warns if it involves a
@@ -2477,149 +1667,6 @@ impl<'a, 'b, 'tcx> Visitor<'tcx> for ImplicitHasherConstructorVisitor<'a, 'b, 't
     }
 }
 
-declare_clippy_lint! {
-    /// **What it does:** Checks for casts of `&T` to `&mut T` anywhere in the code.
-    ///
-    /// **Why is this bad?** It’s basically guaranteed to be undefined behaviour.
-    /// `UnsafeCell` is the only way to obtain aliasable data that is considered
-    /// mutable.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    /// ```rust,ignore
-    /// fn x(r: &i32) {
-    ///     unsafe {
-    ///         *(r as *const _ as *mut _) += 1;
-    ///     }
-    /// }
-    /// ```
-    ///
-    /// Instead consider using interior mutability types.
-    ///
-    /// ```rust
-    /// use std::cell::UnsafeCell;
-    ///
-    /// fn x(r: &UnsafeCell<i32>) {
-    ///     unsafe {
-    ///         *r.get() += 1;
-    ///     }
-    /// }
-    /// ```
-    pub CAST_REF_TO_MUT,
-    correctness,
-    "a cast of reference to a mutable pointer"
-}
-
-declare_lint_pass!(RefToMut => [CAST_REF_TO_MUT]);
-
-impl<'tcx> LateLintPass<'tcx> for RefToMut {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if_chain! {
-            if let ExprKind::Unary(UnOp::Deref, e) = &expr.kind;
-            if let ExprKind::Cast(e, t) = &e.kind;
-            if let TyKind::Ptr(MutTy { mutbl: Mutability::Mut, .. }) = t.kind;
-            if let ExprKind::Cast(e, t) = &e.kind;
-            if let TyKind::Ptr(MutTy { mutbl: Mutability::Not, .. }) = t.kind;
-            if let ty::Ref(..) = cx.typeck_results().node_type(e.hir_id).kind();
-            then {
-                span_lint(
-                    cx,
-                    CAST_REF_TO_MUT,
-                    expr.span,
-                    "casting `&T` to `&mut T` may cause undefined behavior, consider instead using an `UnsafeCell`",
-                );
-            }
-        }
-    }
-}
-
-const PTR_AS_PTR_MSRV: RustcVersion = RustcVersion::new(1, 38, 0);
-
-declare_clippy_lint! {
-    /// **What it does:**
-    /// Checks for `as` casts between raw pointers without changing its mutability,
-    /// namely `*const T` to `*const U` and `*mut T` to `*mut U`.
-    ///
-    /// **Why is this bad?**
-    /// Though `as` casts between raw pointers is not terrible, `pointer::cast` is safer because
-    /// it cannot accidentally change the pointer's mutability nor cast the pointer to other types like `usize`.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
-    /// ```rust
-    /// let ptr: *const u32 = &42_u32;
-    /// let mut_ptr: *mut u32 = &mut 42_u32;
-    /// let _ = ptr as *const i32;
-    /// let _ = mut_ptr as *mut i32;
-    /// ```
-    /// Use instead:
-    /// ```rust
-    /// let ptr: *const u32 = &42_u32;
-    /// let mut_ptr: *mut u32 = &mut 42_u32;
-    /// let _ = ptr.cast::<i32>();
-    /// let _ = mut_ptr.cast::<i32>();
-    /// ```
-    pub PTR_AS_PTR,
-    pedantic,
-    "casting using `as` from and to raw pointers that doesn't change its mutability, where `pointer::cast` could take the place of `as`"
-}
-
-pub struct PtrAsPtr {
-    msrv: Option<RustcVersion>,
-}
-
-impl PtrAsPtr {
-    #[must_use]
-    pub fn new(msrv: Option<RustcVersion>) -> Self {
-        Self { msrv }
-    }
-}
-
-impl_lint_pass!(PtrAsPtr => [PTR_AS_PTR]);
-
-impl<'tcx> LateLintPass<'tcx> for PtrAsPtr {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if !meets_msrv(self.msrv.as_ref(), &PTR_AS_PTR_MSRV) {
-            return;
-        }
-
-        if expr.span.from_expansion() {
-            return;
-        }
-
-        if_chain! {
-            if let ExprKind::Cast(cast_expr, cast_to_hir_ty) = expr.kind;
-            let (cast_from, cast_to) = (cx.typeck_results().expr_ty(cast_expr), cx.typeck_results().expr_ty(expr));
-            if let ty::RawPtr(TypeAndMut { mutbl: from_mutbl, .. }) = cast_from.kind();
-            if let ty::RawPtr(TypeAndMut { ty: to_pointee_ty, mutbl: to_mutbl }) = cast_to.kind();
-            if matches!((from_mutbl, to_mutbl),
-                (Mutability::Not, Mutability::Not) | (Mutability::Mut, Mutability::Mut));
-            // The `U` in `pointer::cast` have to be `Sized`
-            // as explained here: https://github.com/rust-lang/rust/issues/60602.
-            if to_pointee_ty.is_sized(cx.tcx.at(expr.span), cx.param_env);
-            then {
-                let mut applicability = Applicability::MachineApplicable;
-                let cast_expr_sugg = Sugg::hir_with_applicability(cx, cast_expr, "_", &mut applicability);
-                let turbofish = match &cast_to_hir_ty.kind {
-                        TyKind::Infer => Cow::Borrowed(""),
-                        TyKind::Ptr(mut_ty) if matches!(mut_ty.ty.kind, TyKind::Infer) => Cow::Borrowed(""),
-                        _ => Cow::Owned(format!("::<{}>", to_pointee_ty)),
-                    };
-                span_lint_and_sugg(
-                    cx,
-                    PTR_AS_PTR,
-                    expr.span,
-                    "`as` casting between raw pointers without changing its mutability",
-                    "try `pointer::cast`, a safer alternative",
-                    format!("{}.cast{}()", cast_expr_sugg.maybe_par(), turbofish),
-                    applicability,
-                );
-            }
-        }
-    }
-
-    extract_msrv_attr!(LateContext);
+fn is_isize_or_usize(typ: Ty<'_>) -> bool {
+    matches!(typ.kind(), ty::Int(IntTy::Isize) | ty::Uint(UintTy::Usize))
 }
-- 
cgit 1.4.1-3-g733a5


From 360f0654047ef45212440e0cc9dcfe77c970b1eb Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Tue, 9 Mar 2021 11:08:26 +0900
Subject: Move 'is_isize_or_usize' to clippy_utils

---
 clippy_lints/src/casts/mod.rs |  9 +++------
 clippy_lints/src/types/mod.rs | 10 +++-------
 clippy_utils/src/lib.rs       |  7 ++++++-
 3 files changed, 12 insertions(+), 14 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index d8245a3b88f..95e563fc3ba 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -15,8 +15,9 @@ use rustc_target::abi::LayoutOf;
 use crate::consts::{constant, Constant};
 use crate::utils::sugg::Sugg;
 use crate::utils::{
-    in_constant, is_hir_ty_cfg_dependant, meets_msrv, method_chain_args, numeric_literal::NumericLiteral, sext,
-    snippet_opt, snippet_with_applicability, span_lint, span_lint_and_sugg, span_lint_and_then,
+    in_constant, is_hir_ty_cfg_dependant, is_isize_or_usize, meets_msrv, method_chain_args,
+    numeric_literal::NumericLiteral, sext, snippet_opt, snippet_with_applicability, span_lint, span_lint_and_sugg,
+    span_lint_and_then,
 };
 
 declare_clippy_lint! {
@@ -967,7 +968,3 @@ impl<'tcx> LateLintPass<'tcx> for PtrAsPtr {
 
     extract_msrv_attr!(LateContext);
 }
-
-fn is_isize_or_usize(typ: Ty<'_>) -> bool {
-    matches!(typ.kind(), ty::Int(IntTy::Isize) | ty::Uint(UintTy::Usize))
-}
diff --git a/clippy_lints/src/types/mod.rs b/clippy_lints/src/types/mod.rs
index 3e7aa53d5bc..7be4ea03793 100644
--- a/clippy_lints/src/types/mod.rs
+++ b/clippy_lints/src/types/mod.rs
@@ -37,9 +37,9 @@ use rustc_typeck::hir_ty_to_ty;
 use crate::consts::{constant, Constant};
 use crate::utils::paths;
 use crate::utils::{
-    clip, comparisons, differing_macro_contexts, higher, indent_of, int_bits, is_type_diagnostic_item, match_path,
-    multispan_sugg, reindent_multiline, sext, snippet, snippet_opt, snippet_with_macro_callsite, span_lint,
-    span_lint_and_help, span_lint_and_then, unsext,
+    clip, comparisons, differing_macro_contexts, higher, indent_of, int_bits, is_isize_or_usize,
+    is_type_diagnostic_item, match_path, multispan_sugg, reindent_multiline, sext, snippet, snippet_opt,
+    snippet_with_macro_callsite, span_lint, span_lint_and_help, span_lint_and_then, unsext,
 };
 
 declare_clippy_lint! {
@@ -1666,7 +1666,3 @@ impl<'a, 'b, 'tcx> Visitor<'tcx> for ImplicitHasherConstructorVisitor<'a, 'b, 't
         NestedVisitorMap::OnlyBodies(self.cx.tcx.hir())
     }
 }
-
-fn is_isize_or_usize(typ: Ty<'_>) -> bool {
-    matches!(typ.kind(), ty::Int(IntTy::Isize) | ty::Uint(UintTy::Usize))
-}
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 3845667802d..74429982759 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -72,7 +72,7 @@ use rustc_lint::{LateContext, Level, Lint, LintContext};
 use rustc_middle::hir::exports::Export;
 use rustc_middle::hir::map::Map;
 use rustc_middle::ty::subst::{GenericArg, GenericArgKind};
-use rustc_middle::ty::{self, layout::IntegerExt, DefIdTree, Ty, TyCtxt, TypeFoldable};
+use rustc_middle::ty::{self, layout::IntegerExt, DefIdTree, IntTy, Ty, TyCtxt, TypeFoldable, UintTy};
 use rustc_semver::RustcVersion;
 use rustc_session::Session;
 use rustc_span::hygiene::{self, ExpnKind, MacroKind};
@@ -262,6 +262,11 @@ pub fn is_ty_param_diagnostic_item(
     }
 }
 
+/// Return `true` if the passed `typ` is `isize` or `usize`.
+pub fn is_isize_or_usize(typ: Ty<'_>) -> bool {
+    matches!(typ.kind(), ty::Int(IntTy::Isize) | ty::Uint(UintTy::Usize))
+}
+
 /// Checks if the method call given in `expr` belongs to the given trait.
 pub fn match_trait_method(cx: &LateContext<'_>, expr: &Expr<'_>, path: &[&str]) -> bool {
     let def_id = cx.typeck_results().type_dependent_def_id(expr.hir_id).unwrap();
-- 
cgit 1.4.1-3-g733a5


From c2cbcd32299270487388442e3dc684619279ae6b Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Tue, 9 Mar 2021 11:22:17 +0900
Subject: Move cast_precision_loss to its own module

---
 clippy_lints/src/casts/cast_precision_loss.rs | 51 ++++++++++++++++++++++
 clippy_lints/src/casts/mod.rs                 | 62 +++------------------------
 clippy_lints/src/casts/utils.rs               | 25 +++++++++++
 3 files changed, 83 insertions(+), 55 deletions(-)
 create mode 100644 clippy_lints/src/casts/cast_precision_loss.rs
 create mode 100644 clippy_lints/src/casts/utils.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/cast_precision_loss.rs b/clippy_lints/src/casts/cast_precision_loss.rs
new file mode 100644
index 00000000000..a1c3900ce1f
--- /dev/null
+++ b/clippy_lints/src/casts/cast_precision_loss.rs
@@ -0,0 +1,51 @@
+use rustc_hir::Expr;
+use rustc_lint::LateContext;
+use rustc_middle::ty::{self, FloatTy, Ty};
+
+use crate::utils::{is_isize_or_usize, span_lint};
+
+use super::{utils, CAST_PRECISION_LOSS};
+
+pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_from: Ty<'_>, cast_to: Ty<'_>) {
+    if !cast_from.is_integral() || cast_to.is_integral() {
+        return;
+    }
+
+    let from_nbits = utils::int_ty_to_nbits(cast_from, cx.tcx);
+    let to_nbits = if let ty::Float(FloatTy::F32) = cast_to.kind() {
+        32
+    } else {
+        64
+    };
+
+    if !(is_isize_or_usize(cast_from) || from_nbits >= to_nbits) {
+        return;
+    }
+
+    let cast_to_f64 = to_nbits == 64;
+    let mantissa_nbits = if cast_to_f64 { 52 } else { 23 };
+    let arch_dependent = is_isize_or_usize(cast_from) && cast_to_f64;
+    let arch_dependent_str = "on targets with 64-bit wide pointers ";
+    let from_nbits_str = if arch_dependent {
+        "64".to_owned()
+    } else if is_isize_or_usize(cast_from) {
+        "32 or 64".to_owned()
+    } else {
+        utils::int_ty_to_nbits(cast_from, cx.tcx).to_string()
+    };
+
+    span_lint(
+        cx,
+        CAST_PRECISION_LOSS,
+        expr.span,
+        &format!(
+            "casting `{0}` to `{1}` causes a loss of precision {2}(`{0}` is {3} bits wide, \
+             but `{1}`'s mantissa is only {4} bits wide)",
+            cast_from,
+            if cast_to_f64 { "f64" } else { "f32" },
+            if arch_dependent { arch_dependent_str } else { "" },
+            from_nbits_str,
+            mantissa_nbits
+        ),
+    );
+}
diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index 95e563fc3ba..7eb35aa8290 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -1,3 +1,6 @@
+mod cast_precision_loss;
+mod utils;
+
 use std::borrow::Cow;
 
 use if_chain::if_chain;
@@ -6,7 +9,7 @@ use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, GenericArg, Lit, MutTy, Mutability, TyKind, UnOp};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_middle::ty::{self, FloatTy, InferTy, IntTy, Ty, TyCtxt, TypeAndMut, UintTy};
+use rustc_middle::ty::{self, FloatTy, InferTy, Ty, TypeAndMut, UintTy};
 use rustc_semver::RustcVersion;
 use rustc_session::{declare_lint_pass, declare_tool_lint, impl_lint_pass};
 use rustc_span::symbol::sym;
@@ -20,6 +23,8 @@ use crate::utils::{
     span_lint_and_then,
 };
 
+use utils::int_ty_to_nbits;
+
 declare_clippy_lint! {
     /// **What it does:** Checks for casts from any numerical to a float type where
     /// the receiving type cannot store all values from the original type without
@@ -249,57 +254,6 @@ declare_clippy_lint! {
     "casting a function pointer to a numeric type not wide enough to store the address"
 }
 
-/// Returns the size in bits of an integral type.
-/// Will return 0 if the type is not an int or uint variant
-fn int_ty_to_nbits(typ: Ty<'_>, tcx: TyCtxt<'_>) -> u64 {
-    match typ.kind() {
-        ty::Int(i) => match i {
-            IntTy::Isize => tcx.data_layout.pointer_size.bits(),
-            IntTy::I8 => 8,
-            IntTy::I16 => 16,
-            IntTy::I32 => 32,
-            IntTy::I64 => 64,
-            IntTy::I128 => 128,
-        },
-        ty::Uint(i) => match i {
-            UintTy::Usize => tcx.data_layout.pointer_size.bits(),
-            UintTy::U8 => 8,
-            UintTy::U16 => 16,
-            UintTy::U32 => 32,
-            UintTy::U64 => 64,
-            UintTy::U128 => 128,
-        },
-        _ => 0,
-    }
-}
-
-fn span_precision_loss_lint(cx: &LateContext<'_>, expr: &Expr<'_>, cast_from: Ty<'_>, cast_to_f64: bool) {
-    let mantissa_nbits = if cast_to_f64 { 52 } else { 23 };
-    let arch_dependent = is_isize_or_usize(cast_from) && cast_to_f64;
-    let arch_dependent_str = "on targets with 64-bit wide pointers ";
-    let from_nbits_str = if arch_dependent {
-        "64".to_owned()
-    } else if is_isize_or_usize(cast_from) {
-        "32 or 64".to_owned()
-    } else {
-        int_ty_to_nbits(cast_from, cx.tcx).to_string()
-    };
-    span_lint(
-        cx,
-        CAST_PRECISION_LOSS,
-        expr.span,
-        &format!(
-            "casting `{0}` to `{1}` causes a loss of precision {2}(`{0}` is {3} bits wide, \
-             but `{1}`'s mantissa is only {4} bits wide)",
-            cast_from,
-            if cast_to_f64 { "f64" } else { "f32" },
-            if arch_dependent { arch_dependent_str } else { "" },
-            from_nbits_str,
-            mantissa_nbits
-        ),
-    );
-}
-
 fn should_strip_parens(op: &Expr<'_>, snip: &str) -> bool {
     if let ExprKind::Binary(_, _, _) = op.kind {
         if snip.starts_with('(') && snip.ends_with(')') {
@@ -629,6 +583,7 @@ fn lint_numeric_casts<'tcx>(
     cast_from: Ty<'tcx>,
     cast_to: Ty<'tcx>,
 ) {
+    cast_precision_loss::check(cx, expr, cast_from, cast_to);
     match (cast_from.is_integral(), cast_to.is_integral()) {
         (true, false) => {
             let from_nbits = int_ty_to_nbits(cast_from, cx.tcx);
@@ -637,9 +592,6 @@ fn lint_numeric_casts<'tcx>(
             } else {
                 64
             };
-            if is_isize_or_usize(cast_from) || from_nbits >= to_nbits {
-                span_precision_loss_lint(cx, expr, cast_from, to_nbits == 64);
-            }
             if from_nbits < to_nbits {
                 span_lossless_lint(cx, expr, cast_expr, cast_from, cast_to);
             }
diff --git a/clippy_lints/src/casts/utils.rs b/clippy_lints/src/casts/utils.rs
new file mode 100644
index 00000000000..00fd0b3473b
--- /dev/null
+++ b/clippy_lints/src/casts/utils.rs
@@ -0,0 +1,25 @@
+use rustc_middle::ty::{self, IntTy, Ty, TyCtxt, UintTy};
+
+/// Returns the size in bits of an integral type.
+/// Will return 0 if the type is not an int or uint variant
+pub(super) fn int_ty_to_nbits(typ: Ty<'_>, tcx: TyCtxt<'_>) -> u64 {
+    match typ.kind() {
+        ty::Int(i) => match i {
+            IntTy::Isize => tcx.data_layout.pointer_size.bits(),
+            IntTy::I8 => 8,
+            IntTy::I16 => 16,
+            IntTy::I32 => 32,
+            IntTy::I64 => 64,
+            IntTy::I128 => 128,
+        },
+        ty::Uint(i) => match i {
+            UintTy::Usize => tcx.data_layout.pointer_size.bits(),
+            UintTy::U8 => 8,
+            UintTy::U16 => 16,
+            UintTy::U32 => 32,
+            UintTy::U64 => 64,
+            UintTy::U128 => 128,
+        },
+        _ => 0,
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From b12d7515b1ee867b0ef23b489f5b3166bed31ae3 Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Tue, 9 Mar 2021 11:44:52 +0900
Subject: Move cast_lossless to its own module

---
 clippy_lints/src/casts/cast_lossless.rs | 87 +++++++++++++++++++++++++++++++++
 clippy_lints/src/casts/mod.rs           | 79 ++----------------------------
 2 files changed, 92 insertions(+), 74 deletions(-)
 create mode 100644 clippy_lints/src/casts/cast_lossless.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/cast_lossless.rs b/clippy_lints/src/casts/cast_lossless.rs
new file mode 100644
index 00000000000..478832a5164
--- /dev/null
+++ b/clippy_lints/src/casts/cast_lossless.rs
@@ -0,0 +1,87 @@
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind};
+use rustc_lint::LateContext;
+use rustc_middle::ty::{self, FloatTy, Ty};
+
+use crate::utils::{in_constant, is_isize_or_usize, snippet_opt, span_lint_and_sugg};
+
+use super::{utils, CAST_LOSSLESS};
+
+pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_op: &Expr<'_>, cast_from: Ty<'_>, cast_to: Ty<'_>) {
+    if !should_lint(cx, expr, cast_from, cast_to) {
+        return;
+    }
+
+    // The suggestion is to use a function call, so if the original expression
+    // has parens on the outside, they are no longer needed.
+    let mut applicability = Applicability::MachineApplicable;
+    let opt = snippet_opt(cx, cast_op.span);
+    let sugg = opt.as_ref().map_or_else(
+        || {
+            applicability = Applicability::HasPlaceholders;
+            ".."
+        },
+        |snip| {
+            if should_strip_parens(cast_op, snip) {
+                &snip[1..snip.len() - 1]
+            } else {
+                snip.as_str()
+            }
+        },
+    );
+
+    span_lint_and_sugg(
+        cx,
+        CAST_LOSSLESS,
+        expr.span,
+        &format!(
+            "casting `{}` to `{}` may become silently lossy if you later change the type",
+            cast_from, cast_to
+        ),
+        "try",
+        format!("{}::from({})", cast_to, sugg),
+        applicability,
+    );
+}
+
+fn should_lint(cx: &LateContext<'_>, expr: &Expr<'_>, cast_from: Ty<'_>, cast_to: Ty<'_>) -> bool {
+    // Do not suggest using From in consts/statics until it is valid to do so (see #2267).
+    if in_constant(cx, expr.hir_id) {
+        return false;
+    }
+
+    match (cast_from.is_integral(), cast_to.is_integral()) {
+        (true, true) => {
+            let cast_signed_to_unsigned = cast_from.is_signed() && !cast_to.is_signed();
+            let from_nbits = utils::int_ty_to_nbits(cast_from, cx.tcx);
+            let to_nbits = utils::int_ty_to_nbits(cast_to, cx.tcx);
+            !is_isize_or_usize(cast_from)
+                && !is_isize_or_usize(cast_to)
+                && from_nbits < to_nbits
+                && !cast_signed_to_unsigned
+        },
+
+        (true, false) => {
+            let from_nbits = utils::int_ty_to_nbits(cast_from, cx.tcx);
+            let to_nbits = if let ty::Float(FloatTy::F32) = cast_to.kind() {
+                32
+            } else {
+                64
+            };
+            from_nbits < to_nbits
+        },
+
+        (_, _) => {
+            matches!(cast_from.kind(), ty::Float(FloatTy::F32)) && matches!(cast_to.kind(), ty::Float(FloatTy::F64))
+        },
+    }
+}
+
+fn should_strip_parens(cast_expr: &Expr<'_>, snip: &str) -> bool {
+    if let ExprKind::Binary(_, _, _) = cast_expr.kind {
+        if snip.starts_with('(') && snip.ends_with(')') {
+            return true;
+        }
+    }
+    false
+}
diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index 7eb35aa8290..6c2464e0090 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -1,3 +1,4 @@
+mod cast_lossless;
 mod cast_precision_loss;
 mod utils;
 
@@ -18,9 +19,8 @@ use rustc_target::abi::LayoutOf;
 use crate::consts::{constant, Constant};
 use crate::utils::sugg::Sugg;
 use crate::utils::{
-    in_constant, is_hir_ty_cfg_dependant, is_isize_or_usize, meets_msrv, method_chain_args,
-    numeric_literal::NumericLiteral, sext, snippet_opt, snippet_with_applicability, span_lint, span_lint_and_sugg,
-    span_lint_and_then,
+    is_hir_ty_cfg_dependant, is_isize_or_usize, meets_msrv, method_chain_args, numeric_literal::NumericLiteral, sext,
+    snippet_opt, snippet_with_applicability, span_lint, span_lint_and_sugg, span_lint_and_then,
 };
 
 use utils::int_ty_to_nbits;
@@ -254,52 +254,6 @@ declare_clippy_lint! {
     "casting a function pointer to a numeric type not wide enough to store the address"
 }
 
-fn should_strip_parens(op: &Expr<'_>, snip: &str) -> bool {
-    if let ExprKind::Binary(_, _, _) = op.kind {
-        if snip.starts_with('(') && snip.ends_with(')') {
-            return true;
-        }
-    }
-    false
-}
-
-fn span_lossless_lint(cx: &LateContext<'_>, expr: &Expr<'_>, op: &Expr<'_>, cast_from: Ty<'_>, cast_to: Ty<'_>) {
-    // Do not suggest using From in consts/statics until it is valid to do so (see #2267).
-    if in_constant(cx, expr.hir_id) {
-        return;
-    }
-    // The suggestion is to use a function call, so if the original expression
-    // has parens on the outside, they are no longer needed.
-    let mut applicability = Applicability::MachineApplicable;
-    let opt = snippet_opt(cx, op.span);
-    let sugg = opt.as_ref().map_or_else(
-        || {
-            applicability = Applicability::HasPlaceholders;
-            ".."
-        },
-        |snip| {
-            if should_strip_parens(op, snip) {
-                &snip[1..snip.len() - 1]
-            } else {
-                snip.as_str()
-            }
-        },
-    );
-
-    span_lint_and_sugg(
-        cx,
-        CAST_LOSSLESS,
-        expr.span,
-        &format!(
-            "casting `{}` to `{}` may become silently lossy if you later change the type",
-            cast_from, cast_to
-        ),
-        "try",
-        format!("{}::from({})", cast_to, sugg),
-        applicability,
-    );
-}
-
 enum ArchSuffix {
     _32,
     _64,
@@ -423,16 +377,6 @@ fn check_truncation_and_wrapping(cx: &LateContext<'_>, expr: &Expr<'_>, cast_fro
     }
 }
 
-fn check_lossless(cx: &LateContext<'_>, expr: &Expr<'_>, op: &Expr<'_>, cast_from: Ty<'_>, cast_to: Ty<'_>) {
-    let cast_signed_to_unsigned = cast_from.is_signed() && !cast_to.is_signed();
-    let from_nbits = int_ty_to_nbits(cast_from, cx.tcx);
-    let to_nbits = int_ty_to_nbits(cast_to, cx.tcx);
-    if !is_isize_or_usize(cast_from) && !is_isize_or_usize(cast_to) && from_nbits < to_nbits && !cast_signed_to_unsigned
-    {
-        span_lossless_lint(cx, expr, op, cast_from, cast_to);
-    }
-}
-
 declare_lint_pass!(Casts => [
     CAST_PRECISION_LOSS,
     CAST_SIGN_LOSS,
@@ -584,18 +528,8 @@ fn lint_numeric_casts<'tcx>(
     cast_to: Ty<'tcx>,
 ) {
     cast_precision_loss::check(cx, expr, cast_from, cast_to);
+    cast_lossless::check(cx, expr, cast_expr, cast_from, cast_to);
     match (cast_from.is_integral(), cast_to.is_integral()) {
-        (true, false) => {
-            let from_nbits = int_ty_to_nbits(cast_from, cx.tcx);
-            let to_nbits = if let ty::Float(FloatTy::F32) = cast_to.kind() {
-                32
-            } else {
-                64
-            };
-            if from_nbits < to_nbits {
-                span_lossless_lint(cx, expr, cast_expr, cast_from, cast_to);
-            }
-        },
         (false, true) => {
             span_lint(
                 cx,
@@ -618,7 +552,6 @@ fn lint_numeric_casts<'tcx>(
         (true, true) => {
             check_loss_of_sign(cx, expr, cast_expr, cast_from, cast_to);
             check_truncation_and_wrapping(cx, expr, cast_from, cast_to);
-            check_lossless(cx, expr, cast_expr, cast_from, cast_to);
         },
         (false, false) => {
             if let (&ty::Float(FloatTy::F64), &ty::Float(FloatTy::F32)) = (&cast_from.kind(), &cast_to.kind()) {
@@ -629,10 +562,8 @@ fn lint_numeric_casts<'tcx>(
                     "casting `f64` to `f32` may truncate the value",
                 );
             }
-            if let (&ty::Float(FloatTy::F32), &ty::Float(FloatTy::F64)) = (&cast_from.kind(), &cast_to.kind()) {
-                span_lossless_lint(cx, expr, cast_expr, cast_from, cast_to);
-            }
         },
+        (_, _) => {},
     }
 }
 
-- 
cgit 1.4.1-3-g733a5


From 0534bf4698acc7b302664bb80d9c85be2648fcd8 Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Tue, 9 Mar 2021 12:10:59 +0900
Subject: Move cast_possible_truncation to its own module

---
 clippy_lints/src/casts/cast_possible_truncation.rs | 54 +++++++++++++++
 clippy_lints/src/casts/mod.rs                      | 76 ++++------------------
 2 files changed, 68 insertions(+), 62 deletions(-)
 create mode 100644 clippy_lints/src/casts/cast_possible_truncation.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/cast_possible_truncation.rs b/clippy_lints/src/casts/cast_possible_truncation.rs
new file mode 100644
index 00000000000..33b06b8fe7c
--- /dev/null
+++ b/clippy_lints/src/casts/cast_possible_truncation.rs
@@ -0,0 +1,54 @@
+use rustc_hir::Expr;
+use rustc_lint::LateContext;
+use rustc_middle::ty::{self, FloatTy, Ty};
+
+use crate::utils::{is_isize_or_usize, span_lint};
+
+use super::{utils, CAST_POSSIBLE_TRUNCATION};
+
+pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_from: Ty<'_>, cast_to: Ty<'_>) {
+    let msg = match (cast_from.is_integral(), cast_to.is_integral()) {
+        (true, true) => {
+            let from_nbits = utils::int_ty_to_nbits(cast_from, cx.tcx);
+            let to_nbits = utils::int_ty_to_nbits(cast_to, cx.tcx);
+
+            let (should_lint, suffix) = match (is_isize_or_usize(cast_from), is_isize_or_usize(cast_to)) {
+                (true, true) | (false, false) => (to_nbits < from_nbits, ""),
+                (true, false) => (
+                    to_nbits <= 32,
+                    if to_nbits == 32 {
+                        " on targets with 64-bit wide pointers"
+                    } else {
+                        ""
+                    },
+                ),
+                (false, true) => (from_nbits == 64, " on targets with 32-bit wide pointers"),
+            };
+
+            if !should_lint {
+                return;
+            }
+
+            format!(
+                "casting `{}` to `{}` may truncate the value{}",
+                cast_from, cast_to, suffix,
+            )
+        },
+
+        (false, true) => {
+            format!("casting `{}` to `{}` may truncate the value", cast_from, cast_to)
+        },
+
+        (_, _) => {
+            if matches!(cast_from.kind(), &ty::Float(FloatTy::F64))
+                && matches!(cast_to.kind(), &ty::Float(FloatTy::F32))
+            {
+                "casting `f64` to `f32` may truncate the value".to_string()
+            } else {
+                return;
+            }
+        },
+    };
+
+    span_lint(cx, CAST_POSSIBLE_TRUNCATION, expr.span, &msg);
+}
diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index 6c2464e0090..9b89b076d90 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -1,4 +1,5 @@
 mod cast_lossless;
+mod cast_possible_truncation;
 mod cast_precision_loss;
 mod utils;
 
@@ -312,52 +313,18 @@ fn check_truncation_and_wrapping(cx: &LateContext<'_>, expr: &Expr<'_>, cast_fro
     let cast_unsigned_to_signed = !cast_from.is_signed() && cast_to.is_signed();
     let from_nbits = int_ty_to_nbits(cast_from, cx.tcx);
     let to_nbits = int_ty_to_nbits(cast_to, cx.tcx);
-    let (span_truncation, suffix_truncation, span_wrap, suffix_wrap) =
-        match (is_isize_or_usize(cast_from), is_isize_or_usize(cast_to)) {
-            (true, true) | (false, false) => (
-                to_nbits < from_nbits,
-                ArchSuffix::None,
-                to_nbits == from_nbits && cast_unsigned_to_signed,
-                ArchSuffix::None,
-            ),
-            (true, false) => (
-                to_nbits <= 32,
-                if to_nbits == 32 {
-                    ArchSuffix::_64
-                } else {
-                    ArchSuffix::None
-                },
-                to_nbits <= 32 && cast_unsigned_to_signed,
-                ArchSuffix::_32,
-            ),
-            (false, true) => (
-                from_nbits == 64,
-                ArchSuffix::_32,
-                cast_unsigned_to_signed,
-                if from_nbits == 64 {
-                    ArchSuffix::_64
-                } else {
-                    ArchSuffix::_32
-                },
-            ),
-        };
-    if span_truncation {
-        span_lint(
-            cx,
-            CAST_POSSIBLE_TRUNCATION,
-            expr.span,
-            &format!(
-                "casting `{}` to `{}` may truncate the value{}",
-                cast_from,
-                cast_to,
-                match suffix_truncation {
-                    ArchSuffix::_32 => arch_32_suffix,
-                    ArchSuffix::_64 => arch_64_suffix,
-                    ArchSuffix::None => "",
-                }
-            ),
-        );
-    }
+    let (span_wrap, suffix_wrap) = match (is_isize_or_usize(cast_from), is_isize_or_usize(cast_to)) {
+        (true, true) | (false, false) => (to_nbits == from_nbits && cast_unsigned_to_signed, ArchSuffix::None),
+        (true, false) => (to_nbits <= 32 && cast_unsigned_to_signed, ArchSuffix::_32),
+        (false, true) => (
+            cast_unsigned_to_signed,
+            if from_nbits == 64 {
+                ArchSuffix::_64
+            } else {
+                ArchSuffix::_32
+            },
+        ),
+    };
     if span_wrap {
         span_lint(
             cx,
@@ -529,14 +496,9 @@ fn lint_numeric_casts<'tcx>(
 ) {
     cast_precision_loss::check(cx, expr, cast_from, cast_to);
     cast_lossless::check(cx, expr, cast_expr, cast_from, cast_to);
+    cast_possible_truncation::check(cx, expr, cast_from, cast_to);
     match (cast_from.is_integral(), cast_to.is_integral()) {
         (false, true) => {
-            span_lint(
-                cx,
-                CAST_POSSIBLE_TRUNCATION,
-                expr.span,
-                &format!("casting `{}` to `{}` may truncate the value", cast_from, cast_to),
-            );
             if !cast_to.is_signed() {
                 span_lint(
                     cx,
@@ -553,16 +515,6 @@ fn lint_numeric_casts<'tcx>(
             check_loss_of_sign(cx, expr, cast_expr, cast_from, cast_to);
             check_truncation_and_wrapping(cx, expr, cast_from, cast_to);
         },
-        (false, false) => {
-            if let (&ty::Float(FloatTy::F64), &ty::Float(FloatTy::F32)) = (&cast_from.kind(), &cast_to.kind()) {
-                span_lint(
-                    cx,
-                    CAST_POSSIBLE_TRUNCATION,
-                    expr.span,
-                    "casting `f64` to `f32` may truncate the value",
-                );
-            }
-        },
         (_, _) => {},
     }
 }
-- 
cgit 1.4.1-3-g733a5


From 0975031117fc1de35220f0e16d2294acaab154f8 Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Tue, 9 Mar 2021 12:37:46 +0900
Subject: Move cast_sign_loss to its own module

---
 clippy_lints/src/casts/cast_sign_loss.rs | 70 ++++++++++++++++++++++++++++++
 clippy_lints/src/casts/mod.rs            | 74 ++++----------------------------
 2 files changed, 78 insertions(+), 66 deletions(-)
 create mode 100644 clippy_lints/src/casts/cast_sign_loss.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/cast_sign_loss.rs b/clippy_lints/src/casts/cast_sign_loss.rs
new file mode 100644
index 00000000000..9656fbebd77
--- /dev/null
+++ b/clippy_lints/src/casts/cast_sign_loss.rs
@@ -0,0 +1,70 @@
+use rustc_hir::{Expr, ExprKind};
+use rustc_lint::LateContext;
+use rustc_middle::ty::{self, Ty};
+
+use if_chain::if_chain;
+
+use crate::consts::{constant, Constant};
+use crate::utils::{method_chain_args, sext, span_lint};
+
+use super::CAST_SIGN_LOSS;
+
+pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_op: &Expr<'_>, cast_from: Ty<'_>, cast_to: Ty<'_>) {
+    if should_lint(cx, cast_op, cast_from, cast_to) {
+        span_lint(
+            cx,
+            CAST_SIGN_LOSS,
+            expr.span,
+            &format!(
+                "casting `{}` to `{}` may lose the sign of the value",
+                cast_from, cast_to
+            ),
+        );
+    }
+}
+
+fn should_lint(cx: &LateContext<'_>, cast_op: &Expr<'_>, cast_from: Ty<'_>, cast_to: Ty<'_>) -> bool {
+    match (cast_from.is_integral(), cast_to.is_integral()) {
+        (true, true) => {
+            if !cast_from.is_signed() || cast_to.is_signed() {
+                return false;
+            }
+
+            // Don't lint for positive constants.
+            let const_val = constant(cx, &cx.typeck_results(), cast_op);
+            if_chain! {
+                if let Some((Constant::Int(n), _)) = const_val;
+                if let ty::Int(ity) = *cast_from.kind();
+                if sext(cx.tcx, n, ity) >= 0;
+                then {
+                    return false;
+                }
+            }
+
+            // Don't lint for the result of methods that always return non-negative values.
+            if let ExprKind::MethodCall(ref path, _, _, _) = cast_op.kind {
+                let mut method_name = path.ident.name.as_str();
+                let allowed_methods = ["abs", "checked_abs", "rem_euclid", "checked_rem_euclid"];
+
+                if_chain! {
+                    if method_name == "unwrap";
+                    if let Some(arglist) = method_chain_args(cast_op, &["unwrap"]);
+                    if let ExprKind::MethodCall(ref inner_path, _, _, _) = &arglist[0][0].kind;
+                    then {
+                        method_name = inner_path.ident.name.as_str();
+                    }
+                }
+
+                if allowed_methods.iter().any(|&name| method_name == name) {
+                    return false;
+                }
+            }
+
+            true
+        },
+
+        (false, true) => !cast_to.is_signed(),
+
+        (_, _) => false,
+    }
+}
diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index 9b89b076d90..f390dfdfab7 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -1,6 +1,7 @@
 mod cast_lossless;
 mod cast_possible_truncation;
 mod cast_precision_loss;
+mod cast_sign_loss;
 mod utils;
 
 use std::borrow::Cow;
@@ -17,11 +18,10 @@ use rustc_session::{declare_lint_pass, declare_tool_lint, impl_lint_pass};
 use rustc_span::symbol::sym;
 use rustc_target::abi::LayoutOf;
 
-use crate::consts::{constant, Constant};
 use crate::utils::sugg::Sugg;
 use crate::utils::{
-    is_hir_ty_cfg_dependant, is_isize_or_usize, meets_msrv, method_chain_args, numeric_literal::NumericLiteral, sext,
-    snippet_opt, snippet_with_applicability, span_lint, span_lint_and_sugg, span_lint_and_then,
+    is_hir_ty_cfg_dependant, is_isize_or_usize, meets_msrv, numeric_literal::NumericLiteral, snippet_opt,
+    snippet_with_applicability, span_lint, span_lint_and_sugg, span_lint_and_then,
 };
 
 use utils::int_ty_to_nbits;
@@ -261,52 +261,6 @@ enum ArchSuffix {
     None,
 }
 
-fn check_loss_of_sign(cx: &LateContext<'_>, expr: &Expr<'_>, op: &Expr<'_>, cast_from: Ty<'_>, cast_to: Ty<'_>) {
-    if !cast_from.is_signed() || cast_to.is_signed() {
-        return;
-    }
-
-    // don't lint for positive constants
-    let const_val = constant(cx, &cx.typeck_results(), op);
-    if_chain! {
-        if let Some((Constant::Int(n), _)) = const_val;
-        if let ty::Int(ity) = *cast_from.kind();
-        if sext(cx.tcx, n, ity) >= 0;
-        then {
-            return
-        }
-    }
-
-    // don't lint for the result of methods that always return non-negative values
-    if let ExprKind::MethodCall(ref path, _, _, _) = op.kind {
-        let mut method_name = path.ident.name.as_str();
-        let allowed_methods = ["abs", "checked_abs", "rem_euclid", "checked_rem_euclid"];
-
-        if_chain! {
-            if method_name == "unwrap";
-            if let Some(arglist) = method_chain_args(op, &["unwrap"]);
-            if let ExprKind::MethodCall(ref inner_path, _, _, _) = &arglist[0][0].kind;
-            then {
-                method_name = inner_path.ident.name.as_str();
-            }
-        }
-
-        if allowed_methods.iter().any(|&name| method_name == name) {
-            return;
-        }
-    }
-
-    span_lint(
-        cx,
-        CAST_SIGN_LOSS,
-        expr.span,
-        &format!(
-            "casting `{}` to `{}` may lose the sign of the value",
-            cast_from, cast_to
-        ),
-    );
-}
-
 fn check_truncation_and_wrapping(cx: &LateContext<'_>, expr: &Expr<'_>, cast_from: Ty<'_>, cast_to: Ty<'_>) {
     let arch_64_suffix = " on targets with 64-bit wide pointers";
     let arch_32_suffix = " on targets with 32-bit wide pointers";
@@ -490,29 +444,17 @@ fn show_unnecessary_cast(cx: &LateContext<'_>, expr: &Expr<'_>, literal_str: &st
 fn lint_numeric_casts<'tcx>(
     cx: &LateContext<'tcx>,
     expr: &Expr<'tcx>,
-    cast_expr: &Expr<'_>,
+    cast_op: &Expr<'_>,
     cast_from: Ty<'tcx>,
     cast_to: Ty<'tcx>,
 ) {
-    cast_precision_loss::check(cx, expr, cast_from, cast_to);
-    cast_lossless::check(cx, expr, cast_expr, cast_from, cast_to);
     cast_possible_truncation::check(cx, expr, cast_from, cast_to);
+    cast_precision_loss::check(cx, expr, cast_from, cast_to);
+    cast_lossless::check(cx, expr, cast_op, cast_from, cast_to);
+    cast_sign_loss::check(cx, expr, cast_op, cast_from, cast_to);
+
     match (cast_from.is_integral(), cast_to.is_integral()) {
-        (false, true) => {
-            if !cast_to.is_signed() {
-                span_lint(
-                    cx,
-                    CAST_SIGN_LOSS,
-                    expr.span,
-                    &format!(
-                        "casting `{}` to `{}` may lose the sign of the value",
-                        cast_from, cast_to
-                    ),
-                );
-            }
-        },
         (true, true) => {
-            check_loss_of_sign(cx, expr, cast_expr, cast_from, cast_to);
             check_truncation_and_wrapping(cx, expr, cast_from, cast_to);
         },
         (_, _) => {},
-- 
cgit 1.4.1-3-g733a5


From a383e034dc2f3d9cb53bd7164447fe7f3bfbf08c Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Tue, 9 Mar 2021 16:11:46 +0900
Subject: Move cast_possible_wrap to its own module

---
 clippy_lints/src/casts/cast_possible_wrap.rs | 44 ++++++++++++++++++++++
 clippy_lints/src/casts/mod.rs                | 56 ++--------------------------
 2 files changed, 48 insertions(+), 52 deletions(-)
 create mode 100644 clippy_lints/src/casts/cast_possible_wrap.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/cast_possible_wrap.rs b/clippy_lints/src/casts/cast_possible_wrap.rs
new file mode 100644
index 00000000000..56d301ed3e1
--- /dev/null
+++ b/clippy_lints/src/casts/cast_possible_wrap.rs
@@ -0,0 +1,44 @@
+use rustc_hir::Expr;
+use rustc_lint::LateContext;
+use rustc_middle::ty::Ty;
+
+use crate::utils::{is_isize_or_usize, span_lint};
+
+use super::{utils, CAST_POSSIBLE_WRAP};
+
+pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_from: Ty<'_>, cast_to: Ty<'_>) {
+    if !(cast_from.is_integral() && cast_to.is_integral()) {
+        return;
+    }
+
+    let arch_64_suffix = " on targets with 64-bit wide pointers";
+    let arch_32_suffix = " on targets with 32-bit wide pointers";
+    let cast_unsigned_to_signed = !cast_from.is_signed() && cast_to.is_signed();
+    let from_nbits = utils::int_ty_to_nbits(cast_from, cx.tcx);
+    let to_nbits = utils::int_ty_to_nbits(cast_to, cx.tcx);
+
+    let (should_lint, suffix) = match (is_isize_or_usize(cast_from), is_isize_or_usize(cast_to)) {
+        (true, true) | (false, false) => (to_nbits == from_nbits && cast_unsigned_to_signed, ""),
+        (true, false) => (to_nbits <= 32 && cast_unsigned_to_signed, arch_32_suffix),
+        (false, true) => (
+            cast_unsigned_to_signed,
+            if from_nbits == 64 {
+                arch_64_suffix
+            } else {
+                arch_32_suffix
+            },
+        ),
+    };
+
+    if should_lint {
+        span_lint(
+            cx,
+            CAST_POSSIBLE_WRAP,
+            expr.span,
+            &format!(
+                "casting `{}` to `{}` may wrap around the value{}",
+                cast_from, cast_to, suffix,
+            ),
+        );
+    }
+}
diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index f390dfdfab7..01528a5a16a 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -1,5 +1,6 @@
 mod cast_lossless;
 mod cast_possible_truncation;
+mod cast_possible_wrap;
 mod cast_precision_loss;
 mod cast_sign_loss;
 mod utils;
@@ -20,8 +21,8 @@ use rustc_target::abi::LayoutOf;
 
 use crate::utils::sugg::Sugg;
 use crate::utils::{
-    is_hir_ty_cfg_dependant, is_isize_or_usize, meets_msrv, numeric_literal::NumericLiteral, snippet_opt,
-    snippet_with_applicability, span_lint, span_lint_and_sugg, span_lint_and_then,
+    is_hir_ty_cfg_dependant, meets_msrv, numeric_literal::NumericLiteral, snippet_opt, snippet_with_applicability,
+    span_lint, span_lint_and_sugg, span_lint_and_then,
 };
 
 use utils::int_ty_to_nbits;
@@ -255,49 +256,6 @@ declare_clippy_lint! {
     "casting a function pointer to a numeric type not wide enough to store the address"
 }
 
-enum ArchSuffix {
-    _32,
-    _64,
-    None,
-}
-
-fn check_truncation_and_wrapping(cx: &LateContext<'_>, expr: &Expr<'_>, cast_from: Ty<'_>, cast_to: Ty<'_>) {
-    let arch_64_suffix = " on targets with 64-bit wide pointers";
-    let arch_32_suffix = " on targets with 32-bit wide pointers";
-    let cast_unsigned_to_signed = !cast_from.is_signed() && cast_to.is_signed();
-    let from_nbits = int_ty_to_nbits(cast_from, cx.tcx);
-    let to_nbits = int_ty_to_nbits(cast_to, cx.tcx);
-    let (span_wrap, suffix_wrap) = match (is_isize_or_usize(cast_from), is_isize_or_usize(cast_to)) {
-        (true, true) | (false, false) => (to_nbits == from_nbits && cast_unsigned_to_signed, ArchSuffix::None),
-        (true, false) => (to_nbits <= 32 && cast_unsigned_to_signed, ArchSuffix::_32),
-        (false, true) => (
-            cast_unsigned_to_signed,
-            if from_nbits == 64 {
-                ArchSuffix::_64
-            } else {
-                ArchSuffix::_32
-            },
-        ),
-    };
-    if span_wrap {
-        span_lint(
-            cx,
-            CAST_POSSIBLE_WRAP,
-            expr.span,
-            &format!(
-                "casting `{}` to `{}` may wrap around the value{}",
-                cast_from,
-                cast_to,
-                match suffix_wrap {
-                    ArchSuffix::_32 => arch_32_suffix,
-                    ArchSuffix::_64 => arch_64_suffix,
-                    ArchSuffix::None => "",
-                }
-            ),
-        );
-    }
-}
-
 declare_lint_pass!(Casts => [
     CAST_PRECISION_LOSS,
     CAST_SIGN_LOSS,
@@ -449,16 +407,10 @@ fn lint_numeric_casts<'tcx>(
     cast_to: Ty<'tcx>,
 ) {
     cast_possible_truncation::check(cx, expr, cast_from, cast_to);
+    cast_possible_wrap::check(cx, expr, cast_from, cast_to);
     cast_precision_loss::check(cx, expr, cast_from, cast_to);
     cast_lossless::check(cx, expr, cast_op, cast_from, cast_to);
     cast_sign_loss::check(cx, expr, cast_op, cast_from, cast_to);
-
-    match (cast_from.is_integral(), cast_to.is_integral()) {
-        (true, true) => {
-            check_truncation_and_wrapping(cx, expr, cast_from, cast_to);
-        },
-        (_, _) => {},
-    }
 }
 
 fn lint_cast_ptr_alignment<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, cast_from: Ty<'tcx>, cast_to: Ty<'tcx>) {
-- 
cgit 1.4.1-3-g733a5


From 9709993e412dd3400aec27d4fefae0cbf1f702aa Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Tue, 9 Mar 2021 16:43:10 +0900
Subject: Move unnecessary_cast to its own module

---
 clippy_lints/src/casts/mod.rs              | 120 ++++++-----------------------
 clippy_lints/src/casts/unnecessary_cast.rs | 106 +++++++++++++++++++++++++
 2 files changed, 128 insertions(+), 98 deletions(-)
 create mode 100644 clippy_lints/src/casts/unnecessary_cast.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index 01528a5a16a..d8c74436501 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -3,17 +3,18 @@ mod cast_possible_truncation;
 mod cast_possible_wrap;
 mod cast_precision_loss;
 mod cast_sign_loss;
+mod unnecessary_cast;
 mod utils;
 
 use std::borrow::Cow;
 
 use if_chain::if_chain;
-use rustc_ast::{LitFloatType, LitIntType, LitKind};
+use rustc_ast::LitKind;
 use rustc_errors::Applicability;
-use rustc_hir::{Expr, ExprKind, GenericArg, Lit, MutTy, Mutability, TyKind, UnOp};
+use rustc_hir::{Expr, ExprKind, GenericArg, MutTy, Mutability, TyKind, UnOp};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_middle::ty::{self, FloatTy, InferTy, Ty, TypeAndMut, UintTy};
+use rustc_middle::ty::{self, Ty, TypeAndMut, UintTy};
 use rustc_semver::RustcVersion;
 use rustc_session::{declare_lint_pass, declare_tool_lint, impl_lint_pass};
 use rustc_span::symbol::sym;
@@ -21,8 +22,7 @@ use rustc_target::abi::LayoutOf;
 
 use crate::utils::sugg::Sugg;
 use crate::utils::{
-    is_hir_ty_cfg_dependant, meets_msrv, numeric_literal::NumericLiteral, snippet_opt, snippet_with_applicability,
-    span_lint, span_lint_and_sugg, span_lint_and_then,
+    is_hir_ty_cfg_dependant, meets_msrv, snippet_with_applicability, span_lint, span_lint_and_sugg, span_lint_and_then,
 };
 
 use utils::int_ty_to_nbits;
@@ -284,72 +284,25 @@ fn is_c_void(cx: &LateContext<'_>, ty: Ty<'_>) -> bool {
     false
 }
 
-/// Returns the mantissa bits wide of a fp type.
-/// Will return 0 if the type is not a fp
-fn fp_ty_mantissa_nbits(typ: Ty<'_>) -> u32 {
-    match typ.kind() {
-        ty::Float(FloatTy::F32) => 23,
-        ty::Float(FloatTy::F64) | ty::Infer(InferTy::FloatVar(_)) => 52,
-        _ => 0,
-    }
-}
-
 impl<'tcx> LateLintPass<'tcx> for Casts {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if expr.span.from_expansion() {
             return;
         }
-        if let ExprKind::Cast(ref ex, cast_to) = expr.kind {
+        if let ExprKind::Cast(ref cast_expr, cast_to) = expr.kind {
             if is_hir_ty_cfg_dependant(cx, cast_to) {
                 return;
             }
-            let (cast_from, cast_to) = (cx.typeck_results().expr_ty(ex), cx.typeck_results().expr_ty(expr));
-            lint_fn_to_numeric_cast(cx, expr, ex, cast_from, cast_to);
-            if let Some(lit) = get_numeric_literal(ex) {
-                let literal_str = snippet_opt(cx, ex.span).unwrap_or_default();
-
-                if_chain! {
-                    if let LitKind::Int(n, _) = lit.node;
-                    if let Some(src) = snippet_opt(cx, lit.span);
-                    if cast_to.is_floating_point();
-                    if let Some(num_lit) = NumericLiteral::from_lit_kind(&src, &lit.node);
-                    let from_nbits = 128 - n.leading_zeros();
-                    let to_nbits = fp_ty_mantissa_nbits(cast_to);
-                    if from_nbits != 0 && to_nbits != 0 && from_nbits <= to_nbits && num_lit.is_decimal();
-                    then {
-                        let literal_str = if is_unary_neg(ex) { format!("-{}", num_lit.integer) } else { num_lit.integer.into() };
-                        show_unnecessary_cast(cx, expr, &literal_str, cast_from, cast_to);
-                        return;
-                    }
-                }
-
-                match lit.node {
-                    LitKind::Int(_, LitIntType::Unsuffixed) if cast_to.is_integral() => {
-                        show_unnecessary_cast(cx, expr, &literal_str, cast_from, cast_to);
-                    },
-                    LitKind::Float(_, LitFloatType::Unsuffixed) if cast_to.is_floating_point() => {
-                        show_unnecessary_cast(cx, expr, &literal_str, cast_from, cast_to);
-                    },
-                    LitKind::Int(_, LitIntType::Unsuffixed) | LitKind::Float(_, LitFloatType::Unsuffixed) => {},
-                    _ => {
-                        if cast_from.kind() == cast_to.kind() && !in_external_macro(cx.sess(), expr.span) {
-                            span_lint(
-                                cx,
-                                UNNECESSARY_CAST,
-                                expr.span,
-                                &format!(
-                                    "casting to the same type is unnecessary (`{}` -> `{}`)",
-                                    cast_from, cast_to
-                                ),
-                            );
-                        }
-                    },
-                }
-            }
-            if cast_from.is_numeric() && cast_to.is_numeric() && !in_external_macro(cx.sess(), expr.span) {
-                lint_numeric_casts(cx, expr, ex, cast_from, cast_to);
-            }
+            let (cast_from, cast_to) = (
+                cx.typeck_results().expr_ty(cast_expr),
+                cx.typeck_results().expr_ty(expr),
+            );
 
+            if unnecessary_cast::check(cx, expr, cast_expr, cast_from, cast_to) {
+                return;
+            }
+            lint_fn_to_numeric_cast(cx, expr, cast_expr, cast_from, cast_to);
+            lint_numeric_casts(cx, expr, cast_expr, cast_from, cast_to);
             lint_cast_ptr_alignment(cx, expr, cast_from, cast_to);
         } else if let ExprKind::MethodCall(method_path, _, args, _) = expr.kind {
             if_chain! {
@@ -368,37 +321,6 @@ impl<'tcx> LateLintPass<'tcx> for Casts {
     }
 }
 
-fn is_unary_neg(expr: &Expr<'_>) -> bool {
-    matches!(expr.kind, ExprKind::Unary(UnOp::Neg, _))
-}
-
-fn get_numeric_literal<'e>(expr: &'e Expr<'e>) -> Option<&'e Lit> {
-    match expr.kind {
-        ExprKind::Lit(ref lit) => Some(lit),
-        ExprKind::Unary(UnOp::Neg, e) => {
-            if let ExprKind::Lit(ref lit) = e.kind {
-                Some(lit)
-            } else {
-                None
-            }
-        },
-        _ => None,
-    }
-}
-
-fn show_unnecessary_cast(cx: &LateContext<'_>, expr: &Expr<'_>, literal_str: &str, cast_from: Ty<'_>, cast_to: Ty<'_>) {
-    let literal_kind_name = if cast_from.is_integral() { "integer" } else { "float" };
-    span_lint_and_sugg(
-        cx,
-        UNNECESSARY_CAST,
-        expr.span,
-        &format!("casting {} literal to `{}` is unnecessary", literal_kind_name, cast_to),
-        "try",
-        format!("{}_{}", literal_str.trim_end_matches('.'), cast_to),
-        Applicability::MachineApplicable,
-    );
-}
-
 fn lint_numeric_casts<'tcx>(
     cx: &LateContext<'tcx>,
     expr: &Expr<'tcx>,
@@ -406,11 +328,13 @@ fn lint_numeric_casts<'tcx>(
     cast_from: Ty<'tcx>,
     cast_to: Ty<'tcx>,
 ) {
-    cast_possible_truncation::check(cx, expr, cast_from, cast_to);
-    cast_possible_wrap::check(cx, expr, cast_from, cast_to);
-    cast_precision_loss::check(cx, expr, cast_from, cast_to);
-    cast_lossless::check(cx, expr, cast_op, cast_from, cast_to);
-    cast_sign_loss::check(cx, expr, cast_op, cast_from, cast_to);
+    if cast_from.is_numeric() && cast_to.is_numeric() && !in_external_macro(cx.sess(), expr.span) {
+        cast_possible_truncation::check(cx, expr, cast_from, cast_to);
+        cast_possible_wrap::check(cx, expr, cast_from, cast_to);
+        cast_precision_loss::check(cx, expr, cast_from, cast_to);
+        cast_lossless::check(cx, expr, cast_op, cast_from, cast_to);
+        cast_sign_loss::check(cx, expr, cast_op, cast_from, cast_to);
+    }
 }
 
 fn lint_cast_ptr_alignment<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, cast_from: Ty<'tcx>, cast_to: Ty<'tcx>) {
diff --git a/clippy_lints/src/casts/unnecessary_cast.rs b/clippy_lints/src/casts/unnecessary_cast.rs
new file mode 100644
index 00000000000..fa2a07ef1da
--- /dev/null
+++ b/clippy_lints/src/casts/unnecessary_cast.rs
@@ -0,0 +1,106 @@
+use rustc_ast::{LitFloatType, LitIntType, LitKind};
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind, Lit, UnOp};
+use rustc_lint::{LateContext, LintContext};
+use rustc_middle::lint::in_external_macro;
+use rustc_middle::ty::{self, FloatTy, InferTy, Ty};
+
+use if_chain::if_chain;
+
+use crate::utils::{numeric_literal::NumericLiteral, snippet_opt, span_lint, span_lint_and_sugg};
+
+use super::UNNECESSARY_CAST;
+
+pub(super) fn check(
+    cx: &LateContext<'_>,
+    expr: &Expr<'_>,
+    cast_expr: &Expr<'_>,
+    cast_from: Ty<'_>,
+    cast_to: Ty<'_>,
+) -> bool {
+    if let Some(lit) = get_numeric_literal(cast_expr) {
+        let literal_str = snippet_opt(cx, cast_expr.span).unwrap_or_default();
+
+        if_chain! {
+            if let LitKind::Int(n, _) = lit.node;
+            if let Some(src) = snippet_opt(cx, lit.span);
+            if cast_to.is_floating_point();
+            if let Some(num_lit) = NumericLiteral::from_lit_kind(&src, &lit.node);
+            let from_nbits = 128 - n.leading_zeros();
+            let to_nbits = fp_ty_mantissa_nbits(cast_to);
+            if from_nbits != 0 && to_nbits != 0 && from_nbits <= to_nbits && num_lit.is_decimal();
+            then {
+                let literal_str = if is_unary_neg(cast_expr) { format!("-{}", num_lit.integer) } else { num_lit.integer.into() };
+                lint_unnecessary_cast(cx, expr, &literal_str, cast_from, cast_to);
+                return true
+            }
+        }
+
+        match lit.node {
+            LitKind::Int(_, LitIntType::Unsuffixed) if cast_to.is_integral() => {
+                lint_unnecessary_cast(cx, expr, &literal_str, cast_from, cast_to);
+            },
+            LitKind::Float(_, LitFloatType::Unsuffixed) if cast_to.is_floating_point() => {
+                lint_unnecessary_cast(cx, expr, &literal_str, cast_from, cast_to);
+            },
+            LitKind::Int(_, LitIntType::Unsuffixed) | LitKind::Float(_, LitFloatType::Unsuffixed) => {},
+            _ => {
+                if cast_from.kind() == cast_to.kind() && !in_external_macro(cx.sess(), expr.span) {
+                    span_lint(
+                        cx,
+                        UNNECESSARY_CAST,
+                        expr.span,
+                        &format!(
+                            "casting to the same type is unnecessary (`{}` -> `{}`)",
+                            cast_from, cast_to
+                        ),
+                    );
+                    return true;
+                }
+            },
+        }
+    }
+
+    false
+}
+
+fn lint_unnecessary_cast(cx: &LateContext<'_>, expr: &Expr<'_>, literal_str: &str, cast_from: Ty<'_>, cast_to: Ty<'_>) {
+    let literal_kind_name = if cast_from.is_integral() { "integer" } else { "float" };
+    span_lint_and_sugg(
+        cx,
+        UNNECESSARY_CAST,
+        expr.span,
+        &format!("casting {} literal to `{}` is unnecessary", literal_kind_name, cast_to),
+        "try",
+        format!("{}_{}", literal_str.trim_end_matches('.'), cast_to),
+        Applicability::MachineApplicable,
+    );
+}
+
+fn get_numeric_literal<'e>(expr: &'e Expr<'e>) -> Option<&'e Lit> {
+    match expr.kind {
+        ExprKind::Lit(ref lit) => Some(lit),
+        ExprKind::Unary(UnOp::Neg, e) => {
+            if let ExprKind::Lit(ref lit) = e.kind {
+                Some(lit)
+            } else {
+                None
+            }
+        },
+        _ => None,
+    }
+}
+
+/// Returns the mantissa bits wide of a fp type.
+/// Will return 0 if the type is not a fp
+fn fp_ty_mantissa_nbits(typ: Ty<'_>) -> u32 {
+    match typ.kind() {
+        ty::Float(FloatTy::F32) => 23,
+        ty::Float(FloatTy::F64) | ty::Infer(InferTy::FloatVar(_)) => 52,
+        _ => 0,
+    }
+}
+
+fn is_unary_neg(expr: &Expr<'_>) -> bool {
+    matches!(expr.kind, ExprKind::Unary(UnOp::Neg, _))
+}
-- 
cgit 1.4.1-3-g733a5


From 0dce9921fd6a1e55430c56e5ccf0faf0f1e23491 Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Tue, 9 Mar 2021 16:47:46 +0900
Subject: Remove 'lint_numeric_casts'

---
 clippy_lints/src/casts/mod.rs | 24 +++++++-----------------
 1 file changed, 7 insertions(+), 17 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index d8c74436501..c7e9066f3ea 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -302,8 +302,14 @@ impl<'tcx> LateLintPass<'tcx> for Casts {
                 return;
             }
             lint_fn_to_numeric_cast(cx, expr, cast_expr, cast_from, cast_to);
-            lint_numeric_casts(cx, expr, cast_expr, cast_from, cast_to);
             lint_cast_ptr_alignment(cx, expr, cast_from, cast_to);
+            if cast_from.is_numeric() && cast_to.is_numeric() && !in_external_macro(cx.sess(), expr.span) {
+                cast_possible_truncation::check(cx, expr, cast_from, cast_to);
+                cast_possible_wrap::check(cx, expr, cast_from, cast_to);
+                cast_precision_loss::check(cx, expr, cast_from, cast_to);
+                cast_lossless::check(cx, expr, cast_expr, cast_from, cast_to);
+                cast_sign_loss::check(cx, expr, cast_expr, cast_from, cast_to);
+            }
         } else if let ExprKind::MethodCall(method_path, _, args, _) = expr.kind {
             if_chain! {
             if method_path.ident.name == sym!(cast);
@@ -321,22 +327,6 @@ impl<'tcx> LateLintPass<'tcx> for Casts {
     }
 }
 
-fn lint_numeric_casts<'tcx>(
-    cx: &LateContext<'tcx>,
-    expr: &Expr<'tcx>,
-    cast_op: &Expr<'_>,
-    cast_from: Ty<'tcx>,
-    cast_to: Ty<'tcx>,
-) {
-    if cast_from.is_numeric() && cast_to.is_numeric() && !in_external_macro(cx.sess(), expr.span) {
-        cast_possible_truncation::check(cx, expr, cast_from, cast_to);
-        cast_possible_wrap::check(cx, expr, cast_from, cast_to);
-        cast_precision_loss::check(cx, expr, cast_from, cast_to);
-        cast_lossless::check(cx, expr, cast_op, cast_from, cast_to);
-        cast_sign_loss::check(cx, expr, cast_op, cast_from, cast_to);
-    }
-}
-
 fn lint_cast_ptr_alignment<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, cast_from: Ty<'tcx>, cast_to: Ty<'tcx>) {
     if_chain! {
         if let ty::RawPtr(from_ptr_ty) = &cast_from.kind();
-- 
cgit 1.4.1-3-g733a5


From 458f6d19d0c51ee97b7ac90ce60994f627983824 Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Tue, 9 Mar 2021 17:03:07 +0900
Subject: Move fn_to_numeric_cast to its own module

---
 clippy_lints/src/casts/fn_to_numeric_cast.rs | 37 ++++++++++++++++++++++++++++
 clippy_lints/src/casts/mod.rs                | 13 +++-------
 2 files changed, 40 insertions(+), 10 deletions(-)
 create mode 100644 clippy_lints/src/casts/fn_to_numeric_cast.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/fn_to_numeric_cast.rs b/clippy_lints/src/casts/fn_to_numeric_cast.rs
new file mode 100644
index 00000000000..a8d508585b5
--- /dev/null
+++ b/clippy_lints/src/casts/fn_to_numeric_cast.rs
@@ -0,0 +1,37 @@
+use rustc_errors::Applicability;
+use rustc_hir::Expr;
+use rustc_lint::LateContext;
+use rustc_middle::ty::{self, Ty, UintTy};
+
+use crate::utils::{snippet_with_applicability, span_lint_and_sugg};
+
+use super::{utils, FN_TO_NUMERIC_CAST};
+
+pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_expr: &Expr<'_>, cast_from: Ty<'_>, cast_to: Ty<'_>) {
+    // We only want to check casts to `ty::Uint` or `ty::Int`
+    match cast_to.kind() {
+        ty::Uint(_) | ty::Int(..) => { /* continue on */ },
+        _ => return,
+    }
+
+    match cast_from.kind() {
+        ty::FnDef(..) | ty::FnPtr(_) => {
+            let mut applicability = Applicability::MaybeIncorrect;
+            let from_snippet = snippet_with_applicability(cx, cast_expr.span, "x", &mut applicability);
+            let to_nbits = utils::int_ty_to_nbits(cast_to, cx.tcx);
+
+            if (to_nbits >= cx.tcx.data_layout.pointer_size.bits()) && (*cast_to.kind() != ty::Uint(UintTy::Usize)) {
+                span_lint_and_sugg(
+                    cx,
+                    FN_TO_NUMERIC_CAST,
+                    expr.span,
+                    &format!("casting function pointer `{}` to `{}`", from_snippet, cast_to),
+                    "try",
+                    format!("{} as usize", from_snippet),
+                    applicability,
+                );
+            }
+        },
+        _ => {},
+    }
+}
diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index c7e9066f3ea..bbe492be72e 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -3,6 +3,7 @@ mod cast_possible_truncation;
 mod cast_possible_wrap;
 mod cast_precision_loss;
 mod cast_sign_loss;
+mod fn_to_numeric_cast;
 mod unnecessary_cast;
 mod utils;
 
@@ -301,6 +302,8 @@ impl<'tcx> LateLintPass<'tcx> for Casts {
             if unnecessary_cast::check(cx, expr, cast_expr, cast_from, cast_to) {
                 return;
             }
+
+            fn_to_numeric_cast::check(cx, expr, cast_expr, cast_from, cast_to);
             lint_fn_to_numeric_cast(cx, expr, cast_expr, cast_from, cast_to);
             lint_cast_ptr_alignment(cx, expr, cast_from, cast_to);
             if cast_from.is_numeric() && cast_to.is_numeric() && !in_external_macro(cx.sess(), expr.span) {
@@ -386,16 +389,6 @@ fn lint_fn_to_numeric_cast(
                     format!("{} as usize", from_snippet),
                     applicability,
                 );
-            } else if *cast_to.kind() != ty::Uint(UintTy::Usize) {
-                span_lint_and_sugg(
-                    cx,
-                    FN_TO_NUMERIC_CAST,
-                    expr.span,
-                    &format!("casting function pointer `{}` to `{}`", from_snippet, cast_to),
-                    "try",
-                    format!("{} as usize", from_snippet),
-                    applicability,
-                );
             }
         },
         _ => {},
-- 
cgit 1.4.1-3-g733a5


From 9a24877e2cd68f22edd3de4a44f59c9899953f91 Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Tue, 9 Mar 2021 17:06:25 +0900
Subject: Move fn_to_numeric_cast_with_truncation to its own module

---
 .../casts/fn_to_numeric_cast_with_truncation.rs    | 39 +++++++++++++++++++++
 clippy_lints/src/casts/mod.rs                      | 40 ++--------------------
 2 files changed, 41 insertions(+), 38 deletions(-)
 create mode 100644 clippy_lints/src/casts/fn_to_numeric_cast_with_truncation.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/fn_to_numeric_cast_with_truncation.rs b/clippy_lints/src/casts/fn_to_numeric_cast_with_truncation.rs
new file mode 100644
index 00000000000..0085c7b27b2
--- /dev/null
+++ b/clippy_lints/src/casts/fn_to_numeric_cast_with_truncation.rs
@@ -0,0 +1,39 @@
+use rustc_errors::Applicability;
+use rustc_hir::Expr;
+use rustc_lint::LateContext;
+use rustc_middle::ty::{self, Ty};
+
+use crate::utils::{snippet_with_applicability, span_lint_and_sugg};
+
+use super::{utils, FN_TO_NUMERIC_CAST_WITH_TRUNCATION};
+
+pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_expr: &Expr<'_>, cast_from: Ty<'_>, cast_to: Ty<'_>) {
+    // We only want to check casts to `ty::Uint` or `ty::Int`
+    match cast_to.kind() {
+        ty::Uint(_) | ty::Int(..) => { /* continue on */ },
+        _ => return,
+    }
+    match cast_from.kind() {
+        ty::FnDef(..) | ty::FnPtr(_) => {
+            let mut applicability = Applicability::MaybeIncorrect;
+            let from_snippet = snippet_with_applicability(cx, cast_expr.span, "x", &mut applicability);
+
+            let to_nbits = utils::int_ty_to_nbits(cast_to, cx.tcx);
+            if to_nbits < cx.tcx.data_layout.pointer_size.bits() {
+                span_lint_and_sugg(
+                    cx,
+                    FN_TO_NUMERIC_CAST_WITH_TRUNCATION,
+                    expr.span,
+                    &format!(
+                        "casting function pointer `{}` to `{}`, which truncates the value",
+                        from_snippet, cast_to
+                    ),
+                    "try",
+                    format!("{} as usize", from_snippet),
+                    applicability,
+                );
+            }
+        },
+        _ => {},
+    }
+}
diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index bbe492be72e..a80de01cfaf 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -4,6 +4,7 @@ mod cast_possible_wrap;
 mod cast_precision_loss;
 mod cast_sign_loss;
 mod fn_to_numeric_cast;
+mod fn_to_numeric_cast_with_truncation;
 mod unnecessary_cast;
 mod utils;
 
@@ -304,7 +305,7 @@ impl<'tcx> LateLintPass<'tcx> for Casts {
             }
 
             fn_to_numeric_cast::check(cx, expr, cast_expr, cast_from, cast_to);
-            lint_fn_to_numeric_cast(cx, expr, cast_expr, cast_from, cast_to);
+            fn_to_numeric_cast_with_truncation::check(cx, expr, cast_expr, cast_from, cast_to);
             lint_cast_ptr_alignment(cx, expr, cast_from, cast_to);
             if cast_from.is_numeric() && cast_to.is_numeric() && !in_external_macro(cx.sess(), expr.span) {
                 cast_possible_truncation::check(cx, expr, cast_from, cast_to);
@@ -358,43 +359,6 @@ fn lint_cast_ptr_alignment<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, cast_f
     }
 }
 
-fn lint_fn_to_numeric_cast(
-    cx: &LateContext<'_>,
-    expr: &Expr<'_>,
-    cast_expr: &Expr<'_>,
-    cast_from: Ty<'_>,
-    cast_to: Ty<'_>,
-) {
-    // We only want to check casts to `ty::Uint` or `ty::Int`
-    match cast_to.kind() {
-        ty::Uint(_) | ty::Int(..) => { /* continue on */ },
-        _ => return,
-    }
-    match cast_from.kind() {
-        ty::FnDef(..) | ty::FnPtr(_) => {
-            let mut applicability = Applicability::MaybeIncorrect;
-            let from_snippet = snippet_with_applicability(cx, cast_expr.span, "x", &mut applicability);
-
-            let to_nbits = int_ty_to_nbits(cast_to, cx.tcx);
-            if to_nbits < cx.tcx.data_layout.pointer_size.bits() {
-                span_lint_and_sugg(
-                    cx,
-                    FN_TO_NUMERIC_CAST_WITH_TRUNCATION,
-                    expr.span,
-                    &format!(
-                        "casting function pointer `{}` to `{}`, which truncates the value",
-                        from_snippet, cast_to
-                    ),
-                    "try",
-                    format!("{} as usize", from_snippet),
-                    applicability,
-                );
-            }
-        },
-        _ => {},
-    }
-}
-
 declare_clippy_lint! {
     /// **What it does:** Checks for casts of `&T` to `&mut T` anywhere in the code.
     ///
-- 
cgit 1.4.1-3-g733a5


From ebd1ec0e40739d8b968c2b9bfd249485cec866ab Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Tue, 9 Mar 2021 17:15:18 +0900
Subject: Move cast_ptr_alignment to its own module

---
 clippy_lints/src/casts/cast_ptr_alignment.rs | 81 ++++++++++++++++++++++++++++
 clippy_lints/src/casts/mod.rs                | 67 ++---------------------
 2 files changed, 85 insertions(+), 63 deletions(-)
 create mode 100644 clippy_lints/src/casts/cast_ptr_alignment.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/cast_ptr_alignment.rs b/clippy_lints/src/casts/cast_ptr_alignment.rs
new file mode 100644
index 00000000000..87fb5557be0
--- /dev/null
+++ b/clippy_lints/src/casts/cast_ptr_alignment.rs
@@ -0,0 +1,81 @@
+use rustc_hir::{Expr, ExprKind, GenericArg};
+use rustc_lint::LateContext;
+use rustc_middle::ty::{self, Ty};
+use rustc_span::symbol::sym;
+use rustc_target::abi::LayoutOf;
+
+use if_chain::if_chain;
+
+use crate::utils::{is_hir_ty_cfg_dependant, span_lint};
+
+use super::CAST_PTR_ALIGNMENT;
+
+pub(super) fn check(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+    if let ExprKind::Cast(ref cast_expr, cast_to) = expr.kind {
+        if is_hir_ty_cfg_dependant(cx, cast_to) {
+            return;
+        }
+        let (cast_from, cast_to) = (
+            cx.typeck_results().expr_ty(cast_expr),
+            cx.typeck_results().expr_ty(expr),
+        );
+        lint_cast_ptr_alignment(cx, expr, cast_from, cast_to);
+    } else if let ExprKind::MethodCall(method_path, _, args, _) = expr.kind {
+        if_chain! {
+            if method_path.ident.name == sym!(cast);
+            if let Some(generic_args) = method_path.args;
+            if let [GenericArg::Type(cast_to)] = generic_args.args;
+            // There probably is no obvious reason to do this, just to be consistent with `as` cases.
+            if !is_hir_ty_cfg_dependant(cx, cast_to);
+            then {
+                let (cast_from, cast_to) =
+                    (cx.typeck_results().expr_ty(&args[0]), cx.typeck_results().expr_ty(expr));
+                lint_cast_ptr_alignment(cx, expr, cast_from, cast_to);
+            }
+        }
+    }
+}
+
+fn lint_cast_ptr_alignment<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, cast_from: Ty<'tcx>, cast_to: Ty<'tcx>) {
+    if_chain! {
+        if let ty::RawPtr(from_ptr_ty) = &cast_from.kind();
+        if let ty::RawPtr(to_ptr_ty) = &cast_to.kind();
+        if let Ok(from_layout) = cx.layout_of(from_ptr_ty.ty);
+        if let Ok(to_layout) = cx.layout_of(to_ptr_ty.ty);
+        if from_layout.align.abi < to_layout.align.abi;
+        // with c_void, we inherently need to trust the user
+        if !is_c_void(cx, from_ptr_ty.ty);
+        // when casting from a ZST, we don't know enough to properly lint
+        if !from_layout.is_zst();
+        then {
+            span_lint(
+                cx,
+                CAST_PTR_ALIGNMENT,
+                expr.span,
+                &format!(
+                    "casting from `{}` to a more-strictly-aligned pointer (`{}`) ({} < {} bytes)",
+                    cast_from,
+                    cast_to,
+                    from_layout.align.abi.bytes(),
+                    to_layout.align.abi.bytes(),
+                ),
+            );
+        }
+    }
+}
+
+/// Check if the given type is either `core::ffi::c_void` or
+/// one of the platform specific `libc::<platform>::c_void` of libc.
+fn is_c_void(cx: &LateContext<'_>, ty: Ty<'_>) -> bool {
+    if let ty::Adt(adt, _) = ty.kind() {
+        let names = cx.get_def_path(adt.did);
+
+        if names.is_empty() {
+            return false;
+        }
+        if names[0] == sym::libc || names[0] == sym::core && *names.last().unwrap() == sym!(c_void) {
+            return true;
+        }
+    }
+    false
+}
diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index a80de01cfaf..cf8a64e1fd8 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -2,6 +2,7 @@ mod cast_lossless;
 mod cast_possible_truncation;
 mod cast_possible_wrap;
 mod cast_precision_loss;
+mod cast_ptr_alignment;
 mod cast_sign_loss;
 mod fn_to_numeric_cast;
 mod fn_to_numeric_cast_with_truncation;
@@ -13,22 +14,18 @@ use std::borrow::Cow;
 use if_chain::if_chain;
 use rustc_ast::LitKind;
 use rustc_errors::Applicability;
-use rustc_hir::{Expr, ExprKind, GenericArg, MutTy, Mutability, TyKind, UnOp};
+use rustc_hir::{Expr, ExprKind, MutTy, Mutability, TyKind, UnOp};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_middle::ty::{self, Ty, TypeAndMut, UintTy};
+use rustc_middle::ty::{self, TypeAndMut, UintTy};
 use rustc_semver::RustcVersion;
 use rustc_session::{declare_lint_pass, declare_tool_lint, impl_lint_pass};
-use rustc_span::symbol::sym;
-use rustc_target::abi::LayoutOf;
 
 use crate::utils::sugg::Sugg;
 use crate::utils::{
     is_hir_ty_cfg_dependant, meets_msrv, snippet_with_applicability, span_lint, span_lint_and_sugg, span_lint_and_then,
 };
 
-use utils::int_ty_to_nbits;
-
 declare_clippy_lint! {
     /// **What it does:** Checks for casts from any numerical to a float type where
     /// the receiving type cannot store all values from the original type without
@@ -270,22 +267,6 @@ declare_lint_pass!(Casts => [
     FN_TO_NUMERIC_CAST_WITH_TRUNCATION,
 ]);
 
-/// Check if the given type is either `core::ffi::c_void` or
-/// one of the platform specific `libc::<platform>::c_void` of libc.
-fn is_c_void(cx: &LateContext<'_>, ty: Ty<'_>) -> bool {
-    if let ty::Adt(adt, _) = ty.kind() {
-        let names = cx.get_def_path(adt.did);
-
-        if names.is_empty() {
-            return false;
-        }
-        if names[0] == sym::libc || names[0] == sym::core && *names.last().unwrap() == sym!(c_void) {
-            return true;
-        }
-    }
-    false
-}
-
 impl<'tcx> LateLintPass<'tcx> for Casts {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if expr.span.from_expansion() {
@@ -306,7 +287,6 @@ impl<'tcx> LateLintPass<'tcx> for Casts {
 
             fn_to_numeric_cast::check(cx, expr, cast_expr, cast_from, cast_to);
             fn_to_numeric_cast_with_truncation::check(cx, expr, cast_expr, cast_from, cast_to);
-            lint_cast_ptr_alignment(cx, expr, cast_from, cast_to);
             if cast_from.is_numeric() && cast_to.is_numeric() && !in_external_macro(cx.sess(), expr.span) {
                 cast_possible_truncation::check(cx, expr, cast_from, cast_to);
                 cast_possible_wrap::check(cx, expr, cast_from, cast_to);
@@ -314,48 +294,9 @@ impl<'tcx> LateLintPass<'tcx> for Casts {
                 cast_lossless::check(cx, expr, cast_expr, cast_from, cast_to);
                 cast_sign_loss::check(cx, expr, cast_expr, cast_from, cast_to);
             }
-        } else if let ExprKind::MethodCall(method_path, _, args, _) = expr.kind {
-            if_chain! {
-            if method_path.ident.name == sym!(cast);
-            if let Some(generic_args) = method_path.args;
-            if let [GenericArg::Type(cast_to)] = generic_args.args;
-            // There probably is no obvious reason to do this, just to be consistent with `as` cases.
-            if !is_hir_ty_cfg_dependant(cx, cast_to);
-            then {
-                let (cast_from, cast_to) =
-                    (cx.typeck_results().expr_ty(&args[0]), cx.typeck_results().expr_ty(expr));
-                lint_cast_ptr_alignment(cx, expr, cast_from, cast_to);
-            }
-            }
         }
-    }
-}
 
-fn lint_cast_ptr_alignment<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, cast_from: Ty<'tcx>, cast_to: Ty<'tcx>) {
-    if_chain! {
-        if let ty::RawPtr(from_ptr_ty) = &cast_from.kind();
-        if let ty::RawPtr(to_ptr_ty) = &cast_to.kind();
-        if let Ok(from_layout) = cx.layout_of(from_ptr_ty.ty);
-        if let Ok(to_layout) = cx.layout_of(to_ptr_ty.ty);
-        if from_layout.align.abi < to_layout.align.abi;
-        // with c_void, we inherently need to trust the user
-        if !is_c_void(cx, from_ptr_ty.ty);
-        // when casting from a ZST, we don't know enough to properly lint
-        if !from_layout.is_zst();
-        then {
-            span_lint(
-                cx,
-                CAST_PTR_ALIGNMENT,
-                expr.span,
-                &format!(
-                    "casting from `{}` to a more-strictly-aligned pointer (`{}`) ({} < {} bytes)",
-                    cast_from,
-                    cast_to,
-                    from_layout.align.abi.bytes(),
-                    to_layout.align.abi.bytes(),
-                ),
-            );
-        }
+        cast_ptr_alignment::check(cx, expr);
     }
 }
 
-- 
cgit 1.4.1-3-g733a5


From f33bb3d900f93b13f4a9060e0060df36ff3a7e3d Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Tue, 9 Mar 2021 17:22:21 +0900
Subject: Move cast_ref_to_mut to its own module

---
 clippy_lints/src/casts/cast_ref_to_mut.rs | 28 +++++++++
 clippy_lints/src/casts/mod.rs             | 99 +++++++++++++------------------
 clippy_lints/src/lib.rs                   |  1 -
 3 files changed, 68 insertions(+), 60 deletions(-)
 create mode 100644 clippy_lints/src/casts/cast_ref_to_mut.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/cast_ref_to_mut.rs b/clippy_lints/src/casts/cast_ref_to_mut.rs
new file mode 100644
index 00000000000..3fdc1c6168b
--- /dev/null
+++ b/clippy_lints/src/casts/cast_ref_to_mut.rs
@@ -0,0 +1,28 @@
+use rustc_hir::{Expr, ExprKind, MutTy, Mutability, TyKind, UnOp};
+use rustc_lint::LateContext;
+use rustc_middle::ty;
+
+use if_chain::if_chain;
+
+use crate::utils::span_lint;
+
+use super::CAST_REF_TO_MUT;
+
+pub(super) fn check(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+    if_chain! {
+        if let ExprKind::Unary(UnOp::Deref, e) = &expr.kind;
+        if let ExprKind::Cast(e, t) = &e.kind;
+        if let TyKind::Ptr(MutTy { mutbl: Mutability::Mut, .. }) = t.kind;
+        if let ExprKind::Cast(e, t) = &e.kind;
+        if let TyKind::Ptr(MutTy { mutbl: Mutability::Not, .. }) = t.kind;
+        if let ty::Ref(..) = cx.typeck_results().node_type(e.hir_id).kind();
+        then {
+            span_lint(
+                cx,
+                CAST_REF_TO_MUT,
+                expr.span,
+                "casting `&T` to `&mut T` may cause undefined behavior, consider instead using an `UnsafeCell`",
+            );
+        }
+    }
+}
diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index cf8a64e1fd8..7d5ada18be3 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -3,6 +3,7 @@ mod cast_possible_truncation;
 mod cast_possible_wrap;
 mod cast_precision_loss;
 mod cast_ptr_alignment;
+mod cast_ref_to_mut;
 mod cast_sign_loss;
 mod fn_to_numeric_cast;
 mod fn_to_numeric_cast_with_truncation;
@@ -14,7 +15,7 @@ use std::borrow::Cow;
 use if_chain::if_chain;
 use rustc_ast::LitKind;
 use rustc_errors::Applicability;
-use rustc_hir::{Expr, ExprKind, MutTy, Mutability, TyKind, UnOp};
+use rustc_hir::{Expr, ExprKind, Mutability, TyKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::{self, TypeAndMut, UintTy};
@@ -23,7 +24,7 @@ use rustc_session::{declare_lint_pass, declare_tool_lint, impl_lint_pass};
 
 use crate::utils::sugg::Sugg;
 use crate::utils::{
-    is_hir_ty_cfg_dependant, meets_msrv, snippet_with_applicability, span_lint, span_lint_and_sugg, span_lint_and_then,
+    is_hir_ty_cfg_dependant, meets_msrv, snippet_with_applicability, span_lint_and_sugg, span_lint_and_then,
 };
 
 declare_clippy_lint! {
@@ -255,12 +256,47 @@ declare_clippy_lint! {
     "casting a function pointer to a numeric type not wide enough to store the address"
 }
 
+declare_clippy_lint! {
+    /// **What it does:** Checks for casts of `&T` to `&mut T` anywhere in the code.
+    ///
+    /// **Why is this bad?** It’s basically guaranteed to be undefined behaviour.
+    /// `UnsafeCell` is the only way to obtain aliasable data that is considered
+    /// mutable.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// ```rust,ignore
+    /// fn x(r: &i32) {
+    ///     unsafe {
+    ///         *(r as *const _ as *mut _) += 1;
+    ///     }
+    /// }
+    /// ```
+    ///
+    /// Instead consider using interior mutability types.
+    ///
+    /// ```rust
+    /// use std::cell::UnsafeCell;
+    ///
+    /// fn x(r: &UnsafeCell<i32>) {
+    ///     unsafe {
+    ///         *r.get() += 1;
+    ///     }
+    /// }
+    /// ```
+    pub CAST_REF_TO_MUT,
+    correctness,
+    "a cast of reference to a mutable pointer"
+}
+
 declare_lint_pass!(Casts => [
     CAST_PRECISION_LOSS,
     CAST_SIGN_LOSS,
     CAST_POSSIBLE_TRUNCATION,
     CAST_POSSIBLE_WRAP,
     CAST_LOSSLESS,
+    CAST_REF_TO_MUT,
     UNNECESSARY_CAST,
     CAST_PTR_ALIGNMENT,
     FN_TO_NUMERIC_CAST,
@@ -269,6 +305,8 @@ declare_lint_pass!(Casts => [
 
 impl<'tcx> LateLintPass<'tcx> for Casts {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        cast_ref_to_mut::check(cx, expr);
+
         if expr.span.from_expansion() {
             return;
         }
@@ -300,63 +338,6 @@ impl<'tcx> LateLintPass<'tcx> for Casts {
     }
 }
 
-declare_clippy_lint! {
-    /// **What it does:** Checks for casts of `&T` to `&mut T` anywhere in the code.
-    ///
-    /// **Why is this bad?** It’s basically guaranteed to be undefined behaviour.
-    /// `UnsafeCell` is the only way to obtain aliasable data that is considered
-    /// mutable.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    /// ```rust,ignore
-    /// fn x(r: &i32) {
-    ///     unsafe {
-    ///         *(r as *const _ as *mut _) += 1;
-    ///     }
-    /// }
-    /// ```
-    ///
-    /// Instead consider using interior mutability types.
-    ///
-    /// ```rust
-    /// use std::cell::UnsafeCell;
-    ///
-    /// fn x(r: &UnsafeCell<i32>) {
-    ///     unsafe {
-    ///         *r.get() += 1;
-    ///     }
-    /// }
-    /// ```
-    pub CAST_REF_TO_MUT,
-    correctness,
-    "a cast of reference to a mutable pointer"
-}
-
-declare_lint_pass!(RefToMut => [CAST_REF_TO_MUT]);
-
-impl<'tcx> LateLintPass<'tcx> for RefToMut {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if_chain! {
-            if let ExprKind::Unary(UnOp::Deref, e) = &expr.kind;
-            if let ExprKind::Cast(e, t) = &e.kind;
-            if let TyKind::Ptr(MutTy { mutbl: Mutability::Mut, .. }) = t.kind;
-            if let ExprKind::Cast(e, t) = &e.kind;
-            if let TyKind::Ptr(MutTy { mutbl: Mutability::Not, .. }) = t.kind;
-            if let ty::Ref(..) = cx.typeck_results().node_type(e.hir_id).kind();
-            then {
-                span_lint(
-                    cx,
-                    CAST_REF_TO_MUT,
-                    expr.span,
-                    "casting `&T` to `&mut T` may cause undefined behavior, consider instead using an `UnsafeCell`",
-                );
-            }
-        }
-    }
-}
-
 const PTR_AS_PTR_MSRV: RustcVersion = RustcVersion::new(1, 38, 0);
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index a46c56a01d5..47afd7beb74 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1176,7 +1176,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box slow_vector_initialization::SlowVectorInit);
     store.register_late_pass(|| box unnecessary_sort_by::UnnecessarySortBy);
     store.register_late_pass(|| box unnecessary_wraps::UnnecessaryWraps);
-    store.register_late_pass(|| box casts::RefToMut);
     store.register_late_pass(|| box assertions_on_constants::AssertionsOnConstants);
     store.register_late_pass(|| box transmuting_null::TransmutingNull);
     store.register_late_pass(|| box path_buf_push_overwrite::PathBufPushOverwrite);
-- 
cgit 1.4.1-3-g733a5


From 43c88c60c152f55fb1ada9438ed2378c358b329a Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Tue, 9 Mar 2021 17:28:56 +0900
Subject: Move char_lit_as_u8 to its own module

---
 clippy_lints/src/casts/char_lit_as_u8.rs |  42 +++++++++++++
 clippy_lints/src/casts/mod.rs            | 102 ++++++++++---------------------
 clippy_lints/src/lib.rs                  |   1 -
 3 files changed, 75 insertions(+), 70 deletions(-)
 create mode 100644 clippy_lints/src/casts/char_lit_as_u8.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/char_lit_as_u8.rs b/clippy_lints/src/casts/char_lit_as_u8.rs
new file mode 100644
index 00000000000..ccaad1b8f2a
--- /dev/null
+++ b/clippy_lints/src/casts/char_lit_as_u8.rs
@@ -0,0 +1,42 @@
+use rustc_ast::LitKind;
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind};
+use rustc_lint::LateContext;
+use rustc_middle::ty::{self, UintTy};
+
+use if_chain::if_chain;
+
+use crate::utils::{snippet_with_applicability, span_lint_and_then};
+
+use super::CHAR_LIT_AS_U8;
+
+pub(super) fn check(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+    if_chain! {
+        if let ExprKind::Cast(e, _) = &expr.kind;
+        if let ExprKind::Lit(l) = &e.kind;
+        if let LitKind::Char(c) = l.node;
+        if ty::Uint(UintTy::U8) == *cx.typeck_results().expr_ty(expr).kind();
+        then {
+            let mut applicability = Applicability::MachineApplicable;
+            let snippet = snippet_with_applicability(cx, e.span, "'x'", &mut applicability);
+
+            span_lint_and_then(
+                cx,
+                CHAR_LIT_AS_U8,
+                expr.span,
+                "casting a character literal to `u8` truncates",
+                |diag| {
+                    diag.note("`char` is four bytes wide, but `u8` is a single byte");
+
+                    if c.is_ascii() {
+                        diag.span_suggestion(
+                            expr.span,
+                            "use a byte literal instead",
+                            format!("b{}", snippet),
+                            applicability,
+                        );
+                    }
+            });
+        }
+    }
+}
diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index 7d5ada18be3..6d49af21a5f 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -5,6 +5,7 @@ mod cast_precision_loss;
 mod cast_ptr_alignment;
 mod cast_ref_to_mut;
 mod cast_sign_loss;
+mod char_lit_as_u8;
 mod fn_to_numeric_cast;
 mod fn_to_numeric_cast_with_truncation;
 mod unnecessary_cast;
@@ -13,19 +14,16 @@ mod utils;
 use std::borrow::Cow;
 
 use if_chain::if_chain;
-use rustc_ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, Mutability, TyKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_middle::ty::{self, TypeAndMut, UintTy};
+use rustc_middle::ty::{self, TypeAndMut};
 use rustc_semver::RustcVersion;
 use rustc_session::{declare_lint_pass, declare_tool_lint, impl_lint_pass};
 
 use crate::utils::sugg::Sugg;
-use crate::utils::{
-    is_hir_ty_cfg_dependant, meets_msrv, snippet_with_applicability, span_lint_and_sugg, span_lint_and_then,
-};
+use crate::utils::{is_hir_ty_cfg_dependant, meets_msrv, span_lint_and_sugg};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for casts from any numerical to a float type where
@@ -290,6 +288,33 @@ declare_clippy_lint! {
     "a cast of reference to a mutable pointer"
 }
 
+declare_clippy_lint! {
+    /// **What it does:** Checks for expressions where a character literal is cast
+    /// to `u8` and suggests using a byte literal instead.
+    ///
+    /// **Why is this bad?** In general, casting values to smaller types is
+    /// error-prone and should be avoided where possible. In the particular case of
+    /// converting a character literal to u8, it is easy to avoid by just using a
+    /// byte literal instead. As an added bonus, `b'a'` is even slightly shorter
+    /// than `'a' as u8`.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// ```rust,ignore
+    /// 'x' as u8
+    /// ```
+    ///
+    /// A better version, using the byte literal:
+    ///
+    /// ```rust,ignore
+    /// b'x'
+    /// ```
+    pub CHAR_LIT_AS_U8,
+    complexity,
+    "casting a character literal to `u8` truncates"
+}
+
 declare_lint_pass!(Casts => [
     CAST_PRECISION_LOSS,
     CAST_SIGN_LOSS,
@@ -297,10 +322,11 @@ declare_lint_pass!(Casts => [
     CAST_POSSIBLE_WRAP,
     CAST_LOSSLESS,
     CAST_REF_TO_MUT,
-    UNNECESSARY_CAST,
     CAST_PTR_ALIGNMENT,
+    UNNECESSARY_CAST,
     FN_TO_NUMERIC_CAST,
     FN_TO_NUMERIC_CAST_WITH_TRUNCATION,
+    CHAR_LIT_AS_U8,
 ]);
 
 impl<'tcx> LateLintPass<'tcx> for Casts {
@@ -335,74 +361,12 @@ impl<'tcx> LateLintPass<'tcx> for Casts {
         }
 
         cast_ptr_alignment::check(cx, expr);
+        char_lit_as_u8::check(cx, expr);
     }
 }
 
 const PTR_AS_PTR_MSRV: RustcVersion = RustcVersion::new(1, 38, 0);
 
-declare_clippy_lint! {
-    /// **What it does:** Checks for expressions where a character literal is cast
-    /// to `u8` and suggests using a byte literal instead.
-    ///
-    /// **Why is this bad?** In general, casting values to smaller types is
-    /// error-prone and should be avoided where possible. In the particular case of
-    /// converting a character literal to u8, it is easy to avoid by just using a
-    /// byte literal instead. As an added bonus, `b'a'` is even slightly shorter
-    /// than `'a' as u8`.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    /// ```rust,ignore
-    /// 'x' as u8
-    /// ```
-    ///
-    /// A better version, using the byte literal:
-    ///
-    /// ```rust,ignore
-    /// b'x'
-    /// ```
-    pub CHAR_LIT_AS_U8,
-    complexity,
-    "casting a character literal to `u8` truncates"
-}
-
-declare_lint_pass!(CharLitAsU8 => [CHAR_LIT_AS_U8]);
-
-impl<'tcx> LateLintPass<'tcx> for CharLitAsU8 {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if_chain! {
-            if !expr.span.from_expansion();
-            if let ExprKind::Cast(e, _) = &expr.kind;
-            if let ExprKind::Lit(l) = &e.kind;
-            if let LitKind::Char(c) = l.node;
-            if ty::Uint(UintTy::U8) == *cx.typeck_results().expr_ty(expr).kind();
-            then {
-                let mut applicability = Applicability::MachineApplicable;
-                let snippet = snippet_with_applicability(cx, e.span, "'x'", &mut applicability);
-
-                span_lint_and_then(
-                    cx,
-                    CHAR_LIT_AS_U8,
-                    expr.span,
-                    "casting a character literal to `u8` truncates",
-                    |diag| {
-                        diag.note("`char` is four bytes wide, but `u8` is a single byte");
-
-                        if c.is_ascii() {
-                            diag.span_suggestion(
-                                expr.span,
-                                "use a byte literal instead",
-                                format!("b{}", snippet),
-                                applicability,
-                            );
-                        }
-                });
-            }
-        }
-    }
-}
-
 declare_clippy_lint! {
     /// **What it does:**
     /// Checks for `as` casts between raw pointers without changing its mutability,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 47afd7beb74..67c481145c3 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1108,7 +1108,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box panic_unimplemented::PanicUnimplemented);
     store.register_late_pass(|| box strings::StringLitAsBytes);
     store.register_late_pass(|| box derive::Derive);
-    store.register_late_pass(|| box casts::CharLitAsU8);
     store.register_late_pass(|| box get_last_with_len::GetLastWithLen);
     store.register_late_pass(|| box drop_forget_ref::DropForgetRef);
     store.register_late_pass(|| box empty_enum::EmptyEnum);
-- 
cgit 1.4.1-3-g733a5


From 9e631da454e3ab6f756228b438b61126a0e51518 Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Tue, 9 Mar 2021 20:04:19 +0900
Subject: Move ptr_as_ptr to its own module

---
 clippy_lints/src/casts/mod.rs        | 143 ++++++++++++-----------------------
 clippy_lints/src/casts/ptr_as_ptr.rs |  52 +++++++++++++
 clippy_lints/src/lib.rs              |   3 +-
 3 files changed, 100 insertions(+), 98 deletions(-)
 create mode 100644 clippy_lints/src/casts/ptr_as_ptr.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index 6d49af21a5f..b726bd75f1d 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -8,22 +8,17 @@ mod cast_sign_loss;
 mod char_lit_as_u8;
 mod fn_to_numeric_cast;
 mod fn_to_numeric_cast_with_truncation;
+mod ptr_as_ptr;
 mod unnecessary_cast;
 mod utils;
 
-use std::borrow::Cow;
-
-use if_chain::if_chain;
-use rustc_errors::Applicability;
-use rustc_hir::{Expr, ExprKind, Mutability, TyKind};
+use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_middle::ty::{self, TypeAndMut};
 use rustc_semver::RustcVersion;
-use rustc_session::{declare_lint_pass, declare_tool_lint, impl_lint_pass};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
 
-use crate::utils::sugg::Sugg;
-use crate::utils::{is_hir_ty_cfg_dependant, meets_msrv, span_lint_and_sugg};
+use crate::utils::is_hir_ty_cfg_dependant;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for casts from any numerical to a float type where
@@ -315,58 +310,6 @@ declare_clippy_lint! {
     "casting a character literal to `u8` truncates"
 }
 
-declare_lint_pass!(Casts => [
-    CAST_PRECISION_LOSS,
-    CAST_SIGN_LOSS,
-    CAST_POSSIBLE_TRUNCATION,
-    CAST_POSSIBLE_WRAP,
-    CAST_LOSSLESS,
-    CAST_REF_TO_MUT,
-    CAST_PTR_ALIGNMENT,
-    UNNECESSARY_CAST,
-    FN_TO_NUMERIC_CAST,
-    FN_TO_NUMERIC_CAST_WITH_TRUNCATION,
-    CHAR_LIT_AS_U8,
-]);
-
-impl<'tcx> LateLintPass<'tcx> for Casts {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        cast_ref_to_mut::check(cx, expr);
-
-        if expr.span.from_expansion() {
-            return;
-        }
-        if let ExprKind::Cast(ref cast_expr, cast_to) = expr.kind {
-            if is_hir_ty_cfg_dependant(cx, cast_to) {
-                return;
-            }
-            let (cast_from, cast_to) = (
-                cx.typeck_results().expr_ty(cast_expr),
-                cx.typeck_results().expr_ty(expr),
-            );
-
-            if unnecessary_cast::check(cx, expr, cast_expr, cast_from, cast_to) {
-                return;
-            }
-
-            fn_to_numeric_cast::check(cx, expr, cast_expr, cast_from, cast_to);
-            fn_to_numeric_cast_with_truncation::check(cx, expr, cast_expr, cast_from, cast_to);
-            if cast_from.is_numeric() && cast_to.is_numeric() && !in_external_macro(cx.sess(), expr.span) {
-                cast_possible_truncation::check(cx, expr, cast_from, cast_to);
-                cast_possible_wrap::check(cx, expr, cast_from, cast_to);
-                cast_precision_loss::check(cx, expr, cast_from, cast_to);
-                cast_lossless::check(cx, expr, cast_expr, cast_from, cast_to);
-                cast_sign_loss::check(cx, expr, cast_expr, cast_from, cast_to);
-            }
-        }
-
-        cast_ptr_alignment::check(cx, expr);
-        char_lit_as_u8::check(cx, expr);
-    }
-}
-
-const PTR_AS_PTR_MSRV: RustcVersion = RustcVersion::new(1, 38, 0);
-
 declare_clippy_lint! {
     /// **What it does:**
     /// Checks for `as` casts between raw pointers without changing its mutability,
@@ -398,58 +341,66 @@ declare_clippy_lint! {
     "casting using `as` from and to raw pointers that doesn't change its mutability, where `pointer::cast` could take the place of `as`"
 }
 
-pub struct PtrAsPtr {
+pub struct Casts {
     msrv: Option<RustcVersion>,
 }
 
-impl PtrAsPtr {
+impl Casts {
     #[must_use]
     pub fn new(msrv: Option<RustcVersion>) -> Self {
         Self { msrv }
     }
 }
 
-impl_lint_pass!(PtrAsPtr => [PTR_AS_PTR]);
+impl_lint_pass!(Casts => [
+    CAST_PRECISION_LOSS,
+    CAST_SIGN_LOSS,
+    CAST_POSSIBLE_TRUNCATION,
+    CAST_POSSIBLE_WRAP,
+    CAST_LOSSLESS,
+    CAST_REF_TO_MUT,
+    CAST_PTR_ALIGNMENT,
+    UNNECESSARY_CAST,
+    FN_TO_NUMERIC_CAST,
+    FN_TO_NUMERIC_CAST_WITH_TRUNCATION,
+    CHAR_LIT_AS_U8,
+    PTR_AS_PTR,
+]);
 
-impl<'tcx> LateLintPass<'tcx> for PtrAsPtr {
+impl<'tcx> LateLintPass<'tcx> for Casts {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if !meets_msrv(self.msrv.as_ref(), &PTR_AS_PTR_MSRV) {
-            return;
-        }
-
         if expr.span.from_expansion() {
             return;
         }
 
-        if_chain! {
-            if let ExprKind::Cast(cast_expr, cast_to_hir_ty) = expr.kind;
-            let (cast_from, cast_to) = (cx.typeck_results().expr_ty(cast_expr), cx.typeck_results().expr_ty(expr));
-            if let ty::RawPtr(TypeAndMut { mutbl: from_mutbl, .. }) = cast_from.kind();
-            if let ty::RawPtr(TypeAndMut { ty: to_pointee_ty, mutbl: to_mutbl }) = cast_to.kind();
-            if matches!((from_mutbl, to_mutbl),
-                (Mutability::Not, Mutability::Not) | (Mutability::Mut, Mutability::Mut));
-            // The `U` in `pointer::cast` have to be `Sized`
-            // as explained here: https://github.com/rust-lang/rust/issues/60602.
-            if to_pointee_ty.is_sized(cx.tcx.at(expr.span), cx.param_env);
-            then {
-                let mut applicability = Applicability::MachineApplicable;
-                let cast_expr_sugg = Sugg::hir_with_applicability(cx, cast_expr, "_", &mut applicability);
-                let turbofish = match &cast_to_hir_ty.kind {
-                        TyKind::Infer => Cow::Borrowed(""),
-                        TyKind::Ptr(mut_ty) if matches!(mut_ty.ty.kind, TyKind::Infer) => Cow::Borrowed(""),
-                        _ => Cow::Owned(format!("::<{}>", to_pointee_ty)),
-                    };
-                span_lint_and_sugg(
-                    cx,
-                    PTR_AS_PTR,
-                    expr.span,
-                    "`as` casting between raw pointers without changing its mutability",
-                    "try `pointer::cast`, a safer alternative",
-                    format!("{}.cast{}()", cast_expr_sugg.maybe_par(), turbofish),
-                    applicability,
-                );
+        if let ExprKind::Cast(ref cast_expr, cast_to) = expr.kind {
+            if is_hir_ty_cfg_dependant(cx, cast_to) {
+                return;
+            }
+            let (cast_from, cast_to) = (
+                cx.typeck_results().expr_ty(cast_expr),
+                cx.typeck_results().expr_ty(expr),
+            );
+
+            if unnecessary_cast::check(cx, expr, cast_expr, cast_from, cast_to) {
+                return;
+            }
+
+            fn_to_numeric_cast::check(cx, expr, cast_expr, cast_from, cast_to);
+            fn_to_numeric_cast_with_truncation::check(cx, expr, cast_expr, cast_from, cast_to);
+            if cast_from.is_numeric() && cast_to.is_numeric() && !in_external_macro(cx.sess(), expr.span) {
+                cast_possible_truncation::check(cx, expr, cast_from, cast_to);
+                cast_possible_wrap::check(cx, expr, cast_from, cast_to);
+                cast_precision_loss::check(cx, expr, cast_from, cast_to);
+                cast_lossless::check(cx, expr, cast_expr, cast_from, cast_to);
+                cast_sign_loss::check(cx, expr, cast_expr, cast_from, cast_to);
             }
         }
+
+        cast_ref_to_mut::check(cx, expr);
+        cast_ptr_alignment::check(cx, expr);
+        char_lit_as_u8::check(cx, expr);
+        ptr_as_ptr::check(cx, expr, &self.msrv);
     }
 
     extract_msrv_attr!(LateContext);
diff --git a/clippy_lints/src/casts/ptr_as_ptr.rs b/clippy_lints/src/casts/ptr_as_ptr.rs
new file mode 100644
index 00000000000..abfbadf3642
--- /dev/null
+++ b/clippy_lints/src/casts/ptr_as_ptr.rs
@@ -0,0 +1,52 @@
+use std::borrow::Cow;
+
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind, Mutability, TyKind};
+use rustc_lint::LateContext;
+use rustc_middle::ty::{self, TypeAndMut};
+use rustc_semver::RustcVersion;
+
+use if_chain::if_chain;
+
+use crate::utils::sugg::Sugg;
+use crate::utils::{meets_msrv, span_lint_and_sugg};
+
+use super::PTR_AS_PTR;
+
+const PTR_AS_PTR_MSRV: RustcVersion = RustcVersion::new(1, 38, 0);
+
+pub(super) fn check(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, msrv: &Option<RustcVersion>) {
+    if !meets_msrv(msrv.as_ref(), &PTR_AS_PTR_MSRV) {
+        return;
+    }
+
+    if_chain! {
+        if let ExprKind::Cast(cast_expr, cast_to_hir_ty) = expr.kind;
+        let (cast_from, cast_to) = (cx.typeck_results().expr_ty(cast_expr), cx.typeck_results().expr_ty(expr));
+        if let ty::RawPtr(TypeAndMut { mutbl: from_mutbl, .. }) = cast_from.kind();
+        if let ty::RawPtr(TypeAndMut { ty: to_pointee_ty, mutbl: to_mutbl }) = cast_to.kind();
+        if matches!((from_mutbl, to_mutbl),
+            (Mutability::Not, Mutability::Not) | (Mutability::Mut, Mutability::Mut));
+        // The `U` in `pointer::cast` have to be `Sized`
+        // as explained here: https://github.com/rust-lang/rust/issues/60602.
+        if to_pointee_ty.is_sized(cx.tcx.at(expr.span), cx.param_env);
+        then {
+            let mut applicability = Applicability::MachineApplicable;
+            let cast_expr_sugg = Sugg::hir_with_applicability(cx, cast_expr, "_", &mut applicability);
+            let turbofish = match &cast_to_hir_ty.kind {
+                    TyKind::Infer => Cow::Borrowed(""),
+                    TyKind::Ptr(mut_ty) if matches!(mut_ty.ty.kind, TyKind::Infer) => Cow::Borrowed(""),
+                    _ => Cow::Owned(format!("::<{}>", to_pointee_ty)),
+                };
+            span_lint_and_sugg(
+                cx,
+                PTR_AS_PTR,
+                expr.span,
+                "`as` casting between raw pointers without changing its mutability",
+                "try `pointer::cast`, a safer alternative",
+                format!("{}.cast{}()", cast_expr_sugg.maybe_par(), turbofish),
+                applicability,
+            );
+        }
+    }
+}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 67c481145c3..04e151df8e8 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1076,6 +1076,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(move || box use_self::UseSelf::new(msrv));
     store.register_late_pass(move || box missing_const_for_fn::MissingConstForFn::new(msrv));
     store.register_late_pass(move || box needless_question_mark::NeedlessQuestionMark::new(msrv));
+    store.register_late_pass(move || box casts::Casts::new(msrv));
 
     store.register_late_pass(|| box size_of_in_element_count::SizeOfInElementCount);
     store.register_late_pass(|| box map_clone::MapClone);
@@ -1087,7 +1088,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box main_recursion::MainRecursion::default());
     store.register_late_pass(|| box lifetimes::Lifetimes);
     store.register_late_pass(|| box entry::HashMapPass);
-    store.register_late_pass(|| box casts::Casts);
     let type_complexity_threshold = conf.type_complexity_threshold;
     store.register_late_pass(move || box types::TypeComplexity::new(type_complexity_threshold));
     store.register_late_pass(|| box minmax::MinMaxPass);
@@ -1276,7 +1276,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box strings::StringToString);
     store.register_late_pass(|| box zero_sized_map_values::ZeroSizedMapValues);
     store.register_late_pass(|| box vec_init_then_push::VecInitThenPush::default());
-    store.register_late_pass(move || box casts::PtrAsPtr::new(msrv));
     store.register_late_pass(|| box case_sensitive_file_extension_comparisons::CaseSensitiveFileExtensionComparisons);
     store.register_late_pass(|| box redundant_slicing::RedundantSlicing);
     store.register_late_pass(|| box from_str_radix_10::FromStrRadix10);
-- 
cgit 1.4.1-3-g733a5


From e0f982bb3e975a3b5925e17790f6df70bad0c153 Mon Sep 17 00:00:00 2001
From: Takayuki Nakata <f.seasons017@gmail.com>
Date: Wed, 10 Mar 2021 00:02:24 +0900
Subject: Improve doc on `map_flatten`

---
 clippy_lints/src/methods/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index cc8dcacb1eb..612684dc4d8 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -403,7 +403,7 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for usage of `_.map(_).flatten(_)`,
+    /// **What it does:** Checks for usage of `_.map(_).flatten(_)` on `Iterator` and `Option`
     ///
     /// **Why is this bad?** Readability, this can be written more concisely as
     /// `_.flat_map(_)`
-- 
cgit 1.4.1-3-g733a5


From 9c1dd0c22721029dc47e5fe73d85670abab9adfc Mon Sep 17 00:00:00 2001
From: flip1995 <philipp.krones@embecosm.com>
Date: Thu, 11 Mar 2021 10:57:49 +0100
Subject: Fix remaining dogfood errors (internal lints)

---
 clippy_lints/src/loops/explicit_iter_loop.rs | 8 ++++----
 clippy_lints/src/loops/for_kv_map.rs         | 3 ++-
 clippy_lints/src/loops/manual_memcpy.rs      | 2 +-
 clippy_lints/src/loops/needless_collect.rs   | 6 +++---
 clippy_lints/src/methods/iter_count.rs       | 6 +++---
 clippy_utils/src/eager_or_lazy.rs            | 5 +++--
 6 files changed, 16 insertions(+), 14 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/explicit_iter_loop.rs b/clippy_lints/src/loops/explicit_iter_loop.rs
index 44d08916891..9683e59a396 100644
--- a/clippy_lints/src/loops/explicit_iter_loop.rs
+++ b/clippy_lints/src/loops/explicit_iter_loop.rs
@@ -4,7 +4,7 @@ use rustc_errors::Applicability;
 use rustc_hir::{Expr, Mutability};
 use rustc_lint::LateContext;
 use rustc_middle::ty::{self, Ty, TyS};
-use rustc_span::symbol::sym;
+use rustc_span::sym;
 
 use crate::utils::{is_type_diagnostic_item, match_type, paths};
 
@@ -55,9 +55,9 @@ fn is_ref_iterable_type(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
     is_iterable_array(ty, cx) ||
     is_type_diagnostic_item(cx, ty, sym::vec_type) ||
     match_type(cx, ty, &paths::LINKED_LIST) ||
-    is_type_diagnostic_item(cx, ty, sym!(hashmap_type)) ||
-    is_type_diagnostic_item(cx, ty, sym!(hashset_type)) ||
-    is_type_diagnostic_item(cx, ty, sym!(vecdeque_type)) ||
+    is_type_diagnostic_item(cx, ty, sym::hashmap_type) ||
+    is_type_diagnostic_item(cx, ty, sym::hashset_type) ||
+    is_type_diagnostic_item(cx, ty, sym::vecdeque_type) ||
     match_type(cx, ty, &paths::BINARY_HEAP) ||
     match_type(cx, ty, &paths::BTREEMAP) ||
     match_type(cx, ty, &paths::BTREESET)
diff --git a/clippy_lints/src/loops/for_kv_map.rs b/clippy_lints/src/loops/for_kv_map.rs
index eb53c3179ca..6ee9b95a3b6 100644
--- a/clippy_lints/src/loops/for_kv_map.rs
+++ b/clippy_lints/src/loops/for_kv_map.rs
@@ -4,6 +4,7 @@ use crate::utils::{is_type_diagnostic_item, match_type, multispan_sugg, paths, s
 use rustc_hir::{BorrowKind, Expr, ExprKind, Mutability, Pat, PatKind};
 use rustc_lint::LateContext;
 use rustc_middle::ty;
+use rustc_span::sym;
 
 /// Checks for the `FOR_KV_MAP` lint.
 pub(super) fn check<'tcx>(
@@ -35,7 +36,7 @@ pub(super) fn check<'tcx>(
                 _ => arg,
             };
 
-            if is_type_diagnostic_item(cx, ty, sym!(hashmap_type)) || match_type(cx, ty, &paths::BTREEMAP) {
+            if is_type_diagnostic_item(cx, ty, sym::hashmap_type) || match_type(cx, ty, &paths::BTREEMAP) {
                 span_lint_and_then(
                     cx,
                     FOR_KV_MAP,
diff --git a/clippy_lints/src/loops/manual_memcpy.rs b/clippy_lints/src/loops/manual_memcpy.rs
index c41eb32f9d8..fad96c2d5c0 100644
--- a/clippy_lints/src/loops/manual_memcpy.rs
+++ b/clippy_lints/src/loops/manual_memcpy.rs
@@ -328,7 +328,7 @@ fn is_slice_like<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'_>) -> bool {
         _ => false,
     };
 
-    is_slice || is_type_diagnostic_item(cx, ty, sym::vec_type) || is_type_diagnostic_item(cx, ty, sym!(vecdeque_type))
+    is_slice || is_type_diagnostic_item(cx, ty, sym::vec_type) || is_type_diagnostic_item(cx, ty, sym::vecdeque_type)
 }
 
 fn fetch_cloned_expr<'tcx>(expr: &'tcx Expr<'tcx>) -> &'tcx Expr<'tcx> {
diff --git a/clippy_lints/src/loops/needless_collect.rs b/clippy_lints/src/loops/needless_collect.rs
index 6f271309105..92560c80629 100644
--- a/clippy_lints/src/loops/needless_collect.rs
+++ b/clippy_lints/src/loops/needless_collect.rs
@@ -29,9 +29,9 @@ fn check_needless_collect_direct_usage<'tcx>(expr: &'tcx Expr<'_>, cx: &LateCont
         then {
             let ty = cx.typeck_results().node_type(ty.hir_id);
             if is_type_diagnostic_item(cx, ty, sym::vec_type) ||
-                is_type_diagnostic_item(cx, ty, sym!(vecdeque_type)) ||
+                is_type_diagnostic_item(cx, ty, sym::vecdeque_type) ||
                 match_type(cx, ty, &paths::BTREEMAP) ||
-                is_type_diagnostic_item(cx, ty, sym!(hashmap_type)) {
+                is_type_diagnostic_item(cx, ty, sym::hashmap_type) {
                 if method.ident.name == sym!(len) {
                     let span = shorten_needless_collect_span(expr);
                     span_lint_and_sugg(
@@ -99,7 +99,7 @@ fn check_needless_collect_indirect_usage<'tcx>(expr: &'tcx Expr<'_>, cx: &LateCo
                 if let Some(GenericArg::Type(ref ty)) = generic_args.args.get(0);
                 if let ty = cx.typeck_results().node_type(ty.hir_id);
                 if is_type_diagnostic_item(cx, ty, sym::vec_type) ||
-                    is_type_diagnostic_item(cx, ty, sym!(vecdeque_type)) ||
+                    is_type_diagnostic_item(cx, ty, sym::vecdeque_type) ||
                     match_type(cx, ty, &paths::LINKED_LIST);
                 if let Some(iter_calls) = detect_iter_and_into_iters(block, *ident);
                 if iter_calls.len() == 1;
diff --git a/clippy_lints/src/methods/iter_count.rs b/clippy_lints/src/methods/iter_count.rs
index 1b99bacc3f1..71d65a01d3e 100644
--- a/clippy_lints/src/methods/iter_count.rs
+++ b/clippy_lints/src/methods/iter_count.rs
@@ -14,11 +14,11 @@ pub(crate) fn lints<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, iter_args: &'
         "slice"
     } else if is_type_diagnostic_item(cx, ty, sym::vec_type) {
         "Vec"
-    } else if is_type_diagnostic_item(cx, ty, sym!(vecdeque_type)) {
+    } else if is_type_diagnostic_item(cx, ty, sym::vecdeque_type) {
         "VecDeque"
-    } else if is_type_diagnostic_item(cx, ty, sym!(hashset_type)) {
+    } else if is_type_diagnostic_item(cx, ty, sym::hashset_type) {
         "HashSet"
-    } else if is_type_diagnostic_item(cx, ty, sym!(hashmap_type)) {
+    } else if is_type_diagnostic_item(cx, ty, sym::hashmap_type) {
         "HashMap"
     } else if match_type(cx, ty, &paths::BTREEMAP) {
         "BTreeMap"
diff --git a/clippy_utils/src/eager_or_lazy.rs b/clippy_utils/src/eager_or_lazy.rs
index f54a35a0a18..8013c4e4fcb 100644
--- a/clippy_utils/src/eager_or_lazy.rs
+++ b/clippy_utils/src/eager_or_lazy.rs
@@ -9,7 +9,7 @@
 //!  - or-fun-call
 //!  - option-if-let-else
 
-use crate::{is_ctor_or_promotable_const_function, is_type_diagnostic_item, match_type, paths};
+use crate::{is_ctor_or_promotable_const_function, is_type_diagnostic_item};
 use rustc_hir::def::{DefKind, Res};
 
 use rustc_hir::intravisit;
@@ -100,7 +100,8 @@ fn identify_some_potentially_expensive_patterns<'tcx>(cx: &LateContext<'tcx>, ex
                 ExprKind::Call(..) => !is_ctor_or_promotable_const_function(self.cx, expr),
                 ExprKind::Index(obj, _) => {
                     let ty = self.cx.typeck_results().expr_ty(obj);
-                    is_type_diagnostic_item(self.cx, ty, sym::hashmap_type) || match_type(self.cx, ty, &paths::BTREEMAP)
+                    is_type_diagnostic_item(self.cx, ty, sym::hashmap_type)
+                        || is_type_diagnostic_item(self.cx, ty, sym::BTreeMap)
                 },
                 ExprKind::MethodCall(..) => true,
                 _ => false,
-- 
cgit 1.4.1-3-g733a5


From f0f07accbce24adb5706eeb4e14e0e1c6b2b973b Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Wed, 3 Mar 2021 00:14:38 +0900
Subject: move expect_used, filter_next, get_unwrap, ok_expect and unwrap_used
 to their own modules

---
 clippy_lints/src/methods/expect_used.rs           |  30 +++
 clippy_lints/src/methods/filter_next.rs           |  31 +++
 clippy_lints/src/methods/get_unwrap.rs            |  84 +++++++++
 clippy_lints/src/methods/mod.rs                   | 218 ++--------------------
 clippy_lints/src/methods/ok_expect.rs             |  45 +++++
 clippy_lints/src/methods/option_map_unwrap_or.rs  |   2 +-
 clippy_lints/src/methods/unnecessary_lazy_eval.rs |   2 +-
 clippy_lints/src/methods/unwrap_used.rs           |  34 ++++
 8 files changed, 244 insertions(+), 202 deletions(-)
 create mode 100644 clippy_lints/src/methods/expect_used.rs
 create mode 100644 clippy_lints/src/methods/filter_next.rs
 create mode 100644 clippy_lints/src/methods/get_unwrap.rs
 create mode 100644 clippy_lints/src/methods/ok_expect.rs
 create mode 100644 clippy_lints/src/methods/unwrap_used.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/expect_used.rs b/clippy_lints/src/methods/expect_used.rs
new file mode 100644
index 00000000000..90b781bd9d1
--- /dev/null
+++ b/clippy_lints/src/methods/expect_used.rs
@@ -0,0 +1,30 @@
+use crate::utils::{is_type_diagnostic_item, span_lint_and_help};
+use rustc_hir as hir;
+use rustc_lint::LateContext;
+use rustc_span::sym;
+
+use super::EXPECT_USED;
+
+/// lint use of `expect()` for `Option`s and `Result`s
+pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, expect_args: &[hir::Expr<'_>]) {
+    let obj_ty = cx.typeck_results().expr_ty(&expect_args[0]).peel_refs();
+
+    let mess = if is_type_diagnostic_item(cx, obj_ty, sym::option_type) {
+        Some((EXPECT_USED, "an Option", "None"))
+    } else if is_type_diagnostic_item(cx, obj_ty, sym::result_type) {
+        Some((EXPECT_USED, "a Result", "Err"))
+    } else {
+        None
+    };
+
+    if let Some((lint, kind, none_value)) = mess {
+        span_lint_and_help(
+            cx,
+            lint,
+            expr.span,
+            &format!("used `expect()` on `{}` value", kind,),
+            None,
+            &format!("if this value is an `{}`, it will panic", none_value,),
+        );
+    }
+}
diff --git a/clippy_lints/src/methods/filter_next.rs b/clippy_lints/src/methods/filter_next.rs
new file mode 100644
index 00000000000..81619e73017
--- /dev/null
+++ b/clippy_lints/src/methods/filter_next.rs
@@ -0,0 +1,31 @@
+use crate::utils::{match_trait_method, paths, snippet, span_lint, span_lint_and_sugg};
+use rustc_errors::Applicability;
+use rustc_hir as hir;
+use rustc_lint::LateContext;
+
+use super::FILTER_NEXT;
+
+/// lint use of `filter().next()` for `Iterators`
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, filter_args: &'tcx [hir::Expr<'_>]) {
+    // lint if caller of `.filter().next()` is an Iterator
+    if match_trait_method(cx, expr, &paths::ITERATOR) {
+        let msg = "called `filter(..).next()` on an `Iterator`. This is more succinctly expressed by calling \
+                   `.find(..)` instead";
+        let filter_snippet = snippet(cx, filter_args[1].span, "..");
+        if filter_snippet.lines().count() <= 1 {
+            let iter_snippet = snippet(cx, filter_args[0].span, "..");
+            // add note if not multi-line
+            span_lint_and_sugg(
+                cx,
+                FILTER_NEXT,
+                expr.span,
+                msg,
+                "try this",
+                format!("{}.find({})", iter_snippet, filter_snippet),
+                Applicability::MachineApplicable,
+            );
+        } else {
+            span_lint(cx, FILTER_NEXT, expr.span, msg);
+        }
+    }
+}
diff --git a/clippy_lints/src/methods/get_unwrap.rs b/clippy_lints/src/methods/get_unwrap.rs
new file mode 100644
index 00000000000..2684c50e01b
--- /dev/null
+++ b/clippy_lints/src/methods/get_unwrap.rs
@@ -0,0 +1,84 @@
+use crate::methods::derefs_to_slice;
+use crate::utils::{
+    get_parent_expr, is_type_diagnostic_item, match_type, paths, snippet_with_applicability, span_lint_and_sugg,
+};
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir as hir;
+use rustc_lint::LateContext;
+use rustc_span::sym;
+
+use super::GET_UNWRAP;
+
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &hir::Expr<'_>, get_args: &'tcx [hir::Expr<'_>], is_mut: bool) {
+    // Note: we don't want to lint `get_mut().unwrap` for `HashMap` or `BTreeMap`,
+    // because they do not implement `IndexMut`
+    let mut applicability = Applicability::MachineApplicable;
+    let expr_ty = cx.typeck_results().expr_ty(&get_args[0]);
+    let get_args_str = if get_args.len() > 1 {
+        snippet_with_applicability(cx, get_args[1].span, "..", &mut applicability)
+    } else {
+        return; // not linting on a .get().unwrap() chain or variant
+    };
+    let mut needs_ref;
+    let caller_type = if derefs_to_slice(cx, &get_args[0], expr_ty).is_some() {
+        needs_ref = get_args_str.parse::<usize>().is_ok();
+        "slice"
+    } else if is_type_diagnostic_item(cx, expr_ty, sym::vec_type) {
+        needs_ref = get_args_str.parse::<usize>().is_ok();
+        "Vec"
+    } else if is_type_diagnostic_item(cx, expr_ty, sym!(vecdeque_type)) {
+        needs_ref = get_args_str.parse::<usize>().is_ok();
+        "VecDeque"
+    } else if !is_mut && is_type_diagnostic_item(cx, expr_ty, sym!(hashmap_type)) {
+        needs_ref = true;
+        "HashMap"
+    } else if !is_mut && match_type(cx, expr_ty, &paths::BTREEMAP) {
+        needs_ref = true;
+        "BTreeMap"
+    } else {
+        return; // caller is not a type that we want to lint
+    };
+
+    let mut span = expr.span;
+
+    // Handle the case where the result is immediately dereferenced
+    // by not requiring ref and pulling the dereference into the
+    // suggestion.
+    if_chain! {
+        if needs_ref;
+        if let Some(parent) = get_parent_expr(cx, expr);
+        if let hir::ExprKind::Unary(hir::UnOp::Deref, _) = parent.kind;
+        then {
+            needs_ref = false;
+            span = parent.span;
+        }
+    }
+
+    let mut_str = if is_mut { "_mut" } else { "" };
+    let borrow_str = if !needs_ref {
+        ""
+    } else if is_mut {
+        "&mut "
+    } else {
+        "&"
+    };
+
+    span_lint_and_sugg(
+        cx,
+        GET_UNWRAP,
+        span,
+        &format!(
+            "called `.get{0}().unwrap()` on a {1}. Using `[]` is more clear and more concise",
+            mut_str, caller_type
+        ),
+        "try this",
+        format!(
+            "{}{}[{}]",
+            borrow_str,
+            snippet_with_applicability(cx, get_args[0].span, "..", &mut applicability),
+            get_args_str
+        ),
+        applicability,
+    );
+}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index e8af9b3d7d9..71080e9bef0 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1,14 +1,19 @@
 mod bind_instead_of_map;
 mod bytes_nth;
+mod expect_used;
 mod filter_map_identity;
+mod filter_next;
+mod get_unwrap;
 mod implicit_clone;
 mod inefficient_to_string;
 mod inspect_for_each;
 mod iter_count;
 mod manual_saturating_arithmetic;
+mod ok_expect;
 mod option_map_unwrap_or;
 mod unnecessary_filter_map;
 mod unnecessary_lazy_eval;
+mod unwrap_used;
 
 use std::borrow::Cow;
 use std::fmt;
@@ -1649,15 +1654,15 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
         let method_names: Vec<&str> = method_names.iter().map(|s| &**s).collect();
 
         match method_names.as_slice() {
-            ["unwrap", "get"] => lint_get_unwrap(cx, expr, arg_lists[1], false),
-            ["unwrap", "get_mut"] => lint_get_unwrap(cx, expr, arg_lists[1], true),
-            ["unwrap", ..] => lint_unwrap(cx, expr, arg_lists[0]),
-            ["expect", "ok"] => lint_ok_expect(cx, expr, arg_lists[1]),
-            ["expect", ..] => lint_expect(cx, expr, arg_lists[0]),
-            ["unwrap_or", "map"] => option_map_unwrap_or::lint(cx, expr, arg_lists[1], arg_lists[0], method_spans[1]),
+            ["unwrap", "get"] => get_unwrap::check(cx, expr, arg_lists[1], false),
+            ["unwrap", "get_mut"] => get_unwrap::check(cx, expr, arg_lists[1], true),
+            ["unwrap", ..] => unwrap_used::check(cx, expr, arg_lists[0]),
+            ["expect", "ok"] => ok_expect::check(cx, expr, arg_lists[1]),
+            ["expect", ..] => expect_used::check(cx, expr, arg_lists[0]),
+            ["unwrap_or", "map"] => option_map_unwrap_or::check(cx, expr, arg_lists[1], arg_lists[0], method_spans[1]),
             ["unwrap_or_else", "map"] => {
                 if !lint_map_unwrap_or_else(cx, expr, arg_lists[1], arg_lists[0], self.msrv.as_ref()) {
-                    unnecessary_lazy_eval::lint(cx, expr, arg_lists[0], "unwrap_or");
+                    unnecessary_lazy_eval::check(cx, expr, arg_lists[0], "unwrap_or");
                 }
             },
             ["map_or", ..] => lint_map_or_none(cx, expr, arg_lists[0]),
@@ -1665,15 +1670,15 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
                 let biom_option_linted = bind_instead_of_map::OptionAndThenSome::lint(cx, expr, arg_lists[0]);
                 let biom_result_linted = bind_instead_of_map::ResultAndThenOk::lint(cx, expr, arg_lists[0]);
                 if !biom_option_linted && !biom_result_linted {
-                    unnecessary_lazy_eval::lint(cx, expr, arg_lists[0], "and");
+                    unnecessary_lazy_eval::check(cx, expr, arg_lists[0], "and");
                 }
             },
             ["or_else", ..] => {
                 if !bind_instead_of_map::ResultOrElseErrInfo::lint(cx, expr, arg_lists[0]) {
-                    unnecessary_lazy_eval::lint(cx, expr, arg_lists[0], "or");
+                    unnecessary_lazy_eval::check(cx, expr, arg_lists[0], "or");
                 }
             },
-            ["next", "filter"] => lint_filter_next(cx, expr, arg_lists[1]),
+            ["next", "filter"] => filter_next::check(cx, expr, arg_lists[1]),
             ["next", "skip_while"] => lint_skip_while_next(cx, expr, arg_lists[1]),
             ["next", "iter"] => lint_iter_next(cx, expr, arg_lists[1]),
             ["map", "filter"] => lint_filter_map(cx, expr, false),
@@ -1724,9 +1729,9 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             ["map", "as_mut"] => {
                 lint_option_as_ref_deref(cx, expr, arg_lists[1], arg_lists[0], true, self.msrv.as_ref())
             },
-            ["unwrap_or_else", ..] => unnecessary_lazy_eval::lint(cx, expr, arg_lists[0], "unwrap_or"),
-            ["get_or_insert_with", ..] => unnecessary_lazy_eval::lint(cx, expr, arg_lists[0], "get_or_insert"),
-            ["ok_or_else", ..] => unnecessary_lazy_eval::lint(cx, expr, arg_lists[0], "ok_or"),
+            ["unwrap_or_else", ..] => unnecessary_lazy_eval::check(cx, expr, arg_lists[0], "unwrap_or"),
+            ["get_or_insert_with", ..] => unnecessary_lazy_eval::check(cx, expr, arg_lists[0], "get_or_insert"),
+            ["ok_or_else", ..] => unnecessary_lazy_eval::check(cx, expr, arg_lists[0], "ok_or"),
             ["collect", "map"] => lint_map_collect(cx, expr, arg_lists[1], arg_lists[0]),
             ["for_each", "inspect"] => inspect_for_each::lint(cx, expr, method_spans[1]),
             ["to_owned", ..] => implicit_clone::check(cx, expr, sym::ToOwned),
@@ -2712,79 +2717,6 @@ fn lint_iter_nth_zero<'tcx>(cx: &LateContext<'tcx>, expr: &hir::Expr<'_>, nth_ar
     }
 }
 
-fn lint_get_unwrap<'tcx>(cx: &LateContext<'tcx>, expr: &hir::Expr<'_>, get_args: &'tcx [hir::Expr<'_>], is_mut: bool) {
-    // Note: we don't want to lint `get_mut().unwrap` for `HashMap` or `BTreeMap`,
-    // because they do not implement `IndexMut`
-    let mut applicability = Applicability::MachineApplicable;
-    let expr_ty = cx.typeck_results().expr_ty(&get_args[0]);
-    let get_args_str = if get_args.len() > 1 {
-        snippet_with_applicability(cx, get_args[1].span, "..", &mut applicability)
-    } else {
-        return; // not linting on a .get().unwrap() chain or variant
-    };
-    let mut needs_ref;
-    let caller_type = if derefs_to_slice(cx, &get_args[0], expr_ty).is_some() {
-        needs_ref = get_args_str.parse::<usize>().is_ok();
-        "slice"
-    } else if is_type_diagnostic_item(cx, expr_ty, sym::vec_type) {
-        needs_ref = get_args_str.parse::<usize>().is_ok();
-        "Vec"
-    } else if is_type_diagnostic_item(cx, expr_ty, sym::vecdeque_type) {
-        needs_ref = get_args_str.parse::<usize>().is_ok();
-        "VecDeque"
-    } else if !is_mut && is_type_diagnostic_item(cx, expr_ty, sym::hashmap_type) {
-        needs_ref = true;
-        "HashMap"
-    } else if !is_mut && match_type(cx, expr_ty, &paths::BTREEMAP) {
-        needs_ref = true;
-        "BTreeMap"
-    } else {
-        return; // caller is not a type that we want to lint
-    };
-
-    let mut span = expr.span;
-
-    // Handle the case where the result is immediately dereferenced
-    // by not requiring ref and pulling the dereference into the
-    // suggestion.
-    if_chain! {
-        if needs_ref;
-        if let Some(parent) = get_parent_expr(cx, expr);
-        if let hir::ExprKind::Unary(hir::UnOp::Deref, _) = parent.kind;
-        then {
-            needs_ref = false;
-            span = parent.span;
-        }
-    }
-
-    let mut_str = if is_mut { "_mut" } else { "" };
-    let borrow_str = if !needs_ref {
-        ""
-    } else if is_mut {
-        "&mut "
-    } else {
-        "&"
-    };
-
-    span_lint_and_sugg(
-        cx,
-        GET_UNWRAP,
-        span,
-        &format!(
-            "called `.get{0}().unwrap()` on a {1}. Using `[]` is more clear and more concise",
-            mut_str, caller_type
-        ),
-        "try this",
-        format!(
-            "{}{}[{}]",
-            borrow_str,
-            snippet_with_applicability(cx, get_args[0].span, "..", &mut applicability),
-            get_args_str
-        ),
-        applicability,
-    );
-}
-
 fn lint_iter_skip_next(cx: &LateContext<'_>, expr: &hir::Expr<'_>, skip_args: &[hir::Expr<'_>]) {
     // lint if caller of skip is an Iterator
     if match_trait_method(cx, expr, &paths::ITERATOR) {
@@ -2843,80 +2775,6 @@ fn derefs_to_slice<'tcx>(
     }
 }
 
-/// lint use of `unwrap()` for `Option`s and `Result`s
-fn lint_unwrap(cx: &LateContext<'_>, expr: &hir::Expr<'_>, unwrap_args: &[hir::Expr<'_>]) {
-    let obj_ty = cx.typeck_results().expr_ty(&unwrap_args[0]).peel_refs();
-
-    let mess = if is_type_diagnostic_item(cx, obj_ty, sym::option_type) {
-        Some((UNWRAP_USED, "an Option", "None"))
-    } else if is_type_diagnostic_item(cx, obj_ty, sym::result_type) {
-        Some((UNWRAP_USED, "a Result", "Err"))
-    } else {
-        None
-    };
-
-    if let Some((lint, kind, none_value)) = mess {
-        span_lint_and_help(
-            cx,
-            lint,
-            expr.span,
-            &format!("used `unwrap()` on `{}` value", kind,),
-            None,
-            &format!(
-                "if you don't want to handle the `{}` case gracefully, consider \
-                using `expect()` to provide a better panic message",
-                none_value,
-            ),
-        );
-    }
-}
-
-/// lint use of `expect()` for `Option`s and `Result`s
-fn lint_expect(cx: &LateContext<'_>, expr: &hir::Expr<'_>, expect_args: &[hir::Expr<'_>]) {
-    let obj_ty = cx.typeck_results().expr_ty(&expect_args[0]).peel_refs();
-
-    let mess = if is_type_diagnostic_item(cx, obj_ty, sym::option_type) {
-        Some((EXPECT_USED, "an Option", "None"))
-    } else if is_type_diagnostic_item(cx, obj_ty, sym::result_type) {
-        Some((EXPECT_USED, "a Result", "Err"))
-    } else {
-        None
-    };
-
-    if let Some((lint, kind, none_value)) = mess {
-        span_lint_and_help(
-            cx,
-            lint,
-            expr.span,
-            &format!("used `expect()` on `{}` value", kind,),
-            None,
-            &format!("if this value is an `{}`, it will panic", none_value,),
-        );
-    }
-}
-
-/// lint use of `ok().expect()` for `Result`s
-fn lint_ok_expect(cx: &LateContext<'_>, expr: &hir::Expr<'_>, ok_args: &[hir::Expr<'_>]) {
-    if_chain! {
-        // lint if the caller of `ok()` is a `Result`
-        if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&ok_args[0]), sym::result_type);
-        let result_type = cx.typeck_results().expr_ty(&ok_args[0]);
-        if let Some(error_type) = get_error_type(cx, result_type);
-        if has_debug_impl(error_type, cx);
-
-        then {
-            span_lint_and_help(
-                cx,
-                OK_EXPECT,
-                expr.span,
-                "called `ok().expect()` on a `Result` value",
-                None,
-                "you can call `expect()` directly on the `Result`",
-            );
-        }
-    }
-}
-
 /// lint use of `map().flatten()` for `Iterators` and 'Options'
 fn lint_map_flatten<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, map_args: &'tcx [hir::Expr<'_>]) {
     // lint if caller of `.map().flatten()` is an Iterator
@@ -3107,31 +2965,6 @@ fn lint_map_or_none<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, map
     );
 }
 
-/// lint use of `filter().next()` for `Iterators`
-fn lint_filter_next<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, filter_args: &'tcx [hir::Expr<'_>]) {
-    // lint if caller of `.filter().next()` is an Iterator
-    if match_trait_method(cx, expr, &paths::ITERATOR) {
-        let msg = "called `filter(..).next()` on an `Iterator`. This is more succinctly expressed by calling \
-                   `.find(..)` instead";
-        let filter_snippet = snippet(cx, filter_args[1].span, "..");
-        if filter_snippet.lines().count() <= 1 {
-            let iter_snippet = snippet(cx, filter_args[0].span, "..");
-            // add note if not multi-line
-            span_lint_and_sugg(
-                cx,
-                FILTER_NEXT,
-                expr.span,
-                msg,
-                "try this",
-                format!("{}.find({})", iter_snippet, filter_snippet),
-                Applicability::MachineApplicable,
-            );
-        } else {
-            span_lint(cx, FILTER_NEXT, expr.span, msg);
-        }
-    }
-}
-
 /// lint use of `skip_while().next()` for `Iterators`
 fn lint_skip_while_next<'tcx>(
     cx: &LateContext<'tcx>,
@@ -3914,21 +3747,6 @@ fn lint_map_collect(
     }
 }
 
-/// Given a `Result<T, E>` type, return its error type (`E`).
-fn get_error_type<'a>(cx: &LateContext<'_>, ty: Ty<'a>) -> Option<Ty<'a>> {
-    match ty.kind() {
-        ty::Adt(_, substs) if is_type_diagnostic_item(cx, ty, sym::result_type) => substs.types().nth(1),
-        _ => None,
-    }
-}
-
-/// This checks whether a given type is known to implement Debug.
-fn has_debug_impl<'tcx>(ty: Ty<'tcx>, cx: &LateContext<'tcx>) -> bool {
-    cx.tcx
-        .get_diagnostic_item(sym::debug_trait)
-        .map_or(false, |debug| implements_trait(cx, ty, debug, &[]))
-}
-
 enum Convention {
     Eq(&'static str),
     StartsWith(&'static str),
diff --git a/clippy_lints/src/methods/ok_expect.rs b/clippy_lints/src/methods/ok_expect.rs
new file mode 100644
index 00000000000..c1706cc7cc7
--- /dev/null
+++ b/clippy_lints/src/methods/ok_expect.rs
@@ -0,0 +1,45 @@
+use crate::utils::{implements_trait, is_type_diagnostic_item, span_lint_and_help};
+use if_chain::if_chain;
+use rustc_hir as hir;
+use rustc_lint::LateContext;
+use rustc_middle::ty::{self, Ty};
+use rustc_span::sym;
+
+use super::OK_EXPECT;
+
+/// lint use of `ok().expect()` for `Result`s
+pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, ok_args: &[hir::Expr<'_>]) {
+    if_chain! {
+        // lint if the caller of `ok()` is a `Result`
+        if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&ok_args[0]), sym::result_type);
+        let result_type = cx.typeck_results().expr_ty(&ok_args[0]);
+        if let Some(error_type) = get_error_type(cx, result_type);
+        if has_debug_impl(error_type, cx);
+
+        then {
+            span_lint_and_help(
+                cx,
+                OK_EXPECT,
+                expr.span,
+                "called `ok().expect()` on a `Result` value",
+                None,
+                "you can call `expect()` directly on the `Result`",
+            );
+        }
+    }
+}
+
+/// Given a `Result<T, E>` type, return its error type (`E`).
+fn get_error_type<'a>(cx: &LateContext<'_>, ty: Ty<'a>) -> Option<Ty<'a>> {
+    match ty.kind() {
+        ty::Adt(_, substs) if is_type_diagnostic_item(cx, ty, sym::result_type) => substs.types().nth(1),
+        _ => None,
+    }
+}
+
+/// This checks whether a given type is known to implement Debug.
+fn has_debug_impl<'tcx>(ty: Ty<'tcx>, cx: &LateContext<'tcx>) -> bool {
+    cx.tcx
+        .get_diagnostic_item(sym::debug_trait)
+        .map_or(false, |debug| implements_trait(cx, ty, debug, &[]))
+}
diff --git a/clippy_lints/src/methods/option_map_unwrap_or.rs b/clippy_lints/src/methods/option_map_unwrap_or.rs
index 7763fd5f113..7cdd49bbf03 100644
--- a/clippy_lints/src/methods/option_map_unwrap_or.rs
+++ b/clippy_lints/src/methods/option_map_unwrap_or.rs
@@ -12,7 +12,7 @@ use rustc_span::{sym, Symbol};
 use super::MAP_UNWRAP_OR;
 
 /// lint use of `map().unwrap_or()` for `Option`s
-pub(super) fn lint<'tcx>(
+pub(super) fn check<'tcx>(
     cx: &LateContext<'tcx>,
     expr: &rustc_hir::Expr<'_>,
     map_args: &'tcx [rustc_hir::Expr<'_>],
diff --git a/clippy_lints/src/methods/unnecessary_lazy_eval.rs b/clippy_lints/src/methods/unnecessary_lazy_eval.rs
index 40ccb8c80b3..a17259d697f 100644
--- a/clippy_lints/src/methods/unnecessary_lazy_eval.rs
+++ b/clippy_lints/src/methods/unnecessary_lazy_eval.rs
@@ -9,7 +9,7 @@ use super::UNNECESSARY_LAZY_EVALUATIONS;
 
 /// lint use of `<fn>_else(simple closure)` for `Option`s and `Result`s that can be
 /// replaced with `<fn>(return value of simple closure)`
-pub(super) fn lint<'tcx>(
+pub(super) fn check<'tcx>(
     cx: &LateContext<'tcx>,
     expr: &'tcx hir::Expr<'_>,
     args: &'tcx [hir::Expr<'_>],
diff --git a/clippy_lints/src/methods/unwrap_used.rs b/clippy_lints/src/methods/unwrap_used.rs
new file mode 100644
index 00000000000..094c3fc45c4
--- /dev/null
+++ b/clippy_lints/src/methods/unwrap_used.rs
@@ -0,0 +1,34 @@
+use crate::utils::{is_type_diagnostic_item, span_lint_and_help};
+use rustc_hir as hir;
+use rustc_lint::LateContext;
+use rustc_span::sym;
+
+use super::UNWRAP_USED;
+
+/// lint use of `unwrap()` for `Option`s and `Result`s
+pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, unwrap_args: &[hir::Expr<'_>]) {
+    let obj_ty = cx.typeck_results().expr_ty(&unwrap_args[0]).peel_refs();
+
+    let mess = if is_type_diagnostic_item(cx, obj_ty, sym::option_type) {
+        Some((UNWRAP_USED, "an Option", "None"))
+    } else if is_type_diagnostic_item(cx, obj_ty, sym::result_type) {
+        Some((UNWRAP_USED, "a Result", "Err"))
+    } else {
+        None
+    };
+
+    if let Some((lint, kind, none_value)) = mess {
+        span_lint_and_help(
+            cx,
+            lint,
+            expr.span,
+            &format!("used `unwrap()` on `{}` value", kind,),
+            None,
+            &format!(
+                "if you don't want to handle the `{}` case gracefully, consider \
+                using `expect()` to provide a better panic message",
+                none_value,
+            ),
+        );
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 483bac2dc0a47df87141a98df1d470b25cd2eda3 Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Wed, 3 Mar 2021 00:31:15 +0900
Subject: move skip_while_next to its own module

---
 clippy_lints/src/methods/mod.rs             | 22 ++--------------------
 clippy_lints/src/methods/skip_while_next.rs | 20 ++++++++++++++++++++
 2 files changed, 22 insertions(+), 20 deletions(-)
 create mode 100644 clippy_lints/src/methods/skip_while_next.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 71080e9bef0..34def45a8dd 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -11,6 +11,7 @@ mod iter_count;
 mod manual_saturating_arithmetic;
 mod ok_expect;
 mod option_map_unwrap_or;
+mod skip_while_next;
 mod unnecessary_filter_map;
 mod unnecessary_lazy_eval;
 mod unwrap_used;
@@ -1679,7 +1680,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
                 }
             },
             ["next", "filter"] => filter_next::check(cx, expr, arg_lists[1]),
-            ["next", "skip_while"] => lint_skip_while_next(cx, expr, arg_lists[1]),
+            ["next", "skip_while"] => skip_while_next::check(cx, expr, arg_lists[1]),
             ["next", "iter"] => lint_iter_next(cx, expr, arg_lists[1]),
             ["map", "filter"] => lint_filter_map(cx, expr, false),
             ["map", "filter_map"] => lint_filter_map_map(cx, expr, arg_lists[1], arg_lists[0]),
@@ -2965,25 +2966,6 @@ fn lint_map_or_none<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, map
     );
 }
 
-/// lint use of `skip_while().next()` for `Iterators`
-fn lint_skip_while_next<'tcx>(
-    cx: &LateContext<'tcx>,
-    expr: &'tcx hir::Expr<'_>,
-    _skip_while_args: &'tcx [hir::Expr<'_>],
-) {
-    // lint if caller of `.skip_while().next()` is an Iterator
-    if match_trait_method(cx, expr, &paths::ITERATOR) {
-        span_lint_and_help(
-            cx,
-            SKIP_WHILE_NEXT,
-            expr.span,
-            "called `skip_while(<p>).next()` on an `Iterator`",
-            None,
-            "this is more succinctly expressed by calling `.find(!<p>)` instead",
-        );
-    }
-}
-
 /// lint use of `filter().map()` or `find().map()` for `Iterators`
 fn lint_filter_map<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, is_find: bool) {
     if_chain! {
diff --git a/clippy_lints/src/methods/skip_while_next.rs b/clippy_lints/src/methods/skip_while_next.rs
new file mode 100644
index 00000000000..8ba6ae95200
--- /dev/null
+++ b/clippy_lints/src/methods/skip_while_next.rs
@@ -0,0 +1,20 @@
+use crate::utils::{match_trait_method, paths, span_lint_and_help};
+use rustc_hir as hir;
+use rustc_lint::LateContext;
+
+use super::SKIP_WHILE_NEXT;
+
+/// lint use of `skip_while().next()` for `Iterators`
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, _skip_while_args: &'tcx [hir::Expr<'_>]) {
+    // lint if caller of `.skip_while().next()` is an Iterator
+    if match_trait_method(cx, expr, &paths::ITERATOR) {
+        span_lint_and_help(
+            cx,
+            SKIP_WHILE_NEXT,
+            expr.span,
+            "called `skip_while(<p>).next()` on an `Iterator`",
+            None,
+            "this is more succinctly expressed by calling `.find(!<p>)` instead",
+        );
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 110dac7f58257a0186daf13688aa8b02fba67bdb Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Wed, 3 Mar 2021 00:43:27 +0900
Subject: move option_as_ref_deref to its own module

---
 clippy_lints/src/methods/mod.rs                 | 114 +---------------------
 clippy_lints/src/methods/option_as_ref_deref.rs | 122 ++++++++++++++++++++++++
 2 files changed, 125 insertions(+), 111 deletions(-)
 create mode 100644 clippy_lints/src/methods/option_as_ref_deref.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 34def45a8dd..c6b6ef34bc4 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -10,6 +10,7 @@ mod inspect_for_each;
 mod iter_count;
 mod manual_saturating_arithmetic;
 mod ok_expect;
+mod option_as_ref_deref;
 mod option_map_unwrap_or;
 mod skip_while_next;
 mod unnecessary_filter_map;
@@ -1725,10 +1726,10 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             },
             ["is_file", ..] => lint_filetype_is_file(cx, expr, arg_lists[0]),
             ["map", "as_ref"] => {
-                lint_option_as_ref_deref(cx, expr, arg_lists[1], arg_lists[0], false, self.msrv.as_ref())
+                option_as_ref_deref::check(cx, expr, arg_lists[1], arg_lists[0], false, self.msrv.as_ref())
             },
             ["map", "as_mut"] => {
-                lint_option_as_ref_deref(cx, expr, arg_lists[1], arg_lists[0], true, self.msrv.as_ref())
+                option_as_ref_deref::check(cx, expr, arg_lists[1], arg_lists[0], true, self.msrv.as_ref())
             },
             ["unwrap_or_else", ..] => unnecessary_lazy_eval::check(cx, expr, arg_lists[0], "unwrap_or"),
             ["get_or_insert_with", ..] => unnecessary_lazy_eval::check(cx, expr, arg_lists[0], "get_or_insert"),
@@ -3584,115 +3585,6 @@ fn lint_suspicious_map(cx: &LateContext<'_>, expr: &hir::Expr<'_>) {
     );
 }
 
-const OPTION_AS_REF_DEREF_MSRV: RustcVersion = RustcVersion::new(1, 40, 0);
-
-/// lint use of `_.as_ref().map(Deref::deref)` for `Option`s
-fn lint_option_as_ref_deref<'tcx>(
-    cx: &LateContext<'tcx>,
-    expr: &hir::Expr<'_>,
-    as_ref_args: &[hir::Expr<'_>],
-    map_args: &[hir::Expr<'_>],
-    is_mut: bool,
-    msrv: Option<&RustcVersion>,
-) {
-    if !meets_msrv(msrv, &OPTION_AS_REF_DEREF_MSRV) {
-        return;
-    }
-
-    let same_mutability = |m| (is_mut && m == &hir::Mutability::Mut) || (!is_mut && m == &hir::Mutability::Not);
-
-    let option_ty = cx.typeck_results().expr_ty(&as_ref_args[0]);
-    if !is_type_diagnostic_item(cx, option_ty, sym::option_type) {
-        return;
-    }
-
-    let deref_aliases: [&[&str]; 9] = [
-        &paths::DEREF_TRAIT_METHOD,
-        &paths::DEREF_MUT_TRAIT_METHOD,
-        &paths::CSTRING_AS_C_STR,
-        &paths::OS_STRING_AS_OS_STR,
-        &paths::PATH_BUF_AS_PATH,
-        &paths::STRING_AS_STR,
-        &paths::STRING_AS_MUT_STR,
-        &paths::VEC_AS_SLICE,
-        &paths::VEC_AS_MUT_SLICE,
-    ];
-
-    let is_deref = match map_args[1].kind {
-        hir::ExprKind::Path(ref expr_qpath) => cx
-            .qpath_res(expr_qpath, map_args[1].hir_id)
-            .opt_def_id()
-            .map_or(false, |fun_def_id| {
-                deref_aliases.iter().any(|path| match_def_path(cx, fun_def_id, path))
-            }),
-        hir::ExprKind::Closure(_, _, body_id, _, _) => {
-            let closure_body = cx.tcx.hir().body(body_id);
-            let closure_expr = remove_blocks(&closure_body.value);
-
-            match &closure_expr.kind {
-                hir::ExprKind::MethodCall(_, _, args, _) => {
-                    if_chain! {
-                        if args.len() == 1;
-                        if path_to_local_id(&args[0], closure_body.params[0].pat.hir_id);
-                        let adj = cx
-                            .typeck_results()
-                            .expr_adjustments(&args[0])
-                            .iter()
-                            .map(|x| &x.kind)
-                            .collect::<Box<[_]>>();
-                        if let [ty::adjustment::Adjust::Deref(None), ty::adjustment::Adjust::Borrow(_)] = *adj;
-                        then {
-                            let method_did = cx.typeck_results().type_dependent_def_id(closure_expr.hir_id).unwrap();
-                            deref_aliases.iter().any(|path| match_def_path(cx, method_did, path))
-                        } else {
-                            false
-                        }
-                    }
-                },
-                hir::ExprKind::AddrOf(hir::BorrowKind::Ref, m, ref inner) if same_mutability(m) => {
-                    if_chain! {
-                        if let hir::ExprKind::Unary(hir::UnOp::Deref, ref inner1) = inner.kind;
-                        if let hir::ExprKind::Unary(hir::UnOp::Deref, ref inner2) = inner1.kind;
-                        then {
-                            path_to_local_id(inner2, closure_body.params[0].pat.hir_id)
-                        } else {
-                            false
-                        }
-                    }
-                },
-                _ => false,
-            }
-        },
-        _ => false,
-    };
-
-    if is_deref {
-        let current_method = if is_mut {
-            format!(".as_mut().map({})", snippet(cx, map_args[1].span, ".."))
-        } else {
-            format!(".as_ref().map({})", snippet(cx, map_args[1].span, ".."))
-        };
-        let method_hint = if is_mut { "as_deref_mut" } else { "as_deref" };
-        let hint = format!("{}.{}()", snippet(cx, as_ref_args[0].span, ".."), method_hint);
-        let suggestion = format!("try using {} instead", method_hint);
-
-        let msg = format!(
-            "called `{0}` on an Option value. This can be done more directly \
-            by calling `{1}` instead",
-            current_method, hint
-        );
-        span_lint_and_sugg(
-            cx,
-            OPTION_AS_REF_DEREF,
-            expr.span,
-            &msg,
-            &suggestion,
-            hint,
-            Applicability::MachineApplicable,
-        );
-    }
-}
-
 fn lint_map_collect(
     cx: &LateContext<'_>,
     expr: &hir::Expr<'_>,
diff --git a/clippy_lints/src/methods/option_as_ref_deref.rs b/clippy_lints/src/methods/option_as_ref_deref.rs
new file mode 100644
index 00000000000..89067dbfe0e
--- /dev/null
+++ b/clippy_lints/src/methods/option_as_ref_deref.rs
@@ -0,0 +1,122 @@
+use crate::utils::{
+    is_type_diagnostic_item, match_def_path, meets_msrv, path_to_local_id, paths, remove_blocks, snippet,
+    span_lint_and_sugg,
+};
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir as hir;
+use rustc_lint::LateContext;
+use rustc_middle::ty;
+use rustc_semver::RustcVersion;
+use rustc_span::sym;
+
+use super::OPTION_AS_REF_DEREF;
+
+const OPTION_AS_REF_DEREF_MSRV: RustcVersion = RustcVersion::new(1, 40, 0);
+
+/// lint use of `_.as_ref().map(Deref::deref)` for `Option`s
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &hir::Expr<'_>,
+    as_ref_args: &[hir::Expr<'_>],
+    map_args: &[hir::Expr<'_>],
+    is_mut: bool,
+    msrv: Option<&RustcVersion>,
+) {
+    if !meets_msrv(msrv, &OPTION_AS_REF_DEREF_MSRV) {
+        return;
+    }
+
+    let same_mutability = |m| (is_mut && m == &hir::Mutability::Mut) || (!is_mut && m == &hir::Mutability::Not);
+
+    let option_ty = cx.typeck_results().expr_ty(&as_ref_args[0]);
+    if !is_type_diagnostic_item(cx, option_ty, sym::option_type) {
+        return;
+    }
+
+    let deref_aliases: [&[&str]; 9] = [
+        &paths::DEREF_TRAIT_METHOD,
+        &paths::DEREF_MUT_TRAIT_METHOD,
+        &paths::CSTRING_AS_C_STR,
+        &paths::OS_STRING_AS_OS_STR,
+        &paths::PATH_BUF_AS_PATH,
+        &paths::STRING_AS_STR,
+        &paths::STRING_AS_MUT_STR,
+        &paths::VEC_AS_SLICE,
+        &paths::VEC_AS_MUT_SLICE,
+    ];
+
+    let is_deref = match map_args[1].kind {
+        hir::ExprKind::Path(ref expr_qpath) => cx
+            .qpath_res(expr_qpath, map_args[1].hir_id)
+            .opt_def_id()
+            .map_or(false, |fun_def_id| {
+                deref_aliases.iter().any(|path| match_def_path(cx, fun_def_id, path))
+            }),
+        hir::ExprKind::Closure(_, _, body_id, _, _) => {
+            let closure_body = cx.tcx.hir().body(body_id);
+            let closure_expr = remove_blocks(&closure_body.value);
+
+            match &closure_expr.kind {
+                hir::ExprKind::MethodCall(_, _, args, _) => {
+                    if_chain! {
+                        if args.len() == 1;
+                        if path_to_local_id(&args[0], closure_body.params[0].pat.hir_id);
+                        let adj = cx
+                            .typeck_results()
+                            .expr_adjustments(&args[0])
+                            .iter()
+                            .map(|x| &x.kind)
+                            .collect::<Box<[_]>>();
+                        if let [ty::adjustment::Adjust::Deref(None), ty::adjustment::Adjust::Borrow(_)] = *adj;
+                        then {
+                            let method_did = cx.typeck_results().type_dependent_def_id(closure_expr.hir_id).unwrap();
+                            deref_aliases.iter().any(|path| match_def_path(cx, method_did, path))
+                        } else {
+                            false
+                        }
+                    }
+                },
+                hir::ExprKind::AddrOf(hir::BorrowKind::Ref, m, ref inner) if same_mutability(m) => {
+                    if_chain! {
+                        if let hir::ExprKind::Unary(hir::UnOp::Deref, ref inner1) = inner.kind;
+                        if let hir::ExprKind::Unary(hir::UnOp::Deref, ref inner2) = inner1.kind;
+                        then {
+                            path_to_local_id(inner2, closure_body.params[0].pat.hir_id)
+                        } else {
+                            false
+                        }
+                    }
+                },
+                _ => false,
+            }
+        },
+        _ => false,
+    };
+
+    if is_deref {
+        let current_method = if is_mut {
+            format!(".as_mut().map({})", snippet(cx, map_args[1].span, ".."))
+        } else {
+            format!(".as_ref().map({})", snippet(cx, map_args[1].span, ".."))
+        };
+        let method_hint = if is_mut { "as_deref_mut" } else { "as_deref" };
+        let hint = format!("{}.{}()", snippet(cx, as_ref_args[0].span, ".."), method_hint);
+        let suggestion = format!("try using {} instead", method_hint);
+
+        let msg = format!(
+            "called `{0}` on an Option value. This can be done more directly \
+            by calling `{1}` instead",
+            current_method, hint
+        );
+        span_lint_and_sugg(
+            cx,
+            OPTION_AS_REF_DEREF,
+            expr.span,
+            &msg,
+            &suggestion,
+            hint,
+            Applicability::MachineApplicable,
+        );
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 60a053725e5c5c3a78e3d0918ca00e9e98324a95 Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Wed, 3 Mar 2021 00:48:21 +0900
Subject: move suspicious_map to its own module

---
 clippy_lints/src/methods/mod.rs            | 14 ++------------
 clippy_lints/src/methods/suspicious_map.rs | 16 ++++++++++++++++
 2 files changed, 18 insertions(+), 12 deletions(-)
 create mode 100644 clippy_lints/src/methods/suspicious_map.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index c6b6ef34bc4..a807afb6051 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -13,6 +13,7 @@ mod ok_expect;
 mod option_as_ref_deref;
 mod option_map_unwrap_or;
 mod skip_while_next;
+mod suspicious_map;
 mod unnecessary_filter_map;
 mod unnecessary_lazy_eval;
 mod unwrap_used;
@@ -1716,7 +1717,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
                 unnecessary_filter_map::lint(cx, expr, arg_lists[0]);
                 filter_map_identity::check(cx, expr, arg_lists[0], method_spans[0]);
             },
-            ["count", "map"] => lint_suspicious_map(cx, expr),
+            ["count", "map"] => suspicious_map::check(cx, expr),
             ["assume_init"] => lint_maybe_uninit(cx, &arg_lists[0][0], expr),
             ["unwrap_or", arith @ ("checked_add" | "checked_sub" | "checked_mul")] => {
                 manual_saturating_arithmetic::lint(cx, expr, &arg_lists, &arith["checked_".len()..])
@@ -3574,17 +3575,6 @@ fn is_maybe_uninit_ty_valid(cx: &LateContext<'_>, ty: Ty<'_>) -> bool {
     }
 }
 
-fn lint_suspicious_map(cx: &LateContext<'_>, expr: &hir::Expr<'_>) {
-    span_lint_and_help(
-        cx,
-        SUSPICIOUS_MAP,
-        expr.span,
-        "this call to `map()` won't have an effect on the call to `count()`",
-        None,
-        "make sure you did not confuse `map` with `filter` or `for_each`",
-    );
-}
-
 fn lint_map_collect(
     cx: &LateContext<'_>,
     expr: &hir::Expr<'_>,
diff --git a/clippy_lints/src/methods/suspicious_map.rs b/clippy_lints/src/methods/suspicious_map.rs
new file mode 100644
index 00000000000..e135a826dc4
--- /dev/null
+++ b/clippy_lints/src/methods/suspicious_map.rs
@@ -0,0 +1,16 @@
+use crate::utils::span_lint_and_help;
+use rustc_hir as hir;
+use rustc_lint::LateContext;
+
+use super::SUSPICIOUS_MAP;
+
+pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>) {
+    span_lint_and_help(
+        cx,
+        SUSPICIOUS_MAP,
+        expr.span,
+        "this call to `map()` won't have an effect on the call to `count()`",
+        None,
+        "make sure you did not confuse `map` with `filter` or `for_each`",
+    );
+}
-- 
cgit 1.4.1-3-g733a5


From 8623b331eebfa097bb33dff1df5efa324e6a780a Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Wed, 3 Mar 2021 00:55:19 +0900
Subject: move filetype_is_file to its own module

---
 clippy_lints/src/methods/filetype_is_file.rs | 39 ++++++++++++++++++++++++++++
 clippy_lints/src/methods/mod.rs              | 35 ++-----------------------
 2 files changed, 41 insertions(+), 33 deletions(-)
 create mode 100644 clippy_lints/src/methods/filetype_is_file.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/filetype_is_file.rs b/clippy_lints/src/methods/filetype_is_file.rs
new file mode 100644
index 00000000000..b03835f97e6
--- /dev/null
+++ b/clippy_lints/src/methods/filetype_is_file.rs
@@ -0,0 +1,39 @@
+use crate::utils::{get_parent_expr, match_type, paths, span_lint_and_help};
+use if_chain::if_chain;
+use rustc_hir as hir;
+use rustc_lint::LateContext;
+use rustc_span::source_map::Span;
+
+use super::FILETYPE_IS_FILE;
+
+pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::Expr<'_>]) {
+    let ty = cx.typeck_results().expr_ty(&args[0]);
+
+    if !match_type(cx, ty, &paths::FILE_TYPE) {
+        return;
+    }
+
+    let span: Span;
+    let verb: &str;
+    let lint_unary: &str;
+    let help_unary: &str;
+    if_chain! {
+        if let Some(parent) = get_parent_expr(cx, expr);
+        if let hir::ExprKind::Unary(op, _) = parent.kind;
+        if op == hir::UnOp::Not;
+        then {
+            lint_unary = "!";
+            verb = "denies";
+            help_unary = "";
+            span = parent.span;
+        } else {
+            lint_unary = "";
+            verb = "covers";
+            help_unary = "!";
+            span = expr.span;
+        }
+    }
+    let lint_msg = format!("`{}FileType::is_file()` only {} regular files", lint_unary, verb);
+    let help_msg = format!("use `{}FileType::is_dir()` instead", help_unary);
+    span_lint_and_help(cx, FILETYPE_IS_FILE, span, &lint_msg, None, &help_msg);
+}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index a807afb6051..54a6a4cf934 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1,6 +1,7 @@
 mod bind_instead_of_map;
 mod bytes_nth;
 mod expect_used;
+mod filetype_is_file;
 mod filter_map_identity;
 mod filter_next;
 mod get_unwrap;
@@ -1725,7 +1726,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             ["add" | "offset" | "sub" | "wrapping_offset" | "wrapping_add" | "wrapping_sub"] => {
                 check_pointer_offset(cx, expr, arg_lists[0])
             },
-            ["is_file", ..] => lint_filetype_is_file(cx, expr, arg_lists[0]),
+            ["is_file", ..] => filetype_is_file::check(cx, expr, arg_lists[0]),
             ["map", "as_ref"] => {
                 option_as_ref_deref::check(cx, expr, arg_lists[1], arg_lists[0], false, self.msrv.as_ref())
             },
@@ -3859,38 +3860,6 @@ fn check_pointer_offset(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir:
     }
 }
 
-fn lint_filetype_is_file(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::Expr<'_>]) {
-    let ty = cx.typeck_results().expr_ty(&args[0]);
-
-    if !match_type(cx, ty, &paths::FILE_TYPE) {
-        return;
-    }
-
-    let span: Span;
-    let verb: &str;
-    let lint_unary: &str;
-    let help_unary: &str;
-    if_chain! {
-        if let Some(parent) = get_parent_expr(cx, expr);
-        if let hir::ExprKind::Unary(op, _) = parent.kind;
-        if op == hir::UnOp::Not;
-        then {
-            lint_unary = "!";
-            verb = "denies";
-            help_unary = "";
-            span = parent.span;
-        } else {
-            lint_unary = "";
-            verb = "covers";
-            help_unary = "!";
-            span = expr.span;
-        }
-    }
-    let lint_msg = format!("`{}FileType::is_file()` only {} regular files", lint_unary, verb);
-    let help_msg = format!("use `{}FileType::is_dir()` instead", help_unary);
-    span_lint_and_help(cx, FILETYPE_IS_FILE, span, &lint_msg, None, &help_msg);
-}
-
 fn lint_from_iter(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::Expr<'_>]) {
     let ty = cx.typeck_results().expr_ty(expr);
     let arg_ty = cx.typeck_results().expr_ty(&args[0]);
-- 
cgit 1.4.1-3-g733a5


From 35147d4cf342ee479d50afcb70aceab4ea506c2d Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Wed, 3 Mar 2021 01:03:47 +0900
Subject: move uninit_assumed_init to its own module

---
 clippy_lints/src/methods/mod.rs                 | 31 ++--------------------
 clippy_lints/src/methods/uninit_assumed_init.rs | 35 +++++++++++++++++++++++++
 2 files changed, 37 insertions(+), 29 deletions(-)
 create mode 100644 clippy_lints/src/methods/uninit_assumed_init.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 54a6a4cf934..acb8318970e 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -15,6 +15,7 @@ mod option_as_ref_deref;
 mod option_map_unwrap_or;
 mod skip_while_next;
 mod suspicious_map;
+mod uninit_assumed_init;
 mod unnecessary_filter_map;
 mod unnecessary_lazy_eval;
 mod unwrap_used;
@@ -1719,7 +1720,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
                 filter_map_identity::check(cx, expr, arg_lists[0], method_spans[0]);
             },
             ["count", "map"] => suspicious_map::check(cx, expr),
-            ["assume_init"] => lint_maybe_uninit(cx, &arg_lists[0][0], expr),
+            ["assume_init"] => uninit_assumed_init::check(cx, &arg_lists[0][0], expr),
             ["unwrap_or", arith @ ("checked_add" | "checked_sub" | "checked_mul")] => {
                 manual_saturating_arithmetic::lint(cx, expr, &arg_lists, &arith["checked_".len()..])
             },
@@ -3548,34 +3549,6 @@ fn lint_into_iter(cx: &LateContext<'_>, expr: &hir::Expr<'_>, self_ref_ty: Ty<'_
     }
 }
 
-/// lint for `MaybeUninit::uninit().assume_init()` (we already have the latter)
-fn lint_maybe_uninit(cx: &LateContext<'_>, expr: &hir::Expr<'_>, outer: &hir::Expr<'_>) {
-    if_chain! {
-        if let hir::ExprKind::Call(ref callee, ref args) = expr.kind;
-        if args.is_empty();
-        if let hir::ExprKind::Path(ref path) = callee.kind;
-        if match_qpath(path, &paths::MEM_MAYBEUNINIT_UNINIT);
-        if !is_maybe_uninit_ty_valid(cx, cx.typeck_results().expr_ty_adjusted(outer));
-        then {
-            span_lint(
-                cx,
-                UNINIT_ASSUMED_INIT,
-                outer.span,
-                "this call for this type may be undefined behavior"
-            );
-        }
-    }
-}
-
-fn is_maybe_uninit_ty_valid(cx: &LateContext<'_>, ty: Ty<'_>) -> bool {
-    match ty.kind() {
-        ty::Array(ref component, _) => is_maybe_uninit_ty_valid(cx, component),
-        ty::Tuple(ref types) => types.types().all(|ty| is_maybe_uninit_ty_valid(cx, ty)),
-        ty::Adt(ref adt, _) => match_def_path(cx, adt.did, &paths::MEM_MAYBEUNINIT),
-        _ => false,
-    }
-}
-
 fn lint_map_collect(
     cx: &LateContext<'_>,
     expr: &hir::Expr<'_>,
diff --git a/clippy_lints/src/methods/uninit_assumed_init.rs b/clippy_lints/src/methods/uninit_assumed_init.rs
new file mode 100644
index 00000000000..798b66192c8
--- /dev/null
+++ b/clippy_lints/src/methods/uninit_assumed_init.rs
@@ -0,0 +1,35 @@
+use crate::utils::{match_def_path, match_qpath, paths, span_lint};
+use if_chain::if_chain;
+use rustc_hir as hir;
+use rustc_lint::LateContext;
+use rustc_middle::ty::{self, Ty};
+
+use super::UNINIT_ASSUMED_INIT;
+
+/// lint for `MaybeUninit::uninit().assume_init()` (we already have the latter)
+pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, outer: &hir::Expr<'_>) {
+    if_chain! {
+        if let hir::ExprKind::Call(ref callee, ref args) = expr.kind;
+        if args.is_empty();
+        if let hir::ExprKind::Path(ref path) = callee.kind;
+        if match_qpath(path, &paths::MEM_MAYBEUNINIT_UNINIT);
+        if !is_maybe_uninit_ty_valid(cx, cx.typeck_results().expr_ty_adjusted(outer));
+        then {
+            span_lint(
+                cx,
+                UNINIT_ASSUMED_INIT,
+                outer.span,
+                "this call for this type may be undefined behavior"
+            );
+        }
+    }
+}
+
+fn is_maybe_uninit_ty_valid(cx: &LateContext<'_>, ty: Ty<'_>) -> bool {
+    match ty.kind() {
+        ty::Array(ref component, _) => is_maybe_uninit_ty_valid(cx, component),
+        ty::Tuple(ref types) => types.types().all(|ty| is_maybe_uninit_ty_valid(cx, ty)),
+        ty::Adt(ref adt, _) => match_def_path(cx, adt.did, &paths::MEM_MAYBEUNINIT),
+        _ => false,
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 45ee914df0c1d1a6a15272bd6833023dd4185b9b Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Wed, 3 Mar 2021 01:09:33 +0900
Subject: move iter_cloned_collect to its own module

---
 clippy_lints/src/methods/iter_cloned_collect.rs | 30 +++++++++++++++++++++++++
 clippy_lints/src/methods/mod.rs                 | 24 ++------------------
 2 files changed, 32 insertions(+), 22 deletions(-)
 create mode 100644 clippy_lints/src/methods/iter_cloned_collect.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/iter_cloned_collect.rs b/clippy_lints/src/methods/iter_cloned_collect.rs
new file mode 100644
index 00000000000..c3e48ffa5fa
--- /dev/null
+++ b/clippy_lints/src/methods/iter_cloned_collect.rs
@@ -0,0 +1,30 @@
+use crate::methods::derefs_to_slice;
+use crate::utils::{is_type_diagnostic_item, span_lint_and_sugg};
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir as hir;
+use rustc_lint::LateContext;
+use rustc_span::sym;
+
+use super::ITER_CLONED_COLLECT;
+
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &hir::Expr<'_>, iter_args: &'tcx [hir::Expr<'_>]) {
+    if_chain! {
+        if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(expr), sym::vec_type);
+        if let Some(slice) = derefs_to_slice(cx, &iter_args[0], cx.typeck_results().expr_ty(&iter_args[0]));
+        if let Some(to_replace) = expr.span.trim_start(slice.span.source_callsite());
+
+        then {
+            span_lint_and_sugg(
+                cx,
+                ITER_CLONED_COLLECT,
+                to_replace,
+                "called `iter().cloned().collect()` on a slice to create a `Vec`. Calling `to_vec()` is both faster and \
+                more readable",
+                "try",
+                ".to_vec()".to_string(),
+                Applicability::MachineApplicable,
+            );
+        }
+    }
+}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index acb8318970e..92d8077c1ab 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -8,6 +8,7 @@ mod get_unwrap;
 mod implicit_clone;
 mod inefficient_to_string;
 mod inspect_for_each;
+mod iter_cloned_collect;
 mod iter_count;
 mod manual_saturating_arithmetic;
 mod ok_expect;
@@ -1711,7 +1712,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             ["nth", ..] => lint_iter_nth_zero(cx, expr, arg_lists[0]),
             ["step_by", ..] => lint_step_by(cx, expr, arg_lists[0]),
             ["next", "skip"] => lint_iter_skip_next(cx, expr, arg_lists[1]),
-            ["collect", "cloned"] => lint_iter_cloned_collect(cx, expr, arg_lists[1]),
+            ["collect", "cloned"] => iter_cloned_collect::check(cx, expr, arg_lists[1]),
             ["as_ref"] => lint_asref(cx, expr, "as_ref", arg_lists[0]),
             ["as_mut"] => lint_asref(cx, expr, "as_mut", arg_lists[0]),
             ["fold", ..] => lint_unnecessary_fold(cx, expr, arg_lists[0], method_spans[0]),
@@ -2494,27 +2495,6 @@ fn lint_extend(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::Expr<'_>
     }
 }
 
-fn lint_iter_cloned_collect<'tcx>(cx: &LateContext<'tcx>, expr: &hir::Expr<'_>, iter_args: &'tcx [hir::Expr<'_>]) {
-    if_chain! {
-        if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(expr), sym::vec_type);
-        if let Some(slice) = derefs_to_slice(cx, &iter_args[0], cx.typeck_results().expr_ty(&iter_args[0]));
-        if let Some(to_replace) = expr.span.trim_start(slice.span.source_callsite());
-
-        then {
-            span_lint_and_sugg(
-                cx,
-                ITER_CLONED_COLLECT,
-                to_replace,
-                "called `iter().cloned().collect()` on a slice to create a `Vec`. Calling `to_vec()` is both faster and \
-                more readable",
-                "try",
-                ".to_vec()".to_string(),
-                Applicability::MachineApplicable,
-            );
-        }
-    }
-}
-
 fn lint_unnecessary_fold(cx: &LateContext<'_>, expr: &hir::Expr<'_>, fold_args: &[hir::Expr<'_>], fold_span: Span) {
     fn check_fold_with_op(
         cx: &LateContext<'_>,
-- 
cgit 1.4.1-3-g733a5


From 6376da70be18d6cb9dbe22b5a661896cf916bc51 Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Wed, 3 Mar 2021 01:16:16 +0900
Subject: replace `lints` and `lint` with `check`

---
 clippy_lints/src/methods/bind_instead_of_map.rs    |  2 +-
 clippy_lints/src/methods/bytes_nth.rs              |  2 +-
 clippy_lints/src/methods/inefficient_to_string.rs  |  2 +-
 clippy_lints/src/methods/inspect_for_each.rs       |  2 +-
 clippy_lints/src/methods/iter_count.rs             |  2 +-
 .../src/methods/manual_saturating_arithmetic.rs    |  2 +-
 clippy_lints/src/methods/mod.rs                    | 22 +++++++++++-----------
 clippy_lints/src/methods/unnecessary_filter_map.rs |  2 +-
 8 files changed, 18 insertions(+), 18 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/bind_instead_of_map.rs b/clippy_lints/src/methods/bind_instead_of_map.rs
index 540a1484a85..5decb81d9f2 100644
--- a/clippy_lints/src/methods/bind_instead_of_map.rs
+++ b/clippy_lints/src/methods/bind_instead_of_map.rs
@@ -158,7 +158,7 @@ pub(crate) trait BindInsteadOfMap {
     }
 
     /// Lint use of `_.and_then(|x| Some(y))` for `Option`s
-    fn lint(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::Expr<'_>]) -> bool {
+    fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::Expr<'_>]) -> bool {
         if !match_type(cx, cx.typeck_results().expr_ty(&args[0]), Self::TYPE_QPATH) {
             return false;
         }
diff --git a/clippy_lints/src/methods/bytes_nth.rs b/clippy_lints/src/methods/bytes_nth.rs
index defc50ede22..71a7e195e41 100644
--- a/clippy_lints/src/methods/bytes_nth.rs
+++ b/clippy_lints/src/methods/bytes_nth.rs
@@ -7,7 +7,7 @@ use rustc_span::sym;
 
 use super::BYTES_NTH;
 
-pub(super) fn lints<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, iter_args: &'tcx [Expr<'tcx>]) {
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, iter_args: &'tcx [Expr<'tcx>]) {
     if_chain! {
         if let ExprKind::MethodCall(_, _, ref args, _) = expr.kind;
         let ty = cx.typeck_results().expr_ty(&iter_args[0]).peel_refs();
diff --git a/clippy_lints/src/methods/inefficient_to_string.rs b/clippy_lints/src/methods/inefficient_to_string.rs
index c83b6f2c329..3045b09c238 100644
--- a/clippy_lints/src/methods/inefficient_to_string.rs
+++ b/clippy_lints/src/methods/inefficient_to_string.rs
@@ -10,7 +10,7 @@ use rustc_middle::ty::{self, Ty};
 use rustc_span::sym;
 
 /// Checks for the `INEFFICIENT_TO_STRING` lint
-pub fn lint<'tcx>(cx: &LateContext<'tcx>, expr: &hir::Expr<'_>, arg: &hir::Expr<'_>, arg_ty: Ty<'tcx>) {
+pub fn check<'tcx>(cx: &LateContext<'tcx>, expr: &hir::Expr<'_>, arg: &hir::Expr<'_>, arg_ty: Ty<'tcx>) {
     if_chain! {
         if let Some(to_string_meth_did) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
         if match_def_path(cx, to_string_meth_did, &paths::TO_STRING_METHOD);
diff --git a/clippy_lints/src/methods/inspect_for_each.rs b/clippy_lints/src/methods/inspect_for_each.rs
index 6d41ee38a27..959457a5bfc 100644
--- a/clippy_lints/src/methods/inspect_for_each.rs
+++ b/clippy_lints/src/methods/inspect_for_each.rs
@@ -7,7 +7,7 @@ use crate::utils::{match_trait_method, paths, span_lint_and_help};
 use super::INSPECT_FOR_EACH;
 
 /// lint use of `inspect().for_each()` for `Iterators`
-pub(super) fn lint<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, inspect_span: Span) {
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, inspect_span: Span) {
     if match_trait_method(cx, expr, &paths::ITERATOR) {
         let msg = "called `inspect(..).for_each(..)` on an `Iterator`";
         let hint = "move the code from `inspect(..)` to `for_each(..)` and remove the `inspect(..)`";
diff --git a/clippy_lints/src/methods/iter_count.rs b/clippy_lints/src/methods/iter_count.rs
index 71d65a01d3e..869440e0165 100644
--- a/clippy_lints/src/methods/iter_count.rs
+++ b/clippy_lints/src/methods/iter_count.rs
@@ -8,7 +8,7 @@ use rustc_span::sym;
 
 use super::ITER_COUNT;
 
-pub(crate) fn lints<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, iter_args: &'tcx [Expr<'tcx>], iter_method: &str) {
+pub(crate) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, iter_args: &'tcx [Expr<'tcx>], iter_method: &str) {
     let ty = cx.typeck_results().expr_ty(&iter_args[0]);
     let caller_type = if derefs_to_slice(cx, &iter_args[0], ty).is_some() {
         "slice"
diff --git a/clippy_lints/src/methods/manual_saturating_arithmetic.rs b/clippy_lints/src/methods/manual_saturating_arithmetic.rs
index eaa604c2ae6..0b414e0eb95 100644
--- a/clippy_lints/src/methods/manual_saturating_arithmetic.rs
+++ b/clippy_lints/src/methods/manual_saturating_arithmetic.rs
@@ -6,7 +6,7 @@ use rustc_hir as hir;
 use rustc_lint::LateContext;
 use rustc_target::abi::LayoutOf;
 
-pub fn lint(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[&[hir::Expr<'_>]], arith: &str) {
+pub fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[&[hir::Expr<'_>]], arith: &str) {
     let unwrap_arg = &args[0][1];
     let arith_lhs = &args[1][0];
     let arith_rhs = &args[1][1];
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 92d8077c1ab..639d013f786 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1673,14 +1673,14 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             },
             ["map_or", ..] => lint_map_or_none(cx, expr, arg_lists[0]),
             ["and_then", ..] => {
-                let biom_option_linted = bind_instead_of_map::OptionAndThenSome::lint(cx, expr, arg_lists[0]);
-                let biom_result_linted = bind_instead_of_map::ResultAndThenOk::lint(cx, expr, arg_lists[0]);
+                let biom_option_linted = bind_instead_of_map::OptionAndThenSome::check(cx, expr, arg_lists[0]);
+                let biom_result_linted = bind_instead_of_map::ResultAndThenOk::check(cx, expr, arg_lists[0]);
                 if !biom_option_linted && !biom_result_linted {
                     unnecessary_lazy_eval::check(cx, expr, arg_lists[0], "and");
                 }
             },
             ["or_else", ..] => {
-                if !bind_instead_of_map::ResultOrElseErrInfo::lint(cx, expr, arg_lists[0]) {
+                if !bind_instead_of_map::ResultOrElseErrInfo::check(cx, expr, arg_lists[0]) {
                     unnecessary_lazy_eval::check(cx, expr, arg_lists[0], "or");
                 }
             },
@@ -1703,12 +1703,12 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
                 lint_search_is_some(cx, expr, "rposition", arg_lists[1], arg_lists[0], method_spans[1])
             },
             ["extend", ..] => lint_extend(cx, expr, arg_lists[0]),
-            ["count", "into_iter"] => iter_count::lints(cx, expr, &arg_lists[1], "into_iter"),
-            ["count", "iter"] => iter_count::lints(cx, expr, &arg_lists[1], "iter"),
-            ["count", "iter_mut"] => iter_count::lints(cx, expr, &arg_lists[1], "iter_mut"),
+            ["count", "into_iter"] => iter_count::check(cx, expr, &arg_lists[1], "into_iter"),
+            ["count", "iter"] => iter_count::check(cx, expr, &arg_lists[1], "iter"),
+            ["count", "iter_mut"] => iter_count::check(cx, expr, &arg_lists[1], "iter_mut"),
             ["nth", "iter"] => lint_iter_nth(cx, expr, &arg_lists, false),
             ["nth", "iter_mut"] => lint_iter_nth(cx, expr, &arg_lists, true),
-            ["nth", "bytes"] => bytes_nth::lints(cx, expr, &arg_lists[1]),
+            ["nth", "bytes"] => bytes_nth::check(cx, expr, &arg_lists[1]),
             ["nth", ..] => lint_iter_nth_zero(cx, expr, arg_lists[0]),
             ["step_by", ..] => lint_step_by(cx, expr, arg_lists[0]),
             ["next", "skip"] => lint_iter_skip_next(cx, expr, arg_lists[1]),
@@ -1717,13 +1717,13 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             ["as_mut"] => lint_asref(cx, expr, "as_mut", arg_lists[0]),
             ["fold", ..] => lint_unnecessary_fold(cx, expr, arg_lists[0], method_spans[0]),
             ["filter_map", ..] => {
-                unnecessary_filter_map::lint(cx, expr, arg_lists[0]);
+                unnecessary_filter_map::check(cx, expr, arg_lists[0]);
                 filter_map_identity::check(cx, expr, arg_lists[0], method_spans[0]);
             },
             ["count", "map"] => suspicious_map::check(cx, expr),
             ["assume_init"] => uninit_assumed_init::check(cx, &arg_lists[0][0], expr),
             ["unwrap_or", arith @ ("checked_add" | "checked_sub" | "checked_mul")] => {
-                manual_saturating_arithmetic::lint(cx, expr, &arg_lists, &arith["checked_".len()..])
+                manual_saturating_arithmetic::check(cx, expr, &arg_lists, &arith["checked_".len()..])
             },
             ["add" | "offset" | "sub" | "wrapping_offset" | "wrapping_add" | "wrapping_sub"] => {
                 check_pointer_offset(cx, expr, arg_lists[0])
@@ -1739,7 +1739,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             ["get_or_insert_with", ..] => unnecessary_lazy_eval::check(cx, expr, arg_lists[0], "get_or_insert"),
             ["ok_or_else", ..] => unnecessary_lazy_eval::check(cx, expr, arg_lists[0], "ok_or"),
             ["collect", "map"] => lint_map_collect(cx, expr, arg_lists[1], arg_lists[0]),
-            ["for_each", "inspect"] => inspect_for_each::lint(cx, expr, method_spans[1]),
+            ["for_each", "inspect"] => inspect_for_each::check(cx, expr, method_spans[1]),
             ["to_owned", ..] => implicit_clone::check(cx, expr, sym::ToOwned),
             ["to_os_string", ..] => implicit_clone::check(cx, expr, sym::OsStr),
             ["to_path_buf", ..] => implicit_clone::check(cx, expr, sym::Path),
@@ -1765,7 +1765,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
                     lint_clone_on_ref_ptr(cx, expr, &args[0]);
                 }
                 if args.len() == 1 && method_call.ident.name == sym!(to_string) {
-                    inefficient_to_string::lint(cx, expr, &args[0], self_ty);
+                    inefficient_to_string::check(cx, expr, &args[0], self_ty);
                 }
 
                 if let Some(fn_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id) {
diff --git a/clippy_lints/src/methods/unnecessary_filter_map.rs b/clippy_lints/src/methods/unnecessary_filter_map.rs
index 5691fcb88e9..12b2cf0a165 100644
--- a/clippy_lints/src/methods/unnecessary_filter_map.rs
+++ b/clippy_lints/src/methods/unnecessary_filter_map.rs
@@ -9,7 +9,7 @@ use if_chain::if_chain;
 
 use super::UNNECESSARY_FILTER_MAP;
 
-pub(super) fn lint(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::Expr<'_>]) {
+pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::Expr<'_>]) {
     if !match_trait_method(cx, expr, &paths::ITERATOR) {
         return;
     }
-- 
cgit 1.4.1-3-g733a5


From 9b0a42b67d66cb79bdd09379d0b0e7959fc1505a Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Thu, 4 Mar 2021 19:46:44 +0900
Subject: move zst_offset to its own module

---
 clippy_lints/src/methods/mod.rs        | 15 ++-------------
 clippy_lints/src/methods/zst_offset.rs | 19 +++++++++++++++++++
 2 files changed, 21 insertions(+), 13 deletions(-)
 create mode 100644 clippy_lints/src/methods/zst_offset.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 639d013f786..c944568dc61 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -20,6 +20,7 @@ mod uninit_assumed_init;
 mod unnecessary_filter_map;
 mod unnecessary_lazy_eval;
 mod unwrap_used;
+mod zst_offset;
 
 use std::borrow::Cow;
 use std::fmt;
@@ -1726,7 +1727,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
                 manual_saturating_arithmetic::check(cx, expr, &arg_lists, &arith["checked_".len()..])
             },
             ["add" | "offset" | "sub" | "wrapping_offset" | "wrapping_add" | "wrapping_sub"] => {
-                check_pointer_offset(cx, expr, arg_lists[0])
+                zst_offset::check(cx, expr, arg_lists[0])
             },
             ["is_file", ..] => filetype_is_file::check(cx, expr, arg_lists[0]),
             ["map", "as_ref"] => {
@@ -3801,18 +3802,6 @@ fn is_bool(ty: &hir::Ty<'_>) -> bool {
     }
 }
 
-fn check_pointer_offset(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::Expr<'_>]) {
-    if_chain! {
-        if args.len() == 2;
-        if let ty::RawPtr(ty::TypeAndMut { ref ty, .. }) = cx.typeck_results().expr_ty(&args[0]).kind();
-        if let Ok(layout) = cx.tcx.layout_of(cx.param_env.and(ty));
-        if layout.is_zst();
-        then {
-            span_lint(cx, ZST_OFFSET, expr.span, "offset calculation on zero-sized value");
-        }
-    }
-}
-
 fn lint_from_iter(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::Expr<'_>]) {
     let ty = cx.typeck_results().expr_ty(expr);
     let arg_ty = cx.typeck_results().expr_ty(&args[0]);
diff --git a/clippy_lints/src/methods/zst_offset.rs b/clippy_lints/src/methods/zst_offset.rs
new file mode 100644
index 00000000000..f1335726736
--- /dev/null
+++ b/clippy_lints/src/methods/zst_offset.rs
@@ -0,0 +1,19 @@
+use crate::utils::span_lint;
+use if_chain::if_chain;
+use rustc_hir as hir;
+use rustc_lint::LateContext;
+use rustc_middle::ty;
+
+use super::ZST_OFFSET;
+
+pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::Expr<'_>]) {
+    if_chain! {
+        if args.len() == 2;
+        if let ty::RawPtr(ty::TypeAndMut { ref ty, .. }) = cx.typeck_results().expr_ty(&args[0]).kind();
+        if let Ok(layout) = cx.tcx.layout_of(cx.param_env.and(ty));
+        if layout.is_zst();
+        then {
+            span_lint(cx, ZST_OFFSET, expr.span, "offset calculation on zero-sized value");
+        }
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From db91d9cf9a620cc258ab84a152a9333351ac166e Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Thu, 4 Mar 2021 19:47:06 +0900
Subject: move map_collect_result_unit to its own module

---
 .../src/methods/map_collect_result_unit.rs         | 45 ++++++++++++++++++++++
 clippy_lints/src/methods/mod.rs                    | 39 +------------------
 2 files changed, 47 insertions(+), 37 deletions(-)
 create mode 100644 clippy_lints/src/methods/map_collect_result_unit.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/map_collect_result_unit.rs b/clippy_lints/src/methods/map_collect_result_unit.rs
new file mode 100644
index 00000000000..5b20e268d9f
--- /dev/null
+++ b/clippy_lints/src/methods/map_collect_result_unit.rs
@@ -0,0 +1,45 @@
+use crate::utils::{is_type_diagnostic_item, match_trait_method, paths, snippet, span_lint_and_sugg};
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir as hir;
+use rustc_lint::LateContext;
+use rustc_middle::ty;
+use rustc_span::symbol::sym;
+
+use super::MAP_COLLECT_RESULT_UNIT;
+
+pub(super) fn check(
+    cx: &LateContext<'_>,
+    expr: &hir::Expr<'_>,
+    map_args: &[hir::Expr<'_>],
+    collect_args: &[hir::Expr<'_>],
+) {
+    if_chain! {
+        // called on Iterator
+        if let [map_expr] = collect_args;
+        if match_trait_method(cx, map_expr, &paths::ITERATOR);
+        // return of collect `Result<(),_>`
+        let collect_ret_ty = cx.typeck_results().expr_ty(expr);
+        if is_type_diagnostic_item(cx, collect_ret_ty, sym::result_type);
+        if let ty::Adt(_, substs) = collect_ret_ty.kind();
+        if let Some(result_t) = substs.types().next();
+        if result_t.is_unit();
+        // get parts for snippet
+        if let [iter, map_fn] = map_args;
+        then {
+            span_lint_and_sugg(
+                cx,
+                MAP_COLLECT_RESULT_UNIT,
+                expr.span,
+                "`.map().collect()` can be replaced with `.try_for_each()`",
+                "try this",
+                format!(
+                    "{}.try_for_each({})",
+                    snippet(cx, iter.span, ".."),
+                    snippet(cx, map_fn.span, "..")
+                ),
+                Applicability::MachineApplicable,
+            );
+        }
+    }
+}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index c944568dc61..baa342ab3bb 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -11,6 +11,7 @@ mod inspect_for_each;
 mod iter_cloned_collect;
 mod iter_count;
 mod manual_saturating_arithmetic;
+mod map_collect_result_unit;
 mod ok_expect;
 mod option_as_ref_deref;
 mod option_map_unwrap_or;
@@ -1739,7 +1740,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             ["unwrap_or_else", ..] => unnecessary_lazy_eval::check(cx, expr, arg_lists[0], "unwrap_or"),
             ["get_or_insert_with", ..] => unnecessary_lazy_eval::check(cx, expr, arg_lists[0], "get_or_insert"),
             ["ok_or_else", ..] => unnecessary_lazy_eval::check(cx, expr, arg_lists[0], "ok_or"),
-            ["collect", "map"] => lint_map_collect(cx, expr, arg_lists[1], arg_lists[0]),
+            ["collect", "map"] => map_collect_result_unit::check(cx, expr, arg_lists[1], arg_lists[0]),
             ["for_each", "inspect"] => inspect_for_each::check(cx, expr, method_spans[1]),
             ["to_owned", ..] => implicit_clone::check(cx, expr, sym::ToOwned),
             ["to_os_string", ..] => implicit_clone::check(cx, expr, sym::OsStr),
@@ -3530,42 +3531,6 @@ fn lint_into_iter(cx: &LateContext<'_>, expr: &hir::Expr<'_>, self_ref_ty: Ty<'_
     }
 }
 
-fn lint_map_collect(
-    cx: &LateContext<'_>,
-    expr: &hir::Expr<'_>,
-    map_args: &[hir::Expr<'_>],
-    collect_args: &[hir::Expr<'_>],
-) {
-    if_chain! {
-        // called on Iterator
-        if let [map_expr] = collect_args;
-        if match_trait_method(cx, map_expr, &paths::ITERATOR);
-        // return of collect `Result<(),_>`
-        let collect_ret_ty = cx.typeck_results().expr_ty(expr);
-        if is_type_diagnostic_item(cx, collect_ret_ty, sym::result_type);
-        if let ty::Adt(_, substs) = collect_ret_ty.kind();
-        if let Some(result_t) = substs.types().next();
-        if result_t.is_unit();
-        // get parts for snippet
-        if let [iter, map_fn] = map_args;
-        then {
-            span_lint_and_sugg(
-                cx,
-                MAP_COLLECT_RESULT_UNIT,
-                expr.span,
-                "`.map().collect()` can be replaced with `.try_for_each()`",
-                "try this",
-                format!(
-                    "{}.try_for_each({})",
-                    snippet(cx, iter.span, ".."),
-                    snippet(cx, map_fn.span, "..")
-                ),
-                Applicability::MachineApplicable,
-            );
-        }
-    }
-}
-
 enum Convention {
     Eq(&'static str),
     StartsWith(&'static str),
-- 
cgit 1.4.1-3-g733a5


From 3fe099ba8d2f6f4d085e7480f020f9f87e6b39e8 Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Thu, 4 Mar 2021 22:50:53 +0900
Subject: move iter_next_slice to its own module

---
 clippy_lints/src/methods/iter_next_slice.rs | 68 +++++++++++++++++++++++++++++
 clippy_lints/src/methods/mod.rs             | 66 +++-------------------------
 2 files changed, 73 insertions(+), 61 deletions(-)
 create mode 100644 clippy_lints/src/methods/iter_next_slice.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/iter_next_slice.rs b/clippy_lints/src/methods/iter_next_slice.rs
new file mode 100644
index 00000000000..3c03a949cfe
--- /dev/null
+++ b/clippy_lints/src/methods/iter_next_slice.rs
@@ -0,0 +1,68 @@
+use crate::methods::derefs_to_slice;
+use crate::utils::{get_parent_expr, higher, is_type_diagnostic_item, snippet_with_applicability, span_lint_and_sugg};
+use if_chain::if_chain;
+use rustc_ast::ast;
+use rustc_errors::Applicability;
+use rustc_hir as hir;
+use rustc_lint::LateContext;
+use rustc_middle::ty;
+use rustc_span::symbol::sym;
+
+use super::ITER_NEXT_SLICE;
+
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, iter_args: &'tcx [hir::Expr<'_>]) {
+    let caller_expr = &iter_args[0];
+
+    // Skip lint if the `iter().next()` expression is a for loop argument,
+    // since it is already covered by `&loops::ITER_NEXT_LOOP`
+    let mut parent_expr_opt = get_parent_expr(cx, expr);
+    while let Some(parent_expr) = parent_expr_opt {
+        if higher::for_loop(parent_expr).is_some() {
+            return;
+        }
+        parent_expr_opt = get_parent_expr(cx, parent_expr);
+    }
+
+    if derefs_to_slice(cx, caller_expr, cx.typeck_results().expr_ty(caller_expr)).is_some() {
+        // caller is a Slice
+        if_chain! {
+            if let hir::ExprKind::Index(ref caller_var, ref index_expr) = &caller_expr.kind;
+            if let Some(higher::Range { start: Some(start_expr), end: None, limits: ast::RangeLimits::HalfOpen })
+                = higher::range(index_expr);
+            if let hir::ExprKind::Lit(ref start_lit) = &start_expr.kind;
+            if let ast::LitKind::Int(start_idx, _) = start_lit.node;
+            then {
+                let mut applicability = Applicability::MachineApplicable;
+                span_lint_and_sugg(
+                    cx,
+                    ITER_NEXT_SLICE,
+                    expr.span,
+                    "using `.iter().next()` on a Slice without end index",
+                    "try calling",
+                    format!("{}.get({})", snippet_with_applicability(cx, caller_var.span, "..", &mut applicability), start_idx),
+                    applicability,
+                );
+            }
+        }
+    } else if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(caller_expr), sym::vec_type)
+        || matches!(
+            &cx.typeck_results().expr_ty(caller_expr).peel_refs().kind(),
+            ty::Array(_, _)
+        )
+    {
+        // caller is a Vec or an Array
+        let mut applicability = Applicability::MachineApplicable;
+        span_lint_and_sugg(
+            cx,
+            ITER_NEXT_SLICE,
+            expr.span,
+            "using `.iter().next()` on an array",
+            "try calling",
+            format!(
+                "{}.get(0)",
+                snippet_with_applicability(cx, caller_expr.span, "..", &mut applicability)
+            ),
+            applicability,
+        );
+    }
+}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index baa342ab3bb..46c9524af55 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -10,6 +10,7 @@ mod inefficient_to_string;
 mod inspect_for_each;
 mod iter_cloned_collect;
 mod iter_count;
+mod iter_next_slice;
 mod manual_saturating_arithmetic;
 mod map_collect_result_unit;
 mod ok_expect;
@@ -46,9 +47,9 @@ use crate::consts::{constant, Constant};
 use crate::utils::eager_or_lazy::is_lazyness_candidate;
 use crate::utils::usage::mutated_variables;
 use crate::utils::{
-    contains_return, contains_ty, get_parent_expr, get_trait_def_id, has_iter_method, higher, implements_trait,
-    in_macro, is_copy, is_expn_of, is_type_diagnostic_item, iter_input_pats, last_path_segment, match_def_path,
-    match_qpath, match_trait_method, match_type, meets_msrv, method_calls, method_chain_args, path_to_local_id, paths,
+    contains_return, contains_ty, get_parent_expr, get_trait_def_id, has_iter_method, implements_trait, in_macro,
+    is_copy, is_expn_of, is_type_diagnostic_item, iter_input_pats, last_path_segment, match_def_path, match_qpath,
+    match_trait_method, match_type, meets_msrv, method_calls, method_chain_args, path_to_local_id, paths,
     remove_blocks, return_ty, single_segment_path, snippet, snippet_with_applicability, snippet_with_macro_callsite,
     span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then, strip_pat_refs, sugg, walk_ptrs_ty_depth,
     SpanlessEq,
@@ -1688,7 +1689,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             },
             ["next", "filter"] => filter_next::check(cx, expr, arg_lists[1]),
             ["next", "skip_while"] => skip_while_next::check(cx, expr, arg_lists[1]),
-            ["next", "iter"] => lint_iter_next(cx, expr, arg_lists[1]),
+            ["next", "iter"] => iter_next_slice::check(cx, expr, arg_lists[1]),
             ["map", "filter"] => lint_filter_map(cx, expr, false),
             ["map", "filter_map"] => lint_filter_map_map(cx, expr, arg_lists[1], arg_lists[0]),
             ["next", "filter_map"] => lint_filter_map_next(cx, expr, arg_lists[1], self.msrv.as_ref()),
@@ -2598,63 +2599,6 @@ fn lint_step_by<'tcx>(cx: &LateContext<'tcx>, expr: &hir::Expr<'_>, args: &'tcx
     }
 }
 
-fn lint_iter_next<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, iter_args: &'tcx [hir::Expr<'_>]) {
-    let caller_expr = &iter_args[0];
-
-    // Skip lint if the `iter().next()` expression is a for loop argument,
-    // since it is already covered by `&loops::ITER_NEXT_LOOP`
-    let mut parent_expr_opt = get_parent_expr(cx, expr);
-    while let Some(parent_expr) = parent_expr_opt {
-        if higher::for_loop(parent_expr).is_some() {
-            return;
-        }
-        parent_expr_opt = get_parent_expr(cx, parent_expr);
-    }
-
-    if derefs_to_slice(cx, caller_expr, cx.typeck_results().expr_ty(caller_expr)).is_some() {
-        // caller is a Slice
-        if_chain! {
-            if let hir::ExprKind::Index(ref caller_var, ref index_expr) = &caller_expr.kind;
-            if let Some(higher::Range { start: Some(start_expr), end: None, limits: ast::RangeLimits::HalfOpen })
-                = higher::range(index_expr);
-            if let hir::ExprKind::Lit(ref start_lit) = &start_expr.kind;
-            if let ast::LitKind::Int(start_idx, _) = start_lit.node;
-            then {
-                let mut applicability = Applicability::MachineApplicable;
-                span_lint_and_sugg(
-                    cx,
-                    ITER_NEXT_SLICE,
-                    expr.span,
-                    "using `.iter().next()` on a Slice without end index",
-                    "try calling",
-                    format!("{}.get({})", snippet_with_applicability(cx, caller_var.span, "..", &mut applicability), start_idx),
-                    applicability,
-                );
-            }
-        }
-    } else if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(caller_expr), sym::vec_type)
-        || matches!(
-            &cx.typeck_results().expr_ty(caller_expr).peel_refs().kind(),
-            ty::Array(_, _)
-        )
-    {
-        // caller is a Vec or an Array
-        let mut applicability = Applicability::MachineApplicable;
-        span_lint_and_sugg(
-            cx,
-            ITER_NEXT_SLICE,
-            expr.span,
-            "using `.iter().next()` on an array",
-            "try calling",
-            format!(
-                "{}.get(0)",
-                snippet_with_applicability(cx, caller_expr.span, "..", &mut applicability)
-            ),
-            applicability,
-        );
-    }
-}
-
 fn lint_iter_nth<'tcx>(
     cx: &LateContext<'tcx>,
     expr: &hir::Expr<'_>,
-- 
cgit 1.4.1-3-g733a5


From 5912ca986c52041d01384393cbf2da10270738ee Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Thu, 4 Mar 2021 23:06:05 +0900
Subject: move iter_nth, iter_nth_zero and iterator_step_by_zero to their own
 module

---
 clippy_lints/src/methods/iter_nth.rs              | 38 ++++++++++++
 clippy_lints/src/methods/iter_nth_zero.rs         | 27 +++++++++
 clippy_lints/src/methods/iterator_step_by_zero.rs | 19 ++++++
 clippy_lints/src/methods/mod.rs                   | 74 +++--------------------
 4 files changed, 91 insertions(+), 67 deletions(-)
 create mode 100644 clippy_lints/src/methods/iter_nth.rs
 create mode 100644 clippy_lints/src/methods/iter_nth_zero.rs
 create mode 100644 clippy_lints/src/methods/iterator_step_by_zero.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/iter_nth.rs b/clippy_lints/src/methods/iter_nth.rs
new file mode 100644
index 00000000000..c8adea9536b
--- /dev/null
+++ b/clippy_lints/src/methods/iter_nth.rs
@@ -0,0 +1,38 @@
+use crate::methods::derefs_to_slice;
+use crate::methods::iter_nth_zero;
+use crate::utils::{is_type_diagnostic_item, span_lint_and_help};
+use rustc_hir as hir;
+use rustc_lint::LateContext;
+use rustc_span::symbol::sym;
+
+use super::ITER_NTH;
+
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &hir::Expr<'_>,
+    nth_and_iter_args: &[&'tcx [hir::Expr<'tcx>]],
+    is_mut: bool,
+) {
+    let iter_args = nth_and_iter_args[1];
+    let mut_str = if is_mut { "_mut" } else { "" };
+    let caller_type = if derefs_to_slice(cx, &iter_args[0], cx.typeck_results().expr_ty(&iter_args[0])).is_some() {
+        "slice"
+    } else if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&iter_args[0]), sym::vec_type) {
+        "Vec"
+    } else if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&iter_args[0]), sym!(vecdeque_type)) {
+        "VecDeque"
+    } else {
+        let nth_args = nth_and_iter_args[0];
+        iter_nth_zero::check(cx, expr, &nth_args);
+        return; // caller is not a type that we want to lint
+    };
+
+    span_lint_and_help(
+        cx,
+        ITER_NTH,
+        expr.span,
+        &format!("called `.iter{0}().nth()` on a {1}", mut_str, caller_type),
+        None,
+        &format!("calling `.get{}()` is both faster and more readable", mut_str),
+    );
+}
diff --git a/clippy_lints/src/methods/iter_nth_zero.rs b/clippy_lints/src/methods/iter_nth_zero.rs
new file mode 100644
index 00000000000..247192d81f3
--- /dev/null
+++ b/clippy_lints/src/methods/iter_nth_zero.rs
@@ -0,0 +1,27 @@
+use crate::consts::{constant, Constant};
+use crate::utils::{match_trait_method, paths, snippet_with_applicability, span_lint_and_sugg};
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir as hir;
+use rustc_lint::LateContext;
+
+use super::ITER_NTH_ZERO;
+
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &hir::Expr<'_>, nth_args: &'tcx [hir::Expr<'_>]) {
+    if_chain! {
+        if match_trait_method(cx, expr, &paths::ITERATOR);
+        if let Some((Constant::Int(0), _)) = constant(cx, cx.typeck_results(), &nth_args[1]);
+        then {
+            let mut applicability = Applicability::MachineApplicable;
+            span_lint_and_sugg(
+                cx,
+                ITER_NTH_ZERO,
+                expr.span,
+                "called `.nth(0)` on a `std::iter::Iterator`, when `.next()` is equivalent",
+                "try calling `.next()` instead of `.nth(0)`",
+                format!("{}.next()", snippet_with_applicability(cx, nth_args[0].span, "..", &mut applicability)),
+                applicability,
+            );
+        }
+    }
+}
diff --git a/clippy_lints/src/methods/iterator_step_by_zero.rs b/clippy_lints/src/methods/iterator_step_by_zero.rs
new file mode 100644
index 00000000000..3e05d7f76b7
--- /dev/null
+++ b/clippy_lints/src/methods/iterator_step_by_zero.rs
@@ -0,0 +1,19 @@
+use crate::consts::{constant, Constant};
+use crate::utils::{match_trait_method, paths, span_lint};
+use rustc_hir as hir;
+use rustc_lint::LateContext;
+
+use super::ITERATOR_STEP_BY_ZERO;
+
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &hir::Expr<'_>, args: &'tcx [hir::Expr<'_>]) {
+    if match_trait_method(cx, expr, &paths::ITERATOR) {
+        if let Some((Constant::Int(0), _)) = constant(cx, cx.typeck_results(), &args[1]) {
+            span_lint(
+                cx,
+                ITERATOR_STEP_BY_ZERO,
+                expr.span,
+                "`Iterator::step_by(0)` will panic at runtime",
+            );
+        }
+    }
+}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 46c9524af55..259d370550c 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -11,6 +11,9 @@ mod inspect_for_each;
 mod iter_cloned_collect;
 mod iter_count;
 mod iter_next_slice;
+mod iter_nth;
+mod iter_nth_zero;
+mod iterator_step_by_zero;
 mod manual_saturating_arithmetic;
 mod map_collect_result_unit;
 mod ok_expect;
@@ -43,7 +46,6 @@ use rustc_span::source_map::Span;
 use rustc_span::symbol::{sym, Symbol, SymbolStr};
 use rustc_typeck::hir_ty_to_ty;
 
-use crate::consts::{constant, Constant};
 use crate::utils::eager_or_lazy::is_lazyness_candidate;
 use crate::utils::usage::mutated_variables;
 use crate::utils::{
@@ -1709,11 +1711,11 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             ["count", "into_iter"] => iter_count::check(cx, expr, &arg_lists[1], "into_iter"),
             ["count", "iter"] => iter_count::check(cx, expr, &arg_lists[1], "iter"),
             ["count", "iter_mut"] => iter_count::check(cx, expr, &arg_lists[1], "iter_mut"),
-            ["nth", "iter"] => lint_iter_nth(cx, expr, &arg_lists, false),
-            ["nth", "iter_mut"] => lint_iter_nth(cx, expr, &arg_lists, true),
+            ["nth", "iter"] => iter_nth::check(cx, expr, &arg_lists, false),
+            ["nth", "iter_mut"] => iter_nth::check(cx, expr, &arg_lists, true),
             ["nth", "bytes"] => bytes_nth::check(cx, expr, &arg_lists[1]),
-            ["nth", ..] => lint_iter_nth_zero(cx, expr, arg_lists[0]),
-            ["step_by", ..] => lint_step_by(cx, expr, arg_lists[0]),
+            ["nth", ..] => iter_nth_zero::check(cx, expr, arg_lists[0]),
+            ["step_by", ..] => iterator_step_by_zero::check(cx, expr, arg_lists[0]),
             ["next", "skip"] => lint_iter_skip_next(cx, expr, arg_lists[1]),
             ["collect", "cloned"] => iter_cloned_collect::check(cx, expr, arg_lists[1]),
             ["as_ref"] => lint_asref(cx, expr, "as_ref", arg_lists[0]),
@@ -2586,68 +2588,6 @@ fn lint_unnecessary_fold(cx: &LateContext<'_>, expr: &hir::Expr<'_>, fold_args:
     }
 }
 
-fn lint_step_by<'tcx>(cx: &LateContext<'tcx>, expr: &hir::Expr<'_>, args: &'tcx [hir::Expr<'_>]) {
-    if match_trait_method(cx, expr, &paths::ITERATOR) {
-        if let Some((Constant::Int(0), _)) = constant(cx, cx.typeck_results(), &args[1]) {
-            span_lint(
-                cx,
-                ITERATOR_STEP_BY_ZERO,
-                expr.span,
-                "`Iterator::step_by(0)` will panic at runtime",
-            );
-        }
-    }
-}
-
-fn lint_iter_nth<'tcx>(
-    cx: &LateContext<'tcx>,
-    expr: &hir::Expr<'_>,
-    nth_and_iter_args: &[&'tcx [hir::Expr<'tcx>]],
-    is_mut: bool,
-) {
-    let iter_args = nth_and_iter_args[1];
-    let mut_str = if is_mut { "_mut" } else { "" };
-    let caller_type = if derefs_to_slice(cx, &iter_args[0], cx.typeck_results().expr_ty(&iter_args[0])).is_some() {
-        "slice"
-    } else if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&iter_args[0]), sym::vec_type) {
-        "Vec"
-    } else if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&iter_args[0]), sym::vecdeque_type) {
-        "VecDeque"
-    } else {
-        let nth_args = nth_and_iter_args[0];
-        lint_iter_nth_zero(cx, expr, &nth_args);
-        return; // caller is not a type that we want to lint
-    };
-
-    span_lint_and_help(
-        cx,
-        ITER_NTH,
-        expr.span,
-        &format!("called `.iter{0}().nth()` on a {1}", mut_str, caller_type),
-        None,
-        &format!("calling `.get{}()` is both faster and more readable", mut_str),
-    );
-}
-
-fn lint_iter_nth_zero<'tcx>(cx: &LateContext<'tcx>, expr: &hir::Expr<'_>, nth_args: &'tcx [hir::Expr<'_>]) {
-    if_chain! {
-        if match_trait_method(cx, expr, &paths::ITERATOR);
-        if let Some((Constant::Int(0), _)) = constant(cx, cx.typeck_results(), &nth_args[1]);
-        then {
-            let mut applicability = Applicability::MachineApplicable;
-            span_lint_and_sugg(
-                cx,
-                ITER_NTH_ZERO,
-                expr.span,
-                "called `.nth(0)` on a `std::iter::Iterator`, when `.next()` is equivalent",
-                "try calling `.next()` instead of `.nth(0)`",
-                format!("{}.next()", snippet_with_applicability(cx, nth_args[0].span, "..", &mut applicability)),
-                applicability,
-            );
-        }
-    }
-}
-
 fn lint_iter_skip_next(cx: &LateContext<'_>, expr: &hir::Expr<'_>, skip_args: &[hir::Expr<'_>]) {
     // lint if caller of skip is an Iterator
     if match_trait_method(cx, expr, &paths::ITERATOR) {
-- 
cgit 1.4.1-3-g733a5


From b5d809a660240d5c826989839bd5eaab63fbb312 Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Thu, 4 Mar 2021 23:47:30 +0900
Subject: move wrong_self_convention to its own module

---
 clippy_lints/src/methods/mod.rs                   | 81 +++--------------------
 clippy_lints/src/methods/wrong_self_convention.rs | 76 +++++++++++++++++++++
 2 files changed, 86 insertions(+), 71 deletions(-)
 create mode 100644 clippy_lints/src/methods/wrong_self_convention.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 259d370550c..3cd720bc9ca 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -25,10 +25,10 @@ mod uninit_assumed_init;
 mod unnecessary_filter_map;
 mod unnecessary_lazy_eval;
 mod unwrap_used;
+mod wrong_self_convention;
 mod zst_offset;
 
 use std::borrow::Cow;
-use std::fmt;
 use std::iter;
 
 use bind_instead_of_map::BindInsteadOfMap;
@@ -1868,7 +1868,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
                     }
                 }
 
-                lint_wrong_self_convention(
+                wrong_self_convention::check(
                     cx,
                     &name,
                     item.vis.node.is_pub(),
@@ -1924,7 +1924,14 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             let self_ty = TraitRef::identity(cx.tcx, item.def_id.to_def_id()).self_ty();
 
             then {
-                lint_wrong_self_convention(cx, &item.ident.name.as_str(), false, self_ty, first_arg_ty, first_arg_span);
+                wrong_self_convention::check(
+                    cx,
+                    &item.ident.name.as_str(),
+                    false,
+                    self_ty,
+                    first_arg_ty,
+                    first_arg_span
+                );
             }
         }
 
@@ -1949,39 +1956,6 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
     extract_msrv_attr!(LateContext);
 }
 
-fn lint_wrong_self_convention<'tcx>(
-    cx: &LateContext<'tcx>,
-    item_name: &str,
-    is_pub: bool,
-    self_ty: &'tcx TyS<'tcx>,
-    first_arg_ty: &'tcx TyS<'tcx>,
-    first_arg_span: Span,
-) {
-    let lint = if is_pub {
-        WRONG_PUB_SELF_CONVENTION
-    } else {
-        WRONG_SELF_CONVENTION
-    };
-    if let Some((ref conv, self_kinds)) = &CONVENTIONS.iter().find(|(ref conv, _)| conv.check(item_name)) {
-        if !self_kinds.iter().any(|k| k.matches(cx, self_ty, first_arg_ty)) {
-            span_lint(
-                cx,
-                lint,
-                first_arg_span,
-                &format!(
-                    "methods called `{}` usually take {}; consider choosing a less ambiguous name",
-                    conv,
-                    &self_kinds
-                        .iter()
-                        .map(|k| k.description())
-                        .collect::<Vec<_>>()
-                        .join(" or ")
-                ),
-            );
-        }
-    }
-}
-
 /// Checks for the `OR_FUN_CALL` lint.
 #[allow(clippy::too_many_lines)]
 fn lint_or_fun_call<'tcx>(
@@ -3415,22 +3389,6 @@ fn lint_into_iter(cx: &LateContext<'_>, expr: &hir::Expr<'_>, self_ref_ty: Ty<'_
     }
 }
 
-enum Convention {
-    Eq(&'static str),
-    StartsWith(&'static str),
-}
-
-#[rustfmt::skip]
-const CONVENTIONS: [(Convention, &[SelfKind]); 7] = [
-    (Convention::Eq("new"), &[SelfKind::No]),
-    (Convention::StartsWith("as_"), &[SelfKind::Ref, SelfKind::RefMut]),
-    (Convention::StartsWith("from_"), &[SelfKind::No]),
-    (Convention::StartsWith("into_"), &[SelfKind::Value]),
-    (Convention::StartsWith("is_"), &[SelfKind::Ref, SelfKind::No]),
-    (Convention::Eq("to_mut"), &[SelfKind::RefMut]),
-    (Convention::StartsWith("to_"), &[SelfKind::Ref]),
-];
-
 const FN_HEADER: hir::FnHeader = hir::FnHeader {
     unsafety: hir::Unsafety::Normal,
     constness: hir::Constness::NotConst,
@@ -3602,25 +3560,6 @@ impl SelfKind {
     }
 }
 
-impl Convention {
-    #[must_use]
-    fn check(&self, other: &str) -> bool {
-        match *self {
-            Self::Eq(this) => this == other,
-            Self::StartsWith(this) => other.starts_with(this) && this != other,
-        }
-    }
-}
-
-impl fmt::Display for Convention {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
-        match *self {
-            Self::Eq(this) => this.fmt(f),
-            Self::StartsWith(this) => this.fmt(f).and_then(|_| '*'.fmt(f)),
-        }
-    }
-}
-
 #[derive(Clone, Copy)]
 enum OutType {
     Unit,
diff --git a/clippy_lints/src/methods/wrong_self_convention.rs b/clippy_lints/src/methods/wrong_self_convention.rs
new file mode 100644
index 00000000000..90fab577436
--- /dev/null
+++ b/clippy_lints/src/methods/wrong_self_convention.rs
@@ -0,0 +1,76 @@
+use crate::methods::SelfKind;
+use crate::utils::span_lint;
+use rustc_lint::LateContext;
+use rustc_middle::ty::TyS;
+use rustc_span::source_map::Span;
+use std::fmt;
+
+use super::WRONG_PUB_SELF_CONVENTION;
+use super::WRONG_SELF_CONVENTION;
+
+#[rustfmt::skip]
+const CONVENTIONS: [(Convention, &[SelfKind]); 7] = [
+    (Convention::Eq("new"), &[SelfKind::No]),
+    (Convention::StartsWith("as_"), &[SelfKind::Ref, SelfKind::RefMut]),
+    (Convention::StartsWith("from_"), &[SelfKind::No]),
+    (Convention::StartsWith("into_"), &[SelfKind::Value]),
+    (Convention::StartsWith("is_"), &[SelfKind::Ref, SelfKind::No]),
+    (Convention::Eq("to_mut"), &[SelfKind::RefMut]),
+    (Convention::StartsWith("to_"), &[SelfKind::Ref]),
+];
+enum Convention {
+    Eq(&'static str),
+    StartsWith(&'static str),
+}
+
+impl Convention {
+    #[must_use]
+    fn check(&self, other: &str) -> bool {
+        match *self {
+            Self::Eq(this) => this == other,
+            Self::StartsWith(this) => other.starts_with(this) && this != other,
+        }
+    }
+}
+
+impl fmt::Display for Convention {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
+        match *self {
+            Self::Eq(this) => this.fmt(f),
+            Self::StartsWith(this) => this.fmt(f).and_then(|_| '*'.fmt(f)),
+        }
+    }
+}
+
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    item_name: &str,
+    is_pub: bool,
+    self_ty: &'tcx TyS<'tcx>,
+    first_arg_ty: &'tcx TyS<'tcx>,
+    first_arg_span: Span,
+) {
+    let lint = if is_pub {
+        WRONG_PUB_SELF_CONVENTION
+    } else {
+        WRONG_SELF_CONVENTION
+    };
+    if let Some((ref conv, self_kinds)) = &CONVENTIONS.iter().find(|(ref conv, _)| conv.check(item_name)) {
+        if !self_kinds.iter().any(|k| k.matches(cx, self_ty, first_arg_ty)) {
+            span_lint(
+                cx,
+                lint,
+                first_arg_span,
+                &format!(
+                    "methods called `{}` usually take {}; consider choosing a less ambiguous name",
+                    conv,
+                    &self_kinds
+                        .iter()
+                        .map(|k| k.description())
+                        .collect::<Vec<_>>()
+                        .join(" or ")
+                ),
+            );
+        }
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 2ade32ddf2ec13a6ec2e03c14e7393ce784d4d18 Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Fri, 5 Mar 2021 00:16:43 +0900
Subject: move string_extend_chars and clone_on_ref_ptr to their own module

---
 clippy_lints/src/methods/clone_on_ref_ptr.rs    | 36 +++++++++++++
 clippy_lints/src/methods/mod.rs                 | 72 ++-----------------------
 clippy_lints/src/methods/string_extend_chars.rs | 42 +++++++++++++++
 3 files changed, 82 insertions(+), 68 deletions(-)
 create mode 100644 clippy_lints/src/methods/clone_on_ref_ptr.rs
 create mode 100644 clippy_lints/src/methods/string_extend_chars.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/clone_on_ref_ptr.rs b/clippy_lints/src/methods/clone_on_ref_ptr.rs
new file mode 100644
index 00000000000..3d5a68d69d7
--- /dev/null
+++ b/clippy_lints/src/methods/clone_on_ref_ptr.rs
@@ -0,0 +1,36 @@
+use crate::utils::{is_type_diagnostic_item, match_type, paths, snippet_with_macro_callsite, span_lint_and_sugg};
+use rustc_errors::Applicability;
+use rustc_hir as hir;
+use rustc_lint::LateContext;
+use rustc_middle::ty;
+use rustc_span::symbol::sym;
+
+use super::CLONE_ON_REF_PTR;
+
+pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, arg: &hir::Expr<'_>) {
+    let obj_ty = cx.typeck_results().expr_ty(arg).peel_refs();
+
+    if let ty::Adt(_, subst) = obj_ty.kind() {
+        let caller_type = if is_type_diagnostic_item(cx, obj_ty, sym::Rc) {
+            "Rc"
+        } else if is_type_diagnostic_item(cx, obj_ty, sym::Arc) {
+            "Arc"
+        } else if match_type(cx, obj_ty, &paths::WEAK_RC) || match_type(cx, obj_ty, &paths::WEAK_ARC) {
+            "Weak"
+        } else {
+            return;
+        };
+
+        let snippet = snippet_with_macro_callsite(cx, arg.span, "..");
+
+        span_lint_and_sugg(
+            cx,
+            CLONE_ON_REF_PTR,
+            expr.span,
+            "using `.clone()` on a ref-counted pointer",
+            "try this",
+            format!("{}::<{}>::clone(&{})", caller_type, subst.type_at(0), snippet),
+            Applicability::Unspecified, // Sometimes unnecessary ::<_> after Rc/Arc/Weak
+        );
+    }
+}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 3cd720bc9ca..480f32a4340 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1,5 +1,6 @@
 mod bind_instead_of_map;
 mod bytes_nth;
+mod clone_on_ref_ptr;
 mod expect_used;
 mod filetype_is_file;
 mod filter_map_identity;
@@ -20,6 +21,7 @@ mod ok_expect;
 mod option_as_ref_deref;
 mod option_map_unwrap_or;
 mod skip_while_next;
+mod string_extend_chars;
 mod suspicious_map;
 mod uninit_assumed_init;
 mod unnecessary_filter_map;
@@ -1707,7 +1709,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             ["is_some", "rposition"] => {
                 lint_search_is_some(cx, expr, "rposition", arg_lists[1], arg_lists[0], method_spans[1])
             },
-            ["extend", ..] => lint_extend(cx, expr, arg_lists[0]),
+            ["extend", ..] => string_extend_chars::check(cx, expr, arg_lists[0]),
             ["count", "into_iter"] => iter_count::check(cx, expr, &arg_lists[1], "into_iter"),
             ["count", "iter"] => iter_count::check(cx, expr, &arg_lists[1], "iter"),
             ["count", "iter_mut"] => iter_count::check(cx, expr, &arg_lists[1], "iter_mut"),
@@ -1767,7 +1769,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
                 let self_ty = cx.typeck_results().expr_ty_adjusted(&args[0]);
                 if args.len() == 1 && method_call.ident.name == sym::clone {
                     lint_clone_on_copy(cx, expr, &args[0], self_ty);
-                    lint_clone_on_ref_ptr(cx, expr, &args[0]);
+                    clone_on_ref_ptr::check(cx, expr, &args[0]);
                 }
                 if args.len() == 1 && method_call.ident.name == sym!(to_string) {
                     inefficient_to_string::check(cx, expr, &args[0], self_ty);
@@ -2408,72 +2410,6 @@ fn lint_clone_on_copy(cx: &LateContext<'_>, expr: &hir::Expr<'_>, arg: &hir::Exp
     }
 }
 
-fn lint_clone_on_ref_ptr(cx: &LateContext<'_>, expr: &hir::Expr<'_>, arg: &hir::Expr<'_>) {
-    let obj_ty = cx.typeck_results().expr_ty(arg).peel_refs();
-
-    if let ty::Adt(_, subst) = obj_ty.kind() {
-        let caller_type = if is_type_diagnostic_item(cx, obj_ty, sym::Rc) {
-            "Rc"
-        } else if is_type_diagnostic_item(cx, obj_ty, sym::Arc) {
-            "Arc"
-        } else if match_type(cx, obj_ty, &paths::WEAK_RC) || match_type(cx, obj_ty, &paths::WEAK_ARC) {
-            "Weak"
-        } else {
-            return;
-        };
-
-        let snippet = snippet_with_macro_callsite(cx, arg.span, "..");
-
-        span_lint_and_sugg(
-            cx,
-            CLONE_ON_REF_PTR,
-            expr.span,
-            "using `.clone()` on a ref-counted pointer",
-            "try this",
-            format!("{}::<{}>::clone(&{})", caller_type, subst.type_at(0), snippet),
-            Applicability::Unspecified, // Sometimes unnecessary ::<_> after Rc/Arc/Weak
-        );
-    }
-}
-
-fn lint_string_extend(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::Expr<'_>]) {
-    let arg = &args[1];
-    if let Some(arglists) = method_chain_args(arg, &["chars"]) {
-        let target = &arglists[0][0];
-        let self_ty = cx.typeck_results().expr_ty(target).peel_refs();
-        let ref_str = if *self_ty.kind() == ty::Str {
-            ""
-        } else if is_type_diagnostic_item(cx, self_ty, sym::string_type) {
-            "&"
-        } else {
-            return;
-        };
-
-        let mut applicability = Applicability::MachineApplicable;
-        span_lint_and_sugg(
-            cx,
-            STRING_EXTEND_CHARS,
-            expr.span,
-            "calling `.extend(_.chars())`",
-            "try this",
-            format!(
-                "{}.push_str({}{})",
-                snippet_with_applicability(cx, args[0].span, "..", &mut applicability),
-                ref_str,
-                snippet_with_applicability(cx, target.span, "..", &mut applicability)
-            ),
-            applicability,
-        );
-    }
-}
-
-fn lint_extend(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::Expr<'_>]) {
-    let obj_ty = cx.typeck_results().expr_ty(&args[0]).peel_refs();
-    if is_type_diagnostic_item(cx, obj_ty, sym::string_type) {
-        lint_string_extend(cx, expr, args);
-    }
-}
-
 fn lint_unnecessary_fold(cx: &LateContext<'_>, expr: &hir::Expr<'_>, fold_args: &[hir::Expr<'_>], fold_span: Span) {
     fn check_fold_with_op(
         cx: &LateContext<'_>,
diff --git a/clippy_lints/src/methods/string_extend_chars.rs b/clippy_lints/src/methods/string_extend_chars.rs
new file mode 100644
index 00000000000..0a08ea26175
--- /dev/null
+++ b/clippy_lints/src/methods/string_extend_chars.rs
@@ -0,0 +1,42 @@
+use crate::utils::{is_type_diagnostic_item, method_chain_args, snippet_with_applicability, span_lint_and_sugg};
+use rustc_errors::Applicability;
+use rustc_hir as hir;
+use rustc_lint::LateContext;
+use rustc_middle::ty;
+use rustc_span::symbol::sym;
+
+use super::STRING_EXTEND_CHARS;
+
+pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::Expr<'_>]) {
+    let obj_ty = cx.typeck_results().expr_ty(&args[0]).peel_refs();
+    if is_type_diagnostic_item(cx, obj_ty, sym::string_type) {
+        let arg = &args[1];
+        if let Some(arglists) = method_chain_args(arg, &["chars"]) {
+            let target = &arglists[0][0];
+            let self_ty = cx.typeck_results().expr_ty(target).peel_refs();
+            let ref_str = if *self_ty.kind() == ty::Str {
+                ""
+            } else if is_type_diagnostic_item(cx, self_ty, sym::string_type) {
+                "&"
+            } else {
+                return;
+            };
+
+            let mut applicability = Applicability::MachineApplicable;
+            span_lint_and_sugg(
+                cx,
+                STRING_EXTEND_CHARS,
+                expr.span,
+                "calling `.extend(_.chars())`",
+                "try this",
+                format!(
+                    "{}.push_str({}{})",
+                    snippet_with_applicability(cx, args[0].span, "..", &mut applicability),
+                    ref_str,
+                    snippet_with_applicability(cx, target.span, "..", &mut applicability)
+                ),
+                applicability,
+            );
+        }
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 8006dab817e6bfa0a71a593d46c5569e8a98a6b7 Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Sat, 6 Mar 2021 15:29:02 +0900
Subject: move single_char_insert_string to its own module

---
 clippy_lints/src/methods/mod.rs                    | 23 ++----------------
 .../src/methods/single_char_insert_string.rs       | 27 ++++++++++++++++++++++
 2 files changed, 29 insertions(+), 21 deletions(-)
 create mode 100644 clippy_lints/src/methods/single_char_insert_string.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 480f32a4340..ef671e41cb5 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -20,6 +20,7 @@ mod map_collect_result_unit;
 mod ok_expect;
 mod option_as_ref_deref;
 mod option_map_unwrap_or;
+mod single_char_insert_string;
 mod skip_while_next;
 mod string_extend_chars;
 mod suspicious_map;
@@ -1779,7 +1780,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
                     if match_def_path(cx, fn_def_id, &paths::PUSH_STR) {
                         lint_single_char_push_string(cx, expr, args);
                     } else if match_def_path(cx, fn_def_id, &paths::INSERT_STR) {
-                        lint_single_char_insert_string(cx, expr, args);
+                        single_char_insert_string::check(cx, expr, args);
                     }
                 }
 
@@ -3235,26 +3236,6 @@ fn lint_single_char_push_string(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args
     }
 }
 
-/// lint for length-1 `str`s as argument for `insert_str`
-fn lint_single_char_insert_string(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::Expr<'_>]) {
-    let mut applicability = Applicability::MachineApplicable;
-    if let Some(extension_string) = get_hint_if_single_char_arg(cx, &args[2], &mut applicability) {
-        let base_string_snippet =
-            snippet_with_applicability(cx, args[0].span.source_callsite(), "_", &mut applicability);
-        let pos_arg = snippet_with_applicability(cx, args[1].span, "..", &mut applicability);
-        let sugg = format!("{}.insert({}, {})", base_string_snippet, pos_arg, extension_string);
-        span_lint_and_sugg(
-            cx,
-            SINGLE_CHAR_ADD_STR,
-            expr.span,
-            "calling `insert_str()` using a single-character string literal",
-            "consider using `insert` with a character literal",
-            sugg,
-            applicability,
-        );
-    }
-}
-
 /// Checks for the `USELESS_ASREF` lint.
 fn lint_asref(cx: &LateContext<'_>, expr: &hir::Expr<'_>, call_name: &str, as_ref_args: &[hir::Expr<'_>]) {
     // when we get here, we've already checked that the call name is "as_ref" or "as_mut"
diff --git a/clippy_lints/src/methods/single_char_insert_string.rs b/clippy_lints/src/methods/single_char_insert_string.rs
new file mode 100644
index 00000000000..0ce8b66978d
--- /dev/null
+++ b/clippy_lints/src/methods/single_char_insert_string.rs
@@ -0,0 +1,27 @@
+use crate::methods::get_hint_if_single_char_arg;
+use crate::utils::{snippet_with_applicability, span_lint_and_sugg};
+use rustc_errors::Applicability;
+use rustc_hir as hir;
+use rustc_lint::LateContext;
+
+use super::SINGLE_CHAR_ADD_STR;
+
+/// lint for length-1 `str`s as argument for `insert_str`
+pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::Expr<'_>]) {
+    let mut applicability = Applicability::MachineApplicable;
+    if let Some(extension_string) = get_hint_if_single_char_arg(cx, &args[2], &mut applicability) {
+        let base_string_snippet =
+            snippet_with_applicability(cx, args[0].span.source_callsite(), "_", &mut applicability);
+        let pos_arg = snippet_with_applicability(cx, args[1].span, "..", &mut applicability);
+        let sugg = format!("{}.insert({}, {})", base_string_snippet, pos_arg, extension_string);
+        span_lint_and_sugg(
+            cx,
+            SINGLE_CHAR_ADD_STR,
+            expr.span,
+            "calling `insert_str()` using a single-character string literal",
+            "consider using `insert` with a character literal",
+            sugg,
+            applicability,
+        );
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 805aa47f43ab9b61a69f63682176604cdcda8fae Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Sat, 6 Mar 2021 15:39:28 +0900
Subject: move single_char_push_string to its own module

---
 clippy_lints/src/methods/mod.rs                    | 22 ++----------------
 .../src/methods/single_char_push_string.rs         | 26 ++++++++++++++++++++++
 2 files changed, 28 insertions(+), 20 deletions(-)
 create mode 100644 clippy_lints/src/methods/single_char_push_string.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index ef671e41cb5..24d610cf5f8 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -21,6 +21,7 @@ mod ok_expect;
 mod option_as_ref_deref;
 mod option_map_unwrap_or;
 mod single_char_insert_string;
+mod single_char_push_string;
 mod skip_while_next;
 mod string_extend_chars;
 mod suspicious_map;
@@ -1778,7 +1779,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
 
                 if let Some(fn_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id) {
                     if match_def_path(cx, fn_def_id, &paths::PUSH_STR) {
-                        lint_single_char_push_string(cx, expr, args);
+                        single_char_push_string::check(cx, expr, args);
                     } else if match_def_path(cx, fn_def_id, &paths::INSERT_STR) {
                         single_char_insert_string::check(cx, expr, args);
                     }
@@ -3217,25 +3218,6 @@ fn lint_single_char_pattern(cx: &LateContext<'_>, _expr: &hir::Expr<'_>, arg: &h
     }
 }
 
-/// lint for length-1 `str`s as argument for `push_str`
-fn lint_single_char_push_string(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::Expr<'_>]) {
-    let mut applicability = Applicability::MachineApplicable;
-    if let Some(extension_string) = get_hint_if_single_char_arg(cx, &args[1], &mut applicability) {
-        let base_string_snippet =
-            snippet_with_applicability(cx, args[0].span.source_callsite(), "..", &mut applicability);
-        let sugg = format!("{}.push({})", base_string_snippet, extension_string);
-        span_lint_and_sugg(
-            cx,
-            SINGLE_CHAR_ADD_STR,
-            expr.span,
-            "calling `push_str()` using a single-character string literal",
-            "consider using `push` with a character literal",
-            sugg,
-            applicability,
-        );
-    }
-}
-
 /// Checks for the `USELESS_ASREF` lint.
 fn lint_asref(cx: &LateContext<'_>, expr: &hir::Expr<'_>, call_name: &str, as_ref_args: &[hir::Expr<'_>]) {
     // when we get here, we've already checked that the call name is "as_ref" or "as_mut"
diff --git a/clippy_lints/src/methods/single_char_push_string.rs b/clippy_lints/src/methods/single_char_push_string.rs
new file mode 100644
index 00000000000..deacc70b713
--- /dev/null
+++ b/clippy_lints/src/methods/single_char_push_string.rs
@@ -0,0 +1,26 @@
+use crate::methods::get_hint_if_single_char_arg;
+use crate::utils::{snippet_with_applicability, span_lint_and_sugg};
+use rustc_errors::Applicability;
+use rustc_hir as hir;
+use rustc_lint::LateContext;
+
+use super::SINGLE_CHAR_ADD_STR;
+
+/// lint for length-1 `str`s as argument for `push_str`
+pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::Expr<'_>]) {
+    let mut applicability = Applicability::MachineApplicable;
+    if let Some(extension_string) = get_hint_if_single_char_arg(cx, &args[1], &mut applicability) {
+        let base_string_snippet =
+            snippet_with_applicability(cx, args[0].span.source_callsite(), "..", &mut applicability);
+        let sugg = format!("{}.push({})", base_string_snippet, extension_string);
+        span_lint_and_sugg(
+            cx,
+            SINGLE_CHAR_ADD_STR,
+            expr.span,
+            "calling `push_str()` using a single-character string literal",
+            "consider using `push` with a character literal",
+            sugg,
+            applicability,
+        );
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 0c8d143515a19b04a404765ecb8145a183dc2186 Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Sat, 6 Mar 2021 17:28:14 +0900
Subject: move into_iter_on_ref and single_char_pattern to their own modules

---
 clippy_lints/src/methods/into_iter_on_ref.rs    | 42 ++++++++++++++++
 clippy_lints/src/methods/mod.rs                 | 67 ++++---------------------
 clippy_lints/src/methods/single_char_pattern.rs | 23 +++++++++
 3 files changed, 74 insertions(+), 58 deletions(-)
 create mode 100644 clippy_lints/src/methods/into_iter_on_ref.rs
 create mode 100644 clippy_lints/src/methods/single_char_pattern.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/into_iter_on_ref.rs b/clippy_lints/src/methods/into_iter_on_ref.rs
new file mode 100644
index 00000000000..d94b243404c
--- /dev/null
+++ b/clippy_lints/src/methods/into_iter_on_ref.rs
@@ -0,0 +1,42 @@
+use crate::utils::{has_iter_method, match_trait_method, paths, span_lint_and_sugg};
+use rustc_errors::Applicability;
+use rustc_hir as hir;
+use rustc_lint::LateContext;
+use rustc_middle::ty::{self, Ty};
+use rustc_span::source_map::Span;
+
+use super::INTO_ITER_ON_REF;
+
+pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, self_ref_ty: Ty<'_>, method_span: Span) {
+    if !match_trait_method(cx, expr, &paths::INTO_ITERATOR) {
+        return;
+    }
+    if let Some((kind, method_name)) = ty_has_iter_method(cx, self_ref_ty) {
+        span_lint_and_sugg(
+            cx,
+            INTO_ITER_ON_REF,
+            method_span,
+            &format!(
+                "this `.into_iter()` call is equivalent to `.{}()` and will not consume the `{}`",
+                method_name, kind,
+            ),
+            "call directly",
+            method_name.to_string(),
+            Applicability::MachineApplicable,
+        );
+    }
+}
+
+fn ty_has_iter_method(cx: &LateContext<'_>, self_ref_ty: Ty<'_>) -> Option<(&'static str, &'static str)> {
+    has_iter_method(cx, self_ref_ty).map(|ty_name| {
+        let mutbl = match self_ref_ty.kind() {
+            ty::Ref(_, _, mutbl) => mutbl,
+            _ => unreachable!(),
+        };
+        let method_name = match mutbl {
+            hir::Mutability::Not => "iter",
+            hir::Mutability::Mut => "iter_mut",
+        };
+        (ty_name, method_name)
+    })
+}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 24d610cf5f8..28e2d896e6c 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -9,6 +9,7 @@ mod get_unwrap;
 mod implicit_clone;
 mod inefficient_to_string;
 mod inspect_for_each;
+mod into_iter_on_ref;
 mod iter_cloned_collect;
 mod iter_count;
 mod iter_next_slice;
@@ -21,6 +22,7 @@ mod ok_expect;
 mod option_as_ref_deref;
 mod option_map_unwrap_or;
 mod single_char_insert_string;
+mod single_char_pattern;
 mod single_char_push_string;
 mod skip_while_next;
 mod string_extend_chars;
@@ -53,12 +55,11 @@ use rustc_typeck::hir_ty_to_ty;
 use crate::utils::eager_or_lazy::is_lazyness_candidate;
 use crate::utils::usage::mutated_variables;
 use crate::utils::{
-    contains_return, contains_ty, get_parent_expr, get_trait_def_id, has_iter_method, implements_trait, in_macro,
-    is_copy, is_expn_of, is_type_diagnostic_item, iter_input_pats, last_path_segment, match_def_path, match_qpath,
-    match_trait_method, match_type, meets_msrv, method_calls, method_chain_args, path_to_local_id, paths,
-    remove_blocks, return_ty, single_segment_path, snippet, snippet_with_applicability, snippet_with_macro_callsite,
-    span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then, strip_pat_refs, sugg, walk_ptrs_ty_depth,
-    SpanlessEq,
+    contains_return, contains_ty, get_parent_expr, get_trait_def_id, implements_trait, in_macro, is_copy, is_expn_of,
+    is_type_diagnostic_item, iter_input_pats, last_path_segment, match_def_path, match_qpath, match_trait_method,
+    match_type, meets_msrv, method_calls, method_chain_args, path_to_local_id, paths, remove_blocks, return_ty,
+    single_segment_path, snippet, snippet_with_applicability, snippet_with_macro_callsite, span_lint,
+    span_lint_and_help, span_lint_and_sugg, span_lint_and_then, strip_pat_refs, sugg, walk_ptrs_ty_depth, SpanlessEq,
 };
 
 declare_clippy_lint! {
@@ -1789,12 +1790,12 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
                     ty::Ref(_, ty, _) if *ty.kind() == ty::Str => {
                         for &(method, pos) in &PATTERN_METHODS {
                             if method_call.ident.name.as_str() == method && args.len() > pos {
-                                lint_single_char_pattern(cx, expr, &args[pos]);
+                                single_char_pattern::check(cx, expr, &args[pos]);
                             }
                         }
                     },
                     ty::Ref(..) if method_call.ident.name == sym::into_iter => {
-                        lint_into_iter(cx, expr, self_ty, *method_span);
+                        into_iter_on_ref::check(cx, expr, self_ty, *method_span);
                     },
                     _ => (),
                 }
@@ -3202,22 +3203,6 @@ fn get_hint_if_single_char_arg(
     }
 }
 
-/// lint for length-1 `str`s for methods in `PATTERN_METHODS`
-fn lint_single_char_pattern(cx: &LateContext<'_>, _expr: &hir::Expr<'_>, arg: &hir::Expr<'_>) {
-    let mut applicability = Applicability::MachineApplicable;
-    if let Some(hint) = get_hint_if_single_char_arg(cx, arg, &mut applicability) {
-        span_lint_and_sugg(
-            cx,
-            SINGLE_CHAR_PATTERN,
-            arg.span,
-            "single-character string constant used as pattern",
-            "try using a `char` instead",
-            hint,
-            applicability,
-        );
-    }
-}
-
 /// Checks for the `USELESS_ASREF` lint.
 fn lint_asref(cx: &LateContext<'_>, expr: &hir::Expr<'_>, call_name: &str, as_ref_args: &[hir::Expr<'_>]) {
     // when we get here, we've already checked that the call name is "as_ref" or "as_mut"
@@ -3254,40 +3239,6 @@ fn lint_asref(cx: &LateContext<'_>, expr: &hir::Expr<'_>, call_name: &str, as_re
     }
 }
 
-fn ty_has_iter_method(cx: &LateContext<'_>, self_ref_ty: Ty<'_>) -> Option<(Symbol, &'static str)> {
-    has_iter_method(cx, self_ref_ty).map(|ty_name| {
-        let mutbl = match self_ref_ty.kind() {
-            ty::Ref(_, _, mutbl) => mutbl,
-            _ => unreachable!(),
-        };
-        let method_name = match mutbl {
-            hir::Mutability::Not => "iter",
-            hir::Mutability::Mut => "iter_mut",
-        };
-        (ty_name, method_name)
-    })
-}
-
-fn lint_into_iter(cx: &LateContext<'_>, expr: &hir::Expr<'_>, self_ref_ty: Ty<'_>, method_span: Span) {
-    if !match_trait_method(cx, expr, &paths::INTO_ITERATOR) {
-        return;
-    }
-    if let Some((kind, method_name)) = ty_has_iter_method(cx, self_ref_ty) {
-        span_lint_and_sugg(
-            cx,
-            INTO_ITER_ON_REF,
-            method_span,
-            &format!(
-                "this `.into_iter()` call is equivalent to `.{}()` and will not consume the `{}`",
-                method_name, kind,
-            ),
-            "call directly",
-            method_name.to_string(),
-            Applicability::MachineApplicable,
-        );
-    }
-}
-
 const FN_HEADER: hir::FnHeader = hir::FnHeader {
     unsafety: hir::Unsafety::Normal,
     constness: hir::Constness::NotConst,
diff --git a/clippy_lints/src/methods/single_char_pattern.rs b/clippy_lints/src/methods/single_char_pattern.rs
new file mode 100644
index 00000000000..61cbc9d2f0a
--- /dev/null
+++ b/clippy_lints/src/methods/single_char_pattern.rs
@@ -0,0 +1,23 @@
+use crate::methods::get_hint_if_single_char_arg;
+use crate::utils::span_lint_and_sugg;
+use rustc_errors::Applicability;
+use rustc_hir as hir;
+use rustc_lint::LateContext;
+
+use super::SINGLE_CHAR_PATTERN;
+
+/// lint for length-1 `str`s for methods in `PATTERN_METHODS`
+pub(super) fn check(cx: &LateContext<'_>, _expr: &hir::Expr<'_>, arg: &hir::Expr<'_>) {
+    let mut applicability = Applicability::MachineApplicable;
+    if let Some(hint) = get_hint_if_single_char_arg(cx, arg, &mut applicability) {
+        span_lint_and_sugg(
+            cx,
+            SINGLE_CHAR_PATTERN,
+            arg.span,
+            "single-character string constant used as pattern",
+            "try using a `char` instead",
+            hint,
+            applicability,
+        );
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 2561b7ea062f0c07f27d9ebdf0c355ab29a4edf9 Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Sat, 6 Mar 2021 17:46:50 +0900
Subject: move from_iter_insteam_of_collect to its own module

---
 .../src/methods/from_iter_instead_of_collect.rs    | 67 ++++++++++++++++++++++
 clippy_lints/src/methods/mod.rs                    | 62 +-------------------
 2 files changed, 69 insertions(+), 60 deletions(-)
 create mode 100644 clippy_lints/src/methods/from_iter_instead_of_collect.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/from_iter_instead_of_collect.rs b/clippy_lints/src/methods/from_iter_instead_of_collect.rs
new file mode 100644
index 00000000000..e50d0a33400
--- /dev/null
+++ b/clippy_lints/src/methods/from_iter_instead_of_collect.rs
@@ -0,0 +1,67 @@
+use crate::utils::{get_trait_def_id, implements_trait, paths, span_lint_and_sugg, sugg};
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir as hir;
+use rustc_lint::{LateContext, LintContext};
+use rustc_middle::ty::Ty;
+
+use super::FROM_ITER_INSTEAD_OF_COLLECT;
+
+pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::Expr<'_>]) {
+    let ty = cx.typeck_results().expr_ty(expr);
+    let arg_ty = cx.typeck_results().expr_ty(&args[0]);
+
+    if_chain! {
+        if let Some(from_iter_id) = get_trait_def_id(cx, &paths::FROM_ITERATOR);
+        if let Some(iter_id) = get_trait_def_id(cx, &paths::ITERATOR);
+
+        if implements_trait(cx, ty, from_iter_id, &[]) && implements_trait(cx, arg_ty, iter_id, &[]);
+        then {
+            // `expr` implements `FromIterator` trait
+            let iter_expr = sugg::Sugg::hir(cx, &args[0], "..").maybe_par();
+            let turbofish = extract_turbofish(cx, expr, ty);
+            let sugg = format!("{}.collect::<{}>()", iter_expr, turbofish);
+            span_lint_and_sugg(
+                cx,
+                FROM_ITER_INSTEAD_OF_COLLECT,
+                expr.span,
+                "usage of `FromIterator::from_iter`",
+                "use `.collect()` instead of `::from_iter()`",
+                sugg,
+                Applicability::MaybeIncorrect,
+            );
+        }
+    }
+}
+
+fn extract_turbofish(cx: &LateContext<'_>, expr: &hir::Expr<'_>, ty: Ty<'tcx>) -> String {
+    if_chain! {
+        let call_site = expr.span.source_callsite();
+        if let Ok(snippet) = cx.sess().source_map().span_to_snippet(call_site);
+        let snippet_split = snippet.split("::").collect::<Vec<_>>();
+        if let Some((_, elements)) = snippet_split.split_last();
+
+        then {
+            // is there a type specifier? (i.e.: like `<u32>` in `collections::BTreeSet::<u32>::`)
+            if let Some(type_specifier) = snippet_split.iter().find(|e| e.starts_with('<') && e.ends_with('>')) {
+                // remove the type specifier from the path elements
+                let without_ts = elements.iter().filter_map(|e| {
+                    if e == type_specifier { None } else { Some((*e).to_string()) }
+                }).collect::<Vec<_>>();
+                // join and add the type specifier at the end (i.e.: `collections::BTreeSet<u32>`)
+                format!("{}{}", without_ts.join("::"), type_specifier)
+            } else {
+                // type is not explicitly specified so wildcards are needed
+                // i.e.: 2 wildcards in `std::collections::BTreeMap<&i32, &char>`
+                let ty_str = ty.to_string();
+                let start = ty_str.find('<').unwrap_or(0);
+                let end = ty_str.find('>').unwrap_or_else(|| ty_str.len());
+                let nb_wildcard = ty_str[start..end].split(',').count();
+                let wildcards = format!("_{}", ", _".repeat(nb_wildcard - 1));
+                format!("{}<{}>", elements.join("::"), wildcards)
+            }
+        } else {
+            ty.to_string()
+        }
+    }
+}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 28e2d896e6c..9a0ef6c01c1 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -5,6 +5,7 @@ mod expect_used;
 mod filetype_is_file;
 mod filter_map_identity;
 mod filter_next;
+mod from_iter_instead_of_collect;
 mod get_unwrap;
 mod implicit_clone;
 mod inefficient_to_string;
@@ -1761,7 +1762,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             hir::ExprKind::Call(ref func, ref args) => {
                 if let hir::ExprKind::Path(path) = &func.kind {
                     if match_qpath(path, &["from_iter"]) {
-                        lint_from_iter(cx, expr, args);
+                        from_iter_instead_of_collect::check(cx, expr, args);
                     }
                 }
             },
@@ -3440,65 +3441,6 @@ fn is_bool(ty: &hir::Ty<'_>) -> bool {
     }
 }
 
-fn lint_from_iter(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::Expr<'_>]) {
-    let ty = cx.typeck_results().expr_ty(expr);
-    let arg_ty = cx.typeck_results().expr_ty(&args[0]);
-
-    if_chain! {
-        if let Some(from_iter_id) = get_trait_def_id(cx, &paths::FROM_ITERATOR);
-        if let Some(iter_id) = get_trait_def_id(cx, &paths::ITERATOR);
-
-        if implements_trait(cx, ty, from_iter_id, &[]) && implements_trait(cx, arg_ty, iter_id, &[]);
-        then {
-            // `expr` implements `FromIterator` trait
-            let iter_expr = sugg::Sugg::hir(cx, &args[0], "..").maybe_par();
-            let turbofish = extract_turbofish(cx, expr, ty);
-            let sugg = format!("{}.collect::<{}>()", iter_expr, turbofish);
-            span_lint_and_sugg(
-                cx,
-                FROM_ITER_INSTEAD_OF_COLLECT,
-                expr.span,
-                "usage of `FromIterator::from_iter`",
-                "use `.collect()` instead of `::from_iter()`",
-                sugg,
-                Applicability::MaybeIncorrect,
-            );
-        }
-    }
-}
-
-fn extract_turbofish(cx: &LateContext<'_>, expr: &hir::Expr<'_>, ty: Ty<'tcx>) -> String {
-    if_chain! {
-        let call_site = expr.span.source_callsite();
-        if let Ok(snippet) = cx.sess().source_map().span_to_snippet(call_site);
-        let snippet_split = snippet.split("::").collect::<Vec<_>>();
-        if let Some((_, elements)) = snippet_split.split_last();
-
-        then {
-            // is there a type specifier? (i.e.: like `<u32>` in `collections::BTreeSet::<u32>::`)
-            if let Some(type_specifier) = snippet_split.iter().find(|e| e.starts_with('<') && e.ends_with('>')) {
-                // remove the type specifier from the path elements
-                let without_ts = elements.iter().filter_map(|e| {
-                    if e == type_specifier { None } else { Some((*e).to_string()) }
-                }).collect::<Vec<_>>();
-                // join and add the type specifier at the end (i.e.: `collections::BTreeSet<u32>`)
-                format!("{}{}", without_ts.join("::"), type_specifier)
-            } else {
-                // type is not explicitly specified so wildcards are needed
-                // i.e.: 2 wildcards in `std::collections::BTreeMap<&i32, &char>`
-                let ty_str = ty.to_string();
-                let start = ty_str.find('<').unwrap_or(0);
-                let end = ty_str.find('>').unwrap_or_else(|| ty_str.len());
-                let nb_wildcard = ty_str[start..end].split(',').count();
-                let wildcards = format!("_{}", ", _".repeat(nb_wildcard - 1));
-                format!("{}<{}>", elements.join("::"), wildcards)
-            }
-        } else {
-            ty.to_string()
-        }
-    }
-}
-
 fn fn_header_equals(expected: hir::FnHeader, actual: hir::FnHeader) -> bool {
     expected.constness == actual.constness
         && expected.unsafety == actual.unsafety
-- 
cgit 1.4.1-3-g733a5


From 183daeb961c83d5be108cfa5ee463bba412dedc4 Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Sat, 6 Mar 2021 17:55:29 +0900
Subject: move filter_map to its own module

---
 clippy_lints/src/methods/filter_map.rs | 85 ++++++++++++++++++++++++++++++++++
 clippy_lints/src/methods/mod.rs        | 81 ++------------------------------
 2 files changed, 89 insertions(+), 77 deletions(-)
 create mode 100644 clippy_lints/src/methods/filter_map.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/filter_map.rs b/clippy_lints/src/methods/filter_map.rs
new file mode 100644
index 00000000000..f559160004c
--- /dev/null
+++ b/clippy_lints/src/methods/filter_map.rs
@@ -0,0 +1,85 @@
+use crate::utils::{match_trait_method, path_to_local_id, paths, snippet, span_lint_and_sugg, SpanlessEq};
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir as hir;
+use rustc_hir::{Expr, ExprKind, PatKind, UnOp};
+use rustc_lint::LateContext;
+use rustc_middle::ty::TyS;
+use rustc_span::symbol::sym;
+
+use super::MANUAL_FILTER_MAP;
+use super::MANUAL_FIND_MAP;
+
+/// lint use of `filter().map()` or `find().map()` for `Iterators`
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, is_find: bool) {
+    if_chain! {
+        if let ExprKind::MethodCall(_, _, [map_recv, map_arg], map_span) = expr.kind;
+        if let ExprKind::MethodCall(_, _, [_, filter_arg], filter_span) = map_recv.kind;
+        if match_trait_method(cx, map_recv, &paths::ITERATOR);
+
+        // filter(|x| ...is_some())...
+        if let ExprKind::Closure(_, _, filter_body_id, ..) = filter_arg.kind;
+        let filter_body = cx.tcx.hir().body(filter_body_id);
+        if let [filter_param] = filter_body.params;
+        // optional ref pattern: `filter(|&x| ..)`
+        let (filter_pat, is_filter_param_ref) = if let PatKind::Ref(ref_pat, _) = filter_param.pat.kind {
+            (ref_pat, true)
+        } else {
+            (filter_param.pat, false)
+        };
+        // closure ends with is_some() or is_ok()
+        if let PatKind::Binding(_, filter_param_id, _, None) = filter_pat.kind;
+        if let ExprKind::MethodCall(path, _, [filter_arg], _) = filter_body.value.kind;
+        if let Some(opt_ty) = cx.typeck_results().expr_ty(filter_arg).ty_adt_def();
+        if let Some(is_result) = if cx.tcx.is_diagnostic_item(sym::option_type, opt_ty.did) {
+            Some(false)
+        } else if cx.tcx.is_diagnostic_item(sym::result_type, opt_ty.did) {
+            Some(true)
+        } else {
+            None
+        };
+        if path.ident.name.as_str() == if is_result { "is_ok" } else { "is_some" };
+
+        // ...map(|x| ...unwrap())
+        if let ExprKind::Closure(_, _, map_body_id, ..) = map_arg.kind;
+        let map_body = cx.tcx.hir().body(map_body_id);
+        if let [map_param] = map_body.params;
+        if let PatKind::Binding(_, map_param_id, map_param_ident, None) = map_param.pat.kind;
+        // closure ends with expect() or unwrap()
+        if let ExprKind::MethodCall(seg, _, [map_arg, ..], _) = map_body.value.kind;
+        if matches!(seg.ident.name, sym::expect | sym::unwrap | sym::unwrap_or);
+
+        let eq_fallback = |a: &Expr<'_>, b: &Expr<'_>| {
+            // in `filter(|x| ..)`, replace `*x` with `x`
+            let a_path = if_chain! {
+                if !is_filter_param_ref;
+                if let ExprKind::Unary(UnOp::Deref, expr_path) = a.kind;
+                then { expr_path } else { a }
+            };
+            // let the filter closure arg and the map closure arg be equal
+            if_chain! {
+                if path_to_local_id(a_path, filter_param_id);
+                if path_to_local_id(b, map_param_id);
+                if TyS::same_type(cx.typeck_results().expr_ty_adjusted(a), cx.typeck_results().expr_ty_adjusted(b));
+                then {
+                    return true;
+                }
+            }
+            false
+        };
+        if SpanlessEq::new(cx).expr_fallback(eq_fallback).eq_expr(filter_arg, map_arg);
+        then {
+            let span = filter_span.to(map_span);
+            let (filter_name, lint) = if is_find {
+                ("find", MANUAL_FIND_MAP)
+            } else {
+                ("filter", MANUAL_FILTER_MAP)
+            };
+            let msg = format!("`{}(..).map(..)` can be simplified as `{0}_map(..)`", filter_name);
+            let to_opt = if is_result { ".ok()" } else { "" };
+            let sugg = format!("{}_map(|{}| {}{})", filter_name, map_param_ident,
+                snippet(cx, map_arg.span, ".."), to_opt);
+            span_lint_and_sugg(cx, lint, span, &msg, "try", sugg, Applicability::MachineApplicable);
+        }
+    }
+}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 9a0ef6c01c1..61d562cbc28 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3,6 +3,7 @@ mod bytes_nth;
 mod clone_on_ref_ptr;
 mod expect_used;
 mod filetype_is_file;
+mod filter_map;
 mod filter_map_identity;
 mod filter_next;
 mod from_iter_instead_of_collect;
@@ -43,7 +44,7 @@ use if_chain::if_chain;
 use rustc_ast::ast;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
-use rustc_hir::{Expr, ExprKind, PatKind, TraitItem, TraitItemKind, UnOp};
+use rustc_hir::{PatKind, TraitItem, TraitItemKind};
 use rustc_lint::{LateContext, LateLintPass, Lint, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::{self, TraitRef, Ty, TyS};
@@ -1698,10 +1699,10 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             ["next", "filter"] => filter_next::check(cx, expr, arg_lists[1]),
             ["next", "skip_while"] => skip_while_next::check(cx, expr, arg_lists[1]),
             ["next", "iter"] => iter_next_slice::check(cx, expr, arg_lists[1]),
-            ["map", "filter"] => lint_filter_map(cx, expr, false),
+            ["map", "filter"] => filter_map::check(cx, expr, false),
             ["map", "filter_map"] => lint_filter_map_map(cx, expr, arg_lists[1], arg_lists[0]),
             ["next", "filter_map"] => lint_filter_map_next(cx, expr, arg_lists[1], self.msrv.as_ref()),
-            ["map", "find"] => lint_filter_map(cx, expr, true),
+            ["map", "find"] => filter_map::check(cx, expr, true),
             ["flat_map", "filter"] => lint_filter_flat_map(cx, expr, arg_lists[1], arg_lists[0]),
             ["flat_map", "filter_map"] => lint_filter_map_flat_map(cx, expr, arg_lists[1], arg_lists[0]),
             ["flat_map", ..] => lint_flat_map_identity(cx, expr, arg_lists[0], method_spans[0]),
@@ -2750,80 +2751,6 @@ fn lint_map_or_none<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, map
     );
 }
 
-/// lint use of `filter().map()` or `find().map()` for `Iterators`
-fn lint_filter_map<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, is_find: bool) {
-    if_chain! {
-        if let ExprKind::MethodCall(_, _, [map_recv, map_arg], map_span) = expr.kind;
-        if let ExprKind::MethodCall(_, _, [_, filter_arg], filter_span) = map_recv.kind;
-        if match_trait_method(cx, map_recv, &paths::ITERATOR);
-
-        // filter(|x| ...is_some())...
-        if let ExprKind::Closure(_, _, filter_body_id, ..) = filter_arg.kind;
-        let filter_body = cx.tcx.hir().body(filter_body_id);
-        if let [filter_param] = filter_body.params;
-        // optional ref pattern: `filter(|&x| ..)`
-        let (filter_pat, is_filter_param_ref) = if let PatKind::Ref(ref_pat, _) = filter_param.pat.kind {
-            (ref_pat, true)
-        } else {
-            (filter_param.pat, false)
-        };
-        // closure ends with is_some() or is_ok()
-        if let PatKind::Binding(_, filter_param_id, _, None) = filter_pat.kind;
-        if let ExprKind::MethodCall(path, _, [filter_arg], _) = filter_body.value.kind;
-        if let Some(opt_ty) = cx.typeck_results().expr_ty(filter_arg).ty_adt_def();
-        if let Some(is_result) = if cx.tcx.is_diagnostic_item(sym::option_type, opt_ty.did) {
-            Some(false)
-        } else if cx.tcx.is_diagnostic_item(sym::result_type, opt_ty.did) {
-            Some(true)
-        } else {
-            None
-        };
-        if path.ident.name.as_str() == if is_result { "is_ok" } else { "is_some" };
-
-        // ...map(|x| ...unwrap())
-        if let ExprKind::Closure(_, _, map_body_id, ..) = map_arg.kind;
-        let map_body = cx.tcx.hir().body(map_body_id);
-        if let [map_param] = map_body.params;
-        if let PatKind::Binding(_, map_param_id, map_param_ident, None) = map_param.pat.kind;
-        // closure ends with expect() or unwrap()
-        if let ExprKind::MethodCall(seg, _, [map_arg, ..], _) = map_body.value.kind;
-        if matches!(seg.ident.name, sym::expect | sym::unwrap | sym::unwrap_or);
-
-        let eq_fallback = |a: &Expr<'_>, b: &Expr<'_>| {
-            // in `filter(|x| ..)`, replace `*x` with `x`
-            let a_path = if_chain! {
-                if !is_filter_param_ref;
-                if let ExprKind::Unary(UnOp::Deref, expr_path) = a.kind;
-                then { expr_path } else { a }
-            };
-            // let the filter closure arg and the map closure arg be equal
-            if_chain! {
-                if path_to_local_id(a_path, filter_param_id);
-                if path_to_local_id(b, map_param_id);
-                if TyS::same_type(cx.typeck_results().expr_ty_adjusted(a), cx.typeck_results().expr_ty_adjusted(b));
-                then {
-                    return true;
-                }
-            }
-            false
-        };
-        if SpanlessEq::new(cx).expr_fallback(eq_fallback).eq_expr(filter_arg, map_arg);
-        then {
-            let span = filter_span.to(map_span);
-            let (filter_name, lint) = if is_find {
-                ("find", MANUAL_FIND_MAP)
-            } else {
-                ("filter", MANUAL_FILTER_MAP)
-            };
-            let msg = format!("`{}(..).map(..)` can be simplified as `{0}_map(..)`", filter_name);
-            let to_opt = if is_result { ".ok()" } else { "" };
-            let sugg = format!("{}_map(|{}| {}{})", filter_name, map_param_ident,
-                snippet(cx, map_arg.span, ".."), to_opt);
-            span_lint_and_sugg(cx, lint, span, &msg, "try", sugg, Applicability::MachineApplicable);
-        }
-    }
-}
-
 const FILTER_MAP_NEXT_MSRV: RustcVersion = RustcVersion::new(1, 30, 0);
 
 /// lint use of `filter_map().next()` for `Iterators`
-- 
cgit 1.4.1-3-g733a5


From 805dcd12d41e72c16bbca83496f4b89ba49eed64 Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Sat, 6 Mar 2021 18:05:15 +0900
Subject: move filter_map_map to its own module

---
 clippy_lints/src/methods/filter_map_map.rs | 20 ++++++++++++++++++++
 clippy_lints/src/methods/mod.rs            | 18 ++----------------
 2 files changed, 22 insertions(+), 16 deletions(-)
 create mode 100644 clippy_lints/src/methods/filter_map_map.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/filter_map_map.rs b/clippy_lints/src/methods/filter_map_map.rs
new file mode 100644
index 00000000000..d015b4c7b38
--- /dev/null
+++ b/clippy_lints/src/methods/filter_map_map.rs
@@ -0,0 +1,20 @@
+use crate::utils::{match_trait_method, paths, span_lint_and_help};
+use rustc_hir as hir;
+use rustc_lint::LateContext;
+
+use super::FILTER_MAP;
+
+/// lint use of `filter_map().map()` for `Iterators`
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx hir::Expr<'_>,
+    _filter_args: &'tcx [hir::Expr<'_>],
+    _map_args: &'tcx [hir::Expr<'_>],
+) {
+    // lint if caller of `.filter_map().map()` is an Iterator
+    if match_trait_method(cx, expr, &paths::ITERATOR) {
+        let msg = "called `filter_map(..).map(..)` on an `Iterator`";
+        let hint = "this is more succinctly expressed by only calling `.filter_map(..)` instead";
+        span_lint_and_help(cx, FILTER_MAP, expr.span, msg, None, hint);
+    }
+}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 61d562cbc28..2e5dc857b44 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -5,6 +5,7 @@ mod expect_used;
 mod filetype_is_file;
 mod filter_map;
 mod filter_map_identity;
+mod filter_map_map;
 mod filter_next;
 mod from_iter_instead_of_collect;
 mod get_unwrap;
@@ -1700,7 +1701,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             ["next", "skip_while"] => skip_while_next::check(cx, expr, arg_lists[1]),
             ["next", "iter"] => iter_next_slice::check(cx, expr, arg_lists[1]),
             ["map", "filter"] => filter_map::check(cx, expr, false),
-            ["map", "filter_map"] => lint_filter_map_map(cx, expr, arg_lists[1], arg_lists[0]),
+            ["map", "filter_map"] => filter_map_map::check(cx, expr, arg_lists[1], arg_lists[0]),
             ["next", "filter_map"] => lint_filter_map_next(cx, expr, arg_lists[1], self.msrv.as_ref()),
             ["map", "find"] => filter_map::check(cx, expr, true),
             ["flat_map", "filter"] => lint_filter_flat_map(cx, expr, arg_lists[1], arg_lists[0]),
@@ -2785,21 +2786,6 @@ fn lint_filter_map_next<'tcx>(
     }
 }
 
-/// lint use of `filter_map().map()` for `Iterators`
-fn lint_filter_map_map<'tcx>(
-    cx: &LateContext<'tcx>,
-    expr: &'tcx hir::Expr<'_>,
-    _filter_args: &'tcx [hir::Expr<'_>],
-    _map_args: &'tcx [hir::Expr<'_>],
-) {
-    // lint if caller of `.filter_map().map()` is an Iterator
-    if match_trait_method(cx, expr, &paths::ITERATOR) {
-        let msg = "called `filter_map(..).map(..)` on an `Iterator`";
-        let hint = "this is more succinctly expressed by only calling `.filter_map(..)` instead";
-        span_lint_and_help(cx, FILTER_MAP, expr.span, msg, None, hint);
-    }
-}
-
 /// lint use of `filter().flat_map()` for `Iterators`
 fn lint_filter_flat_map<'tcx>(
     cx: &LateContext<'tcx>,
-- 
cgit 1.4.1-3-g733a5


From 2baf043c374396dea3354eb8bc56af7539bf30b4 Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Sat, 6 Mar 2021 18:11:42 +0900
Subject: move filter_map_next to its own module

---
 clippy_lints/src/methods/filter_map_next.rs | 40 +++++++++++++++++++++++++++++
 clippy_lints/src/methods/mod.rs             | 37 ++------------------------
 2 files changed, 42 insertions(+), 35 deletions(-)
 create mode 100644 clippy_lints/src/methods/filter_map_next.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/filter_map_next.rs b/clippy_lints/src/methods/filter_map_next.rs
new file mode 100644
index 00000000000..a789df922ff
--- /dev/null
+++ b/clippy_lints/src/methods/filter_map_next.rs
@@ -0,0 +1,40 @@
+use crate::utils::{match_trait_method, meets_msrv, paths, snippet, span_lint, span_lint_and_sugg};
+use rustc_errors::Applicability;
+use rustc_hir as hir;
+use rustc_lint::LateContext;
+use rustc_semver::RustcVersion;
+
+use super::FILTER_MAP_NEXT;
+
+const FILTER_MAP_NEXT_MSRV: RustcVersion = RustcVersion::new(1, 30, 0);
+
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx hir::Expr<'_>,
+    filter_args: &'tcx [hir::Expr<'_>],
+    msrv: Option<&RustcVersion>,
+) {
+    if match_trait_method(cx, expr, &paths::ITERATOR) {
+        if !meets_msrv(msrv, &FILTER_MAP_NEXT_MSRV) {
+            return;
+        }
+
+        let msg = "called `filter_map(..).next()` on an `Iterator`. This is more succinctly expressed by calling \
+                   `.find_map(..)` instead";
+        let filter_snippet = snippet(cx, filter_args[1].span, "..");
+        if filter_snippet.lines().count() <= 1 {
+            let iter_snippet = snippet(cx, filter_args[0].span, "..");
+            span_lint_and_sugg(
+                cx,
+                FILTER_MAP_NEXT,
+                expr.span,
+                msg,
+                "try this",
+                format!("{}.find_map({})", iter_snippet, filter_snippet),
+                Applicability::MachineApplicable,
+            );
+        } else {
+            span_lint(cx, FILTER_MAP_NEXT, expr.span, msg);
+        }
+    }
+}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 2e5dc857b44..fe1327564b2 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -6,6 +6,7 @@ mod filetype_is_file;
 mod filter_map;
 mod filter_map_identity;
 mod filter_map_map;
+mod filter_map_next;
 mod filter_next;
 mod from_iter_instead_of_collect;
 mod get_unwrap;
@@ -1702,7 +1703,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             ["next", "iter"] => iter_next_slice::check(cx, expr, arg_lists[1]),
             ["map", "filter"] => filter_map::check(cx, expr, false),
             ["map", "filter_map"] => filter_map_map::check(cx, expr, arg_lists[1], arg_lists[0]),
-            ["next", "filter_map"] => lint_filter_map_next(cx, expr, arg_lists[1], self.msrv.as_ref()),
+            ["next", "filter_map"] => filter_map_next::check(cx, expr, arg_lists[1], self.msrv.as_ref()),
             ["map", "find"] => filter_map::check(cx, expr, true),
             ["flat_map", "filter"] => lint_filter_flat_map(cx, expr, arg_lists[1], arg_lists[0]),
             ["flat_map", "filter_map"] => lint_filter_map_flat_map(cx, expr, arg_lists[1], arg_lists[0]),
@@ -2752,40 +2753,6 @@ fn lint_map_or_none<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, map
     );
 }
 
-const FILTER_MAP_NEXT_MSRV: RustcVersion = RustcVersion::new(1, 30, 0);
-
-/// lint use of `filter_map().next()` for `Iterators`
-fn lint_filter_map_next<'tcx>(
-    cx: &LateContext<'tcx>,
-    expr: &'tcx hir::Expr<'_>,
-    filter_args: &'tcx [hir::Expr<'_>],
-    msrv: Option<&RustcVersion>,
-) {
-    if match_trait_method(cx, expr, &paths::ITERATOR) {
-        if !meets_msrv(msrv, &FILTER_MAP_NEXT_MSRV) {
-            return;
-        }
-
-        let msg = "called `filter_map(..).next()` on an `Iterator`. This is more succinctly expressed by calling \
-                   `.find_map(..)` instead";
-        let filter_snippet = snippet(cx, filter_args[1].span, "..");
-        if filter_snippet.lines().count() <= 1 {
-            let iter_snippet = snippet(cx, filter_args[0].span, "..");
-            span_lint_and_sugg(
-                cx,
-                FILTER_MAP_NEXT,
-                expr.span,
-                msg,
-                "try this",
-                format!("{}.find_map({})", iter_snippet, filter_snippet),
-                Applicability::MachineApplicable,
-            );
-        } else {
-            span_lint(cx, FILTER_MAP_NEXT, expr.span, msg);
-        }
-    }
-}
-
 /// lint use of `filter().flat_map()` for `Iterators`
 fn lint_filter_flat_map<'tcx>(
     cx: &LateContext<'tcx>,
-- 
cgit 1.4.1-3-g733a5


From 6d941616f925298124eabe3ca10e48ec10bb33a9 Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Sat, 6 Mar 2021 18:19:18 +0900
Subject: move filter_flat_map to its own module

---
 clippy_lints/src/methods/filter_flat_map.rs | 21 +++++++++++++++++++++
 clippy_lints/src/methods/mod.rs             | 19 ++-----------------
 2 files changed, 23 insertions(+), 17 deletions(-)
 create mode 100644 clippy_lints/src/methods/filter_flat_map.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/filter_flat_map.rs b/clippy_lints/src/methods/filter_flat_map.rs
new file mode 100644
index 00000000000..8da867fce51
--- /dev/null
+++ b/clippy_lints/src/methods/filter_flat_map.rs
@@ -0,0 +1,21 @@
+use crate::utils::{match_trait_method, paths, span_lint_and_help};
+use rustc_hir as hir;
+use rustc_lint::LateContext;
+
+use super::FILTER_MAP;
+
+/// lint use of `filter().flat_map()` for `Iterators`
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx hir::Expr<'_>,
+    _filter_args: &'tcx [hir::Expr<'_>],
+    _map_args: &'tcx [hir::Expr<'_>],
+) {
+    // lint if caller of `.filter().flat_map()` is an Iterator
+    if match_trait_method(cx, expr, &paths::ITERATOR) {
+        let msg = "called `filter(..).flat_map(..)` on an `Iterator`";
+        let hint = "this is more succinctly expressed by calling `.flat_map(..)` \
+                    and filtering by returning `iter::empty()`";
+        span_lint_and_help(cx, FILTER_MAP, expr.span, msg, None, hint);
+    }
+}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index fe1327564b2..3251a49da09 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3,6 +3,7 @@ mod bytes_nth;
 mod clone_on_ref_ptr;
 mod expect_used;
 mod filetype_is_file;
+mod filter_flat_map;
 mod filter_map;
 mod filter_map_identity;
 mod filter_map_map;
@@ -1705,7 +1706,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             ["map", "filter_map"] => filter_map_map::check(cx, expr, arg_lists[1], arg_lists[0]),
             ["next", "filter_map"] => filter_map_next::check(cx, expr, arg_lists[1], self.msrv.as_ref()),
             ["map", "find"] => filter_map::check(cx, expr, true),
-            ["flat_map", "filter"] => lint_filter_flat_map(cx, expr, arg_lists[1], arg_lists[0]),
+            ["flat_map", "filter"] => filter_flat_map::check(cx, expr, arg_lists[1], arg_lists[0]),
             ["flat_map", "filter_map"] => lint_filter_map_flat_map(cx, expr, arg_lists[1], arg_lists[0]),
             ["flat_map", ..] => lint_flat_map_identity(cx, expr, arg_lists[0], method_spans[0]),
             ["flatten", "map"] => lint_map_flatten(cx, expr, arg_lists[1]),
@@ -2753,22 +2754,6 @@ fn lint_map_or_none<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, map
     );
 }
 
-/// lint use of `filter().flat_map()` for `Iterators`
-fn lint_filter_flat_map<'tcx>(
-    cx: &LateContext<'tcx>,
-    expr: &'tcx hir::Expr<'_>,
-    _filter_args: &'tcx [hir::Expr<'_>],
-    _map_args: &'tcx [hir::Expr<'_>],
-) {
-    // lint if caller of `.filter().flat_map()` is an Iterator
-    if match_trait_method(cx, expr, &paths::ITERATOR) {
-        let msg = "called `filter(..).flat_map(..)` on an `Iterator`";
-        let hint = "this is more succinctly expressed by calling `.flat_map(..)` \
-                    and filtering by returning `iter::empty()`";
-        span_lint_and_help(cx, FILTER_MAP, expr.span, msg, None, hint);
-    }
-}
-
 /// lint use of `filter_map().flat_map()` for `Iterators`
 fn lint_filter_map_flat_map<'tcx>(
     cx: &LateContext<'tcx>,
-- 
cgit 1.4.1-3-g733a5


From f430384f04ee3ee62156a9e3060ba4d9054278b5 Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Sat, 6 Mar 2021 18:22:15 +0900
Subject: move filter_map_flat_map to its own module

---
 clippy_lints/src/methods/filter_map_flat_map.rs | 21 +++++++++++++++++++++
 clippy_lints/src/methods/mod.rs                 | 19 ++-----------------
 2 files changed, 23 insertions(+), 17 deletions(-)
 create mode 100644 clippy_lints/src/methods/filter_map_flat_map.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/filter_map_flat_map.rs b/clippy_lints/src/methods/filter_map_flat_map.rs
new file mode 100644
index 00000000000..a6db138623a
--- /dev/null
+++ b/clippy_lints/src/methods/filter_map_flat_map.rs
@@ -0,0 +1,21 @@
+use crate::utils::{match_trait_method, paths, span_lint_and_help};
+use rustc_hir as hir;
+use rustc_lint::LateContext;
+
+use super::FILTER_MAP;
+
+/// lint use of `filter_map().flat_map()` for `Iterators`
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx hir::Expr<'_>,
+    _filter_args: &'tcx [hir::Expr<'_>],
+    _map_args: &'tcx [hir::Expr<'_>],
+) {
+    // lint if caller of `.filter_map().flat_map()` is an Iterator
+    if match_trait_method(cx, expr, &paths::ITERATOR) {
+        let msg = "called `filter_map(..).flat_map(..)` on an `Iterator`";
+        let hint = "this is more succinctly expressed by calling `.flat_map(..)` \
+                    and filtering by returning `iter::empty()`";
+        span_lint_and_help(cx, FILTER_MAP, expr.span, msg, None, hint);
+    }
+}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 3251a49da09..34e1463f630 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -5,6 +5,7 @@ mod expect_used;
 mod filetype_is_file;
 mod filter_flat_map;
 mod filter_map;
+mod filter_map_flat_map;
 mod filter_map_identity;
 mod filter_map_map;
 mod filter_map_next;
@@ -1707,7 +1708,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             ["next", "filter_map"] => filter_map_next::check(cx, expr, arg_lists[1], self.msrv.as_ref()),
             ["map", "find"] => filter_map::check(cx, expr, true),
             ["flat_map", "filter"] => filter_flat_map::check(cx, expr, arg_lists[1], arg_lists[0]),
-            ["flat_map", "filter_map"] => lint_filter_map_flat_map(cx, expr, arg_lists[1], arg_lists[0]),
+            ["flat_map", "filter_map"] => filter_map_flat_map::check(cx, expr, arg_lists[1], arg_lists[0]),
             ["flat_map", ..] => lint_flat_map_identity(cx, expr, arg_lists[0], method_spans[0]),
             ["flatten", "map"] => lint_map_flatten(cx, expr, arg_lists[1]),
             ["is_some", "find"] => lint_search_is_some(cx, expr, "find", arg_lists[1], arg_lists[0], method_spans[1]),
@@ -2754,22 +2755,6 @@ fn lint_map_or_none<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, map
     );
 }
 
-/// lint use of `filter_map().flat_map()` for `Iterators`
-fn lint_filter_map_flat_map<'tcx>(
-    cx: &LateContext<'tcx>,
-    expr: &'tcx hir::Expr<'_>,
-    _filter_args: &'tcx [hir::Expr<'_>],
-    _map_args: &'tcx [hir::Expr<'_>],
-) {
-    // lint if caller of `.filter_map().flat_map()` is an Iterator
-    if match_trait_method(cx, expr, &paths::ITERATOR) {
-        let msg = "called `filter_map(..).flat_map(..)` on an `Iterator`";
-        let hint = "this is more succinctly expressed by calling `.flat_map(..)` \
-                    and filtering by returning `iter::empty()`";
-        span_lint_and_help(cx, FILTER_MAP, expr.span, msg, None, hint);
-    }
-}
-
 /// lint use of `flat_map` for `Iterators` where `flatten` would be sufficient
 fn lint_flat_map_identity<'tcx>(
     cx: &LateContext<'tcx>,
-- 
cgit 1.4.1-3-g733a5


From 37ba779a532cd229a18e8a99342f351ba035aa30 Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Sat, 6 Mar 2021 18:30:40 +0900
Subject: move flat_map_identity to its own module

---
 clippy_lints/src/methods/flat_map_identity.rs | 57 +++++++++++++++++++++++++++
 clippy_lints/src/methods/mod.rs               | 52 +-----------------------
 2 files changed, 59 insertions(+), 50 deletions(-)
 create mode 100644 clippy_lints/src/methods/flat_map_identity.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/flat_map_identity.rs b/clippy_lints/src/methods/flat_map_identity.rs
new file mode 100644
index 00000000000..ce3194f8a23
--- /dev/null
+++ b/clippy_lints/src/methods/flat_map_identity.rs
@@ -0,0 +1,57 @@
+use crate::utils::{match_qpath, match_trait_method, paths, span_lint_and_sugg};
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir as hir;
+use rustc_lint::LateContext;
+use rustc_span::source_map::Span;
+
+use super::FLAT_MAP_IDENTITY;
+
+/// lint use of `flat_map` for `Iterators` where `flatten` would be sufficient
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx hir::Expr<'_>,
+    flat_map_args: &'tcx [hir::Expr<'_>],
+    flat_map_span: Span,
+) {
+    if match_trait_method(cx, expr, &paths::ITERATOR) {
+        let arg_node = &flat_map_args[1].kind;
+
+        let apply_lint = |message: &str| {
+            span_lint_and_sugg(
+                cx,
+                FLAT_MAP_IDENTITY,
+                flat_map_span.with_hi(expr.span.hi()),
+                message,
+                "try",
+                "flatten()".to_string(),
+                Applicability::MachineApplicable,
+            );
+        };
+
+        if_chain! {
+            if let hir::ExprKind::Closure(_, _, body_id, _, _) = arg_node;
+            let body = cx.tcx.hir().body(*body_id);
+
+            if let hir::PatKind::Binding(_, _, binding_ident, _) = body.params[0].pat.kind;
+            if let hir::ExprKind::Path(hir::QPath::Resolved(_, ref path)) = body.value.kind;
+
+            if path.segments.len() == 1;
+            if path.segments[0].ident.name == binding_ident.name;
+
+            then {
+                apply_lint("called `flat_map(|x| x)` on an `Iterator`");
+            }
+        }
+
+        if_chain! {
+            if let hir::ExprKind::Path(ref qpath) = arg_node;
+
+            if match_qpath(qpath, &paths::STD_CONVERT_IDENTITY);
+
+            then {
+                apply_lint("called `flat_map(std::convert::identity)` on an `Iterator`");
+            }
+        }
+    }
+}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 34e1463f630..6a425e6e3ed 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -10,6 +10,7 @@ mod filter_map_identity;
 mod filter_map_map;
 mod filter_map_next;
 mod filter_next;
+mod flat_map_identity;
 mod from_iter_instead_of_collect;
 mod get_unwrap;
 mod implicit_clone;
@@ -1709,7 +1710,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             ["map", "find"] => filter_map::check(cx, expr, true),
             ["flat_map", "filter"] => filter_flat_map::check(cx, expr, arg_lists[1], arg_lists[0]),
             ["flat_map", "filter_map"] => filter_map_flat_map::check(cx, expr, arg_lists[1], arg_lists[0]),
-            ["flat_map", ..] => lint_flat_map_identity(cx, expr, arg_lists[0], method_spans[0]),
+            ["flat_map", ..] => flat_map_identity::check(cx, expr, arg_lists[0], method_spans[0]),
             ["flatten", "map"] => lint_map_flatten(cx, expr, arg_lists[1]),
             ["is_some", "find"] => lint_search_is_some(cx, expr, "find", arg_lists[1], arg_lists[0], method_spans[1]),
             ["is_some", "position"] => {
@@ -2755,55 +2756,6 @@ fn lint_map_or_none<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, map
     );
 }
 
-/// lint use of `flat_map` for `Iterators` where `flatten` would be sufficient
-fn lint_flat_map_identity<'tcx>(
-    cx: &LateContext<'tcx>,
-    expr: &'tcx hir::Expr<'_>,
-    flat_map_args: &'tcx [hir::Expr<'_>],
-    flat_map_span: Span,
-) {
-    if match_trait_method(cx, expr, &paths::ITERATOR) {
-        let arg_node = &flat_map_args[1].kind;
-
-        let apply_lint = |message: &str| {
-            span_lint_and_sugg(
-                cx,
-                FLAT_MAP_IDENTITY,
-                flat_map_span.with_hi(expr.span.hi()),
-                message,
-                "try",
-                "flatten()".to_string(),
-                Applicability::MachineApplicable,
-            );
-        };
-
-        if_chain! {
-            if let hir::ExprKind::Closure(_, _, body_id, _, _) = arg_node;
-            let body = cx.tcx.hir().body(*body_id);
-
-            if let hir::PatKind::Binding(_, _, binding_ident, _) = body.params[0].pat.kind;
-            if let hir::ExprKind::Path(hir::QPath::Resolved(_, ref path)) = body.value.kind;
-
-            if path.segments.len() == 1;
-            if path.segments[0].ident.name == binding_ident.name;
-
-            then {
-                apply_lint("called `flat_map(|x| x)` on an `Iterator`");
-            }
-        }
-
-        if_chain! {
-            if let hir::ExprKind::Path(ref qpath) = arg_node;
-
-            if match_qpath(qpath, &paths::STD_CONVERT_IDENTITY);
-
-            then {
-                apply_lint("called `flat_map(std::convert::identity)` on an `Iterator`");
-            }
-        }
-    }
-}
-
 /// lint searching an Iterator followed by `is_some()`
 /// or calling `find()` on a string followed by `is_some()`
 fn lint_search_is_some<'tcx>(
-- 
cgit 1.4.1-3-g733a5


From 24909fabd27091a7b363dcbc549636e98ba4a898 Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Sat, 6 Mar 2021 18:41:43 +0900
Subject: move map_flatten and search_is_some to their own modules

---
 clippy_lints/src/methods/map_flatten.rs    |  61 ++++++++++++
 clippy_lints/src/methods/mod.rs            | 150 ++---------------------------
 clippy_lints/src/methods/search_is_some.rs | 101 +++++++++++++++++++
 3 files changed, 168 insertions(+), 144 deletions(-)
 create mode 100644 clippy_lints/src/methods/map_flatten.rs
 create mode 100644 clippy_lints/src/methods/search_is_some.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/map_flatten.rs b/clippy_lints/src/methods/map_flatten.rs
new file mode 100644
index 00000000000..14a14e4f9ec
--- /dev/null
+++ b/clippy_lints/src/methods/map_flatten.rs
@@ -0,0 +1,61 @@
+use crate::utils::{is_type_diagnostic_item, match_trait_method, paths, snippet, span_lint_and_sugg};
+use rustc_errors::Applicability;
+use rustc_hir as hir;
+use rustc_lint::LateContext;
+use rustc_middle::ty;
+use rustc_span::symbol::sym;
+
+use super::MAP_FLATTEN;
+
+/// lint use of `map().flatten()` for `Iterators` and 'Options'
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, map_args: &'tcx [hir::Expr<'_>]) {
+    // lint if caller of `.map().flatten()` is an Iterator
+    if match_trait_method(cx, expr, &paths::ITERATOR) {
+        let map_closure_ty = cx.typeck_results().expr_ty(&map_args[1]);
+        let is_map_to_option = match map_closure_ty.kind() {
+            ty::Closure(_, _) | ty::FnDef(_, _) | ty::FnPtr(_) => {
+                let map_closure_sig = match map_closure_ty.kind() {
+                    ty::Closure(_, substs) => substs.as_closure().sig(),
+                    _ => map_closure_ty.fn_sig(cx.tcx),
+                };
+                let map_closure_return_ty = cx.tcx.erase_late_bound_regions(map_closure_sig.output());
+                is_type_diagnostic_item(cx, map_closure_return_ty, sym::option_type)
+            },
+            _ => false,
+        };
+
+        let method_to_use = if is_map_to_option {
+            // `(...).map(...)` has type `impl Iterator<Item=Option<...>>
+            "filter_map"
+        } else {
+            // `(...).map(...)` has type `impl Iterator<Item=impl Iterator<...>>
+            "flat_map"
+        };
+        let func_snippet = snippet(cx, map_args[1].span, "..");
+        let hint = format!(".{0}({1})", method_to_use, func_snippet);
+        span_lint_and_sugg(
+            cx,
+            MAP_FLATTEN,
+            expr.span.with_lo(map_args[0].span.hi()),
+            "called `map(..).flatten()` on an `Iterator`",
+            &format!("try using `{}` instead", method_to_use),
+            hint,
+            Applicability::MachineApplicable,
+        );
+    }
+
+    // lint if caller of `.map().flatten()` is an Option
+    if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&map_args[0]), sym::option_type) {
+        let func_snippet = snippet(cx, map_args[1].span, "..");
+        let hint = format!(".and_then({})", func_snippet);
+        span_lint_and_sugg(
+            cx,
+            MAP_FLATTEN,
+            expr.span.with_lo(map_args[0].span.hi()),
+            "called `map(..).flatten()` on an `Option`",
+            "try using `and_then` instead",
+            hint,
+            Applicability::MachineApplicable,
+        );
+    }
+}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 6a425e6e3ed..2b8bb0b4216 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -25,9 +25,11 @@ mod iter_nth_zero;
 mod iterator_step_by_zero;
 mod manual_saturating_arithmetic;
 mod map_collect_result_unit;
+mod map_flatten;
 mod ok_expect;
 mod option_as_ref_deref;
 mod option_map_unwrap_or;
+mod search_is_some;
 mod single_char_insert_string;
 mod single_char_pattern;
 mod single_char_push_string;
@@ -1711,13 +1713,13 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             ["flat_map", "filter"] => filter_flat_map::check(cx, expr, arg_lists[1], arg_lists[0]),
             ["flat_map", "filter_map"] => filter_map_flat_map::check(cx, expr, arg_lists[1], arg_lists[0]),
             ["flat_map", ..] => flat_map_identity::check(cx, expr, arg_lists[0], method_spans[0]),
-            ["flatten", "map"] => lint_map_flatten(cx, expr, arg_lists[1]),
-            ["is_some", "find"] => lint_search_is_some(cx, expr, "find", arg_lists[1], arg_lists[0], method_spans[1]),
+            ["flatten", "map"] => map_flatten::check(cx, expr, arg_lists[1]),
+            ["is_some", "find"] => search_is_some::check(cx, expr, "find", arg_lists[1], arg_lists[0], method_spans[1]),
             ["is_some", "position"] => {
-                lint_search_is_some(cx, expr, "position", arg_lists[1], arg_lists[0], method_spans[1])
+                search_is_some::check(cx, expr, "position", arg_lists[1], arg_lists[0], method_spans[1])
             },
             ["is_some", "rposition"] => {
-                lint_search_is_some(cx, expr, "rposition", arg_lists[1], arg_lists[0], method_spans[1])
+                search_is_some::check(cx, expr, "rposition", arg_lists[1], arg_lists[0], method_spans[1])
             },
             ["extend", ..] => string_extend_chars::check(cx, expr, arg_lists[0]),
             ["count", "into_iter"] => iter_count::check(cx, expr, &arg_lists[1], "into_iter"),
@@ -2566,59 +2568,6 @@ fn derefs_to_slice<'tcx>(
     }
 }
 
-/// lint use of `map().flatten()` for `Iterators` and 'Options'
-fn lint_map_flatten<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, map_args: &'tcx [hir::Expr<'_>]) {
-    // lint if caller of `.map().flatten()` is an Iterator
-    if match_trait_method(cx, expr, &paths::ITERATOR) {
-        let map_closure_ty = cx.typeck_results().expr_ty(&map_args[1]);
-        let is_map_to_option = match map_closure_ty.kind() {
-            ty::Closure(_, _) | ty::FnDef(_, _) | ty::FnPtr(_) => {
-                let map_closure_sig = match map_closure_ty.kind() {
-                    ty::Closure(_, substs) => substs.as_closure().sig(),
-                    _ => map_closure_ty.fn_sig(cx.tcx),
-                };
-                let map_closure_return_ty = cx.tcx.erase_late_bound_regions(map_closure_sig.output());
-                is_type_diagnostic_item(cx, map_closure_return_ty, sym::option_type)
-            },
-            _ => false,
-        };
-
-        let method_to_use = if is_map_to_option {
-            // `(...).map(...)` has type `impl Iterator<Item=Option<...>>
-            "filter_map"
-        } else {
-            // `(...).map(...)` has type `impl Iterator<Item=impl Iterator<...>>
-            "flat_map"
-        };
-        let func_snippet = snippet(cx, map_args[1].span, "..");
-        let hint = format!(".{0}({1})", method_to_use, func_snippet);
-        span_lint_and_sugg(
-            cx,
-            MAP_FLATTEN,
-            expr.span.with_lo(map_args[0].span.hi()),
-            "called `map(..).flatten()` on an `Iterator`",
-            &format!("try using `{}` instead", method_to_use),
-            hint,
-            Applicability::MachineApplicable,
-        );
-    }
-
-    // lint if caller of `.map().flatten()` is an Option
-    if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&map_args[0]), sym::option_type) {
-        let func_snippet = snippet(cx, map_args[1].span, "..");
-        let hint = format!(".and_then({})", func_snippet);
-        span_lint_and_sugg(
-            cx,
-            MAP_FLATTEN,
-            expr.span.with_lo(map_args[0].span.hi()),
-            "called `map(..).flatten()` on an `Option`",
-            "try using `and_then` instead",
-            hint,
-            Applicability::MachineApplicable,
-        );
-    }
-}
-
 const MAP_UNWRAP_OR_MSRV: RustcVersion = RustcVersion::new(1, 41, 0);
 
 /// lint use of `map().unwrap_or_else()` for `Option`s and `Result`s
@@ -2756,93 +2705,6 @@ fn lint_map_or_none<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, map
     );
 }
 
-/// lint searching an Iterator followed by `is_some()`
-/// or calling `find()` on a string followed by `is_some()`
-fn lint_search_is_some<'tcx>(
-    cx: &LateContext<'tcx>,
-    expr: &'tcx hir::Expr<'_>,
-    search_method: &str,
-    search_args: &'tcx [hir::Expr<'_>],
-    is_some_args: &'tcx [hir::Expr<'_>],
-    method_span: Span,
-) {
-    // lint if caller of search is an Iterator
-    if match_trait_method(cx, &is_some_args[0], &paths::ITERATOR) {
-        let msg = format!(
-            "called `is_some()` after searching an `Iterator` with `{}`",
-            search_method
-        );
-        let hint = "this is more succinctly expressed by calling `any()`";
-        let search_snippet = snippet(cx, search_args[1].span, "..");
-        if search_snippet.lines().count() <= 1 {
-            // suggest `any(|x| ..)` instead of `any(|&x| ..)` for `find(|&x| ..).is_some()`
-            // suggest `any(|..| *..)` instead of `any(|..| **..)` for `find(|..| **..).is_some()`
-            let any_search_snippet = if_chain! {
-                if search_method == "find";
-                if let hir::ExprKind::Closure(_, _, body_id, ..) = search_args[1].kind;
-                let closure_body = cx.tcx.hir().body(body_id);
-                if let Some(closure_arg) = closure_body.params.get(0);
-                then {
-                    if let hir::PatKind::Ref(..) = closure_arg.pat.kind {
-                        Some(search_snippet.replacen('&', "", 1))
-                    } else if let PatKind::Binding(_, _, ident, _) = strip_pat_refs(&closure_arg.pat).kind {
-                        let name = &*ident.name.as_str();
-                        Some(search_snippet.replace(&format!("*{}", name), name))
-                    } else {
-                        None
-                    }
-                } else {
-                    None
-                }
-            };
-            // add note if not multi-line
-            span_lint_and_sugg(
-                cx,
-                SEARCH_IS_SOME,
-                method_span.with_hi(expr.span.hi()),
-                &msg,
-                "use `any()` instead",
-                format!(
-                    "any({})",
-                    any_search_snippet.as_ref().map_or(&*search_snippet, String::as_str)
-                ),
-                Applicability::MachineApplicable,
-            );
-        } else {
-            span_lint_and_help(cx, SEARCH_IS_SOME, expr.span, &msg, None, hint);
-        }
-    }
-    // lint if `find()` is called by `String` or `&str`
-    else if search_method == "find" {
-        let is_string_or_str_slice = |e| {
-            let self_ty = cx.typeck_results().expr_ty(e).peel_refs();
-            if is_type_diagnostic_item(cx, self_ty, sym::string_type) {
-                true
-            } else {
-                *self_ty.kind() == ty::Str
-            }
-        };
-        if_chain! {
-            if is_string_or_str_slice(&search_args[0]);
-            if is_string_or_str_slice(&search_args[1]);
-            then {
-                let msg = "called `is_some()` after calling `find()` on a string";
-                let mut applicability = Applicability::MachineApplicable;
-                let find_arg = snippet_with_applicability(cx, search_args[1].span, "..", &mut applicability);
-                span_lint_and_sugg(
-                    cx,
-                    SEARCH_IS_SOME,
-                    method_span.with_hi(expr.span.hi()),
-                    msg,
-                    "use `contains()` instead",
-                    format!("contains({})", find_arg),
-                    applicability,
-                );
-            }
-        }
-    }
-}
-
 /// Used for `lint_binary_expr_with_method_call`.
 #[derive(Copy, Clone)]
 struct BinaryExprInfo<'a> {
diff --git a/clippy_lints/src/methods/search_is_some.rs b/clippy_lints/src/methods/search_is_some.rs
new file mode 100644
index 00000000000..e9e65443220
--- /dev/null
+++ b/clippy_lints/src/methods/search_is_some.rs
@@ -0,0 +1,101 @@
+use crate::utils::{
+    is_type_diagnostic_item, match_trait_method, paths, snippet, snippet_with_applicability, span_lint_and_help,
+    span_lint_and_sugg, strip_pat_refs,
+};
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir as hir;
+use rustc_hir::PatKind;
+use rustc_lint::LateContext;
+use rustc_middle::ty;
+use rustc_span::source_map::Span;
+use rustc_span::symbol::sym;
+
+use super::SEARCH_IS_SOME;
+
+/// lint searching an Iterator followed by `is_some()`
+/// or calling `find()` on a string followed by `is_some()`
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx hir::Expr<'_>,
+    search_method: &str,
+    search_args: &'tcx [hir::Expr<'_>],
+    is_some_args: &'tcx [hir::Expr<'_>],
+    method_span: Span,
+) {
+    // lint if caller of search is an Iterator
+    if match_trait_method(cx, &is_some_args[0], &paths::ITERATOR) {
+        let msg = format!(
+            "called `is_some()` after searching an `Iterator` with `{}`",
+            search_method
+        );
+        let hint = "this is more succinctly expressed by calling `any()`";
+        let search_snippet = snippet(cx, search_args[1].span, "..");
+        if search_snippet.lines().count() <= 1 {
+            // suggest `any(|x| ..)` instead of `any(|&x| ..)` for `find(|&x| ..).is_some()`
+            // suggest `any(|..| *..)` instead of `any(|..| **..)` for `find(|..| **..).is_some()`
+            let any_search_snippet = if_chain! {
+                if search_method == "find";
+                if let hir::ExprKind::Closure(_, _, body_id, ..) = search_args[1].kind;
+                let closure_body = cx.tcx.hir().body(body_id);
+                if let Some(closure_arg) = closure_body.params.get(0);
+                then {
+                    if let hir::PatKind::Ref(..) = closure_arg.pat.kind {
+                        Some(search_snippet.replacen('&', "", 1))
+                    } else if let PatKind::Binding(_, _, ident, _) = strip_pat_refs(&closure_arg.pat).kind {
+                        let name = &*ident.name.as_str();
+                        Some(search_snippet.replace(&format!("*{}", name), name))
+                    } else {
+                        None
+                    }
+                } else {
+                    None
+                }
+            };
+            // add note if not multi-line
+            span_lint_and_sugg(
+                cx,
+                SEARCH_IS_SOME,
+                method_span.with_hi(expr.span.hi()),
+                &msg,
+                "use `any()` instead",
+                format!(
+                    "any({})",
+                    any_search_snippet.as_ref().map_or(&*search_snippet, String::as_str)
+                ),
+                Applicability::MachineApplicable,
+            );
+        } else {
+            span_lint_and_help(cx, SEARCH_IS_SOME, expr.span, &msg, None, hint);
+        }
+    }
+    // lint if `find()` is called by `String` or `&str`
+    else if search_method == "find" {
+        let is_string_or_str_slice = |e| {
+            let self_ty = cx.typeck_results().expr_ty(e).peel_refs();
+            if is_type_diagnostic_item(cx, self_ty, sym::string_type) {
+                true
+            } else {
+                *self_ty.kind() == ty::Str
+            }
+        };
+        if_chain! {
+            if is_string_or_str_slice(&search_args[0]);
+            if is_string_or_str_slice(&search_args[1]);
+            then {
+                let msg = "called `is_some()` after calling `find()` on a string";
+                let mut applicability = Applicability::MachineApplicable;
+                let find_arg = snippet_with_applicability(cx, search_args[1].span, "..", &mut applicability);
+                span_lint_and_sugg(
+                    cx,
+                    SEARCH_IS_SOME,
+                    method_span.with_hi(expr.span.hi()),
+                    msg,
+                    "use `contains()` instead",
+                    format!("contains({})", find_arg),
+                    applicability,
+                );
+            }
+        }
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 171c4c148540846c8aab4e1f0f491e8bfb892fcf Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Sat, 6 Mar 2021 18:45:25 +0900
Subject: move iter_skip_next to its own module

---
 clippy_lints/src/methods/iter_skip_next.rs | 24 ++++++++++++++++++++++++
 clippy_lints/src/methods/mod.rs            | 21 ++-------------------
 2 files changed, 26 insertions(+), 19 deletions(-)
 create mode 100644 clippy_lints/src/methods/iter_skip_next.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/iter_skip_next.rs b/clippy_lints/src/methods/iter_skip_next.rs
new file mode 100644
index 00000000000..5f5969134e4
--- /dev/null
+++ b/clippy_lints/src/methods/iter_skip_next.rs
@@ -0,0 +1,24 @@
+use crate::utils::{match_trait_method, paths, snippet, span_lint_and_sugg};
+use rustc_errors::Applicability;
+use rustc_hir as hir;
+use rustc_lint::LateContext;
+
+use super::ITER_SKIP_NEXT;
+
+pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, skip_args: &[hir::Expr<'_>]) {
+    // lint if caller of skip is an Iterator
+    if match_trait_method(cx, expr, &paths::ITERATOR) {
+        if let [caller, n] = skip_args {
+            let hint = format!(".nth({})", snippet(cx, n.span, ".."));
+            span_lint_and_sugg(
+                cx,
+                ITER_SKIP_NEXT,
+                expr.span.trim_start(caller.span).unwrap(),
+                "called `skip(..).next()` on an iterator",
+                "use `nth` instead",
+                hint,
+                Applicability::MachineApplicable,
+            );
+        }
+    }
+}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 2b8bb0b4216..927375f9e0b 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -22,6 +22,7 @@ mod iter_count;
 mod iter_next_slice;
 mod iter_nth;
 mod iter_nth_zero;
+mod iter_skip_next;
 mod iterator_step_by_zero;
 mod manual_saturating_arithmetic;
 mod map_collect_result_unit;
@@ -1730,7 +1731,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             ["nth", "bytes"] => bytes_nth::check(cx, expr, &arg_lists[1]),
             ["nth", ..] => iter_nth_zero::check(cx, expr, arg_lists[0]),
             ["step_by", ..] => iterator_step_by_zero::check(cx, expr, arg_lists[0]),
-            ["next", "skip"] => lint_iter_skip_next(cx, expr, arg_lists[1]),
+            ["next", "skip"] => iter_skip_next::check(cx, expr, arg_lists[1]),
             ["collect", "cloned"] => iter_cloned_collect::check(cx, expr, arg_lists[1]),
             ["as_ref"] => lint_asref(cx, expr, "as_ref", arg_lists[0]),
             ["as_mut"] => lint_asref(cx, expr, "as_mut", arg_lists[0]),
@@ -2510,24 +2511,6 @@ fn lint_unnecessary_fold(cx: &LateContext<'_>, expr: &hir::Expr<'_>, fold_args:
     }
 }
 
-fn lint_iter_skip_next(cx: &LateContext<'_>, expr: &hir::Expr<'_>, skip_args: &[hir::Expr<'_>]) {
-    // lint if caller of skip is an Iterator
-    if match_trait_method(cx, expr, &paths::ITERATOR) {
-        if let [caller, n] = skip_args {
-            let hint = format!(".nth({})", snippet(cx, n.span, ".."));
-            span_lint_and_sugg(
-                cx,
-                ITER_SKIP_NEXT,
-                expr.span.trim_start(caller.span).unwrap(),
-                "called `skip(..).next()` on an iterator",
-                "use `nth` instead",
-                hint,
-                Applicability::MachineApplicable,
-            );
-        }
-    }
-}
-
 fn derefs_to_slice<'tcx>(
     cx: &LateContext<'tcx>,
     expr: &'tcx hir::Expr<'tcx>,
-- 
cgit 1.4.1-3-g733a5


From caaba8270c7de1bf3446f3345e7e794295db59fd Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Sat, 6 Mar 2021 18:53:31 +0900
Subject: move clone_on_copy to its own module

---
 clippy_lints/src/methods/clone_on_copy.rs | 109 ++++++++++++++++++++++++++++++
 clippy_lints/src/methods/mod.rs           | 106 +----------------------------
 2 files changed, 112 insertions(+), 103 deletions(-)
 create mode 100644 clippy_lints/src/methods/clone_on_copy.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/clone_on_copy.rs b/clippy_lints/src/methods/clone_on_copy.rs
new file mode 100644
index 00000000000..4a130ed47db
--- /dev/null
+++ b/clippy_lints/src/methods/clone_on_copy.rs
@@ -0,0 +1,109 @@
+use crate::utils::{is_copy, span_lint_and_then, sugg};
+use rustc_errors::Applicability;
+use rustc_hir as hir;
+use rustc_lint::LateContext;
+use rustc_middle::ty::{self, Ty};
+use std::iter;
+
+use super::CLONE_DOUBLE_REF;
+use super::CLONE_ON_COPY;
+
+/// Checks for the `CLONE_ON_COPY` lint.
+pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, arg: &hir::Expr<'_>, arg_ty: Ty<'_>) {
+    let ty = cx.typeck_results().expr_ty(expr);
+    if let ty::Ref(_, inner, _) = arg_ty.kind() {
+        if let ty::Ref(_, innermost, _) = inner.kind() {
+            span_lint_and_then(
+                cx,
+                CLONE_DOUBLE_REF,
+                expr.span,
+                &format!(
+                    "using `clone` on a double-reference; \
+                    this will copy the reference of type `{}` instead of cloning the inner type",
+                    ty
+                ),
+                |diag| {
+                    if let Some(snip) = sugg::Sugg::hir_opt(cx, arg) {
+                        let mut ty = innermost;
+                        let mut n = 0;
+                        while let ty::Ref(_, inner, _) = ty.kind() {
+                            ty = inner;
+                            n += 1;
+                        }
+                        let refs: String = iter::repeat('&').take(n + 1).collect();
+                        let derefs: String = iter::repeat('*').take(n).collect();
+                        let explicit = format!("<{}{}>::clone({})", refs, ty, snip);
+                        diag.span_suggestion(
+                            expr.span,
+                            "try dereferencing it",
+                            format!("{}({}{}).clone()", refs, derefs, snip.deref()),
+                            Applicability::MaybeIncorrect,
+                        );
+                        diag.span_suggestion(
+                            expr.span,
+                            "or try being explicit if you are sure, that you want to clone a reference",
+                            explicit,
+                            Applicability::MaybeIncorrect,
+                        );
+                    }
+                },
+            );
+            return; // don't report clone_on_copy
+        }
+    }
+
+    if is_copy(cx, ty) {
+        let snip;
+        if let Some(snippet) = sugg::Sugg::hir_opt(cx, arg) {
+            let parent = cx.tcx.hir().get_parent_node(expr.hir_id);
+            match &cx.tcx.hir().get(parent) {
+                hir::Node::Expr(parent) => match parent.kind {
+                    // &*x is a nop, &x.clone() is not
+                    hir::ExprKind::AddrOf(..) => return,
+                    // (*x).func() is useless, x.clone().func() can work in case func borrows mutably
+                    hir::ExprKind::MethodCall(_, _, parent_args, _) if expr.hir_id == parent_args[0].hir_id => {
+                        return;
+                    },
+
+                    _ => {},
+                },
+                hir::Node::Stmt(stmt) => {
+                    if let hir::StmtKind::Local(ref loc) = stmt.kind {
+                        if let hir::PatKind::Ref(..) = loc.pat.kind {
+                            // let ref y = *x borrows x, let ref y = x.clone() does not
+                            return;
+                        }
+                    }
+                },
+                _ => {},
+            }
+
+            // x.clone() might have dereferenced x, possibly through Deref impls
+            if cx.typeck_results().expr_ty(arg) == ty {
+                snip = Some(("try removing the `clone` call", format!("{}", snippet)));
+            } else {
+                let deref_count = cx
+                    .typeck_results()
+                    .expr_adjustments(arg)
+                    .iter()
+                    .filter(|adj| matches!(adj.kind, ty::adjustment::Adjust::Deref(_)))
+                    .count();
+                let derefs: String = iter::repeat('*').take(deref_count).collect();
+                snip = Some(("try dereferencing it", format!("{}{}", derefs, snippet)));
+            }
+        } else {
+            snip = None;
+        }
+        span_lint_and_then(
+            cx,
+            CLONE_ON_COPY,
+            expr.span,
+            &format!("using `clone` on type `{}` which implements the `Copy` trait", ty),
+            |diag| {
+                if let Some((text, snip)) = snip {
+                    diag.span_suggestion(expr.span, text, snip, Applicability::MachineApplicable);
+                }
+            },
+        );
+    }
+}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 927375f9e0b..f248a09e18e 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1,5 +1,6 @@
 mod bind_instead_of_map;
 mod bytes_nth;
+mod clone_on_copy;
 mod clone_on_ref_ptr;
 mod expect_used;
 mod filetype_is_file;
@@ -45,7 +46,6 @@ mod wrong_self_convention;
 mod zst_offset;
 
 use std::borrow::Cow;
-use std::iter;
 
 use bind_instead_of_map::BindInsteadOfMap;
 use if_chain::if_chain;
@@ -69,7 +69,7 @@ use crate::utils::{
     is_type_diagnostic_item, iter_input_pats, last_path_segment, match_def_path, match_qpath, match_trait_method,
     match_type, meets_msrv, method_calls, method_chain_args, path_to_local_id, paths, remove_blocks, return_ty,
     single_segment_path, snippet, snippet_with_applicability, snippet_with_macro_callsite, span_lint,
-    span_lint_and_help, span_lint_and_sugg, span_lint_and_then, strip_pat_refs, sugg, walk_ptrs_ty_depth, SpanlessEq,
+    span_lint_and_help, span_lint_and_sugg, strip_pat_refs, walk_ptrs_ty_depth, SpanlessEq,
 };
 
 declare_clippy_lint! {
@@ -1781,7 +1781,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
 
                 let self_ty = cx.typeck_results().expr_ty_adjusted(&args[0]);
                 if args.len() == 1 && method_call.ident.name == sym::clone {
-                    lint_clone_on_copy(cx, expr, &args[0], self_ty);
+                    clone_on_copy::check(cx, expr, &args[0], self_ty);
                     clone_on_ref_ptr::check(cx, expr, &args[0]);
                 }
                 if args.len() == 1 && method_call.ident.name == sym!(to_string) {
@@ -2323,106 +2323,6 @@ fn lint_expect_fun_call(
     );
 }
 
-/// Checks for the `CLONE_ON_COPY` lint.
-fn lint_clone_on_copy(cx: &LateContext<'_>, expr: &hir::Expr<'_>, arg: &hir::Expr<'_>, arg_ty: Ty<'_>) {
-    let ty = cx.typeck_results().expr_ty(expr);
-    if let ty::Ref(_, inner, _) = arg_ty.kind() {
-        if let ty::Ref(_, innermost, _) = inner.kind() {
-            span_lint_and_then(
-                cx,
-                CLONE_DOUBLE_REF,
-                expr.span,
-                &format!(
-                    "using `clone` on a double-reference; \
-                    this will copy the reference of type `{}` instead of cloning the inner type",
-                    ty
-                ),
-                |diag| {
-                    if let Some(snip) = sugg::Sugg::hir_opt(cx, arg) {
-                        let mut ty = innermost;
-                        let mut n = 0;
-                        while let ty::Ref(_, inner, _) = ty.kind() {
-                            ty = inner;
-                            n += 1;
-                        }
-                        let refs: String = iter::repeat('&').take(n + 1).collect();
-                        let derefs: String = iter::repeat('*').take(n).collect();
-                        let explicit = format!("<{}{}>::clone({})", refs, ty, snip);
-                        diag.span_suggestion(
-                            expr.span,
-                            "try dereferencing it",
-                            format!("{}({}{}).clone()", refs, derefs, snip.deref()),
-                            Applicability::MaybeIncorrect,
-                        );
-                        diag.span_suggestion(
-                            expr.span,
-                            "or try being explicit if you are sure, that you want to clone a reference",
-                            explicit,
-                            Applicability::MaybeIncorrect,
-                        );
-                    }
-                },
-            );
-            return; // don't report clone_on_copy
-        }
-    }
-
-    if is_copy(cx, ty) {
-        let snip;
-        if let Some(snippet) = sugg::Sugg::hir_opt(cx, arg) {
-            let parent = cx.tcx.hir().get_parent_node(expr.hir_id);
-            match &cx.tcx.hir().get(parent) {
-                hir::Node::Expr(parent) => match parent.kind {
-                    // &*x is a nop, &x.clone() is not
-                    hir::ExprKind::AddrOf(..) => return,
-                    // (*x).func() is useless, x.clone().func() can work in case func borrows mutably
-                    hir::ExprKind::MethodCall(_, _, parent_args, _) if expr.hir_id == parent_args[0].hir_id => {
-                        return;
-                    },
-
-                    _ => {},
-                },
-                hir::Node::Stmt(stmt) => {
-                    if let hir::StmtKind::Local(ref loc) = stmt.kind {
-                        if let hir::PatKind::Ref(..) = loc.pat.kind {
-                            // let ref y = *x borrows x, let ref y = x.clone() does not
-                            return;
-                        }
-                    }
-                },
-                _ => {},
-            }
-
-            // x.clone() might have dereferenced x, possibly through Deref impls
-            if cx.typeck_results().expr_ty(arg) == ty {
-                snip = Some(("try removing the `clone` call", format!("{}", snippet)));
-            } else {
-                let deref_count = cx
-                    .typeck_results()
-                    .expr_adjustments(arg)
-                    .iter()
-                    .filter(|adj| matches!(adj.kind, ty::adjustment::Adjust::Deref(_)))
-                    .count();
-                let derefs: String = iter::repeat('*').take(deref_count).collect();
-                snip = Some(("try dereferencing it", format!("{}{}", derefs, snippet)));
-            }
-        } else {
-            snip = None;
-        }
-        span_lint_and_then(
-            cx,
-            CLONE_ON_COPY,
-            expr.span,
-            &format!("using `clone` on type `{}` which implements the `Copy` trait", ty),
-            |diag| {
-                if let Some((text, snip)) = snip {
-                    diag.span_suggestion(expr.span, text, snip, Applicability::MachineApplicable);
-                }
-            },
-        );
-    }
-}
-
 fn lint_unnecessary_fold(cx: &LateContext<'_>, expr: &hir::Expr<'_>, fold_args: &[hir::Expr<'_>], fold_span: Span) {
     fn check_fold_with_op(
         cx: &LateContext<'_>,
-- 
cgit 1.4.1-3-g733a5


From 78e572c62782b4bd027c23b9d56a14b0b42ba93a Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Sat, 6 Mar 2021 18:59:35 +0900
Subject: move useless_asref to its own module

---
 clippy_lints/src/methods/mod.rs           | 45 ++++---------------------------
 clippy_lints/src/methods/useless_asref.rs | 45 +++++++++++++++++++++++++++++++
 2 files changed, 50 insertions(+), 40 deletions(-)
 create mode 100644 clippy_lints/src/methods/useless_asref.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index f248a09e18e..eaf247536b6 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -42,6 +42,7 @@ mod uninit_assumed_init;
 mod unnecessary_filter_map;
 mod unnecessary_lazy_eval;
 mod unwrap_used;
+mod useless_asref;
 mod wrong_self_convention;
 mod zst_offset;
 
@@ -65,11 +66,11 @@ use rustc_typeck::hir_ty_to_ty;
 use crate::utils::eager_or_lazy::is_lazyness_candidate;
 use crate::utils::usage::mutated_variables;
 use crate::utils::{
-    contains_return, contains_ty, get_parent_expr, get_trait_def_id, implements_trait, in_macro, is_copy, is_expn_of,
+    contains_return, contains_ty, get_trait_def_id, implements_trait, in_macro, is_copy, is_expn_of,
     is_type_diagnostic_item, iter_input_pats, last_path_segment, match_def_path, match_qpath, match_trait_method,
     match_type, meets_msrv, method_calls, method_chain_args, path_to_local_id, paths, remove_blocks, return_ty,
     single_segment_path, snippet, snippet_with_applicability, snippet_with_macro_callsite, span_lint,
-    span_lint_and_help, span_lint_and_sugg, strip_pat_refs, walk_ptrs_ty_depth, SpanlessEq,
+    span_lint_and_help, span_lint_and_sugg, strip_pat_refs, SpanlessEq,
 };
 
 declare_clippy_lint! {
@@ -1733,8 +1734,8 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             ["step_by", ..] => iterator_step_by_zero::check(cx, expr, arg_lists[0]),
             ["next", "skip"] => iter_skip_next::check(cx, expr, arg_lists[1]),
             ["collect", "cloned"] => iter_cloned_collect::check(cx, expr, arg_lists[1]),
-            ["as_ref"] => lint_asref(cx, expr, "as_ref", arg_lists[0]),
-            ["as_mut"] => lint_asref(cx, expr, "as_mut", arg_lists[0]),
+            ["as_ref"] => useless_asref::check(cx, expr, "as_ref", arg_lists[0]),
+            ["as_mut"] => useless_asref::check(cx, expr, "as_mut", arg_lists[0]),
             ["fold", ..] => lint_unnecessary_fold(cx, expr, arg_lists[0], method_spans[0]),
             ["filter_map", ..] => {
                 unnecessary_filter_map::check(cx, expr, arg_lists[0]);
@@ -2751,42 +2752,6 @@ fn get_hint_if_single_char_arg(
     }
 }
 
-/// Checks for the `USELESS_ASREF` lint.
-fn lint_asref(cx: &LateContext<'_>, expr: &hir::Expr<'_>, call_name: &str, as_ref_args: &[hir::Expr<'_>]) {
-    // when we get here, we've already checked that the call name is "as_ref" or "as_mut"
-    // check if the call is to the actual `AsRef` or `AsMut` trait
-    if match_trait_method(cx, expr, &paths::ASREF_TRAIT) || match_trait_method(cx, expr, &paths::ASMUT_TRAIT) {
-        // check if the type after `as_ref` or `as_mut` is the same as before
-        let recvr = &as_ref_args[0];
-        let rcv_ty = cx.typeck_results().expr_ty(recvr);
-        let res_ty = cx.typeck_results().expr_ty(expr);
-        let (base_res_ty, res_depth) = walk_ptrs_ty_depth(res_ty);
-        let (base_rcv_ty, rcv_depth) = walk_ptrs_ty_depth(rcv_ty);
-        if base_rcv_ty == base_res_ty && rcv_depth >= res_depth {
-            // allow the `as_ref` or `as_mut` if it is followed by another method call
-            if_chain! {
-                if let Some(parent) = get_parent_expr(cx, expr);
-                if let hir::ExprKind::MethodCall(_, ref span, _, _) = parent.kind;
-                if span != &expr.span;
-                then {
-                    return;
-                }
-            }
-
-            let mut applicability = Applicability::MachineApplicable;
-            span_lint_and_sugg(
-                cx,
-                USELESS_ASREF,
-                expr.span,
-                &format!("this call to `{}` does nothing", call_name),
-                "try this",
-                snippet_with_applicability(cx, recvr.span, "..", &mut applicability).to_string(),
-                applicability,
-            );
-        }
-    }
-}
-
 const FN_HEADER: hir::FnHeader = hir::FnHeader {
     unsafety: hir::Unsafety::Normal,
     constness: hir::Constness::NotConst,
diff --git a/clippy_lints/src/methods/useless_asref.rs b/clippy_lints/src/methods/useless_asref.rs
new file mode 100644
index 00000000000..e4554f8d489
--- /dev/null
+++ b/clippy_lints/src/methods/useless_asref.rs
@@ -0,0 +1,45 @@
+use crate::utils::{
+    get_parent_expr, match_trait_method, paths, snippet_with_applicability, span_lint_and_sugg, walk_ptrs_ty_depth,
+};
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir as hir;
+use rustc_lint::LateContext;
+
+use super::USELESS_ASREF;
+
+/// Checks for the `USELESS_ASREF` lint.
+pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, call_name: &str, as_ref_args: &[hir::Expr<'_>]) {
+    // when we get here, we've already checked that the call name is "as_ref" or "as_mut"
+    // check if the call is to the actual `AsRef` or `AsMut` trait
+    if match_trait_method(cx, expr, &paths::ASREF_TRAIT) || match_trait_method(cx, expr, &paths::ASMUT_TRAIT) {
+        // check if the type after `as_ref` or `as_mut` is the same as before
+        let recvr = &as_ref_args[0];
+        let rcv_ty = cx.typeck_results().expr_ty(recvr);
+        let res_ty = cx.typeck_results().expr_ty(expr);
+        let (base_res_ty, res_depth) = walk_ptrs_ty_depth(res_ty);
+        let (base_rcv_ty, rcv_depth) = walk_ptrs_ty_depth(rcv_ty);
+        if base_rcv_ty == base_res_ty && rcv_depth >= res_depth {
+            // allow the `as_ref` or `as_mut` if it is followed by another method call
+            if_chain! {
+                if let Some(parent) = get_parent_expr(cx, expr);
+                if let hir::ExprKind::MethodCall(_, ref span, _, _) = parent.kind;
+                if span != &expr.span;
+                then {
+                    return;
+                }
+            }
+
+            let mut applicability = Applicability::MachineApplicable;
+            span_lint_and_sugg(
+                cx,
+                USELESS_ASREF,
+                expr.span,
+                &format!("this call to `{}` does nothing", call_name),
+                "try this",
+                snippet_with_applicability(cx, recvr.span, "..", &mut applicability).to_string(),
+                applicability,
+            );
+        }
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From bbed852f6fb82aa85f72fc8b2aeffdb90f409495 Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Sat, 6 Mar 2021 19:05:51 +0900
Subject: unnecessary_fold to its own module

---
 clippy_lints/src/methods/mod.rs              | 100 ++------------------------
 clippy_lints/src/methods/unnecessary_fold.rs | 101 +++++++++++++++++++++++++++
 2 files changed, 107 insertions(+), 94 deletions(-)
 create mode 100644 clippy_lints/src/methods/unnecessary_fold.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index eaf247536b6..702c8e76f49 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -40,6 +40,7 @@ mod string_extend_chars;
 mod suspicious_map;
 mod uninit_assumed_init;
 mod unnecessary_filter_map;
+mod unnecessary_fold;
 mod unnecessary_lazy_eval;
 mod unwrap_used;
 mod useless_asref;
@@ -53,7 +54,7 @@ use if_chain::if_chain;
 use rustc_ast::ast;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
-use rustc_hir::{PatKind, TraitItem, TraitItemKind};
+use rustc_hir::{TraitItem, TraitItemKind};
 use rustc_lint::{LateContext, LateLintPass, Lint, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::{self, TraitRef, Ty, TyS};
@@ -67,10 +68,9 @@ use crate::utils::eager_or_lazy::is_lazyness_candidate;
 use crate::utils::usage::mutated_variables;
 use crate::utils::{
     contains_return, contains_ty, get_trait_def_id, implements_trait, in_macro, is_copy, is_expn_of,
-    is_type_diagnostic_item, iter_input_pats, last_path_segment, match_def_path, match_qpath, match_trait_method,
-    match_type, meets_msrv, method_calls, method_chain_args, path_to_local_id, paths, remove_blocks, return_ty,
-    single_segment_path, snippet, snippet_with_applicability, snippet_with_macro_callsite, span_lint,
-    span_lint_and_help, span_lint_and_sugg, strip_pat_refs, SpanlessEq,
+    is_type_diagnostic_item, iter_input_pats, last_path_segment, match_def_path, match_qpath, match_type, meets_msrv,
+    method_calls, method_chain_args, paths, return_ty, single_segment_path, snippet, snippet_with_applicability,
+    snippet_with_macro_callsite, span_lint, span_lint_and_help, span_lint_and_sugg, SpanlessEq,
 };
 
 declare_clippy_lint! {
@@ -1736,7 +1736,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             ["collect", "cloned"] => iter_cloned_collect::check(cx, expr, arg_lists[1]),
             ["as_ref"] => useless_asref::check(cx, expr, "as_ref", arg_lists[0]),
             ["as_mut"] => useless_asref::check(cx, expr, "as_mut", arg_lists[0]),
-            ["fold", ..] => lint_unnecessary_fold(cx, expr, arg_lists[0], method_spans[0]),
+            ["fold", ..] => unnecessary_fold::check(cx, expr, arg_lists[0], method_spans[0]),
             ["filter_map", ..] => {
                 unnecessary_filter_map::check(cx, expr, arg_lists[0]);
                 filter_map_identity::check(cx, expr, arg_lists[0], method_spans[0]);
@@ -2324,94 +2324,6 @@ fn lint_expect_fun_call(
     );
 }
 
-fn lint_unnecessary_fold(cx: &LateContext<'_>, expr: &hir::Expr<'_>, fold_args: &[hir::Expr<'_>], fold_span: Span) {
-    fn check_fold_with_op(
-        cx: &LateContext<'_>,
-        expr: &hir::Expr<'_>,
-        fold_args: &[hir::Expr<'_>],
-        fold_span: Span,
-        op: hir::BinOpKind,
-        replacement_method_name: &str,
-        replacement_has_args: bool,
-    ) {
-        if_chain! {
-            // Extract the body of the closure passed to fold
-            if let hir::ExprKind::Closure(_, _, body_id, _, _) = fold_args[2].kind;
-            let closure_body = cx.tcx.hir().body(body_id);
-            let closure_expr = remove_blocks(&closure_body.value);
-
-            // Check if the closure body is of the form `acc <op> some_expr(x)`
-            if let hir::ExprKind::Binary(ref bin_op, ref left_expr, ref right_expr) = closure_expr.kind;
-            if bin_op.node == op;
-
-            // Extract the names of the two arguments to the closure
-            if let [param_a, param_b] = closure_body.params;
-            if let PatKind::Binding(_, first_arg_id, ..) = strip_pat_refs(&param_a.pat).kind;
-            if let PatKind::Binding(_, second_arg_id, second_arg_ident, _) = strip_pat_refs(&param_b.pat).kind;
-
-            if path_to_local_id(left_expr, first_arg_id);
-            if replacement_has_args || path_to_local_id(right_expr, second_arg_id);
-
-            then {
-                let mut applicability = Applicability::MachineApplicable;
-                let sugg = if replacement_has_args {
-                    format!(
-                        "{replacement}(|{s}| {r})",
-                        replacement = replacement_method_name,
-                        s = second_arg_ident,
-                        r = snippet_with_applicability(cx, right_expr.span, "EXPR", &mut applicability),
-                    )
-                } else {
-                    format!(
-                        "{replacement}()",
-                        replacement = replacement_method_name,
-                    )
-                };
-
-                span_lint_and_sugg(
-                    cx,
-                    UNNECESSARY_FOLD,
-                    fold_span.with_hi(expr.span.hi()),
-                    // TODO #2371 don't suggest e.g., .any(|x| f(x)) if we can suggest .any(f)
-                    "this `.fold` can be written more succinctly using another method",
-                    "try",
-                    sugg,
-                    applicability,
-                );
-            }
-        }
-    }
-
-    // Check that this is a call to Iterator::fold rather than just some function called fold
-    if !match_trait_method(cx, expr, &paths::ITERATOR) {
-        return;
-    }
-
-    assert!(
-        fold_args.len() == 3,
-        "Expected fold_args to have three entries - the receiver, the initial value and the closure"
-    );
-
-    // Check if the first argument to .fold is a suitable literal
-    if let hir::ExprKind::Lit(ref lit) = fold_args[1].kind {
-        match lit.node {
-            ast::LitKind::Bool(false) => {
-                check_fold_with_op(cx, expr, fold_args, fold_span, hir::BinOpKind::Or, "any", true)
-            },
-            ast::LitKind::Bool(true) => {
-                check_fold_with_op(cx, expr, fold_args, fold_span, hir::BinOpKind::And, "all", true)
-            },
-            ast::LitKind::Int(0, _) => {
-                check_fold_with_op(cx, expr, fold_args, fold_span, hir::BinOpKind::Add, "sum", false)
-            },
-            ast::LitKind::Int(1, _) => {
-                check_fold_with_op(cx, expr, fold_args, fold_span, hir::BinOpKind::Mul, "product", false)
-            },
-            _ => (),
-        }
-    }
-}
-
 fn derefs_to_slice<'tcx>(
     cx: &LateContext<'tcx>,
     expr: &'tcx hir::Expr<'tcx>,
diff --git a/clippy_lints/src/methods/unnecessary_fold.rs b/clippy_lints/src/methods/unnecessary_fold.rs
new file mode 100644
index 00000000000..a26443f4ee9
--- /dev/null
+++ b/clippy_lints/src/methods/unnecessary_fold.rs
@@ -0,0 +1,101 @@
+use crate::utils::{
+    match_trait_method, path_to_local_id, paths, remove_blocks, snippet_with_applicability, span_lint_and_sugg,
+    strip_pat_refs,
+};
+use if_chain::if_chain;
+use rustc_ast::ast;
+use rustc_errors::Applicability;
+use rustc_hir as hir;
+use rustc_hir::PatKind;
+use rustc_lint::LateContext;
+use rustc_span::source_map::Span;
+
+use super::UNNECESSARY_FOLD;
+
+pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, fold_args: &[hir::Expr<'_>], fold_span: Span) {
+    fn check_fold_with_op(
+        cx: &LateContext<'_>,
+        expr: &hir::Expr<'_>,
+        fold_args: &[hir::Expr<'_>],
+        fold_span: Span,
+        op: hir::BinOpKind,
+        replacement_method_name: &str,
+        replacement_has_args: bool,
+    ) {
+        if_chain! {
+            // Extract the body of the closure passed to fold
+            if let hir::ExprKind::Closure(_, _, body_id, _, _) = fold_args[2].kind;
+            let closure_body = cx.tcx.hir().body(body_id);
+            let closure_expr = remove_blocks(&closure_body.value);
+
+            // Check if the closure body is of the form `acc <op> some_expr(x)`
+            if let hir::ExprKind::Binary(ref bin_op, ref left_expr, ref right_expr) = closure_expr.kind;
+            if bin_op.node == op;
+
+            // Extract the names of the two arguments to the closure
+            if let [param_a, param_b] = closure_body.params;
+            if let PatKind::Binding(_, first_arg_id, ..) = strip_pat_refs(&param_a.pat).kind;
+            if let PatKind::Binding(_, second_arg_id, second_arg_ident, _) = strip_pat_refs(&param_b.pat).kind;
+
+            if path_to_local_id(left_expr, first_arg_id);
+            if replacement_has_args || path_to_local_id(right_expr, second_arg_id);
+
+            then {
+                let mut applicability = Applicability::MachineApplicable;
+                let sugg = if replacement_has_args {
+                    format!(
+                        "{replacement}(|{s}| {r})",
+                        replacement = replacement_method_name,
+                        s = second_arg_ident,
+                        r = snippet_with_applicability(cx, right_expr.span, "EXPR", &mut applicability),
+                    )
+                } else {
+                    format!(
+                        "{replacement}()",
+                        replacement = replacement_method_name,
+                    )
+                };
+
+                span_lint_and_sugg(
+                    cx,
+                    UNNECESSARY_FOLD,
+                    fold_span.with_hi(expr.span.hi()),
+                    // TODO #2371 don't suggest e.g., .any(|x| f(x)) if we can suggest .any(f)
+                    "this `.fold` can be written more succinctly using another method",
+                    "try",
+                    sugg,
+                    applicability,
+                );
+            }
+        }
+    }
+
+    // Check that this is a call to Iterator::fold rather than just some function called fold
+    if !match_trait_method(cx, expr, &paths::ITERATOR) {
+        return;
+    }
+
+    assert!(
+        fold_args.len() == 3,
+        "Expected fold_args to have three entries - the receiver, the initial value and the closure"
+    );
+
+    // Check if the first argument to .fold is a suitable literal
+    if let hir::ExprKind::Lit(ref lit) = fold_args[1].kind {
+        match lit.node {
+            ast::LitKind::Bool(false) => {
+                check_fold_with_op(cx, expr, fold_args, fold_span, hir::BinOpKind::Or, "any", true)
+            },
+            ast::LitKind::Bool(true) => {
+                check_fold_with_op(cx, expr, fold_args, fold_span, hir::BinOpKind::And, "all", true)
+            },
+            ast::LitKind::Int(0, _) => {
+                check_fold_with_op(cx, expr, fold_args, fold_span, hir::BinOpKind::Add, "sum", false)
+            },
+            ast::LitKind::Int(1, _) => {
+                check_fold_with_op(cx, expr, fold_args, fold_span, hir::BinOpKind::Mul, "product", false)
+            },
+            _ => (),
+        }
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 5557596926b493f1fdb85aef6bd78941f231f962 Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Sat, 6 Mar 2021 19:11:52 +0900
Subject: move option_map_or_none to its own module

---
 clippy_lints/src/methods/mod.rs                | 73 +-----------------------
 clippy_lints/src/methods/option_map_or_none.rs | 78 ++++++++++++++++++++++++++
 2 files changed, 80 insertions(+), 71 deletions(-)
 create mode 100644 clippy_lints/src/methods/option_map_or_none.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 702c8e76f49..0c67c3b892b 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -30,6 +30,7 @@ mod map_collect_result_unit;
 mod map_flatten;
 mod ok_expect;
 mod option_as_ref_deref;
+mod option_map_or_none;
 mod option_map_unwrap_or;
 mod search_is_some;
 mod single_char_insert_string;
@@ -1692,7 +1693,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
                     unnecessary_lazy_eval::check(cx, expr, arg_lists[0], "unwrap_or");
                 }
             },
-            ["map_or", ..] => lint_map_or_none(cx, expr, arg_lists[0]),
+            ["map_or", ..] => option_map_or_none::check(cx, expr, arg_lists[0]),
             ["and_then", ..] => {
                 let biom_option_linted = bind_instead_of_map::OptionAndThenSome::check(cx, expr, arg_lists[0]);
                 let biom_result_linted = bind_instead_of_map::ResultAndThenOk::check(cx, expr, arg_lists[0]);
@@ -2431,76 +2432,6 @@ fn lint_map_unwrap_or_else<'tcx>(
     false
 }
 
-/// lint use of `_.map_or(None, _)` for `Option`s and `Result`s
-fn lint_map_or_none<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, map_or_args: &'tcx [hir::Expr<'_>]) {
-    let is_option = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&map_or_args[0]), sym::option_type);
-    let is_result = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&map_or_args[0]), sym::result_type);
-
-    // There are two variants of this `map_or` lint:
-    // (1) using `map_or` as an adapter from `Result<T,E>` to `Option<T>`
-    // (2) using `map_or` as a combinator instead of `and_then`
-    //
-    // (For this lint) we don't care if any other type calls `map_or`
-    if !is_option && !is_result {
-        return;
-    }
-
-    let (lint_name, msg, instead, hint) = {
-        let default_arg_is_none = if let hir::ExprKind::Path(ref qpath) = map_or_args[1].kind {
-            match_qpath(qpath, &paths::OPTION_NONE)
-        } else {
-            return;
-        };
-
-        if !default_arg_is_none {
-            // nothing to lint!
-            return;
-        }
-
-        let f_arg_is_some = if let hir::ExprKind::Path(ref qpath) = map_or_args[2].kind {
-            match_qpath(qpath, &paths::OPTION_SOME)
-        } else {
-            false
-        };
-
-        if is_option {
-            let self_snippet = snippet(cx, map_or_args[0].span, "..");
-            let func_snippet = snippet(cx, map_or_args[2].span, "..");
-            let msg = "called `map_or(None, ..)` on an `Option` value. This can be done more directly by calling \
-                       `and_then(..)` instead";
-            (
-                OPTION_MAP_OR_NONE,
-                msg,
-                "try using `and_then` instead",
-                format!("{0}.and_then({1})", self_snippet, func_snippet),
-            )
-        } else if f_arg_is_some {
-            let msg = "called `map_or(None, Some)` on a `Result` value. This can be done more directly by calling \
-                       `ok()` instead";
-            let self_snippet = snippet(cx, map_or_args[0].span, "..");
-            (
-                RESULT_MAP_OR_INTO_OPTION,
-                msg,
-                "try using `ok` instead",
-                format!("{0}.ok()", self_snippet),
-            )
-        } else {
-            // nothing to lint!
-            return;
-        }
-    };
-
-    span_lint_and_sugg(
-        cx,
-        lint_name,
-        expr.span,
-        msg,
-        instead,
-        hint,
-        Applicability::MachineApplicable,
-    );
-}
-
 /// Used for `lint_binary_expr_with_method_call`.
 #[derive(Copy, Clone)]
 struct BinaryExprInfo<'a> {
diff --git a/clippy_lints/src/methods/option_map_or_none.rs b/clippy_lints/src/methods/option_map_or_none.rs
new file mode 100644
index 00000000000..64f6ebc5062
--- /dev/null
+++ b/clippy_lints/src/methods/option_map_or_none.rs
@@ -0,0 +1,78 @@
+use crate::utils::{is_type_diagnostic_item, match_qpath, paths, snippet, span_lint_and_sugg};
+use rustc_errors::Applicability;
+use rustc_hir as hir;
+use rustc_lint::LateContext;
+use rustc_span::symbol::sym;
+
+use super::OPTION_MAP_OR_NONE;
+use super::RESULT_MAP_OR_INTO_OPTION;
+
+/// lint use of `_.map_or(None, _)` for `Option`s and `Result`s
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, map_or_args: &'tcx [hir::Expr<'_>]) {
+    let is_option = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&map_or_args[0]), sym::option_type);
+    let is_result = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&map_or_args[0]), sym::result_type);
+
+    // There are two variants of this `map_or` lint:
+    // (1) using `map_or` as an adapter from `Result<T,E>` to `Option<T>`
+    // (2) using `map_or` as a combinator instead of `and_then`
+    //
+    // (For this lint) we don't care if any other type calls `map_or`
+    if !is_option && !is_result {
+        return;
+    }
+
+    let (lint_name, msg, instead, hint) = {
+        let default_arg_is_none = if let hir::ExprKind::Path(ref qpath) = map_or_args[1].kind {
+            match_qpath(qpath, &paths::OPTION_NONE)
+        } else {
+            return;
+        };
+
+        if !default_arg_is_none {
+            // nothing to lint!
+            return;
+        }
+
+        let f_arg_is_some = if let hir::ExprKind::Path(ref qpath) = map_or_args[2].kind {
+            match_qpath(qpath, &paths::OPTION_SOME)
+        } else {
+            false
+        };
+
+        if is_option {
+            let self_snippet = snippet(cx, map_or_args[0].span, "..");
+            let func_snippet = snippet(cx, map_or_args[2].span, "..");
+            let msg = "called `map_or(None, ..)` on an `Option` value. This can be done more directly by calling \
+                       `and_then(..)` instead";
+            (
+                OPTION_MAP_OR_NONE,
+                msg,
+                "try using `and_then` instead",
+                format!("{0}.and_then({1})", self_snippet, func_snippet),
+            )
+        } else if f_arg_is_some {
+            let msg = "called `map_or(None, Some)` on a `Result` value. This can be done more directly by calling \
+                       `ok()` instead";
+            let self_snippet = snippet(cx, map_or_args[0].span, "..");
+            (
+                RESULT_MAP_OR_INTO_OPTION,
+                msg,
+                "try using `ok` instead",
+                format!("{0}.ok()", self_snippet),
+            )
+        } else {
+            // nothing to lint!
+            return;
+        }
+    };
+
+    span_lint_and_sugg(
+        cx,
+        lint_name,
+        expr.span,
+        msg,
+        instead,
+        hint,
+        Applicability::MachineApplicable,
+    );
+}
-- 
cgit 1.4.1-3-g733a5


From b0824bf75fba159f40e498dd88386174feea5cf5 Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Sat, 6 Mar 2021 19:31:46 +0900
Subject: move map_unwrap_or to its own module

---
 clippy_lints/src/methods/map_unwrap_or.rs | 76 +++++++++++++++++++++++++++++++
 clippy_lints/src/methods/mod.rs           | 75 ++----------------------------
 2 files changed, 80 insertions(+), 71 deletions(-)
 create mode 100644 clippy_lints/src/methods/map_unwrap_or.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/map_unwrap_or.rs b/clippy_lints/src/methods/map_unwrap_or.rs
new file mode 100644
index 00000000000..63b2cf87f32
--- /dev/null
+++ b/clippy_lints/src/methods/map_unwrap_or.rs
@@ -0,0 +1,76 @@
+use crate::utils::usage::mutated_variables;
+use crate::utils::{is_type_diagnostic_item, meets_msrv, snippet, span_lint, span_lint_and_sugg};
+use rustc_errors::Applicability;
+use rustc_hir as hir;
+use rustc_lint::LateContext;
+use rustc_semver::RustcVersion;
+use rustc_span::symbol::sym;
+
+use super::MAP_UNWRAP_OR;
+
+const MAP_UNWRAP_OR_MSRV: RustcVersion = RustcVersion::new(1, 41, 0);
+
+/// lint use of `map().unwrap_or_else()` for `Option`s and `Result`s
+/// Return true if lint triggered
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx hir::Expr<'_>,
+    map_args: &'tcx [hir::Expr<'_>],
+    unwrap_args: &'tcx [hir::Expr<'_>],
+    msrv: Option<&RustcVersion>,
+) -> bool {
+    if !meets_msrv(msrv, &MAP_UNWRAP_OR_MSRV) {
+        return false;
+    }
+    // lint if the caller of `map()` is an `Option`
+    let is_option = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&map_args[0]), sym::option_type);
+    let is_result = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&map_args[0]), sym::result_type);
+
+    if is_option || is_result {
+        // Don't make a suggestion that may fail to compile due to mutably borrowing
+        // the same variable twice.
+        let map_mutated_vars = mutated_variables(&map_args[0], cx);
+        let unwrap_mutated_vars = mutated_variables(&unwrap_args[1], cx);
+        if let (Some(map_mutated_vars), Some(unwrap_mutated_vars)) = (map_mutated_vars, unwrap_mutated_vars) {
+            if map_mutated_vars.intersection(&unwrap_mutated_vars).next().is_some() {
+                return false;
+            }
+        } else {
+            return false;
+        }
+
+        // lint message
+        let msg = if is_option {
+            "called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling \
+            `map_or_else(<g>, <f>)` instead"
+        } else {
+            "called `map(<f>).unwrap_or_else(<g>)` on a `Result` value. This can be done more directly by calling \
+            `.map_or_else(<g>, <f>)` instead"
+        };
+        // get snippets for args to map() and unwrap_or_else()
+        let map_snippet = snippet(cx, map_args[1].span, "..");
+        let unwrap_snippet = snippet(cx, unwrap_args[1].span, "..");
+        // lint, with note if neither arg is > 1 line and both map() and
+        // unwrap_or_else() have the same span
+        let multiline = map_snippet.lines().count() > 1 || unwrap_snippet.lines().count() > 1;
+        let same_span = map_args[1].span.ctxt() == unwrap_args[1].span.ctxt();
+        if same_span && !multiline {
+            let var_snippet = snippet(cx, map_args[0].span, "..");
+            span_lint_and_sugg(
+                cx,
+                MAP_UNWRAP_OR,
+                expr.span,
+                msg,
+                "try this",
+                format!("{}.map_or_else({}, {})", var_snippet, unwrap_snippet, map_snippet),
+                Applicability::MachineApplicable,
+            );
+            return true;
+        } else if same_span && multiline {
+            span_lint(cx, MAP_UNWRAP_OR, expr.span, msg);
+            return true;
+        }
+    }
+
+    false
+}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 0c67c3b892b..5f62942530c 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -28,6 +28,7 @@ mod iterator_step_by_zero;
 mod manual_saturating_arithmetic;
 mod map_collect_result_unit;
 mod map_flatten;
+mod map_unwrap_or;
 mod ok_expect;
 mod option_as_ref_deref;
 mod option_map_or_none;
@@ -66,11 +67,10 @@ use rustc_span::symbol::{sym, Symbol, SymbolStr};
 use rustc_typeck::hir_ty_to_ty;
 
 use crate::utils::eager_or_lazy::is_lazyness_candidate;
-use crate::utils::usage::mutated_variables;
 use crate::utils::{
     contains_return, contains_ty, get_trait_def_id, implements_trait, in_macro, is_copy, is_expn_of,
-    is_type_diagnostic_item, iter_input_pats, last_path_segment, match_def_path, match_qpath, match_type, meets_msrv,
-    method_calls, method_chain_args, paths, return_ty, single_segment_path, snippet, snippet_with_applicability,
+    is_type_diagnostic_item, iter_input_pats, last_path_segment, match_def_path, match_qpath, match_type, method_calls,
+    method_chain_args, paths, return_ty, single_segment_path, snippet, snippet_with_applicability,
     snippet_with_macro_callsite, span_lint, span_lint_and_help, span_lint_and_sugg, SpanlessEq,
 };
 
@@ -1689,7 +1689,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             ["expect", ..] => expect_used::check(cx, expr, arg_lists[0]),
             ["unwrap_or", "map"] => option_map_unwrap_or::check(cx, expr, arg_lists[1], arg_lists[0], method_spans[1]),
             ["unwrap_or_else", "map"] => {
-                if !lint_map_unwrap_or_else(cx, expr, arg_lists[1], arg_lists[0], self.msrv.as_ref()) {
+                if !map_unwrap_or::check(cx, expr, arg_lists[1], arg_lists[0], self.msrv.as_ref()) {
                     unnecessary_lazy_eval::check(cx, expr, arg_lists[0], "unwrap_or");
                 }
             },
@@ -2365,73 +2365,6 @@ fn derefs_to_slice<'tcx>(
     }
 }
 
-const MAP_UNWRAP_OR_MSRV: RustcVersion = RustcVersion::new(1, 41, 0);
-
-/// lint use of `map().unwrap_or_else()` for `Option`s and `Result`s
-/// Return true if lint triggered
-fn lint_map_unwrap_or_else<'tcx>(
-    cx: &LateContext<'tcx>,
-    expr: &'tcx hir::Expr<'_>,
-    map_args: &'tcx [hir::Expr<'_>],
-    unwrap_args: &'tcx [hir::Expr<'_>],
-    msrv: Option<&RustcVersion>,
-) -> bool {
-    if !meets_msrv(msrv, &MAP_UNWRAP_OR_MSRV) {
-        return false;
-    }
-    // lint if the caller of `map()` is an `Option`
-    let is_option = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&map_args[0]), sym::option_type);
-    let is_result = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&map_args[0]), sym::result_type);
-
-    if is_option || is_result {
-        // Don't make a suggestion that may fail to compile due to mutably borrowing
-        // the same variable twice.
-        let map_mutated_vars = mutated_variables(&map_args[0], cx);
-        let unwrap_mutated_vars = mutated_variables(&unwrap_args[1], cx);
-        if let (Some(map_mutated_vars), Some(unwrap_mutated_vars)) = (map_mutated_vars, unwrap_mutated_vars) {
-            if map_mutated_vars.intersection(&unwrap_mutated_vars).next().is_some() {
-                return false;
-            }
-        } else {
-            return false;
-        }
-
-        // lint message
-        let msg = if is_option {
-            "called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling \
-            `map_or_else(<g>, <f>)` instead"
-        } else {
-            "called `map(<f>).unwrap_or_else(<g>)` on a `Result` value. This can be done more directly by calling \
-            `.map_or_else(<g>, <f>)` instead"
-        };
-        // get snippets for args to map() and unwrap_or_else()
-        let map_snippet = snippet(cx, map_args[1].span, "..");
-        let unwrap_snippet = snippet(cx, unwrap_args[1].span, "..");
-        // lint, with note if neither arg is > 1 line and both map() and
-        // unwrap_or_else() have the same span
-        let multiline = map_snippet.lines().count() > 1 || unwrap_snippet.lines().count() > 1;
-        let same_span = map_args[1].span.ctxt() == unwrap_args[1].span.ctxt();
-        if same_span && !multiline {
-            let var_snippet = snippet(cx, map_args[0].span, "..");
-            span_lint_and_sugg(
-                cx,
-                MAP_UNWRAP_OR,
-                expr.span,
-                msg,
-                "try this",
-                format!("{}.map_or_else({}, {})", var_snippet, unwrap_snippet, map_snippet),
-                Applicability::MachineApplicable,
-            );
-            return true;
-        } else if same_span && multiline {
-            span_lint(cx, MAP_UNWRAP_OR, expr.span, msg);
-            return true;
-        }
-    }
-
-    false
-}
-
 /// Used for `lint_binary_expr_with_method_call`.
 #[derive(Copy, Clone)]
 struct BinaryExprInfo<'a> {
-- 
cgit 1.4.1-3-g733a5


From f49349bf333001166e3a215b7b2eb5b5cb1c9989 Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Sat, 6 Mar 2021 19:40:34 +0900
Subject: move or_fun_call to its own module

---
 clippy_lints/src/methods/mod.rs         | 168 +------------------------------
 clippy_lints/src/methods/or_fun_call.rs | 173 ++++++++++++++++++++++++++++++++
 2 files changed, 178 insertions(+), 163 deletions(-)
 create mode 100644 clippy_lints/src/methods/or_fun_call.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 5f62942530c..857c1bf0ec0 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -33,6 +33,7 @@ mod ok_expect;
 mod option_as_ref_deref;
 mod option_map_or_none;
 mod option_map_unwrap_or;
+mod or_fun_call;
 mod search_is_some;
 mod single_char_insert_string;
 mod single_char_pattern;
@@ -66,12 +67,11 @@ use rustc_span::source_map::Span;
 use rustc_span::symbol::{sym, Symbol, SymbolStr};
 use rustc_typeck::hir_ty_to_ty;
 
-use crate::utils::eager_or_lazy::is_lazyness_candidate;
 use crate::utils::{
     contains_return, contains_ty, get_trait_def_id, implements_trait, in_macro, is_copy, is_expn_of,
-    is_type_diagnostic_item, iter_input_pats, last_path_segment, match_def_path, match_qpath, match_type, method_calls,
-    method_chain_args, paths, return_ty, single_segment_path, snippet, snippet_with_applicability,
-    snippet_with_macro_callsite, span_lint, span_lint_and_help, span_lint_and_sugg, SpanlessEq,
+    is_type_diagnostic_item, iter_input_pats, match_def_path, match_qpath, method_calls, method_chain_args, paths,
+    return_ty, single_segment_path, snippet, snippet_with_applicability, span_lint, span_lint_and_help,
+    span_lint_and_sugg, SpanlessEq,
 };
 
 declare_clippy_lint! {
@@ -1778,7 +1778,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
                 }
             },
             hir::ExprKind::MethodCall(ref method_call, ref method_span, ref args, _) => {
-                lint_or_fun_call(cx, expr, *method_span, &method_call.ident.as_str(), args);
+                or_fun_call::check(cx, expr, *method_span, &method_call.ident.as_str(), args);
                 lint_expect_fun_call(cx, expr, *method_span, &method_call.ident.as_str(), args);
 
                 let self_ty = cx.typeck_results().expr_ty_adjusted(&args[0]);
@@ -1973,164 +1973,6 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
     extract_msrv_attr!(LateContext);
 }
 
-/// Checks for the `OR_FUN_CALL` lint.
-#[allow(clippy::too_many_lines)]
-fn lint_or_fun_call<'tcx>(
-    cx: &LateContext<'tcx>,
-    expr: &hir::Expr<'_>,
-    method_span: Span,
-    name: &str,
-    args: &'tcx [hir::Expr<'_>],
-) {
-    /// Checks for `unwrap_or(T::new())` or `unwrap_or(T::default())`.
-    fn check_unwrap_or_default(
-        cx: &LateContext<'_>,
-        name: &str,
-        fun: &hir::Expr<'_>,
-        self_expr: &hir::Expr<'_>,
-        arg: &hir::Expr<'_>,
-        or_has_args: bool,
-        span: Span,
-    ) -> bool {
-        if_chain! {
-            if !or_has_args;
-            if name == "unwrap_or";
-            if let hir::ExprKind::Path(ref qpath) = fun.kind;
-            let path = &*last_path_segment(qpath).ident.as_str();
-            if ["default", "new"].contains(&path);
-            let arg_ty = cx.typeck_results().expr_ty(arg);
-            if let Some(default_trait_id) = get_trait_def_id(cx, &paths::DEFAULT_TRAIT);
-            if implements_trait(cx, arg_ty, default_trait_id, &[]);
-
-            then {
-                let mut applicability = Applicability::MachineApplicable;
-                span_lint_and_sugg(
-                    cx,
-                    OR_FUN_CALL,
-                    span,
-                    &format!("use of `{}` followed by a call to `{}`", name, path),
-                    "try this",
-                    format!(
-                        "{}.unwrap_or_default()",
-                        snippet_with_applicability(cx, self_expr.span, "..", &mut applicability)
-                    ),
-                    applicability,
-                );
-
-                true
-            } else {
-                false
-            }
-        }
-    }
-
-    /// Checks for `*or(foo())`.
-    #[allow(clippy::too_many_arguments)]
-    fn check_general_case<'tcx>(
-        cx: &LateContext<'tcx>,
-        name: &str,
-        method_span: Span,
-        self_expr: &hir::Expr<'_>,
-        arg: &'tcx hir::Expr<'_>,
-        span: Span,
-        // None if lambda is required
-        fun_span: Option<Span>,
-    ) {
-        // (path, fn_has_argument, methods, suffix)
-        static KNOW_TYPES: [(&[&str], bool, &[&str], &str); 4] = [
-            (&paths::BTREEMAP_ENTRY, false, &["or_insert"], "with"),
-            (&paths::HASHMAP_ENTRY, false, &["or_insert"], "with"),
-            (&paths::OPTION, false, &["map_or", "ok_or", "or", "unwrap_or"], "else"),
-            (&paths::RESULT, true, &["or", "unwrap_or"], "else"),
-        ];
-
-        if let hir::ExprKind::MethodCall(ref path, _, ref args, _) = &arg.kind {
-            if path.ident.as_str() == "len" {
-                let ty = cx.typeck_results().expr_ty(&args[0]).peel_refs();
-
-                match ty.kind() {
-                    ty::Slice(_) | ty::Array(_, _) => return,
-                    _ => (),
-                }
-
-                if is_type_diagnostic_item(cx, ty, sym::vec_type) {
-                    return;
-                }
-            }
-        }
-
-        if_chain! {
-            if KNOW_TYPES.iter().any(|k| k.2.contains(&name));
-
-            if is_lazyness_candidate(cx, arg);
-            if !contains_return(&arg);
-
-            let self_ty = cx.typeck_results().expr_ty(self_expr);
-
-            if let Some(&(_, fn_has_arguments, poss, suffix)) =
-                KNOW_TYPES.iter().find(|&&i| match_type(cx, self_ty, i.0));
-
-            if poss.contains(&name);
-
-            then {
-                let macro_expanded_snipped;
-                let sugg: Cow<'_, str> = {
-                    let (snippet_span, use_lambda) = match (fn_has_arguments, fun_span) {
-                        (false, Some(fun_span)) => (fun_span, false),
-                        _ => (arg.span, true),
-                    };
-                    let snippet = {
-                        let not_macro_argument_snippet = snippet_with_macro_callsite(cx, snippet_span, "..");
-                        if not_macro_argument_snippet == "vec![]" {
-                            macro_expanded_snipped = snippet(cx, snippet_span, "..");
-                            match macro_expanded_snipped.strip_prefix("$crate::vec::") {
-                                Some(stripped) => Cow::from(stripped),
-                                None => macro_expanded_snipped
-                            }
-                        }
-                        else {
-                            not_macro_argument_snippet
-                        }
-                    };
-
-                    if use_lambda {
-                        let l_arg = if fn_has_arguments { "_" } else { "" };
-                        format!("|{}| {}", l_arg, snippet).into()
-                    } else {
-                        snippet
-                    }
-                };
-                let span_replace_word = method_span.with_hi(span.hi());
-                span_lint_and_sugg(
-                    cx,
-                    OR_FUN_CALL,
-                    span_replace_word,
-                    &format!("use of `{}` followed by a function call", name),
-                    "try this",
-                    format!("{}_{}({})", name, suffix, sugg),
-                    Applicability::HasPlaceholders,
-                );
-            }
-        }
-    }
-
-    if args.len() == 2 {
-        match args[1].kind {
-            hir::ExprKind::Call(ref fun, ref or_args) => {
-                let or_has_args = !or_args.is_empty();
-                if !check_unwrap_or_default(cx, name, fun, &args[0], &args[1], or_has_args, expr.span) {
-                    let fun_span = if or_has_args { None } else { Some(fun.span) };
-                    check_general_case(cx, name, method_span, &args[0], &args[1], expr.span, fun_span);
-                }
-            },
-            hir::ExprKind::Index(..) | hir::ExprKind::MethodCall(..) => {
-                check_general_case(cx, name, method_span, &args[0], &args[1], expr.span, None);
-            },
-            _ => {},
-        }
-    }
-}
-
 /// Checks for the `EXPECT_FUN_CALL` lint.
 #[allow(clippy::too_many_lines)]
 fn lint_expect_fun_call(
diff --git a/clippy_lints/src/methods/or_fun_call.rs b/clippy_lints/src/methods/or_fun_call.rs
new file mode 100644
index 00000000000..5f7fc431d22
--- /dev/null
+++ b/clippy_lints/src/methods/or_fun_call.rs
@@ -0,0 +1,173 @@
+use crate::utils::eager_or_lazy::is_lazyness_candidate;
+use crate::utils::{
+    contains_return, get_trait_def_id, implements_trait, is_type_diagnostic_item, last_path_segment, match_type, paths,
+    snippet, snippet_with_applicability, snippet_with_macro_callsite, span_lint_and_sugg,
+};
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir as hir;
+use rustc_lint::LateContext;
+use rustc_middle::ty;
+use rustc_span::source_map::Span;
+use rustc_span::symbol::sym;
+use std::borrow::Cow;
+
+use super::OR_FUN_CALL;
+
+/// Checks for the `OR_FUN_CALL` lint.
+#[allow(clippy::too_many_lines)]
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &hir::Expr<'_>,
+    method_span: Span,
+    name: &str,
+    args: &'tcx [hir::Expr<'_>],
+) {
+    /// Checks for `unwrap_or(T::new())` or `unwrap_or(T::default())`.
+    fn check_unwrap_or_default(
+        cx: &LateContext<'_>,
+        name: &str,
+        fun: &hir::Expr<'_>,
+        self_expr: &hir::Expr<'_>,
+        arg: &hir::Expr<'_>,
+        or_has_args: bool,
+        span: Span,
+    ) -> bool {
+        if_chain! {
+            if !or_has_args;
+            if name == "unwrap_or";
+            if let hir::ExprKind::Path(ref qpath) = fun.kind;
+            let path = &*last_path_segment(qpath).ident.as_str();
+            if ["default", "new"].contains(&path);
+            let arg_ty = cx.typeck_results().expr_ty(arg);
+            if let Some(default_trait_id) = get_trait_def_id(cx, &paths::DEFAULT_TRAIT);
+            if implements_trait(cx, arg_ty, default_trait_id, &[]);
+
+            then {
+                let mut applicability = Applicability::MachineApplicable;
+                span_lint_and_sugg(
+                    cx,
+                    OR_FUN_CALL,
+                    span,
+                    &format!("use of `{}` followed by a call to `{}`", name, path),
+                    "try this",
+                    format!(
+                        "{}.unwrap_or_default()",
+                        snippet_with_applicability(cx, self_expr.span, "..", &mut applicability)
+                    ),
+                    applicability,
+                );
+
+                true
+            } else {
+                false
+            }
+        }
+    }
+
+    /// Checks for `*or(foo())`.
+    #[allow(clippy::too_many_arguments)]
+    fn check_general_case<'tcx>(
+        cx: &LateContext<'tcx>,
+        name: &str,
+        method_span: Span,
+        self_expr: &hir::Expr<'_>,
+        arg: &'tcx hir::Expr<'_>,
+        span: Span,
+        // None if lambda is required
+        fun_span: Option<Span>,
+    ) {
+        // (path, fn_has_argument, methods, suffix)
+        static KNOW_TYPES: [(&[&str], bool, &[&str], &str); 4] = [
+            (&paths::BTREEMAP_ENTRY, false, &["or_insert"], "with"),
+            (&paths::HASHMAP_ENTRY, false, &["or_insert"], "with"),
+            (&paths::OPTION, false, &["map_or", "ok_or", "or", "unwrap_or"], "else"),
+            (&paths::RESULT, true, &["or", "unwrap_or"], "else"),
+        ];
+
+        if let hir::ExprKind::MethodCall(ref path, _, ref args, _) = &arg.kind {
+            if path.ident.as_str() == "len" {
+                let ty = cx.typeck_results().expr_ty(&args[0]).peel_refs();
+
+                match ty.kind() {
+                    ty::Slice(_) | ty::Array(_, _) => return,
+                    _ => (),
+                }
+
+                if is_type_diagnostic_item(cx, ty, sym::vec_type) {
+                    return;
+                }
+            }
+        }
+
+        if_chain! {
+            if KNOW_TYPES.iter().any(|k| k.2.contains(&name));
+
+            if is_lazyness_candidate(cx, arg);
+            if !contains_return(&arg);
+
+            let self_ty = cx.typeck_results().expr_ty(self_expr);
+
+            if let Some(&(_, fn_has_arguments, poss, suffix)) =
+                KNOW_TYPES.iter().find(|&&i| match_type(cx, self_ty, i.0));
+
+            if poss.contains(&name);
+
+            then {
+                let macro_expanded_snipped;
+                let sugg: Cow<'_, str> = {
+                    let (snippet_span, use_lambda) = match (fn_has_arguments, fun_span) {
+                        (false, Some(fun_span)) => (fun_span, false),
+                        _ => (arg.span, true),
+                    };
+                    let snippet = {
+                        let not_macro_argument_snippet = snippet_with_macro_callsite(cx, snippet_span, "..");
+                        if not_macro_argument_snippet == "vec![]" {
+                            macro_expanded_snipped = snippet(cx, snippet_span, "..");
+                            match macro_expanded_snipped.strip_prefix("$crate::vec::") {
+                                Some(stripped) => Cow::from(stripped),
+                                None => macro_expanded_snipped
+                            }
+                        }
+                        else {
+                            not_macro_argument_snippet
+                        }
+                    };
+
+                    if use_lambda {
+                        let l_arg = if fn_has_arguments { "_" } else { "" };
+                        format!("|{}| {}", l_arg, snippet).into()
+                    } else {
+                        snippet
+                    }
+                };
+                let span_replace_word = method_span.with_hi(span.hi());
+                span_lint_and_sugg(
+                    cx,
+                    OR_FUN_CALL,
+                    span_replace_word,
+                    &format!("use of `{}` followed by a function call", name),
+                    "try this",
+                    format!("{}_{}({})", name, suffix, sugg),
+                    Applicability::HasPlaceholders,
+                );
+            }
+        }
+    }
+
+    if args.len() == 2 {
+        match args[1].kind {
+            hir::ExprKind::Call(ref fun, ref or_args) => {
+                let or_has_args = !or_args.is_empty();
+                if !check_unwrap_or_default(cx, name, fun, &args[0], &args[1], or_has_args, expr.span) {
+                    let fun_span = if or_has_args { None } else { Some(fun.span) };
+                    check_general_case(cx, name, method_span, &args[0], &args[1], expr.span, fun_span);
+                }
+            },
+            hir::ExprKind::Index(..) | hir::ExprKind::MethodCall(..) => {
+                check_general_case(cx, name, method_span, &args[0], &args[1], expr.span, None);
+            },
+            _ => {},
+        }
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From c711de28ee903c78ad465f6af99afdb977ab8dfe Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Sat, 6 Mar 2021 22:26:29 +0900
Subject: move expect_fun_call to its own module

---
 clippy_lints/src/methods/expect_fun_call.rs | 199 +++++++++++++++++++++++++++
 clippy_lints/src/methods/mod.rs             | 206 +---------------------------
 2 files changed, 204 insertions(+), 201 deletions(-)
 create mode 100644 clippy_lints/src/methods/expect_fun_call.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/expect_fun_call.rs b/clippy_lints/src/methods/expect_fun_call.rs
new file mode 100644
index 00000000000..6866e9c652a
--- /dev/null
+++ b/clippy_lints/src/methods/expect_fun_call.rs
@@ -0,0 +1,199 @@
+use crate::utils::{is_expn_of, is_type_diagnostic_item, snippet, snippet_with_applicability, span_lint_and_sugg};
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir as hir;
+use rustc_lint::LateContext;
+use rustc_middle::ty;
+use rustc_span::source_map::Span;
+use rustc_span::symbol::sym;
+use std::borrow::Cow;
+
+use super::EXPECT_FUN_CALL;
+
+/// Checks for the `EXPECT_FUN_CALL` lint.
+#[allow(clippy::too_many_lines)]
+pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, method_span: Span, name: &str, args: &[hir::Expr<'_>]) {
+    // Strip `&`, `as_ref()` and `as_str()` off `arg` until we're left with either a `String` or
+    // `&str`
+    fn get_arg_root<'a>(cx: &LateContext<'_>, arg: &'a hir::Expr<'a>) -> &'a hir::Expr<'a> {
+        let mut arg_root = arg;
+        loop {
+            arg_root = match &arg_root.kind {
+                hir::ExprKind::AddrOf(hir::BorrowKind::Ref, _, expr) => expr,
+                hir::ExprKind::MethodCall(method_name, _, call_args, _) => {
+                    if call_args.len() == 1
+                        && (method_name.ident.name == sym::as_str || method_name.ident.name == sym!(as_ref))
+                        && {
+                            let arg_type = cx.typeck_results().expr_ty(&call_args[0]);
+                            let base_type = arg_type.peel_refs();
+                            *base_type.kind() == ty::Str || is_type_diagnostic_item(cx, base_type, sym::string_type)
+                        }
+                    {
+                        &call_args[0]
+                    } else {
+                        break;
+                    }
+                },
+                _ => break,
+            };
+        }
+        arg_root
+    }
+
+    // Only `&'static str` or `String` can be used directly in the `panic!`. Other types should be
+    // converted to string.
+    fn requires_to_string(cx: &LateContext<'_>, arg: &hir::Expr<'_>) -> bool {
+        let arg_ty = cx.typeck_results().expr_ty(arg);
+        if is_type_diagnostic_item(cx, arg_ty, sym::string_type) {
+            return false;
+        }
+        if let ty::Ref(_, ty, ..) = arg_ty.kind() {
+            if *ty.kind() == ty::Str && can_be_static_str(cx, arg) {
+                return false;
+            }
+        };
+        true
+    }
+
+    // Check if an expression could have type `&'static str`, knowing that it
+    // has type `&str` for some lifetime.
+    fn can_be_static_str(cx: &LateContext<'_>, arg: &hir::Expr<'_>) -> bool {
+        match arg.kind {
+            hir::ExprKind::Lit(_) => true,
+            hir::ExprKind::Call(fun, _) => {
+                if let hir::ExprKind::Path(ref p) = fun.kind {
+                    match cx.qpath_res(p, fun.hir_id) {
+                        hir::def::Res::Def(hir::def::DefKind::Fn | hir::def::DefKind::AssocFn, def_id) => matches!(
+                            cx.tcx.fn_sig(def_id).output().skip_binder().kind(),
+                            ty::Ref(ty::ReStatic, ..)
+                        ),
+                        _ => false,
+                    }
+                } else {
+                    false
+                }
+            },
+            hir::ExprKind::MethodCall(..) => {
+                cx.typeck_results()
+                    .type_dependent_def_id(arg.hir_id)
+                    .map_or(false, |method_id| {
+                        matches!(
+                            cx.tcx.fn_sig(method_id).output().skip_binder().kind(),
+                            ty::Ref(ty::ReStatic, ..)
+                        )
+                    })
+            },
+            hir::ExprKind::Path(ref p) => matches!(
+                cx.qpath_res(p, arg.hir_id),
+                hir::def::Res::Def(hir::def::DefKind::Const | hir::def::DefKind::Static, _)
+            ),
+            _ => false,
+        }
+    }
+
+    fn generate_format_arg_snippet(
+        cx: &LateContext<'_>,
+        a: &hir::Expr<'_>,
+        applicability: &mut Applicability,
+    ) -> Vec<String> {
+        if_chain! {
+            if let hir::ExprKind::AddrOf(hir::BorrowKind::Ref, _, ref format_arg) = a.kind;
+            if let hir::ExprKind::Match(ref format_arg_expr, _, _) = format_arg.kind;
+            if let hir::ExprKind::Tup(ref format_arg_expr_tup) = format_arg_expr.kind;
+
+            then {
+                format_arg_expr_tup
+                    .iter()
+                    .map(|a| snippet_with_applicability(cx, a.span, "..", applicability).into_owned())
+                    .collect()
+            } else {
+                unreachable!()
+            }
+        }
+    }
+
+    fn is_call(node: &hir::ExprKind<'_>) -> bool {
+        match node {
+            hir::ExprKind::AddrOf(hir::BorrowKind::Ref, _, expr) => {
+                is_call(&expr.kind)
+            },
+            hir::ExprKind::Call(..)
+            | hir::ExprKind::MethodCall(..)
+            // These variants are debatable or require further examination
+            | hir::ExprKind::If(..)
+            | hir::ExprKind::Match(..)
+            | hir::ExprKind::Block{ .. } => true,
+            _ => false,
+        }
+    }
+
+    if args.len() != 2 || name != "expect" || !is_call(&args[1].kind) {
+        return;
+    }
+
+    let receiver_type = cx.typeck_results().expr_ty_adjusted(&args[0]);
+    let closure_args = if is_type_diagnostic_item(cx, receiver_type, sym::option_type) {
+        "||"
+    } else if is_type_diagnostic_item(cx, receiver_type, sym::result_type) {
+        "|_|"
+    } else {
+        return;
+    };
+
+    let arg_root = get_arg_root(cx, &args[1]);
+
+    let span_replace_word = method_span.with_hi(expr.span.hi());
+
+    let mut applicability = Applicability::MachineApplicable;
+
+    //Special handling for `format!` as arg_root
+    if_chain! {
+        if let hir::ExprKind::Block(block, None) = &arg_root.kind;
+        if block.stmts.len() == 1;
+        if let hir::StmtKind::Local(local) = &block.stmts[0].kind;
+        if let Some(arg_root) = &local.init;
+        if let hir::ExprKind::Call(ref inner_fun, ref inner_args) = arg_root.kind;
+        if is_expn_of(inner_fun.span, "format").is_some() && inner_args.len() == 1;
+        if let hir::ExprKind::Call(_, format_args) = &inner_args[0].kind;
+        then {
+            let fmt_spec = &format_args[0];
+            let fmt_args = &format_args[1];
+
+            let mut args = vec![snippet(cx, fmt_spec.span, "..").into_owned()];
+
+            args.extend(generate_format_arg_snippet(cx, fmt_args, &mut applicability));
+
+            let sugg = args.join(", ");
+
+            span_lint_and_sugg(
+                cx,
+                EXPECT_FUN_CALL,
+                span_replace_word,
+                &format!("use of `{}` followed by a function call", name),
+                "try this",
+                format!("unwrap_or_else({} panic!({}))", closure_args, sugg),
+                applicability,
+            );
+
+            return;
+        }
+    }
+
+    let mut arg_root_snippet: Cow<'_, _> = snippet_with_applicability(cx, arg_root.span, "..", &mut applicability);
+    if requires_to_string(cx, arg_root) {
+        arg_root_snippet.to_mut().push_str(".to_string()");
+    }
+
+    span_lint_and_sugg(
+        cx,
+        EXPECT_FUN_CALL,
+        span_replace_word,
+        &format!("use of `{}` followed by a function call", name),
+        "try this",
+        format!(
+            "unwrap_or_else({} {{ panic!(\"{{}}\", {}) }})",
+            closure_args, arg_root_snippet
+        ),
+        applicability,
+    );
+}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 857c1bf0ec0..180620e860a 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -2,6 +2,7 @@ mod bind_instead_of_map;
 mod bytes_nth;
 mod clone_on_copy;
 mod clone_on_ref_ptr;
+mod expect_fun_call;
 mod expect_used;
 mod filetype_is_file;
 mod filter_flat_map;
@@ -50,8 +51,6 @@ mod useless_asref;
 mod wrong_self_convention;
 mod zst_offset;
 
-use std::borrow::Cow;
-
 use bind_instead_of_map::BindInsteadOfMap;
 use if_chain::if_chain;
 use rustc_ast::ast;
@@ -68,10 +67,9 @@ use rustc_span::symbol::{sym, Symbol, SymbolStr};
 use rustc_typeck::hir_ty_to_ty;
 
 use crate::utils::{
-    contains_return, contains_ty, get_trait_def_id, implements_trait, in_macro, is_copy, is_expn_of,
-    is_type_diagnostic_item, iter_input_pats, match_def_path, match_qpath, method_calls, method_chain_args, paths,
-    return_ty, single_segment_path, snippet, snippet_with_applicability, span_lint, span_lint_and_help,
-    span_lint_and_sugg, SpanlessEq,
+    contains_return, contains_ty, get_trait_def_id, implements_trait, in_macro, is_copy, is_type_diagnostic_item,
+    iter_input_pats, match_def_path, match_qpath, method_calls, method_chain_args, paths, return_ty,
+    single_segment_path, snippet_with_applicability, span_lint, span_lint_and_help, span_lint_and_sugg, SpanlessEq,
 };
 
 declare_clippy_lint! {
@@ -1779,7 +1777,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             },
             hir::ExprKind::MethodCall(ref method_call, ref method_span, ref args, _) => {
                 or_fun_call::check(cx, expr, *method_span, &method_call.ident.as_str(), args);
-                lint_expect_fun_call(cx, expr, *method_span, &method_call.ident.as_str(), args);
+                expect_fun_call::check(cx, expr, *method_span, &method_call.ident.as_str(), args);
 
                 let self_ty = cx.typeck_results().expr_ty_adjusted(&args[0]);
                 if args.len() == 1 && method_call.ident.name == sym::clone {
@@ -1973,200 +1971,6 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
     extract_msrv_attr!(LateContext);
 }
 
-/// Checks for the `EXPECT_FUN_CALL` lint.
-#[allow(clippy::too_many_lines)]
-fn lint_expect_fun_call(
-    cx: &LateContext<'_>,
-    expr: &hir::Expr<'_>,
-    method_span: Span,
-    name: &str,
-    args: &[hir::Expr<'_>],
-) {
-    // Strip `&`, `as_ref()` and `as_str()` off `arg` until we're left with either a `String` or
-    // `&str`
-    fn get_arg_root<'a>(cx: &LateContext<'_>, arg: &'a hir::Expr<'a>) -> &'a hir::Expr<'a> {
-        let mut arg_root = arg;
-        loop {
-            arg_root = match &arg_root.kind {
-                hir::ExprKind::AddrOf(hir::BorrowKind::Ref, _, expr) => expr,
-                hir::ExprKind::MethodCall(method_name, _, call_args, _) => {
-                    if call_args.len() == 1
-                        && (method_name.ident.name == sym::as_str || method_name.ident.name == sym!(as_ref))
-                        && {
-                            let arg_type = cx.typeck_results().expr_ty(&call_args[0]);
-                            let base_type = arg_type.peel_refs();
-                            *base_type.kind() == ty::Str || is_type_diagnostic_item(cx, base_type, sym::string_type)
-                        }
-                    {
-                        &call_args[0]
-                    } else {
-                        break;
-                    }
-                },
-                _ => break,
-            };
-        }
-        arg_root
-    }
-
-    // Only `&'static str` or `String` can be used directly in the `panic!`. Other types should be
-    // converted to string.
-    fn requires_to_string(cx: &LateContext<'_>, arg: &hir::Expr<'_>) -> bool {
-        let arg_ty = cx.typeck_results().expr_ty(arg);
-        if is_type_diagnostic_item(cx, arg_ty, sym::string_type) {
-            return false;
-        }
-        if let ty::Ref(_, ty, ..) = arg_ty.kind() {
-            if *ty.kind() == ty::Str && can_be_static_str(cx, arg) {
-                return false;
-            }
-        };
-        true
-    }
-
-    // Check if an expression could have type `&'static str`, knowing that it
-    // has type `&str` for some lifetime.
-    fn can_be_static_str(cx: &LateContext<'_>, arg: &hir::Expr<'_>) -> bool {
-        match arg.kind {
-            hir::ExprKind::Lit(_) => true,
-            hir::ExprKind::Call(fun, _) => {
-                if let hir::ExprKind::Path(ref p) = fun.kind {
-                    match cx.qpath_res(p, fun.hir_id) {
-                        hir::def::Res::Def(hir::def::DefKind::Fn | hir::def::DefKind::AssocFn, def_id) => matches!(
-                            cx.tcx.fn_sig(def_id).output().skip_binder().kind(),
-                            ty::Ref(ty::ReStatic, ..)
-                        ),
-                        _ => false,
-                    }
-                } else {
-                    false
-                }
-            },
-            hir::ExprKind::MethodCall(..) => {
-                cx.typeck_results()
-                    .type_dependent_def_id(arg.hir_id)
-                    .map_or(false, |method_id| {
-                        matches!(
-                            cx.tcx.fn_sig(method_id).output().skip_binder().kind(),
-                            ty::Ref(ty::ReStatic, ..)
-                        )
-                    })
-            },
-            hir::ExprKind::Path(ref p) => matches!(
-                cx.qpath_res(p, arg.hir_id),
-                hir::def::Res::Def(hir::def::DefKind::Const | hir::def::DefKind::Static, _)
-            ),
-            _ => false,
-        }
-    }
-
-    fn generate_format_arg_snippet(
-        cx: &LateContext<'_>,
-        a: &hir::Expr<'_>,
-        applicability: &mut Applicability,
-    ) -> Vec<String> {
-        if_chain! {
-            if let hir::ExprKind::AddrOf(hir::BorrowKind::Ref, _, ref format_arg) = a.kind;
-            if let hir::ExprKind::Match(ref format_arg_expr, _, _) = format_arg.kind;
-            if let hir::ExprKind::Tup(ref format_arg_expr_tup) = format_arg_expr.kind;
-
-            then {
-                format_arg_expr_tup
-                    .iter()
-                    .map(|a| snippet_with_applicability(cx, a.span, "..", applicability).into_owned())
-                    .collect()
-            } else {
-                unreachable!()
-            }
-        }
-    }
-
-    fn is_call(node: &hir::ExprKind<'_>) -> bool {
-        match node {
-            hir::ExprKind::AddrOf(hir::BorrowKind::Ref, _, expr) => {
-                is_call(&expr.kind)
-            },
-            hir::ExprKind::Call(..)
-            | hir::ExprKind::MethodCall(..)
-            // These variants are debatable or require further examination
-            | hir::ExprKind::If(..)
-            | hir::ExprKind::Match(..)
-            | hir::ExprKind::Block{ .. } => true,
-            _ => false,
-        }
-    }
-
-    if args.len() != 2 || name != "expect" || !is_call(&args[1].kind) {
-        return;
-    }
-
-    let receiver_type = cx.typeck_results().expr_ty_adjusted(&args[0]);
-    let closure_args = if is_type_diagnostic_item(cx, receiver_type, sym::option_type) {
-        "||"
-    } else if is_type_diagnostic_item(cx, receiver_type, sym::result_type) {
-        "|_|"
-    } else {
-        return;
-    };
-
-    let arg_root = get_arg_root(cx, &args[1]);
-
-    let span_replace_word = method_span.with_hi(expr.span.hi());
-
-    let mut applicability = Applicability::MachineApplicable;
-
-    //Special handling for `format!` as arg_root
-    if_chain! {
-        if let hir::ExprKind::Block(block, None) = &arg_root.kind;
-        if block.stmts.len() == 1;
-        if let hir::StmtKind::Local(local) = &block.stmts[0].kind;
-        if let Some(arg_root) = &local.init;
-        if let hir::ExprKind::Call(ref inner_fun, ref inner_args) = arg_root.kind;
-        if is_expn_of(inner_fun.span, "format").is_some() && inner_args.len() == 1;
-        if let hir::ExprKind::Call(_, format_args) = &inner_args[0].kind;
-        then {
-            let fmt_spec = &format_args[0];
-            let fmt_args = &format_args[1];
-
-            let mut args = vec![snippet(cx, fmt_spec.span, "..").into_owned()];
-
-            args.extend(generate_format_arg_snippet(cx, fmt_args, &mut applicability));
-
-            let sugg = args.join(", ");
-
-            span_lint_and_sugg(
-                cx,
-                EXPECT_FUN_CALL,
-                span_replace_word,
-                &format!("use of `{}` followed by a function call", name),
-                "try this",
-                format!("unwrap_or_else({} panic!({}))", closure_args, sugg),
-                applicability,
-            );
-
-            return;
-        }
-    }
-
-    let mut arg_root_snippet: Cow<'_, _> = snippet_with_applicability(cx, arg_root.span, "..", &mut applicability);
-    if requires_to_string(cx, arg_root) {
-        arg_root_snippet.to_mut().push_str(".to_string()");
-    }
-
-    span_lint_and_sugg(
-        cx,
-        EXPECT_FUN_CALL,
-        span_replace_word,
-        &format!("use of `{}` followed by a function call", name),
-        "try this",
-        format!(
-            "unwrap_or_else({} {{ panic!(\"{{}}\", {}) }})",
-            closure_args, arg_root_snippet
-        ),
-        applicability,
-    );
-}
-
 fn derefs_to_slice<'tcx>(
     cx: &LateContext<'tcx>,
     expr: &'tcx hir::Expr<'tcx>,
-- 
cgit 1.4.1-3-g733a5


From 99f860768cdd71c371cdaf7827c377dbaa4fe396 Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Thu, 11 Mar 2021 20:02:29 +0900
Subject: remove unused imports

---
 clippy_lints/src/methods/into_iter_on_ref.rs | 3 ++-
 clippy_lints/src/methods/mod.rs              | 3 +--
 2 files changed, 3 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/into_iter_on_ref.rs b/clippy_lints/src/methods/into_iter_on_ref.rs
index d94b243404c..1e8315dbee2 100644
--- a/clippy_lints/src/methods/into_iter_on_ref.rs
+++ b/clippy_lints/src/methods/into_iter_on_ref.rs
@@ -4,6 +4,7 @@ use rustc_hir as hir;
 use rustc_lint::LateContext;
 use rustc_middle::ty::{self, Ty};
 use rustc_span::source_map::Span;
+use rustc_span::symbol::Symbol;
 
 use super::INTO_ITER_ON_REF;
 
@@ -27,7 +28,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, self_ref_ty: Ty<
     }
 }
 
-fn ty_has_iter_method(cx: &LateContext<'_>, self_ref_ty: Ty<'_>) -> Option<(&'static str, &'static str)> {
+fn ty_has_iter_method(cx: &LateContext<'_>, self_ref_ty: Ty<'_>) -> Option<(Symbol, &'static str)> {
     has_iter_method(cx, self_ref_ty).map(|ty_name| {
         let mutbl = match self_ref_ty.kind() {
             ty::Ref(_, _, mutbl) => mutbl,
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 180620e860a..7fd14c4f9b1 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -62,8 +62,7 @@ use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::{self, TraitRef, Ty, TyS};
 use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::source_map::Span;
-use rustc_span::symbol::{sym, Symbol, SymbolStr};
+use rustc_span::symbol::{sym, SymbolStr};
 use rustc_typeck::hir_ty_to_ty;
 
 use crate::utils::{
-- 
cgit 1.4.1-3-g733a5


From 83a955335f986c503ac114cf5009ff965bb21741 Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Thu, 11 Mar 2021 20:18:33 +0900
Subject: fix interning-defined-symbol error

---
 clippy_lints/src/methods/get_unwrap.rs | 4 ++--
 clippy_lints/src/methods/iter_nth.rs   | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/get_unwrap.rs b/clippy_lints/src/methods/get_unwrap.rs
index 2684c50e01b..e157db2712a 100644
--- a/clippy_lints/src/methods/get_unwrap.rs
+++ b/clippy_lints/src/methods/get_unwrap.rs
@@ -27,10 +27,10 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &hir::Expr<'_>, get_args
     } else if is_type_diagnostic_item(cx, expr_ty, sym::vec_type) {
         needs_ref = get_args_str.parse::<usize>().is_ok();
         "Vec"
-    } else if is_type_diagnostic_item(cx, expr_ty, sym!(vecdeque_type)) {
+    } else if is_type_diagnostic_item(cx, expr_ty, sym::vecdeque_type) {
         needs_ref = get_args_str.parse::<usize>().is_ok();
         "VecDeque"
-    } else if !is_mut && is_type_diagnostic_item(cx, expr_ty, sym!(hashmap_type)) {
+    } else if !is_mut && is_type_diagnostic_item(cx, expr_ty, sym::hashmap_type) {
         needs_ref = true;
         "HashMap"
     } else if !is_mut && match_type(cx, expr_ty, &paths::BTREEMAP) {
diff --git a/clippy_lints/src/methods/iter_nth.rs b/clippy_lints/src/methods/iter_nth.rs
index c8adea9536b..cc3e56ea872 100644
--- a/clippy_lints/src/methods/iter_nth.rs
+++ b/clippy_lints/src/methods/iter_nth.rs
@@ -19,7 +19,7 @@ pub(super) fn check<'tcx>(
         "slice"
     } else if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&iter_args[0]), sym::vec_type) {
         "Vec"
-    } else if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&iter_args[0]), sym!(vecdeque_type)) {
+    } else if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&iter_args[0]), sym::vecdeque_type) {
         "VecDeque"
     } else {
         let nth_args = nth_and_iter_args[0];
-- 
cgit 1.4.1-3-g733a5


From 2547edb84272aeb3d01e2b61640a9107c01b281b Mon Sep 17 00:00:00 2001
From: Mateusz Gacek <96mateusz.gacek@gmail.com>
Date: Thu, 11 Mar 2021 23:47:15 -0800
Subject: wrong_self_convention: fix lint in case of `to_*_mut` method

When a method starts with `to_` and ends with `_mut`, it should expect a `&mut self` parameter,
otherwise `&self`.
---
 clippy_lints/src/methods/mod.rs                   | 15 ++--
 clippy_lints/src/methods/wrong_self_convention.rs | 72 +++++++++++++----
 tests/ui/def_id_nocore.stderr                     |  3 +-
 tests/ui/wrong_self_convention.stderr             | 95 +++++++++++++++++------
 tests/ui/wrong_self_conventions_mut.rs            | 30 +++++++
 tests/ui/wrong_self_conventions_mut.stderr        | 19 +++++
 6 files changed, 189 insertions(+), 45 deletions(-)
 create mode 100644 tests/ui/wrong_self_conventions_mut.rs
 create mode 100644 tests/ui/wrong_self_conventions_mut.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 7fd14c4f9b1..16d5e3bb43f 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -191,13 +191,14 @@ declare_clippy_lint! {
     /// **What it does:** Checks for methods with certain name prefixes and which
     /// doesn't match how self is taken. The actual rules are:
     ///
-    /// |Prefix |`self` taken          |
-    /// |-------|----------------------|
-    /// |`as_`  |`&self` or `&mut self`|
-    /// |`from_`| none                 |
-    /// |`into_`|`self`                |
-    /// |`is_`  |`&self` or none       |
-    /// |`to_`  |`&self`               |
+    /// |Prefix |Postfix     |`self` taken          |
+    /// |-------|------------|----------------------|
+    /// |`as_`  | none       |`&self` or `&mut self`|
+    /// |`from_`| none       | none                 |
+    /// |`into_`| none       |`self`                |
+    /// |`is_`  | none       |`&self` or none       |
+    /// |`to_`  | `_mut`     |`&mut &self`          |
+    /// |`to_`  | not `_mut` |`&self`               |
     ///
     /// **Why is this bad?** Consistency breeds readability. If you follow the
     /// conventions, your users won't be surprised that they, e.g., need to supply a
diff --git a/clippy_lints/src/methods/wrong_self_convention.rs b/clippy_lints/src/methods/wrong_self_convention.rs
index 90fab577436..c8bcad7be3e 100644
--- a/clippy_lints/src/methods/wrong_self_convention.rs
+++ b/clippy_lints/src/methods/wrong_self_convention.rs
@@ -1,5 +1,5 @@
 use crate::methods::SelfKind;
-use crate::utils::span_lint;
+use crate::utils::span_lint_and_help;
 use rustc_lint::LateContext;
 use rustc_middle::ty::TyS;
 use rustc_span::source_map::Span;
@@ -9,18 +9,22 @@ use super::WRONG_PUB_SELF_CONVENTION;
 use super::WRONG_SELF_CONVENTION;
 
 #[rustfmt::skip]
-const CONVENTIONS: [(Convention, &[SelfKind]); 7] = [
-    (Convention::Eq("new"), &[SelfKind::No]),
-    (Convention::StartsWith("as_"), &[SelfKind::Ref, SelfKind::RefMut]),
-    (Convention::StartsWith("from_"), &[SelfKind::No]),
-    (Convention::StartsWith("into_"), &[SelfKind::Value]),
-    (Convention::StartsWith("is_"), &[SelfKind::Ref, SelfKind::No]),
-    (Convention::Eq("to_mut"), &[SelfKind::RefMut]),
-    (Convention::StartsWith("to_"), &[SelfKind::Ref]),
+const CONVENTIONS: [(&[Convention], &[SelfKind]); 8] = [
+    (&[Convention::Eq("new")], &[SelfKind::No]),
+    (&[Convention::StartsWith("as_")], &[SelfKind::Ref, SelfKind::RefMut]),
+    (&[Convention::StartsWith("from_")], &[SelfKind::No]),
+    (&[Convention::StartsWith("into_")], &[SelfKind::Value]),
+    (&[Convention::StartsWith("is_")], &[SelfKind::Ref, SelfKind::No]),
+    (&[Convention::Eq("to_mut")], &[SelfKind::RefMut]),
+    (&[Convention::StartsWith("to_"), Convention::EndsWith("_mut")], &[SelfKind::RefMut]),
+    (&[Convention::StartsWith("to_"), Convention::NotEndsWith("_mut")], &[SelfKind::Ref]),
 ];
+
 enum Convention {
     Eq(&'static str),
     StartsWith(&'static str),
+    EndsWith(&'static str),
+    NotEndsWith(&'static str),
 }
 
 impl Convention {
@@ -29,6 +33,8 @@ impl Convention {
         match *self {
             Self::Eq(this) => this == other,
             Self::StartsWith(this) => other.starts_with(this) && this != other,
+            Self::EndsWith(this) => other.ends_with(this) && this != other,
+            Self::NotEndsWith(this) => !Self::EndsWith(this).check(other),
         }
     }
 }
@@ -38,6 +44,8 @@ impl fmt::Display for Convention {
         match *self {
             Self::Eq(this) => this.fmt(f),
             Self::StartsWith(this) => this.fmt(f).and_then(|_| '*'.fmt(f)),
+            Self::EndsWith(this) => '*'.fmt(f).and_then(|_| this.fmt(f)),
+            Self::NotEndsWith(this) => '~'.fmt(f).and_then(|_| this.fmt(f)),
         }
     }
 }
@@ -55,21 +63,59 @@ pub(super) fn check<'tcx>(
     } else {
         WRONG_SELF_CONVENTION
     };
-    if let Some((ref conv, self_kinds)) = &CONVENTIONS.iter().find(|(ref conv, _)| conv.check(item_name)) {
+    if let Some((conventions, self_kinds)) = &CONVENTIONS
+        .iter()
+        .find(|(convs, _)| convs.iter().all(|conv| conv.check(item_name)))
+    {
         if !self_kinds.iter().any(|k| k.matches(cx, self_ty, first_arg_ty)) {
-            span_lint(
+            let suggestion = {
+                if conventions.len() > 1 {
+                    let special_case = {
+                        // Don't mention `NotEndsWith` when there is also `StartsWith` convention present
+                        if conventions.len() == 2 {
+                            match conventions {
+                                [Convention::StartsWith(starts_with), Convention::NotEndsWith(_)]
+                                | [Convention::NotEndsWith(_), Convention::StartsWith(starts_with)] => {
+                                    Some(format!("methods called `{}`", Convention::StartsWith(starts_with)))
+                                },
+                                _ => None,
+                            }
+                        } else {
+                            None
+                        }
+                    };
+
+                    if let Some(suggestion) = special_case {
+                        suggestion
+                    } else {
+                        let s = conventions
+                            .iter()
+                            .map(|c| format!("`{}`", &c.to_string()))
+                            .collect::<Vec<_>>()
+                            .join(" and ");
+
+                        format!("methods called like this: ({})", &s)
+                    }
+                } else {
+                    format!("methods called `{}`", &conventions[0])
+                }
+            };
+
+            span_lint_and_help(
                 cx,
                 lint,
                 first_arg_span,
                 &format!(
-                    "methods called `{}` usually take {}; consider choosing a less ambiguous name",
-                    conv,
+                    "{} usually take {}",
+                    suggestion,
                     &self_kinds
                         .iter()
                         .map(|k| k.description())
                         .collect::<Vec<_>>()
                         .join(" or ")
                 ),
+                None,
+                "consider choosing a less ambiguous name",
             );
         }
     }
diff --git a/tests/ui/def_id_nocore.stderr b/tests/ui/def_id_nocore.stderr
index ed87a50547d..a3e9cc75b08 100644
--- a/tests/ui/def_id_nocore.stderr
+++ b/tests/ui/def_id_nocore.stderr
@@ -1,10 +1,11 @@
-error: methods called `as_*` usually take self by reference or self by mutable reference; consider choosing a less ambiguous name
+error: methods called `as_*` usually take self by reference or self by mutable reference
   --> $DIR/def_id_nocore.rs:26:19
    |
 LL |     pub fn as_ref(self) -> &'static str {
    |                   ^^^^
    |
    = note: `-D clippy::wrong-self-convention` implied by `-D warnings`
+   = help: consider choosing a less ambiguous name
 
 error: aborting due to previous error
 
diff --git a/tests/ui/wrong_self_convention.stderr b/tests/ui/wrong_self_convention.stderr
index 32bd9075bd5..f43fea0d513 100644
--- a/tests/ui/wrong_self_convention.stderr
+++ b/tests/ui/wrong_self_convention.stderr
@@ -1,148 +1,195 @@
-error: methods called `from_*` usually take no self; consider choosing a less ambiguous name
+error: methods called `from_*` usually take no self
   --> $DIR/wrong_self_convention.rs:18:17
    |
 LL |     fn from_i32(self) {}
    |                 ^^^^
    |
    = note: `-D clippy::wrong-self-convention` implied by `-D warnings`
+   = help: consider choosing a less ambiguous name
 
-error: methods called `from_*` usually take no self; consider choosing a less ambiguous name
+error: methods called `from_*` usually take no self
   --> $DIR/wrong_self_convention.rs:24:21
    |
 LL |     pub fn from_i64(self) {}
    |                     ^^^^
+   |
+   = help: consider choosing a less ambiguous name
 
-error: methods called `as_*` usually take self by reference or self by mutable reference; consider choosing a less ambiguous name
+error: methods called `as_*` usually take self by reference or self by mutable reference
   --> $DIR/wrong_self_convention.rs:36:15
    |
 LL |     fn as_i32(self) {}
    |               ^^^^
+   |
+   = help: consider choosing a less ambiguous name
 
-error: methods called `into_*` usually take self by value; consider choosing a less ambiguous name
+error: methods called `into_*` usually take self by value
   --> $DIR/wrong_self_convention.rs:38:17
    |
 LL |     fn into_i32(&self) {}
    |                 ^^^^^
+   |
+   = help: consider choosing a less ambiguous name
 
-error: methods called `is_*` usually take self by reference or no self; consider choosing a less ambiguous name
+error: methods called `is_*` usually take self by reference or no self
   --> $DIR/wrong_self_convention.rs:40:15
    |
 LL |     fn is_i32(self) {}
    |               ^^^^
+   |
+   = help: consider choosing a less ambiguous name
 
-error: methods called `to_*` usually take self by reference; consider choosing a less ambiguous name
+error: methods called `to_*` usually take self by reference
   --> $DIR/wrong_self_convention.rs:42:15
    |
 LL |     fn to_i32(self) {}
    |               ^^^^
+   |
+   = help: consider choosing a less ambiguous name
 
-error: methods called `from_*` usually take no self; consider choosing a less ambiguous name
+error: methods called `from_*` usually take no self
   --> $DIR/wrong_self_convention.rs:44:17
    |
 LL |     fn from_i32(self) {}
    |                 ^^^^
+   |
+   = help: consider choosing a less ambiguous name
 
-error: methods called `as_*` usually take self by reference or self by mutable reference; consider choosing a less ambiguous name
+error: methods called `as_*` usually take self by reference or self by mutable reference
   --> $DIR/wrong_self_convention.rs:46:19
    |
 LL |     pub fn as_i64(self) {}
    |                   ^^^^
+   |
+   = help: consider choosing a less ambiguous name
 
-error: methods called `into_*` usually take self by value; consider choosing a less ambiguous name
+error: methods called `into_*` usually take self by value
   --> $DIR/wrong_self_convention.rs:47:21
    |
 LL |     pub fn into_i64(&self) {}
    |                     ^^^^^
+   |
+   = help: consider choosing a less ambiguous name
 
-error: methods called `is_*` usually take self by reference or no self; consider choosing a less ambiguous name
+error: methods called `is_*` usually take self by reference or no self
   --> $DIR/wrong_self_convention.rs:48:19
    |
 LL |     pub fn is_i64(self) {}
    |                   ^^^^
+   |
+   = help: consider choosing a less ambiguous name
 
-error: methods called `to_*` usually take self by reference; consider choosing a less ambiguous name
+error: methods called `to_*` usually take self by reference
   --> $DIR/wrong_self_convention.rs:49:19
    |
 LL |     pub fn to_i64(self) {}
    |                   ^^^^
+   |
+   = help: consider choosing a less ambiguous name
 
-error: methods called `from_*` usually take no self; consider choosing a less ambiguous name
+error: methods called `from_*` usually take no self
   --> $DIR/wrong_self_convention.rs:50:21
    |
 LL |     pub fn from_i64(self) {}
    |                     ^^^^
+   |
+   = help: consider choosing a less ambiguous name
 
-error: methods called `as_*` usually take self by reference or self by mutable reference; consider choosing a less ambiguous name
+error: methods called `as_*` usually take self by reference or self by mutable reference
   --> $DIR/wrong_self_convention.rs:95:19
    |
 LL |         fn as_i32(self) {}
    |                   ^^^^
+   |
+   = help: consider choosing a less ambiguous name
 
-error: methods called `into_*` usually take self by value; consider choosing a less ambiguous name
+error: methods called `into_*` usually take self by value
   --> $DIR/wrong_self_convention.rs:98:25
    |
 LL |         fn into_i32_ref(&self) {}
    |                         ^^^^^
+   |
+   = help: consider choosing a less ambiguous name
 
-error: methods called `is_*` usually take self by reference or no self; consider choosing a less ambiguous name
+error: methods called `is_*` usually take self by reference or no self
   --> $DIR/wrong_self_convention.rs:100:19
    |
 LL |         fn is_i32(self) {}
    |                   ^^^^
+   |
+   = help: consider choosing a less ambiguous name
 
-error: methods called `to_*` usually take self by reference; consider choosing a less ambiguous name
+error: methods called `to_*` usually take self by reference
   --> $DIR/wrong_self_convention.rs:102:19
    |
 LL |         fn to_i32(self) {}
    |                   ^^^^
+   |
+   = help: consider choosing a less ambiguous name
 
-error: methods called `from_*` usually take no self; consider choosing a less ambiguous name
+error: methods called `from_*` usually take no self
   --> $DIR/wrong_self_convention.rs:104:21
    |
 LL |         fn from_i32(self) {}
    |                     ^^^^
+   |
+   = help: consider choosing a less ambiguous name
 
-error: methods called `as_*` usually take self by reference or self by mutable reference; consider choosing a less ambiguous name
+error: methods called `as_*` usually take self by reference or self by mutable reference
   --> $DIR/wrong_self_convention.rs:119:19
    |
 LL |         fn as_i32(self);
    |                   ^^^^
+   |
+   = help: consider choosing a less ambiguous name
 
-error: methods called `into_*` usually take self by value; consider choosing a less ambiguous name
+error: methods called `into_*` usually take self by value
   --> $DIR/wrong_self_convention.rs:122:25
    |
 LL |         fn into_i32_ref(&self);
    |                         ^^^^^
+   |
+   = help: consider choosing a less ambiguous name
 
-error: methods called `is_*` usually take self by reference or no self; consider choosing a less ambiguous name
+error: methods called `is_*` usually take self by reference or no self
   --> $DIR/wrong_self_convention.rs:124:19
    |
 LL |         fn is_i32(self);
    |                   ^^^^
+   |
+   = help: consider choosing a less ambiguous name
 
-error: methods called `to_*` usually take self by reference; consider choosing a less ambiguous name
+error: methods called `to_*` usually take self by reference
   --> $DIR/wrong_self_convention.rs:126:19
    |
 LL |         fn to_i32(self);
    |                   ^^^^
+   |
+   = help: consider choosing a less ambiguous name
 
-error: methods called `from_*` usually take no self; consider choosing a less ambiguous name
+error: methods called `from_*` usually take no self
   --> $DIR/wrong_self_convention.rs:128:21
    |
 LL |         fn from_i32(self);
    |                     ^^^^
+   |
+   = help: consider choosing a less ambiguous name
 
-error: methods called `into_*` usually take self by value; consider choosing a less ambiguous name
+error: methods called `into_*` usually take self by value
   --> $DIR/wrong_self_convention.rs:146:25
    |
 LL |         fn into_i32_ref(&self);
    |                         ^^^^^
+   |
+   = help: consider choosing a less ambiguous name
 
-error: methods called `from_*` usually take no self; consider choosing a less ambiguous name
+error: methods called `from_*` usually take no self
   --> $DIR/wrong_self_convention.rs:152:21
    |
 LL |         fn from_i32(self);
    |                     ^^^^
+   |
+   = help: consider choosing a less ambiguous name
 
 error: aborting due to 24 previous errors
 
diff --git a/tests/ui/wrong_self_conventions_mut.rs b/tests/ui/wrong_self_conventions_mut.rs
new file mode 100644
index 00000000000..486a0d77235
--- /dev/null
+++ b/tests/ui/wrong_self_conventions_mut.rs
@@ -0,0 +1,30 @@
+// edition:2018
+#![warn(clippy::wrong_self_convention)]
+#![allow(dead_code)]
+
+fn main() {}
+
+mod issue6758 {
+    pub enum Test<T> {
+        One(T),
+        Many(Vec<T>),
+    }
+
+    impl<T> Test<T> {
+        // If a method starts with `to_` and not ends with `_mut` it should expect `&self`
+        pub fn to_many(&mut self) -> Option<&mut [T]> {
+            match self {
+                Self::Many(data) => Some(data),
+                _ => None,
+            }
+        }
+
+        // If a method starts with `to_` and ends with `_mut` it should expect `&mut self`
+        pub fn to_many_mut(&self) -> Option<&[T]> {
+            match self {
+                Self::Many(data) => Some(data),
+                _ => None,
+            }
+        }
+    }
+}
diff --git a/tests/ui/wrong_self_conventions_mut.stderr b/tests/ui/wrong_self_conventions_mut.stderr
new file mode 100644
index 00000000000..7662b38e67d
--- /dev/null
+++ b/tests/ui/wrong_self_conventions_mut.stderr
@@ -0,0 +1,19 @@
+error: methods called `to_*` usually take self by reference
+  --> $DIR/wrong_self_conventions_mut.rs:15:24
+   |
+LL |         pub fn to_many(&mut self) -> Option<&mut [T]> {
+   |                        ^^^^^^^^^
+   |
+   = note: `-D clippy::wrong-self-convention` implied by `-D warnings`
+   = help: consider choosing a less ambiguous name
+
+error: methods called like this: (`to_*` and `*_mut`) usually take self by mutable reference
+  --> $DIR/wrong_self_conventions_mut.rs:23:28
+   |
+LL |         pub fn to_many_mut(&self) -> Option<&[T]> {
+   |                            ^^^^^
+   |
+   = help: consider choosing a less ambiguous name
+
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 11d2af7e9694e8e63000e33f77d4926e936e3822 Mon Sep 17 00:00:00 2001
From: Yusuke Tanaka <yusuktan@maguro.dev>
Date: Fri, 12 Mar 2021 20:46:46 +0900
Subject: Improve suggestion and make it work for macros

---
 clippy_lints/src/if_then_some_else_none.rs | 18 ++++++++++++----
 tests/ui/if_then_some_else_none.rs         | 16 ++++++++++++++
 tests/ui/if_then_some_else_none.stderr     | 34 ++++++++++++++++++++++++++++--
 3 files changed, 62 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/if_then_some_else_none.rs b/clippy_lints/src/if_then_some_else_none.rs
index 569a7f06f95..a527f51b1fd 100644
--- a/clippy_lints/src/if_then_some_else_none.rs
+++ b/clippy_lints/src/if_then_some_else_none.rs
@@ -82,12 +82,22 @@ impl LateLintPass<'_> for IfThenSomeElseNone {
             if let ExprKind::Path(ref els_call_qpath) = els_expr.kind;
             if utils::match_qpath(els_call_qpath, &utils::paths::OPTION_NONE);
             then {
-                let cond_snip = utils::snippet(cx, cond.span, "[condition]");
-                let arg_snip = utils::snippet(cx, then_arg.span, "");
+                let cond_snip = utils::snippet_with_macro_callsite(cx, cond.span, "[condition]");
+                let cond_snip = if matches!(cond.kind, ExprKind::Unary(_, _) | ExprKind::Binary(_, _, _)) {
+                    format!("({})", cond_snip)
+                } else {
+                    cond_snip.into_owned()
+                };
+                let arg_snip = utils::snippet_with_macro_callsite(cx, then_arg.span, "");
+                let closure_body = if then_block.stmts.is_empty() {
+                    arg_snip.into_owned()
+                } else {
+                    format!("{{ /* snippet */ {} }}", arg_snip)
+                };
                 let help = format!(
-                    "consider using `bool::then` like: `{}.then(|| {{ /* snippet */ {} }})`",
+                    "consider using `bool::then` like: `{}.then(|| {})`",
                     cond_snip,
-                    arg_snip,
+                    closure_body,
                 );
                 utils::span_lint_and_help(
                     cx,
diff --git a/tests/ui/if_then_some_else_none.rs b/tests/ui/if_then_some_else_none.rs
index 14a5fe76245..54789bf9320 100644
--- a/tests/ui/if_then_some_else_none.rs
+++ b/tests/ui/if_then_some_else_none.rs
@@ -10,6 +10,22 @@ fn main() {
         None
     };
 
+    // Should issue an error when macros are used.
+    let _ = if matches!(true, true) {
+        println!("true!");
+        Some(matches!(true, false))
+    } else {
+        None
+    };
+
+    // Should issue an error. Binary expression `o < 32` should be parenthesized.
+    let x = Some(5);
+    let _ = x.and_then(|o| if o < 32 { Some(o) } else { None });
+
+    // Should issue an error. Unary expression `!x` should be parenthesized.
+    let x = true;
+    let _ = if !x { Some(0) } else { None };
+
     // Should not issue an error since the `else` block has a statement besides `None`.
     let _ = if foo() {
         println!("true!");
diff --git a/tests/ui/if_then_some_else_none.stderr b/tests/ui/if_then_some_else_none.stderr
index 722c52b1cb4..8cb22d569f4 100644
--- a/tests/ui/if_then_some_else_none.stderr
+++ b/tests/ui/if_then_some_else_none.stderr
@@ -14,7 +14,37 @@ LL | |     };
    = help: consider using `bool::then` like: `foo().then(|| { /* snippet */ "foo" })`
 
 error: this could be simplified with `bool::then`
-  --> $DIR/if_then_some_else_none.rs:66:13
+  --> $DIR/if_then_some_else_none.rs:14:13
+   |
+LL |       let _ = if matches!(true, true) {
+   |  _____________^
+LL | |         println!("true!");
+LL | |         Some(matches!(true, false))
+LL | |     } else {
+LL | |         None
+LL | |     };
+   | |_____^
+   |
+   = help: consider using `bool::then` like: `matches!(true, true).then(|| { /* snippet */ matches!(true, false) })`
+
+error: this could be simplified with `bool::then`
+  --> $DIR/if_then_some_else_none.rs:23:28
+   |
+LL |     let _ = x.and_then(|o| if o < 32 { Some(o) } else { None });
+   |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using `bool::then` like: `(o < 32).then(|| o)`
+
+error: this could be simplified with `bool::then`
+  --> $DIR/if_then_some_else_none.rs:27:13
+   |
+LL |     let _ = if !x { Some(0) } else { None };
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using `bool::then` like: `(!x).then(|| 0)`
+
+error: this could be simplified with `bool::then`
+  --> $DIR/if_then_some_else_none.rs:82:13
    |
 LL |       let _ = if foo() {
    |  _____________^
@@ -27,5 +57,5 @@ LL | |     };
    |
    = help: consider using `bool::then` like: `foo().then(|| { /* snippet */ 150 })`
 
-error: aborting due to 2 previous errors
+error: aborting due to 5 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 93ee80ac3e9ecc3eee4246c56fce5582a6e1a15f Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Sat, 13 Mar 2021 02:09:19 +0900
Subject: Use sym::Iterator instead of paths::ITERATOR

---
 clippy_lints/src/blocks_in_if_conditions.rs         |  7 ++++---
 clippy_lints/src/copy_iterator.rs                   | 21 +++++++++++++--------
 clippy_lints/src/loops/iter_next_loop.rs            |  6 ++++--
 clippy_lints/src/loops/needless_collect.rs          |  6 +++---
 clippy_lints/src/loops/utils.rs                     |  7 +++----
 clippy_lints/src/loops/while_let_on_iterator.rs     |  8 ++++----
 clippy_lints/src/map_clone.rs                       |  5 ++---
 clippy_lints/src/map_identity.rs                    |  4 ++--
 clippy_lints/src/matches.rs                         |  4 ++--
 clippy_lints/src/methods/filter_flat_map.rs         |  5 +++--
 clippy_lints/src/methods/filter_map.rs              |  4 ++--
 clippy_lints/src/methods/filter_map_flat_map.rs     |  5 +++--
 clippy_lints/src/methods/filter_map_identity.rs     |  6 +++---
 clippy_lints/src/methods/filter_map_map.rs          |  5 +++--
 clippy_lints/src/methods/filter_map_next.rs         |  5 +++--
 clippy_lints/src/methods/filter_next.rs             |  5 +++--
 clippy_lints/src/methods/flat_map_identity.rs       |  6 +++---
 .../src/methods/from_iter_instead_of_collect.rs     |  3 ++-
 clippy_lints/src/methods/inspect_for_each.rs        |  6 +++---
 clippy_lints/src/methods/iter_nth_zero.rs           |  5 +++--
 clippy_lints/src/methods/iter_skip_next.rs          |  5 +++--
 clippy_lints/src/methods/iterator_step_by_zero.rs   |  5 +++--
 clippy_lints/src/methods/map_collect_result_unit.rs |  4 ++--
 clippy_lints/src/methods/map_flatten.rs             |  4 ++--
 clippy_lints/src/methods/search_is_some.rs          |  4 ++--
 clippy_lints/src/methods/skip_while_next.rs         |  5 +++--
 clippy_lints/src/methods/unnecessary_filter_map.rs  |  5 +++--
 clippy_lints/src/methods/unnecessary_fold.rs        |  7 +++----
 clippy_utils/src/lib.rs                             |  8 ++++++++
 clippy_utils/src/paths.rs                           |  1 -
 30 files changed, 97 insertions(+), 74 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/blocks_in_if_conditions.rs b/clippy_lints/src/blocks_in_if_conditions.rs
index b53f80fd8bc..59bddb8473b 100644
--- a/clippy_lints/src/blocks_in_if_conditions.rs
+++ b/clippy_lints/src/blocks_in_if_conditions.rs
@@ -1,6 +1,6 @@
 use crate::utils::{
-    differing_macro_contexts, get_parent_expr, get_trait_def_id, implements_trait, paths,
-    snippet_block_with_applicability, span_lint, span_lint_and_sugg,
+    differing_macro_contexts, get_parent_expr, implements_trait, snippet_block_with_applicability, span_lint,
+    span_lint_and_sugg,
 };
 use if_chain::if_chain;
 use rustc_errors::Applicability;
@@ -10,6 +10,7 @@ use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::hir::map::Map;
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::sym;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for `if` conditions that use blocks containing an
@@ -61,7 +62,7 @@ impl<'a, 'tcx> Visitor<'tcx> for ExVisitor<'a, 'tcx> {
                 if let Some(parent) = get_parent_expr(self.cx, expr);
                 if let ExprKind::MethodCall(_, _, args, _) = parent.kind;
                 let caller = self.cx.typeck_results().expr_ty(&args[0]);
-                if let Some(iter_id) = get_trait_def_id(self.cx, &paths::ITERATOR);
+                if let Some(iter_id) = self.cx.tcx.get_diagnostic_item(sym::Iterator);
                 if implements_trait(self.cx, caller, iter_id, &[]);
                 then {
                     return;
diff --git a/clippy_lints/src/copy_iterator.rs b/clippy_lints/src/copy_iterator.rs
index 004bce5f62a..0502f725efb 100644
--- a/clippy_lints/src/copy_iterator.rs
+++ b/clippy_lints/src/copy_iterator.rs
@@ -1,7 +1,10 @@
-use crate::utils::{is_copy, match_path, paths, span_lint_and_note};
+use crate::utils::{is_copy, span_lint_and_note};
 use rustc_hir::{Impl, Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::sym;
+
+use if_chain::if_chain;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for types that implement `Copy` as well as
@@ -33,14 +36,16 @@ declare_lint_pass!(CopyIterator => [COPY_ITERATOR]);
 
 impl<'tcx> LateLintPass<'tcx> for CopyIterator {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
-        if let ItemKind::Impl(Impl {
-            of_trait: Some(ref trait_ref),
-            ..
-        }) = item.kind
-        {
+        if_chain! {
+            if let ItemKind::Impl(Impl {
+                of_trait: Some(ref trait_ref),
+                ..
+            }) = item.kind;
             let ty = cx.tcx.type_of(item.def_id);
-
-            if is_copy(cx, ty) && match_path(&trait_ref.path, &paths::ITERATOR) {
+            if is_copy(cx, ty);
+            if let Some(trait_id) = trait_ref.trait_def_id();
+            if cx.tcx.is_diagnostic_item(sym::Iterator, trait_id);
+            then {
                 span_lint_and_note(
                     cx,
                     COPY_ITERATOR,
diff --git a/clippy_lints/src/loops/iter_next_loop.rs b/clippy_lints/src/loops/iter_next_loop.rs
index cf78bbc49a3..d6b40fa9fa8 100644
--- a/clippy_lints/src/loops/iter_next_loop.rs
+++ b/clippy_lints/src/loops/iter_next_loop.rs
@@ -1,10 +1,12 @@
 use super::ITER_NEXT_LOOP;
-use crate::utils::{match_trait_method, paths, span_lint};
 use rustc_hir::Expr;
 use rustc_lint::LateContext;
+use rustc_span::sym;
+
+use crate::utils::{is_trait_method, span_lint};
 
 pub(super) fn check(cx: &LateContext<'_>, arg: &Expr<'_>, expr: &Expr<'_>) -> bool {
-    if match_trait_method(cx, arg, &paths::ITERATOR) {
+    if is_trait_method(cx, arg, sym::Iterator) {
         span_lint(
             cx,
             ITER_NEXT_LOOP,
diff --git a/clippy_lints/src/loops/needless_collect.rs b/clippy_lints/src/loops/needless_collect.rs
index 92560c80629..f8432abfa8a 100644
--- a/clippy_lints/src/loops/needless_collect.rs
+++ b/clippy_lints/src/loops/needless_collect.rs
@@ -1,7 +1,7 @@
 use super::NEEDLESS_COLLECT;
 use crate::utils::sugg::Sugg;
 use crate::utils::{
-    is_type_diagnostic_item, match_trait_method, match_type, path_to_local_id, paths, snippet, span_lint_and_sugg,
+    is_trait_method, is_type_diagnostic_item, match_type, path_to_local_id, paths, snippet, span_lint_and_sugg,
     span_lint_and_then,
 };
 use if_chain::if_chain;
@@ -23,7 +23,7 @@ fn check_needless_collect_direct_usage<'tcx>(expr: &'tcx Expr<'_>, cx: &LateCont
     if_chain! {
         if let ExprKind::MethodCall(ref method, _, ref args, _) = expr.kind;
         if let ExprKind::MethodCall(ref chain_method, _, _, _) = args[0].kind;
-        if chain_method.ident.name == sym!(collect) && match_trait_method(cx, &args[0], &paths::ITERATOR);
+        if chain_method.ident.name == sym!(collect) && is_trait_method(cx, &args[0], sym::Iterator);
         if let Some(ref generic_args) = chain_method.args;
         if let Some(GenericArg::Type(ref ty)) = generic_args.args.get(0);
         then {
@@ -94,7 +94,7 @@ fn check_needless_collect_indirect_usage<'tcx>(expr: &'tcx Expr<'_>, cx: &LateCo
                     init: Some(ref init_expr), .. }
                 ) = stmt.kind;
                 if let ExprKind::MethodCall(ref method_name, _, &[ref iter_source], ..) = init_expr.kind;
-                if method_name.ident.name == sym!(collect) && match_trait_method(cx, &init_expr, &paths::ITERATOR);
+                if method_name.ident.name == sym!(collect) && is_trait_method(cx, &init_expr, sym::Iterator);
                 if let Some(ref generic_args) = method_name.args;
                 if let Some(GenericArg::Type(ref ty)) = generic_args.args.get(0);
                 if let ty = cx.typeck_results().node_type(ty.hir_id);
diff --git a/clippy_lints/src/loops/utils.rs b/clippy_lints/src/loops/utils.rs
index 9e38e17719a..e62b2ab16d1 100644
--- a/clippy_lints/src/loops/utils.rs
+++ b/clippy_lints/src/loops/utils.rs
@@ -1,6 +1,5 @@
 use crate::utils::{
-    get_parent_expr, get_trait_def_id, has_iter_method, implements_trait, is_integer_const, path_to_local,
-    path_to_local_id, paths, sugg,
+    get_parent_expr, has_iter_method, implements_trait, is_integer_const, path_to_local, path_to_local_id, sugg,
 };
 use if_chain::if_chain;
 use rustc_data_structures::fx::FxHashMap;
@@ -10,7 +9,7 @@ use rustc_hir::{BinOpKind, BorrowKind, Expr, ExprKind, HirId, Mutability, Pat, P
 use rustc_lint::LateContext;
 use rustc_middle::hir::map::Map;
 use rustc_span::source_map::Span;
-use rustc_span::symbol::Symbol;
+use rustc_span::symbol::{sym, Symbol};
 use std::iter::Iterator;
 
 #[derive(Debug, PartialEq)]
@@ -316,7 +315,7 @@ pub(super) fn get_span_of_entire_for_loop(expr: &Expr<'_>) -> Span {
 /// If `arg` was the argument to a `for` loop, return the "cleanest" way of writing the
 /// actual `Iterator` that the loop uses.
 pub(super) fn make_iterator_snippet(cx: &LateContext<'_>, arg: &Expr<'_>, applic_ref: &mut Applicability) -> String {
-    let impls_iterator = get_trait_def_id(cx, &paths::ITERATOR).map_or(false, |id| {
+    let impls_iterator = cx.tcx.get_diagnostic_item(sym::Iterator).map_or(false, |id| {
         implements_trait(cx, cx.typeck_results().expr_ty(arg), id, &[])
     });
     if impls_iterator {
diff --git a/clippy_lints/src/loops/while_let_on_iterator.rs b/clippy_lints/src/loops/while_let_on_iterator.rs
index e5a47694faa..f3b8d0da9cd 100644
--- a/clippy_lints/src/loops/while_let_on_iterator.rs
+++ b/clippy_lints/src/loops/while_let_on_iterator.rs
@@ -2,8 +2,8 @@ use super::utils::{LoopNestVisitor, Nesting};
 use super::WHILE_LET_ON_ITERATOR;
 use crate::utils::usage::mutated_variables;
 use crate::utils::{
-    get_enclosing_block, get_trait_def_id, implements_trait, is_refutable, last_path_segment, match_trait_method,
-    path_to_local, path_to_local_id, paths, snippet_with_applicability, span_lint_and_sugg,
+    get_enclosing_block, implements_trait, is_refutable, is_trait_method, last_path_segment, path_to_local,
+    path_to_local_id, snippet_with_applicability, span_lint_and_sugg,
 };
 use if_chain::if_chain;
 use rustc_errors::Applicability;
@@ -27,7 +27,7 @@ pub(super) fn check(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
             // Don't lint when the iterator is recreated on every iteration
             if_chain! {
                 if let ExprKind::MethodCall(..) | ExprKind::Call(..) = iter_expr.kind;
-                if let Some(iter_def_id) = get_trait_def_id(cx, &paths::ITERATOR);
+                if let Some(iter_def_id) = cx.tcx.get_diagnostic_item(sym::Iterator);
                 if implements_trait(cx, cx.typeck_results().expr_ty(iter_expr), iter_def_id, &[]);
                 then {
                     return;
@@ -36,7 +36,7 @@ pub(super) fn check(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
 
             let lhs_constructor = last_path_segment(qpath);
             if method_path.ident.name == sym::next
-                && match_trait_method(cx, match_expr, &paths::ITERATOR)
+                && is_trait_method(cx, match_expr, sym::Iterator)
                 && lhs_constructor.ident.name == sym::Some
                 && (pat_args.is_empty()
                     || !is_refutable(cx, &pat_args[0])
diff --git a/clippy_lints/src/map_clone.rs b/clippy_lints/src/map_clone.rs
index 4b685c09a05..61cf768bcab 100644
--- a/clippy_lints/src/map_clone.rs
+++ b/clippy_lints/src/map_clone.rs
@@ -1,6 +1,5 @@
-use crate::utils::paths;
 use crate::utils::{
-    is_copy, is_type_diagnostic_item, match_trait_method, remove_blocks, snippet_with_applicability, span_lint_and_sugg,
+    is_copy, is_trait_method, is_type_diagnostic_item, remove_blocks, snippet_with_applicability, span_lint_and_sugg,
 };
 use if_chain::if_chain;
 use rustc_errors::Applicability;
@@ -55,7 +54,7 @@ impl<'tcx> LateLintPass<'tcx> for MapClone {
             if args.len() == 2;
             if method.ident.name == sym::map;
             let ty = cx.typeck_results().expr_ty(&args[0]);
-            if is_type_diagnostic_item(cx, ty, sym::option_type) || match_trait_method(cx, e, &paths::ITERATOR);
+            if is_type_diagnostic_item(cx, ty, sym::option_type) || is_trait_method(cx, e, sym::Iterator);
             if let hir::ExprKind::Closure(_, _, body_id, _, _) = args[1].kind;
             let closure_body = cx.tcx.hir().body(body_id);
             let closure_expr = remove_blocks(&closure_body.value);
diff --git a/clippy_lints/src/map_identity.rs b/clippy_lints/src/map_identity.rs
index 9f9c108a85a..7202a29edd9 100644
--- a/clippy_lints/src/map_identity.rs
+++ b/clippy_lints/src/map_identity.rs
@@ -1,5 +1,5 @@
 use crate::utils::{
-    is_adjusted, is_type_diagnostic_item, match_path, match_trait_method, match_var, paths, remove_blocks,
+    is_adjusted, is_trait_method, is_type_diagnostic_item, match_path, match_var, paths, remove_blocks,
     span_lint_and_sugg,
 };
 use if_chain::if_chain;
@@ -65,7 +65,7 @@ fn get_map_argument<'a>(cx: &LateContext<'_>, expr: &'a Expr<'a>) -> Option<&'a
         if let ExprKind::MethodCall(ref method, _, ref args, _) = expr.kind;
         if args.len() == 2 && method.ident.name == sym::map;
         let caller_ty = cx.typeck_results().expr_ty(&args[0]);
-        if match_trait_method(cx, expr, &paths::ITERATOR)
+        if is_trait_method(cx, expr, sym::Iterator)
             || is_type_diagnostic_item(cx, caller_ty, sym::result_type)
             || is_type_diagnostic_item(cx, caller_ty, sym::option_type);
         then {
diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index 1d5a6e7fcc5..e6c2885eb4d 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -1614,7 +1614,7 @@ where
 
 mod redundant_pattern_match {
     use super::REDUNDANT_PATTERN_MATCHING;
-    use crate::utils::{match_qpath, match_trait_method, paths, snippet, span_lint_and_then};
+    use crate::utils::{is_trait_method, match_qpath, paths, snippet, span_lint_and_then};
     use if_chain::if_chain;
     use rustc_ast::ast::LitKind;
     use rustc_errors::Applicability;
@@ -1679,7 +1679,7 @@ mod redundant_pattern_match {
             if keyword == "while";
             if let ExprKind::MethodCall(method_path, _, _, _) = op.kind;
             if method_path.ident.name == sym::next;
-            if match_trait_method(cx, op, &paths::ITERATOR);
+            if is_trait_method(cx, op, sym::Iterator);
             then {
                 return;
             }
diff --git a/clippy_lints/src/methods/filter_flat_map.rs b/clippy_lints/src/methods/filter_flat_map.rs
index 8da867fce51..42f05aa0b3a 100644
--- a/clippy_lints/src/methods/filter_flat_map.rs
+++ b/clippy_lints/src/methods/filter_flat_map.rs
@@ -1,6 +1,7 @@
-use crate::utils::{match_trait_method, paths, span_lint_and_help};
+use crate::utils::{is_trait_method, span_lint_and_help};
 use rustc_hir as hir;
 use rustc_lint::LateContext;
+use rustc_span::sym;
 
 use super::FILTER_MAP;
 
@@ -12,7 +13,7 @@ pub(super) fn check<'tcx>(
     _map_args: &'tcx [hir::Expr<'_>],
 ) {
     // lint if caller of `.filter().flat_map()` is an Iterator
-    if match_trait_method(cx, expr, &paths::ITERATOR) {
+    if is_trait_method(cx, expr, sym::Iterator) {
         let msg = "called `filter(..).flat_map(..)` on an `Iterator`";
         let hint = "this is more succinctly expressed by calling `.flat_map(..)` \
                     and filtering by returning `iter::empty()`";
diff --git a/clippy_lints/src/methods/filter_map.rs b/clippy_lints/src/methods/filter_map.rs
index f559160004c..91c11afcaaf 100644
--- a/clippy_lints/src/methods/filter_map.rs
+++ b/clippy_lints/src/methods/filter_map.rs
@@ -1,4 +1,4 @@
-use crate::utils::{match_trait_method, path_to_local_id, paths, snippet, span_lint_and_sugg, SpanlessEq};
+use crate::utils::{is_trait_method, path_to_local_id, snippet, span_lint_and_sugg, SpanlessEq};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
@@ -15,7 +15,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, is_
     if_chain! {
         if let ExprKind::MethodCall(_, _, [map_recv, map_arg], map_span) = expr.kind;
         if let ExprKind::MethodCall(_, _, [_, filter_arg], filter_span) = map_recv.kind;
-        if match_trait_method(cx, map_recv, &paths::ITERATOR);
+        if is_trait_method(cx, map_recv, sym::Iterator);
 
         // filter(|x| ...is_some())...
         if let ExprKind::Closure(_, _, filter_body_id, ..) = filter_arg.kind;
diff --git a/clippy_lints/src/methods/filter_map_flat_map.rs b/clippy_lints/src/methods/filter_map_flat_map.rs
index a6db138623a..e113f3f71b1 100644
--- a/clippy_lints/src/methods/filter_map_flat_map.rs
+++ b/clippy_lints/src/methods/filter_map_flat_map.rs
@@ -1,6 +1,7 @@
-use crate::utils::{match_trait_method, paths, span_lint_and_help};
+use crate::utils::{is_trait_method, span_lint_and_help};
 use rustc_hir as hir;
 use rustc_lint::LateContext;
+use rustc_span::sym;
 
 use super::FILTER_MAP;
 
@@ -12,7 +13,7 @@ pub(super) fn check<'tcx>(
     _map_args: &'tcx [hir::Expr<'_>],
 ) {
     // lint if caller of `.filter_map().flat_map()` is an Iterator
-    if match_trait_method(cx, expr, &paths::ITERATOR) {
+    if is_trait_method(cx, expr, sym::Iterator) {
         let msg = "called `filter_map(..).flat_map(..)` on an `Iterator`";
         let hint = "this is more succinctly expressed by calling `.flat_map(..)` \
                     and filtering by returning `iter::empty()`";
diff --git a/clippy_lints/src/methods/filter_map_identity.rs b/clippy_lints/src/methods/filter_map_identity.rs
index 9e646360a40..5f627b42abc 100644
--- a/clippy_lints/src/methods/filter_map_identity.rs
+++ b/clippy_lints/src/methods/filter_map_identity.rs
@@ -1,9 +1,9 @@
-use crate::utils::{match_qpath, match_trait_method, path_to_local_id, paths, span_lint_and_sugg};
+use crate::utils::{is_trait_method, match_qpath, path_to_local_id, paths, span_lint_and_sugg};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
-use rustc_span::source_map::Span;
+use rustc_span::{source_map::Span, sym};
 
 use super::FILTER_MAP_IDENTITY;
 
@@ -13,7 +13,7 @@ pub(super) fn check(
     filter_map_args: &[hir::Expr<'_>],
     filter_map_span: Span,
 ) {
-    if match_trait_method(cx, expr, &paths::ITERATOR) {
+    if is_trait_method(cx, expr, sym::Iterator) {
         let arg_node = &filter_map_args[1].kind;
 
         let apply_lint = |message: &str| {
diff --git a/clippy_lints/src/methods/filter_map_map.rs b/clippy_lints/src/methods/filter_map_map.rs
index d015b4c7b38..2e704c4c555 100644
--- a/clippy_lints/src/methods/filter_map_map.rs
+++ b/clippy_lints/src/methods/filter_map_map.rs
@@ -1,6 +1,7 @@
-use crate::utils::{match_trait_method, paths, span_lint_and_help};
+use crate::utils::{is_trait_method, span_lint_and_help};
 use rustc_hir as hir;
 use rustc_lint::LateContext;
+use rustc_span::sym;
 
 use super::FILTER_MAP;
 
@@ -12,7 +13,7 @@ pub(super) fn check<'tcx>(
     _map_args: &'tcx [hir::Expr<'_>],
 ) {
     // lint if caller of `.filter_map().map()` is an Iterator
-    if match_trait_method(cx, expr, &paths::ITERATOR) {
+    if is_trait_method(cx, expr, sym::Iterator) {
         let msg = "called `filter_map(..).map(..)` on an `Iterator`";
         let hint = "this is more succinctly expressed by only calling `.filter_map(..)` instead";
         span_lint_and_help(cx, FILTER_MAP, expr.span, msg, None, hint);
diff --git a/clippy_lints/src/methods/filter_map_next.rs b/clippy_lints/src/methods/filter_map_next.rs
index a789df922ff..9019202df0c 100644
--- a/clippy_lints/src/methods/filter_map_next.rs
+++ b/clippy_lints/src/methods/filter_map_next.rs
@@ -1,8 +1,9 @@
-use crate::utils::{match_trait_method, meets_msrv, paths, snippet, span_lint, span_lint_and_sugg};
+use crate::utils::{is_trait_method, meets_msrv, snippet, span_lint, span_lint_and_sugg};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
 use rustc_semver::RustcVersion;
+use rustc_span::sym;
 
 use super::FILTER_MAP_NEXT;
 
@@ -14,7 +15,7 @@ pub(super) fn check<'tcx>(
     filter_args: &'tcx [hir::Expr<'_>],
     msrv: Option<&RustcVersion>,
 ) {
-    if match_trait_method(cx, expr, &paths::ITERATOR) {
+    if is_trait_method(cx, expr, sym::Iterator) {
         if !meets_msrv(msrv, &FILTER_MAP_NEXT_MSRV) {
             return;
         }
diff --git a/clippy_lints/src/methods/filter_next.rs b/clippy_lints/src/methods/filter_next.rs
index 81619e73017..34787b9a828 100644
--- a/clippy_lints/src/methods/filter_next.rs
+++ b/clippy_lints/src/methods/filter_next.rs
@@ -1,14 +1,15 @@
-use crate::utils::{match_trait_method, paths, snippet, span_lint, span_lint_and_sugg};
+use crate::utils::{is_trait_method, snippet, span_lint, span_lint_and_sugg};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
+use rustc_span::sym;
 
 use super::FILTER_NEXT;
 
 /// lint use of `filter().next()` for `Iterators`
 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, filter_args: &'tcx [hir::Expr<'_>]) {
     // lint if caller of `.filter().next()` is an Iterator
-    if match_trait_method(cx, expr, &paths::ITERATOR) {
+    if is_trait_method(cx, expr, sym::Iterator) {
         let msg = "called `filter(..).next()` on an `Iterator`. This is more succinctly expressed by calling \
                    `.find(..)` instead";
         let filter_snippet = snippet(cx, filter_args[1].span, "..");
diff --git a/clippy_lints/src/methods/flat_map_identity.rs b/clippy_lints/src/methods/flat_map_identity.rs
index ce3194f8a23..19ddceeccce 100644
--- a/clippy_lints/src/methods/flat_map_identity.rs
+++ b/clippy_lints/src/methods/flat_map_identity.rs
@@ -1,9 +1,9 @@
-use crate::utils::{match_qpath, match_trait_method, paths, span_lint_and_sugg};
+use crate::utils::{is_trait_method, match_qpath, paths, span_lint_and_sugg};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
-use rustc_span::source_map::Span;
+use rustc_span::{source_map::Span, sym};
 
 use super::FLAT_MAP_IDENTITY;
 
@@ -14,7 +14,7 @@ pub(super) fn check<'tcx>(
     flat_map_args: &'tcx [hir::Expr<'_>],
     flat_map_span: Span,
 ) {
-    if match_trait_method(cx, expr, &paths::ITERATOR) {
+    if is_trait_method(cx, expr, sym::Iterator) {
         let arg_node = &flat_map_args[1].kind;
 
         let apply_lint = |message: &str| {
diff --git a/clippy_lints/src/methods/from_iter_instead_of_collect.rs b/clippy_lints/src/methods/from_iter_instead_of_collect.rs
index e50d0a33400..a5c5bc0e4e2 100644
--- a/clippy_lints/src/methods/from_iter_instead_of_collect.rs
+++ b/clippy_lints/src/methods/from_iter_instead_of_collect.rs
@@ -4,6 +4,7 @@ use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LintContext};
 use rustc_middle::ty::Ty;
+use rustc_span::sym;
 
 use super::FROM_ITER_INSTEAD_OF_COLLECT;
 
@@ -13,7 +14,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::Exp
 
     if_chain! {
         if let Some(from_iter_id) = get_trait_def_id(cx, &paths::FROM_ITERATOR);
-        if let Some(iter_id) = get_trait_def_id(cx, &paths::ITERATOR);
+        if let Some(iter_id) = cx.tcx.get_diagnostic_item(sym::Iterator);
 
         if implements_trait(cx, ty, from_iter_id, &[]) && implements_trait(cx, arg_ty, iter_id, &[]);
         then {
diff --git a/clippy_lints/src/methods/inspect_for_each.rs b/clippy_lints/src/methods/inspect_for_each.rs
index 959457a5bfc..e7c3a433fe1 100644
--- a/clippy_lints/src/methods/inspect_for_each.rs
+++ b/clippy_lints/src/methods/inspect_for_each.rs
@@ -1,14 +1,14 @@
 use rustc_hir as hir;
 use rustc_lint::LateContext;
-use rustc_span::source_map::Span;
+use rustc_span::{source_map::Span, sym};
 
-use crate::utils::{match_trait_method, paths, span_lint_and_help};
+use crate::utils::{is_trait_method, span_lint_and_help};
 
 use super::INSPECT_FOR_EACH;
 
 /// lint use of `inspect().for_each()` for `Iterators`
 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, inspect_span: Span) {
-    if match_trait_method(cx, expr, &paths::ITERATOR) {
+    if is_trait_method(cx, expr, sym::Iterator) {
         let msg = "called `inspect(..).for_each(..)` on an `Iterator`";
         let hint = "move the code from `inspect(..)` to `for_each(..)` and remove the `inspect(..)`";
         span_lint_and_help(
diff --git a/clippy_lints/src/methods/iter_nth_zero.rs b/clippy_lints/src/methods/iter_nth_zero.rs
index 247192d81f3..ca2e5db4382 100644
--- a/clippy_lints/src/methods/iter_nth_zero.rs
+++ b/clippy_lints/src/methods/iter_nth_zero.rs
@@ -1,15 +1,16 @@
 use crate::consts::{constant, Constant};
-use crate::utils::{match_trait_method, paths, snippet_with_applicability, span_lint_and_sugg};
+use crate::utils::{is_trait_method, snippet_with_applicability, span_lint_and_sugg};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
+use rustc_span::sym;
 
 use super::ITER_NTH_ZERO;
 
 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &hir::Expr<'_>, nth_args: &'tcx [hir::Expr<'_>]) {
     if_chain! {
-        if match_trait_method(cx, expr, &paths::ITERATOR);
+        if is_trait_method(cx, expr, sym::Iterator);
         if let Some((Constant::Int(0), _)) = constant(cx, cx.typeck_results(), &nth_args[1]);
         then {
             let mut applicability = Applicability::MachineApplicable;
diff --git a/clippy_lints/src/methods/iter_skip_next.rs b/clippy_lints/src/methods/iter_skip_next.rs
index 5f5969134e4..bdfa133b9e2 100644
--- a/clippy_lints/src/methods/iter_skip_next.rs
+++ b/clippy_lints/src/methods/iter_skip_next.rs
@@ -1,13 +1,14 @@
-use crate::utils::{match_trait_method, paths, snippet, span_lint_and_sugg};
+use crate::utils::{is_trait_method, snippet, span_lint_and_sugg};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
+use rustc_span::sym;
 
 use super::ITER_SKIP_NEXT;
 
 pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, skip_args: &[hir::Expr<'_>]) {
     // lint if caller of skip is an Iterator
-    if match_trait_method(cx, expr, &paths::ITERATOR) {
+    if is_trait_method(cx, expr, sym::Iterator) {
         if let [caller, n] = skip_args {
             let hint = format!(".nth({})", snippet(cx, n.span, ".."));
             span_lint_and_sugg(
diff --git a/clippy_lints/src/methods/iterator_step_by_zero.rs b/clippy_lints/src/methods/iterator_step_by_zero.rs
index 3e05d7f76b7..019a08f746e 100644
--- a/clippy_lints/src/methods/iterator_step_by_zero.rs
+++ b/clippy_lints/src/methods/iterator_step_by_zero.rs
@@ -1,12 +1,13 @@
 use crate::consts::{constant, Constant};
-use crate::utils::{match_trait_method, paths, span_lint};
+use crate::utils::{is_trait_method, span_lint};
 use rustc_hir as hir;
 use rustc_lint::LateContext;
+use rustc_span::sym;
 
 use super::ITERATOR_STEP_BY_ZERO;
 
 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &hir::Expr<'_>, args: &'tcx [hir::Expr<'_>]) {
-    if match_trait_method(cx, expr, &paths::ITERATOR) {
+    if is_trait_method(cx, expr, sym::Iterator) {
         if let Some((Constant::Int(0), _)) = constant(cx, cx.typeck_results(), &args[1]) {
             span_lint(
                 cx,
diff --git a/clippy_lints/src/methods/map_collect_result_unit.rs b/clippy_lints/src/methods/map_collect_result_unit.rs
index 5b20e268d9f..8f4de00a2b7 100644
--- a/clippy_lints/src/methods/map_collect_result_unit.rs
+++ b/clippy_lints/src/methods/map_collect_result_unit.rs
@@ -1,4 +1,4 @@
-use crate::utils::{is_type_diagnostic_item, match_trait_method, paths, snippet, span_lint_and_sugg};
+use crate::utils::{is_trait_method, is_type_diagnostic_item, snippet, span_lint_and_sugg};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
@@ -17,7 +17,7 @@ pub(super) fn check(
     if_chain! {
         // called on Iterator
         if let [map_expr] = collect_args;
-        if match_trait_method(cx, map_expr, &paths::ITERATOR);
+        if is_trait_method(cx, map_expr, sym::Iterator);
         // return of collect `Result<(),_>`
         let collect_ret_ty = cx.typeck_results().expr_ty(expr);
         if is_type_diagnostic_item(cx, collect_ret_ty, sym::result_type);
diff --git a/clippy_lints/src/methods/map_flatten.rs b/clippy_lints/src/methods/map_flatten.rs
index 14a14e4f9ec..afd76e8b959 100644
--- a/clippy_lints/src/methods/map_flatten.rs
+++ b/clippy_lints/src/methods/map_flatten.rs
@@ -1,4 +1,4 @@
-use crate::utils::{is_type_diagnostic_item, match_trait_method, paths, snippet, span_lint_and_sugg};
+use crate::utils::{is_trait_method, is_type_diagnostic_item, snippet, span_lint_and_sugg};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
@@ -10,7 +10,7 @@ use super::MAP_FLATTEN;
 /// lint use of `map().flatten()` for `Iterators` and 'Options'
 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, map_args: &'tcx [hir::Expr<'_>]) {
     // lint if caller of `.map().flatten()` is an Iterator
-    if match_trait_method(cx, expr, &paths::ITERATOR) {
+    if is_trait_method(cx, expr, sym::Iterator) {
         let map_closure_ty = cx.typeck_results().expr_ty(&map_args[1]);
         let is_map_to_option = match map_closure_ty.kind() {
             ty::Closure(_, _) | ty::FnDef(_, _) | ty::FnPtr(_) => {
diff --git a/clippy_lints/src/methods/search_is_some.rs b/clippy_lints/src/methods/search_is_some.rs
index e9e65443220..eb3dc308722 100644
--- a/clippy_lints/src/methods/search_is_some.rs
+++ b/clippy_lints/src/methods/search_is_some.rs
@@ -1,5 +1,5 @@
 use crate::utils::{
-    is_type_diagnostic_item, match_trait_method, paths, snippet, snippet_with_applicability, span_lint_and_help,
+    is_trait_method, is_type_diagnostic_item, snippet, snippet_with_applicability, span_lint_and_help,
     span_lint_and_sugg, strip_pat_refs,
 };
 use if_chain::if_chain;
@@ -24,7 +24,7 @@ pub(super) fn check<'tcx>(
     method_span: Span,
 ) {
     // lint if caller of search is an Iterator
-    if match_trait_method(cx, &is_some_args[0], &paths::ITERATOR) {
+    if is_trait_method(cx, &is_some_args[0], sym::Iterator) {
         let msg = format!(
             "called `is_some()` after searching an `Iterator` with `{}`",
             search_method
diff --git a/clippy_lints/src/methods/skip_while_next.rs b/clippy_lints/src/methods/skip_while_next.rs
index 8ba6ae95200..a9ff78c3260 100644
--- a/clippy_lints/src/methods/skip_while_next.rs
+++ b/clippy_lints/src/methods/skip_while_next.rs
@@ -1,13 +1,14 @@
-use crate::utils::{match_trait_method, paths, span_lint_and_help};
+use crate::utils::{is_trait_method, span_lint_and_help};
 use rustc_hir as hir;
 use rustc_lint::LateContext;
+use rustc_span::sym;
 
 use super::SKIP_WHILE_NEXT;
 
 /// lint use of `skip_while().next()` for `Iterators`
 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, _skip_while_args: &'tcx [hir::Expr<'_>]) {
     // lint if caller of `.skip_while().next()` is an Iterator
-    if match_trait_method(cx, expr, &paths::ITERATOR) {
+    if is_trait_method(cx, expr, sym::Iterator) {
         span_lint_and_help(
             cx,
             SKIP_WHILE_NEXT,
diff --git a/clippy_lints/src/methods/unnecessary_filter_map.rs b/clippy_lints/src/methods/unnecessary_filter_map.rs
index 12b2cf0a165..686874c0a24 100644
--- a/clippy_lints/src/methods/unnecessary_filter_map.rs
+++ b/clippy_lints/src/methods/unnecessary_filter_map.rs
@@ -1,16 +1,17 @@
 use crate::utils::usage::mutated_variables;
-use crate::utils::{match_qpath, match_trait_method, path_to_local_id, paths, span_lint};
+use crate::utils::{is_trait_method, match_qpath, path_to_local_id, paths, span_lint};
 use rustc_hir as hir;
 use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
 use rustc_lint::LateContext;
 use rustc_middle::hir::map::Map;
+use rustc_span::sym;
 
 use if_chain::if_chain;
 
 use super::UNNECESSARY_FILTER_MAP;
 
 pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::Expr<'_>]) {
-    if !match_trait_method(cx, expr, &paths::ITERATOR) {
+    if !is_trait_method(cx, expr, sym::Iterator) {
         return;
     }
 
diff --git a/clippy_lints/src/methods/unnecessary_fold.rs b/clippy_lints/src/methods/unnecessary_fold.rs
index a26443f4ee9..9aa53f02ef0 100644
--- a/clippy_lints/src/methods/unnecessary_fold.rs
+++ b/clippy_lints/src/methods/unnecessary_fold.rs
@@ -1,6 +1,5 @@
 use crate::utils::{
-    match_trait_method, path_to_local_id, paths, remove_blocks, snippet_with_applicability, span_lint_and_sugg,
-    strip_pat_refs,
+    is_trait_method, path_to_local_id, remove_blocks, snippet_with_applicability, span_lint_and_sugg, strip_pat_refs,
 };
 use if_chain::if_chain;
 use rustc_ast::ast;
@@ -8,7 +7,7 @@ use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_hir::PatKind;
 use rustc_lint::LateContext;
-use rustc_span::source_map::Span;
+use rustc_span::{source_map::Span, sym};
 
 use super::UNNECESSARY_FOLD;
 
@@ -71,7 +70,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, fold_args: &[hir
     }
 
     // Check that this is a call to Iterator::fold rather than just some function called fold
-    if !match_trait_method(cx, expr, &paths::ITERATOR) {
+    if !is_trait_method(cx, expr, sym::Iterator) {
         return;
     }
 
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index e17af49f618..3dad21d2028 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -273,6 +273,7 @@ pub fn is_isize_or_usize(typ: Ty<'_>) -> bool {
 }
 
 /// Checks if the method call given in `expr` belongs to the given trait.
+/// This is a deprecated function, consider using [`is_trait_method`].
 pub fn match_trait_method(cx: &LateContext<'_>, expr: &Expr<'_>, path: &[&str]) -> bool {
     let def_id = cx.typeck_results().type_dependent_def_id(expr.hir_id).unwrap();
     let trt_id = cx.tcx.trait_of_item(def_id);
@@ -295,6 +296,13 @@ pub fn is_diagnostic_assoc_item(cx: &LateContext<'_>, def_id: DefId, diag_item:
         .map_or(false, |assoc_def_id| cx.tcx.is_diagnostic_item(diag_item, assoc_def_id))
 }
 
+/// Checks if the method call given in `expr` belongs to the given trait.
+pub fn is_trait_method(cx: &LateContext<'_>, expr: &Expr<'_>, diag_item: Symbol) -> bool {
+    cx.typeck_results()
+        .type_dependent_def_id(expr.hir_id)
+        .map_or(false, |did| is_diagnostic_assoc_item(cx, did, diag_item))
+}
+
 /// Checks if an expression references a variable of the given name.
 pub fn match_var(expr: &Expr<'_>, var: Symbol) -> bool {
     if let ExprKind::Path(QPath::Resolved(None, ref path)) = expr.kind {
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index 560614efc74..11a446e42a4 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -61,7 +61,6 @@ pub const IO_READ: [&str; 3] = ["std", "io", "Read"];
 pub const IO_WRITE: [&str; 3] = ["std", "io", "Write"];
 pub const IPADDR_V4: [&str; 4] = ["std", "net", "IpAddr", "V4"];
 pub const IPADDR_V6: [&str; 4] = ["std", "net", "IpAddr", "V6"];
-pub const ITERATOR: [&str; 5] = ["core", "iter", "traits", "iterator", "Iterator"];
 #[cfg(feature = "internal-lints")]
 pub const KW_MODULE: [&str; 3] = ["rustc_span", "symbol", "kw"];
 #[cfg(feature = "internal-lints")]
-- 
cgit 1.4.1-3-g733a5


From 6bc5fe4a88d1c6dce50c7be169f8be5d77d4f7e7 Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Fri, 12 Mar 2021 20:40:23 +0100
Subject: inconsistent_struct_constructor: try to make message and lint
 description a bit clearer

---
 clippy_lints/src/inconsistent_struct_constructor.rs | 12 +++++++-----
 tests/ui/inconsistent_struct_constructor.stderr     |  4 ++--
 2 files changed, 9 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/inconsistent_struct_constructor.rs b/clippy_lints/src/inconsistent_struct_constructor.rs
index 4f35e13c85a..49c17a12102 100644
--- a/clippy_lints/src/inconsistent_struct_constructor.rs
+++ b/clippy_lints/src/inconsistent_struct_constructor.rs
@@ -10,8 +10,9 @@ use if_chain::if_chain;
 use crate::utils::{snippet, span_lint_and_sugg};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for struct constructors where the order of the field init
-    /// shorthand in the constructor is inconsistent with the order in the struct definition.
+    /// **What it does:** Checks for struct constructors where all fields are shorthand and
+    /// the order of the field init shorthand in the constructor is inconsistent
+    /// with the order in the struct definition.
     ///
     /// **Why is this bad?** Since the order of fields in a constructor doesn't affect the
     /// resulted instance as the below example indicates,
@@ -25,11 +26,11 @@ declare_clippy_lint! {
     /// let x = 1;
     /// let y = 2;
     ///
-    /// // This assertion never fails.
+    /// // This assertion never fails:
     /// assert_eq!(Foo { x, y }, Foo { y, x });
     /// ```
     ///
-    /// inconsistent order means nothing and just decreases readability and consistency.
+    /// inconsistent order can be confusing and decreases readability and consistency.
     ///
     /// **Known problems:** None.
     ///
@@ -42,6 +43,7 @@ declare_clippy_lint! {
     /// }
     /// let x = 1;
     /// let y = 2;
+    ///
     /// Foo { y, x };
     /// ```
     ///
@@ -107,7 +109,7 @@ impl LateLintPass<'_> for InconsistentStructConstructor {
                     cx,
                     INCONSISTENT_STRUCT_CONSTRUCTOR,
                     expr.span,
-                    "inconsistent struct constructor",
+                    "struct constructor field order is inconsistent with struct definition field order",
                     "try",
                     sugg,
                     Applicability::MachineApplicable,
diff --git a/tests/ui/inconsistent_struct_constructor.stderr b/tests/ui/inconsistent_struct_constructor.stderr
index d7abe44f254..d021bb19579 100644
--- a/tests/ui/inconsistent_struct_constructor.stderr
+++ b/tests/ui/inconsistent_struct_constructor.stderr
@@ -1,4 +1,4 @@
-error: inconsistent struct constructor
+error: struct constructor field order is inconsistent with struct definition field order
   --> $DIR/inconsistent_struct_constructor.rs:25:9
    |
 LL |         Foo { y, x, z };
@@ -6,7 +6,7 @@ LL |         Foo { y, x, z };
    |
    = note: `-D clippy::inconsistent-struct-constructor` implied by `-D warnings`
 
-error: inconsistent struct constructor
+error: struct constructor field order is inconsistent with struct definition field order
   --> $DIR/inconsistent_struct_constructor.rs:43:9
    |
 LL | /         Foo {
-- 
cgit 1.4.1-3-g733a5


From c86ba7f92d9627d2170827c07449542c7c0f7d77 Mon Sep 17 00:00:00 2001
From: Mateusz Gacek <96mateusz.gacek@gmail.com>
Date: Mon, 1 Mar 2021 16:49:52 +0100
Subject: mem_replace_with_default: recognize some std library ctors

---
 clippy_lints/src/mem_replace.rs | 17 ++++++++-
 clippy_utils/src/paths.rs       |  8 +++++
 tests/ui/mem_replace.fixed      | 29 +++++++++++++++
 tests/ui/mem_replace.rs         | 29 +++++++++++++++
 tests/ui/mem_replace.stderr     | 78 +++++++++++++++++++++++++++++++++++++----
 5 files changed, 154 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/mem_replace.rs b/clippy_lints/src/mem_replace.rs
index 19087b02077..2f71e22b4fc 100644
--- a/clippy_lints/src/mem_replace.rs
+++ b/clippy_lints/src/mem_replace.rs
@@ -200,7 +200,22 @@ fn check_replace_with_default(cx: &LateContext<'_>, src: &Expr<'_>, dest: &Expr<
             if !in_external_macro(cx.tcx.sess, expr_span);
             if let ExprKind::Path(ref repl_func_qpath) = repl_func.kind;
             if let Some(repl_def_id) = cx.qpath_res(repl_func_qpath, repl_func.hir_id).opt_def_id();
-            if match_def_path(cx, repl_def_id, &paths::DEFAULT_TRAIT_METHOD);
+
+            let defaults = &[
+                paths::DEFAULT_TRAIT_METHOD.as_ref(),
+                paths::STRING_NEW.as_ref(),
+                paths::VEC_NEW.as_ref(),
+                paths::VEC_DEQUE_NEW.as_ref(),
+                paths::LINKED_LIST_NEW.as_ref(),
+                paths::HASHMAP_NEW.as_ref(),
+                paths::BTREEMAP_NEW.as_ref(),
+                paths::HASHSET_NEW.as_ref(),
+                paths::BTREESET_NEW.as_ref(),
+                paths::BINARY_HEAP_NEW.as_ref(),
+            ];
+
+            if defaults.iter().any(|x| match_def_path(cx, repl_def_id, &x));
+
             then {
                 span_lint_and_then(
                     cx,
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index 560614efc74..8234ab7282c 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -11,10 +11,13 @@ pub const ASREF_TRAIT: [&str; 3] = ["core", "convert", "AsRef"];
 pub(super) const BEGIN_PANIC: [&str; 3] = ["std", "panicking", "begin_panic"];
 pub(super) const BEGIN_PANIC_FMT: [&str; 3] = ["std", "panicking", "begin_panic_fmt"];
 pub const BINARY_HEAP: [&str; 4] = ["alloc", "collections", "binary_heap", "BinaryHeap"];
+pub const BINARY_HEAP_NEW: [&str; 5] = ["alloc", "collections", "binary_heap", "BinaryHeap", "new"];
 pub const BORROW_TRAIT: [&str; 3] = ["core", "borrow", "Borrow"];
 pub const BTREEMAP: [&str; 5] = ["alloc", "collections", "btree", "map", "BTreeMap"];
+pub const BTREEMAP_NEW: [&str; 6] = ["alloc", "collections", "btree", "map", "BTreeMap", "new"];
 pub const BTREEMAP_ENTRY: [&str; 6] = ["alloc", "collections", "btree", "map", "entry", "Entry"];
 pub const BTREESET: [&str; 5] = ["alloc", "collections", "btree", "set", "BTreeSet"];
+pub const BTREESET_NEW: [&str; 6] = ["alloc", "collections", "btree", "set", "BTreeSet", "new"];
 pub const CLONE_TRAIT_METHOD: [&str; 4] = ["core", "clone", "Clone", "clone"];
 pub const CMP_MAX: [&str; 3] = ["core", "cmp", "max"];
 pub const CMP_MIN: [&str; 3] = ["core", "cmp", "min"];
@@ -46,8 +49,10 @@ pub const FROM_ITERATOR: [&str; 5] = ["core", "iter", "traits", "collect", "From
 pub const FUTURE_FROM_GENERATOR: [&str; 3] = ["core", "future", "from_generator"];
 pub const HASH: [&str; 3] = ["core", "hash", "Hash"];
 pub const HASHMAP: [&str; 5] = ["std", "collections", "hash", "map", "HashMap"];
+pub const HASHMAP_NEW: [&str; 6] = ["std", "collections", "hash", "map", "HashMap", "new"];
 pub const HASHMAP_ENTRY: [&str; 5] = ["std", "collections", "hash", "map", "Entry"];
 pub const HASHSET: [&str; 5] = ["std", "collections", "hash", "set", "HashSet"];
+pub const HASHSET_NEW: [&str; 6] = ["std", "collections", "hash", "set", "HashSet", "new"];
 #[cfg(feature = "internal-lints")]
 pub const IDENT: [&str; 3] = ["rustc_span", "symbol", "Ident"];
 #[cfg(feature = "internal-lints")]
@@ -67,6 +72,7 @@ pub const KW_MODULE: [&str; 3] = ["rustc_span", "symbol", "kw"];
 #[cfg(feature = "internal-lints")]
 pub const LATE_CONTEXT: [&str; 2] = ["rustc_lint", "LateContext"];
 pub const LINKED_LIST: [&str; 4] = ["alloc", "collections", "linked_list", "LinkedList"];
+pub const LINKED_LIST_NEW: [&str; 5] = ["alloc", "collections", "linked_list", "LinkedList", "new"];
 #[cfg(feature = "internal-lints")]
 pub const LINT: [&str; 2] = ["rustc_lint_defs", "Lint"];
 pub const MEM_DISCRIMINANT: [&str; 3] = ["core", "mem", "discriminant"];
@@ -134,6 +140,7 @@ pub const STD_CONVERT_IDENTITY: [&str; 3] = ["std", "convert", "identity"];
 pub const STD_FS_CREATE_DIR: [&str; 3] = ["std", "fs", "create_dir"];
 pub const STD_MEM_TRANSMUTE: [&str; 3] = ["std", "mem", "transmute"];
 pub const STD_PTR_NULL: [&str; 3] = ["std", "ptr", "null"];
+pub const STRING_NEW: [&str; 4] = ["alloc", "string", "String", "new"];
 pub const STRING_AS_MUT_STR: [&str; 4] = ["alloc", "string", "String", "as_mut_str"];
 pub const STRING_AS_STR: [&str; 4] = ["alloc", "string", "String", "as_str"];
 pub const STR_ENDS_WITH: [&str; 4] = ["core", "str", "<impl str>", "ends_with"];
@@ -161,6 +168,7 @@ pub const VEC: [&str; 3] = ["alloc", "vec", "Vec"];
 pub const VEC_AS_MUT_SLICE: [&str; 4] = ["alloc", "vec", "Vec", "as_mut_slice"];
 pub const VEC_AS_SLICE: [&str; 4] = ["alloc", "vec", "Vec", "as_slice"];
 pub const VEC_DEQUE: [&str; 4] = ["alloc", "collections", "vec_deque", "VecDeque"];
+pub const VEC_DEQUE_NEW: [&str; 5] = ["alloc", "collections", "vec_deque", "VecDeque", "new"];
 pub const VEC_FROM_ELEM: [&str; 3] = ["alloc", "vec", "from_elem"];
 pub const VEC_NEW: [&str; 4] = ["alloc", "vec", "Vec", "new"];
 pub const VEC_RESIZE: [&str; 4] = ["alloc", "vec", "Vec", "resize"];
diff --git a/tests/ui/mem_replace.fixed b/tests/ui/mem_replace.fixed
index 54e962e7116..3b6224254a0 100644
--- a/tests/ui/mem_replace.fixed
+++ b/tests/ui/mem_replace.fixed
@@ -7,6 +7,7 @@
     clippy::mem_replace_with_default
 )]
 
+use std::collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, LinkedList, VecDeque};
 use std::mem;
 
 fn replace_option_with_none() {
@@ -19,9 +20,37 @@ fn replace_option_with_none() {
 fn replace_with_default() {
     let mut s = String::from("foo");
     let _ = std::mem::take(&mut s);
+
     let s = &mut String::from("foo");
     let _ = std::mem::take(s);
     let _ = std::mem::take(s);
+
+    let mut v = vec![123];
+    let _ = std::mem::take(&mut v);
+    let _ = std::mem::take(&mut v);
+    let _ = std::mem::take(&mut v);
+    let _ = std::mem::take(&mut v);
+
+    let mut hash_map: HashMap<i32, i32> = HashMap::new();
+    let _ = std::mem::take(&mut hash_map);
+
+    let mut btree_map: BTreeMap<i32, i32> = BTreeMap::new();
+    let _ = std::mem::take(&mut btree_map);
+
+    let mut vd: VecDeque<i32> = VecDeque::new();
+    let _ = std::mem::take(&mut vd);
+
+    let mut hash_set: HashSet<&str> = HashSet::new();
+    let _ = std::mem::take(&mut hash_set);
+
+    let mut btree_set: BTreeSet<&str> = BTreeSet::new();
+    let _ = std::mem::take(&mut btree_set);
+
+    let mut list: LinkedList<i32> = LinkedList::new();
+    let _ = std::mem::take(&mut list);
+
+    let mut binary_heap: BinaryHeap<i32> = BinaryHeap::new();
+    let _ = std::mem::take(&mut binary_heap);
 }
 
 fn main() {
diff --git a/tests/ui/mem_replace.rs b/tests/ui/mem_replace.rs
index 60f52781071..0a36db9e921 100644
--- a/tests/ui/mem_replace.rs
+++ b/tests/ui/mem_replace.rs
@@ -7,6 +7,7 @@
     clippy::mem_replace_with_default
 )]
 
+use std::collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, LinkedList, VecDeque};
 use std::mem;
 
 fn replace_option_with_none() {
@@ -19,9 +20,37 @@ fn replace_option_with_none() {
 fn replace_with_default() {
     let mut s = String::from("foo");
     let _ = std::mem::replace(&mut s, String::default());
+
     let s = &mut String::from("foo");
     let _ = std::mem::replace(s, String::default());
     let _ = std::mem::replace(s, Default::default());
+
+    let mut v = vec![123];
+    let _ = std::mem::replace(&mut v, Vec::default());
+    let _ = std::mem::replace(&mut v, Default::default());
+    let _ = std::mem::replace(&mut v, Vec::new());
+    let _ = std::mem::replace(&mut v, vec![]);
+
+    let mut hash_map: HashMap<i32, i32> = HashMap::new();
+    let _ = std::mem::replace(&mut hash_map, HashMap::new());
+
+    let mut btree_map: BTreeMap<i32, i32> = BTreeMap::new();
+    let _ = std::mem::replace(&mut btree_map, BTreeMap::new());
+
+    let mut vd: VecDeque<i32> = VecDeque::new();
+    let _ = std::mem::replace(&mut vd, VecDeque::new());
+
+    let mut hash_set: HashSet<&str> = HashSet::new();
+    let _ = std::mem::replace(&mut hash_set, HashSet::new());
+
+    let mut btree_set: BTreeSet<&str> = BTreeSet::new();
+    let _ = std::mem::replace(&mut btree_set, BTreeSet::new());
+
+    let mut list: LinkedList<i32> = LinkedList::new();
+    let _ = std::mem::replace(&mut list, LinkedList::new());
+
+    let mut binary_heap: BinaryHeap<i32> = BinaryHeap::new();
+    let _ = std::mem::replace(&mut binary_heap, BinaryHeap::new());
 }
 
 fn main() {
diff --git a/tests/ui/mem_replace.stderr b/tests/ui/mem_replace.stderr
index 245d33aa4f2..f8aa1538bff 100644
--- a/tests/ui/mem_replace.stderr
+++ b/tests/ui/mem_replace.stderr
@@ -1,5 +1,5 @@
 error: replacing an `Option` with `None`
-  --> $DIR/mem_replace.rs:14:13
+  --> $DIR/mem_replace.rs:15:13
    |
 LL |     let _ = mem::replace(&mut an_option, None);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider `Option::take()` instead: `an_option.take()`
@@ -7,13 +7,13 @@ LL |     let _ = mem::replace(&mut an_option, None);
    = note: `-D clippy::mem-replace-option-with-none` implied by `-D warnings`
 
 error: replacing an `Option` with `None`
-  --> $DIR/mem_replace.rs:16:13
+  --> $DIR/mem_replace.rs:17:13
    |
 LL |     let _ = mem::replace(an_option, None);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider `Option::take()` instead: `an_option.take()`
 
 error: replacing a value of type `T` with `T::default()` is better expressed using `std::mem::take`
-  --> $DIR/mem_replace.rs:21:13
+  --> $DIR/mem_replace.rs:22:13
    |
 LL |     let _ = std::mem::replace(&mut s, String::default());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::mem::take(&mut s)`
@@ -21,16 +21,82 @@ LL |     let _ = std::mem::replace(&mut s, String::default());
    = note: `-D clippy::mem-replace-with-default` implied by `-D warnings`
 
 error: replacing a value of type `T` with `T::default()` is better expressed using `std::mem::take`
-  --> $DIR/mem_replace.rs:23:13
+  --> $DIR/mem_replace.rs:25:13
    |
 LL |     let _ = std::mem::replace(s, String::default());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::mem::take(s)`
 
 error: replacing a value of type `T` with `T::default()` is better expressed using `std::mem::take`
-  --> $DIR/mem_replace.rs:24:13
+  --> $DIR/mem_replace.rs:26:13
    |
 LL |     let _ = std::mem::replace(s, Default::default());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::mem::take(s)`
 
-error: aborting due to 5 previous errors
+error: replacing a value of type `T` with `T::default()` is better expressed using `std::mem::take`
+  --> $DIR/mem_replace.rs:29:13
+   |
+LL |     let _ = std::mem::replace(&mut v, Vec::default());
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::mem::take(&mut v)`
+
+error: replacing a value of type `T` with `T::default()` is better expressed using `std::mem::take`
+  --> $DIR/mem_replace.rs:30:13
+   |
+LL |     let _ = std::mem::replace(&mut v, Default::default());
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::mem::take(&mut v)`
+
+error: replacing a value of type `T` with `T::default()` is better expressed using `std::mem::take`
+  --> $DIR/mem_replace.rs:31:13
+   |
+LL |     let _ = std::mem::replace(&mut v, Vec::new());
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::mem::take(&mut v)`
+
+error: replacing a value of type `T` with `T::default()` is better expressed using `std::mem::take`
+  --> $DIR/mem_replace.rs:32:13
+   |
+LL |     let _ = std::mem::replace(&mut v, vec![]);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::mem::take(&mut v)`
+
+error: replacing a value of type `T` with `T::default()` is better expressed using `std::mem::take`
+  --> $DIR/mem_replace.rs:35:13
+   |
+LL |     let _ = std::mem::replace(&mut hash_map, HashMap::new());
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::mem::take(&mut hash_map)`
+
+error: replacing a value of type `T` with `T::default()` is better expressed using `std::mem::take`
+  --> $DIR/mem_replace.rs:38:13
+   |
+LL |     let _ = std::mem::replace(&mut btree_map, BTreeMap::new());
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::mem::take(&mut btree_map)`
+
+error: replacing a value of type `T` with `T::default()` is better expressed using `std::mem::take`
+  --> $DIR/mem_replace.rs:41:13
+   |
+LL |     let _ = std::mem::replace(&mut vd, VecDeque::new());
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::mem::take(&mut vd)`
+
+error: replacing a value of type `T` with `T::default()` is better expressed using `std::mem::take`
+  --> $DIR/mem_replace.rs:44:13
+   |
+LL |     let _ = std::mem::replace(&mut hash_set, HashSet::new());
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::mem::take(&mut hash_set)`
+
+error: replacing a value of type `T` with `T::default()` is better expressed using `std::mem::take`
+  --> $DIR/mem_replace.rs:47:13
+   |
+LL |     let _ = std::mem::replace(&mut btree_set, BTreeSet::new());
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::mem::take(&mut btree_set)`
+
+error: replacing a value of type `T` with `T::default()` is better expressed using `std::mem::take`
+  --> $DIR/mem_replace.rs:50:13
+   |
+LL |     let _ = std::mem::replace(&mut list, LinkedList::new());
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::mem::take(&mut list)`
+
+error: replacing a value of type `T` with `T::default()` is better expressed using `std::mem::take`
+  --> $DIR/mem_replace.rs:53:13
+   |
+LL |     let _ = std::mem::replace(&mut binary_heap, BinaryHeap::new());
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::mem::take(&mut binary_heap)`
+
+error: aborting due to 16 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 41be515062ff709d080cd8a8858f31778a775bcc Mon Sep 17 00:00:00 2001
From: Mateusz Gacek <96mateusz.gacek@gmail.com>
Date: Fri, 12 Mar 2021 12:00:08 -0800
Subject: mem_replace_with_default: use diagnostic items intead of paths

---
 clippy_lints/src/mem_replace.rs | 49 ++++++++++++++++++++++++++++-------------
 clippy_utils/src/lib.rs         |  2 +-
 clippy_utils/src/paths.rs       |  8 -------
 3 files changed, 35 insertions(+), 24 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/mem_replace.rs b/clippy_lints/src/mem_replace.rs
index 2f71e22b4fc..13f9c9b71f3 100644
--- a/clippy_lints/src/mem_replace.rs
+++ b/clippy_lints/src/mem_replace.rs
@@ -4,6 +4,7 @@ use crate::utils::{
 };
 use if_chain::if_chain;
 use rustc_errors::Applicability;
+use rustc_hir::def_id::DefId;
 use rustc_hir::{BorrowKind, Expr, ExprKind, Mutability, QPath};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
@@ -12,6 +13,8 @@ use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::Span;
 use rustc_span::symbol::sym;
 
+use clippy_utils::is_diagnostic_assoc_item;
+
 declare_clippy_lint! {
     /// **What it does:** Checks for `mem::replace()` on an `Option` with
     /// `None`.
@@ -194,27 +197,43 @@ fn check_replace_with_uninit(cx: &LateContext<'_>, src: &Expr<'_>, dest: &Expr<'
     }
 }
 
+/// Returns true if the `def_id` associated with the `path` is recognized as a "default-equivalent"
+/// constructor from the std library
+fn is_default_equivalent_ctor(cx: &LateContext<'_>, def_id: DefId, path: &QPath<'_>) -> bool {
+    let std_types_symbols = &[
+        sym::string_type,
+        sym::vec_type,
+        sym::vecdeque_type,
+        sym::LinkedList,
+        sym::hashmap_type,
+        sym::BTreeMap,
+        sym::hashset_type,
+        sym::BTreeSet,
+        sym::BinaryHeap,
+    ];
+
+    if std_types_symbols
+        .iter()
+        .any(|symbol| is_diagnostic_assoc_item(cx, def_id, *symbol))
+    {
+        if let QPath::TypeRelative(_, ref method) = path {
+            if method.ident.name == sym::new {
+                return true;
+            }
+        }
+    }
+
+    false
+}
+
 fn check_replace_with_default(cx: &LateContext<'_>, src: &Expr<'_>, dest: &Expr<'_>, expr_span: Span) {
     if let ExprKind::Call(ref repl_func, _) = src.kind {
         if_chain! {
             if !in_external_macro(cx.tcx.sess, expr_span);
             if let ExprKind::Path(ref repl_func_qpath) = repl_func.kind;
             if let Some(repl_def_id) = cx.qpath_res(repl_func_qpath, repl_func.hir_id).opt_def_id();
-
-            let defaults = &[
-                paths::DEFAULT_TRAIT_METHOD.as_ref(),
-                paths::STRING_NEW.as_ref(),
-                paths::VEC_NEW.as_ref(),
-                paths::VEC_DEQUE_NEW.as_ref(),
-                paths::LINKED_LIST_NEW.as_ref(),
-                paths::HASHMAP_NEW.as_ref(),
-                paths::BTREEMAP_NEW.as_ref(),
-                paths::HASHSET_NEW.as_ref(),
-                paths::BTREESET_NEW.as_ref(),
-                paths::BINARY_HEAP_NEW.as_ref(),
-            ];
-
-            if defaults.iter().any(|x| match_def_path(cx, repl_def_id, &x));
+            if is_diagnostic_assoc_item(cx, repl_def_id, sym::Default)
+                || is_default_equivalent_ctor(cx, repl_def_id, repl_func_qpath);
 
             then {
                 span_lint_and_then(
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index e17af49f618..045123ab71e 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -279,7 +279,7 @@ pub fn match_trait_method(cx: &LateContext<'_>, expr: &Expr<'_>, path: &[&str])
     trt_id.map_or(false, |trt_id| match_def_path(cx, trt_id, path))
 }
 
-/// Checks if the method call given in `expr` belongs to a trait or other container with a given
+/// Checks if the method call given in `def_id` belongs to a trait or other container with a given
 /// diagnostic item
 pub fn is_diagnostic_assoc_item(cx: &LateContext<'_>, def_id: DefId, diag_item: Symbol) -> bool {
     cx.tcx
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index 8234ab7282c..560614efc74 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -11,13 +11,10 @@ pub const ASREF_TRAIT: [&str; 3] = ["core", "convert", "AsRef"];
 pub(super) const BEGIN_PANIC: [&str; 3] = ["std", "panicking", "begin_panic"];
 pub(super) const BEGIN_PANIC_FMT: [&str; 3] = ["std", "panicking", "begin_panic_fmt"];
 pub const BINARY_HEAP: [&str; 4] = ["alloc", "collections", "binary_heap", "BinaryHeap"];
-pub const BINARY_HEAP_NEW: [&str; 5] = ["alloc", "collections", "binary_heap", "BinaryHeap", "new"];
 pub const BORROW_TRAIT: [&str; 3] = ["core", "borrow", "Borrow"];
 pub const BTREEMAP: [&str; 5] = ["alloc", "collections", "btree", "map", "BTreeMap"];
-pub const BTREEMAP_NEW: [&str; 6] = ["alloc", "collections", "btree", "map", "BTreeMap", "new"];
 pub const BTREEMAP_ENTRY: [&str; 6] = ["alloc", "collections", "btree", "map", "entry", "Entry"];
 pub const BTREESET: [&str; 5] = ["alloc", "collections", "btree", "set", "BTreeSet"];
-pub const BTREESET_NEW: [&str; 6] = ["alloc", "collections", "btree", "set", "BTreeSet", "new"];
 pub const CLONE_TRAIT_METHOD: [&str; 4] = ["core", "clone", "Clone", "clone"];
 pub const CMP_MAX: [&str; 3] = ["core", "cmp", "max"];
 pub const CMP_MIN: [&str; 3] = ["core", "cmp", "min"];
@@ -49,10 +46,8 @@ pub const FROM_ITERATOR: [&str; 5] = ["core", "iter", "traits", "collect", "From
 pub const FUTURE_FROM_GENERATOR: [&str; 3] = ["core", "future", "from_generator"];
 pub const HASH: [&str; 3] = ["core", "hash", "Hash"];
 pub const HASHMAP: [&str; 5] = ["std", "collections", "hash", "map", "HashMap"];
-pub const HASHMAP_NEW: [&str; 6] = ["std", "collections", "hash", "map", "HashMap", "new"];
 pub const HASHMAP_ENTRY: [&str; 5] = ["std", "collections", "hash", "map", "Entry"];
 pub const HASHSET: [&str; 5] = ["std", "collections", "hash", "set", "HashSet"];
-pub const HASHSET_NEW: [&str; 6] = ["std", "collections", "hash", "set", "HashSet", "new"];
 #[cfg(feature = "internal-lints")]
 pub const IDENT: [&str; 3] = ["rustc_span", "symbol", "Ident"];
 #[cfg(feature = "internal-lints")]
@@ -72,7 +67,6 @@ pub const KW_MODULE: [&str; 3] = ["rustc_span", "symbol", "kw"];
 #[cfg(feature = "internal-lints")]
 pub const LATE_CONTEXT: [&str; 2] = ["rustc_lint", "LateContext"];
 pub const LINKED_LIST: [&str; 4] = ["alloc", "collections", "linked_list", "LinkedList"];
-pub const LINKED_LIST_NEW: [&str; 5] = ["alloc", "collections", "linked_list", "LinkedList", "new"];
 #[cfg(feature = "internal-lints")]
 pub const LINT: [&str; 2] = ["rustc_lint_defs", "Lint"];
 pub const MEM_DISCRIMINANT: [&str; 3] = ["core", "mem", "discriminant"];
@@ -140,7 +134,6 @@ pub const STD_CONVERT_IDENTITY: [&str; 3] = ["std", "convert", "identity"];
 pub const STD_FS_CREATE_DIR: [&str; 3] = ["std", "fs", "create_dir"];
 pub const STD_MEM_TRANSMUTE: [&str; 3] = ["std", "mem", "transmute"];
 pub const STD_PTR_NULL: [&str; 3] = ["std", "ptr", "null"];
-pub const STRING_NEW: [&str; 4] = ["alloc", "string", "String", "new"];
 pub const STRING_AS_MUT_STR: [&str; 4] = ["alloc", "string", "String", "as_mut_str"];
 pub const STRING_AS_STR: [&str; 4] = ["alloc", "string", "String", "as_str"];
 pub const STR_ENDS_WITH: [&str; 4] = ["core", "str", "<impl str>", "ends_with"];
@@ -168,7 +161,6 @@ pub const VEC: [&str; 3] = ["alloc", "vec", "Vec"];
 pub const VEC_AS_MUT_SLICE: [&str; 4] = ["alloc", "vec", "Vec", "as_mut_slice"];
 pub const VEC_AS_SLICE: [&str; 4] = ["alloc", "vec", "Vec", "as_slice"];
 pub const VEC_DEQUE: [&str; 4] = ["alloc", "collections", "vec_deque", "VecDeque"];
-pub const VEC_DEQUE_NEW: [&str; 5] = ["alloc", "collections", "vec_deque", "VecDeque", "new"];
 pub const VEC_FROM_ELEM: [&str; 3] = ["alloc", "vec", "from_elem"];
 pub const VEC_NEW: [&str; 4] = ["alloc", "vec", "Vec", "new"];
 pub const VEC_RESIZE: [&str; 4] = ["alloc", "vec", "Vec", "resize"];
-- 
cgit 1.4.1-3-g733a5


From 6d2236f5036e89b69bdba4a364d73d159ac74187 Mon Sep 17 00:00:00 2001
From: iobtl <tedmundhtl@gmail.com>
Date: Sat, 13 Mar 2021 16:54:59 +0800
Subject: replace span_lint with span_lint_and_sugg along with error message

---
 clippy_lints/src/casts/unnecessary_cast.rs | 7 +++++--
 tests/ui/unnecessary_cast.stderr           | 6 +++---
 2 files changed, 8 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/unnecessary_cast.rs b/clippy_lints/src/casts/unnecessary_cast.rs
index fa2a07ef1da..171cac091c2 100644
--- a/clippy_lints/src/casts/unnecessary_cast.rs
+++ b/clippy_lints/src/casts/unnecessary_cast.rs
@@ -7,7 +7,7 @@ use rustc_middle::ty::{self, FloatTy, InferTy, Ty};
 
 use if_chain::if_chain;
 
-use crate::utils::{numeric_literal::NumericLiteral, snippet_opt, span_lint, span_lint_and_sugg};
+use crate::utils::{numeric_literal::NumericLiteral, snippet_opt, span_lint_and_sugg};
 
 use super::UNNECESSARY_CAST;
 
@@ -46,7 +46,7 @@ pub(super) fn check(
             LitKind::Int(_, LitIntType::Unsuffixed) | LitKind::Float(_, LitFloatType::Unsuffixed) => {},
             _ => {
                 if cast_from.kind() == cast_to.kind() && !in_external_macro(cx.sess(), expr.span) {
-                    span_lint(
+                    span_lint_and_sugg(
                         cx,
                         UNNECESSARY_CAST,
                         expr.span,
@@ -54,6 +54,9 @@ pub(super) fn check(
                             "casting to the same type is unnecessary (`{}` -> `{}`)",
                             cast_from, cast_to
                         ),
+                        "try",
+                        literal_str,
+                        Applicability::MachineApplicable,
                     );
                     return true;
                 }
diff --git a/tests/ui/unnecessary_cast.stderr b/tests/ui/unnecessary_cast.stderr
index 8981d13e8ea..87261cd8333 100644
--- a/tests/ui/unnecessary_cast.stderr
+++ b/tests/ui/unnecessary_cast.stderr
@@ -2,7 +2,7 @@ error: casting to the same type is unnecessary (`i32` -> `i32`)
   --> $DIR/unnecessary_cast.rs:6:5
    |
 LL |     1i32 as i32;
-   |     ^^^^^^^^^^^
+   |     ^^^^^^^^^^^ help: try: `1i32`
    |
    = note: `-D clippy::unnecessary-cast` implied by `-D warnings`
 
@@ -10,13 +10,13 @@ error: casting to the same type is unnecessary (`f32` -> `f32`)
   --> $DIR/unnecessary_cast.rs:7:5
    |
 LL |     1f32 as f32;
-   |     ^^^^^^^^^^^
+   |     ^^^^^^^^^^^ help: try: `1f32`
 
 error: casting to the same type is unnecessary (`bool` -> `bool`)
   --> $DIR/unnecessary_cast.rs:8:5
    |
 LL |     false as bool;
-   |     ^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^ help: try: `false`
 
 error: aborting due to 3 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From a261bc5fadc3c72fd8828d64c4281097b2e7c0b0 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Tue, 2 Mar 2021 13:32:56 -0500
Subject: Make `explicit_deref_methods` check for multiple deref calls Fix
 suggestion for `explicit_deref_methods`. Sometimes `&**` is needed, sometimes
 nothing is needed. Allow `explicit_deref_methods` to trigger in a few new
 contexts. `explicit_deref_methods` will now consider ufcs calls

---
 clippy_lints/src/dereference.rs        | 369 +++++++++++++++++++++++++++------
 clippy_lints/src/lib.rs                |   2 +-
 clippy_lints/src/manual_map.rs         |   8 +-
 clippy_lints/src/redundant_deref.rs    |  63 ++++++
 clippy_utils/src/lib.rs                |  82 ++++++--
 tests/ui/dereference.fixed             |  93 ---------
 tests/ui/dereference.rs                |  93 ---------
 tests/ui/dereference.stderr            |  70 -------
 tests/ui/explicit_deref_methods.fixed  |  93 +++++++++
 tests/ui/explicit_deref_methods.rs     |  93 +++++++++
 tests/ui/explicit_deref_methods.stderr |  70 +++++++
 11 files changed, 687 insertions(+), 349 deletions(-)
 create mode 100644 clippy_lints/src/redundant_deref.rs
 delete mode 100644 tests/ui/dereference.fixed
 delete mode 100644 tests/ui/dereference.rs
 delete mode 100644 tests/ui/dereference.stderr
 create mode 100644 tests/ui/explicit_deref_methods.fixed
 create mode 100644 tests/ui/explicit_deref_methods.rs
 create mode 100644 tests/ui/explicit_deref_methods.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index b5fb51af1c7..a33634ca34e 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -1,11 +1,13 @@
-use crate::utils::{get_parent_expr, implements_trait, snippet, span_lint_and_sugg};
-use if_chain::if_chain;
-use rustc_ast::util::parser::{ExprPrecedence, PREC_POSTFIX, PREC_PREFIX};
+use crate::utils::{
+    get_node_span, get_parent_node, in_macro, is_allowed, peel_mid_ty_refs, snippet_with_context, span_lint_and_sugg,
+};
+use rustc_ast::util::parser::PREC_PREFIX;
 use rustc_errors::Applicability;
-use rustc_hir::{Expr, ExprKind};
+use rustc_hir::{BorrowKind, Destination, Expr, ExprKind, HirId, MatchSource, Mutability, Node, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::source_map::Span;
+use rustc_middle::ty::{self, adjustment::Adjustment, Ty, TyCtxt, TyS, TypeckResults};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::{symbol::sym, Span};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for explicit `deref()` or `deref_mut()` method calls.
@@ -34,76 +36,313 @@ declare_clippy_lint! {
     "Explicit use of deref or deref_mut method while not in a method chain."
 }
 
-declare_lint_pass!(Dereferencing => [
-    EXPLICIT_DEREF_METHODS
+impl_lint_pass!(Dereferencing => [
+    EXPLICIT_DEREF_METHODS,
 ]);
 
+#[derive(Default)]
+pub struct Dereferencing {
+    state: Option<(State, StateData)>,
+
+    // While parsing a `deref` method call in ufcs form, the path to the function is itself an
+    // expression. This is to store the id of that expression so it can be skipped when
+    // `check_expr` is called for it.
+    skip_expr: Option<HirId>,
+}
+
+struct StateData {
+    /// Span of the top level expression
+    span: Span,
+    /// The required mutability
+    target_mut: Mutability,
+}
+
+enum State {
+    // Any number of deref method calls.
+    DerefMethod {
+        // The number of calls in a sequence which changed the referenced type
+        ty_changed_count: usize,
+        is_final_ufcs: bool,
+    },
+}
+
+// A reference operation considered by this lint pass
+enum RefOp {
+    Method,
+    Deref,
+    AddrOf,
+}
+
 impl<'tcx> LateLintPass<'tcx> for Dereferencing {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if_chain! {
-            if !expr.span.from_expansion();
-            if let ExprKind::MethodCall(ref method_name, _, ref args, _) = &expr.kind;
-            if args.len() == 1;
-
-            then {
-                if let Some(parent_expr) = get_parent_expr(cx, expr) {
-                    // Check if we have the whole call chain here
-                    if let ExprKind::MethodCall(..) = parent_expr.kind {
-                        return;
-                    }
-                    // Check for Expr that we don't want to be linted
-                    let precedence = parent_expr.precedence();
-                    match precedence {
-                        // Lint a Call is ok though
-                        ExprPrecedence::Call | ExprPrecedence::AddrOf => (),
-                        _ => {
-                            if precedence.order() >= PREC_PREFIX && precedence.order() <= PREC_POSTFIX {
-                                return;
-                            }
-                        }
+        // Skip path expressions from deref calls. e.g. `Deref::deref(e)`
+        if Some(expr.hir_id) == self.skip_expr.take() {
+            return;
+        }
+
+        // Stop processing sub expressions when a macro call is seen
+        if in_macro(expr.span) {
+            if let Some((state, data)) = self.state.take() {
+                report(cx, expr, state, data);
+            }
+            return;
+        }
+
+        let typeck = cx.typeck_results();
+        let (kind, sub_expr) = if let Some(x) = try_parse_ref_op(cx.tcx, typeck, expr) {
+            x
+        } else {
+            // The whole chain of reference operations has been seen
+            if let Some((state, data)) = self.state.take() {
+                report(cx, expr, state, data);
+            }
+            return;
+        };
+
+        match (self.state.take(), kind) {
+            (None, kind) => {
+                let parent = get_parent_node(cx.tcx, expr.hir_id);
+                // This is an odd case. The expression is a macro argument, but the top level
+                // address of expression is inserted by the compiler.
+                if matches!(kind, RefOp::AddrOf) && parent.and_then(get_node_span).map_or(false, in_macro) {
+                    return;
+                }
+
+                let expr_adjustments = find_adjustments(cx.tcx, typeck, expr);
+                let expr_ty = typeck.expr_ty(expr);
+                let target_mut =
+                    if let ty::Ref(_, _, mutability) = *expr_adjustments.last().map_or(expr_ty, |a| a.target).kind() {
+                        mutability
+                    } else {
+                        Mutability::Not
+                    };
+
+                match kind {
+                    RefOp::Method
+                        if !is_allowed(cx, EXPLICIT_DEREF_METHODS, expr.hir_id)
+                            && is_linted_explicit_deref_position(parent, expr.hir_id) =>
+                    {
+                        self.state = Some((
+                            State::DerefMethod {
+                                ty_changed_count: if deref_method_same_type(expr_ty, typeck.expr_ty(sub_expr)) {
+                                    0
+                                } else {
+                                    1
+                                },
+                                is_final_ufcs: matches!(expr.kind, ExprKind::Call(..)),
+                            },
+                            StateData {
+                                span: expr.span,
+                                target_mut,
+                            },
+                        ));
                     }
+                    _ => (),
                 }
-                let name = method_name.ident.as_str();
-                lint_deref(cx, &*name, &args[0], args[0].span, expr.span);
-            }
+            },
+            (Some((State::DerefMethod { ty_changed_count, .. }, data)), RefOp::Method) => {
+                self.state = Some((
+                    State::DerefMethod {
+                        ty_changed_count: if deref_method_same_type(typeck.expr_ty(expr), typeck.expr_ty(sub_expr)) {
+                            ty_changed_count
+                        } else {
+                            ty_changed_count + 1
+                        },
+                        is_final_ufcs: matches!(expr.kind, ExprKind::Call(..)),
+                    },
+                    data,
+                ));
+            },
+
+            (Some((state, data)), _) => report(cx, expr, state, data),
         }
     }
 }
 
-fn lint_deref(cx: &LateContext<'_>, method_name: &str, call_expr: &Expr<'_>, var_span: Span, expr_span: Span) {
-    match method_name {
-        "deref" => {
-            let impls_deref_trait = cx.tcx.lang_items().deref_trait().map_or(false, |id| {
-                implements_trait(cx, cx.typeck_results().expr_ty(&call_expr), id, &[])
-            });
-            if impls_deref_trait {
-                span_lint_and_sugg(
-                    cx,
-                    EXPLICIT_DEREF_METHODS,
-                    expr_span,
-                    "explicit deref method call",
-                    "try this",
-                    format!("&*{}", &snippet(cx, var_span, "..")),
-                    Applicability::MachineApplicable,
-                );
-            }
+fn try_parse_ref_op(
+    tcx: TyCtxt<'tcx>,
+    typeck: &'tcx TypeckResults<'_>,
+    expr: &'tcx Expr<'_>,
+) -> Option<(RefOp, &'tcx Expr<'tcx>)> {
+    let (def_id, arg) = match expr.kind {
+        ExprKind::MethodCall(_, _, [arg], _) => (typeck.type_dependent_def_id(expr.hir_id)?, arg),
+        ExprKind::Call(
+            Expr {
+                kind: ExprKind::Path(path),
+                hir_id,
+                ..
+            },
+            [arg],
+        ) => (typeck.qpath_res(path, *hir_id).opt_def_id()?, arg),
+        ExprKind::Unary(UnOp::Deref, sub_expr) if !typeck.expr_ty(sub_expr).is_unsafe_ptr() => {
+            return Some((RefOp::Deref, sub_expr));
         },
-        "deref_mut" => {
-            let impls_deref_mut_trait = cx.tcx.lang_items().deref_mut_trait().map_or(false, |id| {
-                implements_trait(cx, cx.typeck_results().expr_ty(&call_expr), id, &[])
-            });
-            if impls_deref_mut_trait {
-                span_lint_and_sugg(
-                    cx,
-                    EXPLICIT_DEREF_METHODS,
-                    expr_span,
-                    "explicit deref_mut method call",
-                    "try this",
-                    format!("&mut *{}", &snippet(cx, var_span, "..")),
-                    Applicability::MachineApplicable,
-                );
-            }
+        ExprKind::AddrOf(BorrowKind::Ref, _, sub_expr) => return Some((RefOp::AddrOf, sub_expr)),
+        _ => return None,
+    };
+    (tcx.is_diagnostic_item(sym::deref_method, def_id)
+        || tcx.trait_of_item(def_id)? == tcx.lang_items().deref_mut_trait()?)
+    .then(|| (RefOp::Method, arg))
+}
+
+// Checks whether the type for a deref call actually changed the type, not just the mutability of
+// the reference.
+fn deref_method_same_type(result_ty: Ty<'tcx>, arg_ty: Ty<'tcx>) -> bool {
+    match (result_ty.kind(), arg_ty.kind()) {
+        (ty::Ref(_, result_ty, _), ty::Ref(_, arg_ty, _)) => TyS::same_type(result_ty, arg_ty),
+
+        // The result type for a deref method is always a reference
+        // Not matching the previous pattern means the argument type is not a reference
+        // This means that the type did change
+        _ => false,
+    }
+}
+
+// Adjustments are sometimes made in the parent block rather than the expression itself.
+fn find_adjustments(
+    tcx: TyCtxt<'tcx>,
+    typeck: &'tcx TypeckResults<'_>,
+    expr: &'tcx Expr<'_>,
+) -> &'tcx [Adjustment<'tcx>] {
+    let map = tcx.hir();
+    let mut iter = map.parent_iter(expr.hir_id);
+    let mut prev = expr;
+
+    loop {
+        match typeck.expr_adjustments(prev) {
+            [] => (),
+            a => break a,
+        };
+
+        match iter.next().map(|(_, x)| x) {
+            Some(Node::Block(_)) => {
+                if let Some((_, Node::Expr(e))) = iter.next() {
+                    prev = e;
+                } else {
+                    // This shouldn't happen. Blocks are always contained in an expression.
+                    break &[];
+                }
+            },
+            Some(Node::Expr(&Expr {
+                kind: ExprKind::Break(Destination { target_id: Ok(id), .. }, _),
+                ..
+            })) => {
+                if let Some(Node::Expr(e)) = map.find(id) {
+                    prev = e;
+                    iter = map.parent_iter(id);
+                    continue;
+                }
+                // This shouldn't happen. The destination should definitely exist at this point.
+                break &[];
+            },
+            _ => break &[],
+        }
+    }
+}
+
+// Checks whether the parent node is a suitable context for switching from a deref method to the
+// deref operator.
+fn is_linted_explicit_deref_position(parent: Option<Node<'_>>, child_id: HirId) -> bool {
+    let parent = match parent {
+        Some(Node::Expr(e)) => e,
+        _ => return true,
+    };
+    match parent.kind {
+        // Leave deref calls in the middle of a method chain.
+        // e.g. x.deref().foo()
+        ExprKind::MethodCall(_, _, [self_arg, ..], _) if self_arg.hir_id == child_id => false,
+
+        // Leave deref calls resulting in a called function
+        // e.g. (x.deref())()
+        ExprKind::Call(func_expr, _) if func_expr.hir_id == child_id => false,
+
+        // Makes an ugly suggestion
+        // e.g. *x.deref() => *&*x
+        ExprKind::Unary(UnOp::Deref, _)
+        // Postfix expressions would require parens
+        | ExprKind::Match(_, _, MatchSource::TryDesugar | MatchSource::AwaitDesugar)
+        | ExprKind::Field(..)
+        | ExprKind::Index(..)
+        | ExprKind::Err => false,
+
+        ExprKind::Box(..)
+        | ExprKind::ConstBlock(..)
+        | ExprKind::Array(_)
+        | ExprKind::Call(..)
+        | ExprKind::MethodCall(..)
+        | ExprKind::Tup(..)
+        | ExprKind::Binary(..)
+        | ExprKind::Unary(..)
+        | ExprKind::Lit(..)
+        | ExprKind::Cast(..)
+        | ExprKind::Type(..)
+        | ExprKind::DropTemps(..)
+        | ExprKind::If(..)
+        | ExprKind::Loop(..)
+        | ExprKind::Match(..)
+        | ExprKind::Closure(..)
+        | ExprKind::Block(..)
+        | ExprKind::Assign(..)
+        | ExprKind::AssignOp(..)
+        | ExprKind::Path(..)
+        | ExprKind::AddrOf(..)
+        | ExprKind::Break(..)
+        | ExprKind::Continue(..)
+        | ExprKind::Ret(..)
+        | ExprKind::InlineAsm(..)
+        | ExprKind::LlvmInlineAsm(..)
+        | ExprKind::Struct(..)
+        | ExprKind::Repeat(..)
+        | ExprKind::Yield(..) => true,
+    }
+}
+
+#[allow(clippy::needless_pass_by_value)]
+fn report(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, state: State, data: StateData) {
+    match state {
+        State::DerefMethod {
+            ty_changed_count,
+            is_final_ufcs,
+        } => {
+            let mut app = Applicability::MachineApplicable;
+            let (expr_str, expr_is_macro_call) = snippet_with_context(cx, expr.span, data.span.ctxt(), "..", &mut app);
+            let ty = cx.typeck_results().expr_ty(expr);
+            let (_, ref_count) = peel_mid_ty_refs(ty);
+            let deref_str = if ty_changed_count >= ref_count && ref_count != 0 {
+                // a deref call changing &T -> &U requires two deref operators the first time
+                // this occurs. One to remove the reference, a second to call the deref impl.
+                "*".repeat(ty_changed_count + 1)
+            } else {
+                "*".repeat(ty_changed_count)
+            };
+            let addr_of_str = if ty_changed_count < ref_count {
+                // Check if a reborrow from &mut T -> &T is required.
+                if data.target_mut == Mutability::Not && matches!(ty.kind(), ty::Ref(_, _, Mutability::Mut)) {
+                    "&*"
+                } else {
+                    ""
+                }
+            } else if data.target_mut == Mutability::Mut {
+                "&mut "
+            } else {
+                "&"
+            };
+
+            let expr_str = if !expr_is_macro_call && is_final_ufcs && expr.precedence().order() < PREC_PREFIX {
+                format!("({})", expr_str)
+            } else {
+                expr_str.into_owned()
+            };
+
+            span_lint_and_sugg(
+                cx,
+                EXPLICIT_DEREF_METHODS,
+                data.span,
+                "explicit `deref` method call",
+                "try this",
+                format!("{}{}{}", addr_of_str, deref_str, expr_str),
+                app,
+            );
         },
-        _ => (),
     }
 }
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 04e151df8e8..bf5688aa95c 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1241,7 +1241,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box verbose_file_reads::VerboseFileReads);
     store.register_late_pass(|| box redundant_pub_crate::RedundantPubCrate::default());
     store.register_late_pass(|| box unnamed_address::UnnamedAddress);
-    store.register_late_pass(|| box dereference::Dereferencing);
+    store.register_late_pass(|| box dereference::Dereferencing::default());
     store.register_late_pass(|| box option_if_let_else::OptionIfLetElse);
     store.register_late_pass(|| box future_not_send::FutureNotSend);
     store.register_late_pass(|| box if_let_mutex::IfLetMutex);
diff --git a/clippy_lints/src/manual_map.rs b/clippy_lints/src/manual_map.rs
index ac1d51e1993..ea4cedc6754 100644
--- a/clippy_lints/src/manual_map.rs
+++ b/clippy_lints/src/manual_map.rs
@@ -129,7 +129,7 @@ impl LateLintPass<'_> for ManualMap {
             // Remove address-of expressions from the scrutinee. Either `as_ref` will be called, or
             // it's being passed by value.
             let scrutinee = peel_hir_expr_refs(scrutinee).0;
-            let scrutinee_str = snippet_with_context(cx, scrutinee.span, expr_ctxt, "..", &mut app);
+            let (scrutinee_str, _) = snippet_with_context(cx, scrutinee.span, expr_ctxt, "..", &mut app);
             let scrutinee_str =
                 if scrutinee.span.ctxt() == expr.span.ctxt() && scrutinee.precedence().order() < PREC_POSTFIX {
                     format!("({})", scrutinee_str)
@@ -160,7 +160,7 @@ impl LateLintPass<'_> for ManualMap {
                             "|{}{}| {}",
                             annotation,
                             some_binding,
-                            snippet_with_context(cx, some_expr.span, expr_ctxt, "..", &mut app)
+                            snippet_with_context(cx, some_expr.span, expr_ctxt, "..", &mut app).0
                         )
                     },
                 }
@@ -168,8 +168,8 @@ impl LateLintPass<'_> for ManualMap {
                 // TODO: handle explicit reference annotations.
                 format!(
                     "|{}| {}",
-                    snippet_with_context(cx, some_pat.span, expr_ctxt, "..", &mut app),
-                    snippet_with_context(cx, some_expr.span, expr_ctxt, "..", &mut app)
+                    snippet_with_context(cx, some_pat.span, expr_ctxt, "..", &mut app).0,
+                    snippet_with_context(cx, some_expr.span, expr_ctxt, "..", &mut app).0
                 )
             } else {
                 // Refutable bindings and mixed reference annotations can't be handled by `map`.
diff --git a/clippy_lints/src/redundant_deref.rs b/clippy_lints/src/redundant_deref.rs
new file mode 100644
index 00000000000..029583720d2
--- /dev/null
+++ b/clippy_lints/src/redundant_deref.rs
@@ -0,0 +1,63 @@
+// use crate::utils::{get_parent_expr, snippet_with_applicability, span_lint_and_sugg};
+// use if_chain::if_chain;
+// use rustc_errors::Applicability;
+// use rustc_hir::{Expr, ExprKind, UnOp};
+// use rustc_lint::{LateContext, LateLintPass, LintContext};
+// use rustc_middle::lint::in_external_macro;
+// use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+// declare_clippy_lint! {
+//     /// **What it does:** Checks for uses of the dereference operator which would be covered by
+//     /// auto-dereferencing.
+//     ///
+//     /// **Why is this bad?** This unnecessarily complicates the code.
+//     ///
+//     /// **Known problems:** None.
+//     ///
+//     /// **Example:**
+//     ///
+//     /// ```rust
+//     /// fn foo(_: &str) {}
+//     /// foo(&*String::new())
+//     /// ```
+//     /// Use instead:
+//     /// ```rust
+//     /// fn foo(_: &str) {}
+//     /// foo(&String::new())
+//     /// ```
+//     pub REDUNDANT_DEREF,
+//     style,
+//     "default lint description"
+// }
+
+// declare_lint_pass!(RedundantDeref => [REDUNDANT_DEREF]);
+
+// impl LateLintPass<'_> for RedundantDeref {
+//     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+//         if_chain! {
+//             if let ExprKind::AddrOf(_, _, addr_expr) = expr.kind;
+//             if let ExprKind::Unary(UnOp::UnDeref, deref_expr) = addr_expr.kind;
+//             if !in_external_macro(cx.sess(), expr.span);
+//             if let Some(parent_expr) = get_parent_expr(cx, expr);
+//             if match parent_expr.kind {
+//                 ExprKind::Call(func, _) => func.hir_id != expr.hir_id,
+//                 ExprKind::MethodCall(..) => true,
+//                 _ => false,
+//             };
+//             if !cx.typeck_results().expr_ty(deref_expr).is_unsafe_ptr();
+//             then {
+//                 let mut app = Applicability::MachineApplicable;
+//                 let sugg = format!("&{}", snippet_with_applicability(cx, deref_expr.span, "_", &mut app));
+//                 span_lint_and_sugg(
+//                     cx,
+//                     REDUNDANT_DEREF,
+//                     expr.span,
+//                     "redundant dereference",
+//                     "remove the dereference",
+//                     sugg,
+//                     app,
+//                 );
+//             }
+//         }
+//     }
+// }
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 3dad21d2028..2ac2298ff74 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -61,11 +61,11 @@ use rustc_hir as hir;
 use rustc_hir::def::{CtorKind, CtorOf, DefKind, Res};
 use rustc_hir::def_id::{DefId, LOCAL_CRATE};
 use rustc_hir::intravisit::{self, NestedVisitorMap, Visitor};
-use rustc_hir::Node;
 use rustc_hir::{
-    def, Arm, Block, Body, Constness, Expr, ExprKind, FnDecl, GenericArgs, HirId, Impl, ImplItem, ImplItemKind, Item,
-    ItemKind, LangItem, MatchSource, Param, Pat, PatKind, Path, PathSegment, QPath, TraitItem, TraitItemKind, TraitRef,
-    TyKind, Unsafety,
+    def, Arm, Block, Body, Constness, CrateItem, Expr, ExprKind, FnDecl, ForeignItem, GenericArgs, GenericParam, HirId,
+    Impl, ImplItem, ImplItemKind, Item, ItemKind, LangItem, Lifetime, Local, MacroDef, MatchSource, Node, Param, Pat,
+    PatKind, Path, PathSegment, QPath, Stmt, StructField, TraitItem, TraitItemKind, TraitRef, TyKind, Unsafety,
+    Variant, Visibility,
 };
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::{LateContext, Level, Lint, LintContext};
@@ -78,7 +78,7 @@ use rustc_session::Session;
 use rustc_span::hygiene::{self, ExpnKind, MacroKind};
 use rustc_span::source_map::original_sp;
 use rustc_span::sym;
-use rustc_span::symbol::{kw, Symbol};
+use rustc_span::symbol::{kw, Ident, Symbol};
 use rustc_span::{BytePos, Pos, Span, SyntaxContext, DUMMY_SP};
 use rustc_target::abi::Integer;
 use rustc_trait_selection::traits::query::normalize::AtExt;
@@ -852,26 +852,31 @@ pub fn snippet_block_with_applicability<'a, T: LintContext>(
 /// e.g. Given the expression `&vec![]`, getting a snippet from the span for `vec![]` as a HIR node
 /// would result in `box []`. If given the context of the address of expression, this function will
 /// correctly get a snippet of `vec![]`.
+///
+/// This will also return whether or not the snippet is a macro call.
 pub fn snippet_with_context(
     cx: &LateContext<'_>,
     span: Span,
     outer: SyntaxContext,
     default: &'a str,
     applicability: &mut Applicability,
-) -> Cow<'a, str> {
+) -> (Cow<'a, str>, bool) {
     let outer_span = hygiene::walk_chain(span, outer);
-    let span = if outer_span.ctxt() == outer {
-        outer_span
+    let (span, is_macro_call) = if outer_span.ctxt() == outer {
+        (outer_span, span.ctxt() != outer)
     } else {
         // The span is from a macro argument, and the outer context is the macro using the argument
         if *applicability != Applicability::Unspecified {
             *applicability = Applicability::MaybeIncorrect;
         }
         // TODO: get the argument span.
-        span
+        (span, false)
     };
 
-    snippet_with_applicability(cx, span, default, applicability)
+    (
+        snippet_with_applicability(cx, span, default, applicability),
+        is_macro_call,
+    )
 }
 
 /// Returns a new Span that extends the original Span to the first non-whitespace char of the first
@@ -1013,21 +1018,52 @@ fn reindent_multiline_inner(s: &str, ignore_first: bool, indent: Option<usize>,
         .join("\n")
 }
 
+/// Gets the span of the node, if there is one.
+pub fn get_node_span(node: Node<'_>) -> Option<Span> {
+    match node {
+        Node::Param(Param { span, .. })
+        | Node::Item(Item { span, .. })
+        | Node::ForeignItem(ForeignItem { span, .. })
+        | Node::TraitItem(TraitItem { span, .. })
+        | Node::ImplItem(ImplItem { span, .. })
+        | Node::Variant(Variant { span, .. })
+        | Node::Field(StructField { span, .. })
+        | Node::Expr(Expr { span, .. })
+        | Node::Stmt(Stmt { span, .. })
+        | Node::PathSegment(PathSegment {
+            ident: Ident { span, .. },
+            ..
+        })
+        | Node::Ty(hir::Ty { span, .. })
+        | Node::TraitRef(TraitRef {
+            path: Path { span, .. },
+            ..
+        })
+        | Node::Binding(Pat { span, .. })
+        | Node::Pat(Pat { span, .. })
+        | Node::Arm(Arm { span, .. })
+        | Node::Block(Block { span, .. })
+        | Node::Local(Local { span, .. })
+        | Node::MacroDef(MacroDef { span, .. })
+        | Node::Lifetime(Lifetime { span, .. })
+        | Node::GenericParam(GenericParam { span, .. })
+        | Node::Visibility(Visibility { span, .. })
+        | Node::Crate(CrateItem { span, .. }) => Some(*span),
+        Node::Ctor(_) | Node::AnonConst(_) => None,
+    }
+}
+
+/// Gets the parent node, if any.
+pub fn get_parent_node(tcx: TyCtxt<'_>, id: HirId) -> Option<Node<'_>> {
+    tcx.hir().parent_iter(id).next().map(|(_, node)| node)
+}
+
 /// Gets the parent expression, if any –- this is useful to constrain a lint.
 pub fn get_parent_expr<'tcx>(cx: &LateContext<'tcx>, e: &Expr<'_>) -> Option<&'tcx Expr<'tcx>> {
-    let map = &cx.tcx.hir();
-    let hir_id = e.hir_id;
-    let parent_id = map.get_parent_node(hir_id);
-    if hir_id == parent_id {
-        return None;
-    }
-    map.find(parent_id).and_then(|node| {
-        if let Node::Expr(parent) = node {
-            Some(parent)
-        } else {
-            None
-        }
-    })
+    match get_parent_node(cx.tcx, e.hir_id) {
+        Some(Node::Expr(parent)) => Some(parent),
+        _ => None,
+    }
 }
 
 pub fn get_enclosing_block<'tcx>(cx: &LateContext<'tcx>, hir_id: HirId) -> Option<&'tcx Block<'tcx>> {
diff --git a/tests/ui/dereference.fixed b/tests/ui/dereference.fixed
deleted file mode 100644
index 459ca91b93b..00000000000
--- a/tests/ui/dereference.fixed
+++ /dev/null
@@ -1,93 +0,0 @@
-// run-rustfix
-
-#![allow(unused_variables, clippy::many_single_char_names, clippy::clone_double_ref)]
-#![warn(clippy::explicit_deref_methods)]
-
-use std::ops::{Deref, DerefMut};
-
-fn concat(deref_str: &str) -> String {
-    format!("{}bar", deref_str)
-}
-
-fn just_return(deref_str: &str) -> &str {
-    deref_str
-}
-
-struct CustomVec(Vec<u8>);
-impl Deref for CustomVec {
-    type Target = Vec<u8>;
-
-    fn deref(&self) -> &Vec<u8> {
-        &self.0
-    }
-}
-
-fn main() {
-    let a: &mut String = &mut String::from("foo");
-
-    // these should require linting
-
-    let b: &str = &*a;
-
-    let b: &mut str = &mut *a;
-
-    // both derefs should get linted here
-    let b: String = format!("{}, {}", &*a, &*a);
-
-    println!("{}", &*a);
-
-    #[allow(clippy::match_single_binding)]
-    match &*a {
-        _ => (),
-    }
-
-    let b: String = concat(&*a);
-
-    let b = &*just_return(a);
-
-    let b: String = concat(&*just_return(a));
-
-    let b: &str = &*a.deref();
-
-    let opt_a = Some(a.clone());
-    let b = &*opt_a.unwrap();
-
-    // following should not require linting
-
-    let cv = CustomVec(vec![0, 42]);
-    let c = cv.deref()[0];
-
-    let b: &str = &*a.deref();
-
-    let b: String = a.deref().clone();
-
-    let b: usize = a.deref_mut().len();
-
-    let b: &usize = &a.deref().len();
-
-    let b: &str = &*a;
-
-    let b: &mut str = &mut *a;
-
-    macro_rules! expr_deref {
-        ($body:expr) => {
-            $body.deref()
-        };
-    }
-    let b: &str = expr_deref!(a);
-
-    // The struct does not implement Deref trait
-    #[derive(Copy, Clone)]
-    struct NoLint(u32);
-    impl NoLint {
-        pub fn deref(self) -> u32 {
-            self.0
-        }
-        pub fn deref_mut(self) -> u32 {
-            self.0
-        }
-    }
-    let no_lint = NoLint(42);
-    let b = no_lint.deref();
-    let b = no_lint.deref_mut();
-}
diff --git a/tests/ui/dereference.rs b/tests/ui/dereference.rs
deleted file mode 100644
index 8dc5272e67f..00000000000
--- a/tests/ui/dereference.rs
+++ /dev/null
@@ -1,93 +0,0 @@
-// run-rustfix
-
-#![allow(unused_variables, clippy::many_single_char_names, clippy::clone_double_ref)]
-#![warn(clippy::explicit_deref_methods)]
-
-use std::ops::{Deref, DerefMut};
-
-fn concat(deref_str: &str) -> String {
-    format!("{}bar", deref_str)
-}
-
-fn just_return(deref_str: &str) -> &str {
-    deref_str
-}
-
-struct CustomVec(Vec<u8>);
-impl Deref for CustomVec {
-    type Target = Vec<u8>;
-
-    fn deref(&self) -> &Vec<u8> {
-        &self.0
-    }
-}
-
-fn main() {
-    let a: &mut String = &mut String::from("foo");
-
-    // these should require linting
-
-    let b: &str = a.deref();
-
-    let b: &mut str = a.deref_mut();
-
-    // both derefs should get linted here
-    let b: String = format!("{}, {}", a.deref(), a.deref());
-
-    println!("{}", a.deref());
-
-    #[allow(clippy::match_single_binding)]
-    match a.deref() {
-        _ => (),
-    }
-
-    let b: String = concat(a.deref());
-
-    let b = just_return(a).deref();
-
-    let b: String = concat(just_return(a).deref());
-
-    let b: &str = a.deref().deref();
-
-    let opt_a = Some(a.clone());
-    let b = opt_a.unwrap().deref();
-
-    // following should not require linting
-
-    let cv = CustomVec(vec![0, 42]);
-    let c = cv.deref()[0];
-
-    let b: &str = &*a.deref();
-
-    let b: String = a.deref().clone();
-
-    let b: usize = a.deref_mut().len();
-
-    let b: &usize = &a.deref().len();
-
-    let b: &str = &*a;
-
-    let b: &mut str = &mut *a;
-
-    macro_rules! expr_deref {
-        ($body:expr) => {
-            $body.deref()
-        };
-    }
-    let b: &str = expr_deref!(a);
-
-    // The struct does not implement Deref trait
-    #[derive(Copy, Clone)]
-    struct NoLint(u32);
-    impl NoLint {
-        pub fn deref(self) -> u32 {
-            self.0
-        }
-        pub fn deref_mut(self) -> u32 {
-            self.0
-        }
-    }
-    let no_lint = NoLint(42);
-    let b = no_lint.deref();
-    let b = no_lint.deref_mut();
-}
diff --git a/tests/ui/dereference.stderr b/tests/ui/dereference.stderr
deleted file mode 100644
index d26b462a433..00000000000
--- a/tests/ui/dereference.stderr
+++ /dev/null
@@ -1,70 +0,0 @@
-error: explicit deref method call
-  --> $DIR/dereference.rs:30:19
-   |
-LL |     let b: &str = a.deref();
-   |                   ^^^^^^^^^ help: try this: `&*a`
-   |
-   = note: `-D clippy::explicit-deref-methods` implied by `-D warnings`
-
-error: explicit deref_mut method call
-  --> $DIR/dereference.rs:32:23
-   |
-LL |     let b: &mut str = a.deref_mut();
-   |                       ^^^^^^^^^^^^^ help: try this: `&mut *a`
-
-error: explicit deref method call
-  --> $DIR/dereference.rs:35:39
-   |
-LL |     let b: String = format!("{}, {}", a.deref(), a.deref());
-   |                                       ^^^^^^^^^ help: try this: `&*a`
-
-error: explicit deref method call
-  --> $DIR/dereference.rs:35:50
-   |
-LL |     let b: String = format!("{}, {}", a.deref(), a.deref());
-   |                                                  ^^^^^^^^^ help: try this: `&*a`
-
-error: explicit deref method call
-  --> $DIR/dereference.rs:37:20
-   |
-LL |     println!("{}", a.deref());
-   |                    ^^^^^^^^^ help: try this: `&*a`
-
-error: explicit deref method call
-  --> $DIR/dereference.rs:40:11
-   |
-LL |     match a.deref() {
-   |           ^^^^^^^^^ help: try this: `&*a`
-
-error: explicit deref method call
-  --> $DIR/dereference.rs:44:28
-   |
-LL |     let b: String = concat(a.deref());
-   |                            ^^^^^^^^^ help: try this: `&*a`
-
-error: explicit deref method call
-  --> $DIR/dereference.rs:46:13
-   |
-LL |     let b = just_return(a).deref();
-   |             ^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&*just_return(a)`
-
-error: explicit deref method call
-  --> $DIR/dereference.rs:48:28
-   |
-LL |     let b: String = concat(just_return(a).deref());
-   |                            ^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&*just_return(a)`
-
-error: explicit deref method call
-  --> $DIR/dereference.rs:50:19
-   |
-LL |     let b: &str = a.deref().deref();
-   |                   ^^^^^^^^^^^^^^^^^ help: try this: `&*a.deref()`
-
-error: explicit deref method call
-  --> $DIR/dereference.rs:53:13
-   |
-LL |     let b = opt_a.unwrap().deref();
-   |             ^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&*opt_a.unwrap()`
-
-error: aborting due to 11 previous errors
-
diff --git a/tests/ui/explicit_deref_methods.fixed b/tests/ui/explicit_deref_methods.fixed
new file mode 100644
index 00000000000..8155fdf9950
--- /dev/null
+++ b/tests/ui/explicit_deref_methods.fixed
@@ -0,0 +1,93 @@
+// run-rustfix
+
+#![allow(unused_variables, clippy::many_single_char_names, clippy::clone_double_ref)]
+#![warn(clippy::explicit_deref_methods)]
+
+use std::ops::{Deref, DerefMut};
+
+fn concat(deref_str: &str) -> String {
+    format!("{}bar", deref_str)
+}
+
+fn just_return(deref_str: &str) -> &str {
+    deref_str
+}
+
+struct CustomVec(Vec<u8>);
+impl Deref for CustomVec {
+    type Target = Vec<u8>;
+
+    fn deref(&self) -> &Vec<u8> {
+        &self.0
+    }
+}
+
+fn main() {
+    let a: &mut String = &mut String::from("foo");
+
+    // these should require linting
+
+    let b: &str = &*a;
+
+    let b: &mut str = &mut **a;
+
+    // both derefs should get linted here
+    let b: String = format!("{}, {}", &*a, &*a);
+
+    println!("{}", &*a);
+
+    #[allow(clippy::match_single_binding)]
+    match &*a {
+        _ => (),
+    }
+
+    let b: String = concat(&*a);
+
+    let b = just_return(a);
+
+    let b: String = concat(just_return(a));
+
+    let b: &str = &**a;
+
+    let opt_a = Some(a.clone());
+    let b = &*opt_a.unwrap();
+
+    // following should not require linting
+
+    let cv = CustomVec(vec![0, 42]);
+    let c = cv.deref()[0];
+
+    let b: &str = &*a.deref();
+
+    let b: String = a.deref().clone();
+
+    let b: usize = a.deref_mut().len();
+
+    let b: &usize = &a.deref().len();
+
+    let b: &str = &*a;
+
+    let b: &mut str = &mut *a;
+
+    macro_rules! expr_deref {
+        ($body:expr) => {
+            $body.deref()
+        };
+    }
+    let b: &str = expr_deref!(a);
+
+    // The struct does not implement Deref trait
+    #[derive(Copy, Clone)]
+    struct NoLint(u32);
+    impl NoLint {
+        pub fn deref(self) -> u32 {
+            self.0
+        }
+        pub fn deref_mut(self) -> u32 {
+            self.0
+        }
+    }
+    let no_lint = NoLint(42);
+    let b = no_lint.deref();
+    let b = no_lint.deref_mut();
+}
diff --git a/tests/ui/explicit_deref_methods.rs b/tests/ui/explicit_deref_methods.rs
new file mode 100644
index 00000000000..8dc5272e67f
--- /dev/null
+++ b/tests/ui/explicit_deref_methods.rs
@@ -0,0 +1,93 @@
+// run-rustfix
+
+#![allow(unused_variables, clippy::many_single_char_names, clippy::clone_double_ref)]
+#![warn(clippy::explicit_deref_methods)]
+
+use std::ops::{Deref, DerefMut};
+
+fn concat(deref_str: &str) -> String {
+    format!("{}bar", deref_str)
+}
+
+fn just_return(deref_str: &str) -> &str {
+    deref_str
+}
+
+struct CustomVec(Vec<u8>);
+impl Deref for CustomVec {
+    type Target = Vec<u8>;
+
+    fn deref(&self) -> &Vec<u8> {
+        &self.0
+    }
+}
+
+fn main() {
+    let a: &mut String = &mut String::from("foo");
+
+    // these should require linting
+
+    let b: &str = a.deref();
+
+    let b: &mut str = a.deref_mut();
+
+    // both derefs should get linted here
+    let b: String = format!("{}, {}", a.deref(), a.deref());
+
+    println!("{}", a.deref());
+
+    #[allow(clippy::match_single_binding)]
+    match a.deref() {
+        _ => (),
+    }
+
+    let b: String = concat(a.deref());
+
+    let b = just_return(a).deref();
+
+    let b: String = concat(just_return(a).deref());
+
+    let b: &str = a.deref().deref();
+
+    let opt_a = Some(a.clone());
+    let b = opt_a.unwrap().deref();
+
+    // following should not require linting
+
+    let cv = CustomVec(vec![0, 42]);
+    let c = cv.deref()[0];
+
+    let b: &str = &*a.deref();
+
+    let b: String = a.deref().clone();
+
+    let b: usize = a.deref_mut().len();
+
+    let b: &usize = &a.deref().len();
+
+    let b: &str = &*a;
+
+    let b: &mut str = &mut *a;
+
+    macro_rules! expr_deref {
+        ($body:expr) => {
+            $body.deref()
+        };
+    }
+    let b: &str = expr_deref!(a);
+
+    // The struct does not implement Deref trait
+    #[derive(Copy, Clone)]
+    struct NoLint(u32);
+    impl NoLint {
+        pub fn deref(self) -> u32 {
+            self.0
+        }
+        pub fn deref_mut(self) -> u32 {
+            self.0
+        }
+    }
+    let no_lint = NoLint(42);
+    let b = no_lint.deref();
+    let b = no_lint.deref_mut();
+}
diff --git a/tests/ui/explicit_deref_methods.stderr b/tests/ui/explicit_deref_methods.stderr
new file mode 100644
index 00000000000..35db6ef0905
--- /dev/null
+++ b/tests/ui/explicit_deref_methods.stderr
@@ -0,0 +1,70 @@
+error: explicit `deref` method call
+  --> $DIR/explicit_deref_methods.rs:30:19
+   |
+LL |     let b: &str = a.deref();
+   |                   ^^^^^^^^^ help: try this: `&*a`
+   |
+   = note: `-D clippy::explicit-deref-methods` implied by `-D warnings`
+
+error: explicit `deref` method call
+  --> $DIR/explicit_deref_methods.rs:32:23
+   |
+LL |     let b: &mut str = a.deref_mut();
+   |                       ^^^^^^^^^^^^^ help: try this: `&mut **a`
+
+error: explicit `deref` method call
+  --> $DIR/explicit_deref_methods.rs:35:39
+   |
+LL |     let b: String = format!("{}, {}", a.deref(), a.deref());
+   |                                       ^^^^^^^^^ help: try this: `&*a`
+
+error: explicit `deref` method call
+  --> $DIR/explicit_deref_methods.rs:35:50
+   |
+LL |     let b: String = format!("{}, {}", a.deref(), a.deref());
+   |                                                  ^^^^^^^^^ help: try this: `&*a`
+
+error: explicit `deref` method call
+  --> $DIR/explicit_deref_methods.rs:37:20
+   |
+LL |     println!("{}", a.deref());
+   |                    ^^^^^^^^^ help: try this: `&*a`
+
+error: explicit `deref` method call
+  --> $DIR/explicit_deref_methods.rs:40:11
+   |
+LL |     match a.deref() {
+   |           ^^^^^^^^^ help: try this: `&*a`
+
+error: explicit `deref` method call
+  --> $DIR/explicit_deref_methods.rs:44:28
+   |
+LL |     let b: String = concat(a.deref());
+   |                            ^^^^^^^^^ help: try this: `&*a`
+
+error: explicit `deref` method call
+  --> $DIR/explicit_deref_methods.rs:46:13
+   |
+LL |     let b = just_return(a).deref();
+   |             ^^^^^^^^^^^^^^^^^^^^^^ help: try this: `just_return(a)`
+
+error: explicit `deref` method call
+  --> $DIR/explicit_deref_methods.rs:48:28
+   |
+LL |     let b: String = concat(just_return(a).deref());
+   |                            ^^^^^^^^^^^^^^^^^^^^^^ help: try this: `just_return(a)`
+
+error: explicit `deref` method call
+  --> $DIR/explicit_deref_methods.rs:50:19
+   |
+LL |     let b: &str = a.deref().deref();
+   |                   ^^^^^^^^^^^^^^^^^ help: try this: `&**a`
+
+error: explicit `deref` method call
+  --> $DIR/explicit_deref_methods.rs:53:13
+   |
+LL |     let b = opt_a.unwrap().deref();
+   |             ^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&*opt_a.unwrap()`
+
+error: aborting due to 11 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 1666e43cc0b1f2df9b8b4a3d8bb3ffb5ecdcf27e Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Tue, 9 Mar 2021 10:37:15 -0500
Subject: Remove unneeded code.

---
 clippy_lints/src/dereference.rs     |  9 +-----
 clippy_lints/src/redundant_deref.rs | 63 -------------------------------------
 2 files changed, 1 insertion(+), 71 deletions(-)
 delete mode 100644 clippy_lints/src/redundant_deref.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index a33634ca34e..6185cf50b35 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -1,6 +1,4 @@
-use crate::utils::{
-    get_node_span, get_parent_node, in_macro, is_allowed, peel_mid_ty_refs, snippet_with_context, span_lint_and_sugg,
-};
+use crate::utils::{get_parent_node, in_macro, is_allowed, peel_mid_ty_refs, snippet_with_context, span_lint_and_sugg};
 use rustc_ast::util::parser::PREC_PREFIX;
 use rustc_errors::Applicability;
 use rustc_hir::{BorrowKind, Destination, Expr, ExprKind, HirId, MatchSource, Mutability, Node, UnOp};
@@ -102,11 +100,6 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing {
         match (self.state.take(), kind) {
             (None, kind) => {
                 let parent = get_parent_node(cx.tcx, expr.hir_id);
-                // This is an odd case. The expression is a macro argument, but the top level
-                // address of expression is inserted by the compiler.
-                if matches!(kind, RefOp::AddrOf) && parent.and_then(get_node_span).map_or(false, in_macro) {
-                    return;
-                }
 
                 let expr_adjustments = find_adjustments(cx.tcx, typeck, expr);
                 let expr_ty = typeck.expr_ty(expr);
diff --git a/clippy_lints/src/redundant_deref.rs b/clippy_lints/src/redundant_deref.rs
deleted file mode 100644
index 029583720d2..00000000000
--- a/clippy_lints/src/redundant_deref.rs
+++ /dev/null
@@ -1,63 +0,0 @@
-// use crate::utils::{get_parent_expr, snippet_with_applicability, span_lint_and_sugg};
-// use if_chain::if_chain;
-// use rustc_errors::Applicability;
-// use rustc_hir::{Expr, ExprKind, UnOp};
-// use rustc_lint::{LateContext, LateLintPass, LintContext};
-// use rustc_middle::lint::in_external_macro;
-// use rustc_session::{declare_lint_pass, declare_tool_lint};
-
-// declare_clippy_lint! {
-//     /// **What it does:** Checks for uses of the dereference operator which would be covered by
-//     /// auto-dereferencing.
-//     ///
-//     /// **Why is this bad?** This unnecessarily complicates the code.
-//     ///
-//     /// **Known problems:** None.
-//     ///
-//     /// **Example:**
-//     ///
-//     /// ```rust
-//     /// fn foo(_: &str) {}
-//     /// foo(&*String::new())
-//     /// ```
-//     /// Use instead:
-//     /// ```rust
-//     /// fn foo(_: &str) {}
-//     /// foo(&String::new())
-//     /// ```
-//     pub REDUNDANT_DEREF,
-//     style,
-//     "default lint description"
-// }
-
-// declare_lint_pass!(RedundantDeref => [REDUNDANT_DEREF]);
-
-// impl LateLintPass<'_> for RedundantDeref {
-//     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-//         if_chain! {
-//             if let ExprKind::AddrOf(_, _, addr_expr) = expr.kind;
-//             if let ExprKind::Unary(UnOp::UnDeref, deref_expr) = addr_expr.kind;
-//             if !in_external_macro(cx.sess(), expr.span);
-//             if let Some(parent_expr) = get_parent_expr(cx, expr);
-//             if match parent_expr.kind {
-//                 ExprKind::Call(func, _) => func.hir_id != expr.hir_id,
-//                 ExprKind::MethodCall(..) => true,
-//                 _ => false,
-//             };
-//             if !cx.typeck_results().expr_ty(deref_expr).is_unsafe_ptr();
-//             then {
-//                 let mut app = Applicability::MachineApplicable;
-//                 let sugg = format!("&{}", snippet_with_applicability(cx, deref_expr.span, "_", &mut app));
-//                 span_lint_and_sugg(
-//                     cx,
-//                     REDUNDANT_DEREF,
-//                     expr.span,
-//                     "redundant dereference",
-//                     "remove the dereference",
-//                     sugg,
-//                     app,
-//                 );
-//             }
-//         }
-//     }
-// }
-- 
cgit 1.4.1-3-g733a5


From 704f7a8e5025cdf5765493b4369290b65230c5d1 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Fri, 12 Mar 2021 20:13:45 -0500
Subject: Keep track of whether `deref` or `deref_mut` was called Remove more
 unnecessary code

---
 clippy_lints/src/dereference.rs        | 75 ++++++++--------------------------
 tests/ui/explicit_deref_methods.stderr |  2 +-
 2 files changed, 17 insertions(+), 60 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index 6185cf50b35..a1d0110929c 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -1,9 +1,9 @@
 use crate::utils::{get_parent_node, in_macro, is_allowed, peel_mid_ty_refs, snippet_with_context, span_lint_and_sugg};
 use rustc_ast::util::parser::PREC_PREFIX;
 use rustc_errors::Applicability;
-use rustc_hir::{BorrowKind, Destination, Expr, ExprKind, HirId, MatchSource, Mutability, Node, UnOp};
+use rustc_hir::{BorrowKind, Expr, ExprKind, HirId, MatchSource, Mutability, Node, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty::{self, adjustment::Adjustment, Ty, TyCtxt, TyS, TypeckResults};
+use rustc_middle::ty::{self, Ty, TyCtxt, TyS, TypeckResults};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::{symbol::sym, Span};
 
@@ -66,7 +66,7 @@ enum State {
 
 // A reference operation considered by this lint pass
 enum RefOp {
-    Method,
+    Method(Mutability),
     Deref,
     AddrOf,
 }
@@ -100,18 +100,10 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing {
         match (self.state.take(), kind) {
             (None, kind) => {
                 let parent = get_parent_node(cx.tcx, expr.hir_id);
-
-                let expr_adjustments = find_adjustments(cx.tcx, typeck, expr);
                 let expr_ty = typeck.expr_ty(expr);
-                let target_mut =
-                    if let ty::Ref(_, _, mutability) = *expr_adjustments.last().map_or(expr_ty, |a| a.target).kind() {
-                        mutability
-                    } else {
-                        Mutability::Not
-                    };
 
                 match kind {
-                    RefOp::Method
+                    RefOp::Method(target_mut)
                         if !is_allowed(cx, EXPLICIT_DEREF_METHODS, expr.hir_id)
                             && is_linted_explicit_deref_position(parent, expr.hir_id) =>
                     {
@@ -133,7 +125,7 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing {
                     _ => (),
                 }
             },
-            (Some((State::DerefMethod { ty_changed_count, .. }, data)), RefOp::Method) => {
+            (Some((State::DerefMethod { ty_changed_count, .. }, data)), RefOp::Method(_)) => {
                 self.state = Some((
                     State::DerefMethod {
                         ty_changed_count: if deref_method_same_type(typeck.expr_ty(expr), typeck.expr_ty(sub_expr)) {
@@ -173,9 +165,13 @@ fn try_parse_ref_op(
         ExprKind::AddrOf(BorrowKind::Ref, _, sub_expr) => return Some((RefOp::AddrOf, sub_expr)),
         _ => return None,
     };
-    (tcx.is_diagnostic_item(sym::deref_method, def_id)
-        || tcx.trait_of_item(def_id)? == tcx.lang_items().deref_mut_trait()?)
-    .then(|| (RefOp::Method, arg))
+    if tcx.is_diagnostic_item(sym::deref_method, def_id) {
+        Some((RefOp::Method(Mutability::Not), arg))
+    } else if tcx.trait_of_item(def_id)? == tcx.lang_items().deref_mut_trait()? {
+        Some((RefOp::Method(Mutability::Mut), arg))
+    } else {
+        None
+    }
 }
 
 // Checks whether the type for a deref call actually changed the type, not just the mutability of
@@ -191,48 +187,6 @@ fn deref_method_same_type(result_ty: Ty<'tcx>, arg_ty: Ty<'tcx>) -> bool {
     }
 }
 
-// Adjustments are sometimes made in the parent block rather than the expression itself.
-fn find_adjustments(
-    tcx: TyCtxt<'tcx>,
-    typeck: &'tcx TypeckResults<'_>,
-    expr: &'tcx Expr<'_>,
-) -> &'tcx [Adjustment<'tcx>] {
-    let map = tcx.hir();
-    let mut iter = map.parent_iter(expr.hir_id);
-    let mut prev = expr;
-
-    loop {
-        match typeck.expr_adjustments(prev) {
-            [] => (),
-            a => break a,
-        };
-
-        match iter.next().map(|(_, x)| x) {
-            Some(Node::Block(_)) => {
-                if let Some((_, Node::Expr(e))) = iter.next() {
-                    prev = e;
-                } else {
-                    // This shouldn't happen. Blocks are always contained in an expression.
-                    break &[];
-                }
-            },
-            Some(Node::Expr(&Expr {
-                kind: ExprKind::Break(Destination { target_id: Ok(id), .. }, _),
-                ..
-            })) => {
-                if let Some(Node::Expr(e)) = map.find(id) {
-                    prev = e;
-                    iter = map.parent_iter(id);
-                    continue;
-                }
-                // This shouldn't happen. The destination should definitely exist at this point.
-                break &[];
-            },
-            _ => break &[],
-        }
-    }
-}
-
 // Checks whether the parent node is a suitable context for switching from a deref method to the
 // deref operator.
 fn is_linted_explicit_deref_position(parent: Option<Node<'_>>, child_id: HirId) -> bool {
@@ -331,7 +285,10 @@ fn report(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, state: State, data: Stat
                 cx,
                 EXPLICIT_DEREF_METHODS,
                 data.span,
-                "explicit `deref` method call",
+                match data.target_mut {
+                    Mutability::Not => "explicit `deref` method call",
+                    Mutability::Mut => "explicit `deref_mut` method call",
+                },
                 "try this",
                 format!("{}{}{}", addr_of_str, deref_str, expr_str),
                 app,
diff --git a/tests/ui/explicit_deref_methods.stderr b/tests/ui/explicit_deref_methods.stderr
index 35db6ef0905..335c0e4bb9d 100644
--- a/tests/ui/explicit_deref_methods.stderr
+++ b/tests/ui/explicit_deref_methods.stderr
@@ -6,7 +6,7 @@ LL |     let b: &str = a.deref();
    |
    = note: `-D clippy::explicit-deref-methods` implied by `-D warnings`
 
-error: explicit `deref` method call
+error: explicit `deref_mut` method call
   --> $DIR/explicit_deref_methods.rs:32:23
    |
 LL |     let b: &mut str = a.deref_mut();
-- 
cgit 1.4.1-3-g733a5


From 2713ad43425bef040e3c7d55618d18035fe68c1a Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sat, 13 Mar 2021 08:27:42 -0500
Subject: Properly lint macro arguments for `explicit_deref_methods`

---
 clippy_lints/src/dereference.rs        | 6 +++---
 tests/ui/explicit_deref_methods.fixed  | 2 ++
 tests/ui/explicit_deref_methods.rs     | 2 ++
 tests/ui/explicit_deref_methods.stderr | 8 +++++++-
 4 files changed, 14 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index a1d0110929c..40ed6d8d154 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -105,7 +105,7 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing {
                 match kind {
                     RefOp::Method(target_mut)
                         if !is_allowed(cx, EXPLICIT_DEREF_METHODS, expr.hir_id)
-                            && is_linted_explicit_deref_position(parent, expr.hir_id) =>
+                            && is_linted_explicit_deref_position(parent, expr.hir_id, expr.span) =>
                     {
                         self.state = Some((
                             State::DerefMethod {
@@ -189,9 +189,9 @@ fn deref_method_same_type(result_ty: Ty<'tcx>, arg_ty: Ty<'tcx>) -> bool {
 
 // Checks whether the parent node is a suitable context for switching from a deref method to the
 // deref operator.
-fn is_linted_explicit_deref_position(parent: Option<Node<'_>>, child_id: HirId) -> bool {
+fn is_linted_explicit_deref_position(parent: Option<Node<'_>>, child_id: HirId, child_span: Span) -> bool {
     let parent = match parent {
-        Some(Node::Expr(e)) => e,
+        Some(Node::Expr(e)) if e.span.ctxt() == child_span.ctxt() => e,
         _ => return true,
     };
     match parent.kind {
diff --git a/tests/ui/explicit_deref_methods.fixed b/tests/ui/explicit_deref_methods.fixed
index 8155fdf9950..51d0468e47c 100644
--- a/tests/ui/explicit_deref_methods.fixed
+++ b/tests/ui/explicit_deref_methods.fixed
@@ -76,6 +76,8 @@ fn main() {
     }
     let b: &str = expr_deref!(a);
 
+    let b: &str = expr_deref!(&*a);
+
     // The struct does not implement Deref trait
     #[derive(Copy, Clone)]
     struct NoLint(u32);
diff --git a/tests/ui/explicit_deref_methods.rs b/tests/ui/explicit_deref_methods.rs
index 8dc5272e67f..680664bd4f6 100644
--- a/tests/ui/explicit_deref_methods.rs
+++ b/tests/ui/explicit_deref_methods.rs
@@ -76,6 +76,8 @@ fn main() {
     }
     let b: &str = expr_deref!(a);
 
+    let b: &str = expr_deref!(a.deref());
+
     // The struct does not implement Deref trait
     #[derive(Copy, Clone)]
     struct NoLint(u32);
diff --git a/tests/ui/explicit_deref_methods.stderr b/tests/ui/explicit_deref_methods.stderr
index 335c0e4bb9d..8035d77d18d 100644
--- a/tests/ui/explicit_deref_methods.stderr
+++ b/tests/ui/explicit_deref_methods.stderr
@@ -66,5 +66,11 @@ error: explicit `deref` method call
 LL |     let b = opt_a.unwrap().deref();
    |             ^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&*opt_a.unwrap()`
 
-error: aborting due to 11 previous errors
+error: explicit `deref` method call
+  --> $DIR/explicit_deref_methods.rs:79:31
+   |
+LL |     let b: &str = expr_deref!(a.deref());
+   |                               ^^^^^^^^^ help: try this: `&*a`
+
+error: aborting due to 12 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 1054eb0c853aefec9787b57e103d3a1432169263 Mon Sep 17 00:00:00 2001
From: iobtl <tedmundhtl@gmail.com>
Date: Sun, 14 Mar 2021 08:09:08 +0800
Subject: use lint_unnecessary_cast for literals, suggest `_` if not present

---
 clippy_lints/src/casts/unnecessary_cast.rs | 9 +++++++++
 tests/ui/unnecessary_cast.stderr           | 8 ++++----
 2 files changed, 13 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/unnecessary_cast.rs b/clippy_lints/src/casts/unnecessary_cast.rs
index 171cac091c2..c43bbf32949 100644
--- a/clippy_lints/src/casts/unnecessary_cast.rs
+++ b/clippy_lints/src/casts/unnecessary_cast.rs
@@ -44,6 +44,15 @@ pub(super) fn check(
                 lint_unnecessary_cast(cx, expr, &literal_str, cast_from, cast_to);
             },
             LitKind::Int(_, LitIntType::Unsuffixed) | LitKind::Float(_, LitFloatType::Unsuffixed) => {},
+            LitKind::Int(_, LitIntType::Signed(_) | LitIntType::Unsigned(_))
+            | LitKind::Float(_, LitFloatType::Suffixed(_))
+                if cast_from.kind() == cast_to.kind() =>
+            {
+                if let Some(src) = snippet_opt(cx, lit.span) {
+                    let num_lit = NumericLiteral::from_lit_kind(&src, &lit.node).unwrap();
+                    lint_unnecessary_cast(cx, expr, num_lit.integer, cast_from, cast_to);
+                }
+            },
             _ => {
                 if cast_from.kind() == cast_to.kind() && !in_external_macro(cx.sess(), expr.span) {
                     span_lint_and_sugg(
diff --git a/tests/ui/unnecessary_cast.stderr b/tests/ui/unnecessary_cast.stderr
index 87261cd8333..70aa448af68 100644
--- a/tests/ui/unnecessary_cast.stderr
+++ b/tests/ui/unnecessary_cast.stderr
@@ -1,16 +1,16 @@
-error: casting to the same type is unnecessary (`i32` -> `i32`)
+error: casting integer literal to `i32` is unnecessary
   --> $DIR/unnecessary_cast.rs:6:5
    |
 LL |     1i32 as i32;
-   |     ^^^^^^^^^^^ help: try: `1i32`
+   |     ^^^^^^^^^^^ help: try: `1_i32`
    |
    = note: `-D clippy::unnecessary-cast` implied by `-D warnings`
 
-error: casting to the same type is unnecessary (`f32` -> `f32`)
+error: casting float literal to `f32` is unnecessary
   --> $DIR/unnecessary_cast.rs:7:5
    |
 LL |     1f32 as f32;
-   |     ^^^^^^^^^^^ help: try: `1f32`
+   |     ^^^^^^^^^^^ help: try: `1_f32`
 
 error: casting to the same type is unnecessary (`bool` -> `bool`)
   --> $DIR/unnecessary_cast.rs:8:5
-- 
cgit 1.4.1-3-g733a5


From ecf0c76c369a80c1a2de61e25c94b7df5dc7d164 Mon Sep 17 00:00:00 2001
From: Ben Boeckel <mathstuf@gmail.com>
Date: Wed, 25 Mar 2020 21:13:24 -0400
Subject: Fix suspicious_map false positives

---
 clippy_lints/src/methods/mod.rs            |  2 +-
 clippy_lints/src/methods/suspicious_map.rs | 45 ++++++++++++++++-----
 clippy_utils/src/lib.rs                    | 64 ++++++++++++++++++++++++++++--
 tests/ui/suspicious_map.rs                 | 27 +++++++++++++
 tests/ui/suspicious_map.stderr             | 10 ++++-
 5 files changed, 132 insertions(+), 16 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 7fd14c4f9b1..45e906cf468 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1739,7 +1739,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
                 unnecessary_filter_map::check(cx, expr, arg_lists[0]);
                 filter_map_identity::check(cx, expr, arg_lists[0], method_spans[0]);
             },
-            ["count", "map"] => suspicious_map::check(cx, expr),
+            ["count", "map"] => suspicious_map::check(cx, expr, arg_lists[1], arg_lists[0]),
             ["assume_init"] => uninit_assumed_init::check(cx, &arg_lists[0][0], expr),
             ["unwrap_or", arith @ ("checked_add" | "checked_sub" | "checked_mul")] => {
                 manual_saturating_arithmetic::check(cx, expr, &arg_lists, &arith["checked_".len()..])
diff --git a/clippy_lints/src/methods/suspicious_map.rs b/clippy_lints/src/methods/suspicious_map.rs
index e135a826dc4..0ffa71de30c 100644
--- a/clippy_lints/src/methods/suspicious_map.rs
+++ b/clippy_lints/src/methods/suspicious_map.rs
@@ -1,16 +1,41 @@
-use crate::utils::span_lint_and_help;
+use crate::utils::usage::mutated_variables;
+use crate::utils::{expr_or_init, is_trait_method, span_lint_and_help};
+use if_chain::if_chain;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
+use rustc_span::sym;
 
 use super::SUSPICIOUS_MAP;
 
-pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>) {
-    span_lint_and_help(
-        cx,
-        SUSPICIOUS_MAP,
-        expr.span,
-        "this call to `map()` won't have an effect on the call to `count()`",
-        None,
-        "make sure you did not confuse `map` with `filter` or `for_each`",
-    );
+pub fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &hir::Expr<'_>,
+    map_args: &[hir::Expr<'_>],
+    count_args: &[hir::Expr<'_>],
+) {
+    if_chain! {
+        if let [count_recv] = count_args;
+        if let [_, map_arg] = map_args;
+        if is_trait_method(cx, count_recv, sym::Iterator);
+        let closure = expr_or_init(cx, map_arg);
+        if let Some(body_id) = cx.tcx.hir().maybe_body_owned_by(closure.hir_id);
+        let closure_body = cx.tcx.hir().body(body_id);
+        if !cx.typeck_results().expr_ty(&closure_body.value).is_unit();
+        then {
+            if let Some(map_mutated_vars) = mutated_variables(&closure_body.value, cx) {
+                // A variable is used mutably inside of the closure. Suppress the lint.
+                if !map_mutated_vars.is_empty() {
+                    return;
+                }
+            }
+            span_lint_and_help(
+                cx,
+                SUSPICIOUS_MAP,
+                expr.span,
+                "this call to `map()` won't have an effect on the call to `count()`",
+                None,
+                "make sure you did not confuse `map` with `filter` or `for_each`",
+            );
+        }
+    }
 }
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 0ddc915862c..98cdeae739f 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -62,10 +62,10 @@ use rustc_hir::def::{CtorKind, CtorOf, DefKind, Res};
 use rustc_hir::def_id::{DefId, LOCAL_CRATE};
 use rustc_hir::intravisit::{self, NestedVisitorMap, Visitor};
 use rustc_hir::{
-    def, Arm, Block, Body, Constness, CrateItem, Expr, ExprKind, FnDecl, ForeignItem, GenericArgs, GenericParam, HirId,
-    Impl, ImplItem, ImplItemKind, Item, ItemKind, LangItem, Lifetime, Local, MacroDef, MatchSource, Node, Param, Pat,
-    PatKind, Path, PathSegment, QPath, Stmt, StructField, TraitItem, TraitItemKind, TraitRef, TyKind, Unsafety,
-    Variant, Visibility,
+    def, Arm, BindingAnnotation, Block, Body, Constness, CrateItem, Expr, ExprKind, FnDecl, ForeignItem, GenericArgs,
+    GenericParam, HirId, Impl, ImplItem, ImplItemKind, Item, ItemKind, LangItem, Lifetime, Local, MacroDef,
+    MatchSource, Node, Param, Pat, PatKind, Path, PathSegment, QPath, Stmt, StructField, TraitItem, TraitItemKind,
+    TraitRef, TyKind, Unsafety, Variant, Visibility,
 };
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::{LateContext, Level, Lint, LintContext};
@@ -138,6 +138,62 @@ pub fn differing_macro_contexts(lhs: Span, rhs: Span) -> bool {
     rhs.ctxt() != lhs.ctxt()
 }
 
+/// If the given expression is a local binding, find the initializer expression.
+/// If that initializer expression is another local binding, find its initializer again.
+/// This process repeats as long as possible (but usually no more than once). Initializer
+/// expressions with adjustments are ignored. If this is not desired, use [`find_binding_init`]
+/// instead.
+///
+/// Examples:
+/// ```ignore
+/// let abc = 1;
+/// //        ^ output
+/// let def = abc;
+/// dbg!(def)
+/// //   ^^^ input
+///
+/// // or...
+/// let abc = 1;
+/// let def = abc + 2;
+/// //        ^^^^^^^ output
+/// dbg!(def)
+/// //   ^^^ input
+/// ```
+pub fn expr_or_init<'a, 'b, 'tcx: 'b>(cx: &LateContext<'tcx>, mut expr: &'a Expr<'b>) -> &'a Expr<'b> {
+    while let Some(init) = path_to_local(expr)
+        .and_then(|id| find_binding_init(cx, id))
+        .filter(|init| cx.typeck_results().expr_adjustments(init).is_empty())
+    {
+        expr = init;
+    }
+    expr
+}
+
+/// Finds the initializer expression for a local binding. Returns `None` if the binding is mutable.
+/// By only considering immutable bindings, we guarantee that the returned expression represents the
+/// value of the binding wherever it is referenced.
+///
+/// Example:
+/// ```ignore
+/// let abc = 1;
+/// //        ^ output
+/// dbg!(abc)
+/// //   ^^^ input
+/// ```
+pub fn find_binding_init<'tcx>(cx: &LateContext<'tcx>, hir_id: HirId) -> Option<&'tcx Expr<'tcx>> {
+    let hir = cx.tcx.hir();
+    if_chain! {
+        if let Some(Node::Binding(pat)) = hir.find(hir_id);
+        if matches!(pat.kind, PatKind::Binding(BindingAnnotation::Unannotated, ..));
+        let parent = hir.get_parent_node(hir_id);
+        if let Some(Node::Local(local)) = hir.find(parent);
+        then {
+            return local.init;
+        }
+    }
+    None
+}
+
 /// Returns `true` if the given `NodeId` is inside a constant context
 ///
 /// # Example
diff --git a/tests/ui/suspicious_map.rs b/tests/ui/suspicious_map.rs
index d838d8fde21..3a2a10cf09e 100644
--- a/tests/ui/suspicious_map.rs
+++ b/tests/ui/suspicious_map.rs
@@ -2,4 +2,31 @@
 
 fn main() {
     let _ = (0..3).map(|x| x + 2).count();
+
+    let f = |x| x + 1;
+    let _ = (0..3).map(f).count();
+}
+
+fn negative() {
+    // closure with side effects
+    let mut sum = 0;
+    let _ = (0..3).map(|x| sum += x).count();
+
+    // closure variable with side effects
+    let ext_closure = |x| sum += x;
+    let _ = (0..3).map(ext_closure).count();
+
+    // closure that returns unit
+    let _ = (0..3)
+        .map(|x| {
+            // do nothing
+        })
+        .count();
+
+    // external function
+    let _ = (0..3).map(do_something).count();
+}
+
+fn do_something<T>(t: T) -> String {
+    unimplemented!()
 }
diff --git a/tests/ui/suspicious_map.stderr b/tests/ui/suspicious_map.stderr
index e1b4ba40376..8c3f36584a5 100644
--- a/tests/ui/suspicious_map.stderr
+++ b/tests/ui/suspicious_map.stderr
@@ -7,5 +7,13 @@ LL |     let _ = (0..3).map(|x| x + 2).count();
    = note: `-D clippy::suspicious-map` implied by `-D warnings`
    = help: make sure you did not confuse `map` with `filter` or `for_each`
 
-error: aborting due to previous error
+error: this call to `map()` won't have an effect on the call to `count()`
+  --> $DIR/suspicious_map.rs:7:13
+   |
+LL |     let _ = (0..3).map(f).count();
+   |             ^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: make sure you did not confuse `map` with `filter` or `for_each`
+
+error: aborting due to 2 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From eb7f8d6089e2dba4006f0452ab25262735bbbf61 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Sat, 13 Mar 2021 17:01:03 -0600
Subject: Move some utils to ty_utils

---
 clippy_lints/src/assign_ops.rs                     |   5 +-
 clippy_lints/src/async_yields_async.rs             |   3 +-
 clippy_lints/src/blocks_in_if_conditions.rs        |   4 +-
 clippy_lints/src/booleans.rs                       |   4 +-
 clippy_lints/src/bytecount.rs                      |   3 +-
 clippy_lints/src/casts/cast_lossless.rs            |   3 +-
 clippy_lints/src/casts/cast_possible_truncation.rs |   3 +-
 clippy_lints/src/casts/cast_possible_wrap.rs       |   3 +-
 clippy_lints/src/casts/cast_precision_loss.rs      |   3 +-
 clippy_lints/src/cognitive_complexity.rs           |   3 +-
 clippy_lints/src/comparison_chain.rs               |   5 +-
 clippy_lints/src/copy_iterator.rs                  |   3 +-
 clippy_lints/src/dereference.rs                    |   3 +-
 clippy_lints/src/derive.rs                         |   5 +-
 clippy_lints/src/doc.rs                            |   4 +-
 clippy_lints/src/drop_forget_ref.rs                |   3 +-
 clippy_lints/src/duration_subsec.rs                |   3 +-
 clippy_lints/src/entry.rs                          |   3 +-
 clippy_lints/src/eq_op.rs                          |   5 +-
 clippy_lints/src/escape.rs                         |   3 +-
 clippy_lints/src/eta_reduction.rs                  |  10 +-
 clippy_lints/src/fallible_impl_from.rs             |   3 +-
 clippy_lints/src/format.rs                         |   4 +-
 clippy_lints/src/from_str_radix_10.rs              |   2 +-
 clippy_lints/src/functions.rs                      |   7 +-
 clippy_lints/src/get_last_with_len.rs              |   3 +-
 clippy_lints/src/if_let_mutex.rs                   |   3 +-
 clippy_lints/src/if_let_some_result.rs             |   3 +-
 clippy_lints/src/infinite_iter.rs                  |   3 +-
 clippy_lints/src/inherent_to_string.rs             |   6 +-
 clippy_lints/src/let_underscore.rs                 |   3 +-
 clippy_lints/src/loops/explicit_iter_loop.rs       |   4 +-
 clippy_lints/src/loops/for_kv_map.rs               |   3 +-
 clippy_lints/src/loops/for_loops_over_fallibles.rs |   3 +-
 clippy_lints/src/loops/manual_memcpy.rs            |   5 +-
 clippy_lints/src/loops/needless_collect.rs         |   6 +-
 clippy_lints/src/loops/needless_range_loop.rs      |   5 +-
 clippy_lints/src/loops/same_item_push.rs           |   3 +-
 clippy_lints/src/loops/utils.rs                    |   5 +-
 clippy_lints/src/loops/while_let_on_iterator.rs    |   6 +-
 clippy_lints/src/manual_map.rs                     |   6 +-
 clippy_lints/src/manual_ok_or.rs                   |   4 +-
 clippy_lints/src/manual_unwrap_or.rs               |   5 +-
 clippy_lints/src/map_clone.rs                      |   6 +-
 clippy_lints/src/map_identity.rs                   |   6 +-
 clippy_lints/src/map_unit_fn.rs                    |   3 +-
 clippy_lints/src/match_on_vec_items.rs             |   3 +-
 clippy_lints/src/matches.rs                        |  10 +-
 clippy_lints/src/mem_discriminant.rs               |   4 +-
 clippy_lints/src/methods/bind_instead_of_map.rs    |   3 +-
 clippy_lints/src/methods/bytes_nth.rs              |   3 +-
 clippy_lints/src/methods/clone_on_copy.rs          |   3 +-
 clippy_lints/src/methods/clone_on_ref_ptr.rs       |   3 +-
 clippy_lints/src/methods/expect_fun_call.rs        |   3 +-
 clippy_lints/src/methods/expect_used.rs            |   3 +-
 clippy_lints/src/methods/filetype_is_file.rs       |   3 +-
 .../src/methods/from_iter_instead_of_collect.rs    |   3 +-
 clippy_lints/src/methods/get_unwrap.rs             |   5 +-
 clippy_lints/src/methods/inefficient_to_string.rs  |   5 +-
 clippy_lints/src/methods/into_iter_on_ref.rs       |   3 +-
 clippy_lints/src/methods/iter_cloned_collect.rs    |   3 +-
 clippy_lints/src/methods/iter_count.rs             |   4 +-
 clippy_lints/src/methods/iter_next_slice.rs        |   3 +-
 clippy_lints/src/methods/iter_nth.rs               |   3 +-
 .../src/methods/map_collect_result_unit.rs         |   3 +-
 clippy_lints/src/methods/map_flatten.rs            |   3 +-
 clippy_lints/src/methods/map_unwrap_or.rs          |   3 +-
 clippy_lints/src/methods/mod.rs                    |   7 +-
 clippy_lints/src/methods/ok_expect.rs              |   3 +-
 clippy_lints/src/methods/option_as_ref_deref.rs    |   6 +-
 clippy_lints/src/methods/option_map_or_none.rs     |   3 +-
 clippy_lints/src/methods/option_map_unwrap_or.rs   |   3 +-
 clippy_lints/src/methods/or_fun_call.rs            |   5 +-
 clippy_lints/src/methods/search_is_some.rs         |   4 +-
 clippy_lints/src/methods/string_extend_chars.rs    |   3 +-
 clippy_lints/src/methods/unnecessary_lazy_eval.rs  |   3 +-
 clippy_lints/src/methods/unwrap_used.rs            |   3 +-
 clippy_lints/src/methods/useless_asref.rs          |   5 +-
 clippy_lints/src/misc.rs                           |   7 +-
 clippy_lints/src/missing_const_for_fn.rs           |   5 +-
 clippy_lints/src/mut_mutex_lock.rs                 |   3 +-
 clippy_lints/src/mutex_atomic.rs                   |   3 +-
 clippy_lints/src/needless_pass_by_value.rs         |   6 +-
 clippy_lints/src/needless_question_mark.rs         |   9 +-
 clippy_lints/src/neg_cmp_op_on_partial_ord.rs      |   5 +-
 clippy_lints/src/no_effect.rs                      |   3 +-
 clippy_lints/src/open_options.rs                   |   3 +-
 clippy_lints/src/option_if_let_else.rs             |   3 +-
 clippy_lints/src/panic_in_result_fn.rs             |   3 +-
 clippy_lints/src/pass_by_ref_or_value.rs           |   3 +-
 clippy_lints/src/path_buf_push_overwrite.rs        |   3 +-
 clippy_lints/src/ptr.rs                            |   6 +-
 clippy_lints/src/question_mark.rs                  |   6 +-
 clippy_lints/src/redundant_clone.rs                |   4 +-
 clippy_lints/src/redundant_slicing.rs              |   3 +-
 clippy_lints/src/repeat_once.rs                    |   3 +-
 clippy_lints/src/strings.rs                        |  15 +-
 clippy_lints/src/swap.rs                           |   5 +-
 clippy_lints/src/transmute/utils.rs                |   3 +-
 clippy_lints/src/try_err.rs                        |   5 +-
 clippy_lints/src/types/mod.rs                      |   7 +-
 clippy_lints/src/undropped_manually_drops.rs       |   3 +-
 clippy_lints/src/unnecessary_sort_by.rs            |   3 +-
 clippy_lints/src/unwrap.rs                         |   5 +-
 clippy_lints/src/unwrap_in_result.rs               |   8 +-
 clippy_lints/src/useless_conversion.rs             |   5 +-
 clippy_lints/src/utils/internal_lints.rs           |   5 +-
 clippy_lints/src/vec.rs                            |   3 +-
 clippy_lints/src/vec_init_then_push.rs             |   5 +-
 clippy_lints/src/verbose_file_reads.rs             |   3 +-
 clippy_lints/src/zero_sized_map_values.rs          |   3 +-
 clippy_utils/src/eager_or_lazy.rs                  |   3 +-
 clippy_utils/src/lib.rs                            | 323 ++-------------------
 clippy_utils/src/ty.rs                             | 296 +++++++++++++++++++
 114 files changed, 578 insertions(+), 509 deletions(-)
 create mode 100644 clippy_utils/src/ty.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/assign_ops.rs b/clippy_lints/src/assign_ops.rs
index e13f62d0428..ae300324158 100644
--- a/clippy_lints/src/assign_ops.rs
+++ b/clippy_lints/src/assign_ops.rs
@@ -1,7 +1,6 @@
-use crate::utils::{
-    eq_expr_value, get_trait_def_id, implements_trait, snippet_opt, span_lint_and_then, trait_ref_of_method,
-};
+use crate::utils::{eq_expr_value, get_trait_def_id, snippet_opt, span_lint_and_then, trait_ref_of_method};
 use crate::utils::{higher, sugg};
+use clippy_utils::ty::implements_trait;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
diff --git a/clippy_lints/src/async_yields_async.rs b/clippy_lints/src/async_yields_async.rs
index 869a5c28d05..1e185e97df6 100644
--- a/clippy_lints/src/async_yields_async.rs
+++ b/clippy_lints/src/async_yields_async.rs
@@ -1,4 +1,5 @@
-use crate::utils::{implements_trait, snippet, span_lint_and_then};
+use crate::utils::{snippet, span_lint_and_then};
+use clippy_utils::ty::implements_trait;
 use rustc_errors::Applicability;
 use rustc_hir::{AsyncGeneratorKind, Body, BodyId, ExprKind, GeneratorKind, QPath};
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/blocks_in_if_conditions.rs b/clippy_lints/src/blocks_in_if_conditions.rs
index 59bddb8473b..222bb39f89c 100644
--- a/clippy_lints/src/blocks_in_if_conditions.rs
+++ b/clippy_lints/src/blocks_in_if_conditions.rs
@@ -1,7 +1,7 @@
 use crate::utils::{
-    differing_macro_contexts, get_parent_expr, implements_trait, snippet_block_with_applicability, span_lint,
-    span_lint_and_sugg,
+    differing_macro_contexts, get_parent_expr, snippet_block_with_applicability, span_lint, span_lint_and_sugg,
 };
+use clippy_utils::ty::implements_trait;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
diff --git a/clippy_lints/src/booleans.rs b/clippy_lints/src/booleans.rs
index 0713303ec4b..affc7d2c93f 100644
--- a/clippy_lints/src/booleans.rs
+++ b/clippy_lints/src/booleans.rs
@@ -1,7 +1,7 @@
 use crate::utils::{
-    eq_expr_value, get_trait_def_id, implements_trait, in_macro, is_type_diagnostic_item, paths, snippet_opt,
-    span_lint_and_sugg, span_lint_and_then,
+    eq_expr_value, get_trait_def_id, in_macro, paths, snippet_opt, span_lint_and_sugg, span_lint_and_then,
 };
+use clippy_utils::ty::{implements_trait, is_type_diagnostic_item};
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/bytecount.rs b/clippy_lints/src/bytecount.rs
index eb5dc7ceecd..67cca8dcadb 100644
--- a/clippy_lints/src/bytecount.rs
+++ b/clippy_lints/src/bytecount.rs
@@ -1,6 +1,7 @@
 use crate::utils::{
-    contains_name, get_pat_name, match_type, paths, single_segment_path, snippet_with_applicability, span_lint_and_sugg,
+    contains_name, get_pat_name, paths, single_segment_path, snippet_with_applicability, span_lint_and_sugg,
 };
+use clippy_utils::ty::match_type;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, BorrowKind, Expr, ExprKind, UnOp};
diff --git a/clippy_lints/src/casts/cast_lossless.rs b/clippy_lints/src/casts/cast_lossless.rs
index 478832a5164..902fb423ff1 100644
--- a/clippy_lints/src/casts/cast_lossless.rs
+++ b/clippy_lints/src/casts/cast_lossless.rs
@@ -1,9 +1,10 @@
+use clippy_utils::ty::is_isize_or_usize;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::LateContext;
 use rustc_middle::ty::{self, FloatTy, Ty};
 
-use crate::utils::{in_constant, is_isize_or_usize, snippet_opt, span_lint_and_sugg};
+use crate::utils::{in_constant, snippet_opt, span_lint_and_sugg};
 
 use super::{utils, CAST_LOSSLESS};
 
diff --git a/clippy_lints/src/casts/cast_possible_truncation.rs b/clippy_lints/src/casts/cast_possible_truncation.rs
index 33b06b8fe7c..522ef5348be 100644
--- a/clippy_lints/src/casts/cast_possible_truncation.rs
+++ b/clippy_lints/src/casts/cast_possible_truncation.rs
@@ -1,8 +1,9 @@
+use clippy_utils::ty::is_isize_or_usize;
 use rustc_hir::Expr;
 use rustc_lint::LateContext;
 use rustc_middle::ty::{self, FloatTy, Ty};
 
-use crate::utils::{is_isize_or_usize, span_lint};
+use crate::utils::span_lint;
 
 use super::{utils, CAST_POSSIBLE_TRUNCATION};
 
diff --git a/clippy_lints/src/casts/cast_possible_wrap.rs b/clippy_lints/src/casts/cast_possible_wrap.rs
index 56d301ed3e1..931252415ad 100644
--- a/clippy_lints/src/casts/cast_possible_wrap.rs
+++ b/clippy_lints/src/casts/cast_possible_wrap.rs
@@ -1,8 +1,9 @@
+use clippy_utils::ty::is_isize_or_usize;
 use rustc_hir::Expr;
 use rustc_lint::LateContext;
 use rustc_middle::ty::Ty;
 
-use crate::utils::{is_isize_or_usize, span_lint};
+use crate::utils::span_lint;
 
 use super::{utils, CAST_POSSIBLE_WRAP};
 
diff --git a/clippy_lints/src/casts/cast_precision_loss.rs b/clippy_lints/src/casts/cast_precision_loss.rs
index a1c3900ce1f..b6905c21c78 100644
--- a/clippy_lints/src/casts/cast_precision_loss.rs
+++ b/clippy_lints/src/casts/cast_precision_loss.rs
@@ -1,8 +1,9 @@
+use clippy_utils::ty::is_isize_or_usize;
 use rustc_hir::Expr;
 use rustc_lint::LateContext;
 use rustc_middle::ty::{self, FloatTy, Ty};
 
-use crate::utils::{is_isize_or_usize, span_lint};
+use crate::utils::span_lint;
 
 use super::{utils, CAST_PRECISION_LOSS};
 
diff --git a/clippy_lints/src/cognitive_complexity.rs b/clippy_lints/src/cognitive_complexity.rs
index 658d445dfec..3d842a46813 100644
--- a/clippy_lints/src/cognitive_complexity.rs
+++ b/clippy_lints/src/cognitive_complexity.rs
@@ -1,5 +1,6 @@
 //! calculate cognitive complexity and warn about overly complex functions
 
+use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_ast::ast::Attribute;
 use rustc_hir::intravisit::{walk_expr, FnKind, NestedVisitorMap, Visitor};
 use rustc_hir::{Body, Expr, ExprKind, FnDecl, HirId};
@@ -9,7 +10,7 @@ use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::Span;
 use rustc_span::{sym, BytePos};
 
-use crate::utils::{is_type_diagnostic_item, snippet_opt, span_lint_and_help, LimitStack};
+use crate::utils::{snippet_opt, span_lint_and_help, LimitStack};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for methods with high cognitive complexity.
diff --git a/clippy_lints/src/comparison_chain.rs b/clippy_lints/src/comparison_chain.rs
index e309db25995..9843033a2e0 100644
--- a/clippy_lints/src/comparison_chain.rs
+++ b/clippy_lints/src/comparison_chain.rs
@@ -1,6 +1,5 @@
-use crate::utils::{
-    get_trait_def_id, if_sequence, implements_trait, parent_node_is_if_expr, paths, span_lint_and_help, SpanlessEq,
-};
+use crate::utils::{get_trait_def_id, if_sequence, parent_node_is_if_expr, paths, span_lint_and_help, SpanlessEq};
+use clippy_utils::ty::implements_trait;
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
diff --git a/clippy_lints/src/copy_iterator.rs b/clippy_lints/src/copy_iterator.rs
index 0502f725efb..434d8958da5 100644
--- a/clippy_lints/src/copy_iterator.rs
+++ b/clippy_lints/src/copy_iterator.rs
@@ -1,4 +1,5 @@
-use crate::utils::{is_copy, span_lint_and_note};
+use crate::utils::span_lint_and_note;
+use clippy_utils::ty::is_copy;
 use rustc_hir::{Impl, Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index 40ed6d8d154..8842ea9628d 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -1,4 +1,5 @@
-use crate::utils::{get_parent_node, in_macro, is_allowed, peel_mid_ty_refs, snippet_with_context, span_lint_and_sugg};
+use crate::utils::{get_parent_node, in_macro, is_allowed, snippet_with_context, span_lint_and_sugg};
+use clippy_utils::ty::peel_mid_ty_refs;
 use rustc_ast::util::parser::PREC_PREFIX;
 use rustc_errors::Applicability;
 use rustc_hir::{BorrowKind, Expr, ExprKind, HirId, MatchSource, Mutability, Node, UnOp};
diff --git a/clippy_lints/src/derive.rs b/clippy_lints/src/derive.rs
index 6d3094ed6bf..460fe385272 100644
--- a/clippy_lints/src/derive.rs
+++ b/clippy_lints/src/derive.rs
@@ -1,8 +1,9 @@
 use crate::utils::paths;
 use crate::utils::{
-    get_trait_def_id, is_allowed, is_automatically_derived, is_copy, match_def_path, span_lint_and_help,
-    span_lint_and_note, span_lint_and_then,
+    get_trait_def_id, is_allowed, is_automatically_derived, match_def_path, span_lint_and_help, span_lint_and_note,
+    span_lint_and_then,
 };
+use clippy_utils::ty::is_copy;
 use if_chain::if_chain;
 use rustc_hir::def_id::DefId;
 use rustc_hir::intravisit::{walk_expr, walk_fn, walk_item, FnKind, NestedVisitorMap, Visitor};
diff --git a/clippy_lints/src/doc.rs b/clippy_lints/src/doc.rs
index 90b02d52f8a..4f3c573691e 100644
--- a/clippy_lints/src/doc.rs
+++ b/clippy_lints/src/doc.rs
@@ -1,7 +1,7 @@
 use crate::utils::{
-    implements_trait, is_entrypoint_fn, is_expn_of, is_type_diagnostic_item, match_panic_def_id, method_chain_args,
-    return_ty, span_lint, span_lint_and_note,
+    is_entrypoint_fn, is_expn_of, match_panic_def_id, method_chain_args, return_ty, span_lint, span_lint_and_note,
 };
+use clippy_utils::ty::{implements_trait, is_type_diagnostic_item};
 use if_chain::if_chain;
 use itertools::Itertools;
 use rustc_ast::ast::{Async, AttrKind, Attribute, FnKind, FnRetTy, ItemKind};
diff --git a/clippy_lints/src/drop_forget_ref.rs b/clippy_lints/src/drop_forget_ref.rs
index 2aea00d883c..dd145ba6867 100644
--- a/clippy_lints/src/drop_forget_ref.rs
+++ b/clippy_lints/src/drop_forget_ref.rs
@@ -1,4 +1,5 @@
-use crate::utils::{is_copy, match_def_path, paths, span_lint_and_note};
+use crate::utils::{match_def_path, paths, span_lint_and_note};
+use clippy_utils::ty::is_copy;
 use if_chain::if_chain;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/duration_subsec.rs b/clippy_lints/src/duration_subsec.rs
index c0529a34cc4..c97392e3385 100644
--- a/clippy_lints/src/duration_subsec.rs
+++ b/clippy_lints/src/duration_subsec.rs
@@ -1,3 +1,4 @@
+use clippy_utils::ty::match_type;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind};
@@ -7,7 +8,7 @@ use rustc_span::source_map::Spanned;
 
 use crate::consts::{constant, Constant};
 use crate::utils::paths;
-use crate::utils::{match_type, snippet_with_applicability, span_lint_and_sugg};
+use crate::utils::{snippet_with_applicability, span_lint_and_sugg};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for calculation of subsecond microseconds or milliseconds
diff --git a/clippy_lints/src/entry.rs b/clippy_lints/src/entry.rs
index 55575969927..68363e53f0e 100644
--- a/clippy_lints/src/entry.rs
+++ b/clippy_lints/src/entry.rs
@@ -1,6 +1,7 @@
 use crate::utils::SpanlessEq;
-use crate::utils::{get_item_name, is_type_diagnostic_item, match_type, paths, snippet, snippet_opt};
+use crate::utils::{get_item_name, paths, snippet, snippet_opt};
 use crate::utils::{snippet_with_applicability, span_lint_and_then};
+use clippy_utils::ty::{is_type_diagnostic_item, match_type};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
diff --git a/clippy_lints/src/eq_op.rs b/clippy_lints/src/eq_op.rs
index 6308f6e2e7e..fa19f16074d 100644
--- a/clippy_lints/src/eq_op.rs
+++ b/clippy_lints/src/eq_op.rs
@@ -1,7 +1,8 @@
 use crate::utils::{
-    ast_utils::is_useless_with_eq_exprs, eq_expr_value, higher, implements_trait, in_macro, is_copy, is_expn_of,
-    multispan_sugg, snippet, span_lint, span_lint_and_then,
+    ast_utils::is_useless_with_eq_exprs, eq_expr_value, higher, in_macro, is_expn_of, multispan_sugg, snippet,
+    span_lint, span_lint_and_then,
 };
+use clippy_utils::ty::{implements_trait, is_copy};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, BorrowKind, Expr, ExprKind, StmtKind};
diff --git a/clippy_lints/src/escape.rs b/clippy_lints/src/escape.rs
index f8ef2a464d5..a7258eea0ad 100644
--- a/clippy_lints/src/escape.rs
+++ b/clippy_lints/src/escape.rs
@@ -1,3 +1,4 @@
+use clippy_utils::ty::contains_ty;
 use rustc_hir::intravisit;
 use rustc_hir::{self, AssocItemKind, Body, FnDecl, HirId, HirIdSet, Impl, ItemKind, Node};
 use rustc_infer::infer::TyCtxtInferExt;
@@ -10,7 +11,7 @@ use rustc_target::abi::LayoutOf;
 use rustc_target::spec::abi::Abi;
 use rustc_typeck::expr_use_visitor::{ConsumeMode, Delegate, ExprUseVisitor, PlaceBase, PlaceWithHirId};
 
-use crate::utils::{contains_ty, span_lint};
+use crate::utils::span_lint;
 
 #[derive(Copy, Clone)]
 pub struct BoxedLocal {
diff --git a/clippy_lints/src/eta_reduction.rs b/clippy_lints/src/eta_reduction.rs
index c461732fd36..d93c32c179f 100644
--- a/clippy_lints/src/eta_reduction.rs
+++ b/clippy_lints/src/eta_reduction.rs
@@ -1,3 +1,6 @@
+use clippy_utils::higher;
+use clippy_utils::higher::VecArgs;
+use clippy_utils::ty::{implements_trait, type_is_unsafe_function};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{def_id, Expr, ExprKind, Param, PatKind, QPath};
@@ -6,12 +9,7 @@ use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::{self, Ty};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
-use crate::utils::{
-    implements_trait, is_adjusted, iter_input_pats, snippet_opt, span_lint_and_sugg, span_lint_and_then,
-    type_is_unsafe_function,
-};
-use clippy_utils::higher;
-use clippy_utils::higher::VecArgs;
+use crate::utils::{is_adjusted, iter_input_pats, snippet_opt, span_lint_and_sugg, span_lint_and_then};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for closures which just call another function where
diff --git a/clippy_lints/src/fallible_impl_from.rs b/clippy_lints/src/fallible_impl_from.rs
index f466dddc13c..cc4e570956b 100644
--- a/clippy_lints/src/fallible_impl_from.rs
+++ b/clippy_lints/src/fallible_impl_from.rs
@@ -1,4 +1,5 @@
-use crate::utils::{is_expn_of, is_type_diagnostic_item, match_panic_def_id, method_chain_args, span_lint_and_then};
+use crate::utils::{is_expn_of, match_panic_def_id, method_chain_args, span_lint_and_then};
+use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/format.rs b/clippy_lints/src/format.rs
index fd6bf19db94..b6209f815bc 100644
--- a/clippy_lints/src/format.rs
+++ b/clippy_lints/src/format.rs
@@ -1,8 +1,8 @@
 use crate::utils::paths;
 use crate::utils::{
-    is_expn_of, is_type_diagnostic_item, last_path_segment, match_def_path, match_function_call, snippet, snippet_opt,
-    span_lint_and_then,
+    is_expn_of, last_path_segment, match_def_path, match_function_call, snippet, snippet_opt, span_lint_and_then,
 };
+use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/from_str_radix_10.rs b/clippy_lints/src/from_str_radix_10.rs
index 0933f983014..b92c8ccfb1b 100644
--- a/clippy_lints/src/from_str_radix_10.rs
+++ b/clippy_lints/src/from_str_radix_10.rs
@@ -1,3 +1,4 @@
+use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{def, Expr, ExprKind, PrimTy, QPath, TyKind};
@@ -6,7 +7,6 @@ use rustc_middle::ty::Ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::symbol::sym;
 
-use crate::utils::is_type_diagnostic_item;
 use crate::utils::span_lint_and_sugg;
 use crate::utils::sugg::Sugg;
 
diff --git a/clippy_lints/src/functions.rs b/clippy_lints/src/functions.rs
index c474db06fe3..349cd39ffb6 100644
--- a/clippy_lints/src/functions.rs
+++ b/clippy_lints/src/functions.rs
@@ -1,8 +1,9 @@
 use crate::utils::{
-    attr_by_name, attrs::is_proc_macro, is_must_use_ty, is_trait_impl_item, is_type_diagnostic_item, iter_input_pats,
-    match_def_path, must_use_attr, path_to_local, return_ty, snippet, snippet_opt, span_lint, span_lint_and_help,
-    span_lint_and_then, trait_ref_of_method, type_is_unsafe_function,
+    attr_by_name, attrs::is_proc_macro, is_trait_impl_item, iter_input_pats, match_def_path, must_use_attr,
+    path_to_local, return_ty, snippet, snippet_opt, span_lint, span_lint_and_help, span_lint_and_then,
+    trait_ref_of_method,
 };
+use clippy_utils::ty::{is_must_use_ty, is_type_diagnostic_item, type_is_unsafe_function};
 use if_chain::if_chain;
 use rustc_ast::ast::Attribute;
 use rustc_data_structures::fx::FxHashSet;
diff --git a/clippy_lints/src/get_last_with_len.rs b/clippy_lints/src/get_last_with_len.rs
index cdd8a42e7cd..478008ea48c 100644
--- a/clippy_lints/src/get_last_with_len.rs
+++ b/clippy_lints/src/get_last_with_len.rs
@@ -1,6 +1,7 @@
 //! lint on using `x.get(x.len() - 1)` instead of `x.last()`
 
-use crate::utils::{is_type_diagnostic_item, snippet_with_applicability, span_lint_and_sugg, SpanlessEq};
+use crate::utils::{snippet_with_applicability, span_lint_and_sugg, SpanlessEq};
+use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/if_let_mutex.rs b/clippy_lints/src/if_let_mutex.rs
index 58511c6d57c..f53d1b1cf3b 100644
--- a/clippy_lints/src/if_let_mutex.rs
+++ b/clippy_lints/src/if_let_mutex.rs
@@ -1,4 +1,5 @@
-use crate::utils::{is_type_diagnostic_item, span_lint_and_help, SpanlessEq};
+use crate::utils::{span_lint_and_help, SpanlessEq};
+use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
 use rustc_hir::intravisit::{self as visit, NestedVisitorMap, Visitor};
 use rustc_hir::{Expr, ExprKind, MatchSource};
diff --git a/clippy_lints/src/if_let_some_result.rs b/clippy_lints/src/if_let_some_result.rs
index 1194bd7e55e..0cd44a1c3a0 100644
--- a/clippy_lints/src/if_let_some_result.rs
+++ b/clippy_lints/src/if_let_some_result.rs
@@ -1,4 +1,5 @@
-use crate::utils::{is_type_diagnostic_item, method_chain_args, snippet_with_applicability, span_lint_and_sugg};
+use crate::utils::{method_chain_args, snippet_with_applicability, span_lint_and_sugg};
+use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, MatchSource, PatKind, QPath};
diff --git a/clippy_lints/src/infinite_iter.rs b/clippy_lints/src/infinite_iter.rs
index 7040ac3191f..6bce205ec3a 100644
--- a/clippy_lints/src/infinite_iter.rs
+++ b/clippy_lints/src/infinite_iter.rs
@@ -1,8 +1,9 @@
+use clippy_utils::ty::{implements_trait, match_type};
 use rustc_hir::{BorrowKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
-use crate::utils::{get_trait_def_id, higher, implements_trait, match_qpath, match_type, paths, span_lint};
+use crate::utils::{get_trait_def_id, higher, match_qpath, paths, span_lint};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for iteration that is guaranteed to be infinite.
diff --git a/clippy_lints/src/inherent_to_string.rs b/clippy_lints/src/inherent_to_string.rs
index c1f3e1d9d68..9207413cd69 100644
--- a/clippy_lints/src/inherent_to_string.rs
+++ b/clippy_lints/src/inherent_to_string.rs
@@ -1,13 +1,11 @@
+use clippy_utils::ty::{implements_trait, is_type_diagnostic_item};
 use if_chain::if_chain;
 use rustc_hir::{ImplItem, ImplItemKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::sym;
 
-use crate::utils::{
-    get_trait_def_id, implements_trait, is_type_diagnostic_item, paths, return_ty, span_lint_and_help,
-    trait_ref_of_method,
-};
+use crate::utils::{get_trait_def_id, paths, return_ty, span_lint_and_help, trait_ref_of_method};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for the definition of inherent methods with a signature of `to_string(&self) -> String`.
diff --git a/clippy_lints/src/let_underscore.rs b/clippy_lints/src/let_underscore.rs
index 7e96dfcc7da..2da7137b48b 100644
--- a/clippy_lints/src/let_underscore.rs
+++ b/clippy_lints/src/let_underscore.rs
@@ -1,3 +1,4 @@
+use clippy_utils::ty::{is_must_use_ty, match_type};
 use if_chain::if_chain;
 use rustc_hir::{Local, PatKind};
 use rustc_lint::{LateContext, LateLintPass};
@@ -5,7 +6,7 @@ use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::subst::GenericArgKind;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
-use crate::utils::{is_must_use_func_call, is_must_use_ty, match_type, paths, span_lint_and_help};
+use crate::utils::{is_must_use_func_call, paths, span_lint_and_help};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for `let _ = <expr>`
diff --git a/clippy_lints/src/loops/explicit_iter_loop.rs b/clippy_lints/src/loops/explicit_iter_loop.rs
index 9683e59a396..b70585015ca 100644
--- a/clippy_lints/src/loops/explicit_iter_loop.rs
+++ b/clippy_lints/src/loops/explicit_iter_loop.rs
@@ -1,12 +1,12 @@
 use super::EXPLICIT_ITER_LOOP;
-use crate::utils::{match_trait_method, snippet_with_applicability, span_lint_and_sugg};
+use clippy_utils::ty::{is_type_diagnostic_item, match_type};
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, Mutability};
 use rustc_lint::LateContext;
 use rustc_middle::ty::{self, Ty, TyS};
 use rustc_span::sym;
 
-use crate::utils::{is_type_diagnostic_item, match_type, paths};
+use crate::utils::{match_trait_method, paths, snippet_with_applicability, span_lint_and_sugg};
 
 pub(super) fn check(cx: &LateContext<'_>, args: &[Expr<'_>], arg: &Expr<'_>, method_name: &str) {
     let should_lint = match method_name {
diff --git a/clippy_lints/src/loops/for_kv_map.rs b/clippy_lints/src/loops/for_kv_map.rs
index 6ee9b95a3b6..aef21886803 100644
--- a/clippy_lints/src/loops/for_kv_map.rs
+++ b/clippy_lints/src/loops/for_kv_map.rs
@@ -1,6 +1,7 @@
 use super::FOR_KV_MAP;
 use crate::utils::visitors::LocalUsedVisitor;
-use crate::utils::{is_type_diagnostic_item, match_type, multispan_sugg, paths, snippet, span_lint_and_then, sugg};
+use crate::utils::{multispan_sugg, paths, snippet, span_lint_and_then, sugg};
+use clippy_utils::ty::{is_type_diagnostic_item, match_type};
 use rustc_hir::{BorrowKind, Expr, ExprKind, Mutability, Pat, PatKind};
 use rustc_lint::LateContext;
 use rustc_middle::ty;
diff --git a/clippy_lints/src/loops/for_loops_over_fallibles.rs b/clippy_lints/src/loops/for_loops_over_fallibles.rs
index db22d90a304..063078adcd1 100644
--- a/clippy_lints/src/loops/for_loops_over_fallibles.rs
+++ b/clippy_lints/src/loops/for_loops_over_fallibles.rs
@@ -1,5 +1,6 @@
 use super::FOR_LOOPS_OVER_FALLIBLES;
-use crate::utils::{is_type_diagnostic_item, snippet, span_lint_and_help};
+use crate::utils::{snippet, span_lint_and_help};
+use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_hir::{Expr, Pat};
 use rustc_lint::LateContext;
 use rustc_span::symbol::sym;
diff --git a/clippy_lints/src/loops/manual_memcpy.rs b/clippy_lints/src/loops/manual_memcpy.rs
index fad96c2d5c0..362124c082a 100644
--- a/clippy_lints/src/loops/manual_memcpy.rs
+++ b/clippy_lints/src/loops/manual_memcpy.rs
@@ -1,8 +1,7 @@
 use super::{get_span_of_entire_for_loop, IncrementVisitor, InitializeVisitor, MANUAL_MEMCPY};
 use crate::utils::sugg::Sugg;
-use crate::utils::{
-    get_enclosing_block, higher, is_type_diagnostic_item, path_to_local, snippet, span_lint_and_sugg, sugg,
-};
+use crate::utils::{get_enclosing_block, higher, path_to_local, snippet, span_lint_and_sugg, sugg};
+use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
 use rustc_ast::ast;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/loops/needless_collect.rs b/clippy_lints/src/loops/needless_collect.rs
index f8432abfa8a..f4d3b9eb272 100644
--- a/clippy_lints/src/loops/needless_collect.rs
+++ b/clippy_lints/src/loops/needless_collect.rs
@@ -1,9 +1,7 @@
 use super::NEEDLESS_COLLECT;
 use crate::utils::sugg::Sugg;
-use crate::utils::{
-    is_trait_method, is_type_diagnostic_item, match_type, path_to_local_id, paths, snippet, span_lint_and_sugg,
-    span_lint_and_then,
-};
+use crate::utils::{is_trait_method, path_to_local_id, paths, snippet, span_lint_and_sugg, span_lint_and_then};
+use clippy_utils::ty::{is_type_diagnostic_item, match_type};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_block, walk_expr, NestedVisitorMap, Visitor};
diff --git a/clippy_lints/src/loops/needless_range_loop.rs b/clippy_lints/src/loops/needless_range_loop.rs
index 5f02e4b9d87..6d498149166 100644
--- a/clippy_lints/src/loops/needless_range_loop.rs
+++ b/clippy_lints/src/loops/needless_range_loop.rs
@@ -1,9 +1,10 @@
 use super::NEEDLESS_RANGE_LOOP;
 use crate::utils::visitors::LocalUsedVisitor;
 use crate::utils::{
-    contains_name, has_iter_method, higher, is_integer_const, match_trait_method, multispan_sugg, path_to_local_id,
-    paths, snippet, span_lint_and_then, sugg, SpanlessEq,
+    contains_name, higher, is_integer_const, match_trait_method, multispan_sugg, path_to_local_id, paths, snippet,
+    span_lint_and_then, sugg, SpanlessEq,
 };
+use clippy_utils::ty::has_iter_method;
 use if_chain::if_chain;
 use rustc_ast::ast;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
diff --git a/clippy_lints/src/loops/same_item_push.rs b/clippy_lints/src/loops/same_item_push.rs
index f3585830e4a..f891f7b8a1f 100644
--- a/clippy_lints/src/loops/same_item_push.rs
+++ b/clippy_lints/src/loops/same_item_push.rs
@@ -1,5 +1,6 @@
 use super::SAME_ITEM_PUSH;
-use crate::utils::{implements_trait, is_type_diagnostic_item, snippet_with_macro_callsite, span_lint_and_help};
+use crate::utils::{snippet_with_macro_callsite, span_lint_and_help};
+use clippy_utils::ty::{implements_trait, is_type_diagnostic_item};
 use if_chain::if_chain;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
diff --git a/clippy_lints/src/loops/utils.rs b/clippy_lints/src/loops/utils.rs
index e62b2ab16d1..b85676570b4 100644
--- a/clippy_lints/src/loops/utils.rs
+++ b/clippy_lints/src/loops/utils.rs
@@ -1,6 +1,5 @@
-use crate::utils::{
-    get_parent_expr, has_iter_method, implements_trait, is_integer_const, path_to_local, path_to_local_id, sugg,
-};
+use crate::utils::{get_parent_expr, is_integer_const, path_to_local, path_to_local_id, sugg};
+use clippy_utils::ty::{has_iter_method, implements_trait};
 use if_chain::if_chain;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/loops/while_let_on_iterator.rs b/clippy_lints/src/loops/while_let_on_iterator.rs
index f3b8d0da9cd..619fd1554f0 100644
--- a/clippy_lints/src/loops/while_let_on_iterator.rs
+++ b/clippy_lints/src/loops/while_let_on_iterator.rs
@@ -2,16 +2,16 @@ use super::utils::{LoopNestVisitor, Nesting};
 use super::WHILE_LET_ON_ITERATOR;
 use crate::utils::usage::mutated_variables;
 use crate::utils::{
-    get_enclosing_block, implements_trait, is_refutable, is_trait_method, last_path_segment, path_to_local,
-    path_to_local_id, snippet_with_applicability, span_lint_and_sugg,
+    get_enclosing_block, is_refutable, is_trait_method, last_path_segment, path_to_local, path_to_local_id,
+    snippet_with_applicability, span_lint_and_sugg,
 };
+use clippy_utils::ty::implements_trait;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_block, walk_expr, NestedVisitorMap, Visitor};
 use rustc_hir::{Expr, ExprKind, HirId, MatchSource, Node, PatKind};
 use rustc_lint::LateContext;
 use rustc_middle::hir::map::Map;
-
 use rustc_span::symbol::sym;
 
 pub(super) fn check(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
diff --git a/clippy_lints/src/manual_map.rs b/clippy_lints/src/manual_map.rs
index ea4cedc6754..7c89359f2d9 100644
--- a/clippy_lints/src/manual_map.rs
+++ b/clippy_lints/src/manual_map.rs
@@ -2,11 +2,11 @@ use crate::{
     map_unit_fn::OPTION_MAP_UNIT_FN,
     matches::MATCH_AS_REF,
     utils::{
-        can_partially_move_ty, is_allowed, is_type_diagnostic_item, match_def_path, match_var, paths,
-        peel_hir_expr_refs, peel_mid_ty_refs_is_mutable, snippet_with_applicability, snippet_with_context,
-        span_lint_and_sugg,
+        is_allowed, match_def_path, match_var, paths, peel_hir_expr_refs, snippet_with_applicability,
+        snippet_with_context, span_lint_and_sugg,
     },
 };
+use clippy_utils::ty::{can_partially_move_ty, is_type_diagnostic_item, peel_mid_ty_refs_is_mutable};
 use rustc_ast::util::parser::PREC_POSTFIX;
 use rustc_errors::Applicability;
 use rustc_hir::{
diff --git a/clippy_lints/src/manual_ok_or.rs b/clippy_lints/src/manual_ok_or.rs
index efb05b8ffdf..b08829a8bbf 100644
--- a/clippy_lints/src/manual_ok_or.rs
+++ b/clippy_lints/src/manual_ok_or.rs
@@ -1,7 +1,7 @@
 use crate::utils::{
-    indent_of, is_type_diagnostic_item, match_qpath, path_to_local_id, paths, reindent_multiline, snippet_opt,
-    span_lint_and_sugg,
+    indent_of, match_qpath, path_to_local_id, paths, reindent_multiline, snippet_opt, span_lint_and_sugg,
 };
+use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, PatKind};
diff --git a/clippy_lints/src/manual_unwrap_or.rs b/clippy_lints/src/manual_unwrap_or.rs
index b452225b5db..3a1bde9540d 100644
--- a/clippy_lints/src/manual_unwrap_or.rs
+++ b/clippy_lints/src/manual_unwrap_or.rs
@@ -1,6 +1,7 @@
 use crate::consts::constant_simple;
 use crate::utils;
 use crate::utils::{path_to_local_id, sugg};
+use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Arm, Expr, ExprKind, Pat, PatKind};
@@ -96,9 +97,9 @@ fn lint_manual_unwrap_or<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
     if_chain! {
         if let ExprKind::Match(scrutinee, match_arms, _) = expr.kind;
         let ty = cx.typeck_results().expr_ty(scrutinee);
-        if let Some(case) = if utils::is_type_diagnostic_item(cx, ty, sym::option_type) {
+        if let Some(case) = if is_type_diagnostic_item(cx, ty, sym::option_type) {
             Some(Case::Option)
-        } else if utils::is_type_diagnostic_item(cx, ty, sym::result_type) {
+        } else if is_type_diagnostic_item(cx, ty, sym::result_type) {
             Some(Case::Result)
         } else {
             None
diff --git a/clippy_lints/src/map_clone.rs b/clippy_lints/src/map_clone.rs
index 61cf768bcab..73d924cd51e 100644
--- a/clippy_lints/src/map_clone.rs
+++ b/clippy_lints/src/map_clone.rs
@@ -1,6 +1,6 @@
-use crate::utils::{
-    is_copy, is_trait_method, is_type_diagnostic_item, remove_blocks, snippet_with_applicability, span_lint_and_sugg,
-};
+use crate::utils::is_trait_method;
+use crate::utils::{remove_blocks, snippet_with_applicability, span_lint_and_sugg};
+use clippy_utils::ty::{is_copy, is_type_diagnostic_item};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
diff --git a/clippy_lints/src/map_identity.rs b/clippy_lints/src/map_identity.rs
index 7202a29edd9..79570367ed9 100644
--- a/clippy_lints/src/map_identity.rs
+++ b/clippy_lints/src/map_identity.rs
@@ -1,7 +1,5 @@
-use crate::utils::{
-    is_adjusted, is_trait_method, is_type_diagnostic_item, match_path, match_var, paths, remove_blocks,
-    span_lint_and_sugg,
-};
+use crate::utils::{is_adjusted, is_trait_method, match_path, match_var, paths, remove_blocks, span_lint_and_sugg};
+use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Body, Expr, ExprKind, Pat, PatKind, QPath, StmtKind};
diff --git a/clippy_lints/src/map_unit_fn.rs b/clippy_lints/src/map_unit_fn.rs
index 01126e86199..6f4ce87ea5c 100644
--- a/clippy_lints/src/map_unit_fn.rs
+++ b/clippy_lints/src/map_unit_fn.rs
@@ -1,4 +1,5 @@
-use crate::utils::{is_type_diagnostic_item, iter_input_pats, method_chain_args, snippet, span_lint_and_then};
+use crate::utils::{iter_input_pats, method_chain_args, snippet, span_lint_and_then};
+use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
diff --git a/clippy_lints/src/match_on_vec_items.rs b/clippy_lints/src/match_on_vec_items.rs
index 086dae9422f..65afd691d62 100644
--- a/clippy_lints/src/match_on_vec_items.rs
+++ b/clippy_lints/src/match_on_vec_items.rs
@@ -1,4 +1,5 @@
-use crate::utils::{is_type_diagnostic_item, is_type_lang_item, snippet, span_lint_and_sugg};
+use crate::utils::{snippet, span_lint_and_sugg};
+use clippy_utils::ty::{is_type_diagnostic_item, is_type_lang_item};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, LangItem, MatchSource};
diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index e6c2885eb4d..4689974e850 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -2,13 +2,13 @@ use crate::consts::{constant, miri_to_const, Constant};
 use crate::utils::sugg::Sugg;
 use crate::utils::visitors::LocalUsedVisitor;
 use crate::utils::{
-    expr_block, get_parent_expr, implements_trait, in_macro, indent_of, is_allowed, is_expn_of, is_refutable,
-    is_type_diagnostic_item, is_wild, match_qpath, match_type, meets_msrv, multispan_sugg, path_to_local,
-    path_to_local_id, peel_hir_pat_refs, peel_mid_ty_refs, peel_n_hir_expr_refs, remove_blocks, snippet, snippet_block,
-    snippet_opt, snippet_with_applicability, span_lint_and_help, span_lint_and_note, span_lint_and_sugg,
-    span_lint_and_then, strip_pat_refs,
+    expr_block, get_parent_expr, in_macro, indent_of, is_allowed, is_expn_of, is_refutable, is_wild, match_qpath,
+    meets_msrv, multispan_sugg, path_to_local, path_to_local_id, peel_hir_pat_refs, peel_n_hir_expr_refs,
+    remove_blocks, snippet, snippet_block, snippet_opt, snippet_with_applicability, span_lint_and_help,
+    span_lint_and_note, span_lint_and_sugg, span_lint_and_then, strip_pat_refs,
 };
 use crate::utils::{paths, search_same, SpanlessEq, SpanlessHash};
+use clippy_utils::ty::{implements_trait, is_type_diagnostic_item, match_type, peel_mid_ty_refs};
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
diff --git a/clippy_lints/src/mem_discriminant.rs b/clippy_lints/src/mem_discriminant.rs
index c71c2ee7d70..d9d86ac9912 100644
--- a/clippy_lints/src/mem_discriminant.rs
+++ b/clippy_lints/src/mem_discriminant.rs
@@ -1,10 +1,10 @@
-use crate::utils::{match_def_path, paths, snippet, span_lint_and_then, walk_ptrs_ty_depth};
+use crate::utils::{match_def_path, paths, snippet, span_lint_and_then};
+use clippy_utils::ty::walk_ptrs_ty_depth;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{BorrowKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-
 use std::iter;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/methods/bind_instead_of_map.rs b/clippy_lints/src/methods/bind_instead_of_map.rs
index 5decb81d9f2..073d684dbe3 100644
--- a/clippy_lints/src/methods/bind_instead_of_map.rs
+++ b/clippy_lints/src/methods/bind_instead_of_map.rs
@@ -1,8 +1,9 @@
 use super::{contains_return, BIND_INSTEAD_OF_MAP};
 use crate::utils::{
-    in_macro, match_qpath, match_type, method_calls, multispan_sugg_with_applicability, paths, remove_blocks, snippet,
+    in_macro, match_qpath, method_calls, multispan_sugg_with_applicability, paths, remove_blocks, snippet,
     snippet_with_macro_callsite, span_lint_and_sugg, span_lint_and_then, visitors::find_all_ret_expressions,
 };
+use clippy_utils::ty::match_type;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
diff --git a/clippy_lints/src/methods/bytes_nth.rs b/clippy_lints/src/methods/bytes_nth.rs
index 71a7e195e41..a695c27f11b 100644
--- a/clippy_lints/src/methods/bytes_nth.rs
+++ b/clippy_lints/src/methods/bytes_nth.rs
@@ -1,4 +1,5 @@
-use crate::utils::{is_type_diagnostic_item, snippet_with_applicability, span_lint_and_sugg};
+use crate::utils::{snippet_with_applicability, span_lint_and_sugg};
+use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
diff --git a/clippy_lints/src/methods/clone_on_copy.rs b/clippy_lints/src/methods/clone_on_copy.rs
index 4a130ed47db..954d589a47e 100644
--- a/clippy_lints/src/methods/clone_on_copy.rs
+++ b/clippy_lints/src/methods/clone_on_copy.rs
@@ -1,4 +1,5 @@
-use crate::utils::{is_copy, span_lint_and_then, sugg};
+use crate::utils::{span_lint_and_then, sugg};
+use clippy_utils::ty::is_copy;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
diff --git a/clippy_lints/src/methods/clone_on_ref_ptr.rs b/clippy_lints/src/methods/clone_on_ref_ptr.rs
index 3d5a68d69d7..7bc4ed622dc 100644
--- a/clippy_lints/src/methods/clone_on_ref_ptr.rs
+++ b/clippy_lints/src/methods/clone_on_ref_ptr.rs
@@ -1,4 +1,5 @@
-use crate::utils::{is_type_diagnostic_item, match_type, paths, snippet_with_macro_callsite, span_lint_and_sugg};
+use crate::utils::{paths, snippet_with_macro_callsite, span_lint_and_sugg};
+use clippy_utils::ty::{is_type_diagnostic_item, match_type};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
diff --git a/clippy_lints/src/methods/expect_fun_call.rs b/clippy_lints/src/methods/expect_fun_call.rs
index 6866e9c652a..3de35c930ea 100644
--- a/clippy_lints/src/methods/expect_fun_call.rs
+++ b/clippy_lints/src/methods/expect_fun_call.rs
@@ -1,4 +1,5 @@
-use crate::utils::{is_expn_of, is_type_diagnostic_item, snippet, snippet_with_applicability, span_lint_and_sugg};
+use crate::utils::{is_expn_of, snippet, snippet_with_applicability, span_lint_and_sugg};
+use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
diff --git a/clippy_lints/src/methods/expect_used.rs b/clippy_lints/src/methods/expect_used.rs
index 90b781bd9d1..37c41194b4a 100644
--- a/clippy_lints/src/methods/expect_used.rs
+++ b/clippy_lints/src/methods/expect_used.rs
@@ -1,4 +1,5 @@
-use crate::utils::{is_type_diagnostic_item, span_lint_and_help};
+use crate::utils::span_lint_and_help;
+use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
 use rustc_span::sym;
diff --git a/clippy_lints/src/methods/filetype_is_file.rs b/clippy_lints/src/methods/filetype_is_file.rs
index b03835f97e6..791fe3647cb 100644
--- a/clippy_lints/src/methods/filetype_is_file.rs
+++ b/clippy_lints/src/methods/filetype_is_file.rs
@@ -1,4 +1,5 @@
-use crate::utils::{get_parent_expr, match_type, paths, span_lint_and_help};
+use crate::utils::{get_parent_expr, paths, span_lint_and_help};
+use clippy_utils::ty::match_type;
 use if_chain::if_chain;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
diff --git a/clippy_lints/src/methods/from_iter_instead_of_collect.rs b/clippy_lints/src/methods/from_iter_instead_of_collect.rs
index a5c5bc0e4e2..9b46adaac58 100644
--- a/clippy_lints/src/methods/from_iter_instead_of_collect.rs
+++ b/clippy_lints/src/methods/from_iter_instead_of_collect.rs
@@ -1,4 +1,5 @@
-use crate::utils::{get_trait_def_id, implements_trait, paths, span_lint_and_sugg, sugg};
+use crate::utils::{get_trait_def_id, paths, span_lint_and_sugg, sugg};
+use clippy_utils::ty::implements_trait;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
diff --git a/clippy_lints/src/methods/get_unwrap.rs b/clippy_lints/src/methods/get_unwrap.rs
index e157db2712a..35071a25cec 100644
--- a/clippy_lints/src/methods/get_unwrap.rs
+++ b/clippy_lints/src/methods/get_unwrap.rs
@@ -1,7 +1,6 @@
 use crate::methods::derefs_to_slice;
-use crate::utils::{
-    get_parent_expr, is_type_diagnostic_item, match_type, paths, snippet_with_applicability, span_lint_and_sugg,
-};
+use crate::utils::{get_parent_expr, paths, snippet_with_applicability, span_lint_and_sugg};
+use clippy_utils::ty::{is_type_diagnostic_item, match_type};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
diff --git a/clippy_lints/src/methods/inefficient_to_string.rs b/clippy_lints/src/methods/inefficient_to_string.rs
index 3045b09c238..42ba62cd4e7 100644
--- a/clippy_lints/src/methods/inefficient_to_string.rs
+++ b/clippy_lints/src/methods/inefficient_to_string.rs
@@ -1,7 +1,6 @@
 use super::INEFFICIENT_TO_STRING;
-use crate::utils::{
-    is_type_diagnostic_item, match_def_path, paths, snippet_with_applicability, span_lint_and_then, walk_ptrs_ty_depth,
-};
+use crate::utils::{match_def_path, paths, snippet_with_applicability, span_lint_and_then};
+use clippy_utils::ty::{is_type_diagnostic_item, walk_ptrs_ty_depth};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
diff --git a/clippy_lints/src/methods/into_iter_on_ref.rs b/clippy_lints/src/methods/into_iter_on_ref.rs
index 1e8315dbee2..f28f082e6fc 100644
--- a/clippy_lints/src/methods/into_iter_on_ref.rs
+++ b/clippy_lints/src/methods/into_iter_on_ref.rs
@@ -1,4 +1,5 @@
-use crate::utils::{has_iter_method, match_trait_method, paths, span_lint_and_sugg};
+use crate::utils::{match_trait_method, paths, span_lint_and_sugg};
+use clippy_utils::ty::has_iter_method;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
diff --git a/clippy_lints/src/methods/iter_cloned_collect.rs b/clippy_lints/src/methods/iter_cloned_collect.rs
index c3e48ffa5fa..1e1d3fdcf70 100644
--- a/clippy_lints/src/methods/iter_cloned_collect.rs
+++ b/clippy_lints/src/methods/iter_cloned_collect.rs
@@ -1,5 +1,6 @@
 use crate::methods::derefs_to_slice;
-use crate::utils::{is_type_diagnostic_item, span_lint_and_sugg};
+use crate::utils::span_lint_and_sugg;
+use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
diff --git a/clippy_lints/src/methods/iter_count.rs b/clippy_lints/src/methods/iter_count.rs
index 869440e0165..320fd15d6f8 100644
--- a/clippy_lints/src/methods/iter_count.rs
+++ b/clippy_lints/src/methods/iter_count.rs
@@ -1,6 +1,6 @@
 use crate::methods::derefs_to_slice;
-use crate::utils::{is_type_diagnostic_item, match_type, paths, snippet_with_applicability, span_lint_and_sugg};
-
+use crate::utils::{paths, snippet_with_applicability, span_lint_and_sugg};
+use clippy_utils::ty::{is_type_diagnostic_item, match_type};
 use rustc_errors::Applicability;
 use rustc_hir::Expr;
 use rustc_lint::LateContext;
diff --git a/clippy_lints/src/methods/iter_next_slice.rs b/clippy_lints/src/methods/iter_next_slice.rs
index 3c03a949cfe..736148d4fb8 100644
--- a/clippy_lints/src/methods/iter_next_slice.rs
+++ b/clippy_lints/src/methods/iter_next_slice.rs
@@ -1,5 +1,6 @@
 use crate::methods::derefs_to_slice;
-use crate::utils::{get_parent_expr, higher, is_type_diagnostic_item, snippet_with_applicability, span_lint_and_sugg};
+use crate::utils::{get_parent_expr, higher, snippet_with_applicability, span_lint_and_sugg};
+use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
 use rustc_ast::ast;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/methods/iter_nth.rs b/clippy_lints/src/methods/iter_nth.rs
index cc3e56ea872..17600bb8153 100644
--- a/clippy_lints/src/methods/iter_nth.rs
+++ b/clippy_lints/src/methods/iter_nth.rs
@@ -1,6 +1,7 @@
 use crate::methods::derefs_to_slice;
 use crate::methods::iter_nth_zero;
-use crate::utils::{is_type_diagnostic_item, span_lint_and_help};
+use crate::utils::span_lint_and_help;
+use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
 use rustc_span::symbol::sym;
diff --git a/clippy_lints/src/methods/map_collect_result_unit.rs b/clippy_lints/src/methods/map_collect_result_unit.rs
index 8f4de00a2b7..0a8837be752 100644
--- a/clippy_lints/src/methods/map_collect_result_unit.rs
+++ b/clippy_lints/src/methods/map_collect_result_unit.rs
@@ -1,4 +1,5 @@
-use crate::utils::{is_trait_method, is_type_diagnostic_item, snippet, span_lint_and_sugg};
+use crate::utils::{is_trait_method, snippet, span_lint_and_sugg};
+use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
diff --git a/clippy_lints/src/methods/map_flatten.rs b/clippy_lints/src/methods/map_flatten.rs
index afd76e8b959..3d1c6408dea 100644
--- a/clippy_lints/src/methods/map_flatten.rs
+++ b/clippy_lints/src/methods/map_flatten.rs
@@ -1,4 +1,5 @@
-use crate::utils::{is_trait_method, is_type_diagnostic_item, snippet, span_lint_and_sugg};
+use crate::utils::{is_trait_method, snippet, span_lint_and_sugg};
+use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
diff --git a/clippy_lints/src/methods/map_unwrap_or.rs b/clippy_lints/src/methods/map_unwrap_or.rs
index 63b2cf87f32..4346869ae0d 100644
--- a/clippy_lints/src/methods/map_unwrap_or.rs
+++ b/clippy_lints/src/methods/map_unwrap_or.rs
@@ -1,5 +1,6 @@
 use crate::utils::usage::mutated_variables;
-use crate::utils::{is_type_diagnostic_item, meets_msrv, snippet, span_lint, span_lint_and_sugg};
+use crate::utils::{meets_msrv, snippet, span_lint, span_lint_and_sugg};
+use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 45e906cf468..3e78b662b89 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -52,6 +52,7 @@ mod wrong_self_convention;
 mod zst_offset;
 
 use bind_instead_of_map::BindInsteadOfMap;
+use clippy_utils::ty::{contains_ty, implements_trait, is_copy, is_type_diagnostic_item};
 use if_chain::if_chain;
 use rustc_ast::ast;
 use rustc_errors::Applicability;
@@ -66,9 +67,9 @@ use rustc_span::symbol::{sym, SymbolStr};
 use rustc_typeck::hir_ty_to_ty;
 
 use crate::utils::{
-    contains_return, contains_ty, get_trait_def_id, implements_trait, in_macro, is_copy, is_type_diagnostic_item,
-    iter_input_pats, match_def_path, match_qpath, method_calls, method_chain_args, paths, return_ty,
-    single_segment_path, snippet_with_applicability, span_lint, span_lint_and_help, span_lint_and_sugg, SpanlessEq,
+    contains_return, get_trait_def_id, in_macro, iter_input_pats, match_def_path, match_qpath, method_calls,
+    method_chain_args, paths, return_ty, single_segment_path, snippet_with_applicability, span_lint,
+    span_lint_and_help, span_lint_and_sugg, SpanlessEq,
 };
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/methods/ok_expect.rs b/clippy_lints/src/methods/ok_expect.rs
index c1706cc7cc7..2618d04b242 100644
--- a/clippy_lints/src/methods/ok_expect.rs
+++ b/clippy_lints/src/methods/ok_expect.rs
@@ -1,4 +1,5 @@
-use crate::utils::{implements_trait, is_type_diagnostic_item, span_lint_and_help};
+use crate::utils::span_lint_and_help;
+use clippy_utils::ty::{implements_trait, is_type_diagnostic_item};
 use if_chain::if_chain;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
diff --git a/clippy_lints/src/methods/option_as_ref_deref.rs b/clippy_lints/src/methods/option_as_ref_deref.rs
index 89067dbfe0e..17444336a5e 100644
--- a/clippy_lints/src/methods/option_as_ref_deref.rs
+++ b/clippy_lints/src/methods/option_as_ref_deref.rs
@@ -1,7 +1,5 @@
-use crate::utils::{
-    is_type_diagnostic_item, match_def_path, meets_msrv, path_to_local_id, paths, remove_blocks, snippet,
-    span_lint_and_sugg,
-};
+use crate::utils::{match_def_path, meets_msrv, path_to_local_id, paths, remove_blocks, snippet, span_lint_and_sugg};
+use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
diff --git a/clippy_lints/src/methods/option_map_or_none.rs b/clippy_lints/src/methods/option_map_or_none.rs
index 64f6ebc5062..5bd4a5bfe21 100644
--- a/clippy_lints/src/methods/option_map_or_none.rs
+++ b/clippy_lints/src/methods/option_map_or_none.rs
@@ -1,4 +1,5 @@
-use crate::utils::{is_type_diagnostic_item, match_qpath, paths, snippet, span_lint_and_sugg};
+use crate::utils::{match_qpath, paths, snippet, span_lint_and_sugg};
+use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
diff --git a/clippy_lints/src/methods/option_map_unwrap_or.rs b/clippy_lints/src/methods/option_map_unwrap_or.rs
index 7cdd49bbf03..d1c78b3a833 100644
--- a/clippy_lints/src/methods/option_map_unwrap_or.rs
+++ b/clippy_lints/src/methods/option_map_unwrap_or.rs
@@ -1,5 +1,6 @@
 use crate::utils::{differing_macro_contexts, snippet_with_applicability, span_lint_and_then};
-use crate::utils::{is_copy, is_type_diagnostic_item};
+use clippy_utils::ty::is_copy;
+use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_path, NestedVisitorMap, Visitor};
diff --git a/clippy_lints/src/methods/or_fun_call.rs b/clippy_lints/src/methods/or_fun_call.rs
index 5f7fc431d22..9f24fe79089 100644
--- a/clippy_lints/src/methods/or_fun_call.rs
+++ b/clippy_lints/src/methods/or_fun_call.rs
@@ -1,8 +1,9 @@
 use crate::utils::eager_or_lazy::is_lazyness_candidate;
 use crate::utils::{
-    contains_return, get_trait_def_id, implements_trait, is_type_diagnostic_item, last_path_segment, match_type, paths,
-    snippet, snippet_with_applicability, snippet_with_macro_callsite, span_lint_and_sugg,
+    contains_return, get_trait_def_id, last_path_segment, paths, snippet, snippet_with_applicability,
+    snippet_with_macro_callsite, span_lint_and_sugg,
 };
+use clippy_utils::ty::{implements_trait, is_type_diagnostic_item, match_type};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
diff --git a/clippy_lints/src/methods/search_is_some.rs b/clippy_lints/src/methods/search_is_some.rs
index eb3dc308722..d903f1e74d3 100644
--- a/clippy_lints/src/methods/search_is_some.rs
+++ b/clippy_lints/src/methods/search_is_some.rs
@@ -1,7 +1,7 @@
 use crate::utils::{
-    is_trait_method, is_type_diagnostic_item, snippet, snippet_with_applicability, span_lint_and_help,
-    span_lint_and_sugg, strip_pat_refs,
+    is_trait_method, snippet, snippet_with_applicability, span_lint_and_help, span_lint_and_sugg, strip_pat_refs,
 };
+use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
diff --git a/clippy_lints/src/methods/string_extend_chars.rs b/clippy_lints/src/methods/string_extend_chars.rs
index 0a08ea26175..5b8cca34931 100644
--- a/clippy_lints/src/methods/string_extend_chars.rs
+++ b/clippy_lints/src/methods/string_extend_chars.rs
@@ -1,4 +1,5 @@
-use crate::utils::{is_type_diagnostic_item, method_chain_args, snippet_with_applicability, span_lint_and_sugg};
+use crate::utils::{method_chain_args, snippet_with_applicability, span_lint_and_sugg};
+use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
diff --git a/clippy_lints/src/methods/unnecessary_lazy_eval.rs b/clippy_lints/src/methods/unnecessary_lazy_eval.rs
index a17259d697f..d260a771c01 100644
--- a/clippy_lints/src/methods/unnecessary_lazy_eval.rs
+++ b/clippy_lints/src/methods/unnecessary_lazy_eval.rs
@@ -1,5 +1,6 @@
 use crate::utils::{eager_or_lazy, usage};
-use crate::utils::{is_type_diagnostic_item, snippet, span_lint_and_sugg};
+use crate::utils::{snippet, span_lint_and_sugg};
+use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
diff --git a/clippy_lints/src/methods/unwrap_used.rs b/clippy_lints/src/methods/unwrap_used.rs
index 094c3fc45c4..efe43a6a952 100644
--- a/clippy_lints/src/methods/unwrap_used.rs
+++ b/clippy_lints/src/methods/unwrap_used.rs
@@ -1,4 +1,5 @@
-use crate::utils::{is_type_diagnostic_item, span_lint_and_help};
+use crate::utils::span_lint_and_help;
+use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
 use rustc_span::sym;
diff --git a/clippy_lints/src/methods/useless_asref.rs b/clippy_lints/src/methods/useless_asref.rs
index e4554f8d489..e6b1789a4a8 100644
--- a/clippy_lints/src/methods/useless_asref.rs
+++ b/clippy_lints/src/methods/useless_asref.rs
@@ -1,6 +1,5 @@
-use crate::utils::{
-    get_parent_expr, match_trait_method, paths, snippet_with_applicability, span_lint_and_sugg, walk_ptrs_ty_depth,
-};
+use crate::utils::{get_parent_expr, match_trait_method, paths, snippet_with_applicability, span_lint_and_sugg};
+use clippy_utils::ty::walk_ptrs_ty_depth;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
diff --git a/clippy_lints/src/misc.rs b/clippy_lints/src/misc.rs
index acdc245456b..5c4d4401cd9 100644
--- a/clippy_lints/src/misc.rs
+++ b/clippy_lints/src/misc.rs
@@ -1,3 +1,4 @@
+use clippy_utils::ty::implements_trait;
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
@@ -17,9 +18,9 @@ use rustc_span::symbol::sym;
 use crate::consts::{constant, Constant};
 use crate::utils::sugg::Sugg;
 use crate::utils::{
-    get_item_name, get_parent_expr, higher, implements_trait, in_constant, is_diagnostic_assoc_item, is_integer_const,
-    iter_input_pats, last_path_segment, match_qpath, snippet, snippet_opt, span_lint, span_lint_and_sugg,
-    span_lint_and_then, span_lint_hir_and_then, unsext, SpanlessEq,
+    get_item_name, get_parent_expr, higher, in_constant, is_diagnostic_assoc_item, is_integer_const, iter_input_pats,
+    last_path_segment, match_qpath, snippet, snippet_opt, span_lint, span_lint_and_sugg, span_lint_and_then,
+    span_lint_hir_and_then, unsext, SpanlessEq,
 };
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/missing_const_for_fn.rs b/clippy_lints/src/missing_const_for_fn.rs
index b0998a80128..4cc20b8d38c 100644
--- a/clippy_lints/src/missing_const_for_fn.rs
+++ b/clippy_lints/src/missing_const_for_fn.rs
@@ -1,7 +1,6 @@
 use crate::utils::qualify_min_const_fn::is_min_const_fn;
-use crate::utils::{
-    fn_has_unsatisfiable_preds, has_drop, is_entrypoint_fn, meets_msrv, span_lint, trait_ref_of_method,
-};
+use crate::utils::{fn_has_unsatisfiable_preds, is_entrypoint_fn, meets_msrv, span_lint, trait_ref_of_method};
+use clippy_utils::ty::has_drop;
 use rustc_hir as hir;
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::{Body, Constness, FnDecl, GenericParamKind, HirId};
diff --git a/clippy_lints/src/mut_mutex_lock.rs b/clippy_lints/src/mut_mutex_lock.rs
index df1cecb328c..e4a57661f97 100644
--- a/clippy_lints/src/mut_mutex_lock.rs
+++ b/clippy_lints/src/mut_mutex_lock.rs
@@ -1,4 +1,5 @@
-use crate::utils::{is_type_diagnostic_item, span_lint_and_sugg};
+use crate::utils::span_lint_and_sugg;
+use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, Mutability};
diff --git a/clippy_lints/src/mutex_atomic.rs b/clippy_lints/src/mutex_atomic.rs
index 40b236493a3..9f746ce2e1a 100644
--- a/clippy_lints/src/mutex_atomic.rs
+++ b/clippy_lints/src/mutex_atomic.rs
@@ -2,7 +2,8 @@
 //!
 //! This lint is **warn** by default
 
-use crate::utils::{is_type_diagnostic_item, span_lint};
+use crate::utils::span_lint;
+use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_hir::Expr;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{self, Ty};
diff --git a/clippy_lints/src/needless_pass_by_value.rs b/clippy_lints/src/needless_pass_by_value.rs
index cac4b207511..14989283681 100644
--- a/clippy_lints/src/needless_pass_by_value.rs
+++ b/clippy_lints/src/needless_pass_by_value.rs
@@ -1,8 +1,6 @@
 use crate::utils::ptr::get_spans;
-use crate::utils::{
-    get_trait_def_id, implements_trait, is_copy, is_self, is_type_diagnostic_item, multispan_sugg, paths, snippet,
-    snippet_opt, span_lint_and_then,
-};
+use crate::utils::{get_trait_def_id, is_self, multispan_sugg, paths, snippet, snippet_opt, span_lint_and_then};
+use clippy_utils::ty::{implements_trait, is_copy, is_type_diagnostic_item};
 use if_chain::if_chain;
 use rustc_ast::ast::Attribute;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
diff --git a/clippy_lints/src/needless_question_mark.rs b/clippy_lints/src/needless_question_mark.rs
index a3293f1b361..d616290ee9c 100644
--- a/clippy_lints/src/needless_question_mark.rs
+++ b/clippy_lints/src/needless_question_mark.rs
@@ -1,3 +1,4 @@
+use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_errors::Applicability;
 use rustc_hir::{Body, Expr, ExprKind, LangItem, MatchSource, QPath};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
@@ -175,8 +176,8 @@ fn is_some_or_ok_call<'a>(
             let outer_ty = cx.typeck_results().expr_ty(expr);
 
             // Check if outer and inner type are Option
-            let outer_is_some = utils::is_type_diagnostic_item(cx, outer_ty, sym::option_type);
-            let inner_is_some = utils::is_type_diagnostic_item(cx, inner_ty, sym::option_type);
+            let outer_is_some = is_type_diagnostic_item(cx, outer_ty, sym::option_type);
+            let inner_is_some = is_type_diagnostic_item(cx, inner_ty, sym::option_type);
 
             // Check for Option MSRV
             let meets_option_msrv = utils::meets_msrv(nqml.msrv.as_ref(), &NEEDLESS_QUESTION_MARK_OPTION_MSRV);
@@ -185,8 +186,8 @@ fn is_some_or_ok_call<'a>(
             }
 
             // Check if outer and inner type are Result
-            let outer_is_result = utils::is_type_diagnostic_item(cx, outer_ty, sym::result_type);
-            let inner_is_result = utils::is_type_diagnostic_item(cx, inner_ty, sym::result_type);
+            let outer_is_result = is_type_diagnostic_item(cx, outer_ty, sym::result_type);
+            let inner_is_result = is_type_diagnostic_item(cx, inner_ty, sym::result_type);
 
             // Additional check: if the error type of the Result can be converted
             // via the From trait, then don't match
diff --git a/clippy_lints/src/neg_cmp_op_on_partial_ord.rs b/clippy_lints/src/neg_cmp_op_on_partial_ord.rs
index ec0ad58ca9c..67d49f06ad9 100644
--- a/clippy_lints/src/neg_cmp_op_on_partial_ord.rs
+++ b/clippy_lints/src/neg_cmp_op_on_partial_ord.rs
@@ -1,3 +1,4 @@
+use clippy_utils::ty::implements_trait;
 use if_chain::if_chain;
 use rustc_hir::{BinOpKind, Expr, ExprKind, UnOp};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
@@ -60,7 +61,7 @@ impl<'tcx> LateLintPass<'tcx> for NoNegCompOpForPartialOrd {
 
                 let implements_ord = {
                     if let Some(id) = utils::get_trait_def_id(cx, &paths::ORD) {
-                        utils::implements_trait(cx, ty, id, &[])
+                        implements_trait(cx, ty, id, &[])
                     } else {
                         return;
                     }
@@ -68,7 +69,7 @@ impl<'tcx> LateLintPass<'tcx> for NoNegCompOpForPartialOrd {
 
                 let implements_partial_ord = {
                     if let Some(id) = cx.tcx.lang_items().partial_ord_trait() {
-                        utils::implements_trait(cx, ty, id, &[])
+                        implements_trait(cx, ty, id, &[])
                     } else {
                         return;
                     }
diff --git a/clippy_lints/src/no_effect.rs b/clippy_lints/src/no_effect.rs
index 69302d695ce..c377d373ad6 100644
--- a/clippy_lints/src/no_effect.rs
+++ b/clippy_lints/src/no_effect.rs
@@ -1,4 +1,5 @@
-use crate::utils::{has_drop, snippet_opt, span_lint, span_lint_and_sugg};
+use crate::utils::{snippet_opt, span_lint, span_lint_and_sugg};
+use clippy_utils::ty::has_drop;
 use rustc_errors::Applicability;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::{BinOpKind, BlockCheckMode, Expr, ExprKind, Stmt, StmtKind, UnsafeSource};
diff --git a/clippy_lints/src/open_options.rs b/clippy_lints/src/open_options.rs
index 07ca196990d..71e77932f7a 100644
--- a/clippy_lints/src/open_options.rs
+++ b/clippy_lints/src/open_options.rs
@@ -1,4 +1,5 @@
-use crate::utils::{match_type, paths, span_lint};
+use crate::utils::{paths, span_lint};
+use clippy_utils::ty::match_type;
 use rustc_ast::ast::LitKind;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/option_if_let_else.rs b/clippy_lints/src/option_if_let_else.rs
index 9ef0d267b0b..8a6d257848f 100644
--- a/clippy_lints/src/option_if_let_else.rs
+++ b/clippy_lints/src/option_if_let_else.rs
@@ -1,7 +1,8 @@
 use crate::utils;
 use crate::utils::eager_or_lazy;
 use crate::utils::sugg::Sugg;
-use crate::utils::{is_type_diagnostic_item, paths, span_lint_and_sugg};
+use crate::utils::{paths, span_lint_and_sugg};
+use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
 
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/panic_in_result_fn.rs b/clippy_lints/src/panic_in_result_fn.rs
index 207423a1861..1821e2611ff 100644
--- a/clippy_lints/src/panic_in_result_fn.rs
+++ b/clippy_lints/src/panic_in_result_fn.rs
@@ -1,4 +1,5 @@
-use crate::utils::{find_macro_calls, is_type_diagnostic_item, return_ty, span_lint_and_then};
+use crate::utils::{find_macro_calls, return_ty, span_lint_and_then};
+use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_hir as hir;
 use rustc_hir::intravisit::FnKind;
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/pass_by_ref_or_value.rs b/clippy_lints/src/pass_by_ref_or_value.rs
index ff700aa5146..c9b59b89306 100644
--- a/clippy_lints/src/pass_by_ref_or_value.rs
+++ b/clippy_lints/src/pass_by_ref_or_value.rs
@@ -1,6 +1,7 @@
 use std::cmp;
 
-use crate::utils::{is_copy, is_self_ty, snippet, span_lint_and_sugg};
+use crate::utils::{is_self_ty, snippet, span_lint_and_sugg};
+use clippy_utils::ty::is_copy;
 use if_chain::if_chain;
 use rustc_ast::attr;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/path_buf_push_overwrite.rs b/clippy_lints/src/path_buf_push_overwrite.rs
index 4a7b0ad07aa..46533682d42 100644
--- a/clippy_lints/src/path_buf_push_overwrite.rs
+++ b/clippy_lints/src/path_buf_push_overwrite.rs
@@ -1,4 +1,5 @@
-use crate::utils::{is_type_diagnostic_item, span_lint_and_sugg};
+use crate::utils::span_lint_and_sugg;
+use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs
index 6ea2d8b06d8..c2649a135eb 100644
--- a/clippy_lints/src/ptr.rs
+++ b/clippy_lints/src/ptr.rs
@@ -1,10 +1,8 @@
 //! Checks for usage of  `&Vec[_]` and `&String`.
 
 use crate::utils::ptr::get_spans;
-use crate::utils::{
-    is_allowed, is_type_diagnostic_item, match_qpath, match_type, paths, snippet_opt, span_lint, span_lint_and_sugg,
-    span_lint_and_then, walk_ptrs_hir_ty,
-};
+use crate::utils::{is_allowed, match_qpath, paths, snippet_opt, span_lint, span_lint_and_sugg, span_lint_and_then};
+use clippy_utils::ty::{is_type_diagnostic_item, match_type, walk_ptrs_hir_ty};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{
diff --git a/clippy_lints/src/question_mark.rs b/clippy_lints/src/question_mark.rs
index 6c480d48c75..dc00aaffa58 100644
--- a/clippy_lints/src/question_mark.rs
+++ b/clippy_lints/src/question_mark.rs
@@ -1,3 +1,4 @@
+use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::def::{DefKind, Res};
@@ -7,10 +8,7 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::sym;
 
 use crate::utils::sugg::Sugg;
-use crate::utils::{
-    eq_expr_value, is_type_diagnostic_item, match_def_path, match_qpath, paths, snippet_with_applicability,
-    span_lint_and_sugg,
-};
+use crate::utils::{eq_expr_value, match_def_path, match_qpath, paths, snippet_with_applicability, span_lint_and_sugg};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for expressions that could be replaced by the question mark operator.
diff --git a/clippy_lints/src/redundant_clone.rs b/clippy_lints/src/redundant_clone.rs
index c57e1d0ba77..d2e5a5db372 100644
--- a/clippy_lints/src/redundant_clone.rs
+++ b/clippy_lints/src/redundant_clone.rs
@@ -1,7 +1,7 @@
 use crate::utils::{
-    fn_has_unsatisfiable_preds, has_drop, is_copy, is_type_diagnostic_item, match_def_path, paths, snippet_opt,
-    span_lint_hir, span_lint_hir_and_then, walk_ptrs_ty_depth,
+    fn_has_unsatisfiable_preds, match_def_path, paths, snippet_opt, span_lint_hir, span_lint_hir_and_then,
 };
+use clippy_utils::ty::{has_drop, is_copy, is_type_diagnostic_item, walk_ptrs_ty_depth};
 use if_chain::if_chain;
 use rustc_data_structures::{fx::FxHashMap, transitive_relation::TransitiveRelation};
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/redundant_slicing.rs b/clippy_lints/src/redundant_slicing.rs
index e5ced13514f..992d1901584 100644
--- a/clippy_lints/src/redundant_slicing.rs
+++ b/clippy_lints/src/redundant_slicing.rs
@@ -1,3 +1,4 @@
+use clippy_utils::ty::is_type_lang_item;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, LangItem};
@@ -5,7 +6,7 @@ use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::{lint::in_external_macro, ty::TyS};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
-use crate::utils::{is_type_lang_item, snippet_with_applicability, span_lint_and_sugg};
+use crate::utils::{snippet_with_applicability, span_lint_and_sugg};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for redundant slicing expressions which use the full range, and
diff --git a/clippy_lints/src/repeat_once.rs b/clippy_lints/src/repeat_once.rs
index d34e744eb94..7d668739c5a 100644
--- a/clippy_lints/src/repeat_once.rs
+++ b/clippy_lints/src/repeat_once.rs
@@ -1,5 +1,6 @@
 use crate::consts::{constant_context, Constant};
-use crate::utils::{in_macro, is_type_diagnostic_item, snippet, span_lint_and_sugg};
+use crate::utils::{in_macro, snippet, span_lint_and_sugg};
+use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
diff --git a/clippy_lints/src/strings.rs b/clippy_lints/src/strings.rs
index 31dd5965473..62b4b40df45 100644
--- a/clippy_lints/src/strings.rs
+++ b/clippy_lints/src/strings.rs
@@ -1,3 +1,10 @@
+use crate::utils::SpanlessEq;
+use crate::utils::{
+    get_parent_expr, is_allowed, match_function_call, method_calls, paths, span_lint, span_lint_and_help,
+    span_lint_and_sugg,
+};
+use clippy_utils::ty::is_type_diagnostic_item;
+use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, BorrowKind, Expr, ExprKind, LangItem, QPath};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
@@ -7,14 +14,6 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Spanned;
 use rustc_span::sym;
 
-use if_chain::if_chain;
-
-use crate::utils::SpanlessEq;
-use crate::utils::{
-    get_parent_expr, is_allowed, is_type_diagnostic_item, match_function_call, method_calls, paths, span_lint,
-    span_lint_and_help, span_lint_and_sugg,
-};
-
 declare_clippy_lint! {
     /// **What it does:** Checks for string appends of the form `x = x + y` (without
     /// `let`!).
diff --git a/clippy_lints/src/swap.rs b/clippy_lints/src/swap.rs
index 9d8a0c24833..ba2d73a8228 100644
--- a/clippy_lints/src/swap.rs
+++ b/clippy_lints/src/swap.rs
@@ -1,7 +1,6 @@
 use crate::utils::sugg::Sugg;
-use crate::utils::{
-    differing_macro_contexts, eq_expr_value, is_type_diagnostic_item, snippet_with_applicability, span_lint_and_then,
-};
+use crate::utils::{differing_macro_contexts, eq_expr_value, snippet_with_applicability, span_lint_and_then};
+use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Block, Expr, ExprKind, PatKind, QPath, StmtKind};
diff --git a/clippy_lints/src/transmute/utils.rs b/clippy_lints/src/transmute/utils.rs
index 55008d8ec3f..f4b0f205993 100644
--- a/clippy_lints/src/transmute/utils.rs
+++ b/clippy_lints/src/transmute/utils.rs
@@ -1,4 +1,5 @@
-use crate::utils::{is_normalizable, last_path_segment, snippet};
+use crate::utils::{last_path_segment, snippet};
+use clippy_utils::ty::is_normalizable;
 use if_chain::if_chain;
 use rustc_hir::{Expr, GenericArg, QPath, TyKind};
 use rustc_lint::LateContext;
diff --git a/clippy_lints/src/try_err.rs b/clippy_lints/src/try_err.rs
index 73e3a04aec9..bdb81ea32d7 100644
--- a/clippy_lints/src/try_err.rs
+++ b/clippy_lints/src/try_err.rs
@@ -1,7 +1,8 @@
 use crate::utils::{
-    differing_macro_contexts, in_macro, is_type_diagnostic_item, match_def_path, match_qpath, paths, snippet,
-    snippet_with_macro_callsite, span_lint_and_sugg,
+    differing_macro_contexts, in_macro, match_def_path, match_qpath, paths, snippet, snippet_with_macro_callsite,
+    span_lint_and_sugg,
 };
+use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, LangItem, MatchSource, QPath};
diff --git a/clippy_lints/src/types/mod.rs b/clippy_lints/src/types/mod.rs
index 13da768b0ca..fcd38718b9b 100644
--- a/clippy_lints/src/types/mod.rs
+++ b/clippy_lints/src/types/mod.rs
@@ -13,6 +13,7 @@ use std::borrow::Cow;
 use std::cmp::Ordering;
 use std::collections::BTreeMap;
 
+use clippy_utils::ty::{is_isize_or_usize, is_type_diagnostic_item};
 use if_chain::if_chain;
 use rustc_errors::{Applicability, DiagnosticBuilder};
 use rustc_hir as hir;
@@ -37,9 +38,9 @@ use rustc_typeck::hir_ty_to_ty;
 use crate::consts::{constant, Constant};
 use crate::utils::paths;
 use crate::utils::{
-    clip, comparisons, differing_macro_contexts, higher, indent_of, int_bits, is_isize_or_usize,
-    is_type_diagnostic_item, match_path, multispan_sugg, reindent_multiline, sext, snippet, snippet_opt,
-    snippet_with_macro_callsite, span_lint, span_lint_and_help, span_lint_and_then, unsext,
+    clip, comparisons, differing_macro_contexts, higher, indent_of, int_bits, match_path, multispan_sugg,
+    reindent_multiline, sext, snippet, snippet_opt, snippet_with_macro_callsite, span_lint, span_lint_and_help,
+    span_lint_and_then, unsext,
 };
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/undropped_manually_drops.rs b/clippy_lints/src/undropped_manually_drops.rs
index 5443f1601fc..8c34ca16e6f 100644
--- a/clippy_lints/src/undropped_manually_drops.rs
+++ b/clippy_lints/src/undropped_manually_drops.rs
@@ -1,4 +1,5 @@
-use crate::utils::{is_type_lang_item, match_function_call, paths, span_lint_and_help};
+use crate::utils::{match_function_call, paths, span_lint_and_help};
+use clippy_utils::ty::is_type_lang_item;
 use rustc_hir::{lang_items, Expr};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
diff --git a/clippy_lints/src/unnecessary_sort_by.rs b/clippy_lints/src/unnecessary_sort_by.rs
index 00a707107bc..7e385b00646 100644
--- a/clippy_lints/src/unnecessary_sort_by.rs
+++ b/clippy_lints/src/unnecessary_sort_by.rs
@@ -1,5 +1,6 @@
 use crate::utils;
 use crate::utils::sugg::Sugg;
+use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, Mutability, Param, Pat, PatKind, Path, PathSegment, QPath};
@@ -176,7 +177,7 @@ fn detect_lint(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<LintTrigger> {
         if let name = name_ident.ident.name.to_ident_string();
         if name == "sort_by" || name == "sort_unstable_by";
         if let [vec, Expr { kind: ExprKind::Closure(_, _, closure_body_id, _, _), .. }] = args;
-        if utils::is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(vec), sym::vec_type);
+        if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(vec), sym::vec_type);
         if let closure_body = cx.tcx.hir().body(*closure_body_id);
         if let &[
             Param { pat: Pat { kind: PatKind::Binding(_, _, left_ident, _), .. }, ..},
diff --git a/clippy_lints/src/unwrap.rs b/clippy_lints/src/unwrap.rs
index 2fb0463c5a6..43b5f138a42 100644
--- a/clippy_lints/src/unwrap.rs
+++ b/clippy_lints/src/unwrap.rs
@@ -1,6 +1,5 @@
-use crate::utils::{
-    differing_macro_contexts, is_type_diagnostic_item, span_lint_and_then, usage::is_potentially_mutated,
-};
+use crate::utils::{differing_macro_contexts, span_lint_and_then, usage::is_potentially_mutated};
+use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
 use rustc_hir::intravisit::{walk_expr, walk_fn, FnKind, NestedVisitorMap, Visitor};
 use rustc_hir::{BinOpKind, Body, Expr, ExprKind, FnDecl, HirId, Path, QPath, UnOp};
diff --git a/clippy_lints/src/unwrap_in_result.rs b/clippy_lints/src/unwrap_in_result.rs
index 8cb7429849d..6a8f8211566 100644
--- a/clippy_lints/src/unwrap_in_result.rs
+++ b/clippy_lints/src/unwrap_in_result.rs
@@ -1,6 +1,9 @@
-use crate::utils::{is_type_diagnostic_item, method_chain_args, return_ty, span_lint_and_then};
+use crate::utils::{method_chain_args, return_ty, span_lint_and_then};
+use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
 use rustc_hir as hir;
+use rustc_hir::intravisit::{self, NestedVisitorMap, Visitor};
+use rustc_hir::{Expr, ImplItemKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::map::Map;
 use rustc_middle::ty;
@@ -66,9 +69,6 @@ impl<'tcx> LateLintPass<'tcx> for UnwrapInResult {
     }
 }
 
-use rustc_hir::intravisit::{self, NestedVisitorMap, Visitor};
-use rustc_hir::{Expr, ImplItemKind};
-
 struct FindExpectUnwrap<'a, 'tcx> {
     lcx: &'a LateContext<'tcx>,
     typeck_results: &'tcx ty::TypeckResults<'tcx>,
diff --git a/clippy_lints/src/useless_conversion.rs b/clippy_lints/src/useless_conversion.rs
index c5334853986..23032c74f9a 100644
--- a/clippy_lints/src/useless_conversion.rs
+++ b/clippy_lints/src/useless_conversion.rs
@@ -1,8 +1,9 @@
 use crate::utils::sugg::Sugg;
 use crate::utils::{
-    get_parent_expr, is_type_diagnostic_item, match_def_path, match_trait_method, paths, snippet,
-    snippet_with_macro_callsite, span_lint_and_help, span_lint_and_sugg,
+    get_parent_expr, match_def_path, match_trait_method, paths, snippet, snippet_with_macro_callsite,
+    span_lint_and_help, span_lint_and_sugg,
 };
+use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, HirId, MatchSource};
diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs
index 0a347516c3a..2f4bc74ef64 100644
--- a/clippy_lints/src/utils/internal_lints.rs
+++ b/clippy_lints/src/utils/internal_lints.rs
@@ -1,8 +1,9 @@
 use crate::consts::{constant_simple, Constant};
 use crate::utils::{
-    is_expn_of, match_def_path, match_qpath, match_type, method_calls, path_to_res, paths, run_lints, snippet,
-    span_lint, span_lint_and_help, span_lint_and_sugg, SpanlessEq,
+    is_expn_of, match_def_path, match_qpath, method_calls, path_to_res, paths, run_lints, snippet, span_lint,
+    span_lint_and_help, span_lint_and_sugg, SpanlessEq,
 };
+use clippy_utils::ty::match_type;
 use if_chain::if_chain;
 use rustc_ast::ast::{Crate as AstCrate, ItemKind, LitKind, ModKind, NodeId};
 use rustc_ast::visit::FnKind;
diff --git a/clippy_lints/src/vec.rs b/clippy_lints/src/vec.rs
index c132e4de4f6..682cc35a7d7 100644
--- a/clippy_lints/src/vec.rs
+++ b/clippy_lints/src/vec.rs
@@ -1,6 +1,7 @@
 use crate::consts::{constant, Constant};
 use crate::rustc_target::abi::LayoutOf;
-use crate::utils::{higher, is_copy, snippet_with_applicability, span_lint_and_sugg};
+use crate::utils::{higher, snippet_with_applicability, span_lint_and_sugg};
+use clippy_utils::ty::is_copy;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{BorrowKind, Expr, ExprKind};
diff --git a/clippy_lints/src/vec_init_then_push.rs b/clippy_lints/src/vec_init_then_push.rs
index 8d111f98add..b3262a253e7 100644
--- a/clippy_lints/src/vec_init_then_push.rs
+++ b/clippy_lints/src/vec_init_then_push.rs
@@ -1,6 +1,5 @@
-use crate::utils::{
-    is_type_diagnostic_item, match_def_path, path_to_local, path_to_local_id, paths, snippet, span_lint_and_sugg,
-};
+use crate::utils::{match_def_path, path_to_local, path_to_local_id, paths, snippet, span_lint_and_sugg};
+use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/verbose_file_reads.rs b/clippy_lints/src/verbose_file_reads.rs
index 32574d9d6c9..079a4279c60 100644
--- a/clippy_lints/src/verbose_file_reads.rs
+++ b/clippy_lints/src/verbose_file_reads.rs
@@ -1,4 +1,5 @@
-use crate::utils::{match_type, paths, span_lint_and_help};
+use crate::utils::{paths, span_lint_and_help};
+use clippy_utils::ty::match_type;
 use if_chain::if_chain;
 use rustc_hir::{Expr, ExprKind, QPath};
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/zero_sized_map_values.rs b/clippy_lints/src/zero_sized_map_values.rs
index adf7077e650..ab27b60cfa4 100644
--- a/clippy_lints/src/zero_sized_map_values.rs
+++ b/clippy_lints/src/zero_sized_map_values.rs
@@ -1,3 +1,4 @@
+use clippy_utils::ty::{is_normalizable, is_type_diagnostic_item, match_type};
 use if_chain::if_chain;
 use rustc_hir::{self as hir, HirId, ItemKind, Node};
 use rustc_lint::{LateContext, LateLintPass};
@@ -7,7 +8,7 @@ use rustc_span::sym;
 use rustc_target::abi::LayoutOf as _;
 use rustc_typeck::hir_ty_to_ty;
 
-use crate::utils::{is_normalizable, is_type_diagnostic_item, match_type, paths, span_lint_and_help};
+use crate::utils::{paths, span_lint_and_help};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for maps with zero-sized value types anywhere in the code.
diff --git a/clippy_utils/src/eager_or_lazy.rs b/clippy_utils/src/eager_or_lazy.rs
index 8013c4e4fcb..88b115a63d7 100644
--- a/clippy_utils/src/eager_or_lazy.rs
+++ b/clippy_utils/src/eager_or_lazy.rs
@@ -9,7 +9,8 @@
 //!  - or-fun-call
 //!  - option-if-let-else
 
-use crate::{is_ctor_or_promotable_const_function, is_type_diagnostic_item};
+use crate::is_ctor_or_promotable_const_function;
+use crate::ty::is_type_diagnostic_item;
 use rustc_hir::def::{DefKind, Res};
 
 use rustc_hir::intravisit;
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 5b2529b4930..366962d8b77 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -42,6 +42,7 @@ pub mod paths;
 pub mod ptr;
 pub mod qualify_min_const_fn;
 pub mod sugg;
+pub mod ty;
 pub mod usage;
 pub mod visitors;
 
@@ -54,7 +55,7 @@ use std::collections::hash_map::Entry;
 use std::hash::BuildHasherDefault;
 
 use if_chain::if_chain;
-use rustc_ast::ast::{self, Attribute, BorrowKind, LitKind, Mutability};
+use rustc_ast::ast::{self, Attribute, BorrowKind, LitKind};
 use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
@@ -65,14 +66,13 @@ use rustc_hir::{
     def, Arm, BindingAnnotation, Block, Body, Constness, CrateItem, Expr, ExprKind, FnDecl, ForeignItem, GenericArgs,
     GenericParam, HirId, Impl, ImplItem, ImplItemKind, Item, ItemKind, LangItem, Lifetime, Local, MacroDef,
     MatchSource, Node, Param, Pat, PatKind, Path, PathSegment, QPath, Stmt, StructField, TraitItem, TraitItemKind,
-    TraitRef, TyKind, Unsafety, Variant, Visibility,
+    TraitRef, TyKind, Variant, Visibility,
 };
-use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::{LateContext, Level, Lint, LintContext};
 use rustc_middle::hir::exports::Export;
 use rustc_middle::hir::map::Map;
-use rustc_middle::ty::subst::{GenericArg, GenericArgKind};
-use rustc_middle::ty::{self, layout::IntegerExt, DefIdTree, IntTy, Ty, TyCtxt, TypeFoldable, UintTy};
+use rustc_middle::ty as rustc_ty;
+use rustc_middle::ty::{layout::IntegerExt, DefIdTree, Ty, TyCtxt, TypeFoldable};
 use rustc_semver::RustcVersion;
 use rustc_session::Session;
 use rustc_span::hygiene::{self, ExpnKind, MacroKind};
@@ -81,11 +81,10 @@ use rustc_span::sym;
 use rustc_span::symbol::{kw, Ident, Symbol};
 use rustc_span::{BytePos, Pos, Span, SyntaxContext, DUMMY_SP};
 use rustc_target::abi::Integer;
-use rustc_trait_selection::traits::query::normalize::AtExt;
 use smallvec::SmallVec;
 
 use crate::consts::{constant, Constant};
-use std::collections::HashMap;
+use crate::ty::is_recursively_primitive_type;
 
 pub fn parse_msrv(msrv: &str, sess: Option<&Session>, span: Option<Span>) -> Option<RustcVersion> {
     if let Ok(version) = RustcVersion::parse(msrv) {
@@ -256,35 +255,6 @@ pub fn is_wild<'tcx>(pat: &impl std::ops::Deref<Target = Pat<'tcx>>) -> bool {
     matches!(pat.kind, PatKind::Wild)
 }
 
-/// Checks if type is struct, enum or union type with the given def path.
-///
-/// If the type is a diagnostic item, use `is_type_diagnostic_item` instead.
-/// If you change the signature, remember to update the internal lint `MatchTypeOnDiagItem`
-pub fn match_type(cx: &LateContext<'_>, ty: Ty<'_>, path: &[&str]) -> bool {
-    match ty.kind() {
-        ty::Adt(adt, _) => match_def_path(cx, adt.did, path),
-        _ => false,
-    }
-}
-
-/// Checks if the type is equal to a diagnostic item
-///
-/// If you change the signature, remember to update the internal lint `MatchTypeOnDiagItem`
-pub fn is_type_diagnostic_item(cx: &LateContext<'_>, ty: Ty<'_>, diag_item: Symbol) -> bool {
-    match ty.kind() {
-        ty::Adt(adt, _) => cx.tcx.is_diagnostic_item(diag_item, adt.did),
-        _ => false,
-    }
-}
-
-/// Checks if the type is equal to a lang item
-pub fn is_type_lang_item(cx: &LateContext<'_>, ty: Ty<'_>, lang_item: hir::LangItem) -> bool {
-    match ty.kind() {
-        ty::Adt(adt, _) => cx.tcx.lang_items().require(lang_item).unwrap() == adt.did,
-        _ => false,
-    }
-}
-
 /// Checks if the first type parameter is a lang item.
 pub fn is_ty_param_lang_item(cx: &LateContext<'_>, qpath: &QPath<'tcx>, item: LangItem) -> Option<&'tcx hir::Ty<'tcx>> {
     let ty = get_qpath_generic_tys(qpath).next()?;
@@ -319,11 +289,6 @@ pub fn is_ty_param_diagnostic_item(
     }
 }
 
-/// Return `true` if the passed `typ` is `isize` or `usize`.
-pub fn is_isize_or_usize(typ: Ty<'_>) -> bool {
-    matches!(typ.kind(), ty::Int(IntTy::Isize) | ty::Uint(UintTy::Usize))
-}
-
 /// Checks if the method call given in `expr` belongs to the given trait.
 /// This is a deprecated function, consider using [`is_trait_method`].
 pub fn match_trait_method(cx: &LateContext<'_>, expr: &Expr<'_>, path: &[&str]) -> bool {
@@ -338,10 +303,10 @@ pub fn is_diagnostic_assoc_item(cx: &LateContext<'_>, def_id: DefId, diag_item:
     cx.tcx
         .opt_associated_item(def_id)
         .and_then(|associated_item| match associated_item.container {
-            ty::TraitContainer(assoc_def_id) => Some(assoc_def_id),
-            ty::ImplContainer(assoc_def_id) => match cx.tcx.type_of(assoc_def_id).kind() {
-                ty::Adt(adt, _) => Some(adt.did),
-                ty::Slice(_) => cx.tcx.get_diagnostic_item(sym::slice), // this isn't perfect but it works
+            rustc_ty::TraitContainer(assoc_def_id) => Some(assoc_def_id),
+            rustc_ty::ImplContainer(assoc_def_id) => match cx.tcx.type_of(assoc_def_id).kind() {
+                rustc_ty::Adt(adt, _) => Some(adt.did),
+                rustc_ty::Slice(_) => cx.tcx.get_diagnostic_item(sym::slice), // this isn't perfect but it works
                 _ => None,
             },
         })
@@ -540,26 +505,6 @@ pub fn get_trait_def_id(cx: &LateContext<'_>, path: &[&str]) -> Option<DefId> {
     }
 }
 
-/// Checks whether a type implements a trait.
-/// See also `get_trait_def_id`.
-pub fn implements_trait<'tcx>(
-    cx: &LateContext<'tcx>,
-    ty: Ty<'tcx>,
-    trait_id: DefId,
-    ty_params: &[GenericArg<'tcx>],
-) -> bool {
-    // Do not check on infer_types to avoid panic in evaluate_obligation.
-    if ty.has_infer_types() {
-        return false;
-    }
-    let ty = cx.tcx.erase_regions(ty);
-    if ty.has_escaping_bound_vars() {
-        return false;
-    }
-    let ty_params = cx.tcx.mk_substs(ty_params.iter());
-    cx.tcx.type_implements_trait((trait_id, ty, ty_params, cx.param_env))
-}
-
 /// Gets the `hir::TraitRef` of the trait the given method is implemented for.
 ///
 /// Use this if you want to find the `TraitRef` of the `Add` trait in this example:
@@ -587,26 +532,6 @@ pub fn trait_ref_of_method<'tcx>(cx: &LateContext<'tcx>, hir_id: HirId) -> Optio
     None
 }
 
-/// Checks whether this type implements `Drop`.
-pub fn has_drop<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
-    match ty.ty_adt_def() {
-        Some(def) => def.has_dtor(cx.tcx),
-        None => false,
-    }
-}
-
-/// Checks whether a type can be partially moved.
-pub fn can_partially_move_ty(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
-    if has_drop(cx, ty) || is_copy(cx, ty) {
-        return false;
-    }
-    match ty.kind() {
-        ty::Param(_) => false,
-        ty::Adt(def, subs) => def.all_fields().any(|f| !is_copy(cx, f.ty(cx.tcx, subs))),
-        _ => true,
-    }
-}
-
 /// Returns the method names and argument list of nested method call expressions that make up
 /// `expr`. method/span lists are sorted with the most recent call first.
 pub fn method_calls<'tcx>(
@@ -1155,26 +1080,6 @@ pub fn get_parent_as_impl(tcx: TyCtxt<'_>, id: HirId) -> Option<&Impl<'_>> {
     }
 }
 
-/// Returns the base type for HIR references and pointers.
-pub fn walk_ptrs_hir_ty<'tcx>(ty: &'tcx hir::Ty<'tcx>) -> &'tcx hir::Ty<'tcx> {
-    match ty.kind {
-        TyKind::Ptr(ref mut_ty) | TyKind::Rptr(_, ref mut_ty) => walk_ptrs_hir_ty(&mut_ty.ty),
-        _ => ty,
-    }
-}
-
-/// Returns the base type for references and raw pointers, and count reference
-/// depth.
-pub fn walk_ptrs_ty_depth(ty: Ty<'_>) -> (Ty<'_>, usize) {
-    fn inner(ty: Ty<'_>, depth: usize) -> (Ty<'_>, usize) {
-        match ty.kind() {
-            ty::Ref(_, ty, _) => inner(ty, depth + 1),
-            _ => (ty, depth),
-        }
-    }
-    inner(ty, 0)
-}
-
 /// Checks whether the given expression is a constant integer of the given value.
 /// unlike `is_integer_literal`, this version does const folding
 pub fn is_integer_const(cx: &LateContext<'_>, e: &Expr<'_>, value: u128) -> bool {
@@ -1270,26 +1175,6 @@ pub fn return_ty<'tcx>(cx: &LateContext<'tcx>, fn_item: hir::HirId) -> Ty<'tcx>
     cx.tcx.erase_late_bound_regions(ret_ty)
 }
 
-/// Walks into `ty` and returns `true` if any inner type is the same as `other_ty`
-pub fn contains_ty(ty: Ty<'_>, other_ty: Ty<'_>) -> bool {
-    ty.walk().any(|inner| match inner.unpack() {
-        GenericArgKind::Type(inner_ty) => ty::TyS::same_type(other_ty, inner_ty),
-        GenericArgKind::Lifetime(_) | GenericArgKind::Const(_) => false,
-    })
-}
-
-/// Returns `true` if the given type is an `unsafe` function.
-pub fn type_is_unsafe_function<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
-    match ty.kind() {
-        ty::FnDef(..) | ty::FnPtr(_) => ty.fn_sig(cx.tcx).unsafety() == Unsafety::Unsafe,
-        _ => false,
-    }
-}
-
-pub fn is_copy<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
-    ty.is_copy_modulo_regions(cx.tcx.at(DUMMY_SP), cx.param_env)
-}
-
 /// Checks if an expression is constructing a tuple-like enum variant or struct
 pub fn is_ctor_or_promotable_const_function(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
     if let ExprKind::Call(ref fun, _) = expr.kind {
@@ -1338,11 +1223,13 @@ pub fn is_refutable(cx: &LateContext<'_>, pat: &Pat<'_>) -> bool {
         },
         PatKind::Slice(ref head, ref middle, ref tail) => {
             match &cx.typeck_results().node_type(pat.hir_id).kind() {
-                ty::Slice(..) => {
+                rustc_ty::Slice(..) => {
                     // [..] is the only irrefutable slice pattern.
                     !head.is_empty() || middle.is_none() || !tail.is_empty()
                 },
-                ty::Array(..) => are_refutable(cx, head.iter().chain(middle).chain(tail.iter()).map(|pat| &**pat)),
+                rustc_ty::Array(..) => {
+                    are_refutable(cx, head.iter().chain(middle).chain(tail.iter()).map(|pat| &**pat))
+                },
                 _ => {
                     // unreachable!()
                     true
@@ -1454,26 +1341,26 @@ pub fn strip_pat_refs<'hir>(mut pat: &'hir Pat<'hir>) -> &'hir Pat<'hir> {
     pat
 }
 
-pub fn int_bits(tcx: TyCtxt<'_>, ity: ty::IntTy) -> u64 {
+pub fn int_bits(tcx: TyCtxt<'_>, ity: rustc_ty::IntTy) -> u64 {
     Integer::from_int_ty(&tcx, ity).size().bits()
 }
 
 #[allow(clippy::cast_possible_wrap)]
 /// Turn a constant int byte representation into an i128
-pub fn sext(tcx: TyCtxt<'_>, u: u128, ity: ty::IntTy) -> i128 {
+pub fn sext(tcx: TyCtxt<'_>, u: u128, ity: rustc_ty::IntTy) -> i128 {
     let amt = 128 - int_bits(tcx, ity);
     ((u as i128) << amt) >> amt
 }
 
 #[allow(clippy::cast_sign_loss)]
 /// clip unused bytes
-pub fn unsext(tcx: TyCtxt<'_>, u: i128, ity: ty::IntTy) -> u128 {
+pub fn unsext(tcx: TyCtxt<'_>, u: i128, ity: rustc_ty::IntTy) -> u128 {
     let amt = 128 - int_bits(tcx, ity);
     ((u as u128) << amt) >> amt
 }
 
 /// clip unused bytes
-pub fn clip(tcx: TyCtxt<'_>, u: u128, ity: ty::UintTy) -> u128 {
+pub fn clip(tcx: TyCtxt<'_>, u: u128, ity: rustc_ty::UintTy) -> u128 {
     let bits = Integer::from_uint_ty(&tcx, ity).size().bits();
     let amt = 128 - bits;
     (u << amt) >> amt
@@ -1526,47 +1413,6 @@ pub fn any_parent_is_automatically_derived(tcx: TyCtxt<'_>, node: HirId) -> bool
     false
 }
 
-/// Returns true if ty has `iter` or `iter_mut` methods
-pub fn has_iter_method(cx: &LateContext<'_>, probably_ref_ty: Ty<'_>) -> Option<Symbol> {
-    // FIXME: instead of this hard-coded list, we should check if `<adt>::iter`
-    // exists and has the desired signature. Unfortunately FnCtxt is not exported
-    // so we can't use its `lookup_method` method.
-    let into_iter_collections: &[Symbol] = &[
-        sym::vec_type,
-        sym::option_type,
-        sym::result_type,
-        sym::BTreeMap,
-        sym::BTreeSet,
-        sym::vecdeque_type,
-        sym::LinkedList,
-        sym::BinaryHeap,
-        sym::hashset_type,
-        sym::hashmap_type,
-        sym::PathBuf,
-        sym::Path,
-        sym::Receiver,
-    ];
-
-    let ty_to_check = match probably_ref_ty.kind() {
-        ty::Ref(_, ty_to_check, _) => ty_to_check,
-        _ => probably_ref_ty,
-    };
-
-    let def_id = match ty_to_check.kind() {
-        ty::Array(..) => return Some(sym::array),
-        ty::Slice(..) => return Some(sym::slice),
-        ty::Adt(adt, _) => adt.did,
-        _ => return None,
-    };
-
-    for &name in into_iter_collections {
-        if cx.tcx.is_diagnostic_item(name, def_id) {
-            return Some(cx.tcx.item_name(def_id));
-        }
-    }
-    None
-}
-
 /// Matches a function call with the given path and returns the arguments.
 ///
 /// Usage:
@@ -1591,51 +1437,6 @@ pub fn match_function_call<'tcx>(
     None
 }
 
-// FIXME: Per https://doc.rust-lang.org/nightly/nightly-rustc/rustc_trait_selection/infer/at/struct.At.html#method.normalize
-// this function can be removed once the `normalizie` method does not panic when normalization does
-// not succeed
-/// Checks if `Ty` is normalizable. This function is useful
-/// to avoid crashes on `layout_of`.
-pub fn is_normalizable<'tcx>(cx: &LateContext<'tcx>, param_env: ty::ParamEnv<'tcx>, ty: Ty<'tcx>) -> bool {
-    is_normalizable_helper(cx, param_env, ty, &mut HashMap::new())
-}
-
-fn is_normalizable_helper<'tcx>(
-    cx: &LateContext<'tcx>,
-    param_env: ty::ParamEnv<'tcx>,
-    ty: Ty<'tcx>,
-    cache: &mut HashMap<Ty<'tcx>, bool>,
-) -> bool {
-    if let Some(&cached_result) = cache.get(ty) {
-        return cached_result;
-    }
-    // prevent recursive loops, false-negative is better than endless loop leading to stack overflow
-    cache.insert(ty, false);
-    let result = cx.tcx.infer_ctxt().enter(|infcx| {
-        let cause = rustc_middle::traits::ObligationCause::dummy();
-        if infcx.at(&cause, param_env).normalize(ty).is_ok() {
-            match ty.kind() {
-                ty::Adt(def, substs) => def.variants.iter().all(|variant| {
-                    variant
-                        .fields
-                        .iter()
-                        .all(|field| is_normalizable_helper(cx, param_env, field.ty(cx.tcx, substs), cache))
-                }),
-                _ => ty.walk().all(|generic_arg| match generic_arg.unpack() {
-                    GenericArgKind::Type(inner_ty) if inner_ty != ty => {
-                        is_normalizable_helper(cx, param_env, inner_ty, cache)
-                    },
-                    _ => true, // if inner_ty == ty, we've already checked it
-                }),
-            }
-        } else {
-            false
-        }
-    });
-    cache.insert(ty, result);
-    result
-}
-
 pub fn match_def_path<'tcx>(cx: &LateContext<'tcx>, did: DefId, syms: &[&str]) -> bool {
     // We have to convert `syms` to `&[Symbol]` here because rustc's `match_def_path`
     // accepts only that. We should probably move to Symbols in Clippy as well.
@@ -1721,44 +1522,6 @@ pub fn must_use_attr(attrs: &[Attribute]) -> Option<&Attribute> {
     attr_by_name(attrs, "must_use")
 }
 
-// Returns whether the type has #[must_use] attribute
-pub fn is_must_use_ty<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
-    match ty.kind() {
-        ty::Adt(ref adt, _) => must_use_attr(&cx.tcx.get_attrs(adt.did)).is_some(),
-        ty::Foreign(ref did) => must_use_attr(&cx.tcx.get_attrs(*did)).is_some(),
-        ty::Slice(ref ty)
-        | ty::Array(ref ty, _)
-        | ty::RawPtr(ty::TypeAndMut { ref ty, .. })
-        | ty::Ref(_, ref ty, _) => {
-            // for the Array case we don't need to care for the len == 0 case
-            // because we don't want to lint functions returning empty arrays
-            is_must_use_ty(cx, *ty)
-        },
-        ty::Tuple(ref substs) => substs.types().any(|ty| is_must_use_ty(cx, ty)),
-        ty::Opaque(ref def_id, _) => {
-            for (predicate, _) in cx.tcx.explicit_item_bounds(*def_id) {
-                if let ty::PredicateKind::Trait(trait_predicate, _) = predicate.kind().skip_binder() {
-                    if must_use_attr(&cx.tcx.get_attrs(trait_predicate.trait_ref.def_id)).is_some() {
-                        return true;
-                    }
-                }
-            }
-            false
-        },
-        ty::Dynamic(binder, _) => {
-            for predicate in binder.iter() {
-                if let ty::ExistentialPredicate::Trait(ref trait_ref) = predicate.skip_binder() {
-                    if must_use_attr(&cx.tcx.get_attrs(trait_ref.def_id)).is_some() {
-                        return true;
-                    }
-                }
-            }
-            false
-        },
-        _ => false,
-    }
-}
-
 // check if expr is calling method or function with #[must_use] attribute
 pub fn is_must_use_func_call(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
     let did = match expr.kind {
@@ -1853,18 +1616,6 @@ pub fn run_lints(cx: &LateContext<'_>, lints: &[&'static Lint], id: HirId) -> bo
     })
 }
 
-/// Returns true iff the given type is a primitive (a bool or char, any integer or floating-point
-/// number type, a str, or an array, slice, or tuple of those types).
-pub fn is_recursively_primitive_type(ty: Ty<'_>) -> bool {
-    match ty.kind() {
-        ty::Bool | ty::Char | ty::Int(_) | ty::Uint(_) | ty::Float(_) | ty::Str => true,
-        ty::Ref(_, inner, _) if *inner.kind() == ty::Str => true,
-        ty::Array(inner_type, _) | ty::Slice(inner_type) => is_recursively_primitive_type(inner_type),
-        ty::Tuple(inner_types) => inner_types.types().all(is_recursively_primitive_type),
-        _ => false,
-    }
-}
-
 /// Returns Option<String> where String is a textual representation of the type encapsulated in the
 /// slice iff the given expression is a slice of primitives (as defined in the
 /// `is_recursively_primitive_type` function) and None otherwise.
@@ -1872,9 +1623,9 @@ pub fn is_slice_of_primitives(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<S
     let expr_type = cx.typeck_results().expr_ty_adjusted(expr);
     let expr_kind = expr_type.kind();
     let is_primitive = match expr_kind {
-        ty::Slice(element_type) => is_recursively_primitive_type(element_type),
-        ty::Ref(_, inner_ty, _) if matches!(inner_ty.kind(), &ty::Slice(_)) => {
-            if let ty::Slice(element_type) = inner_ty.kind() {
+        rustc_ty::Slice(element_type) => is_recursively_primitive_type(element_type),
+        rustc_ty::Ref(_, inner_ty, _) if matches!(inner_ty.kind(), &rustc_ty::Slice(_)) => {
+            if let rustc_ty::Slice(element_type) = inner_ty.kind() {
                 is_recursively_primitive_type(element_type)
             } else {
                 unreachable!()
@@ -1887,9 +1638,9 @@ pub fn is_slice_of_primitives(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<S
         // if we have wrappers like Array, Slice or Tuple, print these
         // and get the type enclosed in the slice ref
         match expr_type.peel_refs().walk().nth(1).unwrap().expect_ty().kind() {
-            ty::Slice(..) => return Some("slice".into()),
-            ty::Array(..) => return Some("array".into()),
-            ty::Tuple(..) => return Some("tuple".into()),
+            rustc_ty::Slice(..) => return Some("slice".into()),
+            rustc_ty::Array(..) => return Some("array".into()),
+            rustc_ty::Tuple(..) => return Some("tuple".into()),
             _ => {
                 // is_recursively_primitive_type() should have taken care
                 // of the rest and we can rely on the type that is found
@@ -1973,32 +1724,6 @@ pub fn peel_hir_expr_refs(expr: &'a Expr<'a>) -> (&'a Expr<'a>, usize) {
     f(expr, 0)
 }
 
-/// Peels off all references on the type. Returns the underlying type and the number of references
-/// removed.
-pub fn peel_mid_ty_refs(ty: Ty<'_>) -> (Ty<'_>, usize) {
-    fn peel(ty: Ty<'_>, count: usize) -> (Ty<'_>, usize) {
-        if let ty::Ref(_, ty, _) = ty.kind() {
-            peel(ty, count + 1)
-        } else {
-            (ty, count)
-        }
-    }
-    peel(ty, 0)
-}
-
-/// Peels off all references on the type.Returns the underlying type, the number of references
-/// removed, and whether the pointer is ultimately mutable or not.
-pub fn peel_mid_ty_refs_is_mutable(ty: Ty<'_>) -> (Ty<'_>, usize, Mutability) {
-    fn f(ty: Ty<'_>, count: usize, mutability: Mutability) -> (Ty<'_>, usize, Mutability) {
-        match ty.kind() {
-            ty::Ref(_, ty, Mutability::Mut) => f(ty, count + 1, mutability),
-            ty::Ref(_, ty, Mutability::Not) => f(ty, count + 1, Mutability::Not),
-            _ => (ty, count, mutability),
-        }
-    }
-    f(ty, 0, Mutability::Mut)
-}
-
 #[macro_export]
 macro_rules! unwrap_cargo_metadata {
     ($cx: ident, $lint: ident, $deps: expr) => {{
diff --git a/clippy_utils/src/ty.rs b/clippy_utils/src/ty.rs
new file mode 100644
index 00000000000..f4a1ae67da3
--- /dev/null
+++ b/clippy_utils/src/ty.rs
@@ -0,0 +1,296 @@
+//! Util methods for [`rustc_middle::ty`]
+
+#![allow(clippy::module_name_repetitions)]
+
+use std::collections::HashMap;
+
+use rustc_ast::ast::Mutability;
+use rustc_hir as hir;
+use rustc_hir::def_id::DefId;
+use rustc_hir::{TyKind, Unsafety};
+use rustc_infer::infer::TyCtxtInferExt;
+use rustc_lint::LateContext;
+use rustc_middle::ty::subst::{GenericArg, GenericArgKind};
+use rustc_middle::ty::{self, IntTy, Ty, TypeFoldable, UintTy};
+use rustc_span::sym;
+use rustc_span::symbol::Symbol;
+use rustc_span::DUMMY_SP;
+use rustc_trait_selection::traits::query::normalize::AtExt;
+
+use crate::{match_def_path, must_use_attr};
+
+pub fn is_copy<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
+    ty.is_copy_modulo_regions(cx.tcx.at(DUMMY_SP), cx.param_env)
+}
+
+/// Checks whether a type can be partially moved.
+pub fn can_partially_move_ty(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
+    if has_drop(cx, ty) || is_copy(cx, ty) {
+        return false;
+    }
+    match ty.kind() {
+        ty::Param(_) => false,
+        ty::Adt(def, subs) => def.all_fields().any(|f| !is_copy(cx, f.ty(cx.tcx, subs))),
+        _ => true,
+    }
+}
+
+/// Walks into `ty` and returns `true` if any inner type is the same as `other_ty`
+pub fn contains_ty(ty: Ty<'_>, other_ty: Ty<'_>) -> bool {
+    ty.walk().any(|inner| match inner.unpack() {
+        GenericArgKind::Type(inner_ty) => ty::TyS::same_type(other_ty, inner_ty),
+        GenericArgKind::Lifetime(_) | GenericArgKind::Const(_) => false,
+    })
+}
+
+/// Returns true if ty has `iter` or `iter_mut` methods
+pub fn has_iter_method(cx: &LateContext<'_>, probably_ref_ty: Ty<'_>) -> Option<Symbol> {
+    // FIXME: instead of this hard-coded list, we should check if `<adt>::iter`
+    // exists and has the desired signature. Unfortunately FnCtxt is not exported
+    // so we can't use its `lookup_method` method.
+    let into_iter_collections: &[Symbol] = &[
+        sym::vec_type,
+        sym::option_type,
+        sym::result_type,
+        sym::BTreeMap,
+        sym::BTreeSet,
+        sym::vecdeque_type,
+        sym::LinkedList,
+        sym::BinaryHeap,
+        sym::hashset_type,
+        sym::hashmap_type,
+        sym::PathBuf,
+        sym::Path,
+        sym::Receiver,
+    ];
+
+    let ty_to_check = match probably_ref_ty.kind() {
+        ty::Ref(_, ty_to_check, _) => ty_to_check,
+        _ => probably_ref_ty,
+    };
+
+    let def_id = match ty_to_check.kind() {
+        ty::Array(..) => return Some(sym::array),
+        ty::Slice(..) => return Some(sym::slice),
+        ty::Adt(adt, _) => adt.did,
+        _ => return None,
+    };
+
+    for &name in into_iter_collections {
+        if cx.tcx.is_diagnostic_item(name, def_id) {
+            return Some(cx.tcx.item_name(def_id));
+        }
+    }
+    None
+}
+
+/// Checks whether a type implements a trait.
+/// See also `get_trait_def_id`.
+pub fn implements_trait<'tcx>(
+    cx: &LateContext<'tcx>,
+    ty: Ty<'tcx>,
+    trait_id: DefId,
+    ty_params: &[GenericArg<'tcx>],
+) -> bool {
+    // Do not check on infer_types to avoid panic in evaluate_obligation.
+    if ty.has_infer_types() {
+        return false;
+    }
+    let ty = cx.tcx.erase_regions(ty);
+    if ty.has_escaping_bound_vars() {
+        return false;
+    }
+    let ty_params = cx.tcx.mk_substs(ty_params.iter());
+    cx.tcx.type_implements_trait((trait_id, ty, ty_params, cx.param_env))
+}
+
+/// Checks whether this type implements `Drop`.
+pub fn has_drop<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
+    match ty.ty_adt_def() {
+        Some(def) => def.has_dtor(cx.tcx),
+        None => false,
+    }
+}
+
+// Returns whether the type has #[must_use] attribute
+pub fn is_must_use_ty<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
+    match ty.kind() {
+        ty::Adt(ref adt, _) => must_use_attr(&cx.tcx.get_attrs(adt.did)).is_some(),
+        ty::Foreign(ref did) => must_use_attr(&cx.tcx.get_attrs(*did)).is_some(),
+        ty::Slice(ref ty)
+        | ty::Array(ref ty, _)
+        | ty::RawPtr(ty::TypeAndMut { ref ty, .. })
+        | ty::Ref(_, ref ty, _) => {
+            // for the Array case we don't need to care for the len == 0 case
+            // because we don't want to lint functions returning empty arrays
+            is_must_use_ty(cx, *ty)
+        },
+        ty::Tuple(ref substs) => substs.types().any(|ty| is_must_use_ty(cx, ty)),
+        ty::Opaque(ref def_id, _) => {
+            for (predicate, _) in cx.tcx.explicit_item_bounds(*def_id) {
+                if let ty::PredicateKind::Trait(trait_predicate, _) = predicate.kind().skip_binder() {
+                    if must_use_attr(&cx.tcx.get_attrs(trait_predicate.trait_ref.def_id)).is_some() {
+                        return true;
+                    }
+                }
+            }
+            false
+        },
+        ty::Dynamic(binder, _) => {
+            for predicate in binder.iter() {
+                if let ty::ExistentialPredicate::Trait(ref trait_ref) = predicate.skip_binder() {
+                    if must_use_attr(&cx.tcx.get_attrs(trait_ref.def_id)).is_some() {
+                        return true;
+                    }
+                }
+            }
+            false
+        },
+        _ => false,
+    }
+}
+
+// FIXME: Per https://doc.rust-lang.org/nightly/nightly-rustc/rustc_trait_selection/infer/at/struct.At.html#method.normalize
+// this function can be removed once the `normalizie` method does not panic when normalization does
+// not succeed
+/// Checks if `Ty` is normalizable. This function is useful
+/// to avoid crashes on `layout_of`.
+pub fn is_normalizable<'tcx>(cx: &LateContext<'tcx>, param_env: ty::ParamEnv<'tcx>, ty: Ty<'tcx>) -> bool {
+    is_normalizable_helper(cx, param_env, ty, &mut HashMap::new())
+}
+
+fn is_normalizable_helper<'tcx>(
+    cx: &LateContext<'tcx>,
+    param_env: ty::ParamEnv<'tcx>,
+    ty: Ty<'tcx>,
+    cache: &mut HashMap<Ty<'tcx>, bool>,
+) -> bool {
+    if let Some(&cached_result) = cache.get(ty) {
+        return cached_result;
+    }
+    // prevent recursive loops, false-negative is better than endless loop leading to stack overflow
+    cache.insert(ty, false);
+    let result = cx.tcx.infer_ctxt().enter(|infcx| {
+        let cause = rustc_middle::traits::ObligationCause::dummy();
+        if infcx.at(&cause, param_env).normalize(ty).is_ok() {
+            match ty.kind() {
+                ty::Adt(def, substs) => def.variants.iter().all(|variant| {
+                    variant
+                        .fields
+                        .iter()
+                        .all(|field| is_normalizable_helper(cx, param_env, field.ty(cx.tcx, substs), cache))
+                }),
+                _ => ty.walk().all(|generic_arg| match generic_arg.unpack() {
+                    GenericArgKind::Type(inner_ty) if inner_ty != ty => {
+                        is_normalizable_helper(cx, param_env, inner_ty, cache)
+                    },
+                    _ => true, // if inner_ty == ty, we've already checked it
+                }),
+            }
+        } else {
+            false
+        }
+    });
+    cache.insert(ty, result);
+    result
+}
+
+/// Returns true iff the given type is a primitive (a bool or char, any integer or floating-point
+/// number type, a str, or an array, slice, or tuple of those types).
+pub fn is_recursively_primitive_type(ty: Ty<'_>) -> bool {
+    match ty.kind() {
+        ty::Bool | ty::Char | ty::Int(_) | ty::Uint(_) | ty::Float(_) | ty::Str => true,
+        ty::Ref(_, inner, _) if *inner.kind() == ty::Str => true,
+        ty::Array(inner_type, _) | ty::Slice(inner_type) => is_recursively_primitive_type(inner_type),
+        ty::Tuple(inner_types) => inner_types.types().all(is_recursively_primitive_type),
+        _ => false,
+    }
+}
+
+/// Checks if the type is equal to a diagnostic item
+///
+/// If you change the signature, remember to update the internal lint `MatchTypeOnDiagItem`
+pub fn is_type_diagnostic_item(cx: &LateContext<'_>, ty: Ty<'_>, diag_item: Symbol) -> bool {
+    match ty.kind() {
+        ty::Adt(adt, _) => cx.tcx.is_diagnostic_item(diag_item, adt.did),
+        _ => false,
+    }
+}
+
+/// Checks if the type is equal to a lang item
+pub fn is_type_lang_item(cx: &LateContext<'_>, ty: Ty<'_>, lang_item: hir::LangItem) -> bool {
+    match ty.kind() {
+        ty::Adt(adt, _) => cx.tcx.lang_items().require(lang_item).unwrap() == adt.did,
+        _ => false,
+    }
+}
+
+/// Return `true` if the passed `typ` is `isize` or `usize`.
+pub fn is_isize_or_usize(typ: Ty<'_>) -> bool {
+    matches!(typ.kind(), ty::Int(IntTy::Isize) | ty::Uint(UintTy::Usize))
+}
+
+/// Checks if type is struct, enum or union type with the given def path.
+///
+/// If the type is a diagnostic item, use `is_type_diagnostic_item` instead.
+/// If you change the signature, remember to update the internal lint `MatchTypeOnDiagItem`
+pub fn match_type(cx: &LateContext<'_>, ty: Ty<'_>, path: &[&str]) -> bool {
+    match ty.kind() {
+        ty::Adt(adt, _) => match_def_path(cx, adt.did, path),
+        _ => false,
+    }
+}
+
+/// Peels off all references on the type. Returns the underlying type and the number of references
+/// removed.
+pub fn peel_mid_ty_refs(ty: Ty<'_>) -> (Ty<'_>, usize) {
+    fn peel(ty: Ty<'_>, count: usize) -> (Ty<'_>, usize) {
+        if let ty::Ref(_, ty, _) = ty.kind() {
+            peel(ty, count + 1)
+        } else {
+            (ty, count)
+        }
+    }
+    peel(ty, 0)
+}
+
+/// Peels off all references on the type.Returns the underlying type, the number of references
+/// removed, and whether the pointer is ultimately mutable or not.
+pub fn peel_mid_ty_refs_is_mutable(ty: Ty<'_>) -> (Ty<'_>, usize, Mutability) {
+    fn f(ty: Ty<'_>, count: usize, mutability: Mutability) -> (Ty<'_>, usize, Mutability) {
+        match ty.kind() {
+            ty::Ref(_, ty, Mutability::Mut) => f(ty, count + 1, mutability),
+            ty::Ref(_, ty, Mutability::Not) => f(ty, count + 1, Mutability::Not),
+            _ => (ty, count, mutability),
+        }
+    }
+    f(ty, 0, Mutability::Mut)
+}
+
+/// Returns `true` if the given type is an `unsafe` function.
+pub fn type_is_unsafe_function<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
+    match ty.kind() {
+        ty::FnDef(..) | ty::FnPtr(_) => ty.fn_sig(cx.tcx).unsafety() == Unsafety::Unsafe,
+        _ => false,
+    }
+}
+
+/// Returns the base type for HIR references and pointers.
+pub fn walk_ptrs_hir_ty<'tcx>(ty: &'tcx hir::Ty<'tcx>) -> &'tcx hir::Ty<'tcx> {
+    match ty.kind {
+        TyKind::Ptr(ref mut_ty) | TyKind::Rptr(_, ref mut_ty) => walk_ptrs_hir_ty(&mut_ty.ty),
+        _ => ty,
+    }
+}
+
+/// Returns the base type for references and raw pointers, and count reference
+/// depth.
+pub fn walk_ptrs_ty_depth(ty: Ty<'_>) -> (Ty<'_>, usize) {
+    fn inner(ty: Ty<'_>, depth: usize) -> (Ty<'_>, usize) {
+        match ty.kind() {
+            ty::Ref(_, ty, _) => inner(ty, depth + 1),
+            _ => (ty, depth),
+        }
+    }
+    inner(ty, 0)
+}
-- 
cgit 1.4.1-3-g733a5


From 6fc52a63d19c85e952fc81298e7dd2289a774ac6 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Sun, 14 Mar 2021 18:17:44 -0500
Subject: Move some utils to clippy_utils::source module

---
 clippy_lints/src/assertions_on_constants.rs        |   3 +-
 clippy_lints/src/assign_ops.rs                     |   3 +-
 clippy_lints/src/async_yields_async.rs             |   3 +-
 clippy_lints/src/attrs.rs                          |   6 +-
 clippy_lints/src/blocks_in_if_conditions.rs        |   5 +-
 clippy_lints/src/booleans.rs                       |   5 +-
 clippy_lints/src/bytecount.rs                      |   5 +-
 clippy_lints/src/casts/cast_lossless.rs            |   3 +-
 clippy_lints/src/casts/char_lit_as_u8.rs           |   6 +-
 clippy_lints/src/casts/fn_to_numeric_cast.rs       |   4 +-
 .../casts/fn_to_numeric_cast_with_truncation.rs    |   4 +-
 clippy_lints/src/casts/unnecessary_cast.rs         |   6 +-
 clippy_lints/src/checked_conversions.rs            |   3 +-
 clippy_lints/src/cognitive_complexity.rs           |   3 +-
 clippy_lints/src/collapsible_if.rs                 |   5 +-
 clippy_lints/src/create_dir.rs                     |   3 +-
 clippy_lints/src/dbg_macro.rs                      |   3 +-
 clippy_lints/src/default.rs                        |   5 +-
 clippy_lints/src/default_numeric_fallback.rs       |   6 +-
 clippy_lints/src/dereference.rs                    |   3 +-
 clippy_lints/src/double_comparison.rs              |   3 +-
 clippy_lints/src/duration_subsec.rs                |   3 +-
 clippy_lints/src/entry.rs                          |   5 +-
 clippy_lints/src/enum_variants.rs                  |   3 +-
 clippy_lints/src/eq_op.rs                          |   5 +-
 clippy_lints/src/eta_reduction.rs                  |   3 +-
 clippy_lints/src/exhaustive_items.rs               |   5 +-
 clippy_lints/src/format.rs                         |   5 +-
 clippy_lints/src/formatting.rs                     |   3 +-
 clippy_lints/src/functions.rs                      |   4 +-
 clippy_lints/src/get_last_with_len.rs              |   3 +-
 clippy_lints/src/identity_op.rs                    |   3 +-
 clippy_lints/src/if_let_some_result.rs             |   3 +-
 clippy_lints/src/if_then_some_else_none.rs         |   5 +-
 clippy_lints/src/implicit_return.rs                |   3 +-
 .../src/inconsistent_struct_constructor.rs         |   6 +-
 clippy_lints/src/int_plus_one.rs                   |   3 +-
 clippy_lints/src/large_enum_variant.rs             |   3 +-
 clippy_lints/src/large_stack_arrays.rs             |   6 +-
 clippy_lints/src/len_zero.rs                       |   6 +-
 clippy_lints/src/let_if_seq.rs                     |   3 +-
 clippy_lints/src/literal_representation.rs         |   3 +-
 clippy_lints/src/loops/explicit_counter_loop.rs    |   3 +-
 clippy_lints/src/loops/explicit_into_iter_loop.rs  |   3 +-
 clippy_lints/src/loops/explicit_iter_loop.rs       |   4 +-
 clippy_lints/src/loops/for_kv_map.rs               |   3 +-
 clippy_lints/src/loops/for_loops_over_fallibles.rs |   6 +-
 clippy_lints/src/loops/manual_memcpy.rs            |   3 +-
 clippy_lints/src/loops/needless_collect.rs         |   3 +-
 clippy_lints/src/loops/needless_range_loop.rs      |   3 +-
 clippy_lints/src/loops/same_item_push.rs           |   3 +-
 clippy_lints/src/loops/single_element_loop.rs      |   3 +-
 clippy_lints/src/loops/while_let_loop.rs           |   3 +-
 clippy_lints/src/loops/while_let_on_iterator.rs    |   3 +-
 clippy_lints/src/macro_use.rs                      |   3 +-
 clippy_lints/src/main_recursion.rs                 |   5 +-
 clippy_lints/src/manual_async_fn.rs                |   3 +-
 clippy_lints/src/manual_map.rs                     |   6 +-
 clippy_lints/src/manual_non_exhaustive.rs          |   3 +-
 clippy_lints/src/manual_ok_or.rs                   |   5 +-
 clippy_lints/src/manual_strip.rs                   |   6 +-
 clippy_lints/src/manual_unwrap_or.rs               |   7 +-
 clippy_lints/src/map_clone.rs                      |   3 +-
 clippy_lints/src/map_unit_fn.rs                    |   3 +-
 clippy_lints/src/match_on_vec_items.rs             |   3 +-
 clippy_lints/src/matches.rs                        |   9 +-
 clippy_lints/src/mem_discriminant.rs               |   3 +-
 clippy_lints/src/mem_replace.rs                    |   8 +-
 clippy_lints/src/methods/bind_instead_of_map.rs    |   5 +-
 clippy_lints/src/methods/bytes_nth.rs              |   3 +-
 clippy_lints/src/methods/clone_on_ref_ptr.rs       |   3 +-
 clippy_lints/src/methods/expect_fun_call.rs        |   3 +-
 clippy_lints/src/methods/filter_map.rs             |   3 +-
 clippy_lints/src/methods/filter_map_next.rs        |   3 +-
 clippy_lints/src/methods/filter_next.rs            |   3 +-
 clippy_lints/src/methods/get_unwrap.rs             |   3 +-
 clippy_lints/src/methods/inefficient_to_string.rs  |   3 +-
 clippy_lints/src/methods/iter_count.rs             |   3 +-
 clippy_lints/src/methods/iter_next_slice.rs        |   3 +-
 clippy_lints/src/methods/iter_nth_zero.rs          |   3 +-
 clippy_lints/src/methods/iter_skip_next.rs         |   3 +-
 .../src/methods/manual_saturating_arithmetic.rs    |   3 +-
 .../src/methods/map_collect_result_unit.rs         |   3 +-
 clippy_lints/src/methods/map_flatten.rs            |   3 +-
 clippy_lints/src/methods/map_unwrap_or.rs          |   3 +-
 clippy_lints/src/methods/mod.rs                    |   5 +-
 clippy_lints/src/methods/option_as_ref_deref.rs    |   3 +-
 clippy_lints/src/methods/option_map_or_none.rs     |   3 +-
 clippy_lints/src/methods/option_map_unwrap_or.rs   |   3 +-
 clippy_lints/src/methods/or_fun_call.rs            |   6 +-
 clippy_lints/src/methods/search_is_some.rs         |   5 +-
 .../src/methods/single_char_insert_string.rs       |   3 +-
 .../src/methods/single_char_push_string.rs         |   3 +-
 clippy_lints/src/methods/string_extend_chars.rs    |   3 +-
 clippy_lints/src/methods/unnecessary_fold.rs       |   5 +-
 clippy_lints/src/methods/unnecessary_lazy_eval.rs  |   3 +-
 clippy_lints/src/methods/useless_asref.rs          |   3 +-
 clippy_lints/src/misc.rs                           |   5 +-
 clippy_lints/src/misc_early.rs                     |   3 +-
 clippy_lints/src/needless_bool.rs                  |   3 +-
 clippy_lints/src/needless_borrow.rs                |   3 +-
 clippy_lints/src/needless_borrowed_ref.rs          |   3 +-
 clippy_lints/src/needless_continue.rs              |   3 +-
 clippy_lints/src/needless_pass_by_value.rs         |   3 +-
 clippy_lints/src/needless_question_mark.rs         |   3 +-
 clippy_lints/src/no_effect.rs                      |   3 +-
 clippy_lints/src/pass_by_ref_or_value.rs           |   3 +-
 clippy_lints/src/precedence.rs                     |   3 +-
 clippy_lints/src/ptr.rs                            |   3 +-
 clippy_lints/src/ptr_eq.rs                         |   5 +-
 clippy_lints/src/ptr_offset_with_cast.rs           |   3 +-
 clippy_lints/src/question_mark.rs                  |   3 +-
 clippy_lints/src/ranges.rs                         |   5 +-
 clippy_lints/src/redundant_clone.rs                |   5 +-
 clippy_lints/src/redundant_closure_call.rs         |   3 +-
 clippy_lints/src/redundant_slicing.rs              |   3 +-
 clippy_lints/src/redundant_static_lifetimes.rs     |   3 +-
 clippy_lints/src/ref_option_ref.rs                 |   8 +-
 clippy_lints/src/reference.rs                      |   3 +-
 clippy_lints/src/repeat_once.rs                    |   3 +-
 clippy_lints/src/returns.rs                        |   3 +-
 clippy_lints/src/self_assignment.rs                |   3 +-
 clippy_lints/src/semicolon_if_nothing_returned.rs  |   3 +-
 clippy_lints/src/shadow.rs                         |   3 +-
 clippy_lints/src/strings.rs                        |   2 +-
 clippy_lints/src/suspicious_operation_groupings.rs |   3 +-
 clippy_lints/src/swap.rs                           |   3 +-
 clippy_lints/src/to_digit_is_some.rs               |   3 +-
 clippy_lints/src/trait_bounds.rs                   |   3 +-
 clippy_lints/src/transmute/transmute_ref_to_ref.rs |   3 +-
 clippy_lints/src/transmute/utils.rs                |   3 +-
 clippy_lints/src/try_err.rs                        |   6 +-
 clippy_lints/src/types/borrowed_box.rs             |   7 +-
 clippy_lints/src/types/mod.rs                      |   6 +-
 clippy_lints/src/types/rc_buffer.rs                |   5 +-
 clippy_lints/src/types/redundant_allocation.rs     |   6 +-
 clippy_lints/src/types/vec_box.rs                  |   6 +-
 clippy_lints/src/unicode.rs                        |   3 +-
 clippy_lints/src/unnecessary_wraps.rs              |   4 +-
 clippy_lints/src/unused_unit.rs                    |   3 +-
 clippy_lints/src/use_self.rs                       |   3 +-
 clippy_lints/src/useless_conversion.rs             |   4 +-
 clippy_lints/src/utils/internal_lints.rs           |   3 +-
 clippy_lints/src/vec.rs                            |   3 +-
 clippy_lints/src/vec_init_then_push.rs             |   3 +-
 clippy_lints/src/wildcard_imports.rs               |   3 +-
 clippy_lints/src/write.rs                          |   3 +-
 clippy_utils/src/hir_utils.rs                      |   3 +-
 clippy_utils/src/lib.rs                            | 416 +-------------------
 clippy_utils/src/ptr.rs                            |   3 +-
 clippy_utils/src/source.rs                         | 420 +++++++++++++++++++++
 clippy_utils/src/sugg.rs                           |   3 +-
 152 files changed, 753 insertions(+), 649 deletions(-)
 create mode 100644 clippy_utils/src/source.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/assertions_on_constants.rs b/clippy_lints/src/assertions_on_constants.rs
index 77b26faaa58..3b6f64e7769 100644
--- a/clippy_lints/src/assertions_on_constants.rs
+++ b/clippy_lints/src/assertions_on_constants.rs
@@ -1,5 +1,6 @@
 use crate::consts::{constant, Constant};
-use crate::utils::{is_direct_expn_of, is_expn_of, match_panic_call, snippet_opt, span_lint_and_help};
+use crate::utils::{is_direct_expn_of, is_expn_of, match_panic_call, span_lint_and_help};
+use clippy_utils::source::snippet_opt;
 use if_chain::if_chain;
 use rustc_hir::{Expr, ExprKind, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/assign_ops.rs b/clippy_lints/src/assign_ops.rs
index ae300324158..031827e7e89 100644
--- a/clippy_lints/src/assign_ops.rs
+++ b/clippy_lints/src/assign_ops.rs
@@ -1,5 +1,6 @@
-use crate::utils::{eq_expr_value, get_trait_def_id, snippet_opt, span_lint_and_then, trait_ref_of_method};
+use crate::utils::{eq_expr_value, get_trait_def_id, span_lint_and_then, trait_ref_of_method};
 use crate::utils::{higher, sugg};
+use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::implements_trait;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/async_yields_async.rs b/clippy_lints/src/async_yields_async.rs
index 1e185e97df6..a5ed6016874 100644
--- a/clippy_lints/src/async_yields_async.rs
+++ b/clippy_lints/src/async_yields_async.rs
@@ -1,4 +1,5 @@
-use crate::utils::{snippet, span_lint_and_then};
+use crate::utils::span_lint_and_then;
+use clippy_utils::source::snippet;
 use clippy_utils::ty::implements_trait;
 use rustc_errors::Applicability;
 use rustc_hir::{AsyncGeneratorKind, Body, BodyId, ExprKind, GeneratorKind, QPath};
diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs
index 6250810bc42..04b0e71e4a3 100644
--- a/clippy_lints/src/attrs.rs
+++ b/clippy_lints/src/attrs.rs
@@ -1,9 +1,7 @@
 //! checks for attributes
 
-use crate::utils::{
-    first_line_of_span, is_present_in_source, match_panic_def_id, snippet_opt, span_lint, span_lint_and_help,
-    span_lint_and_sugg, span_lint_and_then, without_block_comments,
-};
+use crate::utils::{match_panic_def_id, span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then};
+use clippy_utils::source::{first_line_of_span, is_present_in_source, snippet_opt, without_block_comments};
 use if_chain::if_chain;
 use rustc_ast::{AttrKind, AttrStyle, Attribute, Lit, LitKind, MetaItemKind, NestedMetaItem};
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/blocks_in_if_conditions.rs b/clippy_lints/src/blocks_in_if_conditions.rs
index 222bb39f89c..f43f98d1dc0 100644
--- a/clippy_lints/src/blocks_in_if_conditions.rs
+++ b/clippy_lints/src/blocks_in_if_conditions.rs
@@ -1,6 +1,5 @@
-use crate::utils::{
-    differing_macro_contexts, get_parent_expr, snippet_block_with_applicability, span_lint, span_lint_and_sugg,
-};
+use crate::utils::{differing_macro_contexts, get_parent_expr, span_lint, span_lint_and_sugg};
+use clippy_utils::source::snippet_block_with_applicability;
 use clippy_utils::ty::implements_trait;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/booleans.rs b/clippy_lints/src/booleans.rs
index affc7d2c93f..12a07c60438 100644
--- a/clippy_lints/src/booleans.rs
+++ b/clippy_lints/src/booleans.rs
@@ -1,6 +1,5 @@
-use crate::utils::{
-    eq_expr_value, get_trait_def_id, in_macro, paths, snippet_opt, span_lint_and_sugg, span_lint_and_then,
-};
+use crate::utils::{eq_expr_value, get_trait_def_id, in_macro, paths, span_lint_and_sugg, span_lint_and_then};
+use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::{implements_trait, is_type_diagnostic_item};
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
diff --git a/clippy_lints/src/bytecount.rs b/clippy_lints/src/bytecount.rs
index 67cca8dcadb..d02861b1b1e 100644
--- a/clippy_lints/src/bytecount.rs
+++ b/clippy_lints/src/bytecount.rs
@@ -1,6 +1,5 @@
-use crate::utils::{
-    contains_name, get_pat_name, paths, single_segment_path, snippet_with_applicability, span_lint_and_sugg,
-};
+use crate::utils::{contains_name, get_pat_name, paths, single_segment_path, span_lint_and_sugg};
+use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::match_type;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/casts/cast_lossless.rs b/clippy_lints/src/casts/cast_lossless.rs
index 902fb423ff1..62ba19c0e16 100644
--- a/clippy_lints/src/casts/cast_lossless.rs
+++ b/clippy_lints/src/casts/cast_lossless.rs
@@ -1,10 +1,11 @@
+use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::is_isize_or_usize;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::LateContext;
 use rustc_middle::ty::{self, FloatTy, Ty};
 
-use crate::utils::{in_constant, snippet_opt, span_lint_and_sugg};
+use crate::utils::{in_constant, span_lint_and_sugg};
 
 use super::{utils, CAST_LOSSLESS};
 
diff --git a/clippy_lints/src/casts/char_lit_as_u8.rs b/clippy_lints/src/casts/char_lit_as_u8.rs
index ccaad1b8f2a..75aa559359c 100644
--- a/clippy_lints/src/casts/char_lit_as_u8.rs
+++ b/clippy_lints/src/casts/char_lit_as_u8.rs
@@ -1,12 +1,12 @@
+use clippy_utils::source::snippet_with_applicability;
+use if_chain::if_chain;
 use rustc_ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::LateContext;
 use rustc_middle::ty::{self, UintTy};
 
-use if_chain::if_chain;
-
-use crate::utils::{snippet_with_applicability, span_lint_and_then};
+use crate::utils::span_lint_and_then;
 
 use super::CHAR_LIT_AS_U8;
 
diff --git a/clippy_lints/src/casts/fn_to_numeric_cast.rs b/clippy_lints/src/casts/fn_to_numeric_cast.rs
index a8d508585b5..723bfa5befe 100644
--- a/clippy_lints/src/casts/fn_to_numeric_cast.rs
+++ b/clippy_lints/src/casts/fn_to_numeric_cast.rs
@@ -1,10 +1,10 @@
+use crate::utils::span_lint_and_sugg;
+use clippy_utils::source::snippet_with_applicability;
 use rustc_errors::Applicability;
 use rustc_hir::Expr;
 use rustc_lint::LateContext;
 use rustc_middle::ty::{self, Ty, UintTy};
 
-use crate::utils::{snippet_with_applicability, span_lint_and_sugg};
-
 use super::{utils, FN_TO_NUMERIC_CAST};
 
 pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_expr: &Expr<'_>, cast_from: Ty<'_>, cast_to: Ty<'_>) {
diff --git a/clippy_lints/src/casts/fn_to_numeric_cast_with_truncation.rs b/clippy_lints/src/casts/fn_to_numeric_cast_with_truncation.rs
index 0085c7b27b2..a3108f8a983 100644
--- a/clippy_lints/src/casts/fn_to_numeric_cast_with_truncation.rs
+++ b/clippy_lints/src/casts/fn_to_numeric_cast_with_truncation.rs
@@ -1,10 +1,10 @@
+use crate::utils::span_lint_and_sugg;
+use clippy_utils::source::snippet_with_applicability;
 use rustc_errors::Applicability;
 use rustc_hir::Expr;
 use rustc_lint::LateContext;
 use rustc_middle::ty::{self, Ty};
 
-use crate::utils::{snippet_with_applicability, span_lint_and_sugg};
-
 use super::{utils, FN_TO_NUMERIC_CAST_WITH_TRUNCATION};
 
 pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_expr: &Expr<'_>, cast_from: Ty<'_>, cast_to: Ty<'_>) {
diff --git a/clippy_lints/src/casts/unnecessary_cast.rs b/clippy_lints/src/casts/unnecessary_cast.rs
index c43bbf32949..eb0ee012e6c 100644
--- a/clippy_lints/src/casts/unnecessary_cast.rs
+++ b/clippy_lints/src/casts/unnecessary_cast.rs
@@ -1,3 +1,5 @@
+use clippy_utils::source::snippet_opt;
+use if_chain::if_chain;
 use rustc_ast::{LitFloatType, LitIntType, LitKind};
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, Lit, UnOp};
@@ -5,9 +7,7 @@ use rustc_lint::{LateContext, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::{self, FloatTy, InferTy, Ty};
 
-use if_chain::if_chain;
-
-use crate::utils::{numeric_literal::NumericLiteral, snippet_opt, span_lint_and_sugg};
+use crate::utils::{numeric_literal::NumericLiteral, span_lint_and_sugg};
 
 use super::UNNECESSARY_CAST;
 
diff --git a/clippy_lints/src/checked_conversions.rs b/clippy_lints/src/checked_conversions.rs
index 54bc69e058b..4f3daa427e3 100644
--- a/clippy_lints/src/checked_conversions.rs
+++ b/clippy_lints/src/checked_conversions.rs
@@ -1,5 +1,6 @@
 //! lint on manually implemented checked conversions that could be transformed into `try_from`
 
+use clippy_utils::source::snippet_with_applicability;
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
@@ -9,7 +10,7 @@ use rustc_middle::lint::in_external_macro;
 use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 
-use crate::utils::{meets_msrv, snippet_with_applicability, span_lint_and_sugg, SpanlessEq};
+use crate::utils::{meets_msrv, span_lint_and_sugg, SpanlessEq};
 
 const CHECKED_CONVERSIONS_MSRV: RustcVersion = RustcVersion::new(1, 34, 0);
 
diff --git a/clippy_lints/src/cognitive_complexity.rs b/clippy_lints/src/cognitive_complexity.rs
index 3d842a46813..5b8ef01505b 100644
--- a/clippy_lints/src/cognitive_complexity.rs
+++ b/clippy_lints/src/cognitive_complexity.rs
@@ -1,5 +1,6 @@
 //! calculate cognitive complexity and warn about overly complex functions
 
+use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_ast::ast::Attribute;
 use rustc_hir::intravisit::{walk_expr, FnKind, NestedVisitorMap, Visitor};
@@ -10,7 +11,7 @@ use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::Span;
 use rustc_span::{sym, BytePos};
 
-use crate::utils::{snippet_opt, span_lint_and_help, LimitStack};
+use crate::utils::{span_lint_and_help, LimitStack};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for methods with high cognitive complexity.
diff --git a/clippy_lints/src/collapsible_if.rs b/clippy_lints/src/collapsible_if.rs
index 34f0e6ab027..c866f18ef3e 100644
--- a/clippy_lints/src/collapsible_if.rs
+++ b/clippy_lints/src/collapsible_if.rs
@@ -12,14 +12,15 @@
 //!
 //! This lint is **warn** by default
 
+use clippy_utils::source::{snippet_block, snippet_block_with_applicability};
 use if_chain::if_chain;
 use rustc_ast::ast;
+use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 use crate::utils::sugg::Sugg;
-use crate::utils::{snippet_block, snippet_block_with_applicability, span_lint_and_sugg, span_lint_and_then};
-use rustc_errors::Applicability;
+use crate::utils::{span_lint_and_sugg, span_lint_and_then};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for nested `if` statements which can be collapsed
diff --git a/clippy_lints/src/create_dir.rs b/clippy_lints/src/create_dir.rs
index 200b6a565cc..0785e25b0a2 100644
--- a/clippy_lints/src/create_dir.rs
+++ b/clippy_lints/src/create_dir.rs
@@ -1,4 +1,5 @@
-use crate::utils::{match_def_path, paths, snippet, span_lint_and_sugg};
+use crate::utils::{match_def_path, paths, span_lint_and_sugg};
+use clippy_utils::source::snippet;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
diff --git a/clippy_lints/src/dbg_macro.rs b/clippy_lints/src/dbg_macro.rs
index e513dcce64e..3171a945eb0 100644
--- a/clippy_lints/src/dbg_macro.rs
+++ b/clippy_lints/src/dbg_macro.rs
@@ -1,4 +1,5 @@
-use crate::utils::{snippet_opt, span_lint_and_help, span_lint_and_sugg};
+use crate::utils::{span_lint_and_help, span_lint_and_sugg};
+use clippy_utils::source::snippet_opt;
 use rustc_ast::ast;
 use rustc_ast::tokenstream::TokenStream;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/default.rs b/clippy_lints/src/default.rs
index 6fa1378b8c7..7d975b5a3d9 100644
--- a/clippy_lints/src/default.rs
+++ b/clippy_lints/src/default.rs
@@ -1,7 +1,6 @@
-use crate::utils::{
-    any_parent_is_automatically_derived, contains_name, match_def_path, paths, snippet_with_macro_callsite,
-};
+use crate::utils::{any_parent_is_automatically_derived, contains_name, match_def_path, paths};
 use crate::utils::{span_lint_and_note, span_lint_and_sugg};
+use clippy_utils::source::snippet_with_macro_callsite;
 use if_chain::if_chain;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/default_numeric_fallback.rs b/clippy_lints/src/default_numeric_fallback.rs
index 369efacc9bc..e58dcb942c6 100644
--- a/clippy_lints/src/default_numeric_fallback.rs
+++ b/clippy_lints/src/default_numeric_fallback.rs
@@ -1,3 +1,5 @@
+use clippy_utils::source::snippet;
+use if_chain::if_chain;
 use rustc_ast::ast::{LitFloatType, LitIntType, LitKind};
 use rustc_errors::Applicability;
 use rustc_hir::{
@@ -11,9 +13,7 @@ use rustc_middle::{
 };
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
-use if_chain::if_chain;
-
-use crate::utils::{snippet, span_lint_and_sugg};
+use crate::utils::span_lint_and_sugg;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for usage of unconstrained numeric literals which may cause default numeric fallback in type
diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index 8842ea9628d..e112338dfea 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -1,4 +1,5 @@
-use crate::utils::{get_parent_node, in_macro, is_allowed, snippet_with_context, span_lint_and_sugg};
+use crate::utils::{get_parent_node, in_macro, is_allowed, span_lint_and_sugg};
+use clippy_utils::source::snippet_with_context;
 use clippy_utils::ty::peel_mid_ty_refs;
 use rustc_ast::util::parser::PREC_PREFIX;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/double_comparison.rs b/clippy_lints/src/double_comparison.rs
index 19f56195ec1..3de027b2cc6 100644
--- a/clippy_lints/src/double_comparison.rs
+++ b/clippy_lints/src/double_comparison.rs
@@ -1,12 +1,13 @@
 //! Lint on unnecessary double comparisons. Some examples:
 
+use clippy_utils::source::snippet_with_applicability;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
 
-use crate::utils::{eq_expr_value, snippet_with_applicability, span_lint_and_sugg};
+use crate::utils::{eq_expr_value, span_lint_and_sugg};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for double comparisons that could be simplified to a single expression.
diff --git a/clippy_lints/src/duration_subsec.rs b/clippy_lints/src/duration_subsec.rs
index c97392e3385..195143d720d 100644
--- a/clippy_lints/src/duration_subsec.rs
+++ b/clippy_lints/src/duration_subsec.rs
@@ -1,3 +1,4 @@
+use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::match_type;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
@@ -8,7 +9,7 @@ use rustc_span::source_map::Spanned;
 
 use crate::consts::{constant, Constant};
 use crate::utils::paths;
-use crate::utils::{snippet_with_applicability, span_lint_and_sugg};
+use crate::utils::span_lint_and_sugg;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for calculation of subsecond microseconds or milliseconds
diff --git a/clippy_lints/src/entry.rs b/clippy_lints/src/entry.rs
index 68363e53f0e..93723219594 100644
--- a/clippy_lints/src/entry.rs
+++ b/clippy_lints/src/entry.rs
@@ -1,6 +1,7 @@
+use crate::utils::span_lint_and_then;
 use crate::utils::SpanlessEq;
-use crate::utils::{get_item_name, paths, snippet, snippet_opt};
-use crate::utils::{snippet_with_applicability, span_lint_and_then};
+use crate::utils::{get_item_name, paths};
+use clippy_utils::source::{snippet, snippet_opt, snippet_with_applicability};
 use clippy_utils::ty::{is_type_diagnostic_item, match_type};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/enum_variants.rs b/clippy_lints/src/enum_variants.rs
index 67a46353856..660131cf176 100644
--- a/clippy_lints/src/enum_variants.rs
+++ b/clippy_lints/src/enum_variants.rs
@@ -1,7 +1,8 @@
 //! lint on enum variants that are prefixed or suffixed by the same characters
 
-use crate::utils::{camel_case, is_present_in_source};
+use crate::utils::camel_case;
 use crate::utils::{span_lint, span_lint_and_help};
+use clippy_utils::source::is_present_in_source;
 use rustc_ast::ast::{EnumDef, Item, ItemKind, VisibilityKind};
 use rustc_lint::{EarlyContext, EarlyLintPass, Lint};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
diff --git a/clippy_lints/src/eq_op.rs b/clippy_lints/src/eq_op.rs
index fa19f16074d..0a5917c10ea 100644
--- a/clippy_lints/src/eq_op.rs
+++ b/clippy_lints/src/eq_op.rs
@@ -1,7 +1,8 @@
 use crate::utils::{
-    ast_utils::is_useless_with_eq_exprs, eq_expr_value, higher, in_macro, is_expn_of, multispan_sugg, snippet,
-    span_lint, span_lint_and_then,
+    ast_utils::is_useless_with_eq_exprs, eq_expr_value, higher, in_macro, is_expn_of, multispan_sugg, span_lint,
+    span_lint_and_then,
 };
+use clippy_utils::source::snippet;
 use clippy_utils::ty::{implements_trait, is_copy};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/eta_reduction.rs b/clippy_lints/src/eta_reduction.rs
index d93c32c179f..e8d5b992b63 100644
--- a/clippy_lints/src/eta_reduction.rs
+++ b/clippy_lints/src/eta_reduction.rs
@@ -1,5 +1,6 @@
 use clippy_utils::higher;
 use clippy_utils::higher::VecArgs;
+use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::{implements_trait, type_is_unsafe_function};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
@@ -9,7 +10,7 @@ use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::{self, Ty};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
-use crate::utils::{is_adjusted, iter_input_pats, snippet_opt, span_lint_and_sugg, span_lint_and_then};
+use crate::utils::{is_adjusted, iter_input_pats, span_lint_and_sugg, span_lint_and_then};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for closures which just call another function where
diff --git a/clippy_lints/src/exhaustive_items.rs b/clippy_lints/src/exhaustive_items.rs
index 316f7484862..5e31072523d 100644
--- a/clippy_lints/src/exhaustive_items.rs
+++ b/clippy_lints/src/exhaustive_items.rs
@@ -1,11 +1,14 @@
-use crate::utils::{indent_of, span_lint_and_then};
+use clippy_utils::source::indent_of;
 use if_chain::if_chain;
+
 use rustc_errors::Applicability;
 use rustc_hir::{Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::sym;
 
+use crate::utils::span_lint_and_then;
+
 declare_clippy_lint! {
     /// **What it does:** Warns on any exported `enum`s that are not tagged `#[non_exhaustive]`
     ///
diff --git a/clippy_lints/src/format.rs b/clippy_lints/src/format.rs
index b6209f815bc..c0048bb2175 100644
--- a/clippy_lints/src/format.rs
+++ b/clippy_lints/src/format.rs
@@ -1,7 +1,6 @@
 use crate::utils::paths;
-use crate::utils::{
-    is_expn_of, last_path_segment, match_def_path, match_function_call, snippet, snippet_opt, span_lint_and_then,
-};
+use crate::utils::{is_expn_of, last_path_segment, match_def_path, match_function_call, span_lint_and_then};
+use clippy_utils::source::{snippet, snippet_opt};
 use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
diff --git a/clippy_lints/src/formatting.rs b/clippy_lints/src/formatting.rs
index 1bd16e6cce5..590de04717a 100644
--- a/clippy_lints/src/formatting.rs
+++ b/clippy_lints/src/formatting.rs
@@ -1,4 +1,5 @@
-use crate::utils::{differing_macro_contexts, snippet_opt, span_lint_and_help, span_lint_and_note};
+use crate::utils::{differing_macro_contexts, span_lint_and_help, span_lint_and_note};
+use clippy_utils::source::snippet_opt;
 use if_chain::if_chain;
 use rustc_ast::ast::{BinOpKind, Block, Expr, ExprKind, StmtKind, UnOp};
 use rustc_lint::{EarlyContext, EarlyLintPass};
diff --git a/clippy_lints/src/functions.rs b/clippy_lints/src/functions.rs
index 349cd39ffb6..104c692dcec 100644
--- a/clippy_lints/src/functions.rs
+++ b/clippy_lints/src/functions.rs
@@ -1,8 +1,8 @@
 use crate::utils::{
     attr_by_name, attrs::is_proc_macro, is_trait_impl_item, iter_input_pats, match_def_path, must_use_attr,
-    path_to_local, return_ty, snippet, snippet_opt, span_lint, span_lint_and_help, span_lint_and_then,
-    trait_ref_of_method,
+    path_to_local, return_ty, span_lint, span_lint_and_help, span_lint_and_then, trait_ref_of_method,
 };
+use clippy_utils::source::{snippet, snippet_opt};
 use clippy_utils::ty::{is_must_use_ty, is_type_diagnostic_item, type_is_unsafe_function};
 use if_chain::if_chain;
 use rustc_ast::ast::Attribute;
diff --git a/clippy_lints/src/get_last_with_len.rs b/clippy_lints/src/get_last_with_len.rs
index 478008ea48c..875cd33bc8f 100644
--- a/clippy_lints/src/get_last_with_len.rs
+++ b/clippy_lints/src/get_last_with_len.rs
@@ -1,6 +1,7 @@
 //! lint on using `x.get(x.len() - 1)` instead of `x.last()`
 
-use crate::utils::{snippet_with_applicability, span_lint_and_sugg, SpanlessEq};
+use crate::utils::{span_lint_and_sugg, SpanlessEq};
+use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
diff --git a/clippy_lints/src/identity_op.rs b/clippy_lints/src/identity_op.rs
index 8501d347702..fc93864c74a 100644
--- a/clippy_lints/src/identity_op.rs
+++ b/clippy_lints/src/identity_op.rs
@@ -1,3 +1,4 @@
+use clippy_utils::source::snippet;
 use if_chain::if_chain;
 use rustc_hir::{BinOp, BinOpKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
@@ -6,7 +7,7 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
 
 use crate::consts::{constant_simple, Constant};
-use crate::utils::{clip, snippet, span_lint, unsext};
+use crate::utils::{clip, span_lint, unsext};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for identity operations, e.g., `x + 0`.
diff --git a/clippy_lints/src/if_let_some_result.rs b/clippy_lints/src/if_let_some_result.rs
index 0cd44a1c3a0..9f7ca95a8f3 100644
--- a/clippy_lints/src/if_let_some_result.rs
+++ b/clippy_lints/src/if_let_some_result.rs
@@ -1,4 +1,5 @@
-use crate::utils::{method_chain_args, snippet_with_applicability, span_lint_and_sugg};
+use crate::utils::{method_chain_args, span_lint_and_sugg};
+use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/if_then_some_else_none.rs b/clippy_lints/src/if_then_some_else_none.rs
index a527f51b1fd..7e1807786ee 100644
--- a/clippy_lints/src/if_then_some_else_none.rs
+++ b/clippy_lints/src/if_then_some_else_none.rs
@@ -1,4 +1,5 @@
 use crate::utils;
+use clippy_utils::source::snippet_with_macro_callsite;
 use if_chain::if_chain;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
@@ -82,13 +83,13 @@ impl LateLintPass<'_> for IfThenSomeElseNone {
             if let ExprKind::Path(ref els_call_qpath) = els_expr.kind;
             if utils::match_qpath(els_call_qpath, &utils::paths::OPTION_NONE);
             then {
-                let cond_snip = utils::snippet_with_macro_callsite(cx, cond.span, "[condition]");
+                let cond_snip = snippet_with_macro_callsite(cx, cond.span, "[condition]");
                 let cond_snip = if matches!(cond.kind, ExprKind::Unary(_, _) | ExprKind::Binary(_, _, _)) {
                     format!("({})", cond_snip)
                 } else {
                     cond_snip.into_owned()
                 };
-                let arg_snip = utils::snippet_with_macro_callsite(cx, then_arg.span, "");
+                let arg_snip = snippet_with_macro_callsite(cx, then_arg.span, "");
                 let closure_body = if then_block.stmts.is_empty() {
                     arg_snip.into_owned()
                 } else {
diff --git a/clippy_lints/src/implicit_return.rs b/clippy_lints/src/implicit_return.rs
index b4f814e1dcc..e86bd49251d 100644
--- a/clippy_lints/src/implicit_return.rs
+++ b/clippy_lints/src/implicit_return.rs
@@ -1,4 +1,5 @@
-use crate::utils::{match_panic_def_id, snippet_opt, span_lint_and_then};
+use crate::utils::{match_panic_def_id, span_lint_and_then};
+use clippy_utils::source::snippet_opt;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::FnKind;
diff --git a/clippy_lints/src/inconsistent_struct_constructor.rs b/clippy_lints/src/inconsistent_struct_constructor.rs
index 49c17a12102..4762d5d40f3 100644
--- a/clippy_lints/src/inconsistent_struct_constructor.rs
+++ b/clippy_lints/src/inconsistent_struct_constructor.rs
@@ -1,3 +1,5 @@
+use clippy_utils::source::snippet;
+use if_chain::if_chain;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::Applicability;
 use rustc_hir::{self as hir, ExprKind};
@@ -5,9 +7,7 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::symbol::Symbol;
 
-use if_chain::if_chain;
-
-use crate::utils::{snippet, span_lint_and_sugg};
+use crate::utils::span_lint_and_sugg;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for struct constructors where all fields are shorthand and
diff --git a/clippy_lints/src/int_plus_one.rs b/clippy_lints/src/int_plus_one.rs
index 260b8988d37..9eae653dd67 100644
--- a/clippy_lints/src/int_plus_one.rs
+++ b/clippy_lints/src/int_plus_one.rs
@@ -1,11 +1,12 @@
 //! lint on blocks unnecessarily using >= with a + 1 or - 1
 
+use clippy_utils::source::snippet_opt;
 use rustc_ast::ast::{BinOpKind, Expr, ExprKind, Lit, LitKind};
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
-use crate::utils::{snippet_opt, span_lint_and_sugg};
+use crate::utils::span_lint_and_sugg;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for usage of `x >= y + 1` or `x - 1 >= y` (and `<=`) in a block
diff --git a/clippy_lints/src/large_enum_variant.rs b/clippy_lints/src/large_enum_variant.rs
index ab4cb33612d..cbb5192bfd9 100644
--- a/clippy_lints/src/large_enum_variant.rs
+++ b/clippy_lints/src/large_enum_variant.rs
@@ -1,6 +1,7 @@
 //! lint when there is a large size difference between variants on an enum
 
-use crate::utils::{snippet_opt, span_lint_and_then};
+use crate::utils::span_lint_and_then;
+use clippy_utils::source::snippet_opt;
 use rustc_errors::Applicability;
 use rustc_hir::{Item, ItemKind, VariantData};
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/large_stack_arrays.rs b/clippy_lints/src/large_stack_arrays.rs
index 9a448ab1256..ceae4243e63 100644
--- a/clippy_lints/src/large_stack_arrays.rs
+++ b/clippy_lints/src/large_stack_arrays.rs
@@ -1,13 +1,13 @@
+use clippy_utils::source::snippet;
+use if_chain::if_chain;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::mir::interpret::ConstValue;
 use rustc_middle::ty::{self, ConstKind};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 
-use if_chain::if_chain;
-
 use crate::rustc_target::abi::LayoutOf;
-use crate::utils::{snippet, span_lint_and_help};
+use crate::utils::span_lint_and_help;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for local arrays that may be too large.
diff --git a/clippy_lints/src/len_zero.rs b/clippy_lints/src/len_zero.rs
index 1e1023b2743..e758a269fbe 100644
--- a/clippy_lints/src/len_zero.rs
+++ b/clippy_lints/src/len_zero.rs
@@ -1,7 +1,5 @@
-use crate::utils::{
-    get_item_name, get_parent_as_impl, is_allowed, snippet_with_applicability, span_lint, span_lint_and_sugg,
-    span_lint_and_then,
-};
+use crate::utils::{get_item_name, get_parent_as_impl, is_allowed, span_lint, span_lint_and_sugg, span_lint_and_then};
+use clippy_utils::source::snippet_with_applicability;
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
 use rustc_data_structures::fx::FxHashSet;
diff --git a/clippy_lints/src/let_if_seq.rs b/clippy_lints/src/let_if_seq.rs
index 5863eef8a26..7059ba21207 100644
--- a/clippy_lints/src/let_if_seq.rs
+++ b/clippy_lints/src/let_if_seq.rs
@@ -1,4 +1,5 @@
-use crate::utils::{path_to_local_id, snippet, span_lint_and_then, visitors::LocalUsedVisitor};
+use crate::utils::{path_to_local_id, span_lint_and_then, visitors::LocalUsedVisitor};
+use clippy_utils::source::snippet;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
diff --git a/clippy_lints/src/literal_representation.rs b/clippy_lints/src/literal_representation.rs
index 87a957a9bd2..8bc7bf37ef1 100644
--- a/clippy_lints/src/literal_representation.rs
+++ b/clippy_lints/src/literal_representation.rs
@@ -4,8 +4,9 @@
 use crate::utils::{
     in_macro,
     numeric_literal::{NumericLiteral, Radix},
-    snippet_opt, span_lint_and_sugg,
+    span_lint_and_sugg,
 };
+use clippy_utils::source::snippet_opt;
 use if_chain::if_chain;
 use rustc_ast::ast::{Expr, ExprKind, Lit, LitKind};
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/loops/explicit_counter_loop.rs b/clippy_lints/src/loops/explicit_counter_loop.rs
index 8d98b940c66..1f6d48fe915 100644
--- a/clippy_lints/src/loops/explicit_counter_loop.rs
+++ b/clippy_lints/src/loops/explicit_counter_loop.rs
@@ -1,7 +1,8 @@
 use super::{
     get_span_of_entire_for_loop, make_iterator_snippet, IncrementVisitor, InitializeVisitor, EXPLICIT_COUNTER_LOOP,
 };
-use crate::utils::{get_enclosing_block, is_integer_const, snippet_with_applicability, span_lint_and_sugg};
+use crate::utils::{get_enclosing_block, is_integer_const, span_lint_and_sugg};
+use clippy_utils::source::snippet_with_applicability;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_block, walk_expr};
diff --git a/clippy_lints/src/loops/explicit_into_iter_loop.rs b/clippy_lints/src/loops/explicit_into_iter_loop.rs
index 1d778205a2a..e5b3dc7aad7 100644
--- a/clippy_lints/src/loops/explicit_into_iter_loop.rs
+++ b/clippy_lints/src/loops/explicit_into_iter_loop.rs
@@ -1,5 +1,6 @@
 use super::EXPLICIT_INTO_ITER_LOOP;
-use crate::utils::{snippet_with_applicability, span_lint_and_sugg};
+use crate::utils::span_lint_and_sugg;
+use clippy_utils::source::snippet_with_applicability;
 use rustc_errors::Applicability;
 use rustc_hir::Expr;
 use rustc_lint::LateContext;
diff --git a/clippy_lints/src/loops/explicit_iter_loop.rs b/clippy_lints/src/loops/explicit_iter_loop.rs
index b70585015ca..d2000d80ac1 100644
--- a/clippy_lints/src/loops/explicit_iter_loop.rs
+++ b/clippy_lints/src/loops/explicit_iter_loop.rs
@@ -1,4 +1,6 @@
 use super::EXPLICIT_ITER_LOOP;
+use crate::utils::{match_trait_method, paths, span_lint_and_sugg};
+use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::{is_type_diagnostic_item, match_type};
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, Mutability};
@@ -6,8 +8,6 @@ use rustc_lint::LateContext;
 use rustc_middle::ty::{self, Ty, TyS};
 use rustc_span::sym;
 
-use crate::utils::{match_trait_method, paths, snippet_with_applicability, span_lint_and_sugg};
-
 pub(super) fn check(cx: &LateContext<'_>, args: &[Expr<'_>], arg: &Expr<'_>, method_name: &str) {
     let should_lint = match method_name {
         "iter" | "iter_mut" => is_ref_iterable_type(cx, &args[0]),
diff --git a/clippy_lints/src/loops/for_kv_map.rs b/clippy_lints/src/loops/for_kv_map.rs
index aef21886803..19a68dd78d1 100644
--- a/clippy_lints/src/loops/for_kv_map.rs
+++ b/clippy_lints/src/loops/for_kv_map.rs
@@ -1,6 +1,7 @@
 use super::FOR_KV_MAP;
 use crate::utils::visitors::LocalUsedVisitor;
-use crate::utils::{multispan_sugg, paths, snippet, span_lint_and_then, sugg};
+use crate::utils::{multispan_sugg, paths, span_lint_and_then, sugg};
+use clippy_utils::source::snippet;
 use clippy_utils::ty::{is_type_diagnostic_item, match_type};
 use rustc_hir::{BorrowKind, Expr, ExprKind, Mutability, Pat, PatKind};
 use rustc_lint::LateContext;
diff --git a/clippy_lints/src/loops/for_loops_over_fallibles.rs b/clippy_lints/src/loops/for_loops_over_fallibles.rs
index 063078adcd1..5140448592d 100644
--- a/clippy_lints/src/loops/for_loops_over_fallibles.rs
+++ b/clippy_lints/src/loops/for_loops_over_fallibles.rs
@@ -1,6 +1,8 @@
-use super::FOR_LOOPS_OVER_FALLIBLES;
-use crate::utils::{snippet, span_lint_and_help};
+use clippy_utils::source::snippet;
 use clippy_utils::ty::is_type_diagnostic_item;
+
+use super::FOR_LOOPS_OVER_FALLIBLES;
+use crate::utils::span_lint_and_help;
 use rustc_hir::{Expr, Pat};
 use rustc_lint::LateContext;
 use rustc_span::symbol::sym;
diff --git a/clippy_lints/src/loops/manual_memcpy.rs b/clippy_lints/src/loops/manual_memcpy.rs
index 362124c082a..c9c25641160 100644
--- a/clippy_lints/src/loops/manual_memcpy.rs
+++ b/clippy_lints/src/loops/manual_memcpy.rs
@@ -1,6 +1,7 @@
 use super::{get_span_of_entire_for_loop, IncrementVisitor, InitializeVisitor, MANUAL_MEMCPY};
 use crate::utils::sugg::Sugg;
-use crate::utils::{get_enclosing_block, higher, path_to_local, snippet, span_lint_and_sugg, sugg};
+use crate::utils::{get_enclosing_block, higher, path_to_local, span_lint_and_sugg, sugg};
+use clippy_utils::source::snippet;
 use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
 use rustc_ast::ast;
diff --git a/clippy_lints/src/loops/needless_collect.rs b/clippy_lints/src/loops/needless_collect.rs
index f4d3b9eb272..59f7b23af75 100644
--- a/clippy_lints/src/loops/needless_collect.rs
+++ b/clippy_lints/src/loops/needless_collect.rs
@@ -1,6 +1,7 @@
 use super::NEEDLESS_COLLECT;
 use crate::utils::sugg::Sugg;
-use crate::utils::{is_trait_method, path_to_local_id, paths, snippet, span_lint_and_sugg, span_lint_and_then};
+use crate::utils::{is_trait_method, path_to_local_id, paths, span_lint_and_sugg, span_lint_and_then};
+use clippy_utils::source::snippet;
 use clippy_utils::ty::{is_type_diagnostic_item, match_type};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/loops/needless_range_loop.rs b/clippy_lints/src/loops/needless_range_loop.rs
index 6d498149166..674cb34c37b 100644
--- a/clippy_lints/src/loops/needless_range_loop.rs
+++ b/clippy_lints/src/loops/needless_range_loop.rs
@@ -1,9 +1,10 @@
 use super::NEEDLESS_RANGE_LOOP;
 use crate::utils::visitors::LocalUsedVisitor;
 use crate::utils::{
-    contains_name, higher, is_integer_const, match_trait_method, multispan_sugg, path_to_local_id, paths, snippet,
+    contains_name, higher, is_integer_const, match_trait_method, multispan_sugg, path_to_local_id, paths,
     span_lint_and_then, sugg, SpanlessEq,
 };
+use clippy_utils::source::snippet;
 use clippy_utils::ty::has_iter_method;
 use if_chain::if_chain;
 use rustc_ast::ast;
diff --git a/clippy_lints/src/loops/same_item_push.rs b/clippy_lints/src/loops/same_item_push.rs
index f891f7b8a1f..255d6de4a36 100644
--- a/clippy_lints/src/loops/same_item_push.rs
+++ b/clippy_lints/src/loops/same_item_push.rs
@@ -1,5 +1,6 @@
 use super::SAME_ITEM_PUSH;
-use crate::utils::{snippet_with_macro_callsite, span_lint_and_help};
+use crate::utils::span_lint_and_help;
+use clippy_utils::source::snippet_with_macro_callsite;
 use clippy_utils::ty::{implements_trait, is_type_diagnostic_item};
 use if_chain::if_chain;
 use rustc_hir::def::{DefKind, Res};
diff --git a/clippy_lints/src/loops/single_element_loop.rs b/clippy_lints/src/loops/single_element_loop.rs
index 38400c93c9a..4f83191d919 100644
--- a/clippy_lints/src/loops/single_element_loop.rs
+++ b/clippy_lints/src/loops/single_element_loop.rs
@@ -1,5 +1,6 @@
 use super::{get_span_of_entire_for_loop, SINGLE_ELEMENT_LOOP};
-use crate::utils::{indent_of, single_segment_path, snippet, span_lint_and_sugg};
+use crate::utils::{single_segment_path, span_lint_and_sugg};
+use clippy_utils::source::{indent_of, snippet};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{BorrowKind, Expr, ExprKind, Pat, PatKind};
diff --git a/clippy_lints/src/loops/while_let_loop.rs b/clippy_lints/src/loops/while_let_loop.rs
index 65d8f2f1111..dbd9126861f 100644
--- a/clippy_lints/src/loops/while_let_loop.rs
+++ b/clippy_lints/src/loops/while_let_loop.rs
@@ -1,5 +1,6 @@
 use super::WHILE_LET_LOOP;
-use crate::utils::{snippet_with_applicability, span_lint_and_sugg};
+use crate::utils::span_lint_and_sugg;
+use clippy_utils::source::snippet_with_applicability;
 use rustc_errors::Applicability;
 use rustc_hir::{Block, Expr, ExprKind, MatchSource, StmtKind};
 use rustc_lint::{LateContext, LintContext};
diff --git a/clippy_lints/src/loops/while_let_on_iterator.rs b/clippy_lints/src/loops/while_let_on_iterator.rs
index 619fd1554f0..ccabe586c2b 100644
--- a/clippy_lints/src/loops/while_let_on_iterator.rs
+++ b/clippy_lints/src/loops/while_let_on_iterator.rs
@@ -3,8 +3,9 @@ use super::WHILE_LET_ON_ITERATOR;
 use crate::utils::usage::mutated_variables;
 use crate::utils::{
     get_enclosing_block, is_refutable, is_trait_method, last_path_segment, path_to_local, path_to_local_id,
-    snippet_with_applicability, span_lint_and_sugg,
+    span_lint_and_sugg,
 };
+use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::implements_trait;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/macro_use.rs b/clippy_lints/src/macro_use.rs
index 6d9c78393c8..637f10f6609 100644
--- a/clippy_lints/src/macro_use.rs
+++ b/clippy_lints/src/macro_use.rs
@@ -1,4 +1,5 @@
-use crate::utils::{in_macro, snippet, span_lint_and_sugg};
+use crate::utils::{in_macro, span_lint_and_sugg};
+use clippy_utils::source::snippet;
 use hir::def::{DefKind, Res};
 use if_chain::if_chain;
 use rustc_ast::ast;
diff --git a/clippy_lints/src/main_recursion.rs b/clippy_lints/src/main_recursion.rs
index 1b274c79d38..5db2968e42c 100644
--- a/clippy_lints/src/main_recursion.rs
+++ b/clippy_lints/src/main_recursion.rs
@@ -1,9 +1,10 @@
+use clippy_utils::source::snippet;
+use if_chain::if_chain;
 use rustc_hir::{Crate, Expr, ExprKind, QPath};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 
-use crate::utils::{is_entrypoint_fn, is_no_std_crate, snippet, span_lint_and_help};
-use if_chain::if_chain;
+use crate::utils::{is_entrypoint_fn, is_no_std_crate, span_lint_and_help};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for recursion using the entrypoint.
diff --git a/clippy_lints/src/manual_async_fn.rs b/clippy_lints/src/manual_async_fn.rs
index 2e2e693592c..ebc493c0f7e 100644
--- a/clippy_lints/src/manual_async_fn.rs
+++ b/clippy_lints/src/manual_async_fn.rs
@@ -1,5 +1,6 @@
 use crate::utils::paths::FUTURE_FROM_GENERATOR;
-use crate::utils::{match_function_call, position_before_rarrow, snippet_block, snippet_opt, span_lint_and_then};
+use crate::utils::{match_function_call, span_lint_and_then};
+use clippy_utils::source::{position_before_rarrow, snippet_block, snippet_opt};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::FnKind;
diff --git a/clippy_lints/src/manual_map.rs b/clippy_lints/src/manual_map.rs
index 7c89359f2d9..3896645ca7d 100644
--- a/clippy_lints/src/manual_map.rs
+++ b/clippy_lints/src/manual_map.rs
@@ -1,11 +1,9 @@
 use crate::{
     map_unit_fn::OPTION_MAP_UNIT_FN,
     matches::MATCH_AS_REF,
-    utils::{
-        is_allowed, match_def_path, match_var, paths, peel_hir_expr_refs, snippet_with_applicability,
-        snippet_with_context, span_lint_and_sugg,
-    },
+    utils::{is_allowed, match_def_path, match_var, paths, peel_hir_expr_refs, span_lint_and_sugg},
 };
+use clippy_utils::source::{snippet_with_applicability, snippet_with_context};
 use clippy_utils::ty::{can_partially_move_ty, is_type_diagnostic_item, peel_mid_ty_refs_is_mutable};
 use rustc_ast::util::parser::PREC_POSTFIX;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/manual_non_exhaustive.rs b/clippy_lints/src/manual_non_exhaustive.rs
index 91849e74887..0b8c049b466 100644
--- a/clippy_lints/src/manual_non_exhaustive.rs
+++ b/clippy_lints/src/manual_non_exhaustive.rs
@@ -1,4 +1,5 @@
-use crate::utils::{meets_msrv, snippet_opt, span_lint_and_then};
+use crate::utils::{meets_msrv, span_lint_and_then};
+use clippy_utils::source::snippet_opt;
 use if_chain::if_chain;
 use rustc_ast::ast::{Attribute, Item, ItemKind, StructField, Variant, VariantData, VisibilityKind};
 use rustc_attr as attr;
diff --git a/clippy_lints/src/manual_ok_or.rs b/clippy_lints/src/manual_ok_or.rs
index b08829a8bbf..f436eccc0dc 100644
--- a/clippy_lints/src/manual_ok_or.rs
+++ b/clippy_lints/src/manual_ok_or.rs
@@ -1,6 +1,5 @@
-use crate::utils::{
-    indent_of, match_qpath, path_to_local_id, paths, reindent_multiline, snippet_opt, span_lint_and_sugg,
-};
+use crate::utils::{match_qpath, path_to_local_id, paths, span_lint_and_sugg};
+use clippy_utils::source::{indent_of, reindent_multiline, snippet_opt};
 use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/manual_strip.rs b/clippy_lints/src/manual_strip.rs
index 42a92104a49..3bfca8bea40 100644
--- a/clippy_lints/src/manual_strip.rs
+++ b/clippy_lints/src/manual_strip.rs
@@ -1,9 +1,7 @@
 use crate::consts::{constant, Constant};
 use crate::utils::usage::mutated_variables;
-use crate::utils::{
-    eq_expr_value, higher, match_def_path, meets_msrv, multispan_sugg, paths, snippet, span_lint_and_then,
-};
-
+use crate::utils::{eq_expr_value, higher, match_def_path, meets_msrv, multispan_sugg, paths, span_lint_and_then};
+use clippy_utils::source::snippet;
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
 use rustc_hir::def::Res;
diff --git a/clippy_lints/src/manual_unwrap_or.rs b/clippy_lints/src/manual_unwrap_or.rs
index 3a1bde9540d..7a4040539e3 100644
--- a/clippy_lints/src/manual_unwrap_or.rs
+++ b/clippy_lints/src/manual_unwrap_or.rs
@@ -1,6 +1,7 @@
 use crate::consts::constant_simple;
 use crate::utils;
 use crate::utils::{path_to_local_id, sugg};
+use clippy_utils::source::{indent_of, reindent_multiline, snippet_opt};
 use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
@@ -105,12 +106,12 @@ fn lint_manual_unwrap_or<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
             None
         };
         if let Some(or_arm) = applicable_or_arm(match_arms);
-        if let Some(or_body_snippet) = utils::snippet_opt(cx, or_arm.body.span);
-        if let Some(indent) = utils::indent_of(cx, expr.span);
+        if let Some(or_body_snippet) = snippet_opt(cx, or_arm.body.span);
+        if let Some(indent) = indent_of(cx, expr.span);
         if constant_simple(cx, cx.typeck_results(), or_arm.body).is_some();
         then {
             let reindented_or_body =
-                utils::reindent_multiline(or_body_snippet.into(), true, Some(indent));
+                reindent_multiline(or_body_snippet.into(), true, Some(indent));
             utils::span_lint_and_sugg(
                 cx,
                 MANUAL_UNWRAP_OR, expr.span,
diff --git a/clippy_lints/src/map_clone.rs b/clippy_lints/src/map_clone.rs
index 73d924cd51e..e10d7647bcf 100644
--- a/clippy_lints/src/map_clone.rs
+++ b/clippy_lints/src/map_clone.rs
@@ -1,5 +1,6 @@
 use crate::utils::is_trait_method;
-use crate::utils::{remove_blocks, snippet_with_applicability, span_lint_and_sugg};
+use crate::utils::{remove_blocks, span_lint_and_sugg};
+use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::{is_copy, is_type_diagnostic_item};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/map_unit_fn.rs b/clippy_lints/src/map_unit_fn.rs
index 6f4ce87ea5c..24bcc808585 100644
--- a/clippy_lints/src/map_unit_fn.rs
+++ b/clippy_lints/src/map_unit_fn.rs
@@ -1,4 +1,5 @@
-use crate::utils::{iter_input_pats, method_chain_args, snippet, span_lint_and_then};
+use crate::utils::{iter_input_pats, method_chain_args, span_lint_and_then};
+use clippy_utils::source::snippet;
 use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/match_on_vec_items.rs b/clippy_lints/src/match_on_vec_items.rs
index 65afd691d62..57dcd8709b8 100644
--- a/clippy_lints/src/match_on_vec_items.rs
+++ b/clippy_lints/src/match_on_vec_items.rs
@@ -1,4 +1,5 @@
-use crate::utils::{snippet, span_lint_and_sugg};
+use crate::utils::span_lint_and_sugg;
+use clippy_utils::source::snippet;
 use clippy_utils::ty::{is_type_diagnostic_item, is_type_lang_item};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index 4689974e850..4ae1ce977f4 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -2,12 +2,12 @@ use crate::consts::{constant, miri_to_const, Constant};
 use crate::utils::sugg::Sugg;
 use crate::utils::visitors::LocalUsedVisitor;
 use crate::utils::{
-    expr_block, get_parent_expr, in_macro, indent_of, is_allowed, is_expn_of, is_refutable, is_wild, match_qpath,
-    meets_msrv, multispan_sugg, path_to_local, path_to_local_id, peel_hir_pat_refs, peel_n_hir_expr_refs,
-    remove_blocks, snippet, snippet_block, snippet_opt, snippet_with_applicability, span_lint_and_help,
+    get_parent_expr, in_macro, is_allowed, is_expn_of, is_refutable, is_wild, match_qpath, meets_msrv, multispan_sugg,
+    path_to_local, path_to_local_id, peel_hir_pat_refs, peel_n_hir_expr_refs, remove_blocks, span_lint_and_help,
     span_lint_and_note, span_lint_and_sugg, span_lint_and_then, strip_pat_refs,
 };
 use crate::utils::{paths, search_same, SpanlessEq, SpanlessHash};
+use clippy_utils::source::{expr_block, indent_of, snippet, snippet_block, snippet_opt, snippet_with_applicability};
 use clippy_utils::ty::{implements_trait, is_type_diagnostic_item, match_type, peel_mid_ty_refs};
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
@@ -1614,7 +1614,8 @@ where
 
 mod redundant_pattern_match {
     use super::REDUNDANT_PATTERN_MATCHING;
-    use crate::utils::{is_trait_method, match_qpath, paths, snippet, span_lint_and_then};
+    use crate::utils::{is_trait_method, match_qpath, paths, span_lint_and_then};
+    use clippy_utils::source::snippet;
     use if_chain::if_chain;
     use rustc_ast::ast::LitKind;
     use rustc_errors::Applicability;
diff --git a/clippy_lints/src/mem_discriminant.rs b/clippy_lints/src/mem_discriminant.rs
index d9d86ac9912..fbdc0cdb2d8 100644
--- a/clippy_lints/src/mem_discriminant.rs
+++ b/clippy_lints/src/mem_discriminant.rs
@@ -1,4 +1,5 @@
-use crate::utils::{match_def_path, paths, snippet, span_lint_and_then};
+use crate::utils::{match_def_path, paths, span_lint_and_then};
+use clippy_utils::source::snippet;
 use clippy_utils::ty::walk_ptrs_ty_depth;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/mem_replace.rs b/clippy_lints/src/mem_replace.rs
index 13f9c9b71f3..bf3f6f7f830 100644
--- a/clippy_lints/src/mem_replace.rs
+++ b/clippy_lints/src/mem_replace.rs
@@ -1,7 +1,9 @@
 use crate::utils::{
-    in_macro, match_def_path, match_qpath, meets_msrv, paths, snippet, snippet_with_applicability, span_lint_and_help,
-    span_lint_and_sugg, span_lint_and_then,
+    in_macro, match_def_path, match_qpath, meets_msrv, paths, span_lint_and_help, span_lint_and_sugg,
+    span_lint_and_then,
 };
+use clippy_utils::is_diagnostic_assoc_item;
+use clippy_utils::source::{snippet, snippet_with_applicability};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::def_id::DefId;
@@ -13,8 +15,6 @@ use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::Span;
 use rustc_span::symbol::sym;
 
-use clippy_utils::is_diagnostic_assoc_item;
-
 declare_clippy_lint! {
     /// **What it does:** Checks for `mem::replace()` on an `Option` with
     /// `None`.
diff --git a/clippy_lints/src/methods/bind_instead_of_map.rs b/clippy_lints/src/methods/bind_instead_of_map.rs
index 073d684dbe3..99b3be67f18 100644
--- a/clippy_lints/src/methods/bind_instead_of_map.rs
+++ b/clippy_lints/src/methods/bind_instead_of_map.rs
@@ -1,8 +1,9 @@
 use super::{contains_return, BIND_INSTEAD_OF_MAP};
 use crate::utils::{
-    in_macro, match_qpath, method_calls, multispan_sugg_with_applicability, paths, remove_blocks, snippet,
-    snippet_with_macro_callsite, span_lint_and_sugg, span_lint_and_then, visitors::find_all_ret_expressions,
+    in_macro, match_qpath, method_calls, multispan_sugg_with_applicability, paths, remove_blocks, span_lint_and_sugg,
+    span_lint_and_then, visitors::find_all_ret_expressions,
 };
+use clippy_utils::source::{snippet, snippet_with_macro_callsite};
 use clippy_utils::ty::match_type;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/methods/bytes_nth.rs b/clippy_lints/src/methods/bytes_nth.rs
index a695c27f11b..f81e9a8c524 100644
--- a/clippy_lints/src/methods/bytes_nth.rs
+++ b/clippy_lints/src/methods/bytes_nth.rs
@@ -1,4 +1,5 @@
-use crate::utils::{snippet_with_applicability, span_lint_and_sugg};
+use crate::utils::span_lint_and_sugg;
+use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/methods/clone_on_ref_ptr.rs b/clippy_lints/src/methods/clone_on_ref_ptr.rs
index 7bc4ed622dc..90ecb2382e7 100644
--- a/clippy_lints/src/methods/clone_on_ref_ptr.rs
+++ b/clippy_lints/src/methods/clone_on_ref_ptr.rs
@@ -1,4 +1,5 @@
-use crate::utils::{paths, snippet_with_macro_callsite, span_lint_and_sugg};
+use crate::utils::{paths, span_lint_and_sugg};
+use clippy_utils::source::snippet_with_macro_callsite;
 use clippy_utils::ty::{is_type_diagnostic_item, match_type};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
diff --git a/clippy_lints/src/methods/expect_fun_call.rs b/clippy_lints/src/methods/expect_fun_call.rs
index 3de35c930ea..9e96d571337 100644
--- a/clippy_lints/src/methods/expect_fun_call.rs
+++ b/clippy_lints/src/methods/expect_fun_call.rs
@@ -1,4 +1,5 @@
-use crate::utils::{is_expn_of, snippet, snippet_with_applicability, span_lint_and_sugg};
+use crate::utils::{is_expn_of, span_lint_and_sugg};
+use clippy_utils::source::{snippet, snippet_with_applicability};
 use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/methods/filter_map.rs b/clippy_lints/src/methods/filter_map.rs
index 91c11afcaaf..964c4903ed2 100644
--- a/clippy_lints/src/methods/filter_map.rs
+++ b/clippy_lints/src/methods/filter_map.rs
@@ -1,4 +1,5 @@
-use crate::utils::{is_trait_method, path_to_local_id, snippet, span_lint_and_sugg, SpanlessEq};
+use crate::utils::{is_trait_method, path_to_local_id, span_lint_and_sugg, SpanlessEq};
+use clippy_utils::source::snippet;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
diff --git a/clippy_lints/src/methods/filter_map_next.rs b/clippy_lints/src/methods/filter_map_next.rs
index 9019202df0c..ed75315b52c 100644
--- a/clippy_lints/src/methods/filter_map_next.rs
+++ b/clippy_lints/src/methods/filter_map_next.rs
@@ -1,4 +1,5 @@
-use crate::utils::{is_trait_method, meets_msrv, snippet, span_lint, span_lint_and_sugg};
+use crate::utils::{is_trait_method, meets_msrv, span_lint, span_lint_and_sugg};
+use clippy_utils::source::snippet;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
diff --git a/clippy_lints/src/methods/filter_next.rs b/clippy_lints/src/methods/filter_next.rs
index 34787b9a828..097f9fdf2c4 100644
--- a/clippy_lints/src/methods/filter_next.rs
+++ b/clippy_lints/src/methods/filter_next.rs
@@ -1,4 +1,5 @@
-use crate::utils::{is_trait_method, snippet, span_lint, span_lint_and_sugg};
+use crate::utils::{is_trait_method, span_lint, span_lint_and_sugg};
+use clippy_utils::source::snippet;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
diff --git a/clippy_lints/src/methods/get_unwrap.rs b/clippy_lints/src/methods/get_unwrap.rs
index 35071a25cec..b9d34b402bb 100644
--- a/clippy_lints/src/methods/get_unwrap.rs
+++ b/clippy_lints/src/methods/get_unwrap.rs
@@ -1,5 +1,6 @@
 use crate::methods::derefs_to_slice;
-use crate::utils::{get_parent_expr, paths, snippet_with_applicability, span_lint_and_sugg};
+use crate::utils::{get_parent_expr, paths, span_lint_and_sugg};
+use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::{is_type_diagnostic_item, match_type};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/methods/inefficient_to_string.rs b/clippy_lints/src/methods/inefficient_to_string.rs
index 42ba62cd4e7..19d05b5c693 100644
--- a/clippy_lints/src/methods/inefficient_to_string.rs
+++ b/clippy_lints/src/methods/inefficient_to_string.rs
@@ -1,5 +1,6 @@
 use super::INEFFICIENT_TO_STRING;
-use crate::utils::{match_def_path, paths, snippet_with_applicability, span_lint_and_then};
+use crate::utils::{match_def_path, paths, span_lint_and_then};
+use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::{is_type_diagnostic_item, walk_ptrs_ty_depth};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/methods/iter_count.rs b/clippy_lints/src/methods/iter_count.rs
index 320fd15d6f8..0f393423b7d 100644
--- a/clippy_lints/src/methods/iter_count.rs
+++ b/clippy_lints/src/methods/iter_count.rs
@@ -1,5 +1,6 @@
 use crate::methods::derefs_to_slice;
-use crate::utils::{paths, snippet_with_applicability, span_lint_and_sugg};
+use crate::utils::{paths, span_lint_and_sugg};
+use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::{is_type_diagnostic_item, match_type};
 use rustc_errors::Applicability;
 use rustc_hir::Expr;
diff --git a/clippy_lints/src/methods/iter_next_slice.rs b/clippy_lints/src/methods/iter_next_slice.rs
index 736148d4fb8..f79942576da 100644
--- a/clippy_lints/src/methods/iter_next_slice.rs
+++ b/clippy_lints/src/methods/iter_next_slice.rs
@@ -1,5 +1,6 @@
 use crate::methods::derefs_to_slice;
-use crate::utils::{get_parent_expr, higher, snippet_with_applicability, span_lint_and_sugg};
+use crate::utils::{get_parent_expr, higher, span_lint_and_sugg};
+use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
 use rustc_ast::ast;
diff --git a/clippy_lints/src/methods/iter_nth_zero.rs b/clippy_lints/src/methods/iter_nth_zero.rs
index ca2e5db4382..98ddfdfdf9c 100644
--- a/clippy_lints/src/methods/iter_nth_zero.rs
+++ b/clippy_lints/src/methods/iter_nth_zero.rs
@@ -1,5 +1,6 @@
 use crate::consts::{constant, Constant};
-use crate::utils::{is_trait_method, snippet_with_applicability, span_lint_and_sugg};
+use crate::utils::{is_trait_method, span_lint_and_sugg};
+use clippy_utils::source::snippet_with_applicability;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
diff --git a/clippy_lints/src/methods/iter_skip_next.rs b/clippy_lints/src/methods/iter_skip_next.rs
index bdfa133b9e2..d191ea0a831 100644
--- a/clippy_lints/src/methods/iter_skip_next.rs
+++ b/clippy_lints/src/methods/iter_skip_next.rs
@@ -1,4 +1,5 @@
-use crate::utils::{is_trait_method, snippet, span_lint_and_sugg};
+use crate::utils::{is_trait_method, span_lint_and_sugg};
+use clippy_utils::source::snippet;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
diff --git a/clippy_lints/src/methods/manual_saturating_arithmetic.rs b/clippy_lints/src/methods/manual_saturating_arithmetic.rs
index 0b414e0eb95..d090a35a3cf 100644
--- a/clippy_lints/src/methods/manual_saturating_arithmetic.rs
+++ b/clippy_lints/src/methods/manual_saturating_arithmetic.rs
@@ -1,4 +1,5 @@
-use crate::utils::{match_qpath, snippet_with_applicability, span_lint_and_sugg};
+use crate::utils::{match_qpath, span_lint_and_sugg};
+use clippy_utils::source::snippet_with_applicability;
 use if_chain::if_chain;
 use rustc_ast::ast;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/methods/map_collect_result_unit.rs b/clippy_lints/src/methods/map_collect_result_unit.rs
index 0a8837be752..349b26b9d58 100644
--- a/clippy_lints/src/methods/map_collect_result_unit.rs
+++ b/clippy_lints/src/methods/map_collect_result_unit.rs
@@ -1,4 +1,5 @@
-use crate::utils::{is_trait_method, snippet, span_lint_and_sugg};
+use crate::utils::{is_trait_method, span_lint_and_sugg};
+use clippy_utils::source::snippet;
 use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/methods/map_flatten.rs b/clippy_lints/src/methods/map_flatten.rs
index 3d1c6408dea..56719b3cff2 100644
--- a/clippy_lints/src/methods/map_flatten.rs
+++ b/clippy_lints/src/methods/map_flatten.rs
@@ -1,4 +1,5 @@
-use crate::utils::{is_trait_method, snippet, span_lint_and_sugg};
+use crate::utils::{is_trait_method, span_lint_and_sugg};
+use clippy_utils::source::snippet;
 use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
diff --git a/clippy_lints/src/methods/map_unwrap_or.rs b/clippy_lints/src/methods/map_unwrap_or.rs
index 4346869ae0d..96dbc7ddc63 100644
--- a/clippy_lints/src/methods/map_unwrap_or.rs
+++ b/clippy_lints/src/methods/map_unwrap_or.rs
@@ -1,5 +1,6 @@
 use crate::utils::usage::mutated_variables;
-use crate::utils::{meets_msrv, snippet, span_lint, span_lint_and_sugg};
+use crate::utils::{meets_msrv, span_lint, span_lint_and_sugg};
+use clippy_utils::source::snippet;
 use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 3e78b662b89..6e0ae9416ff 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -52,6 +52,7 @@ mod wrong_self_convention;
 mod zst_offset;
 
 use bind_instead_of_map::BindInsteadOfMap;
+use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::{contains_ty, implements_trait, is_copy, is_type_diagnostic_item};
 use if_chain::if_chain;
 use rustc_ast::ast;
@@ -68,8 +69,8 @@ use rustc_typeck::hir_ty_to_ty;
 
 use crate::utils::{
     contains_return, get_trait_def_id, in_macro, iter_input_pats, match_def_path, match_qpath, method_calls,
-    method_chain_args, paths, return_ty, single_segment_path, snippet_with_applicability, span_lint,
-    span_lint_and_help, span_lint_and_sugg, SpanlessEq,
+    method_chain_args, paths, return_ty, single_segment_path, span_lint, span_lint_and_help, span_lint_and_sugg,
+    SpanlessEq,
 };
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/methods/option_as_ref_deref.rs b/clippy_lints/src/methods/option_as_ref_deref.rs
index 17444336a5e..6597e9f96a8 100644
--- a/clippy_lints/src/methods/option_as_ref_deref.rs
+++ b/clippy_lints/src/methods/option_as_ref_deref.rs
@@ -1,4 +1,5 @@
-use crate::utils::{match_def_path, meets_msrv, path_to_local_id, paths, remove_blocks, snippet, span_lint_and_sugg};
+use crate::utils::{match_def_path, meets_msrv, path_to_local_id, paths, remove_blocks, span_lint_and_sugg};
+use clippy_utils::source::snippet;
 use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/methods/option_map_or_none.rs b/clippy_lints/src/methods/option_map_or_none.rs
index 5bd4a5bfe21..eed71d02467 100644
--- a/clippy_lints/src/methods/option_map_or_none.rs
+++ b/clippy_lints/src/methods/option_map_or_none.rs
@@ -1,4 +1,5 @@
-use crate::utils::{match_qpath, paths, snippet, span_lint_and_sugg};
+use crate::utils::{match_qpath, paths, span_lint_and_sugg};
+use clippy_utils::source::snippet;
 use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
diff --git a/clippy_lints/src/methods/option_map_unwrap_or.rs b/clippy_lints/src/methods/option_map_unwrap_or.rs
index d1c78b3a833..398d8f13bd4 100644
--- a/clippy_lints/src/methods/option_map_unwrap_or.rs
+++ b/clippy_lints/src/methods/option_map_unwrap_or.rs
@@ -1,4 +1,5 @@
-use crate::utils::{differing_macro_contexts, snippet_with_applicability, span_lint_and_then};
+use crate::utils::{differing_macro_contexts, span_lint_and_then};
+use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::is_copy;
 use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_data_structures::fx::FxHashSet;
diff --git a/clippy_lints/src/methods/or_fun_call.rs b/clippy_lints/src/methods/or_fun_call.rs
index 9f24fe79089..634feebe54a 100644
--- a/clippy_lints/src/methods/or_fun_call.rs
+++ b/clippy_lints/src/methods/or_fun_call.rs
@@ -1,8 +1,6 @@
 use crate::utils::eager_or_lazy::is_lazyness_candidate;
-use crate::utils::{
-    contains_return, get_trait_def_id, last_path_segment, paths, snippet, snippet_with_applicability,
-    snippet_with_macro_callsite, span_lint_and_sugg,
-};
+use crate::utils::{contains_return, get_trait_def_id, last_path_segment, paths, span_lint_and_sugg};
+use clippy_utils::source::{snippet, snippet_with_applicability, snippet_with_macro_callsite};
 use clippy_utils::ty::{implements_trait, is_type_diagnostic_item, match_type};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/methods/search_is_some.rs b/clippy_lints/src/methods/search_is_some.rs
index d903f1e74d3..6054579d988 100644
--- a/clippy_lints/src/methods/search_is_some.rs
+++ b/clippy_lints/src/methods/search_is_some.rs
@@ -1,6 +1,5 @@
-use crate::utils::{
-    is_trait_method, snippet, snippet_with_applicability, span_lint_and_help, span_lint_and_sugg, strip_pat_refs,
-};
+use crate::utils::{is_trait_method, span_lint_and_help, span_lint_and_sugg, strip_pat_refs};
+use clippy_utils::source::{snippet, snippet_with_applicability};
 use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/methods/single_char_insert_string.rs b/clippy_lints/src/methods/single_char_insert_string.rs
index 0ce8b66978d..ff67564b39d 100644
--- a/clippy_lints/src/methods/single_char_insert_string.rs
+++ b/clippy_lints/src/methods/single_char_insert_string.rs
@@ -1,5 +1,6 @@
 use crate::methods::get_hint_if_single_char_arg;
-use crate::utils::{snippet_with_applicability, span_lint_and_sugg};
+use crate::utils::span_lint_and_sugg;
+use clippy_utils::source::snippet_with_applicability;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
diff --git a/clippy_lints/src/methods/single_char_push_string.rs b/clippy_lints/src/methods/single_char_push_string.rs
index deacc70b713..18df90c1ab3 100644
--- a/clippy_lints/src/methods/single_char_push_string.rs
+++ b/clippy_lints/src/methods/single_char_push_string.rs
@@ -1,5 +1,6 @@
 use crate::methods::get_hint_if_single_char_arg;
-use crate::utils::{snippet_with_applicability, span_lint_and_sugg};
+use crate::utils::span_lint_and_sugg;
+use clippy_utils::source::snippet_with_applicability;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
diff --git a/clippy_lints/src/methods/string_extend_chars.rs b/clippy_lints/src/methods/string_extend_chars.rs
index 5b8cca34931..1b26e8314af 100644
--- a/clippy_lints/src/methods/string_extend_chars.rs
+++ b/clippy_lints/src/methods/string_extend_chars.rs
@@ -1,4 +1,5 @@
-use crate::utils::{method_chain_args, snippet_with_applicability, span_lint_and_sugg};
+use crate::utils::{method_chain_args, span_lint_and_sugg};
+use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
diff --git a/clippy_lints/src/methods/unnecessary_fold.rs b/clippy_lints/src/methods/unnecessary_fold.rs
index 9aa53f02ef0..4d5cbdd619d 100644
--- a/clippy_lints/src/methods/unnecessary_fold.rs
+++ b/clippy_lints/src/methods/unnecessary_fold.rs
@@ -1,6 +1,5 @@
-use crate::utils::{
-    is_trait_method, path_to_local_id, remove_blocks, snippet_with_applicability, span_lint_and_sugg, strip_pat_refs,
-};
+use crate::utils::{is_trait_method, path_to_local_id, remove_blocks, span_lint_and_sugg, strip_pat_refs};
+use clippy_utils::source::snippet_with_applicability;
 use if_chain::if_chain;
 use rustc_ast::ast;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/methods/unnecessary_lazy_eval.rs b/clippy_lints/src/methods/unnecessary_lazy_eval.rs
index d260a771c01..444abde3d0f 100644
--- a/clippy_lints/src/methods/unnecessary_lazy_eval.rs
+++ b/clippy_lints/src/methods/unnecessary_lazy_eval.rs
@@ -1,5 +1,6 @@
+use crate::utils::span_lint_and_sugg;
 use crate::utils::{eager_or_lazy, usage};
-use crate::utils::{snippet, span_lint_and_sugg};
+use clippy_utils::source::snippet;
 use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
diff --git a/clippy_lints/src/methods/useless_asref.rs b/clippy_lints/src/methods/useless_asref.rs
index e6b1789a4a8..c6d84aedc0a 100644
--- a/clippy_lints/src/methods/useless_asref.rs
+++ b/clippy_lints/src/methods/useless_asref.rs
@@ -1,4 +1,5 @@
-use crate::utils::{get_parent_expr, match_trait_method, paths, snippet_with_applicability, span_lint_and_sugg};
+use crate::utils::{get_parent_expr, match_trait_method, paths, span_lint_and_sugg};
+use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::walk_ptrs_ty_depth;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/misc.rs b/clippy_lints/src/misc.rs
index 5c4d4401cd9..f161054cc8c 100644
--- a/clippy_lints/src/misc.rs
+++ b/clippy_lints/src/misc.rs
@@ -1,3 +1,4 @@
+use clippy_utils::source::{snippet, snippet_opt};
 use clippy_utils::ty::implements_trait;
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
@@ -19,8 +20,8 @@ use crate::consts::{constant, Constant};
 use crate::utils::sugg::Sugg;
 use crate::utils::{
     get_item_name, get_parent_expr, higher, in_constant, is_diagnostic_assoc_item, is_integer_const, iter_input_pats,
-    last_path_segment, match_qpath, snippet, snippet_opt, span_lint, span_lint_and_sugg, span_lint_and_then,
-    span_lint_hir_and_then, unsext, SpanlessEq,
+    last_path_segment, match_qpath, span_lint, span_lint_and_sugg, span_lint_and_then, span_lint_hir_and_then, unsext,
+    SpanlessEq,
 };
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/misc_early.rs b/clippy_lints/src/misc_early.rs
index 84a0df92f5b..6ec523498e1 100644
--- a/clippy_lints/src/misc_early.rs
+++ b/clippy_lints/src/misc_early.rs
@@ -1,4 +1,5 @@
-use crate::utils::{snippet_opt, span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then};
+use crate::utils::{span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then};
+use clippy_utils::source::snippet_opt;
 use rustc_ast::ast::{
     BindingMode, Expr, ExprKind, GenericParamKind, Generics, Lit, LitFloatType, LitIntType, LitKind, Mutability,
     NodeId, Pat, PatKind, UnOp,
diff --git a/clippy_lints/src/needless_bool.rs b/clippy_lints/src/needless_bool.rs
index f283ff1715f..22adbdf09a6 100644
--- a/clippy_lints/src/needless_bool.rs
+++ b/clippy_lints/src/needless_bool.rs
@@ -3,7 +3,8 @@
 //! This lint is **warn** by default
 
 use crate::utils::sugg::Sugg;
-use crate::utils::{is_expn_of, parent_node_is_if_expr, snippet_with_applicability, span_lint, span_lint_and_sugg};
+use crate::utils::{is_expn_of, parent_node_is_if_expr, span_lint, span_lint_and_sugg};
+use clippy_utils::source::snippet_with_applicability;
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Block, Expr, ExprKind, StmtKind, UnOp};
diff --git a/clippy_lints/src/needless_borrow.rs b/clippy_lints/src/needless_borrow.rs
index 1aadcfd87b6..d8b574af1fe 100644
--- a/clippy_lints/src/needless_borrow.rs
+++ b/clippy_lints/src/needless_borrow.rs
@@ -2,7 +2,8 @@
 //!
 //! This lint is **warn** by default
 
-use crate::utils::{is_automatically_derived, snippet_opt, span_lint_and_then};
+use crate::utils::{is_automatically_derived, span_lint_and_then};
+use clippy_utils::source::snippet_opt;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{BindingAnnotation, BorrowKind, Expr, ExprKind, Item, Mutability, Pat, PatKind};
diff --git a/clippy_lints/src/needless_borrowed_ref.rs b/clippy_lints/src/needless_borrowed_ref.rs
index f449f397e7d..5ee71f25694 100644
--- a/clippy_lints/src/needless_borrowed_ref.rs
+++ b/clippy_lints/src/needless_borrowed_ref.rs
@@ -1,4 +1,5 @@
-use crate::utils::{snippet_with_applicability, span_lint_and_then};
+use crate::utils::span_lint_and_then;
+use clippy_utils::source::snippet_with_applicability;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{BindingAnnotation, Mutability, Node, Pat, PatKind};
diff --git a/clippy_lints/src/needless_continue.rs b/clippy_lints/src/needless_continue.rs
index 30fe2d6225c..4ff90704207 100644
--- a/clippy_lints/src/needless_continue.rs
+++ b/clippy_lints/src/needless_continue.rs
@@ -33,13 +33,14 @@
 //! ```
 //!
 //! This lint is **warn** by default.
+use clippy_utils::source::{indent_of, snippet, snippet_block};
 use rustc_ast::ast;
 use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::{original_sp, DUMMY_SP};
 use rustc_span::Span;
 
-use crate::utils::{indent_of, snippet, snippet_block, span_lint_and_help};
+use crate::utils::span_lint_and_help;
 
 declare_clippy_lint! {
     /// **What it does:** The lint checks for `if`-statements appearing in loops
diff --git a/clippy_lints/src/needless_pass_by_value.rs b/clippy_lints/src/needless_pass_by_value.rs
index 14989283681..6f7a5d85480 100644
--- a/clippy_lints/src/needless_pass_by_value.rs
+++ b/clippy_lints/src/needless_pass_by_value.rs
@@ -1,5 +1,6 @@
 use crate::utils::ptr::get_spans;
-use crate::utils::{get_trait_def_id, is_self, multispan_sugg, paths, snippet, snippet_opt, span_lint_and_then};
+use crate::utils::{get_trait_def_id, is_self, multispan_sugg, paths, span_lint_and_then};
+use clippy_utils::source::{snippet, snippet_opt};
 use clippy_utils::ty::{implements_trait, is_copy, is_type_diagnostic_item};
 use if_chain::if_chain;
 use rustc_ast::ast::Attribute;
diff --git a/clippy_lints/src/needless_question_mark.rs b/clippy_lints/src/needless_question_mark.rs
index d616290ee9c..bcc39ff855c 100644
--- a/clippy_lints/src/needless_question_mark.rs
+++ b/clippy_lints/src/needless_question_mark.rs
@@ -1,3 +1,4 @@
+use clippy_utils::source::snippet;
 use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_errors::Applicability;
 use rustc_hir::{Body, Expr, ExprKind, LangItem, MatchSource, QPath};
@@ -145,7 +146,7 @@ fn emit_lint(cx: &LateContext<'_>, expr: &SomeOkCall<'_>) {
         entire_expr.span,
         "question mark operator is useless here",
         "try",
-        format!("{}", utils::snippet(cx, inner_expr.span, r#""...""#)),
+        format!("{}", snippet(cx, inner_expr.span, r#""...""#)),
         Applicability::MachineApplicable,
     );
 }
diff --git a/clippy_lints/src/no_effect.rs b/clippy_lints/src/no_effect.rs
index c377d373ad6..7a7bc7a44cd 100644
--- a/clippy_lints/src/no_effect.rs
+++ b/clippy_lints/src/no_effect.rs
@@ -1,4 +1,5 @@
-use crate::utils::{snippet_opt, span_lint, span_lint_and_sugg};
+use crate::utils::{span_lint, span_lint_and_sugg};
+use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::has_drop;
 use rustc_errors::Applicability;
 use rustc_hir::def::{DefKind, Res};
diff --git a/clippy_lints/src/pass_by_ref_or_value.rs b/clippy_lints/src/pass_by_ref_or_value.rs
index c9b59b89306..757ead2c24c 100644
--- a/clippy_lints/src/pass_by_ref_or_value.rs
+++ b/clippy_lints/src/pass_by_ref_or_value.rs
@@ -1,6 +1,7 @@
 use std::cmp;
 
-use crate::utils::{is_self_ty, snippet, span_lint_and_sugg};
+use crate::utils::{is_self_ty, span_lint_and_sugg};
+use clippy_utils::source::snippet;
 use clippy_utils::ty::is_copy;
 use if_chain::if_chain;
 use rustc_ast::attr;
diff --git a/clippy_lints/src/precedence.rs b/clippy_lints/src/precedence.rs
index c9d18c3cb72..fbe54e92ab9 100644
--- a/clippy_lints/src/precedence.rs
+++ b/clippy_lints/src/precedence.rs
@@ -1,4 +1,5 @@
-use crate::utils::{snippet_with_applicability, span_lint_and_sugg};
+use crate::utils::span_lint_and_sugg;
+use clippy_utils::source::snippet_with_applicability;
 use if_chain::if_chain;
 use rustc_ast::ast::{BinOpKind, Expr, ExprKind, LitKind, UnOp};
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs
index c2649a135eb..bfe8bf33f51 100644
--- a/clippy_lints/src/ptr.rs
+++ b/clippy_lints/src/ptr.rs
@@ -1,7 +1,8 @@
 //! Checks for usage of  `&Vec[_]` and `&String`.
 
 use crate::utils::ptr::get_spans;
-use crate::utils::{is_allowed, match_qpath, paths, snippet_opt, span_lint, span_lint_and_sugg, span_lint_and_then};
+use crate::utils::{is_allowed, match_qpath, paths, span_lint, span_lint_and_sugg, span_lint_and_then};
+use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::{is_type_diagnostic_item, match_type, walk_ptrs_hir_ty};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/ptr_eq.rs b/clippy_lints/src/ptr_eq.rs
index 3be792ce5e4..4f83e370c5f 100644
--- a/clippy_lints/src/ptr_eq.rs
+++ b/clippy_lints/src/ptr_eq.rs
@@ -1,4 +1,5 @@
 use crate::utils;
+use clippy_utils::source::snippet_opt;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind};
@@ -54,8 +55,8 @@ impl LateLintPass<'_> for PtrEq {
                 if_chain! {
                     if let Some(left_var) = expr_as_cast_to_raw_pointer(cx, left);
                     if let Some(right_var) = expr_as_cast_to_raw_pointer(cx, right);
-                    if let Some(left_snip) = utils::snippet_opt(cx, left_var.span);
-                    if let Some(right_snip) = utils::snippet_opt(cx, right_var.span);
+                    if let Some(left_snip) = snippet_opt(cx, left_var.span);
+                    if let Some(right_snip) = snippet_opt(cx, right_var.span);
                     then {
                         utils::span_lint_and_sugg(
                             cx,
diff --git a/clippy_lints/src/ptr_offset_with_cast.rs b/clippy_lints/src/ptr_offset_with_cast.rs
index e0996804a59..b801defeb24 100644
--- a/clippy_lints/src/ptr_offset_with_cast.rs
+++ b/clippy_lints/src/ptr_offset_with_cast.rs
@@ -1,4 +1,5 @@
-use crate::utils::{snippet_opt, span_lint, span_lint_and_sugg};
+use crate::utils::{span_lint, span_lint_and_sugg};
+use clippy_utils::source::snippet_opt;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/question_mark.rs b/clippy_lints/src/question_mark.rs
index dc00aaffa58..43431425a43 100644
--- a/clippy_lints/src/question_mark.rs
+++ b/clippy_lints/src/question_mark.rs
@@ -1,3 +1,4 @@
+use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
@@ -8,7 +9,7 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::sym;
 
 use crate::utils::sugg::Sugg;
-use crate::utils::{eq_expr_value, match_def_path, match_qpath, paths, snippet_with_applicability, span_lint_and_sugg};
+use crate::utils::{eq_expr_value, match_def_path, match_qpath, paths, span_lint_and_sugg};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for expressions that could be replaced by the question mark operator.
diff --git a/clippy_lints/src/ranges.rs b/clippy_lints/src/ranges.rs
index 59503817c0f..3ce8949bf8b 100644
--- a/clippy_lints/src/ranges.rs
+++ b/clippy_lints/src/ranges.rs
@@ -1,4 +1,5 @@
 use crate::consts::{constant, Constant};
+use clippy_utils::source::{snippet, snippet_opt, snippet_with_applicability};
 use if_chain::if_chain;
 use rustc_ast::ast::RangeLimits;
 use rustc_errors::Applicability;
@@ -14,8 +15,8 @@ use std::cmp::Ordering;
 
 use crate::utils::sugg::Sugg;
 use crate::utils::{
-    get_parent_expr, in_constant, is_integer_const, meets_msrv, single_segment_path, snippet, snippet_opt,
-    snippet_with_applicability, span_lint, span_lint_and_sugg, span_lint_and_then,
+    get_parent_expr, in_constant, is_integer_const, meets_msrv, single_segment_path, span_lint, span_lint_and_sugg,
+    span_lint_and_then,
 };
 use crate::utils::{higher, SpanlessEq};
 
diff --git a/clippy_lints/src/redundant_clone.rs b/clippy_lints/src/redundant_clone.rs
index d2e5a5db372..84723acd034 100644
--- a/clippy_lints/src/redundant_clone.rs
+++ b/clippy_lints/src/redundant_clone.rs
@@ -1,6 +1,5 @@
-use crate::utils::{
-    fn_has_unsatisfiable_preds, match_def_path, paths, snippet_opt, span_lint_hir, span_lint_hir_and_then,
-};
+use crate::utils::{fn_has_unsatisfiable_preds, match_def_path, paths, span_lint_hir, span_lint_hir_and_then};
+use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::{has_drop, is_copy, is_type_diagnostic_item, walk_ptrs_ty_depth};
 use if_chain::if_chain;
 use rustc_data_structures::{fx::FxHashMap, transitive_relation::TransitiveRelation};
diff --git a/clippy_lints/src/redundant_closure_call.rs b/clippy_lints/src/redundant_closure_call.rs
index f398b3fff25..283e25553cf 100644
--- a/clippy_lints/src/redundant_closure_call.rs
+++ b/clippy_lints/src/redundant_closure_call.rs
@@ -1,4 +1,5 @@
-use crate::utils::{snippet_with_applicability, span_lint, span_lint_and_then};
+use crate::utils::{span_lint, span_lint_and_then};
+use clippy_utils::source::snippet_with_applicability;
 use if_chain::if_chain;
 use rustc_ast::ast;
 use rustc_ast::visit as ast_visit;
diff --git a/clippy_lints/src/redundant_slicing.rs b/clippy_lints/src/redundant_slicing.rs
index 992d1901584..85ea91a387b 100644
--- a/clippy_lints/src/redundant_slicing.rs
+++ b/clippy_lints/src/redundant_slicing.rs
@@ -1,3 +1,4 @@
+use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::is_type_lang_item;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
@@ -6,7 +7,7 @@ use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::{lint::in_external_macro, ty::TyS};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
-use crate::utils::{snippet_with_applicability, span_lint_and_sugg};
+use crate::utils::span_lint_and_sugg;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for redundant slicing expressions which use the full range, and
diff --git a/clippy_lints/src/redundant_static_lifetimes.rs b/clippy_lints/src/redundant_static_lifetimes.rs
index fcfa3c12755..1352a651723 100644
--- a/clippy_lints/src/redundant_static_lifetimes.rs
+++ b/clippy_lints/src/redundant_static_lifetimes.rs
@@ -1,4 +1,5 @@
-use crate::utils::{meets_msrv, snippet, span_lint_and_then};
+use crate::utils::{meets_msrv, span_lint_and_then};
+use clippy_utils::source::snippet;
 use rustc_ast::ast::{Item, ItemKind, Ty, TyKind};
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass};
diff --git a/clippy_lints/src/ref_option_ref.rs b/clippy_lints/src/ref_option_ref.rs
index 8cd6692ce03..cec6b06262b 100644
--- a/clippy_lints/src/ref_option_ref.rs
+++ b/clippy_lints/src/ref_option_ref.rs
@@ -1,12 +1,12 @@
-use crate::utils::{last_path_segment, snippet, span_lint_and_sugg};
+use crate::utils::{last_path_segment, span_lint_and_sugg};
+use clippy_utils::source::snippet;
+use if_chain::if_chain;
+use rustc_errors::Applicability;
 use rustc_hir::{GenericArg, Mutability, Ty, TyKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::symbol::sym;
 
-use if_chain::if_chain;
-use rustc_errors::Applicability;
-
 declare_clippy_lint! {
     /// **What it does:** Checks for usage of `&Option<&T>`.
     ///
diff --git a/clippy_lints/src/reference.rs b/clippy_lints/src/reference.rs
index e1450466a7c..31e834ac174 100644
--- a/clippy_lints/src/reference.rs
+++ b/clippy_lints/src/reference.rs
@@ -1,5 +1,6 @@
 use crate::utils::sugg::Sugg;
-use crate::utils::{in_macro, snippet_opt, snippet_with_applicability, span_lint_and_sugg};
+use crate::utils::{in_macro, span_lint_and_sugg};
+use clippy_utils::source::{snippet_opt, snippet_with_applicability};
 use if_chain::if_chain;
 use rustc_ast::ast::{Expr, ExprKind, Mutability, UnOp};
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/repeat_once.rs b/clippy_lints/src/repeat_once.rs
index 7d668739c5a..a88078c12a3 100644
--- a/clippy_lints/src/repeat_once.rs
+++ b/clippy_lints/src/repeat_once.rs
@@ -1,5 +1,6 @@
 use crate::consts::{constant_context, Constant};
-use crate::utils::{in_macro, snippet, span_lint_and_sugg};
+use crate::utils::{in_macro, span_lint_and_sugg};
+use clippy_utils::source::snippet;
 use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
index 40c0f1f4589..eb7fe403fd7 100644
--- a/clippy_lints/src/returns.rs
+++ b/clippy_lints/src/returns.rs
@@ -1,3 +1,4 @@
+use clippy_utils::source::snippet_opt;
 use if_chain::if_chain;
 use rustc_ast::ast::Attribute;
 use rustc_errors::Applicability;
@@ -11,7 +12,7 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
 use rustc_span::sym;
 
-use crate::utils::{fn_def_id, in_macro, match_qpath, snippet_opt, span_lint_and_sugg, span_lint_and_then};
+use crate::utils::{fn_def_id, in_macro, match_qpath, span_lint_and_sugg, span_lint_and_then};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for `let`-bindings, which are subsequently
diff --git a/clippy_lints/src/self_assignment.rs b/clippy_lints/src/self_assignment.rs
index e096c9aebc1..e62b75de4ca 100644
--- a/clippy_lints/src/self_assignment.rs
+++ b/clippy_lints/src/self_assignment.rs
@@ -1,4 +1,5 @@
-use crate::utils::{eq_expr_value, snippet, span_lint};
+use crate::utils::{eq_expr_value, span_lint};
+use clippy_utils::source::snippet;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
diff --git a/clippy_lints/src/semicolon_if_nothing_returned.rs b/clippy_lints/src/semicolon_if_nothing_returned.rs
index 839c995e525..695d7233af2 100644
--- a/clippy_lints/src/semicolon_if_nothing_returned.rs
+++ b/clippy_lints/src/semicolon_if_nothing_returned.rs
@@ -1,4 +1,5 @@
-use crate::utils::{in_macro, snippet_with_macro_callsite, span_lint_and_sugg, sugg};
+use crate::utils::{in_macro, span_lint_and_sugg, sugg};
+use clippy_utils::source::snippet_with_macro_callsite;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Block, ExprKind};
diff --git a/clippy_lints/src/shadow.rs b/clippy_lints/src/shadow.rs
index 32f6bc74642..4a8cacb31fd 100644
--- a/clippy_lints/src/shadow.rs
+++ b/clippy_lints/src/shadow.rs
@@ -1,4 +1,5 @@
-use crate::utils::{contains_name, higher, iter_input_pats, snippet, span_lint_and_then};
+use crate::utils::{contains_name, higher, iter_input_pats, span_lint_and_then};
+use clippy_utils::source::snippet;
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::{
     Block, Body, Expr, ExprKind, FnDecl, Guard, HirId, Local, MutTy, Pat, PatKind, Path, QPath, StmtKind, Ty, TyKind,
diff --git a/clippy_lints/src/strings.rs b/clippy_lints/src/strings.rs
index 62b4b40df45..ce93ab23b2f 100644
--- a/clippy_lints/src/strings.rs
+++ b/clippy_lints/src/strings.rs
@@ -3,6 +3,7 @@ use crate::utils::{
     get_parent_expr, is_allowed, match_function_call, method_calls, paths, span_lint, span_lint_and_help,
     span_lint_and_sugg,
 };
+use clippy_utils::source::{snippet, snippet_with_applicability};
 use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
@@ -204,7 +205,6 @@ declare_lint_pass!(StringLitAsBytes => [STRING_LIT_AS_BYTES, STRING_FROM_UTF8_AS
 
 impl<'tcx> LateLintPass<'tcx> for StringLitAsBytes {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
-        use crate::utils::{snippet, snippet_with_applicability};
         use rustc_ast::LitKind;
 
         if_chain! {
diff --git a/clippy_lints/src/suspicious_operation_groupings.rs b/clippy_lints/src/suspicious_operation_groupings.rs
index 44521885d20..3bdd9b7e4cb 100644
--- a/clippy_lints/src/suspicious_operation_groupings.rs
+++ b/clippy_lints/src/suspicious_operation_groupings.rs
@@ -1,5 +1,6 @@
 use crate::utils::ast_utils::{eq_id, is_useless_with_eq_exprs, IdentIter};
-use crate::utils::{snippet_with_applicability, span_lint_and_sugg};
+use crate::utils::span_lint_and_sugg;
+use clippy_utils::source::snippet_with_applicability;
 use core::ops::{Add, AddAssign};
 use if_chain::if_chain;
 use rustc_ast::ast::{BinOpKind, Expr, ExprKind, StmtKind};
diff --git a/clippy_lints/src/swap.rs b/clippy_lints/src/swap.rs
index ba2d73a8228..d4a495f3ea9 100644
--- a/clippy_lints/src/swap.rs
+++ b/clippy_lints/src/swap.rs
@@ -1,5 +1,6 @@
 use crate::utils::sugg::Sugg;
-use crate::utils::{differing_macro_contexts, eq_expr_value, snippet_with_applicability, span_lint_and_then};
+use crate::utils::{differing_macro_contexts, eq_expr_value, span_lint_and_then};
+use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/to_digit_is_some.rs b/clippy_lints/src/to_digit_is_some.rs
index eeda39bfa20..940273afc57 100644
--- a/clippy_lints/src/to_digit_is_some.rs
+++ b/clippy_lints/src/to_digit_is_some.rs
@@ -1,4 +1,5 @@
-use crate::utils::{match_def_path, snippet_with_applicability, span_lint_and_sugg};
+use crate::utils::{match_def_path, span_lint_and_sugg};
+use clippy_utils::source::snippet_with_applicability;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
diff --git a/clippy_lints/src/trait_bounds.rs b/clippy_lints/src/trait_bounds.rs
index daff5f81e8c..d3314271c21 100644
--- a/clippy_lints/src/trait_bounds.rs
+++ b/clippy_lints/src/trait_bounds.rs
@@ -1,4 +1,5 @@
-use crate::utils::{in_macro, snippet, snippet_with_applicability, span_lint_and_help, SpanlessHash};
+use crate::utils::{in_macro, span_lint_and_help, SpanlessHash};
+use clippy_utils::source::{snippet, snippet_with_applicability};
 use if_chain::if_chain;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/transmute/transmute_ref_to_ref.rs b/clippy_lints/src/transmute/transmute_ref_to_ref.rs
index 01b00bb0a22..4780eb9b14e 100644
--- a/clippy_lints/src/transmute/transmute_ref_to_ref.rs
+++ b/clippy_lints/src/transmute/transmute_ref_to_ref.rs
@@ -1,5 +1,6 @@
 use super::{TRANSMUTE_BYTES_TO_STR, TRANSMUTE_PTR_TO_PTR};
-use crate::utils::{snippet, span_lint_and_sugg, span_lint_and_then, sugg};
+use crate::utils::{span_lint_and_sugg, span_lint_and_then, sugg};
+use clippy_utils::source::snippet;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, Mutability};
diff --git a/clippy_lints/src/transmute/utils.rs b/clippy_lints/src/transmute/utils.rs
index f4b0f205993..0633697687a 100644
--- a/clippy_lints/src/transmute/utils.rs
+++ b/clippy_lints/src/transmute/utils.rs
@@ -1,4 +1,5 @@
-use crate::utils::{last_path_segment, snippet};
+use crate::utils::last_path_segment;
+use clippy_utils::source::snippet;
 use clippy_utils::ty::is_normalizable;
 use if_chain::if_chain;
 use rustc_hir::{Expr, GenericArg, QPath, TyKind};
diff --git a/clippy_lints/src/try_err.rs b/clippy_lints/src/try_err.rs
index bdb81ea32d7..e356add8e9d 100644
--- a/clippy_lints/src/try_err.rs
+++ b/clippy_lints/src/try_err.rs
@@ -1,7 +1,5 @@
-use crate::utils::{
-    differing_macro_contexts, in_macro, match_def_path, match_qpath, paths, snippet, snippet_with_macro_callsite,
-    span_lint_and_sugg,
-};
+use crate::utils::{differing_macro_contexts, in_macro, match_def_path, match_qpath, paths, span_lint_and_sugg};
+use clippy_utils::source::{snippet, snippet_with_macro_callsite};
 use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/types/borrowed_box.rs b/clippy_lints/src/types/borrowed_box.rs
index a7a511b21cf..01aeea7a67f 100644
--- a/clippy_lints/src/types/borrowed_box.rs
+++ b/clippy_lints/src/types/borrowed_box.rs
@@ -1,3 +1,6 @@
+use crate::utils::{match_path, paths, span_lint_and_sugg};
+use clippy_utils::source::snippet;
+use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{
     self as hir, GenericArg, GenericBounds, GenericParamKind, HirId, Lifetime, MutTy, Mutability, Node, QPath,
@@ -5,10 +8,6 @@ use rustc_hir::{
 };
 use rustc_lint::LateContext;
 
-use if_chain::if_chain;
-
-use crate::utils::{match_path, paths, snippet, span_lint_and_sugg};
-
 use super::BORROWED_BOX;
 
 pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, lt: &Lifetime, mut_ty: &MutTy<'_>) -> bool {
diff --git a/clippy_lints/src/types/mod.rs b/clippy_lints/src/types/mod.rs
index fcd38718b9b..279a971318c 100644
--- a/clippy_lints/src/types/mod.rs
+++ b/clippy_lints/src/types/mod.rs
@@ -13,6 +13,7 @@ use std::borrow::Cow;
 use std::cmp::Ordering;
 use std::collections::BTreeMap;
 
+use clippy_utils::source::{indent_of, reindent_multiline, snippet, snippet_opt, snippet_with_macro_callsite};
 use clippy_utils::ty::{is_isize_or_usize, is_type_diagnostic_item};
 use if_chain::if_chain;
 use rustc_errors::{Applicability, DiagnosticBuilder};
@@ -38,9 +39,8 @@ use rustc_typeck::hir_ty_to_ty;
 use crate::consts::{constant, Constant};
 use crate::utils::paths;
 use crate::utils::{
-    clip, comparisons, differing_macro_contexts, higher, indent_of, int_bits, match_path, multispan_sugg,
-    reindent_multiline, sext, snippet, snippet_opt, snippet_with_macro_callsite, span_lint, span_lint_and_help,
-    span_lint_and_then, unsext,
+    clip, comparisons, differing_macro_contexts, higher, int_bits, match_path, multispan_sugg, sext, span_lint,
+    span_lint_and_help, span_lint_and_then, unsext,
 };
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/types/rc_buffer.rs b/clippy_lints/src/types/rc_buffer.rs
index e34b95147e1..0ace1807535 100644
--- a/clippy_lints/src/types/rc_buffer.rs
+++ b/clippy_lints/src/types/rc_buffer.rs
@@ -1,11 +1,10 @@
+use clippy_utils::source::snippet_with_applicability;
 use rustc_errors::Applicability;
 use rustc_hir::{self as hir, def_id::DefId, QPath, TyKind};
 use rustc_lint::LateContext;
 use rustc_span::symbol::sym;
 
-use crate::utils::{
-    get_qpath_generic_tys, is_ty_param_diagnostic_item, snippet_with_applicability, span_lint_and_sugg,
-};
+use crate::utils::{get_qpath_generic_tys, is_ty_param_diagnostic_item, span_lint_and_sugg};
 
 use super::RC_BUFFER;
 
diff --git a/clippy_lints/src/types/redundant_allocation.rs b/clippy_lints/src/types/redundant_allocation.rs
index 5da6db179c4..c6f6a2f6564 100644
--- a/clippy_lints/src/types/redundant_allocation.rs
+++ b/clippy_lints/src/types/redundant_allocation.rs
@@ -1,12 +1,10 @@
+use clippy_utils::source::snippet_with_applicability;
 use rustc_errors::Applicability;
 use rustc_hir::{self as hir, def_id::DefId, LangItem, QPath, TyKind};
 use rustc_lint::LateContext;
 use rustc_span::symbol::sym;
 
-use crate::utils::{
-    get_qpath_generic_tys, is_ty_param_diagnostic_item, is_ty_param_lang_item, snippet_with_applicability,
-    span_lint_and_sugg,
-};
+use crate::utils::{get_qpath_generic_tys, is_ty_param_diagnostic_item, is_ty_param_lang_item, span_lint_and_sugg};
 
 use super::{utils, REDUNDANT_ALLOCATION};
 
diff --git a/clippy_lints/src/types/vec_box.rs b/clippy_lints/src/types/vec_box.rs
index 2530cc133c6..6f45442b9ba 100644
--- a/clippy_lints/src/types/vec_box.rs
+++ b/clippy_lints/src/types/vec_box.rs
@@ -1,3 +1,5 @@
+use clippy_utils::source::snippet;
+use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{self as hir, def_id::DefId, GenericArg, QPath, TyKind};
 use rustc_lint::LateContext;
@@ -6,9 +8,7 @@ use rustc_span::symbol::sym;
 use rustc_target::abi::LayoutOf;
 use rustc_typeck::hir_ty_to_ty;
 
-use if_chain::if_chain;
-
-use crate::utils::{last_path_segment, snippet, span_lint_and_sugg};
+use crate::utils::{last_path_segment, span_lint_and_sugg};
 
 use super::VEC_BOX;
 
diff --git a/clippy_lints/src/unicode.rs b/clippy_lints/src/unicode.rs
index 93d59cc7fcd..e44fec7ad8e 100644
--- a/clippy_lints/src/unicode.rs
+++ b/clippy_lints/src/unicode.rs
@@ -1,4 +1,5 @@
-use crate::utils::{is_allowed, snippet, span_lint_and_sugg};
+use crate::utils::{is_allowed, span_lint_and_sugg};
+use clippy_utils::source::snippet;
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, HirId};
diff --git a/clippy_lints/src/unnecessary_wraps.rs b/clippy_lints/src/unnecessary_wraps.rs
index 8e076397c11..01497de3211 100644
--- a/clippy_lints/src/unnecessary_wraps.rs
+++ b/clippy_lints/src/unnecessary_wraps.rs
@@ -1,7 +1,7 @@
 use crate::utils::{
-    contains_return, in_macro, match_qpath, paths, return_ty, snippet, span_lint_and_then,
-    visitors::find_all_ret_expressions,
+    contains_return, in_macro, match_qpath, paths, return_ty, span_lint_and_then, visitors::find_all_ret_expressions,
 };
+use clippy_utils::source::snippet;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::FnKind;
diff --git a/clippy_lints/src/unused_unit.rs b/clippy_lints/src/unused_unit.rs
index a31cd5fda84..a90d26fc95c 100644
--- a/clippy_lints/src/unused_unit.rs
+++ b/clippy_lints/src/unused_unit.rs
@@ -1,3 +1,4 @@
+use clippy_utils::source::position_before_rarrow;
 use if_chain::if_chain;
 use rustc_ast::ast;
 use rustc_ast::visit::FnKind;
@@ -7,7 +8,7 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
 use rustc_span::BytePos;
 
-use crate::utils::{position_before_rarrow, span_lint_and_sugg};
+use crate::utils::span_lint_and_sugg;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for unit (`()`) expressions that can be removed.
diff --git a/clippy_lints/src/use_self.rs b/clippy_lints/src/use_self.rs
index f0523cec621..de7eb42d56d 100644
--- a/clippy_lints/src/use_self.rs
+++ b/clippy_lints/src/use_self.rs
@@ -1,6 +1,7 @@
-use crate::utils::{in_macro, meets_msrv, snippet_opt, span_lint_and_sugg};
+use clippy_utils::source::snippet_opt;
 use if_chain::if_chain;
 
+use crate::utils::{in_macro, meets_msrv, span_lint_and_sugg};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_hir::def::DefKind;
diff --git a/clippy_lints/src/useless_conversion.rs b/clippy_lints/src/useless_conversion.rs
index 23032c74f9a..e6b4fde560f 100644
--- a/clippy_lints/src/useless_conversion.rs
+++ b/clippy_lints/src/useless_conversion.rs
@@ -1,8 +1,8 @@
 use crate::utils::sugg::Sugg;
 use crate::utils::{
-    get_parent_expr, match_def_path, match_trait_method, paths, snippet, snippet_with_macro_callsite,
-    span_lint_and_help, span_lint_and_sugg,
+    get_parent_expr, match_def_path, match_trait_method, paths, span_lint_and_help, span_lint_and_sugg,
 };
+use clippy_utils::source::{snippet, snippet_with_macro_callsite};
 use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs
index 2f4bc74ef64..04b8d9ee2c7 100644
--- a/clippy_lints/src/utils/internal_lints.rs
+++ b/clippy_lints/src/utils/internal_lints.rs
@@ -1,8 +1,9 @@
 use crate::consts::{constant_simple, Constant};
 use crate::utils::{
-    is_expn_of, match_def_path, match_qpath, method_calls, path_to_res, paths, run_lints, snippet, span_lint,
+    is_expn_of, match_def_path, match_qpath, method_calls, path_to_res, paths, run_lints, span_lint,
     span_lint_and_help, span_lint_and_sugg, SpanlessEq,
 };
+use clippy_utils::source::snippet;
 use clippy_utils::ty::match_type;
 use if_chain::if_chain;
 use rustc_ast::ast::{Crate as AstCrate, ItemKind, LitKind, ModKind, NodeId};
diff --git a/clippy_lints/src/vec.rs b/clippy_lints/src/vec.rs
index 682cc35a7d7..cd09a5b53e0 100644
--- a/clippy_lints/src/vec.rs
+++ b/clippy_lints/src/vec.rs
@@ -1,6 +1,7 @@
 use crate::consts::{constant, Constant};
 use crate::rustc_target::abi::LayoutOf;
-use crate::utils::{higher, snippet_with_applicability, span_lint_and_sugg};
+use crate::utils::{higher, span_lint_and_sugg};
+use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::is_copy;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/vec_init_then_push.rs b/clippy_lints/src/vec_init_then_push.rs
index b3262a253e7..4ad787ecf66 100644
--- a/clippy_lints/src/vec_init_then_push.rs
+++ b/clippy_lints/src/vec_init_then_push.rs
@@ -1,4 +1,5 @@
-use crate::utils::{match_def_path, path_to_local, path_to_local_id, paths, snippet, span_lint_and_sugg};
+use crate::utils::{match_def_path, path_to_local, path_to_local_id, paths, span_lint_and_sugg};
+use clippy_utils::source::snippet;
 use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
diff --git a/clippy_lints/src/wildcard_imports.rs b/clippy_lints/src/wildcard_imports.rs
index 094b1a42346..e12ca49fd4c 100644
--- a/clippy_lints/src/wildcard_imports.rs
+++ b/clippy_lints/src/wildcard_imports.rs
@@ -1,4 +1,5 @@
-use crate::utils::{in_macro, snippet, snippet_with_applicability, span_lint_and_sugg};
+use crate::utils::{in_macro, span_lint_and_sugg};
+use clippy_utils::source::{snippet, snippet_with_applicability};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{
diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs
index f21f5180554..f2fef73a641 100644
--- a/clippy_lints/src/write.rs
+++ b/clippy_lints/src/write.rs
@@ -1,7 +1,8 @@
 use std::borrow::Cow;
 use std::ops::Range;
 
-use crate::utils::{snippet_with_applicability, span_lint, span_lint_and_sugg, span_lint_and_then};
+use crate::utils::{span_lint, span_lint_and_sugg, span_lint_and_then};
+use clippy_utils::source::snippet_with_applicability;
 use if_chain::if_chain;
 use rustc_ast::ast::{Expr, ExprKind, ImplKind, Item, ItemKind, LitKind, MacCall, StrLit, StrStyle};
 use rustc_ast::token;
diff --git a/clippy_utils/src/hir_utils.rs b/clippy_utils/src/hir_utils.rs
index e28ad27d9a6..4c13a185d5d 100644
--- a/clippy_utils/src/hir_utils.rs
+++ b/clippy_utils/src/hir_utils.rs
@@ -1,5 +1,6 @@
 use crate::consts::{constant_context, constant_simple};
-use crate::{differing_macro_contexts, snippet_opt};
+use crate::differing_macro_contexts;
+use crate::source::snippet_opt;
 use rustc_ast::ast::InlineAsmTemplatePiece;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 366962d8b77..d895d798b5e 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -41,6 +41,7 @@ pub mod numeric_literal;
 pub mod paths;
 pub mod ptr;
 pub mod qualify_min_const_fn;
+pub mod source;
 pub mod sugg;
 pub mod ty;
 pub mod usage;
@@ -50,14 +51,12 @@ pub use self::attrs::*;
 pub use self::diagnostics::*;
 pub use self::hir_utils::{both, eq_expr_value, over, SpanlessEq, SpanlessHash};
 
-use std::borrow::Cow;
 use std::collections::hash_map::Entry;
 use std::hash::BuildHasherDefault;
 
 use if_chain::if_chain;
 use rustc_ast::ast::{self, Attribute, BorrowKind, LitKind};
 use rustc_data_structures::fx::FxHashMap;
-use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_hir::def::{CtorKind, CtorOf, DefKind, Res};
 use rustc_hir::def_id::{DefId, LOCAL_CRATE};
@@ -75,11 +74,11 @@ use rustc_middle::ty as rustc_ty;
 use rustc_middle::ty::{layout::IntegerExt, DefIdTree, Ty, TyCtxt, TypeFoldable};
 use rustc_semver::RustcVersion;
 use rustc_session::Session;
-use rustc_span::hygiene::{self, ExpnKind, MacroKind};
+use rustc_span::hygiene::{ExpnKind, MacroKind};
 use rustc_span::source_map::original_sp;
 use rustc_span::sym;
 use rustc_span::symbol::{kw, Ident, Symbol};
-use rustc_span::{BytePos, Pos, Span, SyntaxContext, DUMMY_SP};
+use rustc_span::{Span, DUMMY_SP};
 use rustc_target::abi::Integer;
 use smallvec::SmallVec;
 
@@ -236,20 +235,6 @@ pub fn in_macro(span: Span) -> bool {
     }
 }
 
-// If the snippet is empty, it's an attribute that was inserted during macro
-// expansion and we want to ignore those, because they could come from external
-// sources that the user has no control over.
-// For some reason these attributes don't have any expansion info on them, so
-// we have to check it this way until there is a better way.
-pub fn is_present_in_source<T: LintContext>(cx: &T, span: Span) -> bool {
-    if let Some(snippet) = snippet_opt(cx, span) {
-        if snippet.is_empty() {
-            return false;
-        }
-    }
-    true
-}
-
 /// Checks if given pattern is a wildcard (`_`)
 pub fn is_wild<'tcx>(pat: &impl std::ops::Deref<Target = Pat<'tcx>>) -> bool {
     matches!(pat.kind, PatKind::Wild)
@@ -713,211 +698,6 @@ pub fn find_macro_calls(names: &[&str], body: &Body<'_>) -> Vec<Span> {
     fmc.result
 }
 
-/// Converts a span to a code snippet if available, otherwise use default.
-///
-/// This is useful if you want to provide suggestions for your lint or more generally, if you want
-/// to convert a given `Span` to a `str`.
-///
-/// # Example
-/// ```rust,ignore
-/// snippet(cx, expr.span, "..")
-/// ```
-pub fn snippet<'a, T: LintContext>(cx: &T, span: Span, default: &'a str) -> Cow<'a, str> {
-    snippet_opt(cx, span).map_or_else(|| Cow::Borrowed(default), From::from)
-}
-
-/// Same as `snippet`, but it adapts the applicability level by following rules:
-///
-/// - Applicability level `Unspecified` will never be changed.
-/// - If the span is inside a macro, change the applicability level to `MaybeIncorrect`.
-/// - If the default value is used and the applicability level is `MachineApplicable`, change it to
-/// `HasPlaceholders`
-pub fn snippet_with_applicability<'a, T: LintContext>(
-    cx: &T,
-    span: Span,
-    default: &'a str,
-    applicability: &mut Applicability,
-) -> Cow<'a, str> {
-    if *applicability != Applicability::Unspecified && span.from_expansion() {
-        *applicability = Applicability::MaybeIncorrect;
-    }
-    snippet_opt(cx, span).map_or_else(
-        || {
-            if *applicability == Applicability::MachineApplicable {
-                *applicability = Applicability::HasPlaceholders;
-            }
-            Cow::Borrowed(default)
-        },
-        From::from,
-    )
-}
-
-/// Same as `snippet`, but should only be used when it's clear that the input span is
-/// not a macro argument.
-pub fn snippet_with_macro_callsite<'a, T: LintContext>(cx: &T, span: Span, default: &'a str) -> Cow<'a, str> {
-    snippet(cx, span.source_callsite(), default)
-}
-
-/// Converts a span to a code snippet. Returns `None` if not available.
-pub fn snippet_opt<T: LintContext>(cx: &T, span: Span) -> Option<String> {
-    cx.sess().source_map().span_to_snippet(span).ok()
-}
-
-/// Converts a span (from a block) to a code snippet if available, otherwise use default.
-///
-/// This trims the code of indentation, except for the first line. Use it for blocks or block-like
-/// things which need to be printed as such.
-///
-/// The `indent_relative_to` arg can be used, to provide a span, where the indentation of the
-/// resulting snippet of the given span.
-///
-/// # Example
-///
-/// ```rust,ignore
-/// snippet_block(cx, block.span, "..", None)
-/// // where, `block` is the block of the if expr
-///     if x {
-///         y;
-///     }
-/// // will return the snippet
-/// {
-///     y;
-/// }
-/// ```
-///
-/// ```rust,ignore
-/// snippet_block(cx, block.span, "..", Some(if_expr.span))
-/// // where, `block` is the block of the if expr
-///     if x {
-///         y;
-///     }
-/// // will return the snippet
-/// {
-///         y;
-///     } // aligned with `if`
-/// ```
-/// Note that the first line of the snippet always has 0 indentation.
-pub fn snippet_block<'a, T: LintContext>(
-    cx: &T,
-    span: Span,
-    default: &'a str,
-    indent_relative_to: Option<Span>,
-) -> Cow<'a, str> {
-    let snip = snippet(cx, span, default);
-    let indent = indent_relative_to.and_then(|s| indent_of(cx, s));
-    reindent_multiline(snip, true, indent)
-}
-
-/// Same as `snippet_block`, but adapts the applicability level by the rules of
-/// `snippet_with_applicability`.
-pub fn snippet_block_with_applicability<'a, T: LintContext>(
-    cx: &T,
-    span: Span,
-    default: &'a str,
-    indent_relative_to: Option<Span>,
-    applicability: &mut Applicability,
-) -> Cow<'a, str> {
-    let snip = snippet_with_applicability(cx, span, default, applicability);
-    let indent = indent_relative_to.and_then(|s| indent_of(cx, s));
-    reindent_multiline(snip, true, indent)
-}
-
-/// Same as `snippet_with_applicability`, but first walks the span up to the given context. This
-/// will result in the macro call, rather then the expansion, if the span is from a child context.
-/// If the span is not from a child context, it will be used directly instead.
-///
-/// e.g. Given the expression `&vec![]`, getting a snippet from the span for `vec![]` as a HIR node
-/// would result in `box []`. If given the context of the address of expression, this function will
-/// correctly get a snippet of `vec![]`.
-///
-/// This will also return whether or not the snippet is a macro call.
-pub fn snippet_with_context(
-    cx: &LateContext<'_>,
-    span: Span,
-    outer: SyntaxContext,
-    default: &'a str,
-    applicability: &mut Applicability,
-) -> (Cow<'a, str>, bool) {
-    let outer_span = hygiene::walk_chain(span, outer);
-    let (span, is_macro_call) = if outer_span.ctxt() == outer {
-        (outer_span, span.ctxt() != outer)
-    } else {
-        // The span is from a macro argument, and the outer context is the macro using the argument
-        if *applicability != Applicability::Unspecified {
-            *applicability = Applicability::MaybeIncorrect;
-        }
-        // TODO: get the argument span.
-        (span, false)
-    };
-
-    (
-        snippet_with_applicability(cx, span, default, applicability),
-        is_macro_call,
-    )
-}
-
-/// Returns a new Span that extends the original Span to the first non-whitespace char of the first
-/// line.
-///
-/// ```rust,ignore
-///     let x = ();
-/// //          ^^
-/// // will be converted to
-///     let x = ();
-/// //  ^^^^^^^^^^
-/// ```
-pub fn first_line_of_span<T: LintContext>(cx: &T, span: Span) -> Span {
-    first_char_in_first_line(cx, span).map_or(span, |first_char_pos| span.with_lo(first_char_pos))
-}
-
-fn first_char_in_first_line<T: LintContext>(cx: &T, span: Span) -> Option<BytePos> {
-    let line_span = line_span(cx, span);
-    snippet_opt(cx, line_span).and_then(|snip| {
-        snip.find(|c: char| !c.is_whitespace())
-            .map(|pos| line_span.lo() + BytePos::from_usize(pos))
-    })
-}
-
-/// Returns the indentation of the line of a span
-///
-/// ```rust,ignore
-/// let x = ();
-/// //      ^^ -- will return 0
-///     let x = ();
-/// //          ^^ -- will return 4
-/// ```
-pub fn indent_of<T: LintContext>(cx: &T, span: Span) -> Option<usize> {
-    snippet_opt(cx, line_span(cx, span)).and_then(|snip| snip.find(|c: char| !c.is_whitespace()))
-}
-
-/// Returns the positon just before rarrow
-///
-/// ```rust,ignore
-/// fn into(self) -> () {}
-///              ^
-/// // in case of unformatted code
-/// fn into2(self)-> () {}
-///               ^
-/// fn into3(self)   -> () {}
-///               ^
-/// ```
-pub fn position_before_rarrow(s: &str) -> Option<usize> {
-    s.rfind("->").map(|rpos| {
-        let mut rpos = rpos;
-        let chars: Vec<char> = s.chars().collect();
-        while rpos > 1 {
-            if let Some(c) = chars.get(rpos - 1) {
-                if c.is_whitespace() {
-                    rpos -= 1;
-                    continue;
-                }
-            }
-            break;
-        }
-        rpos
-    })
-}
-
 /// Extends the span to the beginning of the spans line, incl. whitespaces.
 ///
 /// ```rust,ignore
@@ -935,66 +715,6 @@ fn line_span<T: LintContext>(cx: &T, span: Span) -> Span {
     Span::new(line_start, span.hi(), span.ctxt())
 }
 
-/// Like `snippet_block`, but add braces if the expr is not an `ExprKind::Block`.
-/// Also takes an `Option<String>` which can be put inside the braces.
-pub fn expr_block<'a, T: LintContext>(
-    cx: &T,
-    expr: &Expr<'_>,
-    option: Option<String>,
-    default: &'a str,
-    indent_relative_to: Option<Span>,
-) -> Cow<'a, str> {
-    let code = snippet_block(cx, expr.span, default, indent_relative_to);
-    let string = option.unwrap_or_default();
-    if expr.span.from_expansion() {
-        Cow::Owned(format!("{{ {} }}", snippet_with_macro_callsite(cx, expr.span, default)))
-    } else if let ExprKind::Block(_, _) = expr.kind {
-        Cow::Owned(format!("{}{}", code, string))
-    } else if string.is_empty() {
-        Cow::Owned(format!("{{ {} }}", code))
-    } else {
-        Cow::Owned(format!("{{\n{};\n{}\n}}", code, string))
-    }
-}
-
-/// Reindent a multiline string with possibility of ignoring the first line.
-#[allow(clippy::needless_pass_by_value)]
-pub fn reindent_multiline(s: Cow<'_, str>, ignore_first: bool, indent: Option<usize>) -> Cow<'_, str> {
-    let s_space = reindent_multiline_inner(&s, ignore_first, indent, ' ');
-    let s_tab = reindent_multiline_inner(&s_space, ignore_first, indent, '\t');
-    reindent_multiline_inner(&s_tab, ignore_first, indent, ' ').into()
-}
-
-fn reindent_multiline_inner(s: &str, ignore_first: bool, indent: Option<usize>, ch: char) -> String {
-    let x = s
-        .lines()
-        .skip(ignore_first as usize)
-        .filter_map(|l| {
-            if l.is_empty() {
-                None
-            } else {
-                // ignore empty lines
-                Some(l.char_indices().find(|&(_, x)| x != ch).unwrap_or((l.len(), ch)).0)
-            }
-        })
-        .min()
-        .unwrap_or(0);
-    let indent = indent.unwrap_or(0);
-    s.lines()
-        .enumerate()
-        .map(|(i, l)| {
-            if (ignore_first && i == 0) || l.is_empty() {
-                l.to_owned()
-            } else if x > indent {
-                l.split_at(x - indent).1.to_owned()
-            } else {
-                " ".repeat(indent - x) + l
-            }
-        })
-        .collect::<Vec<String>>()
-        .join("\n")
-}
-
 /// Gets the span of the node, if there is one.
 pub fn get_node_span(node: Node<'_>) -> Option<Span> {
     match node {
@@ -1366,39 +1086,6 @@ pub fn clip(tcx: TyCtxt<'_>, u: u128, ity: rustc_ty::UintTy) -> u128 {
     (u << amt) >> amt
 }
 
-/// Removes block comments from the given `Vec` of lines.
-///
-/// # Examples
-///
-/// ```rust,ignore
-/// without_block_comments(vec!["/*", "foo", "*/"]);
-/// // => vec![]
-///
-/// without_block_comments(vec!["bar", "/*", "foo", "*/"]);
-/// // => vec!["bar"]
-/// ```
-pub fn without_block_comments(lines: Vec<&str>) -> Vec<&str> {
-    let mut without = vec![];
-
-    let mut nest_level = 0;
-
-    for line in lines {
-        if line.contains("/*") {
-            nest_level += 1;
-            continue;
-        } else if line.contains("*/") {
-            nest_level -= 1;
-            continue;
-        }
-
-        if nest_level == 0 {
-            without.push(line);
-        }
-    }
-
-    without
-}
-
 pub fn any_parent_is_automatically_derived(tcx: TyCtxt<'_>, node: HirId) -> bool {
     let map = &tcx.hir();
     let mut prev_enclosing_node = None;
@@ -1777,100 +1464,3 @@ pub fn is_some_ctor(cx: &LateContext<'_>, res: Res) -> bool {
     }
     false
 }
-
-#[cfg(test)]
-mod test {
-    use super::{reindent_multiline, without_block_comments};
-
-    #[test]
-    fn test_reindent_multiline_single_line() {
-        assert_eq!("", reindent_multiline("".into(), false, None));
-        assert_eq!("...", reindent_multiline("...".into(), false, None));
-        assert_eq!("...", reindent_multiline("    ...".into(), false, None));
-        assert_eq!("...", reindent_multiline("\t...".into(), false, None));
-        assert_eq!("...", reindent_multiline("\t\t...".into(), false, None));
-    }
-
-    #[test]
-    #[rustfmt::skip]
-    fn test_reindent_multiline_block() {
-        assert_eq!("\
-    if x {
-        y
-    } else {
-        z
-    }", reindent_multiline("    if x {
-            y
-        } else {
-            z
-        }".into(), false, None));
-        assert_eq!("\
-    if x {
-    \ty
-    } else {
-    \tz
-    }", reindent_multiline("    if x {
-        \ty
-        } else {
-        \tz
-        }".into(), false, None));
-    }
-
-    #[test]
-    #[rustfmt::skip]
-    fn test_reindent_multiline_empty_line() {
-        assert_eq!("\
-    if x {
-        y
-
-    } else {
-        z
-    }", reindent_multiline("    if x {
-            y
-
-        } else {
-            z
-        }".into(), false, None));
-    }
-
-    #[test]
-    #[rustfmt::skip]
-    fn test_reindent_multiline_lines_deeper() {
-        assert_eq!("\
-        if x {
-            y
-        } else {
-            z
-        }", reindent_multiline("\
-    if x {
-        y
-    } else {
-        z
-    }".into(), true, Some(8)));
-    }
-
-    #[test]
-    fn test_without_block_comments_lines_without_block_comments() {
-        let result = without_block_comments(vec!["/*", "", "*/"]);
-        println!("result: {:?}", result);
-        assert!(result.is_empty());
-
-        let result = without_block_comments(vec!["", "/*", "", "*/", "#[crate_type = \"lib\"]", "/*", "", "*/", ""]);
-        assert_eq!(result, vec!["", "#[crate_type = \"lib\"]", ""]);
-
-        let result = without_block_comments(vec!["/* rust", "", "*/"]);
-        assert!(result.is_empty());
-
-        let result = without_block_comments(vec!["/* one-line comment */"]);
-        assert!(result.is_empty());
-
-        let result = without_block_comments(vec!["/* nested", "/* multi-line", "comment", "*/", "test", "*/"]);
-        assert!(result.is_empty());
-
-        let result = without_block_comments(vec!["/* nested /* inline /* comment */ test */ */"]);
-        assert!(result.is_empty());
-
-        let result = without_block_comments(vec!["foo", "bar", "baz"]);
-        assert_eq!(result, vec!["foo", "bar", "baz"]);
-    }
-}
diff --git a/clippy_utils/src/ptr.rs b/clippy_utils/src/ptr.rs
index df6143edbca..5885cc83560 100644
--- a/clippy_utils/src/ptr.rs
+++ b/clippy_utils/src/ptr.rs
@@ -1,4 +1,5 @@
-use crate::{get_pat_name, match_var, snippet};
+use crate::source::snippet;
+use crate::{get_pat_name, match_var};
 use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
 use rustc_hir::{Body, BodyId, Expr, ExprKind, Param};
 use rustc_lint::LateContext;
diff --git a/clippy_utils/src/source.rs b/clippy_utils/src/source.rs
new file mode 100644
index 00000000000..2d794d48dc5
--- /dev/null
+++ b/clippy_utils/src/source.rs
@@ -0,0 +1,420 @@
+//! Utils for extracting, inspecting or transforming source code
+
+#![allow(clippy::module_name_repetitions)]
+
+use crate::line_span;
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind};
+use rustc_lint::{LateContext, LintContext};
+use rustc_span::hygiene;
+use rustc_span::{BytePos, Pos, Span, SyntaxContext};
+use std::borrow::Cow;
+
+/// Like `snippet_block`, but add braces if the expr is not an `ExprKind::Block`.
+/// Also takes an `Option<String>` which can be put inside the braces.
+pub fn expr_block<'a, T: LintContext>(
+    cx: &T,
+    expr: &Expr<'_>,
+    option: Option<String>,
+    default: &'a str,
+    indent_relative_to: Option<Span>,
+) -> Cow<'a, str> {
+    let code = snippet_block(cx, expr.span, default, indent_relative_to);
+    let string = option.unwrap_or_default();
+    if expr.span.from_expansion() {
+        Cow::Owned(format!("{{ {} }}", snippet_with_macro_callsite(cx, expr.span, default)))
+    } else if let ExprKind::Block(_, _) = expr.kind {
+        Cow::Owned(format!("{}{}", code, string))
+    } else if string.is_empty() {
+        Cow::Owned(format!("{{ {} }}", code))
+    } else {
+        Cow::Owned(format!("{{\n{};\n{}\n}}", code, string))
+    }
+}
+
+/// Returns a new Span that extends the original Span to the first non-whitespace char of the first
+/// line.
+///
+/// ```rust,ignore
+///     let x = ();
+/// //          ^^
+/// // will be converted to
+///     let x = ();
+/// //  ^^^^^^^^^^
+/// ```
+pub fn first_line_of_span<T: LintContext>(cx: &T, span: Span) -> Span {
+    first_char_in_first_line(cx, span).map_or(span, |first_char_pos| span.with_lo(first_char_pos))
+}
+
+fn first_char_in_first_line<T: LintContext>(cx: &T, span: Span) -> Option<BytePos> {
+    let line_span = line_span(cx, span);
+    snippet_opt(cx, line_span).and_then(|snip| {
+        snip.find(|c: char| !c.is_whitespace())
+            .map(|pos| line_span.lo() + BytePos::from_usize(pos))
+    })
+}
+
+/// Returns the indentation of the line of a span
+///
+/// ```rust,ignore
+/// let x = ();
+/// //      ^^ -- will return 0
+///     let x = ();
+/// //          ^^ -- will return 4
+/// ```
+pub fn indent_of<T: LintContext>(cx: &T, span: Span) -> Option<usize> {
+    snippet_opt(cx, line_span(cx, span)).and_then(|snip| snip.find(|c: char| !c.is_whitespace()))
+}
+
+// If the snippet is empty, it's an attribute that was inserted during macro
+// expansion and we want to ignore those, because they could come from external
+// sources that the user has no control over.
+// For some reason these attributes don't have any expansion info on them, so
+// we have to check it this way until there is a better way.
+pub fn is_present_in_source<T: LintContext>(cx: &T, span: Span) -> bool {
+    if let Some(snippet) = snippet_opt(cx, span) {
+        if snippet.is_empty() {
+            return false;
+        }
+    }
+    true
+}
+
+/// Returns the positon just before rarrow
+///
+/// ```rust,ignore
+/// fn into(self) -> () {}
+///              ^
+/// // in case of unformatted code
+/// fn into2(self)-> () {}
+///               ^
+/// fn into3(self)   -> () {}
+///               ^
+/// ```
+pub fn position_before_rarrow(s: &str) -> Option<usize> {
+    s.rfind("->").map(|rpos| {
+        let mut rpos = rpos;
+        let chars: Vec<char> = s.chars().collect();
+        while rpos > 1 {
+            if let Some(c) = chars.get(rpos - 1) {
+                if c.is_whitespace() {
+                    rpos -= 1;
+                    continue;
+                }
+            }
+            break;
+        }
+        rpos
+    })
+}
+
+/// Reindent a multiline string with possibility of ignoring the first line.
+#[allow(clippy::needless_pass_by_value)]
+pub fn reindent_multiline(s: Cow<'_, str>, ignore_first: bool, indent: Option<usize>) -> Cow<'_, str> {
+    let s_space = reindent_multiline_inner(&s, ignore_first, indent, ' ');
+    let s_tab = reindent_multiline_inner(&s_space, ignore_first, indent, '\t');
+    reindent_multiline_inner(&s_tab, ignore_first, indent, ' ').into()
+}
+
+fn reindent_multiline_inner(s: &str, ignore_first: bool, indent: Option<usize>, ch: char) -> String {
+    let x = s
+        .lines()
+        .skip(ignore_first as usize)
+        .filter_map(|l| {
+            if l.is_empty() {
+                None
+            } else {
+                // ignore empty lines
+                Some(l.char_indices().find(|&(_, x)| x != ch).unwrap_or((l.len(), ch)).0)
+            }
+        })
+        .min()
+        .unwrap_or(0);
+    let indent = indent.unwrap_or(0);
+    s.lines()
+        .enumerate()
+        .map(|(i, l)| {
+            if (ignore_first && i == 0) || l.is_empty() {
+                l.to_owned()
+            } else if x > indent {
+                l.split_at(x - indent).1.to_owned()
+            } else {
+                " ".repeat(indent - x) + l
+            }
+        })
+        .collect::<Vec<String>>()
+        .join("\n")
+}
+
+/// Converts a span to a code snippet if available, otherwise use default.
+///
+/// This is useful if you want to provide suggestions for your lint or more generally, if you want
+/// to convert a given `Span` to a `str`.
+///
+/// # Example
+/// ```rust,ignore
+/// snippet(cx, expr.span, "..")
+/// ```
+pub fn snippet<'a, T: LintContext>(cx: &T, span: Span, default: &'a str) -> Cow<'a, str> {
+    snippet_opt(cx, span).map_or_else(|| Cow::Borrowed(default), From::from)
+}
+
+/// Same as `snippet`, but it adapts the applicability level by following rules:
+///
+/// - Applicability level `Unspecified` will never be changed.
+/// - If the span is inside a macro, change the applicability level to `MaybeIncorrect`.
+/// - If the default value is used and the applicability level is `MachineApplicable`, change it to
+/// `HasPlaceholders`
+pub fn snippet_with_applicability<'a, T: LintContext>(
+    cx: &T,
+    span: Span,
+    default: &'a str,
+    applicability: &mut Applicability,
+) -> Cow<'a, str> {
+    if *applicability != Applicability::Unspecified && span.from_expansion() {
+        *applicability = Applicability::MaybeIncorrect;
+    }
+    snippet_opt(cx, span).map_or_else(
+        || {
+            if *applicability == Applicability::MachineApplicable {
+                *applicability = Applicability::HasPlaceholders;
+            }
+            Cow::Borrowed(default)
+        },
+        From::from,
+    )
+}
+
+/// Same as `snippet`, but should only be used when it's clear that the input span is
+/// not a macro argument.
+pub fn snippet_with_macro_callsite<'a, T: LintContext>(cx: &T, span: Span, default: &'a str) -> Cow<'a, str> {
+    snippet(cx, span.source_callsite(), default)
+}
+
+/// Converts a span to a code snippet. Returns `None` if not available.
+pub fn snippet_opt<T: LintContext>(cx: &T, span: Span) -> Option<String> {
+    cx.sess().source_map().span_to_snippet(span).ok()
+}
+
+/// Converts a span (from a block) to a code snippet if available, otherwise use default.
+///
+/// This trims the code of indentation, except for the first line. Use it for blocks or block-like
+/// things which need to be printed as such.
+///
+/// The `indent_relative_to` arg can be used, to provide a span, where the indentation of the
+/// resulting snippet of the given span.
+///
+/// # Example
+///
+/// ```rust,ignore
+/// snippet_block(cx, block.span, "..", None)
+/// // where, `block` is the block of the if expr
+///     if x {
+///         y;
+///     }
+/// // will return the snippet
+/// {
+///     y;
+/// }
+/// ```
+///
+/// ```rust,ignore
+/// snippet_block(cx, block.span, "..", Some(if_expr.span))
+/// // where, `block` is the block of the if expr
+///     if x {
+///         y;
+///     }
+/// // will return the snippet
+/// {
+///         y;
+///     } // aligned with `if`
+/// ```
+/// Note that the first line of the snippet always has 0 indentation.
+pub fn snippet_block<'a, T: LintContext>(
+    cx: &T,
+    span: Span,
+    default: &'a str,
+    indent_relative_to: Option<Span>,
+) -> Cow<'a, str> {
+    let snip = snippet(cx, span, default);
+    let indent = indent_relative_to.and_then(|s| indent_of(cx, s));
+    reindent_multiline(snip, true, indent)
+}
+
+/// Same as `snippet_block`, but adapts the applicability level by the rules of
+/// `snippet_with_applicability`.
+pub fn snippet_block_with_applicability<'a, T: LintContext>(
+    cx: &T,
+    span: Span,
+    default: &'a str,
+    indent_relative_to: Option<Span>,
+    applicability: &mut Applicability,
+) -> Cow<'a, str> {
+    let snip = snippet_with_applicability(cx, span, default, applicability);
+    let indent = indent_relative_to.and_then(|s| indent_of(cx, s));
+    reindent_multiline(snip, true, indent)
+}
+
+/// Same as `snippet_with_applicability`, but first walks the span up to the given context. This
+/// will result in the macro call, rather then the expansion, if the span is from a child context.
+/// If the span is not from a child context, it will be used directly instead.
+///
+/// e.g. Given the expression `&vec![]`, getting a snippet from the span for `vec![]` as a HIR node
+/// would result in `box []`. If given the context of the address of expression, this function will
+/// correctly get a snippet of `vec![]`.
+///
+/// This will also return whether or not the snippet is a macro call.
+pub fn snippet_with_context(
+    cx: &LateContext<'_>,
+    span: Span,
+    outer: SyntaxContext,
+    default: &'a str,
+    applicability: &mut Applicability,
+) -> (Cow<'a, str>, bool) {
+    let outer_span = hygiene::walk_chain(span, outer);
+    let (span, is_macro_call) = if outer_span.ctxt() == outer {
+        (outer_span, span.ctxt() != outer)
+    } else {
+        // The span is from a macro argument, and the outer context is the macro using the argument
+        if *applicability != Applicability::Unspecified {
+            *applicability = Applicability::MaybeIncorrect;
+        }
+        // TODO: get the argument span.
+        (span, false)
+    };
+
+    (
+        snippet_with_applicability(cx, span, default, applicability),
+        is_macro_call,
+    )
+}
+
+/// Removes block comments from the given `Vec` of lines.
+///
+/// # Examples
+///
+/// ```rust,ignore
+/// without_block_comments(vec!["/*", "foo", "*/"]);
+/// // => vec![]
+///
+/// without_block_comments(vec!["bar", "/*", "foo", "*/"]);
+/// // => vec!["bar"]
+/// ```
+pub fn without_block_comments(lines: Vec<&str>) -> Vec<&str> {
+    let mut without = vec![];
+
+    let mut nest_level = 0;
+
+    for line in lines {
+        if line.contains("/*") {
+            nest_level += 1;
+            continue;
+        } else if line.contains("*/") {
+            nest_level -= 1;
+            continue;
+        }
+
+        if nest_level == 0 {
+            without.push(line);
+        }
+    }
+
+    without
+}
+
+#[cfg(test)]
+mod test {
+    use super::{reindent_multiline, without_block_comments};
+
+    #[test]
+    fn test_reindent_multiline_single_line() {
+        assert_eq!("", reindent_multiline("".into(), false, None));
+        assert_eq!("...", reindent_multiline("...".into(), false, None));
+        assert_eq!("...", reindent_multiline("    ...".into(), false, None));
+        assert_eq!("...", reindent_multiline("\t...".into(), false, None));
+        assert_eq!("...", reindent_multiline("\t\t...".into(), false, None));
+    }
+
+    #[test]
+    #[rustfmt::skip]
+    fn test_reindent_multiline_block() {
+        assert_eq!("\
+    if x {
+        y
+    } else {
+        z
+    }", reindent_multiline("    if x {
+            y
+        } else {
+            z
+        }".into(), false, None));
+        assert_eq!("\
+    if x {
+    \ty
+    } else {
+    \tz
+    }", reindent_multiline("    if x {
+        \ty
+        } else {
+        \tz
+        }".into(), false, None));
+    }
+
+    #[test]
+    #[rustfmt::skip]
+    fn test_reindent_multiline_empty_line() {
+        assert_eq!("\
+    if x {
+        y
+
+    } else {
+        z
+    }", reindent_multiline("    if x {
+            y
+
+        } else {
+            z
+        }".into(), false, None));
+    }
+
+    #[test]
+    #[rustfmt::skip]
+    fn test_reindent_multiline_lines_deeper() {
+        assert_eq!("\
+        if x {
+            y
+        } else {
+            z
+        }", reindent_multiline("\
+    if x {
+        y
+    } else {
+        z
+    }".into(), true, Some(8)));
+    }
+
+    #[test]
+    fn test_without_block_comments_lines_without_block_comments() {
+        let result = without_block_comments(vec!["/*", "", "*/"]);
+        println!("result: {:?}", result);
+        assert!(result.is_empty());
+
+        let result = without_block_comments(vec!["", "/*", "", "*/", "#[crate_type = \"lib\"]", "/*", "", "*/", ""]);
+        assert_eq!(result, vec!["", "#[crate_type = \"lib\"]", ""]);
+
+        let result = without_block_comments(vec!["/* rust", "", "*/"]);
+        assert!(result.is_empty());
+
+        let result = without_block_comments(vec!["/* one-line comment */"]);
+        assert!(result.is_empty());
+
+        let result = without_block_comments(vec!["/* nested", "/* multi-line", "comment", "*/", "test", "*/"]);
+        assert!(result.is_empty());
+
+        let result = without_block_comments(vec!["/* nested /* inline /* comment */ test */ */"]);
+        assert!(result.is_empty());
+
+        let result = without_block_comments(vec!["foo", "bar", "baz"]);
+        assert_eq!(result, vec!["foo", "bar", "baz"]);
+    }
+}
diff --git a/clippy_utils/src/sugg.rs b/clippy_utils/src/sugg.rs
index d4f6f4281d3..b2fe4317154 100644
--- a/clippy_utils/src/sugg.rs
+++ b/clippy_utils/src/sugg.rs
@@ -1,7 +1,8 @@
 //! Contains utility functions to generate suggestions.
 #![deny(clippy::missing_docs_in_private_items)]
 
-use crate::{higher, snippet, snippet_opt, snippet_with_macro_callsite};
+use crate::higher;
+use crate::source::{snippet, snippet_opt, snippet_with_macro_callsite};
 use rustc_ast::util::parser::AssocOp;
 use rustc_ast::{ast, token};
 use rustc_ast_pretty::pprust::token_kind_to_string;
-- 
cgit 1.4.1-3-g733a5


From 1c3a3e7dc62ae3b4b84cc00c067789dae1d722c9 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Mon, 15 Mar 2021 19:55:45 -0500
Subject: Don't re-export clippy_utils::diagnostics::*

---
 clippy_lints/src/approx_const.rs                              |  2 +-
 clippy_lints/src/arithmetic.rs                                |  2 +-
 clippy_lints/src/as_conversions.rs                            |  3 +--
 clippy_lints/src/asm_syntax.rs                                |  2 +-
 clippy_lints/src/assertions_on_constants.rs                   |  3 ++-
 clippy_lints/src/assign_ops.rs                                |  3 ++-
 clippy_lints/src/async_yields_async.rs                        |  2 +-
 clippy_lints/src/atomic_ordering.rs                           |  3 ++-
 clippy_lints/src/attrs.rs                                     |  3 ++-
 clippy_lints/src/await_holding_invalid.rs                     |  3 ++-
 clippy_lints/src/bit_mask.rs                                  |  2 +-
 clippy_lints/src/blacklisted_name.rs                          |  2 +-
 clippy_lints/src/blocks_in_if_conditions.rs                   |  3 ++-
 clippy_lints/src/booleans.rs                                  |  3 ++-
 clippy_lints/src/bytecount.rs                                 |  3 ++-
 clippy_lints/src/cargo_common_metadata.rs                     |  3 ++-
 clippy_lints/src/case_sensitive_file_extension_comparisons.rs |  2 +-
 clippy_lints/src/casts/cast_lossless.rs                       |  3 ++-
 clippy_lints/src/casts/cast_possible_truncation.rs            |  2 +-
 clippy_lints/src/casts/cast_possible_wrap.rs                  |  3 +--
 clippy_lints/src/casts/cast_precision_loss.rs                 |  3 +--
 clippy_lints/src/casts/cast_ptr_alignment.rs                  |  3 ++-
 clippy_lints/src/casts/cast_ref_to_mut.rs                     |  6 ++----
 clippy_lints/src/casts/cast_sign_loss.rs                      |  3 ++-
 clippy_lints/src/casts/char_lit_as_u8.rs                      |  3 +--
 clippy_lints/src/casts/fn_to_numeric_cast.rs                  |  2 +-
 clippy_lints/src/casts/fn_to_numeric_cast_with_truncation.rs  |  2 +-
 clippy_lints/src/casts/ptr_as_ptr.rs                          |  3 ++-
 clippy_lints/src/casts/unnecessary_cast.rs                    |  3 ++-
 clippy_lints/src/checked_conversions.rs                       |  3 ++-
 clippy_lints/src/cognitive_complexity.rs                      |  3 ++-
 clippy_lints/src/collapsible_if.rs                            |  2 +-
 clippy_lints/src/collapsible_match.rs                         |  3 ++-
 clippy_lints/src/comparison_chain.rs                          |  3 ++-
 clippy_lints/src/copies.rs                                    |  3 ++-
 clippy_lints/src/copy_iterator.rs                             |  2 +-
 clippy_lints/src/create_dir.rs                                |  3 ++-
 clippy_lints/src/dbg_macro.rs                                 |  2 +-
 clippy_lints/src/default.rs                                   |  2 +-
 clippy_lints/src/default_numeric_fallback.rs                  |  3 +--
 clippy_lints/src/dereference.rs                               |  3 ++-
 clippy_lints/src/derive.rs                                    |  6 ++----
 clippy_lints/src/disallowed_method.rs                         |  3 ++-
 clippy_lints/src/doc.rs                                       |  5 ++---
 clippy_lints/src/double_comparison.rs                         |  3 ++-
 clippy_lints/src/double_parens.rs                             |  2 +-
 clippy_lints/src/drop_forget_ref.rs                           |  3 ++-
 clippy_lints/src/duration_subsec.rs                           |  2 +-
 clippy_lints/src/else_if_without_else.rs                      |  3 +--
 clippy_lints/src/empty_enum.rs                                |  2 +-
 clippy_lints/src/entry.rs                                     |  2 +-
 clippy_lints/src/enum_clike.rs                                |  2 +-
 clippy_lints/src/enum_variants.rs                             |  2 +-
 clippy_lints/src/eq_op.rs                                     |  6 ++----
 clippy_lints/src/erasing_op.rs                                |  2 +-
 clippy_lints/src/escape.rs                                    |  3 +--
 clippy_lints/src/eta_reduction.rs                             |  3 ++-
 clippy_lints/src/eval_order_dependence.rs                     |  3 ++-
 clippy_lints/src/excessive_bools.rs                           |  3 ++-
 clippy_lints/src/exhaustive_items.rs                          |  4 +---
 clippy_lints/src/exit.rs                                      |  3 ++-
 clippy_lints/src/explicit_write.rs                            |  3 ++-
 clippy_lints/src/fallible_impl_from.rs                        |  3 ++-
 clippy_lints/src/float_equality_without_abs.rs                |  3 ++-
 clippy_lints/src/float_literal.rs                             |  3 ++-
 clippy_lints/src/floating_point_arithmetic.rs                 |  3 ++-
 clippy_lints/src/format.rs                                    |  3 ++-
 clippy_lints/src/formatting.rs                                |  3 ++-
 clippy_lints/src/from_over_into.rs                            |  3 ++-
 clippy_lints/src/from_str_radix_10.rs                         |  2 +-
 clippy_lints/src/functions.rs                                 |  3 ++-
 clippy_lints/src/future_not_send.rs                           |  3 ++-
 clippy_lints/src/get_last_with_len.rs                         |  3 ++-
 clippy_lints/src/identity_op.rs                               |  3 ++-
 clippy_lints/src/if_let_mutex.rs                              |  3 ++-
 clippy_lints/src/if_let_some_result.rs                        |  3 ++-
 clippy_lints/src/if_not_else.rs                               |  3 +--
 clippy_lints/src/if_then_some_else_none.rs                    |  3 ++-
 clippy_lints/src/implicit_return.rs                           |  3 ++-
 clippy_lints/src/implicit_saturating_sub.rs                   |  3 ++-
 clippy_lints/src/inconsistent_struct_constructor.rs           |  3 +--
 clippy_lints/src/indexing_slicing.rs                          |  3 ++-
 clippy_lints/src/infinite_iter.rs                             |  3 ++-
 clippy_lints/src/inherent_impl.rs                             |  3 ++-
 clippy_lints/src/inherent_to_string.rs                        |  3 ++-
 clippy_lints/src/inline_fn_without_body.rs                    |  2 +-
 clippy_lints/src/int_plus_one.rs                              |  3 +--
 clippy_lints/src/integer_division.rs                          |  2 +-
 clippy_lints/src/items_after_statements.rs                    |  2 +-
 clippy_lints/src/large_const_arrays.rs                        |  2 +-
 clippy_lints/src/large_enum_variant.rs                        |  2 +-
 clippy_lints/src/large_stack_arrays.rs                        |  2 +-
 clippy_lints/src/len_zero.rs                                  |  3 ++-
 clippy_lints/src/let_if_seq.rs                                |  3 ++-
 clippy_lints/src/let_underscore.rs                            |  3 ++-
 clippy_lints/src/lifetimes.rs                                 |  3 ++-
 clippy_lints/src/literal_representation.rs                    |  2 +-
 clippy_lints/src/loops/empty_loop.rs                          |  3 ++-
 clippy_lints/src/loops/explicit_counter_loop.rs               |  3 ++-
 clippy_lints/src/loops/explicit_into_iter_loop.rs             |  2 +-
 clippy_lints/src/loops/explicit_iter_loop.rs                  |  3 ++-
 clippy_lints/src/loops/for_kv_map.rs                          |  3 ++-
 clippy_lints/src/loops/for_loops_over_fallibles.rs            |  5 ++---
 clippy_lints/src/loops/iter_next_loop.rs                      |  3 ++-
 clippy_lints/src/loops/manual_flatten.rs                      |  3 ++-
 clippy_lints/src/loops/manual_memcpy.rs                       |  3 ++-
 clippy_lints/src/loops/mut_range_bound.rs                     |  3 ++-
 clippy_lints/src/loops/needless_collect.rs                    |  3 ++-
 clippy_lints/src/loops/needless_range_loop.rs                 |  4 ++--
 clippy_lints/src/loops/never_loop.rs                          |  2 +-
 clippy_lints/src/loops/same_item_push.rs                      |  2 +-
 clippy_lints/src/loops/single_element_loop.rs                 |  3 ++-
 clippy_lints/src/loops/while_immutable_condition.rs           |  2 +-
 clippy_lints/src/loops/while_let_loop.rs                      |  2 +-
 clippy_lints/src/loops/while_let_on_iterator.rs               |  2 +-
 clippy_lints/src/macro_use.rs                                 |  3 ++-
 clippy_lints/src/main_recursion.rs                            |  3 ++-
 clippy_lints/src/manual_async_fn.rs                           |  3 ++-
 clippy_lints/src/manual_map.rs                                |  3 ++-
 clippy_lints/src/manual_non_exhaustive.rs                     |  3 ++-
 clippy_lints/src/manual_ok_or.rs                              |  3 ++-
 clippy_lints/src/manual_strip.rs                              |  3 ++-
 clippy_lints/src/manual_unwrap_or.rs                          |  3 ++-
 clippy_lints/src/map_clone.rs                                 |  3 ++-
 clippy_lints/src/map_err_ignore.rs                            |  3 +--
 clippy_lints/src/map_identity.rs                              |  3 ++-
 clippy_lints/src/map_unit_fn.rs                               |  3 ++-
 clippy_lints/src/match_on_vec_items.rs                        |  2 +-
 clippy_lints/src/matches.rs                                   | 11 +++++++----
 clippy_lints/src/mem_discriminant.rs                          |  3 ++-
 clippy_lints/src/mem_forget.rs                                |  3 ++-
 clippy_lints/src/mem_replace.rs                               |  6 ++----
 clippy_lints/src/methods/bind_instead_of_map.rs               |  6 ++----
 clippy_lints/src/methods/bytes_nth.rs                         |  2 +-
 clippy_lints/src/methods/clone_on_copy.rs                     |  3 ++-
 clippy_lints/src/methods/clone_on_ref_ptr.rs                  |  3 ++-
 clippy_lints/src/methods/expect_fun_call.rs                   |  3 ++-
 clippy_lints/src/methods/expect_used.rs                       |  2 +-
 clippy_lints/src/methods/filetype_is_file.rs                  |  3 ++-
 clippy_lints/src/methods/filter_flat_map.rs                   |  3 ++-
 clippy_lints/src/methods/filter_map.rs                        |  3 ++-
 clippy_lints/src/methods/filter_map_flat_map.rs               |  3 ++-
 clippy_lints/src/methods/filter_map_identity.rs               |  3 ++-
 clippy_lints/src/methods/filter_map_map.rs                    |  3 ++-
 clippy_lints/src/methods/filter_map_next.rs                   |  3 ++-
 clippy_lints/src/methods/filter_next.rs                       |  3 ++-
 clippy_lints/src/methods/flat_map_identity.rs                 |  3 ++-
 clippy_lints/src/methods/from_iter_instead_of_collect.rs      |  3 ++-
 clippy_lints/src/methods/get_unwrap.rs                        |  3 ++-
 clippy_lints/src/methods/implicit_clone.rs                    |  2 +-
 clippy_lints/src/methods/inefficient_to_string.rs             |  3 ++-
 clippy_lints/src/methods/inspect_for_each.rs                  |  3 ++-
 clippy_lints/src/methods/into_iter_on_ref.rs                  |  3 ++-
 clippy_lints/src/methods/iter_cloned_collect.rs               |  2 +-
 clippy_lints/src/methods/iter_count.rs                        |  3 ++-
 clippy_lints/src/methods/iter_next_slice.rs                   |  3 ++-
 clippy_lints/src/methods/iter_nth.rs                          |  2 +-
 clippy_lints/src/methods/iter_nth_zero.rs                     |  3 ++-
 clippy_lints/src/methods/iter_skip_next.rs                    |  3 ++-
 clippy_lints/src/methods/iterator_step_by_zero.rs             |  3 ++-
 clippy_lints/src/methods/manual_saturating_arithmetic.rs      |  3 ++-
 clippy_lints/src/methods/map_collect_result_unit.rs           |  3 ++-
 clippy_lints/src/methods/map_flatten.rs                       |  3 ++-
 clippy_lints/src/methods/map_unwrap_or.rs                     |  3 ++-
 clippy_lints/src/methods/mod.rs                               |  4 ++--
 clippy_lints/src/methods/ok_expect.rs                         |  2 +-
 clippy_lints/src/methods/option_as_ref_deref.rs               |  3 ++-
 clippy_lints/src/methods/option_map_or_none.rs                |  3 ++-
 clippy_lints/src/methods/option_map_unwrap_or.rs              |  3 ++-
 clippy_lints/src/methods/or_fun_call.rs                       |  3 ++-
 clippy_lints/src/methods/search_is_some.rs                    |  3 ++-
 clippy_lints/src/methods/single_char_insert_string.rs         |  2 +-
 clippy_lints/src/methods/single_char_pattern.rs               |  2 +-
 clippy_lints/src/methods/single_char_push_string.rs           |  2 +-
 clippy_lints/src/methods/skip_while_next.rs                   |  3 ++-
 clippy_lints/src/methods/string_extend_chars.rs               |  3 ++-
 clippy_lints/src/methods/suspicious_map.rs                    |  3 ++-
 clippy_lints/src/methods/uninit_assumed_init.rs               |  3 ++-
 clippy_lints/src/methods/unnecessary_filter_map.rs            |  3 ++-
 clippy_lints/src/methods/unnecessary_fold.rs                  |  3 ++-
 clippy_lints/src/methods/unnecessary_lazy_eval.rs             |  2 +-
 clippy_lints/src/methods/unwrap_used.rs                       |  2 +-
 clippy_lints/src/methods/useless_asref.rs                     |  3 ++-
 clippy_lints/src/methods/wrong_self_convention.rs             |  2 +-
 clippy_lints/src/methods/zst_offset.rs                        |  2 +-
 clippy_lints/src/minmax.rs                                    |  3 ++-
 clippy_lints/src/misc.rs                                      |  4 ++--
 clippy_lints/src/misc_early.rs                                |  2 +-
 clippy_lints/src/missing_const_for_fn.rs                      |  3 ++-
 clippy_lints/src/missing_doc.rs                               |  2 +-
 clippy_lints/src/missing_inline.rs                            |  2 +-
 clippy_lints/src/modulo_arithmetic.rs                         |  3 ++-
 clippy_lints/src/multiple_crate_versions.rs                   |  3 ++-
 clippy_lints/src/mut_key.rs                                   |  3 ++-
 clippy_lints/src/mut_mut.rs                                   |  3 ++-
 clippy_lints/src/mut_mutex_lock.rs                            |  2 +-
 clippy_lints/src/mut_reference.rs                             |  2 +-
 clippy_lints/src/mutable_debug_assertion.rs                   |  3 ++-
 clippy_lints/src/mutex_atomic.rs                              |  2 +-
 clippy_lints/src/needless_arbitrary_self_type.rs              |  3 ++-
 clippy_lints/src/needless_bool.rs                             |  3 ++-
 clippy_lints/src/needless_borrow.rs                           |  3 ++-
 clippy_lints/src/needless_borrowed_ref.rs                     |  2 +-
 clippy_lints/src/needless_continue.rs                         |  3 +--
 clippy_lints/src/needless_pass_by_value.rs                    |  3 ++-
 clippy_lints/src/needless_question_mark.rs                    |  3 ++-
 clippy_lints/src/needless_update.rs                           |  2 +-
 clippy_lints/src/neg_cmp_op_on_partial_ord.rs                 |  3 ++-
 clippy_lints/src/neg_multiply.rs                              |  2 +-
 clippy_lints/src/new_without_default.rs                       |  3 ++-
 clippy_lints/src/no_effect.rs                                 |  2 +-
 clippy_lints/src/non_copy_const.rs                            |  3 ++-
 clippy_lints/src/non_expressive_names.rs                      |  2 +-
 clippy_lints/src/open_options.rs                              |  3 ++-
 clippy_lints/src/option_env_unwrap.rs                         |  3 ++-
 clippy_lints/src/option_if_let_else.rs                        |  3 ++-
 clippy_lints/src/overflow_check_conditional.rs                |  3 ++-
 clippy_lints/src/panic_in_result_fn.rs                        |  3 ++-
 clippy_lints/src/panic_unimplemented.rs                       |  3 ++-
 clippy_lints/src/partialeq_ne_impl.rs                         |  3 ++-
 clippy_lints/src/pass_by_ref_or_value.rs                      |  3 ++-
 clippy_lints/src/path_buf_push_overwrite.rs                   |  2 +-
 clippy_lints/src/pattern_type_mismatch.rs                     |  3 ++-
 clippy_lints/src/precedence.rs                                |  2 +-
 clippy_lints/src/ptr.rs                                       |  3 ++-
 clippy_lints/src/ptr_eq.rs                                    |  3 ++-
 clippy_lints/src/ptr_offset_with_cast.rs                      |  2 +-
 clippy_lints/src/question_mark.rs                             |  3 ++-
 clippy_lints/src/ranges.rs                                    |  6 ++----
 clippy_lints/src/redundant_clone.rs                           |  3 ++-
 clippy_lints/src/redundant_closure_call.rs                    |  2 +-
 clippy_lints/src/redundant_else.rs                            |  2 +-
 clippy_lints/src/redundant_field_names.rs                     |  3 ++-
 clippy_lints/src/redundant_pub_crate.rs                       |  2 +-
 clippy_lints/src/redundant_slicing.rs                         |  3 +--
 clippy_lints/src/redundant_static_lifetimes.rs                |  3 ++-
 clippy_lints/src/ref_option_ref.rs                            |  3 ++-
 clippy_lints/src/reference.rs                                 |  3 ++-
 clippy_lints/src/regex.rs                                     |  3 ++-
 clippy_lints/src/repeat_once.rs                               |  3 ++-
 clippy_lints/src/returns.rs                                   |  3 ++-
 clippy_lints/src/self_assignment.rs                           |  3 ++-
 clippy_lints/src/semicolon_if_nothing_returned.rs             |  3 ++-
 clippy_lints/src/serde_api.rs                                 |  3 ++-
 clippy_lints/src/shadow.rs                                    |  3 ++-
 clippy_lints/src/single_component_path_imports.rs             |  3 ++-
 clippy_lints/src/size_of_in_element_count.rs                  |  3 ++-
 clippy_lints/src/slow_vector_initialization.rs                |  3 ++-
 clippy_lints/src/stable_sort_primitive.rs                     |  3 ++-
 clippy_lints/src/strings.rs                                   |  6 ++----
 clippy_lints/src/suspicious_operation_groupings.rs            |  2 +-
 clippy_lints/src/suspicious_trait_impl.rs                     |  3 ++-
 clippy_lints/src/swap.rs                                      |  3 ++-
 clippy_lints/src/tabs_in_doc_comments.rs                      |  2 +-
 clippy_lints/src/temporary_assignment.rs                      |  3 ++-
 clippy_lints/src/to_digit_is_some.rs                          |  3 ++-
 clippy_lints/src/to_string_in_display.rs                      |  3 ++-
 clippy_lints/src/trait_bounds.rs                              |  3 ++-
 clippy_lints/src/transmute/crosspointer_transmute.rs          |  2 +-
 clippy_lints/src/transmute/transmute_float_to_int.rs          |  3 ++-
 clippy_lints/src/transmute/transmute_int_to_bool.rs           |  3 ++-
 clippy_lints/src/transmute/transmute_int_to_char.rs           |  3 ++-
 clippy_lints/src/transmute/transmute_int_to_float.rs          |  3 ++-
 clippy_lints/src/transmute/transmute_ptr_to_ptr.rs            |  3 ++-
 clippy_lints/src/transmute/transmute_ptr_to_ref.rs            |  3 ++-
 clippy_lints/src/transmute/transmute_ref_to_ref.rs            |  3 ++-
 .../src/transmute/transmutes_expressible_as_ptr_casts.rs      |  3 ++-
 clippy_lints/src/transmute/unsound_collection_transmute.rs    |  3 ++-
 clippy_lints/src/transmute/useless_transmute.rs               |  3 ++-
 clippy_lints/src/transmute/wrong_transmute.rs                 |  2 +-
 clippy_lints/src/transmuting_null.rs                          |  3 ++-
 clippy_lints/src/try_err.rs                                   |  3 ++-
 clippy_lints/src/types/borrowed_box.rs                        |  3 ++-
 clippy_lints/src/types/box_vec.rs                             |  3 ++-
 clippy_lints/src/types/linked_list.rs                         |  3 ++-
 clippy_lints/src/types/mod.rs                                 |  6 ++----
 clippy_lints/src/types/option_option.rs                       |  3 ++-
 clippy_lints/src/types/rc_buffer.rs                           |  3 ++-
 clippy_lints/src/types/redundant_allocation.rs                |  3 ++-
 clippy_lints/src/types/vec_box.rs                             |  3 ++-
 clippy_lints/src/undropped_manually_drops.rs                  |  3 ++-
 clippy_lints/src/unicode.rs                                   |  3 ++-
 clippy_lints/src/unit_return_expecting_ord.rs                 |  3 ++-
 clippy_lints/src/unnamed_address.rs                           |  3 ++-
 clippy_lints/src/unnecessary_sort_by.rs                       |  6 +++---
 clippy_lints/src/unnecessary_wraps.rs                         |  5 ++---
 clippy_lints/src/unnested_or_patterns.rs                      |  3 ++-
 clippy_lints/src/unsafe_removed_from_name.rs                  |  2 +-
 clippy_lints/src/unused_io_amount.rs                          |  3 ++-
 clippy_lints/src/unused_self.rs                               |  2 +-
 clippy_lints/src/unused_unit.rs                               |  2 +-
 clippy_lints/src/unwrap.rs                                    |  3 ++-
 clippy_lints/src/unwrap_in_result.rs                          |  3 ++-
 clippy_lints/src/upper_case_acronyms.rs                       |  4 ++--
 clippy_lints/src/use_self.rs                                  |  4 ++--
 clippy_lints/src/useless_conversion.rs                        |  5 ++---
 clippy_lints/src/utils/internal_lints.rs                      |  7 +++----
 clippy_lints/src/vec.rs                                       |  3 ++-
 clippy_lints/src/vec_init_then_push.rs                        |  3 ++-
 clippy_lints/src/vec_resize_to_zero.rs                        |  2 +-
 clippy_lints/src/verbose_file_reads.rs                        |  3 ++-
 clippy_lints/src/wildcard_dependencies.rs                     |  3 ++-
 clippy_lints/src/wildcard_imports.rs                          |  3 ++-
 clippy_lints/src/write.rs                                     |  2 +-
 clippy_lints/src/zero_div_zero.rs                             |  2 +-
 clippy_lints/src/zero_sized_map_values.rs                     |  3 ++-
 clippy_utils/src/lib.rs                                       |  3 +--
 307 files changed, 530 insertions(+), 368 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/approx_const.rs b/clippy_lints/src/approx_const.rs
index 1d511a86c90..3d04abe094d 100644
--- a/clippy_lints/src/approx_const.rs
+++ b/clippy_lints/src/approx_const.rs
@@ -1,4 +1,4 @@
-use crate::utils::span_lint;
+use clippy_utils::diagnostics::span_lint;
 use rustc_ast::ast::{FloatTy, LitFloatType, LitKind};
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/arithmetic.rs b/clippy_lints/src/arithmetic.rs
index 61fdf9495b9..c560f545d6a 100644
--- a/clippy_lints/src/arithmetic.rs
+++ b/clippy_lints/src/arithmetic.rs
@@ -1,5 +1,5 @@
 use crate::consts::constant_simple;
-use crate::utils::span_lint;
+use clippy_utils::diagnostics::span_lint;
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
diff --git a/clippy_lints/src/as_conversions.rs b/clippy_lints/src/as_conversions.rs
index c30d65bbc57..4b31e16094e 100644
--- a/clippy_lints/src/as_conversions.rs
+++ b/clippy_lints/src/as_conversions.rs
@@ -1,10 +1,9 @@
+use clippy_utils::diagnostics::span_lint_and_help;
 use rustc_ast::ast::{Expr, ExprKind};
 use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
-use crate::utils::span_lint_and_help;
-
 declare_clippy_lint! {
     /// **What it does:** Checks for usage of `as` conversions.
     ///
diff --git a/clippy_lints/src/asm_syntax.rs b/clippy_lints/src/asm_syntax.rs
index ef1f1a14afc..b970c71b753 100644
--- a/clippy_lints/src/asm_syntax.rs
+++ b/clippy_lints/src/asm_syntax.rs
@@ -1,6 +1,6 @@
 use std::fmt;
 
-use crate::utils::span_lint_and_help;
+use clippy_utils::diagnostics::span_lint_and_help;
 use rustc_ast::ast::{Expr, ExprKind, InlineAsmOptions};
 use rustc_lint::{EarlyContext, EarlyLintPass, Lint};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
diff --git a/clippy_lints/src/assertions_on_constants.rs b/clippy_lints/src/assertions_on_constants.rs
index 3b6f64e7769..bae4d4957a9 100644
--- a/clippy_lints/src/assertions_on_constants.rs
+++ b/clippy_lints/src/assertions_on_constants.rs
@@ -1,5 +1,6 @@
 use crate::consts::{constant, Constant};
-use crate::utils::{is_direct_expn_of, is_expn_of, match_panic_call, span_lint_and_help};
+use crate::utils::{is_direct_expn_of, is_expn_of, match_panic_call};
+use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::source::snippet_opt;
 use if_chain::if_chain;
 use rustc_hir::{Expr, ExprKind, UnOp};
diff --git a/clippy_lints/src/assign_ops.rs b/clippy_lints/src/assign_ops.rs
index 031827e7e89..8581e176e0c 100644
--- a/clippy_lints/src/assign_ops.rs
+++ b/clippy_lints/src/assign_ops.rs
@@ -1,5 +1,6 @@
-use crate::utils::{eq_expr_value, get_trait_def_id, span_lint_and_then, trait_ref_of_method};
+use crate::utils::{eq_expr_value, get_trait_def_id, trait_ref_of_method};
 use crate::utils::{higher, sugg};
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::implements_trait;
 use if_chain::if_chain;
diff --git a/clippy_lints/src/async_yields_async.rs b/clippy_lints/src/async_yields_async.rs
index a5ed6016874..e6c7c68f91a 100644
--- a/clippy_lints/src/async_yields_async.rs
+++ b/clippy_lints/src/async_yields_async.rs
@@ -1,4 +1,4 @@
-use crate::utils::span_lint_and_then;
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::implements_trait;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/atomic_ordering.rs b/clippy_lints/src/atomic_ordering.rs
index 703d8a6f62b..231e74e16c0 100644
--- a/clippy_lints/src/atomic_ordering.rs
+++ b/clippy_lints/src/atomic_ordering.rs
@@ -1,4 +1,5 @@
-use crate::utils::{match_def_path, span_lint_and_help};
+use crate::utils::match_def_path;
+use clippy_utils::diagnostics::span_lint_and_help;
 use if_chain::if_chain;
 use rustc_hir::def_id::DefId;
 use rustc_hir::{Expr, ExprKind};
diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs
index 04b0e71e4a3..6be6722375d 100644
--- a/clippy_lints/src/attrs.rs
+++ b/clippy_lints/src/attrs.rs
@@ -1,6 +1,7 @@
 //! checks for attributes
 
-use crate::utils::{match_panic_def_id, span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then};
+use crate::utils::match_panic_def_id;
+use clippy_utils::diagnostics::{span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::{first_line_of_span, is_present_in_source, snippet_opt, without_block_comments};
 use if_chain::if_chain;
 use rustc_ast::{AttrKind, AttrStyle, Attribute, Lit, LitKind, MetaItemKind, NestedMetaItem};
diff --git a/clippy_lints/src/await_holding_invalid.rs b/clippy_lints/src/await_holding_invalid.rs
index 14b6a156c62..3a3296c2c3d 100644
--- a/clippy_lints/src/await_holding_invalid.rs
+++ b/clippy_lints/src/await_holding_invalid.rs
@@ -1,4 +1,5 @@
-use crate::utils::{match_def_path, paths, span_lint_and_note};
+use crate::utils::{match_def_path, paths};
+use clippy_utils::diagnostics::span_lint_and_note;
 use rustc_hir::def_id::DefId;
 use rustc_hir::{AsyncGeneratorKind, Body, BodyId, GeneratorKind};
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/bit_mask.rs b/clippy_lints/src/bit_mask.rs
index a4ee54076ee..2b8400344f5 100644
--- a/clippy_lints/src/bit_mask.rs
+++ b/clippy_lints/src/bit_mask.rs
@@ -1,6 +1,6 @@
 use crate::consts::{constant, Constant};
 use crate::utils::sugg::Sugg;
-use crate::utils::{span_lint, span_lint_and_then};
+use clippy_utils::diagnostics::{span_lint, span_lint_and_then};
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/blacklisted_name.rs b/clippy_lints/src/blacklisted_name.rs
index 153870fb416..b26ef33e056 100644
--- a/clippy_lints/src/blacklisted_name.rs
+++ b/clippy_lints/src/blacklisted_name.rs
@@ -1,4 +1,4 @@
-use crate::utils::span_lint;
+use clippy_utils::diagnostics::span_lint;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_hir::{Pat, PatKind};
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/blocks_in_if_conditions.rs b/clippy_lints/src/blocks_in_if_conditions.rs
index f43f98d1dc0..343c4821c56 100644
--- a/clippy_lints/src/blocks_in_if_conditions.rs
+++ b/clippy_lints/src/blocks_in_if_conditions.rs
@@ -1,4 +1,5 @@
-use crate::utils::{differing_macro_contexts, get_parent_expr, span_lint, span_lint_and_sugg};
+use crate::utils::{differing_macro_contexts, get_parent_expr};
+use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg};
 use clippy_utils::source::snippet_block_with_applicability;
 use clippy_utils::ty::implements_trait;
 use if_chain::if_chain;
diff --git a/clippy_lints/src/booleans.rs b/clippy_lints/src/booleans.rs
index 12a07c60438..1303613b8c4 100644
--- a/clippy_lints/src/booleans.rs
+++ b/clippy_lints/src/booleans.rs
@@ -1,4 +1,5 @@
-use crate::utils::{eq_expr_value, get_trait_def_id, in_macro, paths, span_lint_and_sugg, span_lint_and_then};
+use crate::utils::{eq_expr_value, get_trait_def_id, in_macro, paths};
+use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::{implements_trait, is_type_diagnostic_item};
 use if_chain::if_chain;
diff --git a/clippy_lints/src/bytecount.rs b/clippy_lints/src/bytecount.rs
index d02861b1b1e..c1ca787c1e5 100644
--- a/clippy_lints/src/bytecount.rs
+++ b/clippy_lints/src/bytecount.rs
@@ -1,4 +1,5 @@
-use crate::utils::{contains_name, get_pat_name, paths, single_segment_path, span_lint_and_sugg};
+use crate::utils::{contains_name, get_pat_name, paths, single_segment_path};
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::match_type;
 use if_chain::if_chain;
diff --git a/clippy_lints/src/cargo_common_metadata.rs b/clippy_lints/src/cargo_common_metadata.rs
index cc2869ab495..f0ef482164a 100644
--- a/clippy_lints/src/cargo_common_metadata.rs
+++ b/clippy_lints/src/cargo_common_metadata.rs
@@ -2,7 +2,8 @@
 
 use std::path::PathBuf;
 
-use crate::utils::{run_lints, span_lint};
+use crate::utils::run_lints;
+use clippy_utils::diagnostics::span_lint;
 use rustc_hir::{hir_id::CRATE_HIR_ID, Crate};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
diff --git a/clippy_lints/src/case_sensitive_file_extension_comparisons.rs b/clippy_lints/src/case_sensitive_file_extension_comparisons.rs
index b15fe65352a..c9ef379be56 100644
--- a/clippy_lints/src/case_sensitive_file_extension_comparisons.rs
+++ b/clippy_lints/src/case_sensitive_file_extension_comparisons.rs
@@ -1,4 +1,4 @@
-use crate::utils::span_lint_and_help;
+use clippy_utils::diagnostics::span_lint_and_help;
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
 use rustc_hir::{Expr, ExprKind, PathSegment};
diff --git a/clippy_lints/src/casts/cast_lossless.rs b/clippy_lints/src/casts/cast_lossless.rs
index 62ba19c0e16..4b660188d82 100644
--- a/clippy_lints/src/casts/cast_lossless.rs
+++ b/clippy_lints/src/casts/cast_lossless.rs
@@ -1,3 +1,4 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::is_isize_or_usize;
 use rustc_errors::Applicability;
@@ -5,7 +6,7 @@ use rustc_hir::{Expr, ExprKind};
 use rustc_lint::LateContext;
 use rustc_middle::ty::{self, FloatTy, Ty};
 
-use crate::utils::{in_constant, span_lint_and_sugg};
+use crate::utils::in_constant;
 
 use super::{utils, CAST_LOSSLESS};
 
diff --git a/clippy_lints/src/casts/cast_possible_truncation.rs b/clippy_lints/src/casts/cast_possible_truncation.rs
index 522ef5348be..75d7c55b637 100644
--- a/clippy_lints/src/casts/cast_possible_truncation.rs
+++ b/clippy_lints/src/casts/cast_possible_truncation.rs
@@ -3,7 +3,7 @@ use rustc_hir::Expr;
 use rustc_lint::LateContext;
 use rustc_middle::ty::{self, FloatTy, Ty};
 
-use crate::utils::span_lint;
+use clippy_utils::diagnostics::span_lint;
 
 use super::{utils, CAST_POSSIBLE_TRUNCATION};
 
diff --git a/clippy_lints/src/casts/cast_possible_wrap.rs b/clippy_lints/src/casts/cast_possible_wrap.rs
index 931252415ad..2c5c1d7cb46 100644
--- a/clippy_lints/src/casts/cast_possible_wrap.rs
+++ b/clippy_lints/src/casts/cast_possible_wrap.rs
@@ -1,10 +1,9 @@
+use clippy_utils::diagnostics::span_lint;
 use clippy_utils::ty::is_isize_or_usize;
 use rustc_hir::Expr;
 use rustc_lint::LateContext;
 use rustc_middle::ty::Ty;
 
-use crate::utils::span_lint;
-
 use super::{utils, CAST_POSSIBLE_WRAP};
 
 pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_from: Ty<'_>, cast_to: Ty<'_>) {
diff --git a/clippy_lints/src/casts/cast_precision_loss.rs b/clippy_lints/src/casts/cast_precision_loss.rs
index b6905c21c78..63ac8fd2dd2 100644
--- a/clippy_lints/src/casts/cast_precision_loss.rs
+++ b/clippy_lints/src/casts/cast_precision_loss.rs
@@ -1,10 +1,9 @@
+use clippy_utils::diagnostics::span_lint;
 use clippy_utils::ty::is_isize_or_usize;
 use rustc_hir::Expr;
 use rustc_lint::LateContext;
 use rustc_middle::ty::{self, FloatTy, Ty};
 
-use crate::utils::span_lint;
-
 use super::{utils, CAST_PRECISION_LOSS};
 
 pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_from: Ty<'_>, cast_to: Ty<'_>) {
diff --git a/clippy_lints/src/casts/cast_ptr_alignment.rs b/clippy_lints/src/casts/cast_ptr_alignment.rs
index 87fb5557be0..6a45ec61c54 100644
--- a/clippy_lints/src/casts/cast_ptr_alignment.rs
+++ b/clippy_lints/src/casts/cast_ptr_alignment.rs
@@ -1,3 +1,4 @@
+use clippy_utils::diagnostics::span_lint;
 use rustc_hir::{Expr, ExprKind, GenericArg};
 use rustc_lint::LateContext;
 use rustc_middle::ty::{self, Ty};
@@ -6,7 +7,7 @@ use rustc_target::abi::LayoutOf;
 
 use if_chain::if_chain;
 
-use crate::utils::{is_hir_ty_cfg_dependant, span_lint};
+use crate::utils::is_hir_ty_cfg_dependant;
 
 use super::CAST_PTR_ALIGNMENT;
 
diff --git a/clippy_lints/src/casts/cast_ref_to_mut.rs b/clippy_lints/src/casts/cast_ref_to_mut.rs
index 3fdc1c6168b..d9bf1ea58b9 100644
--- a/clippy_lints/src/casts/cast_ref_to_mut.rs
+++ b/clippy_lints/src/casts/cast_ref_to_mut.rs
@@ -1,11 +1,9 @@
+use clippy_utils::diagnostics::span_lint;
+use if_chain::if_chain;
 use rustc_hir::{Expr, ExprKind, MutTy, Mutability, TyKind, UnOp};
 use rustc_lint::LateContext;
 use rustc_middle::ty;
 
-use if_chain::if_chain;
-
-use crate::utils::span_lint;
-
 use super::CAST_REF_TO_MUT;
 
 pub(super) fn check(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
diff --git a/clippy_lints/src/casts/cast_sign_loss.rs b/clippy_lints/src/casts/cast_sign_loss.rs
index 9656fbebd77..2965a840a82 100644
--- a/clippy_lints/src/casts/cast_sign_loss.rs
+++ b/clippy_lints/src/casts/cast_sign_loss.rs
@@ -5,7 +5,8 @@ use rustc_middle::ty::{self, Ty};
 use if_chain::if_chain;
 
 use crate::consts::{constant, Constant};
-use crate::utils::{method_chain_args, sext, span_lint};
+use crate::utils::{method_chain_args, sext};
+use clippy_utils::diagnostics::span_lint;
 
 use super::CAST_SIGN_LOSS;
 
diff --git a/clippy_lints/src/casts/char_lit_as_u8.rs b/clippy_lints/src/casts/char_lit_as_u8.rs
index 75aa559359c..099a0de881f 100644
--- a/clippy_lints/src/casts/char_lit_as_u8.rs
+++ b/clippy_lints/src/casts/char_lit_as_u8.rs
@@ -1,3 +1,4 @@
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet_with_applicability;
 use if_chain::if_chain;
 use rustc_ast::LitKind;
@@ -6,8 +7,6 @@ use rustc_hir::{Expr, ExprKind};
 use rustc_lint::LateContext;
 use rustc_middle::ty::{self, UintTy};
 
-use crate::utils::span_lint_and_then;
-
 use super::CHAR_LIT_AS_U8;
 
 pub(super) fn check(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
diff --git a/clippy_lints/src/casts/fn_to_numeric_cast.rs b/clippy_lints/src/casts/fn_to_numeric_cast.rs
index 723bfa5befe..35350d8a25b 100644
--- a/clippy_lints/src/casts/fn_to_numeric_cast.rs
+++ b/clippy_lints/src/casts/fn_to_numeric_cast.rs
@@ -1,4 +1,4 @@
-use crate::utils::span_lint_and_sugg;
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use rustc_errors::Applicability;
 use rustc_hir::Expr;
diff --git a/clippy_lints/src/casts/fn_to_numeric_cast_with_truncation.rs b/clippy_lints/src/casts/fn_to_numeric_cast_with_truncation.rs
index a3108f8a983..6287f479b5b 100644
--- a/clippy_lints/src/casts/fn_to_numeric_cast_with_truncation.rs
+++ b/clippy_lints/src/casts/fn_to_numeric_cast_with_truncation.rs
@@ -1,4 +1,4 @@
-use crate::utils::span_lint_and_sugg;
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use rustc_errors::Applicability;
 use rustc_hir::Expr;
diff --git a/clippy_lints/src/casts/ptr_as_ptr.rs b/clippy_lints/src/casts/ptr_as_ptr.rs
index abfbadf3642..2c25f865cb8 100644
--- a/clippy_lints/src/casts/ptr_as_ptr.rs
+++ b/clippy_lints/src/casts/ptr_as_ptr.rs
@@ -8,8 +8,9 @@ use rustc_semver::RustcVersion;
 
 use if_chain::if_chain;
 
+use crate::utils::meets_msrv;
 use crate::utils::sugg::Sugg;
-use crate::utils::{meets_msrv, span_lint_and_sugg};
+use clippy_utils::diagnostics::span_lint_and_sugg;
 
 use super::PTR_AS_PTR;
 
diff --git a/clippy_lints/src/casts/unnecessary_cast.rs b/clippy_lints/src/casts/unnecessary_cast.rs
index eb0ee012e6c..a84e658024a 100644
--- a/clippy_lints/src/casts/unnecessary_cast.rs
+++ b/clippy_lints/src/casts/unnecessary_cast.rs
@@ -1,3 +1,4 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_opt;
 use if_chain::if_chain;
 use rustc_ast::{LitFloatType, LitIntType, LitKind};
@@ -7,7 +8,7 @@ use rustc_lint::{LateContext, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::{self, FloatTy, InferTy, Ty};
 
-use crate::utils::{numeric_literal::NumericLiteral, span_lint_and_sugg};
+use crate::utils::numeric_literal::NumericLiteral;
 
 use super::UNNECESSARY_CAST;
 
diff --git a/clippy_lints/src/checked_conversions.rs b/clippy_lints/src/checked_conversions.rs
index 4f3daa427e3..8b62e315e04 100644
--- a/clippy_lints/src/checked_conversions.rs
+++ b/clippy_lints/src/checked_conversions.rs
@@ -1,5 +1,6 @@
 //! lint on manually implemented checked conversions that could be transformed into `try_from`
 
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
@@ -10,7 +11,7 @@ use rustc_middle::lint::in_external_macro;
 use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 
-use crate::utils::{meets_msrv, span_lint_and_sugg, SpanlessEq};
+use crate::utils::{meets_msrv, SpanlessEq};
 
 const CHECKED_CONVERSIONS_MSRV: RustcVersion = RustcVersion::new(1, 34, 0);
 
diff --git a/clippy_lints/src/cognitive_complexity.rs b/clippy_lints/src/cognitive_complexity.rs
index 5b8ef01505b..8134f3af3ef 100644
--- a/clippy_lints/src/cognitive_complexity.rs
+++ b/clippy_lints/src/cognitive_complexity.rs
@@ -1,5 +1,6 @@
 //! calculate cognitive complexity and warn about overly complex functions
 
+use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_ast::ast::Attribute;
@@ -11,7 +12,7 @@ use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::Span;
 use rustc_span::{sym, BytePos};
 
-use crate::utils::{span_lint_and_help, LimitStack};
+use crate::utils::LimitStack;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for methods with high cognitive complexity.
diff --git a/clippy_lints/src/collapsible_if.rs b/clippy_lints/src/collapsible_if.rs
index c866f18ef3e..dbe70f90732 100644
--- a/clippy_lints/src/collapsible_if.rs
+++ b/clippy_lints/src/collapsible_if.rs
@@ -12,6 +12,7 @@
 //!
 //! This lint is **warn** by default
 
+use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::{snippet_block, snippet_block_with_applicability};
 use if_chain::if_chain;
 use rustc_ast::ast;
@@ -20,7 +21,6 @@ use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 use crate::utils::sugg::Sugg;
-use crate::utils::{span_lint_and_sugg, span_lint_and_then};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for nested `if` statements which can be collapsed
diff --git a/clippy_lints/src/collapsible_match.rs b/clippy_lints/src/collapsible_match.rs
index 3c45525684b..5ff2518bd94 100644
--- a/clippy_lints/src/collapsible_match.rs
+++ b/clippy_lints/src/collapsible_match.rs
@@ -1,5 +1,6 @@
 use crate::utils::visitors::LocalUsedVisitor;
-use crate::utils::{path_to_local, span_lint_and_then, SpanlessEq};
+use crate::utils::{path_to_local, SpanlessEq};
+use clippy_utils::diagnostics::span_lint_and_then;
 use if_chain::if_chain;
 use rustc_hir::def::{CtorKind, CtorOf, DefKind, Res};
 use rustc_hir::{Arm, Expr, ExprKind, Guard, HirId, Pat, PatKind, QPath, StmtKind, UnOp};
diff --git a/clippy_lints/src/comparison_chain.rs b/clippy_lints/src/comparison_chain.rs
index 9843033a2e0..5411905791c 100644
--- a/clippy_lints/src/comparison_chain.rs
+++ b/clippy_lints/src/comparison_chain.rs
@@ -1,4 +1,5 @@
-use crate::utils::{get_trait_def_id, if_sequence, parent_node_is_if_expr, paths, span_lint_and_help, SpanlessEq};
+use crate::utils::{get_trait_def_id, if_sequence, parent_node_is_if_expr, paths, SpanlessEq};
+use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::ty::implements_trait;
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/copies.rs b/clippy_lints/src/copies.rs
index 944aaafb46d..f86f0da6d6f 100644
--- a/clippy_lints/src/copies.rs
+++ b/clippy_lints/src/copies.rs
@@ -1,5 +1,6 @@
 use crate::utils::{eq_expr_value, in_macro, search_same, SpanlessEq, SpanlessHash};
-use crate::utils::{get_parent_expr, if_sequence, span_lint_and_note};
+use crate::utils::{get_parent_expr, if_sequence};
+use clippy_utils::diagnostics::span_lint_and_note;
 use rustc_hir::{Block, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
diff --git a/clippy_lints/src/copy_iterator.rs b/clippy_lints/src/copy_iterator.rs
index 434d8958da5..35079c6bedc 100644
--- a/clippy_lints/src/copy_iterator.rs
+++ b/clippy_lints/src/copy_iterator.rs
@@ -1,4 +1,4 @@
-use crate::utils::span_lint_and_note;
+use clippy_utils::diagnostics::span_lint_and_note;
 use clippy_utils::ty::is_copy;
 use rustc_hir::{Impl, Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/create_dir.rs b/clippy_lints/src/create_dir.rs
index 0785e25b0a2..01ca2837a99 100644
--- a/clippy_lints/src/create_dir.rs
+++ b/clippy_lints/src/create_dir.rs
@@ -1,4 +1,5 @@
-use crate::utils::{match_def_path, paths, span_lint_and_sugg};
+use crate::utils::{match_def_path, paths};
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/dbg_macro.rs b/clippy_lints/src/dbg_macro.rs
index 3171a945eb0..286cc7e223e 100644
--- a/clippy_lints/src/dbg_macro.rs
+++ b/clippy_lints/src/dbg_macro.rs
@@ -1,4 +1,4 @@
-use crate::utils::{span_lint_and_help, span_lint_and_sugg};
+use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg};
 use clippy_utils::source::snippet_opt;
 use rustc_ast::ast;
 use rustc_ast::tokenstream::TokenStream;
diff --git a/clippy_lints/src/default.rs b/clippy_lints/src/default.rs
index 7d975b5a3d9..0b074c088d4 100644
--- a/clippy_lints/src/default.rs
+++ b/clippy_lints/src/default.rs
@@ -1,5 +1,5 @@
 use crate::utils::{any_parent_is_automatically_derived, contains_name, match_def_path, paths};
-use crate::utils::{span_lint_and_note, span_lint_and_sugg};
+use clippy_utils::diagnostics::{span_lint_and_note, span_lint_and_sugg};
 use clippy_utils::source::snippet_with_macro_callsite;
 use if_chain::if_chain;
 use rustc_data_structures::fx::FxHashSet;
diff --git a/clippy_lints/src/default_numeric_fallback.rs b/clippy_lints/src/default_numeric_fallback.rs
index e58dcb942c6..d136db9373c 100644
--- a/clippy_lints/src/default_numeric_fallback.rs
+++ b/clippy_lints/src/default_numeric_fallback.rs
@@ -1,3 +1,4 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet;
 use if_chain::if_chain;
 use rustc_ast::ast::{LitFloatType, LitIntType, LitKind};
@@ -13,8 +14,6 @@ use rustc_middle::{
 };
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
-use crate::utils::span_lint_and_sugg;
-
 declare_clippy_lint! {
     /// **What it does:** Checks for usage of unconstrained numeric literals which may cause default numeric fallback in type
     /// inference.
diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index e112338dfea..62ec2f8ce48 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -1,4 +1,5 @@
-use crate::utils::{get_parent_node, in_macro, is_allowed, span_lint_and_sugg};
+use crate::utils::{get_parent_node, in_macro, is_allowed};
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_context;
 use clippy_utils::ty::peel_mid_ty_refs;
 use rustc_ast::util::parser::PREC_PREFIX;
diff --git a/clippy_lints/src/derive.rs b/clippy_lints/src/derive.rs
index 460fe385272..a7f2106e357 100644
--- a/clippy_lints/src/derive.rs
+++ b/clippy_lints/src/derive.rs
@@ -1,8 +1,6 @@
 use crate::utils::paths;
-use crate::utils::{
-    get_trait_def_id, is_allowed, is_automatically_derived, match_def_path, span_lint_and_help, span_lint_and_note,
-    span_lint_and_then,
-};
+use crate::utils::{get_trait_def_id, is_allowed, is_automatically_derived, match_def_path};
+use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_note, span_lint_and_then};
 use clippy_utils::ty::is_copy;
 use if_chain::if_chain;
 use rustc_hir::def_id::DefId;
diff --git a/clippy_lints/src/disallowed_method.rs b/clippy_lints/src/disallowed_method.rs
index 56dc6d18a58..16023bc53b0 100644
--- a/clippy_lints/src/disallowed_method.rs
+++ b/clippy_lints/src/disallowed_method.rs
@@ -1,4 +1,5 @@
-use crate::utils::{fn_def_id, span_lint};
+use crate::utils::fn_def_id;
+use clippy_utils::diagnostics::span_lint;
 
 use rustc_data_structures::fx::FxHashSet;
 use rustc_hir::Expr;
diff --git a/clippy_lints/src/doc.rs b/clippy_lints/src/doc.rs
index 4f3c573691e..d9952325c4b 100644
--- a/clippy_lints/src/doc.rs
+++ b/clippy_lints/src/doc.rs
@@ -1,6 +1,5 @@
-use crate::utils::{
-    is_entrypoint_fn, is_expn_of, match_panic_def_id, method_chain_args, return_ty, span_lint, span_lint_and_note,
-};
+use crate::utils::{is_entrypoint_fn, is_expn_of, match_panic_def_id, method_chain_args, return_ty};
+use clippy_utils::diagnostics::{span_lint, span_lint_and_note};
 use clippy_utils::ty::{implements_trait, is_type_diagnostic_item};
 use if_chain::if_chain;
 use itertools::Itertools;
diff --git a/clippy_lints/src/double_comparison.rs b/clippy_lints/src/double_comparison.rs
index 3de027b2cc6..549720feb2d 100644
--- a/clippy_lints/src/double_comparison.rs
+++ b/clippy_lints/src/double_comparison.rs
@@ -1,5 +1,6 @@
 //! Lint on unnecessary double comparisons. Some examples:
 
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind};
@@ -7,7 +8,7 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
 
-use crate::utils::{eq_expr_value, span_lint_and_sugg};
+use crate::utils::eq_expr_value;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for double comparisons that could be simplified to a single expression.
diff --git a/clippy_lints/src/double_parens.rs b/clippy_lints/src/double_parens.rs
index abbcaf43f41..5afdcb3c09f 100644
--- a/clippy_lints/src/double_parens.rs
+++ b/clippy_lints/src/double_parens.rs
@@ -1,4 +1,4 @@
-use crate::utils::span_lint;
+use clippy_utils::diagnostics::span_lint;
 use rustc_ast::ast::{Expr, ExprKind};
 use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
diff --git a/clippy_lints/src/drop_forget_ref.rs b/clippy_lints/src/drop_forget_ref.rs
index dd145ba6867..fe86adcec45 100644
--- a/clippy_lints/src/drop_forget_ref.rs
+++ b/clippy_lints/src/drop_forget_ref.rs
@@ -1,4 +1,5 @@
-use crate::utils::{match_def_path, paths, span_lint_and_note};
+use crate::utils::{match_def_path, paths};
+use clippy_utils::diagnostics::span_lint_and_note;
 use clippy_utils::ty::is_copy;
 use if_chain::if_chain;
 use rustc_hir::{Expr, ExprKind};
diff --git a/clippy_lints/src/duration_subsec.rs b/clippy_lints/src/duration_subsec.rs
index 195143d720d..40c75f568ae 100644
--- a/clippy_lints/src/duration_subsec.rs
+++ b/clippy_lints/src/duration_subsec.rs
@@ -9,7 +9,7 @@ use rustc_span::source_map::Spanned;
 
 use crate::consts::{constant, Constant};
 use crate::utils::paths;
-use crate::utils::span_lint_and_sugg;
+use clippy_utils::diagnostics::span_lint_and_sugg;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for calculation of subsecond microseconds or milliseconds
diff --git a/clippy_lints/src/else_if_without_else.rs b/clippy_lints/src/else_if_without_else.rs
index 95123e6ff6f..26984df9539 100644
--- a/clippy_lints/src/else_if_without_else.rs
+++ b/clippy_lints/src/else_if_without_else.rs
@@ -1,12 +1,11 @@
 //! Lint on if expressions with an else if, but without a final else branch.
 
+use clippy_utils::diagnostics::span_lint_and_help;
 use rustc_ast::ast::{Expr, ExprKind};
 use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
-use crate::utils::span_lint_and_help;
-
 declare_clippy_lint! {
     /// **What it does:** Checks for usage of if expressions with an `else if` branch,
     /// but without a final `else` branch.
diff --git a/clippy_lints/src/empty_enum.rs b/clippy_lints/src/empty_enum.rs
index 077c3b75fb8..c92984a9834 100644
--- a/clippy_lints/src/empty_enum.rs
+++ b/clippy_lints/src/empty_enum.rs
@@ -1,6 +1,6 @@
 //! lint when there is an enum with no variants
 
-use crate::utils::span_lint_and_help;
+use clippy_utils::diagnostics::span_lint_and_help;
 use rustc_hir::{Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
diff --git a/clippy_lints/src/entry.rs b/clippy_lints/src/entry.rs
index 93723219594..cc774831491 100644
--- a/clippy_lints/src/entry.rs
+++ b/clippy_lints/src/entry.rs
@@ -1,6 +1,6 @@
-use crate::utils::span_lint_and_then;
 use crate::utils::SpanlessEq;
 use crate::utils::{get_item_name, paths};
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::{snippet, snippet_opt, snippet_with_applicability};
 use clippy_utils::ty::{is_type_diagnostic_item, match_type};
 use if_chain::if_chain;
diff --git a/clippy_lints/src/enum_clike.rs b/clippy_lints/src/enum_clike.rs
index aa235642ac3..7a98ae39d3a 100644
--- a/clippy_lints/src/enum_clike.rs
+++ b/clippy_lints/src/enum_clike.rs
@@ -2,7 +2,7 @@
 //! don't fit into an `i32`
 
 use crate::consts::{miri_to_const, Constant};
-use crate::utils::span_lint;
+use clippy_utils::diagnostics::span_lint;
 use rustc_hir::{Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::util::IntTypeExt;
diff --git a/clippy_lints/src/enum_variants.rs b/clippy_lints/src/enum_variants.rs
index 660131cf176..d2d8acb443b 100644
--- a/clippy_lints/src/enum_variants.rs
+++ b/clippy_lints/src/enum_variants.rs
@@ -1,7 +1,7 @@
 //! lint on enum variants that are prefixed or suffixed by the same characters
 
 use crate::utils::camel_case;
-use crate::utils::{span_lint, span_lint_and_help};
+use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
 use clippy_utils::source::is_present_in_source;
 use rustc_ast::ast::{EnumDef, Item, ItemKind, VisibilityKind};
 use rustc_lint::{EarlyContext, EarlyLintPass, Lint};
diff --git a/clippy_lints/src/eq_op.rs b/clippy_lints/src/eq_op.rs
index 0a5917c10ea..1b2f66fb628 100644
--- a/clippy_lints/src/eq_op.rs
+++ b/clippy_lints/src/eq_op.rs
@@ -1,7 +1,5 @@
-use crate::utils::{
-    ast_utils::is_useless_with_eq_exprs, eq_expr_value, higher, in_macro, is_expn_of, multispan_sugg, span_lint,
-    span_lint_and_then,
-};
+use crate::utils::{ast_utils::is_useless_with_eq_exprs, eq_expr_value, higher, in_macro, is_expn_of};
+use clippy_utils::diagnostics::{multispan_sugg, span_lint, span_lint_and_then};
 use clippy_utils::source::snippet;
 use clippy_utils::ty::{implements_trait, is_copy};
 use if_chain::if_chain;
diff --git a/clippy_lints/src/erasing_op.rs b/clippy_lints/src/erasing_op.rs
index dbd1ff514f0..59602616781 100644
--- a/clippy_lints/src/erasing_op.rs
+++ b/clippy_lints/src/erasing_op.rs
@@ -1,10 +1,10 @@
+use clippy_utils::diagnostics::span_lint;
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
 
 use crate::consts::{constant_simple, Constant};
-use crate::utils::span_lint;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for erasing operations, e.g., `x * 0`.
diff --git a/clippy_lints/src/escape.rs b/clippy_lints/src/escape.rs
index a7258eea0ad..06da14a9844 100644
--- a/clippy_lints/src/escape.rs
+++ b/clippy_lints/src/escape.rs
@@ -1,3 +1,4 @@
+use clippy_utils::diagnostics::span_lint;
 use clippy_utils::ty::contains_ty;
 use rustc_hir::intravisit;
 use rustc_hir::{self, AssocItemKind, Body, FnDecl, HirId, HirIdSet, Impl, ItemKind, Node};
@@ -11,8 +12,6 @@ use rustc_target::abi::LayoutOf;
 use rustc_target::spec::abi::Abi;
 use rustc_typeck::expr_use_visitor::{ConsumeMode, Delegate, ExprUseVisitor, PlaceBase, PlaceWithHirId};
 
-use crate::utils::span_lint;
-
 #[derive(Copy, Clone)]
 pub struct BoxedLocal {
     pub too_large_for_stack: u64,
diff --git a/clippy_lints/src/eta_reduction.rs b/clippy_lints/src/eta_reduction.rs
index e8d5b992b63..2557e9f2796 100644
--- a/clippy_lints/src/eta_reduction.rs
+++ b/clippy_lints/src/eta_reduction.rs
@@ -1,3 +1,4 @@
+use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::higher;
 use clippy_utils::higher::VecArgs;
 use clippy_utils::source::snippet_opt;
@@ -10,7 +11,7 @@ use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::{self, Ty};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
-use crate::utils::{is_adjusted, iter_input_pats, span_lint_and_sugg, span_lint_and_then};
+use crate::utils::{is_adjusted, iter_input_pats};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for closures which just call another function where
diff --git a/clippy_lints/src/eval_order_dependence.rs b/clippy_lints/src/eval_order_dependence.rs
index 83cee11c3a8..3711ba4a7ee 100644
--- a/clippy_lints/src/eval_order_dependence.rs
+++ b/clippy_lints/src/eval_order_dependence.rs
@@ -1,4 +1,5 @@
-use crate::utils::{get_parent_expr, path_to_local, path_to_local_id, span_lint, span_lint_and_note};
+use crate::utils::{get_parent_expr, path_to_local, path_to_local_id};
+use clippy_utils::diagnostics::{span_lint, span_lint_and_note};
 use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
 use rustc_hir::{BinOpKind, Block, Expr, ExprKind, Guard, HirId, Local, Node, Stmt, StmtKind};
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/excessive_bools.rs b/clippy_lints/src/excessive_bools.rs
index 6a85b57af07..683e0435351 100644
--- a/clippy_lints/src/excessive_bools.rs
+++ b/clippy_lints/src/excessive_bools.rs
@@ -1,4 +1,5 @@
-use crate::utils::{attr_by_name, in_macro, match_path_ast, span_lint_and_help};
+use crate::utils::{attr_by_name, in_macro, match_path_ast};
+use clippy_utils::diagnostics::span_lint_and_help;
 use rustc_ast::ast::{AssocItemKind, Extern, FnKind, FnSig, ImplKind, Item, ItemKind, TraitKind, Ty, TyKind};
 use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
diff --git a/clippy_lints/src/exhaustive_items.rs b/clippy_lints/src/exhaustive_items.rs
index 5e31072523d..60ad2e8ee14 100644
--- a/clippy_lints/src/exhaustive_items.rs
+++ b/clippy_lints/src/exhaustive_items.rs
@@ -1,14 +1,12 @@
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::indent_of;
 use if_chain::if_chain;
-
 use rustc_errors::Applicability;
 use rustc_hir::{Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::sym;
 
-use crate::utils::span_lint_and_then;
-
 declare_clippy_lint! {
     /// **What it does:** Warns on any exported `enum`s that are not tagged `#[non_exhaustive]`
     ///
diff --git a/clippy_lints/src/exit.rs b/clippy_lints/src/exit.rs
index 91585927000..adfb644b199 100644
--- a/clippy_lints/src/exit.rs
+++ b/clippy_lints/src/exit.rs
@@ -1,4 +1,5 @@
-use crate::utils::{is_entrypoint_fn, match_def_path, paths, span_lint};
+use crate::utils::{is_entrypoint_fn, match_def_path, paths};
+use clippy_utils::diagnostics::span_lint;
 use if_chain::if_chain;
 use rustc_hir::{Expr, ExprKind, Item, ItemKind, Node};
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/explicit_write.rs b/clippy_lints/src/explicit_write.rs
index f8038d06e50..0861cba4675 100644
--- a/clippy_lints/src/explicit_write.rs
+++ b/clippy_lints/src/explicit_write.rs
@@ -1,4 +1,5 @@
-use crate::utils::{is_expn_of, match_function_call, paths, span_lint, span_lint_and_sugg};
+use crate::utils::{is_expn_of, match_function_call, paths};
+use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg};
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/fallible_impl_from.rs b/clippy_lints/src/fallible_impl_from.rs
index cc4e570956b..5efe465a667 100644
--- a/clippy_lints/src/fallible_impl_from.rs
+++ b/clippy_lints/src/fallible_impl_from.rs
@@ -1,4 +1,5 @@
-use crate::utils::{is_expn_of, match_panic_def_id, method_chain_args, span_lint_and_then};
+use crate::utils::{is_expn_of, match_panic_def_id, method_chain_args};
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
 use rustc_hir as hir;
diff --git a/clippy_lints/src/float_equality_without_abs.rs b/clippy_lints/src/float_equality_without_abs.rs
index c1c08597ee6..b3593d328cc 100644
--- a/clippy_lints/src/float_equality_without_abs.rs
+++ b/clippy_lints/src/float_equality_without_abs.rs
@@ -1,4 +1,5 @@
-use crate::utils::{match_def_path, paths, span_lint_and_then, sugg};
+use crate::utils::{match_def_path, paths, sugg};
+use clippy_utils::diagnostics::span_lint_and_then;
 use if_chain::if_chain;
 use rustc_ast::util::parser::AssocOp;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/float_literal.rs b/clippy_lints/src/float_literal.rs
index 8e256f34684..6446fe62a64 100644
--- a/clippy_lints/src/float_literal.rs
+++ b/clippy_lints/src/float_literal.rs
@@ -1,4 +1,5 @@
-use crate::utils::{numeric_literal, span_lint_and_sugg};
+use crate::utils::numeric_literal;
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use if_chain::if_chain;
 use rustc_ast::ast::{self, LitFloatType, LitKind};
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/floating_point_arithmetic.rs b/clippy_lints/src/floating_point_arithmetic.rs
index 086a791520f..8b53384ecbd 100644
--- a/clippy_lints/src/floating_point_arithmetic.rs
+++ b/clippy_lints/src/floating_point_arithmetic.rs
@@ -2,7 +2,8 @@ use crate::consts::{
     constant, constant_simple, Constant,
     Constant::{Int, F32, F64},
 };
-use crate::utils::{eq_expr_value, get_parent_expr, numeric_literal, span_lint_and_sugg, sugg};
+use crate::utils::{eq_expr_value, get_parent_expr, numeric_literal, sugg};
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind, PathSegment, UnOp};
diff --git a/clippy_lints/src/format.rs b/clippy_lints/src/format.rs
index c0048bb2175..db27225707d 100644
--- a/clippy_lints/src/format.rs
+++ b/clippy_lints/src/format.rs
@@ -1,5 +1,6 @@
 use crate::utils::paths;
-use crate::utils::{is_expn_of, last_path_segment, match_def_path, match_function_call, span_lint_and_then};
+use crate::utils::{is_expn_of, last_path_segment, match_def_path, match_function_call};
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::{snippet, snippet_opt};
 use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
diff --git a/clippy_lints/src/formatting.rs b/clippy_lints/src/formatting.rs
index 590de04717a..4dadd2ba936 100644
--- a/clippy_lints/src/formatting.rs
+++ b/clippy_lints/src/formatting.rs
@@ -1,4 +1,5 @@
-use crate::utils::{differing_macro_contexts, span_lint_and_help, span_lint_and_note};
+use crate::utils::differing_macro_contexts;
+use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_note};
 use clippy_utils::source::snippet_opt;
 use if_chain::if_chain;
 use rustc_ast::ast::{BinOpKind, Block, Expr, ExprKind, StmtKind, UnOp};
diff --git a/clippy_lints/src/from_over_into.rs b/clippy_lints/src/from_over_into.rs
index b644bb07990..5eea4d14759 100644
--- a/clippy_lints/src/from_over_into.rs
+++ b/clippy_lints/src/from_over_into.rs
@@ -1,5 +1,6 @@
 use crate::utils::paths::INTO;
-use crate::utils::{match_def_path, meets_msrv, span_lint_and_help};
+use crate::utils::{match_def_path, meets_msrv};
+use clippy_utils::diagnostics::span_lint_and_help;
 use if_chain::if_chain;
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass, LintContext};
diff --git a/clippy_lints/src/from_str_radix_10.rs b/clippy_lints/src/from_str_radix_10.rs
index b92c8ccfb1b..b9a44f26381 100644
--- a/clippy_lints/src/from_str_radix_10.rs
+++ b/clippy_lints/src/from_str_radix_10.rs
@@ -1,3 +1,4 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
@@ -7,7 +8,6 @@ use rustc_middle::ty::Ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::symbol::sym;
 
-use crate::utils::span_lint_and_sugg;
 use crate::utils::sugg::Sugg;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/functions.rs b/clippy_lints/src/functions.rs
index 104c692dcec..37288d7a0b2 100644
--- a/clippy_lints/src/functions.rs
+++ b/clippy_lints/src/functions.rs
@@ -1,7 +1,8 @@
 use crate::utils::{
     attr_by_name, attrs::is_proc_macro, is_trait_impl_item, iter_input_pats, match_def_path, must_use_attr,
-    path_to_local, return_ty, span_lint, span_lint_and_help, span_lint_and_then, trait_ref_of_method,
+    path_to_local, return_ty, trait_ref_of_method,
 };
+use clippy_utils::diagnostics::{span_lint, span_lint_and_help, span_lint_and_then};
 use clippy_utils::source::{snippet, snippet_opt};
 use clippy_utils::ty::{is_must_use_ty, is_type_diagnostic_item, type_is_unsafe_function};
 use if_chain::if_chain;
diff --git a/clippy_lints/src/future_not_send.rs b/clippy_lints/src/future_not_send.rs
index 9e1a8864a3e..36960e7f51b 100644
--- a/clippy_lints/src/future_not_send.rs
+++ b/clippy_lints/src/future_not_send.rs
@@ -1,4 +1,5 @@
 use crate::utils;
+use clippy_utils::diagnostics::span_lint_and_then;
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::{Body, FnDecl, HirId};
 use rustc_infer::infer::TyCtxtInferExt;
@@ -84,7 +85,7 @@ impl<'tcx> LateLintPass<'tcx> for FutureNotSend {
                     fulfillment_cx.select_all_or_error(&infcx)
                 });
                 if let Err(send_errors) = send_result {
-                    utils::span_lint_and_then(
+                    span_lint_and_then(
                         cx,
                         FUTURE_NOT_SEND,
                         span,
diff --git a/clippy_lints/src/get_last_with_len.rs b/clippy_lints/src/get_last_with_len.rs
index 875cd33bc8f..6f14ede0ecb 100644
--- a/clippy_lints/src/get_last_with_len.rs
+++ b/clippy_lints/src/get_last_with_len.rs
@@ -1,6 +1,7 @@
 //! lint on using `x.get(x.len() - 1)` instead of `x.last()`
 
-use crate::utils::{span_lint_and_sugg, SpanlessEq};
+use crate::utils::SpanlessEq;
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
diff --git a/clippy_lints/src/identity_op.rs b/clippy_lints/src/identity_op.rs
index fc93864c74a..385ea020328 100644
--- a/clippy_lints/src/identity_op.rs
+++ b/clippy_lints/src/identity_op.rs
@@ -7,7 +7,8 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
 
 use crate::consts::{constant_simple, Constant};
-use crate::utils::{clip, span_lint, unsext};
+use crate::utils::{clip, unsext};
+use clippy_utils::diagnostics::span_lint;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for identity operations, e.g., `x + 0`.
diff --git a/clippy_lints/src/if_let_mutex.rs b/clippy_lints/src/if_let_mutex.rs
index f53d1b1cf3b..c2ec8b3ffd1 100644
--- a/clippy_lints/src/if_let_mutex.rs
+++ b/clippy_lints/src/if_let_mutex.rs
@@ -1,4 +1,5 @@
-use crate::utils::{span_lint_and_help, SpanlessEq};
+use crate::utils::SpanlessEq;
+use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
 use rustc_hir::intravisit::{self as visit, NestedVisitorMap, Visitor};
diff --git a/clippy_lints/src/if_let_some_result.rs b/clippy_lints/src/if_let_some_result.rs
index 9f7ca95a8f3..59094d1147a 100644
--- a/clippy_lints/src/if_let_some_result.rs
+++ b/clippy_lints/src/if_let_some_result.rs
@@ -1,4 +1,5 @@
-use crate::utils::{method_chain_args, span_lint_and_sugg};
+use crate::utils::method_chain_args;
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
diff --git a/clippy_lints/src/if_not_else.rs b/clippy_lints/src/if_not_else.rs
index b86d2e76656..c56f67df061 100644
--- a/clippy_lints/src/if_not_else.rs
+++ b/clippy_lints/src/if_not_else.rs
@@ -1,13 +1,12 @@
 //! lint on if branches that could be swapped so no `!` operation is necessary
 //! on the condition
 
+use clippy_utils::diagnostics::span_lint_and_help;
 use rustc_ast::ast::{BinOpKind, Expr, ExprKind, UnOp};
 use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
-use crate::utils::span_lint_and_help;
-
 declare_clippy_lint! {
     /// **What it does:** Checks for usage of `!` or `!=` in an if condition with an
     /// else branch.
diff --git a/clippy_lints/src/if_then_some_else_none.rs b/clippy_lints/src/if_then_some_else_none.rs
index 7e1807786ee..c4e87300b7b 100644
--- a/clippy_lints/src/if_then_some_else_none.rs
+++ b/clippy_lints/src/if_then_some_else_none.rs
@@ -1,4 +1,5 @@
 use crate::utils;
+use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::source::snippet_with_macro_callsite;
 use if_chain::if_chain;
 use rustc_hir::{Expr, ExprKind};
@@ -100,7 +101,7 @@ impl LateLintPass<'_> for IfThenSomeElseNone {
                     cond_snip,
                     closure_body,
                 );
-                utils::span_lint_and_help(
+                span_lint_and_help(
                     cx,
                     IF_THEN_SOME_ELSE_NONE,
                     expr.span,
diff --git a/clippy_lints/src/implicit_return.rs b/clippy_lints/src/implicit_return.rs
index e86bd49251d..70ea9a92279 100644
--- a/clippy_lints/src/implicit_return.rs
+++ b/clippy_lints/src/implicit_return.rs
@@ -1,4 +1,5 @@
-use crate::utils::{match_panic_def_id, span_lint_and_then};
+use crate::utils::match_panic_def_id;
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet_opt;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/implicit_saturating_sub.rs b/clippy_lints/src/implicit_saturating_sub.rs
index 16e162badb5..3d2798f3fb4 100644
--- a/clippy_lints/src/implicit_saturating_sub.rs
+++ b/clippy_lints/src/implicit_saturating_sub.rs
@@ -1,4 +1,5 @@
-use crate::utils::{in_macro, match_qpath, span_lint_and_sugg, SpanlessEq};
+use crate::utils::{in_macro, match_qpath, SpanlessEq};
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/inconsistent_struct_constructor.rs b/clippy_lints/src/inconsistent_struct_constructor.rs
index 4762d5d40f3..b7986da7820 100644
--- a/clippy_lints/src/inconsistent_struct_constructor.rs
+++ b/clippy_lints/src/inconsistent_struct_constructor.rs
@@ -1,3 +1,4 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet;
 use if_chain::if_chain;
 use rustc_data_structures::fx::FxHashMap;
@@ -7,8 +8,6 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::symbol::Symbol;
 
-use crate::utils::span_lint_and_sugg;
-
 declare_clippy_lint! {
     /// **What it does:** Checks for struct constructors where all fields are shorthand and
     /// the order of the field init shorthand in the constructor is inconsistent
diff --git a/clippy_lints/src/indexing_slicing.rs b/clippy_lints/src/indexing_slicing.rs
index c919ec097a2..4c0f976f79a 100644
--- a/clippy_lints/src/indexing_slicing.rs
+++ b/clippy_lints/src/indexing_slicing.rs
@@ -1,7 +1,8 @@
 //! lint on indexing and slicing operations
 
 use crate::consts::{constant, Constant};
-use crate::utils::{higher, span_lint, span_lint_and_help};
+use crate::utils::higher;
+use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
 use rustc_ast::ast::RangeLimits;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/infinite_iter.rs b/clippy_lints/src/infinite_iter.rs
index 6bce205ec3a..addd95c6eae 100644
--- a/clippy_lints/src/infinite_iter.rs
+++ b/clippy_lints/src/infinite_iter.rs
@@ -1,9 +1,10 @@
+use clippy_utils::diagnostics::span_lint;
 use clippy_utils::ty::{implements_trait, match_type};
 use rustc_hir::{BorrowKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
-use crate::utils::{get_trait_def_id, higher, match_qpath, paths, span_lint};
+use crate::utils::{get_trait_def_id, higher, match_qpath, paths};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for iteration that is guaranteed to be infinite.
diff --git a/clippy_lints/src/inherent_impl.rs b/clippy_lints/src/inherent_impl.rs
index 005c461f105..f838ce190dc 100644
--- a/clippy_lints/src/inherent_impl.rs
+++ b/clippy_lints/src/inherent_impl.rs
@@ -1,6 +1,7 @@
 //! lint on inherent implementations
 
-use crate::utils::{in_macro, span_lint_and_then};
+use crate::utils::in_macro;
+use clippy_utils::diagnostics::span_lint_and_then;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_hir::{def_id, Crate, Impl, Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/inherent_to_string.rs b/clippy_lints/src/inherent_to_string.rs
index 9207413cd69..6b29feeb4ed 100644
--- a/clippy_lints/src/inherent_to_string.rs
+++ b/clippy_lints/src/inherent_to_string.rs
@@ -1,3 +1,4 @@
+use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::ty::{implements_trait, is_type_diagnostic_item};
 use if_chain::if_chain;
 use rustc_hir::{ImplItem, ImplItemKind};
@@ -5,7 +6,7 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::sym;
 
-use crate::utils::{get_trait_def_id, paths, return_ty, span_lint_and_help, trait_ref_of_method};
+use crate::utils::{get_trait_def_id, paths, return_ty, trait_ref_of_method};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for the definition of inherent methods with a signature of `to_string(&self) -> String`.
diff --git a/clippy_lints/src/inline_fn_without_body.rs b/clippy_lints/src/inline_fn_without_body.rs
index 00acbd6cc3f..87fe5123cf6 100644
--- a/clippy_lints/src/inline_fn_without_body.rs
+++ b/clippy_lints/src/inline_fn_without_body.rs
@@ -1,7 +1,7 @@
 //! checks for `#[inline]` on trait methods without bodies
 
-use crate::utils::span_lint_and_then;
 use crate::utils::sugg::DiagnosticBuilderExt;
+use clippy_utils::diagnostics::span_lint_and_then;
 use rustc_ast::ast::Attribute;
 use rustc_errors::Applicability;
 use rustc_hir::{TraitFn, TraitItem, TraitItemKind};
diff --git a/clippy_lints/src/int_plus_one.rs b/clippy_lints/src/int_plus_one.rs
index 9eae653dd67..c4a1222b51f 100644
--- a/clippy_lints/src/int_plus_one.rs
+++ b/clippy_lints/src/int_plus_one.rs
@@ -1,13 +1,12 @@
 //! lint on blocks unnecessarily using >= with a + 1 or - 1
 
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_opt;
 use rustc_ast::ast::{BinOpKind, Expr, ExprKind, Lit, LitKind};
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
-use crate::utils::span_lint_and_sugg;
-
 declare_clippy_lint! {
     /// **What it does:** Checks for usage of `x >= y + 1` or `x - 1 >= y` (and `<=`) in a block
     ///
diff --git a/clippy_lints/src/integer_division.rs b/clippy_lints/src/integer_division.rs
index 39b4605e72f..e5482f675e7 100644
--- a/clippy_lints/src/integer_division.rs
+++ b/clippy_lints/src/integer_division.rs
@@ -1,4 +1,4 @@
-use crate::utils::span_lint_and_help;
+use clippy_utils::diagnostics::span_lint_and_help;
 use if_chain::if_chain;
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/items_after_statements.rs b/clippy_lints/src/items_after_statements.rs
index 0927d218446..c69571f32a2 100644
--- a/clippy_lints/src/items_after_statements.rs
+++ b/clippy_lints/src/items_after_statements.rs
@@ -1,6 +1,6 @@
 //! lint when items are used after statements
 
-use crate::utils::span_lint;
+use clippy_utils::diagnostics::span_lint;
 use rustc_ast::ast::{Block, ItemKind, StmtKind};
 use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
diff --git a/clippy_lints/src/large_const_arrays.rs b/clippy_lints/src/large_const_arrays.rs
index a76595ed089..48dc5fefe99 100644
--- a/clippy_lints/src/large_const_arrays.rs
+++ b/clippy_lints/src/large_const_arrays.rs
@@ -1,5 +1,5 @@
 use crate::rustc_target::abi::LayoutOf;
-use crate::utils::span_lint_and_then;
+use clippy_utils::diagnostics::span_lint_and_then;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Item, ItemKind};
diff --git a/clippy_lints/src/large_enum_variant.rs b/clippy_lints/src/large_enum_variant.rs
index cbb5192bfd9..76584dc1822 100644
--- a/clippy_lints/src/large_enum_variant.rs
+++ b/clippy_lints/src/large_enum_variant.rs
@@ -1,6 +1,6 @@
 //! lint when there is a large size difference between variants on an enum
 
-use crate::utils::span_lint_and_then;
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet_opt;
 use rustc_errors::Applicability;
 use rustc_hir::{Item, ItemKind, VariantData};
diff --git a/clippy_lints/src/large_stack_arrays.rs b/clippy_lints/src/large_stack_arrays.rs
index ceae4243e63..c46b98022c6 100644
--- a/clippy_lints/src/large_stack_arrays.rs
+++ b/clippy_lints/src/large_stack_arrays.rs
@@ -1,3 +1,4 @@
+use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::source::snippet;
 use if_chain::if_chain;
 use rustc_hir::{Expr, ExprKind};
@@ -7,7 +8,6 @@ use rustc_middle::ty::{self, ConstKind};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 
 use crate::rustc_target::abi::LayoutOf;
-use crate::utils::span_lint_and_help;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for local arrays that may be too large.
diff --git a/clippy_lints/src/len_zero.rs b/clippy_lints/src/len_zero.rs
index e758a269fbe..a644a4113ae 100644
--- a/clippy_lints/src/len_zero.rs
+++ b/clippy_lints/src/len_zero.rs
@@ -1,4 +1,5 @@
-use crate::utils::{get_item_name, get_parent_as_impl, is_allowed, span_lint, span_lint_and_sugg, span_lint_and_then};
+use crate::utils::{get_item_name, get_parent_as_impl, is_allowed};
+use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::snippet_with_applicability;
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
diff --git a/clippy_lints/src/let_if_seq.rs b/clippy_lints/src/let_if_seq.rs
index 7059ba21207..4b7e02398fb 100644
--- a/clippy_lints/src/let_if_seq.rs
+++ b/clippy_lints/src/let_if_seq.rs
@@ -1,4 +1,5 @@
-use crate::utils::{path_to_local_id, span_lint_and_then, visitors::LocalUsedVisitor};
+use crate::utils::{path_to_local_id, visitors::LocalUsedVisitor};
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/let_underscore.rs b/clippy_lints/src/let_underscore.rs
index 2da7137b48b..eee2503b481 100644
--- a/clippy_lints/src/let_underscore.rs
+++ b/clippy_lints/src/let_underscore.rs
@@ -1,3 +1,4 @@
+use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::ty::{is_must_use_ty, match_type};
 use if_chain::if_chain;
 use rustc_hir::{Local, PatKind};
@@ -6,7 +7,7 @@ use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::subst::GenericArgKind;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
-use crate::utils::{is_must_use_func_call, paths, span_lint_and_help};
+use crate::utils::{is_must_use_func_call, paths};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for `let _ = <expr>`
diff --git a/clippy_lints/src/lifetimes.rs b/clippy_lints/src/lifetimes.rs
index 33ff01a30e8..0848aaed815 100644
--- a/clippy_lints/src/lifetimes.rs
+++ b/clippy_lints/src/lifetimes.rs
@@ -1,4 +1,5 @@
-use crate::utils::{in_macro, span_lint, trait_ref_of_method};
+use crate::utils::{in_macro, trait_ref_of_method};
+use clippy_utils::diagnostics::span_lint;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_hir::intravisit::{
     walk_fn_decl, walk_generic_param, walk_generics, walk_item, walk_param_bound, walk_poly_trait_ref, walk_ty,
diff --git a/clippy_lints/src/literal_representation.rs b/clippy_lints/src/literal_representation.rs
index 8bc7bf37ef1..dd303bc0a01 100644
--- a/clippy_lints/src/literal_representation.rs
+++ b/clippy_lints/src/literal_representation.rs
@@ -4,8 +4,8 @@
 use crate::utils::{
     in_macro,
     numeric_literal::{NumericLiteral, Radix},
-    span_lint_and_sugg,
 };
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_opt;
 use if_chain::if_chain;
 use rustc_ast::ast::{Expr, ExprKind, Lit, LitKind};
diff --git a/clippy_lints/src/loops/empty_loop.rs b/clippy_lints/src/loops/empty_loop.rs
index 43e85538f28..d52a061fc8f 100644
--- a/clippy_lints/src/loops/empty_loop.rs
+++ b/clippy_lints/src/loops/empty_loop.rs
@@ -1,5 +1,6 @@
 use super::EMPTY_LOOP;
-use crate::utils::{is_in_panic_handler, is_no_std_crate, span_lint_and_help};
+use crate::utils::{is_in_panic_handler, is_no_std_crate};
+use clippy_utils::diagnostics::span_lint_and_help;
 
 use rustc_hir::{Block, Expr};
 use rustc_lint::LateContext;
diff --git a/clippy_lints/src/loops/explicit_counter_loop.rs b/clippy_lints/src/loops/explicit_counter_loop.rs
index 1f6d48fe915..87ce4e4c20c 100644
--- a/clippy_lints/src/loops/explicit_counter_loop.rs
+++ b/clippy_lints/src/loops/explicit_counter_loop.rs
@@ -1,7 +1,8 @@
 use super::{
     get_span_of_entire_for_loop, make_iterator_snippet, IncrementVisitor, InitializeVisitor, EXPLICIT_COUNTER_LOOP,
 };
-use crate::utils::{get_enclosing_block, is_integer_const, span_lint_and_sugg};
+use crate::utils::{get_enclosing_block, is_integer_const};
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/loops/explicit_into_iter_loop.rs b/clippy_lints/src/loops/explicit_into_iter_loop.rs
index e5b3dc7aad7..4871a031187 100644
--- a/clippy_lints/src/loops/explicit_into_iter_loop.rs
+++ b/clippy_lints/src/loops/explicit_into_iter_loop.rs
@@ -1,5 +1,5 @@
 use super::EXPLICIT_INTO_ITER_LOOP;
-use crate::utils::span_lint_and_sugg;
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use rustc_errors::Applicability;
 use rustc_hir::Expr;
diff --git a/clippy_lints/src/loops/explicit_iter_loop.rs b/clippy_lints/src/loops/explicit_iter_loop.rs
index d2000d80ac1..259e95e5ef4 100644
--- a/clippy_lints/src/loops/explicit_iter_loop.rs
+++ b/clippy_lints/src/loops/explicit_iter_loop.rs
@@ -1,5 +1,6 @@
 use super::EXPLICIT_ITER_LOOP;
-use crate::utils::{match_trait_method, paths, span_lint_and_sugg};
+use crate::utils::{match_trait_method, paths};
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::{is_type_diagnostic_item, match_type};
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/loops/for_kv_map.rs b/clippy_lints/src/loops/for_kv_map.rs
index 19a68dd78d1..bf037f392e0 100644
--- a/clippy_lints/src/loops/for_kv_map.rs
+++ b/clippy_lints/src/loops/for_kv_map.rs
@@ -1,6 +1,7 @@
 use super::FOR_KV_MAP;
 use crate::utils::visitors::LocalUsedVisitor;
-use crate::utils::{multispan_sugg, paths, span_lint_and_then, sugg};
+use crate::utils::{paths, sugg};
+use clippy_utils::diagnostics::{multispan_sugg, span_lint_and_then};
 use clippy_utils::source::snippet;
 use clippy_utils::ty::{is_type_diagnostic_item, match_type};
 use rustc_hir::{BorrowKind, Expr, ExprKind, Mutability, Pat, PatKind};
diff --git a/clippy_lints/src/loops/for_loops_over_fallibles.rs b/clippy_lints/src/loops/for_loops_over_fallibles.rs
index 5140448592d..d49b0517dcf 100644
--- a/clippy_lints/src/loops/for_loops_over_fallibles.rs
+++ b/clippy_lints/src/loops/for_loops_over_fallibles.rs
@@ -1,8 +1,7 @@
+use super::FOR_LOOPS_OVER_FALLIBLES;
+use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::is_type_diagnostic_item;
-
-use super::FOR_LOOPS_OVER_FALLIBLES;
-use crate::utils::span_lint_and_help;
 use rustc_hir::{Expr, Pat};
 use rustc_lint::LateContext;
 use rustc_span::symbol::sym;
diff --git a/clippy_lints/src/loops/iter_next_loop.rs b/clippy_lints/src/loops/iter_next_loop.rs
index d6b40fa9fa8..27a03562800 100644
--- a/clippy_lints/src/loops/iter_next_loop.rs
+++ b/clippy_lints/src/loops/iter_next_loop.rs
@@ -1,9 +1,10 @@
 use super::ITER_NEXT_LOOP;
+use clippy_utils::diagnostics::span_lint;
 use rustc_hir::Expr;
 use rustc_lint::LateContext;
 use rustc_span::sym;
 
-use crate::utils::{is_trait_method, span_lint};
+use crate::utils::is_trait_method;
 
 pub(super) fn check(cx: &LateContext<'_>, arg: &Expr<'_>, expr: &Expr<'_>) -> bool {
     if is_trait_method(cx, arg, sym::Iterator) {
diff --git a/clippy_lints/src/loops/manual_flatten.rs b/clippy_lints/src/loops/manual_flatten.rs
index 3d3ae6f3152..43580d6071a 100644
--- a/clippy_lints/src/loops/manual_flatten.rs
+++ b/clippy_lints/src/loops/manual_flatten.rs
@@ -1,6 +1,7 @@
 use super::utils::make_iterator_snippet;
 use super::MANUAL_FLATTEN;
-use crate::utils::{is_ok_ctor, is_some_ctor, path_to_local_id, span_lint_and_then};
+use crate::utils::{is_ok_ctor, is_some_ctor, path_to_local_id};
+use clippy_utils::diagnostics::span_lint_and_then;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, MatchSource, Pat, PatKind, QPath, StmtKind};
diff --git a/clippy_lints/src/loops/manual_memcpy.rs b/clippy_lints/src/loops/manual_memcpy.rs
index c9c25641160..ff68d136999 100644
--- a/clippy_lints/src/loops/manual_memcpy.rs
+++ b/clippy_lints/src/loops/manual_memcpy.rs
@@ -1,6 +1,7 @@
 use super::{get_span_of_entire_for_loop, IncrementVisitor, InitializeVisitor, MANUAL_MEMCPY};
 use crate::utils::sugg::Sugg;
-use crate::utils::{get_enclosing_block, higher, path_to_local, span_lint_and_sugg, sugg};
+use crate::utils::{get_enclosing_block, higher, path_to_local, sugg};
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
diff --git a/clippy_lints/src/loops/mut_range_bound.rs b/clippy_lints/src/loops/mut_range_bound.rs
index 3ae592950f1..175aee53a9a 100644
--- a/clippy_lints/src/loops/mut_range_bound.rs
+++ b/clippy_lints/src/loops/mut_range_bound.rs
@@ -1,5 +1,6 @@
 use super::MUT_RANGE_BOUND;
-use crate::utils::{higher, path_to_local, span_lint};
+use crate::utils::{higher, path_to_local};
+use clippy_utils::diagnostics::span_lint;
 use if_chain::if_chain;
 use rustc_hir::{BindingAnnotation, Expr, HirId, Node, PatKind};
 use rustc_infer::infer::TyCtxtInferExt;
diff --git a/clippy_lints/src/loops/needless_collect.rs b/clippy_lints/src/loops/needless_collect.rs
index 59f7b23af75..a3b731eefa0 100644
--- a/clippy_lints/src/loops/needless_collect.rs
+++ b/clippy_lints/src/loops/needless_collect.rs
@@ -1,6 +1,7 @@
 use super::NEEDLESS_COLLECT;
 use crate::utils::sugg::Sugg;
-use crate::utils::{is_trait_method, path_to_local_id, paths, span_lint_and_sugg, span_lint_and_then};
+use crate::utils::{is_trait_method, path_to_local_id, paths};
+use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::snippet;
 use clippy_utils::ty::{is_type_diagnostic_item, match_type};
 use if_chain::if_chain;
diff --git a/clippy_lints/src/loops/needless_range_loop.rs b/clippy_lints/src/loops/needless_range_loop.rs
index 674cb34c37b..ca679d7ebe1 100644
--- a/clippy_lints/src/loops/needless_range_loop.rs
+++ b/clippy_lints/src/loops/needless_range_loop.rs
@@ -1,9 +1,9 @@
 use super::NEEDLESS_RANGE_LOOP;
 use crate::utils::visitors::LocalUsedVisitor;
 use crate::utils::{
-    contains_name, higher, is_integer_const, match_trait_method, multispan_sugg, path_to_local_id, paths,
-    span_lint_and_then, sugg, SpanlessEq,
+    contains_name, higher, is_integer_const, match_trait_method, path_to_local_id, paths, sugg, SpanlessEq,
 };
+use clippy_utils::diagnostics::{multispan_sugg, span_lint_and_then};
 use clippy_utils::source::snippet;
 use clippy_utils::ty::has_iter_method;
 use if_chain::if_chain;
diff --git a/clippy_lints/src/loops/never_loop.rs b/clippy_lints/src/loops/never_loop.rs
index 45e1001d755..82ec2635aeb 100644
--- a/clippy_lints/src/loops/never_loop.rs
+++ b/clippy_lints/src/loops/never_loop.rs
@@ -1,5 +1,5 @@
 use super::NEVER_LOOP;
-use crate::utils::span_lint;
+use clippy_utils::diagnostics::span_lint;
 use rustc_hir::{Block, Expr, ExprKind, HirId, InlineAsmOperand, Stmt, StmtKind};
 use rustc_lint::LateContext;
 use std::iter::{once, Iterator};
diff --git a/clippy_lints/src/loops/same_item_push.rs b/clippy_lints/src/loops/same_item_push.rs
index 255d6de4a36..849d7ec718c 100644
--- a/clippy_lints/src/loops/same_item_push.rs
+++ b/clippy_lints/src/loops/same_item_push.rs
@@ -1,5 +1,5 @@
 use super::SAME_ITEM_PUSH;
-use crate::utils::span_lint_and_help;
+use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::source::snippet_with_macro_callsite;
 use clippy_utils::ty::{implements_trait, is_type_diagnostic_item};
 use if_chain::if_chain;
diff --git a/clippy_lints/src/loops/single_element_loop.rs b/clippy_lints/src/loops/single_element_loop.rs
index 4f83191d919..172eb963ae3 100644
--- a/clippy_lints/src/loops/single_element_loop.rs
+++ b/clippy_lints/src/loops/single_element_loop.rs
@@ -1,5 +1,6 @@
 use super::{get_span_of_entire_for_loop, SINGLE_ELEMENT_LOOP};
-use crate::utils::{single_segment_path, span_lint_and_sugg};
+use crate::utils::single_segment_path;
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::{indent_of, snippet};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/loops/while_immutable_condition.rs b/clippy_lints/src/loops/while_immutable_condition.rs
index 05e0a722563..a037a06de81 100644
--- a/clippy_lints/src/loops/while_immutable_condition.rs
+++ b/clippy_lints/src/loops/while_immutable_condition.rs
@@ -1,7 +1,7 @@
 use super::WHILE_IMMUTABLE_CONDITION;
 use crate::consts::constant;
-use crate::utils::span_lint_and_then;
 use crate::utils::usage::mutated_variables;
+use clippy_utils::diagnostics::span_lint_and_then;
 use if_chain::if_chain;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_hir::def::{DefKind, Res};
diff --git a/clippy_lints/src/loops/while_let_loop.rs b/clippy_lints/src/loops/while_let_loop.rs
index dbd9126861f..ffe8c0c5494 100644
--- a/clippy_lints/src/loops/while_let_loop.rs
+++ b/clippy_lints/src/loops/while_let_loop.rs
@@ -1,5 +1,5 @@
 use super::WHILE_LET_LOOP;
-use crate::utils::span_lint_and_sugg;
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use rustc_errors::Applicability;
 use rustc_hir::{Block, Expr, ExprKind, MatchSource, StmtKind};
diff --git a/clippy_lints/src/loops/while_let_on_iterator.rs b/clippy_lints/src/loops/while_let_on_iterator.rs
index ccabe586c2b..29ad9e735cc 100644
--- a/clippy_lints/src/loops/while_let_on_iterator.rs
+++ b/clippy_lints/src/loops/while_let_on_iterator.rs
@@ -3,8 +3,8 @@ use super::WHILE_LET_ON_ITERATOR;
 use crate::utils::usage::mutated_variables;
 use crate::utils::{
     get_enclosing_block, is_refutable, is_trait_method, last_path_segment, path_to_local, path_to_local_id,
-    span_lint_and_sugg,
 };
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::implements_trait;
 use if_chain::if_chain;
diff --git a/clippy_lints/src/macro_use.rs b/clippy_lints/src/macro_use.rs
index 637f10f6609..92f95645734 100644
--- a/clippy_lints/src/macro_use.rs
+++ b/clippy_lints/src/macro_use.rs
@@ -1,4 +1,5 @@
-use crate::utils::{in_macro, span_lint_and_sugg};
+use crate::utils::in_macro;
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet;
 use hir::def::{DefKind, Res};
 use if_chain::if_chain;
diff --git a/clippy_lints/src/main_recursion.rs b/clippy_lints/src/main_recursion.rs
index 5db2968e42c..6c0308cbd92 100644
--- a/clippy_lints/src/main_recursion.rs
+++ b/clippy_lints/src/main_recursion.rs
@@ -1,10 +1,11 @@
+use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::source::snippet;
 use if_chain::if_chain;
 use rustc_hir::{Crate, Expr, ExprKind, QPath};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 
-use crate::utils::{is_entrypoint_fn, is_no_std_crate, span_lint_and_help};
+use crate::utils::{is_entrypoint_fn, is_no_std_crate};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for recursion using the entrypoint.
diff --git a/clippy_lints/src/manual_async_fn.rs b/clippy_lints/src/manual_async_fn.rs
index ebc493c0f7e..1db5cf56962 100644
--- a/clippy_lints/src/manual_async_fn.rs
+++ b/clippy_lints/src/manual_async_fn.rs
@@ -1,5 +1,6 @@
+use crate::utils::match_function_call;
 use crate::utils::paths::FUTURE_FROM_GENERATOR;
-use crate::utils::{match_function_call, span_lint_and_then};
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::{position_before_rarrow, snippet_block, snippet_opt};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/manual_map.rs b/clippy_lints/src/manual_map.rs
index 3896645ca7d..fd563bec769 100644
--- a/clippy_lints/src/manual_map.rs
+++ b/clippy_lints/src/manual_map.rs
@@ -1,8 +1,9 @@
 use crate::{
     map_unit_fn::OPTION_MAP_UNIT_FN,
     matches::MATCH_AS_REF,
-    utils::{is_allowed, match_def_path, match_var, paths, peel_hir_expr_refs, span_lint_and_sugg},
+    utils::{is_allowed, match_def_path, match_var, paths, peel_hir_expr_refs},
 };
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::{snippet_with_applicability, snippet_with_context};
 use clippy_utils::ty::{can_partially_move_ty, is_type_diagnostic_item, peel_mid_ty_refs_is_mutable};
 use rustc_ast::util::parser::PREC_POSTFIX;
diff --git a/clippy_lints/src/manual_non_exhaustive.rs b/clippy_lints/src/manual_non_exhaustive.rs
index 0b8c049b466..705c1ec1859 100644
--- a/clippy_lints/src/manual_non_exhaustive.rs
+++ b/clippy_lints/src/manual_non_exhaustive.rs
@@ -1,4 +1,5 @@
-use crate::utils::{meets_msrv, span_lint_and_then};
+use crate::utils::meets_msrv;
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet_opt;
 use if_chain::if_chain;
 use rustc_ast::ast::{Attribute, Item, ItemKind, StructField, Variant, VariantData, VisibilityKind};
diff --git a/clippy_lints/src/manual_ok_or.rs b/clippy_lints/src/manual_ok_or.rs
index f436eccc0dc..a1e5c752f83 100644
--- a/clippy_lints/src/manual_ok_or.rs
+++ b/clippy_lints/src/manual_ok_or.rs
@@ -1,4 +1,5 @@
-use crate::utils::{match_qpath, path_to_local_id, paths, span_lint_and_sugg};
+use crate::utils::{match_qpath, path_to_local_id, paths};
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::{indent_of, reindent_multiline, snippet_opt};
 use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
diff --git a/clippy_lints/src/manual_strip.rs b/clippy_lints/src/manual_strip.rs
index 3bfca8bea40..bc4e255b03d 100644
--- a/clippy_lints/src/manual_strip.rs
+++ b/clippy_lints/src/manual_strip.rs
@@ -1,6 +1,7 @@
 use crate::consts::{constant, Constant};
 use crate::utils::usage::mutated_variables;
-use crate::utils::{eq_expr_value, higher, match_def_path, meets_msrv, multispan_sugg, paths, span_lint_and_then};
+use crate::utils::{eq_expr_value, higher, match_def_path, meets_msrv, paths};
+use clippy_utils::diagnostics::{multispan_sugg, span_lint_and_then};
 use clippy_utils::source::snippet;
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
diff --git a/clippy_lints/src/manual_unwrap_or.rs b/clippy_lints/src/manual_unwrap_or.rs
index 7a4040539e3..0e030e0e261 100644
--- a/clippy_lints/src/manual_unwrap_or.rs
+++ b/clippy_lints/src/manual_unwrap_or.rs
@@ -1,6 +1,7 @@
 use crate::consts::constant_simple;
 use crate::utils;
 use crate::utils::{path_to_local_id, sugg};
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::{indent_of, reindent_multiline, snippet_opt};
 use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
@@ -112,7 +113,7 @@ fn lint_manual_unwrap_or<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
         then {
             let reindented_or_body =
                 reindent_multiline(or_body_snippet.into(), true, Some(indent));
-            utils::span_lint_and_sugg(
+            span_lint_and_sugg(
                 cx,
                 MANUAL_UNWRAP_OR, expr.span,
                 &format!("this pattern reimplements `{}`", case.unwrap_fn_path()),
diff --git a/clippy_lints/src/map_clone.rs b/clippy_lints/src/map_clone.rs
index e10d7647bcf..fd39052871b 100644
--- a/clippy_lints/src/map_clone.rs
+++ b/clippy_lints/src/map_clone.rs
@@ -1,5 +1,6 @@
 use crate::utils::is_trait_method;
-use crate::utils::{remove_blocks, span_lint_and_sugg};
+use crate::utils::remove_blocks;
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::{is_copy, is_type_diagnostic_item};
 use if_chain::if_chain;
diff --git a/clippy_lints/src/map_err_ignore.rs b/clippy_lints/src/map_err_ignore.rs
index 76fe8e776ea..a6a63961be5 100644
--- a/clippy_lints/src/map_err_ignore.rs
+++ b/clippy_lints/src/map_err_ignore.rs
@@ -1,5 +1,4 @@
-use crate::utils::span_lint_and_help;
-
+use clippy_utils::diagnostics::span_lint_and_help;
 use rustc_hir::{CaptureBy, Expr, ExprKind, PatKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
diff --git a/clippy_lints/src/map_identity.rs b/clippy_lints/src/map_identity.rs
index 79570367ed9..84ec23c4e2f 100644
--- a/clippy_lints/src/map_identity.rs
+++ b/clippy_lints/src/map_identity.rs
@@ -1,4 +1,5 @@
-use crate::utils::{is_adjusted, is_trait_method, match_path, match_var, paths, remove_blocks, span_lint_and_sugg};
+use crate::utils::{is_adjusted, is_trait_method, match_path, match_var, paths, remove_blocks};
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/map_unit_fn.rs b/clippy_lints/src/map_unit_fn.rs
index 24bcc808585..3bd4a965765 100644
--- a/clippy_lints/src/map_unit_fn.rs
+++ b/clippy_lints/src/map_unit_fn.rs
@@ -1,4 +1,5 @@
-use crate::utils::{iter_input_pats, method_chain_args, span_lint_and_then};
+use crate::utils::{iter_input_pats, method_chain_args};
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
diff --git a/clippy_lints/src/match_on_vec_items.rs b/clippy_lints/src/match_on_vec_items.rs
index 57dcd8709b8..ccaa5e98c83 100644
--- a/clippy_lints/src/match_on_vec_items.rs
+++ b/clippy_lints/src/match_on_vec_items.rs
@@ -1,4 +1,4 @@
-use crate::utils::span_lint_and_sugg;
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::{is_type_diagnostic_item, is_type_lang_item};
 use if_chain::if_chain;
diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index 4ae1ce977f4..1aa09b82822 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -2,11 +2,13 @@ use crate::consts::{constant, miri_to_const, Constant};
 use crate::utils::sugg::Sugg;
 use crate::utils::visitors::LocalUsedVisitor;
 use crate::utils::{
-    get_parent_expr, in_macro, is_allowed, is_expn_of, is_refutable, is_wild, match_qpath, meets_msrv, multispan_sugg,
-    path_to_local, path_to_local_id, peel_hir_pat_refs, peel_n_hir_expr_refs, remove_blocks, span_lint_and_help,
-    span_lint_and_note, span_lint_and_sugg, span_lint_and_then, strip_pat_refs,
+    get_parent_expr, in_macro, is_allowed, is_expn_of, is_refutable, is_wild, match_qpath, meets_msrv, path_to_local,
+    path_to_local_id, peel_hir_pat_refs, peel_n_hir_expr_refs, remove_blocks, strip_pat_refs,
 };
 use crate::utils::{paths, search_same, SpanlessEq, SpanlessHash};
+use clippy_utils::diagnostics::{
+    multispan_sugg, span_lint_and_help, span_lint_and_note, span_lint_and_sugg, span_lint_and_then,
+};
 use clippy_utils::source::{expr_block, indent_of, snippet, snippet_block, snippet_opt, snippet_with_applicability};
 use clippy_utils::ty::{implements_trait, is_type_diagnostic_item, match_type, peel_mid_ty_refs};
 use if_chain::if_chain;
@@ -1614,7 +1616,8 @@ where
 
 mod redundant_pattern_match {
     use super::REDUNDANT_PATTERN_MATCHING;
-    use crate::utils::{is_trait_method, match_qpath, paths, span_lint_and_then};
+    use crate::utils::{is_trait_method, match_qpath, paths};
+    use clippy_utils::diagnostics::span_lint_and_then;
     use clippy_utils::source::snippet;
     use if_chain::if_chain;
     use rustc_ast::ast::LitKind;
diff --git a/clippy_lints/src/mem_discriminant.rs b/clippy_lints/src/mem_discriminant.rs
index fbdc0cdb2d8..85353d4cdde 100644
--- a/clippy_lints/src/mem_discriminant.rs
+++ b/clippy_lints/src/mem_discriminant.rs
@@ -1,4 +1,5 @@
-use crate::utils::{match_def_path, paths, span_lint_and_then};
+use crate::utils::{match_def_path, paths};
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::walk_ptrs_ty_depth;
 use if_chain::if_chain;
diff --git a/clippy_lints/src/mem_forget.rs b/clippy_lints/src/mem_forget.rs
index d34f9761e26..1a8cb82514b 100644
--- a/clippy_lints/src/mem_forget.rs
+++ b/clippy_lints/src/mem_forget.rs
@@ -1,4 +1,5 @@
-use crate::utils::{match_def_path, paths, span_lint};
+use crate::utils::{match_def_path, paths};
+use clippy_utils::diagnostics::span_lint;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
diff --git a/clippy_lints/src/mem_replace.rs b/clippy_lints/src/mem_replace.rs
index bf3f6f7f830..87cb66a6770 100644
--- a/clippy_lints/src/mem_replace.rs
+++ b/clippy_lints/src/mem_replace.rs
@@ -1,7 +1,5 @@
-use crate::utils::{
-    in_macro, match_def_path, match_qpath, meets_msrv, paths, span_lint_and_help, span_lint_and_sugg,
-    span_lint_and_then,
-};
+use crate::utils::{in_macro, match_def_path, match_qpath, meets_msrv, paths};
+use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::is_diagnostic_assoc_item;
 use clippy_utils::source::{snippet, snippet_with_applicability};
 use if_chain::if_chain;
diff --git a/clippy_lints/src/methods/bind_instead_of_map.rs b/clippy_lints/src/methods/bind_instead_of_map.rs
index 99b3be67f18..7d6104ebb7f 100644
--- a/clippy_lints/src/methods/bind_instead_of_map.rs
+++ b/clippy_lints/src/methods/bind_instead_of_map.rs
@@ -1,8 +1,6 @@
 use super::{contains_return, BIND_INSTEAD_OF_MAP};
-use crate::utils::{
-    in_macro, match_qpath, method_calls, multispan_sugg_with_applicability, paths, remove_blocks, span_lint_and_sugg,
-    span_lint_and_then, visitors::find_all_ret_expressions,
-};
+use crate::utils::{in_macro, match_qpath, method_calls, paths, remove_blocks, visitors::find_all_ret_expressions};
+use clippy_utils::diagnostics::{multispan_sugg_with_applicability, span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::{snippet, snippet_with_macro_callsite};
 use clippy_utils::ty::match_type;
 use if_chain::if_chain;
diff --git a/clippy_lints/src/methods/bytes_nth.rs b/clippy_lints/src/methods/bytes_nth.rs
index f81e9a8c524..4f88f80a304 100644
--- a/clippy_lints/src/methods/bytes_nth.rs
+++ b/clippy_lints/src/methods/bytes_nth.rs
@@ -1,4 +1,4 @@
-use crate::utils::span_lint_and_sugg;
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
diff --git a/clippy_lints/src/methods/clone_on_copy.rs b/clippy_lints/src/methods/clone_on_copy.rs
index 954d589a47e..d1c7789a241 100644
--- a/clippy_lints/src/methods/clone_on_copy.rs
+++ b/clippy_lints/src/methods/clone_on_copy.rs
@@ -1,4 +1,5 @@
-use crate::utils::{span_lint_and_then, sugg};
+use crate::utils::sugg;
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::ty::is_copy;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
diff --git a/clippy_lints/src/methods/clone_on_ref_ptr.rs b/clippy_lints/src/methods/clone_on_ref_ptr.rs
index 90ecb2382e7..b49ae42b12f 100644
--- a/clippy_lints/src/methods/clone_on_ref_ptr.rs
+++ b/clippy_lints/src/methods/clone_on_ref_ptr.rs
@@ -1,4 +1,5 @@
-use crate::utils::{paths, span_lint_and_sugg};
+use crate::utils::paths;
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_macro_callsite;
 use clippy_utils::ty::{is_type_diagnostic_item, match_type};
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/methods/expect_fun_call.rs b/clippy_lints/src/methods/expect_fun_call.rs
index 9e96d571337..1c673c11d65 100644
--- a/clippy_lints/src/methods/expect_fun_call.rs
+++ b/clippy_lints/src/methods/expect_fun_call.rs
@@ -1,4 +1,5 @@
-use crate::utils::{is_expn_of, span_lint_and_sugg};
+use crate::utils::is_expn_of;
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::{snippet, snippet_with_applicability};
 use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
diff --git a/clippy_lints/src/methods/expect_used.rs b/clippy_lints/src/methods/expect_used.rs
index 37c41194b4a..64531b29ade 100644
--- a/clippy_lints/src/methods/expect_used.rs
+++ b/clippy_lints/src/methods/expect_used.rs
@@ -1,4 +1,4 @@
-use crate::utils::span_lint_and_help;
+use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
diff --git a/clippy_lints/src/methods/filetype_is_file.rs b/clippy_lints/src/methods/filetype_is_file.rs
index 791fe3647cb..005c94a6018 100644
--- a/clippy_lints/src/methods/filetype_is_file.rs
+++ b/clippy_lints/src/methods/filetype_is_file.rs
@@ -1,4 +1,5 @@
-use crate::utils::{get_parent_expr, paths, span_lint_and_help};
+use crate::utils::{get_parent_expr, paths};
+use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::ty::match_type;
 use if_chain::if_chain;
 use rustc_hir as hir;
diff --git a/clippy_lints/src/methods/filter_flat_map.rs b/clippy_lints/src/methods/filter_flat_map.rs
index 42f05aa0b3a..4820bb137c1 100644
--- a/clippy_lints/src/methods/filter_flat_map.rs
+++ b/clippy_lints/src/methods/filter_flat_map.rs
@@ -1,4 +1,5 @@
-use crate::utils::{is_trait_method, span_lint_and_help};
+use crate::utils::is_trait_method;
+use clippy_utils::diagnostics::span_lint_and_help;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
 use rustc_span::sym;
diff --git a/clippy_lints/src/methods/filter_map.rs b/clippy_lints/src/methods/filter_map.rs
index 964c4903ed2..af91370df20 100644
--- a/clippy_lints/src/methods/filter_map.rs
+++ b/clippy_lints/src/methods/filter_map.rs
@@ -1,4 +1,5 @@
-use crate::utils::{is_trait_method, path_to_local_id, span_lint_and_sugg, SpanlessEq};
+use crate::utils::{is_trait_method, path_to_local_id, SpanlessEq};
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/methods/filter_map_flat_map.rs b/clippy_lints/src/methods/filter_map_flat_map.rs
index e113f3f71b1..5294ef97528 100644
--- a/clippy_lints/src/methods/filter_map_flat_map.rs
+++ b/clippy_lints/src/methods/filter_map_flat_map.rs
@@ -1,4 +1,5 @@
-use crate::utils::{is_trait_method, span_lint_and_help};
+use crate::utils::is_trait_method;
+use clippy_utils::diagnostics::span_lint_and_help;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
 use rustc_span::sym;
diff --git a/clippy_lints/src/methods/filter_map_identity.rs b/clippy_lints/src/methods/filter_map_identity.rs
index 5f627b42abc..4461baf4f7c 100644
--- a/clippy_lints/src/methods/filter_map_identity.rs
+++ b/clippy_lints/src/methods/filter_map_identity.rs
@@ -1,4 +1,5 @@
-use crate::utils::{is_trait_method, match_qpath, path_to_local_id, paths, span_lint_and_sugg};
+use crate::utils::{is_trait_method, match_qpath, path_to_local_id, paths};
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
diff --git a/clippy_lints/src/methods/filter_map_map.rs b/clippy_lints/src/methods/filter_map_map.rs
index 2e704c4c555..8f17350054b 100644
--- a/clippy_lints/src/methods/filter_map_map.rs
+++ b/clippy_lints/src/methods/filter_map_map.rs
@@ -1,4 +1,5 @@
-use crate::utils::{is_trait_method, span_lint_and_help};
+use crate::utils::is_trait_method;
+use clippy_utils::diagnostics::span_lint_and_help;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
 use rustc_span::sym;
diff --git a/clippy_lints/src/methods/filter_map_next.rs b/clippy_lints/src/methods/filter_map_next.rs
index ed75315b52c..8fbadd1d457 100644
--- a/clippy_lints/src/methods/filter_map_next.rs
+++ b/clippy_lints/src/methods/filter_map_next.rs
@@ -1,4 +1,5 @@
-use crate::utils::{is_trait_method, meets_msrv, span_lint, span_lint_and_sugg};
+use crate::utils::{is_trait_method, meets_msrv};
+use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg};
 use clippy_utils::source::snippet;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
diff --git a/clippy_lints/src/methods/filter_next.rs b/clippy_lints/src/methods/filter_next.rs
index 097f9fdf2c4..af16ea19007 100644
--- a/clippy_lints/src/methods/filter_next.rs
+++ b/clippy_lints/src/methods/filter_next.rs
@@ -1,4 +1,5 @@
-use crate::utils::{is_trait_method, span_lint, span_lint_and_sugg};
+use crate::utils::is_trait_method;
+use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg};
 use clippy_utils::source::snippet;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
diff --git a/clippy_lints/src/methods/flat_map_identity.rs b/clippy_lints/src/methods/flat_map_identity.rs
index 19ddceeccce..669ac1f743f 100644
--- a/clippy_lints/src/methods/flat_map_identity.rs
+++ b/clippy_lints/src/methods/flat_map_identity.rs
@@ -1,4 +1,5 @@
-use crate::utils::{is_trait_method, match_qpath, paths, span_lint_and_sugg};
+use crate::utils::{is_trait_method, match_qpath, paths};
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
diff --git a/clippy_lints/src/methods/from_iter_instead_of_collect.rs b/clippy_lints/src/methods/from_iter_instead_of_collect.rs
index 9b46adaac58..5d0a07992c8 100644
--- a/clippy_lints/src/methods/from_iter_instead_of_collect.rs
+++ b/clippy_lints/src/methods/from_iter_instead_of_collect.rs
@@ -1,4 +1,5 @@
-use crate::utils::{get_trait_def_id, paths, span_lint_and_sugg, sugg};
+use crate::utils::{get_trait_def_id, paths, sugg};
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::ty::implements_trait;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/methods/get_unwrap.rs b/clippy_lints/src/methods/get_unwrap.rs
index b9d34b402bb..ac855419d00 100644
--- a/clippy_lints/src/methods/get_unwrap.rs
+++ b/clippy_lints/src/methods/get_unwrap.rs
@@ -1,5 +1,6 @@
 use crate::methods::derefs_to_slice;
-use crate::utils::{get_parent_expr, paths, span_lint_and_sugg};
+use crate::utils::{get_parent_expr, paths};
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::{is_type_diagnostic_item, match_type};
 use if_chain::if_chain;
diff --git a/clippy_lints/src/methods/implicit_clone.rs b/clippy_lints/src/methods/implicit_clone.rs
index a769493d11d..04461ad5c3a 100644
--- a/clippy_lints/src/methods/implicit_clone.rs
+++ b/clippy_lints/src/methods/implicit_clone.rs
@@ -1,4 +1,4 @@
-use crate::utils::span_lint_and_sugg;
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
diff --git a/clippy_lints/src/methods/inefficient_to_string.rs b/clippy_lints/src/methods/inefficient_to_string.rs
index 19d05b5c693..56de7a8bc5e 100644
--- a/clippy_lints/src/methods/inefficient_to_string.rs
+++ b/clippy_lints/src/methods/inefficient_to_string.rs
@@ -1,5 +1,6 @@
 use super::INEFFICIENT_TO_STRING;
-use crate::utils::{match_def_path, paths, span_lint_and_then};
+use crate::utils::{match_def_path, paths};
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::{is_type_diagnostic_item, walk_ptrs_ty_depth};
 use if_chain::if_chain;
diff --git a/clippy_lints/src/methods/inspect_for_each.rs b/clippy_lints/src/methods/inspect_for_each.rs
index e7c3a433fe1..c9bbfbc37eb 100644
--- a/clippy_lints/src/methods/inspect_for_each.rs
+++ b/clippy_lints/src/methods/inspect_for_each.rs
@@ -1,8 +1,9 @@
+use clippy_utils::diagnostics::span_lint_and_help;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
 use rustc_span::{source_map::Span, sym};
 
-use crate::utils::{is_trait_method, span_lint_and_help};
+use crate::utils::is_trait_method;
 
 use super::INSPECT_FOR_EACH;
 
diff --git a/clippy_lints/src/methods/into_iter_on_ref.rs b/clippy_lints/src/methods/into_iter_on_ref.rs
index f28f082e6fc..a862b55e139 100644
--- a/clippy_lints/src/methods/into_iter_on_ref.rs
+++ b/clippy_lints/src/methods/into_iter_on_ref.rs
@@ -1,4 +1,5 @@
-use crate::utils::{match_trait_method, paths, span_lint_and_sugg};
+use crate::utils::{match_trait_method, paths};
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::ty::has_iter_method;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
diff --git a/clippy_lints/src/methods/iter_cloned_collect.rs b/clippy_lints/src/methods/iter_cloned_collect.rs
index 1e1d3fdcf70..cd575c9cb02 100644
--- a/clippy_lints/src/methods/iter_cloned_collect.rs
+++ b/clippy_lints/src/methods/iter_cloned_collect.rs
@@ -1,5 +1,5 @@
 use crate::methods::derefs_to_slice;
-use crate::utils::span_lint_and_sugg;
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/methods/iter_count.rs b/clippy_lints/src/methods/iter_count.rs
index 0f393423b7d..bfd62ff1f0d 100644
--- a/clippy_lints/src/methods/iter_count.rs
+++ b/clippy_lints/src/methods/iter_count.rs
@@ -1,5 +1,6 @@
 use crate::methods::derefs_to_slice;
-use crate::utils::{paths, span_lint_and_sugg};
+use crate::utils::paths;
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::{is_type_diagnostic_item, match_type};
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/methods/iter_next_slice.rs b/clippy_lints/src/methods/iter_next_slice.rs
index f79942576da..ce599682bbe 100644
--- a/clippy_lints/src/methods/iter_next_slice.rs
+++ b/clippy_lints/src/methods/iter_next_slice.rs
@@ -1,5 +1,6 @@
 use crate::methods::derefs_to_slice;
-use crate::utils::{get_parent_expr, higher, span_lint_and_sugg};
+use crate::utils::{get_parent_expr, higher};
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
diff --git a/clippy_lints/src/methods/iter_nth.rs b/clippy_lints/src/methods/iter_nth.rs
index 17600bb8153..2619793e1e2 100644
--- a/clippy_lints/src/methods/iter_nth.rs
+++ b/clippy_lints/src/methods/iter_nth.rs
@@ -1,6 +1,6 @@
 use crate::methods::derefs_to_slice;
 use crate::methods::iter_nth_zero;
-use crate::utils::span_lint_and_help;
+use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
diff --git a/clippy_lints/src/methods/iter_nth_zero.rs b/clippy_lints/src/methods/iter_nth_zero.rs
index 98ddfdfdf9c..f2b2dd8c097 100644
--- a/clippy_lints/src/methods/iter_nth_zero.rs
+++ b/clippy_lints/src/methods/iter_nth_zero.rs
@@ -1,5 +1,6 @@
 use crate::consts::{constant, Constant};
-use crate::utils::{is_trait_method, span_lint_and_sugg};
+use crate::utils::is_trait_method;
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/methods/iter_skip_next.rs b/clippy_lints/src/methods/iter_skip_next.rs
index d191ea0a831..6100613bcac 100644
--- a/clippy_lints/src/methods/iter_skip_next.rs
+++ b/clippy_lints/src/methods/iter_skip_next.rs
@@ -1,4 +1,5 @@
-use crate::utils::{is_trait_method, span_lint_and_sugg};
+use crate::utils::is_trait_method;
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
diff --git a/clippy_lints/src/methods/iterator_step_by_zero.rs b/clippy_lints/src/methods/iterator_step_by_zero.rs
index 019a08f746e..51c1ab0484e 100644
--- a/clippy_lints/src/methods/iterator_step_by_zero.rs
+++ b/clippy_lints/src/methods/iterator_step_by_zero.rs
@@ -1,5 +1,6 @@
 use crate::consts::{constant, Constant};
-use crate::utils::{is_trait_method, span_lint};
+use crate::utils::is_trait_method;
+use clippy_utils::diagnostics::span_lint;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
 use rustc_span::sym;
diff --git a/clippy_lints/src/methods/manual_saturating_arithmetic.rs b/clippy_lints/src/methods/manual_saturating_arithmetic.rs
index d090a35a3cf..0c8a002e359 100644
--- a/clippy_lints/src/methods/manual_saturating_arithmetic.rs
+++ b/clippy_lints/src/methods/manual_saturating_arithmetic.rs
@@ -1,4 +1,5 @@
-use crate::utils::{match_qpath, span_lint_and_sugg};
+use crate::utils::match_qpath;
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use if_chain::if_chain;
 use rustc_ast::ast;
diff --git a/clippy_lints/src/methods/map_collect_result_unit.rs b/clippy_lints/src/methods/map_collect_result_unit.rs
index 349b26b9d58..b59998fc8b4 100644
--- a/clippy_lints/src/methods/map_collect_result_unit.rs
+++ b/clippy_lints/src/methods/map_collect_result_unit.rs
@@ -1,4 +1,5 @@
-use crate::utils::{is_trait_method, span_lint_and_sugg};
+use crate::utils::is_trait_method;
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
diff --git a/clippy_lints/src/methods/map_flatten.rs b/clippy_lints/src/methods/map_flatten.rs
index 56719b3cff2..6f5e723fbfb 100644
--- a/clippy_lints/src/methods/map_flatten.rs
+++ b/clippy_lints/src/methods/map_flatten.rs
@@ -1,4 +1,5 @@
-use crate::utils::{is_trait_method, span_lint_and_sugg};
+use crate::utils::is_trait_method;
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/methods/map_unwrap_or.rs b/clippy_lints/src/methods/map_unwrap_or.rs
index 96dbc7ddc63..8ef02b4a641 100644
--- a/clippy_lints/src/methods/map_unwrap_or.rs
+++ b/clippy_lints/src/methods/map_unwrap_or.rs
@@ -1,5 +1,6 @@
+use crate::utils::meets_msrv;
 use crate::utils::usage::mutated_variables;
-use crate::utils::{meets_msrv, span_lint, span_lint_and_sugg};
+use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg};
 use clippy_utils::source::snippet;
 use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 47617e4722e..af8fe7abd96 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -52,6 +52,7 @@ mod wrong_self_convention;
 mod zst_offset;
 
 use bind_instead_of_map::BindInsteadOfMap;
+use clippy_utils::diagnostics::{span_lint, span_lint_and_help, span_lint_and_sugg};
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::{contains_ty, implements_trait, is_copy, is_type_diagnostic_item};
 use if_chain::if_chain;
@@ -69,8 +70,7 @@ use rustc_typeck::hir_ty_to_ty;
 
 use crate::utils::{
     contains_return, get_trait_def_id, in_macro, iter_input_pats, match_def_path, match_qpath, method_calls,
-    method_chain_args, paths, return_ty, single_segment_path, span_lint, span_lint_and_help, span_lint_and_sugg,
-    SpanlessEq,
+    method_chain_args, paths, return_ty, single_segment_path, SpanlessEq,
 };
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/methods/ok_expect.rs b/clippy_lints/src/methods/ok_expect.rs
index 2618d04b242..e6ce9cac397 100644
--- a/clippy_lints/src/methods/ok_expect.rs
+++ b/clippy_lints/src/methods/ok_expect.rs
@@ -1,4 +1,4 @@
-use crate::utils::span_lint_and_help;
+use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::ty::{implements_trait, is_type_diagnostic_item};
 use if_chain::if_chain;
 use rustc_hir as hir;
diff --git a/clippy_lints/src/methods/option_as_ref_deref.rs b/clippy_lints/src/methods/option_as_ref_deref.rs
index 6597e9f96a8..f921d7b16c0 100644
--- a/clippy_lints/src/methods/option_as_ref_deref.rs
+++ b/clippy_lints/src/methods/option_as_ref_deref.rs
@@ -1,4 +1,5 @@
-use crate::utils::{match_def_path, meets_msrv, path_to_local_id, paths, remove_blocks, span_lint_and_sugg};
+use crate::utils::{match_def_path, meets_msrv, path_to_local_id, paths, remove_blocks};
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
diff --git a/clippy_lints/src/methods/option_map_or_none.rs b/clippy_lints/src/methods/option_map_or_none.rs
index eed71d02467..e8b057c2d74 100644
--- a/clippy_lints/src/methods/option_map_or_none.rs
+++ b/clippy_lints/src/methods/option_map_or_none.rs
@@ -1,4 +1,5 @@
-use crate::utils::{match_qpath, paths, span_lint_and_sugg};
+use crate::utils::{match_qpath, paths};
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/methods/option_map_unwrap_or.rs b/clippy_lints/src/methods/option_map_unwrap_or.rs
index 398d8f13bd4..c6459648cd5 100644
--- a/clippy_lints/src/methods/option_map_unwrap_or.rs
+++ b/clippy_lints/src/methods/option_map_unwrap_or.rs
@@ -1,4 +1,5 @@
-use crate::utils::{differing_macro_contexts, span_lint_and_then};
+use crate::utils::differing_macro_contexts;
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::is_copy;
 use clippy_utils::ty::is_type_diagnostic_item;
diff --git a/clippy_lints/src/methods/or_fun_call.rs b/clippy_lints/src/methods/or_fun_call.rs
index 634feebe54a..1b43802a08e 100644
--- a/clippy_lints/src/methods/or_fun_call.rs
+++ b/clippy_lints/src/methods/or_fun_call.rs
@@ -1,5 +1,6 @@
 use crate::utils::eager_or_lazy::is_lazyness_candidate;
-use crate::utils::{contains_return, get_trait_def_id, last_path_segment, paths, span_lint_and_sugg};
+use crate::utils::{contains_return, get_trait_def_id, last_path_segment, paths};
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::{snippet, snippet_with_applicability, snippet_with_macro_callsite};
 use clippy_utils::ty::{implements_trait, is_type_diagnostic_item, match_type};
 use if_chain::if_chain;
diff --git a/clippy_lints/src/methods/search_is_some.rs b/clippy_lints/src/methods/search_is_some.rs
index 6054579d988..18e1064b018 100644
--- a/clippy_lints/src/methods/search_is_some.rs
+++ b/clippy_lints/src/methods/search_is_some.rs
@@ -1,4 +1,5 @@
-use crate::utils::{is_trait_method, span_lint_and_help, span_lint_and_sugg, strip_pat_refs};
+use crate::utils::{is_trait_method, strip_pat_refs};
+use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg};
 use clippy_utils::source::{snippet, snippet_with_applicability};
 use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
diff --git a/clippy_lints/src/methods/single_char_insert_string.rs b/clippy_lints/src/methods/single_char_insert_string.rs
index ff67564b39d..cd87d2c56b7 100644
--- a/clippy_lints/src/methods/single_char_insert_string.rs
+++ b/clippy_lints/src/methods/single_char_insert_string.rs
@@ -1,5 +1,5 @@
 use crate::methods::get_hint_if_single_char_arg;
-use crate::utils::span_lint_and_sugg;
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
diff --git a/clippy_lints/src/methods/single_char_pattern.rs b/clippy_lints/src/methods/single_char_pattern.rs
index 61cbc9d2f0a..12d6418d700 100644
--- a/clippy_lints/src/methods/single_char_pattern.rs
+++ b/clippy_lints/src/methods/single_char_pattern.rs
@@ -1,5 +1,5 @@
 use crate::methods::get_hint_if_single_char_arg;
-use crate::utils::span_lint_and_sugg;
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
diff --git a/clippy_lints/src/methods/single_char_push_string.rs b/clippy_lints/src/methods/single_char_push_string.rs
index 18df90c1ab3..882703a987d 100644
--- a/clippy_lints/src/methods/single_char_push_string.rs
+++ b/clippy_lints/src/methods/single_char_push_string.rs
@@ -1,5 +1,5 @@
 use crate::methods::get_hint_if_single_char_arg;
-use crate::utils::span_lint_and_sugg;
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
diff --git a/clippy_lints/src/methods/skip_while_next.rs b/clippy_lints/src/methods/skip_while_next.rs
index a9ff78c3260..8995226191b 100644
--- a/clippy_lints/src/methods/skip_while_next.rs
+++ b/clippy_lints/src/methods/skip_while_next.rs
@@ -1,4 +1,5 @@
-use crate::utils::{is_trait_method, span_lint_and_help};
+use crate::utils::is_trait_method;
+use clippy_utils::diagnostics::span_lint_and_help;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
 use rustc_span::sym;
diff --git a/clippy_lints/src/methods/string_extend_chars.rs b/clippy_lints/src/methods/string_extend_chars.rs
index 1b26e8314af..d9b97168490 100644
--- a/clippy_lints/src/methods/string_extend_chars.rs
+++ b/clippy_lints/src/methods/string_extend_chars.rs
@@ -1,4 +1,5 @@
-use crate::utils::{method_chain_args, span_lint_and_sugg};
+use crate::utils::method_chain_args;
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/methods/suspicious_map.rs b/clippy_lints/src/methods/suspicious_map.rs
index 0ffa71de30c..fd4651dd182 100644
--- a/clippy_lints/src/methods/suspicious_map.rs
+++ b/clippy_lints/src/methods/suspicious_map.rs
@@ -1,5 +1,6 @@
 use crate::utils::usage::mutated_variables;
-use crate::utils::{expr_or_init, is_trait_method, span_lint_and_help};
+use crate::utils::{expr_or_init, is_trait_method};
+use clippy_utils::diagnostics::span_lint_and_help;
 use if_chain::if_chain;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
diff --git a/clippy_lints/src/methods/uninit_assumed_init.rs b/clippy_lints/src/methods/uninit_assumed_init.rs
index 798b66192c8..071856c3ba6 100644
--- a/clippy_lints/src/methods/uninit_assumed_init.rs
+++ b/clippy_lints/src/methods/uninit_assumed_init.rs
@@ -1,4 +1,5 @@
-use crate::utils::{match_def_path, match_qpath, paths, span_lint};
+use crate::utils::{match_def_path, match_qpath, paths};
+use clippy_utils::diagnostics::span_lint;
 use if_chain::if_chain;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
diff --git a/clippy_lints/src/methods/unnecessary_filter_map.rs b/clippy_lints/src/methods/unnecessary_filter_map.rs
index 686874c0a24..670134c68f2 100644
--- a/clippy_lints/src/methods/unnecessary_filter_map.rs
+++ b/clippy_lints/src/methods/unnecessary_filter_map.rs
@@ -1,5 +1,6 @@
 use crate::utils::usage::mutated_variables;
-use crate::utils::{is_trait_method, match_qpath, path_to_local_id, paths, span_lint};
+use crate::utils::{is_trait_method, match_qpath, path_to_local_id, paths};
+use clippy_utils::diagnostics::span_lint;
 use rustc_hir as hir;
 use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
 use rustc_lint::LateContext;
diff --git a/clippy_lints/src/methods/unnecessary_fold.rs b/clippy_lints/src/methods/unnecessary_fold.rs
index 4d5cbdd619d..3ccde57de3f 100644
--- a/clippy_lints/src/methods/unnecessary_fold.rs
+++ b/clippy_lints/src/methods/unnecessary_fold.rs
@@ -1,4 +1,5 @@
-use crate::utils::{is_trait_method, path_to_local_id, remove_blocks, span_lint_and_sugg, strip_pat_refs};
+use crate::utils::{is_trait_method, path_to_local_id, remove_blocks, strip_pat_refs};
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use if_chain::if_chain;
 use rustc_ast::ast;
diff --git a/clippy_lints/src/methods/unnecessary_lazy_eval.rs b/clippy_lints/src/methods/unnecessary_lazy_eval.rs
index 444abde3d0f..3874673bf9f 100644
--- a/clippy_lints/src/methods/unnecessary_lazy_eval.rs
+++ b/clippy_lints/src/methods/unnecessary_lazy_eval.rs
@@ -1,5 +1,5 @@
-use crate::utils::span_lint_and_sugg;
 use crate::utils::{eager_or_lazy, usage};
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/methods/unwrap_used.rs b/clippy_lints/src/methods/unwrap_used.rs
index efe43a6a952..2f5806115bd 100644
--- a/clippy_lints/src/methods/unwrap_used.rs
+++ b/clippy_lints/src/methods/unwrap_used.rs
@@ -1,4 +1,4 @@
-use crate::utils::span_lint_and_help;
+use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
diff --git a/clippy_lints/src/methods/useless_asref.rs b/clippy_lints/src/methods/useless_asref.rs
index c6d84aedc0a..13c95e33fef 100644
--- a/clippy_lints/src/methods/useless_asref.rs
+++ b/clippy_lints/src/methods/useless_asref.rs
@@ -1,4 +1,5 @@
-use crate::utils::{get_parent_expr, match_trait_method, paths, span_lint_and_sugg};
+use crate::utils::{get_parent_expr, match_trait_method, paths};
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::walk_ptrs_ty_depth;
 use if_chain::if_chain;
diff --git a/clippy_lints/src/methods/wrong_self_convention.rs b/clippy_lints/src/methods/wrong_self_convention.rs
index c8bcad7be3e..b728d7d8d08 100644
--- a/clippy_lints/src/methods/wrong_self_convention.rs
+++ b/clippy_lints/src/methods/wrong_self_convention.rs
@@ -1,5 +1,5 @@
 use crate::methods::SelfKind;
-use crate::utils::span_lint_and_help;
+use clippy_utils::diagnostics::span_lint_and_help;
 use rustc_lint::LateContext;
 use rustc_middle::ty::TyS;
 use rustc_span::source_map::Span;
diff --git a/clippy_lints/src/methods/zst_offset.rs b/clippy_lints/src/methods/zst_offset.rs
index f1335726736..9f6a7c4db17 100644
--- a/clippy_lints/src/methods/zst_offset.rs
+++ b/clippy_lints/src/methods/zst_offset.rs
@@ -1,4 +1,4 @@
-use crate::utils::span_lint;
+use clippy_utils::diagnostics::span_lint;
 use if_chain::if_chain;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
diff --git a/clippy_lints/src/minmax.rs b/clippy_lints/src/minmax.rs
index 8d0c3b8e0fe..6a4e70e50af 100644
--- a/clippy_lints/src/minmax.rs
+++ b/clippy_lints/src/minmax.rs
@@ -1,5 +1,6 @@
 use crate::consts::{constant_simple, Constant};
-use crate::utils::{match_def_path, match_trait_method, paths, span_lint};
+use crate::utils::{match_def_path, match_trait_method, paths};
+use clippy_utils::diagnostics::span_lint;
 use if_chain::if_chain;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/misc.rs b/clippy_lints/src/misc.rs
index f161054cc8c..03d07287005 100644
--- a/clippy_lints/src/misc.rs
+++ b/clippy_lints/src/misc.rs
@@ -1,3 +1,4 @@
+use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg, span_lint_and_then, span_lint_hir_and_then};
 use clippy_utils::source::{snippet, snippet_opt};
 use clippy_utils::ty::implements_trait;
 use if_chain::if_chain;
@@ -20,8 +21,7 @@ use crate::consts::{constant, Constant};
 use crate::utils::sugg::Sugg;
 use crate::utils::{
     get_item_name, get_parent_expr, higher, in_constant, is_diagnostic_assoc_item, is_integer_const, iter_input_pats,
-    last_path_segment, match_qpath, span_lint, span_lint_and_sugg, span_lint_and_then, span_lint_hir_and_then, unsext,
-    SpanlessEq,
+    last_path_segment, match_qpath, unsext, SpanlessEq,
 };
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/misc_early.rs b/clippy_lints/src/misc_early.rs
index 6ec523498e1..3c6a7071c24 100644
--- a/clippy_lints/src/misc_early.rs
+++ b/clippy_lints/src/misc_early.rs
@@ -1,4 +1,4 @@
-use crate::utils::{span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then};
+use clippy_utils::diagnostics::{span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::snippet_opt;
 use rustc_ast::ast::{
     BindingMode, Expr, ExprKind, GenericParamKind, Generics, Lit, LitFloatType, LitIntType, LitKind, Mutability,
diff --git a/clippy_lints/src/missing_const_for_fn.rs b/clippy_lints/src/missing_const_for_fn.rs
index 4cc20b8d38c..aba4accccb1 100644
--- a/clippy_lints/src/missing_const_for_fn.rs
+++ b/clippy_lints/src/missing_const_for_fn.rs
@@ -1,5 +1,6 @@
 use crate::utils::qualify_min_const_fn::is_min_const_fn;
-use crate::utils::{fn_has_unsatisfiable_preds, is_entrypoint_fn, meets_msrv, span_lint, trait_ref_of_method};
+use crate::utils::{fn_has_unsatisfiable_preds, is_entrypoint_fn, meets_msrv, trait_ref_of_method};
+use clippy_utils::diagnostics::span_lint;
 use clippy_utils::ty::has_drop;
 use rustc_hir as hir;
 use rustc_hir::intravisit::FnKind;
diff --git a/clippy_lints/src/missing_doc.rs b/clippy_lints/src/missing_doc.rs
index 6ec4c38d0f9..fd6f31faa94 100644
--- a/clippy_lints/src/missing_doc.rs
+++ b/clippy_lints/src/missing_doc.rs
@@ -5,7 +5,7 @@
 // [`missing_doc`]: https://github.com/rust-lang/rust/blob/cf9cf7c923eb01146971429044f216a3ca905e06/compiler/rustc_lint/src/builtin.rs#L415
 //
 
-use crate::utils::span_lint;
+use clippy_utils::diagnostics::span_lint;
 use if_chain::if_chain;
 use rustc_ast::ast::{self, MetaItem, MetaItemKind};
 use rustc_ast::attr;
diff --git a/clippy_lints/src/missing_inline.rs b/clippy_lints/src/missing_inline.rs
index da59c820999..dd4488f3f02 100644
--- a/clippy_lints/src/missing_inline.rs
+++ b/clippy_lints/src/missing_inline.rs
@@ -1,4 +1,4 @@
-use crate::utils::span_lint;
+use clippy_utils::diagnostics::span_lint;
 use rustc_ast::ast;
 use rustc_hir as hir;
 use rustc_lint::{self, LateContext, LateLintPass, LintContext};
diff --git a/clippy_lints/src/modulo_arithmetic.rs b/clippy_lints/src/modulo_arithmetic.rs
index da3ae1d652f..1b00cf2c75d 100644
--- a/clippy_lints/src/modulo_arithmetic.rs
+++ b/clippy_lints/src/modulo_arithmetic.rs
@@ -1,5 +1,6 @@
 use crate::consts::{constant, Constant};
-use crate::utils::{sext, span_lint_and_then};
+use crate::utils::sext;
+use clippy_utils::diagnostics::span_lint_and_then;
 use if_chain::if_chain;
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/multiple_crate_versions.rs b/clippy_lints/src/multiple_crate_versions.rs
index c1773cef7a8..6eaeaebe781 100644
--- a/clippy_lints/src/multiple_crate_versions.rs
+++ b/clippy_lints/src/multiple_crate_versions.rs
@@ -1,6 +1,7 @@
 //! lint on multiple versions of a crate being used
 
-use crate::utils::{run_lints, span_lint};
+use crate::utils::run_lints;
+use clippy_utils::diagnostics::span_lint;
 use rustc_hir::def_id::LOCAL_CRATE;
 use rustc_hir::{Crate, CRATE_HIR_ID};
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/mut_key.rs b/clippy_lints/src/mut_key.rs
index 908b7bb7ce0..39aec79734c 100644
--- a/clippy_lints/src/mut_key.rs
+++ b/clippy_lints/src/mut_key.rs
@@ -1,4 +1,5 @@
-use crate::utils::{match_def_path, paths, span_lint, trait_ref_of_method};
+use crate::utils::{match_def_path, paths, trait_ref_of_method};
+use clippy_utils::diagnostics::span_lint;
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::TypeFoldable;
diff --git a/clippy_lints/src/mut_mut.rs b/clippy_lints/src/mut_mut.rs
index d7239b328bb..c11ccc94890 100644
--- a/clippy_lints/src/mut_mut.rs
+++ b/clippy_lints/src/mut_mut.rs
@@ -1,4 +1,5 @@
-use crate::utils::{higher, span_lint};
+use crate::utils::higher;
+use clippy_utils::diagnostics::span_lint;
 use rustc_hir as hir;
 use rustc_hir::intravisit;
 use rustc_lint::{LateContext, LateLintPass, LintContext};
diff --git a/clippy_lints/src/mut_mutex_lock.rs b/clippy_lints/src/mut_mutex_lock.rs
index e4a57661f97..b9ba74c7d02 100644
--- a/clippy_lints/src/mut_mutex_lock.rs
+++ b/clippy_lints/src/mut_mutex_lock.rs
@@ -1,4 +1,4 @@
-use crate::utils::span_lint_and_sugg;
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/mut_reference.rs b/clippy_lints/src/mut_reference.rs
index 3f0b765df15..0c09ddb8073 100644
--- a/clippy_lints/src/mut_reference.rs
+++ b/clippy_lints/src/mut_reference.rs
@@ -1,4 +1,4 @@
-use crate::utils::span_lint;
+use clippy_utils::diagnostics::span_lint;
 use rustc_hir::{BorrowKind, Expr, ExprKind, Mutability};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::subst::Subst;
diff --git a/clippy_lints/src/mutable_debug_assertion.rs b/clippy_lints/src/mutable_debug_assertion.rs
index 9ac127abe0a..fb8895e08d0 100644
--- a/clippy_lints/src/mutable_debug_assertion.rs
+++ b/clippy_lints/src/mutable_debug_assertion.rs
@@ -1,4 +1,5 @@
-use crate::utils::{higher, is_direct_expn_of, span_lint};
+use crate::utils::{higher, is_direct_expn_of};
+use clippy_utils::diagnostics::span_lint;
 use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
 use rustc_hir::{BorrowKind, Expr, ExprKind, MatchSource, Mutability};
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/mutex_atomic.rs b/clippy_lints/src/mutex_atomic.rs
index 9f746ce2e1a..354e2c3fb74 100644
--- a/clippy_lints/src/mutex_atomic.rs
+++ b/clippy_lints/src/mutex_atomic.rs
@@ -2,7 +2,7 @@
 //!
 //! This lint is **warn** by default
 
-use crate::utils::span_lint;
+use clippy_utils::diagnostics::span_lint;
 use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_hir::Expr;
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/needless_arbitrary_self_type.rs b/clippy_lints/src/needless_arbitrary_self_type.rs
index 7687962bdd9..c62ff7323f3 100644
--- a/clippy_lints/src/needless_arbitrary_self_type.rs
+++ b/clippy_lints/src/needless_arbitrary_self_type.rs
@@ -1,4 +1,5 @@
-use crate::utils::{in_macro, span_lint_and_sugg};
+use crate::utils::in_macro;
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use if_chain::if_chain;
 use rustc_ast::ast::{BindingMode, Lifetime, Mutability, Param, PatKind, Path, TyKind};
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/needless_bool.rs b/clippy_lints/src/needless_bool.rs
index 22adbdf09a6..4c67304d23e 100644
--- a/clippy_lints/src/needless_bool.rs
+++ b/clippy_lints/src/needless_bool.rs
@@ -3,7 +3,8 @@
 //! This lint is **warn** by default
 
 use crate::utils::sugg::Sugg;
-use crate::utils::{is_expn_of, parent_node_is_if_expr, span_lint, span_lint_and_sugg};
+use crate::utils::{is_expn_of, parent_node_is_if_expr};
+use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg};
 use clippy_utils::source::snippet_with_applicability;
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/needless_borrow.rs b/clippy_lints/src/needless_borrow.rs
index d8b574af1fe..72436b51dcb 100644
--- a/clippy_lints/src/needless_borrow.rs
+++ b/clippy_lints/src/needless_borrow.rs
@@ -2,7 +2,8 @@
 //!
 //! This lint is **warn** by default
 
-use crate::utils::{is_automatically_derived, span_lint_and_then};
+use crate::utils::is_automatically_derived;
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet_opt;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/needless_borrowed_ref.rs b/clippy_lints/src/needless_borrowed_ref.rs
index 5ee71f25694..7fbffe04a3f 100644
--- a/clippy_lints/src/needless_borrowed_ref.rs
+++ b/clippy_lints/src/needless_borrowed_ref.rs
@@ -1,4 +1,4 @@
-use crate::utils::span_lint_and_then;
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet_with_applicability;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/needless_continue.rs b/clippy_lints/src/needless_continue.rs
index 4ff90704207..91c97ef7c2a 100644
--- a/clippy_lints/src/needless_continue.rs
+++ b/clippy_lints/src/needless_continue.rs
@@ -33,6 +33,7 @@
 //! ```
 //!
 //! This lint is **warn** by default.
+use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::source::{indent_of, snippet, snippet_block};
 use rustc_ast::ast;
 use rustc_lint::{EarlyContext, EarlyLintPass};
@@ -40,8 +41,6 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::{original_sp, DUMMY_SP};
 use rustc_span::Span;
 
-use crate::utils::span_lint_and_help;
-
 declare_clippy_lint! {
     /// **What it does:** The lint checks for `if`-statements appearing in loops
     /// that contain a `continue` statement in either their main blocks or their
diff --git a/clippy_lints/src/needless_pass_by_value.rs b/clippy_lints/src/needless_pass_by_value.rs
index 6f7a5d85480..fc8ee6cb8ef 100644
--- a/clippy_lints/src/needless_pass_by_value.rs
+++ b/clippy_lints/src/needless_pass_by_value.rs
@@ -1,5 +1,6 @@
 use crate::utils::ptr::get_spans;
-use crate::utils::{get_trait_def_id, is_self, multispan_sugg, paths, span_lint_and_then};
+use crate::utils::{get_trait_def_id, is_self, paths};
+use clippy_utils::diagnostics::{multispan_sugg, span_lint_and_then};
 use clippy_utils::source::{snippet, snippet_opt};
 use clippy_utils::ty::{implements_trait, is_copy, is_type_diagnostic_item};
 use if_chain::if_chain;
diff --git a/clippy_lints/src/needless_question_mark.rs b/clippy_lints/src/needless_question_mark.rs
index bcc39ff855c..ecf48d082af 100644
--- a/clippy_lints/src/needless_question_mark.rs
+++ b/clippy_lints/src/needless_question_mark.rs
@@ -1,3 +1,4 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_errors::Applicability;
@@ -140,7 +141,7 @@ fn emit_lint(cx: &LateContext<'_>, expr: &SomeOkCall<'_>) {
         SomeOkCall::OkCall(outer, inner) | SomeOkCall::SomeCall(outer, inner) => (outer, inner),
     };
 
-    utils::span_lint_and_sugg(
+    span_lint_and_sugg(
         cx,
         NEEDLESS_QUESTION_MARK,
         entire_expr.span,
diff --git a/clippy_lints/src/needless_update.rs b/clippy_lints/src/needless_update.rs
index 41cf541ecf5..e93de8a252a 100644
--- a/clippy_lints/src/needless_update.rs
+++ b/clippy_lints/src/needless_update.rs
@@ -1,4 +1,4 @@
-use crate::utils::span_lint;
+use clippy_utils::diagnostics::span_lint;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
diff --git a/clippy_lints/src/neg_cmp_op_on_partial_ord.rs b/clippy_lints/src/neg_cmp_op_on_partial_ord.rs
index 67d49f06ad9..e291885d34d 100644
--- a/clippy_lints/src/neg_cmp_op_on_partial_ord.rs
+++ b/clippy_lints/src/neg_cmp_op_on_partial_ord.rs
@@ -1,3 +1,4 @@
+use clippy_utils::diagnostics::span_lint;
 use clippy_utils::ty::implements_trait;
 use if_chain::if_chain;
 use rustc_hir::{BinOpKind, Expr, ExprKind, UnOp};
@@ -5,7 +6,7 @@ use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
-use crate::utils::{self, paths, span_lint};
+use crate::utils::{self, paths};
 
 declare_clippy_lint! {
     /// **What it does:**
diff --git a/clippy_lints/src/neg_multiply.rs b/clippy_lints/src/neg_multiply.rs
index ef7cc65cfcf..7b00879251f 100644
--- a/clippy_lints/src/neg_multiply.rs
+++ b/clippy_lints/src/neg_multiply.rs
@@ -1,3 +1,4 @@
+use clippy_utils::diagnostics::span_lint;
 use if_chain::if_chain;
 use rustc_hir::{BinOpKind, Expr, ExprKind, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
@@ -5,7 +6,6 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
 
 use crate::consts::{self, Constant};
-use crate::utils::span_lint;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for multiplication by -1 as a form of negation.
diff --git a/clippy_lints/src/new_without_default.rs b/clippy_lints/src/new_without_default.rs
index de2899c3462..9fbb6b02742 100644
--- a/clippy_lints/src/new_without_default.rs
+++ b/clippy_lints/src/new_without_default.rs
@@ -1,6 +1,7 @@
 use crate::utils::paths;
 use crate::utils::sugg::DiagnosticBuilderExt;
-use crate::utils::{get_trait_def_id, return_ty, span_lint_hir_and_then};
+use crate::utils::{get_trait_def_id, return_ty};
+use clippy_utils::diagnostics::span_lint_hir_and_then;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
diff --git a/clippy_lints/src/no_effect.rs b/clippy_lints/src/no_effect.rs
index 7a7bc7a44cd..83953a16bc8 100644
--- a/clippy_lints/src/no_effect.rs
+++ b/clippy_lints/src/no_effect.rs
@@ -1,4 +1,4 @@
-use crate::utils::{span_lint, span_lint_and_sugg};
+use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg};
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::has_drop;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/non_copy_const.rs b/clippy_lints/src/non_copy_const.rs
index 8aebce67917..5db614497e3 100644
--- a/clippy_lints/src/non_copy_const.rs
+++ b/clippy_lints/src/non_copy_const.rs
@@ -4,6 +4,7 @@
 
 use std::ptr;
 
+use clippy_utils::diagnostics::span_lint_and_then;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::def_id::DefId;
 use rustc_hir::{
@@ -18,7 +19,7 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::{InnerSpan, Span, DUMMY_SP};
 use rustc_typeck::hir_ty_to_ty;
 
-use crate::utils::{in_constant, span_lint_and_then};
+use crate::utils::in_constant;
 use if_chain::if_chain;
 
 // FIXME: this is a correctness problem but there's no suitable
diff --git a/clippy_lints/src/non_expressive_names.rs b/clippy_lints/src/non_expressive_names.rs
index 7c74b316018..52661416de6 100644
--- a/clippy_lints/src/non_expressive_names.rs
+++ b/clippy_lints/src/non_expressive_names.rs
@@ -1,4 +1,4 @@
-use crate::utils::{span_lint, span_lint_and_then};
+use clippy_utils::diagnostics::{span_lint, span_lint_and_then};
 use rustc_ast::ast::{
     Arm, AssocItem, AssocItemKind, Attribute, Block, FnDecl, FnKind, Item, ItemKind, Local, Pat, PatKind,
 };
diff --git a/clippy_lints/src/open_options.rs b/clippy_lints/src/open_options.rs
index 71e77932f7a..8e8aaa67afa 100644
--- a/clippy_lints/src/open_options.rs
+++ b/clippy_lints/src/open_options.rs
@@ -1,4 +1,5 @@
-use crate::utils::{paths, span_lint};
+use crate::utils::paths;
+use clippy_utils::diagnostics::span_lint;
 use clippy_utils::ty::match_type;
 use rustc_ast::ast::LitKind;
 use rustc_hir::{Expr, ExprKind};
diff --git a/clippy_lints/src/option_env_unwrap.rs b/clippy_lints/src/option_env_unwrap.rs
index fd653044a1b..343159f9ae2 100644
--- a/clippy_lints/src/option_env_unwrap.rs
+++ b/clippy_lints/src/option_env_unwrap.rs
@@ -1,4 +1,5 @@
-use crate::utils::{is_direct_expn_of, span_lint_and_help};
+use crate::utils::is_direct_expn_of;
+use clippy_utils::diagnostics::span_lint_and_help;
 use if_chain::if_chain;
 use rustc_ast::ast::{Expr, ExprKind};
 use rustc_lint::{EarlyContext, EarlyLintPass};
diff --git a/clippy_lints/src/option_if_let_else.rs b/clippy_lints/src/option_if_let_else.rs
index 8a6d257848f..eab08a58320 100644
--- a/clippy_lints/src/option_if_let_else.rs
+++ b/clippy_lints/src/option_if_let_else.rs
@@ -1,7 +1,8 @@
 use crate::utils;
 use crate::utils::eager_or_lazy;
+use crate::utils::paths;
 use crate::utils::sugg::Sugg;
-use crate::utils::{paths, span_lint_and_sugg};
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
 
diff --git a/clippy_lints/src/overflow_check_conditional.rs b/clippy_lints/src/overflow_check_conditional.rs
index 3c041bac234..524b96921fe 100644
--- a/clippy_lints/src/overflow_check_conditional.rs
+++ b/clippy_lints/src/overflow_check_conditional.rs
@@ -1,4 +1,5 @@
-use crate::utils::{span_lint, SpanlessEq};
+use crate::utils::SpanlessEq;
+use clippy_utils::diagnostics::span_lint;
 use if_chain::if_chain;
 use rustc_hir::{BinOpKind, Expr, ExprKind, QPath};
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/panic_in_result_fn.rs b/clippy_lints/src/panic_in_result_fn.rs
index 1821e2611ff..880951f3e3e 100644
--- a/clippy_lints/src/panic_in_result_fn.rs
+++ b/clippy_lints/src/panic_in_result_fn.rs
@@ -1,4 +1,5 @@
-use crate::utils::{find_macro_calls, return_ty, span_lint_and_then};
+use crate::utils::{find_macro_calls, return_ty};
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_hir as hir;
 use rustc_hir::intravisit::FnKind;
diff --git a/clippy_lints/src/panic_unimplemented.rs b/clippy_lints/src/panic_unimplemented.rs
index 359620cc079..ad4ed831941 100644
--- a/clippy_lints/src/panic_unimplemented.rs
+++ b/clippy_lints/src/panic_unimplemented.rs
@@ -1,4 +1,5 @@
-use crate::utils::{is_expn_of, match_panic_call, span_lint};
+use crate::utils::{is_expn_of, match_panic_call};
+use clippy_utils::diagnostics::span_lint;
 use if_chain::if_chain;
 use rustc_hir::Expr;
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/partialeq_ne_impl.rs b/clippy_lints/src/partialeq_ne_impl.rs
index aca1ed5ca65..06985cef4ff 100644
--- a/clippy_lints/src/partialeq_ne_impl.rs
+++ b/clippy_lints/src/partialeq_ne_impl.rs
@@ -1,4 +1,5 @@
-use crate::utils::{is_automatically_derived, span_lint_hir};
+use crate::utils::is_automatically_derived;
+use clippy_utils::diagnostics::span_lint_hir;
 use if_chain::if_chain;
 use rustc_hir::{Impl, Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/pass_by_ref_or_value.rs b/clippy_lints/src/pass_by_ref_or_value.rs
index 757ead2c24c..c14273840c4 100644
--- a/clippy_lints/src/pass_by_ref_or_value.rs
+++ b/clippy_lints/src/pass_by_ref_or_value.rs
@@ -1,6 +1,7 @@
 use std::cmp;
 
-use crate::utils::{is_self_ty, span_lint_and_sugg};
+use crate::utils::is_self_ty;
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::is_copy;
 use if_chain::if_chain;
diff --git a/clippy_lints/src/path_buf_push_overwrite.rs b/clippy_lints/src/path_buf_push_overwrite.rs
index 46533682d42..95ffae28d8c 100644
--- a/clippy_lints/src/path_buf_push_overwrite.rs
+++ b/clippy_lints/src/path_buf_push_overwrite.rs
@@ -1,4 +1,4 @@
-use crate::utils::span_lint_and_sugg;
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
diff --git a/clippy_lints/src/pattern_type_mismatch.rs b/clippy_lints/src/pattern_type_mismatch.rs
index 5539331d046..dd63cf99e42 100644
--- a/clippy_lints/src/pattern_type_mismatch.rs
+++ b/clippy_lints/src/pattern_type_mismatch.rs
@@ -1,4 +1,5 @@
-use crate::utils::{last_path_segment, span_lint_and_help};
+use crate::utils::last_path_segment;
+use clippy_utils::diagnostics::span_lint_and_help;
 use rustc_hir::{
     intravisit, Body, Expr, ExprKind, FieldPat, FnDecl, HirId, LocalSource, MatchSource, Mutability, Pat, PatKind,
     QPath, Stmt, StmtKind,
diff --git a/clippy_lints/src/precedence.rs b/clippy_lints/src/precedence.rs
index fbe54e92ab9..9cf00c953b9 100644
--- a/clippy_lints/src/precedence.rs
+++ b/clippy_lints/src/precedence.rs
@@ -1,4 +1,4 @@
-use crate::utils::span_lint_and_sugg;
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use if_chain::if_chain;
 use rustc_ast::ast::{BinOpKind, Expr, ExprKind, LitKind, UnOp};
diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs
index bfe8bf33f51..779eddcc170 100644
--- a/clippy_lints/src/ptr.rs
+++ b/clippy_lints/src/ptr.rs
@@ -1,7 +1,8 @@
 //! Checks for usage of  `&Vec[_]` and `&String`.
 
 use crate::utils::ptr::get_spans;
-use crate::utils::{is_allowed, match_qpath, paths, span_lint, span_lint_and_sugg, span_lint_and_then};
+use crate::utils::{is_allowed, match_qpath, paths};
+use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::{is_type_diagnostic_item, match_type, walk_ptrs_hir_ty};
 use if_chain::if_chain;
diff --git a/clippy_lints/src/ptr_eq.rs b/clippy_lints/src/ptr_eq.rs
index 4f83e370c5f..82408c639b1 100644
--- a/clippy_lints/src/ptr_eq.rs
+++ b/clippy_lints/src/ptr_eq.rs
@@ -1,4 +1,5 @@
 use crate::utils;
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_opt;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
@@ -58,7 +59,7 @@ impl LateLintPass<'_> for PtrEq {
                     if let Some(left_snip) = snippet_opt(cx, left_var.span);
                     if let Some(right_snip) = snippet_opt(cx, right_var.span);
                     then {
-                        utils::span_lint_and_sugg(
+                        span_lint_and_sugg(
                             cx,
                             PTR_EQ,
                             expr.span,
diff --git a/clippy_lints/src/ptr_offset_with_cast.rs b/clippy_lints/src/ptr_offset_with_cast.rs
index b801defeb24..c04b4255256 100644
--- a/clippy_lints/src/ptr_offset_with_cast.rs
+++ b/clippy_lints/src/ptr_offset_with_cast.rs
@@ -1,4 +1,4 @@
-use crate::utils::{span_lint, span_lint_and_sugg};
+use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg};
 use clippy_utils::source::snippet_opt;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
diff --git a/clippy_lints/src/question_mark.rs b/clippy_lints/src/question_mark.rs
index 43431425a43..c4686623487 100644
--- a/clippy_lints/src/question_mark.rs
+++ b/clippy_lints/src/question_mark.rs
@@ -9,7 +9,8 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::sym;
 
 use crate::utils::sugg::Sugg;
-use crate::utils::{eq_expr_value, match_def_path, match_qpath, paths, span_lint_and_sugg};
+use crate::utils::{eq_expr_value, match_def_path, match_qpath, paths};
+use clippy_utils::diagnostics::span_lint_and_sugg;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for expressions that could be replaced by the question mark operator.
diff --git a/clippy_lints/src/ranges.rs b/clippy_lints/src/ranges.rs
index 3ce8949bf8b..d476d95256f 100644
--- a/clippy_lints/src/ranges.rs
+++ b/clippy_lints/src/ranges.rs
@@ -1,4 +1,5 @@
 use crate::consts::{constant, Constant};
+use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::{snippet, snippet_opt, snippet_with_applicability};
 use if_chain::if_chain;
 use rustc_ast::ast::RangeLimits;
@@ -14,10 +15,7 @@ use rustc_span::symbol::Ident;
 use std::cmp::Ordering;
 
 use crate::utils::sugg::Sugg;
-use crate::utils::{
-    get_parent_expr, in_constant, is_integer_const, meets_msrv, single_segment_path, span_lint, span_lint_and_sugg,
-    span_lint_and_then,
-};
+use crate::utils::{get_parent_expr, in_constant, is_integer_const, meets_msrv, single_segment_path};
 use crate::utils::{higher, SpanlessEq};
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/redundant_clone.rs b/clippy_lints/src/redundant_clone.rs
index 84723acd034..3d799328bb5 100644
--- a/clippy_lints/src/redundant_clone.rs
+++ b/clippy_lints/src/redundant_clone.rs
@@ -1,4 +1,5 @@
-use crate::utils::{fn_has_unsatisfiable_preds, match_def_path, paths, span_lint_hir, span_lint_hir_and_then};
+use crate::utils::{fn_has_unsatisfiable_preds, match_def_path, paths};
+use clippy_utils::diagnostics::{span_lint_hir, span_lint_hir_and_then};
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::{has_drop, is_copy, is_type_diagnostic_item, walk_ptrs_ty_depth};
 use if_chain::if_chain;
diff --git a/clippy_lints/src/redundant_closure_call.rs b/clippy_lints/src/redundant_closure_call.rs
index 283e25553cf..2977a108d14 100644
--- a/clippy_lints/src/redundant_closure_call.rs
+++ b/clippy_lints/src/redundant_closure_call.rs
@@ -1,4 +1,4 @@
-use crate::utils::{span_lint, span_lint_and_then};
+use clippy_utils::diagnostics::{span_lint, span_lint_and_then};
 use clippy_utils::source::snippet_with_applicability;
 use if_chain::if_chain;
 use rustc_ast::ast;
diff --git a/clippy_lints/src/redundant_else.rs b/clippy_lints/src/redundant_else.rs
index 3d585cd27a3..061526c6f09 100644
--- a/clippy_lints/src/redundant_else.rs
+++ b/clippy_lints/src/redundant_else.rs
@@ -1,4 +1,4 @@
-use crate::utils::span_lint_and_help;
+use clippy_utils::diagnostics::span_lint_and_help;
 use rustc_ast::ast::{Block, Expr, ExprKind, Stmt, StmtKind};
 use rustc_ast::visit::{walk_expr, Visitor};
 use rustc_lint::{EarlyContext, EarlyLintPass};
diff --git a/clippy_lints/src/redundant_field_names.rs b/clippy_lints/src/redundant_field_names.rs
index 38dcf7a192c..fd11150bce2 100644
--- a/clippy_lints/src/redundant_field_names.rs
+++ b/clippy_lints/src/redundant_field_names.rs
@@ -1,4 +1,5 @@
-use crate::utils::{meets_msrv, span_lint_and_sugg};
+use crate::utils::meets_msrv;
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use rustc_ast::ast::{Expr, ExprKind};
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass};
diff --git a/clippy_lints/src/redundant_pub_crate.rs b/clippy_lints/src/redundant_pub_crate.rs
index c876bae2303..e091095de13 100644
--- a/clippy_lints/src/redundant_pub_crate.rs
+++ b/clippy_lints/src/redundant_pub_crate.rs
@@ -1,4 +1,4 @@
-use crate::utils::span_lint_and_then;
+use clippy_utils::diagnostics::span_lint_and_then;
 use rustc_errors::Applicability;
 use rustc_hir::{Item, ItemKind, VisibilityKind};
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/redundant_slicing.rs b/clippy_lints/src/redundant_slicing.rs
index 85ea91a387b..6da7b5fbcc8 100644
--- a/clippy_lints/src/redundant_slicing.rs
+++ b/clippy_lints/src/redundant_slicing.rs
@@ -1,3 +1,4 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::is_type_lang_item;
 use if_chain::if_chain;
@@ -7,8 +8,6 @@ use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::{lint::in_external_macro, ty::TyS};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
-use crate::utils::span_lint_and_sugg;
-
 declare_clippy_lint! {
     /// **What it does:** Checks for redundant slicing expressions which use the full range, and
     /// do not change the type.
diff --git a/clippy_lints/src/redundant_static_lifetimes.rs b/clippy_lints/src/redundant_static_lifetimes.rs
index 1352a651723..da8339a795a 100644
--- a/clippy_lints/src/redundant_static_lifetimes.rs
+++ b/clippy_lints/src/redundant_static_lifetimes.rs
@@ -1,4 +1,5 @@
-use crate::utils::{meets_msrv, span_lint_and_then};
+use crate::utils::meets_msrv;
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet;
 use rustc_ast::ast::{Item, ItemKind, Ty, TyKind};
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/ref_option_ref.rs b/clippy_lints/src/ref_option_ref.rs
index cec6b06262b..452fef0694f 100644
--- a/clippy_lints/src/ref_option_ref.rs
+++ b/clippy_lints/src/ref_option_ref.rs
@@ -1,4 +1,5 @@
-use crate::utils::{last_path_segment, span_lint_and_sugg};
+use crate::utils::last_path_segment;
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/reference.rs b/clippy_lints/src/reference.rs
index 31e834ac174..ec2acb6a0ab 100644
--- a/clippy_lints/src/reference.rs
+++ b/clippy_lints/src/reference.rs
@@ -1,5 +1,6 @@
+use crate::utils::in_macro;
 use crate::utils::sugg::Sugg;
-use crate::utils::{in_macro, span_lint_and_sugg};
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::{snippet_opt, snippet_with_applicability};
 use if_chain::if_chain;
 use rustc_ast::ast::{Expr, ExprKind, Mutability, UnOp};
diff --git a/clippy_lints/src/regex.rs b/clippy_lints/src/regex.rs
index 1edea613148..bfa21ba9c97 100644
--- a/clippy_lints/src/regex.rs
+++ b/clippy_lints/src/regex.rs
@@ -1,5 +1,6 @@
 use crate::consts::{constant, Constant};
-use crate::utils::{match_def_path, paths, span_lint, span_lint_and_help};
+use crate::utils::{match_def_path, paths};
+use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
 use if_chain::if_chain;
 use rustc_ast::ast::{LitKind, StrStyle};
 use rustc_data_structures::fx::FxHashSet;
diff --git a/clippy_lints/src/repeat_once.rs b/clippy_lints/src/repeat_once.rs
index a88078c12a3..b39e9d5a78c 100644
--- a/clippy_lints/src/repeat_once.rs
+++ b/clippy_lints/src/repeat_once.rs
@@ -1,5 +1,6 @@
 use crate::consts::{constant_context, Constant};
-use crate::utils::{in_macro, span_lint_and_sugg};
+use crate::utils::in_macro;
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
index eb7fe403fd7..59d3c0ca5f0 100644
--- a/clippy_lints/src/returns.rs
+++ b/clippy_lints/src/returns.rs
@@ -1,3 +1,4 @@
+use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::snippet_opt;
 use if_chain::if_chain;
 use rustc_ast::ast::Attribute;
@@ -12,7 +13,7 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
 use rustc_span::sym;
 
-use crate::utils::{fn_def_id, in_macro, match_qpath, span_lint_and_sugg, span_lint_and_then};
+use crate::utils::{fn_def_id, in_macro, match_qpath};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for `let`-bindings, which are subsequently
diff --git a/clippy_lints/src/self_assignment.rs b/clippy_lints/src/self_assignment.rs
index e62b75de4ca..320d1a8dbe3 100644
--- a/clippy_lints/src/self_assignment.rs
+++ b/clippy_lints/src/self_assignment.rs
@@ -1,4 +1,5 @@
-use crate::utils::{eq_expr_value, span_lint};
+use crate::utils::eq_expr_value;
+use clippy_utils::diagnostics::span_lint;
 use clippy_utils::source::snippet;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/semicolon_if_nothing_returned.rs b/clippy_lints/src/semicolon_if_nothing_returned.rs
index 695d7233af2..e43947025b9 100644
--- a/clippy_lints/src/semicolon_if_nothing_returned.rs
+++ b/clippy_lints/src/semicolon_if_nothing_returned.rs
@@ -1,4 +1,5 @@
-use crate::utils::{in_macro, span_lint_and_sugg, sugg};
+use crate::utils::{in_macro, sugg};
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_macro_callsite;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/serde_api.rs b/clippy_lints/src/serde_api.rs
index 90cf1b6c861..632715852c5 100644
--- a/clippy_lints/src/serde_api.rs
+++ b/clippy_lints/src/serde_api.rs
@@ -1,4 +1,5 @@
-use crate::utils::{get_trait_def_id, paths, span_lint};
+use crate::utils::{get_trait_def_id, paths};
+use clippy_utils::diagnostics::span_lint;
 use rustc_hir::{Impl, Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
diff --git a/clippy_lints/src/shadow.rs b/clippy_lints/src/shadow.rs
index 4a8cacb31fd..8ef58b6d563 100644
--- a/clippy_lints/src/shadow.rs
+++ b/clippy_lints/src/shadow.rs
@@ -1,4 +1,5 @@
-use crate::utils::{contains_name, higher, iter_input_pats, span_lint_and_then};
+use crate::utils::{contains_name, higher, iter_input_pats};
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet;
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::{
diff --git a/clippy_lints/src/single_component_path_imports.rs b/clippy_lints/src/single_component_path_imports.rs
index 1fc4ff5c2e6..6d15a6c444e 100644
--- a/clippy_lints/src/single_component_path_imports.rs
+++ b/clippy_lints/src/single_component_path_imports.rs
@@ -1,4 +1,5 @@
-use crate::utils::{in_macro, span_lint_and_sugg};
+use crate::utils::in_macro;
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use if_chain::if_chain;
 use rustc_ast::{Item, ItemKind, UseTreeKind};
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/size_of_in_element_count.rs b/clippy_lints/src/size_of_in_element_count.rs
index 87e386baadc..8920d446b9c 100644
--- a/clippy_lints/src/size_of_in_element_count.rs
+++ b/clippy_lints/src/size_of_in_element_count.rs
@@ -1,7 +1,8 @@
 //! Lint on use of `size_of` or `size_of_val` of T in an expression
 //! expecting a count of T
 
-use crate::utils::{match_def_path, paths, span_lint_and_help};
+use crate::utils::{match_def_path, paths};
+use clippy_utils::diagnostics::span_lint_and_help;
 use if_chain::if_chain;
 use rustc_hir::BinOpKind;
 use rustc_hir::{Expr, ExprKind};
diff --git a/clippy_lints/src/slow_vector_initialization.rs b/clippy_lints/src/slow_vector_initialization.rs
index 96f6881556c..7f0f21084af 100644
--- a/clippy_lints/src/slow_vector_initialization.rs
+++ b/clippy_lints/src/slow_vector_initialization.rs
@@ -1,5 +1,6 @@
 use crate::utils::sugg::Sugg;
-use crate::utils::{get_enclosing_block, match_qpath, span_lint_and_then, SpanlessEq};
+use crate::utils::{get_enclosing_block, match_qpath, SpanlessEq};
+use clippy_utils::diagnostics::span_lint_and_then;
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/stable_sort_primitive.rs b/clippy_lints/src/stable_sort_primitive.rs
index 276a9338819..85e4bb806e7 100644
--- a/clippy_lints/src/stable_sort_primitive.rs
+++ b/clippy_lints/src/stable_sort_primitive.rs
@@ -1,4 +1,5 @@
-use crate::utils::{is_slice_of_primitives, span_lint_and_then, sugg::Sugg};
+use crate::utils::{is_slice_of_primitives, sugg::Sugg};
+use clippy_utils::diagnostics::span_lint_and_then;
 
 use if_chain::if_chain;
 
diff --git a/clippy_lints/src/strings.rs b/clippy_lints/src/strings.rs
index ce93ab23b2f..626166f9008 100644
--- a/clippy_lints/src/strings.rs
+++ b/clippy_lints/src/strings.rs
@@ -1,8 +1,6 @@
 use crate::utils::SpanlessEq;
-use crate::utils::{
-    get_parent_expr, is_allowed, match_function_call, method_calls, paths, span_lint, span_lint_and_help,
-    span_lint_and_sugg,
-};
+use crate::utils::{get_parent_expr, is_allowed, match_function_call, method_calls, paths};
+use clippy_utils::diagnostics::{span_lint, span_lint_and_help, span_lint_and_sugg};
 use clippy_utils::source::{snippet, snippet_with_applicability};
 use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
diff --git a/clippy_lints/src/suspicious_operation_groupings.rs b/clippy_lints/src/suspicious_operation_groupings.rs
index 3bdd9b7e4cb..364c99adc69 100644
--- a/clippy_lints/src/suspicious_operation_groupings.rs
+++ b/clippy_lints/src/suspicious_operation_groupings.rs
@@ -1,5 +1,5 @@
 use crate::utils::ast_utils::{eq_id, is_useless_with_eq_exprs, IdentIter};
-use crate::utils::span_lint_and_sugg;
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use core::ops::{Add, AddAssign};
 use if_chain::if_chain;
diff --git a/clippy_lints/src/suspicious_trait_impl.rs b/clippy_lints/src/suspicious_trait_impl.rs
index 0b7d08cb164..ef14b6c5136 100644
--- a/clippy_lints/src/suspicious_trait_impl.rs
+++ b/clippy_lints/src/suspicious_trait_impl.rs
@@ -1,4 +1,5 @@
-use crate::utils::{get_trait_def_id, span_lint, trait_ref_of_method};
+use crate::utils::{get_trait_def_id, trait_ref_of_method};
+use clippy_utils::diagnostics::span_lint;
 use if_chain::if_chain;
 use rustc_hir as hir;
 use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
diff --git a/clippy_lints/src/swap.rs b/clippy_lints/src/swap.rs
index d4a495f3ea9..83fe3c49959 100644
--- a/clippy_lints/src/swap.rs
+++ b/clippy_lints/src/swap.rs
@@ -1,5 +1,6 @@
 use crate::utils::sugg::Sugg;
-use crate::utils::{differing_macro_contexts, eq_expr_value, span_lint_and_then};
+use crate::utils::{differing_macro_contexts, eq_expr_value};
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
diff --git a/clippy_lints/src/tabs_in_doc_comments.rs b/clippy_lints/src/tabs_in_doc_comments.rs
index 74ccd9235de..88bd2feaadd 100644
--- a/clippy_lints/src/tabs_in_doc_comments.rs
+++ b/clippy_lints/src/tabs_in_doc_comments.rs
@@ -1,4 +1,4 @@
-use crate::utils::span_lint_and_sugg;
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use rustc_ast::ast;
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass};
diff --git a/clippy_lints/src/temporary_assignment.rs b/clippy_lints/src/temporary_assignment.rs
index fb891866364..75a13cb9187 100644
--- a/clippy_lints/src/temporary_assignment.rs
+++ b/clippy_lints/src/temporary_assignment.rs
@@ -1,4 +1,5 @@
-use crate::utils::{is_adjusted, span_lint};
+use crate::utils::is_adjusted;
+use clippy_utils::diagnostics::span_lint;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
diff --git a/clippy_lints/src/to_digit_is_some.rs b/clippy_lints/src/to_digit_is_some.rs
index 940273afc57..abc9b2fe88e 100644
--- a/clippy_lints/src/to_digit_is_some.rs
+++ b/clippy_lints/src/to_digit_is_some.rs
@@ -1,4 +1,5 @@
-use crate::utils::{match_def_path, span_lint_and_sugg};
+use crate::utils::match_def_path;
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/to_string_in_display.rs b/clippy_lints/src/to_string_in_display.rs
index 84ec2aa18ab..42605c01089 100644
--- a/clippy_lints/src/to_string_in_display.rs
+++ b/clippy_lints/src/to_string_in_display.rs
@@ -1,4 +1,5 @@
-use crate::utils::{is_diagnostic_assoc_item, match_def_path, path_to_local_id, paths, span_lint};
+use crate::utils::{is_diagnostic_assoc_item, match_def_path, path_to_local_id, paths};
+use clippy_utils::diagnostics::span_lint;
 use if_chain::if_chain;
 use rustc_hir::{Expr, ExprKind, HirId, Impl, ImplItem, ImplItemKind, Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/trait_bounds.rs b/clippy_lints/src/trait_bounds.rs
index d3314271c21..cfcc8da9910 100644
--- a/clippy_lints/src/trait_bounds.rs
+++ b/clippy_lints/src/trait_bounds.rs
@@ -1,4 +1,5 @@
-use crate::utils::{in_macro, span_lint_and_help, SpanlessHash};
+use crate::utils::{in_macro, SpanlessHash};
+use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::source::{snippet, snippet_with_applicability};
 use if_chain::if_chain;
 use rustc_data_structures::fx::FxHashMap;
diff --git a/clippy_lints/src/transmute/crosspointer_transmute.rs b/clippy_lints/src/transmute/crosspointer_transmute.rs
index ce87defaa94..25d0543c861 100644
--- a/clippy_lints/src/transmute/crosspointer_transmute.rs
+++ b/clippy_lints/src/transmute/crosspointer_transmute.rs
@@ -1,5 +1,5 @@
 use super::CROSSPOINTER_TRANSMUTE;
-use crate::utils::span_lint;
+use clippy_utils::diagnostics::span_lint;
 use rustc_hir::Expr;
 use rustc_lint::LateContext;
 use rustc_middle::ty::{self, Ty};
diff --git a/clippy_lints/src/transmute/transmute_float_to_int.rs b/clippy_lints/src/transmute/transmute_float_to_int.rs
index 562d880e39a..f61b5362b5a 100644
--- a/clippy_lints/src/transmute/transmute_float_to_int.rs
+++ b/clippy_lints/src/transmute/transmute_float_to_int.rs
@@ -1,5 +1,6 @@
 use super::TRANSMUTE_FLOAT_TO_INT;
-use crate::utils::{span_lint_and_then, sugg};
+use crate::utils::sugg;
+use clippy_utils::diagnostics::span_lint_and_then;
 use if_chain::if_chain;
 use rustc_ast as ast;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/transmute/transmute_int_to_bool.rs b/clippy_lints/src/transmute/transmute_int_to_bool.rs
index 5b609f906a3..ebdd1eba744 100644
--- a/clippy_lints/src/transmute/transmute_int_to_bool.rs
+++ b/clippy_lints/src/transmute/transmute_int_to_bool.rs
@@ -1,5 +1,6 @@
 use super::TRANSMUTE_INT_TO_BOOL;
-use crate::utils::{span_lint_and_then, sugg};
+use crate::utils::sugg;
+use clippy_utils::diagnostics::span_lint_and_then;
 use rustc_ast as ast;
 use rustc_errors::Applicability;
 use rustc_hir::Expr;
diff --git a/clippy_lints/src/transmute/transmute_int_to_char.rs b/clippy_lints/src/transmute/transmute_int_to_char.rs
index 29d2450618a..afecfc3d701 100644
--- a/clippy_lints/src/transmute/transmute_int_to_char.rs
+++ b/clippy_lints/src/transmute/transmute_int_to_char.rs
@@ -1,5 +1,6 @@
 use super::TRANSMUTE_INT_TO_CHAR;
-use crate::utils::{span_lint_and_then, sugg};
+use crate::utils::sugg;
+use clippy_utils::diagnostics::span_lint_and_then;
 use rustc_ast as ast;
 use rustc_errors::Applicability;
 use rustc_hir::Expr;
diff --git a/clippy_lints/src/transmute/transmute_int_to_float.rs b/clippy_lints/src/transmute/transmute_int_to_float.rs
index f83fba8966a..c762a7ab885 100644
--- a/clippy_lints/src/transmute/transmute_int_to_float.rs
+++ b/clippy_lints/src/transmute/transmute_int_to_float.rs
@@ -1,5 +1,6 @@
 use super::TRANSMUTE_INT_TO_FLOAT;
-use crate::utils::{span_lint_and_then, sugg};
+use crate::utils::sugg;
+use clippy_utils::diagnostics::span_lint_and_then;
 use rustc_errors::Applicability;
 use rustc_hir::Expr;
 use rustc_lint::LateContext;
diff --git a/clippy_lints/src/transmute/transmute_ptr_to_ptr.rs b/clippy_lints/src/transmute/transmute_ptr_to_ptr.rs
index f4e60a3020c..820c56a215e 100644
--- a/clippy_lints/src/transmute/transmute_ptr_to_ptr.rs
+++ b/clippy_lints/src/transmute/transmute_ptr_to_ptr.rs
@@ -1,5 +1,6 @@
 use super::TRANSMUTE_PTR_TO_PTR;
-use crate::utils::{span_lint_and_then, sugg};
+use crate::utils::sugg;
+use clippy_utils::diagnostics::span_lint_and_then;
 use rustc_errors::Applicability;
 use rustc_hir::Expr;
 use rustc_lint::LateContext;
diff --git a/clippy_lints/src/transmute/transmute_ptr_to_ref.rs b/clippy_lints/src/transmute/transmute_ptr_to_ref.rs
index f5dbbbe33bc..049210e555c 100644
--- a/clippy_lints/src/transmute/transmute_ptr_to_ref.rs
+++ b/clippy_lints/src/transmute/transmute_ptr_to_ref.rs
@@ -1,6 +1,7 @@
 use super::utils::get_type_snippet;
 use super::TRANSMUTE_PTR_TO_REF;
-use crate::utils::{span_lint_and_then, sugg};
+use crate::utils::sugg;
+use clippy_utils::diagnostics::span_lint_and_then;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, Mutability, QPath};
 use rustc_lint::LateContext;
diff --git a/clippy_lints/src/transmute/transmute_ref_to_ref.rs b/clippy_lints/src/transmute/transmute_ref_to_ref.rs
index 4780eb9b14e..993ef8698f8 100644
--- a/clippy_lints/src/transmute/transmute_ref_to_ref.rs
+++ b/clippy_lints/src/transmute/transmute_ref_to_ref.rs
@@ -1,5 +1,6 @@
 use super::{TRANSMUTE_BYTES_TO_STR, TRANSMUTE_PTR_TO_PTR};
-use crate::utils::{span_lint_and_sugg, span_lint_and_then, sugg};
+use crate::utils::sugg;
+use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::snippet;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/transmute/transmutes_expressible_as_ptr_casts.rs b/clippy_lints/src/transmute/transmutes_expressible_as_ptr_casts.rs
index dea896622f1..da7d1016d97 100644
--- a/clippy_lints/src/transmute/transmutes_expressible_as_ptr_casts.rs
+++ b/clippy_lints/src/transmute/transmutes_expressible_as_ptr_casts.rs
@@ -1,6 +1,7 @@
 use super::utils::can_be_expressed_as_pointer_cast;
 use super::TRANSMUTES_EXPRESSIBLE_AS_PTR_CASTS;
-use crate::utils::{span_lint_and_then, sugg};
+use crate::utils::sugg;
+use clippy_utils::diagnostics::span_lint_and_then;
 use rustc_errors::Applicability;
 use rustc_hir::Expr;
 use rustc_lint::LateContext;
diff --git a/clippy_lints/src/transmute/unsound_collection_transmute.rs b/clippy_lints/src/transmute/unsound_collection_transmute.rs
index 503c5e0ff38..9bea88be7da 100644
--- a/clippy_lints/src/transmute/unsound_collection_transmute.rs
+++ b/clippy_lints/src/transmute/unsound_collection_transmute.rs
@@ -1,6 +1,7 @@
 use super::utils::is_layout_incompatible;
 use super::UNSOUND_COLLECTION_TRANSMUTE;
-use crate::utils::{match_def_path, paths, span_lint};
+use crate::utils::{match_def_path, paths};
+use clippy_utils::diagnostics::span_lint;
 use rustc_hir::Expr;
 use rustc_lint::LateContext;
 use rustc_middle::ty::{self, Ty};
diff --git a/clippy_lints/src/transmute/useless_transmute.rs b/clippy_lints/src/transmute/useless_transmute.rs
index 83441514af0..29ffe03b673 100644
--- a/clippy_lints/src/transmute/useless_transmute.rs
+++ b/clippy_lints/src/transmute/useless_transmute.rs
@@ -1,5 +1,6 @@
 use super::USELESS_TRANSMUTE;
-use crate::utils::{span_lint, span_lint_and_then, sugg};
+use crate::utils::sugg;
+use clippy_utils::diagnostics::{span_lint, span_lint_and_then};
 use rustc_errors::Applicability;
 use rustc_hir::Expr;
 use rustc_lint::LateContext;
diff --git a/clippy_lints/src/transmute/wrong_transmute.rs b/clippy_lints/src/transmute/wrong_transmute.rs
index d6d77f2c834..2118f3d6950 100644
--- a/clippy_lints/src/transmute/wrong_transmute.rs
+++ b/clippy_lints/src/transmute/wrong_transmute.rs
@@ -1,5 +1,5 @@
 use super::WRONG_TRANSMUTE;
-use crate::utils::span_lint;
+use clippy_utils::diagnostics::span_lint;
 use rustc_hir::Expr;
 use rustc_lint::LateContext;
 use rustc_middle::ty::{self, Ty};
diff --git a/clippy_lints/src/transmuting_null.rs b/clippy_lints/src/transmuting_null.rs
index 2ba2b646f00..3a2b1359a54 100644
--- a/clippy_lints/src/transmuting_null.rs
+++ b/clippy_lints/src/transmuting_null.rs
@@ -1,5 +1,6 @@
 use crate::consts::{constant_context, Constant};
-use crate::utils::{match_qpath, paths, span_lint};
+use crate::utils::{match_qpath, paths};
+use clippy_utils::diagnostics::span_lint;
 use if_chain::if_chain;
 use rustc_ast::LitKind;
 use rustc_hir::{Expr, ExprKind};
diff --git a/clippy_lints/src/try_err.rs b/clippy_lints/src/try_err.rs
index e356add8e9d..1fce03b4f47 100644
--- a/clippy_lints/src/try_err.rs
+++ b/clippy_lints/src/try_err.rs
@@ -1,4 +1,5 @@
-use crate::utils::{differing_macro_contexts, in_macro, match_def_path, match_qpath, paths, span_lint_and_sugg};
+use crate::utils::{differing_macro_contexts, in_macro, match_def_path, match_qpath, paths};
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::{snippet, snippet_with_macro_callsite};
 use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
diff --git a/clippy_lints/src/types/borrowed_box.rs b/clippy_lints/src/types/borrowed_box.rs
index 01aeea7a67f..eab81b1e246 100644
--- a/clippy_lints/src/types/borrowed_box.rs
+++ b/clippy_lints/src/types/borrowed_box.rs
@@ -1,4 +1,5 @@
-use crate::utils::{match_path, paths, span_lint_and_sugg};
+use crate::utils::{match_path, paths};
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/types/box_vec.rs b/clippy_lints/src/types/box_vec.rs
index 6aa98e435e1..6d04a47a5c8 100644
--- a/clippy_lints/src/types/box_vec.rs
+++ b/clippy_lints/src/types/box_vec.rs
@@ -1,8 +1,9 @@
+use clippy_utils::diagnostics::span_lint_and_help;
 use rustc_hir::{self as hir, def_id::DefId, QPath};
 use rustc_lint::LateContext;
 use rustc_span::symbol::sym;
 
-use crate::utils::{is_ty_param_diagnostic_item, span_lint_and_help};
+use crate::utils::is_ty_param_diagnostic_item;
 
 use super::BOX_VEC;
 
diff --git a/clippy_lints/src/types/linked_list.rs b/clippy_lints/src/types/linked_list.rs
index 47eb4ede4e4..e9e1995f6a5 100644
--- a/clippy_lints/src/types/linked_list.rs
+++ b/clippy_lints/src/types/linked_list.rs
@@ -1,7 +1,8 @@
+use clippy_utils::diagnostics::span_lint_and_help;
 use rustc_hir::{self as hir, def_id::DefId};
 use rustc_lint::LateContext;
 
-use crate::utils::{match_def_path, paths, span_lint_and_help};
+use crate::utils::{match_def_path, paths};
 
 use super::LINKEDLIST;
 
diff --git a/clippy_lints/src/types/mod.rs b/clippy_lints/src/types/mod.rs
index 279a971318c..ac4fe502a7a 100644
--- a/clippy_lints/src/types/mod.rs
+++ b/clippy_lints/src/types/mod.rs
@@ -13,6 +13,7 @@ use std::borrow::Cow;
 use std::cmp::Ordering;
 use std::collections::BTreeMap;
 
+use clippy_utils::diagnostics::{multispan_sugg, span_lint, span_lint_and_help, span_lint_and_then};
 use clippy_utils::source::{indent_of, reindent_multiline, snippet, snippet_opt, snippet_with_macro_callsite};
 use clippy_utils::ty::{is_isize_or_usize, is_type_diagnostic_item};
 use if_chain::if_chain;
@@ -38,10 +39,7 @@ use rustc_typeck::hir_ty_to_ty;
 
 use crate::consts::{constant, Constant};
 use crate::utils::paths;
-use crate::utils::{
-    clip, comparisons, differing_macro_contexts, higher, int_bits, match_path, multispan_sugg, sext, span_lint,
-    span_lint_and_help, span_lint_and_then, unsext,
-};
+use crate::utils::{clip, comparisons, differing_macro_contexts, higher, int_bits, match_path, sext, unsext};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for use of `Box<Vec<_>>` anywhere in the code.
diff --git a/clippy_lints/src/types/option_option.rs b/clippy_lints/src/types/option_option.rs
index dc5db963b4e..79c5a32de2c 100644
--- a/clippy_lints/src/types/option_option.rs
+++ b/clippy_lints/src/types/option_option.rs
@@ -1,8 +1,9 @@
+use clippy_utils::diagnostics::span_lint;
 use rustc_hir::{self as hir, def_id::DefId, QPath};
 use rustc_lint::LateContext;
 use rustc_span::symbol::sym;
 
-use crate::utils::{is_ty_param_diagnostic_item, span_lint};
+use crate::utils::is_ty_param_diagnostic_item;
 
 use super::OPTION_OPTION;
 
diff --git a/clippy_lints/src/types/rc_buffer.rs b/clippy_lints/src/types/rc_buffer.rs
index 0ace1807535..d5fc23f2e39 100644
--- a/clippy_lints/src/types/rc_buffer.rs
+++ b/clippy_lints/src/types/rc_buffer.rs
@@ -1,10 +1,11 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use rustc_errors::Applicability;
 use rustc_hir::{self as hir, def_id::DefId, QPath, TyKind};
 use rustc_lint::LateContext;
 use rustc_span::symbol::sym;
 
-use crate::utils::{get_qpath_generic_tys, is_ty_param_diagnostic_item, span_lint_and_sugg};
+use crate::utils::{get_qpath_generic_tys, is_ty_param_diagnostic_item};
 
 use super::RC_BUFFER;
 
diff --git a/clippy_lints/src/types/redundant_allocation.rs b/clippy_lints/src/types/redundant_allocation.rs
index c6f6a2f6564..71c014f96f7 100644
--- a/clippy_lints/src/types/redundant_allocation.rs
+++ b/clippy_lints/src/types/redundant_allocation.rs
@@ -1,10 +1,11 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use rustc_errors::Applicability;
 use rustc_hir::{self as hir, def_id::DefId, LangItem, QPath, TyKind};
 use rustc_lint::LateContext;
 use rustc_span::symbol::sym;
 
-use crate::utils::{get_qpath_generic_tys, is_ty_param_diagnostic_item, is_ty_param_lang_item, span_lint_and_sugg};
+use crate::utils::{get_qpath_generic_tys, is_ty_param_diagnostic_item, is_ty_param_lang_item};
 
 use super::{utils, REDUNDANT_ALLOCATION};
 
diff --git a/clippy_lints/src/types/vec_box.rs b/clippy_lints/src/types/vec_box.rs
index 6f45442b9ba..8cedb0ede2b 100644
--- a/clippy_lints/src/types/vec_box.rs
+++ b/clippy_lints/src/types/vec_box.rs
@@ -1,3 +1,4 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
@@ -8,7 +9,7 @@ use rustc_span::symbol::sym;
 use rustc_target::abi::LayoutOf;
 use rustc_typeck::hir_ty_to_ty;
 
-use crate::utils::{last_path_segment, span_lint_and_sugg};
+use crate::utils::last_path_segment;
 
 use super::VEC_BOX;
 
diff --git a/clippy_lints/src/undropped_manually_drops.rs b/clippy_lints/src/undropped_manually_drops.rs
index 8c34ca16e6f..943573a2b53 100644
--- a/clippy_lints/src/undropped_manually_drops.rs
+++ b/clippy_lints/src/undropped_manually_drops.rs
@@ -1,4 +1,5 @@
-use crate::utils::{match_function_call, paths, span_lint_and_help};
+use crate::utils::{match_function_call, paths};
+use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::ty::is_type_lang_item;
 use rustc_hir::{lang_items, Expr};
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/unicode.rs b/clippy_lints/src/unicode.rs
index e44fec7ad8e..c37bbf297f8 100644
--- a/clippy_lints/src/unicode.rs
+++ b/clippy_lints/src/unicode.rs
@@ -1,4 +1,5 @@
-use crate::utils::{is_allowed, span_lint_and_sugg};
+use crate::utils::is_allowed;
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet;
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/unit_return_expecting_ord.rs b/clippy_lints/src/unit_return_expecting_ord.rs
index c6ae8b9b598..d0456347f8a 100644
--- a/clippy_lints/src/unit_return_expecting_ord.rs
+++ b/clippy_lints/src/unit_return_expecting_ord.rs
@@ -1,4 +1,5 @@
-use crate::utils::{get_trait_def_id, paths, span_lint, span_lint_and_help};
+use crate::utils::{get_trait_def_id, paths};
+use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
 use if_chain::if_chain;
 use rustc_hir::def_id::DefId;
 use rustc_hir::{Expr, ExprKind, StmtKind};
diff --git a/clippy_lints/src/unnamed_address.rs b/clippy_lints/src/unnamed_address.rs
index 9582c162e77..2c51a8556d9 100644
--- a/clippy_lints/src/unnamed_address.rs
+++ b/clippy_lints/src/unnamed_address.rs
@@ -1,4 +1,5 @@
-use crate::utils::{match_def_path, paths, span_lint, span_lint_and_help};
+use crate::utils::{match_def_path, paths};
+use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
 use if_chain::if_chain;
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/unnecessary_sort_by.rs b/clippy_lints/src/unnecessary_sort_by.rs
index 7e385b00646..aa83f6a74be 100644
--- a/clippy_lints/src/unnecessary_sort_by.rs
+++ b/clippy_lints/src/unnecessary_sort_by.rs
@@ -1,5 +1,5 @@
-use crate::utils;
 use crate::utils::sugg::Sugg;
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
@@ -233,7 +233,7 @@ fn expr_borrows(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
 impl LateLintPass<'_> for UnnecessarySortBy {
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
         match detect_lint(cx, expr) {
-            Some(LintTrigger::SortByKey(trigger)) => utils::span_lint_and_sugg(
+            Some(LintTrigger::SortByKey(trigger)) => span_lint_and_sugg(
                 cx,
                 UNNECESSARY_SORT_BY,
                 expr.span,
@@ -256,7 +256,7 @@ impl LateLintPass<'_> for UnnecessarySortBy {
                     Applicability::MachineApplicable
                 },
             ),
-            Some(LintTrigger::Sort(trigger)) => utils::span_lint_and_sugg(
+            Some(LintTrigger::Sort(trigger)) => span_lint_and_sugg(
                 cx,
                 UNNECESSARY_SORT_BY,
                 expr.span,
diff --git a/clippy_lints/src/unnecessary_wraps.rs b/clippy_lints/src/unnecessary_wraps.rs
index 01497de3211..cb20192b683 100644
--- a/clippy_lints/src/unnecessary_wraps.rs
+++ b/clippy_lints/src/unnecessary_wraps.rs
@@ -1,6 +1,5 @@
-use crate::utils::{
-    contains_return, in_macro, match_qpath, paths, return_ty, span_lint_and_then, visitors::find_all_ret_expressions,
-};
+use crate::utils::{contains_return, in_macro, match_qpath, paths, return_ty, visitors::find_all_ret_expressions};
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/unnested_or_patterns.rs b/clippy_lints/src/unnested_or_patterns.rs
index 7f4f16f8faf..42ff1809ff4 100644
--- a/clippy_lints/src/unnested_or_patterns.rs
+++ b/clippy_lints/src/unnested_or_patterns.rs
@@ -1,7 +1,8 @@
 #![allow(clippy::wildcard_imports, clippy::enum_glob_use)]
 
 use crate::utils::ast_utils::{eq_field_pat, eq_id, eq_pat, eq_path};
-use crate::utils::{over, span_lint_and_then};
+use crate::utils::over;
+use clippy_utils::diagnostics::span_lint_and_then;
 use rustc_ast::mut_visit::*;
 use rustc_ast::ptr::P;
 use rustc_ast::{self as ast, Pat, PatKind, PatKind::*, DUMMY_NODE_ID};
diff --git a/clippy_lints/src/unsafe_removed_from_name.rs b/clippy_lints/src/unsafe_removed_from_name.rs
index 154082a0fdb..16ad9d2dfd3 100644
--- a/clippy_lints/src/unsafe_removed_from_name.rs
+++ b/clippy_lints/src/unsafe_removed_from_name.rs
@@ -1,4 +1,4 @@
-use crate::utils::span_lint;
+use clippy_utils::diagnostics::span_lint;
 use rustc_ast::ast::{Item, ItemKind, UseTree, UseTreeKind};
 use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
diff --git a/clippy_lints/src/unused_io_amount.rs b/clippy_lints/src/unused_io_amount.rs
index 43166d26787..31fd61f99f2 100644
--- a/clippy_lints/src/unused_io_amount.rs
+++ b/clippy_lints/src/unused_io_amount.rs
@@ -1,4 +1,5 @@
-use crate::utils::{is_try, match_trait_method, paths, span_lint};
+use crate::utils::{is_try, match_trait_method, paths};
+use clippy_utils::diagnostics::span_lint;
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
diff --git a/clippy_lints/src/unused_self.rs b/clippy_lints/src/unused_self.rs
index 812482cf5cf..4642bf07c45 100644
--- a/clippy_lints/src/unused_self.rs
+++ b/clippy_lints/src/unused_self.rs
@@ -1,9 +1,9 @@
+use clippy_utils::diagnostics::span_lint_and_help;
 use if_chain::if_chain;
 use rustc_hir::{Impl, ImplItem, ImplItemKind, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
-use crate::utils::span_lint_and_help;
 use crate::utils::visitors::LocalUsedVisitor;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/unused_unit.rs b/clippy_lints/src/unused_unit.rs
index a90d26fc95c..c45b851211c 100644
--- a/clippy_lints/src/unused_unit.rs
+++ b/clippy_lints/src/unused_unit.rs
@@ -8,7 +8,7 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
 use rustc_span::BytePos;
 
-use crate::utils::span_lint_and_sugg;
+use clippy_utils::diagnostics::span_lint_and_sugg;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for unit (`()`) expressions that can be removed.
diff --git a/clippy_lints/src/unwrap.rs b/clippy_lints/src/unwrap.rs
index 43b5f138a42..75b2f2da602 100644
--- a/clippy_lints/src/unwrap.rs
+++ b/clippy_lints/src/unwrap.rs
@@ -1,4 +1,5 @@
-use crate::utils::{differing_macro_contexts, span_lint_and_then, usage::is_potentially_mutated};
+use crate::utils::{differing_macro_contexts, usage::is_potentially_mutated};
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
 use rustc_hir::intravisit::{walk_expr, walk_fn, FnKind, NestedVisitorMap, Visitor};
diff --git a/clippy_lints/src/unwrap_in_result.rs b/clippy_lints/src/unwrap_in_result.rs
index 6a8f8211566..a85f3ce5c9c 100644
--- a/clippy_lints/src/unwrap_in_result.rs
+++ b/clippy_lints/src/unwrap_in_result.rs
@@ -1,4 +1,5 @@
-use crate::utils::{method_chain_args, return_ty, span_lint_and_then};
+use crate::utils::{method_chain_args, return_ty};
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
 use rustc_hir as hir;
diff --git a/clippy_lints/src/upper_case_acronyms.rs b/clippy_lints/src/upper_case_acronyms.rs
index 0470e1dbbb8..7ce9aa13184 100644
--- a/clippy_lints/src/upper_case_acronyms.rs
+++ b/clippy_lints/src/upper_case_acronyms.rs
@@ -1,4 +1,4 @@
-use crate::utils::span_lint_and_sugg;
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use if_chain::if_chain;
 use itertools::Itertools;
 use rustc_ast::ast::{Item, ItemKind, Variant};
@@ -81,7 +81,7 @@ fn check_ident(cx: &EarlyContext<'_>, ident: &Ident, be_aggressive: bool) {
     // assume that two-letter words are some kind of valid abbreviation like FP for false positive
     // (and don't warn)
     if (ident.chars().all(|c| c.is_ascii_uppercase()) && ident.len() > 2)
-    // otherwise, warn if we have SOmeTHING lIKE THIs but only warn with the aggressive 
+    // otherwise, warn if we have SOmeTHING lIKE THIs but only warn with the aggressive
     // upper-case-acronyms-aggressive config option enabled
     || (be_aggressive && ident != &corrected)
     {
diff --git a/clippy_lints/src/use_self.rs b/clippy_lints/src/use_self.rs
index de7eb42d56d..9a42c833470 100644
--- a/clippy_lints/src/use_self.rs
+++ b/clippy_lints/src/use_self.rs
@@ -1,7 +1,7 @@
+use crate::utils::{in_macro, meets_msrv};
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_opt;
 use if_chain::if_chain;
-
-use crate::utils::{in_macro, meets_msrv, span_lint_and_sugg};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_hir::def::DefKind;
diff --git a/clippy_lints/src/useless_conversion.rs b/clippy_lints/src/useless_conversion.rs
index e6b4fde560f..1eb152daac8 100644
--- a/clippy_lints/src/useless_conversion.rs
+++ b/clippy_lints/src/useless_conversion.rs
@@ -1,7 +1,6 @@
 use crate::utils::sugg::Sugg;
-use crate::utils::{
-    get_parent_expr, match_def_path, match_trait_method, paths, span_lint_and_help, span_lint_and_sugg,
-};
+use crate::utils::{get_parent_expr, match_def_path, match_trait_method, paths};
+use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg};
 use clippy_utils::source::{snippet, snippet_with_macro_callsite};
 use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs
index 04b8d9ee2c7..a566362ae78 100644
--- a/clippy_lints/src/utils/internal_lints.rs
+++ b/clippy_lints/src/utils/internal_lints.rs
@@ -1,8 +1,7 @@
 use crate::consts::{constant_simple, Constant};
-use crate::utils::{
-    is_expn_of, match_def_path, match_qpath, method_calls, path_to_res, paths, run_lints, span_lint,
-    span_lint_and_help, span_lint_and_sugg, SpanlessEq,
-};
+use crate::utils::{is_expn_of, match_def_path, match_qpath, method_calls, path_to_res, paths, run_lints, SpanlessEq};
+
+use clippy_utils::diagnostics::{span_lint, span_lint_and_help, span_lint_and_sugg};
 use clippy_utils::source::snippet;
 use clippy_utils::ty::match_type;
 use if_chain::if_chain;
diff --git a/clippy_lints/src/vec.rs b/clippy_lints/src/vec.rs
index cd09a5b53e0..9e142413365 100644
--- a/clippy_lints/src/vec.rs
+++ b/clippy_lints/src/vec.rs
@@ -1,6 +1,7 @@
 use crate::consts::{constant, Constant};
 use crate::rustc_target::abi::LayoutOf;
-use crate::utils::{higher, span_lint_and_sugg};
+use crate::utils::higher;
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::is_copy;
 use if_chain::if_chain;
diff --git a/clippy_lints/src/vec_init_then_push.rs b/clippy_lints/src/vec_init_then_push.rs
index 4ad787ecf66..3ef55a82a17 100644
--- a/clippy_lints/src/vec_init_then_push.rs
+++ b/clippy_lints/src/vec_init_then_push.rs
@@ -1,4 +1,5 @@
-use crate::utils::{match_def_path, path_to_local, path_to_local_id, paths, span_lint_and_sugg};
+use crate::utils::{match_def_path, path_to_local, path_to_local_id, paths};
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
diff --git a/clippy_lints/src/vec_resize_to_zero.rs b/clippy_lints/src/vec_resize_to_zero.rs
index d2494b321ef..9a2fb1414a1 100644
--- a/clippy_lints/src/vec_resize_to_zero.rs
+++ b/clippy_lints/src/vec_resize_to_zero.rs
@@ -1,4 +1,4 @@
-use crate::utils::span_lint_and_then;
+use clippy_utils::diagnostics::span_lint_and_then;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
diff --git a/clippy_lints/src/verbose_file_reads.rs b/clippy_lints/src/verbose_file_reads.rs
index 079a4279c60..01dc54dc5fd 100644
--- a/clippy_lints/src/verbose_file_reads.rs
+++ b/clippy_lints/src/verbose_file_reads.rs
@@ -1,4 +1,5 @@
-use crate::utils::{paths, span_lint_and_help};
+use crate::utils::paths;
+use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::ty::match_type;
 use if_chain::if_chain;
 use rustc_hir::{Expr, ExprKind, QPath};
diff --git a/clippy_lints/src/wildcard_dependencies.rs b/clippy_lints/src/wildcard_dependencies.rs
index cd1864f461d..8f96b962279 100644
--- a/clippy_lints/src/wildcard_dependencies.rs
+++ b/clippy_lints/src/wildcard_dependencies.rs
@@ -1,4 +1,5 @@
-use crate::utils::{run_lints, span_lint};
+use crate::utils::run_lints;
+use clippy_utils::diagnostics::span_lint;
 use rustc_hir::{hir_id::CRATE_HIR_ID, Crate};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
diff --git a/clippy_lints/src/wildcard_imports.rs b/clippy_lints/src/wildcard_imports.rs
index e12ca49fd4c..424ca2a4c2f 100644
--- a/clippy_lints/src/wildcard_imports.rs
+++ b/clippy_lints/src/wildcard_imports.rs
@@ -1,4 +1,5 @@
-use crate::utils::{in_macro, span_lint_and_sugg};
+use crate::utils::in_macro;
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::{snippet, snippet_with_applicability};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs
index f2fef73a641..fd3e5a7ce91 100644
--- a/clippy_lints/src/write.rs
+++ b/clippy_lints/src/write.rs
@@ -1,7 +1,7 @@
 use std::borrow::Cow;
 use std::ops::Range;
 
-use crate::utils::{span_lint, span_lint_and_sugg, span_lint_and_then};
+use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::snippet_with_applicability;
 use if_chain::if_chain;
 use rustc_ast::ast::{Expr, ExprKind, ImplKind, Item, ItemKind, LitKind, MacCall, StrLit, StrStyle};
diff --git a/clippy_lints/src/zero_div_zero.rs b/clippy_lints/src/zero_div_zero.rs
index 11d96e15ff1..3b4890ad560 100644
--- a/clippy_lints/src/zero_div_zero.rs
+++ b/clippy_lints/src/zero_div_zero.rs
@@ -1,5 +1,5 @@
 use crate::consts::{constant_simple, Constant};
-use crate::utils::span_lint_and_help;
+use clippy_utils::diagnostics::span_lint_and_help;
 use if_chain::if_chain;
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/zero_sized_map_values.rs b/clippy_lints/src/zero_sized_map_values.rs
index ab27b60cfa4..82466da6862 100644
--- a/clippy_lints/src/zero_sized_map_values.rs
+++ b/clippy_lints/src/zero_sized_map_values.rs
@@ -1,3 +1,4 @@
+use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::ty::{is_normalizable, is_type_diagnostic_item, match_type};
 use if_chain::if_chain;
 use rustc_hir::{self as hir, HirId, ItemKind, Node};
@@ -8,7 +9,7 @@ use rustc_span::sym;
 use rustc_target::abi::LayoutOf as _;
 use rustc_typeck::hir_ty_to_ty;
 
-use crate::utils::{paths, span_lint_and_help};
+use crate::utils::paths;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for maps with zero-sized value types anywhere in the code.
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index d895d798b5e..d3cf2a34709 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -33,7 +33,7 @@ pub mod attrs;
 pub mod camel_case;
 pub mod comparisons;
 pub mod consts;
-mod diagnostics;
+pub mod diagnostics;
 pub mod eager_or_lazy;
 pub mod higher;
 mod hir_utils;
@@ -48,7 +48,6 @@ pub mod usage;
 pub mod visitors;
 
 pub use self::attrs::*;
-pub use self::diagnostics::*;
 pub use self::hir_utils::{both, eq_expr_value, over, SpanlessEq, SpanlessHash};
 
 use std::collections::hash_map::Entry;
-- 
cgit 1.4.1-3-g733a5


From ecbef77bd71c2a4b4ad8dbb0b0ffa67affe29cc3 Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Fri, 12 Mar 2021 12:04:44 +0900
Subject: Extract lints of unit_types group from types group

---
 clippy_lints/src/lib.rs            |  23 ++-
 clippy_lints/src/types/mod.rs      | 396 +-----------------------------------
 clippy_lints/src/unit_types/mod.rs | 398 +++++++++++++++++++++++++++++++++++++
 3 files changed, 415 insertions(+), 402 deletions(-)
 create mode 100644 clippy_lints/src/unit_types/mod.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 52c342d580e..f80aee182e2 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -350,6 +350,7 @@ mod types;
 mod undropped_manually_drops;
 mod unicode;
 mod unit_return_expecting_ord;
+mod unit_types;
 mod unnamed_address;
 mod unnecessary_sort_by;
 mod unnecessary_wraps;
@@ -960,20 +961,20 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &types::BOX_VEC,
         &types::IMPLICIT_HASHER,
         &types::INVALID_UPCAST_COMPARISONS,
-        &types::LET_UNIT_VALUE,
         &types::LINKEDLIST,
         &types::OPTION_OPTION,
         &types::RC_BUFFER,
         &types::REDUNDANT_ALLOCATION,
         &types::TYPE_COMPLEXITY,
-        &types::UNIT_ARG,
-        &types::UNIT_CMP,
         &types::VEC_BOX,
         &undropped_manually_drops::UNDROPPED_MANUALLY_DROPS,
         &unicode::INVISIBLE_CHARACTERS,
         &unicode::NON_ASCII_LITERAL,
         &unicode::UNICODE_NOT_NFC,
         &unit_return_expecting_ord::UNIT_RETURN_EXPECTING_ORD,
+        &unit_types::LET_UNIT_VALUE,
+        &unit_types::UNIT_ARG,
+        &unit_types::UNIT_CMP,
         &unnamed_address::FN_ADDRESS_COMPARISONS,
         &unnamed_address::VTABLE_ADDRESS_COMPARISONS,
         &unnecessary_sort_by::UNNECESSARY_SORT_BY,
@@ -1084,8 +1085,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box map_clone::MapClone);
     store.register_late_pass(|| box map_err_ignore::MapErrIgnore);
     store.register_late_pass(|| box shadow::Shadow);
-    store.register_late_pass(|| box types::LetUnitValue);
-    store.register_late_pass(|| box types::UnitCmp);
+    store.register_late_pass(|| box unit_types::LetUnitValue);
+    store.register_late_pass(|| box unit_types::UnitCmp);
     store.register_late_pass(|| box loops::Loops);
     store.register_late_pass(|| box main_recursion::MainRecursion::default());
     store.register_late_pass(|| box lifetimes::Lifetimes);
@@ -1160,7 +1161,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box useless_conversion::UselessConversion::default());
     store.register_late_pass(|| box types::ImplicitHasher);
     store.register_late_pass(|| box fallible_impl_from::FallibleImplFrom);
-    store.register_late_pass(|| box types::UnitArg);
+    store.register_late_pass(|| box unit_types::UnitArg);
     store.register_late_pass(|| box double_comparison::DoubleComparisons);
     store.register_late_pass(|| box question_mark::QuestionMark);
     store.register_early_pass(|| box suspicious_operation_groupings::SuspiciousOperationGroupings);
@@ -1415,11 +1416,11 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&trait_bounds::TYPE_REPETITION_IN_BOUNDS),
         LintId::of(&types::IMPLICIT_HASHER),
         LintId::of(&types::INVALID_UPCAST_COMPARISONS),
-        LintId::of(&types::LET_UNIT_VALUE),
         LintId::of(&types::LINKEDLIST),
         LintId::of(&types::OPTION_OPTION),
         LintId::of(&unicode::NON_ASCII_LITERAL),
         LintId::of(&unicode::UNICODE_NOT_NFC),
+        LintId::of(&unit_types::LET_UNIT_VALUE),
         LintId::of(&unnecessary_wraps::UNNECESSARY_WRAPS),
         LintId::of(&unnested_or_patterns::UNNESTED_OR_PATTERNS),
         LintId::of(&unused_self::UNUSED_SELF),
@@ -1708,12 +1709,12 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&types::BOX_VEC),
         LintId::of(&types::REDUNDANT_ALLOCATION),
         LintId::of(&types::TYPE_COMPLEXITY),
-        LintId::of(&types::UNIT_ARG),
-        LintId::of(&types::UNIT_CMP),
         LintId::of(&types::VEC_BOX),
         LintId::of(&undropped_manually_drops::UNDROPPED_MANUALLY_DROPS),
         LintId::of(&unicode::INVISIBLE_CHARACTERS),
         LintId::of(&unit_return_expecting_ord::UNIT_RETURN_EXPECTING_ORD),
+        LintId::of(&unit_types::UNIT_ARG),
+        LintId::of(&unit_types::UNIT_CMP),
         LintId::of(&unnamed_address::FN_ADDRESS_COMPARISONS),
         LintId::of(&unnamed_address::VTABLE_ADDRESS_COMPARISONS),
         LintId::of(&unnecessary_sort_by::UNNECESSARY_SORT_BY),
@@ -1934,8 +1935,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&transmute::TRANSMUTE_PTR_TO_REF),
         LintId::of(&types::BORROWED_BOX),
         LintId::of(&types::TYPE_COMPLEXITY),
-        LintId::of(&types::UNIT_ARG),
         LintId::of(&types::VEC_BOX),
+        LintId::of(&unit_types::UNIT_ARG),
         LintId::of(&unnecessary_sort_by::UNNECESSARY_SORT_BY),
         LintId::of(&unwrap::UNNECESSARY_UNWRAP),
         LintId::of(&useless_conversion::USELESS_CONVERSION),
@@ -2005,10 +2006,10 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&transmute::WRONG_TRANSMUTE),
         LintId::of(&transmuting_null::TRANSMUTING_NULL),
         LintId::of(&types::ABSURD_EXTREME_COMPARISONS),
-        LintId::of(&types::UNIT_CMP),
         LintId::of(&undropped_manually_drops::UNDROPPED_MANUALLY_DROPS),
         LintId::of(&unicode::INVISIBLE_CHARACTERS),
         LintId::of(&unit_return_expecting_ord::UNIT_RETURN_EXPECTING_ORD),
+        LintId::of(&unit_types::UNIT_CMP),
         LintId::of(&unnamed_address::FN_ADDRESS_COMPARISONS),
         LintId::of(&unnamed_address::VTABLE_ADDRESS_COMPARISONS),
         LintId::of(&unused_io_amount::UNUSED_IO_AMOUNT),
diff --git a/clippy_lints/src/types/mod.rs b/clippy_lints/src/types/mod.rs
index ac4fe502a7a..5103a259559 100644
--- a/clippy_lints/src/types/mod.rs
+++ b/clippy_lints/src/types/mod.rs
@@ -14,23 +14,21 @@ use std::cmp::Ordering;
 use std::collections::BTreeMap;
 
 use clippy_utils::diagnostics::{multispan_sugg, span_lint, span_lint_and_help, span_lint_and_then};
-use clippy_utils::source::{indent_of, reindent_multiline, snippet, snippet_opt, snippet_with_macro_callsite};
+use clippy_utils::source::{snippet, snippet_opt};
 use clippy_utils::ty::{is_isize_or_usize, is_type_diagnostic_item};
 use if_chain::if_chain;
-use rustc_errors::{Applicability, DiagnosticBuilder};
+use rustc_errors::DiagnosticBuilder;
 use rustc_hir as hir;
 use rustc_hir::intravisit::{walk_body, walk_expr, walk_ty, FnKind, NestedVisitorMap, Visitor};
 use rustc_hir::{
-    BinOpKind, Block, Body, Expr, ExprKind, FnDecl, FnRetTy, FnSig, GenericArg, GenericParamKind, HirId, ImplItem,
-    ImplItemKind, Item, ItemKind, Local, MatchSource, MutTy, Node, QPath, Stmt, StmtKind, TraitFn, TraitItem,
-    TraitItemKind, TyKind,
+    BinOpKind, Body, Expr, ExprKind, FnDecl, FnRetTy, FnSig, GenericArg, GenericParamKind, HirId, ImplItem,
+    ImplItemKind, Item, ItemKind, Local, MutTy, QPath, TraitFn, TraitItem, TraitItemKind, TyKind,
 };
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::hir::map::Map;
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::{self, IntTy, Ty, TyS, TypeckResults, UintTy};
 use rustc_session::{declare_lint_pass, declare_tool_lint, impl_lint_pass};
-use rustc_span::hygiene::{ExpnKind, MacroKind};
 use rustc_span::source_map::Span;
 use rustc_span::symbol::sym;
 use rustc_target::abi::LayoutOf;
@@ -39,7 +37,7 @@ use rustc_typeck::hir_ty_to_ty;
 
 use crate::consts::{constant, Constant};
 use crate::utils::paths;
-use crate::utils::{clip, comparisons, differing_macro_contexts, higher, int_bits, match_path, sext, unsext};
+use crate::utils::{clip, comparisons, differing_macro_contexts, int_bits, match_path, sext, unsext};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for use of `Box<Vec<_>>` anywhere in the code.
@@ -389,390 +387,6 @@ impl Types {
     }
 }
 
-declare_clippy_lint! {
-    /// **What it does:** Checks for binding a unit value.
-    ///
-    /// **Why is this bad?** A unit value cannot usefully be used anywhere. So
-    /// binding one is kind of pointless.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    /// ```rust
-    /// let x = {
-    ///     1;
-    /// };
-    /// ```
-    pub LET_UNIT_VALUE,
-    pedantic,
-    "creating a `let` binding to a value of unit type, which usually can't be used afterwards"
-}
-
-declare_lint_pass!(LetUnitValue => [LET_UNIT_VALUE]);
-
-impl<'tcx> LateLintPass<'tcx> for LetUnitValue {
-    fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) {
-        if let StmtKind::Local(ref local) = stmt.kind {
-            if is_unit(cx.typeck_results().pat_ty(&local.pat)) {
-                if in_external_macro(cx.sess(), stmt.span) || local.pat.span.from_expansion() {
-                    return;
-                }
-                if higher::is_from_for_desugar(local) {
-                    return;
-                }
-                span_lint_and_then(
-                    cx,
-                    LET_UNIT_VALUE,
-                    stmt.span,
-                    "this let-binding has unit value",
-                    |diag| {
-                        if let Some(expr) = &local.init {
-                            let snip = snippet_with_macro_callsite(cx, expr.span, "()");
-                            diag.span_suggestion(
-                                stmt.span,
-                                "omit the `let` binding",
-                                format!("{};", snip),
-                                Applicability::MachineApplicable, // snippet
-                            );
-                        }
-                    },
-                );
-            }
-        }
-    }
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for comparisons to unit. This includes all binary
-    /// comparisons (like `==` and `<`) and asserts.
-    ///
-    /// **Why is this bad?** Unit is always equal to itself, and thus is just a
-    /// clumsily written constant. Mostly this happens when someone accidentally
-    /// adds semicolons at the end of the operands.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    /// ```rust
-    /// # fn foo() {};
-    /// # fn bar() {};
-    /// # fn baz() {};
-    /// if {
-    ///     foo();
-    /// } == {
-    ///     bar();
-    /// } {
-    ///     baz();
-    /// }
-    /// ```
-    /// is equal to
-    /// ```rust
-    /// # fn foo() {};
-    /// # fn bar() {};
-    /// # fn baz() {};
-    /// {
-    ///     foo();
-    ///     bar();
-    ///     baz();
-    /// }
-    /// ```
-    ///
-    /// For asserts:
-    /// ```rust
-    /// # fn foo() {};
-    /// # fn bar() {};
-    /// assert_eq!({ foo(); }, { bar(); });
-    /// ```
-    /// will always succeed
-    pub UNIT_CMP,
-    correctness,
-    "comparing unit values"
-}
-
-declare_lint_pass!(UnitCmp => [UNIT_CMP]);
-
-impl<'tcx> LateLintPass<'tcx> for UnitCmp {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
-        if expr.span.from_expansion() {
-            if let Some(callee) = expr.span.source_callee() {
-                if let ExpnKind::Macro(MacroKind::Bang, symbol) = callee.kind {
-                    if let ExprKind::Binary(ref cmp, ref left, _) = expr.kind {
-                        let op = cmp.node;
-                        if op.is_comparison() && is_unit(cx.typeck_results().expr_ty(left)) {
-                            let result = match &*symbol.as_str() {
-                                "assert_eq" | "debug_assert_eq" => "succeed",
-                                "assert_ne" | "debug_assert_ne" => "fail",
-                                _ => return,
-                            };
-                            span_lint(
-                                cx,
-                                UNIT_CMP,
-                                expr.span,
-                                &format!(
-                                    "`{}` of unit values detected. This will always {}",
-                                    symbol.as_str(),
-                                    result
-                                ),
-                            );
-                        }
-                    }
-                }
-            }
-            return;
-        }
-        if let ExprKind::Binary(ref cmp, ref left, _) = expr.kind {
-            let op = cmp.node;
-            if op.is_comparison() && is_unit(cx.typeck_results().expr_ty(left)) {
-                let result = match op {
-                    BinOpKind::Eq | BinOpKind::Le | BinOpKind::Ge => "true",
-                    _ => "false",
-                };
-                span_lint(
-                    cx,
-                    UNIT_CMP,
-                    expr.span,
-                    &format!(
-                        "{}-comparison of unit values detected. This will always be {}",
-                        op.as_str(),
-                        result
-                    ),
-                );
-            }
-        }
-    }
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for passing a unit value as an argument to a function without using a
-    /// unit literal (`()`).
-    ///
-    /// **Why is this bad?** This is likely the result of an accidental semicolon.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    /// ```rust,ignore
-    /// foo({
-    ///     let a = bar();
-    ///     baz(a);
-    /// })
-    /// ```
-    pub UNIT_ARG,
-    complexity,
-    "passing unit to a function"
-}
-
-declare_lint_pass!(UnitArg => [UNIT_ARG]);
-
-impl<'tcx> LateLintPass<'tcx> for UnitArg {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if expr.span.from_expansion() {
-            return;
-        }
-
-        // apparently stuff in the desugaring of `?` can trigger this
-        // so check for that here
-        // only the calls to `Try::from_error` is marked as desugared,
-        // so we need to check both the current Expr and its parent.
-        if is_questionmark_desugar_marked_call(expr) {
-            return;
-        }
-        if_chain! {
-            let map = &cx.tcx.hir();
-            let opt_parent_node = map.find(map.get_parent_node(expr.hir_id));
-            if let Some(hir::Node::Expr(parent_expr)) = opt_parent_node;
-            if is_questionmark_desugar_marked_call(parent_expr);
-            then {
-                return;
-            }
-        }
-
-        match expr.kind {
-            ExprKind::Call(_, args) | ExprKind::MethodCall(_, _, args, _) => {
-                let args_to_recover = args
-                    .iter()
-                    .filter(|arg| {
-                        if is_unit(cx.typeck_results().expr_ty(arg)) && !is_unit_literal(arg) {
-                            !matches!(
-                                &arg.kind,
-                                ExprKind::Match(.., MatchSource::TryDesugar) | ExprKind::Path(..)
-                            )
-                        } else {
-                            false
-                        }
-                    })
-                    .collect::<Vec<_>>();
-                if !args_to_recover.is_empty() {
-                    lint_unit_args(cx, expr, &args_to_recover);
-                }
-            },
-            _ => (),
-        }
-    }
-}
-
-fn fmt_stmts_and_call(
-    cx: &LateContext<'_>,
-    call_expr: &Expr<'_>,
-    call_snippet: &str,
-    args_snippets: &[impl AsRef<str>],
-    non_empty_block_args_snippets: &[impl AsRef<str>],
-) -> String {
-    let call_expr_indent = indent_of(cx, call_expr.span).unwrap_or(0);
-    let call_snippet_with_replacements = args_snippets
-        .iter()
-        .fold(call_snippet.to_owned(), |acc, arg| acc.replacen(arg.as_ref(), "()", 1));
-
-    let mut stmts_and_call = non_empty_block_args_snippets
-        .iter()
-        .map(|it| it.as_ref().to_owned())
-        .collect::<Vec<_>>();
-    stmts_and_call.push(call_snippet_with_replacements);
-    stmts_and_call = stmts_and_call
-        .into_iter()
-        .map(|v| reindent_multiline(v.into(), true, Some(call_expr_indent)).into_owned())
-        .collect();
-
-    let mut stmts_and_call_snippet = stmts_and_call.join(&format!("{}{}", ";\n", " ".repeat(call_expr_indent)));
-    // expr is not in a block statement or result expression position, wrap in a block
-    let parent_node = cx.tcx.hir().find(cx.tcx.hir().get_parent_node(call_expr.hir_id));
-    if !matches!(parent_node, Some(Node::Block(_))) && !matches!(parent_node, Some(Node::Stmt(_))) {
-        let block_indent = call_expr_indent + 4;
-        stmts_and_call_snippet =
-            reindent_multiline(stmts_and_call_snippet.into(), true, Some(block_indent)).into_owned();
-        stmts_and_call_snippet = format!(
-            "{{\n{}{}\n{}}}",
-            " ".repeat(block_indent),
-            &stmts_and_call_snippet,
-            " ".repeat(call_expr_indent)
-        );
-    }
-    stmts_and_call_snippet
-}
-
-fn lint_unit_args(cx: &LateContext<'_>, expr: &Expr<'_>, args_to_recover: &[&Expr<'_>]) {
-    let mut applicability = Applicability::MachineApplicable;
-    let (singular, plural) = if args_to_recover.len() > 1 {
-        ("", "s")
-    } else {
-        ("a ", "")
-    };
-    span_lint_and_then(
-        cx,
-        UNIT_ARG,
-        expr.span,
-        &format!("passing {}unit value{} to a function", singular, plural),
-        |db| {
-            let mut or = "";
-            args_to_recover
-                .iter()
-                .filter_map(|arg| {
-                    if_chain! {
-                        if let ExprKind::Block(block, _) = arg.kind;
-                        if block.expr.is_none();
-                        if let Some(last_stmt) = block.stmts.iter().last();
-                        if let StmtKind::Semi(last_expr) = last_stmt.kind;
-                        if let Some(snip) = snippet_opt(cx, last_expr.span);
-                        then {
-                            Some((
-                                last_stmt.span,
-                                snip,
-                            ))
-                        }
-                        else {
-                            None
-                        }
-                    }
-                })
-                .for_each(|(span, sugg)| {
-                    db.span_suggestion(
-                        span,
-                        "remove the semicolon from the last statement in the block",
-                        sugg,
-                        Applicability::MaybeIncorrect,
-                    );
-                    or = "or ";
-                    applicability = Applicability::MaybeIncorrect;
-                });
-
-            let arg_snippets: Vec<String> = args_to_recover
-                .iter()
-                .filter_map(|arg| snippet_opt(cx, arg.span))
-                .collect();
-            let arg_snippets_without_empty_blocks: Vec<String> = args_to_recover
-                .iter()
-                .filter(|arg| !is_empty_block(arg))
-                .filter_map(|arg| snippet_opt(cx, arg.span))
-                .collect();
-
-            if let Some(call_snippet) = snippet_opt(cx, expr.span) {
-                let sugg = fmt_stmts_and_call(
-                    cx,
-                    expr,
-                    &call_snippet,
-                    &arg_snippets,
-                    &arg_snippets_without_empty_blocks,
-                );
-
-                if arg_snippets_without_empty_blocks.is_empty() {
-                    db.multipart_suggestion(
-                        &format!("use {}unit literal{} instead", singular, plural),
-                        args_to_recover
-                            .iter()
-                            .map(|arg| (arg.span, "()".to_string()))
-                            .collect::<Vec<_>>(),
-                        applicability,
-                    );
-                } else {
-                    let plural = arg_snippets_without_empty_blocks.len() > 1;
-                    let empty_or_s = if plural { "s" } else { "" };
-                    let it_or_them = if plural { "them" } else { "it" };
-                    db.span_suggestion(
-                        expr.span,
-                        &format!(
-                            "{}move the expression{} in front of the call and replace {} with the unit literal `()`",
-                            or, empty_or_s, it_or_them
-                        ),
-                        sugg,
-                        applicability,
-                    );
-                }
-            }
-        },
-    );
-}
-
-fn is_empty_block(expr: &Expr<'_>) -> bool {
-    matches!(
-        expr.kind,
-        ExprKind::Block(
-            Block {
-                stmts: &[],
-                expr: None,
-                ..
-            },
-            _,
-        )
-    )
-}
-
-fn is_questionmark_desugar_marked_call(expr: &Expr<'_>) -> bool {
-    use rustc_span::hygiene::DesugaringKind;
-    if let ExprKind::Call(ref callee, _) = expr.kind {
-        callee.span.is_desugaring(DesugaringKind::QuestionMark)
-    } else {
-        false
-    }
-}
-
-fn is_unit(ty: Ty<'_>) -> bool {
-    matches!(ty.kind(), ty::Tuple(slice) if slice.is_empty())
-}
-
-fn is_unit_literal(expr: &Expr<'_>) -> bool {
-    matches!(expr.kind, ExprKind::Tup(ref slice) if slice.is_empty())
-}
-
 declare_clippy_lint! {
     /// **What it does:** Checks for types used in structs, parameters and `let`
     /// declarations above a certain complexity threshold.
diff --git a/clippy_lints/src/unit_types/mod.rs b/clippy_lints/src/unit_types/mod.rs
new file mode 100644
index 00000000000..6450ef600ca
--- /dev/null
+++ b/clippy_lints/src/unit_types/mod.rs
@@ -0,0 +1,398 @@
+use rustc_errors::Applicability;
+use rustc_hir as hir;
+use rustc_hir::{BinOpKind, Block, Expr, ExprKind, MatchSource, Node, Stmt, StmtKind};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_middle::lint::in_external_macro;
+use rustc_middle::ty::{self, Ty};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::hygiene::{ExpnKind, MacroKind};
+
+use if_chain::if_chain;
+
+use crate::utils::diagnostics::{span_lint, span_lint_and_then};
+use crate::utils::higher;
+use crate::utils::source::{indent_of, reindent_multiline, snippet_opt, snippet_with_macro_callsite};
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for binding a unit value.
+    ///
+    /// **Why is this bad?** A unit value cannot usefully be used anywhere. So
+    /// binding one is kind of pointless.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// ```rust
+    /// let x = {
+    ///     1;
+    /// };
+    /// ```
+    pub LET_UNIT_VALUE,
+    pedantic,
+    "creating a `let` binding to a value of unit type, which usually can't be used afterwards"
+}
+
+declare_lint_pass!(LetUnitValue => [LET_UNIT_VALUE]);
+
+impl<'tcx> LateLintPass<'tcx> for LetUnitValue {
+    fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) {
+        if let StmtKind::Local(ref local) = stmt.kind {
+            if is_unit(cx.typeck_results().pat_ty(&local.pat)) {
+                if in_external_macro(cx.sess(), stmt.span) || local.pat.span.from_expansion() {
+                    return;
+                }
+                if higher::is_from_for_desugar(local) {
+                    return;
+                }
+                span_lint_and_then(
+                    cx,
+                    LET_UNIT_VALUE,
+                    stmt.span,
+                    "this let-binding has unit value",
+                    |diag| {
+                        if let Some(expr) = &local.init {
+                            let snip = snippet_with_macro_callsite(cx, expr.span, "()");
+                            diag.span_suggestion(
+                                stmt.span,
+                                "omit the `let` binding",
+                                format!("{};", snip),
+                                Applicability::MachineApplicable, // snippet
+                            );
+                        }
+                    },
+                );
+            }
+        }
+    }
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for comparisons to unit. This includes all binary
+    /// comparisons (like `==` and `<`) and asserts.
+    ///
+    /// **Why is this bad?** Unit is always equal to itself, and thus is just a
+    /// clumsily written constant. Mostly this happens when someone accidentally
+    /// adds semicolons at the end of the operands.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// ```rust
+    /// # fn foo() {};
+    /// # fn bar() {};
+    /// # fn baz() {};
+    /// if {
+    ///     foo();
+    /// } == {
+    ///     bar();
+    /// } {
+    ///     baz();
+    /// }
+    /// ```
+    /// is equal to
+    /// ```rust
+    /// # fn foo() {};
+    /// # fn bar() {};
+    /// # fn baz() {};
+    /// {
+    ///     foo();
+    ///     bar();
+    ///     baz();
+    /// }
+    /// ```
+    ///
+    /// For asserts:
+    /// ```rust
+    /// # fn foo() {};
+    /// # fn bar() {};
+    /// assert_eq!({ foo(); }, { bar(); });
+    /// ```
+    /// will always succeed
+    pub UNIT_CMP,
+    correctness,
+    "comparing unit values"
+}
+
+declare_lint_pass!(UnitCmp => [UNIT_CMP]);
+
+impl<'tcx> LateLintPass<'tcx> for UnitCmp {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
+        if expr.span.from_expansion() {
+            if let Some(callee) = expr.span.source_callee() {
+                if let ExpnKind::Macro(MacroKind::Bang, symbol) = callee.kind {
+                    if let ExprKind::Binary(ref cmp, ref left, _) = expr.kind {
+                        let op = cmp.node;
+                        if op.is_comparison() && is_unit(cx.typeck_results().expr_ty(left)) {
+                            let result = match &*symbol.as_str() {
+                                "assert_eq" | "debug_assert_eq" => "succeed",
+                                "assert_ne" | "debug_assert_ne" => "fail",
+                                _ => return,
+                            };
+                            span_lint(
+                                cx,
+                                UNIT_CMP,
+                                expr.span,
+                                &format!(
+                                    "`{}` of unit values detected. This will always {}",
+                                    symbol.as_str(),
+                                    result
+                                ),
+                            );
+                        }
+                    }
+                }
+            }
+            return;
+        }
+        if let ExprKind::Binary(ref cmp, ref left, _) = expr.kind {
+            let op = cmp.node;
+            if op.is_comparison() && is_unit(cx.typeck_results().expr_ty(left)) {
+                let result = match op {
+                    BinOpKind::Eq | BinOpKind::Le | BinOpKind::Ge => "true",
+                    _ => "false",
+                };
+                span_lint(
+                    cx,
+                    UNIT_CMP,
+                    expr.span,
+                    &format!(
+                        "{}-comparison of unit values detected. This will always be {}",
+                        op.as_str(),
+                        result
+                    ),
+                );
+            }
+        }
+    }
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for passing a unit value as an argument to a function without using a
+    /// unit literal (`()`).
+    ///
+    /// **Why is this bad?** This is likely the result of an accidental semicolon.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// ```rust,ignore
+    /// foo({
+    ///     let a = bar();
+    ///     baz(a);
+    /// })
+    /// ```
+    pub UNIT_ARG,
+    complexity,
+    "passing unit to a function"
+}
+
+declare_lint_pass!(UnitArg => [UNIT_ARG]);
+
+impl<'tcx> LateLintPass<'tcx> for UnitArg {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        if expr.span.from_expansion() {
+            return;
+        }
+
+        // apparently stuff in the desugaring of `?` can trigger this
+        // so check for that here
+        // only the calls to `Try::from_error` is marked as desugared,
+        // so we need to check both the current Expr and its parent.
+        if is_questionmark_desugar_marked_call(expr) {
+            return;
+        }
+        if_chain! {
+            let map = &cx.tcx.hir();
+            let opt_parent_node = map.find(map.get_parent_node(expr.hir_id));
+            if let Some(hir::Node::Expr(parent_expr)) = opt_parent_node;
+            if is_questionmark_desugar_marked_call(parent_expr);
+            then {
+                return;
+            }
+        }
+
+        match expr.kind {
+            ExprKind::Call(_, args) | ExprKind::MethodCall(_, _, args, _) => {
+                let args_to_recover = args
+                    .iter()
+                    .filter(|arg| {
+                        if is_unit(cx.typeck_results().expr_ty(arg)) && !is_unit_literal(arg) {
+                            !matches!(
+                                &arg.kind,
+                                ExprKind::Match(.., MatchSource::TryDesugar) | ExprKind::Path(..)
+                            )
+                        } else {
+                            false
+                        }
+                    })
+                    .collect::<Vec<_>>();
+                if !args_to_recover.is_empty() {
+                    lint_unit_args(cx, expr, &args_to_recover);
+                }
+            },
+            _ => (),
+        }
+    }
+}
+
+fn is_questionmark_desugar_marked_call(expr: &Expr<'_>) -> bool {
+    use rustc_span::hygiene::DesugaringKind;
+    if let ExprKind::Call(ref callee, _) = expr.kind {
+        callee.span.is_desugaring(DesugaringKind::QuestionMark)
+    } else {
+        false
+    }
+}
+
+fn is_unit(ty: Ty<'_>) -> bool {
+    matches!(ty.kind(), ty::Tuple(slice) if slice.is_empty())
+}
+
+fn is_unit_literal(expr: &Expr<'_>) -> bool {
+    matches!(expr.kind, ExprKind::Tup(ref slice) if slice.is_empty())
+}
+
+fn lint_unit_args(cx: &LateContext<'_>, expr: &Expr<'_>, args_to_recover: &[&Expr<'_>]) {
+    let mut applicability = Applicability::MachineApplicable;
+    let (singular, plural) = if args_to_recover.len() > 1 {
+        ("", "s")
+    } else {
+        ("a ", "")
+    };
+    span_lint_and_then(
+        cx,
+        UNIT_ARG,
+        expr.span,
+        &format!("passing {}unit value{} to a function", singular, plural),
+        |db| {
+            let mut or = "";
+            args_to_recover
+                .iter()
+                .filter_map(|arg| {
+                    if_chain! {
+                        if let ExprKind::Block(block, _) = arg.kind;
+                        if block.expr.is_none();
+                        if let Some(last_stmt) = block.stmts.iter().last();
+                        if let StmtKind::Semi(last_expr) = last_stmt.kind;
+                        if let Some(snip) = snippet_opt(cx, last_expr.span);
+                        then {
+                            Some((
+                                last_stmt.span,
+                                snip,
+                            ))
+                        }
+                        else {
+                            None
+                        }
+                    }
+                })
+                .for_each(|(span, sugg)| {
+                    db.span_suggestion(
+                        span,
+                        "remove the semicolon from the last statement in the block",
+                        sugg,
+                        Applicability::MaybeIncorrect,
+                    );
+                    or = "or ";
+                    applicability = Applicability::MaybeIncorrect;
+                });
+
+            let arg_snippets: Vec<String> = args_to_recover
+                .iter()
+                .filter_map(|arg| snippet_opt(cx, arg.span))
+                .collect();
+            let arg_snippets_without_empty_blocks: Vec<String> = args_to_recover
+                .iter()
+                .filter(|arg| !is_empty_block(arg))
+                .filter_map(|arg| snippet_opt(cx, arg.span))
+                .collect();
+
+            if let Some(call_snippet) = snippet_opt(cx, expr.span) {
+                let sugg = fmt_stmts_and_call(
+                    cx,
+                    expr,
+                    &call_snippet,
+                    &arg_snippets,
+                    &arg_snippets_without_empty_blocks,
+                );
+
+                if arg_snippets_without_empty_blocks.is_empty() {
+                    db.multipart_suggestion(
+                        &format!("use {}unit literal{} instead", singular, plural),
+                        args_to_recover
+                            .iter()
+                            .map(|arg| (arg.span, "()".to_string()))
+                            .collect::<Vec<_>>(),
+                        applicability,
+                    );
+                } else {
+                    let plural = arg_snippets_without_empty_blocks.len() > 1;
+                    let empty_or_s = if plural { "s" } else { "" };
+                    let it_or_them = if plural { "them" } else { "it" };
+                    db.span_suggestion(
+                        expr.span,
+                        &format!(
+                            "{}move the expression{} in front of the call and replace {} with the unit literal `()`",
+                            or, empty_or_s, it_or_them
+                        ),
+                        sugg,
+                        applicability,
+                    );
+                }
+            }
+        },
+    );
+}
+
+fn is_empty_block(expr: &Expr<'_>) -> bool {
+    matches!(
+        expr.kind,
+        ExprKind::Block(
+            Block {
+                stmts: &[],
+                expr: None,
+                ..
+            },
+            _,
+        )
+    )
+}
+
+fn fmt_stmts_and_call(
+    cx: &LateContext<'_>,
+    call_expr: &Expr<'_>,
+    call_snippet: &str,
+    args_snippets: &[impl AsRef<str>],
+    non_empty_block_args_snippets: &[impl AsRef<str>],
+) -> String {
+    let call_expr_indent = indent_of(cx, call_expr.span).unwrap_or(0);
+    let call_snippet_with_replacements = args_snippets
+        .iter()
+        .fold(call_snippet.to_owned(), |acc, arg| acc.replacen(arg.as_ref(), "()", 1));
+
+    let mut stmts_and_call = non_empty_block_args_snippets
+        .iter()
+        .map(|it| it.as_ref().to_owned())
+        .collect::<Vec<_>>();
+    stmts_and_call.push(call_snippet_with_replacements);
+    stmts_and_call = stmts_and_call
+        .into_iter()
+        .map(|v| reindent_multiline(v.into(), true, Some(call_expr_indent)).into_owned())
+        .collect();
+
+    let mut stmts_and_call_snippet = stmts_and_call.join(&format!("{}{}", ";\n", " ".repeat(call_expr_indent)));
+    // expr is not in a block statement or result expression position, wrap in a block
+    let parent_node = cx.tcx.hir().find(cx.tcx.hir().get_parent_node(call_expr.hir_id));
+    if !matches!(parent_node, Some(Node::Block(_))) && !matches!(parent_node, Some(Node::Stmt(_))) {
+        let block_indent = call_expr_indent + 4;
+        stmts_and_call_snippet =
+            reindent_multiline(stmts_and_call_snippet.into(), true, Some(block_indent)).into_owned();
+        stmts_and_call_snippet = format!(
+            "{{\n{}{}\n{}}}",
+            " ".repeat(block_indent),
+            &stmts_and_call_snippet,
+            " ".repeat(call_expr_indent)
+        );
+    }
+    stmts_and_call_snippet
+}
-- 
cgit 1.4.1-3-g733a5


From 37bffb7797ff7ffa65eeda3f936a1d45670c157b Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Fri, 12 Mar 2021 12:15:45 +0900
Subject: Extract utility functions to utils.rs

---
 clippy_lints/src/unit_types/mod.rs   | 13 ++++---------
 clippy_lints/src/unit_types/utils.rs | 10 ++++++++++
 2 files changed, 14 insertions(+), 9 deletions(-)
 create mode 100644 clippy_lints/src/unit_types/utils.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unit_types/mod.rs b/clippy_lints/src/unit_types/mod.rs
index 6450ef600ca..d71f9d7d24b 100644
--- a/clippy_lints/src/unit_types/mod.rs
+++ b/clippy_lints/src/unit_types/mod.rs
@@ -1,9 +1,10 @@
+mod utils;
+
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_hir::{BinOpKind, Block, Expr, ExprKind, MatchSource, Node, Stmt, StmtKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_middle::ty::{self, Ty};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::hygiene::{ExpnKind, MacroKind};
 
@@ -13,6 +14,8 @@ use crate::utils::diagnostics::{span_lint, span_lint_and_then};
 use crate::utils::higher;
 use crate::utils::source::{indent_of, reindent_multiline, snippet_opt, snippet_with_macro_callsite};
 
+use utils::{is_unit, is_unit_literal};
+
 declare_clippy_lint! {
     /// **What it does:** Checks for binding a unit value.
     ///
@@ -244,14 +247,6 @@ fn is_questionmark_desugar_marked_call(expr: &Expr<'_>) -> bool {
     }
 }
 
-fn is_unit(ty: Ty<'_>) -> bool {
-    matches!(ty.kind(), ty::Tuple(slice) if slice.is_empty())
-}
-
-fn is_unit_literal(expr: &Expr<'_>) -> bool {
-    matches!(expr.kind, ExprKind::Tup(ref slice) if slice.is_empty())
-}
-
 fn lint_unit_args(cx: &LateContext<'_>, expr: &Expr<'_>, args_to_recover: &[&Expr<'_>]) {
     let mut applicability = Applicability::MachineApplicable;
     let (singular, plural) = if args_to_recover.len() > 1 {
diff --git a/clippy_lints/src/unit_types/utils.rs b/clippy_lints/src/unit_types/utils.rs
new file mode 100644
index 00000000000..a15a7b812c5
--- /dev/null
+++ b/clippy_lints/src/unit_types/utils.rs
@@ -0,0 +1,10 @@
+use rustc_hir::{Expr, ExprKind};
+use rustc_middle::ty::{self, Ty};
+
+pub(super) fn is_unit(ty: Ty<'_>) -> bool {
+    matches!(ty.kind(), ty::Tuple(slice) if slice.is_empty())
+}
+
+pub(super) fn is_unit_literal(expr: &Expr<'_>) -> bool {
+    matches!(expr.kind, ExprKind::Tup(ref slice) if slice.is_empty())
+}
-- 
cgit 1.4.1-3-g733a5


From d17f54538f602480a10357f7677020190b9bac8e Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Fri, 12 Mar 2021 12:28:31 +0900
Subject: Move let_unit_value to its own module

---
 clippy_lints/src/lib.rs                       |  2 +-
 clippy_lints/src/unit_types/let_unit_value.rs | 40 +++++++++++++++++++++++++++
 clippy_lints/src/unit_types/mod.rs            | 39 ++++----------------------
 3 files changed, 47 insertions(+), 34 deletions(-)
 create mode 100644 clippy_lints/src/unit_types/let_unit_value.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index f80aee182e2..a8c4eb61a85 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1085,7 +1085,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box map_clone::MapClone);
     store.register_late_pass(|| box map_err_ignore::MapErrIgnore);
     store.register_late_pass(|| box shadow::Shadow);
-    store.register_late_pass(|| box unit_types::LetUnitValue);
+    store.register_late_pass(|| box unit_types::UnitTypes);
     store.register_late_pass(|| box unit_types::UnitCmp);
     store.register_late_pass(|| box loops::Loops);
     store.register_late_pass(|| box main_recursion::MainRecursion::default());
diff --git a/clippy_lints/src/unit_types/let_unit_value.rs b/clippy_lints/src/unit_types/let_unit_value.rs
new file mode 100644
index 00000000000..126f6aa746a
--- /dev/null
+++ b/clippy_lints/src/unit_types/let_unit_value.rs
@@ -0,0 +1,40 @@
+use rustc_errors::Applicability;
+use rustc_hir::{Stmt, StmtKind};
+use rustc_lint::{LateContext, LintContext};
+use rustc_middle::lint::in_external_macro;
+
+use crate::utils::diagnostics::span_lint_and_then;
+use crate::utils::higher;
+use crate::utils::source::snippet_with_macro_callsite;
+
+use super::{utils, LET_UNIT_VALUE};
+
+pub(super) fn check(cx: &LateContext<'_>, stmt: &Stmt<'_>) {
+    if let StmtKind::Local(ref local) = stmt.kind {
+        if utils::is_unit(cx.typeck_results().pat_ty(&local.pat)) {
+            if in_external_macro(cx.sess(), stmt.span) || local.pat.span.from_expansion() {
+                return;
+            }
+            if higher::is_from_for_desugar(local) {
+                return;
+            }
+            span_lint_and_then(
+                cx,
+                LET_UNIT_VALUE,
+                stmt.span,
+                "this let-binding has unit value",
+                |diag| {
+                    if let Some(expr) = &local.init {
+                        let snip = snippet_with_macro_callsite(cx, expr.span, "()");
+                        diag.span_suggestion(
+                            stmt.span,
+                            "omit the `let` binding",
+                            format!("{};", snip),
+                            Applicability::MachineApplicable, // snippet
+                        );
+                    }
+                },
+            );
+        }
+    }
+}
diff --git a/clippy_lints/src/unit_types/mod.rs b/clippy_lints/src/unit_types/mod.rs
index d71f9d7d24b..530c0fcf53d 100644
--- a/clippy_lints/src/unit_types/mod.rs
+++ b/clippy_lints/src/unit_types/mod.rs
@@ -1,18 +1,17 @@
+mod let_unit_value;
 mod utils;
 
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_hir::{BinOpKind, Block, Expr, ExprKind, MatchSource, Node, Stmt, StmtKind};
-use rustc_lint::{LateContext, LateLintPass, LintContext};
-use rustc_middle::lint::in_external_macro;
+use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::hygiene::{ExpnKind, MacroKind};
 
 use if_chain::if_chain;
 
 use crate::utils::diagnostics::{span_lint, span_lint_and_then};
-use crate::utils::higher;
-use crate::utils::source::{indent_of, reindent_multiline, snippet_opt, snippet_with_macro_callsite};
+use crate::utils::source::{indent_of, reindent_multiline, snippet_opt};
 
 use utils::{is_unit, is_unit_literal};
 
@@ -35,37 +34,11 @@ declare_clippy_lint! {
     "creating a `let` binding to a value of unit type, which usually can't be used afterwards"
 }
 
-declare_lint_pass!(LetUnitValue => [LET_UNIT_VALUE]);
+declare_lint_pass!(UnitTypes => [LET_UNIT_VALUE]);
 
-impl<'tcx> LateLintPass<'tcx> for LetUnitValue {
+impl<'tcx> LateLintPass<'tcx> for UnitTypes {
     fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) {
-        if let StmtKind::Local(ref local) = stmt.kind {
-            if is_unit(cx.typeck_results().pat_ty(&local.pat)) {
-                if in_external_macro(cx.sess(), stmt.span) || local.pat.span.from_expansion() {
-                    return;
-                }
-                if higher::is_from_for_desugar(local) {
-                    return;
-                }
-                span_lint_and_then(
-                    cx,
-                    LET_UNIT_VALUE,
-                    stmt.span,
-                    "this let-binding has unit value",
-                    |diag| {
-                        if let Some(expr) = &local.init {
-                            let snip = snippet_with_macro_callsite(cx, expr.span, "()");
-                            diag.span_suggestion(
-                                stmt.span,
-                                "omit the `let` binding",
-                                format!("{};", snip),
-                                Applicability::MachineApplicable, // snippet
-                            );
-                        }
-                    },
-                );
-            }
-        }
+        let_unit_value::check(cx, stmt);
     }
 }
 
-- 
cgit 1.4.1-3-g733a5


From 1bb221243b853856596241ff3c4210e80a114d34 Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Fri, 12 Mar 2021 12:38:31 +0900
Subject: Move unit_cmp to its own module

---
 clippy_lints/src/lib.rs                 |  1 -
 clippy_lints/src/unit_types/mod.rs      | 71 +++++----------------------------
 clippy_lints/src/unit_types/unit_cmp.rs | 57 ++++++++++++++++++++++++++
 3 files changed, 68 insertions(+), 61 deletions(-)
 create mode 100644 clippy_lints/src/unit_types/unit_cmp.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index a8c4eb61a85..c52c2ea80c5 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1086,7 +1086,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box map_err_ignore::MapErrIgnore);
     store.register_late_pass(|| box shadow::Shadow);
     store.register_late_pass(|| box unit_types::UnitTypes);
-    store.register_late_pass(|| box unit_types::UnitCmp);
     store.register_late_pass(|| box loops::Loops);
     store.register_late_pass(|| box main_recursion::MainRecursion::default());
     store.register_late_pass(|| box lifetimes::Lifetimes);
diff --git a/clippy_lints/src/unit_types/mod.rs b/clippy_lints/src/unit_types/mod.rs
index 530c0fcf53d..40cc9d9dbfb 100644
--- a/clippy_lints/src/unit_types/mod.rs
+++ b/clippy_lints/src/unit_types/mod.rs
@@ -1,16 +1,16 @@
 mod let_unit_value;
+mod unit_cmp;
 mod utils;
 
 use rustc_errors::Applicability;
 use rustc_hir as hir;
-use rustc_hir::{BinOpKind, Block, Expr, ExprKind, MatchSource, Node, Stmt, StmtKind};
+use rustc_hir::{Block, Expr, ExprKind, MatchSource, Node, Stmt, StmtKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::hygiene::{ExpnKind, MacroKind};
 
 use if_chain::if_chain;
 
-use crate::utils::diagnostics::{span_lint, span_lint_and_then};
+use crate::utils::diagnostics::span_lint_and_then;
 use crate::utils::source::{indent_of, reindent_multiline, snippet_opt};
 
 use utils::{is_unit, is_unit_literal};
@@ -34,14 +34,6 @@ declare_clippy_lint! {
     "creating a `let` binding to a value of unit type, which usually can't be used afterwards"
 }
 
-declare_lint_pass!(UnitTypes => [LET_UNIT_VALUE]);
-
-impl<'tcx> LateLintPass<'tcx> for UnitTypes {
-    fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) {
-        let_unit_value::check(cx, stmt);
-    }
-}
-
 declare_clippy_lint! {
     /// **What it does:** Checks for comparisons to unit. This includes all binary
     /// comparisons (like `==` and `<`) and asserts.
@@ -89,56 +81,15 @@ declare_clippy_lint! {
     "comparing unit values"
 }
 
-declare_lint_pass!(UnitCmp => [UNIT_CMP]);
+declare_lint_pass!(UnitTypes => [LET_UNIT_VALUE, UNIT_CMP]);
 
-impl<'tcx> LateLintPass<'tcx> for UnitCmp {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
-        if expr.span.from_expansion() {
-            if let Some(callee) = expr.span.source_callee() {
-                if let ExpnKind::Macro(MacroKind::Bang, symbol) = callee.kind {
-                    if let ExprKind::Binary(ref cmp, ref left, _) = expr.kind {
-                        let op = cmp.node;
-                        if op.is_comparison() && is_unit(cx.typeck_results().expr_ty(left)) {
-                            let result = match &*symbol.as_str() {
-                                "assert_eq" | "debug_assert_eq" => "succeed",
-                                "assert_ne" | "debug_assert_ne" => "fail",
-                                _ => return,
-                            };
-                            span_lint(
-                                cx,
-                                UNIT_CMP,
-                                expr.span,
-                                &format!(
-                                    "`{}` of unit values detected. This will always {}",
-                                    symbol.as_str(),
-                                    result
-                                ),
-                            );
-                        }
-                    }
-                }
-            }
-            return;
-        }
-        if let ExprKind::Binary(ref cmp, ref left, _) = expr.kind {
-            let op = cmp.node;
-            if op.is_comparison() && is_unit(cx.typeck_results().expr_ty(left)) {
-                let result = match op {
-                    BinOpKind::Eq | BinOpKind::Le | BinOpKind::Ge => "true",
-                    _ => "false",
-                };
-                span_lint(
-                    cx,
-                    UNIT_CMP,
-                    expr.span,
-                    &format!(
-                        "{}-comparison of unit values detected. This will always be {}",
-                        op.as_str(),
-                        result
-                    ),
-                );
-            }
-        }
+impl LateLintPass<'_> for UnitTypes {
+    fn check_stmt(&mut self, cx: &LateContext<'_>, stmt: &Stmt<'_>) {
+        let_unit_value::check(cx, stmt);
+    }
+
+    fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
+        unit_cmp::check(cx, expr);
     }
 }
 
diff --git a/clippy_lints/src/unit_types/unit_cmp.rs b/clippy_lints/src/unit_types/unit_cmp.rs
new file mode 100644
index 00000000000..e19fc1ec9ef
--- /dev/null
+++ b/clippy_lints/src/unit_types/unit_cmp.rs
@@ -0,0 +1,57 @@
+use rustc_hir::{BinOpKind, Expr, ExprKind};
+use rustc_lint::LateContext;
+use rustc_span::hygiene::{ExpnKind, MacroKind};
+
+use crate::utils::diagnostics::span_lint;
+
+use super::{utils, UNIT_CMP};
+
+pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>) {
+    if expr.span.from_expansion() {
+        if let Some(callee) = expr.span.source_callee() {
+            if let ExpnKind::Macro(MacroKind::Bang, symbol) = callee.kind {
+                if let ExprKind::Binary(ref cmp, ref left, _) = expr.kind {
+                    let op = cmp.node;
+                    if op.is_comparison() && utils::is_unit(cx.typeck_results().expr_ty(left)) {
+                        let result = match &*symbol.as_str() {
+                            "assert_eq" | "debug_assert_eq" => "succeed",
+                            "assert_ne" | "debug_assert_ne" => "fail",
+                            _ => return,
+                        };
+                        span_lint(
+                            cx,
+                            UNIT_CMP,
+                            expr.span,
+                            &format!(
+                                "`{}` of unit values detected. This will always {}",
+                                symbol.as_str(),
+                                result
+                            ),
+                        );
+                    }
+                }
+            }
+        }
+        return;
+    }
+
+    if let ExprKind::Binary(ref cmp, ref left, _) = expr.kind {
+        let op = cmp.node;
+        if op.is_comparison() && utils::is_unit(cx.typeck_results().expr_ty(left)) {
+            let result = match op {
+                BinOpKind::Eq | BinOpKind::Le | BinOpKind::Ge => "true",
+                _ => "false",
+            };
+            span_lint(
+                cx,
+                UNIT_CMP,
+                expr.span,
+                &format!(
+                    "{}-comparison of unit values detected. This will always be {}",
+                    op.as_str(),
+                    result
+                ),
+            );
+        }
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 6211b49ac1c9a013869943a003efbd5a71a73c93 Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Fri, 12 Mar 2021 12:47:21 +0900
Subject: Move unit_arg to its own module

---
 clippy_lints/src/lib.rs                 |   1 -
 clippy_lints/src/unit_types/mod.rs      | 228 ++------------------------------
 clippy_lints/src/unit_types/unit_arg.rs | 209 +++++++++++++++++++++++++++++
 3 files changed, 218 insertions(+), 220 deletions(-)
 create mode 100644 clippy_lints/src/unit_types/unit_arg.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index c52c2ea80c5..f479d756a33 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1160,7 +1160,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box useless_conversion::UselessConversion::default());
     store.register_late_pass(|| box types::ImplicitHasher);
     store.register_late_pass(|| box fallible_impl_from::FallibleImplFrom);
-    store.register_late_pass(|| box unit_types::UnitArg);
     store.register_late_pass(|| box double_comparison::DoubleComparisons);
     store.register_late_pass(|| box question_mark::QuestionMark);
     store.register_early_pass(|| box suspicious_operation_groupings::SuspiciousOperationGroupings);
diff --git a/clippy_lints/src/unit_types/mod.rs b/clippy_lints/src/unit_types/mod.rs
index 40cc9d9dbfb..64420a03933 100644
--- a/clippy_lints/src/unit_types/mod.rs
+++ b/clippy_lints/src/unit_types/mod.rs
@@ -1,20 +1,12 @@
 mod let_unit_value;
+mod unit_arg;
 mod unit_cmp;
 mod utils;
 
-use rustc_errors::Applicability;
-use rustc_hir as hir;
-use rustc_hir::{Block, Expr, ExprKind, MatchSource, Node, Stmt, StmtKind};
+use rustc_hir::{Expr, Stmt};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
-use if_chain::if_chain;
-
-use crate::utils::diagnostics::span_lint_and_then;
-use crate::utils::source::{indent_of, reindent_multiline, snippet_opt};
-
-use utils::{is_unit, is_unit_literal};
-
 declare_clippy_lint! {
     /// **What it does:** Checks for binding a unit value.
     ///
@@ -81,18 +73,6 @@ declare_clippy_lint! {
     "comparing unit values"
 }
 
-declare_lint_pass!(UnitTypes => [LET_UNIT_VALUE, UNIT_CMP]);
-
-impl LateLintPass<'_> for UnitTypes {
-    fn check_stmt(&mut self, cx: &LateContext<'_>, stmt: &Stmt<'_>) {
-        let_unit_value::check(cx, stmt);
-    }
-
-    fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
-        unit_cmp::check(cx, expr);
-    }
-}
-
 declare_clippy_lint! {
     /// **What it does:** Checks for passing a unit value as an argument to a function without using a
     /// unit literal (`()`).
@@ -113,205 +93,15 @@ declare_clippy_lint! {
     "passing unit to a function"
 }
 
-declare_lint_pass!(UnitArg => [UNIT_ARG]);
-
-impl<'tcx> LateLintPass<'tcx> for UnitArg {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if expr.span.from_expansion() {
-            return;
-        }
-
-        // apparently stuff in the desugaring of `?` can trigger this
-        // so check for that here
-        // only the calls to `Try::from_error` is marked as desugared,
-        // so we need to check both the current Expr and its parent.
-        if is_questionmark_desugar_marked_call(expr) {
-            return;
-        }
-        if_chain! {
-            let map = &cx.tcx.hir();
-            let opt_parent_node = map.find(map.get_parent_node(expr.hir_id));
-            if let Some(hir::Node::Expr(parent_expr)) = opt_parent_node;
-            if is_questionmark_desugar_marked_call(parent_expr);
-            then {
-                return;
-            }
-        }
-
-        match expr.kind {
-            ExprKind::Call(_, args) | ExprKind::MethodCall(_, _, args, _) => {
-                let args_to_recover = args
-                    .iter()
-                    .filter(|arg| {
-                        if is_unit(cx.typeck_results().expr_ty(arg)) && !is_unit_literal(arg) {
-                            !matches!(
-                                &arg.kind,
-                                ExprKind::Match(.., MatchSource::TryDesugar) | ExprKind::Path(..)
-                            )
-                        } else {
-                            false
-                        }
-                    })
-                    .collect::<Vec<_>>();
-                if !args_to_recover.is_empty() {
-                    lint_unit_args(cx, expr, &args_to_recover);
-                }
-            },
-            _ => (),
-        }
-    }
-}
+declare_lint_pass!(UnitTypes => [LET_UNIT_VALUE, UNIT_CMP, UNIT_ARG]);
 
-fn is_questionmark_desugar_marked_call(expr: &Expr<'_>) -> bool {
-    use rustc_span::hygiene::DesugaringKind;
-    if let ExprKind::Call(ref callee, _) = expr.kind {
-        callee.span.is_desugaring(DesugaringKind::QuestionMark)
-    } else {
-        false
+impl LateLintPass<'_> for UnitTypes {
+    fn check_stmt(&mut self, cx: &LateContext<'_>, stmt: &Stmt<'_>) {
+        let_unit_value::check(cx, stmt);
     }
-}
-
-fn lint_unit_args(cx: &LateContext<'_>, expr: &Expr<'_>, args_to_recover: &[&Expr<'_>]) {
-    let mut applicability = Applicability::MachineApplicable;
-    let (singular, plural) = if args_to_recover.len() > 1 {
-        ("", "s")
-    } else {
-        ("a ", "")
-    };
-    span_lint_and_then(
-        cx,
-        UNIT_ARG,
-        expr.span,
-        &format!("passing {}unit value{} to a function", singular, plural),
-        |db| {
-            let mut or = "";
-            args_to_recover
-                .iter()
-                .filter_map(|arg| {
-                    if_chain! {
-                        if let ExprKind::Block(block, _) = arg.kind;
-                        if block.expr.is_none();
-                        if let Some(last_stmt) = block.stmts.iter().last();
-                        if let StmtKind::Semi(last_expr) = last_stmt.kind;
-                        if let Some(snip) = snippet_opt(cx, last_expr.span);
-                        then {
-                            Some((
-                                last_stmt.span,
-                                snip,
-                            ))
-                        }
-                        else {
-                            None
-                        }
-                    }
-                })
-                .for_each(|(span, sugg)| {
-                    db.span_suggestion(
-                        span,
-                        "remove the semicolon from the last statement in the block",
-                        sugg,
-                        Applicability::MaybeIncorrect,
-                    );
-                    or = "or ";
-                    applicability = Applicability::MaybeIncorrect;
-                });
-
-            let arg_snippets: Vec<String> = args_to_recover
-                .iter()
-                .filter_map(|arg| snippet_opt(cx, arg.span))
-                .collect();
-            let arg_snippets_without_empty_blocks: Vec<String> = args_to_recover
-                .iter()
-                .filter(|arg| !is_empty_block(arg))
-                .filter_map(|arg| snippet_opt(cx, arg.span))
-                .collect();
-
-            if let Some(call_snippet) = snippet_opt(cx, expr.span) {
-                let sugg = fmt_stmts_and_call(
-                    cx,
-                    expr,
-                    &call_snippet,
-                    &arg_snippets,
-                    &arg_snippets_without_empty_blocks,
-                );
 
-                if arg_snippets_without_empty_blocks.is_empty() {
-                    db.multipart_suggestion(
-                        &format!("use {}unit literal{} instead", singular, plural),
-                        args_to_recover
-                            .iter()
-                            .map(|arg| (arg.span, "()".to_string()))
-                            .collect::<Vec<_>>(),
-                        applicability,
-                    );
-                } else {
-                    let plural = arg_snippets_without_empty_blocks.len() > 1;
-                    let empty_or_s = if plural { "s" } else { "" };
-                    let it_or_them = if plural { "them" } else { "it" };
-                    db.span_suggestion(
-                        expr.span,
-                        &format!(
-                            "{}move the expression{} in front of the call and replace {} with the unit literal `()`",
-                            or, empty_or_s, it_or_them
-                        ),
-                        sugg,
-                        applicability,
-                    );
-                }
-            }
-        },
-    );
-}
-
-fn is_empty_block(expr: &Expr<'_>) -> bool {
-    matches!(
-        expr.kind,
-        ExprKind::Block(
-            Block {
-                stmts: &[],
-                expr: None,
-                ..
-            },
-            _,
-        )
-    )
-}
-
-fn fmt_stmts_and_call(
-    cx: &LateContext<'_>,
-    call_expr: &Expr<'_>,
-    call_snippet: &str,
-    args_snippets: &[impl AsRef<str>],
-    non_empty_block_args_snippets: &[impl AsRef<str>],
-) -> String {
-    let call_expr_indent = indent_of(cx, call_expr.span).unwrap_or(0);
-    let call_snippet_with_replacements = args_snippets
-        .iter()
-        .fold(call_snippet.to_owned(), |acc, arg| acc.replacen(arg.as_ref(), "()", 1));
-
-    let mut stmts_and_call = non_empty_block_args_snippets
-        .iter()
-        .map(|it| it.as_ref().to_owned())
-        .collect::<Vec<_>>();
-    stmts_and_call.push(call_snippet_with_replacements);
-    stmts_and_call = stmts_and_call
-        .into_iter()
-        .map(|v| reindent_multiline(v.into(), true, Some(call_expr_indent)).into_owned())
-        .collect();
-
-    let mut stmts_and_call_snippet = stmts_and_call.join(&format!("{}{}", ";\n", " ".repeat(call_expr_indent)));
-    // expr is not in a block statement or result expression position, wrap in a block
-    let parent_node = cx.tcx.hir().find(cx.tcx.hir().get_parent_node(call_expr.hir_id));
-    if !matches!(parent_node, Some(Node::Block(_))) && !matches!(parent_node, Some(Node::Stmt(_))) {
-        let block_indent = call_expr_indent + 4;
-        stmts_and_call_snippet =
-            reindent_multiline(stmts_and_call_snippet.into(), true, Some(block_indent)).into_owned();
-        stmts_and_call_snippet = format!(
-            "{{\n{}{}\n{}}}",
-            " ".repeat(block_indent),
-            &stmts_and_call_snippet,
-            " ".repeat(call_expr_indent)
-        );
+    fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
+        unit_cmp::check(cx, expr);
+        unit_arg::check(cx, expr);
     }
-    stmts_and_call_snippet
 }
diff --git a/clippy_lints/src/unit_types/unit_arg.rs b/clippy_lints/src/unit_types/unit_arg.rs
new file mode 100644
index 00000000000..49b5725f528
--- /dev/null
+++ b/clippy_lints/src/unit_types/unit_arg.rs
@@ -0,0 +1,209 @@
+use rustc_errors::Applicability;
+use rustc_hir::{self as hir, Block, Expr, ExprKind, MatchSource, Node, StmtKind};
+use rustc_lint::LateContext;
+
+use if_chain::if_chain;
+
+use crate::utils::diagnostics::span_lint_and_then;
+use crate::utils::source::{indent_of, reindent_multiline, snippet_opt};
+
+use super::{utils, UNIT_ARG};
+
+pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>) {
+    if expr.span.from_expansion() {
+        return;
+    }
+
+    // apparently stuff in the desugaring of `?` can trigger this
+    // so check for that here
+    // only the calls to `Try::from_error` is marked as desugared,
+    // so we need to check both the current Expr and its parent.
+    if is_questionmark_desugar_marked_call(expr) {
+        return;
+    }
+    if_chain! {
+        let map = &cx.tcx.hir();
+        let opt_parent_node = map.find(map.get_parent_node(expr.hir_id));
+        if let Some(hir::Node::Expr(parent_expr)) = opt_parent_node;
+        if is_questionmark_desugar_marked_call(parent_expr);
+        then {
+            return;
+        }
+    }
+
+    match expr.kind {
+        ExprKind::Call(_, args) | ExprKind::MethodCall(_, _, args, _) => {
+            let args_to_recover = args
+                .iter()
+                .filter(|arg| {
+                    if utils::is_unit(cx.typeck_results().expr_ty(arg)) && !utils::is_unit_literal(arg) {
+                        !matches!(
+                            &arg.kind,
+                            ExprKind::Match(.., MatchSource::TryDesugar) | ExprKind::Path(..)
+                        )
+                    } else {
+                        false
+                    }
+                })
+                .collect::<Vec<_>>();
+            if !args_to_recover.is_empty() {
+                lint_unit_args(cx, expr, &args_to_recover);
+            }
+        },
+        _ => (),
+    }
+}
+
+fn is_questionmark_desugar_marked_call(expr: &Expr<'_>) -> bool {
+    use rustc_span::hygiene::DesugaringKind;
+    if let ExprKind::Call(ref callee, _) = expr.kind {
+        callee.span.is_desugaring(DesugaringKind::QuestionMark)
+    } else {
+        false
+    }
+}
+
+fn lint_unit_args(cx: &LateContext<'_>, expr: &Expr<'_>, args_to_recover: &[&Expr<'_>]) {
+    let mut applicability = Applicability::MachineApplicable;
+    let (singular, plural) = if args_to_recover.len() > 1 {
+        ("", "s")
+    } else {
+        ("a ", "")
+    };
+    span_lint_and_then(
+        cx,
+        UNIT_ARG,
+        expr.span,
+        &format!("passing {}unit value{} to a function", singular, plural),
+        |db| {
+            let mut or = "";
+            args_to_recover
+                .iter()
+                .filter_map(|arg| {
+                    if_chain! {
+                        if let ExprKind::Block(block, _) = arg.kind;
+                        if block.expr.is_none();
+                        if let Some(last_stmt) = block.stmts.iter().last();
+                        if let StmtKind::Semi(last_expr) = last_stmt.kind;
+                        if let Some(snip) = snippet_opt(cx, last_expr.span);
+                        then {
+                            Some((
+                                last_stmt.span,
+                                snip,
+                            ))
+                        }
+                        else {
+                            None
+                        }
+                    }
+                })
+                .for_each(|(span, sugg)| {
+                    db.span_suggestion(
+                        span,
+                        "remove the semicolon from the last statement in the block",
+                        sugg,
+                        Applicability::MaybeIncorrect,
+                    );
+                    or = "or ";
+                    applicability = Applicability::MaybeIncorrect;
+                });
+
+            let arg_snippets: Vec<String> = args_to_recover
+                .iter()
+                .filter_map(|arg| snippet_opt(cx, arg.span))
+                .collect();
+            let arg_snippets_without_empty_blocks: Vec<String> = args_to_recover
+                .iter()
+                .filter(|arg| !is_empty_block(arg))
+                .filter_map(|arg| snippet_opt(cx, arg.span))
+                .collect();
+
+            if let Some(call_snippet) = snippet_opt(cx, expr.span) {
+                let sugg = fmt_stmts_and_call(
+                    cx,
+                    expr,
+                    &call_snippet,
+                    &arg_snippets,
+                    &arg_snippets_without_empty_blocks,
+                );
+
+                if arg_snippets_without_empty_blocks.is_empty() {
+                    db.multipart_suggestion(
+                        &format!("use {}unit literal{} instead", singular, plural),
+                        args_to_recover
+                            .iter()
+                            .map(|arg| (arg.span, "()".to_string()))
+                            .collect::<Vec<_>>(),
+                        applicability,
+                    );
+                } else {
+                    let plural = arg_snippets_without_empty_blocks.len() > 1;
+                    let empty_or_s = if plural { "s" } else { "" };
+                    let it_or_them = if plural { "them" } else { "it" };
+                    db.span_suggestion(
+                        expr.span,
+                        &format!(
+                            "{}move the expression{} in front of the call and replace {} with the unit literal `()`",
+                            or, empty_or_s, it_or_them
+                        ),
+                        sugg,
+                        applicability,
+                    );
+                }
+            }
+        },
+    );
+}
+
+fn is_empty_block(expr: &Expr<'_>) -> bool {
+    matches!(
+        expr.kind,
+        ExprKind::Block(
+            Block {
+                stmts: &[],
+                expr: None,
+                ..
+            },
+            _,
+        )
+    )
+}
+
+fn fmt_stmts_and_call(
+    cx: &LateContext<'_>,
+    call_expr: &Expr<'_>,
+    call_snippet: &str,
+    args_snippets: &[impl AsRef<str>],
+    non_empty_block_args_snippets: &[impl AsRef<str>],
+) -> String {
+    let call_expr_indent = indent_of(cx, call_expr.span).unwrap_or(0);
+    let call_snippet_with_replacements = args_snippets
+        .iter()
+        .fold(call_snippet.to_owned(), |acc, arg| acc.replacen(arg.as_ref(), "()", 1));
+
+    let mut stmts_and_call = non_empty_block_args_snippets
+        .iter()
+        .map(|it| it.as_ref().to_owned())
+        .collect::<Vec<_>>();
+    stmts_and_call.push(call_snippet_with_replacements);
+    stmts_and_call = stmts_and_call
+        .into_iter()
+        .map(|v| reindent_multiline(v.into(), true, Some(call_expr_indent)).into_owned())
+        .collect();
+
+    let mut stmts_and_call_snippet = stmts_and_call.join(&format!("{}{}", ";\n", " ".repeat(call_expr_indent)));
+    // expr is not in a block statement or result expression position, wrap in a block
+    let parent_node = cx.tcx.hir().find(cx.tcx.hir().get_parent_node(call_expr.hir_id));
+    if !matches!(parent_node, Some(Node::Block(_))) && !matches!(parent_node, Some(Node::Stmt(_))) {
+        let block_indent = call_expr_indent + 4;
+        stmts_and_call_snippet =
+            reindent_multiline(stmts_and_call_snippet.into(), true, Some(block_indent)).into_owned();
+        stmts_and_call_snippet = format!(
+            "{{\n{}{}\n{}}}",
+            " ".repeat(block_indent),
+            &stmts_and_call_snippet,
+            " ".repeat(call_expr_indent)
+        );
+    }
+    stmts_and_call_snippet
+}
-- 
cgit 1.4.1-3-g733a5


From 5a439f5a82815c029c8b2bfa28d9525aaac1c320 Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Tue, 16 Mar 2021 10:37:05 +0900
Subject: Remove unit_types::utils::is_unit

---
 clippy_lints/src/unit_types/let_unit_value.rs | 4 ++--
 clippy_lints/src/unit_types/unit_arg.rs       | 2 +-
 clippy_lints/src/unit_types/unit_cmp.rs       | 6 +++---
 clippy_lints/src/unit_types/utils.rs          | 5 -----
 4 files changed, 6 insertions(+), 11 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unit_types/let_unit_value.rs b/clippy_lints/src/unit_types/let_unit_value.rs
index 126f6aa746a..55715cc6bf3 100644
--- a/clippy_lints/src/unit_types/let_unit_value.rs
+++ b/clippy_lints/src/unit_types/let_unit_value.rs
@@ -7,11 +7,11 @@ use crate::utils::diagnostics::span_lint_and_then;
 use crate::utils::higher;
 use crate::utils::source::snippet_with_macro_callsite;
 
-use super::{utils, LET_UNIT_VALUE};
+use super::LET_UNIT_VALUE;
 
 pub(super) fn check(cx: &LateContext<'_>, stmt: &Stmt<'_>) {
     if let StmtKind::Local(ref local) = stmt.kind {
-        if utils::is_unit(cx.typeck_results().pat_ty(&local.pat)) {
+        if cx.typeck_results().pat_ty(&local.pat).is_unit() {
             if in_external_macro(cx.sess(), stmt.span) || local.pat.span.from_expansion() {
                 return;
             }
diff --git a/clippy_lints/src/unit_types/unit_arg.rs b/clippy_lints/src/unit_types/unit_arg.rs
index 49b5725f528..d4ef645fc8d 100644
--- a/clippy_lints/src/unit_types/unit_arg.rs
+++ b/clippy_lints/src/unit_types/unit_arg.rs
@@ -36,7 +36,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>) {
             let args_to_recover = args
                 .iter()
                 .filter(|arg| {
-                    if utils::is_unit(cx.typeck_results().expr_ty(arg)) && !utils::is_unit_literal(arg) {
+                    if cx.typeck_results().expr_ty(arg).is_unit() && !utils::is_unit_literal(arg) {
                         !matches!(
                             &arg.kind,
                             ExprKind::Match(.., MatchSource::TryDesugar) | ExprKind::Path(..)
diff --git a/clippy_lints/src/unit_types/unit_cmp.rs b/clippy_lints/src/unit_types/unit_cmp.rs
index e19fc1ec9ef..f9c0374c86d 100644
--- a/clippy_lints/src/unit_types/unit_cmp.rs
+++ b/clippy_lints/src/unit_types/unit_cmp.rs
@@ -4,7 +4,7 @@ use rustc_span::hygiene::{ExpnKind, MacroKind};
 
 use crate::utils::diagnostics::span_lint;
 
-use super::{utils, UNIT_CMP};
+use super::UNIT_CMP;
 
 pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>) {
     if expr.span.from_expansion() {
@@ -12,7 +12,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>) {
             if let ExpnKind::Macro(MacroKind::Bang, symbol) = callee.kind {
                 if let ExprKind::Binary(ref cmp, ref left, _) = expr.kind {
                     let op = cmp.node;
-                    if op.is_comparison() && utils::is_unit(cx.typeck_results().expr_ty(left)) {
+                    if op.is_comparison() && cx.typeck_results().expr_ty(left).is_unit() {
                         let result = match &*symbol.as_str() {
                             "assert_eq" | "debug_assert_eq" => "succeed",
                             "assert_ne" | "debug_assert_ne" => "fail",
@@ -37,7 +37,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>) {
 
     if let ExprKind::Binary(ref cmp, ref left, _) = expr.kind {
         let op = cmp.node;
-        if op.is_comparison() && utils::is_unit(cx.typeck_results().expr_ty(left)) {
+        if op.is_comparison() && cx.typeck_results().expr_ty(left).is_unit() {
             let result = match op {
                 BinOpKind::Eq | BinOpKind::Le | BinOpKind::Ge => "true",
                 _ => "false",
diff --git a/clippy_lints/src/unit_types/utils.rs b/clippy_lints/src/unit_types/utils.rs
index a15a7b812c5..4e194a05e8d 100644
--- a/clippy_lints/src/unit_types/utils.rs
+++ b/clippy_lints/src/unit_types/utils.rs
@@ -1,9 +1,4 @@
 use rustc_hir::{Expr, ExprKind};
-use rustc_middle::ty::{self, Ty};
-
-pub(super) fn is_unit(ty: Ty<'_>) -> bool {
-    matches!(ty.kind(), ty::Tuple(slice) if slice.is_empty())
-}
 
 pub(super) fn is_unit_literal(expr: &Expr<'_>) -> bool {
     matches!(expr.kind, ExprKind::Tup(ref slice) if slice.is_empty())
-- 
cgit 1.4.1-3-g733a5


From c5b3a719ed85ae48e813ee07cb9e7b56c6a763d9 Mon Sep 17 00:00:00 2001
From: Yukio Tanaka <news7vip@gmail.com>
Date: Tue, 16 Mar 2021 19:46:40 +0900
Subject: Fix FP of `manual_unwrap_or` in const fn

---
 clippy_lints/src/manual_unwrap_or.rs | 33 ++++++++++++++++++++++++++++-----
 tests/ui/manual_unwrap_or.fixed      | 15 +++++++++++++++
 tests/ui/manual_unwrap_or.rs         | 15 +++++++++++++++
 3 files changed, 58 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_unwrap_or.rs b/clippy_lints/src/manual_unwrap_or.rs
index 0e030e0e261..203f018a9e2 100644
--- a/clippy_lints/src/manual_unwrap_or.rs
+++ b/clippy_lints/src/manual_unwrap_or.rs
@@ -6,12 +6,12 @@ use clippy_utils::source::{indent_of, reindent_multiline, snippet_opt};
 use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
-use rustc_hir::{Arm, Expr, ExprKind, Pat, PatKind};
+use rustc_hir::{hir_id::HirId, intravisit::FnKind, Arm, Body, Expr, ExprKind, FnDecl, Pat, PatKind, StmtKind};
 use rustc_lint::LintContext;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::sym;
+use rustc_span::{source_map::Span, sym};
 
 declare_clippy_lint! {
     /// **What it does:**
@@ -44,11 +44,34 @@ declare_clippy_lint! {
 declare_lint_pass!(ManualUnwrapOr => [MANUAL_UNWRAP_OR]);
 
 impl LateLintPass<'_> for ManualUnwrapOr {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
-        if in_external_macro(cx.sess(), expr.span) {
+    fn check_fn(
+        &mut self,
+        cx: &LateContext<'tcx>,
+        kind: FnKind<'tcx>,
+        _: &'tcx FnDecl<'tcx>,
+        body: &'tcx Body<'tcx>,
+        span: Span,
+        _: HirId,
+    ) {
+        if in_external_macro(cx.sess(), span) {
             return;
         }
-        lint_manual_unwrap_or(cx, expr);
+        if_chain! {
+            if let FnKind::ItemFn(_, _, header, _) = kind;
+            if !header.is_const();
+            let expr = &body.value;
+            if let ExprKind::Block(block, _) = expr.kind;
+            then {
+                for stmt in block.stmts {
+                    if let StmtKind::Expr(expr) | StmtKind::Semi(expr) = &stmt.kind {
+                        lint_manual_unwrap_or(cx, expr);
+                    }
+                }
+                if let Some(expr) = block.expr {
+                    lint_manual_unwrap_or(cx, expr);
+                }
+            }
+        }
     }
 }
 
diff --git a/tests/ui/manual_unwrap_or.fixed b/tests/ui/manual_unwrap_or.fixed
index 81d903c15d3..2f57957f55b 100644
--- a/tests/ui/manual_unwrap_or.fixed
+++ b/tests/ui/manual_unwrap_or.fixed
@@ -136,4 +136,19 @@ fn result_unwrap_or() {
     };
 }
 
+// don't lint in const fn
+const fn const_fn_unwrap_or() {
+    match Some(1) {
+        Some(s) => s,
+        None => 0,
+    };
+}
+
+const fn const_fn_unwrap() {
+    match Ok::<&str, &str>("Alice") {
+        Ok(s) => s,
+        Err(_) => "Bob",
+    };
+}
+
 fn main() {}
diff --git a/tests/ui/manual_unwrap_or.rs b/tests/ui/manual_unwrap_or.rs
index 16105d379c3..1088047da75 100644
--- a/tests/ui/manual_unwrap_or.rs
+++ b/tests/ui/manual_unwrap_or.rs
@@ -175,4 +175,19 @@ fn result_unwrap_or() {
     };
 }
 
+// don't lint in const fn
+const fn const_fn_unwrap_or() {
+    match Some(1) {
+        Some(s) => s,
+        None => 0,
+    };
+}
+
+const fn const_fn_unwrap() {
+    match Ok::<&str, &str>("Alice") {
+        Ok(s) => s,
+        Err(_) => "Bob",
+    };
+}
+
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 02ceeb59d4853eecec3a52a7fbd9f6acc1c3f91c Mon Sep 17 00:00:00 2001
From: Yukio Tanaka <news7vip@gmail.com>
Date: Wed, 17 Mar 2021 00:06:42 +0900
Subject: Use in_constant instead of is_const

---
 clippy_lints/src/manual_unwrap_or.rs | 35 ++++++-----------------------------
 1 file changed, 6 insertions(+), 29 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_unwrap_or.rs b/clippy_lints/src/manual_unwrap_or.rs
index 203f018a9e2..615e2d5c2af 100644
--- a/clippy_lints/src/manual_unwrap_or.rs
+++ b/clippy_lints/src/manual_unwrap_or.rs
@@ -1,17 +1,17 @@
 use crate::consts::constant_simple;
 use crate::utils;
-use crate::utils::{path_to_local_id, sugg};
+use crate::utils::{in_constant, path_to_local_id, sugg};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::{indent_of, reindent_multiline, snippet_opt};
 use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
-use rustc_hir::{hir_id::HirId, intravisit::FnKind, Arm, Body, Expr, ExprKind, FnDecl, Pat, PatKind, StmtKind};
+use rustc_hir::{Arm, Expr, ExprKind, Pat, PatKind};
 use rustc_lint::LintContext;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::{source_map::Span, sym};
+use rustc_span::sym;
 
 declare_clippy_lint! {
     /// **What it does:**
@@ -44,34 +44,11 @@ declare_clippy_lint! {
 declare_lint_pass!(ManualUnwrapOr => [MANUAL_UNWRAP_OR]);
 
 impl LateLintPass<'_> for ManualUnwrapOr {
-    fn check_fn(
-        &mut self,
-        cx: &LateContext<'tcx>,
-        kind: FnKind<'tcx>,
-        _: &'tcx FnDecl<'tcx>,
-        body: &'tcx Body<'tcx>,
-        span: Span,
-        _: HirId,
-    ) {
-        if in_external_macro(cx.sess(), span) {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
+        if in_external_macro(cx.sess(), expr.span) || in_constant(cx, expr.hir_id) {
             return;
         }
-        if_chain! {
-            if let FnKind::ItemFn(_, _, header, _) = kind;
-            if !header.is_const();
-            let expr = &body.value;
-            if let ExprKind::Block(block, _) = expr.kind;
-            then {
-                for stmt in block.stmts {
-                    if let StmtKind::Expr(expr) | StmtKind::Semi(expr) = &stmt.kind {
-                        lint_manual_unwrap_or(cx, expr);
-                    }
-                }
-                if let Some(expr) = block.expr {
-                    lint_manual_unwrap_or(cx, expr);
-                }
-            }
-        }
+        lint_manual_unwrap_or(cx, expr);
     }
 }
 
-- 
cgit 1.4.1-3-g733a5


From 4450c21f5125c363397d87ff74ed1a1d52a9f1a8 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Mon, 1 Mar 2021 13:14:52 -0500
Subject: Keep track of spans in format strings

---
 clippy_lints/src/write.rs | 238 ++++++++++++++++++++++++++++------------------
 1 file changed, 148 insertions(+), 90 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs
index fd3e5a7ce91..b5470c3bc70 100644
--- a/clippy_lints/src/write.rs
+++ b/clippy_lints/src/write.rs
@@ -2,9 +2,8 @@ use std::borrow::Cow;
 use std::ops::Range;
 
 use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg, span_lint_and_then};
-use clippy_utils::source::snippet_with_applicability;
-use if_chain::if_chain;
-use rustc_ast::ast::{Expr, ExprKind, ImplKind, Item, ItemKind, LitKind, MacCall, StrLit, StrStyle};
+use clippy_utils::source::{snippet_opt, snippet_with_applicability};
+use rustc_ast::ast::{Expr, ExprKind, ImplKind, Item, ItemKind, LitKind, MacCall, Path, StrLit, StrStyle};
 use rustc_ast::token;
 use rustc_ast::tokenstream::TokenStream;
 use rustc_errors::Applicability;
@@ -12,8 +11,9 @@ use rustc_lexer::unescape::{self, EscapeError};
 use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_parse::parser;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::symbol::kw;
-use rustc_span::{sym, BytePos, Span};
+use rustc_span::symbol::{kw, Symbol};
+use rustc_span::{sym, BytePos, Span, DUMMY_SP};
+use smallvec::SmallVec;
 
 declare_clippy_lint! {
     /// **What it does:** This lint warns when you use `println!("")` to
@@ -354,7 +354,117 @@ fn newline_span(fmtstr: &StrLit) -> Span {
     sp.with_lo(newline_sp_hi - newline_sp_len).with_hi(newline_sp_hi)
 }
 
+/// Stores a list of replacement spans for each argument, but only if all the replacements used an
+/// empty format string.
+#[derive(Default)]
+struct SimpleFormatArgs {
+    unnamed: Vec<SmallVec<[Span; 1]>>,
+    named: Vec<(Symbol, SmallVec<[Span; 1]>)>,
+}
+impl SimpleFormatArgs {
+    fn get_unnamed(&self) -> impl Iterator<Item = &[Span]> {
+        self.unnamed.iter().map(|x| match x.as_slice() {
+            // Ignore the dummy span added from out of order format arguments.
+            [DUMMY_SP] => &[],
+            x => x,
+        })
+    }
+
+    fn get_named(&self, n: &Path) -> &[Span] {
+        self.named.iter().find(|x| *n == x.0).map_or(&[], |x| x.1.as_slice())
+    }
+
+    fn push(&mut self, arg: rustc_parse_format::Argument<'_>, span: Span) {
+        use rustc_parse_format::{
+            AlignUnknown, ArgumentImplicitlyIs, ArgumentIs, ArgumentNamed, CountImplied, FormatSpec,
+        };
+
+        const SIMPLE: FormatSpec<'_> = FormatSpec {
+            fill: None,
+            align: AlignUnknown,
+            flags: 0,
+            precision: CountImplied,
+            precision_span: None,
+            width: CountImplied,
+            width_span: None,
+            ty: "",
+            ty_span: None,
+        };
+
+        match arg.position {
+            ArgumentIs(n) | ArgumentImplicitlyIs(n) => {
+                if self.unnamed.len() <= n {
+                    // Use a dummy span to mark all unseen arguments.
+                    self.unnamed.resize_with(n, || SmallVec::from([DUMMY_SP]));
+                    if arg.format == SIMPLE {
+                        self.unnamed.push(SmallVec::from([span]));
+                    } else {
+                        self.unnamed.push(SmallVec::new());
+                    }
+                } else {
+                    let args = &mut self.unnamed[n];
+                    match (args.as_mut_slice(), arg.format == SIMPLE) {
+                        // A non-empty format string has been seen already.
+                        ([], _) => (),
+                        // Replace the dummy span, if it exists.
+                        ([dummy @ DUMMY_SP], true) => *dummy = span,
+                        ([_, ..], true) => args.push(span),
+                        ([_, ..], false) => *args = SmallVec::new(),
+                    }
+                }
+            },
+            ArgumentNamed(n) => {
+                if let Some(x) = self.named.iter_mut().find(|x| x.0 == n) {
+                    match x.1.as_slice() {
+                        // A non-empty format string has been seen already.
+                        [] => (),
+                        [_, ..] if arg.format == SIMPLE => x.1.push(span),
+                        [_, ..] => x.1 = SmallVec::new(),
+                    }
+                } else if arg.format == SIMPLE {
+                    self.named.push((n, SmallVec::from([span])));
+                } else {
+                    self.named.push((n, SmallVec::new()));
+                }
+            },
+        };
+    }
+}
+
 impl Write {
+    /// Parses a format string into a collection of spans for each argument. This only keeps track
+    /// of empty format arguments. Will also lint usages of debug format strings outside of debug
+    /// impls.
+    fn parse_fmt_string(&self, cx: &EarlyContext<'_>, str: &StrLit) -> Option<SimpleFormatArgs> {
+        use rustc_parse_format::{ParseMode, Parser, Piece};
+
+        let str_sym = str.symbol.as_str();
+        let style = match str.style {
+            StrStyle::Cooked => None,
+            StrStyle::Raw(n) => Some(n as usize),
+        };
+
+        let mut parser = Parser::new(&str_sym, style, snippet_opt(cx, str.span), false, ParseMode::Format);
+        let mut args = SimpleFormatArgs::default();
+
+        while let Some(arg) = parser.next() {
+            let arg = match arg {
+                Piece::String(_) => continue,
+                Piece::NextArgument(arg) => arg,
+            };
+            let span = parser.arg_places.last().map_or(DUMMY_SP, |&x| str.span.from_inner(x));
+
+            if !self.in_debug_impl && arg.format.ty == "?" {
+                // FIXME: modify rustc's fmt string parser to give us the current span
+                span_lint(cx, USE_DEBUG, str.span, "use of `Debug`-based formatting");
+            }
+
+            args.push(arg, span);
+        }
+
+        parser.errors.is_empty().then(move || args)
+    }
+
     /// Checks the arguments of `print[ln]!` and `write[ln]!` calls. It will return a tuple of two
     /// `Option`s. The first `Option` of the tuple is the macro's format string. It includes
     /// the contents of the string, whether it's a raw string, and the span of the literal in the
@@ -376,57 +486,31 @@ impl Write {
     /// ```
     #[allow(clippy::too_many_lines)]
     fn check_tts<'a>(&self, cx: &EarlyContext<'a>, tts: TokenStream, is_write: bool) -> (Option<StrLit>, Option<Expr>) {
-        use rustc_parse_format::{
-            AlignUnknown, ArgumentImplicitlyIs, ArgumentIs, ArgumentNamed, CountImplied, FormatSpec, ParseMode, Parser,
-            Piece,
-        };
-
         let mut parser = parser::Parser::new(&cx.sess.parse_sess, tts, false, None);
-        let mut expr: Option<Expr> = None;
-        if is_write {
-            expr = match parser.parse_expr().map_err(|mut err| err.cancel()) {
-                Ok(p) => Some(p.into_inner()),
-                Err(_) => return (None, None),
-            };
-            // might be `writeln!(foo)`
-            if parser.expect(&token::Comma).map_err(|mut err| err.cancel()).is_err() {
-                return (None, expr);
+        let expr = if is_write {
+            match parser.parse_expr().map(|e| e.into_inner()).map_err(|mut e| e.cancel()) {
+                // write!(e, ...)
+                Ok(p) if parser.eat(&token::Comma) => Some(p),
+                // write!(e) or error
+                e => return (None, e.ok()),
             }
-        }
+        } else {
+            None
+        };
 
         let fmtstr = match parser.parse_str_lit() {
             Ok(fmtstr) => fmtstr,
             Err(_) => return (None, expr),
         };
-        let tmp = fmtstr.symbol.as_str();
-        let mut args = vec![];
-        let mut fmt_parser = Parser::new(&tmp, None, None, false, ParseMode::Format);
-        while let Some(piece) = fmt_parser.next() {
-            if !fmt_parser.errors.is_empty() {
-                return (None, expr);
-            }
-            if let Piece::NextArgument(arg) = piece {
-                if !self.in_debug_impl && arg.format.ty == "?" {
-                    // FIXME: modify rustc's fmt string parser to give us the current span
-                    span_lint(cx, USE_DEBUG, parser.prev_token.span, "use of `Debug`-based formatting");
-                }
-                args.push(arg);
-            }
-        }
+
+        let args = match self.parse_fmt_string(cx, &fmtstr) {
+            Some(args) => args,
+            None => return (Some(fmtstr), expr),
+        };
+
         let lint = if is_write { WRITE_LITERAL } else { PRINT_LITERAL };
-        let mut idx = 0;
+        let mut unnamed_args = args.get_unnamed();
         loop {
-            const SIMPLE: FormatSpec<'_> = FormatSpec {
-                fill: None,
-                align: AlignUnknown,
-                flags: 0,
-                precision: CountImplied,
-                precision_span: None,
-                width: CountImplied,
-                width_span: None,
-                ty: "",
-                ty_span: None,
-            };
             if !parser.eat(&token::Comma) {
                 return (Some(fmtstr), expr);
             }
@@ -435,52 +519,26 @@ impl Write {
             } else {
                 return (Some(fmtstr), None);
             };
-            match &token_expr.kind {
+            let (fmt_spans, span) = match &token_expr.kind {
                 ExprKind::Lit(lit) if !matches!(lit.kind, LitKind::Int(..) | LitKind::Float(..)) => {
-                    let mut all_simple = true;
-                    let mut seen = false;
-                    for arg in &args {
-                        match arg.position {
-                            ArgumentImplicitlyIs(n) | ArgumentIs(n) => {
-                                if n == idx {
-                                    all_simple &= arg.format == SIMPLE;
-                                    seen = true;
-                                }
-                            },
-                            ArgumentNamed(_) => {},
-                        }
-                    }
-                    if all_simple && seen {
-                        span_lint(cx, lint, token_expr.span, "literal with an empty format string");
-                    }
-                    idx += 1;
+                    (unnamed_args.next().unwrap_or(&[]), token_expr.span)
                 },
-                ExprKind::Assign(lhs, rhs, _) => {
-                    if_chain! {
-                        if let ExprKind::Lit(ref lit) = rhs.kind;
-                        if !matches!(lit.kind, LitKind::Int(..) | LitKind::Float(..));
-                        if let ExprKind::Path(_, p) = &lhs.kind;
-                        then {
-                            let mut all_simple = true;
-                            let mut seen = false;
-                            for arg in &args {
-                                match arg.position {
-                                    ArgumentImplicitlyIs(_) | ArgumentIs(_) => {},
-                                    ArgumentNamed(name) => {
-                                        if *p == name {
-                                            seen = true;
-                                            all_simple &= arg.format == SIMPLE;
-                                        }
-                                    },
-                                }
-                            }
-                            if all_simple && seen {
-                                span_lint(cx, lint, rhs.span, "literal with an empty format string");
-                            }
-                        }
-                    }
+                ExprKind::Assign(lhs, rhs, _) => match (&lhs.kind, &rhs.kind) {
+                    (ExprKind::Path(_, p), ExprKind::Lit(lit))
+                        if !matches!(lit.kind, LitKind::Int(..) | LitKind::Float(..)) =>
+                    {
+                        (args.get_named(p), rhs.span)
+                    },
+                    _ => continue,
                 },
-                _ => idx += 1,
+                _ => {
+                    unnamed_args.next();
+                    continue;
+                },
+            };
+
+            if !fmt_spans.is_empty() {
+                span_lint(cx, lint, span, "literal with an empty format string");
             }
         }
     }
-- 
cgit 1.4.1-3-g733a5


From 4c1047167d20460dcb84e3d947787ce91d5fd0d4 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Mon, 1 Mar 2021 13:28:36 -0500
Subject: More specific spans for `use_debug` lint

---
 clippy_lints/src/write.rs |  2 +-
 tests/ui/print.stderr     | 12 ++++++------
 2 files changed, 7 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs
index b5470c3bc70..210ddc7465f 100644
--- a/clippy_lints/src/write.rs
+++ b/clippy_lints/src/write.rs
@@ -456,7 +456,7 @@ impl Write {
 
             if !self.in_debug_impl && arg.format.ty == "?" {
                 // FIXME: modify rustc's fmt string parser to give us the current span
-                span_lint(cx, USE_DEBUG, str.span, "use of `Debug`-based formatting");
+                span_lint(cx, USE_DEBUG, span, "use of `Debug`-based formatting");
             }
 
             args.push(arg, span);
diff --git a/tests/ui/print.stderr b/tests/ui/print.stderr
index 208d9532628..1754c418381 100644
--- a/tests/ui/print.stderr
+++ b/tests/ui/print.stderr
@@ -1,8 +1,8 @@
 error: use of `Debug`-based formatting
-  --> $DIR/print.rs:11:19
+  --> $DIR/print.rs:11:20
    |
 LL |         write!(f, "{:?}", 43.1415)
-   |                   ^^^^^^
+   |                    ^^^^
    |
    = note: `-D clippy::use-debug` implied by `-D warnings`
 
@@ -33,10 +33,10 @@ LL |     print!("Hello {:?}", "World");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: use of `Debug`-based formatting
-  --> $DIR/print.rs:28:12
+  --> $DIR/print.rs:28:19
    |
 LL |     print!("Hello {:?}", "World");
-   |            ^^^^^^^^^^^^
+   |                   ^^^^
 
 error: use of `print!`
   --> $DIR/print.rs:30:5
@@ -45,10 +45,10 @@ LL |     print!("Hello {:#?}", "#orld");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: use of `Debug`-based formatting
-  --> $DIR/print.rs:30:12
+  --> $DIR/print.rs:30:19
    |
 LL |     print!("Hello {:#?}", "#orld");
-   |            ^^^^^^^^^^^^^
+   |                   ^^^^^
 
 error: aborting due to 8 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From a7fa2a6fa88477ab2542bb15347e3085d9547f95 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Mon, 1 Mar 2021 16:31:04 -0500
Subject: Add suggestion to `write_literal` and `print_literal` Don't lint on a
 mixture of raw and regular strings Fix spans in format strings

---
 clippy_lints/src/write.rs       |  62 +++++++++++++++++------
 tests/ui/print_literal.stderr   |  70 +++++++++++++++++++++++---
 tests/ui/write_literal.stderr   |  70 +++++++++++++++++++++++---
 tests/ui/write_literal_2.rs     |  27 ++++++++++
 tests/ui/write_literal_2.stderr | 106 ++++++++++++++++++++++++++++++++++++++++
 5 files changed, 305 insertions(+), 30 deletions(-)
 create mode 100644 tests/ui/write_literal_2.rs
 create mode 100644 tests/ui/write_literal_2.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs
index 210ddc7465f..e416eab7914 100644
--- a/clippy_lints/src/write.rs
+++ b/clippy_lints/src/write.rs
@@ -1,10 +1,11 @@
 use std::borrow::Cow;
-use std::ops::Range;
+use std::iter;
+use std::ops::{Deref, Range};
 
 use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::{snippet_opt, snippet_with_applicability};
-use rustc_ast::ast::{Expr, ExprKind, ImplKind, Item, ItemKind, LitKind, MacCall, Path, StrLit, StrStyle};
-use rustc_ast::token;
+use rustc_ast::ast::{Expr, ExprKind, ImplKind, Item, ItemKind, MacCall, Path, StrLit, StrStyle};
+use rustc_ast::token::{self, LitKind};
 use rustc_ast::tokenstream::TokenStream;
 use rustc_errors::Applicability;
 use rustc_lexer::unescape::{self, EscapeError};
@@ -438,7 +439,7 @@ impl Write {
     fn parse_fmt_string(&self, cx: &EarlyContext<'_>, str: &StrLit) -> Option<SimpleFormatArgs> {
         use rustc_parse_format::{ParseMode, Parser, Piece};
 
-        let str_sym = str.symbol.as_str();
+        let str_sym = str.symbol_unescaped.as_str();
         let style = match str.style {
             StrStyle::Cooked => None,
             StrStyle::Raw(n) => Some(n as usize),
@@ -514,21 +515,17 @@ impl Write {
             if !parser.eat(&token::Comma) {
                 return (Some(fmtstr), expr);
             }
+
+            let comma_span = parser.prev_token.span;
             let token_expr = if let Ok(expr) = parser.parse_expr().map_err(|mut err| err.cancel()) {
                 expr
             } else {
                 return (Some(fmtstr), None);
             };
-            let (fmt_spans, span) = match &token_expr.kind {
-                ExprKind::Lit(lit) if !matches!(lit.kind, LitKind::Int(..) | LitKind::Float(..)) => {
-                    (unnamed_args.next().unwrap_or(&[]), token_expr.span)
-                },
+            let (fmt_spans, lit) = match &token_expr.kind {
+                ExprKind::Lit(lit) => (unnamed_args.next().unwrap_or(&[]), lit),
                 ExprKind::Assign(lhs, rhs, _) => match (&lhs.kind, &rhs.kind) {
-                    (ExprKind::Path(_, p), ExprKind::Lit(lit))
-                        if !matches!(lit.kind, LitKind::Int(..) | LitKind::Float(..)) =>
-                    {
-                        (args.get_named(p), rhs.span)
-                    },
+                    (ExprKind::Path(_, p), ExprKind::Lit(lit)) => (args.get_named(p), lit),
                     _ => continue,
                 },
                 _ => {
@@ -537,8 +534,45 @@ impl Write {
                 },
             };
 
+            let replacement: String = match lit.token.kind {
+                LitKind::Integer | LitKind::Float | LitKind::Err => continue,
+                LitKind::StrRaw(_) | LitKind::ByteStrRaw(_) if matches!(fmtstr.style, StrStyle::Raw(_)) => {
+                    lit.token.symbol.as_str().replace("{", "{{").replace("}", "}}")
+                },
+                LitKind::Str | LitKind::ByteStr if matches!(fmtstr.style, StrStyle::Cooked) => {
+                    lit.token.symbol.as_str().replace("{", "{{").replace("}", "}}")
+                },
+                LitKind::StrRaw(_) | LitKind::Str | LitKind::ByteStrRaw(_) | LitKind::ByteStr => continue,
+                LitKind::Byte | LitKind::Char => match lit.token.symbol.as_str().deref() {
+                    "\"" if matches!(fmtstr.style, StrStyle::Cooked) => "\\\"",
+                    "\"" if matches!(fmtstr.style, StrStyle::Raw(0)) => continue,
+                    "\\\\" if matches!(fmtstr.style, StrStyle::Raw(_)) => "\\",
+                    "\\'" => "'",
+                    "{" => "{{",
+                    "}" => "}}",
+                    x if matches!(fmtstr.style, StrStyle::Raw(_)) && x.starts_with("\\") => continue,
+                    x => x,
+                }
+                .into(),
+                LitKind::Bool => lit.token.symbol.as_str().deref().into(),
+            };
+
             if !fmt_spans.is_empty() {
-                span_lint(cx, lint, span, "literal with an empty format string");
+                span_lint_and_then(
+                    cx,
+                    lint,
+                    token_expr.span,
+                    "literal with an empty format string",
+                    |diag| {
+                        diag.multipart_suggestion(
+                            "try this",
+                            iter::once((comma_span.to(token_expr.span), String::new()))
+                                .chain(fmt_spans.iter().cloned().zip(iter::repeat(replacement)))
+                                .collect(),
+                            Applicability::MachineApplicable,
+                        );
+                    },
+                );
             }
         }
     }
diff --git a/tests/ui/print_literal.stderr b/tests/ui/print_literal.stderr
index e284aece236..54a4084c89e 100644
--- a/tests/ui/print_literal.stderr
+++ b/tests/ui/print_literal.stderr
@@ -5,66 +5,120 @@ LL |     print!("Hello {}", "world");
    |                        ^^^^^^^
    |
    = note: `-D clippy::print-literal` implied by `-D warnings`
+help: try this
+   |
+LL |     print!("Hello world");
+   |                   ^^^^^--
 
 error: literal with an empty format string
   --> $DIR/print_literal.rs:26:36
    |
 LL |     println!("Hello {} {}", world, "world");
    |                                    ^^^^^^^
+   |
+help: try this
+   |
+LL |     println!("Hello {} world", world);
+   |                        ^^^^^       --
 
 error: literal with an empty format string
   --> $DIR/print_literal.rs:27:26
    |
 LL |     println!("Hello {}", "world");
    |                          ^^^^^^^
+   |
+help: try this
+   |
+LL |     println!("Hello world");
+   |                     ^^^^^--
 
 error: literal with an empty format string
   --> $DIR/print_literal.rs:32:25
    |
 LL |     println!("{0} {1}", "hello", "world");
    |                         ^^^^^^^
+   |
+help: try this
+   |
+LL |     println!("hello {1}", "world");
+   |               ^^^^^    --
 
 error: literal with an empty format string
   --> $DIR/print_literal.rs:32:34
    |
 LL |     println!("{0} {1}", "hello", "world");
    |                                  ^^^^^^^
+   |
+help: try this
+   |
+LL |     println!("{0} world", "hello");
+   |                   ^^^^^         --
 
 error: literal with an empty format string
   --> $DIR/print_literal.rs:33:25
    |
 LL |     println!("{1} {0}", "hello", "world");
    |                         ^^^^^^^
+   |
+help: try this
+   |
+LL |     println!("{1} hello", "world");
+   |                   ^^^^^--
 
 error: literal with an empty format string
   --> $DIR/print_literal.rs:33:34
    |
 LL |     println!("{1} {0}", "hello", "world");
    |                                  ^^^^^^^
+   |
+help: try this
+   |
+LL |     println!("world {0}", "hello");
+   |               ^^^^^             --
 
 error: literal with an empty format string
-  --> $DIR/print_literal.rs:36:35
+  --> $DIR/print_literal.rs:36:29
    |
 LL |     println!("{foo} {bar}", foo = "hello", bar = "world");
-   |                                   ^^^^^^^
+   |                             ^^^^^^^^^^^^^
+   |
+help: try this
+   |
+LL |     println!("hello {bar}", bar = "world");
+   |               ^^^^^      --
 
 error: literal with an empty format string
-  --> $DIR/print_literal.rs:36:50
+  --> $DIR/print_literal.rs:36:44
    |
 LL |     println!("{foo} {bar}", foo = "hello", bar = "world");
-   |                                                  ^^^^^^^
+   |                                            ^^^^^^^^^^^^^
+   |
+help: try this
+   |
+LL |     println!("{foo} world", foo = "hello");
+   |                     ^^^^^               --
 
 error: literal with an empty format string
-  --> $DIR/print_literal.rs:37:35
+  --> $DIR/print_literal.rs:37:29
    |
 LL |     println!("{bar} {foo}", foo = "hello", bar = "world");
-   |                                   ^^^^^^^
+   |                             ^^^^^^^^^^^^^
+   |
+help: try this
+   |
+LL |     println!("{bar} hello", bar = "world");
+   |                     ^^^^^--
 
 error: literal with an empty format string
-  --> $DIR/print_literal.rs:37:50
+  --> $DIR/print_literal.rs:37:44
    |
 LL |     println!("{bar} {foo}", foo = "hello", bar = "world");
-   |                                                  ^^^^^^^
+   |                                            ^^^^^^^^^^^^^
+   |
+help: try this
+   |
+LL |     println!("world {foo}", foo = "hello");
+   |               ^^^^^                     --
 
 error: aborting due to 11 previous errors
 
diff --git a/tests/ui/write_literal.stderr b/tests/ui/write_literal.stderr
index e54d89ecf29..507a78e8280 100644
--- a/tests/ui/write_literal.stderr
+++ b/tests/ui/write_literal.stderr
@@ -5,66 +5,120 @@ LL |     write!(&mut v, "Hello {}", "world");
    |                                ^^^^^^^
    |
    = note: `-D clippy::write-literal` implied by `-D warnings`
+help: try this
+   |
+LL |     write!(&mut v, "Hello world");
+   |                           ^^^^^--
 
 error: literal with an empty format string
   --> $DIR/write_literal.rs:31:44
    |
 LL |     writeln!(&mut v, "Hello {} {}", world, "world");
    |                                            ^^^^^^^
+   |
+help: try this
+   |
+LL |     writeln!(&mut v, "Hello {} world", world);
+   |                                ^^^^^       --
 
 error: literal with an empty format string
   --> $DIR/write_literal.rs:32:34
    |
 LL |     writeln!(&mut v, "Hello {}", "world");
    |                                  ^^^^^^^
+   |
+help: try this
+   |
+LL |     writeln!(&mut v, "Hello world");
+   |                             ^^^^^--
 
 error: literal with an empty format string
   --> $DIR/write_literal.rs:37:33
    |
 LL |     writeln!(&mut v, "{0} {1}", "hello", "world");
    |                                 ^^^^^^^
+   |
+help: try this
+   |
+LL |     writeln!(&mut v, "hello {1}", "world");
+   |                       ^^^^^    --
 
 error: literal with an empty format string
   --> $DIR/write_literal.rs:37:42
    |
 LL |     writeln!(&mut v, "{0} {1}", "hello", "world");
    |                                          ^^^^^^^
+   |
+help: try this
+   |
+LL |     writeln!(&mut v, "{0} world", "hello");
+   |                           ^^^^^         --
 
 error: literal with an empty format string
   --> $DIR/write_literal.rs:38:33
    |
 LL |     writeln!(&mut v, "{1} {0}", "hello", "world");
    |                                 ^^^^^^^
+   |
+help: try this
+   |
+LL |     writeln!(&mut v, "{1} hello", "world");
+   |                           ^^^^^--
 
 error: literal with an empty format string
   --> $DIR/write_literal.rs:38:42
    |
 LL |     writeln!(&mut v, "{1} {0}", "hello", "world");
    |                                          ^^^^^^^
+   |
+help: try this
+   |
+LL |     writeln!(&mut v, "world {0}", "hello");
+   |                       ^^^^^             --
 
 error: literal with an empty format string
-  --> $DIR/write_literal.rs:41:43
+  --> $DIR/write_literal.rs:41:37
    |
 LL |     writeln!(&mut v, "{foo} {bar}", foo = "hello", bar = "world");
-   |                                           ^^^^^^^
+   |                                     ^^^^^^^^^^^^^
+   |
+help: try this
+   |
+LL |     writeln!(&mut v, "hello {bar}", bar = "world");
+   |                       ^^^^^      --
 
 error: literal with an empty format string
-  --> $DIR/write_literal.rs:41:58
+  --> $DIR/write_literal.rs:41:52
    |
 LL |     writeln!(&mut v, "{foo} {bar}", foo = "hello", bar = "world");
-   |                                                          ^^^^^^^
+   |                                                    ^^^^^^^^^^^^^
+   |
+help: try this
+   |
+LL |     writeln!(&mut v, "{foo} world", foo = "hello");
+   |                             ^^^^^               --
 
 error: literal with an empty format string
-  --> $DIR/write_literal.rs:42:43
+  --> $DIR/write_literal.rs:42:37
    |
 LL |     writeln!(&mut v, "{bar} {foo}", foo = "hello", bar = "world");
-   |                                           ^^^^^^^
+   |                                     ^^^^^^^^^^^^^
+   |
+help: try this
+   |
+LL |     writeln!(&mut v, "{bar} hello", bar = "world");
+   |                             ^^^^^--
 
 error: literal with an empty format string
-  --> $DIR/write_literal.rs:42:58
+  --> $DIR/write_literal.rs:42:52
    |
 LL |     writeln!(&mut v, "{bar} {foo}", foo = "hello", bar = "world");
-   |                                                          ^^^^^^^
+   |                                                    ^^^^^^^^^^^^^
+   |
+help: try this
+   |
+LL |     writeln!(&mut v, "world {foo}", foo = "hello");
+   |                       ^^^^^                     --
 
 error: aborting due to 11 previous errors
 
diff --git a/tests/ui/write_literal_2.rs b/tests/ui/write_literal_2.rs
new file mode 100644
index 00000000000..f341e8215e1
--- /dev/null
+++ b/tests/ui/write_literal_2.rs
@@ -0,0 +1,27 @@
+#![allow(unused_must_use)]
+#![warn(clippy::write_literal)]
+
+use std::io::Write;
+
+fn main() {
+    let mut v = Vec::new();
+
+    writeln!(&mut v, "{}", "{hello}");
+    writeln!(&mut v, r"{}", r"{hello}");
+    writeln!(&mut v, "{}", '\'');
+    writeln!(&mut v, "{}", '"');
+    writeln!(&mut v, r"{}", '"'); // don't lint
+    writeln!(&mut v, r"{}", '\'');
+    writeln!(
+        &mut v,
+        "some {}",
+        "hello \
+        world!"
+    );
+    writeln!(
+        &mut v,
+        "some {}\
+        {} \\ {}",
+        "1", "2", "3",
+    );
+}
diff --git a/tests/ui/write_literal_2.stderr b/tests/ui/write_literal_2.stderr
new file mode 100644
index 00000000000..5b488358011
--- /dev/null
+++ b/tests/ui/write_literal_2.stderr
@@ -0,0 +1,106 @@
+error: literal with an empty format string
+  --> $DIR/write_literal_2.rs:9:28
+   |
+LL |     writeln!(&mut v, "{}", "{hello}");
+   |                            ^^^^^^^^^
+   |
+   = note: `-D clippy::write-literal` implied by `-D warnings`
+help: try this
+   |
+LL |     writeln!(&mut v, "{{hello}}");
+   |                       ^^^^^^^^^--
+
+error: literal with an empty format string
+  --> $DIR/write_literal_2.rs:10:29
+   |
+LL |     writeln!(&mut v, r"{}", r"{hello}");
+   |                             ^^^^^^^^^^
+   |
+help: try this
+   |
+LL |     writeln!(&mut v, r"{{hello}}");
+   |                        ^^^^^^^^^--
+
+error: literal with an empty format string
+  --> $DIR/write_literal_2.rs:11:28
+   |
+LL |     writeln!(&mut v, "{}", '/'');
+   |                            ^^^^
+   |
+help: try this
+   |
+LL |     writeln!(&mut v, "'");
+   |                       ^--
+
+error: literal with an empty format string
+  --> $DIR/write_literal_2.rs:12:28
+   |
+LL |     writeln!(&mut v, "{}", '"');
+   |                            ^^^
+   |
+help: try this
+   |
+LL |     writeln!(&mut v, "/"");
+   |                       ^^--
+
+error: literal with an empty format string
+  --> $DIR/write_literal_2.rs:14:29
+   |
+LL |     writeln!(&mut v, r"{}", '/'');
+   |                             ^^^^
+   |
+help: try this
+   |
+LL |     writeln!(&mut v, r"'");
+   |                        ^--
+
+error: literal with an empty format string
+  --> $DIR/write_literal_2.rs:18:9
+   |
+LL | /         "hello /
+LL | |         world!"
+   | |_______________^
+   |
+help: try this
+   |
+LL |         "some hello /
+LL |         world!"
+   |
+
+error: literal with an empty format string
+  --> $DIR/write_literal_2.rs:25:9
+   |
+LL |         "1", "2", "3",
+   |         ^^^
+   |
+help: try this
+   |
+LL |         "some 1{} / {}", "2", "3",
+   |               ^        --
+
+error: literal with an empty format string
+  --> $DIR/write_literal_2.rs:25:14
+   |
+LL |         "1", "2", "3",
+   |              ^^^
+   |
+help: try this
+   |
+LL |         2 / {}",
+LL |         "1", "3",
+   |
+
+error: literal with an empty format string
+  --> $DIR/write_literal_2.rs:25:19
+   |
+LL |         "1", "2", "3",
+   |                   ^^^
+   |
+help: try this
+   |
+LL |         {} / 3",
+LL |         "1", "2",
+   |
+
+error: aborting due to 9 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From d45873b4c151898876da73746300ac29d5448e62 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Tue, 16 Mar 2021 12:06:41 -0400
Subject: Remove SmallVec

---
 clippy_lints/src/write.rs | 42 ++++++++++++++++++++++++------------------
 1 file changed, 24 insertions(+), 18 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs
index e416eab7914..12a47a6b703 100644
--- a/clippy_lints/src/write.rs
+++ b/clippy_lints/src/write.rs
@@ -14,7 +14,6 @@ use rustc_parse::parser;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::symbol::{kw, Symbol};
 use rustc_span::{sym, BytePos, Span, DUMMY_SP};
-use smallvec::SmallVec;
 
 declare_clippy_lint! {
     /// **What it does:** This lint warns when you use `println!("")` to
@@ -359,8 +358,8 @@ fn newline_span(fmtstr: &StrLit) -> Span {
 /// empty format string.
 #[derive(Default)]
 struct SimpleFormatArgs {
-    unnamed: Vec<SmallVec<[Span; 1]>>,
-    named: Vec<(Symbol, SmallVec<[Span; 1]>)>,
+    unnamed: Vec<Vec<Span>>,
+    named: Vec<(Symbol, Vec<Span>)>,
 }
 impl SimpleFormatArgs {
     fn get_unnamed(&self) -> impl Iterator<Item = &[Span]> {
@@ -396,11 +395,11 @@ impl SimpleFormatArgs {
             ArgumentIs(n) | ArgumentImplicitlyIs(n) => {
                 if self.unnamed.len() <= n {
                     // Use a dummy span to mark all unseen arguments.
-                    self.unnamed.resize_with(n, || SmallVec::from([DUMMY_SP]));
+                    self.unnamed.resize_with(n, || vec![DUMMY_SP]);
                     if arg.format == SIMPLE {
-                        self.unnamed.push(SmallVec::from([span]));
+                        self.unnamed.push(vec![span]);
                     } else {
-                        self.unnamed.push(SmallVec::new());
+                        self.unnamed.push(Vec::new());
                     }
                 } else {
                     let args = &mut self.unnamed[n];
@@ -410,7 +409,7 @@ impl SimpleFormatArgs {
                         // Replace the dummy span, if it exists.
                         ([dummy @ DUMMY_SP], true) => *dummy = span,
                         ([_, ..], true) => args.push(span),
-                        ([_, ..], false) => *args = SmallVec::new(),
+                        ([_, ..], false) => *args = Vec::new(),
                     }
                 }
             },
@@ -420,12 +419,12 @@ impl SimpleFormatArgs {
                         // A non-empty format string has been seen already.
                         [] => (),
                         [_, ..] if arg.format == SIMPLE => x.1.push(span),
-                        [_, ..] => x.1 = SmallVec::new(),
+                        [_, ..] => x.1 = Vec::new(),
                     }
                 } else if arg.format == SIMPLE {
-                    self.named.push((n, SmallVec::from([span])));
+                    self.named.push((n, vec![span]));
                 } else {
-                    self.named.push((n, SmallVec::new()));
+                    self.named.push((n, Vec::new()));
                 }
             },
         };
@@ -436,16 +435,16 @@ impl Write {
     /// Parses a format string into a collection of spans for each argument. This only keeps track
     /// of empty format arguments. Will also lint usages of debug format strings outside of debug
     /// impls.
-    fn parse_fmt_string(&self, cx: &EarlyContext<'_>, str: &StrLit) -> Option<SimpleFormatArgs> {
+    fn parse_fmt_string(&self, cx: &EarlyContext<'_>, str_lit: &StrLit) -> Option<SimpleFormatArgs> {
         use rustc_parse_format::{ParseMode, Parser, Piece};
 
-        let str_sym = str.symbol_unescaped.as_str();
-        let style = match str.style {
+        let str_sym = str_lit.symbol_unescaped.as_str();
+        let style = match str_lit.style {
             StrStyle::Cooked => None,
             StrStyle::Raw(n) => Some(n as usize),
         };
 
-        let mut parser = Parser::new(&str_sym, style, snippet_opt(cx, str.span), false, ParseMode::Format);
+        let mut parser = Parser::new(&str_sym, style, snippet_opt(cx, str_lit.span), false, ParseMode::Format);
         let mut args = SimpleFormatArgs::default();
 
         while let Some(arg) = parser.next() {
@@ -453,7 +452,10 @@ impl Write {
                 Piece::String(_) => continue,
                 Piece::NextArgument(arg) => arg,
             };
-            let span = parser.arg_places.last().map_or(DUMMY_SP, |&x| str.span.from_inner(x));
+            let span = parser
+                .arg_places
+                .last()
+                .map_or(DUMMY_SP, |&x| str_lit.span.from_inner(x));
 
             if !self.in_debug_impl && arg.format.ty == "?" {
                 // FIXME: modify rustc's fmt string parser to give us the current span
@@ -489,7 +491,11 @@ impl Write {
     fn check_tts<'a>(&self, cx: &EarlyContext<'a>, tts: TokenStream, is_write: bool) -> (Option<StrLit>, Option<Expr>) {
         let mut parser = parser::Parser::new(&cx.sess.parse_sess, tts, false, None);
         let expr = if is_write {
-            match parser.parse_expr().map(|e| e.into_inner()).map_err(|mut e| e.cancel()) {
+            match parser
+                .parse_expr()
+                .map(rustc_ast::ptr::P::into_inner)
+                .map_err(|mut e| e.cancel())
+            {
                 // write!(e, ...)
                 Ok(p) if parser.eat(&token::Comma) => Some(p),
                 // write!(e) or error
@@ -543,14 +549,14 @@ impl Write {
                     lit.token.symbol.as_str().replace("{", "{{").replace("}", "}}")
                 },
                 LitKind::StrRaw(_) | LitKind::Str | LitKind::ByteStrRaw(_) | LitKind::ByteStr => continue,
-                LitKind::Byte | LitKind::Char => match lit.token.symbol.as_str().deref() {
+                LitKind::Byte | LitKind::Char => match &*lit.token.symbol.as_str() {
                     "\"" if matches!(fmtstr.style, StrStyle::Cooked) => "\\\"",
                     "\"" if matches!(fmtstr.style, StrStyle::Raw(0)) => continue,
                     "\\\\" if matches!(fmtstr.style, StrStyle::Raw(_)) => "\\",
                     "\\'" => "'",
                     "{" => "{{",
                     "}" => "}}",
-                    x if matches!(fmtstr.style, StrStyle::Raw(_)) && x.starts_with("\\") => continue,
+                    x if matches!(fmtstr.style, StrStyle::Raw(_)) && x.starts_with('\\') => continue,
                     x => x,
                 }
                 .into(),
-- 
cgit 1.4.1-3-g733a5


From 0743e841f07b7c41f65187fbf71f90bb5dc71982 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Tue, 16 Mar 2021 11:06:34 -0500
Subject: Don't re-export clippy_utils::*

---
 clippy_lints/src/assertions_on_constants.rs           |  2 +-
 clippy_lints/src/assign_ops.rs                        |  6 +++---
 clippy_lints/src/atomic_ordering.rs                   |  2 +-
 clippy_lints/src/attrs.rs                             |  2 +-
 clippy_lints/src/await_holding_invalid.rs             |  2 +-
 clippy_lints/src/bit_mask.rs                          |  2 +-
 clippy_lints/src/blocks_in_if_conditions.rs           |  2 +-
 clippy_lints/src/booleans.rs                          |  2 +-
 clippy_lints/src/bytecount.rs                         |  2 +-
 clippy_lints/src/cargo_common_metadata.rs             |  2 +-
 clippy_lints/src/casts/cast_lossless.rs               |  3 +--
 clippy_lints/src/casts/cast_possible_truncation.rs    |  3 +--
 clippy_lints/src/casts/cast_ptr_alignment.rs          |  6 ++----
 clippy_lints/src/casts/cast_sign_loss.rs              | 10 ++++------
 clippy_lints/src/casts/mod.rs                         |  3 +--
 clippy_lints/src/casts/ptr_as_ptr.rs                  | 10 ++++------
 clippy_lints/src/casts/unnecessary_cast.rs            |  3 +--
 clippy_lints/src/checked_conversions.rs               |  3 +--
 clippy_lints/src/cognitive_complexity.rs              |  3 +--
 clippy_lints/src/collapsible_if.rs                    |  3 +--
 clippy_lints/src/collapsible_match.rs                 |  4 ++--
 clippy_lints/src/comparison_chain.rs                  |  2 +-
 clippy_lints/src/copies.rs                            |  4 ++--
 clippy_lints/src/create_dir.rs                        |  2 +-
 clippy_lints/src/default.rs                           |  2 +-
 clippy_lints/src/dereference.rs                       |  2 +-
 clippy_lints/src/derive.rs                            |  4 ++--
 clippy_lints/src/disallowed_method.rs                 |  2 +-
 clippy_lints/src/doc.rs                               |  2 +-
 clippy_lints/src/double_comparison.rs                 |  3 +--
 clippy_lints/src/drop_forget_ref.rs                   |  2 +-
 clippy_lints/src/duration_subsec.rs                   |  2 +-
 clippy_lints/src/entry.rs                             |  4 ++--
 clippy_lints/src/enum_variants.rs                     |  2 +-
 clippy_lints/src/eq_op.rs                             |  2 +-
 clippy_lints/src/eta_reduction.rs                     |  3 +--
 clippy_lints/src/eval_order_dependence.rs             |  2 +-
 clippy_lints/src/excessive_bools.rs                   |  2 +-
 clippy_lints/src/exit.rs                              |  2 +-
 clippy_lints/src/explicit_write.rs                    |  2 +-
 clippy_lints/src/fallible_impl_from.rs                |  2 +-
 clippy_lints/src/float_equality_without_abs.rs        |  2 +-
 clippy_lints/src/float_literal.rs                     |  2 +-
 clippy_lints/src/floating_point_arithmetic.rs         |  2 +-
 clippy_lints/src/format.rs                            |  4 ++--
 clippy_lints/src/formatting.rs                        |  2 +-
 clippy_lints/src/from_over_into.rs                    |  4 ++--
 clippy_lints/src/from_str_radix_10.rs                 |  3 +--
 clippy_lints/src/functions.rs                         |  8 ++++----
 clippy_lints/src/future_not_send.rs                   |  4 ++--
 clippy_lints/src/get_last_with_len.rs                 |  2 +-
 clippy_lints/src/identity_op.rs                       |  2 +-
 clippy_lints/src/if_let_mutex.rs                      |  2 +-
 clippy_lints/src/if_let_some_result.rs                |  2 +-
 clippy_lints/src/if_then_some_else_none.rs            | 10 +++++-----
 clippy_lints/src/implicit_return.rs                   |  2 +-
 clippy_lints/src/implicit_saturating_sub.rs           |  2 +-
 clippy_lints/src/indexing_slicing.rs                  |  2 +-
 clippy_lints/src/infinite_iter.rs                     |  3 +--
 clippy_lints/src/inherent_impl.rs                     |  2 +-
 clippy_lints/src/inherent_to_string.rs                |  3 +--
 clippy_lints/src/inline_fn_without_body.rs            |  2 +-
 clippy_lints/src/len_zero.rs                          |  2 +-
 clippy_lints/src/let_if_seq.rs                        |  2 +-
 clippy_lints/src/let_underscore.rs                    |  3 +--
 clippy_lints/src/lib.rs                               |  2 +-
 clippy_lints/src/lifetimes.rs                         |  2 +-
 clippy_lints/src/literal_representation.rs            |  6 +++---
 clippy_lints/src/loops/empty_loop.rs                  |  2 +-
 clippy_lints/src/loops/explicit_counter_loop.rs       |  2 +-
 clippy_lints/src/loops/explicit_iter_loop.rs          |  2 +-
 clippy_lints/src/loops/for_kv_map.rs                  |  4 ++--
 clippy_lints/src/loops/iter_next_loop.rs              |  3 +--
 clippy_lints/src/loops/manual_flatten.rs              |  2 +-
 clippy_lints/src/loops/manual_memcpy.rs               |  4 ++--
 clippy_lints/src/loops/mod.rs                         |  2 +-
 clippy_lints/src/loops/mut_range_bound.rs             |  2 +-
 clippy_lints/src/loops/needless_collect.rs            |  4 ++--
 clippy_lints/src/loops/needless_range_loop.rs         |  8 ++++----
 clippy_lints/src/loops/single_element_loop.rs         |  2 +-
 clippy_lints/src/loops/utils.rs                       |  2 +-
 clippy_lints/src/loops/while_immutable_condition.rs   |  2 +-
 clippy_lints/src/loops/while_let_on_iterator.rs       |  8 ++++----
 clippy_lints/src/macro_use.rs                         |  2 +-
 clippy_lints/src/main_recursion.rs                    |  3 +--
 clippy_lints/src/manual_async_fn.rs                   |  4 ++--
 clippy_lints/src/manual_map.rs                        |  7 ++-----
 clippy_lints/src/manual_non_exhaustive.rs             |  2 +-
 clippy_lints/src/manual_ok_or.rs                      |  2 +-
 clippy_lints/src/manual_strip.rs                      |  4 ++--
 clippy_lints/src/manual_unwrap_or.rs                  | 14 +++++++-------
 clippy_lints/src/map_clone.rs                         |  4 ++--
 clippy_lints/src/map_identity.rs                      |  2 +-
 clippy_lints/src/map_unit_fn.rs                       |  2 +-
 clippy_lints/src/matches.rs                           | 16 ++++++++--------
 clippy_lints/src/mem_discriminant.rs                  |  2 +-
 clippy_lints/src/mem_forget.rs                        |  2 +-
 clippy_lints/src/mem_replace.rs                       |  2 +-
 clippy_lints/src/methods/bind_instead_of_map.rs       |  2 +-
 clippy_lints/src/methods/clone_on_copy.rs             |  2 +-
 clippy_lints/src/methods/clone_on_ref_ptr.rs          |  2 +-
 clippy_lints/src/methods/expect_fun_call.rs           |  2 +-
 clippy_lints/src/methods/filetype_is_file.rs          |  2 +-
 clippy_lints/src/methods/filter_flat_map.rs           |  2 +-
 clippy_lints/src/methods/filter_map.rs                |  2 +-
 clippy_lints/src/methods/filter_map_flat_map.rs       |  2 +-
 clippy_lints/src/methods/filter_map_identity.rs       |  2 +-
 clippy_lints/src/methods/filter_map_map.rs            |  2 +-
 clippy_lints/src/methods/filter_map_next.rs           |  2 +-
 clippy_lints/src/methods/filter_next.rs               |  2 +-
 clippy_lints/src/methods/flat_map_identity.rs         |  2 +-
 .../src/methods/from_iter_instead_of_collect.rs       |  2 +-
 clippy_lints/src/methods/get_unwrap.rs                |  2 +-
 clippy_lints/src/methods/inefficient_to_string.rs     |  2 +-
 clippy_lints/src/methods/inspect_for_each.rs          |  3 +--
 clippy_lints/src/methods/into_iter_on_ref.rs          |  2 +-
 clippy_lints/src/methods/iter_count.rs                |  2 +-
 clippy_lints/src/methods/iter_next_slice.rs           |  2 +-
 clippy_lints/src/methods/iter_nth_zero.rs             |  2 +-
 clippy_lints/src/methods/iter_skip_next.rs            |  2 +-
 clippy_lints/src/methods/iterator_step_by_zero.rs     |  2 +-
 .../src/methods/manual_saturating_arithmetic.rs       |  2 +-
 clippy_lints/src/methods/map_collect_result_unit.rs   |  2 +-
 clippy_lints/src/methods/map_flatten.rs               |  2 +-
 clippy_lints/src/methods/map_unwrap_or.rs             |  4 ++--
 clippy_lints/src/methods/mod.rs                       |  9 ++++-----
 clippy_lints/src/methods/option_as_ref_deref.rs       |  2 +-
 clippy_lints/src/methods/option_map_or_none.rs        |  2 +-
 clippy_lints/src/methods/option_map_unwrap_or.rs      |  2 +-
 clippy_lints/src/methods/or_fun_call.rs               |  4 ++--
 clippy_lints/src/methods/search_is_some.rs            |  2 +-
 clippy_lints/src/methods/skip_while_next.rs           |  2 +-
 clippy_lints/src/methods/string_extend_chars.rs       |  2 +-
 clippy_lints/src/methods/suspicious_map.rs            |  4 ++--
 clippy_lints/src/methods/uninit_assumed_init.rs       |  2 +-
 clippy_lints/src/methods/unnecessary_filter_map.rs    |  7 +++----
 clippy_lints/src/methods/unnecessary_fold.rs          |  2 +-
 clippy_lints/src/methods/unnecessary_lazy_eval.rs     |  2 +-
 clippy_lints/src/methods/useless_asref.rs             |  2 +-
 clippy_lints/src/minmax.rs                            |  2 +-
 clippy_lints/src/misc.rs                              |  4 ++--
 clippy_lints/src/missing_const_for_fn.rs              |  4 ++--
 clippy_lints/src/modulo_arithmetic.rs                 |  2 +-
 clippy_lints/src/multiple_crate_versions.rs           |  2 +-
 clippy_lints/src/mut_key.rs                           |  2 +-
 clippy_lints/src/mut_mut.rs                           |  2 +-
 clippy_lints/src/mutable_debug_assertion.rs           |  2 +-
 clippy_lints/src/needless_arbitrary_self_type.rs      |  2 +-
 clippy_lints/src/needless_bool.rs                     |  4 ++--
 clippy_lints/src/needless_borrow.rs                   |  2 +-
 clippy_lints/src/needless_pass_by_value.rs            |  4 ++--
 clippy_lints/src/needless_question_mark.rs            | 11 +++++------
 clippy_lints/src/neg_cmp_op_on_partial_ord.rs         |  5 ++---
 clippy_lints/src/new_without_default.rs               |  6 +++---
 clippy_lints/src/non_copy_const.rs                    |  5 ++---
 clippy_lints/src/open_options.rs                      |  2 +-
 clippy_lints/src/option_env_unwrap.rs                 |  2 +-
 clippy_lints/src/option_if_let_else.rs                | 19 +++++++++----------
 clippy_lints/src/overflow_check_conditional.rs        |  2 +-
 clippy_lints/src/panic_in_result_fn.rs                |  2 +-
 clippy_lints/src/panic_unimplemented.rs               |  2 +-
 clippy_lints/src/partialeq_ne_impl.rs                 |  2 +-
 clippy_lints/src/pass_by_ref_or_value.rs              |  2 +-
 clippy_lints/src/pattern_type_mismatch.rs             |  2 +-
 clippy_lints/src/ptr.rs                               |  4 ++--
 clippy_lints/src/ptr_eq.rs                            |  4 ++--
 clippy_lints/src/question_mark.rs                     |  7 +++----
 clippy_lints/src/ranges.rs                            |  7 +++----
 clippy_lints/src/redundant_clone.rs                   |  2 +-
 clippy_lints/src/redundant_field_names.rs             |  2 +-
 clippy_lints/src/redundant_static_lifetimes.rs        |  2 +-
 clippy_lints/src/ref_option_ref.rs                    |  2 +-
 clippy_lints/src/reference.rs                         |  4 ++--
 clippy_lints/src/regex.rs                             |  2 +-
 clippy_lints/src/repeat_once.rs                       |  2 +-
 clippy_lints/src/returns.rs                           |  3 +--
 clippy_lints/src/self_assignment.rs                   |  2 +-
 clippy_lints/src/semicolon_if_nothing_returned.rs     |  2 +-
 clippy_lints/src/serde_api.rs                         |  2 +-
 clippy_lints/src/shadow.rs                            |  2 +-
 clippy_lints/src/single_component_path_imports.rs     |  2 +-
 clippy_lints/src/size_of_in_element_count.rs          |  2 +-
 clippy_lints/src/slow_vector_initialization.rs        |  4 ++--
 clippy_lints/src/stable_sort_primitive.rs             |  4 +---
 clippy_lints/src/strings.rs                           |  4 ++--
 clippy_lints/src/suspicious_operation_groupings.rs    |  2 +-
 clippy_lints/src/suspicious_trait_impl.rs             |  4 ++--
 clippy_lints/src/swap.rs                              |  4 ++--
 clippy_lints/src/temporary_assignment.rs              |  2 +-
 clippy_lints/src/to_digit_is_some.rs                  |  2 +-
 clippy_lints/src/to_string_in_display.rs              |  2 +-
 clippy_lints/src/trait_bounds.rs                      |  2 +-
 clippy_lints/src/transmute/mod.rs                     |  2 +-
 clippy_lints/src/transmute/transmute_float_to_int.rs  |  2 +-
 clippy_lints/src/transmute/transmute_int_to_bool.rs   |  2 +-
 clippy_lints/src/transmute/transmute_int_to_char.rs   |  2 +-
 clippy_lints/src/transmute/transmute_int_to_float.rs  |  2 +-
 clippy_lints/src/transmute/transmute_ptr_to_ptr.rs    |  2 +-
 clippy_lints/src/transmute/transmute_ptr_to_ref.rs    |  2 +-
 clippy_lints/src/transmute/transmute_ref_to_ref.rs    |  2 +-
 .../transmute/transmutes_expressible_as_ptr_casts.rs  |  2 +-
 .../src/transmute/unsound_collection_transmute.rs     |  2 +-
 clippy_lints/src/transmute/useless_transmute.rs       |  2 +-
 clippy_lints/src/transmute/utils.rs                   |  2 +-
 clippy_lints/src/transmuting_null.rs                  |  2 +-
 clippy_lints/src/try_err.rs                           |  2 +-
 clippy_lints/src/types/borrowed_box.rs                |  2 +-
 clippy_lints/src/types/box_vec.rs                     |  3 +--
 clippy_lints/src/types/linked_list.rs                 |  3 +--
 clippy_lints/src/types/mod.rs                         |  8 ++++----
 clippy_lints/src/types/option_option.rs               |  3 +--
 clippy_lints/src/types/rc_buffer.rs                   |  3 +--
 clippy_lints/src/types/redundant_allocation.rs        |  3 +--
 clippy_lints/src/types/utils.rs                       |  6 ++----
 clippy_lints/src/types/vec_box.rs                     |  3 +--
 clippy_lints/src/undropped_manually_drops.rs          |  2 +-
 clippy_lints/src/unicode.rs                           |  2 +-
 clippy_lints/src/unit_return_expecting_ord.rs         |  2 +-
 clippy_lints/src/unit_types/let_unit_value.rs         |  7 +++----
 clippy_lints/src/unit_types/unit_arg.rs               |  8 +++-----
 clippy_lints/src/unit_types/unit_cmp.rs               |  3 +--
 clippy_lints/src/unnamed_address.rs                   |  2 +-
 clippy_lints/src/unnecessary_sort_by.rs               |  2 +-
 clippy_lints/src/unnecessary_wraps.rs                 |  2 +-
 clippy_lints/src/unnested_or_patterns.rs              |  4 ++--
 clippy_lints/src/unused_io_amount.rs                  |  2 +-
 clippy_lints/src/unused_self.rs                       |  3 +--
 clippy_lints/src/unused_unit.rs                       |  3 +--
 clippy_lints/src/unwrap.rs                            |  2 +-
 clippy_lints/src/unwrap_in_result.rs                  |  2 +-
 clippy_lints/src/use_self.rs                          |  2 +-
 clippy_lints/src/useless_conversion.rs                |  4 ++--
 clippy_lints/src/utils/author.rs                      |  2 +-
 clippy_lints/src/utils/inspector.rs                   |  2 +-
 clippy_lints/src/utils/internal_lints.rs              |  3 +--
 clippy_lints/src/utils/mod.rs                         |  2 --
 clippy_lints/src/vec.rs                               |  2 +-
 clippy_lints/src/vec_init_then_push.rs                |  2 +-
 clippy_lints/src/vec_resize_to_zero.rs                |  7 +++----
 clippy_lints/src/verbose_file_reads.rs                |  2 +-
 clippy_lints/src/wildcard_dependencies.rs             |  2 +-
 clippy_lints/src/wildcard_imports.rs                  |  2 +-
 clippy_lints/src/zero_sized_map_values.rs             |  3 +--
 243 files changed, 344 insertions(+), 399 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/assertions_on_constants.rs b/clippy_lints/src/assertions_on_constants.rs
index bae4d4957a9..16905781c56 100644
--- a/clippy_lints/src/assertions_on_constants.rs
+++ b/clippy_lints/src/assertions_on_constants.rs
@@ -1,7 +1,7 @@
 use crate::consts::{constant, Constant};
-use crate::utils::{is_direct_expn_of, is_expn_of, match_panic_call};
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::source::snippet_opt;
+use clippy_utils::{is_direct_expn_of, is_expn_of, match_panic_call};
 use if_chain::if_chain;
 use rustc_hir::{Expr, ExprKind, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/assign_ops.rs b/clippy_lints/src/assign_ops.rs
index 8581e176e0c..5b8fb9b436a 100644
--- a/clippy_lints/src/assign_ops.rs
+++ b/clippy_lints/src/assign_ops.rs
@@ -1,8 +1,8 @@
-use crate::utils::{eq_expr_value, get_trait_def_id, trait_ref_of_method};
-use crate::utils::{higher, sugg};
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::implements_trait;
+use clippy_utils::{eq_expr_value, get_trait_def_id, trait_ref_of_method};
+use clippy_utils::{higher, sugg};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
@@ -93,7 +93,7 @@ impl<'tcx> LateLintPass<'tcx> for AssignOps {
                              $($trait_name:ident),+) => {
                                 match $op {
                                     $(hir::BinOpKind::$trait_name => {
-                                        let [krate, module] = crate::utils::paths::OPS_MODULE;
+                                        let [krate, module] = clippy_utils::paths::OPS_MODULE;
                                         let path: [&str; 3] = [krate, module, concat!(stringify!($trait_name), "Assign")];
                                         let trait_id = if let Some(trait_id) = get_trait_def_id($cx, &path) {
                                             trait_id
diff --git a/clippy_lints/src/atomic_ordering.rs b/clippy_lints/src/atomic_ordering.rs
index 231e74e16c0..dfb18199325 100644
--- a/clippy_lints/src/atomic_ordering.rs
+++ b/clippy_lints/src/atomic_ordering.rs
@@ -1,5 +1,5 @@
-use crate::utils::match_def_path;
 use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::match_def_path;
 use if_chain::if_chain;
 use rustc_hir::def_id::DefId;
 use rustc_hir::{Expr, ExprKind};
diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs
index 6be6722375d..f805f716e6b 100644
--- a/clippy_lints/src/attrs.rs
+++ b/clippy_lints/src/attrs.rs
@@ -1,7 +1,7 @@
 //! checks for attributes
 
-use crate::utils::match_panic_def_id;
 use clippy_utils::diagnostics::{span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then};
+use clippy_utils::match_panic_def_id;
 use clippy_utils::source::{first_line_of_span, is_present_in_source, snippet_opt, without_block_comments};
 use if_chain::if_chain;
 use rustc_ast::{AttrKind, AttrStyle, Attribute, Lit, LitKind, MetaItemKind, NestedMetaItem};
diff --git a/clippy_lints/src/await_holding_invalid.rs b/clippy_lints/src/await_holding_invalid.rs
index 3a3296c2c3d..68eee0520b3 100644
--- a/clippy_lints/src/await_holding_invalid.rs
+++ b/clippy_lints/src/await_holding_invalid.rs
@@ -1,5 +1,5 @@
-use crate::utils::{match_def_path, paths};
 use clippy_utils::diagnostics::span_lint_and_note;
+use clippy_utils::{match_def_path, paths};
 use rustc_hir::def_id::DefId;
 use rustc_hir::{AsyncGeneratorKind, Body, BodyId, GeneratorKind};
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/bit_mask.rs b/clippy_lints/src/bit_mask.rs
index 2b8400344f5..f7daf3dab49 100644
--- a/clippy_lints/src/bit_mask.rs
+++ b/clippy_lints/src/bit_mask.rs
@@ -1,6 +1,6 @@
 use crate::consts::{constant, Constant};
-use crate::utils::sugg::Sugg;
 use clippy_utils::diagnostics::{span_lint, span_lint_and_then};
+use clippy_utils::sugg::Sugg;
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/blocks_in_if_conditions.rs b/clippy_lints/src/blocks_in_if_conditions.rs
index 343c4821c56..badcf8d2a43 100644
--- a/clippy_lints/src/blocks_in_if_conditions.rs
+++ b/clippy_lints/src/blocks_in_if_conditions.rs
@@ -1,7 +1,7 @@
-use crate::utils::{differing_macro_contexts, get_parent_expr};
 use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg};
 use clippy_utils::source::snippet_block_with_applicability;
 use clippy_utils::ty::implements_trait;
+use clippy_utils::{differing_macro_contexts, get_parent_expr};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
diff --git a/clippy_lints/src/booleans.rs b/clippy_lints/src/booleans.rs
index 1303613b8c4..58d9aa9c005 100644
--- a/clippy_lints/src/booleans.rs
+++ b/clippy_lints/src/booleans.rs
@@ -1,7 +1,7 @@
-use crate::utils::{eq_expr_value, get_trait_def_id, in_macro, paths};
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::{implements_trait, is_type_diagnostic_item};
+use clippy_utils::{eq_expr_value, get_trait_def_id, in_macro, paths};
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/bytecount.rs b/clippy_lints/src/bytecount.rs
index c1ca787c1e5..846ac08e93a 100644
--- a/clippy_lints/src/bytecount.rs
+++ b/clippy_lints/src/bytecount.rs
@@ -1,7 +1,7 @@
-use crate::utils::{contains_name, get_pat_name, paths, single_segment_path};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::match_type;
+use clippy_utils::{contains_name, get_pat_name, paths, single_segment_path};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, BorrowKind, Expr, ExprKind, UnOp};
diff --git a/clippy_lints/src/cargo_common_metadata.rs b/clippy_lints/src/cargo_common_metadata.rs
index f0ef482164a..fce5c559672 100644
--- a/clippy_lints/src/cargo_common_metadata.rs
+++ b/clippy_lints/src/cargo_common_metadata.rs
@@ -2,8 +2,8 @@
 
 use std::path::PathBuf;
 
-use crate::utils::run_lints;
 use clippy_utils::diagnostics::span_lint;
+use clippy_utils::run_lints;
 use rustc_hir::{hir_id::CRATE_HIR_ID, Crate};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
diff --git a/clippy_lints/src/casts/cast_lossless.rs b/clippy_lints/src/casts/cast_lossless.rs
index 4b660188d82..869deecfbd5 100644
--- a/clippy_lints/src/casts/cast_lossless.rs
+++ b/clippy_lints/src/casts/cast_lossless.rs
@@ -1,4 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::in_constant;
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::is_isize_or_usize;
 use rustc_errors::Applicability;
@@ -6,8 +7,6 @@ use rustc_hir::{Expr, ExprKind};
 use rustc_lint::LateContext;
 use rustc_middle::ty::{self, FloatTy, Ty};
 
-use crate::utils::in_constant;
-
 use super::{utils, CAST_LOSSLESS};
 
 pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_op: &Expr<'_>, cast_from: Ty<'_>, cast_to: Ty<'_>) {
diff --git a/clippy_lints/src/casts/cast_possible_truncation.rs b/clippy_lints/src/casts/cast_possible_truncation.rs
index 75d7c55b637..833ad122e0d 100644
--- a/clippy_lints/src/casts/cast_possible_truncation.rs
+++ b/clippy_lints/src/casts/cast_possible_truncation.rs
@@ -1,10 +1,9 @@
+use clippy_utils::diagnostics::span_lint;
 use clippy_utils::ty::is_isize_or_usize;
 use rustc_hir::Expr;
 use rustc_lint::LateContext;
 use rustc_middle::ty::{self, FloatTy, Ty};
 
-use clippy_utils::diagnostics::span_lint;
-
 use super::{utils, CAST_POSSIBLE_TRUNCATION};
 
 pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_from: Ty<'_>, cast_to: Ty<'_>) {
diff --git a/clippy_lints/src/casts/cast_ptr_alignment.rs b/clippy_lints/src/casts/cast_ptr_alignment.rs
index 6a45ec61c54..5208156ffd2 100644
--- a/clippy_lints/src/casts/cast_ptr_alignment.rs
+++ b/clippy_lints/src/casts/cast_ptr_alignment.rs
@@ -1,14 +1,12 @@
 use clippy_utils::diagnostics::span_lint;
+use clippy_utils::is_hir_ty_cfg_dependant;
+use if_chain::if_chain;
 use rustc_hir::{Expr, ExprKind, GenericArg};
 use rustc_lint::LateContext;
 use rustc_middle::ty::{self, Ty};
 use rustc_span::symbol::sym;
 use rustc_target::abi::LayoutOf;
 
-use if_chain::if_chain;
-
-use crate::utils::is_hir_ty_cfg_dependant;
-
 use super::CAST_PTR_ALIGNMENT;
 
 pub(super) fn check(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
diff --git a/clippy_lints/src/casts/cast_sign_loss.rs b/clippy_lints/src/casts/cast_sign_loss.rs
index 2965a840a82..bf722d0a3f4 100644
--- a/clippy_lints/src/casts/cast_sign_loss.rs
+++ b/clippy_lints/src/casts/cast_sign_loss.rs
@@ -1,13 +1,11 @@
+use crate::consts::{constant, Constant};
+use clippy_utils::diagnostics::span_lint;
+use clippy_utils::{method_chain_args, sext};
+use if_chain::if_chain;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::LateContext;
 use rustc_middle::ty::{self, Ty};
 
-use if_chain::if_chain;
-
-use crate::consts::{constant, Constant};
-use crate::utils::{method_chain_args, sext};
-use clippy_utils::diagnostics::span_lint;
-
 use super::CAST_SIGN_LOSS;
 
 pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_op: &Expr<'_>, cast_from: Ty<'_>, cast_to: Ty<'_>) {
diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index b726bd75f1d..d9e172c01a7 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -12,14 +12,13 @@ mod ptr_as_ptr;
 mod unnecessary_cast;
 mod utils;
 
+use clippy_utils::is_hir_ty_cfg_dependant;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 
-use crate::utils::is_hir_ty_cfg_dependant;
-
 declare_clippy_lint! {
     /// **What it does:** Checks for casts from any numerical to a float type where
     /// the receiving type cannot store all values from the original type without
diff --git a/clippy_lints/src/casts/ptr_as_ptr.rs b/clippy_lints/src/casts/ptr_as_ptr.rs
index 2c25f865cb8..9113e5a0920 100644
--- a/clippy_lints/src/casts/ptr_as_ptr.rs
+++ b/clippy_lints/src/casts/ptr_as_ptr.rs
@@ -1,17 +1,15 @@
 use std::borrow::Cow;
 
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::meets_msrv;
+use clippy_utils::sugg::Sugg;
+use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, Mutability, TyKind};
 use rustc_lint::LateContext;
 use rustc_middle::ty::{self, TypeAndMut};
 use rustc_semver::RustcVersion;
 
-use if_chain::if_chain;
-
-use crate::utils::meets_msrv;
-use crate::utils::sugg::Sugg;
-use clippy_utils::diagnostics::span_lint_and_sugg;
-
 use super::PTR_AS_PTR;
 
 const PTR_AS_PTR_MSRV: RustcVersion = RustcVersion::new(1, 38, 0);
diff --git a/clippy_lints/src/casts/unnecessary_cast.rs b/clippy_lints/src/casts/unnecessary_cast.rs
index a84e658024a..9ed359922fd 100644
--- a/clippy_lints/src/casts/unnecessary_cast.rs
+++ b/clippy_lints/src/casts/unnecessary_cast.rs
@@ -1,4 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::numeric_literal::NumericLiteral;
 use clippy_utils::source::snippet_opt;
 use if_chain::if_chain;
 use rustc_ast::{LitFloatType, LitIntType, LitKind};
@@ -8,8 +9,6 @@ use rustc_lint::{LateContext, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::{self, FloatTy, InferTy, Ty};
 
-use crate::utils::numeric_literal::NumericLiteral;
-
 use super::UNNECESSARY_CAST;
 
 pub(super) fn check(
diff --git a/clippy_lints/src/checked_conversions.rs b/clippy_lints/src/checked_conversions.rs
index 8b62e315e04..ed46cac493a 100644
--- a/clippy_lints/src/checked_conversions.rs
+++ b/clippy_lints/src/checked_conversions.rs
@@ -2,6 +2,7 @@
 
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::{meets_msrv, SpanlessEq};
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
@@ -11,8 +12,6 @@ use rustc_middle::lint::in_external_macro;
 use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 
-use crate::utils::{meets_msrv, SpanlessEq};
-
 const CHECKED_CONVERSIONS_MSRV: RustcVersion = RustcVersion::new(1, 34, 0);
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/cognitive_complexity.rs b/clippy_lints/src/cognitive_complexity.rs
index 8134f3af3ef..4cc542f723c 100644
--- a/clippy_lints/src/cognitive_complexity.rs
+++ b/clippy_lints/src/cognitive_complexity.rs
@@ -3,6 +3,7 @@
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::LimitStack;
 use rustc_ast::ast::Attribute;
 use rustc_hir::intravisit::{walk_expr, FnKind, NestedVisitorMap, Visitor};
 use rustc_hir::{Body, Expr, ExprKind, FnDecl, HirId};
@@ -12,8 +13,6 @@ use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::Span;
 use rustc_span::{sym, BytePos};
 
-use crate::utils::LimitStack;
-
 declare_clippy_lint! {
     /// **What it does:** Checks for methods with high cognitive complexity.
     ///
diff --git a/clippy_lints/src/collapsible_if.rs b/clippy_lints/src/collapsible_if.rs
index dbe70f90732..dae5c86bd44 100644
--- a/clippy_lints/src/collapsible_if.rs
+++ b/clippy_lints/src/collapsible_if.rs
@@ -14,14 +14,13 @@
 
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::{snippet_block, snippet_block_with_applicability};
+use clippy_utils::sugg::Sugg;
 use if_chain::if_chain;
 use rustc_ast::ast;
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
-use crate::utils::sugg::Sugg;
-
 declare_clippy_lint! {
     /// **What it does:** Checks for nested `if` statements which can be collapsed
     /// by `&&`-combining their conditions.
diff --git a/clippy_lints/src/collapsible_match.rs b/clippy_lints/src/collapsible_match.rs
index 5ff2518bd94..e2b3686ddf0 100644
--- a/clippy_lints/src/collapsible_match.rs
+++ b/clippy_lints/src/collapsible_match.rs
@@ -1,6 +1,6 @@
-use crate::utils::visitors::LocalUsedVisitor;
-use crate::utils::{path_to_local, SpanlessEq};
 use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::visitors::LocalUsedVisitor;
+use clippy_utils::{path_to_local, SpanlessEq};
 use if_chain::if_chain;
 use rustc_hir::def::{CtorKind, CtorOf, DefKind, Res};
 use rustc_hir::{Arm, Expr, ExprKind, Guard, HirId, Pat, PatKind, QPath, StmtKind, UnOp};
diff --git a/clippy_lints/src/comparison_chain.rs b/clippy_lints/src/comparison_chain.rs
index 5411905791c..d601cb7c224 100644
--- a/clippy_lints/src/comparison_chain.rs
+++ b/clippy_lints/src/comparison_chain.rs
@@ -1,6 +1,6 @@
-use crate::utils::{get_trait_def_id, if_sequence, parent_node_is_if_expr, paths, SpanlessEq};
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::ty::implements_trait;
+use clippy_utils::{get_trait_def_id, if_sequence, parent_node_is_if_expr, paths, SpanlessEq};
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
diff --git a/clippy_lints/src/copies.rs b/clippy_lints/src/copies.rs
index f86f0da6d6f..46093a16571 100644
--- a/clippy_lints/src/copies.rs
+++ b/clippy_lints/src/copies.rs
@@ -1,6 +1,6 @@
-use crate::utils::{eq_expr_value, in_macro, search_same, SpanlessEq, SpanlessHash};
-use crate::utils::{get_parent_expr, if_sequence};
 use clippy_utils::diagnostics::span_lint_and_note;
+use clippy_utils::{eq_expr_value, in_macro, search_same, SpanlessEq, SpanlessHash};
+use clippy_utils::{get_parent_expr, if_sequence};
 use rustc_hir::{Block, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
diff --git a/clippy_lints/src/create_dir.rs b/clippy_lints/src/create_dir.rs
index 01ca2837a99..ac890c90c97 100644
--- a/clippy_lints/src/create_dir.rs
+++ b/clippy_lints/src/create_dir.rs
@@ -1,6 +1,6 @@
-use crate::utils::{match_def_path, paths};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet;
+use clippy_utils::{match_def_path, paths};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
diff --git a/clippy_lints/src/default.rs b/clippy_lints/src/default.rs
index 0b074c088d4..d046e894792 100644
--- a/clippy_lints/src/default.rs
+++ b/clippy_lints/src/default.rs
@@ -1,6 +1,6 @@
-use crate::utils::{any_parent_is_automatically_derived, contains_name, match_def_path, paths};
 use clippy_utils::diagnostics::{span_lint_and_note, span_lint_and_sugg};
 use clippy_utils::source::snippet_with_macro_callsite;
+use clippy_utils::{any_parent_is_automatically_derived, contains_name, match_def_path, paths};
 use if_chain::if_chain;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index 62ec2f8ce48..1415f8e235a 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -1,7 +1,7 @@
-use crate::utils::{get_parent_node, in_macro, is_allowed};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_context;
 use clippy_utils::ty::peel_mid_ty_refs;
+use clippy_utils::{get_parent_node, in_macro, is_allowed};
 use rustc_ast::util::parser::PREC_PREFIX;
 use rustc_errors::Applicability;
 use rustc_hir::{BorrowKind, Expr, ExprKind, HirId, MatchSource, Mutability, Node, UnOp};
diff --git a/clippy_lints/src/derive.rs b/clippy_lints/src/derive.rs
index a7f2106e357..834136f910d 100644
--- a/clippy_lints/src/derive.rs
+++ b/clippy_lints/src/derive.rs
@@ -1,7 +1,7 @@
-use crate::utils::paths;
-use crate::utils::{get_trait_def_id, is_allowed, is_automatically_derived, match_def_path};
 use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_note, span_lint_and_then};
+use clippy_utils::paths;
 use clippy_utils::ty::is_copy;
+use clippy_utils::{get_trait_def_id, is_allowed, is_automatically_derived, match_def_path};
 use if_chain::if_chain;
 use rustc_hir::def_id::DefId;
 use rustc_hir::intravisit::{walk_expr, walk_fn, walk_item, FnKind, NestedVisitorMap, Visitor};
diff --git a/clippy_lints/src/disallowed_method.rs b/clippy_lints/src/disallowed_method.rs
index 16023bc53b0..ded0a0fff54 100644
--- a/clippy_lints/src/disallowed_method.rs
+++ b/clippy_lints/src/disallowed_method.rs
@@ -1,5 +1,5 @@
-use crate::utils::fn_def_id;
 use clippy_utils::diagnostics::span_lint;
+use clippy_utils::fn_def_id;
 
 use rustc_data_structures::fx::FxHashSet;
 use rustc_hir::Expr;
diff --git a/clippy_lints/src/doc.rs b/clippy_lints/src/doc.rs
index d9952325c4b..5fa278b2897 100644
--- a/clippy_lints/src/doc.rs
+++ b/clippy_lints/src/doc.rs
@@ -1,6 +1,6 @@
-use crate::utils::{is_entrypoint_fn, is_expn_of, match_panic_def_id, method_chain_args, return_ty};
 use clippy_utils::diagnostics::{span_lint, span_lint_and_note};
 use clippy_utils::ty::{implements_trait, is_type_diagnostic_item};
+use clippy_utils::{is_entrypoint_fn, is_expn_of, match_panic_def_id, method_chain_args, return_ty};
 use if_chain::if_chain;
 use itertools::Itertools;
 use rustc_ast::ast::{Async, AttrKind, Attribute, FnKind, FnRetTy, ItemKind};
diff --git a/clippy_lints/src/double_comparison.rs b/clippy_lints/src/double_comparison.rs
index 549720feb2d..1d291565ec1 100644
--- a/clippy_lints/src/double_comparison.rs
+++ b/clippy_lints/src/double_comparison.rs
@@ -1,6 +1,7 @@
 //! Lint on unnecessary double comparisons. Some examples:
 
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::eq_expr_value;
 use clippy_utils::source::snippet_with_applicability;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind};
@@ -8,8 +9,6 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
 
-use crate::utils::eq_expr_value;
-
 declare_clippy_lint! {
     /// **What it does:** Checks for double comparisons that could be simplified to a single expression.
     ///
diff --git a/clippy_lints/src/drop_forget_ref.rs b/clippy_lints/src/drop_forget_ref.rs
index fe86adcec45..7e7ec017bbb 100644
--- a/clippy_lints/src/drop_forget_ref.rs
+++ b/clippy_lints/src/drop_forget_ref.rs
@@ -1,6 +1,6 @@
-use crate::utils::{match_def_path, paths};
 use clippy_utils::diagnostics::span_lint_and_note;
 use clippy_utils::ty::is_copy;
+use clippy_utils::{match_def_path, paths};
 use if_chain::if_chain;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/duration_subsec.rs b/clippy_lints/src/duration_subsec.rs
index 40c75f568ae..746c1f6df91 100644
--- a/clippy_lints/src/duration_subsec.rs
+++ b/clippy_lints/src/duration_subsec.rs
@@ -8,8 +8,8 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Spanned;
 
 use crate::consts::{constant, Constant};
-use crate::utils::paths;
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::paths;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for calculation of subsecond microseconds or milliseconds
diff --git a/clippy_lints/src/entry.rs b/clippy_lints/src/entry.rs
index cc774831491..25eb048448c 100644
--- a/clippy_lints/src/entry.rs
+++ b/clippy_lints/src/entry.rs
@@ -1,8 +1,8 @@
-use crate::utils::SpanlessEq;
-use crate::utils::{get_item_name, paths};
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::{snippet, snippet_opt, snippet_with_applicability};
 use clippy_utils::ty::{is_type_diagnostic_item, match_type};
+use clippy_utils::SpanlessEq;
+use clippy_utils::{get_item_name, paths};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
diff --git a/clippy_lints/src/enum_variants.rs b/clippy_lints/src/enum_variants.rs
index d2d8acb443b..0ecc0bc3eb6 100644
--- a/clippy_lints/src/enum_variants.rs
+++ b/clippy_lints/src/enum_variants.rs
@@ -1,6 +1,6 @@
 //! lint on enum variants that are prefixed or suffixed by the same characters
 
-use crate::utils::camel_case;
+use clippy_utils::camel_case;
 use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
 use clippy_utils::source::is_present_in_source;
 use rustc_ast::ast::{EnumDef, Item, ItemKind, VisibilityKind};
diff --git a/clippy_lints/src/eq_op.rs b/clippy_lints/src/eq_op.rs
index 1b2f66fb628..6d7046ac8b7 100644
--- a/clippy_lints/src/eq_op.rs
+++ b/clippy_lints/src/eq_op.rs
@@ -1,7 +1,7 @@
-use crate::utils::{ast_utils::is_useless_with_eq_exprs, eq_expr_value, higher, in_macro, is_expn_of};
 use clippy_utils::diagnostics::{multispan_sugg, span_lint, span_lint_and_then};
 use clippy_utils::source::snippet;
 use clippy_utils::ty::{implements_trait, is_copy};
+use clippy_utils::{ast_utils::is_useless_with_eq_exprs, eq_expr_value, higher, in_macro, is_expn_of};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, BorrowKind, Expr, ExprKind, StmtKind};
diff --git a/clippy_lints/src/eta_reduction.rs b/clippy_lints/src/eta_reduction.rs
index 2557e9f2796..99253555a95 100644
--- a/clippy_lints/src/eta_reduction.rs
+++ b/clippy_lints/src/eta_reduction.rs
@@ -3,6 +3,7 @@ use clippy_utils::higher;
 use clippy_utils::higher::VecArgs;
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::{implements_trait, type_is_unsafe_function};
+use clippy_utils::{is_adjusted, iter_input_pats};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{def_id, Expr, ExprKind, Param, PatKind, QPath};
@@ -11,8 +12,6 @@ use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::{self, Ty};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
-use crate::utils::{is_adjusted, iter_input_pats};
-
 declare_clippy_lint! {
     /// **What it does:** Checks for closures which just call another function where
     /// the function can be called directly. `unsafe` functions or calls where types
diff --git a/clippy_lints/src/eval_order_dependence.rs b/clippy_lints/src/eval_order_dependence.rs
index 3711ba4a7ee..5d5b67de843 100644
--- a/clippy_lints/src/eval_order_dependence.rs
+++ b/clippy_lints/src/eval_order_dependence.rs
@@ -1,5 +1,5 @@
-use crate::utils::{get_parent_expr, path_to_local, path_to_local_id};
 use clippy_utils::diagnostics::{span_lint, span_lint_and_note};
+use clippy_utils::{get_parent_expr, path_to_local, path_to_local_id};
 use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
 use rustc_hir::{BinOpKind, Block, Expr, ExprKind, Guard, HirId, Local, Node, Stmt, StmtKind};
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/excessive_bools.rs b/clippy_lints/src/excessive_bools.rs
index 683e0435351..6c9652fd87d 100644
--- a/clippy_lints/src/excessive_bools.rs
+++ b/clippy_lints/src/excessive_bools.rs
@@ -1,5 +1,5 @@
-use crate::utils::{attr_by_name, in_macro, match_path_ast};
 use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::{attr_by_name, in_macro, match_path_ast};
 use rustc_ast::ast::{AssocItemKind, Extern, FnKind, FnSig, ImplKind, Item, ItemKind, TraitKind, Ty, TyKind};
 use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
diff --git a/clippy_lints/src/exit.rs b/clippy_lints/src/exit.rs
index adfb644b199..635b6d83eab 100644
--- a/clippy_lints/src/exit.rs
+++ b/clippy_lints/src/exit.rs
@@ -1,5 +1,5 @@
-use crate::utils::{is_entrypoint_fn, match_def_path, paths};
 use clippy_utils::diagnostics::span_lint;
+use clippy_utils::{is_entrypoint_fn, match_def_path, paths};
 use if_chain::if_chain;
 use rustc_hir::{Expr, ExprKind, Item, ItemKind, Node};
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/explicit_write.rs b/clippy_lints/src/explicit_write.rs
index 0861cba4675..4146b7baa10 100644
--- a/clippy_lints/src/explicit_write.rs
+++ b/clippy_lints/src/explicit_write.rs
@@ -1,5 +1,5 @@
-use crate::utils::{is_expn_of, match_function_call, paths};
 use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg};
+use clippy_utils::{is_expn_of, match_function_call, paths};
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/fallible_impl_from.rs b/clippy_lints/src/fallible_impl_from.rs
index 5efe465a667..52a5a7acf0d 100644
--- a/clippy_lints/src/fallible_impl_from.rs
+++ b/clippy_lints/src/fallible_impl_from.rs
@@ -1,6 +1,6 @@
-use crate::utils::{is_expn_of, match_panic_def_id, method_chain_args};
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::{is_expn_of, match_panic_def_id, method_chain_args};
 use if_chain::if_chain;
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/float_equality_without_abs.rs b/clippy_lints/src/float_equality_without_abs.rs
index b3593d328cc..0c59db360f9 100644
--- a/clippy_lints/src/float_equality_without_abs.rs
+++ b/clippy_lints/src/float_equality_without_abs.rs
@@ -1,5 +1,5 @@
-use crate::utils::{match_def_path, paths, sugg};
 use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::{match_def_path, paths, sugg};
 use if_chain::if_chain;
 use rustc_ast::util::parser::AssocOp;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/float_literal.rs b/clippy_lints/src/float_literal.rs
index 6446fe62a64..1ca5c685a75 100644
--- a/clippy_lints/src/float_literal.rs
+++ b/clippy_lints/src/float_literal.rs
@@ -1,5 +1,5 @@
-use crate::utils::numeric_literal;
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::numeric_literal;
 use if_chain::if_chain;
 use rustc_ast::ast::{self, LitFloatType, LitKind};
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/floating_point_arithmetic.rs b/clippy_lints/src/floating_point_arithmetic.rs
index 8b53384ecbd..0b5f0379ce6 100644
--- a/clippy_lints/src/floating_point_arithmetic.rs
+++ b/clippy_lints/src/floating_point_arithmetic.rs
@@ -2,8 +2,8 @@ use crate::consts::{
     constant, constant_simple, Constant,
     Constant::{Int, F32, F64},
 };
-use crate::utils::{eq_expr_value, get_parent_expr, numeric_literal, sugg};
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::{eq_expr_value, get_parent_expr, numeric_literal, sugg};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind, PathSegment, UnOp};
diff --git a/clippy_lints/src/format.rs b/clippy_lints/src/format.rs
index db27225707d..a33f987b423 100644
--- a/clippy_lints/src/format.rs
+++ b/clippy_lints/src/format.rs
@@ -1,8 +1,8 @@
-use crate::utils::paths;
-use crate::utils::{is_expn_of, last_path_segment, match_def_path, match_function_call};
 use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::paths;
 use clippy_utils::source::{snippet, snippet_opt};
 use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::{is_expn_of, last_path_segment, match_def_path, match_function_call};
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/formatting.rs b/clippy_lints/src/formatting.rs
index 4dadd2ba936..b10e83c0ea8 100644
--- a/clippy_lints/src/formatting.rs
+++ b/clippy_lints/src/formatting.rs
@@ -1,5 +1,5 @@
-use crate::utils::differing_macro_contexts;
 use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_note};
+use clippy_utils::differing_macro_contexts;
 use clippy_utils::source::snippet_opt;
 use if_chain::if_chain;
 use rustc_ast::ast::{BinOpKind, Block, Expr, ExprKind, StmtKind, UnOp};
diff --git a/clippy_lints/src/from_over_into.rs b/clippy_lints/src/from_over_into.rs
index 5eea4d14759..e5ec245e502 100644
--- a/clippy_lints/src/from_over_into.rs
+++ b/clippy_lints/src/from_over_into.rs
@@ -1,6 +1,6 @@
-use crate::utils::paths::INTO;
-use crate::utils::{match_def_path, meets_msrv};
 use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::paths::INTO;
+use clippy_utils::{match_def_path, meets_msrv};
 use if_chain::if_chain;
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass, LintContext};
diff --git a/clippy_lints/src/from_str_radix_10.rs b/clippy_lints/src/from_str_radix_10.rs
index b9a44f26381..3da5bc95b6d 100644
--- a/clippy_lints/src/from_str_radix_10.rs
+++ b/clippy_lints/src/from_str_radix_10.rs
@@ -1,4 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
@@ -8,8 +9,6 @@ use rustc_middle::ty::Ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::symbol::sym;
 
-use crate::utils::sugg::Sugg;
-
 declare_clippy_lint! {
     /// **What it does:**
     /// Checks for function invocations of the form `primitive::from_str_radix(s, 10)`
diff --git a/clippy_lints/src/functions.rs b/clippy_lints/src/functions.rs
index 37288d7a0b2..730492fc7e3 100644
--- a/clippy_lints/src/functions.rs
+++ b/clippy_lints/src/functions.rs
@@ -1,10 +1,10 @@
-use crate::utils::{
-    attr_by_name, attrs::is_proc_macro, is_trait_impl_item, iter_input_pats, match_def_path, must_use_attr,
-    path_to_local, return_ty, trait_ref_of_method,
-};
 use clippy_utils::diagnostics::{span_lint, span_lint_and_help, span_lint_and_then};
 use clippy_utils::source::{snippet, snippet_opt};
 use clippy_utils::ty::{is_must_use_ty, is_type_diagnostic_item, type_is_unsafe_function};
+use clippy_utils::{
+    attr_by_name, attrs::is_proc_macro, is_trait_impl_item, iter_input_pats, match_def_path, must_use_attr,
+    path_to_local, return_ty, trait_ref_of_method,
+};
 use if_chain::if_chain;
 use rustc_ast::ast::Attribute;
 use rustc_data_structures::fx::FxHashSet;
diff --git a/clippy_lints/src/future_not_send.rs b/clippy_lints/src/future_not_send.rs
index 36960e7f51b..04730ace887 100644
--- a/clippy_lints/src/future_not_send.rs
+++ b/clippy_lints/src/future_not_send.rs
@@ -1,5 +1,5 @@
-use crate::utils;
 use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::return_ty;
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::{Body, FnDecl, HirId};
 use rustc_infer::infer::TyCtxtInferExt;
@@ -62,7 +62,7 @@ impl<'tcx> LateLintPass<'tcx> for FutureNotSend {
         if let FnKind::Closure = kind {
             return;
         }
-        let ret_ty = utils::return_ty(cx, hir_id);
+        let ret_ty = return_ty(cx, hir_id);
         if let Opaque(id, subst) = *ret_ty.kind() {
             let preds = cx.tcx.explicit_item_bounds(id);
             let mut is_future = false;
diff --git a/clippy_lints/src/get_last_with_len.rs b/clippy_lints/src/get_last_with_len.rs
index 6f14ede0ecb..cbcef567c53 100644
--- a/clippy_lints/src/get_last_with_len.rs
+++ b/clippy_lints/src/get_last_with_len.rs
@@ -1,9 +1,9 @@
 //! lint on using `x.get(x.len() - 1)` instead of `x.last()`
 
-use crate::utils::SpanlessEq;
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::SpanlessEq;
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/identity_op.rs b/clippy_lints/src/identity_op.rs
index 385ea020328..8bed5e1bf64 100644
--- a/clippy_lints/src/identity_op.rs
+++ b/clippy_lints/src/identity_op.rs
@@ -7,8 +7,8 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
 
 use crate::consts::{constant_simple, Constant};
-use crate::utils::{clip, unsext};
 use clippy_utils::diagnostics::span_lint;
+use clippy_utils::{clip, unsext};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for identity operations, e.g., `x + 0`.
diff --git a/clippy_lints/src/if_let_mutex.rs b/clippy_lints/src/if_let_mutex.rs
index c2ec8b3ffd1..4aab43256bf 100644
--- a/clippy_lints/src/if_let_mutex.rs
+++ b/clippy_lints/src/if_let_mutex.rs
@@ -1,6 +1,6 @@
-use crate::utils::SpanlessEq;
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::SpanlessEq;
 use if_chain::if_chain;
 use rustc_hir::intravisit::{self as visit, NestedVisitorMap, Visitor};
 use rustc_hir::{Expr, ExprKind, MatchSource};
diff --git a/clippy_lints/src/if_let_some_result.rs b/clippy_lints/src/if_let_some_result.rs
index 59094d1147a..6e9280c8c7e 100644
--- a/clippy_lints/src/if_let_some_result.rs
+++ b/clippy_lints/src/if_let_some_result.rs
@@ -1,5 +1,5 @@
-use crate::utils::method_chain_args;
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::method_chain_args;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
diff --git a/clippy_lints/src/if_then_some_else_none.rs b/clippy_lints/src/if_then_some_else_none.rs
index c4e87300b7b..0b5bf060d4c 100644
--- a/clippy_lints/src/if_then_some_else_none.rs
+++ b/clippy_lints/src/if_then_some_else_none.rs
@@ -1,6 +1,6 @@
-use crate::utils;
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::source::snippet_with_macro_callsite;
+use clippy_utils::{match_qpath, meets_msrv, parent_node_is_if_expr};
 use if_chain::if_chain;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
@@ -58,7 +58,7 @@ impl_lint_pass!(IfThenSomeElseNone => [IF_THEN_SOME_ELSE_NONE]);
 
 impl LateLintPass<'_> for IfThenSomeElseNone {
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &'tcx Expr<'_>) {
-        if !utils::meets_msrv(self.msrv.as_ref(), &IF_THEN_SOME_ELSE_NONE_MSRV) {
+        if !meets_msrv(self.msrv.as_ref(), &IF_THEN_SOME_ELSE_NONE_MSRV) {
             return;
         }
 
@@ -67,7 +67,7 @@ impl LateLintPass<'_> for IfThenSomeElseNone {
         }
 
         // We only care about the top-most `if` in the chain
-        if utils::parent_node_is_if_expr(expr, cx) {
+        if parent_node_is_if_expr(expr, cx) {
             return;
         }
 
@@ -77,12 +77,12 @@ impl LateLintPass<'_> for IfThenSomeElseNone {
             if let Some(ref then_expr) = then_block.expr;
             if let ExprKind::Call(ref then_call, [then_arg]) = then_expr.kind;
             if let ExprKind::Path(ref then_call_qpath) = then_call.kind;
-            if utils::match_qpath(then_call_qpath, &utils::paths::OPTION_SOME);
+            if match_qpath(then_call_qpath, &clippy_utils::paths::OPTION_SOME);
             if let ExprKind::Block(ref els_block, _) = els.kind;
             if els_block.stmts.is_empty();
             if let Some(ref els_expr) = els_block.expr;
             if let ExprKind::Path(ref els_call_qpath) = els_expr.kind;
-            if utils::match_qpath(els_call_qpath, &utils::paths::OPTION_NONE);
+            if match_qpath(els_call_qpath, &clippy_utils::paths::OPTION_NONE);
             then {
                 let cond_snip = snippet_with_macro_callsite(cx, cond.span, "[condition]");
                 let cond_snip = if matches!(cond.kind, ExprKind::Unary(_, _) | ExprKind::Binary(_, _, _)) {
diff --git a/clippy_lints/src/implicit_return.rs b/clippy_lints/src/implicit_return.rs
index 70ea9a92279..6863645a92d 100644
--- a/clippy_lints/src/implicit_return.rs
+++ b/clippy_lints/src/implicit_return.rs
@@ -1,5 +1,5 @@
-use crate::utils::match_panic_def_id;
 use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::match_panic_def_id;
 use clippy_utils::source::snippet_opt;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/implicit_saturating_sub.rs b/clippy_lints/src/implicit_saturating_sub.rs
index 3d2798f3fb4..5207c628987 100644
--- a/clippy_lints/src/implicit_saturating_sub.rs
+++ b/clippy_lints/src/implicit_saturating_sub.rs
@@ -1,5 +1,5 @@
-use crate::utils::{in_macro, match_qpath, SpanlessEq};
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::{in_macro, match_qpath, SpanlessEq};
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/indexing_slicing.rs b/clippy_lints/src/indexing_slicing.rs
index 4c0f976f79a..94d39019608 100644
--- a/clippy_lints/src/indexing_slicing.rs
+++ b/clippy_lints/src/indexing_slicing.rs
@@ -1,8 +1,8 @@
 //! lint on indexing and slicing operations
 
 use crate::consts::{constant, Constant};
-use crate::utils::higher;
 use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
+use clippy_utils::higher;
 use rustc_ast::ast::RangeLimits;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/infinite_iter.rs b/clippy_lints/src/infinite_iter.rs
index addd95c6eae..fb35bc1e780 100644
--- a/clippy_lints/src/infinite_iter.rs
+++ b/clippy_lints/src/infinite_iter.rs
@@ -1,11 +1,10 @@
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::ty::{implements_trait, match_type};
+use clippy_utils::{get_trait_def_id, higher, match_qpath, paths};
 use rustc_hir::{BorrowKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
-use crate::utils::{get_trait_def_id, higher, match_qpath, paths};
-
 declare_clippy_lint! {
     /// **What it does:** Checks for iteration that is guaranteed to be infinite.
     ///
diff --git a/clippy_lints/src/inherent_impl.rs b/clippy_lints/src/inherent_impl.rs
index f838ce190dc..5b2e70e3ce9 100644
--- a/clippy_lints/src/inherent_impl.rs
+++ b/clippy_lints/src/inherent_impl.rs
@@ -1,7 +1,7 @@
 //! lint on inherent implementations
 
-use crate::utils::in_macro;
 use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::in_macro;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_hir::{def_id, Crate, Impl, Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/inherent_to_string.rs b/clippy_lints/src/inherent_to_string.rs
index 6b29feeb4ed..b023e13e846 100644
--- a/clippy_lints/src/inherent_to_string.rs
+++ b/clippy_lints/src/inherent_to_string.rs
@@ -1,13 +1,12 @@
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::ty::{implements_trait, is_type_diagnostic_item};
+use clippy_utils::{get_trait_def_id, paths, return_ty, trait_ref_of_method};
 use if_chain::if_chain;
 use rustc_hir::{ImplItem, ImplItemKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::sym;
 
-use crate::utils::{get_trait_def_id, paths, return_ty, trait_ref_of_method};
-
 declare_clippy_lint! {
     /// **What it does:** Checks for the definition of inherent methods with a signature of `to_string(&self) -> String`.
     ///
diff --git a/clippy_lints/src/inline_fn_without_body.rs b/clippy_lints/src/inline_fn_without_body.rs
index 87fe5123cf6..20f00bd51ba 100644
--- a/clippy_lints/src/inline_fn_without_body.rs
+++ b/clippy_lints/src/inline_fn_without_body.rs
@@ -1,7 +1,7 @@
 //! checks for `#[inline]` on trait methods without bodies
 
-use crate::utils::sugg::DiagnosticBuilderExt;
 use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::sugg::DiagnosticBuilderExt;
 use rustc_ast::ast::Attribute;
 use rustc_errors::Applicability;
 use rustc_hir::{TraitFn, TraitItem, TraitItemKind};
diff --git a/clippy_lints/src/len_zero.rs b/clippy_lints/src/len_zero.rs
index a644a4113ae..717f2ea84f4 100644
--- a/clippy_lints/src/len_zero.rs
+++ b/clippy_lints/src/len_zero.rs
@@ -1,6 +1,6 @@
-use crate::utils::{get_item_name, get_parent_as_impl, is_allowed};
 use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::{get_item_name, get_parent_as_impl, is_allowed};
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
 use rustc_data_structures::fx::FxHashSet;
diff --git a/clippy_lints/src/let_if_seq.rs b/clippy_lints/src/let_if_seq.rs
index 4b7e02398fb..2d7d9c9befb 100644
--- a/clippy_lints/src/let_if_seq.rs
+++ b/clippy_lints/src/let_if_seq.rs
@@ -1,6 +1,6 @@
-use crate::utils::{path_to_local_id, visitors::LocalUsedVisitor};
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet;
+use clippy_utils::{path_to_local_id, visitors::LocalUsedVisitor};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
diff --git a/clippy_lints/src/let_underscore.rs b/clippy_lints/src/let_underscore.rs
index eee2503b481..7e3a76ded2c 100644
--- a/clippy_lints/src/let_underscore.rs
+++ b/clippy_lints/src/let_underscore.rs
@@ -1,5 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::ty::{is_must_use_ty, match_type};
+use clippy_utils::{is_must_use_func_call, paths};
 use if_chain::if_chain;
 use rustc_hir::{Local, PatKind};
 use rustc_lint::{LateContext, LateLintPass};
@@ -7,8 +8,6 @@ use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::subst::GenericArgKind;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
-use crate::utils::{is_must_use_func_call, paths};
-
 declare_clippy_lint! {
     /// **What it does:** Checks for `let _ = <expr>`
     /// where expr is #[must_use]
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index f479d756a33..9b2876ddc11 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -42,7 +42,7 @@ extern crate rustc_target;
 extern crate rustc_trait_selection;
 extern crate rustc_typeck;
 
-use crate::utils::parse_msrv;
+use clippy_utils::parse_msrv;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_lint::LintId;
 use rustc_session::Session;
diff --git a/clippy_lints/src/lifetimes.rs b/clippy_lints/src/lifetimes.rs
index 0848aaed815..a2f093e6ef7 100644
--- a/clippy_lints/src/lifetimes.rs
+++ b/clippy_lints/src/lifetimes.rs
@@ -1,5 +1,5 @@
-use crate::utils::{in_macro, trait_ref_of_method};
 use clippy_utils::diagnostics::span_lint;
+use clippy_utils::{in_macro, trait_ref_of_method};
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_hir::intravisit::{
     walk_fn_decl, walk_generic_param, walk_generics, walk_item, walk_param_bound, walk_poly_trait_ref, walk_ty,
diff --git a/clippy_lints/src/literal_representation.rs b/clippy_lints/src/literal_representation.rs
index dd303bc0a01..7fd55151226 100644
--- a/clippy_lints/src/literal_representation.rs
+++ b/clippy_lints/src/literal_representation.rs
@@ -1,12 +1,12 @@
 //! Lints concerned with the grouping of digits with underscores in integral or
 //! floating-point literal expressions.
 
-use crate::utils::{
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet_opt;
+use clippy_utils::{
     in_macro,
     numeric_literal::{NumericLiteral, Radix},
 };
-use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::source::snippet_opt;
 use if_chain::if_chain;
 use rustc_ast::ast::{Expr, ExprKind, Lit, LitKind};
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/loops/empty_loop.rs b/clippy_lints/src/loops/empty_loop.rs
index d52a061fc8f..dda09fecdf9 100644
--- a/clippy_lints/src/loops/empty_loop.rs
+++ b/clippy_lints/src/loops/empty_loop.rs
@@ -1,6 +1,6 @@
 use super::EMPTY_LOOP;
-use crate::utils::{is_in_panic_handler, is_no_std_crate};
 use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::{is_in_panic_handler, is_no_std_crate};
 
 use rustc_hir::{Block, Expr};
 use rustc_lint::LateContext;
diff --git a/clippy_lints/src/loops/explicit_counter_loop.rs b/clippy_lints/src/loops/explicit_counter_loop.rs
index 87ce4e4c20c..f14dbb1d642 100644
--- a/clippy_lints/src/loops/explicit_counter_loop.rs
+++ b/clippy_lints/src/loops/explicit_counter_loop.rs
@@ -1,9 +1,9 @@
 use super::{
     get_span_of_entire_for_loop, make_iterator_snippet, IncrementVisitor, InitializeVisitor, EXPLICIT_COUNTER_LOOP,
 };
-use crate::utils::{get_enclosing_block, is_integer_const};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::{get_enclosing_block, is_integer_const};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_block, walk_expr};
diff --git a/clippy_lints/src/loops/explicit_iter_loop.rs b/clippy_lints/src/loops/explicit_iter_loop.rs
index 259e95e5ef4..92aa2beb66d 100644
--- a/clippy_lints/src/loops/explicit_iter_loop.rs
+++ b/clippy_lints/src/loops/explicit_iter_loop.rs
@@ -1,8 +1,8 @@
 use super::EXPLICIT_ITER_LOOP;
-use crate::utils::{match_trait_method, paths};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::{is_type_diagnostic_item, match_type};
+use clippy_utils::{match_trait_method, paths};
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, Mutability};
 use rustc_lint::LateContext;
diff --git a/clippy_lints/src/loops/for_kv_map.rs b/clippy_lints/src/loops/for_kv_map.rs
index bf037f392e0..8f18f54119b 100644
--- a/clippy_lints/src/loops/for_kv_map.rs
+++ b/clippy_lints/src/loops/for_kv_map.rs
@@ -1,9 +1,9 @@
 use super::FOR_KV_MAP;
-use crate::utils::visitors::LocalUsedVisitor;
-use crate::utils::{paths, sugg};
 use clippy_utils::diagnostics::{multispan_sugg, span_lint_and_then};
 use clippy_utils::source::snippet;
 use clippy_utils::ty::{is_type_diagnostic_item, match_type};
+use clippy_utils::visitors::LocalUsedVisitor;
+use clippy_utils::{paths, sugg};
 use rustc_hir::{BorrowKind, Expr, ExprKind, Mutability, Pat, PatKind};
 use rustc_lint::LateContext;
 use rustc_middle::ty;
diff --git a/clippy_lints/src/loops/iter_next_loop.rs b/clippy_lints/src/loops/iter_next_loop.rs
index 27a03562800..9148fbfd497 100644
--- a/clippy_lints/src/loops/iter_next_loop.rs
+++ b/clippy_lints/src/loops/iter_next_loop.rs
@@ -1,11 +1,10 @@
 use super::ITER_NEXT_LOOP;
 use clippy_utils::diagnostics::span_lint;
+use clippy_utils::is_trait_method;
 use rustc_hir::Expr;
 use rustc_lint::LateContext;
 use rustc_span::sym;
 
-use crate::utils::is_trait_method;
-
 pub(super) fn check(cx: &LateContext<'_>, arg: &Expr<'_>, expr: &Expr<'_>) -> bool {
     if is_trait_method(cx, arg, sym::Iterator) {
         span_lint(
diff --git a/clippy_lints/src/loops/manual_flatten.rs b/clippy_lints/src/loops/manual_flatten.rs
index 43580d6071a..be87f67d300 100644
--- a/clippy_lints/src/loops/manual_flatten.rs
+++ b/clippy_lints/src/loops/manual_flatten.rs
@@ -1,7 +1,7 @@
 use super::utils::make_iterator_snippet;
 use super::MANUAL_FLATTEN;
-use crate::utils::{is_ok_ctor, is_some_ctor, path_to_local_id};
 use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::{is_ok_ctor, is_some_ctor, path_to_local_id};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, MatchSource, Pat, PatKind, QPath, StmtKind};
diff --git a/clippy_lints/src/loops/manual_memcpy.rs b/clippy_lints/src/loops/manual_memcpy.rs
index ff68d136999..af6d56a89af 100644
--- a/clippy_lints/src/loops/manual_memcpy.rs
+++ b/clippy_lints/src/loops/manual_memcpy.rs
@@ -1,9 +1,9 @@
 use super::{get_span_of_entire_for_loop, IncrementVisitor, InitializeVisitor, MANUAL_MEMCPY};
-use crate::utils::sugg::Sugg;
-use crate::utils::{get_enclosing_block, higher, path_to_local, sugg};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet;
+use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::{get_enclosing_block, higher, path_to_local, sugg};
 use if_chain::if_chain;
 use rustc_ast::ast;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/loops/mod.rs b/clippy_lints/src/loops/mod.rs
index 2a372c6307e..20291491998 100644
--- a/clippy_lints/src/loops/mod.rs
+++ b/clippy_lints/src/loops/mod.rs
@@ -18,7 +18,7 @@ mod while_immutable_condition;
 mod while_let_loop;
 mod while_let_on_iterator;
 
-use crate::utils::higher;
+use clippy_utils::higher;
 use rustc_hir::{Expr, ExprKind, LoopSource, Pat};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
diff --git a/clippy_lints/src/loops/mut_range_bound.rs b/clippy_lints/src/loops/mut_range_bound.rs
index 175aee53a9a..f4e4064ba1d 100644
--- a/clippy_lints/src/loops/mut_range_bound.rs
+++ b/clippy_lints/src/loops/mut_range_bound.rs
@@ -1,6 +1,6 @@
 use super::MUT_RANGE_BOUND;
-use crate::utils::{higher, path_to_local};
 use clippy_utils::diagnostics::span_lint;
+use clippy_utils::{higher, path_to_local};
 use if_chain::if_chain;
 use rustc_hir::{BindingAnnotation, Expr, HirId, Node, PatKind};
 use rustc_infer::infer::TyCtxtInferExt;
diff --git a/clippy_lints/src/loops/needless_collect.rs b/clippy_lints/src/loops/needless_collect.rs
index a3b731eefa0..5594fc7b046 100644
--- a/clippy_lints/src/loops/needless_collect.rs
+++ b/clippy_lints/src/loops/needless_collect.rs
@@ -1,9 +1,9 @@
 use super::NEEDLESS_COLLECT;
-use crate::utils::sugg::Sugg;
-use crate::utils::{is_trait_method, path_to_local_id, paths};
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::snippet;
+use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::{is_type_diagnostic_item, match_type};
+use clippy_utils::{is_trait_method, path_to_local_id, paths};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_block, walk_expr, NestedVisitorMap, Visitor};
diff --git a/clippy_lints/src/loops/needless_range_loop.rs b/clippy_lints/src/loops/needless_range_loop.rs
index ca679d7ebe1..3c40d54cb42 100644
--- a/clippy_lints/src/loops/needless_range_loop.rs
+++ b/clippy_lints/src/loops/needless_range_loop.rs
@@ -1,11 +1,11 @@
 use super::NEEDLESS_RANGE_LOOP;
-use crate::utils::visitors::LocalUsedVisitor;
-use crate::utils::{
-    contains_name, higher, is_integer_const, match_trait_method, path_to_local_id, paths, sugg, SpanlessEq,
-};
 use clippy_utils::diagnostics::{multispan_sugg, span_lint_and_then};
 use clippy_utils::source::snippet;
 use clippy_utils::ty::has_iter_method;
+use clippy_utils::visitors::LocalUsedVisitor;
+use clippy_utils::{
+    contains_name, higher, is_integer_const, match_trait_method, path_to_local_id, paths, sugg, SpanlessEq,
+};
 use if_chain::if_chain;
 use rustc_ast::ast;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
diff --git a/clippy_lints/src/loops/single_element_loop.rs b/clippy_lints/src/loops/single_element_loop.rs
index 172eb963ae3..8451c1c6130 100644
--- a/clippy_lints/src/loops/single_element_loop.rs
+++ b/clippy_lints/src/loops/single_element_loop.rs
@@ -1,6 +1,6 @@
 use super::{get_span_of_entire_for_loop, SINGLE_ELEMENT_LOOP};
-use crate::utils::single_segment_path;
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::single_segment_path;
 use clippy_utils::source::{indent_of, snippet};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/loops/utils.rs b/clippy_lints/src/loops/utils.rs
index b85676570b4..bb409c48532 100644
--- a/clippy_lints/src/loops/utils.rs
+++ b/clippy_lints/src/loops/utils.rs
@@ -1,5 +1,5 @@
-use crate::utils::{get_parent_expr, is_integer_const, path_to_local, path_to_local_id, sugg};
 use clippy_utils::ty::{has_iter_method, implements_trait};
+use clippy_utils::{get_parent_expr, is_integer_const, path_to_local, path_to_local_id, sugg};
 use if_chain::if_chain;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/loops/while_immutable_condition.rs b/clippy_lints/src/loops/while_immutable_condition.rs
index a037a06de81..cad9ff8489a 100644
--- a/clippy_lints/src/loops/while_immutable_condition.rs
+++ b/clippy_lints/src/loops/while_immutable_condition.rs
@@ -1,7 +1,7 @@
 use super::WHILE_IMMUTABLE_CONDITION;
 use crate::consts::constant;
-use crate::utils::usage::mutated_variables;
 use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::usage::mutated_variables;
 use if_chain::if_chain;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_hir::def::{DefKind, Res};
diff --git a/clippy_lints/src/loops/while_let_on_iterator.rs b/clippy_lints/src/loops/while_let_on_iterator.rs
index 29ad9e735cc..57fc6250a9a 100644
--- a/clippy_lints/src/loops/while_let_on_iterator.rs
+++ b/clippy_lints/src/loops/while_let_on_iterator.rs
@@ -1,12 +1,12 @@
 use super::utils::{LoopNestVisitor, Nesting};
 use super::WHILE_LET_ON_ITERATOR;
-use crate::utils::usage::mutated_variables;
-use crate::utils::{
-    get_enclosing_block, is_refutable, is_trait_method, last_path_segment, path_to_local, path_to_local_id,
-};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::implements_trait;
+use clippy_utils::usage::mutated_variables;
+use clippy_utils::{
+    get_enclosing_block, is_refutable, is_trait_method, last_path_segment, path_to_local, path_to_local_id,
+};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_block, walk_expr, NestedVisitorMap, Visitor};
diff --git a/clippy_lints/src/macro_use.rs b/clippy_lints/src/macro_use.rs
index 92f95645734..d573c297838 100644
--- a/clippy_lints/src/macro_use.rs
+++ b/clippy_lints/src/macro_use.rs
@@ -1,5 +1,5 @@
-use crate::utils::in_macro;
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::in_macro;
 use clippy_utils::source::snippet;
 use hir::def::{DefKind, Res};
 use if_chain::if_chain;
diff --git a/clippy_lints/src/main_recursion.rs b/clippy_lints/src/main_recursion.rs
index 6c0308cbd92..07d8a440aea 100644
--- a/clippy_lints/src/main_recursion.rs
+++ b/clippy_lints/src/main_recursion.rs
@@ -1,12 +1,11 @@
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::source::snippet;
+use clippy_utils::{is_entrypoint_fn, is_no_std_crate};
 use if_chain::if_chain;
 use rustc_hir::{Crate, Expr, ExprKind, QPath};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 
-use crate::utils::{is_entrypoint_fn, is_no_std_crate};
-
 declare_clippy_lint! {
     /// **What it does:** Checks for recursion using the entrypoint.
     ///
diff --git a/clippy_lints/src/manual_async_fn.rs b/clippy_lints/src/manual_async_fn.rs
index 1db5cf56962..5d88ff3b99f 100644
--- a/clippy_lints/src/manual_async_fn.rs
+++ b/clippy_lints/src/manual_async_fn.rs
@@ -1,6 +1,6 @@
-use crate::utils::match_function_call;
-use crate::utils::paths::FUTURE_FROM_GENERATOR;
 use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::match_function_call;
+use clippy_utils::paths::FUTURE_FROM_GENERATOR;
 use clippy_utils::source::{position_before_rarrow, snippet_block, snippet_opt};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/manual_map.rs b/clippy_lints/src/manual_map.rs
index fd563bec769..cd9594737bf 100644
--- a/clippy_lints/src/manual_map.rs
+++ b/clippy_lints/src/manual_map.rs
@@ -1,11 +1,8 @@
-use crate::{
-    map_unit_fn::OPTION_MAP_UNIT_FN,
-    matches::MATCH_AS_REF,
-    utils::{is_allowed, match_def_path, match_var, paths, peel_hir_expr_refs},
-};
+use crate::{map_unit_fn::OPTION_MAP_UNIT_FN, matches::MATCH_AS_REF};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::{snippet_with_applicability, snippet_with_context};
 use clippy_utils::ty::{can_partially_move_ty, is_type_diagnostic_item, peel_mid_ty_refs_is_mutable};
+use clippy_utils::{is_allowed, match_def_path, match_var, paths, peel_hir_expr_refs};
 use rustc_ast::util::parser::PREC_POSTFIX;
 use rustc_errors::Applicability;
 use rustc_hir::{
diff --git a/clippy_lints/src/manual_non_exhaustive.rs b/clippy_lints/src/manual_non_exhaustive.rs
index 705c1ec1859..a9a89ae5659 100644
--- a/clippy_lints/src/manual_non_exhaustive.rs
+++ b/clippy_lints/src/manual_non_exhaustive.rs
@@ -1,5 +1,5 @@
-use crate::utils::meets_msrv;
 use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::meets_msrv;
 use clippy_utils::source::snippet_opt;
 use if_chain::if_chain;
 use rustc_ast::ast::{Attribute, Item, ItemKind, StructField, Variant, VariantData, VisibilityKind};
diff --git a/clippy_lints/src/manual_ok_or.rs b/clippy_lints/src/manual_ok_or.rs
index a1e5c752f83..9bfae602c40 100644
--- a/clippy_lints/src/manual_ok_or.rs
+++ b/clippy_lints/src/manual_ok_or.rs
@@ -1,7 +1,7 @@
-use crate::utils::{match_qpath, path_to_local_id, paths};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::{indent_of, reindent_multiline, snippet_opt};
 use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::{match_qpath, path_to_local_id, paths};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, PatKind};
diff --git a/clippy_lints/src/manual_strip.rs b/clippy_lints/src/manual_strip.rs
index bc4e255b03d..9da37efddac 100644
--- a/clippy_lints/src/manual_strip.rs
+++ b/clippy_lints/src/manual_strip.rs
@@ -1,8 +1,8 @@
 use crate::consts::{constant, Constant};
-use crate::utils::usage::mutated_variables;
-use crate::utils::{eq_expr_value, higher, match_def_path, meets_msrv, paths};
 use clippy_utils::diagnostics::{multispan_sugg, span_lint_and_then};
 use clippy_utils::source::snippet;
+use clippy_utils::usage::mutated_variables;
+use clippy_utils::{eq_expr_value, higher, match_def_path, meets_msrv, paths};
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
 use rustc_hir::def::Res;
diff --git a/clippy_lints/src/manual_unwrap_or.rs b/clippy_lints/src/manual_unwrap_or.rs
index 615e2d5c2af..4f139f8d39a 100644
--- a/clippy_lints/src/manual_unwrap_or.rs
+++ b/clippy_lints/src/manual_unwrap_or.rs
@@ -1,9 +1,9 @@
 use crate::consts::constant_simple;
-use crate::utils;
-use crate::utils::{in_constant, path_to_local_id, sugg};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::{indent_of, reindent_multiline, snippet_opt};
 use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::usage::contains_return_break_continue_macro;
+use clippy_utils::{in_constant, match_qpath, path_to_local_id, sugg};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Arm, Expr, ExprKind, Pat, PatKind};
@@ -75,19 +75,19 @@ fn lint_manual_unwrap_or<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
             if let Some((idx, or_arm)) = arms.iter().enumerate().find(|(_, arm)|
                 match arm.pat.kind {
                     PatKind::Path(ref some_qpath) =>
-                        utils::match_qpath(some_qpath, &utils::paths::OPTION_NONE),
+                        match_qpath(some_qpath, &clippy_utils::paths::OPTION_NONE),
                     PatKind::TupleStruct(ref err_qpath, &[Pat { kind: PatKind::Wild, .. }], _) =>
-                        utils::match_qpath(err_qpath, &utils::paths::RESULT_ERR),
+                        match_qpath(err_qpath, &clippy_utils::paths::RESULT_ERR),
                     _ => false,
                 }
             );
             let unwrap_arm = &arms[1 - idx];
             if let PatKind::TupleStruct(ref unwrap_qpath, &[unwrap_pat], _) = unwrap_arm.pat.kind;
-            if utils::match_qpath(unwrap_qpath, &utils::paths::OPTION_SOME)
-                || utils::match_qpath(unwrap_qpath, &utils::paths::RESULT_OK);
+            if match_qpath(unwrap_qpath, &clippy_utils::paths::OPTION_SOME)
+                || match_qpath(unwrap_qpath, &clippy_utils::paths::RESULT_OK);
             if let PatKind::Binding(_, binding_hir_id, ..) = unwrap_pat.kind;
             if path_to_local_id(unwrap_arm.body, binding_hir_id);
-            if !utils::usage::contains_return_break_continue_macro(or_arm.body);
+            if !contains_return_break_continue_macro(or_arm.body);
             then {
                 Some(or_arm)
             } else {
diff --git a/clippy_lints/src/map_clone.rs b/clippy_lints/src/map_clone.rs
index fd39052871b..cfcc705eabc 100644
--- a/clippy_lints/src/map_clone.rs
+++ b/clippy_lints/src/map_clone.rs
@@ -1,6 +1,6 @@
-use crate::utils::is_trait_method;
-use crate::utils::remove_blocks;
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::is_trait_method;
+use clippy_utils::remove_blocks;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::{is_copy, is_type_diagnostic_item};
 use if_chain::if_chain;
diff --git a/clippy_lints/src/map_identity.rs b/clippy_lints/src/map_identity.rs
index 84ec23c4e2f..75191e1f9ee 100644
--- a/clippy_lints/src/map_identity.rs
+++ b/clippy_lints/src/map_identity.rs
@@ -1,6 +1,6 @@
-use crate::utils::{is_adjusted, is_trait_method, match_path, match_var, paths, remove_blocks};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::{is_adjusted, is_trait_method, match_path, match_var, paths, remove_blocks};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Body, Expr, ExprKind, Pat, PatKind, QPath, StmtKind};
diff --git a/clippy_lints/src/map_unit_fn.rs b/clippy_lints/src/map_unit_fn.rs
index 3bd4a965765..d4764b5ccff 100644
--- a/clippy_lints/src/map_unit_fn.rs
+++ b/clippy_lints/src/map_unit_fn.rs
@@ -1,7 +1,7 @@
-use crate::utils::{iter_input_pats, method_chain_args};
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::{iter_input_pats, method_chain_args};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index 1aa09b82822..e94c7094cac 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -1,16 +1,16 @@
 use crate::consts::{constant, miri_to_const, Constant};
-use crate::utils::sugg::Sugg;
-use crate::utils::visitors::LocalUsedVisitor;
-use crate::utils::{
-    get_parent_expr, in_macro, is_allowed, is_expn_of, is_refutable, is_wild, match_qpath, meets_msrv, path_to_local,
-    path_to_local_id, peel_hir_pat_refs, peel_n_hir_expr_refs, remove_blocks, strip_pat_refs,
-};
-use crate::utils::{paths, search_same, SpanlessEq, SpanlessHash};
 use clippy_utils::diagnostics::{
     multispan_sugg, span_lint_and_help, span_lint_and_note, span_lint_and_sugg, span_lint_and_then,
 };
 use clippy_utils::source::{expr_block, indent_of, snippet, snippet_block, snippet_opt, snippet_with_applicability};
+use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::{implements_trait, is_type_diagnostic_item, match_type, peel_mid_ty_refs};
+use clippy_utils::visitors::LocalUsedVisitor;
+use clippy_utils::{
+    get_parent_expr, in_macro, is_allowed, is_expn_of, is_refutable, is_wild, match_qpath, meets_msrv, path_to_local,
+    path_to_local_id, peel_hir_pat_refs, peel_n_hir_expr_refs, remove_blocks, strip_pat_refs,
+};
+use clippy_utils::{paths, search_same, SpanlessEq, SpanlessHash};
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
@@ -1616,9 +1616,9 @@ where
 
 mod redundant_pattern_match {
     use super::REDUNDANT_PATTERN_MATCHING;
-    use crate::utils::{is_trait_method, match_qpath, paths};
     use clippy_utils::diagnostics::span_lint_and_then;
     use clippy_utils::source::snippet;
+    use clippy_utils::{is_trait_method, match_qpath, paths};
     use if_chain::if_chain;
     use rustc_ast::ast::LitKind;
     use rustc_errors::Applicability;
diff --git a/clippy_lints/src/mem_discriminant.rs b/clippy_lints/src/mem_discriminant.rs
index 85353d4cdde..7895ba9f1e0 100644
--- a/clippy_lints/src/mem_discriminant.rs
+++ b/clippy_lints/src/mem_discriminant.rs
@@ -1,7 +1,7 @@
-use crate::utils::{match_def_path, paths};
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::walk_ptrs_ty_depth;
+use clippy_utils::{match_def_path, paths};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{BorrowKind, Expr, ExprKind};
diff --git a/clippy_lints/src/mem_forget.rs b/clippy_lints/src/mem_forget.rs
index 1a8cb82514b..c13802e3953 100644
--- a/clippy_lints/src/mem_forget.rs
+++ b/clippy_lints/src/mem_forget.rs
@@ -1,5 +1,5 @@
-use crate::utils::{match_def_path, paths};
 use clippy_utils::diagnostics::span_lint;
+use clippy_utils::{match_def_path, paths};
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
diff --git a/clippy_lints/src/mem_replace.rs b/clippy_lints/src/mem_replace.rs
index 87cb66a6770..426c108d89f 100644
--- a/clippy_lints/src/mem_replace.rs
+++ b/clippy_lints/src/mem_replace.rs
@@ -1,7 +1,7 @@
-use crate::utils::{in_macro, match_def_path, match_qpath, meets_msrv, paths};
 use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::is_diagnostic_assoc_item;
 use clippy_utils::source::{snippet, snippet_with_applicability};
+use clippy_utils::{in_macro, match_def_path, match_qpath, meets_msrv, paths};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::def_id::DefId;
diff --git a/clippy_lints/src/methods/bind_instead_of_map.rs b/clippy_lints/src/methods/bind_instead_of_map.rs
index 7d6104ebb7f..0ba8a98a018 100644
--- a/clippy_lints/src/methods/bind_instead_of_map.rs
+++ b/clippy_lints/src/methods/bind_instead_of_map.rs
@@ -1,8 +1,8 @@
 use super::{contains_return, BIND_INSTEAD_OF_MAP};
-use crate::utils::{in_macro, match_qpath, method_calls, paths, remove_blocks, visitors::find_all_ret_expressions};
 use clippy_utils::diagnostics::{multispan_sugg_with_applicability, span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::{snippet, snippet_with_macro_callsite};
 use clippy_utils::ty::match_type;
+use clippy_utils::{in_macro, match_qpath, method_calls, paths, remove_blocks, visitors::find_all_ret_expressions};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
diff --git a/clippy_lints/src/methods/clone_on_copy.rs b/clippy_lints/src/methods/clone_on_copy.rs
index d1c7789a241..949152cf789 100644
--- a/clippy_lints/src/methods/clone_on_copy.rs
+++ b/clippy_lints/src/methods/clone_on_copy.rs
@@ -1,5 +1,5 @@
-use crate::utils::sugg;
 use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::sugg;
 use clippy_utils::ty::is_copy;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
diff --git a/clippy_lints/src/methods/clone_on_ref_ptr.rs b/clippy_lints/src/methods/clone_on_ref_ptr.rs
index b49ae42b12f..03c949d5c31 100644
--- a/clippy_lints/src/methods/clone_on_ref_ptr.rs
+++ b/clippy_lints/src/methods/clone_on_ref_ptr.rs
@@ -1,5 +1,5 @@
-use crate::utils::paths;
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::paths;
 use clippy_utils::source::snippet_with_macro_callsite;
 use clippy_utils::ty::{is_type_diagnostic_item, match_type};
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/methods/expect_fun_call.rs b/clippy_lints/src/methods/expect_fun_call.rs
index 1c673c11d65..e7bffa66b3f 100644
--- a/clippy_lints/src/methods/expect_fun_call.rs
+++ b/clippy_lints/src/methods/expect_fun_call.rs
@@ -1,5 +1,5 @@
-use crate::utils::is_expn_of;
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::is_expn_of;
 use clippy_utils::source::{snippet, snippet_with_applicability};
 use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
diff --git a/clippy_lints/src/methods/filetype_is_file.rs b/clippy_lints/src/methods/filetype_is_file.rs
index 005c94a6018..39d2f15dbc8 100644
--- a/clippy_lints/src/methods/filetype_is_file.rs
+++ b/clippy_lints/src/methods/filetype_is_file.rs
@@ -1,6 +1,6 @@
-use crate::utils::{get_parent_expr, paths};
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::ty::match_type;
+use clippy_utils::{get_parent_expr, paths};
 use if_chain::if_chain;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
diff --git a/clippy_lints/src/methods/filter_flat_map.rs b/clippy_lints/src/methods/filter_flat_map.rs
index 4820bb137c1..2f3a3c55ab5 100644
--- a/clippy_lints/src/methods/filter_flat_map.rs
+++ b/clippy_lints/src/methods/filter_flat_map.rs
@@ -1,5 +1,5 @@
-use crate::utils::is_trait_method;
 use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::is_trait_method;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
 use rustc_span::sym;
diff --git a/clippy_lints/src/methods/filter_map.rs b/clippy_lints/src/methods/filter_map.rs
index af91370df20..2cb476acb2b 100644
--- a/clippy_lints/src/methods/filter_map.rs
+++ b/clippy_lints/src/methods/filter_map.rs
@@ -1,6 +1,6 @@
-use crate::utils::{is_trait_method, path_to_local_id, SpanlessEq};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet;
+use clippy_utils::{is_trait_method, path_to_local_id, SpanlessEq};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
diff --git a/clippy_lints/src/methods/filter_map_flat_map.rs b/clippy_lints/src/methods/filter_map_flat_map.rs
index 5294ef97528..b1a4dc98eb8 100644
--- a/clippy_lints/src/methods/filter_map_flat_map.rs
+++ b/clippy_lints/src/methods/filter_map_flat_map.rs
@@ -1,5 +1,5 @@
-use crate::utils::is_trait_method;
 use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::is_trait_method;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
 use rustc_span::sym;
diff --git a/clippy_lints/src/methods/filter_map_identity.rs b/clippy_lints/src/methods/filter_map_identity.rs
index 4461baf4f7c..80598d88508 100644
--- a/clippy_lints/src/methods/filter_map_identity.rs
+++ b/clippy_lints/src/methods/filter_map_identity.rs
@@ -1,5 +1,5 @@
-use crate::utils::{is_trait_method, match_qpath, path_to_local_id, paths};
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::{is_trait_method, match_qpath, path_to_local_id, paths};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
diff --git a/clippy_lints/src/methods/filter_map_map.rs b/clippy_lints/src/methods/filter_map_map.rs
index 8f17350054b..0b0a8b1dd3b 100644
--- a/clippy_lints/src/methods/filter_map_map.rs
+++ b/clippy_lints/src/methods/filter_map_map.rs
@@ -1,5 +1,5 @@
-use crate::utils::is_trait_method;
 use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::is_trait_method;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
 use rustc_span::sym;
diff --git a/clippy_lints/src/methods/filter_map_next.rs b/clippy_lints/src/methods/filter_map_next.rs
index 8fbadd1d457..ba57abd16c9 100644
--- a/clippy_lints/src/methods/filter_map_next.rs
+++ b/clippy_lints/src/methods/filter_map_next.rs
@@ -1,6 +1,6 @@
-use crate::utils::{is_trait_method, meets_msrv};
 use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg};
 use clippy_utils::source::snippet;
+use clippy_utils::{is_trait_method, meets_msrv};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
diff --git a/clippy_lints/src/methods/filter_next.rs b/clippy_lints/src/methods/filter_next.rs
index af16ea19007..6cd24334414 100644
--- a/clippy_lints/src/methods/filter_next.rs
+++ b/clippy_lints/src/methods/filter_next.rs
@@ -1,5 +1,5 @@
-use crate::utils::is_trait_method;
 use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg};
+use clippy_utils::is_trait_method;
 use clippy_utils::source::snippet;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
diff --git a/clippy_lints/src/methods/flat_map_identity.rs b/clippy_lints/src/methods/flat_map_identity.rs
index 669ac1f743f..034ea6c6562 100644
--- a/clippy_lints/src/methods/flat_map_identity.rs
+++ b/clippy_lints/src/methods/flat_map_identity.rs
@@ -1,5 +1,5 @@
-use crate::utils::{is_trait_method, match_qpath, paths};
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::{is_trait_method, match_qpath, paths};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
diff --git a/clippy_lints/src/methods/from_iter_instead_of_collect.rs b/clippy_lints/src/methods/from_iter_instead_of_collect.rs
index 5d0a07992c8..2095a60e44b 100644
--- a/clippy_lints/src/methods/from_iter_instead_of_collect.rs
+++ b/clippy_lints/src/methods/from_iter_instead_of_collect.rs
@@ -1,6 +1,6 @@
-use crate::utils::{get_trait_def_id, paths, sugg};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::ty::implements_trait;
+use clippy_utils::{get_trait_def_id, paths, sugg};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
diff --git a/clippy_lints/src/methods/get_unwrap.rs b/clippy_lints/src/methods/get_unwrap.rs
index ac855419d00..b122a0a0b89 100644
--- a/clippy_lints/src/methods/get_unwrap.rs
+++ b/clippy_lints/src/methods/get_unwrap.rs
@@ -1,8 +1,8 @@
 use crate::methods::derefs_to_slice;
-use crate::utils::{get_parent_expr, paths};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::{is_type_diagnostic_item, match_type};
+use clippy_utils::{get_parent_expr, paths};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
diff --git a/clippy_lints/src/methods/inefficient_to_string.rs b/clippy_lints/src/methods/inefficient_to_string.rs
index 56de7a8bc5e..d10a540c24e 100644
--- a/clippy_lints/src/methods/inefficient_to_string.rs
+++ b/clippy_lints/src/methods/inefficient_to_string.rs
@@ -1,8 +1,8 @@
 use super::INEFFICIENT_TO_STRING;
-use crate::utils::{match_def_path, paths};
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::{is_type_diagnostic_item, walk_ptrs_ty_depth};
+use clippy_utils::{match_def_path, paths};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
diff --git a/clippy_lints/src/methods/inspect_for_each.rs b/clippy_lints/src/methods/inspect_for_each.rs
index c9bbfbc37eb..7fd3ef1a622 100644
--- a/clippy_lints/src/methods/inspect_for_each.rs
+++ b/clippy_lints/src/methods/inspect_for_each.rs
@@ -1,10 +1,9 @@
 use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::is_trait_method;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
 use rustc_span::{source_map::Span, sym};
 
-use crate::utils::is_trait_method;
-
 use super::INSPECT_FOR_EACH;
 
 /// lint use of `inspect().for_each()` for `Iterators`
diff --git a/clippy_lints/src/methods/into_iter_on_ref.rs b/clippy_lints/src/methods/into_iter_on_ref.rs
index a862b55e139..cfe749cf361 100644
--- a/clippy_lints/src/methods/into_iter_on_ref.rs
+++ b/clippy_lints/src/methods/into_iter_on_ref.rs
@@ -1,6 +1,6 @@
-use crate::utils::{match_trait_method, paths};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::ty::has_iter_method;
+use clippy_utils::{match_trait_method, paths};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
diff --git a/clippy_lints/src/methods/iter_count.rs b/clippy_lints/src/methods/iter_count.rs
index bfd62ff1f0d..fd3d53816a1 100644
--- a/clippy_lints/src/methods/iter_count.rs
+++ b/clippy_lints/src/methods/iter_count.rs
@@ -1,6 +1,6 @@
 use crate::methods::derefs_to_slice;
-use crate::utils::paths;
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::paths;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::{is_type_diagnostic_item, match_type};
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/methods/iter_next_slice.rs b/clippy_lints/src/methods/iter_next_slice.rs
index ce599682bbe..feebf8b8209 100644
--- a/clippy_lints/src/methods/iter_next_slice.rs
+++ b/clippy_lints/src/methods/iter_next_slice.rs
@@ -1,8 +1,8 @@
 use crate::methods::derefs_to_slice;
-use crate::utils::{get_parent_expr, higher};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::{get_parent_expr, higher};
 use if_chain::if_chain;
 use rustc_ast::ast;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/methods/iter_nth_zero.rs b/clippy_lints/src/methods/iter_nth_zero.rs
index f2b2dd8c097..a12f672739c 100644
--- a/clippy_lints/src/methods/iter_nth_zero.rs
+++ b/clippy_lints/src/methods/iter_nth_zero.rs
@@ -1,6 +1,6 @@
 use crate::consts::{constant, Constant};
-use crate::utils::is_trait_method;
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::is_trait_method;
 use clippy_utils::source::snippet_with_applicability;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/methods/iter_skip_next.rs b/clippy_lints/src/methods/iter_skip_next.rs
index 6100613bcac..ea01860b456 100644
--- a/clippy_lints/src/methods/iter_skip_next.rs
+++ b/clippy_lints/src/methods/iter_skip_next.rs
@@ -1,5 +1,5 @@
-use crate::utils::is_trait_method;
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::is_trait_method;
 use clippy_utils::source::snippet;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
diff --git a/clippy_lints/src/methods/iterator_step_by_zero.rs b/clippy_lints/src/methods/iterator_step_by_zero.rs
index 51c1ab0484e..3baa580314f 100644
--- a/clippy_lints/src/methods/iterator_step_by_zero.rs
+++ b/clippy_lints/src/methods/iterator_step_by_zero.rs
@@ -1,6 +1,6 @@
 use crate::consts::{constant, Constant};
-use crate::utils::is_trait_method;
 use clippy_utils::diagnostics::span_lint;
+use clippy_utils::is_trait_method;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
 use rustc_span::sym;
diff --git a/clippy_lints/src/methods/manual_saturating_arithmetic.rs b/clippy_lints/src/methods/manual_saturating_arithmetic.rs
index 0c8a002e359..f16699322d1 100644
--- a/clippy_lints/src/methods/manual_saturating_arithmetic.rs
+++ b/clippy_lints/src/methods/manual_saturating_arithmetic.rs
@@ -1,5 +1,5 @@
-use crate::utils::match_qpath;
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::match_qpath;
 use clippy_utils::source::snippet_with_applicability;
 use if_chain::if_chain;
 use rustc_ast::ast;
diff --git a/clippy_lints/src/methods/map_collect_result_unit.rs b/clippy_lints/src/methods/map_collect_result_unit.rs
index b59998fc8b4..e4402b2da21 100644
--- a/clippy_lints/src/methods/map_collect_result_unit.rs
+++ b/clippy_lints/src/methods/map_collect_result_unit.rs
@@ -1,5 +1,5 @@
-use crate::utils::is_trait_method;
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::is_trait_method;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
diff --git a/clippy_lints/src/methods/map_flatten.rs b/clippy_lints/src/methods/map_flatten.rs
index 6f5e723fbfb..4bc52b036a8 100644
--- a/clippy_lints/src/methods/map_flatten.rs
+++ b/clippy_lints/src/methods/map_flatten.rs
@@ -1,5 +1,5 @@
-use crate::utils::is_trait_method;
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::is_trait_method;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/methods/map_unwrap_or.rs b/clippy_lints/src/methods/map_unwrap_or.rs
index 8ef02b4a641..deb4b4492b5 100644
--- a/clippy_lints/src/methods/map_unwrap_or.rs
+++ b/clippy_lints/src/methods/map_unwrap_or.rs
@@ -1,8 +1,8 @@
-use crate::utils::meets_msrv;
-use crate::utils::usage::mutated_variables;
 use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg};
+use clippy_utils::meets_msrv;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::usage::mutated_variables;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index af8fe7abd96..cbfb350ebb1 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -55,6 +55,10 @@ use bind_instead_of_map::BindInsteadOfMap;
 use clippy_utils::diagnostics::{span_lint, span_lint_and_help, span_lint_and_sugg};
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::{contains_ty, implements_trait, is_copy, is_type_diagnostic_item};
+use clippy_utils::{
+    contains_return, get_trait_def_id, in_macro, iter_input_pats, match_def_path, match_qpath, method_calls,
+    method_chain_args, paths, return_ty, single_segment_path, SpanlessEq,
+};
 use if_chain::if_chain;
 use rustc_ast::ast;
 use rustc_errors::Applicability;
@@ -68,11 +72,6 @@ use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::symbol::{sym, SymbolStr};
 use rustc_typeck::hir_ty_to_ty;
 
-use crate::utils::{
-    contains_return, get_trait_def_id, in_macro, iter_input_pats, match_def_path, match_qpath, method_calls,
-    method_chain_args, paths, return_ty, single_segment_path, SpanlessEq,
-};
-
 declare_clippy_lint! {
     /// **What it does:** Checks for `.unwrap()` calls on `Option`s and on `Result`s.
     ///
diff --git a/clippy_lints/src/methods/option_as_ref_deref.rs b/clippy_lints/src/methods/option_as_ref_deref.rs
index f921d7b16c0..d11ede080dc 100644
--- a/clippy_lints/src/methods/option_as_ref_deref.rs
+++ b/clippy_lints/src/methods/option_as_ref_deref.rs
@@ -1,7 +1,7 @@
-use crate::utils::{match_def_path, meets_msrv, path_to_local_id, paths, remove_blocks};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::{match_def_path, meets_msrv, path_to_local_id, paths, remove_blocks};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
diff --git a/clippy_lints/src/methods/option_map_or_none.rs b/clippy_lints/src/methods/option_map_or_none.rs
index e8b057c2d74..d93db2c22e4 100644
--- a/clippy_lints/src/methods/option_map_or_none.rs
+++ b/clippy_lints/src/methods/option_map_or_none.rs
@@ -1,7 +1,7 @@
-use crate::utils::{match_qpath, paths};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::{match_qpath, paths};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
diff --git a/clippy_lints/src/methods/option_map_unwrap_or.rs b/clippy_lints/src/methods/option_map_unwrap_or.rs
index c6459648cd5..e252abc177a 100644
--- a/clippy_lints/src/methods/option_map_unwrap_or.rs
+++ b/clippy_lints/src/methods/option_map_unwrap_or.rs
@@ -1,5 +1,5 @@
-use crate::utils::differing_macro_contexts;
 use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::differing_macro_contexts;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::is_copy;
 use clippy_utils::ty::is_type_diagnostic_item;
diff --git a/clippy_lints/src/methods/or_fun_call.rs b/clippy_lints/src/methods/or_fun_call.rs
index 1b43802a08e..4880d13f39a 100644
--- a/clippy_lints/src/methods/or_fun_call.rs
+++ b/clippy_lints/src/methods/or_fun_call.rs
@@ -1,8 +1,8 @@
-use crate::utils::eager_or_lazy::is_lazyness_candidate;
-use crate::utils::{contains_return, get_trait_def_id, last_path_segment, paths};
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::eager_or_lazy::is_lazyness_candidate;
 use clippy_utils::source::{snippet, snippet_with_applicability, snippet_with_macro_callsite};
 use clippy_utils::ty::{implements_trait, is_type_diagnostic_item, match_type};
+use clippy_utils::{contains_return, get_trait_def_id, last_path_segment, paths};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
diff --git a/clippy_lints/src/methods/search_is_some.rs b/clippy_lints/src/methods/search_is_some.rs
index 18e1064b018..13546dc1779 100644
--- a/clippy_lints/src/methods/search_is_some.rs
+++ b/clippy_lints/src/methods/search_is_some.rs
@@ -1,7 +1,7 @@
-use crate::utils::{is_trait_method, strip_pat_refs};
 use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg};
 use clippy_utils::source::{snippet, snippet_with_applicability};
 use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::{is_trait_method, strip_pat_refs};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
diff --git a/clippy_lints/src/methods/skip_while_next.rs b/clippy_lints/src/methods/skip_while_next.rs
index 8995226191b..3db83785b59 100644
--- a/clippy_lints/src/methods/skip_while_next.rs
+++ b/clippy_lints/src/methods/skip_while_next.rs
@@ -1,5 +1,5 @@
-use crate::utils::is_trait_method;
 use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::is_trait_method;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
 use rustc_span::sym;
diff --git a/clippy_lints/src/methods/string_extend_chars.rs b/clippy_lints/src/methods/string_extend_chars.rs
index d9b97168490..52b26a36fe3 100644
--- a/clippy_lints/src/methods/string_extend_chars.rs
+++ b/clippy_lints/src/methods/string_extend_chars.rs
@@ -1,5 +1,5 @@
-use crate::utils::method_chain_args;
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::method_chain_args;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/methods/suspicious_map.rs b/clippy_lints/src/methods/suspicious_map.rs
index fd4651dd182..7015bd54c35 100644
--- a/clippy_lints/src/methods/suspicious_map.rs
+++ b/clippy_lints/src/methods/suspicious_map.rs
@@ -1,6 +1,6 @@
-use crate::utils::usage::mutated_variables;
-use crate::utils::{expr_or_init, is_trait_method};
 use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::usage::mutated_variables;
+use clippy_utils::{expr_or_init, is_trait_method};
 use if_chain::if_chain;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
diff --git a/clippy_lints/src/methods/uninit_assumed_init.rs b/clippy_lints/src/methods/uninit_assumed_init.rs
index 071856c3ba6..f2f6ef4be6c 100644
--- a/clippy_lints/src/methods/uninit_assumed_init.rs
+++ b/clippy_lints/src/methods/uninit_assumed_init.rs
@@ -1,5 +1,5 @@
-use crate::utils::{match_def_path, match_qpath, paths};
 use clippy_utils::diagnostics::span_lint;
+use clippy_utils::{match_def_path, match_qpath, paths};
 use if_chain::if_chain;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
diff --git a/clippy_lints/src/methods/unnecessary_filter_map.rs b/clippy_lints/src/methods/unnecessary_filter_map.rs
index 670134c68f2..48d905ab833 100644
--- a/clippy_lints/src/methods/unnecessary_filter_map.rs
+++ b/clippy_lints/src/methods/unnecessary_filter_map.rs
@@ -1,14 +1,13 @@
-use crate::utils::usage::mutated_variables;
-use crate::utils::{is_trait_method, match_qpath, path_to_local_id, paths};
 use clippy_utils::diagnostics::span_lint;
+use clippy_utils::usage::mutated_variables;
+use clippy_utils::{is_trait_method, match_qpath, path_to_local_id, paths};
+use if_chain::if_chain;
 use rustc_hir as hir;
 use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
 use rustc_lint::LateContext;
 use rustc_middle::hir::map::Map;
 use rustc_span::sym;
 
-use if_chain::if_chain;
-
 use super::UNNECESSARY_FILTER_MAP;
 
 pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::Expr<'_>]) {
diff --git a/clippy_lints/src/methods/unnecessary_fold.rs b/clippy_lints/src/methods/unnecessary_fold.rs
index 3ccde57de3f..1268fd4bda9 100644
--- a/clippy_lints/src/methods/unnecessary_fold.rs
+++ b/clippy_lints/src/methods/unnecessary_fold.rs
@@ -1,6 +1,6 @@
-use crate::utils::{is_trait_method, path_to_local_id, remove_blocks, strip_pat_refs};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::{is_trait_method, path_to_local_id, remove_blocks, strip_pat_refs};
 use if_chain::if_chain;
 use rustc_ast::ast;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/methods/unnecessary_lazy_eval.rs b/clippy_lints/src/methods/unnecessary_lazy_eval.rs
index 3874673bf9f..a86185bf0a6 100644
--- a/clippy_lints/src/methods/unnecessary_lazy_eval.rs
+++ b/clippy_lints/src/methods/unnecessary_lazy_eval.rs
@@ -1,7 +1,7 @@
-use crate::utils::{eager_or_lazy, usage};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::{eager_or_lazy, usage};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
diff --git a/clippy_lints/src/methods/useless_asref.rs b/clippy_lints/src/methods/useless_asref.rs
index 13c95e33fef..b5505af0f7e 100644
--- a/clippy_lints/src/methods/useless_asref.rs
+++ b/clippy_lints/src/methods/useless_asref.rs
@@ -1,7 +1,7 @@
-use crate::utils::{get_parent_expr, match_trait_method, paths};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::walk_ptrs_ty_depth;
+use clippy_utils::{get_parent_expr, match_trait_method, paths};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
diff --git a/clippy_lints/src/minmax.rs b/clippy_lints/src/minmax.rs
index 6a4e70e50af..776f4c7b741 100644
--- a/clippy_lints/src/minmax.rs
+++ b/clippy_lints/src/minmax.rs
@@ -1,6 +1,6 @@
 use crate::consts::{constant_simple, Constant};
-use crate::utils::{match_def_path, match_trait_method, paths};
 use clippy_utils::diagnostics::span_lint;
+use clippy_utils::{match_def_path, match_trait_method, paths};
 use if_chain::if_chain;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/misc.rs b/clippy_lints/src/misc.rs
index 03d07287005..026ea50936a 100644
--- a/clippy_lints/src/misc.rs
+++ b/clippy_lints/src/misc.rs
@@ -18,8 +18,8 @@ use rustc_span::source_map::{ExpnKind, Span};
 use rustc_span::symbol::sym;
 
 use crate::consts::{constant, Constant};
-use crate::utils::sugg::Sugg;
-use crate::utils::{
+use clippy_utils::sugg::Sugg;
+use clippy_utils::{
     get_item_name, get_parent_expr, higher, in_constant, is_diagnostic_assoc_item, is_integer_const, iter_input_pats,
     last_path_segment, match_qpath, unsext, SpanlessEq,
 };
diff --git a/clippy_lints/src/missing_const_for_fn.rs b/clippy_lints/src/missing_const_for_fn.rs
index aba4accccb1..23554669d97 100644
--- a/clippy_lints/src/missing_const_for_fn.rs
+++ b/clippy_lints/src/missing_const_for_fn.rs
@@ -1,7 +1,7 @@
-use crate::utils::qualify_min_const_fn::is_min_const_fn;
-use crate::utils::{fn_has_unsatisfiable_preds, is_entrypoint_fn, meets_msrv, trait_ref_of_method};
 use clippy_utils::diagnostics::span_lint;
+use clippy_utils::qualify_min_const_fn::is_min_const_fn;
 use clippy_utils::ty::has_drop;
+use clippy_utils::{fn_has_unsatisfiable_preds, is_entrypoint_fn, meets_msrv, trait_ref_of_method};
 use rustc_hir as hir;
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::{Body, Constness, FnDecl, GenericParamKind, HirId};
diff --git a/clippy_lints/src/modulo_arithmetic.rs b/clippy_lints/src/modulo_arithmetic.rs
index 1b00cf2c75d..6a52de4f713 100644
--- a/clippy_lints/src/modulo_arithmetic.rs
+++ b/clippy_lints/src/modulo_arithmetic.rs
@@ -1,6 +1,6 @@
 use crate::consts::{constant, Constant};
-use crate::utils::sext;
 use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::sext;
 use if_chain::if_chain;
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/multiple_crate_versions.rs b/clippy_lints/src/multiple_crate_versions.rs
index 6eaeaebe781..584daa5e119 100644
--- a/clippy_lints/src/multiple_crate_versions.rs
+++ b/clippy_lints/src/multiple_crate_versions.rs
@@ -1,7 +1,7 @@
 //! lint on multiple versions of a crate being used
 
-use crate::utils::run_lints;
 use clippy_utils::diagnostics::span_lint;
+use clippy_utils::run_lints;
 use rustc_hir::def_id::LOCAL_CRATE;
 use rustc_hir::{Crate, CRATE_HIR_ID};
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/mut_key.rs b/clippy_lints/src/mut_key.rs
index 39aec79734c..41bd07bcf1e 100644
--- a/clippy_lints/src/mut_key.rs
+++ b/clippy_lints/src/mut_key.rs
@@ -1,5 +1,5 @@
-use crate::utils::{match_def_path, paths, trait_ref_of_method};
 use clippy_utils::diagnostics::span_lint;
+use clippy_utils::{match_def_path, paths, trait_ref_of_method};
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::TypeFoldable;
diff --git a/clippy_lints/src/mut_mut.rs b/clippy_lints/src/mut_mut.rs
index c11ccc94890..ef33e41a5fa 100644
--- a/clippy_lints/src/mut_mut.rs
+++ b/clippy_lints/src/mut_mut.rs
@@ -1,5 +1,5 @@
-use crate::utils::higher;
 use clippy_utils::diagnostics::span_lint;
+use clippy_utils::higher;
 use rustc_hir as hir;
 use rustc_hir::intravisit;
 use rustc_lint::{LateContext, LateLintPass, LintContext};
diff --git a/clippy_lints/src/mutable_debug_assertion.rs b/clippy_lints/src/mutable_debug_assertion.rs
index fb8895e08d0..533c5a22db0 100644
--- a/clippy_lints/src/mutable_debug_assertion.rs
+++ b/clippy_lints/src/mutable_debug_assertion.rs
@@ -1,5 +1,5 @@
-use crate::utils::{higher, is_direct_expn_of};
 use clippy_utils::diagnostics::span_lint;
+use clippy_utils::{higher, is_direct_expn_of};
 use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
 use rustc_hir::{BorrowKind, Expr, ExprKind, MatchSource, Mutability};
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/needless_arbitrary_self_type.rs b/clippy_lints/src/needless_arbitrary_self_type.rs
index c62ff7323f3..3e2b2782ed5 100644
--- a/clippy_lints/src/needless_arbitrary_self_type.rs
+++ b/clippy_lints/src/needless_arbitrary_self_type.rs
@@ -1,5 +1,5 @@
-use crate::utils::in_macro;
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::in_macro;
 use if_chain::if_chain;
 use rustc_ast::ast::{BindingMode, Lifetime, Mutability, Param, PatKind, Path, TyKind};
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/needless_bool.rs b/clippy_lints/src/needless_bool.rs
index 4c67304d23e..db7b3423ad9 100644
--- a/clippy_lints/src/needless_bool.rs
+++ b/clippy_lints/src/needless_bool.rs
@@ -2,10 +2,10 @@
 //!
 //! This lint is **warn** by default
 
-use crate::utils::sugg::Sugg;
-use crate::utils::{is_expn_of, parent_node_is_if_expr};
 use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg};
 use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::sugg::Sugg;
+use clippy_utils::{is_expn_of, parent_node_is_if_expr};
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Block, Expr, ExprKind, StmtKind, UnOp};
diff --git a/clippy_lints/src/needless_borrow.rs b/clippy_lints/src/needless_borrow.rs
index 72436b51dcb..79d84da2dfc 100644
--- a/clippy_lints/src/needless_borrow.rs
+++ b/clippy_lints/src/needless_borrow.rs
@@ -2,8 +2,8 @@
 //!
 //! This lint is **warn** by default
 
-use crate::utils::is_automatically_derived;
 use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::is_automatically_derived;
 use clippy_utils::source::snippet_opt;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/needless_pass_by_value.rs b/clippy_lints/src/needless_pass_by_value.rs
index fc8ee6cb8ef..075bbf9a426 100644
--- a/clippy_lints/src/needless_pass_by_value.rs
+++ b/clippy_lints/src/needless_pass_by_value.rs
@@ -1,8 +1,8 @@
-use crate::utils::ptr::get_spans;
-use crate::utils::{get_trait_def_id, is_self, paths};
 use clippy_utils::diagnostics::{multispan_sugg, span_lint_and_then};
+use clippy_utils::ptr::get_spans;
 use clippy_utils::source::{snippet, snippet_opt};
 use clippy_utils::ty::{implements_trait, is_copy, is_type_diagnostic_item};
+use clippy_utils::{get_trait_def_id, is_self, paths};
 use if_chain::if_chain;
 use rustc_ast::ast::Attribute;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
diff --git a/clippy_lints/src/needless_question_mark.rs b/clippy_lints/src/needless_question_mark.rs
index ecf48d082af..99e85e6683c 100644
--- a/clippy_lints/src/needless_question_mark.rs
+++ b/clippy_lints/src/needless_question_mark.rs
@@ -1,6 +1,8 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::{is_ok_ctor, is_some_ctor, meets_msrv};
+use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Body, Expr, ExprKind, LangItem, MatchSource, QPath};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
@@ -8,9 +10,6 @@ use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::sym;
 
-use crate::utils;
-use if_chain::if_chain;
-
 declare_clippy_lint! {
     /// **What it does:**
     /// Suggests alternatives for useless applications of `?` in terminating expressions
@@ -161,7 +160,7 @@ fn is_some_or_ok_call<'a>(
         // Check outer expression matches CALL_IDENT(ARGUMENT) format
         if let ExprKind::Call(path, args) = &expr.kind;
         if let ExprKind::Path(QPath::Resolved(None, path)) = &path.kind;
-        if utils::is_some_ctor(cx, path.res) || utils::is_ok_ctor(cx, path.res);
+        if is_some_ctor(cx, path.res) || is_ok_ctor(cx, path.res);
 
         // Extract inner expression from ARGUMENT
         if let ExprKind::Match(inner_expr_with_q, _, MatchSource::TryDesugar) = &args[0].kind;
@@ -182,7 +181,7 @@ fn is_some_or_ok_call<'a>(
             let inner_is_some = is_type_diagnostic_item(cx, inner_ty, sym::option_type);
 
             // Check for Option MSRV
-            let meets_option_msrv = utils::meets_msrv(nqml.msrv.as_ref(), &NEEDLESS_QUESTION_MARK_OPTION_MSRV);
+            let meets_option_msrv = meets_msrv(nqml.msrv.as_ref(), &NEEDLESS_QUESTION_MARK_OPTION_MSRV);
             if outer_is_some && inner_is_some && meets_option_msrv {
                 return Some(SomeOkCall::SomeCall(expr, inner_expr));
             }
@@ -196,7 +195,7 @@ fn is_some_or_ok_call<'a>(
             let does_not_call_from = !has_implicit_error_from(cx, expr, inner_expr);
 
             // Must meet Result MSRV
-            let meets_result_msrv = utils::meets_msrv(nqml.msrv.as_ref(), &NEEDLESS_QUESTION_MARK_RESULT_MSRV);
+            let meets_result_msrv = meets_msrv(nqml.msrv.as_ref(), &NEEDLESS_QUESTION_MARK_RESULT_MSRV);
             if outer_is_result && inner_is_result && does_not_call_from && meets_result_msrv {
                 return Some(SomeOkCall::OkCall(expr, inner_expr));
             }
diff --git a/clippy_lints/src/neg_cmp_op_on_partial_ord.rs b/clippy_lints/src/neg_cmp_op_on_partial_ord.rs
index e291885d34d..4b935c7b906 100644
--- a/clippy_lints/src/neg_cmp_op_on_partial_ord.rs
+++ b/clippy_lints/src/neg_cmp_op_on_partial_ord.rs
@@ -1,13 +1,12 @@
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::ty::implements_trait;
+use clippy_utils::{self, get_trait_def_id, paths};
 use if_chain::if_chain;
 use rustc_hir::{BinOpKind, Expr, ExprKind, UnOp};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
-use crate::utils::{self, paths};
-
 declare_clippy_lint! {
     /// **What it does:**
     /// Checks for the usage of negated comparison operators on types which only implement
@@ -61,7 +60,7 @@ impl<'tcx> LateLintPass<'tcx> for NoNegCompOpForPartialOrd {
                 let ty = cx.typeck_results().expr_ty(left);
 
                 let implements_ord = {
-                    if let Some(id) = utils::get_trait_def_id(cx, &paths::ORD) {
+                    if let Some(id) = get_trait_def_id(cx, &paths::ORD) {
                         implements_trait(cx, ty, id, &[])
                     } else {
                         return;
diff --git a/clippy_lints/src/new_without_default.rs b/clippy_lints/src/new_without_default.rs
index 9fbb6b02742..502e5e4bf37 100644
--- a/clippy_lints/src/new_without_default.rs
+++ b/clippy_lints/src/new_without_default.rs
@@ -1,7 +1,7 @@
-use crate::utils::paths;
-use crate::utils::sugg::DiagnosticBuilderExt;
-use crate::utils::{get_trait_def_id, return_ty};
 use clippy_utils::diagnostics::span_lint_hir_and_then;
+use clippy_utils::paths;
+use clippy_utils::sugg::DiagnosticBuilderExt;
+use clippy_utils::{get_trait_def_id, return_ty};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
diff --git a/clippy_lints/src/non_copy_const.rs b/clippy_lints/src/non_copy_const.rs
index 5db614497e3..b86ae1426ef 100644
--- a/clippy_lints/src/non_copy_const.rs
+++ b/clippy_lints/src/non_copy_const.rs
@@ -5,6 +5,8 @@
 use std::ptr;
 
 use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::in_constant;
+use if_chain::if_chain;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::def_id::DefId;
 use rustc_hir::{
@@ -19,9 +21,6 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::{InnerSpan, Span, DUMMY_SP};
 use rustc_typeck::hir_ty_to_ty;
 
-use crate::utils::in_constant;
-use if_chain::if_chain;
-
 // FIXME: this is a correctness problem but there's no suitable
 // warn-by-default category.
 declare_clippy_lint! {
diff --git a/clippy_lints/src/open_options.rs b/clippy_lints/src/open_options.rs
index 8e8aaa67afa..c61dff4b8e0 100644
--- a/clippy_lints/src/open_options.rs
+++ b/clippy_lints/src/open_options.rs
@@ -1,5 +1,5 @@
-use crate::utils::paths;
 use clippy_utils::diagnostics::span_lint;
+use clippy_utils::paths;
 use clippy_utils::ty::match_type;
 use rustc_ast::ast::LitKind;
 use rustc_hir::{Expr, ExprKind};
diff --git a/clippy_lints/src/option_env_unwrap.rs b/clippy_lints/src/option_env_unwrap.rs
index 343159f9ae2..a0bc324e026 100644
--- a/clippy_lints/src/option_env_unwrap.rs
+++ b/clippy_lints/src/option_env_unwrap.rs
@@ -1,5 +1,5 @@
-use crate::utils::is_direct_expn_of;
 use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::is_direct_expn_of;
 use if_chain::if_chain;
 use rustc_ast::ast::{Expr, ExprKind};
 use rustc_lint::{EarlyContext, EarlyLintPass};
diff --git a/clippy_lints/src/option_if_let_else.rs b/clippy_lints/src/option_if_let_else.rs
index eab08a58320..a76a4a33f1f 100644
--- a/clippy_lints/src/option_if_let_else.rs
+++ b/clippy_lints/src/option_if_let_else.rs
@@ -1,11 +1,10 @@
-use crate::utils;
-use crate::utils::eager_or_lazy;
-use crate::utils::paths;
-use crate::utils::sugg::Sugg;
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::paths;
+use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::usage::contains_return_break_continue_macro;
+use clippy_utils::{eager_or_lazy, get_enclosing_block, in_macro, match_qpath};
 use if_chain::if_chain;
-
 use rustc_errors::Applicability;
 use rustc_hir::{Arm, BindingAnnotation, Block, Expr, ExprKind, MatchSource, Mutability, PatKind, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
@@ -110,7 +109,7 @@ fn extract_body_from_arm<'a>(arm: &'a Arm<'a>) -> Option<&'a Expr<'a>> {
 /// If this is the else body of an if/else expression, then we need to wrap
 /// it in curly braces. Otherwise, we don't.
 fn should_wrap_in_braces(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-    utils::get_enclosing_block(cx, expr.hir_id).map_or(false, |parent| {
+    get_enclosing_block(cx, expr.hir_id).map_or(false, |parent| {
         let mut should_wrap = false;
 
         if let Some(Expr {
@@ -160,15 +159,15 @@ fn detect_option_if_let_else<'tcx>(
     expr: &'_ Expr<'tcx>,
 ) -> Option<OptionIfLetElseOccurence> {
     if_chain! {
-        if !utils::in_macro(expr.span); // Don't lint macros, because it behaves weirdly
+        if !in_macro(expr.span); // Don't lint macros, because it behaves weirdly
         if let ExprKind::Match(cond_expr, arms, MatchSource::IfLetDesugar{contains_else_clause: true}) = &expr.kind;
         if arms.len() == 2;
         if !is_result_ok(cx, cond_expr); // Don't lint on Result::ok because a different lint does it already
         if let PatKind::TupleStruct(struct_qpath, &[inner_pat], _) = &arms[0].pat.kind;
-        if utils::match_qpath(struct_qpath, &paths::OPTION_SOME);
+        if match_qpath(struct_qpath, &paths::OPTION_SOME);
         if let PatKind::Binding(bind_annotation, _, id, _) = &inner_pat.kind;
-        if !utils::usage::contains_return_break_continue_macro(arms[0].body);
-        if !utils::usage::contains_return_break_continue_macro(arms[1].body);
+        if !contains_return_break_continue_macro(arms[0].body);
+        if !contains_return_break_continue_macro(arms[1].body);
         then {
             let capture_mut = if bind_annotation == &BindingAnnotation::Mutable { "mut " } else { "" };
             let some_body = extract_body_from_arm(&arms[0])?;
diff --git a/clippy_lints/src/overflow_check_conditional.rs b/clippy_lints/src/overflow_check_conditional.rs
index 524b96921fe..cf667c6e805 100644
--- a/clippy_lints/src/overflow_check_conditional.rs
+++ b/clippy_lints/src/overflow_check_conditional.rs
@@ -1,5 +1,5 @@
-use crate::utils::SpanlessEq;
 use clippy_utils::diagnostics::span_lint;
+use clippy_utils::SpanlessEq;
 use if_chain::if_chain;
 use rustc_hir::{BinOpKind, Expr, ExprKind, QPath};
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/panic_in_result_fn.rs b/clippy_lints/src/panic_in_result_fn.rs
index 880951f3e3e..d32b937b209 100644
--- a/clippy_lints/src/panic_in_result_fn.rs
+++ b/clippy_lints/src/panic_in_result_fn.rs
@@ -1,6 +1,6 @@
-use crate::utils::{find_macro_calls, return_ty};
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::{find_macro_calls, return_ty};
 use rustc_hir as hir;
 use rustc_hir::intravisit::FnKind;
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/panic_unimplemented.rs b/clippy_lints/src/panic_unimplemented.rs
index ad4ed831941..d06e7f8fe1e 100644
--- a/clippy_lints/src/panic_unimplemented.rs
+++ b/clippy_lints/src/panic_unimplemented.rs
@@ -1,5 +1,5 @@
-use crate::utils::{is_expn_of, match_panic_call};
 use clippy_utils::diagnostics::span_lint;
+use clippy_utils::{is_expn_of, match_panic_call};
 use if_chain::if_chain;
 use rustc_hir::Expr;
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/partialeq_ne_impl.rs b/clippy_lints/src/partialeq_ne_impl.rs
index 06985cef4ff..1251ddd9a02 100644
--- a/clippy_lints/src/partialeq_ne_impl.rs
+++ b/clippy_lints/src/partialeq_ne_impl.rs
@@ -1,5 +1,5 @@
-use crate::utils::is_automatically_derived;
 use clippy_utils::diagnostics::span_lint_hir;
+use clippy_utils::is_automatically_derived;
 use if_chain::if_chain;
 use rustc_hir::{Impl, Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/pass_by_ref_or_value.rs b/clippy_lints/src/pass_by_ref_or_value.rs
index c14273840c4..9a5b1c3b944 100644
--- a/clippy_lints/src/pass_by_ref_or_value.rs
+++ b/clippy_lints/src/pass_by_ref_or_value.rs
@@ -1,7 +1,7 @@
 use std::cmp;
 
-use crate::utils::is_self_ty;
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::is_self_ty;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::is_copy;
 use if_chain::if_chain;
diff --git a/clippy_lints/src/pattern_type_mismatch.rs b/clippy_lints/src/pattern_type_mismatch.rs
index dd63cf99e42..288e0e4586e 100644
--- a/clippy_lints/src/pattern_type_mismatch.rs
+++ b/clippy_lints/src/pattern_type_mismatch.rs
@@ -1,5 +1,5 @@
-use crate::utils::last_path_segment;
 use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::last_path_segment;
 use rustc_hir::{
     intravisit, Body, Expr, ExprKind, FieldPat, FnDecl, HirId, LocalSource, MatchSource, Mutability, Pat, PatKind,
     QPath, Stmt, StmtKind,
diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs
index 779eddcc170..be686b1b0cd 100644
--- a/clippy_lints/src/ptr.rs
+++ b/clippy_lints/src/ptr.rs
@@ -1,10 +1,10 @@
 //! Checks for usage of  `&Vec[_]` and `&String`.
 
-use crate::utils::ptr::get_spans;
-use crate::utils::{is_allowed, match_qpath, paths};
 use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg, span_lint_and_then};
+use clippy_utils::ptr::get_spans;
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::{is_type_diagnostic_item, match_type, walk_ptrs_hir_ty};
+use clippy_utils::{is_allowed, match_qpath, paths};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{
diff --git a/clippy_lints/src/ptr_eq.rs b/clippy_lints/src/ptr_eq.rs
index 82408c639b1..5796c59c8b3 100644
--- a/clippy_lints/src/ptr_eq.rs
+++ b/clippy_lints/src/ptr_eq.rs
@@ -1,5 +1,5 @@
-use crate::utils;
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::in_macro;
 use clippy_utils::source::snippet_opt;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
@@ -42,7 +42,7 @@ static LINT_MSG: &str = "use `std::ptr::eq` when comparing raw pointers";
 
 impl LateLintPass<'_> for PtrEq {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if utils::in_macro(expr.span) {
+        if in_macro(expr.span) {
             return;
         }
 
diff --git a/clippy_lints/src/question_mark.rs b/clippy_lints/src/question_mark.rs
index c4686623487..2054255a7c9 100644
--- a/clippy_lints/src/question_mark.rs
+++ b/clippy_lints/src/question_mark.rs
@@ -1,5 +1,8 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::{eq_expr_value, match_def_path, match_qpath, paths};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::def::{DefKind, Res};
@@ -8,10 +11,6 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::sym;
 
-use crate::utils::sugg::Sugg;
-use crate::utils::{eq_expr_value, match_def_path, match_qpath, paths};
-use clippy_utils::diagnostics::span_lint_and_sugg;
-
 declare_clippy_lint! {
     /// **What it does:** Checks for expressions that could be replaced by the question mark operator.
     ///
diff --git a/clippy_lints/src/ranges.rs b/clippy_lints/src/ranges.rs
index d476d95256f..95b21489eb5 100644
--- a/clippy_lints/src/ranges.rs
+++ b/clippy_lints/src/ranges.rs
@@ -1,6 +1,9 @@
 use crate::consts::{constant, Constant};
 use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::{snippet, snippet_opt, snippet_with_applicability};
+use clippy_utils::sugg::Sugg;
+use clippy_utils::{get_parent_expr, in_constant, is_integer_const, meets_msrv, single_segment_path};
+use clippy_utils::{higher, SpanlessEq};
 use if_chain::if_chain;
 use rustc_ast::ast::RangeLimits;
 use rustc_errors::Applicability;
@@ -14,10 +17,6 @@ use rustc_span::sym;
 use rustc_span::symbol::Ident;
 use std::cmp::Ordering;
 
-use crate::utils::sugg::Sugg;
-use crate::utils::{get_parent_expr, in_constant, is_integer_const, meets_msrv, single_segment_path};
-use crate::utils::{higher, SpanlessEq};
-
 declare_clippy_lint! {
     /// **What it does:** Checks for zipping a collection with the range of
     /// `0.._.len()`.
diff --git a/clippy_lints/src/redundant_clone.rs b/clippy_lints/src/redundant_clone.rs
index 3d799328bb5..60da2bcb04a 100644
--- a/clippy_lints/src/redundant_clone.rs
+++ b/clippy_lints/src/redundant_clone.rs
@@ -1,7 +1,7 @@
-use crate::utils::{fn_has_unsatisfiable_preds, match_def_path, paths};
 use clippy_utils::diagnostics::{span_lint_hir, span_lint_hir_and_then};
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::{has_drop, is_copy, is_type_diagnostic_item, walk_ptrs_ty_depth};
+use clippy_utils::{fn_has_unsatisfiable_preds, match_def_path, paths};
 use if_chain::if_chain;
 use rustc_data_structures::{fx::FxHashMap, transitive_relation::TransitiveRelation};
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/redundant_field_names.rs b/clippy_lints/src/redundant_field_names.rs
index fd11150bce2..f77be6fdf04 100644
--- a/clippy_lints/src/redundant_field_names.rs
+++ b/clippy_lints/src/redundant_field_names.rs
@@ -1,5 +1,5 @@
-use crate::utils::meets_msrv;
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::meets_msrv;
 use rustc_ast::ast::{Expr, ExprKind};
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass};
diff --git a/clippy_lints/src/redundant_static_lifetimes.rs b/clippy_lints/src/redundant_static_lifetimes.rs
index da8339a795a..32b57698ec5 100644
--- a/clippy_lints/src/redundant_static_lifetimes.rs
+++ b/clippy_lints/src/redundant_static_lifetimes.rs
@@ -1,5 +1,5 @@
-use crate::utils::meets_msrv;
 use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::meets_msrv;
 use clippy_utils::source::snippet;
 use rustc_ast::ast::{Item, ItemKind, Ty, TyKind};
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/ref_option_ref.rs b/clippy_lints/src/ref_option_ref.rs
index 452fef0694f..0922cfa494e 100644
--- a/clippy_lints/src/ref_option_ref.rs
+++ b/clippy_lints/src/ref_option_ref.rs
@@ -1,5 +1,5 @@
-use crate::utils::last_path_segment;
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::last_path_segment;
 use clippy_utils::source::snippet;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/reference.rs b/clippy_lints/src/reference.rs
index ec2acb6a0ab..d6336389b0a 100644
--- a/clippy_lints/src/reference.rs
+++ b/clippy_lints/src/reference.rs
@@ -1,7 +1,7 @@
-use crate::utils::in_macro;
-use crate::utils::sugg::Sugg;
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::in_macro;
 use clippy_utils::source::{snippet_opt, snippet_with_applicability};
+use clippy_utils::sugg::Sugg;
 use if_chain::if_chain;
 use rustc_ast::ast::{Expr, ExprKind, Mutability, UnOp};
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/regex.rs b/clippy_lints/src/regex.rs
index bfa21ba9c97..1cc332de894 100644
--- a/clippy_lints/src/regex.rs
+++ b/clippy_lints/src/regex.rs
@@ -1,6 +1,6 @@
 use crate::consts::{constant, Constant};
-use crate::utils::{match_def_path, paths};
 use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
+use clippy_utils::{match_def_path, paths};
 use if_chain::if_chain;
 use rustc_ast::ast::{LitKind, StrStyle};
 use rustc_data_structures::fx::FxHashSet;
diff --git a/clippy_lints/src/repeat_once.rs b/clippy_lints/src/repeat_once.rs
index b39e9d5a78c..63e5ec69e66 100644
--- a/clippy_lints/src/repeat_once.rs
+++ b/clippy_lints/src/repeat_once.rs
@@ -1,6 +1,6 @@
 use crate::consts::{constant_context, Constant};
-use crate::utils::in_macro;
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::in_macro;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
index 59d3c0ca5f0..8995ae431ad 100644
--- a/clippy_lints/src/returns.rs
+++ b/clippy_lints/src/returns.rs
@@ -1,5 +1,6 @@
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::snippet_opt;
+use clippy_utils::{fn_def_id, in_macro, match_qpath};
 use if_chain::if_chain;
 use rustc_ast::ast::Attribute;
 use rustc_errors::Applicability;
@@ -13,8 +14,6 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
 use rustc_span::sym;
 
-use crate::utils::{fn_def_id, in_macro, match_qpath};
-
 declare_clippy_lint! {
     /// **What it does:** Checks for `let`-bindings, which are subsequently
     /// returned.
diff --git a/clippy_lints/src/self_assignment.rs b/clippy_lints/src/self_assignment.rs
index 320d1a8dbe3..e7925c4fbde 100644
--- a/clippy_lints/src/self_assignment.rs
+++ b/clippy_lints/src/self_assignment.rs
@@ -1,5 +1,5 @@
-use crate::utils::eq_expr_value;
 use clippy_utils::diagnostics::span_lint;
+use clippy_utils::eq_expr_value;
 use clippy_utils::source::snippet;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/semicolon_if_nothing_returned.rs b/clippy_lints/src/semicolon_if_nothing_returned.rs
index e43947025b9..f61af15fbed 100644
--- a/clippy_lints/src/semicolon_if_nothing_returned.rs
+++ b/clippy_lints/src/semicolon_if_nothing_returned.rs
@@ -1,6 +1,6 @@
-use crate::utils::{in_macro, sugg};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_macro_callsite;
+use clippy_utils::{in_macro, sugg};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Block, ExprKind};
diff --git a/clippy_lints/src/serde_api.rs b/clippy_lints/src/serde_api.rs
index 632715852c5..169f7d26285 100644
--- a/clippy_lints/src/serde_api.rs
+++ b/clippy_lints/src/serde_api.rs
@@ -1,5 +1,5 @@
-use crate::utils::{get_trait_def_id, paths};
 use clippy_utils::diagnostics::span_lint;
+use clippy_utils::{get_trait_def_id, paths};
 use rustc_hir::{Impl, Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
diff --git a/clippy_lints/src/shadow.rs b/clippy_lints/src/shadow.rs
index 8ef58b6d563..612d2fd84cb 100644
--- a/clippy_lints/src/shadow.rs
+++ b/clippy_lints/src/shadow.rs
@@ -1,6 +1,6 @@
-use crate::utils::{contains_name, higher, iter_input_pats};
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet;
+use clippy_utils::{contains_name, higher, iter_input_pats};
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::{
     Block, Body, Expr, ExprKind, FnDecl, Guard, HirId, Local, MutTy, Pat, PatKind, Path, QPath, StmtKind, Ty, TyKind,
diff --git a/clippy_lints/src/single_component_path_imports.rs b/clippy_lints/src/single_component_path_imports.rs
index 6d15a6c444e..c9d72aabb6a 100644
--- a/clippy_lints/src/single_component_path_imports.rs
+++ b/clippy_lints/src/single_component_path_imports.rs
@@ -1,5 +1,5 @@
-use crate::utils::in_macro;
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::in_macro;
 use if_chain::if_chain;
 use rustc_ast::{Item, ItemKind, UseTreeKind};
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/size_of_in_element_count.rs b/clippy_lints/src/size_of_in_element_count.rs
index 8920d446b9c..09e00866815 100644
--- a/clippy_lints/src/size_of_in_element_count.rs
+++ b/clippy_lints/src/size_of_in_element_count.rs
@@ -1,8 +1,8 @@
 //! Lint on use of `size_of` or `size_of_val` of T in an expression
 //! expecting a count of T
 
-use crate::utils::{match_def_path, paths};
 use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::{match_def_path, paths};
 use if_chain::if_chain;
 use rustc_hir::BinOpKind;
 use rustc_hir::{Expr, ExprKind};
diff --git a/clippy_lints/src/slow_vector_initialization.rs b/clippy_lints/src/slow_vector_initialization.rs
index 7f0f21084af..d55a83f1613 100644
--- a/clippy_lints/src/slow_vector_initialization.rs
+++ b/clippy_lints/src/slow_vector_initialization.rs
@@ -1,6 +1,6 @@
-use crate::utils::sugg::Sugg;
-use crate::utils::{get_enclosing_block, match_qpath, SpanlessEq};
 use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::sugg::Sugg;
+use clippy_utils::{get_enclosing_block, match_qpath, SpanlessEq};
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/stable_sort_primitive.rs b/clippy_lints/src/stable_sort_primitive.rs
index 85e4bb806e7..65790375c73 100644
--- a/clippy_lints/src/stable_sort_primitive.rs
+++ b/clippy_lints/src/stable_sort_primitive.rs
@@ -1,8 +1,6 @@
-use crate::utils::{is_slice_of_primitives, sugg::Sugg};
 use clippy_utils::diagnostics::span_lint_and_then;
-
+use clippy_utils::{is_slice_of_primitives, sugg::Sugg};
 use if_chain::if_chain;
-
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/strings.rs b/clippy_lints/src/strings.rs
index 626166f9008..760f5e3b432 100644
--- a/clippy_lints/src/strings.rs
+++ b/clippy_lints/src/strings.rs
@@ -1,8 +1,8 @@
-use crate::utils::SpanlessEq;
-use crate::utils::{get_parent_expr, is_allowed, match_function_call, method_calls, paths};
 use clippy_utils::diagnostics::{span_lint, span_lint_and_help, span_lint_and_sugg};
 use clippy_utils::source::{snippet, snippet_with_applicability};
 use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::SpanlessEq;
+use clippy_utils::{get_parent_expr, is_allowed, match_function_call, method_calls, paths};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, BorrowKind, Expr, ExprKind, LangItem, QPath};
diff --git a/clippy_lints/src/suspicious_operation_groupings.rs b/clippy_lints/src/suspicious_operation_groupings.rs
index 364c99adc69..1e5d3c17e3b 100644
--- a/clippy_lints/src/suspicious_operation_groupings.rs
+++ b/clippy_lints/src/suspicious_operation_groupings.rs
@@ -1,4 +1,4 @@
-use crate::utils::ast_utils::{eq_id, is_useless_with_eq_exprs, IdentIter};
+use clippy_utils::ast_utils::{eq_id, is_useless_with_eq_exprs, IdentIter};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use core::ops::{Add, AddAssign};
diff --git a/clippy_lints/src/suspicious_trait_impl.rs b/clippy_lints/src/suspicious_trait_impl.rs
index ef14b6c5136..0f024c9a11e 100644
--- a/clippy_lints/src/suspicious_trait_impl.rs
+++ b/clippy_lints/src/suspicious_trait_impl.rs
@@ -1,5 +1,5 @@
-use crate::utils::{get_trait_def_id, trait_ref_of_method};
 use clippy_utils::diagnostics::span_lint;
+use clippy_utils::{get_trait_def_id, trait_ref_of_method};
 use if_chain::if_chain;
 use rustc_hir as hir;
 use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
@@ -159,7 +159,7 @@ fn check_binop(
     expected_ops: &[hir::BinOpKind],
 ) -> Option<&'static str> {
     let mut trait_ids = vec![];
-    let [krate, module] = crate::utils::paths::OPS_MODULE;
+    let [krate, module] = clippy_utils::paths::OPS_MODULE;
 
     for &t in traits {
         let path = [krate, module, t];
diff --git a/clippy_lints/src/swap.rs b/clippy_lints/src/swap.rs
index 83fe3c49959..14519eaa962 100644
--- a/clippy_lints/src/swap.rs
+++ b/clippy_lints/src/swap.rs
@@ -1,8 +1,8 @@
-use crate::utils::sugg::Sugg;
-use crate::utils::{differing_macro_contexts, eq_expr_value};
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::{differing_macro_contexts, eq_expr_value};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Block, Expr, ExprKind, PatKind, QPath, StmtKind};
diff --git a/clippy_lints/src/temporary_assignment.rs b/clippy_lints/src/temporary_assignment.rs
index 75a13cb9187..8ef25dc816c 100644
--- a/clippy_lints/src/temporary_assignment.rs
+++ b/clippy_lints/src/temporary_assignment.rs
@@ -1,5 +1,5 @@
-use crate::utils::is_adjusted;
 use clippy_utils::diagnostics::span_lint;
+use clippy_utils::is_adjusted;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
diff --git a/clippy_lints/src/to_digit_is_some.rs b/clippy_lints/src/to_digit_is_some.rs
index abc9b2fe88e..c66a596c784 100644
--- a/clippy_lints/src/to_digit_is_some.rs
+++ b/clippy_lints/src/to_digit_is_some.rs
@@ -1,5 +1,5 @@
-use crate::utils::match_def_path;
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::match_def_path;
 use clippy_utils::source::snippet_with_applicability;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/to_string_in_display.rs b/clippy_lints/src/to_string_in_display.rs
index 42605c01089..42ec14c31b5 100644
--- a/clippy_lints/src/to_string_in_display.rs
+++ b/clippy_lints/src/to_string_in_display.rs
@@ -1,5 +1,5 @@
-use crate::utils::{is_diagnostic_assoc_item, match_def_path, path_to_local_id, paths};
 use clippy_utils::diagnostics::span_lint;
+use clippy_utils::{is_diagnostic_assoc_item, match_def_path, path_to_local_id, paths};
 use if_chain::if_chain;
 use rustc_hir::{Expr, ExprKind, HirId, Impl, ImplItem, ImplItemKind, Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/trait_bounds.rs b/clippy_lints/src/trait_bounds.rs
index cfcc8da9910..3ff27c3bcf4 100644
--- a/clippy_lints/src/trait_bounds.rs
+++ b/clippy_lints/src/trait_bounds.rs
@@ -1,6 +1,6 @@
-use crate::utils::{in_macro, SpanlessHash};
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::source::{snippet, snippet_with_applicability};
+use clippy_utils::{in_macro, SpanlessHash};
 use if_chain::if_chain;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/transmute/mod.rs b/clippy_lints/src/transmute/mod.rs
index c1870f5208b..47d58bd30db 100644
--- a/clippy_lints/src/transmute/mod.rs
+++ b/clippy_lints/src/transmute/mod.rs
@@ -12,7 +12,7 @@ mod useless_transmute;
 mod utils;
 mod wrong_transmute;
 
-use crate::utils::{in_constant, match_def_path, paths};
+use clippy_utils::{in_constant, match_def_path, paths};
 use if_chain::if_chain;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/transmute/transmute_float_to_int.rs b/clippy_lints/src/transmute/transmute_float_to_int.rs
index f61b5362b5a..72489f27cd3 100644
--- a/clippy_lints/src/transmute/transmute_float_to_int.rs
+++ b/clippy_lints/src/transmute/transmute_float_to_int.rs
@@ -1,6 +1,6 @@
 use super::TRANSMUTE_FLOAT_TO_INT;
-use crate::utils::sugg;
 use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::sugg;
 use if_chain::if_chain;
 use rustc_ast as ast;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/transmute/transmute_int_to_bool.rs b/clippy_lints/src/transmute/transmute_int_to_bool.rs
index ebdd1eba744..cc0a5643e2a 100644
--- a/clippy_lints/src/transmute/transmute_int_to_bool.rs
+++ b/clippy_lints/src/transmute/transmute_int_to_bool.rs
@@ -1,6 +1,6 @@
 use super::TRANSMUTE_INT_TO_BOOL;
-use crate::utils::sugg;
 use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::sugg;
 use rustc_ast as ast;
 use rustc_errors::Applicability;
 use rustc_hir::Expr;
diff --git a/clippy_lints/src/transmute/transmute_int_to_char.rs b/clippy_lints/src/transmute/transmute_int_to_char.rs
index afecfc3d701..8f884e6a4a1 100644
--- a/clippy_lints/src/transmute/transmute_int_to_char.rs
+++ b/clippy_lints/src/transmute/transmute_int_to_char.rs
@@ -1,6 +1,6 @@
 use super::TRANSMUTE_INT_TO_CHAR;
-use crate::utils::sugg;
 use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::sugg;
 use rustc_ast as ast;
 use rustc_errors::Applicability;
 use rustc_hir::Expr;
diff --git a/clippy_lints/src/transmute/transmute_int_to_float.rs b/clippy_lints/src/transmute/transmute_int_to_float.rs
index c762a7ab885..2b6a4cff81e 100644
--- a/clippy_lints/src/transmute/transmute_int_to_float.rs
+++ b/clippy_lints/src/transmute/transmute_int_to_float.rs
@@ -1,6 +1,6 @@
 use super::TRANSMUTE_INT_TO_FLOAT;
-use crate::utils::sugg;
 use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::sugg;
 use rustc_errors::Applicability;
 use rustc_hir::Expr;
 use rustc_lint::LateContext;
diff --git a/clippy_lints/src/transmute/transmute_ptr_to_ptr.rs b/clippy_lints/src/transmute/transmute_ptr_to_ptr.rs
index 820c56a215e..7b646bfc0c6 100644
--- a/clippy_lints/src/transmute/transmute_ptr_to_ptr.rs
+++ b/clippy_lints/src/transmute/transmute_ptr_to_ptr.rs
@@ -1,6 +1,6 @@
 use super::TRANSMUTE_PTR_TO_PTR;
-use crate::utils::sugg;
 use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::sugg;
 use rustc_errors::Applicability;
 use rustc_hir::Expr;
 use rustc_lint::LateContext;
diff --git a/clippy_lints/src/transmute/transmute_ptr_to_ref.rs b/clippy_lints/src/transmute/transmute_ptr_to_ref.rs
index 049210e555c..f14eef93645 100644
--- a/clippy_lints/src/transmute/transmute_ptr_to_ref.rs
+++ b/clippy_lints/src/transmute/transmute_ptr_to_ref.rs
@@ -1,7 +1,7 @@
 use super::utils::get_type_snippet;
 use super::TRANSMUTE_PTR_TO_REF;
-use crate::utils::sugg;
 use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::sugg;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, Mutability, QPath};
 use rustc_lint::LateContext;
diff --git a/clippy_lints/src/transmute/transmute_ref_to_ref.rs b/clippy_lints/src/transmute/transmute_ref_to_ref.rs
index 993ef8698f8..d105e37abf9 100644
--- a/clippy_lints/src/transmute/transmute_ref_to_ref.rs
+++ b/clippy_lints/src/transmute/transmute_ref_to_ref.rs
@@ -1,7 +1,7 @@
 use super::{TRANSMUTE_BYTES_TO_STR, TRANSMUTE_PTR_TO_PTR};
-use crate::utils::sugg;
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::snippet;
+use clippy_utils::sugg;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, Mutability};
diff --git a/clippy_lints/src/transmute/transmutes_expressible_as_ptr_casts.rs b/clippy_lints/src/transmute/transmutes_expressible_as_ptr_casts.rs
index da7d1016d97..e2c6d130f3c 100644
--- a/clippy_lints/src/transmute/transmutes_expressible_as_ptr_casts.rs
+++ b/clippy_lints/src/transmute/transmutes_expressible_as_ptr_casts.rs
@@ -1,7 +1,7 @@
 use super::utils::can_be_expressed_as_pointer_cast;
 use super::TRANSMUTES_EXPRESSIBLE_AS_PTR_CASTS;
-use crate::utils::sugg;
 use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::sugg;
 use rustc_errors::Applicability;
 use rustc_hir::Expr;
 use rustc_lint::LateContext;
diff --git a/clippy_lints/src/transmute/unsound_collection_transmute.rs b/clippy_lints/src/transmute/unsound_collection_transmute.rs
index 9bea88be7da..de9277e016e 100644
--- a/clippy_lints/src/transmute/unsound_collection_transmute.rs
+++ b/clippy_lints/src/transmute/unsound_collection_transmute.rs
@@ -1,7 +1,7 @@
 use super::utils::is_layout_incompatible;
 use super::UNSOUND_COLLECTION_TRANSMUTE;
-use crate::utils::{match_def_path, paths};
 use clippy_utils::diagnostics::span_lint;
+use clippy_utils::{match_def_path, paths};
 use rustc_hir::Expr;
 use rustc_lint::LateContext;
 use rustc_middle::ty::{self, Ty};
diff --git a/clippy_lints/src/transmute/useless_transmute.rs b/clippy_lints/src/transmute/useless_transmute.rs
index 29ffe03b673..445bcf60fa7 100644
--- a/clippy_lints/src/transmute/useless_transmute.rs
+++ b/clippy_lints/src/transmute/useless_transmute.rs
@@ -1,6 +1,6 @@
 use super::USELESS_TRANSMUTE;
-use crate::utils::sugg;
 use clippy_utils::diagnostics::{span_lint, span_lint_and_then};
+use clippy_utils::sugg;
 use rustc_errors::Applicability;
 use rustc_hir::Expr;
 use rustc_lint::LateContext;
diff --git a/clippy_lints/src/transmute/utils.rs b/clippy_lints/src/transmute/utils.rs
index 0633697687a..c6d0d63b0b5 100644
--- a/clippy_lints/src/transmute/utils.rs
+++ b/clippy_lints/src/transmute/utils.rs
@@ -1,4 +1,4 @@
-use crate::utils::last_path_segment;
+use clippy_utils::last_path_segment;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::is_normalizable;
 use if_chain::if_chain;
diff --git a/clippy_lints/src/transmuting_null.rs b/clippy_lints/src/transmuting_null.rs
index 3a2b1359a54..d42cdde110e 100644
--- a/clippy_lints/src/transmuting_null.rs
+++ b/clippy_lints/src/transmuting_null.rs
@@ -1,6 +1,6 @@
 use crate::consts::{constant_context, Constant};
-use crate::utils::{match_qpath, paths};
 use clippy_utils::diagnostics::span_lint;
+use clippy_utils::{match_qpath, paths};
 use if_chain::if_chain;
 use rustc_ast::LitKind;
 use rustc_hir::{Expr, ExprKind};
diff --git a/clippy_lints/src/try_err.rs b/clippy_lints/src/try_err.rs
index 1fce03b4f47..e61058c2749 100644
--- a/clippy_lints/src/try_err.rs
+++ b/clippy_lints/src/try_err.rs
@@ -1,7 +1,7 @@
-use crate::utils::{differing_macro_contexts, in_macro, match_def_path, match_qpath, paths};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::{snippet, snippet_with_macro_callsite};
 use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::{differing_macro_contexts, in_macro, match_def_path, match_qpath, paths};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, LangItem, MatchSource, QPath};
diff --git a/clippy_lints/src/types/borrowed_box.rs b/clippy_lints/src/types/borrowed_box.rs
index eab81b1e246..1721fcfdcf4 100644
--- a/clippy_lints/src/types/borrowed_box.rs
+++ b/clippy_lints/src/types/borrowed_box.rs
@@ -1,6 +1,6 @@
-use crate::utils::{match_path, paths};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet;
+use clippy_utils::{match_path, paths};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{
diff --git a/clippy_lints/src/types/box_vec.rs b/clippy_lints/src/types/box_vec.rs
index 6d04a47a5c8..d8b1953457c 100644
--- a/clippy_lints/src/types/box_vec.rs
+++ b/clippy_lints/src/types/box_vec.rs
@@ -1,10 +1,9 @@
 use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::is_ty_param_diagnostic_item;
 use rustc_hir::{self as hir, def_id::DefId, QPath};
 use rustc_lint::LateContext;
 use rustc_span::symbol::sym;
 
-use crate::utils::is_ty_param_diagnostic_item;
-
 use super::BOX_VEC;
 
 pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_>, def_id: DefId) -> bool {
diff --git a/clippy_lints/src/types/linked_list.rs b/clippy_lints/src/types/linked_list.rs
index e9e1995f6a5..a9fbe7aa315 100644
--- a/clippy_lints/src/types/linked_list.rs
+++ b/clippy_lints/src/types/linked_list.rs
@@ -1,9 +1,8 @@
 use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::{match_def_path, paths};
 use rustc_hir::{self as hir, def_id::DefId};
 use rustc_lint::LateContext;
 
-use crate::utils::{match_def_path, paths};
-
 use super::LINKEDLIST;
 
 pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, def_id: DefId) -> bool {
diff --git a/clippy_lints/src/types/mod.rs b/clippy_lints/src/types/mod.rs
index 5103a259559..c0cd48e94b2 100644
--- a/clippy_lints/src/types/mod.rs
+++ b/clippy_lints/src/types/mod.rs
@@ -36,8 +36,8 @@ use rustc_target::spec::abi::Abi;
 use rustc_typeck::hir_ty_to_ty;
 
 use crate::consts::{constant, Constant};
-use crate::utils::paths;
-use crate::utils::{clip, comparisons, differing_macro_contexts, int_bits, match_path, sext, unsext};
+use clippy_utils::paths;
+use clippy_utils::{clip, comparisons, differing_macro_contexts, int_bits, match_path, sext, unsext};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for use of `Box<Vec<_>>` anywhere in the code.
@@ -618,7 +618,7 @@ fn detect_absurd_comparison<'tcx>(
 ) -> Option<(ExtremeExpr<'tcx>, AbsurdComparisonResult)> {
     use crate::types::AbsurdComparisonResult::{AlwaysFalse, AlwaysTrue, InequalityImpossible};
     use crate::types::ExtremeType::{Maximum, Minimum};
-    use crate::utils::comparisons::{normalize_comparison, Rel};
+    use clippy_utils::comparisons::{normalize_comparison, Rel};
 
     // absurd comparison only makes sense on primitive types
     // primitive types don't implement comparison operators with each other
@@ -860,7 +860,7 @@ fn upcast_comparison_bounds_err<'tcx>(
     rhs: &'tcx Expr<'_>,
     invert: bool,
 ) {
-    use crate::utils::comparisons::Rel;
+    use clippy_utils::comparisons::Rel;
 
     if let Some((lb, ub)) = lhs_bounds {
         if let Some(norm_rhs_val) = node_as_const_fullint(cx, rhs) {
diff --git a/clippy_lints/src/types/option_option.rs b/clippy_lints/src/types/option_option.rs
index 79c5a32de2c..b2692c48076 100644
--- a/clippy_lints/src/types/option_option.rs
+++ b/clippy_lints/src/types/option_option.rs
@@ -1,10 +1,9 @@
 use clippy_utils::diagnostics::span_lint;
+use clippy_utils::is_ty_param_diagnostic_item;
 use rustc_hir::{self as hir, def_id::DefId, QPath};
 use rustc_lint::LateContext;
 use rustc_span::symbol::sym;
 
-use crate::utils::is_ty_param_diagnostic_item;
-
 use super::OPTION_OPTION;
 
 pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_>, def_id: DefId) -> bool {
diff --git a/clippy_lints/src/types/rc_buffer.rs b/clippy_lints/src/types/rc_buffer.rs
index d5fc23f2e39..ef629a35d10 100644
--- a/clippy_lints/src/types/rc_buffer.rs
+++ b/clippy_lints/src/types/rc_buffer.rs
@@ -1,12 +1,11 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::{get_qpath_generic_tys, is_ty_param_diagnostic_item};
 use rustc_errors::Applicability;
 use rustc_hir::{self as hir, def_id::DefId, QPath, TyKind};
 use rustc_lint::LateContext;
 use rustc_span::symbol::sym;
 
-use crate::utils::{get_qpath_generic_tys, is_ty_param_diagnostic_item};
-
 use super::RC_BUFFER;
 
 pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_>, def_id: DefId) -> bool {
diff --git a/clippy_lints/src/types/redundant_allocation.rs b/clippy_lints/src/types/redundant_allocation.rs
index 71c014f96f7..c0c1f340583 100644
--- a/clippy_lints/src/types/redundant_allocation.rs
+++ b/clippy_lints/src/types/redundant_allocation.rs
@@ -1,12 +1,11 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::{get_qpath_generic_tys, is_ty_param_diagnostic_item, is_ty_param_lang_item};
 use rustc_errors::Applicability;
 use rustc_hir::{self as hir, def_id::DefId, LangItem, QPath, TyKind};
 use rustc_lint::LateContext;
 use rustc_span::symbol::sym;
 
-use crate::utils::{get_qpath_generic_tys, is_ty_param_diagnostic_item, is_ty_param_lang_item};
-
 use super::{utils, REDUNDANT_ALLOCATION};
 
 pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_>, def_id: DefId) -> bool {
diff --git a/clippy_lints/src/types/utils.rs b/clippy_lints/src/types/utils.rs
index 4d64748f998..45f891ed718 100644
--- a/clippy_lints/src/types/utils.rs
+++ b/clippy_lints/src/types/utils.rs
@@ -1,11 +1,9 @@
+use clippy_utils::last_path_segment;
+use if_chain::if_chain;
 use rustc_hir::{GenericArg, QPath, TyKind};
 use rustc_lint::LateContext;
 use rustc_span::source_map::Span;
 
-use crate::utils::last_path_segment;
-
-use if_chain::if_chain;
-
 pub(super) fn match_borrows_parameter(_cx: &LateContext<'_>, qpath: &QPath<'_>) -> Option<Span> {
     let last = last_path_segment(qpath);
     if_chain! {
diff --git a/clippy_lints/src/types/vec_box.rs b/clippy_lints/src/types/vec_box.rs
index 8cedb0ede2b..d2c373db261 100644
--- a/clippy_lints/src/types/vec_box.rs
+++ b/clippy_lints/src/types/vec_box.rs
@@ -1,4 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::last_path_segment;
 use clippy_utils::source::snippet;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
@@ -9,8 +10,6 @@ use rustc_span::symbol::sym;
 use rustc_target::abi::LayoutOf;
 use rustc_typeck::hir_ty_to_ty;
 
-use crate::utils::last_path_segment;
-
 use super::VEC_BOX;
 
 pub(super) fn check(
diff --git a/clippy_lints/src/undropped_manually_drops.rs b/clippy_lints/src/undropped_manually_drops.rs
index 943573a2b53..b6749069176 100644
--- a/clippy_lints/src/undropped_manually_drops.rs
+++ b/clippy_lints/src/undropped_manually_drops.rs
@@ -1,6 +1,6 @@
-use crate::utils::{match_function_call, paths};
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::ty::is_type_lang_item;
+use clippy_utils::{match_function_call, paths};
 use rustc_hir::{lang_items, Expr};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
diff --git a/clippy_lints/src/unicode.rs b/clippy_lints/src/unicode.rs
index c37bbf297f8..d81e31f5a21 100644
--- a/clippy_lints/src/unicode.rs
+++ b/clippy_lints/src/unicode.rs
@@ -1,5 +1,5 @@
-use crate::utils::is_allowed;
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::is_allowed;
 use clippy_utils::source::snippet;
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/unit_return_expecting_ord.rs b/clippy_lints/src/unit_return_expecting_ord.rs
index d0456347f8a..bad3e488bb6 100644
--- a/clippy_lints/src/unit_return_expecting_ord.rs
+++ b/clippy_lints/src/unit_return_expecting_ord.rs
@@ -1,5 +1,5 @@
-use crate::utils::{get_trait_def_id, paths};
 use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
+use clippy_utils::{get_trait_def_id, paths};
 use if_chain::if_chain;
 use rustc_hir::def_id::DefId;
 use rustc_hir::{Expr, ExprKind, StmtKind};
diff --git a/clippy_lints/src/unit_types/let_unit_value.rs b/clippy_lints/src/unit_types/let_unit_value.rs
index 55715cc6bf3..8698a718bbd 100644
--- a/clippy_lints/src/unit_types/let_unit_value.rs
+++ b/clippy_lints/src/unit_types/let_unit_value.rs
@@ -1,12 +1,11 @@
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::higher;
+use clippy_utils::source::snippet_with_macro_callsite;
 use rustc_errors::Applicability;
 use rustc_hir::{Stmt, StmtKind};
 use rustc_lint::{LateContext, LintContext};
 use rustc_middle::lint::in_external_macro;
 
-use crate::utils::diagnostics::span_lint_and_then;
-use crate::utils::higher;
-use crate::utils::source::snippet_with_macro_callsite;
-
 use super::LET_UNIT_VALUE;
 
 pub(super) fn check(cx: &LateContext<'_>, stmt: &Stmt<'_>) {
diff --git a/clippy_lints/src/unit_types/unit_arg.rs b/clippy_lints/src/unit_types/unit_arg.rs
index d4ef645fc8d..925ab577099 100644
--- a/clippy_lints/src/unit_types/unit_arg.rs
+++ b/clippy_lints/src/unit_types/unit_arg.rs
@@ -1,12 +1,10 @@
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::source::{indent_of, reindent_multiline, snippet_opt};
+use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{self as hir, Block, Expr, ExprKind, MatchSource, Node, StmtKind};
 use rustc_lint::LateContext;
 
-use if_chain::if_chain;
-
-use crate::utils::diagnostics::span_lint_and_then;
-use crate::utils::source::{indent_of, reindent_multiline, snippet_opt};
-
 use super::{utils, UNIT_ARG};
 
 pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>) {
diff --git a/clippy_lints/src/unit_types/unit_cmp.rs b/clippy_lints/src/unit_types/unit_cmp.rs
index f9c0374c86d..b3077dec5d8 100644
--- a/clippy_lints/src/unit_types/unit_cmp.rs
+++ b/clippy_lints/src/unit_types/unit_cmp.rs
@@ -1,9 +1,8 @@
+use clippy_utils::diagnostics::span_lint;
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::LateContext;
 use rustc_span::hygiene::{ExpnKind, MacroKind};
 
-use crate::utils::diagnostics::span_lint;
-
 use super::UNIT_CMP;
 
 pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>) {
diff --git a/clippy_lints/src/unnamed_address.rs b/clippy_lints/src/unnamed_address.rs
index 2c51a8556d9..d5bc3de6698 100644
--- a/clippy_lints/src/unnamed_address.rs
+++ b/clippy_lints/src/unnamed_address.rs
@@ -1,5 +1,5 @@
-use crate::utils::{match_def_path, paths};
 use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
+use clippy_utils::{match_def_path, paths};
 use if_chain::if_chain;
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/unnecessary_sort_by.rs b/clippy_lints/src/unnecessary_sort_by.rs
index aa83f6a74be..e23bab5eba0 100644
--- a/clippy_lints/src/unnecessary_sort_by.rs
+++ b/clippy_lints/src/unnecessary_sort_by.rs
@@ -1,5 +1,5 @@
-use crate::utils::sugg::Sugg;
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/unnecessary_wraps.rs b/clippy_lints/src/unnecessary_wraps.rs
index cb20192b683..9e227164695 100644
--- a/clippy_lints/src/unnecessary_wraps.rs
+++ b/clippy_lints/src/unnecessary_wraps.rs
@@ -1,6 +1,6 @@
-use crate::utils::{contains_return, in_macro, match_qpath, paths, return_ty, visitors::find_all_ret_expressions};
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet;
+use clippy_utils::{contains_return, in_macro, match_qpath, paths, return_ty, visitors::find_all_ret_expressions};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::FnKind;
diff --git a/clippy_lints/src/unnested_or_patterns.rs b/clippy_lints/src/unnested_or_patterns.rs
index 42ff1809ff4..512d505dfb5 100644
--- a/clippy_lints/src/unnested_or_patterns.rs
+++ b/clippy_lints/src/unnested_or_patterns.rs
@@ -1,8 +1,8 @@
 #![allow(clippy::wildcard_imports, clippy::enum_glob_use)]
 
-use crate::utils::ast_utils::{eq_field_pat, eq_id, eq_pat, eq_path};
-use crate::utils::over;
+use clippy_utils::ast_utils::{eq_field_pat, eq_id, eq_pat, eq_path};
 use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::over;
 use rustc_ast::mut_visit::*;
 use rustc_ast::ptr::P;
 use rustc_ast::{self as ast, Pat, PatKind, PatKind::*, DUMMY_NODE_ID};
diff --git a/clippy_lints/src/unused_io_amount.rs b/clippy_lints/src/unused_io_amount.rs
index 31fd61f99f2..9990052e114 100644
--- a/clippy_lints/src/unused_io_amount.rs
+++ b/clippy_lints/src/unused_io_amount.rs
@@ -1,5 +1,5 @@
-use crate::utils::{is_try, match_trait_method, paths};
 use clippy_utils::diagnostics::span_lint;
+use clippy_utils::{is_try, match_trait_method, paths};
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
diff --git a/clippy_lints/src/unused_self.rs b/clippy_lints/src/unused_self.rs
index 4642bf07c45..aef4ce75915 100644
--- a/clippy_lints/src/unused_self.rs
+++ b/clippy_lints/src/unused_self.rs
@@ -1,11 +1,10 @@
 use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::visitors::LocalUsedVisitor;
 use if_chain::if_chain;
 use rustc_hir::{Impl, ImplItem, ImplItemKind, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
-use crate::utils::visitors::LocalUsedVisitor;
-
 declare_clippy_lint! {
     /// **What it does:** Checks methods that contain a `self` argument but don't use it
     ///
diff --git a/clippy_lints/src/unused_unit.rs b/clippy_lints/src/unused_unit.rs
index c45b851211c..329ea49024b 100644
--- a/clippy_lints/src/unused_unit.rs
+++ b/clippy_lints/src/unused_unit.rs
@@ -1,3 +1,4 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::position_before_rarrow;
 use if_chain::if_chain;
 use rustc_ast::ast;
@@ -8,8 +9,6 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
 use rustc_span::BytePos;
 
-use clippy_utils::diagnostics::span_lint_and_sugg;
-
 declare_clippy_lint! {
     /// **What it does:** Checks for unit (`()`) expressions that can be removed.
     ///
diff --git a/clippy_lints/src/unwrap.rs b/clippy_lints/src/unwrap.rs
index 75b2f2da602..fb29acca18a 100644
--- a/clippy_lints/src/unwrap.rs
+++ b/clippy_lints/src/unwrap.rs
@@ -1,6 +1,6 @@
-use crate::utils::{differing_macro_contexts, usage::is_potentially_mutated};
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::{differing_macro_contexts, usage::is_potentially_mutated};
 use if_chain::if_chain;
 use rustc_hir::intravisit::{walk_expr, walk_fn, FnKind, NestedVisitorMap, Visitor};
 use rustc_hir::{BinOpKind, Body, Expr, ExprKind, FnDecl, HirId, Path, QPath, UnOp};
diff --git a/clippy_lints/src/unwrap_in_result.rs b/clippy_lints/src/unwrap_in_result.rs
index a85f3ce5c9c..0d745813beb 100644
--- a/clippy_lints/src/unwrap_in_result.rs
+++ b/clippy_lints/src/unwrap_in_result.rs
@@ -1,6 +1,6 @@
-use crate::utils::{method_chain_args, return_ty};
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::{method_chain_args, return_ty};
 use if_chain::if_chain;
 use rustc_hir as hir;
 use rustc_hir::intravisit::{self, NestedVisitorMap, Visitor};
diff --git a/clippy_lints/src/use_self.rs b/clippy_lints/src/use_self.rs
index 9a42c833470..116cb8b1e1c 100644
--- a/clippy_lints/src/use_self.rs
+++ b/clippy_lints/src/use_self.rs
@@ -1,6 +1,6 @@
-use crate::utils::{in_macro, meets_msrv};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_opt;
+use clippy_utils::{in_macro, meets_msrv};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
diff --git a/clippy_lints/src/useless_conversion.rs b/clippy_lints/src/useless_conversion.rs
index 1eb152daac8..3e1b69e676b 100644
--- a/clippy_lints/src/useless_conversion.rs
+++ b/clippy_lints/src/useless_conversion.rs
@@ -1,8 +1,8 @@
-use crate::utils::sugg::Sugg;
-use crate::utils::{get_parent_expr, match_def_path, match_trait_method, paths};
 use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg};
 use clippy_utils::source::{snippet, snippet_with_macro_callsite};
+use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::{get_parent_expr, match_def_path, match_trait_method, paths};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, HirId, MatchSource};
diff --git a/clippy_lints/src/utils/author.rs b/clippy_lints/src/utils/author.rs
index 3dd190ba440..2de5b1a628e 100644
--- a/clippy_lints/src/utils/author.rs
+++ b/clippy_lints/src/utils/author.rs
@@ -1,7 +1,7 @@
 //! A group of attributes that can be attached to Rust code in order
 //! to generate a clippy lint detecting said code automatically.
 
-use crate::utils::get_attr;
+use clippy_utils::get_attr;
 use rustc_ast::ast::{LitFloatType, LitKind};
 use rustc_ast::walk_list;
 use rustc_data_structures::fx::FxHashMap;
diff --git a/clippy_lints/src/utils/inspector.rs b/clippy_lints/src/utils/inspector.rs
index 9e3973e1d51..191ff6e4f16 100644
--- a/clippy_lints/src/utils/inspector.rs
+++ b/clippy_lints/src/utils/inspector.rs
@@ -1,6 +1,6 @@
 //! checks for attributes
 
-use crate::utils::get_attr;
+use clippy_utils::get_attr;
 use rustc_ast::ast::{Attribute, InlineAsmTemplatePiece};
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass, LintContext};
diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs
index a566362ae78..c496ff1fb24 100644
--- a/clippy_lints/src/utils/internal_lints.rs
+++ b/clippy_lints/src/utils/internal_lints.rs
@@ -1,9 +1,8 @@
 use crate::consts::{constant_simple, Constant};
-use crate::utils::{is_expn_of, match_def_path, match_qpath, method_calls, path_to_res, paths, run_lints, SpanlessEq};
-
 use clippy_utils::diagnostics::{span_lint, span_lint_and_help, span_lint_and_sugg};
 use clippy_utils::source::snippet;
 use clippy_utils::ty::match_type;
+use clippy_utils::{is_expn_of, match_def_path, match_qpath, method_calls, path_to_res, paths, run_lints, SpanlessEq};
 use if_chain::if_chain;
 use rustc_ast::ast::{Crate as AstCrate, ItemKind, LitKind, ModKind, NodeId};
 use rustc_ast::visit::FnKind;
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index be9a07f8d7c..d8b31344e6d 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -3,5 +3,3 @@ pub mod conf;
 pub mod inspector;
 #[cfg(feature = "internal-lints")]
 pub mod internal_lints;
-
-pub use clippy_utils::*;
diff --git a/clippy_lints/src/vec.rs b/clippy_lints/src/vec.rs
index 9e142413365..1af9583887f 100644
--- a/clippy_lints/src/vec.rs
+++ b/clippy_lints/src/vec.rs
@@ -1,7 +1,7 @@
 use crate::consts::{constant, Constant};
 use crate::rustc_target::abi::LayoutOf;
-use crate::utils::higher;
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::higher;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::is_copy;
 use if_chain::if_chain;
diff --git a/clippy_lints/src/vec_init_then_push.rs b/clippy_lints/src/vec_init_then_push.rs
index 3ef55a82a17..8b696ed1c84 100644
--- a/clippy_lints/src/vec_init_then_push.rs
+++ b/clippy_lints/src/vec_init_then_push.rs
@@ -1,7 +1,7 @@
-use crate::utils::{match_def_path, path_to_local, path_to_local_id, paths};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::{match_def_path, path_to_local, path_to_local_id, paths};
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/vec_resize_to_zero.rs b/clippy_lints/src/vec_resize_to_zero.rs
index 9a2fb1414a1..e035d3c5cad 100644
--- a/clippy_lints/src/vec_resize_to_zero.rs
+++ b/clippy_lints/src/vec_resize_to_zero.rs
@@ -1,15 +1,14 @@
 use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::{match_def_path, paths};
 use if_chain::if_chain;
+use rustc_ast::LitKind;
 use rustc_errors::Applicability;
+use rustc_hir as hir;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Spanned;
 
-use crate::utils::{match_def_path, paths};
-use rustc_ast::LitKind;
-use rustc_hir as hir;
-
 declare_clippy_lint! {
     /// **What it does:** Finds occurrences of `Vec::resize(0, an_int)`
     ///
diff --git a/clippy_lints/src/verbose_file_reads.rs b/clippy_lints/src/verbose_file_reads.rs
index 01dc54dc5fd..ec209b30951 100644
--- a/clippy_lints/src/verbose_file_reads.rs
+++ b/clippy_lints/src/verbose_file_reads.rs
@@ -1,5 +1,5 @@
-use crate::utils::paths;
 use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::paths;
 use clippy_utils::ty::match_type;
 use if_chain::if_chain;
 use rustc_hir::{Expr, ExprKind, QPath};
diff --git a/clippy_lints/src/wildcard_dependencies.rs b/clippy_lints/src/wildcard_dependencies.rs
index 8f96b962279..60c3489a449 100644
--- a/clippy_lints/src/wildcard_dependencies.rs
+++ b/clippy_lints/src/wildcard_dependencies.rs
@@ -1,5 +1,5 @@
-use crate::utils::run_lints;
 use clippy_utils::diagnostics::span_lint;
+use clippy_utils::run_lints;
 use rustc_hir::{hir_id::CRATE_HIR_ID, Crate};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
diff --git a/clippy_lints/src/wildcard_imports.rs b/clippy_lints/src/wildcard_imports.rs
index 424ca2a4c2f..51c1117d206 100644
--- a/clippy_lints/src/wildcard_imports.rs
+++ b/clippy_lints/src/wildcard_imports.rs
@@ -1,5 +1,5 @@
-use crate::utils::in_macro;
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::in_macro;
 use clippy_utils::source::{snippet, snippet_with_applicability};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/zero_sized_map_values.rs b/clippy_lints/src/zero_sized_map_values.rs
index 82466da6862..2abd033e2a0 100644
--- a/clippy_lints/src/zero_sized_map_values.rs
+++ b/clippy_lints/src/zero_sized_map_values.rs
@@ -1,4 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::paths;
 use clippy_utils::ty::{is_normalizable, is_type_diagnostic_item, match_type};
 use if_chain::if_chain;
 use rustc_hir::{self as hir, HirId, ItemKind, Node};
@@ -9,8 +10,6 @@ use rustc_span::sym;
 use rustc_target::abi::LayoutOf as _;
 use rustc_typeck::hir_ty_to_ty;
 
-use crate::utils::paths;
-
 declare_clippy_lint! {
     /// **What it does:** Checks for maps with zero-sized value types anywhere in the code.
     ///
-- 
cgit 1.4.1-3-g733a5


From 565400d1f990399726498b66e87d6866533d1b1d Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Wed, 17 Mar 2021 09:31:20 -0500
Subject: Add clippy_utils::paths imports

---
 clippy_lints/src/assign_ops.rs            |  4 ++--
 clippy_lints/src/manual_unwrap_or.rs      | 10 +++++-----
 clippy_lints/src/suspicious_trait_impl.rs |  4 ++--
 3 files changed, 9 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/assign_ops.rs b/clippy_lints/src/assign_ops.rs
index 5b8fb9b436a..bc6eec0051a 100644
--- a/clippy_lints/src/assign_ops.rs
+++ b/clippy_lints/src/assign_ops.rs
@@ -2,7 +2,7 @@ use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::implements_trait;
 use clippy_utils::{eq_expr_value, get_trait_def_id, trait_ref_of_method};
-use clippy_utils::{higher, sugg};
+use clippy_utils::{higher, paths, sugg};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
@@ -93,7 +93,7 @@ impl<'tcx> LateLintPass<'tcx> for AssignOps {
                              $($trait_name:ident),+) => {
                                 match $op {
                                     $(hir::BinOpKind::$trait_name => {
-                                        let [krate, module] = clippy_utils::paths::OPS_MODULE;
+                                        let [krate, module] = paths::OPS_MODULE;
                                         let path: [&str; 3] = [krate, module, concat!(stringify!($trait_name), "Assign")];
                                         let trait_id = if let Some(trait_id) = get_trait_def_id($cx, &path) {
                                             trait_id
diff --git a/clippy_lints/src/manual_unwrap_or.rs b/clippy_lints/src/manual_unwrap_or.rs
index 4f139f8d39a..f296d6a1a15 100644
--- a/clippy_lints/src/manual_unwrap_or.rs
+++ b/clippy_lints/src/manual_unwrap_or.rs
@@ -3,7 +3,7 @@ use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::{indent_of, reindent_multiline, snippet_opt};
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::usage::contains_return_break_continue_macro;
-use clippy_utils::{in_constant, match_qpath, path_to_local_id, sugg};
+use clippy_utils::{in_constant, match_qpath, path_to_local_id, paths, sugg};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Arm, Expr, ExprKind, Pat, PatKind};
@@ -75,16 +75,16 @@ fn lint_manual_unwrap_or<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
             if let Some((idx, or_arm)) = arms.iter().enumerate().find(|(_, arm)|
                 match arm.pat.kind {
                     PatKind::Path(ref some_qpath) =>
-                        match_qpath(some_qpath, &clippy_utils::paths::OPTION_NONE),
+                        match_qpath(some_qpath, &paths::OPTION_NONE),
                     PatKind::TupleStruct(ref err_qpath, &[Pat { kind: PatKind::Wild, .. }], _) =>
-                        match_qpath(err_qpath, &clippy_utils::paths::RESULT_ERR),
+                        match_qpath(err_qpath, &paths::RESULT_ERR),
                     _ => false,
                 }
             );
             let unwrap_arm = &arms[1 - idx];
             if let PatKind::TupleStruct(ref unwrap_qpath, &[unwrap_pat], _) = unwrap_arm.pat.kind;
-            if match_qpath(unwrap_qpath, &clippy_utils::paths::OPTION_SOME)
-                || match_qpath(unwrap_qpath, &clippy_utils::paths::RESULT_OK);
+            if match_qpath(unwrap_qpath, &paths::OPTION_SOME)
+                || match_qpath(unwrap_qpath, &paths::RESULT_OK);
             if let PatKind::Binding(_, binding_hir_id, ..) = unwrap_pat.kind;
             if path_to_local_id(unwrap_arm.body, binding_hir_id);
             if !contains_return_break_continue_macro(or_arm.body);
diff --git a/clippy_lints/src/suspicious_trait_impl.rs b/clippy_lints/src/suspicious_trait_impl.rs
index 0f024c9a11e..99e3d818b79 100644
--- a/clippy_lints/src/suspicious_trait_impl.rs
+++ b/clippy_lints/src/suspicious_trait_impl.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint;
-use clippy_utils::{get_trait_def_id, trait_ref_of_method};
+use clippy_utils::{get_trait_def_id, paths, trait_ref_of_method};
 use if_chain::if_chain;
 use rustc_hir as hir;
 use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
@@ -159,7 +159,7 @@ fn check_binop(
     expected_ops: &[hir::BinOpKind],
 ) -> Option<&'static str> {
     let mut trait_ids = vec![];
-    let [krate, module] = clippy_utils::paths::OPS_MODULE;
+    let [krate, module] = paths::OPS_MODULE;
 
     for &t in traits {
         let path = [krate, module, t];
-- 
cgit 1.4.1-3-g733a5


From 94fb2b58a30f46cd462bea088ea523ed8f4d9580 Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Sat, 13 Mar 2021 17:17:10 +0900
Subject: move chars_cmp and chars_next_cmp to its own modules

---
 clippy_lints/src/methods/chars_cmp.rs      | 54 +++++++++++++++++++++++++++
 clippy_lints/src/methods/chars_next_cmp.rs |  8 ++++
 clippy_lints/src/methods/mod.rs            | 59 +++---------------------------
 3 files changed, 68 insertions(+), 53 deletions(-)
 create mode 100644 clippy_lints/src/methods/chars_cmp.rs
 create mode 100644 clippy_lints/src/methods/chars_next_cmp.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/chars_cmp.rs b/clippy_lints/src/methods/chars_cmp.rs
new file mode 100644
index 00000000000..f9af06d200c
--- /dev/null
+++ b/clippy_lints/src/methods/chars_cmp.rs
@@ -0,0 +1,54 @@
+use crate::utils::{method_chain_args, single_segment_path};
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet_with_applicability;
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir as hir;
+use rustc_lint::LateContext;
+use rustc_lint::Lint;
+use rustc_middle::ty;
+use rustc_span::sym;
+
+/// Wrapper fn for `CHARS_NEXT_CMP` and `CHARS_LAST_CMP` lints.
+pub(super) fn check(
+    cx: &LateContext<'_>,
+    info: &crate::methods::BinaryExprInfo<'_>,
+    chain_methods: &[&str],
+    lint: &'static Lint,
+    suggest: &str,
+) -> bool {
+    if_chain! {
+        if let Some(args) = method_chain_args(info.chain, chain_methods);
+        if let hir::ExprKind::Call(ref fun, ref arg_char) = info.other.kind;
+        if arg_char.len() == 1;
+        if let hir::ExprKind::Path(ref qpath) = fun.kind;
+        if let Some(segment) = single_segment_path(qpath);
+        if segment.ident.name == sym::Some;
+        then {
+            let mut applicability = Applicability::MachineApplicable;
+            let self_ty = cx.typeck_results().expr_ty_adjusted(&args[0][0]).peel_refs();
+
+            if *self_ty.kind() != ty::Str {
+                return false;
+            }
+
+            span_lint_and_sugg(
+                cx,
+                lint,
+                info.expr.span,
+                &format!("you should use the `{}` method", suggest),
+                "like this",
+                format!("{}{}.{}({})",
+                        if info.eq { "" } else { "!" },
+                        snippet_with_applicability(cx, args[0][0].span, "..", &mut applicability),
+                        suggest,
+                        snippet_with_applicability(cx, arg_char[0].span, "..", &mut applicability)),
+                applicability,
+            );
+
+            return true;
+        }
+    }
+
+    false
+}
diff --git a/clippy_lints/src/methods/chars_next_cmp.rs b/clippy_lints/src/methods/chars_next_cmp.rs
new file mode 100644
index 00000000000..a6701d8830e
--- /dev/null
+++ b/clippy_lints/src/methods/chars_next_cmp.rs
@@ -0,0 +1,8 @@
+use rustc_lint::LateContext;
+
+use super::CHARS_NEXT_CMP;
+
+/// Checks for the `CHARS_NEXT_CMP` lint.
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, info: &crate::methods::BinaryExprInfo<'_>) -> bool {
+    crate::methods::chars_cmp::check(cx, info, &["chars", "next"], CHARS_NEXT_CMP, "starts_with")
+}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index cbfb350ebb1..d288c51907e 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1,5 +1,7 @@
 mod bind_instead_of_map;
 mod bytes_nth;
+mod chars_cmp;
+mod chars_next_cmp;
 mod clone_on_copy;
 mod clone_on_ref_ptr;
 mod expect_fun_call;
@@ -2024,7 +2026,7 @@ struct BinaryExprInfo<'a> {
 /// Checks for the `CHARS_NEXT_CMP` and `CHARS_LAST_CMP` lints.
 fn lint_binary_expr_with_method_call(cx: &LateContext<'_>, info: &mut BinaryExprInfo<'_>) {
     macro_rules! lint_with_both_lhs_and_rhs {
-        ($func:ident, $cx:expr, $info:ident) => {
+        ($func:expr, $cx:expr, $info:ident) => {
             if !$func($cx, $info) {
                 ::std::mem::swap(&mut $info.chain, &mut $info.other);
                 if $func($cx, $info) {
@@ -2034,67 +2036,18 @@ fn lint_binary_expr_with_method_call(cx: &LateContext<'_>, info: &mut BinaryExpr
         };
     }
 
-    lint_with_both_lhs_and_rhs!(lint_chars_next_cmp, cx, info);
+    lint_with_both_lhs_and_rhs!(chars_next_cmp::check, cx, info);
     lint_with_both_lhs_and_rhs!(lint_chars_last_cmp, cx, info);
     lint_with_both_lhs_and_rhs!(lint_chars_next_cmp_with_unwrap, cx, info);
     lint_with_both_lhs_and_rhs!(lint_chars_last_cmp_with_unwrap, cx, info);
 }
 
-/// Wrapper fn for `CHARS_NEXT_CMP` and `CHARS_LAST_CMP` lints.
-fn lint_chars_cmp(
-    cx: &LateContext<'_>,
-    info: &BinaryExprInfo<'_>,
-    chain_methods: &[&str],
-    lint: &'static Lint,
-    suggest: &str,
-) -> bool {
-    if_chain! {
-        if let Some(args) = method_chain_args(info.chain, chain_methods);
-        if let hir::ExprKind::Call(ref fun, ref arg_char) = info.other.kind;
-        if arg_char.len() == 1;
-        if let hir::ExprKind::Path(ref qpath) = fun.kind;
-        if let Some(segment) = single_segment_path(qpath);
-        if segment.ident.name == sym::Some;
-        then {
-            let mut applicability = Applicability::MachineApplicable;
-            let self_ty = cx.typeck_results().expr_ty_adjusted(&args[0][0]).peel_refs();
-
-            if *self_ty.kind() != ty::Str {
-                return false;
-            }
-
-            span_lint_and_sugg(
-                cx,
-                lint,
-                info.expr.span,
-                &format!("you should use the `{}` method", suggest),
-                "like this",
-                format!("{}{}.{}({})",
-                        if info.eq { "" } else { "!" },
-                        snippet_with_applicability(cx, args[0][0].span, "..", &mut applicability),
-                        suggest,
-                        snippet_with_applicability(cx, arg_char[0].span, "..", &mut applicability)),
-                applicability,
-            );
-
-            return true;
-        }
-    }
-
-    false
-}
-
-/// Checks for the `CHARS_NEXT_CMP` lint.
-fn lint_chars_next_cmp<'tcx>(cx: &LateContext<'tcx>, info: &BinaryExprInfo<'_>) -> bool {
-    lint_chars_cmp(cx, info, &["chars", "next"], CHARS_NEXT_CMP, "starts_with")
-}
-
 /// Checks for the `CHARS_LAST_CMP` lint.
 fn lint_chars_last_cmp<'tcx>(cx: &LateContext<'tcx>, info: &BinaryExprInfo<'_>) -> bool {
-    if lint_chars_cmp(cx, info, &["chars", "last"], CHARS_LAST_CMP, "ends_with") {
+    if chars_cmp::check(cx, info, &["chars", "last"], CHARS_LAST_CMP, "ends_with") {
         true
     } else {
-        lint_chars_cmp(cx, info, &["chars", "next_back"], CHARS_LAST_CMP, "ends_with")
+        chars_cmp::check(cx, info, &["chars", "next_back"], CHARS_LAST_CMP, "ends_with")
     }
 }
 
-- 
cgit 1.4.1-3-g733a5


From 058d8c878ab51ccd65e636456207b3d63ee532b5 Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Sat, 13 Mar 2021 17:28:22 +0900
Subject: move chars_cmp_with_unwrap, chars_last_cmp and
 chars_next_cmp_with_unwrap to their own modules

---
 clippy_lints/src/methods/chars_cmp_with_unwrap.rs  | 44 +++++++++++++++
 clippy_lints/src/methods/chars_last_cmp.rs         | 13 +++++
 .../src/methods/chars_next_cmp_with_unwrap.rs      |  8 +++
 clippy_lints/src/methods/mod.rs                    | 64 +++-------------------
 4 files changed, 74 insertions(+), 55 deletions(-)
 create mode 100644 clippy_lints/src/methods/chars_cmp_with_unwrap.rs
 create mode 100644 clippy_lints/src/methods/chars_last_cmp.rs
 create mode 100644 clippy_lints/src/methods/chars_next_cmp_with_unwrap.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/chars_cmp_with_unwrap.rs b/clippy_lints/src/methods/chars_cmp_with_unwrap.rs
new file mode 100644
index 00000000000..3ba59171f77
--- /dev/null
+++ b/clippy_lints/src/methods/chars_cmp_with_unwrap.rs
@@ -0,0 +1,44 @@
+use crate::utils::method_chain_args;
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet_with_applicability;
+use if_chain::if_chain;
+use rustc_ast::ast;
+use rustc_errors::Applicability;
+use rustc_hir as hir;
+use rustc_lint::LateContext;
+use rustc_lint::Lint;
+
+/// Wrapper fn for `CHARS_NEXT_CMP` and `CHARS_LAST_CMP` lints with `unwrap()`.
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    info: &crate::methods::BinaryExprInfo<'_>,
+    chain_methods: &[&str],
+    lint: &'static Lint,
+    suggest: &str,
+) -> bool {
+    if_chain! {
+        if let Some(args) = method_chain_args(info.chain, chain_methods);
+        if let hir::ExprKind::Lit(ref lit) = info.other.kind;
+        if let ast::LitKind::Char(c) = lit.node;
+        then {
+            let mut applicability = Applicability::MachineApplicable;
+            span_lint_and_sugg(
+                cx,
+                lint,
+                info.expr.span,
+                &format!("you should use the `{}` method", suggest),
+                "like this",
+                format!("{}{}.{}('{}')",
+                        if info.eq { "" } else { "!" },
+                        snippet_with_applicability(cx, args[0][0].span, "..", &mut applicability),
+                        suggest,
+                        c),
+                applicability,
+            );
+
+            true
+        } else {
+            false
+        }
+    }
+}
diff --git a/clippy_lints/src/methods/chars_last_cmp.rs b/clippy_lints/src/methods/chars_last_cmp.rs
new file mode 100644
index 00000000000..07bbc5ca1bf
--- /dev/null
+++ b/clippy_lints/src/methods/chars_last_cmp.rs
@@ -0,0 +1,13 @@
+use crate::methods::chars_cmp;
+use rustc_lint::LateContext;
+
+use super::CHARS_LAST_CMP;
+
+/// Checks for the `CHARS_LAST_CMP` lint.
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, info: &crate::methods::BinaryExprInfo<'_>) -> bool {
+    if chars_cmp::check(cx, info, &["chars", "last"], CHARS_LAST_CMP, "ends_with") {
+        true
+    } else {
+        chars_cmp::check(cx, info, &["chars", "next_back"], CHARS_LAST_CMP, "ends_with")
+    }
+}
diff --git a/clippy_lints/src/methods/chars_next_cmp_with_unwrap.rs b/clippy_lints/src/methods/chars_next_cmp_with_unwrap.rs
new file mode 100644
index 00000000000..28ede28e935
--- /dev/null
+++ b/clippy_lints/src/methods/chars_next_cmp_with_unwrap.rs
@@ -0,0 +1,8 @@
+use rustc_lint::LateContext;
+
+use super::CHARS_NEXT_CMP;
+
+/// Checks for the `CHARS_NEXT_CMP` lint with `unwrap()`.
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, info: &crate::methods::BinaryExprInfo<'_>) -> bool {
+    crate::methods::chars_cmp_with_unwrap::check(cx, info, &["chars", "next", "unwrap"], CHARS_NEXT_CMP, "starts_with")
+}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index d288c51907e..b4c32e45da9 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1,7 +1,10 @@
 mod bind_instead_of_map;
 mod bytes_nth;
 mod chars_cmp;
+mod chars_cmp_with_unwrap;
+mod chars_last_cmp;
 mod chars_next_cmp;
+mod chars_next_cmp_with_unwrap;
 mod clone_on_copy;
 mod clone_on_ref_ptr;
 mod expect_fun_call;
@@ -54,7 +57,7 @@ mod wrong_self_convention;
 mod zst_offset;
 
 use bind_instead_of_map::BindInsteadOfMap;
-use clippy_utils::diagnostics::{span_lint, span_lint_and_help, span_lint_and_sugg};
+use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::{contains_ty, implements_trait, is_copy, is_type_diagnostic_item};
 use clippy_utils::{
@@ -66,7 +69,7 @@ use rustc_ast::ast;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_hir::{TraitItem, TraitItemKind};
-use rustc_lint::{LateContext, LateLintPass, Lint, LintContext};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::{self, TraitRef, Ty, TyS};
 use rustc_semver::RustcVersion;
@@ -2037,66 +2040,17 @@ fn lint_binary_expr_with_method_call(cx: &LateContext<'_>, info: &mut BinaryExpr
     }
 
     lint_with_both_lhs_and_rhs!(chars_next_cmp::check, cx, info);
-    lint_with_both_lhs_and_rhs!(lint_chars_last_cmp, cx, info);
-    lint_with_both_lhs_and_rhs!(lint_chars_next_cmp_with_unwrap, cx, info);
+    lint_with_both_lhs_and_rhs!(chars_last_cmp::check, cx, info);
+    lint_with_both_lhs_and_rhs!(chars_next_cmp_with_unwrap::check, cx, info);
     lint_with_both_lhs_and_rhs!(lint_chars_last_cmp_with_unwrap, cx, info);
 }
 
-/// Checks for the `CHARS_LAST_CMP` lint.
-fn lint_chars_last_cmp<'tcx>(cx: &LateContext<'tcx>, info: &BinaryExprInfo<'_>) -> bool {
-    if chars_cmp::check(cx, info, &["chars", "last"], CHARS_LAST_CMP, "ends_with") {
-        true
-    } else {
-        chars_cmp::check(cx, info, &["chars", "next_back"], CHARS_LAST_CMP, "ends_with")
-    }
-}
-
-/// Wrapper fn for `CHARS_NEXT_CMP` and `CHARS_LAST_CMP` lints with `unwrap()`.
-fn lint_chars_cmp_with_unwrap<'tcx>(
-    cx: &LateContext<'tcx>,
-    info: &BinaryExprInfo<'_>,
-    chain_methods: &[&str],
-    lint: &'static Lint,
-    suggest: &str,
-) -> bool {
-    if_chain! {
-        if let Some(args) = method_chain_args(info.chain, chain_methods);
-        if let hir::ExprKind::Lit(ref lit) = info.other.kind;
-        if let ast::LitKind::Char(c) = lit.node;
-        then {
-            let mut applicability = Applicability::MachineApplicable;
-            span_lint_and_sugg(
-                cx,
-                lint,
-                info.expr.span,
-                &format!("you should use the `{}` method", suggest),
-                "like this",
-                format!("{}{}.{}('{}')",
-                        if info.eq { "" } else { "!" },
-                        snippet_with_applicability(cx, args[0][0].span, "..", &mut applicability),
-                        suggest,
-                        c),
-                applicability,
-            );
-
-            true
-        } else {
-            false
-        }
-    }
-}
-
-/// Checks for the `CHARS_NEXT_CMP` lint with `unwrap()`.
-fn lint_chars_next_cmp_with_unwrap<'tcx>(cx: &LateContext<'tcx>, info: &BinaryExprInfo<'_>) -> bool {
-    lint_chars_cmp_with_unwrap(cx, info, &["chars", "next", "unwrap"], CHARS_NEXT_CMP, "starts_with")
-}
-
 /// Checks for the `CHARS_LAST_CMP` lint with `unwrap()`.
 fn lint_chars_last_cmp_with_unwrap<'tcx>(cx: &LateContext<'tcx>, info: &BinaryExprInfo<'_>) -> bool {
-    if lint_chars_cmp_with_unwrap(cx, info, &["chars", "last", "unwrap"], CHARS_LAST_CMP, "ends_with") {
+    if chars_cmp_with_unwrap::check(cx, info, &["chars", "last", "unwrap"], CHARS_LAST_CMP, "ends_with") {
         true
     } else {
-        lint_chars_cmp_with_unwrap(cx, info, &["chars", "next_back", "unwrap"], CHARS_LAST_CMP, "ends_with")
+        chars_cmp_with_unwrap::check(cx, info, &["chars", "next_back", "unwrap"], CHARS_LAST_CMP, "ends_with")
     }
 }
 
-- 
cgit 1.4.1-3-g733a5


From c07c046b317bf9a75b04e97c37396436351d80ab Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Sat, 13 Mar 2021 17:36:04 +0900
Subject: refactor string_extend_chars: return when obj type is not string

---
 clippy_lints/src/methods/string_extend_chars.rs | 57 +++++++++++++------------
 1 file changed, 29 insertions(+), 28 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/string_extend_chars.rs b/clippy_lints/src/methods/string_extend_chars.rs
index 52b26a36fe3..5c688ac5621 100644
--- a/clippy_lints/src/methods/string_extend_chars.rs
+++ b/clippy_lints/src/methods/string_extend_chars.rs
@@ -12,34 +12,35 @@ use super::STRING_EXTEND_CHARS;
 
 pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::Expr<'_>]) {
     let obj_ty = cx.typeck_results().expr_ty(&args[0]).peel_refs();
-    if is_type_diagnostic_item(cx, obj_ty, sym::string_type) {
-        let arg = &args[1];
-        if let Some(arglists) = method_chain_args(arg, &["chars"]) {
-            let target = &arglists[0][0];
-            let self_ty = cx.typeck_results().expr_ty(target).peel_refs();
-            let ref_str = if *self_ty.kind() == ty::Str {
-                ""
-            } else if is_type_diagnostic_item(cx, self_ty, sym::string_type) {
-                "&"
-            } else {
-                return;
-            };
+    if !is_type_diagnostic_item(cx, obj_ty, sym::string_type) {
+        return;
+    }
+    let arg = &args[1];
+    if let Some(arglists) = method_chain_args(arg, &["chars"]) {
+        let target = &arglists[0][0];
+        let self_ty = cx.typeck_results().expr_ty(target).peel_refs();
+        let ref_str = if *self_ty.kind() == ty::Str {
+            ""
+        } else if is_type_diagnostic_item(cx, self_ty, sym::string_type) {
+            "&"
+        } else {
+            return;
+        };
 
-            let mut applicability = Applicability::MachineApplicable;
-            span_lint_and_sugg(
-                cx,
-                STRING_EXTEND_CHARS,
-                expr.span,
-                "calling `.extend(_.chars())`",
-                "try this",
-                format!(
-                    "{}.push_str({}{})",
-                    snippet_with_applicability(cx, args[0].span, "..", &mut applicability),
-                    ref_str,
-                    snippet_with_applicability(cx, target.span, "..", &mut applicability)
-                ),
-                applicability,
-            );
-        }
+        let mut applicability = Applicability::MachineApplicable;
+        span_lint_and_sugg(
+            cx,
+            STRING_EXTEND_CHARS,
+            expr.span,
+            "calling `.extend(_.chars())`",
+            "try this",
+            format!(
+                "{}.push_str({}{})",
+                snippet_with_applicability(cx, args[0].span, "..", &mut applicability),
+                ref_str,
+                snippet_with_applicability(cx, target.span, "..", &mut applicability)
+            ),
+            applicability,
+        );
     }
 }
-- 
cgit 1.4.1-3-g733a5


From e578a536c703cd799b74f261e345121bd889be45 Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Sat, 13 Mar 2021 18:13:31 +0900
Subject: move derefs_to_slice to methods/utils.rs

---
 clippy_lints/src/methods/utils.rs | 46 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 46 insertions(+)
 create mode 100644 clippy_lints/src/methods/utils.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/utils.rs b/clippy_lints/src/methods/utils.rs
new file mode 100644
index 00000000000..3596aaa089b
--- /dev/null
+++ b/clippy_lints/src/methods/utils.rs
@@ -0,0 +1,46 @@
+use crate::utils::is_type_diagnostic_item;
+use rustc_hir as hir;
+use rustc_lint::LateContext;
+use rustc_middle::ty;
+use rustc_middle::ty::Ty;
+use rustc_span::symbol::sym;
+
+pub fn derefs_to_slice<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx hir::Expr<'tcx>,
+    ty: Ty<'tcx>,
+) -> Option<&'tcx hir::Expr<'tcx>> {
+    fn may_slice<'a>(cx: &LateContext<'a>, ty: Ty<'a>) -> bool {
+        match ty.kind() {
+            ty::Slice(_) => true,
+            ty::Adt(def, _) if def.is_box() => may_slice(cx, ty.boxed_ty()),
+            ty::Adt(..) => is_type_diagnostic_item(cx, ty, sym::vec_type),
+            ty::Array(_, size) => size
+                .try_eval_usize(cx.tcx, cx.param_env)
+                .map_or(false, |size| size < 32),
+            ty::Ref(_, inner, _) => may_slice(cx, inner),
+            _ => false,
+        }
+    }
+
+    if let hir::ExprKind::MethodCall(ref path, _, ref args, _) = expr.kind {
+        if path.ident.name == sym::iter && may_slice(cx, cx.typeck_results().expr_ty(&args[0])) {
+            Some(&args[0])
+        } else {
+            None
+        }
+    } else {
+        match ty.kind() {
+            ty::Slice(_) => Some(expr),
+            ty::Adt(def, _) if def.is_box() && may_slice(cx, ty.boxed_ty()) => Some(expr),
+            ty::Ref(_, inner, _) => {
+                if may_slice(cx, inner) {
+                    Some(expr)
+                } else {
+                    None
+                }
+            },
+            _ => None,
+        }
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 1bec8b606540813cc068c5b564aa2dbd3d212823 Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Sat, 13 Mar 2021 18:16:38 +0900
Subject: use derefs_to_slice in methods/utils.rs

---
 clippy_lints/src/methods/get_unwrap.rs          |  2 +-
 clippy_lints/src/methods/iter_cloned_collect.rs |  2 +-
 clippy_lints/src/methods/iter_count.rs          |  2 +-
 clippy_lints/src/methods/iter_next_slice.rs     |  2 +-
 clippy_lints/src/methods/iter_nth.rs            |  2 +-
 clippy_lints/src/methods/mod.rs                 | 42 +------------------------
 6 files changed, 6 insertions(+), 46 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/get_unwrap.rs b/clippy_lints/src/methods/get_unwrap.rs
index b122a0a0b89..b3a9743c614 100644
--- a/clippy_lints/src/methods/get_unwrap.rs
+++ b/clippy_lints/src/methods/get_unwrap.rs
@@ -1,4 +1,4 @@
-use crate::methods::derefs_to_slice;
+use super::utils::derefs_to_slice;
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::{is_type_diagnostic_item, match_type};
diff --git a/clippy_lints/src/methods/iter_cloned_collect.rs b/clippy_lints/src/methods/iter_cloned_collect.rs
index cd575c9cb02..848f47e39f6 100644
--- a/clippy_lints/src/methods/iter_cloned_collect.rs
+++ b/clippy_lints/src/methods/iter_cloned_collect.rs
@@ -1,4 +1,4 @@
-use crate::methods::derefs_to_slice;
+use crate::methods::utils::derefs_to_slice;
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
diff --git a/clippy_lints/src/methods/iter_count.rs b/clippy_lints/src/methods/iter_count.rs
index fd3d53816a1..e394a8fe819 100644
--- a/clippy_lints/src/methods/iter_count.rs
+++ b/clippy_lints/src/methods/iter_count.rs
@@ -1,4 +1,4 @@
-use crate::methods::derefs_to_slice;
+use super::utils::derefs_to_slice;
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::paths;
 use clippy_utils::source::snippet_with_applicability;
diff --git a/clippy_lints/src/methods/iter_next_slice.rs b/clippy_lints/src/methods/iter_next_slice.rs
index feebf8b8209..869b2cdd1a6 100644
--- a/clippy_lints/src/methods/iter_next_slice.rs
+++ b/clippy_lints/src/methods/iter_next_slice.rs
@@ -1,4 +1,4 @@
-use crate::methods::derefs_to_slice;
+use crate::methods::utils::derefs_to_slice;
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::is_type_diagnostic_item;
diff --git a/clippy_lints/src/methods/iter_nth.rs b/clippy_lints/src/methods/iter_nth.rs
index 2619793e1e2..2e7220025f8 100644
--- a/clippy_lints/src/methods/iter_nth.rs
+++ b/clippy_lints/src/methods/iter_nth.rs
@@ -1,7 +1,7 @@
-use crate::methods::derefs_to_slice;
 use crate::methods::iter_nth_zero;
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::ty::is_type_diagnostic_item;
+use crate::methods::utils::derefs_to_slice;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
 use rustc_span::symbol::sym;
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index b4c32e45da9..e16ab4bc20b 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -53,6 +53,7 @@ mod unnecessary_fold;
 mod unnecessary_lazy_eval;
 mod unwrap_used;
 mod useless_asref;
+mod utils;
 mod wrong_self_convention;
 mod zst_offset;
 
@@ -1976,47 +1977,6 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
 
     extract_msrv_attr!(LateContext);
 }
-
-fn derefs_to_slice<'tcx>(
-    cx: &LateContext<'tcx>,
-    expr: &'tcx hir::Expr<'tcx>,
-    ty: Ty<'tcx>,
-) -> Option<&'tcx hir::Expr<'tcx>> {
-    fn may_slice<'a>(cx: &LateContext<'a>, ty: Ty<'a>) -> bool {
-        match ty.kind() {
-            ty::Slice(_) => true,
-            ty::Adt(def, _) if def.is_box() => may_slice(cx, ty.boxed_ty()),
-            ty::Adt(..) => is_type_diagnostic_item(cx, ty, sym::vec_type),
-            ty::Array(_, size) => size
-                .try_eval_usize(cx.tcx, cx.param_env)
-                .map_or(false, |size| size < 32),
-            ty::Ref(_, inner, _) => may_slice(cx, inner),
-            _ => false,
-        }
-    }
-
-    if let hir::ExprKind::MethodCall(ref path, _, ref args, _) = expr.kind {
-        if path.ident.name == sym::iter && may_slice(cx, cx.typeck_results().expr_ty(&args[0])) {
-            Some(&args[0])
-        } else {
-            None
-        }
-    } else {
-        match ty.kind() {
-            ty::Slice(_) => Some(expr),
-            ty::Adt(def, _) if def.is_box() && may_slice(cx, ty.boxed_ty()) => Some(expr),
-            ty::Ref(_, inner, _) => {
-                if may_slice(cx, inner) {
-                    Some(expr)
-                } else {
-                    None
-                }
-            },
-            _ => None,
-        }
-    }
-}
-
 /// Used for `lint_binary_expr_with_method_call`.
 #[derive(Copy, Clone)]
 struct BinaryExprInfo<'a> {
-- 
cgit 1.4.1-3-g733a5


From f0a101d81dc25fae998d0670348d928f1789439b Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Sun, 14 Mar 2021 01:05:37 +0900
Subject: remove a needless variable

---
 clippy_lints/src/methods/iter_skip_next.rs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/iter_skip_next.rs b/clippy_lints/src/methods/iter_skip_next.rs
index ea01860b456..b1d398876d3 100644
--- a/clippy_lints/src/methods/iter_skip_next.rs
+++ b/clippy_lints/src/methods/iter_skip_next.rs
@@ -12,14 +12,13 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, skip_args: &[hir
     // lint if caller of skip is an Iterator
     if is_trait_method(cx, expr, sym::Iterator) {
         if let [caller, n] = skip_args {
-            let hint = format!(".nth({})", snippet(cx, n.span, ".."));
             span_lint_and_sugg(
                 cx,
                 ITER_SKIP_NEXT,
                 expr.span.trim_start(caller.span).unwrap(),
                 "called `skip(..).next()` on an iterator",
                 "use `nth` instead",
-                hint,
+                format!(".nth({})", snippet(cx, n.span, "..")),
                 Applicability::MachineApplicable,
             );
         }
-- 
cgit 1.4.1-3-g733a5


From 0c81311bf0093e991c0b5ca8b69096a5c5cd161c Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Sun, 14 Mar 2021 01:18:04 +0900
Subject: extract a condition into a function.

---
 clippy_lints/src/methods/iter_next_slice.rs | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/iter_next_slice.rs b/clippy_lints/src/methods/iter_next_slice.rs
index 869b2cdd1a6..2155159bf7c 100644
--- a/clippy_lints/src/methods/iter_next_slice.rs
+++ b/clippy_lints/src/methods/iter_next_slice.rs
@@ -47,12 +47,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, ite
                 );
             }
         }
-    } else if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(caller_expr), sym::vec_type)
-        || matches!(
-            &cx.typeck_results().expr_ty(caller_expr).peel_refs().kind(),
-            ty::Array(_, _)
-        )
-    {
+    } else if is_vec_or_array(cx, caller_expr) {
         // caller is a Vec or an Array
         let mut applicability = Applicability::MachineApplicable;
         span_lint_and_sugg(
@@ -69,3 +64,8 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, ite
         );
     }
 }
+
+fn is_vec_or_array<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) -> bool {
+    is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(expr), sym::vec_type)
+        || matches!(&cx.typeck_results().expr_ty(expr).peel_refs().kind(), ty::Array(_, _))
+}
-- 
cgit 1.4.1-3-g733a5


From b6597eec0b3fcd9598fd4f90daa2d4d781e0aabc Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Sun, 14 Mar 2021 01:37:33 +0900
Subject: remove unused arguments

---
 clippy_lints/src/methods/filter_flat_map.rs     | 7 +------
 clippy_lints/src/methods/filter_map_flat_map.rs | 7 +------
 clippy_lints/src/methods/filter_map_map.rs      | 7 +------
 clippy_lints/src/methods/mod.rs                 | 6 +++---
 4 files changed, 6 insertions(+), 21 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/filter_flat_map.rs b/clippy_lints/src/methods/filter_flat_map.rs
index 2f3a3c55ab5..1588eec8882 100644
--- a/clippy_lints/src/methods/filter_flat_map.rs
+++ b/clippy_lints/src/methods/filter_flat_map.rs
@@ -7,12 +7,7 @@ use rustc_span::sym;
 use super::FILTER_MAP;
 
 /// lint use of `filter().flat_map()` for `Iterators`
-pub(super) fn check<'tcx>(
-    cx: &LateContext<'tcx>,
-    expr: &'tcx hir::Expr<'_>,
-    _filter_args: &'tcx [hir::Expr<'_>],
-    _map_args: &'tcx [hir::Expr<'_>],
-) {
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
     // lint if caller of `.filter().flat_map()` is an Iterator
     if is_trait_method(cx, expr, sym::Iterator) {
         let msg = "called `filter(..).flat_map(..)` on an `Iterator`";
diff --git a/clippy_lints/src/methods/filter_map_flat_map.rs b/clippy_lints/src/methods/filter_map_flat_map.rs
index b1a4dc98eb8..741b1e7e361 100644
--- a/clippy_lints/src/methods/filter_map_flat_map.rs
+++ b/clippy_lints/src/methods/filter_map_flat_map.rs
@@ -7,12 +7,7 @@ use rustc_span::sym;
 use super::FILTER_MAP;
 
 /// lint use of `filter_map().flat_map()` for `Iterators`
-pub(super) fn check<'tcx>(
-    cx: &LateContext<'tcx>,
-    expr: &'tcx hir::Expr<'_>,
-    _filter_args: &'tcx [hir::Expr<'_>],
-    _map_args: &'tcx [hir::Expr<'_>],
-) {
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
     // lint if caller of `.filter_map().flat_map()` is an Iterator
     if is_trait_method(cx, expr, sym::Iterator) {
         let msg = "called `filter_map(..).flat_map(..)` on an `Iterator`";
diff --git a/clippy_lints/src/methods/filter_map_map.rs b/clippy_lints/src/methods/filter_map_map.rs
index 0b0a8b1dd3b..713bbf25837 100644
--- a/clippy_lints/src/methods/filter_map_map.rs
+++ b/clippy_lints/src/methods/filter_map_map.rs
@@ -7,12 +7,7 @@ use rustc_span::sym;
 use super::FILTER_MAP;
 
 /// lint use of `filter_map().map()` for `Iterators`
-pub(super) fn check<'tcx>(
-    cx: &LateContext<'tcx>,
-    expr: &'tcx hir::Expr<'_>,
-    _filter_args: &'tcx [hir::Expr<'_>],
-    _map_args: &'tcx [hir::Expr<'_>],
-) {
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
     // lint if caller of `.filter_map().map()` is an Iterator
     if is_trait_method(cx, expr, sym::Iterator) {
         let msg = "called `filter_map(..).map(..)` on an `Iterator`";
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index e16ab4bc20b..044348a2c34 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1715,11 +1715,11 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             ["next", "skip_while"] => skip_while_next::check(cx, expr, arg_lists[1]),
             ["next", "iter"] => iter_next_slice::check(cx, expr, arg_lists[1]),
             ["map", "filter"] => filter_map::check(cx, expr, false),
-            ["map", "filter_map"] => filter_map_map::check(cx, expr, arg_lists[1], arg_lists[0]),
+            ["map", "filter_map"] => filter_map_map::check(cx, expr),
             ["next", "filter_map"] => filter_map_next::check(cx, expr, arg_lists[1], self.msrv.as_ref()),
             ["map", "find"] => filter_map::check(cx, expr, true),
-            ["flat_map", "filter"] => filter_flat_map::check(cx, expr, arg_lists[1], arg_lists[0]),
-            ["flat_map", "filter_map"] => filter_map_flat_map::check(cx, expr, arg_lists[1], arg_lists[0]),
+            ["flat_map", "filter"] => filter_flat_map::check(cx, expr),
+            ["flat_map", "filter_map"] => filter_map_flat_map::check(cx, expr),
             ["flat_map", ..] => flat_map_identity::check(cx, expr, arg_lists[0], method_spans[0]),
             ["flatten", "map"] => map_flatten::check(cx, expr, arg_lists[1]),
             ["is_some", "find"] => search_is_some::check(cx, expr, "find", arg_lists[1], arg_lists[0], method_spans[1]),
-- 
cgit 1.4.1-3-g733a5


From f0f787192006a7b0a508b90a03dcfdd37b3c31d2 Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Wed, 17 Mar 2021 11:15:25 +0900
Subject: fmt

---
 clippy_lints/src/methods/iter_nth.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/iter_nth.rs b/clippy_lints/src/methods/iter_nth.rs
index 2e7220025f8..bf1575660d1 100644
--- a/clippy_lints/src/methods/iter_nth.rs
+++ b/clippy_lints/src/methods/iter_nth.rs
@@ -1,7 +1,7 @@
 use crate::methods::iter_nth_zero;
+use crate::methods::utils::derefs_to_slice;
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::ty::is_type_diagnostic_item;
-use crate::methods::utils::derefs_to_slice;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
 use rustc_span::symbol::sym;
-- 
cgit 1.4.1-3-g733a5


From 48430849465ae94255e78f895197b09c2ce3b03e Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Wed, 17 Mar 2021 11:18:02 +0900
Subject: use clippy_utils::ty::is_type_diagnostic_item

---
 clippy_lints/src/methods/utils.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/utils.rs b/clippy_lints/src/methods/utils.rs
index 3596aaa089b..4d801148cbc 100644
--- a/clippy_lints/src/methods/utils.rs
+++ b/clippy_lints/src/methods/utils.rs
@@ -1,4 +1,4 @@
-use crate::utils::is_type_diagnostic_item;
+use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
 use rustc_middle::ty;
-- 
cgit 1.4.1-3-g733a5


From 3d9b45df0fa6bc04d864aa4a67fdb631b9bf0a99 Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Wed, 17 Mar 2021 12:33:09 +0900
Subject: move single_char_add_str to its own module

---
 clippy_lints/src/methods/single_char_add_str.rs | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 clippy_lints/src/methods/single_char_add_str.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/single_char_add_str.rs b/clippy_lints/src/methods/single_char_add_str.rs
new file mode 100644
index 00000000000..3df88e5b69c
--- /dev/null
+++ b/clippy_lints/src/methods/single_char_add_str.rs
@@ -0,0 +1,15 @@
+use crate::methods::{single_char_insert_string, single_char_push_string};
+use crate::utils::match_def_path;
+use crate::utils::paths;
+use rustc_hir as hir;
+use rustc_lint::LateContext;
+
+pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::Expr<'_>]) {
+    if let Some(fn_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id) {
+        if match_def_path(cx, fn_def_id, &paths::PUSH_STR) {
+            single_char_push_string::check(cx, expr, args);
+        } else if match_def_path(cx, fn_def_id, &paths::INSERT_STR) {
+            single_char_insert_string::check(cx, expr, args);
+        }
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 62490c41af1a5dab806e45dd2bc0b8d56a3c3c23 Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Wed, 17 Mar 2021 12:34:37 +0900
Subject: extract conditions into modules

---
 clippy_lints/src/methods/clone_on_copy.rs         | 10 ++++++++--
 clippy_lints/src/methods/clone_on_ref_ptr.rs      |  8 ++++++--
 clippy_lints/src/methods/inefficient_to_string.rs | 11 +++++++----
 clippy_lints/src/methods/mod.rs                   | 20 +++++---------------
 4 files changed, 26 insertions(+), 23 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/clone_on_copy.rs b/clippy_lints/src/methods/clone_on_copy.rs
index 949152cf789..edb6649b87b 100644
--- a/clippy_lints/src/methods/clone_on_copy.rs
+++ b/clippy_lints/src/methods/clone_on_copy.rs
@@ -4,14 +4,20 @@ use clippy_utils::ty::is_copy;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
-use rustc_middle::ty::{self, Ty};
+use rustc_middle::ty;
+use rustc_span::symbol::{sym, Symbol};
 use std::iter;
 
 use super::CLONE_DOUBLE_REF;
 use super::CLONE_ON_COPY;
 
 /// Checks for the `CLONE_ON_COPY` lint.
-pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, arg: &hir::Expr<'_>, arg_ty: Ty<'_>) {
+pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, method_name: Symbol, args: &[hir::Expr<'_>]) {
+    if !(args.len() == 1 && method_name == sym::clone) {
+        return;
+    }
+    let arg = &args[0];
+    let arg_ty = cx.typeck_results().expr_ty_adjusted(&args[0]);
     let ty = cx.typeck_results().expr_ty(expr);
     if let ty::Ref(_, inner, _) = arg_ty.kind() {
         if let ty::Ref(_, innermost, _) = inner.kind() {
diff --git a/clippy_lints/src/methods/clone_on_ref_ptr.rs b/clippy_lints/src/methods/clone_on_ref_ptr.rs
index 03c949d5c31..6417bc81304 100644
--- a/clippy_lints/src/methods/clone_on_ref_ptr.rs
+++ b/clippy_lints/src/methods/clone_on_ref_ptr.rs
@@ -6,11 +6,15 @@ use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
 use rustc_middle::ty;
-use rustc_span::symbol::sym;
+use rustc_span::symbol::{sym, Symbol};
 
 use super::CLONE_ON_REF_PTR;
 
-pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, arg: &hir::Expr<'_>) {
+pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, method_name: Symbol, args: &[hir::Expr<'_>]) {
+    if !(args.len() == 1 && method_name == sym::clone) {
+        return;
+    }
+    let arg = &args[0];
     let obj_ty = cx.typeck_results().expr_ty(arg).peel_refs();
 
     if let ty::Adt(_, subst) = obj_ty.kind() {
diff --git a/clippy_lints/src/methods/inefficient_to_string.rs b/clippy_lints/src/methods/inefficient_to_string.rs
index d10a540c24e..950ec62c9fe 100644
--- a/clippy_lints/src/methods/inefficient_to_string.rs
+++ b/clippy_lints/src/methods/inefficient_to_string.rs
@@ -1,4 +1,3 @@
-use super::INEFFICIENT_TO_STRING;
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::{is_type_diagnostic_item, walk_ptrs_ty_depth};
@@ -8,14 +7,18 @@ use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
 use rustc_middle::ty::{self, Ty};
-use rustc_span::sym;
+use rustc_span::symbol::{sym, Symbol};
+
+use super::INEFFICIENT_TO_STRING;
 
 /// Checks for the `INEFFICIENT_TO_STRING` lint
-pub fn check<'tcx>(cx: &LateContext<'tcx>, expr: &hir::Expr<'_>, arg: &hir::Expr<'_>, arg_ty: Ty<'tcx>) {
+pub fn check<'tcx>(cx: &LateContext<'tcx>, expr: &hir::Expr<'_>, method_name: Symbol, args: &[hir::Expr<'_>]) {
     if_chain! {
+        if args.len() == 1 && method_name == sym!(to_string);
         if let Some(to_string_meth_did) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
         if match_def_path(cx, to_string_meth_did, &paths::TO_STRING_METHOD);
         if let Some(substs) = cx.typeck_results().node_substs_opt(expr.hir_id);
+        let arg_ty = cx.typeck_results().expr_ty_adjusted(&args[0]);
         let self_ty = substs.type_at(0);
         let (deref_self_ty, deref_count) = walk_ptrs_ty_depth(self_ty);
         if deref_count >= 1;
@@ -32,7 +35,7 @@ pub fn check<'tcx>(cx: &LateContext<'tcx>, expr: &hir::Expr<'_>, arg: &hir::Expr
                         self_ty, deref_self_ty
                     ));
                     let mut applicability = Applicability::MachineApplicable;
-                    let arg_snippet = snippet_with_applicability(cx, arg.span, "..", &mut applicability);
+                    let arg_snippet = snippet_with_applicability(cx, args[0].span, "..", &mut applicability);
                     diag.span_suggestion(
                         expr.span,
                         "try dereferencing the receiver",
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 044348a2c34..bbf7f1d312b 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -41,6 +41,7 @@ mod option_map_or_none;
 mod option_map_unwrap_or;
 mod or_fun_call;
 mod search_is_some;
+mod single_char_add_str;
 mod single_char_insert_string;
 mod single_char_pattern;
 mod single_char_push_string;
@@ -1785,23 +1786,12 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             hir::ExprKind::MethodCall(ref method_call, ref method_span, ref args, _) => {
                 or_fun_call::check(cx, expr, *method_span, &method_call.ident.as_str(), args);
                 expect_fun_call::check(cx, expr, *method_span, &method_call.ident.as_str(), args);
+                clone_on_copy::check(cx, expr, method_call.ident.name, args);
+                clone_on_ref_ptr::check(cx, expr, method_call.ident.name, args);
 
                 let self_ty = cx.typeck_results().expr_ty_adjusted(&args[0]);
-                if args.len() == 1 && method_call.ident.name == sym::clone {
-                    clone_on_copy::check(cx, expr, &args[0], self_ty);
-                    clone_on_ref_ptr::check(cx, expr, &args[0]);
-                }
-                if args.len() == 1 && method_call.ident.name == sym!(to_string) {
-                    inefficient_to_string::check(cx, expr, &args[0], self_ty);
-                }
-
-                if let Some(fn_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id) {
-                    if match_def_path(cx, fn_def_id, &paths::PUSH_STR) {
-                        single_char_push_string::check(cx, expr, args);
-                    } else if match_def_path(cx, fn_def_id, &paths::INSERT_STR) {
-                        single_char_insert_string::check(cx, expr, args);
-                    }
-                }
+                inefficient_to_string::check(cx, expr, method_call.ident.name, args);
+                single_char_add_str::check(cx, expr, args);
 
                 match self_ty.kind() {
                     ty::Ref(_, ty, _) if *ty.kind() == ty::Str => {
-- 
cgit 1.4.1-3-g733a5


From d38076995258ed7f1ebd270f2f32b1744c688e71 Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Wed, 17 Mar 2021 13:22:25 +0900
Subject: extract conditions for `from_iter_instead_of_collect`  into its own
 module

---
 clippy_lints/src/methods/chars_cmp.rs                    |  2 +-
 clippy_lints/src/methods/chars_cmp_with_unwrap.rs        |  2 +-
 clippy_lints/src/methods/from_iter_instead_of_collect.rs | 12 +++++++-----
 clippy_lints/src/methods/mod.rs                          | 13 ++++---------
 clippy_lints/src/methods/single_char_add_str.rs          |  3 +--
 5 files changed, 14 insertions(+), 18 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/chars_cmp.rs b/clippy_lints/src/methods/chars_cmp.rs
index f9af06d200c..c668fe52781 100644
--- a/clippy_lints/src/methods/chars_cmp.rs
+++ b/clippy_lints/src/methods/chars_cmp.rs
@@ -1,6 +1,6 @@
-use crate::utils::{method_chain_args, single_segment_path};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::{method_chain_args, single_segment_path};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
diff --git a/clippy_lints/src/methods/chars_cmp_with_unwrap.rs b/clippy_lints/src/methods/chars_cmp_with_unwrap.rs
index 3ba59171f77..4275857757f 100644
--- a/clippy_lints/src/methods/chars_cmp_with_unwrap.rs
+++ b/clippy_lints/src/methods/chars_cmp_with_unwrap.rs
@@ -1,5 +1,5 @@
-use crate::utils::method_chain_args;
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::method_chain_args;
 use clippy_utils::source::snippet_with_applicability;
 use if_chain::if_chain;
 use rustc_ast::ast;
diff --git a/clippy_lints/src/methods/from_iter_instead_of_collect.rs b/clippy_lints/src/methods/from_iter_instead_of_collect.rs
index 2095a60e44b..15cf5674313 100644
--- a/clippy_lints/src/methods/from_iter_instead_of_collect.rs
+++ b/clippy_lints/src/methods/from_iter_instead_of_collect.rs
@@ -1,20 +1,22 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::ty::implements_trait;
-use clippy_utils::{get_trait_def_id, paths, sugg};
+use clippy_utils::{get_trait_def_id, match_qpath, paths, sugg};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
+use rustc_hir::ExprKind;
 use rustc_lint::{LateContext, LintContext};
 use rustc_middle::ty::Ty;
 use rustc_span::sym;
 
 use super::FROM_ITER_INSTEAD_OF_COLLECT;
 
-pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::Expr<'_>]) {
-    let ty = cx.typeck_results().expr_ty(expr);
-    let arg_ty = cx.typeck_results().expr_ty(&args[0]);
-
+pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::Expr<'_>], func_kind: &ExprKind<'_>) {
     if_chain! {
+        if let hir::ExprKind::Path(path) = func_kind;
+        if match_qpath(path, &["from_iter"]);
+        let ty = cx.typeck_results().expr_ty(expr);
+        let arg_ty = cx.typeck_results().expr_ty(&args[0]);
         if let Some(from_iter_id) = get_trait_def_id(cx, &paths::FROM_ITERATOR);
         if let Some(iter_id) = cx.tcx.get_diagnostic_item(sym::Iterator);
 
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index bbf7f1d312b..808b64d9493 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -63,8 +63,8 @@ use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::{contains_ty, implements_trait, is_copy, is_type_diagnostic_item};
 use clippy_utils::{
-    contains_return, get_trait_def_id, in_macro, iter_input_pats, match_def_path, match_qpath, method_calls,
-    method_chain_args, paths, return_ty, single_segment_path, SpanlessEq,
+    contains_return, get_trait_def_id, in_macro, iter_input_pats, match_qpath, method_calls, paths, return_ty,
+    SpanlessEq,
 };
 use if_chain::if_chain;
 use rustc_ast::ast;
@@ -1777,22 +1777,17 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
 
         match expr.kind {
             hir::ExprKind::Call(ref func, ref args) => {
-                if let hir::ExprKind::Path(path) = &func.kind {
-                    if match_qpath(path, &["from_iter"]) {
-                        from_iter_instead_of_collect::check(cx, expr, args);
-                    }
-                }
+                from_iter_instead_of_collect::check(cx, expr, args, &func.kind);
             },
             hir::ExprKind::MethodCall(ref method_call, ref method_span, ref args, _) => {
                 or_fun_call::check(cx, expr, *method_span, &method_call.ident.as_str(), args);
                 expect_fun_call::check(cx, expr, *method_span, &method_call.ident.as_str(), args);
                 clone_on_copy::check(cx, expr, method_call.ident.name, args);
                 clone_on_ref_ptr::check(cx, expr, method_call.ident.name, args);
-
-                let self_ty = cx.typeck_results().expr_ty_adjusted(&args[0]);
                 inefficient_to_string::check(cx, expr, method_call.ident.name, args);
                 single_char_add_str::check(cx, expr, args);
 
+                let self_ty = cx.typeck_results().expr_ty_adjusted(&args[0]);
                 match self_ty.kind() {
                     ty::Ref(_, ty, _) if *ty.kind() == ty::Str => {
                         for &(method, pos) in &PATTERN_METHODS {
diff --git a/clippy_lints/src/methods/single_char_add_str.rs b/clippy_lints/src/methods/single_char_add_str.rs
index 3df88e5b69c..9a5fabcf7cd 100644
--- a/clippy_lints/src/methods/single_char_add_str.rs
+++ b/clippy_lints/src/methods/single_char_add_str.rs
@@ -1,6 +1,5 @@
 use crate::methods::{single_char_insert_string, single_char_push_string};
-use crate::utils::match_def_path;
-use crate::utils::paths;
+use clippy_utils::{match_def_path, paths};
 use rustc_hir as hir;
 use rustc_lint::LateContext;
 
-- 
cgit 1.4.1-3-g733a5


From 7a7fcc0eda1d62f44ec374bad3d14226888238ad Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Wed, 17 Mar 2021 14:14:06 +0900
Subject: extract condition for into_iter_on_ref to its own module

---
 clippy_lints/src/methods/into_iter_on_ref.rs | 47 +++++++++++++++++-----------
 clippy_lints/src/methods/mod.rs              |  7 ++---
 2 files changed, 31 insertions(+), 23 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/into_iter_on_ref.rs b/clippy_lints/src/methods/into_iter_on_ref.rs
index cfe749cf361..5d59fa86c9e 100644
--- a/clippy_lints/src/methods/into_iter_on_ref.rs
+++ b/clippy_lints/src/methods/into_iter_on_ref.rs
@@ -1,32 +1,43 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::ty::has_iter_method;
 use clippy_utils::{match_trait_method, paths};
+use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
 use rustc_middle::ty::{self, Ty};
 use rustc_span::source_map::Span;
-use rustc_span::symbol::Symbol;
+use rustc_span::symbol::{sym, Symbol};
 
 use super::INTO_ITER_ON_REF;
 
-pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, self_ref_ty: Ty<'_>, method_span: Span) {
-    if !match_trait_method(cx, expr, &paths::INTO_ITERATOR) {
-        return;
-    }
-    if let Some((kind, method_name)) = ty_has_iter_method(cx, self_ref_ty) {
-        span_lint_and_sugg(
-            cx,
-            INTO_ITER_ON_REF,
-            method_span,
-            &format!(
-                "this `.into_iter()` call is equivalent to `.{}()` and will not consume the `{}`",
-                method_name, kind,
-            ),
-            "call directly",
-            method_name.to_string(),
-            Applicability::MachineApplicable,
-        );
+pub(super) fn check(
+    cx: &LateContext<'_>,
+    expr: &hir::Expr<'_>,
+    method_span: Span,
+    method_name: Symbol,
+    args: &[hir::Expr<'_>],
+) {
+    let self_ty = cx.typeck_results().expr_ty_adjusted(&args[0]);
+    if_chain! {
+        if let ty::Ref(..) = self_ty.kind();
+        if method_name == sym::into_iter;
+        if match_trait_method(cx, expr, &paths::INTO_ITERATOR);
+        if let Some((kind, method_name)) = ty_has_iter_method(cx, self_ty);
+        then {
+            span_lint_and_sugg(
+                cx,
+                INTO_ITER_ON_REF,
+                method_span,
+                &format!(
+                    "this `.into_iter()` call is equivalent to `.{}()` and will not consume the `{}`",
+                    method_name, kind,
+                ),
+                "call directly",
+                method_name.to_string(),
+                Applicability::MachineApplicable,
+            );
+        }
     }
 }
 
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 808b64d9493..e8cefbd7422 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1786,9 +1786,9 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
                 clone_on_ref_ptr::check(cx, expr, method_call.ident.name, args);
                 inefficient_to_string::check(cx, expr, method_call.ident.name, args);
                 single_char_add_str::check(cx, expr, args);
+                into_iter_on_ref::check(cx, expr, *method_span, method_call.ident.name, args);
 
-                let self_ty = cx.typeck_results().expr_ty_adjusted(&args[0]);
-                match self_ty.kind() {
+                match cx.typeck_results().expr_ty_adjusted(&args[0]).kind() {
                     ty::Ref(_, ty, _) if *ty.kind() == ty::Str => {
                         for &(method, pos) in &PATTERN_METHODS {
                             if method_call.ident.name.as_str() == method && args.len() > pos {
@@ -1796,9 +1796,6 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
                             }
                         }
                     },
-                    ty::Ref(..) if method_call.ident.name == sym::into_iter => {
-                        into_iter_on_ref::check(cx, expr, self_ty, *method_span);
-                    },
                     _ => (),
                 }
             },
-- 
cgit 1.4.1-3-g733a5


From 4d1f2bc56519a9b37daaec84273f97e3aba4318b Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Wed, 17 Mar 2021 14:26:27 +0900
Subject: extract conditions for single_char_pattern into its own module

---
 clippy_lints/src/methods/mod.rs                 | 12 +--------
 clippy_lints/src/methods/single_char_pattern.rs | 36 ++++++++++++++++---------
 2 files changed, 25 insertions(+), 23 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index e8cefbd7422..b97dee27c52 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1787,17 +1787,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
                 inefficient_to_string::check(cx, expr, method_call.ident.name, args);
                 single_char_add_str::check(cx, expr, args);
                 into_iter_on_ref::check(cx, expr, *method_span, method_call.ident.name, args);
-
-                match cx.typeck_results().expr_ty_adjusted(&args[0]).kind() {
-                    ty::Ref(_, ty, _) if *ty.kind() == ty::Str => {
-                        for &(method, pos) in &PATTERN_METHODS {
-                            if method_call.ident.name.as_str() == method && args.len() > pos {
-                                single_char_pattern::check(cx, expr, &args[pos]);
-                            }
-                        }
-                    },
-                    _ => (),
-                }
+                single_char_pattern::check(cx, expr, method_call.ident.name, args);
             },
             hir::ExprKind::Binary(op, ref lhs, ref rhs)
                 if op.node == hir::BinOpKind::Eq || op.node == hir::BinOpKind::Ne =>
diff --git a/clippy_lints/src/methods/single_char_pattern.rs b/clippy_lints/src/methods/single_char_pattern.rs
index 12d6418d700..ae998468c2d 100644
--- a/clippy_lints/src/methods/single_char_pattern.rs
+++ b/clippy_lints/src/methods/single_char_pattern.rs
@@ -1,23 +1,35 @@
 use crate::methods::get_hint_if_single_char_arg;
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
+use rustc_middle::ty;
+use rustc_span::symbol::Symbol;
 
 use super::SINGLE_CHAR_PATTERN;
 
 /// lint for length-1 `str`s for methods in `PATTERN_METHODS`
-pub(super) fn check(cx: &LateContext<'_>, _expr: &hir::Expr<'_>, arg: &hir::Expr<'_>) {
-    let mut applicability = Applicability::MachineApplicable;
-    if let Some(hint) = get_hint_if_single_char_arg(cx, arg, &mut applicability) {
-        span_lint_and_sugg(
-            cx,
-            SINGLE_CHAR_PATTERN,
-            arg.span,
-            "single-character string constant used as pattern",
-            "try using a `char` instead",
-            hint,
-            applicability,
-        );
+pub(super) fn check(cx: &LateContext<'_>, _expr: &hir::Expr<'_>, method_name: Symbol, args: &[hir::Expr<'_>]) {
+    for &(method, pos) in &crate::methods::PATTERN_METHODS {
+        if_chain! {
+            if let ty::Ref(_, ty, _) = cx.typeck_results().expr_ty_adjusted(&args[0]).kind();
+            if *ty.kind() == ty::Str;
+            if method_name.as_str() == method && args.len() > pos;
+            let arg = &args[pos];
+            let mut applicability = Applicability::MachineApplicable;
+            if let Some(hint) = get_hint_if_single_char_arg(cx, arg, &mut applicability);
+            then {
+                span_lint_and_sugg(
+                    cx,
+                    SINGLE_CHAR_PATTERN,
+                    arg.span,
+                    "single-character string constant used as pattern",
+                    "try using a `char` instead",
+                    hint,
+                    applicability,
+                );
+            }
+        }
     }
 }
-- 
cgit 1.4.1-3-g733a5


From 27963c8dce5b2db8c6c308681682bbb33938e125 Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Wed, 17 Mar 2021 14:34:20 +0900
Subject: move chars_last_cmp_with_unwrap to its own module

---
 clippy_lints/src/methods/chars_last_cmp_with_unwrap.rs | 13 +++++++++++++
 clippy_lints/src/methods/mod.rs                        | 12 ++----------
 2 files changed, 15 insertions(+), 10 deletions(-)
 create mode 100644 clippy_lints/src/methods/chars_last_cmp_with_unwrap.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/chars_last_cmp_with_unwrap.rs b/clippy_lints/src/methods/chars_last_cmp_with_unwrap.rs
new file mode 100644
index 00000000000..c29ee0ec8c8
--- /dev/null
+++ b/clippy_lints/src/methods/chars_last_cmp_with_unwrap.rs
@@ -0,0 +1,13 @@
+use crate::methods::chars_cmp_with_unwrap;
+use rustc_lint::LateContext;
+
+use super::CHARS_LAST_CMP;
+
+/// Checks for the `CHARS_LAST_CMP` lint with `unwrap()`.
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, info: &crate::methods::BinaryExprInfo<'_>) -> bool {
+    if chars_cmp_with_unwrap::check(cx, info, &["chars", "last", "unwrap"], CHARS_LAST_CMP, "ends_with") {
+        true
+    } else {
+        chars_cmp_with_unwrap::check(cx, info, &["chars", "next_back", "unwrap"], CHARS_LAST_CMP, "ends_with")
+    }
+}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index b97dee27c52..f124d0b12f5 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3,6 +3,7 @@ mod bytes_nth;
 mod chars_cmp;
 mod chars_cmp_with_unwrap;
 mod chars_last_cmp;
+mod chars_last_cmp_with_unwrap;
 mod chars_next_cmp;
 mod chars_next_cmp_with_unwrap;
 mod clone_on_copy;
@@ -1974,16 +1975,7 @@ fn lint_binary_expr_with_method_call(cx: &LateContext<'_>, info: &mut BinaryExpr
     lint_with_both_lhs_and_rhs!(chars_next_cmp::check, cx, info);
     lint_with_both_lhs_and_rhs!(chars_last_cmp::check, cx, info);
     lint_with_both_lhs_and_rhs!(chars_next_cmp_with_unwrap::check, cx, info);
-    lint_with_both_lhs_and_rhs!(lint_chars_last_cmp_with_unwrap, cx, info);
-}
-
-/// Checks for the `CHARS_LAST_CMP` lint with `unwrap()`.
-fn lint_chars_last_cmp_with_unwrap<'tcx>(cx: &LateContext<'tcx>, info: &BinaryExprInfo<'_>) -> bool {
-    if chars_cmp_with_unwrap::check(cx, info, &["chars", "last", "unwrap"], CHARS_LAST_CMP, "ends_with") {
-        true
-    } else {
-        chars_cmp_with_unwrap::check(cx, info, &["chars", "next_back", "unwrap"], CHARS_LAST_CMP, "ends_with")
-    }
+    lint_with_both_lhs_and_rhs!(chars_last_cmp_with_unwrap::check, cx, info);
 }
 
 fn get_hint_if_single_char_arg(
-- 
cgit 1.4.1-3-g733a5


From 602bcf3e4f5f540e2f81d9e807e28b35c7bee0ed Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Wed, 17 Mar 2021 14:45:20 +0900
Subject: move get_hint_if_single_char_arg to methods/utils.rs

---
 clippy_lints/src/methods/mod.rs                    | 31 --------------------
 .../src/methods/single_char_insert_string.rs       |  2 +-
 clippy_lints/src/methods/single_char_pattern.rs    |  2 +-
 .../src/methods/single_char_push_string.rs         |  2 +-
 clippy_lints/src/methods/utils.rs                  | 34 +++++++++++++++++++++-
 5 files changed, 36 insertions(+), 35 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index f124d0b12f5..a80162015dc 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -61,15 +61,12 @@ mod zst_offset;
 
 use bind_instead_of_map::BindInsteadOfMap;
 use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
-use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::{contains_ty, implements_trait, is_copy, is_type_diagnostic_item};
 use clippy_utils::{
     contains_return, get_trait_def_id, in_macro, iter_input_pats, match_qpath, method_calls, paths, return_ty,
     SpanlessEq,
 };
 use if_chain::if_chain;
-use rustc_ast::ast;
-use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_hir::{TraitItem, TraitItemKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
@@ -1978,34 +1975,6 @@ fn lint_binary_expr_with_method_call(cx: &LateContext<'_>, info: &mut BinaryExpr
     lint_with_both_lhs_and_rhs!(chars_last_cmp_with_unwrap::check, cx, info);
 }
 
-fn get_hint_if_single_char_arg(
-    cx: &LateContext<'_>,
-    arg: &hir::Expr<'_>,
-    applicability: &mut Applicability,
-) -> Option<String> {
-    if_chain! {
-        if let hir::ExprKind::Lit(lit) = &arg.kind;
-        if let ast::LitKind::Str(r, style) = lit.node;
-        let string = r.as_str();
-        if string.chars().count() == 1;
-        then {
-            let snip = snippet_with_applicability(cx, arg.span, &string, applicability);
-            let ch = if let ast::StrStyle::Raw(nhash) = style {
-                let nhash = nhash as usize;
-                // for raw string: r##"a"##
-                &snip[(nhash + 2)..(snip.len() - 1 - nhash)]
-            } else {
-                // for regular string: "a"
-                &snip[1..(snip.len() - 1)]
-            };
-            let hint = format!("'{}'", if ch == "'" { "\\'" } else { ch });
-            Some(hint)
-        } else {
-            None
-        }
-    }
-}
-
 const FN_HEADER: hir::FnHeader = hir::FnHeader {
     unsafety: hir::Unsafety::Normal,
     constness: hir::Constness::NotConst,
diff --git a/clippy_lints/src/methods/single_char_insert_string.rs b/clippy_lints/src/methods/single_char_insert_string.rs
index cd87d2c56b7..3f3e3bd7dfd 100644
--- a/clippy_lints/src/methods/single_char_insert_string.rs
+++ b/clippy_lints/src/methods/single_char_insert_string.rs
@@ -1,4 +1,4 @@
-use crate::methods::get_hint_if_single_char_arg;
+use crate::methods::utils::get_hint_if_single_char_arg;
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/methods/single_char_pattern.rs b/clippy_lints/src/methods/single_char_pattern.rs
index ae998468c2d..abead199098 100644
--- a/clippy_lints/src/methods/single_char_pattern.rs
+++ b/clippy_lints/src/methods/single_char_pattern.rs
@@ -1,4 +1,4 @@
-use crate::methods::get_hint_if_single_char_arg;
+use crate::methods::utils::get_hint_if_single_char_arg;
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/methods/single_char_push_string.rs b/clippy_lints/src/methods/single_char_push_string.rs
index 882703a987d..189157f819e 100644
--- a/clippy_lints/src/methods/single_char_push_string.rs
+++ b/clippy_lints/src/methods/single_char_push_string.rs
@@ -1,4 +1,4 @@
-use crate::methods::get_hint_if_single_char_arg;
+use crate::methods::utils::get_hint_if_single_char_arg;
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/methods/utils.rs b/clippy_lints/src/methods/utils.rs
index 4d801148cbc..8de23e1bc6e 100644
--- a/clippy_lints/src/methods/utils.rs
+++ b/clippy_lints/src/methods/utils.rs
@@ -1,11 +1,15 @@
+use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::is_type_diagnostic_item;
+use if_chain::if_chain;
+use rustc_ast::ast;
+use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
 use rustc_middle::ty;
 use rustc_middle::ty::Ty;
 use rustc_span::symbol::sym;
 
-pub fn derefs_to_slice<'tcx>(
+pub(super) fn derefs_to_slice<'tcx>(
     cx: &LateContext<'tcx>,
     expr: &'tcx hir::Expr<'tcx>,
     ty: Ty<'tcx>,
@@ -44,3 +48,31 @@ pub fn derefs_to_slice<'tcx>(
         }
     }
 }
+
+pub(super) fn get_hint_if_single_char_arg(
+    cx: &LateContext<'_>,
+    arg: &hir::Expr<'_>,
+    applicability: &mut Applicability,
+) -> Option<String> {
+    if_chain! {
+        if let hir::ExprKind::Lit(lit) = &arg.kind;
+        if let ast::LitKind::Str(r, style) = lit.node;
+        let string = r.as_str();
+        if string.chars().count() == 1;
+        then {
+            let snip = snippet_with_applicability(cx, arg.span, &string, applicability);
+            let ch = if let ast::StrStyle::Raw(nhash) = style {
+                let nhash = nhash as usize;
+                // for raw string: r##"a"##
+                &snip[(nhash + 2)..(snip.len() - 1 - nhash)]
+            } else {
+                // for regular string: "a"
+                &snip[1..(snip.len() - 1)]
+            };
+            let hint = format!("'{}'", if ch == "'" { "\\'" } else { ch });
+            Some(hint)
+        } else {
+            None
+        }
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 0b7ab90ecae3c5ab55aa053ea9477cab88ab7f0e Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sat, 6 Mar 2021 19:25:09 -0500
Subject: Improvements to `match_wildcard_for_single_variants` and
 `wildcard_enum_match_arm` lints Don't lint on `Result` and `Option` types.
 Considers `or` patterns. Considers variants prefixed with `Self` Suggestions
 will try to find a common prefix rather than just using the full path

---
 clippy_lints/src/attrs.rs                          |   4 +-
 clippy_lints/src/doc.rs                            |   2 +-
 clippy_lints/src/eval_order_dependence.rs          |   2 +-
 clippy_lints/src/loops/never_loop.rs               |   2 +-
 clippy_lints/src/matches.rs                        | 245 +++++++++++++--------
 clippy_lints/src/redundant_clone.rs                |   4 +-
 clippy_lints/src/types/mod.rs                      |   6 +-
 clippy_lints/src/unnecessary_wraps.rs              |   2 +-
 clippy_utils/src/lib.rs                            |  10 +
 tests/ui/match_wildcard_for_single_variants.fixed  |  40 ++++
 tests/ui/match_wildcard_for_single_variants.rs     |  40 ++++
 tests/ui/match_wildcard_for_single_variants.stderr |  44 +++-
 tests/ui/wildcard_enum_match_arm.fixed             |   2 +-
 tests/ui/wildcard_enum_match_arm.stderr            |   2 +-
 14 files changed, 293 insertions(+), 112 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs
index f805f716e6b..a4ddef666c0 100644
--- a/clippy_lints/src/attrs.rs
+++ b/clippy_lints/src/attrs.rs
@@ -430,7 +430,7 @@ fn is_relevant_block(cx: &LateContext<'_>, typeck_results: &ty::TypeckResults<'_
         |stmt| match &stmt.kind {
             StmtKind::Local(_) => true,
             StmtKind::Expr(expr) | StmtKind::Semi(expr) => is_relevant_expr(cx, typeck_results, expr),
-            _ => false,
+            StmtKind::Item(_) => false,
         },
     )
 }
@@ -613,7 +613,7 @@ fn check_mismatched_target_os(cx: &EarlyContext<'_>, attr: &Attribute) {
                             }
                         }
                     },
-                    _ => {},
+                    MetaItemKind::NameValue(..) => {},
                 }
             }
         }
diff --git a/clippy_lints/src/doc.rs b/clippy_lints/src/doc.rs
index 5fa278b2897..14338ac8faf 100644
--- a/clippy_lints/src/doc.rs
+++ b/clippy_lints/src/doc.rs
@@ -583,7 +583,7 @@ fn check_code(cx: &LateContext<'_>, text: &str, edition: Edition, span: Span) {
                                 let returns_nothing = match &sig.decl.output {
                                     FnRetTy::Default(..) => true,
                                     FnRetTy::Ty(ty) if ty.kind.is_unit() => true,
-                                    _ => false,
+                                    FnRetTy::Ty(_) => false,
                                 };
 
                                 if returns_nothing && !is_async && !block.stmts.is_empty() {
diff --git a/clippy_lints/src/eval_order_dependence.rs b/clippy_lints/src/eval_order_dependence.rs
index 5d5b67de843..ea33a4d98fd 100644
--- a/clippy_lints/src/eval_order_dependence.rs
+++ b/clippy_lints/src/eval_order_dependence.rs
@@ -273,7 +273,7 @@ fn check_stmt<'a, 'tcx>(vis: &mut ReadVisitor<'a, 'tcx>, stmt: &'tcx Stmt<'_>) -
             .init
             .as_ref()
             .map_or(StopEarly::KeepGoing, |expr| check_expr(vis, expr)),
-        _ => StopEarly::KeepGoing,
+        StmtKind::Item(..) => StopEarly::KeepGoing,
     }
 }
 
diff --git a/clippy_lints/src/loops/never_loop.rs b/clippy_lints/src/loops/never_loop.rs
index 82ec2635aeb..f63a3761a0d 100644
--- a/clippy_lints/src/loops/never_loop.rs
+++ b/clippy_lints/src/loops/never_loop.rs
@@ -78,7 +78,7 @@ fn stmt_to_expr<'tcx>(stmt: &Stmt<'tcx>) -> Option<&'tcx Expr<'tcx>> {
     match stmt.kind {
         StmtKind::Semi(ref e, ..) | StmtKind::Expr(ref e, ..) => Some(e),
         StmtKind::Local(ref local) => local.init.as_deref(),
-        _ => None,
+        StmtKind::Item(..) => None,
     }
 }
 
diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index e94c7094cac..e9926e0bca5 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -8,21 +8,21 @@ use clippy_utils::ty::{implements_trait, is_type_diagnostic_item, match_type, pe
 use clippy_utils::visitors::LocalUsedVisitor;
 use clippy_utils::{
     get_parent_expr, in_macro, is_allowed, is_expn_of, is_refutable, is_wild, match_qpath, meets_msrv, path_to_local,
-    path_to_local_id, peel_hir_pat_refs, peel_n_hir_expr_refs, remove_blocks, strip_pat_refs,
+    path_to_local_id, peel_hir_pat_refs, peel_n_hir_expr_refs, recurse_or_patterns, remove_blocks, strip_pat_refs,
 };
 use clippy_utils::{paths, search_same, SpanlessEq, SpanlessHash};
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_errors::Applicability;
-use rustc_hir::def::CtorKind;
+use rustc_hir::def::{CtorKind, DefKind, Res};
 use rustc_hir::{
-    Arm, BindingAnnotation, Block, BorrowKind, Expr, ExprKind, Guard, HirId, Local, MatchSource, Mutability, Node, Pat,
-    PatKind, QPath, RangeEnd,
+    self as hir, Arm, BindingAnnotation, Block, BorrowKind, Expr, ExprKind, Guard, HirId, Local, MatchSource,
+    Mutability, Node, Pat, PatKind, PathSegment, QPath, RangeEnd, TyKind,
 };
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_middle::ty::{self, Ty, TyS};
+use rustc_middle::ty::{self, Ty, TyS, VariantDef};
 use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::{Span, Spanned};
@@ -956,114 +956,181 @@ fn check_wild_err_arm<'tcx>(cx: &LateContext<'tcx>, ex: &Expr<'tcx>, arms: &[Arm
     }
 }
 
-fn check_wild_enum_match(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>]) {
-    let ty = cx.typeck_results().expr_ty(ex);
-    if !ty.is_enum() {
-        // If there isn't a nice closed set of possible values that can be conveniently enumerated,
-        // don't complain about not enumerating the mall.
-        return;
+enum CommonPrefixSearcher<'a> {
+    None,
+    Path(&'a [PathSegment<'a>]),
+    Mixed,
+}
+impl CommonPrefixSearcher<'a> {
+    fn with_path(&mut self, path: &'a [PathSegment<'a>]) {
+        match path {
+            [path @ .., _] => self.with_prefix(path),
+            [] => (),
+        }
     }
 
+    fn with_prefix(&mut self, path: &'a [PathSegment<'a>]) {
+        match self {
+            Self::None => *self = Self::Path(path),
+            Self::Path(self_path)
+                if path
+                    .iter()
+                    .map(|p| p.ident.name)
+                    .eq(self_path.iter().map(|p| p.ident.name)) => {},
+            Self::Path(_) => *self = Self::Mixed,
+            Self::Mixed => (),
+        }
+    }
+}
+
+#[allow(clippy::too_many_lines)]
+fn check_wild_enum_match(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>]) {
+    let ty = cx.typeck_results().expr_ty(ex).peel_refs();
+    let adt_def = match ty.kind() {
+        ty::Adt(adt_def, _)
+            if adt_def.is_enum()
+                && !(is_type_diagnostic_item(cx, ty, sym::option_type)
+                    || is_type_diagnostic_item(cx, ty, sym::result_type)) =>
+        {
+            adt_def
+        },
+        _ => return,
+    };
+
     // First pass - check for violation, but don't do much book-keeping because this is hopefully
     // the uncommon case, and the book-keeping is slightly expensive.
     let mut wildcard_span = None;
     let mut wildcard_ident = None;
+    let mut has_non_wild = false;
     for arm in arms {
-        if let PatKind::Wild = arm.pat.kind {
-            wildcard_span = Some(arm.pat.span);
-        } else if let PatKind::Binding(_, _, ident, None) = arm.pat.kind {
-            wildcard_span = Some(arm.pat.span);
-            wildcard_ident = Some(ident);
+        match peel_hir_pat_refs(arm.pat).0.kind {
+            PatKind::Wild => wildcard_span = Some(arm.pat.span),
+            PatKind::Binding(_, _, ident, None) => {
+                wildcard_span = Some(arm.pat.span);
+                wildcard_ident = Some(ident);
+            },
+            _ => has_non_wild = true,
         }
     }
+    let wildcard_span = match wildcard_span {
+        Some(x) if has_non_wild => x,
+        _ => return,
+    };
 
-    if let Some(wildcard_span) = wildcard_span {
-        // Accumulate the variants which should be put in place of the wildcard because they're not
-        // already covered.
+    // Accumulate the variants which should be put in place of the wildcard because they're not
+    // already covered.
+    let mut missing_variants: Vec<_> = adt_def.variants.iter().collect();
 
-        let mut missing_variants = vec![];
-        if let ty::Adt(def, _) = ty.kind() {
-            for variant in &def.variants {
-                missing_variants.push(variant);
+    let mut path_prefix = CommonPrefixSearcher::None;
+    for arm in arms {
+        // Guards mean that this case probably isn't exhaustively covered. Technically
+        // this is incorrect, as we should really check whether each variant is exhaustively
+        // covered by the set of guards that cover it, but that's really hard to do.
+        recurse_or_patterns(arm.pat, |pat| {
+            let path = match &peel_hir_pat_refs(pat).0.kind {
+                PatKind::Path(path) => {
+                    #[allow(clippy::match_same_arms)]
+                    let id = match cx.qpath_res(path, pat.hir_id) {
+                        Res::Def(DefKind::Const | DefKind::ConstParam | DefKind::AnonConst, _) => return,
+                        Res::Def(_, id) => id,
+                        _ => return,
+                    };
+                    if arm.guard.is_none() {
+                        missing_variants.retain(|e| e.ctor_def_id != Some(id));
+                    }
+                    path
+                },
+                PatKind::TupleStruct(path, patterns, ..) => {
+                    if arm.guard.is_none() && patterns.iter().all(|p| !is_refutable(cx, p)) {
+                        let id = cx.qpath_res(path, pat.hir_id).def_id();
+                        missing_variants.retain(|e| e.ctor_def_id != Some(id));
+                    }
+                    path
+                },
+                PatKind::Struct(path, patterns, ..) => {
+                    if arm.guard.is_none() && patterns.iter().all(|p| !is_refutable(cx, p.pat)) {
+                        let id = cx.qpath_res(path, pat.hir_id).def_id();
+                        missing_variants.retain(|e| e.def_id != id);
+                    }
+                    path
+                },
+                _ => return,
+            };
+            match path {
+                QPath::Resolved(_, path) => path_prefix.with_path(path.segments),
+                QPath::TypeRelative(
+                    hir::Ty {
+                        kind: TyKind::Path(QPath::Resolved(_, path)),
+                        ..
+                    },
+                    _,
+                ) => path_prefix.with_prefix(path.segments),
+                _ => (),
             }
-        }
+        });
+    }
 
-        for arm in arms {
-            if arm.guard.is_some() {
-                // Guards mean that this case probably isn't exhaustively covered. Technically
-                // this is incorrect, as we should really check whether each variant is exhaustively
-                // covered by the set of guards that cover it, but that's really hard to do.
-                continue;
-            }
-            if let PatKind::Path(ref path) = arm.pat.kind {
-                if let QPath::Resolved(_, p) = path {
-                    missing_variants.retain(|e| e.ctor_def_id != Some(p.res.def_id()));
-                }
-            } else if let PatKind::TupleStruct(QPath::Resolved(_, p), ref patterns, ..) = arm.pat.kind {
-                // Some simple checks for exhaustive patterns.
-                // There is a room for improvements to detect more cases,
-                // but it can be more expensive to do so.
-                let is_pattern_exhaustive =
-                    |pat: &&Pat<'_>| matches!(pat.kind, PatKind::Wild | PatKind::Binding(.., None));
-                if patterns.iter().all(is_pattern_exhaustive) {
-                    missing_variants.retain(|e| e.ctor_def_id != Some(p.res.def_id()));
+    let format_suggestion = |variant: &VariantDef| {
+        format!(
+            "{}{}{}{}",
+            if let Some(ident) = wildcard_ident {
+                format!("{} @ ", ident.name)
+            } else {
+                String::new()
+            },
+            if let CommonPrefixSearcher::Path(path_prefix) = path_prefix {
+                let mut s = String::new();
+                for seg in path_prefix {
+                    s.push_str(&seg.ident.as_str());
+                    s.push_str("::");
                 }
+                s
+            } else {
+                let mut s = cx.tcx.def_path_str(adt_def.did);
+                s.push_str("::");
+                s
+            },
+            variant.ident.name,
+            match variant.ctor_kind {
+                CtorKind::Fn if variant.fields.len() == 1 => "(_)",
+                CtorKind::Fn => "(..)",
+                CtorKind::Const => "",
+                CtorKind::Fictive => "{ .. }",
             }
-        }
-
-        let mut suggestion: Vec<String> = missing_variants
-            .iter()
-            .map(|v| {
-                let suffix = match v.ctor_kind {
-                    CtorKind::Fn => "(..)",
-                    CtorKind::Const | CtorKind::Fictive => "",
-                };
-                let ident_str = if let Some(ident) = wildcard_ident {
-                    format!("{} @ ", ident.name)
-                } else {
-                    String::new()
-                };
-                // This path assumes that the enum type is imported into scope.
-                format!("{}{}{}", ident_str, cx.tcx.def_path_str(v.def_id), suffix)
-            })
-            .collect();
-
-        if suggestion.is_empty() {
-            return;
-        }
-
-        let mut message = "wildcard match will miss any future added variants";
+        )
+    };
 
-        if let ty::Adt(def, _) = ty.kind() {
-            if def.is_variant_list_non_exhaustive() {
-                message = "match on non-exhaustive enum doesn't explicitly match all known variants";
-                suggestion.push(String::from("_"));
-            }
-        }
+    match missing_variants.as_slice() {
+        [] => (),
+        [x] if !adt_def.is_variant_list_non_exhaustive() => span_lint_and_sugg(
+            cx,
+            MATCH_WILDCARD_FOR_SINGLE_VARIANTS,
+            wildcard_span,
+            "match on non-exhaustive enum doesn't explicitly match all known variants",
+            "try this",
+            format_suggestion(x),
+            Applicability::MaybeIncorrect,
+        ),
+        variants => {
+            let mut suggestions: Vec<_> = variants.iter().cloned().map(format_suggestion).collect();
+            let message = if adt_def.is_variant_list_non_exhaustive() {
+                suggestions.push("_".into());
+                "match on non-exhaustive enum doesn't explicitly match all known variants"
+            } else {
+                "wildcard match will miss any future added variants"
+            };
 
-        if suggestion.len() == 1 {
-            // No need to check for non-exhaustive enum as in that case len would be greater than 1
             span_lint_and_sugg(
                 cx,
-                MATCH_WILDCARD_FOR_SINGLE_VARIANTS,
+                WILDCARD_ENUM_MATCH_ARM,
                 wildcard_span,
                 message,
                 "try this",
-                suggestion[0].clone(),
+                suggestions.join(" | "),
                 Applicability::MaybeIncorrect,
             )
-        };
-
-        span_lint_and_sugg(
-            cx,
-            WILDCARD_ENUM_MATCH_ARM,
-            wildcard_span,
-            message,
-            "try this",
-            suggestion.join(" | "),
-            Applicability::MaybeIncorrect,
-        )
-    }
+        },
+    };
 }
 
 // If the block contains only a `panic!` macro (as expression or statement)
diff --git a/clippy_lints/src/redundant_clone.rs b/clippy_lints/src/redundant_clone.rs
index 60da2bcb04a..37678fac1d2 100644
--- a/clippy_lints/src/redundant_clone.rs
+++ b/clippy_lints/src/redundant_clone.rs
@@ -556,7 +556,7 @@ impl<'a, 'tcx> mir::visit::Visitor<'tcx> for PossibleBorrowerVisitor<'a, 'tcx> {
                     mir::Operand::Copy(p) | mir::Operand::Move(p) => {
                         self.possible_borrower.add(p.local, *dest);
                     },
-                    _ => (),
+                    mir::Operand::Constant(..) => (),
                 }
             }
         }
@@ -578,7 +578,7 @@ fn rvalue_locals(rvalue: &mir::Rvalue<'_>, mut visit: impl FnMut(mir::Local)) {
 
     let mut visit_op = |op: &mir::Operand<'_>| match op {
         mir::Operand::Copy(p) | mir::Operand::Move(p) => visit(p.local),
-        _ => (),
+        mir::Operand::Constant(..) => (),
     };
 
     match rvalue {
diff --git a/clippy_lints/src/types/mod.rs b/clippy_lints/src/types/mod.rs
index c0cd48e94b2..10c93c6ad06 100644
--- a/clippy_lints/src/types/mod.rs
+++ b/clippy_lints/src/types/mod.rs
@@ -276,7 +276,7 @@ impl<'tcx> LateLintPass<'tcx> for Types {
         match item.kind {
             TraitItemKind::Const(ref ty, _) | TraitItemKind::Type(_, Some(ref ty)) => self.check_ty(cx, ty, false),
             TraitItemKind::Fn(ref sig, _) => self.check_fn_decl(cx, &sig.decl),
-            _ => (),
+            TraitItemKind::Type(..) => (),
         }
     }
 
@@ -452,7 +452,7 @@ impl<'tcx> LateLintPass<'tcx> for TypeComplexity {
             TraitItemKind::Const(ref ty, _) | TraitItemKind::Type(_, Some(ref ty)) => self.check_type(cx, ty),
             TraitItemKind::Fn(FnSig { ref decl, .. }, TraitFn::Required(_)) => self.check_fndecl(cx, decl),
             // methods with default impl are covered by check_fn
-            _ => (),
+            TraitItemKind::Type(..) | TraitItemKind::Fn(_, TraitFn::Provided(_)) => (),
         }
     }
 
@@ -460,7 +460,7 @@ impl<'tcx> LateLintPass<'tcx> for TypeComplexity {
         match item.kind {
             ImplItemKind::Const(ref ty, _) | ImplItemKind::TyAlias(ref ty) => self.check_type(cx, ty),
             // methods are covered by check_fn
-            _ => (),
+            ImplItemKind::Fn(..) => (),
         }
     }
 
diff --git a/clippy_lints/src/unnecessary_wraps.rs b/clippy_lints/src/unnecessary_wraps.rs
index 9e227164695..c2be457e9dc 100644
--- a/clippy_lints/src/unnecessary_wraps.rs
+++ b/clippy_lints/src/unnecessary_wraps.rs
@@ -71,7 +71,7 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryWraps {
                 }
             },
             FnKind::Closure => return,
-            _ => (),
+            FnKind::Method(..) => (),
         }
 
         // Abort if the method is implementing a trait or of it a trait method.
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 3efa84f6b86..7c8ad4fea9a 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -957,6 +957,16 @@ pub fn is_refutable(cx: &LateContext<'_>, pat: &Pat<'_>) -> bool {
     }
 }
 
+/// If the pattern is an `or` pattern, call the function once for each sub pattern. Otherwise, call
+/// the function once on the given pattern.
+pub fn recurse_or_patterns<'tcx, F: FnMut(&'tcx Pat<'tcx>)>(pat: &'tcx Pat<'tcx>, mut f: F) {
+    if let PatKind::Or(pats) = pat.kind {
+        pats.iter().cloned().for_each(f)
+    } else {
+        f(pat)
+    }
+}
+
 /// Checks for the `#[automatically_derived]` attribute all `#[derive]`d
 /// implementations have.
 pub fn is_automatically_derived(attrs: &[ast::Attribute]) -> bool {
diff --git a/tests/ui/match_wildcard_for_single_variants.fixed b/tests/ui/match_wildcard_for_single_variants.fixed
index 519200977a7..f101e144a13 100644
--- a/tests/ui/match_wildcard_for_single_variants.fixed
+++ b/tests/ui/match_wildcard_for_single_variants.fixed
@@ -15,6 +15,16 @@ enum Color {
     Blue,
     Rgb(u8, u8, u8),
 }
+impl Color {
+    fn f(self) {
+        match self {
+            Self::Red => (),
+            Self::Green => (),
+            Self::Blue => (),
+            Self::Rgb(..) => (),
+        };
+    }
+}
 
 fn main() {
     let f = Foo::A;
@@ -56,4 +66,34 @@ fn main() {
         Color::Rgb(255, _, _) => {},
         _ => {},
     }
+
+    // References shouldn't change anything
+    match &color {
+        &Color::Red => (),
+        Color::Green => (),
+        &Color::Rgb(..) => (),
+        Color::Blue => (),
+    }
+
+    use self::Color as C;
+
+    match color {
+        C::Red => (),
+        C::Green => (),
+        C::Rgb(..) => (),
+        C::Blue => (),
+    }
+
+    match color {
+        C::Red => (),
+        Color::Green => (),
+        Color::Rgb(..) => (),
+        Color::Blue => (),
+    }
+
+    match Some(0) {
+        Some(0) => 0,
+        Some(_) => 1,
+        _ => 2,
+    };
 }
diff --git a/tests/ui/match_wildcard_for_single_variants.rs b/tests/ui/match_wildcard_for_single_variants.rs
index 1df917e085c..1ddba87e78f 100644
--- a/tests/ui/match_wildcard_for_single_variants.rs
+++ b/tests/ui/match_wildcard_for_single_variants.rs
@@ -15,6 +15,16 @@ enum Color {
     Blue,
     Rgb(u8, u8, u8),
 }
+impl Color {
+    fn f(self) {
+        match self {
+            Self::Red => (),
+            Self::Green => (),
+            Self::Blue => (),
+            _ => (),
+        };
+    }
+}
 
 fn main() {
     let f = Foo::A;
@@ -56,4 +66,34 @@ fn main() {
         Color::Rgb(255, _, _) => {},
         _ => {},
     }
+
+    // References shouldn't change anything
+    match &color {
+        &Color::Red => (),
+        Color::Green => (),
+        &Color::Rgb(..) => (),
+        &_ => (),
+    }
+
+    use self::Color as C;
+
+    match color {
+        C::Red => (),
+        C::Green => (),
+        C::Rgb(..) => (),
+        _ => (),
+    }
+
+    match color {
+        C::Red => (),
+        Color::Green => (),
+        Color::Rgb(..) => (),
+        _ => (),
+    }
+
+    match Some(0) {
+        Some(0) => 0,
+        Some(_) => 1,
+        _ => 2,
+    };
 }
diff --git a/tests/ui/match_wildcard_for_single_variants.stderr b/tests/ui/match_wildcard_for_single_variants.stderr
index 82790aa9e80..e0900c970c3 100644
--- a/tests/ui/match_wildcard_for_single_variants.stderr
+++ b/tests/ui/match_wildcard_for_single_variants.stderr
@@ -1,28 +1,52 @@
-error: wildcard match will miss any future added variants
-  --> $DIR/match_wildcard_for_single_variants.rs:24:9
+error: match on non-exhaustive enum doesn't explicitly match all known variants
+  --> $DIR/match_wildcard_for_single_variants.rs:24:13
    |
-LL |         _ => {},
-   |         ^ help: try this: `Foo::C`
+LL |             _ => (),
+   |             ^ help: try this: `Self::Rgb(..)`
    |
    = note: `-D clippy::match-wildcard-for-single-variants` implied by `-D warnings`
 
-error: wildcard match will miss any future added variants
+error: match on non-exhaustive enum doesn't explicitly match all known variants
   --> $DIR/match_wildcard_for_single_variants.rs:34:9
    |
+LL |         _ => {},
+   |         ^ help: try this: `Foo::C`
+
+error: match on non-exhaustive enum doesn't explicitly match all known variants
+  --> $DIR/match_wildcard_for_single_variants.rs:44:9
+   |
 LL |         _ => {},
    |         ^ help: try this: `Color::Blue`
 
-error: wildcard match will miss any future added variants
-  --> $DIR/match_wildcard_for_single_variants.rs:42:9
+error: match on non-exhaustive enum doesn't explicitly match all known variants
+  --> $DIR/match_wildcard_for_single_variants.rs:52:9
    |
 LL |         _ => {},
    |         ^ help: try this: `Color::Blue`
 
-error: wildcard match will miss any future added variants
-  --> $DIR/match_wildcard_for_single_variants.rs:48:9
+error: match on non-exhaustive enum doesn't explicitly match all known variants
+  --> $DIR/match_wildcard_for_single_variants.rs:58:9
    |
 LL |         _ => {},
    |         ^ help: try this: `Color::Blue`
 
-error: aborting due to 4 previous errors
+error: match on non-exhaustive enum doesn't explicitly match all known variants
+  --> $DIR/match_wildcard_for_single_variants.rs:75:9
+   |
+LL |         &_ => (),
+   |         ^^ help: try this: `Color::Blue`
+
+error: match on non-exhaustive enum doesn't explicitly match all known variants
+  --> $DIR/match_wildcard_for_single_variants.rs:84:9
+   |
+LL |         _ => (),
+   |         ^ help: try this: `C::Blue`
+
+error: match on non-exhaustive enum doesn't explicitly match all known variants
+  --> $DIR/match_wildcard_for_single_variants.rs:91:9
+   |
+LL |         _ => (),
+   |         ^ help: try this: `Color::Blue`
+
+error: aborting due to 8 previous errors
 
diff --git a/tests/ui/wildcard_enum_match_arm.fixed b/tests/ui/wildcard_enum_match_arm.fixed
index c266f684a36..fd754e4c794 100644
--- a/tests/ui/wildcard_enum_match_arm.fixed
+++ b/tests/ui/wildcard_enum_match_arm.fixed
@@ -77,7 +77,7 @@ fn main() {
     let error_kind = ErrorKind::NotFound;
     match error_kind {
         ErrorKind::NotFound => {},
-        std::io::ErrorKind::PermissionDenied | std::io::ErrorKind::ConnectionRefused | std::io::ErrorKind::ConnectionReset | std::io::ErrorKind::ConnectionAborted | std::io::ErrorKind::NotConnected | std::io::ErrorKind::AddrInUse | std::io::ErrorKind::AddrNotAvailable | std::io::ErrorKind::BrokenPipe | std::io::ErrorKind::AlreadyExists | std::io::ErrorKind::WouldBlock | std::io::ErrorKind::InvalidInput | std::io::ErrorKind::InvalidData | std::io::ErrorKind::TimedOut | std::io::ErrorKind::WriteZero | std::io::ErrorKind::Interrupted | std::io::ErrorKind::Other | std::io::ErrorKind::UnexpectedEof | _ => {},
+        ErrorKind::PermissionDenied | ErrorKind::ConnectionRefused | ErrorKind::ConnectionReset | ErrorKind::ConnectionAborted | ErrorKind::NotConnected | ErrorKind::AddrInUse | ErrorKind::AddrNotAvailable | ErrorKind::BrokenPipe | ErrorKind::AlreadyExists | ErrorKind::WouldBlock | ErrorKind::InvalidInput | ErrorKind::InvalidData | ErrorKind::TimedOut | ErrorKind::WriteZero | ErrorKind::Interrupted | ErrorKind::Other | ErrorKind::UnexpectedEof | _ => {},
     }
     match error_kind {
         ErrorKind::NotFound => {},
diff --git a/tests/ui/wildcard_enum_match_arm.stderr b/tests/ui/wildcard_enum_match_arm.stderr
index 0da2b68ba0b..8d880b7ce0a 100644
--- a/tests/ui/wildcard_enum_match_arm.stderr
+++ b/tests/ui/wildcard_enum_match_arm.stderr
@@ -32,7 +32,7 @@ error: match on non-exhaustive enum doesn't explicitly match all known variants
   --> $DIR/wildcard_enum_match_arm.rs:80:9
    |
 LL |         _ => {},
-   |         ^ help: try this: `std::io::ErrorKind::PermissionDenied | std::io::ErrorKind::ConnectionRefused | std::io::ErrorKind::ConnectionReset | std::io::ErrorKind::ConnectionAborted | std::io::ErrorKind::NotConnected | std::io::ErrorKind::AddrInUse | std::io::ErrorKind::AddrNotAvailable | std::io::ErrorKind::BrokenPipe | std::io::ErrorKind::AlreadyExists | std::io::ErrorKind::WouldBlock | std::io::ErrorKind::InvalidInput | std::io::ErrorKind::InvalidData | std::io::ErrorKind::TimedOut | std::io::ErrorKind::WriteZero | std::io::ErrorKind::Interrupted | std::io::ErrorKind::Other | std::io::ErrorKind::UnexpectedEof | _`
+   |         ^ help: try this: `ErrorKind::PermissionDenied | ErrorKind::ConnectionRefused | ErrorKind::ConnectionReset | ErrorKind::ConnectionAborted | ErrorKind::NotConnected | ErrorKind::AddrInUse | ErrorKind::AddrNotAvailable | ErrorKind::BrokenPipe | ErrorKind::AlreadyExists | ErrorKind::WouldBlock | ErrorKind::InvalidInput | ErrorKind::InvalidData | ErrorKind::TimedOut | ErrorKind::WriteZero | ErrorKind::Interrupted | ErrorKind::Other | ErrorKind::UnexpectedEof | _`
 
 error: aborting due to 5 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 0edd5f881d287dcff1b7401c44c8482cbd627c6b Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Thu, 18 Mar 2021 01:06:24 +0900
Subject: remove the use of paths

---
 clippy_lints/src/methods/into_iter_on_ref.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/into_iter_on_ref.rs b/clippy_lints/src/methods/into_iter_on_ref.rs
index 5d59fa86c9e..da13b4ba37a 100644
--- a/clippy_lints/src/methods/into_iter_on_ref.rs
+++ b/clippy_lints/src/methods/into_iter_on_ref.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::is_trait_method;
 use clippy_utils::ty::has_iter_method;
-use clippy_utils::{match_trait_method, paths};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
@@ -22,7 +22,7 @@ pub(super) fn check(
     if_chain! {
         if let ty::Ref(..) = self_ty.kind();
         if method_name == sym::into_iter;
-        if match_trait_method(cx, expr, &paths::INTO_ITERATOR);
+        if is_trait_method(cx, expr, sym::IntoIterator);
         if let Some((kind, method_name)) = ty_has_iter_method(cx, self_ty);
         then {
             span_lint_and_sugg(
-- 
cgit 1.4.1-3-g733a5


From b6a2757561167f831939f874735e259e655031a1 Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Thu, 18 Mar 2021 01:23:37 +0900
Subject: replace crate::methods::utils with super::utils

---
 clippy_lints/src/methods/iter_next_slice.rs           | 2 +-
 clippy_lints/src/methods/iter_nth.rs                  | 2 +-
 clippy_lints/src/methods/single_char_insert_string.rs | 2 +-
 clippy_lints/src/methods/single_char_pattern.rs       | 2 +-
 clippy_lints/src/methods/single_char_push_string.rs   | 2 +-
 5 files changed, 5 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/iter_next_slice.rs b/clippy_lints/src/methods/iter_next_slice.rs
index 2155159bf7c..e9b37b6f2bd 100644
--- a/clippy_lints/src/methods/iter_next_slice.rs
+++ b/clippy_lints/src/methods/iter_next_slice.rs
@@ -1,4 +1,4 @@
-use crate::methods::utils::derefs_to_slice;
+use super::utils::derefs_to_slice;
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::is_type_diagnostic_item;
diff --git a/clippy_lints/src/methods/iter_nth.rs b/clippy_lints/src/methods/iter_nth.rs
index bf1575660d1..c46af427b3c 100644
--- a/clippy_lints/src/methods/iter_nth.rs
+++ b/clippy_lints/src/methods/iter_nth.rs
@@ -1,5 +1,5 @@
+use super::utils::derefs_to_slice;
 use crate::methods::iter_nth_zero;
-use crate::methods::utils::derefs_to_slice;
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_hir as hir;
diff --git a/clippy_lints/src/methods/single_char_insert_string.rs b/clippy_lints/src/methods/single_char_insert_string.rs
index 3f3e3bd7dfd..6cdc954c03b 100644
--- a/clippy_lints/src/methods/single_char_insert_string.rs
+++ b/clippy_lints/src/methods/single_char_insert_string.rs
@@ -1,4 +1,4 @@
-use crate::methods::utils::get_hint_if_single_char_arg;
+use super::utils::get_hint_if_single_char_arg;
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/methods/single_char_pattern.rs b/clippy_lints/src/methods/single_char_pattern.rs
index abead199098..f4090c7c617 100644
--- a/clippy_lints/src/methods/single_char_pattern.rs
+++ b/clippy_lints/src/methods/single_char_pattern.rs
@@ -1,4 +1,4 @@
-use crate::methods::utils::get_hint_if_single_char_arg;
+use super::utils::get_hint_if_single_char_arg;
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/methods/single_char_push_string.rs b/clippy_lints/src/methods/single_char_push_string.rs
index 189157f819e..0237d39cbdb 100644
--- a/clippy_lints/src/methods/single_char_push_string.rs
+++ b/clippy_lints/src/methods/single_char_push_string.rs
@@ -1,4 +1,4 @@
-use crate::methods::utils::get_hint_if_single_char_arg;
+use super::utils::get_hint_if_single_char_arg;
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use rustc_errors::Applicability;
-- 
cgit 1.4.1-3-g733a5


From d5a7941ead06e1cb89a0a2cc6ea5c19810daea03 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Tue, 16 Mar 2021 12:56:08 -0400
Subject: Fix message for `match_wildcard_for_single_variant`

---
 clippy_lints/src/matches.rs                        |  6 +++---
 tests/ui/match_wildcard_for_single_variants.stderr | 16 ++++++++--------
 tests/ui/wildcard_enum_match_arm.stderr            | 10 +++++-----
 3 files changed, 16 insertions(+), 16 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index e9926e0bca5..d43cb32ee51 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -1106,7 +1106,7 @@ fn check_wild_enum_match(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>])
             cx,
             MATCH_WILDCARD_FOR_SINGLE_VARIANTS,
             wildcard_span,
-            "match on non-exhaustive enum doesn't explicitly match all known variants",
+            "wildcard matches only a single variant and will also match any future added variants",
             "try this",
             format_suggestion(x),
             Applicability::MaybeIncorrect,
@@ -1115,9 +1115,9 @@ fn check_wild_enum_match(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>])
             let mut suggestions: Vec<_> = variants.iter().cloned().map(format_suggestion).collect();
             let message = if adt_def.is_variant_list_non_exhaustive() {
                 suggestions.push("_".into());
-                "match on non-exhaustive enum doesn't explicitly match all known variants"
+                "wildcard matches known variants and will also match future added variants"
             } else {
-                "wildcard match will miss any future added variants"
+                "wildcard match will also match any future added variants"
             };
 
             span_lint_and_sugg(
diff --git a/tests/ui/match_wildcard_for_single_variants.stderr b/tests/ui/match_wildcard_for_single_variants.stderr
index e0900c970c3..34538dea8e5 100644
--- a/tests/ui/match_wildcard_for_single_variants.stderr
+++ b/tests/ui/match_wildcard_for_single_variants.stderr
@@ -1,4 +1,4 @@
-error: match on non-exhaustive enum doesn't explicitly match all known variants
+error: wildcard matches only a single variant and will also match any future added variants
   --> $DIR/match_wildcard_for_single_variants.rs:24:13
    |
 LL |             _ => (),
@@ -6,43 +6,43 @@ LL |             _ => (),
    |
    = note: `-D clippy::match-wildcard-for-single-variants` implied by `-D warnings`
 
-error: match on non-exhaustive enum doesn't explicitly match all known variants
+error: wildcard matches only a single variant and will also match any future added variants
   --> $DIR/match_wildcard_for_single_variants.rs:34:9
    |
 LL |         _ => {},
    |         ^ help: try this: `Foo::C`
 
-error: match on non-exhaustive enum doesn't explicitly match all known variants
+error: wildcard matches only a single variant and will also match any future added variants
   --> $DIR/match_wildcard_for_single_variants.rs:44:9
    |
 LL |         _ => {},
    |         ^ help: try this: `Color::Blue`
 
-error: match on non-exhaustive enum doesn't explicitly match all known variants
+error: wildcard matches only a single variant and will also match any future added variants
   --> $DIR/match_wildcard_for_single_variants.rs:52:9
    |
 LL |         _ => {},
    |         ^ help: try this: `Color::Blue`
 
-error: match on non-exhaustive enum doesn't explicitly match all known variants
+error: wildcard matches only a single variant and will also match any future added variants
   --> $DIR/match_wildcard_for_single_variants.rs:58:9
    |
 LL |         _ => {},
    |         ^ help: try this: `Color::Blue`
 
-error: match on non-exhaustive enum doesn't explicitly match all known variants
+error: wildcard matches only a single variant and will also match any future added variants
   --> $DIR/match_wildcard_for_single_variants.rs:75:9
    |
 LL |         &_ => (),
    |         ^^ help: try this: `Color::Blue`
 
-error: match on non-exhaustive enum doesn't explicitly match all known variants
+error: wildcard matches only a single variant and will also match any future added variants
   --> $DIR/match_wildcard_for_single_variants.rs:84:9
    |
 LL |         _ => (),
    |         ^ help: try this: `C::Blue`
 
-error: match on non-exhaustive enum doesn't explicitly match all known variants
+error: wildcard matches only a single variant and will also match any future added variants
   --> $DIR/match_wildcard_for_single_variants.rs:91:9
    |
 LL |         _ => (),
diff --git a/tests/ui/wildcard_enum_match_arm.stderr b/tests/ui/wildcard_enum_match_arm.stderr
index 8d880b7ce0a..a513a62c748 100644
--- a/tests/ui/wildcard_enum_match_arm.stderr
+++ b/tests/ui/wildcard_enum_match_arm.stderr
@@ -1,4 +1,4 @@
-error: wildcard match will miss any future added variants
+error: wildcard match will also match any future added variants
   --> $DIR/wildcard_enum_match_arm.rs:39:9
    |
 LL |         _ => eprintln!("Not red"),
@@ -10,25 +10,25 @@ note: the lint level is defined here
 LL | #![deny(clippy::wildcard_enum_match_arm)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: wildcard match will miss any future added variants
+error: wildcard match will also match any future added variants
   --> $DIR/wildcard_enum_match_arm.rs:43:9
    |
 LL |         _not_red => eprintln!("Not red"),
    |         ^^^^^^^^ help: try this: `_not_red @ Color::Green | _not_red @ Color::Blue | _not_red @ Color::Rgb(..) | _not_red @ Color::Cyan`
 
-error: wildcard match will miss any future added variants
+error: wildcard match will also match any future added variants
   --> $DIR/wildcard_enum_match_arm.rs:47:9
    |
 LL |         not_red => format!("{:?}", not_red),
    |         ^^^^^^^ help: try this: `not_red @ Color::Green | not_red @ Color::Blue | not_red @ Color::Rgb(..) | not_red @ Color::Cyan`
 
-error: wildcard match will miss any future added variants
+error: wildcard match will also match any future added variants
   --> $DIR/wildcard_enum_match_arm.rs:63:9
    |
 LL |         _ => "No red",
    |         ^ help: try this: `Color::Red | Color::Green | Color::Blue | Color::Rgb(..) | Color::Cyan`
 
-error: match on non-exhaustive enum doesn't explicitly match all known variants
+error: wildcard matches known variants and will also match future added variants
   --> $DIR/wildcard_enum_match_arm.rs:80:9
    |
 LL |         _ => {},
-- 
cgit 1.4.1-3-g733a5


From f468d822830b36bb61d2ecd90fe3f1e9e1b90cf4 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Fri, 5 Mar 2021 15:57:37 -0500
Subject: Fix `manual_map` suggestion for `if let.. else ... if let.. else`
 chain

---
 clippy_lints/src/manual_map.rs    | 18 +++++++++++++-----
 clippy_utils/src/lib.rs           | 20 ++++++++++++++++++++
 tests/ui/manual_map_option.fixed  |  5 +++++
 tests/ui/manual_map_option.rs     |  9 +++++++++
 tests/ui/manual_map_option.stderr | 21 ++++++++++++++++++++-
 5 files changed, 67 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_map.rs b/clippy_lints/src/manual_map.rs
index cd9594737bf..ed157783b72 100644
--- a/clippy_lints/src/manual_map.rs
+++ b/clippy_lints/src/manual_map.rs
@@ -2,13 +2,13 @@ use crate::{map_unit_fn::OPTION_MAP_UNIT_FN, matches::MATCH_AS_REF};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::{snippet_with_applicability, snippet_with_context};
 use clippy_utils::ty::{can_partially_move_ty, is_type_diagnostic_item, peel_mid_ty_refs_is_mutable};
-use clippy_utils::{is_allowed, match_def_path, match_var, paths, peel_hir_expr_refs};
+use clippy_utils::{is_allowed, is_else_clause_of_if_let_else, match_def_path, match_var, paths, peel_hir_expr_refs};
 use rustc_ast::util::parser::PREC_POSTFIX;
 use rustc_errors::Applicability;
 use rustc_hir::{
     def::Res,
     intravisit::{walk_expr, ErasedMap, NestedVisitorMap, Visitor},
-    Arm, BindingAnnotation, Block, Expr, ExprKind, Mutability, Pat, PatKind, Path, QPath,
+    Arm, BindingAnnotation, Block, Expr, ExprKind, MatchSource, Mutability, Pat, PatKind, Path, QPath,
 };
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
@@ -51,8 +51,11 @@ impl LateLintPass<'_> for ManualMap {
             return;
         }
 
-        if let ExprKind::Match(scrutinee, [arm1 @ Arm { guard: None, .. }, arm2 @ Arm { guard: None, .. }], _) =
-            expr.kind
+        if let ExprKind::Match(
+            scrutinee,
+            [arm1 @ Arm { guard: None, .. }, arm2 @ Arm { guard: None, .. }],
+            match_kind,
+        ) = expr.kind
         {
             let (scrutinee_ty, ty_ref_count, ty_mutability) =
                 peel_mid_ty_refs_is_mutable(cx.typeck_results().expr_ty(scrutinee));
@@ -178,7 +181,12 @@ impl LateLintPass<'_> for ManualMap {
                 expr.span,
                 "manual implementation of `Option::map`",
                 "try this",
-                format!("{}{}.map({})", scrutinee_str, as_ref_str, body_str),
+                if matches!(match_kind, MatchSource::IfLetDesugar { .. }) && is_else_clause_of_if_let_else(cx.tcx, expr)
+                {
+                    format!("{{ {}{}.map({}) }}", scrutinee_str, as_ref_str, body_str)
+                } else {
+                    format!("{}{}.map({})", scrutinee_str, as_ref_str, body_str)
+                },
                 app,
             );
         }
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 3efa84f6b86..d5a5430546d 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -798,6 +798,26 @@ pub fn get_parent_as_impl(tcx: TyCtxt<'_>, id: HirId) -> Option<&Impl<'_>> {
     }
 }
 
+/// Checks if the given expression is the else clause in the expression `if let .. {} else {}`
+pub fn is_else_clause_of_if_let_else(tcx: TyCtxt<'_>, expr: &Expr<'_>) -> bool {
+    let map = tcx.hir();
+    let mut iter = map.parent_iter(expr.hir_id);
+    let arm_id = match iter.next() {
+        Some((id, Node::Arm(..))) => id,
+        _ => return false,
+    };
+    match iter.next() {
+        Some((
+            _,
+            Node::Expr(Expr {
+                kind: ExprKind::Match(_, [_, else_arm], kind),
+                ..
+            }),
+        )) => else_arm.hir_id == arm_id && matches!(kind, MatchSource::IfLetDesugar { .. }),
+        _ => false,
+    }
+}
+
 /// Checks whether the given expression is a constant integer of the given value.
 /// unlike `is_integer_literal`, this version does const folding
 pub fn is_integer_const(cx: &LateContext<'_>, e: &Expr<'_>, value: u128) -> bool {
diff --git a/tests/ui/manual_map_option.fixed b/tests/ui/manual_map_option.fixed
index 9222aaf6c78..acb6a580ceb 100644
--- a/tests/ui/manual_map_option.fixed
+++ b/tests/ui/manual_map_option.fixed
@@ -128,4 +128,9 @@ fn main() {
             None => None,
         };
     }
+
+    // #6847
+    if Some(0).is_some() {
+        Some(0)
+    } else { Some(0).map(|x| x + 1) };
 }
diff --git a/tests/ui/manual_map_option.rs b/tests/ui/manual_map_option.rs
index 1ccb450619c..3299e617707 100644
--- a/tests/ui/manual_map_option.rs
+++ b/tests/ui/manual_map_option.rs
@@ -186,4 +186,13 @@ fn main() {
             None => None,
         };
     }
+
+    // #6847
+    if let Some(_) = Some(0) {
+        Some(0)
+    } else if let Some(x) = Some(0) {
+        Some(x + 1)
+    } else {
+        None
+    };
 }
diff --git a/tests/ui/manual_map_option.stderr b/tests/ui/manual_map_option.stderr
index d9f86eecd93..048ccfb9582 100644
--- a/tests/ui/manual_map_option.stderr
+++ b/tests/ui/manual_map_option.stderr
@@ -172,5 +172,24 @@ LL | |         None => None,
 LL | |     };
    | |_____^ help: try this: `option_env!("").map(String::from)`
 
-error: aborting due to 19 previous errors
+error: redundant pattern matching, consider using `is_some()`
+  --> $DIR/manual_map_option.rs:191:12
+   |
+LL |     if let Some(_) = Some(0) {
+   |     -------^^^^^^^---------- help: try this: `if Some(0).is_some()`
+   |
+   = note: `-D clippy::redundant-pattern-matching` implied by `-D warnings`
+
+error: manual implementation of `Option::map`
+  --> $DIR/manual_map_option.rs:193:12
+   |
+LL |       } else if let Some(x) = Some(0) {
+   |  ____________^
+LL | |         Some(x + 1)
+LL | |     } else {
+LL | |         None
+LL | |     };
+   | |_____^ help: try this: `{ Some(0).map(|x| x + 1) }`
+
+error: aborting due to 21 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From ea15fb2177b0c33352363c130bc296a0dd1a794a Mon Sep 17 00:00:00 2001
From: Mateusz Gacek <96mateusz.gacek@gmail.com>
Date: Wed, 17 Mar 2021 15:52:14 +0100
Subject: wrong_self_convention: `to_` respects `Copy` types

More details here:
https://rust-lang.github.io/api-guidelines/naming.html#ad-hoc-conversions-follow-as_-to_-into_-conventions-c-conv
---
 clippy_lints/src/methods/mod.rs                   | 39 +++++++-----
 clippy_lints/src/methods/wrong_self_convention.rs | 74 +++++++++++++----------
 tests/ui/use_self.fixed                           |  1 +
 tests/ui/use_self.rs                              |  1 +
 tests/ui/use_self.stderr                          | 46 +++++++-------
 tests/ui/wrong_self_convention.rs                 | 32 ++++++++++
 tests/ui/wrong_self_convention.stderr             | 36 +++++------
 tests/ui/wrong_self_conventions_mut.stderr        |  4 +-
 8 files changed, 143 insertions(+), 90 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index af8fe7abd96..722effc29b2 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -193,14 +193,18 @@ declare_clippy_lint! {
     /// **What it does:** Checks for methods with certain name prefixes and which
     /// doesn't match how self is taken. The actual rules are:
     ///
-    /// |Prefix |Postfix     |`self` taken          |
-    /// |-------|------------|----------------------|
-    /// |`as_`  | none       |`&self` or `&mut self`|
-    /// |`from_`| none       | none                 |
-    /// |`into_`| none       |`self`                |
-    /// |`is_`  | none       |`&self` or none       |
-    /// |`to_`  | `_mut`     |`&mut &self`          |
-    /// |`to_`  | not `_mut` |`&self`               |
+    /// |Prefix |Postfix     |`self` taken           | `self` type  |
+    /// |-------|------------|-----------------------|--------------|
+    /// |`as_`  | none       |`&self` or `&mut self` | any          |
+    /// |`from_`| none       | none                  | any          |
+    /// |`into_`| none       |`self`                 | any          |
+    /// |`is_`  | none       |`&self` or none        | any          |
+    /// |`to_`  | `_mut`     |`&mut self`            | any          |
+    /// |`to_`  | not `_mut` |`self`                 | `Copy`       |
+    /// |`to_`  | not `_mut` |`&self`                | not `Copy`   |
+    ///
+    /// Please find more info here:
+    /// https://rust-lang.github.io/api-guidelines/naming.html#ad-hoc-conversions-follow-as_-to_-into_-conventions-c-conv
     ///
     /// **Why is this bad?** Consistency breeds readability. If you follow the
     /// conventions, your users won't be surprised that they, e.g., need to supply a
@@ -1837,10 +1841,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
         let item = cx.tcx.hir().expect_item(parent);
         let self_ty = cx.tcx.type_of(item.def_id);
 
-        // if this impl block implements a trait, lint in trait definition instead
-        if let hir::ItemKind::Impl(hir::Impl { of_trait: Some(_), .. }) = item.kind {
-            return;
-        }
+        let implements_trait = matches!(item.kind, hir::ItemKind::Impl(hir::Impl { of_trait: Some(_), .. }));
 
         if_chain! {
             if let hir::ImplItemKind::Fn(ref sig, id) = impl_item.kind;
@@ -1855,7 +1856,8 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             if let Some(first_arg_ty) = first_arg_ty;
 
             then {
-                if cx.access_levels.is_exported(impl_item.hir_id()) {
+                // if this impl block implements a trait, lint in trait definition instead
+                if !implements_trait && cx.access_levels.is_exported(impl_item.hir_id()) {
                     // check missing trait implementations
                     for method_config in &TRAIT_METHODS {
                         if name == method_config.method_name &&
@@ -1891,11 +1893,17 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
                     item.vis.node.is_pub(),
                     self_ty,
                     first_arg_ty,
-                    first_arg.pat.span
+                    first_arg.pat.span,
+                    false
                 );
             }
         }
 
+        // if this impl block implements a trait, lint in trait definition instead
+        if implements_trait {
+            return;
+        }
+
         if let hir::ImplItemKind::Fn(_, _) = impl_item.kind {
             let ret_ty = return_ty(cx, impl_item.hir_id());
 
@@ -1947,7 +1955,8 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
                     false,
                     self_ty,
                     first_arg_ty,
-                    first_arg_span
+                    first_arg_span,
+                    true
                 );
             }
         }
diff --git a/clippy_lints/src/methods/wrong_self_convention.rs b/clippy_lints/src/methods/wrong_self_convention.rs
index b728d7d8d08..bece8f251da 100644
--- a/clippy_lints/src/methods/wrong_self_convention.rs
+++ b/clippy_lints/src/methods/wrong_self_convention.rs
@@ -1,5 +1,6 @@
 use crate::methods::SelfKind;
 use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::ty::is_copy;
 use rustc_lint::LateContext;
 use rustc_middle::ty::TyS;
 use rustc_span::source_map::Span;
@@ -9,7 +10,7 @@ use super::WRONG_PUB_SELF_CONVENTION;
 use super::WRONG_SELF_CONVENTION;
 
 #[rustfmt::skip]
-const CONVENTIONS: [(&[Convention], &[SelfKind]); 8] = [
+const CONVENTIONS: [(&[Convention], &[SelfKind]); 9] = [
     (&[Convention::Eq("new")], &[SelfKind::No]),
     (&[Convention::StartsWith("as_")], &[SelfKind::Ref, SelfKind::RefMut]),
     (&[Convention::StartsWith("from_")], &[SelfKind::No]),
@@ -17,7 +18,11 @@ const CONVENTIONS: [(&[Convention], &[SelfKind]); 8] = [
     (&[Convention::StartsWith("is_")], &[SelfKind::Ref, SelfKind::No]),
     (&[Convention::Eq("to_mut")], &[SelfKind::RefMut]),
     (&[Convention::StartsWith("to_"), Convention::EndsWith("_mut")], &[SelfKind::RefMut]),
-    (&[Convention::StartsWith("to_"), Convention::NotEndsWith("_mut")], &[SelfKind::Ref]),
+
+    // Conversion using `to_` can use borrowed (non-Copy types) or owned (Copy types).
+    // Source: https://rust-lang.github.io/api-guidelines/naming.html#ad-hoc-conversions-follow-as_-to_-into_-conventions-c-conv
+    (&[Convention::StartsWith("to_"), Convention::NotEndsWith("_mut"), Convention::IsSelfTypeCopy(false), Convention::ImplementsTrait(false)], &[SelfKind::Ref]),
+    (&[Convention::StartsWith("to_"), Convention::NotEndsWith("_mut"), Convention::IsSelfTypeCopy(true), Convention::ImplementsTrait(false)], &[SelfKind::Value]),
 ];
 
 enum Convention {
@@ -25,16 +30,20 @@ enum Convention {
     StartsWith(&'static str),
     EndsWith(&'static str),
     NotEndsWith(&'static str),
+    IsSelfTypeCopy(bool),
+    ImplementsTrait(bool),
 }
 
 impl Convention {
     #[must_use]
-    fn check(&self, other: &str) -> bool {
+    fn check<'tcx>(&self, cx: &LateContext<'tcx>, self_ty: &'tcx TyS<'tcx>, other: &str, is_trait_def: bool) -> bool {
         match *self {
             Self::Eq(this) => this == other,
             Self::StartsWith(this) => other.starts_with(this) && this != other,
             Self::EndsWith(this) => other.ends_with(this) && this != other,
-            Self::NotEndsWith(this) => !Self::EndsWith(this).check(other),
+            Self::NotEndsWith(this) => !Self::EndsWith(this).check(cx, self_ty, other, is_trait_def),
+            Self::IsSelfTypeCopy(is_true) => is_true == is_copy(cx, self_ty),
+            Self::ImplementsTrait(is_true) => is_true == is_trait_def,
         }
     }
 }
@@ -46,6 +55,10 @@ impl fmt::Display for Convention {
             Self::StartsWith(this) => this.fmt(f).and_then(|_| '*'.fmt(f)),
             Self::EndsWith(this) => '*'.fmt(f).and_then(|_| this.fmt(f)),
             Self::NotEndsWith(this) => '~'.fmt(f).and_then(|_| this.fmt(f)),
+            Self::IsSelfTypeCopy(is_true) => format!("self type is {} Copy", if is_true { "" } else { "not" }).fmt(f),
+            Self::ImplementsTrait(is_true) => {
+                format!("Method {} implement a trait", if is_true { "" } else { "do not" }).fmt(f)
+            },
         }
     }
 }
@@ -57,45 +70,42 @@ pub(super) fn check<'tcx>(
     self_ty: &'tcx TyS<'tcx>,
     first_arg_ty: &'tcx TyS<'tcx>,
     first_arg_span: Span,
+    is_trait_item: bool,
 ) {
     let lint = if is_pub {
         WRONG_PUB_SELF_CONVENTION
     } else {
         WRONG_SELF_CONVENTION
     };
-    if let Some((conventions, self_kinds)) = &CONVENTIONS
-        .iter()
-        .find(|(convs, _)| convs.iter().all(|conv| conv.check(item_name)))
-    {
+    if let Some((conventions, self_kinds)) = &CONVENTIONS.iter().find(|(convs, _)| {
+        convs
+            .iter()
+            .all(|conv| conv.check(cx, self_ty, item_name, is_trait_item))
+    }) {
         if !self_kinds.iter().any(|k| k.matches(cx, self_ty, first_arg_ty)) {
             let suggestion = {
                 if conventions.len() > 1 {
-                    let special_case = {
-                        // Don't mention `NotEndsWith` when there is also `StartsWith` convention present
-                        if conventions.len() == 2 {
-                            match conventions {
-                                [Convention::StartsWith(starts_with), Convention::NotEndsWith(_)]
-                                | [Convention::NotEndsWith(_), Convention::StartsWith(starts_with)] => {
-                                    Some(format!("methods called `{}`", Convention::StartsWith(starts_with)))
-                                },
-                                _ => None,
-                            }
-                        } else {
-                            None
-                        }
-                    };
-
-                    if let Some(suggestion) = special_case {
-                        suggestion
-                    } else {
-                        let s = conventions
+                    // Don't mention `NotEndsWith` when there is also `StartsWith` convention present
+                    let cut_ends_with_conv = conventions.iter().any(|conv| matches!(conv, Convention::StartsWith(_)))
+                        && conventions
                             .iter()
-                            .map(|c| format!("`{}`", &c.to_string()))
-                            .collect::<Vec<_>>()
-                            .join(" and ");
+                            .any(|conv| matches!(conv, Convention::NotEndsWith(_)));
+
+                    let s = conventions
+                        .iter()
+                        .filter_map(|conv| {
+                            if (cut_ends_with_conv && matches!(conv, Convention::NotEndsWith(_)))
+                                || matches!(conv, Convention::ImplementsTrait(_))
+                            {
+                                None
+                            } else {
+                                Some(format!("`{}`", &conv.to_string()))
+                            }
+                        })
+                        .collect::<Vec<_>>()
+                        .join(" and ");
 
-                        format!("methods called like this: ({})", &s)
-                    }
+                    format!("methods with the following characteristics: ({})", &s)
                 } else {
                     format!("methods called `{}`", &conventions[0])
                 }
diff --git a/tests/ui/use_self.fixed b/tests/ui/use_self.fixed
index a630936e3b1..1986b54e66c 100644
--- a/tests/ui/use_self.fixed
+++ b/tests/ui/use_self.fixed
@@ -79,6 +79,7 @@ mod issue2894 {
     }
 
     // This should not be linted
+    #[allow(clippy::wrong_self_convention)]
     impl IntoBytes for u8 {
         fn to_bytes(&self) -> Vec<u8> {
             vec![*self]
diff --git a/tests/ui/use_self.rs b/tests/ui/use_self.rs
index f3e081dd203..acc18280f1a 100644
--- a/tests/ui/use_self.rs
+++ b/tests/ui/use_self.rs
@@ -79,6 +79,7 @@ mod issue2894 {
     }
 
     // This should not be linted
+    #[allow(clippy::wrong_self_convention)]
     impl IntoBytes for u8 {
         fn to_bytes(&self) -> Vec<u8> {
             vec![*self]
diff --git a/tests/ui/use_self.stderr b/tests/ui/use_self.stderr
index e1410d2e652..a2c95963487 100644
--- a/tests/ui/use_self.stderr
+++ b/tests/ui/use_self.stderr
@@ -37,139 +37,139 @@ LL |             Foo::new()
    |             ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:93:24
+  --> $DIR/use_self.rs:94:24
    |
 LL |         fn bad(foos: &[Foo]) -> impl Iterator<Item = &Foo> {
    |                        ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:93:55
+  --> $DIR/use_self.rs:94:55
    |
 LL |         fn bad(foos: &[Foo]) -> impl Iterator<Item = &Foo> {
    |                                                       ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:108:13
+  --> $DIR/use_self.rs:109:13
    |
 LL |             TS(0)
    |             ^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:143:29
+  --> $DIR/use_self.rs:144:29
    |
 LL |                 fn bar() -> Bar {
    |                             ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:144:21
+  --> $DIR/use_self.rs:145:21
    |
 LL |                     Bar { foo: Foo {} }
    |                     ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:155:21
+  --> $DIR/use_self.rs:156:21
    |
 LL |         fn baz() -> Foo {
    |                     ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:156:13
+  --> $DIR/use_self.rs:157:13
    |
 LL |             Foo {}
    |             ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:173:21
+  --> $DIR/use_self.rs:174:21
    |
 LL |             let _ = Enum::B(42);
    |                     ^^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:174:21
+  --> $DIR/use_self.rs:175:21
    |
 LL |             let _ = Enum::C { field: true };
    |                     ^^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:175:21
+  --> $DIR/use_self.rs:176:21
    |
 LL |             let _ = Enum::A;
    |                     ^^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:217:13
+  --> $DIR/use_self.rs:218:13
    |
 LL |             nested::A::fun_1();
    |             ^^^^^^^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:218:13
+  --> $DIR/use_self.rs:219:13
    |
 LL |             nested::A::A;
    |             ^^^^^^^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:220:13
+  --> $DIR/use_self.rs:221:13
    |
 LL |             nested::A {};
    |             ^^^^^^^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:239:13
+  --> $DIR/use_self.rs:240:13
    |
 LL |             TestStruct::from_something()
    |             ^^^^^^^^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:253:25
+  --> $DIR/use_self.rs:254:25
    |
 LL |         async fn g() -> S {
    |                         ^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:254:13
+  --> $DIR/use_self.rs:255:13
    |
 LL |             S {}
    |             ^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:258:16
+  --> $DIR/use_self.rs:259:16
    |
 LL |             &p[S::A..S::B]
    |                ^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:258:22
+  --> $DIR/use_self.rs:259:22
    |
 LL |             &p[S::A..S::B]
    |                      ^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:281:29
+  --> $DIR/use_self.rs:282:29
    |
 LL |         fn foo(value: T) -> Foo<T> {
    |                             ^^^^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:282:13
+  --> $DIR/use_self.rs:283:13
    |
 LL |             Foo { value }
    |             ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:319:21
+  --> $DIR/use_self.rs:320:21
    |
 LL |         type From = T::From;
    |                     ^^^^^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:320:19
+  --> $DIR/use_self.rs:321:19
    |
 LL |         type To = T::To;
    |                   ^^^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:453:13
+  --> $DIR/use_self.rs:454:13
    |
 LL |             A::new::<submod::B>(submod::B {})
    |             ^ help: use the applicable keyword: `Self`
diff --git a/tests/ui/wrong_self_convention.rs b/tests/ui/wrong_self_convention.rs
index 6cfc0fcb4ca..ba9e19a1722 100644
--- a/tests/ui/wrong_self_convention.rs
+++ b/tests/ui/wrong_self_convention.rs
@@ -163,3 +163,35 @@ mod issue6307 {
         fn to_mut(&mut self);
     }
 }
+
+mod issue6727 {
+    trait ToU64 {
+        fn to_u64(self) -> u64;
+        fn to_u64_v2(&self) -> u64;
+    }
+
+    #[derive(Clone, Copy)]
+    struct FooCopy;
+
+    impl ToU64 for FooCopy {
+        fn to_u64(self) -> u64 {
+            1
+        }
+        // trigger lint
+        fn to_u64_v2(&self) -> u64 {
+            1
+        }
+    }
+
+    struct FooNoCopy;
+
+    impl ToU64 for FooNoCopy {
+        // trigger lint
+        fn to_u64(self) -> u64 {
+            2
+        }
+        fn to_u64_v2(&self) -> u64 {
+            2
+        }
+    }
+}
diff --git a/tests/ui/wrong_self_convention.stderr b/tests/ui/wrong_self_convention.stderr
index f43fea0d513..6daa334ed48 100644
--- a/tests/ui/wrong_self_convention.stderr
+++ b/tests/ui/wrong_self_convention.stderr
@@ -39,7 +39,7 @@ LL |     fn is_i32(self) {}
    |
    = help: consider choosing a less ambiguous name
 
-error: methods called `to_*` usually take self by reference
+error: methods with the following characteristics: (`to_*` and `self type is not Copy`) usually take self by reference
   --> $DIR/wrong_self_convention.rs:42:15
    |
 LL |     fn to_i32(self) {}
@@ -79,7 +79,7 @@ LL |     pub fn is_i64(self) {}
    |
    = help: consider choosing a less ambiguous name
 
-error: methods called `to_*` usually take self by reference
+error: methods with the following characteristics: (`to_*` and `self type is not Copy`) usually take self by reference
   --> $DIR/wrong_self_convention.rs:49:19
    |
 LL |     pub fn to_i64(self) {}
@@ -119,14 +119,6 @@ LL |         fn is_i32(self) {}
    |
    = help: consider choosing a less ambiguous name
 
-error: methods called `to_*` usually take self by reference
-  --> $DIR/wrong_self_convention.rs:102:19
-   |
-LL |         fn to_i32(self) {}
-   |                   ^^^^
-   |
-   = help: consider choosing a less ambiguous name
-
 error: methods called `from_*` usually take no self
   --> $DIR/wrong_self_convention.rs:104:21
    |
@@ -159,14 +151,6 @@ LL |         fn is_i32(self);
    |
    = help: consider choosing a less ambiguous name
 
-error: methods called `to_*` usually take self by reference
-  --> $DIR/wrong_self_convention.rs:126:19
-   |
-LL |         fn to_i32(self);
-   |                   ^^^^
-   |
-   = help: consider choosing a less ambiguous name
-
 error: methods called `from_*` usually take no self
   --> $DIR/wrong_self_convention.rs:128:21
    |
@@ -191,5 +175,21 @@ LL |         fn from_i32(self);
    |
    = help: consider choosing a less ambiguous name
 
+error: methods with the following characteristics: (`to_*` and `self type is  Copy`) usually take self by value
+  --> $DIR/wrong_self_convention.rs:181:22
+   |
+LL |         fn to_u64_v2(&self) -> u64 {
+   |                      ^^^^^
+   |
+   = help: consider choosing a less ambiguous name
+
+error: methods with the following characteristics: (`to_*` and `self type is not Copy`) usually take self by reference
+  --> $DIR/wrong_self_convention.rs:190:19
+   |
+LL |         fn to_u64(self) -> u64 {
+   |                   ^^^^
+   |
+   = help: consider choosing a less ambiguous name
+
 error: aborting due to 24 previous errors
 
diff --git a/tests/ui/wrong_self_conventions_mut.stderr b/tests/ui/wrong_self_conventions_mut.stderr
index 7662b38e67d..8095188758c 100644
--- a/tests/ui/wrong_self_conventions_mut.stderr
+++ b/tests/ui/wrong_self_conventions_mut.stderr
@@ -1,4 +1,4 @@
-error: methods called `to_*` usually take self by reference
+error: methods with the following characteristics: (`to_*` and `self type is not Copy`) usually take self by reference
   --> $DIR/wrong_self_conventions_mut.rs:15:24
    |
 LL |         pub fn to_many(&mut self) -> Option<&mut [T]> {
@@ -7,7 +7,7 @@ LL |         pub fn to_many(&mut self) -> Option<&mut [T]> {
    = note: `-D clippy::wrong-self-convention` implied by `-D warnings`
    = help: consider choosing a less ambiguous name
 
-error: methods called like this: (`to_*` and `*_mut`) usually take self by mutable reference
+error: methods with the following characteristics: (`to_*` and `*_mut`) usually take self by mutable reference
   --> $DIR/wrong_self_conventions_mut.rs:23:28
    |
 LL |         pub fn to_many_mut(&self) -> Option<&[T]> {
-- 
cgit 1.4.1-3-g733a5


From b1f89ee02ff05d559a27949601bef628e498b128 Mon Sep 17 00:00:00 2001
From: Mateusz Gacek <96mateusz.gacek@gmail.com>
Date: Wed, 17 Mar 2021 20:29:31 +0100
Subject: or_fun_call: trigger on unsafe blocks

---
 clippy_lints/src/methods/or_fun_call.rs | 13 +++++++++++--
 tests/ui/or_fun_call.fixed              | 14 ++++++++++++++
 tests/ui/or_fun_call.rs                 | 14 ++++++++++++++
 tests/ui/or_fun_call.stderr             | 20 +++++++++++++++++++-
 4 files changed, 58 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/or_fun_call.rs b/clippy_lints/src/methods/or_fun_call.rs
index 1b43802a08e..22df3e028f9 100644
--- a/clippy_lints/src/methods/or_fun_call.rs
+++ b/clippy_lints/src/methods/or_fun_call.rs
@@ -6,6 +6,7 @@ use clippy_utils::ty::{implements_trait, is_type_diagnostic_item, match_type};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
+use rustc_hir::{BlockCheckMode, UnsafeSource};
 use rustc_lint::LateContext;
 use rustc_middle::ty;
 use rustc_span::source_map::Span;
@@ -154,7 +155,6 @@ pub(super) fn check<'tcx>(
             }
         }
     }
-
     if args.len() == 2 {
         match args[1].kind {
             hir::ExprKind::Call(ref fun, ref or_args) => {
@@ -167,7 +167,16 @@ pub(super) fn check<'tcx>(
             hir::ExprKind::Index(..) | hir::ExprKind::MethodCall(..) => {
                 check_general_case(cx, name, method_span, &args[0], &args[1], expr.span, None);
             },
-            _ => {},
+            hir::ExprKind::Block(block, _) => {
+                if let BlockCheckMode::UnsafeBlock(UnsafeSource::UserProvided) = block.rules {
+                    if let Some(block_expr) = block.expr {
+                        if let hir::ExprKind::MethodCall(..) = block_expr.kind {
+                            check_general_case(cx, name, method_span, &args[0], &args[1], expr.span, None);
+                        }
+                    }
+                }
+            },
+            _ => (),
         }
     }
 }
diff --git a/tests/ui/or_fun_call.fixed b/tests/ui/or_fun_call.fixed
index 64347cae5da..660245f10c3 100644
--- a/tests/ui/or_fun_call.fixed
+++ b/tests/ui/or_fun_call.fixed
@@ -132,4 +132,18 @@ fn f() -> Option<()> {
     Some(())
 }
 
+mod issue6675 {
+    unsafe fn foo() {
+        let mut s = "test".to_owned();
+        None.unwrap_or_else(|| s.as_mut_vec());
+    }
+
+    fn bar() {
+        let mut s = "test".to_owned();
+        None.unwrap_or_else(|| unsafe { s.as_mut_vec() });
+        #[rustfmt::skip]
+        None.unwrap_or_else(|| unsafe { s.as_mut_vec() });
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/or_fun_call.rs b/tests/ui/or_fun_call.rs
index 7faab0017b2..c589b170bdd 100644
--- a/tests/ui/or_fun_call.rs
+++ b/tests/ui/or_fun_call.rs
@@ -132,4 +132,18 @@ fn f() -> Option<()> {
     Some(())
 }
 
+mod issue6675 {
+    unsafe fn foo() {
+        let mut s = "test".to_owned();
+        None.unwrap_or(s.as_mut_vec());
+    }
+
+    fn bar() {
+        let mut s = "test".to_owned();
+        None.unwrap_or(unsafe { s.as_mut_vec() });
+        #[rustfmt::skip]
+        None.unwrap_or( unsafe { s.as_mut_vec() }    );
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/or_fun_call.stderr b/tests/ui/or_fun_call.stderr
index 1e2bfd490e0..d63b3443592 100644
--- a/tests/ui/or_fun_call.stderr
+++ b/tests/ui/or_fun_call.stderr
@@ -114,5 +114,23 @@ error: use of `or` followed by a function call
 LL |         .or(Some(Bar(b, Duration::from_secs(2))));
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `or_else(|| Some(Bar(b, Duration::from_secs(2))))`
 
-error: aborting due to 19 previous errors
+error: use of `unwrap_or` followed by a function call
+  --> $DIR/or_fun_call.rs:138:14
+   |
+LL |         None.unwrap_or(s.as_mut_vec());
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|| s.as_mut_vec())`
+
+error: use of `unwrap_or` followed by a function call
+  --> $DIR/or_fun_call.rs:143:14
+   |
+LL |         None.unwrap_or(unsafe { s.as_mut_vec() });
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|| unsafe { s.as_mut_vec() })`
+
+error: use of `unwrap_or` followed by a function call
+  --> $DIR/or_fun_call.rs:145:14
+   |
+LL |         None.unwrap_or( unsafe { s.as_mut_vec() }    );
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|| unsafe { s.as_mut_vec() })`
+
+error: aborting due to 22 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From b42ec5e04d51e2fa16a689ce61128533559f09ff Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Thu, 18 Mar 2021 23:01:42 +0100
Subject: needless_question_mark: don't lint if Some(..) is inside a macro def
 and the ? is not.

The suggestion would fail to apply.

Fixes #6921

changelog: needless_question_mark: don't lint if Some(..) is inside a macro def and the ? is not.
---
 clippy_lints/src/needless_question_mark.rs |  7 ++++++-
 tests/ui/needless_question_mark.fixed      | 25 +++++++++++++++++++++++++
 tests/ui/needless_question_mark.rs         | 25 +++++++++++++++++++++++++
 tests/ui/needless_question_mark.stderr     | 13 ++++++++++++-
 4 files changed, 68 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/needless_question_mark.rs b/clippy_lints/src/needless_question_mark.rs
index 99e85e6683c..9852633b734 100644
--- a/clippy_lints/src/needless_question_mark.rs
+++ b/clippy_lints/src/needless_question_mark.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{is_ok_ctor, is_some_ctor, meets_msrv};
+use clippy_utils::{differing_macro_contexts, is_ok_ctor, is_some_ctor, meets_msrv};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Body, Expr, ExprKind, LangItem, MatchSource, QPath};
@@ -173,6 +173,11 @@ fn is_some_or_ok_call<'a>(
             // question mark operator
             let inner_expr = &args[0];
 
+            // if the inner expr is inside macro but the outer one is not, do not lint (#6921)
+            if  differing_macro_contexts(expr.span, inner_expr.span) {
+                return None;
+            }
+
             let inner_ty = cx.typeck_results().expr_ty(inner_expr);
             let outer_ty = cx.typeck_results().expr_ty(expr);
 
diff --git a/tests/ui/needless_question_mark.fixed b/tests/ui/needless_question_mark.fixed
index 71fb3565224..fd8433870bb 100644
--- a/tests/ui/needless_question_mark.fixed
+++ b/tests/ui/needless_question_mark.fixed
@@ -167,3 +167,28 @@ mod question_mark_both {
         needless_question_mark_result();
     }
 }
+
+// #6921 if a macro wraps an expr in Some(  ) and the ? is in the macro use,
+// the suggestion fails to apply; do not lint
+macro_rules! some_in_macro {
+    ($expr:expr) => {
+        || -> _ { Some($expr) }()
+    };
+}
+
+pub fn test1() {
+    let x = Some(3);
+    let _x = some_in_macro!(x?);
+}
+
+// this one is ok because both the ? and the Some are both inside the macro def
+macro_rules! some_and_qmark_in_macro {
+    ($expr:expr) => {
+        || -> Option<_> { Some($expr) }()
+    };
+}
+
+pub fn test2() {
+    let x = Some(3);
+    let _x = some_and_qmark_in_macro!(x?);
+}
diff --git a/tests/ui/needless_question_mark.rs b/tests/ui/needless_question_mark.rs
index e31f6f48fa7..36d45ac7e03 100644
--- a/tests/ui/needless_question_mark.rs
+++ b/tests/ui/needless_question_mark.rs
@@ -167,3 +167,28 @@ mod question_mark_both {
         needless_question_mark_result();
     }
 }
+
+// #6921 if a macro wraps an expr in Some(  ) and the ? is in the macro use,
+// the suggestion fails to apply; do not lint
+macro_rules! some_in_macro {
+    ($expr:expr) => {
+        || -> _ { Some($expr) }()
+    };
+}
+
+pub fn test1() {
+    let x = Some(3);
+    let _x = some_in_macro!(x?);
+}
+
+// this one is ok because both the ? and the Some are both inside the macro def
+macro_rules! some_and_qmark_in_macro {
+    ($expr:expr) => {
+        || -> Option<_> { Some(Some($expr)?) }()
+    };
+}
+
+pub fn test2() {
+    let x = Some(3);
+    let _x = some_and_qmark_in_macro!(x?);
+}
diff --git a/tests/ui/needless_question_mark.stderr b/tests/ui/needless_question_mark.stderr
index 983c56031d8..7cbf1e505ad 100644
--- a/tests/ui/needless_question_mark.stderr
+++ b/tests/ui/needless_question_mark.stderr
@@ -84,5 +84,16 @@ error: question mark operator is useless here
 LL |         Ok(to.magic?) // should be triggered
    |         ^^^^^^^^^^^^^ help: try: `to.magic`
 
-error: aborting due to 14 previous errors
+error: question mark operator is useless here
+  --> $DIR/needless_question_mark.rs:187:27
+   |
+LL |         || -> Option<_> { Some(Some($expr)?) }()
+   |                           ^^^^^^^^^^^^^^^^^^ help: try: `Some($expr)`
+...
+LL |     let _x = some_and_qmark_in_macro!(x?);
+   |              ---------------------------- in this macro invocation
+   |
+   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: aborting due to 15 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 1f2d01641d6ef2f283265eb603c7d231692b6a89 Mon Sep 17 00:00:00 2001
From: Mateusz Gacek <96mateusz.gacek@gmail.com>
Date: Thu, 18 Mar 2021 19:45:13 +0100
Subject: wrong_self_convention: Enhance lint message

---
 clippy_lints/src/methods/mod.rs                   |  8 ++--
 clippy_lints/src/methods/wrong_self_convention.rs | 19 +++++----
 tests/ui/def_id_nocore.stderr                     |  2 +-
 tests/ui/wrong_self_convention.stderr             | 48 +++++++++++------------
 tests/ui/wrong_self_conventions_mut.stderr        |  4 +-
 5 files changed, 42 insertions(+), 39 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 722effc29b2..a3652c18a78 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -2348,10 +2348,10 @@ impl SelfKind {
     #[must_use]
     fn description(self) -> &'static str {
         match self {
-            Self::Value => "self by value",
-            Self::Ref => "self by reference",
-            Self::RefMut => "self by mutable reference",
-            Self::No => "no self",
+            Self::Value => "`self` by value",
+            Self::Ref => "`self` by reference",
+            Self::RefMut => "`self` by mutable reference",
+            Self::No => "no `self`",
         }
     }
 }
diff --git a/clippy_lints/src/methods/wrong_self_convention.rs b/clippy_lints/src/methods/wrong_self_convention.rs
index bece8f251da..59e683aa9a7 100644
--- a/clippy_lints/src/methods/wrong_self_convention.rs
+++ b/clippy_lints/src/methods/wrong_self_convention.rs
@@ -51,13 +51,16 @@ impl Convention {
 impl fmt::Display for Convention {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
         match *self {
-            Self::Eq(this) => this.fmt(f),
-            Self::StartsWith(this) => this.fmt(f).and_then(|_| '*'.fmt(f)),
-            Self::EndsWith(this) => '*'.fmt(f).and_then(|_| this.fmt(f)),
-            Self::NotEndsWith(this) => '~'.fmt(f).and_then(|_| this.fmt(f)),
-            Self::IsSelfTypeCopy(is_true) => format!("self type is {} Copy", if is_true { "" } else { "not" }).fmt(f),
+            Self::Eq(this) => format!("`{}`", this).fmt(f),
+            Self::StartsWith(this) => format!("`{}*`", this).fmt(f),
+            Self::EndsWith(this) => format!("`*{}`", this).fmt(f),
+            Self::NotEndsWith(this) => format!("`~{}`", this).fmt(f),
+            Self::IsSelfTypeCopy(is_true) => {
+                format!("`self` type is{} `Copy`", if is_true { "" } else { " not" }).fmt(f)
+            },
             Self::ImplementsTrait(is_true) => {
-                format!("Method {} implement a trait", if is_true { "" } else { "do not" }).fmt(f)
+                let (negation, s_suffix) = if is_true { ("", "s") } else { (" does not", "") };
+                format!("Method{} implement{} a trait", negation, s_suffix).fmt(f)
             },
         }
     }
@@ -99,7 +102,7 @@ pub(super) fn check<'tcx>(
                             {
                                 None
                             } else {
-                                Some(format!("`{}`", &conv.to_string()))
+                                Some(conv.to_string())
                             }
                         })
                         .collect::<Vec<_>>()
@@ -107,7 +110,7 @@ pub(super) fn check<'tcx>(
 
                     format!("methods with the following characteristics: ({})", &s)
                 } else {
-                    format!("methods called `{}`", &conventions[0])
+                    format!("methods called {}", &conventions[0])
                 }
             };
 
diff --git a/tests/ui/def_id_nocore.stderr b/tests/ui/def_id_nocore.stderr
index a3e9cc75b08..702684f6b43 100644
--- a/tests/ui/def_id_nocore.stderr
+++ b/tests/ui/def_id_nocore.stderr
@@ -1,4 +1,4 @@
-error: methods called `as_*` usually take self by reference or self by mutable reference
+error: methods called `as_*` usually take `self` by reference or `self` by mutable reference
   --> $DIR/def_id_nocore.rs:26:19
    |
 LL |     pub fn as_ref(self) -> &'static str {
diff --git a/tests/ui/wrong_self_convention.stderr b/tests/ui/wrong_self_convention.stderr
index 6daa334ed48..1d58a12ac79 100644
--- a/tests/ui/wrong_self_convention.stderr
+++ b/tests/ui/wrong_self_convention.stderr
@@ -1,4 +1,4 @@
-error: methods called `from_*` usually take no self
+error: methods called `from_*` usually take no `self`
   --> $DIR/wrong_self_convention.rs:18:17
    |
 LL |     fn from_i32(self) {}
@@ -7,7 +7,7 @@ LL |     fn from_i32(self) {}
    = note: `-D clippy::wrong-self-convention` implied by `-D warnings`
    = help: consider choosing a less ambiguous name
 
-error: methods called `from_*` usually take no self
+error: methods called `from_*` usually take no `self`
   --> $DIR/wrong_self_convention.rs:24:21
    |
 LL |     pub fn from_i64(self) {}
@@ -15,7 +15,7 @@ LL |     pub fn from_i64(self) {}
    |
    = help: consider choosing a less ambiguous name
 
-error: methods called `as_*` usually take self by reference or self by mutable reference
+error: methods called `as_*` usually take `self` by reference or `self` by mutable reference
   --> $DIR/wrong_self_convention.rs:36:15
    |
 LL |     fn as_i32(self) {}
@@ -23,7 +23,7 @@ LL |     fn as_i32(self) {}
    |
    = help: consider choosing a less ambiguous name
 
-error: methods called `into_*` usually take self by value
+error: methods called `into_*` usually take `self` by value
   --> $DIR/wrong_self_convention.rs:38:17
    |
 LL |     fn into_i32(&self) {}
@@ -31,7 +31,7 @@ LL |     fn into_i32(&self) {}
    |
    = help: consider choosing a less ambiguous name
 
-error: methods called `is_*` usually take self by reference or no self
+error: methods called `is_*` usually take `self` by reference or no `self`
   --> $DIR/wrong_self_convention.rs:40:15
    |
 LL |     fn is_i32(self) {}
@@ -39,7 +39,7 @@ LL |     fn is_i32(self) {}
    |
    = help: consider choosing a less ambiguous name
 
-error: methods with the following characteristics: (`to_*` and `self type is not Copy`) usually take self by reference
+error: methods with the following characteristics: (`to_*` and `self` type is not `Copy`) usually take `self` by reference
   --> $DIR/wrong_self_convention.rs:42:15
    |
 LL |     fn to_i32(self) {}
@@ -47,7 +47,7 @@ LL |     fn to_i32(self) {}
    |
    = help: consider choosing a less ambiguous name
 
-error: methods called `from_*` usually take no self
+error: methods called `from_*` usually take no `self`
   --> $DIR/wrong_self_convention.rs:44:17
    |
 LL |     fn from_i32(self) {}
@@ -55,7 +55,7 @@ LL |     fn from_i32(self) {}
    |
    = help: consider choosing a less ambiguous name
 
-error: methods called `as_*` usually take self by reference or self by mutable reference
+error: methods called `as_*` usually take `self` by reference or `self` by mutable reference
   --> $DIR/wrong_self_convention.rs:46:19
    |
 LL |     pub fn as_i64(self) {}
@@ -63,7 +63,7 @@ LL |     pub fn as_i64(self) {}
    |
    = help: consider choosing a less ambiguous name
 
-error: methods called `into_*` usually take self by value
+error: methods called `into_*` usually take `self` by value
   --> $DIR/wrong_self_convention.rs:47:21
    |
 LL |     pub fn into_i64(&self) {}
@@ -71,7 +71,7 @@ LL |     pub fn into_i64(&self) {}
    |
    = help: consider choosing a less ambiguous name
 
-error: methods called `is_*` usually take self by reference or no self
+error: methods called `is_*` usually take `self` by reference or no `self`
   --> $DIR/wrong_self_convention.rs:48:19
    |
 LL |     pub fn is_i64(self) {}
@@ -79,7 +79,7 @@ LL |     pub fn is_i64(self) {}
    |
    = help: consider choosing a less ambiguous name
 
-error: methods with the following characteristics: (`to_*` and `self type is not Copy`) usually take self by reference
+error: methods with the following characteristics: (`to_*` and `self` type is not `Copy`) usually take `self` by reference
   --> $DIR/wrong_self_convention.rs:49:19
    |
 LL |     pub fn to_i64(self) {}
@@ -87,7 +87,7 @@ LL |     pub fn to_i64(self) {}
    |
    = help: consider choosing a less ambiguous name
 
-error: methods called `from_*` usually take no self
+error: methods called `from_*` usually take no `self`
   --> $DIR/wrong_self_convention.rs:50:21
    |
 LL |     pub fn from_i64(self) {}
@@ -95,7 +95,7 @@ LL |     pub fn from_i64(self) {}
    |
    = help: consider choosing a less ambiguous name
 
-error: methods called `as_*` usually take self by reference or self by mutable reference
+error: methods called `as_*` usually take `self` by reference or `self` by mutable reference
   --> $DIR/wrong_self_convention.rs:95:19
    |
 LL |         fn as_i32(self) {}
@@ -103,7 +103,7 @@ LL |         fn as_i32(self) {}
    |
    = help: consider choosing a less ambiguous name
 
-error: methods called `into_*` usually take self by value
+error: methods called `into_*` usually take `self` by value
   --> $DIR/wrong_self_convention.rs:98:25
    |
 LL |         fn into_i32_ref(&self) {}
@@ -111,7 +111,7 @@ LL |         fn into_i32_ref(&self) {}
    |
    = help: consider choosing a less ambiguous name
 
-error: methods called `is_*` usually take self by reference or no self
+error: methods called `is_*` usually take `self` by reference or no `self`
   --> $DIR/wrong_self_convention.rs:100:19
    |
 LL |         fn is_i32(self) {}
@@ -119,7 +119,7 @@ LL |         fn is_i32(self) {}
    |
    = help: consider choosing a less ambiguous name
 
-error: methods called `from_*` usually take no self
+error: methods called `from_*` usually take no `self`
   --> $DIR/wrong_self_convention.rs:104:21
    |
 LL |         fn from_i32(self) {}
@@ -127,7 +127,7 @@ LL |         fn from_i32(self) {}
    |
    = help: consider choosing a less ambiguous name
 
-error: methods called `as_*` usually take self by reference or self by mutable reference
+error: methods called `as_*` usually take `self` by reference or `self` by mutable reference
   --> $DIR/wrong_self_convention.rs:119:19
    |
 LL |         fn as_i32(self);
@@ -135,7 +135,7 @@ LL |         fn as_i32(self);
    |
    = help: consider choosing a less ambiguous name
 
-error: methods called `into_*` usually take self by value
+error: methods called `into_*` usually take `self` by value
   --> $DIR/wrong_self_convention.rs:122:25
    |
 LL |         fn into_i32_ref(&self);
@@ -143,7 +143,7 @@ LL |         fn into_i32_ref(&self);
    |
    = help: consider choosing a less ambiguous name
 
-error: methods called `is_*` usually take self by reference or no self
+error: methods called `is_*` usually take `self` by reference or no `self`
   --> $DIR/wrong_self_convention.rs:124:19
    |
 LL |         fn is_i32(self);
@@ -151,7 +151,7 @@ LL |         fn is_i32(self);
    |
    = help: consider choosing a less ambiguous name
 
-error: methods called `from_*` usually take no self
+error: methods called `from_*` usually take no `self`
   --> $DIR/wrong_self_convention.rs:128:21
    |
 LL |         fn from_i32(self);
@@ -159,7 +159,7 @@ LL |         fn from_i32(self);
    |
    = help: consider choosing a less ambiguous name
 
-error: methods called `into_*` usually take self by value
+error: methods called `into_*` usually take `self` by value
   --> $DIR/wrong_self_convention.rs:146:25
    |
 LL |         fn into_i32_ref(&self);
@@ -167,7 +167,7 @@ LL |         fn into_i32_ref(&self);
    |
    = help: consider choosing a less ambiguous name
 
-error: methods called `from_*` usually take no self
+error: methods called `from_*` usually take no `self`
   --> $DIR/wrong_self_convention.rs:152:21
    |
 LL |         fn from_i32(self);
@@ -175,7 +175,7 @@ LL |         fn from_i32(self);
    |
    = help: consider choosing a less ambiguous name
 
-error: methods with the following characteristics: (`to_*` and `self type is  Copy`) usually take self by value
+error: methods with the following characteristics: (`to_*` and `self` type is `Copy`) usually take `self` by value
   --> $DIR/wrong_self_convention.rs:181:22
    |
 LL |         fn to_u64_v2(&self) -> u64 {
@@ -183,7 +183,7 @@ LL |         fn to_u64_v2(&self) -> u64 {
    |
    = help: consider choosing a less ambiguous name
 
-error: methods with the following characteristics: (`to_*` and `self type is not Copy`) usually take self by reference
+error: methods with the following characteristics: (`to_*` and `self` type is not `Copy`) usually take `self` by reference
   --> $DIR/wrong_self_convention.rs:190:19
    |
 LL |         fn to_u64(self) -> u64 {
diff --git a/tests/ui/wrong_self_conventions_mut.stderr b/tests/ui/wrong_self_conventions_mut.stderr
index 8095188758c..6ce37c59491 100644
--- a/tests/ui/wrong_self_conventions_mut.stderr
+++ b/tests/ui/wrong_self_conventions_mut.stderr
@@ -1,4 +1,4 @@
-error: methods with the following characteristics: (`to_*` and `self type is not Copy`) usually take self by reference
+error: methods with the following characteristics: (`to_*` and `self` type is not `Copy`) usually take `self` by reference
   --> $DIR/wrong_self_conventions_mut.rs:15:24
    |
 LL |         pub fn to_many(&mut self) -> Option<&mut [T]> {
@@ -7,7 +7,7 @@ LL |         pub fn to_many(&mut self) -> Option<&mut [T]> {
    = note: `-D clippy::wrong-self-convention` implied by `-D warnings`
    = help: consider choosing a less ambiguous name
 
-error: methods with the following characteristics: (`to_*` and `*_mut`) usually take self by mutable reference
+error: methods with the following characteristics: (`to_*` and `*_mut`) usually take `self` by mutable reference
   --> $DIR/wrong_self_conventions_mut.rs:23:28
    |
 LL |         pub fn to_many_mut(&self) -> Option<&[T]> {
-- 
cgit 1.4.1-3-g733a5


From 296751f643952f02f6fa721c90bbb81f4183e3f6 Mon Sep 17 00:00:00 2001
From: ThibsG <thibsg@pm.me>
Date: Sat, 20 Mar 2021 10:24:10 +0100
Subject: Fix bad suggestion for generics in `new_without_default` lint

---
 clippy_lints/src/new_without_default.rs | 15 ++++++++-----
 tests/ui/new_without_default.rs         | 15 +++++++++++++
 tests/ui/new_without_default.stderr     | 38 +++++++++++++++++++++++++++++++--
 3 files changed, 61 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/new_without_default.rs b/clippy_lints/src/new_without_default.rs
index 502e5e4bf37..3789572ad43 100644
--- a/clippy_lints/src/new_without_default.rs
+++ b/clippy_lints/src/new_without_default.rs
@@ -1,5 +1,6 @@
 use clippy_utils::diagnostics::span_lint_hir_and_then;
 use clippy_utils::paths;
+use clippy_utils::source::snippet;
 use clippy_utils::sugg::DiagnosticBuilderExt;
 use clippy_utils::{get_trait_def_id, return_ty};
 use if_chain::if_chain;
@@ -62,7 +63,10 @@ impl<'tcx> LateLintPass<'tcx> for NewWithoutDefault {
     #[allow(clippy::too_many_lines)]
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) {
         if let hir::ItemKind::Impl(hir::Impl {
-            of_trait: None, items, ..
+            of_trait: None,
+            ref generics,
+            items,
+            ..
         }) = item.kind
         {
             for assoc_item in items {
@@ -126,6 +130,7 @@ impl<'tcx> LateLintPass<'tcx> for NewWithoutDefault {
                                         }
                                     }
 
+                                    let generics_sugg = snippet(cx, generics.span, "");
                                     span_lint_hir_and_then(
                                         cx,
                                         NEW_WITHOUT_DEFAULT,
@@ -140,7 +145,7 @@ impl<'tcx> LateLintPass<'tcx> for NewWithoutDefault {
                                                 cx,
                                                 item.span,
                                                 "try this",
-                                                &create_new_without_default_suggest_msg(self_ty),
+                                                &create_new_without_default_suggest_msg(self_ty, &generics_sugg),
                                                 Applicability::MaybeIncorrect,
                                             );
                                         },
@@ -155,12 +160,12 @@ impl<'tcx> LateLintPass<'tcx> for NewWithoutDefault {
     }
 }
 
-fn create_new_without_default_suggest_msg(ty: Ty<'_>) -> String {
+fn create_new_without_default_suggest_msg(ty: Ty<'_>, generics_sugg: &str) -> String {
     #[rustfmt::skip]
     format!(
-"impl Default for {} {{
+"impl{} Default for {} {{
     fn default() -> Self {{
         Self::new()
     }}
-}}", ty)
+}}", generics_sugg, ty)
 }
diff --git a/tests/ui/new_without_default.rs b/tests/ui/new_without_default.rs
index 3b6041823d8..64659b63f46 100644
--- a/tests/ui/new_without_default.rs
+++ b/tests/ui/new_without_default.rs
@@ -159,4 +159,19 @@ impl NewNotEqualToDerive {
     }
 }
 
+// see #6933
+pub struct FooGenerics<T>(std::marker::PhantomData<T>);
+impl<T> FooGenerics<T> {
+    pub fn new() -> Self {
+        Self(Default::default())
+    }
+}
+
+pub struct BarGenerics<T>(std::marker::PhantomData<T>);
+impl<T: Copy> BarGenerics<T> {
+    pub fn new() -> Self {
+        Self(Default::default())
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/new_without_default.stderr b/tests/ui/new_without_default.stderr
index e529e441eb7..973836f75a9 100644
--- a/tests/ui/new_without_default.stderr
+++ b/tests/ui/new_without_default.stderr
@@ -43,7 +43,7 @@ LL | |     }
    |
 help: try this
    |
-LL | impl Default for LtKo<'c> {
+LL | impl<'c> Default for LtKo<'c> {
 LL |     fn default() -> Self {
 LL |         Self::new()
 LL |     }
@@ -67,5 +67,39 @@ LL |     }
 LL | }
    |
 
-error: aborting due to 4 previous errors
+error: you should consider adding a `Default` implementation for `FooGenerics<T>`
+  --> $DIR/new_without_default.rs:165:5
+   |
+LL | /     pub fn new() -> Self {
+LL | |         Self(Default::default())
+LL | |     }
+   | |_____^
+   |
+help: try this
+   |
+LL | impl<T> Default for FooGenerics<T> {
+LL |     fn default() -> Self {
+LL |         Self::new()
+LL |     }
+LL | }
+   |
+
+error: you should consider adding a `Default` implementation for `BarGenerics<T>`
+  --> $DIR/new_without_default.rs:172:5
+   |
+LL | /     pub fn new() -> Self {
+LL | |         Self(Default::default())
+LL | |     }
+   | |_____^
+   |
+help: try this
+   |
+LL | impl<T: Copy> Default for BarGenerics<T> {
+LL |     fn default() -> Self {
+LL |         Self::new()
+LL |     }
+LL | }
+   |
+
+error: aborting due to 6 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 00a2d7ad7e1a041e47f618a019702bfb37eca680 Mon Sep 17 00:00:00 2001
From: ThibsG <thibsg@pm.me>
Date: Sat, 20 Mar 2021 16:11:19 +0100
Subject: Fix bad suggestion that needs curly braces for `match_single_binding`
 lint

---
 clippy_lints/src/matches.rs          | 14 +++++++++++++-
 tests/ui/match_single_binding.fixed  | 29 +++++++++++++++++++++++++++++
 tests/ui/match_single_binding.rs     | 29 +++++++++++++++++++++++++++++
 tests/ui/match_single_binding.stderr | 33 ++++++++++++++++++++++++++++++++-
 4 files changed, 103 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index d43cb32ee51..1a8ec9c6ec3 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -1353,6 +1353,7 @@ fn find_bool_lit(ex: &ExprKind<'_>, desugared: bool) -> Option<bool> {
     }
 }
 
+#[allow(clippy::too_many_lines)]
 fn check_match_single_binding<'a>(cx: &LateContext<'a>, ex: &Expr<'a>, arms: &[Arm<'_>], expr: &Expr<'_>) {
     if in_macro(expr.span) || arms.len() != 1 || is_refutable(cx, arms[0].pat) {
         return;
@@ -1427,7 +1428,18 @@ fn check_match_single_binding<'a>(cx: &LateContext<'a>, ex: &Expr<'a>, arms: &[A
                         indent = " ".repeat(indent_of(cx, bind_names).unwrap_or(0));
                         cbrace_start = format!("{{\n{}", indent);
                     }
-                };
+                }
+                // If the parent is already an arm, and the body is another match statement,
+                // we need curly braces around suggestion
+                let parent_node_id = cx.tcx.hir().get_parent_node(expr.hir_id);
+                if let Node::Arm(arm) = &cx.tcx.hir().get(parent_node_id) {
+                    if let ExprKind::Match(..) = arm.body.kind {
+                        cbrace_end = format!("\n{}}}", indent);
+                        // Fix body indent due to the match
+                        indent = " ".repeat(indent_of(cx, bind_names).unwrap_or(0));
+                        cbrace_start = format!("{{\n{}", indent);
+                    }
+                }
                 (
                     expr.span,
                     format!(
diff --git a/tests/ui/match_single_binding.fixed b/tests/ui/match_single_binding.fixed
index 526e94b10bd..4709b5b0157 100644
--- a/tests/ui/match_single_binding.fixed
+++ b/tests/ui/match_single_binding.fixed
@@ -115,4 +115,33 @@ fn main() {
         // =>
         _ => println!("Not an array index start"),
     }
+    // Lint (additional curly braces needed, see #6572)
+    struct AppendIter<I>
+    where
+        I: Iterator,
+    {
+        inner: Option<(I, <I as Iterator>::Item)>,
+    }
+
+    #[allow(dead_code)]
+    fn size_hint<I: Iterator>(iter: &AppendIter<I>) -> (usize, Option<usize>) {
+        match &iter.inner {
+            Some((iter, _item)) => {
+                let (min, max) = iter.size_hint();
+                (min.saturating_add(1), max.and_then(|max| max.checked_add(1)))
+            },
+            None => (0, Some(0)),
+        }
+    }
+    // Lint (no additional curly braces needed)
+    let opt = Some((5, 2));
+    let get_tup = || -> (i32, i32) { (1, 2) };
+    match opt {
+        #[rustfmt::skip]
+        Some((first, _second)) => {
+            let (a, b) = get_tup();
+            println!("a {:?} and b {:?}", a, b);
+        },
+        None => println!("nothing"),
+    }
 }
diff --git a/tests/ui/match_single_binding.rs b/tests/ui/match_single_binding.rs
index 6a2ca7c5e93..6a6b3e8e8a9 100644
--- a/tests/ui/match_single_binding.rs
+++ b/tests/ui/match_single_binding.rs
@@ -132,4 +132,33 @@ fn main() {
         // =>
         _ => println!("Not an array index start"),
     }
+    // Lint (additional curly braces needed, see #6572)
+    struct AppendIter<I>
+    where
+        I: Iterator,
+    {
+        inner: Option<(I, <I as Iterator>::Item)>,
+    }
+
+    #[allow(dead_code)]
+    fn size_hint<I: Iterator>(iter: &AppendIter<I>) -> (usize, Option<usize>) {
+        match &iter.inner {
+            Some((iter, _item)) => match iter.size_hint() {
+                (min, max) => (min.saturating_add(1), max.and_then(|max| max.checked_add(1))),
+            },
+            None => (0, Some(0)),
+        }
+    }
+    // Lint (no additional curly braces needed)
+    let opt = Some((5, 2));
+    let get_tup = || -> (i32, i32) { (1, 2) };
+    match opt {
+        #[rustfmt::skip]
+        Some((first, _second)) => {
+            match get_tup() {
+                (a, b) => println!("a {:?} and b {:?}", a, b),
+            }
+        },
+        None => println!("nothing"),
+    }
 }
diff --git a/tests/ui/match_single_binding.stderr b/tests/ui/match_single_binding.stderr
index cbbf5d29c02..73cc867dd9f 100644
--- a/tests/ui/match_single_binding.stderr
+++ b/tests/ui/match_single_binding.stderr
@@ -178,5 +178,36 @@ LL | |         _ => println!("Single branch"),
 LL | |     }
    | |_____^ help: consider using the match body instead: `println!("Single branch");`
 
-error: aborting due to 12 previous errors
+error: this match could be written as a `let` statement
+  --> $DIR/match_single_binding.rs:146:36
+   |
+LL |               Some((iter, _item)) => match iter.size_hint() {
+   |  ____________________________________^
+LL | |                 (min, max) => (min.saturating_add(1), max.and_then(|max| max.checked_add(1))),
+LL | |             },
+   | |_____________^
+   |
+help: consider using `let` statement
+   |
+LL |             Some((iter, _item)) => {
+LL |                 let (min, max) = iter.size_hint();
+LL |                 (min.saturating_add(1), max.and_then(|max| max.checked_add(1)))
+LL |             },
+   |
+
+error: this match could be written as a `let` statement
+  --> $DIR/match_single_binding.rs:158:13
+   |
+LL | /             match get_tup() {
+LL | |                 (a, b) => println!("a {:?} and b {:?}", a, b),
+LL | |             }
+   | |_____________^
+   |
+help: consider using `let` statement
+   |
+LL |             let (a, b) = get_tup();
+LL |             println!("a {:?} and b {:?}", a, b);
+   |
+
+error: aborting due to 14 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 3ddaabcbc9cf223f6a2f8f645b2092166f911eab Mon Sep 17 00:00:00 2001
From: ThibsG <thibsg@pm.me>
Date: Sun, 21 Mar 2021 09:50:35 +0100
Subject: Fix suggestion with generics for `field_reassign_with_default` lint

---
 clippy_lints/src/default.rs                 | 19 +++++++++++++++++++
 tests/ui/field_reassign_with_default.rs     | 18 ++++++++++++++++++
 tests/ui/field_reassign_with_default.stderr | 26 +++++++++++++++++++++++++-
 3 files changed, 62 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/default.rs b/clippy_lints/src/default.rs
index d046e894792..568a174445c 100644
--- a/clippy_lints/src/default.rs
+++ b/clippy_lints/src/default.rs
@@ -104,6 +104,7 @@ impl LateLintPass<'_> for Default {
         }
     }
 
+    #[allow(clippy::too_many_lines)]
     fn check_block<'tcx>(&mut self, cx: &LateContext<'tcx>, block: &Block<'tcx>) {
         // start from the `let mut _ = _::default();` and look at all the following
         // statements, see if they re-assign the fields of the binding
@@ -197,6 +198,24 @@ impl LateLintPass<'_> for Default {
                     .collect::<Vec<String>>()
                     .join(", ");
 
+                // give correct suggestion if generics are involved (see #6944)
+                let binding_type = if_chain! {
+                    if let ty::Adt(adt_def, substs) = binding_type.kind();
+                    if !substs.is_empty();
+                    let adt_def_ty_name = cx.tcx.item_name(adt_def.did);
+                    let generic_args = substs.iter().collect::<Vec<_>>();
+                    let tys_str = generic_args
+                        .iter()
+                        .map(ToString::to_string)
+                        .collect::<Vec<_>>()
+                        .join(", ");
+                    then {
+                        format!("{}::<{}>", adt_def_ty_name, &tys_str)
+                    } else {
+                        binding_type.to_string()
+                    }
+                };
+
                 let sugg = if ext_with_default {
                     if field_list.is_empty() {
                         format!("{}::default()", binding_type)
diff --git a/tests/ui/field_reassign_with_default.rs b/tests/ui/field_reassign_with_default.rs
index 9fc208f5332..1368c5d7984 100644
--- a/tests/ui/field_reassign_with_default.rs
+++ b/tests/ui/field_reassign_with_default.rs
@@ -136,6 +136,13 @@ fn main() {
 
     // Don't lint in external macros
     field_reassign_with_default!();
+
+    // be sure suggestion is correct with generics
+    let mut a: Wrapper<bool> = Default::default();
+    a.i = true;
+
+    let mut a: WrapperMulti<i32, i64> = Default::default();
+    a.i = 42;
 }
 
 mod m {
@@ -145,3 +152,14 @@ mod m {
         b: u64,
     }
 }
+
+#[derive(Default)]
+struct Wrapper<T> {
+    i: T,
+}
+
+#[derive(Default)]
+struct WrapperMulti<T, U> {
+    i: T,
+    j: U,
+}
diff --git a/tests/ui/field_reassign_with_default.stderr b/tests/ui/field_reassign_with_default.stderr
index 2f0f28f7bb7..dd7c0360bb1 100644
--- a/tests/ui/field_reassign_with_default.stderr
+++ b/tests/ui/field_reassign_with_default.stderr
@@ -83,5 +83,29 @@ note: consider initializing the variable with `C { i: vec![1], ..Default::defaul
 LL |     let mut a: C = C::default();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 7 previous errors
+error: field assignment outside of initializer for an instance created with Default::default()
+  --> $DIR/field_reassign_with_default.rs:142:5
+   |
+LL |     a.i = true;
+   |     ^^^^^^^^^^^
+   |
+note: consider initializing the variable with `Wrapper::<bool> { i: true }` and removing relevant reassignments
+  --> $DIR/field_reassign_with_default.rs:141:5
+   |
+LL |     let mut a: Wrapper<bool> = Default::default();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: field assignment outside of initializer for an instance created with Default::default()
+  --> $DIR/field_reassign_with_default.rs:145:5
+   |
+LL |     a.i = 42;
+   |     ^^^^^^^^^
+   |
+note: consider initializing the variable with `WrapperMulti::<i32, i64> { i: 42, ..Default::default() }` and removing relevant reassignments
+  --> $DIR/field_reassign_with_default.rs:144:5
+   |
+LL |     let mut a: WrapperMulti<i32, i64> = Default::default();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 9 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 2ffee89b752212d4e7d72ece16636d7c43b11c63 Mon Sep 17 00:00:00 2001
From: Mateusz Gacek <96mateusz.gacek@gmail.com>
Date: Sat, 20 Mar 2021 14:30:45 +0100
Subject: search_is_some: check also when search is none

---
 clippy_lints/src/methods/mod.rs            |  57 ++++++++++++---
 clippy_lints/src/methods/search_is_some.rs | 107 +++++++++++++++++++++--------
 tests/ui/search_is_some.rs                 |  37 +++++++++-
 tests/ui/search_is_some.stderr             |  44 ++++++++++--
 tests/ui/search_is_some_fixable.fixed      |  35 +++++++++-
 tests/ui/search_is_some_fixable.rs         |  35 +++++++++-
 tests/ui/search_is_some_fixable.stderr     |  92 ++++++++++++++++++++++++-
 7 files changed, 359 insertions(+), 48 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 46deb20f97d..5be28354769 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -588,26 +588,31 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// **What it does:** Checks for an iterator or string search (such as `find()`,
-    /// `position()`, or `rposition()`) followed by a call to `is_some()`.
+    /// `position()`, or `rposition()`) followed by a call to `is_some()` or `is_none()`.
     ///
-    /// **Why is this bad?** Readability, this can be written more concisely as
-    /// `_.any(_)` or `_.contains(_)`.
+    /// **Why is this bad?** Readability, this can be written more concisely as:
+    /// * `_.any(_)`, or `_.contains(_)` for `is_some()`,
+    /// * `!_.any(_)`, or `!_.contains(_)` for `is_none()`.
     ///
     /// **Known problems:** None.
     ///
     /// **Example:**
     /// ```rust
-    /// # let vec = vec![1];
+    /// let vec = vec![1];
     /// vec.iter().find(|x| **x == 0).is_some();
+    ///
+    /// let _ = "hello world".find("world").is_none();
     /// ```
     /// Could be written as
     /// ```rust
-    /// # let vec = vec![1];
+    /// let vec = vec![1];
     /// vec.iter().any(|x| *x == 0);
+    ///
+    /// let _ = !"hello world".contains("world");
     /// ```
     pub SEARCH_IS_SOME,
     complexity,
-    "using an iterator or string search followed by `is_some()`, which is more succinctly expressed as a call to `any()` or `contains()`"
+    "using an iterator or string search followed by `is_some()` or `is_none()`, which is more succinctly expressed as a call to `any()` or `contains()` (with negation in case of `is_none()`)"
 }
 
 declare_clippy_lint! {
@@ -1720,12 +1725,42 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             ["flat_map", "filter_map"] => filter_map_flat_map::check(cx, expr, arg_lists[1], arg_lists[0]),
             ["flat_map", ..] => flat_map_identity::check(cx, expr, arg_lists[0], method_spans[0]),
             ["flatten", "map"] => map_flatten::check(cx, expr, arg_lists[1]),
-            ["is_some", "find"] => search_is_some::check(cx, expr, "find", arg_lists[1], arg_lists[0], method_spans[1]),
-            ["is_some", "position"] => {
-                search_is_some::check(cx, expr, "position", arg_lists[1], arg_lists[0], method_spans[1])
+            [option_check_method, "find"] if "is_some" == *option_check_method || "is_none" == *option_check_method => {
+                search_is_some::check(
+                    cx,
+                    expr,
+                    "find",
+                    option_check_method,
+                    arg_lists[1],
+                    arg_lists[0],
+                    method_spans[1],
+                )
             },
-            ["is_some", "rposition"] => {
-                search_is_some::check(cx, expr, "rposition", arg_lists[1], arg_lists[0], method_spans[1])
+            [option_check_method, "position"]
+                if "is_some" == *option_check_method || "is_none" == *option_check_method =>
+            {
+                search_is_some::check(
+                    cx,
+                    expr,
+                    "position",
+                    option_check_method,
+                    arg_lists[1],
+                    arg_lists[0],
+                    method_spans[1],
+                )
+            },
+            [option_check_method, "rposition"]
+                if "is_some" == *option_check_method || "is_none" == *option_check_method =>
+            {
+                search_is_some::check(
+                    cx,
+                    expr,
+                    "rposition",
+                    option_check_method,
+                    arg_lists[1],
+                    arg_lists[0],
+                    method_spans[1],
+                )
             },
             ["extend", ..] => string_extend_chars::check(cx, expr, arg_lists[0]),
             ["count", "into_iter"] => iter_count::check(cx, expr, &arg_lists[1], "into_iter"),
diff --git a/clippy_lints/src/methods/search_is_some.rs b/clippy_lints/src/methods/search_is_some.rs
index 13546dc1779..de7d168295f 100644
--- a/clippy_lints/src/methods/search_is_some.rs
+++ b/clippy_lints/src/methods/search_is_some.rs
@@ -14,11 +14,13 @@ use rustc_span::symbol::sym;
 use super::SEARCH_IS_SOME;
 
 /// lint searching an Iterator followed by `is_some()`
-/// or calling `find()` on a string followed by `is_some()`
+/// or calling `find()` on a string followed by `is_some()` or `is_none()`
+#[allow(clippy::too_many_lines)]
 pub(super) fn check<'tcx>(
     cx: &LateContext<'tcx>,
     expr: &'tcx hir::Expr<'_>,
     search_method: &str,
+    option_check_method: &str,
     search_args: &'tcx [hir::Expr<'_>],
     is_some_args: &'tcx [hir::Expr<'_>],
     method_span: Span,
@@ -26,10 +28,9 @@ pub(super) fn check<'tcx>(
     // lint if caller of search is an Iterator
     if is_trait_method(cx, &is_some_args[0], sym::Iterator) {
         let msg = format!(
-            "called `is_some()` after searching an `Iterator` with `{}`",
-            search_method
+            "called `{}()` after searching an `Iterator` with `{}`",
+            option_check_method, search_method
         );
-        let hint = "this is more succinctly expressed by calling `any()`";
         let search_snippet = snippet(cx, search_args[1].span, "..");
         if search_snippet.lines().count() <= 1 {
             // suggest `any(|x| ..)` instead of `any(|&x| ..)` for `find(|&x| ..).is_some()`
@@ -53,20 +54,49 @@ pub(super) fn check<'tcx>(
                 }
             };
             // add note if not multi-line
-            span_lint_and_sugg(
-                cx,
-                SEARCH_IS_SOME,
-                method_span.with_hi(expr.span.hi()),
-                &msg,
-                "use `any()` instead",
-                format!(
-                    "any({})",
-                    any_search_snippet.as_ref().map_or(&*search_snippet, String::as_str)
-                ),
-                Applicability::MachineApplicable,
-            );
+            match option_check_method {
+                "is_some" => {
+                    span_lint_and_sugg(
+                        cx,
+                        SEARCH_IS_SOME,
+                        method_span.with_hi(expr.span.hi()),
+                        &msg,
+                        "use `any()` instead",
+                        format!(
+                            "any({})",
+                            any_search_snippet.as_ref().map_or(&*search_snippet, String::as_str)
+                        ),
+                        Applicability::MachineApplicable,
+                    );
+                },
+                "is_none" => {
+                    let iter = snippet(cx, search_args[0].span, "..");
+                    span_lint_and_sugg(
+                        cx,
+                        SEARCH_IS_SOME,
+                        expr.span,
+                        &msg,
+                        "use `!_.any()` instead",
+                        format!(
+                            "!{}.any({})",
+                            iter,
+                            any_search_snippet.as_ref().map_or(&*search_snippet, String::as_str)
+                        ),
+                        Applicability::MachineApplicable,
+                    );
+                },
+                _ => (),
+            }
         } else {
-            span_lint_and_help(cx, SEARCH_IS_SOME, expr.span, &msg, None, hint);
+            let hint = format!(
+                "this is more succinctly expressed by calling `any()`{}",
+                if option_check_method == "is_none" {
+                    " with negation"
+                } else {
+                    ""
+                }
+            );
+            span_lint_and_help(cx, SEARCH_IS_SOME, expr.span, &msg, None, &hint);
         }
     }
     // lint if `find()` is called by `String` or `&str`
@@ -83,18 +113,37 @@ pub(super) fn check<'tcx>(
             if is_string_or_str_slice(&search_args[0]);
             if is_string_or_str_slice(&search_args[1]);
             then {
-                let msg = "called `is_some()` after calling `find()` on a string";
-                let mut applicability = Applicability::MachineApplicable;
-                let find_arg = snippet_with_applicability(cx, search_args[1].span, "..", &mut applicability);
-                span_lint_and_sugg(
-                    cx,
-                    SEARCH_IS_SOME,
-                    method_span.with_hi(expr.span.hi()),
-                    msg,
-                    "use `contains()` instead",
-                    format!("contains({})", find_arg),
-                    applicability,
-                );
+                let msg = format!("called `{}()` after calling `find()` on a string", option_check_method);
+                match option_check_method {
+                    "is_some" => {
+                        let mut applicability = Applicability::MachineApplicable;
+                        let find_arg = snippet_with_applicability(cx, search_args[1].span, "..", &mut applicability);
+                        span_lint_and_sugg(
+                            cx,
+                            SEARCH_IS_SOME,
+                            method_span.with_hi(expr.span.hi()),
+                            &msg,
+                            "use `contains()` instead",
+                            format!("contains({})", find_arg),
+                            applicability,
+                        );
+                    },
+                    "is_none" => {
+                        let string = snippet(cx, search_args[0].span, "..");
+                        let mut applicability = Applicability::MachineApplicable;
+                        let find_arg = snippet_with_applicability(cx, search_args[1].span, "..", &mut applicability);
+                        span_lint_and_sugg(
+                            cx,
+                            SEARCH_IS_SOME,
+                            expr.span,
+                            &msg,
+                            "use `!_.contains()` instead",
+                            format!("!{}.contains({})", string, find_arg),
+                            applicability,
+                        );
+                    },
+                    _ => (),
+                }
             }
         }
     }
diff --git a/tests/ui/search_is_some.rs b/tests/ui/search_is_some.rs
index f0dc3b3d06b..72bc6ef35d3 100644
--- a/tests/ui/search_is_some.rs
+++ b/tests/ui/search_is_some.rs
@@ -1,8 +1,9 @@
 // aux-build:option_helpers.rs
+#![warn(clippy::search_is_some)]
+#![allow(dead_code)]
 extern crate option_helpers;
 use option_helpers::IteratorFalsePositives;
 
-#[warn(clippy::search_is_some)]
 #[rustfmt::skip]
 fn main() {
     let v = vec![3, 2, 1, 0, -1, -2, -3];
@@ -36,3 +37,37 @@ fn main() {
     // `Pattern` that is not a string
     let _ = "hello world".find(|c: char| c == 'o' || c == 'l').is_some();
 }
+
+#[rustfmt::skip]
+fn is_none() {
+    let v = vec![3, 2, 1, 0, -1, -2, -3];
+    let y = &&42;
+
+
+    // Check `find().is_none()`, multi-line case.
+    let _ = v.iter().find(|&x| {
+                              *x < 0
+                          }
+                   ).is_none();
+
+    // Check `position().is_none()`, multi-line case.
+    let _ = v.iter().position(|&x| {
+                                  x < 0
+                              }
+                   ).is_none();
+
+    // Check `rposition().is_none()`, multi-line case.
+    let _ = v.iter().rposition(|&x| {
+                                   x < 0
+                               }
+                   ).is_none();
+
+    // Check that we don't lint if the caller is not an `Iterator` or string
+    let falsepos = IteratorFalsePositives { foo: 0 };
+    let _ = falsepos.find().is_none();
+    let _ = falsepos.position().is_none();
+    let _ = falsepos.rposition().is_none();
+    // check that we don't lint if `find()` is called with
+    // `Pattern` that is not a string
+    let _ = "hello world".find(|c: char| c == 'o' || c == 'l').is_none();
+}
diff --git a/tests/ui/search_is_some.stderr b/tests/ui/search_is_some.stderr
index c601f568c60..f3c758e451e 100644
--- a/tests/ui/search_is_some.stderr
+++ b/tests/ui/search_is_some.stderr
@@ -1,5 +1,5 @@
 error: called `is_some()` after searching an `Iterator` with `find`
-  --> $DIR/search_is_some.rs:13:13
+  --> $DIR/search_is_some.rs:14:13
    |
 LL |       let _ = v.iter().find(|&x| {
    |  _____________^
@@ -12,7 +12,7 @@ LL | |                    ).is_some();
    = help: this is more succinctly expressed by calling `any()`
 
 error: called `is_some()` after searching an `Iterator` with `position`
-  --> $DIR/search_is_some.rs:19:13
+  --> $DIR/search_is_some.rs:20:13
    |
 LL |       let _ = v.iter().position(|&x| {
    |  _____________^
@@ -24,7 +24,7 @@ LL | |                    ).is_some();
    = help: this is more succinctly expressed by calling `any()`
 
 error: called `is_some()` after searching an `Iterator` with `rposition`
-  --> $DIR/search_is_some.rs:25:13
+  --> $DIR/search_is_some.rs:26:13
    |
 LL |       let _ = v.iter().rposition(|&x| {
    |  _____________^
@@ -35,5 +35,41 @@ LL | |                    ).is_some();
    |
    = help: this is more succinctly expressed by calling `any()`
 
-error: aborting due to 3 previous errors
+error: called `is_none()` after searching an `Iterator` with `find`
+  --> $DIR/search_is_some.rs:48:13
+   |
+LL |       let _ = v.iter().find(|&x| {
+   |  _____________^
+LL | |                               *x < 0
+LL | |                           }
+LL | |                    ).is_none();
+   | |______________________________^
+   |
+   = help: this is more succinctly expressed by calling `any()` with negation
+
+error: called `is_none()` after searching an `Iterator` with `position`
+  --> $DIR/search_is_some.rs:54:13
+   |
+LL |       let _ = v.iter().position(|&x| {
+   |  _____________^
+LL | |                                   x < 0
+LL | |                               }
+LL | |                    ).is_none();
+   | |______________________________^
+   |
+   = help: this is more succinctly expressed by calling `any()` with negation
+
+error: called `is_none()` after searching an `Iterator` with `rposition`
+  --> $DIR/search_is_some.rs:60:13
+   |
+LL |       let _ = v.iter().rposition(|&x| {
+   |  _____________^
+LL | |                                    x < 0
+LL | |                                }
+LL | |                    ).is_none();
+   | |______________________________^
+   |
+   = help: this is more succinctly expressed by calling `any()` with negation
+
+error: aborting due to 6 previous errors
 
diff --git a/tests/ui/search_is_some_fixable.fixed b/tests/ui/search_is_some_fixable.fixed
index dc3f290e562..62ff16f67f4 100644
--- a/tests/ui/search_is_some_fixable.fixed
+++ b/tests/ui/search_is_some_fixable.fixed
@@ -1,5 +1,5 @@
 // run-rustfix
-
+#![allow(dead_code)]
 #![warn(clippy::search_is_some)]
 
 fn main() {
@@ -33,3 +33,36 @@ fn main() {
     let _ = s1[2..].contains(&s2);
     let _ = s1[2..].contains(&s2[2..]);
 }
+
+fn is_none() {
+    let v = vec![3, 2, 1, 0, -1, -2, -3];
+    let y = &&42;
+
+    // Check `find().is_none()`, single-line case.
+    let _ = !v.iter().any(|x| *x < 0);
+    let _ = !(0..1).any(|x| **y == x); // one dereference less
+    let _ = !(0..1).any(|x| x == 0);
+    let _ = !v.iter().any(|x| *x == 0);
+
+    // Check `position().is_none()`, single-line case.
+    let _ = !v.iter().any(|&x| x < 0);
+
+    // Check `rposition().is_none()`, single-line case.
+    let _ = !v.iter().any(|&x| x < 0);
+
+    let s1 = String::from("hello world");
+    let s2 = String::from("world");
+
+    // caller of `find()` is a `&`static str`
+    let _ = !"hello world".contains("world");
+    let _ = !"hello world".contains(&s2);
+    let _ = !"hello world".contains(&s2[2..]);
+    // caller of `find()` is a `String`
+    let _ = !s1.contains("world");
+    let _ = !s1.contains(&s2);
+    let _ = !s1.contains(&s2[2..]);
+    // caller of `find()` is slice of `String`
+    let _ = !s1[2..].contains("world");
+    let _ = !s1[2..].contains(&s2);
+    let _ = !s1[2..].contains(&s2[2..]);
+}
diff --git a/tests/ui/search_is_some_fixable.rs b/tests/ui/search_is_some_fixable.rs
index 146cf5adf1b..8407f716647 100644
--- a/tests/ui/search_is_some_fixable.rs
+++ b/tests/ui/search_is_some_fixable.rs
@@ -1,5 +1,5 @@
 // run-rustfix
-
+#![allow(dead_code)]
 #![warn(clippy::search_is_some)]
 
 fn main() {
@@ -33,3 +33,36 @@ fn main() {
     let _ = s1[2..].find(&s2).is_some();
     let _ = s1[2..].find(&s2[2..]).is_some();
 }
+
+fn is_none() {
+    let v = vec![3, 2, 1, 0, -1, -2, -3];
+    let y = &&42;
+
+    // Check `find().is_none()`, single-line case.
+    let _ = v.iter().find(|&x| *x < 0).is_none();
+    let _ = (0..1).find(|x| **y == *x).is_none(); // one dereference less
+    let _ = (0..1).find(|x| *x == 0).is_none();
+    let _ = v.iter().find(|x| **x == 0).is_none();
+
+    // Check `position().is_none()`, single-line case.
+    let _ = v.iter().position(|&x| x < 0).is_none();
+
+    // Check `rposition().is_none()`, single-line case.
+    let _ = v.iter().rposition(|&x| x < 0).is_none();
+
+    let s1 = String::from("hello world");
+    let s2 = String::from("world");
+
+    // caller of `find()` is a `&`static str`
+    let _ = "hello world".find("world").is_none();
+    let _ = "hello world".find(&s2).is_none();
+    let _ = "hello world".find(&s2[2..]).is_none();
+    // caller of `find()` is a `String`
+    let _ = s1.find("world").is_none();
+    let _ = s1.find(&s2).is_none();
+    let _ = s1.find(&s2[2..]).is_none();
+    // caller of `find()` is slice of `String`
+    let _ = s1[2..].find("world").is_none();
+    let _ = s1[2..].find(&s2).is_none();
+    let _ = s1[2..].find(&s2[2..]).is_none();
+}
diff --git a/tests/ui/search_is_some_fixable.stderr b/tests/ui/search_is_some_fixable.stderr
index 23c1d9a901b..bd1b6955a97 100644
--- a/tests/ui/search_is_some_fixable.stderr
+++ b/tests/ui/search_is_some_fixable.stderr
@@ -90,5 +90,95 @@ error: called `is_some()` after calling `find()` on a string
 LL |     let _ = s1[2..].find(&s2[2..]).is_some();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^ help: use `contains()` instead: `contains(&s2[2..])`
 
-error: aborting due to 15 previous errors
+error: called `is_none()` after searching an `Iterator` with `find`
+  --> $DIR/search_is_some_fixable.rs:42:13
+   |
+LL |     let _ = v.iter().find(|&x| *x < 0).is_none();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.any()` instead: `!v.iter().any(|x| *x < 0)`
+
+error: called `is_none()` after searching an `Iterator` with `find`
+  --> $DIR/search_is_some_fixable.rs:43:13
+   |
+LL |     let _ = (0..1).find(|x| **y == *x).is_none(); // one dereference less
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.any()` instead: `!(0..1).any(|x| **y == x)`
+
+error: called `is_none()` after searching an `Iterator` with `find`
+  --> $DIR/search_is_some_fixable.rs:44:13
+   |
+LL |     let _ = (0..1).find(|x| *x == 0).is_none();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.any()` instead: `!(0..1).any(|x| x == 0)`
+
+error: called `is_none()` after searching an `Iterator` with `find`
+  --> $DIR/search_is_some_fixable.rs:45:13
+   |
+LL |     let _ = v.iter().find(|x| **x == 0).is_none();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.any()` instead: `!v.iter().any(|x| *x == 0)`
+
+error: called `is_none()` after searching an `Iterator` with `position`
+  --> $DIR/search_is_some_fixable.rs:48:13
+   |
+LL |     let _ = v.iter().position(|&x| x < 0).is_none();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.any()` instead: `!v.iter().any(|&x| x < 0)`
+
+error: called `is_none()` after searching an `Iterator` with `rposition`
+  --> $DIR/search_is_some_fixable.rs:51:13
+   |
+LL |     let _ = v.iter().rposition(|&x| x < 0).is_none();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.any()` instead: `!v.iter().any(|&x| x < 0)`
+
+error: called `is_none()` after calling `find()` on a string
+  --> $DIR/search_is_some_fixable.rs:57:13
+   |
+LL |     let _ = "hello world".find("world").is_none();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.contains()` instead: `!"hello world".contains("world")`
+
+error: called `is_none()` after calling `find()` on a string
+  --> $DIR/search_is_some_fixable.rs:58:13
+   |
+LL |     let _ = "hello world".find(&s2).is_none();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.contains()` instead: `!"hello world".contains(&s2)`
+
+error: called `is_none()` after calling `find()` on a string
+  --> $DIR/search_is_some_fixable.rs:59:13
+   |
+LL |     let _ = "hello world".find(&s2[2..]).is_none();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.contains()` instead: `!"hello world".contains(&s2[2..])`
+
+error: called `is_none()` after calling `find()` on a string
+  --> $DIR/search_is_some_fixable.rs:61:13
+   |
+LL |     let _ = s1.find("world").is_none();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.contains()` instead: `!s1.contains("world")`
+
+error: called `is_none()` after calling `find()` on a string
+  --> $DIR/search_is_some_fixable.rs:62:13
+   |
+LL |     let _ = s1.find(&s2).is_none();
+   |             ^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.contains()` instead: `!s1.contains(&s2)`
+
+error: called `is_none()` after calling `find()` on a string
+  --> $DIR/search_is_some_fixable.rs:63:13
+   |
+LL |     let _ = s1.find(&s2[2..]).is_none();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.contains()` instead: `!s1.contains(&s2[2..])`
+
+error: called `is_none()` after calling `find()` on a string
+  --> $DIR/search_is_some_fixable.rs:65:13
+   |
+LL |     let _ = s1[2..].find("world").is_none();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.contains()` instead: `!s1[2..].contains("world")`
+
+error: called `is_none()` after calling `find()` on a string
+  --> $DIR/search_is_some_fixable.rs:66:13
+   |
+LL |     let _ = s1[2..].find(&s2).is_none();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.contains()` instead: `!s1[2..].contains(&s2)`
+
+error: called `is_none()` after calling `find()` on a string
+  --> $DIR/search_is_some_fixable.rs:67:13
+   |
+LL |     let _ = s1[2..].find(&s2[2..]).is_none();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.contains()` instead: `!s1[2..].contains(&s2[2..])`
+
+error: aborting due to 30 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 45e775697ea4376224275e0c568fbefed6645fee Mon Sep 17 00:00:00 2001
From: Jamie Quigley <jamie@quigley.xyz>
Date: Mon, 22 Mar 2021 19:34:20 +0000
Subject: Ignore str::len() in or_fun_call lint.

---
 clippy_lints/src/methods/or_fun_call.rs | 2 +-
 tests/ui/or_fun_call.fixed              | 3 +++
 tests/ui/or_fun_call.rs                 | 3 +++
 tests/ui/or_fun_call.stderr             | 6 +++---
 4 files changed, 10 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/or_fun_call.rs b/clippy_lints/src/methods/or_fun_call.rs
index e6b473dbafa..20861ff8686 100644
--- a/clippy_lints/src/methods/or_fun_call.rs
+++ b/clippy_lints/src/methods/or_fun_call.rs
@@ -91,7 +91,7 @@ pub(super) fn check<'tcx>(
                 let ty = cx.typeck_results().expr_ty(&args[0]).peel_refs();
 
                 match ty.kind() {
-                    ty::Slice(_) | ty::Array(_, _) => return,
+                    ty::Slice(_) | ty::Array(_, _) | ty::Str => return,
                     _ => (),
                 }
 
diff --git a/tests/ui/or_fun_call.fixed b/tests/ui/or_fun_call.fixed
index 660245f10c3..4390ff7dc30 100644
--- a/tests/ui/or_fun_call.fixed
+++ b/tests/ui/or_fun_call.fixed
@@ -120,6 +120,9 @@ fn test_or_with_ctors() {
 
     let slice = &["foo"][..];
     let _ = opt.ok_or(slice.len());
+
+    let string = "foo";
+    let _ = opt.ok_or(string.len());
 }
 
 // Issue 4514 - early return
diff --git a/tests/ui/or_fun_call.rs b/tests/ui/or_fun_call.rs
index c589b170bdd..75908c974cc 100644
--- a/tests/ui/or_fun_call.rs
+++ b/tests/ui/or_fun_call.rs
@@ -120,6 +120,9 @@ fn test_or_with_ctors() {
 
     let slice = &["foo"][..];
     let _ = opt.ok_or(slice.len());
+
+    let string = "foo";
+    let _ = opt.ok_or(string.len());
 }
 
 // Issue 4514 - early return
diff --git a/tests/ui/or_fun_call.stderr b/tests/ui/or_fun_call.stderr
index d63b3443592..9905029ce91 100644
--- a/tests/ui/or_fun_call.stderr
+++ b/tests/ui/or_fun_call.stderr
@@ -115,19 +115,19 @@ LL |         .or(Some(Bar(b, Duration::from_secs(2))));
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `or_else(|| Some(Bar(b, Duration::from_secs(2))))`
 
 error: use of `unwrap_or` followed by a function call
-  --> $DIR/or_fun_call.rs:138:14
+  --> $DIR/or_fun_call.rs:141:14
    |
 LL |         None.unwrap_or(s.as_mut_vec());
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|| s.as_mut_vec())`
 
 error: use of `unwrap_or` followed by a function call
-  --> $DIR/or_fun_call.rs:143:14
+  --> $DIR/or_fun_call.rs:146:14
    |
 LL |         None.unwrap_or(unsafe { s.as_mut_vec() });
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|| unsafe { s.as_mut_vec() })`
 
 error: use of `unwrap_or` followed by a function call
-  --> $DIR/or_fun_call.rs:145:14
+  --> $DIR/or_fun_call.rs:148:14
    |
 LL |         None.unwrap_or( unsafe { s.as_mut_vec() }    );
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|| unsafe { s.as_mut_vec() })`
-- 
cgit 1.4.1-3-g733a5


From 9132dbdf310bbffbf5a8efd3b52f68189e3ee15e Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Tue, 23 Mar 2021 10:40:27 -0500
Subject: Factor out eq_ty_kind

---
 clippy_lints/src/methods/mod.rs | 18 ++++++++----------
 clippy_utils/src/hir_utils.rs   | 12 ++----------
 2 files changed, 10 insertions(+), 20 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index b37d744269e..d77f9c03cae 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -62,13 +62,11 @@ mod zst_offset;
 use bind_instead_of_map::BindInsteadOfMap;
 use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
 use clippy_utils::ty::{contains_ty, implements_trait, is_copy, is_type_diagnostic_item};
-use clippy_utils::{
-    contains_return, get_trait_def_id, in_macro, iter_input_pats, match_qpath, method_calls, paths, return_ty,
-    SpanlessEq,
-};
+use clippy_utils::{contains_return, get_trait_def_id, in_macro, iter_input_pats, method_calls, paths, return_ty};
 use if_chain::if_chain;
 use rustc_hir as hir;
-use rustc_hir::{TraitItem, TraitItemKind};
+use rustc_hir::def::Res;
+use rustc_hir::{PrimTy, QPath, TraitItem, TraitItemKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::{self, TraitRef, Ty, TyS};
@@ -1872,7 +1870,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
                     for method_config in &TRAIT_METHODS {
                         if name == method_config.method_name &&
                             sig.decl.inputs.len() == method_config.param_count &&
-                            method_config.output_type.matches(cx, &sig.decl.output) &&
+                            method_config.output_type.matches(&sig.decl.output) &&
                             method_config.self_kind.matches(cx, self_ty, first_arg_ty) &&
                             fn_header_equals(method_config.fn_header, sig.header) &&
                             method_config.lifetime_param_cond(&impl_item)
@@ -2199,8 +2197,8 @@ enum OutType {
 }
 
 impl OutType {
-    fn matches(self, cx: &LateContext<'_>, ty: &hir::FnRetTy<'_>) -> bool {
-        let is_unit = |ty: &hir::Ty<'_>| SpanlessEq::new(cx).eq_ty_kind(&ty.kind, &hir::TyKind::Tup(&[]));
+    fn matches(self, ty: &hir::FnRetTy<'_>) -> bool {
+        let is_unit = |ty: &hir::Ty<'_>| matches!(ty.kind, hir::TyKind::Tup(&[]));
         match (self, ty) {
             (Self::Unit, &hir::FnRetTy::DefaultReturn(_)) => true,
             (Self::Unit, &hir::FnRetTy::Return(ref ty)) if is_unit(ty) => true,
@@ -2213,8 +2211,8 @@ impl OutType {
 }
 
 fn is_bool(ty: &hir::Ty<'_>) -> bool {
-    if let hir::TyKind::Path(ref p) = ty.kind {
-        match_qpath(p, &["bool"])
+    if let hir::TyKind::Path(QPath::Resolved(_, path)) = ty.kind {
+        matches!(path.res, Res::PrimTy(PrimTy::Bool))
     } else {
         false
     }
diff --git a/clippy_utils/src/hir_utils.rs b/clippy_utils/src/hir_utils.rs
index 4c13a185d5d..5cfeaee28cf 100644
--- a/clippy_utils/src/hir_utils.rs
+++ b/clippy_utils/src/hir_utils.rs
@@ -80,10 +80,6 @@ impl<'a, 'tcx> SpanlessEq<'a, 'tcx> {
     pub fn eq_path_segments(&mut self, left: &[PathSegment<'_>], right: &[PathSegment<'_>]) -> bool {
         self.inter_expr().eq_path_segments(left, right)
     }
-
-    pub fn eq_ty_kind(&mut self, left: &TyKind<'_>, right: &TyKind<'_>) -> bool {
-        self.inter_expr().eq_ty_kind(left, right)
-    }
 }
 
 struct HirEqInterExpr<'a, 'b, 'tcx> {
@@ -378,13 +374,9 @@ impl HirEqInterExpr<'_, '_, '_> {
         left.ident.name == right.ident.name && both(&left.args, &right.args, |l, r| self.eq_path_parameters(l, r))
     }
 
-    fn eq_ty(&mut self, left: &Ty<'_>, right: &Ty<'_>) -> bool {
-        self.eq_ty_kind(&left.kind, &right.kind)
-    }
-
     #[allow(clippy::similar_names)]
-    fn eq_ty_kind(&mut self, left: &TyKind<'_>, right: &TyKind<'_>) -> bool {
-        match (left, right) {
+    fn eq_ty(&mut self, left: &Ty<'_>, right: &Ty<'_>) -> bool {
+        match (&left.kind, &right.kind) {
             (&TyKind::Slice(ref l_vec), &TyKind::Slice(ref r_vec)) => self.eq_ty(l_vec, r_vec),
             (&TyKind::Array(ref lt, ref ll_id), &TyKind::Array(ref rt, ref rl_id)) => {
                 let cx = self.inner.cx;
-- 
cgit 1.4.1-3-g733a5


From 3b8e85a5dccd47c7284b30ad29d3144d5c152235 Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Thu, 25 Mar 2021 00:15:15 +0900
Subject: fix false positive in manual_flatten

---
 clippy_lints/src/loops/manual_flatten.rs | 10 +++-
 tests/ui/manual_flatten.rs               | 22 +++++++++
 tests/ui/manual_flatten.stderr           | 85 +++++++++++++++++++++++++++-----
 3 files changed, 105 insertions(+), 12 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/manual_flatten.rs b/clippy_lints/src/loops/manual_flatten.rs
index be87f67d300..8d2b9cccba4 100644
--- a/clippy_lints/src/loops/manual_flatten.rs
+++ b/clippy_lints/src/loops/manual_flatten.rs
@@ -6,6 +6,7 @@ use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, MatchSource, Pat, PatKind, QPath, StmtKind};
 use rustc_lint::LateContext;
+use rustc_middle::ty;
 use rustc_span::source_map::Span;
 
 /// Check for unnecessary `if let` usage in a for loop where only the `Some` or `Ok` variant of the
@@ -54,6 +55,13 @@ pub(super) fn check<'tcx>(
                 // Prepare the help message
                 let mut applicability = Applicability::MaybeIncorrect;
                 let arg_snippet = make_iterator_snippet(cx, arg, &mut applicability);
+                let copied = match cx.typeck_results().expr_ty(match_expr).kind() {
+                    ty::Ref(_, inner, _) => match inner.kind() {
+                        ty::Ref(..) => ".copied()",
+                        _ => ""
+                    }
+                    _ => ""
+                };
 
                 span_lint_and_then(
                     cx,
@@ -61,7 +69,7 @@ pub(super) fn check<'tcx>(
                     span,
                     &msg,
                     |diag| {
-                        let sugg = format!("{}.flatten()", arg_snippet);
+                        let sugg = format!("{}{}.flatten()", arg_snippet, copied);
                         diag.span_suggestion(
                             arg.span,
                             "try",
diff --git a/tests/ui/manual_flatten.rs b/tests/ui/manual_flatten.rs
index cff68eca933..b5bd35a6878 100644
--- a/tests/ui/manual_flatten.rs
+++ b/tests/ui/manual_flatten.rs
@@ -1,4 +1,5 @@
 #![warn(clippy::manual_flatten)]
+#![allow(clippy::useless_vec)]
 
 fn main() {
     // Test for loop over implicitly adjusted `Iterator` with `if let` expression
@@ -69,6 +70,27 @@ fn main() {
         }
     }
 
+    let vec_of_ref = vec![&Some(1)];
+    for n in &vec_of_ref {
+        if let Some(n) = n {
+            println!("{:?}", n);
+        }
+    }
+
+    let vec_of_ref = &vec_of_ref;
+    for n in vec_of_ref {
+        if let Some(n) = n {
+            println!("{:?}", n);
+        }
+    }
+
+    let slice_of_ref = &[&Some(1)];
+    for n in slice_of_ref {
+        if let Some(n) = n {
+            println!("{:?}", n);
+        }
+    }
+
     // Using manual flatten should not trigger the lint
     for n in vec![Some(1), Some(2), Some(3)].iter().flatten() {
         println!("{}", n);
diff --git a/tests/ui/manual_flatten.stderr b/tests/ui/manual_flatten.stderr
index 855dd9130e2..be5f8a1d818 100644
--- a/tests/ui/manual_flatten.stderr
+++ b/tests/ui/manual_flatten.stderr
@@ -1,5 +1,5 @@
 error: unnecessary `if let` since only the `Some` variant of the iterator element is used
-  --> $DIR/manual_flatten.rs:6:5
+  --> $DIR/manual_flatten.rs:7:5
    |
 LL |       for n in x {
    |       ^        - help: try: `x.into_iter().flatten()`
@@ -13,7 +13,7 @@ LL | |     }
    |
    = note: `-D clippy::manual-flatten` implied by `-D warnings`
 help: ...and remove the `if let` statement in the for loop
-  --> $DIR/manual_flatten.rs:7:9
+  --> $DIR/manual_flatten.rs:8:9
    |
 LL | /         if let Some(y) = n {
 LL | |             println!("{}", y);
@@ -21,7 +21,7 @@ LL | |         }
    | |_________^
 
 error: unnecessary `if let` since only the `Ok` variant of the iterator element is used
-  --> $DIR/manual_flatten.rs:14:5
+  --> $DIR/manual_flatten.rs:15:5
    |
 LL |       for n in y.clone() {
    |       ^        --------- help: try: `y.clone().into_iter().flatten()`
@@ -34,7 +34,7 @@ LL | |     }
    | |_____^
    |
 help: ...and remove the `if let` statement in the for loop
-  --> $DIR/manual_flatten.rs:15:9
+  --> $DIR/manual_flatten.rs:16:9
    |
 LL | /         if let Ok(n) = n {
 LL | |             println!("{}", n);
@@ -42,7 +42,7 @@ LL | |         };
    | |_________^
 
 error: unnecessary `if let` since only the `Ok` variant of the iterator element is used
-  --> $DIR/manual_flatten.rs:21:5
+  --> $DIR/manual_flatten.rs:22:5
    |
 LL |       for n in &y {
    |       ^        -- help: try: `y.iter().flatten()`
@@ -55,7 +55,7 @@ LL | |     }
    | |_____^
    |
 help: ...and remove the `if let` statement in the for loop
-  --> $DIR/manual_flatten.rs:22:9
+  --> $DIR/manual_flatten.rs:23:9
    |
 LL | /         if let Ok(n) = n {
 LL | |             println!("{}", n);
@@ -63,7 +63,7 @@ LL | |         }
    | |_________^
 
 error: unnecessary `if let` since only the `Ok` variant of the iterator element is used
-  --> $DIR/manual_flatten.rs:31:5
+  --> $DIR/manual_flatten.rs:32:5
    |
 LL |       for n in z {
    |       ^        - help: try: `z.into_iter().flatten()`
@@ -76,7 +76,7 @@ LL | |     }
    | |_____^
    |
 help: ...and remove the `if let` statement in the for loop
-  --> $DIR/manual_flatten.rs:32:9
+  --> $DIR/manual_flatten.rs:33:9
    |
 LL | /         if let Ok(n) = n {
 LL | |             println!("{}", n);
@@ -84,7 +84,7 @@ LL | |         }
    | |_________^
 
 error: unnecessary `if let` since only the `Some` variant of the iterator element is used
-  --> $DIR/manual_flatten.rs:40:5
+  --> $DIR/manual_flatten.rs:41:5
    |
 LL |       for n in z {
    |       ^        - help: try: `z.flatten()`
@@ -97,12 +97,75 @@ LL | |     }
    | |_____^
    |
 help: ...and remove the `if let` statement in the for loop
-  --> $DIR/manual_flatten.rs:41:9
+  --> $DIR/manual_flatten.rs:42:9
    |
 LL | /         if let Some(m) = n {
 LL | |             println!("{}", m);
 LL | |         }
    | |_________^
 
-error: aborting due to 5 previous errors
+error: unnecessary `if let` since only the `Some` variant of the iterator element is used
+  --> $DIR/manual_flatten.rs:74:5
+   |
+LL |       for n in &vec_of_ref {
+   |       ^        ----------- help: try: `vec_of_ref.iter().copied().flatten()`
+   |  _____|
+   | |
+LL | |         if let Some(n) = n {
+LL | |             println!("{:?}", n);
+LL | |         }
+LL | |     }
+   | |_____^
+   |
+help: ...and remove the `if let` statement in the for loop
+  --> $DIR/manual_flatten.rs:75:9
+   |
+LL | /         if let Some(n) = n {
+LL | |             println!("{:?}", n);
+LL | |         }
+   | |_________^
+
+error: unnecessary `if let` since only the `Some` variant of the iterator element is used
+  --> $DIR/manual_flatten.rs:81:5
+   |
+LL |       for n in vec_of_ref {
+   |       ^        ---------- help: try: `vec_of_ref.into_iter().copied().flatten()`
+   |  _____|
+   | |
+LL | |         if let Some(n) = n {
+LL | |             println!("{:?}", n);
+LL | |         }
+LL | |     }
+   | |_____^
+   |
+help: ...and remove the `if let` statement in the for loop
+  --> $DIR/manual_flatten.rs:82:9
+   |
+LL | /         if let Some(n) = n {
+LL | |             println!("{:?}", n);
+LL | |         }
+   | |_________^
+
+error: unnecessary `if let` since only the `Some` variant of the iterator element is used
+  --> $DIR/manual_flatten.rs:88:5
+   |
+LL |       for n in slice_of_ref {
+   |       ^        ------------ help: try: `slice_of_ref.into_iter().copied().flatten()`
+   |  _____|
+   | |
+LL | |         if let Some(n) = n {
+LL | |             println!("{:?}", n);
+LL | |         }
+LL | |     }
+   | |_____^
+   |
+help: ...and remove the `if let` statement in the for loop
+  --> $DIR/manual_flatten.rs:89:9
+   |
+LL | /         if let Some(n) = n {
+LL | |             println!("{:?}", n);
+LL | |         }
+   | |_________^
+
+error: aborting due to 8 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 2f8d71b9dc5cbb2a26ecd88f943c8a225e28108f Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Thu, 25 Mar 2021 00:17:43 +0900
Subject: merge imports

---
 clippy_lints/src/methods/utils.rs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/utils.rs b/clippy_lints/src/methods/utils.rs
index 8de23e1bc6e..ac6b55396da 100644
--- a/clippy_lints/src/methods/utils.rs
+++ b/clippy_lints/src/methods/utils.rs
@@ -5,8 +5,7 @@ use rustc_ast::ast;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
-use rustc_middle::ty;
-use rustc_middle::ty::Ty;
+use rustc_middle::ty::{self, Ty};
 use rustc_span::symbol::sym;
 
 pub(super) fn derefs_to_slice<'tcx>(
-- 
cgit 1.4.1-3-g733a5


From 99b8a671981eb9bf2c624027940bf9ae4cd23087 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Mon, 22 Mar 2021 21:38:14 -0400
Subject: Fix false positive with `new_ret_no_self` when returning `Self` with
 different generic arguments

---
 clippy_lints/src/methods/mod.rs | 14 +++++++++++---
 clippy_utils/src/ty.rs          | 11 ++++++++++-
 tests/ui/new_ret_no_self.rs     | 10 ++++++++++
 3 files changed, 31 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index d77f9c03cae..b6be77b03e5 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -61,7 +61,7 @@ mod zst_offset;
 
 use bind_instead_of_map::BindInsteadOfMap;
 use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
-use clippy_utils::ty::{contains_ty, implements_trait, is_copy, is_type_diagnostic_item};
+use clippy_utils::ty::{contains_adt, contains_ty, implements_trait, is_copy, is_type_diagnostic_item};
 use clippy_utils::{contains_return, get_trait_def_id, in_macro, iter_input_pats, method_calls, paths, return_ty};
 use if_chain::if_chain;
 use rustc_hir as hir;
@@ -1916,7 +1916,11 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             let ret_ty = return_ty(cx, impl_item.hir_id());
 
             // walk the return type and check for Self (this does not check associated types)
-            if contains_ty(ret_ty, self_ty) {
+            if let Some(self_adt) = self_ty.ty_adt_def() {
+                if contains_adt(ret_ty, self_adt) {
+                    return;
+                }
+            } else if contains_ty(ret_ty, self_ty) {
                 return;
             }
 
@@ -1926,7 +1930,11 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
                 for &(predicate, _span) in cx.tcx.explicit_item_bounds(def_id) {
                     if let ty::PredicateKind::Projection(projection_predicate) = predicate.kind().skip_binder() {
                         // walk the associated type and check for Self
-                        if contains_ty(projection_predicate.ty, self_ty) {
+                        if let Some(self_adt) = self_ty.ty_adt_def() {
+                            if contains_adt(projection_predicate.ty, self_adt) {
+                                return;
+                            }
+                        } else if contains_ty(projection_predicate.ty, self_ty) {
                             return;
                         }
                     }
diff --git a/clippy_utils/src/ty.rs b/clippy_utils/src/ty.rs
index f4a1ae67da3..b9724efb04f 100644
--- a/clippy_utils/src/ty.rs
+++ b/clippy_utils/src/ty.rs
@@ -11,7 +11,7 @@ use rustc_hir::{TyKind, Unsafety};
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::LateContext;
 use rustc_middle::ty::subst::{GenericArg, GenericArgKind};
-use rustc_middle::ty::{self, IntTy, Ty, TypeFoldable, UintTy};
+use rustc_middle::ty::{self, AdtDef, IntTy, Ty, TypeFoldable, UintTy};
 use rustc_span::sym;
 use rustc_span::symbol::Symbol;
 use rustc_span::DUMMY_SP;
@@ -43,6 +43,15 @@ pub fn contains_ty(ty: Ty<'_>, other_ty: Ty<'_>) -> bool {
     })
 }
 
+/// Walks into `ty` and returns `true` if any inner type is any instance of the given abstract data
+/// type.`
+pub fn contains_adt(ty: Ty<'_>, adt: &AdtDef) -> bool {
+    ty.walk().any(|inner| match inner.unpack() {
+        GenericArgKind::Type(inner_ty) => inner_ty.ty_adt_def() == Some(adt),
+        GenericArgKind::Lifetime(_) | GenericArgKind::Const(_) => false,
+    })
+}
+
 /// Returns true if ty has `iter` or `iter_mut` methods
 pub fn has_iter_method(cx: &LateContext<'_>, probably_ref_ty: Ty<'_>) -> Option<Symbol> {
     // FIXME: instead of this hard-coded list, we should check if `<adt>::iter`
diff --git a/tests/ui/new_ret_no_self.rs b/tests/ui/new_ret_no_self.rs
index e82873629a5..2f315ffe298 100644
--- a/tests/ui/new_ret_no_self.rs
+++ b/tests/ui/new_ret_no_self.rs
@@ -340,3 +340,13 @@ mod issue5435 {
         }
     }
 }
+
+// issue #1724
+struct RetOtherSelf<T>(T);
+struct RetOtherSelfWrapper<T>(T);
+
+impl RetOtherSelf<T> {
+    fn new(t: T) -> RetOtherSelf<RetOtherSelfWrapper<T>> {
+        RetOtherSelf(RetOtherSelfWrapper(t))
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 6e88900f9ecc3b1e9ffce777d5e74e0eb3554ef4 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Wed, 24 Mar 2021 16:19:27 -0400
Subject: Rename `contains_adt` to `contains_adt_constructor`

---
 clippy_lints/src/methods/mod.rs | 6 +++---
 clippy_utils/src/ty.rs          | 6 +++---
 2 files changed, 6 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index b6be77b03e5..fccdee07877 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -61,7 +61,7 @@ mod zst_offset;
 
 use bind_instead_of_map::BindInsteadOfMap;
 use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
-use clippy_utils::ty::{contains_adt, contains_ty, implements_trait, is_copy, is_type_diagnostic_item};
+use clippy_utils::ty::{contains_adt_constructor, contains_ty, implements_trait, is_copy, is_type_diagnostic_item};
 use clippy_utils::{contains_return, get_trait_def_id, in_macro, iter_input_pats, method_calls, paths, return_ty};
 use if_chain::if_chain;
 use rustc_hir as hir;
@@ -1917,7 +1917,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
 
             // walk the return type and check for Self (this does not check associated types)
             if let Some(self_adt) = self_ty.ty_adt_def() {
-                if contains_adt(ret_ty, self_adt) {
+                if contains_adt_constructor(ret_ty, self_adt) {
                     return;
                 }
             } else if contains_ty(ret_ty, self_ty) {
@@ -1931,7 +1931,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
                     if let ty::PredicateKind::Projection(projection_predicate) = predicate.kind().skip_binder() {
                         // walk the associated type and check for Self
                         if let Some(self_adt) = self_ty.ty_adt_def() {
-                            if contains_adt(projection_predicate.ty, self_adt) {
+                            if contains_adt_constructor(projection_predicate.ty, self_adt) {
                                 return;
                             }
                         } else if contains_ty(projection_predicate.ty, self_ty) {
diff --git a/clippy_utils/src/ty.rs b/clippy_utils/src/ty.rs
index b9724efb04f..807cfbc4c7f 100644
--- a/clippy_utils/src/ty.rs
+++ b/clippy_utils/src/ty.rs
@@ -43,9 +43,9 @@ pub fn contains_ty(ty: Ty<'_>, other_ty: Ty<'_>) -> bool {
     })
 }
 
-/// Walks into `ty` and returns `true` if any inner type is any instance of the given abstract data
-/// type.`
-pub fn contains_adt(ty: Ty<'_>, adt: &AdtDef) -> bool {
+/// Walks into `ty` and returns `true` if any inner type is an instance of the given adt
+/// constructor.
+pub fn contains_adt_constructor(ty: Ty<'_>, adt: &AdtDef) -> bool {
     ty.walk().any(|inner| match inner.unpack() {
         GenericArgKind::Type(inner_ty) => inner_ty.ty_adt_def() == Some(adt),
         GenericArgKind::Lifetime(_) | GenericArgKind::Const(_) => false,
-- 
cgit 1.4.1-3-g733a5


From e9ebc27525757f967131ecb3570c1438f8de4efb Mon Sep 17 00:00:00 2001
From: Elliot Bobrow <elliotgreybobrow@gmail.com>
Date: Tue, 23 Mar 2021 17:10:27 -0700
Subject: check for `.to_string().into_bytes()` in string_lit_to_bytes

apply changes from review
---
 clippy_lints/src/strings.rs         | 29 +++++++++++++++++++++++++++++
 tests/ui/string_lit_as_bytes.fixed  |  6 ++++++
 tests/ui/string_lit_as_bytes.rs     |  6 ++++++
 tests/ui/string_lit_as_bytes.stderr | 18 +++++++++++++++---
 4 files changed, 56 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/strings.rs b/clippy_lints/src/strings.rs
index 760f5e3b432..99ca7ef77a5 100644
--- a/clippy_lints/src/strings.rs
+++ b/clippy_lints/src/strings.rs
@@ -284,6 +284,35 @@ impl<'tcx> LateLintPass<'tcx> for StringLitAsBytes {
                 }
             }
         }
+
+        if_chain! {
+            if let ExprKind::MethodCall(path, _, [recv], _) = &e.kind;
+            if path.ident.name == sym!(into_bytes);
+            if let ExprKind::MethodCall(path, _, [recv], _) = &recv.kind;
+            if matches!(&*path.ident.name.as_str(), "to_owned" | "to_string");
+            if let ExprKind::Lit(lit) = &recv.kind;
+            if let LitKind::Str(lit_content, _) = &lit.node;
+
+            if lit_content.as_str().is_ascii();
+            if lit_content.as_str().len() <= MAX_LENGTH_BYTE_STRING_LIT;
+            if !recv.span.from_expansion();
+            then {
+                let mut applicability = Applicability::MachineApplicable;
+
+                span_lint_and_sugg(
+                    cx,
+                    STRING_LIT_AS_BYTES,
+                    e.span,
+                    "calling `into_bytes()` on a string literal",
+                    "consider using a byte string literal instead",
+                    format!(
+                        "b{}.to_vec()",
+                        snippet_with_applicability(cx, recv.span, r#""..""#, &mut applicability)
+                    ),
+                    applicability,
+                );
+            }
+        }
     }
 }
 
diff --git a/tests/ui/string_lit_as_bytes.fixed b/tests/ui/string_lit_as_bytes.fixed
index ccf8f61c4a9..dd22bfa5c53 100644
--- a/tests/ui/string_lit_as_bytes.fixed
+++ b/tests/ui/string_lit_as_bytes.fixed
@@ -8,10 +8,16 @@ fn str_lit_as_bytes() {
 
     let bs = br###"raw string with 3# plus " ""###;
 
+    let bs = b"lit to string".to_vec();
+    let bs = b"lit to owned".to_vec();
+
     // no warning, because these cannot be written as byte string literals:
     let ubs = "☃".as_bytes();
     let ubs = "hello there! this is a very long string".as_bytes();
 
+    let ubs = "☃".to_string().into_bytes();
+    let ubs = "this is also too long and shouldn't be fixed".to_string().into_bytes();
+
     let strify = stringify!(foobar).as_bytes();
 
     let current_version = env!("CARGO_PKG_VERSION").as_bytes();
diff --git a/tests/ui/string_lit_as_bytes.rs b/tests/ui/string_lit_as_bytes.rs
index 178df08e249..d2a710ed6b8 100644
--- a/tests/ui/string_lit_as_bytes.rs
+++ b/tests/ui/string_lit_as_bytes.rs
@@ -8,10 +8,16 @@ fn str_lit_as_bytes() {
 
     let bs = r###"raw string with 3# plus " ""###.as_bytes();
 
+    let bs = "lit to string".to_string().into_bytes();
+    let bs = "lit to owned".to_owned().into_bytes();
+
     // no warning, because these cannot be written as byte string literals:
     let ubs = "☃".as_bytes();
     let ubs = "hello there! this is a very long string".as_bytes();
 
+    let ubs = "☃".to_string().into_bytes();
+    let ubs = "this is also too long and shouldn't be fixed".to_string().into_bytes();
+
     let strify = stringify!(foobar).as_bytes();
 
     let current_version = env!("CARGO_PKG_VERSION").as_bytes();
diff --git a/tests/ui/string_lit_as_bytes.stderr b/tests/ui/string_lit_as_bytes.stderr
index 99c512354d5..e0ddb070b50 100644
--- a/tests/ui/string_lit_as_bytes.stderr
+++ b/tests/ui/string_lit_as_bytes.stderr
@@ -12,17 +12,29 @@ error: calling `as_bytes()` on a string literal
 LL |     let bs = r###"raw string with 3# plus " ""###.as_bytes();
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using a byte string literal instead: `br###"raw string with 3# plus " ""###`
 
+error: calling `into_bytes()` on a string literal
+  --> $DIR/string_lit_as_bytes.rs:11:14
+   |
+LL |     let bs = "lit to string".to_string().into_bytes();
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using a byte string literal instead: `b"lit to string".to_vec()`
+
+error: calling `into_bytes()` on a string literal
+  --> $DIR/string_lit_as_bytes.rs:12:14
+   |
+LL |     let bs = "lit to owned".to_owned().into_bytes();
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using a byte string literal instead: `b"lit to owned".to_vec()`
+
 error: calling `as_bytes()` on `include_str!(..)`
-  --> $DIR/string_lit_as_bytes.rs:19:22
+  --> $DIR/string_lit_as_bytes.rs:25:22
    |
 LL |     let includestr = include_str!("entry_unfixable.rs").as_bytes();
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `include_bytes!(..)` instead: `include_bytes!("entry_unfixable.rs")`
 
 error: calling `as_bytes()` on a string literal
-  --> $DIR/string_lit_as_bytes.rs:21:13
+  --> $DIR/string_lit_as_bytes.rs:27:13
    |
 LL |     let _ = "string with newline/t/n".as_bytes();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using a byte string literal instead: `b"string with newline/t/n"`
 
-error: aborting due to 4 previous errors
+error: aborting due to 6 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 0ff68bb151ee8e93c0a6aff9f3cda3ac3f757d2f Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Thu, 25 Mar 2021 22:30:14 -0400
Subject: Improve `redundant_slicing` Fix bad suggestion when a reborrow might
 be required Fix bad suggestion when the value being sliced is a macro call
 Don't lint inside of a macro due to the previous context sensitive changes

---
 clippy_lints/src/redundant_slicing.rs | 37 ++++++++++++++++++++++++++---------
 tests/ui/redundant_slicing.rs         | 29 +++++++++++++++++++++++----
 tests/ui/redundant_slicing.stderr     | 32 +++++++++++++++++++++++-------
 3 files changed, 78 insertions(+), 20 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/redundant_slicing.rs b/clippy_lints/src/redundant_slicing.rs
index 6da7b5fbcc8..9c6cd7b4fa6 100644
--- a/clippy_lints/src/redundant_slicing.rs
+++ b/clippy_lints/src/redundant_slicing.rs
@@ -1,11 +1,12 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::source::snippet_with_context;
 use clippy_utils::ty::is_type_lang_item;
+use clippy_utils::{get_parent_expr, in_macro};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
-use rustc_hir::{Expr, ExprKind, LangItem};
-use rustc_lint::{LateContext, LateLintPass, LintContext};
-use rustc_middle::{lint::in_external_macro, ty::TyS};
+use rustc_hir::{BorrowKind, Expr, ExprKind, LangItem, Mutability};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::TyS;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
@@ -40,26 +41,44 @@ declare_lint_pass!(RedundantSlicing => [REDUNDANT_SLICING]);
 
 impl LateLintPass<'_> for RedundantSlicing {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if in_external_macro(cx.sess(), expr.span) {
+        if in_macro(expr.span) {
             return;
         }
 
+        let ctxt = expr.span.ctxt();
         if_chain! {
-            if let ExprKind::AddrOf(_, _, addressee) = expr.kind;
+            if let ExprKind::AddrOf(BorrowKind::Ref, mutability, addressee) = expr.kind;
+            if addressee.span.ctxt() == ctxt;
             if let ExprKind::Index(indexed, range) = addressee.kind;
             if is_type_lang_item(cx, cx.typeck_results().expr_ty_adjusted(range), LangItem::RangeFull);
             if TyS::same_type(cx.typeck_results().expr_ty(expr), cx.typeck_results().expr_ty(indexed));
             then {
                 let mut app = Applicability::MachineApplicable;
-                let hint = snippet_with_applicability(cx, indexed.span, "..", &mut app).into_owned();
+                let snip = snippet_with_context(cx, indexed.span, ctxt, "..", &mut app).0;
+
+                let (reborrow_str, help_str) = if mutability == Mutability::Mut {
+                    // The slice was used to reborrow the mutable reference.
+                    ("&mut *", "reborrow the original value instead")
+                } else if matches!(
+                    get_parent_expr(cx, expr),
+                    Some(Expr {
+                        kind: ExprKind::AddrOf(BorrowKind::Ref, Mutability::Mut, _),
+                        ..
+                    })
+                ) {
+                    // The slice was used to make a temporary reference.
+                    ("&*", "reborrow the original value instead")
+                } else {
+                    ("", "use the original value instead")
+                };
 
                 span_lint_and_sugg(
                     cx,
                     REDUNDANT_SLICING,
                     expr.span,
                     "redundant slicing of the whole range",
-                    "use the original slice instead",
-                    hint,
+                    help_str,
+                    format!("{}{}", reborrow_str, snip),
                     app,
                 );
             }
diff --git a/tests/ui/redundant_slicing.rs b/tests/ui/redundant_slicing.rs
index 922b8b4ce57..554b6ba36ae 100644
--- a/tests/ui/redundant_slicing.rs
+++ b/tests/ui/redundant_slicing.rs
@@ -2,10 +2,31 @@
 #![warn(clippy::redundant_slicing)]
 
 fn main() {
-    let x: &[u32] = &[0];
-    let err = &x[..];
+    let slice: &[u32] = &[0];
+    let _ = &slice[..];
 
     let v = vec![0];
-    let ok = &v[..];
-    let err = &(&v[..])[..];
+    let _ = &v[..]; // Changes the type
+    let _ = &(&v[..])[..]; // Outer borrow is redundant
+
+    static S: &[u8] = &[0, 1, 2];
+    let err = &mut &S[..]; // Should reborrow instead of slice
+
+    let mut vec = vec![0];
+    let mut_slice = &mut *vec;
+    let _ = &mut mut_slice[..]; // Should reborrow instead of slice
+
+    macro_rules! m {
+        ($e:expr) => {
+            $e
+        };
+    }
+    let _ = &m!(slice)[..];
+
+    macro_rules! m2 {
+        ($e:expr) => {
+            &$e[..]
+        };
+    }
+    let _ = m2!(slice); // Don't lint in a macro
 }
diff --git a/tests/ui/redundant_slicing.stderr b/tests/ui/redundant_slicing.stderr
index 9efd6484ad0..bbd10eafbbe 100644
--- a/tests/ui/redundant_slicing.stderr
+++ b/tests/ui/redundant_slicing.stderr
@@ -1,16 +1,34 @@
 error: redundant slicing of the whole range
-  --> $DIR/redundant_slicing.rs:6:15
+  --> $DIR/redundant_slicing.rs:6:13
    |
-LL |     let err = &x[..];
-   |               ^^^^^^ help: use the original slice instead: `x`
+LL |     let _ = &slice[..];
+   |             ^^^^^^^^^^ help: use the original value instead: `slice`
    |
    = note: `-D clippy::redundant-slicing` implied by `-D warnings`
 
 error: redundant slicing of the whole range
-  --> $DIR/redundant_slicing.rs:10:15
+  --> $DIR/redundant_slicing.rs:10:13
    |
-LL |     let err = &(&v[..])[..];
-   |               ^^^^^^^^^^^^^ help: use the original slice instead: `(&v[..])`
+LL |     let _ = &(&v[..])[..]; // Outer borrow is redundant
+   |             ^^^^^^^^^^^^^ help: use the original value instead: `(&v[..])`
 
-error: aborting due to 2 previous errors
+error: redundant slicing of the whole range
+  --> $DIR/redundant_slicing.rs:13:20
+   |
+LL |     let err = &mut &S[..]; // Should reborrow instead of slice
+   |                    ^^^^^^ help: reborrow the original value instead: `&*S`
+
+error: redundant slicing of the whole range
+  --> $DIR/redundant_slicing.rs:17:13
+   |
+LL |     let _ = &mut mut_slice[..]; // Should reborrow instead of slice
+   |             ^^^^^^^^^^^^^^^^^^ help: reborrow the original value instead: `&mut *mut_slice`
+
+error: redundant slicing of the whole range
+  --> $DIR/redundant_slicing.rs:24:13
+   |
+LL |     let _ = &m!(slice)[..];
+   |             ^^^^^^^^^^^^^^ help: use the original value instead: `slice`
+
+error: aborting due to 5 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From caa49c85d6c1d45678d1065c689cc4d168e18dfb Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Thu, 18 Mar 2021 16:03:56 +0900
Subject: Move absurd_extreme_comparisons to its own module

---
 clippy_lints/src/absurd_extreme_comparisons.rs | 173 ++++++++++++++++++++++++
 clippy_lints/src/lib.rs                        |   9 +-
 clippy_lints/src/types/mod.rs                  | 178 +------------------------
 3 files changed, 183 insertions(+), 177 deletions(-)
 create mode 100644 clippy_lints/src/absurd_extreme_comparisons.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/absurd_extreme_comparisons.rs b/clippy_lints/src/absurd_extreme_comparisons.rs
new file mode 100644
index 00000000000..33c720c666e
--- /dev/null
+++ b/clippy_lints/src/absurd_extreme_comparisons.rs
@@ -0,0 +1,173 @@
+use rustc_hir::{BinOpKind, Expr, ExprKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+use crate::consts::{constant, Constant};
+
+use clippy_utils::comparisons::{normalize_comparison, Rel};
+use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::source::snippet;
+use clippy_utils::ty::is_isize_or_usize;
+use clippy_utils::{clip, int_bits, unsext};
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for comparisons where one side of the relation is
+    /// either the minimum or maximum value for its type and warns if it involves a
+    /// case that is always true or always false. Only integer and boolean types are
+    /// checked.
+    ///
+    /// **Why is this bad?** An expression like `min <= x` may misleadingly imply
+    /// that it is possible for `x` to be less than the minimum. Expressions like
+    /// `max < x` are probably mistakes.
+    ///
+    /// **Known problems:** For `usize` the size of the current compile target will
+    /// be assumed (e.g., 64 bits on 64 bit systems). This means code that uses such
+    /// a comparison to detect target pointer width will trigger this lint. One can
+    /// use `mem::sizeof` and compare its value or conditional compilation
+    /// attributes
+    /// like `#[cfg(target_pointer_width = "64")] ..` instead.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// let vec: Vec<isize> = Vec::new();
+    /// if vec.len() <= 0 {}
+    /// if 100 > i32::MAX {}
+    /// ```
+    pub ABSURD_EXTREME_COMPARISONS,
+    correctness,
+    "a comparison with a maximum or minimum value that is always true or false"
+}
+
+declare_lint_pass!(AbsurdExtremeComparisons => [ABSURD_EXTREME_COMPARISONS]);
+
+impl<'tcx> LateLintPass<'tcx> for AbsurdExtremeComparisons {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        if let ExprKind::Binary(ref cmp, ref lhs, ref rhs) = expr.kind {
+            if let Some((culprit, result)) = detect_absurd_comparison(cx, cmp.node, lhs, rhs) {
+                if !expr.span.from_expansion() {
+                    let msg = "this comparison involving the minimum or maximum element for this \
+                               type contains a case that is always true or always false";
+
+                    let conclusion = match result {
+                        AbsurdComparisonResult::AlwaysFalse => "this comparison is always false".to_owned(),
+                        AbsurdComparisonResult::AlwaysTrue => "this comparison is always true".to_owned(),
+                        AbsurdComparisonResult::InequalityImpossible => format!(
+                            "the case where the two sides are not equal never occurs, consider using `{} == {}` \
+                             instead",
+                            snippet(cx, lhs.span, "lhs"),
+                            snippet(cx, rhs.span, "rhs")
+                        ),
+                    };
+
+                    let help = format!(
+                        "because `{}` is the {} value for this type, {}",
+                        snippet(cx, culprit.expr.span, "x"),
+                        match culprit.which {
+                            ExtremeType::Minimum => "minimum",
+                            ExtremeType::Maximum => "maximum",
+                        },
+                        conclusion
+                    );
+
+                    span_lint_and_help(cx, ABSURD_EXTREME_COMPARISONS, expr.span, msg, None, &help);
+                }
+            }
+        }
+    }
+}
+
+enum ExtremeType {
+    Minimum,
+    Maximum,
+}
+
+struct ExtremeExpr<'a> {
+    which: ExtremeType,
+    expr: &'a Expr<'a>,
+}
+
+enum AbsurdComparisonResult {
+    AlwaysFalse,
+    AlwaysTrue,
+    InequalityImpossible,
+}
+
+fn is_cast_between_fixed_and_target<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
+    if let ExprKind::Cast(ref cast_exp, _) = expr.kind {
+        let precast_ty = cx.typeck_results().expr_ty(cast_exp);
+        let cast_ty = cx.typeck_results().expr_ty(expr);
+
+        return is_isize_or_usize(precast_ty) != is_isize_or_usize(cast_ty);
+    }
+
+    false
+}
+
+fn detect_absurd_comparison<'tcx>(
+    cx: &LateContext<'tcx>,
+    op: BinOpKind,
+    lhs: &'tcx Expr<'_>,
+    rhs: &'tcx Expr<'_>,
+) -> Option<(ExtremeExpr<'tcx>, AbsurdComparisonResult)> {
+    use AbsurdComparisonResult::{AlwaysFalse, AlwaysTrue, InequalityImpossible};
+    use ExtremeType::{Maximum, Minimum};
+    // absurd comparison only makes sense on primitive types
+    // primitive types don't implement comparison operators with each other
+    if cx.typeck_results().expr_ty(lhs) != cx.typeck_results().expr_ty(rhs) {
+        return None;
+    }
+
+    // comparisons between fix sized types and target sized types are considered unanalyzable
+    if is_cast_between_fixed_and_target(cx, lhs) || is_cast_between_fixed_and_target(cx, rhs) {
+        return None;
+    }
+
+    let (rel, normalized_lhs, normalized_rhs) = normalize_comparison(op, lhs, rhs)?;
+
+    let lx = detect_extreme_expr(cx, normalized_lhs);
+    let rx = detect_extreme_expr(cx, normalized_rhs);
+
+    Some(match rel {
+        Rel::Lt => {
+            match (lx, rx) {
+                (Some(l @ ExtremeExpr { which: Maximum, .. }), _) => (l, AlwaysFalse), // max < x
+                (_, Some(r @ ExtremeExpr { which: Minimum, .. })) => (r, AlwaysFalse), // x < min
+                _ => return None,
+            }
+        },
+        Rel::Le => {
+            match (lx, rx) {
+                (Some(l @ ExtremeExpr { which: Minimum, .. }), _) => (l, AlwaysTrue), // min <= x
+                (Some(l @ ExtremeExpr { which: Maximum, .. }), _) => (l, InequalityImpossible), // max <= x
+                (_, Some(r @ ExtremeExpr { which: Minimum, .. })) => (r, InequalityImpossible), // x <= min
+                (_, Some(r @ ExtremeExpr { which: Maximum, .. })) => (r, AlwaysTrue), // x <= max
+                _ => return None,
+            }
+        },
+        Rel::Ne | Rel::Eq => return None,
+    })
+}
+
+fn detect_extreme_expr<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<ExtremeExpr<'tcx>> {
+    let ty = cx.typeck_results().expr_ty(expr);
+
+    let cv = constant(cx, cx.typeck_results(), expr)?.0;
+
+    let which = match (ty.kind(), cv) {
+        (&ty::Bool, Constant::Bool(false)) | (&ty::Uint(_), Constant::Int(0)) => ExtremeType::Minimum,
+        (&ty::Int(ity), Constant::Int(i)) if i == unsext(cx.tcx, i128::MIN >> (128 - int_bits(cx.tcx, ity)), ity) => {
+            ExtremeType::Minimum
+        },
+
+        (&ty::Bool, Constant::Bool(true)) => ExtremeType::Maximum,
+        (&ty::Int(ity), Constant::Int(i)) if i == unsext(cx.tcx, i128::MAX >> (128 - int_bits(cx.tcx, ity)), ity) => {
+            ExtremeType::Maximum
+        },
+        (&ty::Uint(uty), Constant::Int(i)) if clip(cx.tcx, u128::MAX, uty) == i => ExtremeType::Maximum,
+
+        _ => return None,
+    };
+    Some(ExtremeExpr { which, expr })
+}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 3a9236d8735..7b261121f51 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -164,6 +164,7 @@ mod consts;
 mod utils;
 
 // begin lints modules, do not remove this comment, it’s used in `update_lints`
+mod absurd_extreme_comparisons;
 mod approx_const;
 mod arithmetic;
 mod as_conversions;
@@ -558,6 +559,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &utils::internal_lints::PRODUCE_ICE,
         #[cfg(feature = "internal-lints")]
         &utils::internal_lints::UNNECESSARY_SYMBOL_STR,
+        &absurd_extreme_comparisons::ABSURD_EXTREME_COMPARISONS,
         &approx_const::APPROX_CONSTANT,
         &arithmetic::FLOAT_ARITHMETIC,
         &arithmetic::INTEGER_ARITHMETIC,
@@ -955,7 +957,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &transmute::WRONG_TRANSMUTE,
         &transmuting_null::TRANSMUTING_NULL,
         &try_err::TRY_ERR,
-        &types::ABSURD_EXTREME_COMPARISONS,
         &types::BORROWED_BOX,
         &types::BOX_VEC,
         &types::IMPLICIT_HASHER,
@@ -1112,7 +1113,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box get_last_with_len::GetLastWithLen);
     store.register_late_pass(|| box drop_forget_ref::DropForgetRef);
     store.register_late_pass(|| box empty_enum::EmptyEnum);
-    store.register_late_pass(|| box types::AbsurdExtremeComparisons);
+    store.register_late_pass(|| box absurd_extreme_comparisons::AbsurdExtremeComparisons);
     store.register_late_pass(|| box types::InvalidUpcastComparisons);
     store.register_late_pass(|| box regex::Regex::default());
     store.register_late_pass(|| box copies::CopyAndPaste);
@@ -1442,6 +1443,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     ]);
 
     store.register_group(true, "clippy::all", Some("clippy"), vec![
+        LintId::of(&absurd_extreme_comparisons::ABSURD_EXTREME_COMPARISONS),
         LintId::of(&approx_const::APPROX_CONSTANT),
         LintId::of(&assertions_on_constants::ASSERTIONS_ON_CONSTANTS),
         LintId::of(&assign_ops::ASSIGN_OP_PATTERN),
@@ -1701,7 +1703,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&transmute::WRONG_TRANSMUTE),
         LintId::of(&transmuting_null::TRANSMUTING_NULL),
         LintId::of(&try_err::TRY_ERR),
-        LintId::of(&types::ABSURD_EXTREME_COMPARISONS),
         LintId::of(&types::BORROWED_BOX),
         LintId::of(&types::BOX_VEC),
         LintId::of(&types::REDUNDANT_ALLOCATION),
@@ -1941,6 +1942,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     ]);
 
     store.register_group(true, "clippy::correctness", Some("clippy_correctness"), vec![
+        LintId::of(&absurd_extreme_comparisons::ABSURD_EXTREME_COMPARISONS),
         LintId::of(&approx_const::APPROX_CONSTANT),
         LintId::of(&async_yields_async::ASYNC_YIELDS_ASYNC),
         LintId::of(&atomic_ordering::INVALID_ATOMIC_ORDERING),
@@ -2002,7 +2004,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&transmute::UNSOUND_COLLECTION_TRANSMUTE),
         LintId::of(&transmute::WRONG_TRANSMUTE),
         LintId::of(&transmuting_null::TRANSMUTING_NULL),
-        LintId::of(&types::ABSURD_EXTREME_COMPARISONS),
         LintId::of(&undropped_manually_drops::UNDROPPED_MANUALLY_DROPS),
         LintId::of(&unicode::INVISIBLE_CHARACTERS),
         LintId::of(&unit_return_expecting_ord::UNIT_RETURN_EXPECTING_ORD),
diff --git a/clippy_lints/src/types/mod.rs b/clippy_lints/src/types/mod.rs
index c73c1c9d92d..0c50ed8348e 100644
--- a/clippy_lints/src/types/mod.rs
+++ b/clippy_lints/src/types/mod.rs
@@ -13,16 +13,16 @@ use std::borrow::Cow;
 use std::cmp::Ordering;
 use std::collections::BTreeMap;
 
-use clippy_utils::diagnostics::{multispan_sugg, span_lint, span_lint_and_help, span_lint_and_then};
+use clippy_utils::diagnostics::{multispan_sugg, span_lint, span_lint_and_then};
 use clippy_utils::source::{snippet, snippet_opt};
-use clippy_utils::ty::{is_isize_or_usize, is_type_diagnostic_item};
+use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
 use rustc_errors::DiagnosticBuilder;
 use rustc_hir as hir;
 use rustc_hir::intravisit::{walk_body, walk_expr, walk_ty, FnKind, NestedVisitorMap, Visitor};
 use rustc_hir::{
-    BinOpKind, Body, Expr, ExprKind, FnDecl, FnRetTy, FnSig, GenericArg, GenericParamKind, HirId, ImplItem,
-    ImplItemKind, Item, ItemKind, Local, MutTy, QPath, TraitFn, TraitItem, TraitItemKind, TyKind,
+    Body, Expr, ExprKind, FnDecl, FnRetTy, FnSig, GenericArg, GenericParamKind, HirId, ImplItem, ImplItemKind, Item,
+    ItemKind, Local, MutTy, QPath, TraitFn, TraitItem, TraitItemKind, TyKind,
 };
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::hir::map::Map;
@@ -37,7 +37,7 @@ use rustc_typeck::hir_ty_to_ty;
 
 use crate::consts::{constant, Constant};
 use clippy_utils::paths;
-use clippy_utils::{clip, comparisons, differing_macro_contexts, int_bits, match_path, sext, unsext};
+use clippy_utils::{comparisons, differing_macro_contexts, match_path, sext};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for use of `Box<Vec<_>>` anywhere in the code.
@@ -552,174 +552,6 @@ impl<'tcx> Visitor<'tcx> for TypeComplexityVisitor {
     }
 }
 
-declare_clippy_lint! {
-    /// **What it does:** Checks for comparisons where one side of the relation is
-    /// either the minimum or maximum value for its type and warns if it involves a
-    /// case that is always true or always false. Only integer and boolean types are
-    /// checked.
-    ///
-    /// **Why is this bad?** An expression like `min <= x` may misleadingly imply
-    /// that it is possible for `x` to be less than the minimum. Expressions like
-    /// `max < x` are probably mistakes.
-    ///
-    /// **Known problems:** For `usize` the size of the current compile target will
-    /// be assumed (e.g., 64 bits on 64 bit systems). This means code that uses such
-    /// a comparison to detect target pointer width will trigger this lint. One can
-    /// use `mem::sizeof` and compare its value or conditional compilation
-    /// attributes
-    /// like `#[cfg(target_pointer_width = "64")] ..` instead.
-    ///
-    /// **Example:**
-    ///
-    /// ```rust
-    /// let vec: Vec<isize> = Vec::new();
-    /// if vec.len() <= 0 {}
-    /// if 100 > i32::MAX {}
-    /// ```
-    pub ABSURD_EXTREME_COMPARISONS,
-    correctness,
-    "a comparison with a maximum or minimum value that is always true or false"
-}
-
-declare_lint_pass!(AbsurdExtremeComparisons => [ABSURD_EXTREME_COMPARISONS]);
-
-enum ExtremeType {
-    Minimum,
-    Maximum,
-}
-
-struct ExtremeExpr<'a> {
-    which: ExtremeType,
-    expr: &'a Expr<'a>,
-}
-
-enum AbsurdComparisonResult {
-    AlwaysFalse,
-    AlwaysTrue,
-    InequalityImpossible,
-}
-
-fn is_cast_between_fixed_and_target<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
-    if let ExprKind::Cast(ref cast_exp, _) = expr.kind {
-        let precast_ty = cx.typeck_results().expr_ty(cast_exp);
-        let cast_ty = cx.typeck_results().expr_ty(expr);
-
-        return is_isize_or_usize(precast_ty) != is_isize_or_usize(cast_ty);
-    }
-
-    false
-}
-
-fn detect_absurd_comparison<'tcx>(
-    cx: &LateContext<'tcx>,
-    op: BinOpKind,
-    lhs: &'tcx Expr<'_>,
-    rhs: &'tcx Expr<'_>,
-) -> Option<(ExtremeExpr<'tcx>, AbsurdComparisonResult)> {
-    use crate::types::AbsurdComparisonResult::{AlwaysFalse, AlwaysTrue, InequalityImpossible};
-    use crate::types::ExtremeType::{Maximum, Minimum};
-    use clippy_utils::comparisons::{normalize_comparison, Rel};
-
-    // absurd comparison only makes sense on primitive types
-    // primitive types don't implement comparison operators with each other
-    if cx.typeck_results().expr_ty(lhs) != cx.typeck_results().expr_ty(rhs) {
-        return None;
-    }
-
-    // comparisons between fix sized types and target sized types are considered unanalyzable
-    if is_cast_between_fixed_and_target(cx, lhs) || is_cast_between_fixed_and_target(cx, rhs) {
-        return None;
-    }
-
-    let (rel, normalized_lhs, normalized_rhs) = normalize_comparison(op, lhs, rhs)?;
-
-    let lx = detect_extreme_expr(cx, normalized_lhs);
-    let rx = detect_extreme_expr(cx, normalized_rhs);
-
-    Some(match rel {
-        Rel::Lt => {
-            match (lx, rx) {
-                (Some(l @ ExtremeExpr { which: Maximum, .. }), _) => (l, AlwaysFalse), // max < x
-                (_, Some(r @ ExtremeExpr { which: Minimum, .. })) => (r, AlwaysFalse), // x < min
-                _ => return None,
-            }
-        },
-        Rel::Le => {
-            match (lx, rx) {
-                (Some(l @ ExtremeExpr { which: Minimum, .. }), _) => (l, AlwaysTrue), // min <= x
-                (Some(l @ ExtremeExpr { which: Maximum, .. }), _) => (l, InequalityImpossible), // max <= x
-                (_, Some(r @ ExtremeExpr { which: Minimum, .. })) => (r, InequalityImpossible), // x <= min
-                (_, Some(r @ ExtremeExpr { which: Maximum, .. })) => (r, AlwaysTrue), // x <= max
-                _ => return None,
-            }
-        },
-        Rel::Ne | Rel::Eq => return None,
-    })
-}
-
-fn detect_extreme_expr<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<ExtremeExpr<'tcx>> {
-    use crate::types::ExtremeType::{Maximum, Minimum};
-
-    let ty = cx.typeck_results().expr_ty(expr);
-
-    let cv = constant(cx, cx.typeck_results(), expr)?.0;
-
-    let which = match (ty.kind(), cv) {
-        (&ty::Bool, Constant::Bool(false)) | (&ty::Uint(_), Constant::Int(0)) => Minimum,
-        (&ty::Int(ity), Constant::Int(i)) if i == unsext(cx.tcx, i128::MIN >> (128 - int_bits(cx.tcx, ity)), ity) => {
-            Minimum
-        },
-
-        (&ty::Bool, Constant::Bool(true)) => Maximum,
-        (&ty::Int(ity), Constant::Int(i)) if i == unsext(cx.tcx, i128::MAX >> (128 - int_bits(cx.tcx, ity)), ity) => {
-            Maximum
-        },
-        (&ty::Uint(uty), Constant::Int(i)) if clip(cx.tcx, u128::MAX, uty) == i => Maximum,
-
-        _ => return None,
-    };
-    Some(ExtremeExpr { which, expr })
-}
-
-impl<'tcx> LateLintPass<'tcx> for AbsurdExtremeComparisons {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        use crate::types::AbsurdComparisonResult::{AlwaysFalse, AlwaysTrue, InequalityImpossible};
-        use crate::types::ExtremeType::{Maximum, Minimum};
-
-        if let ExprKind::Binary(ref cmp, ref lhs, ref rhs) = expr.kind {
-            if let Some((culprit, result)) = detect_absurd_comparison(cx, cmp.node, lhs, rhs) {
-                if !expr.span.from_expansion() {
-                    let msg = "this comparison involving the minimum or maximum element for this \
-                               type contains a case that is always true or always false";
-
-                    let conclusion = match result {
-                        AlwaysFalse => "this comparison is always false".to_owned(),
-                        AlwaysTrue => "this comparison is always true".to_owned(),
-                        InequalityImpossible => format!(
-                            "the case where the two sides are not equal never occurs, consider using `{} == {}` \
-                             instead",
-                            snippet(cx, lhs.span, "lhs"),
-                            snippet(cx, rhs.span, "rhs")
-                        ),
-                    };
-
-                    let help = format!(
-                        "because `{}` is the {} value for this type, {}",
-                        snippet(cx, culprit.expr.span, "x"),
-                        match culprit.which {
-                            Minimum => "minimum",
-                            Maximum => "maximum",
-                        },
-                        conclusion
-                    );
-
-                    span_lint_and_help(cx, ABSURD_EXTREME_COMPARISONS, expr.span, msg, None, &help);
-                }
-            }
-        }
-    }
-}
-
 declare_clippy_lint! {
     /// **What it does:** Checks for comparisons where the relation is always either
     /// true or false, but where one side has been upcast so that the comparison is
-- 
cgit 1.4.1-3-g733a5


From f231b59b9e3fc1ea074a269b006421295d5402d0 Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Thu, 18 Mar 2021 16:15:19 +0900
Subject: Move invalid_upcast_comparisons to its own module

---
 clippy_lints/src/invalid_upcast_comparisons.rs | 221 +++++++++++++++++++++++++
 clippy_lints/src/lib.rs                        |   7 +-
 clippy_lints/src/types/mod.rs                  | 215 +-----------------------
 3 files changed, 227 insertions(+), 216 deletions(-)
 create mode 100644 clippy_lints/src/invalid_upcast_comparisons.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/invalid_upcast_comparisons.rs b/clippy_lints/src/invalid_upcast_comparisons.rs
new file mode 100644
index 00000000000..d183fc41f31
--- /dev/null
+++ b/clippy_lints/src/invalid_upcast_comparisons.rs
@@ -0,0 +1,221 @@
+use std::cmp::Ordering;
+
+use rustc_hir::{Expr, ExprKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::{self, IntTy, UintTy};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::Span;
+use rustc_target::abi::LayoutOf;
+
+use crate::consts::{constant, Constant};
+
+use clippy_utils::comparisons::Rel;
+use clippy_utils::diagnostics::span_lint;
+use clippy_utils::source::snippet;
+use clippy_utils::{comparisons, sext};
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for comparisons where the relation is always either
+    /// true or false, but where one side has been upcast so that the comparison is
+    /// necessary. Only integer types are checked.
+    ///
+    /// **Why is this bad?** An expression like `let x : u8 = ...; (x as u32) > 300`
+    /// will mistakenly imply that it is possible for `x` to be outside the range of
+    /// `u8`.
+    ///
+    /// **Known problems:**
+    /// https://github.com/rust-lang/rust-clippy/issues/886
+    ///
+    /// **Example:**
+    /// ```rust
+    /// let x: u8 = 1;
+    /// (x as u32) > 300;
+    /// ```
+    pub INVALID_UPCAST_COMPARISONS,
+    pedantic,
+    "a comparison involving an upcast which is always true or false"
+}
+
+declare_lint_pass!(InvalidUpcastComparisons => [INVALID_UPCAST_COMPARISONS]);
+
+#[derive(Copy, Clone, Debug, Eq)]
+enum FullInt {
+    S(i128),
+    U(u128),
+}
+
+impl FullInt {
+    #[allow(clippy::cast_sign_loss)]
+    #[must_use]
+    fn cmp_s_u(s: i128, u: u128) -> Ordering {
+        if s < 0 {
+            Ordering::Less
+        } else if u > (i128::MAX as u128) {
+            Ordering::Greater
+        } else {
+            (s as u128).cmp(&u)
+        }
+    }
+}
+
+impl PartialEq for FullInt {
+    #[must_use]
+    fn eq(&self, other: &Self) -> bool {
+        self.partial_cmp(other).expect("`partial_cmp` only returns `Some(_)`") == Ordering::Equal
+    }
+}
+
+impl PartialOrd for FullInt {
+    #[must_use]
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(match (self, other) {
+            (&Self::S(s), &Self::S(o)) => s.cmp(&o),
+            (&Self::U(s), &Self::U(o)) => s.cmp(&o),
+            (&Self::S(s), &Self::U(o)) => Self::cmp_s_u(s, o),
+            (&Self::U(s), &Self::S(o)) => Self::cmp_s_u(o, s).reverse(),
+        })
+    }
+}
+
+impl Ord for FullInt {
+    #[must_use]
+    fn cmp(&self, other: &Self) -> Ordering {
+        self.partial_cmp(other)
+            .expect("`partial_cmp` for FullInt can never return `None`")
+    }
+}
+
+fn numeric_cast_precast_bounds<'a>(cx: &LateContext<'_>, expr: &'a Expr<'_>) -> Option<(FullInt, FullInt)> {
+    if let ExprKind::Cast(ref cast_exp, _) = expr.kind {
+        let pre_cast_ty = cx.typeck_results().expr_ty(cast_exp);
+        let cast_ty = cx.typeck_results().expr_ty(expr);
+        // if it's a cast from i32 to u32 wrapping will invalidate all these checks
+        if cx.layout_of(pre_cast_ty).ok().map(|l| l.size) == cx.layout_of(cast_ty).ok().map(|l| l.size) {
+            return None;
+        }
+        match pre_cast_ty.kind() {
+            ty::Int(int_ty) => Some(match int_ty {
+                IntTy::I8 => (FullInt::S(i128::from(i8::MIN)), FullInt::S(i128::from(i8::MAX))),
+                IntTy::I16 => (FullInt::S(i128::from(i16::MIN)), FullInt::S(i128::from(i16::MAX))),
+                IntTy::I32 => (FullInt::S(i128::from(i32::MIN)), FullInt::S(i128::from(i32::MAX))),
+                IntTy::I64 => (FullInt::S(i128::from(i64::MIN)), FullInt::S(i128::from(i64::MAX))),
+                IntTy::I128 => (FullInt::S(i128::MIN), FullInt::S(i128::MAX)),
+                IntTy::Isize => (FullInt::S(isize::MIN as i128), FullInt::S(isize::MAX as i128)),
+            }),
+            ty::Uint(uint_ty) => Some(match uint_ty {
+                UintTy::U8 => (FullInt::U(u128::from(u8::MIN)), FullInt::U(u128::from(u8::MAX))),
+                UintTy::U16 => (FullInt::U(u128::from(u16::MIN)), FullInt::U(u128::from(u16::MAX))),
+                UintTy::U32 => (FullInt::U(u128::from(u32::MIN)), FullInt::U(u128::from(u32::MAX))),
+                UintTy::U64 => (FullInt::U(u128::from(u64::MIN)), FullInt::U(u128::from(u64::MAX))),
+                UintTy::U128 => (FullInt::U(u128::MIN), FullInt::U(u128::MAX)),
+                UintTy::Usize => (FullInt::U(usize::MIN as u128), FullInt::U(usize::MAX as u128)),
+            }),
+            _ => None,
+        }
+    } else {
+        None
+    }
+}
+
+fn node_as_const_fullint<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<FullInt> {
+    let val = constant(cx, cx.typeck_results(), expr)?.0;
+    if let Constant::Int(const_int) = val {
+        match *cx.typeck_results().expr_ty(expr).kind() {
+            ty::Int(ity) => Some(FullInt::S(sext(cx.tcx, const_int, ity))),
+            ty::Uint(_) => Some(FullInt::U(const_int)),
+            _ => None,
+        }
+    } else {
+        None
+    }
+}
+
+fn err_upcast_comparison(cx: &LateContext<'_>, span: Span, expr: &Expr<'_>, always: bool) {
+    if let ExprKind::Cast(ref cast_val, _) = expr.kind {
+        span_lint(
+            cx,
+            INVALID_UPCAST_COMPARISONS,
+            span,
+            &format!(
+                "because of the numeric bounds on `{}` prior to casting, this expression is always {}",
+                snippet(cx, cast_val.span, "the expression"),
+                if always { "true" } else { "false" },
+            ),
+        );
+    }
+}
+
+fn upcast_comparison_bounds_err<'tcx>(
+    cx: &LateContext<'tcx>,
+    span: Span,
+    rel: comparisons::Rel,
+    lhs_bounds: Option<(FullInt, FullInt)>,
+    lhs: &'tcx Expr<'_>,
+    rhs: &'tcx Expr<'_>,
+    invert: bool,
+) {
+    if let Some((lb, ub)) = lhs_bounds {
+        if let Some(norm_rhs_val) = node_as_const_fullint(cx, rhs) {
+            if rel == Rel::Eq || rel == Rel::Ne {
+                if norm_rhs_val < lb || norm_rhs_val > ub {
+                    err_upcast_comparison(cx, span, lhs, rel == Rel::Ne);
+                }
+            } else if match rel {
+                Rel::Lt => {
+                    if invert {
+                        norm_rhs_val < lb
+                    } else {
+                        ub < norm_rhs_val
+                    }
+                },
+                Rel::Le => {
+                    if invert {
+                        norm_rhs_val <= lb
+                    } else {
+                        ub <= norm_rhs_val
+                    }
+                },
+                Rel::Eq | Rel::Ne => unreachable!(),
+            } {
+                err_upcast_comparison(cx, span, lhs, true)
+            } else if match rel {
+                Rel::Lt => {
+                    if invert {
+                        norm_rhs_val >= ub
+                    } else {
+                        lb >= norm_rhs_val
+                    }
+                },
+                Rel::Le => {
+                    if invert {
+                        norm_rhs_val > ub
+                    } else {
+                        lb > norm_rhs_val
+                    }
+                },
+                Rel::Eq | Rel::Ne => unreachable!(),
+            } {
+                err_upcast_comparison(cx, span, lhs, false)
+            }
+        }
+    }
+}
+
+impl<'tcx> LateLintPass<'tcx> for InvalidUpcastComparisons {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        if let ExprKind::Binary(ref cmp, ref lhs, ref rhs) = expr.kind {
+            let normalized = comparisons::normalize_comparison(cmp.node, lhs, rhs);
+            let (rel, normalized_lhs, normalized_rhs) = if let Some(val) = normalized {
+                val
+            } else {
+                return;
+            };
+
+            let lhs_bounds = numeric_cast_precast_bounds(cx, normalized_lhs);
+            let rhs_bounds = numeric_cast_precast_bounds(cx, normalized_rhs);
+
+            upcast_comparison_bounds_err(cx, expr.span, rel, lhs_bounds, normalized_lhs, normalized_rhs, false);
+            upcast_comparison_bounds_err(cx, expr.span, rel, rhs_bounds, normalized_rhs, normalized_lhs, true);
+        }
+    }
+}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 7b261121f51..c16be6da11a 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -242,6 +242,7 @@ mod inherent_to_string;
 mod inline_fn_without_body;
 mod int_plus_one;
 mod integer_division;
+mod invalid_upcast_comparisons;
 mod items_after_statements;
 mod large_const_arrays;
 mod large_enum_variant;
@@ -697,6 +698,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &inline_fn_without_body::INLINE_FN_WITHOUT_BODY,
         &int_plus_one::INT_PLUS_ONE,
         &integer_division::INTEGER_DIVISION,
+        &invalid_upcast_comparisons::INVALID_UPCAST_COMPARISONS,
         &items_after_statements::ITEMS_AFTER_STATEMENTS,
         &large_const_arrays::LARGE_CONST_ARRAYS,
         &large_enum_variant::LARGE_ENUM_VARIANT,
@@ -960,7 +962,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &types::BORROWED_BOX,
         &types::BOX_VEC,
         &types::IMPLICIT_HASHER,
-        &types::INVALID_UPCAST_COMPARISONS,
         &types::LINKEDLIST,
         &types::OPTION_OPTION,
         &types::RC_BUFFER,
@@ -1114,7 +1115,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box drop_forget_ref::DropForgetRef);
     store.register_late_pass(|| box empty_enum::EmptyEnum);
     store.register_late_pass(|| box absurd_extreme_comparisons::AbsurdExtremeComparisons);
-    store.register_late_pass(|| box types::InvalidUpcastComparisons);
+    store.register_late_pass(|| box invalid_upcast_comparisons::InvalidUpcastComparisons);
     store.register_late_pass(|| box regex::Regex::default());
     store.register_late_pass(|| box copies::CopyAndPaste);
     store.register_late_pass(|| box copy_iterator::CopyIterator);
@@ -1374,6 +1375,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&if_not_else::IF_NOT_ELSE),
         LintId::of(&implicit_saturating_sub::IMPLICIT_SATURATING_SUB),
         LintId::of(&infinite_iter::MAYBE_INFINITE_ITER),
+        LintId::of(&invalid_upcast_comparisons::INVALID_UPCAST_COMPARISONS),
         LintId::of(&items_after_statements::ITEMS_AFTER_STATEMENTS),
         LintId::of(&large_stack_arrays::LARGE_STACK_ARRAYS),
         LintId::of(&let_underscore::LET_UNDERSCORE_DROP),
@@ -1413,7 +1415,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&trait_bounds::TRAIT_DUPLICATION_IN_BOUNDS),
         LintId::of(&trait_bounds::TYPE_REPETITION_IN_BOUNDS),
         LintId::of(&types::IMPLICIT_HASHER),
-        LintId::of(&types::INVALID_UPCAST_COMPARISONS),
         LintId::of(&types::LINKEDLIST),
         LintId::of(&types::OPTION_OPTION),
         LintId::of(&unicode::NON_ASCII_LITERAL),
diff --git a/clippy_lints/src/types/mod.rs b/clippy_lints/src/types/mod.rs
index 0c50ed8348e..785f2c511d0 100644
--- a/clippy_lints/src/types/mod.rs
+++ b/clippy_lints/src/types/mod.rs
@@ -10,7 +10,6 @@ mod utils;
 mod vec_box;
 
 use std::borrow::Cow;
-use std::cmp::Ordering;
 use std::collections::BTreeMap;
 
 use clippy_utils::diagnostics::{multispan_sugg, span_lint, span_lint_and_then};
@@ -27,17 +26,15 @@ use rustc_hir::{
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::hir::map::Map;
 use rustc_middle::lint::in_external_macro;
-use rustc_middle::ty::{self, IntTy, Ty, TyS, TypeckResults, UintTy};
+use rustc_middle::ty::{Ty, TyS, TypeckResults};
 use rustc_session::{declare_lint_pass, declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::Span;
 use rustc_span::symbol::sym;
-use rustc_target::abi::LayoutOf;
 use rustc_target::spec::abi::Abi;
 use rustc_typeck::hir_ty_to_ty;
 
-use crate::consts::{constant, Constant};
 use clippy_utils::paths;
-use clippy_utils::{comparisons, differing_macro_contexts, match_path, sext};
+use clippy_utils::{differing_macro_contexts, match_path};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for use of `Box<Vec<_>>` anywhere in the code.
@@ -552,214 +549,6 @@ impl<'tcx> Visitor<'tcx> for TypeComplexityVisitor {
     }
 }
 
-declare_clippy_lint! {
-    /// **What it does:** Checks for comparisons where the relation is always either
-    /// true or false, but where one side has been upcast so that the comparison is
-    /// necessary. Only integer types are checked.
-    ///
-    /// **Why is this bad?** An expression like `let x : u8 = ...; (x as u32) > 300`
-    /// will mistakenly imply that it is possible for `x` to be outside the range of
-    /// `u8`.
-    ///
-    /// **Known problems:**
-    /// https://github.com/rust-lang/rust-clippy/issues/886
-    ///
-    /// **Example:**
-    /// ```rust
-    /// let x: u8 = 1;
-    /// (x as u32) > 300;
-    /// ```
-    pub INVALID_UPCAST_COMPARISONS,
-    pedantic,
-    "a comparison involving an upcast which is always true or false"
-}
-
-declare_lint_pass!(InvalidUpcastComparisons => [INVALID_UPCAST_COMPARISONS]);
-
-#[derive(Copy, Clone, Debug, Eq)]
-enum FullInt {
-    S(i128),
-    U(u128),
-}
-
-impl FullInt {
-    #[allow(clippy::cast_sign_loss)]
-    #[must_use]
-    fn cmp_s_u(s: i128, u: u128) -> Ordering {
-        if s < 0 {
-            Ordering::Less
-        } else if u > (i128::MAX as u128) {
-            Ordering::Greater
-        } else {
-            (s as u128).cmp(&u)
-        }
-    }
-}
-
-impl PartialEq for FullInt {
-    #[must_use]
-    fn eq(&self, other: &Self) -> bool {
-        self.partial_cmp(other).expect("`partial_cmp` only returns `Some(_)`") == Ordering::Equal
-    }
-}
-
-impl PartialOrd for FullInt {
-    #[must_use]
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        Some(match (self, other) {
-            (&Self::S(s), &Self::S(o)) => s.cmp(&o),
-            (&Self::U(s), &Self::U(o)) => s.cmp(&o),
-            (&Self::S(s), &Self::U(o)) => Self::cmp_s_u(s, o),
-            (&Self::U(s), &Self::S(o)) => Self::cmp_s_u(o, s).reverse(),
-        })
-    }
-}
-
-impl Ord for FullInt {
-    #[must_use]
-    fn cmp(&self, other: &Self) -> Ordering {
-        self.partial_cmp(other)
-            .expect("`partial_cmp` for FullInt can never return `None`")
-    }
-}
-
-fn numeric_cast_precast_bounds<'a>(cx: &LateContext<'_>, expr: &'a Expr<'_>) -> Option<(FullInt, FullInt)> {
-    if let ExprKind::Cast(ref cast_exp, _) = expr.kind {
-        let pre_cast_ty = cx.typeck_results().expr_ty(cast_exp);
-        let cast_ty = cx.typeck_results().expr_ty(expr);
-        // if it's a cast from i32 to u32 wrapping will invalidate all these checks
-        if cx.layout_of(pre_cast_ty).ok().map(|l| l.size) == cx.layout_of(cast_ty).ok().map(|l| l.size) {
-            return None;
-        }
-        match pre_cast_ty.kind() {
-            ty::Int(int_ty) => Some(match int_ty {
-                IntTy::I8 => (FullInt::S(i128::from(i8::MIN)), FullInt::S(i128::from(i8::MAX))),
-                IntTy::I16 => (FullInt::S(i128::from(i16::MIN)), FullInt::S(i128::from(i16::MAX))),
-                IntTy::I32 => (FullInt::S(i128::from(i32::MIN)), FullInt::S(i128::from(i32::MAX))),
-                IntTy::I64 => (FullInt::S(i128::from(i64::MIN)), FullInt::S(i128::from(i64::MAX))),
-                IntTy::I128 => (FullInt::S(i128::MIN), FullInt::S(i128::MAX)),
-                IntTy::Isize => (FullInt::S(isize::MIN as i128), FullInt::S(isize::MAX as i128)),
-            }),
-            ty::Uint(uint_ty) => Some(match uint_ty {
-                UintTy::U8 => (FullInt::U(u128::from(u8::MIN)), FullInt::U(u128::from(u8::MAX))),
-                UintTy::U16 => (FullInt::U(u128::from(u16::MIN)), FullInt::U(u128::from(u16::MAX))),
-                UintTy::U32 => (FullInt::U(u128::from(u32::MIN)), FullInt::U(u128::from(u32::MAX))),
-                UintTy::U64 => (FullInt::U(u128::from(u64::MIN)), FullInt::U(u128::from(u64::MAX))),
-                UintTy::U128 => (FullInt::U(u128::MIN), FullInt::U(u128::MAX)),
-                UintTy::Usize => (FullInt::U(usize::MIN as u128), FullInt::U(usize::MAX as u128)),
-            }),
-            _ => None,
-        }
-    } else {
-        None
-    }
-}
-
-fn node_as_const_fullint<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<FullInt> {
-    let val = constant(cx, cx.typeck_results(), expr)?.0;
-    if let Constant::Int(const_int) = val {
-        match *cx.typeck_results().expr_ty(expr).kind() {
-            ty::Int(ity) => Some(FullInt::S(sext(cx.tcx, const_int, ity))),
-            ty::Uint(_) => Some(FullInt::U(const_int)),
-            _ => None,
-        }
-    } else {
-        None
-    }
-}
-
-fn err_upcast_comparison(cx: &LateContext<'_>, span: Span, expr: &Expr<'_>, always: bool) {
-    if let ExprKind::Cast(ref cast_val, _) = expr.kind {
-        span_lint(
-            cx,
-            INVALID_UPCAST_COMPARISONS,
-            span,
-            &format!(
-                "because of the numeric bounds on `{}` prior to casting, this expression is always {}",
-                snippet(cx, cast_val.span, "the expression"),
-                if always { "true" } else { "false" },
-            ),
-        );
-    }
-}
-
-fn upcast_comparison_bounds_err<'tcx>(
-    cx: &LateContext<'tcx>,
-    span: Span,
-    rel: comparisons::Rel,
-    lhs_bounds: Option<(FullInt, FullInt)>,
-    lhs: &'tcx Expr<'_>,
-    rhs: &'tcx Expr<'_>,
-    invert: bool,
-) {
-    use clippy_utils::comparisons::Rel;
-
-    if let Some((lb, ub)) = lhs_bounds {
-        if let Some(norm_rhs_val) = node_as_const_fullint(cx, rhs) {
-            if rel == Rel::Eq || rel == Rel::Ne {
-                if norm_rhs_val < lb || norm_rhs_val > ub {
-                    err_upcast_comparison(cx, span, lhs, rel == Rel::Ne);
-                }
-            } else if match rel {
-                Rel::Lt => {
-                    if invert {
-                        norm_rhs_val < lb
-                    } else {
-                        ub < norm_rhs_val
-                    }
-                },
-                Rel::Le => {
-                    if invert {
-                        norm_rhs_val <= lb
-                    } else {
-                        ub <= norm_rhs_val
-                    }
-                },
-                Rel::Eq | Rel::Ne => unreachable!(),
-            } {
-                err_upcast_comparison(cx, span, lhs, true)
-            } else if match rel {
-                Rel::Lt => {
-                    if invert {
-                        norm_rhs_val >= ub
-                    } else {
-                        lb >= norm_rhs_val
-                    }
-                },
-                Rel::Le => {
-                    if invert {
-                        norm_rhs_val > ub
-                    } else {
-                        lb > norm_rhs_val
-                    }
-                },
-                Rel::Eq | Rel::Ne => unreachable!(),
-            } {
-                err_upcast_comparison(cx, span, lhs, false)
-            }
-        }
-    }
-}
-
-impl<'tcx> LateLintPass<'tcx> for InvalidUpcastComparisons {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if let ExprKind::Binary(ref cmp, ref lhs, ref rhs) = expr.kind {
-            let normalized = comparisons::normalize_comparison(cmp.node, lhs, rhs);
-            let (rel, normalized_lhs, normalized_rhs) = if let Some(val) = normalized {
-                val
-            } else {
-                return;
-            };
-
-            let lhs_bounds = numeric_cast_precast_bounds(cx, normalized_lhs);
-            let rhs_bounds = numeric_cast_precast_bounds(cx, normalized_rhs);
-
-            upcast_comparison_bounds_err(cx, expr.span, rel, lhs_bounds, normalized_lhs, normalized_rhs, false);
-            upcast_comparison_bounds_err(cx, expr.span, rel, rhs_bounds, normalized_rhs, normalized_lhs, true);
-        }
-    }
-}
-
 declare_clippy_lint! {
     /// **What it does:** Checks for public `impl` or `fn` missing generalization
     /// over different hashers and implicitly defaulting to the default hashing
-- 
cgit 1.4.1-3-g733a5


From dad39b6613645aefd6671f1378cafa1c8f2d5f65 Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Thu, 18 Mar 2021 16:34:22 +0900
Subject: Move implicit_hasher to its own module

---
 clippy_lints/src/implicit_hasher.rs | 377 +++++++++++++++++++++++++++++++++++
 clippy_lints/src/lib.rs             |   7 +-
 clippy_lints/src/types/mod.rs       | 380 +-----------------------------------
 3 files changed, 387 insertions(+), 377 deletions(-)
 create mode 100644 clippy_lints/src/implicit_hasher.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/implicit_hasher.rs b/clippy_lints/src/implicit_hasher.rs
new file mode 100644
index 00000000000..0b748b4d72d
--- /dev/null
+++ b/clippy_lints/src/implicit_hasher.rs
@@ -0,0 +1,377 @@
+#![allow(rustc::default_hash_types)]
+
+use std::borrow::Cow;
+use std::collections::BTreeMap;
+
+use rustc_errors::DiagnosticBuilder;
+use rustc_hir as hir;
+use rustc_hir::intravisit::{walk_body, walk_expr, walk_ty, NestedVisitorMap, Visitor};
+use rustc_hir::{Body, Expr, ExprKind, GenericArg, Item, ItemKind, QPath, TyKind};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_middle::hir::map::Map;
+use rustc_middle::lint::in_external_macro;
+use rustc_middle::ty::{Ty, TyS, TypeckResults};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::source_map::Span;
+use rustc_span::symbol::sym;
+use rustc_typeck::hir_ty_to_ty;
+
+use if_chain::if_chain;
+
+use clippy_utils::diagnostics::{multispan_sugg, span_lint_and_then};
+use clippy_utils::paths;
+use clippy_utils::source::{snippet, snippet_opt};
+use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::{differing_macro_contexts, match_path};
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for public `impl` or `fn` missing generalization
+    /// over different hashers and implicitly defaulting to the default hashing
+    /// algorithm (`SipHash`).
+    ///
+    /// **Why is this bad?** `HashMap` or `HashSet` with custom hashers cannot be
+    /// used with them.
+    ///
+    /// **Known problems:** Suggestions for replacing constructors can contain
+    /// false-positives. Also applying suggestions can require modification of other
+    /// pieces of code, possibly including external crates.
+    ///
+    /// **Example:**
+    /// ```rust
+    /// # use std::collections::HashMap;
+    /// # use std::hash::{Hash, BuildHasher};
+    /// # trait Serialize {};
+    /// impl<K: Hash + Eq, V> Serialize for HashMap<K, V> { }
+    ///
+    /// pub fn foo(map: &mut HashMap<i32, i32>) { }
+    /// ```
+    /// could be rewritten as
+    /// ```rust
+    /// # use std::collections::HashMap;
+    /// # use std::hash::{Hash, BuildHasher};
+    /// # trait Serialize {};
+    /// impl<K: Hash + Eq, V, S: BuildHasher> Serialize for HashMap<K, V, S> { }
+    ///
+    /// pub fn foo<S: BuildHasher>(map: &mut HashMap<i32, i32, S>) { }
+    /// ```
+    pub IMPLICIT_HASHER,
+    pedantic,
+    "missing generalization over different hashers"
+}
+
+declare_lint_pass!(ImplicitHasher => [IMPLICIT_HASHER]);
+
+impl<'tcx> LateLintPass<'tcx> for ImplicitHasher {
+    #[allow(clippy::cast_possible_truncation, clippy::too_many_lines)]
+    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
+        use rustc_span::BytePos;
+
+        fn suggestion<'tcx>(
+            cx: &LateContext<'tcx>,
+            diag: &mut DiagnosticBuilder<'_>,
+            generics_span: Span,
+            generics_suggestion_span: Span,
+            target: &ImplicitHasherType<'_>,
+            vis: ImplicitHasherConstructorVisitor<'_, '_, '_>,
+        ) {
+            let generics_snip = snippet(cx, generics_span, "");
+            // trim `<` `>`
+            let generics_snip = if generics_snip.is_empty() {
+                ""
+            } else {
+                &generics_snip[1..generics_snip.len() - 1]
+            };
+
+            multispan_sugg(
+                diag,
+                "consider adding a type parameter",
+                vec![
+                    (
+                        generics_suggestion_span,
+                        format!(
+                            "<{}{}S: ::std::hash::BuildHasher{}>",
+                            generics_snip,
+                            if generics_snip.is_empty() { "" } else { ", " },
+                            if vis.suggestions.is_empty() {
+                                ""
+                            } else {
+                                // request users to add `Default` bound so that generic constructors can be used
+                                " + Default"
+                            },
+                        ),
+                    ),
+                    (
+                        target.span(),
+                        format!("{}<{}, S>", target.type_name(), target.type_arguments(),),
+                    ),
+                ],
+            );
+
+            if !vis.suggestions.is_empty() {
+                multispan_sugg(diag, "...and use generic constructor", vis.suggestions);
+            }
+        }
+
+        if !cx.access_levels.is_exported(item.hir_id()) {
+            return;
+        }
+
+        match item.kind {
+            ItemKind::Impl(ref impl_) => {
+                let mut vis = ImplicitHasherTypeVisitor::new(cx);
+                vis.visit_ty(impl_.self_ty);
+
+                for target in &vis.found {
+                    if differing_macro_contexts(item.span, target.span()) {
+                        return;
+                    }
+
+                    let generics_suggestion_span = impl_.generics.span.substitute_dummy({
+                        let pos = snippet_opt(cx, item.span.until(target.span()))
+                            .and_then(|snip| Some(item.span.lo() + BytePos(snip.find("impl")? as u32 + 4)));
+                        if let Some(pos) = pos {
+                            Span::new(pos, pos, item.span.data().ctxt)
+                        } else {
+                            return;
+                        }
+                    });
+
+                    let mut ctr_vis = ImplicitHasherConstructorVisitor::new(cx, target);
+                    for item in impl_.items.iter().map(|item| cx.tcx.hir().impl_item(item.id)) {
+                        ctr_vis.visit_impl_item(item);
+                    }
+
+                    span_lint_and_then(
+                        cx,
+                        IMPLICIT_HASHER,
+                        target.span(),
+                        &format!(
+                            "impl for `{}` should be generalized over different hashers",
+                            target.type_name()
+                        ),
+                        move |diag| {
+                            suggestion(cx, diag, impl_.generics.span, generics_suggestion_span, target, ctr_vis);
+                        },
+                    );
+                }
+            },
+            ItemKind::Fn(ref sig, ref generics, body_id) => {
+                let body = cx.tcx.hir().body(body_id);
+
+                for ty in sig.decl.inputs {
+                    let mut vis = ImplicitHasherTypeVisitor::new(cx);
+                    vis.visit_ty(ty);
+
+                    for target in &vis.found {
+                        if in_external_macro(cx.sess(), generics.span) {
+                            continue;
+                        }
+                        let generics_suggestion_span = generics.span.substitute_dummy({
+                            let pos = snippet_opt(cx, item.span.until(body.params[0].pat.span))
+                                .and_then(|snip| {
+                                    let i = snip.find("fn")?;
+                                    Some(item.span.lo() + BytePos((i + (&snip[i..]).find('(')?) as u32))
+                                })
+                                .expect("failed to create span for type parameters");
+                            Span::new(pos, pos, item.span.data().ctxt)
+                        });
+
+                        let mut ctr_vis = ImplicitHasherConstructorVisitor::new(cx, target);
+                        ctr_vis.visit_body(body);
+
+                        span_lint_and_then(
+                            cx,
+                            IMPLICIT_HASHER,
+                            target.span(),
+                            &format!(
+                                "parameter of type `{}` should be generalized over different hashers",
+                                target.type_name()
+                            ),
+                            move |diag| {
+                                suggestion(cx, diag, generics.span, generics_suggestion_span, target, ctr_vis);
+                            },
+                        );
+                    }
+                }
+            },
+            _ => {},
+        }
+    }
+}
+
+enum ImplicitHasherType<'tcx> {
+    HashMap(Span, Ty<'tcx>, Cow<'static, str>, Cow<'static, str>),
+    HashSet(Span, Ty<'tcx>, Cow<'static, str>),
+}
+
+impl<'tcx> ImplicitHasherType<'tcx> {
+    /// Checks that `ty` is a target type without a `BuildHasher`.
+    fn new(cx: &LateContext<'tcx>, hir_ty: &hir::Ty<'_>) -> Option<Self> {
+        if let TyKind::Path(QPath::Resolved(None, ref path)) = hir_ty.kind {
+            let params: Vec<_> = path
+                .segments
+                .last()
+                .as_ref()?
+                .args
+                .as_ref()?
+                .args
+                .iter()
+                .filter_map(|arg| match arg {
+                    GenericArg::Type(ty) => Some(ty),
+                    _ => None,
+                })
+                .collect();
+            let params_len = params.len();
+
+            let ty = hir_ty_to_ty(cx.tcx, hir_ty);
+
+            if is_type_diagnostic_item(cx, ty, sym::hashmap_type) && params_len == 2 {
+                Some(ImplicitHasherType::HashMap(
+                    hir_ty.span,
+                    ty,
+                    snippet(cx, params[0].span, "K"),
+                    snippet(cx, params[1].span, "V"),
+                ))
+            } else if is_type_diagnostic_item(cx, ty, sym::hashset_type) && params_len == 1 {
+                Some(ImplicitHasherType::HashSet(
+                    hir_ty.span,
+                    ty,
+                    snippet(cx, params[0].span, "T"),
+                ))
+            } else {
+                None
+            }
+        } else {
+            None
+        }
+    }
+
+    fn type_name(&self) -> &'static str {
+        match *self {
+            ImplicitHasherType::HashMap(..) => "HashMap",
+            ImplicitHasherType::HashSet(..) => "HashSet",
+        }
+    }
+
+    fn type_arguments(&self) -> String {
+        match *self {
+            ImplicitHasherType::HashMap(.., ref k, ref v) => format!("{}, {}", k, v),
+            ImplicitHasherType::HashSet(.., ref t) => format!("{}", t),
+        }
+    }
+
+    fn ty(&self) -> Ty<'tcx> {
+        match *self {
+            ImplicitHasherType::HashMap(_, ty, ..) | ImplicitHasherType::HashSet(_, ty, ..) => ty,
+        }
+    }
+
+    fn span(&self) -> Span {
+        match *self {
+            ImplicitHasherType::HashMap(span, ..) | ImplicitHasherType::HashSet(span, ..) => span,
+        }
+    }
+}
+
+struct ImplicitHasherTypeVisitor<'a, 'tcx> {
+    cx: &'a LateContext<'tcx>,
+    found: Vec<ImplicitHasherType<'tcx>>,
+}
+
+impl<'a, 'tcx> ImplicitHasherTypeVisitor<'a, 'tcx> {
+    fn new(cx: &'a LateContext<'tcx>) -> Self {
+        Self { cx, found: vec![] }
+    }
+}
+
+impl<'a, 'tcx> Visitor<'tcx> for ImplicitHasherTypeVisitor<'a, 'tcx> {
+    type Map = Map<'tcx>;
+
+    fn visit_ty(&mut self, t: &'tcx hir::Ty<'_>) {
+        if let Some(target) = ImplicitHasherType::new(self.cx, t) {
+            self.found.push(target);
+        }
+
+        walk_ty(self, t);
+    }
+
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::None
+    }
+}
+
+/// Looks for default-hasher-dependent constructors like `HashMap::new`.
+struct ImplicitHasherConstructorVisitor<'a, 'b, 'tcx> {
+    cx: &'a LateContext<'tcx>,
+    maybe_typeck_results: Option<&'tcx TypeckResults<'tcx>>,
+    target: &'b ImplicitHasherType<'tcx>,
+    suggestions: BTreeMap<Span, String>,
+}
+
+impl<'a, 'b, 'tcx> ImplicitHasherConstructorVisitor<'a, 'b, 'tcx> {
+    fn new(cx: &'a LateContext<'tcx>, target: &'b ImplicitHasherType<'tcx>) -> Self {
+        Self {
+            cx,
+            maybe_typeck_results: cx.maybe_typeck_results(),
+            target,
+            suggestions: BTreeMap::new(),
+        }
+    }
+}
+
+impl<'a, 'b, 'tcx> Visitor<'tcx> for ImplicitHasherConstructorVisitor<'a, 'b, 'tcx> {
+    type Map = Map<'tcx>;
+
+    fn visit_body(&mut self, body: &'tcx Body<'_>) {
+        let old_maybe_typeck_results = self.maybe_typeck_results.replace(self.cx.tcx.typeck_body(body.id()));
+        walk_body(self, body);
+        self.maybe_typeck_results = old_maybe_typeck_results;
+    }
+
+    fn visit_expr(&mut self, e: &'tcx Expr<'_>) {
+        if_chain! {
+            if let ExprKind::Call(ref fun, ref args) = e.kind;
+            if let ExprKind::Path(QPath::TypeRelative(ref ty, ref method)) = fun.kind;
+            if let TyKind::Path(QPath::Resolved(None, ty_path)) = ty.kind;
+            then {
+                if !TyS::same_type(self.target.ty(), self.maybe_typeck_results.unwrap().expr_ty(e)) {
+                    return;
+                }
+
+                if match_path(ty_path, &paths::HASHMAP) {
+                    if method.ident.name == sym::new {
+                        self.suggestions
+                            .insert(e.span, "HashMap::default()".to_string());
+                    } else if method.ident.name == sym!(with_capacity) {
+                        self.suggestions.insert(
+                            e.span,
+                            format!(
+                                "HashMap::with_capacity_and_hasher({}, Default::default())",
+                                snippet(self.cx, args[0].span, "capacity"),
+                            ),
+                        );
+                    }
+                } else if match_path(ty_path, &paths::HASHSET) {
+                    if method.ident.name == sym::new {
+                        self.suggestions
+                            .insert(e.span, "HashSet::default()".to_string());
+                    } else if method.ident.name == sym!(with_capacity) {
+                        self.suggestions.insert(
+                            e.span,
+                            format!(
+                                "HashSet::with_capacity_and_hasher({}, Default::default())",
+                                snippet(self.cx, args[0].span, "capacity"),
+                            ),
+                        );
+                    }
+                }
+            }
+        }
+
+        walk_expr(self, e);
+    }
+
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::OnlyBodies(self.cx.tcx.hir())
+    }
+}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index c16be6da11a..05165ec9d66 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -232,6 +232,7 @@ mod if_let_mutex;
 mod if_let_some_result;
 mod if_not_else;
 mod if_then_some_else_none;
+mod implicit_hasher;
 mod implicit_return;
 mod implicit_saturating_sub;
 mod inconsistent_struct_constructor;
@@ -685,6 +686,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &if_let_some_result::IF_LET_SOME_RESULT,
         &if_not_else::IF_NOT_ELSE,
         &if_then_some_else_none::IF_THEN_SOME_ELSE_NONE,
+        &implicit_hasher::IMPLICIT_HASHER,
         &implicit_return::IMPLICIT_RETURN,
         &implicit_saturating_sub::IMPLICIT_SATURATING_SUB,
         &inconsistent_struct_constructor::INCONSISTENT_STRUCT_CONSTRUCTOR,
@@ -961,7 +963,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &try_err::TRY_ERR,
         &types::BORROWED_BOX,
         &types::BOX_VEC,
-        &types::IMPLICIT_HASHER,
         &types::LINKEDLIST,
         &types::OPTION_OPTION,
         &types::RC_BUFFER,
@@ -1159,7 +1160,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box infinite_iter::InfiniteIter);
     store.register_late_pass(|| box inline_fn_without_body::InlineFnWithoutBody);
     store.register_late_pass(|| box useless_conversion::UselessConversion::default());
-    store.register_late_pass(|| box types::ImplicitHasher);
+    store.register_late_pass(|| box implicit_hasher::ImplicitHasher);
     store.register_late_pass(|| box fallible_impl_from::FallibleImplFrom);
     store.register_late_pass(|| box double_comparison::DoubleComparisons);
     store.register_late_pass(|| box question_mark::QuestionMark);
@@ -1373,6 +1374,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&functions::MUST_USE_CANDIDATE),
         LintId::of(&functions::TOO_MANY_LINES),
         LintId::of(&if_not_else::IF_NOT_ELSE),
+        LintId::of(&implicit_hasher::IMPLICIT_HASHER),
         LintId::of(&implicit_saturating_sub::IMPLICIT_SATURATING_SUB),
         LintId::of(&infinite_iter::MAYBE_INFINITE_ITER),
         LintId::of(&invalid_upcast_comparisons::INVALID_UPCAST_COMPARISONS),
@@ -1414,7 +1416,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&strings::STRING_ADD_ASSIGN),
         LintId::of(&trait_bounds::TRAIT_DUPLICATION_IN_BOUNDS),
         LintId::of(&trait_bounds::TYPE_REPETITION_IN_BOUNDS),
-        LintId::of(&types::IMPLICIT_HASHER),
         LintId::of(&types::LINKEDLIST),
         LintId::of(&types::OPTION_OPTION),
         LintId::of(&unicode::NON_ASCII_LITERAL),
diff --git a/clippy_lints/src/types/mod.rs b/clippy_lints/src/types/mod.rs
index 785f2c511d0..d5f2b3d013e 100644
--- a/clippy_lints/src/types/mod.rs
+++ b/clippy_lints/src/types/mod.rs
@@ -1,5 +1,3 @@
-#![allow(rustc::default_hash_types)]
-
 mod borrowed_box;
 mod box_vec;
 mod linked_list;
@@ -9,32 +7,18 @@ mod redundant_allocation;
 mod utils;
 mod vec_box;
 
-use std::borrow::Cow;
-use std::collections::BTreeMap;
-
-use clippy_utils::diagnostics::{multispan_sugg, span_lint, span_lint_and_then};
-use clippy_utils::source::{snippet, snippet_opt};
-use clippy_utils::ty::is_type_diagnostic_item;
-use if_chain::if_chain;
-use rustc_errors::DiagnosticBuilder;
+use clippy_utils::diagnostics::span_lint;
 use rustc_hir as hir;
-use rustc_hir::intravisit::{walk_body, walk_expr, walk_ty, FnKind, NestedVisitorMap, Visitor};
+use rustc_hir::intravisit::{walk_ty, FnKind, NestedVisitorMap, Visitor};
 use rustc_hir::{
-    Body, Expr, ExprKind, FnDecl, FnRetTy, FnSig, GenericArg, GenericParamKind, HirId, ImplItem, ImplItemKind, Item,
-    ItemKind, Local, MutTy, QPath, TraitFn, TraitItem, TraitItemKind, TyKind,
+    Body, FnDecl, FnRetTy, FnSig, GenericArg, GenericParamKind, HirId, ImplItem, ImplItemKind, Item, ItemKind, Local,
+    MutTy, QPath, TraitFn, TraitItem, TraitItemKind, TyKind,
 };
-use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::map::Map;
-use rustc_middle::lint::in_external_macro;
-use rustc_middle::ty::{Ty, TyS, TypeckResults};
-use rustc_session::{declare_lint_pass, declare_tool_lint, impl_lint_pass};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::Span;
-use rustc_span::symbol::sym;
 use rustc_target::spec::abi::Abi;
-use rustc_typeck::hir_ty_to_ty;
-
-use clippy_utils::paths;
-use clippy_utils::{differing_macro_contexts, match_path};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for use of `Box<Vec<_>>` anywhere in the code.
@@ -548,355 +532,3 @@ impl<'tcx> Visitor<'tcx> for TypeComplexityVisitor {
         NestedVisitorMap::None
     }
 }
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for public `impl` or `fn` missing generalization
-    /// over different hashers and implicitly defaulting to the default hashing
-    /// algorithm (`SipHash`).
-    ///
-    /// **Why is this bad?** `HashMap` or `HashSet` with custom hashers cannot be
-    /// used with them.
-    ///
-    /// **Known problems:** Suggestions for replacing constructors can contain
-    /// false-positives. Also applying suggestions can require modification of other
-    /// pieces of code, possibly including external crates.
-    ///
-    /// **Example:**
-    /// ```rust
-    /// # use std::collections::HashMap;
-    /// # use std::hash::{Hash, BuildHasher};
-    /// # trait Serialize {};
-    /// impl<K: Hash + Eq, V> Serialize for HashMap<K, V> { }
-    ///
-    /// pub fn foo(map: &mut HashMap<i32, i32>) { }
-    /// ```
-    /// could be rewritten as
-    /// ```rust
-    /// # use std::collections::HashMap;
-    /// # use std::hash::{Hash, BuildHasher};
-    /// # trait Serialize {};
-    /// impl<K: Hash + Eq, V, S: BuildHasher> Serialize for HashMap<K, V, S> { }
-    ///
-    /// pub fn foo<S: BuildHasher>(map: &mut HashMap<i32, i32, S>) { }
-    /// ```
-    pub IMPLICIT_HASHER,
-    pedantic,
-    "missing generalization over different hashers"
-}
-
-declare_lint_pass!(ImplicitHasher => [IMPLICIT_HASHER]);
-
-impl<'tcx> LateLintPass<'tcx> for ImplicitHasher {
-    #[allow(clippy::cast_possible_truncation, clippy::too_many_lines)]
-    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
-        use rustc_span::BytePos;
-
-        fn suggestion<'tcx>(
-            cx: &LateContext<'tcx>,
-            diag: &mut DiagnosticBuilder<'_>,
-            generics_span: Span,
-            generics_suggestion_span: Span,
-            target: &ImplicitHasherType<'_>,
-            vis: ImplicitHasherConstructorVisitor<'_, '_, '_>,
-        ) {
-            let generics_snip = snippet(cx, generics_span, "");
-            // trim `<` `>`
-            let generics_snip = if generics_snip.is_empty() {
-                ""
-            } else {
-                &generics_snip[1..generics_snip.len() - 1]
-            };
-
-            multispan_sugg(
-                diag,
-                "consider adding a type parameter",
-                vec![
-                    (
-                        generics_suggestion_span,
-                        format!(
-                            "<{}{}S: ::std::hash::BuildHasher{}>",
-                            generics_snip,
-                            if generics_snip.is_empty() { "" } else { ", " },
-                            if vis.suggestions.is_empty() {
-                                ""
-                            } else {
-                                // request users to add `Default` bound so that generic constructors can be used
-                                " + Default"
-                            },
-                        ),
-                    ),
-                    (
-                        target.span(),
-                        format!("{}<{}, S>", target.type_name(), target.type_arguments(),),
-                    ),
-                ],
-            );
-
-            if !vis.suggestions.is_empty() {
-                multispan_sugg(diag, "...and use generic constructor", vis.suggestions);
-            }
-        }
-
-        if !cx.access_levels.is_exported(item.hir_id()) {
-            return;
-        }
-
-        match item.kind {
-            ItemKind::Impl(ref impl_) => {
-                let mut vis = ImplicitHasherTypeVisitor::new(cx);
-                vis.visit_ty(impl_.self_ty);
-
-                for target in &vis.found {
-                    if differing_macro_contexts(item.span, target.span()) {
-                        return;
-                    }
-
-                    let generics_suggestion_span = impl_.generics.span.substitute_dummy({
-                        let pos = snippet_opt(cx, item.span.until(target.span()))
-                            .and_then(|snip| Some(item.span.lo() + BytePos(snip.find("impl")? as u32 + 4)));
-                        if let Some(pos) = pos {
-                            Span::new(pos, pos, item.span.data().ctxt)
-                        } else {
-                            return;
-                        }
-                    });
-
-                    let mut ctr_vis = ImplicitHasherConstructorVisitor::new(cx, target);
-                    for item in impl_.items.iter().map(|item| cx.tcx.hir().impl_item(item.id)) {
-                        ctr_vis.visit_impl_item(item);
-                    }
-
-                    span_lint_and_then(
-                        cx,
-                        IMPLICIT_HASHER,
-                        target.span(),
-                        &format!(
-                            "impl for `{}` should be generalized over different hashers",
-                            target.type_name()
-                        ),
-                        move |diag| {
-                            suggestion(cx, diag, impl_.generics.span, generics_suggestion_span, target, ctr_vis);
-                        },
-                    );
-                }
-            },
-            ItemKind::Fn(ref sig, ref generics, body_id) => {
-                let body = cx.tcx.hir().body(body_id);
-
-                for ty in sig.decl.inputs {
-                    let mut vis = ImplicitHasherTypeVisitor::new(cx);
-                    vis.visit_ty(ty);
-
-                    for target in &vis.found {
-                        if in_external_macro(cx.sess(), generics.span) {
-                            continue;
-                        }
-                        let generics_suggestion_span = generics.span.substitute_dummy({
-                            let pos = snippet_opt(cx, item.span.until(body.params[0].pat.span))
-                                .and_then(|snip| {
-                                    let i = snip.find("fn")?;
-                                    Some(item.span.lo() + BytePos((i + (&snip[i..]).find('(')?) as u32))
-                                })
-                                .expect("failed to create span for type parameters");
-                            Span::new(pos, pos, item.span.data().ctxt)
-                        });
-
-                        let mut ctr_vis = ImplicitHasherConstructorVisitor::new(cx, target);
-                        ctr_vis.visit_body(body);
-
-                        span_lint_and_then(
-                            cx,
-                            IMPLICIT_HASHER,
-                            target.span(),
-                            &format!(
-                                "parameter of type `{}` should be generalized over different hashers",
-                                target.type_name()
-                            ),
-                            move |diag| {
-                                suggestion(cx, diag, generics.span, generics_suggestion_span, target, ctr_vis);
-                            },
-                        );
-                    }
-                }
-            },
-            _ => {},
-        }
-    }
-}
-
-enum ImplicitHasherType<'tcx> {
-    HashMap(Span, Ty<'tcx>, Cow<'static, str>, Cow<'static, str>),
-    HashSet(Span, Ty<'tcx>, Cow<'static, str>),
-}
-
-impl<'tcx> ImplicitHasherType<'tcx> {
-    /// Checks that `ty` is a target type without a `BuildHasher`.
-    fn new(cx: &LateContext<'tcx>, hir_ty: &hir::Ty<'_>) -> Option<Self> {
-        if let TyKind::Path(QPath::Resolved(None, ref path)) = hir_ty.kind {
-            let params: Vec<_> = path
-                .segments
-                .last()
-                .as_ref()?
-                .args
-                .as_ref()?
-                .args
-                .iter()
-                .filter_map(|arg| match arg {
-                    GenericArg::Type(ty) => Some(ty),
-                    _ => None,
-                })
-                .collect();
-            let params_len = params.len();
-
-            let ty = hir_ty_to_ty(cx.tcx, hir_ty);
-
-            if is_type_diagnostic_item(cx, ty, sym::hashmap_type) && params_len == 2 {
-                Some(ImplicitHasherType::HashMap(
-                    hir_ty.span,
-                    ty,
-                    snippet(cx, params[0].span, "K"),
-                    snippet(cx, params[1].span, "V"),
-                ))
-            } else if is_type_diagnostic_item(cx, ty, sym::hashset_type) && params_len == 1 {
-                Some(ImplicitHasherType::HashSet(
-                    hir_ty.span,
-                    ty,
-                    snippet(cx, params[0].span, "T"),
-                ))
-            } else {
-                None
-            }
-        } else {
-            None
-        }
-    }
-
-    fn type_name(&self) -> &'static str {
-        match *self {
-            ImplicitHasherType::HashMap(..) => "HashMap",
-            ImplicitHasherType::HashSet(..) => "HashSet",
-        }
-    }
-
-    fn type_arguments(&self) -> String {
-        match *self {
-            ImplicitHasherType::HashMap(.., ref k, ref v) => format!("{}, {}", k, v),
-            ImplicitHasherType::HashSet(.., ref t) => format!("{}", t),
-        }
-    }
-
-    fn ty(&self) -> Ty<'tcx> {
-        match *self {
-            ImplicitHasherType::HashMap(_, ty, ..) | ImplicitHasherType::HashSet(_, ty, ..) => ty,
-        }
-    }
-
-    fn span(&self) -> Span {
-        match *self {
-            ImplicitHasherType::HashMap(span, ..) | ImplicitHasherType::HashSet(span, ..) => span,
-        }
-    }
-}
-
-struct ImplicitHasherTypeVisitor<'a, 'tcx> {
-    cx: &'a LateContext<'tcx>,
-    found: Vec<ImplicitHasherType<'tcx>>,
-}
-
-impl<'a, 'tcx> ImplicitHasherTypeVisitor<'a, 'tcx> {
-    fn new(cx: &'a LateContext<'tcx>) -> Self {
-        Self { cx, found: vec![] }
-    }
-}
-
-impl<'a, 'tcx> Visitor<'tcx> for ImplicitHasherTypeVisitor<'a, 'tcx> {
-    type Map = Map<'tcx>;
-
-    fn visit_ty(&mut self, t: &'tcx hir::Ty<'_>) {
-        if let Some(target) = ImplicitHasherType::new(self.cx, t) {
-            self.found.push(target);
-        }
-
-        walk_ty(self, t);
-    }
-
-    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-        NestedVisitorMap::None
-    }
-}
-
-/// Looks for default-hasher-dependent constructors like `HashMap::new`.
-struct ImplicitHasherConstructorVisitor<'a, 'b, 'tcx> {
-    cx: &'a LateContext<'tcx>,
-    maybe_typeck_results: Option<&'tcx TypeckResults<'tcx>>,
-    target: &'b ImplicitHasherType<'tcx>,
-    suggestions: BTreeMap<Span, String>,
-}
-
-impl<'a, 'b, 'tcx> ImplicitHasherConstructorVisitor<'a, 'b, 'tcx> {
-    fn new(cx: &'a LateContext<'tcx>, target: &'b ImplicitHasherType<'tcx>) -> Self {
-        Self {
-            cx,
-            maybe_typeck_results: cx.maybe_typeck_results(),
-            target,
-            suggestions: BTreeMap::new(),
-        }
-    }
-}
-
-impl<'a, 'b, 'tcx> Visitor<'tcx> for ImplicitHasherConstructorVisitor<'a, 'b, 'tcx> {
-    type Map = Map<'tcx>;
-
-    fn visit_body(&mut self, body: &'tcx Body<'_>) {
-        let old_maybe_typeck_results = self.maybe_typeck_results.replace(self.cx.tcx.typeck_body(body.id()));
-        walk_body(self, body);
-        self.maybe_typeck_results = old_maybe_typeck_results;
-    }
-
-    fn visit_expr(&mut self, e: &'tcx Expr<'_>) {
-        if_chain! {
-            if let ExprKind::Call(ref fun, ref args) = e.kind;
-            if let ExprKind::Path(QPath::TypeRelative(ref ty, ref method)) = fun.kind;
-            if let TyKind::Path(QPath::Resolved(None, ty_path)) = ty.kind;
-            then {
-                if !TyS::same_type(self.target.ty(), self.maybe_typeck_results.unwrap().expr_ty(e)) {
-                    return;
-                }
-
-                if match_path(ty_path, &paths::HASHMAP) {
-                    if method.ident.name == sym::new {
-                        self.suggestions
-                            .insert(e.span, "HashMap::default()".to_string());
-                    } else if method.ident.name == sym!(with_capacity) {
-                        self.suggestions.insert(
-                            e.span,
-                            format!(
-                                "HashMap::with_capacity_and_hasher({}, Default::default())",
-                                snippet(self.cx, args[0].span, "capacity"),
-                            ),
-                        );
-                    }
-                } else if match_path(ty_path, &paths::HASHSET) {
-                    if method.ident.name == sym::new {
-                        self.suggestions
-                            .insert(e.span, "HashSet::default()".to_string());
-                    } else if method.ident.name == sym!(with_capacity) {
-                        self.suggestions.insert(
-                            e.span,
-                            format!(
-                                "HashSet::with_capacity_and_hasher({}, Default::default())",
-                                snippet(self.cx, args[0].span, "capacity"),
-                            ),
-                        );
-                    }
-                }
-            }
-        }
-
-        walk_expr(self, e);
-    }
-
-    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-        NestedVisitorMap::OnlyBodies(self.cx.tcx.hir())
-    }
-}
-- 
cgit 1.4.1-3-g733a5


From 494bc8a30cf154eede2f22178c9a7ebc404302e7 Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Fri, 19 Mar 2021 18:14:48 +0900
Subject: Fix FN that types lints don't work with const or static

---
 clippy_lints/src/types/mod.rs |  8 ++++++++
 tests/ui/dlist.rs             |  3 +++
 tests/ui/dlist.stderr         | 32 ++++++++++++++++++++++++--------
 tests/ui/option_option.rs     |  3 +++
 tests/ui/option_option.stderr | 38 +++++++++++++++++++++++++-------------
 tests/ui/vec_box_sized.fixed  |  2 ++
 tests/ui/vec_box_sized.rs     |  2 ++
 tests/ui/vec_box_sized.stderr | 26 +++++++++++++++++++-------
 8 files changed, 86 insertions(+), 28 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types/mod.rs b/clippy_lints/src/types/mod.rs
index d5f2b3d013e..1df964db38f 100644
--- a/clippy_lints/src/types/mod.rs
+++ b/clippy_lints/src/types/mod.rs
@@ -249,6 +249,14 @@ impl<'tcx> LateLintPass<'tcx> for Types {
         self.check_fn_decl(cx, decl);
     }
 
+    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
+        match item.kind {
+            ItemKind::Static(ref ty, _, _) | ItemKind::Const(ref ty, _) => self.check_ty(cx, ty, false),
+            // functions, enums, structs, impls and traits are covered
+            _ => (),
+        }
+    }
+
     fn check_field_def(&mut self, cx: &LateContext<'_>, field: &hir::FieldDef<'_>) {
         self.check_ty(cx, &field.ty, false);
     }
diff --git a/tests/ui/dlist.rs b/tests/ui/dlist.rs
index 2940d2d2901..2c3b25cd45e 100644
--- a/tests/ui/dlist.rs
+++ b/tests/ui/dlist.rs
@@ -5,6 +5,9 @@
 extern crate alloc;
 use alloc::collections::linked_list::LinkedList;
 
+const C: LinkedList<i32> = LinkedList::new();
+static S: LinkedList<i32> = LinkedList::new();
+
 trait Foo {
     type Baz = LinkedList<u8>;
     fn foo(_: LinkedList<u8>);
diff --git a/tests/ui/dlist.stderr b/tests/ui/dlist.stderr
index 234db33ba12..425407dc334 100644
--- a/tests/ui/dlist.stderr
+++ b/tests/ui/dlist.stderr
@@ -1,14 +1,30 @@
 error: you seem to be using a `LinkedList`! Perhaps you meant some other data structure?
-  --> $DIR/dlist.rs:9:16
+  --> $DIR/dlist.rs:8:10
+   |
+LL | const C: LinkedList<i32> = LinkedList::new();
+   |          ^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::linkedlist` implied by `-D warnings`
+   = help: a `VecDeque` might work
+
+error: you seem to be using a `LinkedList`! Perhaps you meant some other data structure?
+  --> $DIR/dlist.rs:9:11
+   |
+LL | static S: LinkedList<i32> = LinkedList::new();
+   |           ^^^^^^^^^^^^^^^
+   |
+   = help: a `VecDeque` might work
+
+error: you seem to be using a `LinkedList`! Perhaps you meant some other data structure?
+  --> $DIR/dlist.rs:12:16
    |
 LL |     type Baz = LinkedList<u8>;
    |                ^^^^^^^^^^^^^^
    |
-   = note: `-D clippy::linkedlist` implied by `-D warnings`
    = help: a `VecDeque` might work
 
 error: you seem to be using a `LinkedList`! Perhaps you meant some other data structure?
-  --> $DIR/dlist.rs:10:15
+  --> $DIR/dlist.rs:13:15
    |
 LL |     fn foo(_: LinkedList<u8>);
    |               ^^^^^^^^^^^^^^
@@ -16,7 +32,7 @@ LL |     fn foo(_: LinkedList<u8>);
    = help: a `VecDeque` might work
 
 error: you seem to be using a `LinkedList`! Perhaps you meant some other data structure?
-  --> $DIR/dlist.rs:11:23
+  --> $DIR/dlist.rs:14:23
    |
 LL |     const BAR: Option<LinkedList<u8>>;
    |                       ^^^^^^^^^^^^^^
@@ -24,7 +40,7 @@ LL |     const BAR: Option<LinkedList<u8>>;
    = help: a `VecDeque` might work
 
 error: you seem to be using a `LinkedList`! Perhaps you meant some other data structure?
-  --> $DIR/dlist.rs:22:15
+  --> $DIR/dlist.rs:25:15
    |
 LL |     fn foo(_: LinkedList<u8>) {}
    |               ^^^^^^^^^^^^^^
@@ -32,7 +48,7 @@ LL |     fn foo(_: LinkedList<u8>) {}
    = help: a `VecDeque` might work
 
 error: you seem to be using a `LinkedList`! Perhaps you meant some other data structure?
-  --> $DIR/dlist.rs:25:39
+  --> $DIR/dlist.rs:28:39
    |
 LL | pub fn test(my_favourite_linked_list: LinkedList<u8>) {
    |                                       ^^^^^^^^^^^^^^
@@ -40,12 +56,12 @@ LL | pub fn test(my_favourite_linked_list: LinkedList<u8>) {
    = help: a `VecDeque` might work
 
 error: you seem to be using a `LinkedList`! Perhaps you meant some other data structure?
-  --> $DIR/dlist.rs:29:29
+  --> $DIR/dlist.rs:32:29
    |
 LL | pub fn test_ret() -> Option<LinkedList<u8>> {
    |                             ^^^^^^^^^^^^^^
    |
    = help: a `VecDeque` might work
 
-error: aborting due to 6 previous errors
+error: aborting due to 8 previous errors
 
diff --git a/tests/ui/option_option.rs b/tests/ui/option_option.rs
index 6859ba8e5bb..2faab9e035d 100644
--- a/tests/ui/option_option.rs
+++ b/tests/ui/option_option.rs
@@ -1,6 +1,9 @@
 #![deny(clippy::option_option)]
 #![allow(clippy::unnecessary_wraps)]
 
+const C: Option<Option<i32>> = None;
+static S: Option<Option<i32>> = None;
+
 fn input(_: Option<Option<u8>>) {}
 
 fn output() -> Option<Option<u8>> {
diff --git a/tests/ui/option_option.stderr b/tests/ui/option_option.stderr
index ad7f081c713..a925bb35b04 100644
--- a/tests/ui/option_option.stderr
+++ b/tests/ui/option_option.stderr
@@ -1,8 +1,8 @@
 error: consider using `Option<T>` instead of `Option<Option<T>>` or a custom enum if you need to distinguish all 3 cases
-  --> $DIR/option_option.rs:4:13
+  --> $DIR/option_option.rs:4:10
    |
-LL | fn input(_: Option<Option<u8>>) {}
-   |             ^^^^^^^^^^^^^^^^^^
+LL | const C: Option<Option<i32>> = None;
+   |          ^^^^^^^^^^^^^^^^^^^
    |
 note: the lint level is defined here
   --> $DIR/option_option.rs:1:9
@@ -11,58 +11,70 @@ LL | #![deny(clippy::option_option)]
    |         ^^^^^^^^^^^^^^^^^^^^^
 
 error: consider using `Option<T>` instead of `Option<Option<T>>` or a custom enum if you need to distinguish all 3 cases
-  --> $DIR/option_option.rs:6:16
+  --> $DIR/option_option.rs:5:11
+   |
+LL | static S: Option<Option<i32>> = None;
+   |           ^^^^^^^^^^^^^^^^^^^
+
+error: consider using `Option<T>` instead of `Option<Option<T>>` or a custom enum if you need to distinguish all 3 cases
+  --> $DIR/option_option.rs:7:13
+   |
+LL | fn input(_: Option<Option<u8>>) {}
+   |             ^^^^^^^^^^^^^^^^^^
+
+error: consider using `Option<T>` instead of `Option<Option<T>>` or a custom enum if you need to distinguish all 3 cases
+  --> $DIR/option_option.rs:9:16
    |
 LL | fn output() -> Option<Option<u8>> {
    |                ^^^^^^^^^^^^^^^^^^
 
 error: consider using `Option<T>` instead of `Option<Option<T>>` or a custom enum if you need to distinguish all 3 cases
-  --> $DIR/option_option.rs:10:27
+  --> $DIR/option_option.rs:13:27
    |
 LL | fn output_nested() -> Vec<Option<Option<u8>>> {
    |                           ^^^^^^^^^^^^^^^^^^
 
 error: consider using `Option<T>` instead of `Option<Option<T>>` or a custom enum if you need to distinguish all 3 cases
-  --> $DIR/option_option.rs:15:30
+  --> $DIR/option_option.rs:18:30
    |
 LL | fn output_nested_nested() -> Option<Option<Option<u8>>> {
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: consider using `Option<T>` instead of `Option<Option<T>>` or a custom enum if you need to distinguish all 3 cases
-  --> $DIR/option_option.rs:20:8
+  --> $DIR/option_option.rs:23:8
    |
 LL |     x: Option<Option<u8>>,
    |        ^^^^^^^^^^^^^^^^^^
 
 error: consider using `Option<T>` instead of `Option<Option<T>>` or a custom enum if you need to distinguish all 3 cases
-  --> $DIR/option_option.rs:24:23
+  --> $DIR/option_option.rs:27:23
    |
 LL |     fn struct_fn() -> Option<Option<u8>> {
    |                       ^^^^^^^^^^^^^^^^^^
 
 error: consider using `Option<T>` instead of `Option<Option<T>>` or a custom enum if you need to distinguish all 3 cases
-  --> $DIR/option_option.rs:30:22
+  --> $DIR/option_option.rs:33:22
    |
 LL |     fn trait_fn() -> Option<Option<u8>>;
    |                      ^^^^^^^^^^^^^^^^^^
 
 error: consider using `Option<T>` instead of `Option<Option<T>>` or a custom enum if you need to distinguish all 3 cases
-  --> $DIR/option_option.rs:34:11
+  --> $DIR/option_option.rs:37:11
    |
 LL |     Tuple(Option<Option<u8>>),
    |           ^^^^^^^^^^^^^^^^^^
 
 error: consider using `Option<T>` instead of `Option<Option<T>>` or a custom enum if you need to distinguish all 3 cases
-  --> $DIR/option_option.rs:35:17
+  --> $DIR/option_option.rs:38:17
    |
 LL |     Struct { x: Option<Option<u8>> },
    |                 ^^^^^^^^^^^^^^^^^^
 
 error: consider using `Option<T>` instead of `Option<Option<T>>` or a custom enum if you need to distinguish all 3 cases
-  --> $DIR/option_option.rs:76:14
+  --> $DIR/option_option.rs:79:14
    |
 LL |         foo: Option<Option<Cow<'a, str>>>,
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 10 previous errors
+error: aborting due to 12 previous errors
 
diff --git a/tests/ui/vec_box_sized.fixed b/tests/ui/vec_box_sized.fixed
index 4fa28b525c3..a40d91fdb18 100644
--- a/tests/ui/vec_box_sized.fixed
+++ b/tests/ui/vec_box_sized.fixed
@@ -9,6 +9,8 @@ struct BigStruct([i32; 10000]);
 /// The following should trigger the lint
 mod should_trigger {
     use super::SizedStruct;
+    const C: Vec<i32> = Vec::new();
+    static S: Vec<i32> = Vec::new();
 
     struct StructWithVecBox {
         sized_type: Vec<SizedStruct>,
diff --git a/tests/ui/vec_box_sized.rs b/tests/ui/vec_box_sized.rs
index 7dc735cd90b..843bbb64e71 100644
--- a/tests/ui/vec_box_sized.rs
+++ b/tests/ui/vec_box_sized.rs
@@ -9,6 +9,8 @@ struct BigStruct([i32; 10000]);
 /// The following should trigger the lint
 mod should_trigger {
     use super::SizedStruct;
+    const C: Vec<Box<i32>> = Vec::new();
+    static S: Vec<Box<i32>> = Vec::new();
 
     struct StructWithVecBox {
         sized_type: Vec<Box<SizedStruct>>,
diff --git a/tests/ui/vec_box_sized.stderr b/tests/ui/vec_box_sized.stderr
index 83435a40aa1..c518267f041 100644
--- a/tests/ui/vec_box_sized.stderr
+++ b/tests/ui/vec_box_sized.stderr
@@ -1,28 +1,40 @@
 error: `Vec<T>` is already on the heap, the boxing is unnecessary
-  --> $DIR/vec_box_sized.rs:14:21
+  --> $DIR/vec_box_sized.rs:12:14
    |
-LL |         sized_type: Vec<Box<SizedStruct>>,
-   |                     ^^^^^^^^^^^^^^^^^^^^^ help: try: `Vec<SizedStruct>`
+LL |     const C: Vec<Box<i32>> = Vec::new();
+   |              ^^^^^^^^^^^^^ help: try: `Vec<i32>`
    |
    = note: `-D clippy::vec-box` implied by `-D warnings`
 
 error: `Vec<T>` is already on the heap, the boxing is unnecessary
-  --> $DIR/vec_box_sized.rs:17:14
+  --> $DIR/vec_box_sized.rs:13:15
+   |
+LL |     static S: Vec<Box<i32>> = Vec::new();
+   |               ^^^^^^^^^^^^^ help: try: `Vec<i32>`
+
+error: `Vec<T>` is already on the heap, the boxing is unnecessary
+  --> $DIR/vec_box_sized.rs:16:21
+   |
+LL |         sized_type: Vec<Box<SizedStruct>>,
+   |                     ^^^^^^^^^^^^^^^^^^^^^ help: try: `Vec<SizedStruct>`
+
+error: `Vec<T>` is already on the heap, the boxing is unnecessary
+  --> $DIR/vec_box_sized.rs:19:14
    |
 LL |     struct A(Vec<Box<SizedStruct>>);
    |              ^^^^^^^^^^^^^^^^^^^^^ help: try: `Vec<SizedStruct>`
 
 error: `Vec<T>` is already on the heap, the boxing is unnecessary
-  --> $DIR/vec_box_sized.rs:18:18
+  --> $DIR/vec_box_sized.rs:20:18
    |
 LL |     struct B(Vec<Vec<Box<(u32)>>>);
    |                  ^^^^^^^^^^^^^^^ help: try: `Vec<u32>`
 
 error: `Vec<T>` is already on the heap, the boxing is unnecessary
-  --> $DIR/vec_box_sized.rs:46:23
+  --> $DIR/vec_box_sized.rs:48:23
    |
 LL |         pub fn f() -> Vec<Box<S>> {
    |                       ^^^^^^^^^^^ help: try: `Vec<S>`
 
-error: aborting due to 4 previous errors
+error: aborting due to 6 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 818f8320a34c60ec72c2cce0eb24a4a26c0d2b7a Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Sat, 20 Mar 2021 15:32:19 +0900
Subject: Merge type_complexity pass into types pass

---
 clippy_lints/src/lib.rs                   |   5 +-
 clippy_lints/src/types/mod.rs             | 308 +++++++++++-------------------
 clippy_lints/src/types/type_complexity.rs |  79 ++++++++
 3 files changed, 192 insertions(+), 200 deletions(-)
 create mode 100644 clippy_lints/src/types/type_complexity.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 05165ec9d66..402fecd478c 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1031,7 +1031,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box await_holding_invalid::AwaitHolding);
     store.register_late_pass(|| box serde_api::SerdeApi);
     let vec_box_size_threshold = conf.vec_box_size_threshold;
-    store.register_late_pass(move || box types::Types::new(vec_box_size_threshold));
+    let type_complexity_threshold = conf.type_complexity_threshold;
+    store.register_late_pass(move || box types::Types::new(vec_box_size_threshold, type_complexity_threshold));
     store.register_late_pass(|| box booleans::NonminimalBool);
     store.register_late_pass(|| box eq_op::EqOp);
     store.register_late_pass(|| box enum_clike::UnportableVariant);
@@ -1092,8 +1093,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box main_recursion::MainRecursion::default());
     store.register_late_pass(|| box lifetimes::Lifetimes);
     store.register_late_pass(|| box entry::HashMapPass);
-    let type_complexity_threshold = conf.type_complexity_threshold;
-    store.register_late_pass(move || box types::TypeComplexity::new(type_complexity_threshold));
     store.register_late_pass(|| box minmax::MinMaxPass);
     store.register_late_pass(|| box open_options::OpenOptions);
     store.register_late_pass(|| box zero_div_zero::ZeroDiv);
diff --git a/clippy_lints/src/types/mod.rs b/clippy_lints/src/types/mod.rs
index 1df964db38f..12e1eba2ca6 100644
--- a/clippy_lints/src/types/mod.rs
+++ b/clippy_lints/src/types/mod.rs
@@ -4,21 +4,19 @@ mod linked_list;
 mod option_option;
 mod rc_buffer;
 mod redundant_allocation;
+mod type_complexity;
 mod utils;
 mod vec_box;
 
-use clippy_utils::diagnostics::span_lint;
 use rustc_hir as hir;
-use rustc_hir::intravisit::{walk_ty, FnKind, NestedVisitorMap, Visitor};
+use rustc_hir::intravisit::FnKind;
 use rustc_hir::{
-    Body, FnDecl, FnRetTy, FnSig, GenericArg, GenericParamKind, HirId, ImplItem, ImplItemKind, Item, ItemKind, Local,
-    MutTy, QPath, TraitFn, TraitItem, TraitItemKind, TyKind,
+    Body, FnDecl, FnRetTy, GenericArg, HirId, ImplItem, ImplItemKind, Item, ItemKind, Local, MutTy, QPath, TraitItem,
+    TraitItemKind, TyKind,
 };
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::hir::map::Map;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::Span;
-use rustc_target::spec::abi::Abi;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for use of `Box<Vec<_>>` anywhere in the code.
@@ -231,63 +229,121 @@ declare_clippy_lint! {
     "shared ownership of a buffer type"
 }
 
+declare_clippy_lint! {
+    /// **What it does:** Checks for types used in structs, parameters and `let`
+    /// declarations above a certain complexity threshold.
+    ///
+    /// **Why is this bad?** Too complex types make the code less readable. Consider
+    /// using a `type` definition to simplify them.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// ```rust
+    /// # use std::rc::Rc;
+    /// struct Foo {
+    ///     inner: Rc<Vec<Vec<Box<(u32, u32, u32, u32)>>>>,
+    /// }
+    /// ```
+    pub TYPE_COMPLEXITY,
+    complexity,
+    "usage of very complex types that might be better factored into `type` definitions"
+}
+
 pub struct Types {
     vec_box_size_threshold: u64,
+    type_complexity_threshold: u64,
 }
 
-impl_lint_pass!(Types => [BOX_VEC, VEC_BOX, OPTION_OPTION, LINKEDLIST, BORROWED_BOX, REDUNDANT_ALLOCATION, RC_BUFFER]);
+impl_lint_pass!(Types => [BOX_VEC, VEC_BOX, OPTION_OPTION, LINKEDLIST, BORROWED_BOX, REDUNDANT_ALLOCATION, RC_BUFFER, TYPE_COMPLEXITY]);
 
 impl<'tcx> LateLintPass<'tcx> for Types {
     fn check_fn(&mut self, cx: &LateContext<'_>, _: FnKind<'_>, decl: &FnDecl<'_>, _: &Body<'_>, _: Span, id: HirId) {
-        // Skip trait implementations; see issue #605.
-        if let Some(hir::Node::Item(item)) = cx.tcx.hir().find(cx.tcx.hir().get_parent_item(id)) {
-            if let ItemKind::Impl(hir::Impl { of_trait: Some(_), .. }) = item.kind {
-                return;
-            }
-        }
+        let is_in_trait_impl = if let Some(hir::Node::Item(item)) = cx.tcx.hir().find(cx.tcx.hir().get_parent_item(id))
+        {
+            matches!(item.kind, ItemKind::Impl(hir::Impl { of_trait: Some(_), .. }))
+        } else {
+            false
+        };
 
-        self.check_fn_decl(cx, decl);
+        self.check_fn_decl(
+            cx,
+            decl,
+            CheckTyContext {
+                is_in_trait_impl,
+                ..CheckTyContext::default()
+            },
+        );
     }
 
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
         match item.kind {
-            ItemKind::Static(ref ty, _, _) | ItemKind::Const(ref ty, _) => self.check_ty(cx, ty, false),
+            ItemKind::Static(ref ty, _, _) | ItemKind::Const(ref ty, _) => {
+                self.check_ty(cx, ty, CheckTyContext::default())
+            },
             // functions, enums, structs, impls and traits are covered
             _ => (),
         }
     }
 
+    fn check_impl_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx ImplItem<'_>) {
+        match item.kind {
+            ImplItemKind::Const(ref ty, _) | ImplItemKind::TyAlias(ref ty) => self.check_ty(
+                cx,
+                ty,
+                CheckTyContext {
+                    is_in_trait_impl: true,
+                    ..CheckTyContext::default()
+                },
+            ),
+            // methods are covered by check_fn
+            ImplItemKind::Fn(..) => (),
+        }
+    }
+
     fn check_field_def(&mut self, cx: &LateContext<'_>, field: &hir::FieldDef<'_>) {
-        self.check_ty(cx, &field.ty, false);
+        self.check_ty(cx, &field.ty, CheckTyContext::default());
     }
 
     fn check_trait_item(&mut self, cx: &LateContext<'_>, item: &TraitItem<'_>) {
         match item.kind {
-            TraitItemKind::Const(ref ty, _) | TraitItemKind::Type(_, Some(ref ty)) => self.check_ty(cx, ty, false),
-            TraitItemKind::Fn(ref sig, _) => self.check_fn_decl(cx, &sig.decl),
+            TraitItemKind::Const(ref ty, _) | TraitItemKind::Type(_, Some(ref ty)) => {
+                self.check_ty(cx, ty, CheckTyContext::default())
+            },
+            TraitItemKind::Fn(ref sig, _) => self.check_fn_decl(cx, &sig.decl, CheckTyContext::default()),
             TraitItemKind::Type(..) => (),
         }
     }
 
     fn check_local(&mut self, cx: &LateContext<'_>, local: &Local<'_>) {
         if let Some(ref ty) = local.ty {
-            self.check_ty(cx, ty, true);
+            self.check_ty(
+                cx,
+                ty,
+                CheckTyContext {
+                    is_local: true,
+                    ..CheckTyContext::default()
+                },
+            );
         }
     }
 }
 
 impl Types {
-    pub fn new(vec_box_size_threshold: u64) -> Self {
-        Self { vec_box_size_threshold }
+    pub fn new(vec_box_size_threshold: u64, type_complexity_threshold: u64) -> Self {
+        Self {
+            vec_box_size_threshold,
+            type_complexity_threshold,
+        }
     }
 
-    fn check_fn_decl(&mut self, cx: &LateContext<'_>, decl: &FnDecl<'_>) {
+    fn check_fn_decl(&mut self, cx: &LateContext<'_>, decl: &FnDecl<'_>, context: CheckTyContext) {
         for input in decl.inputs {
-            self.check_ty(cx, input, false);
+            self.check_ty(cx, input, context);
         }
 
         if let FnRetTy::Return(ref ty) = decl.output {
-            self.check_ty(cx, ty, false);
+            self.check_ty(cx, ty, context);
         }
     }
 
@@ -295,12 +351,22 @@ impl Types {
     /// lint found.
     ///
     /// The parameter `is_local` distinguishes the context of the type.
-    fn check_ty(&mut self, cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, is_local: bool) {
+    fn check_ty(&mut self, cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, mut context: CheckTyContext) {
         if hir_ty.span.from_expansion() {
             return;
         }
+
+        if !context.is_nested_call && type_complexity::check(cx, hir_ty, self.type_complexity_threshold) {
+            return;
+        }
+
+        // Skip trait implementations; see issue #605.
+        if context.is_in_trait_impl {
+            return;
+        }
+
         match hir_ty.kind {
-            TyKind::Path(ref qpath) if !is_local => {
+            TyKind::Path(ref qpath) if !context.is_local => {
                 let hir_id = hir_ty.hir_id;
                 let res = cx.qpath_res(qpath, hir_id);
                 if let Some(def_id) = res.opt_def_id() {
@@ -318,7 +384,8 @@ impl Types {
                 }
                 match *qpath {
                     QPath::Resolved(Some(ref ty), ref p) => {
-                        self.check_ty(cx, ty, is_local);
+                        context.is_nested_call = true;
+                        self.check_ty(cx, ty, context);
                         for ty in p.segments.iter().flat_map(|seg| {
                             seg.args
                                 .as_ref()
@@ -328,10 +395,11 @@ impl Types {
                                     _ => None,
                                 })
                         }) {
-                            self.check_ty(cx, ty, is_local);
+                            self.check_ty(cx, ty, context);
                         }
                     },
                     QPath::Resolved(None, ref p) => {
+                        context.is_nested_call = true;
                         for ty in p.segments.iter().flat_map(|seg| {
                             seg.args
                                 .as_ref()
@@ -341,17 +409,18 @@ impl Types {
                                     _ => None,
                                 })
                         }) {
-                            self.check_ty(cx, ty, is_local);
+                            self.check_ty(cx, ty, context);
                         }
                     },
                     QPath::TypeRelative(ref ty, ref seg) => {
-                        self.check_ty(cx, ty, is_local);
+                        context.is_nested_call = true;
+                        self.check_ty(cx, ty, context);
                         if let Some(ref params) = seg.args {
                             for ty in params.args.iter().filter_map(|arg| match arg {
                                 GenericArg::Type(ty) => Some(ty),
                                 _ => None,
                             }) {
-                                self.check_ty(cx, ty, is_local);
+                                self.check_ty(cx, ty, context);
                             }
                         }
                     },
@@ -359,16 +428,19 @@ impl Types {
                 }
             },
             TyKind::Rptr(ref lt, ref mut_ty) => {
+                context.is_nested_call = true;
                 if !borrowed_box::check(cx, hir_ty, lt, mut_ty) {
-                    self.check_ty(cx, &mut_ty.ty, is_local);
+                    self.check_ty(cx, &mut_ty.ty, context);
                 }
             },
             TyKind::Slice(ref ty) | TyKind::Array(ref ty, _) | TyKind::Ptr(MutTy { ref ty, .. }) => {
-                self.check_ty(cx, ty, is_local)
+                context.is_nested_call = true;
+                self.check_ty(cx, ty, context)
             },
             TyKind::Tup(tys) => {
+                context.is_nested_call = true;
                 for ty in tys {
-                    self.check_ty(cx, ty, is_local);
+                    self.check_ty(cx, ty, context);
                 }
             },
             _ => {},
@@ -376,167 +448,9 @@ impl Types {
     }
 }
 
-declare_clippy_lint! {
-    /// **What it does:** Checks for types used in structs, parameters and `let`
-    /// declarations above a certain complexity threshold.
-    ///
-    /// **Why is this bad?** Too complex types make the code less readable. Consider
-    /// using a `type` definition to simplify them.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    /// ```rust
-    /// # use std::rc::Rc;
-    /// struct Foo {
-    ///     inner: Rc<Vec<Vec<Box<(u32, u32, u32, u32)>>>>,
-    /// }
-    /// ```
-    pub TYPE_COMPLEXITY,
-    complexity,
-    "usage of very complex types that might be better factored into `type` definitions"
-}
-
-pub struct TypeComplexity {
-    threshold: u64,
-}
-
-impl TypeComplexity {
-    #[must_use]
-    pub fn new(threshold: u64) -> Self {
-        Self { threshold }
-    }
-}
-
-impl_lint_pass!(TypeComplexity => [TYPE_COMPLEXITY]);
-
-impl<'tcx> LateLintPass<'tcx> for TypeComplexity {
-    fn check_fn(
-        &mut self,
-        cx: &LateContext<'tcx>,
-        _: FnKind<'tcx>,
-        decl: &'tcx FnDecl<'_>,
-        _: &'tcx Body<'_>,
-        _: Span,
-        _: HirId,
-    ) {
-        self.check_fndecl(cx, decl);
-    }
-
-    fn check_field_def(&mut self, cx: &LateContext<'tcx>, field: &'tcx hir::FieldDef<'_>) {
-        // enum variants are also struct fields now
-        self.check_type(cx, &field.ty);
-    }
-
-    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
-        match item.kind {
-            ItemKind::Static(ref ty, _, _) | ItemKind::Const(ref ty, _) => self.check_type(cx, ty),
-            // functions, enums, structs, impls and traits are covered
-            _ => (),
-        }
-    }
-
-    fn check_trait_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx TraitItem<'_>) {
-        match item.kind {
-            TraitItemKind::Const(ref ty, _) | TraitItemKind::Type(_, Some(ref ty)) => self.check_type(cx, ty),
-            TraitItemKind::Fn(FnSig { ref decl, .. }, TraitFn::Required(_)) => self.check_fndecl(cx, decl),
-            // methods with default impl are covered by check_fn
-            TraitItemKind::Type(..) | TraitItemKind::Fn(_, TraitFn::Provided(_)) => (),
-        }
-    }
-
-    fn check_impl_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx ImplItem<'_>) {
-        match item.kind {
-            ImplItemKind::Const(ref ty, _) | ImplItemKind::TyAlias(ref ty) => self.check_type(cx, ty),
-            // methods are covered by check_fn
-            ImplItemKind::Fn(..) => (),
-        }
-    }
-
-    fn check_local(&mut self, cx: &LateContext<'tcx>, local: &'tcx Local<'_>) {
-        if let Some(ref ty) = local.ty {
-            self.check_type(cx, ty);
-        }
-    }
-}
-
-impl<'tcx> TypeComplexity {
-    fn check_fndecl(&self, cx: &LateContext<'tcx>, decl: &'tcx FnDecl<'_>) {
-        for arg in decl.inputs {
-            self.check_type(cx, arg);
-        }
-        if let FnRetTy::Return(ref ty) = decl.output {
-            self.check_type(cx, ty);
-        }
-    }
-
-    fn check_type(&self, cx: &LateContext<'_>, ty: &hir::Ty<'_>) {
-        if ty.span.from_expansion() {
-            return;
-        }
-        let score = {
-            let mut visitor = TypeComplexityVisitor { score: 0, nest: 1 };
-            visitor.visit_ty(ty);
-            visitor.score
-        };
-
-        if score > self.threshold {
-            span_lint(
-                cx,
-                TYPE_COMPLEXITY,
-                ty.span,
-                "very complex type used. Consider factoring parts into `type` definitions",
-            );
-        }
-    }
-}
-
-/// Walks a type and assigns a complexity score to it.
-struct TypeComplexityVisitor {
-    /// total complexity score of the type
-    score: u64,
-    /// current nesting level
-    nest: u64,
-}
-
-impl<'tcx> Visitor<'tcx> for TypeComplexityVisitor {
-    type Map = Map<'tcx>;
-
-    fn visit_ty(&mut self, ty: &'tcx hir::Ty<'_>) {
-        let (add_score, sub_nest) = match ty.kind {
-            // _, &x and *x have only small overhead; don't mess with nesting level
-            TyKind::Infer | TyKind::Ptr(..) | TyKind::Rptr(..) => (1, 0),
-
-            // the "normal" components of a type: named types, arrays/tuples
-            TyKind::Path(..) | TyKind::Slice(..) | TyKind::Tup(..) | TyKind::Array(..) => (10 * self.nest, 1),
-
-            // function types bring a lot of overhead
-            TyKind::BareFn(ref bare) if bare.abi == Abi::Rust => (50 * self.nest, 1),
-
-            TyKind::TraitObject(ref param_bounds, _, _) => {
-                let has_lifetime_parameters = param_bounds.iter().any(|bound| {
-                    bound
-                        .bound_generic_params
-                        .iter()
-                        .any(|gen| matches!(gen.kind, GenericParamKind::Lifetime { .. }))
-                });
-                if has_lifetime_parameters {
-                    // complex trait bounds like A<'a, 'b>
-                    (50 * self.nest, 1)
-                } else {
-                    // simple trait bounds like A + B
-                    (20 * self.nest, 0)
-                }
-            },
-
-            _ => (0, 0),
-        };
-        self.score += add_score;
-        self.nest += sub_nest;
-        walk_ty(self, ty);
-        self.nest -= sub_nest;
-    }
-    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-        NestedVisitorMap::None
-    }
+#[derive(Clone, Copy, Default)]
+struct CheckTyContext {
+    is_in_trait_impl: bool,
+    is_local: bool,
+    is_nested_call: bool,
 }
diff --git a/clippy_lints/src/types/type_complexity.rs b/clippy_lints/src/types/type_complexity.rs
new file mode 100644
index 00000000000..9a4e9da3e2b
--- /dev/null
+++ b/clippy_lints/src/types/type_complexity.rs
@@ -0,0 +1,79 @@
+use clippy_utils::diagnostics::span_lint;
+use rustc_hir as hir;
+use rustc_hir::intravisit::{walk_ty, NestedVisitorMap, Visitor};
+use rustc_hir::{GenericParamKind, TyKind};
+use rustc_lint::LateContext;
+use rustc_middle::hir::map::Map;
+use rustc_target::spec::abi::Abi;
+
+use super::TYPE_COMPLEXITY;
+
+pub(super) fn check(cx: &LateContext<'_>, ty: &hir::Ty<'_>, type_complexity_threshold: u64) -> bool {
+    let score = {
+        let mut visitor = TypeComplexityVisitor { score: 0, nest: 1 };
+        visitor.visit_ty(ty);
+        visitor.score
+    };
+
+    if score > type_complexity_threshold {
+        span_lint(
+            cx,
+            TYPE_COMPLEXITY,
+            ty.span,
+            "very complex type used. Consider factoring parts into `type` definitions",
+        );
+        true
+    } else {
+        false
+    }
+}
+
+/// Walks a type and assigns a complexity score to it.
+struct TypeComplexityVisitor {
+    /// total complexity score of the type
+    score: u64,
+    /// current nesting level
+    nest: u64,
+}
+
+impl<'tcx> Visitor<'tcx> for TypeComplexityVisitor {
+    type Map = Map<'tcx>;
+
+    fn visit_ty(&mut self, ty: &'tcx hir::Ty<'_>) {
+        let (add_score, sub_nest) = match ty.kind {
+            // _, &x and *x have only small overhead; don't mess with nesting level
+            TyKind::Infer | TyKind::Ptr(..) | TyKind::Rptr(..) => (1, 0),
+
+            // the "normal" components of a type: named types, arrays/tuples
+            TyKind::Path(..) | TyKind::Slice(..) | TyKind::Tup(..) | TyKind::Array(..) => (10 * self.nest, 1),
+
+            // function types bring a lot of overhead
+            TyKind::BareFn(ref bare) if bare.abi == Abi::Rust => (50 * self.nest, 1),
+
+            TyKind::TraitObject(ref param_bounds, _, _) => {
+                let has_lifetime_parameters = param_bounds.iter().any(|bound| {
+                    bound
+                        .bound_generic_params
+                        .iter()
+                        .any(|gen| matches!(gen.kind, GenericParamKind::Lifetime { .. }))
+                });
+                if has_lifetime_parameters {
+                    // complex trait bounds like A<'a, 'b>
+                    (50 * self.nest, 1)
+                } else {
+                    // simple trait bounds like A + B
+                    (20 * self.nest, 0)
+                }
+            },
+
+            _ => (0, 0),
+        };
+        self.score += add_score;
+        self.nest += sub_nest;
+        walk_ty(self, ty);
+        self.nest -= sub_nest;
+    }
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::None
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 1a1adad81d0fd7d0c64d0a72575a6b4db69c035a Mon Sep 17 00:00:00 2001
From: flip1995 <philipp.krones@embecosm.com>
Date: Fri, 26 Mar 2021 10:56:05 +0100
Subject: Add MSRV option to unnested_or_patterns lint

---
 clippy_lints/src/lib.rs                  |  2 +-
 clippy_lints/src/unnested_or_patterns.rs | 44 ++++++++++++++++++++++++++------
 clippy_lints/src/utils/conf.rs           |  2 +-
 tests/ui/min_rust_version_attr.rs        |  6 +++++
 tests/ui/min_rust_version_attr.stderr    |  8 +++---
 5 files changed, 48 insertions(+), 14 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 3a9236d8735..f013613119c 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1079,6 +1079,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(move || box missing_const_for_fn::MissingConstForFn::new(msrv));
     store.register_late_pass(move || box needless_question_mark::NeedlessQuestionMark::new(msrv));
     store.register_late_pass(move || box casts::Casts::new(msrv));
+    store.register_early_pass(move || box unnested_or_patterns::UnnestedOrPatterns::new(msrv));
 
     store.register_late_pass(|| box size_of_in_element_count::SizeOfInElementCount);
     store.register_late_pass(|| box map_clone::MapClone);
@@ -1254,7 +1255,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_early_pass(move || box non_expressive_names::NonExpressiveNames {
         single_char_binding_names_threshold,
     });
-    store.register_early_pass(|| box unnested_or_patterns::UnnestedOrPatterns);
     store.register_late_pass(|| box macro_use::MacroUseImports::default());
     store.register_late_pass(|| box map_identity::MapIdentity);
     store.register_late_pass(|| box pattern_type_mismatch::PatternTypeMismatch);
diff --git a/clippy_lints/src/unnested_or_patterns.rs b/clippy_lints/src/unnested_or_patterns.rs
index 2b9479365c6..9376a2cf66a 100644
--- a/clippy_lints/src/unnested_or_patterns.rs
+++ b/clippy_lints/src/unnested_or_patterns.rs
@@ -1,15 +1,19 @@
 #![allow(clippy::wildcard_imports, clippy::enum_glob_use)]
 
-use clippy_utils::ast_utils::{eq_field_pat, eq_id, eq_pat, eq_path};
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::over;
+use clippy_utils::{
+    ast_utils::{eq_field_pat, eq_id, eq_pat, eq_path},
+    meets_msrv,
+};
 use rustc_ast::mut_visit::*;
 use rustc_ast::ptr::P;
 use rustc_ast::{self as ast, Pat, PatKind, PatKind::*, DUMMY_NODE_ID};
 use rustc_ast_pretty::pprust;
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_semver::RustcVersion;
+use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::DUMMY_SP;
 
 use std::cell::Cell;
@@ -50,26 +54,50 @@ declare_clippy_lint! {
     "unnested or-patterns, e.g., `Foo(Bar) | Foo(Baz) instead of `Foo(Bar | Baz)`"
 }
 
-declare_lint_pass!(UnnestedOrPatterns => [UNNESTED_OR_PATTERNS]);
+const UNNESTED_OR_PATTERNS_MSRV: RustcVersion = RustcVersion::new(1, 53, 0);
+
+#[derive(Clone, Copy)]
+pub struct UnnestedOrPatterns {
+    msrv: Option<RustcVersion>,
+}
+
+impl UnnestedOrPatterns {
+    #[must_use]
+    pub fn new(msrv: Option<RustcVersion>) -> Self {
+        Self { msrv }
+    }
+}
+
+impl_lint_pass!(UnnestedOrPatterns => [UNNESTED_OR_PATTERNS]);
 
 impl EarlyLintPass for UnnestedOrPatterns {
     fn check_arm(&mut self, cx: &EarlyContext<'_>, a: &ast::Arm) {
-        lint_unnested_or_patterns(cx, &a.pat);
+        if meets_msrv(self.msrv.as_ref(), &UNNESTED_OR_PATTERNS_MSRV) {
+            lint_unnested_or_patterns(cx, &a.pat);
+        }
     }
 
     fn check_expr(&mut self, cx: &EarlyContext<'_>, e: &ast::Expr) {
-        if let ast::ExprKind::Let(pat, _) = &e.kind {
-            lint_unnested_or_patterns(cx, pat);
+        if meets_msrv(self.msrv.as_ref(), &UNNESTED_OR_PATTERNS_MSRV) {
+            if let ast::ExprKind::Let(pat, _) = &e.kind {
+                lint_unnested_or_patterns(cx, pat);
+            }
         }
     }
 
     fn check_param(&mut self, cx: &EarlyContext<'_>, p: &ast::Param) {
-        lint_unnested_or_patterns(cx, &p.pat);
+        if meets_msrv(self.msrv.as_ref(), &UNNESTED_OR_PATTERNS_MSRV) {
+            lint_unnested_or_patterns(cx, &p.pat);
+        }
     }
 
     fn check_local(&mut self, cx: &EarlyContext<'_>, l: &ast::Local) {
-        lint_unnested_or_patterns(cx, &l.pat);
+        if meets_msrv(self.msrv.as_ref(), &UNNESTED_OR_PATTERNS_MSRV) {
+            lint_unnested_or_patterns(cx, &l.pat);
+        }
     }
+
+    extract_msrv_attr!(EarlyContext);
 }
 
 fn lint_unnested_or_patterns(cx: &EarlyContext<'_>, pat: &Pat) {
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 9139a0966c5..b372f5b0e72 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -106,7 +106,7 @@ macro_rules! define_Conf {
 
 pub use self::helpers::Conf;
 define_Conf! {
-    /// Lint: REDUNDANT_FIELD_NAMES, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN. The minimum rust version that the project supports
+    /// Lint: REDUNDANT_FIELD_NAMES, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS. The minimum rust version that the project supports
     (msrv, "msrv": Option<String>, None),
     /// Lint: BLACKLISTED_NAME. The list of blacklisted names to lint about. NB: `bar` is not here since it has legitimate uses
     (blacklisted_names, "blacklisted_names": Vec<String>, ["foo", "baz", "quux"].iter().map(ToString::to_string).collect()),
diff --git a/tests/ui/min_rust_version_attr.rs b/tests/ui/min_rust_version_attr.rs
index 0f47f1cbc40..49ace1ca128 100644
--- a/tests/ui/min_rust_version_attr.rs
+++ b/tests/ui/min_rust_version_attr.rs
@@ -123,6 +123,11 @@ fn missing_const_for_fn() -> i32 {
     1
 }
 
+fn unnest_or_patterns() {
+    struct TS(u8, u8);
+    if let TS(0, x) | TS(1, x) = TS(0, 0) {}
+}
+
 fn main() {
     filter_map_next();
     checked_conversion();
@@ -138,6 +143,7 @@ fn main() {
     replace_with_default();
     map_unwrap_or();
     missing_const_for_fn();
+    unnest_or_patterns();
 }
 
 mod meets_msrv {
diff --git a/tests/ui/min_rust_version_attr.stderr b/tests/ui/min_rust_version_attr.stderr
index e3e3b335cbe..8d3575c2da8 100644
--- a/tests/ui/min_rust_version_attr.stderr
+++ b/tests/ui/min_rust_version_attr.stderr
@@ -1,12 +1,12 @@
 error: stripping a prefix manually
-  --> $DIR/min_rust_version_attr.rs:150:24
+  --> $DIR/min_rust_version_attr.rs:156:24
    |
 LL |             assert_eq!(s["hello, ".len()..].to_uppercase(), "WORLD!");
    |                        ^^^^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::manual-strip` implied by `-D warnings`
 note: the prefix was tested here
-  --> $DIR/min_rust_version_attr.rs:149:9
+  --> $DIR/min_rust_version_attr.rs:155:9
    |
 LL |         if s.starts_with("hello, ") {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -17,13 +17,13 @@ LL |             assert_eq!(<stripped>.to_uppercase(), "WORLD!");
    |
 
 error: stripping a prefix manually
-  --> $DIR/min_rust_version_attr.rs:162:24
+  --> $DIR/min_rust_version_attr.rs:168:24
    |
 LL |             assert_eq!(s["hello, ".len()..].to_uppercase(), "WORLD!");
    |                        ^^^^^^^^^^^^^^^^^^^^
    |
 note: the prefix was tested here
-  --> $DIR/min_rust_version_attr.rs:161:9
+  --> $DIR/min_rust_version_attr.rs:167:9
    |
 LL |         if s.starts_with("hello, ") {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From 5351bbfbf52acea4af2a6b72685fcf2ff935b476 Mon Sep 17 00:00:00 2001
From: flip1995 <philipp.krones@embecosm.com>
Date: Fri, 26 Mar 2021 15:39:23 +0100
Subject: Add missing lints to MSRV config doc

---
 clippy_lints/src/utils/conf.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index b372f5b0e72..147f823491d 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -106,7 +106,7 @@ macro_rules! define_Conf {
 
 pub use self::helpers::Conf;
 define_Conf! {
-    /// Lint: REDUNDANT_FIELD_NAMES, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS. The minimum rust version that the project supports
+    /// Lint: REDUNDANT_FIELD_NAMES, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, NEEDLESS_QUESTION_MARK, PTR_AS_PTR. The minimum rust version that the project supports
     (msrv, "msrv": Option<String>, None),
     /// Lint: BLACKLISTED_NAME. The list of blacklisted names to lint about. NB: `bar` is not here since it has legitimate uses
     (blacklisted_names, "blacklisted_names": Vec<String>, ["foo", "baz", "quux"].iter().map(ToString::to_string).collect()),
-- 
cgit 1.4.1-3-g733a5


From 4e19d406a916fc053a6e217f15efe35b20a7ddb5 Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Sat, 27 Mar 2021 00:44:30 +0100
Subject: upper_case_acronyms: only lint enum variants if the enum is not
 public

---
 clippy_lints/src/upper_case_acronyms.rs | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/upper_case_acronyms.rs b/clippy_lints/src/upper_case_acronyms.rs
index a6d29d36862..f8023d07437 100644
--- a/clippy_lints/src/upper_case_acronyms.rs
+++ b/clippy_lints/src/upper_case_acronyms.rs
@@ -99,21 +99,21 @@ fn check_ident(cx: &EarlyContext<'_>, ident: &Ident, be_aggressive: bool) {
 
 impl EarlyLintPass for UpperCaseAcronyms {
     fn check_item(&mut self, cx: &EarlyContext<'_>, it: &Item) {
-        if_chain! {
-            if !in_external_macro(cx.sess(), it.span);
+        // do not lint public items or in macros
+        if !in_external_macro(cx.sess(), it.span) && !matches!(it.vis.kind, VisibilityKind::Public) {
             if matches!(
                 it.kind,
-                ItemKind::TyAlias(..) | ItemKind::Enum(..) | ItemKind::Struct(..) | ItemKind::Trait(..)
-            );
-            // do not lint public items
-            if !matches!(it.vis.kind, VisibilityKind::Public);
-            then {
+                ItemKind::TyAlias(..) | ItemKind::Struct(..) | ItemKind::Trait(..)
+            ) {
                 check_ident(cx, &it.ident, self.upper_case_acronyms_aggressive);
+            } else if let ItemKind::Enum(ref enumdef, _) = it.kind {
+                // check enum variants seperately because again we only want to lint on private enums and
+                // the fn check_variant does not know about the vis of the enum of its variants
+                &enumdef
+                    .variants
+                    .iter()
+                    .for_each(|variant| check_ident(cx, &variant.ident, self.upper_case_acronyms_aggressive));
             }
         }
     }
-
-    fn check_variant(&mut self, cx: &EarlyContext<'_>, v: &Variant) {
-        check_ident(cx, &v.ident, self.upper_case_acronyms_aggressive);
-    }
 }
-- 
cgit 1.4.1-3-g733a5


From ca7e95501c13f386956728bb66ec099a0d89e8e5 Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Sat, 27 Mar 2021 00:52:49 +0100
Subject: upper_case_acronyms: add ui and ui-toml tests for private/public
 enums

---
 clippy_lints/src/upper_case_acronyms.rs                  |  5 ++---
 .../upper_case_acronyms.rs                               | 16 ++++++++++++++++
 .../upper_case_acronyms.stderr                           | 14 +++++++++++++-
 tests/ui/upper_case_acronyms.rs                          | 14 ++++++++++++++
 tests/ui/upper_case_acronyms.stderr                      |  8 +++++++-
 5 files changed, 52 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/upper_case_acronyms.rs b/clippy_lints/src/upper_case_acronyms.rs
index f8023d07437..4ac2ec55b98 100644
--- a/clippy_lints/src/upper_case_acronyms.rs
+++ b/clippy_lints/src/upper_case_acronyms.rs
@@ -1,7 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use if_chain::if_chain;
 use itertools::Itertools;
-use rustc_ast::ast::{Item, ItemKind, Variant, VisibilityKind};
+use rustc_ast::ast::{Item, ItemKind, VisibilityKind};
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
@@ -109,7 +108,7 @@ impl EarlyLintPass for UpperCaseAcronyms {
             } else if let ItemKind::Enum(ref enumdef, _) = it.kind {
                 // check enum variants seperately because again we only want to lint on private enums and
                 // the fn check_variant does not know about the vis of the enum of its variants
-                &enumdef
+                enumdef
                     .variants
                     .iter()
                     .for_each(|variant| check_ident(cx, &variant.ident, self.upper_case_acronyms_aggressive));
diff --git a/tests/ui-toml/upper_case_acronyms_aggressive/upper_case_acronyms.rs b/tests/ui-toml/upper_case_acronyms_aggressive/upper_case_acronyms.rs
index c6659edacc3..1a5cf1b1947 100644
--- a/tests/ui-toml/upper_case_acronyms_aggressive/upper_case_acronyms.rs
+++ b/tests/ui-toml/upper_case_acronyms_aggressive/upper_case_acronyms.rs
@@ -25,4 +25,20 @@ pub struct MIXEDCapital;
 
 pub struct FULLCAPITAL;
 
+// enum variants should not be linted if the num is pub
+pub enum ParseError<T> {
+    FULLCAPITAL(u8),
+    MIXEDCapital(String),
+    Utf8(std::string::FromUtf8Error),
+    Parse(T, String),
+}
+
+// private, do lint here
+enum ParseErrorPrivate<T> {
+    WASD(u8),
+    WASDMixed(String),
+    Utf8(std::string::FromUtf8Error),
+    Parse(T, String),
+}
+
 fn main() {}
diff --git a/tests/ui-toml/upper_case_acronyms_aggressive/upper_case_acronyms.stderr b/tests/ui-toml/upper_case_acronyms_aggressive/upper_case_acronyms.stderr
index 38e30683d57..02f29bbefe1 100644
--- a/tests/ui-toml/upper_case_acronyms_aggressive/upper_case_acronyms.stderr
+++ b/tests/ui-toml/upper_case_acronyms_aggressive/upper_case_acronyms.stderr
@@ -66,5 +66,17 @@ error: name `GCCLLVMSomething` contains a capitalized acronym
 LL | struct GCCLLVMSomething;
    |        ^^^^^^^^^^^^^^^^ help: consider making the acronym lowercase, except the initial letter: `GccllvmSomething`
 
-error: aborting due to 11 previous errors
+error: name `WASD` contains a capitalized acronym
+  --> $DIR/upper_case_acronyms.rs:38:5
+   |
+LL |     WASD(u8),
+   |     ^^^^ help: consider making the acronym lowercase, except the initial letter: `Wasd`
+
+error: name `WASDMixed` contains a capitalized acronym
+  --> $DIR/upper_case_acronyms.rs:39:5
+   |
+LL |     WASDMixed(String),
+   |     ^^^^^^^^^ help: consider making the acronym lowercase, except the initial letter: `WasdMixed`
+
+error: aborting due to 13 previous errors
 
diff --git a/tests/ui/upper_case_acronyms.rs b/tests/ui/upper_case_acronyms.rs
index 8c09c6f5b23..48bb9e54b12 100644
--- a/tests/ui/upper_case_acronyms.rs
+++ b/tests/ui/upper_case_acronyms.rs
@@ -24,4 +24,18 @@ struct GCCLLVMSomething;
 pub struct NOWARNINGHERE;
 pub struct ALSONoWarningHERE;
 
+// enum variants should not be linted if the num is pub
+pub enum ParseError<T> {
+    YDB(u8),
+    Utf8(std::string::FromUtf8Error),
+    Parse(T, String),
+}
+
+// private, do lint here
+enum ParseErrorPrivate<T> {
+    WASD(u8),
+    Utf8(std::string::FromUtf8Error),
+    Parse(T, String),
+}
+
 fn main() {}
diff --git a/tests/ui/upper_case_acronyms.stderr b/tests/ui/upper_case_acronyms.stderr
index bbe38991e52..250b196a99e 100644
--- a/tests/ui/upper_case_acronyms.stderr
+++ b/tests/ui/upper_case_acronyms.stderr
@@ -48,5 +48,11 @@ error: name `FIN` contains a capitalized acronym
 LL |     FIN,
    |     ^^^ help: consider making the acronym lowercase, except the initial letter: `Fin`
 
-error: aborting due to 8 previous errors
+error: name `WASD` contains a capitalized acronym
+  --> $DIR/upper_case_acronyms.rs:36:5
+   |
+LL |     WASD(u8),
+   |     ^^^^ help: consider making the acronym lowercase, except the initial letter: `Wasd`
+
+error: aborting due to 9 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 12985afbcad28eb67c0b5c5903ff21b6fa922b13 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Fri, 26 Mar 2021 16:27:19 -0400
Subject: `len_without_is_empty` improvements Check the return type of `len`.
 Only integral types, or an `Option` or `Result` wrapping one. Ensure the
 return type of `is_empty` matches. e.g. `Option<usize>` -> `Option<bool>`

---
 clippy_lints/src/len_zero.rs         | 78 +++++++++++++++++++++++-----
 tests/ui/len_without_is_empty.rs     | 99 +++++++++++++++++++++++++++++++++++-
 tests/ui/len_without_is_empty.stderr | 79 ++++++++++++++++++++++++----
 3 files changed, 231 insertions(+), 25 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/len_zero.rs b/clippy_lints/src/len_zero.rs
index 717f2ea84f4..fb522be2f1a 100644
--- a/clippy_lints/src/len_zero.rs
+++ b/clippy_lints/src/len_zero.rs
@@ -10,9 +10,12 @@ use rustc_hir::{
     ItemKind, Mutability, Node, TraitItemRef, TyKind,
 };
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty::{self, AssocKind, FnSig};
+use rustc_middle::ty::{self, AssocKind, FnSig, Ty, TyS};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::source_map::{Span, Spanned, Symbol};
+use rustc_span::{
+    source_map::{Span, Spanned, Symbol},
+    symbol::sym,
+};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for getting the length of something via `.len()`
@@ -137,6 +140,7 @@ impl<'tcx> LateLintPass<'tcx> for LenZero {
             if let Some(local_id) = ty_id.as_local();
             let ty_hir_id = cx.tcx.hir().local_def_id_to_hir_id(local_id);
             if !is_allowed(cx, LEN_WITHOUT_IS_EMPTY, ty_hir_id);
+            if let Some(output) = parse_len_output(cx, cx.tcx.fn_sig(item.def_id).skip_binder());
             then {
                 let (name, kind) = match cx.tcx.hir().find(ty_hir_id) {
                     Some(Node::ForeignItem(x)) => (x.ident.name, "extern type"),
@@ -148,7 +152,7 @@ impl<'tcx> LateLintPass<'tcx> for LenZero {
                     }
                     _ => return,
                 };
-                check_for_is_empty(cx, sig.span, sig.decl.implicit_self, ty_id, name, kind)
+                check_for_is_empty(cx, sig.span, sig.decl.implicit_self, output, ty_id, name, kind)
             }
         }
     }
@@ -231,10 +235,62 @@ fn check_trait_items(cx: &LateContext<'_>, visited_trait: &Item<'_>, trait_items
     }
 }
 
+#[derive(Debug, Clone, Copy)]
+enum LenOutput<'tcx> {
+    Integral,
+    Option(DefId),
+    Result(DefId, Ty<'tcx>),
+}
+fn parse_len_output(cx: &LateContext<'_>, sig: FnSig<'tcx>) -> Option<LenOutput<'tcx>> {
+    match *sig.output().kind() {
+        ty::Int(_) | ty::Uint(_) => Some(LenOutput::Integral),
+        ty::Adt(adt, subs) if cx.tcx.is_diagnostic_item(sym::option_type, adt.did) => {
+            subs.type_at(0).is_integral().then(|| LenOutput::Option(adt.did))
+        },
+        ty::Adt(adt, subs) if cx.tcx.is_diagnostic_item(sym::result_type, adt.did) => subs
+            .type_at(0)
+            .is_integral()
+            .then(|| LenOutput::Result(adt.did, subs.type_at(1))),
+        _ => None,
+    }
+}
+
+impl LenOutput<'_> {
+    fn matches_is_empty_output(self, ty: Ty<'_>) -> bool {
+        match (self, ty.kind()) {
+            (_, &ty::Bool) => true,
+            (Self::Option(id), &ty::Adt(adt, subs)) if id == adt.did => subs.type_at(0).is_bool(),
+            (Self::Result(id, err_ty), &ty::Adt(adt, subs)) if id == adt.did => {
+                subs.type_at(0).is_bool() && TyS::same_type(subs.type_at(1), err_ty)
+            },
+            _ => false,
+        }
+    }
+
+    fn expected_sig(self, self_kind: ImplicitSelfKind) -> String {
+        let self_ref = match self_kind {
+            ImplicitSelfKind::ImmRef => "&",
+            ImplicitSelfKind::MutRef => "&mut ",
+            _ => "",
+        };
+        match self {
+            Self::Integral => format!("expected signature: `({}self) -> bool`", self_ref),
+            Self::Option(_) => format!(
+                "expected signature: `({}self) -> bool` or `({}self) -> Option<bool>",
+                self_ref, self_ref
+            ),
+            Self::Result(..) => format!(
+                "expected signature: `({}self) -> bool` or `({}self) -> Result<bool>",
+                self_ref, self_ref
+            ),
+        }
+    }
+}
+
 /// Checks if the given signature matches the expectations for `is_empty`
-fn check_is_empty_sig(cx: &LateContext<'_>, sig: FnSig<'_>, self_kind: ImplicitSelfKind) -> bool {
+fn check_is_empty_sig(sig: FnSig<'_>, self_kind: ImplicitSelfKind, len_output: LenOutput<'_>) -> bool {
     match &**sig.inputs_and_output {
-        [arg, res] if *res == cx.tcx.types.bool => {
+        [arg, res] if len_output.matches_is_empty_output(res) => {
             matches!(
                 (arg.kind(), self_kind),
                 (ty::Ref(_, _, Mutability::Not), ImplicitSelfKind::ImmRef)
@@ -250,6 +306,7 @@ fn check_for_is_empty(
     cx: &LateContext<'_>,
     span: Span,
     self_kind: ImplicitSelfKind,
+    output: LenOutput<'_>,
     impl_ty: DefId,
     item_name: Symbol,
     item_kind: &str,
@@ -289,7 +346,7 @@ fn check_for_is_empty(
         },
         Some(is_empty)
             if !(is_empty.fn_has_self_parameter
-                && check_is_empty_sig(cx, cx.tcx.fn_sig(is_empty.def_id).skip_binder(), self_kind)) =>
+                && check_is_empty_sig(cx.tcx.fn_sig(is_empty.def_id).skip_binder(), self_kind, output)) =>
         {
             (
                 format!(
@@ -309,14 +366,7 @@ fn check_for_is_empty(
             db.span_note(span, "`is_empty` defined here");
         }
         if let Some(self_kind) = self_kind {
-            db.note(&format!(
-                "expected signature: `({}self) -> bool`",
-                match self_kind {
-                    ImplicitSelfKind::ImmRef => "&",
-                    ImplicitSelfKind::MutRef => "&mut ",
-                    _ => "",
-                }
-            ));
+            db.note(&output.expected_sig(self_kind));
         }
     });
 }
diff --git a/tests/ui/len_without_is_empty.rs b/tests/ui/len_without_is_empty.rs
index 6b3636a482e..b9d66347c27 100644
--- a/tests/ui/len_without_is_empty.rs
+++ b/tests/ui/len_without_is_empty.rs
@@ -1,3 +1,5 @@
+// edition:2018
+
 #![warn(clippy::len_without_is_empty)]
 #![allow(dead_code, unused)]
 
@@ -172,9 +174,9 @@ pub trait DependsOnFoo: Foo {
     fn len(&mut self) -> usize;
 }
 
+// issue #1562
 pub struct MultipleImpls;
 
-// issue #1562
 impl MultipleImpls {
     pub fn len(&self) -> usize {
         1
@@ -187,4 +189,99 @@ impl MultipleImpls {
     }
 }
 
+// issue #6958
+pub struct OptionalLen;
+
+impl OptionalLen {
+    pub fn len(&self) -> Option<usize> {
+        Some(0)
+    }
+
+    pub fn is_empty(&self) -> Option<bool> {
+        Some(true)
+    }
+}
+
+pub struct OptionalLen2;
+impl OptionalLen2 {
+    pub fn len(&self) -> Option<usize> {
+        Some(0)
+    }
+
+    pub fn is_empty(&self) -> bool {
+        true
+    }
+}
+
+pub struct OptionalLen3;
+impl OptionalLen3 {
+    pub fn len(&self) -> usize {
+        0
+    }
+
+    // should lint, len is not an option
+    pub fn is_empty(&self) -> Option<bool> {
+        None
+    }
+}
+
+pub struct ResultLen;
+impl ResultLen {
+    pub fn len(&self) -> Result<usize, ()> {
+        Ok(0)
+    }
+
+    // Differing result types
+    pub fn is_empty(&self) -> Option<bool> {
+        Some(true)
+    }
+}
+
+pub struct ResultLen2;
+impl ResultLen2 {
+    pub fn len(&self) -> Result<usize, ()> {
+        Ok(0)
+    }
+
+    pub fn is_empty(&self) -> Result<bool, ()> {
+        Ok(true)
+    }
+}
+
+pub struct ResultLen3;
+impl ResultLen3 {
+    pub fn len(&self) -> Result<usize, ()> {
+        Ok(0)
+    }
+
+    // Non-fallible result is ok.
+    pub fn is_empty(&self) -> bool {
+        true
+    }
+}
+
+pub struct OddLenSig;
+impl OddLenSig {
+    // don't lint
+    pub fn len(&self) -> bool {
+        true
+    }
+}
+
+// issue #6958
+pub struct AsyncLen;
+impl AsyncLen {
+    async fn async_task(&self) -> bool {
+        true
+    }
+
+    pub async fn len(&self) -> usize {
+        if self.async_task().await { 0 } else { 1 }
+    }
+
+    pub async fn is_empty(&self) -> bool {
+        self.len().await == 0
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/len_without_is_empty.stderr b/tests/ui/len_without_is_empty.stderr
index f106506faf4..ff7f5562308 100644
--- a/tests/ui/len_without_is_empty.stderr
+++ b/tests/ui/len_without_is_empty.stderr
@@ -1,5 +1,5 @@
 error: struct `PubOne` has a public `len` method, but no `is_empty` method
-  --> $DIR/len_without_is_empty.rs:7:5
+  --> $DIR/len_without_is_empty.rs:9:5
    |
 LL |     pub fn len(&self) -> isize {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -7,7 +7,7 @@ LL |     pub fn len(&self) -> isize {
    = note: `-D clippy::len-without-is-empty` implied by `-D warnings`
 
 error: trait `PubTraitsToo` has a `len` method but no (possibly inherited) `is_empty` method
-  --> $DIR/len_without_is_empty.rs:55:1
+  --> $DIR/len_without_is_empty.rs:57:1
    |
 LL | / pub trait PubTraitsToo {
 LL | |     fn len(&self) -> isize;
@@ -15,50 +15,109 @@ LL | | }
    | |_^
 
 error: struct `HasIsEmpty` has a public `len` method, but a private `is_empty` method
-  --> $DIR/len_without_is_empty.rs:68:5
+  --> $DIR/len_without_is_empty.rs:70:5
    |
 LL |     pub fn len(&self) -> isize {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: `is_empty` defined here
-  --> $DIR/len_without_is_empty.rs:72:5
+  --> $DIR/len_without_is_empty.rs:74:5
    |
 LL |     fn is_empty(&self) -> bool {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: struct `HasWrongIsEmpty` has a public `len` method, but the `is_empty` method has an unexpected signature
-  --> $DIR/len_without_is_empty.rs:80:5
+  --> $DIR/len_without_is_empty.rs:82:5
    |
 LL |     pub fn len(&self) -> isize {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: `is_empty` defined here
-  --> $DIR/len_without_is_empty.rs:84:5
+  --> $DIR/len_without_is_empty.rs:86:5
    |
 LL |     pub fn is_empty(&self, x: u32) -> bool {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    = note: expected signature: `(&self) -> bool`
 
 error: struct `MismatchedSelf` has a public `len` method, but the `is_empty` method has an unexpected signature
-  --> $DIR/len_without_is_empty.rs:92:5
+  --> $DIR/len_without_is_empty.rs:94:5
    |
 LL |     pub fn len(self) -> isize {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: `is_empty` defined here
-  --> $DIR/len_without_is_empty.rs:96:5
+  --> $DIR/len_without_is_empty.rs:98:5
    |
 LL |     pub fn is_empty(&self) -> bool {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    = note: expected signature: `(self) -> bool`
 
 error: trait `DependsOnFoo` has a `len` method but no (possibly inherited) `is_empty` method
-  --> $DIR/len_without_is_empty.rs:171:1
+  --> $DIR/len_without_is_empty.rs:173:1
    |
 LL | / pub trait DependsOnFoo: Foo {
 LL | |     fn len(&mut self) -> usize;
 LL | | }
    | |_^
 
-error: aborting due to 6 previous errors
+error: struct `OptionalLen3` has a public `len` method, but the `is_empty` method has an unexpected signature
+  --> $DIR/len_without_is_empty.rs:218:5
+   |
+LL |     pub fn len(&self) -> usize {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: `is_empty` defined here
+  --> $DIR/len_without_is_empty.rs:223:5
+   |
+LL |     pub fn is_empty(&self) -> Option<bool> {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   = note: expected signature: `(&self) -> bool`
+
+error: struct `ResultLen` has a public `len` method, but the `is_empty` method has an unexpected signature
+  --> $DIR/len_without_is_empty.rs:230:5
+   |
+LL |     pub fn len(&self) -> Result<usize, ()> {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: `is_empty` defined here
+  --> $DIR/len_without_is_empty.rs:235:5
+   |
+LL |     pub fn is_empty(&self) -> Option<bool> {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   = note: expected signature: `(&self) -> bool` or `(&self) -> Result<bool>
+
+error: this returns a `Result<_, ()>
+  --> $DIR/len_without_is_empty.rs:230:5
+   |
+LL |     pub fn len(&self) -> Result<usize, ()> {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::result-unit-err` implied by `-D warnings`
+   = help: use a custom Error type instead
+
+error: this returns a `Result<_, ()>
+  --> $DIR/len_without_is_empty.rs:242:5
+   |
+LL |     pub fn len(&self) -> Result<usize, ()> {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use a custom Error type instead
+
+error: this returns a `Result<_, ()>
+  --> $DIR/len_without_is_empty.rs:246:5
+   |
+LL |     pub fn is_empty(&self) -> Result<bool, ()> {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use a custom Error type instead
+
+error: this returns a `Result<_, ()>
+  --> $DIR/len_without_is_empty.rs:253:5
+   |
+LL |     pub fn len(&self) -> Result<usize, ()> {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use a custom Error type instead
+
+error: aborting due to 12 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From febf34e2b4ed9b66fc3095d55ae13cef9b6b154b Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Wed, 24 Mar 2021 23:12:08 +0900
Subject: Move too_many_arguments to its own module

---
 clippy_lints/src/functions.rs                    | 738 -----------------------
 clippy_lints/src/functions/mod.rs                | 713 ++++++++++++++++++++++
 clippy_lints/src/functions/too_many_arguments.rs |  73 +++
 clippy_lints/src/lib.rs                          |   6 +-
 4 files changed, 789 insertions(+), 741 deletions(-)
 delete mode 100644 clippy_lints/src/functions.rs
 create mode 100644 clippy_lints/src/functions/mod.rs
 create mode 100644 clippy_lints/src/functions/too_many_arguments.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/functions.rs b/clippy_lints/src/functions.rs
deleted file mode 100644
index 730492fc7e3..00000000000
--- a/clippy_lints/src/functions.rs
+++ /dev/null
@@ -1,738 +0,0 @@
-use clippy_utils::diagnostics::{span_lint, span_lint_and_help, span_lint_and_then};
-use clippy_utils::source::{snippet, snippet_opt};
-use clippy_utils::ty::{is_must_use_ty, is_type_diagnostic_item, type_is_unsafe_function};
-use clippy_utils::{
-    attr_by_name, attrs::is_proc_macro, is_trait_impl_item, iter_input_pats, match_def_path, must_use_attr,
-    path_to_local, return_ty, trait_ref_of_method,
-};
-use if_chain::if_chain;
-use rustc_ast::ast::Attribute;
-use rustc_data_structures::fx::FxHashSet;
-use rustc_errors::Applicability;
-use rustc_hir as hir;
-use rustc_hir::intravisit;
-use rustc_hir::{def::Res, def_id::DefId, QPath};
-use rustc_lint::{LateContext, LateLintPass, LintContext};
-use rustc_middle::hir::map::Map;
-use rustc_middle::lint::in_external_macro;
-use rustc_middle::ty::{self, Ty};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::source_map::Span;
-use rustc_span::sym;
-use rustc_target::spec::abi::Abi;
-use rustc_typeck::hir_ty_to_ty;
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for functions with too many parameters.
-    ///
-    /// **Why is this bad?** Functions with lots of parameters are considered bad
-    /// style and reduce readability (“what does the 5th parameter mean?”). Consider
-    /// grouping some parameters into a new type.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    /// ```rust
-    /// # struct Color;
-    /// fn foo(x: u32, y: u32, name: &str, c: Color, w: f32, h: f32, a: f32, b: f32) {
-    ///     // ..
-    /// }
-    /// ```
-    pub TOO_MANY_ARGUMENTS,
-    complexity,
-    "functions with too many arguments"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for functions with a large amount of lines.
-    ///
-    /// **Why is this bad?** Functions with a lot of lines are harder to understand
-    /// due to having to look at a larger amount of code to understand what the
-    /// function is doing. Consider splitting the body of the function into
-    /// multiple functions.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    /// ```rust
-    /// fn im_too_long() {
-    ///     println!("");
-    ///     // ... 100 more LoC
-    ///     println!("");
-    /// }
-    /// ```
-    pub TOO_MANY_LINES,
-    pedantic,
-    "functions with too many lines"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for public functions that dereference raw pointer
-    /// arguments but are not marked unsafe.
-    ///
-    /// **Why is this bad?** The function should probably be marked `unsafe`, since
-    /// for an arbitrary raw pointer, there is no way of telling for sure if it is
-    /// valid.
-    ///
-    /// **Known problems:**
-    ///
-    /// * It does not check functions recursively so if the pointer is passed to a
-    /// private non-`unsafe` function which does the dereferencing, the lint won't
-    /// trigger.
-    /// * It only checks for arguments whose type are raw pointers, not raw pointers
-    /// got from an argument in some other way (`fn foo(bar: &[*const u8])` or
-    /// `some_argument.get_raw_ptr()`).
-    ///
-    /// **Example:**
-    /// ```rust,ignore
-    /// // Bad
-    /// pub fn foo(x: *const u8) {
-    ///     println!("{}", unsafe { *x });
-    /// }
-    ///
-    /// // Good
-    /// pub unsafe fn foo(x: *const u8) {
-    ///     println!("{}", unsafe { *x });
-    /// }
-    /// ```
-    pub NOT_UNSAFE_PTR_ARG_DEREF,
-    correctness,
-    "public functions dereferencing raw pointer arguments but not marked `unsafe`"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for a [`#[must_use]`] attribute on
-    /// unit-returning functions and methods.
-    ///
-    /// [`#[must_use]`]: https://doc.rust-lang.org/reference/attributes/diagnostics.html#the-must_use-attribute
-    ///
-    /// **Why is this bad?** Unit values are useless. The attribute is likely
-    /// a remnant of a refactoring that removed the return type.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Examples:**
-    /// ```rust
-    /// #[must_use]
-    /// fn useless() { }
-    /// ```
-    pub MUST_USE_UNIT,
-    style,
-    "`#[must_use]` attribute on a unit-returning function / method"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for a [`#[must_use]`] attribute without
-    /// further information on functions and methods that return a type already
-    /// marked as `#[must_use]`.
-    ///
-    /// [`#[must_use]`]: https://doc.rust-lang.org/reference/attributes/diagnostics.html#the-must_use-attribute
-    ///
-    /// **Why is this bad?** The attribute isn't needed. Not using the result
-    /// will already be reported. Alternatively, one can add some text to the
-    /// attribute to improve the lint message.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Examples:**
-    /// ```rust
-    /// #[must_use]
-    /// fn double_must_use() -> Result<(), ()> {
-    ///     unimplemented!();
-    /// }
-    /// ```
-    pub DOUBLE_MUST_USE,
-    style,
-    "`#[must_use]` attribute on a `#[must_use]`-returning function / method"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for public functions that have no
-    /// [`#[must_use]`] attribute, but return something not already marked
-    /// must-use, have no mutable arg and mutate no statics.
-    ///
-    /// [`#[must_use]`]: https://doc.rust-lang.org/reference/attributes/diagnostics.html#the-must_use-attribute
-    ///
-    /// **Why is this bad?** Not bad at all, this lint just shows places where
-    /// you could add the attribute.
-    ///
-    /// **Known problems:** The lint only checks the arguments for mutable
-    /// types without looking if they are actually changed. On the other hand,
-    /// it also ignores a broad range of potentially interesting side effects,
-    /// because we cannot decide whether the programmer intends the function to
-    /// be called for the side effect or the result. Expect many false
-    /// positives. At least we don't lint if the result type is unit or already
-    /// `#[must_use]`.
-    ///
-    /// **Examples:**
-    /// ```rust
-    /// // this could be annotated with `#[must_use]`.
-    /// fn id<T>(t: T) -> T { t }
-    /// ```
-    pub MUST_USE_CANDIDATE,
-    pedantic,
-    "function or method that could take a `#[must_use]` attribute"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for public functions that return a `Result`
-    /// with an `Err` type of `()`. It suggests using a custom type that
-    /// implements [`std::error::Error`].
-    ///
-    /// **Why is this bad?** Unit does not implement `Error` and carries no
-    /// further information about what went wrong.
-    ///
-    /// **Known problems:** Of course, this lint assumes that `Result` is used
-    /// for a fallible operation (which is after all the intended use). However
-    /// code may opt to (mis)use it as a basic two-variant-enum. In that case,
-    /// the suggestion is misguided, and the code should use a custom enum
-    /// instead.
-    ///
-    /// **Examples:**
-    /// ```rust
-    /// pub fn read_u8() -> Result<u8, ()> { Err(()) }
-    /// ```
-    /// should become
-    /// ```rust,should_panic
-    /// use std::fmt;
-    ///
-    /// #[derive(Debug)]
-    /// pub struct EndOfStream;
-    ///
-    /// impl fmt::Display for EndOfStream {
-    ///     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-    ///         write!(f, "End of Stream")
-    ///     }
-    /// }
-    ///
-    /// impl std::error::Error for EndOfStream { }
-    ///
-    /// pub fn read_u8() -> Result<u8, EndOfStream> { Err(EndOfStream) }
-    ///# fn main() {
-    ///#     read_u8().unwrap();
-    ///# }
-    /// ```
-    ///
-    /// Note that there are crates that simplify creating the error type, e.g.
-    /// [`thiserror`](https://docs.rs/thiserror).
-    pub RESULT_UNIT_ERR,
-    style,
-    "public function returning `Result` with an `Err` type of `()`"
-}
-
-#[derive(Copy, Clone)]
-pub struct Functions {
-    threshold: u64,
-    max_lines: u64,
-}
-
-impl Functions {
-    pub fn new(threshold: u64, max_lines: u64) -> Self {
-        Self { threshold, max_lines }
-    }
-}
-
-impl_lint_pass!(Functions => [
-    TOO_MANY_ARGUMENTS,
-    TOO_MANY_LINES,
-    NOT_UNSAFE_PTR_ARG_DEREF,
-    MUST_USE_UNIT,
-    DOUBLE_MUST_USE,
-    MUST_USE_CANDIDATE,
-    RESULT_UNIT_ERR,
-]);
-
-impl<'tcx> LateLintPass<'tcx> for Functions {
-    fn check_fn(
-        &mut self,
-        cx: &LateContext<'tcx>,
-        kind: intravisit::FnKind<'tcx>,
-        decl: &'tcx hir::FnDecl<'_>,
-        body: &'tcx hir::Body<'_>,
-        span: Span,
-        hir_id: hir::HirId,
-    ) {
-        let unsafety = match kind {
-            intravisit::FnKind::ItemFn(_, _, hir::FnHeader { unsafety, .. }, _) => unsafety,
-            intravisit::FnKind::Method(_, sig, _) => sig.header.unsafety,
-            intravisit::FnKind::Closure => return,
-        };
-
-        // don't warn for implementations, it's not their fault
-        if !is_trait_impl_item(cx, hir_id) {
-            // don't lint extern functions decls, it's not their fault either
-            match kind {
-                intravisit::FnKind::Method(
-                    _,
-                    &hir::FnSig {
-                        header: hir::FnHeader { abi: Abi::Rust, .. },
-                        ..
-                    },
-                    _,
-                )
-                | intravisit::FnKind::ItemFn(_, _, hir::FnHeader { abi: Abi::Rust, .. }, _) => {
-                    self.check_arg_number(cx, decl, span.with_hi(decl.output.span().hi()))
-                },
-                _ => {},
-            }
-        }
-
-        Self::check_raw_ptr(cx, unsafety, decl, body, hir_id);
-        self.check_line_number(cx, span, body);
-    }
-
-    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) {
-        let attrs = cx.tcx.hir().attrs(item.hir_id());
-        let attr = must_use_attr(attrs);
-        if let hir::ItemKind::Fn(ref sig, ref _generics, ref body_id) = item.kind {
-            let is_public = cx.access_levels.is_exported(item.hir_id());
-            let fn_header_span = item.span.with_hi(sig.decl.output.span().hi());
-            if is_public {
-                check_result_unit_err(cx, &sig.decl, item.span, fn_header_span);
-            }
-            if let Some(attr) = attr {
-                check_needless_must_use(cx, &sig.decl, item.hir_id(), item.span, fn_header_span, attr);
-                return;
-            }
-            if is_public && !is_proc_macro(cx.sess(), attrs) && attr_by_name(attrs, "no_mangle").is_none() {
-                check_must_use_candidate(
-                    cx,
-                    &sig.decl,
-                    cx.tcx.hir().body(*body_id),
-                    item.span,
-                    item.hir_id(),
-                    item.span.with_hi(sig.decl.output.span().hi()),
-                    "this function could have a `#[must_use]` attribute",
-                );
-            }
-        }
-    }
-
-    fn check_impl_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::ImplItem<'_>) {
-        if let hir::ImplItemKind::Fn(ref sig, ref body_id) = item.kind {
-            let is_public = cx.access_levels.is_exported(item.hir_id());
-            let fn_header_span = item.span.with_hi(sig.decl.output.span().hi());
-            if is_public && trait_ref_of_method(cx, item.hir_id()).is_none() {
-                check_result_unit_err(cx, &sig.decl, item.span, fn_header_span);
-            }
-            let attrs = cx.tcx.hir().attrs(item.hir_id());
-            let attr = must_use_attr(attrs);
-            if let Some(attr) = attr {
-                check_needless_must_use(cx, &sig.decl, item.hir_id(), item.span, fn_header_span, attr);
-            } else if is_public && !is_proc_macro(cx.sess(), attrs) && trait_ref_of_method(cx, item.hir_id()).is_none()
-            {
-                check_must_use_candidate(
-                    cx,
-                    &sig.decl,
-                    cx.tcx.hir().body(*body_id),
-                    item.span,
-                    item.hir_id(),
-                    item.span.with_hi(sig.decl.output.span().hi()),
-                    "this method could have a `#[must_use]` attribute",
-                );
-            }
-        }
-    }
-
-    fn check_trait_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::TraitItem<'_>) {
-        if let hir::TraitItemKind::Fn(ref sig, ref eid) = item.kind {
-            // don't lint extern functions decls, it's not their fault
-            if sig.header.abi == Abi::Rust {
-                self.check_arg_number(cx, &sig.decl, item.span.with_hi(sig.decl.output.span().hi()));
-            }
-            let is_public = cx.access_levels.is_exported(item.hir_id());
-            let fn_header_span = item.span.with_hi(sig.decl.output.span().hi());
-            if is_public {
-                check_result_unit_err(cx, &sig.decl, item.span, fn_header_span);
-            }
-
-            let attrs = cx.tcx.hir().attrs(item.hir_id());
-            let attr = must_use_attr(attrs);
-            if let Some(attr) = attr {
-                check_needless_must_use(cx, &sig.decl, item.hir_id(), item.span, fn_header_span, attr);
-            }
-            if let hir::TraitFn::Provided(eid) = *eid {
-                let body = cx.tcx.hir().body(eid);
-                Self::check_raw_ptr(cx, sig.header.unsafety, &sig.decl, body, item.hir_id());
-
-                if attr.is_none() && is_public && !is_proc_macro(cx.sess(), attrs) {
-                    check_must_use_candidate(
-                        cx,
-                        &sig.decl,
-                        body,
-                        item.span,
-                        item.hir_id(),
-                        item.span.with_hi(sig.decl.output.span().hi()),
-                        "this method could have a `#[must_use]` attribute",
-                    );
-                }
-            }
-        }
-    }
-}
-
-impl<'tcx> Functions {
-    fn check_arg_number(self, cx: &LateContext<'_>, decl: &hir::FnDecl<'_>, fn_span: Span) {
-        let args = decl.inputs.len() as u64;
-        if args > self.threshold {
-            span_lint(
-                cx,
-                TOO_MANY_ARGUMENTS,
-                fn_span,
-                &format!("this function has too many arguments ({}/{})", args, self.threshold),
-            );
-        }
-    }
-
-    fn check_line_number(self, cx: &LateContext<'_>, span: Span, body: &'tcx hir::Body<'_>) {
-        if in_external_macro(cx.sess(), span) {
-            return;
-        }
-
-        let code_snippet = snippet(cx, body.value.span, "..");
-        let mut line_count: u64 = 0;
-        let mut in_comment = false;
-        let mut code_in_line;
-
-        // Skip the surrounding function decl.
-        let start_brace_idx = code_snippet.find('{').map_or(0, |i| i + 1);
-        let end_brace_idx = code_snippet.rfind('}').unwrap_or_else(|| code_snippet.len());
-        let function_lines = code_snippet[start_brace_idx..end_brace_idx].lines();
-
-        for mut line in function_lines {
-            code_in_line = false;
-            loop {
-                line = line.trim_start();
-                if line.is_empty() {
-                    break;
-                }
-                if in_comment {
-                    if let Some(i) = line.find("*/") {
-                        line = &line[i + 2..];
-                        in_comment = false;
-                        continue;
-                    }
-                } else {
-                    let multi_idx = line.find("/*").unwrap_or_else(|| line.len());
-                    let single_idx = line.find("//").unwrap_or_else(|| line.len());
-                    code_in_line |= multi_idx > 0 && single_idx > 0;
-                    // Implies multi_idx is below line.len()
-                    if multi_idx < single_idx {
-                        line = &line[multi_idx + 2..];
-                        in_comment = true;
-                        continue;
-                    }
-                }
-                break;
-            }
-            if code_in_line {
-                line_count += 1;
-            }
-        }
-
-        if line_count > self.max_lines {
-            span_lint(
-                cx,
-                TOO_MANY_LINES,
-                span,
-                &format!("this function has too many lines ({}/{})", line_count, self.max_lines),
-            )
-        }
-    }
-
-    fn check_raw_ptr(
-        cx: &LateContext<'tcx>,
-        unsafety: hir::Unsafety,
-        decl: &'tcx hir::FnDecl<'_>,
-        body: &'tcx hir::Body<'_>,
-        hir_id: hir::HirId,
-    ) {
-        let expr = &body.value;
-        if unsafety == hir::Unsafety::Normal && cx.access_levels.is_exported(hir_id) {
-            let raw_ptrs = iter_input_pats(decl, body)
-                .zip(decl.inputs.iter())
-                .filter_map(|(arg, ty)| raw_ptr_arg(arg, ty))
-                .collect::<FxHashSet<_>>();
-
-            if !raw_ptrs.is_empty() {
-                let typeck_results = cx.tcx.typeck_body(body.id());
-                let mut v = DerefVisitor {
-                    cx,
-                    ptrs: raw_ptrs,
-                    typeck_results,
-                };
-
-                intravisit::walk_expr(&mut v, expr);
-            }
-        }
-    }
-}
-
-fn check_result_unit_err(cx: &LateContext<'_>, decl: &hir::FnDecl<'_>, item_span: Span, fn_header_span: Span) {
-    if_chain! {
-        if !in_external_macro(cx.sess(), item_span);
-        if let hir::FnRetTy::Return(ref ty) = decl.output;
-        let ty = hir_ty_to_ty(cx.tcx, ty);
-        if is_type_diagnostic_item(cx, ty, sym::result_type);
-        if let ty::Adt(_, substs) = ty.kind();
-        let err_ty = substs.type_at(1);
-        if err_ty.is_unit();
-        then {
-            span_lint_and_help(
-                cx,
-                RESULT_UNIT_ERR,
-                fn_header_span,
-                "this returns a `Result<_, ()>",
-                None,
-                "use a custom Error type instead",
-            );
-        }
-    }
-}
-
-fn check_needless_must_use(
-    cx: &LateContext<'_>,
-    decl: &hir::FnDecl<'_>,
-    item_id: hir::HirId,
-    item_span: Span,
-    fn_header_span: Span,
-    attr: &Attribute,
-) {
-    if in_external_macro(cx.sess(), item_span) {
-        return;
-    }
-    if returns_unit(decl) {
-        span_lint_and_then(
-            cx,
-            MUST_USE_UNIT,
-            fn_header_span,
-            "this unit-returning function has a `#[must_use]` attribute",
-            |diag| {
-                diag.span_suggestion(
-                    attr.span,
-                    "remove the attribute",
-                    "".into(),
-                    Applicability::MachineApplicable,
-                );
-            },
-        );
-    } else if !attr.is_value_str() && is_must_use_ty(cx, return_ty(cx, item_id)) {
-        span_lint_and_help(
-            cx,
-            DOUBLE_MUST_USE,
-            fn_header_span,
-            "this function has an empty `#[must_use]` attribute, but returns a type already marked as `#[must_use]`",
-            None,
-            "either add some descriptive text or remove the attribute",
-        );
-    }
-}
-
-fn check_must_use_candidate<'tcx>(
-    cx: &LateContext<'tcx>,
-    decl: &'tcx hir::FnDecl<'_>,
-    body: &'tcx hir::Body<'_>,
-    item_span: Span,
-    item_id: hir::HirId,
-    fn_span: Span,
-    msg: &str,
-) {
-    if has_mutable_arg(cx, body)
-        || mutates_static(cx, body)
-        || in_external_macro(cx.sess(), item_span)
-        || returns_unit(decl)
-        || !cx.access_levels.is_exported(item_id)
-        || is_must_use_ty(cx, return_ty(cx, item_id))
-    {
-        return;
-    }
-    span_lint_and_then(cx, MUST_USE_CANDIDATE, fn_span, msg, |diag| {
-        if let Some(snippet) = snippet_opt(cx, fn_span) {
-            diag.span_suggestion(
-                fn_span,
-                "add the attribute",
-                format!("#[must_use] {}", snippet),
-                Applicability::MachineApplicable,
-            );
-        }
-    });
-}
-
-fn returns_unit(decl: &hir::FnDecl<'_>) -> bool {
-    match decl.output {
-        hir::FnRetTy::DefaultReturn(_) => true,
-        hir::FnRetTy::Return(ref ty) => match ty.kind {
-            hir::TyKind::Tup(ref tys) => tys.is_empty(),
-            hir::TyKind::Never => true,
-            _ => false,
-        },
-    }
-}
-
-fn has_mutable_arg(cx: &LateContext<'_>, body: &hir::Body<'_>) -> bool {
-    let mut tys = FxHashSet::default();
-    body.params.iter().any(|param| is_mutable_pat(cx, &param.pat, &mut tys))
-}
-
-fn is_mutable_pat(cx: &LateContext<'_>, pat: &hir::Pat<'_>, tys: &mut FxHashSet<DefId>) -> bool {
-    if let hir::PatKind::Wild = pat.kind {
-        return false; // ignore `_` patterns
-    }
-    if cx.tcx.has_typeck_results(pat.hir_id.owner.to_def_id()) {
-        is_mutable_ty(cx, &cx.tcx.typeck(pat.hir_id.owner).pat_ty(pat), pat.span, tys)
-    } else {
-        false
-    }
-}
-
-static KNOWN_WRAPPER_TYS: &[&[&str]] = &[&["alloc", "rc", "Rc"], &["std", "sync", "Arc"]];
-
-fn is_mutable_ty<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>, span: Span, tys: &mut FxHashSet<DefId>) -> bool {
-    match *ty.kind() {
-        // primitive types are never mutable
-        ty::Bool | ty::Char | ty::Int(_) | ty::Uint(_) | ty::Float(_) | ty::Str => false,
-        ty::Adt(ref adt, ref substs) => {
-            tys.insert(adt.did) && !ty.is_freeze(cx.tcx.at(span), cx.param_env)
-                || KNOWN_WRAPPER_TYS.iter().any(|path| match_def_path(cx, adt.did, path))
-                    && substs.types().any(|ty| is_mutable_ty(cx, ty, span, tys))
-        },
-        ty::Tuple(ref substs) => substs.types().any(|ty| is_mutable_ty(cx, ty, span, tys)),
-        ty::Array(ty, _) | ty::Slice(ty) => is_mutable_ty(cx, ty, span, tys),
-        ty::RawPtr(ty::TypeAndMut { ty, mutbl }) | ty::Ref(_, ty, mutbl) => {
-            mutbl == hir::Mutability::Mut || is_mutable_ty(cx, ty, span, tys)
-        },
-        // calling something constitutes a side effect, so return true on all callables
-        // also never calls need not be used, so return true for them, too
-        _ => true,
-    }
-}
-
-fn raw_ptr_arg(arg: &hir::Param<'_>, ty: &hir::Ty<'_>) -> Option<hir::HirId> {
-    if let (&hir::PatKind::Binding(_, id, _, _), &hir::TyKind::Ptr(_)) = (&arg.pat.kind, &ty.kind) {
-        Some(id)
-    } else {
-        None
-    }
-}
-
-struct DerefVisitor<'a, 'tcx> {
-    cx: &'a LateContext<'tcx>,
-    ptrs: FxHashSet<hir::HirId>,
-    typeck_results: &'a ty::TypeckResults<'tcx>,
-}
-
-impl<'a, 'tcx> intravisit::Visitor<'tcx> for DerefVisitor<'a, 'tcx> {
-    type Map = Map<'tcx>;
-
-    fn visit_expr(&mut self, expr: &'tcx hir::Expr<'_>) {
-        match expr.kind {
-            hir::ExprKind::Call(ref f, args) => {
-                let ty = self.typeck_results.expr_ty(f);
-
-                if type_is_unsafe_function(self.cx, ty) {
-                    for arg in args {
-                        self.check_arg(arg);
-                    }
-                }
-            },
-            hir::ExprKind::MethodCall(_, _, args, _) => {
-                let def_id = self.typeck_results.type_dependent_def_id(expr.hir_id).unwrap();
-                let base_type = self.cx.tcx.type_of(def_id);
-
-                if type_is_unsafe_function(self.cx, base_type) {
-                    for arg in args {
-                        self.check_arg(arg);
-                    }
-                }
-            },
-            hir::ExprKind::Unary(hir::UnOp::Deref, ref ptr) => self.check_arg(ptr),
-            _ => (),
-        }
-
-        intravisit::walk_expr(self, expr);
-    }
-
-    fn nested_visit_map(&mut self) -> intravisit::NestedVisitorMap<Self::Map> {
-        intravisit::NestedVisitorMap::None
-    }
-}
-
-impl<'a, 'tcx> DerefVisitor<'a, 'tcx> {
-    fn check_arg(&self, ptr: &hir::Expr<'_>) {
-        if let Some(id) = path_to_local(ptr) {
-            if self.ptrs.contains(&id) {
-                span_lint(
-                    self.cx,
-                    NOT_UNSAFE_PTR_ARG_DEREF,
-                    ptr.span,
-                    "this public function dereferences a raw pointer but is not marked `unsafe`",
-                );
-            }
-        }
-    }
-}
-
-struct StaticMutVisitor<'a, 'tcx> {
-    cx: &'a LateContext<'tcx>,
-    mutates_static: bool,
-}
-
-impl<'a, 'tcx> intravisit::Visitor<'tcx> for StaticMutVisitor<'a, 'tcx> {
-    type Map = Map<'tcx>;
-
-    fn visit_expr(&mut self, expr: &'tcx hir::Expr<'_>) {
-        use hir::ExprKind::{AddrOf, Assign, AssignOp, Call, MethodCall};
-
-        if self.mutates_static {
-            return;
-        }
-        match expr.kind {
-            Call(_, args) | MethodCall(_, _, args, _) => {
-                let mut tys = FxHashSet::default();
-                for arg in args {
-                    if self.cx.tcx.has_typeck_results(arg.hir_id.owner.to_def_id())
-                        && is_mutable_ty(
-                            self.cx,
-                            self.cx.tcx.typeck(arg.hir_id.owner).expr_ty(arg),
-                            arg.span,
-                            &mut tys,
-                        )
-                        && is_mutated_static(arg)
-                    {
-                        self.mutates_static = true;
-                        return;
-                    }
-                    tys.clear();
-                }
-            },
-            Assign(ref target, ..) | AssignOp(_, ref target, _) | AddrOf(_, hir::Mutability::Mut, ref target) => {
-                self.mutates_static |= is_mutated_static(target)
-            },
-            _ => {},
-        }
-    }
-
-    fn nested_visit_map(&mut self) -> intravisit::NestedVisitorMap<Self::Map> {
-        intravisit::NestedVisitorMap::None
-    }
-}
-
-fn is_mutated_static(e: &hir::Expr<'_>) -> bool {
-    use hir::ExprKind::{Field, Index, Path};
-
-    match e.kind {
-        Path(QPath::Resolved(_, path)) => !matches!(path.res, Res::Local(_)),
-        Path(_) => true,
-        Field(ref inner, _) | Index(ref inner, _) => is_mutated_static(inner),
-        _ => false,
-    }
-}
-
-fn mutates_static<'tcx>(cx: &LateContext<'tcx>, body: &'tcx hir::Body<'_>) -> bool {
-    let mut v = StaticMutVisitor {
-        cx,
-        mutates_static: false,
-    };
-    intravisit::walk_expr(&mut v, &body.value);
-    v.mutates_static
-}
diff --git a/clippy_lints/src/functions/mod.rs b/clippy_lints/src/functions/mod.rs
new file mode 100644
index 00000000000..68badb87b22
--- /dev/null
+++ b/clippy_lints/src/functions/mod.rs
@@ -0,0 +1,713 @@
+mod too_many_arguments;
+
+use clippy_utils::diagnostics::{span_lint, span_lint_and_help, span_lint_and_then};
+use clippy_utils::source::{snippet, snippet_opt};
+use clippy_utils::ty::{is_must_use_ty, is_type_diagnostic_item, type_is_unsafe_function};
+use clippy_utils::{
+    attr_by_name, attrs::is_proc_macro, iter_input_pats, match_def_path, must_use_attr, path_to_local, return_ty,
+    trait_ref_of_method,
+};
+use if_chain::if_chain;
+use rustc_ast::ast::Attribute;
+use rustc_data_structures::fx::FxHashSet;
+use rustc_errors::Applicability;
+use rustc_hir as hir;
+use rustc_hir::intravisit;
+use rustc_hir::{def::Res, def_id::DefId, QPath};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_middle::hir::map::Map;
+use rustc_middle::lint::in_external_macro;
+use rustc_middle::ty::{self, Ty};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::{sym, Span};
+use rustc_typeck::hir_ty_to_ty;
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for functions with too many parameters.
+    ///
+    /// **Why is this bad?** Functions with lots of parameters are considered bad
+    /// style and reduce readability (“what does the 5th parameter mean?”). Consider
+    /// grouping some parameters into a new type.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// ```rust
+    /// # struct Color;
+    /// fn foo(x: u32, y: u32, name: &str, c: Color, w: f32, h: f32, a: f32, b: f32) {
+    ///     // ..
+    /// }
+    /// ```
+    pub TOO_MANY_ARGUMENTS,
+    complexity,
+    "functions with too many arguments"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for functions with a large amount of lines.
+    ///
+    /// **Why is this bad?** Functions with a lot of lines are harder to understand
+    /// due to having to look at a larger amount of code to understand what the
+    /// function is doing. Consider splitting the body of the function into
+    /// multiple functions.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// ```rust
+    /// fn im_too_long() {
+    ///     println!("");
+    ///     // ... 100 more LoC
+    ///     println!("");
+    /// }
+    /// ```
+    pub TOO_MANY_LINES,
+    pedantic,
+    "functions with too many lines"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for public functions that dereference raw pointer
+    /// arguments but are not marked unsafe.
+    ///
+    /// **Why is this bad?** The function should probably be marked `unsafe`, since
+    /// for an arbitrary raw pointer, there is no way of telling for sure if it is
+    /// valid.
+    ///
+    /// **Known problems:**
+    ///
+    /// * It does not check functions recursively so if the pointer is passed to a
+    /// private non-`unsafe` function which does the dereferencing, the lint won't
+    /// trigger.
+    /// * It only checks for arguments whose type are raw pointers, not raw pointers
+    /// got from an argument in some other way (`fn foo(bar: &[*const u8])` or
+    /// `some_argument.get_raw_ptr()`).
+    ///
+    /// **Example:**
+    /// ```rust,ignore
+    /// // Bad
+    /// pub fn foo(x: *const u8) {
+    ///     println!("{}", unsafe { *x });
+    /// }
+    ///
+    /// // Good
+    /// pub unsafe fn foo(x: *const u8) {
+    ///     println!("{}", unsafe { *x });
+    /// }
+    /// ```
+    pub NOT_UNSAFE_PTR_ARG_DEREF,
+    correctness,
+    "public functions dereferencing raw pointer arguments but not marked `unsafe`"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for a [`#[must_use]`] attribute on
+    /// unit-returning functions and methods.
+    ///
+    /// [`#[must_use]`]: https://doc.rust-lang.org/reference/attributes/diagnostics.html#the-must_use-attribute
+    ///
+    /// **Why is this bad?** Unit values are useless. The attribute is likely
+    /// a remnant of a refactoring that removed the return type.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Examples:**
+    /// ```rust
+    /// #[must_use]
+    /// fn useless() { }
+    /// ```
+    pub MUST_USE_UNIT,
+    style,
+    "`#[must_use]` attribute on a unit-returning function / method"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for a [`#[must_use]`] attribute without
+    /// further information on functions and methods that return a type already
+    /// marked as `#[must_use]`.
+    ///
+    /// [`#[must_use]`]: https://doc.rust-lang.org/reference/attributes/diagnostics.html#the-must_use-attribute
+    ///
+    /// **Why is this bad?** The attribute isn't needed. Not using the result
+    /// will already be reported. Alternatively, one can add some text to the
+    /// attribute to improve the lint message.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Examples:**
+    /// ```rust
+    /// #[must_use]
+    /// fn double_must_use() -> Result<(), ()> {
+    ///     unimplemented!();
+    /// }
+    /// ```
+    pub DOUBLE_MUST_USE,
+    style,
+    "`#[must_use]` attribute on a `#[must_use]`-returning function / method"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for public functions that have no
+    /// [`#[must_use]`] attribute, but return something not already marked
+    /// must-use, have no mutable arg and mutate no statics.
+    ///
+    /// [`#[must_use]`]: https://doc.rust-lang.org/reference/attributes/diagnostics.html#the-must_use-attribute
+    ///
+    /// **Why is this bad?** Not bad at all, this lint just shows places where
+    /// you could add the attribute.
+    ///
+    /// **Known problems:** The lint only checks the arguments for mutable
+    /// types without looking if they are actually changed. On the other hand,
+    /// it also ignores a broad range of potentially interesting side effects,
+    /// because we cannot decide whether the programmer intends the function to
+    /// be called for the side effect or the result. Expect many false
+    /// positives. At least we don't lint if the result type is unit or already
+    /// `#[must_use]`.
+    ///
+    /// **Examples:**
+    /// ```rust
+    /// // this could be annotated with `#[must_use]`.
+    /// fn id<T>(t: T) -> T { t }
+    /// ```
+    pub MUST_USE_CANDIDATE,
+    pedantic,
+    "function or method that could take a `#[must_use]` attribute"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for public functions that return a `Result`
+    /// with an `Err` type of `()`. It suggests using a custom type that
+    /// implements [`std::error::Error`].
+    ///
+    /// **Why is this bad?** Unit does not implement `Error` and carries no
+    /// further information about what went wrong.
+    ///
+    /// **Known problems:** Of course, this lint assumes that `Result` is used
+    /// for a fallible operation (which is after all the intended use). However
+    /// code may opt to (mis)use it as a basic two-variant-enum. In that case,
+    /// the suggestion is misguided, and the code should use a custom enum
+    /// instead.
+    ///
+    /// **Examples:**
+    /// ```rust
+    /// pub fn read_u8() -> Result<u8, ()> { Err(()) }
+    /// ```
+    /// should become
+    /// ```rust,should_panic
+    /// use std::fmt;
+    ///
+    /// #[derive(Debug)]
+    /// pub struct EndOfStream;
+    ///
+    /// impl fmt::Display for EndOfStream {
+    ///     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    ///         write!(f, "End of Stream")
+    ///     }
+    /// }
+    ///
+    /// impl std::error::Error for EndOfStream { }
+    ///
+    /// pub fn read_u8() -> Result<u8, EndOfStream> { Err(EndOfStream) }
+    ///# fn main() {
+    ///#     read_u8().unwrap();
+    ///# }
+    /// ```
+    ///
+    /// Note that there are crates that simplify creating the error type, e.g.
+    /// [`thiserror`](https://docs.rs/thiserror).
+    pub RESULT_UNIT_ERR,
+    style,
+    "public function returning `Result` with an `Err` type of `()`"
+}
+
+#[derive(Copy, Clone)]
+pub struct Functions {
+    too_many_arguments_threshold: u64,
+    too_many_lines_threshold: u64,
+}
+
+impl Functions {
+    pub fn new(too_many_arguments_threshold: u64, too_many_lines_threshold: u64) -> Self {
+        Self {
+            too_many_arguments_threshold,
+            too_many_lines_threshold,
+        }
+    }
+}
+
+impl_lint_pass!(Functions => [
+    TOO_MANY_ARGUMENTS,
+    TOO_MANY_LINES,
+    NOT_UNSAFE_PTR_ARG_DEREF,
+    MUST_USE_UNIT,
+    DOUBLE_MUST_USE,
+    MUST_USE_CANDIDATE,
+    RESULT_UNIT_ERR,
+]);
+
+impl<'tcx> LateLintPass<'tcx> for Functions {
+    fn check_fn(
+        &mut self,
+        cx: &LateContext<'tcx>,
+        kind: intravisit::FnKind<'tcx>,
+        decl: &'tcx hir::FnDecl<'_>,
+        body: &'tcx hir::Body<'_>,
+        span: Span,
+        hir_id: hir::HirId,
+    ) {
+        too_many_arguments::check_fn(cx, kind, decl, span, hir_id, self.too_many_arguments_threshold);
+
+        let unsafety = match kind {
+            intravisit::FnKind::ItemFn(_, _, hir::FnHeader { unsafety, .. }, _) => unsafety,
+            intravisit::FnKind::Method(_, sig, _) => sig.header.unsafety,
+            intravisit::FnKind::Closure => return,
+        };
+
+        Self::check_raw_ptr(cx, unsafety, decl, body, hir_id);
+        self.check_line_number(cx, span, body);
+    }
+
+    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) {
+        let attrs = cx.tcx.hir().attrs(item.hir_id());
+        let attr = must_use_attr(attrs);
+        if let hir::ItemKind::Fn(ref sig, ref _generics, ref body_id) = item.kind {
+            let is_public = cx.access_levels.is_exported(item.hir_id());
+            let fn_header_span = item.span.with_hi(sig.decl.output.span().hi());
+            if is_public {
+                check_result_unit_err(cx, &sig.decl, item.span, fn_header_span);
+            }
+            if let Some(attr) = attr {
+                check_needless_must_use(cx, &sig.decl, item.hir_id(), item.span, fn_header_span, attr);
+                return;
+            }
+            if is_public && !is_proc_macro(cx.sess(), attrs) && attr_by_name(attrs, "no_mangle").is_none() {
+                check_must_use_candidate(
+                    cx,
+                    &sig.decl,
+                    cx.tcx.hir().body(*body_id),
+                    item.span,
+                    item.hir_id(),
+                    item.span.with_hi(sig.decl.output.span().hi()),
+                    "this function could have a `#[must_use]` attribute",
+                );
+            }
+        }
+    }
+
+    fn check_impl_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::ImplItem<'_>) {
+        if let hir::ImplItemKind::Fn(ref sig, ref body_id) = item.kind {
+            let is_public = cx.access_levels.is_exported(item.hir_id());
+            let fn_header_span = item.span.with_hi(sig.decl.output.span().hi());
+            if is_public && trait_ref_of_method(cx, item.hir_id()).is_none() {
+                check_result_unit_err(cx, &sig.decl, item.span, fn_header_span);
+            }
+            let attrs = cx.tcx.hir().attrs(item.hir_id());
+            let attr = must_use_attr(attrs);
+            if let Some(attr) = attr {
+                check_needless_must_use(cx, &sig.decl, item.hir_id(), item.span, fn_header_span, attr);
+            } else if is_public && !is_proc_macro(cx.sess(), attrs) && trait_ref_of_method(cx, item.hir_id()).is_none()
+            {
+                check_must_use_candidate(
+                    cx,
+                    &sig.decl,
+                    cx.tcx.hir().body(*body_id),
+                    item.span,
+                    item.hir_id(),
+                    item.span.with_hi(sig.decl.output.span().hi()),
+                    "this method could have a `#[must_use]` attribute",
+                );
+            }
+        }
+    }
+
+    fn check_trait_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::TraitItem<'_>) {
+        too_many_arguments::check_trait_item(cx, item, self.too_many_arguments_threshold);
+
+        if let hir::TraitItemKind::Fn(ref sig, ref eid) = item.kind {
+            let is_public = cx.access_levels.is_exported(item.hir_id());
+            let fn_header_span = item.span.with_hi(sig.decl.output.span().hi());
+            if is_public {
+                check_result_unit_err(cx, &sig.decl, item.span, fn_header_span);
+            }
+
+            let attrs = cx.tcx.hir().attrs(item.hir_id());
+            let attr = must_use_attr(attrs);
+            if let Some(attr) = attr {
+                check_needless_must_use(cx, &sig.decl, item.hir_id(), item.span, fn_header_span, attr);
+            }
+            if let hir::TraitFn::Provided(eid) = *eid {
+                let body = cx.tcx.hir().body(eid);
+                Self::check_raw_ptr(cx, sig.header.unsafety, &sig.decl, body, item.hir_id());
+
+                if attr.is_none() && is_public && !is_proc_macro(cx.sess(), attrs) {
+                    check_must_use_candidate(
+                        cx,
+                        &sig.decl,
+                        body,
+                        item.span,
+                        item.hir_id(),
+                        item.span.with_hi(sig.decl.output.span().hi()),
+                        "this method could have a `#[must_use]` attribute",
+                    );
+                }
+            }
+        }
+    }
+}
+
+impl<'tcx> Functions {
+    fn check_line_number(self, cx: &LateContext<'_>, span: Span, body: &'tcx hir::Body<'_>) {
+        if in_external_macro(cx.sess(), span) {
+            return;
+        }
+
+        let code_snippet = snippet(cx, body.value.span, "..");
+        let mut line_count: u64 = 0;
+        let mut in_comment = false;
+        let mut code_in_line;
+
+        // Skip the surrounding function decl.
+        let start_brace_idx = code_snippet.find('{').map_or(0, |i| i + 1);
+        let end_brace_idx = code_snippet.rfind('}').unwrap_or_else(|| code_snippet.len());
+        let function_lines = code_snippet[start_brace_idx..end_brace_idx].lines();
+
+        for mut line in function_lines {
+            code_in_line = false;
+            loop {
+                line = line.trim_start();
+                if line.is_empty() {
+                    break;
+                }
+                if in_comment {
+                    if let Some(i) = line.find("*/") {
+                        line = &line[i + 2..];
+                        in_comment = false;
+                        continue;
+                    }
+                } else {
+                    let multi_idx = line.find("/*").unwrap_or_else(|| line.len());
+                    let single_idx = line.find("//").unwrap_or_else(|| line.len());
+                    code_in_line |= multi_idx > 0 && single_idx > 0;
+                    // Implies multi_idx is below line.len()
+                    if multi_idx < single_idx {
+                        line = &line[multi_idx + 2..];
+                        in_comment = true;
+                        continue;
+                    }
+                }
+                break;
+            }
+            if code_in_line {
+                line_count += 1;
+            }
+        }
+
+        if line_count > self.too_many_lines_threshold {
+            span_lint(
+                cx,
+                TOO_MANY_LINES,
+                span,
+                &format!(
+                    "this function has too many lines ({}/{})",
+                    line_count, self.too_many_lines_threshold
+                ),
+            )
+        }
+    }
+
+    fn check_raw_ptr(
+        cx: &LateContext<'tcx>,
+        unsafety: hir::Unsafety,
+        decl: &'tcx hir::FnDecl<'_>,
+        body: &'tcx hir::Body<'_>,
+        hir_id: hir::HirId,
+    ) {
+        let expr = &body.value;
+        if unsafety == hir::Unsafety::Normal && cx.access_levels.is_exported(hir_id) {
+            let raw_ptrs = iter_input_pats(decl, body)
+                .zip(decl.inputs.iter())
+                .filter_map(|(arg, ty)| raw_ptr_arg(arg, ty))
+                .collect::<FxHashSet<_>>();
+
+            if !raw_ptrs.is_empty() {
+                let typeck_results = cx.tcx.typeck_body(body.id());
+                let mut v = DerefVisitor {
+                    cx,
+                    ptrs: raw_ptrs,
+                    typeck_results,
+                };
+
+                intravisit::walk_expr(&mut v, expr);
+            }
+        }
+    }
+}
+
+fn check_result_unit_err(cx: &LateContext<'_>, decl: &hir::FnDecl<'_>, item_span: Span, fn_header_span: Span) {
+    if_chain! {
+        if !in_external_macro(cx.sess(), item_span);
+        if let hir::FnRetTy::Return(ref ty) = decl.output;
+        let ty = hir_ty_to_ty(cx.tcx, ty);
+        if is_type_diagnostic_item(cx, ty, sym::result_type);
+        if let ty::Adt(_, substs) = ty.kind();
+        let err_ty = substs.type_at(1);
+        if err_ty.is_unit();
+        then {
+            span_lint_and_help(
+                cx,
+                RESULT_UNIT_ERR,
+                fn_header_span,
+                "this returns a `Result<_, ()>",
+                None,
+                "use a custom Error type instead",
+            );
+        }
+    }
+}
+
+fn check_needless_must_use(
+    cx: &LateContext<'_>,
+    decl: &hir::FnDecl<'_>,
+    item_id: hir::HirId,
+    item_span: Span,
+    fn_header_span: Span,
+    attr: &Attribute,
+) {
+    if in_external_macro(cx.sess(), item_span) {
+        return;
+    }
+    if returns_unit(decl) {
+        span_lint_and_then(
+            cx,
+            MUST_USE_UNIT,
+            fn_header_span,
+            "this unit-returning function has a `#[must_use]` attribute",
+            |diag| {
+                diag.span_suggestion(
+                    attr.span,
+                    "remove the attribute",
+                    "".into(),
+                    Applicability::MachineApplicable,
+                );
+            },
+        );
+    } else if !attr.is_value_str() && is_must_use_ty(cx, return_ty(cx, item_id)) {
+        span_lint_and_help(
+            cx,
+            DOUBLE_MUST_USE,
+            fn_header_span,
+            "this function has an empty `#[must_use]` attribute, but returns a type already marked as `#[must_use]`",
+            None,
+            "either add some descriptive text or remove the attribute",
+        );
+    }
+}
+
+fn check_must_use_candidate<'tcx>(
+    cx: &LateContext<'tcx>,
+    decl: &'tcx hir::FnDecl<'_>,
+    body: &'tcx hir::Body<'_>,
+    item_span: Span,
+    item_id: hir::HirId,
+    fn_span: Span,
+    msg: &str,
+) {
+    if has_mutable_arg(cx, body)
+        || mutates_static(cx, body)
+        || in_external_macro(cx.sess(), item_span)
+        || returns_unit(decl)
+        || !cx.access_levels.is_exported(item_id)
+        || is_must_use_ty(cx, return_ty(cx, item_id))
+    {
+        return;
+    }
+    span_lint_and_then(cx, MUST_USE_CANDIDATE, fn_span, msg, |diag| {
+        if let Some(snippet) = snippet_opt(cx, fn_span) {
+            diag.span_suggestion(
+                fn_span,
+                "add the attribute",
+                format!("#[must_use] {}", snippet),
+                Applicability::MachineApplicable,
+            );
+        }
+    });
+}
+
+fn returns_unit(decl: &hir::FnDecl<'_>) -> bool {
+    match decl.output {
+        hir::FnRetTy::DefaultReturn(_) => true,
+        hir::FnRetTy::Return(ref ty) => match ty.kind {
+            hir::TyKind::Tup(ref tys) => tys.is_empty(),
+            hir::TyKind::Never => true,
+            _ => false,
+        },
+    }
+}
+
+fn has_mutable_arg(cx: &LateContext<'_>, body: &hir::Body<'_>) -> bool {
+    let mut tys = FxHashSet::default();
+    body.params.iter().any(|param| is_mutable_pat(cx, &param.pat, &mut tys))
+}
+
+fn is_mutable_pat(cx: &LateContext<'_>, pat: &hir::Pat<'_>, tys: &mut FxHashSet<DefId>) -> bool {
+    if let hir::PatKind::Wild = pat.kind {
+        return false; // ignore `_` patterns
+    }
+    if cx.tcx.has_typeck_results(pat.hir_id.owner.to_def_id()) {
+        is_mutable_ty(cx, &cx.tcx.typeck(pat.hir_id.owner).pat_ty(pat), pat.span, tys)
+    } else {
+        false
+    }
+}
+
+static KNOWN_WRAPPER_TYS: &[&[&str]] = &[&["alloc", "rc", "Rc"], &["std", "sync", "Arc"]];
+
+fn is_mutable_ty<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>, span: Span, tys: &mut FxHashSet<DefId>) -> bool {
+    match *ty.kind() {
+        // primitive types are never mutable
+        ty::Bool | ty::Char | ty::Int(_) | ty::Uint(_) | ty::Float(_) | ty::Str => false,
+        ty::Adt(ref adt, ref substs) => {
+            tys.insert(adt.did) && !ty.is_freeze(cx.tcx.at(span), cx.param_env)
+                || KNOWN_WRAPPER_TYS.iter().any(|path| match_def_path(cx, adt.did, path))
+                    && substs.types().any(|ty| is_mutable_ty(cx, ty, span, tys))
+        },
+        ty::Tuple(ref substs) => substs.types().any(|ty| is_mutable_ty(cx, ty, span, tys)),
+        ty::Array(ty, _) | ty::Slice(ty) => is_mutable_ty(cx, ty, span, tys),
+        ty::RawPtr(ty::TypeAndMut { ty, mutbl }) | ty::Ref(_, ty, mutbl) => {
+            mutbl == hir::Mutability::Mut || is_mutable_ty(cx, ty, span, tys)
+        },
+        // calling something constitutes a side effect, so return true on all callables
+        // also never calls need not be used, so return true for them, too
+        _ => true,
+    }
+}
+
+fn raw_ptr_arg(arg: &hir::Param<'_>, ty: &hir::Ty<'_>) -> Option<hir::HirId> {
+    if let (&hir::PatKind::Binding(_, id, _, _), &hir::TyKind::Ptr(_)) = (&arg.pat.kind, &ty.kind) {
+        Some(id)
+    } else {
+        None
+    }
+}
+
+struct DerefVisitor<'a, 'tcx> {
+    cx: &'a LateContext<'tcx>,
+    ptrs: FxHashSet<hir::HirId>,
+    typeck_results: &'a ty::TypeckResults<'tcx>,
+}
+
+impl<'a, 'tcx> intravisit::Visitor<'tcx> for DerefVisitor<'a, 'tcx> {
+    type Map = Map<'tcx>;
+
+    fn visit_expr(&mut self, expr: &'tcx hir::Expr<'_>) {
+        match expr.kind {
+            hir::ExprKind::Call(ref f, args) => {
+                let ty = self.typeck_results.expr_ty(f);
+
+                if type_is_unsafe_function(self.cx, ty) {
+                    for arg in args {
+                        self.check_arg(arg);
+                    }
+                }
+            },
+            hir::ExprKind::MethodCall(_, _, args, _) => {
+                let def_id = self.typeck_results.type_dependent_def_id(expr.hir_id).unwrap();
+                let base_type = self.cx.tcx.type_of(def_id);
+
+                if type_is_unsafe_function(self.cx, base_type) {
+                    for arg in args {
+                        self.check_arg(arg);
+                    }
+                }
+            },
+            hir::ExprKind::Unary(hir::UnOp::Deref, ref ptr) => self.check_arg(ptr),
+            _ => (),
+        }
+
+        intravisit::walk_expr(self, expr);
+    }
+
+    fn nested_visit_map(&mut self) -> intravisit::NestedVisitorMap<Self::Map> {
+        intravisit::NestedVisitorMap::None
+    }
+}
+
+impl<'a, 'tcx> DerefVisitor<'a, 'tcx> {
+    fn check_arg(&self, ptr: &hir::Expr<'_>) {
+        if let Some(id) = path_to_local(ptr) {
+            if self.ptrs.contains(&id) {
+                span_lint(
+                    self.cx,
+                    NOT_UNSAFE_PTR_ARG_DEREF,
+                    ptr.span,
+                    "this public function dereferences a raw pointer but is not marked `unsafe`",
+                );
+            }
+        }
+    }
+}
+
+struct StaticMutVisitor<'a, 'tcx> {
+    cx: &'a LateContext<'tcx>,
+    mutates_static: bool,
+}
+
+impl<'a, 'tcx> intravisit::Visitor<'tcx> for StaticMutVisitor<'a, 'tcx> {
+    type Map = Map<'tcx>;
+
+    fn visit_expr(&mut self, expr: &'tcx hir::Expr<'_>) {
+        use hir::ExprKind::{AddrOf, Assign, AssignOp, Call, MethodCall};
+
+        if self.mutates_static {
+            return;
+        }
+        match expr.kind {
+            Call(_, args) | MethodCall(_, _, args, _) => {
+                let mut tys = FxHashSet::default();
+                for arg in args {
+                    if self.cx.tcx.has_typeck_results(arg.hir_id.owner.to_def_id())
+                        && is_mutable_ty(
+                            self.cx,
+                            self.cx.tcx.typeck(arg.hir_id.owner).expr_ty(arg),
+                            arg.span,
+                            &mut tys,
+                        )
+                        && is_mutated_static(arg)
+                    {
+                        self.mutates_static = true;
+                        return;
+                    }
+                    tys.clear();
+                }
+            },
+            Assign(ref target, ..) | AssignOp(_, ref target, _) | AddrOf(_, hir::Mutability::Mut, ref target) => {
+                self.mutates_static |= is_mutated_static(target)
+            },
+            _ => {},
+        }
+    }
+
+    fn nested_visit_map(&mut self) -> intravisit::NestedVisitorMap<Self::Map> {
+        intravisit::NestedVisitorMap::None
+    }
+}
+
+fn is_mutated_static(e: &hir::Expr<'_>) -> bool {
+    use hir::ExprKind::{Field, Index, Path};
+
+    match e.kind {
+        Path(QPath::Resolved(_, path)) => !matches!(path.res, Res::Local(_)),
+        Path(_) => true,
+        Field(ref inner, _) | Index(ref inner, _) => is_mutated_static(inner),
+        _ => false,
+    }
+}
+
+fn mutates_static<'tcx>(cx: &LateContext<'tcx>, body: &'tcx hir::Body<'_>) -> bool {
+    let mut v = StaticMutVisitor {
+        cx,
+        mutates_static: false,
+    };
+    intravisit::walk_expr(&mut v, &body.value);
+    v.mutates_static
+}
diff --git a/clippy_lints/src/functions/too_many_arguments.rs b/clippy_lints/src/functions/too_many_arguments.rs
new file mode 100644
index 00000000000..62b1e6bd7ca
--- /dev/null
+++ b/clippy_lints/src/functions/too_many_arguments.rs
@@ -0,0 +1,73 @@
+use rustc_hir::{self as hir, intravisit};
+use rustc_lint::LateContext;
+use rustc_span::Span;
+use rustc_target::spec::abi::Abi;
+
+use clippy_utils::diagnostics::span_lint;
+use clippy_utils::is_trait_impl_item;
+
+use super::TOO_MANY_ARGUMENTS;
+
+pub(super) fn check_fn(
+    cx: &LateContext<'tcx>,
+    kind: intravisit::FnKind<'tcx>,
+    decl: &'tcx hir::FnDecl<'_>,
+    span: Span,
+    hir_id: hir::HirId,
+    too_many_arguments_threshold: u64,
+) {
+    // don't warn for implementations, it's not their fault
+    if !is_trait_impl_item(cx, hir_id) {
+        // don't lint extern functions decls, it's not their fault either
+        match kind {
+            intravisit::FnKind::Method(
+                _,
+                &hir::FnSig {
+                    header: hir::FnHeader { abi: Abi::Rust, .. },
+                    ..
+                },
+                _,
+            )
+            | intravisit::FnKind::ItemFn(_, _, hir::FnHeader { abi: Abi::Rust, .. }, _) => check_arg_number(
+                cx,
+                decl,
+                span.with_hi(decl.output.span().hi()),
+                too_many_arguments_threshold,
+            ),
+            _ => {},
+        }
+    }
+}
+
+pub(super) fn check_trait_item(
+    cx: &LateContext<'tcx>,
+    item: &'tcx hir::TraitItem<'_>,
+    too_many_arguments_threshold: u64,
+) {
+    if let hir::TraitItemKind::Fn(ref sig, _) = item.kind {
+        // don't lint extern functions decls, it's not their fault
+        if sig.header.abi == Abi::Rust {
+            check_arg_number(
+                cx,
+                &sig.decl,
+                item.span.with_hi(sig.decl.output.span().hi()),
+                too_many_arguments_threshold,
+            );
+        }
+    }
+}
+
+fn check_arg_number(cx: &LateContext<'_>, decl: &hir::FnDecl<'_>, fn_span: Span, too_many_arguments_threshold: u64) {
+    let args = decl.inputs.len() as u64;
+    if args > too_many_arguments_threshold {
+        span_lint(
+            cx,
+            TOO_MANY_ARGUMENTS,
+            fn_span,
+            &format!(
+                "this function has too many arguments ({}/{})",
+                args, too_many_arguments_threshold
+            ),
+        );
+    }
+}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index f013613119c..3d3e57f7d2f 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1124,9 +1124,9 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box new_without_default::NewWithoutDefault::default());
     let blacklisted_names = conf.blacklisted_names.iter().cloned().collect::<FxHashSet<_>>();
     store.register_late_pass(move || box blacklisted_name::BlacklistedName::new(blacklisted_names.clone()));
-    let too_many_arguments_threshold1 = conf.too_many_arguments_threshold;
-    let too_many_lines_threshold2 = conf.too_many_lines_threshold;
-    store.register_late_pass(move || box functions::Functions::new(too_many_arguments_threshold1, too_many_lines_threshold2));
+    let too_many_arguments_threshold = conf.too_many_arguments_threshold;
+    let too_many_lines_threshold = conf.too_many_lines_threshold;
+    store.register_late_pass(move || box functions::Functions::new(too_many_arguments_threshold, too_many_lines_threshold));
     let doc_valid_idents = conf.doc_valid_idents.iter().cloned().collect::<FxHashSet<_>>();
     store.register_late_pass(move || box doc::DocMarkdown::new(doc_valid_idents.clone()));
     store.register_late_pass(|| box neg_multiply::NegMultiply);
-- 
cgit 1.4.1-3-g733a5


From 7c028de05f7b6803c062e12ee09a41ea9007d1e1 Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Wed, 24 Mar 2021 23:20:31 +0900
Subject: Move too_many_lines to its own module

---
 clippy_lints/src/functions/mod.rs            | 64 ++------------------------
 clippy_lints/src/functions/too_many_lines.rs | 68 ++++++++++++++++++++++++++++
 2 files changed, 71 insertions(+), 61 deletions(-)
 create mode 100644 clippy_lints/src/functions/too_many_lines.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/functions/mod.rs b/clippy_lints/src/functions/mod.rs
index 68badb87b22..97d3623d919 100644
--- a/clippy_lints/src/functions/mod.rs
+++ b/clippy_lints/src/functions/mod.rs
@@ -1,7 +1,8 @@
 mod too_many_arguments;
+mod too_many_lines;
 
 use clippy_utils::diagnostics::{span_lint, span_lint_and_help, span_lint_and_then};
-use clippy_utils::source::{snippet, snippet_opt};
+use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::{is_must_use_ty, is_type_diagnostic_item, type_is_unsafe_function};
 use clippy_utils::{
     attr_by_name, attrs::is_proc_macro, iter_input_pats, match_def_path, must_use_attr, path_to_local, return_ty,
@@ -256,6 +257,7 @@ impl<'tcx> LateLintPass<'tcx> for Functions {
         hir_id: hir::HirId,
     ) {
         too_many_arguments::check_fn(cx, kind, decl, span, hir_id, self.too_many_arguments_threshold);
+        too_many_lines::check(cx, span, body, self.too_many_lines_threshold);
 
         let unsafety = match kind {
             intravisit::FnKind::ItemFn(_, _, hir::FnHeader { unsafety, .. }, _) => unsafety,
@@ -264,7 +266,6 @@ impl<'tcx> LateLintPass<'tcx> for Functions {
         };
 
         Self::check_raw_ptr(cx, unsafety, decl, body, hir_id);
-        self.check_line_number(cx, span, body);
     }
 
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) {
@@ -356,65 +357,6 @@ impl<'tcx> LateLintPass<'tcx> for Functions {
 }
 
 impl<'tcx> Functions {
-    fn check_line_number(self, cx: &LateContext<'_>, span: Span, body: &'tcx hir::Body<'_>) {
-        if in_external_macro(cx.sess(), span) {
-            return;
-        }
-
-        let code_snippet = snippet(cx, body.value.span, "..");
-        let mut line_count: u64 = 0;
-        let mut in_comment = false;
-        let mut code_in_line;
-
-        // Skip the surrounding function decl.
-        let start_brace_idx = code_snippet.find('{').map_or(0, |i| i + 1);
-        let end_brace_idx = code_snippet.rfind('}').unwrap_or_else(|| code_snippet.len());
-        let function_lines = code_snippet[start_brace_idx..end_brace_idx].lines();
-
-        for mut line in function_lines {
-            code_in_line = false;
-            loop {
-                line = line.trim_start();
-                if line.is_empty() {
-                    break;
-                }
-                if in_comment {
-                    if let Some(i) = line.find("*/") {
-                        line = &line[i + 2..];
-                        in_comment = false;
-                        continue;
-                    }
-                } else {
-                    let multi_idx = line.find("/*").unwrap_or_else(|| line.len());
-                    let single_idx = line.find("//").unwrap_or_else(|| line.len());
-                    code_in_line |= multi_idx > 0 && single_idx > 0;
-                    // Implies multi_idx is below line.len()
-                    if multi_idx < single_idx {
-                        line = &line[multi_idx + 2..];
-                        in_comment = true;
-                        continue;
-                    }
-                }
-                break;
-            }
-            if code_in_line {
-                line_count += 1;
-            }
-        }
-
-        if line_count > self.too_many_lines_threshold {
-            span_lint(
-                cx,
-                TOO_MANY_LINES,
-                span,
-                &format!(
-                    "this function has too many lines ({}/{})",
-                    line_count, self.too_many_lines_threshold
-                ),
-            )
-        }
-    }
-
     fn check_raw_ptr(
         cx: &LateContext<'tcx>,
         unsafety: hir::Unsafety,
diff --git a/clippy_lints/src/functions/too_many_lines.rs b/clippy_lints/src/functions/too_many_lines.rs
new file mode 100644
index 00000000000..99d5028befc
--- /dev/null
+++ b/clippy_lints/src/functions/too_many_lines.rs
@@ -0,0 +1,68 @@
+use rustc_hir as hir;
+use rustc_lint::{LateContext, LintContext};
+use rustc_middle::lint::in_external_macro;
+use rustc_span::Span;
+
+use clippy_utils::diagnostics::span_lint;
+use clippy_utils::source::snippet;
+
+use super::TOO_MANY_LINES;
+
+pub(super) fn check(cx: &LateContext<'_>, span: Span, body: &'tcx hir::Body<'_>, too_many_lines_threshold: u64) {
+    if in_external_macro(cx.sess(), span) {
+        return;
+    }
+
+    let code_snippet = snippet(cx, body.value.span, "..");
+    let mut line_count: u64 = 0;
+    let mut in_comment = false;
+    let mut code_in_line;
+
+    // Skip the surrounding function decl.
+    let start_brace_idx = code_snippet.find('{').map_or(0, |i| i + 1);
+    let end_brace_idx = code_snippet.rfind('}').unwrap_or_else(|| code_snippet.len());
+    let function_lines = code_snippet[start_brace_idx..end_brace_idx].lines();
+
+    for mut line in function_lines {
+        code_in_line = false;
+        loop {
+            line = line.trim_start();
+            if line.is_empty() {
+                break;
+            }
+            if in_comment {
+                if let Some(i) = line.find("*/") {
+                    line = &line[i + 2..];
+                    in_comment = false;
+                    continue;
+                }
+            } else {
+                let multi_idx = line.find("/*").unwrap_or_else(|| line.len());
+                let single_idx = line.find("//").unwrap_or_else(|| line.len());
+                code_in_line |= multi_idx > 0 && single_idx > 0;
+                // Implies multi_idx is below line.len()
+                if multi_idx < single_idx {
+                    line = &line[multi_idx + 2..];
+                    in_comment = true;
+                    continue;
+                }
+            }
+            break;
+        }
+        if code_in_line {
+            line_count += 1;
+        }
+    }
+
+    if line_count > too_many_lines_threshold {
+        span_lint(
+            cx,
+            TOO_MANY_LINES,
+            span,
+            &format!(
+                "this function has too many lines ({}/{})",
+                line_count, too_many_lines_threshold
+            ),
+        )
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 9782fc42852927428736f27f0496deece545f46c Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Sat, 27 Mar 2021 20:43:59 +0900
Subject: move not_unsafe_ptr_arg_deref to its own module

---
 clippy_lints/src/functions/mod.rs                  | 116 +------------------
 .../src/functions/not_unsafe_ptr_arg_deref.rs      | 125 +++++++++++++++++++++
 2 files changed, 131 insertions(+), 110 deletions(-)
 create mode 100644 clippy_lints/src/functions/not_unsafe_ptr_arg_deref.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/functions/mod.rs b/clippy_lints/src/functions/mod.rs
index 97d3623d919..f53edc1b3c7 100644
--- a/clippy_lints/src/functions/mod.rs
+++ b/clippy_lints/src/functions/mod.rs
@@ -1,13 +1,11 @@
+mod not_unsafe_ptr_arg_deref;
 mod too_many_arguments;
 mod too_many_lines;
 
-use clippy_utils::diagnostics::{span_lint, span_lint_and_help, span_lint_and_then};
+use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_then};
 use clippy_utils::source::snippet_opt;
-use clippy_utils::ty::{is_must_use_ty, is_type_diagnostic_item, type_is_unsafe_function};
-use clippy_utils::{
-    attr_by_name, attrs::is_proc_macro, iter_input_pats, match_def_path, must_use_attr, path_to_local, return_ty,
-    trait_ref_of_method,
-};
+use clippy_utils::ty::{is_must_use_ty, is_type_diagnostic_item};
+use clippy_utils::{attr_by_name, attrs::is_proc_macro, match_def_path, must_use_attr, return_ty, trait_ref_of_method};
 use if_chain::if_chain;
 use rustc_ast::ast::Attribute;
 use rustc_data_structures::fx::FxHashSet;
@@ -258,14 +256,7 @@ impl<'tcx> LateLintPass<'tcx> for Functions {
     ) {
         too_many_arguments::check_fn(cx, kind, decl, span, hir_id, self.too_many_arguments_threshold);
         too_many_lines::check(cx, span, body, self.too_many_lines_threshold);
-
-        let unsafety = match kind {
-            intravisit::FnKind::ItemFn(_, _, hir::FnHeader { unsafety, .. }, _) => unsafety,
-            intravisit::FnKind::Method(_, sig, _) => sig.header.unsafety,
-            intravisit::FnKind::Closure => return,
-        };
-
-        Self::check_raw_ptr(cx, unsafety, decl, body, hir_id);
+        not_unsafe_ptr_arg_deref::check_fn(cx, kind, decl, body, hir_id);
     }
 
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) {
@@ -323,6 +314,7 @@ impl<'tcx> LateLintPass<'tcx> for Functions {
 
     fn check_trait_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::TraitItem<'_>) {
         too_many_arguments::check_trait_item(cx, item, self.too_many_arguments_threshold);
+        not_unsafe_ptr_arg_deref::check_trait_item(cx, item);
 
         if let hir::TraitItemKind::Fn(ref sig, ref eid) = item.kind {
             let is_public = cx.access_levels.is_exported(item.hir_id());
@@ -338,8 +330,6 @@ impl<'tcx> LateLintPass<'tcx> for Functions {
             }
             if let hir::TraitFn::Provided(eid) = *eid {
                 let body = cx.tcx.hir().body(eid);
-                Self::check_raw_ptr(cx, sig.header.unsafety, &sig.decl, body, item.hir_id());
-
                 if attr.is_none() && is_public && !is_proc_macro(cx.sess(), attrs) {
                     check_must_use_candidate(
                         cx,
@@ -356,35 +346,6 @@ impl<'tcx> LateLintPass<'tcx> for Functions {
     }
 }
 
-impl<'tcx> Functions {
-    fn check_raw_ptr(
-        cx: &LateContext<'tcx>,
-        unsafety: hir::Unsafety,
-        decl: &'tcx hir::FnDecl<'_>,
-        body: &'tcx hir::Body<'_>,
-        hir_id: hir::HirId,
-    ) {
-        let expr = &body.value;
-        if unsafety == hir::Unsafety::Normal && cx.access_levels.is_exported(hir_id) {
-            let raw_ptrs = iter_input_pats(decl, body)
-                .zip(decl.inputs.iter())
-                .filter_map(|(arg, ty)| raw_ptr_arg(arg, ty))
-                .collect::<FxHashSet<_>>();
-
-            if !raw_ptrs.is_empty() {
-                let typeck_results = cx.tcx.typeck_body(body.id());
-                let mut v = DerefVisitor {
-                    cx,
-                    ptrs: raw_ptrs,
-                    typeck_results,
-                };
-
-                intravisit::walk_expr(&mut v, expr);
-            }
-        }
-    }
-}
-
 fn check_result_unit_err(cx: &LateContext<'_>, decl: &hir::FnDecl<'_>, item_span: Span, fn_header_span: Span) {
     if_chain! {
         if !in_external_macro(cx.sess(), item_span);
@@ -524,71 +485,6 @@ fn is_mutable_ty<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>, span: Span, tys: &m
     }
 }
 
-fn raw_ptr_arg(arg: &hir::Param<'_>, ty: &hir::Ty<'_>) -> Option<hir::HirId> {
-    if let (&hir::PatKind::Binding(_, id, _, _), &hir::TyKind::Ptr(_)) = (&arg.pat.kind, &ty.kind) {
-        Some(id)
-    } else {
-        None
-    }
-}
-
-struct DerefVisitor<'a, 'tcx> {
-    cx: &'a LateContext<'tcx>,
-    ptrs: FxHashSet<hir::HirId>,
-    typeck_results: &'a ty::TypeckResults<'tcx>,
-}
-
-impl<'a, 'tcx> intravisit::Visitor<'tcx> for DerefVisitor<'a, 'tcx> {
-    type Map = Map<'tcx>;
-
-    fn visit_expr(&mut self, expr: &'tcx hir::Expr<'_>) {
-        match expr.kind {
-            hir::ExprKind::Call(ref f, args) => {
-                let ty = self.typeck_results.expr_ty(f);
-
-                if type_is_unsafe_function(self.cx, ty) {
-                    for arg in args {
-                        self.check_arg(arg);
-                    }
-                }
-            },
-            hir::ExprKind::MethodCall(_, _, args, _) => {
-                let def_id = self.typeck_results.type_dependent_def_id(expr.hir_id).unwrap();
-                let base_type = self.cx.tcx.type_of(def_id);
-
-                if type_is_unsafe_function(self.cx, base_type) {
-                    for arg in args {
-                        self.check_arg(arg);
-                    }
-                }
-            },
-            hir::ExprKind::Unary(hir::UnOp::Deref, ref ptr) => self.check_arg(ptr),
-            _ => (),
-        }
-
-        intravisit::walk_expr(self, expr);
-    }
-
-    fn nested_visit_map(&mut self) -> intravisit::NestedVisitorMap<Self::Map> {
-        intravisit::NestedVisitorMap::None
-    }
-}
-
-impl<'a, 'tcx> DerefVisitor<'a, 'tcx> {
-    fn check_arg(&self, ptr: &hir::Expr<'_>) {
-        if let Some(id) = path_to_local(ptr) {
-            if self.ptrs.contains(&id) {
-                span_lint(
-                    self.cx,
-                    NOT_UNSAFE_PTR_ARG_DEREF,
-                    ptr.span,
-                    "this public function dereferences a raw pointer but is not marked `unsafe`",
-                );
-            }
-        }
-    }
-}
-
 struct StaticMutVisitor<'a, 'tcx> {
     cx: &'a LateContext<'tcx>,
     mutates_static: bool,
diff --git a/clippy_lints/src/functions/not_unsafe_ptr_arg_deref.rs b/clippy_lints/src/functions/not_unsafe_ptr_arg_deref.rs
new file mode 100644
index 00000000000..ac02b60a356
--- /dev/null
+++ b/clippy_lints/src/functions/not_unsafe_ptr_arg_deref.rs
@@ -0,0 +1,125 @@
+use rustc_data_structures::fx::FxHashSet;
+use rustc_hir::{self as hir, intravisit};
+use rustc_lint::LateContext;
+use rustc_middle::{hir::map::Map, ty};
+
+use clippy_utils::diagnostics::span_lint;
+use clippy_utils::ty::type_is_unsafe_function;
+use clippy_utils::{iter_input_pats, path_to_local};
+
+use super::NOT_UNSAFE_PTR_ARG_DEREF;
+
+pub(super) fn check_fn(
+    cx: &LateContext<'tcx>,
+    kind: intravisit::FnKind<'tcx>,
+    decl: &'tcx hir::FnDecl<'tcx>,
+    body: &'tcx hir::Body<'tcx>,
+    hir_id: hir::HirId,
+) {
+    let unsafety = match kind {
+        intravisit::FnKind::ItemFn(_, _, hir::FnHeader { unsafety, .. }, _) => unsafety,
+        intravisit::FnKind::Method(_, sig, _) => sig.header.unsafety,
+        intravisit::FnKind::Closure => return,
+    };
+
+    check_raw_ptr(cx, unsafety, decl, body, hir_id);
+}
+
+pub(super) fn check_trait_item(cx: &LateContext<'tcx>, item: &'tcx hir::TraitItem<'_>) {
+    if let hir::TraitItemKind::Fn(ref sig, hir::TraitFn::Provided(eid)) = item.kind {
+        let body = cx.tcx.hir().body(eid);
+        check_raw_ptr(cx, sig.header.unsafety, &sig.decl, body, item.hir_id());
+    }
+}
+
+fn check_raw_ptr(
+    cx: &LateContext<'tcx>,
+    unsafety: hir::Unsafety,
+    decl: &'tcx hir::FnDecl<'tcx>,
+    body: &'tcx hir::Body<'tcx>,
+    hir_id: hir::HirId,
+) {
+    let expr = &body.value;
+    if unsafety == hir::Unsafety::Normal && cx.access_levels.is_exported(hir_id) {
+        let raw_ptrs = iter_input_pats(decl, body)
+            .zip(decl.inputs.iter())
+            .filter_map(|(arg, ty)| raw_ptr_arg(arg, ty))
+            .collect::<FxHashSet<_>>();
+
+        if !raw_ptrs.is_empty() {
+            let typeck_results = cx.tcx.typeck_body(body.id());
+            let mut v = DerefVisitor {
+                cx,
+                ptrs: raw_ptrs,
+                typeck_results,
+            };
+
+            intravisit::walk_expr(&mut v, expr);
+        }
+    }
+}
+
+fn raw_ptr_arg(arg: &hir::Param<'_>, ty: &hir::Ty<'_>) -> Option<hir::HirId> {
+    if let (&hir::PatKind::Binding(_, id, _, _), &hir::TyKind::Ptr(_)) = (&arg.pat.kind, &ty.kind) {
+        Some(id)
+    } else {
+        None
+    }
+}
+
+struct DerefVisitor<'a, 'tcx> {
+    cx: &'a LateContext<'tcx>,
+    ptrs: FxHashSet<hir::HirId>,
+    typeck_results: &'a ty::TypeckResults<'tcx>,
+}
+
+impl<'a, 'tcx> intravisit::Visitor<'tcx> for DerefVisitor<'a, 'tcx> {
+    type Map = Map<'tcx>;
+
+    fn visit_expr(&mut self, expr: &'tcx hir::Expr<'_>) {
+        match expr.kind {
+            hir::ExprKind::Call(ref f, args) => {
+                let ty = self.typeck_results.expr_ty(f);
+
+                if type_is_unsafe_function(self.cx, ty) {
+                    for arg in args {
+                        self.check_arg(arg);
+                    }
+                }
+            },
+            hir::ExprKind::MethodCall(_, _, args, _) => {
+                let def_id = self.typeck_results.type_dependent_def_id(expr.hir_id).unwrap();
+                let base_type = self.cx.tcx.type_of(def_id);
+
+                if type_is_unsafe_function(self.cx, base_type) {
+                    for arg in args {
+                        self.check_arg(arg);
+                    }
+                }
+            },
+            hir::ExprKind::Unary(hir::UnOp::Deref, ref ptr) => self.check_arg(ptr),
+            _ => (),
+        }
+
+        intravisit::walk_expr(self, expr);
+    }
+
+    fn nested_visit_map(&mut self) -> intravisit::NestedVisitorMap<Self::Map> {
+        intravisit::NestedVisitorMap::None
+    }
+}
+
+impl<'a, 'tcx> DerefVisitor<'a, 'tcx> {
+    fn check_arg(&self, ptr: &hir::Expr<'_>) {
+        if let Some(id) = path_to_local(ptr) {
+            if self.ptrs.contains(&id) {
+                span_lint(
+                    self.cx,
+                    NOT_UNSAFE_PTR_ARG_DEREF,
+                    ptr.span,
+                    "this public function dereferences a raw pointer but is not marked `unsafe`",
+                );
+            }
+        }
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From c37916501db2c649f57d2cc0d84ee41db34094c4 Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Sat, 27 Mar 2021 22:41:55 +0900
Subject: Move lints related to must_use to their own module

---
 clippy_lints/src/functions/mod.rs      | 259 ++-----------------------------
 clippy_lints/src/functions/must_use.rs | 272 +++++++++++++++++++++++++++++++++
 2 files changed, 283 insertions(+), 248 deletions(-)
 create mode 100644 clippy_lints/src/functions/must_use.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/functions/mod.rs b/clippy_lints/src/functions/mod.rs
index f53edc1b3c7..a1f4a453608 100644
--- a/clippy_lints/src/functions/mod.rs
+++ b/clippy_lints/src/functions/mod.rs
@@ -1,22 +1,17 @@
+mod must_use;
 mod not_unsafe_ptr_arg_deref;
 mod too_many_arguments;
 mod too_many_lines;
 
-use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_then};
-use clippy_utils::source::snippet_opt;
-use clippy_utils::ty::{is_must_use_ty, is_type_diagnostic_item};
-use clippy_utils::{attr_by_name, attrs::is_proc_macro, match_def_path, must_use_attr, return_ty, trait_ref_of_method};
+use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::trait_ref_of_method;
+use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
-use rustc_ast::ast::Attribute;
-use rustc_data_structures::fx::FxHashSet;
-use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_hir::intravisit;
-use rustc_hir::{def::Res, def_id::DefId, QPath};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
-use rustc_middle::hir::map::Map;
 use rustc_middle::lint::in_external_macro;
-use rustc_middle::ty::{self, Ty};
+use rustc_middle::ty;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::{sym, Span};
 use rustc_typeck::hir_ty_to_ty;
@@ -260,88 +255,38 @@ impl<'tcx> LateLintPass<'tcx> for Functions {
     }
 
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) {
-        let attrs = cx.tcx.hir().attrs(item.hir_id());
-        let attr = must_use_attr(attrs);
-        if let hir::ItemKind::Fn(ref sig, ref _generics, ref body_id) = item.kind {
+        must_use::check_item(cx, item);
+        if let hir::ItemKind::Fn(ref sig, ref _generics, _) = item.kind {
             let is_public = cx.access_levels.is_exported(item.hir_id());
             let fn_header_span = item.span.with_hi(sig.decl.output.span().hi());
             if is_public {
                 check_result_unit_err(cx, &sig.decl, item.span, fn_header_span);
             }
-            if let Some(attr) = attr {
-                check_needless_must_use(cx, &sig.decl, item.hir_id(), item.span, fn_header_span, attr);
-                return;
-            }
-            if is_public && !is_proc_macro(cx.sess(), attrs) && attr_by_name(attrs, "no_mangle").is_none() {
-                check_must_use_candidate(
-                    cx,
-                    &sig.decl,
-                    cx.tcx.hir().body(*body_id),
-                    item.span,
-                    item.hir_id(),
-                    item.span.with_hi(sig.decl.output.span().hi()),
-                    "this function could have a `#[must_use]` attribute",
-                );
-            }
         }
     }
 
     fn check_impl_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::ImplItem<'_>) {
-        if let hir::ImplItemKind::Fn(ref sig, ref body_id) = item.kind {
+        must_use::check_impl_item(cx, item);
+        if let hir::ImplItemKind::Fn(ref sig, _) = item.kind {
             let is_public = cx.access_levels.is_exported(item.hir_id());
             let fn_header_span = item.span.with_hi(sig.decl.output.span().hi());
             if is_public && trait_ref_of_method(cx, item.hir_id()).is_none() {
                 check_result_unit_err(cx, &sig.decl, item.span, fn_header_span);
             }
-            let attrs = cx.tcx.hir().attrs(item.hir_id());
-            let attr = must_use_attr(attrs);
-            if let Some(attr) = attr {
-                check_needless_must_use(cx, &sig.decl, item.hir_id(), item.span, fn_header_span, attr);
-            } else if is_public && !is_proc_macro(cx.sess(), attrs) && trait_ref_of_method(cx, item.hir_id()).is_none()
-            {
-                check_must_use_candidate(
-                    cx,
-                    &sig.decl,
-                    cx.tcx.hir().body(*body_id),
-                    item.span,
-                    item.hir_id(),
-                    item.span.with_hi(sig.decl.output.span().hi()),
-                    "this method could have a `#[must_use]` attribute",
-                );
-            }
         }
     }
 
     fn check_trait_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::TraitItem<'_>) {
         too_many_arguments::check_trait_item(cx, item, self.too_many_arguments_threshold);
         not_unsafe_ptr_arg_deref::check_trait_item(cx, item);
+        must_use::check_trait_item(cx, item);
 
-        if let hir::TraitItemKind::Fn(ref sig, ref eid) = item.kind {
+        if let hir::TraitItemKind::Fn(ref sig, _) = item.kind {
             let is_public = cx.access_levels.is_exported(item.hir_id());
             let fn_header_span = item.span.with_hi(sig.decl.output.span().hi());
             if is_public {
                 check_result_unit_err(cx, &sig.decl, item.span, fn_header_span);
             }
-
-            let attrs = cx.tcx.hir().attrs(item.hir_id());
-            let attr = must_use_attr(attrs);
-            if let Some(attr) = attr {
-                check_needless_must_use(cx, &sig.decl, item.hir_id(), item.span, fn_header_span, attr);
-            }
-            if let hir::TraitFn::Provided(eid) = *eid {
-                let body = cx.tcx.hir().body(eid);
-                if attr.is_none() && is_public && !is_proc_macro(cx.sess(), attrs) {
-                    check_must_use_candidate(
-                        cx,
-                        &sig.decl,
-                        body,
-                        item.span,
-                        item.hir_id(),
-                        item.span.with_hi(sig.decl.output.span().hi()),
-                        "this method could have a `#[must_use]` attribute",
-                    );
-                }
-            }
         }
     }
 }
@@ -367,185 +312,3 @@ fn check_result_unit_err(cx: &LateContext<'_>, decl: &hir::FnDecl<'_>, item_span
         }
     }
 }
-
-fn check_needless_must_use(
-    cx: &LateContext<'_>,
-    decl: &hir::FnDecl<'_>,
-    item_id: hir::HirId,
-    item_span: Span,
-    fn_header_span: Span,
-    attr: &Attribute,
-) {
-    if in_external_macro(cx.sess(), item_span) {
-        return;
-    }
-    if returns_unit(decl) {
-        span_lint_and_then(
-            cx,
-            MUST_USE_UNIT,
-            fn_header_span,
-            "this unit-returning function has a `#[must_use]` attribute",
-            |diag| {
-                diag.span_suggestion(
-                    attr.span,
-                    "remove the attribute",
-                    "".into(),
-                    Applicability::MachineApplicable,
-                );
-            },
-        );
-    } else if !attr.is_value_str() && is_must_use_ty(cx, return_ty(cx, item_id)) {
-        span_lint_and_help(
-            cx,
-            DOUBLE_MUST_USE,
-            fn_header_span,
-            "this function has an empty `#[must_use]` attribute, but returns a type already marked as `#[must_use]`",
-            None,
-            "either add some descriptive text or remove the attribute",
-        );
-    }
-}
-
-fn check_must_use_candidate<'tcx>(
-    cx: &LateContext<'tcx>,
-    decl: &'tcx hir::FnDecl<'_>,
-    body: &'tcx hir::Body<'_>,
-    item_span: Span,
-    item_id: hir::HirId,
-    fn_span: Span,
-    msg: &str,
-) {
-    if has_mutable_arg(cx, body)
-        || mutates_static(cx, body)
-        || in_external_macro(cx.sess(), item_span)
-        || returns_unit(decl)
-        || !cx.access_levels.is_exported(item_id)
-        || is_must_use_ty(cx, return_ty(cx, item_id))
-    {
-        return;
-    }
-    span_lint_and_then(cx, MUST_USE_CANDIDATE, fn_span, msg, |diag| {
-        if let Some(snippet) = snippet_opt(cx, fn_span) {
-            diag.span_suggestion(
-                fn_span,
-                "add the attribute",
-                format!("#[must_use] {}", snippet),
-                Applicability::MachineApplicable,
-            );
-        }
-    });
-}
-
-fn returns_unit(decl: &hir::FnDecl<'_>) -> bool {
-    match decl.output {
-        hir::FnRetTy::DefaultReturn(_) => true,
-        hir::FnRetTy::Return(ref ty) => match ty.kind {
-            hir::TyKind::Tup(ref tys) => tys.is_empty(),
-            hir::TyKind::Never => true,
-            _ => false,
-        },
-    }
-}
-
-fn has_mutable_arg(cx: &LateContext<'_>, body: &hir::Body<'_>) -> bool {
-    let mut tys = FxHashSet::default();
-    body.params.iter().any(|param| is_mutable_pat(cx, &param.pat, &mut tys))
-}
-
-fn is_mutable_pat(cx: &LateContext<'_>, pat: &hir::Pat<'_>, tys: &mut FxHashSet<DefId>) -> bool {
-    if let hir::PatKind::Wild = pat.kind {
-        return false; // ignore `_` patterns
-    }
-    if cx.tcx.has_typeck_results(pat.hir_id.owner.to_def_id()) {
-        is_mutable_ty(cx, &cx.tcx.typeck(pat.hir_id.owner).pat_ty(pat), pat.span, tys)
-    } else {
-        false
-    }
-}
-
-static KNOWN_WRAPPER_TYS: &[&[&str]] = &[&["alloc", "rc", "Rc"], &["std", "sync", "Arc"]];
-
-fn is_mutable_ty<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>, span: Span, tys: &mut FxHashSet<DefId>) -> bool {
-    match *ty.kind() {
-        // primitive types are never mutable
-        ty::Bool | ty::Char | ty::Int(_) | ty::Uint(_) | ty::Float(_) | ty::Str => false,
-        ty::Adt(ref adt, ref substs) => {
-            tys.insert(adt.did) && !ty.is_freeze(cx.tcx.at(span), cx.param_env)
-                || KNOWN_WRAPPER_TYS.iter().any(|path| match_def_path(cx, adt.did, path))
-                    && substs.types().any(|ty| is_mutable_ty(cx, ty, span, tys))
-        },
-        ty::Tuple(ref substs) => substs.types().any(|ty| is_mutable_ty(cx, ty, span, tys)),
-        ty::Array(ty, _) | ty::Slice(ty) => is_mutable_ty(cx, ty, span, tys),
-        ty::RawPtr(ty::TypeAndMut { ty, mutbl }) | ty::Ref(_, ty, mutbl) => {
-            mutbl == hir::Mutability::Mut || is_mutable_ty(cx, ty, span, tys)
-        },
-        // calling something constitutes a side effect, so return true on all callables
-        // also never calls need not be used, so return true for them, too
-        _ => true,
-    }
-}
-
-struct StaticMutVisitor<'a, 'tcx> {
-    cx: &'a LateContext<'tcx>,
-    mutates_static: bool,
-}
-
-impl<'a, 'tcx> intravisit::Visitor<'tcx> for StaticMutVisitor<'a, 'tcx> {
-    type Map = Map<'tcx>;
-
-    fn visit_expr(&mut self, expr: &'tcx hir::Expr<'_>) {
-        use hir::ExprKind::{AddrOf, Assign, AssignOp, Call, MethodCall};
-
-        if self.mutates_static {
-            return;
-        }
-        match expr.kind {
-            Call(_, args) | MethodCall(_, _, args, _) => {
-                let mut tys = FxHashSet::default();
-                for arg in args {
-                    if self.cx.tcx.has_typeck_results(arg.hir_id.owner.to_def_id())
-                        && is_mutable_ty(
-                            self.cx,
-                            self.cx.tcx.typeck(arg.hir_id.owner).expr_ty(arg),
-                            arg.span,
-                            &mut tys,
-                        )
-                        && is_mutated_static(arg)
-                    {
-                        self.mutates_static = true;
-                        return;
-                    }
-                    tys.clear();
-                }
-            },
-            Assign(ref target, ..) | AssignOp(_, ref target, _) | AddrOf(_, hir::Mutability::Mut, ref target) => {
-                self.mutates_static |= is_mutated_static(target)
-            },
-            _ => {},
-        }
-    }
-
-    fn nested_visit_map(&mut self) -> intravisit::NestedVisitorMap<Self::Map> {
-        intravisit::NestedVisitorMap::None
-    }
-}
-
-fn is_mutated_static(e: &hir::Expr<'_>) -> bool {
-    use hir::ExprKind::{Field, Index, Path};
-
-    match e.kind {
-        Path(QPath::Resolved(_, path)) => !matches!(path.res, Res::Local(_)),
-        Path(_) => true,
-        Field(ref inner, _) | Index(ref inner, _) => is_mutated_static(inner),
-        _ => false,
-    }
-}
-
-fn mutates_static<'tcx>(cx: &LateContext<'tcx>, body: &'tcx hir::Body<'_>) -> bool {
-    let mut v = StaticMutVisitor {
-        cx,
-        mutates_static: false,
-    };
-    intravisit::walk_expr(&mut v, &body.value);
-    v.mutates_static
-}
diff --git a/clippy_lints/src/functions/must_use.rs b/clippy_lints/src/functions/must_use.rs
new file mode 100644
index 00000000000..3825699936f
--- /dev/null
+++ b/clippy_lints/src/functions/must_use.rs
@@ -0,0 +1,272 @@
+use rustc_ast::ast::Attribute;
+use rustc_data_structures::fx::FxHashSet;
+use rustc_errors::Applicability;
+use rustc_hir::{self as hir, def::Res, def_id::DefId, intravisit, QPath};
+use rustc_lint::{LateContext, LintContext};
+use rustc_middle::{
+    hir::map::Map,
+    lint::in_external_macro,
+    ty::{self, Ty},
+};
+use rustc_span::Span;
+
+use clippy_utils::attrs::is_proc_macro;
+use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_then};
+use clippy_utils::source::snippet_opt;
+use clippy_utils::ty::is_must_use_ty;
+use clippy_utils::{attr_by_name, match_def_path, must_use_attr, return_ty, trait_ref_of_method};
+
+use super::{DOUBLE_MUST_USE, MUST_USE_CANDIDATE, MUST_USE_UNIT};
+
+pub(super) fn check_item(cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) {
+    let attrs = cx.tcx.hir().attrs(item.hir_id());
+    let attr = must_use_attr(attrs);
+    if let hir::ItemKind::Fn(ref sig, ref _generics, ref body_id) = item.kind {
+        let is_public = cx.access_levels.is_exported(item.hir_id());
+        let fn_header_span = item.span.with_hi(sig.decl.output.span().hi());
+        if let Some(attr) = attr {
+            check_needless_must_use(cx, &sig.decl, item.hir_id(), item.span, fn_header_span, attr);
+            return;
+        } else if is_public && !is_proc_macro(cx.sess(), attrs) && attr_by_name(attrs, "no_mangle").is_none() {
+            check_must_use_candidate(
+                cx,
+                &sig.decl,
+                cx.tcx.hir().body(*body_id),
+                item.span,
+                item.hir_id(),
+                item.span.with_hi(sig.decl.output.span().hi()),
+                "this function could have a `#[must_use]` attribute",
+            );
+        }
+    }
+}
+
+pub(super) fn check_impl_item(cx: &LateContext<'tcx>, item: &'tcx hir::ImplItem<'_>) {
+    if let hir::ImplItemKind::Fn(ref sig, ref body_id) = item.kind {
+        let is_public = cx.access_levels.is_exported(item.hir_id());
+        let fn_header_span = item.span.with_hi(sig.decl.output.span().hi());
+        let attrs = cx.tcx.hir().attrs(item.hir_id());
+        let attr = must_use_attr(attrs);
+        if let Some(attr) = attr {
+            check_needless_must_use(cx, &sig.decl, item.hir_id(), item.span, fn_header_span, attr);
+        } else if is_public && !is_proc_macro(cx.sess(), attrs) && trait_ref_of_method(cx, item.hir_id()).is_none() {
+            check_must_use_candidate(
+                cx,
+                &sig.decl,
+                cx.tcx.hir().body(*body_id),
+                item.span,
+                item.hir_id(),
+                item.span.with_hi(sig.decl.output.span().hi()),
+                "this method could have a `#[must_use]` attribute",
+            );
+        }
+    }
+}
+
+pub(super) fn check_trait_item(cx: &LateContext<'tcx>, item: &'tcx hir::TraitItem<'_>) {
+    if let hir::TraitItemKind::Fn(ref sig, ref eid) = item.kind {
+        let is_public = cx.access_levels.is_exported(item.hir_id());
+        let fn_header_span = item.span.with_hi(sig.decl.output.span().hi());
+
+        let attrs = cx.tcx.hir().attrs(item.hir_id());
+        let attr = must_use_attr(attrs);
+        if let Some(attr) = attr {
+            check_needless_must_use(cx, &sig.decl, item.hir_id(), item.span, fn_header_span, attr);
+        } else if let hir::TraitFn::Provided(eid) = *eid {
+            let body = cx.tcx.hir().body(eid);
+            if attr.is_none() && is_public && !is_proc_macro(cx.sess(), attrs) {
+                check_must_use_candidate(
+                    cx,
+                    &sig.decl,
+                    body,
+                    item.span,
+                    item.hir_id(),
+                    item.span.with_hi(sig.decl.output.span().hi()),
+                    "this method could have a `#[must_use]` attribute",
+                );
+            }
+        }
+    }
+}
+
+fn check_needless_must_use(
+    cx: &LateContext<'_>,
+    decl: &hir::FnDecl<'_>,
+    item_id: hir::HirId,
+    item_span: Span,
+    fn_header_span: Span,
+    attr: &Attribute,
+) {
+    if in_external_macro(cx.sess(), item_span) {
+        return;
+    }
+    if returns_unit(decl) {
+        span_lint_and_then(
+            cx,
+            MUST_USE_UNIT,
+            fn_header_span,
+            "this unit-returning function has a `#[must_use]` attribute",
+            |diag| {
+                diag.span_suggestion(
+                    attr.span,
+                    "remove the attribute",
+                    "".into(),
+                    Applicability::MachineApplicable,
+                );
+            },
+        );
+    } else if !attr.is_value_str() && is_must_use_ty(cx, return_ty(cx, item_id)) {
+        span_lint_and_help(
+            cx,
+            DOUBLE_MUST_USE,
+            fn_header_span,
+            "this function has an empty `#[must_use]` attribute, but returns a type already marked as `#[must_use]`",
+            None,
+            "either add some descriptive text or remove the attribute",
+        );
+    }
+}
+
+fn check_must_use_candidate<'tcx>(
+    cx: &LateContext<'tcx>,
+    decl: &'tcx hir::FnDecl<'_>,
+    body: &'tcx hir::Body<'_>,
+    item_span: Span,
+    item_id: hir::HirId,
+    fn_span: Span,
+    msg: &str,
+) {
+    if has_mutable_arg(cx, body)
+        || mutates_static(cx, body)
+        || in_external_macro(cx.sess(), item_span)
+        || returns_unit(decl)
+        || !cx.access_levels.is_exported(item_id)
+        || is_must_use_ty(cx, return_ty(cx, item_id))
+    {
+        return;
+    }
+    span_lint_and_then(cx, MUST_USE_CANDIDATE, fn_span, msg, |diag| {
+        if let Some(snippet) = snippet_opt(cx, fn_span) {
+            diag.span_suggestion(
+                fn_span,
+                "add the attribute",
+                format!("#[must_use] {}", snippet),
+                Applicability::MachineApplicable,
+            );
+        }
+    });
+}
+
+fn returns_unit(decl: &hir::FnDecl<'_>) -> bool {
+    match decl.output {
+        hir::FnRetTy::DefaultReturn(_) => true,
+        hir::FnRetTy::Return(ref ty) => match ty.kind {
+            hir::TyKind::Tup(ref tys) => tys.is_empty(),
+            hir::TyKind::Never => true,
+            _ => false,
+        },
+    }
+}
+
+fn has_mutable_arg(cx: &LateContext<'_>, body: &hir::Body<'_>) -> bool {
+    let mut tys = FxHashSet::default();
+    body.params.iter().any(|param| is_mutable_pat(cx, &param.pat, &mut tys))
+}
+
+fn is_mutable_pat(cx: &LateContext<'_>, pat: &hir::Pat<'_>, tys: &mut FxHashSet<DefId>) -> bool {
+    if let hir::PatKind::Wild = pat.kind {
+        return false; // ignore `_` patterns
+    }
+    if cx.tcx.has_typeck_results(pat.hir_id.owner.to_def_id()) {
+        is_mutable_ty(cx, &cx.tcx.typeck(pat.hir_id.owner).pat_ty(pat), pat.span, tys)
+    } else {
+        false
+    }
+}
+
+static KNOWN_WRAPPER_TYS: &[&[&str]] = &[&["alloc", "rc", "Rc"], &["std", "sync", "Arc"]];
+
+fn is_mutable_ty<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>, span: Span, tys: &mut FxHashSet<DefId>) -> bool {
+    match *ty.kind() {
+        // primitive types are never mutable
+        ty::Bool | ty::Char | ty::Int(_) | ty::Uint(_) | ty::Float(_) | ty::Str => false,
+        ty::Adt(ref adt, ref substs) => {
+            tys.insert(adt.did) && !ty.is_freeze(cx.tcx.at(span), cx.param_env)
+                || KNOWN_WRAPPER_TYS.iter().any(|path| match_def_path(cx, adt.did, path))
+                    && substs.types().any(|ty| is_mutable_ty(cx, ty, span, tys))
+        },
+        ty::Tuple(ref substs) => substs.types().any(|ty| is_mutable_ty(cx, ty, span, tys)),
+        ty::Array(ty, _) | ty::Slice(ty) => is_mutable_ty(cx, ty, span, tys),
+        ty::RawPtr(ty::TypeAndMut { ty, mutbl }) | ty::Ref(_, ty, mutbl) => {
+            mutbl == hir::Mutability::Mut || is_mutable_ty(cx, ty, span, tys)
+        },
+        // calling something constitutes a side effect, so return true on all callables
+        // also never calls need not be used, so return true for them, too
+        _ => true,
+    }
+}
+
+struct StaticMutVisitor<'a, 'tcx> {
+    cx: &'a LateContext<'tcx>,
+    mutates_static: bool,
+}
+
+impl<'a, 'tcx> intravisit::Visitor<'tcx> for StaticMutVisitor<'a, 'tcx> {
+    type Map = Map<'tcx>;
+
+    fn visit_expr(&mut self, expr: &'tcx hir::Expr<'_>) {
+        use hir::ExprKind::{AddrOf, Assign, AssignOp, Call, MethodCall};
+
+        if self.mutates_static {
+            return;
+        }
+        match expr.kind {
+            Call(_, args) | MethodCall(_, _, args, _) => {
+                let mut tys = FxHashSet::default();
+                for arg in args {
+                    if self.cx.tcx.has_typeck_results(arg.hir_id.owner.to_def_id())
+                        && is_mutable_ty(
+                            self.cx,
+                            self.cx.tcx.typeck(arg.hir_id.owner).expr_ty(arg),
+                            arg.span,
+                            &mut tys,
+                        )
+                        && is_mutated_static(arg)
+                    {
+                        self.mutates_static = true;
+                        return;
+                    }
+                    tys.clear();
+                }
+            },
+            Assign(ref target, ..) | AssignOp(_, ref target, _) | AddrOf(_, hir::Mutability::Mut, ref target) => {
+                self.mutates_static |= is_mutated_static(target)
+            },
+            _ => {},
+        }
+    }
+
+    fn nested_visit_map(&mut self) -> intravisit::NestedVisitorMap<Self::Map> {
+        intravisit::NestedVisitorMap::None
+    }
+}
+
+fn is_mutated_static(e: &hir::Expr<'_>) -> bool {
+    use hir::ExprKind::{Field, Index, Path};
+
+    match e.kind {
+        Path(QPath::Resolved(_, path)) => !matches!(path.res, Res::Local(_)),
+        Path(_) => true,
+        Field(ref inner, _) | Index(ref inner, _) => is_mutated_static(inner),
+        _ => false,
+    }
+}
+
+fn mutates_static<'tcx>(cx: &LateContext<'tcx>, body: &'tcx hir::Body<'_>) -> bool {
+    let mut v = StaticMutVisitor {
+        cx,
+        mutates_static: false,
+    };
+    intravisit::walk_expr(&mut v, &body.value);
+    v.mutates_static
+}
-- 
cgit 1.4.1-3-g733a5


From add3e5094f83e7b36f7dfa0813be4c9d8d0706c1 Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Sat, 27 Mar 2021 22:48:25 +0900
Subject: Move result_unit_err to its own module

---
 clippy_lints/src/functions/mod.rs             | 61 +++----------------------
 clippy_lints/src/functions/result_unit_err.rs | 66 +++++++++++++++++++++++++++
 clippy_lints/src/functions/too_many_lines.rs  |  2 +-
 3 files changed, 74 insertions(+), 55 deletions(-)
 create mode 100644 clippy_lints/src/functions/result_unit_err.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/functions/mod.rs b/clippy_lints/src/functions/mod.rs
index a1f4a453608..4ba5166059f 100644
--- a/clippy_lints/src/functions/mod.rs
+++ b/clippy_lints/src/functions/mod.rs
@@ -1,20 +1,14 @@
 mod must_use;
 mod not_unsafe_ptr_arg_deref;
+mod result_unit_err;
 mod too_many_arguments;
 mod too_many_lines;
 
-use clippy_utils::diagnostics::span_lint_and_help;
-use clippy_utils::trait_ref_of_method;
-use clippy_utils::ty::is_type_diagnostic_item;
-use if_chain::if_chain;
 use rustc_hir as hir;
 use rustc_hir::intravisit;
-use rustc_lint::{LateContext, LateLintPass, LintContext};
-use rustc_middle::lint::in_external_macro;
-use rustc_middle::ty;
+use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::{sym, Span};
-use rustc_typeck::hir_ty_to_ty;
+use rustc_span::Span;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for functions with too many parameters.
@@ -250,65 +244,24 @@ impl<'tcx> LateLintPass<'tcx> for Functions {
         hir_id: hir::HirId,
     ) {
         too_many_arguments::check_fn(cx, kind, decl, span, hir_id, self.too_many_arguments_threshold);
-        too_many_lines::check(cx, span, body, self.too_many_lines_threshold);
+        too_many_lines::check_fn(cx, span, body, self.too_many_lines_threshold);
         not_unsafe_ptr_arg_deref::check_fn(cx, kind, decl, body, hir_id);
     }
 
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) {
         must_use::check_item(cx, item);
-        if let hir::ItemKind::Fn(ref sig, ref _generics, _) = item.kind {
-            let is_public = cx.access_levels.is_exported(item.hir_id());
-            let fn_header_span = item.span.with_hi(sig.decl.output.span().hi());
-            if is_public {
-                check_result_unit_err(cx, &sig.decl, item.span, fn_header_span);
-            }
-        }
+        result_unit_err::check_item(cx, item);
     }
 
     fn check_impl_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::ImplItem<'_>) {
         must_use::check_impl_item(cx, item);
-        if let hir::ImplItemKind::Fn(ref sig, _) = item.kind {
-            let is_public = cx.access_levels.is_exported(item.hir_id());
-            let fn_header_span = item.span.with_hi(sig.decl.output.span().hi());
-            if is_public && trait_ref_of_method(cx, item.hir_id()).is_none() {
-                check_result_unit_err(cx, &sig.decl, item.span, fn_header_span);
-            }
-        }
+        result_unit_err::check_impl_item(cx, item);
     }
 
     fn check_trait_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::TraitItem<'_>) {
         too_many_arguments::check_trait_item(cx, item, self.too_many_arguments_threshold);
         not_unsafe_ptr_arg_deref::check_trait_item(cx, item);
         must_use::check_trait_item(cx, item);
-
-        if let hir::TraitItemKind::Fn(ref sig, _) = item.kind {
-            let is_public = cx.access_levels.is_exported(item.hir_id());
-            let fn_header_span = item.span.with_hi(sig.decl.output.span().hi());
-            if is_public {
-                check_result_unit_err(cx, &sig.decl, item.span, fn_header_span);
-            }
-        }
-    }
-}
-
-fn check_result_unit_err(cx: &LateContext<'_>, decl: &hir::FnDecl<'_>, item_span: Span, fn_header_span: Span) {
-    if_chain! {
-        if !in_external_macro(cx.sess(), item_span);
-        if let hir::FnRetTy::Return(ref ty) = decl.output;
-        let ty = hir_ty_to_ty(cx.tcx, ty);
-        if is_type_diagnostic_item(cx, ty, sym::result_type);
-        if let ty::Adt(_, substs) = ty.kind();
-        let err_ty = substs.type_at(1);
-        if err_ty.is_unit();
-        then {
-            span_lint_and_help(
-                cx,
-                RESULT_UNIT_ERR,
-                fn_header_span,
-                "this returns a `Result<_, ()>",
-                None,
-                "use a custom Error type instead",
-            );
-        }
+        result_unit_err::check_trait_item(cx, item);
     }
 }
diff --git a/clippy_lints/src/functions/result_unit_err.rs b/clippy_lints/src/functions/result_unit_err.rs
new file mode 100644
index 00000000000..f71bfc690f6
--- /dev/null
+++ b/clippy_lints/src/functions/result_unit_err.rs
@@ -0,0 +1,66 @@
+use rustc_hir as hir;
+use rustc_lint::{LateContext, LintContext};
+use rustc_middle::lint::in_external_macro;
+use rustc_middle::ty;
+use rustc_span::{sym, Span};
+use rustc_typeck::hir_ty_to_ty;
+
+use if_chain::if_chain;
+
+use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::trait_ref_of_method;
+use clippy_utils::ty::is_type_diagnostic_item;
+
+use super::RESULT_UNIT_ERR;
+
+pub(super) fn check_item(cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) {
+    if let hir::ItemKind::Fn(ref sig, ref _generics, _) = item.kind {
+        let is_public = cx.access_levels.is_exported(item.hir_id());
+        let fn_header_span = item.span.with_hi(sig.decl.output.span().hi());
+        if is_public {
+            check_result_unit_err(cx, &sig.decl, item.span, fn_header_span);
+        }
+    }
+}
+
+pub(super) fn check_impl_item(cx: &LateContext<'tcx>, item: &'tcx hir::ImplItem<'_>) {
+    if let hir::ImplItemKind::Fn(ref sig, _) = item.kind {
+        let is_public = cx.access_levels.is_exported(item.hir_id());
+        let fn_header_span = item.span.with_hi(sig.decl.output.span().hi());
+        if is_public && trait_ref_of_method(cx, item.hir_id()).is_none() {
+            check_result_unit_err(cx, &sig.decl, item.span, fn_header_span);
+        }
+    }
+}
+
+pub(super) fn check_trait_item(cx: &LateContext<'tcx>, item: &'tcx hir::TraitItem<'_>) {
+    if let hir::TraitItemKind::Fn(ref sig, _) = item.kind {
+        let is_public = cx.access_levels.is_exported(item.hir_id());
+        let fn_header_span = item.span.with_hi(sig.decl.output.span().hi());
+        if is_public {
+            check_result_unit_err(cx, &sig.decl, item.span, fn_header_span);
+        }
+    }
+}
+
+fn check_result_unit_err(cx: &LateContext<'_>, decl: &hir::FnDecl<'_>, item_span: Span, fn_header_span: Span) {
+    if_chain! {
+        if !in_external_macro(cx.sess(), item_span);
+        if let hir::FnRetTy::Return(ref ty) = decl.output;
+        let ty = hir_ty_to_ty(cx.tcx, ty);
+        if is_type_diagnostic_item(cx, ty, sym::result_type);
+        if let ty::Adt(_, substs) = ty.kind();
+        let err_ty = substs.type_at(1);
+        if err_ty.is_unit();
+        then {
+            span_lint_and_help(
+                cx,
+                RESULT_UNIT_ERR,
+                fn_header_span,
+                "this returns a `Result<_, ()>",
+                None,
+                "use a custom Error type instead",
+            );
+        }
+    }
+}
diff --git a/clippy_lints/src/functions/too_many_lines.rs b/clippy_lints/src/functions/too_many_lines.rs
index 99d5028befc..aa5494d5a7d 100644
--- a/clippy_lints/src/functions/too_many_lines.rs
+++ b/clippy_lints/src/functions/too_many_lines.rs
@@ -8,7 +8,7 @@ use clippy_utils::source::snippet;
 
 use super::TOO_MANY_LINES;
 
-pub(super) fn check(cx: &LateContext<'_>, span: Span, body: &'tcx hir::Body<'_>, too_many_lines_threshold: u64) {
+pub(super) fn check_fn(cx: &LateContext<'_>, span: Span, body: &'tcx hir::Body<'_>, too_many_lines_threshold: u64) {
     if in_external_macro(cx.sess(), span) {
         return;
     }
-- 
cgit 1.4.1-3-g733a5


From e006c77d611e20692beb3f319b0fec8cb6f09dc3 Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Sun, 28 Mar 2021 00:04:44 +0100
Subject: redundant_pattern_matching: look inside Refs

look inside refs and detect if let &None = ...

Fixes https://github.com/rust-lang/rust-clippy/issues/5396

changelog:  redundant_pattern_matching: look inside Refs to fix FNs with "if let &None = .. "
---
 clippy_lints/src/matches.rs    |  8 +++++++-
 tests/ui/match_ref_pats.stderr | 16 +++++++++++++++-
 2 files changed, 22 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index 3680429fed7..425124b78f4 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -1723,7 +1723,13 @@ mod redundant_pattern_match {
         arms: &[Arm<'_>],
         keyword: &'static str,
     ) {
-        let good_method = match arms[0].pat.kind {
+        // also look inside refs
+        let mut kind = &arms[0].pat.kind;
+        // if we have &None for example, peel it so we can detect "if let None = x"
+        if let PatKind::Ref(inner, _mutability) = kind {
+            kind = &inner.kind;
+        }
+        let good_method = match kind {
             PatKind::TupleStruct(ref path, ref patterns, _) if patterns.len() == 1 => {
                 if let PatKind::Wild = patterns[0].kind {
                     if match_qpath(path, &paths::RESULT_OK) {
diff --git a/tests/ui/match_ref_pats.stderr b/tests/ui/match_ref_pats.stderr
index 52cb4a14b72..67474e65cde 100644
--- a/tests/ui/match_ref_pats.stderr
+++ b/tests/ui/match_ref_pats.stderr
@@ -46,6 +46,14 @@ LL |         Some(v) => println!("{:?}", v),
 LL |         None => println!("none"),
    |
 
+error: redundant pattern matching, consider using `is_none()`
+  --> $DIR/match_ref_pats.rs:35:12
+   |
+LL |     if let &None = a {
+   |     -------^^^^^---- help: try this: `if a.is_none()`
+   |
+   = note: `-D clippy::redundant-pattern-matching` implied by `-D warnings`
+
 error: you don't need to add `&` to all patterns
   --> $DIR/match_ref_pats.rs:35:5
    |
@@ -59,6 +67,12 @@ help: instead of prefixing all patterns with `&`, you can dereference the expres
 LL |     if let None = *a {
    |            ^^^^   ^^
 
+error: redundant pattern matching, consider using `is_none()`
+  --> $DIR/match_ref_pats.rs:40:12
+   |
+LL |     if let &None = &b {
+   |     -------^^^^^----- help: try this: `if b.is_none()`
+
 error: you don't need to add `&` to both the expression and the patterns
   --> $DIR/match_ref_pats.rs:40:5
    |
@@ -87,5 +101,5 @@ LL |         match *foo_variant!(0) {
 LL |             Foo::A => println!("A"),
    |
 
-error: aborting due to 6 previous errors
+error: aborting due to 8 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 1768efa33344022c550f3cfcd30ede168bcf3143 Mon Sep 17 00:00:00 2001
From: ThibsG <thibsg@pm.me>
Date: Sun, 14 Mar 2021 19:35:35 +0100
Subject: Fix FP in `single_component_path_imports` lint

---
 clippy_lints/src/lib.rs                            |  2 +-
 clippy_lints/src/single_component_path_imports.rs  | 90 ++++++++++++++++++----
 .../ui/single_component_path_imports_self_after.rs | 16 ++++
 .../single_component_path_imports_self_before.rs   | 17 ++++
 4 files changed, 109 insertions(+), 16 deletions(-)
 create mode 100644 tests/ui/single_component_path_imports_self_after.rs
 create mode 100644 tests/ui/single_component_path_imports_self_before.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index f013613119c..97557fefe3e 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1232,7 +1232,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_early_pass(|| box as_conversions::AsConversions);
     store.register_late_pass(|| box let_underscore::LetUnderscore);
     store.register_late_pass(|| box atomic_ordering::AtomicOrdering);
-    store.register_early_pass(|| box single_component_path_imports::SingleComponentPathImports);
+    store.register_early_pass(|| box single_component_path_imports::SingleComponentPathImports::default());
     let max_fn_params_bools = conf.max_fn_params_bools;
     let max_struct_bools = conf.max_struct_bools;
     store.register_early_pass(move || box excessive_bools::ExcessiveBools::new(max_struct_bools, max_fn_params_bools));
diff --git a/clippy_lints/src/single_component_path_imports.rs b/clippy_lints/src/single_component_path_imports.rs
index c9d72aabb6a..ee74ef97bcd 100644
--- a/clippy_lints/src/single_component_path_imports.rs
+++ b/clippy_lints/src/single_component_path_imports.rs
@@ -1,11 +1,13 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::in_macro;
 use if_chain::if_chain;
-use rustc_ast::{Item, ItemKind, UseTreeKind};
+use rustc_ast::{Crate, Item, ItemKind, UseTreeKind};
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::edition::Edition;
+use rustc_span::symbol::kw;
+use rustc_span::{Span, Symbol};
 
 declare_clippy_lint! {
     /// **What it does:** Checking for imports with single component use path.
@@ -35,29 +37,87 @@ declare_clippy_lint! {
     "imports with single component path are redundant"
 }
 
-declare_lint_pass!(SingleComponentPathImports => [SINGLE_COMPONENT_PATH_IMPORTS]);
+#[derive(Default)]
+pub struct SingleComponentPathImports {
+    /// keep track of imports reused with `self` keyword,
+    /// such as `self::crypto_hash` in the example below
+    ///
+    /// ```rust,ignore
+    /// use self::crypto_hash::{Algorithm, Hasher};
+    /// ```
+    imports_reused_with_self: Vec<Symbol>,
+    /// keep track of single use statements
+    /// such as `crypto_hash` in the example below
+    ///
+    /// ```rust,ignore
+    /// use crypto_hash;
+    /// ```
+    single_use_usages: Vec<(Symbol, Span)>,
+}
+
+impl_lint_pass!(SingleComponentPathImports => [SINGLE_COMPONENT_PATH_IMPORTS]);
 
 impl EarlyLintPass for SingleComponentPathImports {
-    fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {
-        if_chain! {
-            if !in_macro(item.span);
-            if cx.sess.opts.edition >= Edition::Edition2018;
-            if !item.vis.kind.is_pub();
-            if let ItemKind::Use(use_tree) = &item.kind;
-            if let segments = &use_tree.prefix.segments;
-            if segments.len() == 1;
-            if let UseTreeKind::Simple(None, _, _) = use_tree.kind;
-            then {
+    fn check_crate(&mut self, cx: &EarlyContext<'_>, krate: &Crate) {
+        if cx.sess.opts.edition < Edition::Edition2018 {
+            return;
+        }
+        for item in &krate.items {
+            self.track_uses(&item);
+        }
+        for single_use in &self.single_use_usages {
+            if !self.imports_reused_with_self.contains(&single_use.0) {
                 span_lint_and_sugg(
                     cx,
                     SINGLE_COMPONENT_PATH_IMPORTS,
-                    item.span,
+                    single_use.1,
                     "this import is redundant",
                     "remove it entirely",
                     String::new(),
-                    Applicability::MachineApplicable
+                    Applicability::MachineApplicable,
                 );
             }
         }
     }
 }
+
+impl SingleComponentPathImports {
+    fn track_uses(&mut self, item: &Item) {
+        if_chain! {
+            if !in_macro(item.span);
+            if !item.vis.kind.is_pub();
+            if let ItemKind::Use(use_tree) = &item.kind;
+            if let segments = &use_tree.prefix.segments;
+
+            then {
+                // keep track of `use some_module;` usages
+                if segments.len() == 1 {
+                    if let UseTreeKind::Simple(None, _, _) = use_tree.kind {
+                        let ident = &segments[0].ident;
+                        self.single_use_usages.push((ident.name, item.span));
+                    }
+                    return;
+                }
+
+                // keep track of `use self::some_module` usages
+                if segments[0].ident.name == kw::SelfLower {
+                    // simple case such as `use self::module::SomeStruct`
+                    if segments.len() > 1 {
+                        self.imports_reused_with_self.push(segments[1].ident.name);
+                        return;
+                    }
+
+                    // nested case such as `use self::{module1::Struct1, module2::Struct2}`
+                    if let UseTreeKind::Nested(trees) = &use_tree.kind {
+                        for tree in trees {
+                            let segments = &tree.0.prefix.segments;
+                            if !segments.is_empty() {
+                                self.imports_reused_with_self.push(segments[0].ident.name);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/tests/ui/single_component_path_imports_self_after.rs b/tests/ui/single_component_path_imports_self_after.rs
new file mode 100644
index 00000000000..94319ade0ac
--- /dev/null
+++ b/tests/ui/single_component_path_imports_self_after.rs
@@ -0,0 +1,16 @@
+// edition:2018
+#![warn(clippy::single_component_path_imports)]
+#![allow(unused_imports)]
+
+use self::regex::{Regex as xeger, RegexSet as tesxeger};
+pub use self::{
+    regex::{Regex, RegexSet},
+    some_mod::SomeType,
+};
+use regex;
+
+mod some_mod {
+    pub struct SomeType;
+}
+
+fn main() {}
diff --git a/tests/ui/single_component_path_imports_self_before.rs b/tests/ui/single_component_path_imports_self_before.rs
new file mode 100644
index 00000000000..c7437b23456
--- /dev/null
+++ b/tests/ui/single_component_path_imports_self_before.rs
@@ -0,0 +1,17 @@
+// edition:2018
+#![warn(clippy::single_component_path_imports)]
+#![allow(unused_imports)]
+
+use regex;
+
+use self::regex::{Regex as xeger, RegexSet as tesxeger};
+pub use self::{
+    regex::{Regex, RegexSet},
+    some_mod::SomeType,
+};
+
+mod some_mod {
+    pub struct SomeType;
+}
+
+fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 6985d13a9783bb7181b6c43e83465e7630e48ec2 Mon Sep 17 00:00:00 2001
From: ThibsG <thibsg@pm.me>
Date: Sun, 28 Mar 2021 09:35:44 +0200
Subject: Take into account sub modules

---
 clippy_lints/src/single_component_path_imports.rs | 24 ++++++++++++++---------
 tests/ui/single_component_path_imports.fixed      |  6 ++++++
 tests/ui/single_component_path_imports.rs         |  6 ++++++
 tests/ui/single_component_path_imports.stderr     |  8 +++++++-
 4 files changed, 34 insertions(+), 10 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/single_component_path_imports.rs b/clippy_lints/src/single_component_path_imports.rs
index ee74ef97bcd..901f7642a12 100644
--- a/clippy_lints/src/single_component_path_imports.rs
+++ b/clippy_lints/src/single_component_path_imports.rs
@@ -1,7 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::in_macro;
-use if_chain::if_chain;
-use rustc_ast::{Crate, Item, ItemKind, UseTreeKind};
+use rustc_ast::{Crate, Item, ItemKind, ModKind, UseTreeKind};
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
@@ -83,13 +82,19 @@ impl EarlyLintPass for SingleComponentPathImports {
 
 impl SingleComponentPathImports {
     fn track_uses(&mut self, item: &Item) {
-        if_chain! {
-            if !in_macro(item.span);
-            if !item.vis.kind.is_pub();
-            if let ItemKind::Use(use_tree) = &item.kind;
-            if let segments = &use_tree.prefix.segments;
+        if in_macro(item.span) || item.vis.kind.is_pub() {
+            return;
+        }
+
+        match &item.kind {
+            ItemKind::Mod(_, ModKind::Loaded(ref items, ..)) => {
+                for item in items.iter() {
+                    self.track_uses(&item);
+                }
+            },
+            ItemKind::Use(use_tree) => {
+                let segments = &use_tree.prefix.segments;
 
-            then {
                 // keep track of `use some_module;` usages
                 if segments.len() == 1 {
                     if let UseTreeKind::Simple(None, _, _) = use_tree.kind {
@@ -117,7 +122,8 @@ impl SingleComponentPathImports {
                         }
                     }
                 }
-            }
+            },
+            _ => {},
         }
     }
 }
diff --git a/tests/ui/single_component_path_imports.fixed b/tests/ui/single_component_path_imports.fixed
index a7a8499b58f..226d2b315d7 100644
--- a/tests/ui/single_component_path_imports.fixed
+++ b/tests/ui/single_component_path_imports.fixed
@@ -19,3 +19,9 @@ fn main() {
     // False positive #5154, shouldn't trigger lint.
     m!();
 }
+
+mod hello_mod {
+    
+    #[allow(dead_code)]
+    fn hello_mod() {}
+}
diff --git a/tests/ui/single_component_path_imports.rs b/tests/ui/single_component_path_imports.rs
index 9a427e90ad3..88bf7f1fc5a 100644
--- a/tests/ui/single_component_path_imports.rs
+++ b/tests/ui/single_component_path_imports.rs
@@ -19,3 +19,9 @@ fn main() {
     // False positive #5154, shouldn't trigger lint.
     m!();
 }
+
+mod hello_mod {
+    use regex;
+    #[allow(dead_code)]
+    fn hello_mod() {}
+}
diff --git a/tests/ui/single_component_path_imports.stderr b/tests/ui/single_component_path_imports.stderr
index 519ada0169a..646e6d3647a 100644
--- a/tests/ui/single_component_path_imports.stderr
+++ b/tests/ui/single_component_path_imports.stderr
@@ -6,5 +6,11 @@ LL | use regex;
    |
    = note: `-D clippy::single-component-path-imports` implied by `-D warnings`
 
-error: aborting due to previous error
+error: this import is redundant
+  --> $DIR/single_component_path_imports.rs:24:5
+   |
+LL |     use regex;
+   |     ^^^^^^^^^^ help: remove it entirely
+
+error: aborting due to 2 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 879fa5c9721c89c27be6a9db5f51d935a51f549b Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sat, 27 Mar 2021 21:48:10 -0400
Subject: Improve `expl_impl_clone_on_copy` Check to see if the generic
 constraints are the same as if using derive

---
 clippy_lints/src/derive.rs | 87 ++++++++++++++++++++++++----------------------
 tests/ui/derive.rs         | 21 +++++++++--
 tests/ui/derive.stderr     | 30 +++++++++++++---
 3 files changed, 89 insertions(+), 49 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/derive.rs b/clippy_lints/src/derive.rs
index 834136f910d..9fad85f8ef4 100644
--- a/clippy_lints/src/derive.rs
+++ b/clippy_lints/src/derive.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_note, span_lint_and_then};
 use clippy_utils::paths;
-use clippy_utils::ty::is_copy;
+use clippy_utils::ty::{implements_trait, is_copy};
 use clippy_utils::{get_trait_def_id, is_allowed, is_automatically_derived, match_def_path};
 use if_chain::if_chain;
 use rustc_hir::def_id::DefId;
@@ -12,7 +12,7 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::map::Map;
 use rustc_middle::ty::{self, Ty};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::source_map::Span;
+use rustc_span::{def_id::LOCAL_CRATE, source_map::Span};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for deriving `Hash` but implementing `PartialEq`
@@ -293,48 +293,53 @@ fn check_ord_partial_ord<'tcx>(
 
 /// Implementation of the `EXPL_IMPL_CLONE_ON_COPY` lint.
 fn check_copy_clone<'tcx>(cx: &LateContext<'tcx>, item: &Item<'_>, trait_ref: &TraitRef<'_>, ty: Ty<'tcx>) {
-    if cx
-        .tcx
-        .lang_items()
-        .clone_trait()
-        .map_or(false, |id| Some(id) == trait_ref.trait_def_id())
-    {
-        if !is_copy(cx, ty) {
+    let clone_id = match cx.tcx.lang_items().clone_trait() {
+        Some(id) if trait_ref.trait_def_id() == Some(id) => id,
+        _ => return,
+    };
+    let copy_id = match cx.tcx.lang_items().copy_trait() {
+        Some(id) => id,
+        None => return,
+    };
+    let (ty_adt, ty_subs) = match *ty.kind() {
+        // Unions can't derive clone.
+        ty::Adt(adt, subs) if !adt.is_union() => (adt, subs),
+        _ => return,
+    };
+    // If the current self type doesn't implement Copy (due to generic constraints), search to see if
+    // there's a Copy impl for any instance of the adt.
+    if !is_copy(cx, ty) {
+        if ty_subs.non_erasable_generics().next().is_some() {
+            let has_copy_impl = cx
+                .tcx
+                .all_local_trait_impls(LOCAL_CRATE)
+                .get(&copy_id)
+                .map_or(false, |impls| {
+                    impls
+                        .iter()
+                        .any(|&id| matches!(cx.tcx.type_of(id).kind(), ty::Adt(adt, _) if ty_adt.did == adt.did))
+                });
+            if !has_copy_impl {
+                return;
+            }
+        } else {
             return;
         }
-
-        match *ty.kind() {
-            ty::Adt(def, _) if def.is_union() => return,
-
-            // Some types are not Clone by default but could be cloned “by hand” if necessary
-            ty::Adt(def, substs) => {
-                for variant in &def.variants {
-                    for field in &variant.fields {
-                        if let ty::FnDef(..) = field.ty(cx.tcx, substs).kind() {
-                            return;
-                        }
-                    }
-                    for subst in substs {
-                        if let ty::subst::GenericArgKind::Type(subst) = subst.unpack() {
-                            if let ty::Param(_) = subst.kind() {
-                                return;
-                            }
-                        }
-                    }
-                }
-            },
-            _ => (),
-        }
-
-        span_lint_and_note(
-            cx,
-            EXPL_IMPL_CLONE_ON_COPY,
-            item.span,
-            "you are implementing `Clone` explicitly on a `Copy` type",
-            Some(item.span),
-            "consider deriving `Clone` or removing `Copy`",
-        );
     }
+    // Derive constrains all generic types to requiring Clone. Check if any type is not constrained for
+    // this impl.
+    if ty_subs.types().any(|ty| !implements_trait(cx, ty, clone_id, &[])) {
+        return;
+    }
+
+    span_lint_and_note(
+        cx,
+        EXPL_IMPL_CLONE_ON_COPY,
+        item.span,
+        "you are implementing `Clone` explicitly on a `Copy` type",
+        Some(item.span),
+        "consider deriving `Clone` or removing `Copy`",
+    );
 }
 
 /// Implementation of the `UNSAFE_DERIVE_DESERIALIZE` lint.
diff --git a/tests/ui/derive.rs b/tests/ui/derive.rs
index 8fcb0e8b28d..4e46bf13991 100644
--- a/tests/ui/derive.rs
+++ b/tests/ui/derive.rs
@@ -35,7 +35,6 @@ impl<'a> Clone for Lt<'a> {
     }
 }
 
-// Ok, `Clone` cannot be derived because of the big array
 #[derive(Copy)]
 struct BigArray {
     a: [u8; 65],
@@ -47,7 +46,6 @@ impl Clone for BigArray {
     }
 }
 
-// Ok, function pointers are not always Clone
 #[derive(Copy)]
 struct FnPtr {
     a: fn() -> !,
@@ -59,7 +57,7 @@ impl Clone for FnPtr {
     }
 }
 
-// Ok, generics
+// Ok, Clone trait impl doesn't have constrained generics.
 #[derive(Copy)]
 struct Generic<T> {
     a: T,
@@ -71,4 +69,21 @@ impl<T> Clone for Generic<T> {
     }
 }
 
+#[derive(Copy)]
+struct Generic2<T>(T);
+impl<T: Clone> Clone for Generic2<T> {
+    fn clone(&self) -> Self {
+        Self(self.0.clone())
+    }
+}
+
+// Ok, Clone trait impl doesn't have constrained generics.
+#[derive(Copy)]
+struct GenericRef<'a, T, U>(T, &'a U);
+impl<T: Clone, U> Clone for GenericRef<'_, T, U> {
+    fn clone(&self) -> Self {
+        Self(self.0.clone(), self.1)
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/derive.stderr b/tests/ui/derive.stderr
index 1328a9b3107..82a70ceecc3 100644
--- a/tests/ui/derive.stderr
+++ b/tests/ui/derive.stderr
@@ -40,7 +40,7 @@ LL | | }
    | |_^
 
 error: you are implementing `Clone` explicitly on a `Copy` type
-  --> $DIR/derive.rs:44:1
+  --> $DIR/derive.rs:43:1
    |
 LL | / impl Clone for BigArray {
 LL | |     fn clone(&self) -> Self {
@@ -50,7 +50,7 @@ LL | | }
    | |_^
    |
 note: consider deriving `Clone` or removing `Copy`
-  --> $DIR/derive.rs:44:1
+  --> $DIR/derive.rs:43:1
    |
 LL | / impl Clone for BigArray {
 LL | |     fn clone(&self) -> Self {
@@ -60,7 +60,7 @@ LL | | }
    | |_^
 
 error: you are implementing `Clone` explicitly on a `Copy` type
-  --> $DIR/derive.rs:56:1
+  --> $DIR/derive.rs:54:1
    |
 LL | / impl Clone for FnPtr {
 LL | |     fn clone(&self) -> Self {
@@ -70,7 +70,7 @@ LL | | }
    | |_^
    |
 note: consider deriving `Clone` or removing `Copy`
-  --> $DIR/derive.rs:56:1
+  --> $DIR/derive.rs:54:1
    |
 LL | / impl Clone for FnPtr {
 LL | |     fn clone(&self) -> Self {
@@ -79,5 +79,25 @@ LL | |     }
 LL | | }
    | |_^
 
-error: aborting due to 4 previous errors
+error: you are implementing `Clone` explicitly on a `Copy` type
+  --> $DIR/derive.rs:74:1
+   |
+LL | / impl<T: Clone> Clone for Generic2<T> {
+LL | |     fn clone(&self) -> Self {
+LL | |         Self(self.0.clone())
+LL | |     }
+LL | | }
+   | |_^
+   |
+note: consider deriving `Clone` or removing `Copy`
+  --> $DIR/derive.rs:74:1
+   |
+LL | / impl<T: Clone> Clone for Generic2<T> {
+LL | |     fn clone(&self) -> Self {
+LL | |         Self(self.0.clone())
+LL | |     }
+LL | | }
+   | |_^
+
+error: aborting due to 5 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 31afdfc12bbe1bd2681ac17bfb07134ffd3cf061 Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Mon, 29 Mar 2021 17:19:05 +0900
Subject: missing_panics_doc: Ignore usage of debug_assert family

---
 clippy_lints/src/doc.rs        | 6 ++++++
 tests/ui/missing_panics_doc.rs | 8 ++++++++
 2 files changed, 14 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/doc.rs b/clippy_lints/src/doc.rs
index 14338ac8faf..69800f9d331 100644
--- a/clippy_lints/src/doc.rs
+++ b/clippy_lints/src/doc.rs
@@ -715,6 +715,7 @@ impl<'a, 'tcx> Visitor<'tcx> for FindPanicUnwrap<'a, 'tcx> {
             if let Some(path_def_id) = path.res.opt_def_id();
             if match_panic_def_id(self.cx, path_def_id);
             if is_expn_of(expr.span, "unreachable").is_none();
+            if !is_expn_of_debug_assertions(expr.span);
             then {
                 self.panic_span = Some(expr.span);
             }
@@ -738,3 +739,8 @@ impl<'a, 'tcx> Visitor<'tcx> for FindPanicUnwrap<'a, 'tcx> {
         NestedVisitorMap::OnlyBodies(self.cx.tcx.hir())
     }
 }
+
+fn is_expn_of_debug_assertions(span: Span) -> bool {
+    const MACRO_NAMES: &[&str] = &["debug_assert", "debug_assert_eq", "debug_assert_ne"];
+    MACRO_NAMES.iter().any(|name| is_expn_of(span, name).is_some())
+}
diff --git a/tests/ui/missing_panics_doc.rs b/tests/ui/missing_panics_doc.rs
index 17e72353f80..3fe35c75799 100644
--- a/tests/ui/missing_panics_doc.rs
+++ b/tests/ui/missing_panics_doc.rs
@@ -112,3 +112,11 @@ fn inner_body_private(opt: Option<u32>) {
 pub fn unreachable() {
     unreachable!("This function panics")
 }
+
+/// #6970.
+/// This is okay because it is expansion of `debug_assert` family.
+pub fn debug_assertions() {
+    debug_assert!(false);
+    debug_assert_eq!(1, 2);
+    debug_assert_ne!(1, 2);
+}
-- 
cgit 1.4.1-3-g733a5


From d2657769a22f15098343f9272f52a01145698786 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Mon, 29 Mar 2021 13:29:58 -0400
Subject: Improve `clone_on_copy` Lint on `_.clone().method()` when method
 takes self by value Set applicability correctly Correct suggestion when the
 cloned value is a macro call. e.g. `m!(x).clone()` Don't lint when not using
 the `Clone` trait

---
 clippy_lints/src/methods/clone_on_copy.rs | 118 +++++++++++++++++-------------
 tests/ui/clone_on_copy.fixed              |  34 ++++++++-
 tests/ui/clone_on_copy.rs                 |  34 ++++++++-
 tests/ui/clone_on_copy.stderr             |  30 ++++++--
 tests/ui/clone_on_copy_mut.rs             |  18 -----
 5 files changed, 157 insertions(+), 77 deletions(-)
 delete mode 100644 tests/ui/clone_on_copy_mut.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/clone_on_copy.rs b/clippy_lints/src/methods/clone_on_copy.rs
index edb6649b87b..ce2e8fa8b10 100644
--- a/clippy_lints/src/methods/clone_on_copy.rs
+++ b/clippy_lints/src/methods/clone_on_copy.rs
@@ -1,10 +1,12 @@
-use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
+use clippy_utils::get_parent_node;
+use clippy_utils::source::snippet_with_context;
 use clippy_utils::sugg;
 use clippy_utils::ty::is_copy;
 use rustc_errors::Applicability;
-use rustc_hir as hir;
+use rustc_hir::{BindingAnnotation, Expr, ExprKind, MatchSource, Node, PatKind};
 use rustc_lint::LateContext;
-use rustc_middle::ty;
+use rustc_middle::ty::{self, adjustment::Adjust};
 use rustc_span::symbol::{sym, Symbol};
 use std::iter;
 
@@ -12,12 +14,26 @@ use super::CLONE_DOUBLE_REF;
 use super::CLONE_ON_COPY;
 
 /// Checks for the `CLONE_ON_COPY` lint.
-pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, method_name: Symbol, args: &[hir::Expr<'_>]) {
-    if !(args.len() == 1 && method_name == sym::clone) {
+#[allow(clippy::too_many_lines)]
+pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, method_name: Symbol, args: &[Expr<'_>]) {
+    let arg = match args {
+        [arg] if method_name == sym::clone => arg,
+        _ => return,
+    };
+    if cx
+        .typeck_results()
+        .type_dependent_def_id(expr.hir_id)
+        .and_then(|id| cx.tcx.trait_of_item(id))
+        .zip(cx.tcx.lang_items().clone_trait())
+        .map_or(true, |(x, y)| x != y)
+    {
         return;
     }
-    let arg = &args[0];
-    let arg_ty = cx.typeck_results().expr_ty_adjusted(&args[0]);
+    let arg_adjustments = cx.typeck_results().expr_adjustments(arg);
+    let arg_ty = arg_adjustments
+        .last()
+        .map_or_else(|| cx.typeck_results().expr_ty(arg), |a| a.target);
+
     let ty = cx.typeck_results().expr_ty(expr);
     if let ty::Ref(_, inner, _) = arg_ty.kind() {
         if let ty::Ref(_, innermost, _) = inner.kind() {
@@ -61,57 +77,57 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, method_name: Sym
     }
 
     if is_copy(cx, ty) {
-        let snip;
-        if let Some(snippet) = sugg::Sugg::hir_opt(cx, arg) {
-            let parent = cx.tcx.hir().get_parent_node(expr.hir_id);
-            match &cx.tcx.hir().get(parent) {
-                hir::Node::Expr(parent) => match parent.kind {
-                    // &*x is a nop, &x.clone() is not
-                    hir::ExprKind::AddrOf(..) => return,
-                    // (*x).func() is useless, x.clone().func() can work in case func borrows mutably
-                    hir::ExprKind::MethodCall(_, _, parent_args, _) if expr.hir_id == parent_args[0].hir_id => {
-                        return;
-                    },
-
-                    _ => {},
-                },
-                hir::Node::Stmt(stmt) => {
-                    if let hir::StmtKind::Local(ref loc) = stmt.kind {
-                        if let hir::PatKind::Ref(..) = loc.pat.kind {
-                            // let ref y = *x borrows x, let ref y = x.clone() does not
-                            return;
-                        }
-                    }
-                },
-                _ => {},
+        let parent_is_suffix_expr = match get_parent_node(cx.tcx, expr.hir_id) {
+            Some(Node::Expr(parent)) => match parent.kind {
+                // &*x is a nop, &x.clone() is not
+                ExprKind::AddrOf(..) => return,
+                // (*x).func() is useless, x.clone().func() can work in case func borrows self
+                ExprKind::MethodCall(_, _, [self_arg, ..], _)
+                    if expr.hir_id == self_arg.hir_id && ty != cx.typeck_results().expr_ty_adjusted(expr) =>
+                {
+                    return;
+                }
+                ExprKind::MethodCall(_, _, [self_arg, ..], _) if expr.hir_id == self_arg.hir_id => true,
+                ExprKind::Match(_, _, MatchSource::TryDesugar | MatchSource::AwaitDesugar)
+                | ExprKind::Field(..)
+                | ExprKind::Index(..) => true,
+                _ => false,
+            },
+            // local binding capturing a reference
+            Some(Node::Local(l))
+                if matches!(
+                    l.pat.kind,
+                    PatKind::Binding(BindingAnnotation::Ref | BindingAnnotation::RefMut, ..)
+                ) =>
+            {
+                return;
             }
+            _ => false,
+        };
 
-            // x.clone() might have dereferenced x, possibly through Deref impls
-            if cx.typeck_results().expr_ty(arg) == ty {
-                snip = Some(("try removing the `clone` call", format!("{}", snippet)));
-            } else {
-                let deref_count = cx
-                    .typeck_results()
-                    .expr_adjustments(arg)
-                    .iter()
-                    .filter(|adj| matches!(adj.kind, ty::adjustment::Adjust::Deref(_)))
-                    .count();
-                let derefs: String = iter::repeat('*').take(deref_count).collect();
-                snip = Some(("try dereferencing it", format!("{}{}", derefs, snippet)));
-            }
+        let mut app = Applicability::MachineApplicable;
+        let snip = snippet_with_context(cx, arg.span, expr.span.ctxt(), "_", &mut app).0;
+
+        let deref_count = arg_adjustments
+            .iter()
+            .take_while(|adj| matches!(adj.kind, Adjust::Deref(_)))
+            .count();
+        let (help, sugg) = if deref_count == 0 {
+            ("try removing the `clone` call", snip.into())
+        } else if parent_is_suffix_expr {
+            ("try dereferencing it", format!("({}{})", "*".repeat(deref_count), snip))
         } else {
-            snip = None;
-        }
-        span_lint_and_then(
+            ("try dereferencing it", format!("{}{}", "*".repeat(deref_count), snip))
+        };
+
+        span_lint_and_sugg(
             cx,
             CLONE_ON_COPY,
             expr.span,
             &format!("using `clone` on type `{}` which implements the `Copy` trait", ty),
-            |diag| {
-                if let Some((text, snip)) = snip {
-                    diag.span_suggestion(expr.span, text, snip, Applicability::MachineApplicable);
-                }
-            },
+            help,
+            sugg,
+            app,
         );
     }
 }
diff --git a/tests/ui/clone_on_copy.fixed b/tests/ui/clone_on_copy.fixed
index d924625132e..8d43f64768d 100644
--- a/tests/ui/clone_on_copy.fixed
+++ b/tests/ui/clone_on_copy.fixed
@@ -6,7 +6,8 @@
     clippy::deref_addrof,
     clippy::no_effect,
     clippy::unnecessary_operation,
-    clippy::vec_init_then_push
+    clippy::vec_init_then_push,
+    clippy::toplevel_ref_arg
 )]
 
 use std::cell::RefCell;
@@ -29,6 +30,37 @@ fn clone_on_copy() {
     let rc = RefCell::new(0);
     *rc.borrow();
 
+    let x = 0u32;
+    x.rotate_left(1);
+
+    #[derive(Clone, Copy)]
+    struct Foo;
+    impl Foo {
+        fn clone(&self) -> u32 {
+            0
+        }
+    }
+    Foo.clone(); // ok, this is not the clone trait
+
+    macro_rules! m {
+        ($e:expr) => {{ $e }};
+    }
+    m!(42);
+
+    struct Wrap([u32; 2]);
+    impl core::ops::Deref for Wrap {
+        type Target = [u32; 2];
+        fn deref(&self) -> &[u32; 2] {
+            &self.0
+        }
+    }
+    let x = Wrap([0, 0]);
+    (*x)[0];
+
+    let x = 42;
+    let ref y = x.clone(); // ok, binds by reference
+    let ref mut y = x.clone(); // ok, binds by reference
+
     // Issue #4348
     let mut x = 43;
     let _ = &x.clone(); // ok, getting a ref
diff --git a/tests/ui/clone_on_copy.rs b/tests/ui/clone_on_copy.rs
index 97f49467244..f15501f7184 100644
--- a/tests/ui/clone_on_copy.rs
+++ b/tests/ui/clone_on_copy.rs
@@ -6,7 +6,8 @@
     clippy::deref_addrof,
     clippy::no_effect,
     clippy::unnecessary_operation,
-    clippy::vec_init_then_push
+    clippy::vec_init_then_push,
+    clippy::toplevel_ref_arg
 )]
 
 use std::cell::RefCell;
@@ -29,6 +30,37 @@ fn clone_on_copy() {
     let rc = RefCell::new(0);
     rc.borrow().clone();
 
+    let x = 0u32;
+    x.clone().rotate_left(1);
+
+    #[derive(Clone, Copy)]
+    struct Foo;
+    impl Foo {
+        fn clone(&self) -> u32 {
+            0
+        }
+    }
+    Foo.clone(); // ok, this is not the clone trait
+
+    macro_rules! m {
+        ($e:expr) => {{ $e }};
+    }
+    m!(42).clone();
+
+    struct Wrap([u32; 2]);
+    impl core::ops::Deref for Wrap {
+        type Target = [u32; 2];
+        fn deref(&self) -> &[u32; 2] {
+            &self.0
+        }
+    }
+    let x = Wrap([0, 0]);
+    x.clone()[0];
+
+    let x = 42;
+    let ref y = x.clone(); // ok, binds by reference
+    let ref mut y = x.clone(); // ok, binds by reference
+
     // Issue #4348
     let mut x = 43;
     let _ = &x.clone(); // ok, getting a ref
diff --git a/tests/ui/clone_on_copy.stderr b/tests/ui/clone_on_copy.stderr
index 7a706884fb0..e7d28b4320b 100644
--- a/tests/ui/clone_on_copy.stderr
+++ b/tests/ui/clone_on_copy.stderr
@@ -1,5 +1,5 @@
 error: using `clone` on type `i32` which implements the `Copy` trait
-  --> $DIR/clone_on_copy.rs:23:5
+  --> $DIR/clone_on_copy.rs:24:5
    |
 LL |     42.clone();
    |     ^^^^^^^^^^ help: try removing the `clone` call: `42`
@@ -7,28 +7,46 @@ LL |     42.clone();
    = note: `-D clippy::clone-on-copy` implied by `-D warnings`
 
 error: using `clone` on type `i32` which implements the `Copy` trait
-  --> $DIR/clone_on_copy.rs:27:5
+  --> $DIR/clone_on_copy.rs:28:5
    |
 LL |     (&42).clone();
    |     ^^^^^^^^^^^^^ help: try dereferencing it: `*(&42)`
 
 error: using `clone` on type `i32` which implements the `Copy` trait
-  --> $DIR/clone_on_copy.rs:30:5
+  --> $DIR/clone_on_copy.rs:31:5
    |
 LL |     rc.borrow().clone();
    |     ^^^^^^^^^^^^^^^^^^^ help: try dereferencing it: `*rc.borrow()`
 
+error: using `clone` on type `u32` which implements the `Copy` trait
+  --> $DIR/clone_on_copy.rs:34:5
+   |
+LL |     x.clone().rotate_left(1);
+   |     ^^^^^^^^^ help: try removing the `clone` call: `x`
+
+error: using `clone` on type `i32` which implements the `Copy` trait
+  --> $DIR/clone_on_copy.rs:48:5
+   |
+LL |     m!(42).clone();
+   |     ^^^^^^^^^^^^^^ help: try removing the `clone` call: `m!(42)`
+
+error: using `clone` on type `[u32; 2]` which implements the `Copy` trait
+  --> $DIR/clone_on_copy.rs:58:5
+   |
+LL |     x.clone()[0];
+   |     ^^^^^^^^^ help: try dereferencing it: `(*x)`
+
 error: using `clone` on type `char` which implements the `Copy` trait
-  --> $DIR/clone_on_copy.rs:36:14
+  --> $DIR/clone_on_copy.rs:68:14
    |
 LL |     is_ascii('z'.clone());
    |              ^^^^^^^^^^^ help: try removing the `clone` call: `'z'`
 
 error: using `clone` on type `i32` which implements the `Copy` trait
-  --> $DIR/clone_on_copy.rs:40:14
+  --> $DIR/clone_on_copy.rs:72:14
    |
 LL |     vec.push(42.clone());
    |              ^^^^^^^^^^ help: try removing the `clone` call: `42`
 
-error: aborting due to 5 previous errors
+error: aborting due to 8 previous errors
 
diff --git a/tests/ui/clone_on_copy_mut.rs b/tests/ui/clone_on_copy_mut.rs
deleted file mode 100644
index 5bfa256623b..00000000000
--- a/tests/ui/clone_on_copy_mut.rs
+++ /dev/null
@@ -1,18 +0,0 @@
-pub fn dec_read_dec(i: &mut i32) -> i32 {
-    *i -= 1;
-    let ret = *i;
-    *i -= 1;
-    ret
-}
-
-pub fn minus_1(i: &i32) -> i32 {
-    dec_read_dec(&mut i.clone())
-}
-
-fn main() {
-    let mut i = 10;
-    assert_eq!(minus_1(&i), 9);
-    assert_eq!(i, 10);
-    assert_eq!(dec_read_dec(&mut i), 9);
-    assert_eq!(i, 8);
-}
-- 
cgit 1.4.1-3-g733a5


From 541c8b8f69b1b14fe3de272d5fad4323cfd1ae0c Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Tue, 30 Mar 2021 11:45:54 +0900
Subject: Improve documents in functions group

---
 clippy_lints/src/functions/mod.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/functions/mod.rs b/clippy_lints/src/functions/mod.rs
index 4ba5166059f..2beb9bc94bf 100644
--- a/clippy_lints/src/functions/mod.rs
+++ b/clippy_lints/src/functions/mod.rs
@@ -56,7 +56,7 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// **What it does:** Checks for public functions that dereference raw pointer
-    /// arguments but are not marked unsafe.
+    /// arguments but are not marked `unsafe`.
     ///
     /// **Why is this bad?** The function should probably be marked `unsafe`, since
     /// for an arbitrary raw pointer, there is no way of telling for sure if it is
@@ -165,7 +165,7 @@ declare_clippy_lint! {
 declare_clippy_lint! {
     /// **What it does:** Checks for public functions that return a `Result`
     /// with an `Err` type of `()`. It suggests using a custom type that
-    /// implements [`std::error::Error`].
+    /// implements `std::error::Error`.
     ///
     /// **Why is this bad?** Unit does not implement `Error` and carries no
     /// further information about what went wrong.
-- 
cgit 1.4.1-3-g733a5


From 6966c78be74ec7dea5cbbb18f1ec10771bf4b728 Mon Sep 17 00:00:00 2001
From: Mateusz Gacek <96mateusz.gacek@gmail.com>
Date: Mon, 29 Mar 2021 12:51:23 -0700
Subject: wrong_self_convention: fix FP inside trait impl for `to_*` method

When the `to_*` method takes `&self` and it is a trait implementation,
we don't trigger the lint.
---
 clippy_lints/src/methods/mod.rs                   | 10 ++++++-
 clippy_lints/src/methods/wrong_self_convention.rs | 32 ++++++++++++++++++-----
 tests/ui/wrong_self_convention.rs                 |  9 ++-----
 tests/ui/wrong_self_convention.stderr             |  4 +--
 tests/ui/wrong_self_convention2.rs                | 32 +++++++++++++++++++++++
 tests/ui/wrong_self_convention2.stderr            | 11 ++++++++
 6 files changed, 81 insertions(+), 17 deletions(-)
 create mode 100644 tests/ui/wrong_self_convention2.rs
 create mode 100644 tests/ui/wrong_self_convention2.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index fccdee07877..95592523928 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -205,6 +205,13 @@ declare_clippy_lint! {
     /// |`to_`  | not `_mut` |`self`                 | `Copy`       |
     /// |`to_`  | not `_mut` |`&self`                | not `Copy`   |
     ///
+    /// Note: Clippy doesn't trigger methods with `to_` prefix in:
+    /// - Traits definition.
+    /// Clippy can not tell if a type that implements a trait is `Copy` or not.
+    /// - Traits implementation, when `&self` is taken.
+    /// The method signature is controlled by the trait and often `&self` is required for all types that implement the trait
+    /// (see e.g. the `std::string::ToString` trait).
+    ///
     /// Please find more info here:
     /// https://rust-lang.github.io/api-guidelines/naming.html#ad-hoc-conversions-follow-as_-to_-into_-conventions-c-conv
     ///
@@ -1850,7 +1857,6 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
         let self_ty = cx.tcx.type_of(item.def_id);
 
         let implements_trait = matches!(item.kind, hir::ItemKind::Impl(hir::Impl { of_trait: Some(_), .. }));
-
         if_chain! {
             if let hir::ImplItemKind::Fn(ref sig, id) = impl_item.kind;
             if let Some(first_arg) = iter_input_pats(&sig.decl, cx.tcx.hir().body(id)).next();
@@ -1902,6 +1908,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
                     self_ty,
                     first_arg_ty,
                     first_arg.pat.span,
+                    implements_trait,
                     false
                 );
             }
@@ -1972,6 +1979,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
                     self_ty,
                     first_arg_ty,
                     first_arg_span,
+                    false,
                     true
                 );
             }
diff --git a/clippy_lints/src/methods/wrong_self_convention.rs b/clippy_lints/src/methods/wrong_self_convention.rs
index 59e683aa9a7..1e0de249a91 100644
--- a/clippy_lints/src/methods/wrong_self_convention.rs
+++ b/clippy_lints/src/methods/wrong_self_convention.rs
@@ -21,8 +21,10 @@ const CONVENTIONS: [(&[Convention], &[SelfKind]); 9] = [
 
     // Conversion using `to_` can use borrowed (non-Copy types) or owned (Copy types).
     // Source: https://rust-lang.github.io/api-guidelines/naming.html#ad-hoc-conversions-follow-as_-to_-into_-conventions-c-conv
-    (&[Convention::StartsWith("to_"), Convention::NotEndsWith("_mut"), Convention::IsSelfTypeCopy(false), Convention::ImplementsTrait(false)], &[SelfKind::Ref]),
-    (&[Convention::StartsWith("to_"), Convention::NotEndsWith("_mut"), Convention::IsSelfTypeCopy(true), Convention::ImplementsTrait(false)], &[SelfKind::Value]),
+    (&[Convention::StartsWith("to_"), Convention::NotEndsWith("_mut"), Convention::IsSelfTypeCopy(false), 
+    Convention::IsTraitItem(false)], &[SelfKind::Ref]),
+    (&[Convention::StartsWith("to_"), Convention::NotEndsWith("_mut"), Convention::IsSelfTypeCopy(true), 
+    Convention::IsTraitItem(false), Convention::ImplementsTrait(false)], &[SelfKind::Value]),
 ];
 
 enum Convention {
@@ -32,18 +34,27 @@ enum Convention {
     NotEndsWith(&'static str),
     IsSelfTypeCopy(bool),
     ImplementsTrait(bool),
+    IsTraitItem(bool),
 }
 
 impl Convention {
     #[must_use]
-    fn check<'tcx>(&self, cx: &LateContext<'tcx>, self_ty: &'tcx TyS<'tcx>, other: &str, is_trait_def: bool) -> bool {
+    fn check<'tcx>(
+        &self,
+        cx: &LateContext<'tcx>,
+        self_ty: &'tcx TyS<'tcx>,
+        other: &str,
+        implements_trait: bool,
+        is_trait_item: bool,
+    ) -> bool {
         match *self {
             Self::Eq(this) => this == other,
             Self::StartsWith(this) => other.starts_with(this) && this != other,
             Self::EndsWith(this) => other.ends_with(this) && this != other,
-            Self::NotEndsWith(this) => !Self::EndsWith(this).check(cx, self_ty, other, is_trait_def),
+            Self::NotEndsWith(this) => !Self::EndsWith(this).check(cx, self_ty, other, implements_trait, is_trait_item),
             Self::IsSelfTypeCopy(is_true) => is_true == is_copy(cx, self_ty),
-            Self::ImplementsTrait(is_true) => is_true == is_trait_def,
+            Self::ImplementsTrait(is_true) => is_true == implements_trait,
+            Self::IsTraitItem(is_true) => is_true == is_trait_item,
         }
     }
 }
@@ -60,12 +71,17 @@ impl fmt::Display for Convention {
             },
             Self::ImplementsTrait(is_true) => {
                 let (negation, s_suffix) = if is_true { ("", "s") } else { (" does not", "") };
-                format!("Method{} implement{} a trait", negation, s_suffix).fmt(f)
+                format!("method{} implement{} a trait", negation, s_suffix).fmt(f)
+            },
+            Self::IsTraitItem(is_true) => {
+                let suffix = if is_true { " is" } else { " is not" };
+                format!("method{} a trait item", suffix).fmt(f)
             },
         }
     }
 }
 
+#[allow(clippy::too_many_arguments)]
 pub(super) fn check<'tcx>(
     cx: &LateContext<'tcx>,
     item_name: &str,
@@ -73,6 +89,7 @@ pub(super) fn check<'tcx>(
     self_ty: &'tcx TyS<'tcx>,
     first_arg_ty: &'tcx TyS<'tcx>,
     first_arg_span: Span,
+    implements_trait: bool,
     is_trait_item: bool,
 ) {
     let lint = if is_pub {
@@ -83,7 +100,7 @@ pub(super) fn check<'tcx>(
     if let Some((conventions, self_kinds)) = &CONVENTIONS.iter().find(|(convs, _)| {
         convs
             .iter()
-            .all(|conv| conv.check(cx, self_ty, item_name, is_trait_item))
+            .all(|conv| conv.check(cx, self_ty, item_name, implements_trait, is_trait_item))
     }) {
         if !self_kinds.iter().any(|k| k.matches(cx, self_ty, first_arg_ty)) {
             let suggestion = {
@@ -99,6 +116,7 @@ pub(super) fn check<'tcx>(
                         .filter_map(|conv| {
                             if (cut_ends_with_conv && matches!(conv, Convention::NotEndsWith(_)))
                                 || matches!(conv, Convention::ImplementsTrait(_))
+                                || matches!(conv, Convention::IsTraitItem(_))
                             {
                                 None
                             } else {
diff --git a/tests/ui/wrong_self_convention.rs b/tests/ui/wrong_self_convention.rs
index ba9e19a1722..cdfbdb8b0db 100644
--- a/tests/ui/wrong_self_convention.rs
+++ b/tests/ui/wrong_self_convention.rs
@@ -165,15 +165,10 @@ mod issue6307 {
 }
 
 mod issue6727 {
-    trait ToU64 {
-        fn to_u64(self) -> u64;
-        fn to_u64_v2(&self) -> u64;
-    }
-
     #[derive(Clone, Copy)]
     struct FooCopy;
 
-    impl ToU64 for FooCopy {
+    impl FooCopy {
         fn to_u64(self) -> u64 {
             1
         }
@@ -185,7 +180,7 @@ mod issue6727 {
 
     struct FooNoCopy;
 
-    impl ToU64 for FooNoCopy {
+    impl FooNoCopy {
         // trigger lint
         fn to_u64(self) -> u64 {
             2
diff --git a/tests/ui/wrong_self_convention.stderr b/tests/ui/wrong_self_convention.stderr
index 1d58a12ac79..29f5ba82695 100644
--- a/tests/ui/wrong_self_convention.stderr
+++ b/tests/ui/wrong_self_convention.stderr
@@ -176,7 +176,7 @@ LL |         fn from_i32(self);
    = help: consider choosing a less ambiguous name
 
 error: methods with the following characteristics: (`to_*` and `self` type is `Copy`) usually take `self` by value
-  --> $DIR/wrong_self_convention.rs:181:22
+  --> $DIR/wrong_self_convention.rs:176:22
    |
 LL |         fn to_u64_v2(&self) -> u64 {
    |                      ^^^^^
@@ -184,7 +184,7 @@ LL |         fn to_u64_v2(&self) -> u64 {
    = help: consider choosing a less ambiguous name
 
 error: methods with the following characteristics: (`to_*` and `self` type is not `Copy`) usually take `self` by reference
-  --> $DIR/wrong_self_convention.rs:190:19
+  --> $DIR/wrong_self_convention.rs:185:19
    |
 LL |         fn to_u64(self) -> u64 {
    |                   ^^^^
diff --git a/tests/ui/wrong_self_convention2.rs b/tests/ui/wrong_self_convention2.rs
new file mode 100644
index 00000000000..8b42aa59e13
--- /dev/null
+++ b/tests/ui/wrong_self_convention2.rs
@@ -0,0 +1,32 @@
+// edition:2018
+#![warn(clippy::wrong_self_convention)]
+#![warn(clippy::wrong_pub_self_convention)]
+#![allow(dead_code)]
+
+fn main() {}
+
+mod issue6983 {
+    pub struct Thing;
+    pub trait Trait {
+        fn to_thing(&self) -> Thing;
+    }
+
+    impl Trait for u8 {
+        // don't trigger, e.g. `ToString` from `std` requires `&self`
+        fn to_thing(&self) -> Thing {
+            Thing
+        }
+    }
+
+    trait ToU64 {
+        fn to_u64(self) -> u64;
+    }
+
+    struct FooNoCopy;
+    // trigger lint
+    impl ToU64 for FooNoCopy {
+        fn to_u64(self) -> u64 {
+            2
+        }
+    }
+}
diff --git a/tests/ui/wrong_self_convention2.stderr b/tests/ui/wrong_self_convention2.stderr
new file mode 100644
index 00000000000..0ca1a390974
--- /dev/null
+++ b/tests/ui/wrong_self_convention2.stderr
@@ -0,0 +1,11 @@
+error: methods with the following characteristics: (`to_*` and `self` type is not `Copy`) usually take `self` by reference
+  --> $DIR/wrong_self_convention2.rs:28:19
+   |
+LL |         fn to_u64(self) -> u64 {
+   |                   ^^^^
+   |
+   = note: `-D clippy::wrong-self-convention` implied by `-D warnings`
+   = help: consider choosing a less ambiguous name
+
+error: aborting due to previous error
+
-- 
cgit 1.4.1-3-g733a5


From fa689f865e4096a1788c38fe9fef0c05dc15b9be Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Mon, 29 Mar 2021 20:39:28 -0400
Subject: Fix `manual_map` at the end of an if chain

---
 clippy_lints/src/manual_map.rs    |  5 ++--
 clippy_utils/src/lib.rs           | 23 ++++++++++------
 tests/ui/manual_map_option.fixed  |  7 ++++-
 tests/ui/manual_map_option.rs     |  9 +++++++
 tests/ui/manual_map_option.stderr | 55 +++++++++++++++++++++------------------
 5 files changed, 61 insertions(+), 38 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_map.rs b/clippy_lints/src/manual_map.rs
index ed157783b72..d6ef3aa1e77 100644
--- a/clippy_lints/src/manual_map.rs
+++ b/clippy_lints/src/manual_map.rs
@@ -2,7 +2,7 @@ use crate::{map_unit_fn::OPTION_MAP_UNIT_FN, matches::MATCH_AS_REF};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::{snippet_with_applicability, snippet_with_context};
 use clippy_utils::ty::{can_partially_move_ty, is_type_diagnostic_item, peel_mid_ty_refs_is_mutable};
-use clippy_utils::{is_allowed, is_else_clause_of_if_let_else, match_def_path, match_var, paths, peel_hir_expr_refs};
+use clippy_utils::{is_allowed, is_else_clause, match_def_path, match_var, paths, peel_hir_expr_refs};
 use rustc_ast::util::parser::PREC_POSTFIX;
 use rustc_errors::Applicability;
 use rustc_hir::{
@@ -181,8 +181,7 @@ impl LateLintPass<'_> for ManualMap {
                 expr.span,
                 "manual implementation of `Option::map`",
                 "try this",
-                if matches!(match_kind, MatchSource::IfLetDesugar { .. }) && is_else_clause_of_if_let_else(cx.tcx, expr)
-                {
+                if matches!(match_kind, MatchSource::IfLetDesugar { .. }) && is_else_clause(cx.tcx, expr) {
                     format!("{{ {}{}.map({}) }}", scrutinee_str, as_ref_str, body_str)
                 } else {
                     format!("{}{}.map({})", scrutinee_str, as_ref_str, body_str)
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 9e4dcb600ed..d6364625e70 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -797,22 +797,29 @@ pub fn get_parent_as_impl(tcx: TyCtxt<'_>, id: HirId) -> Option<&Impl<'_>> {
     }
 }
 
-/// Checks if the given expression is the else clause in the expression `if let .. {} else {}`
-pub fn is_else_clause_of_if_let_else(tcx: TyCtxt<'_>, expr: &Expr<'_>) -> bool {
+/// Checks if the given expression is the else clause of either an `if` or `if let` expression.
+pub fn is_else_clause(tcx: TyCtxt<'_>, expr: &Expr<'_>) -> bool {
     let map = tcx.hir();
     let mut iter = map.parent_iter(expr.hir_id);
-    let arm_id = match iter.next() {
-        Some((id, Node::Arm(..))) => id,
-        _ => return false,
-    };
     match iter.next() {
+        Some((arm_id, Node::Arm(..))) => matches!(
+            iter.next(),
+            Some((
+                _,
+                Node::Expr(Expr {
+                    kind: ExprKind::Match(_, [_, else_arm], MatchSource::IfLetDesugar { .. }),
+                    ..
+                })
+            ))
+            if else_arm.hir_id == arm_id
+        ),
         Some((
             _,
             Node::Expr(Expr {
-                kind: ExprKind::Match(_, [_, else_arm], kind),
+                kind: ExprKind::If(_, _, Some(else_expr)),
                 ..
             }),
-        )) => else_arm.hir_id == arm_id && matches!(kind, MatchSource::IfLetDesugar { .. }),
+        )) => else_expr.hir_id == expr.hir_id,
         _ => false,
     }
 }
diff --git a/tests/ui/manual_map_option.fixed b/tests/ui/manual_map_option.fixed
index acb6a580ceb..5e26958041d 100644
--- a/tests/ui/manual_map_option.fixed
+++ b/tests/ui/manual_map_option.fixed
@@ -7,6 +7,7 @@
     clippy::map_identity,
     clippy::unit_arg,
     clippy::match_ref_pats,
+    clippy::redundant_pattern_matching,
     dead_code
 )]
 
@@ -130,7 +131,11 @@ fn main() {
     }
 
     // #6847
-    if Some(0).is_some() {
+    if let Some(_) = Some(0) {
+        Some(0)
+    } else { Some(0).map(|x| x + 1) };
+
+    if true {
         Some(0)
     } else { Some(0).map(|x| x + 1) };
 }
diff --git a/tests/ui/manual_map_option.rs b/tests/ui/manual_map_option.rs
index 3299e617707..33eb8156105 100644
--- a/tests/ui/manual_map_option.rs
+++ b/tests/ui/manual_map_option.rs
@@ -7,6 +7,7 @@
     clippy::map_identity,
     clippy::unit_arg,
     clippy::match_ref_pats,
+    clippy::redundant_pattern_matching,
     dead_code
 )]
 
@@ -195,4 +196,12 @@ fn main() {
     } else {
         None
     };
+
+    if true {
+        Some(0)
+    } else if let Some(x) = Some(0) {
+        Some(x + 1)
+    } else {
+        None
+    };
 }
diff --git a/tests/ui/manual_map_option.stderr b/tests/ui/manual_map_option.stderr
index 048ccfb9582..cdc2c0e62a9 100644
--- a/tests/ui/manual_map_option.stderr
+++ b/tests/ui/manual_map_option.stderr
@@ -1,5 +1,5 @@
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:14:5
+  --> $DIR/manual_map_option.rs:15:5
    |
 LL | /     match Some(0) {
 LL | |         Some(_) => Some(2),
@@ -10,7 +10,7 @@ LL | |     };
    = note: `-D clippy::manual-map` implied by `-D warnings`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:19:5
+  --> $DIR/manual_map_option.rs:20:5
    |
 LL | /     match Some(0) {
 LL | |         Some(x) => Some(x + 1),
@@ -19,7 +19,7 @@ LL | |     };
    | |_____^ help: try this: `Some(0).map(|x| x + 1)`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:24:5
+  --> $DIR/manual_map_option.rs:25:5
    |
 LL | /     match Some("") {
 LL | |         Some(x) => Some(x.is_empty()),
@@ -28,7 +28,7 @@ LL | |     };
    | |_____^ help: try this: `Some("").map(|x| x.is_empty())`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:29:5
+  --> $DIR/manual_map_option.rs:30:5
    |
 LL | /     if let Some(x) = Some(0) {
 LL | |         Some(!x)
@@ -38,7 +38,7 @@ LL | |     };
    | |_____^ help: try this: `Some(0).map(|x| !x)`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:36:5
+  --> $DIR/manual_map_option.rs:37:5
    |
 LL | /     match Some(0) {
 LL | |         Some(x) => { Some(std::convert::identity(x)) }
@@ -47,7 +47,7 @@ LL | |     };
    | |_____^ help: try this: `Some(0).map(std::convert::identity)`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:41:5
+  --> $DIR/manual_map_option.rs:42:5
    |
 LL | /     match Some(&String::new()) {
 LL | |         Some(x) => Some(str::len(x)),
@@ -56,7 +56,7 @@ LL | |     };
    | |_____^ help: try this: `Some(&String::new()).map(|x| str::len(x))`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:51:5
+  --> $DIR/manual_map_option.rs:52:5
    |
 LL | /     match &Some([0, 1]) {
 LL | |         Some(x) => Some(x[0]),
@@ -65,7 +65,7 @@ LL | |     };
    | |_____^ help: try this: `Some([0, 1]).as_ref().map(|x| x[0])`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:56:5
+  --> $DIR/manual_map_option.rs:57:5
    |
 LL | /     match &Some(0) {
 LL | |         &Some(x) => Some(x * 2),
@@ -74,7 +74,7 @@ LL | |     };
    | |_____^ help: try this: `Some(0).map(|x| x * 2)`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:61:5
+  --> $DIR/manual_map_option.rs:62:5
    |
 LL | /     match Some(String::new()) {
 LL | |         Some(ref x) => Some(x.is_empty()),
@@ -83,7 +83,7 @@ LL | |     };
    | |_____^ help: try this: `Some(String::new()).as_ref().map(|x| x.is_empty())`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:66:5
+  --> $DIR/manual_map_option.rs:67:5
    |
 LL | /     match &&Some(String::new()) {
 LL | |         Some(x) => Some(x.len()),
@@ -92,7 +92,7 @@ LL | |     };
    | |_____^ help: try this: `Some(String::new()).as_ref().map(|x| x.len())`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:71:5
+  --> $DIR/manual_map_option.rs:72:5
    |
 LL | /     match &&Some(0) {
 LL | |         &&Some(x) => Some(x + x),
@@ -101,7 +101,7 @@ LL | |     };
    | |_____^ help: try this: `Some(0).map(|x| x + x)`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:84:9
+  --> $DIR/manual_map_option.rs:85:9
    |
 LL | /         match &mut Some(String::new()) {
 LL | |             Some(x) => Some(x.push_str("")),
@@ -110,7 +110,7 @@ LL | |         };
    | |_________^ help: try this: `Some(String::new()).as_mut().map(|x| x.push_str(""))`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:90:5
+  --> $DIR/manual_map_option.rs:91:5
    |
 LL | /     match &mut Some(String::new()) {
 LL | |         Some(ref x) => Some(x.len()),
@@ -119,7 +119,7 @@ LL | |     };
    | |_____^ help: try this: `Some(String::new()).as_ref().map(|x| x.len())`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:95:5
+  --> $DIR/manual_map_option.rs:96:5
    |
 LL | /     match &mut &Some(String::new()) {
 LL | |         Some(x) => Some(x.is_empty()),
@@ -128,7 +128,7 @@ LL | |     };
    | |_____^ help: try this: `Some(String::new()).as_ref().map(|x| x.is_empty())`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:100:5
+  --> $DIR/manual_map_option.rs:101:5
    |
 LL | /     match Some((0, 1, 2)) {
 LL | |         Some((x, y, z)) => Some(x + y + z),
@@ -137,7 +137,7 @@ LL | |     };
    | |_____^ help: try this: `Some((0, 1, 2)).map(|(x, y, z)| x + y + z)`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:105:5
+  --> $DIR/manual_map_option.rs:106:5
    |
 LL | /     match Some([1, 2, 3]) {
 LL | |         Some([first, ..]) => Some(first),
@@ -146,7 +146,7 @@ LL | |     };
    | |_____^ help: try this: `Some([1, 2, 3]).map(|[first, ..]| first)`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:110:5
+  --> $DIR/manual_map_option.rs:111:5
    |
 LL | /     match &Some((String::new(), "test")) {
 LL | |         Some((x, y)) => Some((y, x)),
@@ -155,7 +155,7 @@ LL | |     };
    | |_____^ help: try this: `Some((String::new(), "test")).as_ref().map(|(x, y)| (y, x))`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:168:5
+  --> $DIR/manual_map_option.rs:169:5
    |
 LL | /     match Some(0) {
 LL | |         Some(x) => Some(vec![x]),
@@ -164,7 +164,7 @@ LL | |     };
    | |_____^ help: try this: `Some(0).map(|x| vec![x])`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:173:5
+  --> $DIR/manual_map_option.rs:174:5
    |
 LL | /     match option_env!("") {
 LL | |         Some(x) => Some(String::from(x)),
@@ -172,16 +172,19 @@ LL | |         None => None,
 LL | |     };
    | |_____^ help: try this: `option_env!("").map(String::from)`
 
-error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/manual_map_option.rs:191:12
-   |
-LL |     if let Some(_) = Some(0) {
-   |     -------^^^^^^^---------- help: try this: `if Some(0).is_some()`
+error: manual implementation of `Option::map`
+  --> $DIR/manual_map_option.rs:194:12
    |
-   = note: `-D clippy::redundant-pattern-matching` implied by `-D warnings`
+LL |       } else if let Some(x) = Some(0) {
+   |  ____________^
+LL | |         Some(x + 1)
+LL | |     } else {
+LL | |         None
+LL | |     };
+   | |_____^ help: try this: `{ Some(0).map(|x| x + 1) }`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:193:12
+  --> $DIR/manual_map_option.rs:202:12
    |
 LL |       } else if let Some(x) = Some(0) {
    |  ____________^
-- 
cgit 1.4.1-3-g733a5


From cc7f1daab2e8104d8ae5952e28f22dcac920d244 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Thu, 25 Mar 2021 22:48:27 -0400
Subject: Don't lint `manual_map` in const functions

---
 clippy_lints/src/manual_map.rs   | 10 +++++-----
 tests/ui/manual_map_option.fixed |  8 ++++++++
 tests/ui/manual_map_option.rs    |  8 ++++++++
 3 files changed, 21 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_map.rs b/clippy_lints/src/manual_map.rs
index d6ef3aa1e77..8c9e3af62f4 100644
--- a/clippy_lints/src/manual_map.rs
+++ b/clippy_lints/src/manual_map.rs
@@ -2,7 +2,7 @@ use crate::{map_unit_fn::OPTION_MAP_UNIT_FN, matches::MATCH_AS_REF};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::{snippet_with_applicability, snippet_with_context};
 use clippy_utils::ty::{can_partially_move_ty, is_type_diagnostic_item, peel_mid_ty_refs_is_mutable};
-use clippy_utils::{is_allowed, is_else_clause, match_def_path, match_var, paths, peel_hir_expr_refs};
+use clippy_utils::{in_constant, is_allowed, is_else_clause, match_def_path, match_var, paths, peel_hir_expr_refs};
 use rustc_ast::util::parser::PREC_POSTFIX;
 use rustc_errors::Applicability;
 use rustc_hir::{
@@ -47,16 +47,16 @@ declare_lint_pass!(ManualMap => [MANUAL_MAP]);
 impl LateLintPass<'_> for ManualMap {
     #[allow(clippy::too_many_lines)]
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if in_external_macro(cx.sess(), expr.span) {
-            return;
-        }
-
         if let ExprKind::Match(
             scrutinee,
             [arm1 @ Arm { guard: None, .. }, arm2 @ Arm { guard: None, .. }],
             match_kind,
         ) = expr.kind
         {
+            if in_external_macro(cx.sess(), expr.span) || in_constant(cx, expr.hir_id) {
+                return;
+            }
+
             let (scrutinee_ty, ty_ref_count, ty_mutability) =
                 peel_mid_ty_refs_is_mutable(cx.typeck_results().expr_ty(scrutinee));
             if !(is_type_diagnostic_item(cx, scrutinee_ty, sym::option_type)
diff --git a/tests/ui/manual_map_option.fixed b/tests/ui/manual_map_option.fixed
index 5e26958041d..ee015845777 100644
--- a/tests/ui/manual_map_option.fixed
+++ b/tests/ui/manual_map_option.fixed
@@ -138,4 +138,12 @@ fn main() {
     if true {
         Some(0)
     } else { Some(0).map(|x| x + 1) };
+
+    // #6967
+    const fn f4() {
+        match Some(0) {
+            Some(x) => Some(x + 1),
+            None => None,
+        };
+    }
 }
diff --git a/tests/ui/manual_map_option.rs b/tests/ui/manual_map_option.rs
index 33eb8156105..29509bddfd9 100644
--- a/tests/ui/manual_map_option.rs
+++ b/tests/ui/manual_map_option.rs
@@ -204,4 +204,12 @@ fn main() {
     } else {
         None
     };
+
+    // #6967
+    const fn f4() {
+        match Some(0) {
+            Some(x) => Some(x + 1),
+            None => None,
+        };
+    }
 }
-- 
cgit 1.4.1-3-g733a5


From 7fcd15571201d55951cf518a564069ff3ed115aa Mon Sep 17 00:00:00 2001
From: Elliot Bobrow <elliotgreybobrow@gmail.com>
Date: Mon, 29 Mar 2021 11:18:59 -0700
Subject: Add non_octal_unix_permissions lint

---
 CHANGELOG.md                                   |   1 +
 README.md                                      |   2 +-
 clippy_lints/src/lib.rs                        |   5 ++
 clippy_lints/src/non_octal_unix_permissions.rs | 106 +++++++++++++++++++++++++
 clippy_utils/src/paths.rs                      |   3 +
 tests/ui/non_octal_unix_permissions.fixed      |  33 ++++++++
 tests/ui/non_octal_unix_permissions.rs         |  33 ++++++++
 tests/ui/non_octal_unix_permissions.stderr     |  28 +++++++
 8 files changed, 210 insertions(+), 1 deletion(-)
 create mode 100644 clippy_lints/src/non_octal_unix_permissions.rs
 create mode 100644 tests/ui/non_octal_unix_permissions.fixed
 create mode 100644 tests/ui/non_octal_unix_permissions.rs
 create mode 100644 tests/ui/non_octal_unix_permissions.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 57996802182..681ecd6832a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2382,6 +2382,7 @@ Released 2018-09-13
 [`new_without_default`]: https://rust-lang.github.io/rust-clippy/master/index.html#new_without_default
 [`no_effect`]: https://rust-lang.github.io/rust-clippy/master/index.html#no_effect
 [`non_ascii_literal`]: https://rust-lang.github.io/rust-clippy/master/index.html#non_ascii_literal
+[`non_octal_unix_permissions`]: https://rust-lang.github.io/rust-clippy/master/index.html#non_octal_unix_permissions
 [`nonminimal_bool`]: https://rust-lang.github.io/rust-clippy/master/index.html#nonminimal_bool
 [`nonsensical_open_options`]: https://rust-lang.github.io/rust-clippy/master/index.html#nonsensical_open_options
 [`not_unsafe_ptr_arg_deref`]: https://rust-lang.github.io/rust-clippy/master/index.html#not_unsafe_ptr_arg_deref
diff --git a/README.md b/README.md
index 63057609bb6..8c0c16c443d 100644
--- a/README.md
+++ b/README.md
@@ -5,7 +5,7 @@
 
 A collection of lints to catch common mistakes and improve your [Rust](https://github.com/rust-lang/rust) code.
 
-[There are over 400 lints included in this crate!](https://rust-lang.github.io/rust-clippy/master/index.html)
+[There are over 450 lints included in this crate!](https://rust-lang.github.io/rust-clippy/master/index.html)
 
 Lints are divided into categories, each with a default [lint level](https://doc.rust-lang.org/rustc/lints/levels.html).
 You can choose how much Clippy is supposed to ~~annoy~~ help you by changing the lint level by category.
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index f013613119c..237c0f48881 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -297,6 +297,7 @@ mod new_without_default;
 mod no_effect;
 mod non_copy_const;
 mod non_expressive_names;
+mod non_octal_unix_permissions;
 mod open_options;
 mod option_env_unwrap;
 mod option_if_let_else;
@@ -873,6 +874,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &non_expressive_names::JUST_UNDERSCORES_AND_DIGITS,
         &non_expressive_names::MANY_SINGLE_CHAR_NAMES,
         &non_expressive_names::SIMILAR_NAMES,
+        &non_octal_unix_permissions::NON_OCTAL_UNIX_PERMISSIONS,
         &open_options::NONSENSICAL_OPEN_OPTIONS,
         &option_env_unwrap::OPTION_ENV_UNWRAP,
         &option_if_let_else::OPTION_IF_LET_ELSE,
@@ -1057,6 +1059,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box implicit_saturating_sub::ImplicitSaturatingSub);
     store.register_late_pass(|| box default_numeric_fallback::DefaultNumericFallback);
     store.register_late_pass(|| box inconsistent_struct_constructor::InconsistentStructConstructor);
+    store.register_late_pass(|| box non_octal_unix_permissions::NonOctalUnixPermissions);
 
     let msrv = conf.msrv.as_ref().and_then(|s| {
         parse_msrv(s, None, None).or_else(|| {
@@ -1647,6 +1650,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&non_copy_const::DECLARE_INTERIOR_MUTABLE_CONST),
         LintId::of(&non_expressive_names::JUST_UNDERSCORES_AND_DIGITS),
         LintId::of(&non_expressive_names::MANY_SINGLE_CHAR_NAMES),
+        LintId::of(&non_octal_unix_permissions::NON_OCTAL_UNIX_PERMISSIONS),
         LintId::of(&open_options::NONSENSICAL_OPEN_OPTIONS),
         LintId::of(&option_env_unwrap::OPTION_ENV_UNWRAP),
         LintId::of(&overflow_check_conditional::OVERFLOW_CHECK_CONDITIONAL),
@@ -1987,6 +1991,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&misc::FLOAT_CMP),
         LintId::of(&misc::MODULO_ONE),
         LintId::of(&mut_key::MUTABLE_KEY_TYPE),
+        LintId::of(&non_octal_unix_permissions::NON_OCTAL_UNIX_PERMISSIONS),
         LintId::of(&open_options::NONSENSICAL_OPEN_OPTIONS),
         LintId::of(&option_env_unwrap::OPTION_ENV_UNWRAP),
         LintId::of(&ptr::MUT_FROM_REF),
diff --git a/clippy_lints/src/non_octal_unix_permissions.rs b/clippy_lints/src/non_octal_unix_permissions.rs
new file mode 100644
index 00000000000..6d45e7bc6cf
--- /dev/null
+++ b/clippy_lints/src/non_octal_unix_permissions.rs
@@ -0,0 +1,106 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::{snippet_opt, snippet_with_applicability};
+use clippy_utils::ty::match_type;
+use clippy_utils::{match_def_path, paths};
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for non-octal values used to set Unix file permissions.
+    ///
+    /// **Why is this bad?** They will be converted into octal, creating potentially
+    /// unintended file permissions.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust,ignore
+    /// use std::fs::OpenOptions;
+    /// use std::os::unix::fs::OpenOptionsExt;
+    ///
+    /// let mut options = OpenOptions::new();
+    /// options.mode(644);
+    /// ```
+    /// Use instead:
+    /// ```rust,ignore
+    /// use std::fs::OpenOptions;
+    /// use std::os::unix::fs::OpenOptionsExt;
+    ///
+    /// let mut options = OpenOptions::new();
+    /// options.mode(0o644);
+    /// ```
+    pub NON_OCTAL_UNIX_PERMISSIONS,
+    correctness,
+    "use of non-octal value to set unix file permissions, which will be translated into octal"
+}
+
+declare_lint_pass!(NonOctalUnixPermissions => [NON_OCTAL_UNIX_PERMISSIONS]);
+
+impl LateLintPass<'_> for NonOctalUnixPermissions {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
+        match &expr.kind {
+            ExprKind::MethodCall(path, _, [func, param], _) => {
+                let obj_ty = cx.typeck_results().expr_ty(&func).peel_refs();
+
+                if_chain! {
+                    if (path.ident.name == sym!(mode)
+                        && (match_type(cx, obj_ty, &paths::OPEN_OPTIONS)
+                            || match_type(cx, obj_ty, &paths::DIR_BUILDER)))
+                        || (path.ident.name == sym!(set_mode) && match_type(cx, obj_ty, &paths::PERMISSIONS));
+                    if let ExprKind::Lit(_) = param.kind;
+
+                    then {
+                        let snip = match snippet_opt(cx, param.span) {
+                            Some(s) => s,
+                            _ => return,
+                        };
+
+                        if !snip.starts_with("0o") {
+                            show_error(cx, param);
+                        }
+                    }
+                }
+            },
+            ExprKind::Call(ref func, [param]) => {
+                if_chain! {
+                    if let ExprKind::Path(ref path) = func.kind;
+                    if let Some(def_id) = cx.qpath_res(path, func.hir_id).opt_def_id();
+                    if match_def_path(cx, def_id, &paths::PERMISSIONS_FROM_MODE);
+                    if let ExprKind::Lit(_) = param.kind;
+
+                    then {
+                        let snip = match snippet_opt(cx, param.span) {
+                            Some(s) => s,
+                            _ => return,
+                        };
+
+                        if !snip.starts_with("0o") {
+                            show_error(cx, param);
+                        }
+                    }
+                }
+            },
+            _ => {},
+        };
+    }
+}
+
+fn show_error(cx: &LateContext<'_>, param: &Expr<'_>) {
+    let mut applicability = Applicability::MachineApplicable;
+    span_lint_and_sugg(
+        cx,
+        NON_OCTAL_UNIX_PERMISSIONS,
+        param.span,
+        "using a non-octal value to set unix file permissions",
+        "consider using an octal literal instead",
+        format!(
+            "0o{}",
+            snippet_with_applicability(cx, param.span, "0o..", &mut applicability,),
+        ),
+        applicability,
+    );
+}
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index 11a446e42a4..7c83a9fe4e2 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -26,6 +26,7 @@ pub const DEFAULT_TRAIT: [&str; 3] = ["core", "default", "Default"];
 pub const DEFAULT_TRAIT_METHOD: [&str; 4] = ["core", "default", "Default", "default"];
 pub const DEREF_MUT_TRAIT_METHOD: [&str; 5] = ["core", "ops", "deref", "DerefMut", "deref_mut"];
 pub const DEREF_TRAIT_METHOD: [&str; 5] = ["core", "ops", "deref", "Deref", "deref"];
+pub const DIR_BUILDER: [&str; 3] = ["std", "fs", "DirBuilder"];
 pub const DISPLAY_FMT_METHOD: [&str; 4] = ["core", "fmt", "Display", "fmt"];
 pub const DISPLAY_TRAIT: [&str; 3] = ["core", "fmt", "Display"];
 pub const DOUBLE_ENDED_ITERATOR: [&str; 4] = ["core", "iter", "traits", "DoubleEndedIterator"];
@@ -95,6 +96,8 @@ pub const PARKING_LOT_RWLOCK_WRITE_GUARD: [&str; 2] = ["parking_lot", "RwLockWri
 pub const PATH_BUF: [&str; 3] = ["std", "path", "PathBuf"];
 pub const PATH_BUF_AS_PATH: [&str; 4] = ["std", "path", "PathBuf", "as_path"];
 pub const PATH_TO_PATH_BUF: [&str; 4] = ["std", "path", "Path", "to_path_buf"];
+pub const PERMISSIONS: [&str; 3] = ["std", "fs", "Permissions"];
+pub const PERMISSIONS_FROM_MODE: [&str; 7] = ["std", "sys", "unix", "ext", "fs", "PermissionsExt", "from_mode"];
 pub const POLL: [&str; 4] = ["core", "task", "poll", "Poll"];
 pub const POLL_PENDING: [&str; 5] = ["core", "task", "poll", "Poll", "Pending"];
 pub const POLL_READY: [&str; 5] = ["core", "task", "poll", "Poll", "Ready"];
diff --git a/tests/ui/non_octal_unix_permissions.fixed b/tests/ui/non_octal_unix_permissions.fixed
new file mode 100644
index 00000000000..a9b2dcfb085
--- /dev/null
+++ b/tests/ui/non_octal_unix_permissions.fixed
@@ -0,0 +1,33 @@
+// ignore-windows
+// run-rustfix
+#![warn(clippy::non_octal_unix_permissions)]
+use std::fs::{DirBuilder, File, OpenOptions, Permissions};
+use std::os::unix::fs::{DirBuilderExt, OpenOptionsExt, PermissionsExt};
+
+fn main() {
+    let permissions = 0o760;
+
+    // OpenOptionsExt::mode
+    let mut options = OpenOptions::new();
+    options.mode(0o440);
+    options.mode(0o400);
+    options.mode(permissions);
+
+    // PermissionsExt::from_mode
+    let _permissions = Permissions::from_mode(0o647);
+    let _permissions = Permissions::from_mode(0o000);
+    let _permissions = Permissions::from_mode(permissions);
+
+    // PermissionsExt::set_mode
+    let f = File::create("foo.txt").unwrap();
+    let metadata = f.metadata().unwrap();
+    let mut permissions = metadata.permissions();
+
+    permissions.set_mode(0o644);
+    permissions.set_mode(0o704);
+
+    // DirBuilderExt::mode
+    let mut builder = DirBuilder::new();
+    builder.mode(0o755);
+    builder.mode(0o406);
+}
diff --git a/tests/ui/non_octal_unix_permissions.rs b/tests/ui/non_octal_unix_permissions.rs
new file mode 100644
index 00000000000..7d2922f494e
--- /dev/null
+++ b/tests/ui/non_octal_unix_permissions.rs
@@ -0,0 +1,33 @@
+// ignore-windows
+// run-rustfix
+#![warn(clippy::non_octal_unix_permissions)]
+use std::fs::{DirBuilder, File, OpenOptions, Permissions};
+use std::os::unix::fs::{DirBuilderExt, OpenOptionsExt, PermissionsExt};
+
+fn main() {
+    let permissions = 0o760;
+
+    // OpenOptionsExt::mode
+    let mut options = OpenOptions::new();
+    options.mode(440);
+    options.mode(0o400);
+    options.mode(permissions);
+
+    // PermissionsExt::from_mode
+    let _permissions = Permissions::from_mode(647);
+    let _permissions = Permissions::from_mode(0o000);
+    let _permissions = Permissions::from_mode(permissions);
+
+    // PermissionsExt::set_mode
+    let f = File::create("foo.txt").unwrap();
+    let metadata = f.metadata().unwrap();
+    let mut permissions = metadata.permissions();
+
+    permissions.set_mode(644);
+    permissions.set_mode(0o704);
+
+    // DirBuilderExt::mode
+    let mut builder = DirBuilder::new();
+    builder.mode(755);
+    builder.mode(0o406);
+}
diff --git a/tests/ui/non_octal_unix_permissions.stderr b/tests/ui/non_octal_unix_permissions.stderr
new file mode 100644
index 00000000000..32845d06594
--- /dev/null
+++ b/tests/ui/non_octal_unix_permissions.stderr
@@ -0,0 +1,28 @@
+error: using a non-octal value to set unix file permissions
+  --> $DIR/non_octal_unix_permissions.rs:12:18
+   |
+LL |     options.mode(440);
+   |                  ^^^ help: consider using an octal literal instead: `0o440`
+   |
+   = note: `-D clippy::non-octal-unix-permissions` implied by `-D warnings`
+
+error: using a non-octal value to set unix file permissions
+  --> $DIR/non_octal_unix_permissions.rs:17:47
+   |
+LL |     let _permissions = Permissions::from_mode(647);
+   |                                               ^^^ help: consider using an octal literal instead: `0o647`
+
+error: using a non-octal value to set unix file permissions
+  --> $DIR/non_octal_unix_permissions.rs:26:26
+   |
+LL |     permissions.set_mode(644);
+   |                          ^^^ help: consider using an octal literal instead: `0o644`
+
+error: using a non-octal value to set unix file permissions
+  --> $DIR/non_octal_unix_permissions.rs:31:18
+   |
+LL |     builder.mode(755);
+   |                  ^^^ help: consider using an octal literal instead: `0o755`
+
+error: aborting due to 4 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 45164de59fb09d8aec57ffe87a7ea7619daa2781 Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Wed, 31 Mar 2021 11:18:48 +0900
Subject: result_unit_err: Fix typo

---
 clippy_lints/src/functions/result_unit_err.rs |  4 ++--
 tests/ui/len_without_is_empty.stderr          | 16 ++++++++--------
 tests/ui/result_unit_error.stderr             | 20 ++++++++++----------
 3 files changed, 20 insertions(+), 20 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/functions/result_unit_err.rs b/clippy_lints/src/functions/result_unit_err.rs
index f71bfc690f6..3d1092ce21f 100644
--- a/clippy_lints/src/functions/result_unit_err.rs
+++ b/clippy_lints/src/functions/result_unit_err.rs
@@ -57,9 +57,9 @@ fn check_result_unit_err(cx: &LateContext<'_>, decl: &hir::FnDecl<'_>, item_span
                 cx,
                 RESULT_UNIT_ERR,
                 fn_header_span,
-                "this returns a `Result<_, ()>",
+                "this returns a `Result<_, ()>`",
                 None,
-                "use a custom Error type instead",
+                "use a custom `Error` type instead",
             );
         }
     }
diff --git a/tests/ui/len_without_is_empty.stderr b/tests/ui/len_without_is_empty.stderr
index ff7f5562308..3282709bcd6 100644
--- a/tests/ui/len_without_is_empty.stderr
+++ b/tests/ui/len_without_is_empty.stderr
@@ -86,38 +86,38 @@ LL |     pub fn is_empty(&self) -> Option<bool> {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    = note: expected signature: `(&self) -> bool` or `(&self) -> Result<bool>
 
-error: this returns a `Result<_, ()>
+error: this returns a `Result<_, ()>`
   --> $DIR/len_without_is_empty.rs:230:5
    |
 LL |     pub fn len(&self) -> Result<usize, ()> {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::result-unit-err` implied by `-D warnings`
-   = help: use a custom Error type instead
+   = help: use a custom `Error` type instead
 
-error: this returns a `Result<_, ()>
+error: this returns a `Result<_, ()>`
   --> $DIR/len_without_is_empty.rs:242:5
    |
 LL |     pub fn len(&self) -> Result<usize, ()> {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: use a custom Error type instead
+   = help: use a custom `Error` type instead
 
-error: this returns a `Result<_, ()>
+error: this returns a `Result<_, ()>`
   --> $DIR/len_without_is_empty.rs:246:5
    |
 LL |     pub fn is_empty(&self) -> Result<bool, ()> {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: use a custom Error type instead
+   = help: use a custom `Error` type instead
 
-error: this returns a `Result<_, ()>
+error: this returns a `Result<_, ()>`
   --> $DIR/len_without_is_empty.rs:253:5
    |
 LL |     pub fn len(&self) -> Result<usize, ()> {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: use a custom Error type instead
+   = help: use a custom `Error` type instead
 
 error: aborting due to 12 previous errors
 
diff --git a/tests/ui/result_unit_error.stderr b/tests/ui/result_unit_error.stderr
index 41d8b0a7cb7..8c7573eabda 100644
--- a/tests/ui/result_unit_error.stderr
+++ b/tests/ui/result_unit_error.stderr
@@ -1,43 +1,43 @@
-error: this returns a `Result<_, ()>
+error: this returns a `Result<_, ()>`
   --> $DIR/result_unit_error.rs:3:1
    |
 LL | pub fn returns_unit_error() -> Result<u32, ()> {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::result-unit-err` implied by `-D warnings`
-   = help: use a custom Error type instead
+   = help: use a custom `Error` type instead
 
-error: this returns a `Result<_, ()>
+error: this returns a `Result<_, ()>`
   --> $DIR/result_unit_error.rs:12:5
    |
 LL |     fn get_that_error(&self) -> Result<bool, ()>;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: use a custom Error type instead
+   = help: use a custom `Error` type instead
 
-error: this returns a `Result<_, ()>
+error: this returns a `Result<_, ()>`
   --> $DIR/result_unit_error.rs:14:5
    |
 LL |     fn get_this_one_too(&self) -> Result<bool, ()> {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: use a custom Error type instead
+   = help: use a custom `Error` type instead
 
-error: this returns a `Result<_, ()>
+error: this returns a `Result<_, ()>`
   --> $DIR/result_unit_error.rs:32:5
    |
 LL |     pub fn unit_error(&self) -> Result<usize, ()> {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: use a custom Error type instead
+   = help: use a custom `Error` type instead
 
-error: this returns a `Result<_, ()>
+error: this returns a `Result<_, ()>`
   --> $DIR/result_unit_error.rs:41:5
    |
 LL |     pub fn should_lint() -> ResInv<(), usize> {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: use a custom Error type instead
+   = help: use a custom `Error` type instead
 
 error: aborting due to 5 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 8abab5561caf0243799fba29a53e175948977ec2 Mon Sep 17 00:00:00 2001
From: Michael Wright <mikerite@lavabit.com>
Date: Sat, 27 Mar 2021 08:50:19 +0200
Subject: Fix hidden variant suggestion on single variant

Fixes #6984
---
 clippy_lints/src/lib.rs                           |  1 -
 clippy_lints/src/manual_non_exhaustive.rs         | 14 +++-----------
 clippy_lints/src/matches.rs                       |  7 ++++++-
 clippy_lints/src/missing_doc.rs                   | 11 ++---------
 clippy_utils/src/attrs.rs                         | 12 +++++++++++-
 tests/ui/match_wildcard_for_single_variants.fixed | 16 ++++++++++++++++
 tests/ui/match_wildcard_for_single_variants.rs    | 16 ++++++++++++++++
 7 files changed, 54 insertions(+), 23 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 153972671fd..c060429edea 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -21,7 +21,6 @@
 // (Currently there is no way to opt into sysroot crates without `extern crate`.)
 extern crate rustc_ast;
 extern crate rustc_ast_pretty;
-extern crate rustc_attr;
 extern crate rustc_data_structures;
 extern crate rustc_driver;
 extern crate rustc_errors;
diff --git a/clippy_lints/src/manual_non_exhaustive.rs b/clippy_lints/src/manual_non_exhaustive.rs
index 95261580b8e..7f7aeaf2be8 100644
--- a/clippy_lints/src/manual_non_exhaustive.rs
+++ b/clippy_lints/src/manual_non_exhaustive.rs
@@ -1,9 +1,9 @@
+use clippy_utils::attrs::is_doc_hidden;
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::meets_msrv;
 use clippy_utils::source::snippet_opt;
 use if_chain::if_chain;
-use rustc_ast::ast::{Attribute, FieldDef, Item, ItemKind, Variant, VariantData, VisibilityKind};
-use rustc_attr as attr;
+use rustc_ast::ast::{FieldDef, Item, ItemKind, Variant, VariantData, VisibilityKind};
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_semver::RustcVersion;
@@ -102,15 +102,7 @@ fn check_manual_non_exhaustive_enum(cx: &EarlyContext<'_>, item: &Item, variants
     fn is_non_exhaustive_marker(variant: &Variant) -> bool {
         matches!(variant.data, VariantData::Unit(_))
             && variant.ident.as_str().starts_with('_')
-            && variant.attrs.iter().any(|a| is_doc_hidden(a))
-    }
-
-    fn is_doc_hidden(attr: &Attribute) -> bool {
-        attr.has_name(sym::doc)
-            && match attr.meta_item_list() {
-                Some(l) => attr::list_contains_name(&l, sym::hidden),
-                None => false,
-            }
+            && is_doc_hidden(&variant.attrs)
     }
 
     if_chain! {
diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index 425124b78f4..052bbb48887 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -983,6 +983,11 @@ impl CommonPrefixSearcher<'a> {
     }
 }
 
+fn is_doc_hidden(cx: &LateContext<'_>, variant_def: &VariantDef) -> bool {
+    let attrs = cx.tcx.get_attrs(variant_def.def_id);
+    clippy_utils::attrs::is_doc_hidden(attrs)
+}
+
 #[allow(clippy::too_many_lines)]
 fn check_wild_enum_match(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>]) {
     let ty = cx.typeck_results().expr_ty(ex).peel_refs();
@@ -1102,7 +1107,7 @@ fn check_wild_enum_match(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>])
 
     match missing_variants.as_slice() {
         [] => (),
-        [x] if !adt_def.is_variant_list_non_exhaustive() => span_lint_and_sugg(
+        [x] if !adt_def.is_variant_list_non_exhaustive() && !is_doc_hidden(cx, x) => span_lint_and_sugg(
             cx,
             MATCH_WILDCARD_FOR_SINGLE_VARIANTS,
             wildcard_span,
diff --git a/clippy_lints/src/missing_doc.rs b/clippy_lints/src/missing_doc.rs
index ff87828c2e7..d731a9fe223 100644
--- a/clippy_lints/src/missing_doc.rs
+++ b/clippy_lints/src/missing_doc.rs
@@ -5,10 +5,10 @@
 // [`missing_doc`]: https://github.com/rust-lang/rust/blob/cf9cf7c923eb01146971429044f216a3ca905e06/compiler/rustc_lint/src/builtin.rs#L415
 //
 
+use clippy_utils::attrs::is_doc_hidden;
 use clippy_utils::diagnostics::span_lint;
 use if_chain::if_chain;
 use rustc_ast::ast::{self, MetaItem, MetaItemKind};
-use rustc_ast::attr;
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::ty;
@@ -111,14 +111,7 @@ impl_lint_pass!(MissingDoc => [MISSING_DOCS_IN_PRIVATE_ITEMS]);
 
 impl<'tcx> LateLintPass<'tcx> for MissingDoc {
     fn enter_lint_attrs(&mut self, _: &LateContext<'tcx>, attrs: &'tcx [ast::Attribute]) {
-        let doc_hidden = self.doc_hidden()
-            || attrs.iter().any(|attr| {
-                attr.has_name(sym::doc)
-                    && match attr.meta_item_list() {
-                        None => false,
-                        Some(l) => attr::list_contains_name(&l[..], sym::hidden),
-                    }
-            });
+        let doc_hidden = self.doc_hidden() || is_doc_hidden(attrs);
         self.doc_hidden_stack.push(doc_hidden);
     }
 
diff --git a/clippy_utils/src/attrs.rs b/clippy_utils/src/attrs.rs
index 8d28421d70d..7ec8452bf4c 100644
--- a/clippy_utils/src/attrs.rs
+++ b/clippy_utils/src/attrs.rs
@@ -1,4 +1,4 @@
-use rustc_ast::ast;
+use rustc_ast::{ast, attr};
 use rustc_errors::Applicability;
 use rustc_session::Session;
 use rustc_span::sym;
@@ -148,3 +148,13 @@ pub fn get_unique_inner_attr(sess: &Session, attrs: &[ast::Attribute], name: &'s
 pub fn is_proc_macro(sess: &Session, attrs: &[ast::Attribute]) -> bool {
     attrs.iter().any(|attr| sess.is_proc_macro_attr(attr))
 }
+
+/// Return true if the attributes contain `#[doc(hidden)]`
+pub fn is_doc_hidden(attrs: &[ast::Attribute]) -> bool {
+    #[allow(clippy::filter_map)]
+    attrs
+        .iter()
+        .filter(|attr| attr.has_name(sym::doc))
+        .flat_map(ast::Attribute::meta_item_list)
+        .any(|l| attr::list_contains_name(&l, sym::hidden))
+}
diff --git a/tests/ui/match_wildcard_for_single_variants.fixed b/tests/ui/match_wildcard_for_single_variants.fixed
index d99f9af3faf..31b743f7a18 100644
--- a/tests/ui/match_wildcard_for_single_variants.fixed
+++ b/tests/ui/match_wildcard_for_single_variants.fixed
@@ -108,4 +108,20 @@ fn main() {
         Bar::B => (),
         _ => (),
     };
+
+    //#6984
+    {
+        #![allow(clippy::manual_non_exhaustive)]
+        pub enum Enum {
+            A,
+            B,
+            #[doc(hidden)]
+            __Private,
+        }
+        match Enum::A {
+            Enum::A => (),
+            Enum::B => (),
+            _ => (),
+        }
+    }
 }
diff --git a/tests/ui/match_wildcard_for_single_variants.rs b/tests/ui/match_wildcard_for_single_variants.rs
index 1752a95de4b..d19e6ab7eb2 100644
--- a/tests/ui/match_wildcard_for_single_variants.rs
+++ b/tests/ui/match_wildcard_for_single_variants.rs
@@ -108,4 +108,20 @@ fn main() {
         Bar::B => (),
         _ => (),
     };
+
+    //#6984
+    {
+        #![allow(clippy::manual_non_exhaustive)]
+        pub enum Enum {
+            A,
+            B,
+            #[doc(hidden)]
+            __Private,
+        }
+        match Enum::A {
+            Enum::A => (),
+            Enum::B => (),
+            _ => (),
+        }
+    }
 }
-- 
cgit 1.4.1-3-g733a5


From 5029dc805fa1b8c58988cad119a45a6d51bcdaad Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Tue, 9 Feb 2021 00:24:23 +0900
Subject: New Lint: excessive_for_each

---
 CHANGELOG.md                                   |   1 +
 clippy_lints/src/iter_for_each.rs              |   0
 clippy_lints/src/lib.rs                        |   3 +
 clippy_lints/src/methods/excessive_for_each.rs | 149 +++++++++++++++++++++++++
 clippy_lints/src/methods/mod.rs                |  29 +++++
 tests/ui/excessive_for_each.rs                 |  96 ++++++++++++++++
 tests/ui/excessive_for_each.stderr             | 123 ++++++++++++++++++++
 7 files changed, 401 insertions(+)
 create mode 100644 clippy_lints/src/iter_for_each.rs
 create mode 100644 clippy_lints/src/methods/excessive_for_each.rs
 create mode 100644 tests/ui/excessive_for_each.rs
 create mode 100644 tests/ui/excessive_for_each.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 681ecd6832a..c35ab6c94bf 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2192,6 +2192,7 @@ Released 2018-09-13
 [`eq_op`]: https://rust-lang.github.io/rust-clippy/master/index.html#eq_op
 [`erasing_op`]: https://rust-lang.github.io/rust-clippy/master/index.html#erasing_op
 [`eval_order_dependence`]: https://rust-lang.github.io/rust-clippy/master/index.html#eval_order_dependence
+[`excessive_for_each`]: https://rust-lang.github.io/rust-clippy/master/index.html#excessive_for_each
 [`excessive_precision`]: https://rust-lang.github.io/rust-clippy/master/index.html#excessive_precision
 [`exhaustive_enums`]: https://rust-lang.github.io/rust-clippy/master/index.html#exhaustive_enums
 [`exhaustive_structs`]: https://rust-lang.github.io/rust-clippy/master/index.html#exhaustive_structs
diff --git a/clippy_lints/src/iter_for_each.rs b/clippy_lints/src/iter_for_each.rs
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index d37e229fb57..8fb3bfdafc9 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -781,6 +781,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &methods::CLONE_DOUBLE_REF,
         &methods::CLONE_ON_COPY,
         &methods::CLONE_ON_REF_PTR,
+        &methods::EXCESSIVE_FOR_EACH,
         &methods::EXPECT_FUN_CALL,
         &methods::EXPECT_USED,
         &methods::FILETYPE_IS_FILE,
@@ -1581,6 +1582,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&methods::CHARS_NEXT_CMP),
         LintId::of(&methods::CLONE_DOUBLE_REF),
         LintId::of(&methods::CLONE_ON_COPY),
+        LintId::of(&methods::EXCESSIVE_FOR_EACH),
         LintId::of(&methods::EXPECT_FUN_CALL),
         LintId::of(&methods::FILTER_MAP_IDENTITY),
         LintId::of(&methods::FILTER_NEXT),
@@ -1797,6 +1799,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&methods::BYTES_NTH),
         LintId::of(&methods::CHARS_LAST_CMP),
         LintId::of(&methods::CHARS_NEXT_CMP),
+        LintId::of(&methods::EXCESSIVE_FOR_EACH),
         LintId::of(&methods::FROM_ITER_INSTEAD_OF_COLLECT),
         LintId::of(&methods::INTO_ITER_ON_REF),
         LintId::of(&methods::ITER_CLONED_COLLECT),
diff --git a/clippy_lints/src/methods/excessive_for_each.rs b/clippy_lints/src/methods/excessive_for_each.rs
new file mode 100644
index 00000000000..36f92d5b95f
--- /dev/null
+++ b/clippy_lints/src/methods/excessive_for_each.rs
@@ -0,0 +1,149 @@
+use rustc_errors::Applicability;
+use rustc_hir::{
+    intravisit::{walk_expr, NestedVisitorMap, Visitor},
+    Expr, ExprKind,
+};
+use rustc_lint::LateContext;
+use rustc_middle::{hir::map::Map, ty, ty::Ty};
+use rustc_span::source_map::Span;
+
+use crate::utils::{match_trait_method, match_type, paths, snippet, span_lint_and_then};
+
+use if_chain::if_chain;
+
+pub(super) fn lint(cx: &LateContext<'_>, expr: &'tcx Expr<'_>, args: &[&[Expr<'_>]]) {
+    if args.len() < 2 {
+        return;
+    }
+
+    let for_each_args = args[0];
+    if for_each_args.len() < 2 {
+        return;
+    }
+    let for_each_receiver = &for_each_args[0];
+    let for_each_arg = &for_each_args[1];
+    let iter_receiver = &args[1][0];
+
+    if_chain! {
+        if match_trait_method(cx, expr, &paths::ITERATOR);
+        if !match_trait_method(cx, for_each_receiver, &paths::ITERATOR);
+        if is_target_ty(cx, cx.typeck_results().expr_ty(iter_receiver));
+        if let ExprKind::Closure(_, _, body_id, ..) = for_each_arg.kind;
+        then {
+            let body = cx.tcx.hir().body(body_id);
+            let mut ret_span_collector = RetSpanCollector::new();
+            ret_span_collector.visit_expr(&body.value);
+
+            let label = "'outer";
+            let loop_label = if ret_span_collector.need_label {
+                format!("{}: ", label)
+            } else {
+                "".to_string()
+            };
+            let sugg =
+                format!("{}for {} in {} {{ .. }}", loop_label, snippet(cx, body.params[0].pat.span, ""), snippet(cx, for_each_receiver.span, ""));
+
+            let mut notes = vec![];
+            for (span, need_label) in ret_span_collector.spans {
+                let cont_label = if need_label {
+                    format!(" {}", label)
+                } else {
+                    "".to_string()
+                };
+                let note = format!("change `return` to `continue{}` in the loop body", cont_label);
+                notes.push((span, note));
+            }
+
+            span_lint_and_then(cx,
+                      super::EXCESSIVE_FOR_EACH,
+                      expr.span,
+                      "excessive use of `for_each`",
+                      |diag| {
+                          diag.span_suggestion(expr.span, "try", sugg, Applicability::HasPlaceholders);
+                          for note in notes {
+                              diag.span_note(note.0, &note.1);
+                          }
+                      }
+                );
+        }
+    }
+}
+
+type PathSegment = &'static [&'static str];
+
+const TARGET_ITER_RECEIVER_TY: &[PathSegment] = &[
+    &paths::VEC,
+    &paths::VEC_DEQUE,
+    &paths::LINKED_LIST,
+    &paths::HASHMAP,
+    &paths::BTREEMAP,
+    &paths::HASHSET,
+    &paths::BTREESET,
+    &paths::BINARY_HEAP,
+];
+
+fn is_target_ty(cx: &LateContext<'_>, expr_ty: Ty<'_>) -> bool {
+    let expr_ty = expr_ty.peel_refs();
+    for target in TARGET_ITER_RECEIVER_TY {
+        if match_type(cx, expr_ty, target) {
+            return true;
+        }
+    }
+
+    if_chain! {
+        if matches!(expr_ty.kind(), ty::Slice(_) | ty::Array(..));
+        then {
+            return true;
+        }
+    }
+
+    false
+}
+
+/// Collect spans of `return` in the closure body.
+struct RetSpanCollector {
+    spans: Vec<(Span, bool)>,
+    loop_depth: u16,
+    need_label: bool,
+}
+
+impl RetSpanCollector {
+    fn new() -> Self {
+        Self {
+            spans: Vec::new(),
+            loop_depth: 0,
+            need_label: false,
+        }
+    }
+}
+
+impl<'tcx> Visitor<'tcx> for RetSpanCollector {
+    type Map = Map<'tcx>;
+
+    fn visit_expr(&mut self, expr: &Expr<'_>) {
+        match expr.kind {
+            ExprKind::Ret(..) => {
+                if self.loop_depth > 0 && !self.need_label {
+                    self.need_label = true
+                }
+
+                self.spans.push((expr.span, self.loop_depth > 0))
+            },
+
+            ExprKind::Loop(..) => {
+                self.loop_depth += 1;
+                walk_expr(self, expr);
+                self.loop_depth -= 1;
+                return;
+            },
+
+            _ => {},
+        }
+
+        walk_expr(self, expr);
+    }
+
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::None
+    }
+}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index fccdee07877..058140fddb8 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -974,6 +974,33 @@ declare_clippy_lint! {
     "using `.skip(x).next()` on an iterator"
 }
 
+declare_clippy_lint! {
+    /// **What it does:** Checks for use of `obj.method().for_each(closure)` if obj doesn't
+    /// implelement `Iterator` and `method()` returns `Impl Iterator` type.
+    ///
+    /// **Why is this bad?** Excessive use of `for_each` reduces redability, using `for` loop is
+    /// clearer and more concise.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// let v = vec![0, 1, 2];
+    /// v.iter().for_each(|elem| println!("{}", elem));
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// let v = vec![0, 1, 2];
+    /// for elem in v.iter() {
+    ///     println!("{}", elem);
+    /// }
+    /// ```
+    pub EXCESSIVE_FOR_EACH,
+    style,
+    "using `.iter().for_each(|x| {..})` when using `for` loop would work instead"
+}
+
 declare_clippy_lint! {
     /// **What it does:** Checks for use of `.get().unwrap()` (or
     /// `.get_mut().unwrap`) on a standard library type which implements `Index`
@@ -1661,6 +1688,7 @@ impl_lint_pass!(Methods => [
     ITER_NTH_ZERO,
     BYTES_NTH,
     ITER_SKIP_NEXT,
+    EXCESSIVE_FOR_EACH,
     GET_UNWRAP,
     STRING_EXTEND_CHARS,
     ITER_CLONED_COLLECT,
@@ -1807,6 +1835,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             ["to_os_string", ..] => implicit_clone::check(cx, expr, sym::OsStr),
             ["to_path_buf", ..] => implicit_clone::check(cx, expr, sym::Path),
             ["to_vec", ..] => implicit_clone::check(cx, expr, sym::slice),
+            ["for_each", ..] => excessive_for_each::lint(cx, expr, &arg_lists),
             _ => {},
         }
 
diff --git a/tests/ui/excessive_for_each.rs b/tests/ui/excessive_for_each.rs
new file mode 100644
index 00000000000..12c87782d97
--- /dev/null
+++ b/tests/ui/excessive_for_each.rs
@@ -0,0 +1,96 @@
+#![warn(clippy::excessive_for_each)]
+#![allow(clippy::needless_return)]
+
+use std::collections::*;
+
+fn main() {
+    // Should trigger this lint: Vec.
+    let vec: Vec<i32> = Vec::new();
+    vec.iter().for_each(|v| println!("{}", v));
+
+    // Should trigger this lint: &Vec.
+    let vec_ref = &vec;
+    vec_ref.iter().for_each(|v| println!("{}", v));
+
+    // Should trigger this lint: VecDeque.
+    let vec_deq: VecDeque<i32> = VecDeque::new();
+    vec_deq.iter().for_each(|v| println!("{}", v));
+
+    // Should trigger this lint: LinkedList.
+    let list: LinkedList<i32> = LinkedList::new();
+    list.iter().for_each(|v| println!("{}", v));
+
+    // Should trigger this lint: HashMap.
+    let mut hash_map: HashMap<i32, i32> = HashMap::new();
+    hash_map.iter().for_each(|(k, v)| println!("{}: {}", k, v));
+    hash_map.iter_mut().for_each(|(k, v)| println!("{}: {}", k, v));
+    hash_map.keys().for_each(|k| println!("{}", k));
+    hash_map.values().for_each(|v| println!("{}", v));
+
+    // Should trigger this lint: HashSet.
+    let hash_set: HashSet<i32> = HashSet::new();
+    hash_set.iter().for_each(|v| println!("{}", v));
+
+    // Should trigger this lint: BTreeSet.
+    let btree_set: BTreeSet<i32> = BTreeSet::new();
+    btree_set.iter().for_each(|v| println!("{}", v));
+
+    // Should trigger this lint: BinaryHeap.
+    let binary_heap: BinaryHeap<i32> = BinaryHeap::new();
+    binary_heap.iter().for_each(|v| println!("{}", v));
+
+    // Should trigger this lint: Array.
+    let s = [1, 2, 3];
+    s.iter().for_each(|v| println!("{}", v));
+
+    // Should trigger this lint. Slice.
+    vec.as_slice().iter().for_each(|v| println!("{}", v));
+
+    // Should trigger this lint with notes that say "change `return` to `continue`".
+    vec.iter().for_each(|v| {
+        if *v == 10 {
+            return;
+        } else {
+            println!("{}", v);
+        }
+    });
+
+    // Should trigger this lint with notes that say "change `return` to `continue 'outer`".
+    vec.iter().for_each(|v| {
+        for i in 0..*v {
+            if i == 10 {
+                return;
+            } else {
+                println!("{}", v);
+            }
+        }
+        if *v == 20 {
+            return;
+        } else {
+            println!("{}", v);
+        }
+    });
+
+    // Should NOT trigger this lint in case `for_each` follows long iterator chain.
+    vec.iter().chain(vec.iter()).for_each(|v| println!("{}", v));
+
+    // Should NOT trigger this lint in case a `for_each` argument is not closure.
+    fn print(x: &i32) {
+        println!("{}", x);
+    }
+    vec.iter().for_each(print);
+
+    // Should NOT trigger this lint in case the receiver of `iter` is a user defined type.
+    let my_collection = MyCollection { v: vec![] };
+    my_collection.iter().for_each(|v| println!("{}", v));
+}
+
+struct MyCollection {
+    v: Vec<i32>,
+}
+
+impl MyCollection {
+    fn iter(&self) -> impl Iterator<Item = &i32> {
+        self.v.iter()
+    }
+}
diff --git a/tests/ui/excessive_for_each.stderr b/tests/ui/excessive_for_each.stderr
new file mode 100644
index 00000000000..026b14a5899
--- /dev/null
+++ b/tests/ui/excessive_for_each.stderr
@@ -0,0 +1,123 @@
+error: excessive use of `for_each`
+  --> $DIR/excessive_for_each.rs:9:5
+   |
+LL |     vec.iter().for_each(|v| println!("{}", v));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for v in vec.iter() { .. }`
+   |
+   = note: `-D clippy::excessive-for-each` implied by `-D warnings`
+
+error: excessive use of `for_each`
+  --> $DIR/excessive_for_each.rs:13:5
+   |
+LL |     vec_ref.iter().for_each(|v| println!("{}", v));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for v in vec_ref.iter() { .. }`
+
+error: excessive use of `for_each`
+  --> $DIR/excessive_for_each.rs:17:5
+   |
+LL |     vec_deq.iter().for_each(|v| println!("{}", v));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for v in vec_deq.iter() { .. }`
+
+error: excessive use of `for_each`
+  --> $DIR/excessive_for_each.rs:21:5
+   |
+LL |     list.iter().for_each(|v| println!("{}", v));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for v in list.iter() { .. }`
+
+error: excessive use of `for_each`
+  --> $DIR/excessive_for_each.rs:25:5
+   |
+LL |     hash_map.iter().for_each(|(k, v)| println!("{}: {}", k, v));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for (k, v) in hash_map.iter() { .. }`
+
+error: excessive use of `for_each`
+  --> $DIR/excessive_for_each.rs:26:5
+   |
+LL |     hash_map.iter_mut().for_each(|(k, v)| println!("{}: {}", k, v));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for (k, v) in hash_map.iter_mut() { .. }`
+
+error: excessive use of `for_each`
+  --> $DIR/excessive_for_each.rs:27:5
+   |
+LL |     hash_map.keys().for_each(|k| println!("{}", k));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for k in hash_map.keys() { .. }`
+
+error: excessive use of `for_each`
+  --> $DIR/excessive_for_each.rs:28:5
+   |
+LL |     hash_map.values().for_each(|v| println!("{}", v));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for v in hash_map.values() { .. }`
+
+error: excessive use of `for_each`
+  --> $DIR/excessive_for_each.rs:32:5
+   |
+LL |     hash_set.iter().for_each(|v| println!("{}", v));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for v in hash_set.iter() { .. }`
+
+error: excessive use of `for_each`
+  --> $DIR/excessive_for_each.rs:36:5
+   |
+LL |     btree_set.iter().for_each(|v| println!("{}", v));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for v in btree_set.iter() { .. }`
+
+error: excessive use of `for_each`
+  --> $DIR/excessive_for_each.rs:40:5
+   |
+LL |     binary_heap.iter().for_each(|v| println!("{}", v));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for v in binary_heap.iter() { .. }`
+
+error: excessive use of `for_each`
+  --> $DIR/excessive_for_each.rs:44:5
+   |
+LL |     s.iter().for_each(|v| println!("{}", v));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for v in s.iter() { .. }`
+
+error: excessive use of `for_each`
+  --> $DIR/excessive_for_each.rs:47:5
+   |
+LL |     vec.as_slice().iter().for_each(|v| println!("{}", v));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for v in vec.as_slice().iter() { .. }`
+
+error: excessive use of `for_each`
+  --> $DIR/excessive_for_each.rs:50:5
+   |
+LL | /     vec.iter().for_each(|v| {
+LL | |         if *v == 10 {
+LL | |             return;
+LL | |         } else {
+LL | |             println!("{}", v);
+LL | |         }
+LL | |     });
+   | |______^ help: try: `for v in vec.iter() { .. }`
+   |
+note: change `return` to `continue` in the loop body
+  --> $DIR/excessive_for_each.rs:52:13
+   |
+LL |             return;
+   |             ^^^^^^
+
+error: excessive use of `for_each`
+  --> $DIR/excessive_for_each.rs:59:5
+   |
+LL | /     vec.iter().for_each(|v| {
+LL | |         for i in 0..*v {
+LL | |             if i == 10 {
+LL | |                 return;
+...  |
+LL | |         }
+LL | |     });
+   | |______^ help: try: `'outer: for v in vec.iter() { .. }`
+   |
+note: change `return` to `continue 'outer` in the loop body
+  --> $DIR/excessive_for_each.rs:62:17
+   |
+LL |                 return;
+   |                 ^^^^^^
+note: change `return` to `continue` in the loop body
+  --> $DIR/excessive_for_each.rs:68:13
+   |
+LL |             return;
+   |             ^^^^^^
+
+error: aborting due to 15 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 30952530c502acbfc40853f0392853469ece8024 Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Tue, 9 Feb 2021 21:20:42 +0900
Subject: Fix codes that fails dogfood

---
 clippy_lints/src/matches.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index 425124b78f4..8c6c30a1881 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -924,7 +924,7 @@ fn check_wild_err_arm<'tcx>(cx: &LateContext<'tcx>, ex: &Expr<'tcx>, arms: &[Arm
                     let mut ident_bind_name = String::from("_");
                     if !matching_wild {
                         // Looking for unused bindings (i.e.: `_e`)
-                        inner.iter().for_each(|pat| {
+                        for pat in inner.iter() {
                             if let PatKind::Binding(_, id, ident, None) = pat.kind {
                                 if ident.as_str().starts_with('_')
                                     && !LocalUsedVisitor::new(cx, id).check_expr(arm.body)
@@ -933,7 +933,7 @@ fn check_wild_err_arm<'tcx>(cx: &LateContext<'tcx>, ex: &Expr<'tcx>, arms: &[Arm
                                     matching_wild = true;
                                 }
                             }
-                        });
+                        }
                     }
                     if_chain! {
                         if matching_wild;
-- 
cgit 1.4.1-3-g733a5


From 54a04711edb15ad0ce5e19f833a5172f651bb4c0 Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Tue, 9 Feb 2021 23:36:20 +0900
Subject: Change a category of excessive_for_each: Style -> Restriction

---
 clippy_lints/src/lib.rs                        | 3 +--
 clippy_lints/src/methods/excessive_for_each.rs | 1 -
 clippy_lints/src/methods/mod.rs                | 2 +-
 3 files changed, 2 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 8fb3bfdafc9..2f2ccdb310a 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1314,6 +1314,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&matches::WILDCARD_ENUM_MATCH_ARM),
         LintId::of(&mem_forget::MEM_FORGET),
         LintId::of(&methods::CLONE_ON_REF_PTR),
+        LintId::of(&methods::EXCESSIVE_FOR_EACH),
         LintId::of(&methods::EXPECT_USED),
         LintId::of(&methods::FILETYPE_IS_FILE),
         LintId::of(&methods::GET_UNWRAP),
@@ -1582,7 +1583,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&methods::CHARS_NEXT_CMP),
         LintId::of(&methods::CLONE_DOUBLE_REF),
         LintId::of(&methods::CLONE_ON_COPY),
-        LintId::of(&methods::EXCESSIVE_FOR_EACH),
         LintId::of(&methods::EXPECT_FUN_CALL),
         LintId::of(&methods::FILTER_MAP_IDENTITY),
         LintId::of(&methods::FILTER_NEXT),
@@ -1799,7 +1799,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&methods::BYTES_NTH),
         LintId::of(&methods::CHARS_LAST_CMP),
         LintId::of(&methods::CHARS_NEXT_CMP),
-        LintId::of(&methods::EXCESSIVE_FOR_EACH),
         LintId::of(&methods::FROM_ITER_INSTEAD_OF_COLLECT),
         LintId::of(&methods::INTO_ITER_ON_REF),
         LintId::of(&methods::ITER_CLONED_COLLECT),
diff --git a/clippy_lints/src/methods/excessive_for_each.rs b/clippy_lints/src/methods/excessive_for_each.rs
index 36f92d5b95f..6b3a11044f0 100644
--- a/clippy_lints/src/methods/excessive_for_each.rs
+++ b/clippy_lints/src/methods/excessive_for_each.rs
@@ -26,7 +26,6 @@ pub(super) fn lint(cx: &LateContext<'_>, expr: &'tcx Expr<'_>, args: &[&[Expr<'_
 
     if_chain! {
         if match_trait_method(cx, expr, &paths::ITERATOR);
-        if !match_trait_method(cx, for_each_receiver, &paths::ITERATOR);
         if is_target_ty(cx, cx.typeck_results().expr_ty(iter_receiver));
         if let ExprKind::Closure(_, _, body_id, ..) = for_each_arg.kind;
         then {
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 058140fddb8..344c7f1bd9a 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -997,7 +997,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     pub EXCESSIVE_FOR_EACH,
-    style,
+    restriction,
     "using `.iter().for_each(|x| {..})` when using `for` loop would work instead"
 }
 
-- 
cgit 1.4.1-3-g733a5


From 5bb0f16552e8eab45025c7f4581b8ae5edca3219 Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Wed, 10 Feb 2021 00:53:53 +0900
Subject: Trigger the lint iff exposure's body is ExprKind::Block.

---
 clippy_lints/src/methods/excessive_for_each.rs |   3 +-
 tests/ui/excessive_for_each.rs                 |  56 +++++++++---
 tests/ui/excessive_for_each.stderr             | 114 +++++++++++++++----------
 3 files changed, 115 insertions(+), 58 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/excessive_for_each.rs b/clippy_lints/src/methods/excessive_for_each.rs
index 6b3a11044f0..f3e9e2400f1 100644
--- a/clippy_lints/src/methods/excessive_for_each.rs
+++ b/clippy_lints/src/methods/excessive_for_each.rs
@@ -28,8 +28,9 @@ pub(super) fn lint(cx: &LateContext<'_>, expr: &'tcx Expr<'_>, args: &[&[Expr<'_
         if match_trait_method(cx, expr, &paths::ITERATOR);
         if is_target_ty(cx, cx.typeck_results().expr_ty(iter_receiver));
         if let ExprKind::Closure(_, _, body_id, ..) = for_each_arg.kind;
+        let body = cx.tcx.hir().body(body_id);
+        if let ExprKind::Block(..) = body.value.kind;
         then {
-            let body = cx.tcx.hir().body(body_id);
             let mut ret_span_collector = RetSpanCollector::new();
             ret_span_collector.visit_expr(&body.value);
 
diff --git a/tests/ui/excessive_for_each.rs b/tests/ui/excessive_for_each.rs
index 12c87782d97..1c8e450398e 100644
--- a/tests/ui/excessive_for_each.rs
+++ b/tests/ui/excessive_for_each.rs
@@ -6,45 +6,72 @@ use std::collections::*;
 fn main() {
     // Should trigger this lint: Vec.
     let vec: Vec<i32> = Vec::new();
-    vec.iter().for_each(|v| println!("{}", v));
+    let mut acc = 0;
+    vec.iter().for_each(|v| {
+        acc += v;
+    });
 
     // Should trigger this lint: &Vec.
     let vec_ref = &vec;
-    vec_ref.iter().for_each(|v| println!("{}", v));
+    vec_ref.iter().for_each(|v| {
+        acc += v;
+    });
 
     // Should trigger this lint: VecDeque.
     let vec_deq: VecDeque<i32> = VecDeque::new();
-    vec_deq.iter().for_each(|v| println!("{}", v));
+    vec_deq.iter().for_each(|v| {
+        acc += v;
+    });
 
     // Should trigger this lint: LinkedList.
     let list: LinkedList<i32> = LinkedList::new();
-    list.iter().for_each(|v| println!("{}", v));
+    list.iter().for_each(|v| {
+        acc += v;
+    });
 
     // Should trigger this lint: HashMap.
     let mut hash_map: HashMap<i32, i32> = HashMap::new();
-    hash_map.iter().for_each(|(k, v)| println!("{}: {}", k, v));
-    hash_map.iter_mut().for_each(|(k, v)| println!("{}: {}", k, v));
-    hash_map.keys().for_each(|k| println!("{}", k));
-    hash_map.values().for_each(|v| println!("{}", v));
+    hash_map.iter().for_each(|(k, v)| {
+        acc += k + v;
+    });
+    hash_map.iter_mut().for_each(|(k, v)| {
+        acc += *k + *v;
+    });
+    hash_map.keys().for_each(|k| {
+        acc += k;
+    });
+    hash_map.values().for_each(|v| {
+        acc += v;
+    });
 
     // Should trigger this lint: HashSet.
     let hash_set: HashSet<i32> = HashSet::new();
-    hash_set.iter().for_each(|v| println!("{}", v));
+    hash_set.iter().for_each(|v| {
+        acc += v;
+    });
 
     // Should trigger this lint: BTreeSet.
     let btree_set: BTreeSet<i32> = BTreeSet::new();
-    btree_set.iter().for_each(|v| println!("{}", v));
+    btree_set.iter().for_each(|v| {
+        acc += v;
+    });
 
     // Should trigger this lint: BinaryHeap.
     let binary_heap: BinaryHeap<i32> = BinaryHeap::new();
-    binary_heap.iter().for_each(|v| println!("{}", v));
+    binary_heap.iter().for_each(|v| {
+        acc += v;
+    });
 
     // Should trigger this lint: Array.
     let s = [1, 2, 3];
-    s.iter().for_each(|v| println!("{}", v));
+    s.iter().for_each(|v| {
+        acc += v;
+    });
 
     // Should trigger this lint. Slice.
-    vec.as_slice().iter().for_each(|v| println!("{}", v));
+    vec.as_slice().iter().for_each(|v| {
+        acc += v;
+    });
 
     // Should trigger this lint with notes that say "change `return` to `continue`".
     vec.iter().for_each(|v| {
@@ -83,6 +110,9 @@ fn main() {
     // Should NOT trigger this lint in case the receiver of `iter` is a user defined type.
     let my_collection = MyCollection { v: vec![] };
     my_collection.iter().for_each(|v| println!("{}", v));
+
+    // Should NOT trigger this lint in case the closure body is not a `ExprKind::Block`.
+    vec.iter().for_each(|x| acc += x);
 }
 
 struct MyCollection {
diff --git a/tests/ui/excessive_for_each.stderr b/tests/ui/excessive_for_each.stderr
index 026b14a5899..c4b66e3a034 100644
--- a/tests/ui/excessive_for_each.stderr
+++ b/tests/ui/excessive_for_each.stderr
@@ -1,85 +1,111 @@
 error: excessive use of `for_each`
-  --> $DIR/excessive_for_each.rs:9:5
+  --> $DIR/excessive_for_each.rs:10:5
    |
-LL |     vec.iter().for_each(|v| println!("{}", v));
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for v in vec.iter() { .. }`
+LL | /     vec.iter().for_each(|v| {
+LL | |         acc += v;
+LL | |     });
+   | |______^ help: try: `for v in vec.iter() { .. }`
    |
    = note: `-D clippy::excessive-for-each` implied by `-D warnings`
 
 error: excessive use of `for_each`
-  --> $DIR/excessive_for_each.rs:13:5
+  --> $DIR/excessive_for_each.rs:16:5
    |
-LL |     vec_ref.iter().for_each(|v| println!("{}", v));
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for v in vec_ref.iter() { .. }`
+LL | /     vec_ref.iter().for_each(|v| {
+LL | |         acc += v;
+LL | |     });
+   | |______^ help: try: `for v in vec_ref.iter() { .. }`
 
 error: excessive use of `for_each`
-  --> $DIR/excessive_for_each.rs:17:5
+  --> $DIR/excessive_for_each.rs:22:5
    |
-LL |     vec_deq.iter().for_each(|v| println!("{}", v));
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for v in vec_deq.iter() { .. }`
+LL | /     vec_deq.iter().for_each(|v| {
+LL | |         acc += v;
+LL | |     });
+   | |______^ help: try: `for v in vec_deq.iter() { .. }`
 
 error: excessive use of `for_each`
-  --> $DIR/excessive_for_each.rs:21:5
+  --> $DIR/excessive_for_each.rs:28:5
    |
-LL |     list.iter().for_each(|v| println!("{}", v));
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for v in list.iter() { .. }`
+LL | /     list.iter().for_each(|v| {
+LL | |         acc += v;
+LL | |     });
+   | |______^ help: try: `for v in list.iter() { .. }`
 
 error: excessive use of `for_each`
-  --> $DIR/excessive_for_each.rs:25:5
+  --> $DIR/excessive_for_each.rs:34:5
    |
-LL |     hash_map.iter().for_each(|(k, v)| println!("{}: {}", k, v));
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for (k, v) in hash_map.iter() { .. }`
+LL | /     hash_map.iter().for_each(|(k, v)| {
+LL | |         acc += k + v;
+LL | |     });
+   | |______^ help: try: `for (k, v) in hash_map.iter() { .. }`
 
 error: excessive use of `for_each`
-  --> $DIR/excessive_for_each.rs:26:5
+  --> $DIR/excessive_for_each.rs:37:5
    |
-LL |     hash_map.iter_mut().for_each(|(k, v)| println!("{}: {}", k, v));
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for (k, v) in hash_map.iter_mut() { .. }`
+LL | /     hash_map.iter_mut().for_each(|(k, v)| {
+LL | |         acc += *k + *v;
+LL | |     });
+   | |______^ help: try: `for (k, v) in hash_map.iter_mut() { .. }`
 
 error: excessive use of `for_each`
-  --> $DIR/excessive_for_each.rs:27:5
+  --> $DIR/excessive_for_each.rs:40:5
    |
-LL |     hash_map.keys().for_each(|k| println!("{}", k));
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for k in hash_map.keys() { .. }`
+LL | /     hash_map.keys().for_each(|k| {
+LL | |         acc += k;
+LL | |     });
+   | |______^ help: try: `for k in hash_map.keys() { .. }`
 
 error: excessive use of `for_each`
-  --> $DIR/excessive_for_each.rs:28:5
+  --> $DIR/excessive_for_each.rs:43:5
    |
-LL |     hash_map.values().for_each(|v| println!("{}", v));
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for v in hash_map.values() { .. }`
+LL | /     hash_map.values().for_each(|v| {
+LL | |         acc += v;
+LL | |     });
+   | |______^ help: try: `for v in hash_map.values() { .. }`
 
 error: excessive use of `for_each`
-  --> $DIR/excessive_for_each.rs:32:5
+  --> $DIR/excessive_for_each.rs:49:5
    |
-LL |     hash_set.iter().for_each(|v| println!("{}", v));
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for v in hash_set.iter() { .. }`
+LL | /     hash_set.iter().for_each(|v| {
+LL | |         acc += v;
+LL | |     });
+   | |______^ help: try: `for v in hash_set.iter() { .. }`
 
 error: excessive use of `for_each`
-  --> $DIR/excessive_for_each.rs:36:5
+  --> $DIR/excessive_for_each.rs:55:5
    |
-LL |     btree_set.iter().for_each(|v| println!("{}", v));
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for v in btree_set.iter() { .. }`
+LL | /     btree_set.iter().for_each(|v| {
+LL | |         acc += v;
+LL | |     });
+   | |______^ help: try: `for v in btree_set.iter() { .. }`
 
 error: excessive use of `for_each`
-  --> $DIR/excessive_for_each.rs:40:5
+  --> $DIR/excessive_for_each.rs:61:5
    |
-LL |     binary_heap.iter().for_each(|v| println!("{}", v));
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for v in binary_heap.iter() { .. }`
+LL | /     binary_heap.iter().for_each(|v| {
+LL | |         acc += v;
+LL | |     });
+   | |______^ help: try: `for v in binary_heap.iter() { .. }`
 
 error: excessive use of `for_each`
-  --> $DIR/excessive_for_each.rs:44:5
+  --> $DIR/excessive_for_each.rs:67:5
    |
-LL |     s.iter().for_each(|v| println!("{}", v));
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for v in s.iter() { .. }`
+LL | /     s.iter().for_each(|v| {
+LL | |         acc += v;
+LL | |     });
+   | |______^ help: try: `for v in s.iter() { .. }`
 
 error: excessive use of `for_each`
-  --> $DIR/excessive_for_each.rs:47:5
+  --> $DIR/excessive_for_each.rs:72:5
    |
-LL |     vec.as_slice().iter().for_each(|v| println!("{}", v));
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for v in vec.as_slice().iter() { .. }`
+LL | /     vec.as_slice().iter().for_each(|v| {
+LL | |         acc += v;
+LL | |     });
+   | |______^ help: try: `for v in vec.as_slice().iter() { .. }`
 
 error: excessive use of `for_each`
-  --> $DIR/excessive_for_each.rs:50:5
+  --> $DIR/excessive_for_each.rs:77:5
    |
 LL | /     vec.iter().for_each(|v| {
 LL | |         if *v == 10 {
@@ -91,13 +117,13 @@ LL | |     });
    | |______^ help: try: `for v in vec.iter() { .. }`
    |
 note: change `return` to `continue` in the loop body
-  --> $DIR/excessive_for_each.rs:52:13
+  --> $DIR/excessive_for_each.rs:79:13
    |
 LL |             return;
    |             ^^^^^^
 
 error: excessive use of `for_each`
-  --> $DIR/excessive_for_each.rs:59:5
+  --> $DIR/excessive_for_each.rs:86:5
    |
 LL | /     vec.iter().for_each(|v| {
 LL | |         for i in 0..*v {
@@ -109,12 +135,12 @@ LL | |     });
    | |______^ help: try: `'outer: for v in vec.iter() { .. }`
    |
 note: change `return` to `continue 'outer` in the loop body
-  --> $DIR/excessive_for_each.rs:62:17
+  --> $DIR/excessive_for_each.rs:89:17
    |
 LL |                 return;
    |                 ^^^^^^
 note: change `return` to `continue` in the loop body
-  --> $DIR/excessive_for_each.rs:68:13
+  --> $DIR/excessive_for_each.rs:95:13
    |
 LL |             return;
    |             ^^^^^^
-- 
cgit 1.4.1-3-g733a5


From 90cbbb2da3989a437a36c075396331f81a0e3b30 Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Thu, 11 Feb 2021 12:50:20 +0900
Subject: Avoid to suggest using label

---
 clippy_lints/src/methods/excessive_for_each.rs | 51 ++++++++++++--------------
 tests/ui/excessive_for_each.rs                 |  2 +-
 tests/ui/excessive_for_each.stderr             | 25 +------------
 3 files changed, 26 insertions(+), 52 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/excessive_for_each.rs b/clippy_lints/src/methods/excessive_for_each.rs
index f3e9e2400f1..e1440e68327 100644
--- a/clippy_lints/src/methods/excessive_for_each.rs
+++ b/clippy_lints/src/methods/excessive_for_each.rs
@@ -31,26 +31,20 @@ pub(super) fn lint(cx: &LateContext<'_>, expr: &'tcx Expr<'_>, args: &[&[Expr<'_
         let body = cx.tcx.hir().body(body_id);
         if let ExprKind::Block(..) = body.value.kind;
         then {
-            let mut ret_span_collector = RetSpanCollector::new();
-            ret_span_collector.visit_expr(&body.value);
-
-            let label = "'outer";
-            let loop_label = if ret_span_collector.need_label {
-                format!("{}: ", label)
-            } else {
-                "".to_string()
-            };
+            let mut ret_collector = RetCollector::new();
+            ret_collector.visit_expr(&body.value);
+
+            // Skip the lint if `return` is used in `Loop` to avoid a suggest using `'label`.
+            if ret_collector.ret_in_loop {
+                return;
+            }
+
             let sugg =
-                format!("{}for {} in {} {{ .. }}", loop_label, snippet(cx, body.params[0].pat.span, ""), snippet(cx, for_each_receiver.span, ""));
+                format!("for {} in {} {{ .. }}", snippet(cx, body.params[0].pat.span, ""), snippet(cx, for_each_receiver.span, ""));
 
             let mut notes = vec![];
-            for (span, need_label) in ret_span_collector.spans {
-                let cont_label = if need_label {
-                    format!(" {}", label)
-                } else {
-                    "".to_string()
-                };
-                let note = format!("change `return` to `continue{}` in the loop body", cont_label);
+            for span in ret_collector.spans {
+                let note = format!("change `return` to `continue` in the loop body");
                 notes.push((span, note));
             }
 
@@ -100,34 +94,37 @@ fn is_target_ty(cx: &LateContext<'_>, expr_ty: Ty<'_>) -> bool {
     false
 }
 
-/// Collect spans of `return` in the closure body.
-struct RetSpanCollector {
-    spans: Vec<(Span, bool)>,
+/// This type plays two roles.
+/// 1. Collect spans of `return` in the closure body.
+/// 2. Detect use of `return` in `Loop` in the closure body.
+struct RetCollector {
+    spans: Vec<Span>,
+    ret_in_loop: bool,
+
     loop_depth: u16,
-    need_label: bool,
 }
 
-impl RetSpanCollector {
+impl RetCollector {
     fn new() -> Self {
         Self {
             spans: Vec::new(),
+            ret_in_loop: false,
             loop_depth: 0,
-            need_label: false,
         }
     }
 }
 
-impl<'tcx> Visitor<'tcx> for RetSpanCollector {
+impl<'tcx> Visitor<'tcx> for RetCollector {
     type Map = Map<'tcx>;
 
     fn visit_expr(&mut self, expr: &Expr<'_>) {
         match expr.kind {
             ExprKind::Ret(..) => {
-                if self.loop_depth > 0 && !self.need_label {
-                    self.need_label = true
+                if self.loop_depth > 0 && !self.ret_in_loop {
+                    self.ret_in_loop = true
                 }
 
-                self.spans.push((expr.span, self.loop_depth > 0))
+                self.spans.push(expr.span)
             },
 
             ExprKind::Loop(..) => {
diff --git a/tests/ui/excessive_for_each.rs b/tests/ui/excessive_for_each.rs
index 1c8e450398e..0800bef71e9 100644
--- a/tests/ui/excessive_for_each.rs
+++ b/tests/ui/excessive_for_each.rs
@@ -82,7 +82,7 @@ fn main() {
         }
     });
 
-    // Should trigger this lint with notes that say "change `return` to `continue 'outer`".
+    // Should NOT trigger this lint in case `return` is used in `Loop` of the closure.
     vec.iter().for_each(|v| {
         for i in 0..*v {
             if i == 10 {
diff --git a/tests/ui/excessive_for_each.stderr b/tests/ui/excessive_for_each.stderr
index c4b66e3a034..f5799484e03 100644
--- a/tests/ui/excessive_for_each.stderr
+++ b/tests/ui/excessive_for_each.stderr
@@ -122,28 +122,5 @@ note: change `return` to `continue` in the loop body
 LL |             return;
    |             ^^^^^^
 
-error: excessive use of `for_each`
-  --> $DIR/excessive_for_each.rs:86:5
-   |
-LL | /     vec.iter().for_each(|v| {
-LL | |         for i in 0..*v {
-LL | |             if i == 10 {
-LL | |                 return;
-...  |
-LL | |         }
-LL | |     });
-   | |______^ help: try: `'outer: for v in vec.iter() { .. }`
-   |
-note: change `return` to `continue 'outer` in the loop body
-  --> $DIR/excessive_for_each.rs:89:17
-   |
-LL |                 return;
-   |                 ^^^^^^
-note: change `return` to `continue` in the loop body
-  --> $DIR/excessive_for_each.rs:95:13
-   |
-LL |             return;
-   |             ^^^^^^
-
-error: aborting due to 15 previous errors
+error: aborting due to 14 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From ccd7a600233ead22a77e024503edf4ef679c1751 Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Mon, 22 Feb 2021 21:41:38 +0900
Subject: Refactor: Remove duplicated codes from excessive_for_each

---
 clippy_lints/src/methods/excessive_for_each.rs | 81 ++++++++------------------
 1 file changed, 25 insertions(+), 56 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/excessive_for_each.rs b/clippy_lints/src/methods/excessive_for_each.rs
index e1440e68327..14aef0e99d5 100644
--- a/clippy_lints/src/methods/excessive_for_each.rs
+++ b/clippy_lints/src/methods/excessive_for_each.rs
@@ -4,13 +4,15 @@ use rustc_hir::{
     Expr, ExprKind,
 };
 use rustc_lint::LateContext;
-use rustc_middle::{hir::map::Map, ty, ty::Ty};
+use rustc_middle::hir::map::Map;
 use rustc_span::source_map::Span;
 
-use crate::utils::{match_trait_method, match_type, paths, snippet, span_lint_and_then};
-
 use if_chain::if_chain;
 
+use crate::utils::{has_iter_method, match_trait_method, paths, snippet, span_lint_and_then};
+
+use super::EXCESSIVE_FOR_EACH;
+
 pub(super) fn lint(cx: &LateContext<'_>, expr: &'tcx Expr<'_>, args: &[&[Expr<'_>]]) {
     if args.len() < 2 {
         return;
@@ -25,8 +27,8 @@ pub(super) fn lint(cx: &LateContext<'_>, expr: &'tcx Expr<'_>, args: &[&[Expr<'_
     let iter_receiver = &args[1][0];
 
     if_chain! {
+        if has_iter_method(cx, cx.typeck_results().expr_ty(iter_receiver)).is_some();
         if match_trait_method(cx, expr, &paths::ITERATOR);
-        if is_target_ty(cx, cx.typeck_results().expr_ty(iter_receiver));
         if let ExprKind::Closure(_, _, body_id, ..) = for_each_arg.kind;
         let body = cx.tcx.hir().body(body_id);
         if let ExprKind::Block(..) = body.value.kind;
@@ -34,64 +36,31 @@ pub(super) fn lint(cx: &LateContext<'_>, expr: &'tcx Expr<'_>, args: &[&[Expr<'_
             let mut ret_collector = RetCollector::new();
             ret_collector.visit_expr(&body.value);
 
-            // Skip the lint if `return` is used in `Loop` to avoid a suggest using `'label`.
+            // Skip the lint if `return` is used in `Loop` in order not to suggest using `'label`.
             if ret_collector.ret_in_loop {
                 return;
             }
 
-            let sugg =
-                format!("for {} in {} {{ .. }}", snippet(cx, body.params[0].pat.span, ""), snippet(cx, for_each_receiver.span, ""));
-
-            let mut notes = vec![];
-            for span in ret_collector.spans {
-                let note = format!("change `return` to `continue` in the loop body");
-                notes.push((span, note));
-            }
-
-            span_lint_and_then(cx,
-                      super::EXCESSIVE_FOR_EACH,
-                      expr.span,
-                      "excessive use of `for_each`",
-                      |diag| {
-                          diag.span_suggestion(expr.span, "try", sugg, Applicability::HasPlaceholders);
-                          for note in notes {
-                              diag.span_note(note.0, &note.1);
-                          }
-                      }
-                );
-        }
-    }
-}
-
-type PathSegment = &'static [&'static str];
-
-const TARGET_ITER_RECEIVER_TY: &[PathSegment] = &[
-    &paths::VEC,
-    &paths::VEC_DEQUE,
-    &paths::LINKED_LIST,
-    &paths::HASHMAP,
-    &paths::BTREEMAP,
-    &paths::HASHSET,
-    &paths::BTREESET,
-    &paths::BINARY_HEAP,
-];
-
-fn is_target_ty(cx: &LateContext<'_>, expr_ty: Ty<'_>) -> bool {
-    let expr_ty = expr_ty.peel_refs();
-    for target in TARGET_ITER_RECEIVER_TY {
-        if match_type(cx, expr_ty, target) {
-            return true;
-        }
-    }
-
-    if_chain! {
-        if matches!(expr_ty.kind(), ty::Slice(_) | ty::Array(..));
-        then {
-            return true;
+            let sugg = format!(
+                "for {} in {} {{ .. }}",
+                snippet(cx, body.params[0].pat.span, ""),
+                snippet(cx, for_each_receiver.span, "")
+            );
+
+            span_lint_and_then(
+                cx,
+                EXCESSIVE_FOR_EACH,
+                expr.span,
+                "excessive use of `for_each`",
+                |diag| {
+                    diag.span_suggestion(expr.span, "try", sugg, Applicability::HasPlaceholders);
+                    for span in ret_collector.spans {
+                        diag.span_note(span, "change `return` to `continue` in the loop body");
+                    }
+                }
+            )
         }
     }
-
-    false
 }
 
 /// This type plays two roles.
-- 
cgit 1.4.1-3-g733a5


From 25d8b94cecf5f7d17fc1d3d6140b62ae2f910b56 Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Tue, 23 Feb 2021 21:55:00 +0900
Subject: Add comments to clarify why RetCollector is needed

---
 clippy_lints/src/methods/excessive_for_each.rs | 7 +++++++
 1 file changed, 7 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/excessive_for_each.rs b/clippy_lints/src/methods/excessive_for_each.rs
index 14aef0e99d5..470f4ea2204 100644
--- a/clippy_lints/src/methods/excessive_for_each.rs
+++ b/clippy_lints/src/methods/excessive_for_each.rs
@@ -66,6 +66,13 @@ pub(super) fn lint(cx: &LateContext<'_>, expr: &'tcx Expr<'_>, args: &[&[Expr<'_
 /// This type plays two roles.
 /// 1. Collect spans of `return` in the closure body.
 /// 2. Detect use of `return` in `Loop` in the closure body.
+///
+/// NOTE: The functionality of this type is similar to
+/// [`crate::utilts::visitors::find_all_ret_expressions`], but we can't use
+/// `find_all_ret_expressions` instead of this type. The reasons are:
+/// 1. `find_all_ret_expressions` passes the argument of `ExprKind::Ret` to a callback, but what we
+///    need here is `ExprKind::Ret` itself.
+/// 2. We can't trace current loop depth with `find_all_ret_expressions`.
 struct RetCollector {
     spans: Vec<Span>,
     ret_in_loop: bool,
-- 
cgit 1.4.1-3-g733a5


From 38431712998affe21621174faa2e490525d6b221 Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Sat, 27 Feb 2021 13:50:22 +0900
Subject: Improve the document of excessive_for_each

---
 clippy_lints/src/methods/mod.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 344c7f1bd9a..f0c99528fe1 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -975,8 +975,8 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for use of `obj.method().for_each(closure)` if obj doesn't
-    /// implelement `Iterator` and `method()` returns `Impl Iterator` type.
+    /// **What it does:** Checks for use of `.method(..).for_each(closure)` if the reciever of `.method(..)` doesn't
+    /// implement `Iterator` and the return type of `.method(..)` implements `Iterator`.
     ///
     /// **Why is this bad?** Excessive use of `for_each` reduces redability, using `for` loop is
     /// clearer and more concise.
-- 
cgit 1.4.1-3-g733a5


From 5543c34699ea2723565c1d517b3d3d98cb9fd8d4 Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Sat, 27 Feb 2021 13:58:41 +0900
Subject: Use ".." as default value of snippet in excessive_for_each

---
 clippy_lints/src/methods/excessive_for_each.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/excessive_for_each.rs b/clippy_lints/src/methods/excessive_for_each.rs
index 470f4ea2204..bcb7cf1491f 100644
--- a/clippy_lints/src/methods/excessive_for_each.rs
+++ b/clippy_lints/src/methods/excessive_for_each.rs
@@ -43,8 +43,8 @@ pub(super) fn lint(cx: &LateContext<'_>, expr: &'tcx Expr<'_>, args: &[&[Expr<'_
 
             let sugg = format!(
                 "for {} in {} {{ .. }}",
-                snippet(cx, body.params[0].pat.span, ""),
-                snippet(cx, for_each_receiver.span, "")
+                snippet(cx, body.params[0].pat.span, ".."),
+                snippet(cx, for_each_receiver.span, "..")
             );
 
             span_lint_and_then(
-- 
cgit 1.4.1-3-g733a5


From 527fbbef486bab32a95209b638b097a14ff41db0 Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Sat, 13 Mar 2021 00:42:43 +0900
Subject: Refactor excessive_for_each

---
 CHANGELOG.md                                   |   2 +-
 clippy_lints/src/iter_for_each.rs              |   0
 clippy_lints/src/lib.rs                        |   6 +-
 clippy_lints/src/methods/excessive_for_each.rs | 122 ------------------
 clippy_lints/src/methods/mod.rs                |  29 -----
 clippy_lints/src/needless_for_each.rs          | 170 +++++++++++++++++++++++++
 tests/ui/excessive_for_each.rs                 | 126 ------------------
 tests/ui/excessive_for_each.stderr             | 126 ------------------
 tests/ui/needless_for_each_fixable.fixed       |  99 ++++++++++++++
 tests/ui/needless_for_each_fixable.rs          |  99 ++++++++++++++
 tests/ui/needless_for_each_fixable.stderr      | 108 ++++++++++++++++
 tests/ui/needless_for_each_unfixable.rs        |  14 ++
 tests/ui/needless_for_each_unfixable.stderr    |  30 +++++
 13 files changed, 525 insertions(+), 406 deletions(-)
 delete mode 100644 clippy_lints/src/iter_for_each.rs
 delete mode 100644 clippy_lints/src/methods/excessive_for_each.rs
 create mode 100644 clippy_lints/src/needless_for_each.rs
 delete mode 100644 tests/ui/excessive_for_each.rs
 delete mode 100644 tests/ui/excessive_for_each.stderr
 create mode 100644 tests/ui/needless_for_each_fixable.fixed
 create mode 100644 tests/ui/needless_for_each_fixable.rs
 create mode 100644 tests/ui/needless_for_each_fixable.stderr
 create mode 100644 tests/ui/needless_for_each_unfixable.rs
 create mode 100644 tests/ui/needless_for_each_unfixable.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index c35ab6c94bf..a2193f0eab9 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2192,7 +2192,6 @@ Released 2018-09-13
 [`eq_op`]: https://rust-lang.github.io/rust-clippy/master/index.html#eq_op
 [`erasing_op`]: https://rust-lang.github.io/rust-clippy/master/index.html#erasing_op
 [`eval_order_dependence`]: https://rust-lang.github.io/rust-clippy/master/index.html#eval_order_dependence
-[`excessive_for_each`]: https://rust-lang.github.io/rust-clippy/master/index.html#excessive_for_each
 [`excessive_precision`]: https://rust-lang.github.io/rust-clippy/master/index.html#excessive_precision
 [`exhaustive_enums`]: https://rust-lang.github.io/rust-clippy/master/index.html#exhaustive_enums
 [`exhaustive_structs`]: https://rust-lang.github.io/rust-clippy/master/index.html#exhaustive_structs
@@ -2370,6 +2369,7 @@ Released 2018-09-13
 [`needless_collect`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_collect
 [`needless_continue`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_continue
 [`needless_doctest_main`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_doctest_main
+[`needless_for_each`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_for_each
 [`needless_lifetimes`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_lifetimes
 [`needless_pass_by_value`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_pass_by_value
 [`needless_question_mark`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_question_mark
diff --git a/clippy_lints/src/iter_for_each.rs b/clippy_lints/src/iter_for_each.rs
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 2f2ccdb310a..8c9247d9781 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -291,6 +291,7 @@ mod needless_bool;
 mod needless_borrow;
 mod needless_borrowed_ref;
 mod needless_continue;
+mod needless_for_each;
 mod needless_pass_by_value;
 mod needless_question_mark;
 mod needless_update;
@@ -781,7 +782,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &methods::CLONE_DOUBLE_REF,
         &methods::CLONE_ON_COPY,
         &methods::CLONE_ON_REF_PTR,
-        &methods::EXCESSIVE_FOR_EACH,
         &methods::EXPECT_FUN_CALL,
         &methods::EXPECT_USED,
         &methods::FILETYPE_IS_FILE,
@@ -868,6 +868,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &needless_borrow::NEEDLESS_BORROW,
         &needless_borrowed_ref::NEEDLESS_BORROWED_REFERENCE,
         &needless_continue::NEEDLESS_CONTINUE,
+        &needless_for_each::NEEDLESS_FOR_EACH,
         &needless_pass_by_value::NEEDLESS_PASS_BY_VALUE,
         &needless_question_mark::NEEDLESS_QUESTION_MARK,
         &needless_update::NEEDLESS_UPDATE,
@@ -1046,6 +1047,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box ptr_eq::PtrEq);
     store.register_late_pass(|| box needless_bool::NeedlessBool);
     store.register_late_pass(|| box needless_bool::BoolComparison);
+    store.register_late_pass(|| box needless_for_each::NeedlessForEach);
     store.register_late_pass(|| box approx_const::ApproxConstant);
     store.register_late_pass(|| box misc::MiscLints);
     store.register_late_pass(|| box eta_reduction::EtaReduction);
@@ -1314,7 +1316,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&matches::WILDCARD_ENUM_MATCH_ARM),
         LintId::of(&mem_forget::MEM_FORGET),
         LintId::of(&methods::CLONE_ON_REF_PTR),
-        LintId::of(&methods::EXCESSIVE_FOR_EACH),
         LintId::of(&methods::EXPECT_USED),
         LintId::of(&methods::FILETYPE_IS_FILE),
         LintId::of(&methods::GET_UNWRAP),
@@ -1325,6 +1326,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&missing_doc::MISSING_DOCS_IN_PRIVATE_ITEMS),
         LintId::of(&missing_inline::MISSING_INLINE_IN_PUBLIC_ITEMS),
         LintId::of(&modulo_arithmetic::MODULO_ARITHMETIC),
+        LintId::of(&needless_for_each::NEEDLESS_FOR_EACH),
         LintId::of(&panic_in_result_fn::PANIC_IN_RESULT_FN),
         LintId::of(&panic_unimplemented::PANIC),
         LintId::of(&panic_unimplemented::TODO),
diff --git a/clippy_lints/src/methods/excessive_for_each.rs b/clippy_lints/src/methods/excessive_for_each.rs
deleted file mode 100644
index bcb7cf1491f..00000000000
--- a/clippy_lints/src/methods/excessive_for_each.rs
+++ /dev/null
@@ -1,122 +0,0 @@
-use rustc_errors::Applicability;
-use rustc_hir::{
-    intravisit::{walk_expr, NestedVisitorMap, Visitor},
-    Expr, ExprKind,
-};
-use rustc_lint::LateContext;
-use rustc_middle::hir::map::Map;
-use rustc_span::source_map::Span;
-
-use if_chain::if_chain;
-
-use crate::utils::{has_iter_method, match_trait_method, paths, snippet, span_lint_and_then};
-
-use super::EXCESSIVE_FOR_EACH;
-
-pub(super) fn lint(cx: &LateContext<'_>, expr: &'tcx Expr<'_>, args: &[&[Expr<'_>]]) {
-    if args.len() < 2 {
-        return;
-    }
-
-    let for_each_args = args[0];
-    if for_each_args.len() < 2 {
-        return;
-    }
-    let for_each_receiver = &for_each_args[0];
-    let for_each_arg = &for_each_args[1];
-    let iter_receiver = &args[1][0];
-
-    if_chain! {
-        if has_iter_method(cx, cx.typeck_results().expr_ty(iter_receiver)).is_some();
-        if match_trait_method(cx, expr, &paths::ITERATOR);
-        if let ExprKind::Closure(_, _, body_id, ..) = for_each_arg.kind;
-        let body = cx.tcx.hir().body(body_id);
-        if let ExprKind::Block(..) = body.value.kind;
-        then {
-            let mut ret_collector = RetCollector::new();
-            ret_collector.visit_expr(&body.value);
-
-            // Skip the lint if `return` is used in `Loop` in order not to suggest using `'label`.
-            if ret_collector.ret_in_loop {
-                return;
-            }
-
-            let sugg = format!(
-                "for {} in {} {{ .. }}",
-                snippet(cx, body.params[0].pat.span, ".."),
-                snippet(cx, for_each_receiver.span, "..")
-            );
-
-            span_lint_and_then(
-                cx,
-                EXCESSIVE_FOR_EACH,
-                expr.span,
-                "excessive use of `for_each`",
-                |diag| {
-                    diag.span_suggestion(expr.span, "try", sugg, Applicability::HasPlaceholders);
-                    for span in ret_collector.spans {
-                        diag.span_note(span, "change `return` to `continue` in the loop body");
-                    }
-                }
-            )
-        }
-    }
-}
-
-/// This type plays two roles.
-/// 1. Collect spans of `return` in the closure body.
-/// 2. Detect use of `return` in `Loop` in the closure body.
-///
-/// NOTE: The functionality of this type is similar to
-/// [`crate::utilts::visitors::find_all_ret_expressions`], but we can't use
-/// `find_all_ret_expressions` instead of this type. The reasons are:
-/// 1. `find_all_ret_expressions` passes the argument of `ExprKind::Ret` to a callback, but what we
-///    need here is `ExprKind::Ret` itself.
-/// 2. We can't trace current loop depth with `find_all_ret_expressions`.
-struct RetCollector {
-    spans: Vec<Span>,
-    ret_in_loop: bool,
-
-    loop_depth: u16,
-}
-
-impl RetCollector {
-    fn new() -> Self {
-        Self {
-            spans: Vec::new(),
-            ret_in_loop: false,
-            loop_depth: 0,
-        }
-    }
-}
-
-impl<'tcx> Visitor<'tcx> for RetCollector {
-    type Map = Map<'tcx>;
-
-    fn visit_expr(&mut self, expr: &Expr<'_>) {
-        match expr.kind {
-            ExprKind::Ret(..) => {
-                if self.loop_depth > 0 && !self.ret_in_loop {
-                    self.ret_in_loop = true
-                }
-
-                self.spans.push(expr.span)
-            },
-
-            ExprKind::Loop(..) => {
-                self.loop_depth += 1;
-                walk_expr(self, expr);
-                self.loop_depth -= 1;
-                return;
-            },
-
-            _ => {},
-        }
-
-        walk_expr(self, expr);
-    }
-
-    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-        NestedVisitorMap::None
-    }
-}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index f0c99528fe1..fccdee07877 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -974,33 +974,6 @@ declare_clippy_lint! {
     "using `.skip(x).next()` on an iterator"
 }
 
-declare_clippy_lint! {
-    /// **What it does:** Checks for use of `.method(..).for_each(closure)` if the reciever of `.method(..)` doesn't
-    /// implement `Iterator` and the return type of `.method(..)` implements `Iterator`.
-    ///
-    /// **Why is this bad?** Excessive use of `for_each` reduces redability, using `for` loop is
-    /// clearer and more concise.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
-    /// ```rust
-    /// let v = vec![0, 1, 2];
-    /// v.iter().for_each(|elem| println!("{}", elem));
-    /// ```
-    /// Use instead:
-    /// ```rust
-    /// let v = vec![0, 1, 2];
-    /// for elem in v.iter() {
-    ///     println!("{}", elem);
-    /// }
-    /// ```
-    pub EXCESSIVE_FOR_EACH,
-    restriction,
-    "using `.iter().for_each(|x| {..})` when using `for` loop would work instead"
-}
-
 declare_clippy_lint! {
     /// **What it does:** Checks for use of `.get().unwrap()` (or
     /// `.get_mut().unwrap`) on a standard library type which implements `Index`
@@ -1688,7 +1661,6 @@ impl_lint_pass!(Methods => [
     ITER_NTH_ZERO,
     BYTES_NTH,
     ITER_SKIP_NEXT,
-    EXCESSIVE_FOR_EACH,
     GET_UNWRAP,
     STRING_EXTEND_CHARS,
     ITER_CLONED_COLLECT,
@@ -1835,7 +1807,6 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             ["to_os_string", ..] => implicit_clone::check(cx, expr, sym::OsStr),
             ["to_path_buf", ..] => implicit_clone::check(cx, expr, sym::Path),
             ["to_vec", ..] => implicit_clone::check(cx, expr, sym::slice),
-            ["for_each", ..] => excessive_for_each::lint(cx, expr, &arg_lists),
             _ => {},
         }
 
diff --git a/clippy_lints/src/needless_for_each.rs b/clippy_lints/src/needless_for_each.rs
new file mode 100644
index 00000000000..a7b0a1ca082
--- /dev/null
+++ b/clippy_lints/src/needless_for_each.rs
@@ -0,0 +1,170 @@
+use rustc_errors::Applicability;
+use rustc_hir::{
+    intravisit::{walk_expr, NestedVisitorMap, Visitor},
+    Expr, ExprKind, Stmt, StmtKind,
+};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::hir::map::Map;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::{source_map::Span, sym, Symbol};
+
+use if_chain::if_chain;
+
+use crate::utils::{
+    has_iter_method, is_diagnostic_assoc_item, method_calls, snippet_with_applicability, span_lint_and_then,
+};
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for usage of `for_each` that would be more simply written as a
+    /// `for` loop.
+    ///
+    /// **Why is this bad?** `for_each` may be used after applying iterator transformers like
+    /// `filter` for better readability and performance. It may also be used to fit a simple
+    /// operation on one line.
+    /// But when none of these apply, a simple `for` loop is more idiomatic.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// let v = vec![0, 1, 2];
+    /// v.iter().for_each(|elem| {
+    ///     println!("{}", elem);
+    /// })
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// let v = vec![0, 1, 2];
+    /// for elem in v.iter() {
+    ///     println!("{}", elem);
+    /// }
+    /// ```
+    pub NEEDLESS_FOR_EACH,
+    restriction,
+    "using `for_each` where a `for` loop would be simpler"
+}
+
+declare_lint_pass!(NeedlessForEach => [NEEDLESS_FOR_EACH]);
+
+impl LateLintPass<'_> for NeedlessForEach {
+    fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) {
+        let expr = match stmt.kind {
+            StmtKind::Expr(expr) | StmtKind::Semi(expr) => expr,
+            StmtKind::Local(local) if local.init.is_some() => local.init.unwrap(),
+            _ => return,
+        };
+
+        // Max depth is set to 3 because we need to check the method chain length is just two.
+        let (method_names, arg_lists, _) = method_calls(expr, 3);
+
+        if_chain! {
+            // This assures the length of this method chain is two.
+            if let [for_each_args, iter_args] = arg_lists.as_slice();
+            if let Some(for_each_sym) = method_names.first();
+            if *for_each_sym == Symbol::intern("for_each");
+            if let Some(did) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
+            if is_diagnostic_assoc_item(cx, did, sym::Iterator);
+            // Checks the type of the first method receiver is NOT a user defined type.
+            if has_iter_method(cx, cx.typeck_results().expr_ty(&iter_args[0])).is_some();
+            if let ExprKind::Closure(_, _, body_id, ..) = for_each_args[1].kind;
+            let body = cx.tcx.hir().body(body_id);
+            // Skip the lint if the body is not block because this is simpler than `for` loop.
+            // e.g. `v.iter().for_each(f)` is simpler and clearer than using `for` loop.
+            if let ExprKind::Block(..) = body.value.kind;
+            then {
+                let mut ret_collector = RetCollector::default();
+                ret_collector.visit_expr(&body.value);
+
+                // Skip the lint if `return` is used in `Loop` in order not to suggest using `'label`.
+                if ret_collector.ret_in_loop {
+                    return;
+                }
+
+                // We can't use `Applicability::MachineApplicable` when the closure contains `return`
+                // because `Diagnostic::multipart_suggestion` doesn't work with multiple overlapped
+                // spans.
+                let mut applicability = if ret_collector.spans.is_empty() {
+                    Applicability::MachineApplicable
+                } else {
+                    Applicability::MaybeIncorrect
+                };
+
+                let mut suggs = vec![];
+                suggs.push((stmt.span, format!(
+                    "for {} in {} {}",
+                    snippet_with_applicability(cx, body.params[0].pat.span, "..", &mut applicability),
+                    snippet_with_applicability(cx, for_each_args[0].span, "..", &mut applicability),
+                    snippet_with_applicability(cx, body.value.span, "..", &mut applicability),
+                )));
+
+                for span in &ret_collector.spans {
+                    suggs.push((*span, "return".to_string()));
+                }
+
+                span_lint_and_then(
+                    cx,
+                    NEEDLESS_FOR_EACH,
+                    stmt.span,
+                    "needless use of `for_each`",
+                    |diag| {
+                        diag.multipart_suggestion("try", suggs, applicability);
+                        // `Diagnostic::multipart_suggestion` ignores the second and subsequent overlapped spans,
+                        // so `span_note` is needed here even though `suggs` includes the replacements.
+                        for span in ret_collector.spans {
+                            diag.span_note(span, "replace `return` with `continue`");
+                        }
+                    }
+                )
+            }
+        }
+    }
+}
+
+/// This type plays two roles.
+/// 1. Collect spans of `return` in the closure body.
+/// 2. Detect use of `return` in `Loop` in the closure body.
+///
+/// NOTE: The functionality of this type is similar to
+/// [`crate::utilts::visitors::find_all_ret_expressions`], but we can't use
+/// `find_all_ret_expressions` instead of this type. The reasons are:
+/// 1. `find_all_ret_expressions` passes the argument of `ExprKind::Ret` to a callback, but what we
+///    need here is `ExprKind::Ret` itself.
+/// 2. We can't trace current loop depth with `find_all_ret_expressions`.
+#[derive(Default)]
+struct RetCollector {
+    spans: Vec<Span>,
+    ret_in_loop: bool,
+    loop_depth: u16,
+}
+
+impl<'tcx> Visitor<'tcx> for RetCollector {
+    type Map = Map<'tcx>;
+
+    fn visit_expr(&mut self, expr: &Expr<'_>) {
+        match expr.kind {
+            ExprKind::Ret(..) => {
+                if self.loop_depth > 0 && !self.ret_in_loop {
+                    self.ret_in_loop = true
+                }
+
+                self.spans.push(expr.span)
+            },
+
+            ExprKind::Loop(..) => {
+                self.loop_depth += 1;
+                walk_expr(self, expr);
+                self.loop_depth -= 1;
+                return;
+            },
+
+            _ => {},
+        }
+
+        walk_expr(self, expr);
+    }
+
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::None
+    }
+}
diff --git a/tests/ui/excessive_for_each.rs b/tests/ui/excessive_for_each.rs
deleted file mode 100644
index 0800bef71e9..00000000000
--- a/tests/ui/excessive_for_each.rs
+++ /dev/null
@@ -1,126 +0,0 @@
-#![warn(clippy::excessive_for_each)]
-#![allow(clippy::needless_return)]
-
-use std::collections::*;
-
-fn main() {
-    // Should trigger this lint: Vec.
-    let vec: Vec<i32> = Vec::new();
-    let mut acc = 0;
-    vec.iter().for_each(|v| {
-        acc += v;
-    });
-
-    // Should trigger this lint: &Vec.
-    let vec_ref = &vec;
-    vec_ref.iter().for_each(|v| {
-        acc += v;
-    });
-
-    // Should trigger this lint: VecDeque.
-    let vec_deq: VecDeque<i32> = VecDeque::new();
-    vec_deq.iter().for_each(|v| {
-        acc += v;
-    });
-
-    // Should trigger this lint: LinkedList.
-    let list: LinkedList<i32> = LinkedList::new();
-    list.iter().for_each(|v| {
-        acc += v;
-    });
-
-    // Should trigger this lint: HashMap.
-    let mut hash_map: HashMap<i32, i32> = HashMap::new();
-    hash_map.iter().for_each(|(k, v)| {
-        acc += k + v;
-    });
-    hash_map.iter_mut().for_each(|(k, v)| {
-        acc += *k + *v;
-    });
-    hash_map.keys().for_each(|k| {
-        acc += k;
-    });
-    hash_map.values().for_each(|v| {
-        acc += v;
-    });
-
-    // Should trigger this lint: HashSet.
-    let hash_set: HashSet<i32> = HashSet::new();
-    hash_set.iter().for_each(|v| {
-        acc += v;
-    });
-
-    // Should trigger this lint: BTreeSet.
-    let btree_set: BTreeSet<i32> = BTreeSet::new();
-    btree_set.iter().for_each(|v| {
-        acc += v;
-    });
-
-    // Should trigger this lint: BinaryHeap.
-    let binary_heap: BinaryHeap<i32> = BinaryHeap::new();
-    binary_heap.iter().for_each(|v| {
-        acc += v;
-    });
-
-    // Should trigger this lint: Array.
-    let s = [1, 2, 3];
-    s.iter().for_each(|v| {
-        acc += v;
-    });
-
-    // Should trigger this lint. Slice.
-    vec.as_slice().iter().for_each(|v| {
-        acc += v;
-    });
-
-    // Should trigger this lint with notes that say "change `return` to `continue`".
-    vec.iter().for_each(|v| {
-        if *v == 10 {
-            return;
-        } else {
-            println!("{}", v);
-        }
-    });
-
-    // Should NOT trigger this lint in case `return` is used in `Loop` of the closure.
-    vec.iter().for_each(|v| {
-        for i in 0..*v {
-            if i == 10 {
-                return;
-            } else {
-                println!("{}", v);
-            }
-        }
-        if *v == 20 {
-            return;
-        } else {
-            println!("{}", v);
-        }
-    });
-
-    // Should NOT trigger this lint in case `for_each` follows long iterator chain.
-    vec.iter().chain(vec.iter()).for_each(|v| println!("{}", v));
-
-    // Should NOT trigger this lint in case a `for_each` argument is not closure.
-    fn print(x: &i32) {
-        println!("{}", x);
-    }
-    vec.iter().for_each(print);
-
-    // Should NOT trigger this lint in case the receiver of `iter` is a user defined type.
-    let my_collection = MyCollection { v: vec![] };
-    my_collection.iter().for_each(|v| println!("{}", v));
-
-    // Should NOT trigger this lint in case the closure body is not a `ExprKind::Block`.
-    vec.iter().for_each(|x| acc += x);
-}
-
-struct MyCollection {
-    v: Vec<i32>,
-}
-
-impl MyCollection {
-    fn iter(&self) -> impl Iterator<Item = &i32> {
-        self.v.iter()
-    }
-}
diff --git a/tests/ui/excessive_for_each.stderr b/tests/ui/excessive_for_each.stderr
deleted file mode 100644
index f5799484e03..00000000000
--- a/tests/ui/excessive_for_each.stderr
+++ /dev/null
@@ -1,126 +0,0 @@
-error: excessive use of `for_each`
-  --> $DIR/excessive_for_each.rs:10:5
-   |
-LL | /     vec.iter().for_each(|v| {
-LL | |         acc += v;
-LL | |     });
-   | |______^ help: try: `for v in vec.iter() { .. }`
-   |
-   = note: `-D clippy::excessive-for-each` implied by `-D warnings`
-
-error: excessive use of `for_each`
-  --> $DIR/excessive_for_each.rs:16:5
-   |
-LL | /     vec_ref.iter().for_each(|v| {
-LL | |         acc += v;
-LL | |     });
-   | |______^ help: try: `for v in vec_ref.iter() { .. }`
-
-error: excessive use of `for_each`
-  --> $DIR/excessive_for_each.rs:22:5
-   |
-LL | /     vec_deq.iter().for_each(|v| {
-LL | |         acc += v;
-LL | |     });
-   | |______^ help: try: `for v in vec_deq.iter() { .. }`
-
-error: excessive use of `for_each`
-  --> $DIR/excessive_for_each.rs:28:5
-   |
-LL | /     list.iter().for_each(|v| {
-LL | |         acc += v;
-LL | |     });
-   | |______^ help: try: `for v in list.iter() { .. }`
-
-error: excessive use of `for_each`
-  --> $DIR/excessive_for_each.rs:34:5
-   |
-LL | /     hash_map.iter().for_each(|(k, v)| {
-LL | |         acc += k + v;
-LL | |     });
-   | |______^ help: try: `for (k, v) in hash_map.iter() { .. }`
-
-error: excessive use of `for_each`
-  --> $DIR/excessive_for_each.rs:37:5
-   |
-LL | /     hash_map.iter_mut().for_each(|(k, v)| {
-LL | |         acc += *k + *v;
-LL | |     });
-   | |______^ help: try: `for (k, v) in hash_map.iter_mut() { .. }`
-
-error: excessive use of `for_each`
-  --> $DIR/excessive_for_each.rs:40:5
-   |
-LL | /     hash_map.keys().for_each(|k| {
-LL | |         acc += k;
-LL | |     });
-   | |______^ help: try: `for k in hash_map.keys() { .. }`
-
-error: excessive use of `for_each`
-  --> $DIR/excessive_for_each.rs:43:5
-   |
-LL | /     hash_map.values().for_each(|v| {
-LL | |         acc += v;
-LL | |     });
-   | |______^ help: try: `for v in hash_map.values() { .. }`
-
-error: excessive use of `for_each`
-  --> $DIR/excessive_for_each.rs:49:5
-   |
-LL | /     hash_set.iter().for_each(|v| {
-LL | |         acc += v;
-LL | |     });
-   | |______^ help: try: `for v in hash_set.iter() { .. }`
-
-error: excessive use of `for_each`
-  --> $DIR/excessive_for_each.rs:55:5
-   |
-LL | /     btree_set.iter().for_each(|v| {
-LL | |         acc += v;
-LL | |     });
-   | |______^ help: try: `for v in btree_set.iter() { .. }`
-
-error: excessive use of `for_each`
-  --> $DIR/excessive_for_each.rs:61:5
-   |
-LL | /     binary_heap.iter().for_each(|v| {
-LL | |         acc += v;
-LL | |     });
-   | |______^ help: try: `for v in binary_heap.iter() { .. }`
-
-error: excessive use of `for_each`
-  --> $DIR/excessive_for_each.rs:67:5
-   |
-LL | /     s.iter().for_each(|v| {
-LL | |         acc += v;
-LL | |     });
-   | |______^ help: try: `for v in s.iter() { .. }`
-
-error: excessive use of `for_each`
-  --> $DIR/excessive_for_each.rs:72:5
-   |
-LL | /     vec.as_slice().iter().for_each(|v| {
-LL | |         acc += v;
-LL | |     });
-   | |______^ help: try: `for v in vec.as_slice().iter() { .. }`
-
-error: excessive use of `for_each`
-  --> $DIR/excessive_for_each.rs:77:5
-   |
-LL | /     vec.iter().for_each(|v| {
-LL | |         if *v == 10 {
-LL | |             return;
-LL | |         } else {
-LL | |             println!("{}", v);
-LL | |         }
-LL | |     });
-   | |______^ help: try: `for v in vec.iter() { .. }`
-   |
-note: change `return` to `continue` in the loop body
-  --> $DIR/excessive_for_each.rs:79:13
-   |
-LL |             return;
-   |             ^^^^^^
-
-error: aborting due to 14 previous errors
-
diff --git a/tests/ui/needless_for_each_fixable.fixed b/tests/ui/needless_for_each_fixable.fixed
new file mode 100644
index 00000000000..0caa95a9f53
--- /dev/null
+++ b/tests/ui/needless_for_each_fixable.fixed
@@ -0,0 +1,99 @@
+// run-rustfix
+#![warn(clippy::needless_for_each)]
+#![allow(unused, clippy::needless_return, clippy::match_single_binding)]
+
+use std::collections::HashMap;
+
+fn should_lint() {
+    let v: Vec<i32> = Vec::new();
+    let mut acc = 0;
+    for elem in v.iter() {
+        acc += elem;
+    }
+    for elem in v.into_iter() {
+        acc += elem;
+    }
+
+    let mut hash_map: HashMap<i32, i32> = HashMap::new();
+    for (k, v) in hash_map.iter() {
+        acc += k + v;
+    }
+    for (k, v) in hash_map.iter_mut() {
+        acc += *k + *v;
+    }
+    for k in hash_map.keys() {
+        acc += k;
+    }
+    for v in hash_map.values() {
+        acc += v;
+    }
+
+    fn my_vec() -> Vec<i32> {
+        Vec::new()
+    }
+    for elem in my_vec().iter() {
+        acc += elem;
+    }
+}
+
+fn should_not_lint() {
+    let v: Vec<i32> = Vec::new();
+    let mut acc = 0;
+
+    // `for_each` argument is not closure.
+    fn print(x: &i32) {
+        println!("{}", x);
+    }
+    v.iter().for_each(print);
+
+    // `for_each` follows long iterator chain.
+    v.iter().chain(v.iter()).for_each(|v| println!("{}", v));
+    v.as_slice().iter().for_each(|v| {
+        acc += v;
+    });
+
+    // `return` is used in `Loop` of the closure.
+    v.iter().for_each(|v| {
+        for i in 0..*v {
+            if i == 10 {
+                return;
+            } else {
+                println!("{}", v);
+            }
+        }
+        if *v == 20 {
+            return;
+        } else {
+            println!("{}", v);
+        }
+    });
+
+    // User defined type.
+    struct MyStruct {
+        v: Vec<i32>,
+    }
+    impl MyStruct {
+        fn iter(&self) -> impl Iterator<Item = &i32> {
+            self.v.iter()
+        }
+    }
+    let s = MyStruct { v: Vec::new() };
+    s.iter().for_each(|elem| {
+        acc += elem;
+    });
+
+    // Previously transformed iterator variable.
+    let it = v.iter();
+    it.chain(v.iter()).for_each(|elem| {
+        acc += elem;
+    });
+
+    // `for_each` is not directly in a statement.
+    match 1 {
+        _ => v.iter().for_each(|elem| {
+            acc += elem;
+        }),
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/needless_for_each_fixable.rs b/tests/ui/needless_for_each_fixable.rs
new file mode 100644
index 00000000000..a04243de27a
--- /dev/null
+++ b/tests/ui/needless_for_each_fixable.rs
@@ -0,0 +1,99 @@
+// run-rustfix
+#![warn(clippy::needless_for_each)]
+#![allow(unused, clippy::needless_return, clippy::match_single_binding)]
+
+use std::collections::HashMap;
+
+fn should_lint() {
+    let v: Vec<i32> = Vec::new();
+    let mut acc = 0;
+    v.iter().for_each(|elem| {
+        acc += elem;
+    });
+    v.into_iter().for_each(|elem| {
+        acc += elem;
+    });
+
+    let mut hash_map: HashMap<i32, i32> = HashMap::new();
+    hash_map.iter().for_each(|(k, v)| {
+        acc += k + v;
+    });
+    hash_map.iter_mut().for_each(|(k, v)| {
+        acc += *k + *v;
+    });
+    hash_map.keys().for_each(|k| {
+        acc += k;
+    });
+    hash_map.values().for_each(|v| {
+        acc += v;
+    });
+
+    fn my_vec() -> Vec<i32> {
+        Vec::new()
+    }
+    my_vec().iter().for_each(|elem| {
+        acc += elem;
+    });
+}
+
+fn should_not_lint() {
+    let v: Vec<i32> = Vec::new();
+    let mut acc = 0;
+
+    // `for_each` argument is not closure.
+    fn print(x: &i32) {
+        println!("{}", x);
+    }
+    v.iter().for_each(print);
+
+    // `for_each` follows long iterator chain.
+    v.iter().chain(v.iter()).for_each(|v| println!("{}", v));
+    v.as_slice().iter().for_each(|v| {
+        acc += v;
+    });
+
+    // `return` is used in `Loop` of the closure.
+    v.iter().for_each(|v| {
+        for i in 0..*v {
+            if i == 10 {
+                return;
+            } else {
+                println!("{}", v);
+            }
+        }
+        if *v == 20 {
+            return;
+        } else {
+            println!("{}", v);
+        }
+    });
+
+    // User defined type.
+    struct MyStruct {
+        v: Vec<i32>,
+    }
+    impl MyStruct {
+        fn iter(&self) -> impl Iterator<Item = &i32> {
+            self.v.iter()
+        }
+    }
+    let s = MyStruct { v: Vec::new() };
+    s.iter().for_each(|elem| {
+        acc += elem;
+    });
+
+    // Previously transformed iterator variable.
+    let it = v.iter();
+    it.chain(v.iter()).for_each(|elem| {
+        acc += elem;
+    });
+
+    // `for_each` is not directly in a statement.
+    match 1 {
+        _ => v.iter().for_each(|elem| {
+            acc += elem;
+        }),
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/needless_for_each_fixable.stderr b/tests/ui/needless_for_each_fixable.stderr
new file mode 100644
index 00000000000..214e357a208
--- /dev/null
+++ b/tests/ui/needless_for_each_fixable.stderr
@@ -0,0 +1,108 @@
+error: needless use of `for_each`
+  --> $DIR/needless_for_each_fixable.rs:10:5
+   |
+LL | /     v.iter().for_each(|elem| {
+LL | |         acc += elem;
+LL | |     });
+   | |_______^
+   |
+   = note: `-D clippy::needless-for-each` implied by `-D warnings`
+help: try
+   |
+LL |     for elem in v.iter() {
+LL |         acc += elem;
+LL |     }
+   |
+
+error: needless use of `for_each`
+  --> $DIR/needless_for_each_fixable.rs:13:5
+   |
+LL | /     v.into_iter().for_each(|elem| {
+LL | |         acc += elem;
+LL | |     });
+   | |_______^
+   |
+help: try
+   |
+LL |     for elem in v.into_iter() {
+LL |         acc += elem;
+LL |     }
+   |
+
+error: needless use of `for_each`
+  --> $DIR/needless_for_each_fixable.rs:18:5
+   |
+LL | /     hash_map.iter().for_each(|(k, v)| {
+LL | |         acc += k + v;
+LL | |     });
+   | |_______^
+   |
+help: try
+   |
+LL |     for (k, v) in hash_map.iter() {
+LL |         acc += k + v;
+LL |     }
+   |
+
+error: needless use of `for_each`
+  --> $DIR/needless_for_each_fixable.rs:21:5
+   |
+LL | /     hash_map.iter_mut().for_each(|(k, v)| {
+LL | |         acc += *k + *v;
+LL | |     });
+   | |_______^
+   |
+help: try
+   |
+LL |     for (k, v) in hash_map.iter_mut() {
+LL |         acc += *k + *v;
+LL |     }
+   |
+
+error: needless use of `for_each`
+  --> $DIR/needless_for_each_fixable.rs:24:5
+   |
+LL | /     hash_map.keys().for_each(|k| {
+LL | |         acc += k;
+LL | |     });
+   | |_______^
+   |
+help: try
+   |
+LL |     for k in hash_map.keys() {
+LL |         acc += k;
+LL |     }
+   |
+
+error: needless use of `for_each`
+  --> $DIR/needless_for_each_fixable.rs:27:5
+   |
+LL | /     hash_map.values().for_each(|v| {
+LL | |         acc += v;
+LL | |     });
+   | |_______^
+   |
+help: try
+   |
+LL |     for v in hash_map.values() {
+LL |         acc += v;
+LL |     }
+   |
+
+error: needless use of `for_each`
+  --> $DIR/needless_for_each_fixable.rs:34:5
+   |
+LL | /     my_vec().iter().for_each(|elem| {
+LL | |         acc += elem;
+LL | |     });
+   | |_______^
+   |
+help: try
+   |
+LL |     for elem in my_vec().iter() {
+LL |         acc += elem;
+LL |     }
+   |
+
+error: aborting due to 7 previous errors
+
diff --git a/tests/ui/needless_for_each_unfixable.rs b/tests/ui/needless_for_each_unfixable.rs
new file mode 100644
index 00000000000..d765d7dab65
--- /dev/null
+++ b/tests/ui/needless_for_each_unfixable.rs
@@ -0,0 +1,14 @@
+#![warn(clippy::needless_for_each)]
+#![allow(clippy::needless_return)]
+
+fn main() {
+    let v: Vec<i32> = Vec::new();
+    // This is unfixable because the closure includes `return`.
+    v.iter().for_each(|v| {
+        if *v == 10 {
+            return;
+        } else {
+            println!("{}", v);
+        }
+    });
+}
diff --git a/tests/ui/needless_for_each_unfixable.stderr b/tests/ui/needless_for_each_unfixable.stderr
new file mode 100644
index 00000000000..58d107062bc
--- /dev/null
+++ b/tests/ui/needless_for_each_unfixable.stderr
@@ -0,0 +1,30 @@
+error: needless use of `for_each`
+  --> $DIR/needless_for_each_unfixable.rs:7:5
+   |
+LL | /     v.iter().for_each(|v| {
+LL | |         if *v == 10 {
+LL | |             return;
+LL | |         } else {
+LL | |             println!("{}", v);
+LL | |         }
+LL | |     });
+   | |_______^
+   |
+   = note: `-D clippy::needless-for-each` implied by `-D warnings`
+note: replace `return` with `continue`
+  --> $DIR/needless_for_each_unfixable.rs:9:13
+   |
+LL |             return;
+   |             ^^^^^^
+help: try
+   |
+LL |     for v in v.iter() {
+LL |         if *v == 10 {
+LL |             return;
+LL |         } else {
+LL |             println!("{}", v);
+LL |         }
+ ...
+
+error: aborting due to previous error
+
-- 
cgit 1.4.1-3-g733a5


From f2cc995bcfdc86a564b4040585f97f012be9454b Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Sat, 13 Mar 2021 15:11:39 +0900
Subject: Remove method_calls

---
 clippy_lints/src/lib.rs                   |  2 +-
 clippy_lints/src/needless_for_each.rs     | 40 +++++++++++++++++--------------
 tests/ui/needless_for_each_fixable.fixed  | 39 ++++++++++++++++++------------
 tests/ui/needless_for_each_fixable.rs     | 39 ++++++++++++++++++------------
 tests/ui/needless_for_each_fixable.stderr | 27 ++++++++++++++++-----
 5 files changed, 92 insertions(+), 55 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 8c9247d9781..11716afe11c 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1326,7 +1326,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&missing_doc::MISSING_DOCS_IN_PRIVATE_ITEMS),
         LintId::of(&missing_inline::MISSING_INLINE_IN_PUBLIC_ITEMS),
         LintId::of(&modulo_arithmetic::MODULO_ARITHMETIC),
-        LintId::of(&needless_for_each::NEEDLESS_FOR_EACH),
         LintId::of(&panic_in_result_fn::PANIC_IN_RESULT_FN),
         LintId::of(&panic_unimplemented::PANIC),
         LintId::of(&panic_unimplemented::TODO),
@@ -1409,6 +1408,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&misc_early::UNSEPARATED_LITERAL_SUFFIX),
         LintId::of(&mut_mut::MUT_MUT),
         LintId::of(&needless_continue::NEEDLESS_CONTINUE),
+        LintId::of(&needless_for_each::NEEDLESS_FOR_EACH),
         LintId::of(&needless_pass_by_value::NEEDLESS_PASS_BY_VALUE),
         LintId::of(&non_expressive_names::SIMILAR_NAMES),
         LintId::of(&option_if_let_else::OPTION_IF_LET_ELSE),
diff --git a/clippy_lints/src/needless_for_each.rs b/clippy_lints/src/needless_for_each.rs
index a7b0a1ca082..f60b09898ab 100644
--- a/clippy_lints/src/needless_for_each.rs
+++ b/clippy_lints/src/needless_for_each.rs
@@ -10,9 +10,7 @@ use rustc_span::{source_map::Span, sym, Symbol};
 
 use if_chain::if_chain;
 
-use crate::utils::{
-    has_iter_method, is_diagnostic_assoc_item, method_calls, snippet_with_applicability, span_lint_and_then,
-};
+use crate::utils::{has_iter_method, is_trait_method, snippet_with_applicability, span_lint_and_then};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for usage of `for_each` that would be more simply written as a
@@ -41,7 +39,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     pub NEEDLESS_FOR_EACH,
-    restriction,
+    pedantic,
     "using `for_each` where a `for` loop would be simpler"
 }
 
@@ -55,22 +53,28 @@ impl LateLintPass<'_> for NeedlessForEach {
             _ => return,
         };
 
-        // Max depth is set to 3 because we need to check the method chain length is just two.
-        let (method_names, arg_lists, _) = method_calls(expr, 3);
-
         if_chain! {
-            // This assures the length of this method chain is two.
-            if let [for_each_args, iter_args] = arg_lists.as_slice();
-            if let Some(for_each_sym) = method_names.first();
-            if *for_each_sym == Symbol::intern("for_each");
-            if let Some(did) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
-            if is_diagnostic_assoc_item(cx, did, sym::Iterator);
-            // Checks the type of the first method receiver is NOT a user defined type.
-            if has_iter_method(cx, cx.typeck_results().expr_ty(&iter_args[0])).is_some();
-            if let ExprKind::Closure(_, _, body_id, ..) = for_each_args[1].kind;
-            let body = cx.tcx.hir().body(body_id);
+            // Check the method name is `for_each`.
+            if let ExprKind::MethodCall(method_name, _, for_each_args, _) = expr.kind;
+            if method_name.ident.name == Symbol::intern("for_each");
+            // Check `for_each` is an associated function of `Iterator`.
+            if is_trait_method(cx, expr, sym::Iterator);
+            // Checks the receiver of `for_each` is also a method call.
+            if let Some(for_each_receiver) = for_each_args.get(0);
+            if let ExprKind::MethodCall(_, _, iter_args, _) = for_each_receiver.kind;
+            // Skip the lint if the call chain is too long. e.g. `v.field.iter().for_each()` or
+            // `v.foo().iter().for_each()` must be skipped.
+            if let Some(iter_receiver) = iter_args.get(0);
+            if matches!(
+                iter_receiver.kind,
+                ExprKind::Array(..) | ExprKind::Call(..) | ExprKind::Path(..)
+            );
+            // Checks the type of the `iter` method receiver is NOT a user defined type.
+            if has_iter_method(cx, cx.typeck_results().expr_ty(&iter_receiver)).is_some();
             // Skip the lint if the body is not block because this is simpler than `for` loop.
             // e.g. `v.iter().for_each(f)` is simpler and clearer than using `for` loop.
+            if let ExprKind::Closure(_, _, body_id, ..) = for_each_args[1].kind;
+            let body = cx.tcx.hir().body(body_id);
             if let ExprKind::Block(..) = body.value.kind;
             then {
                 let mut ret_collector = RetCollector::default();
@@ -99,7 +103,7 @@ impl LateLintPass<'_> for NeedlessForEach {
                 )));
 
                 for span in &ret_collector.spans {
-                    suggs.push((*span, "return".to_string()));
+                    suggs.push((*span, "continue".to_string()));
                 }
 
                 span_lint_and_then(
diff --git a/tests/ui/needless_for_each_fixable.fixed b/tests/ui/needless_for_each_fixable.fixed
index 0caa95a9f53..a4d4937a19a 100644
--- a/tests/ui/needless_for_each_fixable.fixed
+++ b/tests/ui/needless_for_each_fixable.fixed
@@ -14,6 +14,10 @@ fn should_lint() {
         acc += elem;
     }
 
+    for elem in [1, 2, 3].iter() {
+        acc += elem;
+    }
+
     let mut hash_map: HashMap<i32, i32> = HashMap::new();
     for (k, v) in hash_map.iter() {
         acc += k + v;
@@ -46,11 +50,30 @@ fn should_not_lint() {
     }
     v.iter().for_each(print);
 
+    // User defined type.
+    struct MyStruct {
+        v: Vec<i32>,
+    }
+    impl MyStruct {
+        fn iter(&self) -> impl Iterator<Item = &i32> {
+            self.v.iter()
+        }
+    }
+    let s = MyStruct { v: Vec::new() };
+    s.iter().for_each(|elem| {
+        acc += elem;
+    });
+
     // `for_each` follows long iterator chain.
-    v.iter().chain(v.iter()).for_each(|v| println!("{}", v));
+    v.iter().chain(v.iter()).for_each(|v| {
+        acc += v;
+    });
     v.as_slice().iter().for_each(|v| {
         acc += v;
     });
+    s.v.iter().for_each(|v| {
+        acc += v;
+    });
 
     // `return` is used in `Loop` of the closure.
     v.iter().for_each(|v| {
@@ -68,20 +91,6 @@ fn should_not_lint() {
         }
     });
 
-    // User defined type.
-    struct MyStruct {
-        v: Vec<i32>,
-    }
-    impl MyStruct {
-        fn iter(&self) -> impl Iterator<Item = &i32> {
-            self.v.iter()
-        }
-    }
-    let s = MyStruct { v: Vec::new() };
-    s.iter().for_each(|elem| {
-        acc += elem;
-    });
-
     // Previously transformed iterator variable.
     let it = v.iter();
     it.chain(v.iter()).for_each(|elem| {
diff --git a/tests/ui/needless_for_each_fixable.rs b/tests/ui/needless_for_each_fixable.rs
index a04243de27a..b374128f253 100644
--- a/tests/ui/needless_for_each_fixable.rs
+++ b/tests/ui/needless_for_each_fixable.rs
@@ -14,6 +14,10 @@ fn should_lint() {
         acc += elem;
     });
 
+    [1, 2, 3].iter().for_each(|elem| {
+        acc += elem;
+    });
+
     let mut hash_map: HashMap<i32, i32> = HashMap::new();
     hash_map.iter().for_each(|(k, v)| {
         acc += k + v;
@@ -46,11 +50,30 @@ fn should_not_lint() {
     }
     v.iter().for_each(print);
 
+    // User defined type.
+    struct MyStruct {
+        v: Vec<i32>,
+    }
+    impl MyStruct {
+        fn iter(&self) -> impl Iterator<Item = &i32> {
+            self.v.iter()
+        }
+    }
+    let s = MyStruct { v: Vec::new() };
+    s.iter().for_each(|elem| {
+        acc += elem;
+    });
+
     // `for_each` follows long iterator chain.
-    v.iter().chain(v.iter()).for_each(|v| println!("{}", v));
+    v.iter().chain(v.iter()).for_each(|v| {
+        acc += v;
+    });
     v.as_slice().iter().for_each(|v| {
         acc += v;
     });
+    s.v.iter().for_each(|v| {
+        acc += v;
+    });
 
     // `return` is used in `Loop` of the closure.
     v.iter().for_each(|v| {
@@ -68,20 +91,6 @@ fn should_not_lint() {
         }
     });
 
-    // User defined type.
-    struct MyStruct {
-        v: Vec<i32>,
-    }
-    impl MyStruct {
-        fn iter(&self) -> impl Iterator<Item = &i32> {
-            self.v.iter()
-        }
-    }
-    let s = MyStruct { v: Vec::new() };
-    s.iter().for_each(|elem| {
-        acc += elem;
-    });
-
     // Previously transformed iterator variable.
     let it = v.iter();
     it.chain(v.iter()).for_each(|elem| {
diff --git a/tests/ui/needless_for_each_fixable.stderr b/tests/ui/needless_for_each_fixable.stderr
index 214e357a208..483a5e6d61d 100644
--- a/tests/ui/needless_for_each_fixable.stderr
+++ b/tests/ui/needless_for_each_fixable.stderr
@@ -30,7 +30,22 @@ LL |     }
    |
 
 error: needless use of `for_each`
-  --> $DIR/needless_for_each_fixable.rs:18:5
+  --> $DIR/needless_for_each_fixable.rs:17:5
+   |
+LL | /     [1, 2, 3].iter().for_each(|elem| {
+LL | |         acc += elem;
+LL | |     });
+   | |_______^
+   |
+help: try
+   |
+LL |     for elem in [1, 2, 3].iter() {
+LL |         acc += elem;
+LL |     }
+   |
+
+error: needless use of `for_each`
+  --> $DIR/needless_for_each_fixable.rs:22:5
    |
 LL | /     hash_map.iter().for_each(|(k, v)| {
 LL | |         acc += k + v;
@@ -45,7 +60,7 @@ LL |     }
    |
 
 error: needless use of `for_each`
-  --> $DIR/needless_for_each_fixable.rs:21:5
+  --> $DIR/needless_for_each_fixable.rs:25:5
    |
 LL | /     hash_map.iter_mut().for_each(|(k, v)| {
 LL | |         acc += *k + *v;
@@ -60,7 +75,7 @@ LL |     }
    |
 
 error: needless use of `for_each`
-  --> $DIR/needless_for_each_fixable.rs:24:5
+  --> $DIR/needless_for_each_fixable.rs:28:5
    |
 LL | /     hash_map.keys().for_each(|k| {
 LL | |         acc += k;
@@ -75,7 +90,7 @@ LL |     }
    |
 
 error: needless use of `for_each`
-  --> $DIR/needless_for_each_fixable.rs:27:5
+  --> $DIR/needless_for_each_fixable.rs:31:5
    |
 LL | /     hash_map.values().for_each(|v| {
 LL | |         acc += v;
@@ -90,7 +105,7 @@ LL |     }
    |
 
 error: needless use of `for_each`
-  --> $DIR/needless_for_each_fixable.rs:34:5
+  --> $DIR/needless_for_each_fixable.rs:38:5
    |
 LL | /     my_vec().iter().for_each(|elem| {
 LL | |         acc += elem;
@@ -104,5 +119,5 @@ LL |         acc += elem;
 LL |     }
    |
 
-error: aborting due to 7 previous errors
+error: aborting due to 8 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From bf1e3f7a9f53dd783ddf500ee45e8c0629dd5e67 Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Sun, 14 Mar 2021 10:22:28 +0900
Subject: Skip needless_for_each if an input stmt is local

---
 clippy_lints/src/needless_for_each.rs       | 50 +++++++++++++----------------
 tests/ui/needless_for_each_fixable.fixed    |  5 +++
 tests/ui/needless_for_each_fixable.rs       |  5 +++
 tests/ui/needless_for_each_unfixable.stderr |  9 +++---
 4 files changed, 37 insertions(+), 32 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/needless_for_each.rs b/clippy_lints/src/needless_for_each.rs
index f60b09898ab..727937354d6 100644
--- a/clippy_lints/src/needless_for_each.rs
+++ b/clippy_lints/src/needless_for_each.rs
@@ -49,31 +49,28 @@ impl LateLintPass<'_> for NeedlessForEach {
     fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) {
         let expr = match stmt.kind {
             StmtKind::Expr(expr) | StmtKind::Semi(expr) => expr,
-            StmtKind::Local(local) if local.init.is_some() => local.init.unwrap(),
             _ => return,
         };
 
         if_chain! {
             // Check the method name is `for_each`.
-            if let ExprKind::MethodCall(method_name, _, for_each_args, _) = expr.kind;
+            if let ExprKind::MethodCall(method_name, _, [for_each_recv, for_each_arg], _) = expr.kind;
             if method_name.ident.name == Symbol::intern("for_each");
             // Check `for_each` is an associated function of `Iterator`.
             if is_trait_method(cx, expr, sym::Iterator);
             // Checks the receiver of `for_each` is also a method call.
-            if let Some(for_each_receiver) = for_each_args.get(0);
-            if let ExprKind::MethodCall(_, _, iter_args, _) = for_each_receiver.kind;
+            if let ExprKind::MethodCall(_, _, [iter_recv], _) = for_each_recv.kind;
             // Skip the lint if the call chain is too long. e.g. `v.field.iter().for_each()` or
             // `v.foo().iter().for_each()` must be skipped.
-            if let Some(iter_receiver) = iter_args.get(0);
             if matches!(
-                iter_receiver.kind,
+                iter_recv.kind,
                 ExprKind::Array(..) | ExprKind::Call(..) | ExprKind::Path(..)
             );
             // Checks the type of the `iter` method receiver is NOT a user defined type.
-            if has_iter_method(cx, cx.typeck_results().expr_ty(&iter_receiver)).is_some();
+            if has_iter_method(cx, cx.typeck_results().expr_ty(&iter_recv)).is_some();
             // Skip the lint if the body is not block because this is simpler than `for` loop.
             // e.g. `v.iter().for_each(f)` is simpler and clearer than using `for` loop.
-            if let ExprKind::Closure(_, _, body_id, ..) = for_each_args[1].kind;
+            if let ExprKind::Closure(_, _, body_id, ..) = for_each_arg.kind;
             let body = cx.tcx.hir().body(body_id);
             if let ExprKind::Block(..) = body.value.kind;
             then {
@@ -85,26 +82,27 @@ impl LateLintPass<'_> for NeedlessForEach {
                     return;
                 }
 
-                // We can't use `Applicability::MachineApplicable` when the closure contains `return`
-                // because `Diagnostic::multipart_suggestion` doesn't work with multiple overlapped
-                // spans.
-                let mut applicability = if ret_collector.spans.is_empty() {
-                    Applicability::MachineApplicable
+                let (mut applicability, ret_suggs) = if ret_collector.spans.is_empty() {
+                    (Applicability::MachineApplicable, None)
                 } else {
-                    Applicability::MaybeIncorrect
+                    (
+                        Applicability::MaybeIncorrect,
+                        Some(
+                            ret_collector
+                                .spans
+                                .into_iter()
+                                .map(|span| (span, "continue".to_string()))
+                                .collect(),
+                        ),
+                    )
                 };
 
-                let mut suggs = vec![];
-                suggs.push((stmt.span, format!(
+                let sugg = format!(
                     "for {} in {} {}",
                     snippet_with_applicability(cx, body.params[0].pat.span, "..", &mut applicability),
-                    snippet_with_applicability(cx, for_each_args[0].span, "..", &mut applicability),
+                    snippet_with_applicability(cx, for_each_recv.span, "..", &mut applicability),
                     snippet_with_applicability(cx, body.value.span, "..", &mut applicability),
-                )));
-
-                for span in &ret_collector.spans {
-                    suggs.push((*span, "continue".to_string()));
-                }
+                );
 
                 span_lint_and_then(
                     cx,
@@ -112,11 +110,9 @@ impl LateLintPass<'_> for NeedlessForEach {
                     stmt.span,
                     "needless use of `for_each`",
                     |diag| {
-                        diag.multipart_suggestion("try", suggs, applicability);
-                        // `Diagnostic::multipart_suggestion` ignores the second and subsequent overlapped spans,
-                        // so `span_note` is needed here even though `suggs` includes the replacements.
-                        for span in ret_collector.spans {
-                            diag.span_note(span, "replace `return` with `continue`");
+                        diag.span_suggestion(stmt.span, "try", sugg, applicability);
+                        if let Some(ret_suggs) = ret_suggs {
+                            diag.multipart_suggestion("try replacing `return` with `continue`", ret_suggs, applicability);
                         }
                     }
                 )
diff --git a/tests/ui/needless_for_each_fixable.fixed b/tests/ui/needless_for_each_fixable.fixed
index a4d4937a19a..f00f9ee4c33 100644
--- a/tests/ui/needless_for_each_fixable.fixed
+++ b/tests/ui/needless_for_each_fixable.fixed
@@ -103,6 +103,11 @@ fn should_not_lint() {
             acc += elem;
         }),
     }
+
+    // `for_each` is in a let bingind.
+    let _ = v.iter().for_each(|elem| {
+        acc += elem;
+    });
 }
 
 fn main() {}
diff --git a/tests/ui/needless_for_each_fixable.rs b/tests/ui/needless_for_each_fixable.rs
index b374128f253..1bd400d348b 100644
--- a/tests/ui/needless_for_each_fixable.rs
+++ b/tests/ui/needless_for_each_fixable.rs
@@ -103,6 +103,11 @@ fn should_not_lint() {
             acc += elem;
         }),
     }
+
+    // `for_each` is in a let bingind.
+    let _ = v.iter().for_each(|elem| {
+        acc += elem;
+    });
 }
 
 fn main() {}
diff --git a/tests/ui/needless_for_each_unfixable.stderr b/tests/ui/needless_for_each_unfixable.stderr
index 58d107062bc..bbb63fd8deb 100644
--- a/tests/ui/needless_for_each_unfixable.stderr
+++ b/tests/ui/needless_for_each_unfixable.stderr
@@ -11,11 +11,6 @@ LL | |     });
    | |_______^
    |
    = note: `-D clippy::needless-for-each` implied by `-D warnings`
-note: replace `return` with `continue`
-  --> $DIR/needless_for_each_unfixable.rs:9:13
-   |
-LL |             return;
-   |             ^^^^^^
 help: try
    |
 LL |     for v in v.iter() {
@@ -25,6 +20,10 @@ LL |         } else {
 LL |             println!("{}", v);
 LL |         }
  ...
+help: try replacing `return` with `continue`
+   |
+LL |             continue;
+   |             ^^^^^^^^
 
 error: aborting due to previous error
 
-- 
cgit 1.4.1-3-g733a5


From e61f9782c805f246394f870902140bf32c897b7e Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Mon, 15 Mar 2021 12:01:39 +0900
Subject: Tweak a suggestion message of needless_for_each

---
 clippy_lints/src/needless_for_each.rs       | 21 +++++++++------------
 tests/ui/needless_for_each_unfixable.stderr |  2 +-
 2 files changed, 10 insertions(+), 13 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/needless_for_each.rs b/clippy_lints/src/needless_for_each.rs
index 727937354d6..2ea871990f1 100644
--- a/clippy_lints/src/needless_for_each.rs
+++ b/clippy_lints/src/needless_for_each.rs
@@ -10,7 +10,10 @@ use rustc_span::{source_map::Span, sym, Symbol};
 
 use if_chain::if_chain;
 
-use crate::utils::{has_iter_method, is_trait_method, snippet_with_applicability, span_lint_and_then};
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::is_trait_method;
+use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::ty::has_iter_method;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for usage of `for_each` that would be more simply written as a
@@ -104,18 +107,12 @@ impl LateLintPass<'_> for NeedlessForEach {
                     snippet_with_applicability(cx, body.value.span, "..", &mut applicability),
                 );
 
-                span_lint_and_then(
-                    cx,
-                    NEEDLESS_FOR_EACH,
-                    stmt.span,
-                    "needless use of `for_each`",
-                    |diag| {
-                        diag.span_suggestion(stmt.span, "try", sugg, applicability);
-                        if let Some(ret_suggs) = ret_suggs {
-                            diag.multipart_suggestion("try replacing `return` with `continue`", ret_suggs, applicability);
-                        }
+                span_lint_and_then(cx, NEEDLESS_FOR_EACH, stmt.span, "needless use of `for_each`", |diag| {
+                    diag.span_suggestion(stmt.span, "try", sugg, applicability);
+                    if let Some(ret_suggs) = ret_suggs {
+                        diag.multipart_suggestion("...and replace `return` with `continue`", ret_suggs, applicability);
                     }
-                )
+                })
             }
         }
     }
diff --git a/tests/ui/needless_for_each_unfixable.stderr b/tests/ui/needless_for_each_unfixable.stderr
index bbb63fd8deb..8c4507d2328 100644
--- a/tests/ui/needless_for_each_unfixable.stderr
+++ b/tests/ui/needless_for_each_unfixable.stderr
@@ -20,7 +20,7 @@ LL |         } else {
 LL |             println!("{}", v);
 LL |         }
  ...
-help: try replacing `return` with `continue`
+help: ...and replace `return` with `continue`
    |
 LL |             continue;
    |             ^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From 56fbbf7b8fc7c99a6c54dfff6847770a4ed27eb1 Mon Sep 17 00:00:00 2001
From: Eric Loren <eric.loren@droitfintech.com>
Date: Sat, 14 Nov 2020 19:47:17 -0500
Subject: Suggest `flatten` instead of `is_some` -> `unwrap`

---
 CHANGELOG.md                           |   1 +
 README.md                              |   2 +-
 clippy_lints/src/lib.rs                |   3 +
 clippy_lints/src/methods/filter_map.rs | 213 ++++++++++++++++++++++-----------
 clippy_lints/src/methods/mod.rs        |  27 ++++-
 tests/ui/option_filter_map.fixed       |  23 ++++
 tests/ui/option_filter_map.rs          |  25 ++++
 tests/ui/option_filter_map.stderr      |  56 +++++++++
 8 files changed, 280 insertions(+), 70 deletions(-)
 create mode 100644 tests/ui/option_filter_map.fixed
 create mode 100644 tests/ui/option_filter_map.rs
 create mode 100644 tests/ui/option_filter_map.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 57996802182..47af42e14ca 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2389,6 +2389,7 @@ Released 2018-09-13
 [`op_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#op_ref
 [`option_as_ref_deref`]: https://rust-lang.github.io/rust-clippy/master/index.html#option_as_ref_deref
 [`option_env_unwrap`]: https://rust-lang.github.io/rust-clippy/master/index.html#option_env_unwrap
+[`option_filter_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#option_filter_map
 [`option_if_let_else`]: https://rust-lang.github.io/rust-clippy/master/index.html#option_if_let_else
 [`option_map_or_none`]: https://rust-lang.github.io/rust-clippy/master/index.html#option_map_or_none
 [`option_map_unit_fn`]: https://rust-lang.github.io/rust-clippy/master/index.html#option_map_unit_fn
diff --git a/README.md b/README.md
index 63057609bb6..8c0c16c443d 100644
--- a/README.md
+++ b/README.md
@@ -5,7 +5,7 @@
 
 A collection of lints to catch common mistakes and improve your [Rust](https://github.com/rust-lang/rust) code.
 
-[There are over 400 lints included in this crate!](https://rust-lang.github.io/rust-clippy/master/index.html)
+[There are over 450 lints included in this crate!](https://rust-lang.github.io/rust-clippy/master/index.html)
 
 Lints are divided into categories, each with a default [lint level](https://doc.rust-lang.org/rustc/lints/levels.html).
 You can choose how much Clippy is supposed to ~~annoy~~ help you by changing the lint level by category.
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index f013613119c..82abd4803db 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -804,6 +804,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &methods::NEW_RET_NO_SELF,
         &methods::OK_EXPECT,
         &methods::OPTION_AS_REF_DEREF,
+        &methods::OPTION_FILTER_MAP,
         &methods::OPTION_MAP_OR_NONE,
         &methods::OR_FUN_CALL,
         &methods::RESULT_MAP_OR_INTO_OPTION,
@@ -1596,6 +1597,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&methods::NEW_RET_NO_SELF),
         LintId::of(&methods::OK_EXPECT),
         LintId::of(&methods::OPTION_AS_REF_DEREF),
+        LintId::of(&methods::OPTION_FILTER_MAP),
         LintId::of(&methods::OPTION_MAP_OR_NONE),
         LintId::of(&methods::OR_FUN_CALL),
         LintId::of(&methods::RESULT_MAP_OR_INTO_OPTION),
@@ -1891,6 +1893,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&methods::MANUAL_FILTER_MAP),
         LintId::of(&methods::MANUAL_FIND_MAP),
         LintId::of(&methods::OPTION_AS_REF_DEREF),
+        LintId::of(&methods::OPTION_FILTER_MAP),
         LintId::of(&methods::SEARCH_IS_SOME),
         LintId::of(&methods::SKIP_WHILE_NEXT),
         LintId::of(&methods::SUSPICIOUS_MAP),
diff --git a/clippy_lints/src/methods/filter_map.rs b/clippy_lints/src/methods/filter_map.rs
index 2cb476acb2b..68f8480dc51 100644
--- a/clippy_lints/src/methods/filter_map.rs
+++ b/clippy_lints/src/methods/filter_map.rs
@@ -1,87 +1,166 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::source::snippet;
-use clippy_utils::{is_trait_method, path_to_local_id, SpanlessEq};
+use clippy_utils::source::{indent_of, reindent_multiline, snippet};
+use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::{is_trait_method, path_to_local_id, remove_blocks, SpanlessEq};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
-use rustc_hir::{Expr, ExprKind, PatKind, UnOp};
+use rustc_hir::def::Res;
+use rustc_hir::{Expr, ExprKind, PatKind, QPath, UnOp};
 use rustc_lint::LateContext;
 use rustc_middle::ty::TyS;
-use rustc_span::symbol::sym;
+use rustc_span::source_map::Span;
+use rustc_span::symbol::{sym, Symbol};
+use std::borrow::Cow;
 
 use super::MANUAL_FILTER_MAP;
 use super::MANUAL_FIND_MAP;
+use super::OPTION_FILTER_MAP;
+
+fn is_method<'tcx>(cx: &LateContext<'tcx>, expr: &hir::Expr<'_>, method_name: Symbol) -> bool {
+    match &expr.kind {
+        hir::ExprKind::Path(QPath::TypeRelative(_, ref mname)) => mname.ident.name == method_name,
+        hir::ExprKind::Path(QPath::Resolved(_, segments)) => {
+            segments.segments.last().unwrap().ident.name == method_name
+        },
+        hir::ExprKind::Closure(_, _, c, _, _) => {
+            let body = cx.tcx.hir().body(*c);
+            let closure_expr = remove_blocks(&body.value);
+            let arg_id = body.params[0].pat.hir_id;
+            match closure_expr.kind {
+                hir::ExprKind::MethodCall(hir::PathSegment { ident, .. }, _, ref args, _) => {
+                    if_chain! {
+                    if ident.name == method_name;
+                    if let hir::ExprKind::Path(path) = &args[0].kind;
+                    if let Res::Local(ref local) = cx.qpath_res(path, args[0].hir_id);
+                    then {
+                        return arg_id == *local
+                    }
+                    }
+                    false
+                },
+                _ => false,
+            }
+        },
+        _ => false,
+    }
+}
+
+fn is_option_filter_map<'tcx>(
+    cx: &LateContext<'tcx>,
+    filter_arg: &'tcx hir::Expr<'_>,
+    map_arg: &'tcx hir::Expr<'_>,
+) -> bool {
+    is_method(cx, map_arg, sym::unwrap) && is_method(cx, filter_arg, sym!(is_some))
+}
+
+/// lint use of `filter().map()` for `Iterators`
+fn lint_filter_some_map_unwrap<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx hir::Expr<'_>,
+    filter_recv: &'tcx hir::Expr<'_>,
+    filter_arg: &'tcx hir::Expr<'_>,
+    map_arg: &'tcx hir::Expr<'_>,
+    target_span: Span,
+    methods_span: Span,
+) {
+    let iterator = is_trait_method(cx, expr, sym::Iterator);
+    let option = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&filter_recv), sym::option_type);
+    if (iterator || option) && is_option_filter_map(cx, filter_arg, map_arg) {
+        let msg = "`filter` for `Some` followed by `unwrap`";
+        let help = "consider using `flatten` instead";
+        let sugg = format!(
+            "{}",
+            reindent_multiline(Cow::Borrowed("flatten()"), true, indent_of(cx, target_span),)
+        );
+        span_lint_and_sugg(
+            cx,
+            OPTION_FILTER_MAP,
+            methods_span,
+            msg,
+            help,
+            sugg,
+            Applicability::MachineApplicable,
+        );
+    }
+}
 
 /// lint use of `filter().map()` or `find().map()` for `Iterators`
-pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, is_find: bool) {
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, is_find: bool, target_span: Span) {
     if_chain! {
-        if let ExprKind::MethodCall(_, _, [map_recv, map_arg], map_span) = expr.kind;
-        if let ExprKind::MethodCall(_, _, [_, filter_arg], filter_span) = map_recv.kind;
-        if is_trait_method(cx, map_recv, sym::Iterator);
+            if let ExprKind::MethodCall(_, _, [map_recv, map_arg], map_span) = expr.kind;
+            if let ExprKind::MethodCall(_, _, [filter_recv, filter_arg], filter_span) = map_recv.kind;
+            then {
+              lint_filter_some_map_unwrap(cx, expr, filter_recv, filter_arg,
+                map_arg, target_span, filter_span.to(map_span));
+              if_chain! {
+            if is_trait_method(cx, map_recv, sym::Iterator);
 
-        // filter(|x| ...is_some())...
-        if let ExprKind::Closure(_, _, filter_body_id, ..) = filter_arg.kind;
-        let filter_body = cx.tcx.hir().body(filter_body_id);
-        if let [filter_param] = filter_body.params;
-        // optional ref pattern: `filter(|&x| ..)`
-        let (filter_pat, is_filter_param_ref) = if let PatKind::Ref(ref_pat, _) = filter_param.pat.kind {
-            (ref_pat, true)
-        } else {
-            (filter_param.pat, false)
-        };
-        // closure ends with is_some() or is_ok()
-        if let PatKind::Binding(_, filter_param_id, _, None) = filter_pat.kind;
-        if let ExprKind::MethodCall(path, _, [filter_arg], _) = filter_body.value.kind;
-        if let Some(opt_ty) = cx.typeck_results().expr_ty(filter_arg).ty_adt_def();
-        if let Some(is_result) = if cx.tcx.is_diagnostic_item(sym::option_type, opt_ty.did) {
-            Some(false)
-        } else if cx.tcx.is_diagnostic_item(sym::result_type, opt_ty.did) {
-            Some(true)
-        } else {
-            None
-        };
-        if path.ident.name.as_str() == if is_result { "is_ok" } else { "is_some" };
+            // filter(|x| ...is_some())...
+            if let ExprKind::Closure(_, _, filter_body_id, ..) = filter_arg.kind;
+            let filter_body = cx.tcx.hir().body(filter_body_id);
+            if let [filter_param] = filter_body.params;
+            // optional ref pattern: `filter(|&x| ..)`
+            let (filter_pat, is_filter_param_ref) = if let PatKind::Ref(ref_pat, _) = filter_param.pat.kind {
+                (ref_pat, true)
+            } else {
+                (filter_param.pat, false)
+            };
+            // closure ends with is_some() or is_ok()
+            if let PatKind::Binding(_, filter_param_id, _, None) = filter_pat.kind;
+            if let ExprKind::MethodCall(path, _, [filter_arg], _) = filter_body.value.kind;
+            if let Some(opt_ty) = cx.typeck_results().expr_ty(filter_arg).ty_adt_def();
+            if let Some(is_result) = if cx.tcx.is_diagnostic_item(sym::option_type, opt_ty.did) {
+                Some(false)
+            } else if cx.tcx.is_diagnostic_item(sym::result_type, opt_ty.did) {
+                Some(true)
+            } else {
+                None
+            };
+            if path.ident.name.as_str() == if is_result { "is_ok" } else { "is_some" };
 
-        // ...map(|x| ...unwrap())
-        if let ExprKind::Closure(_, _, map_body_id, ..) = map_arg.kind;
-        let map_body = cx.tcx.hir().body(map_body_id);
-        if let [map_param] = map_body.params;
-        if let PatKind::Binding(_, map_param_id, map_param_ident, None) = map_param.pat.kind;
-        // closure ends with expect() or unwrap()
-        if let ExprKind::MethodCall(seg, _, [map_arg, ..], _) = map_body.value.kind;
-        if matches!(seg.ident.name, sym::expect | sym::unwrap | sym::unwrap_or);
+            // ...map(|x| ...unwrap())
+            if let ExprKind::Closure(_, _, map_body_id, ..) = map_arg.kind;
+            let map_body = cx.tcx.hir().body(map_body_id);
+            if let [map_param] = map_body.params;
+            if let PatKind::Binding(_, map_param_id, map_param_ident, None) = map_param.pat.kind;
+            // closure ends with expect() or unwrap()
+            if let ExprKind::MethodCall(seg, _, [map_arg, ..], _) = map_body.value.kind;
+            if matches!(seg.ident.name, sym::expect | sym::unwrap | sym::unwrap_or);
 
-        let eq_fallback = |a: &Expr<'_>, b: &Expr<'_>| {
-            // in `filter(|x| ..)`, replace `*x` with `x`
-            let a_path = if_chain! {
-                if !is_filter_param_ref;
-                if let ExprKind::Unary(UnOp::Deref, expr_path) = a.kind;
-                then { expr_path } else { a }
-            };
-            // let the filter closure arg and the map closure arg be equal
-            if_chain! {
-                if path_to_local_id(a_path, filter_param_id);
-                if path_to_local_id(b, map_param_id);
-                if TyS::same_type(cx.typeck_results().expr_ty_adjusted(a), cx.typeck_results().expr_ty_adjusted(b));
-                then {
-                    return true;
+            let eq_fallback = |a: &Expr<'_>, b: &Expr<'_>| {
+                // in `filter(|x| ..)`, replace `*x` with `x`
+                let a_path = if_chain! {
+                    if !is_filter_param_ref;
+                    if let ExprKind::Unary(UnOp::Deref, expr_path) = a.kind;
+                    then { expr_path } else { a }
+                };
+                // let the filter closure arg and the map closure arg be equal
+                if_chain! {
+                    if path_to_local_id(a_path, filter_param_id);
+                    if path_to_local_id(b, map_param_id);
+                    if TyS::same_type(cx.typeck_results().expr_ty_adjusted(a), cx.typeck_results().expr_ty_adjusted(b));
+                    then {
+                        return true;
+                    }
                 }
-            }
-            false
-        };
-        if SpanlessEq::new(cx).expr_fallback(eq_fallback).eq_expr(filter_arg, map_arg);
-        then {
-            let span = filter_span.to(map_span);
-            let (filter_name, lint) = if is_find {
-                ("find", MANUAL_FIND_MAP)
-            } else {
-                ("filter", MANUAL_FILTER_MAP)
+                false
             };
-            let msg = format!("`{}(..).map(..)` can be simplified as `{0}_map(..)`", filter_name);
-            let to_opt = if is_result { ".ok()" } else { "" };
-            let sugg = format!("{}_map(|{}| {}{})", filter_name, map_param_ident,
-                snippet(cx, map_arg.span, ".."), to_opt);
-            span_lint_and_sugg(cx, lint, span, &msg, "try", sugg, Applicability::MachineApplicable);
+            if SpanlessEq::new(cx).expr_fallback(eq_fallback).eq_expr(filter_arg, map_arg);
+            then {
+                let span = filter_span.to(map_span);
+                let (filter_name, lint) = if is_find {
+                    ("find", MANUAL_FIND_MAP)
+                } else {
+                    ("filter", MANUAL_FILTER_MAP)
+                };
+                let msg = format!("`{}(..).map(..)` can be simplified as `{0}_map(..)`", filter_name);
+                let to_opt = if is_result { ".ok()" } else { "" };
+                let sugg = format!("{}_map(|{}| {}{})", filter_name, map_param_ident,
+                    snippet(cx, map_arg.span, ".."), to_opt);
+                span_lint_and_sugg(cx, lint, span, &msg, "try", sugg, Applicability::MachineApplicable);
+            }
+        }
         }
     }
 }
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index fccdee07877..8a04fd0060d 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -896,6 +896,28 @@ declare_clippy_lint! {
     "using `Iterator::step_by(0)`, which will panic at runtime"
 }
 
+declare_clippy_lint! {
+    /// **What it does:** Checks for indirect collection of populated `Option`
+    ///
+    /// **Why is this bad?** `Option` is like a collection of 0-1 things, so `flatten`
+    /// automatically does this without suspicious-looking `unwrap` calls.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// let _ = std::iter::empty::<Option<i32>>().filter(Option::is_some).map(Option::unwrap);
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// let _ = std::iter::empty::<Option<i32>>().flatten();
+    /// ```
+    pub OPTION_FILTER_MAP,
+    complexity,
+    "filtering `Option` for `Some` then force-unwrapping, which can be one type-safe operation"
+}
+
 declare_clippy_lint! {
     /// **What it does:** Checks for the use of `iter.nth(0)`.
     ///
@@ -1651,6 +1673,7 @@ impl_lint_pass!(Methods => [
     FILTER_MAP_IDENTITY,
     MANUAL_FILTER_MAP,
     MANUAL_FIND_MAP,
+    OPTION_FILTER_MAP,
     FILTER_MAP_NEXT,
     FLAT_MAP_IDENTITY,
     MAP_FLATTEN,
@@ -1720,10 +1743,10 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             ["next", "filter"] => filter_next::check(cx, expr, arg_lists[1]),
             ["next", "skip_while"] => skip_while_next::check(cx, expr, arg_lists[1]),
             ["next", "iter"] => iter_next_slice::check(cx, expr, arg_lists[1]),
-            ["map", "filter"] => filter_map::check(cx, expr, false),
+            ["map", "filter"] => filter_map::check(cx, expr, false, method_spans[0]),
             ["map", "filter_map"] => filter_map_map::check(cx, expr),
             ["next", "filter_map"] => filter_map_next::check(cx, expr, arg_lists[1], self.msrv.as_ref()),
-            ["map", "find"] => filter_map::check(cx, expr, true),
+            ["map", "find"] => filter_map::check(cx, expr, true, method_spans[0]),
             ["flat_map", "filter"] => filter_flat_map::check(cx, expr),
             ["flat_map", "filter_map"] => filter_map_flat_map::check(cx, expr),
             ["flat_map", ..] => flat_map_identity::check(cx, expr, arg_lists[0], method_spans[0]),
diff --git a/tests/ui/option_filter_map.fixed b/tests/ui/option_filter_map.fixed
new file mode 100644
index 00000000000..f9d1825ade0
--- /dev/null
+++ b/tests/ui/option_filter_map.fixed
@@ -0,0 +1,23 @@
+#![warn(clippy::option_filter_map)]
+// run-rustfix
+fn odds_out(x: i32) -> Option<i32> {
+    if x % 2 == 0 { Some(x) } else { None }
+}
+
+fn main() {
+    let _ = Some(Some(1)).flatten();
+    let _ = Some(Some(1)).flatten();
+    let _ = Some(1).map(odds_out).flatten();
+    let _ = Some(1).map(odds_out).flatten();
+
+    let _ = vec![Some(1)].into_iter().flatten();
+    let _ = vec![Some(1)].into_iter().flatten();
+    let _ = vec![1]
+        .into_iter()
+        .map(odds_out)
+        .flatten();
+    let _ = vec![1]
+        .into_iter()
+        .map(odds_out)
+        .flatten();
+}
diff --git a/tests/ui/option_filter_map.rs b/tests/ui/option_filter_map.rs
new file mode 100644
index 00000000000..588e1ccccce
--- /dev/null
+++ b/tests/ui/option_filter_map.rs
@@ -0,0 +1,25 @@
+#![warn(clippy::option_filter_map)]
+// run-rustfix
+fn odds_out(x: i32) -> Option<i32> {
+    if x % 2 == 0 { Some(x) } else { None }
+}
+
+fn main() {
+    let _ = Some(Some(1)).filter(Option::is_some).map(Option::unwrap);
+    let _ = Some(Some(1)).filter(|o| o.is_some()).map(|o| o.unwrap());
+    let _ = Some(1).map(odds_out).filter(Option::is_some).map(Option::unwrap);
+    let _ = Some(1).map(odds_out).filter(|o| o.is_some()).map(|o| o.unwrap());
+
+    let _ = vec![Some(1)].into_iter().filter(Option::is_some).map(Option::unwrap);
+    let _ = vec![Some(1)].into_iter().filter(|o| o.is_some()).map(|o| o.unwrap());
+    let _ = vec![1]
+        .into_iter()
+        .map(odds_out)
+        .filter(Option::is_some)
+        .map(Option::unwrap);
+    let _ = vec![1]
+        .into_iter()
+        .map(odds_out)
+        .filter(|o| o.is_some())
+        .map(|o| o.unwrap());
+}
diff --git a/tests/ui/option_filter_map.stderr b/tests/ui/option_filter_map.stderr
new file mode 100644
index 00000000000..31a82969d5a
--- /dev/null
+++ b/tests/ui/option_filter_map.stderr
@@ -0,0 +1,56 @@
+error: `filter` for `Some` followed by `unwrap`
+  --> $DIR/option_filter_map.rs:8:27
+   |
+LL |     let _ = Some(Some(1)).filter(Option::is_some).map(Option::unwrap);
+   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
+   |
+   = note: `-D clippy::option-filter-map` implied by `-D warnings`
+
+error: `filter` for `Some` followed by `unwrap`
+  --> $DIR/option_filter_map.rs:9:27
+   |
+LL |     let _ = Some(Some(1)).filter(|o| o.is_some()).map(|o| o.unwrap());
+   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
+
+error: `filter` for `Some` followed by `unwrap`
+  --> $DIR/option_filter_map.rs:10:35
+   |
+LL |     let _ = Some(1).map(odds_out).filter(Option::is_some).map(Option::unwrap);
+   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
+
+error: `filter` for `Some` followed by `unwrap`
+  --> $DIR/option_filter_map.rs:11:35
+   |
+LL |     let _ = Some(1).map(odds_out).filter(|o| o.is_some()).map(|o| o.unwrap());
+   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
+
+error: `filter` for `Some` followed by `unwrap`
+  --> $DIR/option_filter_map.rs:13:39
+   |
+LL |     let _ = vec![Some(1)].into_iter().filter(Option::is_some).map(Option::unwrap);
+   |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
+
+error: `filter` for `Some` followed by `unwrap`
+  --> $DIR/option_filter_map.rs:14:39
+   |
+LL |     let _ = vec![Some(1)].into_iter().filter(|o| o.is_some()).map(|o| o.unwrap());
+   |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
+
+error: `filter` for `Some` followed by `unwrap`
+  --> $DIR/option_filter_map.rs:18:10
+   |
+LL |           .filter(Option::is_some)
+   |  __________^
+LL | |         .map(Option::unwrap);
+   | |____________________________^ help: consider using `flatten` instead: `flatten()`
+
+error: `filter` for `Some` followed by `unwrap`
+  --> $DIR/option_filter_map.rs:23:10
+   |
+LL |           .filter(|o| o.is_some())
+   |  __________^
+LL | |         .map(|o| o.unwrap());
+   | |____________________________^ help: consider using `flatten` instead: `flatten()`
+
+error: aborting due to 8 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 21083875d211c29fcfa4a21fcd66d4601d2b618b Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Wed, 10 Mar 2021 23:40:20 -0600
Subject: Destructure args in methods module

---
 clippy_lints/src/methods/bind_instead_of_map.rs    |  14 +-
 clippy_lints/src/methods/bytes_nth.rs              |  11 +-
 clippy_lints/src/methods/expect_used.rs            |   4 +-
 clippy_lints/src/methods/filetype_is_file.rs       |   4 +-
 clippy_lints/src/methods/filter_map.rs             |  50 ++--
 clippy_lints/src/methods/filter_map_identity.rs    |  15 +-
 clippy_lints/src/methods/filter_map_next.rs        |   7 +-
 clippy_lints/src/methods/filter_next.rs            |  11 +-
 clippy_lints/src/methods/flat_map_identity.rs      |   4 +-
 clippy_lints/src/methods/get_unwrap.rs             |  20 +-
 clippy_lints/src/methods/iter_cloned_collect.rs    |   4 +-
 clippy_lints/src/methods/iter_count.rs             |   8 +-
 clippy_lints/src/methods/iter_next_slice.rs        |   4 +-
 clippy_lints/src/methods/iter_nth.rs               |  14 +-
 clippy_lints/src/methods/iter_nth_zero.rs          |   6 +-
 clippy_lints/src/methods/iter_skip_next.rs         |  22 +-
 clippy_lints/src/methods/iterator_step_by_zero.rs  |   4 +-
 .../src/methods/manual_saturating_arithmetic.rs    |  13 +-
 .../src/methods/map_collect_result_unit.rs         |   9 +-
 clippy_lints/src/methods/map_flatten.rs            |  19 +-
 clippy_lints/src/methods/map_unwrap_or.rs          |  21 +-
 clippy_lints/src/methods/mod.rs                    | 283 ++++++++++++---------
 clippy_lints/src/methods/ok_expect.rs              |   6 +-
 clippy_lints/src/methods/option_as_ref_deref.rs    |  16 +-
 clippy_lints/src/methods/option_map_or_none.rs     |  22 +-
 clippy_lints/src/methods/option_map_unwrap_or.rs   |  22 +-
 clippy_lints/src/methods/search_is_some.rs         |  88 ++++---
 clippy_lints/src/methods/skip_while_next.rs        |   2 +-
 clippy_lints/src/methods/string_extend_chars.rs    |   7 +-
 clippy_lints/src/methods/suspicious_map.rs         |   9 +-
 clippy_lints/src/methods/uninit_assumed_init.rs    |   8 +-
 clippy_lints/src/methods/unnecessary_filter_map.rs |   4 +-
 clippy_lints/src/methods/unnecessary_fold.rs       |  33 +--
 clippy_lints/src/methods/unnecessary_lazy_eval.rs  |  11 +-
 clippy_lints/src/methods/unwrap_used.rs            |   4 +-
 clippy_lints/src/methods/useless_asref.rs          |   3 +-
 clippy_lints/src/methods/zst_offset.rs             |   5 +-
 37 files changed, 412 insertions(+), 375 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/bind_instead_of_map.rs b/clippy_lints/src/methods/bind_instead_of_map.rs
index 0ba8a98a018..8ccb8f4268c 100644
--- a/clippy_lints/src/methods/bind_instead_of_map.rs
+++ b/clippy_lints/src/methods/bind_instead_of_map.rs
@@ -80,7 +80,7 @@ pub(crate) trait BindInsteadOfMap {
     fn lint_closure_autofixable(
         cx: &LateContext<'_>,
         expr: &hir::Expr<'_>,
-        args: &[hir::Expr<'_>],
+        recv: &hir::Expr<'_>,
         closure_expr: &hir::Expr<'_>,
         closure_args_span: Span,
     ) -> bool {
@@ -103,7 +103,7 @@ pub(crate) trait BindInsteadOfMap {
                 };
 
                 let closure_args_snip = snippet(cx, closure_args_span, "..");
-                let option_snip = snippet(cx, args[0].span, "..");
+                let option_snip = snippet(cx, recv.span, "..");
                 let note = format!("{}.{}({} {})", option_snip, Self::GOOD_METHOD_NAME, closure_args_snip, some_inner_snip);
                 span_lint_and_sugg(
                     cx,
@@ -158,17 +158,17 @@ pub(crate) trait BindInsteadOfMap {
     }
 
     /// Lint use of `_.and_then(|x| Some(y))` for `Option`s
-    fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::Expr<'_>]) -> bool {
-        if !match_type(cx, cx.typeck_results().expr_ty(&args[0]), Self::TYPE_QPATH) {
+    fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr<'_>, arg: &hir::Expr<'_>) -> bool {
+        if !match_type(cx, cx.typeck_results().expr_ty(recv), Self::TYPE_QPATH) {
             return false;
         }
 
-        match args[1].kind {
+        match arg.kind {
             hir::ExprKind::Closure(_, _, body_id, closure_args_span, _) => {
                 let closure_body = cx.tcx.hir().body(body_id);
                 let closure_expr = remove_blocks(&closure_body.value);
 
-                if Self::lint_closure_autofixable(cx, expr, args, closure_expr, closure_args_span) {
+                if Self::lint_closure_autofixable(cx, expr, recv, closure_expr, closure_args_span) {
                     true
                 } else {
                     Self::lint_closure(cx, expr, closure_expr)
@@ -182,7 +182,7 @@ pub(crate) trait BindInsteadOfMap {
                     expr.span,
                     Self::no_op_msg().as_ref(),
                     "use the expression directly",
-                    snippet(cx, args[0].span, "..").into(),
+                    snippet(cx, recv.span, "..").into(),
                     Applicability::MachineApplicable,
                 );
                 true
diff --git a/clippy_lints/src/methods/bytes_nth.rs b/clippy_lints/src/methods/bytes_nth.rs
index 4f88f80a304..77f140510b6 100644
--- a/clippy_lints/src/methods/bytes_nth.rs
+++ b/clippy_lints/src/methods/bytes_nth.rs
@@ -3,16 +3,15 @@ use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
-use rustc_hir::{Expr, ExprKind};
+use rustc_hir::Expr;
 use rustc_lint::LateContext;
 use rustc_span::sym;
 
 use super::BYTES_NTH;
 
-pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, iter_args: &'tcx [Expr<'tcx>]) {
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, recv: &'tcx Expr<'tcx>, n_arg: &'tcx Expr<'tcx>) {
     if_chain! {
-        if let ExprKind::MethodCall(_, _, ref args, _) = expr.kind;
-        let ty = cx.typeck_results().expr_ty(&iter_args[0]).peel_refs();
+        let ty = cx.typeck_results().expr_ty(recv).peel_refs();
         let caller_type = if is_type_diagnostic_item(cx, ty, sym::string_type) {
             Some("String")
         } else if ty.is_str() {
@@ -31,8 +30,8 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, iter_args: &'
                 "try",
                 format!(
                     "{}.as_bytes().get({})",
-                    snippet_with_applicability(cx, iter_args[0].span, "..", &mut applicability),
-                    snippet_with_applicability(cx, args[1].span, "..", &mut applicability)
+                    snippet_with_applicability(cx, recv.span, "..", &mut applicability),
+                    snippet_with_applicability(cx, n_arg.span, "..", &mut applicability)
                 ),
                 applicability,
             );
diff --git a/clippy_lints/src/methods/expect_used.rs b/clippy_lints/src/methods/expect_used.rs
index 64531b29ade..63a834fdce0 100644
--- a/clippy_lints/src/methods/expect_used.rs
+++ b/clippy_lints/src/methods/expect_used.rs
@@ -7,8 +7,8 @@ use rustc_span::sym;
 use super::EXPECT_USED;
 
 /// lint use of `expect()` for `Option`s and `Result`s
-pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, expect_args: &[hir::Expr<'_>]) {
-    let obj_ty = cx.typeck_results().expr_ty(&expect_args[0]).peel_refs();
+pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr<'_>) {
+    let obj_ty = cx.typeck_results().expr_ty(recv).peel_refs();
 
     let mess = if is_type_diagnostic_item(cx, obj_ty, sym::option_type) {
         Some((EXPECT_USED, "an Option", "None"))
diff --git a/clippy_lints/src/methods/filetype_is_file.rs b/clippy_lints/src/methods/filetype_is_file.rs
index 39d2f15dbc8..7b2967feb0f 100644
--- a/clippy_lints/src/methods/filetype_is_file.rs
+++ b/clippy_lints/src/methods/filetype_is_file.rs
@@ -8,8 +8,8 @@ use rustc_span::source_map::Span;
 
 use super::FILETYPE_IS_FILE;
 
-pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::Expr<'_>]) {
-    let ty = cx.typeck_results().expr_ty(&args[0]);
+pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr<'_>) {
+    let ty = cx.typeck_results().expr_ty(recv);
 
     if !match_type(cx, ty, &paths::FILE_TYPE) {
         return;
diff --git a/clippy_lints/src/methods/filter_map.rs b/clippy_lints/src/methods/filter_map.rs
index 68f8480dc51..45d1ed953b4 100644
--- a/clippy_lints/src/methods/filter_map.rs
+++ b/clippy_lints/src/methods/filter_map.rs
@@ -46,21 +46,17 @@ fn is_method<'tcx>(cx: &LateContext<'tcx>, expr: &hir::Expr<'_>, method_name: Sy
     }
 }
 
-fn is_option_filter_map<'tcx>(
-    cx: &LateContext<'tcx>,
-    filter_arg: &'tcx hir::Expr<'_>,
-    map_arg: &'tcx hir::Expr<'_>,
-) -> bool {
+fn is_option_filter_map<'tcx>(cx: &LateContext<'tcx>, filter_arg: &hir::Expr<'_>, map_arg: &hir::Expr<'_>) -> bool {
     is_method(cx, map_arg, sym::unwrap) && is_method(cx, filter_arg, sym!(is_some))
 }
 
 /// lint use of `filter().map()` for `Iterators`
-fn lint_filter_some_map_unwrap<'tcx>(
-    cx: &LateContext<'tcx>,
-    expr: &'tcx hir::Expr<'_>,
-    filter_recv: &'tcx hir::Expr<'_>,
-    filter_arg: &'tcx hir::Expr<'_>,
-    map_arg: &'tcx hir::Expr<'_>,
+fn lint_filter_some_map_unwrap(
+    cx: &LateContext<'_>,
+    expr: &hir::Expr<'_>,
+    filter_recv: &hir::Expr<'_>,
+    filter_arg: &hir::Expr<'_>,
+    map_arg: &hir::Expr<'_>,
     target_span: Span,
     methods_span: Span,
 ) {
@@ -86,14 +82,28 @@ fn lint_filter_some_map_unwrap<'tcx>(
 }
 
 /// lint use of `filter().map()` or `find().map()` for `Iterators`
-pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, is_find: bool, target_span: Span) {
+#[allow(clippy::too_many_arguments)]
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &hir::Expr<'_>,
+    filter_recv: &hir::Expr<'_>,
+    filter_arg: &hir::Expr<'_>,
+    filter_span: Span,
+    map_recv: &hir::Expr<'_>,
+    map_arg: &hir::Expr<'_>,
+    map_span: Span,
+    is_find: bool,
+) {
+    lint_filter_some_map_unwrap(
+        cx,
+        expr,
+        filter_recv,
+        filter_arg,
+        map_arg,
+        map_span,
+        filter_span.with_hi(expr.span.hi()),
+    );
     if_chain! {
-            if let ExprKind::MethodCall(_, _, [map_recv, map_arg], map_span) = expr.kind;
-            if let ExprKind::MethodCall(_, _, [filter_recv, filter_arg], filter_span) = map_recv.kind;
-            then {
-              lint_filter_some_map_unwrap(cx, expr, filter_recv, filter_arg,
-                map_arg, target_span, filter_span.to(map_span));
-              if_chain! {
             if is_trait_method(cx, map_recv, sym::Iterator);
 
             // filter(|x| ...is_some())...
@@ -148,7 +158,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, is_
             };
             if SpanlessEq::new(cx).expr_fallback(eq_fallback).eq_expr(filter_arg, map_arg);
             then {
-                let span = filter_span.to(map_span);
+                let span = filter_span.with_hi(expr.span.hi());
                 let (filter_name, lint) = if is_find {
                     ("find", MANUAL_FIND_MAP)
                 } else {
@@ -160,7 +170,5 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, is_
                     snippet(cx, map_arg.span, ".."), to_opt);
                 span_lint_and_sugg(cx, lint, span, &msg, "try", sugg, Applicability::MachineApplicable);
             }
-        }
-        }
     }
 }
diff --git a/clippy_lints/src/methods/filter_map_identity.rs b/clippy_lints/src/methods/filter_map_identity.rs
index 80598d88508..3a61f4ccad7 100644
--- a/clippy_lints/src/methods/filter_map_identity.rs
+++ b/clippy_lints/src/methods/filter_map_identity.rs
@@ -8,15 +8,8 @@ use rustc_span::{source_map::Span, sym};
 
 use super::FILTER_MAP_IDENTITY;
 
-pub(super) fn check(
-    cx: &LateContext<'_>,
-    expr: &hir::Expr<'_>,
-    filter_map_args: &[hir::Expr<'_>],
-    filter_map_span: Span,
-) {
+pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, filter_map_arg: &hir::Expr<'_>, filter_map_span: Span) {
     if is_trait_method(cx, expr, sym::Iterator) {
-        let arg_node = &filter_map_args[1].kind;
-
         let apply_lint = |message: &str| {
             span_lint_and_sugg(
                 cx,
@@ -30,8 +23,8 @@ pub(super) fn check(
         };
 
         if_chain! {
-            if let hir::ExprKind::Closure(_, _, body_id, _, _) = arg_node;
-            let body = cx.tcx.hir().body(*body_id);
+            if let hir::ExprKind::Closure(_, _, body_id, _, _) = filter_map_arg.kind;
+            let body = cx.tcx.hir().body(body_id);
 
             if let hir::PatKind::Binding(_, binding_id, ..) = body.params[0].pat.kind;
             if path_to_local_id(&body.value, binding_id);
@@ -41,7 +34,7 @@ pub(super) fn check(
         }
 
         if_chain! {
-            if let hir::ExprKind::Path(ref qpath) = arg_node;
+            if let hir::ExprKind::Path(ref qpath) = filter_map_arg.kind;
 
             if match_qpath(qpath, &paths::STD_CONVERT_IDENTITY);
 
diff --git a/clippy_lints/src/methods/filter_map_next.rs b/clippy_lints/src/methods/filter_map_next.rs
index ba57abd16c9..2b19e4ee8c0 100644
--- a/clippy_lints/src/methods/filter_map_next.rs
+++ b/clippy_lints/src/methods/filter_map_next.rs
@@ -14,7 +14,8 @@ const FILTER_MAP_NEXT_MSRV: RustcVersion = RustcVersion::new(1, 30, 0);
 pub(super) fn check<'tcx>(
     cx: &LateContext<'tcx>,
     expr: &'tcx hir::Expr<'_>,
-    filter_args: &'tcx [hir::Expr<'_>],
+    recv: &'tcx hir::Expr<'_>,
+    arg: &'tcx hir::Expr<'_>,
     msrv: Option<&RustcVersion>,
 ) {
     if is_trait_method(cx, expr, sym::Iterator) {
@@ -24,9 +25,9 @@ pub(super) fn check<'tcx>(
 
         let msg = "called `filter_map(..).next()` on an `Iterator`. This is more succinctly expressed by calling \
                    `.find_map(..)` instead";
-        let filter_snippet = snippet(cx, filter_args[1].span, "..");
+        let filter_snippet = snippet(cx, arg.span, "..");
         if filter_snippet.lines().count() <= 1 {
-            let iter_snippet = snippet(cx, filter_args[0].span, "..");
+            let iter_snippet = snippet(cx, recv.span, "..");
             span_lint_and_sugg(
                 cx,
                 FILTER_MAP_NEXT,
diff --git a/clippy_lints/src/methods/filter_next.rs b/clippy_lints/src/methods/filter_next.rs
index 6cd24334414..172714f6b01 100644
--- a/clippy_lints/src/methods/filter_next.rs
+++ b/clippy_lints/src/methods/filter_next.rs
@@ -9,14 +9,19 @@ use rustc_span::sym;
 use super::FILTER_NEXT;
 
 /// lint use of `filter().next()` for `Iterators`
-pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, filter_args: &'tcx [hir::Expr<'_>]) {
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx hir::Expr<'_>,
+    recv: &'tcx hir::Expr<'_>,
+    filter_arg: &'tcx hir::Expr<'_>,
+) {
     // lint if caller of `.filter().next()` is an Iterator
     if is_trait_method(cx, expr, sym::Iterator) {
         let msg = "called `filter(..).next()` on an `Iterator`. This is more succinctly expressed by calling \
                    `.find(..)` instead";
-        let filter_snippet = snippet(cx, filter_args[1].span, "..");
+        let filter_snippet = snippet(cx, filter_arg.span, "..");
         if filter_snippet.lines().count() <= 1 {
-            let iter_snippet = snippet(cx, filter_args[0].span, "..");
+            let iter_snippet = snippet(cx, recv.span, "..");
             // add note if not multi-line
             span_lint_and_sugg(
                 cx,
diff --git a/clippy_lints/src/methods/flat_map_identity.rs b/clippy_lints/src/methods/flat_map_identity.rs
index 034ea6c6562..664885a2f0e 100644
--- a/clippy_lints/src/methods/flat_map_identity.rs
+++ b/clippy_lints/src/methods/flat_map_identity.rs
@@ -12,11 +12,11 @@ use super::FLAT_MAP_IDENTITY;
 pub(super) fn check<'tcx>(
     cx: &LateContext<'tcx>,
     expr: &'tcx hir::Expr<'_>,
-    flat_map_args: &'tcx [hir::Expr<'_>],
+    flat_map_arg: &'tcx hir::Expr<'_>,
     flat_map_span: Span,
 ) {
     if is_trait_method(cx, expr, sym::Iterator) {
-        let arg_node = &flat_map_args[1].kind;
+        let arg_node = &flat_map_arg.kind;
 
         let apply_lint = |message: &str| {
             span_lint_and_sugg(
diff --git a/clippy_lints/src/methods/get_unwrap.rs b/clippy_lints/src/methods/get_unwrap.rs
index b3a9743c614..54f28064384 100644
--- a/clippy_lints/src/methods/get_unwrap.rs
+++ b/clippy_lints/src/methods/get_unwrap.rs
@@ -11,18 +11,20 @@ use rustc_span::sym;
 
 use super::GET_UNWRAP;
 
-pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &hir::Expr<'_>, get_args: &'tcx [hir::Expr<'_>], is_mut: bool) {
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &hir::Expr<'_>,
+    recv: &'tcx hir::Expr<'tcx>,
+    get_arg: &'tcx hir::Expr<'_>,
+    is_mut: bool,
+) {
     // Note: we don't want to lint `get_mut().unwrap` for `HashMap` or `BTreeMap`,
     // because they do not implement `IndexMut`
     let mut applicability = Applicability::MachineApplicable;
-    let expr_ty = cx.typeck_results().expr_ty(&get_args[0]);
-    let get_args_str = if get_args.len() > 1 {
-        snippet_with_applicability(cx, get_args[1].span, "..", &mut applicability)
-    } else {
-        return; // not linting on a .get().unwrap() chain or variant
-    };
+    let expr_ty = cx.typeck_results().expr_ty(recv);
+    let get_args_str = snippet_with_applicability(cx, get_arg.span, "..", &mut applicability);
     let mut needs_ref;
-    let caller_type = if derefs_to_slice(cx, &get_args[0], expr_ty).is_some() {
+    let caller_type = if derefs_to_slice(cx, recv, expr_ty).is_some() {
         needs_ref = get_args_str.parse::<usize>().is_ok();
         "slice"
     } else if is_type_diagnostic_item(cx, expr_ty, sym::vec_type) {
@@ -77,7 +79,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &hir::Expr<'_>, get_args
         format!(
             "{}{}[{}]",
             borrow_str,
-            snippet_with_applicability(cx, get_args[0].span, "..", &mut applicability),
+            snippet_with_applicability(cx, recv.span, "..", &mut applicability),
             get_args_str
         ),
         applicability,
diff --git a/clippy_lints/src/methods/iter_cloned_collect.rs b/clippy_lints/src/methods/iter_cloned_collect.rs
index 848f47e39f6..739f313716e 100644
--- a/clippy_lints/src/methods/iter_cloned_collect.rs
+++ b/clippy_lints/src/methods/iter_cloned_collect.rs
@@ -9,10 +9,10 @@ use rustc_span::sym;
 
 use super::ITER_CLONED_COLLECT;
 
-pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &hir::Expr<'_>, iter_args: &'tcx [hir::Expr<'_>]) {
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &hir::Expr<'_>, recv: &'tcx hir::Expr<'_>) {
     if_chain! {
         if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(expr), sym::vec_type);
-        if let Some(slice) = derefs_to_slice(cx, &iter_args[0], cx.typeck_results().expr_ty(&iter_args[0]));
+        if let Some(slice) = derefs_to_slice(cx, recv, cx.typeck_results().expr_ty(recv));
         if let Some(to_replace) = expr.span.trim_start(slice.span.source_callsite());
 
         then {
diff --git a/clippy_lints/src/methods/iter_count.rs b/clippy_lints/src/methods/iter_count.rs
index e394a8fe819..c6b7c7cd179 100644
--- a/clippy_lints/src/methods/iter_count.rs
+++ b/clippy_lints/src/methods/iter_count.rs
@@ -10,9 +10,9 @@ use rustc_span::sym;
 
 use super::ITER_COUNT;
 
-pub(crate) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, iter_args: &'tcx [Expr<'tcx>], iter_method: &str) {
-    let ty = cx.typeck_results().expr_ty(&iter_args[0]);
-    let caller_type = if derefs_to_slice(cx, &iter_args[0], ty).is_some() {
+pub(crate) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, recv: &'tcx Expr<'tcx>, iter_method: &str) {
+    let ty = cx.typeck_results().expr_ty(recv);
+    let caller_type = if derefs_to_slice(cx, recv, ty).is_some() {
         "slice"
     } else if is_type_diagnostic_item(cx, ty, sym::vec_type) {
         "Vec"
@@ -42,7 +42,7 @@ pub(crate) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, iter_args: &'
         "try",
         format!(
             "{}.len()",
-            snippet_with_applicability(cx, iter_args[0].span, "..", &mut applicability),
+            snippet_with_applicability(cx, recv.span, "..", &mut applicability),
         ),
         applicability,
     );
diff --git a/clippy_lints/src/methods/iter_next_slice.rs b/clippy_lints/src/methods/iter_next_slice.rs
index e9b37b6f2bd..dab0a43a096 100644
--- a/clippy_lints/src/methods/iter_next_slice.rs
+++ b/clippy_lints/src/methods/iter_next_slice.rs
@@ -13,9 +13,7 @@ use rustc_span::symbol::sym;
 
 use super::ITER_NEXT_SLICE;
 
-pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, iter_args: &'tcx [hir::Expr<'_>]) {
-    let caller_expr = &iter_args[0];
-
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, caller_expr: &'tcx hir::Expr<'_>) {
     // Skip lint if the `iter().next()` expression is a for loop argument,
     // since it is already covered by `&loops::ITER_NEXT_LOOP`
     let mut parent_expr_opt = get_parent_expr(cx, expr);
diff --git a/clippy_lints/src/methods/iter_nth.rs b/clippy_lints/src/methods/iter_nth.rs
index c46af427b3c..c2232239fe4 100644
--- a/clippy_lints/src/methods/iter_nth.rs
+++ b/clippy_lints/src/methods/iter_nth.rs
@@ -11,20 +11,20 @@ use super::ITER_NTH;
 pub(super) fn check<'tcx>(
     cx: &LateContext<'tcx>,
     expr: &hir::Expr<'_>,
-    nth_and_iter_args: &[&'tcx [hir::Expr<'tcx>]],
+    iter_recv: &'tcx hir::Expr<'tcx>,
+    nth_recv: &hir::Expr<'_>,
+    nth_arg: &hir::Expr<'_>,
     is_mut: bool,
 ) {
-    let iter_args = nth_and_iter_args[1];
     let mut_str = if is_mut { "_mut" } else { "" };
-    let caller_type = if derefs_to_slice(cx, &iter_args[0], cx.typeck_results().expr_ty(&iter_args[0])).is_some() {
+    let caller_type = if derefs_to_slice(cx, iter_recv, cx.typeck_results().expr_ty(iter_recv)).is_some() {
         "slice"
-    } else if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&iter_args[0]), sym::vec_type) {
+    } else if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(iter_recv), sym::vec_type) {
         "Vec"
-    } else if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&iter_args[0]), sym::vecdeque_type) {
+    } else if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(iter_recv), sym::vecdeque_type) {
         "VecDeque"
     } else {
-        let nth_args = nth_and_iter_args[0];
-        iter_nth_zero::check(cx, expr, &nth_args);
+        iter_nth_zero::check(cx, expr, nth_recv, nth_arg);
         return; // caller is not a type that we want to lint
     };
 
diff --git a/clippy_lints/src/methods/iter_nth_zero.rs b/clippy_lints/src/methods/iter_nth_zero.rs
index a12f672739c..52d7c15332e 100644
--- a/clippy_lints/src/methods/iter_nth_zero.rs
+++ b/clippy_lints/src/methods/iter_nth_zero.rs
@@ -10,10 +10,10 @@ use rustc_span::sym;
 
 use super::ITER_NTH_ZERO;
 
-pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &hir::Expr<'_>, nth_args: &'tcx [hir::Expr<'_>]) {
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &hir::Expr<'_>, recv: &hir::Expr<'_>, arg: &hir::Expr<'_>) {
     if_chain! {
         if is_trait_method(cx, expr, sym::Iterator);
-        if let Some((Constant::Int(0), _)) = constant(cx, cx.typeck_results(), &nth_args[1]);
+        if let Some((Constant::Int(0), _)) = constant(cx, cx.typeck_results(), arg);
         then {
             let mut applicability = Applicability::MachineApplicable;
             span_lint_and_sugg(
@@ -22,7 +22,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &hir::Expr<'_>, nth_args
                 expr.span,
                 "called `.nth(0)` on a `std::iter::Iterator`, when `.next()` is equivalent",
                 "try calling `.next()` instead of `.nth(0)`",
-                format!("{}.next()", snippet_with_applicability(cx, nth_args[0].span, "..", &mut applicability)),
+                format!("{}.next()", snippet_with_applicability(cx, recv.span, "..", &mut applicability)),
                 applicability,
             );
         }
diff --git a/clippy_lints/src/methods/iter_skip_next.rs b/clippy_lints/src/methods/iter_skip_next.rs
index b1d398876d3..e32594757d0 100644
--- a/clippy_lints/src/methods/iter_skip_next.rs
+++ b/clippy_lints/src/methods/iter_skip_next.rs
@@ -8,19 +8,17 @@ use rustc_span::sym;
 
 use super::ITER_SKIP_NEXT;
 
-pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, skip_args: &[hir::Expr<'_>]) {
+pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr<'_>, arg: &hir::Expr<'_>) {
     // lint if caller of skip is an Iterator
     if is_trait_method(cx, expr, sym::Iterator) {
-        if let [caller, n] = skip_args {
-            span_lint_and_sugg(
-                cx,
-                ITER_SKIP_NEXT,
-                expr.span.trim_start(caller.span).unwrap(),
-                "called `skip(..).next()` on an iterator",
-                "use `nth` instead",
-                format!(".nth({})", snippet(cx, n.span, "..")),
-                Applicability::MachineApplicable,
-            );
-        }
+        span_lint_and_sugg(
+            cx,
+            ITER_SKIP_NEXT,
+            expr.span.trim_start(recv.span).unwrap(),
+            "called `skip(..).next()` on an iterator",
+            "use `nth` instead",
+            format!(".nth({})", snippet(cx, arg.span, "..")),
+            Applicability::MachineApplicable,
+        );
     }
 }
diff --git a/clippy_lints/src/methods/iterator_step_by_zero.rs b/clippy_lints/src/methods/iterator_step_by_zero.rs
index 3baa580314f..06b12998b1a 100644
--- a/clippy_lints/src/methods/iterator_step_by_zero.rs
+++ b/clippy_lints/src/methods/iterator_step_by_zero.rs
@@ -7,9 +7,9 @@ use rustc_span::sym;
 
 use super::ITERATOR_STEP_BY_ZERO;
 
-pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &hir::Expr<'_>, args: &'tcx [hir::Expr<'_>]) {
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &hir::Expr<'_>, arg: &'tcx hir::Expr<'_>) {
     if is_trait_method(cx, expr, sym::Iterator) {
-        if let Some((Constant::Int(0), _)) = constant(cx, cx.typeck_results(), &args[1]) {
+        if let Some((Constant::Int(0), _)) = constant(cx, cx.typeck_results(), arg) {
             span_lint(
                 cx,
                 ITERATOR_STEP_BY_ZERO,
diff --git a/clippy_lints/src/methods/manual_saturating_arithmetic.rs b/clippy_lints/src/methods/manual_saturating_arithmetic.rs
index f16699322d1..6c5a842a912 100644
--- a/clippy_lints/src/methods/manual_saturating_arithmetic.rs
+++ b/clippy_lints/src/methods/manual_saturating_arithmetic.rs
@@ -8,11 +8,14 @@ use rustc_hir as hir;
 use rustc_lint::LateContext;
 use rustc_target::abi::LayoutOf;
 
-pub fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[&[hir::Expr<'_>]], arith: &str) {
-    let unwrap_arg = &args[0][1];
-    let arith_lhs = &args[1][0];
-    let arith_rhs = &args[1][1];
-
+pub fn check(
+    cx: &LateContext<'_>,
+    expr: &hir::Expr<'_>,
+    arith_lhs: &hir::Expr<'_>,
+    arith_rhs: &hir::Expr<'_>,
+    unwrap_arg: &hir::Expr<'_>,
+    arith: &str,
+) {
     let ty = cx.typeck_results().expr_ty(arith_lhs);
     if !ty.is_integral() {
         return;
diff --git a/clippy_lints/src/methods/map_collect_result_unit.rs b/clippy_lints/src/methods/map_collect_result_unit.rs
index e4402b2da21..82063ad70b5 100644
--- a/clippy_lints/src/methods/map_collect_result_unit.rs
+++ b/clippy_lints/src/methods/map_collect_result_unit.rs
@@ -14,13 +14,13 @@ use super::MAP_COLLECT_RESULT_UNIT;
 pub(super) fn check(
     cx: &LateContext<'_>,
     expr: &hir::Expr<'_>,
-    map_args: &[hir::Expr<'_>],
-    collect_args: &[hir::Expr<'_>],
+    iter: &hir::Expr<'_>,
+    map_fn: &hir::Expr<'_>,
+    collect_recv: &hir::Expr<'_>,
 ) {
     if_chain! {
         // called on Iterator
-        if let [map_expr] = collect_args;
-        if is_trait_method(cx, map_expr, sym::Iterator);
+        if is_trait_method(cx, collect_recv, sym::Iterator);
         // return of collect `Result<(),_>`
         let collect_ret_ty = cx.typeck_results().expr_ty(expr);
         if is_type_diagnostic_item(cx, collect_ret_ty, sym::result_type);
@@ -28,7 +28,6 @@ pub(super) fn check(
         if let Some(result_t) = substs.types().next();
         if result_t.is_unit();
         // get parts for snippet
-        if let [iter, map_fn] = map_args;
         then {
             span_lint_and_sugg(
                 cx,
diff --git a/clippy_lints/src/methods/map_flatten.rs b/clippy_lints/src/methods/map_flatten.rs
index 4bc52b036a8..e8ad16bc0de 100644
--- a/clippy_lints/src/methods/map_flatten.rs
+++ b/clippy_lints/src/methods/map_flatten.rs
@@ -11,10 +11,15 @@ use rustc_span::symbol::sym;
 use super::MAP_FLATTEN;
 
 /// lint use of `map().flatten()` for `Iterators` and 'Options'
-pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, map_args: &'tcx [hir::Expr<'_>]) {
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx hir::Expr<'_>,
+    recv: &'tcx hir::Expr<'_>,
+    map_arg: &'tcx hir::Expr<'_>,
+) {
     // lint if caller of `.map().flatten()` is an Iterator
     if is_trait_method(cx, expr, sym::Iterator) {
-        let map_closure_ty = cx.typeck_results().expr_ty(&map_args[1]);
+        let map_closure_ty = cx.typeck_results().expr_ty(map_arg);
         let is_map_to_option = match map_closure_ty.kind() {
             ty::Closure(_, _) | ty::FnDef(_, _) | ty::FnPtr(_) => {
                 let map_closure_sig = match map_closure_ty.kind() {
@@ -34,12 +39,12 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, map
             // `(...).map(...)` has type `impl Iterator<Item=impl Iterator<...>>
             "flat_map"
         };
-        let func_snippet = snippet(cx, map_args[1].span, "..");
+        let func_snippet = snippet(cx, map_arg.span, "..");
         let hint = format!(".{0}({1})", method_to_use, func_snippet);
         span_lint_and_sugg(
             cx,
             MAP_FLATTEN,
-            expr.span.with_lo(map_args[0].span.hi()),
+            expr.span.with_lo(recv.span.hi()),
             "called `map(..).flatten()` on an `Iterator`",
             &format!("try using `{}` instead", method_to_use),
             hint,
@@ -48,13 +53,13 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, map
     }
 
     // lint if caller of `.map().flatten()` is an Option
-    if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&map_args[0]), sym::option_type) {
-        let func_snippet = snippet(cx, map_args[1].span, "..");
+    if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(recv), sym::option_type) {
+        let func_snippet = snippet(cx, map_arg.span, "..");
         let hint = format!(".and_then({})", func_snippet);
         span_lint_and_sugg(
             cx,
             MAP_FLATTEN,
-            expr.span.with_lo(map_args[0].span.hi()),
+            expr.span.with_lo(recv.span.hi()),
             "called `map(..).flatten()` on an `Option`",
             "try using `and_then` instead",
             hint,
diff --git a/clippy_lints/src/methods/map_unwrap_or.rs b/clippy_lints/src/methods/map_unwrap_or.rs
index deb4b4492b5..4330fea727b 100644
--- a/clippy_lints/src/methods/map_unwrap_or.rs
+++ b/clippy_lints/src/methods/map_unwrap_or.rs
@@ -18,22 +18,23 @@ const MAP_UNWRAP_OR_MSRV: RustcVersion = RustcVersion::new(1, 41, 0);
 pub(super) fn check<'tcx>(
     cx: &LateContext<'tcx>,
     expr: &'tcx hir::Expr<'_>,
-    map_args: &'tcx [hir::Expr<'_>],
-    unwrap_args: &'tcx [hir::Expr<'_>],
+    recv: &'tcx hir::Expr<'_>,
+    map_arg: &'tcx hir::Expr<'_>,
+    unwrap_arg: &'tcx hir::Expr<'_>,
     msrv: Option<&RustcVersion>,
 ) -> bool {
     if !meets_msrv(msrv, &MAP_UNWRAP_OR_MSRV) {
         return false;
     }
     // lint if the caller of `map()` is an `Option`
-    let is_option = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&map_args[0]), sym::option_type);
-    let is_result = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&map_args[0]), sym::result_type);
+    let is_option = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(recv), sym::option_type);
+    let is_result = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(recv), sym::result_type);
 
     if is_option || is_result {
         // Don't make a suggestion that may fail to compile due to mutably borrowing
         // the same variable twice.
-        let map_mutated_vars = mutated_variables(&map_args[0], cx);
-        let unwrap_mutated_vars = mutated_variables(&unwrap_args[1], cx);
+        let map_mutated_vars = mutated_variables(recv, cx);
+        let unwrap_mutated_vars = mutated_variables(unwrap_arg, cx);
         if let (Some(map_mutated_vars), Some(unwrap_mutated_vars)) = (map_mutated_vars, unwrap_mutated_vars) {
             if map_mutated_vars.intersection(&unwrap_mutated_vars).next().is_some() {
                 return false;
@@ -51,14 +52,14 @@ pub(super) fn check<'tcx>(
             `.map_or_else(<g>, <f>)` instead"
         };
         // get snippets for args to map() and unwrap_or_else()
-        let map_snippet = snippet(cx, map_args[1].span, "..");
-        let unwrap_snippet = snippet(cx, unwrap_args[1].span, "..");
+        let map_snippet = snippet(cx, map_arg.span, "..");
+        let unwrap_snippet = snippet(cx, unwrap_arg.span, "..");
         // lint, with note if neither arg is > 1 line and both map() and
         // unwrap_or_else() have the same span
         let multiline = map_snippet.lines().count() > 1 || unwrap_snippet.lines().count() > 1;
-        let same_span = map_args[1].span.ctxt() == unwrap_args[1].span.ctxt();
+        let same_span = map_arg.span.ctxt() == unwrap_arg.span.ctxt();
         if same_span && !multiline {
-            let var_snippet = snippet(cx, map_args[0].span, "..");
+            let var_snippet = snippet(cx, recv.span, "..");
             span_lint_and_sugg(
                 cx,
                 MAP_UNWRAP_OR,
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 8a04fd0060d..9a95354db7a 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -62,17 +62,18 @@ mod zst_offset;
 use bind_instead_of_map::BindInsteadOfMap;
 use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
 use clippy_utils::ty::{contains_adt_constructor, contains_ty, implements_trait, is_copy, is_type_diagnostic_item};
-use clippy_utils::{contains_return, get_trait_def_id, in_macro, iter_input_pats, method_calls, paths, return_ty};
+use clippy_utils::{contains_return, get_trait_def_id, in_macro, iter_input_pats, paths, return_ty};
 use if_chain::if_chain;
 use rustc_hir as hir;
 use rustc_hir::def::Res;
-use rustc_hir::{PrimTy, QPath, TraitItem, TraitItemKind};
+use rustc_hir::{Expr, ExprKind, PrimTy, QPath, TraitItem, TraitItemKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::{self, TraitRef, Ty, TyS};
 use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::symbol::{sym, SymbolStr};
+use rustc_span::symbol::SymbolStr;
+use rustc_span::{sym, Span};
 use rustc_typeck::hir_ty_to_ty;
 
 declare_clippy_lint! {
@@ -1704,134 +1705,32 @@ impl_lint_pass!(Methods => [
     IMPLICIT_CLONE
 ]);
 
+/// Extracts a method call name, args, and `Span` of the method name.
+fn method_call<'tcx>(recv: &'tcx hir::Expr<'tcx>) -> Option<(SymbolStr, &'tcx [hir::Expr<'tcx>], Span)> {
+    if let ExprKind::MethodCall(path, span, args, _) = recv.kind {
+        if !args.iter().any(|e| e.span.from_expansion()) {
+            return Some((path.ident.name.as_str(), args, span));
+        }
+    }
+    None
+}
+
+/// Same as `method_call` but the `SymbolStr` is dereferenced into a temporary `&str`
+macro_rules! method_call {
+    ($expr:expr) => {
+        method_call($expr)
+            .as_ref()
+            .map(|&(ref name, args, span)| (&**name, args, span))
+    };
+}
+
 impl<'tcx> LateLintPass<'tcx> for Methods {
-    #[allow(clippy::too_many_lines)]
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
         if in_macro(expr.span) {
             return;
         }
 
-        let (method_names, arg_lists, method_spans) = method_calls(expr, 2);
-        let method_names: Vec<SymbolStr> = method_names.iter().map(|s| s.as_str()).collect();
-        let method_names: Vec<&str> = method_names.iter().map(|s| &**s).collect();
-
-        match method_names.as_slice() {
-            ["unwrap", "get"] => get_unwrap::check(cx, expr, arg_lists[1], false),
-            ["unwrap", "get_mut"] => get_unwrap::check(cx, expr, arg_lists[1], true),
-            ["unwrap", ..] => unwrap_used::check(cx, expr, arg_lists[0]),
-            ["expect", "ok"] => ok_expect::check(cx, expr, arg_lists[1]),
-            ["expect", ..] => expect_used::check(cx, expr, arg_lists[0]),
-            ["unwrap_or", "map"] => option_map_unwrap_or::check(cx, expr, arg_lists[1], arg_lists[0], method_spans[1]),
-            ["unwrap_or_else", "map"] => {
-                if !map_unwrap_or::check(cx, expr, arg_lists[1], arg_lists[0], self.msrv.as_ref()) {
-                    unnecessary_lazy_eval::check(cx, expr, arg_lists[0], "unwrap_or");
-                }
-            },
-            ["map_or", ..] => option_map_or_none::check(cx, expr, arg_lists[0]),
-            ["and_then", ..] => {
-                let biom_option_linted = bind_instead_of_map::OptionAndThenSome::check(cx, expr, arg_lists[0]);
-                let biom_result_linted = bind_instead_of_map::ResultAndThenOk::check(cx, expr, arg_lists[0]);
-                if !biom_option_linted && !biom_result_linted {
-                    unnecessary_lazy_eval::check(cx, expr, arg_lists[0], "and");
-                }
-            },
-            ["or_else", ..] => {
-                if !bind_instead_of_map::ResultOrElseErrInfo::check(cx, expr, arg_lists[0]) {
-                    unnecessary_lazy_eval::check(cx, expr, arg_lists[0], "or");
-                }
-            },
-            ["next", "filter"] => filter_next::check(cx, expr, arg_lists[1]),
-            ["next", "skip_while"] => skip_while_next::check(cx, expr, arg_lists[1]),
-            ["next", "iter"] => iter_next_slice::check(cx, expr, arg_lists[1]),
-            ["map", "filter"] => filter_map::check(cx, expr, false, method_spans[0]),
-            ["map", "filter_map"] => filter_map_map::check(cx, expr),
-            ["next", "filter_map"] => filter_map_next::check(cx, expr, arg_lists[1], self.msrv.as_ref()),
-            ["map", "find"] => filter_map::check(cx, expr, true, method_spans[0]),
-            ["flat_map", "filter"] => filter_flat_map::check(cx, expr),
-            ["flat_map", "filter_map"] => filter_map_flat_map::check(cx, expr),
-            ["flat_map", ..] => flat_map_identity::check(cx, expr, arg_lists[0], method_spans[0]),
-            ["flatten", "map"] => map_flatten::check(cx, expr, arg_lists[1]),
-            [option_check_method, "find"] if "is_some" == *option_check_method || "is_none" == *option_check_method => {
-                search_is_some::check(
-                    cx,
-                    expr,
-                    "find",
-                    option_check_method,
-                    arg_lists[1],
-                    arg_lists[0],
-                    method_spans[1],
-                )
-            },
-            [option_check_method, "position"]
-                if "is_some" == *option_check_method || "is_none" == *option_check_method =>
-            {
-                search_is_some::check(
-                    cx,
-                    expr,
-                    "position",
-                    option_check_method,
-                    arg_lists[1],
-                    arg_lists[0],
-                    method_spans[1],
-                )
-            },
-            [option_check_method, "rposition"]
-                if "is_some" == *option_check_method || "is_none" == *option_check_method =>
-            {
-                search_is_some::check(
-                    cx,
-                    expr,
-                    "rposition",
-                    option_check_method,
-                    arg_lists[1],
-                    arg_lists[0],
-                    method_spans[1],
-                )
-            },
-            ["extend", ..] => string_extend_chars::check(cx, expr, arg_lists[0]),
-            ["count", "into_iter"] => iter_count::check(cx, expr, &arg_lists[1], "into_iter"),
-            ["count", "iter"] => iter_count::check(cx, expr, &arg_lists[1], "iter"),
-            ["count", "iter_mut"] => iter_count::check(cx, expr, &arg_lists[1], "iter_mut"),
-            ["nth", "iter"] => iter_nth::check(cx, expr, &arg_lists, false),
-            ["nth", "iter_mut"] => iter_nth::check(cx, expr, &arg_lists, true),
-            ["nth", "bytes"] => bytes_nth::check(cx, expr, &arg_lists[1]),
-            ["nth", ..] => iter_nth_zero::check(cx, expr, arg_lists[0]),
-            ["step_by", ..] => iterator_step_by_zero::check(cx, expr, arg_lists[0]),
-            ["next", "skip"] => iter_skip_next::check(cx, expr, arg_lists[1]),
-            ["collect", "cloned"] => iter_cloned_collect::check(cx, expr, arg_lists[1]),
-            ["as_ref"] => useless_asref::check(cx, expr, "as_ref", arg_lists[0]),
-            ["as_mut"] => useless_asref::check(cx, expr, "as_mut", arg_lists[0]),
-            ["fold", ..] => unnecessary_fold::check(cx, expr, arg_lists[0], method_spans[0]),
-            ["filter_map", ..] => {
-                unnecessary_filter_map::check(cx, expr, arg_lists[0]);
-                filter_map_identity::check(cx, expr, arg_lists[0], method_spans[0]);
-            },
-            ["count", "map"] => suspicious_map::check(cx, expr, arg_lists[1], arg_lists[0]),
-            ["assume_init"] => uninit_assumed_init::check(cx, &arg_lists[0][0], expr),
-            ["unwrap_or", arith @ ("checked_add" | "checked_sub" | "checked_mul")] => {
-                manual_saturating_arithmetic::check(cx, expr, &arg_lists, &arith["checked_".len()..])
-            },
-            ["add" | "offset" | "sub" | "wrapping_offset" | "wrapping_add" | "wrapping_sub"] => {
-                zst_offset::check(cx, expr, arg_lists[0])
-            },
-            ["is_file", ..] => filetype_is_file::check(cx, expr, arg_lists[0]),
-            ["map", "as_ref"] => {
-                option_as_ref_deref::check(cx, expr, arg_lists[1], arg_lists[0], false, self.msrv.as_ref())
-            },
-            ["map", "as_mut"] => {
-                option_as_ref_deref::check(cx, expr, arg_lists[1], arg_lists[0], true, self.msrv.as_ref())
-            },
-            ["unwrap_or_else", ..] => unnecessary_lazy_eval::check(cx, expr, arg_lists[0], "unwrap_or"),
-            ["get_or_insert_with", ..] => unnecessary_lazy_eval::check(cx, expr, arg_lists[0], "get_or_insert"),
-            ["ok_or_else", ..] => unnecessary_lazy_eval::check(cx, expr, arg_lists[0], "ok_or"),
-            ["collect", "map"] => map_collect_result_unit::check(cx, expr, arg_lists[1], arg_lists[0]),
-            ["for_each", "inspect"] => inspect_for_each::check(cx, expr, method_spans[1]),
-            ["to_owned", ..] => implicit_clone::check(cx, expr, sym::ToOwned),
-            ["to_os_string", ..] => implicit_clone::check(cx, expr, sym::OsStr),
-            ["to_path_buf", ..] => implicit_clone::check(cx, expr, sym::Path),
-            ["to_vec", ..] => implicit_clone::check(cx, expr, sym::slice),
-            _ => {},
-        }
+        check_methods(cx, expr, self.msrv.as_ref());
 
         match expr.kind {
             hir::ExprKind::Call(ref func, ref args) => {
@@ -2020,6 +1919,140 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
 
     extract_msrv_attr!(LateContext);
 }
+
+#[allow(clippy::too_many_lines)]
+fn check_methods<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, msrv: Option<&RustcVersion>) {
+    if let Some((name, [recv, args @ ..], span)) = method_call!(expr) {
+        match (name, args) {
+            ("add" | "offset" | "sub" | "wrapping_offset" | "wrapping_add" | "wrapping_sub", [recv, _]) => {
+                zst_offset::check(cx, expr, recv)
+            },
+            ("and_then", [arg]) => {
+                let biom_option_linted = bind_instead_of_map::OptionAndThenSome::check(cx, expr, recv, arg);
+                let biom_result_linted = bind_instead_of_map::ResultAndThenOk::check(cx, expr, recv, arg);
+                if !biom_option_linted && !biom_result_linted {
+                    unnecessary_lazy_eval::check(cx, expr, recv, arg, "and");
+                }
+            },
+            ("as_mut", []) => useless_asref::check(cx, expr, "as_mut", recv),
+            ("as_ref", []) => useless_asref::check(cx, expr, "as_ref", recv),
+            ("assume_init", []) => uninit_assumed_init::check(cx, expr, recv),
+            ("collect", []) => match method_call!(recv) {
+                Some(("cloned", [recv2], _)) => iter_cloned_collect::check(cx, expr, recv2),
+                Some(("map", [m_recv, m_arg], _)) => {
+                    map_collect_result_unit::check(cx, expr, m_recv, m_arg, recv);
+                },
+                _ => {},
+            },
+            ("count", []) => match method_call!(recv) {
+                Some((name @ ("into_iter" | "iter" | "iter_mut"), [recv2], _)) => {
+                    iter_count::check(cx, expr, recv2, name);
+                },
+                Some(("map", [_, arg], _)) => suspicious_map::check(cx, expr, recv, arg),
+                _ => {},
+            },
+            ("expect", [_]) => match method_call!(recv) {
+                Some(("ok", [recv], _)) => ok_expect::check(cx, expr, recv),
+                _ => expect_used::check(cx, expr, recv),
+            },
+            ("extend", [arg]) => string_extend_chars::check(cx, expr, recv, arg),
+            ("filter_map", [arg]) => {
+                unnecessary_filter_map::check(cx, expr, arg);
+                filter_map_identity::check(cx, expr, arg, span);
+            },
+            ("flat_map", [flm_arg]) => match method_call!(recv) {
+                Some(("filter", [_, _], _)) => filter_flat_map::check(cx, expr),
+                Some(("filter_map", [_, _], _)) => filter_map_flat_map::check(cx, expr),
+                _ => flat_map_identity::check(cx, expr, flm_arg, span),
+            },
+            ("flatten", []) => {
+                if let Some(("map", [recv, map_arg], _)) = method_call!(recv) {
+                    map_flatten::check(cx, expr, recv, map_arg);
+                }
+            },
+            ("fold", [init, acc]) => unnecessary_fold::check(cx, expr, init, acc, span),
+            ("for_each", [_]) => {
+                if let Some(("inspect", [_, _], span2)) = method_call!(recv) {
+                    inspect_for_each::check(cx, expr, span2);
+                }
+            },
+            ("get_or_insert_with", [arg]) => unnecessary_lazy_eval::check(cx, expr, recv, arg, "get_or_insert"),
+            ("is_file", []) => filetype_is_file::check(cx, expr, recv),
+            ("is_none", []) => check_is_some_is_none(cx, expr, recv, false),
+            ("is_some", []) => check_is_some_is_none(cx, expr, recv, true),
+            ("map", [m_arg]) => {
+                if let Some((name, [recv2, args @ ..], span2)) = method_call!(recv) {
+                    match (name, args) {
+                        ("as_mut", []) => option_as_ref_deref::check(cx, expr, recv2, m_arg, true, msrv),
+                        ("as_ref", []) => option_as_ref_deref::check(cx, expr, recv2, m_arg, false, msrv),
+                        ("filter", [f_arg]) => {
+                            filter_map::check(cx, expr, recv2, f_arg, span2, recv, m_arg, span, false)
+                        },
+                        ("filter_map", [_]) => filter_map_map::check(cx, expr),
+                        ("find", [f_arg]) => filter_map::check(cx, expr, recv2, f_arg, span2, recv, m_arg, span, true),
+                        _ => {},
+                    }
+                }
+            },
+            ("map_or", [def, map]) => option_map_or_none::check(cx, expr, recv, def, map),
+            ("next", []) => {
+                if let Some((name, [recv, args @ ..], _)) = method_call!(recv) {
+                    match (name, args) {
+                        ("filter", [arg]) => filter_next::check(cx, expr, recv, arg),
+                        ("filter_map", [arg]) => filter_map_next::check(cx, expr, recv, arg, msrv),
+                        ("iter", []) => iter_next_slice::check(cx, expr, recv),
+                        ("skip", [arg]) => iter_skip_next::check(cx, expr, recv, arg),
+                        ("skip_while", [_]) => skip_while_next::check(cx, expr),
+                        _ => {},
+                    }
+                }
+            },
+            ("nth", [n_arg]) => match method_call!(recv) {
+                Some(("bytes", [recv2], _)) => bytes_nth::check(cx, expr, recv2, n_arg),
+                Some(("iter", [recv2], _)) => iter_nth::check(cx, expr, recv2, recv, n_arg, false),
+                Some(("iter_mut", [recv2], _)) => iter_nth::check(cx, expr, recv2, recv, n_arg, true),
+                _ => iter_nth_zero::check(cx, expr, recv, n_arg),
+            },
+            ("ok_or_else", [arg]) => unnecessary_lazy_eval::check(cx, expr, recv, arg, "ok_or"),
+            ("or_else", [arg]) => {
+                if !bind_instead_of_map::ResultOrElseErrInfo::check(cx, expr, recv, arg) {
+                    unnecessary_lazy_eval::check(cx, expr, recv, arg, "or");
+                }
+            },
+            ("step_by", [arg]) => iterator_step_by_zero::check(cx, expr, arg),
+            ("to_os_string", []) => implicit_clone::check(cx, expr, sym::OsStr),
+            ("to_owned", []) => implicit_clone::check(cx, expr, sym::ToOwned),
+            ("to_path_buf", []) => implicit_clone::check(cx, expr, sym::Path),
+            ("to_vec", []) => implicit_clone::check(cx, expr, sym::slice),
+            ("unwrap", []) => match method_call!(recv) {
+                Some(("get", [recv, get_arg], _)) => get_unwrap::check(cx, expr, recv, get_arg, false),
+                Some(("get_mut", [recv, get_arg], _)) => get_unwrap::check(cx, expr, recv, get_arg, true),
+                _ => unwrap_used::check(cx, expr, recv),
+            },
+            ("unwrap_or", [u_arg]) => match method_call!(recv) {
+                Some((arith @ ("checked_add" | "checked_sub" | "checked_mul"), [lhs, rhs], _)) => {
+                    manual_saturating_arithmetic::check(cx, expr, lhs, rhs, u_arg, &arith["checked_".len()..]);
+                },
+                Some(("map", [m_recv, m_arg], span)) => {
+                    option_map_unwrap_or::check(cx, expr, m_recv, m_arg, recv, u_arg, span)
+                },
+                _ => {},
+            },
+            ("unwrap_or_else", [u_arg]) => match method_call!(recv) {
+                Some(("map", [recv, map_arg], _)) if map_unwrap_or::check(cx, expr, recv, map_arg, u_arg, msrv) => {},
+                _ => unnecessary_lazy_eval::check(cx, expr, recv, u_arg, "unwrap_or"),
+            },
+            _ => {},
+        }
+    }
+}
+
+fn check_is_some_is_none(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'_>, is_some: bool) {
+    if let Some((name @ ("find" | "position" | "rposition"), [f_recv, arg], span)) = method_call!(recv) {
+        search_is_some::check(cx, expr, name, is_some, f_recv, arg, recv, span)
+    }
+}
+
 /// Used for `lint_binary_expr_with_method_call`.
 #[derive(Copy, Clone)]
 struct BinaryExprInfo<'a> {
diff --git a/clippy_lints/src/methods/ok_expect.rs b/clippy_lints/src/methods/ok_expect.rs
index e6ce9cac397..d0b1b4b84be 100644
--- a/clippy_lints/src/methods/ok_expect.rs
+++ b/clippy_lints/src/methods/ok_expect.rs
@@ -9,11 +9,11 @@ use rustc_span::sym;
 use super::OK_EXPECT;
 
 /// lint use of `ok().expect()` for `Result`s
-pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, ok_args: &[hir::Expr<'_>]) {
+pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr<'_>) {
     if_chain! {
         // lint if the caller of `ok()` is a `Result`
-        if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&ok_args[0]), sym::result_type);
-        let result_type = cx.typeck_results().expr_ty(&ok_args[0]);
+        if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(recv), sym::result_type);
+        let result_type = cx.typeck_results().expr_ty(recv);
         if let Some(error_type) = get_error_type(cx, result_type);
         if has_debug_impl(error_type, cx);
 
diff --git a/clippy_lints/src/methods/option_as_ref_deref.rs b/clippy_lints/src/methods/option_as_ref_deref.rs
index d11ede080dc..1367a0c21d8 100644
--- a/clippy_lints/src/methods/option_as_ref_deref.rs
+++ b/clippy_lints/src/methods/option_as_ref_deref.rs
@@ -18,8 +18,8 @@ const OPTION_AS_REF_DEREF_MSRV: RustcVersion = RustcVersion::new(1, 40, 0);
 pub(super) fn check<'tcx>(
     cx: &LateContext<'tcx>,
     expr: &hir::Expr<'_>,
-    as_ref_args: &[hir::Expr<'_>],
-    map_args: &[hir::Expr<'_>],
+    as_ref_recv: &hir::Expr<'_>,
+    map_arg: &hir::Expr<'_>,
     is_mut: bool,
     msrv: Option<&RustcVersion>,
 ) {
@@ -29,7 +29,7 @@ pub(super) fn check<'tcx>(
 
     let same_mutability = |m| (is_mut && m == &hir::Mutability::Mut) || (!is_mut && m == &hir::Mutability::Not);
 
-    let option_ty = cx.typeck_results().expr_ty(&as_ref_args[0]);
+    let option_ty = cx.typeck_results().expr_ty(as_ref_recv);
     if !is_type_diagnostic_item(cx, option_ty, sym::option_type) {
         return;
     }
@@ -46,9 +46,9 @@ pub(super) fn check<'tcx>(
         &paths::VEC_AS_MUT_SLICE,
     ];
 
-    let is_deref = match map_args[1].kind {
+    let is_deref = match map_arg.kind {
         hir::ExprKind::Path(ref expr_qpath) => cx
-            .qpath_res(expr_qpath, map_args[1].hir_id)
+            .qpath_res(expr_qpath, map_arg.hir_id)
             .opt_def_id()
             .map_or(false, |fun_def_id| {
                 deref_aliases.iter().any(|path| match_def_path(cx, fun_def_id, path))
@@ -96,12 +96,12 @@ pub(super) fn check<'tcx>(
 
     if is_deref {
         let current_method = if is_mut {
-            format!(".as_mut().map({})", snippet(cx, map_args[1].span, ".."))
+            format!(".as_mut().map({})", snippet(cx, map_arg.span, ".."))
         } else {
-            format!(".as_ref().map({})", snippet(cx, map_args[1].span, ".."))
+            format!(".as_ref().map({})", snippet(cx, map_arg.span, ".."))
         };
         let method_hint = if is_mut { "as_deref_mut" } else { "as_deref" };
-        let hint = format!("{}.{}()", snippet(cx, as_ref_args[0].span, ".."), method_hint);
+        let hint = format!("{}.{}()", snippet(cx, as_ref_recv.span, ".."), method_hint);
         let suggestion = format!("try using {} instead", method_hint);
 
         let msg = format!(
diff --git a/clippy_lints/src/methods/option_map_or_none.rs b/clippy_lints/src/methods/option_map_or_none.rs
index d93db2c22e4..013a6f90ac9 100644
--- a/clippy_lints/src/methods/option_map_or_none.rs
+++ b/clippy_lints/src/methods/option_map_or_none.rs
@@ -11,9 +11,15 @@ use super::OPTION_MAP_OR_NONE;
 use super::RESULT_MAP_OR_INTO_OPTION;
 
 /// lint use of `_.map_or(None, _)` for `Option`s and `Result`s
-pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, map_or_args: &'tcx [hir::Expr<'_>]) {
-    let is_option = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&map_or_args[0]), sym::option_type);
-    let is_result = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&map_or_args[0]), sym::result_type);
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx hir::Expr<'_>,
+    recv: &'tcx hir::Expr<'_>,
+    def_arg: &'tcx hir::Expr<'_>,
+    map_arg: &'tcx hir::Expr<'_>,
+) {
+    let is_option = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(recv), sym::option_type);
+    let is_result = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(recv), sym::result_type);
 
     // There are two variants of this `map_or` lint:
     // (1) using `map_or` as an adapter from `Result<T,E>` to `Option<T>`
@@ -25,7 +31,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, map
     }
 
     let (lint_name, msg, instead, hint) = {
-        let default_arg_is_none = if let hir::ExprKind::Path(ref qpath) = map_or_args[1].kind {
+        let default_arg_is_none = if let hir::ExprKind::Path(ref qpath) = def_arg.kind {
             match_qpath(qpath, &paths::OPTION_NONE)
         } else {
             return;
@@ -36,15 +42,15 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, map
             return;
         }
 
-        let f_arg_is_some = if let hir::ExprKind::Path(ref qpath) = map_or_args[2].kind {
+        let f_arg_is_some = if let hir::ExprKind::Path(ref qpath) = map_arg.kind {
             match_qpath(qpath, &paths::OPTION_SOME)
         } else {
             false
         };
 
         if is_option {
-            let self_snippet = snippet(cx, map_or_args[0].span, "..");
-            let func_snippet = snippet(cx, map_or_args[2].span, "..");
+            let self_snippet = snippet(cx, recv.span, "..");
+            let func_snippet = snippet(cx, map_arg.span, "..");
             let msg = "called `map_or(None, ..)` on an `Option` value. This can be done more directly by calling \
                        `and_then(..)` instead";
             (
@@ -56,7 +62,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, map
         } else if f_arg_is_some {
             let msg = "called `map_or(None, Some)` on a `Result` value. This can be done more directly by calling \
                        `ok()` instead";
-            let self_snippet = snippet(cx, map_or_args[0].span, "..");
+            let self_snippet = snippet(cx, recv.span, "..");
             (
                 RESULT_MAP_OR_INTO_OPTION,
                 msg,
diff --git a/clippy_lints/src/methods/option_map_unwrap_or.rs b/clippy_lints/src/methods/option_map_unwrap_or.rs
index e252abc177a..5bca49dec24 100644
--- a/clippy_lints/src/methods/option_map_unwrap_or.rs
+++ b/clippy_lints/src/methods/option_map_unwrap_or.rs
@@ -18,13 +18,15 @@ use super::MAP_UNWRAP_OR;
 pub(super) fn check<'tcx>(
     cx: &LateContext<'tcx>,
     expr: &rustc_hir::Expr<'_>,
-    map_args: &'tcx [rustc_hir::Expr<'_>],
-    unwrap_args: &'tcx [rustc_hir::Expr<'_>],
+    recv: &rustc_hir::Expr<'_>,
+    map_arg: &'tcx rustc_hir::Expr<'_>,
+    unwrap_recv: &rustc_hir::Expr<'_>,
+    unwrap_arg: &'tcx rustc_hir::Expr<'_>,
     map_span: Span,
 ) {
     // lint if the caller of `map()` is an `Option`
-    if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&map_args[0]), sym::option_type) {
-        if !is_copy(cx, cx.typeck_results().expr_ty(&unwrap_args[1])) {
+    if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(recv), sym::option_type) {
+        if !is_copy(cx, cx.typeck_results().expr_ty(unwrap_arg)) {
             // Do not lint if the `map` argument uses identifiers in the `map`
             // argument that are also used in the `unwrap_or` argument
 
@@ -32,27 +34,27 @@ pub(super) fn check<'tcx>(
                 cx,
                 identifiers: FxHashSet::default(),
             };
-            unwrap_visitor.visit_expr(&unwrap_args[1]);
+            unwrap_visitor.visit_expr(unwrap_arg);
 
             let mut map_expr_visitor = MapExprVisitor {
                 cx,
                 identifiers: unwrap_visitor.identifiers,
                 found_identifier: false,
             };
-            map_expr_visitor.visit_expr(&map_args[1]);
+            map_expr_visitor.visit_expr(map_arg);
 
             if map_expr_visitor.found_identifier {
                 return;
             }
         }
 
-        if differing_macro_contexts(unwrap_args[1].span, map_span) {
+        if differing_macro_contexts(unwrap_arg.span, map_span) {
             return;
         }
 
         let mut applicability = Applicability::MachineApplicable;
         // get snippet for unwrap_or()
-        let unwrap_snippet = snippet_with_applicability(cx, unwrap_args[1].span, "..", &mut applicability);
+        let unwrap_snippet = snippet_with_applicability(cx, unwrap_arg.span, "..", &mut applicability);
         // lint message
         // comparing the snippet from source to raw text ("None") below is safe
         // because we already have checked the type.
@@ -70,14 +72,14 @@ pub(super) fn check<'tcx>(
         );
 
         span_lint_and_then(cx, MAP_UNWRAP_OR, expr.span, msg, |diag| {
-            let map_arg_span = map_args[1].span;
+            let map_arg_span = map_arg.span;
 
             let mut suggestion = vec![
                 (
                     map_span,
                     String::from(if unwrap_snippet_none { "and_then" } else { "map_or" }),
                 ),
-                (expr.span.with_lo(unwrap_args[0].span.hi()), String::from("")),
+                (expr.span.with_lo(unwrap_recv.span.hi()), String::from("")),
             ];
 
             if !unwrap_snippet_none {
diff --git a/clippy_lints/src/methods/search_is_some.rs b/clippy_lints/src/methods/search_is_some.rs
index de7d168295f..8a94d7f4155 100644
--- a/clippy_lints/src/methods/search_is_some.rs
+++ b/clippy_lints/src/methods/search_is_some.rs
@@ -15,29 +15,31 @@ use super::SEARCH_IS_SOME;
 
 /// lint searching an Iterator followed by `is_some()`
 /// or calling `find()` on a string followed by `is_some()` or `is_none()`
-#[allow(clippy::too_many_lines)]
+#[allow(clippy::too_many_arguments, clippy::too_many_lines)]
 pub(super) fn check<'tcx>(
-    cx: &LateContext<'tcx>,
+    cx: &LateContext<'_>,
     expr: &'tcx hir::Expr<'_>,
     search_method: &str,
-    option_check_method: &str,
-    search_args: &'tcx [hir::Expr<'_>],
-    is_some_args: &'tcx [hir::Expr<'_>],
+    is_some: bool,
+    search_recv: &hir::Expr<'_>,
+    search_arg: &'tcx hir::Expr<'_>,
+    is_some_recv: &hir::Expr<'_>,
     method_span: Span,
 ) {
+    let option_check_method = if is_some { "is_some" } else { "is_none" };
     // lint if caller of search is an Iterator
-    if is_trait_method(cx, &is_some_args[0], sym::Iterator) {
+    if is_trait_method(cx, is_some_recv, sym::Iterator) {
         let msg = format!(
             "called `{}()` after searching an `Iterator` with `{}`",
             option_check_method, search_method
         );
-        let search_snippet = snippet(cx, search_args[1].span, "..");
+        let search_snippet = snippet(cx, search_arg.span, "..");
         if search_snippet.lines().count() <= 1 {
             // suggest `any(|x| ..)` instead of `any(|&x| ..)` for `find(|&x| ..).is_some()`
             // suggest `any(|..| *..)` instead of `any(|..| **..)` for `find(|..| **..).is_some()`
             let any_search_snippet = if_chain! {
                 if search_method == "find";
-                if let hir::ExprKind::Closure(_, _, body_id, ..) = search_args[1].kind;
+                if let hir::ExprKind::Closure(_, _, body_id, ..) = search_arg.kind;
                 let closure_body = cx.tcx.hir().body(body_id);
                 if let Some(closure_arg) = closure_body.params.get(0);
                 then {
@@ -54,38 +56,34 @@ pub(super) fn check<'tcx>(
                 }
             };
             // add note if not multi-line
-            match option_check_method {
-                "is_some" => {
-                    span_lint_and_sugg(
-                        cx,
-                        SEARCH_IS_SOME,
-                        method_span.with_hi(expr.span.hi()),
-                        &msg,
-                        "use `any()` instead",
-                        format!(
-                            "any({})",
-                            any_search_snippet.as_ref().map_or(&*search_snippet, String::as_str)
-                        ),
-                        Applicability::MachineApplicable,
-                    );
-                },
-                "is_none" => {
-                    let iter = snippet(cx, search_args[0].span, "..");
-                    span_lint_and_sugg(
-                        cx,
-                        SEARCH_IS_SOME,
-                        expr.span,
-                        &msg,
-                        "use `!_.any()` instead",
-                        format!(
-                            "!{}.any({})",
-                            iter,
-                            any_search_snippet.as_ref().map_or(&*search_snippet, String::as_str)
-                        ),
-                        Applicability::MachineApplicable,
-                    );
-                },
-                _ => (),
+            if is_some {
+                span_lint_and_sugg(
+                    cx,
+                    SEARCH_IS_SOME,
+                    method_span.with_hi(expr.span.hi()),
+                    &msg,
+                    "use `any()` instead",
+                    format!(
+                        "any({})",
+                        any_search_snippet.as_ref().map_or(&*search_snippet, String::as_str)
+                    ),
+                    Applicability::MachineApplicable,
+                );
+            } else {
+                let iter = snippet(cx, search_recv.span, "..");
+                span_lint_and_sugg(
+                    cx,
+                    SEARCH_IS_SOME,
+                    expr.span,
+                    &msg,
+                    "use `!_.any()` instead",
+                    format!(
+                        "!{}.any({})",
+                        iter,
+                        any_search_snippet.as_ref().map_or(&*search_snippet, String::as_str)
+                    ),
+                    Applicability::MachineApplicable,
+                );
             }
         } else {
             let hint = format!(
@@ -110,14 +108,14 @@ pub(super) fn check<'tcx>(
             }
         };
         if_chain! {
-            if is_string_or_str_slice(&search_args[0]);
-            if is_string_or_str_slice(&search_args[1]);
+            if is_string_or_str_slice(&search_recv);
+            if is_string_or_str_slice(&search_arg);
             then {
                 let msg = format!("called `{}()` after calling `find()` on a string", option_check_method);
                 match option_check_method {
                     "is_some" => {
                         let mut applicability = Applicability::MachineApplicable;
-                        let find_arg = snippet_with_applicability(cx, search_args[1].span, "..", &mut applicability);
+                        let find_arg = snippet_with_applicability(cx, search_arg.span, "..", &mut applicability);
                         span_lint_and_sugg(
                             cx,
                             SEARCH_IS_SOME,
@@ -129,9 +127,9 @@ pub(super) fn check<'tcx>(
                         );
                     },
                     "is_none" => {
-                        let string = snippet(cx, search_args[0].span, "..");
+                        let string = snippet(cx, search_recv.span, "..");
                         let mut applicability = Applicability::MachineApplicable;
-                        let find_arg = snippet_with_applicability(cx, search_args[1].span, "..", &mut applicability);
+                        let find_arg = snippet_with_applicability(cx, search_arg.span, "..", &mut applicability);
                         span_lint_and_sugg(
                             cx,
                             SEARCH_IS_SOME,
diff --git a/clippy_lints/src/methods/skip_while_next.rs b/clippy_lints/src/methods/skip_while_next.rs
index 3db83785b59..9f0b6c34ea2 100644
--- a/clippy_lints/src/methods/skip_while_next.rs
+++ b/clippy_lints/src/methods/skip_while_next.rs
@@ -7,7 +7,7 @@ use rustc_span::sym;
 use super::SKIP_WHILE_NEXT;
 
 /// lint use of `skip_while().next()` for `Iterators`
-pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, _skip_while_args: &'tcx [hir::Expr<'_>]) {
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
     // lint if caller of `.skip_while().next()` is an Iterator
     if is_trait_method(cx, expr, sym::Iterator) {
         span_lint_and_help(
diff --git a/clippy_lints/src/methods/string_extend_chars.rs b/clippy_lints/src/methods/string_extend_chars.rs
index 5c688ac5621..6e7890a3080 100644
--- a/clippy_lints/src/methods/string_extend_chars.rs
+++ b/clippy_lints/src/methods/string_extend_chars.rs
@@ -10,12 +10,11 @@ use rustc_span::symbol::sym;
 
 use super::STRING_EXTEND_CHARS;
 
-pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::Expr<'_>]) {
-    let obj_ty = cx.typeck_results().expr_ty(&args[0]).peel_refs();
+pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr<'_>, arg: &hir::Expr<'_>) {
+    let obj_ty = cx.typeck_results().expr_ty(recv).peel_refs();
     if !is_type_diagnostic_item(cx, obj_ty, sym::string_type) {
         return;
     }
-    let arg = &args[1];
     if let Some(arglists) = method_chain_args(arg, &["chars"]) {
         let target = &arglists[0][0];
         let self_ty = cx.typeck_results().expr_ty(target).peel_refs();
@@ -36,7 +35,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::Exp
             "try this",
             format!(
                 "{}.push_str({}{})",
-                snippet_with_applicability(cx, args[0].span, "..", &mut applicability),
+                snippet_with_applicability(cx, recv.span, "..", &mut applicability),
                 ref_str,
                 snippet_with_applicability(cx, target.span, "..", &mut applicability)
             ),
diff --git a/clippy_lints/src/methods/suspicious_map.rs b/clippy_lints/src/methods/suspicious_map.rs
index 7015bd54c35..0fd0668c734 100644
--- a/clippy_lints/src/methods/suspicious_map.rs
+++ b/clippy_lints/src/methods/suspicious_map.rs
@@ -8,15 +8,8 @@ use rustc_span::sym;
 
 use super::SUSPICIOUS_MAP;
 
-pub fn check<'tcx>(
-    cx: &LateContext<'tcx>,
-    expr: &hir::Expr<'_>,
-    map_args: &[hir::Expr<'_>],
-    count_args: &[hir::Expr<'_>],
-) {
+pub fn check<'tcx>(cx: &LateContext<'tcx>, expr: &hir::Expr<'_>, count_recv: &hir::Expr<'_>, map_arg: &hir::Expr<'_>) {
     if_chain! {
-        if let [count_recv] = count_args;
-        if let [_, map_arg] = map_args;
         if is_trait_method(cx, count_recv, sym::Iterator);
         let closure = expr_or_init(cx, map_arg);
         if let Some(body_id) = cx.tcx.hir().maybe_body_owned_by(closure.hir_id);
diff --git a/clippy_lints/src/methods/uninit_assumed_init.rs b/clippy_lints/src/methods/uninit_assumed_init.rs
index f2f6ef4be6c..3cc1912b15a 100644
--- a/clippy_lints/src/methods/uninit_assumed_init.rs
+++ b/clippy_lints/src/methods/uninit_assumed_init.rs
@@ -8,18 +8,18 @@ use rustc_middle::ty::{self, Ty};
 use super::UNINIT_ASSUMED_INIT;
 
 /// lint for `MaybeUninit::uninit().assume_init()` (we already have the latter)
-pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, outer: &hir::Expr<'_>) {
+pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr<'_>) {
     if_chain! {
-        if let hir::ExprKind::Call(ref callee, ref args) = expr.kind;
+        if let hir::ExprKind::Call(ref callee, ref args) = recv.kind;
         if args.is_empty();
         if let hir::ExprKind::Path(ref path) = callee.kind;
         if match_qpath(path, &paths::MEM_MAYBEUNINIT_UNINIT);
-        if !is_maybe_uninit_ty_valid(cx, cx.typeck_results().expr_ty_adjusted(outer));
+        if !is_maybe_uninit_ty_valid(cx, cx.typeck_results().expr_ty_adjusted(expr));
         then {
             span_lint(
                 cx,
                 UNINIT_ASSUMED_INIT,
-                outer.span,
+                expr.span,
                 "this call for this type may be undefined behavior"
             );
         }
diff --git a/clippy_lints/src/methods/unnecessary_filter_map.rs b/clippy_lints/src/methods/unnecessary_filter_map.rs
index 48d905ab833..dac7e039e37 100644
--- a/clippy_lints/src/methods/unnecessary_filter_map.rs
+++ b/clippy_lints/src/methods/unnecessary_filter_map.rs
@@ -10,12 +10,12 @@ use rustc_span::sym;
 
 use super::UNNECESSARY_FILTER_MAP;
 
-pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::Expr<'_>]) {
+pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, arg: &hir::Expr<'_>) {
     if !is_trait_method(cx, expr, sym::Iterator) {
         return;
     }
 
-    if let hir::ExprKind::Closure(_, _, body_id, ..) = args[1].kind {
+    if let hir::ExprKind::Closure(_, _, body_id, ..) = arg.kind {
         let body = cx.tcx.hir().body(body_id);
         let arg_id = body.params[0].pat.hir_id;
         let mutates_arg =
diff --git a/clippy_lints/src/methods/unnecessary_fold.rs b/clippy_lints/src/methods/unnecessary_fold.rs
index 1268fd4bda9..7c16470348f 100644
--- a/clippy_lints/src/methods/unnecessary_fold.rs
+++ b/clippy_lints/src/methods/unnecessary_fold.rs
@@ -11,11 +11,17 @@ use rustc_span::{source_map::Span, sym};
 
 use super::UNNECESSARY_FOLD;
 
-pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, fold_args: &[hir::Expr<'_>], fold_span: Span) {
+pub(super) fn check(
+    cx: &LateContext<'_>,
+    expr: &hir::Expr<'_>,
+    init: &hir::Expr<'_>,
+    acc: &hir::Expr<'_>,
+    fold_span: Span,
+) {
     fn check_fold_with_op(
         cx: &LateContext<'_>,
         expr: &hir::Expr<'_>,
-        fold_args: &[hir::Expr<'_>],
+        acc: &hir::Expr<'_>,
         fold_span: Span,
         op: hir::BinOpKind,
         replacement_method_name: &str,
@@ -23,7 +29,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, fold_args: &[hir
     ) {
         if_chain! {
             // Extract the body of the closure passed to fold
-            if let hir::ExprKind::Closure(_, _, body_id, _, _) = fold_args[2].kind;
+            if let hir::ExprKind::Closure(_, _, body_id, _, _) = acc.kind;
             let closure_body = cx.tcx.hir().body(body_id);
             let closure_expr = remove_blocks(&closure_body.value);
 
@@ -74,25 +80,14 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, fold_args: &[hir
         return;
     }
 
-    assert!(
-        fold_args.len() == 3,
-        "Expected fold_args to have three entries - the receiver, the initial value and the closure"
-    );
-
     // Check if the first argument to .fold is a suitable literal
-    if let hir::ExprKind::Lit(ref lit) = fold_args[1].kind {
+    if let hir::ExprKind::Lit(ref lit) = init.kind {
         match lit.node {
-            ast::LitKind::Bool(false) => {
-                check_fold_with_op(cx, expr, fold_args, fold_span, hir::BinOpKind::Or, "any", true)
-            },
-            ast::LitKind::Bool(true) => {
-                check_fold_with_op(cx, expr, fold_args, fold_span, hir::BinOpKind::And, "all", true)
-            },
-            ast::LitKind::Int(0, _) => {
-                check_fold_with_op(cx, expr, fold_args, fold_span, hir::BinOpKind::Add, "sum", false)
-            },
+            ast::LitKind::Bool(false) => check_fold_with_op(cx, expr, acc, fold_span, hir::BinOpKind::Or, "any", true),
+            ast::LitKind::Bool(true) => check_fold_with_op(cx, expr, acc, fold_span, hir::BinOpKind::And, "all", true),
+            ast::LitKind::Int(0, _) => check_fold_with_op(cx, expr, acc, fold_span, hir::BinOpKind::Add, "sum", false),
             ast::LitKind::Int(1, _) => {
-                check_fold_with_op(cx, expr, fold_args, fold_span, hir::BinOpKind::Mul, "product", false)
+                check_fold_with_op(cx, expr, acc, fold_span, hir::BinOpKind::Mul, "product", false)
             },
             _ => (),
         }
diff --git a/clippy_lints/src/methods/unnecessary_lazy_eval.rs b/clippy_lints/src/methods/unnecessary_lazy_eval.rs
index a86185bf0a6..b7380883a5e 100644
--- a/clippy_lints/src/methods/unnecessary_lazy_eval.rs
+++ b/clippy_lints/src/methods/unnecessary_lazy_eval.rs
@@ -14,14 +14,15 @@ use super::UNNECESSARY_LAZY_EVALUATIONS;
 pub(super) fn check<'tcx>(
     cx: &LateContext<'tcx>,
     expr: &'tcx hir::Expr<'_>,
-    args: &'tcx [hir::Expr<'_>],
+    recv: &'tcx hir::Expr<'_>,
+    arg: &'tcx hir::Expr<'_>,
     simplify_using: &str,
 ) {
-    let is_option = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&args[0]), sym::option_type);
-    let is_result = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&args[0]), sym::result_type);
+    let is_option = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(recv), sym::option_type);
+    let is_result = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(recv), sym::result_type);
 
     if is_option || is_result {
-        if let hir::ExprKind::Closure(_, _, eid, _, _) = args[1].kind {
+        if let hir::ExprKind::Closure(_, _, eid, _, _) = arg.kind {
             let body = cx.tcx.hir().body(eid);
             let body_expr = &body.value;
 
@@ -55,7 +56,7 @@ pub(super) fn check<'tcx>(
                     &format!("use `{}` instead", simplify_using),
                     format!(
                         "{0}.{1}({2})",
-                        snippet(cx, args[0].span, ".."),
+                        snippet(cx, recv.span, ".."),
                         simplify_using,
                         snippet(cx, body_expr.span, ".."),
                     ),
diff --git a/clippy_lints/src/methods/unwrap_used.rs b/clippy_lints/src/methods/unwrap_used.rs
index 2f5806115bd..7fd1948594d 100644
--- a/clippy_lints/src/methods/unwrap_used.rs
+++ b/clippy_lints/src/methods/unwrap_used.rs
@@ -7,8 +7,8 @@ use rustc_span::sym;
 use super::UNWRAP_USED;
 
 /// lint use of `unwrap()` for `Option`s and `Result`s
-pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, unwrap_args: &[hir::Expr<'_>]) {
-    let obj_ty = cx.typeck_results().expr_ty(&unwrap_args[0]).peel_refs();
+pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr<'_>) {
+    let obj_ty = cx.typeck_results().expr_ty(recv).peel_refs();
 
     let mess = if is_type_diagnostic_item(cx, obj_ty, sym::option_type) {
         Some((UNWRAP_USED, "an Option", "None"))
diff --git a/clippy_lints/src/methods/useless_asref.rs b/clippy_lints/src/methods/useless_asref.rs
index b5505af0f7e..e0b1de68b37 100644
--- a/clippy_lints/src/methods/useless_asref.rs
+++ b/clippy_lints/src/methods/useless_asref.rs
@@ -10,12 +10,11 @@ use rustc_lint::LateContext;
 use super::USELESS_ASREF;
 
 /// Checks for the `USELESS_ASREF` lint.
-pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, call_name: &str, as_ref_args: &[hir::Expr<'_>]) {
+pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, call_name: &str, recvr: &hir::Expr<'_>) {
     // when we get here, we've already checked that the call name is "as_ref" or "as_mut"
     // check if the call is to the actual `AsRef` or `AsMut` trait
     if match_trait_method(cx, expr, &paths::ASREF_TRAIT) || match_trait_method(cx, expr, &paths::ASMUT_TRAIT) {
         // check if the type after `as_ref` or `as_mut` is the same as before
-        let recvr = &as_ref_args[0];
         let rcv_ty = cx.typeck_results().expr_ty(recvr);
         let res_ty = cx.typeck_results().expr_ty(expr);
         let (base_res_ty, res_depth) = walk_ptrs_ty_depth(res_ty);
diff --git a/clippy_lints/src/methods/zst_offset.rs b/clippy_lints/src/methods/zst_offset.rs
index 9f6a7c4db17..0489d0f6fcf 100644
--- a/clippy_lints/src/methods/zst_offset.rs
+++ b/clippy_lints/src/methods/zst_offset.rs
@@ -6,10 +6,9 @@ use rustc_middle::ty;
 
 use super::ZST_OFFSET;
 
-pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::Expr<'_>]) {
+pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr<'_>) {
     if_chain! {
-        if args.len() == 2;
-        if let ty::RawPtr(ty::TypeAndMut { ref ty, .. }) = cx.typeck_results().expr_ty(&args[0]).kind();
+        if let ty::RawPtr(ty::TypeAndMut { ref ty, .. }) = cx.typeck_results().expr_ty(recv).kind();
         if let Ok(layout) = cx.tcx.layout_of(cx.param_env.and(ty));
         if layout.is_zst();
         then {
-- 
cgit 1.4.1-3-g733a5


From 5f887d09b87d7c6a9c3a4f6afa62a20847dd2509 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Tue, 30 Mar 2021 13:35:30 -0500
Subject: Add if_chain lints

---
 clippy_lints/src/lib.rs                  |   4 +
 clippy_lints/src/utils/internal_lints.rs | 177 ++++++++++++++++++++++++++++++-
 tests/ui-internal/if_chain_style.rs      |  92 ++++++++++++++++
 tests/ui-internal/if_chain_style.stderr  |  85 +++++++++++++++
 4 files changed, 353 insertions(+), 5 deletions(-)
 create mode 100644 tests/ui-internal/if_chain_style.rs
 create mode 100644 tests/ui-internal/if_chain_style.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 3e0a3e3ef99..f5941977dd1 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -550,6 +550,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         #[cfg(feature = "internal-lints")]
         &utils::internal_lints::DEFAULT_LINT,
         #[cfg(feature = "internal-lints")]
+        &utils::internal_lints::IF_CHAIN_STYLE,
+        #[cfg(feature = "internal-lints")]
         &utils::internal_lints::INTERNING_DEFINED_SYMBOL,
         #[cfg(feature = "internal-lints")]
         &utils::internal_lints::INVALID_PATHS,
@@ -1026,6 +1028,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         store.register_late_pass(|| box utils::inspector::DeepCodeInspector);
         store.register_late_pass(|| box utils::internal_lints::CollapsibleCalls);
         store.register_late_pass(|| box utils::internal_lints::CompilerLintFunctions::new());
+        store.register_late_pass(|| box utils::internal_lints::IfChainStyle);
         store.register_late_pass(|| box utils::internal_lints::InvalidPaths);
         store.register_late_pass(|| box utils::internal_lints::InterningDefinedSymbol::default());
         store.register_late_pass(|| box utils::internal_lints::LintWithoutLintPass::default());
@@ -1442,6 +1445,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&utils::internal_lints::COLLAPSIBLE_SPAN_LINT_CALLS),
         LintId::of(&utils::internal_lints::COMPILER_LINT_FUNCTIONS),
         LintId::of(&utils::internal_lints::DEFAULT_LINT),
+        LintId::of(&utils::internal_lints::IF_CHAIN_STYLE),
         LintId::of(&utils::internal_lints::INTERNING_DEFINED_SYMBOL),
         LintId::of(&utils::internal_lints::INVALID_PATHS),
         LintId::of(&utils::internal_lints::LINT_WITHOUT_LINT_PASS),
diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs
index c496ff1fb24..266b88beeec 100644
--- a/clippy_lints/src/utils/internal_lints.rs
+++ b/clippy_lints/src/utils/internal_lints.rs
@@ -1,8 +1,10 @@
 use crate::consts::{constant_simple, Constant};
-use clippy_utils::diagnostics::{span_lint, span_lint_and_help, span_lint_and_sugg};
+use clippy_utils::diagnostics::{span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::snippet;
 use clippy_utils::ty::match_type;
-use clippy_utils::{is_expn_of, match_def_path, match_qpath, method_calls, path_to_res, paths, run_lints, SpanlessEq};
+use clippy_utils::{
+    is_else_clause, is_expn_of, match_def_path, match_qpath, method_calls, path_to_res, paths, run_lints, SpanlessEq,
+};
 use if_chain::if_chain;
 use rustc_ast::ast::{Crate as AstCrate, ItemKind, LitKind, ModKind, NodeId};
 use rustc_ast::visit::FnKind;
@@ -14,15 +16,17 @@ use rustc_hir::def_id::DefId;
 use rustc_hir::hir_id::CRATE_HIR_ID;
 use rustc_hir::intravisit::{NestedVisitorMap, Visitor};
 use rustc_hir::{
-    BinOpKind, Crate, Expr, ExprKind, HirId, Item, MutTy, Mutability, Node, Path, StmtKind, Ty, TyKind, UnOp,
+    BinOpKind, Block, Crate, Expr, ExprKind, HirId, Item, Local, MatchSource, MutTy, Mutability, Node, Path, Stmt,
+    StmtKind, Ty, TyKind, UnOp,
 };
-use rustc_lint::{EarlyContext, EarlyLintPass, LateContext, LateLintPass};
+use rustc_lint::{EarlyContext, EarlyLintPass, LateContext, LateLintPass, LintContext};
 use rustc_middle::hir::map::Map;
 use rustc_middle::mir::interpret::ConstValue;
 use rustc_middle::ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint, impl_lint_pass};
-use rustc_span::source_map::{Span, Spanned};
+use rustc_span::source_map::Spanned;
 use rustc_span::symbol::{Symbol, SymbolStr};
+use rustc_span::{BytePos, Span};
 use rustc_typeck::hir_ty_to_ty;
 
 use std::borrow::{Borrow, Cow};
@@ -297,6 +301,13 @@ declare_clippy_lint! {
     "unnecessary conversion between Symbol and string"
 }
 
+declare_clippy_lint! {
+    /// Finds unidiomatic usage of `if_chain!`
+    pub IF_CHAIN_STYLE,
+    internal,
+    "non-idiomatic `if_chain!` usage"
+}
+
 declare_lint_pass!(ClippyLintsInternal => [CLIPPY_LINTS_INTERNAL]);
 
 impl EarlyLintPass for ClippyLintsInternal {
@@ -1063,3 +1074,159 @@ impl<'tcx> SymbolStrExpr<'tcx> {
         }
     }
 }
+
+declare_lint_pass!(IfChainStyle => [IF_CHAIN_STYLE]);
+
+impl<'tcx> LateLintPass<'tcx> for IfChainStyle {
+    fn check_block(&mut self, cx: &LateContext<'tcx>, block: &'tcx hir::Block<'_>) {
+        let (local, after, if_chain_span) = if_chain! {
+            if let [Stmt { kind: StmtKind::Local(local), .. }, after @ ..] = block.stmts;
+            if let Some(if_chain_span) = is_expn_of(block.span, "if_chain");
+            then { (local, after, if_chain_span) } else { return }
+        };
+        if is_first_if_chain_expr(cx, block.hir_id, if_chain_span) {
+            span_lint(
+                cx,
+                IF_CHAIN_STYLE,
+                if_chain_local_span(cx, local, if_chain_span),
+                "`let` expression should be above the `if_chain!`",
+            );
+        } else if local.span.ctxt() == block.span.ctxt() && is_if_chain_then(after, block.expr, if_chain_span) {
+            span_lint(
+                cx,
+                IF_CHAIN_STYLE,
+                if_chain_local_span(cx, local, if_chain_span),
+                "`let` expression should be inside `then { .. }`",
+            )
+        }
+    }
+
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
+        let (cond, then, els) = match expr.kind {
+            ExprKind::If(cond, then, els) => (Some(cond), then, els.is_some()),
+            ExprKind::Match(
+                _,
+                [arm, ..],
+                MatchSource::IfLetDesugar {
+                    contains_else_clause: els,
+                },
+            ) => (None, arm.body, els),
+            _ => return,
+        };
+        let then_block = match then.kind {
+            ExprKind::Block(block, _) => block,
+            _ => return,
+        };
+        let if_chain_span = is_expn_of(expr.span, "if_chain");
+        if !els {
+            check_nested_if_chains(cx, expr, then_block, if_chain_span);
+        }
+        let if_chain_span = match if_chain_span {
+            None => return,
+            Some(span) => span,
+        };
+        // check for `if a && b;`
+        if_chain! {
+            if let Some(cond) = cond;
+            if let ExprKind::Binary(op, _, _) = cond.kind;
+            if op.node == BinOpKind::And;
+            if cx.sess().source_map().is_multiline(cond.span);
+            then {
+                span_lint(cx, IF_CHAIN_STYLE, cond.span, "`if a && b;` should be `if a; if b;`");
+            }
+        }
+        if is_first_if_chain_expr(cx, expr.hir_id, if_chain_span)
+            && is_if_chain_then(then_block.stmts, then_block.expr, if_chain_span)
+        {
+            span_lint(cx, IF_CHAIN_STYLE, expr.span, "`if_chain!` only has one `if`")
+        }
+    }
+}
+
+fn check_nested_if_chains(
+    cx: &LateContext<'_>,
+    if_expr: &Expr<'_>,
+    then_block: &Block<'_>,
+    if_chain_span: Option<Span>,
+) {
+    #[rustfmt::skip]
+    let (head, tail) = match *then_block {
+        Block { stmts, expr: Some(tail), .. } => (stmts, tail),
+        Block {
+            stmts: &[
+                ref head @ ..,
+                Stmt { kind: StmtKind::Expr(tail) | StmtKind::Semi(tail), .. }
+            ],
+            ..
+        } => (head, tail),
+        _ => return,
+    };
+    if_chain! {
+        if matches!(tail.kind,
+            ExprKind::If(_, _, None)
+            | ExprKind::Match(.., MatchSource::IfLetDesugar { contains_else_clause: false }));
+        let sm = cx.sess().source_map();
+        if head
+            .iter()
+            .all(|stmt| matches!(stmt.kind, StmtKind::Local(..)) && !sm.is_multiline(stmt.span));
+        if if_chain_span.is_some() || !is_else_clause(cx.tcx, if_expr);
+        then {} else { return }
+    }
+    let (span, msg) = match (if_chain_span, is_expn_of(tail.span, "if_chain")) {
+        (None, Some(_)) => (if_expr.span, "this `if` can be part of the inner `if_chain!`"),
+        (Some(_), None) => (tail.span, "this `if` can be part of the outer `if_chain!`"),
+        (Some(a), Some(b)) if a != b => (b, "this `if_chain!` can be merged with the outer `if_chain!`"),
+        _ => return,
+    };
+    span_lint_and_then(cx, IF_CHAIN_STYLE, span, msg, |diag| {
+        let (span, msg) = match head {
+            [] => return,
+            [stmt] => (stmt.span, "this `let` statement can also be in the `if_chain!`"),
+            [a, .., b] => (
+                a.span.to(b.span),
+                "these `let` statements can also be in the `if_chain!`",
+            ),
+        };
+        diag.span_help(span, msg);
+    });
+}
+
+fn is_first_if_chain_expr(cx: &LateContext<'_>, hir_id: HirId, if_chain_span: Span) -> bool {
+    cx.tcx
+        .hir()
+        .parent_iter(hir_id)
+        .find(|(_, node)| {
+            #[rustfmt::skip]
+            !matches!(node, Node::Expr(Expr { kind: ExprKind::Block(..), .. }) | Node::Stmt(_))
+        })
+        .map_or(false, |(id, _)| {
+            is_expn_of(cx.tcx.hir().span(id), "if_chain") != Some(if_chain_span)
+        })
+}
+
+/// Checks a trailing slice of statements and expression of a `Block` to see if they are part
+/// of the `then {..}` portion of an `if_chain!`
+fn is_if_chain_then(stmts: &[Stmt<'_>], expr: Option<&Expr<'_>>, if_chain_span: Span) -> bool {
+    let span = if let [stmt, ..] = stmts {
+        stmt.span
+    } else if let Some(expr) = expr {
+        expr.span
+    } else {
+        // empty `then {}`
+        return true;
+    };
+    is_expn_of(span, "if_chain").map_or(true, |span| span != if_chain_span)
+}
+
+/// Creates a `Span` for `let x = ..;` in an `if_chain!` call.
+fn if_chain_local_span(cx: &LateContext<'_>, local: &Local<'_>, if_chain_span: Span) -> Span {
+    let mut span = local.pat.span;
+    if let Some(init) = local.init {
+        span = span.to(init.span);
+    }
+    span.adjust(if_chain_span.ctxt().outer_expn());
+    let sm = cx.sess().source_map();
+    let span = sm.span_extend_to_prev_str(span, "let", false);
+    let span = sm.span_extend_to_next_char(span, ';', false);
+    Span::new(span.lo() - BytePos(3), span.hi() + BytePos(1), span.ctxt())
+}
diff --git a/tests/ui-internal/if_chain_style.rs b/tests/ui-internal/if_chain_style.rs
new file mode 100644
index 00000000000..8e871707aa8
--- /dev/null
+++ b/tests/ui-internal/if_chain_style.rs
@@ -0,0 +1,92 @@
+#![warn(clippy::if_chain_style)]
+#![allow(clippy::no_effect)]
+
+extern crate if_chain;
+
+use if_chain::if_chain;
+
+fn main() {
+    if true {
+        let x = "";
+        // `if_chain!` inside `if`
+        if_chain! {
+            if true;
+            if true;
+            then {}
+        }
+    }
+    if_chain! {
+        if true
+            // multi-line AND'ed conditions
+            && false;
+        if let Some(1) = Some(1);
+        // `let` before `then`
+        let x = "";
+        then {
+            ();
+        }
+    }
+    if_chain! {
+        // single `if` condition
+        if true;
+        then {
+            let x = "";
+            // nested if
+            if true {}
+        }
+    }
+    if_chain! {
+        // starts with `let ..`
+        let x = "";
+        if let Some(1) = Some(1);
+        then {
+            let x = "";
+            let x = "";
+            // nested if_chain!
+            if_chain! {
+                if true;
+                if true;
+                then {}
+            }
+        }
+    }
+}
+
+fn negative() {
+    if true {
+        ();
+        if_chain! {
+            if true;
+            if true;
+            then { (); }
+        }
+    }
+    if_chain! {
+        if true;
+        let x = "";
+        if true;
+        then { (); }
+    }
+    if_chain! {
+        if true;
+        if true;
+        then {
+            if true { 1 } else { 2 }
+        } else {
+            3
+        }
+    };
+    if true {
+        if_chain! {
+            if true;
+            if true;
+            then {}
+        }
+    } else if false {
+        if_chain! {
+            if true;
+            if false;
+            then {}
+        }
+    }
+}
diff --git a/tests/ui-internal/if_chain_style.stderr b/tests/ui-internal/if_chain_style.stderr
new file mode 100644
index 00000000000..b53c3ea05da
--- /dev/null
+++ b/tests/ui-internal/if_chain_style.stderr
@@ -0,0 +1,85 @@
+error: this `if` can be part of the inner `if_chain!`
+  --> $DIR/if_chain_style.rs:9:5
+   |
+LL | /     if true {
+LL | |         let x = "";
+LL | |         // `if_chain!` inside `if`
+LL | |         if_chain! {
+...  |
+LL | |         }
+LL | |     }
+   | |_____^
+   |
+   = note: `-D clippy::if-chain-style` implied by `-D warnings`
+help: this `let` statement can also be in the `if_chain!`
+  --> $DIR/if_chain_style.rs:10:9
+   |
+LL |         let x = "";
+   |         ^^^^^^^^^^^
+
+error: `if a && b;` should be `if a; if b;`
+  --> $DIR/if_chain_style.rs:19:12
+   |
+LL |           if true
+   |  ____________^
+LL | |             // multi-line AND'ed conditions
+LL | |             && false;
+   | |____________________^
+
+error: `let` expression should be inside `then { .. }`
+  --> $DIR/if_chain_style.rs:24:9
+   |
+LL |         let x = "";
+   |         ^^^^^^^^^^^
+
+error: this `if` can be part of the outer `if_chain!`
+  --> $DIR/if_chain_style.rs:35:13
+   |
+LL |             if true {}
+   |             ^^^^^^^^^^
+   |
+help: this `let` statement can also be in the `if_chain!`
+  --> $DIR/if_chain_style.rs:33:13
+   |
+LL |             let x = "";
+   |             ^^^^^^^^^^^
+
+error: `if_chain!` only has one `if`
+  --> $DIR/if_chain_style.rs:29:5
+   |
+LL | /     if_chain! {
+LL | |         // single `if` condition
+LL | |         if true;
+LL | |         then {
+...  |
+LL | |         }
+LL | |     }
+   | |_____^
+   |
+   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: `let` expression should be above the `if_chain!`
+  --> $DIR/if_chain_style.rs:40:9
+   |
+LL |         let x = "";
+   |         ^^^^^^^^^^^
+
+error: this `if_chain!` can be merged with the outer `if_chain!`
+  --> $DIR/if_chain_style.rs:46:13
+   |
+LL | /             if_chain! {
+LL | |                 if true;
+LL | |                 if true;
+LL | |                 then {}
+LL | |             }
+   | |_____________^
+   |
+help: these `let` statements can also be in the `if_chain!`
+  --> $DIR/if_chain_style.rs:43:13
+   |
+LL | /             let x = "";
+LL | |             let x = "";
+   | |_______________________^
+
+error: aborting due to 7 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 827d6aaad4a7ec24dd3191160cefe0c1e0b654b9 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Tue, 30 Mar 2021 14:59:59 -0500
Subject: Eat dogfood

---
 clippy_lints/src/attrs.rs                          |   2 +-
 clippy_lints/src/bytecount.rs                      |  82 ++++++++--------
 clippy_lints/src/checked_conversions.rs            |   6 +-
 clippy_lints/src/collapsible_match.rs              |   2 +-
 clippy_lints/src/default.rs                        |  43 +++++----
 clippy_lints/src/default_numeric_fallback.rs       |   2 +-
 clippy_lints/src/exit.rs                           |  16 ++--
 clippy_lints/src/float_literal.rs                  |   2 +-
 clippy_lints/src/formatting.rs                     |   3 +-
 clippy_lints/src/if_let_mutex.rs                   |  22 ++---
 clippy_lints/src/loops/manual_flatten.rs           |   3 +-
 clippy_lints/src/loops/manual_memcpy.rs            |   4 +-
 clippy_lints/src/loops/needless_collect.rs         | 105 ++++++++++-----------
 clippy_lints/src/loops/needless_range_loop.rs      |  74 +++++++--------
 clippy_lints/src/loops/same_item_push.rs           |   2 +-
 .../src/loops/while_immutable_condition.rs         |   3 +-
 clippy_lints/src/manual_non_exhaustive.rs          |   2 +-
 clippy_lints/src/map_clone.rs                      |   4 +-
 clippy_lints/src/map_unit_fn.rs                    |  16 ++--
 clippy_lints/src/matches.rs                        |   4 +-
 clippy_lints/src/mem_replace.rs                    |  49 +++++-----
 clippy_lints/src/methods/bytes_nth.rs              |  50 +++++-----
 .../src/methods/from_iter_instead_of_collect.rs    |   2 +-
 clippy_lints/src/methods/mod.rs                    |   7 +-
 clippy_lints/src/methods/unnecessary_filter_map.rs |  18 ++--
 clippy_lints/src/misc.rs                           | 102 ++++++++++----------
 clippy_lints/src/new_without_default.rs            |  96 +++++++++----------
 clippy_lints/src/non_copy_const.rs                 |  22 ++---
 clippy_lints/src/panic_unimplemented.rs            |   7 +-
 clippy_lints/src/ptr.rs                            |  23 +++--
 clippy_lints/src/ranges.rs                         |  49 +++++-----
 clippy_lints/src/redundant_closure_call.rs         |   4 +-
 clippy_lints/src/suspicious_trait_impl.rs          |   7 +-
 .../src/transmute/transmute_float_to_int.rs        |   2 +-
 clippy_lints/src/try_err.rs                        |  11 +--
 clippy_lints/src/unit_return_expecting_ord.rs      |   2 +-
 clippy_lints/src/unit_types/unit_arg.rs            |   4 +-
 clippy_lints/src/unnamed_address.rs                |   4 +-
 clippy_lints/src/unused_self.rs                    |  25 +++--
 clippy_lints/src/unwrap_in_result.rs               |  44 ++++-----
 clippy_lints/src/useless_conversion.rs             |  41 ++++----
 clippy_lints/src/utils/internal_lints.rs           |   4 +-
 clippy_lints/src/vec_init_then_push.rs             |  31 +++---
 43 files changed, 469 insertions(+), 532 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs
index 3cef8d2a78b..0ce46e1c214 100644
--- a/clippy_lints/src/attrs.rs
+++ b/clippy_lints/src/attrs.rs
@@ -371,8 +371,8 @@ fn extract_clippy_lint(lint: &NestedMetaItem) -> Option<SymbolStr> {
         if meta_item.path.segments.len() > 1;
         if let tool_name = meta_item.path.segments[0].ident;
         if tool_name.name == sym::clippy;
-        let lint_name = meta_item.path.segments.last().unwrap().ident.name;
         then {
+            let lint_name = meta_item.path.segments.last().unwrap().ident.name;
             return Some(lint_name.as_str());
         }
     }
diff --git a/clippy_lints/src/bytecount.rs b/clippy_lints/src/bytecount.rs
index 846ac08e93a..1546d823167 100644
--- a/clippy_lints/src/bytecount.rs
+++ b/clippy_lints/src/bytecount.rs
@@ -45,52 +45,48 @@ impl<'tcx> LateLintPass<'tcx> for ByteCount {
             if filter.ident.name == sym!(filter);
             if filter_args.len() == 2;
             if let ExprKind::Closure(_, _, body_id, _, _) = filter_args[1].kind;
+            let body = cx.tcx.hir().body(body_id);
+            if body.params.len() == 1;
+            if let Some(argname) = get_pat_name(&body.params[0].pat);
+            if let ExprKind::Binary(ref op, ref l, ref r) = body.value.kind;
+            if op.node == BinOpKind::Eq;
+            if match_type(cx,
+                       cx.typeck_results().expr_ty(&filter_args[0]).peel_refs(),
+                       &paths::SLICE_ITER);
             then {
-                let body = cx.tcx.hir().body(body_id);
-                if_chain! {
-                    if body.params.len() == 1;
-                    if let Some(argname) = get_pat_name(&body.params[0].pat);
-                    if let ExprKind::Binary(ref op, ref l, ref r) = body.value.kind;
-                    if op.node == BinOpKind::Eq;
-                    if match_type(cx,
-                               cx.typeck_results().expr_ty(&filter_args[0]).peel_refs(),
-                               &paths::SLICE_ITER);
-                    then {
-                        let needle = match get_path_name(l) {
-                            Some(name) if check_arg(name, argname, r) => r,
-                            _ => match get_path_name(r) {
-                                Some(name) if check_arg(name, argname, l) => l,
-                                _ => { return; }
-                            }
-                        };
-                        if ty::Uint(UintTy::U8) != *cx.typeck_results().expr_ty(needle).peel_refs().kind() {
-                            return;
-                        }
-                        let haystack = if let ExprKind::MethodCall(ref path, _, ref args, _) =
-                                filter_args[0].kind {
-                            let p = path.ident.name;
-                            if (p == sym::iter || p == sym!(iter_mut)) && args.len() == 1 {
-                                &args[0]
-                            } else {
-                                &filter_args[0]
-                            }
-                        } else {
-                            &filter_args[0]
-                        };
-                        let mut applicability = Applicability::MaybeIncorrect;
-                        span_lint_and_sugg(
-                            cx,
-                            NAIVE_BYTECOUNT,
-                            expr.span,
-                            "you appear to be counting bytes the naive way",
-                            "consider using the bytecount crate",
-                            format!("bytecount::count({}, {})",
-                                    snippet_with_applicability(cx, haystack.span, "..", &mut applicability),
-                                    snippet_with_applicability(cx, needle.span, "..", &mut applicability)),
-                            applicability,
-                        );
+                let needle = match get_path_name(l) {
+                    Some(name) if check_arg(name, argname, r) => r,
+                    _ => match get_path_name(r) {
+                        Some(name) if check_arg(name, argname, l) => l,
+                        _ => { return; }
                     }
                 };
+                if ty::Uint(UintTy::U8) != *cx.typeck_results().expr_ty(needle).peel_refs().kind() {
+                    return;
+                }
+                let haystack = if let ExprKind::MethodCall(ref path, _, ref args, _) =
+                        filter_args[0].kind {
+                    let p = path.ident.name;
+                    if (p == sym::iter || p == sym!(iter_mut)) && args.len() == 1 {
+                        &args[0]
+                    } else {
+                        &filter_args[0]
+                    }
+                } else {
+                    &filter_args[0]
+                };
+                let mut applicability = Applicability::MaybeIncorrect;
+                span_lint_and_sugg(
+                    cx,
+                    NAIVE_BYTECOUNT,
+                    expr.span,
+                    "you appear to be counting bytes the naive way",
+                    "consider using the bytecount crate",
+                    format!("bytecount::count({}, {})",
+                            snippet_with_applicability(cx, haystack.span, "..", &mut applicability),
+                            snippet_with_applicability(cx, needle.span, "..", &mut applicability)),
+                    applicability,
+                );
             }
         };
     }
diff --git a/clippy_lints/src/checked_conversions.rs b/clippy_lints/src/checked_conversions.rs
index ed46cac493a..b38c70bcc41 100644
--- a/clippy_lints/src/checked_conversions.rs
+++ b/clippy_lints/src/checked_conversions.rs
@@ -321,9 +321,8 @@ fn get_implementing_type<'a>(path: &QPath<'_>, candidates: &'a [&str], function:
         if path.ident.name.as_str() == function;
         if let TyKind::Path(QPath::Resolved(None, ref tp)) = &ty.kind;
         if let [int] = &*tp.segments;
-        let name = &int.ident.name.as_str();
-
         then {
+            let name = &int.ident.name.as_str();
             candidates.iter().find(|c| name == *c).cloned()
         } else {
             None
@@ -336,9 +335,8 @@ fn int_ty_to_sym<'tcx>(path: &QPath<'_>) -> Option<&'tcx str> {
     if_chain! {
         if let QPath::Resolved(_, ref path) = *path;
         if let [ty] = &*path.segments;
-        let name = &ty.ident.name.as_str();
-
         then {
+            let name = &ty.ident.name.as_str();
             INTS.iter().find(|c| name == *c).cloned()
         } else {
             None
diff --git a/clippy_lints/src/collapsible_match.rs b/clippy_lints/src/collapsible_match.rs
index e2b3686ddf0..04fff237bb4 100644
--- a/clippy_lints/src/collapsible_match.rs
+++ b/clippy_lints/src/collapsible_match.rs
@@ -62,8 +62,8 @@ impl<'tcx> LateLintPass<'tcx> for CollapsibleMatch {
 }
 
 fn check_arm<'tcx>(arm: &Arm<'tcx>, wild_outer_arm: &Arm<'tcx>, cx: &LateContext<'tcx>) {
+    let expr = strip_singleton_blocks(arm.body);
     if_chain! {
-        let expr = strip_singleton_blocks(arm.body);
         if let ExprKind::Match(expr_in, arms_inner, _) = expr.kind;
         // the outer arm pattern and the inner match
         if expr_in.span.ctxt() == arm.pat.span.ctxt();
diff --git a/clippy_lints/src/default.rs b/clippy_lints/src/default.rs
index 568a174445c..8a2146d93e8 100644
--- a/clippy_lints/src/default.rs
+++ b/clippy_lints/src/default.rs
@@ -84,22 +84,21 @@ impl LateLintPass<'_> for Default {
             if match_def_path(cx, def_id, &paths::DEFAULT_TRAIT_METHOD);
             // Detect and ignore <Foo as Default>::default() because these calls do explicitly name the type.
             if let QPath::Resolved(None, _path) = qpath;
+            let expr_ty = cx.typeck_results().expr_ty(expr);
+            if let ty::Adt(def, ..) = expr_ty.kind();
             then {
-                let expr_ty = cx.typeck_results().expr_ty(expr);
-                if let ty::Adt(def, ..) = expr_ty.kind() {
-                    // TODO: Work out a way to put "whatever the imported way of referencing
-                    // this type in this file" rather than a fully-qualified type.
-                    let replacement = format!("{}::default()", cx.tcx.def_path_str(def.did));
-                    span_lint_and_sugg(
-                        cx,
-                        DEFAULT_TRAIT_ACCESS,
-                        expr.span,
-                        &format!("calling `{}` is more clear than this expression", replacement),
-                        "try",
-                        replacement,
-                        Applicability::Unspecified, // First resolve the TODO above
-                    );
-                }
+                // TODO: Work out a way to put "whatever the imported way of referencing
+                // this type in this file" rather than a fully-qualified type.
+                let replacement = format!("{}::default()", cx.tcx.def_path_str(def.did));
+                span_lint_and_sugg(
+                    cx,
+                    DEFAULT_TRAIT_ACCESS,
+                    expr.span,
+                    &format!("calling `{}` is more clear than this expression", replacement),
+                    "try",
+                    replacement,
+                    Applicability::Unspecified, // First resolve the TODO above
+                );
             }
         }
     }
@@ -202,14 +201,14 @@ impl LateLintPass<'_> for Default {
                 let binding_type = if_chain! {
                     if let ty::Adt(adt_def, substs) = binding_type.kind();
                     if !substs.is_empty();
-                    let adt_def_ty_name = cx.tcx.item_name(adt_def.did);
-                    let generic_args = substs.iter().collect::<Vec<_>>();
-                    let tys_str = generic_args
-                        .iter()
-                        .map(ToString::to_string)
-                        .collect::<Vec<_>>()
-                        .join(", ");
                     then {
+                        let adt_def_ty_name = cx.tcx.item_name(adt_def.did);
+                        let generic_args = substs.iter().collect::<Vec<_>>();
+                        let tys_str = generic_args
+                            .iter()
+                            .map(ToString::to_string)
+                            .collect::<Vec<_>>()
+                            .join(", ");
                         format!("{}::<{}>", adt_def_ty_name, &tys_str)
                     } else {
                         binding_type.to_string()
diff --git a/clippy_lints/src/default_numeric_fallback.rs b/clippy_lints/src/default_numeric_fallback.rs
index d136db9373c..42bafc3442e 100644
--- a/clippy_lints/src/default_numeric_fallback.rs
+++ b/clippy_lints/src/default_numeric_fallback.rs
@@ -130,8 +130,8 @@ impl<'a, 'tcx> Visitor<'tcx> for NumericFallbackVisitor<'a, 'tcx> {
             },
 
             ExprKind::Struct(_, fields, base) => {
+                let ty = self.cx.typeck_results().expr_ty(expr);
                 if_chain! {
-                    let ty = self.cx.typeck_results().expr_ty(expr);
                     if let Some(adt_def) = ty.ty_adt_def();
                     if adt_def.is_struct();
                     if let Some(variant) = adt_def.variants.iter().next();
diff --git a/clippy_lints/src/exit.rs b/clippy_lints/src/exit.rs
index 635b6d83eab..84fac998662 100644
--- a/clippy_lints/src/exit.rs
+++ b/clippy_lints/src/exit.rs
@@ -32,16 +32,14 @@ impl<'tcx> LateLintPass<'tcx> for Exit {
             if let ExprKind::Path(ref path) = path_expr.kind;
             if let Some(def_id) = cx.qpath_res(path, path_expr.hir_id).opt_def_id();
             if match_def_path(cx, def_id, &paths::EXIT);
+            let parent = cx.tcx.hir().get_parent_item(e.hir_id);
+            if let Some(Node::Item(Item{kind: ItemKind::Fn(..), ..})) = cx.tcx.hir().find(parent);
+            // If the next item up is a function we check if it is an entry point
+            // and only then emit a linter warning
+            let def_id = cx.tcx.hir().local_def_id(parent);
+            if !is_entrypoint_fn(cx, def_id.to_def_id());
             then {
-                let parent = cx.tcx.hir().get_parent_item(e.hir_id);
-                if let Some(Node::Item(Item{kind: ItemKind::Fn(..), ..})) = cx.tcx.hir().find(parent) {
-                    // If the next item up is a function we check if it is an entry point
-                    // and only then emit a linter warning
-                    let def_id = cx.tcx.hir().local_def_id(parent);
-                    if !is_entrypoint_fn(cx, def_id.to_def_id()) {
-                        span_lint(cx, EXIT, e.span, "usage of `process::exit`");
-                    }
-                }
+                span_lint(cx, EXIT, e.span, "usage of `process::exit`");
             }
         }
     }
diff --git a/clippy_lints/src/float_literal.rs b/clippy_lints/src/float_literal.rs
index 1ca5c685a75..7968e7b764d 100644
--- a/clippy_lints/src/float_literal.rs
+++ b/clippy_lints/src/float_literal.rs
@@ -61,8 +61,8 @@ declare_lint_pass!(FloatLiteral => [EXCESSIVE_PRECISION, LOSSY_FLOAT_LITERAL]);
 
 impl<'tcx> LateLintPass<'tcx> for FloatLiteral {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
+        let ty = cx.typeck_results().expr_ty(expr);
         if_chain! {
-            let ty = cx.typeck_results().expr_ty(expr);
             if let ty::Float(fty) = *ty.kind();
             if let hir::ExprKind::Lit(ref lit) = expr.kind;
             if let LitKind::Float(sym, lit_float_ty) = lit.node;
diff --git a/clippy_lints/src/formatting.rs b/clippy_lints/src/formatting.rs
index b10e83c0ea8..48612befc68 100644
--- a/clippy_lints/src/formatting.rs
+++ b/clippy_lints/src/formatting.rs
@@ -217,9 +217,8 @@ fn check_else(cx: &EarlyContext<'_>, expr: &Expr) {
         if let Some(else_snippet) = snippet_opt(cx, else_span);
         if let Some(else_pos) = else_snippet.find("else");
         if else_snippet[else_pos..].contains('\n');
-        let else_desc = if is_if(else_) { "if" } else { "{..}" };
-
         then {
+            let else_desc = if is_if(else_) { "if" } else { "{..}" };
             span_lint_and_note(
                 cx,
                 SUSPICIOUS_ELSE_FORMATTING,
diff --git a/clippy_lints/src/if_let_mutex.rs b/clippy_lints/src/if_let_mutex.rs
index 4aab43256bf..56dfcc6a506 100644
--- a/clippy_lints/src/if_let_mutex.rs
+++ b/clippy_lints/src/if_let_mutex.rs
@@ -94,13 +94,10 @@ impl<'tcx> Visitor<'tcx> for OppVisitor<'_, 'tcx> {
     type Map = Map<'tcx>;
 
     fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
-        if_chain! {
-            if let Some(mutex) = is_mutex_lock_call(self.cx, expr);
-            then {
-                self.found_mutex = Some(mutex);
-                self.mutex_lock_called = true;
-                return;
-            }
+        if let Some(mutex) = is_mutex_lock_call(self.cx, expr) {
+            self.found_mutex = Some(mutex);
+            self.mutex_lock_called = true;
+            return;
         }
         visit::walk_expr(self, expr);
     }
@@ -121,13 +118,10 @@ impl<'tcx> Visitor<'tcx> for ArmVisitor<'_, 'tcx> {
     type Map = Map<'tcx>;
 
     fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) {
-        if_chain! {
-            if let Some(mutex) = is_mutex_lock_call(self.cx, expr);
-            then {
-                self.found_mutex = Some(mutex);
-                self.mutex_lock_called = true;
-                return;
-            }
+        if let Some(mutex) = is_mutex_lock_call(self.cx, expr) {
+            self.found_mutex = Some(mutex);
+            self.mutex_lock_called = true;
+            return;
         }
         visit::walk_expr(self, expr);
     }
diff --git a/clippy_lints/src/loops/manual_flatten.rs b/clippy_lints/src/loops/manual_flatten.rs
index 8d2b9cccba4..574ad8c0f29 100644
--- a/clippy_lints/src/loops/manual_flatten.rs
+++ b/clippy_lints/src/loops/manual_flatten.rs
@@ -46,9 +46,8 @@ pub(super) fn check<'tcx>(
             let some_ctor = is_some_ctor(cx, path.res);
             let ok_ctor = is_ok_ctor(cx, path.res);
             if some_ctor || ok_ctor;
-            let if_let_type = if some_ctor { "Some" } else { "Ok" };
-
             then {
+                let if_let_type = if some_ctor { "Some" } else { "Ok" };
                 // Prepare the error message
                 let msg = format!("unnecessary `if let` since only the `{}` variant of the iterator element is used", if_let_type);
 
diff --git a/clippy_lints/src/loops/manual_memcpy.rs b/clippy_lints/src/loops/manual_memcpy.rs
index af6d56a89af..3c5abb7a3c4 100644
--- a/clippy_lints/src/loops/manual_memcpy.rs
+++ b/clippy_lints/src/loops/manual_memcpy.rs
@@ -61,8 +61,8 @@ pub(super) fn check<'tcx>(
                         if_chain! {
                             if let ExprKind::Index(base_left, idx_left) = lhs.kind;
                             if let ExprKind::Index(base_right, idx_right) = rhs.kind;
-                            if is_slice_like(cx, cx.typeck_results().expr_ty(base_left))
-                                && is_slice_like(cx, cx.typeck_results().expr_ty(base_right));
+                            if is_slice_like(cx, cx.typeck_results().expr_ty(base_left));
+                            if is_slice_like(cx, cx.typeck_results().expr_ty(base_right));
                             if let Some((start_left, offset_left)) = get_details_from_idx(cx, &idx_left, &starts);
                             if let Some((start_right, offset_right)) = get_details_from_idx(cx, &idx_right, &starts);
 
diff --git a/clippy_lints/src/loops/needless_collect.rs b/clippy_lints/src/loops/needless_collect.rs
index 5594fc7b046..d23d3c508fa 100644
--- a/clippy_lints/src/loops/needless_collect.rs
+++ b/clippy_lints/src/loops/needless_collect.rs
@@ -26,60 +26,59 @@ fn check_needless_collect_direct_usage<'tcx>(expr: &'tcx Expr<'_>, cx: &LateCont
         if chain_method.ident.name == sym!(collect) && is_trait_method(cx, &args[0], sym::Iterator);
         if let Some(ref generic_args) = chain_method.args;
         if let Some(GenericArg::Type(ref ty)) = generic_args.args.get(0);
+        let ty = cx.typeck_results().node_type(ty.hir_id);
+        if is_type_diagnostic_item(cx, ty, sym::vec_type)
+            || is_type_diagnostic_item(cx, ty, sym::vecdeque_type)
+            || match_type(cx, ty, &paths::BTREEMAP)
+            || is_type_diagnostic_item(cx, ty, sym::hashmap_type);
         then {
-            let ty = cx.typeck_results().node_type(ty.hir_id);
-            if is_type_diagnostic_item(cx, ty, sym::vec_type) ||
-                is_type_diagnostic_item(cx, ty, sym::vecdeque_type) ||
-                match_type(cx, ty, &paths::BTREEMAP) ||
-                is_type_diagnostic_item(cx, ty, sym::hashmap_type) {
-                if method.ident.name == sym!(len) {
-                    let span = shorten_needless_collect_span(expr);
-                    span_lint_and_sugg(
-                        cx,
-                        NEEDLESS_COLLECT,
-                        span,
-                        NEEDLESS_COLLECT_MSG,
-                        "replace with",
-                        "count()".to_string(),
-                        Applicability::MachineApplicable,
-                    );
-                }
-                if method.ident.name == sym!(is_empty) {
-                    let span = shorten_needless_collect_span(expr);
-                    span_lint_and_sugg(
-                        cx,
-                        NEEDLESS_COLLECT,
-                        span,
-                        NEEDLESS_COLLECT_MSG,
-                        "replace with",
-                        "next().is_none()".to_string(),
-                        Applicability::MachineApplicable,
-                    );
-                }
-                if method.ident.name == sym!(contains) {
-                    let contains_arg = snippet(cx, args[1].span, "??");
-                    let span = shorten_needless_collect_span(expr);
-                    span_lint_and_then(
-                        cx,
-                        NEEDLESS_COLLECT,
-                        span,
-                        NEEDLESS_COLLECT_MSG,
-                        |diag| {
-                            let (arg, pred) = contains_arg
-                                    .strip_prefix('&')
-                                    .map_or(("&x", &*contains_arg), |s| ("x", s));
-                            diag.span_suggestion(
-                                span,
-                                "replace with",
-                                format!(
-                                    "any(|{}| x == {})",
-                                    arg, pred
-                                ),
-                                Applicability::MachineApplicable,
-                            );
-                        }
-                    );
-                }
+            if method.ident.name == sym!(len) {
+                let span = shorten_needless_collect_span(expr);
+                span_lint_and_sugg(
+                    cx,
+                    NEEDLESS_COLLECT,
+                    span,
+                    NEEDLESS_COLLECT_MSG,
+                    "replace with",
+                    "count()".to_string(),
+                    Applicability::MachineApplicable,
+                );
+            }
+            if method.ident.name == sym!(is_empty) {
+                let span = shorten_needless_collect_span(expr);
+                span_lint_and_sugg(
+                    cx,
+                    NEEDLESS_COLLECT,
+                    span,
+                    NEEDLESS_COLLECT_MSG,
+                    "replace with",
+                    "next().is_none()".to_string(),
+                    Applicability::MachineApplicable,
+                );
+            }
+            if method.ident.name == sym!(contains) {
+                let contains_arg = snippet(cx, args[1].span, "??");
+                let span = shorten_needless_collect_span(expr);
+                span_lint_and_then(
+                    cx,
+                    NEEDLESS_COLLECT,
+                    span,
+                    NEEDLESS_COLLECT_MSG,
+                    |diag| {
+                        let (arg, pred) = contains_arg
+                                .strip_prefix('&')
+                                .map_or(("&x", &*contains_arg), |s| ("x", s));
+                        diag.span_suggestion(
+                            span,
+                            "replace with",
+                            format!(
+                                "any(|{}| x == {})",
+                                arg, pred
+                            ),
+                            Applicability::MachineApplicable,
+                        );
+                    }
+                );
             }
         }
     }
diff --git a/clippy_lints/src/loops/needless_range_loop.rs b/clippy_lints/src/loops/needless_range_loop.rs
index 3c40d54cb42..60afa449a45 100644
--- a/clippy_lints/src/loops/needless_range_loop.rs
+++ b/clippy_lints/src/loops/needless_range_loop.rs
@@ -256,49 +256,47 @@ impl<'a, 'tcx> VarVisitor<'a, 'tcx> {
             if let ExprKind::Path(ref seqpath) = seqexpr.kind;
             if let QPath::Resolved(None, ref seqvar) = *seqpath;
             if seqvar.segments.len() == 1;
+            let index_used_directly = path_to_local_id(idx, self.var);
+            let indexed_indirectly = {
+                let mut used_visitor = LocalUsedVisitor::new(self.cx, self.var);
+                walk_expr(&mut used_visitor, idx);
+                used_visitor.used
+            };
+            if indexed_indirectly || index_used_directly;
             then {
-                let index_used_directly = path_to_local_id(idx, self.var);
-                let indexed_indirectly = {
-                    let mut used_visitor = LocalUsedVisitor::new(self.cx, self.var);
-                    walk_expr(&mut used_visitor, idx);
-                    used_visitor.used
-                };
-
-                if indexed_indirectly || index_used_directly {
-                    if self.prefer_mutable {
-                        self.indexed_mut.insert(seqvar.segments[0].ident.name);
+                if self.prefer_mutable {
+                    self.indexed_mut.insert(seqvar.segments[0].ident.name);
+                }
+                let res = self.cx.qpath_res(seqpath, seqexpr.hir_id);
+                match res {
+                    Res::Local(hir_id) => {
+                        let parent_id = self.cx.tcx.hir().get_parent_item(expr.hir_id);
+                        let parent_def_id = self.cx.tcx.hir().local_def_id(parent_id);
+                        let extent = self.cx.tcx.region_scope_tree(parent_def_id).var_scope(hir_id.local_id);
+                        if indexed_indirectly {
+                            self.indexed_indirectly.insert(seqvar.segments[0].ident.name, Some(extent));
+                        }
+                        if index_used_directly {
+                            self.indexed_directly.insert(
+                                seqvar.segments[0].ident.name,
+                                (Some(extent), self.cx.typeck_results().node_type(seqexpr.hir_id)),
+                            );
+                        }
+                        return false;  // no need to walk further *on the variable*
                     }
-                    let res = self.cx.qpath_res(seqpath, seqexpr.hir_id);
-                    match res {
-                        Res::Local(hir_id) => {
-                            let parent_id = self.cx.tcx.hir().get_parent_item(expr.hir_id);
-                            let parent_def_id = self.cx.tcx.hir().local_def_id(parent_id);
-                            let extent = self.cx.tcx.region_scope_tree(parent_def_id).var_scope(hir_id.local_id);
-                            if indexed_indirectly {
-                                self.indexed_indirectly.insert(seqvar.segments[0].ident.name, Some(extent));
-                            }
-                            if index_used_directly {
-                                self.indexed_directly.insert(
-                                    seqvar.segments[0].ident.name,
-                                    (Some(extent), self.cx.typeck_results().node_type(seqexpr.hir_id)),
-                                );
-                            }
-                            return false;  // no need to walk further *on the variable*
+                    Res::Def(DefKind::Static | DefKind::Const, ..) => {
+                        if indexed_indirectly {
+                            self.indexed_indirectly.insert(seqvar.segments[0].ident.name, None);
                         }
-                        Res::Def(DefKind::Static | DefKind::Const, ..) => {
-                            if indexed_indirectly {
-                                self.indexed_indirectly.insert(seqvar.segments[0].ident.name, None);
-                            }
-                            if index_used_directly {
-                                self.indexed_directly.insert(
-                                    seqvar.segments[0].ident.name,
-                                    (None, self.cx.typeck_results().node_type(seqexpr.hir_id)),
-                                );
-                            }
-                            return false;  // no need to walk further *on the variable*
+                        if index_used_directly {
+                            self.indexed_directly.insert(
+                                seqvar.segments[0].ident.name,
+                                (None, self.cx.typeck_results().node_type(seqexpr.hir_id)),
+                            );
                         }
-                        _ => (),
+                        return false;  // no need to walk further *on the variable*
                     }
+                    _ => (),
                 }
             }
         }
diff --git a/clippy_lints/src/loops/same_item_push.rs b/clippy_lints/src/loops/same_item_push.rs
index 849d7ec718c..62c131968e7 100644
--- a/clippy_lints/src/loops/same_item_push.rs
+++ b/clippy_lints/src/loops/same_item_push.rs
@@ -63,8 +63,8 @@ pub(super) fn check<'tcx>(
                         match cx.qpath_res(qpath, pushed_item.hir_id) {
                             // immutable bindings that are initialized with literal or constant
                             Res::Local(hir_id) => {
+                                let node = cx.tcx.hir().get(hir_id);
                                 if_chain! {
-                                    let node = cx.tcx.hir().get(hir_id);
                                     if let Node::Binding(pat) = node;
                                     if let PatKind::Binding(bind_ann, ..) = pat.kind;
                                     if !matches!(bind_ann, BindingAnnotation::RefMut | BindingAnnotation::Mutable);
diff --git a/clippy_lints/src/loops/while_immutable_condition.rs b/clippy_lints/src/loops/while_immutable_condition.rs
index cad9ff8489a..7d697b2bf00 100644
--- a/clippy_lints/src/loops/while_immutable_condition.rs
+++ b/clippy_lints/src/loops/while_immutable_condition.rs
@@ -103,9 +103,8 @@ impl<'a, 'tcx> VarCollectorVisitor<'a, 'tcx> {
         if_chain! {
             if let ExprKind::Path(ref qpath) = ex.kind;
             if let QPath::Resolved(None, _) = *qpath;
-            let res = self.cx.qpath_res(qpath, ex.hir_id);
             then {
-                match res {
+                match self.cx.qpath_res(qpath, ex.hir_id) {
                     Res::Local(hir_id) => {
                         self.ids.insert(hir_id);
                     },
diff --git a/clippy_lints/src/manual_non_exhaustive.rs b/clippy_lints/src/manual_non_exhaustive.rs
index 95261580b8e..5a3f0f27bc6 100644
--- a/clippy_lints/src/manual_non_exhaustive.rs
+++ b/clippy_lints/src/manual_non_exhaustive.rs
@@ -113,8 +113,8 @@ fn check_manual_non_exhaustive_enum(cx: &EarlyContext<'_>, item: &Item, variants
             }
     }
 
+    let mut markers = variants.iter().filter(|v| is_non_exhaustive_marker(v));
     if_chain! {
-        let mut markers = variants.iter().filter(|v| is_non_exhaustive_marker(v));
         if let Some(marker) = markers.next();
         if markers.count() == 0 && variants.len() > 1;
         then {
diff --git a/clippy_lints/src/map_clone.rs b/clippy_lints/src/map_clone.rs
index cfcc705eabc..9f1ab1f695d 100644
--- a/clippy_lints/src/map_clone.rs
+++ b/clippy_lints/src/map_clone.rs
@@ -58,9 +58,9 @@ impl<'tcx> LateLintPass<'tcx> for MapClone {
             let ty = cx.typeck_results().expr_ty(&args[0]);
             if is_type_diagnostic_item(cx, ty, sym::option_type) || is_trait_method(cx, e, sym::Iterator);
             if let hir::ExprKind::Closure(_, _, body_id, _, _) = args[1].kind;
-            let closure_body = cx.tcx.hir().body(body_id);
-            let closure_expr = remove_blocks(&closure_body.value);
             then {
+                let closure_body = cx.tcx.hir().body(body_id);
+                let closure_expr = remove_blocks(&closure_body.value);
                 match closure_body.params[0].pat.kind {
                     hir::PatKind::Ref(ref inner, hir::Mutability::Not) => if let hir::PatKind::Binding(
                         hir::BindingAnnotation::Unannotated, .., name, None
diff --git a/clippy_lints/src/map_unit_fn.rs b/clippy_lints/src/map_unit_fn.rs
index d4764b5ccff..5cc16244a0d 100644
--- a/clippy_lints/src/map_unit_fn.rs
+++ b/clippy_lints/src/map_unit_fn.rs
@@ -168,17 +168,15 @@ fn unit_closure<'tcx>(
     cx: &LateContext<'tcx>,
     expr: &hir::Expr<'_>,
 ) -> Option<(&'tcx hir::Param<'tcx>, &'tcx hir::Expr<'tcx>)> {
-    if let hir::ExprKind::Closure(_, ref decl, inner_expr_id, _, _) = expr.kind {
+    if_chain! {
+        if let hir::ExprKind::Closure(_, ref decl, inner_expr_id, _, _) = expr.kind;
         let body = cx.tcx.hir().body(inner_expr_id);
         let body_expr = &body.value;
-
-        if_chain! {
-            if decl.inputs.len() == 1;
-            if is_unit_expression(cx, body_expr);
-            if let Some(binding) = iter_input_pats(&decl, body).next();
-            then {
-                return Some((binding, body_expr));
-            }
+        if decl.inputs.len() == 1;
+        if is_unit_expression(cx, body_expr);
+        if let Some(binding) = iter_input_pats(&decl, body).next();
+        then {
+            return Some((binding, body_expr));
         }
     }
     None
diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index 8c6c30a1881..4a3be67dd75 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -732,8 +732,8 @@ fn report_single_match_single_pattern(
         format!(" else {}", expr_block(cx, els, None, "..", Some(expr.span)))
     });
 
+    let (pat, pat_ref_count) = peel_hir_pat_refs(arms[0].pat);
     let (msg, sugg) = if_chain! {
-        let (pat, pat_ref_count) = peel_hir_pat_refs(arms[0].pat);
         if let PatKind::Path(_) | PatKind::Lit(_) = pat.kind;
         let (ty, ty_ref_count) = peel_mid_ty_refs(cx.typeck_results().expr_ty(ex));
         if let Some(trait_id) = cx.tcx.lang_items().structural_peq_trait();
@@ -1480,8 +1480,8 @@ fn check_match_single_binding<'a>(cx: &LateContext<'a>, ex: &Expr<'a>, arms: &[A
 
 /// Returns true if the `ex` match expression is in a local (`let`) statement
 fn opt_parent_let<'a>(cx: &LateContext<'a>, ex: &Expr<'a>) -> Option<&'a Local<'a>> {
+    let map = &cx.tcx.hir();
     if_chain! {
-        let map = &cx.tcx.hir();
         if let Some(Node::Expr(parent_arm_expr)) = map.find(map.get_parent_node(ex.hir_id));
         if let Some(Node::Local(parent_let_expr)) = map.find(map.get_parent_node(parent_arm_expr.hir_id));
         then {
diff --git a/clippy_lints/src/mem_replace.rs b/clippy_lints/src/mem_replace.rs
index 426c108d89f..0418c616efa 100644
--- a/clippy_lints/src/mem_replace.rs
+++ b/clippy_lints/src/mem_replace.rs
@@ -225,34 +225,33 @@ fn is_default_equivalent_ctor(cx: &LateContext<'_>, def_id: DefId, path: &QPath<
 }
 
 fn check_replace_with_default(cx: &LateContext<'_>, src: &Expr<'_>, dest: &Expr<'_>, expr_span: Span) {
-    if let ExprKind::Call(ref repl_func, _) = src.kind {
-        if_chain! {
-            if !in_external_macro(cx.tcx.sess, expr_span);
-            if let ExprKind::Path(ref repl_func_qpath) = repl_func.kind;
-            if let Some(repl_def_id) = cx.qpath_res(repl_func_qpath, repl_func.hir_id).opt_def_id();
-            if is_diagnostic_assoc_item(cx, repl_def_id, sym::Default)
-                || is_default_equivalent_ctor(cx, repl_def_id, repl_func_qpath);
+    if_chain! {
+        if let ExprKind::Call(ref repl_func, _) = src.kind;
+        if !in_external_macro(cx.tcx.sess, expr_span);
+        if let ExprKind::Path(ref repl_func_qpath) = repl_func.kind;
+        if let Some(repl_def_id) = cx.qpath_res(repl_func_qpath, repl_func.hir_id).opt_def_id();
+        if is_diagnostic_assoc_item(cx, repl_def_id, sym::Default)
+            || is_default_equivalent_ctor(cx, repl_def_id, repl_func_qpath);
 
-            then {
-                span_lint_and_then(
-                    cx,
-                    MEM_REPLACE_WITH_DEFAULT,
-                    expr_span,
-                    "replacing a value of type `T` with `T::default()` is better expressed using `std::mem::take`",
-                    |diag| {
-                        if !in_macro(expr_span) {
-                            let suggestion = format!("std::mem::take({})", snippet(cx, dest.span, ""));
+        then {
+            span_lint_and_then(
+                cx,
+                MEM_REPLACE_WITH_DEFAULT,
+                expr_span,
+                "replacing a value of type `T` with `T::default()` is better expressed using `std::mem::take`",
+                |diag| {
+                    if !in_macro(expr_span) {
+                        let suggestion = format!("std::mem::take({})", snippet(cx, dest.span, ""));
 
-                            diag.span_suggestion(
-                                expr_span,
-                                "consider using",
-                                suggestion,
-                                Applicability::MachineApplicable
-                            );
-                        }
+                        diag.span_suggestion(
+                            expr_span,
+                            "consider using",
+                            suggestion,
+                            Applicability::MachineApplicable
+                        );
                     }
-                );
-            }
+                }
+            );
         }
     }
 }
diff --git a/clippy_lints/src/methods/bytes_nth.rs b/clippy_lints/src/methods/bytes_nth.rs
index 77f140510b6..2ad3e673c57 100644
--- a/clippy_lints/src/methods/bytes_nth.rs
+++ b/clippy_lints/src/methods/bytes_nth.rs
@@ -1,7 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::is_type_diagnostic_item;
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::Expr;
 use rustc_lint::LateContext;
@@ -10,31 +9,26 @@ use rustc_span::sym;
 use super::BYTES_NTH;
 
 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, recv: &'tcx Expr<'tcx>, n_arg: &'tcx Expr<'tcx>) {
-    if_chain! {
-        let ty = cx.typeck_results().expr_ty(recv).peel_refs();
-        let caller_type = if is_type_diagnostic_item(cx, ty, sym::string_type) {
-            Some("String")
-        } else if ty.is_str() {
-            Some("str")
-        } else {
-            None
-        };
-        if let Some(caller_type) = caller_type;
-        then {
-            let mut applicability = Applicability::MachineApplicable;
-            span_lint_and_sugg(
-                cx,
-                BYTES_NTH,
-                expr.span,
-                &format!("called `.byte().nth()` on a `{}`", caller_type),
-                "try",
-                format!(
-                    "{}.as_bytes().get({})",
-                    snippet_with_applicability(cx, recv.span, "..", &mut applicability),
-                    snippet_with_applicability(cx, n_arg.span, "..", &mut applicability)
-                ),
-                applicability,
-            );
-        }
-    }
+    let ty = cx.typeck_results().expr_ty(recv).peel_refs();
+    let caller_type = if ty.is_str() {
+        "str"
+    } else if is_type_diagnostic_item(cx, ty, sym::string_type) {
+        "String"
+    } else {
+        return;
+    };
+    let mut applicability = Applicability::MachineApplicable;
+    span_lint_and_sugg(
+        cx,
+        BYTES_NTH,
+        expr.span,
+        &format!("called `.byte().nth()` on a `{}`", caller_type),
+        "try",
+        format!(
+            "{}.as_bytes().get({})",
+            snippet_with_applicability(cx, recv.span, "..", &mut applicability),
+            snippet_with_applicability(cx, n_arg.span, "..", &mut applicability)
+        ),
+        applicability,
+    );
 }
diff --git a/clippy_lints/src/methods/from_iter_instead_of_collect.rs b/clippy_lints/src/methods/from_iter_instead_of_collect.rs
index 15cf5674313..707c54f7a3c 100644
--- a/clippy_lints/src/methods/from_iter_instead_of_collect.rs
+++ b/clippy_lints/src/methods/from_iter_instead_of_collect.rs
@@ -40,8 +40,8 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::Exp
 }
 
 fn extract_turbofish(cx: &LateContext<'_>, expr: &hir::Expr<'_>, ty: Ty<'tcx>) -> String {
+    let call_site = expr.span.source_callsite();
     if_chain! {
-        let call_site = expr.span.source_callsite();
         if let Ok(snippet) = cx.sess().source_map().span_to_snippet(call_site);
         let snippet_split = snippet.split("::").collect::<Vec<_>>();
         if let Some((_, elements)) = snippet_split.split_last();
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 9a95354db7a..70acf9f6e73 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1882,11 +1882,10 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
         if_chain! {
             if let TraitItemKind::Fn(ref sig, _) = item.kind;
             if let Some(first_arg_ty) = sig.decl.inputs.iter().next();
-            let first_arg_span = first_arg_ty.span;
-            let first_arg_ty = hir_ty_to_ty(cx.tcx, first_arg_ty);
-            let self_ty = TraitRef::identity(cx.tcx, item.def_id.to_def_id()).self_ty();
-
             then {
+                let first_arg_span = first_arg_ty.span;
+                let first_arg_ty = hir_ty_to_ty(cx.tcx, first_arg_ty);
+                let self_ty = TraitRef::identity(cx.tcx, item.def_id.to_def_id()).self_ty();
                 wrong_self_convention::check(
                     cx,
                     &item.ident.name.as_str(),
diff --git a/clippy_lints/src/methods/unnecessary_filter_map.rs b/clippy_lints/src/methods/unnecessary_filter_map.rs
index dac7e039e37..8e637e12393 100644
--- a/clippy_lints/src/methods/unnecessary_filter_map.rs
+++ b/clippy_lints/src/methods/unnecessary_filter_map.rs
@@ -1,7 +1,6 @@
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::usage::mutated_variables;
 use clippy_utils::{is_trait_method, match_qpath, path_to_local_id, paths};
-use if_chain::if_chain;
 use rustc_hir as hir;
 use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
 use rustc_lint::LateContext;
@@ -54,18 +53,15 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, arg: &hir::Expr<
 fn check_expression<'tcx>(cx: &LateContext<'tcx>, arg_id: hir::HirId, expr: &'tcx hir::Expr<'_>) -> (bool, bool) {
     match &expr.kind {
         hir::ExprKind::Call(ref func, ref args) => {
-            if_chain! {
-                if let hir::ExprKind::Path(ref path) = func.kind;
-                then {
-                    if match_qpath(path, &paths::OPTION_SOME) {
-                        if path_to_local_id(&args[0], arg_id) {
-                            return (false, false)
-                        }
-                        return (true, false);
+            if let hir::ExprKind::Path(ref path) = func.kind {
+                if match_qpath(path, &paths::OPTION_SOME) {
+                    if path_to_local_id(&args[0], arg_id) {
+                        return (false, false);
                     }
-                    // We don't know. It might do anything.
-                    return (true, true);
+                    return (true, false);
                 }
+                // We don't know. It might do anything.
+                return (true, true);
             }
             (true, true)
         },
diff --git a/clippy_lints/src/misc.rs b/clippy_lints/src/misc.rs
index 026ea50936a..c23643cb2f5 100644
--- a/clippy_lints/src/misc.rs
+++ b/clippy_lints/src/misc.rs
@@ -308,46 +308,45 @@ impl<'tcx> LateLintPass<'tcx> for MiscLints {
             if let PatKind::Binding(an, .., name, None) = local.pat.kind;
             if let Some(ref init) = local.init;
             if !higher::is_from_for_desugar(local);
+            if an == BindingAnnotation::Ref || an == BindingAnnotation::RefMut;
             then {
-                if an == BindingAnnotation::Ref || an == BindingAnnotation::RefMut {
-                    // use the macro callsite when the init span (but not the whole local span)
-                    // comes from an expansion like `vec![1, 2, 3]` in `let ref _ = vec![1, 2, 3];`
-                    let sugg_init = if init.span.from_expansion() && !local.span.from_expansion() {
-                        Sugg::hir_with_macro_callsite(cx, init, "..")
-                    } else {
-                        Sugg::hir(cx, init, "..")
-                    };
-                    let (mutopt, initref) = if an == BindingAnnotation::RefMut {
-                        ("mut ", sugg_init.mut_addr())
-                    } else {
-                        ("", sugg_init.addr())
-                    };
-                    let tyopt = if let Some(ref ty) = local.ty {
-                        format!(": &{mutopt}{ty}", mutopt=mutopt, ty=snippet(cx, ty.span, ".."))
-                    } else {
-                        String::new()
-                    };
-                    span_lint_hir_and_then(
-                        cx,
-                        TOPLEVEL_REF_ARG,
-                        init.hir_id,
-                        local.pat.span,
-                        "`ref` on an entire `let` pattern is discouraged, take a reference with `&` instead",
-                        |diag| {
-                            diag.span_suggestion(
-                                stmt.span,
-                                "try",
-                                format!(
-                                    "let {name}{tyopt} = {initref};",
-                                    name=snippet(cx, name.span, ".."),
-                                    tyopt=tyopt,
-                                    initref=initref,
-                                ),
-                                Applicability::MachineApplicable,
-                            );
-                        }
-                    );
-                }
+                // use the macro callsite when the init span (but not the whole local span)
+                // comes from an expansion like `vec![1, 2, 3]` in `let ref _ = vec![1, 2, 3];`
+                let sugg_init = if init.span.from_expansion() && !local.span.from_expansion() {
+                    Sugg::hir_with_macro_callsite(cx, init, "..")
+                } else {
+                    Sugg::hir(cx, init, "..")
+                };
+                let (mutopt, initref) = if an == BindingAnnotation::RefMut {
+                    ("mut ", sugg_init.mut_addr())
+                } else {
+                    ("", sugg_init.addr())
+                };
+                let tyopt = if let Some(ref ty) = local.ty {
+                    format!(": &{mutopt}{ty}", mutopt=mutopt, ty=snippet(cx, ty.span, ".."))
+                } else {
+                    String::new()
+                };
+                span_lint_hir_and_then(
+                    cx,
+                    TOPLEVEL_REF_ARG,
+                    init.hir_id,
+                    local.pat.span,
+                    "`ref` on an entire `let` pattern is discouraged, take a reference with `&` instead",
+                    |diag| {
+                        diag.span_suggestion(
+                            stmt.span,
+                            "try",
+                            format!(
+                                "let {name}{tyopt} = {initref};",
+                                name=snippet(cx, name.span, ".."),
+                                tyopt=tyopt,
+                                initref=initref,
+                            ),
+                            Applicability::MachineApplicable,
+                        );
+                    }
+                );
             }
         };
         if_chain! {
@@ -462,21 +461,18 @@ fn check_nan(cx: &LateContext<'_>, expr: &Expr<'_>, cmp_expr: &Expr<'_>) {
     if_chain! {
         if !in_constant(cx, cmp_expr.hir_id);
         if let Some((value, _)) = constant(cx, cx.typeck_results(), expr);
+        if match value {
+            Constant::F32(num) => num.is_nan(),
+            Constant::F64(num) => num.is_nan(),
+            _ => false,
+        };
         then {
-            let needs_lint = match value {
-                Constant::F32(num) => num.is_nan(),
-                Constant::F64(num) => num.is_nan(),
-                _ => false,
-            };
-
-            if needs_lint {
-                span_lint(
-                    cx,
-                    CMP_NAN,
-                    cmp_expr.span,
-                    "doomed comparison with `NAN`, use `{f32,f64}::is_nan()` instead",
-                );
-            }
+            span_lint(
+                cx,
+                CMP_NAN,
+                cmp_expr.span,
+                "doomed comparison with `NAN`, use `{f32,f64}::is_nan()` instead",
+            );
         }
     }
 }
diff --git a/clippy_lints/src/new_without_default.rs b/clippy_lints/src/new_without_default.rs
index 3789572ad43..a5f91eb035f 100644
--- a/clippy_lints/src/new_without_default.rs
+++ b/clippy_lints/src/new_without_default.rs
@@ -97,60 +97,60 @@ impl<'tcx> LateLintPass<'tcx> for NewWithoutDefault {
                             // impl of `Default`
                             return;
                         }
-                        if sig.decl.inputs.is_empty() && name == sym::new && cx.access_levels.is_reachable(id) {
+                        if_chain! {
+                            if sig.decl.inputs.is_empty();
+                            if name == sym::new;
+                            if cx.access_levels.is_reachable(id);
                             let self_def_id = cx.tcx.hir().local_def_id(cx.tcx.hir().get_parent_item(id));
                             let self_ty = cx.tcx.type_of(self_def_id);
-                            if_chain! {
-                                if TyS::same_type(self_ty, return_ty(cx, id));
-                                if let Some(default_trait_id) = get_trait_def_id(cx, &paths::DEFAULT_TRAIT);
-                                then {
-                                    if self.impling_types.is_none() {
-                                        let mut impls = HirIdSet::default();
-                                        cx.tcx.for_each_impl(default_trait_id, |d| {
-                                            if let Some(ty_def) = cx.tcx.type_of(d).ty_adt_def() {
-                                                if let Some(local_def_id) = ty_def.did.as_local() {
-                                                    impls.insert(cx.tcx.hir().local_def_id_to_hir_id(local_def_id));
-                                                }
-                                            }
-                                        });
-                                        self.impling_types = Some(impls);
-                                    }
-
-                                    // Check if a Default implementation exists for the Self type, regardless of
-                                    // generics
-                                    if_chain! {
-                                        if let Some(ref impling_types) = self.impling_types;
-                                        if let Some(self_def) = cx.tcx.type_of(self_def_id).ty_adt_def();
-                                        if let Some(self_local_did) = self_def.did.as_local();
-                                        then {
-                                            let self_id = cx.tcx.hir().local_def_id_to_hir_id(self_local_did);
-                                            if impling_types.contains(&self_id) {
-                                                return;
+                            if TyS::same_type(self_ty, return_ty(cx, id));
+                            if let Some(default_trait_id) = get_trait_def_id(cx, &paths::DEFAULT_TRAIT);
+                            then {
+                                if self.impling_types.is_none() {
+                                    let mut impls = HirIdSet::default();
+                                    cx.tcx.for_each_impl(default_trait_id, |d| {
+                                        if let Some(ty_def) = cx.tcx.type_of(d).ty_adt_def() {
+                                            if let Some(local_def_id) = ty_def.did.as_local() {
+                                                impls.insert(cx.tcx.hir().local_def_id_to_hir_id(local_def_id));
                                             }
                                         }
-                                    }
+                                    });
+                                    self.impling_types = Some(impls);
+                                }
 
-                                    let generics_sugg = snippet(cx, generics.span, "");
-                                    span_lint_hir_and_then(
-                                        cx,
-                                        NEW_WITHOUT_DEFAULT,
-                                        id,
-                                        impl_item.span,
-                                        &format!(
-                                            "you should consider adding a `Default` implementation for `{}`",
-                                            self_ty
-                                        ),
-                                        |diag| {
-                                            diag.suggest_prepend_item(
-                                                cx,
-                                                item.span,
-                                                "try this",
-                                                &create_new_without_default_suggest_msg(self_ty, &generics_sugg),
-                                                Applicability::MaybeIncorrect,
-                                            );
-                                        },
-                                    );
+                                // Check if a Default implementation exists for the Self type, regardless of
+                                // generics
+                                if_chain! {
+                                    if let Some(ref impling_types) = self.impling_types;
+                                    if let Some(self_def) = cx.tcx.type_of(self_def_id).ty_adt_def();
+                                    if let Some(self_local_did) = self_def.did.as_local();
+                                    let self_id = cx.tcx.hir().local_def_id_to_hir_id(self_local_did);
+                                    if impling_types.contains(&self_id);
+                                    then {
+                                        return;
+                                    }
                                 }
+
+                                let generics_sugg = snippet(cx, generics.span, "");
+                                span_lint_hir_and_then(
+                                    cx,
+                                    NEW_WITHOUT_DEFAULT,
+                                    id,
+                                    impl_item.span,
+                                    &format!(
+                                        "you should consider adding a `Default` implementation for `{}`",
+                                        self_ty
+                                    ),
+                                    |diag| {
+                                        diag.suggest_prepend_item(
+                                            cx,
+                                            item.span,
+                                            "try this",
+                                            &create_new_without_default_suggest_msg(self_ty, &generics_sugg),
+                                            Applicability::MaybeIncorrect,
+                                        );
+                                    },
+                                );
                             }
                         }
                     }
diff --git a/clippy_lints/src/non_copy_const.rs b/clippy_lints/src/non_copy_const.rs
index aa1d8fbe300..d775cd7c7f7 100644
--- a/clippy_lints/src/non_copy_const.rs
+++ b/clippy_lints/src/non_copy_const.rs
@@ -307,19 +307,17 @@ impl<'tcx> LateLintPass<'tcx> for NonCopyConst {
                             // we should use here as a frozen variant is a potential to be frozen
                             // similar to unknown layouts.
                             // e.g. `layout_of(...).is_err() || has_frozen_variant(...);`
+                        let ty = hir_ty_to_ty(cx.tcx, hir_ty);
+                        let normalized = cx.tcx.normalize_erasing_regions(cx.param_env, ty);
+                        if is_unfrozen(cx, normalized);
+                        if is_value_unfrozen_poly(cx, *body_id, normalized);
                         then {
-                            let ty = hir_ty_to_ty(cx.tcx, hir_ty);
-                            let normalized = cx.tcx.normalize_erasing_regions(cx.param_env, ty);
-                            if is_unfrozen(cx, normalized)
-                                && is_value_unfrozen_poly(cx, *body_id, normalized)
-                            {
-                                lint(
-                                   cx,
-                                   Source::Assoc {
-                                       item: impl_item.span,
-                                    },
-                                );
-                            }
+                            lint(
+                               cx,
+                               Source::Assoc {
+                                   item: impl_item.span,
+                                },
+                            );
                         }
                     }
                 },
diff --git a/clippy_lints/src/panic_unimplemented.rs b/clippy_lints/src/panic_unimplemented.rs
index d06e7f8fe1e..1e946858947 100644
--- a/clippy_lints/src/panic_unimplemented.rs
+++ b/clippy_lints/src/panic_unimplemented.rs
@@ -97,11 +97,10 @@ impl<'tcx> LateLintPass<'tcx> for PanicUnimplemented {
 fn get_outer_span(expr: &Expr<'_>) -> Span {
     if_chain! {
         if expr.span.from_expansion();
-        let first = expr.span.ctxt().outer_expn_data();
-        if first.call_site.from_expansion();
-        let second = first.call_site.ctxt().outer_expn_data();
+        let first = expr.span.ctxt().outer_expn_data().call_site;
+        if first.from_expansion();
         then {
-            second.call_site
+            first.ctxt().outer_expn_data().call_site
         } else {
             expr.span
         }
diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs
index be686b1b0cd..6e530d0ffb0 100644
--- a/clippy_lints/src/ptr.rs
+++ b/clippy_lints/src/ptr.rs
@@ -271,19 +271,18 @@ fn check_fn(cx: &LateContext<'_>, decl: &FnDecl<'_>, fn_id: HirId, opt_body_id:
                         GenericArg::Type(ty) => Some(ty),
                         _ => None,
                     });
+                    let replacement = snippet_opt(cx, inner.span);
+                    if let Some(r) = replacement;
                     then {
-                        let replacement = snippet_opt(cx, inner.span);
-                        if let Some(r) = replacement {
-                            span_lint_and_sugg(
-                                cx,
-                                PTR_ARG,
-                                arg.span,
-                                "using a reference to `Cow` is not recommended",
-                                "change this to",
-                                "&".to_owned() + &r,
-                                Applicability::Unspecified,
-                            );
-                        }
+                        span_lint_and_sugg(
+                            cx,
+                            PTR_ARG,
+                            arg.span,
+                            "using a reference to `Cow` is not recommended",
+                            "change this to",
+                            "&".to_owned() + &r,
+                            Applicability::Unspecified,
+                        );
                     }
                 }
             }
diff --git a/clippy_lints/src/ranges.rs b/clippy_lints/src/ranges.rs
index 95b21489eb5..79692abb6ac 100644
--- a/clippy_lints/src/ranges.rs
+++ b/clippy_lints/src/ranges.rs
@@ -320,32 +320,29 @@ fn match_ident(e: &Expr<'_>) -> Option<Ident> {
 }
 
 fn check_range_zip_with_len(cx: &LateContext<'_>, path: &PathSegment<'_>, args: &[Expr<'_>], span: Span) {
-    let name = path.ident.as_str();
-    if name == "zip" && args.len() == 2 {
-        let iter = &args[0].kind;
-        let zip_arg = &args[1];
-        if_chain! {
-            // `.iter()` call
-            if let ExprKind::MethodCall(ref iter_path, _, ref iter_args, _) = *iter;
-            if iter_path.ident.name == sym::iter;
-            // range expression in `.zip()` call: `0..x.len()`
-            if let Some(higher::Range { start: Some(start), end: Some(end), .. }) = higher::range(zip_arg);
-            if is_integer_const(cx, start, 0);
-            // `.len()` call
-            if let ExprKind::MethodCall(ref len_path, _, ref len_args, _) = end.kind;
-            if len_path.ident.name == sym!(len) && len_args.len() == 1;
-            // `.iter()` and `.len()` called on same `Path`
-            if let ExprKind::Path(QPath::Resolved(_, ref iter_path)) = iter_args[0].kind;
-            if let ExprKind::Path(QPath::Resolved(_, ref len_path)) = len_args[0].kind;
-            if SpanlessEq::new(cx).eq_path_segments(&iter_path.segments, &len_path.segments);
-            then {
-                span_lint(cx,
-                    RANGE_ZIP_WITH_LEN,
-                    span,
-                    &format!("it is more idiomatic to use `{}.iter().enumerate()`",
-                        snippet(cx, iter_args[0].span, "_"))
-                );
-            }
+    if_chain! {
+        if path.ident.as_str() == "zip";
+        if let [iter, zip_arg] = args;
+        // `.iter()` call
+        if let ExprKind::MethodCall(ref iter_path, _, ref iter_args, _) = iter.kind;
+        if iter_path.ident.name == sym::iter;
+        // range expression in `.zip()` call: `0..x.len()`
+        if let Some(higher::Range { start: Some(start), end: Some(end), .. }) = higher::range(zip_arg);
+        if is_integer_const(cx, start, 0);
+        // `.len()` call
+        if let ExprKind::MethodCall(ref len_path, _, ref len_args, _) = end.kind;
+        if len_path.ident.name == sym!(len) && len_args.len() == 1;
+        // `.iter()` and `.len()` called on same `Path`
+        if let ExprKind::Path(QPath::Resolved(_, ref iter_path)) = iter_args[0].kind;
+        if let ExprKind::Path(QPath::Resolved(_, ref len_path)) = len_args[0].kind;
+        if SpanlessEq::new(cx).eq_path_segments(&iter_path.segments, &len_path.segments);
+        then {
+            span_lint(cx,
+                RANGE_ZIP_WITH_LEN,
+                span,
+                &format!("it is more idiomatic to use `{}.iter().enumerate()`",
+                    snippet(cx, iter_args[0].span, "_"))
+            );
         }
     }
 }
diff --git a/clippy_lints/src/redundant_closure_call.rs b/clippy_lints/src/redundant_closure_call.rs
index 2977a108d14..5429d389610 100644
--- a/clippy_lints/src/redundant_closure_call.rs
+++ b/clippy_lints/src/redundant_closure_call.rs
@@ -113,8 +113,8 @@ impl<'tcx> LateLintPass<'tcx> for RedundantClosureCall {
                     if_chain! {
                         if let hir::ExprKind::Call(ref closure, _) = expr.kind;
                         if let hir::ExprKind::Path(hir::QPath::Resolved(_, ref path)) = closure.kind;
-                        if self.path.segments[0].ident == path.segments[0].ident
-                            && self.path.res == path.res;
+                        if self.path.segments[0].ident == path.segments[0].ident;
+                        if self.path.res == path.res;
                         then {
                             self.count += 1;
                         }
diff --git a/clippy_lints/src/suspicious_trait_impl.rs b/clippy_lints/src/suspicious_trait_impl.rs
index 99e3d818b79..512abde11a6 100644
--- a/clippy_lints/src/suspicious_trait_impl.rs
+++ b/clippy_lints/src/suspicious_trait_impl.rs
@@ -68,14 +68,13 @@ impl<'tcx> LateLintPass<'tcx> for SuspiciousImpl {
 
             // Check for more than one binary operation in the implemented function
             // Linting when multiple operations are involved can result in false positives
+            let parent_fn = cx.tcx.hir().get_parent_item(expr.hir_id);
             if_chain! {
-                let parent_fn = cx.tcx.hir().get_parent_item(expr.hir_id);
                 if let hir::Node::ImplItem(impl_item) = cx.tcx.hir().get(parent_fn);
                 if let hir::ImplItemKind::Fn(_, body_id) = impl_item.kind;
-                let body = cx.tcx.hir().body(body_id);
-                let mut visitor = BinaryExprVisitor { nb_binops: 0 };
-
                 then {
+                    let body = cx.tcx.hir().body(body_id);
+                    let mut visitor = BinaryExprVisitor { nb_binops: 0 };
                     walk_expr(&mut visitor, &body.value);
                     if visitor.nb_binops > 1 {
                         return;
diff --git a/clippy_lints/src/transmute/transmute_float_to_int.rs b/clippy_lints/src/transmute/transmute_float_to_int.rs
index 72489f27cd3..1a6124e9ddb 100644
--- a/clippy_lints/src/transmute/transmute_float_to_int.rs
+++ b/clippy_lints/src/transmute/transmute_float_to_int.rs
@@ -36,10 +36,10 @@ pub(super) fn check<'tcx>(
                     if_chain! {
                         // if the expression is a float literal and it is unsuffixed then
                         // add a suffix so the suggestion is valid and unambiguous
-                        let op = format!("{}{}", arg, float_ty.name_str()).into();
                         if let ExprKind::Lit(lit) = &expr.kind;
                         if let ast::LitKind::Float(_, ast::LitFloatType::Unsuffixed) = lit.node;
                         then {
+                            let op = format!("{}{}", arg, float_ty.name_str()).into();
                             match arg {
                                 sugg::Sugg::MaybeParen(_) => arg = sugg::Sugg::MaybeParen(op),
                                 _ => arg = sugg::Sugg::NonParen(op)
diff --git a/clippy_lints/src/try_err.rs b/clippy_lints/src/try_err.rs
index e61058c2749..e4799790d35 100644
--- a/clippy_lints/src/try_err.rs
+++ b/clippy_lints/src/try_err.rs
@@ -138,9 +138,8 @@ fn result_error_type<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Option<Ty<'t
     if_chain! {
         if let ty::Adt(_, subst) = ty.kind();
         if is_type_diagnostic_item(cx, ty, sym::result_type);
-        let err_ty = subst.type_at(1);
         then {
-            Some(err_ty)
+            Some(subst.type_at(1))
         } else {
             None
         }
@@ -156,10 +155,8 @@ fn poll_result_error_type<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Option<
 
         if let ty::Adt(ready_def, ready_subst) = ready_ty.kind();
         if cx.tcx.is_diagnostic_item(sym::result_type, ready_def.did);
-        let err_ty = ready_subst.type_at(1);
-
         then {
-            Some(err_ty)
+            Some(ready_subst.type_at(1))
         } else {
             None
         }
@@ -179,10 +176,8 @@ fn poll_option_result_error_type<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) ->
 
         if let ty::Adt(some_def, some_subst) = some_ty.kind();
         if cx.tcx.is_diagnostic_item(sym::result_type, some_def.did);
-        let err_ty = some_subst.type_at(1);
-
         then {
-            Some(err_ty)
+            Some(some_subst.type_at(1))
         } else {
             None
         }
diff --git a/clippy_lints/src/unit_return_expecting_ord.rs b/clippy_lints/src/unit_return_expecting_ord.rs
index bad3e488bb6..cdc65abe47c 100644
--- a/clippy_lints/src/unit_return_expecting_ord.rs
+++ b/clippy_lints/src/unit_return_expecting_ord.rs
@@ -116,8 +116,8 @@ fn check_arg<'tcx>(cx: &LateContext<'tcx>, arg: &'tcx Expr<'tcx>) -> Option<(Spa
         let ty = cx.tcx.erase_late_bound_regions(ret_ty);
         if ty.is_unit();
         then {
+            let body = cx.tcx.hir().body(body_id);
             if_chain! {
-                let body = cx.tcx.hir().body(body_id);
                 if let ExprKind::Block(block, _) = body.value.kind;
                 if block.expr.is_none();
                 if let Some(stmt) = block.stmts.last();
diff --git a/clippy_lints/src/unit_types/unit_arg.rs b/clippy_lints/src/unit_types/unit_arg.rs
index 925ab577099..f77d811c283 100644
--- a/clippy_lints/src/unit_types/unit_arg.rs
+++ b/clippy_lints/src/unit_types/unit_arg.rs
@@ -19,9 +19,9 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>) {
     if is_questionmark_desugar_marked_call(expr) {
         return;
     }
+    let map = &cx.tcx.hir();
+    let opt_parent_node = map.find(map.get_parent_node(expr.hir_id));
     if_chain! {
-        let map = &cx.tcx.hir();
-        let opt_parent_node = map.find(map.get_parent_node(expr.hir_id));
         if let Some(hir::Node::Expr(parent_expr)) = opt_parent_node;
         if is_questionmark_desugar_marked_call(parent_expr);
         then {
diff --git a/clippy_lints/src/unnamed_address.rs b/clippy_lints/src/unnamed_address.rs
index d5bc3de6698..9ceb2c3ffe2 100644
--- a/clippy_lints/src/unnamed_address.rs
+++ b/clippy_lints/src/unnamed_address.rs
@@ -116,8 +116,8 @@ impl LateLintPass<'_> for UnnamedAddress {
         if_chain! {
             if let ExprKind::Binary(binop, ref left, ref right) = expr.kind;
             if is_comparison(binop.node);
-            if cx.typeck_results().expr_ty_adjusted(left).is_fn_ptr() &&
-                cx.typeck_results().expr_ty_adjusted(right).is_fn_ptr();
+            if cx.typeck_results().expr_ty_adjusted(left).is_fn_ptr();
+            if cx.typeck_results().expr_ty_adjusted(right).is_fn_ptr();
             if is_fn_def(cx, left) || is_fn_def(cx, right);
             then {
                 span_lint(
diff --git a/clippy_lints/src/unused_self.rs b/clippy_lints/src/unused_self.rs
index aef4ce75915..15343cf90f2 100644
--- a/clippy_lints/src/unused_self.rs
+++ b/clippy_lints/src/unused_self.rs
@@ -49,21 +49,18 @@ impl<'tcx> LateLintPass<'tcx> for UnusedSelf {
             if assoc_item.fn_has_self_parameter;
             if let ImplItemKind::Fn(.., body_id) = &impl_item.kind;
             let body = cx.tcx.hir().body(*body_id);
-            if !body.params.is_empty();
+            if let [self_param, ..] = body.params;
+            let self_hir_id = self_param.pat.hir_id;
+            if !LocalUsedVisitor::new(cx, self_hir_id).check_body(body);
             then {
-                let self_param = &body.params[0];
-                let self_hir_id = self_param.pat.hir_id;
-                if !LocalUsedVisitor::new(cx, self_hir_id).check_body(body) {
-                    span_lint_and_help(
-                        cx,
-                        UNUSED_SELF,
-                        self_param.span,
-                        "unused `self` argument",
-                        None,
-                        "consider refactoring to a associated function",
-                    );
-                    return;
-                }
+                span_lint_and_help(
+                    cx,
+                    UNUSED_SELF,
+                    self_param.span,
+                    "unused `self` argument",
+                    None,
+                    "consider refactoring to a associated function",
+                );
             }
         }
     }
diff --git a/clippy_lints/src/unwrap_in_result.rs b/clippy_lints/src/unwrap_in_result.rs
index 0d745813beb..d17aa6d8424 100644
--- a/clippy_lints/src/unwrap_in_result.rs
+++ b/clippy_lints/src/unwrap_in_result.rs
@@ -110,31 +110,27 @@ impl<'a, 'tcx> Visitor<'tcx> for FindExpectUnwrap<'a, 'tcx> {
 }
 
 fn lint_impl_body<'tcx>(cx: &LateContext<'tcx>, impl_span: Span, impl_item: &'tcx hir::ImplItem<'_>) {
-    if_chain! {
+    if let ImplItemKind::Fn(_, body_id) = impl_item.kind {
+        let body = cx.tcx.hir().body(body_id);
+        let mut fpu = FindExpectUnwrap {
+            lcx: cx,
+            typeck_results: cx.tcx.typeck(impl_item.def_id),
+            result: Vec::new(),
+        };
+        fpu.visit_expr(&body.value);
 
-        if let ImplItemKind::Fn(_, body_id) = impl_item.kind;
-        then {
-            let body = cx.tcx.hir().body(body_id);
-            let mut fpu = FindExpectUnwrap {
-                lcx: cx,
-                typeck_results: cx.tcx.typeck(impl_item.def_id),
-                result: Vec::new(),
-            };
-            fpu.visit_expr(&body.value);
-
-            // if we've found one, lint
-            if  !fpu.result.is_empty()  {
-                span_lint_and_then(
-                    cx,
-                    UNWRAP_IN_RESULT,
-                    impl_span,
-                    "used unwrap or expect in a function that returns result or option",
-                    move |diag| {
-                        diag.help(
-                            "unwrap and expect should not be used in a function that returns result or option" );
-                        diag.span_note(fpu.result, "potential non-recoverable error(s)");
-                    });
-            }
+        // if we've found one, lint
+        if !fpu.result.is_empty() {
+            span_lint_and_then(
+                cx,
+                UNWRAP_IN_RESULT,
+                impl_span,
+                "used unwrap or expect in a function that returns result or option",
+                move |diag| {
+                    diag.help("unwrap and expect should not be used in a function that returns result or option");
+                    diag.span_note(fpu.result, "potential non-recoverable error(s)");
+                },
+            );
         }
     }
 }
diff --git a/clippy_lints/src/useless_conversion.rs b/clippy_lints/src/useless_conversion.rs
index 3e1b69e676b..d893b271a20 100644
--- a/clippy_lints/src/useless_conversion.rs
+++ b/clippy_lints/src/useless_conversion.rs
@@ -103,25 +103,23 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
                         );
                     }
                 }
-                if match_trait_method(cx, e, &paths::TRY_INTO_TRAIT) && &*name.ident.as_str() == "try_into" {
-                    if_chain! {
-                        let a = cx.typeck_results().expr_ty(e);
-                        let b = cx.typeck_results().expr_ty(&args[0]);
-                        if is_type_diagnostic_item(cx, a, sym::result_type);
-                        if let ty::Adt(_, substs) = a.kind();
-                        if let Some(a_type) = substs.types().next();
-                        if TyS::same_type(a_type, b);
-
-                        then {
-                            span_lint_and_help(
-                                cx,
-                                USELESS_CONVERSION,
-                                e.span,
-                                &format!("useless conversion to the same type: `{}`", b),
-                                None,
-                                "consider removing `.try_into()`",
-                            );
-                        }
+                if_chain! {
+                    if match_trait_method(cx, e, &paths::TRY_INTO_TRAIT) && &*name.ident.as_str() == "try_into";
+                    let a = cx.typeck_results().expr_ty(e);
+                    let b = cx.typeck_results().expr_ty(&args[0]);
+                    if is_type_diagnostic_item(cx, a, sym::result_type);
+                    if let ty::Adt(_, substs) = a.kind();
+                    if let Some(a_type) = substs.types().next();
+                    if TyS::same_type(a_type, b);
+                    then {
+                        span_lint_and_help(
+                            cx,
+                            USELESS_CONVERSION,
+                            e.span,
+                            &format!("useless conversion to the same type: `{}`", b),
+                            None,
+                            "consider removing `.try_into()`",
+                        );
                     }
                 }
             },
@@ -131,10 +129,9 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
                     if args.len() == 1;
                     if let ExprKind::Path(ref qpath) = path.kind;
                     if let Some(def_id) = cx.qpath_res(qpath, path.hir_id).opt_def_id();
-                    let a = cx.typeck_results().expr_ty(e);
-                    let b = cx.typeck_results().expr_ty(&args[0]);
-
                     then {
+                        let a = cx.typeck_results().expr_ty(e);
+                        let b = cx.typeck_results().expr_ty(&args[0]);
                         if_chain! {
                             if match_def_path(cx, def_id, &paths::TRY_FROM);
                             if is_type_diagnostic_item(cx, a, sym::result_type);
diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs
index 266b88beeec..d5a13c135b1 100644
--- a/clippy_lints/src/utils/internal_lints.rs
+++ b/clippy_lints/src/utils/internal_lints.rs
@@ -588,9 +588,9 @@ impl<'tcx> LateLintPass<'tcx> for CollapsibleCalls {
             if stmts.len() == 1 && block.expr.is_none();
             if let StmtKind::Semi(only_expr) = &stmts[0].kind;
             if let ExprKind::MethodCall(ref ps, _, ref span_call_args, _) = &only_expr.kind;
-            let and_then_snippets = get_and_then_snippets(cx, and_then_args);
-            let mut sle = SpanlessEq::new(cx).deny_side_effects();
             then {
+                let and_then_snippets = get_and_then_snippets(cx, and_then_args);
+                let mut sle = SpanlessEq::new(cx).deny_side_effects();
                 match &*ps.ident.as_str() {
                     "span_suggestion" if sle.eq_expr(&and_then_args[2], &span_call_args[1]) => {
                         suggest_suggestion(cx, expr, &and_then_snippets, &span_suggestion_snippets(cx, span_call_args));
diff --git a/clippy_lints/src/vec_init_then_push.rs b/clippy_lints/src/vec_init_then_push.rs
index 8b696ed1c84..c7190e2f979 100644
--- a/clippy_lints/src/vec_init_then_push.rs
+++ b/clippy_lints/src/vec_init_then_push.rs
@@ -108,22 +108,21 @@ impl LateLintPass<'_> for VecInitThenPush {
     }
 
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if self.searcher.is_none() {
-            if_chain! {
-                if !in_external_macro(cx.sess(), expr.span);
-                if let ExprKind::Assign(left, right, _) = expr.kind;
-                if let Some(id) = path_to_local(left);
-                if let Some(init_kind) = get_vec_init_kind(cx, right);
-                then {
-                    self.searcher = Some(VecPushSearcher {
-                        local_id: id,
-                        init: init_kind,
-                        lhs_is_local: false,
-                        lhs_span: left.span,
-                        err_span: expr.span,
-                        found: 0,
-                    });
-                }
+        if_chain! {
+            if self.searcher.is_none();
+            if !in_external_macro(cx.sess(), expr.span);
+            if let ExprKind::Assign(left, right, _) = expr.kind;
+            if let Some(id) = path_to_local(left);
+            if let Some(init_kind) = get_vec_init_kind(cx, right);
+            then {
+                self.searcher = Some(VecPushSearcher {
+                    local_id: id,
+                    init: init_kind,
+                    lhs_is_local: false,
+                    lhs_span: left.span,
+                    err_span: expr.span,
+                    found: 0,
+                });
             }
         }
     }
-- 
cgit 1.4.1-3-g733a5


From aaba9b78a210bc20dfdb1aff24d93acc22677a47 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Wed, 31 Mar 2021 14:58:17 -0400
Subject: Fix `redundant_clone` fp where the cloned value is modified while the
 clone is in use.

---
 clippy_lints/src/redundant_clone.rs | 252 +++++++++++++++++++++---------------
 tests/ui/redundant_clone.fixed      |  24 ++++
 tests/ui/redundant_clone.rs         |  24 ++++
 tests/ui/redundant_clone.stderr     |  20 +--
 4 files changed, 207 insertions(+), 113 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/redundant_clone.rs b/clippy_lints/src/redundant_clone.rs
index 37678fac1d2..9656ee64c81 100644
--- a/clippy_lints/src/redundant_clone.rs
+++ b/clippy_lints/src/redundant_clone.rs
@@ -199,79 +199,72 @@ impl<'tcx> LateLintPass<'tcx> for RedundantClone {
                 (local, deref_clone_ret)
             };
 
-            let is_temp = mir.local_kind(ret_local) == mir::LocalKind::Temp;
-
-            // 1. `local` can be moved out if it is not used later.
-            // 2. If `ret_local` is a temporary and is neither consumed nor mutated, we can remove this `clone`
-            // call anyway.
-            let (used, consumed_or_mutated) = traversal::ReversePostorder::new(&mir, bb).skip(1).fold(
-                (false, !is_temp),
-                |(used, consumed), (tbb, tdata)| {
-                    // Short-circuit
-                    if (used && consumed) ||
-                        // Give up on loops
-                        tdata.terminator().successors().any(|s| *s == bb)
-                    {
-                        return (true, true);
+            let clone_usage = if local == ret_local {
+                CloneUsage {
+                    cloned_used: false,
+                    cloned_consume_or_mutate_loc: None,
+                    clone_consumed_or_mutated: true,
+                }
+            } else {
+                let clone_usage = visit_clone_usage(local, ret_local, &mir, bb);
+                if clone_usage.cloned_used && clone_usage.clone_consumed_or_mutated {
+                    // cloned value is used, and the clone is modified or moved
+                    continue;
+                } else if let Some(loc) = clone_usage.cloned_consume_or_mutate_loc {
+                    // cloned value is mutated, and the clone is alive.
+                    if possible_borrower.is_alive_at(ret_local, loc) {
+                        continue;
                     }
+                }
+                clone_usage
+            };
 
-                    let mut vis = LocalUseVisitor {
-                        used: (local, false),
-                        consumed_or_mutated: (ret_local, false),
-                    };
-                    vis.visit_basic_block_data(tbb, tdata);
-                    (used || vis.used.1, consumed || vis.consumed_or_mutated.1)
-                },
-            );
-
-            if !used || !consumed_or_mutated {
-                let span = terminator.source_info.span;
-                let scope = terminator.source_info.scope;
-                let node = mir.source_scopes[scope]
-                    .local_data
-                    .as_ref()
-                    .assert_crate_local()
-                    .lint_root;
-
-                if_chain! {
-                    if let Some(snip) = snippet_opt(cx, span);
-                    if let Some(dot) = snip.rfind('.');
-                    then {
-                        let sugg_span = span.with_lo(
-                            span.lo() + BytePos(u32::try_from(dot).unwrap())
-                        );
-                        let mut app = Applicability::MaybeIncorrect;
-
-                        let call_snip = &snip[dot + 1..];
-                        // Machine applicable when `call_snip` looks like `foobar()`
-                        if let Some(call_snip) = call_snip.strip_suffix("()").map(str::trim) {
-                            if call_snip.as_bytes().iter().all(|b| b.is_ascii_alphabetic() || *b == b'_') {
-                                app = Applicability::MachineApplicable;
-                            }
+            let span = terminator.source_info.span;
+            let scope = terminator.source_info.scope;
+            let node = mir.source_scopes[scope]
+                .local_data
+                .as_ref()
+                .assert_crate_local()
+                .lint_root;
+
+            if_chain! {
+                if let Some(snip) = snippet_opt(cx, span);
+                if let Some(dot) = snip.rfind('.');
+                then {
+                    let sugg_span = span.with_lo(
+                        span.lo() + BytePos(u32::try_from(dot).unwrap())
+                    );
+                    let mut app = Applicability::MaybeIncorrect;
+
+                    let call_snip = &snip[dot + 1..];
+                    // Machine applicable when `call_snip` looks like `foobar()`
+                    if let Some(call_snip) = call_snip.strip_suffix("()").map(str::trim) {
+                        if call_snip.as_bytes().iter().all(|b| b.is_ascii_alphabetic() || *b == b'_') {
+                            app = Applicability::MachineApplicable;
                         }
+                    }
 
-                        span_lint_hir_and_then(cx, REDUNDANT_CLONE, node, sugg_span, "redundant clone", |diag| {
-                            diag.span_suggestion(
-                                sugg_span,
-                                "remove this",
-                                String::new(),
-                                app,
+                    span_lint_hir_and_then(cx, REDUNDANT_CLONE, node, sugg_span, "redundant clone", |diag| {
+                        diag.span_suggestion(
+                            sugg_span,
+                            "remove this",
+                            String::new(),
+                            app,
+                        );
+                        if clone_usage.cloned_used {
+                            diag.span_note(
+                                span,
+                                "cloned value is neither consumed nor mutated",
                             );
-                            if used {
-                                diag.span_note(
-                                    span,
-                                    "cloned value is neither consumed nor mutated",
-                                );
-                            } else {
-                                diag.span_note(
-                                    span.with_hi(span.lo() + BytePos(u32::try_from(dot).unwrap())),
-                                    "this value is dropped without further use",
-                                );
-                            }
-                        });
-                    } else {
-                        span_lint_hir(cx, REDUNDANT_CLONE, node, span, "redundant clone");
-                    }
+                        } else {
+                            diag.span_note(
+                                span.with_hi(span.lo() + BytePos(u32::try_from(dot).unwrap())),
+                                "this value is dropped without further use",
+                            );
+                        }
+                    });
+                } else {
+                    span_lint_hir(cx, REDUNDANT_CLONE, node, span, "redundant clone");
                 }
             }
         }
@@ -365,49 +358,97 @@ fn base_local_and_movability<'tcx>(
     (local, deref || field || slice)
 }
 
-struct LocalUseVisitor {
-    used: (mir::Local, bool),
-    consumed_or_mutated: (mir::Local, bool),
+#[derive(Default)]
+struct CloneUsage {
+    /// Whether the cloned value is used after the clone.
+    cloned_used: bool,
+    /// The first location where the cloned value is consumed or mutated, if any.
+    cloned_consume_or_mutate_loc: Option<mir::Location>,
+    /// Whether the clone value is mutated.
+    clone_consumed_or_mutated: bool,
 }
-
-impl<'tcx> mir::visit::Visitor<'tcx> for LocalUseVisitor {
-    fn visit_basic_block_data(&mut self, block: mir::BasicBlock, data: &mir::BasicBlockData<'tcx>) {
-        let statements = &data.statements;
-        for (statement_index, statement) in statements.iter().enumerate() {
-            self.visit_statement(statement, mir::Location { block, statement_index });
-        }
-
-        self.visit_terminator(
-            data.terminator(),
-            mir::Location {
-                block,
-                statement_index: statements.len(),
-            },
-        );
+fn visit_clone_usage(cloned: mir::Local, clone: mir::Local, mir: &mir::Body<'_>, bb: mir::BasicBlock) -> CloneUsage {
+    struct V {
+        cloned: mir::Local,
+        clone: mir::Local,
+        result: CloneUsage,
     }
+    impl<'tcx> mir::visit::Visitor<'tcx> for V {
+        fn visit_basic_block_data(&mut self, block: mir::BasicBlock, data: &mir::BasicBlockData<'tcx>) {
+            let statements = &data.statements;
+            for (statement_index, statement) in statements.iter().enumerate() {
+                self.visit_statement(statement, mir::Location { block, statement_index });
+            }
 
-    fn visit_place(&mut self, place: &mir::Place<'tcx>, ctx: PlaceContext, _: mir::Location) {
-        let local = place.local;
-
-        if local == self.used.0
-            && !matches!(
-                ctx,
-                PlaceContext::MutatingUse(MutatingUseContext::Drop) | PlaceContext::NonUse(_)
-            )
-        {
-            self.used.1 = true;
+            self.visit_terminator(
+                data.terminator(),
+                mir::Location {
+                    block,
+                    statement_index: statements.len(),
+                },
+            );
         }
 
-        if local == self.consumed_or_mutated.0 {
-            match ctx {
-                PlaceContext::NonMutatingUse(NonMutatingUseContext::Move)
-                | PlaceContext::MutatingUse(MutatingUseContext::Borrow) => {
-                    self.consumed_or_mutated.1 = true;
-                },
-                _ => {},
+        fn visit_place(&mut self, place: &mir::Place<'tcx>, ctx: PlaceContext, loc: mir::Location) {
+            let local = place.local;
+
+            if local == self.cloned
+                && !matches!(
+                    ctx,
+                    PlaceContext::MutatingUse(MutatingUseContext::Drop) | PlaceContext::NonUse(_)
+                )
+            {
+                self.result.cloned_used = true;
+                self.result.cloned_consume_or_mutate_loc = self.result.cloned_consume_or_mutate_loc.or_else(|| {
+                    matches!(
+                        ctx,
+                        PlaceContext::NonMutatingUse(NonMutatingUseContext::Move)
+                            | PlaceContext::MutatingUse(MutatingUseContext::Borrow)
+                    )
+                    .then(|| loc)
+                });
+            } else if local == self.clone {
+                match ctx {
+                    PlaceContext::NonMutatingUse(NonMutatingUseContext::Move)
+                    | PlaceContext::MutatingUse(MutatingUseContext::Borrow) => {
+                        self.result.clone_consumed_or_mutated = true;
+                    },
+                    _ => {},
+                }
             }
         }
     }
+
+    let init = CloneUsage {
+        cloned_used: false,
+        cloned_consume_or_mutate_loc: None,
+        // Consider non-temporary clones consumed.
+        // TODO: Actually check for mutation of non-temporaries.
+        clone_consumed_or_mutated: mir.local_kind(clone) != mir::LocalKind::Temp,
+    };
+    traversal::ReversePostorder::new(&mir, bb)
+        .skip(1)
+        .fold(init, |usage, (tbb, tdata)| {
+            // Short-circuit
+            if (usage.cloned_used && usage.clone_consumed_or_mutated) ||
+                // Give up on loops
+                tdata.terminator().successors().any(|s| *s == bb)
+            {
+                return CloneUsage {
+                    cloned_used: true,
+                    clone_consumed_or_mutated: true,
+                    ..usage
+                };
+            }
+
+            let mut v = V {
+                cloned,
+                clone,
+                result: usage,
+            };
+            v.visit_basic_block_data(tbb, tdata);
+            v.result
+        })
 }
 
 /// Determines liveness of each local purely based on `StorageLive`/`Dead`.
@@ -623,4 +664,9 @@ impl PossibleBorrowerMap<'_, '_> {
 
         self.bitset.0 == self.bitset.1
     }
+
+    fn is_alive_at(&mut self, local: mir::Local, at: mir::Location) -> bool {
+        self.maybe_live.seek_after_primary_effect(at);
+        self.maybe_live.contains(local)
+    }
 }
diff --git a/tests/ui/redundant_clone.fixed b/tests/ui/redundant_clone.fixed
index ec309109ed5..f5da703cd1d 100644
--- a/tests/ui/redundant_clone.fixed
+++ b/tests/ui/redundant_clone.fixed
@@ -54,6 +54,7 @@ fn main() {
     not_consumed();
     issue_5405();
     manually_drop();
+    clone_then_move_cloned();
 }
 
 #[derive(Clone)]
@@ -182,3 +183,26 @@ fn manually_drop() {
         Arc::from_raw(p);
     }
 }
+
+fn clone_then_move_cloned() {
+    // issue #5973
+    let x = Some(String::new());
+    // ok, x is moved while the clone is in use.
+    assert_eq!(x.clone(), None, "not equal {}", x.unwrap());
+
+    // issue #5595
+    fn foo<F: Fn()>(_: &Alpha, _: F) {}
+    let x = Alpha;
+    // ok, data is moved while the clone is in use.
+    foo(&x.clone(), move || {
+        let _ = x;
+    });
+
+    // issue #6998
+    struct S(String);
+    impl S {
+        fn m(&mut self) {}
+    }
+    let mut x = S(String::new());
+    x.0.clone().chars().for_each(|_| x.m());
+}
diff --git a/tests/ui/redundant_clone.rs b/tests/ui/redundant_clone.rs
index b57027456e0..fd7f31a1cc5 100644
--- a/tests/ui/redundant_clone.rs
+++ b/tests/ui/redundant_clone.rs
@@ -54,6 +54,7 @@ fn main() {
     not_consumed();
     issue_5405();
     manually_drop();
+    clone_then_move_cloned();
 }
 
 #[derive(Clone)]
@@ -182,3 +183,26 @@ fn manually_drop() {
         Arc::from_raw(p);
     }
 }
+
+fn clone_then_move_cloned() {
+    // issue #5973
+    let x = Some(String::new());
+    // ok, x is moved while the clone is in use.
+    assert_eq!(x.clone(), None, "not equal {}", x.unwrap());
+
+    // issue #5595
+    fn foo<F: Fn()>(_: &Alpha, _: F) {}
+    let x = Alpha;
+    // ok, data is moved while the clone is in use.
+    foo(&x.clone(), move || {
+        let _ = x;
+    });
+
+    // issue #6998
+    struct S(String);
+    impl S {
+        fn m(&mut self) {}
+    }
+    let mut x = S(String::new());
+    x.0.clone().chars().for_each(|_| x.m());
+}
diff --git a/tests/ui/redundant_clone.stderr b/tests/ui/redundant_clone.stderr
index 821e7934be8..529a6de91e2 100644
--- a/tests/ui/redundant_clone.stderr
+++ b/tests/ui/redundant_clone.stderr
@@ -108,61 +108,61 @@ LL |     let _t = tup.0.clone();
    |              ^^^^^
 
 error: redundant clone
-  --> $DIR/redundant_clone.rs:62:25
+  --> $DIR/redundant_clone.rs:63:25
    |
 LL |     if b { (a.clone(), a.clone()) } else { (Alpha, a) }
    |                         ^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> $DIR/redundant_clone.rs:62:24
+  --> $DIR/redundant_clone.rs:63:24
    |
 LL |     if b { (a.clone(), a.clone()) } else { (Alpha, a) }
    |                        ^
 
 error: redundant clone
-  --> $DIR/redundant_clone.rs:119:15
+  --> $DIR/redundant_clone.rs:120:15
    |
 LL |     let _s = s.clone();
    |               ^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> $DIR/redundant_clone.rs:119:14
+  --> $DIR/redundant_clone.rs:120:14
    |
 LL |     let _s = s.clone();
    |              ^
 
 error: redundant clone
-  --> $DIR/redundant_clone.rs:120:15
+  --> $DIR/redundant_clone.rs:121:15
    |
 LL |     let _t = t.clone();
    |               ^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> $DIR/redundant_clone.rs:120:14
+  --> $DIR/redundant_clone.rs:121:14
    |
 LL |     let _t = t.clone();
    |              ^
 
 error: redundant clone
-  --> $DIR/redundant_clone.rs:130:19
+  --> $DIR/redundant_clone.rs:131:19
    |
 LL |         let _f = f.clone();
    |                   ^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> $DIR/redundant_clone.rs:130:18
+  --> $DIR/redundant_clone.rs:131:18
    |
 LL |         let _f = f.clone();
    |                  ^
 
 error: redundant clone
-  --> $DIR/redundant_clone.rs:142:14
+  --> $DIR/redundant_clone.rs:143:14
    |
 LL |     let y = x.clone().join("matthias");
    |              ^^^^^^^^ help: remove this
    |
 note: cloned value is neither consumed nor mutated
-  --> $DIR/redundant_clone.rs:142:13
+  --> $DIR/redundant_clone.rs:143:13
    |
 LL |     let y = x.clone().join("matthias");
    |             ^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From 08a8ad3a366ff28e4d89997de69ddb3a6ceb1a18 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Thu, 1 Apr 2021 12:15:47 -0500
Subject: Remove paths from bind_instead_of_map

---
 clippy_lints/src/methods/bind_instead_of_map.rs | 159 ++++++++++++------------
 1 file changed, 78 insertions(+), 81 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/bind_instead_of_map.rs b/clippy_lints/src/methods/bind_instead_of_map.rs
index 8ccb8f4268c..46d4c674648 100644
--- a/clippy_lints/src/methods/bind_instead_of_map.rs
+++ b/clippy_lints/src/methods/bind_instead_of_map.rs
@@ -1,80 +1,66 @@
 use super::{contains_return, BIND_INSTEAD_OF_MAP};
 use clippy_utils::diagnostics::{multispan_sugg_with_applicability, span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::{snippet, snippet_with_macro_callsite};
-use clippy_utils::ty::match_type;
-use clippy_utils::{in_macro, match_qpath, method_calls, paths, remove_blocks, visitors::find_all_ret_expressions};
+use clippy_utils::{in_macro, remove_blocks, visitors::find_all_ret_expressions};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
+use rustc_hir::def::{CtorKind, CtorOf, DefKind, Res};
+use rustc_hir::{LangItem, QPath};
 use rustc_lint::LateContext;
+use rustc_middle::ty::DefIdTree;
 use rustc_span::Span;
 
 pub(crate) struct OptionAndThenSome;
 
 impl BindInsteadOfMap for OptionAndThenSome {
-    const TYPE_NAME: &'static str = "Option";
-    const TYPE_QPATH: &'static [&'static str] = &paths::OPTION;
-
+    const VARIANT_LANG_ITEM: LangItem = LangItem::OptionSome;
     const BAD_METHOD_NAME: &'static str = "and_then";
-    const BAD_VARIANT_NAME: &'static str = "Some";
-    const BAD_VARIANT_QPATH: &'static [&'static str] = &paths::OPTION_SOME;
-
     const GOOD_METHOD_NAME: &'static str = "map";
 }
 
 pub(crate) struct ResultAndThenOk;
 
 impl BindInsteadOfMap for ResultAndThenOk {
-    const TYPE_NAME: &'static str = "Result";
-    const TYPE_QPATH: &'static [&'static str] = &paths::RESULT;
-
+    const VARIANT_LANG_ITEM: LangItem = LangItem::ResultOk;
     const BAD_METHOD_NAME: &'static str = "and_then";
-    const BAD_VARIANT_NAME: &'static str = "Ok";
-    const BAD_VARIANT_QPATH: &'static [&'static str] = &paths::RESULT_OK;
-
     const GOOD_METHOD_NAME: &'static str = "map";
 }
 
 pub(crate) struct ResultOrElseErrInfo;
 
 impl BindInsteadOfMap for ResultOrElseErrInfo {
-    const TYPE_NAME: &'static str = "Result";
-    const TYPE_QPATH: &'static [&'static str] = &paths::RESULT;
-
+    const VARIANT_LANG_ITEM: LangItem = LangItem::ResultErr;
     const BAD_METHOD_NAME: &'static str = "or_else";
-    const BAD_VARIANT_NAME: &'static str = "Err";
-    const BAD_VARIANT_QPATH: &'static [&'static str] = &paths::RESULT_ERR;
-
     const GOOD_METHOD_NAME: &'static str = "map_err";
 }
 
 pub(crate) trait BindInsteadOfMap {
-    const TYPE_NAME: &'static str;
-    const TYPE_QPATH: &'static [&'static str];
-
+    const VARIANT_LANG_ITEM: LangItem;
     const BAD_METHOD_NAME: &'static str;
-    const BAD_VARIANT_NAME: &'static str;
-    const BAD_VARIANT_QPATH: &'static [&'static str];
-
     const GOOD_METHOD_NAME: &'static str;
 
-    fn no_op_msg() -> String {
-        format!(
+    fn no_op_msg(cx: &LateContext<'_>) -> Option<String> {
+        let variant_id = cx.tcx.lang_items().require(Self::VARIANT_LANG_ITEM).ok()?;
+        let item_id = cx.tcx.parent(variant_id)?;
+        Some(format!(
             "using `{}.{}({})`, which is a no-op",
-            Self::TYPE_NAME,
+            cx.tcx.item_name(item_id),
             Self::BAD_METHOD_NAME,
-            Self::BAD_VARIANT_NAME
-        )
+            cx.tcx.item_name(variant_id),
+        ))
     }
 
-    fn lint_msg() -> String {
-        format!(
+    fn lint_msg(cx: &LateContext<'_>) -> Option<String> {
+        let variant_id = cx.tcx.lang_items().require(Self::VARIANT_LANG_ITEM).ok()?;
+        let item_id = cx.tcx.parent(variant_id)?;
+        Some(format!(
             "using `{}.{}(|x| {}(y))`, which is more succinctly expressed as `{}(|x| y)`",
-            Self::TYPE_NAME,
+            cx.tcx.item_name(item_id),
             Self::BAD_METHOD_NAME,
-            Self::BAD_VARIANT_NAME,
+            cx.tcx.item_name(variant_id),
             Self::GOOD_METHOD_NAME
-        )
+        ))
     }
 
     fn lint_closure_autofixable(
@@ -85,17 +71,12 @@ pub(crate) trait BindInsteadOfMap {
         closure_args_span: Span,
     ) -> bool {
         if_chain! {
-            if let hir::ExprKind::Call(ref some_expr, ref some_args) = closure_expr.kind;
-            if let hir::ExprKind::Path(ref qpath) = some_expr.kind;
-            if match_qpath(qpath, Self::BAD_VARIANT_QPATH);
-            if some_args.len() == 1;
+            if let hir::ExprKind::Call(ref some_expr, [inner_expr]) = closure_expr.kind;
+            if let hir::ExprKind::Path(QPath::Resolved(_, path)) = some_expr.kind;
+            if Self::is_variant(cx, path.res);
+            if !contains_return(inner_expr);
+            if let Some(msg) = Self::lint_msg(cx);
             then {
-                let inner_expr = &some_args[0];
-
-                if contains_return(inner_expr) {
-                    return false;
-                }
-
                 let some_inner_snip = if inner_expr.span.from_expansion() {
                     snippet_with_macro_callsite(cx, inner_expr.span, "_")
                 } else {
@@ -109,7 +90,7 @@ pub(crate) trait BindInsteadOfMap {
                     cx,
                     BIND_INSTEAD_OF_MAP,
                     expr.span,
-                    Self::lint_msg().as_ref(),
+                    &msg,
                     "try this",
                     note,
                     Applicability::MachineApplicable,
@@ -126,41 +107,46 @@ pub(crate) trait BindInsteadOfMap {
         let can_sugg: bool = find_all_ret_expressions(cx, closure_expr, |ret_expr| {
             if_chain! {
                 if !in_macro(ret_expr.span);
-                if let hir::ExprKind::Call(ref func_path, ref args) = ret_expr.kind;
-                if let hir::ExprKind::Path(ref qpath) = func_path.kind;
-                if match_qpath(qpath, Self::BAD_VARIANT_QPATH);
-                if args.len() == 1;
-                if !contains_return(&args[0]);
+                if let hir::ExprKind::Call(ref func_path, [arg]) = ret_expr.kind;
+                if let hir::ExprKind::Path(QPath::Resolved(_, path)) = func_path.kind;
+                if Self::is_variant(cx, path.res);
+                if !contains_return(arg);
                 then {
-                    suggs.push((ret_expr.span, args[0].span.source_callsite()));
+                    suggs.push((ret_expr.span, arg.span.source_callsite()));
                     true
                 } else {
                     false
                 }
             }
         });
-
-        if can_sugg {
-            span_lint_and_then(cx, BIND_INSTEAD_OF_MAP, expr.span, Self::lint_msg().as_ref(), |diag| {
-                multispan_sugg_with_applicability(
-                    diag,
-                    "try this",
-                    Applicability::MachineApplicable,
-                    std::iter::once((*method_calls(expr, 1).2.get(0).unwrap(), Self::GOOD_METHOD_NAME.into())).chain(
-                        suggs
-                            .into_iter()
-                            .map(|(span1, span2)| (span1, snippet(cx, span2, "_").into())),
-                    ),
-                )
-            });
-        }
-        can_sugg
+        let (span, msg) = if_chain! {
+            if can_sugg;
+            if let hir::ExprKind::MethodCall(_, span, ..) = expr.kind;
+            if let Some(msg) = Self::lint_msg(cx);
+            then { (span, msg) } else { return false; }
+        };
+        span_lint_and_then(cx, BIND_INSTEAD_OF_MAP, expr.span, &msg, |diag| {
+            multispan_sugg_with_applicability(
+                diag,
+                "try this",
+                Applicability::MachineApplicable,
+                std::iter::once((span, Self::GOOD_METHOD_NAME.into())).chain(
+                    suggs
+                        .into_iter()
+                        .map(|(span1, span2)| (span1, snippet(cx, span2, "_").into())),
+                ),
+            )
+        });
+        true
     }
 
     /// Lint use of `_.and_then(|x| Some(y))` for `Option`s
     fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr<'_>, arg: &hir::Expr<'_>) -> bool {
-        if !match_type(cx, cx.typeck_results().expr_ty(recv), Self::TYPE_QPATH) {
-            return false;
+        if_chain! {
+            if let Some(adt) = cx.typeck_results().expr_ty(recv).ty_adt_def();
+            if let Ok(vid) = cx.tcx.lang_items().require(Self::VARIANT_LANG_ITEM);
+            if Some(adt.did) == cx.tcx.parent(vid);
+            then {} else { return false; }
         }
 
         match arg.kind {
@@ -175,19 +161,30 @@ pub(crate) trait BindInsteadOfMap {
                 }
             },
             // `_.and_then(Some)` case, which is no-op.
-            hir::ExprKind::Path(ref qpath) if match_qpath(qpath, Self::BAD_VARIANT_QPATH) => {
-                span_lint_and_sugg(
-                    cx,
-                    BIND_INSTEAD_OF_MAP,
-                    expr.span,
-                    Self::no_op_msg().as_ref(),
-                    "use the expression directly",
-                    snippet(cx, recv.span, "..").into(),
-                    Applicability::MachineApplicable,
-                );
+            hir::ExprKind::Path(QPath::Resolved(_, path)) if Self::is_variant(cx, path.res) => {
+                if let Some(msg) = Self::no_op_msg(cx) {
+                    span_lint_and_sugg(
+                        cx,
+                        BIND_INSTEAD_OF_MAP,
+                        expr.span,
+                        &msg,
+                        "use the expression directly",
+                        snippet(cx, recv.span, "..").into(),
+                        Applicability::MachineApplicable,
+                    );
+                }
                 true
             },
             _ => false,
         }
     }
+
+    fn is_variant(cx: &LateContext<'_>, res: Res) -> bool {
+        if let Res::Def(DefKind::Ctor(CtorOf::Variant, CtorKind::Fn), id) = res {
+            if let Ok(variant_id) = cx.tcx.lang_items().require(Self::VARIANT_LANG_ITEM) {
+                return cx.tcx.parent(id) == Some(variant_id);
+            }
+        }
+        false
+    }
 }
-- 
cgit 1.4.1-3-g733a5


From 9f6f001988ae32e06b3abee5d869ad921fd614ae Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Fri, 2 Apr 2021 13:45:38 +0900
Subject: same_item_push: Don't trigger same_item_push if the vec is used in
 the loop body

---
 clippy_lints/src/loops/same_item_push.rs | 137 +++++++++++++++++++------------
 tests/ui/same_item_push.rs               |   7 ++
 2 files changed, 91 insertions(+), 53 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/same_item_push.rs b/clippy_lints/src/loops/same_item_push.rs
index 62c131968e7..b3d784474c8 100644
--- a/clippy_lints/src/loops/same_item_push.rs
+++ b/clippy_lints/src/loops/same_item_push.rs
@@ -1,11 +1,13 @@
 use super::SAME_ITEM_PUSH;
 use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::path_to_local;
 use clippy_utils::source::snippet_with_macro_callsite;
 use clippy_utils::ty::{implements_trait, is_type_diagnostic_item};
 use if_chain::if_chain;
+use rustc_data_structures::fx::FxHashSet;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
-use rustc_hir::{BindingAnnotation, Block, Expr, ExprKind, Node, Pat, PatKind, Stmt, StmtKind};
+use rustc_hir::{BindingAnnotation, Block, Expr, ExprKind, HirId, Node, Pat, PatKind, Stmt, StmtKind};
 use rustc_lint::LateContext;
 use rustc_middle::hir::map::Map;
 use rustc_span::symbol::sym;
@@ -41,59 +43,55 @@ pub(super) fn check<'tcx>(
     }
 
     // Determine whether it is safe to lint the body
-    let mut same_item_push_visitor = SameItemPushVisitor {
-        should_lint: true,
-        vec_push: None,
-        cx,
-    };
+    let mut same_item_push_visitor = SameItemPushVisitor::new(cx);
     walk_expr(&mut same_item_push_visitor, body);
-    if same_item_push_visitor.should_lint {
-        if let Some((vec, pushed_item)) = same_item_push_visitor.vec_push {
-            let vec_ty = cx.typeck_results().expr_ty(vec);
-            let ty = vec_ty.walk().nth(1).unwrap().expect_ty();
-            if cx
-                .tcx
-                .lang_items()
-                .clone_trait()
-                .map_or(false, |id| implements_trait(cx, ty, id, &[]))
-            {
-                // Make sure that the push does not involve possibly mutating values
-                match pushed_item.kind {
-                    ExprKind::Path(ref qpath) => {
-                        match cx.qpath_res(qpath, pushed_item.hir_id) {
-                            // immutable bindings that are initialized with literal or constant
-                            Res::Local(hir_id) => {
-                                let node = cx.tcx.hir().get(hir_id);
-                                if_chain! {
-                                    if let Node::Binding(pat) = node;
-                                    if let PatKind::Binding(bind_ann, ..) = pat.kind;
-                                    if !matches!(bind_ann, BindingAnnotation::RefMut | BindingAnnotation::Mutable);
-                                    let parent_node = cx.tcx.hir().get_parent_node(hir_id);
-                                    if let Some(Node::Local(parent_let_expr)) = cx.tcx.hir().find(parent_node);
-                                    if let Some(init) = parent_let_expr.init;
-                                    then {
-                                        match init.kind {
-                                            // immutable bindings that are initialized with literal
-                                            ExprKind::Lit(..) => emit_lint(cx, vec, pushed_item),
-                                            // immutable bindings that are initialized with constant
-                                            ExprKind::Path(ref path) => {
-                                                if let Res::Def(DefKind::Const, ..) = cx.qpath_res(path, init.hir_id) {
-                                                    emit_lint(cx, vec, pushed_item);
-                                                }
+    if_chain! {
+        if same_item_push_visitor.should_lint();
+        if let Some((vec, pushed_item)) = same_item_push_visitor.vec_push;
+        let vec_ty = cx.typeck_results().expr_ty(vec);
+        let ty = vec_ty.walk().nth(1).unwrap().expect_ty();
+        if cx
+            .tcx
+            .lang_items()
+            .clone_trait()
+            .map_or(false, |id| implements_trait(cx, ty, id, &[]));
+        then {
+            // Make sure that the push does not involve possibly mutating values
+            match pushed_item.kind {
+                ExprKind::Path(ref qpath) => {
+                    match cx.qpath_res(qpath, pushed_item.hir_id) {
+                        // immutable bindings that are initialized with literal or constant
+                        Res::Local(hir_id) => {
+                            let node = cx.tcx.hir().get(hir_id);
+                            if_chain! {
+                                if let Node::Binding(pat) = node;
+                                if let PatKind::Binding(bind_ann, ..) = pat.kind;
+                                if !matches!(bind_ann, BindingAnnotation::RefMut | BindingAnnotation::Mutable);
+                                let parent_node = cx.tcx.hir().get_parent_node(hir_id);
+                                if let Some(Node::Local(parent_let_expr)) = cx.tcx.hir().find(parent_node);
+                                if let Some(init) = parent_let_expr.init;
+                                then {
+                                    match init.kind {
+                                        // immutable bindings that are initialized with literal
+                                        ExprKind::Lit(..) => emit_lint(cx, vec, pushed_item),
+                                        // immutable bindings that are initialized with constant
+                                        ExprKind::Path(ref path) => {
+                                            if let Res::Def(DefKind::Const, ..) = cx.qpath_res(path, init.hir_id) {
+                                                emit_lint(cx, vec, pushed_item);
                                             }
-                                            _ => {},
                                         }
+                                        _ => {},
                                     }
                                 }
-                            },
-                            // constant
-                            Res::Def(DefKind::Const, ..) => emit_lint(cx, vec, pushed_item),
-                            _ => {},
-                        }
-                    },
-                    ExprKind::Lit(..) => emit_lint(cx, vec, pushed_item),
-                    _ => {},
-                }
+                            }
+                        },
+                        // constant
+                        Res::Def(DefKind::Const, ..) => emit_lint(cx, vec, pushed_item),
+                        _ => {},
+                    }
+                },
+                ExprKind::Lit(..) => emit_lint(cx, vec, pushed_item),
+                _ => {},
             }
         }
     }
@@ -101,10 +99,38 @@ pub(super) fn check<'tcx>(
 
 // Scans the body of the for loop and determines whether lint should be given
 struct SameItemPushVisitor<'a, 'tcx> {
-    should_lint: bool,
+    non_deterministic_expr: bool,
+    multiple_pushes: bool,
     // this field holds the last vec push operation visited, which should be the only push seen
     vec_push: Option<(&'tcx Expr<'tcx>, &'tcx Expr<'tcx>)>,
     cx: &'a LateContext<'tcx>,
+    used_locals: FxHashSet<HirId>,
+}
+
+impl<'a, 'tcx> SameItemPushVisitor<'a, 'tcx> {
+    fn new(cx: &'a LateContext<'tcx>) -> Self {
+        Self {
+            non_deterministic_expr: false,
+            multiple_pushes: false,
+            vec_push: None,
+            cx,
+            used_locals: FxHashSet::default(),
+        }
+    }
+
+    fn should_lint(&self) -> bool {
+        if_chain! {
+            if !self.non_deterministic_expr;
+            if !self.multiple_pushes;
+            if let Some((vec, _)) = self.vec_push;
+            if let Some(hir_id) = path_to_local(vec);
+            then {
+                !self.used_locals.contains(&hir_id)
+            } else {
+                false
+            }
+        }
+    }
 }
 
 impl<'a, 'tcx> Visitor<'tcx> for SameItemPushVisitor<'a, 'tcx> {
@@ -113,9 +139,14 @@ impl<'a, 'tcx> Visitor<'tcx> for SameItemPushVisitor<'a, 'tcx> {
     fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
         match &expr.kind {
             // Non-determinism may occur ... don't give a lint
-            ExprKind::Loop(..) | ExprKind::Match(..) => self.should_lint = false,
+            ExprKind::Loop(..) | ExprKind::Match(..) | ExprKind::If(..) => self.non_deterministic_expr = true,
             ExprKind::Block(block, _) => self.visit_block(block),
-            _ => {},
+            _ => {
+                if let Some(hir_id) = path_to_local(expr) {
+                    self.used_locals.insert(hir_id);
+                }
+                walk_expr(self, expr);
+            },
         }
     }
 
@@ -140,7 +171,7 @@ impl<'a, 'tcx> Visitor<'tcx> for SameItemPushVisitor<'a, 'tcx> {
                 self.vec_push = vec_push_option;
             } else {
                 // There are multiple pushes ... don't lint
-                self.should_lint = false;
+                self.multiple_pushes = true;
             }
         }
     }
diff --git a/tests/ui/same_item_push.rs b/tests/ui/same_item_push.rs
index a37c8782ec3..9d420ec672a 100644
--- a/tests/ui/same_item_push.rs
+++ b/tests/ui/same_item_push.rs
@@ -148,4 +148,11 @@ fn main() {
         };
         vec.push(item);
     }
+
+    // Fix #6987
+    let mut vec = Vec::new();
+    for _ in 0..10 {
+        vec.push(1);
+        vec.extend(&[2]);
+    }
 }
-- 
cgit 1.4.1-3-g733a5


From a064534b9e9754e18429a05db79fcba0d70292b9 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Fri, 2 Apr 2021 08:37:03 -0500
Subject: Refactor needless_collect

---
 clippy_lints/src/loops/needless_collect.rs | 80 ++++++++----------------------
 1 file changed, 21 insertions(+), 59 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/needless_collect.rs b/clippy_lints/src/loops/needless_collect.rs
index d23d3c508fa..5378b018970 100644
--- a/clippy_lints/src/loops/needless_collect.rs
+++ b/clippy_lints/src/loops/needless_collect.rs
@@ -22,7 +22,7 @@ pub(super) fn check<'tcx>(expr: &'tcx Expr<'_>, cx: &LateContext<'tcx>) {
 fn check_needless_collect_direct_usage<'tcx>(expr: &'tcx Expr<'_>, cx: &LateContext<'tcx>) {
     if_chain! {
         if let ExprKind::MethodCall(ref method, _, ref args, _) = expr.kind;
-        if let ExprKind::MethodCall(ref chain_method, _, _, _) = args[0].kind;
+        if let ExprKind::MethodCall(ref chain_method, method0_span, _, _) = args[0].kind;
         if chain_method.ident.name == sym!(collect) && is_trait_method(cx, &args[0], sym::Iterator);
         if let Some(ref generic_args) = chain_method.args;
         if let Some(GenericArg::Type(ref ty)) = generic_args.args.get(0);
@@ -31,55 +31,28 @@ fn check_needless_collect_direct_usage<'tcx>(expr: &'tcx Expr<'_>, cx: &LateCont
             || is_type_diagnostic_item(cx, ty, sym::vecdeque_type)
             || match_type(cx, ty, &paths::BTREEMAP)
             || is_type_diagnostic_item(cx, ty, sym::hashmap_type);
-        then {
-            if method.ident.name == sym!(len) {
-                let span = shorten_needless_collect_span(expr);
-                span_lint_and_sugg(
-                    cx,
-                    NEEDLESS_COLLECT,
-                    span,
-                    NEEDLESS_COLLECT_MSG,
-                    "replace with",
-                    "count()".to_string(),
-                    Applicability::MachineApplicable,
-                );
-            }
-            if method.ident.name == sym!(is_empty) {
-                let span = shorten_needless_collect_span(expr);
-                span_lint_and_sugg(
-                    cx,
-                    NEEDLESS_COLLECT,
-                    span,
-                    NEEDLESS_COLLECT_MSG,
-                    "replace with",
-                    "next().is_none()".to_string(),
-                    Applicability::MachineApplicable,
-                );
-            }
-            if method.ident.name == sym!(contains) {
+        if let Some(sugg) = match &*method.ident.name.as_str() {
+            "len" => Some("count()".to_string()),
+            "is_empty" => Some("next().is_none()".to_string()),
+            "contains" => {
                 let contains_arg = snippet(cx, args[1].span, "??");
-                let span = shorten_needless_collect_span(expr);
-                span_lint_and_then(
-                    cx,
-                    NEEDLESS_COLLECT,
-                    span,
-                    NEEDLESS_COLLECT_MSG,
-                    |diag| {
-                        let (arg, pred) = contains_arg
-                                .strip_prefix('&')
-                                .map_or(("&x", &*contains_arg), |s| ("x", s));
-                        diag.span_suggestion(
-                            span,
-                            "replace with",
-                            format!(
-                                "any(|{}| x == {})",
-                                arg, pred
-                            ),
-                            Applicability::MachineApplicable,
-                        );
-                    }
-                );
+                let (arg, pred) = contains_arg
+                    .strip_prefix('&')
+                    .map_or(("&x", &*contains_arg), |s| ("x", s));
+                Some(format!("any(|{}| x == {})", arg, pred))
             }
+            _ => None,
+        };
+        then {
+            span_lint_and_sugg(
+                cx,
+                NEEDLESS_COLLECT,
+                method0_span.with_hi(expr.span.hi()),
+                NEEDLESS_COLLECT_MSG,
+                "replace with",
+                sugg,
+                Applicability::MachineApplicable,
+            );
         }
     }
 }
@@ -269,14 +242,3 @@ fn detect_iter_and_into_iters<'tcx>(block: &'tcx Block<'tcx>, identifier: Ident)
     visitor.visit_block(block);
     if visitor.seen_other { None } else { Some(visitor.uses) }
 }
-
-fn shorten_needless_collect_span(expr: &Expr<'_>) -> Span {
-    if_chain! {
-        if let ExprKind::MethodCall(.., args, _) = &expr.kind;
-        if let ExprKind::MethodCall(_, span, ..) = &args[0].kind;
-        then {
-            return expr.span.with_lo(span.lo());
-        }
-    }
-    unreachable!();
-}
-- 
cgit 1.4.1-3-g733a5


From 4356a8f8f7882e2ebef3362c5175c69242f27844 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Fri, 2 Apr 2021 09:38:13 -0500
Subject: Remove redundant emit()

---
 clippy_lints/src/loops/needless_collect.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/needless_collect.rs b/clippy_lints/src/loops/needless_collect.rs
index 5378b018970..96b0f2e6cd7 100644
--- a/clippy_lints/src/loops/needless_collect.rs
+++ b/clippy_lints/src/loops/needless_collect.rs
@@ -102,7 +102,7 @@ fn check_needless_collect_indirect_usage<'tcx>(expr: &'tcx Expr<'_>, cx: &LateCo
                                     (iter_call.span, iter_replacement)
                                 ],
                                 Applicability::MachineApplicable,// MaybeIncorrect,
-                            ).emit();
+                            );
                         },
                     );
                 }
-- 
cgit 1.4.1-3-g733a5


From 33798bb0646b32680a204ef39aa1aae07c9ac0f5 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Fri, 2 Apr 2021 10:03:35 -0500
Subject: Improve needless_collect output

---
 clippy_lints/src/loops/needless_collect.rs | 11 ++++----
 clippy_utils/src/diagnostics.rs            |  6 ++--
 tests/ui/needless_collect_indirect.stderr  | 45 +++++++++++++++++-------------
 3 files changed, 35 insertions(+), 27 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/needless_collect.rs b/clippy_lints/src/loops/needless_collect.rs
index 96b0f2e6cd7..e0c5caf5136 100644
--- a/clippy_lints/src/loops/needless_collect.rs
+++ b/clippy_lints/src/loops/needless_collect.rs
@@ -10,8 +10,8 @@ use rustc_hir::intravisit::{walk_block, walk_expr, NestedVisitorMap, Visitor};
 use rustc_hir::{Block, Expr, ExprKind, GenericArg, HirId, Local, Pat, PatKind, QPath, StmtKind};
 use rustc_lint::LateContext;
 use rustc_middle::hir::map::Map;
-use rustc_span::source_map::Span;
 use rustc_span::symbol::{sym, Ident};
+use rustc_span::{MultiSpan, Span};
 
 const NEEDLESS_COLLECT_MSG: &str = "avoid using `collect()` when not needed";
 
@@ -65,7 +65,7 @@ fn check_needless_collect_indirect_usage<'tcx>(expr: &'tcx Expr<'_>, cx: &LateCo
                     Local { pat: Pat { hir_id: pat_id, kind: PatKind::Binding(_, _, ident, .. ), .. },
                     init: Some(ref init_expr), .. }
                 ) = stmt.kind;
-                if let ExprKind::MethodCall(ref method_name, _, &[ref iter_source], ..) = init_expr.kind;
+                if let ExprKind::MethodCall(ref method_name, collect_span, &[ref iter_source], ..) = init_expr.kind;
                 if method_name.ident.name == sym!(collect) && is_trait_method(cx, &init_expr, sym::Iterator);
                 if let Some(ref generic_args) = method_name.args;
                 if let Some(GenericArg::Type(ref ty)) = generic_args.args.get(0);
@@ -74,7 +74,7 @@ fn check_needless_collect_indirect_usage<'tcx>(expr: &'tcx Expr<'_>, cx: &LateCo
                     is_type_diagnostic_item(cx, ty, sym::vecdeque_type) ||
                     match_type(cx, ty, &paths::LINKED_LIST);
                 if let Some(iter_calls) = detect_iter_and_into_iters(block, *ident);
-                if iter_calls.len() == 1;
+                if let [iter_call] = &*iter_calls;
                 then {
                     let mut used_count_visitor = UsedCountVisitor {
                         cx,
@@ -87,11 +87,12 @@ fn check_needless_collect_indirect_usage<'tcx>(expr: &'tcx Expr<'_>, cx: &LateCo
                     }
 
                     // Suggest replacing iter_call with iter_replacement, and removing stmt
-                    let iter_call = &iter_calls[0];
+                    let mut span = MultiSpan::from_span(collect_span);
+                    span.push_span_label(iter_call.span, "the iterator could be used here instead".into());
                     span_lint_and_then(
                         cx,
                         super::NEEDLESS_COLLECT,
-                        stmt.span.until(iter_call.span),
+                        span,
                         NEEDLESS_COLLECT_MSG,
                         |diag| {
                             let iter_replacement = format!("{}{}", Sugg::hir(cx, iter_source, ".."), iter_call.get_iter_method(cx));
diff --git a/clippy_utils/src/diagnostics.rs b/clippy_utils/src/diagnostics.rs
index e9c9cb12b9d..73a2fa992b3 100644
--- a/clippy_utils/src/diagnostics.rs
+++ b/clippy_utils/src/diagnostics.rs
@@ -133,9 +133,11 @@ pub fn span_lint_and_note<'a, T: LintContext>(
 ///
 /// If you need to customize your lint output a lot, use this function.
 /// If you change the signature, remember to update the internal lint `CollapsibleCalls`
-pub fn span_lint_and_then<'a, T: LintContext, F>(cx: &'a T, lint: &'static Lint, sp: Span, msg: &str, f: F)
+pub fn span_lint_and_then<C, S, F>(cx: &C, lint: &'static Lint, sp: S, msg: &str, f: F)
 where
-    F: for<'b> FnOnce(&mut DiagnosticBuilder<'b>),
+    C: LintContext,
+    S: Into<MultiSpan>,
+    F: FnOnce(&mut DiagnosticBuilder<'_>),
 {
     cx.struct_span_lint(lint, sp, |diag| {
         let mut diag = diag.build(msg);
diff --git a/tests/ui/needless_collect_indirect.stderr b/tests/ui/needless_collect_indirect.stderr
index 76e789d9052..c773b841f3b 100644
--- a/tests/ui/needless_collect_indirect.stderr
+++ b/tests/ui/needless_collect_indirect.stderr
@@ -1,9 +1,10 @@
 error: avoid using `collect()` when not needed
-  --> $DIR/needless_collect_indirect.rs:5:5
+  --> $DIR/needless_collect_indirect.rs:5:39
    |
-LL | /     let indirect_iter = sample.iter().collect::<Vec<_>>();
-LL | |     indirect_iter.into_iter().map(|x| (x, x + 1)).collect::<HashMap<_, _>>();
-   | |____^
+LL |     let indirect_iter = sample.iter().collect::<Vec<_>>();
+   |                                       ^^^^^^^
+LL |     indirect_iter.into_iter().map(|x| (x, x + 1)).collect::<HashMap<_, _>>();
+   |     ------------------------- the iterator could be used here instead
    |
    = note: `-D clippy::needless-collect` implied by `-D warnings`
 help: use the original Iterator instead of collecting it and then producing a new one
@@ -13,11 +14,12 @@ LL |     sample.iter().map(|x| (x, x + 1)).collect::<HashMap<_, _>>();
    |
 
 error: avoid using `collect()` when not needed
-  --> $DIR/needless_collect_indirect.rs:7:5
+  --> $DIR/needless_collect_indirect.rs:7:38
    |
-LL | /     let indirect_len = sample.iter().collect::<VecDeque<_>>();
-LL | |     indirect_len.len();
-   | |____^
+LL |     let indirect_len = sample.iter().collect::<VecDeque<_>>();
+   |                                      ^^^^^^^
+LL |     indirect_len.len();
+   |     ------------------ the iterator could be used here instead
    |
 help: take the original Iterator's count instead of collecting it and finding the length
    |
@@ -26,11 +28,12 @@ LL |     sample.iter().count();
    |
 
 error: avoid using `collect()` when not needed
-  --> $DIR/needless_collect_indirect.rs:9:5
+  --> $DIR/needless_collect_indirect.rs:9:40
    |
-LL | /     let indirect_empty = sample.iter().collect::<VecDeque<_>>();
-LL | |     indirect_empty.is_empty();
-   | |____^
+LL |     let indirect_empty = sample.iter().collect::<VecDeque<_>>();
+   |                                        ^^^^^^^
+LL |     indirect_empty.is_empty();
+   |     ------------------------- the iterator could be used here instead
    |
 help: check if the original Iterator has anything instead of collecting it and seeing if it's empty
    |
@@ -39,11 +42,12 @@ LL |     sample.iter().next().is_none();
    |
 
 error: avoid using `collect()` when not needed
-  --> $DIR/needless_collect_indirect.rs:11:5
+  --> $DIR/needless_collect_indirect.rs:11:43
    |
-LL | /     let indirect_contains = sample.iter().collect::<VecDeque<_>>();
-LL | |     indirect_contains.contains(&&5);
-   | |____^
+LL |     let indirect_contains = sample.iter().collect::<VecDeque<_>>();
+   |                                           ^^^^^^^
+LL |     indirect_contains.contains(&&5);
+   |     ------------------------------- the iterator could be used here instead
    |
 help: check if the original Iterator contains an element instead of collecting then checking
    |
@@ -52,11 +56,12 @@ LL |     sample.iter().any(|x| x == &5);
    |
 
 error: avoid using `collect()` when not needed
-  --> $DIR/needless_collect_indirect.rs:23:5
+  --> $DIR/needless_collect_indirect.rs:23:48
    |
-LL | /     let non_copy_contains = sample.into_iter().collect::<Vec<_>>();
-LL | |     non_copy_contains.contains(&a);
-   | |____^
+LL |     let non_copy_contains = sample.into_iter().collect::<Vec<_>>();
+   |                                                ^^^^^^^
+LL |     non_copy_contains.contains(&a);
+   |     ------------------------------ the iterator could be used here instead
    |
 help: check if the original Iterator contains an element instead of collecting then checking
    |
-- 
cgit 1.4.1-3-g733a5


From c05760ff90fbf4ac677db592b2efe25fab5fac6c Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Fri, 2 Apr 2021 22:24:52 -0400
Subject: Fix `macro_use_import` ICE

---
 clippy_lints/src/macro_use.rs    | 1 +
 tests/ui/macro_use_imports.fixed | 6 +++++-
 tests/ui/macro_use_imports.rs    | 6 +++++-
 3 files changed, 11 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/macro_use.rs b/clippy_lints/src/macro_use.rs
index d573c297838..68cba192c4e 100644
--- a/clippy_lints/src/macro_use.rs
+++ b/clippy_lints/src/macro_use.rs
@@ -114,6 +114,7 @@ impl<'tcx> LateLintPass<'tcx> for MacroUseImports {
                 .iter()
                 .find(|attr| attr.ident().map(|s| s.to_string()) == Some("macro_use".to_string()));
             if let Res::Def(DefKind::Mod, id) = path.res;
+            if !id.is_local();
             then {
                 for kid in cx.tcx.item_children(id).iter() {
                     if let Res::Def(DefKind::Macro(_mac_type), mac_id) = kid.res {
diff --git a/tests/ui/macro_use_imports.fixed b/tests/ui/macro_use_imports.fixed
index 91e34c62160..51c66a46368 100644
--- a/tests/ui/macro_use_imports.fixed
+++ b/tests/ui/macro_use_imports.fixed
@@ -4,7 +4,7 @@
 // run-rustfix
 // ignore-32bit
 
-#![allow(unused_imports, unreachable_code, unused_variables, dead_code)]
+#![allow(unused_imports, unreachable_code, unused_variables, dead_code, unused_attributes)]
 #![allow(clippy::single_component_path_imports)]
 #![warn(clippy::macro_use_imports)]
 
@@ -40,4 +40,8 @@ mod a {
     }
 }
 
+// issue #7015, ICE due to calling `item_children` with local `DefId`
+#[macro_use]
+use a as b;
+
 fn main() {}
diff --git a/tests/ui/macro_use_imports.rs b/tests/ui/macro_use_imports.rs
index 9c3c50c5d49..2011129bc94 100644
--- a/tests/ui/macro_use_imports.rs
+++ b/tests/ui/macro_use_imports.rs
@@ -4,7 +4,7 @@
 // run-rustfix
 // ignore-32bit
 
-#![allow(unused_imports, unreachable_code, unused_variables, dead_code)]
+#![allow(unused_imports, unreachable_code, unused_variables, dead_code, unused_attributes)]
 #![allow(clippy::single_component_path_imports)]
 #![warn(clippy::macro_use_imports)]
 
@@ -40,4 +40,8 @@ mod a {
     }
 }
 
+// issue #7015, ICE due to calling `item_children` with local `DefId`
+#[macro_use]
+use a as b;
+
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 7014340d5713b9401d95a5ca3287163fd407da46 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Fri, 2 Apr 2021 11:56:32 -0500
Subject: Fix ICE

---
 clippy_lints/src/matches.rs  | 14 ++++++++------
 tests/ui/crashes/ice-7012.rs | 17 +++++++++++++++++
 2 files changed, 25 insertions(+), 6 deletions(-)
 create mode 100644 tests/ui/crashes/ice-7012.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index b13db4cd45c..ba49097fd3b 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -1046,16 +1046,18 @@ fn check_wild_enum_match(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>])
                     path
                 },
                 PatKind::TupleStruct(path, patterns, ..) => {
-                    if arm.guard.is_none() && patterns.iter().all(|p| !is_refutable(cx, p)) {
-                        let id = cx.qpath_res(path, pat.hir_id).def_id();
-                        missing_variants.retain(|e| e.ctor_def_id != Some(id));
+                    if let Some(id) = cx.qpath_res(path, pat.hir_id).opt_def_id() {
+                        if arm.guard.is_none() && patterns.iter().all(|p| !is_refutable(cx, p)) {
+                            missing_variants.retain(|e| e.ctor_def_id != Some(id));
+                        }
                     }
                     path
                 },
                 PatKind::Struct(path, patterns, ..) => {
-                    if arm.guard.is_none() && patterns.iter().all(|p| !is_refutable(cx, p.pat)) {
-                        let id = cx.qpath_res(path, pat.hir_id).def_id();
-                        missing_variants.retain(|e| e.def_id != id);
+                    if let Some(id) = cx.qpath_res(path, pat.hir_id).opt_def_id() {
+                        if arm.guard.is_none() && patterns.iter().all(|p| !is_refutable(cx, p.pat)) {
+                            missing_variants.retain(|e| e.def_id != id);
+                        }
                     }
                     path
                 },
diff --git a/tests/ui/crashes/ice-7012.rs b/tests/ui/crashes/ice-7012.rs
new file mode 100644
index 00000000000..60bdbc4f124
--- /dev/null
+++ b/tests/ui/crashes/ice-7012.rs
@@ -0,0 +1,17 @@
+#![allow(clippy::all)]
+
+enum _MyOption {
+    None,
+    Some(()),
+}
+
+impl _MyOption {
+    fn _foo(&self) {
+        match self {
+            &Self::Some(_) => {},
+            _ => {},
+        }
+    }
+}
+
+fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 5102c9cc694fd6374370c00f7c9518da14c0156e Mon Sep 17 00:00:00 2001
From: daxpedda <daxpedda@gmail.com>
Date: Sat, 3 Apr 2021 22:52:48 +0200
Subject: Remove author requirement for `cargo_common_metadata`

---
 clippy_lints/src/cargo_common_metadata.rs                      | 10 ++--------
 tests/ui-cargo/cargo_common_metadata/fail/src/main.stderr      |  6 ++----
 .../cargo_common_metadata/fail_publish/src/main.stderr         |  6 ++----
 .../cargo_common_metadata/fail_publish_true/src/main.stderr    |  6 ++----
 tests/ui-cargo/cargo_common_metadata/pass/Cargo.toml           |  1 -
 5 files changed, 8 insertions(+), 21 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/cargo_common_metadata.rs b/clippy_lints/src/cargo_common_metadata.rs
index fce5c559672..8097a1c8326 100644
--- a/clippy_lints/src/cargo_common_metadata.rs
+++ b/clippy_lints/src/cargo_common_metadata.rs
@@ -20,11 +20,10 @@ declare_clippy_lint! {
     ///
     /// **Example:**
     /// ```toml
-    /// # This `Cargo.toml` is missing an authors field:
+    /// # This `Cargo.toml` is missing a description field:
     /// [package]
     /// name = "clippy"
     /// version = "0.0.212"
-    /// description = "A bunch of helpful lints to avoid common pitfalls in Rust"
     /// repository = "https://github.com/rust-lang/rust-clippy"
     /// readme = "README.md"
     /// license = "MIT OR Apache-2.0"
@@ -32,14 +31,13 @@ declare_clippy_lint! {
     /// categories = ["development-tools", "development-tools::cargo-plugins"]
     /// ```
     ///
-    /// Should include an authors field like:
+    /// Should include a description field like:
     ///
     /// ```toml
     /// # This `Cargo.toml` includes all common metadata
     /// [package]
     /// name = "clippy"
     /// version = "0.0.212"
-    /// authors = ["Someone <someone@rust-lang.org>"]
     /// description = "A bunch of helpful lints to avoid common pitfalls in Rust"
     /// repository = "https://github.com/rust-lang/rust-clippy"
     /// readme = "README.md"
@@ -97,10 +95,6 @@ impl LateLintPass<'_> for CargoCommonMetadata {
             // only run the lint if publish is `None` (`publish = true` or skipped entirely)
             // or if the vector isn't empty (`publish = ["something"]`)
             if package.publish.as_ref().filter(|publish| publish.is_empty()).is_none() || self.ignore_publish {
-                if is_empty_vec(&package.authors) {
-                    missing_warning(cx, &package, "package.authors");
-                }
-
                 if is_empty_str(&package.description) {
                     missing_warning(cx, &package, "package.description");
                 }
diff --git a/tests/ui-cargo/cargo_common_metadata/fail/src/main.stderr b/tests/ui-cargo/cargo_common_metadata/fail/src/main.stderr
index c8ae6c820df..5e9aa8dc36a 100644
--- a/tests/ui-cargo/cargo_common_metadata/fail/src/main.stderr
+++ b/tests/ui-cargo/cargo_common_metadata/fail/src/main.stderr
@@ -1,9 +1,7 @@
-error: package `cargo_common_metadata` is missing `package.authors` metadata
+error: package `cargo_common_metadata` is missing `package.description` metadata
    |
    = note: `-D clippy::cargo-common-metadata` implied by `-D warnings`
 
-error: package `cargo_common_metadata` is missing `package.description` metadata
-
 error: package `cargo_common_metadata` is missing `either package.license or package.license_file` metadata
 
 error: package `cargo_common_metadata` is missing `package.repository` metadata
@@ -14,5 +12,5 @@ error: package `cargo_common_metadata` is missing `package.keywords` metadata
 
 error: package `cargo_common_metadata` is missing `package.categories` metadata
 
-error: aborting due to 7 previous errors
+error: aborting due to 6 previous errors
 
diff --git a/tests/ui-cargo/cargo_common_metadata/fail_publish/src/main.stderr b/tests/ui-cargo/cargo_common_metadata/fail_publish/src/main.stderr
index c8ae6c820df..5e9aa8dc36a 100644
--- a/tests/ui-cargo/cargo_common_metadata/fail_publish/src/main.stderr
+++ b/tests/ui-cargo/cargo_common_metadata/fail_publish/src/main.stderr
@@ -1,9 +1,7 @@
-error: package `cargo_common_metadata` is missing `package.authors` metadata
+error: package `cargo_common_metadata` is missing `package.description` metadata
    |
    = note: `-D clippy::cargo-common-metadata` implied by `-D warnings`
 
-error: package `cargo_common_metadata` is missing `package.description` metadata
-
 error: package `cargo_common_metadata` is missing `either package.license or package.license_file` metadata
 
 error: package `cargo_common_metadata` is missing `package.repository` metadata
@@ -14,5 +12,5 @@ error: package `cargo_common_metadata` is missing `package.keywords` metadata
 
 error: package `cargo_common_metadata` is missing `package.categories` metadata
 
-error: aborting due to 7 previous errors
+error: aborting due to 6 previous errors
 
diff --git a/tests/ui-cargo/cargo_common_metadata/fail_publish_true/src/main.stderr b/tests/ui-cargo/cargo_common_metadata/fail_publish_true/src/main.stderr
index c8ae6c820df..5e9aa8dc36a 100644
--- a/tests/ui-cargo/cargo_common_metadata/fail_publish_true/src/main.stderr
+++ b/tests/ui-cargo/cargo_common_metadata/fail_publish_true/src/main.stderr
@@ -1,9 +1,7 @@
-error: package `cargo_common_metadata` is missing `package.authors` metadata
+error: package `cargo_common_metadata` is missing `package.description` metadata
    |
    = note: `-D clippy::cargo-common-metadata` implied by `-D warnings`
 
-error: package `cargo_common_metadata` is missing `package.description` metadata
-
 error: package `cargo_common_metadata` is missing `either package.license or package.license_file` metadata
 
 error: package `cargo_common_metadata` is missing `package.repository` metadata
@@ -14,5 +12,5 @@ error: package `cargo_common_metadata` is missing `package.keywords` metadata
 
 error: package `cargo_common_metadata` is missing `package.categories` metadata
 
-error: aborting due to 7 previous errors
+error: aborting due to 6 previous errors
 
diff --git a/tests/ui-cargo/cargo_common_metadata/pass/Cargo.toml b/tests/ui-cargo/cargo_common_metadata/pass/Cargo.toml
index 737e84e963c..cb4774d43a2 100644
--- a/tests/ui-cargo/cargo_common_metadata/pass/Cargo.toml
+++ b/tests/ui-cargo/cargo_common_metadata/pass/Cargo.toml
@@ -2,7 +2,6 @@
 name = "cargo_common_metadata"
 version = "0.1.0"
 publish = false
-authors = ["Random person from the Internet <someone@someplace.org>"]
 description = "A test package for the cargo_common_metadata lint"
 repository = "https://github.com/someone/cargo_common_metadata"
 readme = "README.md"
-- 
cgit 1.4.1-3-g733a5


From 6f31ed6c8d97cdd1d50dbbf4c9b2d7e50f5be0b1 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Wed, 31 Mar 2021 16:39:09 -0500
Subject: Use DefIdMap and similar aliases

---
 clippy_lints/src/functions/must_use.rs                 | 12 ++++++------
 clippy_lints/src/functions/not_unsafe_ptr_arg_deref.rs |  7 +++----
 clippy_lints/src/inherent_impl.rs                      |  4 ++--
 clippy_lints/src/len_zero.rs                           |  6 +++---
 clippy_lints/src/loops/utils.rs                        | 10 +++++-----
 clippy_lints/src/loops/while_immutable_condition.rs    | 14 +++++++-------
 clippy_lints/src/matches.rs                            |  6 +++---
 clippy_lints/src/needless_pass_by_value.rs             |  7 ++++---
 clippy_utils/src/hir_utils.rs                          |  6 +++---
 clippy_utils/src/usage.rs                              |  8 ++++----
 10 files changed, 40 insertions(+), 40 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/functions/must_use.rs b/clippy_lints/src/functions/must_use.rs
index 3825699936f..9e943c647fe 100644
--- a/clippy_lints/src/functions/must_use.rs
+++ b/clippy_lints/src/functions/must_use.rs
@@ -1,7 +1,7 @@
 use rustc_ast::ast::Attribute;
-use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Applicability;
-use rustc_hir::{self as hir, def::Res, def_id::DefId, intravisit, QPath};
+use rustc_hir::def_id::DefIdSet;
+use rustc_hir::{self as hir, def::Res, intravisit, QPath};
 use rustc_lint::{LateContext, LintContext};
 use rustc_middle::{
     hir::map::Map,
@@ -169,11 +169,11 @@ fn returns_unit(decl: &hir::FnDecl<'_>) -> bool {
 }
 
 fn has_mutable_arg(cx: &LateContext<'_>, body: &hir::Body<'_>) -> bool {
-    let mut tys = FxHashSet::default();
+    let mut tys = DefIdSet::default();
     body.params.iter().any(|param| is_mutable_pat(cx, &param.pat, &mut tys))
 }
 
-fn is_mutable_pat(cx: &LateContext<'_>, pat: &hir::Pat<'_>, tys: &mut FxHashSet<DefId>) -> bool {
+fn is_mutable_pat(cx: &LateContext<'_>, pat: &hir::Pat<'_>, tys: &mut DefIdSet) -> bool {
     if let hir::PatKind::Wild = pat.kind {
         return false; // ignore `_` patterns
     }
@@ -186,7 +186,7 @@ fn is_mutable_pat(cx: &LateContext<'_>, pat: &hir::Pat<'_>, tys: &mut FxHashSet<
 
 static KNOWN_WRAPPER_TYS: &[&[&str]] = &[&["alloc", "rc", "Rc"], &["std", "sync", "Arc"]];
 
-fn is_mutable_ty<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>, span: Span, tys: &mut FxHashSet<DefId>) -> bool {
+fn is_mutable_ty<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>, span: Span, tys: &mut DefIdSet) -> bool {
     match *ty.kind() {
         // primitive types are never mutable
         ty::Bool | ty::Char | ty::Int(_) | ty::Uint(_) | ty::Float(_) | ty::Str => false,
@@ -222,7 +222,7 @@ impl<'a, 'tcx> intravisit::Visitor<'tcx> for StaticMutVisitor<'a, 'tcx> {
         }
         match expr.kind {
             Call(_, args) | MethodCall(_, _, args, _) => {
-                let mut tys = FxHashSet::default();
+                let mut tys = DefIdSet::default();
                 for arg in args {
                     if self.cx.tcx.has_typeck_results(arg.hir_id.owner.to_def_id())
                         && is_mutable_ty(
diff --git a/clippy_lints/src/functions/not_unsafe_ptr_arg_deref.rs b/clippy_lints/src/functions/not_unsafe_ptr_arg_deref.rs
index ac02b60a356..cc69f4aed0c 100644
--- a/clippy_lints/src/functions/not_unsafe_ptr_arg_deref.rs
+++ b/clippy_lints/src/functions/not_unsafe_ptr_arg_deref.rs
@@ -1,5 +1,4 @@
-use rustc_data_structures::fx::FxHashSet;
-use rustc_hir::{self as hir, intravisit};
+use rustc_hir::{self as hir, intravisit, HirIdSet};
 use rustc_lint::LateContext;
 use rustc_middle::{hir::map::Map, ty};
 
@@ -44,7 +43,7 @@ fn check_raw_ptr(
         let raw_ptrs = iter_input_pats(decl, body)
             .zip(decl.inputs.iter())
             .filter_map(|(arg, ty)| raw_ptr_arg(arg, ty))
-            .collect::<FxHashSet<_>>();
+            .collect::<HirIdSet>();
 
         if !raw_ptrs.is_empty() {
             let typeck_results = cx.tcx.typeck_body(body.id());
@@ -69,7 +68,7 @@ fn raw_ptr_arg(arg: &hir::Param<'_>, ty: &hir::Ty<'_>) -> Option<hir::HirId> {
 
 struct DerefVisitor<'a, 'tcx> {
     cx: &'a LateContext<'tcx>,
-    ptrs: FxHashSet<hir::HirId>,
+    ptrs: HirIdSet,
     typeck_results: &'a ty::TypeckResults<'tcx>,
 }
 
diff --git a/clippy_lints/src/inherent_impl.rs b/clippy_lints/src/inherent_impl.rs
index 5b2e70e3ce9..c31013e49be 100644
--- a/clippy_lints/src/inherent_impl.rs
+++ b/clippy_lints/src/inherent_impl.rs
@@ -2,7 +2,7 @@
 
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::in_macro;
-use rustc_data_structures::fx::FxHashMap;
+use rustc_hir::def_id::DefIdMap;
 use rustc_hir::{def_id, Crate, Impl, Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
@@ -43,7 +43,7 @@ declare_clippy_lint! {
 #[allow(clippy::module_name_repetitions)]
 #[derive(Default)]
 pub struct MultipleInherentImpl {
-    impls: FxHashMap<def_id::DefId, Span>,
+    impls: DefIdMap<Span>,
 }
 
 impl_lint_pass!(MultipleInherentImpl => [MULTIPLE_INHERENT_IMPL]);
diff --git a/clippy_lints/src/len_zero.rs b/clippy_lints/src/len_zero.rs
index fb522be2f1a..78152ad9019 100644
--- a/clippy_lints/src/len_zero.rs
+++ b/clippy_lints/src/len_zero.rs
@@ -3,8 +3,8 @@ use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::{get_item_name, get_parent_as_impl, is_allowed};
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
-use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Applicability;
+use rustc_hir::def_id::DefIdSet;
 use rustc_hir::{
     def_id::DefId, AssocItemKind, BinOpKind, Expr, ExprKind, FnRetTy, ImplItem, ImplItemKind, ImplicitSelfKind, Item,
     ItemKind, Mutability, Node, TraitItemRef, TyKind,
@@ -199,7 +199,7 @@ fn check_trait_items(cx: &LateContext<'_>, visited_trait: &Item<'_>, trait_items
     }
 
     // fill the set with current and super traits
-    fn fill_trait_set(traitt: DefId, set: &mut FxHashSet<DefId>, cx: &LateContext<'_>) {
+    fn fill_trait_set(traitt: DefId, set: &mut DefIdSet, cx: &LateContext<'_>) {
         if set.insert(traitt) {
             for supertrait in rustc_trait_selection::traits::supertrait_def_ids(cx.tcx, traitt) {
                 fill_trait_set(supertrait, set, cx);
@@ -208,7 +208,7 @@ fn check_trait_items(cx: &LateContext<'_>, visited_trait: &Item<'_>, trait_items
     }
 
     if cx.access_levels.is_exported(visited_trait.hir_id()) && trait_items.iter().any(|i| is_named_self(cx, i, "len")) {
-        let mut current_and_super_traits = FxHashSet::default();
+        let mut current_and_super_traits = DefIdSet::default();
         fill_trait_set(visited_trait.def_id.to_def_id(), &mut current_and_super_traits, cx);
 
         let is_empty_method_found = current_and_super_traits
diff --git a/clippy_lints/src/loops/utils.rs b/clippy_lints/src/loops/utils.rs
index bb409c48532..fc287d51249 100644
--- a/clippy_lints/src/loops/utils.rs
+++ b/clippy_lints/src/loops/utils.rs
@@ -1,9 +1,9 @@
 use clippy_utils::ty::{has_iter_method, implements_trait};
 use clippy_utils::{get_parent_expr, is_integer_const, path_to_local, path_to_local_id, sugg};
 use if_chain::if_chain;
-use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_expr, walk_pat, walk_stmt, NestedVisitorMap, Visitor};
+use rustc_hir::HirIdMap;
 use rustc_hir::{BinOpKind, BorrowKind, Expr, ExprKind, HirId, Mutability, Pat, PatKind, Stmt, StmtKind};
 use rustc_lint::LateContext;
 use rustc_middle::hir::map::Map;
@@ -20,9 +20,9 @@ enum IncrementVisitorVarState {
 
 /// Scan a for loop for variables that are incremented exactly once and not used after that.
 pub(super) struct IncrementVisitor<'a, 'tcx> {
-    cx: &'a LateContext<'tcx>,                          // context reference
-    states: FxHashMap<HirId, IncrementVisitorVarState>, // incremented variables
-    depth: u32,                                         // depth of conditional expressions
+    cx: &'a LateContext<'tcx>,                  // context reference
+    states: HirIdMap<IncrementVisitorVarState>, // incremented variables
+    depth: u32,                                 // depth of conditional expressions
     done: bool,
 }
 
@@ -30,7 +30,7 @@ impl<'a, 'tcx> IncrementVisitor<'a, 'tcx> {
     pub(super) fn new(cx: &'a LateContext<'tcx>) -> Self {
         Self {
             cx,
-            states: FxHashMap::default(),
+            states: HirIdMap::default(),
             depth: 0,
             done: false,
         }
diff --git a/clippy_lints/src/loops/while_immutable_condition.rs b/clippy_lints/src/loops/while_immutable_condition.rs
index 7d697b2bf00..de267cc77d2 100644
--- a/clippy_lints/src/loops/while_immutable_condition.rs
+++ b/clippy_lints/src/loops/while_immutable_condition.rs
@@ -3,13 +3,13 @@ use crate::consts::constant;
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::usage::mutated_variables;
 use if_chain::if_chain;
-use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_hir::def::{DefKind, Res};
+use rustc_hir::def_id::DefIdMap;
 use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
-use rustc_hir::{def_id, Expr, ExprKind, HirId, QPath};
+use rustc_hir::HirIdSet;
+use rustc_hir::{Expr, ExprKind, QPath};
 use rustc_lint::LateContext;
 use rustc_middle::hir::map::Map;
-use std::iter::Iterator;
 
 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, cond: &'tcx Expr<'_>, expr: &'tcx Expr<'_>) {
     if constant(cx, cx.typeck_results(), cond).is_some() {
@@ -19,8 +19,8 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, cond: &'tcx Expr<'_>, expr: &'
 
     let mut var_visitor = VarCollectorVisitor {
         cx,
-        ids: FxHashSet::default(),
-        def_ids: FxHashMap::default(),
+        ids: HirIdSet::default(),
+        def_ids: DefIdMap::default(),
         skip: false,
     };
     var_visitor.visit_expr(cond);
@@ -93,8 +93,8 @@ impl<'tcx> Visitor<'tcx> for HasBreakOrReturnVisitor {
 /// All variables definition IDs are collected
 struct VarCollectorVisitor<'a, 'tcx> {
     cx: &'a LateContext<'tcx>,
-    ids: FxHashSet<HirId>,
-    def_ids: FxHashMap<def_id::DefId, bool>,
+    ids: HirIdSet,
+    def_ids: DefIdMap<bool>,
     skip: bool,
 }
 
diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index b13db4cd45c..75999468e28 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -13,13 +13,13 @@ use clippy_utils::{
 use clippy_utils::{paths, search_same, SpanlessEq, SpanlessHash};
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
-use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_errors::Applicability;
 use rustc_hir::def::{CtorKind, DefKind, Res};
 use rustc_hir::{
     self as hir, Arm, BindingAnnotation, Block, BorrowKind, Expr, ExprKind, Guard, HirId, Local, MatchSource,
     Mutability, Node, Pat, PatKind, PathSegment, QPath, RangeEnd, TyKind,
 };
+use rustc_hir::{HirIdMap, HirIdSet};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::{self, Ty, TyS, VariantDef};
@@ -1978,7 +1978,7 @@ fn lint_match_arms<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>) {
             let min_index = usize::min(lindex, rindex);
             let max_index = usize::max(lindex, rindex);
 
-            let mut local_map: FxHashMap<HirId, HirId> = FxHashMap::default();
+            let mut local_map: HirIdMap<HirId> = HirIdMap::default();
             let eq_fallback = |a: &Expr<'_>, b: &Expr<'_>| {
                 if_chain! {
                     if let Some(a_id) = path_to_local(a);
@@ -2062,7 +2062,7 @@ fn pat_contains_local(pat: &Pat<'_>, id: HirId) -> bool {
 }
 
 /// Returns true if all the bindings in the `Pat` are in `ids` and vice versa
-fn bindings_eq(pat: &Pat<'_>, mut ids: FxHashSet<HirId>) -> bool {
+fn bindings_eq(pat: &Pat<'_>, mut ids: HirIdSet) -> bool {
     let mut result = true;
     pat.each_binding_or_first(&mut |_, id, _, _| result &= ids.remove(&id));
     result && ids.is_empty()
diff --git a/clippy_lints/src/needless_pass_by_value.rs b/clippy_lints/src/needless_pass_by_value.rs
index e70c248e87b..7370ba39922 100644
--- a/clippy_lints/src/needless_pass_by_value.rs
+++ b/clippy_lints/src/needless_pass_by_value.rs
@@ -5,10 +5,11 @@ use clippy_utils::ty::{implements_trait, is_copy, is_type_diagnostic_item};
 use clippy_utils::{get_trait_def_id, is_self, paths};
 use if_chain::if_chain;
 use rustc_ast::ast::Attribute;
-use rustc_data_structures::fx::{FxHashMap, FxHashSet};
+use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::{Applicability, DiagnosticBuilder};
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::{BindingAnnotation, Body, FnDecl, GenericArg, HirId, Impl, ItemKind, Node, PatKind, QPath, TyKind};
+use rustc_hir::{HirIdMap, HirIdSet};
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::mir::FakeReadCause;
@@ -310,10 +311,10 @@ fn requires_exact_signature(attrs: &[Attribute]) -> bool {
 
 #[derive(Default)]
 struct MovedVariablesCtxt {
-    moved_vars: FxHashSet<HirId>,
+    moved_vars: HirIdSet,
     /// Spans which need to be prefixed with `*` for dereferencing the
     /// suggested additional reference.
-    spans_need_deref: FxHashMap<HirId, FxHashSet<Span>>,
+    spans_need_deref: HirIdMap<FxHashSet<Span>>,
 }
 
 impl MovedVariablesCtxt {
diff --git a/clippy_utils/src/hir_utils.rs b/clippy_utils/src/hir_utils.rs
index 618d33545a4..0c3b8b89171 100644
--- a/clippy_utils/src/hir_utils.rs
+++ b/clippy_utils/src/hir_utils.rs
@@ -2,9 +2,9 @@ use crate::consts::{constant_context, constant_simple};
 use crate::differing_macro_contexts;
 use crate::source::snippet_opt;
 use rustc_ast::ast::InlineAsmTemplatePiece;
-use rustc_data_structures::fx::FxHashMap;
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
 use rustc_hir::def::Res;
+use rustc_hir::HirIdMap;
 use rustc_hir::{
     BinOpKind, Block, BlockCheckMode, BodyId, BorrowKind, CaptureBy, Expr, ExprField, ExprKind, FnRetTy, GenericArg,
     GenericArgs, Guard, HirId, InlineAsmOperand, Lifetime, LifetimeName, ParamName, Pat, PatField, PatKind, Path,
@@ -61,7 +61,7 @@ impl<'a, 'tcx> SpanlessEq<'a, 'tcx> {
     fn inter_expr(&mut self) -> HirEqInterExpr<'_, 'a, 'tcx> {
         HirEqInterExpr {
             inner: self,
-            locals: FxHashMap::default(),
+            locals: HirIdMap::default(),
         }
     }
 
@@ -88,7 +88,7 @@ struct HirEqInterExpr<'a, 'b, 'tcx> {
     // When binding are declared, the binding ID in the left expression is mapped to the one on the
     // right. For example, when comparing `{ let x = 1; x + 2 }` and `{ let y = 1; y + 2 }`,
     // these blocks are considered equal since `x` is mapped to `y`.
-    locals: FxHashMap<HirId, HirId>,
+    locals: HirIdMap<HirId>,
 }
 
 impl HirEqInterExpr<'_, '_, '_> {
diff --git a/clippy_utils/src/usage.rs b/clippy_utils/src/usage.rs
index 54f110988d7..650b70c63af 100644
--- a/clippy_utils/src/usage.rs
+++ b/clippy_utils/src/usage.rs
@@ -1,9 +1,9 @@
 use crate as utils;
-use rustc_data_structures::fx::FxHashSet;
 use rustc_hir as hir;
 use rustc_hir::def::Res;
 use rustc_hir::intravisit;
 use rustc_hir::intravisit::{NestedVisitorMap, Visitor};
+use rustc_hir::HirIdSet;
 use rustc_hir::{Expr, ExprKind, HirId, Path};
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::LateContext;
@@ -13,9 +13,9 @@ use rustc_middle::ty;
 use rustc_typeck::expr_use_visitor::{ConsumeMode, Delegate, ExprUseVisitor, PlaceBase, PlaceWithHirId};
 
 /// Returns a set of mutated local variable IDs, or `None` if mutations could not be determined.
-pub fn mutated_variables<'tcx>(expr: &'tcx Expr<'_>, cx: &LateContext<'tcx>) -> Option<FxHashSet<HirId>> {
+pub fn mutated_variables<'tcx>(expr: &'tcx Expr<'_>, cx: &LateContext<'tcx>) -> Option<HirIdSet> {
     let mut delegate = MutVarsDelegate {
-        used_mutably: FxHashSet::default(),
+        used_mutably: HirIdSet::default(),
         skip: false,
     };
     cx.tcx.infer_ctxt().enter(|infcx| {
@@ -44,7 +44,7 @@ pub fn is_potentially_mutated<'tcx>(variable: &'tcx Path<'_>, expr: &'tcx Expr<'
 }
 
 struct MutVarsDelegate {
-    used_mutably: FxHashSet<HirId>,
+    used_mutably: HirIdSet,
     skip: bool,
 }
 
-- 
cgit 1.4.1-3-g733a5


From 2f81e4e34f96ee674072cbd1ffe55b68da5cc425 Mon Sep 17 00:00:00 2001
From: Aliénore Bouttefeux <alienore.bouttefeux@gmail.com>
Date: Sun, 4 Apr 2021 13:03:05 +0200
Subject: modification not working: fixing

---
 clippy_lints/src/doc.rs   | 5 +++++
 clippy_utils/src/lib.rs   | 2 --
 clippy_utils/src/paths.rs | 1 -
 3 files changed, 5 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/doc.rs b/clippy_lints/src/doc.rs
index 69800f9d331..ea4f4fda0dd 100644
--- a/clippy_lints/src/doc.rs
+++ b/clippy_lints/src/doc.rs
@@ -721,6 +721,11 @@ impl<'a, 'tcx> Visitor<'tcx> for FindPanicUnwrap<'a, 'tcx> {
             }
         }
 
+        // check for `assert_eq` or `assert_ne`
+        if is_expn_of(expr.span, "assert_eq").is_some() || is_expn_of(expr.span, "assert_ne").is_some() {
+            self.panic_span = Some(expr.span);
+        }
+
         // check for `unwrap`
         if let Some(arglists) = method_chain_args(expr, &["unwrap"]) {
             let reciever_ty = self.typeck_results.expr_ty(&arglists[0][0]).peel_refs();
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index aade3409ebe..d6364625e70 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -1172,7 +1172,6 @@ pub fn match_panic_call<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> O
         .or_else(|| match_function_call(cx, expr, &paths::PANICKING_PANIC))
         .or_else(|| match_function_call(cx, expr, &paths::PANICKING_PANIC_FMT))
         .or_else(|| match_function_call(cx, expr, &paths::PANICKING_PANIC_STR))
-        .or_else(|| match_function_call(cx, expr, &paths::PANICKING_ASSERT_FAILED_INNER))
 }
 
 pub fn match_panic_def_id(cx: &LateContext<'_>, did: DefId) -> bool {
@@ -1182,7 +1181,6 @@ pub fn match_panic_def_id(cx: &LateContext<'_>, did: DefId) -> bool {
         || match_def_path(cx, did, &paths::PANICKING_PANIC)
         || match_def_path(cx, did, &paths::PANICKING_PANIC_FMT)
         || match_def_path(cx, did, &paths::PANICKING_PANIC_STR)
-        || match_def_path(cx, did, &paths::PANICKING_ASSERT_FAILED_INNER)
 }
 
 /// Returns the list of condition expressions and the list of blocks in a
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index 287da83babd..7c83a9fe4e2 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -86,7 +86,6 @@ pub const OPTION_SOME: [&str; 4] = ["core", "option", "Option", "Some"];
 pub const ORD: [&str; 3] = ["core", "cmp", "Ord"];
 pub const OS_STRING_AS_OS_STR: [&str; 5] = ["std", "ffi", "os_str", "OsString", "as_os_str"];
 pub const OS_STR_TO_OS_STRING: [&str; 5] = ["std", "ffi", "os_str", "OsStr", "to_os_string"];
-pub(super) const PANICKING_ASSERT_FAILED_INNER: [&str; 3] = ["core", "panicking", "assert_failed_inner"];
 pub(super) const PANICKING_PANIC: [&str; 3] = ["core", "panicking", "panic"];
 pub(super) const PANICKING_PANIC_FMT: [&str; 3] = ["core", "panicking", "panic_fmt"];
 pub(super) const PANICKING_PANIC_STR: [&str; 3] = ["core", "panicking", "panic_str"];
-- 
cgit 1.4.1-3-g733a5


From 81dfb9ecfb13f67a56176bd82c846530858b8ef5 Mon Sep 17 00:00:00 2001
From: ThibsG <thibsg@pm.me>
Date: Sun, 4 Apr 2021 14:21:02 +0200
Subject: Check path imports per module

---
 clippy_lints/src/lib.rs                           |   2 +-
 clippy_lints/src/single_component_path_imports.rs | 150 +++++++++++-----------
 tests/ui/single_component_path_imports.fixed      |   7 +
 tests/ui/single_component_path_imports.rs         |   7 +
 tests/ui/single_component_path_imports.stderr     |  12 +-
 5 files changed, 96 insertions(+), 82 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 97557fefe3e..f013613119c 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1232,7 +1232,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_early_pass(|| box as_conversions::AsConversions);
     store.register_late_pass(|| box let_underscore::LetUnderscore);
     store.register_late_pass(|| box atomic_ordering::AtomicOrdering);
-    store.register_early_pass(|| box single_component_path_imports::SingleComponentPathImports::default());
+    store.register_early_pass(|| box single_component_path_imports::SingleComponentPathImports);
     let max_fn_params_bools = conf.max_fn_params_bools;
     let max_struct_bools = conf.max_struct_bools;
     store.register_early_pass(move || box excessive_bools::ExcessiveBools::new(max_struct_bools, max_fn_params_bools));
diff --git a/clippy_lints/src/single_component_path_imports.rs b/clippy_lints/src/single_component_path_imports.rs
index 901f7642a12..adf0d7998f8 100644
--- a/clippy_lints/src/single_component_path_imports.rs
+++ b/clippy_lints/src/single_component_path_imports.rs
@@ -1,12 +1,10 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::in_macro;
-use rustc_ast::{Crate, Item, ItemKind, ModKind, UseTreeKind};
+use rustc_ast::{ptr::P, Crate, Item, ItemKind, ModKind, UseTreeKind};
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::edition::Edition;
-use rustc_span::symbol::kw;
-use rustc_span::{Span, Symbol};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::{edition::Edition, symbol::kw, Span, Symbol};
 
 declare_clippy_lint! {
     /// **What it does:** Checking for imports with single component use path.
@@ -36,94 +34,96 @@ declare_clippy_lint! {
     "imports with single component path are redundant"
 }
 
-#[derive(Default)]
-pub struct SingleComponentPathImports {
-    /// keep track of imports reused with `self` keyword,
-    /// such as `self::crypto_hash` in the example below
-    ///
-    /// ```rust,ignore
-    /// use self::crypto_hash::{Algorithm, Hasher};
-    /// ```
-    imports_reused_with_self: Vec<Symbol>,
-    /// keep track of single use statements
-    /// such as `crypto_hash` in the example below
-    ///
-    /// ```rust,ignore
-    /// use crypto_hash;
-    /// ```
-    single_use_usages: Vec<(Symbol, Span)>,
-}
-
-impl_lint_pass!(SingleComponentPathImports => [SINGLE_COMPONENT_PATH_IMPORTS]);
+declare_lint_pass!(SingleComponentPathImports => [SINGLE_COMPONENT_PATH_IMPORTS]);
 
 impl EarlyLintPass for SingleComponentPathImports {
     fn check_crate(&mut self, cx: &EarlyContext<'_>, krate: &Crate) {
         if cx.sess.opts.edition < Edition::Edition2018 {
             return;
         }
-        for item in &krate.items {
-            self.track_uses(&item);
-        }
-        for single_use in &self.single_use_usages {
-            if !self.imports_reused_with_self.contains(&single_use.0) {
-                span_lint_and_sugg(
-                    cx,
-                    SINGLE_COMPONENT_PATH_IMPORTS,
-                    single_use.1,
-                    "this import is redundant",
-                    "remove it entirely",
-                    String::new(),
-                    Applicability::MachineApplicable,
-                );
-            }
-        }
+        check_mod(cx, &krate.items);
     }
 }
 
-impl SingleComponentPathImports {
-    fn track_uses(&mut self, item: &Item) {
-        if in_macro(item.span) || item.vis.kind.is_pub() {
-            return;
+fn check_mod(cx: &EarlyContext<'_>, items: &[P<Item>]) {
+    // keep track of imports reused with `self` keyword,
+    // such as `self::crypto_hash` in the example below
+    // ```rust,ignore
+    // use self::crypto_hash::{Algorithm, Hasher};
+    // ```
+    let mut imports_reused_with_self = Vec::new();
+
+    // keep track of single use statements
+    // such as `crypto_hash` in the example below
+    // ```rust,ignore
+    // use crypto_hash;
+    // ```
+    let mut single_use_usages = Vec::new();
+
+    for item in items {
+        track_uses(cx, &item, &mut imports_reused_with_self, &mut single_use_usages);
+    }
+
+    for single_use in &single_use_usages {
+        if !imports_reused_with_self.contains(&single_use.0) {
+            span_lint_and_sugg(
+                cx,
+                SINGLE_COMPONENT_PATH_IMPORTS,
+                single_use.1,
+                "this import is redundant",
+                "remove it entirely",
+                String::new(),
+                Applicability::MachineApplicable,
+            );
         }
+    }
+}
+
+fn track_uses(
+    cx: &EarlyContext<'_>,
+    item: &Item,
+    imports_reused_with_self: &mut Vec<Symbol>,
+    single_use_usages: &mut Vec<(Symbol, Span)>,
+) {
+    if in_macro(item.span) || item.vis.kind.is_pub() {
+        return;
+    }
+
+    match &item.kind {
+        ItemKind::Mod(_, ModKind::Loaded(ref items, ..)) => {
+            check_mod(cx, &items);
+        },
+        ItemKind::Use(use_tree) => {
+            let segments = &use_tree.prefix.segments;
 
-        match &item.kind {
-            ItemKind::Mod(_, ModKind::Loaded(ref items, ..)) => {
-                for item in items.iter() {
-                    self.track_uses(&item);
+            // keep track of `use some_module;` usages
+            if segments.len() == 1 {
+                if let UseTreeKind::Simple(None, _, _) = use_tree.kind {
+                    let ident = &segments[0].ident;
+                    single_use_usages.push((ident.name, item.span));
                 }
-            },
-            ItemKind::Use(use_tree) => {
-                let segments = &use_tree.prefix.segments;
+                return;
+            }
 
-                // keep track of `use some_module;` usages
-                if segments.len() == 1 {
-                    if let UseTreeKind::Simple(None, _, _) = use_tree.kind {
-                        let ident = &segments[0].ident;
-                        self.single_use_usages.push((ident.name, item.span));
-                    }
+            // keep track of `use self::some_module` usages
+            if segments[0].ident.name == kw::SelfLower {
+                // simple case such as `use self::module::SomeStruct`
+                if segments.len() > 1 {
+                    imports_reused_with_self.push(segments[1].ident.name);
                     return;
                 }
 
-                // keep track of `use self::some_module` usages
-                if segments[0].ident.name == kw::SelfLower {
-                    // simple case such as `use self::module::SomeStruct`
-                    if segments.len() > 1 {
-                        self.imports_reused_with_self.push(segments[1].ident.name);
-                        return;
-                    }
-
-                    // nested case such as `use self::{module1::Struct1, module2::Struct2}`
-                    if let UseTreeKind::Nested(trees) = &use_tree.kind {
-                        for tree in trees {
-                            let segments = &tree.0.prefix.segments;
-                            if !segments.is_empty() {
-                                self.imports_reused_with_self.push(segments[0].ident.name);
-                            }
+                // nested case such as `use self::{module1::Struct1, module2::Struct2}`
+                if let UseTreeKind::Nested(trees) = &use_tree.kind {
+                    for tree in trees {
+                        let segments = &tree.0.prefix.segments;
+                        if !segments.is_empty() {
+                            imports_reused_with_self.push(segments[0].ident.name);
                         }
                     }
                 }
-            },
-            _ => {},
-        }
+            }
+        },
+        _ => {},
     }
 }
diff --git a/tests/ui/single_component_path_imports.fixed b/tests/ui/single_component_path_imports.fixed
index 226d2b315d7..f66b445b7b6 100644
--- a/tests/ui/single_component_path_imports.fixed
+++ b/tests/ui/single_component_path_imports.fixed
@@ -25,3 +25,10 @@ mod hello_mod {
     #[allow(dead_code)]
     fn hello_mod() {}
 }
+
+mod hi_mod {
+    use self::regex::{Regex, RegexSet};
+    use regex;
+    #[allow(dead_code)]
+    fn hi_mod() {}
+}
diff --git a/tests/ui/single_component_path_imports.rs b/tests/ui/single_component_path_imports.rs
index 88bf7f1fc5a..09d48658595 100644
--- a/tests/ui/single_component_path_imports.rs
+++ b/tests/ui/single_component_path_imports.rs
@@ -25,3 +25,10 @@ mod hello_mod {
     #[allow(dead_code)]
     fn hello_mod() {}
 }
+
+mod hi_mod {
+    use self::regex::{Regex, RegexSet};
+    use regex;
+    #[allow(dead_code)]
+    fn hi_mod() {}
+}
diff --git a/tests/ui/single_component_path_imports.stderr b/tests/ui/single_component_path_imports.stderr
index 646e6d3647a..7005fa8f125 100644
--- a/tests/ui/single_component_path_imports.stderr
+++ b/tests/ui/single_component_path_imports.stderr
@@ -1,16 +1,16 @@
 error: this import is redundant
-  --> $DIR/single_component_path_imports.rs:6:1
+  --> $DIR/single_component_path_imports.rs:24:5
    |
-LL | use regex;
-   | ^^^^^^^^^^ help: remove it entirely
+LL |     use regex;
+   |     ^^^^^^^^^^ help: remove it entirely
    |
    = note: `-D clippy::single-component-path-imports` implied by `-D warnings`
 
 error: this import is redundant
-  --> $DIR/single_component_path_imports.rs:24:5
+  --> $DIR/single_component_path_imports.rs:6:1
    |
-LL |     use regex;
-   |     ^^^^^^^^^^ help: remove it entirely
+LL | use regex;
+   | ^^^^^^^^^^ help: remove it entirely
 
 error: aborting due to 2 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From a00de90cebedbf24e0cb75ca347f1752335aedca Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Mon, 5 Apr 2021 00:09:13 -0400
Subject: Fix ICE in `missing_panics_doc`

---
 clippy_lints/src/doc.rs |  5 ++++-
 tests/ui/doc.rs         | 21 +++++++++++++++++++--
 2 files changed, 23 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/doc.rs b/clippy_lints/src/doc.rs
index 69800f9d331..69d47850091 100644
--- a/clippy_lints/src/doc.rs
+++ b/clippy_lints/src/doc.rs
@@ -11,7 +11,7 @@ use rustc_errors::emitter::EmitterWriter;
 use rustc_errors::Handler;
 use rustc_hir as hir;
 use rustc_hir::intravisit::{self, NestedVisitorMap, Visitor};
-use rustc_hir::{Expr, ExprKind, QPath};
+use rustc_hir::{AnonConst, Expr, ExprKind, QPath};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::map::Map;
 use rustc_middle::lint::in_external_macro;
@@ -735,6 +735,9 @@ impl<'a, 'tcx> Visitor<'tcx> for FindPanicUnwrap<'a, 'tcx> {
         intravisit::walk_expr(self, expr);
     }
 
+    // Panics in const blocks will cause compilation to fail.
+    fn visit_anon_const(&mut self, _: &'tcx AnonConst) {}
+
     fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
         NestedVisitorMap::OnlyBodies(self.cx.tcx.hir())
     }
diff --git a/tests/ui/doc.rs b/tests/ui/doc.rs
index d2c666bd290..c946a047f1b 100644
--- a/tests/ui/doc.rs
+++ b/tests/ui/doc.rs
@@ -1,8 +1,8 @@
 //! This file tests for the `DOC_MARKDOWN` lint.
 
-#![allow(dead_code)]
+#![allow(dead_code, incomplete_features)]
 #![warn(clippy::doc_markdown)]
-#![feature(custom_inner_attributes)]
+#![feature(custom_inner_attributes, const_generics, const_evaluatable_checked, const_option)]
 #![rustfmt::skip]
 
 /// The foo_bar function does _nothing_. See also foo::bar. (note the dot there)
@@ -202,3 +202,20 @@ fn issue_2343() {}
 /// This should not cause an ICE:
 /// __|_ _|__||_|
 fn pulldown_cmark_crash() {}
+
+// issue #7033 - const_evaluatable_checked ICE
+struct S<T, const N: usize>
+where [(); N.checked_next_power_of_two().unwrap()]: {
+    arr: [T; N.checked_next_power_of_two().unwrap()],
+    n: usize,
+}
+
+impl<T: Copy + Default, const N: usize> S<T, N>
+where [(); N.checked_next_power_of_two().unwrap()]: {
+    fn new() -> Self {
+        Self {
+            arr: [T::default(); N.checked_next_power_of_two().unwrap()],
+            n: 0,
+        }
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From d1df73228a7cdadb4d635c6ed77daeeaebbe10ff Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Fri, 11 Dec 2020 22:29:53 +0000
Subject: A new lint for shared code in if blocks

* Added expression check for shared_code_in_if_blocks
* Finishing touches for the shared_code_in_if_blocks lint
* Applying PR suggestions
* Update lints yay
* Moved test into subfolder
---
 CHANGELOG.md                                       |   1 +
 clippy_lints/src/copies.rs                         | 305 +++++++++++++++++++--
 clippy_lints/src/lib.rs                            |   2 +
 clippy_lints/src/literal_representation.rs         |  40 ++-
 .../src/methods/manual_saturating_arithmetic.rs    |  48 ++--
 clippy_utils/src/hir_utils.rs                      |   9 +
 tests/ui/checked_unwrap/complex_conditionals.rs    |   2 +-
 tests/ui/if_same_then_else.rs                      |   3 +-
 tests/ui/if_same_then_else.stderr                  |  88 +++---
 tests/ui/if_same_then_else2.rs                     |   3 +-
 tests/ui/if_same_then_else2.stderr                 |  80 +++---
 tests/ui/let_if_seq.rs                             |   3 +-
 tests/ui/let_if_seq.stderr                         |   8 +-
 tests/ui/shared_code_in_if_blocks/shared_at_bot.rs |  47 ++++
 tests/ui/shared_code_in_if_blocks/shared_at_top.rs |  83 ++++++
 .../shared_at_top_and_bot.rs                       |  22 ++
 .../ui/shared_code_in_if_blocks/valid_if_blocks.rs | 157 +++++++++++
 17 files changed, 737 insertions(+), 164 deletions(-)
 create mode 100644 tests/ui/shared_code_in_if_blocks/shared_at_bot.rs
 create mode 100644 tests/ui/shared_code_in_if_blocks/shared_at_top.rs
 create mode 100644 tests/ui/shared_code_in_if_blocks/shared_at_top_and_bot.rs
 create mode 100644 tests/ui/shared_code_in_if_blocks/valid_if_blocks.rs

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index fb4a0b500f2..790bca4ac18 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2455,6 +2455,7 @@ Released 2018-09-13
 [`shadow_reuse`]: https://rust-lang.github.io/rust-clippy/master/index.html#shadow_reuse
 [`shadow_same`]: https://rust-lang.github.io/rust-clippy/master/index.html#shadow_same
 [`shadow_unrelated`]: https://rust-lang.github.io/rust-clippy/master/index.html#shadow_unrelated
+[`shared_code_in_if_blocks`]: https://rust-lang.github.io/rust-clippy/master/index.html#shared_code_in_if_blocks
 [`short_circuit_statement`]: https://rust-lang.github.io/rust-clippy/master/index.html#short_circuit_statement
 [`should_assert_eq`]: https://rust-lang.github.io/rust-clippy/master/index.html#should_assert_eq
 [`should_implement_trait`]: https://rust-lang.github.io/rust-clippy/master/index.html#should_implement_trait
diff --git a/clippy_lints/src/copies.rs b/clippy_lints/src/copies.rs
index 46093a16571..29ff1970705 100644
--- a/clippy_lints/src/copies.rs
+++ b/clippy_lints/src/copies.rs
@@ -3,7 +3,10 @@ use clippy_utils::{eq_expr_value, in_macro, search_same, SpanlessEq, SpanlessHas
 use clippy_utils::{get_parent_expr, if_sequence};
 use rustc_hir::{Block, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::hir::map::Map;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::source_map::Span;
+use std::borrow::Cow;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for consecutive `if`s with the same condition.
@@ -104,7 +107,45 @@ declare_clippy_lint! {
     "`if` with the same `then` and `else` blocks"
 }
 
-declare_lint_pass!(CopyAndPaste => [IFS_SAME_COND, SAME_FUNCTIONS_IN_IF_CONDITION, IF_SAME_THEN_ELSE]);
+declare_clippy_lint! {
+    /// **What it does:** Checks if the `if` and `else` block contain shared code that can be
+    /// moved out of the blocks.
+    ///
+    /// **Why is this bad?** Duplicate code is less maintainable.
+    ///
+    /// **Known problems:** Hopefully none.
+    ///
+    /// **Example:**
+    /// ```ignore
+    /// let foo = if … {
+    ///     println!("Hello World");
+    ///     13
+    /// } else {
+    ///     println!("Hello World");
+    ///     42
+    /// };
+    /// ```
+    ///
+    /// Could be written as:
+    /// ```ignore
+    /// println!("Hello World");
+    /// let foo = if … {
+    ///     13
+    /// } else {
+    ///     42
+    /// };
+    /// ```
+    pub SHARED_CODE_IN_IF_BLOCKS,
+    pedantic,
+    "`if` statement with shared code in all blocks"
+}
+
+declare_lint_pass!(CopyAndPaste => [
+    IFS_SAME_COND,
+    SAME_FUNCTIONS_IN_IF_CONDITION,
+    IF_SAME_THEN_ELSE,
+    SHARED_CODE_IN_IF_BLOCKS
+]);
 
 impl<'tcx> LateLintPass<'tcx> for CopyAndPaste {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
@@ -121,30 +162,256 @@ impl<'tcx> LateLintPass<'tcx> for CopyAndPaste {
             }
 
             let (conds, blocks) = if_sequence(expr);
-            lint_same_then_else(cx, &blocks);
+            // Conditions
             lint_same_cond(cx, &conds);
             lint_same_fns_in_if_cond(cx, &conds);
+            // Block duplication
+            lint_same_then_else(cx, &blocks, conds.len() != blocks.len(), expr);
         }
     }
 }
 
-/// Implementation of `IF_SAME_THEN_ELSE`.
-fn lint_same_then_else(cx: &LateContext<'_>, blocks: &[&Block<'_>]) {
-    let eq: &dyn Fn(&&Block<'_>, &&Block<'_>) -> bool =
-        &|&lhs, &rhs| -> bool { SpanlessEq::new(cx).eq_block(lhs, rhs) };
+/// Implementation of `SHARED_CODE_IN_IF_BLOCKS` and `IF_SAME_THEN_ELSE` if the blocks are equal.
+fn lint_same_then_else<'tcx>(
+    cx: &LateContext<'tcx>,
+    blocks: &[&Block<'tcx>],
+    has_unconditional_else: bool,
+    expr: &'tcx Expr<'_>,
+) {
+    // We only lint ifs with multiple blocks
+    // TODO xFrednet 2021-01-01: Check if it's an else if block
+    if blocks.len() < 2 {
+        return;
+    }
 
-    if let Some((i, j)) = search_same_sequenced(blocks, eq) {
-        span_lint_and_note(
+    let has_expr = blocks[0].expr.is_some();
+
+    // Check if each block has shared code
+    let mut start_eq = usize::MAX;
+    let mut end_eq = usize::MAX;
+    let mut expr_eq = true;
+    for (index, win) in blocks.windows(2).enumerate() {
+        let l_stmts = win[0].stmts;
+        let r_stmts = win[1].stmts;
+
+        let mut evaluator = SpanlessEq::new(cx);
+        let current_start_eq = count_eq(&mut l_stmts.iter(), &mut r_stmts.iter(), |l, r| evaluator.eq_stmt(l, r));
+        let current_end_eq = count_eq(&mut l_stmts.iter().rev(), &mut r_stmts.iter().rev(), |l, r| {
+            evaluator.eq_stmt(l, r)
+        });
+        let block_expr_eq = both(&win[0].expr, &win[1].expr, |l, r| evaluator.eq_expr(l, r));
+
+        // IF_SAME_THEN_ELSE
+        // We only lint the first two blocks (index == 0). Further blocks will be linted when that if
+        // statement is checked
+        if index == 0 && block_expr_eq && l_stmts.len() == r_stmts.len() && l_stmts.len() == current_start_eq {
+            span_lint_and_note(
+                cx,
+                IF_SAME_THEN_ELSE,
+                win[0].span,
+                "this `if` has identical blocks",
+                Some(win[1].span),
+                "same as this",
+            );
+
+            return;
+        }
+
+        start_eq = start_eq.min(current_start_eq);
+        end_eq = end_eq.min(current_end_eq);
+        expr_eq &= block_expr_eq;
+
+        // We can return if the eq count is 0 from both sides or if it has no unconditional else case
+        if !has_unconditional_else || (start_eq == 0 && end_eq == 0 && (has_expr && !expr_eq)) {
+            return;
+        }
+    }
+
+    if has_expr && !expr_eq {
+        end_eq = 0;
+    }
+
+    // Check if the regions are overlapping. Set `end_eq` to prevent the overlap
+    let min_block_size = blocks.iter().map(|x| x.stmts.len()).min().unwrap();
+    if (start_eq + end_eq) > min_block_size {
+        end_eq = min_block_size - start_eq;
+    }
+
+    // Only the start is the same
+    if start_eq != 0 && end_eq == 0 && (!has_expr || !expr_eq) {
+        emit_shared_code_in_if_blocks_lint(cx, start_eq, 0, false, blocks, expr);
+    } else if end_eq != 0 && (!has_expr || !expr_eq) {
+        let block = blocks[blocks.len() - 1];
+        let stmts = block.stmts.split_at(start_eq).1;
+        let (block_stmts, moved_stmts) = stmts.split_at(stmts.len() - end_eq);
+
+        // Scan block
+        let mut walker = SymbolFinderVisitor::new(cx);
+        for stmt in block_stmts {
+            intravisit::walk_stmt(&mut walker, stmt);
+        }
+        let mut block_defs = walker.defs;
+
+        // Scan moved stmts
+        let mut moved_start: Option<usize> = None;
+        let mut walker = SymbolFinderVisitor::new(cx);
+        for (index, stmt) in moved_stmts.iter().enumerate() {
+            intravisit::walk_stmt(&mut walker, stmt);
+
+            for value in &walker.uses {
+                // Well we can't move this and all prev statements. So reset
+                if block_defs.contains(&value) {
+                    moved_start = Some(index + 1);
+                    walker.defs.drain().for_each(|x| {
+                        block_defs.insert(x);
+                    });
+                }
+            }
+
+            walker.uses.clear();
+        }
+
+        if let Some(moved_start) = moved_start {
+            end_eq -= moved_start;
+        }
+
+        let mut end_linable = true;
+        if let Some(expr) = block.expr {
+            intravisit::walk_expr(&mut walker, expr);
+            end_linable = walker.uses.iter().any(|x| !block_defs.contains(x));
+        }
+
+        emit_shared_code_in_if_blocks_lint(cx, start_eq, end_eq, end_linable, blocks, expr);
+    }
+}
+
+fn emit_shared_code_in_if_blocks_lint(
+    cx: &LateContext<'tcx>,
+    start_stmts: usize,
+    end_stmts: usize,
+    lint_end: bool,
+    blocks: &[&Block<'tcx>],
+    if_expr: &'tcx Expr<'_>,
+) {
+    if start_stmts == 0 && !lint_end {
+        return;
+    }
+
+    // (help, span, suggestion)
+    let mut suggestions: Vec<(&str, Span, String)> = vec![];
+
+    if start_stmts > 0 {
+        let block = blocks[0];
+        let span_start = first_line_of_span(cx, if_expr.span).shrink_to_lo();
+        let span_end = block.stmts[start_stmts - 1].span.source_callsite();
+
+        let cond_span = first_line_of_span(cx, if_expr.span).until(block.span);
+        let cond_snippet = reindent_multiline(snippet(cx, cond_span, "_"), false, None);
+        let cond_indent = indent_of(cx, cond_span);
+        let moved_span = block.stmts[0].span.source_callsite().to(span_end);
+        let moved_snippet = reindent_multiline(snippet(cx, moved_span, "_"), true, None);
+        let suggestion = moved_snippet.to_string() + "\n" + &cond_snippet + "{";
+        let suggestion = reindent_multiline(Cow::Borrowed(&suggestion), true, cond_indent);
+
+        let span = span_start.to(span_end);
+        suggestions.push(("START HELP", span, suggestion.to_string()));
+    }
+
+    if lint_end {
+        let block = blocks[blocks.len() - 1];
+        let span_end = block.span.shrink_to_hi();
+
+        let moved_start = if end_stmts == 0 && block.expr.is_some() {
+            block.expr.unwrap().span
+        } else {
+            block.stmts[block.stmts.len() - end_stmts].span
+        }
+        .source_callsite();
+        let moved_end = if let Some(expr) = block.expr {
+            expr.span
+        } else {
+            block.stmts[block.stmts.len() - 1].span
+        }
+        .source_callsite();
+
+        let moved_span = moved_start.to(moved_end);
+        let moved_snipped = reindent_multiline(snippet(cx, moved_span, "_"), true, None);
+        let indent = indent_of(cx, if_expr.span.shrink_to_hi());
+        let suggestion = "}\n".to_string() + &moved_snipped;
+        let suggestion = reindent_multiline(Cow::Borrowed(&suggestion), true, indent);
+
+        let span = moved_start.to(span_end);
+        suggestions.push(("END_RANGE", span, suggestion.to_string()));
+    }
+
+    if suggestions.len() == 1 {
+        let (_, span, sugg) = &suggestions[0];
+        span_lint_and_sugg(
             cx,
-            IF_SAME_THEN_ELSE,
-            j.span,
-            "this `if` has identical blocks",
-            Some(i.span),
-            "same as this",
+            SHARED_CODE_IN_IF_BLOCKS,
+            *span,
+            "All code blocks contain the same code",
+            "Consider moving the code out like this",
+            sugg.clone(),
+            Applicability::Unspecified,
+        );
+    } else {
+        span_lint_and_then(
+            cx,
+            SHARED_CODE_IN_IF_BLOCKS,
+            if_expr.span,
+            "All if blocks contain the same code",
+            move |diag| {
+                for (help, span, sugg) in suggestions {
+                    diag.span_suggestion(span, help, sugg, Applicability::Unspecified);
+                }
+            },
         );
     }
 }
 
+pub struct SymbolFinderVisitor<'a, 'tcx> {
+    cx: &'a LateContext<'tcx>,
+    defs: FxHashSet<HirId>,
+    uses: FxHashSet<HirId>,
+}
+
+impl<'a, 'tcx> SymbolFinderVisitor<'a, 'tcx> {
+    fn new(cx: &'a LateContext<'tcx>) -> Self {
+        SymbolFinderVisitor {
+            cx,
+            defs: FxHashSet::default(),
+            uses: FxHashSet::default(),
+        }
+    }
+}
+
+impl<'a, 'tcx> Visitor<'tcx> for SymbolFinderVisitor<'a, 'tcx> {
+    type Map = Map<'tcx>;
+
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::All(self.cx.tcx.hir())
+    }
+
+    fn visit_local(&mut self, l: &'tcx rustc_hir::Local<'tcx>) {
+        let local_id = l.pat.hir_id;
+        self.defs.insert(local_id);
+        if let Some(expr) = l.init {
+            intravisit::walk_expr(self, expr);
+        }
+    }
+
+    fn visit_qpath(&mut self, qpath: &'tcx rustc_hir::QPath<'tcx>, id: HirId, _span: rustc_span::Span) {
+        if let rustc_hir::QPath::Resolved(_, ref path) = *qpath {
+            if path.segments.len() == 1 {
+                if let rustc_hir::def::Res::Local(var) = self.cx.qpath_res(qpath, id) {
+                    self.uses.insert(var);
+                }
+            }
+        }
+    }
+}
+
 /// Implementation of `IFS_SAME_COND`.
 fn lint_same_cond(cx: &LateContext<'_>, conds: &[&Expr<'_>]) {
     let hash: &dyn Fn(&&Expr<'_>) -> u64 = &|expr| -> u64 {
@@ -198,15 +465,3 @@ fn lint_same_fns_in_if_cond(cx: &LateContext<'_>, conds: &[&Expr<'_>]) {
         );
     }
 }
-
-fn search_same_sequenced<T, Eq>(exprs: &[T], eq: Eq) -> Option<(&T, &T)>
-where
-    Eq: Fn(&T, &T) -> bool,
-{
-    for win in exprs.windows(2) {
-        if eq(&win[0], &win[1]) {
-            return Some((&win[0], &win[1]));
-        }
-    }
-    None
-}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index b93e6b5b2e8..ba98a2a2607 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -616,6 +616,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &copies::IFS_SAME_COND,
         &copies::IF_SAME_THEN_ELSE,
         &copies::SAME_FUNCTIONS_IN_IF_CONDITION,
+        &copies::SHARED_CODE_IN_IF_BLOCKS,
         &copy_iterator::COPY_ITERATOR,
         &create_dir::CREATE_DIR,
         &dbg_macro::DBG_MACRO,
@@ -1365,6 +1366,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&casts::PTR_AS_PTR),
         LintId::of(&checked_conversions::CHECKED_CONVERSIONS),
         LintId::of(&copies::SAME_FUNCTIONS_IN_IF_CONDITION),
+        LintId::of(&copies::SHARED_CODE_IN_IF_BLOCKS),
         LintId::of(&copy_iterator::COPY_ITERATOR),
         LintId::of(&default::DEFAULT_TRAIT_ACCESS),
         LintId::of(&dereference::EXPLICIT_DEREF_METHODS),
diff --git a/clippy_lints/src/literal_representation.rs b/clippy_lints/src/literal_representation.rs
index 7fd55151226..b736eeff6bf 100644
--- a/clippy_lints/src/literal_representation.rs
+++ b/clippy_lints/src/literal_representation.rs
@@ -464,32 +464,28 @@ impl DecimalLiteralRepresentation {
             {
                 return Err(WarningType::DecimalRepresentation);
             }
-        } else if digits.len() < 4 {
-            // Lint for Literals with a hex-representation of 2 or 3 digits
-            let f = &digits[0..1]; // first digit
-            let s = &digits[1..]; // suffix
-
-            // Powers of 2
-            if ((f.eq("1") || f.eq("2") || f.eq("4") || f.eq("8")) && s.chars().all(|c| c == '0'))
-                // Powers of 2 minus 1
-                || ((f.eq("1") || f.eq("3") || f.eq("7") || f.eq("F")) && s.chars().all(|c| c == 'F'))
-            {
-                return Err(WarningType::DecimalRepresentation);
-            }
         } else {
-            // Lint for Literals with a hex-representation of 4 digits or more
             let f = &digits[0..1]; // first digit
             let m = &digits[1..digits.len() - 1]; // middle digits, except last
             let s = &digits[1..]; // suffix
-
-            // Powers of 2 with a margin of +15/-16
-            if ((f.eq("1") || f.eq("2") || f.eq("4") || f.eq("8")) && m.chars().all(|c| c == '0'))
-                || ((f.eq("1") || f.eq("3") || f.eq("7") || f.eq("F")) && m.chars().all(|c| c == 'F'))
-                // Lint for representations with only 0s and Fs, while allowing 7 as the first
-                // digit
-                || ((f.eq("7") || f.eq("F")) && s.chars().all(|c| c == '0' || c == 'F'))
-            {
-                return Err(WarningType::DecimalRepresentation);
+            if digits.len() < 4 {
+                // Powers of 2
+                if ((f.eq("1") || f.eq("2") || f.eq("4") || f.eq("8")) && s.chars().all(|c| c == '0'))
+                    // Powers of 2 minus 1
+                    || ((f.eq("1") || f.eq("3") || f.eq("7") || f.eq("F")) && s.chars().all(|c| c == 'F'))
+                {
+                    return Err(WarningType::DecimalRepresentation);
+                }
+            } else {
+                // Powers of 2 with a margin of +15/-16
+                if ((f.eq("1") || f.eq("2") || f.eq("4") || f.eq("8")) && m.chars().all(|c| c == '0'))
+                    || ((f.eq("1") || f.eq("3") || f.eq("7") || f.eq("F")) && m.chars().all(|c| c == 'F'))
+                    // Lint for representations with only 0s and Fs, while allowing 7 as the first
+                    // digit
+                    || ((f.eq("7") || f.eq("F")) && s.chars().all(|c| c == '0' || c == 'F'))
+                {
+                    return Err(WarningType::DecimalRepresentation);
+                }
             }
         }
 
diff --git a/clippy_lints/src/methods/manual_saturating_arithmetic.rs b/clippy_lints/src/methods/manual_saturating_arithmetic.rs
index 6c5a842a912..ecb8b72ef46 100644
--- a/clippy_lints/src/methods/manual_saturating_arithmetic.rs
+++ b/clippy_lints/src/methods/manual_saturating_arithmetic.rs
@@ -44,44 +44,28 @@ pub fn check(
             // "mul" is omitted because lhs can be negative.
             _ => return,
         }
-
-        let mut applicability = Applicability::MachineApplicable;
-        span_lint_and_sugg(
-            cx,
-            super::MANUAL_SATURATING_ARITHMETIC,
-            expr.span,
-            "manual saturating arithmetic",
-            &format!("try using `saturating_{}`", arith),
-            format!(
-                "{}.saturating_{}({})",
-                snippet_with_applicability(cx, arith_lhs.span, "..", &mut applicability),
-                arith,
-                snippet_with_applicability(cx, arith_rhs.span, "..", &mut applicability),
-            ),
-            applicability,
-        );
     } else {
         match (mm, arith) {
             (MinMax::Max, "add" | "mul") | (MinMax::Min, "sub") => (),
             _ => return,
         }
-
-        let mut applicability = Applicability::MachineApplicable;
-        span_lint_and_sugg(
-            cx,
-            super::MANUAL_SATURATING_ARITHMETIC,
-            expr.span,
-            "manual saturating arithmetic",
-            &format!("try using `saturating_{}`", arith),
-            format!(
-                "{}.saturating_{}({})",
-                snippet_with_applicability(cx, arith_lhs.span, "..", &mut applicability),
-                arith,
-                snippet_with_applicability(cx, arith_rhs.span, "..", &mut applicability),
-            ),
-            applicability,
-        );
     }
+
+    let mut applicability = Applicability::MachineApplicable;
+    span_lint_and_sugg(
+        cx,
+        super::MANUAL_SATURATING_ARITHMETIC,
+        expr.span,
+        "manual saturating arithmetic",
+        &format!("try using `saturating_{}`", arith),
+        format!(
+            "{}.saturating_{}({})",
+            snippet_with_applicability(cx, arith_lhs.span, "..", &mut applicability),
+            arith,
+            snippet_with_applicability(cx, arith_rhs.span, "..", &mut applicability),
+        ),
+        applicability,
+    );
 }
 
 #[derive(PartialEq, Eq)]
diff --git a/clippy_utils/src/hir_utils.rs b/clippy_utils/src/hir_utils.rs
index 0c3b8b89171..8b90fedbafe 100644
--- a/clippy_utils/src/hir_utils.rs
+++ b/clippy_utils/src/hir_utils.rs
@@ -483,6 +483,15 @@ pub fn over<X>(left: &[X], right: &[X], mut eq_fn: impl FnMut(&X, &X) -> bool) -
     left.len() == right.len() && left.iter().zip(right).all(|(x, y)| eq_fn(x, y))
 }
 
+/// Counts how many elements of the slices are equal as per `eq_fn`.
+pub fn count_eq<X: Sized>(
+    left: &mut dyn Iterator<Item = X>,
+    right: &mut dyn Iterator<Item = X>,
+    mut eq_fn: impl FnMut(&X, &X) -> bool,
+) -> usize {
+    left.zip(right).take_while(|(l, r)| eq_fn(l, r)).count()
+}
+
 /// Checks if two expressions evaluate to the same value, and don't contain any side effects.
 pub fn eq_expr_value(cx: &LateContext<'_>, left: &Expr<'_>, right: &Expr<'_>) -> bool {
     SpanlessEq::new(cx).deny_side_effects().eq_expr(left, right)
diff --git a/tests/ui/checked_unwrap/complex_conditionals.rs b/tests/ui/checked_unwrap/complex_conditionals.rs
index c986c992a07..bb5b6f5ec04 100644
--- a/tests/ui/checked_unwrap/complex_conditionals.rs
+++ b/tests/ui/checked_unwrap/complex_conditionals.rs
@@ -1,5 +1,5 @@
 #![deny(clippy::panicking_unwrap, clippy::unnecessary_unwrap)]
-#![allow(clippy::if_same_then_else)]
+#![allow(clippy::if_same_then_else, clippy::shared_code_in_if_blocks)]
 
 fn test_complex_conditions() {
     let x: Result<(), ()> = Ok(());
diff --git a/tests/ui/if_same_then_else.rs b/tests/ui/if_same_then_else.rs
index 9c5fe02f751..35a2e139c11 100644
--- a/tests/ui/if_same_then_else.rs
+++ b/tests/ui/if_same_then_else.rs
@@ -5,7 +5,8 @@
     clippy::never_loop,
     clippy::no_effect,
     clippy::unused_unit,
-    clippy::zero_divided_by_zero
+    clippy::zero_divided_by_zero,
+    clippy::shared_code_in_if_blocks
 )]
 
 struct Foo {
diff --git a/tests/ui/if_same_then_else.stderr b/tests/ui/if_same_then_else.stderr
index d9fdf06fa8b..2f38052fc20 100644
--- a/tests/ui/if_same_then_else.stderr
+++ b/tests/ui/if_same_then_else.stderr
@@ -1,111 +1,111 @@
 error: this `if` has identical blocks
-  --> $DIR/if_same_then_else.rs:28:12
+  --> $DIR/if_same_then_else.rs:21:13
    |
-LL |       } else {
-   |  ____________^
-LL | |         //~ ERROR same body as `if` block
+LL |       if true {
+   |  _____________^
 LL | |         Foo { bar: 42 };
 LL | |         0..10;
+LL | |         ..;
 ...  |
 LL | |         foo();
-LL | |     }
+LL | |     } else {
    | |_____^
    |
    = note: `-D clippy::if-same-then-else` implied by `-D warnings`
 note: same as this
-  --> $DIR/if_same_then_else.rs:20:13
+  --> $DIR/if_same_then_else.rs:29:12
    |
-LL |       if true {
-   |  _____________^
+LL |       } else {
+   |  ____________^
+LL | |         //~ ERROR same body as `if` block
 LL | |         Foo { bar: 42 };
 LL | |         0..10;
-LL | |         ..;
 ...  |
 LL | |         foo();
-LL | |     } else {
+LL | |     }
    | |_____^
 
 error: this `if` has identical blocks
-  --> $DIR/if_same_then_else.rs:66:12
-   |
-LL |       } else {
-   |  ____________^
-LL | |         //~ ERROR same body as `if` block
-LL | |         0.0
-LL | |     };
-   | |_____^
-   |
-note: same as this
-  --> $DIR/if_same_then_else.rs:64:21
+  --> $DIR/if_same_then_else.rs:65:21
    |
 LL |       let _ = if true {
    |  _____________________^
 LL | |         0.0
 LL | |     } else {
    | |_____^
-
-error: this `if` has identical blocks
-  --> $DIR/if_same_then_else.rs:73:12
+   |
+note: same as this
+  --> $DIR/if_same_then_else.rs:67:12
    |
 LL |       } else {
    |  ____________^
 LL | |         //~ ERROR same body as `if` block
-LL | |         -0.0
+LL | |         0.0
 LL | |     };
    | |_____^
-   |
-note: same as this
-  --> $DIR/if_same_then_else.rs:71:21
+
+error: this `if` has identical blocks
+  --> $DIR/if_same_then_else.rs:72:21
    |
 LL |       let _ = if true {
    |  _____________________^
 LL | |         -0.0
 LL | |     } else {
    | |_____^
-
-error: this `if` has identical blocks
-  --> $DIR/if_same_then_else.rs:89:12
+   |
+note: same as this
+  --> $DIR/if_same_then_else.rs:74:12
    |
 LL |       } else {
    |  ____________^
 LL | |         //~ ERROR same body as `if` block
-LL | |         42
+LL | |         -0.0
 LL | |     };
    | |_____^
-   |
-note: same as this
-  --> $DIR/if_same_then_else.rs:87:21
+
+error: this `if` has identical blocks
+  --> $DIR/if_same_then_else.rs:88:21
    |
 LL |       let _ = if true {
    |  _____________________^
 LL | |         42
 LL | |     } else {
    | |_____^
-
-error: this `if` has identical blocks
-  --> $DIR/if_same_then_else.rs:101:12
+   |
+note: same as this
+  --> $DIR/if_same_then_else.rs:90:12
    |
 LL |       } else {
    |  ____________^
 LL | |         //~ ERROR same body as `if` block
+LL | |         42
+LL | |     };
+   | |_____^
+
+error: this `if` has identical blocks
+  --> $DIR/if_same_then_else.rs:95:13
+   |
+LL |       if true {
+   |  _____________^
 LL | |         let bar = if true { 42 } else { 43 };
 LL | |
+LL | |         while foo() {
 ...  |
 LL | |         bar + 1;
-LL | |     }
+LL | |     } else {
    | |_____^
    |
 note: same as this
-  --> $DIR/if_same_then_else.rs:94:13
+  --> $DIR/if_same_then_else.rs:102:12
    |
-LL |       if true {
-   |  _____________^
+LL |       } else {
+   |  ____________^
+LL | |         //~ ERROR same body as `if` block
 LL | |         let bar = if true { 42 } else { 43 };
 LL | |
-LL | |         while foo() {
 ...  |
 LL | |         bar + 1;
-LL | |     } else {
+LL | |     }
    | |_____^
 
 error: aborting due to 5 previous errors
diff --git a/tests/ui/if_same_then_else2.rs b/tests/ui/if_same_then_else2.rs
index a2ff1b741ca..8164b125570 100644
--- a/tests/ui/if_same_then_else2.rs
+++ b/tests/ui/if_same_then_else2.rs
@@ -5,7 +5,8 @@
     clippy::collapsible_if,
     clippy::ifs_same_cond,
     clippy::needless_return,
-    clippy::single_element_loop
+    clippy::single_element_loop,
+    clippy::shared_code_in_if_blocks
 )]
 
 fn if_same_then_else2() -> Result<&'static str, ()> {
diff --git a/tests/ui/if_same_then_else2.stderr b/tests/ui/if_same_then_else2.stderr
index 454322d8aac..941b92f23f3 100644
--- a/tests/ui/if_same_then_else2.stderr
+++ b/tests/ui/if_same_then_else2.stderr
@@ -24,18 +24,22 @@ LL | |             if foo.is_some() {
 LL | |         }
 LL | |     } else {
    | |_____^
-
-error: this `if` has identical blocks
-  --> $DIR/if_same_then_else2.rs:35:12
+   |
+   = note: `-D clippy::if-same-then-else` implied by `-D warnings`
+note: same as this
+  --> $DIR/if_same_then_else2.rs:21:12
    |
 LL |       } else {
    |  ____________^
 LL | |         //~ ERROR same body as `if` block
-LL | |         if let Some(a) = Some(42) {}
+LL | |         for _ in &[42] {
+LL | |             let foo: &Option<_> = &Some::<u8>(42);
+...  |
+LL | |         }
 LL | |     }
    | |_____^
-   |
-note: same as this
+
+error: this `if` has identical blocks
   --> $DIR/if_same_then_else2.rs:33:13
    |
 LL |       if true {
@@ -43,18 +47,18 @@ LL |       if true {
 LL | |         if let Some(a) = Some(42) {}
 LL | |     } else {
    | |_____^
-
-error: this `if` has identical blocks
-  --> $DIR/if_same_then_else2.rs:42:12
+   |
+note: same as this
+  --> $DIR/if_same_then_else2.rs:35:12
    |
 LL |       } else {
    |  ____________^
 LL | |         //~ ERROR same body as `if` block
-LL | |         if let (1, .., 3) = (1, 2, 3) {}
+LL | |         if let Some(a) = Some(42) {}
 LL | |     }
    | |_____^
-   |
-note: same as this
+
+error: this `if` has identical blocks
   --> $DIR/if_same_then_else2.rs:40:13
    |
 LL |       if true {
@@ -62,18 +66,18 @@ LL |       if true {
 LL | |         if let (1, .., 3) = (1, 2, 3) {}
 LL | |     } else {
    | |_____^
-
-error: this `if` has identical blocks
-  --> $DIR/if_same_then_else2.rs:92:12
+   |
+note: same as this
+  --> $DIR/if_same_then_else2.rs:42:12
    |
 LL |       } else {
    |  ____________^
 LL | |         //~ ERROR same body as `if` block
-LL | |         f32::NAN
-LL | |     };
+LL | |         if let (1, .., 3) = (1, 2, 3) {}
+LL | |     }
    | |_____^
-   |
-note: same as this
+
+error: this `if` has identical blocks
   --> $DIR/if_same_then_else2.rs:90:21
    |
 LL |       let _ = if true {
@@ -81,18 +85,18 @@ LL |       let _ = if true {
 LL | |         f32::NAN
 LL | |     } else {
    | |_____^
-
-error: this `if` has identical blocks
-  --> $DIR/if_same_then_else2.rs:99:12
+   |
+note: same as this
+  --> $DIR/if_same_then_else2.rs:92:12
    |
 LL |       } else {
    |  ____________^
 LL | |         //~ ERROR same body as `if` block
-LL | |         Ok("foo")?;
-LL | |     }
+LL | |         f32::NAN
+LL | |     };
    | |_____^
-   |
-note: same as this
+
+error: this `if` has identical blocks
   --> $DIR/if_same_then_else2.rs:97:13
    |
 LL |       if true {
@@ -100,18 +104,18 @@ LL |       if true {
 LL | |         Ok("foo")?;
 LL | |     } else {
    | |_____^
-
-error: this `if` has identical blocks
-  --> $DIR/if_same_then_else2.rs:124:12
+   |
+note: same as this
+  --> $DIR/if_same_then_else2.rs:99:12
    |
 LL |       } else {
    |  ____________^
-LL | |         let foo = "";
-LL | |         return Ok(&foo[0..]);
+LL | |         //~ ERROR same body as `if` block
+LL | |         Ok("foo")?;
 LL | |     }
    | |_____^
-   |
-note: same as this
+
+error: this `if` has identical blocks
   --> $DIR/if_same_then_else2.rs:121:20
    |
 LL |       } else if true {
@@ -120,6 +124,16 @@ LL | |         let foo = "";
 LL | |         return Ok(&foo[0..]);
 LL | |     } else {
    | |_____^
+   |
+note: same as this
+  --> $DIR/if_same_then_else2.rs:124:12
+   |
+LL |       } else {
+   |  ____________^
+LL | |         let foo = "";
+LL | |         return Ok(&foo[0..]);
+LL | |     }
+   | |_____^
 
 error: aborting due to 6 previous errors
 
diff --git a/tests/ui/let_if_seq.rs b/tests/ui/let_if_seq.rs
index 32a67f181df..9fd3f875a5f 100644
--- a/tests/ui/let_if_seq.rs
+++ b/tests/ui/let_if_seq.rs
@@ -2,7 +2,8 @@
     unused_variables,
     unused_assignments,
     clippy::similar_names,
-    clippy::blacklisted_name
+    clippy::blacklisted_name,
+    clippy::shared_code_in_if_blocks
 )]
 #![warn(clippy::useless_let_if_seq)]
 
diff --git a/tests/ui/let_if_seq.stderr b/tests/ui/let_if_seq.stderr
index 7de560c7348..9cf2e10a5ee 100644
--- a/tests/ui/let_if_seq.stderr
+++ b/tests/ui/let_if_seq.stderr
@@ -1,5 +1,5 @@
 error: `if _ { .. } else { .. }` is an expression
-  --> $DIR/let_if_seq.rs:64:5
+  --> $DIR/let_if_seq.rs:65:5
    |
 LL | /     let mut foo = 0;
 LL | |     if f() {
@@ -11,7 +11,7 @@ LL | |     }
    = note: you might not need `mut` at all
 
 error: `if _ { .. } else { .. }` is an expression
-  --> $DIR/let_if_seq.rs:69:5
+  --> $DIR/let_if_seq.rs:70:5
    |
 LL | /     let mut bar = 0;
 LL | |     if f() {
@@ -25,7 +25,7 @@ LL | |     }
    = note: you might not need `mut` at all
 
 error: `if _ { .. } else { .. }` is an expression
-  --> $DIR/let_if_seq.rs:77:5
+  --> $DIR/let_if_seq.rs:78:5
    |
 LL | /     let quz;
 LL | |     if f() {
@@ -36,7 +36,7 @@ LL | |     }
    | |_____^ help: it is more idiomatic to write: `let quz = if f() { 42 } else { 0 };`
 
 error: `if _ { .. } else { .. }` is an expression
-  --> $DIR/let_if_seq.rs:106:5
+  --> $DIR/let_if_seq.rs:107:5
    |
 LL | /     let mut baz = 0;
 LL | |     if f() {
diff --git a/tests/ui/shared_code_in_if_blocks/shared_at_bot.rs b/tests/ui/shared_code_in_if_blocks/shared_at_bot.rs
new file mode 100644
index 00000000000..22f1fe95f79
--- /dev/null
+++ b/tests/ui/shared_code_in_if_blocks/shared_at_bot.rs
@@ -0,0 +1,47 @@
+#![allow(dead_code)]
+#![deny(clippy::if_same_then_else, clippy::shared_code_in_if_blocks)]
+
+// This tests the shared_code_in_if_blocks lint at the end of blocks
+
+fn simple_examples() {
+    // TODO xFrednet 2021-01-06: Test with const literals at the end
+    let x = 1;
+
+    let _ = if x == 7 {
+        println!("Branch I");
+        let start_value = 0;
+        println!("=^.^=");
+
+        // Same but not moveable due to `start_value`
+        let _ = start_value;
+
+        // The rest is self contained and moveable => Only lint the rest
+        let result = false;
+        println!("Block end!");
+        result
+    } else {
+        println!("Branch II");
+        let start_value = 8;
+        println!("xD");
+
+        // Same but not moveable due to `start_value`
+        let _ = start_value;
+
+        // The rest is self contained and moveable => Only lint the rest
+        let result = false;
+        println!("Block end!");
+        result
+    };
+}
+
+/// Simple examples where the move can cause some problems due to moved values
+fn simple_but_suggestion_is_invalid() {
+    // TODO xFrednet 2021-01-12: This
+}
+
+/// Tests where the blocks are not linted due to the used value scope
+fn not_moveable_due_to_value_scope() {
+    // TODO xFrednet 2021-01-12: This
+}
+
+fn main() {}
diff --git a/tests/ui/shared_code_in_if_blocks/shared_at_top.rs b/tests/ui/shared_code_in_if_blocks/shared_at_top.rs
new file mode 100644
index 00000000000..0a6828127e9
--- /dev/null
+++ b/tests/ui/shared_code_in_if_blocks/shared_at_top.rs
@@ -0,0 +1,83 @@
+#![allow(dead_code, clippy::eval_order_dependence)]
+#![deny(clippy::if_same_then_else, clippy::shared_code_in_if_blocks)]
+
+// This tests the shared_code_in_if_blocks lint at the start of blocks
+
+fn simple_examples() {
+    let x = 0;
+
+    // Simple
+    if true {
+        println!("Hello World!");
+        println!("I'm branch nr: 1");
+    } else {
+        println!("Hello World!");
+        println!("I'm branch nr: 2");
+    }
+
+    // Else if
+    if x == 0 {
+        let y = 9;
+        println!("The value y was set to: `{}`", y);
+        let _z = y;
+
+        println!("I'm the true start index of arrays");
+    } else if x == 1 {
+        let y = 9;
+        println!("The value y was set to: `{}`", y);
+        let _z = y;
+
+        println!("I start counting from 1 so my array starts from `1`");
+    } else {
+        let y = 9;
+        println!("The value y was set to: `{}`", y);
+        let _z = y;
+
+        println!("Ha, Pascal allows you to start the array where you want")
+    }
+
+    // Return a value
+    let _ = if x == 7 {
+        let y = 16;
+        println!("What can I say except: \"you're welcome?\"");
+        let _ = y;
+        x
+    } else {
+        let y = 16;
+        println!("Thank you");
+        y
+    };
+}
+
+/// Simple examples where the move can cause some problems due to moved values
+fn simple_but_suggestion_is_invalid() {
+    let x = 10;
+
+    // Can't be automatically moved because used_value_name is getting used again
+    let used_value_name = 19;
+    if x == 10 {
+        let used_value_name = "Different type";
+        println!("Str: {}", used_value_name);
+        let _ = 1;
+    } else {
+        let used_value_name = "Different type";
+        println!("Str: {}", used_value_name);
+        let _ = 2;
+    }
+    let _ = used_value_name;
+
+    // This can be automatically moved as `can_be_overridden` is not used again
+    let can_be_overridden = 8;
+    let _ = can_be_overridden;
+    if x == 11 {
+        let can_be_overridden = "Move me";
+        println!("I'm also moveable");
+        let _ = 111;
+    } else {
+        let can_be_overridden = "Move me";
+        println!("I'm also moveable");
+        let _ = 222;
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/shared_code_in_if_blocks/shared_at_top_and_bot.rs b/tests/ui/shared_code_in_if_blocks/shared_at_top_and_bot.rs
new file mode 100644
index 00000000000..8de69623e5d
--- /dev/null
+++ b/tests/ui/shared_code_in_if_blocks/shared_at_top_and_bot.rs
@@ -0,0 +1,22 @@
+#![allow(dead_code)]
+#![deny(clippy::if_same_then_else, clippy::shared_code_in_if_blocks)]
+
+// shared_code_in_if_blocks at the top and bottom of the if blocks
+
+fn main() {
+    // TODO xFrednet 2021-01-12: This
+}
+
+// General TODOs By xFrednet:
+
+// 
+// * Make a test with overlapping eq regions (else ifs)
+// * Test if as function parameter, tuple constructor, index, while loop condition
+// * Test where only the expression is the same
+// * Test where the block only has an expression
+// * Test with let on a previous line let _ = \n if...
+// * Tests with unreadable formatting (Inline if, Not indented)
+// * Test multiline condition if x == 9 \n x == 8 {}
+// * Test if for return/break (Only move to front)
+// * Test in inline closures
+// * Test with structs and tuples
diff --git a/tests/ui/shared_code_in_if_blocks/valid_if_blocks.rs b/tests/ui/shared_code_in_if_blocks/valid_if_blocks.rs
new file mode 100644
index 00000000000..1f12e9348d4
--- /dev/null
+++ b/tests/ui/shared_code_in_if_blocks/valid_if_blocks.rs
@@ -0,0 +1,157 @@
+#![allow(dead_code, clippy::eval_order_dependence)]
+#![deny(clippy::if_same_then_else, clippy::shared_code_in_if_blocks)]
+
+// This tests the shared_code_in_if_blocks lint at the start of blocks
+
+// Tests with value references are includes in "shared_code_at_bot.rs"
+
+fn valid_examples() {
+    let x = 2;
+
+    // The edge statements are different
+    if x == 9 {
+        let y = 1 << 5;
+
+        println!("This is the same: vvv");
+        let _z = y;
+        println!("The block expression is different");
+
+        println!("Different end 1");
+    } else {
+        let y = 1 << 7;
+
+        println!("This is the same: vvv");
+        let _z = y;
+        println!("The block expression is different");
+
+        println!("Different end 2");
+    }
+
+    // No else
+    if x == 2 {
+        println!("Hello world!");
+        println!("Hello back, how are you?");
+
+        // This is different vvvv
+        println!("Howdy stranger =^.^=");
+
+        println!("Bye Bye World");
+    } else if x == 9 {
+        println!("Hello world!");
+        println!("Hello back, how are you?");
+
+        // This is different vvvv
+        println!("Hello reviewer :D");
+
+        println!("Bye Bye World");
+    }
+
+    // Overlapping statements only in else if blocks -> Don't lint
+    if x == 0 {
+        println!("I'm important!")
+    } else if x == 17 {
+        println!("I share code in else if");
+
+        println!("x is 17");
+    } else {
+        println!("I share code in else if");
+
+        println!("x is nether x nor 17");
+    }
+
+    // Mutability is different
+    if x == 13 {
+        let mut y = 9;
+        println!("Value y is: {}", y);
+        y += 16;
+        let _z1 = y;
+    } else {
+        let y = 9;
+        println!("Value y is: {}", y);
+        let _z2 = y;
+    }
+
+    // Same blocks but at start and bottom so no `if_same_then_else` lint
+    if x == 418 {
+        let y = 9;
+        let z = 8;
+        let _ = (x, y, z);
+        // Don't tell the programmer, my code is also in the else block
+    } else if x == 419 {
+        println!("+-----------+");
+        println!("|           |");
+        println!("|  O     O  |");
+        println!("|     °     |");
+        println!("|  \\_____/  |");
+        println!("|           |");
+        println!("+-----------+");
+    } else {
+        let y = 9;
+        let z = 8;
+        let _ = (x, y, z);
+        // I'm so much better than the x == 418 block. Trust me
+    }
+}
+
+/// This makes sure that the `if_same_then_else` masks the `shared_code_in_if_blocks` lint
+fn trigger_other_lint() {
+    let x = 0;
+    let y = 1;
+
+    // Same block
+    if x == 0 {
+        let u = 19;
+        println!("How are u today?");
+        let _ = "This is a string";
+    } else {
+        let u = 19;
+        println!("How are u today?");
+        let _ = "This is a string";
+    }
+
+    // More complex same blocks
+    if x == 17 {
+        #[derive(Debug)]
+        struct Duck {
+            num: u64,
+        };
+        let pet = Duck { num: 18 };
+        println!("{:?}", pet);
+    } else {
+        #[derive(Debug)]
+        struct Duck {
+            num: u64,
+        };
+        let pet = Duck { num: 18 };
+        println!("{:?}", pet);
+    }
+
+    // Only same expression
+    let _ = if x == 6 { 7 } else { 7 };
+
+    // Same in else if block
+    let _ = if x == 67 {
+        println!("Well I'm the most important block");
+        "I'm a pretty string"
+    } else if x == 68 {
+        println!("I'm a doppelgänger");
+        // Don't listen to my clone below
+
+        if y == 90 {
+            "=^.^="
+        } else {
+            ":D"
+        }
+    } else {
+        // Don't listen to my clone above
+        println!("I'm a doppelgänger");
+
+        if y == 90 {
+            "=^.^="
+        } else {
+            ":D"
+        }
+    };
+}
+
+fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 469ff96db3cc397be46ea9d19c72148c6a95eb6a Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Wed, 13 Jan 2021 20:01:15 +0100
Subject: The shared_code_in_if_blocks lint only operats on entire if expr not
 else ifs

---
 clippy_lints/src/copies.rs                         |  52 ++++++----
 tests/ui/shared_code_in_if_blocks/shared_at_bot.rs | 107 ++++++++++++++++++++-
 .../ui/shared_code_in_if_blocks/valid_if_blocks.rs |  10 ++
 3 files changed, 148 insertions(+), 21 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/copies.rs b/clippy_lints/src/copies.rs
index 29ff1970705..7162d809ec6 100644
--- a/clippy_lints/src/copies.rs
+++ b/clippy_lints/src/copies.rs
@@ -1,7 +1,12 @@
-use clippy_utils::diagnostics::span_lint_and_note;
-use clippy_utils::{eq_expr_value, in_macro, search_same, SpanlessEq, SpanlessHash};
-use clippy_utils::{get_parent_expr, if_sequence};
-use rustc_hir::{Block, Expr, ExprKind};
+use crate::utils::{both, count_eq, eq_expr_value, in_macro, search_same, SpanlessEq, SpanlessHash};
+use crate::utils::{
+    first_line_of_span, get_parent_expr, higher, if_sequence, indent_of, parent_node_is_if_expr, reindent_multiline,
+    snippet, span_lint_and_note, span_lint_and_sugg, span_lint_and_then,
+};
+use rustc_data_structures::fx::FxHashSet;
+use rustc_errors::Applicability;
+use rustc_hir::intravisit::{self, NestedVisitorMap, Visitor};
+use rustc_hir::{Block, Expr, HirId};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::map::Map;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -136,7 +141,7 @@ declare_clippy_lint! {
     /// };
     /// ```
     pub SHARED_CODE_IN_IF_BLOCKS,
-    pedantic,
+    nursery,
     "`if` statement with shared code in all blocks"
 }
 
@@ -180,7 +185,7 @@ fn lint_same_then_else<'tcx>(
 ) {
     // We only lint ifs with multiple blocks
     // TODO xFrednet 2021-01-01: Check if it's an else if block
-    if blocks.len() < 2 {
+    if blocks.len() < 2 || parent_node_is_if_expr(expr, cx) {
         return;
     }
 
@@ -190,7 +195,7 @@ fn lint_same_then_else<'tcx>(
     let mut start_eq = usize::MAX;
     let mut end_eq = usize::MAX;
     let mut expr_eq = true;
-    for (index, win) in blocks.windows(2).enumerate() {
+    for win in blocks.windows(2) {
         let l_stmts = win[0].stmts;
         let r_stmts = win[1].stmts;
 
@@ -202,9 +207,7 @@ fn lint_same_then_else<'tcx>(
         let block_expr_eq = both(&win[0].expr, &win[1].expr, |l, r| evaluator.eq_expr(l, r));
 
         // IF_SAME_THEN_ELSE
-        // We only lint the first two blocks (index == 0). Further blocks will be linted when that if
-        // statement is checked
-        if index == 0 && block_expr_eq && l_stmts.len() == r_stmts.len() && l_stmts.len() == current_start_eq {
+        if block_expr_eq && l_stmts.len() == r_stmts.len() && l_stmts.len() == current_start_eq {
             span_lint_and_note(
                 cx,
                 IF_SAME_THEN_ELSE,
@@ -215,16 +218,24 @@ fn lint_same_then_else<'tcx>(
             );
 
             return;
+        } else {
+            println!(
+                "{:?}\n - expr_eq: {:10}, l_stmts.len(): {:10}, r_stmts.len(): {:10}",
+                win[0].span,
+                block_expr_eq,
+                l_stmts.len(),
+                r_stmts.len()
+            )
         }
 
         start_eq = start_eq.min(current_start_eq);
         end_eq = end_eq.min(current_end_eq);
         expr_eq &= block_expr_eq;
+    }
 
-        // We can return if the eq count is 0 from both sides or if it has no unconditional else case
-        if !has_unconditional_else || (start_eq == 0 && end_eq == 0 && (has_expr && !expr_eq)) {
-            return;
-        }
+    // SHARED_CODE_IN_IF_BLOCKS prerequisites
+    if !has_unconditional_else || (start_eq == 0 && end_eq == 0 && (has_expr && !expr_eq)) {
+        return;
     }
 
     if has_expr && !expr_eq {
@@ -275,11 +286,14 @@ fn lint_same_then_else<'tcx>(
             end_eq -= moved_start;
         }
 
-        let mut end_linable = true;
-        if let Some(expr) = block.expr {
+        let end_linable = if let Some(expr) = block.expr {
             intravisit::walk_expr(&mut walker, expr);
-            end_linable = walker.uses.iter().any(|x| !block_defs.contains(x));
-        }
+            walker.uses.iter().any(|x| !block_defs.contains(x))
+        } else if end_eq == 0 {
+            false
+        } else {
+            true
+        };
 
         emit_shared_code_in_if_blocks_lint(cx, start_eq, end_eq, end_linable, blocks, expr);
     }
@@ -351,7 +365,7 @@ fn emit_shared_code_in_if_blocks_lint(
             SHARED_CODE_IN_IF_BLOCKS,
             *span,
             "All code blocks contain the same code",
-            "Consider moving the code out like this",
+            "Consider moving the statements out like this",
             sugg.clone(),
             Applicability::Unspecified,
         );
diff --git a/tests/ui/shared_code_in_if_blocks/shared_at_bot.rs b/tests/ui/shared_code_in_if_blocks/shared_at_bot.rs
index 22f1fe95f79..b85bb2e1f96 100644
--- a/tests/ui/shared_code_in_if_blocks/shared_at_bot.rs
+++ b/tests/ui/shared_code_in_if_blocks/shared_at_bot.rs
@@ -32,16 +32,119 @@ fn simple_examples() {
         println!("Block end!");
         result
     };
+
+    if x == 9 {
+        println!("The index is: 6");
+
+        println!("Same end of block");
+    } else if x == 8 {
+        println!("The index is: 4");
+
+        println!("Same end of block");
+    } else {
+        println!("Same end of block");
+    }
+
+    // TODO xFrednet 2021-01.13: Fix lint for `if let`
+    let index = Some(8);
+    if let Some(index) = index {
+        println!("The index is: {}", index);
+
+        println!("Same end of block");
+    } else {
+        println!("Same end of block");
+    }
+
+    if x == 9 {
+        if x == 8 {
+            // No parent!!
+            println!("Hello World");
+            println!("---");
+        } else {
+            println!("Hello World");
+        }
+    }
 }
 
 /// Simple examples where the move can cause some problems due to moved values
 fn simple_but_suggestion_is_invalid() {
-    // TODO xFrednet 2021-01-12: This
+    let x = 16;
+
+    // Local value
+    let later_used_value = 17;
+    if x == 9 {
+        let _ = 9;
+        let later_used_value = "A string value";
+        println!("{}", later_used_value);
+    } else {
+        let later_used_value = "A string value";
+        println!("{}", later_used_value);
+        // I'm expecting a note about this
+    }
+    println!("{}", later_used_value);
+
+    // outer function
+    if x == 78 {
+        let simple_examples = "I now identify as a &str :)";
+        println!("This is the new simple_example: {}", simple_examples);
+    } else {
+        println!("Separator print statement");
+
+        let simple_examples = "I now identify as a &str :)";
+        println!("This is the new simple_example: {}", simple_examples);
+    }
+    simple_examples();
 }
 
 /// Tests where the blocks are not linted due to the used value scope
 fn not_moveable_due_to_value_scope() {
-    // TODO xFrednet 2021-01-12: This
+    let x = 18;
+
+    // Using a local value in the moved code
+    if x == 9 {
+        let y = 18;
+        println!("y is: `{}`", y);
+    } else {
+        let y = "A string";
+        println!("y is: `{}`", y);
+    }
+
+    // Using a local value in the expression
+    let _ = if x == 0 {
+        let mut result = x + 1;
+
+        println!("1. Doing some calculations");
+        println!("2. Some more calculations");
+        println!("3. Setting result");
+
+        result
+    } else {
+        let mut result = x - 1;
+
+        println!("1. Doing some calculations");
+        println!("2. Some more calculations");
+        println!("3. Setting result");
+
+        result
+    };
+
+    let _ = if x == 7 {
+        let z1 = 100;
+        println!("z1: {}", z1);
+
+        let z2 = z1;
+        println!("z2: {}", z2);
+
+        z2
+    } else {
+        let z1 = 300;
+        println!("z1: {}", z1);
+
+        let z2 = z1;
+        println!("z2: {}", z2);
+
+        z2
+    };
 }
 
 fn main() {}
diff --git a/tests/ui/shared_code_in_if_blocks/valid_if_blocks.rs b/tests/ui/shared_code_in_if_blocks/valid_if_blocks.rs
index 1f12e9348d4..480758777f1 100644
--- a/tests/ui/shared_code_in_if_blocks/valid_if_blocks.rs
+++ b/tests/ui/shared_code_in_if_blocks/valid_if_blocks.rs
@@ -152,6 +152,16 @@ fn trigger_other_lint() {
             ":D"
         }
     };
+
+    if x == 0 {
+        println!("I'm single");
+    } else if x == 68 {
+        println!("I'm a doppelgänger");
+        // Don't listen to my clone below
+    } else {
+        // Don't listen to my clone above
+        println!("I'm a doppelgänger");
+    }
 }
 
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 8efc6acc05387738313798069b8553d0ab9c92e5 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Sat, 16 Jan 2021 14:04:14 +0100
Subject: Improved shared_code_in_if_blocks output readability and added tests

---
 clippy_lints/src/copies.rs                         | 69 +++++++++------
 tests/ui/shared_code_in_if_blocks/shared_at_bot.rs | 35 ++++++++
 .../shared_at_top_and_bot.rs                       | 98 ++++++++++++++++++----
 3 files changed, 161 insertions(+), 41 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/copies.rs b/clippy_lints/src/copies.rs
index 7162d809ec6..089f8c3ab0d 100644
--- a/clippy_lints/src/copies.rs
+++ b/clippy_lints/src/copies.rs
@@ -1,16 +1,16 @@
 use crate::utils::{both, count_eq, eq_expr_value, in_macro, search_same, SpanlessEq, SpanlessHash};
 use crate::utils::{
-    first_line_of_span, get_parent_expr, higher, if_sequence, indent_of, parent_node_is_if_expr, reindent_multiline,
-    snippet, span_lint_and_note, span_lint_and_sugg, span_lint_and_then,
+    first_line_of_span, get_parent_expr, if_sequence, indent_of, parent_node_is_if_expr, reindent_multiline, snippet,
+    snippet_opt, span_lint_and_note, span_lint_and_sugg, span_lint_and_then,
 };
 use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{self, NestedVisitorMap, Visitor};
-use rustc_hir::{Block, Expr, HirId};
+use rustc_hir::{Block, Expr, ExprKind, HirId};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::map::Map;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::source_map::Span;
+use rustc_span::{source_map::Span, BytePos};
 use std::borrow::Cow;
 
 declare_clippy_lint! {
@@ -218,14 +218,6 @@ fn lint_same_then_else<'tcx>(
             );
 
             return;
-        } else {
-            println!(
-                "{:?}\n - expr_eq: {:10}, l_stmts.len(): {:10}, r_stmts.len(): {:10}",
-                win[0].span,
-                block_expr_eq,
-                l_stmts.len(),
-                r_stmts.len()
-            )
         }
 
         start_eq = start_eq.min(current_start_eq);
@@ -328,7 +320,7 @@ fn emit_shared_code_in_if_blocks_lint(
         let suggestion = reindent_multiline(Cow::Borrowed(&suggestion), true, cond_indent);
 
         let span = span_start.to(span_end);
-        suggestions.push(("START HELP", span, suggestion.to_string()));
+        suggestions.push(("start", span, suggestion.to_string()));
     }
 
     if lint_end {
@@ -354,31 +346,56 @@ fn emit_shared_code_in_if_blocks_lint(
         let suggestion = "}\n".to_string() + &moved_snipped;
         let suggestion = reindent_multiline(Cow::Borrowed(&suggestion), true, indent);
 
-        let span = moved_start.to(span_end);
-        suggestions.push(("END_RANGE", span, suggestion.to_string()));
+        let mut span = moved_start.to(span_end);
+        // Improve formatting if the inner block has indention (i.e. normal Rust formatting)
+        let test_span = Span::new(span.lo() - BytePos(4), span.lo(), span.ctxt());
+        if snippet_opt(cx, test_span)
+            .map(|snip| snip == "    ")
+            .unwrap_or_default()
+        {
+            span = span.with_lo(test_span.lo());
+        }
+
+        suggestions.push(("end", span, suggestion.to_string()));
     }
 
     if suggestions.len() == 1 {
-        let (_, span, sugg) = &suggestions[0];
+        let (place_str, span, sugg) = suggestions.pop().unwrap();
+        let msg = format!("All if blocks contain the same code at the {}", place_str);
+        let help = format!("Consider moving the {} statements out like this", place_str);
         span_lint_and_sugg(
             cx,
             SHARED_CODE_IN_IF_BLOCKS,
-            *span,
-            "All code blocks contain the same code",
-            "Consider moving the statements out like this",
-            sugg.clone(),
+            span,
+            msg.as_str(),
+            help.as_str(),
+            sugg,
             Applicability::Unspecified,
         );
-    } else {
+    } else if suggestions.len() == 2 {
+        let (_, end_span, end_sugg) = suggestions.pop().unwrap();
+        let (_, start_span, start_sugg) = suggestions.pop().unwrap();
         span_lint_and_then(
             cx,
             SHARED_CODE_IN_IF_BLOCKS,
-            if_expr.span,
-            "All if blocks contain the same code",
+            start_span,
+            "All if blocks contain the same code at the start and the end. Here at the start:",
             move |diag| {
-                for (help, span, sugg) in suggestions {
-                    diag.span_suggestion(span, help, sugg, Applicability::Unspecified);
-                }
+                diag.span_note(end_span, "And here at the end:");
+
+                diag.span_suggestion(
+                    start_span,
+                    "Consider moving the start statements out like this:",
+                    start_sugg,
+                    Applicability::Unspecified,
+                );
+
+                diag.span_suggestion(
+                    end_span,
+                    "And consider moving the end statements out like this:",
+                    end_sugg,
+                    Applicability::Unspecified,
+                );
             },
         );
     }
diff --git a/tests/ui/shared_code_in_if_blocks/shared_at_bot.rs b/tests/ui/shared_code_in_if_blocks/shared_at_bot.rs
index b85bb2e1f96..a586a1c9d45 100644
--- a/tests/ui/shared_code_in_if_blocks/shared_at_bot.rs
+++ b/tests/ui/shared_code_in_if_blocks/shared_at_bot.rs
@@ -33,6 +33,7 @@ fn simple_examples() {
         result
     };
 
+    // Else if block
     if x == 9 {
         println!("The index is: 6");
 
@@ -40,9 +41,32 @@ fn simple_examples() {
     } else if x == 8 {
         println!("The index is: 4");
 
+        // We should only get a lint trigger for the last statement
+        println!("This is also eq with the else block");
         println!("Same end of block");
     } else {
         println!("Same end of block");
+        println!("This is also eq with the else block");
+    }
+
+    // Use of outer scope value
+    let outer_scope_value = "I'm outside the if block";
+    if x < 99 {
+        let z = "How are you";
+        println!("I'm a local because I use the value `z`: `{}`", z);
+
+        println!(
+            "I'm moveable because I know: `outer_scope_value`: '{}'",
+            outer_scope_value
+        );
+    } else {
+        let z = 45678000;
+        println!("I'm a local because I use the value `z`: `{}`", z);
+
+        println!(
+            "I'm moveable because I know: `outer_scope_value`: '{}'",
+            outer_scope_value
+        );
     }
 
     // TODO xFrednet 2021-01.13: Fix lint for `if let`
@@ -147,4 +171,15 @@ fn not_moveable_due_to_value_scope() {
     };
 }
 
+#[rustfmt::skip]
+fn test_suggestion_with_weird_formatting() {
+    let x = 9;
+    let mut a = 0;
+    let mut b = 0;
+
+    // The error message still looks weird tbh but this is the best I can do
+    // for weird formatting
+    if x == 17 { b = 1; a = 0x99; } else { a = 0x99; }
+}
+
 fn main() {}
diff --git a/tests/ui/shared_code_in_if_blocks/shared_at_top_and_bot.rs b/tests/ui/shared_code_in_if_blocks/shared_at_top_and_bot.rs
index 8de69623e5d..70f969aaf2e 100644
--- a/tests/ui/shared_code_in_if_blocks/shared_at_top_and_bot.rs
+++ b/tests/ui/shared_code_in_if_blocks/shared_at_top_and_bot.rs
@@ -3,20 +3,88 @@
 
 // shared_code_in_if_blocks at the top and bottom of the if blocks
 
-fn main() {
-    // TODO xFrednet 2021-01-12: This
+struct DataPack {
+    id: u32,
+    name: String,
+    some_data: Vec<u8>,
 }
 
-// General TODOs By xFrednet:
-
-// 
-// * Make a test with overlapping eq regions (else ifs)
-// * Test if as function parameter, tuple constructor, index, while loop condition
-// * Test where only the expression is the same
-// * Test where the block only has an expression
-// * Test with let on a previous line let _ = \n if...
-// * Tests with unreadable formatting (Inline if, Not indented)
-// * Test multiline condition if x == 9 \n x == 8 {}
-// * Test if for return/break (Only move to front)
-// * Test in inline closures
-// * Test with structs and tuples
+fn overlapping_eq_regions() {
+    let x = 9;
+
+    // Overlap with separator
+    if x == 7 {
+        let t = 7;
+        let _overlap_start = t * 2;
+        let _overlap_end = 2 * t;
+        let _u = 9;
+    } else {
+        let t = 7;
+        let _overlap_start = t * 2;
+        let _overlap_end = 2 * t;
+        println!("Overlap separator");
+        let _overlap_start = t * 2;
+        let _overlap_end = 2 * t;
+        let _u = 9;
+    }
+
+    // Overlap with separator
+    if x == 99 {
+        let r = 7;
+        let _overlap_start = r;
+        let _overlap_middle = r * r;
+        let _overlap_end = r * r * r;
+        let z = "end";
+    } else {
+        let r = 7;
+        let _overlap_start = r;
+        let _overlap_middle = r * r;
+        let _overlap_middle = r * r;
+        let _overlap_end = r * r * r;
+        let z = "end";
+    }
+}
+
+fn complexer_example() {
+    fn gen_id(x: u32, y: u32) -> u32 {
+        let x = x & 0x0000_ffff;
+        let y = (y & 0xffff_0000) << 16;
+        x | y
+    }
+
+    fn process_data(data: DataPack) {
+        let _ = data;
+    }
+
+    let x = 8;
+    let y = 9;
+    if (x > 7 && y < 13) || (x + y) % 2 == 1 {
+        let a = 0xcafe;
+        let b = 0xffff00ff;
+        let e_id = gen_id(a, b);
+
+        println!("From the a `{}` to the b `{}`", a, b);
+
+        let pack = DataPack {
+            id: e_id,
+            name: "Player 1".to_string(),
+            some_data: vec![0x12, 0x34, 0x56, 0x78, 0x90],
+        };
+        process_data(pack);
+    } else {
+        let a = 0xcafe;
+        let b = 0xffff00ff;
+        let e_id = gen_id(a, b);
+
+        println!("The new ID is '{}'", e_id);
+
+        let pack = DataPack {
+            id: e_id,
+            name: "Player 1".to_string(),
+            some_data: vec![0x12, 0x34, 0x56, 0x78, 0x90],
+        };
+        process_data(pack);
+    }
+}
+
+fn main() {}
-- 
cgit 1.4.1-3-g733a5


From b1d26e544f10b814d9793294d0c05dd2ace5d0dc Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Sat, 16 Jan 2021 20:37:50 +0100
Subject: Improved shared_code_in_if_blocks message and added test stderrs

---
 clippy_lints/src/copies.rs                         | 169 ++++++++++++++++-----
 clippy_lints/src/lib.rs                            |   2 +-
 clippy_lints/src/literal_representation.rs         |  40 ++---
 tests/ui/if_same_then_else2.stderr                 |  22 +--
 tests/ui/shared_code_in_if_blocks/shared_at_bot.rs |  19 +++
 .../shared_code_in_if_blocks/shared_at_bot.stderr  | 131 ++++++++++++++++
 .../shared_code_in_if_blocks/shared_at_top.stderr  |  83 ++++++++++
 .../shared_at_top_and_bot.rs                       |  29 ++++
 .../shared_at_top_and_bot.stderr                   | 154 +++++++++++++++++++
 .../valid_if_blocks.stderr                         | 107 +++++++++++++
 10 files changed, 692 insertions(+), 64 deletions(-)
 create mode 100644 tests/ui/shared_code_in_if_blocks/shared_at_bot.stderr
 create mode 100644 tests/ui/shared_code_in_if_blocks/shared_at_top.stderr
 create mode 100644 tests/ui/shared_code_in_if_blocks/shared_at_top_and_bot.stderr
 create mode 100644 tests/ui/shared_code_in_if_blocks/valid_if_blocks.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/copies.rs b/clippy_lints/src/copies.rs
index 089f8c3ab0d..47732f4766d 100644
--- a/clippy_lints/src/copies.rs
+++ b/clippy_lints/src/copies.rs
@@ -1,16 +1,16 @@
 use crate::utils::{both, count_eq, eq_expr_value, in_macro, search_same, SpanlessEq, SpanlessHash};
 use crate::utils::{
-    first_line_of_span, get_parent_expr, if_sequence, indent_of, parent_node_is_if_expr, reindent_multiline, snippet,
-    snippet_opt, span_lint_and_note, span_lint_and_sugg, span_lint_and_then,
+    first_line_of_span, get_enclosing_block, get_parent_expr, if_sequence, indent_of, parent_node_is_if_expr,
+    reindent_multiline, snippet, snippet_opt, span_lint_and_note, span_lint_and_then, ContainsName,
 };
 use rustc_data_structures::fx::FxHashSet;
-use rustc_errors::Applicability;
+use rustc_errors::{Applicability, DiagnosticBuilder};
 use rustc_hir::intravisit::{self, NestedVisitorMap, Visitor};
 use rustc_hir::{Block, Expr, ExprKind, HirId};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::map::Map;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::{source_map::Span, BytePos};
+use rustc_span::{source_map::Span, symbol::Symbol, BytePos};
 use std::borrow::Cow;
 
 declare_clippy_lint! {
@@ -184,7 +184,6 @@ fn lint_same_then_else<'tcx>(
     expr: &'tcx Expr<'_>,
 ) {
     // We only lint ifs with multiple blocks
-    // TODO xFrednet 2021-01-01: Check if it's an else if block
     if blocks.len() < 2 || parent_node_is_if_expr(expr, cx) {
         return;
     }
@@ -242,36 +241,61 @@ fn lint_same_then_else<'tcx>(
 
     // Only the start is the same
     if start_eq != 0 && end_eq == 0 && (!has_expr || !expr_eq) {
-        emit_shared_code_in_if_blocks_lint(cx, start_eq, 0, false, blocks, expr);
-    } else if end_eq != 0 && (!has_expr || !expr_eq) {
+        let block = blocks[0];
+        let start_stmts = block.stmts.split_at(start_eq).0;
+
+        let mut start_walker = UsedValueFinderVisitor::new(cx);
+        for stmt in start_stmts {
+            intravisit::walk_stmt(&mut start_walker, stmt);
+        }
+
+        emit_shared_code_in_if_blocks_lint(
+            cx,
+            start_eq,
+            0,
+            false,
+            check_for_warn_of_moved_symbol(cx, &start_walker.def_symbols, expr),
+            blocks,
+            expr,
+        );
+    } else if end_eq != 0 || (has_expr && expr_eq) {
         let block = blocks[blocks.len() - 1];
-        let stmts = block.stmts.split_at(start_eq).1;
-        let (block_stmts, moved_stmts) = stmts.split_at(stmts.len() - end_eq);
+        let (start_stmts, block_stmts) = block.stmts.split_at(start_eq);
+        let (block_stmts, end_stmts) = block_stmts.split_at(block_stmts.len() - end_eq);
+
+        // Scan start
+        let mut start_walker = UsedValueFinderVisitor::new(cx);
+        for stmt in start_stmts {
+            intravisit::walk_stmt(&mut start_walker, stmt);
+        }
+        let mut moved_syms = start_walker.def_symbols;
 
         // Scan block
-        let mut walker = SymbolFinderVisitor::new(cx);
+        let mut block_walker = UsedValueFinderVisitor::new(cx);
         for stmt in block_stmts {
-            intravisit::walk_stmt(&mut walker, stmt);
+            intravisit::walk_stmt(&mut block_walker, stmt);
         }
-        let mut block_defs = walker.defs;
+        let mut block_defs = block_walker.defs;
 
         // Scan moved stmts
         let mut moved_start: Option<usize> = None;
-        let mut walker = SymbolFinderVisitor::new(cx);
-        for (index, stmt) in moved_stmts.iter().enumerate() {
-            intravisit::walk_stmt(&mut walker, stmt);
+        let mut end_walker = UsedValueFinderVisitor::new(cx);
+        for (index, stmt) in end_stmts.iter().enumerate() {
+            intravisit::walk_stmt(&mut end_walker, stmt);
 
-            for value in &walker.uses {
+            for value in &end_walker.uses {
                 // Well we can't move this and all prev statements. So reset
                 if block_defs.contains(&value) {
                     moved_start = Some(index + 1);
-                    walker.defs.drain().for_each(|x| {
+                    end_walker.defs.drain().for_each(|x| {
                         block_defs.insert(x);
                     });
+
+                    end_walker.def_symbols.clear();
                 }
             }
 
-            walker.uses.clear();
+            end_walker.uses.clear();
         }
 
         if let Some(moved_start) = moved_start {
@@ -279,15 +303,65 @@ fn lint_same_then_else<'tcx>(
         }
 
         let end_linable = if let Some(expr) = block.expr {
-            intravisit::walk_expr(&mut walker, expr);
-            walker.uses.iter().any(|x| !block_defs.contains(x))
+            intravisit::walk_expr(&mut end_walker, expr);
+            end_walker.uses.iter().any(|x| !block_defs.contains(x))
         } else if end_eq == 0 {
             false
         } else {
             true
         };
 
-        emit_shared_code_in_if_blocks_lint(cx, start_eq, end_eq, end_linable, blocks, expr);
+        if end_linable {
+            end_walker.def_symbols.drain().for_each(|x| {
+                moved_syms.insert(x);
+            });
+        }
+
+        emit_shared_code_in_if_blocks_lint(
+            cx,
+            start_eq,
+            end_eq,
+            end_linable,
+            check_for_warn_of_moved_symbol(cx, &moved_syms, expr),
+            blocks,
+            expr,
+        );
+    }
+}
+
+fn check_for_warn_of_moved_symbol(
+    cx: &LateContext<'tcx>,
+    symbols: &FxHashSet<Symbol>,
+    if_expr: &'tcx Expr<'_>,
+) -> bool {
+    // Obs true as we include the current if block
+    if let Some(block) = get_enclosing_block(cx, if_expr.hir_id) {
+        let ignore_span = block.span.shrink_to_lo().to(if_expr.span);
+
+        symbols
+            .iter()
+            .filter(|sym| !sym.as_str().starts_with('_'))
+            .any(move |sym| {
+                let mut walker = ContainsName {
+                    name: *sym,
+                    result: false,
+                };
+
+                // Scan block
+                block
+                    .stmts
+                    .iter()
+                    .filter(|stmt| !ignore_span.overlaps(stmt.span))
+                    .for_each(|stmt| intravisit::walk_stmt(&mut walker, stmt));
+
+                if let Some(expr) = block.expr {
+                    intravisit::walk_expr(&mut walker, expr);
+                }
+
+                walker.result
+            })
+    } else {
+        false
     }
 }
 
@@ -296,6 +370,7 @@ fn emit_shared_code_in_if_blocks_lint(
     start_stmts: usize,
     end_stmts: usize,
     lint_end: bool,
+    warn_about_moved_symbol: bool,
     blocks: &[&Block<'tcx>],
     if_expr: &'tcx Expr<'_>,
 ) {
@@ -305,7 +380,9 @@ fn emit_shared_code_in_if_blocks_lint(
 
     // (help, span, suggestion)
     let mut suggestions: Vec<(&str, Span, String)> = vec![];
+    let mut add_expr_note = false;
 
+    // Construct suggestions
     if start_stmts > 0 {
         let block = blocks[0];
         let span_start = first_line_of_span(cx, if_expr.span).shrink_to_lo();
@@ -357,21 +434,29 @@ fn emit_shared_code_in_if_blocks_lint(
         }
 
         suggestions.push(("end", span, suggestion.to_string()));
+        add_expr_note = !cx.typeck_results().expr_ty(if_expr).is_unit()
     }
 
+    let add_optional_msgs = |diag: &mut DiagnosticBuilder<'_>| {
+        if add_expr_note {
+            diag.note("The end suggestion probably needs some adjustments to use the expression result correctly.");
+        }
+
+        if warn_about_moved_symbol {
+            diag.warn("Some moved values might need to be renamed to avoid wrong references.");
+        }
+    };
+
+    // Emit lint
     if suggestions.len() == 1 {
         let (place_str, span, sugg) = suggestions.pop().unwrap();
         let msg = format!("All if blocks contain the same code at the {}", place_str);
         let help = format!("Consider moving the {} statements out like this", place_str);
-        span_lint_and_sugg(
-            cx,
-            SHARED_CODE_IN_IF_BLOCKS,
-            span,
-            msg.as_str(),
-            help.as_str(),
-            sugg,
-            Applicability::Unspecified,
-        );
+        span_lint_and_then(cx, SHARED_CODE_IN_IF_BLOCKS, span, msg.as_str(), |diag| {
+            diag.span_suggestion(span, help.as_str(), sugg, Applicability::Unspecified);
+
+            add_optional_msgs(diag);
+        });
     } else if suggestions.len() == 2 {
         let (_, end_span, end_sugg) = suggestions.pop().unwrap();
         let (_, start_span, start_sugg) = suggestions.pop().unwrap();
@@ -396,28 +481,39 @@ fn emit_shared_code_in_if_blocks_lint(
                     end_sugg,
                     Applicability::Unspecified,
                 );
+
+                add_optional_msgs(diag);
             },
         );
     }
 }
 
-pub struct SymbolFinderVisitor<'a, 'tcx> {
+/// This visitor collects HirIds and Symbols of defined symbols and HirIds of used values.
+struct UsedValueFinderVisitor<'a, 'tcx> {
     cx: &'a LateContext<'tcx>,
+
+    /// The `HirId`s of defined values in the scanned statements
     defs: FxHashSet<HirId>,
+
+    /// The Symbols of the defined symbols in the scanned statements
+    def_symbols: FxHashSet<Symbol>,
+
+    /// The `HirId`s of the used values
     uses: FxHashSet<HirId>,
 }
 
-impl<'a, 'tcx> SymbolFinderVisitor<'a, 'tcx> {
+impl<'a, 'tcx> UsedValueFinderVisitor<'a, 'tcx> {
     fn new(cx: &'a LateContext<'tcx>) -> Self {
-        SymbolFinderVisitor {
+        UsedValueFinderVisitor {
             cx,
             defs: FxHashSet::default(),
+            def_symbols: FxHashSet::default(),
             uses: FxHashSet::default(),
         }
     }
 }
 
-impl<'a, 'tcx> Visitor<'tcx> for SymbolFinderVisitor<'a, 'tcx> {
+impl<'a, 'tcx> Visitor<'tcx> for UsedValueFinderVisitor<'a, 'tcx> {
     type Map = Map<'tcx>;
 
     fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
@@ -427,6 +523,11 @@ impl<'a, 'tcx> Visitor<'tcx> for SymbolFinderVisitor<'a, 'tcx> {
     fn visit_local(&mut self, l: &'tcx rustc_hir::Local<'tcx>) {
         let local_id = l.pat.hir_id;
         self.defs.insert(local_id);
+
+        if let Some(sym) = l.pat.simple_ident() {
+            self.def_symbols.insert(sym.name);
+        }
+
         if let Some(expr) = l.init {
             intravisit::walk_expr(self, expr);
         }
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index ba98a2a2607..9afbf95a342 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1366,7 +1366,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&casts::PTR_AS_PTR),
         LintId::of(&checked_conversions::CHECKED_CONVERSIONS),
         LintId::of(&copies::SAME_FUNCTIONS_IN_IF_CONDITION),
-        LintId::of(&copies::SHARED_CODE_IN_IF_BLOCKS),
         LintId::of(&copy_iterator::COPY_ITERATOR),
         LintId::of(&default::DEFAULT_TRAIT_ACCESS),
         LintId::of(&dereference::EXPLICIT_DEREF_METHODS),
@@ -2064,6 +2063,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_group(true, "clippy::nursery", Some("clippy_nursery"), vec![
         LintId::of(&attrs::EMPTY_LINE_AFTER_OUTER_ATTR),
         LintId::of(&cognitive_complexity::COGNITIVE_COMPLEXITY),
+        LintId::of(&copies::SHARED_CODE_IN_IF_BLOCKS),
         LintId::of(&disallowed_method::DISALLOWED_METHOD),
         LintId::of(&fallible_impl_from::FALLIBLE_IMPL_FROM),
         LintId::of(&floating_point_arithmetic::IMPRECISE_FLOPS),
diff --git a/clippy_lints/src/literal_representation.rs b/clippy_lints/src/literal_representation.rs
index b736eeff6bf..7fd55151226 100644
--- a/clippy_lints/src/literal_representation.rs
+++ b/clippy_lints/src/literal_representation.rs
@@ -464,28 +464,32 @@ impl DecimalLiteralRepresentation {
             {
                 return Err(WarningType::DecimalRepresentation);
             }
+        } else if digits.len() < 4 {
+            // Lint for Literals with a hex-representation of 2 or 3 digits
+            let f = &digits[0..1]; // first digit
+            let s = &digits[1..]; // suffix
+
+            // Powers of 2
+            if ((f.eq("1") || f.eq("2") || f.eq("4") || f.eq("8")) && s.chars().all(|c| c == '0'))
+                // Powers of 2 minus 1
+                || ((f.eq("1") || f.eq("3") || f.eq("7") || f.eq("F")) && s.chars().all(|c| c == 'F'))
+            {
+                return Err(WarningType::DecimalRepresentation);
+            }
         } else {
+            // Lint for Literals with a hex-representation of 4 digits or more
             let f = &digits[0..1]; // first digit
             let m = &digits[1..digits.len() - 1]; // middle digits, except last
             let s = &digits[1..]; // suffix
-            if digits.len() < 4 {
-                // Powers of 2
-                if ((f.eq("1") || f.eq("2") || f.eq("4") || f.eq("8")) && s.chars().all(|c| c == '0'))
-                    // Powers of 2 minus 1
-                    || ((f.eq("1") || f.eq("3") || f.eq("7") || f.eq("F")) && s.chars().all(|c| c == 'F'))
-                {
-                    return Err(WarningType::DecimalRepresentation);
-                }
-            } else {
-                // Powers of 2 with a margin of +15/-16
-                if ((f.eq("1") || f.eq("2") || f.eq("4") || f.eq("8")) && m.chars().all(|c| c == '0'))
-                    || ((f.eq("1") || f.eq("3") || f.eq("7") || f.eq("F")) && m.chars().all(|c| c == 'F'))
-                    // Lint for representations with only 0s and Fs, while allowing 7 as the first
-                    // digit
-                    || ((f.eq("7") || f.eq("F")) && s.chars().all(|c| c == '0' || c == 'F'))
-                {
-                    return Err(WarningType::DecimalRepresentation);
-                }
+
+            // Powers of 2 with a margin of +15/-16
+            if ((f.eq("1") || f.eq("2") || f.eq("4") || f.eq("8")) && m.chars().all(|c| c == '0'))
+                || ((f.eq("1") || f.eq("3") || f.eq("7") || f.eq("F")) && m.chars().all(|c| c == 'F'))
+                // Lint for representations with only 0s and Fs, while allowing 7 as the first
+                // digit
+                || ((f.eq("7") || f.eq("F")) && s.chars().all(|c| c == '0' || c == 'F'))
+            {
+                return Err(WarningType::DecimalRepresentation);
             }
         }
 
diff --git a/tests/ui/if_same_then_else2.stderr b/tests/ui/if_same_then_else2.stderr
index 941b92f23f3..b31eb46a982 100644
--- a/tests/ui/if_same_then_else2.stderr
+++ b/tests/ui/if_same_then_else2.stderr
@@ -27,7 +27,7 @@ LL | |     } else {
    |
    = note: `-D clippy::if-same-then-else` implied by `-D warnings`
 note: same as this
-  --> $DIR/if_same_then_else2.rs:21:12
+  --> $DIR/if_same_then_else2.rs:22:12
    |
 LL |       } else {
    |  ____________^
@@ -40,7 +40,7 @@ LL | |     }
    | |_____^
 
 error: this `if` has identical blocks
-  --> $DIR/if_same_then_else2.rs:33:13
+  --> $DIR/if_same_then_else2.rs:34:13
    |
 LL |       if true {
    |  _____________^
@@ -49,7 +49,7 @@ LL | |     } else {
    | |_____^
    |
 note: same as this
-  --> $DIR/if_same_then_else2.rs:35:12
+  --> $DIR/if_same_then_else2.rs:36:12
    |
 LL |       } else {
    |  ____________^
@@ -59,7 +59,7 @@ LL | |     }
    | |_____^
 
 error: this `if` has identical blocks
-  --> $DIR/if_same_then_else2.rs:40:13
+  --> $DIR/if_same_then_else2.rs:41:13
    |
 LL |       if true {
    |  _____________^
@@ -68,7 +68,7 @@ LL | |     } else {
    | |_____^
    |
 note: same as this
-  --> $DIR/if_same_then_else2.rs:42:12
+  --> $DIR/if_same_then_else2.rs:43:12
    |
 LL |       } else {
    |  ____________^
@@ -78,7 +78,7 @@ LL | |     }
    | |_____^
 
 error: this `if` has identical blocks
-  --> $DIR/if_same_then_else2.rs:90:21
+  --> $DIR/if_same_then_else2.rs:91:21
    |
 LL |       let _ = if true {
    |  _____________________^
@@ -87,7 +87,7 @@ LL | |     } else {
    | |_____^
    |
 note: same as this
-  --> $DIR/if_same_then_else2.rs:92:12
+  --> $DIR/if_same_then_else2.rs:93:12
    |
 LL |       } else {
    |  ____________^
@@ -97,7 +97,7 @@ LL | |     };
    | |_____^
 
 error: this `if` has identical blocks
-  --> $DIR/if_same_then_else2.rs:97:13
+  --> $DIR/if_same_then_else2.rs:98:13
    |
 LL |       if true {
    |  _____________^
@@ -106,7 +106,7 @@ LL | |     } else {
    | |_____^
    |
 note: same as this
-  --> $DIR/if_same_then_else2.rs:99:12
+  --> $DIR/if_same_then_else2.rs:100:12
    |
 LL |       } else {
    |  ____________^
@@ -116,7 +116,7 @@ LL | |     }
    | |_____^
 
 error: this `if` has identical blocks
-  --> $DIR/if_same_then_else2.rs:121:20
+  --> $DIR/if_same_then_else2.rs:122:20
    |
 LL |       } else if true {
    |  ____________________^
@@ -126,7 +126,7 @@ LL | |     } else {
    | |_____^
    |
 note: same as this
-  --> $DIR/if_same_then_else2.rs:124:12
+  --> $DIR/if_same_then_else2.rs:125:12
    |
 LL |       } else {
    |  ____________^
diff --git a/tests/ui/shared_code_in_if_blocks/shared_at_bot.rs b/tests/ui/shared_code_in_if_blocks/shared_at_bot.rs
index a586a1c9d45..5392da7ac7a 100644
--- a/tests/ui/shared_code_in_if_blocks/shared_at_bot.rs
+++ b/tests/ui/shared_code_in_if_blocks/shared_at_bot.rs
@@ -171,6 +171,25 @@ fn not_moveable_due_to_value_scope() {
     };
 }
 
+/// This should add a note to the lint msg since the moved expression is not `()`
+fn added_note_for_expression_use() -> u32 {
+    let x = 9;
+
+    let _ = if x == 7 {
+        x << 2
+    } else {
+        let _ = 6;
+        x << 2
+    };
+
+    if x == 9 {
+        x * 4
+    } else {
+        let _ = 17;
+        x * 4
+    }
+}
+
 #[rustfmt::skip]
 fn test_suggestion_with_weird_formatting() {
     let x = 9;
diff --git a/tests/ui/shared_code_in_if_blocks/shared_at_bot.stderr b/tests/ui/shared_code_in_if_blocks/shared_at_bot.stderr
new file mode 100644
index 00000000000..62a95157d61
--- /dev/null
+++ b/tests/ui/shared_code_in_if_blocks/shared_at_bot.stderr
@@ -0,0 +1,131 @@
+error: All if blocks contain the same code at the end
+  --> $DIR/shared_at_bot.rs:31:5
+   |
+LL | /         let result = false;
+LL | |         println!("Block end!");
+LL | |         result
+LL | |     };
+   | |_____^
+   |
+note: the lint level is defined here
+  --> $DIR/shared_at_bot.rs:2:36
+   |
+LL | #![deny(clippy::if_same_then_else, clippy::shared_code_in_if_blocks)]
+   |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   = note: The end suggestion probably needs some adjustments to use the expression result correctly.
+help: Consider moving the end statements out like this
+   |
+LL |     }
+LL |     let result = false;
+LL |     println!("Block end!");
+LL |     result;
+   |
+
+error: All if blocks contain the same code at the end
+  --> $DIR/shared_at_bot.rs:66:5
+   |
+LL | /         println!(
+LL | |             "I'm moveable because I know: `outer_scope_value`: '{}'",
+LL | |             outer_scope_value
+LL | |         );
+LL | |     }
+   | |_____^
+   |
+help: Consider moving the end statements out like this
+   |
+LL |     }
+LL |     println!(
+LL |         "I'm moveable because I know: `outer_scope_value`: '{}'",
+LL |         outer_scope_value
+LL |     );
+   |
+
+error: All if blocks contain the same code at the start
+  --> $DIR/shared_at_bot.rs:83:9
+   |
+LL | /         if x == 8 {
+LL | |             // No parent!!
+LL | |             println!("Hello World");
+   | |____________________________________^
+   |
+help: Consider moving the start statements out like this
+   |
+LL |         println!("Hello World");
+LL |         if x == 8 {
+   |
+
+error: All if blocks contain the same code at the end
+  --> $DIR/shared_at_bot.rs:104:5
+   |
+LL | /         let later_used_value = "A string value";
+LL | |         println!("{}", later_used_value);
+LL | |         // I'm expecting a note about this
+LL | |     }
+   | |_____^
+   |
+   = warning: Some moved values might need to be renamed to avoid wrong references.
+help: Consider moving the end statements out like this
+   |
+LL |     }
+LL |     let later_used_value = "A string value";
+LL |     println!("{}", later_used_value);
+   |
+
+error: All if blocks contain the same code at the end
+  --> $DIR/shared_at_bot.rs:117:5
+   |
+LL | /         let simple_examples = "I now identify as a &str :)";
+LL | |         println!("This is the new simple_example: {}", simple_examples);
+LL | |     }
+   | |_____^
+   |
+   = warning: Some moved values might need to be renamed to avoid wrong references.
+help: Consider moving the end statements out like this
+   |
+LL |     }
+LL |     let simple_examples = "I now identify as a &str :)";
+LL |     println!("This is the new simple_example: {}", simple_examples);
+   |
+
+error: All if blocks contain the same code at the end
+  --> $DIR/shared_at_bot.rs:182:5
+   |
+LL | /         x << 2
+LL | |     };
+   | |_____^
+   |
+   = note: The end suggestion probably needs some adjustments to use the expression result correctly.
+help: Consider moving the end statements out like this
+   |
+LL |     }
+LL |     x << 2;
+   |
+
+error: All if blocks contain the same code at the end
+  --> $DIR/shared_at_bot.rs:189:5
+   |
+LL | /         x * 4
+LL | |     }
+   | |_____^
+   |
+   = note: The end suggestion probably needs some adjustments to use the expression result correctly.
+help: Consider moving the end statements out like this
+   |
+LL |     }
+LL |     x * 4
+   |
+
+error: All if blocks contain the same code at the end
+  --> $DIR/shared_at_bot.rs:201:44
+   |
+LL |     if x == 17 { b = 1; a = 0x99; } else { a = 0x99; }
+   |                                            ^^^^^^^^^^^
+   |
+help: Consider moving the end statements out like this
+   |
+LL |     if x == 17 { b = 1; a = 0x99; } else { }
+LL |     a = 0x99;
+   |
+
+error: aborting due to 8 previous errors
+
diff --git a/tests/ui/shared_code_in_if_blocks/shared_at_top.stderr b/tests/ui/shared_code_in_if_blocks/shared_at_top.stderr
new file mode 100644
index 00000000000..c2bd8a070ed
--- /dev/null
+++ b/tests/ui/shared_code_in_if_blocks/shared_at_top.stderr
@@ -0,0 +1,83 @@
+error: All if blocks contain the same code at the start
+  --> $DIR/shared_at_top.rs:10:5
+   |
+LL | /     if true {
+LL | |         println!("Hello World!");
+   | |_________________________________^
+   |
+note: the lint level is defined here
+  --> $DIR/shared_at_top.rs:2:36
+   |
+LL | #![deny(clippy::if_same_then_else, clippy::shared_code_in_if_blocks)]
+   |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+help: Consider moving the start statements out like this
+   |
+LL |     println!("Hello World!");
+LL |     if true {
+   |
+
+error: All if blocks contain the same code at the start
+  --> $DIR/shared_at_top.rs:19:5
+   |
+LL | /     if x == 0 {
+LL | |         let y = 9;
+LL | |         println!("The value y was set to: `{}`", y);
+LL | |         let _z = y;
+   | |___________________^
+   |
+   = warning: Some moved values might need to be renamed to avoid wrong references.
+help: Consider moving the start statements out like this
+   |
+LL |     let y = 9;
+LL |     println!("The value y was set to: `{}`", y);
+LL |     let _z = y;
+LL |     if x == 0 {
+   |
+
+error: All if blocks contain the same code at the start
+  --> $DIR/shared_at_top.rs:40:5
+   |
+LL | /     let _ = if x == 7 {
+LL | |         let y = 16;
+   | |___________________^
+   |
+help: Consider moving the start statements out like this
+   |
+LL |     let y = 16;
+LL |     let _ = if x == 7 {
+   |
+
+error: All if blocks contain the same code at the start
+  --> $DIR/shared_at_top.rs:58:5
+   |
+LL | /     if x == 10 {
+LL | |         let used_value_name = "Different type";
+LL | |         println!("Str: {}", used_value_name);
+   | |_____________________________________________^
+   |
+   = warning: Some moved values might need to be renamed to avoid wrong references.
+help: Consider moving the start statements out like this
+   |
+LL |     let used_value_name = "Different type";
+LL |     println!("Str: {}", used_value_name);
+LL |     if x == 10 {
+   |
+
+error: All if blocks contain the same code at the start
+  --> $DIR/shared_at_top.rs:72:5
+   |
+LL | /     if x == 11 {
+LL | |         let can_be_overridden = "Move me";
+LL | |         println!("I'm also moveable");
+   | |______________________________________^
+   |
+   = warning: Some moved values might need to be renamed to avoid wrong references.
+help: Consider moving the start statements out like this
+   |
+LL |     let can_be_overridden = "Move me";
+LL |     println!("I'm also moveable");
+LL |     if x == 11 {
+   |
+
+error: aborting due to 5 previous errors
+
diff --git a/tests/ui/shared_code_in_if_blocks/shared_at_top_and_bot.rs b/tests/ui/shared_code_in_if_blocks/shared_at_top_and_bot.rs
index 70f969aaf2e..46a8f931aaf 100644
--- a/tests/ui/shared_code_in_if_blocks/shared_at_top_and_bot.rs
+++ b/tests/ui/shared_code_in_if_blocks/shared_at_top_and_bot.rs
@@ -87,4 +87,33 @@ fn complexer_example() {
     }
 }
 
+/// This should add a note to the lint msg since the moved expression is not `()`
+fn added_note_for_expression_use() -> u32 {
+    let x = 9;
+
+    let _ = if x == 7 {
+        let _ = 19;
+
+        let _splitter = 6;
+
+        x << 2
+    } else {
+        let _ = 19;
+
+        x << 2
+    };
+
+    if x == 9 {
+        let _ = 17;
+
+        let _splitter = 6;
+
+        x * 4
+    } else {
+        let _ = 17;
+
+        x * 4
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/shared_code_in_if_blocks/shared_at_top_and_bot.stderr b/tests/ui/shared_code_in_if_blocks/shared_at_top_and_bot.stderr
new file mode 100644
index 00000000000..1ba7211b469
--- /dev/null
+++ b/tests/ui/shared_code_in_if_blocks/shared_at_top_and_bot.stderr
@@ -0,0 +1,154 @@
+error: All if blocks contain the same code at the start and the end. Here at the start:
+  --> $DIR/shared_at_top_and_bot.rs:16:5
+   |
+LL | /     if x == 7 {
+LL | |         let t = 7;
+LL | |         let _overlap_start = t * 2;
+LL | |         let _overlap_end = 2 * t;
+   | |_________________________________^
+   |
+note: the lint level is defined here
+  --> $DIR/shared_at_top_and_bot.rs:2:36
+   |
+LL | #![deny(clippy::if_same_then_else, clippy::shared_code_in_if_blocks)]
+   |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+note: And here at the end:
+  --> $DIR/shared_at_top_and_bot.rs:28:5
+   |
+LL | /         let _u = 9;
+LL | |     }
+   | |_____^
+help: Consider moving the start statements out like this:
+   |
+LL |     let t = 7;
+LL |     let _overlap_start = t * 2;
+LL |     let _overlap_end = 2 * t;
+LL |     if x == 7 {
+   |
+help: And consider moving the end statements out like this:
+   |
+LL |     }
+LL |     let _u = 9;
+   |
+
+error: All if blocks contain the same code at the start and the end. Here at the start:
+  --> $DIR/shared_at_top_and_bot.rs:32:5
+   |
+LL | /     if x == 99 {
+LL | |         let r = 7;
+LL | |         let _overlap_start = r;
+LL | |         let _overlap_middle = r * r;
+   | |____________________________________^
+   |
+note: And here at the end:
+  --> $DIR/shared_at_top_and_bot.rs:43:5
+   |
+LL | /         let _overlap_end = r * r * r;
+LL | |         let z = "end";
+LL | |     }
+   | |_____^
+   = warning: Some moved values might need to be renamed to avoid wrong references.
+help: Consider moving the start statements out like this:
+   |
+LL |     let r = 7;
+LL |     let _overlap_start = r;
+LL |     let _overlap_middle = r * r;
+LL |     if x == 99 {
+   |
+help: And consider moving the end statements out like this:
+   |
+LL |     }
+LL |     let _overlap_end = r * r * r;
+LL |     let z = "end";
+   |
+
+error: All if blocks contain the same code at the start and the end. Here at the start:
+  --> $DIR/shared_at_top_and_bot.rs:61:5
+   |
+LL | /     if (x > 7 && y < 13) || (x + y) % 2 == 1 {
+LL | |         let a = 0xcafe;
+LL | |         let b = 0xffff00ff;
+LL | |         let e_id = gen_id(a, b);
+   | |________________________________^
+   |
+note: And here at the end:
+  --> $DIR/shared_at_top_and_bot.rs:81:5
+   |
+LL | /         let pack = DataPack {
+LL | |             id: e_id,
+LL | |             name: "Player 1".to_string(),
+LL | |             some_data: vec![0x12, 0x34, 0x56, 0x78, 0x90],
+LL | |         };
+LL | |         process_data(pack);
+LL | |     }
+   | |_____^
+   = warning: Some moved values might need to be renamed to avoid wrong references.
+help: Consider moving the start statements out like this:
+   |
+LL |     let a = 0xcafe;
+LL |     let b = 0xffff00ff;
+LL |     let e_id = gen_id(a, b);
+LL |     if (x > 7 && y < 13) || (x + y) % 2 == 1 {
+   |
+help: And consider moving the end statements out like this:
+   |
+LL |     }
+LL |     let pack = DataPack {
+LL |         id: e_id,
+LL |         name: "Player 1".to_string(),
+LL |         some_data: vec![0x12, 0x34, 0x56, 0x78, 0x90],
+LL |     };
+ ...
+
+error: All if blocks contain the same code at the start and the end. Here at the start:
+  --> $DIR/shared_at_top_and_bot.rs:94:5
+   |
+LL | /     let _ = if x == 7 {
+LL | |         let _ = 19;
+   | |___________________^
+   |
+note: And here at the end:
+  --> $DIR/shared_at_top_and_bot.rs:103:5
+   |
+LL | /         x << 2
+LL | |     };
+   | |_____^
+   = note: The end suggestion probably needs some adjustments to use the expression result correctly.
+help: Consider moving the start statements out like this:
+   |
+LL |     let _ = 19;
+LL |     let _ = if x == 7 {
+   |
+help: And consider moving the end statements out like this:
+   |
+LL |     }
+LL |     x << 2;
+   |
+
+error: All if blocks contain the same code at the start and the end. Here at the start:
+  --> $DIR/shared_at_top_and_bot.rs:106:5
+   |
+LL | /     if x == 9 {
+LL | |         let _ = 17;
+   | |___________________^
+   |
+note: And here at the end:
+  --> $DIR/shared_at_top_and_bot.rs:115:5
+   |
+LL | /         x * 4
+LL | |     }
+   | |_____^
+   = note: The end suggestion probably needs some adjustments to use the expression result correctly.
+help: Consider moving the start statements out like this:
+   |
+LL |     let _ = 17;
+LL |     if x == 9 {
+   |
+help: And consider moving the end statements out like this:
+   |
+LL |     }
+LL |     x * 4
+   |
+
+error: aborting due to 5 previous errors
+
diff --git a/tests/ui/shared_code_in_if_blocks/valid_if_blocks.stderr b/tests/ui/shared_code_in_if_blocks/valid_if_blocks.stderr
new file mode 100644
index 00000000000..003c060f072
--- /dev/null
+++ b/tests/ui/shared_code_in_if_blocks/valid_if_blocks.stderr
@@ -0,0 +1,107 @@
+error: this `if` has identical blocks
+  --> $DIR/valid_if_blocks.rs:102:15
+   |
+LL |       if x == 0 {
+   |  _______________^
+LL | |         let u = 19;
+LL | |         println!("How are u today?");
+LL | |         let _ = "This is a string";
+LL | |     } else {
+   | |_____^
+   |
+note: the lint level is defined here
+  --> $DIR/valid_if_blocks.rs:2:9
+   |
+LL | #![deny(clippy::if_same_then_else, clippy::shared_code_in_if_blocks)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^
+note: same as this
+  --> $DIR/valid_if_blocks.rs:106:12
+   |
+LL |       } else {
+   |  ____________^
+LL | |         let u = 19;
+LL | |         println!("How are u today?");
+LL | |         let _ = "This is a string";
+LL | |     }
+   | |_____^
+
+error: All if blocks contain the same code at the end
+  --> $DIR/valid_if_blocks.rs:125:5
+   |
+LL | /         let pet = Duck { num: 18 };
+LL | |         println!("{:?}", pet);
+LL | |     }
+   | |_____^
+   |
+note: the lint level is defined here
+  --> $DIR/valid_if_blocks.rs:2:36
+   |
+LL | #![deny(clippy::if_same_then_else, clippy::shared_code_in_if_blocks)]
+   |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+help: Consider moving the end statements out like this
+   |
+LL |     }
+LL |     let pet = Duck { num: 18 };
+LL |     println!("{:?}", pet);
+   |
+
+error: this `if` has identical blocks
+  --> $DIR/valid_if_blocks.rs:130:23
+   |
+LL |     let _ = if x == 6 { 7 } else { 7 };
+   |                       ^^^^^
+   |
+note: same as this
+  --> $DIR/valid_if_blocks.rs:130:34
+   |
+LL |     let _ = if x == 6 { 7 } else { 7 };
+   |                                  ^^^^^
+
+error: this `if` has identical blocks
+  --> $DIR/valid_if_blocks.rs:136:23
+   |
+LL |       } else if x == 68 {
+   |  _______________________^
+LL | |         println!("I'm a doppelgänger");
+LL | |         // Don't listen to my clone below
+LL | |
+...  |
+LL | |         }
+LL | |     } else {
+   | |_____^
+   |
+note: same as this
+  --> $DIR/valid_if_blocks.rs:145:12
+   |
+LL |       } else {
+   |  ____________^
+LL | |         // Don't listen to my clone above
+LL | |         println!("I'm a doppelgänger");
+LL | |
+...  |
+LL | |         }
+LL | |     };
+   | |_____^
+
+error: this `if` has identical blocks
+  --> $DIR/valid_if_blocks.rs:158:23
+   |
+LL |       } else if x == 68 {
+   |  _______________________^
+LL | |         println!("I'm a doppelgänger");
+LL | |         // Don't listen to my clone below
+LL | |     } else {
+   | |_____^
+   |
+note: same as this
+  --> $DIR/valid_if_blocks.rs:161:12
+   |
+LL |       } else {
+   |  ____________^
+LL | |         // Don't listen to my clone above
+LL | |         println!("I'm a doppelgänger");
+LL | |     }
+   | |_____^
+
+error: aborting due to 5 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 65ed5a632f5a5fc99a015e7ad0537c401fb61023 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Sat, 16 Jan 2021 21:04:47 +0100
Subject: Updated code for dogfood

---
 clippy_lints/src/copies.rs                         | 142 +++++++++++----------
 tests/ui/shared_code_in_if_blocks/shared_at_top.rs |  20 +++
 .../shared_code_in_if_blocks/shared_at_top.stderr  |  40 +++++-
 3 files changed, 134 insertions(+), 68 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/copies.rs b/clippy_lints/src/copies.rs
index 47732f4766d..4a701dc8898 100644
--- a/clippy_lints/src/copies.rs
+++ b/clippy_lints/src/copies.rs
@@ -1,8 +1,9 @@
-use crate::utils::{both, count_eq, eq_expr_value, in_macro, search_same, SpanlessEq, SpanlessHash};
 use crate::utils::{
-    first_line_of_span, get_enclosing_block, get_parent_expr, if_sequence, indent_of, parent_node_is_if_expr,
-    reindent_multiline, snippet, snippet_opt, span_lint_and_note, span_lint_and_then, ContainsName,
+    both, count_eq, eq_expr_value, first_line_of_span, get_enclosing_block, get_parent_expr, if_sequence, in_macro,
+    indent_of, parent_node_is_if_expr, reindent_multiline, run_lints, search_same, snippet, snippet_opt,
+    span_lint_and_note, span_lint_and_then, ContainsName, SpanlessEq, SpanlessHash,
 };
+use if_chain::if_chain;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::{Applicability, DiagnosticBuilder};
 use rustc_hir::intravisit::{self, NestedVisitorMap, Visitor};
@@ -188,57 +189,15 @@ fn lint_same_then_else<'tcx>(
         return;
     }
 
-    let has_expr = blocks[0].expr.is_some();
-
     // Check if each block has shared code
-    let mut start_eq = usize::MAX;
-    let mut end_eq = usize::MAX;
-    let mut expr_eq = true;
-    for win in blocks.windows(2) {
-        let l_stmts = win[0].stmts;
-        let r_stmts = win[1].stmts;
-
-        let mut evaluator = SpanlessEq::new(cx);
-        let current_start_eq = count_eq(&mut l_stmts.iter(), &mut r_stmts.iter(), |l, r| evaluator.eq_stmt(l, r));
-        let current_end_eq = count_eq(&mut l_stmts.iter().rev(), &mut r_stmts.iter().rev(), |l, r| {
-            evaluator.eq_stmt(l, r)
-        });
-        let block_expr_eq = both(&win[0].expr, &win[1].expr, |l, r| evaluator.eq_expr(l, r));
-
-        // IF_SAME_THEN_ELSE
-        if block_expr_eq && l_stmts.len() == r_stmts.len() && l_stmts.len() == current_start_eq {
-            span_lint_and_note(
-                cx,
-                IF_SAME_THEN_ELSE,
-                win[0].span,
-                "this `if` has identical blocks",
-                Some(win[1].span),
-                "same as this",
-            );
-
-            return;
-        }
-
-        start_eq = start_eq.min(current_start_eq);
-        end_eq = end_eq.min(current_end_eq);
-        expr_eq &= block_expr_eq;
-    }
+    let has_expr = blocks[0].expr.is_some();
+    let (start_eq, mut end_eq, expr_eq) = scan_block_for_eq(cx, blocks);
 
     // SHARED_CODE_IN_IF_BLOCKS prerequisites
     if !has_unconditional_else || (start_eq == 0 && end_eq == 0 && (has_expr && !expr_eq)) {
         return;
     }
 
-    if has_expr && !expr_eq {
-        end_eq = 0;
-    }
-
-    // Check if the regions are overlapping. Set `end_eq` to prevent the overlap
-    let min_block_size = blocks.iter().map(|x| x.stmts.len()).min().unwrap();
-    if (start_eq + end_eq) > min_block_size {
-        end_eq = min_block_size - start_eq;
-    }
-
     // Only the start is the same
     if start_eq != 0 && end_eq == 0 && (!has_expr || !expr_eq) {
         let block = blocks[0];
@@ -302,14 +261,13 @@ fn lint_same_then_else<'tcx>(
             end_eq -= moved_start;
         }
 
-        let end_linable = if let Some(expr) = block.expr {
-            intravisit::walk_expr(&mut end_walker, expr);
-            end_walker.uses.iter().any(|x| !block_defs.contains(x))
-        } else if end_eq == 0 {
-            false
-        } else {
-            true
-        };
+        let end_linable = block.expr.map_or_else(
+            || end_eq != 0,
+            |expr| {
+                intravisit::walk_expr(&mut end_walker, expr);
+                end_walker.uses.iter().any(|x| !block_defs.contains(x))
+            },
+        );
 
         if end_linable {
             end_walker.def_symbols.drain().for_each(|x| {
@@ -329,13 +287,67 @@ fn lint_same_then_else<'tcx>(
     }
 }
 
+fn scan_block_for_eq(cx: &LateContext<'tcx>, blocks: &[&Block<'tcx>]) -> (usize, usize, bool) {
+    let mut start_eq = usize::MAX;
+    let mut end_eq = usize::MAX;
+    let mut expr_eq = true;
+    for win in blocks.windows(2) {
+        let l_stmts = win[0].stmts;
+        let r_stmts = win[1].stmts;
+
+        let mut evaluator = SpanlessEq::new(cx);
+        let current_start_eq = count_eq(&mut l_stmts.iter(), &mut r_stmts.iter(), |l, r| evaluator.eq_stmt(l, r));
+        let current_end_eq = count_eq(&mut l_stmts.iter().rev(), &mut r_stmts.iter().rev(), |l, r| {
+            evaluator.eq_stmt(l, r)
+        });
+        let block_expr_eq = both(&win[0].expr, &win[1].expr, |l, r| evaluator.eq_expr(l, r));
+
+        // IF_SAME_THEN_ELSE
+        if_chain! {
+            if block_expr_eq;
+            if l_stmts.len() == r_stmts.len();
+            if l_stmts.len() == current_start_eq;
+            if run_lints(cx, &[IF_SAME_THEN_ELSE], win[0].hir_id);
+            if run_lints(cx, &[IF_SAME_THEN_ELSE], win[1].hir_id);
+            then {
+                span_lint_and_note(
+                    cx,
+                    IF_SAME_THEN_ELSE,
+                    win[0].span,
+                    "this `if` has identical blocks",
+                    Some(win[1].span),
+                    "same as this",
+                );
+
+                return (0, 0, false);
+            }
+        }
+
+        start_eq = start_eq.min(current_start_eq);
+        end_eq = end_eq.min(current_end_eq);
+        expr_eq &= block_expr_eq;
+    }
+
+    let has_expr = blocks[0].expr.is_some();
+    if has_expr && !expr_eq {
+        end_eq = 0;
+    }
+
+    // Check if the regions are overlapping. Set `end_eq` to prevent the overlap
+    let min_block_size = blocks.iter().map(|x| x.stmts.len()).min().unwrap();
+    if (start_eq + end_eq) > min_block_size {
+        end_eq = min_block_size - start_eq;
+    }
+
+    (start_eq, end_eq, expr_eq)
+}
+
 fn check_for_warn_of_moved_symbol(
     cx: &LateContext<'tcx>,
     symbols: &FxHashSet<Symbol>,
     if_expr: &'tcx Expr<'_>,
 ) -> bool {
-    // Obs true as we include the current if block
-    if let Some(block) = get_enclosing_block(cx, if_expr.hir_id) {
+    get_enclosing_block(cx, if_expr.hir_id).map_or(false, |block| {
         let ignore_span = block.span.shrink_to_lo().to(if_expr.span);
 
         symbols
@@ -360,9 +372,7 @@ fn check_for_warn_of_moved_symbol(
 
                 walker.result
             })
-    } else {
-        false
-    }
+    })
 }
 
 fn emit_shared_code_in_if_blocks_lint(
@@ -410,12 +420,10 @@ fn emit_shared_code_in_if_blocks_lint(
             block.stmts[block.stmts.len() - end_stmts].span
         }
         .source_callsite();
-        let moved_end = if let Some(expr) = block.expr {
-            expr.span
-        } else {
-            block.stmts[block.stmts.len() - 1].span
-        }
-        .source_callsite();
+        let moved_end = block
+            .expr
+            .map_or_else(|| block.stmts[block.stmts.len() - 1].span, |expr| expr.span)
+            .source_callsite();
 
         let moved_span = moved_start.to(moved_end);
         let moved_snipped = reindent_multiline(snippet(cx, moved_span, "_"), true, None);
@@ -488,7 +496,7 @@ fn emit_shared_code_in_if_blocks_lint(
     }
 }
 
-/// This visitor collects HirIds and Symbols of defined symbols and HirIds of used values.
+/// This visitor collects `HirId`s and Symbols of defined symbols and `HirId`s of used values.
 struct UsedValueFinderVisitor<'a, 'tcx> {
     cx: &'a LateContext<'tcx>,
 
diff --git a/tests/ui/shared_code_in_if_blocks/shared_at_top.rs b/tests/ui/shared_code_in_if_blocks/shared_at_top.rs
index 0a6828127e9..496939f2a5e 100644
--- a/tests/ui/shared_code_in_if_blocks/shared_at_top.rs
+++ b/tests/ui/shared_code_in_if_blocks/shared_at_top.rs
@@ -80,4 +80,24 @@ fn simple_but_suggestion_is_invalid() {
     }
 }
 
+/// This function tests that the `IS_SAME_THAN_ELSE` only covers the lint if it's enabled.
+fn check_if_same_than_else_mask() {
+    let x = 2021;
+
+    #[allow(clippy::if_same_then_else)]
+    if x == 2020 {
+        println!("This should trigger the `SHARED_CODE_IN_IF_BLOCKS` lint.");
+        println!("Because `IF_SAME_THEN_ELSE` is allowed here");
+    } else {
+        println!("This should trigger the `SHARED_CODE_IN_IF_BLOCKS` lint.");
+        println!("Because `IF_SAME_THEN_ELSE` is allowed here");
+    }
+
+    if x == 2019 {
+        println!("This should trigger `IS_SAME_THAN_ELSE` as usual");
+    } else {
+        println!("This should trigger `IS_SAME_THAN_ELSE` as usual");
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/shared_code_in_if_blocks/shared_at_top.stderr b/tests/ui/shared_code_in_if_blocks/shared_at_top.stderr
index c2bd8a070ed..d217083c413 100644
--- a/tests/ui/shared_code_in_if_blocks/shared_at_top.stderr
+++ b/tests/ui/shared_code_in_if_blocks/shared_at_top.stderr
@@ -79,5 +79,43 @@ LL |     println!("I'm also moveable");
 LL |     if x == 11 {
    |
 
-error: aborting due to 5 previous errors
+error: All if blocks contain the same code at the start
+  --> $DIR/shared_at_top.rs:88:5
+   |
+LL | /     if x == 2020 {
+LL | |         println!("This should trigger the `SHARED_CODE_IN_IF_BLOCKS` lint.");
+LL | |         println!("Because `IF_SAME_THEN_ELSE` is allowed here");
+   | |________________________________________________________________^
+   |
+help: Consider moving the start statements out like this
+   |
+LL |     println!("This should trigger the `SHARED_CODE_IN_IF_BLOCKS` lint.");
+LL |     println!("Because `IF_SAME_THEN_ELSE` is allowed here");
+LL |     if x == 2020 {
+   |
+
+error: this `if` has identical blocks
+  --> $DIR/shared_at_top.rs:96:18
+   |
+LL |       if x == 2019 {
+   |  __________________^
+LL | |         println!("This should trigger `IS_SAME_THAN_ELSE` as usual");
+LL | |     } else {
+   | |_____^
+   |
+note: the lint level is defined here
+  --> $DIR/shared_at_top.rs:2:9
+   |
+LL | #![deny(clippy::if_same_then_else, clippy::shared_code_in_if_blocks)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^
+note: same as this
+  --> $DIR/shared_at_top.rs:98:12
+   |
+LL |       } else {
+   |  ____________^
+LL | |         println!("This should trigger `IS_SAME_THAN_ELSE` as usual");
+LL | |     }
+   | |_____^
+
+error: aborting due to 7 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From c74e49eab911ce5d55b3692324dea64905323a88 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Tue, 23 Feb 2021 21:16:19 +0100
Subject: Adapted the lint to use the new SpanlessEq

---
 clippy_lints/src/copies.rs                         | 28 ++++++---
 clippy_utils/src/hir_utils.rs                      |  9 +--
 tests/ui/if_same_then_else.stderr                  | 28 +--------
 tests/ui/if_same_then_else2.stderr                 | 40 +-----------
 tests/ui/shared_code_in_if_blocks/shared_at_bot.rs | 15 +----
 .../shared_code_in_if_blocks/shared_at_bot.stderr  | 72 +++++++++++++---------
 .../shared_code_in_if_blocks/shared_at_top.stderr  | 24 ++++----
 .../shared_at_top_and_bot.stderr                   | 40 ++++++------
 .../ui/shared_code_in_if_blocks/valid_if_blocks.rs | 17 -----
 .../valid_if_blocks.stderr                         | 34 +++-------
 10 files changed, 111 insertions(+), 196 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/copies.rs b/clippy_lints/src/copies.rs
index 4a701dc8898..7a9f299d8e0 100644
--- a/clippy_lints/src/copies.rs
+++ b/clippy_lints/src/copies.rs
@@ -295,11 +295,21 @@ fn scan_block_for_eq(cx: &LateContext<'tcx>, blocks: &[&Block<'tcx>]) -> (usize,
         let l_stmts = win[0].stmts;
         let r_stmts = win[1].stmts;
 
+        // `SpanlessEq` now keeps track of the locals and is therefore context sensitive clippy#6752.
+        // The comparison therefor needs to be done in a way that builds the correct context.
         let mut evaluator = SpanlessEq::new(cx);
+        let mut evaluator = evaluator.inter_expr();
+
         let current_start_eq = count_eq(&mut l_stmts.iter(), &mut r_stmts.iter(), |l, r| evaluator.eq_stmt(l, r));
-        let current_end_eq = count_eq(&mut l_stmts.iter().rev(), &mut r_stmts.iter().rev(), |l, r| {
-            evaluator.eq_stmt(l, r)
-        });
+
+        let current_end_eq = {
+            // We skip the middle statements which can't be equal
+            let end_comparison_count = l_stmts.len().min(r_stmts.len()) - current_start_eq;
+            let it1 = l_stmts.iter().skip(l_stmts.len() - end_comparison_count);
+            let it2 = r_stmts.iter().skip(r_stmts.len() - end_comparison_count);
+            it1.zip(it2)
+                .fold(0, |acc, (l, r)| if evaluator.eq_stmt(l, r) { acc + 1 } else { 0 })
+        };
         let block_expr_eq = both(&win[0].expr, &win[1].expr, |l, r| evaluator.eq_expr(l, r));
 
         // IF_SAME_THEN_ELSE
@@ -458,8 +468,8 @@ fn emit_shared_code_in_if_blocks_lint(
     // Emit lint
     if suggestions.len() == 1 {
         let (place_str, span, sugg) = suggestions.pop().unwrap();
-        let msg = format!("All if blocks contain the same code at the {}", place_str);
-        let help = format!("Consider moving the {} statements out like this", place_str);
+        let msg = format!("all if blocks contain the same code at the {}", place_str);
+        let help = format!("consider moving the {} statements out like this", place_str);
         span_lint_and_then(cx, SHARED_CODE_IN_IF_BLOCKS, span, msg.as_str(), |diag| {
             diag.span_suggestion(span, help.as_str(), sugg, Applicability::Unspecified);
 
@@ -472,20 +482,20 @@ fn emit_shared_code_in_if_blocks_lint(
             cx,
             SHARED_CODE_IN_IF_BLOCKS,
             start_span,
-            "All if blocks contain the same code at the start and the end. Here at the start:",
+            "all if blocks contain the same code at the start and the end. Here at the start",
             move |diag| {
-                diag.span_note(end_span, "And here at the end:");
+                diag.span_note(end_span, "and here at the end");
 
                 diag.span_suggestion(
                     start_span,
-                    "Consider moving the start statements out like this:",
+                    "consider moving the start statements out like this",
                     start_sugg,
                     Applicability::Unspecified,
                 );
 
                 diag.span_suggestion(
                     end_span,
-                    "And consider moving the end statements out like this:",
+                    "and consider moving the end statements out like this",
                     end_sugg,
                     Applicability::Unspecified,
                 );
diff --git a/clippy_utils/src/hir_utils.rs b/clippy_utils/src/hir_utils.rs
index 8b90fedbafe..000c249bb0f 100644
--- a/clippy_utils/src/hir_utils.rs
+++ b/clippy_utils/src/hir_utils.rs
@@ -58,13 +58,14 @@ impl<'a, 'tcx> SpanlessEq<'a, 'tcx> {
 
     /// Use this method to wrap comparisons that may involve inter-expression context.
     /// See `self.locals`.
-    fn inter_expr(&mut self) -> HirEqInterExpr<'_, 'a, 'tcx> {
+    pub fn inter_expr(&mut self) -> HirEqInterExpr<'_, 'a, 'tcx> {
         HirEqInterExpr {
             inner: self,
             locals: HirIdMap::default(),
         }
     }
 
+    #[allow(dead_code)]
     pub fn eq_block(&mut self, left: &Block<'_>, right: &Block<'_>) -> bool {
         self.inter_expr().eq_block(left, right)
     }
@@ -82,7 +83,7 @@ impl<'a, 'tcx> SpanlessEq<'a, 'tcx> {
     }
 }
 
-struct HirEqInterExpr<'a, 'b, 'tcx> {
+pub struct HirEqInterExpr<'a, 'b, 'tcx> {
     inner: &'a mut SpanlessEq<'b, 'tcx>,
 
     // When binding are declared, the binding ID in the left expression is mapped to the one on the
@@ -92,7 +93,7 @@ struct HirEqInterExpr<'a, 'b, 'tcx> {
 }
 
 impl HirEqInterExpr<'_, '_, '_> {
-    fn eq_stmt(&mut self, left: &Stmt<'_>, right: &Stmt<'_>) -> bool {
+    pub fn eq_stmt(&mut self, left: &Stmt<'_>, right: &Stmt<'_>) -> bool {
         match (&left.kind, &right.kind) {
             (&StmtKind::Local(ref l), &StmtKind::Local(ref r)) => {
                 self.eq_pat(&l.pat, &r.pat)
@@ -159,7 +160,7 @@ impl HirEqInterExpr<'_, '_, '_> {
     }
 
     #[allow(clippy::similar_names)]
-    fn eq_expr(&mut self, left: &Expr<'_>, right: &Expr<'_>) -> bool {
+    pub fn eq_expr(&mut self, left: &Expr<'_>, right: &Expr<'_>) -> bool {
         if !self.inner.allow_side_effects && differing_macro_contexts(left.span, right.span) {
             return false;
         }
diff --git a/tests/ui/if_same_then_else.stderr b/tests/ui/if_same_then_else.stderr
index 2f38052fc20..74b11bac487 100644
--- a/tests/ui/if_same_then_else.stderr
+++ b/tests/ui/if_same_then_else.stderr
@@ -82,31 +82,5 @@ LL | |         42
 LL | |     };
    | |_____^
 
-error: this `if` has identical blocks
-  --> $DIR/if_same_then_else.rs:95:13
-   |
-LL |       if true {
-   |  _____________^
-LL | |         let bar = if true { 42 } else { 43 };
-LL | |
-LL | |         while foo() {
-...  |
-LL | |         bar + 1;
-LL | |     } else {
-   | |_____^
-   |
-note: same as this
-  --> $DIR/if_same_then_else.rs:102:12
-   |
-LL |       } else {
-   |  ____________^
-LL | |         //~ ERROR same body as `if` block
-LL | |         let bar = if true { 42 } else { 43 };
-LL | |
-...  |
-LL | |         bar + 1;
-LL | |     }
-   | |_____^
-
-error: aborting due to 5 previous errors
+error: aborting due to 4 previous errors
 
diff --git a/tests/ui/if_same_then_else2.stderr b/tests/ui/if_same_then_else2.stderr
index b31eb46a982..a0e636e3a61 100644
--- a/tests/ui/if_same_then_else2.stderr
+++ b/tests/ui/if_same_then_else2.stderr
@@ -1,19 +1,5 @@
 error: this `if` has identical blocks
-  --> $DIR/if_same_then_else2.rs:21:12
-   |
-LL |       } else {
-   |  ____________^
-LL | |         //~ ERROR same body as `if` block
-LL | |         for _ in &[42] {
-LL | |             let bar: &Option<_> = &Some::<u8>(42);
-...  |
-LL | |         }
-LL | |     }
-   | |_____^
-   |
-   = note: `-D clippy::if-same-then-else` implied by `-D warnings`
-note: same as this
-  --> $DIR/if_same_then_else2.rs:12:13
+  --> $DIR/if_same_then_else2.rs:13:13
    |
 LL |       if true {
    |  _____________^
@@ -33,7 +19,7 @@ LL |       } else {
    |  ____________^
 LL | |         //~ ERROR same body as `if` block
 LL | |         for _ in &[42] {
-LL | |             let foo: &Option<_> = &Some::<u8>(42);
+LL | |             let bar: &Option<_> = &Some::<u8>(42);
 ...  |
 LL | |         }
 LL | |     }
@@ -115,25 +101,5 @@ LL | |         Ok("foo")?;
 LL | |     }
    | |_____^
 
-error: this `if` has identical blocks
-  --> $DIR/if_same_then_else2.rs:122:20
-   |
-LL |       } else if true {
-   |  ____________________^
-LL | |         let foo = "";
-LL | |         return Ok(&foo[0..]);
-LL | |     } else {
-   | |_____^
-   |
-note: same as this
-  --> $DIR/if_same_then_else2.rs:125:12
-   |
-LL |       } else {
-   |  ____________^
-LL | |         let foo = "";
-LL | |         return Ok(&foo[0..]);
-LL | |     }
-   | |_____^
-
-error: aborting due to 6 previous errors
+error: aborting due to 5 previous errors
 
diff --git a/tests/ui/shared_code_in_if_blocks/shared_at_bot.rs b/tests/ui/shared_code_in_if_blocks/shared_at_bot.rs
index 5392da7ac7a..7974ea2f59c 100644
--- a/tests/ui/shared_code_in_if_blocks/shared_at_bot.rs
+++ b/tests/ui/shared_code_in_if_blocks/shared_at_bot.rs
@@ -4,7 +4,6 @@
 // This tests the shared_code_in_if_blocks lint at the end of blocks
 
 fn simple_examples() {
-    // TODO xFrednet 2021-01-06: Test with const literals at the end
     let x = 1;
 
     let _ = if x == 7 {
@@ -45,8 +44,8 @@ fn simple_examples() {
         println!("This is also eq with the else block");
         println!("Same end of block");
     } else {
-        println!("Same end of block");
         println!("This is also eq with the else block");
+        println!("Same end of block");
     }
 
     // Use of outer scope value
@@ -69,21 +68,11 @@ fn simple_examples() {
         );
     }
 
-    // TODO xFrednet 2021-01.13: Fix lint for `if let`
-    let index = Some(8);
-    if let Some(index) = index {
-        println!("The index is: {}", index);
-
-        println!("Same end of block");
-    } else {
-        println!("Same end of block");
-    }
-
     if x == 9 {
         if x == 8 {
             // No parent!!
-            println!("Hello World");
             println!("---");
+            println!("Hello World");
         } else {
             println!("Hello World");
         }
diff --git a/tests/ui/shared_code_in_if_blocks/shared_at_bot.stderr b/tests/ui/shared_code_in_if_blocks/shared_at_bot.stderr
index 62a95157d61..5ecf47bf920 100644
--- a/tests/ui/shared_code_in_if_blocks/shared_at_bot.stderr
+++ b/tests/ui/shared_code_in_if_blocks/shared_at_bot.stderr
@@ -1,5 +1,5 @@
-error: All if blocks contain the same code at the end
-  --> $DIR/shared_at_bot.rs:31:5
+error: all if blocks contain the same code at the end
+  --> $DIR/shared_at_bot.rs:30:5
    |
 LL | /         let result = false;
 LL | |         println!("Block end!");
@@ -13,7 +13,7 @@ note: the lint level is defined here
 LL | #![deny(clippy::if_same_then_else, clippy::shared_code_in_if_blocks)]
    |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    = note: The end suggestion probably needs some adjustments to use the expression result correctly.
-help: Consider moving the end statements out like this
+help: consider moving the end statements out like this
    |
 LL |     }
 LL |     let result = false;
@@ -21,8 +21,21 @@ LL |     println!("Block end!");
 LL |     result;
    |
 
-error: All if blocks contain the same code at the end
-  --> $DIR/shared_at_bot.rs:66:5
+error: all if blocks contain the same code at the end
+  --> $DIR/shared_at_bot.rs:48:5
+   |
+LL | /         println!("Same end of block");
+LL | |     }
+   | |_____^
+   |
+help: consider moving the end statements out like this
+   |
+LL |     }
+LL |     println!("Same end of block");
+   |
+
+error: all if blocks contain the same code at the end
+  --> $DIR/shared_at_bot.rs:65:5
    |
 LL | /         println!(
 LL | |             "I'm moveable because I know: `outer_scope_value`: '{}'",
@@ -31,7 +44,7 @@ LL | |         );
 LL | |     }
    | |_____^
    |
-help: Consider moving the end statements out like this
+help: consider moving the end statements out like this
    |
 LL |     }
 LL |     println!(
@@ -40,22 +53,21 @@ LL |         outer_scope_value
 LL |     );
    |
 
-error: All if blocks contain the same code at the start
-  --> $DIR/shared_at_bot.rs:83:9
+error: all if blocks contain the same code at the end
+  --> $DIR/shared_at_bot.rs:77:9
    |
-LL | /         if x == 8 {
-LL | |             // No parent!!
-LL | |             println!("Hello World");
-   | |____________________________________^
+LL | /             println!("Hello World");
+LL | |         }
+   | |_________^
    |
-help: Consider moving the start statements out like this
+help: consider moving the end statements out like this
    |
+LL |         }
 LL |         println!("Hello World");
-LL |         if x == 8 {
    |
 
-error: All if blocks contain the same code at the end
-  --> $DIR/shared_at_bot.rs:104:5
+error: all if blocks contain the same code at the end
+  --> $DIR/shared_at_bot.rs:93:5
    |
 LL | /         let later_used_value = "A string value";
 LL | |         println!("{}", later_used_value);
@@ -64,15 +76,15 @@ LL | |     }
    | |_____^
    |
    = warning: Some moved values might need to be renamed to avoid wrong references.
-help: Consider moving the end statements out like this
+help: consider moving the end statements out like this
    |
 LL |     }
 LL |     let later_used_value = "A string value";
 LL |     println!("{}", later_used_value);
    |
 
-error: All if blocks contain the same code at the end
-  --> $DIR/shared_at_bot.rs:117:5
+error: all if blocks contain the same code at the end
+  --> $DIR/shared_at_bot.rs:106:5
    |
 LL | /         let simple_examples = "I now identify as a &str :)";
 LL | |         println!("This is the new simple_example: {}", simple_examples);
@@ -80,52 +92,52 @@ LL | |     }
    | |_____^
    |
    = warning: Some moved values might need to be renamed to avoid wrong references.
-help: Consider moving the end statements out like this
+help: consider moving the end statements out like this
    |
 LL |     }
 LL |     let simple_examples = "I now identify as a &str :)";
 LL |     println!("This is the new simple_example: {}", simple_examples);
    |
 
-error: All if blocks contain the same code at the end
-  --> $DIR/shared_at_bot.rs:182:5
+error: all if blocks contain the same code at the end
+  --> $DIR/shared_at_bot.rs:171:5
    |
 LL | /         x << 2
 LL | |     };
    | |_____^
    |
    = note: The end suggestion probably needs some adjustments to use the expression result correctly.
-help: Consider moving the end statements out like this
+help: consider moving the end statements out like this
    |
 LL |     }
 LL |     x << 2;
    |
 
-error: All if blocks contain the same code at the end
-  --> $DIR/shared_at_bot.rs:189:5
+error: all if blocks contain the same code at the end
+  --> $DIR/shared_at_bot.rs:178:5
    |
 LL | /         x * 4
 LL | |     }
    | |_____^
    |
    = note: The end suggestion probably needs some adjustments to use the expression result correctly.
-help: Consider moving the end statements out like this
+help: consider moving the end statements out like this
    |
 LL |     }
 LL |     x * 4
    |
 
-error: All if blocks contain the same code at the end
-  --> $DIR/shared_at_bot.rs:201:44
+error: all if blocks contain the same code at the end
+  --> $DIR/shared_at_bot.rs:190:44
    |
 LL |     if x == 17 { b = 1; a = 0x99; } else { a = 0x99; }
    |                                            ^^^^^^^^^^^
    |
-help: Consider moving the end statements out like this
+help: consider moving the end statements out like this
    |
 LL |     if x == 17 { b = 1; a = 0x99; } else { }
 LL |     a = 0x99;
    |
 
-error: aborting due to 8 previous errors
+error: aborting due to 9 previous errors
 
diff --git a/tests/ui/shared_code_in_if_blocks/shared_at_top.stderr b/tests/ui/shared_code_in_if_blocks/shared_at_top.stderr
index d217083c413..1ad924aba6a 100644
--- a/tests/ui/shared_code_in_if_blocks/shared_at_top.stderr
+++ b/tests/ui/shared_code_in_if_blocks/shared_at_top.stderr
@@ -1,4 +1,4 @@
-error: All if blocks contain the same code at the start
+error: all if blocks contain the same code at the start
   --> $DIR/shared_at_top.rs:10:5
    |
 LL | /     if true {
@@ -10,13 +10,13 @@ note: the lint level is defined here
    |
 LL | #![deny(clippy::if_same_then_else, clippy::shared_code_in_if_blocks)]
    |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-help: Consider moving the start statements out like this
+help: consider moving the start statements out like this
    |
 LL |     println!("Hello World!");
 LL |     if true {
    |
 
-error: All if blocks contain the same code at the start
+error: all if blocks contain the same code at the start
   --> $DIR/shared_at_top.rs:19:5
    |
 LL | /     if x == 0 {
@@ -26,7 +26,7 @@ LL | |         let _z = y;
    | |___________________^
    |
    = warning: Some moved values might need to be renamed to avoid wrong references.
-help: Consider moving the start statements out like this
+help: consider moving the start statements out like this
    |
 LL |     let y = 9;
 LL |     println!("The value y was set to: `{}`", y);
@@ -34,20 +34,20 @@ LL |     let _z = y;
 LL |     if x == 0 {
    |
 
-error: All if blocks contain the same code at the start
+error: all if blocks contain the same code at the start
   --> $DIR/shared_at_top.rs:40:5
    |
 LL | /     let _ = if x == 7 {
 LL | |         let y = 16;
    | |___________________^
    |
-help: Consider moving the start statements out like this
+help: consider moving the start statements out like this
    |
 LL |     let y = 16;
 LL |     let _ = if x == 7 {
    |
 
-error: All if blocks contain the same code at the start
+error: all if blocks contain the same code at the start
   --> $DIR/shared_at_top.rs:58:5
    |
 LL | /     if x == 10 {
@@ -56,14 +56,14 @@ LL | |         println!("Str: {}", used_value_name);
    | |_____________________________________________^
    |
    = warning: Some moved values might need to be renamed to avoid wrong references.
-help: Consider moving the start statements out like this
+help: consider moving the start statements out like this
    |
 LL |     let used_value_name = "Different type";
 LL |     println!("Str: {}", used_value_name);
 LL |     if x == 10 {
    |
 
-error: All if blocks contain the same code at the start
+error: all if blocks contain the same code at the start
   --> $DIR/shared_at_top.rs:72:5
    |
 LL | /     if x == 11 {
@@ -72,14 +72,14 @@ LL | |         println!("I'm also moveable");
    | |______________________________________^
    |
    = warning: Some moved values might need to be renamed to avoid wrong references.
-help: Consider moving the start statements out like this
+help: consider moving the start statements out like this
    |
 LL |     let can_be_overridden = "Move me";
 LL |     println!("I'm also moveable");
 LL |     if x == 11 {
    |
 
-error: All if blocks contain the same code at the start
+error: all if blocks contain the same code at the start
   --> $DIR/shared_at_top.rs:88:5
    |
 LL | /     if x == 2020 {
@@ -87,7 +87,7 @@ LL | |         println!("This should trigger the `SHARED_CODE_IN_IF_BLOCKS` lint
 LL | |         println!("Because `IF_SAME_THEN_ELSE` is allowed here");
    | |________________________________________________________________^
    |
-help: Consider moving the start statements out like this
+help: consider moving the start statements out like this
    |
 LL |     println!("This should trigger the `SHARED_CODE_IN_IF_BLOCKS` lint.");
 LL |     println!("Because `IF_SAME_THEN_ELSE` is allowed here");
diff --git a/tests/ui/shared_code_in_if_blocks/shared_at_top_and_bot.stderr b/tests/ui/shared_code_in_if_blocks/shared_at_top_and_bot.stderr
index 1ba7211b469..9f675a20a6d 100644
--- a/tests/ui/shared_code_in_if_blocks/shared_at_top_and_bot.stderr
+++ b/tests/ui/shared_code_in_if_blocks/shared_at_top_and_bot.stderr
@@ -1,4 +1,4 @@
-error: All if blocks contain the same code at the start and the end. Here at the start:
+error: all if blocks contain the same code at the start and the end. Here at the start
   --> $DIR/shared_at_top_and_bot.rs:16:5
    |
 LL | /     if x == 7 {
@@ -12,26 +12,26 @@ note: the lint level is defined here
    |
 LL | #![deny(clippy::if_same_then_else, clippy::shared_code_in_if_blocks)]
    |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-note: And here at the end:
+note: and here at the end
   --> $DIR/shared_at_top_and_bot.rs:28:5
    |
 LL | /         let _u = 9;
 LL | |     }
    | |_____^
-help: Consider moving the start statements out like this:
+help: consider moving the start statements out like this
    |
 LL |     let t = 7;
 LL |     let _overlap_start = t * 2;
 LL |     let _overlap_end = 2 * t;
 LL |     if x == 7 {
    |
-help: And consider moving the end statements out like this:
+help: and consider moving the end statements out like this
    |
 LL |     }
 LL |     let _u = 9;
    |
 
-error: All if blocks contain the same code at the start and the end. Here at the start:
+error: all if blocks contain the same code at the start and the end. Here at the start
   --> $DIR/shared_at_top_and_bot.rs:32:5
    |
 LL | /     if x == 99 {
@@ -40,7 +40,7 @@ LL | |         let _overlap_start = r;
 LL | |         let _overlap_middle = r * r;
    | |____________________________________^
    |
-note: And here at the end:
+note: and here at the end
   --> $DIR/shared_at_top_and_bot.rs:43:5
    |
 LL | /         let _overlap_end = r * r * r;
@@ -48,21 +48,21 @@ LL | |         let z = "end";
 LL | |     }
    | |_____^
    = warning: Some moved values might need to be renamed to avoid wrong references.
-help: Consider moving the start statements out like this:
+help: consider moving the start statements out like this
    |
 LL |     let r = 7;
 LL |     let _overlap_start = r;
 LL |     let _overlap_middle = r * r;
 LL |     if x == 99 {
    |
-help: And consider moving the end statements out like this:
+help: and consider moving the end statements out like this
    |
 LL |     }
 LL |     let _overlap_end = r * r * r;
 LL |     let z = "end";
    |
 
-error: All if blocks contain the same code at the start and the end. Here at the start:
+error: all if blocks contain the same code at the start and the end. Here at the start
   --> $DIR/shared_at_top_and_bot.rs:61:5
    |
 LL | /     if (x > 7 && y < 13) || (x + y) % 2 == 1 {
@@ -71,7 +71,7 @@ LL | |         let b = 0xffff00ff;
 LL | |         let e_id = gen_id(a, b);
    | |________________________________^
    |
-note: And here at the end:
+note: and here at the end
   --> $DIR/shared_at_top_and_bot.rs:81:5
    |
 LL | /         let pack = DataPack {
@@ -83,14 +83,14 @@ LL | |         process_data(pack);
 LL | |     }
    | |_____^
    = warning: Some moved values might need to be renamed to avoid wrong references.
-help: Consider moving the start statements out like this:
+help: consider moving the start statements out like this
    |
 LL |     let a = 0xcafe;
 LL |     let b = 0xffff00ff;
 LL |     let e_id = gen_id(a, b);
 LL |     if (x > 7 && y < 13) || (x + y) % 2 == 1 {
    |
-help: And consider moving the end statements out like this:
+help: and consider moving the end statements out like this
    |
 LL |     }
 LL |     let pack = DataPack {
@@ -100,51 +100,51 @@ LL |         some_data: vec![0x12, 0x34, 0x56, 0x78, 0x90],
 LL |     };
  ...
 
-error: All if blocks contain the same code at the start and the end. Here at the start:
+error: all if blocks contain the same code at the start and the end. Here at the start
   --> $DIR/shared_at_top_and_bot.rs:94:5
    |
 LL | /     let _ = if x == 7 {
 LL | |         let _ = 19;
    | |___________________^
    |
-note: And here at the end:
+note: and here at the end
   --> $DIR/shared_at_top_and_bot.rs:103:5
    |
 LL | /         x << 2
 LL | |     };
    | |_____^
    = note: The end suggestion probably needs some adjustments to use the expression result correctly.
-help: Consider moving the start statements out like this:
+help: consider moving the start statements out like this
    |
 LL |     let _ = 19;
 LL |     let _ = if x == 7 {
    |
-help: And consider moving the end statements out like this:
+help: and consider moving the end statements out like this
    |
 LL |     }
 LL |     x << 2;
    |
 
-error: All if blocks contain the same code at the start and the end. Here at the start:
+error: all if blocks contain the same code at the start and the end. Here at the start
   --> $DIR/shared_at_top_and_bot.rs:106:5
    |
 LL | /     if x == 9 {
 LL | |         let _ = 17;
    | |___________________^
    |
-note: And here at the end:
+note: and here at the end
   --> $DIR/shared_at_top_and_bot.rs:115:5
    |
 LL | /         x * 4
 LL | |     }
    | |_____^
    = note: The end suggestion probably needs some adjustments to use the expression result correctly.
-help: Consider moving the start statements out like this:
+help: consider moving the start statements out like this
    |
 LL |     let _ = 17;
 LL |     if x == 9 {
    |
-help: And consider moving the end statements out like this:
+help: and consider moving the end statements out like this
    |
 LL |     }
 LL |     x * 4
diff --git a/tests/ui/shared_code_in_if_blocks/valid_if_blocks.rs b/tests/ui/shared_code_in_if_blocks/valid_if_blocks.rs
index 480758777f1..a564b30cb1c 100644
--- a/tests/ui/shared_code_in_if_blocks/valid_if_blocks.rs
+++ b/tests/ui/shared_code_in_if_blocks/valid_if_blocks.rs
@@ -109,23 +109,6 @@ fn trigger_other_lint() {
         let _ = "This is a string";
     }
 
-    // More complex same blocks
-    if x == 17 {
-        #[derive(Debug)]
-        struct Duck {
-            num: u64,
-        };
-        let pet = Duck { num: 18 };
-        println!("{:?}", pet);
-    } else {
-        #[derive(Debug)]
-        struct Duck {
-            num: u64,
-        };
-        let pet = Duck { num: 18 };
-        println!("{:?}", pet);
-    }
-
     // Only same expression
     let _ = if x == 6 { 7 } else { 7 };
 
diff --git a/tests/ui/shared_code_in_if_blocks/valid_if_blocks.stderr b/tests/ui/shared_code_in_if_blocks/valid_if_blocks.stderr
index 003c060f072..d290c65822b 100644
--- a/tests/ui/shared_code_in_if_blocks/valid_if_blocks.stderr
+++ b/tests/ui/shared_code_in_if_blocks/valid_if_blocks.stderr
@@ -25,40 +25,20 @@ LL | |         let _ = "This is a string";
 LL | |     }
    | |_____^
 
-error: All if blocks contain the same code at the end
-  --> $DIR/valid_if_blocks.rs:125:5
-   |
-LL | /         let pet = Duck { num: 18 };
-LL | |         println!("{:?}", pet);
-LL | |     }
-   | |_____^
-   |
-note: the lint level is defined here
-  --> $DIR/valid_if_blocks.rs:2:36
-   |
-LL | #![deny(clippy::if_same_then_else, clippy::shared_code_in_if_blocks)]
-   |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-help: Consider moving the end statements out like this
-   |
-LL |     }
-LL |     let pet = Duck { num: 18 };
-LL |     println!("{:?}", pet);
-   |
-
 error: this `if` has identical blocks
-  --> $DIR/valid_if_blocks.rs:130:23
+  --> $DIR/valid_if_blocks.rs:113:23
    |
 LL |     let _ = if x == 6 { 7 } else { 7 };
    |                       ^^^^^
    |
 note: same as this
-  --> $DIR/valid_if_blocks.rs:130:34
+  --> $DIR/valid_if_blocks.rs:113:34
    |
 LL |     let _ = if x == 6 { 7 } else { 7 };
    |                                  ^^^^^
 
 error: this `if` has identical blocks
-  --> $DIR/valid_if_blocks.rs:136:23
+  --> $DIR/valid_if_blocks.rs:119:23
    |
 LL |       } else if x == 68 {
    |  _______________________^
@@ -71,7 +51,7 @@ LL | |     } else {
    | |_____^
    |
 note: same as this
-  --> $DIR/valid_if_blocks.rs:145:12
+  --> $DIR/valid_if_blocks.rs:128:12
    |
 LL |       } else {
    |  ____________^
@@ -84,7 +64,7 @@ LL | |     };
    | |_____^
 
 error: this `if` has identical blocks
-  --> $DIR/valid_if_blocks.rs:158:23
+  --> $DIR/valid_if_blocks.rs:141:23
    |
 LL |       } else if x == 68 {
    |  _______________________^
@@ -94,7 +74,7 @@ LL | |     } else {
    | |_____^
    |
 note: same as this
-  --> $DIR/valid_if_blocks.rs:161:12
+  --> $DIR/valid_if_blocks.rs:144:12
    |
 LL |       } else {
    |  ____________^
@@ -103,5 +83,5 @@ LL | |         println!("I'm a doppelgänger");
 LL | |     }
    | |_____^
 
-error: aborting due to 5 previous errors
+error: aborting due to 4 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 617c65baa90cdbd9228cacad4f2079a9d868d070 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Thu, 25 Feb 2021 23:33:46 +0100
Subject: Moving shared_code_in_if_blocks to clippy::complexity and running
 lintcheck

---
 clippy_lints/src/copies.rs                         |  6 +--
 clippy_lints/src/lib.rs                            |  2 +-
 clippy_utils/src/hir_utils.rs                      |  6 ++-
 clippy_utils/src/lib.rs                            | 18 ++++++--
 .../checked_unwrap/complex_conditionals_nested.rs  |  2 +-
 tests/ui/checked_unwrap/simple_conditionals.rs     |  2 +-
 tests/ui/default_numeric_fallback.rs               |  1 +
 tests/ui/default_numeric_fallback.stderr           | 48 +++++++++++-----------
 tests/ui/if_same_then_else.stderr                  | 28 ++++++++++++-
 tests/ui/if_same_then_else2.stderr                 | 22 +++++++++-
 tests/ui/needless_bool/simple.rs                   |  3 +-
 tests/ui/needless_bool/simple.stderr               |  8 ++--
 tests/ui/needless_return.fixed                     |  9 +++-
 tests/ui/needless_return.rs                        |  9 +++-
 tests/ui/needless_return.stderr                    | 36 ++++++++--------
 tests/ui/shared_code_in_if_blocks/shared_at_bot.rs | 16 ++++++++
 .../shared_code_in_if_blocks/shared_at_bot.stderr  | 10 ++---
 .../shared_code_in_if_blocks/shared_at_top.stderr  |  6 +--
 .../shared_at_top_and_bot.stderr                   |  8 ++--
 .../ui/shared_code_in_if_blocks/valid_if_blocks.rs |  8 ++++
 .../valid_if_blocks.stderr                         | 16 ++++----
 21 files changed, 180 insertions(+), 84 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/copies.rs b/clippy_lints/src/copies.rs
index 7a9f299d8e0..8b94ac96880 100644
--- a/clippy_lints/src/copies.rs
+++ b/clippy_lints/src/copies.rs
@@ -142,7 +142,7 @@ declare_clippy_lint! {
     /// };
     /// ```
     pub SHARED_CODE_IN_IF_BLOCKS,
-    nursery,
+    complexity,
     "`if` statement with shared code in all blocks"
 }
 
@@ -457,11 +457,11 @@ fn emit_shared_code_in_if_blocks_lint(
 
     let add_optional_msgs = |diag: &mut DiagnosticBuilder<'_>| {
         if add_expr_note {
-            diag.note("The end suggestion probably needs some adjustments to use the expression result correctly.");
+            diag.note("The end suggestion probably needs some adjustments to use the expression result correctly");
         }
 
         if warn_about_moved_symbol {
-            diag.warn("Some moved values might need to be renamed to avoid wrong references.");
+            diag.warn("Some moved values might need to be renamed to avoid wrong references");
         }
     };
 
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 9afbf95a342..3f5c1c7c526 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1485,6 +1485,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&comparison_chain::COMPARISON_CHAIN),
         LintId::of(&copies::IFS_SAME_COND),
         LintId::of(&copies::IF_SAME_THEN_ELSE),
+        LintId::of(&copies::SHARED_CODE_IN_IF_BLOCKS),
         LintId::of(&default::FIELD_REASSIGN_WITH_DEFAULT),
         LintId::of(&derive::DERIVE_HASH_XOR_EQ),
         LintId::of(&derive::DERIVE_ORD_XOR_PARTIAL_ORD),
@@ -2063,7 +2064,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_group(true, "clippy::nursery", Some("clippy_nursery"), vec![
         LintId::of(&attrs::EMPTY_LINE_AFTER_OUTER_ATTR),
         LintId::of(&cognitive_complexity::COGNITIVE_COMPLEXITY),
-        LintId::of(&copies::SHARED_CODE_IN_IF_BLOCKS),
         LintId::of(&disallowed_method::DISALLOWED_METHOD),
         LintId::of(&fallible_impl_from::FALLIBLE_IMPL_FROM),
         LintId::of(&floating_point_arithmetic::IMPRECISE_FLOPS),
diff --git a/clippy_utils/src/hir_utils.rs b/clippy_utils/src/hir_utils.rs
index 000c249bb0f..571eec9e530 100644
--- a/clippy_utils/src/hir_utils.rs
+++ b/clippy_utils/src/hir_utils.rs
@@ -96,9 +96,11 @@ impl HirEqInterExpr<'_, '_, '_> {
     pub fn eq_stmt(&mut self, left: &Stmt<'_>, right: &Stmt<'_>) -> bool {
         match (&left.kind, &right.kind) {
             (&StmtKind::Local(ref l), &StmtKind::Local(ref r)) => {
-                self.eq_pat(&l.pat, &r.pat)
+                // eq_pat adds the HirIds to the locals map. We therefor call it last to make sure that
+                // these only get added if the init and type is equal.
+                both(&l.init, &r.init, |l, r| self.eq_expr(l, r))
                     && both(&l.ty, &r.ty, |l, r| self.eq_ty(l, r))
-                    && both(&l.init, &r.init, |l, r| self.eq_expr(l, r))
+                    && self.eq_pat(&l.pat, &r.pat)
             },
             (&StmtKind::Expr(ref l), &StmtKind::Expr(ref r)) | (&StmtKind::Semi(ref l), &StmtKind::Semi(ref r)) => {
                 self.eq_expr(l, r)
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index d6364625e70..f9576068dd6 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -609,9 +609,9 @@ pub fn get_pat_name(pat: &Pat<'_>) -> Option<Symbol> {
     }
 }
 
-struct ContainsName {
-    name: Symbol,
-    result: bool,
+pub struct ContainsName {
+    pub name: Symbol,
+    pub result: bool,
 }
 
 impl<'tcx> Visitor<'tcx> for ContainsName {
@@ -1216,6 +1216,8 @@ pub fn if_sequence<'tcx>(mut expr: &'tcx Expr<'tcx>) -> (Vec<&'tcx Expr<'tcx>>,
     (conds, blocks)
 }
 
+/// This function returns true if the given expression is the `else` or `if else` part of an if
+/// statement
 pub fn parent_node_is_if_expr(expr: &Expr<'_>, cx: &LateContext<'_>) -> bool {
     let map = cx.tcx.hir();
     let parent_id = map.get_parent_node(expr.hir_id);
@@ -1326,6 +1328,16 @@ pub fn fn_def_id(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<DefId> {
     }
 }
 
+/// This function checks if any of the lints in the slice is enabled for the provided `HirId`.
+/// A lint counts as enabled with any of the levels: `Level::Forbid` | `Level::Deny` | `Level::Warn`
+///
+/// ```ignore
+/// #[deny(clippy::YOUR_AWESOME_LINT)]
+/// println!("Hello, World!"); // <- Clippy code: run_lints(cx, &[YOUR_AWESOME_LINT], id) == true
+///
+/// #[allow(clippy::YOUR_AWESOME_LINT)]
+/// println!("See you soon!"); // <- Clippy code: run_lints(cx, &[YOUR_AWESOME_LINT], id) == false
+/// ```
 pub fn run_lints(cx: &LateContext<'_>, lints: &[&'static Lint], id: HirId) -> bool {
     lints.iter().any(|lint| {
         matches!(
diff --git a/tests/ui/checked_unwrap/complex_conditionals_nested.rs b/tests/ui/checked_unwrap/complex_conditionals_nested.rs
index 2307996a48f..99e8fb95466 100644
--- a/tests/ui/checked_unwrap/complex_conditionals_nested.rs
+++ b/tests/ui/checked_unwrap/complex_conditionals_nested.rs
@@ -1,5 +1,5 @@
 #![deny(clippy::panicking_unwrap, clippy::unnecessary_unwrap)]
-#![allow(clippy::if_same_then_else)]
+#![allow(clippy::if_same_then_else, clippy::shared_code_in_if_blocks)]
 
 fn test_nested() {
     fn nested() {
diff --git a/tests/ui/checked_unwrap/simple_conditionals.rs b/tests/ui/checked_unwrap/simple_conditionals.rs
index 36967630834..0459100d88a 100644
--- a/tests/ui/checked_unwrap/simple_conditionals.rs
+++ b/tests/ui/checked_unwrap/simple_conditionals.rs
@@ -1,5 +1,5 @@
 #![deny(clippy::panicking_unwrap, clippy::unnecessary_unwrap)]
-#![allow(clippy::if_same_then_else)]
+#![allow(clippy::if_same_then_else, clippy::shared_code_in_if_blocks)]
 
 macro_rules! m {
     ($a:expr) => {
diff --git a/tests/ui/default_numeric_fallback.rs b/tests/ui/default_numeric_fallback.rs
index 0b3758952ac..de89f806c58 100644
--- a/tests/ui/default_numeric_fallback.rs
+++ b/tests/ui/default_numeric_fallback.rs
@@ -3,6 +3,7 @@
 #![allow(clippy::never_loop)]
 #![allow(clippy::no_effect)]
 #![allow(clippy::unnecessary_operation)]
+#![allow(clippy::shared_code_in_if_blocks)]
 
 mod basic_expr {
     fn test() {
diff --git a/tests/ui/default_numeric_fallback.stderr b/tests/ui/default_numeric_fallback.stderr
index b31aa4ebcf8..d1c4c8203dd 100644
--- a/tests/ui/default_numeric_fallback.stderr
+++ b/tests/ui/default_numeric_fallback.stderr
@@ -1,5 +1,5 @@
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:10:17
+  --> $DIR/default_numeric_fallback.rs:11:17
    |
 LL |         let x = 22;
    |                 ^^ help: consider adding suffix: `22_i32`
@@ -7,139 +7,139 @@ LL |         let x = 22;
    = note: `-D clippy::default-numeric-fallback` implied by `-D warnings`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:11:18
+  --> $DIR/default_numeric_fallback.rs:12:18
    |
 LL |         let x = [1, 2, 3];
    |                  ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:11:21
+  --> $DIR/default_numeric_fallback.rs:12:21
    |
 LL |         let x = [1, 2, 3];
    |                     ^ help: consider adding suffix: `2_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:11:24
+  --> $DIR/default_numeric_fallback.rs:12:24
    |
 LL |         let x = [1, 2, 3];
    |                        ^ help: consider adding suffix: `3_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:12:28
+  --> $DIR/default_numeric_fallback.rs:13:28
    |
 LL |         let x = if true { (1, 2) } else { (3, 4) };
    |                            ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:12:31
+  --> $DIR/default_numeric_fallback.rs:13:31
    |
 LL |         let x = if true { (1, 2) } else { (3, 4) };
    |                               ^ help: consider adding suffix: `2_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:12:44
+  --> $DIR/default_numeric_fallback.rs:13:44
    |
 LL |         let x = if true { (1, 2) } else { (3, 4) };
    |                                            ^ help: consider adding suffix: `3_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:12:47
+  --> $DIR/default_numeric_fallback.rs:13:47
    |
 LL |         let x = if true { (1, 2) } else { (3, 4) };
    |                                               ^ help: consider adding suffix: `4_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:13:23
+  --> $DIR/default_numeric_fallback.rs:14:23
    |
 LL |         let x = match 1 {
    |                       ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:14:13
+  --> $DIR/default_numeric_fallback.rs:15:13
    |
 LL |             1 => 1,
    |             ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:14:18
+  --> $DIR/default_numeric_fallback.rs:15:18
    |
 LL |             1 => 1,
    |                  ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:15:18
+  --> $DIR/default_numeric_fallback.rs:16:18
    |
 LL |             _ => 2,
    |                  ^ help: consider adding suffix: `2_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:19:17
+  --> $DIR/default_numeric_fallback.rs:20:17
    |
 LL |         let x = 0.12;
    |                 ^^^^ help: consider adding suffix: `0.12_f64`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:37:21
+  --> $DIR/default_numeric_fallback.rs:38:21
    |
 LL |             let y = 1;
    |                     ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:45:21
+  --> $DIR/default_numeric_fallback.rs:46:21
    |
 LL |             let y = 1;
    |                     ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:51:21
+  --> $DIR/default_numeric_fallback.rs:52:21
    |
 LL |             let y = 1;
    |                     ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:63:9
+  --> $DIR/default_numeric_fallback.rs:64:9
    |
 LL |         1
    |         ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:69:27
+  --> $DIR/default_numeric_fallback.rs:70:27
    |
 LL |         let f = || -> _ { 1 };
    |                           ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:73:29
+  --> $DIR/default_numeric_fallback.rs:74:29
    |
 LL |         let f = || -> i32 { 1 };
    |                             ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:87:21
+  --> $DIR/default_numeric_fallback.rs:88:21
    |
 LL |         generic_arg(1);
    |                     ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:90:32
+  --> $DIR/default_numeric_fallback.rs:91:32
    |
 LL |         let x: _ = generic_arg(1);
    |                                ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:108:28
+  --> $DIR/default_numeric_fallback.rs:109:28
    |
 LL |         GenericStruct { x: 1 };
    |                            ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:111:36
+  --> $DIR/default_numeric_fallback.rs:112:36
    |
 LL |         let _ = GenericStruct { x: 1 };
    |                                    ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:131:23
+  --> $DIR/default_numeric_fallback.rs:132:23
    |
 LL |         s.generic_arg(1);
    |                       ^ help: consider adding suffix: `1_i32`
diff --git a/tests/ui/if_same_then_else.stderr b/tests/ui/if_same_then_else.stderr
index 74b11bac487..2f38052fc20 100644
--- a/tests/ui/if_same_then_else.stderr
+++ b/tests/ui/if_same_then_else.stderr
@@ -82,5 +82,31 @@ LL | |         42
 LL | |     };
    | |_____^
 
-error: aborting due to 4 previous errors
+error: this `if` has identical blocks
+  --> $DIR/if_same_then_else.rs:95:13
+   |
+LL |       if true {
+   |  _____________^
+LL | |         let bar = if true { 42 } else { 43 };
+LL | |
+LL | |         while foo() {
+...  |
+LL | |         bar + 1;
+LL | |     } else {
+   | |_____^
+   |
+note: same as this
+  --> $DIR/if_same_then_else.rs:102:12
+   |
+LL |       } else {
+   |  ____________^
+LL | |         //~ ERROR same body as `if` block
+LL | |         let bar = if true { 42 } else { 43 };
+LL | |
+...  |
+LL | |         bar + 1;
+LL | |     }
+   | |_____^
+
+error: aborting due to 5 previous errors
 
diff --git a/tests/ui/if_same_then_else2.stderr b/tests/ui/if_same_then_else2.stderr
index a0e636e3a61..6524be0af85 100644
--- a/tests/ui/if_same_then_else2.stderr
+++ b/tests/ui/if_same_then_else2.stderr
@@ -101,5 +101,25 @@ LL | |         Ok("foo")?;
 LL | |     }
    | |_____^
 
-error: aborting due to 5 previous errors
+error: this `if` has identical blocks
+  --> $DIR/if_same_then_else2.rs:122:20
+   |
+LL |       } else if true {
+   |  ____________________^
+LL | |         let foo = "";
+LL | |         return Ok(&foo[0..]);
+LL | |     } else {
+   | |_____^
+   |
+note: same as this
+  --> $DIR/if_same_then_else2.rs:125:12
+   |
+LL |       } else {
+   |  ____________^
+LL | |         let foo = "";
+LL | |         return Ok(&foo[0..]);
+LL | |     }
+   | |_____^
+
+error: aborting due to 6 previous errors
 
diff --git a/tests/ui/needless_bool/simple.rs b/tests/ui/needless_bool/simple.rs
index e9f1428fc3a..678040fa98b 100644
--- a/tests/ui/needless_bool/simple.rs
+++ b/tests/ui/needless_bool/simple.rs
@@ -4,7 +4,8 @@
     dead_code,
     clippy::no_effect,
     clippy::if_same_then_else,
-    clippy::needless_return
+    clippy::needless_return,
+    clippy::shared_code_in_if_blocks
 )]
 
 fn main() {
diff --git a/tests/ui/needless_bool/simple.stderr b/tests/ui/needless_bool/simple.stderr
index c57a8a042fb..0ccc9416bcd 100644
--- a/tests/ui/needless_bool/simple.stderr
+++ b/tests/ui/needless_bool/simple.stderr
@@ -1,5 +1,5 @@
 error: this if-then-else expression will always return true
-  --> $DIR/simple.rs:13:5
+  --> $DIR/simple.rs:14:5
    |
 LL | /     if x {
 LL | |         true
@@ -11,7 +11,7 @@ LL | |     };
    = note: `-D clippy::needless-bool` implied by `-D warnings`
 
 error: this if-then-else expression will always return false
-  --> $DIR/simple.rs:18:5
+  --> $DIR/simple.rs:19:5
    |
 LL | /     if x {
 LL | |         false
@@ -21,7 +21,7 @@ LL | |     };
    | |_____^
 
 error: this if-then-else expression will always return true
-  --> $DIR/simple.rs:33:5
+  --> $DIR/simple.rs:34:5
    |
 LL | /     if x {
 LL | |         return true;
@@ -31,7 +31,7 @@ LL | |     };
    | |_____^
 
 error: this if-then-else expression will always return false
-  --> $DIR/simple.rs:41:5
+  --> $DIR/simple.rs:42:5
    |
 LL | /     if x {
 LL | |         return false;
diff --git a/tests/ui/needless_return.fixed b/tests/ui/needless_return.fixed
index 990475fcb58..ebf74cfef12 100644
--- a/tests/ui/needless_return.fixed
+++ b/tests/ui/needless_return.fixed
@@ -1,7 +1,12 @@
 // run-rustfix
 
-#![allow(unused, clippy::needless_bool)]
-#![allow(clippy::if_same_then_else, clippy::single_match)]
+#![allow(unused)]
+#![allow(
+    clippy::if_same_then_else,
+    clippy::single_match,
+    clippy::shared_code_in_if_blocks,
+    clippy::needless_bool
+)]
 #![warn(clippy::needless_return)]
 
 macro_rules! the_answer {
diff --git a/tests/ui/needless_return.rs b/tests/ui/needless_return.rs
index dec3d84a020..2bebccdabca 100644
--- a/tests/ui/needless_return.rs
+++ b/tests/ui/needless_return.rs
@@ -1,7 +1,12 @@
 // run-rustfix
 
-#![allow(unused, clippy::needless_bool)]
-#![allow(clippy::if_same_then_else, clippy::single_match)]
+#![allow(unused)]
+#![allow(
+    clippy::if_same_then_else,
+    clippy::single_match,
+    clippy::shared_code_in_if_blocks,
+    clippy::needless_bool
+)]
 #![warn(clippy::needless_return)]
 
 macro_rules! the_answer {
diff --git a/tests/ui/needless_return.stderr b/tests/ui/needless_return.stderr
index ae31d607541..075db22456f 100644
--- a/tests/ui/needless_return.stderr
+++ b/tests/ui/needless_return.stderr
@@ -1,5 +1,5 @@
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:18:5
+  --> $DIR/needless_return.rs:23:5
    |
 LL |     return true;
    |     ^^^^^^^^^^^^ help: remove `return`: `true`
@@ -7,103 +7,103 @@ LL |     return true;
    = note: `-D clippy::needless-return` implied by `-D warnings`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:22:5
+  --> $DIR/needless_return.rs:27:5
    |
 LL |     return true;
    |     ^^^^^^^^^^^^ help: remove `return`: `true`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:27:9
+  --> $DIR/needless_return.rs:32:9
    |
 LL |         return true;
    |         ^^^^^^^^^^^^ help: remove `return`: `true`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:29:9
+  --> $DIR/needless_return.rs:34:9
    |
 LL |         return false;
    |         ^^^^^^^^^^^^^ help: remove `return`: `false`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:35:17
+  --> $DIR/needless_return.rs:40:17
    |
 LL |         true => return false,
    |                 ^^^^^^^^^^^^ help: remove `return`: `false`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:37:13
+  --> $DIR/needless_return.rs:42:13
    |
 LL |             return true;
    |             ^^^^^^^^^^^^ help: remove `return`: `true`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:44:9
+  --> $DIR/needless_return.rs:49:9
    |
 LL |         return true;
    |         ^^^^^^^^^^^^ help: remove `return`: `true`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:46:16
+  --> $DIR/needless_return.rs:51:16
    |
 LL |     let _ = || return true;
    |                ^^^^^^^^^^^ help: remove `return`: `true`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:54:5
+  --> $DIR/needless_return.rs:59:5
    |
 LL |     return;
    |     ^^^^^^^ help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:59:9
+  --> $DIR/needless_return.rs:64:9
    |
 LL |         return;
    |         ^^^^^^^ help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:61:9
+  --> $DIR/needless_return.rs:66:9
    |
 LL |         return;
    |         ^^^^^^^ help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:68:14
+  --> $DIR/needless_return.rs:73:14
    |
 LL |         _ => return,
    |              ^^^^^^ help: replace `return` with an empty block: `{}`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:83:9
+  --> $DIR/needless_return.rs:88:9
    |
 LL |         return String::from("test");
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove `return`: `String::from("test")`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:85:9
+  --> $DIR/needless_return.rs:90:9
    |
 LL |         return String::new();
    |         ^^^^^^^^^^^^^^^^^^^^^ help: remove `return`: `String::new()`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:106:32
+  --> $DIR/needless_return.rs:111:32
    |
 LL |         bar.unwrap_or_else(|_| return)
    |                                ^^^^^^ help: replace `return` with an empty block: `{}`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:111:13
+  --> $DIR/needless_return.rs:116:13
    |
 LL |             return;
    |             ^^^^^^^ help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:113:20
+  --> $DIR/needless_return.rs:118:20
    |
 LL |         let _ = || return;
    |                    ^^^^^^ help: replace `return` with an empty block: `{}`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:119:32
+  --> $DIR/needless_return.rs:124:32
    |
 LL |         res.unwrap_or_else(|_| return Foo)
    |                                ^^^^^^^^^^ help: remove `return`: `Foo`
diff --git a/tests/ui/shared_code_in_if_blocks/shared_at_bot.rs b/tests/ui/shared_code_in_if_blocks/shared_at_bot.rs
index 7974ea2f59c..6ff362cb752 100644
--- a/tests/ui/shared_code_in_if_blocks/shared_at_bot.rs
+++ b/tests/ui/shared_code_in_if_blocks/shared_at_bot.rs
@@ -190,4 +190,20 @@ fn test_suggestion_with_weird_formatting() {
     if x == 17 { b = 1; a = 0x99; } else { a = 0x99; }
 }
 
+fn fp_test() {
+    let x = 17;
+
+    if x == 18 {
+        let y = 19;
+        if y < x {
+            println!("Trigger")
+        }
+    } else {
+        let z = 166;
+        if z < x {
+            println!("Trigger")
+        }
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/shared_code_in_if_blocks/shared_at_bot.stderr b/tests/ui/shared_code_in_if_blocks/shared_at_bot.stderr
index 5ecf47bf920..2268d8f5365 100644
--- a/tests/ui/shared_code_in_if_blocks/shared_at_bot.stderr
+++ b/tests/ui/shared_code_in_if_blocks/shared_at_bot.stderr
@@ -12,7 +12,7 @@ note: the lint level is defined here
    |
 LL | #![deny(clippy::if_same_then_else, clippy::shared_code_in_if_blocks)]
    |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   = note: The end suggestion probably needs some adjustments to use the expression result correctly.
+   = note: The end suggestion probably needs some adjustments to use the expression result correctly
 help: consider moving the end statements out like this
    |
 LL |     }
@@ -75,7 +75,7 @@ LL | |         // I'm expecting a note about this
 LL | |     }
    | |_____^
    |
-   = warning: Some moved values might need to be renamed to avoid wrong references.
+   = warning: Some moved values might need to be renamed to avoid wrong references
 help: consider moving the end statements out like this
    |
 LL |     }
@@ -91,7 +91,7 @@ LL | |         println!("This is the new simple_example: {}", simple_examples);
 LL | |     }
    | |_____^
    |
-   = warning: Some moved values might need to be renamed to avoid wrong references.
+   = warning: Some moved values might need to be renamed to avoid wrong references
 help: consider moving the end statements out like this
    |
 LL |     }
@@ -106,7 +106,7 @@ LL | /         x << 2
 LL | |     };
    | |_____^
    |
-   = note: The end suggestion probably needs some adjustments to use the expression result correctly.
+   = note: The end suggestion probably needs some adjustments to use the expression result correctly
 help: consider moving the end statements out like this
    |
 LL |     }
@@ -120,7 +120,7 @@ LL | /         x * 4
 LL | |     }
    | |_____^
    |
-   = note: The end suggestion probably needs some adjustments to use the expression result correctly.
+   = note: The end suggestion probably needs some adjustments to use the expression result correctly
 help: consider moving the end statements out like this
    |
 LL |     }
diff --git a/tests/ui/shared_code_in_if_blocks/shared_at_top.stderr b/tests/ui/shared_code_in_if_blocks/shared_at_top.stderr
index 1ad924aba6a..76898a6ff02 100644
--- a/tests/ui/shared_code_in_if_blocks/shared_at_top.stderr
+++ b/tests/ui/shared_code_in_if_blocks/shared_at_top.stderr
@@ -25,7 +25,7 @@ LL | |         println!("The value y was set to: `{}`", y);
 LL | |         let _z = y;
    | |___________________^
    |
-   = warning: Some moved values might need to be renamed to avoid wrong references.
+   = warning: Some moved values might need to be renamed to avoid wrong references
 help: consider moving the start statements out like this
    |
 LL |     let y = 9;
@@ -55,7 +55,7 @@ LL | |         let used_value_name = "Different type";
 LL | |         println!("Str: {}", used_value_name);
    | |_____________________________________________^
    |
-   = warning: Some moved values might need to be renamed to avoid wrong references.
+   = warning: Some moved values might need to be renamed to avoid wrong references
 help: consider moving the start statements out like this
    |
 LL |     let used_value_name = "Different type";
@@ -71,7 +71,7 @@ LL | |         let can_be_overridden = "Move me";
 LL | |         println!("I'm also moveable");
    | |______________________________________^
    |
-   = warning: Some moved values might need to be renamed to avoid wrong references.
+   = warning: Some moved values might need to be renamed to avoid wrong references
 help: consider moving the start statements out like this
    |
 LL |     let can_be_overridden = "Move me";
diff --git a/tests/ui/shared_code_in_if_blocks/shared_at_top_and_bot.stderr b/tests/ui/shared_code_in_if_blocks/shared_at_top_and_bot.stderr
index 9f675a20a6d..75c3d397f2e 100644
--- a/tests/ui/shared_code_in_if_blocks/shared_at_top_and_bot.stderr
+++ b/tests/ui/shared_code_in_if_blocks/shared_at_top_and_bot.stderr
@@ -47,7 +47,7 @@ LL | /         let _overlap_end = r * r * r;
 LL | |         let z = "end";
 LL | |     }
    | |_____^
-   = warning: Some moved values might need to be renamed to avoid wrong references.
+   = warning: Some moved values might need to be renamed to avoid wrong references
 help: consider moving the start statements out like this
    |
 LL |     let r = 7;
@@ -82,7 +82,7 @@ LL | |         };
 LL | |         process_data(pack);
 LL | |     }
    | |_____^
-   = warning: Some moved values might need to be renamed to avoid wrong references.
+   = warning: Some moved values might need to be renamed to avoid wrong references
 help: consider moving the start statements out like this
    |
 LL |     let a = 0xcafe;
@@ -113,7 +113,7 @@ note: and here at the end
 LL | /         x << 2
 LL | |     };
    | |_____^
-   = note: The end suggestion probably needs some adjustments to use the expression result correctly.
+   = note: The end suggestion probably needs some adjustments to use the expression result correctly
 help: consider moving the start statements out like this
    |
 LL |     let _ = 19;
@@ -138,7 +138,7 @@ note: and here at the end
 LL | /         x * 4
 LL | |     }
    | |_____^
-   = note: The end suggestion probably needs some adjustments to use the expression result correctly.
+   = note: The end suggestion probably needs some adjustments to use the expression result correctly
 help: consider moving the start statements out like this
    |
 LL |     let _ = 17;
diff --git a/tests/ui/shared_code_in_if_blocks/valid_if_blocks.rs b/tests/ui/shared_code_in_if_blocks/valid_if_blocks.rs
index a564b30cb1c..cd397db47d0 100644
--- a/tests/ui/shared_code_in_if_blocks/valid_if_blocks.rs
+++ b/tests/ui/shared_code_in_if_blocks/valid_if_blocks.rs
@@ -91,6 +91,14 @@ fn valid_examples() {
         let _ = (x, y, z);
         // I'm so much better than the x == 418 block. Trust me
     }
+
+    let x = 1;
+    if true {
+        println!("{}", x);
+    } else {
+        let x = 2;
+        println!("{}", x);
+    }
 }
 
 /// This makes sure that the `if_same_then_else` masks the `shared_code_in_if_blocks` lint
diff --git a/tests/ui/shared_code_in_if_blocks/valid_if_blocks.stderr b/tests/ui/shared_code_in_if_blocks/valid_if_blocks.stderr
index d290c65822b..2061cc25d21 100644
--- a/tests/ui/shared_code_in_if_blocks/valid_if_blocks.stderr
+++ b/tests/ui/shared_code_in_if_blocks/valid_if_blocks.stderr
@@ -1,5 +1,5 @@
 error: this `if` has identical blocks
-  --> $DIR/valid_if_blocks.rs:102:15
+  --> $DIR/valid_if_blocks.rs:110:15
    |
 LL |       if x == 0 {
    |  _______________^
@@ -15,7 +15,7 @@ note: the lint level is defined here
 LL | #![deny(clippy::if_same_then_else, clippy::shared_code_in_if_blocks)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^
 note: same as this
-  --> $DIR/valid_if_blocks.rs:106:12
+  --> $DIR/valid_if_blocks.rs:114:12
    |
 LL |       } else {
    |  ____________^
@@ -26,19 +26,19 @@ LL | |     }
    | |_____^
 
 error: this `if` has identical blocks
-  --> $DIR/valid_if_blocks.rs:113:23
+  --> $DIR/valid_if_blocks.rs:121:23
    |
 LL |     let _ = if x == 6 { 7 } else { 7 };
    |                       ^^^^^
    |
 note: same as this
-  --> $DIR/valid_if_blocks.rs:113:34
+  --> $DIR/valid_if_blocks.rs:121:34
    |
 LL |     let _ = if x == 6 { 7 } else { 7 };
    |                                  ^^^^^
 
 error: this `if` has identical blocks
-  --> $DIR/valid_if_blocks.rs:119:23
+  --> $DIR/valid_if_blocks.rs:127:23
    |
 LL |       } else if x == 68 {
    |  _______________________^
@@ -51,7 +51,7 @@ LL | |     } else {
    | |_____^
    |
 note: same as this
-  --> $DIR/valid_if_blocks.rs:128:12
+  --> $DIR/valid_if_blocks.rs:136:12
    |
 LL |       } else {
    |  ____________^
@@ -64,7 +64,7 @@ LL | |     };
    | |_____^
 
 error: this `if` has identical blocks
-  --> $DIR/valid_if_blocks.rs:141:23
+  --> $DIR/valid_if_blocks.rs:149:23
    |
 LL |       } else if x == 68 {
    |  _______________________^
@@ -74,7 +74,7 @@ LL | |     } else {
    | |_____^
    |
 note: same as this
-  --> $DIR/valid_if_blocks.rs:144:12
+  --> $DIR/valid_if_blocks.rs:152:12
    |
 LL |       } else {
    |  ____________^
-- 
cgit 1.4.1-3-g733a5


From 8c0b4d7f65802031f0131bc56de8fb8b275d70d7 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Fri, 26 Feb 2021 21:29:55 +0100
Subject: Only running shared_code_in_if_blocks only for if statements

---
 clippy_lints/src/copies.rs | 32 +++++++++++++++++---------------
 1 file changed, 17 insertions(+), 15 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/copies.rs b/clippy_lints/src/copies.rs
index 8b94ac96880..ff99a9a09b3 100644
--- a/clippy_lints/src/copies.rs
+++ b/clippy_lints/src/copies.rs
@@ -156,23 +156,25 @@ declare_lint_pass!(CopyAndPaste => [
 impl<'tcx> LateLintPass<'tcx> for CopyAndPaste {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if !expr.span.from_expansion() {
-            // skip ifs directly in else, it will be checked in the parent if
-            if let Some(&Expr {
-                kind: ExprKind::If(_, _, Some(ref else_expr)),
-                ..
-            }) = get_parent_expr(cx, expr)
-            {
-                if else_expr.hir_id == expr.hir_id {
-                    return;
+            if let ExprKind::If(_, _, _) = expr.kind {
+                // skip ifs directly in else, it will be checked in the parent if
+                if let Some(&Expr {
+                    kind: ExprKind::If(_, _, Some(ref else_expr)),
+                    ..
+                }) = get_parent_expr(cx, expr)
+                {
+                    if else_expr.hir_id == expr.hir_id {
+                        return;
+                    }
                 }
-            }
 
-            let (conds, blocks) = if_sequence(expr);
-            // Conditions
-            lint_same_cond(cx, &conds);
-            lint_same_fns_in_if_cond(cx, &conds);
-            // Block duplication
-            lint_same_then_else(cx, &blocks, conds.len() != blocks.len(), expr);
+                let (conds, blocks) = if_sequence(expr);
+                // Conditions
+                lint_same_cond(cx, &conds);
+                lint_same_fns_in_if_cond(cx, &conds);
+                // Block duplication
+                lint_same_then_else(cx, &blocks, conds.len() != blocks.len(), expr);
+            }
         }
     }
 }
-- 
cgit 1.4.1-3-g733a5


From a6f54f5dfdfdf0017ffecfbcd6f43352b8b71ca1 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Thu, 1 Apr 2021 18:30:47 +0200
Subject: Renaming the lint to branches_sharing_code and fixing typos

---
 CHANGELOG.md                                       |   2 +-
 clippy_lints/src/copies.rs                         |  35 ++--
 clippy_lints/src/lib.rs                            |   5 +-
 clippy_utils/src/lib.rs                            |   2 +-
 tests/ui/branches_sharing_code/shared_at_bottom.rs | 209 +++++++++++++++++++++
 .../branches_sharing_code/shared_at_bottom.stderr  | 143 ++++++++++++++
 tests/ui/branches_sharing_code/shared_at_top.rs    | 103 ++++++++++
 .../ui/branches_sharing_code/shared_at_top.stderr  | 121 ++++++++++++
 .../shared_at_top_and_bottom.rs                    | 119 ++++++++++++
 .../shared_at_top_and_bottom.stderr                | 154 +++++++++++++++
 tests/ui/branches_sharing_code/valid_if_blocks.rs  | 155 +++++++++++++++
 .../branches_sharing_code/valid_if_blocks.stderr   | 101 ++++++++++
 tests/ui/checked_unwrap/complex_conditionals.rs    |   2 +-
 .../checked_unwrap/complex_conditionals_nested.rs  |   2 +-
 tests/ui/checked_unwrap/simple_conditionals.rs     |   2 +-
 tests/ui/default_numeric_fallback.rs               |   2 +-
 tests/ui/if_same_then_else.rs                      |   2 +-
 tests/ui/if_same_then_else2.rs                     |   2 +-
 tests/ui/let_if_seq.rs                             |   2 +-
 tests/ui/needless_bool/simple.rs                   |   2 +-
 tests/ui/needless_return.fixed                     |   2 +-
 tests/ui/needless_return.rs                        |   2 +-
 tests/ui/shared_code_in_if_blocks/shared_at_bot.rs | 209 ---------------------
 .../shared_code_in_if_blocks/shared_at_bot.stderr  | 143 --------------
 tests/ui/shared_code_in_if_blocks/shared_at_top.rs | 103 ----------
 .../shared_code_in_if_blocks/shared_at_top.stderr  | 121 ------------
 .../shared_at_top_and_bot.rs                       | 119 ------------
 .../shared_at_top_and_bot.stderr                   | 154 ---------------
 .../ui/shared_code_in_if_blocks/valid_if_blocks.rs | 155 ---------------
 .../valid_if_blocks.stderr                         | 101 ----------
 30 files changed, 1138 insertions(+), 1136 deletions(-)
 create mode 100644 tests/ui/branches_sharing_code/shared_at_bottom.rs
 create mode 100644 tests/ui/branches_sharing_code/shared_at_bottom.stderr
 create mode 100644 tests/ui/branches_sharing_code/shared_at_top.rs
 create mode 100644 tests/ui/branches_sharing_code/shared_at_top.stderr
 create mode 100644 tests/ui/branches_sharing_code/shared_at_top_and_bottom.rs
 create mode 100644 tests/ui/branches_sharing_code/shared_at_top_and_bottom.stderr
 create mode 100644 tests/ui/branches_sharing_code/valid_if_blocks.rs
 create mode 100644 tests/ui/branches_sharing_code/valid_if_blocks.stderr
 delete mode 100644 tests/ui/shared_code_in_if_blocks/shared_at_bot.rs
 delete mode 100644 tests/ui/shared_code_in_if_blocks/shared_at_bot.stderr
 delete mode 100644 tests/ui/shared_code_in_if_blocks/shared_at_top.rs
 delete mode 100644 tests/ui/shared_code_in_if_blocks/shared_at_top.stderr
 delete mode 100644 tests/ui/shared_code_in_if_blocks/shared_at_top_and_bot.rs
 delete mode 100644 tests/ui/shared_code_in_if_blocks/shared_at_top_and_bot.stderr
 delete mode 100644 tests/ui/shared_code_in_if_blocks/valid_if_blocks.rs
 delete mode 100644 tests/ui/shared_code_in_if_blocks/valid_if_blocks.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 790bca4ac18..73997192ae0 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2129,6 +2129,7 @@ Released 2018-09-13
 [`borrowed_box`]: https://rust-lang.github.io/rust-clippy/master/index.html#borrowed_box
 [`box_vec`]: https://rust-lang.github.io/rust-clippy/master/index.html#box_vec
 [`boxed_local`]: https://rust-lang.github.io/rust-clippy/master/index.html#boxed_local
+[`branches_sharing_code`]: https://rust-lang.github.io/rust-clippy/master/index.html#branches_sharing_code
 [`builtin_type_shadow`]: https://rust-lang.github.io/rust-clippy/master/index.html#builtin_type_shadow
 [`bytes_nth`]: https://rust-lang.github.io/rust-clippy/master/index.html#bytes_nth
 [`cargo_common_metadata`]: https://rust-lang.github.io/rust-clippy/master/index.html#cargo_common_metadata
@@ -2455,7 +2456,6 @@ Released 2018-09-13
 [`shadow_reuse`]: https://rust-lang.github.io/rust-clippy/master/index.html#shadow_reuse
 [`shadow_same`]: https://rust-lang.github.io/rust-clippy/master/index.html#shadow_same
 [`shadow_unrelated`]: https://rust-lang.github.io/rust-clippy/master/index.html#shadow_unrelated
-[`shared_code_in_if_blocks`]: https://rust-lang.github.io/rust-clippy/master/index.html#shared_code_in_if_blocks
 [`short_circuit_statement`]: https://rust-lang.github.io/rust-clippy/master/index.html#short_circuit_statement
 [`should_assert_eq`]: https://rust-lang.github.io/rust-clippy/master/index.html#should_assert_eq
 [`should_implement_trait`]: https://rust-lang.github.io/rust-clippy/master/index.html#should_implement_trait
diff --git a/clippy_lints/src/copies.rs b/clippy_lints/src/copies.rs
index ff99a9a09b3..1b982221b06 100644
--- a/clippy_lints/src/copies.rs
+++ b/clippy_lints/src/copies.rs
@@ -1,7 +1,8 @@
-use crate::utils::{
-    both, count_eq, eq_expr_value, first_line_of_span, get_enclosing_block, get_parent_expr, if_sequence, in_macro,
-    indent_of, parent_node_is_if_expr, reindent_multiline, run_lints, search_same, snippet, snippet_opt,
-    span_lint_and_note, span_lint_and_then, ContainsName, SpanlessEq, SpanlessHash,
+use clippy_utils::diagnostics::{span_lint_and_note, span_lint_and_then};
+use clippy_utils::source::{first_line_of_span, indent_of, reindent_multiline, snippet, snippet_opt};
+use clippy_utils::{
+    both, count_eq, eq_expr_value, get_enclosing_block, get_parent_expr, if_sequence, in_macro, parent_node_is_if_expr,
+    run_lints, search_same, ContainsName, SpanlessEq, SpanlessHash,
 };
 use if_chain::if_chain;
 use rustc_data_structures::fx::FxHashSet;
@@ -141,7 +142,7 @@ declare_clippy_lint! {
     ///     42
     /// };
     /// ```
-    pub SHARED_CODE_IN_IF_BLOCKS,
+    pub BRANCHES_SHARING_CODE,
     complexity,
     "`if` statement with shared code in all blocks"
 }
@@ -150,7 +151,7 @@ declare_lint_pass!(CopyAndPaste => [
     IFS_SAME_COND,
     SAME_FUNCTIONS_IN_IF_CONDITION,
     IF_SAME_THEN_ELSE,
-    SHARED_CODE_IN_IF_BLOCKS
+    BRANCHES_SHARING_CODE
 ]);
 
 impl<'tcx> LateLintPass<'tcx> for CopyAndPaste {
@@ -173,17 +174,17 @@ impl<'tcx> LateLintPass<'tcx> for CopyAndPaste {
                 lint_same_cond(cx, &conds);
                 lint_same_fns_in_if_cond(cx, &conds);
                 // Block duplication
-                lint_same_then_else(cx, &blocks, conds.len() != blocks.len(), expr);
+                lint_same_then_else(cx, &blocks, conds.len() == blocks.len(), expr);
             }
         }
     }
 }
 
-/// Implementation of `SHARED_CODE_IN_IF_BLOCKS` and `IF_SAME_THEN_ELSE` if the blocks are equal.
+/// Implementation of `BRANCHES_SHARING_CODE` and `IF_SAME_THEN_ELSE` if the blocks are equal.
 fn lint_same_then_else<'tcx>(
     cx: &LateContext<'tcx>,
     blocks: &[&Block<'tcx>],
-    has_unconditional_else: bool,
+    has_conditional_else: bool,
     expr: &'tcx Expr<'_>,
 ) {
     // We only lint ifs with multiple blocks
@@ -195,8 +196,8 @@ fn lint_same_then_else<'tcx>(
     let has_expr = blocks[0].expr.is_some();
     let (start_eq, mut end_eq, expr_eq) = scan_block_for_eq(cx, blocks);
 
-    // SHARED_CODE_IN_IF_BLOCKS prerequisites
-    if !has_unconditional_else || (start_eq == 0 && end_eq == 0 && (has_expr && !expr_eq)) {
+    // BRANCHES_SHARING_CODE prerequisites
+    if has_conditional_else || (start_eq == 0 && end_eq == 0 && (has_expr && !expr_eq)) {
         return;
     }
 
@@ -210,7 +211,7 @@ fn lint_same_then_else<'tcx>(
             intravisit::walk_stmt(&mut start_walker, stmt);
         }
 
-        emit_shared_code_in_if_blocks_lint(
+        emit_branches_sharing_code_lint(
             cx,
             start_eq,
             0,
@@ -277,7 +278,7 @@ fn lint_same_then_else<'tcx>(
             });
         }
 
-        emit_shared_code_in_if_blocks_lint(
+        emit_branches_sharing_code_lint(
             cx,
             start_eq,
             end_eq,
@@ -298,7 +299,7 @@ fn scan_block_for_eq(cx: &LateContext<'tcx>, blocks: &[&Block<'tcx>]) -> (usize,
         let r_stmts = win[1].stmts;
 
         // `SpanlessEq` now keeps track of the locals and is therefore context sensitive clippy#6752.
-        // The comparison therefor needs to be done in a way that builds the correct context.
+        // The comparison therefore needs to be done in a way that builds the correct context.
         let mut evaluator = SpanlessEq::new(cx);
         let mut evaluator = evaluator.inter_expr();
 
@@ -387,7 +388,7 @@ fn check_for_warn_of_moved_symbol(
     })
 }
 
-fn emit_shared_code_in_if_blocks_lint(
+fn emit_branches_sharing_code_lint(
     cx: &LateContext<'tcx>,
     start_stmts: usize,
     end_stmts: usize,
@@ -472,7 +473,7 @@ fn emit_shared_code_in_if_blocks_lint(
         let (place_str, span, sugg) = suggestions.pop().unwrap();
         let msg = format!("all if blocks contain the same code at the {}", place_str);
         let help = format!("consider moving the {} statements out like this", place_str);
-        span_lint_and_then(cx, SHARED_CODE_IN_IF_BLOCKS, span, msg.as_str(), |diag| {
+        span_lint_and_then(cx, BRANCHES_SHARING_CODE, span, msg.as_str(), |diag| {
             diag.span_suggestion(span, help.as_str(), sugg, Applicability::Unspecified);
 
             add_optional_msgs(diag);
@@ -482,7 +483,7 @@ fn emit_shared_code_in_if_blocks_lint(
         let (_, start_span, start_sugg) = suggestions.pop().unwrap();
         span_lint_and_then(
             cx,
-            SHARED_CODE_IN_IF_BLOCKS,
+            BRANCHES_SHARING_CODE,
             start_span,
             "all if blocks contain the same code at the start and the end. Here at the start",
             move |diag| {
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 3f5c1c7c526..43e89c2475f 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -613,10 +613,10 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &collapsible_if::COLLAPSIBLE_IF,
         &collapsible_match::COLLAPSIBLE_MATCH,
         &comparison_chain::COMPARISON_CHAIN,
+        &copies::BRANCHES_SHARING_CODE,
         &copies::IFS_SAME_COND,
         &copies::IF_SAME_THEN_ELSE,
         &copies::SAME_FUNCTIONS_IN_IF_CONDITION,
-        &copies::SHARED_CODE_IN_IF_BLOCKS,
         &copy_iterator::COPY_ITERATOR,
         &create_dir::CREATE_DIR,
         &dbg_macro::DBG_MACRO,
@@ -1483,9 +1483,9 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&collapsible_if::COLLAPSIBLE_IF),
         LintId::of(&collapsible_match::COLLAPSIBLE_MATCH),
         LintId::of(&comparison_chain::COMPARISON_CHAIN),
+        LintId::of(&copies::BRANCHES_SHARING_CODE),
         LintId::of(&copies::IFS_SAME_COND),
         LintId::of(&copies::IF_SAME_THEN_ELSE),
-        LintId::of(&copies::SHARED_CODE_IN_IF_BLOCKS),
         LintId::of(&default::FIELD_REASSIGN_WITH_DEFAULT),
         LintId::of(&derive::DERIVE_HASH_XOR_EQ),
         LintId::of(&derive::DERIVE_ORD_XOR_PARTIAL_ORD),
@@ -1872,6 +1872,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&booleans::NONMINIMAL_BOOL),
         LintId::of(&casts::CHAR_LIT_AS_U8),
         LintId::of(&casts::UNNECESSARY_CAST),
+        LintId::of(&copies::BRANCHES_SHARING_CODE),
         LintId::of(&double_comparison::DOUBLE_COMPARISONS),
         LintId::of(&double_parens::DOUBLE_PARENS),
         LintId::of(&duration_subsec::DURATION_SUBSEC),
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index f9576068dd6..7ce90ffd9f0 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -47,7 +47,7 @@ pub mod usage;
 pub mod visitors;
 
 pub use self::attrs::*;
-pub use self::hir_utils::{both, eq_expr_value, over, SpanlessEq, SpanlessHash};
+pub use self::hir_utils::{both, count_eq, eq_expr_value, over, SpanlessEq, SpanlessHash};
 
 use std::collections::hash_map::Entry;
 use std::hash::BuildHasherDefault;
diff --git a/tests/ui/branches_sharing_code/shared_at_bottom.rs b/tests/ui/branches_sharing_code/shared_at_bottom.rs
new file mode 100644
index 00000000000..c389c243d44
--- /dev/null
+++ b/tests/ui/branches_sharing_code/shared_at_bottom.rs
@@ -0,0 +1,209 @@
+#![allow(dead_code)]
+#![deny(clippy::if_same_then_else, clippy::branches_sharing_code)]
+
+// This tests the branches_sharing_code lint at the end of blocks
+
+fn simple_examples() {
+    let x = 1;
+
+    let _ = if x == 7 {
+        println!("Branch I");
+        let start_value = 0;
+        println!("=^.^=");
+
+        // Same but not moveable due to `start_value`
+        let _ = start_value;
+
+        // The rest is self contained and moveable => Only lint the rest
+        let result = false;
+        println!("Block end!");
+        result
+    } else {
+        println!("Branch II");
+        let start_value = 8;
+        println!("xD");
+
+        // Same but not moveable due to `start_value`
+        let _ = start_value;
+
+        // The rest is self contained and moveable => Only lint the rest
+        let result = false;
+        println!("Block end!");
+        result
+    };
+
+    // Else if block
+    if x == 9 {
+        println!("The index is: 6");
+
+        println!("Same end of block");
+    } else if x == 8 {
+        println!("The index is: 4");
+
+        // We should only get a lint trigger for the last statement
+        println!("This is also eq with the else block");
+        println!("Same end of block");
+    } else {
+        println!("This is also eq with the else block");
+        println!("Same end of block");
+    }
+
+    // Use of outer scope value
+    let outer_scope_value = "I'm outside the if block";
+    if x < 99 {
+        let z = "How are you";
+        println!("I'm a local because I use the value `z`: `{}`", z);
+
+        println!(
+            "I'm moveable because I know: `outer_scope_value`: '{}'",
+            outer_scope_value
+        );
+    } else {
+        let z = 45678000;
+        println!("I'm a local because I use the value `z`: `{}`", z);
+
+        println!(
+            "I'm moveable because I know: `outer_scope_value`: '{}'",
+            outer_scope_value
+        );
+    }
+
+    if x == 9 {
+        if x == 8 {
+            // No parent!!
+            println!("---");
+            println!("Hello World");
+        } else {
+            println!("Hello World");
+        }
+    }
+}
+
+/// Simple examples where the move can cause some problems due to moved values
+fn simple_but_suggestion_is_invalid() {
+    let x = 16;
+
+    // Local value
+    let later_used_value = 17;
+    if x == 9 {
+        let _ = 9;
+        let later_used_value = "A string value";
+        println!("{}", later_used_value);
+    } else {
+        let later_used_value = "A string value";
+        println!("{}", later_used_value);
+        // I'm expecting a note about this
+    }
+    println!("{}", later_used_value);
+
+    // outer function
+    if x == 78 {
+        let simple_examples = "I now identify as a &str :)";
+        println!("This is the new simple_example: {}", simple_examples);
+    } else {
+        println!("Separator print statement");
+
+        let simple_examples = "I now identify as a &str :)";
+        println!("This is the new simple_example: {}", simple_examples);
+    }
+    simple_examples();
+}
+
+/// Tests where the blocks are not linted due to the used value scope
+fn not_moveable_due_to_value_scope() {
+    let x = 18;
+
+    // Using a local value in the moved code
+    if x == 9 {
+        let y = 18;
+        println!("y is: `{}`", y);
+    } else {
+        let y = "A string";
+        println!("y is: `{}`", y);
+    }
+
+    // Using a local value in the expression
+    let _ = if x == 0 {
+        let mut result = x + 1;
+
+        println!("1. Doing some calculations");
+        println!("2. Some more calculations");
+        println!("3. Setting result");
+
+        result
+    } else {
+        let mut result = x - 1;
+
+        println!("1. Doing some calculations");
+        println!("2. Some more calculations");
+        println!("3. Setting result");
+
+        result
+    };
+
+    let _ = if x == 7 {
+        let z1 = 100;
+        println!("z1: {}", z1);
+
+        let z2 = z1;
+        println!("z2: {}", z2);
+
+        z2
+    } else {
+        let z1 = 300;
+        println!("z1: {}", z1);
+
+        let z2 = z1;
+        println!("z2: {}", z2);
+
+        z2
+    };
+}
+
+/// This should add a note to the lint msg since the moved expression is not `()`
+fn added_note_for_expression_use() -> u32 {
+    let x = 9;
+
+    let _ = if x == 7 {
+        x << 2
+    } else {
+        let _ = 6;
+        x << 2
+    };
+
+    if x == 9 {
+        x * 4
+    } else {
+        let _ = 17;
+        x * 4
+    }
+}
+
+#[rustfmt::skip]
+fn test_suggestion_with_weird_formatting() {
+    let x = 9;
+    let mut a = 0;
+    let mut b = 0;
+
+    // The error message still looks weird tbh but this is the best I can do
+    // for weird formatting
+    if x == 17 { b = 1; a = 0x99; } else { a = 0x99; }
+}
+
+fn fp_test() {
+    let x = 17;
+
+    if x == 18 {
+        let y = 19;
+        if y < x {
+            println!("Trigger")
+        }
+    } else {
+        let z = 166;
+        if z < x {
+            println!("Trigger")
+        }
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/branches_sharing_code/shared_at_bottom.stderr b/tests/ui/branches_sharing_code/shared_at_bottom.stderr
new file mode 100644
index 00000000000..271fcd8b6c1
--- /dev/null
+++ b/tests/ui/branches_sharing_code/shared_at_bottom.stderr
@@ -0,0 +1,143 @@
+error: all if blocks contain the same code at the end
+  --> $DIR/shared_at_bottom.rs:30:5
+   |
+LL | /         let result = false;
+LL | |         println!("Block end!");
+LL | |         result
+LL | |     };
+   | |_____^
+   |
+note: the lint level is defined here
+  --> $DIR/shared_at_bottom.rs:2:36
+   |
+LL | #![deny(clippy::if_same_then_else, clippy::branches_sharing_code)]
+   |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   = note: The end suggestion probably needs some adjustments to use the expression result correctly
+help: consider moving the end statements out like this
+   |
+LL |     }
+LL |     let result = false;
+LL |     println!("Block end!");
+LL |     result;
+   |
+
+error: all if blocks contain the same code at the end
+  --> $DIR/shared_at_bottom.rs:48:5
+   |
+LL | /         println!("Same end of block");
+LL | |     }
+   | |_____^
+   |
+help: consider moving the end statements out like this
+   |
+LL |     }
+LL |     println!("Same end of block");
+   |
+
+error: all if blocks contain the same code at the end
+  --> $DIR/shared_at_bottom.rs:65:5
+   |
+LL | /         println!(
+LL | |             "I'm moveable because I know: `outer_scope_value`: '{}'",
+LL | |             outer_scope_value
+LL | |         );
+LL | |     }
+   | |_____^
+   |
+help: consider moving the end statements out like this
+   |
+LL |     }
+LL |     println!(
+LL |         "I'm moveable because I know: `outer_scope_value`: '{}'",
+LL |         outer_scope_value
+LL |     );
+   |
+
+error: all if blocks contain the same code at the end
+  --> $DIR/shared_at_bottom.rs:77:9
+   |
+LL | /             println!("Hello World");
+LL | |         }
+   | |_________^
+   |
+help: consider moving the end statements out like this
+   |
+LL |         }
+LL |         println!("Hello World");
+   |
+
+error: all if blocks contain the same code at the end
+  --> $DIR/shared_at_bottom.rs:93:5
+   |
+LL | /         let later_used_value = "A string value";
+LL | |         println!("{}", later_used_value);
+LL | |         // I'm expecting a note about this
+LL | |     }
+   | |_____^
+   |
+   = warning: Some moved values might need to be renamed to avoid wrong references
+help: consider moving the end statements out like this
+   |
+LL |     }
+LL |     let later_used_value = "A string value";
+LL |     println!("{}", later_used_value);
+   |
+
+error: all if blocks contain the same code at the end
+  --> $DIR/shared_at_bottom.rs:106:5
+   |
+LL | /         let simple_examples = "I now identify as a &str :)";
+LL | |         println!("This is the new simple_example: {}", simple_examples);
+LL | |     }
+   | |_____^
+   |
+   = warning: Some moved values might need to be renamed to avoid wrong references
+help: consider moving the end statements out like this
+   |
+LL |     }
+LL |     let simple_examples = "I now identify as a &str :)";
+LL |     println!("This is the new simple_example: {}", simple_examples);
+   |
+
+error: all if blocks contain the same code at the end
+  --> $DIR/shared_at_bottom.rs:171:5
+   |
+LL | /         x << 2
+LL | |     };
+   | |_____^
+   |
+   = note: The end suggestion probably needs some adjustments to use the expression result correctly
+help: consider moving the end statements out like this
+   |
+LL |     }
+LL |     x << 2;
+   |
+
+error: all if blocks contain the same code at the end
+  --> $DIR/shared_at_bottom.rs:178:5
+   |
+LL | /         x * 4
+LL | |     }
+   | |_____^
+   |
+   = note: The end suggestion probably needs some adjustments to use the expression result correctly
+help: consider moving the end statements out like this
+   |
+LL |     }
+LL |     x * 4
+   |
+
+error: all if blocks contain the same code at the end
+  --> $DIR/shared_at_bottom.rs:190:44
+   |
+LL |     if x == 17 { b = 1; a = 0x99; } else { a = 0x99; }
+   |                                            ^^^^^^^^^^^
+   |
+help: consider moving the end statements out like this
+   |
+LL |     if x == 17 { b = 1; a = 0x99; } else { }
+LL |     a = 0x99;
+   |
+
+error: aborting due to 9 previous errors
+
diff --git a/tests/ui/branches_sharing_code/shared_at_top.rs b/tests/ui/branches_sharing_code/shared_at_top.rs
new file mode 100644
index 00000000000..e65bcfd7873
--- /dev/null
+++ b/tests/ui/branches_sharing_code/shared_at_top.rs
@@ -0,0 +1,103 @@
+#![allow(dead_code, clippy::eval_order_dependence)]
+#![deny(clippy::if_same_then_else, clippy::branches_sharing_code)]
+
+// This tests the branches_sharing_code lint at the start of blocks
+
+fn simple_examples() {
+    let x = 0;
+
+    // Simple
+    if true {
+        println!("Hello World!");
+        println!("I'm branch nr: 1");
+    } else {
+        println!("Hello World!");
+        println!("I'm branch nr: 2");
+    }
+
+    // Else if
+    if x == 0 {
+        let y = 9;
+        println!("The value y was set to: `{}`", y);
+        let _z = y;
+
+        println!("I'm the true start index of arrays");
+    } else if x == 1 {
+        let y = 9;
+        println!("The value y was set to: `{}`", y);
+        let _z = y;
+
+        println!("I start counting from 1 so my array starts from `1`");
+    } else {
+        let y = 9;
+        println!("The value y was set to: `{}`", y);
+        let _z = y;
+
+        println!("Ha, Pascal allows you to start the array where you want")
+    }
+
+    // Return a value
+    let _ = if x == 7 {
+        let y = 16;
+        println!("What can I say except: \"you're welcome?\"");
+        let _ = y;
+        x
+    } else {
+        let y = 16;
+        println!("Thank you");
+        y
+    };
+}
+
+/// Simple examples where the move can cause some problems due to moved values
+fn simple_but_suggestion_is_invalid() {
+    let x = 10;
+
+    // Can't be automatically moved because used_value_name is getting used again
+    let used_value_name = 19;
+    if x == 10 {
+        let used_value_name = "Different type";
+        println!("Str: {}", used_value_name);
+        let _ = 1;
+    } else {
+        let used_value_name = "Different type";
+        println!("Str: {}", used_value_name);
+        let _ = 2;
+    }
+    let _ = used_value_name;
+
+    // This can be automatically moved as `can_be_overridden` is not used again
+    let can_be_overridden = 8;
+    let _ = can_be_overridden;
+    if x == 11 {
+        let can_be_overridden = "Move me";
+        println!("I'm also moveable");
+        let _ = 111;
+    } else {
+        let can_be_overridden = "Move me";
+        println!("I'm also moveable");
+        let _ = 222;
+    }
+}
+
+/// This function tests that the `IS_SAME_THAN_ELSE` only covers the lint if it's enabled.
+fn check_if_same_than_else_mask() {
+    let x = 2021;
+
+    #[allow(clippy::if_same_then_else)]
+    if x == 2020 {
+        println!("This should trigger the `SHARED_CODE_IN_IF_BLOCKS` lint.");
+        println!("Because `IF_SAME_THEN_ELSE` is allowed here");
+    } else {
+        println!("This should trigger the `SHARED_CODE_IN_IF_BLOCKS` lint.");
+        println!("Because `IF_SAME_THEN_ELSE` is allowed here");
+    }
+
+    if x == 2019 {
+        println!("This should trigger `IS_SAME_THAN_ELSE` as usual");
+    } else {
+        println!("This should trigger `IS_SAME_THAN_ELSE` as usual");
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/branches_sharing_code/shared_at_top.stderr b/tests/ui/branches_sharing_code/shared_at_top.stderr
new file mode 100644
index 00000000000..15867e9ea02
--- /dev/null
+++ b/tests/ui/branches_sharing_code/shared_at_top.stderr
@@ -0,0 +1,121 @@
+error: all if blocks contain the same code at the start
+  --> $DIR/shared_at_top.rs:10:5
+   |
+LL | /     if true {
+LL | |         println!("Hello World!");
+   | |_________________________________^
+   |
+note: the lint level is defined here
+  --> $DIR/shared_at_top.rs:2:36
+   |
+LL | #![deny(clippy::if_same_then_else, clippy::branches_sharing_code)]
+   |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+help: consider moving the start statements out like this
+   |
+LL |     println!("Hello World!");
+LL |     if true {
+   |
+
+error: all if blocks contain the same code at the start
+  --> $DIR/shared_at_top.rs:19:5
+   |
+LL | /     if x == 0 {
+LL | |         let y = 9;
+LL | |         println!("The value y was set to: `{}`", y);
+LL | |         let _z = y;
+   | |___________________^
+   |
+   = warning: Some moved values might need to be renamed to avoid wrong references
+help: consider moving the start statements out like this
+   |
+LL |     let y = 9;
+LL |     println!("The value y was set to: `{}`", y);
+LL |     let _z = y;
+LL |     if x == 0 {
+   |
+
+error: all if blocks contain the same code at the start
+  --> $DIR/shared_at_top.rs:40:5
+   |
+LL | /     let _ = if x == 7 {
+LL | |         let y = 16;
+   | |___________________^
+   |
+help: consider moving the start statements out like this
+   |
+LL |     let y = 16;
+LL |     let _ = if x == 7 {
+   |
+
+error: all if blocks contain the same code at the start
+  --> $DIR/shared_at_top.rs:58:5
+   |
+LL | /     if x == 10 {
+LL | |         let used_value_name = "Different type";
+LL | |         println!("Str: {}", used_value_name);
+   | |_____________________________________________^
+   |
+   = warning: Some moved values might need to be renamed to avoid wrong references
+help: consider moving the start statements out like this
+   |
+LL |     let used_value_name = "Different type";
+LL |     println!("Str: {}", used_value_name);
+LL |     if x == 10 {
+   |
+
+error: all if blocks contain the same code at the start
+  --> $DIR/shared_at_top.rs:72:5
+   |
+LL | /     if x == 11 {
+LL | |         let can_be_overridden = "Move me";
+LL | |         println!("I'm also moveable");
+   | |______________________________________^
+   |
+   = warning: Some moved values might need to be renamed to avoid wrong references
+help: consider moving the start statements out like this
+   |
+LL |     let can_be_overridden = "Move me";
+LL |     println!("I'm also moveable");
+LL |     if x == 11 {
+   |
+
+error: all if blocks contain the same code at the start
+  --> $DIR/shared_at_top.rs:88:5
+   |
+LL | /     if x == 2020 {
+LL | |         println!("This should trigger the `SHARED_CODE_IN_IF_BLOCKS` lint.");
+LL | |         println!("Because `IF_SAME_THEN_ELSE` is allowed here");
+   | |________________________________________________________________^
+   |
+help: consider moving the start statements out like this
+   |
+LL |     println!("This should trigger the `SHARED_CODE_IN_IF_BLOCKS` lint.");
+LL |     println!("Because `IF_SAME_THEN_ELSE` is allowed here");
+LL |     if x == 2020 {
+   |
+
+error: this `if` has identical blocks
+  --> $DIR/shared_at_top.rs:96:18
+   |
+LL |       if x == 2019 {
+   |  __________________^
+LL | |         println!("This should trigger `IS_SAME_THAN_ELSE` as usual");
+LL | |     } else {
+   | |_____^
+   |
+note: the lint level is defined here
+  --> $DIR/shared_at_top.rs:2:9
+   |
+LL | #![deny(clippy::if_same_then_else, clippy::branches_sharing_code)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^
+note: same as this
+  --> $DIR/shared_at_top.rs:98:12
+   |
+LL |       } else {
+   |  ____________^
+LL | |         println!("This should trigger `IS_SAME_THAN_ELSE` as usual");
+LL | |     }
+   | |_____^
+
+error: aborting due to 7 previous errors
+
diff --git a/tests/ui/branches_sharing_code/shared_at_top_and_bottom.rs b/tests/ui/branches_sharing_code/shared_at_top_and_bottom.rs
new file mode 100644
index 00000000000..deefdad32c9
--- /dev/null
+++ b/tests/ui/branches_sharing_code/shared_at_top_and_bottom.rs
@@ -0,0 +1,119 @@
+#![allow(dead_code)]
+#![deny(clippy::if_same_then_else, clippy::branches_sharing_code)]
+
+// branches_sharing_code at the top and bottom of the if blocks
+
+struct DataPack {
+    id: u32,
+    name: String,
+    some_data: Vec<u8>,
+}
+
+fn overlapping_eq_regions() {
+    let x = 9;
+
+    // Overlap with separator
+    if x == 7 {
+        let t = 7;
+        let _overlap_start = t * 2;
+        let _overlap_end = 2 * t;
+        let _u = 9;
+    } else {
+        let t = 7;
+        let _overlap_start = t * 2;
+        let _overlap_end = 2 * t;
+        println!("Overlap separator");
+        let _overlap_start = t * 2;
+        let _overlap_end = 2 * t;
+        let _u = 9;
+    }
+
+    // Overlap with separator
+    if x == 99 {
+        let r = 7;
+        let _overlap_start = r;
+        let _overlap_middle = r * r;
+        let _overlap_end = r * r * r;
+        let z = "end";
+    } else {
+        let r = 7;
+        let _overlap_start = r;
+        let _overlap_middle = r * r;
+        let _overlap_middle = r * r;
+        let _overlap_end = r * r * r;
+        let z = "end";
+    }
+}
+
+fn complexer_example() {
+    fn gen_id(x: u32, y: u32) -> u32 {
+        let x = x & 0x0000_ffff;
+        let y = (y & 0xffff_0000) << 16;
+        x | y
+    }
+
+    fn process_data(data: DataPack) {
+        let _ = data;
+    }
+
+    let x = 8;
+    let y = 9;
+    if (x > 7 && y < 13) || (x + y) % 2 == 1 {
+        let a = 0xcafe;
+        let b = 0xffff00ff;
+        let e_id = gen_id(a, b);
+
+        println!("From the a `{}` to the b `{}`", a, b);
+
+        let pack = DataPack {
+            id: e_id,
+            name: "Player 1".to_string(),
+            some_data: vec![0x12, 0x34, 0x56, 0x78, 0x90],
+        };
+        process_data(pack);
+    } else {
+        let a = 0xcafe;
+        let b = 0xffff00ff;
+        let e_id = gen_id(a, b);
+
+        println!("The new ID is '{}'", e_id);
+
+        let pack = DataPack {
+            id: e_id,
+            name: "Player 1".to_string(),
+            some_data: vec![0x12, 0x34, 0x56, 0x78, 0x90],
+        };
+        process_data(pack);
+    }
+}
+
+/// This should add a note to the lint msg since the moved expression is not `()`
+fn added_note_for_expression_use() -> u32 {
+    let x = 9;
+
+    let _ = if x == 7 {
+        let _ = 19;
+
+        let _splitter = 6;
+
+        x << 2
+    } else {
+        let _ = 19;
+
+        x << 2
+    };
+
+    if x == 9 {
+        let _ = 17;
+
+        let _splitter = 6;
+
+        x * 4
+    } else {
+        let _ = 17;
+
+        x * 4
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/branches_sharing_code/shared_at_top_and_bottom.stderr b/tests/ui/branches_sharing_code/shared_at_top_and_bottom.stderr
new file mode 100644
index 00000000000..212cfb2f1d1
--- /dev/null
+++ b/tests/ui/branches_sharing_code/shared_at_top_and_bottom.stderr
@@ -0,0 +1,154 @@
+error: all if blocks contain the same code at the start and the end. Here at the start
+  --> $DIR/shared_at_top_and_bottom.rs:16:5
+   |
+LL | /     if x == 7 {
+LL | |         let t = 7;
+LL | |         let _overlap_start = t * 2;
+LL | |         let _overlap_end = 2 * t;
+   | |_________________________________^
+   |
+note: the lint level is defined here
+  --> $DIR/shared_at_top_and_bottom.rs:2:36
+   |
+LL | #![deny(clippy::if_same_then_else, clippy::branches_sharing_code)]
+   |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+note: and here at the end
+  --> $DIR/shared_at_top_and_bottom.rs:28:5
+   |
+LL | /         let _u = 9;
+LL | |     }
+   | |_____^
+help: consider moving the start statements out like this
+   |
+LL |     let t = 7;
+LL |     let _overlap_start = t * 2;
+LL |     let _overlap_end = 2 * t;
+LL |     if x == 7 {
+   |
+help: and consider moving the end statements out like this
+   |
+LL |     }
+LL |     let _u = 9;
+   |
+
+error: all if blocks contain the same code at the start and the end. Here at the start
+  --> $DIR/shared_at_top_and_bottom.rs:32:5
+   |
+LL | /     if x == 99 {
+LL | |         let r = 7;
+LL | |         let _overlap_start = r;
+LL | |         let _overlap_middle = r * r;
+   | |____________________________________^
+   |
+note: and here at the end
+  --> $DIR/shared_at_top_and_bottom.rs:43:5
+   |
+LL | /         let _overlap_end = r * r * r;
+LL | |         let z = "end";
+LL | |     }
+   | |_____^
+   = warning: Some moved values might need to be renamed to avoid wrong references
+help: consider moving the start statements out like this
+   |
+LL |     let r = 7;
+LL |     let _overlap_start = r;
+LL |     let _overlap_middle = r * r;
+LL |     if x == 99 {
+   |
+help: and consider moving the end statements out like this
+   |
+LL |     }
+LL |     let _overlap_end = r * r * r;
+LL |     let z = "end";
+   |
+
+error: all if blocks contain the same code at the start and the end. Here at the start
+  --> $DIR/shared_at_top_and_bottom.rs:61:5
+   |
+LL | /     if (x > 7 && y < 13) || (x + y) % 2 == 1 {
+LL | |         let a = 0xcafe;
+LL | |         let b = 0xffff00ff;
+LL | |         let e_id = gen_id(a, b);
+   | |________________________________^
+   |
+note: and here at the end
+  --> $DIR/shared_at_top_and_bottom.rs:81:5
+   |
+LL | /         let pack = DataPack {
+LL | |             id: e_id,
+LL | |             name: "Player 1".to_string(),
+LL | |             some_data: vec![0x12, 0x34, 0x56, 0x78, 0x90],
+LL | |         };
+LL | |         process_data(pack);
+LL | |     }
+   | |_____^
+   = warning: Some moved values might need to be renamed to avoid wrong references
+help: consider moving the start statements out like this
+   |
+LL |     let a = 0xcafe;
+LL |     let b = 0xffff00ff;
+LL |     let e_id = gen_id(a, b);
+LL |     if (x > 7 && y < 13) || (x + y) % 2 == 1 {
+   |
+help: and consider moving the end statements out like this
+   |
+LL |     }
+LL |     let pack = DataPack {
+LL |         id: e_id,
+LL |         name: "Player 1".to_string(),
+LL |         some_data: vec![0x12, 0x34, 0x56, 0x78, 0x90],
+LL |     };
+ ...
+
+error: all if blocks contain the same code at the start and the end. Here at the start
+  --> $DIR/shared_at_top_and_bottom.rs:94:5
+   |
+LL | /     let _ = if x == 7 {
+LL | |         let _ = 19;
+   | |___________________^
+   |
+note: and here at the end
+  --> $DIR/shared_at_top_and_bottom.rs:103:5
+   |
+LL | /         x << 2
+LL | |     };
+   | |_____^
+   = note: The end suggestion probably needs some adjustments to use the expression result correctly
+help: consider moving the start statements out like this
+   |
+LL |     let _ = 19;
+LL |     let _ = if x == 7 {
+   |
+help: and consider moving the end statements out like this
+   |
+LL |     }
+LL |     x << 2;
+   |
+
+error: all if blocks contain the same code at the start and the end. Here at the start
+  --> $DIR/shared_at_top_and_bottom.rs:106:5
+   |
+LL | /     if x == 9 {
+LL | |         let _ = 17;
+   | |___________________^
+   |
+note: and here at the end
+  --> $DIR/shared_at_top_and_bottom.rs:115:5
+   |
+LL | /         x * 4
+LL | |     }
+   | |_____^
+   = note: The end suggestion probably needs some adjustments to use the expression result correctly
+help: consider moving the start statements out like this
+   |
+LL |     let _ = 17;
+LL |     if x == 9 {
+   |
+help: and consider moving the end statements out like this
+   |
+LL |     }
+LL |     x * 4
+   |
+
+error: aborting due to 5 previous errors
+
diff --git a/tests/ui/branches_sharing_code/valid_if_blocks.rs b/tests/ui/branches_sharing_code/valid_if_blocks.rs
new file mode 100644
index 00000000000..0c70e3748ec
--- /dev/null
+++ b/tests/ui/branches_sharing_code/valid_if_blocks.rs
@@ -0,0 +1,155 @@
+#![allow(dead_code, clippy::eval_order_dependence)]
+#![deny(clippy::if_same_then_else, clippy::branches_sharing_code)]
+
+// This tests valid if blocks that shouldn't trigger the lint
+
+// Tests with value references are includes in "shared_code_at_bottom.rs"
+
+fn valid_examples() {
+    let x = 2;
+
+    // The edge statements are different
+    if x == 9 {
+        let y = 1 << 5;
+
+        println!("This is the same: vvv");
+        let _z = y;
+        println!("The block expression is different");
+
+        println!("Different end 1");
+    } else {
+        let y = 1 << 7;
+
+        println!("This is the same: vvv");
+        let _z = y;
+        println!("The block expression is different");
+
+        println!("Different end 2");
+    }
+
+    // No else
+    if x == 2 {
+        println!("Hello world!");
+        println!("Hello back, how are you?");
+
+        // This is different vvvv
+        println!("Howdy stranger =^.^=");
+
+        println!("Bye Bye World");
+    } else if x == 9 {
+        println!("Hello world!");
+        println!("Hello back, how are you?");
+
+        // This is different vvvv
+        println!("Hello reviewer :D");
+
+        println!("Bye Bye World");
+    }
+
+    // Overlapping statements only in else if blocks -> Don't lint
+    if x == 0 {
+        println!("I'm important!")
+    } else if x == 17 {
+        println!("I share code in else if");
+
+        println!("x is 17");
+    } else {
+        println!("I share code in else if");
+
+        println!("x is nether x nor 17");
+    }
+
+    // Mutability is different
+    if x == 13 {
+        let mut y = 9;
+        println!("Value y is: {}", y);
+        y += 16;
+        let _z1 = y;
+    } else {
+        let y = 9;
+        println!("Value y is: {}", y);
+        let _z2 = y;
+    }
+
+    // Same blocks but at start and bottom so no `if_same_then_else` lint
+    if x == 418 {
+        let y = 9;
+        let z = 8;
+        let _ = (x, y, z);
+        // Don't tell the programmer, my code is also in the else block
+    } else if x == 419 {
+        println!("+-----------+");
+        println!("|           |");
+        println!("|  O     O  |");
+        println!("|     °     |");
+        println!("|  \\_____/  |");
+        println!("|           |");
+        println!("+-----------+");
+    } else {
+        let y = 9;
+        let z = 8;
+        let _ = (x, y, z);
+        // I'm so much better than the x == 418 block. Trust me
+    }
+
+    let x = 1;
+    if true {
+        println!("{}", x);
+    } else {
+        let x = 2;
+        println!("{}", x);
+    }
+
+    // Let's test empty blocks
+    if false {
+    } else {
+    }
+}
+
+/// This makes sure that the `if_same_then_else` masks the `shared_code_in_if_blocks` lint
+fn trigger_other_lint() {
+    let x = 0;
+    let y = 1;
+
+    // Same block
+    if x == 0 {
+        let u = 19;
+        println!("How are u today?");
+        let _ = "This is a string";
+    } else {
+        let u = 19;
+        println!("How are u today?");
+        let _ = "This is a string";
+    }
+
+    // Only same expression
+    let _ = if x == 6 { 7 } else { 7 };
+
+    // Same in else if block
+    let _ = if x == 67 {
+        println!("Well I'm the most important block");
+        "I'm a pretty string"
+    } else if x == 68 {
+        println!("I'm a doppelgänger");
+        // Don't listen to my clone below
+
+        if y == 90 { "=^.^=" } else { ":D" }
+    } else {
+        // Don't listen to my clone above
+        println!("I'm a doppelgänger");
+
+        if y == 90 { "=^.^=" } else { ":D" }
+    };
+
+    if x == 0 {
+        println!("I'm single");
+    } else if x == 68 {
+        println!("I'm a doppelgänger");
+        // Don't listen to my clone below
+    } else {
+        // Don't listen to my clone above
+        println!("I'm a doppelgänger");
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/branches_sharing_code/valid_if_blocks.stderr b/tests/ui/branches_sharing_code/valid_if_blocks.stderr
new file mode 100644
index 00000000000..a815995e717
--- /dev/null
+++ b/tests/ui/branches_sharing_code/valid_if_blocks.stderr
@@ -0,0 +1,101 @@
+error: this `if` has identical blocks
+  --> $DIR/valid_if_blocks.rs:104:14
+   |
+LL |       if false {
+   |  ______________^
+LL | |     } else {
+   | |_____^
+   |
+note: the lint level is defined here
+  --> $DIR/valid_if_blocks.rs:2:9
+   |
+LL | #![deny(clippy::if_same_then_else, clippy::branches_sharing_code)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^
+note: same as this
+  --> $DIR/valid_if_blocks.rs:105:12
+   |
+LL |       } else {
+   |  ____________^
+LL | |     }
+   | |_____^
+
+error: this `if` has identical blocks
+  --> $DIR/valid_if_blocks.rs:115:15
+   |
+LL |       if x == 0 {
+   |  _______________^
+LL | |         let u = 19;
+LL | |         println!("How are u today?");
+LL | |         let _ = "This is a string";
+LL | |     } else {
+   | |_____^
+   |
+note: same as this
+  --> $DIR/valid_if_blocks.rs:119:12
+   |
+LL |       } else {
+   |  ____________^
+LL | |         let u = 19;
+LL | |         println!("How are u today?");
+LL | |         let _ = "This is a string";
+LL | |     }
+   | |_____^
+
+error: this `if` has identical blocks
+  --> $DIR/valid_if_blocks.rs:126:23
+   |
+LL |     let _ = if x == 6 { 7 } else { 7 };
+   |                       ^^^^^
+   |
+note: same as this
+  --> $DIR/valid_if_blocks.rs:126:34
+   |
+LL |     let _ = if x == 6 { 7 } else { 7 };
+   |                                  ^^^^^
+
+error: this `if` has identical blocks
+  --> $DIR/valid_if_blocks.rs:132:23
+   |
+LL |       } else if x == 68 {
+   |  _______________________^
+LL | |         println!("I'm a doppelgänger");
+LL | |         // Don't listen to my clone below
+LL | |
+LL | |         if y == 90 { "=^.^=" } else { ":D" }
+LL | |     } else {
+   | |_____^
+   |
+note: same as this
+  --> $DIR/valid_if_blocks.rs:137:12
+   |
+LL |       } else {
+   |  ____________^
+LL | |         // Don't listen to my clone above
+LL | |         println!("I'm a doppelgänger");
+LL | |
+LL | |         if y == 90 { "=^.^=" } else { ":D" }
+LL | |     };
+   | |_____^
+
+error: this `if` has identical blocks
+  --> $DIR/valid_if_blocks.rs:146:23
+   |
+LL |       } else if x == 68 {
+   |  _______________________^
+LL | |         println!("I'm a doppelgänger");
+LL | |         // Don't listen to my clone below
+LL | |     } else {
+   | |_____^
+   |
+note: same as this
+  --> $DIR/valid_if_blocks.rs:149:12
+   |
+LL |       } else {
+   |  ____________^
+LL | |         // Don't listen to my clone above
+LL | |         println!("I'm a doppelgänger");
+LL | |     }
+   | |_____^
+
+error: aborting due to 5 previous errors
+
diff --git a/tests/ui/checked_unwrap/complex_conditionals.rs b/tests/ui/checked_unwrap/complex_conditionals.rs
index bb5b6f5ec04..ec082c73b44 100644
--- a/tests/ui/checked_unwrap/complex_conditionals.rs
+++ b/tests/ui/checked_unwrap/complex_conditionals.rs
@@ -1,5 +1,5 @@
 #![deny(clippy::panicking_unwrap, clippy::unnecessary_unwrap)]
-#![allow(clippy::if_same_then_else, clippy::shared_code_in_if_blocks)]
+#![allow(clippy::if_same_then_else, clippy::branches_sharing_code)]
 
 fn test_complex_conditions() {
     let x: Result<(), ()> = Ok(());
diff --git a/tests/ui/checked_unwrap/complex_conditionals_nested.rs b/tests/ui/checked_unwrap/complex_conditionals_nested.rs
index 99e8fb95466..043ea4148dc 100644
--- a/tests/ui/checked_unwrap/complex_conditionals_nested.rs
+++ b/tests/ui/checked_unwrap/complex_conditionals_nested.rs
@@ -1,5 +1,5 @@
 #![deny(clippy::panicking_unwrap, clippy::unnecessary_unwrap)]
-#![allow(clippy::if_same_then_else, clippy::shared_code_in_if_blocks)]
+#![allow(clippy::if_same_then_else, clippy::branches_sharing_code)]
 
 fn test_nested() {
     fn nested() {
diff --git a/tests/ui/checked_unwrap/simple_conditionals.rs b/tests/ui/checked_unwrap/simple_conditionals.rs
index 0459100d88a..8f23fb28827 100644
--- a/tests/ui/checked_unwrap/simple_conditionals.rs
+++ b/tests/ui/checked_unwrap/simple_conditionals.rs
@@ -1,5 +1,5 @@
 #![deny(clippy::panicking_unwrap, clippy::unnecessary_unwrap)]
-#![allow(clippy::if_same_then_else, clippy::shared_code_in_if_blocks)]
+#![allow(clippy::if_same_then_else, clippy::branches_sharing_code)]
 
 macro_rules! m {
     ($a:expr) => {
diff --git a/tests/ui/default_numeric_fallback.rs b/tests/ui/default_numeric_fallback.rs
index de89f806c58..43468872db0 100644
--- a/tests/ui/default_numeric_fallback.rs
+++ b/tests/ui/default_numeric_fallback.rs
@@ -3,7 +3,7 @@
 #![allow(clippy::never_loop)]
 #![allow(clippy::no_effect)]
 #![allow(clippy::unnecessary_operation)]
-#![allow(clippy::shared_code_in_if_blocks)]
+#![allow(clippy::branches_sharing_code)]
 
 mod basic_expr {
     fn test() {
diff --git a/tests/ui/if_same_then_else.rs b/tests/ui/if_same_then_else.rs
index 35a2e139c11..ef956745500 100644
--- a/tests/ui/if_same_then_else.rs
+++ b/tests/ui/if_same_then_else.rs
@@ -6,7 +6,7 @@
     clippy::no_effect,
     clippy::unused_unit,
     clippy::zero_divided_by_zero,
-    clippy::shared_code_in_if_blocks
+    clippy::branches_sharing_code
 )]
 
 struct Foo {
diff --git a/tests/ui/if_same_then_else2.rs b/tests/ui/if_same_then_else2.rs
index 8164b125570..e4dc5b647df 100644
--- a/tests/ui/if_same_then_else2.rs
+++ b/tests/ui/if_same_then_else2.rs
@@ -6,7 +6,7 @@
     clippy::ifs_same_cond,
     clippy::needless_return,
     clippy::single_element_loop,
-    clippy::shared_code_in_if_blocks
+    clippy::branches_sharing_code
 )]
 
 fn if_same_then_else2() -> Result<&'static str, ()> {
diff --git a/tests/ui/let_if_seq.rs b/tests/ui/let_if_seq.rs
index 9fd3f875a5f..2d8f3c2f0e7 100644
--- a/tests/ui/let_if_seq.rs
+++ b/tests/ui/let_if_seq.rs
@@ -3,7 +3,7 @@
     unused_assignments,
     clippy::similar_names,
     clippy::blacklisted_name,
-    clippy::shared_code_in_if_blocks
+    clippy::branches_sharing_code
 )]
 #![warn(clippy::useless_let_if_seq)]
 
diff --git a/tests/ui/needless_bool/simple.rs b/tests/ui/needless_bool/simple.rs
index 678040fa98b..588bb88f446 100644
--- a/tests/ui/needless_bool/simple.rs
+++ b/tests/ui/needless_bool/simple.rs
@@ -5,7 +5,7 @@
     clippy::no_effect,
     clippy::if_same_then_else,
     clippy::needless_return,
-    clippy::shared_code_in_if_blocks
+    clippy::branches_sharing_code
 )]
 
 fn main() {
diff --git a/tests/ui/needless_return.fixed b/tests/ui/needless_return.fixed
index ebf74cfef12..82d95cc041f 100644
--- a/tests/ui/needless_return.fixed
+++ b/tests/ui/needless_return.fixed
@@ -4,7 +4,7 @@
 #![allow(
     clippy::if_same_then_else,
     clippy::single_match,
-    clippy::shared_code_in_if_blocks,
+    clippy::branches_sharing_code,
     clippy::needless_bool
 )]
 #![warn(clippy::needless_return)]
diff --git a/tests/ui/needless_return.rs b/tests/ui/needless_return.rs
index 2bebccdabca..8a471f802e1 100644
--- a/tests/ui/needless_return.rs
+++ b/tests/ui/needless_return.rs
@@ -4,7 +4,7 @@
 #![allow(
     clippy::if_same_then_else,
     clippy::single_match,
-    clippy::shared_code_in_if_blocks,
+    clippy::branches_sharing_code,
     clippy::needless_bool
 )]
 #![warn(clippy::needless_return)]
diff --git a/tests/ui/shared_code_in_if_blocks/shared_at_bot.rs b/tests/ui/shared_code_in_if_blocks/shared_at_bot.rs
deleted file mode 100644
index 6ff362cb752..00000000000
--- a/tests/ui/shared_code_in_if_blocks/shared_at_bot.rs
+++ /dev/null
@@ -1,209 +0,0 @@
-#![allow(dead_code)]
-#![deny(clippy::if_same_then_else, clippy::shared_code_in_if_blocks)]
-
-// This tests the shared_code_in_if_blocks lint at the end of blocks
-
-fn simple_examples() {
-    let x = 1;
-
-    let _ = if x == 7 {
-        println!("Branch I");
-        let start_value = 0;
-        println!("=^.^=");
-
-        // Same but not moveable due to `start_value`
-        let _ = start_value;
-
-        // The rest is self contained and moveable => Only lint the rest
-        let result = false;
-        println!("Block end!");
-        result
-    } else {
-        println!("Branch II");
-        let start_value = 8;
-        println!("xD");
-
-        // Same but not moveable due to `start_value`
-        let _ = start_value;
-
-        // The rest is self contained and moveable => Only lint the rest
-        let result = false;
-        println!("Block end!");
-        result
-    };
-
-    // Else if block
-    if x == 9 {
-        println!("The index is: 6");
-
-        println!("Same end of block");
-    } else if x == 8 {
-        println!("The index is: 4");
-
-        // We should only get a lint trigger for the last statement
-        println!("This is also eq with the else block");
-        println!("Same end of block");
-    } else {
-        println!("This is also eq with the else block");
-        println!("Same end of block");
-    }
-
-    // Use of outer scope value
-    let outer_scope_value = "I'm outside the if block";
-    if x < 99 {
-        let z = "How are you";
-        println!("I'm a local because I use the value `z`: `{}`", z);
-
-        println!(
-            "I'm moveable because I know: `outer_scope_value`: '{}'",
-            outer_scope_value
-        );
-    } else {
-        let z = 45678000;
-        println!("I'm a local because I use the value `z`: `{}`", z);
-
-        println!(
-            "I'm moveable because I know: `outer_scope_value`: '{}'",
-            outer_scope_value
-        );
-    }
-
-    if x == 9 {
-        if x == 8 {
-            // No parent!!
-            println!("---");
-            println!("Hello World");
-        } else {
-            println!("Hello World");
-        }
-    }
-}
-
-/// Simple examples where the move can cause some problems due to moved values
-fn simple_but_suggestion_is_invalid() {
-    let x = 16;
-
-    // Local value
-    let later_used_value = 17;
-    if x == 9 {
-        let _ = 9;
-        let later_used_value = "A string value";
-        println!("{}", later_used_value);
-    } else {
-        let later_used_value = "A string value";
-        println!("{}", later_used_value);
-        // I'm expecting a note about this
-    }
-    println!("{}", later_used_value);
-
-    // outer function
-    if x == 78 {
-        let simple_examples = "I now identify as a &str :)";
-        println!("This is the new simple_example: {}", simple_examples);
-    } else {
-        println!("Separator print statement");
-
-        let simple_examples = "I now identify as a &str :)";
-        println!("This is the new simple_example: {}", simple_examples);
-    }
-    simple_examples();
-}
-
-/// Tests where the blocks are not linted due to the used value scope
-fn not_moveable_due_to_value_scope() {
-    let x = 18;
-
-    // Using a local value in the moved code
-    if x == 9 {
-        let y = 18;
-        println!("y is: `{}`", y);
-    } else {
-        let y = "A string";
-        println!("y is: `{}`", y);
-    }
-
-    // Using a local value in the expression
-    let _ = if x == 0 {
-        let mut result = x + 1;
-
-        println!("1. Doing some calculations");
-        println!("2. Some more calculations");
-        println!("3. Setting result");
-
-        result
-    } else {
-        let mut result = x - 1;
-
-        println!("1. Doing some calculations");
-        println!("2. Some more calculations");
-        println!("3. Setting result");
-
-        result
-    };
-
-    let _ = if x == 7 {
-        let z1 = 100;
-        println!("z1: {}", z1);
-
-        let z2 = z1;
-        println!("z2: {}", z2);
-
-        z2
-    } else {
-        let z1 = 300;
-        println!("z1: {}", z1);
-
-        let z2 = z1;
-        println!("z2: {}", z2);
-
-        z2
-    };
-}
-
-/// This should add a note to the lint msg since the moved expression is not `()`
-fn added_note_for_expression_use() -> u32 {
-    let x = 9;
-
-    let _ = if x == 7 {
-        x << 2
-    } else {
-        let _ = 6;
-        x << 2
-    };
-
-    if x == 9 {
-        x * 4
-    } else {
-        let _ = 17;
-        x * 4
-    }
-}
-
-#[rustfmt::skip]
-fn test_suggestion_with_weird_formatting() {
-    let x = 9;
-    let mut a = 0;
-    let mut b = 0;
-
-    // The error message still looks weird tbh but this is the best I can do
-    // for weird formatting
-    if x == 17 { b = 1; a = 0x99; } else { a = 0x99; }
-}
-
-fn fp_test() {
-    let x = 17;
-
-    if x == 18 {
-        let y = 19;
-        if y < x {
-            println!("Trigger")
-        }
-    } else {
-        let z = 166;
-        if z < x {
-            println!("Trigger")
-        }
-    }
-}
-
-fn main() {}
diff --git a/tests/ui/shared_code_in_if_blocks/shared_at_bot.stderr b/tests/ui/shared_code_in_if_blocks/shared_at_bot.stderr
deleted file mode 100644
index 2268d8f5365..00000000000
--- a/tests/ui/shared_code_in_if_blocks/shared_at_bot.stderr
+++ /dev/null
@@ -1,143 +0,0 @@
-error: all if blocks contain the same code at the end
-  --> $DIR/shared_at_bot.rs:30:5
-   |
-LL | /         let result = false;
-LL | |         println!("Block end!");
-LL | |         result
-LL | |     };
-   | |_____^
-   |
-note: the lint level is defined here
-  --> $DIR/shared_at_bot.rs:2:36
-   |
-LL | #![deny(clippy::if_same_then_else, clippy::shared_code_in_if_blocks)]
-   |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   = note: The end suggestion probably needs some adjustments to use the expression result correctly
-help: consider moving the end statements out like this
-   |
-LL |     }
-LL |     let result = false;
-LL |     println!("Block end!");
-LL |     result;
-   |
-
-error: all if blocks contain the same code at the end
-  --> $DIR/shared_at_bot.rs:48:5
-   |
-LL | /         println!("Same end of block");
-LL | |     }
-   | |_____^
-   |
-help: consider moving the end statements out like this
-   |
-LL |     }
-LL |     println!("Same end of block");
-   |
-
-error: all if blocks contain the same code at the end
-  --> $DIR/shared_at_bot.rs:65:5
-   |
-LL | /         println!(
-LL | |             "I'm moveable because I know: `outer_scope_value`: '{}'",
-LL | |             outer_scope_value
-LL | |         );
-LL | |     }
-   | |_____^
-   |
-help: consider moving the end statements out like this
-   |
-LL |     }
-LL |     println!(
-LL |         "I'm moveable because I know: `outer_scope_value`: '{}'",
-LL |         outer_scope_value
-LL |     );
-   |
-
-error: all if blocks contain the same code at the end
-  --> $DIR/shared_at_bot.rs:77:9
-   |
-LL | /             println!("Hello World");
-LL | |         }
-   | |_________^
-   |
-help: consider moving the end statements out like this
-   |
-LL |         }
-LL |         println!("Hello World");
-   |
-
-error: all if blocks contain the same code at the end
-  --> $DIR/shared_at_bot.rs:93:5
-   |
-LL | /         let later_used_value = "A string value";
-LL | |         println!("{}", later_used_value);
-LL | |         // I'm expecting a note about this
-LL | |     }
-   | |_____^
-   |
-   = warning: Some moved values might need to be renamed to avoid wrong references
-help: consider moving the end statements out like this
-   |
-LL |     }
-LL |     let later_used_value = "A string value";
-LL |     println!("{}", later_used_value);
-   |
-
-error: all if blocks contain the same code at the end
-  --> $DIR/shared_at_bot.rs:106:5
-   |
-LL | /         let simple_examples = "I now identify as a &str :)";
-LL | |         println!("This is the new simple_example: {}", simple_examples);
-LL | |     }
-   | |_____^
-   |
-   = warning: Some moved values might need to be renamed to avoid wrong references
-help: consider moving the end statements out like this
-   |
-LL |     }
-LL |     let simple_examples = "I now identify as a &str :)";
-LL |     println!("This is the new simple_example: {}", simple_examples);
-   |
-
-error: all if blocks contain the same code at the end
-  --> $DIR/shared_at_bot.rs:171:5
-   |
-LL | /         x << 2
-LL | |     };
-   | |_____^
-   |
-   = note: The end suggestion probably needs some adjustments to use the expression result correctly
-help: consider moving the end statements out like this
-   |
-LL |     }
-LL |     x << 2;
-   |
-
-error: all if blocks contain the same code at the end
-  --> $DIR/shared_at_bot.rs:178:5
-   |
-LL | /         x * 4
-LL | |     }
-   | |_____^
-   |
-   = note: The end suggestion probably needs some adjustments to use the expression result correctly
-help: consider moving the end statements out like this
-   |
-LL |     }
-LL |     x * 4
-   |
-
-error: all if blocks contain the same code at the end
-  --> $DIR/shared_at_bot.rs:190:44
-   |
-LL |     if x == 17 { b = 1; a = 0x99; } else { a = 0x99; }
-   |                                            ^^^^^^^^^^^
-   |
-help: consider moving the end statements out like this
-   |
-LL |     if x == 17 { b = 1; a = 0x99; } else { }
-LL |     a = 0x99;
-   |
-
-error: aborting due to 9 previous errors
-
diff --git a/tests/ui/shared_code_in_if_blocks/shared_at_top.rs b/tests/ui/shared_code_in_if_blocks/shared_at_top.rs
deleted file mode 100644
index 496939f2a5e..00000000000
--- a/tests/ui/shared_code_in_if_blocks/shared_at_top.rs
+++ /dev/null
@@ -1,103 +0,0 @@
-#![allow(dead_code, clippy::eval_order_dependence)]
-#![deny(clippy::if_same_then_else, clippy::shared_code_in_if_blocks)]
-
-// This tests the shared_code_in_if_blocks lint at the start of blocks
-
-fn simple_examples() {
-    let x = 0;
-
-    // Simple
-    if true {
-        println!("Hello World!");
-        println!("I'm branch nr: 1");
-    } else {
-        println!("Hello World!");
-        println!("I'm branch nr: 2");
-    }
-
-    // Else if
-    if x == 0 {
-        let y = 9;
-        println!("The value y was set to: `{}`", y);
-        let _z = y;
-
-        println!("I'm the true start index of arrays");
-    } else if x == 1 {
-        let y = 9;
-        println!("The value y was set to: `{}`", y);
-        let _z = y;
-
-        println!("I start counting from 1 so my array starts from `1`");
-    } else {
-        let y = 9;
-        println!("The value y was set to: `{}`", y);
-        let _z = y;
-
-        println!("Ha, Pascal allows you to start the array where you want")
-    }
-
-    // Return a value
-    let _ = if x == 7 {
-        let y = 16;
-        println!("What can I say except: \"you're welcome?\"");
-        let _ = y;
-        x
-    } else {
-        let y = 16;
-        println!("Thank you");
-        y
-    };
-}
-
-/// Simple examples where the move can cause some problems due to moved values
-fn simple_but_suggestion_is_invalid() {
-    let x = 10;
-
-    // Can't be automatically moved because used_value_name is getting used again
-    let used_value_name = 19;
-    if x == 10 {
-        let used_value_name = "Different type";
-        println!("Str: {}", used_value_name);
-        let _ = 1;
-    } else {
-        let used_value_name = "Different type";
-        println!("Str: {}", used_value_name);
-        let _ = 2;
-    }
-    let _ = used_value_name;
-
-    // This can be automatically moved as `can_be_overridden` is not used again
-    let can_be_overridden = 8;
-    let _ = can_be_overridden;
-    if x == 11 {
-        let can_be_overridden = "Move me";
-        println!("I'm also moveable");
-        let _ = 111;
-    } else {
-        let can_be_overridden = "Move me";
-        println!("I'm also moveable");
-        let _ = 222;
-    }
-}
-
-/// This function tests that the `IS_SAME_THAN_ELSE` only covers the lint if it's enabled.
-fn check_if_same_than_else_mask() {
-    let x = 2021;
-
-    #[allow(clippy::if_same_then_else)]
-    if x == 2020 {
-        println!("This should trigger the `SHARED_CODE_IN_IF_BLOCKS` lint.");
-        println!("Because `IF_SAME_THEN_ELSE` is allowed here");
-    } else {
-        println!("This should trigger the `SHARED_CODE_IN_IF_BLOCKS` lint.");
-        println!("Because `IF_SAME_THEN_ELSE` is allowed here");
-    }
-
-    if x == 2019 {
-        println!("This should trigger `IS_SAME_THAN_ELSE` as usual");
-    } else {
-        println!("This should trigger `IS_SAME_THAN_ELSE` as usual");
-    }
-}
-
-fn main() {}
diff --git a/tests/ui/shared_code_in_if_blocks/shared_at_top.stderr b/tests/ui/shared_code_in_if_blocks/shared_at_top.stderr
deleted file mode 100644
index 76898a6ff02..00000000000
--- a/tests/ui/shared_code_in_if_blocks/shared_at_top.stderr
+++ /dev/null
@@ -1,121 +0,0 @@
-error: all if blocks contain the same code at the start
-  --> $DIR/shared_at_top.rs:10:5
-   |
-LL | /     if true {
-LL | |         println!("Hello World!");
-   | |_________________________________^
-   |
-note: the lint level is defined here
-  --> $DIR/shared_at_top.rs:2:36
-   |
-LL | #![deny(clippy::if_same_then_else, clippy::shared_code_in_if_blocks)]
-   |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-help: consider moving the start statements out like this
-   |
-LL |     println!("Hello World!");
-LL |     if true {
-   |
-
-error: all if blocks contain the same code at the start
-  --> $DIR/shared_at_top.rs:19:5
-   |
-LL | /     if x == 0 {
-LL | |         let y = 9;
-LL | |         println!("The value y was set to: `{}`", y);
-LL | |         let _z = y;
-   | |___________________^
-   |
-   = warning: Some moved values might need to be renamed to avoid wrong references
-help: consider moving the start statements out like this
-   |
-LL |     let y = 9;
-LL |     println!("The value y was set to: `{}`", y);
-LL |     let _z = y;
-LL |     if x == 0 {
-   |
-
-error: all if blocks contain the same code at the start
-  --> $DIR/shared_at_top.rs:40:5
-   |
-LL | /     let _ = if x == 7 {
-LL | |         let y = 16;
-   | |___________________^
-   |
-help: consider moving the start statements out like this
-   |
-LL |     let y = 16;
-LL |     let _ = if x == 7 {
-   |
-
-error: all if blocks contain the same code at the start
-  --> $DIR/shared_at_top.rs:58:5
-   |
-LL | /     if x == 10 {
-LL | |         let used_value_name = "Different type";
-LL | |         println!("Str: {}", used_value_name);
-   | |_____________________________________________^
-   |
-   = warning: Some moved values might need to be renamed to avoid wrong references
-help: consider moving the start statements out like this
-   |
-LL |     let used_value_name = "Different type";
-LL |     println!("Str: {}", used_value_name);
-LL |     if x == 10 {
-   |
-
-error: all if blocks contain the same code at the start
-  --> $DIR/shared_at_top.rs:72:5
-   |
-LL | /     if x == 11 {
-LL | |         let can_be_overridden = "Move me";
-LL | |         println!("I'm also moveable");
-   | |______________________________________^
-   |
-   = warning: Some moved values might need to be renamed to avoid wrong references
-help: consider moving the start statements out like this
-   |
-LL |     let can_be_overridden = "Move me";
-LL |     println!("I'm also moveable");
-LL |     if x == 11 {
-   |
-
-error: all if blocks contain the same code at the start
-  --> $DIR/shared_at_top.rs:88:5
-   |
-LL | /     if x == 2020 {
-LL | |         println!("This should trigger the `SHARED_CODE_IN_IF_BLOCKS` lint.");
-LL | |         println!("Because `IF_SAME_THEN_ELSE` is allowed here");
-   | |________________________________________________________________^
-   |
-help: consider moving the start statements out like this
-   |
-LL |     println!("This should trigger the `SHARED_CODE_IN_IF_BLOCKS` lint.");
-LL |     println!("Because `IF_SAME_THEN_ELSE` is allowed here");
-LL |     if x == 2020 {
-   |
-
-error: this `if` has identical blocks
-  --> $DIR/shared_at_top.rs:96:18
-   |
-LL |       if x == 2019 {
-   |  __________________^
-LL | |         println!("This should trigger `IS_SAME_THAN_ELSE` as usual");
-LL | |     } else {
-   | |_____^
-   |
-note: the lint level is defined here
-  --> $DIR/shared_at_top.rs:2:9
-   |
-LL | #![deny(clippy::if_same_then_else, clippy::shared_code_in_if_blocks)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^
-note: same as this
-  --> $DIR/shared_at_top.rs:98:12
-   |
-LL |       } else {
-   |  ____________^
-LL | |         println!("This should trigger `IS_SAME_THAN_ELSE` as usual");
-LL | |     }
-   | |_____^
-
-error: aborting due to 7 previous errors
-
diff --git a/tests/ui/shared_code_in_if_blocks/shared_at_top_and_bot.rs b/tests/ui/shared_code_in_if_blocks/shared_at_top_and_bot.rs
deleted file mode 100644
index 46a8f931aaf..00000000000
--- a/tests/ui/shared_code_in_if_blocks/shared_at_top_and_bot.rs
+++ /dev/null
@@ -1,119 +0,0 @@
-#![allow(dead_code)]
-#![deny(clippy::if_same_then_else, clippy::shared_code_in_if_blocks)]
-
-// shared_code_in_if_blocks at the top and bottom of the if blocks
-
-struct DataPack {
-    id: u32,
-    name: String,
-    some_data: Vec<u8>,
-}
-
-fn overlapping_eq_regions() {
-    let x = 9;
-
-    // Overlap with separator
-    if x == 7 {
-        let t = 7;
-        let _overlap_start = t * 2;
-        let _overlap_end = 2 * t;
-        let _u = 9;
-    } else {
-        let t = 7;
-        let _overlap_start = t * 2;
-        let _overlap_end = 2 * t;
-        println!("Overlap separator");
-        let _overlap_start = t * 2;
-        let _overlap_end = 2 * t;
-        let _u = 9;
-    }
-
-    // Overlap with separator
-    if x == 99 {
-        let r = 7;
-        let _overlap_start = r;
-        let _overlap_middle = r * r;
-        let _overlap_end = r * r * r;
-        let z = "end";
-    } else {
-        let r = 7;
-        let _overlap_start = r;
-        let _overlap_middle = r * r;
-        let _overlap_middle = r * r;
-        let _overlap_end = r * r * r;
-        let z = "end";
-    }
-}
-
-fn complexer_example() {
-    fn gen_id(x: u32, y: u32) -> u32 {
-        let x = x & 0x0000_ffff;
-        let y = (y & 0xffff_0000) << 16;
-        x | y
-    }
-
-    fn process_data(data: DataPack) {
-        let _ = data;
-    }
-
-    let x = 8;
-    let y = 9;
-    if (x > 7 && y < 13) || (x + y) % 2 == 1 {
-        let a = 0xcafe;
-        let b = 0xffff00ff;
-        let e_id = gen_id(a, b);
-
-        println!("From the a `{}` to the b `{}`", a, b);
-
-        let pack = DataPack {
-            id: e_id,
-            name: "Player 1".to_string(),
-            some_data: vec![0x12, 0x34, 0x56, 0x78, 0x90],
-        };
-        process_data(pack);
-    } else {
-        let a = 0xcafe;
-        let b = 0xffff00ff;
-        let e_id = gen_id(a, b);
-
-        println!("The new ID is '{}'", e_id);
-
-        let pack = DataPack {
-            id: e_id,
-            name: "Player 1".to_string(),
-            some_data: vec![0x12, 0x34, 0x56, 0x78, 0x90],
-        };
-        process_data(pack);
-    }
-}
-
-/// This should add a note to the lint msg since the moved expression is not `()`
-fn added_note_for_expression_use() -> u32 {
-    let x = 9;
-
-    let _ = if x == 7 {
-        let _ = 19;
-
-        let _splitter = 6;
-
-        x << 2
-    } else {
-        let _ = 19;
-
-        x << 2
-    };
-
-    if x == 9 {
-        let _ = 17;
-
-        let _splitter = 6;
-
-        x * 4
-    } else {
-        let _ = 17;
-
-        x * 4
-    }
-}
-
-fn main() {}
diff --git a/tests/ui/shared_code_in_if_blocks/shared_at_top_and_bot.stderr b/tests/ui/shared_code_in_if_blocks/shared_at_top_and_bot.stderr
deleted file mode 100644
index 75c3d397f2e..00000000000
--- a/tests/ui/shared_code_in_if_blocks/shared_at_top_and_bot.stderr
+++ /dev/null
@@ -1,154 +0,0 @@
-error: all if blocks contain the same code at the start and the end. Here at the start
-  --> $DIR/shared_at_top_and_bot.rs:16:5
-   |
-LL | /     if x == 7 {
-LL | |         let t = 7;
-LL | |         let _overlap_start = t * 2;
-LL | |         let _overlap_end = 2 * t;
-   | |_________________________________^
-   |
-note: the lint level is defined here
-  --> $DIR/shared_at_top_and_bot.rs:2:36
-   |
-LL | #![deny(clippy::if_same_then_else, clippy::shared_code_in_if_blocks)]
-   |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-note: and here at the end
-  --> $DIR/shared_at_top_and_bot.rs:28:5
-   |
-LL | /         let _u = 9;
-LL | |     }
-   | |_____^
-help: consider moving the start statements out like this
-   |
-LL |     let t = 7;
-LL |     let _overlap_start = t * 2;
-LL |     let _overlap_end = 2 * t;
-LL |     if x == 7 {
-   |
-help: and consider moving the end statements out like this
-   |
-LL |     }
-LL |     let _u = 9;
-   |
-
-error: all if blocks contain the same code at the start and the end. Here at the start
-  --> $DIR/shared_at_top_and_bot.rs:32:5
-   |
-LL | /     if x == 99 {
-LL | |         let r = 7;
-LL | |         let _overlap_start = r;
-LL | |         let _overlap_middle = r * r;
-   | |____________________________________^
-   |
-note: and here at the end
-  --> $DIR/shared_at_top_and_bot.rs:43:5
-   |
-LL | /         let _overlap_end = r * r * r;
-LL | |         let z = "end";
-LL | |     }
-   | |_____^
-   = warning: Some moved values might need to be renamed to avoid wrong references
-help: consider moving the start statements out like this
-   |
-LL |     let r = 7;
-LL |     let _overlap_start = r;
-LL |     let _overlap_middle = r * r;
-LL |     if x == 99 {
-   |
-help: and consider moving the end statements out like this
-   |
-LL |     }
-LL |     let _overlap_end = r * r * r;
-LL |     let z = "end";
-   |
-
-error: all if blocks contain the same code at the start and the end. Here at the start
-  --> $DIR/shared_at_top_and_bot.rs:61:5
-   |
-LL | /     if (x > 7 && y < 13) || (x + y) % 2 == 1 {
-LL | |         let a = 0xcafe;
-LL | |         let b = 0xffff00ff;
-LL | |         let e_id = gen_id(a, b);
-   | |________________________________^
-   |
-note: and here at the end
-  --> $DIR/shared_at_top_and_bot.rs:81:5
-   |
-LL | /         let pack = DataPack {
-LL | |             id: e_id,
-LL | |             name: "Player 1".to_string(),
-LL | |             some_data: vec![0x12, 0x34, 0x56, 0x78, 0x90],
-LL | |         };
-LL | |         process_data(pack);
-LL | |     }
-   | |_____^
-   = warning: Some moved values might need to be renamed to avoid wrong references
-help: consider moving the start statements out like this
-   |
-LL |     let a = 0xcafe;
-LL |     let b = 0xffff00ff;
-LL |     let e_id = gen_id(a, b);
-LL |     if (x > 7 && y < 13) || (x + y) % 2 == 1 {
-   |
-help: and consider moving the end statements out like this
-   |
-LL |     }
-LL |     let pack = DataPack {
-LL |         id: e_id,
-LL |         name: "Player 1".to_string(),
-LL |         some_data: vec![0x12, 0x34, 0x56, 0x78, 0x90],
-LL |     };
- ...
-
-error: all if blocks contain the same code at the start and the end. Here at the start
-  --> $DIR/shared_at_top_and_bot.rs:94:5
-   |
-LL | /     let _ = if x == 7 {
-LL | |         let _ = 19;
-   | |___________________^
-   |
-note: and here at the end
-  --> $DIR/shared_at_top_and_bot.rs:103:5
-   |
-LL | /         x << 2
-LL | |     };
-   | |_____^
-   = note: The end suggestion probably needs some adjustments to use the expression result correctly
-help: consider moving the start statements out like this
-   |
-LL |     let _ = 19;
-LL |     let _ = if x == 7 {
-   |
-help: and consider moving the end statements out like this
-   |
-LL |     }
-LL |     x << 2;
-   |
-
-error: all if blocks contain the same code at the start and the end. Here at the start
-  --> $DIR/shared_at_top_and_bot.rs:106:5
-   |
-LL | /     if x == 9 {
-LL | |         let _ = 17;
-   | |___________________^
-   |
-note: and here at the end
-  --> $DIR/shared_at_top_and_bot.rs:115:5
-   |
-LL | /         x * 4
-LL | |     }
-   | |_____^
-   = note: The end suggestion probably needs some adjustments to use the expression result correctly
-help: consider moving the start statements out like this
-   |
-LL |     let _ = 17;
-LL |     if x == 9 {
-   |
-help: and consider moving the end statements out like this
-   |
-LL |     }
-LL |     x * 4
-   |
-
-error: aborting due to 5 previous errors
-
diff --git a/tests/ui/shared_code_in_if_blocks/valid_if_blocks.rs b/tests/ui/shared_code_in_if_blocks/valid_if_blocks.rs
deleted file mode 100644
index e63490d5b07..00000000000
--- a/tests/ui/shared_code_in_if_blocks/valid_if_blocks.rs
+++ /dev/null
@@ -1,155 +0,0 @@
-#![allow(dead_code, clippy::eval_order_dependence)]
-#![deny(clippy::if_same_then_else, clippy::shared_code_in_if_blocks)]
-
-// This tests the shared_code_in_if_blocks lint at the start of blocks
-
-// Tests with value references are includes in "shared_code_at_bot.rs"
-
-fn valid_examples() {
-    let x = 2;
-
-    // The edge statements are different
-    if x == 9 {
-        let y = 1 << 5;
-
-        println!("This is the same: vvv");
-        let _z = y;
-        println!("The block expression is different");
-
-        println!("Different end 1");
-    } else {
-        let y = 1 << 7;
-
-        println!("This is the same: vvv");
-        let _z = y;
-        println!("The block expression is different");
-
-        println!("Different end 2");
-    }
-
-    // No else
-    if x == 2 {
-        println!("Hello world!");
-        println!("Hello back, how are you?");
-
-        // This is different vvvv
-        println!("Howdy stranger =^.^=");
-
-        println!("Bye Bye World");
-    } else if x == 9 {
-        println!("Hello world!");
-        println!("Hello back, how are you?");
-
-        // This is different vvvv
-        println!("Hello reviewer :D");
-
-        println!("Bye Bye World");
-    }
-
-    // Overlapping statements only in else if blocks -> Don't lint
-    if x == 0 {
-        println!("I'm important!")
-    } else if x == 17 {
-        println!("I share code in else if");
-
-        println!("x is 17");
-    } else {
-        println!("I share code in else if");
-
-        println!("x is nether x nor 17");
-    }
-
-    // Mutability is different
-    if x == 13 {
-        let mut y = 9;
-        println!("Value y is: {}", y);
-        y += 16;
-        let _z1 = y;
-    } else {
-        let y = 9;
-        println!("Value y is: {}", y);
-        let _z2 = y;
-    }
-
-    // Same blocks but at start and bottom so no `if_same_then_else` lint
-    if x == 418 {
-        let y = 9;
-        let z = 8;
-        let _ = (x, y, z);
-        // Don't tell the programmer, my code is also in the else block
-    } else if x == 419 {
-        println!("+-----------+");
-        println!("|           |");
-        println!("|  O     O  |");
-        println!("|     °     |");
-        println!("|  \\_____/  |");
-        println!("|           |");
-        println!("+-----------+");
-    } else {
-        let y = 9;
-        let z = 8;
-        let _ = (x, y, z);
-        // I'm so much better than the x == 418 block. Trust me
-    }
-
-    let x = 1;
-    if true {
-        println!("{}", x);
-    } else {
-        let x = 2;
-        println!("{}", x);
-    }
-
-    // Let's test empty blocks
-    if false {
-    } else {
-    }
-}
-
-/// This makes sure that the `if_same_then_else` masks the `shared_code_in_if_blocks` lint
-fn trigger_other_lint() {
-    let x = 0;
-    let y = 1;
-
-    // Same block
-    if x == 0 {
-        let u = 19;
-        println!("How are u today?");
-        let _ = "This is a string";
-    } else {
-        let u = 19;
-        println!("How are u today?");
-        let _ = "This is a string";
-    }
-
-    // Only same expression
-    let _ = if x == 6 { 7 } else { 7 };
-
-    // Same in else if block
-    let _ = if x == 67 {
-        println!("Well I'm the most important block");
-        "I'm a pretty string"
-    } else if x == 68 {
-        println!("I'm a doppelgänger");
-        // Don't listen to my clone below
-
-        if y == 90 { "=^.^=" } else { ":D" }
-    } else {
-        // Don't listen to my clone above
-        println!("I'm a doppelgänger");
-
-        if y == 90 { "=^.^=" } else { ":D" }
-    };
-
-    if x == 0 {
-        println!("I'm single");
-    } else if x == 68 {
-        println!("I'm a doppelgänger");
-        // Don't listen to my clone below
-    } else {
-        // Don't listen to my clone above
-        println!("I'm a doppelgänger");
-    }
-}
-
-fn main() {}
diff --git a/tests/ui/shared_code_in_if_blocks/valid_if_blocks.stderr b/tests/ui/shared_code_in_if_blocks/valid_if_blocks.stderr
deleted file mode 100644
index 846581456dc..00000000000
--- a/tests/ui/shared_code_in_if_blocks/valid_if_blocks.stderr
+++ /dev/null
@@ -1,101 +0,0 @@
-error: this `if` has identical blocks
-  --> $DIR/valid_if_blocks.rs:104:14
-   |
-LL |       if false {
-   |  ______________^
-LL | |     } else {
-   | |_____^
-   |
-note: the lint level is defined here
-  --> $DIR/valid_if_blocks.rs:2:9
-   |
-LL | #![deny(clippy::if_same_then_else, clippy::shared_code_in_if_blocks)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^
-note: same as this
-  --> $DIR/valid_if_blocks.rs:105:12
-   |
-LL |       } else {
-   |  ____________^
-LL | |     }
-   | |_____^
-
-error: this `if` has identical blocks
-  --> $DIR/valid_if_blocks.rs:115:15
-   |
-LL |       if x == 0 {
-   |  _______________^
-LL | |         let u = 19;
-LL | |         println!("How are u today?");
-LL | |         let _ = "This is a string";
-LL | |     } else {
-   | |_____^
-   |
-note: same as this
-  --> $DIR/valid_if_blocks.rs:119:12
-   |
-LL |       } else {
-   |  ____________^
-LL | |         let u = 19;
-LL | |         println!("How are u today?");
-LL | |         let _ = "This is a string";
-LL | |     }
-   | |_____^
-
-error: this `if` has identical blocks
-  --> $DIR/valid_if_blocks.rs:126:23
-   |
-LL |     let _ = if x == 6 { 7 } else { 7 };
-   |                       ^^^^^
-   |
-note: same as this
-  --> $DIR/valid_if_blocks.rs:126:34
-   |
-LL |     let _ = if x == 6 { 7 } else { 7 };
-   |                                  ^^^^^
-
-error: this `if` has identical blocks
-  --> $DIR/valid_if_blocks.rs:132:23
-   |
-LL |       } else if x == 68 {
-   |  _______________________^
-LL | |         println!("I'm a doppelgänger");
-LL | |         // Don't listen to my clone below
-LL | |
-LL | |         if y == 90 { "=^.^=" } else { ":D" }
-LL | |     } else {
-   | |_____^
-   |
-note: same as this
-  --> $DIR/valid_if_blocks.rs:137:12
-   |
-LL |       } else {
-   |  ____________^
-LL | |         // Don't listen to my clone above
-LL | |         println!("I'm a doppelgänger");
-LL | |
-LL | |         if y == 90 { "=^.^=" } else { ":D" }
-LL | |     };
-   | |_____^
-
-error: this `if` has identical blocks
-  --> $DIR/valid_if_blocks.rs:146:23
-   |
-LL |       } else if x == 68 {
-   |  _______________________^
-LL | |         println!("I'm a doppelgänger");
-LL | |         // Don't listen to my clone below
-LL | |     } else {
-   | |_____^
-   |
-note: same as this
-  --> $DIR/valid_if_blocks.rs:149:12
-   |
-LL |       } else {
-   |  ____________^
-LL | |         // Don't listen to my clone above
-LL | |         println!("I'm a doppelgänger");
-LL | |     }
-   | |_____^
-
-error: aborting due to 5 previous errors
-
-- 
cgit 1.4.1-3-g733a5


From 1573d10325f286ffcbba290d27984ded9538a5c3 Mon Sep 17 00:00:00 2001
From: Philipp Hansch <dev@phansch.net>
Date: Tue, 6 Apr 2021 06:59:10 +0200
Subject: tabs_in_doc_comments: Fix ICE due to char indexing
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This is a quick-fix for an ICE in `tabs_in_doc_comments`. The problem
was that we we're indexing into possibly multi-byte characters, such as '位'.

More specifically `get_chunks_of_tabs` was returning indices into
multi-byte characters. Those were passed on to a `Span` creation that
then caused the ICE.

This fix makes sure that we don't return indices that point inside a
multi-byte character. *However*, we are still iterating over unicode
codepoints, not grapheme clusters. So a seemingly single character like y̆ ,
which actually consists of two codepoints, will probably still cause
incorrect spans in the output.
---
 clippy_lints/src/tabs_in_doc_comments.rs | 28 +++++++++++++++++-----------
 tests/ui/crashes/ice-5835.rs             |  8 ++++++++
 tests/ui/crashes/ice-5835.stderr         | 20 ++++++++++++++++++++
 3 files changed, 45 insertions(+), 11 deletions(-)
 create mode 100644 tests/ui/crashes/ice-5835.rs
 create mode 100644 tests/ui/crashes/ice-5835.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/tabs_in_doc_comments.rs b/clippy_lints/src/tabs_in_doc_comments.rs
index 88bd2feaadd..3f9692540f7 100644
--- a/clippy_lints/src/tabs_in_doc_comments.rs
+++ b/clippy_lints/src/tabs_in_doc_comments.rs
@@ -104,30 +104,29 @@ fn get_chunks_of_tabs(the_str: &str) -> Vec<(u32, u32)> {
     // tracker to decide if the last group of tabs is not closed by a non-tab character
     let mut is_active = false;
 
-    let chars_array: Vec<_> = the_str.chars().collect();
+    let char_indices: Vec<_> = the_str.char_indices().collect();
 
-    if chars_array == vec!['\t'] {
+    if char_indices.len() == 1 && char_indices.first().unwrap().1 == '\t' {
         return vec![(0, 1)];
     }
 
-    for (index, arr) in chars_array.windows(2).enumerate() {
-        let index = u32::try_from(index).expect(line_length_way_to_long);
-        match arr {
-            ['\t', '\t'] => {
+    for entry in char_indices.windows(2) {
+        match entry {
+            [(_, '\t'), (_, '\t')] => {
                 // either string starts with double tab, then we have to set it active,
                 // otherwise is_active is true anyway
                 is_active = true;
             },
-            [_, '\t'] => {
+            [(_, _), (index_b, '\t')] => {
                 // as ['\t', '\t'] is excluded, this has to be a start of a tab group,
                 // set indices accordingly
                 is_active = true;
-                current_start = index + 1;
+                current_start = *index_b as u32;
             },
-            ['\t', _] => {
+            [(_, '\t'), (index_b, _)] => {
                 // this now has to be an end of the group, hence we have to push a new tuple
                 is_active = false;
-                spans.push((current_start, index + 1));
+                spans.push((current_start, *index_b as u32));
             },
             _ => {},
         }
@@ -137,7 +136,7 @@ fn get_chunks_of_tabs(the_str: &str) -> Vec<(u32, u32)> {
     if is_active {
         spans.push((
             current_start,
-            u32::try_from(the_str.chars().count()).expect(line_length_way_to_long),
+            u32::try_from(char_indices.last().unwrap().0 + 1).expect(line_length_way_to_long),
         ));
     }
 
@@ -148,6 +147,13 @@ fn get_chunks_of_tabs(the_str: &str) -> Vec<(u32, u32)> {
 mod tests_for_get_chunks_of_tabs {
     use super::get_chunks_of_tabs;
 
+    #[test]
+    fn test_unicode_han_string() {
+        let res = get_chunks_of_tabs(" 位\t");
+
+        assert_eq!(res, vec![(4, 5)]);
+    }
+
     #[test]
     fn test_empty_string() {
         let res = get_chunks_of_tabs("");
diff --git a/tests/ui/crashes/ice-5835.rs b/tests/ui/crashes/ice-5835.rs
new file mode 100644
index 00000000000..209a5b1eb09
--- /dev/null
+++ b/tests/ui/crashes/ice-5835.rs
@@ -0,0 +1,8 @@
+#![rustfmt::skip]
+
+pub struct Foo {
+    /// 位	
+    pub bar: u8,
+}
+
+fn main() {}
diff --git a/tests/ui/crashes/ice-5835.stderr b/tests/ui/crashes/ice-5835.stderr
new file mode 100644
index 00000000000..e286bc580ad
--- /dev/null
+++ b/tests/ui/crashes/ice-5835.stderr
@@ -0,0 +1,20 @@
+error[E0658]: custom inner attributes are unstable
+  --> $DIR/ice-5835.rs:1:4
+   |
+LL | #![rustfmt::skip]
+   |    ^^^^^^^^^^^^^
+   |
+   = note: see issue #54726 <https://github.com/rust-lang/rust/issues/54726> for more information
+   = help: add `#![feature(custom_inner_attributes)]` to the crate attributes to enable
+
+error: using tabs in doc comments is not recommended
+  --> $DIR/ice-5835.rs:4:10
+   |
+LL |     /// 位    
+   |           ^^^^ help: consider using four spaces per tab
+   |
+   = note: `-D clippy::tabs-in-doc-comments` implied by `-D warnings`
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0658`.
-- 
cgit 1.4.1-3-g733a5


From 8a50923da4884c30e96fce2b4408c96f5824db43 Mon Sep 17 00:00:00 2001
From: Horaci Macias <hmacias@avaya.com>
Date: Mon, 5 Apr 2021 13:27:39 +0200
Subject: consider mutability on useless_vec suggestions
 https://github.com/rust-lang/rust-clippy/issues/7035

---
 clippy_lints/src/vec.rs | 54 ++++++++++++++++++++++++++++++++++++++-----------
 tests/ui/vec.fixed      | 16 +++++++++++++++
 tests/ui/vec.rs         | 16 +++++++++++++++
 tests/ui/vec.stderr     | 44 +++++++++++++++++++++++++++++++++-------
 4 files changed, 111 insertions(+), 19 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/vec.rs b/clippy_lints/src/vec.rs
index 1af9583887f..bc2eb88114e 100644
--- a/clippy_lints/src/vec.rs
+++ b/clippy_lints/src/vec.rs
@@ -6,7 +6,7 @@ use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::is_copy;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
-use rustc_hir::{BorrowKind, Expr, ExprKind};
+use rustc_hir::{BorrowKind, Expr, ExprKind, Mutability};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{self, Ty};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
@@ -49,10 +49,10 @@ impl<'tcx> LateLintPass<'tcx> for UselessVec {
         if_chain! {
             if let ty::Ref(_, ty, _) = cx.typeck_results().expr_ty_adjusted(expr).kind();
             if let ty::Slice(..) = ty.kind();
-            if let ExprKind::AddrOf(BorrowKind::Ref, _, ref addressee) = expr.kind;
+            if let ExprKind::AddrOf(BorrowKind::Ref, mutability, ref addressee) = expr.kind;
             if let Some(vec_args) = higher::vec_macro(cx, addressee);
             then {
-                self.check_vec_macro(cx, &vec_args, expr.span);
+                self.check_vec_macro(cx, &vec_args, mutability, expr.span);
             }
         }
 
@@ -70,14 +70,20 @@ impl<'tcx> LateLintPass<'tcx> for UselessVec {
                     .ctxt()
                     .outer_expn_data()
                     .call_site;
-                self.check_vec_macro(cx, &vec_args, span);
+                self.check_vec_macro(cx, &vec_args, Mutability::Not, span);
             }
         }
     }
 }
 
 impl UselessVec {
-    fn check_vec_macro<'tcx>(self, cx: &LateContext<'tcx>, vec_args: &higher::VecArgs<'tcx>, span: Span) {
+    fn check_vec_macro<'tcx>(
+        self,
+        cx: &LateContext<'tcx>,
+        vec_args: &higher::VecArgs<'tcx>,
+        mutability: Mutability,
+        span: Span,
+    ) {
         let mut applicability = Applicability::MachineApplicable;
         let snippet = match *vec_args {
             higher::VecArgs::Repeat(elem, len) => {
@@ -87,11 +93,22 @@ impl UselessVec {
                         return;
                     }
 
-                    format!(
-                        "&[{}; {}]",
-                        snippet_with_applicability(cx, elem.span, "elem", &mut applicability),
-                        snippet_with_applicability(cx, len.span, "len", &mut applicability)
-                    )
+                    match mutability {
+                        Mutability::Mut => {
+                            format!(
+                                "&mut [{}; {}]",
+                                snippet_with_applicability(cx, elem.span, "elem", &mut applicability),
+                                snippet_with_applicability(cx, len.span, "len", &mut applicability)
+                            )
+                        },
+                        Mutability::Not => {
+                            format!(
+                                "&[{}; {}]",
+                                snippet_with_applicability(cx, elem.span, "elem", &mut applicability),
+                                snippet_with_applicability(cx, len.span, "len", &mut applicability)
+                            )
+                        },
+                    }
                 } else {
                     return;
                 }
@@ -104,9 +121,22 @@ impl UselessVec {
                     }
                     let span = args[0].span.to(last.span);
 
-                    format!("&[{}]", snippet_with_applicability(cx, span, "..", &mut applicability))
+                    match mutability {
+                        Mutability::Mut => {
+                            format!(
+                                "&mut [{}]",
+                                snippet_with_applicability(cx, span, "..", &mut applicability)
+                            )
+                        },
+                        Mutability::Not => {
+                            format!("&[{}]", snippet_with_applicability(cx, span, "..", &mut applicability))
+                        },
+                    }
                 } else {
-                    "&[]".into()
+                    match mutability {
+                        Mutability::Mut => "&mut []".into(),
+                        Mutability::Not => "&[]".into(),
+                    }
                 }
             },
         };
diff --git a/tests/ui/vec.fixed b/tests/ui/vec.fixed
index 85677159620..da35f2e5c1b 100644
--- a/tests/ui/vec.fixed
+++ b/tests/ui/vec.fixed
@@ -6,9 +6,14 @@
 struct NonCopy;
 
 fn on_slice(_: &[u8]) {}
+
+fn on_mut_slice(_: &mut [u8]) {}
+
 #[allow(clippy::ptr_arg)]
 fn on_vec(_: &Vec<u8>) {}
 
+fn on_mut_vec(_: &mut Vec<u8>) {}
+
 struct Line {
     length: usize,
 }
@@ -22,28 +27,38 @@ impl Line {
 fn main() {
     on_slice(&[]);
     on_slice(&[]);
+    on_mut_slice(&mut []);
 
     on_slice(&[1, 2]);
     on_slice(&[1, 2]);
+    on_mut_slice(&mut [1, 2]);
 
     on_slice(&[1, 2]);
     on_slice(&[1, 2]);
+    on_mut_slice(&mut [1, 2]);
     #[rustfmt::skip]
     on_slice(&[1, 2]);
     on_slice(&[1, 2]);
+    on_mut_slice(&mut [1, 2]);
 
     on_slice(&[1; 2]);
     on_slice(&[1; 2]);
+    on_mut_slice(&mut [1; 2]);
 
     on_vec(&vec![]);
     on_vec(&vec![1, 2]);
     on_vec(&vec![1; 2]);
+    on_mut_vec(&mut vec![]);
+    on_mut_vec(&mut vec![1, 2]);
+    on_mut_vec(&mut vec![1; 2]);
 
     // Now with non-constant expressions
     let line = Line { length: 2 };
 
     on_slice(&vec![2; line.length]);
     on_slice(&vec![2; line.length()]);
+    on_mut_slice(&mut vec![2; line.length]);
+    on_mut_slice(&mut vec![2; line.length()]);
 
     for a in &[1, 2, 3] {
         println!("{:?}", a);
@@ -54,6 +69,7 @@ fn main() {
     }
 
     on_vec(&vec![1; 201]); // Ok, size of `vec` higher than `too_large_for_stack`
+    on_mut_vec(&mut vec![1; 201]); // Ok, size of `vec` higher than `too_large_for_stack`
 
     // Ok
     for a in vec![1; 201] {
diff --git a/tests/ui/vec.rs b/tests/ui/vec.rs
index 03b8ee81665..e9ed83e5c5a 100644
--- a/tests/ui/vec.rs
+++ b/tests/ui/vec.rs
@@ -6,9 +6,14 @@
 struct NonCopy;
 
 fn on_slice(_: &[u8]) {}
+
+fn on_mut_slice(_: &mut [u8]) {}
+
 #[allow(clippy::ptr_arg)]
 fn on_vec(_: &Vec<u8>) {}
 
+fn on_mut_vec(_: &mut Vec<u8>) {}
+
 struct Line {
     length: usize,
 }
@@ -22,28 +27,38 @@ impl Line {
 fn main() {
     on_slice(&vec![]);
     on_slice(&[]);
+    on_mut_slice(&mut vec![]);
 
     on_slice(&vec![1, 2]);
     on_slice(&[1, 2]);
+    on_mut_slice(&mut vec![1, 2]);
 
     on_slice(&vec![1, 2]);
     on_slice(&[1, 2]);
+    on_mut_slice(&mut vec![1, 2]);
     #[rustfmt::skip]
     on_slice(&vec!(1, 2));
     on_slice(&[1, 2]);
+    on_mut_slice(&mut vec![1, 2]);
 
     on_slice(&vec![1; 2]);
     on_slice(&[1; 2]);
+    on_mut_slice(&mut vec![1; 2]);
 
     on_vec(&vec![]);
     on_vec(&vec![1, 2]);
     on_vec(&vec![1; 2]);
+    on_mut_vec(&mut vec![]);
+    on_mut_vec(&mut vec![1, 2]);
+    on_mut_vec(&mut vec![1; 2]);
 
     // Now with non-constant expressions
     let line = Line { length: 2 };
 
     on_slice(&vec![2; line.length]);
     on_slice(&vec![2; line.length()]);
+    on_mut_slice(&mut vec![2; line.length]);
+    on_mut_slice(&mut vec![2; line.length()]);
 
     for a in vec![1, 2, 3] {
         println!("{:?}", a);
@@ -54,6 +69,7 @@ fn main() {
     }
 
     on_vec(&vec![1; 201]); // Ok, size of `vec` higher than `too_large_for_stack`
+    on_mut_vec(&mut vec![1; 201]); // Ok, size of `vec` higher than `too_large_for_stack`
 
     // Ok
     for a in vec![1; 201] {
diff --git a/tests/ui/vec.stderr b/tests/ui/vec.stderr
index 37e28ebddb5..7d1de05a5c8 100644
--- a/tests/ui/vec.stderr
+++ b/tests/ui/vec.stderr
@@ -1,5 +1,5 @@
 error: useless use of `vec!`
-  --> $DIR/vec.rs:23:14
+  --> $DIR/vec.rs:28:14
    |
 LL |     on_slice(&vec![]);
    |              ^^^^^^^ help: you can use a slice directly: `&[]`
@@ -7,34 +7,64 @@ LL |     on_slice(&vec![]);
    = note: `-D clippy::useless-vec` implied by `-D warnings`
 
 error: useless use of `vec!`
-  --> $DIR/vec.rs:26:14
+  --> $DIR/vec.rs:30:18
+   |
+LL |     on_mut_slice(&mut vec![]);
+   |                  ^^^^^^^^^^^ help: you can use a slice directly: `&mut []`
+
+error: useless use of `vec!`
+  --> $DIR/vec.rs:32:14
    |
 LL |     on_slice(&vec![1, 2]);
    |              ^^^^^^^^^^^ help: you can use a slice directly: `&[1, 2]`
 
 error: useless use of `vec!`
-  --> $DIR/vec.rs:29:14
+  --> $DIR/vec.rs:34:18
+   |
+LL |     on_mut_slice(&mut vec![1, 2]);
+   |                  ^^^^^^^^^^^^^^^ help: you can use a slice directly: `&mut [1, 2]`
+
+error: useless use of `vec!`
+  --> $DIR/vec.rs:36:14
    |
 LL |     on_slice(&vec![1, 2]);
    |              ^^^^^^^^^^^ help: you can use a slice directly: `&[1, 2]`
 
 error: useless use of `vec!`
-  --> $DIR/vec.rs:32:14
+  --> $DIR/vec.rs:38:18
+   |
+LL |     on_mut_slice(&mut vec![1, 2]);
+   |                  ^^^^^^^^^^^^^^^ help: you can use a slice directly: `&mut [1, 2]`
+
+error: useless use of `vec!`
+  --> $DIR/vec.rs:40:14
    |
 LL |     on_slice(&vec!(1, 2));
    |              ^^^^^^^^^^^ help: you can use a slice directly: `&[1, 2]`
 
 error: useless use of `vec!`
-  --> $DIR/vec.rs:35:14
+  --> $DIR/vec.rs:42:18
+   |
+LL |     on_mut_slice(&mut vec![1, 2]);
+   |                  ^^^^^^^^^^^^^^^ help: you can use a slice directly: `&mut [1, 2]`
+
+error: useless use of `vec!`
+  --> $DIR/vec.rs:44:14
    |
 LL |     on_slice(&vec![1; 2]);
    |              ^^^^^^^^^^^ help: you can use a slice directly: `&[1; 2]`
 
 error: useless use of `vec!`
-  --> $DIR/vec.rs:48:14
+  --> $DIR/vec.rs:46:18
+   |
+LL |     on_mut_slice(&mut vec![1; 2]);
+   |                  ^^^^^^^^^^^^^^^ help: you can use a slice directly: `&mut [1; 2]`
+
+error: useless use of `vec!`
+  --> $DIR/vec.rs:63:14
    |
 LL |     for a in vec![1, 2, 3] {
    |              ^^^^^^^^^^^^^ help: you can use a slice directly: `&[1, 2, 3]`
 
-error: aborting due to 6 previous errors
+error: aborting due to 11 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 12fce557669a0de230399cf8e6eee4f5307bf87b Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Fri, 2 Apr 2021 17:35:32 -0400
Subject: Fix all occurences of `needless_borrow` internally

---
 clippy_dev/src/fmt.rs                              |    2 +-
 clippy_dev/src/lib.rs                              |   16 +-
 clippy_lints/src/absurd_extreme_comparisons.rs     |    4 +-
 clippy_lints/src/assertions_on_constants.rs        |   12 +-
 clippy_lints/src/atomic_ordering.rs                |    6 +-
 clippy_lints/src/attrs.rs                          |    4 +-
 clippy_lints/src/await_holding_invalid.rs          |    2 +-
 clippy_lints/src/bytecount.rs                      |   14 +-
 clippy_lints/src/casts/cast_ptr_alignment.rs       |    2 +-
 clippy_lints/src/casts/cast_sign_loss.rs           |    6 +-
 clippy_lints/src/casts/mod.rs                      |    2 +-
 clippy_lints/src/checked_conversions.rs            |   16 +-
 clippy_lints/src/cognitive_complexity.rs           |    2 +-
 clippy_lints/src/comparison_chain.rs               |    6 +-
 clippy_lints/src/copies.rs                         |    6 +-
 clippy_lints/src/create_dir.rs                     |    2 +-
 clippy_lints/src/default.rs                        |   10 +-
 clippy_lints/src/derive.rs                         |    4 +-
 clippy_lints/src/doc.rs                            |    4 +-
 clippy_lints/src/double_comparison.rs              |    4 +-
 clippy_lints/src/double_parens.rs                  |    6 +-
 clippy_lints/src/drop_forget_ref.rs                |    2 +-
 clippy_lints/src/duration_subsec.rs                |    4 +-
 clippy_lints/src/entry.rs                          |   16 +-
 clippy_lints/src/eq_op.rs                          |   14 +-
 clippy_lints/src/erasing_op.rs                     |    2 +-
 clippy_lints/src/eta_reduction.rs                  |   18 +-
 clippy_lints/src/eval_order_dependence.rs          |   18 +-
 clippy_lints/src/exit.rs                           |    2 +-
 clippy_lints/src/explicit_write.rs                 |   10 +-
 clippy_lints/src/fallible_impl_from.rs             |    4 +-
 clippy_lints/src/float_equality_without_abs.rs     |    6 +-
 clippy_lints/src/floating_point_arithmetic.rs      |   42 +-
 clippy_lints/src/format.rs                         |   38 +-
 clippy_lints/src/functions/must_use.rs             |   28 +-
 .../src/functions/not_unsafe_ptr_arg_deref.rs      |    6 +-
 clippy_lints/src/functions/result_unit_err.rs      |    8 +-
 clippy_lints/src/functions/too_many_arguments.rs   |    2 +-
 clippy_lints/src/get_last_with_len.rs              |    2 +-
 clippy_lints/src/identity_op.rs                    |    2 +-
 clippy_lints/src/if_let_mutex.rs                   |    6 +-
 clippy_lints/src/if_let_some_result.rs             |    6 +-
 clippy_lints/src/if_then_some_else_none.rs         |   12 +-
 clippy_lints/src/implicit_hasher.rs                |    6 +-
 clippy_lints/src/implicit_return.rs                |    4 +-
 clippy_lints/src/implicit_saturating_sub.rs        |   16 +-
 clippy_lints/src/indexing_slicing.rs               |    2 +-
 clippy_lints/src/infinite_iter.rs                  |   12 +-
 clippy_lints/src/invalid_upcast_comparisons.rs     |    6 +-
 clippy_lints/src/large_enum_variant.rs             |    2 +-
 clippy_lints/src/len_zero.rs                       |   15 +-
 clippy_lints/src/let_if_seq.rs                     |   24 +-
 clippy_lints/src/let_underscore.rs                 |    2 +-
 clippy_lints/src/lib.rs                            | 2446 ++++++++++----------
 clippy_lints/src/lifetimes.rs                      |   20 +-
 clippy_lints/src/literal_representation.rs         |    4 +-
 clippy_lints/src/loops/explicit_counter_loop.rs    |    2 +-
 clippy_lints/src/loops/for_kv_map.rs               |    4 +-
 clippy_lints/src/loops/manual_flatten.rs           |    4 +-
 clippy_lints/src/loops/manual_memcpy.rs            |   10 +-
 clippy_lints/src/loops/mod.rs                      |    6 +-
 clippy_lints/src/loops/needless_collect.rs         |   24 +-
 clippy_lints/src/loops/needless_range_loop.rs      |   18 +-
 clippy_lints/src/loops/never_loop.rs               |   46 +-
 clippy_lints/src/loops/same_item_push.rs           |    2 +-
 clippy_lints/src/loops/single_element_loop.rs      |    4 +-
 clippy_lints/src/loops/utils.rs                    |   16 +-
 clippy_lints/src/loops/while_let_loop.rs           |   12 +-
 clippy_lints/src/loops/while_let_on_iterator.rs    |   12 +-
 clippy_lints/src/manual_strip.rs                   |    4 +-
 clippy_lints/src/map_clone.rs                      |   10 +-
 clippy_lints/src/map_err_ignore.rs                 |    2 +-
 clippy_lints/src/map_identity.rs                   |   12 +-
 clippy_lints/src/map_unit_fn.rs                    |   12 +-
 clippy_lints/src/match_on_vec_items.rs             |    4 +-
 clippy_lints/src/matches.rs                        |   81 +-
 clippy_lints/src/mem_discriminant.rs               |    4 +-
 clippy_lints/src/mem_forget.rs                     |    2 +-
 clippy_lints/src/mem_replace.rs                    |   16 +-
 clippy_lints/src/methods/bind_instead_of_map.rs    |    4 +-
 clippy_lints/src/methods/chars_cmp.rs              |    2 +-
 clippy_lints/src/methods/expect_fun_call.rs        |    8 +-
 clippy_lints/src/methods/filter_map.rs             |    6 +-
 clippy_lints/src/methods/flat_map_identity.rs      |    2 +-
 clippy_lints/src/methods/implicit_clone.rs         |    2 +-
 clippy_lints/src/methods/iter_next_slice.rs        |    2 +-
 clippy_lints/src/methods/mod.rs                    |   22 +-
 clippy_lints/src/methods/option_as_ref_deref.rs    |    6 +-
 clippy_lints/src/methods/or_fun_call.rs            |    6 +-
 clippy_lints/src/methods/search_is_some.rs         |    6 +-
 clippy_lints/src/methods/uninit_assumed_init.rs    |    8 +-
 clippy_lints/src/methods/unnecessary_filter_map.rs |   14 +-
 clippy_lints/src/methods/unnecessary_fold.rs       |    6 +-
 clippy_lints/src/methods/utils.rs                  |    2 +-
 clippy_lints/src/methods/zst_offset.rs             |    2 +-
 clippy_lints/src/minmax.rs                         |    4 +-
 clippy_lints/src/misc.rs                           |   26 +-
 clippy_lints/src/missing_const_for_fn.rs           |    2 +-
 clippy_lints/src/missing_inline.rs                 |    2 +-
 clippy_lints/src/mut_key.rs                        |    6 +-
 clippy_lints/src/mut_mut.rs                        |    4 +-
 clippy_lints/src/mut_reference.rs                  |    4 +-
 clippy_lints/src/needless_bool.rs                  |   18 +-
 clippy_lints/src/needless_borrow.rs                |    2 +-
 clippy_lints/src/needless_borrowed_ref.rs          |    2 +-
 clippy_lints/src/needless_for_each.rs              |    2 +-
 clippy_lints/src/needless_pass_by_value.rs         |    2 +-
 clippy_lints/src/needless_update.rs                |    2 +-
 clippy_lints/src/neg_cmp_op_on_partial_ord.rs      |    4 +-
 clippy_lints/src/neg_multiply.rs                   |    6 +-
 clippy_lints/src/no_effect.rs                      |   58 +-
 clippy_lints/src/non_octal_unix_permissions.rs     |    4 +-
 clippy_lints/src/open_options.rs                   |    4 +-
 clippy_lints/src/option_if_let_else.rs             |    8 +-
 clippy_lints/src/overflow_check_conditional.rs     |   20 +-
 clippy_lints/src/pass_by_ref_or_value.rs           |    4 +-
 clippy_lints/src/path_buf_push_overwrite.rs        |    2 +-
 clippy_lints/src/pattern_type_mismatch.rs          |   18 +-
 clippy_lints/src/ptr.rs                            |   22 +-
 clippy_lints/src/ptr_eq.rs                         |    8 +-
 clippy_lints/src/ptr_offset_with_cast.rs           |    6 +-
 clippy_lints/src/question_mark.rs                  |    8 +-
 clippy_lints/src/ranges.rs                         |   24 +-
 clippy_lints/src/redundant_clone.rs                |   10 +-
 clippy_lints/src/redundant_closure_call.rs         |   16 +-
 clippy_lints/src/ref_option_ref.rs                 |    2 +-
 clippy_lints/src/regex.rs                          |    4 +-
 clippy_lints/src/repeat_once.rs                    |    4 +-
 clippy_lints/src/returns.rs                        |   16 +-
 clippy_lints/src/semicolon_if_nothing_returned.rs  |    2 +-
 clippy_lints/src/shadow.rs                         |   69 +-
 clippy_lints/src/slow_vector_initialization.rs     |   42 +-
 clippy_lints/src/strings.rs                        |   14 +-
 clippy_lints/src/suspicious_operation_groupings.rs |   16 +-
 clippy_lints/src/swap.rs                           |   30 +-
 clippy_lints/src/tabs_in_doc_comments.rs           |    2 +-
 clippy_lints/src/to_string_in_display.rs           |    2 +-
 clippy_lints/src/trait_bounds.rs                   |    4 +-
 clippy_lints/src/transmute/mod.rs                  |    2 +-
 .../src/transmute/transmute_float_to_int.rs        |    2 +-
 clippy_lints/src/transmute/utils.rs                |    2 +-
 clippy_lints/src/transmuting_null.rs               |    6 +-
 clippy_lints/src/try_err.rs                        |   14 +-
 clippy_lints/src/types/borrowed_box.rs             |    8 +-
 clippy_lints/src/types/mod.rs                      |   28 +-
 clippy_lints/src/types/type_complexity.rs          |    4 +-
 clippy_lints/src/types/utils.rs                    |    2 +-
 clippy_lints/src/types/vec_box.rs                  |    4 +-
 clippy_lints/src/undropped_manually_drops.rs       |    2 +-
 clippy_lints/src/unit_return_expecting_ord.rs      |    2 +-
 clippy_lints/src/unit_types/let_unit_value.rs      |    4 +-
 clippy_lints/src/unit_types/unit_arg.rs            |    2 +-
 clippy_lints/src/unit_types/unit_cmp.rs            |    4 +-
 clippy_lints/src/unit_types/utils.rs               |    2 +-
 clippy_lints/src/unnamed_address.rs                |    6 +-
 clippy_lints/src/unnecessary_sort_by.rs            |   16 +-
 clippy_lints/src/unnecessary_wraps.rs              |    2 +-
 clippy_lints/src/unused_io_amount.rs               |   10 +-
 clippy_lints/src/unused_unit.rs                    |    2 +-
 clippy_lints/src/unwrap.rs                         |    4 +-
 clippy_lints/src/use_self.rs                       |    6 +-
 clippy_lints/src/useless_conversion.rs             |   12 +-
 clippy_lints/src/utils/author.rs                   |   96 +-
 clippy_lints/src/utils/inspector.rs                |   90 +-
 clippy_lints/src/utils/internal_lints.rs           |   18 +-
 clippy_lints/src/vec.rs                            |    2 +-
 clippy_lints/src/vec_resize_to_zero.rs             |    2 +-
 clippy_lints/src/zero_div_zero.rs                  |    2 +-
 clippy_lints/src/zero_sized_map_values.rs          |    2 +-
 src/driver.rs                                      |   12 +-
 tests/compile-test.rs                              |   16 +-
 tests/ui/borrow_interior_mutable_const/others.rs   |    6 +-
 .../ui/borrow_interior_mutable_const/others.stderr |   28 +-
 tests/ui/collapsible_match2.rs                     |    7 +-
 tests/ui/collapsible_match2.stderr                 |   20 +-
 tests/ui/escape_analysis.rs                        |    4 +-
 tests/ui/implicit_clone.rs                         |    2 +-
 tests/ui/into_iter_on_ref.fixed                    |    2 +-
 tests/ui/into_iter_on_ref.rs                       |    2 +-
 tests/ui/ref_option_ref.rs                         |    2 +-
 tests/ui/ref_option_ref.stderr                     |    2 +-
 tests/ui/stable_sort_primitive.fixed               |    2 +-
 tests/ui/stable_sort_primitive.rs                  |    2 +-
 183 files changed, 2150 insertions(+), 2162 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_dev/src/fmt.rs b/clippy_dev/src/fmt.rs
index 111c79c332d..1517cdc9419 100644
--- a/clippy_dev/src/fmt.rs
+++ b/clippy_dev/src/fmt.rs
@@ -68,7 +68,7 @@ pub fn run(check: bool, verbose: bool) {
                 continue;
             }
 
-            success &= rustfmt(context, &path)?;
+            success &= rustfmt(context, path)?;
         }
 
         Ok(success)
diff --git a/clippy_dev/src/lib.rs b/clippy_dev/src/lib.rs
index a5e94683878..1e5a140e964 100644
--- a/clippy_dev/src/lib.rs
+++ b/clippy_dev/src/lib.rs
@@ -101,7 +101,7 @@ impl Lint {
 #[must_use]
 pub fn gen_lint_group_list<'a>(lints: impl Iterator<Item = &'a Lint>) -> Vec<String> {
     lints
-        .map(|l| format!("        LintId::of(&{}::{}),", l.module, l.name.to_uppercase()))
+        .map(|l| format!("        LintId::of({}::{}),", l.module, l.name.to_uppercase()))
         .sorted()
         .collect::<Vec<String>>()
 }
@@ -154,17 +154,17 @@ pub fn gen_register_lint_list<'a>(
     let header = "    store.register_lints(&[".to_string();
     let footer = "    ]);".to_string();
     let internal_lints = internal_lints
-        .sorted_by_key(|l| format!("        &{}::{},", l.module, l.name.to_uppercase()))
+        .sorted_by_key(|l| format!("        {}::{},", l.module, l.name.to_uppercase()))
         .map(|l| {
             format!(
-                "        #[cfg(feature = \"internal-lints\")]\n        &{}::{},",
+                "        #[cfg(feature = \"internal-lints\")]\n        {}::{},",
                 l.module,
                 l.name.to_uppercase()
             )
         });
     let other_lints = usable_lints
-        .sorted_by_key(|l| format!("        &{}::{},", l.module, l.name.to_uppercase()))
-        .map(|l| format!("        &{}::{},", l.module, l.name.to_uppercase()))
+        .sorted_by_key(|l| format!("        {}::{},", l.module, l.name.to_uppercase()))
+        .map(|l| format!("        {}::{},", l.module, l.name.to_uppercase()))
         .sorted();
     let mut lint_list = vec![header];
     lint_list.extend(internal_lints);
@@ -550,9 +550,9 @@ fn test_gen_lint_group_list() {
         Lint::new("internal", "internal_style", "abc", None, "module_name"),
     ];
     let expected = vec![
-        "        LintId::of(&module_name::ABC),".to_string(),
-        "        LintId::of(&module_name::INTERNAL),".to_string(),
-        "        LintId::of(&module_name::SHOULD_ASSERT_EQ),".to_string(),
+        "        LintId::of(module_name::ABC),".to_string(),
+        "        LintId::of(module_name::INTERNAL),".to_string(),
+        "        LintId::of(module_name::SHOULD_ASSERT_EQ),".to_string(),
     ];
     assert_eq!(expected, gen_lint_group_list(lints.iter()));
 }
diff --git a/clippy_lints/src/absurd_extreme_comparisons.rs b/clippy_lints/src/absurd_extreme_comparisons.rs
index 33c720c666e..5fbf4bdbd18 100644
--- a/clippy_lints/src/absurd_extreme_comparisons.rs
+++ b/clippy_lints/src/absurd_extreme_comparisons.rs
@@ -44,7 +44,7 @@ declare_lint_pass!(AbsurdExtremeComparisons => [ABSURD_EXTREME_COMPARISONS]);
 
 impl<'tcx> LateLintPass<'tcx> for AbsurdExtremeComparisons {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if let ExprKind::Binary(ref cmp, ref lhs, ref rhs) = expr.kind {
+        if let ExprKind::Binary(ref cmp, lhs, rhs) = expr.kind {
             if let Some((culprit, result)) = detect_absurd_comparison(cx, cmp.node, lhs, rhs) {
                 if !expr.span.from_expansion() {
                     let msg = "this comparison involving the minimum or maximum element for this \
@@ -95,7 +95,7 @@ enum AbsurdComparisonResult {
 }
 
 fn is_cast_between_fixed_and_target<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
-    if let ExprKind::Cast(ref cast_exp, _) = expr.kind {
+    if let ExprKind::Cast(cast_exp, _) = expr.kind {
         let precast_ty = cx.typeck_results().expr_ty(cast_exp);
         let cast_ty = cx.typeck_results().expr_ty(expr);
 
diff --git a/clippy_lints/src/assertions_on_constants.rs b/clippy_lints/src/assertions_on_constants.rs
index 16905781c56..a0993bb6913 100644
--- a/clippy_lints/src/assertions_on_constants.rs
+++ b/clippy_lints/src/assertions_on_constants.rs
@@ -71,7 +71,7 @@ impl<'tcx> LateLintPass<'tcx> for AssertionsOnConstants {
                 return;
             }
             if_chain! {
-                if let ExprKind::Unary(_, ref lit) = e.kind;
+                if let ExprKind::Unary(_, lit) = e.kind;
                 if let Some((Constant::Bool(is_true), _)) = constant(cx, cx.typeck_results(), lit);
                 if is_true;
                 then {
@@ -82,7 +82,7 @@ impl<'tcx> LateLintPass<'tcx> for AssertionsOnConstants {
             if assert_span.from_expansion() {
                 return;
             }
-            if let Some(assert_match) = match_assert_with_message(&cx, e) {
+            if let Some(assert_match) = match_assert_with_message(cx, e) {
                 match assert_match {
                     // matched assert but not message
                     AssertKind::WithoutMessage(false) => lint_false_without_message(),
@@ -113,17 +113,17 @@ enum AssertKind {
 /// where `message` is any expression and `c` is a constant bool.
 fn match_assert_with_message<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<AssertKind> {
     if_chain! {
-        if let ExprKind::If(ref cond, ref then, _) = expr.kind;
-        if let ExprKind::Unary(UnOp::Not, ref expr) = cond.kind;
+        if let ExprKind::If(cond, then, _) = expr.kind;
+        if let ExprKind::Unary(UnOp::Not, expr) = cond.kind;
         // bind the first argument of the `assert!` macro
         if let Some((Constant::Bool(is_true), _)) = constant(cx, cx.typeck_results(), expr);
         // block
-        if let ExprKind::Block(ref block, _) = then.kind;
+        if let ExprKind::Block(block, _) = then.kind;
         if block.stmts.is_empty();
         if let Some(block_expr) = &block.expr;
         // inner block is optional. unwrap it if it exists, or use the expression as is otherwise.
         if let Some(begin_panic_call) = match block_expr.kind {
-            ExprKind::Block(ref inner_block, _) => &inner_block.expr,
+            ExprKind::Block(inner_block, _) => &inner_block.expr,
             _ => &block.expr,
         };
         // function call
diff --git a/clippy_lints/src/atomic_ordering.rs b/clippy_lints/src/atomic_ordering.rs
index dfb18199325..7ceb01f5590 100644
--- a/clippy_lints/src/atomic_ordering.rs
+++ b/clippy_lints/src/atomic_ordering.rs
@@ -85,7 +85,7 @@ fn match_ordering_def_path(cx: &LateContext<'_>, did: DefId, orderings: &[&str])
 
 fn check_atomic_load_store(cx: &LateContext<'_>, expr: &Expr<'_>) {
     if_chain! {
-        if let ExprKind::MethodCall(ref method_path, _, args, _) = &expr.kind;
+        if let ExprKind::MethodCall(method_path, _, args, _) = &expr.kind;
         let method = method_path.ident.name.as_str();
         if type_is_atomic(cx, &args[0]);
         if method == "load" || method == "store";
@@ -120,7 +120,7 @@ fn check_atomic_load_store(cx: &LateContext<'_>, expr: &Expr<'_>) {
 
 fn check_memory_fence(cx: &LateContext<'_>, expr: &Expr<'_>) {
     if_chain! {
-        if let ExprKind::Call(ref func, ref args) = expr.kind;
+        if let ExprKind::Call(func, args) = expr.kind;
         if let ExprKind::Path(ref func_qpath) = func.kind;
         if let Some(def_id) = cx.qpath_res(func_qpath, func.hir_id).opt_def_id();
         if ["fence", "compiler_fence"]
@@ -152,7 +152,7 @@ fn opt_ordering_defid(cx: &LateContext<'_>, ord_arg: &Expr<'_>) -> Option<DefId>
 
 fn check_atomic_compare_exchange(cx: &LateContext<'_>, expr: &Expr<'_>) {
     if_chain! {
-        if let ExprKind::MethodCall(ref method_path, _, args, _) = &expr.kind;
+        if let ExprKind::MethodCall(method_path, _, args, _) = &expr.kind;
         let method = method_path.ident.name.as_str();
         if type_is_atomic(cx, &args[0]);
         if method == "compare_exchange" || method == "compare_exchange_weak" || method == "fetch_update";
diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs
index 0ce46e1c214..382fb03d920 100644
--- a/clippy_lints/src/attrs.rs
+++ b/clippy_lints/src/attrs.rs
@@ -602,7 +602,7 @@ fn check_mismatched_target_os(cx: &EarlyContext<'_>, attr: &Attribute) {
             if let NestedMetaItem::MetaItem(meta) = item {
                 match &meta.kind {
                     MetaItemKind::List(list) => {
-                        mismatched.extend(find_mismatched_target_os(&list));
+                        mismatched.extend(find_mismatched_target_os(list));
                     },
                     MetaItemKind::Word => {
                         if_chain! {
@@ -629,7 +629,7 @@ fn check_mismatched_target_os(cx: &EarlyContext<'_>, attr: &Attribute) {
         then {
             let mess = "operating system used in target family position";
 
-            span_lint_and_then(cx, MISMATCHED_TARGET_OS, attr.span, &mess, |diag| {
+            span_lint_and_then(cx, MISMATCHED_TARGET_OS, attr.span, mess, |diag| {
                 // Avoid showing the unix suggestion multiple times in case
                 // we have more than one mismatch for unix-like systems
                 let mut unix_suggested = false;
diff --git a/clippy_lints/src/await_holding_invalid.rs b/clippy_lints/src/await_holding_invalid.rs
index 68eee0520b3..1739a57a240 100644
--- a/clippy_lints/src/await_holding_invalid.rs
+++ b/clippy_lints/src/await_holding_invalid.rs
@@ -101,7 +101,7 @@ impl LateLintPass<'_> for AwaitHolding {
             let typeck_results = cx.tcx.typeck_body(body_id);
             check_interior_types(
                 cx,
-                &typeck_results.generator_interior_types.as_ref().skip_binder(),
+                typeck_results.generator_interior_types.as_ref().skip_binder(),
                 body.value.span,
             );
         }
diff --git a/clippy_lints/src/bytecount.rs b/clippy_lints/src/bytecount.rs
index 1546d823167..877ae002d36 100644
--- a/clippy_lints/src/bytecount.rs
+++ b/clippy_lints/src/bytecount.rs
@@ -38,17 +38,17 @@ declare_lint_pass!(ByteCount => [NAIVE_BYTECOUNT]);
 impl<'tcx> LateLintPass<'tcx> for ByteCount {
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
         if_chain! {
-            if let ExprKind::MethodCall(ref count, _, ref count_args, _) = expr.kind;
+            if let ExprKind::MethodCall(count, _, count_args, _) = expr.kind;
             if count.ident.name == sym!(count);
             if count_args.len() == 1;
-            if let ExprKind::MethodCall(ref filter, _, ref filter_args, _) = count_args[0].kind;
+            if let ExprKind::MethodCall(filter, _, filter_args, _) = count_args[0].kind;
             if filter.ident.name == sym!(filter);
             if filter_args.len() == 2;
             if let ExprKind::Closure(_, _, body_id, _, _) = filter_args[1].kind;
             let body = cx.tcx.hir().body(body_id);
             if body.params.len() == 1;
-            if let Some(argname) = get_pat_name(&body.params[0].pat);
-            if let ExprKind::Binary(ref op, ref l, ref r) = body.value.kind;
+            if let Some(argname) = get_pat_name(body.params[0].pat);
+            if let ExprKind::Binary(ref op, l, r) = body.value.kind;
             if op.node == BinOpKind::Eq;
             if match_type(cx,
                        cx.typeck_results().expr_ty(&filter_args[0]).peel_refs(),
@@ -64,7 +64,7 @@ impl<'tcx> LateLintPass<'tcx> for ByteCount {
                 if ty::Uint(UintTy::U8) != *cx.typeck_results().expr_ty(needle).peel_refs().kind() {
                     return;
                 }
-                let haystack = if let ExprKind::MethodCall(ref path, _, ref args, _) =
+                let haystack = if let ExprKind::MethodCall(path, _, args, _) =
                         filter_args[0].kind {
                     let p = path.ident.name;
                     if (p == sym::iter || p == sym!(iter_mut)) && args.len() == 1 {
@@ -98,10 +98,10 @@ fn check_arg(name: Symbol, arg: Symbol, needle: &Expr<'_>) -> bool {
 
 fn get_path_name(expr: &Expr<'_>) -> Option<Symbol> {
     match expr.kind {
-        ExprKind::Box(ref e) | ExprKind::AddrOf(BorrowKind::Ref, _, ref e) | ExprKind::Unary(UnOp::Deref, ref e) => {
+        ExprKind::Box(e) | ExprKind::AddrOf(BorrowKind::Ref, _, e) | ExprKind::Unary(UnOp::Deref, e) => {
             get_path_name(e)
         },
-        ExprKind::Block(ref b, _) => {
+        ExprKind::Block(b, _) => {
             if b.stmts.is_empty() {
                 b.expr.as_ref().and_then(|p| get_path_name(p))
             } else {
diff --git a/clippy_lints/src/casts/cast_ptr_alignment.rs b/clippy_lints/src/casts/cast_ptr_alignment.rs
index 5208156ffd2..62a119d662b 100644
--- a/clippy_lints/src/casts/cast_ptr_alignment.rs
+++ b/clippy_lints/src/casts/cast_ptr_alignment.rs
@@ -10,7 +10,7 @@ use rustc_target::abi::LayoutOf;
 use super::CAST_PTR_ALIGNMENT;
 
 pub(super) fn check(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-    if let ExprKind::Cast(ref cast_expr, cast_to) = expr.kind {
+    if let ExprKind::Cast(cast_expr, cast_to) = expr.kind {
         if is_hir_ty_cfg_dependant(cx, cast_to) {
             return;
         }
diff --git a/clippy_lints/src/casts/cast_sign_loss.rs b/clippy_lints/src/casts/cast_sign_loss.rs
index bf722d0a3f4..040e0ca8864 100644
--- a/clippy_lints/src/casts/cast_sign_loss.rs
+++ b/clippy_lints/src/casts/cast_sign_loss.rs
@@ -30,7 +30,7 @@ fn should_lint(cx: &LateContext<'_>, cast_op: &Expr<'_>, cast_from: Ty<'_>, cast
             }
 
             // Don't lint for positive constants.
-            let const_val = constant(cx, &cx.typeck_results(), cast_op);
+            let const_val = constant(cx, cx.typeck_results(), cast_op);
             if_chain! {
                 if let Some((Constant::Int(n), _)) = const_val;
                 if let ty::Int(ity) = *cast_from.kind();
@@ -41,14 +41,14 @@ fn should_lint(cx: &LateContext<'_>, cast_op: &Expr<'_>, cast_from: Ty<'_>, cast
             }
 
             // Don't lint for the result of methods that always return non-negative values.
-            if let ExprKind::MethodCall(ref path, _, _, _) = cast_op.kind {
+            if let ExprKind::MethodCall(path, _, _, _) = cast_op.kind {
                 let mut method_name = path.ident.name.as_str();
                 let allowed_methods = ["abs", "checked_abs", "rem_euclid", "checked_rem_euclid"];
 
                 if_chain! {
                     if method_name == "unwrap";
                     if let Some(arglist) = method_chain_args(cast_op, &["unwrap"]);
-                    if let ExprKind::MethodCall(ref inner_path, _, _, _) = &arglist[0][0].kind;
+                    if let ExprKind::MethodCall(inner_path, _, _, _) = &arglist[0][0].kind;
                     then {
                         method_name = inner_path.ident.name.as_str();
                     }
diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index d9e172c01a7..ae4fdd12c41 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -372,7 +372,7 @@ impl<'tcx> LateLintPass<'tcx> for Casts {
             return;
         }
 
-        if let ExprKind::Cast(ref cast_expr, cast_to) = expr.kind {
+        if let ExprKind::Cast(cast_expr, cast_to) = expr.kind {
             if is_hir_ty_cfg_dependant(cx, cast_to) {
                 return;
             }
diff --git a/clippy_lints/src/checked_conversions.rs b/clippy_lints/src/checked_conversions.rs
index b38c70bcc41..d7136f84cc3 100644
--- a/clippy_lints/src/checked_conversions.rs
+++ b/clippy_lints/src/checked_conversions.rs
@@ -64,7 +64,7 @@ impl<'tcx> LateLintPass<'tcx> for CheckedConversions {
 
         let result = if_chain! {
             if !in_external_macro(cx.sess(), item.span);
-            if let ExprKind::Binary(op, ref left, ref right) = &item.kind;
+            if let ExprKind::Binary(op, left, right) = &item.kind;
 
             then {
                 match op.node {
@@ -200,7 +200,7 @@ impl ConversionType {
 /// Check for `expr <= (to_type::MAX as from_type)`
 fn check_upper_bound<'tcx>(expr: &'tcx Expr<'tcx>) -> Option<Conversion<'tcx>> {
     if_chain! {
-         if let ExprKind::Binary(ref op, ref left, ref right) = &expr.kind;
+         if let ExprKind::Binary(ref op, left, right) = &expr.kind;
          if let Some((candidate, check)) = normalize_le_ge(op, left, right);
          if let Some((from, to)) = get_types_from_cast(check, INTS, "max_value", "MAX");
 
@@ -219,7 +219,7 @@ fn check_lower_bound<'tcx>(expr: &'tcx Expr<'tcx>) -> Option<Conversion<'tcx>> {
     }
 
     // First of we need a binary containing the expression & the cast
-    if let ExprKind::Binary(ref op, ref left, ref right) = &expr.kind {
+    if let ExprKind::Binary(ref op, left, right) = &expr.kind {
         normalize_le_ge(op, right, left).and_then(|(l, r)| check_function(l, r))
     } else {
         None
@@ -260,7 +260,7 @@ fn get_types_from_cast<'a>(
     // or `to_type::MAX as from_type`
     let call_from_cast: Option<(&Expr<'_>, &str)> = if_chain! {
         // to_type::max_value(), from_type
-        if let ExprKind::Cast(ref limit, ref from_type) = &expr.kind;
+        if let ExprKind::Cast(limit, from_type) = &expr.kind;
         if let TyKind::Path(ref from_type_path) = &from_type.kind;
         if let Some(from_sym) = int_ty_to_sym(from_type_path);
 
@@ -275,7 +275,7 @@ fn get_types_from_cast<'a>(
     let limit_from: Option<(&Expr<'_>, &str)> = call_from_cast.or_else(|| {
         if_chain! {
             // `from_type::from, to_type::max_value()`
-            if let ExprKind::Call(ref from_func, ref args) = &expr.kind;
+            if let ExprKind::Call(from_func, args) = &expr.kind;
             // `to_type::max_value()`
             if args.len() == 1;
             if let limit = &args[0];
@@ -317,9 +317,9 @@ fn get_types_from_cast<'a>(
 /// Gets the type which implements the called function
 fn get_implementing_type<'a>(path: &QPath<'_>, candidates: &'a [&str], function: &str) -> Option<&'a str> {
     if_chain! {
-        if let QPath::TypeRelative(ref ty, ref path) = &path;
+        if let QPath::TypeRelative(ty, path) = &path;
         if path.ident.name.as_str() == function;
-        if let TyKind::Path(QPath::Resolved(None, ref tp)) = &ty.kind;
+        if let TyKind::Path(QPath::Resolved(None, tp)) = &ty.kind;
         if let [int] = &*tp.segments;
         then {
             let name = &int.ident.name.as_str();
@@ -333,7 +333,7 @@ fn get_implementing_type<'a>(path: &QPath<'_>, candidates: &'a [&str], function:
 /// Gets the type as a string, if it is a supported integer
 fn int_ty_to_sym<'tcx>(path: &QPath<'_>) -> Option<&'tcx str> {
     if_chain! {
-        if let QPath::Resolved(_, ref path) = *path;
+        if let QPath::Resolved(_, path) = *path;
         if let [ty] = &*path.segments;
         then {
             let name = &ty.ident.name.as_str();
diff --git a/clippy_lints/src/cognitive_complexity.rs b/clippy_lints/src/cognitive_complexity.rs
index 4cc542f723c..f62c6a9c325 100644
--- a/clippy_lints/src/cognitive_complexity.rs
+++ b/clippy_lints/src/cognitive_complexity.rs
@@ -152,7 +152,7 @@ impl<'tcx> Visitor<'tcx> for CcHelper {
             ExprKind::If(_, _, _) => {
                 self.cc += 1;
             },
-            ExprKind::Match(_, ref arms, _) => {
+            ExprKind::Match(_, arms, _) => {
                 if arms.len() > 1 {
                     self.cc += 1;
                 }
diff --git a/clippy_lints/src/comparison_chain.rs b/clippy_lints/src/comparison_chain.rs
index d601cb7c224..31ae63b5184 100644
--- a/clippy_lints/src/comparison_chain.rs
+++ b/clippy_lints/src/comparison_chain.rs
@@ -71,10 +71,8 @@ impl<'tcx> LateLintPass<'tcx> for ComparisonChain {
         }
 
         for cond in conds.windows(2) {
-            if let (
-                &ExprKind::Binary(ref kind1, ref lhs1, ref rhs1),
-                &ExprKind::Binary(ref kind2, ref lhs2, ref rhs2),
-            ) = (&cond[0].kind, &cond[1].kind)
+            if let (&ExprKind::Binary(ref kind1, lhs1, rhs1), &ExprKind::Binary(ref kind2, lhs2, rhs2)) =
+                (&cond[0].kind, &cond[1].kind)
             {
                 if !kind_is_cmp(kind1.node) || !kind_is_cmp(kind2.node) {
                     return;
diff --git a/clippy_lints/src/copies.rs b/clippy_lints/src/copies.rs
index 1b982221b06..8b503c9a030 100644
--- a/clippy_lints/src/copies.rs
+++ b/clippy_lints/src/copies.rs
@@ -160,7 +160,7 @@ impl<'tcx> LateLintPass<'tcx> for CopyAndPaste {
             if let ExprKind::If(_, _, _) = expr.kind {
                 // skip ifs directly in else, it will be checked in the parent if
                 if let Some(&Expr {
-                    kind: ExprKind::If(_, _, Some(ref else_expr)),
+                    kind: ExprKind::If(_, _, Some(else_expr)),
                     ..
                 }) = get_parent_expr(cx, expr)
                 {
@@ -247,7 +247,7 @@ fn lint_same_then_else<'tcx>(
 
             for value in &end_walker.uses {
                 // Well we can't move this and all prev statements. So reset
-                if block_defs.contains(&value) {
+                if block_defs.contains(value) {
                     moved_start = Some(index + 1);
                     end_walker.defs.drain().for_each(|x| {
                         block_defs.insert(x);
@@ -555,7 +555,7 @@ impl<'a, 'tcx> Visitor<'tcx> for UsedValueFinderVisitor<'a, 'tcx> {
     }
 
     fn visit_qpath(&mut self, qpath: &'tcx rustc_hir::QPath<'tcx>, id: HirId, _span: rustc_span::Span) {
-        if let rustc_hir::QPath::Resolved(_, ref path) = *qpath {
+        if let rustc_hir::QPath::Resolved(_, path) = *qpath {
             if path.segments.len() == 1 {
                 if let rustc_hir::def::Res::Local(var) = self.cx.qpath_res(qpath, id) {
                     self.uses.insert(var);
diff --git a/clippy_lints/src/create_dir.rs b/clippy_lints/src/create_dir.rs
index ac890c90c97..7b5cce6462a 100644
--- a/clippy_lints/src/create_dir.rs
+++ b/clippy_lints/src/create_dir.rs
@@ -33,7 +33,7 @@ declare_lint_pass!(CreateDir => [CREATE_DIR]);
 impl LateLintPass<'_> for CreateDir {
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
         if_chain! {
-            if let ExprKind::Call(ref func, ref args) = expr.kind;
+            if let ExprKind::Call(func, args) = expr.kind;
             if let ExprKind::Path(ref path) = func.kind;
             if let Some(def_id) = cx.qpath_res(path, func.hir_id).opt_def_id();
             if match_def_path(cx, def_id, &paths::STD_FS_CREATE_DIR);
diff --git a/clippy_lints/src/default.rs b/clippy_lints/src/default.rs
index 8a2146d93e8..710da8fe9e0 100644
--- a/clippy_lints/src/default.rs
+++ b/clippy_lints/src/default.rs
@@ -77,7 +77,7 @@ impl LateLintPass<'_> for Default {
         if_chain! {
             // Avoid cases already linted by `field_reassign_with_default`
             if !self.reassigned_linted.contains(&expr.span);
-            if let ExprKind::Call(ref path, ..) = expr.kind;
+            if let ExprKind::Call(path, ..) = expr.kind;
             if !any_parent_is_automatically_derived(cx.tcx, expr.hir_id);
             if let ExprKind::Path(ref qpath) = path.kind;
             if let Some(def_id) = cx.qpath_res(qpath, path.hir_id).opt_def_id();
@@ -246,7 +246,7 @@ impl LateLintPass<'_> for Default {
 /// Checks if the given expression is the `default` method belonging to the `Default` trait.
 fn is_expr_default<'tcx>(expr: &'tcx Expr<'tcx>, cx: &LateContext<'tcx>) -> bool {
     if_chain! {
-        if let ExprKind::Call(ref fn_expr, _) = &expr.kind;
+        if let ExprKind::Call(fn_expr, _) = &expr.kind;
         if let ExprKind::Path(qpath) = &fn_expr.kind;
         if let Res::Def(_, def_id) = cx.qpath_res(qpath, fn_expr.hir_id);
         then {
@@ -262,11 +262,11 @@ fn is_expr_default<'tcx>(expr: &'tcx Expr<'tcx>, cx: &LateContext<'tcx>) -> bool
 fn field_reassigned_by_stmt<'tcx>(this: &Stmt<'tcx>, binding_name: Symbol) -> Option<(Ident, &'tcx Expr<'tcx>)> {
     if_chain! {
         // only take assignments
-        if let StmtKind::Semi(ref later_expr) = this.kind;
-        if let ExprKind::Assign(ref assign_lhs, ref assign_rhs, _) = later_expr.kind;
+        if let StmtKind::Semi(later_expr) = this.kind;
+        if let ExprKind::Assign(assign_lhs, assign_rhs, _) = later_expr.kind;
         // only take assignments to fields where the left-hand side field is a field of
         // the same binding as the previous statement
-        if let ExprKind::Field(ref binding, field_ident) = assign_lhs.kind;
+        if let ExprKind::Field(binding, field_ident) = assign_lhs.kind;
         if let ExprKind::Path(QPath::Resolved(_, path)) = binding.kind;
         if let Some(second_binding_name) = path.segments.last();
         if second_binding_name.ident.name == binding_name;
diff --git a/clippy_lints/src/derive.rs b/clippy_lints/src/derive.rs
index 9fad85f8ef4..647af3bdc04 100644
--- a/clippy_lints/src/derive.rs
+++ b/clippy_lints/src/derive.rs
@@ -199,7 +199,7 @@ fn check_hash_peq<'tcx>(
         then {
             // Look for the PartialEq implementations for `ty`
             cx.tcx.for_each_relevant_impl(peq_trait_def_id, ty, |impl_id| {
-                let peq_is_automatically_derived = is_automatically_derived(&cx.tcx.get_attrs(impl_id));
+                let peq_is_automatically_derived = is_automatically_derived(cx.tcx.get_attrs(impl_id));
 
                 if peq_is_automatically_derived == hash_is_automatically_derived {
                     return;
@@ -253,7 +253,7 @@ fn check_ord_partial_ord<'tcx>(
         then {
             // Look for the PartialOrd implementations for `ty`
             cx.tcx.for_each_relevant_impl(partial_ord_trait_def_id, ty, |impl_id| {
-                let partial_ord_is_automatically_derived = is_automatically_derived(&cx.tcx.get_attrs(impl_id));
+                let partial_ord_is_automatically_derived = is_automatically_derived(cx.tcx.get_attrs(impl_id));
 
                 if partial_ord_is_automatically_derived == ord_is_automatically_derived {
                     return;
diff --git a/clippy_lints/src/doc.rs b/clippy_lints/src/doc.rs
index b5796ccf43f..fb53b55ebd6 100644
--- a/clippy_lints/src/doc.rs
+++ b/clippy_lints/src/doc.rs
@@ -710,8 +710,8 @@ impl<'a, 'tcx> Visitor<'tcx> for FindPanicUnwrap<'a, 'tcx> {
 
         // check for `begin_panic`
         if_chain! {
-            if let ExprKind::Call(ref func_expr, _) = expr.kind;
-            if let ExprKind::Path(QPath::Resolved(_, ref path)) = func_expr.kind;
+            if let ExprKind::Call(func_expr, _) = expr.kind;
+            if let ExprKind::Path(QPath::Resolved(_, path)) = func_expr.kind;
             if let Some(path_def_id) = path.res.opt_def_id();
             if match_panic_def_id(self.cx, path_def_id);
             if is_expn_of(expr.span, "unreachable").is_none();
diff --git a/clippy_lints/src/double_comparison.rs b/clippy_lints/src/double_comparison.rs
index 1d291565ec1..58543ae6e4e 100644
--- a/clippy_lints/src/double_comparison.rs
+++ b/clippy_lints/src/double_comparison.rs
@@ -47,7 +47,7 @@ impl<'tcx> DoubleComparisons {
             },
             _ => return,
         };
-        if !(eq_expr_value(cx, &llhs, &rlhs) && eq_expr_value(cx, &lrhs, &rrhs)) {
+        if !(eq_expr_value(cx, llhs, rlhs) && eq_expr_value(cx, lrhs, rrhs)) {
             return;
         }
         macro_rules! lint_double_comparison {
@@ -88,7 +88,7 @@ impl<'tcx> DoubleComparisons {
 
 impl<'tcx> LateLintPass<'tcx> for DoubleComparisons {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if let ExprKind::Binary(ref kind, ref lhs, ref rhs) = expr.kind {
+        if let ExprKind::Binary(ref kind, lhs, rhs) = expr.kind {
             Self::check_binop(cx, kind.node, lhs, rhs, expr.span);
         }
     }
diff --git a/clippy_lints/src/double_parens.rs b/clippy_lints/src/double_parens.rs
index 5afdcb3c09f..e4e4a93b011 100644
--- a/clippy_lints/src/double_parens.rs
+++ b/clippy_lints/src/double_parens.rs
@@ -50,7 +50,7 @@ impl EarlyLintPass for DoubleParens {
         match expr.kind {
             ExprKind::Paren(ref in_paren) => match in_paren.kind {
                 ExprKind::Paren(_) | ExprKind::Tup(_) => {
-                    span_lint(cx, DOUBLE_PARENS, expr.span, &msg);
+                    span_lint(cx, DOUBLE_PARENS, expr.span, msg);
                 },
                 _ => {},
             },
@@ -58,7 +58,7 @@ impl EarlyLintPass for DoubleParens {
                 if params.len() == 1 {
                     let param = &params[0];
                     if let ExprKind::Paren(_) = param.kind {
-                        span_lint(cx, DOUBLE_PARENS, param.span, &msg);
+                        span_lint(cx, DOUBLE_PARENS, param.span, msg);
                     }
                 }
             },
@@ -66,7 +66,7 @@ impl EarlyLintPass for DoubleParens {
                 if params.len() == 2 {
                     let param = &params[1];
                     if let ExprKind::Paren(_) = param.kind {
-                        span_lint(cx, DOUBLE_PARENS, param.span, &msg);
+                        span_lint(cx, DOUBLE_PARENS, param.span, msg);
                     }
                 }
             },
diff --git a/clippy_lints/src/drop_forget_ref.rs b/clippy_lints/src/drop_forget_ref.rs
index 7e7ec017bbb..b5b29760636 100644
--- a/clippy_lints/src/drop_forget_ref.rs
+++ b/clippy_lints/src/drop_forget_ref.rs
@@ -113,7 +113,7 @@ declare_lint_pass!(DropForgetRef => [DROP_REF, FORGET_REF, DROP_COPY, FORGET_COP
 impl<'tcx> LateLintPass<'tcx> for DropForgetRef {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if_chain! {
-            if let ExprKind::Call(ref path, ref args) = expr.kind;
+            if let ExprKind::Call(path, args) = expr.kind;
             if let ExprKind::Path(ref qpath) = path.kind;
             if args.len() == 1;
             if let Some(def_id) = cx.qpath_res(qpath, path.hir_id).opt_def_id();
diff --git a/clippy_lints/src/duration_subsec.rs b/clippy_lints/src/duration_subsec.rs
index 746c1f6df91..529807770f3 100644
--- a/clippy_lints/src/duration_subsec.rs
+++ b/clippy_lints/src/duration_subsec.rs
@@ -43,8 +43,8 @@ declare_lint_pass!(DurationSubsec => [DURATION_SUBSEC]);
 impl<'tcx> LateLintPass<'tcx> for DurationSubsec {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if_chain! {
-            if let ExprKind::Binary(Spanned { node: BinOpKind::Div, .. }, ref left, ref right) = expr.kind;
-            if let ExprKind::MethodCall(ref method_path, _ , ref args, _) = left.kind;
+            if let ExprKind::Binary(Spanned { node: BinOpKind::Div, .. }, left, right) = expr.kind;
+            if let ExprKind::MethodCall(method_path, _ , args, _) = left.kind;
             if match_type(cx, cx.typeck_results().expr_ty(&args[0]).peel_refs(), &paths::DURATION);
             if let Some((Constant::Int(divisor), _)) = constant(cx, cx.typeck_results(), right);
             then {
diff --git a/clippy_lints/src/entry.rs b/clippy_lints/src/entry.rs
index 25eb048448c..a815df1691a 100644
--- a/clippy_lints/src/entry.rs
+++ b/clippy_lints/src/entry.rs
@@ -57,14 +57,14 @@ declare_lint_pass!(HashMapPass => [MAP_ENTRY]);
 
 impl<'tcx> LateLintPass<'tcx> for HashMapPass {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if let ExprKind::If(ref check, ref then_block, ref else_block) = expr.kind {
-            if let ExprKind::Unary(UnOp::Not, ref check) = check.kind {
+        if let ExprKind::If(check, then_block, ref else_block) = expr.kind {
+            if let ExprKind::Unary(UnOp::Not, check) = check.kind {
                 if let Some((ty, map, key)) = check_cond(cx, check) {
                     // in case of `if !m.contains_key(&k) { m.insert(k, v); }`
                     // we can give a better error message
                     let sole_expr = {
                         else_block.is_none()
-                            && if let ExprKind::Block(ref then_block, _) = then_block.kind {
+                            && if let ExprKind::Block(then_block, _) = then_block.kind {
                                 (then_block.expr.is_some() as usize) + then_block.stmts.len() == 1
                             } else {
                                 true
@@ -81,9 +81,9 @@ impl<'tcx> LateLintPass<'tcx> for HashMapPass {
                         sole_expr,
                     };
 
-                    walk_expr(&mut visitor, &**then_block);
+                    walk_expr(&mut visitor, then_block);
                 }
-            } else if let Some(ref else_block) = *else_block {
+            } else if let Some(else_block) = *else_block {
                 if let Some((ty, map, key)) = check_cond(cx, check) {
                     let mut visitor = InsertVisitor {
                         cx,
@@ -103,10 +103,10 @@ impl<'tcx> LateLintPass<'tcx> for HashMapPass {
 
 fn check_cond<'a>(cx: &LateContext<'_>, check: &'a Expr<'a>) -> Option<(&'static str, &'a Expr<'a>, &'a Expr<'a>)> {
     if_chain! {
-        if let ExprKind::MethodCall(ref path, _, ref params, _) = check.kind;
+        if let ExprKind::MethodCall(path, _, params, _) = check.kind;
         if params.len() >= 2;
         if path.ident.name == sym!(contains_key);
-        if let ExprKind::AddrOf(BorrowKind::Ref, _, ref key) = params[1].kind;
+        if let ExprKind::AddrOf(BorrowKind::Ref, _, key) = params[1].kind;
         then {
             let map = &params[0];
             let obj_ty = cx.typeck_results().expr_ty(map).peel_refs();
@@ -140,7 +140,7 @@ impl<'a, 'tcx, 'b> Visitor<'tcx> for InsertVisitor<'a, 'tcx, 'b> {
 
     fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
         if_chain! {
-            if let ExprKind::MethodCall(ref path, _, ref params, _) = expr.kind;
+            if let ExprKind::MethodCall(path, _, params, _) = expr.kind;
             if params.len() == 3;
             if path.ident.name == sym!(insert);
             if get_item_name(self.cx, self.map) == get_item_name(self.cx, &params[0]);
diff --git a/clippy_lints/src/eq_op.rs b/clippy_lints/src/eq_op.rs
index 6d7046ac8b7..90f391b5f5c 100644
--- a/clippy_lints/src/eq_op.rs
+++ b/clippy_lints/src/eq_op.rs
@@ -65,12 +65,12 @@ const ASSERT_MACRO_NAMES: [&str; 4] = ["assert_eq", "assert_ne", "debug_assert_e
 impl<'tcx> LateLintPass<'tcx> for EqOp {
     #[allow(clippy::similar_names, clippy::too_many_lines)]
     fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
-        if let ExprKind::Block(ref block, _) = e.kind {
+        if let ExprKind::Block(block, _) = e.kind {
             for stmt in block.stmts {
                 for amn in &ASSERT_MACRO_NAMES {
                     if_chain! {
                         if is_expn_of(stmt.span, amn).is_some();
-                        if let StmtKind::Semi(ref matchexpr) = stmt.kind;
+                        if let StmtKind::Semi(matchexpr) = stmt.kind;
                         if let Some(macro_args) = higher::extract_assert_macro_args(matchexpr);
                         if macro_args.len() == 2;
                         let (lhs, rhs) = (macro_args[0], macro_args[1]);
@@ -88,12 +88,12 @@ impl<'tcx> LateLintPass<'tcx> for EqOp {
                 }
             }
         }
-        if let ExprKind::Binary(op, ref left, ref right) = e.kind {
+        if let ExprKind::Binary(op, left, right) = e.kind {
             if e.span.from_expansion() {
                 return;
             }
             let macro_with_not_op = |expr_kind: &ExprKind<'_>| {
-                if let ExprKind::Unary(_, ref expr) = *expr_kind {
+                if let ExprKind::Unary(_, expr) = *expr_kind {
                     in_macro(expr.span)
                 } else {
                     false
@@ -135,7 +135,7 @@ impl<'tcx> LateLintPass<'tcx> for EqOp {
                     // do not suggest to dereference literals
                     (&ExprKind::Lit(..), _) | (_, &ExprKind::Lit(..)) => {},
                     // &foo == &bar
-                    (&ExprKind::AddrOf(BorrowKind::Ref, _, ref l), &ExprKind::AddrOf(BorrowKind::Ref, _, ref r)) => {
+                    (&ExprKind::AddrOf(BorrowKind::Ref, _, l), &ExprKind::AddrOf(BorrowKind::Ref, _, r)) => {
                         let lty = cx.typeck_results().expr_ty(l);
                         let rty = cx.typeck_results().expr_ty(r);
                         let lcpy = is_copy(cx, lty);
@@ -198,7 +198,7 @@ impl<'tcx> LateLintPass<'tcx> for EqOp {
                         }
                     },
                     // &foo == bar
-                    (&ExprKind::AddrOf(BorrowKind::Ref, _, ref l), _) => {
+                    (&ExprKind::AddrOf(BorrowKind::Ref, _, l), _) => {
                         let lty = cx.typeck_results().expr_ty(l);
                         let lcpy = is_copy(cx, lty);
                         if (requires_ref || lcpy)
@@ -222,7 +222,7 @@ impl<'tcx> LateLintPass<'tcx> for EqOp {
                         }
                     },
                     // foo == &bar
-                    (_, &ExprKind::AddrOf(BorrowKind::Ref, _, ref r)) => {
+                    (_, &ExprKind::AddrOf(BorrowKind::Ref, _, r)) => {
                         let rty = cx.typeck_results().expr_ty(r);
                         let rcpy = is_copy(cx, rty);
                         if (requires_ref || rcpy)
diff --git a/clippy_lints/src/erasing_op.rs b/clippy_lints/src/erasing_op.rs
index 59602616781..f95ca86a2d0 100644
--- a/clippy_lints/src/erasing_op.rs
+++ b/clippy_lints/src/erasing_op.rs
@@ -34,7 +34,7 @@ impl<'tcx> LateLintPass<'tcx> for ErasingOp {
         if e.span.from_expansion() {
             return;
         }
-        if let ExprKind::Binary(ref cmp, ref left, ref right) = e.kind {
+        if let ExprKind::Binary(ref cmp, left, right) = e.kind {
             match cmp.node {
                 BinOpKind::Mul | BinOpKind::BitAnd => {
                     check(cx, left, e.span);
diff --git a/clippy_lints/src/eta_reduction.rs b/clippy_lints/src/eta_reduction.rs
index 99253555a95..2f1aa53236d 100644
--- a/clippy_lints/src/eta_reduction.rs
+++ b/clippy_lints/src/eta_reduction.rs
@@ -87,7 +87,7 @@ impl<'tcx> LateLintPass<'tcx> for EtaReduction {
 }
 
 fn check_closure(cx: &LateContext<'_>, expr: &Expr<'_>) {
-    if let ExprKind::Closure(_, ref decl, eid, _, _) = expr.kind {
+    if let ExprKind::Closure(_, decl, eid, _, _) = expr.kind {
         let body = cx.tcx.hir().body(eid);
         let ex = &body.value;
 
@@ -109,7 +109,7 @@ fn check_closure(cx: &LateContext<'_>, expr: &Expr<'_>) {
         }
 
         if_chain!(
-            if let ExprKind::Call(ref caller, ref args) = ex.kind;
+            if let ExprKind::Call(caller, args) = ex.kind;
 
             if let ExprKind::Path(_) = caller.kind;
 
@@ -142,7 +142,7 @@ fn check_closure(cx: &LateContext<'_>, expr: &Expr<'_>) {
         );
 
         if_chain!(
-            if let ExprKind::MethodCall(ref path, _, ref args, _) = ex.kind;
+            if let ExprKind::MethodCall(path, _, args, _) = ex.kind;
 
             // Not the same number of arguments, there is no way the closure is the same as the function return;
             if args.len() == decl.inputs.len();
@@ -178,7 +178,7 @@ fn get_ufcs_type_name(cx: &LateContext<'_>, method_def_id: def_id::DefId, self_a
     let actual_type_of_self = &cx.typeck_results().node_type(self_arg.hir_id);
 
     if let Some(trait_id) = cx.tcx.trait_of_item(method_def_id) {
-        if match_borrow_depth(expected_type_of_self, &actual_type_of_self)
+        if match_borrow_depth(expected_type_of_self, actual_type_of_self)
             && implements_trait(cx, actual_type_of_self, trait_id, &[])
         {
             return Some(cx.tcx.def_path_str(trait_id));
@@ -187,8 +187,8 @@ fn get_ufcs_type_name(cx: &LateContext<'_>, method_def_id: def_id::DefId, self_a
 
     cx.tcx.impl_of_method(method_def_id).and_then(|_| {
         //a type may implicitly implement other type's methods (e.g. Deref)
-        if match_types(expected_type_of_self, &actual_type_of_self) {
-            return Some(get_type_name(cx, &actual_type_of_self));
+        if match_types(expected_type_of_self, actual_type_of_self) {
+            return Some(get_type_name(cx, actual_type_of_self));
         }
         None
     })
@@ -196,7 +196,7 @@ fn get_ufcs_type_name(cx: &LateContext<'_>, method_def_id: def_id::DefId, self_a
 
 fn match_borrow_depth(lhs: Ty<'_>, rhs: Ty<'_>) -> bool {
     match (&lhs.kind(), &rhs.kind()) {
-        (ty::Ref(_, t1, mut1), ty::Ref(_, t2, mut2)) => mut1 == mut2 && match_borrow_depth(&t1, &t2),
+        (ty::Ref(_, t1, mut1), ty::Ref(_, t2, mut2)) => mut1 == mut2 && match_borrow_depth(t1, t2),
         (l, r) => !matches!((l, r), (ty::Ref(_, _, _), _) | (_, ty::Ref(_, _, _))),
     }
 }
@@ -218,7 +218,7 @@ fn match_types(lhs: Ty<'_>, rhs: Ty<'_>) -> bool {
 fn get_type_name(cx: &LateContext<'_>, ty: Ty<'_>) -> String {
     match ty.kind() {
         ty::Adt(t, _) => cx.tcx.def_path_str(t.did),
-        ty::Ref(_, r, _) => get_type_name(cx, &r),
+        ty::Ref(_, r, _) => get_type_name(cx, r),
         _ => ty.to_string(),
     }
 }
@@ -230,7 +230,7 @@ fn compare_inputs(
     for (closure_input, function_arg) in closure_inputs.zip(call_args) {
         if let PatKind::Binding(_, _, ident, _) = closure_input.pat.kind {
             // XXXManishearth Should I be checking the binding mode here?
-            if let ExprKind::Path(QPath::Resolved(None, ref p)) = function_arg.kind {
+            if let ExprKind::Path(QPath::Resolved(None, p)) = function_arg.kind {
                 if p.segments.len() != 1 {
                     // If it's a proper path, it can't be a local variable
                     return false;
diff --git a/clippy_lints/src/eval_order_dependence.rs b/clippy_lints/src/eval_order_dependence.rs
index ea33a4d98fd..762f64fe37a 100644
--- a/clippy_lints/src/eval_order_dependence.rs
+++ b/clippy_lints/src/eval_order_dependence.rs
@@ -71,7 +71,7 @@ impl<'tcx> LateLintPass<'tcx> for EvalOrderDependence {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         // Find a write to a local variable.
         match expr.kind {
-            ExprKind::Assign(ref lhs, ..) | ExprKind::AssignOp(_, ref lhs, _) => {
+            ExprKind::Assign(lhs, ..) | ExprKind::AssignOp(_, lhs, _) => {
                 if let Some(var) = path_to_local(lhs) {
                     let mut visitor = ReadVisitor {
                         cx,
@@ -87,12 +87,12 @@ impl<'tcx> LateLintPass<'tcx> for EvalOrderDependence {
     }
     fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) {
         match stmt.kind {
-            StmtKind::Local(ref local) => {
-                if let Local { init: Some(ref e), .. } = **local {
+            StmtKind::Local(local) => {
+                if let Local { init: Some(e), .. } = local {
                     DivergenceVisitor { cx }.visit_expr(e);
                 }
             },
-            StmtKind::Expr(ref e) | StmtKind::Semi(ref e) => DivergenceVisitor { cx }.maybe_walk_expr(e),
+            StmtKind::Expr(e) | StmtKind::Semi(e) => DivergenceVisitor { cx }.maybe_walk_expr(e),
             StmtKind::Item(..) => {},
         }
     }
@@ -106,7 +106,7 @@ impl<'a, 'tcx> DivergenceVisitor<'a, 'tcx> {
     fn maybe_walk_expr(&mut self, e: &'tcx Expr<'_>) {
         match e.kind {
             ExprKind::Closure(..) => {},
-            ExprKind::Match(ref e, arms, _) => {
+            ExprKind::Match(e, arms, _) => {
                 self.visit_expr(e);
                 for arm in arms {
                     if let Some(Guard::If(if_expr)) = arm.guard {
@@ -130,7 +130,7 @@ impl<'a, 'tcx> Visitor<'tcx> for DivergenceVisitor<'a, 'tcx> {
     fn visit_expr(&mut self, e: &'tcx Expr<'_>) {
         match e.kind {
             ExprKind::Continue(_) | ExprKind::Break(_, _) | ExprKind::Ret(_) => self.report_diverging_sub_expr(e),
-            ExprKind::Call(ref func, _) => {
+            ExprKind::Call(func, _) => {
                 let typ = self.cx.typeck_results().expr_ty(func);
                 match typ.kind() {
                     ty::FnDef(..) | ty::FnPtr(_) => {
@@ -266,10 +266,10 @@ fn check_expr<'a, 'tcx>(vis: &mut ReadVisitor<'a, 'tcx>, expr: &'tcx Expr<'_>) -
 
 fn check_stmt<'a, 'tcx>(vis: &mut ReadVisitor<'a, 'tcx>, stmt: &'tcx Stmt<'_>) -> StopEarly {
     match stmt.kind {
-        StmtKind::Expr(ref expr) | StmtKind::Semi(ref expr) => check_expr(vis, expr),
+        StmtKind::Expr(expr) | StmtKind::Semi(expr) => check_expr(vis, expr),
         // If the declaration is of a local variable, check its initializer
         // expression if it has one. Otherwise, keep going.
-        StmtKind::Local(ref local) => local
+        StmtKind::Local(local) => local
             .init
             .as_ref()
             .map_or(StopEarly::KeepGoing, |expr| check_expr(vis, expr)),
@@ -343,7 +343,7 @@ impl<'a, 'tcx> Visitor<'tcx> for ReadVisitor<'a, 'tcx> {
 /// Returns `true` if `expr` is the LHS of an assignment, like `expr = ...`.
 fn is_in_assignment_position(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
     if let Some(parent) = get_parent_expr(cx, expr) {
-        if let ExprKind::Assign(ref lhs, ..) = parent.kind {
+        if let ExprKind::Assign(lhs, ..) = parent.kind {
             return lhs.hir_id == expr.hir_id;
         }
     }
diff --git a/clippy_lints/src/exit.rs b/clippy_lints/src/exit.rs
index 84fac998662..16246e548b6 100644
--- a/clippy_lints/src/exit.rs
+++ b/clippy_lints/src/exit.rs
@@ -28,7 +28,7 @@ declare_lint_pass!(Exit => [EXIT]);
 impl<'tcx> LateLintPass<'tcx> for Exit {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
         if_chain! {
-            if let ExprKind::Call(ref path_expr, ref _args) = e.kind;
+            if let ExprKind::Call(path_expr, _args) = e.kind;
             if let ExprKind::Path(ref path) = path_expr.kind;
             if let Some(def_id) = cx.qpath_res(path, path_expr.hir_id).opt_def_id();
             if match_def_path(cx, def_id, &paths::EXIT);
diff --git a/clippy_lints/src/explicit_write.rs b/clippy_lints/src/explicit_write.rs
index 4146b7baa10..da4936ff25b 100644
--- a/clippy_lints/src/explicit_write.rs
+++ b/clippy_lints/src/explicit_write.rs
@@ -34,11 +34,11 @@ impl<'tcx> LateLintPass<'tcx> for ExplicitWrite {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if_chain! {
             // match call to unwrap
-            if let ExprKind::MethodCall(ref unwrap_fun, _, ref unwrap_args, _) = expr.kind;
+            if let ExprKind::MethodCall(unwrap_fun, _, unwrap_args, _) = expr.kind;
             if unwrap_fun.ident.name == sym::unwrap;
             // match call to write_fmt
             if !unwrap_args.is_empty();
-            if let ExprKind::MethodCall(ref write_fun, _, write_args, _) =
+            if let ExprKind::MethodCall(write_fun, _, write_args, _) =
                 unwrap_args[0].kind;
             if write_fun.ident.name == sym!(write_fmt);
             // match calls to std::io::stdout() / std::io::stderr ()
@@ -135,10 +135,10 @@ fn write_output_string(write_args: &[Expr<'_>]) -> Option<String> {
     if_chain! {
         // Obtain the string that should be printed
         if write_args.len() > 1;
-        if let ExprKind::Call(_, ref output_args) = write_args[1].kind;
+        if let ExprKind::Call(_, output_args) = write_args[1].kind;
         if !output_args.is_empty();
-        if let ExprKind::AddrOf(BorrowKind::Ref, _, ref output_string_expr) = output_args[0].kind;
-        if let ExprKind::Array(ref string_exprs) = output_string_expr.kind;
+        if let ExprKind::AddrOf(BorrowKind::Ref, _, output_string_expr) = output_args[0].kind;
+        if let ExprKind::Array(string_exprs) = output_string_expr.kind;
         // we only want to provide an automatic suggestion for simple (non-format) strings
         if string_exprs.len() == 1;
         if let ExprKind::Lit(ref lit) = string_exprs[0].kind;
diff --git a/clippy_lints/src/fallible_impl_from.rs b/clippy_lints/src/fallible_impl_from.rs
index 52a5a7acf0d..2937fcb9ca0 100644
--- a/clippy_lints/src/fallible_impl_from.rs
+++ b/clippy_lints/src/fallible_impl_from.rs
@@ -81,8 +81,8 @@ fn lint_impl_body<'tcx>(cx: &LateContext<'tcx>, impl_span: Span, impl_items: &[h
         fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
             // check for `begin_panic`
             if_chain! {
-                if let ExprKind::Call(ref func_expr, _) = expr.kind;
-                if let ExprKind::Path(QPath::Resolved(_, ref path)) = func_expr.kind;
+                if let ExprKind::Call(func_expr, _) = expr.kind;
+                if let ExprKind::Path(QPath::Resolved(_, path)) = func_expr.kind;
                 if let Some(path_def_id) = path.res.opt_def_id();
                 if match_panic_def_id(self.lcx, path_def_id);
                 if is_expn_of(expr.span, "unreachable").is_none();
diff --git a/clippy_lints/src/float_equality_without_abs.rs b/clippy_lints/src/float_equality_without_abs.rs
index 0c59db360f9..b5ebe5f90ba 100644
--- a/clippy_lints/src/float_equality_without_abs.rs
+++ b/clippy_lints/src/float_equality_without_abs.rs
@@ -48,7 +48,7 @@ impl<'tcx> LateLintPass<'tcx> for FloatEqualityWithoutAbs {
         let rhs;
 
         // check if expr is a binary expression with a lt or gt operator
-        if let ExprKind::Binary(op, ref left, ref right) = expr.kind {
+        if let ExprKind::Binary(op, left, right) = expr.kind {
             match op.node {
                 BinOpKind::Lt => {
                     lhs = left;
@@ -88,8 +88,8 @@ impl<'tcx> LateLintPass<'tcx> for FloatEqualityWithoutAbs {
             if let ty::Float(_) = t_val_r.kind();
 
             then {
-                let sug_l = sugg::Sugg::hir(cx, &val_l, "..");
-                let sug_r = sugg::Sugg::hir(cx, &val_r, "..");
+                let sug_l = sugg::Sugg::hir(cx, val_l, "..");
+                let sug_r = sugg::Sugg::hir(cx, val_r, "..");
                 // format the suggestion
                 let suggestion = format!("{}.abs()", sugg::make_assoc(AssocOp::Subtract, &sug_l, &sug_r).maybe_par());
                 // spans the lint
diff --git a/clippy_lints/src/floating_point_arithmetic.rs b/clippy_lints/src/floating_point_arithmetic.rs
index 0b5f0379ce6..e0b687b0205 100644
--- a/clippy_lints/src/floating_point_arithmetic.rs
+++ b/clippy_lints/src/floating_point_arithmetic.rs
@@ -131,7 +131,7 @@ fn prepare_receiver_sugg<'a>(cx: &LateContext<'_>, mut expr: &'a Expr<'a>) -> Su
     let mut suggestion = Sugg::hir(cx, expr, "..");
 
     if let ExprKind::Unary(UnOp::Neg, inner_expr) = &expr.kind {
-        expr = &inner_expr;
+        expr = inner_expr;
     }
 
     if_chain! {
@@ -313,8 +313,8 @@ fn check_powi(cx: &LateContext<'_>, expr: &Expr<'_>, args: &[Expr<'_>]) {
                     Spanned {
                         node: BinOpKind::Add, ..
                     },
-                    ref lhs,
-                    ref rhs,
+                    lhs,
+                    rhs,
                 ) = parent.kind
                 {
                     let other_addend = if lhs.hir_id == expr.hir_id { rhs } else { lhs };
@@ -329,7 +329,7 @@ fn check_powi(cx: &LateContext<'_>, expr: &Expr<'_>, args: &[Expr<'_>]) {
                             "{}.mul_add({}, {})",
                             Sugg::hir(cx, &args[0], ".."),
                             Sugg::hir(cx, &args[0], ".."),
-                            Sugg::hir(cx, &other_addend, ".."),
+                            Sugg::hir(cx, other_addend, ".."),
                         ),
                         Applicability::MachineApplicable,
                     );
@@ -356,18 +356,18 @@ fn detect_hypot(cx: &LateContext<'_>, args: &[Expr<'_>]) -> Option<String> {
         Spanned {
             node: BinOpKind::Add, ..
         },
-        ref add_lhs,
-        ref add_rhs,
+        add_lhs,
+        add_rhs,
     ) = args[0].kind
     {
         // check if expression of the form x * x + y * y
         if_chain! {
-            if let ExprKind::Binary(Spanned { node: BinOpKind::Mul, .. }, ref lmul_lhs, ref lmul_rhs) = add_lhs.kind;
-            if let ExprKind::Binary(Spanned { node: BinOpKind::Mul, .. }, ref rmul_lhs, ref rmul_rhs) = add_rhs.kind;
+            if let ExprKind::Binary(Spanned { node: BinOpKind::Mul, .. }, lmul_lhs, lmul_rhs) = add_lhs.kind;
+            if let ExprKind::Binary(Spanned { node: BinOpKind::Mul, .. }, rmul_lhs, rmul_rhs) = add_rhs.kind;
             if eq_expr_value(cx, lmul_lhs, lmul_rhs);
             if eq_expr_value(cx, rmul_lhs, rmul_rhs);
             then {
-                return Some(format!("{}.hypot({})", Sugg::hir(cx, &lmul_lhs, ".."), Sugg::hir(cx, &rmul_lhs, "..")));
+                return Some(format!("{}.hypot({})", Sugg::hir(cx, lmul_lhs, ".."), Sugg::hir(cx, rmul_lhs, "..")));
             }
         }
 
@@ -376,13 +376,13 @@ fn detect_hypot(cx: &LateContext<'_>, args: &[Expr<'_>]) -> Option<String> {
             if let ExprKind::MethodCall(
                 PathSegment { ident: lmethod_name, .. },
                 ref _lspan,
-                ref largs,
+                largs,
                 _
             ) = add_lhs.kind;
             if let ExprKind::MethodCall(
                 PathSegment { ident: rmethod_name, .. },
                 ref _rspan,
-                ref rargs,
+                rargs,
                 _
             ) = add_rhs.kind;
             if lmethod_name.as_str() == "powi" && rmethod_name.as_str() == "powi";
@@ -416,11 +416,11 @@ fn check_hypot(cx: &LateContext<'_>, expr: &Expr<'_>, args: &[Expr<'_>]) {
 // and suggest usage of `x.exp_m1() - (y - 1)` instead
 fn check_expm1(cx: &LateContext<'_>, expr: &Expr<'_>) {
     if_chain! {
-        if let ExprKind::Binary(Spanned { node: BinOpKind::Sub, .. }, ref lhs, ref rhs) = expr.kind;
+        if let ExprKind::Binary(Spanned { node: BinOpKind::Sub, .. }, lhs, rhs) = expr.kind;
         if cx.typeck_results().expr_ty(lhs).is_floating_point();
         if let Some((value, _)) = constant(cx, cx.typeck_results(), rhs);
         if F32(1.0) == value || F64(1.0) == value;
-        if let ExprKind::MethodCall(ref path, _, ref method_args, _) = lhs.kind;
+        if let ExprKind::MethodCall(path, _, method_args, _) = lhs.kind;
         if cx.typeck_results().expr_ty(&method_args[0]).is_floating_point();
         if path.ident.name.as_str() == "exp";
         then {
@@ -442,7 +442,7 @@ fn check_expm1(cx: &LateContext<'_>, expr: &Expr<'_>) {
 
 fn is_float_mul_expr<'a>(cx: &LateContext<'_>, expr: &'a Expr<'a>) -> Option<(&'a Expr<'a>, &'a Expr<'a>)> {
     if_chain! {
-        if let ExprKind::Binary(Spanned { node: BinOpKind::Mul, .. }, ref lhs, ref rhs) = &expr.kind;
+        if let ExprKind::Binary(Spanned { node: BinOpKind::Mul, .. }, lhs, rhs) = &expr.kind;
         if cx.typeck_results().expr_ty(lhs).is_floating_point();
         if cx.typeck_results().expr_ty(rhs).is_floating_point();
         then {
@@ -604,8 +604,8 @@ fn check_custom_abs(cx: &LateContext<'_>, expr: &Expr<'_>) {
 
 fn are_same_base_logs(cx: &LateContext<'_>, expr_a: &Expr<'_>, expr_b: &Expr<'_>) -> bool {
     if_chain! {
-        if let ExprKind::MethodCall(PathSegment { ident: method_name_a, .. }, _, ref args_a, _) = expr_a.kind;
-        if let ExprKind::MethodCall(PathSegment { ident: method_name_b, .. }, _, ref args_b, _) = expr_b.kind;
+        if let ExprKind::MethodCall(PathSegment { ident: method_name_a, .. }, _, args_a, _) = expr_a.kind;
+        if let ExprKind::MethodCall(PathSegment { ident: method_name_b, .. }, _, args_b, _) = expr_b.kind;
         then {
             return method_name_a.as_str() == method_name_b.as_str() &&
                 args_a.len() == args_b.len() &&
@@ -630,8 +630,8 @@ fn check_log_division(cx: &LateContext<'_>, expr: &Expr<'_>) {
             rhs,
         ) = &expr.kind;
         if are_same_base_logs(cx, lhs, rhs);
-        if let ExprKind::MethodCall(_, _, ref largs, _) = lhs.kind;
-        if let ExprKind::MethodCall(_, _, ref rargs, _) = rhs.kind;
+        if let ExprKind::MethodCall(_, _, largs, _) = lhs.kind;
+        if let ExprKind::MethodCall(_, _, rargs, _) = rhs.kind;
         then {
             span_lint_and_sugg(
                 cx,
@@ -675,7 +675,7 @@ fn check_radians(cx: &LateContext<'_>, expr: &Expr<'_>) {
                     expr.span,
                     "conversion to degrees can be done more accurately",
                     "consider using",
-                    format!("{}.to_degrees()", Sugg::hir(cx, &mul_lhs, "..")),
+                    format!("{}.to_degrees()", Sugg::hir(cx, mul_lhs, "..")),
                     Applicability::MachineApplicable,
                 );
             } else if
@@ -688,7 +688,7 @@ fn check_radians(cx: &LateContext<'_>, expr: &Expr<'_>) {
                     expr.span,
                     "conversion to radians can be done more accurately",
                     "consider using",
-                    format!("{}.to_radians()", Sugg::hir(cx, &mul_lhs, "..")),
+                    format!("{}.to_radians()", Sugg::hir(cx, mul_lhs, "..")),
                     Applicability::MachineApplicable,
                 );
             }
@@ -698,7 +698,7 @@ fn check_radians(cx: &LateContext<'_>, expr: &Expr<'_>) {
 
 impl<'tcx> LateLintPass<'tcx> for FloatingPointArithmetic {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if let ExprKind::MethodCall(ref path, _, args, _) = &expr.kind {
+        if let ExprKind::MethodCall(path, _, args, _) = &expr.kind {
             let recv_ty = cx.typeck_results().expr_ty(&args[0]);
 
             if recv_ty.is_floating_point() {
diff --git a/clippy_lints/src/format.rs b/clippy_lints/src/format.rs
index a33f987b423..4729abbd8e3 100644
--- a/clippy_lints/src/format.rs
+++ b/clippy_lints/src/format.rs
@@ -78,8 +78,8 @@ fn span_useless_format<T: LintContext>(cx: &T, span: Span, help: &str, mut sugg:
 
 fn on_argumentv1_new<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, arms: &'tcx [Arm<'_>]) -> Option<String> {
     if_chain! {
-        if let ExprKind::AddrOf(BorrowKind::Ref, _, ref format_args) = expr.kind;
-        if let ExprKind::Array(ref elems) = arms[0].body.kind;
+        if let ExprKind::AddrOf(BorrowKind::Ref, _, format_args) = expr.kind;
+        if let ExprKind::Array(elems) = arms[0].body.kind;
         if elems.len() == 1;
         if let Some(args) = match_function_call(cx, &elems[0], &paths::FMT_ARGUMENTV1_NEW);
         // matches `core::fmt::Display::fmt`
@@ -88,10 +88,10 @@ fn on_argumentv1_new<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, arms: &
         if let Some(did) = cx.qpath_res(qpath, args[1].hir_id).opt_def_id();
         if match_def_path(cx, did, &paths::DISPLAY_FMT_METHOD);
         // check `(arg0,)` in match block
-        if let PatKind::Tuple(ref pats, None) = arms[0].pat.kind;
+        if let PatKind::Tuple(pats, None) = arms[0].pat.kind;
         if pats.len() == 1;
         then {
-            let ty = cx.typeck_results().pat_ty(&pats[0]).peel_refs();
+            let ty = cx.typeck_results().pat_ty(pats[0]).peel_refs();
             if *ty.kind() != rustc_middle::ty::Str && !is_type_diagnostic_item(cx, ty, sym::string_type) {
                 return None;
             }
@@ -101,7 +101,7 @@ fn on_argumentv1_new<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, arms: &
                 }
             } else {
                 let snip = snippet(cx, format_args.span, "<arg>");
-                if let ExprKind::MethodCall(ref path, _, _, _) = format_args.kind {
+                if let ExprKind::MethodCall(path, _, _, _) = format_args.kind {
                     if path.ident.name == sym!(to_string) {
                         return Some(format!("{}", snip));
                     }
@@ -120,16 +120,16 @@ fn on_new_v1<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<Strin
         if let Some(args) = match_function_call(cx, expr, &paths::FMT_ARGUMENTS_NEW_V1);
         if args.len() == 2;
         // Argument 1 in `new_v1()`
-        if let ExprKind::AddrOf(BorrowKind::Ref, _, ref arr) = args[0].kind;
-        if let ExprKind::Array(ref pieces) = arr.kind;
+        if let ExprKind::AddrOf(BorrowKind::Ref, _, arr) = args[0].kind;
+        if let ExprKind::Array(pieces) = arr.kind;
         if pieces.len() == 1;
         if let ExprKind::Lit(ref lit) = pieces[0].kind;
         if let LitKind::Str(ref s, _) = lit.node;
         // Argument 2 in `new_v1()`
-        if let ExprKind::AddrOf(BorrowKind::Ref, _, ref arg1) = args[1].kind;
-        if let ExprKind::Match(ref matchee, ref arms, MatchSource::Normal) = arg1.kind;
+        if let ExprKind::AddrOf(BorrowKind::Ref, _, arg1) = args[1].kind;
+        if let ExprKind::Match(matchee, arms, MatchSource::Normal) = arg1.kind;
         if arms.len() == 1;
-        if let ExprKind::Tup(ref tup) = matchee.kind;
+        if let ExprKind::Tup(tup) = matchee.kind;
         then {
             // `format!("foo")` expansion contains `match () { () => [], }`
             if tup.is_empty() {
@@ -152,16 +152,16 @@ fn on_new_v1_fmt<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<S
         if args.len() == 3;
         if check_unformatted(&args[2]);
         // Argument 1 in `new_v1_formatted()`
-        if let ExprKind::AddrOf(BorrowKind::Ref, _, ref arr) = args[0].kind;
-        if let ExprKind::Array(ref pieces) = arr.kind;
+        if let ExprKind::AddrOf(BorrowKind::Ref, _, arr) = args[0].kind;
+        if let ExprKind::Array(pieces) = arr.kind;
         if pieces.len() == 1;
         if let ExprKind::Lit(ref lit) = pieces[0].kind;
         if let LitKind::Str(..) = lit.node;
         // Argument 2 in `new_v1_formatted()`
-        if let ExprKind::AddrOf(BorrowKind::Ref, _, ref arg1) = args[1].kind;
-        if let ExprKind::Match(ref matchee, ref arms, MatchSource::Normal) = arg1.kind;
+        if let ExprKind::AddrOf(BorrowKind::Ref, _, arg1) = args[1].kind;
+        if let ExprKind::Match(matchee, arms, MatchSource::Normal) = arg1.kind;
         if arms.len() == 1;
-        if let ExprKind::Tup(ref tup) = matchee.kind;
+        if let ExprKind::Tup(tup) = matchee.kind;
         then {
             return on_argumentv1_new(cx, &tup[0], arms);
         }
@@ -182,14 +182,14 @@ fn on_new_v1_fmt<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<S
 /// ```
 fn check_unformatted(expr: &Expr<'_>) -> bool {
     if_chain! {
-        if let ExprKind::AddrOf(BorrowKind::Ref, _, ref expr) = expr.kind;
-        if let ExprKind::Array(ref exprs) = expr.kind;
+        if let ExprKind::AddrOf(BorrowKind::Ref, _, expr) = expr.kind;
+        if let ExprKind::Array(exprs) = expr.kind;
         if exprs.len() == 1;
         // struct `core::fmt::rt::v1::Argument`
-        if let ExprKind::Struct(_, ref fields, _) = exprs[0].kind;
+        if let ExprKind::Struct(_, fields, _) = exprs[0].kind;
         if let Some(format_field) = fields.iter().find(|f| f.ident.name == sym::format);
         // struct `core::fmt::rt::v1::FormatSpec`
-        if let ExprKind::Struct(_, ref fields, _) = format_field.expr.kind;
+        if let ExprKind::Struct(_, fields, _) = format_field.expr.kind;
         if let Some(precision_field) = fields.iter().find(|f| f.ident.name == sym::precision);
         if let ExprKind::Path(ref precision_path) = precision_field.expr.kind;
         if last_path_segment(precision_path).ident.name == sym::Implied;
diff --git a/clippy_lints/src/functions/must_use.rs b/clippy_lints/src/functions/must_use.rs
index 9e943c647fe..db5fe90b663 100644
--- a/clippy_lints/src/functions/must_use.rs
+++ b/clippy_lints/src/functions/must_use.rs
@@ -25,12 +25,12 @@ pub(super) fn check_item(cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) {
         let is_public = cx.access_levels.is_exported(item.hir_id());
         let fn_header_span = item.span.with_hi(sig.decl.output.span().hi());
         if let Some(attr) = attr {
-            check_needless_must_use(cx, &sig.decl, item.hir_id(), item.span, fn_header_span, attr);
+            check_needless_must_use(cx, sig.decl, item.hir_id(), item.span, fn_header_span, attr);
             return;
         } else if is_public && !is_proc_macro(cx.sess(), attrs) && attr_by_name(attrs, "no_mangle").is_none() {
             check_must_use_candidate(
                 cx,
-                &sig.decl,
+                sig.decl,
                 cx.tcx.hir().body(*body_id),
                 item.span,
                 item.hir_id(),
@@ -48,11 +48,11 @@ pub(super) fn check_impl_item(cx: &LateContext<'tcx>, item: &'tcx hir::ImplItem<
         let attrs = cx.tcx.hir().attrs(item.hir_id());
         let attr = must_use_attr(attrs);
         if let Some(attr) = attr {
-            check_needless_must_use(cx, &sig.decl, item.hir_id(), item.span, fn_header_span, attr);
+            check_needless_must_use(cx, sig.decl, item.hir_id(), item.span, fn_header_span, attr);
         } else if is_public && !is_proc_macro(cx.sess(), attrs) && trait_ref_of_method(cx, item.hir_id()).is_none() {
             check_must_use_candidate(
                 cx,
-                &sig.decl,
+                sig.decl,
                 cx.tcx.hir().body(*body_id),
                 item.span,
                 item.hir_id(),
@@ -71,13 +71,13 @@ pub(super) fn check_trait_item(cx: &LateContext<'tcx>, item: &'tcx hir::TraitIte
         let attrs = cx.tcx.hir().attrs(item.hir_id());
         let attr = must_use_attr(attrs);
         if let Some(attr) = attr {
-            check_needless_must_use(cx, &sig.decl, item.hir_id(), item.span, fn_header_span, attr);
+            check_needless_must_use(cx, sig.decl, item.hir_id(), item.span, fn_header_span, attr);
         } else if let hir::TraitFn::Provided(eid) = *eid {
             let body = cx.tcx.hir().body(eid);
             if attr.is_none() && is_public && !is_proc_macro(cx.sess(), attrs) {
                 check_must_use_candidate(
                     cx,
-                    &sig.decl,
+                    sig.decl,
                     body,
                     item.span,
                     item.hir_id(),
@@ -160,8 +160,8 @@ fn check_must_use_candidate<'tcx>(
 fn returns_unit(decl: &hir::FnDecl<'_>) -> bool {
     match decl.output {
         hir::FnRetTy::DefaultReturn(_) => true,
-        hir::FnRetTy::Return(ref ty) => match ty.kind {
-            hir::TyKind::Tup(ref tys) => tys.is_empty(),
+        hir::FnRetTy::Return(ty) => match ty.kind {
+            hir::TyKind::Tup(tys) => tys.is_empty(),
             hir::TyKind::Never => true,
             _ => false,
         },
@@ -170,7 +170,7 @@ fn returns_unit(decl: &hir::FnDecl<'_>) -> bool {
 
 fn has_mutable_arg(cx: &LateContext<'_>, body: &hir::Body<'_>) -> bool {
     let mut tys = DefIdSet::default();
-    body.params.iter().any(|param| is_mutable_pat(cx, &param.pat, &mut tys))
+    body.params.iter().any(|param| is_mutable_pat(cx, param.pat, &mut tys))
 }
 
 fn is_mutable_pat(cx: &LateContext<'_>, pat: &hir::Pat<'_>, tys: &mut DefIdSet) -> bool {
@@ -178,7 +178,7 @@ fn is_mutable_pat(cx: &LateContext<'_>, pat: &hir::Pat<'_>, tys: &mut DefIdSet)
         return false; // ignore `_` patterns
     }
     if cx.tcx.has_typeck_results(pat.hir_id.owner.to_def_id()) {
-        is_mutable_ty(cx, &cx.tcx.typeck(pat.hir_id.owner).pat_ty(pat), pat.span, tys)
+        is_mutable_ty(cx, cx.tcx.typeck(pat.hir_id.owner).pat_ty(pat), pat.span, tys)
     } else {
         false
     }
@@ -190,12 +190,12 @@ fn is_mutable_ty<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>, span: Span, tys: &m
     match *ty.kind() {
         // primitive types are never mutable
         ty::Bool | ty::Char | ty::Int(_) | ty::Uint(_) | ty::Float(_) | ty::Str => false,
-        ty::Adt(ref adt, ref substs) => {
+        ty::Adt(adt, substs) => {
             tys.insert(adt.did) && !ty.is_freeze(cx.tcx.at(span), cx.param_env)
                 || KNOWN_WRAPPER_TYS.iter().any(|path| match_def_path(cx, adt.did, path))
                     && substs.types().any(|ty| is_mutable_ty(cx, ty, span, tys))
         },
-        ty::Tuple(ref substs) => substs.types().any(|ty| is_mutable_ty(cx, ty, span, tys)),
+        ty::Tuple(substs) => substs.types().any(|ty| is_mutable_ty(cx, ty, span, tys)),
         ty::Array(ty, _) | ty::Slice(ty) => is_mutable_ty(cx, ty, span, tys),
         ty::RawPtr(ty::TypeAndMut { ty, mutbl }) | ty::Ref(_, ty, mutbl) => {
             mutbl == hir::Mutability::Mut || is_mutable_ty(cx, ty, span, tys)
@@ -239,7 +239,7 @@ impl<'a, 'tcx> intravisit::Visitor<'tcx> for StaticMutVisitor<'a, 'tcx> {
                     tys.clear();
                 }
             },
-            Assign(ref target, ..) | AssignOp(_, ref target, _) | AddrOf(_, hir::Mutability::Mut, ref target) => {
+            Assign(target, ..) | AssignOp(_, target, _) | AddrOf(_, hir::Mutability::Mut, target) => {
                 self.mutates_static |= is_mutated_static(target)
             },
             _ => {},
@@ -257,7 +257,7 @@ fn is_mutated_static(e: &hir::Expr<'_>) -> bool {
     match e.kind {
         Path(QPath::Resolved(_, path)) => !matches!(path.res, Res::Local(_)),
         Path(_) => true,
-        Field(ref inner, _) | Index(ref inner, _) => is_mutated_static(inner),
+        Field(inner, _) | Index(inner, _) => is_mutated_static(inner),
         _ => false,
     }
 }
diff --git a/clippy_lints/src/functions/not_unsafe_ptr_arg_deref.rs b/clippy_lints/src/functions/not_unsafe_ptr_arg_deref.rs
index cc69f4aed0c..b8ea6990866 100644
--- a/clippy_lints/src/functions/not_unsafe_ptr_arg_deref.rs
+++ b/clippy_lints/src/functions/not_unsafe_ptr_arg_deref.rs
@@ -27,7 +27,7 @@ pub(super) fn check_fn(
 pub(super) fn check_trait_item(cx: &LateContext<'tcx>, item: &'tcx hir::TraitItem<'_>) {
     if let hir::TraitItemKind::Fn(ref sig, hir::TraitFn::Provided(eid)) = item.kind {
         let body = cx.tcx.hir().body(eid);
-        check_raw_ptr(cx, sig.header.unsafety, &sig.decl, body, item.hir_id());
+        check_raw_ptr(cx, sig.header.unsafety, sig.decl, body, item.hir_id());
     }
 }
 
@@ -77,7 +77,7 @@ impl<'a, 'tcx> intravisit::Visitor<'tcx> for DerefVisitor<'a, 'tcx> {
 
     fn visit_expr(&mut self, expr: &'tcx hir::Expr<'_>) {
         match expr.kind {
-            hir::ExprKind::Call(ref f, args) => {
+            hir::ExprKind::Call(f, args) => {
                 let ty = self.typeck_results.expr_ty(f);
 
                 if type_is_unsafe_function(self.cx, ty) {
@@ -96,7 +96,7 @@ impl<'a, 'tcx> intravisit::Visitor<'tcx> for DerefVisitor<'a, 'tcx> {
                     }
                 }
             },
-            hir::ExprKind::Unary(hir::UnOp::Deref, ref ptr) => self.check_arg(ptr),
+            hir::ExprKind::Unary(hir::UnOp::Deref, ptr) => self.check_arg(ptr),
             _ => (),
         }
 
diff --git a/clippy_lints/src/functions/result_unit_err.rs b/clippy_lints/src/functions/result_unit_err.rs
index 3d1092ce21f..c073f312d38 100644
--- a/clippy_lints/src/functions/result_unit_err.rs
+++ b/clippy_lints/src/functions/result_unit_err.rs
@@ -18,7 +18,7 @@ pub(super) fn check_item(cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) {
         let is_public = cx.access_levels.is_exported(item.hir_id());
         let fn_header_span = item.span.with_hi(sig.decl.output.span().hi());
         if is_public {
-            check_result_unit_err(cx, &sig.decl, item.span, fn_header_span);
+            check_result_unit_err(cx, sig.decl, item.span, fn_header_span);
         }
     }
 }
@@ -28,7 +28,7 @@ pub(super) fn check_impl_item(cx: &LateContext<'tcx>, item: &'tcx hir::ImplItem<
         let is_public = cx.access_levels.is_exported(item.hir_id());
         let fn_header_span = item.span.with_hi(sig.decl.output.span().hi());
         if is_public && trait_ref_of_method(cx, item.hir_id()).is_none() {
-            check_result_unit_err(cx, &sig.decl, item.span, fn_header_span);
+            check_result_unit_err(cx, sig.decl, item.span, fn_header_span);
         }
     }
 }
@@ -38,7 +38,7 @@ pub(super) fn check_trait_item(cx: &LateContext<'tcx>, item: &'tcx hir::TraitIte
         let is_public = cx.access_levels.is_exported(item.hir_id());
         let fn_header_span = item.span.with_hi(sig.decl.output.span().hi());
         if is_public {
-            check_result_unit_err(cx, &sig.decl, item.span, fn_header_span);
+            check_result_unit_err(cx, sig.decl, item.span, fn_header_span);
         }
     }
 }
@@ -46,7 +46,7 @@ pub(super) fn check_trait_item(cx: &LateContext<'tcx>, item: &'tcx hir::TraitIte
 fn check_result_unit_err(cx: &LateContext<'_>, decl: &hir::FnDecl<'_>, item_span: Span, fn_header_span: Span) {
     if_chain! {
         if !in_external_macro(cx.sess(), item_span);
-        if let hir::FnRetTy::Return(ref ty) = decl.output;
+        if let hir::FnRetTy::Return(ty) = decl.output;
         let ty = hir_ty_to_ty(cx.tcx, ty);
         if is_type_diagnostic_item(cx, ty, sym::result_type);
         if let ty::Adt(_, substs) = ty.kind();
diff --git a/clippy_lints/src/functions/too_many_arguments.rs b/clippy_lints/src/functions/too_many_arguments.rs
index 62b1e6bd7ca..63a14d8d4cd 100644
--- a/clippy_lints/src/functions/too_many_arguments.rs
+++ b/clippy_lints/src/functions/too_many_arguments.rs
@@ -49,7 +49,7 @@ pub(super) fn check_trait_item(
         if sig.header.abi == Abi::Rust {
             check_arg_number(
                 cx,
-                &sig.decl,
+                sig.decl,
                 item.span.with_hi(sig.decl.output.span().hi()),
                 too_many_arguments_threshold,
             );
diff --git a/clippy_lints/src/get_last_with_len.rs b/clippy_lints/src/get_last_with_len.rs
index cbcef567c53..3707e792177 100644
--- a/clippy_lints/src/get_last_with_len.rs
+++ b/clippy_lints/src/get_last_with_len.rs
@@ -51,7 +51,7 @@ impl<'tcx> LateLintPass<'tcx> for GetLastWithLen {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if_chain! {
             // Is a method call
-            if let ExprKind::MethodCall(ref path, _, ref args, _) = expr.kind;
+            if let ExprKind::MethodCall(path, _, args, _) = expr.kind;
 
             // Method name is "get"
             if path.ident.name == sym!(get);
diff --git a/clippy_lints/src/identity_op.rs b/clippy_lints/src/identity_op.rs
index 8bed5e1bf64..366b3b46a8a 100644
--- a/clippy_lints/src/identity_op.rs
+++ b/clippy_lints/src/identity_op.rs
@@ -35,7 +35,7 @@ impl<'tcx> LateLintPass<'tcx> for IdentityOp {
         if e.span.from_expansion() {
             return;
         }
-        if let ExprKind::Binary(cmp, ref left, ref right) = e.kind {
+        if let ExprKind::Binary(cmp, left, right) = e.kind {
             if is_allowed(cx, cmp, left, right) {
                 return;
             }
diff --git a/clippy_lints/src/if_let_mutex.rs b/clippy_lints/src/if_let_mutex.rs
index 56dfcc6a506..f661f7ede82 100644
--- a/clippy_lints/src/if_let_mutex.rs
+++ b/clippy_lints/src/if_let_mutex.rs
@@ -55,8 +55,8 @@ impl<'tcx> LateLintPass<'tcx> for IfLetMutex {
             cx,
         };
         if let ExprKind::Match(
-            ref op,
-            ref arms,
+            op,
+            arms,
             MatchSource::IfLetDesugar {
                 contains_else_clause: true,
             },
@@ -64,7 +64,7 @@ impl<'tcx> LateLintPass<'tcx> for IfLetMutex {
         {
             op_visit.visit_expr(op);
             if op_visit.mutex_lock_called {
-                for arm in *arms {
+                for arm in arms {
                     arm_visit.visit_arm(arm);
                 }
 
diff --git a/clippy_lints/src/if_let_some_result.rs b/clippy_lints/src/if_let_some_result.rs
index 6e9280c8c7e..611da3744ee 100644
--- a/clippy_lints/src/if_let_some_result.rs
+++ b/clippy_lints/src/if_let_some_result.rs
@@ -44,9 +44,9 @@ declare_lint_pass!(OkIfLet => [IF_LET_SOME_RESULT]);
 impl<'tcx> LateLintPass<'tcx> for OkIfLet {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if_chain! { //begin checking variables
-            if let ExprKind::Match(ref op, ref body, MatchSource::IfLetDesugar { .. }) = expr.kind; //test if expr is if let
-            if let ExprKind::MethodCall(_, ok_span, ref result_types, _) = op.kind; //check is expr.ok() has type Result<T,E>.ok(, _)
-            if let PatKind::TupleStruct(QPath::Resolved(_, ref x), ref y, _)  = body[0].pat.kind; //get operation
+            if let ExprKind::Match(op, body, MatchSource::IfLetDesugar { .. }) = expr.kind; //test if expr is if let
+            if let ExprKind::MethodCall(_, ok_span, result_types, _) = op.kind; //check is expr.ok() has type Result<T,E>.ok(, _)
+            if let PatKind::TupleStruct(QPath::Resolved(_, x), y, _)  = body[0].pat.kind; //get operation
             if method_chain_args(op, &["ok"]).is_some(); //test to see if using ok() methoduse std::marker::Sized;
             if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&result_types[0]), sym::result_type);
             if rustc_hir_pretty::to_string(rustc_hir_pretty::NO_ANN, |s| s.print_path(x, false)) == "Some";
diff --git a/clippy_lints/src/if_then_some_else_none.rs b/clippy_lints/src/if_then_some_else_none.rs
index 0b5bf060d4c..ee16519692f 100644
--- a/clippy_lints/src/if_then_some_else_none.rs
+++ b/clippy_lints/src/if_then_some_else_none.rs
@@ -72,15 +72,15 @@ impl LateLintPass<'_> for IfThenSomeElseNone {
         }
 
         if_chain! {
-            if let ExprKind::If(ref cond, ref then, Some(ref els)) = expr.kind;
-            if let ExprKind::Block(ref then_block, _) = then.kind;
-            if let Some(ref then_expr) = then_block.expr;
-            if let ExprKind::Call(ref then_call, [then_arg]) = then_expr.kind;
+            if let ExprKind::If(cond, then, Some(els)) = expr.kind;
+            if let ExprKind::Block(then_block, _) = then.kind;
+            if let Some(then_expr) = then_block.expr;
+            if let ExprKind::Call(then_call, [then_arg]) = then_expr.kind;
             if let ExprKind::Path(ref then_call_qpath) = then_call.kind;
             if match_qpath(then_call_qpath, &clippy_utils::paths::OPTION_SOME);
-            if let ExprKind::Block(ref els_block, _) = els.kind;
+            if let ExprKind::Block(els_block, _) = els.kind;
             if els_block.stmts.is_empty();
-            if let Some(ref els_expr) = els_block.expr;
+            if let Some(els_expr) = els_block.expr;
             if let ExprKind::Path(ref els_call_qpath) = els_expr.kind;
             if match_qpath(els_call_qpath, &clippy_utils::paths::OPTION_NONE);
             then {
diff --git a/clippy_lints/src/implicit_hasher.rs b/clippy_lints/src/implicit_hasher.rs
index 0b748b4d72d..77a38544edc 100644
--- a/clippy_lints/src/implicit_hasher.rs
+++ b/clippy_lints/src/implicit_hasher.rs
@@ -207,7 +207,7 @@ enum ImplicitHasherType<'tcx> {
 impl<'tcx> ImplicitHasherType<'tcx> {
     /// Checks that `ty` is a target type without a `BuildHasher`.
     fn new(cx: &LateContext<'tcx>, hir_ty: &hir::Ty<'_>) -> Option<Self> {
-        if let TyKind::Path(QPath::Resolved(None, ref path)) = hir_ty.kind {
+        if let TyKind::Path(QPath::Resolved(None, path)) = hir_ty.kind {
             let params: Vec<_> = path
                 .segments
                 .last()
@@ -330,8 +330,8 @@ impl<'a, 'b, 'tcx> Visitor<'tcx> for ImplicitHasherConstructorVisitor<'a, 'b, 't
 
     fn visit_expr(&mut self, e: &'tcx Expr<'_>) {
         if_chain! {
-            if let ExprKind::Call(ref fun, ref args) = e.kind;
-            if let ExprKind::Path(QPath::TypeRelative(ref ty, ref method)) = fun.kind;
+            if let ExprKind::Call(fun, args) = e.kind;
+            if let ExprKind::Path(QPath::TypeRelative(ty, method)) = fun.kind;
             if let TyKind::Path(QPath::Resolved(None, ty_path)) = ty.kind;
             then {
                 if !TyS::same_type(self.target.ty(), self.maybe_typeck_results.unwrap().expr_ty(e)) {
diff --git a/clippy_lints/src/implicit_return.rs b/clippy_lints/src/implicit_return.rs
index 6863645a92d..6b379b0d59b 100644
--- a/clippy_lints/src/implicit_return.rs
+++ b/clippy_lints/src/implicit_return.rs
@@ -100,10 +100,10 @@ fn expr_match(cx: &LateContext<'_>, expr: &Expr<'_>) {
 
             if check_all_arms {
                 for arm in arms {
-                    expr_match(cx, &arm.body);
+                    expr_match(cx, arm.body);
                 }
             } else {
-                expr_match(cx, &arms.first().expect("`if let` doesn't have a single arm").body);
+                expr_match(cx, arms.first().expect("`if let` doesn't have a single arm").body);
             }
         },
         // skip if it already has a return statement
diff --git a/clippy_lints/src/implicit_saturating_sub.rs b/clippy_lints/src/implicit_saturating_sub.rs
index 5207c628987..cba3183e869 100644
--- a/clippy_lints/src/implicit_saturating_sub.rs
+++ b/clippy_lints/src/implicit_saturating_sub.rs
@@ -46,21 +46,21 @@ impl<'tcx> LateLintPass<'tcx> for ImplicitSaturatingSub {
             if let ExprKind::If(cond, then, None) = &expr.kind;
 
             // Check if the conditional expression is a binary operation
-            if let ExprKind::Binary(ref cond_op, ref cond_left, ref cond_right) = cond.kind;
+            if let ExprKind::Binary(ref cond_op, cond_left, cond_right) = cond.kind;
 
             // Ensure that the binary operator is >, != and <
             if BinOpKind::Ne == cond_op.node || BinOpKind::Gt == cond_op.node || BinOpKind::Lt == cond_op.node;
 
             // Check if the true condition block has only one statement
-            if let ExprKind::Block(ref block, _) = then.kind;
+            if let ExprKind::Block(block, _) = then.kind;
             if block.stmts.len() == 1 && block.expr.is_none();
 
             // Check if assign operation is done
-            if let StmtKind::Semi(ref e) = block.stmts[0].kind;
+            if let StmtKind::Semi(e) = block.stmts[0].kind;
             if let Some(target) = subtracts_one(cx, e);
 
             // Extracting out the variable name
-            if let ExprKind::Path(QPath::Resolved(_, ref ares_path)) = target.kind;
+            if let ExprKind::Path(QPath::Resolved(_, ares_path)) = target.kind;
 
             then {
                 // Handle symmetric conditions in the if statement
@@ -104,7 +104,7 @@ impl<'tcx> LateLintPass<'tcx> for ImplicitSaturatingSub {
                             print_lint_and_sugg(cx, &var_name, expr);
                         };
                     },
-                    ExprKind::Call(ref func, _) => {
+                    ExprKind::Call(func, _) => {
                         if let ExprKind::Path(ref cond_num_path) = func.kind {
                             if INT_TYPES.iter().any(|int_type| match_qpath(cond_num_path, &[int_type, "min_value"])) {
                                 print_lint_and_sugg(cx, &var_name, expr);
@@ -120,7 +120,7 @@ impl<'tcx> LateLintPass<'tcx> for ImplicitSaturatingSub {
 
 fn subtracts_one<'a>(cx: &LateContext<'_>, expr: &Expr<'a>) -> Option<&'a Expr<'a>> {
     match expr.kind {
-        ExprKind::AssignOp(ref op1, ref target, ref value) => {
+        ExprKind::AssignOp(ref op1, target, value) => {
             if_chain! {
                 if BinOpKind::Sub == op1.node;
                 // Check if literal being subtracted is one
@@ -133,9 +133,9 @@ fn subtracts_one<'a>(cx: &LateContext<'_>, expr: &Expr<'a>) -> Option<&'a Expr<'
                 }
             }
         },
-        ExprKind::Assign(ref target, ref value, _) => {
+        ExprKind::Assign(target, value, _) => {
             if_chain! {
-                if let ExprKind::Binary(ref op1, ref left1, ref right1) = value.kind;
+                if let ExprKind::Binary(ref op1, left1, right1) = value.kind;
                 if BinOpKind::Sub == op1.node;
 
                 if SpanlessEq::new(cx).eq_expr(left1, target);
diff --git a/clippy_lints/src/indexing_slicing.rs b/clippy_lints/src/indexing_slicing.rs
index 94d39019608..1c54599abc4 100644
--- a/clippy_lints/src/indexing_slicing.rs
+++ b/clippy_lints/src/indexing_slicing.rs
@@ -88,7 +88,7 @@ declare_lint_pass!(IndexingSlicing => [INDEXING_SLICING, OUT_OF_BOUNDS_INDEXING]
 
 impl<'tcx> LateLintPass<'tcx> for IndexingSlicing {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if let ExprKind::Index(ref array, ref index) = &expr.kind {
+        if let ExprKind::Index(array, index) = &expr.kind {
             let ty = cx.typeck_results().expr_ty(array).peel_refs();
             if let Some(range) = higher::range(index) {
                 // Ranged indexes, i.e., &x[n..m], &x[n..], &x[..n] and &x[..]
diff --git a/clippy_lints/src/infinite_iter.rs b/clippy_lints/src/infinite_iter.rs
index fb35bc1e780..bbb4ddc613a 100644
--- a/clippy_lints/src/infinite_iter.rs
+++ b/clippy_lints/src/infinite_iter.rs
@@ -139,7 +139,7 @@ const HEURISTICS: [(&str, usize, Heuristic, Finiteness); 19] = [
 
 fn is_infinite(cx: &LateContext<'_>, expr: &Expr<'_>) -> Finiteness {
     match expr.kind {
-        ExprKind::MethodCall(ref method, _, ref args, _) => {
+        ExprKind::MethodCall(method, _, args, _) => {
             for &(name, len, heuristic, cap) in &HEURISTICS {
                 if method.ident.name.as_str() == name && args.len() == len {
                     return (match heuristic {
@@ -159,9 +159,9 @@ fn is_infinite(cx: &LateContext<'_>, expr: &Expr<'_>) -> Finiteness {
             }
             Finite
         },
-        ExprKind::Block(ref block, _) => block.expr.as_ref().map_or(Finite, |e| is_infinite(cx, e)),
-        ExprKind::Box(ref e) | ExprKind::AddrOf(BorrowKind::Ref, _, ref e) => is_infinite(cx, e),
-        ExprKind::Call(ref path, _) => {
+        ExprKind::Block(block, _) => block.expr.as_ref().map_or(Finite, |e| is_infinite(cx, e)),
+        ExprKind::Box(e) | ExprKind::AddrOf(BorrowKind::Ref, _, e) => is_infinite(cx, e),
+        ExprKind::Call(path, _) => {
             if let ExprKind::Path(ref qpath) = path.kind {
                 match_qpath(qpath, &paths::REPEAT).into()
             } else {
@@ -215,7 +215,7 @@ const INFINITE_COLLECTORS: [&[&str]; 8] = [
 
 fn complete_infinite_iter(cx: &LateContext<'_>, expr: &Expr<'_>) -> Finiteness {
     match expr.kind {
-        ExprKind::MethodCall(ref method, _, ref args, _) => {
+        ExprKind::MethodCall(method, _, args, _) => {
             for &(name, len) in &COMPLETING_METHODS {
                 if method.ident.name.as_str() == name && args.len() == len {
                     return is_infinite(cx, &args[0]);
@@ -240,7 +240,7 @@ fn complete_infinite_iter(cx: &LateContext<'_>, expr: &Expr<'_>) -> Finiteness {
                 }
             }
         },
-        ExprKind::Binary(op, ref l, ref r) => {
+        ExprKind::Binary(op, l, r) => {
             if op.node.is_comparison() {
                 return is_infinite(cx, l).and(is_infinite(cx, r)).and(MaybeInfinite);
             }
diff --git a/clippy_lints/src/invalid_upcast_comparisons.rs b/clippy_lints/src/invalid_upcast_comparisons.rs
index d183fc41f31..c67c02eefa5 100644
--- a/clippy_lints/src/invalid_upcast_comparisons.rs
+++ b/clippy_lints/src/invalid_upcast_comparisons.rs
@@ -86,7 +86,7 @@ impl Ord for FullInt {
 }
 
 fn numeric_cast_precast_bounds<'a>(cx: &LateContext<'_>, expr: &'a Expr<'_>) -> Option<(FullInt, FullInt)> {
-    if let ExprKind::Cast(ref cast_exp, _) = expr.kind {
+    if let ExprKind::Cast(cast_exp, _) = expr.kind {
         let pre_cast_ty = cx.typeck_results().expr_ty(cast_exp);
         let cast_ty = cx.typeck_results().expr_ty(expr);
         // if it's a cast from i32 to u32 wrapping will invalidate all these checks
@@ -131,7 +131,7 @@ fn node_as_const_fullint<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) ->
 }
 
 fn err_upcast_comparison(cx: &LateContext<'_>, span: Span, expr: &Expr<'_>, always: bool) {
-    if let ExprKind::Cast(ref cast_val, _) = expr.kind {
+    if let ExprKind::Cast(cast_val, _) = expr.kind {
         span_lint(
             cx,
             INVALID_UPCAST_COMPARISONS,
@@ -203,7 +203,7 @@ fn upcast_comparison_bounds_err<'tcx>(
 
 impl<'tcx> LateLintPass<'tcx> for InvalidUpcastComparisons {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if let ExprKind::Binary(ref cmp, ref lhs, ref rhs) = expr.kind {
+        if let ExprKind::Binary(ref cmp, lhs, rhs) = expr.kind {
             let normalized = comparisons::normalize_comparison(cmp.node, lhs, rhs);
             let (rel, normalized_lhs, normalized_rhs) = if let Some(val) = normalized {
                 val
diff --git a/clippy_lints/src/large_enum_variant.rs b/clippy_lints/src/large_enum_variant.rs
index 76584dc1822..f166748d86b 100644
--- a/clippy_lints/src/large_enum_variant.rs
+++ b/clippy_lints/src/large_enum_variant.rs
@@ -113,7 +113,7 @@ impl<'tcx> LateLintPass<'tcx> for LargeEnumVariant {
                             );
                             if variant.fields.len() == 1 {
                                 let span = match def.variants[i].data {
-                                    VariantData::Struct(ref fields, ..) | VariantData::Tuple(ref fields, ..) => {
+                                    VariantData::Struct(fields, ..) | VariantData::Tuple(fields, ..) => {
                                         fields[0].ty.span
                                     },
                                     VariantData::Unit(..) => unreachable!(),
diff --git a/clippy_lints/src/len_zero.rs b/clippy_lints/src/len_zero.rs
index 78152ad9019..bb57adff7be 100644
--- a/clippy_lints/src/len_zero.rs
+++ b/clippy_lints/src/len_zero.rs
@@ -121,7 +121,7 @@ impl<'tcx> LateLintPass<'tcx> for LenZero {
             return;
         }
 
-        if let ItemKind::Trait(_, _, _, _, ref trait_items) = item.kind {
+        if let ItemKind::Trait(_, _, _, _, trait_items) = item.kind {
             check_trait_items(cx, item, trait_items);
         }
     }
@@ -162,7 +162,7 @@ impl<'tcx> LateLintPass<'tcx> for LenZero {
             return;
         }
 
-        if let ExprKind::Binary(Spanned { node: cmp, .. }, ref left, ref right) = expr.kind {
+        if let ExprKind::Binary(Spanned { node: cmp, .. }, left, right) = expr.kind {
             match cmp {
                 BinOpKind::Eq => {
                     check_cmp(cx, expr.span, left, right, "", 0); // len == 0
@@ -372,8 +372,7 @@ fn check_for_is_empty(
 }
 
 fn check_cmp(cx: &LateContext<'_>, span: Span, method: &Expr<'_>, lit: &Expr<'_>, op: &str, compare_to: u32) {
-    if let (&ExprKind::MethodCall(ref method_path, _, ref args, _), &ExprKind::Lit(ref lit)) = (&method.kind, &lit.kind)
-    {
+    if let (&ExprKind::MethodCall(method_path, _, args, _), &ExprKind::Lit(ref lit)) = (&method.kind, &lit.kind) {
         // check if we are in an is_empty() method
         if let Some(name) = get_item_name(cx, method) {
             if name.as_str() == "is_empty" {
@@ -451,7 +450,7 @@ fn is_empty_string(expr: &Expr<'_>) -> bool {
 }
 
 fn is_empty_array(expr: &Expr<'_>) -> bool {
-    if let ExprKind::Array(ref arr) = expr.kind {
+    if let ExprKind::Array(arr) = expr.kind {
         return arr.is_empty();
     }
     false
@@ -480,17 +479,17 @@ fn has_is_empty(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
             cx.tcx
                 .associated_items(*imp)
                 .in_definition_order()
-                .any(|item| is_is_empty(cx, &item))
+                .any(|item| is_is_empty(cx, item))
         })
     }
 
     let ty = &cx.typeck_results().expr_ty(expr).peel_refs();
     match ty.kind() {
-        ty::Dynamic(ref tt, ..) => tt.principal().map_or(false, |principal| {
+        ty::Dynamic(tt, ..) => tt.principal().map_or(false, |principal| {
             cx.tcx
                 .associated_items(principal.def_id())
                 .in_definition_order()
-                .any(|item| is_is_empty(cx, &item))
+                .any(|item| is_is_empty(cx, item))
         }),
         ty::Projection(ref proj) => has_is_empty_impl(cx, proj.item_def_id),
         ty::Adt(id, _) => has_is_empty_impl(cx, id.did),
diff --git a/clippy_lints/src/let_if_seq.rs b/clippy_lints/src/let_if_seq.rs
index 2d7d9c9befb..67eae4d87bb 100644
--- a/clippy_lints/src/let_if_seq.rs
+++ b/clippy_lints/src/let_if_seq.rs
@@ -61,13 +61,13 @@ impl<'tcx> LateLintPass<'tcx> for LetIfSeq {
         while let Some(stmt) = it.next() {
             if_chain! {
                 if let Some(expr) = it.peek();
-                if let hir::StmtKind::Local(ref local) = stmt.kind;
+                if let hir::StmtKind::Local(local) = stmt.kind;
                 if let hir::PatKind::Binding(mode, canonical_id, ident, None) = local.pat.kind;
-                if let hir::StmtKind::Expr(ref if_) = expr.kind;
-                if let hir::ExprKind::If(ref cond, ref then, ref else_) = if_.kind;
+                if let hir::StmtKind::Expr(if_) = expr.kind;
+                if let hir::ExprKind::If(cond, then, ref else_) = if_.kind;
                 let mut used_visitor = LocalUsedVisitor::new(cx, canonical_id);
                 if !used_visitor.check_expr(cond);
-                if let hir::ExprKind::Block(ref then, _) = then.kind;
+                if let hir::ExprKind::Block(then, _) = then.kind;
                 if let Some(value) = check_assign(cx, canonical_id, &*then);
                 if !used_visitor.check_expr(value);
                 then {
@@ -79,20 +79,20 @@ impl<'tcx> LateLintPass<'tcx> for LetIfSeq {
                     );
                     if has_interior_mutability { return; }
 
-                    let (default_multi_stmts, default) = if let Some(ref else_) = *else_ {
-                        if let hir::ExprKind::Block(ref else_, _) = else_.kind {
+                    let (default_multi_stmts, default) = if let Some(else_) = *else_ {
+                        if let hir::ExprKind::Block(else_, _) = else_.kind {
                             if let Some(default) = check_assign(cx, canonical_id, else_) {
                                 (else_.stmts.len() > 1, default)
-                            } else if let Some(ref default) = local.init {
-                                (true, &**default)
+                            } else if let Some(default) = local.init {
+                                (true, default)
                             } else {
                                 continue;
                             }
                         } else {
                             continue;
                         }
-                    } else if let Some(ref default) = local.init {
-                        (false, &**default)
+                    } else if let Some(default) = local.init {
+                        (false, default)
                     } else {
                         continue;
                     };
@@ -144,8 +144,8 @@ fn check_assign<'tcx>(
     if_chain! {
         if block.expr.is_none();
         if let Some(expr) = block.stmts.iter().last();
-        if let hir::StmtKind::Semi(ref expr) = expr.kind;
-        if let hir::ExprKind::Assign(ref var, ref value, _) = expr.kind;
+        if let hir::StmtKind::Semi(expr) = expr.kind;
+        if let hir::ExprKind::Assign(var, value, _) = expr.kind;
         if path_to_local_id(var, decl);
         then {
             let mut v = LocalUsedVisitor::new(cx, decl);
diff --git a/clippy_lints/src/let_underscore.rs b/clippy_lints/src/let_underscore.rs
index 7e3a76ded2c..17e23781db7 100644
--- a/clippy_lints/src/let_underscore.rs
+++ b/clippy_lints/src/let_underscore.rs
@@ -116,7 +116,7 @@ impl<'tcx> LateLintPass<'tcx> for LetUnderscore {
 
         if_chain! {
             if let PatKind::Wild = local.pat.kind;
-            if let Some(ref init) = local.init;
+            if let Some(init) = local.init;
             then {
                 let init_ty = cx.typeck_results().expr_ty(init);
                 let contains_sync_guard = init_ty.walk().any(|inner| match inner.unpack() {
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 43e89c2475f..cd92b551abd 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -541,482 +541,482 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     // begin register lints, do not remove this comment, it’s used in `update_lints`
     store.register_lints(&[
         #[cfg(feature = "internal-lints")]
-        &utils::internal_lints::CLIPPY_LINTS_INTERNAL,
+        utils::internal_lints::CLIPPY_LINTS_INTERNAL,
         #[cfg(feature = "internal-lints")]
-        &utils::internal_lints::COLLAPSIBLE_SPAN_LINT_CALLS,
+        utils::internal_lints::COLLAPSIBLE_SPAN_LINT_CALLS,
         #[cfg(feature = "internal-lints")]
-        &utils::internal_lints::COMPILER_LINT_FUNCTIONS,
+        utils::internal_lints::COMPILER_LINT_FUNCTIONS,
         #[cfg(feature = "internal-lints")]
-        &utils::internal_lints::DEFAULT_LINT,
+        utils::internal_lints::DEFAULT_LINT,
         #[cfg(feature = "internal-lints")]
-        &utils::internal_lints::IF_CHAIN_STYLE,
+        utils::internal_lints::IF_CHAIN_STYLE,
         #[cfg(feature = "internal-lints")]
-        &utils::internal_lints::INTERNING_DEFINED_SYMBOL,
+        utils::internal_lints::INTERNING_DEFINED_SYMBOL,
         #[cfg(feature = "internal-lints")]
-        &utils::internal_lints::INVALID_PATHS,
+        utils::internal_lints::INVALID_PATHS,
         #[cfg(feature = "internal-lints")]
-        &utils::internal_lints::LINT_WITHOUT_LINT_PASS,
+        utils::internal_lints::LINT_WITHOUT_LINT_PASS,
         #[cfg(feature = "internal-lints")]
-        &utils::internal_lints::MATCH_TYPE_ON_DIAGNOSTIC_ITEM,
+        utils::internal_lints::MATCH_TYPE_ON_DIAGNOSTIC_ITEM,
         #[cfg(feature = "internal-lints")]
-        &utils::internal_lints::OUTER_EXPN_EXPN_DATA,
+        utils::internal_lints::OUTER_EXPN_EXPN_DATA,
         #[cfg(feature = "internal-lints")]
-        &utils::internal_lints::PRODUCE_ICE,
+        utils::internal_lints::PRODUCE_ICE,
         #[cfg(feature = "internal-lints")]
-        &utils::internal_lints::UNNECESSARY_SYMBOL_STR,
-        &absurd_extreme_comparisons::ABSURD_EXTREME_COMPARISONS,
-        &approx_const::APPROX_CONSTANT,
-        &arithmetic::FLOAT_ARITHMETIC,
-        &arithmetic::INTEGER_ARITHMETIC,
-        &as_conversions::AS_CONVERSIONS,
-        &asm_syntax::INLINE_ASM_X86_ATT_SYNTAX,
-        &asm_syntax::INLINE_ASM_X86_INTEL_SYNTAX,
-        &assertions_on_constants::ASSERTIONS_ON_CONSTANTS,
-        &assign_ops::ASSIGN_OP_PATTERN,
-        &assign_ops::MISREFACTORED_ASSIGN_OP,
-        &async_yields_async::ASYNC_YIELDS_ASYNC,
-        &atomic_ordering::INVALID_ATOMIC_ORDERING,
-        &attrs::BLANKET_CLIPPY_RESTRICTION_LINTS,
-        &attrs::DEPRECATED_CFG_ATTR,
-        &attrs::DEPRECATED_SEMVER,
-        &attrs::EMPTY_LINE_AFTER_OUTER_ATTR,
-        &attrs::INLINE_ALWAYS,
-        &attrs::MISMATCHED_TARGET_OS,
-        &attrs::USELESS_ATTRIBUTE,
-        &await_holding_invalid::AWAIT_HOLDING_LOCK,
-        &await_holding_invalid::AWAIT_HOLDING_REFCELL_REF,
-        &bit_mask::BAD_BIT_MASK,
-        &bit_mask::INEFFECTIVE_BIT_MASK,
-        &bit_mask::VERBOSE_BIT_MASK,
-        &blacklisted_name::BLACKLISTED_NAME,
-        &blocks_in_if_conditions::BLOCKS_IN_IF_CONDITIONS,
-        &booleans::LOGIC_BUG,
-        &booleans::NONMINIMAL_BOOL,
-        &bytecount::NAIVE_BYTECOUNT,
-        &cargo_common_metadata::CARGO_COMMON_METADATA,
-        &case_sensitive_file_extension_comparisons::CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS,
-        &casts::CAST_LOSSLESS,
-        &casts::CAST_POSSIBLE_TRUNCATION,
-        &casts::CAST_POSSIBLE_WRAP,
-        &casts::CAST_PRECISION_LOSS,
-        &casts::CAST_PTR_ALIGNMENT,
-        &casts::CAST_REF_TO_MUT,
-        &casts::CAST_SIGN_LOSS,
-        &casts::CHAR_LIT_AS_U8,
-        &casts::FN_TO_NUMERIC_CAST,
-        &casts::FN_TO_NUMERIC_CAST_WITH_TRUNCATION,
-        &casts::PTR_AS_PTR,
-        &casts::UNNECESSARY_CAST,
-        &checked_conversions::CHECKED_CONVERSIONS,
-        &cognitive_complexity::COGNITIVE_COMPLEXITY,
-        &collapsible_if::COLLAPSIBLE_ELSE_IF,
-        &collapsible_if::COLLAPSIBLE_IF,
-        &collapsible_match::COLLAPSIBLE_MATCH,
-        &comparison_chain::COMPARISON_CHAIN,
-        &copies::BRANCHES_SHARING_CODE,
-        &copies::IFS_SAME_COND,
-        &copies::IF_SAME_THEN_ELSE,
-        &copies::SAME_FUNCTIONS_IN_IF_CONDITION,
-        &copy_iterator::COPY_ITERATOR,
-        &create_dir::CREATE_DIR,
-        &dbg_macro::DBG_MACRO,
-        &default::DEFAULT_TRAIT_ACCESS,
-        &default::FIELD_REASSIGN_WITH_DEFAULT,
-        &default_numeric_fallback::DEFAULT_NUMERIC_FALLBACK,
-        &dereference::EXPLICIT_DEREF_METHODS,
-        &derive::DERIVE_HASH_XOR_EQ,
-        &derive::DERIVE_ORD_XOR_PARTIAL_ORD,
-        &derive::EXPL_IMPL_CLONE_ON_COPY,
-        &derive::UNSAFE_DERIVE_DESERIALIZE,
-        &disallowed_method::DISALLOWED_METHOD,
-        &doc::DOC_MARKDOWN,
-        &doc::MISSING_ERRORS_DOC,
-        &doc::MISSING_PANICS_DOC,
-        &doc::MISSING_SAFETY_DOC,
-        &doc::NEEDLESS_DOCTEST_MAIN,
-        &double_comparison::DOUBLE_COMPARISONS,
-        &double_parens::DOUBLE_PARENS,
-        &drop_forget_ref::DROP_COPY,
-        &drop_forget_ref::DROP_REF,
-        &drop_forget_ref::FORGET_COPY,
-        &drop_forget_ref::FORGET_REF,
-        &duration_subsec::DURATION_SUBSEC,
-        &else_if_without_else::ELSE_IF_WITHOUT_ELSE,
-        &empty_enum::EMPTY_ENUM,
-        &entry::MAP_ENTRY,
-        &enum_clike::ENUM_CLIKE_UNPORTABLE_VARIANT,
-        &enum_variants::ENUM_VARIANT_NAMES,
-        &enum_variants::MODULE_INCEPTION,
-        &enum_variants::MODULE_NAME_REPETITIONS,
-        &enum_variants::PUB_ENUM_VARIANT_NAMES,
-        &eq_op::EQ_OP,
-        &eq_op::OP_REF,
-        &erasing_op::ERASING_OP,
-        &escape::BOXED_LOCAL,
-        &eta_reduction::REDUNDANT_CLOSURE,
-        &eta_reduction::REDUNDANT_CLOSURE_FOR_METHOD_CALLS,
-        &eval_order_dependence::DIVERGING_SUB_EXPRESSION,
-        &eval_order_dependence::EVAL_ORDER_DEPENDENCE,
-        &excessive_bools::FN_PARAMS_EXCESSIVE_BOOLS,
-        &excessive_bools::STRUCT_EXCESSIVE_BOOLS,
-        &exhaustive_items::EXHAUSTIVE_ENUMS,
-        &exhaustive_items::EXHAUSTIVE_STRUCTS,
-        &exit::EXIT,
-        &explicit_write::EXPLICIT_WRITE,
-        &fallible_impl_from::FALLIBLE_IMPL_FROM,
-        &float_equality_without_abs::FLOAT_EQUALITY_WITHOUT_ABS,
-        &float_literal::EXCESSIVE_PRECISION,
-        &float_literal::LOSSY_FLOAT_LITERAL,
-        &floating_point_arithmetic::IMPRECISE_FLOPS,
-        &floating_point_arithmetic::SUBOPTIMAL_FLOPS,
-        &format::USELESS_FORMAT,
-        &formatting::POSSIBLE_MISSING_COMMA,
-        &formatting::SUSPICIOUS_ASSIGNMENT_FORMATTING,
-        &formatting::SUSPICIOUS_ELSE_FORMATTING,
-        &formatting::SUSPICIOUS_UNARY_OP_FORMATTING,
-        &from_over_into::FROM_OVER_INTO,
-        &from_str_radix_10::FROM_STR_RADIX_10,
-        &functions::DOUBLE_MUST_USE,
-        &functions::MUST_USE_CANDIDATE,
-        &functions::MUST_USE_UNIT,
-        &functions::NOT_UNSAFE_PTR_ARG_DEREF,
-        &functions::RESULT_UNIT_ERR,
-        &functions::TOO_MANY_ARGUMENTS,
-        &functions::TOO_MANY_LINES,
-        &future_not_send::FUTURE_NOT_SEND,
-        &get_last_with_len::GET_LAST_WITH_LEN,
-        &identity_op::IDENTITY_OP,
-        &if_let_mutex::IF_LET_MUTEX,
-        &if_let_some_result::IF_LET_SOME_RESULT,
-        &if_not_else::IF_NOT_ELSE,
-        &if_then_some_else_none::IF_THEN_SOME_ELSE_NONE,
-        &implicit_hasher::IMPLICIT_HASHER,
-        &implicit_return::IMPLICIT_RETURN,
-        &implicit_saturating_sub::IMPLICIT_SATURATING_SUB,
-        &inconsistent_struct_constructor::INCONSISTENT_STRUCT_CONSTRUCTOR,
-        &indexing_slicing::INDEXING_SLICING,
-        &indexing_slicing::OUT_OF_BOUNDS_INDEXING,
-        &infinite_iter::INFINITE_ITER,
-        &infinite_iter::MAYBE_INFINITE_ITER,
-        &inherent_impl::MULTIPLE_INHERENT_IMPL,
-        &inherent_to_string::INHERENT_TO_STRING,
-        &inherent_to_string::INHERENT_TO_STRING_SHADOW_DISPLAY,
-        &inline_fn_without_body::INLINE_FN_WITHOUT_BODY,
-        &int_plus_one::INT_PLUS_ONE,
-        &integer_division::INTEGER_DIVISION,
-        &invalid_upcast_comparisons::INVALID_UPCAST_COMPARISONS,
-        &items_after_statements::ITEMS_AFTER_STATEMENTS,
-        &large_const_arrays::LARGE_CONST_ARRAYS,
-        &large_enum_variant::LARGE_ENUM_VARIANT,
-        &large_stack_arrays::LARGE_STACK_ARRAYS,
-        &len_zero::COMPARISON_TO_EMPTY,
-        &len_zero::LEN_WITHOUT_IS_EMPTY,
-        &len_zero::LEN_ZERO,
-        &let_if_seq::USELESS_LET_IF_SEQ,
-        &let_underscore::LET_UNDERSCORE_DROP,
-        &let_underscore::LET_UNDERSCORE_LOCK,
-        &let_underscore::LET_UNDERSCORE_MUST_USE,
-        &lifetimes::EXTRA_UNUSED_LIFETIMES,
-        &lifetimes::NEEDLESS_LIFETIMES,
-        &literal_representation::DECIMAL_LITERAL_REPRESENTATION,
-        &literal_representation::INCONSISTENT_DIGIT_GROUPING,
-        &literal_representation::LARGE_DIGIT_GROUPS,
-        &literal_representation::MISTYPED_LITERAL_SUFFIXES,
-        &literal_representation::UNREADABLE_LITERAL,
-        &literal_representation::UNUSUAL_BYTE_GROUPINGS,
-        &loops::EMPTY_LOOP,
-        &loops::EXPLICIT_COUNTER_LOOP,
-        &loops::EXPLICIT_INTO_ITER_LOOP,
-        &loops::EXPLICIT_ITER_LOOP,
-        &loops::FOR_KV_MAP,
-        &loops::FOR_LOOPS_OVER_FALLIBLES,
-        &loops::ITER_NEXT_LOOP,
-        &loops::MANUAL_FLATTEN,
-        &loops::MANUAL_MEMCPY,
-        &loops::MUT_RANGE_BOUND,
-        &loops::NEEDLESS_COLLECT,
-        &loops::NEEDLESS_RANGE_LOOP,
-        &loops::NEVER_LOOP,
-        &loops::SAME_ITEM_PUSH,
-        &loops::SINGLE_ELEMENT_LOOP,
-        &loops::WHILE_IMMUTABLE_CONDITION,
-        &loops::WHILE_LET_LOOP,
-        &loops::WHILE_LET_ON_ITERATOR,
-        &macro_use::MACRO_USE_IMPORTS,
-        &main_recursion::MAIN_RECURSION,
-        &manual_async_fn::MANUAL_ASYNC_FN,
-        &manual_map::MANUAL_MAP,
-        &manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE,
-        &manual_ok_or::MANUAL_OK_OR,
-        &manual_strip::MANUAL_STRIP,
-        &manual_unwrap_or::MANUAL_UNWRAP_OR,
-        &map_clone::MAP_CLONE,
-        &map_err_ignore::MAP_ERR_IGNORE,
-        &map_identity::MAP_IDENTITY,
-        &map_unit_fn::OPTION_MAP_UNIT_FN,
-        &map_unit_fn::RESULT_MAP_UNIT_FN,
-        &match_on_vec_items::MATCH_ON_VEC_ITEMS,
-        &matches::INFALLIBLE_DESTRUCTURING_MATCH,
-        &matches::MATCH_AS_REF,
-        &matches::MATCH_BOOL,
-        &matches::MATCH_LIKE_MATCHES_MACRO,
-        &matches::MATCH_OVERLAPPING_ARM,
-        &matches::MATCH_REF_PATS,
-        &matches::MATCH_SAME_ARMS,
-        &matches::MATCH_SINGLE_BINDING,
-        &matches::MATCH_WILDCARD_FOR_SINGLE_VARIANTS,
-        &matches::MATCH_WILD_ERR_ARM,
-        &matches::REDUNDANT_PATTERN_MATCHING,
-        &matches::REST_PAT_IN_FULLY_BOUND_STRUCTS,
-        &matches::SINGLE_MATCH,
-        &matches::SINGLE_MATCH_ELSE,
-        &matches::WILDCARD_ENUM_MATCH_ARM,
-        &matches::WILDCARD_IN_OR_PATTERNS,
-        &mem_discriminant::MEM_DISCRIMINANT_NON_ENUM,
-        &mem_forget::MEM_FORGET,
-        &mem_replace::MEM_REPLACE_OPTION_WITH_NONE,
-        &mem_replace::MEM_REPLACE_WITH_DEFAULT,
-        &mem_replace::MEM_REPLACE_WITH_UNINIT,
-        &methods::BIND_INSTEAD_OF_MAP,
-        &methods::BYTES_NTH,
-        &methods::CHARS_LAST_CMP,
-        &methods::CHARS_NEXT_CMP,
-        &methods::CLONE_DOUBLE_REF,
-        &methods::CLONE_ON_COPY,
-        &methods::CLONE_ON_REF_PTR,
-        &methods::EXPECT_FUN_CALL,
-        &methods::EXPECT_USED,
-        &methods::FILETYPE_IS_FILE,
-        &methods::FILTER_MAP,
-        &methods::FILTER_MAP_IDENTITY,
-        &methods::FILTER_MAP_NEXT,
-        &methods::FILTER_NEXT,
-        &methods::FLAT_MAP_IDENTITY,
-        &methods::FROM_ITER_INSTEAD_OF_COLLECT,
-        &methods::GET_UNWRAP,
-        &methods::IMPLICIT_CLONE,
-        &methods::INEFFICIENT_TO_STRING,
-        &methods::INSPECT_FOR_EACH,
-        &methods::INTO_ITER_ON_REF,
-        &methods::ITERATOR_STEP_BY_ZERO,
-        &methods::ITER_CLONED_COLLECT,
-        &methods::ITER_COUNT,
-        &methods::ITER_NEXT_SLICE,
-        &methods::ITER_NTH,
-        &methods::ITER_NTH_ZERO,
-        &methods::ITER_SKIP_NEXT,
-        &methods::MANUAL_FILTER_MAP,
-        &methods::MANUAL_FIND_MAP,
-        &methods::MANUAL_SATURATING_ARITHMETIC,
-        &methods::MAP_COLLECT_RESULT_UNIT,
-        &methods::MAP_FLATTEN,
-        &methods::MAP_UNWRAP_OR,
-        &methods::NEW_RET_NO_SELF,
-        &methods::OK_EXPECT,
-        &methods::OPTION_AS_REF_DEREF,
-        &methods::OPTION_FILTER_MAP,
-        &methods::OPTION_MAP_OR_NONE,
-        &methods::OR_FUN_CALL,
-        &methods::RESULT_MAP_OR_INTO_OPTION,
-        &methods::SEARCH_IS_SOME,
-        &methods::SHOULD_IMPLEMENT_TRAIT,
-        &methods::SINGLE_CHAR_ADD_STR,
-        &methods::SINGLE_CHAR_PATTERN,
-        &methods::SKIP_WHILE_NEXT,
-        &methods::STRING_EXTEND_CHARS,
-        &methods::SUSPICIOUS_MAP,
-        &methods::UNINIT_ASSUMED_INIT,
-        &methods::UNNECESSARY_FILTER_MAP,
-        &methods::UNNECESSARY_FOLD,
-        &methods::UNNECESSARY_LAZY_EVALUATIONS,
-        &methods::UNWRAP_USED,
-        &methods::USELESS_ASREF,
-        &methods::WRONG_PUB_SELF_CONVENTION,
-        &methods::WRONG_SELF_CONVENTION,
-        &methods::ZST_OFFSET,
-        &minmax::MIN_MAX,
-        &misc::CMP_NAN,
-        &misc::CMP_OWNED,
-        &misc::FLOAT_CMP,
-        &misc::FLOAT_CMP_CONST,
-        &misc::MODULO_ONE,
-        &misc::SHORT_CIRCUIT_STATEMENT,
-        &misc::TOPLEVEL_REF_ARG,
-        &misc::USED_UNDERSCORE_BINDING,
-        &misc::ZERO_PTR,
-        &misc_early::BUILTIN_TYPE_SHADOW,
-        &misc_early::DOUBLE_NEG,
-        &misc_early::DUPLICATE_UNDERSCORE_ARGUMENT,
-        &misc_early::MIXED_CASE_HEX_LITERALS,
-        &misc_early::REDUNDANT_PATTERN,
-        &misc_early::UNNEEDED_FIELD_PATTERN,
-        &misc_early::UNNEEDED_WILDCARD_PATTERN,
-        &misc_early::UNSEPARATED_LITERAL_SUFFIX,
-        &misc_early::ZERO_PREFIXED_LITERAL,
-        &missing_const_for_fn::MISSING_CONST_FOR_FN,
-        &missing_doc::MISSING_DOCS_IN_PRIVATE_ITEMS,
-        &missing_inline::MISSING_INLINE_IN_PUBLIC_ITEMS,
-        &modulo_arithmetic::MODULO_ARITHMETIC,
-        &multiple_crate_versions::MULTIPLE_CRATE_VERSIONS,
-        &mut_key::MUTABLE_KEY_TYPE,
-        &mut_mut::MUT_MUT,
-        &mut_mutex_lock::MUT_MUTEX_LOCK,
-        &mut_reference::UNNECESSARY_MUT_PASSED,
-        &mutable_debug_assertion::DEBUG_ASSERT_WITH_MUT_CALL,
-        &mutex_atomic::MUTEX_ATOMIC,
-        &mutex_atomic::MUTEX_INTEGER,
-        &needless_arbitrary_self_type::NEEDLESS_ARBITRARY_SELF_TYPE,
-        &needless_bool::BOOL_COMPARISON,
-        &needless_bool::NEEDLESS_BOOL,
-        &needless_borrow::NEEDLESS_BORROW,
-        &needless_borrowed_ref::NEEDLESS_BORROWED_REFERENCE,
-        &needless_continue::NEEDLESS_CONTINUE,
-        &needless_for_each::NEEDLESS_FOR_EACH,
-        &needless_pass_by_value::NEEDLESS_PASS_BY_VALUE,
-        &needless_question_mark::NEEDLESS_QUESTION_MARK,
-        &needless_update::NEEDLESS_UPDATE,
-        &neg_cmp_op_on_partial_ord::NEG_CMP_OP_ON_PARTIAL_ORD,
-        &neg_multiply::NEG_MULTIPLY,
-        &new_without_default::NEW_WITHOUT_DEFAULT,
-        &no_effect::NO_EFFECT,
-        &no_effect::UNNECESSARY_OPERATION,
-        &non_copy_const::BORROW_INTERIOR_MUTABLE_CONST,
-        &non_copy_const::DECLARE_INTERIOR_MUTABLE_CONST,
-        &non_expressive_names::JUST_UNDERSCORES_AND_DIGITS,
-        &non_expressive_names::MANY_SINGLE_CHAR_NAMES,
-        &non_expressive_names::SIMILAR_NAMES,
-        &non_octal_unix_permissions::NON_OCTAL_UNIX_PERMISSIONS,
-        &open_options::NONSENSICAL_OPEN_OPTIONS,
-        &option_env_unwrap::OPTION_ENV_UNWRAP,
-        &option_if_let_else::OPTION_IF_LET_ELSE,
-        &overflow_check_conditional::OVERFLOW_CHECK_CONDITIONAL,
-        &panic_in_result_fn::PANIC_IN_RESULT_FN,
-        &panic_unimplemented::PANIC,
-        &panic_unimplemented::TODO,
-        &panic_unimplemented::UNIMPLEMENTED,
-        &panic_unimplemented::UNREACHABLE,
-        &partialeq_ne_impl::PARTIALEQ_NE_IMPL,
-        &pass_by_ref_or_value::LARGE_TYPES_PASSED_BY_VALUE,
-        &pass_by_ref_or_value::TRIVIALLY_COPY_PASS_BY_REF,
-        &path_buf_push_overwrite::PATH_BUF_PUSH_OVERWRITE,
-        &pattern_type_mismatch::PATTERN_TYPE_MISMATCH,
-        &precedence::PRECEDENCE,
-        &ptr::CMP_NULL,
-        &ptr::MUT_FROM_REF,
-        &ptr::PTR_ARG,
-        &ptr_eq::PTR_EQ,
-        &ptr_offset_with_cast::PTR_OFFSET_WITH_CAST,
-        &question_mark::QUESTION_MARK,
-        &ranges::MANUAL_RANGE_CONTAINS,
-        &ranges::RANGE_MINUS_ONE,
-        &ranges::RANGE_PLUS_ONE,
-        &ranges::RANGE_ZIP_WITH_LEN,
-        &ranges::REVERSED_EMPTY_RANGES,
-        &redundant_clone::REDUNDANT_CLONE,
-        &redundant_closure_call::REDUNDANT_CLOSURE_CALL,
-        &redundant_else::REDUNDANT_ELSE,
-        &redundant_field_names::REDUNDANT_FIELD_NAMES,
-        &redundant_pub_crate::REDUNDANT_PUB_CRATE,
-        &redundant_slicing::REDUNDANT_SLICING,
-        &redundant_static_lifetimes::REDUNDANT_STATIC_LIFETIMES,
-        &ref_option_ref::REF_OPTION_REF,
-        &reference::DEREF_ADDROF,
-        &reference::REF_IN_DEREF,
-        &regex::INVALID_REGEX,
-        &regex::TRIVIAL_REGEX,
-        &repeat_once::REPEAT_ONCE,
-        &returns::LET_AND_RETURN,
-        &returns::NEEDLESS_RETURN,
-        &self_assignment::SELF_ASSIGNMENT,
-        &semicolon_if_nothing_returned::SEMICOLON_IF_NOTHING_RETURNED,
-        &serde_api::SERDE_API_MISUSE,
-        &shadow::SHADOW_REUSE,
-        &shadow::SHADOW_SAME,
-        &shadow::SHADOW_UNRELATED,
-        &single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS,
-        &size_of_in_element_count::SIZE_OF_IN_ELEMENT_COUNT,
-        &slow_vector_initialization::SLOW_VECTOR_INITIALIZATION,
-        &stable_sort_primitive::STABLE_SORT_PRIMITIVE,
-        &strings::STRING_ADD,
-        &strings::STRING_ADD_ASSIGN,
-        &strings::STRING_FROM_UTF8_AS_BYTES,
-        &strings::STRING_LIT_AS_BYTES,
-        &strings::STRING_TO_STRING,
-        &strings::STR_TO_STRING,
-        &suspicious_operation_groupings::SUSPICIOUS_OPERATION_GROUPINGS,
-        &suspicious_trait_impl::SUSPICIOUS_ARITHMETIC_IMPL,
-        &suspicious_trait_impl::SUSPICIOUS_OP_ASSIGN_IMPL,
-        &swap::ALMOST_SWAPPED,
-        &swap::MANUAL_SWAP,
-        &tabs_in_doc_comments::TABS_IN_DOC_COMMENTS,
-        &temporary_assignment::TEMPORARY_ASSIGNMENT,
-        &to_digit_is_some::TO_DIGIT_IS_SOME,
-        &to_string_in_display::TO_STRING_IN_DISPLAY,
-        &trait_bounds::TRAIT_DUPLICATION_IN_BOUNDS,
-        &trait_bounds::TYPE_REPETITION_IN_BOUNDS,
-        &transmute::CROSSPOINTER_TRANSMUTE,
-        &transmute::TRANSMUTES_EXPRESSIBLE_AS_PTR_CASTS,
-        &transmute::TRANSMUTE_BYTES_TO_STR,
-        &transmute::TRANSMUTE_FLOAT_TO_INT,
-        &transmute::TRANSMUTE_INT_TO_BOOL,
-        &transmute::TRANSMUTE_INT_TO_CHAR,
-        &transmute::TRANSMUTE_INT_TO_FLOAT,
-        &transmute::TRANSMUTE_PTR_TO_PTR,
-        &transmute::TRANSMUTE_PTR_TO_REF,
-        &transmute::UNSOUND_COLLECTION_TRANSMUTE,
-        &transmute::USELESS_TRANSMUTE,
-        &transmute::WRONG_TRANSMUTE,
-        &transmuting_null::TRANSMUTING_NULL,
-        &try_err::TRY_ERR,
-        &types::BORROWED_BOX,
-        &types::BOX_VEC,
-        &types::LINKEDLIST,
-        &types::OPTION_OPTION,
-        &types::RC_BUFFER,
-        &types::REDUNDANT_ALLOCATION,
-        &types::TYPE_COMPLEXITY,
-        &types::VEC_BOX,
-        &undropped_manually_drops::UNDROPPED_MANUALLY_DROPS,
-        &unicode::INVISIBLE_CHARACTERS,
-        &unicode::NON_ASCII_LITERAL,
-        &unicode::UNICODE_NOT_NFC,
-        &unit_return_expecting_ord::UNIT_RETURN_EXPECTING_ORD,
-        &unit_types::LET_UNIT_VALUE,
-        &unit_types::UNIT_ARG,
-        &unit_types::UNIT_CMP,
-        &unnamed_address::FN_ADDRESS_COMPARISONS,
-        &unnamed_address::VTABLE_ADDRESS_COMPARISONS,
-        &unnecessary_sort_by::UNNECESSARY_SORT_BY,
-        &unnecessary_wraps::UNNECESSARY_WRAPS,
-        &unnested_or_patterns::UNNESTED_OR_PATTERNS,
-        &unsafe_removed_from_name::UNSAFE_REMOVED_FROM_NAME,
-        &unused_io_amount::UNUSED_IO_AMOUNT,
-        &unused_self::UNUSED_SELF,
-        &unused_unit::UNUSED_UNIT,
-        &unwrap::PANICKING_UNWRAP,
-        &unwrap::UNNECESSARY_UNWRAP,
-        &unwrap_in_result::UNWRAP_IN_RESULT,
-        &upper_case_acronyms::UPPER_CASE_ACRONYMS,
-        &use_self::USE_SELF,
-        &useless_conversion::USELESS_CONVERSION,
-        &vec::USELESS_VEC,
-        &vec_init_then_push::VEC_INIT_THEN_PUSH,
-        &vec_resize_to_zero::VEC_RESIZE_TO_ZERO,
-        &verbose_file_reads::VERBOSE_FILE_READS,
-        &wildcard_dependencies::WILDCARD_DEPENDENCIES,
-        &wildcard_imports::ENUM_GLOB_USE,
-        &wildcard_imports::WILDCARD_IMPORTS,
-        &write::PRINTLN_EMPTY_STRING,
-        &write::PRINT_LITERAL,
-        &write::PRINT_STDERR,
-        &write::PRINT_STDOUT,
-        &write::PRINT_WITH_NEWLINE,
-        &write::USE_DEBUG,
-        &write::WRITELN_EMPTY_STRING,
-        &write::WRITE_LITERAL,
-        &write::WRITE_WITH_NEWLINE,
-        &zero_div_zero::ZERO_DIVIDED_BY_ZERO,
-        &zero_sized_map_values::ZERO_SIZED_MAP_VALUES,
+        utils::internal_lints::UNNECESSARY_SYMBOL_STR,
+        absurd_extreme_comparisons::ABSURD_EXTREME_COMPARISONS,
+        approx_const::APPROX_CONSTANT,
+        arithmetic::FLOAT_ARITHMETIC,
+        arithmetic::INTEGER_ARITHMETIC,
+        as_conversions::AS_CONVERSIONS,
+        asm_syntax::INLINE_ASM_X86_ATT_SYNTAX,
+        asm_syntax::INLINE_ASM_X86_INTEL_SYNTAX,
+        assertions_on_constants::ASSERTIONS_ON_CONSTANTS,
+        assign_ops::ASSIGN_OP_PATTERN,
+        assign_ops::MISREFACTORED_ASSIGN_OP,
+        async_yields_async::ASYNC_YIELDS_ASYNC,
+        atomic_ordering::INVALID_ATOMIC_ORDERING,
+        attrs::BLANKET_CLIPPY_RESTRICTION_LINTS,
+        attrs::DEPRECATED_CFG_ATTR,
+        attrs::DEPRECATED_SEMVER,
+        attrs::EMPTY_LINE_AFTER_OUTER_ATTR,
+        attrs::INLINE_ALWAYS,
+        attrs::MISMATCHED_TARGET_OS,
+        attrs::USELESS_ATTRIBUTE,
+        await_holding_invalid::AWAIT_HOLDING_LOCK,
+        await_holding_invalid::AWAIT_HOLDING_REFCELL_REF,
+        bit_mask::BAD_BIT_MASK,
+        bit_mask::INEFFECTIVE_BIT_MASK,
+        bit_mask::VERBOSE_BIT_MASK,
+        blacklisted_name::BLACKLISTED_NAME,
+        blocks_in_if_conditions::BLOCKS_IN_IF_CONDITIONS,
+        booleans::LOGIC_BUG,
+        booleans::NONMINIMAL_BOOL,
+        bytecount::NAIVE_BYTECOUNT,
+        cargo_common_metadata::CARGO_COMMON_METADATA,
+        case_sensitive_file_extension_comparisons::CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS,
+        casts::CAST_LOSSLESS,
+        casts::CAST_POSSIBLE_TRUNCATION,
+        casts::CAST_POSSIBLE_WRAP,
+        casts::CAST_PRECISION_LOSS,
+        casts::CAST_PTR_ALIGNMENT,
+        casts::CAST_REF_TO_MUT,
+        casts::CAST_SIGN_LOSS,
+        casts::CHAR_LIT_AS_U8,
+        casts::FN_TO_NUMERIC_CAST,
+        casts::FN_TO_NUMERIC_CAST_WITH_TRUNCATION,
+        casts::PTR_AS_PTR,
+        casts::UNNECESSARY_CAST,
+        checked_conversions::CHECKED_CONVERSIONS,
+        cognitive_complexity::COGNITIVE_COMPLEXITY,
+        collapsible_if::COLLAPSIBLE_ELSE_IF,
+        collapsible_if::COLLAPSIBLE_IF,
+        collapsible_match::COLLAPSIBLE_MATCH,
+        comparison_chain::COMPARISON_CHAIN,
+        copies::BRANCHES_SHARING_CODE,
+        copies::IFS_SAME_COND,
+        copies::IF_SAME_THEN_ELSE,
+        copies::SAME_FUNCTIONS_IN_IF_CONDITION,
+        copy_iterator::COPY_ITERATOR,
+        create_dir::CREATE_DIR,
+        dbg_macro::DBG_MACRO,
+        default::DEFAULT_TRAIT_ACCESS,
+        default::FIELD_REASSIGN_WITH_DEFAULT,
+        default_numeric_fallback::DEFAULT_NUMERIC_FALLBACK,
+        dereference::EXPLICIT_DEREF_METHODS,
+        derive::DERIVE_HASH_XOR_EQ,
+        derive::DERIVE_ORD_XOR_PARTIAL_ORD,
+        derive::EXPL_IMPL_CLONE_ON_COPY,
+        derive::UNSAFE_DERIVE_DESERIALIZE,
+        disallowed_method::DISALLOWED_METHOD,
+        doc::DOC_MARKDOWN,
+        doc::MISSING_ERRORS_DOC,
+        doc::MISSING_PANICS_DOC,
+        doc::MISSING_SAFETY_DOC,
+        doc::NEEDLESS_DOCTEST_MAIN,
+        double_comparison::DOUBLE_COMPARISONS,
+        double_parens::DOUBLE_PARENS,
+        drop_forget_ref::DROP_COPY,
+        drop_forget_ref::DROP_REF,
+        drop_forget_ref::FORGET_COPY,
+        drop_forget_ref::FORGET_REF,
+        duration_subsec::DURATION_SUBSEC,
+        else_if_without_else::ELSE_IF_WITHOUT_ELSE,
+        empty_enum::EMPTY_ENUM,
+        entry::MAP_ENTRY,
+        enum_clike::ENUM_CLIKE_UNPORTABLE_VARIANT,
+        enum_variants::ENUM_VARIANT_NAMES,
+        enum_variants::MODULE_INCEPTION,
+        enum_variants::MODULE_NAME_REPETITIONS,
+        enum_variants::PUB_ENUM_VARIANT_NAMES,
+        eq_op::EQ_OP,
+        eq_op::OP_REF,
+        erasing_op::ERASING_OP,
+        escape::BOXED_LOCAL,
+        eta_reduction::REDUNDANT_CLOSURE,
+        eta_reduction::REDUNDANT_CLOSURE_FOR_METHOD_CALLS,
+        eval_order_dependence::DIVERGING_SUB_EXPRESSION,
+        eval_order_dependence::EVAL_ORDER_DEPENDENCE,
+        excessive_bools::FN_PARAMS_EXCESSIVE_BOOLS,
+        excessive_bools::STRUCT_EXCESSIVE_BOOLS,
+        exhaustive_items::EXHAUSTIVE_ENUMS,
+        exhaustive_items::EXHAUSTIVE_STRUCTS,
+        exit::EXIT,
+        explicit_write::EXPLICIT_WRITE,
+        fallible_impl_from::FALLIBLE_IMPL_FROM,
+        float_equality_without_abs::FLOAT_EQUALITY_WITHOUT_ABS,
+        float_literal::EXCESSIVE_PRECISION,
+        float_literal::LOSSY_FLOAT_LITERAL,
+        floating_point_arithmetic::IMPRECISE_FLOPS,
+        floating_point_arithmetic::SUBOPTIMAL_FLOPS,
+        format::USELESS_FORMAT,
+        formatting::POSSIBLE_MISSING_COMMA,
+        formatting::SUSPICIOUS_ASSIGNMENT_FORMATTING,
+        formatting::SUSPICIOUS_ELSE_FORMATTING,
+        formatting::SUSPICIOUS_UNARY_OP_FORMATTING,
+        from_over_into::FROM_OVER_INTO,
+        from_str_radix_10::FROM_STR_RADIX_10,
+        functions::DOUBLE_MUST_USE,
+        functions::MUST_USE_CANDIDATE,
+        functions::MUST_USE_UNIT,
+        functions::NOT_UNSAFE_PTR_ARG_DEREF,
+        functions::RESULT_UNIT_ERR,
+        functions::TOO_MANY_ARGUMENTS,
+        functions::TOO_MANY_LINES,
+        future_not_send::FUTURE_NOT_SEND,
+        get_last_with_len::GET_LAST_WITH_LEN,
+        identity_op::IDENTITY_OP,
+        if_let_mutex::IF_LET_MUTEX,
+        if_let_some_result::IF_LET_SOME_RESULT,
+        if_not_else::IF_NOT_ELSE,
+        if_then_some_else_none::IF_THEN_SOME_ELSE_NONE,
+        implicit_hasher::IMPLICIT_HASHER,
+        implicit_return::IMPLICIT_RETURN,
+        implicit_saturating_sub::IMPLICIT_SATURATING_SUB,
+        inconsistent_struct_constructor::INCONSISTENT_STRUCT_CONSTRUCTOR,
+        indexing_slicing::INDEXING_SLICING,
+        indexing_slicing::OUT_OF_BOUNDS_INDEXING,
+        infinite_iter::INFINITE_ITER,
+        infinite_iter::MAYBE_INFINITE_ITER,
+        inherent_impl::MULTIPLE_INHERENT_IMPL,
+        inherent_to_string::INHERENT_TO_STRING,
+        inherent_to_string::INHERENT_TO_STRING_SHADOW_DISPLAY,
+        inline_fn_without_body::INLINE_FN_WITHOUT_BODY,
+        int_plus_one::INT_PLUS_ONE,
+        integer_division::INTEGER_DIVISION,
+        invalid_upcast_comparisons::INVALID_UPCAST_COMPARISONS,
+        items_after_statements::ITEMS_AFTER_STATEMENTS,
+        large_const_arrays::LARGE_CONST_ARRAYS,
+        large_enum_variant::LARGE_ENUM_VARIANT,
+        large_stack_arrays::LARGE_STACK_ARRAYS,
+        len_zero::COMPARISON_TO_EMPTY,
+        len_zero::LEN_WITHOUT_IS_EMPTY,
+        len_zero::LEN_ZERO,
+        let_if_seq::USELESS_LET_IF_SEQ,
+        let_underscore::LET_UNDERSCORE_DROP,
+        let_underscore::LET_UNDERSCORE_LOCK,
+        let_underscore::LET_UNDERSCORE_MUST_USE,
+        lifetimes::EXTRA_UNUSED_LIFETIMES,
+        lifetimes::NEEDLESS_LIFETIMES,
+        literal_representation::DECIMAL_LITERAL_REPRESENTATION,
+        literal_representation::INCONSISTENT_DIGIT_GROUPING,
+        literal_representation::LARGE_DIGIT_GROUPS,
+        literal_representation::MISTYPED_LITERAL_SUFFIXES,
+        literal_representation::UNREADABLE_LITERAL,
+        literal_representation::UNUSUAL_BYTE_GROUPINGS,
+        loops::EMPTY_LOOP,
+        loops::EXPLICIT_COUNTER_LOOP,
+        loops::EXPLICIT_INTO_ITER_LOOP,
+        loops::EXPLICIT_ITER_LOOP,
+        loops::FOR_KV_MAP,
+        loops::FOR_LOOPS_OVER_FALLIBLES,
+        loops::ITER_NEXT_LOOP,
+        loops::MANUAL_FLATTEN,
+        loops::MANUAL_MEMCPY,
+        loops::MUT_RANGE_BOUND,
+        loops::NEEDLESS_COLLECT,
+        loops::NEEDLESS_RANGE_LOOP,
+        loops::NEVER_LOOP,
+        loops::SAME_ITEM_PUSH,
+        loops::SINGLE_ELEMENT_LOOP,
+        loops::WHILE_IMMUTABLE_CONDITION,
+        loops::WHILE_LET_LOOP,
+        loops::WHILE_LET_ON_ITERATOR,
+        macro_use::MACRO_USE_IMPORTS,
+        main_recursion::MAIN_RECURSION,
+        manual_async_fn::MANUAL_ASYNC_FN,
+        manual_map::MANUAL_MAP,
+        manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE,
+        manual_ok_or::MANUAL_OK_OR,
+        manual_strip::MANUAL_STRIP,
+        manual_unwrap_or::MANUAL_UNWRAP_OR,
+        map_clone::MAP_CLONE,
+        map_err_ignore::MAP_ERR_IGNORE,
+        map_identity::MAP_IDENTITY,
+        map_unit_fn::OPTION_MAP_UNIT_FN,
+        map_unit_fn::RESULT_MAP_UNIT_FN,
+        match_on_vec_items::MATCH_ON_VEC_ITEMS,
+        matches::INFALLIBLE_DESTRUCTURING_MATCH,
+        matches::MATCH_AS_REF,
+        matches::MATCH_BOOL,
+        matches::MATCH_LIKE_MATCHES_MACRO,
+        matches::MATCH_OVERLAPPING_ARM,
+        matches::MATCH_REF_PATS,
+        matches::MATCH_SAME_ARMS,
+        matches::MATCH_SINGLE_BINDING,
+        matches::MATCH_WILDCARD_FOR_SINGLE_VARIANTS,
+        matches::MATCH_WILD_ERR_ARM,
+        matches::REDUNDANT_PATTERN_MATCHING,
+        matches::REST_PAT_IN_FULLY_BOUND_STRUCTS,
+        matches::SINGLE_MATCH,
+        matches::SINGLE_MATCH_ELSE,
+        matches::WILDCARD_ENUM_MATCH_ARM,
+        matches::WILDCARD_IN_OR_PATTERNS,
+        mem_discriminant::MEM_DISCRIMINANT_NON_ENUM,
+        mem_forget::MEM_FORGET,
+        mem_replace::MEM_REPLACE_OPTION_WITH_NONE,
+        mem_replace::MEM_REPLACE_WITH_DEFAULT,
+        mem_replace::MEM_REPLACE_WITH_UNINIT,
+        methods::BIND_INSTEAD_OF_MAP,
+        methods::BYTES_NTH,
+        methods::CHARS_LAST_CMP,
+        methods::CHARS_NEXT_CMP,
+        methods::CLONE_DOUBLE_REF,
+        methods::CLONE_ON_COPY,
+        methods::CLONE_ON_REF_PTR,
+        methods::EXPECT_FUN_CALL,
+        methods::EXPECT_USED,
+        methods::FILETYPE_IS_FILE,
+        methods::FILTER_MAP,
+        methods::FILTER_MAP_IDENTITY,
+        methods::FILTER_MAP_NEXT,
+        methods::FILTER_NEXT,
+        methods::FLAT_MAP_IDENTITY,
+        methods::FROM_ITER_INSTEAD_OF_COLLECT,
+        methods::GET_UNWRAP,
+        methods::IMPLICIT_CLONE,
+        methods::INEFFICIENT_TO_STRING,
+        methods::INSPECT_FOR_EACH,
+        methods::INTO_ITER_ON_REF,
+        methods::ITERATOR_STEP_BY_ZERO,
+        methods::ITER_CLONED_COLLECT,
+        methods::ITER_COUNT,
+        methods::ITER_NEXT_SLICE,
+        methods::ITER_NTH,
+        methods::ITER_NTH_ZERO,
+        methods::ITER_SKIP_NEXT,
+        methods::MANUAL_FILTER_MAP,
+        methods::MANUAL_FIND_MAP,
+        methods::MANUAL_SATURATING_ARITHMETIC,
+        methods::MAP_COLLECT_RESULT_UNIT,
+        methods::MAP_FLATTEN,
+        methods::MAP_UNWRAP_OR,
+        methods::NEW_RET_NO_SELF,
+        methods::OK_EXPECT,
+        methods::OPTION_AS_REF_DEREF,
+        methods::OPTION_FILTER_MAP,
+        methods::OPTION_MAP_OR_NONE,
+        methods::OR_FUN_CALL,
+        methods::RESULT_MAP_OR_INTO_OPTION,
+        methods::SEARCH_IS_SOME,
+        methods::SHOULD_IMPLEMENT_TRAIT,
+        methods::SINGLE_CHAR_ADD_STR,
+        methods::SINGLE_CHAR_PATTERN,
+        methods::SKIP_WHILE_NEXT,
+        methods::STRING_EXTEND_CHARS,
+        methods::SUSPICIOUS_MAP,
+        methods::UNINIT_ASSUMED_INIT,
+        methods::UNNECESSARY_FILTER_MAP,
+        methods::UNNECESSARY_FOLD,
+        methods::UNNECESSARY_LAZY_EVALUATIONS,
+        methods::UNWRAP_USED,
+        methods::USELESS_ASREF,
+        methods::WRONG_PUB_SELF_CONVENTION,
+        methods::WRONG_SELF_CONVENTION,
+        methods::ZST_OFFSET,
+        minmax::MIN_MAX,
+        misc::CMP_NAN,
+        misc::CMP_OWNED,
+        misc::FLOAT_CMP,
+        misc::FLOAT_CMP_CONST,
+        misc::MODULO_ONE,
+        misc::SHORT_CIRCUIT_STATEMENT,
+        misc::TOPLEVEL_REF_ARG,
+        misc::USED_UNDERSCORE_BINDING,
+        misc::ZERO_PTR,
+        misc_early::BUILTIN_TYPE_SHADOW,
+        misc_early::DOUBLE_NEG,
+        misc_early::DUPLICATE_UNDERSCORE_ARGUMENT,
+        misc_early::MIXED_CASE_HEX_LITERALS,
+        misc_early::REDUNDANT_PATTERN,
+        misc_early::UNNEEDED_FIELD_PATTERN,
+        misc_early::UNNEEDED_WILDCARD_PATTERN,
+        misc_early::UNSEPARATED_LITERAL_SUFFIX,
+        misc_early::ZERO_PREFIXED_LITERAL,
+        missing_const_for_fn::MISSING_CONST_FOR_FN,
+        missing_doc::MISSING_DOCS_IN_PRIVATE_ITEMS,
+        missing_inline::MISSING_INLINE_IN_PUBLIC_ITEMS,
+        modulo_arithmetic::MODULO_ARITHMETIC,
+        multiple_crate_versions::MULTIPLE_CRATE_VERSIONS,
+        mut_key::MUTABLE_KEY_TYPE,
+        mut_mut::MUT_MUT,
+        mut_mutex_lock::MUT_MUTEX_LOCK,
+        mut_reference::UNNECESSARY_MUT_PASSED,
+        mutable_debug_assertion::DEBUG_ASSERT_WITH_MUT_CALL,
+        mutex_atomic::MUTEX_ATOMIC,
+        mutex_atomic::MUTEX_INTEGER,
+        needless_arbitrary_self_type::NEEDLESS_ARBITRARY_SELF_TYPE,
+        needless_bool::BOOL_COMPARISON,
+        needless_bool::NEEDLESS_BOOL,
+        needless_borrow::NEEDLESS_BORROW,
+        needless_borrowed_ref::NEEDLESS_BORROWED_REFERENCE,
+        needless_continue::NEEDLESS_CONTINUE,
+        needless_for_each::NEEDLESS_FOR_EACH,
+        needless_pass_by_value::NEEDLESS_PASS_BY_VALUE,
+        needless_question_mark::NEEDLESS_QUESTION_MARK,
+        needless_update::NEEDLESS_UPDATE,
+        neg_cmp_op_on_partial_ord::NEG_CMP_OP_ON_PARTIAL_ORD,
+        neg_multiply::NEG_MULTIPLY,
+        new_without_default::NEW_WITHOUT_DEFAULT,
+        no_effect::NO_EFFECT,
+        no_effect::UNNECESSARY_OPERATION,
+        non_copy_const::BORROW_INTERIOR_MUTABLE_CONST,
+        non_copy_const::DECLARE_INTERIOR_MUTABLE_CONST,
+        non_expressive_names::JUST_UNDERSCORES_AND_DIGITS,
+        non_expressive_names::MANY_SINGLE_CHAR_NAMES,
+        non_expressive_names::SIMILAR_NAMES,
+        non_octal_unix_permissions::NON_OCTAL_UNIX_PERMISSIONS,
+        open_options::NONSENSICAL_OPEN_OPTIONS,
+        option_env_unwrap::OPTION_ENV_UNWRAP,
+        option_if_let_else::OPTION_IF_LET_ELSE,
+        overflow_check_conditional::OVERFLOW_CHECK_CONDITIONAL,
+        panic_in_result_fn::PANIC_IN_RESULT_FN,
+        panic_unimplemented::PANIC,
+        panic_unimplemented::TODO,
+        panic_unimplemented::UNIMPLEMENTED,
+        panic_unimplemented::UNREACHABLE,
+        partialeq_ne_impl::PARTIALEQ_NE_IMPL,
+        pass_by_ref_or_value::LARGE_TYPES_PASSED_BY_VALUE,
+        pass_by_ref_or_value::TRIVIALLY_COPY_PASS_BY_REF,
+        path_buf_push_overwrite::PATH_BUF_PUSH_OVERWRITE,
+        pattern_type_mismatch::PATTERN_TYPE_MISMATCH,
+        precedence::PRECEDENCE,
+        ptr::CMP_NULL,
+        ptr::MUT_FROM_REF,
+        ptr::PTR_ARG,
+        ptr_eq::PTR_EQ,
+        ptr_offset_with_cast::PTR_OFFSET_WITH_CAST,
+        question_mark::QUESTION_MARK,
+        ranges::MANUAL_RANGE_CONTAINS,
+        ranges::RANGE_MINUS_ONE,
+        ranges::RANGE_PLUS_ONE,
+        ranges::RANGE_ZIP_WITH_LEN,
+        ranges::REVERSED_EMPTY_RANGES,
+        redundant_clone::REDUNDANT_CLONE,
+        redundant_closure_call::REDUNDANT_CLOSURE_CALL,
+        redundant_else::REDUNDANT_ELSE,
+        redundant_field_names::REDUNDANT_FIELD_NAMES,
+        redundant_pub_crate::REDUNDANT_PUB_CRATE,
+        redundant_slicing::REDUNDANT_SLICING,
+        redundant_static_lifetimes::REDUNDANT_STATIC_LIFETIMES,
+        ref_option_ref::REF_OPTION_REF,
+        reference::DEREF_ADDROF,
+        reference::REF_IN_DEREF,
+        regex::INVALID_REGEX,
+        regex::TRIVIAL_REGEX,
+        repeat_once::REPEAT_ONCE,
+        returns::LET_AND_RETURN,
+        returns::NEEDLESS_RETURN,
+        self_assignment::SELF_ASSIGNMENT,
+        semicolon_if_nothing_returned::SEMICOLON_IF_NOTHING_RETURNED,
+        serde_api::SERDE_API_MISUSE,
+        shadow::SHADOW_REUSE,
+        shadow::SHADOW_SAME,
+        shadow::SHADOW_UNRELATED,
+        single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS,
+        size_of_in_element_count::SIZE_OF_IN_ELEMENT_COUNT,
+        slow_vector_initialization::SLOW_VECTOR_INITIALIZATION,
+        stable_sort_primitive::STABLE_SORT_PRIMITIVE,
+        strings::STRING_ADD,
+        strings::STRING_ADD_ASSIGN,
+        strings::STRING_FROM_UTF8_AS_BYTES,
+        strings::STRING_LIT_AS_BYTES,
+        strings::STRING_TO_STRING,
+        strings::STR_TO_STRING,
+        suspicious_operation_groupings::SUSPICIOUS_OPERATION_GROUPINGS,
+        suspicious_trait_impl::SUSPICIOUS_ARITHMETIC_IMPL,
+        suspicious_trait_impl::SUSPICIOUS_OP_ASSIGN_IMPL,
+        swap::ALMOST_SWAPPED,
+        swap::MANUAL_SWAP,
+        tabs_in_doc_comments::TABS_IN_DOC_COMMENTS,
+        temporary_assignment::TEMPORARY_ASSIGNMENT,
+        to_digit_is_some::TO_DIGIT_IS_SOME,
+        to_string_in_display::TO_STRING_IN_DISPLAY,
+        trait_bounds::TRAIT_DUPLICATION_IN_BOUNDS,
+        trait_bounds::TYPE_REPETITION_IN_BOUNDS,
+        transmute::CROSSPOINTER_TRANSMUTE,
+        transmute::TRANSMUTES_EXPRESSIBLE_AS_PTR_CASTS,
+        transmute::TRANSMUTE_BYTES_TO_STR,
+        transmute::TRANSMUTE_FLOAT_TO_INT,
+        transmute::TRANSMUTE_INT_TO_BOOL,
+        transmute::TRANSMUTE_INT_TO_CHAR,
+        transmute::TRANSMUTE_INT_TO_FLOAT,
+        transmute::TRANSMUTE_PTR_TO_PTR,
+        transmute::TRANSMUTE_PTR_TO_REF,
+        transmute::UNSOUND_COLLECTION_TRANSMUTE,
+        transmute::USELESS_TRANSMUTE,
+        transmute::WRONG_TRANSMUTE,
+        transmuting_null::TRANSMUTING_NULL,
+        try_err::TRY_ERR,
+        types::BORROWED_BOX,
+        types::BOX_VEC,
+        types::LINKEDLIST,
+        types::OPTION_OPTION,
+        types::RC_BUFFER,
+        types::REDUNDANT_ALLOCATION,
+        types::TYPE_COMPLEXITY,
+        types::VEC_BOX,
+        undropped_manually_drops::UNDROPPED_MANUALLY_DROPS,
+        unicode::INVISIBLE_CHARACTERS,
+        unicode::NON_ASCII_LITERAL,
+        unicode::UNICODE_NOT_NFC,
+        unit_return_expecting_ord::UNIT_RETURN_EXPECTING_ORD,
+        unit_types::LET_UNIT_VALUE,
+        unit_types::UNIT_ARG,
+        unit_types::UNIT_CMP,
+        unnamed_address::FN_ADDRESS_COMPARISONS,
+        unnamed_address::VTABLE_ADDRESS_COMPARISONS,
+        unnecessary_sort_by::UNNECESSARY_SORT_BY,
+        unnecessary_wraps::UNNECESSARY_WRAPS,
+        unnested_or_patterns::UNNESTED_OR_PATTERNS,
+        unsafe_removed_from_name::UNSAFE_REMOVED_FROM_NAME,
+        unused_io_amount::UNUSED_IO_AMOUNT,
+        unused_self::UNUSED_SELF,
+        unused_unit::UNUSED_UNIT,
+        unwrap::PANICKING_UNWRAP,
+        unwrap::UNNECESSARY_UNWRAP,
+        unwrap_in_result::UNWRAP_IN_RESULT,
+        upper_case_acronyms::UPPER_CASE_ACRONYMS,
+        use_self::USE_SELF,
+        useless_conversion::USELESS_CONVERSION,
+        vec::USELESS_VEC,
+        vec_init_then_push::VEC_INIT_THEN_PUSH,
+        vec_resize_to_zero::VEC_RESIZE_TO_ZERO,
+        verbose_file_reads::VERBOSE_FILE_READS,
+        wildcard_dependencies::WILDCARD_DEPENDENCIES,
+        wildcard_imports::ENUM_GLOB_USE,
+        wildcard_imports::WILDCARD_IMPORTS,
+        write::PRINTLN_EMPTY_STRING,
+        write::PRINT_LITERAL,
+        write::PRINT_STDERR,
+        write::PRINT_STDOUT,
+        write::PRINT_WITH_NEWLINE,
+        write::USE_DEBUG,
+        write::WRITELN_EMPTY_STRING,
+        write::WRITE_LITERAL,
+        write::WRITE_WITH_NEWLINE,
+        zero_div_zero::ZERO_DIVIDED_BY_ZERO,
+        zero_sized_map_values::ZERO_SIZED_MAP_VALUES,
     ]);
     // end register lints, do not remove this comment, it’s used in `update_lints`
 
@@ -1295,792 +1295,792 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(move || box if_then_some_else_none::IfThenSomeElseNone::new(msrv));
 
     store.register_group(true, "clippy::restriction", Some("clippy_restriction"), vec![
-        LintId::of(&arithmetic::FLOAT_ARITHMETIC),
-        LintId::of(&arithmetic::INTEGER_ARITHMETIC),
-        LintId::of(&as_conversions::AS_CONVERSIONS),
-        LintId::of(&asm_syntax::INLINE_ASM_X86_ATT_SYNTAX),
-        LintId::of(&asm_syntax::INLINE_ASM_X86_INTEL_SYNTAX),
-        LintId::of(&create_dir::CREATE_DIR),
-        LintId::of(&dbg_macro::DBG_MACRO),
-        LintId::of(&default_numeric_fallback::DEFAULT_NUMERIC_FALLBACK),
-        LintId::of(&else_if_without_else::ELSE_IF_WITHOUT_ELSE),
-        LintId::of(&exhaustive_items::EXHAUSTIVE_ENUMS),
-        LintId::of(&exhaustive_items::EXHAUSTIVE_STRUCTS),
-        LintId::of(&exit::EXIT),
-        LintId::of(&float_literal::LOSSY_FLOAT_LITERAL),
-        LintId::of(&if_then_some_else_none::IF_THEN_SOME_ELSE_NONE),
-        LintId::of(&implicit_return::IMPLICIT_RETURN),
-        LintId::of(&indexing_slicing::INDEXING_SLICING),
-        LintId::of(&inherent_impl::MULTIPLE_INHERENT_IMPL),
-        LintId::of(&integer_division::INTEGER_DIVISION),
-        LintId::of(&let_underscore::LET_UNDERSCORE_MUST_USE),
-        LintId::of(&literal_representation::DECIMAL_LITERAL_REPRESENTATION),
-        LintId::of(&map_err_ignore::MAP_ERR_IGNORE),
-        LintId::of(&matches::REST_PAT_IN_FULLY_BOUND_STRUCTS),
-        LintId::of(&matches::WILDCARD_ENUM_MATCH_ARM),
-        LintId::of(&mem_forget::MEM_FORGET),
-        LintId::of(&methods::CLONE_ON_REF_PTR),
-        LintId::of(&methods::EXPECT_USED),
-        LintId::of(&methods::FILETYPE_IS_FILE),
-        LintId::of(&methods::GET_UNWRAP),
-        LintId::of(&methods::UNWRAP_USED),
-        LintId::of(&methods::WRONG_PUB_SELF_CONVENTION),
-        LintId::of(&misc::FLOAT_CMP_CONST),
-        LintId::of(&misc_early::UNNEEDED_FIELD_PATTERN),
-        LintId::of(&missing_doc::MISSING_DOCS_IN_PRIVATE_ITEMS),
-        LintId::of(&missing_inline::MISSING_INLINE_IN_PUBLIC_ITEMS),
-        LintId::of(&modulo_arithmetic::MODULO_ARITHMETIC),
-        LintId::of(&panic_in_result_fn::PANIC_IN_RESULT_FN),
-        LintId::of(&panic_unimplemented::PANIC),
-        LintId::of(&panic_unimplemented::TODO),
-        LintId::of(&panic_unimplemented::UNIMPLEMENTED),
-        LintId::of(&panic_unimplemented::UNREACHABLE),
-        LintId::of(&pattern_type_mismatch::PATTERN_TYPE_MISMATCH),
-        LintId::of(&semicolon_if_nothing_returned::SEMICOLON_IF_NOTHING_RETURNED),
-        LintId::of(&shadow::SHADOW_REUSE),
-        LintId::of(&shadow::SHADOW_SAME),
-        LintId::of(&strings::STRING_ADD),
-        LintId::of(&strings::STRING_TO_STRING),
-        LintId::of(&strings::STR_TO_STRING),
-        LintId::of(&types::RC_BUFFER),
-        LintId::of(&unwrap_in_result::UNWRAP_IN_RESULT),
-        LintId::of(&verbose_file_reads::VERBOSE_FILE_READS),
-        LintId::of(&write::PRINT_STDERR),
-        LintId::of(&write::PRINT_STDOUT),
-        LintId::of(&write::USE_DEBUG),
+        LintId::of(arithmetic::FLOAT_ARITHMETIC),
+        LintId::of(arithmetic::INTEGER_ARITHMETIC),
+        LintId::of(as_conversions::AS_CONVERSIONS),
+        LintId::of(asm_syntax::INLINE_ASM_X86_ATT_SYNTAX),
+        LintId::of(asm_syntax::INLINE_ASM_X86_INTEL_SYNTAX),
+        LintId::of(create_dir::CREATE_DIR),
+        LintId::of(dbg_macro::DBG_MACRO),
+        LintId::of(default_numeric_fallback::DEFAULT_NUMERIC_FALLBACK),
+        LintId::of(else_if_without_else::ELSE_IF_WITHOUT_ELSE),
+        LintId::of(exhaustive_items::EXHAUSTIVE_ENUMS),
+        LintId::of(exhaustive_items::EXHAUSTIVE_STRUCTS),
+        LintId::of(exit::EXIT),
+        LintId::of(float_literal::LOSSY_FLOAT_LITERAL),
+        LintId::of(if_then_some_else_none::IF_THEN_SOME_ELSE_NONE),
+        LintId::of(implicit_return::IMPLICIT_RETURN),
+        LintId::of(indexing_slicing::INDEXING_SLICING),
+        LintId::of(inherent_impl::MULTIPLE_INHERENT_IMPL),
+        LintId::of(integer_division::INTEGER_DIVISION),
+        LintId::of(let_underscore::LET_UNDERSCORE_MUST_USE),
+        LintId::of(literal_representation::DECIMAL_LITERAL_REPRESENTATION),
+        LintId::of(map_err_ignore::MAP_ERR_IGNORE),
+        LintId::of(matches::REST_PAT_IN_FULLY_BOUND_STRUCTS),
+        LintId::of(matches::WILDCARD_ENUM_MATCH_ARM),
+        LintId::of(mem_forget::MEM_FORGET),
+        LintId::of(methods::CLONE_ON_REF_PTR),
+        LintId::of(methods::EXPECT_USED),
+        LintId::of(methods::FILETYPE_IS_FILE),
+        LintId::of(methods::GET_UNWRAP),
+        LintId::of(methods::UNWRAP_USED),
+        LintId::of(methods::WRONG_PUB_SELF_CONVENTION),
+        LintId::of(misc::FLOAT_CMP_CONST),
+        LintId::of(misc_early::UNNEEDED_FIELD_PATTERN),
+        LintId::of(missing_doc::MISSING_DOCS_IN_PRIVATE_ITEMS),
+        LintId::of(missing_inline::MISSING_INLINE_IN_PUBLIC_ITEMS),
+        LintId::of(modulo_arithmetic::MODULO_ARITHMETIC),
+        LintId::of(panic_in_result_fn::PANIC_IN_RESULT_FN),
+        LintId::of(panic_unimplemented::PANIC),
+        LintId::of(panic_unimplemented::TODO),
+        LintId::of(panic_unimplemented::UNIMPLEMENTED),
+        LintId::of(panic_unimplemented::UNREACHABLE),
+        LintId::of(pattern_type_mismatch::PATTERN_TYPE_MISMATCH),
+        LintId::of(semicolon_if_nothing_returned::SEMICOLON_IF_NOTHING_RETURNED),
+        LintId::of(shadow::SHADOW_REUSE),
+        LintId::of(shadow::SHADOW_SAME),
+        LintId::of(strings::STRING_ADD),
+        LintId::of(strings::STRING_TO_STRING),
+        LintId::of(strings::STR_TO_STRING),
+        LintId::of(types::RC_BUFFER),
+        LintId::of(unwrap_in_result::UNWRAP_IN_RESULT),
+        LintId::of(verbose_file_reads::VERBOSE_FILE_READS),
+        LintId::of(write::PRINT_STDERR),
+        LintId::of(write::PRINT_STDOUT),
+        LintId::of(write::USE_DEBUG),
     ]);
 
     store.register_group(true, "clippy::pedantic", Some("clippy_pedantic"), vec![
-        LintId::of(&attrs::INLINE_ALWAYS),
-        LintId::of(&await_holding_invalid::AWAIT_HOLDING_LOCK),
-        LintId::of(&await_holding_invalid::AWAIT_HOLDING_REFCELL_REF),
-        LintId::of(&bit_mask::VERBOSE_BIT_MASK),
-        LintId::of(&bytecount::NAIVE_BYTECOUNT),
-        LintId::of(&case_sensitive_file_extension_comparisons::CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS),
-        LintId::of(&casts::CAST_LOSSLESS),
-        LintId::of(&casts::CAST_POSSIBLE_TRUNCATION),
-        LintId::of(&casts::CAST_POSSIBLE_WRAP),
-        LintId::of(&casts::CAST_PRECISION_LOSS),
-        LintId::of(&casts::CAST_PTR_ALIGNMENT),
-        LintId::of(&casts::CAST_SIGN_LOSS),
-        LintId::of(&casts::PTR_AS_PTR),
-        LintId::of(&checked_conversions::CHECKED_CONVERSIONS),
-        LintId::of(&copies::SAME_FUNCTIONS_IN_IF_CONDITION),
-        LintId::of(&copy_iterator::COPY_ITERATOR),
-        LintId::of(&default::DEFAULT_TRAIT_ACCESS),
-        LintId::of(&dereference::EXPLICIT_DEREF_METHODS),
-        LintId::of(&derive::EXPL_IMPL_CLONE_ON_COPY),
-        LintId::of(&derive::UNSAFE_DERIVE_DESERIALIZE),
-        LintId::of(&doc::DOC_MARKDOWN),
-        LintId::of(&doc::MISSING_ERRORS_DOC),
-        LintId::of(&doc::MISSING_PANICS_DOC),
-        LintId::of(&empty_enum::EMPTY_ENUM),
-        LintId::of(&enum_variants::MODULE_NAME_REPETITIONS),
-        LintId::of(&enum_variants::PUB_ENUM_VARIANT_NAMES),
-        LintId::of(&eta_reduction::REDUNDANT_CLOSURE_FOR_METHOD_CALLS),
-        LintId::of(&excessive_bools::FN_PARAMS_EXCESSIVE_BOOLS),
-        LintId::of(&excessive_bools::STRUCT_EXCESSIVE_BOOLS),
-        LintId::of(&functions::MUST_USE_CANDIDATE),
-        LintId::of(&functions::TOO_MANY_LINES),
-        LintId::of(&if_not_else::IF_NOT_ELSE),
-        LintId::of(&implicit_hasher::IMPLICIT_HASHER),
-        LintId::of(&implicit_saturating_sub::IMPLICIT_SATURATING_SUB),
-        LintId::of(&infinite_iter::MAYBE_INFINITE_ITER),
-        LintId::of(&invalid_upcast_comparisons::INVALID_UPCAST_COMPARISONS),
-        LintId::of(&items_after_statements::ITEMS_AFTER_STATEMENTS),
-        LintId::of(&large_stack_arrays::LARGE_STACK_ARRAYS),
-        LintId::of(&let_underscore::LET_UNDERSCORE_DROP),
-        LintId::of(&literal_representation::LARGE_DIGIT_GROUPS),
-        LintId::of(&literal_representation::UNREADABLE_LITERAL),
-        LintId::of(&loops::EXPLICIT_INTO_ITER_LOOP),
-        LintId::of(&loops::EXPLICIT_ITER_LOOP),
-        LintId::of(&macro_use::MACRO_USE_IMPORTS),
-        LintId::of(&manual_ok_or::MANUAL_OK_OR),
-        LintId::of(&match_on_vec_items::MATCH_ON_VEC_ITEMS),
-        LintId::of(&matches::MATCH_BOOL),
-        LintId::of(&matches::MATCH_SAME_ARMS),
-        LintId::of(&matches::MATCH_WILDCARD_FOR_SINGLE_VARIANTS),
-        LintId::of(&matches::MATCH_WILD_ERR_ARM),
-        LintId::of(&matches::SINGLE_MATCH_ELSE),
-        LintId::of(&methods::FILTER_MAP),
-        LintId::of(&methods::FILTER_MAP_NEXT),
-        LintId::of(&methods::IMPLICIT_CLONE),
-        LintId::of(&methods::INEFFICIENT_TO_STRING),
-        LintId::of(&methods::MAP_FLATTEN),
-        LintId::of(&methods::MAP_UNWRAP_OR),
-        LintId::of(&misc::USED_UNDERSCORE_BINDING),
-        LintId::of(&misc_early::UNSEPARATED_LITERAL_SUFFIX),
-        LintId::of(&mut_mut::MUT_MUT),
-        LintId::of(&needless_continue::NEEDLESS_CONTINUE),
-        LintId::of(&needless_for_each::NEEDLESS_FOR_EACH),
-        LintId::of(&needless_pass_by_value::NEEDLESS_PASS_BY_VALUE),
-        LintId::of(&non_expressive_names::SIMILAR_NAMES),
-        LintId::of(&option_if_let_else::OPTION_IF_LET_ELSE),
-        LintId::of(&pass_by_ref_or_value::LARGE_TYPES_PASSED_BY_VALUE),
-        LintId::of(&pass_by_ref_or_value::TRIVIALLY_COPY_PASS_BY_REF),
-        LintId::of(&ranges::RANGE_MINUS_ONE),
-        LintId::of(&ranges::RANGE_PLUS_ONE),
-        LintId::of(&redundant_else::REDUNDANT_ELSE),
-        LintId::of(&ref_option_ref::REF_OPTION_REF),
-        LintId::of(&shadow::SHADOW_UNRELATED),
-        LintId::of(&strings::STRING_ADD_ASSIGN),
-        LintId::of(&trait_bounds::TRAIT_DUPLICATION_IN_BOUNDS),
-        LintId::of(&trait_bounds::TYPE_REPETITION_IN_BOUNDS),
-        LintId::of(&types::LINKEDLIST),
-        LintId::of(&types::OPTION_OPTION),
-        LintId::of(&unicode::NON_ASCII_LITERAL),
-        LintId::of(&unicode::UNICODE_NOT_NFC),
-        LintId::of(&unit_types::LET_UNIT_VALUE),
-        LintId::of(&unnecessary_wraps::UNNECESSARY_WRAPS),
-        LintId::of(&unnested_or_patterns::UNNESTED_OR_PATTERNS),
-        LintId::of(&unused_self::UNUSED_SELF),
-        LintId::of(&wildcard_imports::ENUM_GLOB_USE),
-        LintId::of(&wildcard_imports::WILDCARD_IMPORTS),
-        LintId::of(&zero_sized_map_values::ZERO_SIZED_MAP_VALUES),
+        LintId::of(attrs::INLINE_ALWAYS),
+        LintId::of(await_holding_invalid::AWAIT_HOLDING_LOCK),
+        LintId::of(await_holding_invalid::AWAIT_HOLDING_REFCELL_REF),
+        LintId::of(bit_mask::VERBOSE_BIT_MASK),
+        LintId::of(bytecount::NAIVE_BYTECOUNT),
+        LintId::of(case_sensitive_file_extension_comparisons::CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS),
+        LintId::of(casts::CAST_LOSSLESS),
+        LintId::of(casts::CAST_POSSIBLE_TRUNCATION),
+        LintId::of(casts::CAST_POSSIBLE_WRAP),
+        LintId::of(casts::CAST_PRECISION_LOSS),
+        LintId::of(casts::CAST_PTR_ALIGNMENT),
+        LintId::of(casts::CAST_SIGN_LOSS),
+        LintId::of(casts::PTR_AS_PTR),
+        LintId::of(checked_conversions::CHECKED_CONVERSIONS),
+        LintId::of(copies::SAME_FUNCTIONS_IN_IF_CONDITION),
+        LintId::of(copy_iterator::COPY_ITERATOR),
+        LintId::of(default::DEFAULT_TRAIT_ACCESS),
+        LintId::of(dereference::EXPLICIT_DEREF_METHODS),
+        LintId::of(derive::EXPL_IMPL_CLONE_ON_COPY),
+        LintId::of(derive::UNSAFE_DERIVE_DESERIALIZE),
+        LintId::of(doc::DOC_MARKDOWN),
+        LintId::of(doc::MISSING_ERRORS_DOC),
+        LintId::of(doc::MISSING_PANICS_DOC),
+        LintId::of(empty_enum::EMPTY_ENUM),
+        LintId::of(enum_variants::MODULE_NAME_REPETITIONS),
+        LintId::of(enum_variants::PUB_ENUM_VARIANT_NAMES),
+        LintId::of(eta_reduction::REDUNDANT_CLOSURE_FOR_METHOD_CALLS),
+        LintId::of(excessive_bools::FN_PARAMS_EXCESSIVE_BOOLS),
+        LintId::of(excessive_bools::STRUCT_EXCESSIVE_BOOLS),
+        LintId::of(functions::MUST_USE_CANDIDATE),
+        LintId::of(functions::TOO_MANY_LINES),
+        LintId::of(if_not_else::IF_NOT_ELSE),
+        LintId::of(implicit_hasher::IMPLICIT_HASHER),
+        LintId::of(implicit_saturating_sub::IMPLICIT_SATURATING_SUB),
+        LintId::of(infinite_iter::MAYBE_INFINITE_ITER),
+        LintId::of(invalid_upcast_comparisons::INVALID_UPCAST_COMPARISONS),
+        LintId::of(items_after_statements::ITEMS_AFTER_STATEMENTS),
+        LintId::of(large_stack_arrays::LARGE_STACK_ARRAYS),
+        LintId::of(let_underscore::LET_UNDERSCORE_DROP),
+        LintId::of(literal_representation::LARGE_DIGIT_GROUPS),
+        LintId::of(literal_representation::UNREADABLE_LITERAL),
+        LintId::of(loops::EXPLICIT_INTO_ITER_LOOP),
+        LintId::of(loops::EXPLICIT_ITER_LOOP),
+        LintId::of(macro_use::MACRO_USE_IMPORTS),
+        LintId::of(manual_ok_or::MANUAL_OK_OR),
+        LintId::of(match_on_vec_items::MATCH_ON_VEC_ITEMS),
+        LintId::of(matches::MATCH_BOOL),
+        LintId::of(matches::MATCH_SAME_ARMS),
+        LintId::of(matches::MATCH_WILDCARD_FOR_SINGLE_VARIANTS),
+        LintId::of(matches::MATCH_WILD_ERR_ARM),
+        LintId::of(matches::SINGLE_MATCH_ELSE),
+        LintId::of(methods::FILTER_MAP),
+        LintId::of(methods::FILTER_MAP_NEXT),
+        LintId::of(methods::IMPLICIT_CLONE),
+        LintId::of(methods::INEFFICIENT_TO_STRING),
+        LintId::of(methods::MAP_FLATTEN),
+        LintId::of(methods::MAP_UNWRAP_OR),
+        LintId::of(misc::USED_UNDERSCORE_BINDING),
+        LintId::of(misc_early::UNSEPARATED_LITERAL_SUFFIX),
+        LintId::of(mut_mut::MUT_MUT),
+        LintId::of(needless_continue::NEEDLESS_CONTINUE),
+        LintId::of(needless_for_each::NEEDLESS_FOR_EACH),
+        LintId::of(needless_pass_by_value::NEEDLESS_PASS_BY_VALUE),
+        LintId::of(non_expressive_names::SIMILAR_NAMES),
+        LintId::of(option_if_let_else::OPTION_IF_LET_ELSE),
+        LintId::of(pass_by_ref_or_value::LARGE_TYPES_PASSED_BY_VALUE),
+        LintId::of(pass_by_ref_or_value::TRIVIALLY_COPY_PASS_BY_REF),
+        LintId::of(ranges::RANGE_MINUS_ONE),
+        LintId::of(ranges::RANGE_PLUS_ONE),
+        LintId::of(redundant_else::REDUNDANT_ELSE),
+        LintId::of(ref_option_ref::REF_OPTION_REF),
+        LintId::of(shadow::SHADOW_UNRELATED),
+        LintId::of(strings::STRING_ADD_ASSIGN),
+        LintId::of(trait_bounds::TRAIT_DUPLICATION_IN_BOUNDS),
+        LintId::of(trait_bounds::TYPE_REPETITION_IN_BOUNDS),
+        LintId::of(types::LINKEDLIST),
+        LintId::of(types::OPTION_OPTION),
+        LintId::of(unicode::NON_ASCII_LITERAL),
+        LintId::of(unicode::UNICODE_NOT_NFC),
+        LintId::of(unit_types::LET_UNIT_VALUE),
+        LintId::of(unnecessary_wraps::UNNECESSARY_WRAPS),
+        LintId::of(unnested_or_patterns::UNNESTED_OR_PATTERNS),
+        LintId::of(unused_self::UNUSED_SELF),
+        LintId::of(wildcard_imports::ENUM_GLOB_USE),
+        LintId::of(wildcard_imports::WILDCARD_IMPORTS),
+        LintId::of(zero_sized_map_values::ZERO_SIZED_MAP_VALUES),
     ]);
 
     #[cfg(feature = "internal-lints")]
     store.register_group(true, "clippy::internal", Some("clippy_internal"), vec![
-        LintId::of(&utils::internal_lints::CLIPPY_LINTS_INTERNAL),
-        LintId::of(&utils::internal_lints::COLLAPSIBLE_SPAN_LINT_CALLS),
-        LintId::of(&utils::internal_lints::COMPILER_LINT_FUNCTIONS),
-        LintId::of(&utils::internal_lints::DEFAULT_LINT),
-        LintId::of(&utils::internal_lints::IF_CHAIN_STYLE),
-        LintId::of(&utils::internal_lints::INTERNING_DEFINED_SYMBOL),
-        LintId::of(&utils::internal_lints::INVALID_PATHS),
-        LintId::of(&utils::internal_lints::LINT_WITHOUT_LINT_PASS),
-        LintId::of(&utils::internal_lints::MATCH_TYPE_ON_DIAGNOSTIC_ITEM),
-        LintId::of(&utils::internal_lints::OUTER_EXPN_EXPN_DATA),
-        LintId::of(&utils::internal_lints::PRODUCE_ICE),
-        LintId::of(&utils::internal_lints::UNNECESSARY_SYMBOL_STR),
+        LintId::of(utils::internal_lints::CLIPPY_LINTS_INTERNAL),
+        LintId::of(utils::internal_lints::COLLAPSIBLE_SPAN_LINT_CALLS),
+        LintId::of(utils::internal_lints::COMPILER_LINT_FUNCTIONS),
+        LintId::of(utils::internal_lints::DEFAULT_LINT),
+        LintId::of(utils::internal_lints::IF_CHAIN_STYLE),
+        LintId::of(utils::internal_lints::INTERNING_DEFINED_SYMBOL),
+        LintId::of(utils::internal_lints::INVALID_PATHS),
+        LintId::of(utils::internal_lints::LINT_WITHOUT_LINT_PASS),
+        LintId::of(utils::internal_lints::MATCH_TYPE_ON_DIAGNOSTIC_ITEM),
+        LintId::of(utils::internal_lints::OUTER_EXPN_EXPN_DATA),
+        LintId::of(utils::internal_lints::PRODUCE_ICE),
+        LintId::of(utils::internal_lints::UNNECESSARY_SYMBOL_STR),
     ]);
 
     store.register_group(true, "clippy::all", Some("clippy"), vec![
-        LintId::of(&absurd_extreme_comparisons::ABSURD_EXTREME_COMPARISONS),
-        LintId::of(&approx_const::APPROX_CONSTANT),
-        LintId::of(&assertions_on_constants::ASSERTIONS_ON_CONSTANTS),
-        LintId::of(&assign_ops::ASSIGN_OP_PATTERN),
-        LintId::of(&assign_ops::MISREFACTORED_ASSIGN_OP),
-        LintId::of(&async_yields_async::ASYNC_YIELDS_ASYNC),
-        LintId::of(&atomic_ordering::INVALID_ATOMIC_ORDERING),
-        LintId::of(&attrs::BLANKET_CLIPPY_RESTRICTION_LINTS),
-        LintId::of(&attrs::DEPRECATED_CFG_ATTR),
-        LintId::of(&attrs::DEPRECATED_SEMVER),
-        LintId::of(&attrs::MISMATCHED_TARGET_OS),
-        LintId::of(&attrs::USELESS_ATTRIBUTE),
-        LintId::of(&bit_mask::BAD_BIT_MASK),
-        LintId::of(&bit_mask::INEFFECTIVE_BIT_MASK),
-        LintId::of(&blacklisted_name::BLACKLISTED_NAME),
-        LintId::of(&blocks_in_if_conditions::BLOCKS_IN_IF_CONDITIONS),
-        LintId::of(&booleans::LOGIC_BUG),
-        LintId::of(&booleans::NONMINIMAL_BOOL),
-        LintId::of(&casts::CAST_REF_TO_MUT),
-        LintId::of(&casts::CHAR_LIT_AS_U8),
-        LintId::of(&casts::FN_TO_NUMERIC_CAST),
-        LintId::of(&casts::FN_TO_NUMERIC_CAST_WITH_TRUNCATION),
-        LintId::of(&casts::UNNECESSARY_CAST),
-        LintId::of(&collapsible_if::COLLAPSIBLE_ELSE_IF),
-        LintId::of(&collapsible_if::COLLAPSIBLE_IF),
-        LintId::of(&collapsible_match::COLLAPSIBLE_MATCH),
-        LintId::of(&comparison_chain::COMPARISON_CHAIN),
-        LintId::of(&copies::BRANCHES_SHARING_CODE),
-        LintId::of(&copies::IFS_SAME_COND),
-        LintId::of(&copies::IF_SAME_THEN_ELSE),
-        LintId::of(&default::FIELD_REASSIGN_WITH_DEFAULT),
-        LintId::of(&derive::DERIVE_HASH_XOR_EQ),
-        LintId::of(&derive::DERIVE_ORD_XOR_PARTIAL_ORD),
-        LintId::of(&doc::MISSING_SAFETY_DOC),
-        LintId::of(&doc::NEEDLESS_DOCTEST_MAIN),
-        LintId::of(&double_comparison::DOUBLE_COMPARISONS),
-        LintId::of(&double_parens::DOUBLE_PARENS),
-        LintId::of(&drop_forget_ref::DROP_COPY),
-        LintId::of(&drop_forget_ref::DROP_REF),
-        LintId::of(&drop_forget_ref::FORGET_COPY),
-        LintId::of(&drop_forget_ref::FORGET_REF),
-        LintId::of(&duration_subsec::DURATION_SUBSEC),
-        LintId::of(&entry::MAP_ENTRY),
-        LintId::of(&enum_clike::ENUM_CLIKE_UNPORTABLE_VARIANT),
-        LintId::of(&enum_variants::ENUM_VARIANT_NAMES),
-        LintId::of(&enum_variants::MODULE_INCEPTION),
-        LintId::of(&eq_op::EQ_OP),
-        LintId::of(&eq_op::OP_REF),
-        LintId::of(&erasing_op::ERASING_OP),
-        LintId::of(&escape::BOXED_LOCAL),
-        LintId::of(&eta_reduction::REDUNDANT_CLOSURE),
-        LintId::of(&eval_order_dependence::DIVERGING_SUB_EXPRESSION),
-        LintId::of(&eval_order_dependence::EVAL_ORDER_DEPENDENCE),
-        LintId::of(&explicit_write::EXPLICIT_WRITE),
-        LintId::of(&float_equality_without_abs::FLOAT_EQUALITY_WITHOUT_ABS),
-        LintId::of(&float_literal::EXCESSIVE_PRECISION),
-        LintId::of(&format::USELESS_FORMAT),
-        LintId::of(&formatting::POSSIBLE_MISSING_COMMA),
-        LintId::of(&formatting::SUSPICIOUS_ASSIGNMENT_FORMATTING),
-        LintId::of(&formatting::SUSPICIOUS_ELSE_FORMATTING),
-        LintId::of(&formatting::SUSPICIOUS_UNARY_OP_FORMATTING),
-        LintId::of(&from_over_into::FROM_OVER_INTO),
-        LintId::of(&from_str_radix_10::FROM_STR_RADIX_10),
-        LintId::of(&functions::DOUBLE_MUST_USE),
-        LintId::of(&functions::MUST_USE_UNIT),
-        LintId::of(&functions::NOT_UNSAFE_PTR_ARG_DEREF),
-        LintId::of(&functions::RESULT_UNIT_ERR),
-        LintId::of(&functions::TOO_MANY_ARGUMENTS),
-        LintId::of(&get_last_with_len::GET_LAST_WITH_LEN),
-        LintId::of(&identity_op::IDENTITY_OP),
-        LintId::of(&if_let_mutex::IF_LET_MUTEX),
-        LintId::of(&if_let_some_result::IF_LET_SOME_RESULT),
-        LintId::of(&inconsistent_struct_constructor::INCONSISTENT_STRUCT_CONSTRUCTOR),
-        LintId::of(&indexing_slicing::OUT_OF_BOUNDS_INDEXING),
-        LintId::of(&infinite_iter::INFINITE_ITER),
-        LintId::of(&inherent_to_string::INHERENT_TO_STRING),
-        LintId::of(&inherent_to_string::INHERENT_TO_STRING_SHADOW_DISPLAY),
-        LintId::of(&inline_fn_without_body::INLINE_FN_WITHOUT_BODY),
-        LintId::of(&int_plus_one::INT_PLUS_ONE),
-        LintId::of(&large_const_arrays::LARGE_CONST_ARRAYS),
-        LintId::of(&large_enum_variant::LARGE_ENUM_VARIANT),
-        LintId::of(&len_zero::COMPARISON_TO_EMPTY),
-        LintId::of(&len_zero::LEN_WITHOUT_IS_EMPTY),
-        LintId::of(&len_zero::LEN_ZERO),
-        LintId::of(&let_underscore::LET_UNDERSCORE_LOCK),
-        LintId::of(&lifetimes::EXTRA_UNUSED_LIFETIMES),
-        LintId::of(&lifetimes::NEEDLESS_LIFETIMES),
-        LintId::of(&literal_representation::INCONSISTENT_DIGIT_GROUPING),
-        LintId::of(&literal_representation::MISTYPED_LITERAL_SUFFIXES),
-        LintId::of(&literal_representation::UNUSUAL_BYTE_GROUPINGS),
-        LintId::of(&loops::EMPTY_LOOP),
-        LintId::of(&loops::EXPLICIT_COUNTER_LOOP),
-        LintId::of(&loops::FOR_KV_MAP),
-        LintId::of(&loops::FOR_LOOPS_OVER_FALLIBLES),
-        LintId::of(&loops::ITER_NEXT_LOOP),
-        LintId::of(&loops::MANUAL_FLATTEN),
-        LintId::of(&loops::MANUAL_MEMCPY),
-        LintId::of(&loops::MUT_RANGE_BOUND),
-        LintId::of(&loops::NEEDLESS_COLLECT),
-        LintId::of(&loops::NEEDLESS_RANGE_LOOP),
-        LintId::of(&loops::NEVER_LOOP),
-        LintId::of(&loops::SAME_ITEM_PUSH),
-        LintId::of(&loops::SINGLE_ELEMENT_LOOP),
-        LintId::of(&loops::WHILE_IMMUTABLE_CONDITION),
-        LintId::of(&loops::WHILE_LET_LOOP),
-        LintId::of(&loops::WHILE_LET_ON_ITERATOR),
-        LintId::of(&main_recursion::MAIN_RECURSION),
-        LintId::of(&manual_async_fn::MANUAL_ASYNC_FN),
-        LintId::of(&manual_map::MANUAL_MAP),
-        LintId::of(&manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE),
-        LintId::of(&manual_strip::MANUAL_STRIP),
-        LintId::of(&manual_unwrap_or::MANUAL_UNWRAP_OR),
-        LintId::of(&map_clone::MAP_CLONE),
-        LintId::of(&map_identity::MAP_IDENTITY),
-        LintId::of(&map_unit_fn::OPTION_MAP_UNIT_FN),
-        LintId::of(&map_unit_fn::RESULT_MAP_UNIT_FN),
-        LintId::of(&matches::INFALLIBLE_DESTRUCTURING_MATCH),
-        LintId::of(&matches::MATCH_AS_REF),
-        LintId::of(&matches::MATCH_LIKE_MATCHES_MACRO),
-        LintId::of(&matches::MATCH_OVERLAPPING_ARM),
-        LintId::of(&matches::MATCH_REF_PATS),
-        LintId::of(&matches::MATCH_SINGLE_BINDING),
-        LintId::of(&matches::REDUNDANT_PATTERN_MATCHING),
-        LintId::of(&matches::SINGLE_MATCH),
-        LintId::of(&matches::WILDCARD_IN_OR_PATTERNS),
-        LintId::of(&mem_discriminant::MEM_DISCRIMINANT_NON_ENUM),
-        LintId::of(&mem_replace::MEM_REPLACE_OPTION_WITH_NONE),
-        LintId::of(&mem_replace::MEM_REPLACE_WITH_DEFAULT),
-        LintId::of(&mem_replace::MEM_REPLACE_WITH_UNINIT),
-        LintId::of(&methods::BIND_INSTEAD_OF_MAP),
-        LintId::of(&methods::BYTES_NTH),
-        LintId::of(&methods::CHARS_LAST_CMP),
-        LintId::of(&methods::CHARS_NEXT_CMP),
-        LintId::of(&methods::CLONE_DOUBLE_REF),
-        LintId::of(&methods::CLONE_ON_COPY),
-        LintId::of(&methods::EXPECT_FUN_CALL),
-        LintId::of(&methods::FILTER_MAP_IDENTITY),
-        LintId::of(&methods::FILTER_NEXT),
-        LintId::of(&methods::FLAT_MAP_IDENTITY),
-        LintId::of(&methods::FROM_ITER_INSTEAD_OF_COLLECT),
-        LintId::of(&methods::INSPECT_FOR_EACH),
-        LintId::of(&methods::INTO_ITER_ON_REF),
-        LintId::of(&methods::ITERATOR_STEP_BY_ZERO),
-        LintId::of(&methods::ITER_CLONED_COLLECT),
-        LintId::of(&methods::ITER_COUNT),
-        LintId::of(&methods::ITER_NEXT_SLICE),
-        LintId::of(&methods::ITER_NTH),
-        LintId::of(&methods::ITER_NTH_ZERO),
-        LintId::of(&methods::ITER_SKIP_NEXT),
-        LintId::of(&methods::MANUAL_FILTER_MAP),
-        LintId::of(&methods::MANUAL_FIND_MAP),
-        LintId::of(&methods::MANUAL_SATURATING_ARITHMETIC),
-        LintId::of(&methods::MAP_COLLECT_RESULT_UNIT),
-        LintId::of(&methods::NEW_RET_NO_SELF),
-        LintId::of(&methods::OK_EXPECT),
-        LintId::of(&methods::OPTION_AS_REF_DEREF),
-        LintId::of(&methods::OPTION_FILTER_MAP),
-        LintId::of(&methods::OPTION_MAP_OR_NONE),
-        LintId::of(&methods::OR_FUN_CALL),
-        LintId::of(&methods::RESULT_MAP_OR_INTO_OPTION),
-        LintId::of(&methods::SEARCH_IS_SOME),
-        LintId::of(&methods::SHOULD_IMPLEMENT_TRAIT),
-        LintId::of(&methods::SINGLE_CHAR_ADD_STR),
-        LintId::of(&methods::SINGLE_CHAR_PATTERN),
-        LintId::of(&methods::SKIP_WHILE_NEXT),
-        LintId::of(&methods::STRING_EXTEND_CHARS),
-        LintId::of(&methods::SUSPICIOUS_MAP),
-        LintId::of(&methods::UNINIT_ASSUMED_INIT),
-        LintId::of(&methods::UNNECESSARY_FILTER_MAP),
-        LintId::of(&methods::UNNECESSARY_FOLD),
-        LintId::of(&methods::UNNECESSARY_LAZY_EVALUATIONS),
-        LintId::of(&methods::USELESS_ASREF),
-        LintId::of(&methods::WRONG_SELF_CONVENTION),
-        LintId::of(&methods::ZST_OFFSET),
-        LintId::of(&minmax::MIN_MAX),
-        LintId::of(&misc::CMP_NAN),
-        LintId::of(&misc::CMP_OWNED),
-        LintId::of(&misc::FLOAT_CMP),
-        LintId::of(&misc::MODULO_ONE),
-        LintId::of(&misc::SHORT_CIRCUIT_STATEMENT),
-        LintId::of(&misc::TOPLEVEL_REF_ARG),
-        LintId::of(&misc::ZERO_PTR),
-        LintId::of(&misc_early::BUILTIN_TYPE_SHADOW),
-        LintId::of(&misc_early::DOUBLE_NEG),
-        LintId::of(&misc_early::DUPLICATE_UNDERSCORE_ARGUMENT),
-        LintId::of(&misc_early::MIXED_CASE_HEX_LITERALS),
-        LintId::of(&misc_early::REDUNDANT_PATTERN),
-        LintId::of(&misc_early::UNNEEDED_WILDCARD_PATTERN),
-        LintId::of(&misc_early::ZERO_PREFIXED_LITERAL),
-        LintId::of(&mut_key::MUTABLE_KEY_TYPE),
-        LintId::of(&mut_mutex_lock::MUT_MUTEX_LOCK),
-        LintId::of(&mut_reference::UNNECESSARY_MUT_PASSED),
-        LintId::of(&mutex_atomic::MUTEX_ATOMIC),
-        LintId::of(&needless_arbitrary_self_type::NEEDLESS_ARBITRARY_SELF_TYPE),
-        LintId::of(&needless_bool::BOOL_COMPARISON),
-        LintId::of(&needless_bool::NEEDLESS_BOOL),
-        LintId::of(&needless_borrowed_ref::NEEDLESS_BORROWED_REFERENCE),
-        LintId::of(&needless_question_mark::NEEDLESS_QUESTION_MARK),
-        LintId::of(&needless_update::NEEDLESS_UPDATE),
-        LintId::of(&neg_cmp_op_on_partial_ord::NEG_CMP_OP_ON_PARTIAL_ORD),
-        LintId::of(&neg_multiply::NEG_MULTIPLY),
-        LintId::of(&new_without_default::NEW_WITHOUT_DEFAULT),
-        LintId::of(&no_effect::NO_EFFECT),
-        LintId::of(&no_effect::UNNECESSARY_OPERATION),
-        LintId::of(&non_copy_const::BORROW_INTERIOR_MUTABLE_CONST),
-        LintId::of(&non_copy_const::DECLARE_INTERIOR_MUTABLE_CONST),
-        LintId::of(&non_expressive_names::JUST_UNDERSCORES_AND_DIGITS),
-        LintId::of(&non_expressive_names::MANY_SINGLE_CHAR_NAMES),
-        LintId::of(&non_octal_unix_permissions::NON_OCTAL_UNIX_PERMISSIONS),
-        LintId::of(&open_options::NONSENSICAL_OPEN_OPTIONS),
-        LintId::of(&option_env_unwrap::OPTION_ENV_UNWRAP),
-        LintId::of(&overflow_check_conditional::OVERFLOW_CHECK_CONDITIONAL),
-        LintId::of(&partialeq_ne_impl::PARTIALEQ_NE_IMPL),
-        LintId::of(&precedence::PRECEDENCE),
-        LintId::of(&ptr::CMP_NULL),
-        LintId::of(&ptr::MUT_FROM_REF),
-        LintId::of(&ptr::PTR_ARG),
-        LintId::of(&ptr_eq::PTR_EQ),
-        LintId::of(&ptr_offset_with_cast::PTR_OFFSET_WITH_CAST),
-        LintId::of(&question_mark::QUESTION_MARK),
-        LintId::of(&ranges::MANUAL_RANGE_CONTAINS),
-        LintId::of(&ranges::RANGE_ZIP_WITH_LEN),
-        LintId::of(&ranges::REVERSED_EMPTY_RANGES),
-        LintId::of(&redundant_clone::REDUNDANT_CLONE),
-        LintId::of(&redundant_closure_call::REDUNDANT_CLOSURE_CALL),
-        LintId::of(&redundant_field_names::REDUNDANT_FIELD_NAMES),
-        LintId::of(&redundant_slicing::REDUNDANT_SLICING),
-        LintId::of(&redundant_static_lifetimes::REDUNDANT_STATIC_LIFETIMES),
-        LintId::of(&reference::DEREF_ADDROF),
-        LintId::of(&reference::REF_IN_DEREF),
-        LintId::of(&regex::INVALID_REGEX),
-        LintId::of(&repeat_once::REPEAT_ONCE),
-        LintId::of(&returns::LET_AND_RETURN),
-        LintId::of(&returns::NEEDLESS_RETURN),
-        LintId::of(&self_assignment::SELF_ASSIGNMENT),
-        LintId::of(&serde_api::SERDE_API_MISUSE),
-        LintId::of(&single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS),
-        LintId::of(&size_of_in_element_count::SIZE_OF_IN_ELEMENT_COUNT),
-        LintId::of(&slow_vector_initialization::SLOW_VECTOR_INITIALIZATION),
-        LintId::of(&stable_sort_primitive::STABLE_SORT_PRIMITIVE),
-        LintId::of(&strings::STRING_FROM_UTF8_AS_BYTES),
-        LintId::of(&suspicious_operation_groupings::SUSPICIOUS_OPERATION_GROUPINGS),
-        LintId::of(&suspicious_trait_impl::SUSPICIOUS_ARITHMETIC_IMPL),
-        LintId::of(&suspicious_trait_impl::SUSPICIOUS_OP_ASSIGN_IMPL),
-        LintId::of(&swap::ALMOST_SWAPPED),
-        LintId::of(&swap::MANUAL_SWAP),
-        LintId::of(&tabs_in_doc_comments::TABS_IN_DOC_COMMENTS),
-        LintId::of(&temporary_assignment::TEMPORARY_ASSIGNMENT),
-        LintId::of(&to_digit_is_some::TO_DIGIT_IS_SOME),
-        LintId::of(&to_string_in_display::TO_STRING_IN_DISPLAY),
-        LintId::of(&transmute::CROSSPOINTER_TRANSMUTE),
-        LintId::of(&transmute::TRANSMUTES_EXPRESSIBLE_AS_PTR_CASTS),
-        LintId::of(&transmute::TRANSMUTE_BYTES_TO_STR),
-        LintId::of(&transmute::TRANSMUTE_FLOAT_TO_INT),
-        LintId::of(&transmute::TRANSMUTE_INT_TO_BOOL),
-        LintId::of(&transmute::TRANSMUTE_INT_TO_CHAR),
-        LintId::of(&transmute::TRANSMUTE_INT_TO_FLOAT),
-        LintId::of(&transmute::TRANSMUTE_PTR_TO_PTR),
-        LintId::of(&transmute::TRANSMUTE_PTR_TO_REF),
-        LintId::of(&transmute::UNSOUND_COLLECTION_TRANSMUTE),
-        LintId::of(&transmute::WRONG_TRANSMUTE),
-        LintId::of(&transmuting_null::TRANSMUTING_NULL),
-        LintId::of(&try_err::TRY_ERR),
-        LintId::of(&types::BORROWED_BOX),
-        LintId::of(&types::BOX_VEC),
-        LintId::of(&types::REDUNDANT_ALLOCATION),
-        LintId::of(&types::TYPE_COMPLEXITY),
-        LintId::of(&types::VEC_BOX),
-        LintId::of(&undropped_manually_drops::UNDROPPED_MANUALLY_DROPS),
-        LintId::of(&unicode::INVISIBLE_CHARACTERS),
-        LintId::of(&unit_return_expecting_ord::UNIT_RETURN_EXPECTING_ORD),
-        LintId::of(&unit_types::UNIT_ARG),
-        LintId::of(&unit_types::UNIT_CMP),
-        LintId::of(&unnamed_address::FN_ADDRESS_COMPARISONS),
-        LintId::of(&unnamed_address::VTABLE_ADDRESS_COMPARISONS),
-        LintId::of(&unnecessary_sort_by::UNNECESSARY_SORT_BY),
-        LintId::of(&unsafe_removed_from_name::UNSAFE_REMOVED_FROM_NAME),
-        LintId::of(&unused_io_amount::UNUSED_IO_AMOUNT),
-        LintId::of(&unused_unit::UNUSED_UNIT),
-        LintId::of(&unwrap::PANICKING_UNWRAP),
-        LintId::of(&unwrap::UNNECESSARY_UNWRAP),
-        LintId::of(&upper_case_acronyms::UPPER_CASE_ACRONYMS),
-        LintId::of(&useless_conversion::USELESS_CONVERSION),
-        LintId::of(&vec::USELESS_VEC),
-        LintId::of(&vec_init_then_push::VEC_INIT_THEN_PUSH),
-        LintId::of(&vec_resize_to_zero::VEC_RESIZE_TO_ZERO),
-        LintId::of(&write::PRINTLN_EMPTY_STRING),
-        LintId::of(&write::PRINT_LITERAL),
-        LintId::of(&write::PRINT_WITH_NEWLINE),
-        LintId::of(&write::WRITELN_EMPTY_STRING),
-        LintId::of(&write::WRITE_LITERAL),
-        LintId::of(&write::WRITE_WITH_NEWLINE),
-        LintId::of(&zero_div_zero::ZERO_DIVIDED_BY_ZERO),
+        LintId::of(absurd_extreme_comparisons::ABSURD_EXTREME_COMPARISONS),
+        LintId::of(approx_const::APPROX_CONSTANT),
+        LintId::of(assertions_on_constants::ASSERTIONS_ON_CONSTANTS),
+        LintId::of(assign_ops::ASSIGN_OP_PATTERN),
+        LintId::of(assign_ops::MISREFACTORED_ASSIGN_OP),
+        LintId::of(async_yields_async::ASYNC_YIELDS_ASYNC),
+        LintId::of(atomic_ordering::INVALID_ATOMIC_ORDERING),
+        LintId::of(attrs::BLANKET_CLIPPY_RESTRICTION_LINTS),
+        LintId::of(attrs::DEPRECATED_CFG_ATTR),
+        LintId::of(attrs::DEPRECATED_SEMVER),
+        LintId::of(attrs::MISMATCHED_TARGET_OS),
+        LintId::of(attrs::USELESS_ATTRIBUTE),
+        LintId::of(bit_mask::BAD_BIT_MASK),
+        LintId::of(bit_mask::INEFFECTIVE_BIT_MASK),
+        LintId::of(blacklisted_name::BLACKLISTED_NAME),
+        LintId::of(blocks_in_if_conditions::BLOCKS_IN_IF_CONDITIONS),
+        LintId::of(booleans::LOGIC_BUG),
+        LintId::of(booleans::NONMINIMAL_BOOL),
+        LintId::of(casts::CAST_REF_TO_MUT),
+        LintId::of(casts::CHAR_LIT_AS_U8),
+        LintId::of(casts::FN_TO_NUMERIC_CAST),
+        LintId::of(casts::FN_TO_NUMERIC_CAST_WITH_TRUNCATION),
+        LintId::of(casts::UNNECESSARY_CAST),
+        LintId::of(collapsible_if::COLLAPSIBLE_ELSE_IF),
+        LintId::of(collapsible_if::COLLAPSIBLE_IF),
+        LintId::of(collapsible_match::COLLAPSIBLE_MATCH),
+        LintId::of(comparison_chain::COMPARISON_CHAIN),
+        LintId::of(copies::BRANCHES_SHARING_CODE),
+        LintId::of(copies::IFS_SAME_COND),
+        LintId::of(copies::IF_SAME_THEN_ELSE),
+        LintId::of(default::FIELD_REASSIGN_WITH_DEFAULT),
+        LintId::of(derive::DERIVE_HASH_XOR_EQ),
+        LintId::of(derive::DERIVE_ORD_XOR_PARTIAL_ORD),
+        LintId::of(doc::MISSING_SAFETY_DOC),
+        LintId::of(doc::NEEDLESS_DOCTEST_MAIN),
+        LintId::of(double_comparison::DOUBLE_COMPARISONS),
+        LintId::of(double_parens::DOUBLE_PARENS),
+        LintId::of(drop_forget_ref::DROP_COPY),
+        LintId::of(drop_forget_ref::DROP_REF),
+        LintId::of(drop_forget_ref::FORGET_COPY),
+        LintId::of(drop_forget_ref::FORGET_REF),
+        LintId::of(duration_subsec::DURATION_SUBSEC),
+        LintId::of(entry::MAP_ENTRY),
+        LintId::of(enum_clike::ENUM_CLIKE_UNPORTABLE_VARIANT),
+        LintId::of(enum_variants::ENUM_VARIANT_NAMES),
+        LintId::of(enum_variants::MODULE_INCEPTION),
+        LintId::of(eq_op::EQ_OP),
+        LintId::of(eq_op::OP_REF),
+        LintId::of(erasing_op::ERASING_OP),
+        LintId::of(escape::BOXED_LOCAL),
+        LintId::of(eta_reduction::REDUNDANT_CLOSURE),
+        LintId::of(eval_order_dependence::DIVERGING_SUB_EXPRESSION),
+        LintId::of(eval_order_dependence::EVAL_ORDER_DEPENDENCE),
+        LintId::of(explicit_write::EXPLICIT_WRITE),
+        LintId::of(float_equality_without_abs::FLOAT_EQUALITY_WITHOUT_ABS),
+        LintId::of(float_literal::EXCESSIVE_PRECISION),
+        LintId::of(format::USELESS_FORMAT),
+        LintId::of(formatting::POSSIBLE_MISSING_COMMA),
+        LintId::of(formatting::SUSPICIOUS_ASSIGNMENT_FORMATTING),
+        LintId::of(formatting::SUSPICIOUS_ELSE_FORMATTING),
+        LintId::of(formatting::SUSPICIOUS_UNARY_OP_FORMATTING),
+        LintId::of(from_over_into::FROM_OVER_INTO),
+        LintId::of(from_str_radix_10::FROM_STR_RADIX_10),
+        LintId::of(functions::DOUBLE_MUST_USE),
+        LintId::of(functions::MUST_USE_UNIT),
+        LintId::of(functions::NOT_UNSAFE_PTR_ARG_DEREF),
+        LintId::of(functions::RESULT_UNIT_ERR),
+        LintId::of(functions::TOO_MANY_ARGUMENTS),
+        LintId::of(get_last_with_len::GET_LAST_WITH_LEN),
+        LintId::of(identity_op::IDENTITY_OP),
+        LintId::of(if_let_mutex::IF_LET_MUTEX),
+        LintId::of(if_let_some_result::IF_LET_SOME_RESULT),
+        LintId::of(inconsistent_struct_constructor::INCONSISTENT_STRUCT_CONSTRUCTOR),
+        LintId::of(indexing_slicing::OUT_OF_BOUNDS_INDEXING),
+        LintId::of(infinite_iter::INFINITE_ITER),
+        LintId::of(inherent_to_string::INHERENT_TO_STRING),
+        LintId::of(inherent_to_string::INHERENT_TO_STRING_SHADOW_DISPLAY),
+        LintId::of(inline_fn_without_body::INLINE_FN_WITHOUT_BODY),
+        LintId::of(int_plus_one::INT_PLUS_ONE),
+        LintId::of(large_const_arrays::LARGE_CONST_ARRAYS),
+        LintId::of(large_enum_variant::LARGE_ENUM_VARIANT),
+        LintId::of(len_zero::COMPARISON_TO_EMPTY),
+        LintId::of(len_zero::LEN_WITHOUT_IS_EMPTY),
+        LintId::of(len_zero::LEN_ZERO),
+        LintId::of(let_underscore::LET_UNDERSCORE_LOCK),
+        LintId::of(lifetimes::EXTRA_UNUSED_LIFETIMES),
+        LintId::of(lifetimes::NEEDLESS_LIFETIMES),
+        LintId::of(literal_representation::INCONSISTENT_DIGIT_GROUPING),
+        LintId::of(literal_representation::MISTYPED_LITERAL_SUFFIXES),
+        LintId::of(literal_representation::UNUSUAL_BYTE_GROUPINGS),
+        LintId::of(loops::EMPTY_LOOP),
+        LintId::of(loops::EXPLICIT_COUNTER_LOOP),
+        LintId::of(loops::FOR_KV_MAP),
+        LintId::of(loops::FOR_LOOPS_OVER_FALLIBLES),
+        LintId::of(loops::ITER_NEXT_LOOP),
+        LintId::of(loops::MANUAL_FLATTEN),
+        LintId::of(loops::MANUAL_MEMCPY),
+        LintId::of(loops::MUT_RANGE_BOUND),
+        LintId::of(loops::NEEDLESS_COLLECT),
+        LintId::of(loops::NEEDLESS_RANGE_LOOP),
+        LintId::of(loops::NEVER_LOOP),
+        LintId::of(loops::SAME_ITEM_PUSH),
+        LintId::of(loops::SINGLE_ELEMENT_LOOP),
+        LintId::of(loops::WHILE_IMMUTABLE_CONDITION),
+        LintId::of(loops::WHILE_LET_LOOP),
+        LintId::of(loops::WHILE_LET_ON_ITERATOR),
+        LintId::of(main_recursion::MAIN_RECURSION),
+        LintId::of(manual_async_fn::MANUAL_ASYNC_FN),
+        LintId::of(manual_map::MANUAL_MAP),
+        LintId::of(manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE),
+        LintId::of(manual_strip::MANUAL_STRIP),
+        LintId::of(manual_unwrap_or::MANUAL_UNWRAP_OR),
+        LintId::of(map_clone::MAP_CLONE),
+        LintId::of(map_identity::MAP_IDENTITY),
+        LintId::of(map_unit_fn::OPTION_MAP_UNIT_FN),
+        LintId::of(map_unit_fn::RESULT_MAP_UNIT_FN),
+        LintId::of(matches::INFALLIBLE_DESTRUCTURING_MATCH),
+        LintId::of(matches::MATCH_AS_REF),
+        LintId::of(matches::MATCH_LIKE_MATCHES_MACRO),
+        LintId::of(matches::MATCH_OVERLAPPING_ARM),
+        LintId::of(matches::MATCH_REF_PATS),
+        LintId::of(matches::MATCH_SINGLE_BINDING),
+        LintId::of(matches::REDUNDANT_PATTERN_MATCHING),
+        LintId::of(matches::SINGLE_MATCH),
+        LintId::of(matches::WILDCARD_IN_OR_PATTERNS),
+        LintId::of(mem_discriminant::MEM_DISCRIMINANT_NON_ENUM),
+        LintId::of(mem_replace::MEM_REPLACE_OPTION_WITH_NONE),
+        LintId::of(mem_replace::MEM_REPLACE_WITH_DEFAULT),
+        LintId::of(mem_replace::MEM_REPLACE_WITH_UNINIT),
+        LintId::of(methods::BIND_INSTEAD_OF_MAP),
+        LintId::of(methods::BYTES_NTH),
+        LintId::of(methods::CHARS_LAST_CMP),
+        LintId::of(methods::CHARS_NEXT_CMP),
+        LintId::of(methods::CLONE_DOUBLE_REF),
+        LintId::of(methods::CLONE_ON_COPY),
+        LintId::of(methods::EXPECT_FUN_CALL),
+        LintId::of(methods::FILTER_MAP_IDENTITY),
+        LintId::of(methods::FILTER_NEXT),
+        LintId::of(methods::FLAT_MAP_IDENTITY),
+        LintId::of(methods::FROM_ITER_INSTEAD_OF_COLLECT),
+        LintId::of(methods::INSPECT_FOR_EACH),
+        LintId::of(methods::INTO_ITER_ON_REF),
+        LintId::of(methods::ITERATOR_STEP_BY_ZERO),
+        LintId::of(methods::ITER_CLONED_COLLECT),
+        LintId::of(methods::ITER_COUNT),
+        LintId::of(methods::ITER_NEXT_SLICE),
+        LintId::of(methods::ITER_NTH),
+        LintId::of(methods::ITER_NTH_ZERO),
+        LintId::of(methods::ITER_SKIP_NEXT),
+        LintId::of(methods::MANUAL_FILTER_MAP),
+        LintId::of(methods::MANUAL_FIND_MAP),
+        LintId::of(methods::MANUAL_SATURATING_ARITHMETIC),
+        LintId::of(methods::MAP_COLLECT_RESULT_UNIT),
+        LintId::of(methods::NEW_RET_NO_SELF),
+        LintId::of(methods::OK_EXPECT),
+        LintId::of(methods::OPTION_AS_REF_DEREF),
+        LintId::of(methods::OPTION_FILTER_MAP),
+        LintId::of(methods::OPTION_MAP_OR_NONE),
+        LintId::of(methods::OR_FUN_CALL),
+        LintId::of(methods::RESULT_MAP_OR_INTO_OPTION),
+        LintId::of(methods::SEARCH_IS_SOME),
+        LintId::of(methods::SHOULD_IMPLEMENT_TRAIT),
+        LintId::of(methods::SINGLE_CHAR_ADD_STR),
+        LintId::of(methods::SINGLE_CHAR_PATTERN),
+        LintId::of(methods::SKIP_WHILE_NEXT),
+        LintId::of(methods::STRING_EXTEND_CHARS),
+        LintId::of(methods::SUSPICIOUS_MAP),
+        LintId::of(methods::UNINIT_ASSUMED_INIT),
+        LintId::of(methods::UNNECESSARY_FILTER_MAP),
+        LintId::of(methods::UNNECESSARY_FOLD),
+        LintId::of(methods::UNNECESSARY_LAZY_EVALUATIONS),
+        LintId::of(methods::USELESS_ASREF),
+        LintId::of(methods::WRONG_SELF_CONVENTION),
+        LintId::of(methods::ZST_OFFSET),
+        LintId::of(minmax::MIN_MAX),
+        LintId::of(misc::CMP_NAN),
+        LintId::of(misc::CMP_OWNED),
+        LintId::of(misc::FLOAT_CMP),
+        LintId::of(misc::MODULO_ONE),
+        LintId::of(misc::SHORT_CIRCUIT_STATEMENT),
+        LintId::of(misc::TOPLEVEL_REF_ARG),
+        LintId::of(misc::ZERO_PTR),
+        LintId::of(misc_early::BUILTIN_TYPE_SHADOW),
+        LintId::of(misc_early::DOUBLE_NEG),
+        LintId::of(misc_early::DUPLICATE_UNDERSCORE_ARGUMENT),
+        LintId::of(misc_early::MIXED_CASE_HEX_LITERALS),
+        LintId::of(misc_early::REDUNDANT_PATTERN),
+        LintId::of(misc_early::UNNEEDED_WILDCARD_PATTERN),
+        LintId::of(misc_early::ZERO_PREFIXED_LITERAL),
+        LintId::of(mut_key::MUTABLE_KEY_TYPE),
+        LintId::of(mut_mutex_lock::MUT_MUTEX_LOCK),
+        LintId::of(mut_reference::UNNECESSARY_MUT_PASSED),
+        LintId::of(mutex_atomic::MUTEX_ATOMIC),
+        LintId::of(needless_arbitrary_self_type::NEEDLESS_ARBITRARY_SELF_TYPE),
+        LintId::of(needless_bool::BOOL_COMPARISON),
+        LintId::of(needless_bool::NEEDLESS_BOOL),
+        LintId::of(needless_borrowed_ref::NEEDLESS_BORROWED_REFERENCE),
+        LintId::of(needless_question_mark::NEEDLESS_QUESTION_MARK),
+        LintId::of(needless_update::NEEDLESS_UPDATE),
+        LintId::of(neg_cmp_op_on_partial_ord::NEG_CMP_OP_ON_PARTIAL_ORD),
+        LintId::of(neg_multiply::NEG_MULTIPLY),
+        LintId::of(new_without_default::NEW_WITHOUT_DEFAULT),
+        LintId::of(no_effect::NO_EFFECT),
+        LintId::of(no_effect::UNNECESSARY_OPERATION),
+        LintId::of(non_copy_const::BORROW_INTERIOR_MUTABLE_CONST),
+        LintId::of(non_copy_const::DECLARE_INTERIOR_MUTABLE_CONST),
+        LintId::of(non_expressive_names::JUST_UNDERSCORES_AND_DIGITS),
+        LintId::of(non_expressive_names::MANY_SINGLE_CHAR_NAMES),
+        LintId::of(non_octal_unix_permissions::NON_OCTAL_UNIX_PERMISSIONS),
+        LintId::of(open_options::NONSENSICAL_OPEN_OPTIONS),
+        LintId::of(option_env_unwrap::OPTION_ENV_UNWRAP),
+        LintId::of(overflow_check_conditional::OVERFLOW_CHECK_CONDITIONAL),
+        LintId::of(partialeq_ne_impl::PARTIALEQ_NE_IMPL),
+        LintId::of(precedence::PRECEDENCE),
+        LintId::of(ptr::CMP_NULL),
+        LintId::of(ptr::MUT_FROM_REF),
+        LintId::of(ptr::PTR_ARG),
+        LintId::of(ptr_eq::PTR_EQ),
+        LintId::of(ptr_offset_with_cast::PTR_OFFSET_WITH_CAST),
+        LintId::of(question_mark::QUESTION_MARK),
+        LintId::of(ranges::MANUAL_RANGE_CONTAINS),
+        LintId::of(ranges::RANGE_ZIP_WITH_LEN),
+        LintId::of(ranges::REVERSED_EMPTY_RANGES),
+        LintId::of(redundant_clone::REDUNDANT_CLONE),
+        LintId::of(redundant_closure_call::REDUNDANT_CLOSURE_CALL),
+        LintId::of(redundant_field_names::REDUNDANT_FIELD_NAMES),
+        LintId::of(redundant_slicing::REDUNDANT_SLICING),
+        LintId::of(redundant_static_lifetimes::REDUNDANT_STATIC_LIFETIMES),
+        LintId::of(reference::DEREF_ADDROF),
+        LintId::of(reference::REF_IN_DEREF),
+        LintId::of(regex::INVALID_REGEX),
+        LintId::of(repeat_once::REPEAT_ONCE),
+        LintId::of(returns::LET_AND_RETURN),
+        LintId::of(returns::NEEDLESS_RETURN),
+        LintId::of(self_assignment::SELF_ASSIGNMENT),
+        LintId::of(serde_api::SERDE_API_MISUSE),
+        LintId::of(single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS),
+        LintId::of(size_of_in_element_count::SIZE_OF_IN_ELEMENT_COUNT),
+        LintId::of(slow_vector_initialization::SLOW_VECTOR_INITIALIZATION),
+        LintId::of(stable_sort_primitive::STABLE_SORT_PRIMITIVE),
+        LintId::of(strings::STRING_FROM_UTF8_AS_BYTES),
+        LintId::of(suspicious_operation_groupings::SUSPICIOUS_OPERATION_GROUPINGS),
+        LintId::of(suspicious_trait_impl::SUSPICIOUS_ARITHMETIC_IMPL),
+        LintId::of(suspicious_trait_impl::SUSPICIOUS_OP_ASSIGN_IMPL),
+        LintId::of(swap::ALMOST_SWAPPED),
+        LintId::of(swap::MANUAL_SWAP),
+        LintId::of(tabs_in_doc_comments::TABS_IN_DOC_COMMENTS),
+        LintId::of(temporary_assignment::TEMPORARY_ASSIGNMENT),
+        LintId::of(to_digit_is_some::TO_DIGIT_IS_SOME),
+        LintId::of(to_string_in_display::TO_STRING_IN_DISPLAY),
+        LintId::of(transmute::CROSSPOINTER_TRANSMUTE),
+        LintId::of(transmute::TRANSMUTES_EXPRESSIBLE_AS_PTR_CASTS),
+        LintId::of(transmute::TRANSMUTE_BYTES_TO_STR),
+        LintId::of(transmute::TRANSMUTE_FLOAT_TO_INT),
+        LintId::of(transmute::TRANSMUTE_INT_TO_BOOL),
+        LintId::of(transmute::TRANSMUTE_INT_TO_CHAR),
+        LintId::of(transmute::TRANSMUTE_INT_TO_FLOAT),
+        LintId::of(transmute::TRANSMUTE_PTR_TO_PTR),
+        LintId::of(transmute::TRANSMUTE_PTR_TO_REF),
+        LintId::of(transmute::UNSOUND_COLLECTION_TRANSMUTE),
+        LintId::of(transmute::WRONG_TRANSMUTE),
+        LintId::of(transmuting_null::TRANSMUTING_NULL),
+        LintId::of(try_err::TRY_ERR),
+        LintId::of(types::BORROWED_BOX),
+        LintId::of(types::BOX_VEC),
+        LintId::of(types::REDUNDANT_ALLOCATION),
+        LintId::of(types::TYPE_COMPLEXITY),
+        LintId::of(types::VEC_BOX),
+        LintId::of(undropped_manually_drops::UNDROPPED_MANUALLY_DROPS),
+        LintId::of(unicode::INVISIBLE_CHARACTERS),
+        LintId::of(unit_return_expecting_ord::UNIT_RETURN_EXPECTING_ORD),
+        LintId::of(unit_types::UNIT_ARG),
+        LintId::of(unit_types::UNIT_CMP),
+        LintId::of(unnamed_address::FN_ADDRESS_COMPARISONS),
+        LintId::of(unnamed_address::VTABLE_ADDRESS_COMPARISONS),
+        LintId::of(unnecessary_sort_by::UNNECESSARY_SORT_BY),
+        LintId::of(unsafe_removed_from_name::UNSAFE_REMOVED_FROM_NAME),
+        LintId::of(unused_io_amount::UNUSED_IO_AMOUNT),
+        LintId::of(unused_unit::UNUSED_UNIT),
+        LintId::of(unwrap::PANICKING_UNWRAP),
+        LintId::of(unwrap::UNNECESSARY_UNWRAP),
+        LintId::of(upper_case_acronyms::UPPER_CASE_ACRONYMS),
+        LintId::of(useless_conversion::USELESS_CONVERSION),
+        LintId::of(vec::USELESS_VEC),
+        LintId::of(vec_init_then_push::VEC_INIT_THEN_PUSH),
+        LintId::of(vec_resize_to_zero::VEC_RESIZE_TO_ZERO),
+        LintId::of(write::PRINTLN_EMPTY_STRING),
+        LintId::of(write::PRINT_LITERAL),
+        LintId::of(write::PRINT_WITH_NEWLINE),
+        LintId::of(write::WRITELN_EMPTY_STRING),
+        LintId::of(write::WRITE_LITERAL),
+        LintId::of(write::WRITE_WITH_NEWLINE),
+        LintId::of(zero_div_zero::ZERO_DIVIDED_BY_ZERO),
     ]);
 
     store.register_group(true, "clippy::style", Some("clippy_style"), vec![
-        LintId::of(&assertions_on_constants::ASSERTIONS_ON_CONSTANTS),
-        LintId::of(&assign_ops::ASSIGN_OP_PATTERN),
-        LintId::of(&attrs::BLANKET_CLIPPY_RESTRICTION_LINTS),
-        LintId::of(&blacklisted_name::BLACKLISTED_NAME),
-        LintId::of(&blocks_in_if_conditions::BLOCKS_IN_IF_CONDITIONS),
-        LintId::of(&casts::FN_TO_NUMERIC_CAST),
-        LintId::of(&casts::FN_TO_NUMERIC_CAST_WITH_TRUNCATION),
-        LintId::of(&collapsible_if::COLLAPSIBLE_ELSE_IF),
-        LintId::of(&collapsible_if::COLLAPSIBLE_IF),
-        LintId::of(&collapsible_match::COLLAPSIBLE_MATCH),
-        LintId::of(&comparison_chain::COMPARISON_CHAIN),
-        LintId::of(&default::FIELD_REASSIGN_WITH_DEFAULT),
-        LintId::of(&doc::MISSING_SAFETY_DOC),
-        LintId::of(&doc::NEEDLESS_DOCTEST_MAIN),
-        LintId::of(&enum_variants::ENUM_VARIANT_NAMES),
-        LintId::of(&enum_variants::MODULE_INCEPTION),
-        LintId::of(&eq_op::OP_REF),
-        LintId::of(&eta_reduction::REDUNDANT_CLOSURE),
-        LintId::of(&float_literal::EXCESSIVE_PRECISION),
-        LintId::of(&formatting::SUSPICIOUS_ASSIGNMENT_FORMATTING),
-        LintId::of(&formatting::SUSPICIOUS_ELSE_FORMATTING),
-        LintId::of(&formatting::SUSPICIOUS_UNARY_OP_FORMATTING),
-        LintId::of(&from_over_into::FROM_OVER_INTO),
-        LintId::of(&from_str_radix_10::FROM_STR_RADIX_10),
-        LintId::of(&functions::DOUBLE_MUST_USE),
-        LintId::of(&functions::MUST_USE_UNIT),
-        LintId::of(&functions::RESULT_UNIT_ERR),
-        LintId::of(&if_let_some_result::IF_LET_SOME_RESULT),
-        LintId::of(&inconsistent_struct_constructor::INCONSISTENT_STRUCT_CONSTRUCTOR),
-        LintId::of(&inherent_to_string::INHERENT_TO_STRING),
-        LintId::of(&len_zero::COMPARISON_TO_EMPTY),
-        LintId::of(&len_zero::LEN_WITHOUT_IS_EMPTY),
-        LintId::of(&len_zero::LEN_ZERO),
-        LintId::of(&literal_representation::INCONSISTENT_DIGIT_GROUPING),
-        LintId::of(&literal_representation::UNUSUAL_BYTE_GROUPINGS),
-        LintId::of(&loops::EMPTY_LOOP),
-        LintId::of(&loops::FOR_KV_MAP),
-        LintId::of(&loops::NEEDLESS_RANGE_LOOP),
-        LintId::of(&loops::SAME_ITEM_PUSH),
-        LintId::of(&loops::WHILE_LET_ON_ITERATOR),
-        LintId::of(&main_recursion::MAIN_RECURSION),
-        LintId::of(&manual_async_fn::MANUAL_ASYNC_FN),
-        LintId::of(&manual_map::MANUAL_MAP),
-        LintId::of(&manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE),
-        LintId::of(&map_clone::MAP_CLONE),
-        LintId::of(&matches::INFALLIBLE_DESTRUCTURING_MATCH),
-        LintId::of(&matches::MATCH_LIKE_MATCHES_MACRO),
-        LintId::of(&matches::MATCH_OVERLAPPING_ARM),
-        LintId::of(&matches::MATCH_REF_PATS),
-        LintId::of(&matches::REDUNDANT_PATTERN_MATCHING),
-        LintId::of(&matches::SINGLE_MATCH),
-        LintId::of(&mem_replace::MEM_REPLACE_OPTION_WITH_NONE),
-        LintId::of(&mem_replace::MEM_REPLACE_WITH_DEFAULT),
-        LintId::of(&methods::BYTES_NTH),
-        LintId::of(&methods::CHARS_LAST_CMP),
-        LintId::of(&methods::CHARS_NEXT_CMP),
-        LintId::of(&methods::FROM_ITER_INSTEAD_OF_COLLECT),
-        LintId::of(&methods::INTO_ITER_ON_REF),
-        LintId::of(&methods::ITER_CLONED_COLLECT),
-        LintId::of(&methods::ITER_NEXT_SLICE),
-        LintId::of(&methods::ITER_NTH_ZERO),
-        LintId::of(&methods::ITER_SKIP_NEXT),
-        LintId::of(&methods::MANUAL_SATURATING_ARITHMETIC),
-        LintId::of(&methods::MAP_COLLECT_RESULT_UNIT),
-        LintId::of(&methods::NEW_RET_NO_SELF),
-        LintId::of(&methods::OK_EXPECT),
-        LintId::of(&methods::OPTION_MAP_OR_NONE),
-        LintId::of(&methods::RESULT_MAP_OR_INTO_OPTION),
-        LintId::of(&methods::SHOULD_IMPLEMENT_TRAIT),
-        LintId::of(&methods::SINGLE_CHAR_ADD_STR),
-        LintId::of(&methods::STRING_EXTEND_CHARS),
-        LintId::of(&methods::UNNECESSARY_FOLD),
-        LintId::of(&methods::UNNECESSARY_LAZY_EVALUATIONS),
-        LintId::of(&methods::WRONG_SELF_CONVENTION),
-        LintId::of(&misc::TOPLEVEL_REF_ARG),
-        LintId::of(&misc::ZERO_PTR),
-        LintId::of(&misc_early::BUILTIN_TYPE_SHADOW),
-        LintId::of(&misc_early::DOUBLE_NEG),
-        LintId::of(&misc_early::DUPLICATE_UNDERSCORE_ARGUMENT),
-        LintId::of(&misc_early::MIXED_CASE_HEX_LITERALS),
-        LintId::of(&misc_early::REDUNDANT_PATTERN),
-        LintId::of(&mut_mutex_lock::MUT_MUTEX_LOCK),
-        LintId::of(&mut_reference::UNNECESSARY_MUT_PASSED),
-        LintId::of(&neg_multiply::NEG_MULTIPLY),
-        LintId::of(&new_without_default::NEW_WITHOUT_DEFAULT),
-        LintId::of(&non_copy_const::BORROW_INTERIOR_MUTABLE_CONST),
-        LintId::of(&non_copy_const::DECLARE_INTERIOR_MUTABLE_CONST),
-        LintId::of(&non_expressive_names::JUST_UNDERSCORES_AND_DIGITS),
-        LintId::of(&non_expressive_names::MANY_SINGLE_CHAR_NAMES),
-        LintId::of(&ptr::CMP_NULL),
-        LintId::of(&ptr::PTR_ARG),
-        LintId::of(&ptr_eq::PTR_EQ),
-        LintId::of(&question_mark::QUESTION_MARK),
-        LintId::of(&ranges::MANUAL_RANGE_CONTAINS),
-        LintId::of(&redundant_field_names::REDUNDANT_FIELD_NAMES),
-        LintId::of(&redundant_static_lifetimes::REDUNDANT_STATIC_LIFETIMES),
-        LintId::of(&returns::LET_AND_RETURN),
-        LintId::of(&returns::NEEDLESS_RETURN),
-        LintId::of(&single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS),
-        LintId::of(&suspicious_operation_groupings::SUSPICIOUS_OPERATION_GROUPINGS),
-        LintId::of(&tabs_in_doc_comments::TABS_IN_DOC_COMMENTS),
-        LintId::of(&to_digit_is_some::TO_DIGIT_IS_SOME),
-        LintId::of(&try_err::TRY_ERR),
-        LintId::of(&unsafe_removed_from_name::UNSAFE_REMOVED_FROM_NAME),
-        LintId::of(&unused_unit::UNUSED_UNIT),
-        LintId::of(&upper_case_acronyms::UPPER_CASE_ACRONYMS),
-        LintId::of(&write::PRINTLN_EMPTY_STRING),
-        LintId::of(&write::PRINT_LITERAL),
-        LintId::of(&write::PRINT_WITH_NEWLINE),
-        LintId::of(&write::WRITELN_EMPTY_STRING),
-        LintId::of(&write::WRITE_LITERAL),
-        LintId::of(&write::WRITE_WITH_NEWLINE),
+        LintId::of(assertions_on_constants::ASSERTIONS_ON_CONSTANTS),
+        LintId::of(assign_ops::ASSIGN_OP_PATTERN),
+        LintId::of(attrs::BLANKET_CLIPPY_RESTRICTION_LINTS),
+        LintId::of(blacklisted_name::BLACKLISTED_NAME),
+        LintId::of(blocks_in_if_conditions::BLOCKS_IN_IF_CONDITIONS),
+        LintId::of(casts::FN_TO_NUMERIC_CAST),
+        LintId::of(casts::FN_TO_NUMERIC_CAST_WITH_TRUNCATION),
+        LintId::of(collapsible_if::COLLAPSIBLE_ELSE_IF),
+        LintId::of(collapsible_if::COLLAPSIBLE_IF),
+        LintId::of(collapsible_match::COLLAPSIBLE_MATCH),
+        LintId::of(comparison_chain::COMPARISON_CHAIN),
+        LintId::of(default::FIELD_REASSIGN_WITH_DEFAULT),
+        LintId::of(doc::MISSING_SAFETY_DOC),
+        LintId::of(doc::NEEDLESS_DOCTEST_MAIN),
+        LintId::of(enum_variants::ENUM_VARIANT_NAMES),
+        LintId::of(enum_variants::MODULE_INCEPTION),
+        LintId::of(eq_op::OP_REF),
+        LintId::of(eta_reduction::REDUNDANT_CLOSURE),
+        LintId::of(float_literal::EXCESSIVE_PRECISION),
+        LintId::of(formatting::SUSPICIOUS_ASSIGNMENT_FORMATTING),
+        LintId::of(formatting::SUSPICIOUS_ELSE_FORMATTING),
+        LintId::of(formatting::SUSPICIOUS_UNARY_OP_FORMATTING),
+        LintId::of(from_over_into::FROM_OVER_INTO),
+        LintId::of(from_str_radix_10::FROM_STR_RADIX_10),
+        LintId::of(functions::DOUBLE_MUST_USE),
+        LintId::of(functions::MUST_USE_UNIT),
+        LintId::of(functions::RESULT_UNIT_ERR),
+        LintId::of(if_let_some_result::IF_LET_SOME_RESULT),
+        LintId::of(inconsistent_struct_constructor::INCONSISTENT_STRUCT_CONSTRUCTOR),
+        LintId::of(inherent_to_string::INHERENT_TO_STRING),
+        LintId::of(len_zero::COMPARISON_TO_EMPTY),
+        LintId::of(len_zero::LEN_WITHOUT_IS_EMPTY),
+        LintId::of(len_zero::LEN_ZERO),
+        LintId::of(literal_representation::INCONSISTENT_DIGIT_GROUPING),
+        LintId::of(literal_representation::UNUSUAL_BYTE_GROUPINGS),
+        LintId::of(loops::EMPTY_LOOP),
+        LintId::of(loops::FOR_KV_MAP),
+        LintId::of(loops::NEEDLESS_RANGE_LOOP),
+        LintId::of(loops::SAME_ITEM_PUSH),
+        LintId::of(loops::WHILE_LET_ON_ITERATOR),
+        LintId::of(main_recursion::MAIN_RECURSION),
+        LintId::of(manual_async_fn::MANUAL_ASYNC_FN),
+        LintId::of(manual_map::MANUAL_MAP),
+        LintId::of(manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE),
+        LintId::of(map_clone::MAP_CLONE),
+        LintId::of(matches::INFALLIBLE_DESTRUCTURING_MATCH),
+        LintId::of(matches::MATCH_LIKE_MATCHES_MACRO),
+        LintId::of(matches::MATCH_OVERLAPPING_ARM),
+        LintId::of(matches::MATCH_REF_PATS),
+        LintId::of(matches::REDUNDANT_PATTERN_MATCHING),
+        LintId::of(matches::SINGLE_MATCH),
+        LintId::of(mem_replace::MEM_REPLACE_OPTION_WITH_NONE),
+        LintId::of(mem_replace::MEM_REPLACE_WITH_DEFAULT),
+        LintId::of(methods::BYTES_NTH),
+        LintId::of(methods::CHARS_LAST_CMP),
+        LintId::of(methods::CHARS_NEXT_CMP),
+        LintId::of(methods::FROM_ITER_INSTEAD_OF_COLLECT),
+        LintId::of(methods::INTO_ITER_ON_REF),
+        LintId::of(methods::ITER_CLONED_COLLECT),
+        LintId::of(methods::ITER_NEXT_SLICE),
+        LintId::of(methods::ITER_NTH_ZERO),
+        LintId::of(methods::ITER_SKIP_NEXT),
+        LintId::of(methods::MANUAL_SATURATING_ARITHMETIC),
+        LintId::of(methods::MAP_COLLECT_RESULT_UNIT),
+        LintId::of(methods::NEW_RET_NO_SELF),
+        LintId::of(methods::OK_EXPECT),
+        LintId::of(methods::OPTION_MAP_OR_NONE),
+        LintId::of(methods::RESULT_MAP_OR_INTO_OPTION),
+        LintId::of(methods::SHOULD_IMPLEMENT_TRAIT),
+        LintId::of(methods::SINGLE_CHAR_ADD_STR),
+        LintId::of(methods::STRING_EXTEND_CHARS),
+        LintId::of(methods::UNNECESSARY_FOLD),
+        LintId::of(methods::UNNECESSARY_LAZY_EVALUATIONS),
+        LintId::of(methods::WRONG_SELF_CONVENTION),
+        LintId::of(misc::TOPLEVEL_REF_ARG),
+        LintId::of(misc::ZERO_PTR),
+        LintId::of(misc_early::BUILTIN_TYPE_SHADOW),
+        LintId::of(misc_early::DOUBLE_NEG),
+        LintId::of(misc_early::DUPLICATE_UNDERSCORE_ARGUMENT),
+        LintId::of(misc_early::MIXED_CASE_HEX_LITERALS),
+        LintId::of(misc_early::REDUNDANT_PATTERN),
+        LintId::of(mut_mutex_lock::MUT_MUTEX_LOCK),
+        LintId::of(mut_reference::UNNECESSARY_MUT_PASSED),
+        LintId::of(neg_multiply::NEG_MULTIPLY),
+        LintId::of(new_without_default::NEW_WITHOUT_DEFAULT),
+        LintId::of(non_copy_const::BORROW_INTERIOR_MUTABLE_CONST),
+        LintId::of(non_copy_const::DECLARE_INTERIOR_MUTABLE_CONST),
+        LintId::of(non_expressive_names::JUST_UNDERSCORES_AND_DIGITS),
+        LintId::of(non_expressive_names::MANY_SINGLE_CHAR_NAMES),
+        LintId::of(ptr::CMP_NULL),
+        LintId::of(ptr::PTR_ARG),
+        LintId::of(ptr_eq::PTR_EQ),
+        LintId::of(question_mark::QUESTION_MARK),
+        LintId::of(ranges::MANUAL_RANGE_CONTAINS),
+        LintId::of(redundant_field_names::REDUNDANT_FIELD_NAMES),
+        LintId::of(redundant_static_lifetimes::REDUNDANT_STATIC_LIFETIMES),
+        LintId::of(returns::LET_AND_RETURN),
+        LintId::of(returns::NEEDLESS_RETURN),
+        LintId::of(single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS),
+        LintId::of(suspicious_operation_groupings::SUSPICIOUS_OPERATION_GROUPINGS),
+        LintId::of(tabs_in_doc_comments::TABS_IN_DOC_COMMENTS),
+        LintId::of(to_digit_is_some::TO_DIGIT_IS_SOME),
+        LintId::of(try_err::TRY_ERR),
+        LintId::of(unsafe_removed_from_name::UNSAFE_REMOVED_FROM_NAME),
+        LintId::of(unused_unit::UNUSED_UNIT),
+        LintId::of(upper_case_acronyms::UPPER_CASE_ACRONYMS),
+        LintId::of(write::PRINTLN_EMPTY_STRING),
+        LintId::of(write::PRINT_LITERAL),
+        LintId::of(write::PRINT_WITH_NEWLINE),
+        LintId::of(write::WRITELN_EMPTY_STRING),
+        LintId::of(write::WRITE_LITERAL),
+        LintId::of(write::WRITE_WITH_NEWLINE),
     ]);
 
     store.register_group(true, "clippy::complexity", Some("clippy_complexity"), vec![
-        LintId::of(&assign_ops::MISREFACTORED_ASSIGN_OP),
-        LintId::of(&attrs::DEPRECATED_CFG_ATTR),
-        LintId::of(&booleans::NONMINIMAL_BOOL),
-        LintId::of(&casts::CHAR_LIT_AS_U8),
-        LintId::of(&casts::UNNECESSARY_CAST),
-        LintId::of(&copies::BRANCHES_SHARING_CODE),
-        LintId::of(&double_comparison::DOUBLE_COMPARISONS),
-        LintId::of(&double_parens::DOUBLE_PARENS),
-        LintId::of(&duration_subsec::DURATION_SUBSEC),
-        LintId::of(&eval_order_dependence::DIVERGING_SUB_EXPRESSION),
-        LintId::of(&eval_order_dependence::EVAL_ORDER_DEPENDENCE),
-        LintId::of(&explicit_write::EXPLICIT_WRITE),
-        LintId::of(&format::USELESS_FORMAT),
-        LintId::of(&functions::TOO_MANY_ARGUMENTS),
-        LintId::of(&get_last_with_len::GET_LAST_WITH_LEN),
-        LintId::of(&identity_op::IDENTITY_OP),
-        LintId::of(&int_plus_one::INT_PLUS_ONE),
-        LintId::of(&lifetimes::EXTRA_UNUSED_LIFETIMES),
-        LintId::of(&lifetimes::NEEDLESS_LIFETIMES),
-        LintId::of(&loops::EXPLICIT_COUNTER_LOOP),
-        LintId::of(&loops::MANUAL_FLATTEN),
-        LintId::of(&loops::MUT_RANGE_BOUND),
-        LintId::of(&loops::SINGLE_ELEMENT_LOOP),
-        LintId::of(&loops::WHILE_LET_LOOP),
-        LintId::of(&manual_strip::MANUAL_STRIP),
-        LintId::of(&manual_unwrap_or::MANUAL_UNWRAP_OR),
-        LintId::of(&map_identity::MAP_IDENTITY),
-        LintId::of(&map_unit_fn::OPTION_MAP_UNIT_FN),
-        LintId::of(&map_unit_fn::RESULT_MAP_UNIT_FN),
-        LintId::of(&matches::MATCH_AS_REF),
-        LintId::of(&matches::MATCH_SINGLE_BINDING),
-        LintId::of(&matches::WILDCARD_IN_OR_PATTERNS),
-        LintId::of(&methods::BIND_INSTEAD_OF_MAP),
-        LintId::of(&methods::CLONE_ON_COPY),
-        LintId::of(&methods::FILTER_MAP_IDENTITY),
-        LintId::of(&methods::FILTER_NEXT),
-        LintId::of(&methods::FLAT_MAP_IDENTITY),
-        LintId::of(&methods::INSPECT_FOR_EACH),
-        LintId::of(&methods::ITER_COUNT),
-        LintId::of(&methods::MANUAL_FILTER_MAP),
-        LintId::of(&methods::MANUAL_FIND_MAP),
-        LintId::of(&methods::OPTION_AS_REF_DEREF),
-        LintId::of(&methods::OPTION_FILTER_MAP),
-        LintId::of(&methods::SEARCH_IS_SOME),
-        LintId::of(&methods::SKIP_WHILE_NEXT),
-        LintId::of(&methods::SUSPICIOUS_MAP),
-        LintId::of(&methods::UNNECESSARY_FILTER_MAP),
-        LintId::of(&methods::USELESS_ASREF),
-        LintId::of(&misc::SHORT_CIRCUIT_STATEMENT),
-        LintId::of(&misc_early::UNNEEDED_WILDCARD_PATTERN),
-        LintId::of(&misc_early::ZERO_PREFIXED_LITERAL),
-        LintId::of(&needless_arbitrary_self_type::NEEDLESS_ARBITRARY_SELF_TYPE),
-        LintId::of(&needless_bool::BOOL_COMPARISON),
-        LintId::of(&needless_bool::NEEDLESS_BOOL),
-        LintId::of(&needless_borrowed_ref::NEEDLESS_BORROWED_REFERENCE),
-        LintId::of(&needless_question_mark::NEEDLESS_QUESTION_MARK),
-        LintId::of(&needless_update::NEEDLESS_UPDATE),
-        LintId::of(&neg_cmp_op_on_partial_ord::NEG_CMP_OP_ON_PARTIAL_ORD),
-        LintId::of(&no_effect::NO_EFFECT),
-        LintId::of(&no_effect::UNNECESSARY_OPERATION),
-        LintId::of(&overflow_check_conditional::OVERFLOW_CHECK_CONDITIONAL),
-        LintId::of(&partialeq_ne_impl::PARTIALEQ_NE_IMPL),
-        LintId::of(&precedence::PRECEDENCE),
-        LintId::of(&ptr_offset_with_cast::PTR_OFFSET_WITH_CAST),
-        LintId::of(&ranges::RANGE_ZIP_WITH_LEN),
-        LintId::of(&redundant_closure_call::REDUNDANT_CLOSURE_CALL),
-        LintId::of(&redundant_slicing::REDUNDANT_SLICING),
-        LintId::of(&reference::DEREF_ADDROF),
-        LintId::of(&reference::REF_IN_DEREF),
-        LintId::of(&repeat_once::REPEAT_ONCE),
-        LintId::of(&strings::STRING_FROM_UTF8_AS_BYTES),
-        LintId::of(&swap::MANUAL_SWAP),
-        LintId::of(&temporary_assignment::TEMPORARY_ASSIGNMENT),
-        LintId::of(&transmute::CROSSPOINTER_TRANSMUTE),
-        LintId::of(&transmute::TRANSMUTES_EXPRESSIBLE_AS_PTR_CASTS),
-        LintId::of(&transmute::TRANSMUTE_BYTES_TO_STR),
-        LintId::of(&transmute::TRANSMUTE_FLOAT_TO_INT),
-        LintId::of(&transmute::TRANSMUTE_INT_TO_BOOL),
-        LintId::of(&transmute::TRANSMUTE_INT_TO_CHAR),
-        LintId::of(&transmute::TRANSMUTE_INT_TO_FLOAT),
-        LintId::of(&transmute::TRANSMUTE_PTR_TO_PTR),
-        LintId::of(&transmute::TRANSMUTE_PTR_TO_REF),
-        LintId::of(&types::BORROWED_BOX),
-        LintId::of(&types::TYPE_COMPLEXITY),
-        LintId::of(&types::VEC_BOX),
-        LintId::of(&unit_types::UNIT_ARG),
-        LintId::of(&unnecessary_sort_by::UNNECESSARY_SORT_BY),
-        LintId::of(&unwrap::UNNECESSARY_UNWRAP),
-        LintId::of(&useless_conversion::USELESS_CONVERSION),
-        LintId::of(&zero_div_zero::ZERO_DIVIDED_BY_ZERO),
+        LintId::of(assign_ops::MISREFACTORED_ASSIGN_OP),
+        LintId::of(attrs::DEPRECATED_CFG_ATTR),
+        LintId::of(booleans::NONMINIMAL_BOOL),
+        LintId::of(casts::CHAR_LIT_AS_U8),
+        LintId::of(casts::UNNECESSARY_CAST),
+        LintId::of(copies::BRANCHES_SHARING_CODE),
+        LintId::of(double_comparison::DOUBLE_COMPARISONS),
+        LintId::of(double_parens::DOUBLE_PARENS),
+        LintId::of(duration_subsec::DURATION_SUBSEC),
+        LintId::of(eval_order_dependence::DIVERGING_SUB_EXPRESSION),
+        LintId::of(eval_order_dependence::EVAL_ORDER_DEPENDENCE),
+        LintId::of(explicit_write::EXPLICIT_WRITE),
+        LintId::of(format::USELESS_FORMAT),
+        LintId::of(functions::TOO_MANY_ARGUMENTS),
+        LintId::of(get_last_with_len::GET_LAST_WITH_LEN),
+        LintId::of(identity_op::IDENTITY_OP),
+        LintId::of(int_plus_one::INT_PLUS_ONE),
+        LintId::of(lifetimes::EXTRA_UNUSED_LIFETIMES),
+        LintId::of(lifetimes::NEEDLESS_LIFETIMES),
+        LintId::of(loops::EXPLICIT_COUNTER_LOOP),
+        LintId::of(loops::MANUAL_FLATTEN),
+        LintId::of(loops::MUT_RANGE_BOUND),
+        LintId::of(loops::SINGLE_ELEMENT_LOOP),
+        LintId::of(loops::WHILE_LET_LOOP),
+        LintId::of(manual_strip::MANUAL_STRIP),
+        LintId::of(manual_unwrap_or::MANUAL_UNWRAP_OR),
+        LintId::of(map_identity::MAP_IDENTITY),
+        LintId::of(map_unit_fn::OPTION_MAP_UNIT_FN),
+        LintId::of(map_unit_fn::RESULT_MAP_UNIT_FN),
+        LintId::of(matches::MATCH_AS_REF),
+        LintId::of(matches::MATCH_SINGLE_BINDING),
+        LintId::of(matches::WILDCARD_IN_OR_PATTERNS),
+        LintId::of(methods::BIND_INSTEAD_OF_MAP),
+        LintId::of(methods::CLONE_ON_COPY),
+        LintId::of(methods::FILTER_MAP_IDENTITY),
+        LintId::of(methods::FILTER_NEXT),
+        LintId::of(methods::FLAT_MAP_IDENTITY),
+        LintId::of(methods::INSPECT_FOR_EACH),
+        LintId::of(methods::ITER_COUNT),
+        LintId::of(methods::MANUAL_FILTER_MAP),
+        LintId::of(methods::MANUAL_FIND_MAP),
+        LintId::of(methods::OPTION_AS_REF_DEREF),
+        LintId::of(methods::OPTION_FILTER_MAP),
+        LintId::of(methods::SEARCH_IS_SOME),
+        LintId::of(methods::SKIP_WHILE_NEXT),
+        LintId::of(methods::SUSPICIOUS_MAP),
+        LintId::of(methods::UNNECESSARY_FILTER_MAP),
+        LintId::of(methods::USELESS_ASREF),
+        LintId::of(misc::SHORT_CIRCUIT_STATEMENT),
+        LintId::of(misc_early::UNNEEDED_WILDCARD_PATTERN),
+        LintId::of(misc_early::ZERO_PREFIXED_LITERAL),
+        LintId::of(needless_arbitrary_self_type::NEEDLESS_ARBITRARY_SELF_TYPE),
+        LintId::of(needless_bool::BOOL_COMPARISON),
+        LintId::of(needless_bool::NEEDLESS_BOOL),
+        LintId::of(needless_borrowed_ref::NEEDLESS_BORROWED_REFERENCE),
+        LintId::of(needless_question_mark::NEEDLESS_QUESTION_MARK),
+        LintId::of(needless_update::NEEDLESS_UPDATE),
+        LintId::of(neg_cmp_op_on_partial_ord::NEG_CMP_OP_ON_PARTIAL_ORD),
+        LintId::of(no_effect::NO_EFFECT),
+        LintId::of(no_effect::UNNECESSARY_OPERATION),
+        LintId::of(overflow_check_conditional::OVERFLOW_CHECK_CONDITIONAL),
+        LintId::of(partialeq_ne_impl::PARTIALEQ_NE_IMPL),
+        LintId::of(precedence::PRECEDENCE),
+        LintId::of(ptr_offset_with_cast::PTR_OFFSET_WITH_CAST),
+        LintId::of(ranges::RANGE_ZIP_WITH_LEN),
+        LintId::of(redundant_closure_call::REDUNDANT_CLOSURE_CALL),
+        LintId::of(redundant_slicing::REDUNDANT_SLICING),
+        LintId::of(reference::DEREF_ADDROF),
+        LintId::of(reference::REF_IN_DEREF),
+        LintId::of(repeat_once::REPEAT_ONCE),
+        LintId::of(strings::STRING_FROM_UTF8_AS_BYTES),
+        LintId::of(swap::MANUAL_SWAP),
+        LintId::of(temporary_assignment::TEMPORARY_ASSIGNMENT),
+        LintId::of(transmute::CROSSPOINTER_TRANSMUTE),
+        LintId::of(transmute::TRANSMUTES_EXPRESSIBLE_AS_PTR_CASTS),
+        LintId::of(transmute::TRANSMUTE_BYTES_TO_STR),
+        LintId::of(transmute::TRANSMUTE_FLOAT_TO_INT),
+        LintId::of(transmute::TRANSMUTE_INT_TO_BOOL),
+        LintId::of(transmute::TRANSMUTE_INT_TO_CHAR),
+        LintId::of(transmute::TRANSMUTE_INT_TO_FLOAT),
+        LintId::of(transmute::TRANSMUTE_PTR_TO_PTR),
+        LintId::of(transmute::TRANSMUTE_PTR_TO_REF),
+        LintId::of(types::BORROWED_BOX),
+        LintId::of(types::TYPE_COMPLEXITY),
+        LintId::of(types::VEC_BOX),
+        LintId::of(unit_types::UNIT_ARG),
+        LintId::of(unnecessary_sort_by::UNNECESSARY_SORT_BY),
+        LintId::of(unwrap::UNNECESSARY_UNWRAP),
+        LintId::of(useless_conversion::USELESS_CONVERSION),
+        LintId::of(zero_div_zero::ZERO_DIVIDED_BY_ZERO),
     ]);
 
     store.register_group(true, "clippy::correctness", Some("clippy_correctness"), vec![
-        LintId::of(&absurd_extreme_comparisons::ABSURD_EXTREME_COMPARISONS),
-        LintId::of(&approx_const::APPROX_CONSTANT),
-        LintId::of(&async_yields_async::ASYNC_YIELDS_ASYNC),
-        LintId::of(&atomic_ordering::INVALID_ATOMIC_ORDERING),
-        LintId::of(&attrs::DEPRECATED_SEMVER),
-        LintId::of(&attrs::MISMATCHED_TARGET_OS),
-        LintId::of(&attrs::USELESS_ATTRIBUTE),
-        LintId::of(&bit_mask::BAD_BIT_MASK),
-        LintId::of(&bit_mask::INEFFECTIVE_BIT_MASK),
-        LintId::of(&booleans::LOGIC_BUG),
-        LintId::of(&casts::CAST_REF_TO_MUT),
-        LintId::of(&copies::IFS_SAME_COND),
-        LintId::of(&copies::IF_SAME_THEN_ELSE),
-        LintId::of(&derive::DERIVE_HASH_XOR_EQ),
-        LintId::of(&derive::DERIVE_ORD_XOR_PARTIAL_ORD),
-        LintId::of(&drop_forget_ref::DROP_COPY),
-        LintId::of(&drop_forget_ref::DROP_REF),
-        LintId::of(&drop_forget_ref::FORGET_COPY),
-        LintId::of(&drop_forget_ref::FORGET_REF),
-        LintId::of(&enum_clike::ENUM_CLIKE_UNPORTABLE_VARIANT),
-        LintId::of(&eq_op::EQ_OP),
-        LintId::of(&erasing_op::ERASING_OP),
-        LintId::of(&float_equality_without_abs::FLOAT_EQUALITY_WITHOUT_ABS),
-        LintId::of(&formatting::POSSIBLE_MISSING_COMMA),
-        LintId::of(&functions::NOT_UNSAFE_PTR_ARG_DEREF),
-        LintId::of(&if_let_mutex::IF_LET_MUTEX),
-        LintId::of(&indexing_slicing::OUT_OF_BOUNDS_INDEXING),
-        LintId::of(&infinite_iter::INFINITE_ITER),
-        LintId::of(&inherent_to_string::INHERENT_TO_STRING_SHADOW_DISPLAY),
-        LintId::of(&inline_fn_without_body::INLINE_FN_WITHOUT_BODY),
-        LintId::of(&let_underscore::LET_UNDERSCORE_LOCK),
-        LintId::of(&literal_representation::MISTYPED_LITERAL_SUFFIXES),
-        LintId::of(&loops::FOR_LOOPS_OVER_FALLIBLES),
-        LintId::of(&loops::ITER_NEXT_LOOP),
-        LintId::of(&loops::NEVER_LOOP),
-        LintId::of(&loops::WHILE_IMMUTABLE_CONDITION),
-        LintId::of(&mem_discriminant::MEM_DISCRIMINANT_NON_ENUM),
-        LintId::of(&mem_replace::MEM_REPLACE_WITH_UNINIT),
-        LintId::of(&methods::CLONE_DOUBLE_REF),
-        LintId::of(&methods::ITERATOR_STEP_BY_ZERO),
-        LintId::of(&methods::UNINIT_ASSUMED_INIT),
-        LintId::of(&methods::ZST_OFFSET),
-        LintId::of(&minmax::MIN_MAX),
-        LintId::of(&misc::CMP_NAN),
-        LintId::of(&misc::FLOAT_CMP),
-        LintId::of(&misc::MODULO_ONE),
-        LintId::of(&mut_key::MUTABLE_KEY_TYPE),
-        LintId::of(&non_octal_unix_permissions::NON_OCTAL_UNIX_PERMISSIONS),
-        LintId::of(&open_options::NONSENSICAL_OPEN_OPTIONS),
-        LintId::of(&option_env_unwrap::OPTION_ENV_UNWRAP),
-        LintId::of(&ptr::MUT_FROM_REF),
-        LintId::of(&ranges::REVERSED_EMPTY_RANGES),
-        LintId::of(&regex::INVALID_REGEX),
-        LintId::of(&self_assignment::SELF_ASSIGNMENT),
-        LintId::of(&serde_api::SERDE_API_MISUSE),
-        LintId::of(&size_of_in_element_count::SIZE_OF_IN_ELEMENT_COUNT),
-        LintId::of(&suspicious_trait_impl::SUSPICIOUS_ARITHMETIC_IMPL),
-        LintId::of(&suspicious_trait_impl::SUSPICIOUS_OP_ASSIGN_IMPL),
-        LintId::of(&swap::ALMOST_SWAPPED),
-        LintId::of(&to_string_in_display::TO_STRING_IN_DISPLAY),
-        LintId::of(&transmute::UNSOUND_COLLECTION_TRANSMUTE),
-        LintId::of(&transmute::WRONG_TRANSMUTE),
-        LintId::of(&transmuting_null::TRANSMUTING_NULL),
-        LintId::of(&undropped_manually_drops::UNDROPPED_MANUALLY_DROPS),
-        LintId::of(&unicode::INVISIBLE_CHARACTERS),
-        LintId::of(&unit_return_expecting_ord::UNIT_RETURN_EXPECTING_ORD),
-        LintId::of(&unit_types::UNIT_CMP),
-        LintId::of(&unnamed_address::FN_ADDRESS_COMPARISONS),
-        LintId::of(&unnamed_address::VTABLE_ADDRESS_COMPARISONS),
-        LintId::of(&unused_io_amount::UNUSED_IO_AMOUNT),
-        LintId::of(&unwrap::PANICKING_UNWRAP),
-        LintId::of(&vec_resize_to_zero::VEC_RESIZE_TO_ZERO),
+        LintId::of(absurd_extreme_comparisons::ABSURD_EXTREME_COMPARISONS),
+        LintId::of(approx_const::APPROX_CONSTANT),
+        LintId::of(async_yields_async::ASYNC_YIELDS_ASYNC),
+        LintId::of(atomic_ordering::INVALID_ATOMIC_ORDERING),
+        LintId::of(attrs::DEPRECATED_SEMVER),
+        LintId::of(attrs::MISMATCHED_TARGET_OS),
+        LintId::of(attrs::USELESS_ATTRIBUTE),
+        LintId::of(bit_mask::BAD_BIT_MASK),
+        LintId::of(bit_mask::INEFFECTIVE_BIT_MASK),
+        LintId::of(booleans::LOGIC_BUG),
+        LintId::of(casts::CAST_REF_TO_MUT),
+        LintId::of(copies::IFS_SAME_COND),
+        LintId::of(copies::IF_SAME_THEN_ELSE),
+        LintId::of(derive::DERIVE_HASH_XOR_EQ),
+        LintId::of(derive::DERIVE_ORD_XOR_PARTIAL_ORD),
+        LintId::of(drop_forget_ref::DROP_COPY),
+        LintId::of(drop_forget_ref::DROP_REF),
+        LintId::of(drop_forget_ref::FORGET_COPY),
+        LintId::of(drop_forget_ref::FORGET_REF),
+        LintId::of(enum_clike::ENUM_CLIKE_UNPORTABLE_VARIANT),
+        LintId::of(eq_op::EQ_OP),
+        LintId::of(erasing_op::ERASING_OP),
+        LintId::of(float_equality_without_abs::FLOAT_EQUALITY_WITHOUT_ABS),
+        LintId::of(formatting::POSSIBLE_MISSING_COMMA),
+        LintId::of(functions::NOT_UNSAFE_PTR_ARG_DEREF),
+        LintId::of(if_let_mutex::IF_LET_MUTEX),
+        LintId::of(indexing_slicing::OUT_OF_BOUNDS_INDEXING),
+        LintId::of(infinite_iter::INFINITE_ITER),
+        LintId::of(inherent_to_string::INHERENT_TO_STRING_SHADOW_DISPLAY),
+        LintId::of(inline_fn_without_body::INLINE_FN_WITHOUT_BODY),
+        LintId::of(let_underscore::LET_UNDERSCORE_LOCK),
+        LintId::of(literal_representation::MISTYPED_LITERAL_SUFFIXES),
+        LintId::of(loops::FOR_LOOPS_OVER_FALLIBLES),
+        LintId::of(loops::ITER_NEXT_LOOP),
+        LintId::of(loops::NEVER_LOOP),
+        LintId::of(loops::WHILE_IMMUTABLE_CONDITION),
+        LintId::of(mem_discriminant::MEM_DISCRIMINANT_NON_ENUM),
+        LintId::of(mem_replace::MEM_REPLACE_WITH_UNINIT),
+        LintId::of(methods::CLONE_DOUBLE_REF),
+        LintId::of(methods::ITERATOR_STEP_BY_ZERO),
+        LintId::of(methods::UNINIT_ASSUMED_INIT),
+        LintId::of(methods::ZST_OFFSET),
+        LintId::of(minmax::MIN_MAX),
+        LintId::of(misc::CMP_NAN),
+        LintId::of(misc::FLOAT_CMP),
+        LintId::of(misc::MODULO_ONE),
+        LintId::of(mut_key::MUTABLE_KEY_TYPE),
+        LintId::of(non_octal_unix_permissions::NON_OCTAL_UNIX_PERMISSIONS),
+        LintId::of(open_options::NONSENSICAL_OPEN_OPTIONS),
+        LintId::of(option_env_unwrap::OPTION_ENV_UNWRAP),
+        LintId::of(ptr::MUT_FROM_REF),
+        LintId::of(ranges::REVERSED_EMPTY_RANGES),
+        LintId::of(regex::INVALID_REGEX),
+        LintId::of(self_assignment::SELF_ASSIGNMENT),
+        LintId::of(serde_api::SERDE_API_MISUSE),
+        LintId::of(size_of_in_element_count::SIZE_OF_IN_ELEMENT_COUNT),
+        LintId::of(suspicious_trait_impl::SUSPICIOUS_ARITHMETIC_IMPL),
+        LintId::of(suspicious_trait_impl::SUSPICIOUS_OP_ASSIGN_IMPL),
+        LintId::of(swap::ALMOST_SWAPPED),
+        LintId::of(to_string_in_display::TO_STRING_IN_DISPLAY),
+        LintId::of(transmute::UNSOUND_COLLECTION_TRANSMUTE),
+        LintId::of(transmute::WRONG_TRANSMUTE),
+        LintId::of(transmuting_null::TRANSMUTING_NULL),
+        LintId::of(undropped_manually_drops::UNDROPPED_MANUALLY_DROPS),
+        LintId::of(unicode::INVISIBLE_CHARACTERS),
+        LintId::of(unit_return_expecting_ord::UNIT_RETURN_EXPECTING_ORD),
+        LintId::of(unit_types::UNIT_CMP),
+        LintId::of(unnamed_address::FN_ADDRESS_COMPARISONS),
+        LintId::of(unnamed_address::VTABLE_ADDRESS_COMPARISONS),
+        LintId::of(unused_io_amount::UNUSED_IO_AMOUNT),
+        LintId::of(unwrap::PANICKING_UNWRAP),
+        LintId::of(vec_resize_to_zero::VEC_RESIZE_TO_ZERO),
     ]);
 
     store.register_group(true, "clippy::perf", Some("clippy_perf"), vec![
-        LintId::of(&entry::MAP_ENTRY),
-        LintId::of(&escape::BOXED_LOCAL),
-        LintId::of(&large_const_arrays::LARGE_CONST_ARRAYS),
-        LintId::of(&large_enum_variant::LARGE_ENUM_VARIANT),
-        LintId::of(&loops::MANUAL_MEMCPY),
-        LintId::of(&loops::NEEDLESS_COLLECT),
-        LintId::of(&methods::EXPECT_FUN_CALL),
-        LintId::of(&methods::ITER_NTH),
-        LintId::of(&methods::OR_FUN_CALL),
-        LintId::of(&methods::SINGLE_CHAR_PATTERN),
-        LintId::of(&misc::CMP_OWNED),
-        LintId::of(&mutex_atomic::MUTEX_ATOMIC),
-        LintId::of(&redundant_clone::REDUNDANT_CLONE),
-        LintId::of(&slow_vector_initialization::SLOW_VECTOR_INITIALIZATION),
-        LintId::of(&stable_sort_primitive::STABLE_SORT_PRIMITIVE),
-        LintId::of(&types::BOX_VEC),
-        LintId::of(&types::REDUNDANT_ALLOCATION),
-        LintId::of(&vec::USELESS_VEC),
-        LintId::of(&vec_init_then_push::VEC_INIT_THEN_PUSH),
+        LintId::of(entry::MAP_ENTRY),
+        LintId::of(escape::BOXED_LOCAL),
+        LintId::of(large_const_arrays::LARGE_CONST_ARRAYS),
+        LintId::of(large_enum_variant::LARGE_ENUM_VARIANT),
+        LintId::of(loops::MANUAL_MEMCPY),
+        LintId::of(loops::NEEDLESS_COLLECT),
+        LintId::of(methods::EXPECT_FUN_CALL),
+        LintId::of(methods::ITER_NTH),
+        LintId::of(methods::OR_FUN_CALL),
+        LintId::of(methods::SINGLE_CHAR_PATTERN),
+        LintId::of(misc::CMP_OWNED),
+        LintId::of(mutex_atomic::MUTEX_ATOMIC),
+        LintId::of(redundant_clone::REDUNDANT_CLONE),
+        LintId::of(slow_vector_initialization::SLOW_VECTOR_INITIALIZATION),
+        LintId::of(stable_sort_primitive::STABLE_SORT_PRIMITIVE),
+        LintId::of(types::BOX_VEC),
+        LintId::of(types::REDUNDANT_ALLOCATION),
+        LintId::of(vec::USELESS_VEC),
+        LintId::of(vec_init_then_push::VEC_INIT_THEN_PUSH),
     ]);
 
     store.register_group(true, "clippy::cargo", Some("clippy_cargo"), vec![
-        LintId::of(&cargo_common_metadata::CARGO_COMMON_METADATA),
-        LintId::of(&multiple_crate_versions::MULTIPLE_CRATE_VERSIONS),
-        LintId::of(&wildcard_dependencies::WILDCARD_DEPENDENCIES),
+        LintId::of(cargo_common_metadata::CARGO_COMMON_METADATA),
+        LintId::of(multiple_crate_versions::MULTIPLE_CRATE_VERSIONS),
+        LintId::of(wildcard_dependencies::WILDCARD_DEPENDENCIES),
     ]);
 
     store.register_group(true, "clippy::nursery", Some("clippy_nursery"), vec![
-        LintId::of(&attrs::EMPTY_LINE_AFTER_OUTER_ATTR),
-        LintId::of(&cognitive_complexity::COGNITIVE_COMPLEXITY),
-        LintId::of(&disallowed_method::DISALLOWED_METHOD),
-        LintId::of(&fallible_impl_from::FALLIBLE_IMPL_FROM),
-        LintId::of(&floating_point_arithmetic::IMPRECISE_FLOPS),
-        LintId::of(&floating_point_arithmetic::SUBOPTIMAL_FLOPS),
-        LintId::of(&future_not_send::FUTURE_NOT_SEND),
-        LintId::of(&let_if_seq::USELESS_LET_IF_SEQ),
-        LintId::of(&missing_const_for_fn::MISSING_CONST_FOR_FN),
-        LintId::of(&mutable_debug_assertion::DEBUG_ASSERT_WITH_MUT_CALL),
-        LintId::of(&mutex_atomic::MUTEX_INTEGER),
-        LintId::of(&needless_borrow::NEEDLESS_BORROW),
-        LintId::of(&path_buf_push_overwrite::PATH_BUF_PUSH_OVERWRITE),
-        LintId::of(&redundant_pub_crate::REDUNDANT_PUB_CRATE),
-        LintId::of(&regex::TRIVIAL_REGEX),
-        LintId::of(&strings::STRING_LIT_AS_BYTES),
-        LintId::of(&transmute::USELESS_TRANSMUTE),
-        LintId::of(&use_self::USE_SELF),
+        LintId::of(attrs::EMPTY_LINE_AFTER_OUTER_ATTR),
+        LintId::of(cognitive_complexity::COGNITIVE_COMPLEXITY),
+        LintId::of(disallowed_method::DISALLOWED_METHOD),
+        LintId::of(fallible_impl_from::FALLIBLE_IMPL_FROM),
+        LintId::of(floating_point_arithmetic::IMPRECISE_FLOPS),
+        LintId::of(floating_point_arithmetic::SUBOPTIMAL_FLOPS),
+        LintId::of(future_not_send::FUTURE_NOT_SEND),
+        LintId::of(let_if_seq::USELESS_LET_IF_SEQ),
+        LintId::of(missing_const_for_fn::MISSING_CONST_FOR_FN),
+        LintId::of(mutable_debug_assertion::DEBUG_ASSERT_WITH_MUT_CALL),
+        LintId::of(mutex_atomic::MUTEX_INTEGER),
+        LintId::of(needless_borrow::NEEDLESS_BORROW),
+        LintId::of(path_buf_push_overwrite::PATH_BUF_PUSH_OVERWRITE),
+        LintId::of(redundant_pub_crate::REDUNDANT_PUB_CRATE),
+        LintId::of(regex::TRIVIAL_REGEX),
+        LintId::of(strings::STRING_LIT_AS_BYTES),
+        LintId::of(transmute::USELESS_TRANSMUTE),
+        LintId::of(use_self::USE_SELF),
     ]);
 }
 
diff --git a/clippy_lints/src/lifetimes.rs b/clippy_lints/src/lifetimes.rs
index e3b3fa21cab..116ad072837 100644
--- a/clippy_lints/src/lifetimes.rs
+++ b/clippy_lints/src/lifetimes.rs
@@ -81,7 +81,7 @@ declare_lint_pass!(Lifetimes => [NEEDLESS_LIFETIMES, EXTRA_UNUSED_LIFETIMES]);
 impl<'tcx> LateLintPass<'tcx> for Lifetimes {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
         if let ItemKind::Fn(ref sig, ref generics, id) = item.kind {
-            check_fn_inner(cx, &sig.decl, Some(id), generics, item.span, true);
+            check_fn_inner(cx, sig.decl, Some(id), generics, item.span, true);
         }
     }
 
@@ -90,7 +90,7 @@ impl<'tcx> LateLintPass<'tcx> for Lifetimes {
             let report_extra_lifetimes = trait_ref_of_method(cx, item.hir_id()).is_none();
             check_fn_inner(
                 cx,
-                &sig.decl,
+                sig.decl,
                 Some(id),
                 &item.generics,
                 item.span,
@@ -105,7 +105,7 @@ impl<'tcx> LateLintPass<'tcx> for Lifetimes {
                 TraitFn::Required(_) => None,
                 TraitFn::Provided(id) => Some(id),
             };
-            check_fn_inner(cx, &sig.decl, body, &item.generics, item.span, true);
+            check_fn_inner(cx, sig.decl, body, &item.generics, item.span, true);
         }
     }
 }
@@ -149,7 +149,7 @@ fn check_fn_inner<'tcx>(
                     .last()
                     .expect("a path must have at least one segment")
                     .args;
-                if let Some(ref params) = *params {
+                if let Some(params) = *params {
                     let lifetimes = params.args.iter().filter_map(|arg| match arg {
                         GenericArg::Lifetime(lt) => Some(lt),
                         _ => None,
@@ -163,7 +163,7 @@ fn check_fn_inner<'tcx>(
             }
         }
     }
-    if could_use_elision(cx, decl, body, &generics.params) {
+    if could_use_elision(cx, decl, body, generics.params) {
         span_lint(
             cx,
             NEEDLESS_LIFETIMES,
@@ -201,7 +201,7 @@ fn could_use_elision<'tcx>(
         input_visitor.visit_ty(arg);
     }
     // extract lifetimes in output type
-    if let Return(ref ty) = func.output {
+    if let Return(ty) = func.output {
         output_visitor.visit_ty(ty);
     }
     for lt in named_generics {
@@ -416,12 +416,12 @@ fn has_where_lifetimes<'tcx>(cx: &LateContext<'tcx>, where_clause: &'tcx WhereCl
                 // a predicate like F: Trait or F: for<'a> Trait<'a>
                 let mut visitor = RefVisitor::new(cx);
                 // walk the type F, it may not contain LT refs
-                walk_ty(&mut visitor, &pred.bounded_ty);
+                walk_ty(&mut visitor, pred.bounded_ty);
                 if !visitor.all_lts().is_empty() {
                     return true;
                 }
                 // if the bounds define new lifetimes, they are fine to occur
-                let allowed_lts = allowed_lts_from(&pred.bound_generic_params);
+                let allowed_lts = allowed_lts_from(pred.bound_generic_params);
                 // now walk the bounds
                 for bound in pred.bounds.iter() {
                     walk_param_bound(&mut visitor, bound);
@@ -433,8 +433,8 @@ fn has_where_lifetimes<'tcx>(cx: &LateContext<'tcx>, where_clause: &'tcx WhereCl
             },
             WherePredicate::EqPredicate(ref pred) => {
                 let mut visitor = RefVisitor::new(cx);
-                walk_ty(&mut visitor, &pred.lhs_ty);
-                walk_ty(&mut visitor, &pred.rhs_ty);
+                walk_ty(&mut visitor, pred.lhs_ty);
+                walk_ty(&mut visitor, pred.rhs_ty);
                 if !visitor.lts.is_empty() {
                     return true;
                 }
diff --git a/clippy_lints/src/literal_representation.rs b/clippy_lints/src/literal_representation.rs
index 7fd55151226..1d63af25803 100644
--- a/clippy_lints/src/literal_representation.rs
+++ b/clippy_lints/src/literal_representation.rs
@@ -248,7 +248,7 @@ impl LiteralDigitGrouping {
     fn check_lit(self, cx: &EarlyContext<'_>, lit: &Lit) {
         if_chain! {
             if let Some(src) = snippet_opt(cx, lit.span);
-            if let Some(mut num_lit) = NumericLiteral::from_lit(&src, &lit);
+            if let Some(mut num_lit) = NumericLiteral::from_lit(&src, lit);
             then {
                 if !Self::check_for_mistyped_suffix(cx, lit.span, &mut num_lit) {
                     return;
@@ -438,7 +438,7 @@ impl DecimalLiteralRepresentation {
         if_chain! {
             if let LitKind::Int(val, _) = lit.kind;
             if let Some(src) = snippet_opt(cx, lit.span);
-            if let Some(num_lit) = NumericLiteral::from_lit(&src, &lit);
+            if let Some(num_lit) = NumericLiteral::from_lit(&src, lit);
             if num_lit.radix == Radix::Decimal;
             if val >= u128::from(self.threshold);
             then {
diff --git a/clippy_lints/src/loops/explicit_counter_loop.rs b/clippy_lints/src/loops/explicit_counter_loop.rs
index f14dbb1d642..98e60f7ed85 100644
--- a/clippy_lints/src/loops/explicit_counter_loop.rs
+++ b/clippy_lints/src/loops/explicit_counter_loop.rs
@@ -26,7 +26,7 @@ pub(super) fn check<'tcx>(
 
     // For each candidate, check the parent block to see if
     // it's initialized to zero at the start of the loop.
-    if let Some(block) = get_enclosing_block(&cx, expr.hir_id) {
+    if let Some(block) = get_enclosing_block(cx, expr.hir_id) {
         for id in increment_visitor.into_results() {
             let mut initialize_visitor = InitializeVisitor::new(cx, expr, id);
             walk_block(&mut initialize_visitor, block);
diff --git a/clippy_lints/src/loops/for_kv_map.rs b/clippy_lints/src/loops/for_kv_map.rs
index 8f18f54119b..666b8c58728 100644
--- a/clippy_lints/src/loops/for_kv_map.rs
+++ b/clippy_lints/src/loops/for_kv_map.rs
@@ -19,7 +19,7 @@ pub(super) fn check<'tcx>(
 ) {
     let pat_span = pat.span;
 
-    if let PatKind::Tuple(ref pat, _) = pat.kind {
+    if let PatKind::Tuple(pat, _) = pat.kind {
         if pat.len() == 2 {
             let arg_span = arg.span;
             let (new_pat_span, kind, ty, mutbl) = match *cx.typeck_results().expr_ty(arg).kind() {
@@ -35,7 +35,7 @@ pub(super) fn check<'tcx>(
                 Mutability::Mut => "_mut",
             };
             let arg = match arg.kind {
-                ExprKind::AddrOf(BorrowKind::Ref, _, ref expr) => &**expr,
+                ExprKind::AddrOf(BorrowKind::Ref, _, expr) => expr,
                 _ => arg,
             };
 
diff --git a/clippy_lints/src/loops/manual_flatten.rs b/clippy_lints/src/loops/manual_flatten.rs
index 574ad8c0f29..94743cfcf46 100644
--- a/clippy_lints/src/loops/manual_flatten.rs
+++ b/clippy_lints/src/loops/manual_flatten.rs
@@ -18,7 +18,7 @@ pub(super) fn check<'tcx>(
     body: &'tcx Expr<'_>,
     span: Span,
 ) {
-    if let ExprKind::Block(ref block, _) = body.kind {
+    if let ExprKind::Block(block, _) = body.kind {
         // Ensure the `if let` statement is the only expression or statement in the for-loop
         let inner_expr = if block.stmts.len() == 1 && block.expr.is_none() {
             let match_stmt = &block.stmts[0];
@@ -36,7 +36,7 @@ pub(super) fn check<'tcx>(
         if_chain! {
             if let Some(inner_expr) = inner_expr;
             if let ExprKind::Match(
-                ref match_expr, ref match_arms, MatchSource::IfLetDesugar{ contains_else_clause: false }
+                match_expr, match_arms, MatchSource::IfLetDesugar{ contains_else_clause: false }
             ) = inner_expr.kind;
             // Ensure match_expr in `if let` statement is the same as the pat from the for-loop
             if let PatKind::Binding(_, pat_hir_id, _, _) = pat.kind;
diff --git a/clippy_lints/src/loops/manual_memcpy.rs b/clippy_lints/src/loops/manual_memcpy.rs
index 3c5abb7a3c4..47005aba388 100644
--- a/clippy_lints/src/loops/manual_memcpy.rs
+++ b/clippy_lints/src/loops/manual_memcpy.rs
@@ -63,8 +63,8 @@ pub(super) fn check<'tcx>(
                             if let ExprKind::Index(base_right, idx_right) = rhs.kind;
                             if is_slice_like(cx, cx.typeck_results().expr_ty(base_left));
                             if is_slice_like(cx, cx.typeck_results().expr_ty(base_right));
-                            if let Some((start_left, offset_left)) = get_details_from_idx(cx, &idx_left, &starts);
-                            if let Some((start_right, offset_right)) = get_details_from_idx(cx, &idx_right, &starts);
+                            if let Some((start_left, offset_left)) = get_details_from_idx(cx, idx_left, &starts);
+                            if let Some((start_right, offset_right)) = get_details_from_idx(cx, idx_right, &starts);
 
                             // Source and destination must be different
                             if path_to_local(base_left) != path_to_local(base_right);
@@ -168,8 +168,8 @@ fn build_manual_memcpy_suggestion<'tcx>(
         },
     };
 
-    let (dst_offset, dst_limit) = print_offset_and_limit(&dst);
-    let (src_offset, src_limit) = print_offset_and_limit(&src);
+    let (dst_offset, dst_limit) = print_offset_and_limit(dst);
+    let (src_offset, src_limit) = print_offset_and_limit(src);
 
     let dst_base_str = snippet(cx, dst.base.span, "???");
     let src_base_str = snippet(cx, src.base.span, "???");
@@ -435,7 +435,7 @@ fn get_loop_counters<'a, 'tcx>(
 
     // For each candidate, check the parent block to see if
     // it's initialized to zero at the start of the loop.
-    get_enclosing_block(&cx, expr.hir_id).and_then(|block| {
+    get_enclosing_block(cx, expr.hir_id).and_then(|block| {
         increment_visitor
             .into_results()
             .filter_map(move |var_id| {
diff --git a/clippy_lints/src/loops/mod.rs b/clippy_lints/src/loops/mod.rs
index 20291491998..28acefd51fe 100644
--- a/clippy_lints/src/loops/mod.rs
+++ b/clippy_lints/src/loops/mod.rs
@@ -562,7 +562,7 @@ impl<'tcx> LateLintPass<'tcx> for Loops {
         // check for `loop { if let {} else break }` that could be `while let`
         // (also matches an explicit "match" instead of "if let")
         // (even if the "match" or "if let" is used for declaration)
-        if let ExprKind::Loop(ref block, _, LoopSource::Loop, _) = expr.kind {
+        if let ExprKind::Loop(block, _, LoopSource::Loop, _) = expr.kind {
             // also check for empty `loop {}` statements, skipping those in #[panic_handler]
             empty_loop::check(cx, expr, block);
             while_let_loop::check(cx, expr, block);
@@ -570,7 +570,7 @@ impl<'tcx> LateLintPass<'tcx> for Loops {
 
         while_let_on_iterator::check(cx, expr);
 
-        if let Some((cond, body)) = higher::while_loop(&expr) {
+        if let Some((cond, body)) = higher::while_loop(expr) {
             while_immutable_condition::check(cx, cond, body);
         }
 
@@ -602,7 +602,7 @@ fn check_for_loop<'tcx>(
 fn check_for_loop_arg(cx: &LateContext<'_>, pat: &Pat<'_>, arg: &Expr<'_>, expr: &Expr<'_>) {
     let mut next_loop_linted = false; // whether or not ITER_NEXT_LOOP lint was used
 
-    if let ExprKind::MethodCall(ref method, _, ref args, _) = arg.kind {
+    if let ExprKind::MethodCall(method, _, args, _) = arg.kind {
         // just the receiver, no arguments
         if args.len() == 1 {
             let method_name = &*method.ident.as_str();
diff --git a/clippy_lints/src/loops/needless_collect.rs b/clippy_lints/src/loops/needless_collect.rs
index e0c5caf5136..4d73aef76e8 100644
--- a/clippy_lints/src/loops/needless_collect.rs
+++ b/clippy_lints/src/loops/needless_collect.rs
@@ -21,10 +21,10 @@ pub(super) fn check<'tcx>(expr: &'tcx Expr<'_>, cx: &LateContext<'tcx>) {
 }
 fn check_needless_collect_direct_usage<'tcx>(expr: &'tcx Expr<'_>, cx: &LateContext<'tcx>) {
     if_chain! {
-        if let ExprKind::MethodCall(ref method, _, ref args, _) = expr.kind;
-        if let ExprKind::MethodCall(ref chain_method, method0_span, _, _) = args[0].kind;
+        if let ExprKind::MethodCall(method, _, args, _) = expr.kind;
+        if let ExprKind::MethodCall(chain_method, method0_span, _, _) = args[0].kind;
         if chain_method.ident.name == sym!(collect) && is_trait_method(cx, &args[0], sym::Iterator);
-        if let Some(ref generic_args) = chain_method.args;
+        if let Some(generic_args) = chain_method.args;
         if let Some(GenericArg::Type(ref ty)) = generic_args.args.get(0);
         let ty = cx.typeck_results().node_type(ty.hir_id);
         if is_type_diagnostic_item(cx, ty, sym::vec_type)
@@ -58,16 +58,16 @@ fn check_needless_collect_direct_usage<'tcx>(expr: &'tcx Expr<'_>, cx: &LateCont
 }
 
 fn check_needless_collect_indirect_usage<'tcx>(expr: &'tcx Expr<'_>, cx: &LateContext<'tcx>) {
-    if let ExprKind::Block(ref block, _) = expr.kind {
-        for ref stmt in block.stmts {
+    if let ExprKind::Block(block, _) = expr.kind {
+        for stmt in block.stmts {
             if_chain! {
                 if let StmtKind::Local(
                     Local { pat: Pat { hir_id: pat_id, kind: PatKind::Binding(_, _, ident, .. ), .. },
-                    init: Some(ref init_expr), .. }
+                    init: Some(init_expr), .. }
                 ) = stmt.kind;
-                if let ExprKind::MethodCall(ref method_name, collect_span, &[ref iter_source], ..) = init_expr.kind;
-                if method_name.ident.name == sym!(collect) && is_trait_method(cx, &init_expr, sym::Iterator);
-                if let Some(ref generic_args) = method_name.args;
+                if let ExprKind::MethodCall(method_name, collect_span, &[ref iter_source], ..) = init_expr.kind;
+                if method_name.ident.name == sym!(collect) && is_trait_method(cx, init_expr, sym::Iterator);
+                if let Some(generic_args) = method_name.args;
                 if let Some(GenericArg::Type(ref ty)) = generic_args.args.get(0);
                 if let ty = cx.typeck_results().node_type(ty.hir_id);
                 if is_type_diagnostic_item(cx, ty, sym::vec_type) ||
@@ -165,8 +165,8 @@ impl<'tcx> Visitor<'tcx> for IterFunctionVisitor {
     fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) {
         // Check function calls on our collection
         if_chain! {
-            if let ExprKind::MethodCall(method_name, _, ref args, _) = &expr.kind;
-            if let Some(Expr { kind: ExprKind::Path(QPath::Resolved(_, ref path)), .. }) = args.get(0);
+            if let ExprKind::MethodCall(method_name, _, args, _) = &expr.kind;
+            if let Some(Expr { kind: ExprKind::Path(QPath::Resolved(_, path)), .. }) = args.get(0);
             if let &[name] = &path.segments;
             if name.ident == self.target;
             then {
@@ -193,7 +193,7 @@ impl<'tcx> Visitor<'tcx> for IterFunctionVisitor {
         }
         // Check if the collection is used for anything else
         if_chain! {
-            if let Expr { kind: ExprKind::Path(QPath::Resolved(_, ref path)), .. } = expr;
+            if let Expr { kind: ExprKind::Path(QPath::Resolved(_, path)), .. } = expr;
             if let &[name] = &path.segments;
             if name.ident == self.target;
             then {
diff --git a/clippy_lints/src/loops/needless_range_loop.rs b/clippy_lints/src/loops/needless_range_loop.rs
index 60afa449a45..56141fb3837 100644
--- a/clippy_lints/src/loops/needless_range_loop.rs
+++ b/clippy_lints/src/loops/needless_range_loop.rs
@@ -96,7 +96,7 @@ pub(super) fn check<'tcx>(
                 let take = if let Some(end) = *end {
                     let mut take_expr = end;
 
-                    if let ExprKind::Binary(ref op, ref left, ref right) = end.kind {
+                    if let ExprKind::Binary(ref op, left, right) = end.kind {
                         if let BinOpKind::Add = op.node {
                             let start_equal_left = SpanlessEq::new(cx).eq_expr(start, left);
                             let start_equal_right = SpanlessEq::new(cx).eq_expr(start, right);
@@ -190,10 +190,10 @@ pub(super) fn check<'tcx>(
 
 fn is_len_call(expr: &Expr<'_>, var: Symbol) -> bool {
     if_chain! {
-        if let ExprKind::MethodCall(ref method, _, ref len_args, _) = expr.kind;
+        if let ExprKind::MethodCall(method, _, len_args, _) = expr.kind;
         if len_args.len() == 1;
         if method.ident.name == sym!(len);
-        if let ExprKind::Path(QPath::Resolved(_, ref path)) = len_args[0].kind;
+        if let ExprKind::Path(QPath::Resolved(_, path)) = len_args[0].kind;
         if path.segments.len() == 1;
         if path.segments[0].ident.name == var;
         then {
@@ -254,7 +254,7 @@ impl<'a, 'tcx> VarVisitor<'a, 'tcx> {
         if_chain! {
             // the indexed container is referenced by a name
             if let ExprKind::Path(ref seqpath) = seqexpr.kind;
-            if let QPath::Resolved(None, ref seqvar) = *seqpath;
+            if let QPath::Resolved(None, seqvar) = *seqpath;
             if seqvar.segments.len() == 1;
             let index_used_directly = path_to_local_id(idx, self.var);
             let indexed_indirectly = {
@@ -310,7 +310,7 @@ impl<'a, 'tcx> Visitor<'tcx> for VarVisitor<'a, 'tcx> {
     fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
         if_chain! {
             // a range index op
-            if let ExprKind::MethodCall(ref meth, _, ref args, _) = expr.kind;
+            if let ExprKind::MethodCall(meth, _, args, _) = expr.kind;
             if (meth.ident.name == sym::index && match_trait_method(self.cx, expr, &paths::INDEX))
                 || (meth.ident.name == sym::index_mut && match_trait_method(self.cx, expr, &paths::INDEX_MUT));
             if !self.check(&args[1], &args[0], expr);
@@ -319,7 +319,7 @@ impl<'a, 'tcx> Visitor<'tcx> for VarVisitor<'a, 'tcx> {
 
         if_chain! {
             // an index op
-            if let ExprKind::Index(ref seqexpr, ref idx) = expr.kind;
+            if let ExprKind::Index(seqexpr, idx) = expr.kind;
             if !self.check(idx, seqexpr, expr);
             then { return }
         }
@@ -340,19 +340,19 @@ impl<'a, 'tcx> Visitor<'tcx> for VarVisitor<'a, 'tcx> {
 
         let old = self.prefer_mutable;
         match expr.kind {
-            ExprKind::AssignOp(_, ref lhs, ref rhs) | ExprKind::Assign(ref lhs, ref rhs, _) => {
+            ExprKind::AssignOp(_, lhs, rhs) | ExprKind::Assign(lhs, rhs, _) => {
                 self.prefer_mutable = true;
                 self.visit_expr(lhs);
                 self.prefer_mutable = false;
                 self.visit_expr(rhs);
             },
-            ExprKind::AddrOf(BorrowKind::Ref, mutbl, ref expr) => {
+            ExprKind::AddrOf(BorrowKind::Ref, mutbl, expr) => {
                 if mutbl == Mutability::Mut {
                     self.prefer_mutable = true;
                 }
                 self.visit_expr(expr);
             },
-            ExprKind::Call(ref f, args) => {
+            ExprKind::Call(f, args) => {
                 self.visit_expr(f);
                 for expr in args {
                     let ty = self.cx.typeck_results().expr_ty_adjusted(expr);
diff --git a/clippy_lints/src/loops/never_loop.rs b/clippy_lints/src/loops/never_loop.rs
index f63a3761a0d..e2cb4638018 100644
--- a/clippy_lints/src/loops/never_loop.rs
+++ b/clippy_lints/src/loops/never_loop.rs
@@ -5,7 +5,7 @@ use rustc_lint::LateContext;
 use std::iter::{once, Iterator};
 
 pub(super) fn check(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-    if let ExprKind::Loop(ref block, _, _, _) = expr.kind {
+    if let ExprKind::Loop(block, _, _, _) = expr.kind {
         match never_loop_block(block, expr.hir_id) {
             NeverLoopResult::AlwaysBreak => span_lint(cx, NEVER_LOOP, expr.span, "this loop never actually loops"),
             NeverLoopResult::MayContinueMainLoop | NeverLoopResult::Otherwise => (),
@@ -76,36 +76,36 @@ fn never_loop_expr_seq<'a, T: Iterator<Item = &'a Expr<'a>>>(es: &mut T, main_lo
 
 fn stmt_to_expr<'tcx>(stmt: &Stmt<'tcx>) -> Option<&'tcx Expr<'tcx>> {
     match stmt.kind {
-        StmtKind::Semi(ref e, ..) | StmtKind::Expr(ref e, ..) => Some(e),
-        StmtKind::Local(ref local) => local.init.as_deref(),
+        StmtKind::Semi(e, ..) | StmtKind::Expr(e, ..) => Some(e),
+        StmtKind::Local(local) => local.init.as_deref(),
         StmtKind::Item(..) => None,
     }
 }
 
 fn never_loop_expr(expr: &Expr<'_>, main_loop_id: HirId) -> NeverLoopResult {
     match expr.kind {
-        ExprKind::Box(ref e)
-        | ExprKind::Unary(_, ref e)
-        | ExprKind::Cast(ref e, _)
-        | ExprKind::Type(ref e, _)
-        | ExprKind::Field(ref e, _)
-        | ExprKind::AddrOf(_, _, ref e)
-        | ExprKind::Struct(_, _, Some(ref e))
-        | ExprKind::Repeat(ref e, _)
-        | ExprKind::DropTemps(ref e) => never_loop_expr(e, main_loop_id),
-        ExprKind::Array(ref es) | ExprKind::MethodCall(_, _, ref es, _) | ExprKind::Tup(ref es) => {
+        ExprKind::Box(e)
+        | ExprKind::Unary(_, e)
+        | ExprKind::Cast(e, _)
+        | ExprKind::Type(e, _)
+        | ExprKind::Field(e, _)
+        | ExprKind::AddrOf(_, _, e)
+        | ExprKind::Struct(_, _, Some(e))
+        | ExprKind::Repeat(e, _)
+        | ExprKind::DropTemps(e) => never_loop_expr(e, main_loop_id),
+        ExprKind::Array(es) | ExprKind::MethodCall(_, _, es, _) | ExprKind::Tup(es) => {
             never_loop_expr_all(&mut es.iter(), main_loop_id)
         },
-        ExprKind::Call(ref e, ref es) => never_loop_expr_all(&mut once(&**e).chain(es.iter()), main_loop_id),
-        ExprKind::Binary(_, ref e1, ref e2)
-        | ExprKind::Assign(ref e1, ref e2, _)
-        | ExprKind::AssignOp(_, ref e1, ref e2)
-        | ExprKind::Index(ref e1, ref e2) => never_loop_expr_all(&mut [&**e1, &**e2].iter().cloned(), main_loop_id),
-        ExprKind::Loop(ref b, _, _, _) => {
+        ExprKind::Call(e, es) => never_loop_expr_all(&mut once(e).chain(es.iter()), main_loop_id),
+        ExprKind::Binary(_, e1, e2)
+        | ExprKind::Assign(e1, e2, _)
+        | ExprKind::AssignOp(_, e1, e2)
+        | ExprKind::Index(e1, e2) => never_loop_expr_all(&mut [e1, e2].iter().cloned(), main_loop_id),
+        ExprKind::Loop(b, _, _, _) => {
             // Break can come from the inner loop so remove them.
             absorb_break(&never_loop_block(b, main_loop_id))
         },
-        ExprKind::If(ref e, ref e2, ref e3) => {
+        ExprKind::If(e, e2, ref e3) => {
             let e1 = never_loop_expr(e, main_loop_id);
             let e2 = never_loop_expr(e2, main_loop_id);
             let e3 = e3
@@ -113,7 +113,7 @@ fn never_loop_expr(expr: &Expr<'_>, main_loop_id: HirId) -> NeverLoopResult {
                 .map_or(NeverLoopResult::Otherwise, |e| never_loop_expr(e, main_loop_id));
             combine_seq(e1, combine_branches(e2, e3))
         },
-        ExprKind::Match(ref e, ref arms, _) => {
+        ExprKind::Match(e, arms, _) => {
             let e = never_loop_expr(e, main_loop_id);
             if arms.is_empty() {
                 e
@@ -122,7 +122,7 @@ fn never_loop_expr(expr: &Expr<'_>, main_loop_id: HirId) -> NeverLoopResult {
                 combine_seq(e, arms)
             }
         },
-        ExprKind::Block(ref b, _) => never_loop_block(b, main_loop_id),
+        ExprKind::Block(b, _) => never_loop_block(b, main_loop_id),
         ExprKind::Continue(d) => {
             let id = d
                 .target_id
@@ -136,7 +136,7 @@ fn never_loop_expr(expr: &Expr<'_>, main_loop_id: HirId) -> NeverLoopResult {
         ExprKind::Break(_, ref e) | ExprKind::Ret(ref e) => e.as_ref().map_or(NeverLoopResult::AlwaysBreak, |e| {
             combine_seq(never_loop_expr(e, main_loop_id), NeverLoopResult::AlwaysBreak)
         }),
-        ExprKind::InlineAsm(ref asm) => asm
+        ExprKind::InlineAsm(asm) => asm
             .operands
             .iter()
             .map(|(o, _)| match o {
diff --git a/clippy_lints/src/loops/same_item_push.rs b/clippy_lints/src/loops/same_item_push.rs
index b3d784474c8..cb2c83e9029 100644
--- a/clippy_lints/src/loops/same_item_push.rs
+++ b/clippy_lints/src/loops/same_item_push.rs
@@ -161,7 +161,7 @@ impl<'a, 'tcx> Visitor<'tcx> for SameItemPushVisitor<'a, 'tcx> {
         if vec_push_option.is_none() {
             // Current statement is not a push so visit inside
             match &s.kind {
-                StmtKind::Expr(expr) | StmtKind::Semi(expr) => self.visit_expr(&expr),
+                StmtKind::Expr(expr) | StmtKind::Semi(expr) => self.visit_expr(expr),
                 _ => {},
             }
         } else {
diff --git a/clippy_lints/src/loops/single_element_loop.rs b/clippy_lints/src/loops/single_element_loop.rs
index 8451c1c6130..fc067e81bca 100644
--- a/clippy_lints/src/loops/single_element_loop.rs
+++ b/clippy_lints/src/loops/single_element_loop.rs
@@ -15,12 +15,12 @@ pub(super) fn check<'tcx>(
     expr: &'tcx Expr<'_>,
 ) {
     if_chain! {
-        if let ExprKind::AddrOf(BorrowKind::Ref, _, ref arg_expr) = arg.kind;
+        if let ExprKind::AddrOf(BorrowKind::Ref, _, arg_expr) = arg.kind;
         if let PatKind::Binding(.., target, _) = pat.kind;
         if let ExprKind::Array([arg_expression]) = arg_expr.kind;
         if let ExprKind::Path(ref list_item) = arg_expression.kind;
         if let Some(list_item_name) = single_segment_path(list_item).map(|ps| ps.ident.name);
-        if let ExprKind::Block(ref block, _) = body.kind;
+        if let ExprKind::Block(block, _) = body.kind;
         if !block.stmts.is_empty();
 
         then {
diff --git a/clippy_lints/src/loops/utils.rs b/clippy_lints/src/loops/utils.rs
index fc287d51249..4db6644b9d7 100644
--- a/clippy_lints/src/loops/utils.rs
+++ b/clippy_lints/src/loops/utils.rs
@@ -65,7 +65,7 @@ impl<'a, 'tcx> Visitor<'tcx> for IncrementVisitor<'a, 'tcx> {
                 }
 
                 match parent.kind {
-                    ExprKind::AssignOp(op, ref lhs, ref rhs) => {
+                    ExprKind::AssignOp(op, lhs, rhs) => {
                         if lhs.hir_id == expr.hir_id {
                             *state = if op.node == BinOpKind::Add
                                 && is_integer_const(self.cx, rhs, 1)
@@ -79,7 +79,7 @@ impl<'a, 'tcx> Visitor<'tcx> for IncrementVisitor<'a, 'tcx> {
                             };
                         }
                     },
-                    ExprKind::Assign(ref lhs, _, _) if lhs.hir_id == expr.hir_id => {
+                    ExprKind::Assign(lhs, _, _) if lhs.hir_id == expr.hir_id => {
                         *state = IncrementVisitorVarState::DontWarn
                     },
                     ExprKind::AddrOf(BorrowKind::Ref, mutability, _) if mutability == Mutability::Mut => {
@@ -153,7 +153,7 @@ impl<'a, 'tcx> Visitor<'tcx> for InitializeVisitor<'a, 'tcx> {
     fn visit_stmt(&mut self, stmt: &'tcx Stmt<'_>) {
         // Look for declarations of the variable
         if_chain! {
-            if let StmtKind::Local(ref local) = stmt.kind;
+            if let StmtKind::Local(local) = stmt.kind;
             if local.pat.hir_id == self.var_id;
             if let PatKind::Binding(.., ident, _) = local.pat.kind;
             then {
@@ -191,10 +191,10 @@ impl<'a, 'tcx> Visitor<'tcx> for InitializeVisitor<'a, 'tcx> {
 
             if let Some(parent) = get_parent_expr(self.cx, expr) {
                 match parent.kind {
-                    ExprKind::AssignOp(_, ref lhs, _) if lhs.hir_id == expr.hir_id => {
+                    ExprKind::AssignOp(_, lhs, _) if lhs.hir_id == expr.hir_id => {
                         self.state = InitializeVisitorState::DontWarn;
                     },
-                    ExprKind::Assign(ref lhs, ref rhs, _) if lhs.hir_id == expr.hir_id => {
+                    ExprKind::Assign(lhs, rhs, _) if lhs.hir_id == expr.hir_id => {
                         self.state = if_chain! {
                             if self.depth == 0;
                             if let InitializeVisitorState::Declared(name)
@@ -273,7 +273,7 @@ impl<'tcx> Visitor<'tcx> for LoopNestVisitor {
             return;
         }
         match expr.kind {
-            ExprKind::Assign(ref path, _, _) | ExprKind::AssignOp(_, ref path, _) => {
+            ExprKind::Assign(path, _, _) | ExprKind::AssignOp(_, path, _) => {
                 if path_to_local_id(path, self.iterator) {
                     self.nesting = RuledOut;
                 }
@@ -327,7 +327,7 @@ pub(super) fn make_iterator_snippet(cx: &LateContext<'_>, arg: &Expr<'_>, applic
         // (&mut x).into_iter() ==> x.iter_mut()
         match &arg.kind {
             ExprKind::AddrOf(BorrowKind::Ref, mutability, arg_inner)
-                if has_iter_method(cx, cx.typeck_results().expr_ty(&arg_inner)).is_some() =>
+                if has_iter_method(cx, cx.typeck_results().expr_ty(arg_inner)).is_some() =>
             {
                 let meth_name = match mutability {
                     Mutability::Mut => "iter_mut",
@@ -335,7 +335,7 @@ pub(super) fn make_iterator_snippet(cx: &LateContext<'_>, arg: &Expr<'_>, applic
                 };
                 format!(
                     "{}.{}()",
-                    sugg::Sugg::hir_with_applicability(cx, &arg_inner, "_", applic_ref).maybe_par(),
+                    sugg::Sugg::hir_with_applicability(cx, arg_inner, "_", applic_ref).maybe_par(),
                     meth_name,
                 )
             }
diff --git a/clippy_lints/src/loops/while_let_loop.rs b/clippy_lints/src/loops/while_let_loop.rs
index ffe8c0c5494..9c172079852 100644
--- a/clippy_lints/src/loops/while_let_loop.rs
+++ b/clippy_lints/src/loops/while_let_loop.rs
@@ -11,14 +11,14 @@ pub(super) fn check(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, loop_block: &'
     let inner_stmt_expr = extract_expr_from_first_stmt(loop_block);
     // or extract the first expression (if any) from the block
     if let Some(inner) = inner_stmt_expr.or_else(|| extract_first_expr(loop_block)) {
-        if let ExprKind::Match(ref matchexpr, ref arms, ref source) = inner.kind {
+        if let ExprKind::Match(matchexpr, arms, ref source) = inner.kind {
             // ensure "if let" compatible match structure
             match *source {
                 MatchSource::Normal | MatchSource::IfLetDesugar { .. } => {
                     if arms.len() == 2
                         && arms[0].guard.is_none()
                         && arms[1].guard.is_none()
-                        && is_simple_break_expr(&arms[1].body)
+                        && is_simple_break_expr(arms[1].body)
                     {
                         if in_external_macro(cx.sess(), expr.span) {
                             return;
@@ -57,7 +57,7 @@ fn extract_expr_from_first_stmt<'tcx>(block: &Block<'tcx>) -> Option<&'tcx Expr<
     if block.stmts.is_empty() {
         return None;
     }
-    if let StmtKind::Local(ref local) = block.stmts[0].kind {
+    if let StmtKind::Local(local) = block.stmts[0].kind {
         local.init //.map(|expr| expr)
     } else {
         None
@@ -67,9 +67,9 @@ fn extract_expr_from_first_stmt<'tcx>(block: &Block<'tcx>) -> Option<&'tcx Expr<
 /// If a block begins with an expression (with or without semicolon), return it.
 fn extract_first_expr<'tcx>(block: &Block<'tcx>) -> Option<&'tcx Expr<'tcx>> {
     match block.expr {
-        Some(ref expr) if block.stmts.is_empty() => Some(expr),
+        Some(expr) if block.stmts.is_empty() => Some(expr),
         None if !block.stmts.is_empty() => match block.stmts[0].kind {
-            StmtKind::Expr(ref expr) | StmtKind::Semi(ref expr) => Some(expr),
+            StmtKind::Expr(expr) | StmtKind::Semi(expr) => Some(expr),
             StmtKind::Local(..) | StmtKind::Item(..) => None,
         },
         _ => None,
@@ -82,7 +82,7 @@ fn extract_first_expr<'tcx>(block: &Block<'tcx>) -> Option<&'tcx Expr<'tcx>> {
 fn is_simple_break_expr(expr: &Expr<'_>) -> bool {
     match expr.kind {
         ExprKind::Break(dest, ref passed_expr) if dest.label.is_none() && passed_expr.is_none() => true,
-        ExprKind::Block(ref b, _) => extract_first_expr(b).map_or(false, |subexpr| is_simple_break_expr(subexpr)),
+        ExprKind::Block(b, _) => extract_first_expr(b).map_or(false, |subexpr| is_simple_break_expr(subexpr)),
         _ => false,
     }
 }
diff --git a/clippy_lints/src/loops/while_let_on_iterator.rs b/clippy_lints/src/loops/while_let_on_iterator.rs
index 57fc6250a9a..82715d9bafa 100644
--- a/clippy_lints/src/loops/while_let_on_iterator.rs
+++ b/clippy_lints/src/loops/while_let_on_iterator.rs
@@ -16,12 +16,10 @@ use rustc_middle::hir::map::Map;
 use rustc_span::symbol::sym;
 
 pub(super) fn check(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-    if let ExprKind::Match(ref match_expr, ref arms, MatchSource::WhileLetDesugar) = expr.kind {
+    if let ExprKind::Match(match_expr, arms, MatchSource::WhileLetDesugar) = expr.kind {
         let pat = &arms[0].pat.kind;
-        if let (
-            &PatKind::TupleStruct(ref qpath, ref pat_args, _),
-            &ExprKind::MethodCall(ref method_path, _, ref method_args, _),
-        ) = (pat, &match_expr.kind)
+        if let (&PatKind::TupleStruct(ref qpath, pat_args, _), &ExprKind::MethodCall(method_path, _, method_args, _)) =
+            (pat, &match_expr.kind)
         {
             let iter_expr = &method_args[0];
 
@@ -40,8 +38,8 @@ pub(super) fn check(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
                 && is_trait_method(cx, match_expr, sym::Iterator)
                 && lhs_constructor.ident.name == sym::Some
                 && (pat_args.is_empty()
-                    || !is_refutable(cx, &pat_args[0])
-                        && !is_used_inside(cx, iter_expr, &arms[0].body)
+                    || !is_refutable(cx, pat_args[0])
+                        && !is_used_inside(cx, iter_expr, arms[0].body)
                         && !is_iterator_used_after_while_let(cx, iter_expr)
                         && !is_nested(cx, expr, &method_args[0]))
             {
diff --git a/clippy_lints/src/manual_strip.rs b/clippy_lints/src/manual_strip.rs
index 9da37efddac..dfa464ddb81 100644
--- a/clippy_lints/src/manual_strip.rs
+++ b/clippy_lints/src/manual_strip.rs
@@ -91,7 +91,7 @@ impl<'tcx> LateLintPass<'tcx> for ManualStrip {
                 } else {
                     return;
                 };
-                let target_res = cx.qpath_res(&target_path, target_arg.hir_id);
+                let target_res = cx.qpath_res(target_path, target_arg.hir_id);
                 if target_res == Res::Err {
                     return;
                 };
@@ -174,7 +174,7 @@ fn eq_pattern_length<'tcx>(cx: &LateContext<'tcx>, pattern: &Expr<'_>, expr: &'t
 
 // Tests if `expr` is a `&str`.
 fn is_ref_str(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-    match cx.typeck_results().expr_ty_adjusted(&expr).kind() {
+    match cx.typeck_results().expr_ty_adjusted(expr).kind() {
         ty::Ref(_, ty, _) => ty.is_str(),
         _ => false,
     }
diff --git a/clippy_lints/src/map_clone.rs b/clippy_lints/src/map_clone.rs
index 9f1ab1f695d..99c35ae3bbf 100644
--- a/clippy_lints/src/map_clone.rs
+++ b/clippy_lints/src/map_clone.rs
@@ -52,7 +52,7 @@ impl<'tcx> LateLintPass<'tcx> for MapClone {
         }
 
         if_chain! {
-            if let hir::ExprKind::MethodCall(ref method, _, ref args, _) = e.kind;
+            if let hir::ExprKind::MethodCall(method, _, args, _) = e.kind;
             if args.len() == 2;
             if method.ident.name == sym::map;
             let ty = cx.typeck_results().expr_ty(&args[0]);
@@ -62,7 +62,7 @@ impl<'tcx> LateLintPass<'tcx> for MapClone {
                 let closure_body = cx.tcx.hir().body(body_id);
                 let closure_expr = remove_blocks(&closure_body.value);
                 match closure_body.params[0].pat.kind {
-                    hir::PatKind::Ref(ref inner, hir::Mutability::Not) => if let hir::PatKind::Binding(
+                    hir::PatKind::Ref(inner, hir::Mutability::Not) => if let hir::PatKind::Binding(
                         hir::BindingAnnotation::Unannotated, .., name, None
                     ) = inner.kind {
                         if ident_eq(name, closure_expr) {
@@ -71,14 +71,14 @@ impl<'tcx> LateLintPass<'tcx> for MapClone {
                     },
                     hir::PatKind::Binding(hir::BindingAnnotation::Unannotated, .., name, None) => {
                         match closure_expr.kind {
-                            hir::ExprKind::Unary(hir::UnOp::Deref, ref inner) => {
+                            hir::ExprKind::Unary(hir::UnOp::Deref, inner) => {
                                 if ident_eq(name, inner) {
                                     if let ty::Ref(.., Mutability::Not) = cx.typeck_results().expr_ty(inner).kind() {
                                         lint(cx, e.span, args[0].span, true);
                                     }
                                 }
                             },
-                            hir::ExprKind::MethodCall(ref method, _, [obj], _) => if_chain! {
+                            hir::ExprKind::MethodCall(method, _, [obj], _) => if_chain! {
                                 if ident_eq(name, obj) && method.ident.name == sym::clone;
                                 if let Some(fn_id) = cx.typeck_results().type_dependent_def_id(closure_expr.hir_id);
                                 if let Some(trait_id) = cx.tcx.trait_of_item(fn_id);
@@ -109,7 +109,7 @@ impl<'tcx> LateLintPass<'tcx> for MapClone {
 }
 
 fn ident_eq(name: Ident, path: &hir::Expr<'_>) -> bool {
-    if let hir::ExprKind::Path(hir::QPath::Resolved(None, ref path)) = path.kind {
+    if let hir::ExprKind::Path(hir::QPath::Resolved(None, path)) = path.kind {
         path.segments.len() == 1 && path.segments[0].ident == name
     } else {
         false
diff --git a/clippy_lints/src/map_err_ignore.rs b/clippy_lints/src/map_err_ignore.rs
index a6a63961be5..425a9734e5f 100644
--- a/clippy_lints/src/map_err_ignore.rs
+++ b/clippy_lints/src/map_err_ignore.rs
@@ -112,7 +112,7 @@ impl<'tcx> LateLintPass<'tcx> for MapErrIgnore {
         }
 
         // check if this is a method call (e.g. x.foo())
-        if let ExprKind::MethodCall(ref method, _t_span, ref args, _) = e.kind {
+        if let ExprKind::MethodCall(method, _t_span, args, _) = e.kind {
             // only work if the method name is `map_err` and there are only 2 arguments (e.g. x.map_err(|_|[1]
             // Enum::Variant[2]))
             if method.ident.as_str() == "map_err" && args.len() == 2 {
diff --git a/clippy_lints/src/map_identity.rs b/clippy_lints/src/map_identity.rs
index 75191e1f9ee..e7719e7663d 100644
--- a/clippy_lints/src/map_identity.rs
+++ b/clippy_lints/src/map_identity.rs
@@ -61,7 +61,7 @@ impl<'tcx> LateLintPass<'tcx> for MapIdentity {
 /// map(). Otherwise, returns None.
 fn get_map_argument<'a>(cx: &LateContext<'_>, expr: &'a Expr<'a>) -> Option<&'a [Expr<'a>]> {
     if_chain! {
-        if let ExprKind::MethodCall(ref method, _, ref args, _) = expr.kind;
+        if let ExprKind::MethodCall(method, _, args, _) = expr.kind;
         if args.len() == 2 && method.ident.name == sym::map;
         let caller_ty = cx.typeck_results().expr_ty(&args[0]);
         if is_trait_method(cx, expr, sym::Iterator)
@@ -80,7 +80,7 @@ fn get_map_argument<'a>(cx: &LateContext<'_>, expr: &'a Expr<'a>) -> Option<&'a
 fn is_expr_identity_function(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
     match expr.kind {
         ExprKind::Closure(_, _, body_id, _, _) => is_body_identity_function(cx, cx.tcx.hir().body(body_id)),
-        ExprKind::Path(QPath::Resolved(_, ref path)) => match_path(path, &paths::STD_CONVERT_IDENTITY),
+        ExprKind::Path(QPath::Resolved(_, path)) => match_path(path, &paths::STD_CONVERT_IDENTITY),
         _ => false,
     }
 }
@@ -99,12 +99,12 @@ fn is_body_identity_function(cx: &LateContext<'_>, func: &Body<'_>) -> bool {
 
     match body.kind {
         ExprKind::Path(QPath::Resolved(None, _)) => match_expr_param(cx, body, params[0].pat),
-        ExprKind::Ret(Some(ref ret_val)) => match_expr_param(cx, ret_val, params[0].pat),
-        ExprKind::Block(ref block, _) => {
+        ExprKind::Ret(Some(ret_val)) => match_expr_param(cx, ret_val, params[0].pat),
+        ExprKind::Block(block, _) => {
             if_chain! {
                 if block.stmts.len() == 1;
-                if let StmtKind::Semi(ref expr) | StmtKind::Expr(ref expr) = block.stmts[0].kind;
-                if let ExprKind::Ret(Some(ref ret_val)) = expr.kind;
+                if let StmtKind::Semi(expr) | StmtKind::Expr(expr) = block.stmts[0].kind;
+                if let ExprKind::Ret(Some(ret_val)) = expr.kind;
                 then {
                     match_expr_param(cx, ret_val, params[0].pat)
                 } else {
diff --git a/clippy_lints/src/map_unit_fn.rs b/clippy_lints/src/map_unit_fn.rs
index 5cc16244a0d..57cd907e77e 100644
--- a/clippy_lints/src/map_unit_fn.rs
+++ b/clippy_lints/src/map_unit_fn.rs
@@ -133,7 +133,7 @@ fn reduce_unit_expression<'a>(cx: &LateContext<'_>, expr: &'a hir::Expr<'_>) ->
             // Calls can't be reduced any more
             Some(expr.span)
         },
-        hir::ExprKind::Block(ref block, _) => {
+        hir::ExprKind::Block(block, _) => {
             match (block.stmts, block.expr.as_ref()) {
                 (&[], Some(inner_expr)) => {
                     // If block only contains an expression,
@@ -144,8 +144,8 @@ fn reduce_unit_expression<'a>(cx: &LateContext<'_>, expr: &'a hir::Expr<'_>) ->
                     // If block only contains statements,
                     // reduce `{ X; }` to `X` or `X;`
                     match inner_stmt.kind {
-                        hir::StmtKind::Local(ref local) => Some(local.span),
-                        hir::StmtKind::Expr(ref e) => Some(e.span),
+                        hir::StmtKind::Local(local) => Some(local.span),
+                        hir::StmtKind::Expr(e) => Some(e.span),
                         hir::StmtKind::Semi(..) => Some(inner_stmt.span),
                         hir::StmtKind::Item(..) => None,
                     }
@@ -169,12 +169,12 @@ fn unit_closure<'tcx>(
     expr: &hir::Expr<'_>,
 ) -> Option<(&'tcx hir::Param<'tcx>, &'tcx hir::Expr<'tcx>)> {
     if_chain! {
-        if let hir::ExprKind::Closure(_, ref decl, inner_expr_id, _, _) = expr.kind;
+        if let hir::ExprKind::Closure(_, decl, inner_expr_id, _, _) = expr.kind;
         let body = cx.tcx.hir().body(inner_expr_id);
         let body_expr = &body.value;
         if decl.inputs.len() == 1;
         if is_unit_expression(cx, body_expr);
-        if let Some(binding) = iter_input_pats(&decl, body).next();
+        if let Some(binding) = iter_input_pats(decl, body).next();
         then {
             return Some((binding, body_expr));
         }
@@ -267,7 +267,7 @@ impl<'tcx> LateLintPass<'tcx> for MapUnit {
             return;
         }
 
-        if let hir::StmtKind::Semi(ref expr) = stmt.kind {
+        if let hir::StmtKind::Semi(expr) = stmt.kind {
             if let Some(arglists) = method_chain_args(expr, &["map"]) {
                 lint_map_unit_fn(cx, stmt, expr, arglists[0]);
             }
diff --git a/clippy_lints/src/match_on_vec_items.rs b/clippy_lints/src/match_on_vec_items.rs
index ccaa5e98c83..ca6fb0831fe 100644
--- a/clippy_lints/src/match_on_vec_items.rs
+++ b/clippy_lints/src/match_on_vec_items.rs
@@ -51,7 +51,7 @@ impl<'tcx> LateLintPass<'tcx> for MatchOnVecItems {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
         if_chain! {
             if !in_external_macro(cx.sess(), expr.span);
-            if let ExprKind::Match(ref match_expr, _, MatchSource::Normal) = expr.kind;
+            if let ExprKind::Match(match_expr, _, MatchSource::Normal) = expr.kind;
             if let Some(idx_expr) = is_vec_indexing(cx, match_expr);
             if let ExprKind::Index(vec, idx) = idx_expr.kind;
 
@@ -78,7 +78,7 @@ impl<'tcx> LateLintPass<'tcx> for MatchOnVecItems {
 
 fn is_vec_indexing<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> Option<&'tcx Expr<'tcx>> {
     if_chain! {
-        if let ExprKind::Index(ref array, ref index) = expr.kind;
+        if let ExprKind::Index(array, index) = expr.kind;
         if is_vector(cx, array);
         if !is_full_range(cx, index);
 
diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index c68ae00be01..a892e24482b 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -589,7 +589,7 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
             lint_match_arms(cx, expr);
         }
 
-        if let ExprKind::Match(ref ex, ref arms, MatchSource::Normal) = expr.kind {
+        if let ExprKind::Match(ex, arms, MatchSource::Normal) = expr.kind {
             check_single_match(cx, ex, arms, expr);
             check_match_bool(cx, ex, arms, expr);
             check_overlapping_arms(cx, ex, arms);
@@ -604,7 +604,7 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
                 check_match_single_binding(cx, ex, arms, expr);
             }
         }
-        if let ExprKind::Match(ref ex, ref arms, _) = expr.kind {
+        if let ExprKind::Match(ex, arms, _) = expr.kind {
             check_match_ref_pats(cx, ex, arms, expr);
         }
     }
@@ -613,14 +613,14 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
         if_chain! {
             if !in_external_macro(cx.sess(), local.span);
             if !in_macro(local.span);
-            if let Some(ref expr) = local.init;
-            if let ExprKind::Match(ref target, ref arms, MatchSource::Normal) = expr.kind;
+            if let Some(expr) = local.init;
+            if let ExprKind::Match(target, arms, MatchSource::Normal) = expr.kind;
             if arms.len() == 1 && arms[0].guard.is_none();
             if let PatKind::TupleStruct(
-                QPath::Resolved(None, ref variant_name), ref args, _) = arms[0].pat.kind;
+                QPath::Resolved(None, variant_name), args, _) = arms[0].pat.kind;
             if args.len() == 1;
-            if let PatKind::Binding(_, arg, ..) = strip_pat_refs(&args[0]).kind;
-            let body = remove_blocks(&arms[0].body);
+            if let PatKind::Binding(_, arg, ..) = strip_pat_refs(args[0]).kind;
+            let body = remove_blocks(arms[0].body);
             if path_to_local_id(body, arg);
 
             then {
@@ -649,7 +649,7 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
         if_chain! {
             if !in_external_macro(cx.sess(), pat.span);
             if !in_macro(pat.span);
-            if let PatKind::Struct(QPath::Resolved(_, ref path), fields, true) = pat.kind;
+            if let PatKind::Struct(QPath::Resolved(_, path), fields, true) = pat.kind;
             if let Some(def_id) = path.res.opt_def_id();
             let ty = cx.tcx.type_of(def_id);
             if let ty::Adt(def, _) = ty.kind();
@@ -761,7 +761,7 @@ fn report_single_match_single_pattern(
                 // PartialEq for different reference counts may not exist.
                 "&".repeat(ref_count_diff),
                 snippet(cx, arms[0].pat.span, ".."),
-                expr_block(cx, &arms[0].body, None, "..", Some(expr.span)),
+                expr_block(cx, arms[0].body, None, "..", Some(expr.span)),
                 els_str,
             );
             (msg, sugg)
@@ -771,7 +771,7 @@ fn report_single_match_single_pattern(
                 "if let {} = {} {}{}",
                 snippet(cx, arms[0].pat.span, ".."),
                 snippet(cx, ex.span, ".."),
-                expr_block(cx, &arms[0].body, None, "..", Some(expr.span)),
+                expr_block(cx, arms[0].body, None, "..", Some(expr.span)),
                 els_str,
             );
             (msg, sugg)
@@ -809,7 +809,7 @@ fn check_single_match_opt_like(
     ];
 
     let path = match arms[1].pat.kind {
-        PatKind::TupleStruct(ref path, ref inner, _) => {
+        PatKind::TupleStruct(ref path, inner, _) => {
             // Contains any non wildcard patterns (e.g., `Err(err)`)?
             if !inner.iter().all(is_wild) {
                 return;
@@ -841,7 +841,7 @@ fn check_match_bool(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>], expr:
             move |diag| {
                 if arms.len() == 2 {
                     // no guards
-                    let exprs = if let PatKind::Lit(ref arm_bool) = arms[0].pat.kind {
+                    let exprs = if let PatKind::Lit(arm_bool) = arms[0].pat.kind {
                         if let ExprKind::Lit(ref lit) = arm_bool.kind {
                             match lit.node {
                                 LitKind::Bool(true) => Some((&*arms[0].body, &*arms[1].body)),
@@ -917,7 +917,7 @@ fn check_wild_err_arm<'tcx>(cx: &LateContext<'tcx>, ex: &Expr<'tcx>, arms: &[Arm
     let ex_ty = cx.typeck_results().expr_ty(ex).peel_refs();
     if is_type_diagnostic_item(cx, ex_ty, sym::result_type) {
         for arm in arms {
-            if let PatKind::TupleStruct(ref path, ref inner, _) = arm.pat.kind {
+            if let PatKind::TupleStruct(ref path, inner, _) = arm.pat.kind {
                 let path_str = rustc_hir_pretty::to_string(rustc_hir_pretty::NO_ANN, |s| s.print_qpath(path, false));
                 if path_str == "Err" {
                     let mut matching_wild = inner.iter().any(is_wild);
@@ -937,7 +937,7 @@ fn check_wild_err_arm<'tcx>(cx: &LateContext<'tcx>, ex: &Expr<'tcx>, arms: &[Arm
                     }
                     if_chain! {
                         if matching_wild;
-                        if let ExprKind::Block(ref block, _) = arm.body.kind;
+                        if let ExprKind::Block(block, _) = arm.body.kind;
                         if is_panic_block(block);
                         then {
                             // `Err(_)` or `Err(_e)` arm with `panic!` found
@@ -1143,9 +1143,7 @@ fn check_wild_enum_match(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>])
 // If the block contains only a `panic!` macro (as expression or statement)
 fn is_panic_block(block: &Block<'_>) -> bool {
     match (&block.expr, block.stmts.len(), block.stmts.first()) {
-        (&Some(ref exp), 0, _) => {
-            is_expn_of(exp.span, "panic").is_some() && is_expn_of(exp.span, "unreachable").is_none()
-        },
+        (&Some(exp), 0, _) => is_expn_of(exp.span, "panic").is_some() && is_expn_of(exp.span, "unreachable").is_none(),
         (&None, 1, Some(stmt)) => {
             is_expn_of(stmt.span, "panic").is_some() && is_expn_of(stmt.span, "unreachable").is_none()
         },
@@ -1156,7 +1154,7 @@ fn is_panic_block(block: &Block<'_>) -> bool {
 fn check_match_ref_pats(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>], expr: &Expr<'_>) {
     if has_only_ref_pats(arms) {
         let mut suggs = Vec::with_capacity(arms.len() + 1);
-        let (title, msg) = if let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Not, ref inner) = ex.kind {
+        let (title, msg) = if let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Not, inner) = ex.kind {
             let span = ex.span.source_callsite();
             suggs.push((span, Sugg::hir_with_macro_callsite(cx, inner, "..").to_string()));
             (
@@ -1173,7 +1171,7 @@ fn check_match_ref_pats(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>], e
         };
 
         suggs.extend(arms.iter().filter_map(|a| {
-            if let PatKind::Ref(ref refp, _) = a.pat.kind {
+            if let PatKind::Ref(refp, _) = a.pat.kind {
                 Some((a.pat.span, snippet(cx, refp.span, "..").to_string()))
             } else {
                 None
@@ -1242,7 +1240,7 @@ fn check_match_as_ref(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>], exp
 
 fn check_wild_in_or_pats(cx: &LateContext<'_>, arms: &[Arm<'_>]) {
     for arm in arms {
-        if let PatKind::Or(ref fields) = arm.pat.kind {
+        if let PatKind::Or(fields) = arm.pat.kind {
             // look for multiple fields in this arm that contains at least one Wild pattern
             if fields.len() > 1 && fields.iter().any(is_wild) {
                 span_lint_and_help(
@@ -1308,7 +1306,7 @@ fn find_matches_sugg(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>], expr
             // strip potential borrows (#6503), but only if the type is a reference
             let mut ex_new = ex;
             if let ExprKind::AddrOf(BorrowKind::Ref, .., ex_inner) = ex.kind {
-                if let ty::Ref(..) = cx.typeck_results().expr_ty(&ex_inner).kind() {
+                if let ty::Ref(..) = cx.typeck_results().expr_ty(ex_inner).kind() {
                     ex_new = ex_inner;
                 }
             };
@@ -1385,7 +1383,7 @@ fn check_match_single_binding<'a>(cx: &LateContext<'a>, ex: &Expr<'a>, arms: &[A
 
     let matched_vars = ex.span;
     let bind_names = arms[0].pat.span;
-    let match_body = remove_blocks(&arms[0].body);
+    let match_body = remove_blocks(arms[0].body);
     let mut snippet_body = if match_body.span.from_expansion() {
         Sugg::hir_with_macro_callsite(cx, match_body, "..").to_string()
     } else {
@@ -1396,13 +1394,13 @@ fn check_match_single_binding<'a>(cx: &LateContext<'a>, ex: &Expr<'a>, arms: &[A
     match match_body.kind {
         ExprKind::Block(block, _) => {
             // macro + expr_ty(body) == ()
-            if block.span.from_expansion() && cx.typeck_results().expr_ty(&match_body).is_unit() {
+            if block.span.from_expansion() && cx.typeck_results().expr_ty(match_body).is_unit() {
                 snippet_body.push(';');
             }
         },
         _ => {
             // expr_ty(body) == ()
-            if cx.typeck_results().expr_ty(&match_body).is_unit() {
+            if cx.typeck_results().expr_ty(match_body).is_unit() {
                 snippet_body.push(';');
             }
         },
@@ -1502,10 +1500,7 @@ fn opt_parent_let<'a>(cx: &LateContext<'a>, ex: &Expr<'a>) -> Option<&'a Local<'
 fn all_ranges<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>], ty: Ty<'tcx>) -> Vec<SpannedRange<Constant>> {
     arms.iter()
         .flat_map(|arm| {
-            if let Arm {
-                ref pat, guard: None, ..
-            } = *arm
-            {
+            if let Arm { pat, guard: None, .. } = *arm {
                 if let PatKind::Range(ref lhs, ref rhs, range_end) = pat.kind {
                     let lhs = match lhs {
                         Some(lhs) => constant(cx, cx.typeck_results(), lhs)?.0,
@@ -1525,7 +1520,7 @@ fn all_ranges<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>], ty: Ty<'tcx>)
                     });
                 }
 
-                if let PatKind::Lit(ref value) = pat.kind {
+                if let PatKind::Lit(value) = pat.kind {
                     let value = constant(cx, cx.typeck_results(), value)?.0;
                     return Some(SpannedRange {
                         span: pat.span,
@@ -1572,8 +1567,8 @@ fn type_ranges(ranges: &[SpannedRange<Constant>]) -> TypedRanges {
 
 fn is_unit_expr(expr: &Expr<'_>) -> bool {
     match expr.kind {
-        ExprKind::Tup(ref v) if v.is_empty() => true,
-        ExprKind::Block(ref b, _) if b.stmts.is_empty() && b.expr.is_none() => true,
+        ExprKind::Tup(v) if v.is_empty() => true,
+        ExprKind::Block(b, _) if b.stmts.is_empty() && b.expr.is_none() => true,
         _ => false,
     }
 }
@@ -1586,14 +1581,14 @@ fn is_none_arm(arm: &Arm<'_>) -> bool {
 // Checks if arm has the form `Some(ref v) => Some(v)` (checks for `ref` and `ref mut`)
 fn is_ref_some_arm(arm: &Arm<'_>) -> Option<BindingAnnotation> {
     if_chain! {
-        if let PatKind::TupleStruct(ref path, ref pats, _) = arm.pat.kind;
+        if let PatKind::TupleStruct(ref path, pats, _) = arm.pat.kind;
         if pats.len() == 1 && match_qpath(path, &paths::OPTION_SOME);
         if let PatKind::Binding(rb, .., ident, _) = pats[0].kind;
         if rb == BindingAnnotation::Ref || rb == BindingAnnotation::RefMut;
-        if let ExprKind::Call(ref e, ref args) = remove_blocks(&arm.body).kind;
+        if let ExprKind::Call(e, args) = remove_blocks(arm.body).kind;
         if let ExprKind::Path(ref some_path) = e.kind;
         if match_qpath(some_path, &paths::OPTION_SOME) && args.len() == 1;
-        if let ExprKind::Path(QPath::Resolved(_, ref path2)) = args[0].kind;
+        if let ExprKind::Path(QPath::Resolved(_, path2)) = args[0].kind;
         if path2.segments.len() == 1 && ident.name == path2.segments[0].ident.name;
         then {
             return Some(rb)
@@ -1685,7 +1680,7 @@ where
             (&Kind::End(a, _), &Kind::Start(b, _)) if a != Bound::Included(b) => (),
             _ => {
                 // skip if the range `a` is completely included into the range `b`
-                if let Ordering::Equal | Ordering::Less = a.cmp(&b) {
+                if let Ordering::Equal | Ordering::Less = a.cmp(b) {
                     let kind_a = Kind::End(a.range().node.1, a.range());
                     let kind_b = Kind::End(b.range().node.1, b.range());
                     if let Ordering::Equal | Ordering::Greater = kind_a.cmp(&kind_b) {
@@ -1737,7 +1732,7 @@ mod redundant_pattern_match {
             kind = &inner.kind;
         }
         let good_method = match kind {
-            PatKind::TupleStruct(ref path, ref patterns, _) if patterns.len() == 1 => {
+            PatKind::TupleStruct(ref path, patterns, _) if patterns.len() == 1 => {
                 if let PatKind::Wild = patterns[0].kind {
                     if match_qpath(path, &paths::RESULT_OK) {
                         "is_ok()"
@@ -1818,8 +1813,8 @@ mod redundant_pattern_match {
 
             let found_good_method = match node_pair {
                 (
-                    PatKind::TupleStruct(ref path_left, ref patterns_left, _),
-                    PatKind::TupleStruct(ref path_right, ref patterns_right, _),
+                    PatKind::TupleStruct(ref path_left, patterns_left, _),
+                    PatKind::TupleStruct(ref path_right, patterns_right, _),
                 ) if patterns_left.len() == 1 && patterns_right.len() == 1 => {
                     if let (PatKind::Wild, PatKind::Wild) = (&patterns_left[0].kind, &patterns_right[0].kind) {
                         find_good_method_for_match(
@@ -1846,8 +1841,8 @@ mod redundant_pattern_match {
                         None
                     }
                 },
-                (PatKind::TupleStruct(ref path_left, ref patterns, _), PatKind::Path(ref path_right))
-                | (PatKind::Path(ref path_left), PatKind::TupleStruct(ref path_right, ref patterns, _))
+                (PatKind::TupleStruct(ref path_left, patterns, _), PatKind::Path(ref path_right))
+                | (PatKind::Path(ref path_left), PatKind::TupleStruct(ref path_right, patterns, _))
                     if patterns.len() == 1 =>
                 {
                     if let PatKind::Wild = patterns[0].kind {
@@ -1969,10 +1964,10 @@ fn test_overlapping() {
 
 /// Implementation of `MATCH_SAME_ARMS`.
 fn lint_match_arms<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>) {
-    if let ExprKind::Match(_, ref arms, MatchSource::Normal) = expr.kind {
+    if let ExprKind::Match(_, arms, MatchSource::Normal) = expr.kind {
         let hash = |&(_, arm): &(usize, &Arm<'_>)| -> u64 {
             let mut h = SpanlessHash::new(cx);
-            h.hash_expr(&arm.body);
+            h.hash_expr(arm.body);
             h.finish()
         };
 
@@ -2008,7 +2003,7 @@ fn lint_match_arms<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>) {
             (min_index..=max_index).all(|index| arms[index].guard.is_none())
                 && SpanlessEq::new(cx)
                     .expr_fallback(eq_fallback)
-                    .eq_expr(&lhs.body, &rhs.body)
+                    .eq_expr(lhs.body, rhs.body)
                 // these checks could be removed to allow unused bindings
                 && bindings_eq(lhs.pat, local_map.keys().copied().collect())
                 && bindings_eq(rhs.pat, local_map.values().copied().collect())
diff --git a/clippy_lints/src/mem_discriminant.rs b/clippy_lints/src/mem_discriminant.rs
index 7895ba9f1e0..a735c616f6e 100644
--- a/clippy_lints/src/mem_discriminant.rs
+++ b/clippy_lints/src/mem_discriminant.rs
@@ -34,7 +34,7 @@ declare_lint_pass!(MemDiscriminant => [MEM_DISCRIMINANT_NON_ENUM]);
 impl<'tcx> LateLintPass<'tcx> for MemDiscriminant {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if_chain! {
-            if let ExprKind::Call(ref func, ref func_args) = expr.kind;
+            if let ExprKind::Call(func, func_args) = expr.kind;
             // is `mem::discriminant`
             if let ExprKind::Path(ref func_qpath) = func.kind;
             if let Some(def_id) = cx.qpath_res(func_qpath, func.hir_id).opt_def_id();
@@ -59,7 +59,7 @@ impl<'tcx> LateLintPass<'tcx> for MemDiscriminant {
                             let mut derefs_needed = ptr_depth;
                             let mut cur_expr = param;
                             while derefs_needed > 0  {
-                                if let ExprKind::AddrOf(BorrowKind::Ref, _, ref inner_expr) = cur_expr.kind {
+                                if let ExprKind::AddrOf(BorrowKind::Ref, _, inner_expr) = cur_expr.kind {
                                     derefs_needed -= 1;
                                     cur_expr = inner_expr;
                                 } else {
diff --git a/clippy_lints/src/mem_forget.rs b/clippy_lints/src/mem_forget.rs
index c13802e3953..a28cb5f32fe 100644
--- a/clippy_lints/src/mem_forget.rs
+++ b/clippy_lints/src/mem_forget.rs
@@ -28,7 +28,7 @@ declare_lint_pass!(MemForget => [MEM_FORGET]);
 
 impl<'tcx> LateLintPass<'tcx> for MemForget {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
-        if let ExprKind::Call(ref path_expr, ref args) = e.kind {
+        if let ExprKind::Call(path_expr, args) = e.kind {
             if let ExprKind::Path(ref qpath) = path_expr.kind {
                 if let Some(def_id) = cx.qpath_res(qpath, path_expr.hir_id).opt_def_id() {
                     if match_def_path(cx, def_id, &paths::MEM_FORGET) {
diff --git a/clippy_lints/src/mem_replace.rs b/clippy_lints/src/mem_replace.rs
index 0418c616efa..e1d351aee45 100644
--- a/clippy_lints/src/mem_replace.rs
+++ b/clippy_lints/src/mem_replace.rs
@@ -109,14 +109,14 @@ fn check_replace_option_with_none(cx: &LateContext<'_>, src: &Expr<'_>, dest: &E
             // argument's type. All that's left is to get
             // replacee's path.
             let replaced_path = match dest.kind {
-                ExprKind::AddrOf(BorrowKind::Ref, Mutability::Mut, ref replaced) => {
-                    if let ExprKind::Path(QPath::Resolved(None, ref replaced_path)) = replaced.kind {
+                ExprKind::AddrOf(BorrowKind::Ref, Mutability::Mut, replaced) => {
+                    if let ExprKind::Path(QPath::Resolved(None, replaced_path)) = replaced.kind {
                         replaced_path
                     } else {
                         return;
                     }
                 },
-                ExprKind::Path(QPath::Resolved(None, ref replaced_path)) => replaced_path,
+                ExprKind::Path(QPath::Resolved(None, replaced_path)) => replaced_path,
                 _ => return,
             };
 
@@ -161,7 +161,7 @@ fn check_replace_with_uninit(cx: &LateContext<'_>, src: &Expr<'_>, dest: &Expr<'
     }
 
     if_chain! {
-        if let ExprKind::Call(ref repl_func, ref repl_args) = src.kind;
+        if let ExprKind::Call(repl_func, repl_args) = src.kind;
         if repl_args.is_empty();
         if let ExprKind::Path(ref repl_func_qpath) = repl_func.kind;
         if let Some(repl_def_id) = cx.qpath_res(repl_func_qpath, repl_func.hir_id).opt_def_id();
@@ -214,7 +214,7 @@ fn is_default_equivalent_ctor(cx: &LateContext<'_>, def_id: DefId, path: &QPath<
         .iter()
         .any(|symbol| is_diagnostic_assoc_item(cx, def_id, *symbol))
     {
-        if let QPath::TypeRelative(_, ref method) = path {
+        if let QPath::TypeRelative(_, method) = path {
             if method.ident.name == sym::new {
                 return true;
             }
@@ -226,7 +226,7 @@ fn is_default_equivalent_ctor(cx: &LateContext<'_>, def_id: DefId, path: &QPath<
 
 fn check_replace_with_default(cx: &LateContext<'_>, src: &Expr<'_>, dest: &Expr<'_>, expr_span: Span) {
     if_chain! {
-        if let ExprKind::Call(ref repl_func, _) = src.kind;
+        if let ExprKind::Call(repl_func, _) = src.kind;
         if !in_external_macro(cx.tcx.sess, expr_span);
         if let ExprKind::Path(ref repl_func_qpath) = repl_func.kind;
         if let Some(repl_def_id) = cx.qpath_res(repl_func_qpath, repl_func.hir_id).opt_def_id();
@@ -273,11 +273,11 @@ impl<'tcx> LateLintPass<'tcx> for MemReplace {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if_chain! {
             // Check that `expr` is a call to `mem::replace()`
-            if let ExprKind::Call(ref func, ref func_args) = expr.kind;
+            if let ExprKind::Call(func, func_args) = expr.kind;
             if let ExprKind::Path(ref func_qpath) = func.kind;
             if let Some(def_id) = cx.qpath_res(func_qpath, func.hir_id).opt_def_id();
             if match_def_path(cx, def_id, &paths::MEM_REPLACE);
-            if let [dest, src] = &**func_args;
+            if let [dest, src] = func_args;
             then {
                 check_replace_option_with_none(cx, src, dest, expr.span);
                 check_replace_with_uninit(cx, src, dest, expr.span);
diff --git a/clippy_lints/src/methods/bind_instead_of_map.rs b/clippy_lints/src/methods/bind_instead_of_map.rs
index 46d4c674648..287bff886bf 100644
--- a/clippy_lints/src/methods/bind_instead_of_map.rs
+++ b/clippy_lints/src/methods/bind_instead_of_map.rs
@@ -71,7 +71,7 @@ pub(crate) trait BindInsteadOfMap {
         closure_args_span: Span,
     ) -> bool {
         if_chain! {
-            if let hir::ExprKind::Call(ref some_expr, [inner_expr]) = closure_expr.kind;
+            if let hir::ExprKind::Call(some_expr, [inner_expr]) = closure_expr.kind;
             if let hir::ExprKind::Path(QPath::Resolved(_, path)) = some_expr.kind;
             if Self::is_variant(cx, path.res);
             if !contains_return(inner_expr);
@@ -107,7 +107,7 @@ pub(crate) trait BindInsteadOfMap {
         let can_sugg: bool = find_all_ret_expressions(cx, closure_expr, |ret_expr| {
             if_chain! {
                 if !in_macro(ret_expr.span);
-                if let hir::ExprKind::Call(ref func_path, [arg]) = ret_expr.kind;
+                if let hir::ExprKind::Call(func_path, [arg]) = ret_expr.kind;
                 if let hir::ExprKind::Path(QPath::Resolved(_, path)) = func_path.kind;
                 if Self::is_variant(cx, path.res);
                 if !contains_return(arg);
diff --git a/clippy_lints/src/methods/chars_cmp.rs b/clippy_lints/src/methods/chars_cmp.rs
index c668fe52781..514c4118765 100644
--- a/clippy_lints/src/methods/chars_cmp.rs
+++ b/clippy_lints/src/methods/chars_cmp.rs
@@ -19,7 +19,7 @@ pub(super) fn check(
 ) -> bool {
     if_chain! {
         if let Some(args) = method_chain_args(info.chain, chain_methods);
-        if let hir::ExprKind::Call(ref fun, ref arg_char) = info.other.kind;
+        if let hir::ExprKind::Call(fun, arg_char) = info.other.kind;
         if arg_char.len() == 1;
         if let hir::ExprKind::Path(ref qpath) = fun.kind;
         if let Some(segment) = single_segment_path(qpath);
diff --git a/clippy_lints/src/methods/expect_fun_call.rs b/clippy_lints/src/methods/expect_fun_call.rs
index e7bffa66b3f..03cb41697d5 100644
--- a/clippy_lints/src/methods/expect_fun_call.rs
+++ b/clippy_lints/src/methods/expect_fun_call.rs
@@ -100,9 +100,9 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, method_span: Spa
         applicability: &mut Applicability,
     ) -> Vec<String> {
         if_chain! {
-            if let hir::ExprKind::AddrOf(hir::BorrowKind::Ref, _, ref format_arg) = a.kind;
-            if let hir::ExprKind::Match(ref format_arg_expr, _, _) = format_arg.kind;
-            if let hir::ExprKind::Tup(ref format_arg_expr_tup) = format_arg_expr.kind;
+            if let hir::ExprKind::AddrOf(hir::BorrowKind::Ref, _, format_arg) = a.kind;
+            if let hir::ExprKind::Match(format_arg_expr, _, _) = format_arg.kind;
+            if let hir::ExprKind::Tup(format_arg_expr_tup) = format_arg_expr.kind;
 
             then {
                 format_arg_expr_tup
@@ -155,7 +155,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, method_span: Spa
         if block.stmts.len() == 1;
         if let hir::StmtKind::Local(local) = &block.stmts[0].kind;
         if let Some(arg_root) = &local.init;
-        if let hir::ExprKind::Call(ref inner_fun, ref inner_args) = arg_root.kind;
+        if let hir::ExprKind::Call(inner_fun, inner_args) = arg_root.kind;
         if is_expn_of(inner_fun.span, "format").is_some() && inner_args.len() == 1;
         if let hir::ExprKind::Call(_, format_args) = &inner_args[0].kind;
         then {
diff --git a/clippy_lints/src/methods/filter_map.rs b/clippy_lints/src/methods/filter_map.rs
index 45d1ed953b4..35fae450eeb 100644
--- a/clippy_lints/src/methods/filter_map.rs
+++ b/clippy_lints/src/methods/filter_map.rs
@@ -19,7 +19,7 @@ use super::OPTION_FILTER_MAP;
 
 fn is_method<'tcx>(cx: &LateContext<'tcx>, expr: &hir::Expr<'_>, method_name: Symbol) -> bool {
     match &expr.kind {
-        hir::ExprKind::Path(QPath::TypeRelative(_, ref mname)) => mname.ident.name == method_name,
+        hir::ExprKind::Path(QPath::TypeRelative(_, mname)) => mname.ident.name == method_name,
         hir::ExprKind::Path(QPath::Resolved(_, segments)) => {
             segments.segments.last().unwrap().ident.name == method_name
         },
@@ -28,7 +28,7 @@ fn is_method<'tcx>(cx: &LateContext<'tcx>, expr: &hir::Expr<'_>, method_name: Sy
             let closure_expr = remove_blocks(&body.value);
             let arg_id = body.params[0].pat.hir_id;
             match closure_expr.kind {
-                hir::ExprKind::MethodCall(hir::PathSegment { ident, .. }, _, ref args, _) => {
+                hir::ExprKind::MethodCall(hir::PathSegment { ident, .. }, _, args, _) => {
                     if_chain! {
                     if ident.name == method_name;
                     if let hir::ExprKind::Path(path) = &args[0].kind;
@@ -61,7 +61,7 @@ fn lint_filter_some_map_unwrap(
     methods_span: Span,
 ) {
     let iterator = is_trait_method(cx, expr, sym::Iterator);
-    let option = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&filter_recv), sym::option_type);
+    let option = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(filter_recv), sym::option_type);
     if (iterator || option) && is_option_filter_map(cx, filter_arg, map_arg) {
         let msg = "`filter` for `Some` followed by `unwrap`";
         let help = "consider using `flatten` instead";
diff --git a/clippy_lints/src/methods/flat_map_identity.rs b/clippy_lints/src/methods/flat_map_identity.rs
index 664885a2f0e..dd613d0cd63 100644
--- a/clippy_lints/src/methods/flat_map_identity.rs
+++ b/clippy_lints/src/methods/flat_map_identity.rs
@@ -35,7 +35,7 @@ pub(super) fn check<'tcx>(
             let body = cx.tcx.hir().body(*body_id);
 
             if let hir::PatKind::Binding(_, _, binding_ident, _) = body.params[0].pat.kind;
-            if let hir::ExprKind::Path(hir::QPath::Resolved(_, ref path)) = body.value.kind;
+            if let hir::ExprKind::Path(hir::QPath::Resolved(_, path)) = body.value.kind;
 
             if path.segments.len() == 1;
             if path.segments[0].ident.name == binding_ident.name;
diff --git a/clippy_lints/src/methods/implicit_clone.rs b/clippy_lints/src/methods/implicit_clone.rs
index 04461ad5c3a..1211e2f2bf7 100644
--- a/clippy_lints/src/methods/implicit_clone.rs
+++ b/clippy_lints/src/methods/implicit_clone.rs
@@ -13,7 +13,7 @@ use clippy_utils::is_diagnostic_assoc_item;
 pub fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, trait_diagnostic: Symbol) {
     if_chain! {
         if let ExprKind::MethodCall(method_path, _, [arg], _) = &expr.kind;
-        let return_type = cx.typeck_results().expr_ty(&expr);
+        let return_type = cx.typeck_results().expr_ty(expr);
         let input_type = cx.typeck_results().expr_ty(arg).peel_refs();
         if let Some(expr_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
         if let Some(ty_name) = input_type.ty_adt_def().map(|adt_def| cx.tcx.item_name(adt_def.did));
diff --git a/clippy_lints/src/methods/iter_next_slice.rs b/clippy_lints/src/methods/iter_next_slice.rs
index dab0a43a096..a49851de38e 100644
--- a/clippy_lints/src/methods/iter_next_slice.rs
+++ b/clippy_lints/src/methods/iter_next_slice.rs
@@ -27,7 +27,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, cal
     if derefs_to_slice(cx, caller_expr, cx.typeck_results().expr_ty(caller_expr)).is_some() {
         // caller is a Slice
         if_chain! {
-            if let hir::ExprKind::Index(ref caller_var, ref index_expr) = &caller_expr.kind;
+            if let hir::ExprKind::Index(caller_var, index_expr) = &caller_expr.kind;
             if let Some(higher::Range { start: Some(start_expr), end: None, limits: ast::RangeLimits::HalfOpen })
                 = higher::range(index_expr);
             if let hir::ExprKind::Lit(ref start_lit) = &start_expr.kind;
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index fa6323b56e1..b1ade5addd6 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1740,10 +1740,10 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
         check_methods(cx, expr, self.msrv.as_ref());
 
         match expr.kind {
-            hir::ExprKind::Call(ref func, ref args) => {
+            hir::ExprKind::Call(func, args) => {
                 from_iter_instead_of_collect::check(cx, expr, args, &func.kind);
             },
-            hir::ExprKind::MethodCall(ref method_call, ref method_span, ref args, _) => {
+            hir::ExprKind::MethodCall(method_call, ref method_span, args, _) => {
                 or_fun_call::check(cx, expr, *method_span, &method_call.ident.as_str(), args);
                 expect_fun_call::check(cx, expr, *method_span, &method_call.ident.as_str(), args);
                 clone_on_copy::check(cx, expr, method_call.ident.name, args);
@@ -1753,9 +1753,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
                 into_iter_on_ref::check(cx, expr, *method_span, method_call.ident.name, args);
                 single_char_pattern::check(cx, expr, method_call.ident.name, args);
             },
-            hir::ExprKind::Binary(op, ref lhs, ref rhs)
-                if op.node == hir::BinOpKind::Eq || op.node == hir::BinOpKind::Ne =>
-            {
+            hir::ExprKind::Binary(op, lhs, rhs) if op.node == hir::BinOpKind::Eq || op.node == hir::BinOpKind::Ne => {
                 let mut info = BinaryExprInfo {
                     expr,
                     chain: lhs,
@@ -1763,7 +1761,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
                     eq: op.node == hir::BinOpKind::Eq,
                 };
                 lint_binary_expr_with_method_call(cx, &mut info);
-            }
+            },
             _ => (),
         }
     }
@@ -1781,7 +1779,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
         let implements_trait = matches!(item.kind, hir::ItemKind::Impl(hir::Impl { of_trait: Some(_), .. }));
         if_chain! {
             if let hir::ImplItemKind::Fn(ref sig, id) = impl_item.kind;
-            if let Some(first_arg) = iter_input_pats(&sig.decl, cx.tcx.hir().body(id)).next();
+            if let Some(first_arg) = iter_input_pats(sig.decl, cx.tcx.hir().body(id)).next();
 
             let method_sig = cx.tcx.fn_sig(impl_item.def_id);
             let method_sig = cx.tcx.erase_late_bound_regions(method_sig);
@@ -1801,7 +1799,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
                             method_config.output_type.matches(&sig.decl.output) &&
                             method_config.self_kind.matches(cx, self_ty, first_arg_ty) &&
                             fn_header_equals(method_config.fn_header, sig.header) &&
-                            method_config.lifetime_param_cond(&impl_item)
+                            method_config.lifetime_param_cond(impl_item)
                         {
                             span_lint_and_help(
                                 cx,
@@ -2272,10 +2270,10 @@ impl OutType {
         let is_unit = |ty: &hir::Ty<'_>| matches!(ty.kind, hir::TyKind::Tup(&[]));
         match (self, ty) {
             (Self::Unit, &hir::FnRetTy::DefaultReturn(_)) => true,
-            (Self::Unit, &hir::FnRetTy::Return(ref ty)) if is_unit(ty) => true,
-            (Self::Bool, &hir::FnRetTy::Return(ref ty)) if is_bool(ty) => true,
-            (Self::Any, &hir::FnRetTy::Return(ref ty)) if !is_unit(ty) => true,
-            (Self::Ref, &hir::FnRetTy::Return(ref ty)) => matches!(ty.kind, hir::TyKind::Rptr(_, _)),
+            (Self::Unit, &hir::FnRetTy::Return(ty)) if is_unit(ty) => true,
+            (Self::Bool, &hir::FnRetTy::Return(ty)) if is_bool(ty) => true,
+            (Self::Any, &hir::FnRetTy::Return(ty)) if !is_unit(ty) => true,
+            (Self::Ref, &hir::FnRetTy::Return(ty)) => matches!(ty.kind, hir::TyKind::Rptr(_, _)),
             _ => false,
         }
     }
diff --git a/clippy_lints/src/methods/option_as_ref_deref.rs b/clippy_lints/src/methods/option_as_ref_deref.rs
index 1367a0c21d8..7e9c8fa829d 100644
--- a/clippy_lints/src/methods/option_as_ref_deref.rs
+++ b/clippy_lints/src/methods/option_as_ref_deref.rs
@@ -77,10 +77,10 @@ pub(super) fn check<'tcx>(
                         }
                     }
                 },
-                hir::ExprKind::AddrOf(hir::BorrowKind::Ref, m, ref inner) if same_mutability(m) => {
+                hir::ExprKind::AddrOf(hir::BorrowKind::Ref, m, inner) if same_mutability(m) => {
                     if_chain! {
-                        if let hir::ExprKind::Unary(hir::UnOp::Deref, ref inner1) = inner.kind;
-                        if let hir::ExprKind::Unary(hir::UnOp::Deref, ref inner2) = inner1.kind;
+                        if let hir::ExprKind::Unary(hir::UnOp::Deref, inner1) = inner.kind;
+                        if let hir::ExprKind::Unary(hir::UnOp::Deref, inner2) = inner1.kind;
                         then {
                             path_to_local_id(inner2, closure_body.params[0].pat.hir_id)
                         } else {
diff --git a/clippy_lints/src/methods/or_fun_call.rs b/clippy_lints/src/methods/or_fun_call.rs
index 89dedc5f0d8..df89da5d3e0 100644
--- a/clippy_lints/src/methods/or_fun_call.rs
+++ b/clippy_lints/src/methods/or_fun_call.rs
@@ -86,7 +86,7 @@ pub(super) fn check<'tcx>(
             (&paths::RESULT, true, &["or", "unwrap_or"], "else"),
         ];
 
-        if let hir::ExprKind::MethodCall(ref path, _, ref args, _) = &arg.kind {
+        if let hir::ExprKind::MethodCall(path, _, args, _) = &arg.kind {
             if path.ident.as_str() == "len" {
                 let ty = cx.typeck_results().expr_ty(&args[0]).peel_refs();
 
@@ -105,7 +105,7 @@ pub(super) fn check<'tcx>(
             if KNOW_TYPES.iter().any(|k| k.2.contains(&name));
 
             if is_lazyness_candidate(cx, arg);
-            if !contains_return(&arg);
+            if !contains_return(arg);
 
             let self_ty = cx.typeck_results().expr_ty(self_expr);
 
@@ -158,7 +158,7 @@ pub(super) fn check<'tcx>(
 
     if args.len() == 2 {
         match args[1].kind {
-            hir::ExprKind::Call(ref fun, ref or_args) => {
+            hir::ExprKind::Call(fun, or_args) => {
                 let or_has_args = !or_args.is_empty();
                 if !check_unwrap_or_default(cx, name, fun, &args[0], &args[1], or_has_args, expr.span) {
                     let fun_span = if or_has_args { None } else { Some(fun.span) };
diff --git a/clippy_lints/src/methods/search_is_some.rs b/clippy_lints/src/methods/search_is_some.rs
index 8a94d7f4155..ecec6fc3bb7 100644
--- a/clippy_lints/src/methods/search_is_some.rs
+++ b/clippy_lints/src/methods/search_is_some.rs
@@ -45,7 +45,7 @@ pub(super) fn check<'tcx>(
                 then {
                     if let hir::PatKind::Ref(..) = closure_arg.pat.kind {
                         Some(search_snippet.replacen('&', "", 1))
-                    } else if let PatKind::Binding(_, _, ident, _) = strip_pat_refs(&closure_arg.pat).kind {
+                    } else if let PatKind::Binding(_, _, ident, _) = strip_pat_refs(closure_arg.pat).kind {
                         let name = &*ident.name.as_str();
                         Some(search_snippet.replace(&format!("*{}", name), name))
                     } else {
@@ -108,8 +108,8 @@ pub(super) fn check<'tcx>(
             }
         };
         if_chain! {
-            if is_string_or_str_slice(&search_recv);
-            if is_string_or_str_slice(&search_arg);
+            if is_string_or_str_slice(search_recv);
+            if is_string_or_str_slice(search_arg);
             then {
                 let msg = format!("called `{}()` after calling `find()` on a string", option_check_method);
                 match option_check_method {
diff --git a/clippy_lints/src/methods/uninit_assumed_init.rs b/clippy_lints/src/methods/uninit_assumed_init.rs
index 3cc1912b15a..0ae65c0c01d 100644
--- a/clippy_lints/src/methods/uninit_assumed_init.rs
+++ b/clippy_lints/src/methods/uninit_assumed_init.rs
@@ -10,7 +10,7 @@ use super::UNINIT_ASSUMED_INIT;
 /// lint for `MaybeUninit::uninit().assume_init()` (we already have the latter)
 pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr<'_>) {
     if_chain! {
-        if let hir::ExprKind::Call(ref callee, ref args) = recv.kind;
+        if let hir::ExprKind::Call(callee, args) = recv.kind;
         if args.is_empty();
         if let hir::ExprKind::Path(ref path) = callee.kind;
         if match_qpath(path, &paths::MEM_MAYBEUNINIT_UNINIT);
@@ -28,9 +28,9 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr
 
 fn is_maybe_uninit_ty_valid(cx: &LateContext<'_>, ty: Ty<'_>) -> bool {
     match ty.kind() {
-        ty::Array(ref component, _) => is_maybe_uninit_ty_valid(cx, component),
-        ty::Tuple(ref types) => types.types().all(|ty| is_maybe_uninit_ty_valid(cx, ty)),
-        ty::Adt(ref adt, _) => match_def_path(cx, adt.did, &paths::MEM_MAYBEUNINIT),
+        ty::Array(component, _) => is_maybe_uninit_ty_valid(cx, component),
+        ty::Tuple(types) => types.types().all(|ty| is_maybe_uninit_ty_valid(cx, ty)),
+        ty::Adt(adt, _) => match_def_path(cx, adt.did, &paths::MEM_MAYBEUNINIT),
         _ => false,
     }
 }
diff --git a/clippy_lints/src/methods/unnecessary_filter_map.rs b/clippy_lints/src/methods/unnecessary_filter_map.rs
index 8e637e12393..0f28bfdf09e 100644
--- a/clippy_lints/src/methods/unnecessary_filter_map.rs
+++ b/clippy_lints/src/methods/unnecessary_filter_map.rs
@@ -20,9 +20,9 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, arg: &hir::Expr<
         let mutates_arg =
             mutated_variables(&body.value, cx).map_or(true, |used_mutably| used_mutably.contains(&arg_id));
 
-        let (mut found_mapping, mut found_filtering) = check_expression(&cx, arg_id, &body.value);
+        let (mut found_mapping, mut found_filtering) = check_expression(cx, arg_id, &body.value);
 
-        let mut return_visitor = ReturnVisitor::new(&cx, arg_id);
+        let mut return_visitor = ReturnVisitor::new(cx, arg_id);
         return_visitor.visit_expr(&body.value);
         found_mapping |= return_visitor.found_mapping;
         found_filtering |= return_visitor.found_filtering;
@@ -52,7 +52,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, arg: &hir::Expr<
 // returns (found_mapping, found_filtering)
 fn check_expression<'tcx>(cx: &LateContext<'tcx>, arg_id: hir::HirId, expr: &'tcx hir::Expr<'_>) -> (bool, bool) {
     match &expr.kind {
-        hir::ExprKind::Call(ref func, ref args) => {
+        hir::ExprKind::Call(func, args) => {
             if let hir::ExprKind::Path(ref path) = func.kind {
                 if match_qpath(path, &paths::OPTION_SOME) {
                     if path_to_local_id(&args[0], arg_id) {
@@ -65,22 +65,22 @@ fn check_expression<'tcx>(cx: &LateContext<'tcx>, arg_id: hir::HirId, expr: &'tc
             }
             (true, true)
         },
-        hir::ExprKind::Block(ref block, _) => block
+        hir::ExprKind::Block(block, _) => block
             .expr
             .as_ref()
-            .map_or((false, false), |expr| check_expression(cx, arg_id, &expr)),
+            .map_or((false, false), |expr| check_expression(cx, arg_id, expr)),
         hir::ExprKind::Match(_, arms, _) => {
             let mut found_mapping = false;
             let mut found_filtering = false;
             for arm in *arms {
-                let (m, f) = check_expression(cx, arg_id, &arm.body);
+                let (m, f) = check_expression(cx, arg_id, arm.body);
                 found_mapping |= m;
                 found_filtering |= f;
             }
             (found_mapping, found_filtering)
         },
         // There must be an else_arm or there will be a type error
-        hir::ExprKind::If(_, ref if_arm, Some(ref else_arm)) => {
+        hir::ExprKind::If(_, if_arm, Some(else_arm)) => {
             let if_check = check_expression(cx, arg_id, if_arm);
             let else_check = check_expression(cx, arg_id, else_arm);
             (if_check.0 | else_check.0, if_check.1 | else_check.1)
diff --git a/clippy_lints/src/methods/unnecessary_fold.rs b/clippy_lints/src/methods/unnecessary_fold.rs
index 7c16470348f..75517c48a21 100644
--- a/clippy_lints/src/methods/unnecessary_fold.rs
+++ b/clippy_lints/src/methods/unnecessary_fold.rs
@@ -34,13 +34,13 @@ pub(super) fn check(
             let closure_expr = remove_blocks(&closure_body.value);
 
             // Check if the closure body is of the form `acc <op> some_expr(x)`
-            if let hir::ExprKind::Binary(ref bin_op, ref left_expr, ref right_expr) = closure_expr.kind;
+            if let hir::ExprKind::Binary(ref bin_op, left_expr, right_expr) = closure_expr.kind;
             if bin_op.node == op;
 
             // Extract the names of the two arguments to the closure
             if let [param_a, param_b] = closure_body.params;
-            if let PatKind::Binding(_, first_arg_id, ..) = strip_pat_refs(&param_a.pat).kind;
-            if let PatKind::Binding(_, second_arg_id, second_arg_ident, _) = strip_pat_refs(&param_b.pat).kind;
+            if let PatKind::Binding(_, first_arg_id, ..) = strip_pat_refs(param_a.pat).kind;
+            if let PatKind::Binding(_, second_arg_id, second_arg_ident, _) = strip_pat_refs(param_b.pat).kind;
 
             if path_to_local_id(left_expr, first_arg_id);
             if replacement_has_args || path_to_local_id(right_expr, second_arg_id);
diff --git a/clippy_lints/src/methods/utils.rs b/clippy_lints/src/methods/utils.rs
index ac6b55396da..f6bf37e08b9 100644
--- a/clippy_lints/src/methods/utils.rs
+++ b/clippy_lints/src/methods/utils.rs
@@ -26,7 +26,7 @@ pub(super) fn derefs_to_slice<'tcx>(
         }
     }
 
-    if let hir::ExprKind::MethodCall(ref path, _, ref args, _) = expr.kind {
+    if let hir::ExprKind::MethodCall(path, _, args, _) = expr.kind {
         if path.ident.name == sym::iter && may_slice(cx, cx.typeck_results().expr_ty(&args[0])) {
             Some(&args[0])
         } else {
diff --git a/clippy_lints/src/methods/zst_offset.rs b/clippy_lints/src/methods/zst_offset.rs
index 0489d0f6fcf..866cf616679 100644
--- a/clippy_lints/src/methods/zst_offset.rs
+++ b/clippy_lints/src/methods/zst_offset.rs
@@ -8,7 +8,7 @@ use super::ZST_OFFSET;
 
 pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr<'_>) {
     if_chain! {
-        if let ty::RawPtr(ty::TypeAndMut { ref ty, .. }) = cx.typeck_results().expr_ty(recv).kind();
+        if let ty::RawPtr(ty::TypeAndMut { ty, .. }) = cx.typeck_results().expr_ty(recv).kind();
         if let Ok(layout) = cx.tcx.layout_of(cx.param_env.and(ty));
         if layout.is_zst();
         then {
diff --git a/clippy_lints/src/minmax.rs b/clippy_lints/src/minmax.rs
index 776f4c7b741..45948f4d926 100644
--- a/clippy_lints/src/minmax.rs
+++ b/clippy_lints/src/minmax.rs
@@ -67,7 +67,7 @@ enum MinMax {
 
 fn min_max<'a>(cx: &LateContext<'_>, expr: &'a Expr<'a>) -> Option<(MinMax, Constant, &'a Expr<'a>)> {
     match expr.kind {
-        ExprKind::Call(ref path, ref args) => {
+        ExprKind::Call(path, args) => {
             if let ExprKind::Path(ref qpath) = path.kind {
                 cx.typeck_results()
                     .qpath_res(qpath, path.hir_id)
@@ -85,7 +85,7 @@ fn min_max<'a>(cx: &LateContext<'_>, expr: &'a Expr<'a>) -> Option<(MinMax, Cons
                 None
             }
         },
-        ExprKind::MethodCall(ref path, _, ref args, _) => {
+        ExprKind::MethodCall(path, _, args, _) => {
             if_chain! {
                 if let [obj, _] = args;
                 if cx.typeck_results().expr_ty(obj).is_floating_point() || match_trait_method(cx, expr, &paths::ORD);
diff --git a/clippy_lints/src/misc.rs b/clippy_lints/src/misc.rs
index c23643cb2f5..afced5a5ce5 100644
--- a/clippy_lints/src/misc.rs
+++ b/clippy_lints/src/misc.rs
@@ -304,9 +304,9 @@ impl<'tcx> LateLintPass<'tcx> for MiscLints {
     fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) {
         if_chain! {
             if !in_external_macro(cx.tcx.sess, stmt.span);
-            if let StmtKind::Local(ref local) = stmt.kind;
+            if let StmtKind::Local(local) = stmt.kind;
             if let PatKind::Binding(an, .., name, None) = local.pat.kind;
-            if let Some(ref init) = local.init;
+            if let Some(init) = local.init;
             if !higher::is_from_for_desugar(local);
             if an == BindingAnnotation::Ref || an == BindingAnnotation::RefMut;
             then {
@@ -322,7 +322,7 @@ impl<'tcx> LateLintPass<'tcx> for MiscLints {
                 } else {
                     ("", sugg_init.addr())
                 };
-                let tyopt = if let Some(ref ty) = local.ty {
+                let tyopt = if let Some(ty) = local.ty {
                     format!(": &{mutopt}{ty}", mutopt=mutopt, ty=snippet(cx, ty.span, ".."))
                 } else {
                     String::new()
@@ -350,8 +350,8 @@ impl<'tcx> LateLintPass<'tcx> for MiscLints {
             }
         };
         if_chain! {
-            if let StmtKind::Semi(ref expr) = stmt.kind;
-            if let ExprKind::Binary(ref binop, ref a, ref b) = expr.kind;
+            if let StmtKind::Semi(expr) = stmt.kind;
+            if let ExprKind::Binary(ref binop, a, b) = expr.kind;
             if binop.node == BinOpKind::And || binop.node == BinOpKind::Or;
             if let Some(sugg) = Sugg::hir_opt(cx, a);
             then {
@@ -378,11 +378,11 @@ impl<'tcx> LateLintPass<'tcx> for MiscLints {
 
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         match expr.kind {
-            ExprKind::Cast(ref e, ref ty) => {
+            ExprKind::Cast(e, ty) => {
                 check_cast(cx, expr.span, e, ty);
                 return;
             },
-            ExprKind::Binary(ref cmp, ref left, ref right) => {
+            ExprKind::Binary(ref cmp, left, right) => {
                 check_binary(cx, expr, cmp, left, right);
                 return;
             },
@@ -501,12 +501,12 @@ fn is_allowed<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> bool {
 // Return true if `expr` is the result of `signum()` invoked on a float value.
 fn is_signum(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
     // The negation of a signum is still a signum
-    if let ExprKind::Unary(UnOp::Neg, ref child_expr) = expr.kind {
-        return is_signum(cx, &child_expr);
+    if let ExprKind::Unary(UnOp::Neg, child_expr) = expr.kind {
+        return is_signum(cx, child_expr);
     }
 
     if_chain! {
-        if let ExprKind::MethodCall(ref method_name, _, ref expressions, _) = expr.kind;
+        if let ExprKind::MethodCall(method_name, _, expressions, _) = expr.kind;
         if sym!(signum) == method_name.ident.name;
         // Check that the receiver of the signum() is a float (expressions[0] is the receiver of
         // the method call)
@@ -552,7 +552,7 @@ fn check_to_owned(cx: &LateContext<'_>, expr: &Expr<'_>, other: &Expr<'_>, left:
     }
 
     let (arg_ty, snip) = match expr.kind {
-        ExprKind::MethodCall(.., ref args, _) if args.len() == 1 => {
+        ExprKind::MethodCall(.., args, _) if args.len() == 1 => {
             if_chain!(
                 if let Some(expr_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
                 if is_diagnostic_assoc_item(cx, expr_def_id, sym::ToString)
@@ -564,7 +564,7 @@ fn check_to_owned(cx: &LateContext<'_>, expr: &Expr<'_>, other: &Expr<'_>, left:
                 }
             )
         },
-        ExprKind::Call(ref path, ref v) if v.len() == 1 => {
+        ExprKind::Call(path, v) if v.len() == 1 => {
             if let ExprKind::Path(ref path) = path.kind {
                 if match_qpath(path, &["String", "from_str"]) || match_qpath(path, &["String", "from"]) {
                     (cx.typeck_results().expr_ty(&v[0]), snippet(cx, v[0].span, ".."))
@@ -649,7 +649,7 @@ fn check_to_owned(cx: &LateContext<'_>, expr: &Expr<'_>, other: &Expr<'_>, left:
 /// of what it means for an expression to be "used".
 fn is_used(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
     get_parent_expr(cx, expr).map_or(true, |parent| match parent.kind {
-        ExprKind::Assign(_, ref rhs, _) | ExprKind::AssignOp(_, _, ref rhs) => SpanlessEq::new(cx).eq_expr(rhs, expr),
+        ExprKind::Assign(_, rhs, _) | ExprKind::AssignOp(_, _, rhs) => SpanlessEq::new(cx).eq_expr(rhs, expr),
         _ => is_used(cx, parent),
     })
 }
diff --git a/clippy_lints/src/missing_const_for_fn.rs b/clippy_lints/src/missing_const_for_fn.rs
index 23554669d97..0dc02431ad5 100644
--- a/clippy_lints/src/missing_const_for_fn.rs
+++ b/clippy_lints/src/missing_const_for_fn.rs
@@ -138,7 +138,7 @@ impl<'tcx> LateLintPass<'tcx> for MissingConstForFn {
 
         let mir = cx.tcx.optimized_mir(def_id);
 
-        if let Err((span, err)) = is_min_const_fn(cx.tcx, &mir) {
+        if let Err((span, err)) = is_min_const_fn(cx.tcx, mir) {
             if rustc_mir::const_eval::is_min_const_fn(cx.tcx, def_id.to_def_id()) {
                 cx.tcx.sess.span_err(span, &err);
             }
diff --git a/clippy_lints/src/missing_inline.rs b/clippy_lints/src/missing_inline.rs
index dd4488f3f02..041fe64a1a9 100644
--- a/clippy_lints/src/missing_inline.rs
+++ b/clippy_lints/src/missing_inline.rs
@@ -96,7 +96,7 @@ impl<'tcx> LateLintPass<'tcx> for MissingInline {
                 let attrs = cx.tcx.hir().attrs(it.hir_id());
                 check_missing_inline_attrs(cx, attrs, it.span, desc);
             },
-            hir::ItemKind::Trait(ref _is_auto, ref _unsafe, ref _generics, ref _bounds, trait_items) => {
+            hir::ItemKind::Trait(ref _is_auto, ref _unsafe, ref _generics, _bounds, trait_items) => {
                 // note: we need to check if the trait is exported so we can't use
                 // `LateLintPass::check_trait_item` here.
                 for tit in trait_items {
diff --git a/clippy_lints/src/mut_key.rs b/clippy_lints/src/mut_key.rs
index 41bd07bcf1e..ed7b9cd62dc 100644
--- a/clippy_lints/src/mut_key.rs
+++ b/clippy_lints/src/mut_key.rs
@@ -58,21 +58,21 @@ declare_lint_pass!(MutableKeyType => [ MUTABLE_KEY_TYPE ]);
 impl<'tcx> LateLintPass<'tcx> for MutableKeyType {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'tcx>) {
         if let hir::ItemKind::Fn(ref sig, ..) = item.kind {
-            check_sig(cx, item.hir_id(), &sig.decl);
+            check_sig(cx, item.hir_id(), sig.decl);
         }
     }
 
     fn check_impl_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::ImplItem<'tcx>) {
         if let hir::ImplItemKind::Fn(ref sig, ..) = item.kind {
             if trait_ref_of_method(cx, item.hir_id()).is_none() {
-                check_sig(cx, item.hir_id(), &sig.decl);
+                check_sig(cx, item.hir_id(), sig.decl);
             }
         }
     }
 
     fn check_trait_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::TraitItem<'tcx>) {
         if let hir::TraitItemKind::Fn(ref sig, ..) = item.kind {
-            check_sig(cx, item.hir_id(), &sig.decl);
+            check_sig(cx, item.hir_id(), sig.decl);
         }
     }
 
diff --git a/clippy_lints/src/mut_mut.rs b/clippy_lints/src/mut_mut.rs
index ef33e41a5fa..4b9c51d0c16 100644
--- a/clippy_lints/src/mut_mut.rs
+++ b/clippy_lints/src/mut_mut.rs
@@ -62,7 +62,7 @@ impl<'a, 'tcx> intravisit::Visitor<'tcx> for MutVisitor<'a, 'tcx> {
             // Let's ignore the generated code.
             intravisit::walk_expr(self, arg);
             intravisit::walk_expr(self, body);
-        } else if let hir::ExprKind::AddrOf(hir::BorrowKind::Ref, hir::Mutability::Mut, ref e) = expr.kind {
+        } else if let hir::ExprKind::AddrOf(hir::BorrowKind::Ref, hir::Mutability::Mut, e) = expr.kind {
             if let hir::ExprKind::AddrOf(hir::BorrowKind::Ref, hir::Mutability::Mut, _) = e.kind {
                 span_lint(
                     self.cx,
@@ -85,7 +85,7 @@ impl<'a, 'tcx> intravisit::Visitor<'tcx> for MutVisitor<'a, 'tcx> {
         if let hir::TyKind::Rptr(
             _,
             hir::MutTy {
-                ty: ref pty,
+                ty: pty,
                 mutbl: hir::Mutability::Mut,
             },
         ) = ty.kind
diff --git a/clippy_lints/src/mut_reference.rs b/clippy_lints/src/mut_reference.rs
index 0c09ddb8073..b85cc4b9548 100644
--- a/clippy_lints/src/mut_reference.rs
+++ b/clippy_lints/src/mut_reference.rs
@@ -32,7 +32,7 @@ declare_lint_pass!(UnnecessaryMutPassed => [UNNECESSARY_MUT_PASSED]);
 impl<'tcx> LateLintPass<'tcx> for UnnecessaryMutPassed {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
         match e.kind {
-            ExprKind::Call(ref fn_expr, ref arguments) => {
+            ExprKind::Call(fn_expr, arguments) => {
                 if let ExprKind::Path(ref path) = fn_expr.kind {
                     check_arguments(
                         cx,
@@ -43,7 +43,7 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryMutPassed {
                     );
                 }
             },
-            ExprKind::MethodCall(ref path, _, ref arguments, _) => {
+            ExprKind::MethodCall(path, _, arguments, _) => {
                 let def_id = cx.typeck_results().type_dependent_def_id(e.hir_id).unwrap();
                 let substs = cx.typeck_results().node_substs(e.hir_id);
                 let method_type = cx.tcx.type_of(def_id).subst(cx.tcx, substs);
diff --git a/clippy_lints/src/needless_bool.rs b/clippy_lints/src/needless_bool.rs
index db7b3423ad9..96a58d1410f 100644
--- a/clippy_lints/src/needless_bool.rs
+++ b/clippy_lints/src/needless_bool.rs
@@ -71,7 +71,7 @@ declare_lint_pass!(NeedlessBool => [NEEDLESS_BOOL]);
 impl<'tcx> LateLintPass<'tcx> for NeedlessBool {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
         use self::Expression::{Bool, RetBool};
-        if let ExprKind::If(ref pred, ref then_block, Some(ref else_expr)) = e.kind {
+        if let ExprKind::If(pred, then_block, Some(else_expr)) = e.kind {
             let reduce = |ret, not| {
                 let mut applicability = Applicability::MachineApplicable;
                 let snip = Sugg::hir_with_applicability(cx, pred, "<predicate>", &mut applicability);
@@ -81,7 +81,7 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessBool {
                     snip = snip.make_return();
                 }
 
-                if parent_node_is_if_expr(&e, &cx) {
+                if parent_node_is_if_expr(e, cx) {
                     snip = snip.blockify()
                 }
 
@@ -95,7 +95,7 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessBool {
                     applicability,
                 );
             };
-            if let ExprKind::Block(ref then_block, _) = then_block.kind {
+            if let ExprKind::Block(then_block, _) = then_block.kind {
                 match (fetch_bool_block(then_block), fetch_bool_expr(else_expr)) {
                     (RetBool(true), RetBool(true)) | (Bool(true), Bool(true)) => {
                         span_lint(
@@ -225,7 +225,7 @@ fn check_comparison<'a, 'tcx>(
 ) {
     use self::Expression::{Bool, Other};
 
-    if let ExprKind::Binary(op, ref left_side, ref right_side) = e.kind {
+    if let ExprKind::Binary(op, left_side, right_side) = e.kind {
         let (l_ty, r_ty) = (
             cx.typeck_results().expr_ty(left_side),
             cx.typeck_results().expr_ty(right_side),
@@ -237,7 +237,7 @@ fn check_comparison<'a, 'tcx>(
             let mut applicability = Applicability::MachineApplicable;
 
             if let BinOpKind::Eq = op.node {
-                let expression_info = one_side_is_unary_not(&left_side, &right_side);
+                let expression_info = one_side_is_unary_not(left_side, right_side);
                 if expression_info.one_side_is_unary_not {
                     span_lint_and_sugg(
                         cx,
@@ -324,9 +324,9 @@ fn fetch_bool_block(block: &Block<'_>) -> Expression {
     match (&*block.stmts, block.expr.as_ref()) {
         (&[], Some(e)) => fetch_bool_expr(&**e),
         (&[ref e], None) => {
-            if let StmtKind::Semi(ref e) = e.kind {
+            if let StmtKind::Semi(e) = e.kind {
                 if let ExprKind::Ret(_) = e.kind {
-                    fetch_bool_expr(&**e)
+                    fetch_bool_expr(e)
                 } else {
                     Expression::Other
                 }
@@ -340,7 +340,7 @@ fn fetch_bool_block(block: &Block<'_>) -> Expression {
 
 fn fetch_bool_expr(expr: &Expr<'_>) -> Expression {
     match expr.kind {
-        ExprKind::Block(ref block, _) => fetch_bool_block(block),
+        ExprKind::Block(block, _) => fetch_bool_block(block),
         ExprKind::Lit(ref lit_ptr) => {
             if let LitKind::Bool(value) = lit_ptr.node {
                 Expression::Bool(value)
@@ -348,7 +348,7 @@ fn fetch_bool_expr(expr: &Expr<'_>) -> Expression {
                 Expression::Other
             }
         },
-        ExprKind::Ret(Some(ref expr)) => match fetch_bool_expr(expr) {
+        ExprKind::Ret(Some(expr)) => match fetch_bool_expr(expr) {
             Expression::Bool(value) => Expression::RetBool(value),
             _ => Expression::Other,
         },
diff --git a/clippy_lints/src/needless_borrow.rs b/clippy_lints/src/needless_borrow.rs
index 79d84da2dfc..eef3c16730b 100644
--- a/clippy_lints/src/needless_borrow.rs
+++ b/clippy_lints/src/needless_borrow.rs
@@ -48,7 +48,7 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessBorrow {
         if e.span.from_expansion() || self.derived_item.is_some() {
             return;
         }
-        if let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Not, ref inner) = e.kind {
+        if let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Not, inner) = e.kind {
             if let ty::Ref(_, ty, _) = cx.typeck_results().expr_ty(inner).kind() {
                 for adj3 in cx.typeck_results().expr_adjustments(e).windows(3) {
                     if let [Adjustment {
diff --git a/clippy_lints/src/needless_borrowed_ref.rs b/clippy_lints/src/needless_borrowed_ref.rs
index 7fbffe04a3f..0e976b130eb 100644
--- a/clippy_lints/src/needless_borrowed_ref.rs
+++ b/clippy_lints/src/needless_borrowed_ref.rs
@@ -51,7 +51,7 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessBorrowedRef {
 
         if_chain! {
             // Only lint immutable refs, because `&mut ref T` may be useful.
-            if let PatKind::Ref(ref sub_pat, Mutability::Not) = pat.kind;
+            if let PatKind::Ref(sub_pat, Mutability::Not) = pat.kind;
 
             // Check sub_pat got a `ref` keyword (excluding `ref mut`).
             if let PatKind::Binding(BindingAnnotation::Ref, .., spanned_name, _) = sub_pat.kind;
diff --git a/clippy_lints/src/needless_for_each.rs b/clippy_lints/src/needless_for_each.rs
index 2ea871990f1..079b6642d58 100644
--- a/clippy_lints/src/needless_for_each.rs
+++ b/clippy_lints/src/needless_for_each.rs
@@ -70,7 +70,7 @@ impl LateLintPass<'_> for NeedlessForEach {
                 ExprKind::Array(..) | ExprKind::Call(..) | ExprKind::Path(..)
             );
             // Checks the type of the `iter` method receiver is NOT a user defined type.
-            if has_iter_method(cx, cx.typeck_results().expr_ty(&iter_recv)).is_some();
+            if has_iter_method(cx, cx.typeck_results().expr_ty(iter_recv)).is_some();
             // Skip the lint if the body is not block because this is simpler than `for` loop.
             // e.g. `v.iter().for_each(f)` is simpler and clearer than using `for` loop.
             if let ExprKind::Closure(_, _, body_id, ..) = for_each_arg.kind;
diff --git a/clippy_lints/src/needless_pass_by_value.rs b/clippy_lints/src/needless_pass_by_value.rs
index 7370ba39922..780e2241293 100644
--- a/clippy_lints/src/needless_pass_by_value.rs
+++ b/clippy_lints/src/needless_pass_by_value.rs
@@ -208,7 +208,7 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByValue {
                             if is_type_diagnostic_item(cx, ty, sym::vec_type);
                             if let Some(clone_spans) =
                                 get_spans(cx, Some(body.id()), idx, &[("clone", ".to_owned()")]);
-                            if let TyKind::Path(QPath::Resolved(_, ref path)) = input.kind;
+                            if let TyKind::Path(QPath::Resolved(_, path)) = input.kind;
                             if let Some(elem_ty) = path.segments.iter()
                                 .find(|seg| seg.ident.name == sym::Vec)
                                 .and_then(|ps| ps.args.as_ref())
diff --git a/clippy_lints/src/needless_update.rs b/clippy_lints/src/needless_update.rs
index e93de8a252a..8f325404deb 100644
--- a/clippy_lints/src/needless_update.rs
+++ b/clippy_lints/src/needless_update.rs
@@ -49,7 +49,7 @@ declare_lint_pass!(NeedlessUpdate => [NEEDLESS_UPDATE]);
 
 impl<'tcx> LateLintPass<'tcx> for NeedlessUpdate {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if let ExprKind::Struct(_, ref fields, Some(ref base)) = expr.kind {
+        if let ExprKind::Struct(_, fields, Some(base)) = expr.kind {
             let ty = cx.typeck_results().expr_ty(expr);
             if let ty::Adt(def, _) = ty.kind() {
                 if fields.len() == def.non_enum_variant().fields.len()
diff --git a/clippy_lints/src/neg_cmp_op_on_partial_ord.rs b/clippy_lints/src/neg_cmp_op_on_partial_ord.rs
index 4b935c7b906..0704173a011 100644
--- a/clippy_lints/src/neg_cmp_op_on_partial_ord.rs
+++ b/clippy_lints/src/neg_cmp_op_on_partial_ord.rs
@@ -51,8 +51,8 @@ impl<'tcx> LateLintPass<'tcx> for NoNegCompOpForPartialOrd {
         if_chain! {
 
             if !in_external_macro(cx.sess(), expr.span);
-            if let ExprKind::Unary(UnOp::Not, ref inner) = expr.kind;
-            if let ExprKind::Binary(ref op, ref left, _) = inner.kind;
+            if let ExprKind::Unary(UnOp::Not, inner) = expr.kind;
+            if let ExprKind::Binary(ref op, left, _) = inner.kind;
             if let BinOpKind::Le | BinOpKind::Ge | BinOpKind::Lt | BinOpKind::Gt = op.node;
 
             then {
diff --git a/clippy_lints/src/neg_multiply.rs b/clippy_lints/src/neg_multiply.rs
index 7b00879251f..34fd012572f 100644
--- a/clippy_lints/src/neg_multiply.rs
+++ b/clippy_lints/src/neg_multiply.rs
@@ -28,12 +28,12 @@ declare_lint_pass!(NegMultiply => [NEG_MULTIPLY]);
 #[allow(clippy::match_same_arms)]
 impl<'tcx> LateLintPass<'tcx> for NegMultiply {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
-        if let ExprKind::Binary(ref op, ref left, ref right) = e.kind {
+        if let ExprKind::Binary(ref op, left, right) = e.kind {
             if BinOpKind::Mul == op.node {
                 match (&left.kind, &right.kind) {
                     (&ExprKind::Unary(..), &ExprKind::Unary(..)) => {},
-                    (&ExprKind::Unary(UnOp::Neg, ref lit), _) => check_mul(cx, e.span, lit, right),
-                    (_, &ExprKind::Unary(UnOp::Neg, ref lit)) => check_mul(cx, e.span, lit, left),
+                    (&ExprKind::Unary(UnOp::Neg, lit), _) => check_mul(cx, e.span, lit, right),
+                    (_, &ExprKind::Unary(UnOp::Neg, lit)) => check_mul(cx, e.span, lit, left),
                     _ => {},
                 }
             }
diff --git a/clippy_lints/src/no_effect.rs b/clippy_lints/src/no_effect.rs
index 83953a16bc8..cfcaf509471 100644
--- a/clippy_lints/src/no_effect.rs
+++ b/clippy_lints/src/no_effect.rs
@@ -51,23 +51,21 @@ fn has_no_effect(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
     match expr.kind {
         ExprKind::Lit(..) | ExprKind::Closure(..) => true,
         ExprKind::Path(..) => !has_drop(cx, cx.typeck_results().expr_ty(expr)),
-        ExprKind::Index(ref a, ref b) | ExprKind::Binary(_, ref a, ref b) => {
-            has_no_effect(cx, a) && has_no_effect(cx, b)
-        },
-        ExprKind::Array(ref v) | ExprKind::Tup(ref v) => v.iter().all(|val| has_no_effect(cx, val)),
-        ExprKind::Repeat(ref inner, _)
-        | ExprKind::Cast(ref inner, _)
-        | ExprKind::Type(ref inner, _)
-        | ExprKind::Unary(_, ref inner)
-        | ExprKind::Field(ref inner, _)
-        | ExprKind::AddrOf(_, _, ref inner)
-        | ExprKind::Box(ref inner) => has_no_effect(cx, inner),
-        ExprKind::Struct(_, ref fields, ref base) => {
+        ExprKind::Index(a, b) | ExprKind::Binary(_, a, b) => has_no_effect(cx, a) && has_no_effect(cx, b),
+        ExprKind::Array(v) | ExprKind::Tup(v) => v.iter().all(|val| has_no_effect(cx, val)),
+        ExprKind::Repeat(inner, _)
+        | ExprKind::Cast(inner, _)
+        | ExprKind::Type(inner, _)
+        | ExprKind::Unary(_, inner)
+        | ExprKind::Field(inner, _)
+        | ExprKind::AddrOf(_, _, inner)
+        | ExprKind::Box(inner) => has_no_effect(cx, inner),
+        ExprKind::Struct(_, fields, ref base) => {
             !has_drop(cx, cx.typeck_results().expr_ty(expr))
-                && fields.iter().all(|field| has_no_effect(cx, &field.expr))
+                && fields.iter().all(|field| has_no_effect(cx, field.expr))
                 && base.as_ref().map_or(true, |base| has_no_effect(cx, base))
         },
-        ExprKind::Call(ref callee, ref args) => {
+        ExprKind::Call(callee, args) => {
             if let ExprKind::Path(ref qpath) = callee.kind {
                 let res = cx.qpath_res(qpath, callee.hir_id);
                 match res {
@@ -81,7 +79,7 @@ fn has_no_effect(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
                 false
             }
         },
-        ExprKind::Block(ref block, _) => {
+        ExprKind::Block(block, _) => {
             block.stmts.is_empty() && block.expr.as_ref().map_or(false, |expr| has_no_effect(cx, expr))
         },
         _ => false,
@@ -92,7 +90,7 @@ declare_lint_pass!(NoEffect => [NO_EFFECT, UNNECESSARY_OPERATION]);
 
 impl<'tcx> LateLintPass<'tcx> for NoEffect {
     fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) {
-        if let StmtKind::Semi(ref expr) = stmt.kind {
+        if let StmtKind::Semi(expr) = stmt.kind {
             if has_no_effect(cx, expr) {
                 span_lint(cx, NO_EFFECT, stmt.span, "statement with no effect");
             } else if let Some(reduced) = reduce_expression(cx, expr) {
@@ -127,26 +125,26 @@ fn reduce_expression<'a>(cx: &LateContext<'_>, expr: &'a Expr<'a>) -> Option<Vec
         return None;
     }
     match expr.kind {
-        ExprKind::Index(ref a, ref b) => Some(vec![&**a, &**b]),
-        ExprKind::Binary(ref binop, ref a, ref b) if binop.node != BinOpKind::And && binop.node != BinOpKind::Or => {
-            Some(vec![&**a, &**b])
+        ExprKind::Index(a, b) => Some(vec![a, b]),
+        ExprKind::Binary(ref binop, a, b) if binop.node != BinOpKind::And && binop.node != BinOpKind::Or => {
+            Some(vec![a, b])
         },
-        ExprKind::Array(ref v) | ExprKind::Tup(ref v) => Some(v.iter().collect()),
-        ExprKind::Repeat(ref inner, _)
-        | ExprKind::Cast(ref inner, _)
-        | ExprKind::Type(ref inner, _)
-        | ExprKind::Unary(_, ref inner)
-        | ExprKind::Field(ref inner, _)
-        | ExprKind::AddrOf(_, _, ref inner)
-        | ExprKind::Box(ref inner) => reduce_expression(cx, inner).or_else(|| Some(vec![inner])),
-        ExprKind::Struct(_, ref fields, ref base) => {
+        ExprKind::Array(v) | ExprKind::Tup(v) => Some(v.iter().collect()),
+        ExprKind::Repeat(inner, _)
+        | ExprKind::Cast(inner, _)
+        | ExprKind::Type(inner, _)
+        | ExprKind::Unary(_, inner)
+        | ExprKind::Field(inner, _)
+        | ExprKind::AddrOf(_, _, inner)
+        | ExprKind::Box(inner) => reduce_expression(cx, inner).or_else(|| Some(vec![inner])),
+        ExprKind::Struct(_, fields, ref base) => {
             if has_drop(cx, cx.typeck_results().expr_ty(expr)) {
                 None
             } else {
                 Some(fields.iter().map(|f| &f.expr).chain(base).map(Deref::deref).collect())
             }
         },
-        ExprKind::Call(ref callee, ref args) => {
+        ExprKind::Call(callee, args) => {
             if let ExprKind::Path(ref qpath) = callee.kind {
                 let res = cx.qpath_res(qpath, callee.hir_id);
                 match res {
@@ -161,7 +159,7 @@ fn reduce_expression<'a>(cx: &LateContext<'_>, expr: &'a Expr<'a>) -> Option<Vec
                 None
             }
         },
-        ExprKind::Block(ref block, _) => {
+        ExprKind::Block(block, _) => {
             if block.stmts.is_empty() {
                 block.expr.as_ref().and_then(|e| {
                     match block.rules {
diff --git a/clippy_lints/src/non_octal_unix_permissions.rs b/clippy_lints/src/non_octal_unix_permissions.rs
index 6d45e7bc6cf..a83daea97bf 100644
--- a/clippy_lints/src/non_octal_unix_permissions.rs
+++ b/clippy_lints/src/non_octal_unix_permissions.rs
@@ -44,7 +44,7 @@ impl LateLintPass<'_> for NonOctalUnixPermissions {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
         match &expr.kind {
             ExprKind::MethodCall(path, _, [func, param], _) => {
-                let obj_ty = cx.typeck_results().expr_ty(&func).peel_refs();
+                let obj_ty = cx.typeck_results().expr_ty(func).peel_refs();
 
                 if_chain! {
                     if (path.ident.name == sym!(mode)
@@ -65,7 +65,7 @@ impl LateLintPass<'_> for NonOctalUnixPermissions {
                     }
                 }
             },
-            ExprKind::Call(ref func, [param]) => {
+            ExprKind::Call(func, [param]) => {
                 if_chain! {
                     if let ExprKind::Path(ref path) = func.kind;
                     if let Some(def_id) = cx.qpath_res(path, func.hir_id).opt_def_id();
diff --git a/clippy_lints/src/open_options.rs b/clippy_lints/src/open_options.rs
index c61dff4b8e0..9efe45336bf 100644
--- a/clippy_lints/src/open_options.rs
+++ b/clippy_lints/src/open_options.rs
@@ -31,7 +31,7 @@ declare_lint_pass!(OpenOptions => [NONSENSICAL_OPEN_OPTIONS]);
 
 impl<'tcx> LateLintPass<'tcx> for OpenOptions {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
-        if let ExprKind::MethodCall(ref path, _, ref arguments, _) = e.kind {
+        if let ExprKind::MethodCall(path, _, arguments, _) = e.kind {
             let obj_ty = cx.typeck_results().expr_ty(&arguments[0]).peel_refs();
             if path.ident.name == sym!(open) && match_type(cx, obj_ty, &paths::OPEN_OPTIONS) {
                 let mut options = Vec::new();
@@ -59,7 +59,7 @@ enum OpenOption {
 }
 
 fn get_open_options(cx: &LateContext<'_>, argument: &Expr<'_>, options: &mut Vec<(OpenOption, Argument)>) {
-    if let ExprKind::MethodCall(ref path, _, ref arguments, _) = argument.kind {
+    if let ExprKind::MethodCall(path, _, arguments, _) = argument.kind {
         let obj_ty = cx.typeck_results().expr_ty(&arguments[0]).peel_refs();
 
         // Only proceed if this is a call on some object of type std::fs::OpenOptions
diff --git a/clippy_lints/src/option_if_let_else.rs b/clippy_lints/src/option_if_let_else.rs
index a76a4a33f1f..1b9120ae45f 100644
--- a/clippy_lints/src/option_if_let_else.rs
+++ b/clippy_lints/src/option_if_let_else.rs
@@ -66,9 +66,9 @@ declare_lint_pass!(OptionIfLetElse => [OPTION_IF_LET_ELSE]);
 
 /// Returns true iff the given expression is the result of calling `Result::ok`
 fn is_result_ok(cx: &LateContext<'_>, expr: &'_ Expr<'_>) -> bool {
-    if let ExprKind::MethodCall(ref path, _, &[ref receiver], _) = &expr.kind {
+    if let ExprKind::MethodCall(path, _, &[ref receiver], _) = &expr.kind {
         path.ident.name.as_str() == "ok"
-            && is_type_diagnostic_item(cx, &cx.typeck_results().expr_ty(&receiver), sym::result_type)
+            && is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(receiver), sym::result_type)
     } else {
         false
     }
@@ -97,9 +97,9 @@ fn extract_body_from_arm<'a>(arm: &'a Arm<'a>) -> Option<&'a Expr<'a>> {
     ) = &arm.body.kind
     {
         if let [] = statements {
-            Some(&expr)
+            Some(expr)
         } else {
-            Some(&arm.body)
+            Some(arm.body)
         }
     } else {
         None
diff --git a/clippy_lints/src/overflow_check_conditional.rs b/clippy_lints/src/overflow_check_conditional.rs
index cf667c6e805..e222782c2cc 100644
--- a/clippy_lints/src/overflow_check_conditional.rs
+++ b/clippy_lints/src/overflow_check_conditional.rs
@@ -31,11 +31,11 @@ impl<'tcx> LateLintPass<'tcx> for OverflowCheckConditional {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         let eq = |l, r| SpanlessEq::new(cx).eq_path_segment(l, r);
         if_chain! {
-            if let ExprKind::Binary(ref op, ref first, ref second) = expr.kind;
-            if let ExprKind::Binary(ref op2, ref ident1, ref ident2) = first.kind;
-            if let ExprKind::Path(QPath::Resolved(_, ref path1)) = ident1.kind;
-            if let ExprKind::Path(QPath::Resolved(_, ref path2)) = ident2.kind;
-            if let ExprKind::Path(QPath::Resolved(_, ref path3)) = second.kind;
+            if let ExprKind::Binary(ref op, first, second) = expr.kind;
+            if let ExprKind::Binary(ref op2, ident1, ident2) = first.kind;
+            if let ExprKind::Path(QPath::Resolved(_, path1)) = ident1.kind;
+            if let ExprKind::Path(QPath::Resolved(_, path2)) = ident2.kind;
+            if let ExprKind::Path(QPath::Resolved(_, path3)) = second.kind;
             if eq(&path1.segments[0], &path3.segments[0]) || eq(&path2.segments[0], &path3.segments[0]);
             if cx.typeck_results().expr_ty(ident1).is_integral();
             if cx.typeck_results().expr_ty(ident2).is_integral();
@@ -56,11 +56,11 @@ impl<'tcx> LateLintPass<'tcx> for OverflowCheckConditional {
         }
 
         if_chain! {
-            if let ExprKind::Binary(ref op, ref first, ref second) = expr.kind;
-            if let ExprKind::Binary(ref op2, ref ident1, ref ident2) = second.kind;
-            if let ExprKind::Path(QPath::Resolved(_, ref path1)) = ident1.kind;
-            if let ExprKind::Path(QPath::Resolved(_, ref path2)) = ident2.kind;
-            if let ExprKind::Path(QPath::Resolved(_, ref path3)) = first.kind;
+            if let ExprKind::Binary(ref op, first, second) = expr.kind;
+            if let ExprKind::Binary(ref op2, ident1, ident2) = second.kind;
+            if let ExprKind::Path(QPath::Resolved(_, path1)) = ident1.kind;
+            if let ExprKind::Path(QPath::Resolved(_, path2)) = ident2.kind;
+            if let ExprKind::Path(QPath::Resolved(_, path3)) = first.kind;
             if eq(&path1.segments[0], &path3.segments[0]) || eq(&path2.segments[0], &path3.segments[0]);
             if cx.typeck_results().expr_ty(ident1).is_integral();
             if cx.typeck_results().expr_ty(ident2).is_integral();
diff --git a/clippy_lints/src/pass_by_ref_or_value.rs b/clippy_lints/src/pass_by_ref_or_value.rs
index 9a5b1c3b944..c86a847b2ee 100644
--- a/clippy_lints/src/pass_by_ref_or_value.rs
+++ b/clippy_lints/src/pass_by_ref_or_value.rs
@@ -141,11 +141,11 @@ impl<'tcx> PassByRefOrValue {
                     };
 
                     if_chain! {
-                        if !output_lts.contains(&input_lt);
+                        if !output_lts.contains(input_lt);
                         if is_copy(cx, ty);
                         if let Some(size) = cx.layout_of(ty).ok().map(|l| l.size.bytes());
                         if size <= self.ref_min_size;
-                        if let hir::TyKind::Rptr(_, MutTy { ty: ref decl_ty, .. }) = input.kind;
+                        if let hir::TyKind::Rptr(_, MutTy { ty: decl_ty, .. }) = input.kind;
                         then {
                             let value_type = if is_self_ty(decl_ty) {
                                 "self".into()
diff --git a/clippy_lints/src/path_buf_push_overwrite.rs b/clippy_lints/src/path_buf_push_overwrite.rs
index 95ffae28d8c..00245926381 100644
--- a/clippy_lints/src/path_buf_push_overwrite.rs
+++ b/clippy_lints/src/path_buf_push_overwrite.rs
@@ -45,7 +45,7 @@ declare_lint_pass!(PathBufPushOverwrite => [PATH_BUF_PUSH_OVERWRITE]);
 impl<'tcx> LateLintPass<'tcx> for PathBufPushOverwrite {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if_chain! {
-            if let ExprKind::MethodCall(ref path, _, ref args, _) = expr.kind;
+            if let ExprKind::MethodCall(path, _, args, _) = expr.kind;
             if path.ident.name == sym!(push);
             if args.len() == 2;
             if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&args[0]).peel_refs(), sym::PathBuf);
diff --git a/clippy_lints/src/pattern_type_mismatch.rs b/clippy_lints/src/pattern_type_mismatch.rs
index 4550b367da4..8c198cecd6a 100644
--- a/clippy_lints/src/pattern_type_mismatch.rs
+++ b/clippy_lints/src/pattern_type_mismatch.rs
@@ -86,7 +86,7 @@ declare_lint_pass!(PatternTypeMismatch => [PATTERN_TYPE_MISMATCH]);
 
 impl<'tcx> LateLintPass<'tcx> for PatternTypeMismatch {
     fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) {
-        if let StmtKind::Local(ref local) = stmt.kind {
+        if let StmtKind::Local(local) = stmt.kind {
             if let Some(init) = &local.init {
                 if let Some(init_ty) = cx.typeck_results().node_type_opt(init.hir_id) {
                     let pat = &local.pat;
@@ -104,7 +104,7 @@ impl<'tcx> LateLintPass<'tcx> for PatternTypeMismatch {
     }
 
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if let ExprKind::Match(ref expr, arms, source) = expr.kind {
+        if let ExprKind::Match(expr, arms, source) = expr.kind {
             match source {
                 MatchSource::Normal | MatchSource::IfLetDesugar { .. } | MatchSource::WhileLetDesugar => {
                     if let Some(expr_ty) = cx.typeck_results().node_type_opt(expr.hir_id) {
@@ -135,7 +135,7 @@ impl<'tcx> LateLintPass<'tcx> for PatternTypeMismatch {
     ) {
         if let Some(fn_sig) = cx.typeck_results().liberated_fn_sigs().get(hir_id) {
             for (param, ty) in body.params.iter().zip(fn_sig.inputs().iter()) {
-                apply_lint(cx, &param.pat, ty, DerefPossible::Impossible);
+                apply_lint(cx, param.pat, ty, DerefPossible::Impossible);
             }
         }
     }
@@ -187,7 +187,7 @@ fn find_first_mismatch<'tcx>(
     ty: Ty<'tcx>,
     level: Level,
 ) -> Option<(Span, Mutability, Level)> {
-    if let PatKind::Ref(ref sub_pat, _) = pat.kind {
+    if let PatKind::Ref(sub_pat, _) = pat.kind {
         if let TyKind::Ref(_, sub_ty, _) = ty.kind() {
             return find_first_mismatch(cx, sub_pat, sub_ty, Level::Lower);
         }
@@ -199,8 +199,8 @@ fn find_first_mismatch<'tcx>(
         }
     }
 
-    if let PatKind::Struct(ref qpath, ref field_pats, _) = pat.kind {
-        if let TyKind::Adt(ref adt_def, ref substs_ref) = ty.kind() {
+    if let PatKind::Struct(ref qpath, field_pats, _) = pat.kind {
+        if let TyKind::Adt(adt_def, substs_ref) = ty.kind() {
             if let Some(variant) = get_variant(adt_def, qpath) {
                 let field_defs = &variant.fields;
                 return find_first_mismatch_in_struct(cx, field_pats, field_defs, substs_ref);
@@ -208,8 +208,8 @@ fn find_first_mismatch<'tcx>(
         }
     }
 
-    if let PatKind::TupleStruct(ref qpath, ref pats, _) = pat.kind {
-        if let TyKind::Adt(ref adt_def, ref substs_ref) = ty.kind() {
+    if let PatKind::TupleStruct(ref qpath, pats, _) = pat.kind {
+        if let TyKind::Adt(adt_def, substs_ref) = ty.kind() {
             if let Some(variant) = get_variant(adt_def, qpath) {
                 let field_defs = &variant.fields;
                 let ty_iter = field_defs.iter().map(|field_def| field_def.ty(cx.tcx, substs_ref));
@@ -218,7 +218,7 @@ fn find_first_mismatch<'tcx>(
         }
     }
 
-    if let PatKind::Tuple(ref pats, _) = pat.kind {
+    if let PatKind::Tuple(pats, _) = pat.kind {
         if let TyKind::Tuple(..) = ty.kind() {
             return find_first_mismatch_in_tuple(cx, pats, ty.tuple_fields());
         }
diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs
index 6e530d0ffb0..09fcdb5faf8 100644
--- a/clippy_lints/src/ptr.rs
+++ b/clippy_lints/src/ptr.rs
@@ -124,7 +124,7 @@ declare_lint_pass!(Ptr => [PTR_ARG, CMP_NULL, MUT_FROM_REF]);
 impl<'tcx> LateLintPass<'tcx> for Ptr {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
         if let ItemKind::Fn(ref sig, _, body_id) = item.kind {
-            check_fn(cx, &sig.decl, item.hir_id(), Some(body_id));
+            check_fn(cx, sig.decl, item.hir_id(), Some(body_id));
         }
     }
 
@@ -136,7 +136,7 @@ impl<'tcx> LateLintPass<'tcx> for Ptr {
                     return; // ignore trait impls
                 }
             }
-            check_fn(cx, &sig.decl, item.hir_id(), Some(body_id));
+            check_fn(cx, sig.decl, item.hir_id(), Some(body_id));
         }
     }
 
@@ -147,12 +147,12 @@ impl<'tcx> LateLintPass<'tcx> for Ptr {
             } else {
                 None
             };
-            check_fn(cx, &sig.decl, item.hir_id(), body_id);
+            check_fn(cx, sig.decl, item.hir_id(), body_id);
         }
     }
 
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if let ExprKind::Binary(ref op, ref l, ref r) = expr.kind {
+        if let ExprKind::Binary(ref op, l, r) = expr.kind {
             if (op.node == BinOpKind::Eq || op.node == BinOpKind::Ne) && (is_null_path(l) || is_null_path(r)) {
                 span_lint(
                     cx,
@@ -262,10 +262,10 @@ fn check_fn(cx: &LateContext<'_>, decl: &FnDecl<'_>, fn_id: HirId, opt_body_id:
                 }
             } else if match_type(cx, ty, &paths::COW) {
                 if_chain! {
-                    if let TyKind::Rptr(_, MutTy { ref ty, ..} ) = arg.kind;
-                    if let TyKind::Path(QPath::Resolved(None, ref pp)) = ty.kind;
+                    if let TyKind::Rptr(_, MutTy { ty, ..} ) = arg.kind;
+                    if let TyKind::Path(QPath::Resolved(None, pp)) = ty.kind;
                     if let [ref bx] = *pp.segments;
-                    if let Some(ref params) = bx.args;
+                    if let Some(params) = bx.args;
                     if !params.parenthesized;
                     if let Some(inner) = params.args.iter().find_map(|arg| match arg {
                         GenericArg::Type(ty) => Some(ty),
@@ -289,7 +289,7 @@ fn check_fn(cx: &LateContext<'_>, decl: &FnDecl<'_>, fn_id: HirId, opt_body_id:
         }
     }
 
-    if let FnRetTy::Return(ref ty) = decl.output {
+    if let FnRetTy::Return(ty) = decl.output {
         if let Some((out, Mutability::Mut, _)) = get_rptr_lm(ty) {
             let mut immutables = vec![];
             for (_, ref mutbl, ref argspan) in decl
@@ -322,8 +322,8 @@ fn check_fn(cx: &LateContext<'_>, decl: &FnDecl<'_>, fn_id: HirId, opt_body_id:
 
 fn get_only_generic_arg_snippet(cx: &LateContext<'_>, arg: &Ty<'_>) -> Option<String> {
     if_chain! {
-        if let TyKind::Path(QPath::Resolved(_, ref path)) = walk_ptrs_hir_ty(arg).kind;
-        if let Some(&PathSegment{args: Some(ref parameters), ..}) = path.segments.last();
+        if let TyKind::Path(QPath::Resolved(_, path)) = walk_ptrs_hir_ty(arg).kind;
+        if let Some(&PathSegment{args: Some(parameters), ..}) = path.segments.last();
         let types: Vec<_> = parameters.args.iter().filter_map(|arg| match arg {
             GenericArg::Type(ty) => Some(ty),
             _ => None,
@@ -346,7 +346,7 @@ fn get_rptr_lm<'tcx>(ty: &'tcx Ty<'tcx>) -> Option<(&'tcx Lifetime, Mutability,
 }
 
 fn is_null_path(expr: &Expr<'_>) -> bool {
-    if let ExprKind::Call(ref pathexp, ref args) = expr.kind {
+    if let ExprKind::Call(pathexp, args) = expr.kind {
         if args.is_empty() {
             if let ExprKind::Path(ref path) = pathexp.kind {
                 return match_qpath(path, &paths::PTR_NULL) || match_qpath(path, &paths::PTR_NULL_MUT);
diff --git a/clippy_lints/src/ptr_eq.rs b/clippy_lints/src/ptr_eq.rs
index 5796c59c8b3..77cfa3f6b17 100644
--- a/clippy_lints/src/ptr_eq.rs
+++ b/clippy_lints/src/ptr_eq.rs
@@ -46,11 +46,11 @@ impl LateLintPass<'_> for PtrEq {
             return;
         }
 
-        if let ExprKind::Binary(ref op, ref left, ref right) = expr.kind {
+        if let ExprKind::Binary(ref op, left, right) = expr.kind {
             if BinOpKind::Eq == op.node {
                 let (left, right) = match (expr_as_cast_to_usize(cx, left), expr_as_cast_to_usize(cx, right)) {
                     (Some(lhs), Some(rhs)) => (lhs, rhs),
-                    _ => (&**left, &**right),
+                    _ => (left, right),
                 };
 
                 if_chain! {
@@ -79,7 +79,7 @@ impl LateLintPass<'_> for PtrEq {
 // E.g., `foo as *const _ as usize` returns `foo as *const _`.
 fn expr_as_cast_to_usize<'tcx>(cx: &LateContext<'tcx>, cast_expr: &'tcx Expr<'_>) -> Option<&'tcx Expr<'tcx>> {
     if cx.typeck_results().expr_ty(cast_expr) == cx.tcx.types.usize {
-        if let ExprKind::Cast(ref expr, _) = cast_expr.kind {
+        if let ExprKind::Cast(expr, _) = cast_expr.kind {
             return Some(expr);
         }
     }
@@ -90,7 +90,7 @@ fn expr_as_cast_to_usize<'tcx>(cx: &LateContext<'tcx>, cast_expr: &'tcx Expr<'_>
 // E.g., `foo as *const _` returns `foo`.
 fn expr_as_cast_to_raw_pointer<'tcx>(cx: &LateContext<'tcx>, cast_expr: &'tcx Expr<'_>) -> Option<&'tcx Expr<'tcx>> {
     if cx.typeck_results().expr_ty(cast_expr).is_unsafe_ptr() {
-        if let ExprKind::Cast(ref expr, _) = cast_expr.kind {
+        if let ExprKind::Cast(expr, _) = cast_expr.kind {
             return Some(expr);
         }
     }
diff --git a/clippy_lints/src/ptr_offset_with_cast.rs b/clippy_lints/src/ptr_offset_with_cast.rs
index c04b4255256..afb198f4955 100644
--- a/clippy_lints/src/ptr_offset_with_cast.rs
+++ b/clippy_lints/src/ptr_offset_with_cast.rs
@@ -78,8 +78,8 @@ impl<'tcx> LateLintPass<'tcx> for PtrOffsetWithCast {
 
 // If the given expression is a cast from a usize, return the lhs of the cast
 fn expr_as_cast_from_usize<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> Option<&'tcx Expr<'tcx>> {
-    if let ExprKind::Cast(ref cast_lhs_expr, _) = expr.kind {
-        if is_expr_ty_usize(cx, &cast_lhs_expr) {
+    if let ExprKind::Cast(cast_lhs_expr, _) = expr.kind {
+        if is_expr_ty_usize(cx, cast_lhs_expr) {
             return Some(cast_lhs_expr);
         }
     }
@@ -92,7 +92,7 @@ fn expr_as_ptr_offset_call<'tcx>(
     cx: &LateContext<'tcx>,
     expr: &'tcx Expr<'_>,
 ) -> Option<(&'tcx Expr<'tcx>, &'tcx Expr<'tcx>, Method)> {
-    if let ExprKind::MethodCall(ref path_segment, _, ref args, _) = expr.kind {
+    if let ExprKind::MethodCall(path_segment, _, args, _) = expr.kind {
         if is_expr_ty_raw_ptr(cx, &args[0]) {
             if path_segment.ident.name == sym::offset {
                 return Some((&args[0], &args[1], Method::Offset));
diff --git a/clippy_lints/src/question_mark.rs b/clippy_lints/src/question_mark.rs
index 2054255a7c9..6d720f43851 100644
--- a/clippy_lints/src/question_mark.rs
+++ b/clippy_lints/src/question_mark.rs
@@ -148,14 +148,14 @@ impl QuestionMark {
 
     fn expression_returns_none(cx: &LateContext<'_>, expression: &Expr<'_>) -> bool {
         match expression.kind {
-            ExprKind::Block(ref block, _) => {
+            ExprKind::Block(block, _) => {
                 if let Some(return_expression) = Self::return_expression(block) {
-                    return Self::expression_returns_none(cx, &return_expression);
+                    return Self::expression_returns_none(cx, return_expression);
                 }
 
                 false
             },
-            ExprKind::Ret(Some(ref expr)) => Self::expression_returns_none(cx, expr),
+            ExprKind::Ret(Some(expr)) => Self::expression_returns_none(cx, expr),
             ExprKind::Path(ref qp) => {
                 if let Res::Def(DefKind::Ctor(def::CtorOf::Variant, def::CtorKind::Const), def_id) =
                     cx.qpath_res(qp, expression.hir_id)
@@ -174,7 +174,7 @@ impl QuestionMark {
         if_chain! {
             if block.stmts.len() == 1;
             if let Some(expr) = block.stmts.iter().last();
-            if let StmtKind::Semi(ref expr) = expr.kind;
+            if let StmtKind::Semi(expr) = expr.kind;
             if let ExprKind::Ret(Some(ret_expr)) = expr.kind;
 
             then {
diff --git a/clippy_lints/src/ranges.rs b/clippy_lints/src/ranges.rs
index 79692abb6ac..1c3c125e579 100644
--- a/clippy_lints/src/ranges.rs
+++ b/clippy_lints/src/ranges.rs
@@ -183,10 +183,10 @@ impl_lint_pass!(Ranges => [
 impl<'tcx> LateLintPass<'tcx> for Ranges {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         match expr.kind {
-            ExprKind::MethodCall(ref path, _, ref args, _) => {
+            ExprKind::MethodCall(path, _, args, _) => {
                 check_range_zip_with_len(cx, path, args, expr.span);
             },
-            ExprKind::Binary(ref op, ref l, ref r) => {
+            ExprKind::Binary(ref op, l, r) => {
                 if meets_msrv(self.msrv.as_ref(), &MANUAL_RANGE_CONTAINS_MSRV) {
                     check_possible_range_contains(cx, op.node, l, r, expr);
                 }
@@ -287,7 +287,7 @@ fn check_possible_range_contains(cx: &LateContext<'_>, op: BinOpKind, l: &Expr<'
 }
 
 fn check_range_bounds(cx: &LateContext<'_>, ex: &Expr<'_>) -> Option<(Constant, Ident, Span, Span, Ordering, bool)> {
-    if let ExprKind::Binary(ref op, ref l, ref r) = ex.kind {
+    if let ExprKind::Binary(ref op, l, r) = ex.kind {
         let (inclusive, ordering) = match op.node {
             BinOpKind::Gt => (false, Ordering::Greater),
             BinOpKind::Ge => (true, Ordering::Greater),
@@ -324,18 +324,18 @@ fn check_range_zip_with_len(cx: &LateContext<'_>, path: &PathSegment<'_>, args:
         if path.ident.as_str() == "zip";
         if let [iter, zip_arg] = args;
         // `.iter()` call
-        if let ExprKind::MethodCall(ref iter_path, _, ref iter_args, _) = iter.kind;
+        if let ExprKind::MethodCall(iter_path, _, iter_args, _) = iter.kind;
         if iter_path.ident.name == sym::iter;
         // range expression in `.zip()` call: `0..x.len()`
         if let Some(higher::Range { start: Some(start), end: Some(end), .. }) = higher::range(zip_arg);
         if is_integer_const(cx, start, 0);
         // `.len()` call
-        if let ExprKind::MethodCall(ref len_path, _, ref len_args, _) = end.kind;
+        if let ExprKind::MethodCall(len_path, _, len_args, _) = end.kind;
         if len_path.ident.name == sym!(len) && len_args.len() == 1;
         // `.iter()` and `.len()` called on same `Path`
-        if let ExprKind::Path(QPath::Resolved(_, ref iter_path)) = iter_args[0].kind;
-        if let ExprKind::Path(QPath::Resolved(_, ref len_path)) = len_args[0].kind;
-        if SpanlessEq::new(cx).eq_path_segments(&iter_path.segments, &len_path.segments);
+        if let ExprKind::Path(QPath::Resolved(_, iter_path)) = iter_args[0].kind;
+        if let ExprKind::Path(QPath::Resolved(_, len_path)) = len_args[0].kind;
+        if SpanlessEq::new(cx).eq_path_segments(iter_path.segments, len_path.segments);
         then {
             span_lint(cx,
                 RANGE_ZIP_WITH_LEN,
@@ -508,8 +508,8 @@ fn y_plus_one<'t>(cx: &LateContext<'_>, expr: &'t Expr<'_>) -> Option<&'t Expr<'
             Spanned {
                 node: BinOpKind::Add, ..
             },
-            ref lhs,
-            ref rhs,
+            lhs,
+            rhs,
         ) => {
             if is_integer_const(cx, lhs, 1) {
                 Some(rhs)
@@ -529,8 +529,8 @@ fn y_minus_one<'t>(cx: &LateContext<'_>, expr: &'t Expr<'_>) -> Option<&'t Expr<
             Spanned {
                 node: BinOpKind::Sub, ..
             },
-            ref lhs,
-            ref rhs,
+            lhs,
+            rhs,
         ) if is_integer_const(cx, rhs, 1) => Some(lhs),
         _ => None,
     }
diff --git a/clippy_lints/src/redundant_clone.rs b/clippy_lints/src/redundant_clone.rs
index 9656ee64c81..19650c41b84 100644
--- a/clippy_lints/src/redundant_clone.rs
+++ b/clippy_lints/src/redundant_clone.rs
@@ -94,7 +94,7 @@ impl<'tcx> LateLintPass<'tcx> for RedundantClone {
             .into_results_cursor(mir);
         let mut possible_borrower = {
             let mut vis = PossibleBorrowerVisitor::new(cx, mir);
-            vis.visit_body(&mir);
+            vis.visit_body(mir);
             vis.into_map(cx, maybe_storage_live_result)
         };
 
@@ -126,7 +126,7 @@ impl<'tcx> LateLintPass<'tcx> for RedundantClone {
                 continue;
             }
 
-            if let ty::Adt(ref def, _) = arg_ty.kind() {
+            if let ty::Adt(def, _) = arg_ty.kind() {
                 if match_def_path(cx, def.did, &paths::MEM_MANUALLY_DROP) {
                     continue;
                 }
@@ -206,7 +206,7 @@ impl<'tcx> LateLintPass<'tcx> for RedundantClone {
                     clone_consumed_or_mutated: true,
                 }
             } else {
-                let clone_usage = visit_clone_usage(local, ret_local, &mir, bb);
+                let clone_usage = visit_clone_usage(local, ret_local, mir, bb);
                 if clone_usage.cloned_used && clone_usage.clone_consumed_or_mutated {
                     // cloned value is used, and the clone is modified or moved
                     continue;
@@ -426,7 +426,7 @@ fn visit_clone_usage(cloned: mir::Local, clone: mir::Local, mir: &mir::Body<'_>,
         // TODO: Actually check for mutation of non-temporaries.
         clone_consumed_or_mutated: mir.local_kind(clone) != mir::LocalKind::Temp,
     };
-    traversal::ReversePostorder::new(&mir, bb)
+    traversal::ReversePostorder::new(mir, bb)
         .skip(1)
         .fold(init, |usage, (tbb, tdata)| {
             // Short-circuit
@@ -588,7 +588,7 @@ impl<'a, 'tcx> mir::visit::Visitor<'tcx> for PossibleBorrowerVisitor<'a, 'tcx> {
             // If the call returns something with lifetimes,
             // let's conservatively assume the returned value contains lifetime of all the arguments.
             // For example, given `let y: Foo<'a> = foo(x)`, `y` is considered to be a possible borrower of `x`.
-            if ContainsRegion.visit_ty(&self.body.local_decls[*dest].ty).is_continue() {
+            if ContainsRegion.visit_ty(self.body.local_decls[*dest].ty).is_continue() {
                 return;
             }
 
diff --git a/clippy_lints/src/redundant_closure_call.rs b/clippy_lints/src/redundant_closure_call.rs
index 5429d389610..92921bedf4d 100644
--- a/clippy_lints/src/redundant_closure_call.rs
+++ b/clippy_lints/src/redundant_closure_call.rs
@@ -111,8 +111,8 @@ impl<'tcx> LateLintPass<'tcx> for RedundantClosureCall {
 
                 fn visit_expr(&mut self, expr: &'tcx hir::Expr<'tcx>) {
                     if_chain! {
-                        if let hir::ExprKind::Call(ref closure, _) = expr.kind;
-                        if let hir::ExprKind::Path(hir::QPath::Resolved(_, ref path)) = closure.kind;
+                        if let hir::ExprKind::Call(closure, _) = expr.kind;
+                        if let hir::ExprKind::Path(hir::QPath::Resolved(_, path)) = closure.kind;
                         if self.path.segments[0].ident == path.segments[0].ident;
                         if self.path.res == path.res;
                         then {
@@ -133,14 +133,14 @@ impl<'tcx> LateLintPass<'tcx> for RedundantClosureCall {
 
         for w in block.stmts.windows(2) {
             if_chain! {
-                if let hir::StmtKind::Local(ref local) = w[0].kind;
-                if let Option::Some(ref t) = local.init;
+                if let hir::StmtKind::Local(local) = w[0].kind;
+                if let Option::Some(t) = local.init;
                 if let hir::ExprKind::Closure(..) = t.kind;
                 if let hir::PatKind::Binding(_, _, ident, _) = local.pat.kind;
-                if let hir::StmtKind::Semi(ref second) = w[1].kind;
-                if let hir::ExprKind::Assign(_, ref call, _) = second.kind;
-                if let hir::ExprKind::Call(ref closure, _) = call.kind;
-                if let hir::ExprKind::Path(hir::QPath::Resolved(_, ref path)) = closure.kind;
+                if let hir::StmtKind::Semi(second) = w[1].kind;
+                if let hir::ExprKind::Assign(_, call, _) = second.kind;
+                if let hir::ExprKind::Call(closure, _) = call.kind;
+                if let hir::ExprKind::Path(hir::QPath::Resolved(_, path)) = closure.kind;
                 if ident == path.segments[0].ident;
                 if count_closure_usage(cx, block, path) == 1;
                 then {
diff --git a/clippy_lints/src/ref_option_ref.rs b/clippy_lints/src/ref_option_ref.rs
index 0922cfa494e..0cf4e0ce7fe 100644
--- a/clippy_lints/src/ref_option_ref.rs
+++ b/clippy_lints/src/ref_option_ref.rs
@@ -44,7 +44,7 @@ impl<'tcx> LateLintPass<'tcx> for RefOptionRef {
             if let Some(def_id) = res.opt_def_id();
 
             if cx.tcx.is_diagnostic_item(sym::option_type, def_id);
-            if let Some(ref params) = last_path_segment(qpath).args ;
+            if let Some(params) = last_path_segment(qpath).args ;
             if !params.parenthesized;
             if let Some(inner_ty) = params.args.iter().find_map(|arg| match arg {
                 GenericArg::Type(inner_ty) => Some(inner_ty),
diff --git a/clippy_lints/src/regex.rs b/clippy_lints/src/regex.rs
index 1cc332de894..4b5306de58e 100644
--- a/clippy_lints/src/regex.rs
+++ b/clippy_lints/src/regex.rs
@@ -60,7 +60,7 @@ impl_lint_pass!(Regex => [INVALID_REGEX, TRIVIAL_REGEX]);
 impl<'tcx> LateLintPass<'tcx> for Regex {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if_chain! {
-            if let ExprKind::Call(ref fun, ref args) = expr.kind;
+            if let ExprKind::Call(fun, args) = expr.kind;
             if let ExprKind::Path(ref qpath) = fun.kind;
             if args.len() == 1;
             if let Some(def_id) = cx.qpath_res(qpath, fun.hir_id).opt_def_id();
@@ -134,7 +134,7 @@ fn is_trivial_regex(s: &regex_syntax::hir::Hir) -> Option<&'static str> {
 
 fn check_set<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, utf8: bool) {
     if_chain! {
-        if let ExprKind::AddrOf(BorrowKind::Ref, _, ref expr) = expr.kind;
+        if let ExprKind::AddrOf(BorrowKind::Ref, _, expr) = expr.kind;
         if let ExprKind::Array(exprs) = expr.kind;
         then {
             for expr in exprs {
diff --git a/clippy_lints/src/repeat_once.rs b/clippy_lints/src/repeat_once.rs
index 63e5ec69e66..560a5e7c920 100644
--- a/clippy_lints/src/repeat_once.rs
+++ b/clippy_lints/src/repeat_once.rs
@@ -45,10 +45,10 @@ impl<'tcx> LateLintPass<'tcx> for RepeatOnce {
         if_chain! {
             if let ExprKind::MethodCall(path, _, [receiver, count], _) = &expr.kind;
             if path.ident.name == sym!(repeat);
-            if let Some(Constant::Int(1)) = constant_context(cx, cx.typeck_results()).expr(&count);
+            if let Some(Constant::Int(1)) = constant_context(cx, cx.typeck_results()).expr(count);
             if !in_macro(receiver.span);
             then {
-                let ty = cx.typeck_results().expr_ty(&receiver).peel_refs();
+                let ty = cx.typeck_results().expr_ty(receiver).peel_refs();
                 if ty.is_str() {
                     span_lint_and_sugg(
                         cx,
diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
index 8995ae431ad..af772cf4a14 100644
--- a/clippy_lints/src/returns.rs
+++ b/clippy_lints/src/returns.rs
@@ -102,7 +102,7 @@ impl<'tcx> LateLintPass<'tcx> for Return {
                         err.span_label(local.span, "unnecessary `let` binding");
 
                         if let Some(mut snippet) = snippet_opt(cx, initexpr.span) {
-                            if !cx.typeck_results().expr_adjustments(&retexpr).is_empty() {
+                            if !cx.typeck_results().expr_adjustments(retexpr).is_empty() {
                                 snippet.push_str(" as _");
                             }
                             err.multipart_suggestion(
@@ -143,7 +143,7 @@ impl<'tcx> LateLintPass<'tcx> for Return {
                 check_final_expr(cx, &body.value, Some(body.value.span), replacement)
             },
             FnKind::ItemFn(..) | FnKind::Method(..) => {
-                if let ExprKind::Block(ref block, _) = body.value.kind {
+                if let ExprKind::Block(block, _) = body.value.kind {
                     check_block_return(cx, block);
                 }
             },
@@ -160,7 +160,7 @@ fn check_block_return<'tcx>(cx: &LateContext<'tcx>, block: &Block<'tcx>) {
         check_final_expr(cx, expr, Some(expr.span), RetReplacement::Empty);
     } else if let Some(stmt) = block.stmts.iter().last() {
         match stmt.kind {
-            StmtKind::Expr(ref expr) | StmtKind::Semi(ref expr) => {
+            StmtKind::Expr(expr) | StmtKind::Semi(expr) => {
                 check_final_expr(cx, expr, Some(stmt.span), RetReplacement::Empty);
             },
             _ => (),
@@ -192,11 +192,11 @@ fn check_final_expr<'tcx>(
             }
         },
         // a whole block? check it!
-        ExprKind::Block(ref block, _) => {
+        ExprKind::Block(block, _) => {
             check_block_return(cx, block);
         },
         ExprKind::If(_, then, else_clause_opt) => {
-            if let ExprKind::Block(ref ifblock, _) = then.kind {
+            if let ExprKind::Block(ifblock, _) = then.kind {
                 check_block_return(cx, ifblock);
             }
             if let Some(else_clause) = else_clause_opt {
@@ -207,16 +207,16 @@ fn check_final_expr<'tcx>(
         // an if/if let expr, check both exprs
         // note, if without else is going to be a type checking error anyways
         // (except for unit type functions) so we don't match it
-        ExprKind::Match(_, ref arms, source) => match source {
+        ExprKind::Match(_, arms, source) => match source {
             MatchSource::Normal => {
                 for arm in arms.iter() {
-                    check_final_expr(cx, &arm.body, Some(arm.body.span), RetReplacement::Block);
+                    check_final_expr(cx, arm.body, Some(arm.body.span), RetReplacement::Block);
                 }
             },
             MatchSource::IfLetDesugar {
                 contains_else_clause: true,
             } => {
-                if let ExprKind::Block(ref ifblock, _) = arms[0].body.kind {
+                if let ExprKind::Block(ifblock, _) = arms[0].body.kind {
                     check_block_return(cx, ifblock);
                 }
                 check_final_expr(cx, arms[1].body, None, RetReplacement::Empty);
diff --git a/clippy_lints/src/semicolon_if_nothing_returned.rs b/clippy_lints/src/semicolon_if_nothing_returned.rs
index f61af15fbed..553987a426b 100644
--- a/clippy_lints/src/semicolon_if_nothing_returned.rs
+++ b/clippy_lints/src/semicolon_if_nothing_returned.rs
@@ -51,7 +51,7 @@ impl LateLintPass<'_> for SemicolonIfNothingReturned {
                     return;
                 }
 
-                let sugg = sugg::Sugg::hir_with_macro_callsite(cx, &expr, "..");
+                let sugg = sugg::Sugg::hir_with_macro_callsite(cx, expr, "..");
                 let suggestion = format!("{0};", sugg);
                 span_lint_and_sugg(
                     cx,
diff --git a/clippy_lints/src/shadow.rs b/clippy_lints/src/shadow.rs
index 612d2fd84cb..d6101bd5e36 100644
--- a/clippy_lints/src/shadow.rs
+++ b/clippy_lints/src/shadow.rs
@@ -130,12 +130,12 @@ fn check_block<'tcx>(cx: &LateContext<'tcx>, block: &'tcx Block<'_>, bindings: &
     let len = bindings.len();
     for stmt in block.stmts {
         match stmt.kind {
-            StmtKind::Local(ref local) => check_local(cx, local, bindings),
-            StmtKind::Expr(ref e) | StmtKind::Semi(ref e) => check_expr(cx, e, bindings),
+            StmtKind::Local(local) => check_local(cx, local, bindings),
+            StmtKind::Expr(e) | StmtKind::Semi(e) => check_expr(cx, e, bindings),
             StmtKind::Item(..) => {},
         }
     }
-    if let Some(ref o) = block.expr {
+    if let Some(o) = block.expr {
         check_expr(cx, o, bindings);
     }
     bindings.truncate(len);
@@ -149,16 +149,16 @@ fn check_local<'tcx>(cx: &LateContext<'tcx>, local: &'tcx Local<'_>, bindings: &
         return;
     }
     let Local {
-        ref pat,
+        pat,
         ref ty,
         ref init,
         span,
         ..
     } = *local;
-    if let Some(ref t) = *ty {
+    if let Some(t) = *ty {
         check_ty(cx, t, bindings)
     }
-    if let Some(ref o) = *init {
+    if let Some(o) = *init {
         check_expr(cx, o, bindings);
         check_pat(cx, pat, Some(o), span, bindings);
     } else {
@@ -196,34 +196,34 @@ fn check_pat<'tcx>(
                     bindings.push((name, ident.span));
                 }
             }
-            if let Some(ref p) = *inner {
+            if let Some(p) = *inner {
                 check_pat(cx, p, init, span, bindings);
             }
         },
         PatKind::Struct(_, pfields, _) => {
             if let Some(init_struct) = init {
-                if let ExprKind::Struct(_, ref efields, _) = init_struct.kind {
+                if let ExprKind::Struct(_, efields, _) = init_struct.kind {
                     for field in pfields {
                         let name = field.ident.name;
                         let efield = efields
                             .iter()
                             .find_map(|f| if f.ident.name == name { Some(&*f.expr) } else { None });
-                        check_pat(cx, &field.pat, efield, span, bindings);
+                        check_pat(cx, field.pat, efield, span, bindings);
                     }
                 } else {
                     for field in pfields {
-                        check_pat(cx, &field.pat, init, span, bindings);
+                        check_pat(cx, field.pat, init, span, bindings);
                     }
                 }
             } else {
                 for field in pfields {
-                    check_pat(cx, &field.pat, None, span, bindings);
+                    check_pat(cx, field.pat, None, span, bindings);
                 }
             }
         },
         PatKind::Tuple(inner, _) => {
             if let Some(init_tup) = init {
-                if let ExprKind::Tup(ref tup) = init_tup.kind {
+                if let ExprKind::Tup(tup) = init_tup.kind {
                     for (i, p) in inner.iter().enumerate() {
                         check_pat(cx, p, Some(&tup[i]), p.span, bindings);
                     }
@@ -238,10 +238,10 @@ fn check_pat<'tcx>(
                 }
             }
         },
-        PatKind::Box(ref inner) => {
+        PatKind::Box(inner) => {
             if let Some(initp) = init {
-                if let ExprKind::Box(ref inner_init) = initp.kind {
-                    check_pat(cx, inner, Some(&**inner_init), span, bindings);
+                if let ExprKind::Box(inner_init) = initp.kind {
+                    check_pat(cx, inner, Some(inner_init), span, bindings);
                 } else {
                     check_pat(cx, inner, init, span, bindings);
                 }
@@ -249,7 +249,7 @@ fn check_pat<'tcx>(
                 check_pat(cx, inner, init, span, bindings);
             }
         },
-        PatKind::Ref(ref inner, _) => check_pat(cx, inner, init, span, bindings),
+        PatKind::Ref(inner, _) => check_pat(cx, inner, init, span, bindings),
         // PatVec(Vec<P<Pat>>, Option<P<Pat>>, Vec<P<Pat>>),
         _ => (),
     }
@@ -323,11 +323,10 @@ fn check_expr<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, bindings: &mut
         return;
     }
     match expr.kind {
-        ExprKind::Unary(_, ref e)
-        | ExprKind::Field(ref e, _)
-        | ExprKind::AddrOf(_, _, ref e)
-        | ExprKind::Box(ref e) => check_expr(cx, e, bindings),
-        ExprKind::Block(ref block, _) | ExprKind::Loop(ref block, ..) => check_block(cx, block, bindings),
+        ExprKind::Unary(_, e) | ExprKind::Field(e, _) | ExprKind::AddrOf(_, _, e) | ExprKind::Box(e) => {
+            check_expr(cx, e, bindings)
+        },
+        ExprKind::Block(block, _) | ExprKind::Loop(block, ..) => check_block(cx, block, bindings),
         // ExprKind::Call
         // ExprKind::MethodCall
         ExprKind::Array(v) | ExprKind::Tup(v) => {
@@ -335,18 +334,18 @@ fn check_expr<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, bindings: &mut
                 check_expr(cx, e, bindings)
             }
         },
-        ExprKind::If(ref cond, ref then, ref otherwise) => {
+        ExprKind::If(cond, then, ref otherwise) => {
             check_expr(cx, cond, bindings);
-            check_expr(cx, &**then, bindings);
-            if let Some(ref o) = *otherwise {
+            check_expr(cx, then, bindings);
+            if let Some(o) = *otherwise {
                 check_expr(cx, o, bindings);
             }
         },
-        ExprKind::Match(ref init, arms, _) => {
+        ExprKind::Match(init, arms, _) => {
             check_expr(cx, init, bindings);
             let len = bindings.len();
             for arm in arms {
-                check_pat(cx, &arm.pat, Some(&**init), arm.pat.span, bindings);
+                check_pat(cx, arm.pat, Some(init), arm.pat.span, bindings);
                 // This is ugly, but needed to get the right type
                 if let Some(ref guard) = arm.guard {
                     match guard {
@@ -357,7 +356,7 @@ fn check_expr<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, bindings: &mut
                         },
                     }
                 }
-                check_expr(cx, &arm.body, bindings);
+                check_expr(cx, arm.body, bindings);
                 bindings.truncate(len);
             }
         },
@@ -367,14 +366,12 @@ fn check_expr<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, bindings: &mut
 
 fn check_ty<'tcx>(cx: &LateContext<'tcx>, ty: &'tcx Ty<'_>, bindings: &mut Vec<(Symbol, Span)>) {
     match ty.kind {
-        TyKind::Slice(ref sty) => check_ty(cx, sty, bindings),
-        TyKind::Array(ref fty, ref anon_const) => {
+        TyKind::Slice(sty) => check_ty(cx, sty, bindings),
+        TyKind::Array(fty, ref anon_const) => {
             check_ty(cx, fty, bindings);
             check_expr(cx, &cx.tcx.hir().body(anon_const.body).value, bindings);
         },
-        TyKind::Ptr(MutTy { ty: ref mty, .. }) | TyKind::Rptr(_, MutTy { ty: ref mty, .. }) => {
-            check_ty(cx, mty, bindings)
-        },
+        TyKind::Ptr(MutTy { ty: mty, .. }) | TyKind::Rptr(_, MutTy { ty: mty, .. }) => check_ty(cx, mty, bindings),
         TyKind::Tup(tup) => {
             for t in tup {
                 check_ty(cx, t, bindings)
@@ -387,12 +384,12 @@ fn check_ty<'tcx>(cx: &LateContext<'tcx>, ty: &'tcx Ty<'_>, bindings: &mut Vec<(
 
 fn is_self_shadow(name: Symbol, expr: &Expr<'_>) -> bool {
     match expr.kind {
-        ExprKind::Box(ref inner) | ExprKind::AddrOf(_, _, ref inner) => is_self_shadow(name, inner),
-        ExprKind::Block(ref block, _) => {
+        ExprKind::Box(inner) | ExprKind::AddrOf(_, _, inner) => is_self_shadow(name, inner),
+        ExprKind::Block(block, _) => {
             block.stmts.is_empty() && block.expr.as_ref().map_or(false, |e| is_self_shadow(name, e))
         },
-        ExprKind::Unary(op, ref inner) => (UnOp::Deref == op) && is_self_shadow(name, inner),
-        ExprKind::Path(QPath::Resolved(_, ref path)) => path_eq_name(name, path),
+        ExprKind::Unary(op, inner) => (UnOp::Deref == op) && is_self_shadow(name, inner),
+        ExprKind::Path(QPath::Resolved(_, path)) => path_eq_name(name, path),
         _ => false,
     }
 }
diff --git a/clippy_lints/src/slow_vector_initialization.rs b/clippy_lints/src/slow_vector_initialization.rs
index d55a83f1613..8cf89ae456e 100644
--- a/clippy_lints/src/slow_vector_initialization.rs
+++ b/clippy_lints/src/slow_vector_initialization.rs
@@ -70,14 +70,14 @@ impl<'tcx> LateLintPass<'tcx> for SlowVectorInit {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         // Matches initialization on reassignements. For example: `vec = Vec::with_capacity(100)`
         if_chain! {
-            if let ExprKind::Assign(ref left, ref right, _) = expr.kind;
+            if let ExprKind::Assign(left, right, _) = expr.kind;
 
             // Extract variable name
-            if let ExprKind::Path(QPath::Resolved(_, ref path)) = left.kind;
+            if let ExprKind::Path(QPath::Resolved(_, path)) = left.kind;
             if let Some(variable_name) = path.segments.get(0);
 
             // Extract len argument
-            if let Some(ref len_arg) = Self::is_vec_with_capacity(right);
+            if let Some(len_arg) = Self::is_vec_with_capacity(right);
 
             then {
                 let vi = VecAllocation {
@@ -94,10 +94,10 @@ impl<'tcx> LateLintPass<'tcx> for SlowVectorInit {
     fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) {
         // Matches statements which initializes vectors. For example: `let mut vec = Vec::with_capacity(10)`
         if_chain! {
-            if let StmtKind::Local(ref local) = stmt.kind;
+            if let StmtKind::Local(local) = stmt.kind;
             if let PatKind::Binding(BindingAnnotation::Mutable, .., variable_name, None) = local.pat.kind;
-            if let Some(ref init) = local.init;
-            if let Some(ref len_arg) = Self::is_vec_with_capacity(init);
+            if let Some(init) = local.init;
+            if let Some(len_arg) = Self::is_vec_with_capacity(init);
 
             then {
                 let vi = VecAllocation {
@@ -117,7 +117,7 @@ impl SlowVectorInit {
     /// of the first argument of `with_capacity` call if it matches or `None` if it does not.
     fn is_vec_with_capacity<'tcx>(expr: &Expr<'tcx>) -> Option<&'tcx Expr<'tcx>> {
         if_chain! {
-            if let ExprKind::Call(ref func, ref args) = expr.kind;
+            if let ExprKind::Call(func, args) = expr.kind;
             if let ExprKind::Path(ref path) = func.kind;
             if match_qpath(path, &["Vec", "with_capacity"]);
             if args.len() == 1;
@@ -208,11 +208,11 @@ impl<'a, 'tcx> VectorInitializationVisitor<'a, 'tcx> {
     fn search_slow_extend_filling(&mut self, expr: &'tcx Expr<'_>) {
         if_chain! {
             if self.initialization_found;
-            if let ExprKind::MethodCall(ref path, _, ref args, _) = expr.kind;
+            if let ExprKind::MethodCall(path, _, args, _) = expr.kind;
             if let ExprKind::Path(ref qpath_subj) = args[0].kind;
-            if match_qpath(&qpath_subj, &[&*self.vec_alloc.variable_name.as_str()]);
+            if match_qpath(qpath_subj, &[&*self.vec_alloc.variable_name.as_str()]);
             if path.ident.name == sym!(extend);
-            if let Some(ref extend_arg) = args.get(1);
+            if let Some(extend_arg) = args.get(1);
             if self.is_repeat_take(extend_arg);
 
             then {
@@ -225,11 +225,11 @@ impl<'a, 'tcx> VectorInitializationVisitor<'a, 'tcx> {
     fn search_slow_resize_filling(&mut self, expr: &'tcx Expr<'_>) {
         if_chain! {
             if self.initialization_found;
-            if let ExprKind::MethodCall(ref path, _, ref args, _) = expr.kind;
+            if let ExprKind::MethodCall(path, _, args, _) = expr.kind;
             if let ExprKind::Path(ref qpath_subj) = args[0].kind;
-            if match_qpath(&qpath_subj, &[&*self.vec_alloc.variable_name.as_str()]);
+            if match_qpath(qpath_subj, &[&*self.vec_alloc.variable_name.as_str()]);
             if path.ident.name == sym!(resize);
-            if let (Some(ref len_arg), Some(fill_arg)) = (args.get(1), args.get(2));
+            if let (Some(len_arg), Some(fill_arg)) = (args.get(1), args.get(2));
 
             // Check that is filled with 0
             if let ExprKind::Lit(ref lit) = fill_arg.kind;
@@ -247,15 +247,15 @@ impl<'a, 'tcx> VectorInitializationVisitor<'a, 'tcx> {
     /// Returns `true` if give expression is `repeat(0).take(...)`
     fn is_repeat_take(&self, expr: &Expr<'_>) -> bool {
         if_chain! {
-            if let ExprKind::MethodCall(ref take_path, _, ref take_args, _) = expr.kind;
+            if let ExprKind::MethodCall(take_path, _, take_args, _) = expr.kind;
             if take_path.ident.name == sym!(take);
 
             // Check that take is applied to `repeat(0)`
-            if let Some(ref repeat_expr) = take_args.get(0);
+            if let Some(repeat_expr) = take_args.get(0);
             if Self::is_repeat_zero(repeat_expr);
 
             // Check that len expression is equals to `with_capacity` expression
-            if let Some(ref len_arg) = take_args.get(1);
+            if let Some(len_arg) = take_args.get(1);
             if SpanlessEq::new(self.cx).eq_expr(len_arg, self.vec_alloc.len_expr);
 
             then {
@@ -269,10 +269,10 @@ impl<'a, 'tcx> VectorInitializationVisitor<'a, 'tcx> {
     /// Returns `true` if given expression is `repeat(0)`
     fn is_repeat_zero(expr: &Expr<'_>) -> bool {
         if_chain! {
-            if let ExprKind::Call(ref fn_expr, ref repeat_args) = expr.kind;
+            if let ExprKind::Call(fn_expr, repeat_args) = expr.kind;
             if let ExprKind::Path(ref qpath_repeat) = fn_expr.kind;
-            if match_qpath(&qpath_repeat, &["repeat"]);
-            if let Some(ref repeat_arg) = repeat_args.get(0);
+            if match_qpath(qpath_repeat, &["repeat"]);
+            if let Some(repeat_arg) = repeat_args.get(0);
             if let ExprKind::Lit(ref lit) = repeat_arg.kind;
             if let LitKind::Int(0, _) = lit.node;
 
@@ -291,7 +291,7 @@ impl<'a, 'tcx> Visitor<'tcx> for VectorInitializationVisitor<'a, 'tcx> {
     fn visit_stmt(&mut self, stmt: &'tcx Stmt<'_>) {
         if self.initialization_found {
             match stmt.kind {
-                StmtKind::Expr(ref expr) | StmtKind::Semi(ref expr) => {
+                StmtKind::Expr(expr) | StmtKind::Semi(expr) => {
                     self.search_slow_extend_filling(expr);
                     self.search_slow_resize_filling(expr);
                 },
@@ -306,7 +306,7 @@ impl<'a, 'tcx> Visitor<'tcx> for VectorInitializationVisitor<'a, 'tcx> {
 
     fn visit_block(&mut self, block: &'tcx Block<'_>) {
         if self.initialization_found {
-            if let Some(ref s) = block.stmts.get(0) {
+            if let Some(s) = block.stmts.get(0) {
                 self.visit_stmt(s)
             }
 
diff --git a/clippy_lints/src/strings.rs b/clippy_lints/src/strings.rs
index 99ca7ef77a5..9d91b53e1bb 100644
--- a/clippy_lints/src/strings.rs
+++ b/clippy_lints/src/strings.rs
@@ -119,7 +119,7 @@ impl<'tcx> LateLintPass<'tcx> for StringAdd {
             Spanned {
                 node: BinOpKind::Add, ..
             },
-            ref left,
+            left,
             _,
         ) = e.kind
         {
@@ -127,7 +127,7 @@ impl<'tcx> LateLintPass<'tcx> for StringAdd {
                 if !is_allowed(cx, STRING_ADD_ASSIGN, e.hir_id) {
                     let parent = get_parent_expr(cx, e);
                     if let Some(p) = parent {
-                        if let ExprKind::Assign(ref target, _, _) = p.kind {
+                        if let ExprKind::Assign(target, _, _) = p.kind {
                             // avoid duplicate matches
                             if SpanlessEq::new(cx).eq_expr(target, left) {
                                 return;
@@ -142,7 +142,7 @@ impl<'tcx> LateLintPass<'tcx> for StringAdd {
                     "you added something to a string. Consider using `String::push_str()` instead",
                 );
             }
-        } else if let ExprKind::Assign(ref target, ref src, _) = e.kind {
+        } else if let ExprKind::Assign(target, src, _) = e.kind {
             if is_string(cx, target) && is_add(cx, src, target) {
                 span_lint(
                     cx,
@@ -166,10 +166,10 @@ fn is_add(cx: &LateContext<'_>, src: &Expr<'_>, target: &Expr<'_>) -> bool {
             Spanned {
                 node: BinOpKind::Add, ..
             },
-            ref left,
+            left,
             _,
         ) => SpanlessEq::new(cx).eq_expr(target, left),
-        ExprKind::Block(ref block, _) => {
+        ExprKind::Block(block, _) => {
             block.stmts.is_empty() && block.expr.as_ref().map_or(false, |expr| is_add(cx, expr, target))
         },
         _ => false,
@@ -210,8 +210,8 @@ impl<'tcx> LateLintPass<'tcx> for StringLitAsBytes {
             if let Some(args) = match_function_call(cx, e, &paths::STR_FROM_UTF8);
 
             // Find string::as_bytes
-            if let ExprKind::AddrOf(BorrowKind::Ref, _, ref args) = args[0].kind;
-            if let ExprKind::Index(ref left, ref right) = args.kind;
+            if let ExprKind::AddrOf(BorrowKind::Ref, _, args) = args[0].kind;
+            if let ExprKind::Index(left, right) = args.kind;
             let (method_names, expressions, _) = method_calls(left, 1);
             if method_names.len() == 1;
             if expressions.len() == 1;
diff --git a/clippy_lints/src/suspicious_operation_groupings.rs b/clippy_lints/src/suspicious_operation_groupings.rs
index 46f423204a2..cb2237e5312 100644
--- a/clippy_lints/src/suspicious_operation_groupings.rs
+++ b/clippy_lints/src/suspicious_operation_groupings.rs
@@ -225,7 +225,7 @@ fn attempt_to_emit_no_difference_lint(
                     emit_suggestion(
                         cx,
                         binop.span,
-                        replace_left_sugg(cx, &binop, &sugg, &mut applicability),
+                        replace_left_sugg(cx, binop, &sugg, &mut applicability),
                         applicability,
                     );
                     return;
@@ -247,7 +247,7 @@ fn attempt_to_emit_no_difference_lint(
                     emit_suggestion(
                         cx,
                         binop.span,
-                        replace_right_sugg(cx, &binop, &sugg, &mut applicability),
+                        replace_right_sugg(cx, binop, &sugg, &mut applicability),
                         applicability,
                     );
                     return;
@@ -276,8 +276,8 @@ fn ident_swap_sugg(
     location: IdentLocation,
     applicability: &mut Applicability,
 ) -> Option<String> {
-    let left_ident = get_ident(&binop.left, location)?;
-    let right_ident = get_ident(&binop.right, location)?;
+    let left_ident = get_ident(binop.left, location)?;
+    let right_ident = get_ident(binop.right, location)?;
 
     let sugg = match (
         paired_identifiers.contains(&left_ident),
@@ -293,8 +293,7 @@ fn ident_swap_sugg(
             // ends up duplicating a clause, the `logic_bug` lint
             // should catch it.
 
-            let right_suggestion =
-                suggestion_with_swapped_ident(cx, &binop.right, location, left_ident, applicability)?;
+            let right_suggestion = suggestion_with_swapped_ident(cx, binop.right, location, left_ident, applicability)?;
 
             replace_right_sugg(cx, binop, &right_suggestion, applicability)
         },
@@ -302,15 +301,14 @@ fn ident_swap_sugg(
             // We haven't seen a pair involving the left one, so
             // it's probably what is wanted.
 
-            let right_suggestion =
-                suggestion_with_swapped_ident(cx, &binop.right, location, left_ident, applicability)?;
+            let right_suggestion = suggestion_with_swapped_ident(cx, binop.right, location, left_ident, applicability)?;
 
             replace_right_sugg(cx, binop, &right_suggestion, applicability)
         },
         (true, false) => {
             // We haven't seen a pair involving the right one, so
             // it's probably what is wanted.
-            let left_suggestion = suggestion_with_swapped_ident(cx, &binop.left, location, right_ident, applicability)?;
+            let left_suggestion = suggestion_with_swapped_ident(cx, binop.left, location, right_ident, applicability)?;
 
             replace_left_sugg(cx, binop, &left_suggestion, applicability)
         },
diff --git a/clippy_lints/src/swap.rs b/clippy_lints/src/swap.rs
index 14519eaa962..19967e2c970 100644
--- a/clippy_lints/src/swap.rs
+++ b/clippy_lints/src/swap.rs
@@ -78,26 +78,26 @@ fn check_manual_swap(cx: &LateContext<'_>, block: &Block<'_>) {
     for w in block.stmts.windows(3) {
         if_chain! {
             // let t = foo();
-            if let StmtKind::Local(ref tmp) = w[0].kind;
-            if let Some(ref tmp_init) = tmp.init;
+            if let StmtKind::Local(tmp) = w[0].kind;
+            if let Some(tmp_init) = tmp.init;
             if let PatKind::Binding(.., ident, None) = tmp.pat.kind;
 
             // foo() = bar();
-            if let StmtKind::Semi(ref first) = w[1].kind;
-            if let ExprKind::Assign(ref lhs1, ref rhs1, _) = first.kind;
+            if let StmtKind::Semi(first) = w[1].kind;
+            if let ExprKind::Assign(lhs1, rhs1, _) = first.kind;
 
             // bar() = t;
-            if let StmtKind::Semi(ref second) = w[2].kind;
-            if let ExprKind::Assign(ref lhs2, ref rhs2, _) = second.kind;
-            if let ExprKind::Path(QPath::Resolved(None, ref rhs2)) = rhs2.kind;
+            if let StmtKind::Semi(second) = w[2].kind;
+            if let ExprKind::Assign(lhs2, rhs2, _) = second.kind;
+            if let ExprKind::Path(QPath::Resolved(None, rhs2)) = rhs2.kind;
             if rhs2.segments.len() == 1;
 
             if ident.name == rhs2.segments[0].ident.name;
             if eq_expr_value(cx, tmp_init, lhs1);
             if eq_expr_value(cx, rhs1, lhs2);
             then {
-                if let ExprKind::Field(ref lhs1, _) = lhs1.kind {
-                    if let ExprKind::Field(ref lhs2, _) = lhs2.kind {
+                if let ExprKind::Field(lhs1, _) = lhs1.kind {
+                    if let ExprKind::Field(lhs2, _) = lhs2.kind {
                         if lhs1.hir_id.owner == lhs2.hir_id.owner {
                             return;
                         }
@@ -192,8 +192,8 @@ enum Slice<'a> {
 
 /// Checks if both expressions are index operations into "slice-like" types.
 fn check_for_slice<'a>(cx: &LateContext<'_>, lhs1: &'a Expr<'_>, lhs2: &'a Expr<'_>) -> Slice<'a> {
-    if let ExprKind::Index(ref lhs1, ref idx1) = lhs1.kind {
-        if let ExprKind::Index(ref lhs2, ref idx2) = lhs2.kind {
+    if let ExprKind::Index(lhs1, idx1) = lhs1.kind {
+        if let ExprKind::Index(lhs2, idx2) = lhs2.kind {
             if eq_expr_value(cx, lhs1, lhs2) {
                 let ty = cx.typeck_results().expr_ty(lhs1).peel_refs();
 
@@ -217,11 +217,11 @@ fn check_for_slice<'a>(cx: &LateContext<'_>, lhs1: &'a Expr<'_>, lhs2: &'a Expr<
 fn check_suspicious_swap(cx: &LateContext<'_>, block: &Block<'_>) {
     for w in block.stmts.windows(2) {
         if_chain! {
-            if let StmtKind::Semi(ref first) = w[0].kind;
-            if let StmtKind::Semi(ref second) = w[1].kind;
+            if let StmtKind::Semi(first) = w[0].kind;
+            if let StmtKind::Semi(second) = w[1].kind;
             if !differing_macro_contexts(first.span, second.span);
-            if let ExprKind::Assign(ref lhs0, ref rhs0, _) = first.kind;
-            if let ExprKind::Assign(ref lhs1, ref rhs1, _) = second.kind;
+            if let ExprKind::Assign(lhs0, rhs0, _) = first.kind;
+            if let ExprKind::Assign(lhs1, rhs1, _) = second.kind;
             if eq_expr_value(cx, lhs0, rhs1);
             if eq_expr_value(cx, lhs1, rhs0);
             then {
diff --git a/clippy_lints/src/tabs_in_doc_comments.rs b/clippy_lints/src/tabs_in_doc_comments.rs
index 88bd2feaadd..a0492a88f91 100644
--- a/clippy_lints/src/tabs_in_doc_comments.rs
+++ b/clippy_lints/src/tabs_in_doc_comments.rs
@@ -86,7 +86,7 @@ impl TabsInDocComments {
 
 impl EarlyLintPass for TabsInDocComments {
     fn check_attribute(&mut self, cx: &EarlyContext<'_>, attribute: &ast::Attribute) {
-        Self::warn_if_tabs_in_doc(cx, &attribute);
+        Self::warn_if_tabs_in_doc(cx, attribute);
     }
 }
 
diff --git a/clippy_lints/src/to_string_in_display.rs b/clippy_lints/src/to_string_in_display.rs
index 42ec14c31b5..ae05a8da37b 100644
--- a/clippy_lints/src/to_string_in_display.rs
+++ b/clippy_lints/src/to_string_in_display.rs
@@ -92,7 +92,7 @@ impl LateLintPass<'_> for ToStringInDisplay {
         if_chain! {
             if self.in_display_impl;
             if let Some(self_hir_id) = self.self_hir_id;
-            if let ExprKind::MethodCall(ref path, _, args, _) = expr.kind;
+            if let ExprKind::MethodCall(path, _, args, _) = expr.kind;
             if path.ident.name == sym!(to_string);
             if let Some(expr_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
             if is_diagnostic_assoc_item(cx, expr_def_id, sym::ToString);
diff --git a/clippy_lints/src/trait_bounds.rs b/clippy_lints/src/trait_bounds.rs
index 3ff27c3bcf4..b0589b0512e 100644
--- a/clippy_lints/src/trait_bounds.rs
+++ b/clippy_lints/src/trait_bounds.rs
@@ -107,7 +107,7 @@ impl TraitBounds {
                 if let WherePredicate::BoundPredicate(ref p) = bound;
                 if p.bounds.len() as u64 <= self.max_trait_bounds;
                 if !in_macro(p.span);
-                let h = hash(&p.bounded_ty);
+                let h = hash(p.bounded_ty);
                 if let Some(ref v) = map.insert(h, p.bounds.iter().collect::<Vec<_>>());
 
                 then {
@@ -170,7 +170,7 @@ fn check_trait_bound_duplication(cx: &LateContext<'_>, gen: &'_ Generics<'_>) {
         if_chain! {
             if let WherePredicate::BoundPredicate(ref bound_predicate) = predicate;
             if !in_macro(bound_predicate.span);
-            if let TyKind::Path(QPath::Resolved(_, Path { ref segments, .. })) = bound_predicate.bounded_ty.kind;
+            if let TyKind::Path(QPath::Resolved(_, Path { segments, .. })) = bound_predicate.bounded_ty.kind;
             if let Some(segment) = segments.first();
             if let Some(trait_resolutions_direct) = map.get(&segment.ident);
             then {
diff --git a/clippy_lints/src/transmute/mod.rs b/clippy_lints/src/transmute/mod.rs
index 47d58bd30db..86ac916df6c 100644
--- a/clippy_lints/src/transmute/mod.rs
+++ b/clippy_lints/src/transmute/mod.rs
@@ -325,7 +325,7 @@ impl<'tcx> LateLintPass<'tcx> for Transmute {
     #[allow(clippy::similar_names, clippy::too_many_lines)]
     fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
         if_chain! {
-            if let ExprKind::Call(ref path_expr, ref args) = e.kind;
+            if let ExprKind::Call(path_expr, args) = e.kind;
             if let ExprKind::Path(ref qpath) = path_expr.kind;
             if let Some(def_id) = cx.qpath_res(qpath, path_expr.hir_id).opt_def_id();
             if match_def_path(cx, def_id, &paths::TRANSMUTE);
diff --git a/clippy_lints/src/transmute/transmute_float_to_int.rs b/clippy_lints/src/transmute/transmute_float_to_int.rs
index 1a6124e9ddb..3aa3c393ba5 100644
--- a/clippy_lints/src/transmute/transmute_float_to_int.rs
+++ b/clippy_lints/src/transmute/transmute_float_to_int.rs
@@ -30,7 +30,7 @@ pub(super) fn check<'tcx>(
                     let mut arg = sugg::Sugg::hir(cx, expr, "..");
 
                     if let ExprKind::Unary(UnOp::Neg, inner_expr) = &expr.kind {
-                        expr = &inner_expr;
+                        expr = inner_expr;
                     }
 
                     if_chain! {
diff --git a/clippy_lints/src/transmute/utils.rs b/clippy_lints/src/transmute/utils.rs
index c6d0d63b0b5..f359b606e45 100644
--- a/clippy_lints/src/transmute/utils.rs
+++ b/clippy_lints/src/transmute/utils.rs
@@ -16,7 +16,7 @@ use rustc_typeck::check::{cast::CastCheck, FnCtxt, Inherited};
 pub(super) fn get_type_snippet(cx: &LateContext<'_>, path: &QPath<'_>, to_ref_ty: Ty<'_>) -> String {
     let seg = last_path_segment(path);
     if_chain! {
-        if let Some(ref params) = seg.args;
+        if let Some(params) = seg.args;
         if !params.parenthesized;
         if let Some(to_ty) = params.args.iter().filter_map(|arg| match arg {
             GenericArg::Type(ty) => Some(ty),
diff --git a/clippy_lints/src/transmuting_null.rs b/clippy_lints/src/transmuting_null.rs
index d42cdde110e..0be05d3e0cf 100644
--- a/clippy_lints/src/transmuting_null.rs
+++ b/clippy_lints/src/transmuting_null.rs
@@ -37,7 +37,7 @@ impl<'tcx> LateLintPass<'tcx> for TransmutingNull {
         }
 
         if_chain! {
-            if let ExprKind::Call(ref func, ref args) = expr.kind;
+            if let ExprKind::Call(func, args) = expr.kind;
             if let ExprKind::Path(ref path) = func.kind;
             if match_qpath(path, &paths::STD_MEM_TRANSMUTE);
             if args.len() == 1;
@@ -58,7 +58,7 @@ impl<'tcx> LateLintPass<'tcx> for TransmutingNull {
                 // Catching:
                 // `std::mem::transmute(0 as *const i32)`
                 if_chain! {
-                    if let ExprKind::Cast(ref inner_expr, ref _cast_ty) = args[0].kind;
+                    if let ExprKind::Cast(inner_expr, _cast_ty) = args[0].kind;
                     if let ExprKind::Lit(ref lit) = inner_expr.kind;
                     if let LitKind::Int(0, _) = lit.node;
                     then {
@@ -69,7 +69,7 @@ impl<'tcx> LateLintPass<'tcx> for TransmutingNull {
                 // Catching:
                 // `std::mem::transmute(std::ptr::null::<i32>())`
                 if_chain! {
-                    if let ExprKind::Call(ref func1, ref args1) = args[0].kind;
+                    if let ExprKind::Call(func1, args1) = args[0].kind;
                     if let ExprKind::Path(ref path1) = func1.kind;
                     if match_qpath(path1, &paths::STD_PTR_NULL);
                     if args1.is_empty();
diff --git a/clippy_lints/src/try_err.rs b/clippy_lints/src/try_err.rs
index e4799790d35..23a1953ffac 100644
--- a/clippy_lints/src/try_err.rs
+++ b/clippy_lints/src/try_err.rs
@@ -60,13 +60,13 @@ impl<'tcx> LateLintPass<'tcx> for TryErr {
         // };
         if_chain! {
             if !in_external_macro(cx.tcx.sess, expr.span);
-            if let ExprKind::Match(ref match_arg, _, MatchSource::TryDesugar) = expr.kind;
-            if let ExprKind::Call(ref match_fun, ref try_args) = match_arg.kind;
+            if let ExprKind::Match(match_arg, _, MatchSource::TryDesugar) = expr.kind;
+            if let ExprKind::Call(match_fun, try_args) = match_arg.kind;
             if let ExprKind::Path(ref match_fun_path) = match_fun.kind;
             if matches!(match_fun_path, QPath::LangItem(LangItem::TryIntoResult, _));
-            if let Some(ref try_arg) = try_args.get(0);
-            if let ExprKind::Call(ref err_fun, ref err_args) = try_arg.kind;
-            if let Some(ref err_arg) = err_args.get(0);
+            if let Some(try_arg) = try_args.get(0);
+            if let ExprKind::Call(err_fun, err_args) = try_arg.kind;
+            if let Some(err_arg) = err_args.get(0);
             if let ExprKind::Path(ref err_fun_path) = err_fun.kind;
             if match_qpath(err_fun_path, &paths::RESULT_ERR);
             if let Some(return_ty) = find_return_type(cx, &expr.kind);
@@ -123,9 +123,9 @@ impl<'tcx> LateLintPass<'tcx> for TryErr {
 
 /// Finds function return type by examining return expressions in match arms.
 fn find_return_type<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx ExprKind<'_>) -> Option<Ty<'tcx>> {
-    if let ExprKind::Match(_, ref arms, MatchSource::TryDesugar) = expr {
+    if let ExprKind::Match(_, arms, MatchSource::TryDesugar) = expr {
         for arm in arms.iter() {
-            if let ExprKind::Ret(Some(ref ret)) = arm.body.kind {
+            if let ExprKind::Ret(Some(ret)) = arm.body.kind {
                 return Some(cx.typeck_results().expr_ty(ret));
             }
         }
diff --git a/clippy_lints/src/types/borrowed_box.rs b/clippy_lints/src/types/borrowed_box.rs
index d68c6db4e23..1425d8f3f37 100644
--- a/clippy_lints/src/types/borrowed_box.rs
+++ b/clippy_lints/src/types/borrowed_box.rs
@@ -19,9 +19,9 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, lt: &Lifetime, m
             if_chain! {
                 if let Some(def_id) = def.opt_def_id();
                 if Some(def_id) == cx.tcx.lang_items().owned_box();
-                if let QPath::Resolved(None, ref path) = *qpath;
+                if let QPath::Resolved(None, path) = *qpath;
                 if let [ref bx] = *path.segments;
-                if let Some(ref params) = bx.args;
+                if let Some(params) = bx.args;
                 if !params.parenthesized;
                 if let Some(inner) = params.args.iter().find_map(|arg| match arg {
                     GenericArg::Type(ty) => Some(ty),
@@ -86,11 +86,11 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, lt: &Lifetime, m
 // Returns true if given type is `Any` trait.
 fn is_any_trait(t: &hir::Ty<'_>) -> bool {
     if_chain! {
-        if let TyKind::TraitObject(ref traits, ..) = t.kind;
+        if let TyKind::TraitObject(traits, ..) = t.kind;
         if !traits.is_empty();
         // Only Send/Sync can be used as additional traits, so it is enough to
         // check only the first trait.
-        if match_path(&traits[0].trait_ref.path, &paths::ANY_TRAIT);
+        if match_path(traits[0].trait_ref.path, &paths::ANY_TRAIT);
         then {
             return true;
         }
diff --git a/clippy_lints/src/types/mod.rs b/clippy_lints/src/types/mod.rs
index 12e1eba2ca6..d9b47a699dc 100644
--- a/clippy_lints/src/types/mod.rs
+++ b/clippy_lints/src/types/mod.rs
@@ -278,9 +278,7 @@ impl<'tcx> LateLintPass<'tcx> for Types {
 
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
         match item.kind {
-            ItemKind::Static(ref ty, _, _) | ItemKind::Const(ref ty, _) => {
-                self.check_ty(cx, ty, CheckTyContext::default())
-            },
+            ItemKind::Static(ty, _, _) | ItemKind::Const(ty, _) => self.check_ty(cx, ty, CheckTyContext::default()),
             // functions, enums, structs, impls and traits are covered
             _ => (),
         }
@@ -288,7 +286,7 @@ impl<'tcx> LateLintPass<'tcx> for Types {
 
     fn check_impl_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx ImplItem<'_>) {
         match item.kind {
-            ImplItemKind::Const(ref ty, _) | ImplItemKind::TyAlias(ref ty) => self.check_ty(
+            ImplItemKind::Const(ty, _) | ImplItemKind::TyAlias(ty) => self.check_ty(
                 cx,
                 ty,
                 CheckTyContext {
@@ -302,21 +300,21 @@ impl<'tcx> LateLintPass<'tcx> for Types {
     }
 
     fn check_field_def(&mut self, cx: &LateContext<'_>, field: &hir::FieldDef<'_>) {
-        self.check_ty(cx, &field.ty, CheckTyContext::default());
+        self.check_ty(cx, field.ty, CheckTyContext::default());
     }
 
     fn check_trait_item(&mut self, cx: &LateContext<'_>, item: &TraitItem<'_>) {
         match item.kind {
-            TraitItemKind::Const(ref ty, _) | TraitItemKind::Type(_, Some(ref ty)) => {
+            TraitItemKind::Const(ty, _) | TraitItemKind::Type(_, Some(ty)) => {
                 self.check_ty(cx, ty, CheckTyContext::default())
             },
-            TraitItemKind::Fn(ref sig, _) => self.check_fn_decl(cx, &sig.decl, CheckTyContext::default()),
+            TraitItemKind::Fn(ref sig, _) => self.check_fn_decl(cx, sig.decl, CheckTyContext::default()),
             TraitItemKind::Type(..) => (),
         }
     }
 
     fn check_local(&mut self, cx: &LateContext<'_>, local: &Local<'_>) {
-        if let Some(ref ty) = local.ty {
+        if let Some(ty) = local.ty {
             self.check_ty(
                 cx,
                 ty,
@@ -342,7 +340,7 @@ impl Types {
             self.check_ty(cx, input, context);
         }
 
-        if let FnRetTy::Return(ref ty) = decl.output {
+        if let FnRetTy::Return(ty) = decl.output {
             self.check_ty(cx, ty, context);
         }
     }
@@ -383,7 +381,7 @@ impl Types {
                     }
                 }
                 match *qpath {
-                    QPath::Resolved(Some(ref ty), ref p) => {
+                    QPath::Resolved(Some(ty), p) => {
                         context.is_nested_call = true;
                         self.check_ty(cx, ty, context);
                         for ty in p.segments.iter().flat_map(|seg| {
@@ -398,7 +396,7 @@ impl Types {
                             self.check_ty(cx, ty, context);
                         }
                     },
-                    QPath::Resolved(None, ref p) => {
+                    QPath::Resolved(None, p) => {
                         context.is_nested_call = true;
                         for ty in p.segments.iter().flat_map(|seg| {
                             seg.args
@@ -412,10 +410,10 @@ impl Types {
                             self.check_ty(cx, ty, context);
                         }
                     },
-                    QPath::TypeRelative(ref ty, ref seg) => {
+                    QPath::TypeRelative(ty, seg) => {
                         context.is_nested_call = true;
                         self.check_ty(cx, ty, context);
-                        if let Some(ref params) = seg.args {
+                        if let Some(params) = seg.args {
                             for ty in params.args.iter().filter_map(|arg| match arg {
                                 GenericArg::Type(ty) => Some(ty),
                                 _ => None,
@@ -430,10 +428,10 @@ impl Types {
             TyKind::Rptr(ref lt, ref mut_ty) => {
                 context.is_nested_call = true;
                 if !borrowed_box::check(cx, hir_ty, lt, mut_ty) {
-                    self.check_ty(cx, &mut_ty.ty, context);
+                    self.check_ty(cx, mut_ty.ty, context);
                 }
             },
-            TyKind::Slice(ref ty) | TyKind::Array(ref ty, _) | TyKind::Ptr(MutTy { ref ty, .. }) => {
+            TyKind::Slice(ty) | TyKind::Array(ty, _) | TyKind::Ptr(MutTy { ty, .. }) => {
                 context.is_nested_call = true;
                 self.check_ty(cx, ty, context)
             },
diff --git a/clippy_lints/src/types/type_complexity.rs b/clippy_lints/src/types/type_complexity.rs
index 9a4e9da3e2b..d8c4b67520d 100644
--- a/clippy_lints/src/types/type_complexity.rs
+++ b/clippy_lints/src/types/type_complexity.rs
@@ -48,9 +48,9 @@ impl<'tcx> Visitor<'tcx> for TypeComplexityVisitor {
             TyKind::Path(..) | TyKind::Slice(..) | TyKind::Tup(..) | TyKind::Array(..) => (10 * self.nest, 1),
 
             // function types bring a lot of overhead
-            TyKind::BareFn(ref bare) if bare.abi == Abi::Rust => (50 * self.nest, 1),
+            TyKind::BareFn(bare) if bare.abi == Abi::Rust => (50 * self.nest, 1),
 
-            TyKind::TraitObject(ref param_bounds, _, _) => {
+            TyKind::TraitObject(param_bounds, _, _) => {
                 let has_lifetime_parameters = param_bounds.iter().any(|bound| {
                     bound
                         .bound_generic_params
diff --git a/clippy_lints/src/types/utils.rs b/clippy_lints/src/types/utils.rs
index 45f891ed718..0fa75f8f0a9 100644
--- a/clippy_lints/src/types/utils.rs
+++ b/clippy_lints/src/types/utils.rs
@@ -7,7 +7,7 @@ use rustc_span::source_map::Span;
 pub(super) fn match_borrows_parameter(_cx: &LateContext<'_>, qpath: &QPath<'_>) -> Option<Span> {
     let last = last_path_segment(qpath);
     if_chain! {
-        if let Some(ref params) = last.args;
+        if let Some(params) = last.args;
         if !params.parenthesized;
         if let Some(ty) = params.args.iter().find_map(|arg| match arg {
             GenericArg::Type(ty) => Some(ty),
diff --git a/clippy_lints/src/types/vec_box.rs b/clippy_lints/src/types/vec_box.rs
index d2c373db261..7a444174626 100644
--- a/clippy_lints/src/types/vec_box.rs
+++ b/clippy_lints/src/types/vec_box.rs
@@ -22,7 +22,7 @@ pub(super) fn check(
     if cx.tcx.is_diagnostic_item(sym::vec_type, def_id) {
         if_chain! {
             // Get the _ part of Vec<_>
-            if let Some(ref last) = last_path_segment(qpath).args;
+            if let Some(last) = last_path_segment(qpath).args;
             if let Some(ty) = last.args.iter().find_map(|arg| match arg {
                 GenericArg::Type(ty) => Some(ty),
                 _ => None,
@@ -33,7 +33,7 @@ pub(super) fn check(
             if let Some(def_id) = res.opt_def_id();
             if Some(def_id) == cx.tcx.lang_items().owned_box();
             // At this point, we know ty is Box<T>, now get T
-            if let Some(ref last) = last_path_segment(ty_qpath).args;
+            if let Some(last) = last_path_segment(ty_qpath).args;
             if let Some(boxed_ty) = last.args.iter().find_map(|arg| match arg {
                 GenericArg::Type(ty) => Some(ty),
                 _ => None,
diff --git a/clippy_lints/src/undropped_manually_drops.rs b/clippy_lints/src/undropped_manually_drops.rs
index b6749069176..f4f5e1233e3 100644
--- a/clippy_lints/src/undropped_manually_drops.rs
+++ b/clippy_lints/src/undropped_manually_drops.rs
@@ -35,7 +35,7 @@ declare_lint_pass!(UndroppedManuallyDrops => [UNDROPPED_MANUALLY_DROPS]);
 
 impl LateLintPass<'tcx> for UndroppedManuallyDrops {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if let Some(ref args) = match_function_call(cx, expr, &paths::DROP) {
+        if let Some(args) = match_function_call(cx, expr, &paths::DROP) {
             let ty = cx.typeck_results().expr_ty(&args[0]);
             if is_type_lang_item(cx, ty, lang_items::LangItem::ManuallyDrop) {
                 span_lint_and_help(
diff --git a/clippy_lints/src/unit_return_expecting_ord.rs b/clippy_lints/src/unit_return_expecting_ord.rs
index cdc65abe47c..47b95b18ffb 100644
--- a/clippy_lints/src/unit_return_expecting_ord.rs
+++ b/clippy_lints/src/unit_return_expecting_ord.rs
@@ -138,7 +138,7 @@ fn check_arg<'tcx>(cx: &LateContext<'tcx>, arg: &'tcx Expr<'tcx>) -> Option<(Spa
 
 impl<'tcx> LateLintPass<'tcx> for UnitReturnExpectingOrd {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
-        if let ExprKind::MethodCall(_, _, ref args, _) = expr.kind {
+        if let ExprKind::MethodCall(_, _, args, _) = expr.kind {
             let arg_indices = get_args_to_check(cx, expr);
             for (i, trait_name) in arg_indices {
                 if i < args.len() {
diff --git a/clippy_lints/src/unit_types/let_unit_value.rs b/clippy_lints/src/unit_types/let_unit_value.rs
index 8698a718bbd..fad647dfb26 100644
--- a/clippy_lints/src/unit_types/let_unit_value.rs
+++ b/clippy_lints/src/unit_types/let_unit_value.rs
@@ -9,8 +9,8 @@ use rustc_middle::lint::in_external_macro;
 use super::LET_UNIT_VALUE;
 
 pub(super) fn check(cx: &LateContext<'_>, stmt: &Stmt<'_>) {
-    if let StmtKind::Local(ref local) = stmt.kind {
-        if cx.typeck_results().pat_ty(&local.pat).is_unit() {
+    if let StmtKind::Local(local) = stmt.kind {
+        if cx.typeck_results().pat_ty(local.pat).is_unit() {
             if in_external_macro(cx.sess(), stmt.span) || local.pat.span.from_expansion() {
                 return;
             }
diff --git a/clippy_lints/src/unit_types/unit_arg.rs b/clippy_lints/src/unit_types/unit_arg.rs
index f77d811c283..57be2d2f674 100644
--- a/clippy_lints/src/unit_types/unit_arg.rs
+++ b/clippy_lints/src/unit_types/unit_arg.rs
@@ -54,7 +54,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>) {
 
 fn is_questionmark_desugar_marked_call(expr: &Expr<'_>) -> bool {
     use rustc_span::hygiene::DesugaringKind;
-    if let ExprKind::Call(ref callee, _) = expr.kind {
+    if let ExprKind::Call(callee, _) = expr.kind {
         callee.span.is_desugaring(DesugaringKind::QuestionMark)
     } else {
         false
diff --git a/clippy_lints/src/unit_types/unit_cmp.rs b/clippy_lints/src/unit_types/unit_cmp.rs
index b3077dec5d8..85257f3113c 100644
--- a/clippy_lints/src/unit_types/unit_cmp.rs
+++ b/clippy_lints/src/unit_types/unit_cmp.rs
@@ -9,7 +9,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>) {
     if expr.span.from_expansion() {
         if let Some(callee) = expr.span.source_callee() {
             if let ExpnKind::Macro(MacroKind::Bang, symbol) = callee.kind {
-                if let ExprKind::Binary(ref cmp, ref left, _) = expr.kind {
+                if let ExprKind::Binary(ref cmp, left, _) = expr.kind {
                     let op = cmp.node;
                     if op.is_comparison() && cx.typeck_results().expr_ty(left).is_unit() {
                         let result = match &*symbol.as_str() {
@@ -34,7 +34,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>) {
         return;
     }
 
-    if let ExprKind::Binary(ref cmp, ref left, _) = expr.kind {
+    if let ExprKind::Binary(ref cmp, left, _) = expr.kind {
         let op = cmp.node;
         if op.is_comparison() && cx.typeck_results().expr_ty(left).is_unit() {
             let result = match op {
diff --git a/clippy_lints/src/unit_types/utils.rs b/clippy_lints/src/unit_types/utils.rs
index 4e194a05e8d..9a3750b2356 100644
--- a/clippy_lints/src/unit_types/utils.rs
+++ b/clippy_lints/src/unit_types/utils.rs
@@ -1,5 +1,5 @@
 use rustc_hir::{Expr, ExprKind};
 
 pub(super) fn is_unit_literal(expr: &Expr<'_>) -> bool {
-    matches!(expr.kind, ExprKind::Tup(ref slice) if slice.is_empty())
+    matches!(expr.kind, ExprKind::Tup(slice) if slice.is_empty())
 }
diff --git a/clippy_lints/src/unnamed_address.rs b/clippy_lints/src/unnamed_address.rs
index 9ceb2c3ffe2..9cca05b1f1a 100644
--- a/clippy_lints/src/unnamed_address.rs
+++ b/clippy_lints/src/unnamed_address.rs
@@ -77,7 +77,7 @@ impl LateLintPass<'_> for UnnamedAddress {
         }
 
         if_chain! {
-            if let ExprKind::Binary(binop, ref left, ref right) = expr.kind;
+            if let ExprKind::Binary(binop, left, right) = expr.kind;
             if is_comparison(binop.node);
             if is_trait_ptr(cx, left) && is_trait_ptr(cx, right);
             then {
@@ -93,7 +93,7 @@ impl LateLintPass<'_> for UnnamedAddress {
         }
 
         if_chain! {
-            if let ExprKind::Call(ref func, [ref _left, ref _right]) = expr.kind;
+            if let ExprKind::Call(func, [ref _left, ref _right]) = expr.kind;
             if let ExprKind::Path(ref func_qpath) = func.kind;
             if let Some(def_id) = cx.qpath_res(func_qpath, func.hir_id).opt_def_id();
             if match_def_path(cx, def_id, &paths::PTR_EQ) ||
@@ -114,7 +114,7 @@ impl LateLintPass<'_> for UnnamedAddress {
         }
 
         if_chain! {
-            if let ExprKind::Binary(binop, ref left, ref right) = expr.kind;
+            if let ExprKind::Binary(binop, left, right) = expr.kind;
             if is_comparison(binop.node);
             if cx.typeck_results().expr_ty_adjusted(left).is_fn_ptr();
             if cx.typeck_results().expr_ty_adjusted(right).is_fn_ptr();
diff --git a/clippy_lints/src/unnecessary_sort_by.rs b/clippy_lints/src/unnecessary_sort_by.rs
index e23bab5eba0..03711eb5b65 100644
--- a/clippy_lints/src/unnecessary_sort_by.rs
+++ b/clippy_lints/src/unnecessary_sort_by.rs
@@ -187,15 +187,15 @@ fn detect_lint(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<LintTrigger> {
         if method_path.ident.name == sym::cmp;
         then {
             let (closure_body, closure_arg, reverse) = if mirrored_exprs(
-                &cx,
-                &left_expr,
-                &left_ident,
-                &right_expr,
-                &right_ident
+                cx,
+                left_expr,
+                left_ident,
+                right_expr,
+                right_ident
             ) {
-                (Sugg::hir(cx, &left_expr, "..").to_string(), left_ident.name.to_string(), false)
-            } else if mirrored_exprs(&cx, &left_expr, &right_ident, &right_expr, &left_ident) {
-                (Sugg::hir(cx, &left_expr, "..").to_string(), right_ident.name.to_string(), true)
+                (Sugg::hir(cx, left_expr, "..").to_string(), left_ident.name.to_string(), false)
+            } else if mirrored_exprs(cx, left_expr, right_ident, right_expr, left_ident) {
+                (Sugg::hir(cx, left_expr, "..").to_string(), right_ident.name.to_string(), true)
             } else {
                 return None;
             };
diff --git a/clippy_lints/src/unnecessary_wraps.rs b/clippy_lints/src/unnecessary_wraps.rs
index c2be457e9dc..5bb417cb1be 100644
--- a/clippy_lints/src/unnecessary_wraps.rs
+++ b/clippy_lints/src/unnecessary_wraps.rs
@@ -103,7 +103,7 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryWraps {
             if_chain! {
                 if !in_macro(ret_expr.span);
                 // Check if a function call.
-                if let ExprKind::Call(ref func, ref args) = ret_expr.kind;
+                if let ExprKind::Call(func, args) = ret_expr.kind;
                 // Get the Path of the function call.
                 if let ExprKind::Path(ref qpath) = func.kind;
                 // Check if OPTION_SOME or RESULT_OK, depending on return type.
diff --git a/clippy_lints/src/unused_io_amount.rs b/clippy_lints/src/unused_io_amount.rs
index 9990052e114..024ab03fd41 100644
--- a/clippy_lints/src/unused_io_amount.rs
+++ b/clippy_lints/src/unused_io_amount.rs
@@ -36,13 +36,13 @@ declare_lint_pass!(UnusedIoAmount => [UNUSED_IO_AMOUNT]);
 impl<'tcx> LateLintPass<'tcx> for UnusedIoAmount {
     fn check_stmt(&mut self, cx: &LateContext<'_>, s: &hir::Stmt<'_>) {
         let expr = match s.kind {
-            hir::StmtKind::Semi(ref expr) | hir::StmtKind::Expr(ref expr) => &**expr,
+            hir::StmtKind::Semi(expr) | hir::StmtKind::Expr(expr) => expr,
             _ => return,
         };
 
         match expr.kind {
-            hir::ExprKind::Match(ref res, _, _) if is_try(expr).is_some() => {
-                if let hir::ExprKind::Call(ref func, ref args) = res.kind {
+            hir::ExprKind::Match(res, _, _) if is_try(expr).is_some() => {
+                if let hir::ExprKind::Call(func, args) = res.kind {
                     if matches!(
                         func.kind,
                         hir::ExprKind::Path(hir::QPath::LangItem(hir::LangItem::TryIntoResult, _))
@@ -54,7 +54,7 @@ impl<'tcx> LateLintPass<'tcx> for UnusedIoAmount {
                 }
             },
 
-            hir::ExprKind::MethodCall(ref path, _, ref args, _) => match &*path.ident.as_str() {
+            hir::ExprKind::MethodCall(path, _, args, _) => match &*path.ident.as_str() {
                 "expect" | "unwrap" | "unwrap_or" | "unwrap_or_else" => {
                     check_method_call(cx, &args[0], expr);
                 },
@@ -67,7 +67,7 @@ impl<'tcx> LateLintPass<'tcx> for UnusedIoAmount {
 }
 
 fn check_method_call(cx: &LateContext<'_>, call: &hir::Expr<'_>, expr: &hir::Expr<'_>) {
-    if let hir::ExprKind::MethodCall(ref path, _, _, _) = call.kind {
+    if let hir::ExprKind::MethodCall(path, _, _, _) = call.kind {
         let symbol = &*path.ident.as_str();
         let read_trait = match_trait_method(cx, call, &paths::IO_READ);
         let write_trait = match_trait_method(cx, call, &paths::IO_WRITE);
diff --git a/clippy_lints/src/unused_unit.rs b/clippy_lints/src/unused_unit.rs
index 329ea49024b..ce2d0b3ab2f 100644
--- a/clippy_lints/src/unused_unit.rs
+++ b/clippy_lints/src/unused_unit.rs
@@ -45,7 +45,7 @@ impl EarlyLintPass for UnusedUnit {
 
     fn check_block(&mut self, cx: &EarlyContext<'_>, block: &ast::Block) {
         if_chain! {
-            if let Some(ref stmt) = block.stmts.last();
+            if let Some(stmt) = block.stmts.last();
             if let ast::StmtKind::Expr(ref expr) = stmt.kind;
             if is_unit_expr(expr) && !stmt.span.from_expansion();
             then {
diff --git a/clippy_lints/src/unwrap.rs b/clippy_lints/src/unwrap.rs
index fb29acca18a..d4efee56eff 100644
--- a/clippy_lints/src/unwrap.rs
+++ b/clippy_lints/src/unwrap.rs
@@ -166,8 +166,8 @@ impl<'a, 'tcx> Visitor<'tcx> for UnwrappableVariablesVisitor<'a, 'tcx> {
         } else {
             // find `unwrap[_err]()` calls:
             if_chain! {
-                if let ExprKind::MethodCall(ref method_name, _, ref args, _) = expr.kind;
-                if let ExprKind::Path(QPath::Resolved(None, ref path)) = args[0].kind;
+                if let ExprKind::MethodCall(method_name, _, args, _) = expr.kind;
+                if let ExprKind::Path(QPath::Resolved(None, path)) = args[0].kind;
                 if [sym::unwrap, sym!(unwrap_err)].contains(&method_name.ident.name);
                 let call_to_unwrap = method_name.ident.name == sym::unwrap;
                 if let Some(unwrappable) = self.unwrappables.iter()
diff --git a/clippy_lints/src/use_self.rs b/clippy_lints/src/use_self.rs
index 116cb8b1e1c..c6a3c58a9a2 100644
--- a/clippy_lints/src/use_self.rs
+++ b/clippy_lints/src/use_self.rs
@@ -104,7 +104,7 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
                 of_trait,
                 ..
             }) => {
-                let should_check = if let TyKind::Path(QPath::Resolved(_, ref item_path)) = hir_self_ty.kind {
+                let should_check = if let TyKind::Path(QPath::Resolved(_, item_path)) = hir_self_ty.kind {
                     let parameters = &item_path.segments.last().expect(SEGMENTS_MSG).args;
                     parameters.as_ref().map_or(true, |params| {
                         !params.parenthesized && !params.args.iter().any(|arg| matches!(arg, GenericArg::Lifetime(_)))
@@ -197,7 +197,7 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
                 for (impl_hir_ty, trait_sem_ty) in impl_inputs_outputs.zip(trait_method_sig.inputs_and_output) {
                     if trait_sem_ty.walk().any(|inner| inner == self_ty.into()) {
                         let mut visitor = SkipTyCollector::default();
-                        visitor.visit_ty(&impl_hir_ty);
+                        visitor.visit_ty(impl_hir_ty);
                         types_to_skip.extend(visitor.types_to_skip);
                     }
                 }
@@ -333,7 +333,7 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
                 // unit enum variants (`Enum::A`)
                 ExprKind::Path(qpath) => {
                     if expr_ty_matches(cx, expr, self_ty) {
-                        span_lint_on_qpath_resolved(cx, &qpath, true);
+                        span_lint_on_qpath_resolved(cx, qpath, true);
                     }
                 },
                 _ => (),
diff --git a/clippy_lints/src/useless_conversion.rs b/clippy_lints/src/useless_conversion.rs
index d893b271a20..7edb280be73 100644
--- a/clippy_lints/src/useless_conversion.rs
+++ b/clippy_lints/src/useless_conversion.rs
@@ -53,17 +53,17 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
         }
 
         match e.kind {
-            ExprKind::Match(_, ref arms, MatchSource::TryDesugar) => {
+            ExprKind::Match(_, arms, MatchSource::TryDesugar) => {
                 let e = match arms[0].body.kind {
-                    ExprKind::Ret(Some(ref e)) | ExprKind::Break(_, Some(ref e)) => e,
+                    ExprKind::Ret(Some(e)) | ExprKind::Break(_, Some(e)) => e,
                     _ => return,
                 };
-                if let ExprKind::Call(_, ref args) = e.kind {
+                if let ExprKind::Call(_, args) = e.kind {
                     self.try_desugar_arm.push(args[0].hir_id);
                 }
             },
 
-            ExprKind::MethodCall(ref name, .., ref args, _) => {
+            ExprKind::MethodCall(name, .., args, _) => {
                 if match_trait_method(cx, e, &paths::INTO) && &*name.ident.as_str() == "into" {
                     let a = cx.typeck_results().expr_ty(e);
                     let b = cx.typeck_results().expr_ty(&args[0]);
@@ -82,7 +82,7 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
                 }
                 if match_trait_method(cx, e, &paths::INTO_ITERATOR) && name.ident.name == sym::into_iter {
                     if let Some(parent_expr) = get_parent_expr(cx, e) {
-                        if let ExprKind::MethodCall(ref parent_name, ..) = parent_expr.kind {
+                        if let ExprKind::MethodCall(parent_name, ..) = parent_expr.kind {
                             if parent_name.ident.name != sym::into_iter {
                                 return;
                             }
@@ -124,7 +124,7 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
                 }
             },
 
-            ExprKind::Call(ref path, ref args) => {
+            ExprKind::Call(path, args) => {
                 if_chain! {
                     if args.len() == 1;
                     if let ExprKind::Path(ref qpath) = path.kind;
diff --git a/clippy_lints/src/utils/author.rs b/clippy_lints/src/utils/author.rs
index a92c987014f..e70f8a09ebe 100644
--- a/clippy_lints/src/utils/author.rs
+++ b/clippy_lints/src/utils/author.rs
@@ -203,13 +203,13 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor {
         print!("    if let ExprKind::");
         let current = format!("{}.kind", self.current);
         match expr.kind {
-            ExprKind::Box(ref inner) => {
+            ExprKind::Box(inner) => {
                 let inner_pat = self.next("inner");
                 println!("Box(ref {}) = {};", inner_pat, current);
                 self.current = inner_pat;
                 self.visit_expr(inner);
             },
-            ExprKind::Array(ref elements) => {
+            ExprKind::Array(elements) => {
                 let elements_pat = self.next("elements");
                 println!("Array(ref {}) = {};", elements_pat, current);
                 println!("    if {}.len() == {};", elements_pat, elements.len());
@@ -218,7 +218,7 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor {
                     self.visit_expr(element);
                 }
             },
-            ExprKind::Call(ref func, ref args) => {
+            ExprKind::Call(func, args) => {
                 let func_pat = self.next("func");
                 let args_pat = self.next("args");
                 println!("Call(ref {}, ref {}) = {};", func_pat, args_pat, current);
@@ -230,14 +230,14 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor {
                     self.visit_expr(arg);
                 }
             },
-            ExprKind::MethodCall(ref _method_name, ref _generics, ref _args, ref _fn_span) => {
+            ExprKind::MethodCall(_method_name, ref _generics, _args, ref _fn_span) => {
                 println!(
                     "MethodCall(ref method_name, ref generics, ref args, ref fn_span) = {};",
                     current
                 );
                 println!("    // unimplemented: `ExprKind::MethodCall` is not further destructured at the moment");
             },
-            ExprKind::Tup(ref elements) => {
+            ExprKind::Tup(elements) => {
                 let elements_pat = self.next("elements");
                 println!("Tup(ref {}) = {};", elements_pat, current);
                 println!("    if {}.len() == {};", elements_pat, elements.len());
@@ -246,7 +246,7 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor {
                     self.visit_expr(element);
                 }
             },
-            ExprKind::Binary(ref op, ref left, ref right) => {
+            ExprKind::Binary(ref op, left, right) => {
                 let op_pat = self.next("op");
                 let left_pat = self.next("left");
                 let right_pat = self.next("right");
@@ -260,7 +260,7 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor {
                 self.current = right_pat;
                 self.visit_expr(right);
             },
-            ExprKind::Unary(ref op, ref inner) => {
+            ExprKind::Unary(ref op, inner) => {
                 let inner_pat = self.next("inner");
                 println!("Unary(UnOp::{:?}, ref {}) = {};", op, inner_pat, current);
                 self.current = inner_pat;
@@ -296,7 +296,7 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor {
                     },
                 }
             },
-            ExprKind::Cast(ref expr, ref ty) => {
+            ExprKind::Cast(expr, ty) => {
                 let cast_pat = self.next("expr");
                 let cast_ty = self.next("cast_ty");
                 let qp_label = self.next("qp");
@@ -310,13 +310,13 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor {
                 self.current = cast_pat;
                 self.visit_expr(expr);
             },
-            ExprKind::Type(ref expr, ref _ty) => {
+            ExprKind::Type(expr, _ty) => {
                 let cast_pat = self.next("expr");
                 println!("Type(ref {}, _) = {};", cast_pat, current);
                 self.current = cast_pat;
                 self.visit_expr(expr);
             },
-            ExprKind::Loop(ref body, _, desugaring, _) => {
+            ExprKind::Loop(body, _, desugaring, _) => {
                 let body_pat = self.next("body");
                 let des = loop_desugaring_name(desugaring);
                 let label_pat = self.next("label");
@@ -324,10 +324,10 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor {
                 self.current = body_pat;
                 self.visit_block(body);
             },
-            ExprKind::If(ref cond, ref then, ref opt_else) => {
+            ExprKind::If(cond, then, ref opt_else) => {
                 let cond_pat = self.next("cond");
                 let then_pat = self.next("then");
-                if let Some(ref else_) = *opt_else {
+                if let Some(else_) = *opt_else {
                     let else_pat = self.next("else_");
                     println!(
                         "If(ref {}, ref {}, Some(ref {})) = {};",
@@ -343,7 +343,7 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor {
                 self.current = then_pat;
                 self.visit_expr(then);
             },
-            ExprKind::Match(ref expr, ref arms, desugaring) => {
+            ExprKind::Match(expr, arms, desugaring) => {
                 let des = desugaring_name(desugaring);
                 let expr_pat = self.next("expr");
                 let arms_pat = self.next("arms");
@@ -353,18 +353,18 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor {
                 println!("    if {}.len() == {};", arms_pat, arms.len());
                 for (i, arm) in arms.iter().enumerate() {
                     self.current = format!("{}[{}].body", arms_pat, i);
-                    self.visit_expr(&arm.body);
+                    self.visit_expr(arm.body);
                     if let Some(ref guard) = arm.guard {
                         let guard_pat = self.next("guard");
                         println!("    if let Some(ref {}) = {}[{}].guard;", guard_pat, arms_pat, i);
                         match guard {
-                            hir::Guard::If(ref if_expr) => {
+                            hir::Guard::If(if_expr) => {
                                 let if_expr_pat = self.next("expr");
                                 println!("    if let Guard::If(ref {}) = {};", if_expr_pat, guard_pat);
                                 self.current = if_expr_pat;
                                 self.visit_expr(if_expr);
                             },
-                            hir::Guard::IfLet(ref if_let_pat, ref if_let_expr) => {
+                            hir::Guard::IfLet(if_let_pat, if_let_expr) => {
                                 let if_let_pat_pat = self.next("pat");
                                 let if_let_expr_pat = self.next("expr");
                                 println!(
@@ -379,26 +379,26 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor {
                         }
                     }
                     self.current = format!("{}[{}].pat", arms_pat, i);
-                    self.visit_pat(&arm.pat);
+                    self.visit_pat(arm.pat);
                 }
             },
-            ExprKind::Closure(ref _capture_clause, ref _func, _, _, _) => {
+            ExprKind::Closure(ref _capture_clause, _func, _, _, _) => {
                 println!("Closure(ref capture_clause, ref func, _, _, _) = {};", current);
                 println!("    // unimplemented: `ExprKind::Closure` is not further destructured at the moment");
             },
-            ExprKind::Yield(ref sub, _) => {
+            ExprKind::Yield(sub, _) => {
                 let sub_pat = self.next("sub");
                 println!("Yield(ref sub) = {};", current);
                 self.current = sub_pat;
                 self.visit_expr(sub);
             },
-            ExprKind::Block(ref block, _) => {
+            ExprKind::Block(block, _) => {
                 let block_pat = self.next("block");
                 println!("Block(ref {}) = {};", block_pat, current);
                 self.current = block_pat;
                 self.visit_block(block);
             },
-            ExprKind::Assign(ref target, ref value, _) => {
+            ExprKind::Assign(target, value, _) => {
                 let target_pat = self.next("target");
                 let value_pat = self.next("value");
                 println!(
@@ -410,7 +410,7 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor {
                 self.current = value_pat;
                 self.visit_expr(value);
             },
-            ExprKind::AssignOp(ref op, ref target, ref value) => {
+            ExprKind::AssignOp(ref op, target, value) => {
                 let op_pat = self.next("op");
                 let target_pat = self.next("target");
                 let value_pat = self.next("value");
@@ -424,7 +424,7 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor {
                 self.current = value_pat;
                 self.visit_expr(value);
             },
-            ExprKind::Field(ref object, ref field_ident) => {
+            ExprKind::Field(object, ref field_ident) => {
                 let obj_pat = self.next("object");
                 let field_name_pat = self.next("field_name");
                 println!("Field(ref {}, ref {}) = {};", obj_pat, field_name_pat, current);
@@ -432,7 +432,7 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor {
                 self.current = obj_pat;
                 self.visit_expr(object);
             },
-            ExprKind::Index(ref object, ref index) => {
+            ExprKind::Index(object, index) => {
                 let object_pat = self.next("object");
                 let index_pat = self.next("index");
                 println!("Index(ref {}, ref {}) = {};", object_pat, index_pat, current);
@@ -447,7 +447,7 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor {
                 self.current = path_pat;
                 self.print_qpath(path);
             },
-            ExprKind::AddrOf(kind, mutability, ref inner) => {
+            ExprKind::AddrOf(kind, mutability, inner) => {
                 let inner_pat = self.next("inner");
                 println!(
                     "AddrOf(BorrowKind::{:?}, Mutability::{:?}, ref {}) = {};",
@@ -458,7 +458,7 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor {
             },
             ExprKind::Break(ref _destination, ref opt_value) => {
                 let destination_pat = self.next("destination");
-                if let Some(ref value) = *opt_value {
+                if let Some(value) = *opt_value {
                     let value_pat = self.next("value");
                     println!("Break(ref {}, Some(ref {})) = {};", destination_pat, value_pat, current);
                     self.current = value_pat;
@@ -474,7 +474,7 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor {
                 // FIXME: implement label printing
             },
             ExprKind::Ret(ref opt_value) => {
-                if let Some(ref value) = *opt_value {
+                if let Some(value) = *opt_value {
                     let value_pat = self.next("value");
                     println!("Ret(Some(ref {})) = {};", value_pat, current);
                     self.current = value_pat;
@@ -491,10 +491,10 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor {
                 println!("LlvmInlineAsm(_) = {};", current);
                 println!("    // unimplemented: `ExprKind::LlvmInlineAsm` is not further destructured at the moment");
             },
-            ExprKind::Struct(ref path, ref fields, ref opt_base) => {
+            ExprKind::Struct(path, fields, ref opt_base) => {
                 let path_pat = self.next("path");
                 let fields_pat = self.next("fields");
-                if let Some(ref base) = *opt_base {
+                if let Some(base) = *opt_base {
                     let base_pat = self.next("base");
                     println!(
                         "Struct(ref {}, ref {}, Some(ref {})) = {};",
@@ -516,7 +516,7 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor {
                 self.current = value_pat;
             },
             // FIXME: compute length (needs type info)
-            ExprKind::Repeat(ref value, _) => {
+            ExprKind::Repeat(value, _) => {
                 let value_pat = self.next("value");
                 println!("Repeat(ref {}, _) = {};", value_pat, current);
                 println!("// unimplemented: repeat count check");
@@ -526,7 +526,7 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor {
             ExprKind::Err => {
                 println!("Err = {}", current);
             },
-            ExprKind::DropTemps(ref expr) => {
+            ExprKind::DropTemps(expr) => {
                 let expr_pat = self.next("expr");
                 println!("DropTemps(ref {}) = {};", expr_pat, current);
                 self.current = expr_pat;
@@ -560,7 +560,7 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor {
                     BindingAnnotation::RefMut => "BindingAnnotation::RefMut",
                 };
                 let name_pat = self.next("name");
-                if let Some(ref sub) = *sub {
+                if let Some(sub) = *sub {
                     let sub_pat = self.next("sub");
                     println!(
                         "Binding({}, _, {}, Some(ref {})) = {};",
@@ -573,7 +573,7 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor {
                 }
                 println!("    if {}.as_str() == \"{}\";", name_pat, ident.as_str());
             },
-            PatKind::Struct(ref path, ref fields, ignore) => {
+            PatKind::Struct(ref path, fields, ignore) => {
                 let path_pat = self.next("path");
                 let fields_pat = self.next("fields");
                 println!(
@@ -585,13 +585,13 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor {
                 println!("    if {}.len() == {};", fields_pat, fields.len());
                 println!("    // unimplemented: field checks");
             },
-            PatKind::Or(ref fields) => {
+            PatKind::Or(fields) => {
                 let fields_pat = self.next("fields");
                 println!("Or(ref {}) = {};", fields_pat, current);
                 println!("    if {}.len() == {};", fields_pat, fields.len());
                 println!("    // unimplemented: field checks");
             },
-            PatKind::TupleStruct(ref path, ref fields, skip_pos) => {
+            PatKind::TupleStruct(ref path, fields, skip_pos) => {
                 let path_pat = self.next("path");
                 let fields_pat = self.next("fields");
                 println!(
@@ -609,25 +609,25 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor {
                 self.current = path_pat;
                 self.print_qpath(path);
             },
-            PatKind::Tuple(ref fields, skip_pos) => {
+            PatKind::Tuple(fields, skip_pos) => {
                 let fields_pat = self.next("fields");
                 println!("Tuple(ref {}, {:?}) = {};", fields_pat, skip_pos, current);
                 println!("    if {}.len() == {};", fields_pat, fields.len());
                 println!("    // unimplemented: field checks");
             },
-            PatKind::Box(ref pat) => {
+            PatKind::Box(pat) => {
                 let pat_pat = self.next("pat");
                 println!("Box(ref {}) = {};", pat_pat, current);
                 self.current = pat_pat;
                 self.visit_pat(pat);
             },
-            PatKind::Ref(ref pat, muta) => {
+            PatKind::Ref(pat, muta) => {
                 let pat_pat = self.next("pat");
                 println!("Ref(ref {}, Mutability::{:?}) = {};", pat_pat, muta, current);
                 self.current = pat_pat;
                 self.visit_pat(pat);
             },
-            PatKind::Lit(ref lit_expr) => {
+            PatKind::Lit(lit_expr) => {
                 let lit_expr_pat = self.next("lit_expr");
                 println!("Lit(ref {}) = {}", lit_expr_pat, current);
                 self.current = lit_expr_pat;
@@ -645,10 +645,10 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor {
                 self.current = end_pat;
                 walk_list!(self, visit_expr, end);
             },
-            PatKind::Slice(ref start, ref middle, ref end) => {
+            PatKind::Slice(start, ref middle, end) => {
                 let start_pat = self.next("start");
                 let end_pat = self.next("end");
-                if let Some(ref middle) = middle {
+                if let Some(middle) = middle {
                     let middle_pat = self.next("middle");
                     println!(
                         "Slice(ref {}, Some(ref {}), ref {}) = {};",
@@ -678,17 +678,17 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor {
         let current = format!("{}.kind", self.current);
         match s.kind {
             // A local (let) binding:
-            StmtKind::Local(ref local) => {
+            StmtKind::Local(local) => {
                 let local_pat = self.next("local");
                 println!("Local(ref {}) = {};", local_pat, current);
-                if let Some(ref init) = local.init {
+                if let Some(init) = local.init {
                     let init_pat = self.next("init");
                     println!("    if let Some(ref {}) = {}.init;", init_pat, local_pat);
                     self.current = init_pat;
                     self.visit_expr(init);
                 }
                 self.current = format!("{}.pat", local_pat);
-                self.visit_pat(&local.pat);
+                self.visit_pat(local.pat);
             },
             // An item binding:
             StmtKind::Item(_) => {
@@ -696,7 +696,7 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor {
             },
 
             // Expr without trailing semi-colon (must have unit type):
-            StmtKind::Expr(ref e) => {
+            StmtKind::Expr(e) => {
                 let e_pat = self.next("e");
                 println!("Expr(ref {}, _) = {}", e_pat, current);
                 self.current = e_pat;
@@ -704,7 +704,7 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor {
             },
 
             // Expr with trailing semi-colon (may have any type):
-            StmtKind::Semi(ref e) => {
+            StmtKind::Semi(e) => {
                 let e_pat = self.next("e");
                 println!("Semi(ref {}, _) = {}", e_pat, current);
                 self.current = e_pat;
@@ -752,7 +752,7 @@ fn loop_desugaring_name(des: hir::LoopSource) -> &'static str {
 
 fn print_path(path: &QPath<'_>, first: &mut bool) {
     match *path {
-        QPath::Resolved(_, ref path) => {
+        QPath::Resolved(_, path) => {
             for segment in path.segments {
                 if *first {
                     *first = false;
@@ -762,7 +762,7 @@ fn print_path(path: &QPath<'_>, first: &mut bool) {
                 print!("{:?}", segment.ident.as_str());
             }
         },
-        QPath::TypeRelative(ref ty, ref segment) => match ty.kind {
+        QPath::TypeRelative(ty, segment) => match ty.kind {
             hir::TyKind::Path(ref inner_path) => {
                 print_path(inner_path, first);
                 if *first {
diff --git a/clippy_lints/src/utils/inspector.rs b/clippy_lints/src/utils/inspector.rs
index 6fd3c9d7dec..32d34e8d31e 100644
--- a/clippy_lints/src/utils/inspector.rs
+++ b/clippy_lints/src/utils/inspector.rs
@@ -47,7 +47,7 @@ impl<'tcx> LateLintPass<'tcx> for DeepCodeInspector {
         match item.vis.node {
             hir::VisibilityKind::Public => println!("public"),
             hir::VisibilityKind::Crate(_) => println!("visible crate wide"),
-            hir::VisibilityKind::Restricted { ref path, .. } => println!(
+            hir::VisibilityKind::Restricted { path, .. } => println!(
                 "visible in module `{}`",
                 rustc_hir_pretty::to_string(rustc_hir_pretty::NO_ANN, |s| s.print_path(path, false))
             ),
@@ -99,13 +99,13 @@ impl<'tcx> LateLintPass<'tcx> for DeepCodeInspector {
         if !has_attr(cx.sess(), cx.tcx.hir().attrs(arm.hir_id)) {
             return;
         }
-        print_pat(cx, &arm.pat, 1);
+        print_pat(cx, arm.pat, 1);
         if let Some(ref guard) = arm.guard {
             println!("guard:");
             print_guard(cx, guard, 1);
         }
         println!("body:");
-        print_expr(cx, &arm.body, 1);
+        print_expr(cx, arm.body, 1);
     }
 
     fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx hir::Stmt<'_>) {
@@ -113,17 +113,17 @@ impl<'tcx> LateLintPass<'tcx> for DeepCodeInspector {
             return;
         }
         match stmt.kind {
-            hir::StmtKind::Local(ref local) => {
+            hir::StmtKind::Local(local) => {
                 println!("local variable of type {}", cx.typeck_results().node_type(local.hir_id));
                 println!("pattern:");
-                print_pat(cx, &local.pat, 0);
-                if let Some(ref e) = local.init {
+                print_pat(cx, local.pat, 0);
+                if let Some(e) = local.init {
                     println!("init expression:");
                     print_expr(cx, e, 0);
                 }
             },
             hir::StmtKind::Item(_) => println!("item decl"),
-            hir::StmtKind::Expr(ref e) | hir::StmtKind::Semi(ref e) => print_expr(cx, e, 0),
+            hir::StmtKind::Expr(e) | hir::StmtKind::Semi(e) => print_expr(cx, e, 0),
         }
     }
     // fn check_foreign_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx
@@ -151,7 +151,7 @@ fn print_expr(cx: &LateContext<'_>, expr: &hir::Expr<'_>, indent: usize) {
         cx.typeck_results().adjustments().get(expr.hir_id)
     );
     match expr.kind {
-        hir::ExprKind::Box(ref e) => {
+        hir::ExprKind::Box(e) => {
             println!("{}Box", ind);
             print_expr(cx, e, indent + 1);
         },
@@ -161,7 +161,7 @@ fn print_expr(cx: &LateContext<'_>, expr: &hir::Expr<'_>, indent: usize) {
                 print_expr(cx, e, indent + 1);
             }
         },
-        hir::ExprKind::Call(ref func, args) => {
+        hir::ExprKind::Call(func, args) => {
             println!("{}Call", ind);
             println!("{}function:", ind);
             print_expr(cx, func, indent + 1);
@@ -170,7 +170,7 @@ fn print_expr(cx: &LateContext<'_>, expr: &hir::Expr<'_>, indent: usize) {
                 print_expr(cx, arg, indent + 1);
             }
         },
-        hir::ExprKind::MethodCall(ref path, _, args, _) => {
+        hir::ExprKind::MethodCall(path, _, args, _) => {
             println!("{}MethodCall", ind);
             println!("{}method name: {}", ind, path.ident.name);
             for arg in args {
@@ -183,7 +183,7 @@ fn print_expr(cx: &LateContext<'_>, expr: &hir::Expr<'_>, indent: usize) {
                 print_expr(cx, e, indent + 1);
             }
         },
-        hir::ExprKind::Binary(op, ref lhs, ref rhs) => {
+        hir::ExprKind::Binary(op, lhs, rhs) => {
             println!("{}Binary", ind);
             println!("{}op: {:?}", ind, op.node);
             println!("{}lhs:", ind);
@@ -191,7 +191,7 @@ fn print_expr(cx: &LateContext<'_>, expr: &hir::Expr<'_>, indent: usize) {
             println!("{}rhs:", ind);
             print_expr(cx, rhs, indent + 1);
         },
-        hir::ExprKind::Unary(op, ref inner) => {
+        hir::ExprKind::Unary(op, inner) => {
             println!("{}Unary", ind);
             println!("{}op: {:?}", ind, op);
             print_expr(cx, inner, indent + 1);
@@ -200,12 +200,12 @@ fn print_expr(cx: &LateContext<'_>, expr: &hir::Expr<'_>, indent: usize) {
             println!("{}Lit", ind);
             println!("{}{:?}", ind, lit);
         },
-        hir::ExprKind::Cast(ref e, ref target) => {
+        hir::ExprKind::Cast(e, target) => {
             println!("{}Cast", ind);
             print_expr(cx, e, indent + 1);
             println!("{}target type: {:?}", ind, target);
         },
-        hir::ExprKind::Type(ref e, ref target) => {
+        hir::ExprKind::Type(e, target) => {
             println!("{}Type", ind);
             print_expr(cx, e, indent + 1);
             println!("{}target type: {:?}", ind, target);
@@ -213,16 +213,16 @@ fn print_expr(cx: &LateContext<'_>, expr: &hir::Expr<'_>, indent: usize) {
         hir::ExprKind::Loop(..) => {
             println!("{}Loop", ind);
         },
-        hir::ExprKind::If(ref cond, _, ref else_opt) => {
+        hir::ExprKind::If(cond, _, ref else_opt) => {
             println!("{}If", ind);
             println!("{}condition:", ind);
             print_expr(cx, cond, indent + 1);
-            if let Some(ref els) = *else_opt {
+            if let Some(els) = *else_opt {
                 println!("{}else:", ind);
                 print_expr(cx, els, indent + 1);
             }
         },
-        hir::ExprKind::Match(ref cond, _, ref source) => {
+        hir::ExprKind::Match(cond, _, ref source) => {
             println!("{}Match", ind);
             println!("{}condition:", ind);
             print_expr(cx, cond, indent + 1);
@@ -232,21 +232,21 @@ fn print_expr(cx: &LateContext<'_>, expr: &hir::Expr<'_>, indent: usize) {
             println!("{}Closure", ind);
             println!("{}clause: {:?}", ind, clause);
         },
-        hir::ExprKind::Yield(ref sub, _) => {
+        hir::ExprKind::Yield(sub, _) => {
             println!("{}Yield", ind);
             print_expr(cx, sub, indent + 1);
         },
         hir::ExprKind::Block(_, _) => {
             println!("{}Block", ind);
         },
-        hir::ExprKind::Assign(ref lhs, ref rhs, _) => {
+        hir::ExprKind::Assign(lhs, rhs, _) => {
             println!("{}Assign", ind);
             println!("{}lhs:", ind);
             print_expr(cx, lhs, indent + 1);
             println!("{}rhs:", ind);
             print_expr(cx, rhs, indent + 1);
         },
-        hir::ExprKind::AssignOp(ref binop, ref lhs, ref rhs) => {
+        hir::ExprKind::AssignOp(ref binop, lhs, rhs) => {
             println!("{}AssignOp", ind);
             println!("{}op: {:?}", ind, binop.node);
             println!("{}lhs:", ind);
@@ -254,31 +254,31 @@ fn print_expr(cx: &LateContext<'_>, expr: &hir::Expr<'_>, indent: usize) {
             println!("{}rhs:", ind);
             print_expr(cx, rhs, indent + 1);
         },
-        hir::ExprKind::Field(ref e, ident) => {
+        hir::ExprKind::Field(e, ident) => {
             println!("{}Field", ind);
             println!("{}field name: {}", ind, ident.name);
             println!("{}struct expr:", ind);
             print_expr(cx, e, indent + 1);
         },
-        hir::ExprKind::Index(ref arr, ref idx) => {
+        hir::ExprKind::Index(arr, idx) => {
             println!("{}Index", ind);
             println!("{}array expr:", ind);
             print_expr(cx, arr, indent + 1);
             println!("{}index expr:", ind);
             print_expr(cx, idx, indent + 1);
         },
-        hir::ExprKind::Path(hir::QPath::Resolved(ref ty, ref path)) => {
+        hir::ExprKind::Path(hir::QPath::Resolved(ref ty, path)) => {
             println!("{}Resolved Path, {:?}", ind, ty);
             println!("{}path: {:?}", ind, path);
         },
-        hir::ExprKind::Path(hir::QPath::TypeRelative(ref ty, ref seg)) => {
+        hir::ExprKind::Path(hir::QPath::TypeRelative(ty, seg)) => {
             println!("{}Relative Path, {:?}", ind, ty);
             println!("{}seg: {:?}", ind, seg);
         },
         hir::ExprKind::Path(hir::QPath::LangItem(lang_item, ..)) => {
             println!("{}Lang Item Path, {:?}", ind, lang_item.name());
         },
-        hir::ExprKind::AddrOf(kind, ref muta, ref e) => {
+        hir::ExprKind::AddrOf(kind, ref muta, e) => {
             println!("{}AddrOf", ind);
             println!("kind: {:?}", kind);
             println!("mutability: {:?}", muta);
@@ -286,18 +286,18 @@ fn print_expr(cx: &LateContext<'_>, expr: &hir::Expr<'_>, indent: usize) {
         },
         hir::ExprKind::Break(_, ref e) => {
             println!("{}Break", ind);
-            if let Some(ref e) = *e {
+            if let Some(e) = *e {
                 print_expr(cx, e, indent + 1);
             }
         },
         hir::ExprKind::Continue(_) => println!("{}Again", ind),
         hir::ExprKind::Ret(ref e) => {
             println!("{}Ret", ind);
-            if let Some(ref e) = *e {
+            if let Some(e) = *e {
                 print_expr(cx, e, indent + 1);
             }
         },
-        hir::ExprKind::InlineAsm(ref asm) => {
+        hir::ExprKind::InlineAsm(asm) => {
             println!("{}InlineAsm", ind);
             println!("{}template: {}", ind, InlineAsmTemplatePiece::to_string(asm.template));
             println!("{}options: {:?}", ind, asm.options);
@@ -322,7 +322,7 @@ fn print_expr(cx: &LateContext<'_>, expr: &hir::Expr<'_>, indent: usize) {
                 }
             }
         },
-        hir::ExprKind::LlvmInlineAsm(ref asm) => {
+        hir::ExprKind::LlvmInlineAsm(asm) => {
             let inputs = &asm.inputs_exprs;
             let outputs = &asm.outputs_exprs;
             println!("{}LlvmInlineAsm", ind);
@@ -335,14 +335,14 @@ fn print_expr(cx: &LateContext<'_>, expr: &hir::Expr<'_>, indent: usize) {
                 print_expr(cx, e, indent + 1);
             }
         },
-        hir::ExprKind::Struct(ref path, fields, ref base) => {
+        hir::ExprKind::Struct(path, fields, ref base) => {
             println!("{}Struct", ind);
             println!("{}path: {:?}", ind, path);
             for field in fields {
                 println!("{}field \"{}\":", ind, field.ident.name);
-                print_expr(cx, &field.expr, indent + 1);
+                print_expr(cx, field.expr, indent + 1);
             }
-            if let Some(ref base) = *base {
+            if let Some(base) = *base {
                 println!("{}base:", ind);
                 print_expr(cx, base, indent + 1);
             }
@@ -352,7 +352,7 @@ fn print_expr(cx: &LateContext<'_>, expr: &hir::Expr<'_>, indent: usize) {
             println!("{}anon_const:", ind);
             print_expr(cx, &cx.tcx.hir().body(anon_const.body).value, indent + 1);
         },
-        hir::ExprKind::Repeat(ref val, ref anon_const) => {
+        hir::ExprKind::Repeat(val, ref anon_const) => {
             println!("{}Repeat", ind);
             println!("{}value:", ind);
             print_expr(cx, val, indent + 1);
@@ -362,7 +362,7 @@ fn print_expr(cx: &LateContext<'_>, expr: &hir::Expr<'_>, indent: usize) {
         hir::ExprKind::Err => {
             println!("{}Err", ind);
         },
-        hir::ExprKind::DropTemps(ref e) => {
+        hir::ExprKind::DropTemps(e) => {
             println!("{}DropTemps", ind);
             print_expr(cx, e, indent + 1);
         },
@@ -375,7 +375,7 @@ fn print_item(cx: &LateContext<'_>, item: &hir::Item<'_>) {
     match item.vis.node {
         hir::VisibilityKind::Public => println!("public"),
         hir::VisibilityKind::Crate(_) => println!("visible crate wide"),
-        hir::VisibilityKind::Restricted { ref path, .. } => println!(
+        hir::VisibilityKind::Restricted { path, .. } => println!(
             "visible in module `{}`",
             rustc_hir_pretty::to_string(rustc_hir_pretty::NO_ANN, |s| s.print_path(path, false))
         ),
@@ -395,7 +395,7 @@ fn print_item(cx: &LateContext<'_>, item: &hir::Item<'_>) {
                 println!("weird extern crate without a crate id");
             }
         },
-        hir::ItemKind::Use(ref path, ref kind) => println!("{:?}, {:?}", path, kind),
+        hir::ItemKind::Use(path, ref kind) => println!("{:?}, {:?}", path, kind),
         hir::ItemKind::Static(..) => println!("static item of type {:#?}", cx.tcx.type_of(did)),
         hir::ItemKind::Const(..) => println!("const item of type {:#?}", cx.tcx.type_of(did)),
         hir::ItemKind::Fn(..) => {
@@ -404,7 +404,7 @@ fn print_item(cx: &LateContext<'_>, item: &hir::Item<'_>) {
         },
         hir::ItemKind::Mod(..) => println!("module"),
         hir::ItemKind::ForeignMod { abi, .. } => println!("foreign module with abi: {}", abi),
-        hir::ItemKind::GlobalAsm(ref asm) => println!("global asm: {:?}", asm),
+        hir::ItemKind::GlobalAsm(asm) => println!("global asm: {:?}", asm),
         hir::ItemKind::TyAlias(..) => {
             println!("type alias for {:?}", cx.tcx.type_of(did));
         },
@@ -454,7 +454,7 @@ fn print_pat(cx: &LateContext<'_>, pat: &hir::Pat<'_>, indent: usize) {
             println!("{}Binding", ind);
             println!("{}mode: {:?}", ind, mode);
             println!("{}name: {}", ind, ident.name);
-            if let Some(ref inner) = *inner {
+            if let Some(inner) = *inner {
                 println!("{}inner:", ind);
                 print_pat(cx, inner, indent + 1);
             }
@@ -479,7 +479,7 @@ fn print_pat(cx: &LateContext<'_>, pat: &hir::Pat<'_>, indent: usize) {
                 if field.is_shorthand {
                     println!("{}  in shorthand notation", ind);
                 }
-                print_pat(cx, &field.pat, indent + 1);
+                print_pat(cx, field.pat, indent + 1);
             }
         },
         hir::PatKind::TupleStruct(ref path, fields, opt_dots_position) => {
@@ -496,11 +496,11 @@ fn print_pat(cx: &LateContext<'_>, pat: &hir::Pat<'_>, indent: usize) {
                 print_pat(cx, field, indent + 1);
             }
         },
-        hir::PatKind::Path(hir::QPath::Resolved(ref ty, ref path)) => {
+        hir::PatKind::Path(hir::QPath::Resolved(ref ty, path)) => {
             println!("{}Resolved Path, {:?}", ind, ty);
             println!("{}path: {:?}", ind, path);
         },
-        hir::PatKind::Path(hir::QPath::TypeRelative(ref ty, ref seg)) => {
+        hir::PatKind::Path(hir::QPath::TypeRelative(ty, seg)) => {
             println!("{}Relative Path, {:?}", ind, ty);
             println!("{}seg: {:?}", ind, seg);
         },
@@ -516,16 +516,16 @@ fn print_pat(cx: &LateContext<'_>, pat: &hir::Pat<'_>, indent: usize) {
                 print_pat(cx, field, indent + 1);
             }
         },
-        hir::PatKind::Box(ref inner) => {
+        hir::PatKind::Box(inner) => {
             println!("{}Box", ind);
             print_pat(cx, inner, indent + 1);
         },
-        hir::PatKind::Ref(ref inner, ref muta) => {
+        hir::PatKind::Ref(inner, ref muta) => {
             println!("{}Ref", ind);
             println!("{}mutability: {:?}", ind, muta);
             print_pat(cx, inner, indent + 1);
         },
-        hir::PatKind::Lit(ref e) => {
+        hir::PatKind::Lit(e) => {
             println!("{}Lit", ind);
             print_expr(cx, e, indent + 1);
         },
@@ -549,7 +549,7 @@ fn print_pat(cx: &LateContext<'_>, pat: &hir::Pat<'_>, indent: usize) {
                 print_pat(cx, pat, indent + 1);
             }
             println!("i:");
-            if let Some(ref pat) = *range {
+            if let Some(pat) = *range {
                 print_pat(cx, pat, indent + 1);
             }
             println!("[y, z]:");
diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs
index d5a13c135b1..cf8039d6059 100644
--- a/clippy_lints/src/utils/internal_lints.rs
+++ b/clippy_lints/src/utils/internal_lints.rs
@@ -353,12 +353,12 @@ impl<'tcx> LateLintPass<'tcx> for LintWithoutLintPass {
             return;
         }
 
-        if let hir::ItemKind::Static(ref ty, Mutability::Not, body_id) = item.kind {
+        if let hir::ItemKind::Static(ty, Mutability::Not, body_id) = item.kind {
             if is_lint_ref_type(cx, ty) {
                 let expr = &cx.tcx.hir().body(body_id).value;
                 if_chain! {
-                    if let ExprKind::AddrOf(_, _, ref inner_exp) = expr.kind;
-                    if let ExprKind::Struct(_, ref fields, _) = inner_exp.kind;
+                    if let ExprKind::AddrOf(_, _, inner_exp) = expr.kind;
+                    if let ExprKind::Struct(_, fields, _) = inner_exp.kind;
                     let field = fields
                         .iter()
                         .find(|f| f.ident.as_str() == "desc")
@@ -385,7 +385,7 @@ impl<'tcx> LateLintPass<'tcx> for LintWithoutLintPass {
         {
             if let hir::ItemKind::Impl(hir::Impl {
                 of_trait: None,
-                items: ref impl_item_refs,
+                items: impl_item_refs,
                 ..
             }) = item.kind
             {
@@ -437,7 +437,7 @@ fn is_lint_ref_type<'tcx>(cx: &LateContext<'tcx>, ty: &Ty<'_>) -> bool {
     if let TyKind::Rptr(
         _,
         MutTy {
-            ty: ref inner,
+            ty: inner,
             mutbl: Mutability::Not,
         },
     ) = ty.kind
@@ -498,7 +498,7 @@ impl<'tcx> LateLintPass<'tcx> for CompilerLintFunctions {
         }
 
         if_chain! {
-            if let ExprKind::MethodCall(ref path, _, ref args, _) = expr.kind;
+            if let ExprKind::MethodCall(path, _, args, _) = expr.kind;
             let fn_name = path.ident;
             if let Some(sugg) = self.map.get(&*fn_name.as_str());
             let ty = cx.typeck_results().expr_ty(&args[0]).peel_refs();
@@ -577,7 +577,7 @@ impl<'tcx> LateLintPass<'tcx> for CollapsibleCalls {
         }
 
         if_chain! {
-            if let ExprKind::Call(ref func, ref and_then_args) = expr.kind;
+            if let ExprKind::Call(func, and_then_args) = expr.kind;
             if let ExprKind::Path(ref path) = func.kind;
             if match_qpath(path, &["span_lint_and_then"]);
             if and_then_args.len() == 5;
@@ -587,7 +587,7 @@ impl<'tcx> LateLintPass<'tcx> for CollapsibleCalls {
             let stmts = &block.stmts;
             if stmts.len() == 1 && block.expr.is_none();
             if let StmtKind::Semi(only_expr) = &stmts[0].kind;
-            if let ExprKind::MethodCall(ref ps, _, ref span_call_args, _) = &only_expr.kind;
+            if let ExprKind::MethodCall(ps, _, span_call_args, _) = &only_expr.kind;
             then {
                 let and_then_snippets = get_and_then_snippets(cx, and_then_args);
                 let mut sle = SpanlessEq::new(cx).deny_side_effects();
@@ -762,7 +762,7 @@ impl<'tcx> LateLintPass<'tcx> for MatchTypeOnDiagItem {
             // Check if this is a call to utils::match_type()
             if let ExprKind::Call(fn_path, [context, ty, ty_path]) = expr.kind;
             if let ExprKind::Path(fn_qpath) = &fn_path.kind;
-            if match_qpath(&fn_qpath, &["utils", "match_type"]);
+            if match_qpath(fn_qpath, &["utils", "match_type"]);
             // Extract the path to the matched type
             if let Some(segments) = path_to_matched_type(cx, ty_path);
             let segments: Vec<&str> = segments.iter().map(|sym| &**sym).collect();
diff --git a/clippy_lints/src/vec.rs b/clippy_lints/src/vec.rs
index bc2eb88114e..febd4b6ff7b 100644
--- a/clippy_lints/src/vec.rs
+++ b/clippy_lints/src/vec.rs
@@ -49,7 +49,7 @@ impl<'tcx> LateLintPass<'tcx> for UselessVec {
         if_chain! {
             if let ty::Ref(_, ty, _) = cx.typeck_results().expr_ty_adjusted(expr).kind();
             if let ty::Slice(..) = ty.kind();
-            if let ExprKind::AddrOf(BorrowKind::Ref, mutability, ref addressee) = expr.kind;
+            if let ExprKind::AddrOf(BorrowKind::Ref, mutability, addressee) = expr.kind;
             if let Some(vec_args) = higher::vec_macro(cx, addressee);
             then {
                 self.check_vec_macro(cx, &vec_args, mutability, expr.span);
diff --git a/clippy_lints/src/vec_resize_to_zero.rs b/clippy_lints/src/vec_resize_to_zero.rs
index e035d3c5cad..5540e87405f 100644
--- a/clippy_lints/src/vec_resize_to_zero.rs
+++ b/clippy_lints/src/vec_resize_to_zero.rs
@@ -30,7 +30,7 @@ declare_lint_pass!(VecResizeToZero => [VEC_RESIZE_TO_ZERO]);
 impl<'tcx> LateLintPass<'tcx> for VecResizeToZero {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if_chain! {
-            if let hir::ExprKind::MethodCall(path_segment, _, ref args, _) = expr.kind;
+            if let hir::ExprKind::MethodCall(path_segment, _, args, _) = expr.kind;
             if let Some(method_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
             if match_def_path(cx, method_def_id, &paths::VEC_RESIZE) && args.len() == 3;
             if let ExprKind::Lit(Spanned { node: LitKind::Int(0, _), .. }) = args[1].kind;
diff --git a/clippy_lints/src/zero_div_zero.rs b/clippy_lints/src/zero_div_zero.rs
index 3b4890ad560..350b1cf25ff 100644
--- a/clippy_lints/src/zero_div_zero.rs
+++ b/clippy_lints/src/zero_div_zero.rs
@@ -31,7 +31,7 @@ impl<'tcx> LateLintPass<'tcx> for ZeroDiv {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         // check for instances of 0.0/0.0
         if_chain! {
-            if let ExprKind::Binary(ref op, ref left, ref right) = expr.kind;
+            if let ExprKind::Binary(ref op, left, right) = expr.kind;
             if let BinOpKind::Div = op.node;
             // TODO - constant_simple does not fold many operations involving floats.
             // That's probably fine for this lint - it's pretty unlikely that someone would
diff --git a/clippy_lints/src/zero_sized_map_values.rs b/clippy_lints/src/zero_sized_map_values.rs
index 2abd033e2a0..f93f0047f51 100644
--- a/clippy_lints/src/zero_sized_map_values.rs
+++ b/clippy_lints/src/zero_sized_map_values.rs
@@ -50,7 +50,7 @@ impl LateLintPass<'_> for ZeroSizedMapValues {
             if !in_trait_impl(cx, hir_ty.hir_id);
             let ty = ty_from_hir_ty(cx, hir_ty);
             if is_type_diagnostic_item(cx, ty, sym::hashmap_type) || match_type(cx, ty, &paths::BTREEMAP);
-            if let Adt(_, ref substs) = ty.kind();
+            if let Adt(_, substs) = ty.kind();
             let ty = substs.type_at(1);
             // Do this to prevent `layout_of` crashing, being unable to fully normalize `ty`.
             if is_normalizable(cx, cx.param_env, ty);
diff --git a/src/driver.rs b/src/driver.rs
index b6aed862e89..fa0c5f01430 100644
--- a/src/driver.rs
+++ b/src/driver.rs
@@ -99,17 +99,17 @@ impl rustc_driver::Callbacks for ClippyCallbacks {
         config.parse_sess_created = Some(Box::new(move |parse_sess| {
             track_clippy_args(parse_sess, &clippy_args_var);
         }));
-        config.register_lints = Some(Box::new(move |sess, mut lint_store| {
+        config.register_lints = Some(Box::new(move |sess, lint_store| {
             // technically we're ~guaranteed that this is none but might as well call anything that
             // is there already. Certainly it can't hurt.
             if let Some(previous) = &previous {
                 (previous)(sess, lint_store);
             }
 
-            let conf = clippy_lints::read_conf(&[], &sess);
-            clippy_lints::register_plugins(&mut lint_store, &sess, &conf);
-            clippy_lints::register_pre_expansion_lints(&mut lint_store);
-            clippy_lints::register_renamed(&mut lint_store);
+            let conf = clippy_lints::read_conf(&[], sess);
+            clippy_lints::register_plugins(lint_store, sess, &conf);
+            clippy_lints::register_pre_expansion_lints(lint_store);
+            clippy_lints::register_renamed(lint_store);
         }));
 
         // FIXME: #4825; This is required, because Clippy lints that are based on MIR have to be
@@ -191,7 +191,7 @@ fn report_clippy_ice(info: &panic::PanicInfo<'_>, bug_report_url: &str) {
     ];
 
     for note in &xs {
-        handler.note_without_error(&note);
+        handler.note_without_error(note);
     }
 
     // If backtraces are enabled, also print the query stack
diff --git a/tests/compile-test.rs b/tests/compile-test.rs
index 0594663786c..f4d354f0bf9 100644
--- a/tests/compile-test.rs
+++ b/tests/compile-test.rs
@@ -98,7 +98,7 @@ fn default_config() -> compiletest::Config {
 fn run_mode(cfg: &mut compiletest::Config) {
     cfg.mode = TestMode::Ui;
     cfg.src_base = Path::new("tests").join("ui");
-    compiletest::run_tests(&cfg);
+    compiletest::run_tests(cfg);
 }
 
 fn run_internal_tests(cfg: &mut compiletest::Config) {
@@ -108,7 +108,7 @@ fn run_internal_tests(cfg: &mut compiletest::Config) {
     }
     cfg.mode = TestMode::Ui;
     cfg.src_base = Path::new("tests").join("ui-internal");
-    compiletest::run_tests(&cfg);
+    compiletest::run_tests(cfg);
 }
 
 fn run_ui_toml(config: &mut compiletest::Config) {
@@ -136,7 +136,7 @@ fn run_ui_toml(config: &mut compiletest::Config) {
                     base: config.src_base.clone(),
                     relative_dir: dir_path.file_name().unwrap().into(),
                 };
-                let test_name = compiletest::make_test_name(&config, &paths);
+                let test_name = compiletest::make_test_name(config, &paths);
                 let index = tests
                     .iter()
                     .position(|test| test.desc.name == test_name)
@@ -150,10 +150,10 @@ fn run_ui_toml(config: &mut compiletest::Config) {
     config.mode = TestMode::Ui;
     config.src_base = Path::new("tests").join("ui-toml").canonicalize().unwrap();
 
-    let tests = compiletest::make_tests(&config);
+    let tests = compiletest::make_tests(config);
 
     let manifest_dir = var("CARGO_MANIFEST_DIR").unwrap_or_default();
-    let res = run_tests(&config, tests);
+    let res = run_tests(config, tests);
     set_var("CARGO_MANIFEST_DIR", &manifest_dir);
     match res {
         Ok(true) => {},
@@ -221,7 +221,7 @@ fn run_ui_cargo(config: &mut compiletest::Config) {
                         base: config.src_base.clone(),
                         relative_dir: src_path.strip_prefix(&config.src_base).unwrap().into(),
                     };
-                    let test_name = compiletest::make_test_name(&config, &paths);
+                    let test_name = compiletest::make_test_name(config, &paths);
                     let index = tests
                         .iter()
                         .position(|test| test.desc.name == test_name)
@@ -240,11 +240,11 @@ fn run_ui_cargo(config: &mut compiletest::Config) {
     config.mode = TestMode::Ui;
     config.src_base = Path::new("tests").join("ui-cargo").canonicalize().unwrap();
 
-    let tests = compiletest::make_tests(&config);
+    let tests = compiletest::make_tests(config);
 
     let current_dir = env::current_dir().unwrap();
     let conf_dir = var("CLIPPY_CONF_DIR").unwrap_or_default();
-    let res = run_tests(&config, &config.filters, tests);
+    let res = run_tests(config, &config.filters, tests);
     env::set_current_dir(current_dir).unwrap();
     set_var("CLIPPY_CONF_DIR", conf_dir);
 
diff --git a/tests/ui/borrow_interior_mutable_const/others.rs b/tests/ui/borrow_interior_mutable_const/others.rs
index ea25729d11d..4327f12c37c 100644
--- a/tests/ui/borrow_interior_mutable_const/others.rs
+++ b/tests/ui/borrow_interior_mutable_const/others.rs
@@ -1,5 +1,9 @@
 #![warn(clippy::borrow_interior_mutable_const)]
-#![allow(clippy::declare_interior_mutable_const, clippy::ref_in_deref)]
+#![allow(
+    clippy::declare_interior_mutable_const,
+    clippy::ref_in_deref,
+    clippy::needless_borrow
+)]
 #![allow(const_item_mutation)]
 
 use std::borrow::Cow;
diff --git a/tests/ui/borrow_interior_mutable_const/others.stderr b/tests/ui/borrow_interior_mutable_const/others.stderr
index 9a908cf30e9..f146b97cf61 100644
--- a/tests/ui/borrow_interior_mutable_const/others.stderr
+++ b/tests/ui/borrow_interior_mutable_const/others.stderr
@@ -1,5 +1,5 @@
 error: a `const` item with interior mutability should not be borrowed
-  --> $DIR/others.rs:54:5
+  --> $DIR/others.rs:58:5
    |
 LL |     ATOMIC.store(1, Ordering::SeqCst); //~ ERROR interior mutability
    |     ^^^^^^
@@ -8,7 +8,7 @@ LL |     ATOMIC.store(1, Ordering::SeqCst); //~ ERROR interior mutability
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> $DIR/others.rs:55:16
+  --> $DIR/others.rs:59:16
    |
 LL |     assert_eq!(ATOMIC.load(Ordering::SeqCst), 5); //~ ERROR interior mutability
    |                ^^^^^^
@@ -16,7 +16,7 @@ LL |     assert_eq!(ATOMIC.load(Ordering::SeqCst), 5); //~ ERROR interior mutabi
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> $DIR/others.rs:58:22
+  --> $DIR/others.rs:62:22
    |
 LL |     let _once_ref = &ONCE_INIT; //~ ERROR interior mutability
    |                      ^^^^^^^^^
@@ -24,7 +24,7 @@ LL |     let _once_ref = &ONCE_INIT; //~ ERROR interior mutability
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> $DIR/others.rs:59:25
+  --> $DIR/others.rs:63:25
    |
 LL |     let _once_ref_2 = &&ONCE_INIT; //~ ERROR interior mutability
    |                         ^^^^^^^^^
@@ -32,7 +32,7 @@ LL |     let _once_ref_2 = &&ONCE_INIT; //~ ERROR interior mutability
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> $DIR/others.rs:60:27
+  --> $DIR/others.rs:64:27
    |
 LL |     let _once_ref_4 = &&&&ONCE_INIT; //~ ERROR interior mutability
    |                           ^^^^^^^^^
@@ -40,7 +40,7 @@ LL |     let _once_ref_4 = &&&&ONCE_INIT; //~ ERROR interior mutability
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> $DIR/others.rs:61:26
+  --> $DIR/others.rs:65:26
    |
 LL |     let _once_mut = &mut ONCE_INIT; //~ ERROR interior mutability
    |                          ^^^^^^^^^
@@ -48,7 +48,7 @@ LL |     let _once_mut = &mut ONCE_INIT; //~ ERROR interior mutability
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> $DIR/others.rs:72:14
+  --> $DIR/others.rs:76:14
    |
 LL |     let _ = &ATOMIC_TUPLE; //~ ERROR interior mutability
    |              ^^^^^^^^^^^^
@@ -56,7 +56,7 @@ LL |     let _ = &ATOMIC_TUPLE; //~ ERROR interior mutability
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> $DIR/others.rs:73:14
+  --> $DIR/others.rs:77:14
    |
 LL |     let _ = &ATOMIC_TUPLE.0; //~ ERROR interior mutability
    |              ^^^^^^^^^^^^
@@ -64,7 +64,7 @@ LL |     let _ = &ATOMIC_TUPLE.0; //~ ERROR interior mutability
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> $DIR/others.rs:74:19
+  --> $DIR/others.rs:78:19
    |
 LL |     let _ = &(&&&&ATOMIC_TUPLE).0; //~ ERROR interior mutability
    |                   ^^^^^^^^^^^^
@@ -72,7 +72,7 @@ LL |     let _ = &(&&&&ATOMIC_TUPLE).0; //~ ERROR interior mutability
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> $DIR/others.rs:75:14
+  --> $DIR/others.rs:79:14
    |
 LL |     let _ = &ATOMIC_TUPLE.0[0]; //~ ERROR interior mutability
    |              ^^^^^^^^^^^^
@@ -80,7 +80,7 @@ LL |     let _ = &ATOMIC_TUPLE.0[0]; //~ ERROR interior mutability
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> $DIR/others.rs:76:13
+  --> $DIR/others.rs:80:13
    |
 LL |     let _ = ATOMIC_TUPLE.0[0].load(Ordering::SeqCst); //~ ERROR interior mutability
    |             ^^^^^^^^^^^^
@@ -88,7 +88,7 @@ LL |     let _ = ATOMIC_TUPLE.0[0].load(Ordering::SeqCst); //~ ERROR interior mu
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> $DIR/others.rs:82:13
+  --> $DIR/others.rs:86:13
    |
 LL |     let _ = ATOMIC_TUPLE.0[0]; //~ ERROR interior mutability
    |             ^^^^^^^^^^^^
@@ -96,7 +96,7 @@ LL |     let _ = ATOMIC_TUPLE.0[0]; //~ ERROR interior mutability
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> $DIR/others.rs:87:5
+  --> $DIR/others.rs:91:5
    |
 LL |     CELL.set(2); //~ ERROR interior mutability
    |     ^^^^
@@ -104,7 +104,7 @@ LL |     CELL.set(2); //~ ERROR interior mutability
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> $DIR/others.rs:88:16
+  --> $DIR/others.rs:92:16
    |
 LL |     assert_eq!(CELL.get(), 6); //~ ERROR interior mutability
    |                ^^^^
diff --git a/tests/ui/collapsible_match2.rs b/tests/ui/collapsible_match2.rs
index 8372a212477..542e6948427 100644
--- a/tests/ui/collapsible_match2.rs
+++ b/tests/ui/collapsible_match2.rs
@@ -1,5 +1,10 @@
 #![warn(clippy::collapsible_match)]
-#![allow(clippy::needless_return, clippy::no_effect, clippy::single_match)]
+#![allow(
+    clippy::needless_return,
+    clippy::no_effect,
+    clippy::single_match,
+    clippy::needless_borrow
+)]
 
 fn lint_cases(opt_opt: Option<Option<u32>>, res_opt: Result<Option<u32>, String>) {
     // if guards on outer match
diff --git a/tests/ui/collapsible_match2.stderr b/tests/ui/collapsible_match2.stderr
index c8a445ef369..ffef32d1fde 100644
--- a/tests/ui/collapsible_match2.stderr
+++ b/tests/ui/collapsible_match2.stderr
@@ -1,5 +1,5 @@
 error: unnecessary nested match
-  --> $DIR/collapsible_match2.rs:8:34
+  --> $DIR/collapsible_match2.rs:13:34
    |
 LL |               Ok(val) if make() => match val {
    |  __________________________________^
@@ -10,7 +10,7 @@ LL | |             },
    |
    = note: `-D clippy::collapsible-match` implied by `-D warnings`
 help: the outer pattern can be modified to include the inner pattern
-  --> $DIR/collapsible_match2.rs:8:16
+  --> $DIR/collapsible_match2.rs:13:16
    |
 LL |             Ok(val) if make() => match val {
    |                ^^^ replace this binding
@@ -18,7 +18,7 @@ LL |                 Some(n) => foo(n),
    |                 ^^^^^^^ with this pattern
 
 error: unnecessary nested match
-  --> $DIR/collapsible_match2.rs:15:24
+  --> $DIR/collapsible_match2.rs:20:24
    |
 LL |               Ok(val) => match val {
    |  ________________________^
@@ -28,7 +28,7 @@ LL | |             },
    | |_____________^
    |
 help: the outer pattern can be modified to include the inner pattern
-  --> $DIR/collapsible_match2.rs:15:16
+  --> $DIR/collapsible_match2.rs:20:16
    |
 LL |             Ok(val) => match val {
    |                ^^^ replace this binding
@@ -36,7 +36,7 @@ LL |                 Some(n) => foo(n),
    |                 ^^^^^^^ with this pattern
 
 error: unnecessary nested match
-  --> $DIR/collapsible_match2.rs:29:29
+  --> $DIR/collapsible_match2.rs:34:29
    |
 LL |                       $pat => match $e {
    |  _____________________________^
@@ -49,7 +49,7 @@ LL |           mac!(res_opt => Ok(val), val => Some(n), foo(n));
    |           ------------------------------------------------- in this macro invocation
    |
 help: the outer pattern can be modified to include the inner pattern
-  --> $DIR/collapsible_match2.rs:41:28
+  --> $DIR/collapsible_match2.rs:46:28
    |
 LL |         mac!(res_opt => Ok(val), val => Some(n), foo(n));
    |                            ^^^          ^^^^^^^ with this pattern
@@ -58,7 +58,7 @@ LL |         mac!(res_opt => Ok(val), val => Some(n), foo(n));
    = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: unnecessary nested match
-  --> $DIR/collapsible_match2.rs:46:20
+  --> $DIR/collapsible_match2.rs:51:20
    |
 LL |           Some(s) => match *s {
    |  ____________________^
@@ -68,7 +68,7 @@ LL | |         },
    | |_________^
    |
 help: the outer pattern can be modified to include the inner pattern
-  --> $DIR/collapsible_match2.rs:46:14
+  --> $DIR/collapsible_match2.rs:51:14
    |
 LL |         Some(s) => match *s {
    |              ^ replace this binding
@@ -76,7 +76,7 @@ LL |             [n] => foo(n),
    |             ^^^ with this pattern
 
 error: unnecessary nested match
-  --> $DIR/collapsible_match2.rs:55:24
+  --> $DIR/collapsible_match2.rs:60:24
    |
 LL |           Some(ref s) => match &*s {
    |  ________________________^
@@ -86,7 +86,7 @@ LL | |         },
    | |_________^
    |
 help: the outer pattern can be modified to include the inner pattern
-  --> $DIR/collapsible_match2.rs:55:14
+  --> $DIR/collapsible_match2.rs:60:14
    |
 LL |         Some(ref s) => match &*s {
    |              ^^^^^ replace this binding
diff --git a/tests/ui/escape_analysis.rs b/tests/ui/escape_analysis.rs
index d26f48fc68f..13e2b6c7a2e 100644
--- a/tests/ui/escape_analysis.rs
+++ b/tests/ui/escape_analysis.rs
@@ -101,7 +101,7 @@ fn warn_match() {
     let x = box A;
     match &x {
         // not moved
-        ref y => (),
+        y => (),
     }
 }
 
@@ -111,7 +111,7 @@ fn nowarn_large_array() {
     let x = box [1; 10000];
     match &x {
         // not moved
-        ref y => (),
+        y => (),
     }
 }
 
diff --git a/tests/ui/implicit_clone.rs b/tests/ui/implicit_clone.rs
index 19101522163..cef71cf79d7 100644
--- a/tests/ui/implicit_clone.rs
+++ b/tests/ui/implicit_clone.rs
@@ -66,7 +66,7 @@ fn main() {
     let _ = vec.to_vec();
 
     let vec_ref = &vec;
-    let _ = return_owned_from_slice(&vec_ref);
+    let _ = return_owned_from_slice(vec_ref);
     let _ = vec_ref.to_owned();
     let _ = vec_ref.to_vec();
 
diff --git a/tests/ui/into_iter_on_ref.fixed b/tests/ui/into_iter_on_ref.fixed
index 7f92d0dbdc9..b77f17944d8 100644
--- a/tests/ui/into_iter_on_ref.fixed
+++ b/tests/ui/into_iter_on_ref.fixed
@@ -1,5 +1,5 @@
 // run-rustfix
-#![allow(clippy::useless_vec)]
+#![allow(clippy::useless_vec, clippy::needless_borrow)]
 #![warn(clippy::into_iter_on_ref)]
 
 struct X;
diff --git a/tests/ui/into_iter_on_ref.rs b/tests/ui/into_iter_on_ref.rs
index 416056d3fdb..3854bb05af8 100644
--- a/tests/ui/into_iter_on_ref.rs
+++ b/tests/ui/into_iter_on_ref.rs
@@ -1,5 +1,5 @@
 // run-rustfix
-#![allow(clippy::useless_vec)]
+#![allow(clippy::useless_vec, clippy::needless_borrow)]
 #![warn(clippy::into_iter_on_ref)]
 
 struct X;
diff --git a/tests/ui/ref_option_ref.rs b/tests/ui/ref_option_ref.rs
index b2c275d68af..2df45c927d7 100644
--- a/tests/ui/ref_option_ref.rs
+++ b/tests/ui/ref_option_ref.rs
@@ -9,7 +9,7 @@
 static THRESHOLD: i32 = 10;
 static REF_THRESHOLD: &Option<&i32> = &Some(&THRESHOLD);
 const CONST_THRESHOLD: &i32 = &10;
-const REF_CONST: &Option<&i32> = &Some(&CONST_THRESHOLD);
+const REF_CONST: &Option<&i32> = &Some(CONST_THRESHOLD);
 
 type RefOptRefU32<'a> = &'a Option<&'a u32>;
 type RefOptRef<'a, T> = &'a Option<&'a T>;
diff --git a/tests/ui/ref_option_ref.stderr b/tests/ui/ref_option_ref.stderr
index 4e7fc800061..b61334758e8 100644
--- a/tests/ui/ref_option_ref.stderr
+++ b/tests/ui/ref_option_ref.stderr
@@ -9,7 +9,7 @@ LL | static REF_THRESHOLD: &Option<&i32> = &Some(&THRESHOLD);
 error: since `&` implements the `Copy` trait, `&Option<&T>` can be simplified to `Option<&T>`
   --> $DIR/ref_option_ref.rs:12:18
    |
-LL | const REF_CONST: &Option<&i32> = &Some(&CONST_THRESHOLD);
+LL | const REF_CONST: &Option<&i32> = &Some(CONST_THRESHOLD);
    |                  ^^^^^^^^^^^^^ help: try: `Option<&i32>`
 
 error: since `&` implements the `Copy` trait, `&Option<&T>` can be simplified to `Option<&T>`
diff --git a/tests/ui/stable_sort_primitive.fixed b/tests/ui/stable_sort_primitive.fixed
index 8f8f5665931..f5f18169df2 100644
--- a/tests/ui/stable_sort_primitive.fixed
+++ b/tests/ui/stable_sort_primitive.fixed
@@ -20,7 +20,7 @@ fn main() {
     // Negative examples: behavior changes if made unstable
     let mut vec = vec![1, 3, 2];
     vec.sort_by_key(|i| i / 2);
-    vec.sort_by(|a, b| (a + b).cmp(&b));
+    vec.sort_by(|&a, &b| (a + b).cmp(&b));
     // negative examples - Not of a primitive type
     let mut vec_of_complex = vec![String::from("hello"), String::from("world!")];
     vec_of_complex.sort();
diff --git a/tests/ui/stable_sort_primitive.rs b/tests/ui/stable_sort_primitive.rs
index f9bd9779067..8149c5638e0 100644
--- a/tests/ui/stable_sort_primitive.rs
+++ b/tests/ui/stable_sort_primitive.rs
@@ -20,7 +20,7 @@ fn main() {
     // Negative examples: behavior changes if made unstable
     let mut vec = vec![1, 3, 2];
     vec.sort_by_key(|i| i / 2);
-    vec.sort_by(|a, b| (a + b).cmp(&b));
+    vec.sort_by(|&a, &b| (a + b).cmp(&b));
     // negative examples - Not of a primitive type
     let mut vec_of_complex = vec![String::from("hello"), String::from("world!")];
     vec_of_complex.sort();
-- 
cgit 1.4.1-3-g733a5


From 6b5778eb176deda52a3960cc2029bc93f1424c35 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Fri, 26 Mar 2021 22:28:59 -0400
Subject: Fix `explicit_into_iter_loop` Only lint when `into_iter` is an
 implementation of `IntoIterator` Minor cleanups

---
 clippy_lints/src/loops/explicit_into_iter_loop.rs | 13 +++++-----
 clippy_lints/src/loops/explicit_iter_loop.rs      | 10 ++++----
 clippy_lints/src/loops/mod.rs                     | 29 ++++++++++-------------
 tests/ui/for_loop_fixable.fixed                   | 26 ++++++++++++++++++++
 tests/ui/for_loop_fixable.rs                      | 26 ++++++++++++++++++++
 5 files changed, 77 insertions(+), 27 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/explicit_into_iter_loop.rs b/clippy_lints/src/loops/explicit_into_iter_loop.rs
index 4871a031187..c7a28f42ea1 100644
--- a/clippy_lints/src/loops/explicit_into_iter_loop.rs
+++ b/clippy_lints/src/loops/explicit_into_iter_loop.rs
@@ -1,24 +1,25 @@
 use super::EXPLICIT_INTO_ITER_LOOP;
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::{match_trait_method, paths};
 use rustc_errors::Applicability;
 use rustc_hir::Expr;
 use rustc_lint::LateContext;
 use rustc_middle::ty::TyS;
 
-pub(super) fn check(cx: &LateContext<'_>, args: &'hir [Expr<'hir>], arg: &Expr<'_>) {
-    let receiver_ty = cx.typeck_results().expr_ty(&args[0]);
-    let receiver_ty_adjusted = cx.typeck_results().expr_ty_adjusted(&args[0]);
-    if !TyS::same_type(receiver_ty, receiver_ty_adjusted) {
+pub(super) fn check(cx: &LateContext<'_>, self_arg: &'hir Expr<'hir>, call_expr: &Expr<'_>) {
+    let self_ty = cx.typeck_results().expr_ty(self_arg);
+    let self_ty_adjusted = cx.typeck_results().expr_ty_adjusted(self_arg);
+    if !(TyS::same_type(self_ty, self_ty_adjusted) && match_trait_method(cx, call_expr, &paths::INTO_ITERATOR)) {
         return;
     }
 
     let mut applicability = Applicability::MachineApplicable;
-    let object = snippet_with_applicability(cx, args[0].span, "_", &mut applicability);
+    let object = snippet_with_applicability(cx, self_arg.span, "_", &mut applicability);
     span_lint_and_sugg(
         cx,
         EXPLICIT_INTO_ITER_LOOP,
-        arg.span,
+        call_expr.span,
         "it is more concise to loop over containers instead of using explicit \
             iteration methods",
         "to write this more concisely, try",
diff --git a/clippy_lints/src/loops/explicit_iter_loop.rs b/clippy_lints/src/loops/explicit_iter_loop.rs
index 92aa2beb66d..ce02ad013be 100644
--- a/clippy_lints/src/loops/explicit_iter_loop.rs
+++ b/clippy_lints/src/loops/explicit_iter_loop.rs
@@ -9,12 +9,12 @@ use rustc_lint::LateContext;
 use rustc_middle::ty::{self, Ty, TyS};
 use rustc_span::sym;
 
-pub(super) fn check(cx: &LateContext<'_>, args: &[Expr<'_>], arg: &Expr<'_>, method_name: &str) {
+pub(super) fn check(cx: &LateContext<'_>, self_arg: &Expr<'_>, arg: &Expr<'_>, method_name: &str) {
     let should_lint = match method_name {
-        "iter" | "iter_mut" => is_ref_iterable_type(cx, &args[0]),
+        "iter" | "iter_mut" => is_ref_iterable_type(cx, self_arg),
         "into_iter" if match_trait_method(cx, arg, &paths::INTO_ITERATOR) => {
-            let receiver_ty = cx.typeck_results().expr_ty(&args[0]);
-            let receiver_ty_adjusted = cx.typeck_results().expr_ty_adjusted(&args[0]);
+            let receiver_ty = cx.typeck_results().expr_ty(self_arg);
+            let receiver_ty_adjusted = cx.typeck_results().expr_ty_adjusted(self_arg);
             let ref_receiver_ty = cx.tcx.mk_ref(
                 cx.tcx.lifetimes.re_erased,
                 ty::TypeAndMut {
@@ -32,7 +32,7 @@ pub(super) fn check(cx: &LateContext<'_>, args: &[Expr<'_>], arg: &Expr<'_>, met
     }
 
     let mut applicability = Applicability::MachineApplicable;
-    let object = snippet_with_applicability(cx, args[0].span, "_", &mut applicability);
+    let object = snippet_with_applicability(cx, self_arg.span, "_", &mut applicability);
     let muta = if method_name == "iter_mut" { "mut " } else { "" };
     span_lint_and_sugg(
         cx,
diff --git a/clippy_lints/src/loops/mod.rs b/clippy_lints/src/loops/mod.rs
index 28acefd51fe..a4bc3e6bd10 100644
--- a/clippy_lints/src/loops/mod.rs
+++ b/clippy_lints/src/loops/mod.rs
@@ -602,22 +602,19 @@ fn check_for_loop<'tcx>(
 fn check_for_loop_arg(cx: &LateContext<'_>, pat: &Pat<'_>, arg: &Expr<'_>, expr: &Expr<'_>) {
     let mut next_loop_linted = false; // whether or not ITER_NEXT_LOOP lint was used
 
-    if let ExprKind::MethodCall(method, _, args, _) = arg.kind {
-        // just the receiver, no arguments
-        if args.len() == 1 {
-            let method_name = &*method.ident.as_str();
-            // check for looping over x.iter() or x.iter_mut(), could use &x or &mut x
-            match method_name {
-                "iter" | "iter_mut" => explicit_iter_loop::check(cx, args, arg, method_name),
-                "into_iter" => {
-                    explicit_iter_loop::check(cx, args, arg, method_name);
-                    explicit_into_iter_loop::check(cx, args, arg);
-                },
-                "next" => {
-                    next_loop_linted = iter_next_loop::check(cx, arg, expr);
-                },
-                _ => {},
-            }
+    if let ExprKind::MethodCall(method, _, [self_arg], _) = arg.kind {
+        let method_name = &*method.ident.as_str();
+        // check for looping over x.iter() or x.iter_mut(), could use &x or &mut x
+        match method_name {
+            "iter" | "iter_mut" => explicit_iter_loop::check(cx, self_arg, arg, method_name),
+            "into_iter" => {
+                explicit_iter_loop::check(cx, self_arg, arg, method_name);
+                explicit_into_iter_loop::check(cx, self_arg, arg);
+            },
+            "next" => {
+                next_loop_linted = iter_next_loop::check(cx, arg, expr);
+            },
+            _ => {},
         }
     }
 
diff --git a/tests/ui/for_loop_fixable.fixed b/tests/ui/for_loop_fixable.fixed
index 249a88a0b39..f44928d4083 100644
--- a/tests/ui/for_loop_fixable.fixed
+++ b/tests/ui/for_loop_fixable.fixed
@@ -281,3 +281,29 @@ mod issue_4958 {
         for _ in rr.into_iter() {}
     }
 }
+
+// explicit_into_iter_loop
+#[warn(clippy::explicit_into_iter_loop)]
+mod issue_6900 {
+    struct S;
+    impl S {
+        #[allow(clippy::should_implement_trait)]
+        pub fn into_iter<T>(self) -> I<T> {
+            unimplemented!()
+        }
+    }
+
+    struct I<T>(T);
+    impl<T> Iterator for I<T> {
+        type Item = T;
+        fn next(&mut self) -> Option<Self::Item> {
+            unimplemented!()
+        }
+    }
+
+    fn f() {
+        for _ in S.into_iter::<u32>() {
+            unimplemented!()
+        }
+    }
+}
diff --git a/tests/ui/for_loop_fixable.rs b/tests/ui/for_loop_fixable.rs
index 306d85a6351..5b1eb3ee4dc 100644
--- a/tests/ui/for_loop_fixable.rs
+++ b/tests/ui/for_loop_fixable.rs
@@ -281,3 +281,29 @@ mod issue_4958 {
         for _ in rr.into_iter() {}
     }
 }
+
+// explicit_into_iter_loop
+#[warn(clippy::explicit_into_iter_loop)]
+mod issue_6900 {
+    struct S;
+    impl S {
+        #[allow(clippy::should_implement_trait)]
+        pub fn into_iter<T>(self) -> I<T> {
+            unimplemented!()
+        }
+    }
+
+    struct I<T>(T);
+    impl<T> Iterator for I<T> {
+        type Item = T;
+        fn next(&mut self) -> Option<Self::Item> {
+            unimplemented!()
+        }
+    }
+
+    fn f() {
+        for _ in S.into_iter::<u32>() {
+            unimplemented!()
+        }
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 47f0c15f67e334338b82deef1e812f157a54dcf2 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Wed, 24 Mar 2021 09:31:43 -0500
Subject: Symbol optimizations

---
 clippy_lints/src/attrs.rs               | 112 +++++++++++++++-----------------
 clippy_lints/src/excessive_bools.rs     |   6 +-
 clippy_lints/src/functions/must_use.rs  |   6 +-
 clippy_lints/src/macro_use.rs           |   6 +-
 clippy_lints/src/methods/or_fun_call.rs |   6 +-
 clippy_lints/src/option_env_unwrap.rs   |   4 +-
 clippy_utils/src/lib.rs                 |   9 +--
 7 files changed, 67 insertions(+), 82 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs
index 382fb03d920..c5b01461c1c 100644
--- a/clippy_lints/src/attrs.rs
+++ b/clippy_lints/src/attrs.rs
@@ -250,12 +250,8 @@ impl<'tcx> LateLintPass<'tcx> for Attributes {
     fn check_attribute(&mut self, cx: &LateContext<'tcx>, attr: &'tcx Attribute) {
         if let Some(items) = &attr.meta_item_list() {
             if let Some(ident) = attr.ident() {
-                let ident = &*ident.as_str();
-                match ident {
-                    "allow" | "warn" | "deny" | "forbid" => {
-                        check_clippy_lint_names(cx, ident, items);
-                    },
-                    _ => {},
+                if is_lint_level(ident.name) {
+                    check_clippy_lint_names(cx, ident.name, items);
                 }
                 if items.is_empty() || !attr.has_name(sym::deprecated) {
                     return;
@@ -288,60 +284,54 @@ impl<'tcx> LateLintPass<'tcx> for Attributes {
                         return;
                     }
                     if let Some(lint_list) = &attr.meta_item_list() {
-                        if let Some(ident) = attr.ident() {
-                            match &*ident.as_str() {
-                                "allow" | "warn" | "deny" | "forbid" => {
-                                    // permit `unused_imports`, `deprecated`, `unreachable_pub`,
-                                    // `clippy::wildcard_imports`, and `clippy::enum_glob_use` for `use` items
-                                    // and `unused_imports` for `extern crate` items with `macro_use`
-                                    for lint in lint_list {
-                                        match item.kind {
-                                            ItemKind::Use(..) => {
-                                                if is_word(lint, sym!(unused_imports))
-                                                    || is_word(lint, sym::deprecated)
-                                                    || is_word(lint, sym!(unreachable_pub))
-                                                    || is_word(lint, sym!(unused))
-                                                    || extract_clippy_lint(lint)
-                                                        .map_or(false, |s| s == "wildcard_imports")
-                                                    || extract_clippy_lint(lint).map_or(false, |s| s == "enum_glob_use")
-                                                {
-                                                    return;
-                                                }
-                                            },
-                                            ItemKind::ExternCrate(..) => {
-                                                if is_word(lint, sym!(unused_imports)) && skip_unused_imports {
-                                                    return;
-                                                }
-                                                if is_word(lint, sym!(unused_extern_crates)) {
-                                                    return;
-                                                }
-                                            },
-                                            _ => {},
+                        if attr.ident().map_or(false, |ident| is_lint_level(ident.name)) {
+                            // permit `unused_imports`, `deprecated`, `unreachable_pub`,
+                            // `clippy::wildcard_imports`, and `clippy::enum_glob_use` for `use` items
+                            // and `unused_imports` for `extern crate` items with `macro_use`
+                            for lint in lint_list {
+                                match item.kind {
+                                    ItemKind::Use(..) => {
+                                        if is_word(lint, sym!(unused_imports))
+                                            || is_word(lint, sym::deprecated)
+                                            || is_word(lint, sym!(unreachable_pub))
+                                            || is_word(lint, sym!(unused))
+                                            || extract_clippy_lint(lint).map_or(false, |s| s == "wildcard_imports")
+                                            || extract_clippy_lint(lint).map_or(false, |s| s == "enum_glob_use")
+                                        {
+                                            return;
+                                        }
+                                    },
+                                    ItemKind::ExternCrate(..) => {
+                                        if is_word(lint, sym!(unused_imports)) && skip_unused_imports {
+                                            return;
                                         }
-                                    }
-                                    let line_span = first_line_of_span(cx, attr.span);
-
-                                    if let Some(mut sugg) = snippet_opt(cx, line_span) {
-                                        if sugg.contains("#[") {
-                                            span_lint_and_then(
-                                                cx,
-                                                USELESS_ATTRIBUTE,
+                                        if is_word(lint, sym!(unused_extern_crates)) {
+                                            return;
+                                        }
+                                    },
+                                    _ => {},
+                                }
+                            }
+                            let line_span = first_line_of_span(cx, attr.span);
+
+                            if let Some(mut sugg) = snippet_opt(cx, line_span) {
+                                if sugg.contains("#[") {
+                                    span_lint_and_then(
+                                        cx,
+                                        USELESS_ATTRIBUTE,
+                                        line_span,
+                                        "useless lint attribute",
+                                        |diag| {
+                                            sugg = sugg.replacen("#[", "#![", 1);
+                                            diag.span_suggestion(
                                                 line_span,
-                                                "useless lint attribute",
-                                                |diag| {
-                                                    sugg = sugg.replacen("#[", "#![", 1);
-                                                    diag.span_suggestion(
-                                                        line_span,
-                                                        "if you just forgot a `!`, use",
-                                                        sugg,
-                                                        Applicability::MaybeIncorrect,
-                                                    );
-                                                },
+                                                "if you just forgot a `!`, use",
+                                                sugg,
+                                                Applicability::MaybeIncorrect,
                                             );
-                                        }
-                                    }
-                                },
-                                _ => {},
+                                        },
+                                    );
+                                }
                             }
                         }
                     }
@@ -379,10 +369,10 @@ fn extract_clippy_lint(lint: &NestedMetaItem) -> Option<SymbolStr> {
     None
 }
 
-fn check_clippy_lint_names(cx: &LateContext<'_>, ident: &str, items: &[NestedMetaItem]) {
+fn check_clippy_lint_names(cx: &LateContext<'_>, name: Symbol, items: &[NestedMetaItem]) {
     for lint in items {
         if let Some(lint_name) = extract_clippy_lint(lint) {
-            if lint_name == "restriction" && ident != "allow" {
+            if lint_name == "restriction" && name != sym::allow {
                 span_lint_and_help(
                     cx,
                     BLANKET_CLIPPY_RESTRICTION_LINTS,
@@ -647,3 +637,7 @@ fn check_mismatched_target_os(cx: &EarlyContext<'_>, attr: &Attribute) {
         }
     }
 }
+
+fn is_lint_level(symbol: Symbol) -> bool {
+    matches!(symbol, sym::allow | sym::warn | sym::deny | sym::forbid)
+}
diff --git a/clippy_lints/src/excessive_bools.rs b/clippy_lints/src/excessive_bools.rs
index 6c9652fd87d..249ee27330b 100644
--- a/clippy_lints/src/excessive_bools.rs
+++ b/clippy_lints/src/excessive_bools.rs
@@ -1,9 +1,9 @@
 use clippy_utils::diagnostics::span_lint_and_help;
-use clippy_utils::{attr_by_name, in_macro, match_path_ast};
+use clippy_utils::{in_macro, match_path_ast};
 use rustc_ast::ast::{AssocItemKind, Extern, FnKind, FnSig, ImplKind, Item, ItemKind, TraitKind, Ty, TyKind};
 use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::Span;
+use rustc_span::{sym, Span};
 
 use std::convert::TryInto;
 
@@ -138,7 +138,7 @@ impl EarlyLintPass for ExcessiveBools {
         }
         match &item.kind {
             ItemKind::Struct(variant_data, _) => {
-                if attr_by_name(&item.attrs, "repr").is_some() {
+                if item.attrs.iter().any(|attr| attr.has_name(sym::repr)) {
                     return;
                 }
 
diff --git a/clippy_lints/src/functions/must_use.rs b/clippy_lints/src/functions/must_use.rs
index db5fe90b663..9ea8e2eaa2a 100644
--- a/clippy_lints/src/functions/must_use.rs
+++ b/clippy_lints/src/functions/must_use.rs
@@ -8,13 +8,13 @@ use rustc_middle::{
     lint::in_external_macro,
     ty::{self, Ty},
 };
-use rustc_span::Span;
+use rustc_span::{sym, Span};
 
 use clippy_utils::attrs::is_proc_macro;
 use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_then};
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::is_must_use_ty;
-use clippy_utils::{attr_by_name, match_def_path, must_use_attr, return_ty, trait_ref_of_method};
+use clippy_utils::{match_def_path, must_use_attr, return_ty, trait_ref_of_method};
 
 use super::{DOUBLE_MUST_USE, MUST_USE_CANDIDATE, MUST_USE_UNIT};
 
@@ -27,7 +27,7 @@ pub(super) fn check_item(cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) {
         if let Some(attr) = attr {
             check_needless_must_use(cx, sig.decl, item.hir_id(), item.span, fn_header_span, attr);
             return;
-        } else if is_public && !is_proc_macro(cx.sess(), attrs) && attr_by_name(attrs, "no_mangle").is_none() {
+        } else if is_public && !is_proc_macro(cx.sess(), attrs) && !attrs.iter().any(|a| a.has_name(sym::no_mangle)) {
             check_must_use_candidate(
                 cx,
                 sig.decl,
diff --git a/clippy_lints/src/macro_use.rs b/clippy_lints/src/macro_use.rs
index d573c297838..c506d52e746 100644
--- a/clippy_lints/src/macro_use.rs
+++ b/clippy_lints/src/macro_use.rs
@@ -9,7 +9,7 @@ use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::{edition::Edition, Span};
+use rustc_span::{edition::Edition, sym, Span};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for `#[macro_use] use...`.
@@ -110,9 +110,7 @@ impl<'tcx> LateLintPass<'tcx> for MacroUseImports {
             if cx.sess().opts.edition >= Edition::Edition2018;
             if let hir::ItemKind::Use(path, _kind) = &item.kind;
             let attrs = cx.tcx.hir().attrs(item.hir_id());
-            if let Some(mac_attr) = attrs
-                .iter()
-                .find(|attr| attr.ident().map(|s| s.to_string()) == Some("macro_use".to_string()));
+            if let Some(mac_attr) = attrs.iter().find(|attr| attr.has_name(sym::macro_use));
             if let Res::Def(DefKind::Mod, id) = path.res;
             then {
                 for kid in cx.tcx.item_children(id).iter() {
diff --git a/clippy_lints/src/methods/or_fun_call.rs b/clippy_lints/src/methods/or_fun_call.rs
index df89da5d3e0..800172f4cf3 100644
--- a/clippy_lints/src/methods/or_fun_call.rs
+++ b/clippy_lints/src/methods/or_fun_call.rs
@@ -10,7 +10,7 @@ use rustc_hir::{BlockCheckMode, UnsafeSource};
 use rustc_lint::LateContext;
 use rustc_middle::ty;
 use rustc_span::source_map::Span;
-use rustc_span::symbol::sym;
+use rustc_span::symbol::{kw, sym};
 use std::borrow::Cow;
 
 use super::OR_FUN_CALL;
@@ -38,8 +38,8 @@ pub(super) fn check<'tcx>(
             if !or_has_args;
             if name == "unwrap_or";
             if let hir::ExprKind::Path(ref qpath) = fun.kind;
-            let path = &*last_path_segment(qpath).ident.as_str();
-            if ["default", "new"].contains(&path);
+            let path = last_path_segment(qpath).ident.name;
+            if matches!(path, kw::Default | sym::new);
             let arg_ty = cx.typeck_results().expr_ty(arg);
             if let Some(default_trait_id) = get_trait_def_id(cx, &paths::DEFAULT_TRAIT);
             if implements_trait(cx, arg_ty, default_trait_id, &[]);
diff --git a/clippy_lints/src/option_env_unwrap.rs b/clippy_lints/src/option_env_unwrap.rs
index a0bc324e026..b6f518661bd 100644
--- a/clippy_lints/src/option_env_unwrap.rs
+++ b/clippy_lints/src/option_env_unwrap.rs
@@ -4,6 +4,7 @@ use if_chain::if_chain;
 use rustc_ast::ast::{Expr, ExprKind};
 use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::sym;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for usage of `option_env!(...).unwrap()` and
@@ -37,8 +38,7 @@ impl EarlyLintPass for OptionEnvUnwrap {
     fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
         if_chain! {
             if let ExprKind::MethodCall(path_segment, args, _) = &expr.kind;
-            let method_name = path_segment.ident.as_str();
-            if method_name == "expect" || method_name == "unwrap";
+            if matches!(path_segment.ident.name, sym::expect | sym::unwrap);
             if let ExprKind::Call(caller, _) = &args[0].kind;
             if is_direct_expn_of(caller.span, "option_env").is_some();
             then {
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 64f86f5f101..6088cd323c4 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -1203,16 +1203,9 @@ pub fn parent_node_is_if_expr(expr: &Expr<'_>, cx: &LateContext<'_>) -> bool {
     )
 }
 
-// Finds the attribute with the given name, if any
-pub fn attr_by_name<'a>(attrs: &'a [Attribute], name: &'_ str) -> Option<&'a Attribute> {
-    attrs
-        .iter()
-        .find(|attr| attr.ident().map_or(false, |ident| ident.as_str() == name))
-}
-
 // Finds the `#[must_use]` attribute, if any
 pub fn must_use_attr(attrs: &[Attribute]) -> Option<&Attribute> {
-    attr_by_name(attrs, "must_use")
+    attrs.iter().find(|a| a.has_name(sym::must_use))
 }
 
 // check if expr is calling method or function with #[must_use] attribute
-- 
cgit 1.4.1-3-g733a5


From 7468542328caf3f0114ac4733fe2b76e2ed79954 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Fri, 2 Apr 2021 17:09:58 -0500
Subject: Introduce is_lang_ctor

---
 clippy_lints/src/collapsible_match.rs              | 27 ++++-------
 clippy_lints/src/if_then_some_else_none.rs         |  9 ++--
 clippy_lints/src/loops/manual_flatten.rs           | 11 +++--
 clippy_lints/src/manual_map.rs                     | 35 ++++----------
 clippy_lints/src/manual_ok_or.rs                   |  9 ++--
 clippy_lints/src/manual_unwrap_or.rs               | 25 +++++-----
 clippy_lints/src/matches.rs                        | 38 +++++++--------
 clippy_lints/src/mem_replace.rs                    |  7 +--
 clippy_lints/src/methods/option_map_or_none.rs     |  7 +--
 clippy_lints/src/methods/unnecessary_filter_map.rs |  7 +--
 clippy_lints/src/needless_question_mark.rs         |  8 ++--
 clippy_lints/src/option_if_let_else.rs             |  6 +--
 clippy_lints/src/question_mark.rs                  | 17 ++-----
 clippy_lints/src/try_err.rs                        |  5 +-
 clippy_lints/src/unnecessary_wraps.rs              | 11 +++--
 clippy_lints/src/unused_io_amount.rs               |  2 +-
 clippy_utils/src/lib.rs                            | 54 +++++++++-------------
 17 files changed, 121 insertions(+), 157 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/collapsible_match.rs b/clippy_lints/src/collapsible_match.rs
index 04fff237bb4..ab22578abd6 100644
--- a/clippy_lints/src/collapsible_match.rs
+++ b/clippy_lints/src/collapsible_match.rs
@@ -1,11 +1,11 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::visitors::LocalUsedVisitor;
-use clippy_utils::{path_to_local, SpanlessEq};
+use clippy_utils::{is_lang_ctor, path_to_local, SpanlessEq};
 use if_chain::if_chain;
-use rustc_hir::def::{CtorKind, CtorOf, DefKind, Res};
-use rustc_hir::{Arm, Expr, ExprKind, Guard, HirId, Pat, PatKind, QPath, StmtKind, UnOp};
+use rustc_hir::LangItem::OptionNone;
+use rustc_hir::{Arm, Expr, ExprKind, Guard, HirId, Pat, PatKind, StmtKind, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty::{DefIdTree, TyCtxt, TypeckResults};
+use rustc_middle::ty::TypeckResults;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::{MultiSpan, Span};
 
@@ -52,7 +52,7 @@ declare_lint_pass!(CollapsibleMatch => [COLLAPSIBLE_MATCH]);
 impl<'tcx> LateLintPass<'tcx> for CollapsibleMatch {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &Expr<'tcx>) {
         if let ExprKind::Match(_expr, arms, _source) = expr.kind {
-            if let Some(wild_arm) = arms.iter().rfind(|arm| arm_is_wild_like(arm, cx.tcx)) {
+            if let Some(wild_arm) = arms.iter().rfind(|arm| arm_is_wild_like(cx, arm)) {
                 for arm in arms {
                     check_arm(arm, wild_arm, cx);
                 }
@@ -75,7 +75,7 @@ fn check_arm<'tcx>(arm: &Arm<'tcx>, wild_outer_arm: &Arm<'tcx>, cx: &LateContext
         // match <local> { .. }
         if let Some(binding_id) = path_to_local(strip_ref_operators(expr_in, cx.typeck_results()));
         // one of the branches must be "wild-like"
-        if let Some(wild_inner_arm_idx) = arms_inner.iter().rposition(|arm_inner| arm_is_wild_like(arm_inner, cx.tcx));
+        if let Some(wild_inner_arm_idx) = arms_inner.iter().rposition(|arm_inner| arm_is_wild_like(cx, arm_inner));
         let (wild_inner_arm, non_wild_inner_arm) =
             (&arms_inner[wild_inner_arm_idx], &arms_inner[1 - wild_inner_arm_idx]);
         if !pat_contains_or(non_wild_inner_arm.pat);
@@ -126,13 +126,13 @@ fn strip_singleton_blocks<'hir>(mut expr: &'hir Expr<'hir>) -> &'hir Expr<'hir>
 /// A "wild-like" pattern is wild ("_") or `None`.
 /// For this lint to apply, both the outer and inner match expressions
 /// must have "wild-like" branches that can be combined.
-fn arm_is_wild_like(arm: &Arm<'_>, tcx: TyCtxt<'_>) -> bool {
+fn arm_is_wild_like(cx: &LateContext<'_>, arm: &Arm<'_>) -> bool {
     if arm.guard.is_some() {
         return false;
     }
     match arm.pat.kind {
         PatKind::Binding(..) | PatKind::Wild => true,
-        PatKind::Path(QPath::Resolved(None, path)) if is_none_ctor(path.res, tcx) => true,
+        PatKind::Path(ref qpath) => is_lang_ctor(cx, qpath, OptionNone),
         _ => false,
     }
 }
@@ -164,17 +164,6 @@ fn pat_contains_or(pat: &Pat<'_>) -> bool {
     result
 }
 
-fn is_none_ctor(res: Res, tcx: TyCtxt<'_>) -> bool {
-    if let Some(none_id) = tcx.lang_items().option_none_variant() {
-        if let Res::Def(DefKind::Ctor(CtorOf::Variant, CtorKind::Const), id) = res {
-            if let Some(variant_id) = tcx.parent(id) {
-                return variant_id == none_id;
-            }
-        }
-    }
-    false
-}
-
 /// Removes `AddrOf` operators (`&`) or deref operators (`*`), but only if a reference type is
 /// dereferenced. An overloaded deref such as `Vec` to slice would not be removed.
 fn strip_ref_operators<'hir>(mut expr: &'hir Expr<'hir>, typeck_results: &TypeckResults<'_>) -> &'hir Expr<'hir> {
diff --git a/clippy_lints/src/if_then_some_else_none.rs b/clippy_lints/src/if_then_some_else_none.rs
index ee16519692f..f73b3a1fe67 100644
--- a/clippy_lints/src/if_then_some_else_none.rs
+++ b/clippy_lints/src/if_then_some_else_none.rs
@@ -1,7 +1,8 @@
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::source::snippet_with_macro_callsite;
-use clippy_utils::{match_qpath, meets_msrv, parent_node_is_if_expr};
+use clippy_utils::{is_lang_ctor, meets_msrv, parent_node_is_if_expr};
 use if_chain::if_chain;
+use rustc_hir::LangItem::{OptionNone, OptionSome};
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
@@ -77,12 +78,12 @@ impl LateLintPass<'_> for IfThenSomeElseNone {
             if let Some(then_expr) = then_block.expr;
             if let ExprKind::Call(then_call, [then_arg]) = then_expr.kind;
             if let ExprKind::Path(ref then_call_qpath) = then_call.kind;
-            if match_qpath(then_call_qpath, &clippy_utils::paths::OPTION_SOME);
+            if is_lang_ctor(cx, then_call_qpath, OptionSome);
             if let ExprKind::Block(els_block, _) = els.kind;
             if els_block.stmts.is_empty();
             if let Some(els_expr) = els_block.expr;
-            if let ExprKind::Path(ref els_call_qpath) = els_expr.kind;
-            if match_qpath(els_call_qpath, &clippy_utils::paths::OPTION_NONE);
+            if let ExprKind::Path(ref qpath) = els_expr.kind;
+            if is_lang_ctor(cx, qpath, OptionNone);
             then {
                 let cond_snip = snippet_with_macro_callsite(cx, cond.span, "[condition]");
                 let cond_snip = if matches!(cond.kind, ExprKind::Unary(_, _) | ExprKind::Binary(_, _, _)) {
diff --git a/clippy_lints/src/loops/manual_flatten.rs b/clippy_lints/src/loops/manual_flatten.rs
index 94743cfcf46..64ff7574f86 100644
--- a/clippy_lints/src/loops/manual_flatten.rs
+++ b/clippy_lints/src/loops/manual_flatten.rs
@@ -1,10 +1,11 @@
 use super::utils::make_iterator_snippet;
 use super::MANUAL_FLATTEN;
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::{is_ok_ctor, is_some_ctor, path_to_local_id};
+use clippy_utils::{is_lang_ctor, path_to_local_id};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
-use rustc_hir::{Expr, ExprKind, MatchSource, Pat, PatKind, QPath, StmtKind};
+use rustc_hir::LangItem::{OptionSome, ResultOk};
+use rustc_hir::{Expr, ExprKind, MatchSource, Pat, PatKind, StmtKind};
 use rustc_lint::LateContext;
 use rustc_middle::ty;
 use rustc_span::source_map::Span;
@@ -42,9 +43,9 @@ pub(super) fn check<'tcx>(
             if let PatKind::Binding(_, pat_hir_id, _, _) = pat.kind;
             if path_to_local_id(match_expr, pat_hir_id);
             // Ensure the `if let` statement is for the `Some` variant of `Option` or the `Ok` variant of `Result`
-            if let PatKind::TupleStruct(QPath::Resolved(None, path), _, _) = match_arms[0].pat.kind;
-            let some_ctor = is_some_ctor(cx, path.res);
-            let ok_ctor = is_ok_ctor(cx, path.res);
+            if let PatKind::TupleStruct(ref qpath, _, _) = match_arms[0].pat.kind;
+            let some_ctor = is_lang_ctor(cx, qpath, OptionSome);
+            let ok_ctor = is_lang_ctor(cx, qpath, ResultOk);
             if some_ctor || ok_ctor;
             then {
                 let if_let_type = if some_ctor { "Some" } else { "Ok" };
diff --git a/clippy_lints/src/manual_map.rs b/clippy_lints/src/manual_map.rs
index 8c9e3af62f4..29be0739977 100644
--- a/clippy_lints/src/manual_map.rs
+++ b/clippy_lints/src/manual_map.rs
@@ -2,9 +2,10 @@ use crate::{map_unit_fn::OPTION_MAP_UNIT_FN, matches::MATCH_AS_REF};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::{snippet_with_applicability, snippet_with_context};
 use clippy_utils::ty::{can_partially_move_ty, is_type_diagnostic_item, peel_mid_ty_refs_is_mutable};
-use clippy_utils::{in_constant, is_allowed, is_else_clause, match_def_path, match_var, paths, peel_hir_expr_refs};
+use clippy_utils::{in_constant, is_allowed, is_else_clause, is_lang_ctor, match_var, peel_hir_expr_refs};
 use rustc_ast::util::parser::PREC_POSTFIX;
 use rustc_errors::Applicability;
+use rustc_hir::LangItem::{OptionNone, OptionSome};
 use rustc_hir::{
     def::Res,
     intravisit::{walk_expr, ErasedMap, NestedVisitorMap, Visitor},
@@ -269,20 +270,9 @@ fn try_parse_pattern(cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>, ctxt: SyntaxCon
         match pat.kind {
             PatKind::Wild => Some(OptionPat::Wild),
             PatKind::Ref(pat, _) => f(cx, pat, ref_count + 1, ctxt),
-            PatKind::Path(QPath::Resolved(None, path))
-                if path
-                    .res
-                    .opt_def_id()
-                    .map_or(false, |id| match_def_path(cx, id, &paths::OPTION_NONE)) =>
-            {
-                Some(OptionPat::None)
-            },
-            PatKind::TupleStruct(QPath::Resolved(None, path), [pattern], _)
-                if path
-                    .res
-                    .opt_def_id()
-                    .map_or(false, |id| match_def_path(cx, id, &paths::OPTION_SOME))
-                    && pat.span.ctxt() == ctxt =>
+            PatKind::Path(ref qpath) if is_lang_ctor(cx, qpath, OptionNone) => Some(OptionPat::None),
+            PatKind::TupleStruct(ref qpath, [pattern], _)
+                if is_lang_ctor(cx, qpath, OptionSome) && pat.span.ctxt() == ctxt =>
             {
                 Some(OptionPat::Some { pattern, ref_count })
             },
@@ -298,17 +288,11 @@ fn get_some_expr(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, ctxt: SyntaxConte
     match expr.kind {
         ExprKind::Call(
             Expr {
-                kind: ExprKind::Path(QPath::Resolved(None, path)),
+                kind: ExprKind::Path(ref qpath),
                 ..
             },
             [arg],
-        ) if ctxt == expr.span.ctxt() => {
-            if match_def_path(cx, path.res.opt_def_id()?, &paths::OPTION_SOME) {
-                Some(arg)
-            } else {
-                None
-            }
-        },
+        ) if ctxt == expr.span.ctxt() && is_lang_ctor(cx, qpath, OptionSome) => Some(arg),
         ExprKind::Block(
             Block {
                 stmts: [],
@@ -324,10 +308,7 @@ fn get_some_expr(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, ctxt: SyntaxConte
 // Checks for the `None` value.
 fn is_none_expr(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> bool {
     match expr.kind {
-        ExprKind::Path(QPath::Resolved(None, path)) => path
-            .res
-            .opt_def_id()
-            .map_or(false, |id| match_def_path(cx, id, &paths::OPTION_NONE)),
+        ExprKind::Path(ref qpath) => is_lang_ctor(cx, qpath, OptionNone),
         ExprKind::Block(
             Block {
                 stmts: [],
diff --git a/clippy_lints/src/manual_ok_or.rs b/clippy_lints/src/manual_ok_or.rs
index 9bfae602c40..847c8c648b0 100644
--- a/clippy_lints/src/manual_ok_or.rs
+++ b/clippy_lints/src/manual_ok_or.rs
@@ -1,9 +1,10 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::{indent_of, reindent_multiline, snippet_opt};
 use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{match_qpath, path_to_local_id, paths};
+use clippy_utils::{is_lang_ctor, path_to_local_id};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
+use rustc_hir::LangItem::{ResultErr, ResultOk};
 use rustc_hir::{Expr, ExprKind, PatKind};
 use rustc_lint::LintContext;
 use rustc_lint::{LateContext, LateLintPass};
@@ -54,7 +55,7 @@ impl LateLintPass<'_> for ManualOkOr {
             let or_expr = &args[1];
             if is_ok_wrapping(cx, &args[2]);
             if let ExprKind::Call(Expr { kind: ExprKind::Path(err_path), .. }, &[ref err_arg]) = or_expr.kind;
-            if match_qpath(err_path, &paths::RESULT_ERR);
+            if is_lang_ctor(cx, err_path, ResultErr);
             if let Some(method_receiver_snippet) = snippet_opt(cx, method_receiver.span);
             if let Some(err_arg_snippet) = snippet_opt(cx, err_arg.span);
             if let Some(indent) = indent_of(cx, scrutinee.span);
@@ -81,7 +82,7 @@ impl LateLintPass<'_> for ManualOkOr {
 
 fn is_ok_wrapping(cx: &LateContext<'_>, map_expr: &Expr<'_>) -> bool {
     if let ExprKind::Path(ref qpath) = map_expr.kind {
-        if match_qpath(qpath, &paths::RESULT_OK) {
+        if is_lang_ctor(cx, qpath, ResultOk) {
             return true;
         }
     }
@@ -90,7 +91,7 @@ fn is_ok_wrapping(cx: &LateContext<'_>, map_expr: &Expr<'_>) -> bool {
         let body = cx.tcx.hir().body(body_id);
         if let PatKind::Binding(_, param_id, ..) = body.params[0].pat.kind;
         if let ExprKind::Call(Expr { kind: ExprKind::Path(ok_path), .. }, &[ref ok_arg]) = body.value.kind;
-        if match_qpath(ok_path, &paths::RESULT_OK);
+        if is_lang_ctor(cx, ok_path, ResultOk);
         then { path_to_local_id(ok_arg, param_id) } else { false }
     }
 }
diff --git a/clippy_lints/src/manual_unwrap_or.rs b/clippy_lints/src/manual_unwrap_or.rs
index f296d6a1a15..65baa2552cc 100644
--- a/clippy_lints/src/manual_unwrap_or.rs
+++ b/clippy_lints/src/manual_unwrap_or.rs
@@ -3,10 +3,11 @@ use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::{indent_of, reindent_multiline, snippet_opt};
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::usage::contains_return_break_continue_macro;
-use clippy_utils::{in_constant, match_qpath, path_to_local_id, paths, sugg};
+use clippy_utils::{in_constant, is_lang_ctor, path_to_local_id, sugg};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
-use rustc_hir::{Arm, Expr, ExprKind, Pat, PatKind};
+use rustc_hir::LangItem::{OptionNone, OptionSome, ResultErr, ResultOk};
+use rustc_hir::{Arm, Expr, ExprKind, PatKind};
 use rustc_lint::LintContext;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::lint::in_external_macro;
@@ -68,23 +69,21 @@ impl Case {
 }
 
 fn lint_manual_unwrap_or<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
-    fn applicable_or_arm<'a>(arms: &'a [Arm<'a>]) -> Option<&'a Arm<'a>> {
+    fn applicable_or_arm<'a>(cx: &LateContext<'_>, arms: &'a [Arm<'a>]) -> Option<&'a Arm<'a>> {
         if_chain! {
             if arms.len() == 2;
             if arms.iter().all(|arm| arm.guard.is_none());
-            if let Some((idx, or_arm)) = arms.iter().enumerate().find(|(_, arm)|
+            if let Some((idx, or_arm)) = arms.iter().enumerate().find(|(_, arm)| {
                 match arm.pat.kind {
-                    PatKind::Path(ref some_qpath) =>
-                        match_qpath(some_qpath, &paths::OPTION_NONE),
-                    PatKind::TupleStruct(ref err_qpath, &[Pat { kind: PatKind::Wild, .. }], _) =>
-                        match_qpath(err_qpath, &paths::RESULT_ERR),
+                    PatKind::Path(ref qpath) => is_lang_ctor(cx, qpath, OptionNone),
+                    PatKind::TupleStruct(ref qpath, &[pat], _) =>
+                        matches!(pat.kind, PatKind::Wild) && is_lang_ctor(cx, qpath, ResultErr),
                     _ => false,
                 }
-            );
+            });
             let unwrap_arm = &arms[1 - idx];
-            if let PatKind::TupleStruct(ref unwrap_qpath, &[unwrap_pat], _) = unwrap_arm.pat.kind;
-            if match_qpath(unwrap_qpath, &paths::OPTION_SOME)
-                || match_qpath(unwrap_qpath, &paths::RESULT_OK);
+            if let PatKind::TupleStruct(ref qpath, &[unwrap_pat], _) = unwrap_arm.pat.kind;
+            if is_lang_ctor(cx, qpath, OptionSome) || is_lang_ctor(cx, qpath, ResultOk);
             if let PatKind::Binding(_, binding_hir_id, ..) = unwrap_pat.kind;
             if path_to_local_id(unwrap_arm.body, binding_hir_id);
             if !contains_return_break_continue_macro(or_arm.body);
@@ -106,7 +105,7 @@ fn lint_manual_unwrap_or<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
         } else {
             None
         };
-        if let Some(or_arm) = applicable_or_arm(match_arms);
+        if let Some(or_arm) = applicable_or_arm(cx, match_arms);
         if let Some(or_body_snippet) = snippet_opt(cx, or_arm.body.span);
         if let Some(indent) = indent_of(cx, expr.span);
         if constant_simple(cx, cx.typeck_results(), or_arm.body).is_some();
diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index a892e24482b..72f5eed6531 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -7,7 +7,7 @@ use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::{implements_trait, is_type_diagnostic_item, match_type, peel_mid_ty_refs};
 use clippy_utils::visitors::LocalUsedVisitor;
 use clippy_utils::{
-    get_parent_expr, in_macro, is_allowed, is_expn_of, is_refutable, is_wild, match_qpath, meets_msrv, path_to_local,
+    get_parent_expr, in_macro, is_allowed, is_expn_of, is_lang_ctor, is_refutable, is_wild, meets_msrv, path_to_local,
     path_to_local_id, peel_hir_pat_refs, peel_n_hir_expr_refs, recurse_or_patterns, remove_blocks, strip_pat_refs,
 };
 use clippy_utils::{paths, search_same, SpanlessEq, SpanlessHash};
@@ -15,6 +15,7 @@ use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::def::{CtorKind, DefKind, Res};
+use rustc_hir::LangItem::{OptionNone, OptionSome};
 use rustc_hir::{
     self as hir, Arm, BindingAnnotation, Block, BorrowKind, Expr, ExprKind, Guard, HirId, Local, MatchSource,
     Mutability, Node, Pat, PatKind, PathSegment, QPath, RangeEnd, TyKind,
@@ -1188,10 +1189,10 @@ fn check_match_ref_pats(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>], e
 
 fn check_match_as_ref(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>], expr: &Expr<'_>) {
     if arms.len() == 2 && arms[0].guard.is_none() && arms[1].guard.is_none() {
-        let arm_ref: Option<BindingAnnotation> = if is_none_arm(&arms[0]) {
-            is_ref_some_arm(&arms[1])
-        } else if is_none_arm(&arms[1]) {
-            is_ref_some_arm(&arms[0])
+        let arm_ref: Option<BindingAnnotation> = if is_none_arm(cx, &arms[0]) {
+            is_ref_some_arm(cx, &arms[1])
+        } else if is_none_arm(cx, &arms[1]) {
+            is_ref_some_arm(cx, &arms[0])
         } else {
             None
         };
@@ -1574,20 +1575,20 @@ fn is_unit_expr(expr: &Expr<'_>) -> bool {
 }
 
 // Checks if arm has the form `None => None`
-fn is_none_arm(arm: &Arm<'_>) -> bool {
-    matches!(arm.pat.kind, PatKind::Path(ref path) if match_qpath(path, &paths::OPTION_NONE))
+fn is_none_arm(cx: &LateContext<'_>, arm: &Arm<'_>) -> bool {
+    matches!(arm.pat.kind, PatKind::Path(ref qpath) if is_lang_ctor(cx, qpath, OptionNone))
 }
 
 // Checks if arm has the form `Some(ref v) => Some(v)` (checks for `ref` and `ref mut`)
-fn is_ref_some_arm(arm: &Arm<'_>) -> Option<BindingAnnotation> {
+fn is_ref_some_arm(cx: &LateContext<'_>, arm: &Arm<'_>) -> Option<BindingAnnotation> {
     if_chain! {
-        if let PatKind::TupleStruct(ref path, pats, _) = arm.pat.kind;
-        if pats.len() == 1 && match_qpath(path, &paths::OPTION_SOME);
+        if let PatKind::TupleStruct(ref qpath, pats, _) = arm.pat.kind;
+        if is_lang_ctor(cx, qpath, OptionSome);
         if let PatKind::Binding(rb, .., ident, _) = pats[0].kind;
         if rb == BindingAnnotation::Ref || rb == BindingAnnotation::RefMut;
         if let ExprKind::Call(e, args) = remove_blocks(arm.body).kind;
         if let ExprKind::Path(ref some_path) = e.kind;
-        if match_qpath(some_path, &paths::OPTION_SOME) && args.len() == 1;
+        if is_lang_ctor(cx, some_path, OptionSome) && args.len() == 1;
         if let ExprKind::Path(QPath::Resolved(_, path2)) = args[0].kind;
         if path2.segments.len() == 1 && ident.name == path2.segments[0].ident.name;
         then {
@@ -1699,10 +1700,11 @@ mod redundant_pattern_match {
     use super::REDUNDANT_PATTERN_MATCHING;
     use clippy_utils::diagnostics::span_lint_and_then;
     use clippy_utils::source::snippet;
-    use clippy_utils::{is_trait_method, match_qpath, paths};
+    use clippy_utils::{is_lang_ctor, is_trait_method, match_qpath, paths};
     use if_chain::if_chain;
     use rustc_ast::ast::LitKind;
     use rustc_errors::Applicability;
+    use rustc_hir::LangItem::{OptionNone, OptionSome, PollPending, PollReady, ResultErr, ResultOk};
     use rustc_hir::{Arm, Expr, ExprKind, MatchSource, PatKind, QPath};
     use rustc_lint::LateContext;
     use rustc_span::sym;
@@ -1734,13 +1736,13 @@ mod redundant_pattern_match {
         let good_method = match kind {
             PatKind::TupleStruct(ref path, patterns, _) if patterns.len() == 1 => {
                 if let PatKind::Wild = patterns[0].kind {
-                    if match_qpath(path, &paths::RESULT_OK) {
+                    if is_lang_ctor(cx, path, ResultOk) {
                         "is_ok()"
-                    } else if match_qpath(path, &paths::RESULT_ERR) {
+                    } else if is_lang_ctor(cx, path, ResultErr) {
                         "is_err()"
-                    } else if match_qpath(path, &paths::OPTION_SOME) {
+                    } else if is_lang_ctor(cx, path, OptionSome) {
                         "is_some()"
-                    } else if match_qpath(path, &paths::POLL_READY) {
+                    } else if is_lang_ctor(cx, path, PollReady) {
                         "is_ready()"
                     } else if match_qpath(path, &paths::IPADDR_V4) {
                         "is_ipv4()"
@@ -1754,9 +1756,9 @@ mod redundant_pattern_match {
                 }
             },
             PatKind::Path(ref path) => {
-                if match_qpath(path, &paths::OPTION_NONE) {
+                if is_lang_ctor(cx, path, OptionNone) {
                     "is_none()"
-                } else if match_qpath(path, &paths::POLL_PENDING) {
+                } else if is_lang_ctor(cx, path, PollPending) {
                     "is_pending()"
                 } else {
                     return;
diff --git a/clippy_lints/src/mem_replace.rs b/clippy_lints/src/mem_replace.rs
index e1d351aee45..1f521ec6090 100644
--- a/clippy_lints/src/mem_replace.rs
+++ b/clippy_lints/src/mem_replace.rs
@@ -1,10 +1,11 @@
 use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg, span_lint_and_then};
-use clippy_utils::is_diagnostic_assoc_item;
 use clippy_utils::source::{snippet, snippet_with_applicability};
-use clippy_utils::{in_macro, match_def_path, match_qpath, meets_msrv, paths};
+use clippy_utils::{in_macro, match_def_path, meets_msrv, paths};
+use clippy_utils::{is_diagnostic_assoc_item, is_lang_ctor};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::def_id::DefId;
+use rustc_hir::LangItem::OptionNone;
 use rustc_hir::{BorrowKind, Expr, ExprKind, Mutability, QPath};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
@@ -102,7 +103,7 @@ impl_lint_pass!(MemReplace =>
 fn check_replace_option_with_none(cx: &LateContext<'_>, src: &Expr<'_>, dest: &Expr<'_>, expr_span: Span) {
     if let ExprKind::Path(ref replacement_qpath) = src.kind {
         // Check that second argument is `Option::None`
-        if match_qpath(replacement_qpath, &paths::OPTION_NONE) {
+        if is_lang_ctor(cx, replacement_qpath, OptionNone) {
             // Since this is a late pass (already type-checked),
             // and we already know that the second argument is an
             // `Option`, we do not need to check the first
diff --git a/clippy_lints/src/methods/option_map_or_none.rs b/clippy_lints/src/methods/option_map_or_none.rs
index 013a6f90ac9..36a1c13d5be 100644
--- a/clippy_lints/src/methods/option_map_or_none.rs
+++ b/clippy_lints/src/methods/option_map_or_none.rs
@@ -1,9 +1,10 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::is_lang_ctor;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{match_qpath, paths};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
+use rustc_hir::LangItem::{OptionNone, OptionSome};
 use rustc_lint::LateContext;
 use rustc_span::symbol::sym;
 
@@ -32,7 +33,7 @@ pub(super) fn check<'tcx>(
 
     let (lint_name, msg, instead, hint) = {
         let default_arg_is_none = if let hir::ExprKind::Path(ref qpath) = def_arg.kind {
-            match_qpath(qpath, &paths::OPTION_NONE)
+            is_lang_ctor(cx, qpath, OptionNone)
         } else {
             return;
         };
@@ -43,7 +44,7 @@ pub(super) fn check<'tcx>(
         }
 
         let f_arg_is_some = if let hir::ExprKind::Path(ref qpath) = map_arg.kind {
-            match_qpath(qpath, &paths::OPTION_SOME)
+            is_lang_ctor(cx, qpath, OptionSome)
         } else {
             false
         };
diff --git a/clippy_lints/src/methods/unnecessary_filter_map.rs b/clippy_lints/src/methods/unnecessary_filter_map.rs
index 0f28bfdf09e..66255b77331 100644
--- a/clippy_lints/src/methods/unnecessary_filter_map.rs
+++ b/clippy_lints/src/methods/unnecessary_filter_map.rs
@@ -1,8 +1,9 @@
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::usage::mutated_variables;
-use clippy_utils::{is_trait_method, match_qpath, path_to_local_id, paths};
+use clippy_utils::{is_lang_ctor, is_trait_method, path_to_local_id};
 use rustc_hir as hir;
 use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
+use rustc_hir::LangItem::{OptionNone, OptionSome};
 use rustc_lint::LateContext;
 use rustc_middle::hir::map::Map;
 use rustc_span::sym;
@@ -54,7 +55,7 @@ fn check_expression<'tcx>(cx: &LateContext<'tcx>, arg_id: hir::HirId, expr: &'tc
     match &expr.kind {
         hir::ExprKind::Call(func, args) => {
             if let hir::ExprKind::Path(ref path) = func.kind {
-                if match_qpath(path, &paths::OPTION_SOME) {
+                if is_lang_ctor(cx, path, OptionSome) {
                     if path_to_local_id(&args[0], arg_id) {
                         return (false, false);
                     }
@@ -85,7 +86,7 @@ fn check_expression<'tcx>(cx: &LateContext<'tcx>, arg_id: hir::HirId, expr: &'tc
             let else_check = check_expression(cx, arg_id, else_arm);
             (if_check.0 | else_check.0, if_check.1 | else_check.1)
         },
-        hir::ExprKind::Path(path) if match_qpath(path, &paths::OPTION_NONE) => (false, true),
+        hir::ExprKind::Path(path) if is_lang_ctor(cx, path, OptionNone) => (false, true),
         _ => (true, true),
     }
 }
diff --git a/clippy_lints/src/needless_question_mark.rs b/clippy_lints/src/needless_question_mark.rs
index 9852633b734..cfe7ae6630e 100644
--- a/clippy_lints/src/needless_question_mark.rs
+++ b/clippy_lints/src/needless_question_mark.rs
@@ -1,9 +1,11 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::is_lang_ctor;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{differing_macro_contexts, is_ok_ctor, is_some_ctor, meets_msrv};
+use clippy_utils::{differing_macro_contexts, meets_msrv};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
+use rustc_hir::LangItem::{OptionSome, ResultOk};
 use rustc_hir::{Body, Expr, ExprKind, LangItem, MatchSource, QPath};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_semver::RustcVersion;
@@ -159,8 +161,8 @@ fn is_some_or_ok_call<'a>(
     if_chain! {
         // Check outer expression matches CALL_IDENT(ARGUMENT) format
         if let ExprKind::Call(path, args) = &expr.kind;
-        if let ExprKind::Path(QPath::Resolved(None, path)) = &path.kind;
-        if is_some_ctor(cx, path.res) || is_ok_ctor(cx, path.res);
+        if let ExprKind::Path(ref qpath) = &path.kind;
+        if is_lang_ctor(cx, qpath, OptionSome) || is_lang_ctor(cx, qpath, ResultOk);
 
         // Extract inner expression from ARGUMENT
         if let ExprKind::Match(inner_expr_with_q, _, MatchSource::TryDesugar) = &args[0].kind;
diff --git a/clippy_lints/src/option_if_let_else.rs b/clippy_lints/src/option_if_let_else.rs
index 1b9120ae45f..e527adbb892 100644
--- a/clippy_lints/src/option_if_let_else.rs
+++ b/clippy_lints/src/option_if_let_else.rs
@@ -1,11 +1,11 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::paths;
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::usage::contains_return_break_continue_macro;
-use clippy_utils::{eager_or_lazy, get_enclosing_block, in_macro, match_qpath};
+use clippy_utils::{eager_or_lazy, get_enclosing_block, in_macro, is_lang_ctor};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
+use rustc_hir::LangItem::OptionSome;
 use rustc_hir::{Arm, BindingAnnotation, Block, Expr, ExprKind, MatchSource, Mutability, PatKind, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -164,7 +164,7 @@ fn detect_option_if_let_else<'tcx>(
         if arms.len() == 2;
         if !is_result_ok(cx, cond_expr); // Don't lint on Result::ok because a different lint does it already
         if let PatKind::TupleStruct(struct_qpath, &[inner_pat], _) = &arms[0].pat.kind;
-        if match_qpath(struct_qpath, &paths::OPTION_SOME);
+        if is_lang_ctor(cx, struct_qpath, OptionSome);
         if let PatKind::Binding(bind_annotation, _, id, _) = &inner_pat.kind;
         if !contains_return_break_continue_macro(arms[0].body);
         if !contains_return_break_continue_macro(arms[1].body);
diff --git a/clippy_lints/src/question_mark.rs b/clippy_lints/src/question_mark.rs
index 6d720f43851..ea9ff37e13f 100644
--- a/clippy_lints/src/question_mark.rs
+++ b/clippy_lints/src/question_mark.rs
@@ -1,12 +1,13 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::is_lang_ctor;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{eq_expr_value, match_def_path, match_qpath, paths};
+use clippy_utils::{eq_expr_value, match_qpath};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
-use rustc_hir::def::{DefKind, Res};
-use rustc_hir::{def, BindingAnnotation, Block, Expr, ExprKind, MatchSource, PatKind, StmtKind};
+use rustc_hir::LangItem::OptionNone;
+use rustc_hir::{BindingAnnotation, Block, Expr, ExprKind, MatchSource, PatKind, StmtKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::sym;
@@ -156,15 +157,7 @@ impl QuestionMark {
                 false
             },
             ExprKind::Ret(Some(expr)) => Self::expression_returns_none(cx, expr),
-            ExprKind::Path(ref qp) => {
-                if let Res::Def(DefKind::Ctor(def::CtorOf::Variant, def::CtorKind::Const), def_id) =
-                    cx.qpath_res(qp, expression.hir_id)
-                {
-                    return match_def_path(cx, def_id, &paths::OPTION_NONE);
-                }
-
-                false
-            },
+            ExprKind::Path(ref qpath) => is_lang_ctor(cx, qpath, OptionNone),
             _ => false,
         }
     }
diff --git a/clippy_lints/src/try_err.rs b/clippy_lints/src/try_err.rs
index 23a1953ffac..0b8c03c6865 100644
--- a/clippy_lints/src/try_err.rs
+++ b/clippy_lints/src/try_err.rs
@@ -1,9 +1,10 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::{snippet, snippet_with_macro_callsite};
 use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{differing_macro_contexts, in_macro, match_def_path, match_qpath, paths};
+use clippy_utils::{differing_macro_contexts, in_macro, is_lang_ctor, match_def_path, paths};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
+use rustc_hir::LangItem::ResultErr;
 use rustc_hir::{Expr, ExprKind, LangItem, MatchSource, QPath};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::lint::in_external_macro;
@@ -68,7 +69,7 @@ impl<'tcx> LateLintPass<'tcx> for TryErr {
             if let ExprKind::Call(err_fun, err_args) = try_arg.kind;
             if let Some(err_arg) = err_args.get(0);
             if let ExprKind::Path(ref err_fun_path) = err_fun.kind;
-            if match_qpath(err_fun_path, &paths::RESULT_ERR);
+            if is_lang_ctor(cx, err_fun_path, ResultErr);
             if let Some(return_ty) = find_return_type(cx, &expr.kind);
             then {
                 let prefix;
diff --git a/clippy_lints/src/unnecessary_wraps.rs b/clippy_lints/src/unnecessary_wraps.rs
index 5bb417cb1be..d2c0f60d296 100644
--- a/clippy_lints/src/unnecessary_wraps.rs
+++ b/clippy_lints/src/unnecessary_wraps.rs
@@ -1,9 +1,10 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet;
-use clippy_utils::{contains_return, in_macro, match_qpath, paths, return_ty, visitors::find_all_ret_expressions};
+use clippy_utils::{contains_return, in_macro, is_lang_ctor, return_ty, visitors::find_all_ret_expressions};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::FnKind;
+use rustc_hir::LangItem::{OptionSome, ResultOk};
 use rustc_hir::{Body, ExprKind, FnDecl, HirId, Impl, ItemKind, Node};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
@@ -85,11 +86,11 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryWraps {
         }
 
         // Get the wrapper and inner types, if can't, abort.
-        let (return_type_label, path, inner_type) = if let ty::Adt(adt_def, subst) = return_ty(cx, hir_id).kind() {
+        let (return_type_label, lang_item, inner_type) = if let ty::Adt(adt_def, subst) = return_ty(cx, hir_id).kind() {
             if cx.tcx.is_diagnostic_item(sym::option_type, adt_def.did) {
-                ("Option", &paths::OPTION_SOME, subst.type_at(0))
+                ("Option", OptionSome, subst.type_at(0))
             } else if cx.tcx.is_diagnostic_item(sym::result_type, adt_def.did) {
-                ("Result", &paths::RESULT_OK, subst.type_at(0))
+                ("Result", ResultOk, subst.type_at(0))
             } else {
                 return;
             }
@@ -107,7 +108,7 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryWraps {
                 // Get the Path of the function call.
                 if let ExprKind::Path(ref qpath) = func.kind;
                 // Check if OPTION_SOME or RESULT_OK, depending on return type.
-                if match_qpath(qpath, path);
+                if is_lang_ctor(cx, qpath, lang_item);
                 if args.len() == 1;
                 // Make sure the function argument does not contain a return expression.
                 if !contains_return(&args[0]);
diff --git a/clippy_lints/src/unused_io_amount.rs b/clippy_lints/src/unused_io_amount.rs
index 024ab03fd41..5e8e530f480 100644
--- a/clippy_lints/src/unused_io_amount.rs
+++ b/clippy_lints/src/unused_io_amount.rs
@@ -41,7 +41,7 @@ impl<'tcx> LateLintPass<'tcx> for UnusedIoAmount {
         };
 
         match expr.kind {
-            hir::ExprKind::Match(res, _, _) if is_try(expr).is_some() => {
+            hir::ExprKind::Match(res, _, _) if is_try(cx, expr).is_some() => {
                 if let hir::ExprKind::Call(func, args) = res.kind {
                     if matches!(
                         func.kind,
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 64f86f5f101..1d61b7dd412 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -56,9 +56,10 @@ use if_chain::if_chain;
 use rustc_ast::ast::{self, Attribute, BorrowKind, LitKind};
 use rustc_data_structures::fx::FxHashMap;
 use rustc_hir as hir;
-use rustc_hir::def::{CtorKind, CtorOf, DefKind, Res};
+use rustc_hir::def::{DefKind, Res};
 use rustc_hir::def_id::{DefId, LOCAL_CRATE};
 use rustc_hir::intravisit::{self, NestedVisitorMap, Visitor};
+use rustc_hir::LangItem::{ResultErr, ResultOk};
 use rustc_hir::{
     def, Arm, BindingAnnotation, Block, Body, Constness, Expr, ExprKind, FnDecl, GenericArgs, HirId, Impl, ImplItem,
     ImplItemKind, Item, ItemKind, LangItem, MatchSource, Node, Param, Pat, PatKind, Path, PathSegment, QPath,
@@ -221,6 +222,19 @@ pub fn in_constant(cx: &LateContext<'_>, id: HirId) -> bool {
     }
 }
 
+/// Checks if a `QPath` resolves to a constructor of a `LangItem`.
+/// For example, use this to check whether a function call or a pattern is `Some(..)`.
+pub fn is_lang_ctor(cx: &LateContext<'_>, qpath: &QPath<'_>, lang_item: LangItem) -> bool {
+    if let QPath::Resolved(_, path) = qpath {
+        if let Res::Def(DefKind::Ctor(..), ctor_id) = path.res {
+            if let Ok(item_id) = cx.tcx.lang_items().require(lang_item) {
+                return cx.tcx.parent(ctor_id) == Some(item_id);
+            }
+        }
+    }
+    false
+}
+
 /// Returns `true` if this `span` was expanded by any macro.
 #[must_use]
 pub fn in_macro(span: Span) -> bool {
@@ -1010,11 +1024,11 @@ pub fn iter_input_pats<'tcx>(decl: &FnDecl<'_>, body: &'tcx Body<'_>) -> impl It
 
 /// Checks if a given expression is a match expression expanded from the `?`
 /// operator or the `try` macro.
-pub fn is_try<'tcx>(expr: &'tcx Expr<'tcx>) -> Option<&'tcx Expr<'tcx>> {
-    fn is_ok(arm: &Arm<'_>) -> bool {
+pub fn is_try<'tcx>(cx: &LateContext<'_>, expr: &'tcx Expr<'tcx>) -> Option<&'tcx Expr<'tcx>> {
+    fn is_ok(cx: &LateContext<'_>, arm: &Arm<'_>) -> bool {
         if_chain! {
             if let PatKind::TupleStruct(ref path, ref pat, None) = arm.pat.kind;
-            if match_qpath(path, &paths::RESULT_OK[1..]);
+            if is_lang_ctor(cx, path, ResultOk);
             if let PatKind::Binding(_, hir_id, _, None) = pat[0].kind;
             if path_to_local_id(arm.body, hir_id);
             then {
@@ -1024,9 +1038,9 @@ pub fn is_try<'tcx>(expr: &'tcx Expr<'tcx>) -> Option<&'tcx Expr<'tcx>> {
         false
     }
 
-    fn is_err(arm: &Arm<'_>) -> bool {
+    fn is_err(cx: &LateContext<'_>, arm: &Arm<'_>) -> bool {
         if let PatKind::TupleStruct(ref path, _, _) = arm.pat.kind {
-            match_qpath(path, &paths::RESULT_ERR[1..])
+            is_lang_ctor(cx, path, ResultErr)
         } else {
             false
         }
@@ -1042,8 +1056,8 @@ pub fn is_try<'tcx>(expr: &'tcx Expr<'tcx>) -> Option<&'tcx Expr<'tcx>> {
             if arms.len() == 2;
             if arms[0].guard.is_none();
             if arms[1].guard.is_none();
-            if (is_ok(&arms[0]) && is_err(&arms[1])) ||
-                (is_ok(&arms[1]) && is_err(&arms[0]));
+            if (is_ok(cx, &arms[0]) && is_err(cx, &arms[1])) ||
+                (is_ok(cx, &arms[1]) && is_err(cx, &arms[0]));
             then {
                 return Some(expr);
             }
@@ -1456,27 +1470,3 @@ pub fn is_hir_ty_cfg_dependant(cx: &LateContext<'_>, ty: &hir::Ty<'_>) -> bool {
         }
     }
 }
-
-/// Check if the resolution of a given path is an `Ok` variant of `Result`.
-pub fn is_ok_ctor(cx: &LateContext<'_>, res: Res) -> bool {
-    if let Some(ok_id) = cx.tcx.lang_items().result_ok_variant() {
-        if let Res::Def(DefKind::Ctor(CtorOf::Variant, CtorKind::Fn), id) = res {
-            if let Some(variant_id) = cx.tcx.parent(id) {
-                return variant_id == ok_id;
-            }
-        }
-    }
-    false
-}
-
-/// Check if the resolution of a given path is a `Some` variant of `Option`.
-pub fn is_some_ctor(cx: &LateContext<'_>, res: Res) -> bool {
-    if let Some(some_id) = cx.tcx.lang_items().option_some_variant() {
-        if let Res::Def(DefKind::Ctor(CtorOf::Variant, CtorKind::Fn), id) = res {
-            if let Some(variant_id) = cx.tcx.parent(id) {
-                return variant_id == some_id;
-            }
-        }
-    }
-    false
-}
-- 
cgit 1.4.1-3-g733a5


From 4f7fc11ef17e3afb0175b965995cad2f9d7ab210 Mon Sep 17 00:00:00 2001
From: boxdot <d@zerovolt.org>
Date: Sun, 18 Oct 2020 13:42:09 +0200
Subject: Add invalid null pointer usage lint.

---
 CHANGELOG.md                                 |   1 +
 clippy_lints/src/lib.rs                      |   3 +
 clippy_lints/src/ptr.rs                      |  95 +++++++++++++++--
 clippy_lints/src/size_of_in_element_count.rs |   4 +-
 clippy_utils/src/paths.rs                    |  13 ++-
 tests/ui/invalid_null_ptr_usage.fixed        |  49 +++++++++
 tests/ui/invalid_null_ptr_usage.rs           |  49 +++++++++
 tests/ui/invalid_null_ptr_usage.stderr       | 154 +++++++++++++++++++++++++++
 8 files changed, 353 insertions(+), 15 deletions(-)
 create mode 100644 tests/ui/invalid_null_ptr_usage.fixed
 create mode 100644 tests/ui/invalid_null_ptr_usage.rs
 create mode 100644 tests/ui/invalid_null_ptr_usage.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 73997192ae0..715f4702e95 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2267,6 +2267,7 @@ Released 2018-09-13
 [`into_iter_on_array`]: https://rust-lang.github.io/rust-clippy/master/index.html#into_iter_on_array
 [`into_iter_on_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#into_iter_on_ref
 [`invalid_atomic_ordering`]: https://rust-lang.github.io/rust-clippy/master/index.html#invalid_atomic_ordering
+[`invalid_null_ptr_usage`]: https://rust-lang.github.io/rust-clippy/master/index.html#invalid_null_ptr_usage
 [`invalid_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#invalid_ref
 [`invalid_regex`]: https://rust-lang.github.io/rust-clippy/master/index.html#invalid_regex
 [`invalid_upcast_comparisons`]: https://rust-lang.github.io/rust-clippy/master/index.html#invalid_upcast_comparisons
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index cd92b551abd..2fb8bbcd1f7 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -902,6 +902,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         pattern_type_mismatch::PATTERN_TYPE_MISMATCH,
         precedence::PRECEDENCE,
         ptr::CMP_NULL,
+        ptr::INVALID_NULL_PTR_USAGE,
         ptr::MUT_FROM_REF,
         ptr::PTR_ARG,
         ptr_eq::PTR_EQ,
@@ -1671,6 +1672,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(partialeq_ne_impl::PARTIALEQ_NE_IMPL),
         LintId::of(precedence::PRECEDENCE),
         LintId::of(ptr::CMP_NULL),
+        LintId::of(ptr::INVALID_NULL_PTR_USAGE),
         LintId::of(ptr::MUT_FROM_REF),
         LintId::of(ptr::PTR_ARG),
         LintId::of(ptr_eq::PTR_EQ),
@@ -2010,6 +2012,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(non_octal_unix_permissions::NON_OCTAL_UNIX_PERMISSIONS),
         LintId::of(open_options::NONSENSICAL_OPEN_OPTIONS),
         LintId::of(option_env_unwrap::OPTION_ENV_UNWRAP),
+        LintId::of(ptr::INVALID_NULL_PTR_USAGE),
         LintId::of(ptr::MUT_FROM_REF),
         LintId::of(ranges::REVERSED_EMPTY_RANGES),
         LintId::of(regex::INVALID_REGEX),
diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs
index 09fcdb5faf8..2ab1e958ec8 100644
--- a/clippy_lints/src/ptr.rs
+++ b/clippy_lints/src/ptr.rs
@@ -4,7 +4,7 @@ use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg, span_lint_and_the
 use clippy_utils::ptr::get_spans;
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::{is_type_diagnostic_item, match_type, walk_ptrs_hir_ty};
-use clippy_utils::{is_allowed, match_qpath, paths};
+use clippy_utils::{is_allowed, match_def_path, paths};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{
@@ -15,6 +15,7 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
+use rustc_span::symbol::Symbol;
 use rustc_span::{sym, MultiSpan};
 use std::borrow::Cow;
 
@@ -94,7 +95,7 @@ declare_clippy_lint! {
     /// ```
     pub CMP_NULL,
     style,
-    "comparing a pointer to a null pointer, suggesting to use `.is_null()` instead."
+    "comparing a pointer to a null pointer, suggesting to use `.is_null()` instead"
 }
 
 declare_clippy_lint! {
@@ -119,7 +120,28 @@ declare_clippy_lint! {
     "fns that create mutable refs from immutable ref args"
 }
 
-declare_lint_pass!(Ptr => [PTR_ARG, CMP_NULL, MUT_FROM_REF]);
+declare_clippy_lint! {
+    /// **What it does:** This lint checks for invalid usages of `ptr::null`.
+    ///
+    /// **Why is this bad?** This causes undefined behavior.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// ```ignore
+    /// // Bad. Undefined behavior
+    /// unsafe { std::slice::from_raw_parts(ptr::null(), 0); }
+    /// ```
+    ///
+    /// // Good
+    /// unsafe { std::slice::from_raw_parts(NonNull::dangling().as_ptr(), 0); }
+    /// ```
+    pub INVALID_NULL_PTR_USAGE,
+    correctness,
+    "invalid usage of a null pointer, suggesting `NonNull::dangling()` instead"
+}
+
+declare_lint_pass!(Ptr => [PTR_ARG, CMP_NULL, MUT_FROM_REF, INVALID_NULL_PTR_USAGE]);
 
 impl<'tcx> LateLintPass<'tcx> for Ptr {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
@@ -153,7 +175,7 @@ impl<'tcx> LateLintPass<'tcx> for Ptr {
 
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if let ExprKind::Binary(ref op, l, r) = expr.kind {
-            if (op.node == BinOpKind::Eq || op.node == BinOpKind::Ne) && (is_null_path(l) || is_null_path(r)) {
+            if (op.node == BinOpKind::Eq || op.node == BinOpKind::Ne) && (is_null_path(cx, l) || is_null_path(cx, r)) {
                 span_lint(
                     cx,
                     CMP_NULL,
@@ -161,6 +183,55 @@ impl<'tcx> LateLintPass<'tcx> for Ptr {
                     "comparing with null is better expressed by the `.is_null()` method",
                 );
             }
+        } else {
+            check_invalid_ptr_usage(cx, expr);
+        }
+    }
+}
+
+fn check_invalid_ptr_usage<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+    // (fn_path, arg_indices) - `arg_indices` are the `arg` positions where null would cause U.B.
+    const INVALID_NULL_PTR_USAGE_TABLE: [(&[&str], &[usize]); 16] = [
+        (&paths::SLICE_FROM_RAW_PARTS, &[0]),
+        (&paths::SLICE_FROM_RAW_PARTS_MUT, &[0]),
+        (&paths::PTR_COPY, &[0, 1]),
+        (&paths::PTR_COPY_NONOVERLAPPING, &[0, 1]),
+        (&paths::PTR_READ, &[0]),
+        (&paths::PTR_READ_UNALIGNED, &[0]),
+        (&paths::PTR_READ_VOLATILE, &[0]),
+        (&paths::PTR_REPLACE, &[0]),
+        (&paths::PTR_SLICE_FROM_RAW_PARTS, &[0]),
+        (&paths::PTR_SLICE_FROM_RAW_PARTS_MUT, &[0]),
+        (&paths::PTR_SWAP, &[0, 1]),
+        (&paths::PTR_SWAP_NONOVERLAPPING, &[0, 1]),
+        (&paths::PTR_WRITE, &[0]),
+        (&paths::PTR_WRITE_UNALIGNED, &[0]),
+        (&paths::PTR_WRITE_VOLATILE, &[0]),
+        (&paths::PTR_WRITE_BYTES, &[0]),
+    ];
+
+    if_chain! {
+        if let ExprKind::Call(ref fun, ref args) = expr.kind;
+        if let ExprKind::Path(ref qpath) = fun.kind;
+        if let Some(fun_def_id) = cx.qpath_res(qpath, fun.hir_id).opt_def_id();
+        let fun_def_path = cx.get_def_path(fun_def_id).into_iter().map(Symbol::to_ident_string).collect::<Vec<_>>();
+        if let Some(&(_, arg_indices)) = INVALID_NULL_PTR_USAGE_TABLE
+            .iter()
+            .find(|&&(fn_path, _)| fn_path == fun_def_path);
+        then {
+            for &arg_idx in arg_indices {
+                if let Some(arg) = args.get(arg_idx).filter(|arg| is_null_path(cx, arg)) {
+                    span_lint_and_sugg(
+                        cx,
+                        INVALID_NULL_PTR_USAGE,
+                        arg.span,
+                        "pointer must be non-null",
+                        "change this to",
+                        "core::ptr::NonNull::dangling().as_ptr()".to_string(),
+                        Applicability::MachineApplicable,
+                    );
+                }
+            }
         }
     }
 }
@@ -345,13 +416,15 @@ fn get_rptr_lm<'tcx>(ty: &'tcx Ty<'tcx>) -> Option<(&'tcx Lifetime, Mutability,
     }
 }
 
-fn is_null_path(expr: &Expr<'_>) -> bool {
-    if let ExprKind::Call(pathexp, args) = expr.kind {
-        if args.is_empty() {
-            if let ExprKind::Path(ref path) = pathexp.kind {
-                return match_qpath(path, &paths::PTR_NULL) || match_qpath(path, &paths::PTR_NULL_MUT);
-            }
+fn is_null_path(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+    if_chain! {
+        if let ExprKind::Call(path, []) = expr.kind;
+        if let ExprKind::Path(ref qpath) = path.kind;
+        if let Some(fn_def_id) = cx.qpath_res(qpath, path.hir_id).opt_def_id();
+        then {
+            match_def_path(cx, fn_def_id, &paths::PTR_NULL) || match_def_path(cx, fn_def_id, &paths::PTR_NULL_MUT)
+        } else {
+            false
         }
     }
-    false
 }
diff --git a/clippy_lints/src/size_of_in_element_count.rs b/clippy_lints/src/size_of_in_element_count.rs
index 09e00866815..cd2bdec1707 100644
--- a/clippy_lints/src/size_of_in_element_count.rs
+++ b/clippy_lints/src/size_of_in_element_count.rs
@@ -65,8 +65,8 @@ fn get_size_of_ty(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, inverted: bool)
 
 fn get_pointee_ty_and_count_expr(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<(Ty<'tcx>, &'tcx Expr<'tcx>)> {
     const FUNCTIONS: [&[&str]; 8] = [
-        &paths::COPY_NONOVERLAPPING,
-        &paths::COPY,
+        &paths::PTR_COPY_NONOVERLAPPING,
+        &paths::PTR_COPY,
         &paths::WRITE_BYTES,
         &paths::PTR_SWAP_NONOVERLAPPING,
         &paths::PTR_SLICE_FROM_RAW_PARTS,
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index 3b4c4070c0e..5da9c624ac4 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -18,8 +18,6 @@ pub const BTREESET: [&str; 5] = ["alloc", "collections", "btree", "set", "BTreeS
 pub const CLONE_TRAIT_METHOD: [&str; 4] = ["core", "clone", "Clone", "clone"];
 pub const CMP_MAX: [&str; 3] = ["core", "cmp", "max"];
 pub const CMP_MIN: [&str; 3] = ["core", "cmp", "min"];
-pub const COPY: [&str; 4] = ["core", "intrinsics", "", "copy_nonoverlapping"];
-pub const COPY_NONOVERLAPPING: [&str; 4] = ["core", "intrinsics", "", "copy"];
 pub const COW: [&str; 3] = ["alloc", "borrow", "Cow"];
 pub const CSTRING_AS_C_STR: [&str; 5] = ["std", "ffi", "c_str", "CString", "as_c_str"];
 pub const DEFAULT_TRAIT: [&str; 3] = ["core", "default", "Default"];
@@ -100,12 +98,23 @@ pub const PERMISSIONS_FROM_MODE: [&str; 7] = ["std", "sys", "unix", "ext", "fs",
 pub const POLL: [&str; 4] = ["core", "task", "poll", "Poll"];
 pub const POLL_PENDING: [&str; 5] = ["core", "task", "poll", "Poll", "Pending"];
 pub const POLL_READY: [&str; 5] = ["core", "task", "poll", "Poll", "Ready"];
+pub const PTR_COPY: [&str; 4] = ["core", "intrinsics", "", "copy"];
+pub const PTR_COPY_NONOVERLAPPING: [&str; 4] = ["core", "intrinsics", "", "copy_nonoverlapping"];
 pub const PTR_EQ: [&str; 3] = ["core", "ptr", "eq"];
 pub const PTR_NULL: [&str; 3] = ["core", "ptr", "null"];
 pub const PTR_NULL_MUT: [&str; 3] = ["core", "ptr", "null_mut"];
 pub const PTR_SLICE_FROM_RAW_PARTS: [&str; 3] = ["core", "ptr", "slice_from_raw_parts"];
 pub const PTR_SLICE_FROM_RAW_PARTS_MUT: [&str; 3] = ["core", "ptr", "slice_from_raw_parts_mut"];
 pub const PTR_SWAP_NONOVERLAPPING: [&str; 3] = ["core", "ptr", "swap_nonoverlapping"];
+pub const PTR_READ: [&str; 3] = ["core", "ptr", "read"];
+pub const PTR_READ_UNALIGNED: [&str; 3] = ["core", "ptr", "read_unaligned"];
+pub const PTR_READ_VOLATILE: [&str; 3] = ["core", "ptr", "read_volatile"];
+pub const PTR_REPLACE: [&str; 3] = ["core", "ptr", "replace"];
+pub const PTR_SWAP: [&str; 3] = ["core", "ptr", "swap"];
+pub const PTR_WRITE: [&str; 3] = ["core", "ptr", "write"];
+pub const PTR_WRITE_BYTES: [&str; 3] = ["core", "intrinsics", "write_bytes"];
+pub const PTR_WRITE_UNALIGNED: [&str; 3] = ["core", "ptr", "write_unaligned"];
+pub const PTR_WRITE_VOLATILE: [&str; 3] = ["core", "ptr", "write_volatile"];
 pub const PUSH_STR: [&str; 4] = ["alloc", "string", "String", "push_str"];
 pub const RANGE_ARGUMENT_TRAIT: [&str; 3] = ["core", "ops", "RangeBounds"];
 pub const RC_PTR_EQ: [&str; 4] = ["alloc", "rc", "Rc", "ptr_eq"];
diff --git a/tests/ui/invalid_null_ptr_usage.fixed b/tests/ui/invalid_null_ptr_usage.fixed
new file mode 100644
index 00000000000..4f5322ebf20
--- /dev/null
+++ b/tests/ui/invalid_null_ptr_usage.fixed
@@ -0,0 +1,49 @@
+// run-rustfix
+
+fn main() {
+    unsafe {
+        let _slice: &[usize] = std::slice::from_raw_parts(core::ptr::NonNull::dangling().as_ptr(), 0);
+        let _slice: &[usize] = std::slice::from_raw_parts(core::ptr::NonNull::dangling().as_ptr(), 0);
+
+        let _slice: &[usize] = std::slice::from_raw_parts_mut(core::ptr::NonNull::dangling().as_ptr(), 0);
+
+        std::ptr::copy::<usize>(core::ptr::NonNull::dangling().as_ptr(), std::ptr::NonNull::dangling().as_ptr(), 0);
+        std::ptr::copy::<usize>(std::ptr::NonNull::dangling().as_ptr(), core::ptr::NonNull::dangling().as_ptr(), 0);
+
+        std::ptr::copy_nonoverlapping::<usize>(core::ptr::NonNull::dangling().as_ptr(), std::ptr::NonNull::dangling().as_ptr(), 0);
+        std::ptr::copy_nonoverlapping::<usize>(std::ptr::NonNull::dangling().as_ptr(), core::ptr::NonNull::dangling().as_ptr(), 0);
+
+        struct A; // zero sized struct
+        assert_eq!(std::mem::size_of::<A>(), 0);
+
+        let _a: A = std::ptr::read(core::ptr::NonNull::dangling().as_ptr());
+        let _a: A = std::ptr::read(core::ptr::NonNull::dangling().as_ptr());
+
+        let _a: A = std::ptr::read_unaligned(core::ptr::NonNull::dangling().as_ptr());
+        let _a: A = std::ptr::read_unaligned(core::ptr::NonNull::dangling().as_ptr());
+
+        let _a: A = std::ptr::read_volatile(core::ptr::NonNull::dangling().as_ptr());
+        let _a: A = std::ptr::read_volatile(core::ptr::NonNull::dangling().as_ptr());
+
+        let _a: A = std::ptr::replace(core::ptr::NonNull::dangling().as_ptr(), A);
+
+        let _slice: *const [usize] = std::ptr::slice_from_raw_parts(core::ptr::NonNull::dangling().as_ptr(), 0);
+        let _slice: *const [usize] = std::ptr::slice_from_raw_parts(core::ptr::NonNull::dangling().as_ptr(), 0);
+
+        let _slice: *const [usize] = std::ptr::slice_from_raw_parts_mut(core::ptr::NonNull::dangling().as_ptr(), 0);
+
+        std::ptr::swap::<A>(core::ptr::NonNull::dangling().as_ptr(), &mut A);
+        std::ptr::swap::<A>(&mut A, core::ptr::NonNull::dangling().as_ptr());
+
+        std::ptr::swap_nonoverlapping::<A>(core::ptr::NonNull::dangling().as_ptr(), &mut A, 0);
+        std::ptr::swap_nonoverlapping::<A>(&mut A, core::ptr::NonNull::dangling().as_ptr(), 0);
+
+        std::ptr::write(core::ptr::NonNull::dangling().as_ptr(), A);
+
+        std::ptr::write_unaligned(core::ptr::NonNull::dangling().as_ptr(), A);
+
+        std::ptr::write_volatile(core::ptr::NonNull::dangling().as_ptr(), A);
+
+        std::ptr::write_bytes::<usize>(core::ptr::NonNull::dangling().as_ptr(), 42, 0);
+    }
+}
diff --git a/tests/ui/invalid_null_ptr_usage.rs b/tests/ui/invalid_null_ptr_usage.rs
new file mode 100644
index 00000000000..ae51c52d8af
--- /dev/null
+++ b/tests/ui/invalid_null_ptr_usage.rs
@@ -0,0 +1,49 @@
+// run-rustfix
+
+fn main() {
+    unsafe {
+        let _slice: &[usize] = std::slice::from_raw_parts(std::ptr::null(), 0);
+        let _slice: &[usize] = std::slice::from_raw_parts(std::ptr::null_mut(), 0);
+
+        let _slice: &[usize] = std::slice::from_raw_parts_mut(std::ptr::null_mut(), 0);
+
+        std::ptr::copy::<usize>(std::ptr::null(), std::ptr::NonNull::dangling().as_ptr(), 0);
+        std::ptr::copy::<usize>(std::ptr::NonNull::dangling().as_ptr(), std::ptr::null_mut(), 0);
+
+        std::ptr::copy_nonoverlapping::<usize>(std::ptr::null(), std::ptr::NonNull::dangling().as_ptr(), 0);
+        std::ptr::copy_nonoverlapping::<usize>(std::ptr::NonNull::dangling().as_ptr(), std::ptr::null_mut(), 0);
+
+        struct A; // zero sized struct
+        assert_eq!(std::mem::size_of::<A>(), 0);
+
+        let _a: A = std::ptr::read(std::ptr::null());
+        let _a: A = std::ptr::read(std::ptr::null_mut());
+
+        let _a: A = std::ptr::read_unaligned(std::ptr::null());
+        let _a: A = std::ptr::read_unaligned(std::ptr::null_mut());
+
+        let _a: A = std::ptr::read_volatile(std::ptr::null());
+        let _a: A = std::ptr::read_volatile(std::ptr::null_mut());
+
+        let _a: A = std::ptr::replace(std::ptr::null_mut(), A);
+
+        let _slice: *const [usize] = std::ptr::slice_from_raw_parts(std::ptr::null(), 0);
+        let _slice: *const [usize] = std::ptr::slice_from_raw_parts(std::ptr::null_mut(), 0);
+
+        let _slice: *const [usize] = std::ptr::slice_from_raw_parts_mut(std::ptr::null_mut(), 0);
+
+        std::ptr::swap::<A>(std::ptr::null_mut(), &mut A);
+        std::ptr::swap::<A>(&mut A, std::ptr::null_mut());
+
+        std::ptr::swap_nonoverlapping::<A>(std::ptr::null_mut(), &mut A, 0);
+        std::ptr::swap_nonoverlapping::<A>(&mut A, std::ptr::null_mut(), 0);
+
+        std::ptr::write(std::ptr::null_mut(), A);
+
+        std::ptr::write_unaligned(std::ptr::null_mut(), A);
+
+        std::ptr::write_volatile(std::ptr::null_mut(), A);
+
+        std::ptr::write_bytes::<usize>(std::ptr::null_mut(), 42, 0);
+    }
+}
diff --git a/tests/ui/invalid_null_ptr_usage.stderr b/tests/ui/invalid_null_ptr_usage.stderr
new file mode 100644
index 00000000000..532c36abe51
--- /dev/null
+++ b/tests/ui/invalid_null_ptr_usage.stderr
@@ -0,0 +1,154 @@
+error: pointer must be non-null
+  --> $DIR/invalid_null_ptr_usage.rs:5:59
+   |
+LL |         let _slice: &[usize] = std::slice::from_raw_parts(std::ptr::null(), 0);
+   |                                                           ^^^^^^^^^^^^^^^^ help: change this to: `core::ptr::NonNull::dangling().as_ptr()`
+   |
+   = note: `#[deny(clippy::invalid_null_ptr_usage)]` on by default
+
+error: pointer must be non-null
+  --> $DIR/invalid_null_ptr_usage.rs:6:59
+   |
+LL |         let _slice: &[usize] = std::slice::from_raw_parts(std::ptr::null_mut(), 0);
+   |                                                           ^^^^^^^^^^^^^^^^^^^^ help: change this to: `core::ptr::NonNull::dangling().as_ptr()`
+
+error: pointer must be non-null
+  --> $DIR/invalid_null_ptr_usage.rs:8:63
+   |
+LL |         let _slice: &[usize] = std::slice::from_raw_parts_mut(std::ptr::null_mut(), 0);
+   |                                                               ^^^^^^^^^^^^^^^^^^^^ help: change this to: `core::ptr::NonNull::dangling().as_ptr()`
+
+error: pointer must be non-null
+  --> $DIR/invalid_null_ptr_usage.rs:10:33
+   |
+LL |         std::ptr::copy::<usize>(std::ptr::null(), std::ptr::NonNull::dangling().as_ptr(), 0);
+   |                                 ^^^^^^^^^^^^^^^^ help: change this to: `core::ptr::NonNull::dangling().as_ptr()`
+
+error: pointer must be non-null
+  --> $DIR/invalid_null_ptr_usage.rs:11:73
+   |
+LL |         std::ptr::copy::<usize>(std::ptr::NonNull::dangling().as_ptr(), std::ptr::null_mut(), 0);
+   |                                                                         ^^^^^^^^^^^^^^^^^^^^ help: change this to: `core::ptr::NonNull::dangling().as_ptr()`
+
+error: pointer must be non-null
+  --> $DIR/invalid_null_ptr_usage.rs:13:48
+   |
+LL |         std::ptr::copy_nonoverlapping::<usize>(std::ptr::null(), std::ptr::NonNull::dangling().as_ptr(), 0);
+   |                                                ^^^^^^^^^^^^^^^^ help: change this to: `core::ptr::NonNull::dangling().as_ptr()`
+
+error: pointer must be non-null
+  --> $DIR/invalid_null_ptr_usage.rs:14:88
+   |
+LL |         std::ptr::copy_nonoverlapping::<usize>(std::ptr::NonNull::dangling().as_ptr(), std::ptr::null_mut(), 0);
+   |                                                                                        ^^^^^^^^^^^^^^^^^^^^ help: change this to: `core::ptr::NonNull::dangling().as_ptr()`
+
+error: pointer must be non-null
+  --> $DIR/invalid_null_ptr_usage.rs:19:36
+   |
+LL |         let _a: A = std::ptr::read(std::ptr::null());
+   |                                    ^^^^^^^^^^^^^^^^ help: change this to: `core::ptr::NonNull::dangling().as_ptr()`
+
+error: pointer must be non-null
+  --> $DIR/invalid_null_ptr_usage.rs:20:36
+   |
+LL |         let _a: A = std::ptr::read(std::ptr::null_mut());
+   |                                    ^^^^^^^^^^^^^^^^^^^^ help: change this to: `core::ptr::NonNull::dangling().as_ptr()`
+
+error: pointer must be non-null
+  --> $DIR/invalid_null_ptr_usage.rs:22:46
+   |
+LL |         let _a: A = std::ptr::read_unaligned(std::ptr::null());
+   |                                              ^^^^^^^^^^^^^^^^ help: change this to: `core::ptr::NonNull::dangling().as_ptr()`
+
+error: pointer must be non-null
+  --> $DIR/invalid_null_ptr_usage.rs:23:46
+   |
+LL |         let _a: A = std::ptr::read_unaligned(std::ptr::null_mut());
+   |                                              ^^^^^^^^^^^^^^^^^^^^ help: change this to: `core::ptr::NonNull::dangling().as_ptr()`
+
+error: pointer must be non-null
+  --> $DIR/invalid_null_ptr_usage.rs:25:45
+   |
+LL |         let _a: A = std::ptr::read_volatile(std::ptr::null());
+   |                                             ^^^^^^^^^^^^^^^^ help: change this to: `core::ptr::NonNull::dangling().as_ptr()`
+
+error: pointer must be non-null
+  --> $DIR/invalid_null_ptr_usage.rs:26:45
+   |
+LL |         let _a: A = std::ptr::read_volatile(std::ptr::null_mut());
+   |                                             ^^^^^^^^^^^^^^^^^^^^ help: change this to: `core::ptr::NonNull::dangling().as_ptr()`
+
+error: pointer must be non-null
+  --> $DIR/invalid_null_ptr_usage.rs:28:39
+   |
+LL |         let _a: A = std::ptr::replace(std::ptr::null_mut(), A);
+   |                                       ^^^^^^^^^^^^^^^^^^^^ help: change this to: `core::ptr::NonNull::dangling().as_ptr()`
+
+error: pointer must be non-null
+  --> $DIR/invalid_null_ptr_usage.rs:30:69
+   |
+LL |         let _slice: *const [usize] = std::ptr::slice_from_raw_parts(std::ptr::null(), 0);
+   |                                                                     ^^^^^^^^^^^^^^^^ help: change this to: `core::ptr::NonNull::dangling().as_ptr()`
+
+error: pointer must be non-null
+  --> $DIR/invalid_null_ptr_usage.rs:31:69
+   |
+LL |         let _slice: *const [usize] = std::ptr::slice_from_raw_parts(std::ptr::null_mut(), 0);
+   |                                                                     ^^^^^^^^^^^^^^^^^^^^ help: change this to: `core::ptr::NonNull::dangling().as_ptr()`
+
+error: pointer must be non-null
+  --> $DIR/invalid_null_ptr_usage.rs:33:73
+   |
+LL |         let _slice: *const [usize] = std::ptr::slice_from_raw_parts_mut(std::ptr::null_mut(), 0);
+   |                                                                         ^^^^^^^^^^^^^^^^^^^^ help: change this to: `core::ptr::NonNull::dangling().as_ptr()`
+
+error: pointer must be non-null
+  --> $DIR/invalid_null_ptr_usage.rs:35:29
+   |
+LL |         std::ptr::swap::<A>(std::ptr::null_mut(), &mut A);
+   |                             ^^^^^^^^^^^^^^^^^^^^ help: change this to: `core::ptr::NonNull::dangling().as_ptr()`
+
+error: pointer must be non-null
+  --> $DIR/invalid_null_ptr_usage.rs:36:37
+   |
+LL |         std::ptr::swap::<A>(&mut A, std::ptr::null_mut());
+   |                                     ^^^^^^^^^^^^^^^^^^^^ help: change this to: `core::ptr::NonNull::dangling().as_ptr()`
+
+error: pointer must be non-null
+  --> $DIR/invalid_null_ptr_usage.rs:38:44
+   |
+LL |         std::ptr::swap_nonoverlapping::<A>(std::ptr::null_mut(), &mut A, 0);
+   |                                            ^^^^^^^^^^^^^^^^^^^^ help: change this to: `core::ptr::NonNull::dangling().as_ptr()`
+
+error: pointer must be non-null
+  --> $DIR/invalid_null_ptr_usage.rs:39:52
+   |
+LL |         std::ptr::swap_nonoverlapping::<A>(&mut A, std::ptr::null_mut(), 0);
+   |                                                    ^^^^^^^^^^^^^^^^^^^^ help: change this to: `core::ptr::NonNull::dangling().as_ptr()`
+
+error: pointer must be non-null
+  --> $DIR/invalid_null_ptr_usage.rs:41:25
+   |
+LL |         std::ptr::write(std::ptr::null_mut(), A);
+   |                         ^^^^^^^^^^^^^^^^^^^^ help: change this to: `core::ptr::NonNull::dangling().as_ptr()`
+
+error: pointer must be non-null
+  --> $DIR/invalid_null_ptr_usage.rs:43:35
+   |
+LL |         std::ptr::write_unaligned(std::ptr::null_mut(), A);
+   |                                   ^^^^^^^^^^^^^^^^^^^^ help: change this to: `core::ptr::NonNull::dangling().as_ptr()`
+
+error: pointer must be non-null
+  --> $DIR/invalid_null_ptr_usage.rs:45:34
+   |
+LL |         std::ptr::write_volatile(std::ptr::null_mut(), A);
+   |                                  ^^^^^^^^^^^^^^^^^^^^ help: change this to: `core::ptr::NonNull::dangling().as_ptr()`
+
+error: pointer must be non-null
+  --> $DIR/invalid_null_ptr_usage.rs:47:40
+   |
+LL |         std::ptr::write_bytes::<usize>(std::ptr::null_mut(), 42, 0);
+   |                                        ^^^^^^^^^^^^^^^^^^^^ help: change this to: `core::ptr::NonNull::dangling().as_ptr()`
+
+error: aborting due to 25 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 012f9d47b24dc5e92be2d83bf798ca332847e68a Mon Sep 17 00:00:00 2001
From: Joshua Nelson <jyn514@gmail.com>
Date: Fri, 9 Apr 2021 10:09:06 -0400
Subject: Use `register_renamed` instead of `register_removed` for uplifted
 lints

This still applies the lint, and also adds a structured suggestion to
rename it.
---
 CHANGELOG.md                         | 29 +++++++----------
 clippy_lints/src/deprecated_lints.rs | 63 ------------------------------------
 clippy_lints/src/lib.rs              | 37 ++++++---------------
 tests/ui/deprecated.stderr           | 28 ++++++++--------
 4 files changed, 34 insertions(+), 123 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 715f4702e95..7885bdfb12c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -179,7 +179,7 @@ Current stable, released 2021-03-25
 
 * Replace [`find_map`] with [`manual_find_map`]
   [#6591](https://github.com/rust-lang/rust-clippy/pull/6591)
-* [`unknown_clippy_lints`] Now integrated in the `unknown_lints` rustc lint
+* `unknown_clippy_lints` Now integrated in the `unknown_lints` rustc lint
   [#6653](https://github.com/rust-lang/rust-clippy/pull/6653)
 
 ### Enhancements
@@ -280,7 +280,7 @@ Released 2021-02-11
 
 * Previously deprecated [`str_to_string`] and [`string_to_string`] have been un-deprecated
   as `restriction` lints [#6333](https://github.com/rust-lang/rust-clippy/pull/6333)
-* Deprecate [`panic_params`] lint. This is now available in rustc as `panic_fmt`
+* Deprecate `panic_params` lint. This is now available in rustc as `non_fmt_panic`
   [#6351](https://github.com/rust-lang/rust-clippy/pull/6351)
 * Move [`map_err_ignore`] to `restriction`
   [#6416](https://github.com/rust-lang/rust-clippy/pull/6416)
@@ -419,7 +419,7 @@ Released 2020-12-31
   [#6037](https://github.com/rust-lang/rust-clippy/pull/6037)
 * Rename `zero_width_space` to [`invisible_characters`]
   [#6105](https://github.com/rust-lang/rust-clippy/pull/6105)
-* Deprecate [`drop_bounds`] (uplifted)
+* Deprecate `drop_bounds` (uplifted)
   [#6111](https://github.com/rust-lang/rust-clippy/pull/6111)
 * Move [`string_lit_as_bytes`] to `nursery`
   [#6117](https://github.com/rust-lang/rust-clippy/pull/6117)
@@ -1018,7 +1018,7 @@ Released 2020-03-12
   [#5015](https://github.com/rust-lang/rust-clippy/pull/5015)
 * Move [`range_plus_one`] to pedantic group [#5057](https://github.com/rust-lang/rust-clippy/pull/5057)
 * Move [`debug_assert_with_mut_call`] to nursery group [#5106](https://github.com/rust-lang/rust-clippy/pull/5106)
-* Deprecate [`unused_label`] [#4930](https://github.com/rust-lang/rust-clippy/pull/4930)
+* Deprecate `unused_label` [#4930](https://github.com/rust-lang/rust-clippy/pull/4930)
 
 ### Enhancements
 
@@ -1046,7 +1046,7 @@ Released 2020-03-12
 * [`wildcard_enum_match_arm`] [#4934](https://github.com/rust-lang/rust-clippy/pull/4934)
 * [`cognitive_complexity`] [#4935](https://github.com/rust-lang/rust-clippy/pull/4935)
 * [`decimal_literal_representation`] [#4956](https://github.com/rust-lang/rust-clippy/pull/4956)
-* [`unknown_clippy_lints`] [#4963](https://github.com/rust-lang/rust-clippy/pull/4963)
+* `unknown_clippy_lints` [#4963](https://github.com/rust-lang/rust-clippy/pull/4963)
 * [`explicit_into_iter_loop`] [#4978](https://github.com/rust-lang/rust-clippy/pull/4978)
 * [`useless_attribute`] [#5022](https://github.com/rust-lang/rust-clippy/pull/5022)
 * [`if_let_some_result`] [#5032](https://github.com/rust-lang/rust-clippy/pull/5032)
@@ -1080,7 +1080,7 @@ Released 2020-01-30
   [Inside Rust Blog](https://blog.rust-lang.org/inside-rust/2019/11/04/Clippy-removes-plugin-interface.html) for
   details [#4714](https://github.com/rust-lang/rust-clippy/pull/4714)
 * Move [`use_self`] to nursery group [#4863](https://github.com/rust-lang/rust-clippy/pull/4863)
-* Deprecate [`into_iter_on_array`] [#4788](https://github.com/rust-lang/rust-clippy/pull/4788)
+* Deprecate `into_iter_on_array` [#4788](https://github.com/rust-lang/rust-clippy/pull/4788)
 * Expand [`string_lit_as_bytes`] to also trigger when literal has escapes
   [#4808](https://github.com/rust-lang/rust-clippy/pull/4808)
 * Fix false positive in `comparison_chain` [#4842](https://github.com/rust-lang/rust-clippy/pull/4842)
@@ -1282,7 +1282,7 @@ Released 2019-05-20
 
 [1fac380..37f5c1e](https://github.com/rust-lang/rust-clippy/compare/1fac380...37f5c1e)
 
-* New lint: [`drop_bounds`] to detect `T: Drop` bounds
+* New lint: `drop_bounds` to detect `T: Drop` bounds
 * Split [`redundant_closure`] into [`redundant_closure`] and [`redundant_closure_for_method_calls`] [#4110](https://github.com/rust-lang/rust-clippy/pull/4101)
 * Rename `cyclomatic_complexity` to [`cognitive_complexity`], start work on making lint more practical for Rust code
 * Move [`get_unwrap`] to the restriction category
@@ -1375,7 +1375,7 @@ Released 2019-01-17
 
 * New lints: [`slow_vector_initialization`], [`mem_discriminant_non_enum`],
   [`redundant_clone`], [`wildcard_dependencies`],
-  [`into_iter_on_ref`], [`into_iter_on_array`], [`deprecated_cfg_attr`],
+  [`into_iter_on_ref`], `into_iter_on_array`, [`deprecated_cfg_attr`],
   [`mem_discriminant_non_enum`], [`cargo_common_metadata`]
 * Add support for `u128` and `i128` to integer related lints
 * Add float support to `mistyped_literal_suffixes`
@@ -1649,7 +1649,7 @@ Released 2018-09-13
 
 ## 0.0.166
 * Rustup to *rustc 1.22.0-nightly (b7960878b 2017-10-18)*
-* New lints: [`explicit_write`], `identity_conversion`, [`implicit_hasher`], [`invalid_ref`], [`option_map_or_none`],
+* New lints: [`explicit_write`], `identity_conversion`, [`implicit_hasher`], `invalid_ref`, [`option_map_or_none`],
   [`range_minus_one`], [`range_plus_one`], [`transmute_int_to_bool`], [`transmute_int_to_char`],
   [`transmute_int_to_float`]
 
@@ -2037,7 +2037,7 @@ Released 2018-09-13
 
 ## 0.0.64 — 2016-04-26
 * Rustup to *rustc 1.10.0-nightly (645dd013a 2016-04-24)*
-* New lints: [`temporary_cstring_as_ptr`], [`unsafe_removed_from_name`], and [`mem_forget`]
+* New lints: `temporary_cstring_as_ptr`, [`unsafe_removed_from_name`], and [`mem_forget`]
 
 ## 0.0.63 — 2016-04-08
 * Rustup to *rustc 1.9.0-nightly (7979dd608 2016-04-07)*
@@ -2091,7 +2091,7 @@ Released 2018-09-13
 
 ## 0.0.49 — 2016-03-09
 * Update to *rustc 1.9.0-nightly (eabfc160f 2016-03-08)*
-* New lints: [`overflow_check_conditional`], [`unused_label`], [`new_without_default`]
+* New lints: [`overflow_check_conditional`], `unused_label`, [`new_without_default`]
 
 ## 0.0.48 — 2016-03-07
 * Fixed: ICE in [`needless_range_loop`] with globals
@@ -2178,7 +2178,6 @@ Released 2018-09-13
 [`double_must_use`]: https://rust-lang.github.io/rust-clippy/master/index.html#double_must_use
 [`double_neg`]: https://rust-lang.github.io/rust-clippy/master/index.html#double_neg
 [`double_parens`]: https://rust-lang.github.io/rust-clippy/master/index.html#double_parens
-[`drop_bounds`]: https://rust-lang.github.io/rust-clippy/master/index.html#drop_bounds
 [`drop_copy`]: https://rust-lang.github.io/rust-clippy/master/index.html#drop_copy
 [`drop_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#drop_ref
 [`duplicate_underscore_argument`]: https://rust-lang.github.io/rust-clippy/master/index.html#duplicate_underscore_argument
@@ -2264,11 +2263,9 @@ Released 2018-09-13
 [`int_plus_one`]: https://rust-lang.github.io/rust-clippy/master/index.html#int_plus_one
 [`integer_arithmetic`]: https://rust-lang.github.io/rust-clippy/master/index.html#integer_arithmetic
 [`integer_division`]: https://rust-lang.github.io/rust-clippy/master/index.html#integer_division
-[`into_iter_on_array`]: https://rust-lang.github.io/rust-clippy/master/index.html#into_iter_on_array
 [`into_iter_on_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#into_iter_on_ref
 [`invalid_atomic_ordering`]: https://rust-lang.github.io/rust-clippy/master/index.html#invalid_atomic_ordering
 [`invalid_null_ptr_usage`]: https://rust-lang.github.io/rust-clippy/master/index.html#invalid_null_ptr_usage
-[`invalid_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#invalid_ref
 [`invalid_regex`]: https://rust-lang.github.io/rust-clippy/master/index.html#invalid_regex
 [`invalid_upcast_comparisons`]: https://rust-lang.github.io/rust-clippy/master/index.html#invalid_upcast_comparisons
 [`invisible_characters`]: https://rust-lang.github.io/rust-clippy/master/index.html#invisible_characters
@@ -2403,7 +2400,6 @@ Released 2018-09-13
 [`overflow_check_conditional`]: https://rust-lang.github.io/rust-clippy/master/index.html#overflow_check_conditional
 [`panic`]: https://rust-lang.github.io/rust-clippy/master/index.html#panic
 [`panic_in_result_fn`]: https://rust-lang.github.io/rust-clippy/master/index.html#panic_in_result_fn
-[`panic_params`]: https://rust-lang.github.io/rust-clippy/master/index.html#panic_params
 [`panicking_unwrap`]: https://rust-lang.github.io/rust-clippy/master/index.html#panicking_unwrap
 [`partialeq_ne_impl`]: https://rust-lang.github.io/rust-clippy/master/index.html#partialeq_ne_impl
 [`path_buf_push_overwrite`]: https://rust-lang.github.io/rust-clippy/master/index.html#path_buf_push_overwrite
@@ -2489,7 +2485,6 @@ Released 2018-09-13
 [`suspicious_unary_op_formatting`]: https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_unary_op_formatting
 [`tabs_in_doc_comments`]: https://rust-lang.github.io/rust-clippy/master/index.html#tabs_in_doc_comments
 [`temporary_assignment`]: https://rust-lang.github.io/rust-clippy/master/index.html#temporary_assignment
-[`temporary_cstring_as_ptr`]: https://rust-lang.github.io/rust-clippy/master/index.html#temporary_cstring_as_ptr
 [`to_digit_is_some`]: https://rust-lang.github.io/rust-clippy/master/index.html#to_digit_is_some
 [`to_string_in_display`]: https://rust-lang.github.io/rust-clippy/master/index.html#to_string_in_display
 [`todo`]: https://rust-lang.github.io/rust-clippy/master/index.html#todo
@@ -2518,7 +2513,6 @@ Released 2018-09-13
 [`unit_arg`]: https://rust-lang.github.io/rust-clippy/master/index.html#unit_arg
 [`unit_cmp`]: https://rust-lang.github.io/rust-clippy/master/index.html#unit_cmp
 [`unit_return_expecting_ord`]: https://rust-lang.github.io/rust-clippy/master/index.html#unit_return_expecting_ord
-[`unknown_clippy_lints`]: https://rust-lang.github.io/rust-clippy/master/index.html#unknown_clippy_lints
 [`unnecessary_cast`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_cast
 [`unnecessary_filter_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_filter_map
 [`unnecessary_fold`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_fold
@@ -2542,7 +2536,6 @@ Released 2018-09-13
 [`unstable_as_slice`]: https://rust-lang.github.io/rust-clippy/master/index.html#unstable_as_slice
 [`unused_collect`]: https://rust-lang.github.io/rust-clippy/master/index.html#unused_collect
 [`unused_io_amount`]: https://rust-lang.github.io/rust-clippy/master/index.html#unused_io_amount
-[`unused_label`]: https://rust-lang.github.io/rust-clippy/master/index.html#unused_label
 [`unused_self`]: https://rust-lang.github.io/rust-clippy/master/index.html#unused_self
 [`unused_unit`]: https://rust-lang.github.io/rust-clippy/master/index.html#unused_unit
 [`unusual_byte_groupings`]: https://rust-lang.github.io/rust-clippy/master/index.html#unusual_byte_groupings
diff --git a/clippy_lints/src/deprecated_lints.rs b/clippy_lints/src/deprecated_lints.rs
index 89088c533ed..66e9f8c8af7 100644
--- a/clippy_lints/src/deprecated_lints.rs
+++ b/clippy_lints/src/deprecated_lints.rs
@@ -93,15 +93,6 @@ declare_deprecated_lint! {
     "the replacement suggested by this lint had substantially different behavior"
 }
 
-declare_deprecated_lint! {
-    /// **What it does:** Nothing. This lint has been deprecated.
-    ///
-    /// **Deprecation reason:** This lint has been superseded by the warn-by-default
-    /// `invalid_value` rustc lint.
-    pub INVALID_REF,
-    "superseded by rustc lint `invalid_value`"
-}
-
 declare_deprecated_lint! {
     /// **What it does:** Nothing. This lint has been deprecated.
     ///
@@ -110,24 +101,6 @@ declare_deprecated_lint! {
     "`collect` has been marked as #[must_use] in rustc and that covers all cases of this lint"
 }
 
-declare_deprecated_lint! {
-    /// **What it does:** Nothing. This lint has been deprecated.
-    ///
-    /// **Deprecation reason:** This lint has been uplifted to rustc and is now called
-    /// `array_into_iter`.
-    pub INTO_ITER_ON_ARRAY,
-    "this lint has been uplifted to rustc and is now called `array_into_iter`"
-}
-
-declare_deprecated_lint! {
-    /// **What it does:** Nothing. This lint has been deprecated.
-    ///
-    /// **Deprecation reason:** This lint has been uplifted to rustc and is now called
-    /// `unused_labels`.
-    pub UNUSED_LABEL,
-    "this lint has been uplifted to rustc and is now called `unused_labels`"
-}
-
 declare_deprecated_lint! {
     /// **What it does:** Nothing. This lint has been deprecated.
     ///
@@ -144,42 +117,6 @@ declare_deprecated_lint! {
     "the regex! macro has been removed from the regex crate in 2018"
 }
 
-declare_deprecated_lint! {
-    /// **What it does:** Nothing. This lint has been deprecated.
-    ///
-    /// **Deprecation reason:** This lint has been uplifted to rustc and is now called
-    /// `drop_bounds`.
-    pub DROP_BOUNDS,
-    "this lint has been uplifted to rustc and is now called `drop_bounds`"
-}
-
-declare_deprecated_lint! {
-    /// **What it does:** Nothing. This lint has been deprecated.
-    ///
-    /// **Deprecation reason:** This lint has been uplifted to rustc and is now called
-    /// `temporary_cstring_as_ptr`.
-    pub TEMPORARY_CSTRING_AS_PTR,
-    "this lint has been uplifted to rustc and is now called `temporary_cstring_as_ptr`"
-}
-
-declare_deprecated_lint! {
-    /// **What it does:** Nothing. This lint has been deprecated.
-    ///
-    /// **Deprecation reason:** This lint has been uplifted to rustc and is now called
-    /// `panic_fmt`.
-    pub PANIC_PARAMS,
-    "this lint has been uplifted to rustc and is now called `panic_fmt`"
-}
-
-declare_deprecated_lint! {
-    /// **What it does:** Nothing. This lint has been deprecated.
-    ///
-    /// **Deprecation reason:** This lint has been integrated into the `unknown_lints`
-    /// rustc lint.
-    pub UNKNOWN_CLIPPY_LINTS,
-    "this lint has been integrated into the `unknown_lints` rustc lint"
-}
-
 declare_deprecated_lint! {
     /// **What it does:** Nothing. This lint has been deprecated.
     ///
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index b066643b568..e97f363a793 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -493,22 +493,10 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         "clippy::unsafe_vector_initialization",
         "the replacement suggested by this lint had substantially different behavior",
     );
-    store.register_removed(
-        "clippy::invalid_ref",
-        "superseded by rustc lint `invalid_value`",
-    );
     store.register_removed(
         "clippy::unused_collect",
         "`collect` has been marked as #[must_use] in rustc and that covers all cases of this lint",
     );
-    store.register_removed(
-        "clippy::into_iter_on_array",
-        "this lint has been uplifted to rustc and is now called `array_into_iter`",
-    );
-    store.register_removed(
-        "clippy::unused_label",
-        "this lint has been uplifted to rustc and is now called `unused_labels`",
-    );
     store.register_removed(
         "clippy::replace_consts",
         "associated-constants `MIN`/`MAX` of integers are preferred to `{min,max}_value()` and module constants",
@@ -517,22 +505,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         "clippy::regex_macro",
         "the regex! macro has been removed from the regex crate in 2018",
     );
-    store.register_removed(
-        "clippy::drop_bounds",
-        "this lint has been uplifted to rustc and is now called `drop_bounds`",
-    );
-    store.register_removed(
-        "clippy::temporary_cstring_as_ptr",
-        "this lint has been uplifted to rustc and is now called `temporary_cstring_as_ptr`",
-    );
-    store.register_removed(
-        "clippy::panic_params",
-        "this lint has been uplifted to rustc and is now called `panic_fmt`",
-    );
-    store.register_removed(
-        "clippy::unknown_clippy_lints",
-        "this lint has been integrated into the `unknown_lints` rustc lint",
-    );
     store.register_removed(
         "clippy::find_map",
         "this lint has been replaced by `manual_find_map`, a more specific lint",
@@ -2155,6 +2127,15 @@ pub fn register_renamed(ls: &mut rustc_lint::LintStore) {
     ls.register_renamed("clippy::identity_conversion", "clippy::useless_conversion");
     ls.register_renamed("clippy::zero_width_space", "clippy::invisible_characters");
     ls.register_renamed("clippy::single_char_push_str", "clippy::single_char_add_str");
+
+    // uplifted lints
+    ls.register_renamed("clippy::invalid_ref", "invalid_value");
+    ls.register_renamed("clippy::into_iter_on_array", "array_into_iter");
+    ls.register_renamed("clippy::unused_label", "unused_labels");
+    ls.register_renamed("clippy::drop_bounds", "drop_bounds");
+    ls.register_renamed("clippy::temporary_cstring_as_ptr", "temporary_cstring_as_ptr");
+    ls.register_renamed("clippy::panic_params", "non_fmt_panic");
+    ls.register_renamed("clippy::unknown_clippy_lints", "unknown_lints");
 }
 
 // only exists to let the dogfood integration test works.
diff --git a/tests/ui/deprecated.stderr b/tests/ui/deprecated.stderr
index 64efcd18f88..1c92fb6ff04 100644
--- a/tests/ui/deprecated.stderr
+++ b/tests/ui/deprecated.stderr
@@ -24,23 +24,23 @@ error: lint `clippy::unused_collect` has been removed: `collect` has been marked
 LL | #[warn(clippy::unused_collect)]
    |        ^^^^^^^^^^^^^^^^^^^^^^
 
-error: lint `clippy::invalid_ref` has been removed: superseded by rustc lint `invalid_value`
+error: lint `clippy::invalid_ref` has been renamed to `invalid_value`
   --> $DIR/deprecated.rs:5:8
    |
 LL | #[warn(clippy::invalid_ref)]
-   |        ^^^^^^^^^^^^^^^^^^^
+   |        ^^^^^^^^^^^^^^^^^^^ help: use the new name: `invalid_value`
 
-error: lint `clippy::into_iter_on_array` has been removed: this lint has been uplifted to rustc and is now called `array_into_iter`
+error: lint `clippy::into_iter_on_array` has been renamed to `array_into_iter`
   --> $DIR/deprecated.rs:6:8
    |
 LL | #[warn(clippy::into_iter_on_array)]
-   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `array_into_iter`
 
-error: lint `clippy::unused_label` has been removed: this lint has been uplifted to rustc and is now called `unused_labels`
+error: lint `clippy::unused_label` has been renamed to `unused_labels`
   --> $DIR/deprecated.rs:7:8
    |
 LL | #[warn(clippy::unused_label)]
-   |        ^^^^^^^^^^^^^^^^^^^^
+   |        ^^^^^^^^^^^^^^^^^^^^ help: use the new name: `unused_labels`
 
 error: lint `clippy::regex_macro` has been removed: the regex! macro has been removed from the regex crate in 2018
   --> $DIR/deprecated.rs:8:8
@@ -48,29 +48,29 @@ error: lint `clippy::regex_macro` has been removed: the regex! macro has been re
 LL | #[warn(clippy::regex_macro)]
    |        ^^^^^^^^^^^^^^^^^^^
 
-error: lint `clippy::drop_bounds` has been removed: this lint has been uplifted to rustc and is now called `drop_bounds`
+error: lint `clippy::drop_bounds` has been renamed to `drop_bounds`
   --> $DIR/deprecated.rs:9:8
    |
 LL | #[warn(clippy::drop_bounds)]
-   |        ^^^^^^^^^^^^^^^^^^^
+   |        ^^^^^^^^^^^^^^^^^^^ help: use the new name: `drop_bounds`
 
-error: lint `clippy::temporary_cstring_as_ptr` has been removed: this lint has been uplifted to rustc and is now called `temporary_cstring_as_ptr`
+error: lint `clippy::temporary_cstring_as_ptr` has been renamed to `temporary_cstring_as_ptr`
   --> $DIR/deprecated.rs:10:8
    |
 LL | #[warn(clippy::temporary_cstring_as_ptr)]
-   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `temporary_cstring_as_ptr`
 
-error: lint `clippy::panic_params` has been removed: this lint has been uplifted to rustc and is now called `panic_fmt`
+error: lint `clippy::panic_params` has been renamed to `non_fmt_panic`
   --> $DIR/deprecated.rs:11:8
    |
 LL | #[warn(clippy::panic_params)]
-   |        ^^^^^^^^^^^^^^^^^^^^
+   |        ^^^^^^^^^^^^^^^^^^^^ help: use the new name: `non_fmt_panic`
 
-error: lint `clippy::unknown_clippy_lints` has been removed: this lint has been integrated into the `unknown_lints` rustc lint
+error: lint `clippy::unknown_clippy_lints` has been renamed to `unknown_lints`
   --> $DIR/deprecated.rs:12:8
    |
 LL | #[warn(clippy::unknown_clippy_lints)]
-   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `unknown_lints`
 
 error: lint `clippy::find_map` has been removed: this lint has been replaced by `manual_find_map`, a more specific lint
   --> $DIR/deprecated.rs:13:8
-- 
cgit 1.4.1-3-g733a5


From 297e84f3f4b7ff3c2648e65b0f2c144982cfad63 Mon Sep 17 00:00:00 2001
From: ThibsG <thibsg@pm.me>
Date: Sat, 10 Apr 2021 10:26:53 +0200
Subject: Handle imports which are nested directly

---
 clippy_lints/src/single_component_path_imports.rs  | 73 +++++++++++++++-------
 .../single_component_path_imports_nested_first.rs  | 17 +++++
 ...ngle_component_path_imports_nested_first.stderr | 25 ++++++++
 3 files changed, 92 insertions(+), 23 deletions(-)
 create mode 100644 tests/ui/single_component_path_imports_nested_first.rs
 create mode 100644 tests/ui/single_component_path_imports_nested_first.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/single_component_path_imports.rs b/clippy_lints/src/single_component_path_imports.rs
index adf0d7998f8..6104103580e 100644
--- a/clippy_lints/src/single_component_path_imports.rs
+++ b/clippy_lints/src/single_component_path_imports.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg};
 use clippy_utils::in_macro;
 use rustc_ast::{ptr::P, Crate, Item, ItemKind, ModKind, UseTreeKind};
 use rustc_errors::Applicability;
@@ -66,15 +66,27 @@ fn check_mod(cx: &EarlyContext<'_>, items: &[P<Item>]) {
 
     for single_use in &single_use_usages {
         if !imports_reused_with_self.contains(&single_use.0) {
-            span_lint_and_sugg(
-                cx,
-                SINGLE_COMPONENT_PATH_IMPORTS,
-                single_use.1,
-                "this import is redundant",
-                "remove it entirely",
-                String::new(),
-                Applicability::MachineApplicable,
-            );
+            let can_suggest = single_use.2;
+            if can_suggest {
+                span_lint_and_sugg(
+                    cx,
+                    SINGLE_COMPONENT_PATH_IMPORTS,
+                    single_use.1,
+                    "this import is redundant",
+                    "remove it entirely",
+                    String::new(),
+                    Applicability::MachineApplicable,
+                );
+            } else {
+                span_lint_and_help(
+                    cx,
+                    SINGLE_COMPONENT_PATH_IMPORTS,
+                    single_use.1,
+                    "this import is redundant",
+                    None,
+                    "remove this import",
+                );
+            }
         }
     }
 }
@@ -83,7 +95,7 @@ fn track_uses(
     cx: &EarlyContext<'_>,
     item: &Item,
     imports_reused_with_self: &mut Vec<Symbol>,
-    single_use_usages: &mut Vec<(Symbol, Span)>,
+    single_use_usages: &mut Vec<(Symbol, Span, bool)>,
 ) {
     if in_macro(item.span) || item.vis.kind.is_pub() {
         return;
@@ -100,25 +112,40 @@ fn track_uses(
             if segments.len() == 1 {
                 if let UseTreeKind::Simple(None, _, _) = use_tree.kind {
                     let ident = &segments[0].ident;
-                    single_use_usages.push((ident.name, item.span));
+                    single_use_usages.push((ident.name, item.span, true));
                 }
                 return;
             }
 
-            // keep track of `use self::some_module` usages
-            if segments[0].ident.name == kw::SelfLower {
-                // simple case such as `use self::module::SomeStruct`
-                if segments.len() > 1 {
-                    imports_reused_with_self.push(segments[1].ident.name);
-                    return;
-                }
-
-                // nested case such as `use self::{module1::Struct1, module2::Struct2}`
+            if segments.is_empty() {
+                // keep track of `use {some_module, some_other_module};` usages
                 if let UseTreeKind::Nested(trees) = &use_tree.kind {
                     for tree in trees {
                         let segments = &tree.0.prefix.segments;
-                        if !segments.is_empty() {
-                            imports_reused_with_self.push(segments[0].ident.name);
+                        if segments.len() == 1 {
+                            if let UseTreeKind::Simple(None, _, _) = tree.0.kind {
+                                let ident = &segments[0].ident;
+                                single_use_usages.push((ident.name, tree.0.span, false));
+                            }
+                        }
+                    }
+                }
+            } else {
+                // keep track of `use self::some_module` usages
+                if segments[0].ident.name == kw::SelfLower {
+                    // simple case such as `use self::module::SomeStruct`
+                    if segments.len() > 1 {
+                        imports_reused_with_self.push(segments[1].ident.name);
+                        return;
+                    }
+
+                    // nested case such as `use self::{module1::Struct1, module2::Struct2}`
+                    if let UseTreeKind::Nested(trees) = &use_tree.kind {
+                        for tree in trees {
+                            let segments = &tree.0.prefix.segments;
+                            if !segments.is_empty() {
+                                imports_reused_with_self.push(segments[0].ident.name);
+                            }
                         }
                     }
                 }
diff --git a/tests/ui/single_component_path_imports_nested_first.rs b/tests/ui/single_component_path_imports_nested_first.rs
new file mode 100644
index 00000000000..94117061b27
--- /dev/null
+++ b/tests/ui/single_component_path_imports_nested_first.rs
@@ -0,0 +1,17 @@
+// edition:2018
+#![warn(clippy::single_component_path_imports)]
+#![allow(unused_imports)]
+
+use regex;
+use serde as edres;
+pub use serde;
+
+fn main() {
+    regex::Regex::new(r"^\d{4}-\d{2}-\d{2}$").unwrap();
+}
+
+mod root_nested_use_mod {
+    use {regex, serde};
+    #[allow(dead_code)]
+    fn root_nested_use_mod() {}
+}
diff --git a/tests/ui/single_component_path_imports_nested_first.stderr b/tests/ui/single_component_path_imports_nested_first.stderr
new file mode 100644
index 00000000000..0c3256c1ce4
--- /dev/null
+++ b/tests/ui/single_component_path_imports_nested_first.stderr
@@ -0,0 +1,25 @@
+error: this import is redundant
+  --> $DIR/single_component_path_imports_nested_first.rs:14:10
+   |
+LL |     use {regex, serde};
+   |          ^^^^^
+   |
+   = note: `-D clippy::single-component-path-imports` implied by `-D warnings`
+   = help: remove this import
+
+error: this import is redundant
+  --> $DIR/single_component_path_imports_nested_first.rs:14:17
+   |
+LL |     use {regex, serde};
+   |                 ^^^^^
+   |
+   = help: remove this import
+
+error: this import is redundant
+  --> $DIR/single_component_path_imports_nested_first.rs:5:1
+   |
+LL | use regex;
+   | ^^^^^^^^^^ help: remove it entirely
+
+error: aborting due to 3 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From dde46c9340994ad396a8677702be58122384a5ed Mon Sep 17 00:00:00 2001
From: Philipp Hansch <dev@phansch.net>
Date: Sat, 10 Apr 2021 14:42:33 +0200
Subject: Replace complex conditional with pattern matching

---
 clippy_lints/src/tabs_in_doc_comments.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/tabs_in_doc_comments.rs b/clippy_lints/src/tabs_in_doc_comments.rs
index 3f9692540f7..d68227545a6 100644
--- a/clippy_lints/src/tabs_in_doc_comments.rs
+++ b/clippy_lints/src/tabs_in_doc_comments.rs
@@ -106,7 +106,7 @@ fn get_chunks_of_tabs(the_str: &str) -> Vec<(u32, u32)> {
 
     let char_indices: Vec<_> = the_str.char_indices().collect();
 
-    if char_indices.len() == 1 && char_indices.first().unwrap().1 == '\t' {
+    if let &[(_, '\t')] = &char_indices.as_slice() {
         return vec![(0, 1)];
     }
 
-- 
cgit 1.4.1-3-g733a5


From 47a4865406ec748729a6e7ec23e5a4d5f9b88230 Mon Sep 17 00:00:00 2001
From: Philipp Hansch <dev@phansch.net>
Date: Sat, 10 Apr 2021 15:30:51 +0200
Subject: Fix dogfood

---
 clippy_lints/src/tabs_in_doc_comments.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/tabs_in_doc_comments.rs b/clippy_lints/src/tabs_in_doc_comments.rs
index d68227545a6..51581b75ce3 100644
--- a/clippy_lints/src/tabs_in_doc_comments.rs
+++ b/clippy_lints/src/tabs_in_doc_comments.rs
@@ -106,7 +106,7 @@ fn get_chunks_of_tabs(the_str: &str) -> Vec<(u32, u32)> {
 
     let char_indices: Vec<_> = the_str.char_indices().collect();
 
-    if let &[(_, '\t')] = &char_indices.as_slice() {
+    if let [(_, '\t')] = char_indices.as_slice() {
         return vec![(0, 1)];
     }
 
@@ -121,12 +121,12 @@ fn get_chunks_of_tabs(the_str: &str) -> Vec<(u32, u32)> {
                 // as ['\t', '\t'] is excluded, this has to be a start of a tab group,
                 // set indices accordingly
                 is_active = true;
-                current_start = *index_b as u32;
+                current_start = u32::try_from(*index_b).unwrap();
             },
             [(_, '\t'), (index_b, _)] => {
                 // this now has to be an end of the group, hence we have to push a new tuple
                 is_active = false;
-                spans.push((current_start, *index_b as u32));
+                spans.push((current_start, u32::try_from(*index_b).unwrap()));
             },
             _ => {},
         }
@@ -149,7 +149,7 @@ mod tests_for_get_chunks_of_tabs {
 
     #[test]
     fn test_unicode_han_string() {
-        let res = get_chunks_of_tabs(" 位\t");
+        let res = get_chunks_of_tabs(" \u{4f4d}\t");
 
         assert_eq!(res, vec![(4, 5)]);
     }
-- 
cgit 1.4.1-3-g733a5


From 43e6c656ba0f221caace290b8a8deace2abd89cd Mon Sep 17 00:00:00 2001
From: daxpedda <daxpedda@gmail.com>
Date: Sat, 10 Apr 2021 17:38:04 +0200
Subject: Remove `debug_assert` from `panic_in_result_fn`

---
 clippy_lints/src/panic_in_result_fn.rs             |  3 --
 tests/ui/panic_in_result_fn_debug_assertions.rs    | 16 +++---
 .../ui/panic_in_result_fn_debug_assertions.stderr  | 57 ----------------------
 3 files changed, 9 insertions(+), 67 deletions(-)
 delete mode 100644 tests/ui/panic_in_result_fn_debug_assertions.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/panic_in_result_fn.rs b/clippy_lints/src/panic_in_result_fn.rs
index d32b937b209..791a2bf0798 100644
--- a/clippy_lints/src/panic_in_result_fn.rs
+++ b/clippy_lints/src/panic_in_result_fn.rs
@@ -61,9 +61,6 @@ fn lint_impl_body<'tcx>(cx: &LateContext<'tcx>, impl_span: Span, body: &'tcx hir
             "assert",
             "assert_eq",
             "assert_ne",
-            "debug_assert",
-            "debug_assert_eq",
-            "debug_assert_ne",
         ],
         body,
     );
diff --git a/tests/ui/panic_in_result_fn_debug_assertions.rs b/tests/ui/panic_in_result_fn_debug_assertions.rs
index b60c79f97c8..1f8485b8cd8 100644
--- a/tests/ui/panic_in_result_fn_debug_assertions.rs
+++ b/tests/ui/panic_in_result_fn_debug_assertions.rs
@@ -1,43 +1,45 @@
 #![warn(clippy::panic_in_result_fn)]
 #![allow(clippy::unnecessary_wraps)]
 
+// debug_assert should never trigger the `panic_in_result_fn` lint
+
 struct A;
 
 impl A {
-    fn result_with_debug_assert_with_message(x: i32) -> Result<bool, String> // should emit lint
+    fn result_with_debug_assert_with_message(x: i32) -> Result<bool, String>
     {
         debug_assert!(x == 5, "wrong argument");
         Ok(true)
     }
 
-    fn result_with_debug_assert_eq(x: i32) -> Result<bool, String> // should emit lint
+    fn result_with_debug_assert_eq(x: i32) -> Result<bool, String>
     {
         debug_assert_eq!(x, 5);
         Ok(true)
     }
 
-    fn result_with_debug_assert_ne(x: i32) -> Result<bool, String> // should emit lint
+    fn result_with_debug_assert_ne(x: i32) -> Result<bool, String>
     {
         debug_assert_ne!(x, 1);
         Ok(true)
     }
 
-    fn other_with_debug_assert_with_message(x: i32) // should not emit lint
+    fn other_with_debug_assert_with_message(x: i32)
     {
         debug_assert!(x == 5, "wrong argument");
     }
 
-    fn other_with_debug_assert_eq(x: i32) // should not emit lint
+    fn other_with_debug_assert_eq(x: i32)
     {
         debug_assert_eq!(x, 5);
     }
 
-    fn other_with_debug_assert_ne(x: i32) // should not emit lint
+    fn other_with_debug_assert_ne(x: i32)
     {
         debug_assert_ne!(x, 1);
     }
 
-    fn result_without_banned_functions() -> Result<bool, String> // should not emit lint
+    fn result_without_banned_functions() -> Result<bool, String>
     {
         let debug_assert = "debug_assert!";
         println!("No {}", debug_assert);
diff --git a/tests/ui/panic_in_result_fn_debug_assertions.stderr b/tests/ui/panic_in_result_fn_debug_assertions.stderr
deleted file mode 100644
index ec18e89698c..00000000000
--- a/tests/ui/panic_in_result_fn_debug_assertions.stderr
+++ /dev/null
@@ -1,57 +0,0 @@
-error: used `unimplemented!()`, `unreachable!()`, `todo!()`, `panic!()` or assertion in a function that returns `Result`
-  --> $DIR/panic_in_result_fn_debug_assertions.rs:7:5
-   |
-LL | /     fn result_with_debug_assert_with_message(x: i32) -> Result<bool, String> // should emit lint
-LL | |     {
-LL | |         debug_assert!(x == 5, "wrong argument");
-LL | |         Ok(true)
-LL | |     }
-   | |_____^
-   |
-   = note: `-D clippy::panic-in-result-fn` implied by `-D warnings`
-   = help: `unimplemented!()`, `unreachable!()`, `todo!()`, `panic!()` or assertions should not be used in a function that returns `Result` as `Result` is expected to return an error instead of crashing
-note: return Err() instead of panicking
-  --> $DIR/panic_in_result_fn_debug_assertions.rs:9:9
-   |
-LL |         debug_assert!(x == 5, "wrong argument");
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
-
-error: used `unimplemented!()`, `unreachable!()`, `todo!()`, `panic!()` or assertion in a function that returns `Result`
-  --> $DIR/panic_in_result_fn_debug_assertions.rs:13:5
-   |
-LL | /     fn result_with_debug_assert_eq(x: i32) -> Result<bool, String> // should emit lint
-LL | |     {
-LL | |         debug_assert_eq!(x, 5);
-LL | |         Ok(true)
-LL | |     }
-   | |_____^
-   |
-   = help: `unimplemented!()`, `unreachable!()`, `todo!()`, `panic!()` or assertions should not be used in a function that returns `Result` as `Result` is expected to return an error instead of crashing
-note: return Err() instead of panicking
-  --> $DIR/panic_in_result_fn_debug_assertions.rs:15:9
-   |
-LL |         debug_assert_eq!(x, 5);
-   |         ^^^^^^^^^^^^^^^^^^^^^^^
-   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
-
-error: used `unimplemented!()`, `unreachable!()`, `todo!()`, `panic!()` or assertion in a function that returns `Result`
-  --> $DIR/panic_in_result_fn_debug_assertions.rs:19:5
-   |
-LL | /     fn result_with_debug_assert_ne(x: i32) -> Result<bool, String> // should emit lint
-LL | |     {
-LL | |         debug_assert_ne!(x, 1);
-LL | |         Ok(true)
-LL | |     }
-   | |_____^
-   |
-   = help: `unimplemented!()`, `unreachable!()`, `todo!()`, `panic!()` or assertions should not be used in a function that returns `Result` as `Result` is expected to return an error instead of crashing
-note: return Err() instead of panicking
-  --> $DIR/panic_in_result_fn_debug_assertions.rs:21:9
-   |
-LL |         debug_assert_ne!(x, 1);
-   |         ^^^^^^^^^^^^^^^^^^^^^^^
-   = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
-
-error: aborting due to 3 previous errors
-
-- 
cgit 1.4.1-3-g733a5


From 271c163ba319ce8518913057cef32978f38b2f6a Mon Sep 17 00:00:00 2001
From: daxpedda <daxpedda@gmail.com>
Date: Sat, 10 Apr 2021 20:54:40 +0200
Subject: Fix false-positive `debug_assert`

---
 clippy_lints/src/panic_in_result_fn.rs | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/panic_in_result_fn.rs b/clippy_lints/src/panic_in_result_fn.rs
index 791a2bf0798..cef74d87e7c 100644
--- a/clippy_lints/src/panic_in_result_fn.rs
+++ b/clippy_lints/src/panic_in_result_fn.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{find_macro_calls, return_ty};
+use clippy_utils::{find_macro_calls, is_expn_of, return_ty};
 use rustc_hir as hir;
 use rustc_hir::intravisit::FnKind;
 use rustc_lint::{LateContext, LateLintPass};
@@ -52,7 +52,7 @@ impl<'tcx> LateLintPass<'tcx> for PanicInResultFn {
 }
 
 fn lint_impl_body<'tcx>(cx: &LateContext<'tcx>, impl_span: Span, body: &'tcx hir::Body<'tcx>) {
-    let panics = find_macro_calls(
+    let mut panics = find_macro_calls(
         &[
             "unimplemented",
             "unreachable",
@@ -64,6 +64,7 @@ fn lint_impl_body<'tcx>(cx: &LateContext<'tcx>, impl_span: Span, body: &'tcx hir
         ],
         body,
     );
+    panics.retain(|span| is_expn_of(*span, "debug_assert").is_none());
     if !panics.is_empty() {
         span_lint_and_then(
             cx,
-- 
cgit 1.4.1-3-g733a5


From cb14e7ebf40bb6edf9307813b341a9119800ef49 Mon Sep 17 00:00:00 2001
From: daxpedda <daxpedda@gmail.com>
Date: Sat, 10 Apr 2021 23:37:18 +0200
Subject: Fix false-positive `debug_assert` in `panic`

---
 clippy_lints/src/panic_unimplemented.rs |  2 +-
 tests/ui/panicking_macros.rs            | 14 +++++++++++++-
 2 files changed, 14 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/panic_unimplemented.rs b/clippy_lints/src/panic_unimplemented.rs
index 1e946858947..1a680e7607e 100644
--- a/clippy_lints/src/panic_unimplemented.rs
+++ b/clippy_lints/src/panic_unimplemented.rs
@@ -74,7 +74,7 @@ declare_lint_pass!(PanicUnimplemented => [UNIMPLEMENTED, UNREACHABLE, TODO, PANI
 
 impl<'tcx> LateLintPass<'tcx> for PanicUnimplemented {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if match_panic_call(cx, expr).is_some() {
+        if match_panic_call(cx, expr).is_some() && is_expn_of(expr.span, "debug_assert").is_none() {
             let span = get_outer_span(expr);
             if is_expn_of(expr.span, "unimplemented").is_some() {
                 span_lint(
diff --git a/tests/ui/panicking_macros.rs b/tests/ui/panicking_macros.rs
index 77fcb8dfd02..93b236f7473 100644
--- a/tests/ui/panicking_macros.rs
+++ b/tests/ui/panicking_macros.rs
@@ -1,5 +1,5 @@
 #![warn(clippy::unimplemented, clippy::unreachable, clippy::todo, clippy::panic)]
-#![allow(clippy::assertions_on_constants)]
+#![allow(clippy::assertions_on_constants, clippy::eq_op)]
 
 extern crate core;
 
@@ -43,6 +43,18 @@ fn core_versions() {
     unreachable!();
 }
 
+fn debug_assert() {
+    debug_assert!(true);
+    debug_assert_eq!(true, true);
+    debug_assert_ne!(true, false);
+}
+
+fn debug_assert_msg() {
+    debug_assert!(true, "test");
+    debug_assert_eq!(true, true, "test");
+    debug_assert_ne!(true, false, "test");
+}
+
 fn main() {
     panic();
     todo();
-- 
cgit 1.4.1-3-g733a5


From a45faf66f3f35f644be2e121a1cd478bb2b908e0 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Fri, 9 Apr 2021 16:25:39 -0500
Subject: Deprecate filter_map

---
 clippy_lints/src/deprecated_lints.rs            |  9 ++++++
 clippy_lints/src/lib.rs                         |  6 ++--
 clippy_lints/src/methods/filter_flat_map.rs     | 18 -----------
 clippy_lints/src/methods/filter_map_flat_map.rs | 18 -----------
 clippy_lints/src/methods/filter_map_map.rs      | 17 -----------
 clippy_lints/src/methods/mod.rs                 | 40 +------------------------
 clippy_utils/src/attrs.rs                       |  1 -
 lintcheck/src/main.rs                           |  2 +-
 tests/ui/deprecated.rs                          |  1 +
 tests/ui/deprecated.stderr                      |  8 ++++-
 tests/ui/filter_methods.rs                      | 25 ----------------
 tests/ui/filter_methods.stderr                  | 39 ------------------------
 12 files changed, 23 insertions(+), 161 deletions(-)
 delete mode 100644 clippy_lints/src/methods/filter_flat_map.rs
 delete mode 100644 clippy_lints/src/methods/filter_map_flat_map.rs
 delete mode 100644 clippy_lints/src/methods/filter_map_map.rs
 delete mode 100644 tests/ui/filter_methods.rs
 delete mode 100644 tests/ui/filter_methods.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/deprecated_lints.rs b/clippy_lints/src/deprecated_lints.rs
index 89088c533ed..6f61229e133 100644
--- a/clippy_lints/src/deprecated_lints.rs
+++ b/clippy_lints/src/deprecated_lints.rs
@@ -188,3 +188,12 @@ declare_deprecated_lint! {
     pub FIND_MAP,
     "this lint has been replaced by `manual_find_map`, a more specific lint"
 }
+
+declare_deprecated_lint! {
+    /// **What it does:** Nothing. This lint has been deprecated.
+    ///
+    /// **Deprecation reason:** This lint has been replaced by `manual_filter_map`, a
+    /// more specific lint.
+    pub FILTER_MAP,
+    "this lint has been replaced by `manual_filter_map`, a more specific lint"
+}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index b066643b568..03454271da5 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -537,6 +537,10 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         "clippy::find_map",
         "this lint has been replaced by `manual_find_map`, a more specific lint",
     );
+    store.register_removed(
+        "clippy::filter_map",
+        "this lint has been replaced by `manual_filter_map`, a more specific lint",
+    );
     // end deprecated lints, do not remove this comment, it’s used in `update_lints`
 
     // begin register lints, do not remove this comment, it’s used in `update_lints`
@@ -788,7 +792,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         methods::EXPECT_FUN_CALL,
         methods::EXPECT_USED,
         methods::FILETYPE_IS_FILE,
-        methods::FILTER_MAP,
         methods::FILTER_MAP_IDENTITY,
         methods::FILTER_MAP_NEXT,
         methods::FILTER_NEXT,
@@ -1404,7 +1407,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(matches::MATCH_WILDCARD_FOR_SINGLE_VARIANTS),
         LintId::of(matches::MATCH_WILD_ERR_ARM),
         LintId::of(matches::SINGLE_MATCH_ELSE),
-        LintId::of(methods::FILTER_MAP),
         LintId::of(methods::FILTER_MAP_NEXT),
         LintId::of(methods::IMPLICIT_CLONE),
         LintId::of(methods::INEFFICIENT_TO_STRING),
diff --git a/clippy_lints/src/methods/filter_flat_map.rs b/clippy_lints/src/methods/filter_flat_map.rs
deleted file mode 100644
index 1588eec8882..00000000000
--- a/clippy_lints/src/methods/filter_flat_map.rs
+++ /dev/null
@@ -1,18 +0,0 @@
-use clippy_utils::diagnostics::span_lint_and_help;
-use clippy_utils::is_trait_method;
-use rustc_hir as hir;
-use rustc_lint::LateContext;
-use rustc_span::sym;
-
-use super::FILTER_MAP;
-
-/// lint use of `filter().flat_map()` for `Iterators`
-pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
-    // lint if caller of `.filter().flat_map()` is an Iterator
-    if is_trait_method(cx, expr, sym::Iterator) {
-        let msg = "called `filter(..).flat_map(..)` on an `Iterator`";
-        let hint = "this is more succinctly expressed by calling `.flat_map(..)` \
-                    and filtering by returning `iter::empty()`";
-        span_lint_and_help(cx, FILTER_MAP, expr.span, msg, None, hint);
-    }
-}
diff --git a/clippy_lints/src/methods/filter_map_flat_map.rs b/clippy_lints/src/methods/filter_map_flat_map.rs
deleted file mode 100644
index 741b1e7e361..00000000000
--- a/clippy_lints/src/methods/filter_map_flat_map.rs
+++ /dev/null
@@ -1,18 +0,0 @@
-use clippy_utils::diagnostics::span_lint_and_help;
-use clippy_utils::is_trait_method;
-use rustc_hir as hir;
-use rustc_lint::LateContext;
-use rustc_span::sym;
-
-use super::FILTER_MAP;
-
-/// lint use of `filter_map().flat_map()` for `Iterators`
-pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
-    // lint if caller of `.filter_map().flat_map()` is an Iterator
-    if is_trait_method(cx, expr, sym::Iterator) {
-        let msg = "called `filter_map(..).flat_map(..)` on an `Iterator`";
-        let hint = "this is more succinctly expressed by calling `.flat_map(..)` \
-                    and filtering by returning `iter::empty()`";
-        span_lint_and_help(cx, FILTER_MAP, expr.span, msg, None, hint);
-    }
-}
diff --git a/clippy_lints/src/methods/filter_map_map.rs b/clippy_lints/src/methods/filter_map_map.rs
deleted file mode 100644
index 713bbf25837..00000000000
--- a/clippy_lints/src/methods/filter_map_map.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-use clippy_utils::diagnostics::span_lint_and_help;
-use clippy_utils::is_trait_method;
-use rustc_hir as hir;
-use rustc_lint::LateContext;
-use rustc_span::sym;
-
-use super::FILTER_MAP;
-
-/// lint use of `filter_map().map()` for `Iterators`
-pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
-    // lint if caller of `.filter_map().map()` is an Iterator
-    if is_trait_method(cx, expr, sym::Iterator) {
-        let msg = "called `filter_map(..).map(..)` on an `Iterator`";
-        let hint = "this is more succinctly expressed by only calling `.filter_map(..)` instead";
-        span_lint_and_help(cx, FILTER_MAP, expr.span, msg, None, hint);
-    }
-}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index b1ade5addd6..fc18849b07c 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -11,11 +11,8 @@ mod clone_on_ref_ptr;
 mod expect_fun_call;
 mod expect_used;
 mod filetype_is_file;
-mod filter_flat_map;
 mod filter_map;
-mod filter_map_flat_map;
 mod filter_map_identity;
-mod filter_map_map;
 mod filter_map_next;
 mod filter_next;
 mod flat_map_identity;
@@ -472,35 +469,6 @@ declare_clippy_lint! {
     "using combinations of `flatten` and `map` which can usually be written as a single method call"
 }
 
-declare_clippy_lint! {
-    /// **What it does:** Checks for usage of `_.filter(_).map(_)`,
-    /// `_.filter(_).flat_map(_)`, `_.filter_map(_).flat_map(_)` and similar.
-    ///
-    /// **Why is this bad?** Readability, this can be written more concisely as
-    /// `_.filter_map(_)`.
-    ///
-    /// **Known problems:** Often requires a condition + Option/Iterator creation
-    /// inside the closure.
-    ///
-    /// **Example:**
-    /// ```rust
-    /// let vec = vec![1];
-    ///
-    /// // Bad
-    /// vec.iter().filter(|x| **x == 0).map(|x| *x * 2);
-    ///
-    /// // Good
-    /// vec.iter().filter_map(|x| if *x == 0 {
-    ///     Some(*x * 2)
-    /// } else {
-    ///     None
-    /// });
-    /// ```
-    pub FILTER_MAP,
-    pedantic,
-    "using combinations of `filter`, `map`, `filter_map` and `flat_map` which can usually be written as a single method call"
-}
-
 declare_clippy_lint! {
     /// **What it does:** Checks for usage of `_.filter(_).map(_)` that can be written more simply
     /// as `filter_map(_)`.
@@ -1677,7 +1645,6 @@ impl_lint_pass!(Methods => [
     SEARCH_IS_SOME,
     FILTER_NEXT,
     SKIP_WHILE_NEXT,
-    FILTER_MAP,
     FILTER_MAP_IDENTITY,
     MANUAL_FILTER_MAP,
     MANUAL_FIND_MAP,
@@ -1965,11 +1932,7 @@ fn check_methods<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, msrv: Optio
                 unnecessary_filter_map::check(cx, expr, arg);
                 filter_map_identity::check(cx, expr, arg, span);
             },
-            ("flat_map", [flm_arg]) => match method_call!(recv) {
-                Some(("filter", [_, _], _)) => filter_flat_map::check(cx, expr),
-                Some(("filter_map", [_, _], _)) => filter_map_flat_map::check(cx, expr),
-                _ => flat_map_identity::check(cx, expr, flm_arg, span),
-            },
+            ("flat_map", [flm_arg]) => flat_map_identity::check(cx, expr, flm_arg, span),
             ("flatten", []) => {
                 if let Some(("map", [recv, map_arg], _)) = method_call!(recv) {
                     map_flatten::check(cx, expr, recv, map_arg);
@@ -1993,7 +1956,6 @@ fn check_methods<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, msrv: Optio
                         ("filter", [f_arg]) => {
                             filter_map::check(cx, expr, recv2, f_arg, span2, recv, m_arg, span, false)
                         },
-                        ("filter_map", [_]) => filter_map_map::check(cx, expr),
                         ("find", [f_arg]) => filter_map::check(cx, expr, recv2, f_arg, span2, recv, m_arg, span, true),
                         _ => {},
                     }
diff --git a/clippy_utils/src/attrs.rs b/clippy_utils/src/attrs.rs
index 7ec8452bf4c..5e44c7b3ee0 100644
--- a/clippy_utils/src/attrs.rs
+++ b/clippy_utils/src/attrs.rs
@@ -151,7 +151,6 @@ pub fn is_proc_macro(sess: &Session, attrs: &[ast::Attribute]) -> bool {
 
 /// Return true if the attributes contain `#[doc(hidden)]`
 pub fn is_doc_hidden(attrs: &[ast::Attribute]) -> bool {
-    #[allow(clippy::filter_map)]
     attrs
         .iter()
         .filter(|attr| attr.has_name(sym::doc))
diff --git a/lintcheck/src/main.rs b/lintcheck/src/main.rs
index 2041aed2b97..bfb0c3b3f74 100644
--- a/lintcheck/src/main.rs
+++ b/lintcheck/src/main.rs
@@ -5,7 +5,7 @@
 // When a new lint is introduced, we can search the results for new warnings and check for false
 // positives.
 
-#![allow(clippy::filter_map, clippy::collapsible_else_if)]
+#![allow(clippy::collapsible_else_if)]
 
 use std::ffi::OsStr;
 use std::process::Command;
diff --git a/tests/ui/deprecated.rs b/tests/ui/deprecated.rs
index fc444c0bea7..dbf0b03af76 100644
--- a/tests/ui/deprecated.rs
+++ b/tests/ui/deprecated.rs
@@ -11,5 +11,6 @@
 #[warn(clippy::panic_params)]
 #[warn(clippy::unknown_clippy_lints)]
 #[warn(clippy::find_map)]
+#[warn(clippy::filter_map)]
 
 fn main() {}
diff --git a/tests/ui/deprecated.stderr b/tests/ui/deprecated.stderr
index 64efcd18f88..aa3ed28d40b 100644
--- a/tests/ui/deprecated.stderr
+++ b/tests/ui/deprecated.stderr
@@ -78,11 +78,17 @@ error: lint `clippy::find_map` has been removed: this lint has been replaced by
 LL | #[warn(clippy::find_map)]
    |        ^^^^^^^^^^^^^^^^
 
+error: lint `clippy::filter_map` has been removed: this lint has been replaced by `manual_filter_map`, a more specific lint
+  --> $DIR/deprecated.rs:14:8
+   |
+LL | #[warn(clippy::filter_map)]
+   |        ^^^^^^^^^^^^^^^^^^
+
 error: lint `clippy::unstable_as_slice` has been removed: `Vec::as_slice` has been stabilized in 1.7
   --> $DIR/deprecated.rs:1:8
    |
 LL | #[warn(clippy::unstable_as_slice)]
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 14 previous errors
+error: aborting due to 15 previous errors
 
diff --git a/tests/ui/filter_methods.rs b/tests/ui/filter_methods.rs
deleted file mode 100644
index 51450241619..00000000000
--- a/tests/ui/filter_methods.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-#![warn(clippy::all, clippy::pedantic)]
-#![allow(clippy::clippy::let_underscore_drop)]
-#![allow(clippy::missing_docs_in_private_items)]
-
-fn main() {
-    let _: Vec<_> = vec![5; 6].into_iter().filter(|&x| x == 0).map(|x| x * 2).collect();
-
-    let _: Vec<_> = vec![5_i8; 6]
-        .into_iter()
-        .filter(|&x| x == 0)
-        .flat_map(|x| x.checked_mul(2))
-        .collect();
-
-    let _: Vec<_> = vec![5_i8; 6]
-        .into_iter()
-        .filter_map(|x| x.checked_mul(2))
-        .flat_map(|x| x.checked_mul(2))
-        .collect();
-
-    let _: Vec<_> = vec![5_i8; 6]
-        .into_iter()
-        .filter_map(|x| x.checked_mul(2))
-        .map(|x| x.checked_mul(2))
-        .collect();
-}
diff --git a/tests/ui/filter_methods.stderr b/tests/ui/filter_methods.stderr
deleted file mode 100644
index c7b4f28be3a..00000000000
--- a/tests/ui/filter_methods.stderr
+++ /dev/null
@@ -1,39 +0,0 @@
-error: called `filter(..).flat_map(..)` on an `Iterator`
-  --> $DIR/filter_methods.rs:8:21
-   |
-LL |       let _: Vec<_> = vec![5_i8; 6]
-   |  _____________________^
-LL | |         .into_iter()
-LL | |         .filter(|&x| x == 0)
-LL | |         .flat_map(|x| x.checked_mul(2))
-   | |_______________________________________^
-   |
-   = note: `-D clippy::filter-map` implied by `-D warnings`
-   = help: this is more succinctly expressed by calling `.flat_map(..)` and filtering by returning `iter::empty()`
-
-error: called `filter_map(..).flat_map(..)` on an `Iterator`
-  --> $DIR/filter_methods.rs:14:21
-   |
-LL |       let _: Vec<_> = vec![5_i8; 6]
-   |  _____________________^
-LL | |         .into_iter()
-LL | |         .filter_map(|x| x.checked_mul(2))
-LL | |         .flat_map(|x| x.checked_mul(2))
-   | |_______________________________________^
-   |
-   = help: this is more succinctly expressed by calling `.flat_map(..)` and filtering by returning `iter::empty()`
-
-error: called `filter_map(..).map(..)` on an `Iterator`
-  --> $DIR/filter_methods.rs:20:21
-   |
-LL |       let _: Vec<_> = vec![5_i8; 6]
-   |  _____________________^
-LL | |         .into_iter()
-LL | |         .filter_map(|x| x.checked_mul(2))
-LL | |         .map(|x| x.checked_mul(2))
-   | |__________________________________^
-   |
-   = help: this is more succinctly expressed by only calling `.filter_map(..)` instead
-
-error: aborting due to 3 previous errors
-
-- 
cgit 1.4.1-3-g733a5


From 3ce6f0d022014ba13ed328a372c1ac1f37d9045e Mon Sep 17 00:00:00 2001
From: ThibsG <thibsg@pm.me>
Date: Sun, 11 Apr 2021 13:29:08 +0200
Subject: Fix FP in `wrong_self_convention` lint

---
 clippy_lints/src/methods/wrong_self_convention.rs |  8 ++++++++
 tests/ui/wrong_self_convention2.rs                | 12 ++++++++++++
 2 files changed, 20 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/wrong_self_convention.rs b/clippy_lints/src/methods/wrong_self_convention.rs
index 1e0de249a91..6e2bcb113c2 100644
--- a/clippy_lints/src/methods/wrong_self_convention.rs
+++ b/clippy_lints/src/methods/wrong_self_convention.rs
@@ -102,6 +102,14 @@ pub(super) fn check<'tcx>(
             .iter()
             .all(|conv| conv.check(cx, self_ty, item_name, implements_trait, is_trait_item))
     }) {
+        // don't lint if it implements a trait but not willing to check `Copy` types conventions (see #7032)
+        if implements_trait
+            && !conventions
+                .iter()
+                .any(|conv| matches!(conv, Convention::IsSelfTypeCopy(_)))
+        {
+            return;
+        }
         if !self_kinds.iter().any(|k| k.matches(cx, self_ty, first_arg_ty)) {
             let suggestion = {
                 if conventions.len() > 1 {
diff --git a/tests/ui/wrong_self_convention2.rs b/tests/ui/wrong_self_convention2.rs
index 8b42aa59e13..ae3a740d405 100644
--- a/tests/ui/wrong_self_convention2.rs
+++ b/tests/ui/wrong_self_convention2.rs
@@ -30,3 +30,15 @@ mod issue6983 {
         }
     }
 }
+
+mod issue7032 {
+    trait Foo {
+        fn from_usize(x: usize) -> Self;
+    }
+    // don't trigger
+    impl Foo for usize {
+        fn from_usize(x: usize) -> Self {
+            x
+        }
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From fb54b703c7e6cfda05991fbe7e6f292fc82c4a27 Mon Sep 17 00:00:00 2001
From: rail <12975677+rail-rain@users.noreply.github.com>
Date: Sat, 10 Apr 2021 17:50:54 +1200
Subject: Add a note on the issue #5953

---
 clippy_lints/src/pass_by_ref_or_value.rs | 8 ++++++++
 1 file changed, 8 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/pass_by_ref_or_value.rs b/clippy_lints/src/pass_by_ref_or_value.rs
index 9a5b1c3b944..48b1d2b94a1 100644
--- a/clippy_lints/src/pass_by_ref_or_value.rs
+++ b/clippy_lints/src/pass_by_ref_or_value.rs
@@ -41,6 +41,14 @@ declare_clippy_lint! {
     /// false positives in cases involving multiple lifetimes that are bounded by
     /// each other.
     ///
+    /// Also, it does not take account of other similar cases where getting memory addresses
+    /// matters; namely, returning the pointer to the argument in question,
+    /// and passing the argument, as both references and pointers,
+    /// to a function that needs the memory address. For further details, refer to
+    /// [this issue](https://github.com/rust-lang/rust-clippy/issues/5953)
+    /// that explains a real case in which this false positive
+    /// led to an **undefined behaviour** introduced with unsafe code.
+    ///
     /// **Example:**
     ///
     /// ```rust
-- 
cgit 1.4.1-3-g733a5


From 53260df2fa499f1e1908fb2a6b5ce3442f9a023e Mon Sep 17 00:00:00 2001
From: Takayuki <takoyaki0316@gmail.com>
Date: Mon, 12 Apr 2021 21:36:49 +0900
Subject: fix a false negative on `needless_return`

---
 clippy_lints/src/returns.rs | 1 +
 1 file changed, 1 insertion(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
index af772cf4a14..3a6151dce71 100644
--- a/clippy_lints/src/returns.rs
+++ b/clippy_lints/src/returns.rs
@@ -223,6 +223,7 @@ fn check_final_expr<'tcx>(
             },
             _ => (),
         },
+        ExprKind::DropTemps(expr) => check_final_expr(cx, expr, None, RetReplacement::Empty),
         _ => (),
     }
 }
-- 
cgit 1.4.1-3-g733a5


From d6beb1841152a80ec10a5039e2294cd074fc3231 Mon Sep 17 00:00:00 2001
From: boxdot <d@zerovolt.org>
Date: Mon, 12 Apr 2021 18:34:16 +0200
Subject: Remove paths::STD_PTR_NULL

---
 clippy_lints/src/transmuting_null.rs | 14 +++++++-------
 clippy_utils/src/paths.rs            |  2 --
 2 files changed, 7 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/transmuting_null.rs b/clippy_lints/src/transmuting_null.rs
index 0be05d3e0cf..755132da591 100644
--- a/clippy_lints/src/transmuting_null.rs
+++ b/clippy_lints/src/transmuting_null.rs
@@ -1,6 +1,6 @@
 use crate::consts::{constant_context, Constant};
 use clippy_utils::diagnostics::span_lint;
-use clippy_utils::{match_qpath, paths};
+use clippy_utils::{match_def_path, paths};
 use if_chain::if_chain;
 use rustc_ast::LitKind;
 use rustc_hir::{Expr, ExprKind};
@@ -38,10 +38,10 @@ impl<'tcx> LateLintPass<'tcx> for TransmutingNull {
 
         if_chain! {
             if let ExprKind::Call(func, args) = expr.kind;
-            if let ExprKind::Path(ref path) = func.kind;
-            if match_qpath(path, &paths::STD_MEM_TRANSMUTE);
             if args.len() == 1;
-
+            if let ExprKind::Path(ref path) = func.kind;
+            if let Some(func_def_id) = cx.qpath_res(path, func.hir_id).opt_def_id();
+            if match_def_path(cx, func_def_id, &paths::TRANSMUTE);
             then {
 
                 // Catching transmute over constants that resolve to `null`.
@@ -69,10 +69,10 @@ impl<'tcx> LateLintPass<'tcx> for TransmutingNull {
                 // Catching:
                 // `std::mem::transmute(std::ptr::null::<i32>())`
                 if_chain! {
-                    if let ExprKind::Call(func1, args1) = args[0].kind;
+                    if let ExprKind::Call(func1, []) = args[0].kind;
                     if let ExprKind::Path(ref path1) = func1.kind;
-                    if match_qpath(path1, &paths::STD_PTR_NULL);
-                    if args1.is_empty();
+                    if let Some(func1_def_id) = cx.qpath_res(path1, func1.hir_id).opt_def_id();
+                    if match_def_path(cx, func1_def_id, &paths::PTR_NULL);
                     then {
                         span_lint(cx, TRANSMUTING_NULL, expr.span, LINT_MSG)
                     }
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index 5da9c624ac4..ed8915f59e1 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -142,8 +142,6 @@ pub const STDERR: [&str; 4] = ["std", "io", "stdio", "stderr"];
 pub const STDOUT: [&str; 4] = ["std", "io", "stdio", "stdout"];
 pub const STD_CONVERT_IDENTITY: [&str; 3] = ["std", "convert", "identity"];
 pub const STD_FS_CREATE_DIR: [&str; 3] = ["std", "fs", "create_dir"];
-pub const STD_MEM_TRANSMUTE: [&str; 3] = ["std", "mem", "transmute"];
-pub const STD_PTR_NULL: [&str; 3] = ["std", "ptr", "null"];
 pub const STRING_AS_MUT_STR: [&str; 4] = ["alloc", "string", "String", "as_mut_str"];
 pub const STRING_AS_STR: [&str; 4] = ["alloc", "string", "String", "as_str"];
 pub const STR_ENDS_WITH: [&str; 4] = ["core", "str", "<impl str>", "ends_with"];
-- 
cgit 1.4.1-3-g733a5


From 76bd5d232c767dbdab63005eca07a9563982e9dd Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Mon, 12 Apr 2021 18:01:32 -0500
Subject: Refactor diagnostic item methods

---
 clippy_lints/src/mem_replace.rs            | 21 ++++++++++----------
 clippy_lints/src/methods/implicit_clone.rs | 28 ++++++++++++++++----------
 clippy_lints/src/methods/mod.rs            |  7 +++----
 clippy_lints/src/misc.rs                   |  6 +++---
 clippy_lints/src/to_string_in_display.rs   |  4 ++--
 clippy_utils/src/lib.rs                    | 32 ++++++++++++++++--------------
 6 files changed, 53 insertions(+), 45 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/mem_replace.rs b/clippy_lints/src/mem_replace.rs
index 1f521ec6090..ec60bffe955 100644
--- a/clippy_lints/src/mem_replace.rs
+++ b/clippy_lints/src/mem_replace.rs
@@ -1,7 +1,6 @@
 use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::{snippet, snippet_with_applicability};
-use clippy_utils::{in_macro, match_def_path, meets_msrv, paths};
-use clippy_utils::{is_diagnostic_assoc_item, is_lang_ctor};
+use clippy_utils::{in_macro, is_diag_trait_item, is_lang_ctor, match_def_path, meets_msrv, paths};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::def_id::DefId;
@@ -211,17 +210,17 @@ fn is_default_equivalent_ctor(cx: &LateContext<'_>, def_id: DefId, path: &QPath<
         sym::BinaryHeap,
     ];
 
-    if std_types_symbols
-        .iter()
-        .any(|symbol| is_diagnostic_assoc_item(cx, def_id, *symbol))
-    {
-        if let QPath::TypeRelative(_, method) = path {
-            if method.ident.name == sym::new {
-                return true;
+    if let QPath::TypeRelative(_, method) = path {
+        if method.ident.name == sym::new {
+            if let Some(impl_did) = cx.tcx.impl_of_method(def_id) {
+                if let Some(adt) = cx.tcx.type_of(impl_did).ty_adt_def() {
+                    return std_types_symbols
+                        .iter()
+                        .any(|&symbol| cx.tcx.is_diagnostic_item(symbol, adt.did));
+                }
             }
         }
     }
-
     false
 }
 
@@ -231,7 +230,7 @@ fn check_replace_with_default(cx: &LateContext<'_>, src: &Expr<'_>, dest: &Expr<
         if !in_external_macro(cx.tcx.sess, expr_span);
         if let ExprKind::Path(ref repl_func_qpath) = repl_func.kind;
         if let Some(repl_def_id) = cx.qpath_res(repl_func_qpath, repl_func.hir_id).opt_def_id();
-        if is_diagnostic_assoc_item(cx, repl_def_id, sym::Default)
+        if is_diag_trait_item(cx, repl_def_id, sym::Default)
             || is_default_equivalent_ctor(cx, repl_def_id, repl_func_qpath);
 
         then {
diff --git a/clippy_lints/src/methods/implicit_clone.rs b/clippy_lints/src/methods/implicit_clone.rs
index 1211e2f2bf7..81c42de145f 100644
--- a/clippy_lints/src/methods/implicit_clone.rs
+++ b/clippy_lints/src/methods/implicit_clone.rs
@@ -1,28 +1,36 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::{is_diag_item_method, is_diag_trait_item};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
-use rustc_hir::ExprKind;
 use rustc_lint::LateContext;
 use rustc_middle::ty::TyS;
-use rustc_span::symbol::Symbol;
+use rustc_span::{sym, Span};
 
 use super::IMPLICIT_CLONE;
-use clippy_utils::is_diagnostic_assoc_item;
 
-pub fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, trait_diagnostic: Symbol) {
+pub fn check(cx: &LateContext<'_>, method_name: &str, expr: &hir::Expr<'_>, recv: &hir::Expr<'_>, span: Span) {
     if_chain! {
-        if let ExprKind::MethodCall(method_path, _, [arg], _) = &expr.kind;
+        if let Some(method_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
+        if match method_name {
+            "to_os_string" => is_diag_item_method(cx, method_def_id, sym::OsStr),
+            "to_owned" => is_diag_trait_item(cx, method_def_id, sym::ToOwned),
+            "to_path_buf" => is_diag_item_method(cx, method_def_id, sym::Path),
+            "to_vec" => cx.tcx.impl_of_method(method_def_id)
+                .map(|impl_did| Some(impl_did) == cx.tcx.lang_items().slice_alloc_impl())
+                == Some(true),
+            _ => false,
+        };
         let return_type = cx.typeck_results().expr_ty(expr);
-        let input_type = cx.typeck_results().expr_ty(arg).peel_refs();
-        if let Some(expr_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
+        let input_type = cx.typeck_results().expr_ty(recv).peel_refs();
         if let Some(ty_name) = input_type.ty_adt_def().map(|adt_def| cx.tcx.item_name(adt_def.did));
         if TyS::same_type(return_type, input_type);
-        if is_diagnostic_assoc_item(cx, expr_def_id, trait_diagnostic);
         then {
             span_lint_and_sugg(
-                cx,IMPLICIT_CLONE,method_path.ident.span,
-                &format!("implicitly cloning a `{}` by calling `{}` on its dereferenced type", ty_name, method_path.ident.name),
+                cx,
+                IMPLICIT_CLONE,
+                span,
+                &format!("implicitly cloning a `{}` by calling `{}` on its dereferenced type", ty_name, method_name),
                 "consider using",
                 "clone".to_string(),
                 Applicability::MachineApplicable
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index fc18849b07c..b2faaef0786 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1987,10 +1987,9 @@ fn check_methods<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, msrv: Optio
                 }
             },
             ("step_by", [arg]) => iterator_step_by_zero::check(cx, expr, arg),
-            ("to_os_string", []) => implicit_clone::check(cx, expr, sym::OsStr),
-            ("to_owned", []) => implicit_clone::check(cx, expr, sym::ToOwned),
-            ("to_path_buf", []) => implicit_clone::check(cx, expr, sym::Path),
-            ("to_vec", []) => implicit_clone::check(cx, expr, sym::slice),
+            ("to_os_string" | "to_owned" | "to_path_buf" | "to_vec", []) => {
+                implicit_clone::check(cx, name, expr, recv, span);
+            },
             ("unwrap", []) => match method_call!(recv) {
                 Some(("get", [recv, get_arg], _)) => get_unwrap::check(cx, expr, recv, get_arg, false),
                 Some(("get_mut", [recv, get_arg], _)) => get_unwrap::check(cx, expr, recv, get_arg, true),
diff --git a/clippy_lints/src/misc.rs b/clippy_lints/src/misc.rs
index afced5a5ce5..d156c1d5bf4 100644
--- a/clippy_lints/src/misc.rs
+++ b/clippy_lints/src/misc.rs
@@ -20,7 +20,7 @@ use rustc_span::symbol::sym;
 use crate::consts::{constant, Constant};
 use clippy_utils::sugg::Sugg;
 use clippy_utils::{
-    get_item_name, get_parent_expr, higher, in_constant, is_diagnostic_assoc_item, is_integer_const, iter_input_pats,
+    get_item_name, get_parent_expr, higher, in_constant, is_diag_trait_item, is_integer_const, iter_input_pats,
     last_path_segment, match_qpath, unsext, SpanlessEq,
 };
 
@@ -555,8 +555,8 @@ fn check_to_owned(cx: &LateContext<'_>, expr: &Expr<'_>, other: &Expr<'_>, left:
         ExprKind::MethodCall(.., args, _) if args.len() == 1 => {
             if_chain!(
                 if let Some(expr_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
-                if is_diagnostic_assoc_item(cx, expr_def_id, sym::ToString)
-                    || is_diagnostic_assoc_item(cx, expr_def_id, sym::ToOwned);
+                if is_diag_trait_item(cx, expr_def_id, sym::ToString)
+                    || is_diag_trait_item(cx, expr_def_id, sym::ToOwned);
                 then {
                     (cx.typeck_results().expr_ty(&args[0]), snippet(cx, args[0].span, ".."))
                 } else {
diff --git a/clippy_lints/src/to_string_in_display.rs b/clippy_lints/src/to_string_in_display.rs
index ae05a8da37b..4fb297ac6c6 100644
--- a/clippy_lints/src/to_string_in_display.rs
+++ b/clippy_lints/src/to_string_in_display.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint;
-use clippy_utils::{is_diagnostic_assoc_item, match_def_path, path_to_local_id, paths};
+use clippy_utils::{is_diag_trait_item, match_def_path, path_to_local_id, paths};
 use if_chain::if_chain;
 use rustc_hir::{Expr, ExprKind, HirId, Impl, ImplItem, ImplItemKind, Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
@@ -95,7 +95,7 @@ impl LateLintPass<'_> for ToStringInDisplay {
             if let ExprKind::MethodCall(path, _, args, _) = expr.kind;
             if path.ident.name == sym!(to_string);
             if let Some(expr_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
-            if is_diagnostic_assoc_item(cx, expr_def_id, sym::ToString);
+            if is_diag_trait_item(cx, expr_def_id, sym::ToString);
             if path_to_local_id(&args[0], self_hir_id);
             then {
                 span_lint(
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index e99ffbe269b..ec140463a8a 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -293,27 +293,29 @@ pub fn match_trait_method(cx: &LateContext<'_>, expr: &Expr<'_>, path: &[&str])
     trt_id.map_or(false, |trt_id| match_def_path(cx, trt_id, path))
 }
 
-/// Checks if the method call given in `def_id` belongs to a trait or other container with a given
-/// diagnostic item
-pub fn is_diagnostic_assoc_item(cx: &LateContext<'_>, def_id: DefId, diag_item: Symbol) -> bool {
-    cx.tcx
-        .opt_associated_item(def_id)
-        .and_then(|associated_item| match associated_item.container {
-            rustc_ty::TraitContainer(assoc_def_id) => Some(assoc_def_id),
-            rustc_ty::ImplContainer(assoc_def_id) => match cx.tcx.type_of(assoc_def_id).kind() {
-                rustc_ty::Adt(adt, _) => Some(adt.did),
-                rustc_ty::Slice(_) => cx.tcx.get_diagnostic_item(sym::slice), // this isn't perfect but it works
-                _ => None,
-            },
-        })
-        .map_or(false, |assoc_def_id| cx.tcx.is_diagnostic_item(diag_item, assoc_def_id))
+/// Checks if a method is defined in an impl of a diagnostic item
+pub fn is_diag_item_method(cx: &LateContext<'_>, def_id: DefId, diag_item: Symbol) -> bool {
+    if let Some(impl_did) = cx.tcx.impl_of_method(def_id) {
+        if let Some(adt) = cx.tcx.type_of(impl_did).ty_adt_def() {
+            return cx.tcx.is_diagnostic_item(diag_item, adt.did);
+        }
+    }
+    false
+}
+
+/// Checks if a method is in a diagnostic item trait
+pub fn is_diag_trait_item(cx: &LateContext<'_>, def_id: DefId, diag_item: Symbol) -> bool {
+    if let Some(trait_did) = cx.tcx.trait_of_item(def_id) {
+        return cx.tcx.is_diagnostic_item(diag_item, trait_did);
+    }
+    false
 }
 
 /// Checks if the method call given in `expr` belongs to the given trait.
 pub fn is_trait_method(cx: &LateContext<'_>, expr: &Expr<'_>, diag_item: Symbol) -> bool {
     cx.typeck_results()
         .type_dependent_def_id(expr.hir_id)
-        .map_or(false, |did| is_diagnostic_assoc_item(cx, did, diag_item))
+        .map_or(false, |did| is_diag_trait_item(cx, did, diag_item))
 }
 
 /// Checks if an expression references a variable of the given name.
-- 
cgit 1.4.1-3-g733a5


From 26a1989041393116c001f17d0323d6b4fc989dd9 Mon Sep 17 00:00:00 2001
From: rail <12975677+rail-rain@users.noreply.github.com>
Date: Tue, 13 Apr 2021 17:13:49 +1200
Subject: Fix a FP in `missing_const_for_fn`

where a function that calls a standard library function whose constness
is unstable is considered as being able to be a const function
---
 clippy_lints/src/missing_const_for_fn.rs           |  2 +-
 clippy_utils/src/lib.rs                            |  1 +
 clippy_utils/src/qualify_min_const_fn.rs           | 40 +++++++++++++++++++---
 tests/ui/missing_const_for_fn/auxiliary/helper.rs  |  8 +++++
 tests/ui/missing_const_for_fn/cant_be_const.rs     | 19 ++++++++++
 tests/ui/missing_const_for_fn/could_be_const.rs    | 10 ++++++
 .../ui/missing_const_for_fn/could_be_const.stderr  | 26 +++++++++-----
 7 files changed, 92 insertions(+), 14 deletions(-)
 create mode 100644 tests/ui/missing_const_for_fn/auxiliary/helper.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/missing_const_for_fn.rs b/clippy_lints/src/missing_const_for_fn.rs
index 0dc02431ad5..93b7a897405 100644
--- a/clippy_lints/src/missing_const_for_fn.rs
+++ b/clippy_lints/src/missing_const_for_fn.rs
@@ -138,7 +138,7 @@ impl<'tcx> LateLintPass<'tcx> for MissingConstForFn {
 
         let mir = cx.tcx.optimized_mir(def_id);
 
-        if let Err((span, err)) = is_min_const_fn(cx.tcx, mir) {
+        if let Err((span, err)) = is_min_const_fn(cx.tcx, mir, self.msrv.as_ref()) {
             if rustc_mir::const_eval::is_min_const_fn(cx.tcx, def_id.to_def_id()) {
                 cx.tcx.sess.span_err(span, &err);
             }
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index e99ffbe269b..8c20f8a0fbc 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -9,6 +9,7 @@
 // (Currently there is no way to opt into sysroot crates without `extern crate`.)
 extern crate rustc_ast;
 extern crate rustc_ast_pretty;
+extern crate rustc_attr;
 extern crate rustc_data_structures;
 extern crate rustc_errors;
 extern crate rustc_hir;
diff --git a/clippy_utils/src/qualify_min_const_fn.rs b/clippy_utils/src/qualify_min_const_fn.rs
index b52cbf31e35..b2ce58b597b 100644
--- a/clippy_utils/src/qualify_min_const_fn.rs
+++ b/clippy_utils/src/qualify_min_const_fn.rs
@@ -1,3 +1,8 @@
+// This code used to be a part of `rustc` but moved to Clippy as a result of
+// https://github.com/rust-lang/rust/issues/76618. Because of that, it contains unused code and some
+// of terminologies might not be relevant in the context of Clippy. Note that its behavior might
+// differ from the time of `rustc` even if the name stays the same.
+
 use rustc_hir as hir;
 use rustc_hir::def_id::DefId;
 use rustc_middle::mir::{
@@ -6,6 +11,7 @@ use rustc_middle::mir::{
 };
 use rustc_middle::ty::subst::GenericArgKind;
 use rustc_middle::ty::{self, adjustment::PointerCast, Ty, TyCtxt};
+use rustc_semver::RustcVersion;
 use rustc_span::symbol::sym;
 use rustc_span::Span;
 use rustc_target::spec::abi::Abi::RustIntrinsic;
@@ -13,7 +19,7 @@ use std::borrow::Cow;
 
 type McfResult = Result<(), (Span, Cow<'static, str>)>;
 
-pub fn is_min_const_fn(tcx: TyCtxt<'tcx>, body: &'a Body<'tcx>) -> McfResult {
+pub fn is_min_const_fn(tcx: TyCtxt<'tcx>, body: &'a Body<'tcx>, msrv: Option<&RustcVersion>) -> McfResult {
     let def_id = body.source.def_id();
     let mut current = def_id;
     loop {
@@ -70,7 +76,7 @@ pub fn is_min_const_fn(tcx: TyCtxt<'tcx>, body: &'a Body<'tcx>) -> McfResult {
     )?;
 
     for bb in body.basic_blocks() {
-        check_terminator(tcx, body, bb.terminator())?;
+        check_terminator(tcx, body, bb.terminator(), msrv)?;
         for stmt in &bb.statements {
             check_statement(tcx, body, def_id, stmt)?;
         }
@@ -268,7 +274,12 @@ fn check_place(tcx: TyCtxt<'tcx>, place: Place<'tcx>, span: Span, body: &Body<'t
     Ok(())
 }
 
-fn check_terminator(tcx: TyCtxt<'tcx>, body: &'a Body<'tcx>, terminator: &Terminator<'tcx>) -> McfResult {
+fn check_terminator(
+    tcx: TyCtxt<'tcx>,
+    body: &'a Body<'tcx>,
+    terminator: &Terminator<'tcx>,
+    msrv: Option<&RustcVersion>,
+) -> McfResult {
     let span = terminator.source_info.span;
     match &terminator.kind {
         TerminatorKind::FalseEdge { .. }
@@ -305,7 +316,7 @@ fn check_terminator(tcx: TyCtxt<'tcx>, body: &'a Body<'tcx>, terminator: &Termin
         } => {
             let fn_ty = func.ty(body, tcx);
             if let ty::FnDef(fn_def_id, _) = *fn_ty.kind() {
-                if !rustc_mir::const_eval::is_min_const_fn(tcx, fn_def_id) {
+                if !is_const_fn(tcx, fn_def_id, msrv) {
                     return Err((
                         span,
                         format!(
@@ -350,3 +361,24 @@ fn check_terminator(tcx: TyCtxt<'tcx>, body: &'a Body<'tcx>, terminator: &Termin
         TerminatorKind::InlineAsm { .. } => Err((span, "cannot use inline assembly in const fn".into())),
     }
 }
+
+fn is_const_fn(tcx: TyCtxt<'_>, def_id: DefId, msrv: Option<&RustcVersion>) -> bool {
+    rustc_mir::const_eval::is_const_fn(tcx, def_id)
+        && if let Some(const_stab) = tcx.lookup_const_stability(def_id) {
+            if let rustc_attr::StabilityLevel::Stable { since } = const_stab.level {
+                // Checking MSRV is manually necessary because `rustc` has no such concept. This entire
+                // function could be removed if `rustc` provided a MSRV-aware version of `is_const_fn`.
+                // as a part of an unimplemented MSRV check https://github.com/rust-lang/rust/issues/65262.
+                crate::meets_msrv(
+                    msrv,
+                    &RustcVersion::parse(&since.as_str())
+                        .expect("`rustc_attr::StabilityLevel::Stable::since` is ill-formatted"),
+                )
+            } else {
+                // `rustc_mir::const_eval::is_const_fn` should return false for unstably const functions.
+                unreachable!();
+            }
+        } else {
+            true
+        }
+}
diff --git a/tests/ui/missing_const_for_fn/auxiliary/helper.rs b/tests/ui/missing_const_for_fn/auxiliary/helper.rs
new file mode 100644
index 00000000000..7b9dc76b8f1
--- /dev/null
+++ b/tests/ui/missing_const_for_fn/auxiliary/helper.rs
@@ -0,0 +1,8 @@
+// This file provides a const function that is unstably const forever.
+
+#![feature(staged_api)]
+#![stable(feature = "1", since = "1.0.0")]
+
+#[stable(feature = "1", since = "1.0.0")]
+#[rustc_const_unstable(feature = "foo", issue = "none")]
+pub const fn unstably_const_fn() {}
diff --git a/tests/ui/missing_const_for_fn/cant_be_const.rs b/tests/ui/missing_const_for_fn/cant_be_const.rs
index ba352ef9ee9..7cda1aaa3c2 100644
--- a/tests/ui/missing_const_for_fn/cant_be_const.rs
+++ b/tests/ui/missing_const_for_fn/cant_be_const.rs
@@ -2,9 +2,14 @@
 //! compilation error.
 //! The .stderr output of this test should be empty. Otherwise it's a bug somewhere.
 
+// aux-build:helper.rs
+
 #![warn(clippy::missing_const_for_fn)]
 #![allow(incomplete_features)]
 #![feature(start, const_generics)]
+#![feature(custom_inner_attributes)]
+
+extern crate helper;
 
 struct Game;
 
@@ -101,3 +106,17 @@ fn const_generic_return<T, const N: usize>(t: &[T]) -> &[T; N] {
 
     unsafe { &*p }
 }
+
+// Do not lint this because it calls a function whose constness is unstable.
+fn unstably_const_fn() {
+    helper::unstably_const_fn()
+}
+
+mod const_fn_stabilized_after_msrv {
+    #![clippy::msrv = "1.46.0"]
+
+    // Do not lint this because `u8::is_ascii_digit` is stabilized as a const function in 1.47.0.
+    fn const_fn_stabilized_after_msrv(byte: u8) {
+        byte.is_ascii_digit();
+    }
+}
diff --git a/tests/ui/missing_const_for_fn/could_be_const.rs b/tests/ui/missing_const_for_fn/could_be_const.rs
index c6f44b7daa3..0accb516f5f 100644
--- a/tests/ui/missing_const_for_fn/could_be_const.rs
+++ b/tests/ui/missing_const_for_fn/could_be_const.rs
@@ -1,6 +1,7 @@
 #![warn(clippy::missing_const_for_fn)]
 #![allow(incomplete_features, clippy::let_and_return)]
 #![feature(const_generics)]
+#![feature(custom_inner_attributes)]
 
 use std::mem::transmute;
 
@@ -70,5 +71,14 @@ mod with_drop {
     }
 }
 
+mod const_fn_stabilized_before_msrv {
+    #![clippy::msrv = "1.47.0"]
+
+    // This could be const because `u8::is_ascii_digit` is a stable const function in 1.47.
+    fn const_fn_stabilized_before_msrv(byte: u8) {
+        byte.is_ascii_digit();
+    }
+}
+
 // Should not be const
 fn main() {}
diff --git a/tests/ui/missing_const_for_fn/could_be_const.stderr b/tests/ui/missing_const_for_fn/could_be_const.stderr
index 74d32b8a1aa..63c211f39fa 100644
--- a/tests/ui/missing_const_for_fn/could_be_const.stderr
+++ b/tests/ui/missing_const_for_fn/could_be_const.stderr
@@ -1,5 +1,5 @@
 error: this could be a `const fn`
-  --> $DIR/could_be_const.rs:13:5
+  --> $DIR/could_be_const.rs:14:5
    |
 LL | /     pub fn new() -> Self {
 LL | |         Self { guess: 42 }
@@ -9,7 +9,7 @@ LL | |     }
    = note: `-D clippy::missing-const-for-fn` implied by `-D warnings`
 
 error: this could be a `const fn`
-  --> $DIR/could_be_const.rs:17:5
+  --> $DIR/could_be_const.rs:18:5
    |
 LL | /     fn const_generic_params<'a, T, const N: usize>(&self, b: &'a [T; N]) -> &'a [T; N] {
 LL | |         b
@@ -17,7 +17,7 @@ LL | |     }
    | |_____^
 
 error: this could be a `const fn`
-  --> $DIR/could_be_const.rs:23:1
+  --> $DIR/could_be_const.rs:24:1
    |
 LL | / fn one() -> i32 {
 LL | |     1
@@ -25,7 +25,7 @@ LL | | }
    | |_^
 
 error: this could be a `const fn`
-  --> $DIR/could_be_const.rs:28:1
+  --> $DIR/could_be_const.rs:29:1
    |
 LL | / fn two() -> i32 {
 LL | |     let abc = 2;
@@ -34,7 +34,7 @@ LL | | }
    | |_^
 
 error: this could be a `const fn`
-  --> $DIR/could_be_const.rs:34:1
+  --> $DIR/could_be_const.rs:35:1
    |
 LL | / fn string() -> String {
 LL | |     String::new()
@@ -42,7 +42,7 @@ LL | | }
    | |_^
 
 error: this could be a `const fn`
-  --> $DIR/could_be_const.rs:39:1
+  --> $DIR/could_be_const.rs:40:1
    |
 LL | / unsafe fn four() -> i32 {
 LL | |     4
@@ -50,7 +50,7 @@ LL | | }
    | |_^
 
 error: this could be a `const fn`
-  --> $DIR/could_be_const.rs:44:1
+  --> $DIR/could_be_const.rs:45:1
    |
 LL | / fn generic<T>(t: T) -> T {
 LL | |     t
@@ -58,12 +58,20 @@ LL | | }
    | |_^
 
 error: this could be a `const fn`
-  --> $DIR/could_be_const.rs:67:9
+  --> $DIR/could_be_const.rs:68:9
    |
 LL | /         pub fn b(self, a: &A) -> B {
 LL | |             B
 LL | |         }
    | |_________^
 
-error: aborting due to 8 previous errors
+error: this could be a `const fn`
+  --> $DIR/could_be_const.rs:78:5
+   |
+LL | /     fn const_fn_stabilized_before_msrv(byte: u8) {
+LL | |         byte.is_ascii_digit();
+LL | |     }
+   | |_____^
+
+error: aborting due to 9 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From cbdebd97ec4846391dc0f9a1288a3ab1fc053f99 Mon Sep 17 00:00:00 2001
From: Philipp Hansch <dev@phansch.net>
Date: Wed, 14 Apr 2021 06:30:51 +0200
Subject: Explain why we use `char_indices()` instead of `chars()`

---
 clippy_lints/src/tabs_in_doc_comments.rs | 3 +++
 1 file changed, 3 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/tabs_in_doc_comments.rs b/clippy_lints/src/tabs_in_doc_comments.rs
index 51581b75ce3..1995981b905 100644
--- a/clippy_lints/src/tabs_in_doc_comments.rs
+++ b/clippy_lints/src/tabs_in_doc_comments.rs
@@ -104,6 +104,9 @@ fn get_chunks_of_tabs(the_str: &str) -> Vec<(u32, u32)> {
     // tracker to decide if the last group of tabs is not closed by a non-tab character
     let mut is_active = false;
 
+    // Note that we specifically need the char _byte_ indices here, not the positional indexes
+    // within the char array to deal with multi-byte characters properly. `char_indices` does
+    // exactly that. It provides an iterator over tuples of the form `(byte position, char)`.
     let char_indices: Vec<_> = the_str.char_indices().collect();
 
     if let [(_, '\t')] = char_indices.as_slice() {
-- 
cgit 1.4.1-3-g733a5


From cbde4f2c67667c717adecf3fac9df84954154fe0 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Sat, 10 Apr 2021 14:45:51 +0200
Subject: parent_node_is_if_expr now also recognizes if let as parent if

---
 clippy_lints/src/copies.rs                         |  7 +++++
 clippy_utils/src/lib.rs                            | 30 +++++++++++++++++-----
 tests/ui/branches_sharing_code/shared_at_bottom.rs | 14 ++++++++++
 3 files changed, 44 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/copies.rs b/clippy_lints/src/copies.rs
index 8b503c9a030..dfc79ac365b 100644
--- a/clippy_lints/src/copies.rs
+++ b/clippy_lints/src/copies.rs
@@ -290,6 +290,13 @@ fn lint_same_then_else<'tcx>(
     }
 }
 
+/// The return tuple is structured as follows:
+/// 1. The amount of equal statements from the start
+/// 2. The amount of equal statements from the end
+/// 3. An indication if the block expressions are the same. This will also be true if both are `None`
+///
+/// This function can also trigger the `IF_SAME_THEN_ELSE` in which case it'll return `(0, 0, false)`
+/// to aboard any further processing and avoid duplicate lint triggers.
 fn scan_block_for_eq(cx: &LateContext<'tcx>, blocks: &[&Block<'tcx>]) -> (usize, usize, bool) {
     let mut start_eq = usize::MAX;
     let mut end_eq = usize::MAX;
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 8e1a2105b96..1ef5d9d32c5 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -1212,13 +1212,29 @@ pub fn parent_node_is_if_expr(expr: &Expr<'_>, cx: &LateContext<'_>) -> bool {
     let map = cx.tcx.hir();
     let parent_id = map.get_parent_node(expr.hir_id);
     let parent_node = map.get(parent_id);
-    matches!(
-        parent_node,
-        Node::Expr(Expr {
-            kind: ExprKind::If(_, _, _),
-            ..
-        })
-    )
+    
+    // Check for `if`
+    if_chain! {
+        if let Node::Expr(expr) = parent_node;
+        if let ExprKind::If(_, _, _) = expr.kind;
+        then {
+            return true;
+        }
+    }
+
+    // Check for `if let`
+    if_chain! {
+        if let Node::Arm(arm) = parent_node;
+        let arm_parent_id = map.get_parent_node(arm.hir_id);
+        let arm_parent_node = map.get(arm_parent_id);
+        if let Node::Expr(expr) = arm_parent_node;
+        if let ExprKind::Match(_, _, MatchSource::IfLetDesugar { .. }) = expr.kind;
+        then {
+            return true;
+        }
+    }
+
+    false
 }
 
 // Finds the `#[must_use]` attribute, if any
diff --git a/tests/ui/branches_sharing_code/shared_at_bottom.rs b/tests/ui/branches_sharing_code/shared_at_bottom.rs
index c389c243d44..ce2040bdeb8 100644
--- a/tests/ui/branches_sharing_code/shared_at_bottom.rs
+++ b/tests/ui/branches_sharing_code/shared_at_bottom.rs
@@ -206,4 +206,18 @@ fn fp_test() {
     }
 }
 
+fn fp_if_let_issue7054() {
+    // This shouldn't trigger the lint
+    let string;
+    let _x = if let true = true {
+        ""
+    } else if true {
+        string = "x".to_owned();
+        &string
+    } else {
+        string = "y".to_owned();
+        &string
+    };
+}
+
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 2992b19c82c0c5f96327b3be037777bf42862230 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Tue, 13 Apr 2021 22:55:47 +0200
Subject: Added inferred local type comparion to SpanlessEq

---
 clippy_lints/src/copies.rs                      |  9 ++---
 clippy_utils/src/hir_utils.rs                   | 48 +++++++++++++++++++++++++
 clippy_utils/src/lib.rs                         |  2 +-
 tests/ui/branches_sharing_code/shared_at_top.rs | 11 ++++++
 4 files changed, 65 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/copies.rs b/clippy_lints/src/copies.rs
index dfc79ac365b..34ea014dd67 100644
--- a/clippy_lints/src/copies.rs
+++ b/clippy_lints/src/copies.rs
@@ -293,10 +293,11 @@ fn lint_same_then_else<'tcx>(
 /// The return tuple is structured as follows:
 /// 1. The amount of equal statements from the start
 /// 2. The amount of equal statements from the end
-/// 3. An indication if the block expressions are the same. This will also be true if both are `None`
+/// 3. An indication if the block expressions are the same. This will also be true if both are
+/// `None`
 ///
-/// This function can also trigger the `IF_SAME_THEN_ELSE` in which case it'll return `(0, 0, false)`
-/// to aboard any further processing and avoid duplicate lint triggers.
+/// This function can also trigger the `IF_SAME_THEN_ELSE` in which case it'll return `(0, 0,
+/// false)` to aboard any further processing and avoid duplicate lint triggers.
 fn scan_block_for_eq(cx: &LateContext<'tcx>, blocks: &[&Block<'tcx>]) -> (usize, usize, bool) {
     let mut start_eq = usize::MAX;
     let mut end_eq = usize::MAX;
@@ -307,7 +308,7 @@ fn scan_block_for_eq(cx: &LateContext<'tcx>, blocks: &[&Block<'tcx>]) -> (usize,
 
         // `SpanlessEq` now keeps track of the locals and is therefore context sensitive clippy#6752.
         // The comparison therefore needs to be done in a way that builds the correct context.
-        let mut evaluator = SpanlessEq::new(cx);
+        let mut evaluator = SpanlessEq::new(cx).enable_check_inferred_local_types();
         let mut evaluator = evaluator.inter_expr();
 
         let current_start_eq = count_eq(&mut l_stmts.iter(), &mut r_stmts.iter(), |l, r| evaluator.eq_stmt(l, r));
diff --git a/clippy_utils/src/hir_utils.rs b/clippy_utils/src/hir_utils.rs
index f695f1a61e7..97db58ae12b 100644
--- a/clippy_utils/src/hir_utils.rs
+++ b/clippy_utils/src/hir_utils.rs
@@ -1,6 +1,7 @@
 use crate::consts::{constant_context, constant_simple};
 use crate::differing_macro_contexts;
 use crate::source::snippet_opt;
+use if_chain::if_chain;
 use rustc_ast::ast::InlineAsmTemplatePiece;
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
 use rustc_hir::def::Res;
@@ -29,6 +30,30 @@ pub struct SpanlessEq<'a, 'tcx> {
     maybe_typeck_results: Option<&'tcx TypeckResults<'tcx>>,
     allow_side_effects: bool,
     expr_fallback: Option<Box<dyn FnMut(&Expr<'_>, &Expr<'_>) -> bool + 'a>>,
+    /// This adds an additional type comparison to locals that insures that even the
+    /// inferred of the value is the same.
+    ///
+    /// **Example**
+    /// * Context 1
+    /// ```ignore
+    /// let vec = Vec::new();
+    /// vec.push("A string");
+    /// ```
+    ///
+    /// * Context 2
+    /// ```ignore
+    /// let vec = Vec::new();
+    /// vec.push(0); // An integer
+    /// ```
+    ///
+    /// Only comparing the first local definition would usually return that they are
+    /// equal, since they are identical. However, they are different due to the context
+    /// as they have different inferred types.
+    ///
+    /// This option enables or disables the specific check of the inferred type.
+    ///
+    /// Note: This check will only be done if `self.maybe_typeck_results` is `Some()`.
+    check_inferred_local_types: bool,
 }
 
 impl<'a, 'tcx> SpanlessEq<'a, 'tcx> {
@@ -38,6 +63,7 @@ impl<'a, 'tcx> SpanlessEq<'a, 'tcx> {
             maybe_typeck_results: cx.maybe_typeck_results(),
             allow_side_effects: true,
             expr_fallback: None,
+            check_inferred_local_types: false,
         }
     }
 
@@ -56,6 +82,13 @@ impl<'a, 'tcx> SpanlessEq<'a, 'tcx> {
         }
     }
 
+    pub fn enable_check_inferred_local_types(self) -> Self {
+        Self {
+            check_inferred_local_types: true,
+            ..self
+        }
+    }
+
     /// Use this method to wrap comparisons that may involve inter-expression context.
     /// See `self.locals`.
     pub fn inter_expr(&mut self) -> HirEqInterExpr<'_, 'a, 'tcx> {
@@ -96,6 +129,21 @@ impl HirEqInterExpr<'_, '_, '_> {
     pub fn eq_stmt(&mut self, left: &Stmt<'_>, right: &Stmt<'_>) -> bool {
         match (&left.kind, &right.kind) {
             (&StmtKind::Local(ref l), &StmtKind::Local(ref r)) => {
+                // See `SpanlessEq::check_inferred_local_types` for an explication of this check
+                if_chain! {
+                    if l.ty.is_none() && r.ty.is_none();
+                    if self.inner.check_inferred_local_types;
+                    if let Some(tcx) = self.inner.maybe_typeck_results;
+
+                    // Check the inferred types
+                    let l_ty = tcx.pat_ty(&l.pat);
+                    let r_ty = tcx.pat_ty(&r.pat);
+                    if l_ty != r_ty;
+                    then {
+                        return false;
+                    }
+                }
+
                 // eq_pat adds the HirIds to the locals map. We therefor call it last to make sure that
                 // these only get added if the init and type is equal.
                 both(&l.init, &r.init, |l, r| self.eq_expr(l, r))
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 1ef5d9d32c5..280bde73ed7 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -1212,7 +1212,7 @@ pub fn parent_node_is_if_expr(expr: &Expr<'_>, cx: &LateContext<'_>) -> bool {
     let map = cx.tcx.hir();
     let parent_id = map.get_parent_node(expr.hir_id);
     let parent_node = map.get(parent_id);
-    
+
     // Check for `if`
     if_chain! {
         if let Node::Expr(expr) = parent_node;
diff --git a/tests/ui/branches_sharing_code/shared_at_top.rs b/tests/ui/branches_sharing_code/shared_at_top.rs
index e65bcfd7873..51a46481399 100644
--- a/tests/ui/branches_sharing_code/shared_at_top.rs
+++ b/tests/ui/branches_sharing_code/shared_at_top.rs
@@ -100,4 +100,15 @@ fn check_if_same_than_else_mask() {
     }
 }
 
+#[allow(clippy::vec_init_then_push)]
+fn pf_local_with_inferred_type_issue7053() {
+    if true {
+        let mut v = Vec::new();
+        v.push(0);
+    } else {
+        let mut v = Vec::new();
+        v.push("");
+    };
+}
+
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 0b4af7257ddea5cf508305635fbdc4c0d1e6bdd5 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Wed, 14 Apr 2021 19:40:51 +0200
Subject: PR suggestions and removing utils::parent_node_is_if_expr

---
 clippy_lints/src/comparison_chain.rs       |  4 +--
 clippy_lints/src/copies.rs                 | 43 ++++++++++++++++---------
 clippy_lints/src/if_then_some_else_none.rs |  4 +--
 clippy_lints/src/needless_bool.rs          |  4 +--
 clippy_utils/src/hir_utils.rs              | 50 ++++--------------------------
 clippy_utils/src/lib.rs                    | 31 ------------------
 6 files changed, 40 insertions(+), 96 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/comparison_chain.rs b/clippy_lints/src/comparison_chain.rs
index 31ae63b5184..42e153909ce 100644
--- a/clippy_lints/src/comparison_chain.rs
+++ b/clippy_lints/src/comparison_chain.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::ty::implements_trait;
-use clippy_utils::{get_trait_def_id, if_sequence, parent_node_is_if_expr, paths, SpanlessEq};
+use clippy_utils::{get_trait_def_id, if_sequence, is_else_clause, paths, SpanlessEq};
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -60,7 +60,7 @@ impl<'tcx> LateLintPass<'tcx> for ComparisonChain {
         }
 
         // We only care about the top-most `if` in the chain
-        if parent_node_is_if_expr(expr, cx) {
+        if is_else_clause(cx.tcx, expr) {
             return;
         }
 
diff --git a/clippy_lints/src/copies.rs b/clippy_lints/src/copies.rs
index 34ea014dd67..f956d171bfb 100644
--- a/clippy_lints/src/copies.rs
+++ b/clippy_lints/src/copies.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::{span_lint_and_note, span_lint_and_then};
 use clippy_utils::source::{first_line_of_span, indent_of, reindent_multiline, snippet, snippet_opt};
 use clippy_utils::{
-    both, count_eq, eq_expr_value, get_enclosing_block, get_parent_expr, if_sequence, in_macro, parent_node_is_if_expr,
+    both, count_eq, eq_expr_value, get_enclosing_block, get_parent_expr, if_sequence, in_macro, is_else_clause,
     run_lints, search_same, ContainsName, SpanlessEq, SpanlessHash,
 };
 use if_chain::if_chain;
@@ -188,13 +188,18 @@ fn lint_same_then_else<'tcx>(
     expr: &'tcx Expr<'_>,
 ) {
     // We only lint ifs with multiple blocks
-    if blocks.len() < 2 || parent_node_is_if_expr(expr, cx) {
+    if blocks.len() < 2 || is_else_clause(cx.tcx, expr) {
         return;
     }
 
     // Check if each block has shared code
     let has_expr = blocks[0].expr.is_some();
-    let (start_eq, mut end_eq, expr_eq) = scan_block_for_eq(cx, blocks);
+
+    let (start_eq, mut end_eq, expr_eq) = if let Some(block_eq) = scan_block_for_eq(cx, blocks) {
+        (block_eq.start_eq, block_eq.end_eq, block_eq.expr_eq)
+    } else {
+        return;
+    };
 
     // BRANCHES_SHARING_CODE prerequisites
     if has_conditional_else || (start_eq == 0 && end_eq == 0 && (has_expr && !expr_eq)) {
@@ -290,15 +295,19 @@ fn lint_same_then_else<'tcx>(
     }
 }
 
-/// The return tuple is structured as follows:
-/// 1. The amount of equal statements from the start
-/// 2. The amount of equal statements from the end
-/// 3. An indication if the block expressions are the same. This will also be true if both are
-/// `None`
-///
-/// This function can also trigger the `IF_SAME_THEN_ELSE` in which case it'll return `(0, 0,
-/// false)` to aboard any further processing and avoid duplicate lint triggers.
-fn scan_block_for_eq(cx: &LateContext<'tcx>, blocks: &[&Block<'tcx>]) -> (usize, usize, bool) {
+struct BlockEqual {
+    /// The amount statements that are equal from the start
+    start_eq: usize,
+    /// The amount statements that are equal from the end
+    end_eq: usize,
+    ///  An indication if the block expressions are the same. This will also be true if both are
+    /// `None`
+    expr_eq: bool,
+}
+
+/// This function can also trigger the `IF_SAME_THEN_ELSE` in which case it'll return `None` to
+/// abort any further processing and avoid duplicate lint triggers.
+fn scan_block_for_eq(cx: &LateContext<'tcx>, blocks: &[&Block<'tcx>]) -> Option<BlockEqual> {
     let mut start_eq = usize::MAX;
     let mut end_eq = usize::MAX;
     let mut expr_eq = true;
@@ -308,7 +317,7 @@ fn scan_block_for_eq(cx: &LateContext<'tcx>, blocks: &[&Block<'tcx>]) -> (usize,
 
         // `SpanlessEq` now keeps track of the locals and is therefore context sensitive clippy#6752.
         // The comparison therefore needs to be done in a way that builds the correct context.
-        let mut evaluator = SpanlessEq::new(cx).enable_check_inferred_local_types();
+        let mut evaluator = SpanlessEq::new(cx);
         let mut evaluator = evaluator.inter_expr();
 
         let current_start_eq = count_eq(&mut l_stmts.iter(), &mut r_stmts.iter(), |l, r| evaluator.eq_stmt(l, r));
@@ -340,7 +349,7 @@ fn scan_block_for_eq(cx: &LateContext<'tcx>, blocks: &[&Block<'tcx>]) -> (usize,
                     "same as this",
                 );
 
-                return (0, 0, false);
+                return None;
             }
         }
 
@@ -360,7 +369,11 @@ fn scan_block_for_eq(cx: &LateContext<'tcx>, blocks: &[&Block<'tcx>]) -> (usize,
         end_eq = min_block_size - start_eq;
     }
 
-    (start_eq, end_eq, expr_eq)
+    Some(BlockEqual {
+        start_eq,
+        end_eq,
+        expr_eq,
+    })
 }
 
 fn check_for_warn_of_moved_symbol(
diff --git a/clippy_lints/src/if_then_some_else_none.rs b/clippy_lints/src/if_then_some_else_none.rs
index f73b3a1fe67..85c95f1151f 100644
--- a/clippy_lints/src/if_then_some_else_none.rs
+++ b/clippy_lints/src/if_then_some_else_none.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::source::snippet_with_macro_callsite;
-use clippy_utils::{is_lang_ctor, meets_msrv, parent_node_is_if_expr};
+use clippy_utils::{is_else_clause, is_lang_ctor, meets_msrv};
 use if_chain::if_chain;
 use rustc_hir::LangItem::{OptionNone, OptionSome};
 use rustc_hir::{Expr, ExprKind};
@@ -68,7 +68,7 @@ impl LateLintPass<'_> for IfThenSomeElseNone {
         }
 
         // We only care about the top-most `if` in the chain
-        if parent_node_is_if_expr(expr, cx) {
+        if is_else_clause(cx.tcx, expr) {
             return;
         }
 
diff --git a/clippy_lints/src/needless_bool.rs b/clippy_lints/src/needless_bool.rs
index 96a58d1410f..dd458198637 100644
--- a/clippy_lints/src/needless_bool.rs
+++ b/clippy_lints/src/needless_bool.rs
@@ -5,7 +5,7 @@
 use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg};
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::sugg::Sugg;
-use clippy_utils::{is_expn_of, parent_node_is_if_expr};
+use clippy_utils::{is_else_clause, is_expn_of};
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Block, Expr, ExprKind, StmtKind, UnOp};
@@ -81,7 +81,7 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessBool {
                     snip = snip.make_return();
                 }
 
-                if parent_node_is_if_expr(e, cx) {
+                if is_else_clause(cx.tcx, e) {
                     snip = snip.blockify()
                 }
 
diff --git a/clippy_utils/src/hir_utils.rs b/clippy_utils/src/hir_utils.rs
index 97db58ae12b..f0d7f76bea2 100644
--- a/clippy_utils/src/hir_utils.rs
+++ b/clippy_utils/src/hir_utils.rs
@@ -1,7 +1,6 @@
 use crate::consts::{constant_context, constant_simple};
 use crate::differing_macro_contexts;
 use crate::source::snippet_opt;
-use if_chain::if_chain;
 use rustc_ast::ast::InlineAsmTemplatePiece;
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
 use rustc_hir::def::Res;
@@ -30,30 +29,6 @@ pub struct SpanlessEq<'a, 'tcx> {
     maybe_typeck_results: Option<&'tcx TypeckResults<'tcx>>,
     allow_side_effects: bool,
     expr_fallback: Option<Box<dyn FnMut(&Expr<'_>, &Expr<'_>) -> bool + 'a>>,
-    /// This adds an additional type comparison to locals that insures that even the
-    /// inferred of the value is the same.
-    ///
-    /// **Example**
-    /// * Context 1
-    /// ```ignore
-    /// let vec = Vec::new();
-    /// vec.push("A string");
-    /// ```
-    ///
-    /// * Context 2
-    /// ```ignore
-    /// let vec = Vec::new();
-    /// vec.push(0); // An integer
-    /// ```
-    ///
-    /// Only comparing the first local definition would usually return that they are
-    /// equal, since they are identical. However, they are different due to the context
-    /// as they have different inferred types.
-    ///
-    /// This option enables or disables the specific check of the inferred type.
-    ///
-    /// Note: This check will only be done if `self.maybe_typeck_results` is `Some()`.
-    check_inferred_local_types: bool,
 }
 
 impl<'a, 'tcx> SpanlessEq<'a, 'tcx> {
@@ -63,7 +38,6 @@ impl<'a, 'tcx> SpanlessEq<'a, 'tcx> {
             maybe_typeck_results: cx.maybe_typeck_results(),
             allow_side_effects: true,
             expr_fallback: None,
-            check_inferred_local_types: false,
         }
     }
 
@@ -82,13 +56,6 @@ impl<'a, 'tcx> SpanlessEq<'a, 'tcx> {
         }
     }
 
-    pub fn enable_check_inferred_local_types(self) -> Self {
-        Self {
-            check_inferred_local_types: true,
-            ..self
-        }
-    }
-
     /// Use this method to wrap comparisons that may involve inter-expression context.
     /// See `self.locals`.
     pub fn inter_expr(&mut self) -> HirEqInterExpr<'_, 'a, 'tcx> {
@@ -129,17 +96,12 @@ impl HirEqInterExpr<'_, '_, '_> {
     pub fn eq_stmt(&mut self, left: &Stmt<'_>, right: &Stmt<'_>) -> bool {
         match (&left.kind, &right.kind) {
             (&StmtKind::Local(ref l), &StmtKind::Local(ref r)) => {
-                // See `SpanlessEq::check_inferred_local_types` for an explication of this check
-                if_chain! {
-                    if l.ty.is_none() && r.ty.is_none();
-                    if self.inner.check_inferred_local_types;
-                    if let Some(tcx) = self.inner.maybe_typeck_results;
-
-                    // Check the inferred types
-                    let l_ty = tcx.pat_ty(&l.pat);
-                    let r_ty = tcx.pat_ty(&r.pat);
-                    if l_ty != r_ty;
-                    then {
+                // This additional check ensures that the type of the locals are equivalent even if the init
+                // expression or type have some inferred parts.
+                if let Some(typeck) = self.inner.maybe_typeck_results {
+                    let l_ty = typeck.pat_ty(&l.pat);
+                    let r_ty = typeck.pat_ty(&r.pat);
+                    if !rustc_middle::ty::TyS::same_type(l_ty, r_ty) {
                         return false;
                     }
                 }
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 280bde73ed7..c21cef61df4 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -1206,37 +1206,6 @@ pub fn if_sequence<'tcx>(mut expr: &'tcx Expr<'tcx>) -> (Vec<&'tcx Expr<'tcx>>,
     (conds, blocks)
 }
 
-/// This function returns true if the given expression is the `else` or `if else` part of an if
-/// statement
-pub fn parent_node_is_if_expr(expr: &Expr<'_>, cx: &LateContext<'_>) -> bool {
-    let map = cx.tcx.hir();
-    let parent_id = map.get_parent_node(expr.hir_id);
-    let parent_node = map.get(parent_id);
-
-    // Check for `if`
-    if_chain! {
-        if let Node::Expr(expr) = parent_node;
-        if let ExprKind::If(_, _, _) = expr.kind;
-        then {
-            return true;
-        }
-    }
-
-    // Check for `if let`
-    if_chain! {
-        if let Node::Arm(arm) = parent_node;
-        let arm_parent_id = map.get_parent_node(arm.hir_id);
-        let arm_parent_node = map.get(arm_parent_id);
-        if let Node::Expr(expr) = arm_parent_node;
-        if let ExprKind::Match(_, _, MatchSource::IfLetDesugar { .. }) = expr.kind;
-        then {
-            return true;
-        }
-    }
-
-    false
-}
-
 // Finds the `#[must_use]` attribute, if any
 pub fn must_use_attr(attrs: &[Attribute]) -> Option<&Attribute> {
     attrs.iter().find(|a| a.has_name(sym::must_use))
-- 
cgit 1.4.1-3-g733a5


From ce5e927713ddd32096f4e73f7a2c339cc8163d82 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Thu, 25 Mar 2021 09:25:04 -0400
Subject: Improve `map_entry` lint Fix false positives where the map is used
 before inserting into the map. Fix false positives where two insertions
 happen. Suggest using `if let Entry::Vacant(e) = _.entry(_)` when `or_insert`
 might be a semantic change

---
 clippy_lints/src/entry.rs       | 489 ++++++++++++++++++++++++++++++----------
 clippy_utils/src/lib.rs         | 125 ++++++++--
 clippy_utils/src/paths.rs       |   4 +
 clippy_utils/src/source.rs      |   9 +
 tests/ui/entry.fixed            | 101 +++++++++
 tests/ui/entry.rs               | 103 +++++++++
 tests/ui/entry.stderr           | 171 ++++++++++++++
 tests/ui/entry_fixable.fixed    |  15 --
 tests/ui/entry_fixable.rs       |  17 --
 tests/ui/entry_fixable.stderr   |  12 -
 tests/ui/entry_unfixable.rs     |  59 ++---
 tests/ui/entry_unfixable.stderr |  57 -----
 12 files changed, 882 insertions(+), 280 deletions(-)
 create mode 100644 tests/ui/entry.fixed
 create mode 100644 tests/ui/entry.rs
 create mode 100644 tests/ui/entry.stderr
 delete mode 100644 tests/ui/entry_fixable.fixed
 delete mode 100644 tests/ui/entry_fixable.rs
 delete mode 100644 tests/ui/entry_fixable.stderr
 delete mode 100644 tests/ui/entry_unfixable.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/entry.rs b/clippy_lints/src/entry.rs
index a815df1691a..ca01d0a7f87 100644
--- a/clippy_lints/src/entry.rs
+++ b/clippy_lints/src/entry.rs
@@ -1,17 +1,18 @@
-use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::source::{snippet, snippet_opt, snippet_with_applicability};
-use clippy_utils::ty::{is_type_diagnostic_item, match_type};
-use clippy_utils::SpanlessEq;
-use clippy_utils::{get_item_name, paths};
-use if_chain::if_chain;
+use clippy_utils::{
+    diagnostics::span_lint_and_sugg,
+    is_expr_final_block_expr, is_expr_used_or_unified, match_def_path, paths, peel_hir_expr_while,
+    source::{snippet_indent, snippet_with_applicability, snippet_with_context},
+    SpanlessEq,
+};
 use rustc_errors::Applicability;
-use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
-use rustc_hir::{BorrowKind, Expr, ExprKind, UnOp};
+use rustc_hir::{
+    intravisit::{walk_expr, ErasedMap, NestedVisitorMap, Visitor},
+    Expr, ExprKind, Guard, Local, Stmt, StmtKind, UnOp,
+};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::hir::map::Map;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::source_map::Span;
-use rustc_span::sym;
+use rustc_span::{Span, SyntaxContext, DUMMY_SP};
+use std::fmt::Write;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for uses of `contains_key` + `insert` on `HashMap`
@@ -19,15 +20,14 @@ declare_clippy_lint! {
     ///
     /// **Why is this bad?** Using `entry` is more efficient.
     ///
-    /// **Known problems:** Some false negatives, eg.:
+    /// **Known problems:** The suggestion may have type inference errors in some cases. e.g.
     /// ```rust
-    /// # use std::collections::HashMap;
-    /// # let mut map = HashMap::new();
-    /// # let v = 1;
-    /// # let k = 1;
-    /// if !map.contains_key(&k) {
-    ///     map.insert(k.clone(), v);
-    /// }
+    /// let mut map = std::collections::HashMap::new();
+    /// let _ = if !map.contains_key(&0) {
+    ///     map.insert(0, 0)
+    /// } else {
+    ///     None
+    /// };
     /// ```
     ///
     /// **Example:**
@@ -56,132 +56,379 @@ declare_clippy_lint! {
 declare_lint_pass!(HashMapPass => [MAP_ENTRY]);
 
 impl<'tcx> LateLintPass<'tcx> for HashMapPass {
+    #[allow(clippy::too_many_lines)]
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if let ExprKind::If(check, then_block, ref else_block) = expr.kind {
-            if let ExprKind::Unary(UnOp::Not, check) = check.kind {
-                if let Some((ty, map, key)) = check_cond(cx, check) {
-                    // in case of `if !m.contains_key(&k) { m.insert(k, v); }`
-                    // we can give a better error message
-                    let sole_expr = {
-                        else_block.is_none()
-                            && if let ExprKind::Block(then_block, _) = then_block.kind {
-                                (then_block.expr.is_some() as usize) + then_block.stmts.len() == 1
-                            } else {
-                                true
-                            }
-                        // XXXManishearth we can also check for if/else blocks containing `None`.
-                    };
+        let (cond_expr, then_expr, else_expr) = match expr.kind {
+            ExprKind::If(c, t, e) => (c, t, e),
+            _ => return,
+        };
+        let (map_ty, contains_expr) = match try_parse_contains(cx, cond_expr) {
+            Some(x) => x,
+            None => return,
+        };
 
-                    let mut visitor = InsertVisitor {
-                        cx,
-                        span: expr.span,
-                        ty,
-                        map,
-                        key,
-                        sole_expr,
-                    };
+        let then_search = match find_insert_calls(cx, &contains_expr, then_expr) {
+            Some(x) => x,
+            None => return,
+        };
 
-                    walk_expr(&mut visitor, then_block);
-                }
-            } else if let Some(else_block) = *else_block {
-                if let Some((ty, map, key)) = check_cond(cx, check) {
-                    let mut visitor = InsertVisitor {
-                        cx,
-                        span: expr.span,
-                        ty,
-                        map,
-                        key,
-                        sole_expr: false,
+        let mut app = Applicability::MachineApplicable;
+        let map_str = snippet_with_context(cx, contains_expr.map.span, contains_expr.call_ctxt, "..", &mut app).0;
+        let key_str = snippet_with_context(cx, contains_expr.key.span, contains_expr.call_ctxt, "..", &mut app).0;
+        let sugg = if !contains_expr.negated || else_expr.is_some() || then_search.insertions.is_empty() {
+            return;
+        } else {
+            // if .. { insert }
+            match then_search.as_single_insertion() {
+                Some(insertion) if !insertion.value.can_have_side_effects() => {
+                    format!(
+                        "{}.entry({}).or_insert({});",
+                        map_str,
+                        key_str,
+                        snippet_with_context(cx, insertion.value.span, insertion.call.span.ctxt(), "..", &mut app).0,
+                    )
+                },
+                _ => {
+                    let (body_str, entry_kind) = if contains_expr.negated {
+                        (then_search.snippet_vacant(cx, then_expr.span, &mut app), "Vacant(e)")
+                    } else {
+                        (
+                            then_search.snippet_occupied(cx, then_expr.span, &mut app),
+                            "Occupied(mut e)",
+                        )
                     };
-
-                    walk_expr(&mut visitor, else_block);
-                }
+                    format!(
+                        "if let {}::{} = {}.entry({}) {}",
+                        map_ty.entry_path(),
+                        entry_kind,
+                        map_str,
+                        key_str,
+                        body_str,
+                    )
+                },
             }
+        };
+
+        span_lint_and_sugg(
+            cx,
+            MAP_ENTRY,
+            expr.span,
+            &format!("usage of `contains_key` followed by `insert` on a `{}`", map_ty.name()),
+            "try this",
+            sugg,
+            app,
+        );
+    }
+}
+
+#[derive(Clone, Copy)]
+enum MapType {
+    Hash,
+    BTree,
+}
+impl MapType {
+    fn name(self) -> &'static str {
+        match self {
+            Self::Hash => "HashMap",
+            Self::BTree => "BTreeMap",
+        }
+    }
+    fn entry_path(self) -> &'staic str {
+        match self {
+            Self::Hash => "std::collections::hash_map::Entry",
+            Self::BTree => "std::collections::btree_map::Entry",
         }
     }
 }
 
-fn check_cond<'a>(cx: &LateContext<'_>, check: &'a Expr<'a>) -> Option<(&'static str, &'a Expr<'a>, &'a Expr<'a>)> {
-    if_chain! {
-        if let ExprKind::MethodCall(path, _, params, _) = check.kind;
-        if params.len() >= 2;
-        if path.ident.name == sym!(contains_key);
-        if let ExprKind::AddrOf(BorrowKind::Ref, _, key) = params[1].kind;
-        then {
-            let map = &params[0];
-            let obj_ty = cx.typeck_results().expr_ty(map).peel_refs();
-
-            return if match_type(cx, obj_ty, &paths::BTREEMAP) {
-                Some(("BTreeMap", map, key))
-            }
-            else if is_type_diagnostic_item(cx, obj_ty, sym::hashmap_type) {
-                Some(("HashMap", map, key))
-            }
-            else {
-                None
+struct ContainsExpr<'tcx> {
+    negated: bool,
+    map: &'tcx Expr<'tcx>,
+    key: &'tcx Expr<'tcx>,
+    call_ctxt: SyntaxContext,
+}
+fn try_parse_contains(cx: &LateContext<'_>, expr: &'tcx Expr<'_>) -> Option<(MapType, ContainsExpr<'tcx>)> {
+    let mut negated = false;
+    let expr = peel_hir_expr_while(expr, |e| match e.kind {
+        ExprKind::Unary(UnOp::Not, e) => {
+            negated = !negated;
+            Some(e)
+        },
+        _ => None,
+    });
+    match expr.kind {
+        ExprKind::MethodCall(
+            _,
+            _,
+            [map, Expr {
+                kind: ExprKind::AddrOf(_, _, key),
+                span: key_span,
+                ..
+            }],
+            _,
+        ) if key_span.ctxt() == expr.span.ctxt() => {
+            let id = cx.typeck_results().type_dependent_def_id(expr.hir_id)?;
+            let expr = ContainsExpr {
+                negated,
+                map,
+                key,
+                call_ctxt: expr.span.ctxt(),
             };
+            if match_def_path(cx, id, &paths::BTREEMAP_CONTAINS_KEY) {
+                Some((MapType::BTree, expr))
+            } else if match_def_path(cx, id, &paths::HASHMAP_CONTAINS_KEY) {
+                Some((MapType::Hash, expr))
+            } else {
+                None
+            }
+        },
+        _ => None,
+    }
+}
+
+struct InsertExpr<'tcx> {
+    map: &'tcx Expr<'tcx>,
+    key: &'tcx Expr<'tcx>,
+    value: &'tcx Expr<'tcx>,
+}
+fn try_parse_insert(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<InsertExpr<'tcx>> {
+    if let ExprKind::MethodCall(_, _, [map, key, value], _) = expr.kind {
+        let id = cx.typeck_results().type_dependent_def_id(expr.hir_id)?;
+        if match_def_path(cx, id, &paths::BTREEMAP_INSERT) || match_def_path(cx, id, &paths::HASHMAP_INSERT) {
+            Some(InsertExpr { map, key, value })
+        } else {
+            None
         }
+    } else {
+        None
     }
+}
 
-    None
+#[derive(Clone, Copy)]
+struct Insertion<'tcx> {
+    call: &'tcx Expr<'tcx>,
+    value: &'tcx Expr<'tcx>,
 }
 
-struct InsertVisitor<'a, 'tcx, 'b> {
-    cx: &'a LateContext<'tcx>,
-    span: Span,
-    ty: &'static str,
-    map: &'b Expr<'b>,
-    key: &'b Expr<'b>,
-    sole_expr: bool,
+// This visitor needs to do a multiple things:
+// * Find all usages of the map. Only insertions into the map which share the same key are
+//   permitted. All others will prevent the lint.
+// * Determine if the final statement executed is an insertion. This is needed to use `insert_with`.
+// * Determine if there's any sub-expression that can't be placed in a closure.
+// * Determine if there's only a single insert statement. This is needed to give better suggestions.
+
+#[allow(clippy::struct_excessive_bools)]
+struct InsertSearcher<'cx, 'i, 'tcx> {
+    cx: &'cx LateContext<'tcx>,
+    /// The map expression used in the contains call.
+    map: &'tcx Expr<'tcx>,
+    /// The key expression used in the contains call.
+    key: &'tcx Expr<'tcx>,
+    /// The context of the top level block. All insert calls must be in the same context.
+    ctxt: SyntaxContext,
+    /// Whether this expression can use the entry api.
+    can_use_entry: bool,
+    // A single insert expression has a slightly different suggestion.
+    is_single_insert: bool,
+    is_map_used: bool,
+    insertions: &'i mut Vec<Insertion<'tcx>>,
+}
+impl<'tcx> InsertSearcher<'_, '_, 'tcx> {
+    /// Visit the expression as a branch in control flow. Multiple insert calls can be used, but
+    /// only if they are on separate code paths. This will return whether the map was used in the
+    /// given expression.
+    fn visit_cond_arm(&mut self, e: &'tcx Expr<'_>) -> bool {
+        let is_map_used = self.is_map_used;
+        self.visit_expr(e);
+        let res = self.is_map_used;
+        self.is_map_used = is_map_used;
+        res
+    }
 }
+impl<'tcx> Visitor<'tcx> for InsertSearcher<'_, '_, 'tcx> {
+    type Map = ErasedMap<'tcx>;
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::None
+    }
 
-impl<'a, 'tcx, 'b> Visitor<'tcx> for InsertVisitor<'a, 'tcx, 'b> {
-    type Map = Map<'tcx>;
+    fn visit_stmt(&mut self, stmt: &'tcx Stmt<'_>) {
+        match stmt.kind {
+            StmtKind::Semi(e) | StmtKind::Expr(e) => self.visit_expr(e),
+            StmtKind::Local(Local { init: Some(e), .. }) => {
+                self.is_single_insert = false;
+                self.visit_expr(e);
+            },
+            _ => {
+                self.is_single_insert = false;
+            },
+        }
+    }
 
     fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
-        if_chain! {
-            if let ExprKind::MethodCall(path, _, params, _) = expr.kind;
-            if params.len() == 3;
-            if path.ident.name == sym!(insert);
-            if get_item_name(self.cx, self.map) == get_item_name(self.cx, &params[0]);
-            if SpanlessEq::new(self.cx).eq_expr(self.key, &params[1]);
-            if snippet_opt(self.cx, self.map.span) == snippet_opt(self.cx, params[0].span);
-            then {
-                span_lint_and_then(self.cx, MAP_ENTRY, self.span,
-                                   &format!("usage of `contains_key` followed by `insert` on a `{}`", self.ty), |diag| {
-                    if self.sole_expr {
-                        let mut app = Applicability::MachineApplicable;
-                        let help = format!("{}.entry({}).or_insert({});",
-                                           snippet_with_applicability(self.cx, self.map.span, "map", &mut app),
-                                           snippet_with_applicability(self.cx, params[1].span, "..", &mut app),
-                                           snippet_with_applicability(self.cx, params[2].span, "..", &mut app));
-
-                        diag.span_suggestion(
-                            self.span,
-                            "consider using",
-                            help,
-                            Applicability::MachineApplicable, // snippet
-                        );
+        if !self.can_use_entry {
+            return;
+        }
+
+        match try_parse_insert(self.cx, expr) {
+            Some(insert_expr) if SpanlessEq::new(self.cx).eq_expr(self.map, insert_expr.map) => {
+                // Multiple inserts, inserts with a different key, and inserts from a macro can't use the entry api.
+                if self.is_map_used
+                    || !SpanlessEq::new(self.cx).eq_expr(self.key, insert_expr.key)
+                    || expr.span.ctxt() != self.ctxt
+                {
+                    self.can_use_entry = false;
+                    return;
+                }
+
+                self.insertions.push(Insertion {
+                    call: expr,
+                    value: insert_expr.value,
+                });
+                self.is_map_used = true;
+
+                // The value doesn't affect whether there is only a single insert expression.
+                let is_single_insert = self.is_single_insert;
+                self.visit_expr(insert_expr.value);
+                self.is_single_insert = is_single_insert;
+            },
+            _ if SpanlessEq::new(self.cx).eq_expr(self.map, expr) => {
+                self.is_map_used = true;
+            },
+            _ => match expr.kind {
+                ExprKind::If(cond_expr, then_expr, Some(else_expr)) => {
+                    self.is_single_insert = false;
+                    self.visit_expr(cond_expr);
+                    // Each branch may contain it's own insert expression.
+                    let mut is_map_used = self.visit_cond_arm(then_expr);
+                    is_map_used |= self.visit_cond_arm(else_expr);
+                    self.is_map_used = is_map_used;
+                },
+                ExprKind::Match(scrutinee_expr, arms, _) => {
+                    self.is_single_insert = false;
+                    self.visit_expr(scrutinee_expr);
+                    // Each branch may contain it's own insert expression.
+                    let mut is_map_used = self.is_map_used;
+                    for arm in arms {
+                        if let Some(Guard::If(guard) | Guard::IfLet(_, guard)) = arm.guard {
+                            self.visit_expr(guard)
+                        }
+                        is_map_used |= self.visit_cond_arm(arm.body);
                     }
-                    else {
-                        let help = format!("consider using `{}.entry({})`",
-                                           snippet(self.cx, self.map.span, "map"),
-                                           snippet(self.cx, params[1].span, ".."));
-
-                        diag.span_label(
-                            self.span,
-                            &help,
-                        );
+                    self.is_map_used = is_map_used;
+                },
+                ExprKind::Loop(block, ..) => {
+                    // Don't allow insertions inside of a loop.
+                    let insertions_len = self.insertions.len();
+                    self.visit_block(block);
+                    if self.insertions.len() != insertions_len {
+                        self.can_use_entry = false;
                     }
-                });
-            }
+                },
+                ExprKind::Block(block, _) => self.visit_block(block),
+                ExprKind::InlineAsm(_) | ExprKind::LlvmInlineAsm(_) => {
+                    self.can_use_entry = false;
+                },
+                _ => {
+                    self.is_single_insert = false;
+                    walk_expr(self, expr);
+                },
+            },
         }
+    }
+}
 
-        if !self.sole_expr {
-            walk_expr(self, expr);
+struct InsertSearchResults<'tcx> {
+    insertions: Vec<Insertion<'tcx>>,
+    is_single_insert: bool,
+}
+impl InsertSearchResults<'tcx> {
+    fn as_single_insertion(&self) -> Option<Insertion<'tcx>> {
+        self.is_single_insert.then(|| self.insertions[0])
+    }
+
+    fn snippet_occupied(&self, cx: &LateContext<'_>, mut span: Span, app: &mut Applicability) -> String {
+        let ctxt = span.ctxt();
+        let mut res = String::new();
+        for insertion in self.insertions.iter() {
+            res.push_str(&snippet_with_applicability(
+                cx,
+                span.until(insertion.call.span),
+                "..",
+                app,
+            ));
+            if is_expr_used_or_unified(cx.tcx, insertion.call) {
+                res.push_str("Some(e.insert(");
+                res.push_str(&snippet_with_context(cx, insertion.value.span, ctxt, "..", app).0);
+                res.push_str("))");
+            } else {
+                res.push_str("e.insert(");
+                res.push_str(&snippet_with_context(cx, insertion.value.span, ctxt, "..", app).0);
+                res.push(')');
+            }
+            span = span.trim_start(insertion.call.span).unwrap_or(DUMMY_SP);
         }
+        res.push_str(&snippet_with_applicability(cx, span, "..", app));
+        res
     }
-    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-        NestedVisitorMap::None
+
+    fn snippet_vacant(&self, cx: &LateContext<'_>, mut span: Span, app: &mut Applicability) -> String {
+        let ctxt = span.ctxt();
+        let mut res = String::new();
+        for insertion in self.insertions.iter() {
+            res.push_str(&snippet_with_applicability(
+                cx,
+                span.until(insertion.call.span),
+                "..",
+                app,
+            ));
+            if is_expr_used_or_unified(cx.tcx, insertion.call) {
+                if is_expr_final_block_expr(cx.tcx, insertion.call) {
+                    let _ = write!(
+                        res,
+                        "e.insert({});\n{}None",
+                        snippet_with_context(cx, insertion.value.span, ctxt, "..", app).0,
+                        snippet_indent(cx, insertion.call.span).as_deref().unwrap_or(""),
+                    );
+                } else {
+                    let _ = write!(
+                        res,
+                        "{{ e.insert({}); None }}",
+                        snippet_with_context(cx, insertion.value.span, ctxt, "..", app).0,
+                    );
+                }
+            } else {
+                let _ = write!(
+                    res,
+                    "e.insert({})",
+                    snippet_with_context(cx, insertion.value.span, ctxt, "..", app).0,
+                );
+            }
+            span = span.trim_start(insertion.call.span).unwrap_or(DUMMY_SP);
+        }
+        res.push_str(&snippet_with_applicability(cx, span, "..", app));
+        res
     }
 }
+fn find_insert_calls(
+    cx: &LateContext<'tcx>,
+    contains_expr: &ContainsExpr<'tcx>,
+    expr: &'tcx Expr<'_>,
+) -> Option<InsertSearchResults<'tcx>> {
+    let mut insertions = Vec::new();
+    let mut s = InsertSearcher {
+        cx,
+        map: contains_expr.map,
+        key: contains_expr.key,
+        ctxt: expr.span.ctxt(),
+        insertions: &mut insertions,
+        is_map_used: false,
+        can_use_entry: true,
+        is_single_insert: true,
+    };
+    s.visit_expr(expr);
+    let is_single_insert = s.is_single_insert;
+    s.can_use_entry.then(|| InsertSearchResults {
+        insertions,
+        is_single_insert,
+    })
+}
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 8e1a2105b96..0abee49f40c 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -63,9 +63,9 @@ use rustc_hir::def_id::{DefId, LOCAL_CRATE};
 use rustc_hir::intravisit::{self, NestedVisitorMap, Visitor};
 use rustc_hir::LangItem::{ResultErr, ResultOk};
 use rustc_hir::{
-    def, Arm, BindingAnnotation, Block, Body, Constness, Expr, ExprKind, FnDecl, GenericArgs, HirId, Impl, ImplItem,
-    ImplItemKind, Item, ItemKind, LangItem, MatchSource, Node, Param, Pat, PatKind, Path, PathSegment, QPath,
-    TraitItem, TraitItemKind, TraitRef, TyKind,
+    def, Arm, BindingAnnotation, Block, Body, Constness, Destination, Expr, ExprKind, FnDecl, GenericArgs, HirId, Impl,
+    ImplItem, ImplItemKind, Item, ItemKind, LangItem, MatchSource, Node, Param, Pat, PatKind, Path, PathSegment, QPath,
+    Stmt, StmtKind, TraitItem, TraitItemKind, TraitRef, TyKind,
 };
 use rustc_lint::{LateContext, Level, Lint, LintContext};
 use rustc_middle::hir::exports::Export;
@@ -1245,6 +1245,82 @@ pub fn is_must_use_func_call(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
     did.map_or(false, |did| must_use_attr(&cx.tcx.get_attrs(did)).is_some())
 }
 
+pub fn get_expr_use_node(tcx: TyCtxt<'tcx>, expr: &Expr<'_>) -> Option<Node<'tcx>> {
+    let map = tcx.hir();
+    let mut child_id = expr.hir_id;
+    let mut iter = map.parent_iter(child_id);
+    loop {
+        match iter.next() {
+            None => break None,
+            Some((id, Node::Block(_))) => child_id = id,
+            Some((id, Node::Arm(arm))) if arm.body.hir_id == child_id => child_id = id,
+            Some((_, Node::Expr(expr))) => match expr.kind {
+                ExprKind::Break(
+                    Destination {
+                        target_id: Ok(dest), ..
+                    },
+                    _,
+                ) => {
+                    iter = map.parent_iter(dest);
+                    child_id = dest;
+                },
+                ExprKind::DropTemps(_) | ExprKind::Block(..) => child_id = expr.hir_id,
+                ExprKind::If(control_expr, ..) | ExprKind::Match(control_expr, ..)
+                    if control_expr.hir_id != child_id =>
+                {
+                    child_id = expr.hir_id
+                },
+                _ => break Some(Node::Expr(expr)),
+            },
+            Some((_, node)) => break Some(node),
+        }
+    }
+}
+
+pub fn is_expr_used(tcx: TyCtxt<'_>, expr: &Expr<'_>) -> bool {
+    !matches!(
+        get_expr_use_node(tcx, expr),
+        Some(Node::Stmt(Stmt {
+            kind: StmtKind::Expr(_) | StmtKind::Semi(_),
+            ..
+        }))
+    )
+}
+
+pub fn get_expr_use_or_unification_node(tcx: TyCtxt<'tcx>, expr: &Expr<'_>) -> Option<Node<'tcx>> {
+    let map = tcx.hir();
+    let mut child_id = expr.hir_id;
+    let mut iter = map.parent_iter(child_id);
+    loop {
+        match iter.next() {
+            None => break None,
+            Some((id, Node::Block(_))) => child_id = id,
+            Some((id, Node::Arm(arm))) if arm.body.hir_id == child_id => child_id = id,
+            Some((_, Node::Expr(expr))) => match expr.kind {
+                ExprKind::Match(_, [arm], _) if arm.hir_id == child_id => child_id = expr.hir_id,
+                ExprKind::Block(..) | ExprKind::DropTemps(_) => child_id = expr.hir_id,
+                ExprKind::If(_, then_expr, None) if then_expr.hir_id == child_id => break None,
+                _ => break Some(Node::Expr(expr)),
+            },
+            Some((_, node)) => break Some(node),
+        }
+    }
+}
+
+pub fn is_expr_used_or_unified(tcx: TyCtxt<'_>, expr: &Expr<'_>) -> bool {
+    !matches!(
+        get_expr_use_or_unification_node(tcx, expr),
+        None | Some(Node::Stmt(Stmt {
+            kind: StmtKind::Expr(_) | StmtKind::Semi(_),
+            ..
+        }))
+    )
+}
+
+pub fn is_expr_final_block_expr(tcx: TyCtxt<'_>, expr: &Expr<'_>) -> bool {
+    matches!(get_parent_node(tcx, expr.hir_id), Some(Node::Block(..)))
+}
+
 pub fn is_no_std_crate(cx: &LateContext<'_>) -> bool {
     cx.tcx.hir().attrs(hir::CRATE_HIR_ID).iter().any(|attr| {
         if let ast::AttrKind::Normal(ref attr, _) = attr.kind {
@@ -1414,28 +1490,43 @@ pub fn peel_hir_pat_refs(pat: &'a Pat<'a>) -> (&'a Pat<'a>, usize) {
     peel(pat, 0)
 }
 
+/// Peels of expressions while the given closure returns `Some`.
+pub fn peel_hir_expr_while<'tcx>(
+    mut expr: &'tcx Expr<'tcx>,
+    mut f: impl FnMut(&'tcx Expr<'tcx>) -> Option<&'tcx Expr<'tcx>>,
+) -> &'tcx Expr<'tcx> {
+    while let Some(e) = f(expr) {
+        expr = e;
+    }
+    expr
+}
+
 /// Peels off up to the given number of references on the expression. Returns the underlying
 /// expression and the number of references removed.
 pub fn peel_n_hir_expr_refs(expr: &'a Expr<'a>, count: usize) -> (&'a Expr<'a>, usize) {
-    fn f(expr: &'a Expr<'a>, count: usize, target: usize) -> (&'a Expr<'a>, usize) {
-        match expr.kind {
-            ExprKind::AddrOf(_, _, expr) if count != target => f(expr, count + 1, target),
-            _ => (expr, count),
-        }
-    }
-    f(expr, 0, count)
+    let mut remaining = count;
+    let e = peel_hir_expr_while(expr, |e| match e.kind {
+        ExprKind::AddrOf(BorrowKind::Ref, _, e) if remaining != 0 => {
+            remaining -= 1;
+            Some(e)
+        },
+        _ => None,
+    });
+    (e, count - remaining)
 }
 
 /// Peels off all references on the expression. Returns the underlying expression and the number of
 /// references removed.
 pub fn peel_hir_expr_refs(expr: &'a Expr<'a>) -> (&'a Expr<'a>, usize) {
-    fn f(expr: &'a Expr<'a>, count: usize) -> (&'a Expr<'a>, usize) {
-        match expr.kind {
-            ExprKind::AddrOf(BorrowKind::Ref, _, expr) => f(expr, count + 1),
-            _ => (expr, count),
-        }
-    }
-    f(expr, 0)
+    let mut count = 0;
+    let e = peel_hir_expr_while(expr, |e| match e.kind {
+        ExprKind::AddrOf(BorrowKind::Ref, _, e) => {
+            count += 1;
+            Some(e)
+        },
+        _ => None,
+    });
+    (e, count)
 }
 
 #[macro_export]
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index ed8915f59e1..8066f6c223e 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -13,7 +13,9 @@ pub(super) const BEGIN_PANIC_FMT: [&str; 3] = ["std", "panicking", "begin_panic_
 pub const BINARY_HEAP: [&str; 4] = ["alloc", "collections", "binary_heap", "BinaryHeap"];
 pub const BORROW_TRAIT: [&str; 3] = ["core", "borrow", "Borrow"];
 pub const BTREEMAP: [&str; 5] = ["alloc", "collections", "btree", "map", "BTreeMap"];
+pub const BTREEMAP_CONTAINS_KEY: [&str; 6] = ["alloc", "collections", "btree", "map", "BTreeMap", "contains_key"];
 pub const BTREEMAP_ENTRY: [&str; 6] = ["alloc", "collections", "btree", "map", "entry", "Entry"];
+pub const BTREEMAP_INSERT: [&str; 6] = ["alloc", "collections", "btree", "map", "BTreeMap", "insert"];
 pub const BTREESET: [&str; 5] = ["alloc", "collections", "btree", "set", "BTreeSet"];
 pub const CLONE_TRAIT_METHOD: [&str; 4] = ["core", "clone", "Clone", "clone"];
 pub const CMP_MAX: [&str; 3] = ["core", "cmp", "max"];
@@ -45,7 +47,9 @@ pub const FROM_ITERATOR: [&str; 5] = ["core", "iter", "traits", "collect", "From
 pub const FUTURE_FROM_GENERATOR: [&str; 3] = ["core", "future", "from_generator"];
 pub const HASH: [&str; 3] = ["core", "hash", "Hash"];
 pub const HASHMAP: [&str; 5] = ["std", "collections", "hash", "map", "HashMap"];
+pub const HASHMAP_CONTAINS_KEY: [&str; 6] = ["std", "collections", "hash", "map", "HashMap", "contains_key"];
 pub const HASHMAP_ENTRY: [&str; 5] = ["std", "collections", "hash", "map", "Entry"];
+pub const HASHMAP_INSERT: [&str; 6] = ["std", "collections", "hash", "map", "HashMap", "insert"];
 pub const HASHSET: [&str; 5] = ["std", "collections", "hash", "set", "HashSet"];
 #[cfg(feature = "internal-lints")]
 pub const IDENT: [&str; 3] = ["rustc_span", "symbol", "Ident"];
diff --git a/clippy_utils/src/source.rs b/clippy_utils/src/source.rs
index 2d794d48dc5..53180d1f9f5 100644
--- a/clippy_utils/src/source.rs
+++ b/clippy_utils/src/source.rs
@@ -66,6 +66,15 @@ pub fn indent_of<T: LintContext>(cx: &T, span: Span) -> Option<usize> {
     snippet_opt(cx, line_span(cx, span)).and_then(|snip| snip.find(|c: char| !c.is_whitespace()))
 }
 
+/// Gets a snippet of the indentation of the line of a span
+pub fn snippet_indent<T: LintContext>(cx: &T, span: Span) -> Option<String> {
+    snippet_opt(cx, line_span(cx, span)).map(|mut s| {
+        let len = s.len() - s.trim_start().len();
+        s.truncate(len);
+        s
+    })
+}
+
 // If the snippet is empty, it's an attribute that was inserted during macro
 // expansion and we want to ignore those, because they could come from external
 // sources that the user has no control over.
diff --git a/tests/ui/entry.fixed b/tests/ui/entry.fixed
new file mode 100644
index 00000000000..60371c9833c
--- /dev/null
+++ b/tests/ui/entry.fixed
@@ -0,0 +1,101 @@
+// run-rustfix
+
+#![allow(unused, clippy::needless_pass_by_value, clippy::collapsible_if)]
+#![warn(clippy::map_entry)]
+
+use std::collections::{BTreeMap, HashMap};
+use std::hash::Hash;
+
+macro_rules! m {
+    ($e:expr) => {{ $e }};
+}
+
+fn foo() {}
+
+fn hash_map<K: Eq + Hash + Copy, V: Copy>(m: &mut HashMap<K, V>, k: K, v: V, v2: V) {
+    m.entry(k).or_insert(v);
+
+    if let std::collections::hash_map::Entry::Vacant(e) = m.entry(k) {
+        if true {
+            e.insert(v);
+        } else {
+            e.insert(v2);
+        }
+    }
+
+    if let std::collections::hash_map::Entry::Vacant(e) = m.entry(k) {
+        if true {
+            e.insert(v);
+        } else {
+            e.insert(v2);
+            return;
+        }
+    }
+
+    if let std::collections::hash_map::Entry::Vacant(e) = m.entry(k) {
+        foo();
+        e.insert(v);
+    }
+
+    if let std::collections::hash_map::Entry::Vacant(e) = m.entry(k) {
+        match 0 {
+            1 if true => {
+                e.insert(v);
+            },
+            _ => {
+                e.insert(v2);
+            },
+        };
+    }
+
+    if let std::collections::hash_map::Entry::Vacant(e) = m.entry(k) {
+        match 0 {
+            0 => {},
+            1 => {
+                e.insert(v);
+            },
+            _ => {
+                e.insert(v2);
+            },
+        };
+    }
+
+    if let std::collections::hash_map::Entry::Vacant(e) = m.entry(k) {
+        foo();
+        match 0 {
+            0 if false => {
+                e.insert(v);
+            },
+            1 => {
+                foo();
+                e.insert(v);
+            },
+            2 | 3 => {
+                for _ in 0..2 {
+                    foo();
+                }
+                if true {
+                    e.insert(v);
+                } else {
+                    e.insert(v2);
+                };
+            },
+            _ => {
+                e.insert(v2);
+            },
+        }
+    }
+
+    if let std::collections::hash_map::Entry::Vacant(e) = m.entry(m!(k)) {
+        e.insert(m!(v));
+    }
+}
+
+fn btree_map<K: Eq + Ord + Copy, V: Copy>(m: &mut BTreeMap<K, V>, k: K, v: V, v2: V) {
+    if let std::collections::btree_map::Entry::Vacant(e) = m.entry(k) {
+        e.insert(v);
+        foo();
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/entry.rs b/tests/ui/entry.rs
new file mode 100644
index 00000000000..4d3e241de78
--- /dev/null
+++ b/tests/ui/entry.rs
@@ -0,0 +1,103 @@
+// run-rustfix
+
+#![allow(unused, clippy::needless_pass_by_value, clippy::collapsible_if)]
+#![warn(clippy::map_entry)]
+
+use std::collections::{BTreeMap, HashMap};
+use std::hash::Hash;
+
+macro_rules! m {
+    ($e:expr) => {{ $e }};
+}
+
+fn foo() {}
+
+fn hash_map<K: Eq + Hash + Copy, V: Copy>(m: &mut HashMap<K, V>, k: K, v: V, v2: V) {
+    if !m.contains_key(&k) {
+        m.insert(k, v);
+    }
+
+    if !m.contains_key(&k) {
+        if true {
+            m.insert(k, v);
+        } else {
+            m.insert(k, v2);
+        }
+    }
+
+    if !m.contains_key(&k) {
+        if true {
+            m.insert(k, v);
+        } else {
+            m.insert(k, v2);
+            return;
+        }
+    }
+
+    if !m.contains_key(&k) {
+        foo();
+        m.insert(k, v);
+    }
+
+    if !m.contains_key(&k) {
+        match 0 {
+            1 if true => {
+                m.insert(k, v);
+            },
+            _ => {
+                m.insert(k, v2);
+            },
+        };
+    }
+
+    if !m.contains_key(&k) {
+        match 0 {
+            0 => {},
+            1 => {
+                m.insert(k, v);
+            },
+            _ => {
+                m.insert(k, v2);
+            },
+        };
+    }
+
+    if !m.contains_key(&k) {
+        foo();
+        match 0 {
+            0 if false => {
+                m.insert(k, v);
+            },
+            1 => {
+                foo();
+                m.insert(k, v);
+            },
+            2 | 3 => {
+                for _ in 0..2 {
+                    foo();
+                }
+                if true {
+                    m.insert(k, v);
+                } else {
+                    m.insert(k, v2);
+                };
+            },
+            _ => {
+                m.insert(k, v2);
+            },
+        }
+    }
+
+    if !m.contains_key(&m!(k)) {
+        m.insert(m!(k), m!(v));
+    }
+}
+
+fn btree_map<K: Eq + Ord + Copy, V: Copy>(m: &mut BTreeMap<K, V>, k: K, v: V, v2: V) {
+    if !m.contains_key(&k) {
+        m.insert(k, v);
+        foo();
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/entry.stderr b/tests/ui/entry.stderr
new file mode 100644
index 00000000000..ab108ed6861
--- /dev/null
+++ b/tests/ui/entry.stderr
@@ -0,0 +1,171 @@
+error: usage of `contains_key` followed by `insert` on a `HashMap`
+  --> $DIR/entry.rs:16:5
+   |
+LL | /     if !m.contains_key(&k) {
+LL | |         m.insert(k, v);
+LL | |     }
+   | |_____^ help: try this: `m.entry(k).or_insert(v);`
+   |
+   = note: `-D clippy::map-entry` implied by `-D warnings`
+
+error: usage of `contains_key` followed by `insert` on a `HashMap`
+  --> $DIR/entry.rs:20:5
+   |
+LL | /     if !m.contains_key(&k) {
+LL | |         if true {
+LL | |             m.insert(k, v);
+LL | |         } else {
+LL | |             m.insert(k, v2);
+LL | |         }
+LL | |     }
+   | |_____^
+   |
+help: try this
+   |
+LL |     if let std::collections::hash_map::Entry::Vacant(e) = m.entry(k) {
+LL |         if true {
+LL |             e.insert(v);
+LL |         } else {
+LL |             e.insert(v2);
+LL |         }
+ ...
+
+error: usage of `contains_key` followed by `insert` on a `HashMap`
+  --> $DIR/entry.rs:28:5
+   |
+LL | /     if !m.contains_key(&k) {
+LL | |         if true {
+LL | |             m.insert(k, v);
+LL | |         } else {
+...  |
+LL | |         }
+LL | |     }
+   | |_____^
+   |
+help: try this
+   |
+LL |     if let std::collections::hash_map::Entry::Vacant(e) = m.entry(k) {
+LL |         if true {
+LL |             e.insert(v);
+LL |         } else {
+LL |             e.insert(v2);
+LL |             return;
+ ...
+
+error: usage of `contains_key` followed by `insert` on a `HashMap`
+  --> $DIR/entry.rs:37:5
+   |
+LL | /     if !m.contains_key(&k) {
+LL | |         foo();
+LL | |         m.insert(k, v);
+LL | |     }
+   | |_____^
+   |
+help: try this
+   |
+LL |     if let std::collections::hash_map::Entry::Vacant(e) = m.entry(k) {
+LL |         foo();
+LL |         e.insert(v);
+LL |     }
+   |
+
+error: usage of `contains_key` followed by `insert` on a `HashMap`
+  --> $DIR/entry.rs:42:5
+   |
+LL | /     if !m.contains_key(&k) {
+LL | |         match 0 {
+LL | |             1 if true => {
+LL | |                 m.insert(k, v);
+...  |
+LL | |         };
+LL | |     }
+   | |_____^
+   |
+help: try this
+   |
+LL |     if let std::collections::hash_map::Entry::Vacant(e) = m.entry(k) {
+LL |         match 0 {
+LL |             1 if true => {
+LL |                 e.insert(v);
+LL |             },
+LL |             _ => {
+ ...
+
+error: usage of `contains_key` followed by `insert` on a `HashMap`
+  --> $DIR/entry.rs:53:5
+   |
+LL | /     if !m.contains_key(&k) {
+LL | |         match 0 {
+LL | |             0 => {},
+LL | |             1 => {
+...  |
+LL | |         };
+LL | |     }
+   | |_____^
+   |
+help: try this
+   |
+LL |     if let std::collections::hash_map::Entry::Vacant(e) = m.entry(k) {
+LL |         match 0 {
+LL |             0 => {},
+LL |             1 => {
+LL |                 e.insert(v);
+LL |             },
+ ...
+
+error: usage of `contains_key` followed by `insert` on a `HashMap`
+  --> $DIR/entry.rs:65:5
+   |
+LL | /     if !m.contains_key(&k) {
+LL | |         foo();
+LL | |         match 0 {
+LL | |             0 if false => {
+...  |
+LL | |         }
+LL | |     }
+   | |_____^
+   |
+help: try this
+   |
+LL |     if let std::collections::hash_map::Entry::Vacant(e) = m.entry(k) {
+LL |         foo();
+LL |         match 0 {
+LL |             0 if false => {
+LL |                 e.insert(v);
+LL |             },
+ ...
+
+error: usage of `contains_key` followed by `insert` on a `HashMap`
+  --> $DIR/entry.rs:91:5
+   |
+LL | /     if !m.contains_key(&m!(k)) {
+LL | |         m.insert(m!(k), m!(v));
+LL | |     }
+   | |_____^
+   |
+help: try this
+   |
+LL |     if let std::collections::hash_map::Entry::Vacant(e) = m.entry(m!(k)) {
+LL |         e.insert(m!(v));
+LL |     }
+   |
+
+error: usage of `contains_key` followed by `insert` on a `BTreeMap`
+  --> $DIR/entry.rs:97:5
+   |
+LL | /     if !m.contains_key(&k) {
+LL | |         m.insert(k, v);
+LL | |         foo();
+LL | |     }
+   | |_____^
+   |
+help: try this
+   |
+LL |     if let std::collections::btree_map::Entry::Vacant(e) = m.entry(k) {
+LL |         e.insert(v);
+LL |         foo();
+LL |     }
+   |
+
+error: aborting due to 9 previous errors
+
diff --git a/tests/ui/entry_fixable.fixed b/tests/ui/entry_fixable.fixed
deleted file mode 100644
index dcdaae7e724..00000000000
--- a/tests/ui/entry_fixable.fixed
+++ /dev/null
@@ -1,15 +0,0 @@
-// run-rustfix
-
-#![allow(unused, clippy::needless_pass_by_value)]
-#![warn(clippy::map_entry)]
-
-use std::collections::{BTreeMap, HashMap};
-use std::hash::Hash;
-
-fn foo() {}
-
-fn insert_if_absent0<K: Eq + Hash, V>(m: &mut HashMap<K, V>, k: K, v: V) {
-    m.entry(k).or_insert(v);
-}
-
-fn main() {}
diff --git a/tests/ui/entry_fixable.rs b/tests/ui/entry_fixable.rs
deleted file mode 100644
index 55d5b21568d..00000000000
--- a/tests/ui/entry_fixable.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-// run-rustfix
-
-#![allow(unused, clippy::needless_pass_by_value)]
-#![warn(clippy::map_entry)]
-
-use std::collections::{BTreeMap, HashMap};
-use std::hash::Hash;
-
-fn foo() {}
-
-fn insert_if_absent0<K: Eq + Hash, V>(m: &mut HashMap<K, V>, k: K, v: V) {
-    if !m.contains_key(&k) {
-        m.insert(k, v);
-    }
-}
-
-fn main() {}
diff --git a/tests/ui/entry_fixable.stderr b/tests/ui/entry_fixable.stderr
deleted file mode 100644
index 87403200ced..00000000000
--- a/tests/ui/entry_fixable.stderr
+++ /dev/null
@@ -1,12 +0,0 @@
-error: usage of `contains_key` followed by `insert` on a `HashMap`
-  --> $DIR/entry_fixable.rs:12:5
-   |
-LL | /     if !m.contains_key(&k) {
-LL | |         m.insert(k, v);
-LL | |     }
-   | |_____^ help: consider using: `m.entry(k).or_insert(v);`
-   |
-   = note: `-D clippy::map-entry` implied by `-D warnings`
-
-error: aborting due to previous error
-
diff --git a/tests/ui/entry_unfixable.rs b/tests/ui/entry_unfixable.rs
index f530fc023cf..beb2d5c97b1 100644
--- a/tests/ui/entry_unfixable.rs
+++ b/tests/ui/entry_unfixable.rs
@@ -4,50 +4,14 @@
 use std::collections::{BTreeMap, HashMap};
 use std::hash::Hash;
 
-fn foo() {}
-
-fn insert_if_absent2<K: Eq + Hash, V>(m: &mut HashMap<K, V>, k: K, v: V) {
-    if !m.contains_key(&k) {
-        m.insert(k, v)
-    } else {
-        None
-    };
-}
-
-fn insert_if_present2<K: Eq + Hash, V>(m: &mut HashMap<K, V>, k: K, v: V) {
-    if m.contains_key(&k) {
-        None
-    } else {
-        m.insert(k, v)
-    };
-}
-
-fn insert_if_absent3<K: Eq + Hash, V>(m: &mut HashMap<K, V>, k: K, v: V) {
-    if !m.contains_key(&k) {
-        foo();
-        m.insert(k, v)
-    } else {
-        None
-    };
-}
-
-fn insert_if_present3<K: Eq + Hash, V>(m: &mut HashMap<K, V>, k: K, v: V) {
-    if m.contains_key(&k) {
-        None
-    } else {
-        foo();
-        m.insert(k, v)
+macro_rules! m {
+    ($map:expr, $key:expr, $value:expr) => {
+        $map.insert($key, $value)
     };
+    ($e:expr) => {{ $e }};
 }
 
-fn insert_in_btreemap<K: Ord, V>(m: &mut BTreeMap<K, V>, k: K, v: V) {
-    if !m.contains_key(&k) {
-        foo();
-        m.insert(k, v)
-    } else {
-        None
-    };
-}
+fn foo() {}
 
 // should not trigger
 fn insert_other_if_absent<K: Eq + Hash, V>(m: &mut HashMap<K, V>, k: K, o: K, v: V) {
@@ -70,4 +34,17 @@ fn insert_from_different_map2<K: Eq + Hash, V>(m: &mut HashMap<K, V>, n: &mut Ha
     }
 }
 
+fn insert_in_macro<K: Eq + Hash, V>(m: &mut HashMap<K, V>, k: K, v: V) {
+    if !m.contains_key(&k) {
+        m!(m, k, v);
+    }
+}
+
+fn use_map_then_insert<K: Eq + Hash, V>(m: &mut HashMap<K, V>, k: K, v: V) {
+    if !m.contains_key(&k) {
+        let _ = m.len();
+        m.insert(k, v);
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/entry_unfixable.stderr b/tests/ui/entry_unfixable.stderr
deleted file mode 100644
index e58c8d22dc4..00000000000
--- a/tests/ui/entry_unfixable.stderr
+++ /dev/null
@@ -1,57 +0,0 @@
-error: usage of `contains_key` followed by `insert` on a `HashMap`
-  --> $DIR/entry_unfixable.rs:10:5
-   |
-LL | /     if !m.contains_key(&k) {
-LL | |         m.insert(k, v)
-LL | |     } else {
-LL | |         None
-LL | |     };
-   | |_____^ consider using `m.entry(k)`
-   |
-   = note: `-D clippy::map-entry` implied by `-D warnings`
-
-error: usage of `contains_key` followed by `insert` on a `HashMap`
-  --> $DIR/entry_unfixable.rs:18:5
-   |
-LL | /     if m.contains_key(&k) {
-LL | |         None
-LL | |     } else {
-LL | |         m.insert(k, v)
-LL | |     };
-   | |_____^ consider using `m.entry(k)`
-
-error: usage of `contains_key` followed by `insert` on a `HashMap`
-  --> $DIR/entry_unfixable.rs:26:5
-   |
-LL | /     if !m.contains_key(&k) {
-LL | |         foo();
-LL | |         m.insert(k, v)
-LL | |     } else {
-LL | |         None
-LL | |     };
-   | |_____^ consider using `m.entry(k)`
-
-error: usage of `contains_key` followed by `insert` on a `HashMap`
-  --> $DIR/entry_unfixable.rs:35:5
-   |
-LL | /     if m.contains_key(&k) {
-LL | |         None
-LL | |     } else {
-LL | |         foo();
-LL | |         m.insert(k, v)
-LL | |     };
-   | |_____^ consider using `m.entry(k)`
-
-error: usage of `contains_key` followed by `insert` on a `BTreeMap`
-  --> $DIR/entry_unfixable.rs:44:5
-   |
-LL | /     if !m.contains_key(&k) {
-LL | |         foo();
-LL | |         m.insert(k, v)
-LL | |     } else {
-LL | |         None
-LL | |     };
-   | |_____^ consider using `m.entry(k)`
-
-error: aborting due to 5 previous errors
-
-- 
cgit 1.4.1-3-g733a5


From b63a5b56d6a37029970445ab5cbb77aeb5e19e84 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Thu, 25 Mar 2021 09:36:38 -0400
Subject: `map_entry` improvements Lint `if _.[!]contains_key(&_) { .. } else {
 .. }` so long as one of the branches contains an insertion.

---
 clippy_lints/src/entry.rs       |  81 ++++++++++++++++++++++-
 tests/ui/entry_with_else.fixed  |  73 +++++++++++++++++++++
 tests/ui/entry_with_else.rs     |  60 +++++++++++++++++
 tests/ui/entry_with_else.stderr | 142 ++++++++++++++++++++++++++++++++++++++++
 4 files changed, 354 insertions(+), 2 deletions(-)
 create mode 100644 tests/ui/entry_with_else.fixed
 create mode 100644 tests/ui/entry_with_else.rs
 create mode 100644 tests/ui/entry_with_else.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/entry.rs b/clippy_lints/src/entry.rs
index ca01d0a7f87..3e1d70b2e40 100644
--- a/clippy_lints/src/entry.rs
+++ b/clippy_lints/src/entry.rs
@@ -1,7 +1,7 @@
 use clippy_utils::{
     diagnostics::span_lint_and_sugg,
     is_expr_final_block_expr, is_expr_used_or_unified, match_def_path, paths, peel_hir_expr_while,
-    source::{snippet_indent, snippet_with_applicability, snippet_with_context},
+    source::{reindent_multiline, snippet_indent, snippet_with_applicability, snippet_with_context},
     SpanlessEq,
 };
 use rustc_errors::Applicability;
@@ -75,7 +75,84 @@ impl<'tcx> LateLintPass<'tcx> for HashMapPass {
         let mut app = Applicability::MachineApplicable;
         let map_str = snippet_with_context(cx, contains_expr.map.span, contains_expr.call_ctxt, "..", &mut app).0;
         let key_str = snippet_with_context(cx, contains_expr.key.span, contains_expr.call_ctxt, "..", &mut app).0;
-        let sugg = if !contains_expr.negated || else_expr.is_some() || then_search.insertions.is_empty() {
+        let sugg = if let Some(else_expr) = else_expr {
+            // if .. { .. } else { .. }
+            let else_search = match find_insert_calls(cx, &contains_expr, else_expr) {
+                Some(search) if !(then_search.insertions.is_empty() && search.insertions.is_empty()) => search,
+                _ => return,
+            };
+
+            if then_search.insertions.is_empty() || else_search.insertions.is_empty() {
+                // if .. { insert } else { .. } or if .. { .. } else { then } of
+                let (then_str, else_str, entry_kind) = if else_search.insertions.is_empty() {
+                    if contains_expr.negated {
+                        (
+                            then_search.snippet_vacant(cx, then_expr.span, &mut app),
+                            snippet_with_applicability(cx, else_expr.span, "{ .. }", &mut app),
+                            "Vacant(e)",
+                        )
+                    } else {
+                        (
+                            then_search.snippet_occupied(cx, then_expr.span, &mut app),
+                            snippet_with_applicability(cx, else_expr.span, "{ .. }", &mut app),
+                            "Occupied(mut e)",
+                        )
+                    }
+                } else if contains_expr.negated {
+                    (
+                        else_search.snippet_occupied(cx, else_expr.span, &mut app),
+                        snippet_with_applicability(cx, then_expr.span, "{ .. }", &mut app),
+                        "Occupied(mut e)",
+                    )
+                } else {
+                    (
+                        else_search.snippet_vacant(cx, else_expr.span, &mut app),
+                        snippet_with_applicability(cx, then_expr.span, "{ .. }", &mut app),
+                        "Vacant(e)",
+                    )
+                };
+                format!(
+                    "if let {}::{} = {}.entry({}) {} else {}",
+                    map_ty.entry_path(),
+                    entry_kind,
+                    map_str,
+                    key_str,
+                    then_str,
+                    else_str,
+                )
+            } else {
+                // if .. { insert } else { insert }
+                let (then_str, else_str, then_entry, else_entry) = if contains_expr.negated {
+                    (
+                        then_search.snippet_vacant(cx, then_expr.span, &mut app),
+                        else_search.snippet_occupied(cx, else_expr.span, &mut app),
+                        "Vacant(e)",
+                        "Occupied(mut e)",
+                    )
+                } else {
+                    (
+                        then_search.snippet_occupied(cx, then_expr.span, &mut app),
+                        else_search.snippet_vacant(cx, else_expr.span, &mut app),
+                        "Occupied(mut e)",
+                        "Vacant(e)",
+                    )
+                };
+                let indent_str = snippet_indent(cx, expr.span);
+                let indent_str = indent_str.as_deref().unwrap_or("");
+                format!(
+                    "match {}.entry({}) {{\n{indent}    {entry}::{} => {}\n\
+                        {indent}    {entry}::{} => {}\n{indent}}}",
+                    map_str,
+                    key_str,
+                    then_entry,
+                    reindent_multiline(then_str.into(), true, Some(4 + indent_str.len())),
+                    else_entry,
+                    reindent_multiline(else_str.into(), true, Some(4 + indent_str.len())),
+                    entry = map_ty.entry_path(),
+                    indent = indent_str,
+                )
+            }
+        } else if then_search.insertions.is_empty() || !contains_expr.negated {
             return;
         } else {
             // if .. { insert }
diff --git a/tests/ui/entry_with_else.fixed b/tests/ui/entry_with_else.fixed
new file mode 100644
index 00000000000..2332fa6313f
--- /dev/null
+++ b/tests/ui/entry_with_else.fixed
@@ -0,0 +1,73 @@
+// run-rustfix
+
+#![allow(unused, clippy::needless_pass_by_value, clippy::collapsible_if)]
+#![warn(clippy::map_entry)]
+
+use std::collections::{BTreeMap, HashMap};
+use std::hash::Hash;
+
+macro_rules! m {
+    ($e:expr) => {{ $e }};
+}
+
+fn foo() {}
+
+fn insert_if_absent0<K: Eq + Hash + Copy, V: Copy>(m: &mut HashMap<K, V>, k: K, v: V, v2: V) {
+    match m.entry(k) {
+        std::collections::hash_map::Entry::Vacant(e) => {
+            e.insert(v);
+        }
+        std::collections::hash_map::Entry::Occupied(mut e) => {
+            e.insert(v2);
+        }
+    }
+
+    match m.entry(k) {
+        std::collections::hash_map::Entry::Occupied(mut e) => {
+            e.insert(v);
+        }
+        std::collections::hash_map::Entry::Vacant(e) => {
+            e.insert(v2);
+        }
+    }
+
+    if let std::collections::hash_map::Entry::Vacant(e) = m.entry(k) {
+        e.insert(v);
+    } else {
+        foo();
+    }
+
+    if let std::collections::hash_map::Entry::Occupied(mut e) = m.entry(k) {
+        e.insert(v);
+    } else {
+        foo();
+    }
+
+    match m.entry(k) {
+        std::collections::hash_map::Entry::Vacant(e) => {
+            e.insert(v);
+        }
+        std::collections::hash_map::Entry::Occupied(mut e) => {
+            e.insert(v2);
+        }
+    }
+
+    match m.entry(k) {
+        std::collections::hash_map::Entry::Occupied(mut e) => {
+            if true { Some(e.insert(v)) } else { Some(e.insert(v2)) }
+        }
+        std::collections::hash_map::Entry::Vacant(e) => {
+            e.insert(v);
+            None
+        }
+    };
+
+    if let std::collections::hash_map::Entry::Occupied(mut e) = m.entry(k) {
+        foo();
+        Some(e.insert(v))
+    } else {
+        None
+    };
+}
+
+fn main() {}
diff --git a/tests/ui/entry_with_else.rs b/tests/ui/entry_with_else.rs
new file mode 100644
index 00000000000..2ff0c038efe
--- /dev/null
+++ b/tests/ui/entry_with_else.rs
@@ -0,0 +1,60 @@
+// run-rustfix
+
+#![allow(unused, clippy::needless_pass_by_value, clippy::collapsible_if)]
+#![warn(clippy::map_entry)]
+
+use std::collections::{BTreeMap, HashMap};
+use std::hash::Hash;
+
+macro_rules! m {
+    ($e:expr) => {{ $e }};
+}
+
+fn foo() {}
+
+fn insert_if_absent0<K: Eq + Hash + Copy, V: Copy>(m: &mut HashMap<K, V>, k: K, v: V, v2: V) {
+    if !m.contains_key(&k) {
+        m.insert(k, v);
+    } else {
+        m.insert(k, v2);
+    }
+
+    if m.contains_key(&k) {
+        m.insert(k, v);
+    } else {
+        m.insert(k, v2);
+    }
+
+    if !m.contains_key(&k) {
+        m.insert(k, v);
+    } else {
+        foo();
+    }
+
+    if !m.contains_key(&k) {
+        foo();
+    } else {
+        m.insert(k, v);
+    }
+
+    if !m.contains_key(&k) {
+        m.insert(k, v);
+    } else {
+        m.insert(k, v2);
+    }
+
+    if m.contains_key(&k) {
+        if true { m.insert(k, v) } else { m.insert(k, v2) }
+    } else {
+        m.insert(k, v)
+    };
+
+    if m.contains_key(&k) {
+        foo();
+        m.insert(k, v)
+    } else {
+        None
+    };
+}
+
+fn main() {}
diff --git a/tests/ui/entry_with_else.stderr b/tests/ui/entry_with_else.stderr
new file mode 100644
index 00000000000..6f62ff8d374
--- /dev/null
+++ b/tests/ui/entry_with_else.stderr
@@ -0,0 +1,142 @@
+error: usage of `contains_key` followed by `insert` on a `HashMap`
+  --> $DIR/entry_with_else.rs:16:5
+   |
+LL | /     if !m.contains_key(&k) {
+LL | |         m.insert(k, v);
+LL | |     } else {
+LL | |         m.insert(k, v2);
+LL | |     }
+   | |_____^
+   |
+   = note: `-D clippy::map-entry` implied by `-D warnings`
+help: try this
+   |
+LL |     match m.entry(k) {
+LL |         std::collections::hash_map::Entry::Vacant(e) => {
+LL |             e.insert(v);
+LL |         }
+LL |         std::collections::hash_map::Entry::Occupied(mut e) => {
+LL |             e.insert(v2);
+ ...
+
+error: usage of `contains_key` followed by `insert` on a `HashMap`
+  --> $DIR/entry_with_else.rs:22:5
+   |
+LL | /     if m.contains_key(&k) {
+LL | |         m.insert(k, v);
+LL | |     } else {
+LL | |         m.insert(k, v2);
+LL | |     }
+   | |_____^
+   |
+help: try this
+   |
+LL |     match m.entry(k) {
+LL |         std::collections::hash_map::Entry::Occupied(mut e) => {
+LL |             e.insert(v);
+LL |         }
+LL |         std::collections::hash_map::Entry::Vacant(e) => {
+LL |             e.insert(v2);
+ ...
+
+error: usage of `contains_key` followed by `insert` on a `HashMap`
+  --> $DIR/entry_with_else.rs:28:5
+   |
+LL | /     if !m.contains_key(&k) {
+LL | |         m.insert(k, v);
+LL | |     } else {
+LL | |         foo();
+LL | |     }
+   | |_____^
+   |
+help: try this
+   |
+LL |     if let std::collections::hash_map::Entry::Vacant(e) = m.entry(k) {
+LL |         e.insert(v);
+LL |     } else {
+LL |         foo();
+LL |     }
+   |
+
+error: usage of `contains_key` followed by `insert` on a `HashMap`
+  --> $DIR/entry_with_else.rs:34:5
+   |
+LL | /     if !m.contains_key(&k) {
+LL | |         foo();
+LL | |     } else {
+LL | |         m.insert(k, v);
+LL | |     }
+   | |_____^
+   |
+help: try this
+   |
+LL |     if let std::collections::hash_map::Entry::Occupied(mut e) = m.entry(k) {
+LL |         e.insert(v);
+LL |     } else {
+LL |         foo();
+LL |     }
+   |
+
+error: usage of `contains_key` followed by `insert` on a `HashMap`
+  --> $DIR/entry_with_else.rs:40:5
+   |
+LL | /     if !m.contains_key(&k) {
+LL | |         m.insert(k, v);
+LL | |     } else {
+LL | |         m.insert(k, v2);
+LL | |     }
+   | |_____^
+   |
+help: try this
+   |
+LL |     match m.entry(k) {
+LL |         std::collections::hash_map::Entry::Vacant(e) => {
+LL |             e.insert(v);
+LL |         }
+LL |         std::collections::hash_map::Entry::Occupied(mut e) => {
+LL |             e.insert(v2);
+ ...
+
+error: usage of `contains_key` followed by `insert` on a `HashMap`
+  --> $DIR/entry_with_else.rs:46:5
+   |
+LL | /     if m.contains_key(&k) {
+LL | |         if true { m.insert(k, v) } else { m.insert(k, v2) }
+LL | |     } else {
+LL | |         m.insert(k, v)
+LL | |     };
+   | |_____^
+   |
+help: try this
+   |
+LL |     match m.entry(k) {
+LL |         std::collections::hash_map::Entry::Occupied(mut e) => {
+LL |             if true { Some(e.insert(v)) } else { Some(e.insert(v2)) }
+LL |         }
+LL |         std::collections::hash_map::Entry::Vacant(e) => {
+LL |             e.insert(v);
+ ...
+
+error: usage of `contains_key` followed by `insert` on a `HashMap`
+  --> $DIR/entry_with_else.rs:52:5
+   |
+LL | /     if m.contains_key(&k) {
+LL | |         foo();
+LL | |         m.insert(k, v)
+LL | |     } else {
+LL | |         None
+LL | |     };
+   | |_____^
+   |
+help: try this
+   |
+LL |     if let std::collections::hash_map::Entry::Occupied(mut e) = m.entry(k) {
+LL |         foo();
+LL |         Some(e.insert(v))
+LL |     } else {
+LL |         None
+LL |     };
+   |
+
+error: aborting due to 7 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 3323ff71455c763a03353527d6203f90b53058fd Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Thu, 25 Mar 2021 09:47:56 -0400
Subject: `map_entry` improvements Suggest using `or_insert_with` when possible

---
 clippy_lints/src/entry.rs      | 220 ++++++++++++++++++++++++++++++++---------
 clippy_lints/src/manual_map.rs |  53 +---------
 clippy_utils/src/lib.rs        |  71 ++++++++++++-
 tests/ui/entry.fixed           |  52 +++++-----
 tests/ui/entry.rs              |   8 ++
 tests/ui/entry.stderr          |  65 +++++++-----
 6 files changed, 322 insertions(+), 147 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/entry.rs b/clippy_lints/src/entry.rs
index 3e1d70b2e40..0decb22a491 100644
--- a/clippy_lints/src/entry.rs
+++ b/clippy_lints/src/entry.rs
@@ -1,4 +1,5 @@
 use clippy_utils::{
+    can_move_expr_to_closure_no_visit,
     diagnostics::span_lint_and_sugg,
     is_expr_final_block_expr, is_expr_used_or_unified, match_def_path, paths, peel_hir_expr_while,
     source::{reindent_multiline, snippet_indent, snippet_with_applicability, snippet_with_context},
@@ -7,7 +8,7 @@ use clippy_utils::{
 use rustc_errors::Applicability;
 use rustc_hir::{
     intravisit::{walk_expr, ErasedMap, NestedVisitorMap, Visitor},
-    Expr, ExprKind, Guard, Local, Stmt, StmtKind, UnOp,
+    Block, Expr, ExprKind, Guard, HirId, Local, Stmt, StmtKind, UnOp,
 };
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -78,13 +79,13 @@ impl<'tcx> LateLintPass<'tcx> for HashMapPass {
         let sugg = if let Some(else_expr) = else_expr {
             // if .. { .. } else { .. }
             let else_search = match find_insert_calls(cx, &contains_expr, else_expr) {
-                Some(search) if !(then_search.insertions.is_empty() && search.insertions.is_empty()) => search,
+                Some(search) if !(then_search.edits.is_empty() && search.edits.is_empty()) => search,
                 _ => return,
             };
 
-            if then_search.insertions.is_empty() || else_search.insertions.is_empty() {
+            if then_search.edits.is_empty() || else_search.edits.is_empty() {
                 // if .. { insert } else { .. } or if .. { .. } else { then } of
-                let (then_str, else_str, entry_kind) = if else_search.insertions.is_empty() {
+                let (then_str, else_str, entry_kind) = if else_search.edits.is_empty() {
                     if contains_expr.negated {
                         (
                             then_search.snippet_vacant(cx, then_expr.span, &mut app),
@@ -152,37 +153,48 @@ impl<'tcx> LateLintPass<'tcx> for HashMapPass {
                     indent = indent_str,
                 )
             }
-        } else if then_search.insertions.is_empty() || !contains_expr.negated {
+        } else if then_search.edits.is_empty() {
+            // no insertions
             return;
         } else {
             // if .. { insert }
-            match then_search.as_single_insertion() {
-                Some(insertion) if !insertion.value.can_have_side_effects() => {
-                    format!(
-                        "{}.entry({}).or_insert({});",
-                        map_str,
-                        key_str,
-                        snippet_with_context(cx, insertion.value.span, insertion.call.span.ctxt(), "..", &mut app).0,
+            if !then_search.allow_insert_closure {
+                let (body_str, entry_kind) = if contains_expr.negated {
+                    (then_search.snippet_vacant(cx, then_expr.span, &mut app), "Vacant(e)")
+                } else {
+                    (
+                        then_search.snippet_occupied(cx, then_expr.span, &mut app),
+                        "Occupied(mut e)",
                     )
-                },
-                _ => {
-                    let (body_str, entry_kind) = if contains_expr.negated {
-                        (then_search.snippet_vacant(cx, then_expr.span, &mut app), "Vacant(e)")
+                };
+                format!(
+                    "if let {}::{} = {}.entry({}) {}",
+                    map_ty.entry_path(),
+                    entry_kind,
+                    map_str,
+                    key_str,
+                    body_str,
+                )
+            } else if let Some(insertion) = then_search.as_single_insertion() {
+                let value_str = snippet_with_context(cx, insertion.value.span, then_expr.span.ctxt(), "..", &mut app).0;
+                if contains_expr.negated {
+                    if insertion.value.can_have_side_effects() {
+                        format!("{}.entry({}).or_insert_with(|| {});", map_str, key_str, value_str)
                     } else {
-                        (
-                            then_search.snippet_occupied(cx, then_expr.span, &mut app),
-                            "Occupied(mut e)",
-                        )
-                    };
-                    format!(
-                        "if let {}::{} = {}.entry({}) {}",
-                        map_ty.entry_path(),
-                        entry_kind,
-                        map_str,
-                        key_str,
-                        body_str,
-                    )
-                },
+                        format!("{}.entry({}).or_insert({});", map_str, key_str, value_str)
+                    }
+                } else {
+                    // Todo: if let Some(v) = map.get_mut(k)
+                    return;
+                }
+            } else {
+                let block_str = then_search.snippet_closure(cx, then_expr.span, &mut app);
+                if contains_expr.negated {
+                    format!("{}.entry({}).or_insert_with(|| {});", map_str, key_str, block_str)
+                } else {
+                    // Todo: if let Some(v) = map.get_mut(k)
+                    return;
+                }
             }
         };
 
@@ -281,6 +293,19 @@ fn try_parse_insert(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<Inse
     }
 }
 
+/// An edit that will need to be made to move the expression to use the entry api
+#[derive(Clone, Copy)]
+enum Edit<'tcx> {
+    /// A semicolon that needs to be removed. Used to create a closure for `insert_with`.
+    RemoveSemi(Span),
+    /// An insertion into the map.
+    Insertion(Insertion<'tcx>),
+}
+impl Edit<'tcx> {
+    fn as_insertion(self) -> Option<Insertion<'tcx>> {
+        if let Self::Insertion(i) = self { Some(i) } else { None }
+    }
+}
 #[derive(Clone, Copy)]
 struct Insertion<'tcx> {
     call: &'tcx Expr<'tcx>,
@@ -303,12 +328,17 @@ struct InsertSearcher<'cx, 'i, 'tcx> {
     key: &'tcx Expr<'tcx>,
     /// The context of the top level block. All insert calls must be in the same context.
     ctxt: SyntaxContext,
+    /// Whether this expression can be safely moved into a closure.
+    allow_insert_closure: bool,
     /// Whether this expression can use the entry api.
     can_use_entry: bool,
+    /// Whether this expression is the final expression in this code path. This may be a statement.
+    in_tail_pos: bool,
     // A single insert expression has a slightly different suggestion.
     is_single_insert: bool,
     is_map_used: bool,
-    insertions: &'i mut Vec<Insertion<'tcx>>,
+    edits: &'i mut Vec<Edit<'tcx>>,
+    loops: Vec<HirId>,
 }
 impl<'tcx> InsertSearcher<'_, '_, 'tcx> {
     /// Visit the expression as a branch in control flow. Multiple insert calls can be used, but
@@ -316,11 +346,22 @@ impl<'tcx> InsertSearcher<'_, '_, 'tcx> {
     /// given expression.
     fn visit_cond_arm(&mut self, e: &'tcx Expr<'_>) -> bool {
         let is_map_used = self.is_map_used;
+        let in_tail_pos = self.in_tail_pos;
         self.visit_expr(e);
         let res = self.is_map_used;
         self.is_map_used = is_map_used;
+        self.in_tail_pos = in_tail_pos;
         res
     }
+
+    /// Visits an expression which is not itself in a tail position, but other sibling expressions
+    /// may be. e.g. if conditions
+    fn visit_non_tail_expr(&mut self, e: &'tcx Expr<'_>) {
+        let in_tail_pos = self.in_tail_pos;
+        self.in_tail_pos = false;
+        self.visit_expr(e);
+        self.in_tail_pos = in_tail_pos;
+    }
 }
 impl<'tcx> Visitor<'tcx> for InsertSearcher<'_, '_, 'tcx> {
     type Map = ErasedMap<'tcx>;
@@ -330,17 +371,63 @@ impl<'tcx> Visitor<'tcx> for InsertSearcher<'_, '_, 'tcx> {
 
     fn visit_stmt(&mut self, stmt: &'tcx Stmt<'_>) {
         match stmt.kind {
-            StmtKind::Semi(e) | StmtKind::Expr(e) => self.visit_expr(e),
+            StmtKind::Semi(e) => {
+                self.visit_expr(e);
+
+                if self.in_tail_pos && self.allow_insert_closure {
+                    // The spans are used to slice the top level expression into multiple parts. This requires that
+                    // they all come from the same part of the source code.
+                    if stmt.span.ctxt() == self.ctxt && e.span.ctxt() == self.ctxt {
+                        self.edits
+                            .push(Edit::RemoveSemi(stmt.span.trim_start(e.span).unwrap_or(DUMMY_SP)));
+                    } else {
+                        self.allow_insert_closure = false;
+                    }
+                }
+            },
+            StmtKind::Expr(e) => self.visit_expr(e),
             StmtKind::Local(Local { init: Some(e), .. }) => {
+                self.allow_insert_closure &= !self.in_tail_pos;
+                self.in_tail_pos = false;
                 self.is_single_insert = false;
                 self.visit_expr(e);
             },
             _ => {
+                self.allow_insert_closure &= !self.in_tail_pos;
                 self.is_single_insert = false;
             },
         }
     }
 
+    fn visit_block(&mut self, block: &'tcx Block<'_>) {
+        // If the block is in a tail position, then the last expression (possibly a statement) is in the
+        // tail position. The rest, however, are not.
+        match (block.stmts, block.expr) {
+            ([], None) => {
+                self.allow_insert_closure &= !self.in_tail_pos;
+            },
+            ([], Some(expr)) => self.visit_expr(expr),
+            (stmts, Some(expr)) => {
+                let in_tail_pos = self.in_tail_pos;
+                self.in_tail_pos = false;
+                for stmt in stmts {
+                    self.visit_stmt(stmt);
+                }
+                self.in_tail_pos = in_tail_pos;
+                self.visit_expr(expr);
+            },
+            ([stmts @ .., stmt], None) => {
+                let in_tail_pos = self.in_tail_pos;
+                self.in_tail_pos = false;
+                for stmt in stmts {
+                    self.visit_stmt(stmt);
+                }
+                self.in_tail_pos = in_tail_pos;
+                self.visit_stmt(stmt);
+            },
+        }
+    }
+
     fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
         if !self.can_use_entry {
             return;
@@ -357,15 +444,16 @@ impl<'tcx> Visitor<'tcx> for InsertSearcher<'_, '_, 'tcx> {
                     return;
                 }
 
-                self.insertions.push(Insertion {
+                self.edits.push(Edit::Insertion(Insertion {
                     call: expr,
                     value: insert_expr.value,
-                });
+                }));
                 self.is_map_used = true;
+                self.allow_insert_closure &= self.in_tail_pos;
 
                 // The value doesn't affect whether there is only a single insert expression.
                 let is_single_insert = self.is_single_insert;
-                self.visit_expr(insert_expr.value);
+                self.visit_non_tail_expr(insert_expr.value);
                 self.is_single_insert = is_single_insert;
             },
             _ if SpanlessEq::new(self.cx).eq_expr(self.map, expr) => {
@@ -374,7 +462,7 @@ impl<'tcx> Visitor<'tcx> for InsertSearcher<'_, '_, 'tcx> {
             _ => match expr.kind {
                 ExprKind::If(cond_expr, then_expr, Some(else_expr)) => {
                     self.is_single_insert = false;
-                    self.visit_expr(cond_expr);
+                    self.visit_non_tail_expr(cond_expr);
                     // Each branch may contain it's own insert expression.
                     let mut is_map_used = self.visit_cond_arm(then_expr);
                     is_map_used |= self.visit_cond_arm(else_expr);
@@ -382,31 +470,38 @@ impl<'tcx> Visitor<'tcx> for InsertSearcher<'_, '_, 'tcx> {
                 },
                 ExprKind::Match(scrutinee_expr, arms, _) => {
                     self.is_single_insert = false;
-                    self.visit_expr(scrutinee_expr);
+                    self.visit_non_tail_expr(scrutinee_expr);
                     // Each branch may contain it's own insert expression.
                     let mut is_map_used = self.is_map_used;
                     for arm in arms {
                         if let Some(Guard::If(guard) | Guard::IfLet(_, guard)) = arm.guard {
-                            self.visit_expr(guard)
+                            self.visit_non_tail_expr(guard)
                         }
                         is_map_used |= self.visit_cond_arm(arm.body);
                     }
                     self.is_map_used = is_map_used;
                 },
                 ExprKind::Loop(block, ..) => {
+                    self.loops.push(expr.hir_id);
+                    self.allow_insert_closure &= !self.in_tail_pos;
                     // Don't allow insertions inside of a loop.
-                    let insertions_len = self.insertions.len();
+                    let edit_len = self.edits.len();
                     self.visit_block(block);
-                    if self.insertions.len() != insertions_len {
+                    if self.edits.len() != edit_len {
                         self.can_use_entry = false;
                     }
+                    self.loops.pop();
                 },
                 ExprKind::Block(block, _) => self.visit_block(block),
                 ExprKind::InlineAsm(_) | ExprKind::LlvmInlineAsm(_) => {
                     self.can_use_entry = false;
                 },
                 _ => {
+                    self.allow_insert_closure &= !self.in_tail_pos;
+                    self.allow_insert_closure &= can_move_expr_to_closure_no_visit(self.cx, expr, &self.loops);
+                    // Sub expressions are no longer in the tail position.
                     self.is_single_insert = false;
+                    self.in_tail_pos = false;
                     walk_expr(self, expr);
                 },
             },
@@ -415,18 +510,19 @@ impl<'tcx> Visitor<'tcx> for InsertSearcher<'_, '_, 'tcx> {
 }
 
 struct InsertSearchResults<'tcx> {
-    insertions: Vec<Insertion<'tcx>>,
+    edits: Vec<Edit<'tcx>>,
+    allow_insert_closure: bool,
     is_single_insert: bool,
 }
 impl InsertSearchResults<'tcx> {
     fn as_single_insertion(&self) -> Option<Insertion<'tcx>> {
-        self.is_single_insert.then(|| self.insertions[0])
+        self.is_single_insert.then(|| self.edits[0].as_insertion().unwrap())
     }
 
     fn snippet_occupied(&self, cx: &LateContext<'_>, mut span: Span, app: &mut Applicability) -> String {
         let ctxt = span.ctxt();
         let mut res = String::new();
-        for insertion in self.insertions.iter() {
+        for insertion in self.edits.iter().filter_map(|e| e.as_insertion()) {
             res.push_str(&snippet_with_applicability(
                 cx,
                 span.until(insertion.call.span),
@@ -451,7 +547,7 @@ impl InsertSearchResults<'tcx> {
     fn snippet_vacant(&self, cx: &LateContext<'_>, mut span: Span, app: &mut Applicability) -> String {
         let ctxt = span.ctxt();
         let mut res = String::new();
-        for insertion in self.insertions.iter() {
+        for insertion in self.edits.iter().filter_map(|e| e.as_insertion()) {
             res.push_str(&snippet_with_applicability(
                 cx,
                 span.until(insertion.call.span),
@@ -485,27 +581,57 @@ impl InsertSearchResults<'tcx> {
         res.push_str(&snippet_with_applicability(cx, span, "..", app));
         res
     }
+
+    fn snippet_closure(&self, cx: &LateContext<'_>, mut span: Span, app: &mut Applicability) -> String {
+        let ctxt = span.ctxt();
+        let mut res = String::new();
+        for edit in &self.edits {
+            match *edit {
+                Edit::Insertion(insertion) => {
+                    res.push_str(&snippet_with_applicability(
+                        cx,
+                        span.until(insertion.call.span),
+                        "..",
+                        app,
+                    ));
+                    res.push_str(&snippet_with_context(cx, insertion.value.span, ctxt, "..", app).0);
+                    span = span.trim_start(insertion.call.span).unwrap_or(DUMMY_SP);
+                },
+                Edit::RemoveSemi(semi_span) => {
+                    res.push_str(&snippet_with_applicability(cx, span.until(semi_span), "..", app));
+                    span = span.trim_start(semi_span).unwrap_or(DUMMY_SP);
+                },
+            }
+        }
+        res.push_str(&snippet_with_applicability(cx, span, "..", app));
+        res
+    }
 }
 fn find_insert_calls(
     cx: &LateContext<'tcx>,
     contains_expr: &ContainsExpr<'tcx>,
     expr: &'tcx Expr<'_>,
 ) -> Option<InsertSearchResults<'tcx>> {
-    let mut insertions = Vec::new();
+    let mut edits = Vec::new();
     let mut s = InsertSearcher {
         cx,
         map: contains_expr.map,
         key: contains_expr.key,
         ctxt: expr.span.ctxt(),
-        insertions: &mut insertions,
+        edits: &mut edits,
         is_map_used: false,
+        allow_insert_closure: true,
         can_use_entry: true,
+        in_tail_pos: true,
         is_single_insert: true,
+        loops: Vec::new(),
     };
     s.visit_expr(expr);
+    let allow_insert_closure = s.allow_insert_closure;
     let is_single_insert = s.is_single_insert;
     s.can_use_entry.then(|| InsertSearchResults {
-        insertions,
+        edits,
+        allow_insert_closure,
         is_single_insert,
     })
 }
diff --git a/clippy_lints/src/manual_map.rs b/clippy_lints/src/manual_map.rs
index 29be0739977..3f8b976fcac 100644
--- a/clippy_lints/src/manual_map.rs
+++ b/clippy_lints/src/manual_map.rs
@@ -1,15 +1,13 @@
 use crate::{map_unit_fn::OPTION_MAP_UNIT_FN, matches::MATCH_AS_REF};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::{snippet_with_applicability, snippet_with_context};
-use clippy_utils::ty::{can_partially_move_ty, is_type_diagnostic_item, peel_mid_ty_refs_is_mutable};
-use clippy_utils::{in_constant, is_allowed, is_else_clause, is_lang_ctor, match_var, peel_hir_expr_refs};
+use clippy_utils::ty::{is_type_diagnostic_item, peel_mid_ty_refs_is_mutable};
+use clippy_utils::{can_move_expr_to_closure, in_constant, is_allowed, is_else_clause, is_lang_ctor, match_var, peel_hir_expr_refs};
 use rustc_ast::util::parser::PREC_POSTFIX;
 use rustc_errors::Applicability;
 use rustc_hir::LangItem::{OptionNone, OptionSome};
 use rustc_hir::{
-    def::Res,
-    intravisit::{walk_expr, ErasedMap, NestedVisitorMap, Visitor},
-    Arm, BindingAnnotation, Block, Expr, ExprKind, MatchSource, Mutability, Pat, PatKind, Path, QPath,
+    Arm, BindingAnnotation, Block, Expr, ExprKind, MatchSource, Mutability, Pat, PatKind, QPath,
 };
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
@@ -193,51 +191,6 @@ impl LateLintPass<'_> for ManualMap {
     }
 }
 
-// Checks if the expression can be moved into a closure as is.
-fn can_move_expr_to_closure(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> bool {
-    struct V<'cx, 'tcx> {
-        cx: &'cx LateContext<'tcx>,
-        make_closure: bool,
-    }
-    impl Visitor<'tcx> for V<'_, 'tcx> {
-        type Map = ErasedMap<'tcx>;
-        fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-            NestedVisitorMap::None
-        }
-
-        fn visit_expr(&mut self, e: &'tcx Expr<'_>) {
-            match e.kind {
-                ExprKind::Break(..)
-                | ExprKind::Continue(_)
-                | ExprKind::Ret(_)
-                | ExprKind::Yield(..)
-                | ExprKind::InlineAsm(_)
-                | ExprKind::LlvmInlineAsm(_) => {
-                    self.make_closure = false;
-                },
-                // Accessing a field of a local value can only be done if the type isn't
-                // partially moved.
-                ExprKind::Field(base_expr, _)
-                    if matches!(
-                        base_expr.kind,
-                        ExprKind::Path(QPath::Resolved(_, Path { res: Res::Local(_), .. }))
-                    ) && can_partially_move_ty(self.cx, self.cx.typeck_results().expr_ty(base_expr)) =>
-                {
-                    // TODO: check if the local has been partially moved. Assume it has for now.
-                    self.make_closure = false;
-                    return;
-                }
-                _ => (),
-            };
-            walk_expr(self, e);
-        }
-    }
-
-    let mut v = V { cx, make_closure: true };
-    v.visit_expr(expr);
-    v.make_closure
-}
-
 // Checks whether the expression could be passed as a function, or whether a closure is needed.
 // Returns the function to be passed to `map` if it exists.
 fn can_pass_as_func(cx: &LateContext<'tcx>, binding: Ident, expr: &'tcx Expr<'_>) -> Option<&'tcx Expr<'tcx>> {
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 0abee49f40c..5d6c1337be6 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -60,7 +60,7 @@ use rustc_data_structures::fx::FxHashMap;
 use rustc_hir as hir;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::def_id::{DefId, LOCAL_CRATE};
-use rustc_hir::intravisit::{self, NestedVisitorMap, Visitor};
+use rustc_hir::intravisit::{self, walk_expr, ErasedMap, NestedVisitorMap, Visitor};
 use rustc_hir::LangItem::{ResultErr, ResultOk};
 use rustc_hir::{
     def, Arm, BindingAnnotation, Block, Body, Constness, Destination, Expr, ExprKind, FnDecl, GenericArgs, HirId, Impl,
@@ -82,7 +82,7 @@ use rustc_span::{Span, DUMMY_SP};
 use rustc_target::abi::Integer;
 
 use crate::consts::{constant, Constant};
-use crate::ty::is_recursively_primitive_type;
+use crate::ty::{can_partially_move_ty, is_recursively_primitive_type};
 
 pub fn parse_msrv(msrv: &str, sess: Option<&Session>, span: Option<Span>) -> Option<RustcVersion> {
     if let Ok(version) = RustcVersion::parse(msrv) {
@@ -539,6 +539,73 @@ pub fn trait_ref_of_method<'tcx>(cx: &LateContext<'tcx>, hir_id: HirId) -> Optio
     None
 }
 
+/// Checks if the top level expression can be moved into a closure as is.
+pub fn can_move_expr_to_closure_no_visit(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, jump_targets: &[HirId]) -> bool {
+    match expr.kind {
+        ExprKind::Break(Destination { target_id: Ok(id), .. }, _)
+        | ExprKind::Continue(Destination { target_id: Ok(id), .. })
+            if jump_targets.contains(&id) =>
+        {
+            true
+        },
+        ExprKind::Break(..)
+        | ExprKind::Continue(_)
+        | ExprKind::Ret(_)
+        | ExprKind::Yield(..)
+        | ExprKind::InlineAsm(_)
+        | ExprKind::LlvmInlineAsm(_) => false,
+        // Accessing a field of a local value can only be done if the type isn't
+        // partially moved.
+        ExprKind::Field(base_expr, _)
+            if matches!(
+                base_expr.kind,
+                ExprKind::Path(QPath::Resolved(_, Path { res: Res::Local(_), .. }))
+            ) && can_partially_move_ty(cx, cx.typeck_results().expr_ty(base_expr)) =>
+        {
+            // TODO: check if the local has been partially moved. Assume it has for now.
+            false
+        }
+        _ => true,
+    }
+}
+
+/// Checks if the expression can be moved into a closure as is.
+pub fn can_move_expr_to_closure(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> bool {
+    struct V<'cx, 'tcx> {
+        cx: &'cx LateContext<'tcx>,
+        loops: Vec<HirId>,
+        allow_closure: bool,
+    }
+    impl Visitor<'tcx> for V<'_, 'tcx> {
+        type Map = ErasedMap<'tcx>;
+        fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+            NestedVisitorMap::None
+        }
+
+        fn visit_expr(&mut self, e: &'tcx Expr<'_>) {
+            if !self.allow_closure {
+                return;
+            }
+            if let ExprKind::Loop(b, ..) = e.kind {
+                self.loops.push(e.hir_id);
+                self.visit_block(b);
+                self.loops.pop();
+            } else {
+                self.allow_closure &= can_move_expr_to_closure_no_visit(self.cx, e, &self.loops);
+                walk_expr(self, e);
+            }
+        }
+    }
+
+    let mut v = V {
+        cx,
+        allow_closure: true,
+        loops: Vec::new(),
+    };
+    v.visit_expr(expr);
+    v.allow_closure
+}
+
 /// Returns the method names and argument list of nested method call expressions that make up
 /// `expr`. method/span lists are sorted with the most recent call first.
 pub fn method_calls<'tcx>(
diff --git a/tests/ui/entry.fixed b/tests/ui/entry.fixed
index 60371c9833c..524f2132797 100644
--- a/tests/ui/entry.fixed
+++ b/tests/ui/entry.fixed
@@ -15,13 +15,21 @@ fn foo() {}
 fn hash_map<K: Eq + Hash + Copy, V: Copy>(m: &mut HashMap<K, V>, k: K, v: V, v2: V) {
     m.entry(k).or_insert(v);
 
-    if let std::collections::hash_map::Entry::Vacant(e) = m.entry(k) {
+    m.entry(k).or_insert_with(|| {
         if true {
-            e.insert(v);
+            v
         } else {
-            e.insert(v2);
+            v2
         }
-    }
+    });
+
+    m.entry(k).or_insert_with(|| {
+        if true {
+            v
+        } else {
+            v2
+        }
+    });
 
     if let std::collections::hash_map::Entry::Vacant(e) = m.entry(k) {
         if true {
@@ -32,21 +40,21 @@ fn hash_map<K: Eq + Hash + Copy, V: Copy>(m: &mut HashMap<K, V>, k: K, v: V, v2:
         }
     }
 
-    if let std::collections::hash_map::Entry::Vacant(e) = m.entry(k) {
+    m.entry(k).or_insert_with(|| {
         foo();
-        e.insert(v);
-    }
+        v
+    });
 
-    if let std::collections::hash_map::Entry::Vacant(e) = m.entry(k) {
+    m.entry(k).or_insert_with(|| {
         match 0 {
             1 if true => {
-                e.insert(v);
+                v
             },
             _ => {
-                e.insert(v2);
+                v2
             },
-        };
-    }
+        }
+    });
 
     if let std::collections::hash_map::Entry::Vacant(e) = m.entry(k) {
         match 0 {
@@ -60,35 +68,33 @@ fn hash_map<K: Eq + Hash + Copy, V: Copy>(m: &mut HashMap<K, V>, k: K, v: V, v2:
         };
     }
 
-    if let std::collections::hash_map::Entry::Vacant(e) = m.entry(k) {
+    m.entry(k).or_insert_with(|| {
         foo();
         match 0 {
             0 if false => {
-                e.insert(v);
+                v
             },
             1 => {
                 foo();
-                e.insert(v);
+                v
             },
             2 | 3 => {
                 for _ in 0..2 {
                     foo();
                 }
                 if true {
-                    e.insert(v);
+                    v
                 } else {
-                    e.insert(v2);
-                };
+                    v2
+                }
             },
             _ => {
-                e.insert(v2);
+                v2
             },
         }
-    }
+    });
 
-    if let std::collections::hash_map::Entry::Vacant(e) = m.entry(m!(k)) {
-        e.insert(m!(v));
-    }
+    m.entry(m!(k)).or_insert_with(|| m!(v));
 }
 
 fn btree_map<K: Eq + Ord + Copy, V: Copy>(m: &mut BTreeMap<K, V>, k: K, v: V, v2: V) {
diff --git a/tests/ui/entry.rs b/tests/ui/entry.rs
index 4d3e241de78..ff4890eeeb6 100644
--- a/tests/ui/entry.rs
+++ b/tests/ui/entry.rs
@@ -25,6 +25,14 @@ fn hash_map<K: Eq + Hash + Copy, V: Copy>(m: &mut HashMap<K, V>, k: K, v: V, v2:
         }
     }
 
+    if !m.contains_key(&k) {
+        if true {
+            m.insert(k, v)
+        } else {
+            m.insert(k, v2)
+        };
+    }
+
     if !m.contains_key(&k) {
         if true {
             m.insert(k, v);
diff --git a/tests/ui/entry.stderr b/tests/ui/entry.stderr
index ab108ed6861..63b5f5a0b2c 100644
--- a/tests/ui/entry.stderr
+++ b/tests/ui/entry.stderr
@@ -22,11 +22,11 @@ LL | |     }
    |
 help: try this
    |
-LL |     if let std::collections::hash_map::Entry::Vacant(e) = m.entry(k) {
+LL |     m.entry(k).or_insert_with(|| {
 LL |         if true {
-LL |             e.insert(v);
+LL |             v
 LL |         } else {
-LL |             e.insert(v2);
+LL |             v2
 LL |         }
  ...
 
@@ -35,6 +35,28 @@ error: usage of `contains_key` followed by `insert` on a `HashMap`
    |
 LL | /     if !m.contains_key(&k) {
 LL | |         if true {
+LL | |             m.insert(k, v)
+LL | |         } else {
+LL | |             m.insert(k, v2)
+LL | |         };
+LL | |     }
+   | |_____^
+   |
+help: try this
+   |
+LL |     m.entry(k).or_insert_with(|| {
+LL |         if true {
+LL |             v
+LL |         } else {
+LL |             v2
+LL |         }
+ ...
+
+error: usage of `contains_key` followed by `insert` on a `HashMap`
+  --> $DIR/entry.rs:36:5
+   |
+LL | /     if !m.contains_key(&k) {
+LL | |         if true {
 LL | |             m.insert(k, v);
 LL | |         } else {
 ...  |
@@ -53,7 +75,7 @@ LL |             return;
  ...
 
 error: usage of `contains_key` followed by `insert` on a `HashMap`
-  --> $DIR/entry.rs:37:5
+  --> $DIR/entry.rs:45:5
    |
 LL | /     if !m.contains_key(&k) {
 LL | |         foo();
@@ -63,14 +85,14 @@ LL | |     }
    |
 help: try this
    |
-LL |     if let std::collections::hash_map::Entry::Vacant(e) = m.entry(k) {
+LL |     m.entry(k).or_insert_with(|| {
 LL |         foo();
-LL |         e.insert(v);
-LL |     }
+LL |         v
+LL |     });
    |
 
 error: usage of `contains_key` followed by `insert` on a `HashMap`
-  --> $DIR/entry.rs:42:5
+  --> $DIR/entry.rs:50:5
    |
 LL | /     if !m.contains_key(&k) {
 LL | |         match 0 {
@@ -83,16 +105,16 @@ LL | |     }
    |
 help: try this
    |
-LL |     if let std::collections::hash_map::Entry::Vacant(e) = m.entry(k) {
+LL |     m.entry(k).or_insert_with(|| {
 LL |         match 0 {
 LL |             1 if true => {
-LL |                 e.insert(v);
+LL |                 v
 LL |             },
 LL |             _ => {
  ...
 
 error: usage of `contains_key` followed by `insert` on a `HashMap`
-  --> $DIR/entry.rs:53:5
+  --> $DIR/entry.rs:61:5
    |
 LL | /     if !m.contains_key(&k) {
 LL | |         match 0 {
@@ -114,7 +136,7 @@ LL |             },
  ...
 
 error: usage of `contains_key` followed by `insert` on a `HashMap`
-  --> $DIR/entry.rs:65:5
+  --> $DIR/entry.rs:73:5
    |
 LL | /     if !m.contains_key(&k) {
 LL | |         foo();
@@ -127,31 +149,24 @@ LL | |     }
    |
 help: try this
    |
-LL |     if let std::collections::hash_map::Entry::Vacant(e) = m.entry(k) {
+LL |     m.entry(k).or_insert_with(|| {
 LL |         foo();
 LL |         match 0 {
 LL |             0 if false => {
-LL |                 e.insert(v);
+LL |                 v
 LL |             },
  ...
 
 error: usage of `contains_key` followed by `insert` on a `HashMap`
-  --> $DIR/entry.rs:91:5
+  --> $DIR/entry.rs:99:5
    |
 LL | /     if !m.contains_key(&m!(k)) {
 LL | |         m.insert(m!(k), m!(v));
 LL | |     }
-   | |_____^
-   |
-help: try this
-   |
-LL |     if let std::collections::hash_map::Entry::Vacant(e) = m.entry(m!(k)) {
-LL |         e.insert(m!(v));
-LL |     }
-   |
+   | |_____^ help: try this: `m.entry(m!(k)).or_insert_with(|| m!(v));`
 
 error: usage of `contains_key` followed by `insert` on a `BTreeMap`
-  --> $DIR/entry.rs:97:5
+  --> $DIR/entry.rs:105:5
    |
 LL | /     if !m.contains_key(&k) {
 LL | |         m.insert(k, v);
@@ -167,5 +182,5 @@ LL |         foo();
 LL |     }
    |
 
-error: aborting due to 9 previous errors
+error: aborting due to 10 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From bcf348800751e8a03fdbaa49130e53a463e3a441 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Mon, 29 Mar 2021 20:17:03 -0400
Subject: Minor cleanup of `map_entry` and a few additional tests.

---
 clippy_lints/src/entry.rs           | 187 ++++++++++++++++++------------------
 clippy_lints/src/manual_map.rs      |   8 +-
 clippy_utils/src/lib.rs             |  59 +++---------
 tests/ui/entry.fixed                |  58 ++++++++++-
 tests/ui/entry.rs                   |  58 ++++++++++-
 tests/ui/entry.stderr               |  30 +++---
 tests/ui/entry_unfixable.rs         |  50 ----------
 tests/ui/string_lit_as_bytes.fixed  |   2 +-
 tests/ui/string_lit_as_bytes.rs     |   2 +-
 tests/ui/string_lit_as_bytes.stderr |   4 +-
 10 files changed, 238 insertions(+), 220 deletions(-)
 delete mode 100644 tests/ui/entry_unfixable.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/entry.rs b/clippy_lints/src/entry.rs
index 0decb22a491..8db5050a5ac 100644
--- a/clippy_lints/src/entry.rs
+++ b/clippy_lints/src/entry.rs
@@ -77,40 +77,33 @@ impl<'tcx> LateLintPass<'tcx> for HashMapPass {
         let map_str = snippet_with_context(cx, contains_expr.map.span, contains_expr.call_ctxt, "..", &mut app).0;
         let key_str = snippet_with_context(cx, contains_expr.key.span, contains_expr.call_ctxt, "..", &mut app).0;
         let sugg = if let Some(else_expr) = else_expr {
-            // if .. { .. } else { .. }
             let else_search = match find_insert_calls(cx, &contains_expr, else_expr) {
-                Some(search) if !(then_search.edits.is_empty() && search.edits.is_empty()) => search,
-                _ => return,
+                Some(search) => search,
+                None => return,
             };
 
-            if then_search.edits.is_empty() || else_search.edits.is_empty() {
-                // if .. { insert } else { .. } or if .. { .. } else { then } of
-                let (then_str, else_str, entry_kind) = if else_search.edits.is_empty() {
-                    if contains_expr.negated {
-                        (
-                            then_search.snippet_vacant(cx, then_expr.span, &mut app),
-                            snippet_with_applicability(cx, else_expr.span, "{ .. }", &mut app),
-                            "Vacant(e)",
-                        )
-                    } else {
-                        (
-                            then_search.snippet_occupied(cx, then_expr.span, &mut app),
-                            snippet_with_applicability(cx, else_expr.span, "{ .. }", &mut app),
-                            "Occupied(mut e)",
-                        )
-                    }
-                } else if contains_expr.negated {
-                    (
+            if then_search.edits.is_empty() && else_search.edits.is_empty() {
+                // No insertions
+                return;
+            } else if then_search.edits.is_empty() || else_search.edits.is_empty() {
+                // if .. { insert } else { .. } or if .. { .. } else { insert }
+                let ((then_str, entry_kind), else_str) = match (else_search.edits.is_empty(), contains_expr.negated) {
+                    (true, true) => (
+                        then_search.snippet_vacant(cx, then_expr.span, &mut app),
+                        snippet_with_applicability(cx, else_expr.span, "{ .. }", &mut app),
+                    ),
+                    (true, false) => (
+                        then_search.snippet_occupied(cx, then_expr.span, &mut app),
+                        snippet_with_applicability(cx, else_expr.span, "{ .. }", &mut app),
+                    ),
+                    (false, true) => (
                         else_search.snippet_occupied(cx, else_expr.span, &mut app),
                         snippet_with_applicability(cx, then_expr.span, "{ .. }", &mut app),
-                        "Occupied(mut e)",
-                    )
-                } else {
-                    (
+                    ),
+                    (false, false) => (
                         else_search.snippet_vacant(cx, else_expr.span, &mut app),
                         snippet_with_applicability(cx, then_expr.span, "{ .. }", &mut app),
-                        "Vacant(e)",
-                    )
+                    ),
                 };
                 format!(
                     "if let {}::{} = {}.entry({}) {} else {}",
@@ -123,19 +116,15 @@ impl<'tcx> LateLintPass<'tcx> for HashMapPass {
                 )
             } else {
                 // if .. { insert } else { insert }
-                let (then_str, else_str, then_entry, else_entry) = if contains_expr.negated {
+                let ((then_str, then_entry), (else_str, else_entry)) = if contains_expr.negated {
                     (
                         then_search.snippet_vacant(cx, then_expr.span, &mut app),
                         else_search.snippet_occupied(cx, else_expr.span, &mut app),
-                        "Vacant(e)",
-                        "Occupied(mut e)",
                     )
                 } else {
                     (
                         then_search.snippet_occupied(cx, then_expr.span, &mut app),
                         else_search.snippet_vacant(cx, else_expr.span, &mut app),
-                        "Occupied(mut e)",
-                        "Vacant(e)",
                     )
                 };
                 let indent_str = snippet_indent(cx, expr.span);
@@ -153,19 +142,18 @@ impl<'tcx> LateLintPass<'tcx> for HashMapPass {
                     indent = indent_str,
                 )
             }
-        } else if then_search.edits.is_empty() {
-            // no insertions
-            return;
         } else {
+            if then_search.edits.is_empty() {
+                // no insertions
+                return;
+            }
+
             // if .. { insert }
             if !then_search.allow_insert_closure {
                 let (body_str, entry_kind) = if contains_expr.negated {
-                    (then_search.snippet_vacant(cx, then_expr.span, &mut app), "Vacant(e)")
+                    then_search.snippet_vacant(cx, then_expr.span, &mut app)
                 } else {
-                    (
-                        then_search.snippet_occupied(cx, then_expr.span, &mut app),
-                        "Occupied(mut e)",
-                    )
+                    then_search.snippet_occupied(cx, then_expr.span, &mut app)
                 };
                 format!(
                     "if let {}::{} = {}.entry({}) {}",
@@ -184,7 +172,8 @@ impl<'tcx> LateLintPass<'tcx> for HashMapPass {
                         format!("{}.entry({}).or_insert({});", map_str, key_str, value_str)
                     }
                 } else {
-                    // Todo: if let Some(v) = map.get_mut(k)
+                    // TODO: suggest using `if let Some(v) = map.get_mut(k) { .. }` here.
+                    // This would need to be a different lint.
                     return;
                 }
             } else {
@@ -192,7 +181,8 @@ impl<'tcx> LateLintPass<'tcx> for HashMapPass {
                 if contains_expr.negated {
                     format!("{}.entry({}).or_insert_with(|| {});", map_str, key_str, block_str)
                 } else {
-                    // Todo: if let Some(v) = map.get_mut(k)
+                    // TODO: suggest using `if let Some(v) = map.get_mut(k) { .. }` here.
+                    // This would need to be a different lint.
                     return;
                 }
             }
@@ -222,7 +212,7 @@ impl MapType {
             Self::BTree => "BTreeMap",
         }
     }
-    fn entry_path(self) -> &'staic str {
+    fn entry_path(self) -> &'static str {
         match self {
             Self::Hash => "std::collections::hash_map::Entry",
             Self::BTree => "std::collections::btree_map::Entry",
@@ -312,15 +302,16 @@ struct Insertion<'tcx> {
     value: &'tcx Expr<'tcx>,
 }
 
-// This visitor needs to do a multiple things:
-// * Find all usages of the map. Only insertions into the map which share the same key are
-//   permitted. All others will prevent the lint.
-// * Determine if the final statement executed is an insertion. This is needed to use `insert_with`.
-// * Determine if there's any sub-expression that can't be placed in a closure.
-// * Determine if there's only a single insert statement. This is needed to give better suggestions.
-
+/// This visitor needs to do a multiple things:
+/// * Find all usages of the map. An insertion can only be made before any other usages of the map.
+/// * Determine if there's an insertion using the same key. There's no need for the entry api
+///   otherwise.
+/// * Determine if the final statement executed is an insertion. This is needed to use
+///   `or_insert_with`.
+/// * Determine if there's any sub-expression that can't be placed in a closure.
+/// * Determine if there's only a single insert statement. `or_insert` can be used in this case.
 #[allow(clippy::struct_excessive_bools)]
-struct InsertSearcher<'cx, 'i, 'tcx> {
+struct InsertSearcher<'cx, 'tcx> {
     cx: &'cx LateContext<'tcx>,
     /// The map expression used in the contains call.
     map: &'tcx Expr<'tcx>,
@@ -334,13 +325,16 @@ struct InsertSearcher<'cx, 'i, 'tcx> {
     can_use_entry: bool,
     /// Whether this expression is the final expression in this code path. This may be a statement.
     in_tail_pos: bool,
-    // A single insert expression has a slightly different suggestion.
+    // Is this expression a single insert. A slightly better suggestion can be made in this case.
     is_single_insert: bool,
+    /// If the visitor has seen the map being used.
     is_map_used: bool,
-    edits: &'i mut Vec<Edit<'tcx>>,
+    /// The locations where changes need to be made for the suggestion.
+    edits: Vec<Edit<'tcx>>,
+    /// A stack of loops the visitor is currently in.
     loops: Vec<HirId>,
 }
-impl<'tcx> InsertSearcher<'_, '_, 'tcx> {
+impl<'tcx> InsertSearcher<'_, 'tcx> {
     /// Visit the expression as a branch in control flow. Multiple insert calls can be used, but
     /// only if they are on separate code paths. This will return whether the map was used in the
     /// given expression.
@@ -363,7 +357,7 @@ impl<'tcx> InsertSearcher<'_, '_, 'tcx> {
         self.in_tail_pos = in_tail_pos;
     }
 }
-impl<'tcx> Visitor<'tcx> for InsertSearcher<'_, '_, 'tcx> {
+impl<'tcx> Visitor<'tcx> for InsertSearcher<'_, 'tcx> {
     type Map = ErasedMap<'tcx>;
     fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
         NestedVisitorMap::None
@@ -483,6 +477,7 @@ impl<'tcx> Visitor<'tcx> for InsertSearcher<'_, '_, 'tcx> {
                 },
                 ExprKind::Loop(block, ..) => {
                     self.loops.push(expr.hir_id);
+                    self.is_single_insert = false;
                     self.allow_insert_closure &= !self.in_tail_pos;
                     // Don't allow insertions inside of a loop.
                     let edit_len = self.edits.len();
@@ -519,7 +514,13 @@ impl InsertSearchResults<'tcx> {
         self.is_single_insert.then(|| self.edits[0].as_insertion().unwrap())
     }
 
-    fn snippet_occupied(&self, cx: &LateContext<'_>, mut span: Span, app: &mut Applicability) -> String {
+    fn snippet(
+        &self,
+        cx: &LateContext<'_>,
+        mut span: Span,
+        app: &mut Applicability,
+        write_wrapped: impl Fn(&mut String, Insertion<'_>, SyntaxContext, &mut Applicability),
+    ) -> String {
         let ctxt = span.ctxt();
         let mut res = String::new();
         for insertion in self.edits.iter().filter_map(|e| e.as_insertion()) {
@@ -530,13 +531,13 @@ impl InsertSearchResults<'tcx> {
                 app,
             ));
             if is_expr_used_or_unified(cx.tcx, insertion.call) {
-                res.push_str("Some(e.insert(");
-                res.push_str(&snippet_with_context(cx, insertion.value.span, ctxt, "..", app).0);
-                res.push_str("))");
+                write_wrapped(&mut res, insertion, ctxt, app);
             } else {
-                res.push_str("e.insert(");
-                res.push_str(&snippet_with_context(cx, insertion.value.span, ctxt, "..", app).0);
-                res.push(')');
+                let _ = write!(
+                    res,
+                    "e.insert({})",
+                    snippet_with_context(cx, insertion.value.span, ctxt, "..", app).0
+                );
             }
             span = span.trim_start(insertion.call.span).unwrap_or(DUMMY_SP);
         }
@@ -544,42 +545,41 @@ impl InsertSearchResults<'tcx> {
         res
     }
 
-    fn snippet_vacant(&self, cx: &LateContext<'_>, mut span: Span, app: &mut Applicability) -> String {
-        let ctxt = span.ctxt();
-        let mut res = String::new();
-        for insertion in self.edits.iter().filter_map(|e| e.as_insertion()) {
-            res.push_str(&snippet_with_applicability(
-                cx,
-                span.until(insertion.call.span),
-                "..",
-                app,
-            ));
-            if is_expr_used_or_unified(cx.tcx, insertion.call) {
-                if is_expr_final_block_expr(cx.tcx, insertion.call) {
-                    let _ = write!(
+    fn snippet_occupied(&self, cx: &LateContext<'_>, span: Span, app: &mut Applicability) -> (String, &'static str) {
+        (
+            self.snippet(cx, span, app, |res, insertion, ctxt, app| {
+                // Insertion into a map would return `Some(&mut value)`, but the entry returns `&mut value`
+                let _ = write!(
+                    res,
+                    "Some(e.insert({}))",
+                    snippet_with_context(cx, insertion.value.span, ctxt, "..", app).0
+                );
+            }),
+            "Occupied(mut e)",
+        )
+    }
+
+    fn snippet_vacant(&self, cx: &LateContext<'_>, span: Span, app: &mut Applicability) -> (String, &'static str) {
+        (
+            self.snippet(cx, span, app, |res, insertion, ctxt, app| {
+                // Insertion into a map would return `None`, but the entry returns a mutable reference.
+                let _ = if is_expr_final_block_expr(cx.tcx, insertion.call) {
+                    write!(
                         res,
                         "e.insert({});\n{}None",
                         snippet_with_context(cx, insertion.value.span, ctxt, "..", app).0,
                         snippet_indent(cx, insertion.call.span).as_deref().unwrap_or(""),
-                    );
+                    )
                 } else {
-                    let _ = write!(
+                    write!(
                         res,
                         "{{ e.insert({}); None }}",
                         snippet_with_context(cx, insertion.value.span, ctxt, "..", app).0,
-                    );
-                }
-            } else {
-                let _ = write!(
-                    res,
-                    "e.insert({})",
-                    snippet_with_context(cx, insertion.value.span, ctxt, "..", app).0,
-                );
-            }
-            span = span.trim_start(insertion.call.span).unwrap_or(DUMMY_SP);
-        }
-        res.push_str(&snippet_with_applicability(cx, span, "..", app));
-        res
+                    )
+                };
+            }),
+            "Vacant(e)",
+        )
     }
 
     fn snippet_closure(&self, cx: &LateContext<'_>, mut span: Span, app: &mut Applicability) -> String {
@@ -588,6 +588,7 @@ impl InsertSearchResults<'tcx> {
         for edit in &self.edits {
             match *edit {
                 Edit::Insertion(insertion) => {
+                    // Cut out the value from `map.insert(key, value)`
                     res.push_str(&snippet_with_applicability(
                         cx,
                         span.until(insertion.call.span),
@@ -598,6 +599,7 @@ impl InsertSearchResults<'tcx> {
                     span = span.trim_start(insertion.call.span).unwrap_or(DUMMY_SP);
                 },
                 Edit::RemoveSemi(semi_span) => {
+                    // Cut out the semicolon. This allows the value to be returned from the closure.
                     res.push_str(&snippet_with_applicability(cx, span.until(semi_span), "..", app));
                     span = span.trim_start(semi_span).unwrap_or(DUMMY_SP);
                 },
@@ -607,18 +609,18 @@ impl InsertSearchResults<'tcx> {
         res
     }
 }
+
 fn find_insert_calls(
     cx: &LateContext<'tcx>,
     contains_expr: &ContainsExpr<'tcx>,
     expr: &'tcx Expr<'_>,
 ) -> Option<InsertSearchResults<'tcx>> {
-    let mut edits = Vec::new();
     let mut s = InsertSearcher {
         cx,
         map: contains_expr.map,
         key: contains_expr.key,
         ctxt: expr.span.ctxt(),
-        edits: &mut edits,
+        edits: Vec::new(),
         is_map_used: false,
         allow_insert_closure: true,
         can_use_entry: true,
@@ -629,6 +631,7 @@ fn find_insert_calls(
     s.visit_expr(expr);
     let allow_insert_closure = s.allow_insert_closure;
     let is_single_insert = s.is_single_insert;
+    let edits = s.edits;
     s.can_use_entry.then(|| InsertSearchResults {
         edits,
         allow_insert_closure,
diff --git a/clippy_lints/src/manual_map.rs b/clippy_lints/src/manual_map.rs
index 3f8b976fcac..d9b75149b9f 100644
--- a/clippy_lints/src/manual_map.rs
+++ b/clippy_lints/src/manual_map.rs
@@ -2,13 +2,13 @@ use crate::{map_unit_fn::OPTION_MAP_UNIT_FN, matches::MATCH_AS_REF};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::{snippet_with_applicability, snippet_with_context};
 use clippy_utils::ty::{is_type_diagnostic_item, peel_mid_ty_refs_is_mutable};
-use clippy_utils::{can_move_expr_to_closure, in_constant, is_allowed, is_else_clause, is_lang_ctor, match_var, peel_hir_expr_refs};
+use clippy_utils::{
+    can_move_expr_to_closure, in_constant, is_allowed, is_else_clause, is_lang_ctor, match_var, peel_hir_expr_refs,
+};
 use rustc_ast::util::parser::PREC_POSTFIX;
 use rustc_errors::Applicability;
 use rustc_hir::LangItem::{OptionNone, OptionSome};
-use rustc_hir::{
-    Arm, BindingAnnotation, Block, Expr, ExprKind, MatchSource, Mutability, Pat, PatKind, QPath,
-};
+use rustc_hir::{Arm, BindingAnnotation, Block, Expr, ExprKind, MatchSource, Mutability, Pat, PatKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 5d6c1337be6..90a6fd225ab 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -64,8 +64,8 @@ use rustc_hir::intravisit::{self, walk_expr, ErasedMap, NestedVisitorMap, Visito
 use rustc_hir::LangItem::{ResultErr, ResultOk};
 use rustc_hir::{
     def, Arm, BindingAnnotation, Block, Body, Constness, Destination, Expr, ExprKind, FnDecl, GenericArgs, HirId, Impl,
-    ImplItem, ImplItemKind, Item, ItemKind, LangItem, MatchSource, Node, Param, Pat, PatKind, Path, PathSegment, QPath,
-    Stmt, StmtKind, TraitItem, TraitItemKind, TraitRef, TyKind,
+    ImplItem, ImplItemKind, Item, ItemKind, LangItem, Local, MatchSource, Node, Param, Pat, PatKind, Path, PathSegment,
+    QPath, Stmt, StmtKind, TraitItem, TraitItemKind, TraitRef, TyKind,
 };
 use rustc_lint::{LateContext, Level, Lint, LintContext};
 use rustc_middle::hir::exports::Export;
@@ -1312,48 +1312,7 @@ pub fn is_must_use_func_call(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
     did.map_or(false, |did| must_use_attr(&cx.tcx.get_attrs(did)).is_some())
 }
 
-pub fn get_expr_use_node(tcx: TyCtxt<'tcx>, expr: &Expr<'_>) -> Option<Node<'tcx>> {
-    let map = tcx.hir();
-    let mut child_id = expr.hir_id;
-    let mut iter = map.parent_iter(child_id);
-    loop {
-        match iter.next() {
-            None => break None,
-            Some((id, Node::Block(_))) => child_id = id,
-            Some((id, Node::Arm(arm))) if arm.body.hir_id == child_id => child_id = id,
-            Some((_, Node::Expr(expr))) => match expr.kind {
-                ExprKind::Break(
-                    Destination {
-                        target_id: Ok(dest), ..
-                    },
-                    _,
-                ) => {
-                    iter = map.parent_iter(dest);
-                    child_id = dest;
-                },
-                ExprKind::DropTemps(_) | ExprKind::Block(..) => child_id = expr.hir_id,
-                ExprKind::If(control_expr, ..) | ExprKind::Match(control_expr, ..)
-                    if control_expr.hir_id != child_id =>
-                {
-                    child_id = expr.hir_id
-                },
-                _ => break Some(Node::Expr(expr)),
-            },
-            Some((_, node)) => break Some(node),
-        }
-    }
-}
-
-pub fn is_expr_used(tcx: TyCtxt<'_>, expr: &Expr<'_>) -> bool {
-    !matches!(
-        get_expr_use_node(tcx, expr),
-        Some(Node::Stmt(Stmt {
-            kind: StmtKind::Expr(_) | StmtKind::Semi(_),
-            ..
-        }))
-    )
-}
-
+/// Gets the node where an expression is either used, or it's type is unified with another branch.
 pub fn get_expr_use_or_unification_node(tcx: TyCtxt<'tcx>, expr: &Expr<'_>) -> Option<Node<'tcx>> {
     let map = tcx.hir();
     let mut child_id = expr.hir_id;
@@ -1374,16 +1333,26 @@ pub fn get_expr_use_or_unification_node(tcx: TyCtxt<'tcx>, expr: &Expr<'_>) -> O
     }
 }
 
+/// Checks if the result of an expression is used, or it's type is unified with another branch.
 pub fn is_expr_used_or_unified(tcx: TyCtxt<'_>, expr: &Expr<'_>) -> bool {
     !matches!(
         get_expr_use_or_unification_node(tcx, expr),
         None | Some(Node::Stmt(Stmt {
-            kind: StmtKind::Expr(_) | StmtKind::Semi(_),
+            kind: StmtKind::Expr(_)
+                | StmtKind::Semi(_)
+                | StmtKind::Local(Local {
+                    pat: Pat {
+                        kind: PatKind::Wild,
+                        ..
+                    },
+                    ..
+                }),
             ..
         }))
     )
 }
 
+/// Checks if the expression is the final expression returned from a block.
 pub fn is_expr_final_block_expr(tcx: TyCtxt<'_>, expr: &Expr<'_>) -> bool {
     matches!(get_parent_node(tcx, expr.hir_id), Some(Node::Block(..)))
 }
diff --git a/tests/ui/entry.fixed b/tests/ui/entry.fixed
index 524f2132797..cfad3090ba3 100644
--- a/tests/ui/entry.fixed
+++ b/tests/ui/entry.fixed
@@ -2,6 +2,7 @@
 
 #![allow(unused, clippy::needless_pass_by_value, clippy::collapsible_if)]
 #![warn(clippy::map_entry)]
+#![feature(asm)]
 
 use std::collections::{BTreeMap, HashMap};
 use std::hash::Hash;
@@ -10,11 +11,19 @@ macro_rules! m {
     ($e:expr) => {{ $e }};
 }
 
+macro_rules! insert {
+    ($map:expr, $key:expr, $val:expr) => {
+        $map.insert($key, $val)
+    };
+}
+
 fn foo() {}
 
-fn hash_map<K: Eq + Hash + Copy, V: Copy>(m: &mut HashMap<K, V>, k: K, v: V, v2: V) {
+fn hash_map<K: Eq + Hash + Copy, V: Copy>(m: &mut HashMap<K, V>, m2: &mut HashMap<K, V>, k: K, k2: K, v: V, v2: V) {
+    // or_insert(v)
     m.entry(k).or_insert(v);
 
+    // semicolon on insert, use or_insert_with(..)
     m.entry(k).or_insert_with(|| {
         if true {
             v
@@ -23,6 +32,7 @@ fn hash_map<K: Eq + Hash + Copy, V: Copy>(m: &mut HashMap<K, V>, k: K, v: V, v2:
         }
     });
 
+    // semicolon on if, use or_insert_with(..)
     m.entry(k).or_insert_with(|| {
         if true {
             v
@@ -31,6 +41,7 @@ fn hash_map<K: Eq + Hash + Copy, V: Copy>(m: &mut HashMap<K, V>, k: K, v: V, v2:
         }
     });
 
+    // early return, use if let
     if let std::collections::hash_map::Entry::Vacant(e) = m.entry(k) {
         if true {
             e.insert(v);
@@ -40,11 +51,13 @@ fn hash_map<K: Eq + Hash + Copy, V: Copy>(m: &mut HashMap<K, V>, k: K, v: V, v2:
         }
     }
 
+    // use or_insert_with(..)
     m.entry(k).or_insert_with(|| {
         foo();
         v
     });
 
+    // semicolon on insert and match, use or_insert_with(..)
     m.entry(k).or_insert_with(|| {
         match 0 {
             1 if true => {
@@ -56,18 +69,17 @@ fn hash_map<K: Eq + Hash + Copy, V: Copy>(m: &mut HashMap<K, V>, k: K, v: V, v2:
         }
     });
 
+    // one branch doesn't insert, use if let
     if let std::collections::hash_map::Entry::Vacant(e) = m.entry(k) {
         match 0 {
-            0 => {},
-            1 => {
-                e.insert(v);
-            },
+            0 => foo(),
             _ => {
                 e.insert(v2);
             },
         };
     }
 
+    // use or_insert_with
     m.entry(k).or_insert_with(|| {
         foo();
         match 0 {
@@ -94,10 +106,46 @@ fn hash_map<K: Eq + Hash + Copy, V: Copy>(m: &mut HashMap<K, V>, k: K, v: V, v2:
         }
     });
 
+    // ok, insert in loop
+    if !m.contains_key(&k) {
+        for _ in 0..2 {
+            m.insert(k, v);
+        }
+    }
+
+    // macro_expansion test, use or_insert(..)
     m.entry(m!(k)).or_insert_with(|| m!(v));
+
+    // ok, map used before insertion
+    if !m.contains_key(&k) {
+        let _ = m.len();
+        m.insert(k, v);
+    }
+
+    // ok, inline asm
+    if !m.contains_key(&k) {
+        unsafe { asm!("nop") }
+        m.insert(k, v);
+    }
+
+    // ok, different keys.
+    if !m.contains_key(&k) {
+        m.insert(k2, v);
+    }
+
+    // ok, different maps
+    if !m.contains_key(&k) {
+        m2.insert(k, v);
+    }
+
+    // ok, insert in macro
+    if !m.contains_key(&k) {
+        insert!(m, k, v);
+    }
 }
 
 fn btree_map<K: Eq + Ord + Copy, V: Copy>(m: &mut BTreeMap<K, V>, k: K, v: V, v2: V) {
+    // insert then do something, use if let
     if let std::collections::btree_map::Entry::Vacant(e) = m.entry(k) {
         e.insert(v);
         foo();
diff --git a/tests/ui/entry.rs b/tests/ui/entry.rs
index ff4890eeeb6..fa9280b58de 100644
--- a/tests/ui/entry.rs
+++ b/tests/ui/entry.rs
@@ -2,6 +2,7 @@
 
 #![allow(unused, clippy::needless_pass_by_value, clippy::collapsible_if)]
 #![warn(clippy::map_entry)]
+#![feature(asm)]
 
 use std::collections::{BTreeMap, HashMap};
 use std::hash::Hash;
@@ -10,13 +11,21 @@ macro_rules! m {
     ($e:expr) => {{ $e }};
 }
 
+macro_rules! insert {
+    ($map:expr, $key:expr, $val:expr) => {
+        $map.insert($key, $val)
+    };
+}
+
 fn foo() {}
 
-fn hash_map<K: Eq + Hash + Copy, V: Copy>(m: &mut HashMap<K, V>, k: K, v: V, v2: V) {
+fn hash_map<K: Eq + Hash + Copy, V: Copy>(m: &mut HashMap<K, V>, m2: &mut HashMap<K, V>, k: K, k2: K, v: V, v2: V) {
+    // or_insert(v)
     if !m.contains_key(&k) {
         m.insert(k, v);
     }
 
+    // semicolon on insert, use or_insert_with(..)
     if !m.contains_key(&k) {
         if true {
             m.insert(k, v);
@@ -25,6 +34,7 @@ fn hash_map<K: Eq + Hash + Copy, V: Copy>(m: &mut HashMap<K, V>, k: K, v: V, v2:
         }
     }
 
+    // semicolon on if, use or_insert_with(..)
     if !m.contains_key(&k) {
         if true {
             m.insert(k, v)
@@ -33,6 +43,7 @@ fn hash_map<K: Eq + Hash + Copy, V: Copy>(m: &mut HashMap<K, V>, k: K, v: V, v2:
         };
     }
 
+    // early return, use if let
     if !m.contains_key(&k) {
         if true {
             m.insert(k, v);
@@ -42,11 +53,13 @@ fn hash_map<K: Eq + Hash + Copy, V: Copy>(m: &mut HashMap<K, V>, k: K, v: V, v2:
         }
     }
 
+    // use or_insert_with(..)
     if !m.contains_key(&k) {
         foo();
         m.insert(k, v);
     }
 
+    // semicolon on insert and match, use or_insert_with(..)
     if !m.contains_key(&k) {
         match 0 {
             1 if true => {
@@ -58,18 +71,17 @@ fn hash_map<K: Eq + Hash + Copy, V: Copy>(m: &mut HashMap<K, V>, k: K, v: V, v2:
         };
     }
 
+    // one branch doesn't insert, use if let
     if !m.contains_key(&k) {
         match 0 {
-            0 => {},
-            1 => {
-                m.insert(k, v);
-            },
+            0 => foo(),
             _ => {
                 m.insert(k, v2);
             },
         };
     }
 
+    // use or_insert_with
     if !m.contains_key(&k) {
         foo();
         match 0 {
@@ -96,12 +108,48 @@ fn hash_map<K: Eq + Hash + Copy, V: Copy>(m: &mut HashMap<K, V>, k: K, v: V, v2:
         }
     }
 
+    // ok, insert in loop
+    if !m.contains_key(&k) {
+        for _ in 0..2 {
+            m.insert(k, v);
+        }
+    }
+
+    // macro_expansion test, use or_insert(..)
     if !m.contains_key(&m!(k)) {
         m.insert(m!(k), m!(v));
     }
+
+    // ok, map used before insertion
+    if !m.contains_key(&k) {
+        let _ = m.len();
+        m.insert(k, v);
+    }
+
+    // ok, inline asm
+    if !m.contains_key(&k) {
+        unsafe { asm!("nop") }
+        m.insert(k, v);
+    }
+
+    // ok, different keys.
+    if !m.contains_key(&k) {
+        m.insert(k2, v);
+    }
+
+    // ok, different maps
+    if !m.contains_key(&k) {
+        m2.insert(k, v);
+    }
+
+    // ok, insert in macro
+    if !m.contains_key(&k) {
+        insert!(m, k, v);
+    }
 }
 
 fn btree_map<K: Eq + Ord + Copy, V: Copy>(m: &mut BTreeMap<K, V>, k: K, v: V, v2: V) {
+    // insert then do something, use if let
     if !m.contains_key(&k) {
         m.insert(k, v);
         foo();
diff --git a/tests/ui/entry.stderr b/tests/ui/entry.stderr
index 63b5f5a0b2c..2f075a97010 100644
--- a/tests/ui/entry.stderr
+++ b/tests/ui/entry.stderr
@@ -1,5 +1,5 @@
 error: usage of `contains_key` followed by `insert` on a `HashMap`
-  --> $DIR/entry.rs:16:5
+  --> $DIR/entry.rs:24:5
    |
 LL | /     if !m.contains_key(&k) {
 LL | |         m.insert(k, v);
@@ -9,7 +9,7 @@ LL | |     }
    = note: `-D clippy::map-entry` implied by `-D warnings`
 
 error: usage of `contains_key` followed by `insert` on a `HashMap`
-  --> $DIR/entry.rs:20:5
+  --> $DIR/entry.rs:29:5
    |
 LL | /     if !m.contains_key(&k) {
 LL | |         if true {
@@ -31,7 +31,7 @@ LL |         }
  ...
 
 error: usage of `contains_key` followed by `insert` on a `HashMap`
-  --> $DIR/entry.rs:28:5
+  --> $DIR/entry.rs:38:5
    |
 LL | /     if !m.contains_key(&k) {
 LL | |         if true {
@@ -53,7 +53,7 @@ LL |         }
  ...
 
 error: usage of `contains_key` followed by `insert` on a `HashMap`
-  --> $DIR/entry.rs:36:5
+  --> $DIR/entry.rs:47:5
    |
 LL | /     if !m.contains_key(&k) {
 LL | |         if true {
@@ -75,7 +75,7 @@ LL |             return;
  ...
 
 error: usage of `contains_key` followed by `insert` on a `HashMap`
-  --> $DIR/entry.rs:45:5
+  --> $DIR/entry.rs:57:5
    |
 LL | /     if !m.contains_key(&k) {
 LL | |         foo();
@@ -92,7 +92,7 @@ LL |     });
    |
 
 error: usage of `contains_key` followed by `insert` on a `HashMap`
-  --> $DIR/entry.rs:50:5
+  --> $DIR/entry.rs:63:5
    |
 LL | /     if !m.contains_key(&k) {
 LL | |         match 0 {
@@ -114,12 +114,12 @@ LL |             _ => {
  ...
 
 error: usage of `contains_key` followed by `insert` on a `HashMap`
-  --> $DIR/entry.rs:61:5
+  --> $DIR/entry.rs:75:5
    |
 LL | /     if !m.contains_key(&k) {
 LL | |         match 0 {
-LL | |             0 => {},
-LL | |             1 => {
+LL | |             0 => foo(),
+LL | |             _ => {
 ...  |
 LL | |         };
 LL | |     }
@@ -129,14 +129,14 @@ help: try this
    |
 LL |     if let std::collections::hash_map::Entry::Vacant(e) = m.entry(k) {
 LL |         match 0 {
-LL |             0 => {},
-LL |             1 => {
-LL |                 e.insert(v);
+LL |             0 => foo(),
+LL |             _ => {
+LL |                 e.insert(v2);
 LL |             },
  ...
 
 error: usage of `contains_key` followed by `insert` on a `HashMap`
-  --> $DIR/entry.rs:73:5
+  --> $DIR/entry.rs:85:5
    |
 LL | /     if !m.contains_key(&k) {
 LL | |         foo();
@@ -158,7 +158,7 @@ LL |             },
  ...
 
 error: usage of `contains_key` followed by `insert` on a `HashMap`
-  --> $DIR/entry.rs:99:5
+  --> $DIR/entry.rs:119:5
    |
 LL | /     if !m.contains_key(&m!(k)) {
 LL | |         m.insert(m!(k), m!(v));
@@ -166,7 +166,7 @@ LL | |     }
    | |_____^ help: try this: `m.entry(m!(k)).or_insert_with(|| m!(v));`
 
 error: usage of `contains_key` followed by `insert` on a `BTreeMap`
-  --> $DIR/entry.rs:105:5
+  --> $DIR/entry.rs:153:5
    |
 LL | /     if !m.contains_key(&k) {
 LL | |         m.insert(k, v);
diff --git a/tests/ui/entry_unfixable.rs b/tests/ui/entry_unfixable.rs
deleted file mode 100644
index beb2d5c97b1..00000000000
--- a/tests/ui/entry_unfixable.rs
+++ /dev/null
@@ -1,50 +0,0 @@
-#![allow(unused, clippy::needless_pass_by_value)]
-#![warn(clippy::map_entry)]
-
-use std::collections::{BTreeMap, HashMap};
-use std::hash::Hash;
-
-macro_rules! m {
-    ($map:expr, $key:expr, $value:expr) => {
-        $map.insert($key, $value)
-    };
-    ($e:expr) => {{ $e }};
-}
-
-fn foo() {}
-
-// should not trigger
-fn insert_other_if_absent<K: Eq + Hash, V>(m: &mut HashMap<K, V>, k: K, o: K, v: V) {
-    if !m.contains_key(&k) {
-        m.insert(o, v);
-    }
-}
-
-// should not trigger, because the one uses different HashMap from another one
-fn insert_from_different_map<K: Eq + Hash, V>(m: HashMap<K, V>, n: &mut HashMap<K, V>, k: K, v: V) {
-    if !m.contains_key(&k) {
-        n.insert(k, v);
-    }
-}
-
-// should not trigger, because the one uses different HashMap from another one
-fn insert_from_different_map2<K: Eq + Hash, V>(m: &mut HashMap<K, V>, n: &mut HashMap<K, V>, k: K, v: V) {
-    if !m.contains_key(&k) {
-        n.insert(k, v);
-    }
-}
-
-fn insert_in_macro<K: Eq + Hash, V>(m: &mut HashMap<K, V>, k: K, v: V) {
-    if !m.contains_key(&k) {
-        m!(m, k, v);
-    }
-}
-
-fn use_map_then_insert<K: Eq + Hash, V>(m: &mut HashMap<K, V>, k: K, v: V) {
-    if !m.contains_key(&k) {
-        let _ = m.len();
-        m.insert(k, v);
-    }
-}
-
-fn main() {}
diff --git a/tests/ui/string_lit_as_bytes.fixed b/tests/ui/string_lit_as_bytes.fixed
index dd22bfa5c53..df2256e4f97 100644
--- a/tests/ui/string_lit_as_bytes.fixed
+++ b/tests/ui/string_lit_as_bytes.fixed
@@ -22,7 +22,7 @@ fn str_lit_as_bytes() {
 
     let current_version = env!("CARGO_PKG_VERSION").as_bytes();
 
-    let includestr = include_bytes!("entry_unfixable.rs");
+    let includestr = include_bytes!("string_lit_as_bytes.rs");
 
     let _ = b"string with newline\t\n";
 }
diff --git a/tests/ui/string_lit_as_bytes.rs b/tests/ui/string_lit_as_bytes.rs
index d2a710ed6b8..c6bf8f732ed 100644
--- a/tests/ui/string_lit_as_bytes.rs
+++ b/tests/ui/string_lit_as_bytes.rs
@@ -22,7 +22,7 @@ fn str_lit_as_bytes() {
 
     let current_version = env!("CARGO_PKG_VERSION").as_bytes();
 
-    let includestr = include_str!("entry_unfixable.rs").as_bytes();
+    let includestr = include_str!("string_lit_as_bytes.rs").as_bytes();
 
     let _ = "string with newline\t\n".as_bytes();
 }
diff --git a/tests/ui/string_lit_as_bytes.stderr b/tests/ui/string_lit_as_bytes.stderr
index e0ddb070b50..f47d6161c6c 100644
--- a/tests/ui/string_lit_as_bytes.stderr
+++ b/tests/ui/string_lit_as_bytes.stderr
@@ -27,8 +27,8 @@ LL |     let bs = "lit to owned".to_owned().into_bytes();
 error: calling `as_bytes()` on `include_str!(..)`
   --> $DIR/string_lit_as_bytes.rs:25:22
    |
-LL |     let includestr = include_str!("entry_unfixable.rs").as_bytes();
-   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `include_bytes!(..)` instead: `include_bytes!("entry_unfixable.rs")`
+LL |     let includestr = include_str!("string_lit_as_bytes.rs").as_bytes();
+   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `include_bytes!(..)` instead: `include_bytes!("string_lit_as_bytes.rs")`
 
 error: calling `as_bytes()` on a string literal
   --> $DIR/string_lit_as_bytes.rs:27:13
-- 
cgit 1.4.1-3-g733a5


From 779d98f6ccbd76807e811a134bb00a4e0d92c6db Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Thu, 15 Apr 2021 10:37:42 -0400
Subject: Don't allow adjustments for `manual_map`

---
 clippy_lints/src/manual_map.rs   | 6 ++++++
 tests/ui/manual_map_option.fixed | 7 +++++++
 tests/ui/manual_map_option.rs    | 7 +++++++
 3 files changed, 20 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_map.rs b/clippy_lints/src/manual_map.rs
index 29be0739977..f16ed4104fe 100644
--- a/clippy_lints/src/manual_map.rs
+++ b/clippy_lints/src/manual_map.rs
@@ -104,12 +104,18 @@ impl LateLintPass<'_> for ManualMap {
                 None => return,
             };
 
+            // These two lints will go back and forth with each other.
             if cx.typeck_results().expr_ty(some_expr) == cx.tcx.types.unit
                 && !is_allowed(cx, OPTION_MAP_UNIT_FN, expr.hir_id)
             {
                 return;
             }
 
+            // `map` won't perform any adjustments.
+            if !cx.typeck_results().expr_adjustments(some_expr).is_empty() {
+                return;
+            }
+
             if !can_move_expr_to_closure(cx, some_expr) {
                 return;
             }
diff --git a/tests/ui/manual_map_option.fixed b/tests/ui/manual_map_option.fixed
index ee015845777..40d01df6379 100644
--- a/tests/ui/manual_map_option.fixed
+++ b/tests/ui/manual_map_option.fixed
@@ -146,4 +146,11 @@ fn main() {
             None => None,
         };
     }
+
+    // #7077
+    let s = &String::new();
+    let _: Option<&str> = match Some(s) {
+        Some(s) => Some(s),
+        None => None,
+    };
 }
diff --git a/tests/ui/manual_map_option.rs b/tests/ui/manual_map_option.rs
index 29509bddfd9..cfef0c5cc4e 100644
--- a/tests/ui/manual_map_option.rs
+++ b/tests/ui/manual_map_option.rs
@@ -212,4 +212,11 @@ fn main() {
             None => None,
         };
     }
+
+    // #7077
+    let s = &String::new();
+    let _: Option<&str> = match Some(s) {
+        Some(s) => Some(s),
+        None => None,
+    };
 }
-- 
cgit 1.4.1-3-g733a5


From 014bf4390c3dcce701749d09ea253126181bc37a Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Thu, 15 Apr 2021 12:57:31 -0500
Subject: Add note for pre-expansion passes

---
 clippy_lints/src/lib.rs | 1 +
 1 file changed, 1 insertion(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 78a95b00403..93631c5669b 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -390,6 +390,7 @@ pub use crate::utils::conf::Conf;
 ///
 /// Used in `./src/driver.rs`.
 pub fn register_pre_expansion_lints(store: &mut rustc_lint::LintStore) {
+    // NOTE: Do not add any more pre-expansion passes. These should be removed eventually.
     store.register_pre_expansion_pass(|| box write::Write::default());
     store.register_pre_expansion_pass(|| box attrs::EarlyAttributes);
     store.register_pre_expansion_pass(|| box dbg_macro::DbgMacro);
-- 
cgit 1.4.1-3-g733a5


From f6c5d8d599070bacad800ac7014fa3a6f140eadc Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Wed, 7 Apr 2021 16:19:25 -0400
Subject: Remove all usages of `match_path`, `match_qpath` and `match_path_ast`
 except the `author` lint. Add note to fix `MATCH_TYPE_ON_DIAG_ITEM` Add false
 negative test for `uninit_assumed_init`

---
 clippy_lints/src/assertions_on_constants.rs        |  5 +-
 clippy_lints/src/excessive_bools.rs                |  6 +-
 clippy_lints/src/implicit_hasher.rs                |  7 +-
 clippy_lints/src/implicit_saturating_sub.rs        | 43 ++++++++---
 clippy_lints/src/infinite_iter.rs                  |  4 +-
 clippy_lints/src/map_identity.rs                   |  4 +-
 clippy_lints/src/matches.rs                        | 24 ++++--
 clippy_lints/src/methods/filter_map_identity.rs    | 12 +--
 clippy_lints/src/methods/flat_map_identity.rs      | 18 ++---
 .../src/methods/from_iter_instead_of_collect.rs    | 11 +--
 .../src/methods/manual_saturating_arithmetic.rs    |  6 +-
 clippy_lints/src/methods/mod.rs                    |  2 +-
 clippy_lints/src/methods/uninit_assumed_init.rs    |  5 +-
 clippy_lints/src/methods/unnecessary_filter_map.rs |  2 -
 clippy_lints/src/misc.rs                           | 18 ++---
 clippy_lints/src/ptr.rs                            | 17 ++---
 clippy_lints/src/question_mark.rs                  | 11 ++-
 clippy_lints/src/returns.rs                        |  7 +-
 clippy_lints/src/slow_vector_initialization.rs     | 69 ++++++++---------
 clippy_lints/src/transmuting_null.rs               | 23 +++---
 clippy_lints/src/types/borrowed_box.rs             |  9 ++-
 clippy_lints/src/unnecessary_wraps.rs              | 10 +--
 clippy_lints/src/utils/internal_lints.rs           | 14 ++--
 clippy_utils/src/lib.rs                            | 89 ++++++++++++++--------
 clippy_utils/src/paths.rs                          | 12 +--
 doc/adding_lints.md                                |  2 +-
 .../ui-internal/collapsible_span_lint_calls.fixed  | 48 +-----------
 tests/ui-internal/collapsible_span_lint_calls.rs   | 48 +-----------
 .../ui-internal/collapsible_span_lint_calls.stderr | 10 +--
 tests/ui-internal/match_type_on_diag_item.rs       | 21 ++---
 tests/ui-internal/match_type_on_diag_item.stderr   | 30 +++-----
 tests/ui/repl_uninit.rs                            |  4 +-
 tests/ui/uninit.rs                                 |  5 +-
 tests/ui/uninit.stderr                             |  8 +-
 34 files changed, 269 insertions(+), 335 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/assertions_on_constants.rs b/clippy_lints/src/assertions_on_constants.rs
index a0993bb6913..c565e29d078 100644
--- a/clippy_lints/src/assertions_on_constants.rs
+++ b/clippy_lints/src/assertions_on_constants.rs
@@ -127,10 +127,9 @@ fn match_assert_with_message<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>)
             _ => &block.expr,
         };
         // function call
-        if let Some(args) = match_panic_call(cx, begin_panic_call);
-        if args.len() == 1;
+        if let Some(arg) = match_panic_call(cx, begin_panic_call);
         // bind the second argument of the `assert!` macro if it exists
-        if let panic_message = snippet_opt(cx, args[0].span);
+        if let panic_message = snippet_opt(cx, arg.span);
         // second argument of begin_panic is irrelevant
         // as is the second match arm
         then {
diff --git a/clippy_lints/src/excessive_bools.rs b/clippy_lints/src/excessive_bools.rs
index 249ee27330b..4e2dbf005d5 100644
--- a/clippy_lints/src/excessive_bools.rs
+++ b/clippy_lints/src/excessive_bools.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_help;
-use clippy_utils::{in_macro, match_path_ast};
+use clippy_utils::in_macro;
 use rustc_ast::ast::{AssocItemKind, Extern, FnKind, FnSig, ImplKind, Item, ItemKind, TraitKind, Ty, TyKind};
 use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
@@ -126,7 +126,9 @@ impl_lint_pass!(ExcessiveBools => [STRUCT_EXCESSIVE_BOOLS, FN_PARAMS_EXCESSIVE_B
 
 fn is_bool_ty(ty: &Ty) -> bool {
     if let TyKind::Path(None, path) = &ty.kind {
-        return match_path_ast(path, &["bool"]);
+        if let [name] = path.segments.as_slice() {
+            return name.ident.name == sym::bool;
+        }
     }
     false
 }
diff --git a/clippy_lints/src/implicit_hasher.rs b/clippy_lints/src/implicit_hasher.rs
index 77a38544edc..03fe0d16d48 100644
--- a/clippy_lints/src/implicit_hasher.rs
+++ b/clippy_lints/src/implicit_hasher.rs
@@ -22,7 +22,7 @@ use clippy_utils::diagnostics::{multispan_sugg, span_lint_and_then};
 use clippy_utils::paths;
 use clippy_utils::source::{snippet, snippet_opt};
 use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{differing_macro_contexts, match_path};
+use clippy_utils::{differing_macro_contexts, match_def_path};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for public `impl` or `fn` missing generalization
@@ -333,12 +333,13 @@ impl<'a, 'b, 'tcx> Visitor<'tcx> for ImplicitHasherConstructorVisitor<'a, 'b, 't
             if let ExprKind::Call(fun, args) = e.kind;
             if let ExprKind::Path(QPath::TypeRelative(ty, method)) = fun.kind;
             if let TyKind::Path(QPath::Resolved(None, ty_path)) = ty.kind;
+            if let Some(ty_did) = ty_path.res.opt_def_id();
             then {
                 if !TyS::same_type(self.target.ty(), self.maybe_typeck_results.unwrap().expr_ty(e)) {
                     return;
                 }
 
-                if match_path(ty_path, &paths::HASHMAP) {
+                if match_def_path(self.cx, ty_did, &paths::HASHMAP) {
                     if method.ident.name == sym::new {
                         self.suggestions
                             .insert(e.span, "HashMap::default()".to_string());
@@ -351,7 +352,7 @@ impl<'a, 'b, 'tcx> Visitor<'tcx> for ImplicitHasherConstructorVisitor<'a, 'b, 't
                             ),
                         );
                     }
-                } else if match_path(ty_path, &paths::HASHSET) {
+                } else if match_def_path(self.cx, ty_did, &paths::HASHSET) {
                     if method.ident.name == sym::new {
                         self.suggestions
                             .insert(e.span, "HashSet::default()".to_string());
diff --git a/clippy_lints/src/implicit_saturating_sub.rs b/clippy_lints/src/implicit_saturating_sub.rs
index cba3183e869..4069a685ea0 100644
--- a/clippy_lints/src/implicit_saturating_sub.rs
+++ b/clippy_lints/src/implicit_saturating_sub.rs
@@ -1,9 +1,9 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::{in_macro, match_qpath, SpanlessEq};
+use clippy_utils::{in_macro, SpanlessEq};
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
-use rustc_hir::{BinOpKind, Expr, ExprKind, QPath, StmtKind};
+use rustc_hir::{lang_items::LangItem, BinOpKind, Expr, ExprKind, QPath, StmtKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
@@ -87,7 +87,13 @@ impl<'tcx> LateLintPass<'tcx> for ImplicitSaturatingSub {
 
                 // Get the variable name
                 let var_name = ares_path.segments[0].ident.name.as_str();
-                const INT_TYPES: [&str; 5] = ["i8", "i16", "i32", "i64", "i128"];
+                const INT_TYPES: [LangItem; 5] = [
+                    LangItem::I8,
+                    LangItem::I16,
+                    LangItem::I32,
+                    LangItem::I64,
+                    LangItem::Isize
+                ];
 
                 match cond_num_val.kind {
                     ExprKind::Lit(ref cond_lit) => {
@@ -99,17 +105,30 @@ impl<'tcx> LateLintPass<'tcx> for ImplicitSaturatingSub {
                             };
                         }
                     },
-                    ExprKind::Path(ref cond_num_path) => {
-                        if INT_TYPES.iter().any(|int_type| match_qpath(cond_num_path, &[int_type, "MIN"])) {
-                            print_lint_and_sugg(cx, &var_name, expr);
-                        };
+                    ExprKind::Path(QPath::TypeRelative(_, name)) => {
+                        if_chain! {
+                            if name.ident.as_str() == "MIN";
+                            if let Some(const_id) = cx.typeck_results().type_dependent_def_id(cond_num_val.hir_id);
+                            if let Some(impl_id) = cx.tcx.impl_of_method(const_id);
+                            let mut int_ids = INT_TYPES.iter().filter_map(|&ty| cx.tcx.lang_items().require(ty).ok());
+                            if int_ids.any(|int_id| int_id == impl_id);
+                            then {
+                                print_lint_and_sugg(cx, &var_name, expr)
+                            }
+                        }
                     },
-                    ExprKind::Call(func, _) => {
-                        if let ExprKind::Path(ref cond_num_path) = func.kind {
-                            if INT_TYPES.iter().any(|int_type| match_qpath(cond_num_path, &[int_type, "min_value"])) {
-                                print_lint_and_sugg(cx, &var_name, expr);
+                    ExprKind::Call(func, []) => {
+                        if_chain! {
+                            if let ExprKind::Path(QPath::TypeRelative(_, name)) = func.kind;
+                            if name.ident.as_str() == "min_value";
+                            if let Some(func_id) = cx.typeck_results().type_dependent_def_id(func.hir_id);
+                            if let Some(impl_id) = cx.tcx.impl_of_method(func_id);
+                            let mut int_ids = INT_TYPES.iter().filter_map(|&ty| cx.tcx.lang_items().require(ty).ok());
+                            if int_ids.any(|int_id| int_id == impl_id);
+                            then {
+                                print_lint_and_sugg(cx, &var_name, expr)
                             }
-                        };
+                        }
                     },
                     _ => (),
                 }
diff --git a/clippy_lints/src/infinite_iter.rs b/clippy_lints/src/infinite_iter.rs
index bbb4ddc613a..afee20ce43e 100644
--- a/clippy_lints/src/infinite_iter.rs
+++ b/clippy_lints/src/infinite_iter.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::ty::{implements_trait, match_type};
-use clippy_utils::{get_trait_def_id, higher, match_qpath, paths};
+use clippy_utils::{get_trait_def_id, higher, is_qpath_def_path, paths};
 use rustc_hir::{BorrowKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -163,7 +163,7 @@ fn is_infinite(cx: &LateContext<'_>, expr: &Expr<'_>) -> Finiteness {
         ExprKind::Box(e) | ExprKind::AddrOf(BorrowKind::Ref, _, e) => is_infinite(cx, e),
         ExprKind::Call(path, _) => {
             if let ExprKind::Path(ref qpath) = path.kind {
-                match_qpath(qpath, &paths::REPEAT).into()
+                is_qpath_def_path(cx, qpath, path.hir_id, &paths::ITER_REPEAT).into()
             } else {
                 Finite
             }
diff --git a/clippy_lints/src/map_identity.rs b/clippy_lints/src/map_identity.rs
index e7719e7663d..41cda23510e 100644
--- a/clippy_lints/src/map_identity.rs
+++ b/clippy_lints/src/map_identity.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{is_adjusted, is_trait_method, match_path, match_var, paths, remove_blocks};
+use clippy_utils::{is_adjusted, is_qpath_def_path, is_trait_method, match_var, paths, remove_blocks};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Body, Expr, ExprKind, Pat, PatKind, QPath, StmtKind};
@@ -80,7 +80,7 @@ fn get_map_argument<'a>(cx: &LateContext<'_>, expr: &'a Expr<'a>) -> Option<&'a
 fn is_expr_identity_function(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
     match expr.kind {
         ExprKind::Closure(_, _, body_id, _, _) => is_body_identity_function(cx, cx.tcx.hir().body(body_id)),
-        ExprKind::Path(QPath::Resolved(_, path)) => match_path(path, &paths::STD_CONVERT_IDENTITY),
+        ExprKind::Path(ref path) => is_qpath_def_path(cx, path, expr.hir_id, &paths::CONVERT_IDENTITY),
         _ => false,
     }
 }
diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index 30091e0e2d7..8f1112cff7b 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -1701,7 +1701,7 @@ mod redundant_pattern_match {
     use super::REDUNDANT_PATTERN_MATCHING;
     use clippy_utils::diagnostics::span_lint_and_then;
     use clippy_utils::source::snippet;
-    use clippy_utils::{is_lang_ctor, is_trait_method, match_qpath, paths};
+    use clippy_utils::{is_lang_ctor, is_qpath_def_path, is_trait_method, paths};
     use if_chain::if_chain;
     use rustc_ast::ast::LitKind;
     use rustc_errors::Applicability;
@@ -1735,8 +1735,8 @@ mod redundant_pattern_match {
             kind = &inner.kind;
         }
         let good_method = match kind {
-            PatKind::TupleStruct(ref path, patterns, _) if patterns.len() == 1 => {
-                if let PatKind::Wild = patterns[0].kind {
+            PatKind::TupleStruct(ref path, [sub_pat], _) => {
+                if let PatKind::Wild = sub_pat.kind {
                     if is_lang_ctor(cx, path, ResultOk) {
                         "is_ok()"
                     } else if is_lang_ctor(cx, path, ResultErr) {
@@ -1745,9 +1745,9 @@ mod redundant_pattern_match {
                         "is_some()"
                     } else if is_lang_ctor(cx, path, PollReady) {
                         "is_ready()"
-                    } else if match_qpath(path, &paths::IPADDR_V4) {
+                    } else if is_qpath_def_path(cx, path, sub_pat.hir_id, &paths::IPADDR_V4) {
                         "is_ipv4()"
-                    } else if match_qpath(path, &paths::IPADDR_V6) {
+                    } else if is_qpath_def_path(cx, path, sub_pat.hir_id, &paths::IPADDR_V6) {
                         "is_ipv6()"
                     } else {
                         return;
@@ -1821,6 +1821,7 @@ mod redundant_pattern_match {
                 ) if patterns_left.len() == 1 && patterns_right.len() == 1 => {
                     if let (PatKind::Wild, PatKind::Wild) = (&patterns_left[0].kind, &patterns_right[0].kind) {
                         find_good_method_for_match(
+                            cx,
                             arms,
                             path_left,
                             path_right,
@@ -1831,6 +1832,7 @@ mod redundant_pattern_match {
                         )
                         .or_else(|| {
                             find_good_method_for_match(
+                                cx,
                                 arms,
                                 path_left,
                                 path_right,
@@ -1850,6 +1852,7 @@ mod redundant_pattern_match {
                 {
                     if let PatKind::Wild = patterns[0].kind {
                         find_good_method_for_match(
+                            cx,
                             arms,
                             path_left,
                             path_right,
@@ -1860,6 +1863,7 @@ mod redundant_pattern_match {
                         )
                         .or_else(|| {
                             find_good_method_for_match(
+                                cx,
                                 arms,
                                 path_left,
                                 path_right,
@@ -1900,7 +1904,9 @@ mod redundant_pattern_match {
         }
     }
 
+    #[allow(clippy::too_many_arguments)]
     fn find_good_method_for_match<'a>(
+        cx: &LateContext<'_>,
         arms: &[Arm<'_>],
         path_left: &QPath<'_>,
         path_right: &QPath<'_>,
@@ -1909,9 +1915,13 @@ mod redundant_pattern_match {
         should_be_left: &'a str,
         should_be_right: &'a str,
     ) -> Option<&'a str> {
-        let body_node_pair = if match_qpath(path_left, expected_left) && match_qpath(path_right, expected_right) {
+        let body_node_pair = if is_qpath_def_path(cx, path_left, arms[0].pat.hir_id, expected_left)
+            && is_qpath_def_path(cx, path_right, arms[1].pat.hir_id, expected_right)
+        {
             (&(*arms[0].body).kind, &(*arms[1].body).kind)
-        } else if match_qpath(path_right, expected_left) && match_qpath(path_left, expected_right) {
+        } else if is_qpath_def_path(cx, path_right, arms[1].pat.hir_id, expected_left)
+            && is_qpath_def_path(cx, path_left, arms[0].pat.hir_id, expected_right)
+        {
             (&(*arms[1].body).kind, &(*arms[0].body).kind)
         } else {
             return None;
diff --git a/clippy_lints/src/methods/filter_map_identity.rs b/clippy_lints/src/methods/filter_map_identity.rs
index 3a61f4ccad7..403fe8d3546 100644
--- a/clippy_lints/src/methods/filter_map_identity.rs
+++ b/clippy_lints/src/methods/filter_map_identity.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::{is_trait_method, match_qpath, path_to_local_id, paths};
+use clippy_utils::{is_expr_path_def_path, is_trait_method, path_to_local_id, paths};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
@@ -33,14 +33,8 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, filter_map_arg:
             }
         }
 
-        if_chain! {
-            if let hir::ExprKind::Path(ref qpath) = filter_map_arg.kind;
-
-            if match_qpath(qpath, &paths::STD_CONVERT_IDENTITY);
-
-            then {
-                apply_lint("called `filter_map(std::convert::identity)` on an `Iterator`");
-            }
+        if is_expr_path_def_path(cx, filter_map_arg, &paths::CONVERT_IDENTITY) {
+            apply_lint("called `filter_map(std::convert::identity)` on an `Iterator`");
         }
     }
 }
diff --git a/clippy_lints/src/methods/flat_map_identity.rs b/clippy_lints/src/methods/flat_map_identity.rs
index dd613d0cd63..25f8434cb94 100644
--- a/clippy_lints/src/methods/flat_map_identity.rs
+++ b/clippy_lints/src/methods/flat_map_identity.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::{is_trait_method, match_qpath, paths};
+use clippy_utils::{is_expr_path_def_path, is_trait_method, paths};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
@@ -16,8 +16,6 @@ pub(super) fn check<'tcx>(
     flat_map_span: Span,
 ) {
     if is_trait_method(cx, expr, sym::Iterator) {
-        let arg_node = &flat_map_arg.kind;
-
         let apply_lint = |message: &str| {
             span_lint_and_sugg(
                 cx,
@@ -31,8 +29,8 @@ pub(super) fn check<'tcx>(
         };
 
         if_chain! {
-            if let hir::ExprKind::Closure(_, _, body_id, _, _) = arg_node;
-            let body = cx.tcx.hir().body(*body_id);
+            if let hir::ExprKind::Closure(_, _, body_id, _, _) = flat_map_arg.kind;
+            let body = cx.tcx.hir().body(body_id);
 
             if let hir::PatKind::Binding(_, _, binding_ident, _) = body.params[0].pat.kind;
             if let hir::ExprKind::Path(hir::QPath::Resolved(_, path)) = body.value.kind;
@@ -45,14 +43,8 @@ pub(super) fn check<'tcx>(
             }
         }
 
-        if_chain! {
-            if let hir::ExprKind::Path(ref qpath) = arg_node;
-
-            if match_qpath(qpath, &paths::STD_CONVERT_IDENTITY);
-
-            then {
-                apply_lint("called `flat_map(std::convert::identity)` on an `Iterator`");
-            }
+        if is_expr_path_def_path(cx, flat_map_arg, &paths::CONVERT_IDENTITY) {
+            apply_lint("called `flat_map(std::convert::identity)` on an `Iterator`");
         }
     }
 }
diff --git a/clippy_lints/src/methods/from_iter_instead_of_collect.rs b/clippy_lints/src/methods/from_iter_instead_of_collect.rs
index 707c54f7a3c..28d0e8cd4ae 100644
--- a/clippy_lints/src/methods/from_iter_instead_of_collect.rs
+++ b/clippy_lints/src/methods/from_iter_instead_of_collect.rs
@@ -1,26 +1,23 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::ty::implements_trait;
-use clippy_utils::{get_trait_def_id, match_qpath, paths, sugg};
+use clippy_utils::{is_expr_path_def_path, paths, sugg};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
-use rustc_hir::ExprKind;
 use rustc_lint::{LateContext, LintContext};
 use rustc_middle::ty::Ty;
 use rustc_span::sym;
 
 use super::FROM_ITER_INSTEAD_OF_COLLECT;
 
-pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::Expr<'_>], func_kind: &ExprKind<'_>) {
+pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::Expr<'_>], func: &hir::Expr<'_>) {
     if_chain! {
-        if let hir::ExprKind::Path(path) = func_kind;
-        if match_qpath(path, &["from_iter"]);
+        if is_expr_path_def_path(cx, func, &paths::FROM_ITERATOR_METHOD);
         let ty = cx.typeck_results().expr_ty(expr);
         let arg_ty = cx.typeck_results().expr_ty(&args[0]);
-        if let Some(from_iter_id) = get_trait_def_id(cx, &paths::FROM_ITERATOR);
         if let Some(iter_id) = cx.tcx.get_diagnostic_item(sym::Iterator);
 
-        if implements_trait(cx, ty, from_iter_id, &[]) && implements_trait(cx, arg_ty, iter_id, &[]);
+        if implements_trait(cx, arg_ty, iter_id, &[]);
         then {
             // `expr` implements `FromIterator` trait
             let iter_expr = sugg::Sugg::hir(cx, &args[0], "..").maybe_par();
diff --git a/clippy_lints/src/methods/manual_saturating_arithmetic.rs b/clippy_lints/src/methods/manual_saturating_arithmetic.rs
index ecb8b72ef46..2fddea7068d 100644
--- a/clippy_lints/src/methods/manual_saturating_arithmetic.rs
+++ b/clippy_lints/src/methods/manual_saturating_arithmetic.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::match_qpath;
+use clippy_utils::is_qpath_def_path;
 use clippy_utils::source::snippet_with_applicability;
 use if_chain::if_chain;
 use rustc_ast::ast;
@@ -94,11 +94,11 @@ fn is_min_or_max<'tcx>(cx: &LateContext<'tcx>, expr: &hir::Expr<'_>) -> Option<M
 
     // `std::T::MAX` `std::T::MIN` constants
     if let hir::ExprKind::Path(path) = &expr.kind {
-        if match_qpath(path, &["core", &ty_str, "MAX"][..]) {
+        if is_qpath_def_path(cx, path, expr.hir_id, &["core", &ty_str, "MAX"][..]) {
             return Some(MinMax::Max);
         }
 
-        if match_qpath(path, &["core", &ty_str, "MIN"][..]) {
+        if is_qpath_def_path(cx, path, expr.hir_id, &["core", &ty_str, "MIN"][..]) {
             return Some(MinMax::Min);
         }
     }
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index b2faaef0786..6c21ff0f6c2 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1708,7 +1708,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
 
         match expr.kind {
             hir::ExprKind::Call(func, args) => {
-                from_iter_instead_of_collect::check(cx, expr, args, &func.kind);
+                from_iter_instead_of_collect::check(cx, expr, args, func);
             },
             hir::ExprKind::MethodCall(method_call, ref method_span, args, _) => {
                 or_fun_call::check(cx, expr, *method_span, &method_call.ident.as_str(), args);
diff --git a/clippy_lints/src/methods/uninit_assumed_init.rs b/clippy_lints/src/methods/uninit_assumed_init.rs
index 0ae65c0c01d..1a5894e48d1 100644
--- a/clippy_lints/src/methods/uninit_assumed_init.rs
+++ b/clippy_lints/src/methods/uninit_assumed_init.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint;
-use clippy_utils::{match_def_path, match_qpath, paths};
+use clippy_utils::{is_expr_path_def_path, match_def_path, paths};
 use if_chain::if_chain;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
@@ -12,8 +12,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr
     if_chain! {
         if let hir::ExprKind::Call(callee, args) = recv.kind;
         if args.is_empty();
-        if let hir::ExprKind::Path(ref path) = callee.kind;
-        if match_qpath(path, &paths::MEM_MAYBEUNINIT_UNINIT);
+        if is_expr_path_def_path(cx, callee, &paths::MEM_MAYBEUNINIT_UNINIT);
         if !is_maybe_uninit_ty_valid(cx, cx.typeck_results().expr_ty_adjusted(expr));
         then {
             span_lint(
diff --git a/clippy_lints/src/methods/unnecessary_filter_map.rs b/clippy_lints/src/methods/unnecessary_filter_map.rs
index 66255b77331..b61c4ffe9b3 100644
--- a/clippy_lints/src/methods/unnecessary_filter_map.rs
+++ b/clippy_lints/src/methods/unnecessary_filter_map.rs
@@ -61,8 +61,6 @@ fn check_expression<'tcx>(cx: &LateContext<'tcx>, arg_id: hir::HirId, expr: &'tc
                     }
                     return (true, false);
                 }
-                // We don't know. It might do anything.
-                return (true, true);
             }
             (true, true)
         },
diff --git a/clippy_lints/src/misc.rs b/clippy_lints/src/misc.rs
index d156c1d5bf4..0b0cd9be46c 100644
--- a/clippy_lints/src/misc.rs
+++ b/clippy_lints/src/misc.rs
@@ -20,8 +20,8 @@ use rustc_span::symbol::sym;
 use crate::consts::{constant, Constant};
 use clippy_utils::sugg::Sugg;
 use clippy_utils::{
-    get_item_name, get_parent_expr, higher, in_constant, is_diag_trait_item, is_integer_const, iter_input_pats,
-    last_path_segment, match_qpath, unsext, SpanlessEq,
+    expr_path_res, get_item_name, get_parent_expr, higher, in_constant, is_diag_trait_item, is_integer_const,
+    iter_input_pats, last_path_segment, match_any_def_paths, paths, unsext, SpanlessEq,
 };
 
 declare_clippy_lint! {
@@ -564,13 +564,13 @@ fn check_to_owned(cx: &LateContext<'_>, expr: &Expr<'_>, other: &Expr<'_>, left:
                 }
             )
         },
-        ExprKind::Call(path, v) if v.len() == 1 => {
-            if let ExprKind::Path(ref path) = path.kind {
-                if match_qpath(path, &["String", "from_str"]) || match_qpath(path, &["String", "from"]) {
-                    (cx.typeck_results().expr_ty(&v[0]), snippet(cx, v[0].span, ".."))
-                } else {
-                    return;
-                }
+        ExprKind::Call(path, [arg]) => {
+            if expr_path_res(cx, path)
+                .opt_def_id()
+                .and_then(|id| match_any_def_paths(cx, id, &[&paths::FROM_STR_METHOD, &paths::FROM_FROM]))
+                .is_some()
+            {
+                (cx.typeck_results().expr_ty(arg), snippet(cx, arg.span, ".."))
             } else {
                 return;
             }
diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs
index 2ab1e958ec8..b0674f90678 100644
--- a/clippy_lints/src/ptr.rs
+++ b/clippy_lints/src/ptr.rs
@@ -4,7 +4,7 @@ use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg, span_lint_and_the
 use clippy_utils::ptr::get_spans;
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::{is_type_diagnostic_item, match_type, walk_ptrs_hir_ty};
-use clippy_utils::{is_allowed, match_def_path, paths};
+use clippy_utils::{expr_path_res, is_allowed, match_any_def_paths, paths};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{
@@ -417,14 +417,11 @@ fn get_rptr_lm<'tcx>(ty: &'tcx Ty<'tcx>) -> Option<(&'tcx Lifetime, Mutability,
 }
 
 fn is_null_path(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-    if_chain! {
-        if let ExprKind::Call(path, []) = expr.kind;
-        if let ExprKind::Path(ref qpath) = path.kind;
-        if let Some(fn_def_id) = cx.qpath_res(qpath, path.hir_id).opt_def_id();
-        then {
-            match_def_path(cx, fn_def_id, &paths::PTR_NULL) || match_def_path(cx, fn_def_id, &paths::PTR_NULL_MUT)
-        } else {
-            false
-        }
+    if let ExprKind::Call(pathexp, []) = expr.kind {
+        expr_path_res(cx, pathexp).opt_def_id().map_or(false, |id| {
+            match_any_def_paths(cx, id, &[&paths::PTR_NULL, &paths::PTR_NULL_MUT]).is_some()
+        })
+    } else {
+        false
     }
 }
diff --git a/clippy_lints/src/question_mark.rs b/clippy_lints/src/question_mark.rs
index ea9ff37e13f..30bee213900 100644
--- a/clippy_lints/src/question_mark.rs
+++ b/clippy_lints/src/question_mark.rs
@@ -3,10 +3,10 @@ use clippy_utils::is_lang_ctor;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{eq_expr_value, match_qpath};
+use clippy_utils::{eq_expr_value, path_to_local_id};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
-use rustc_hir::LangItem::OptionNone;
+use rustc_hir::LangItem::{OptionNone, OptionSome};
 use rustc_hir::{BindingAnnotation, Block, Expr, ExprKind, MatchSource, PatKind, StmtKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -101,15 +101,14 @@ impl QuestionMark {
             if Self::is_option(cx, subject);
 
             if let PatKind::TupleStruct(path1, fields, None) = &arms[0].pat.kind;
-            if match_qpath(path1, &["Some"]);
-            if let PatKind::Binding(annot, _, bind, _) = &fields[0].kind;
+            if is_lang_ctor(cx, path1, OptionSome);
+            if let PatKind::Binding(annot, bind_id, _, _) = fields[0].kind;
             let by_ref = matches!(annot, BindingAnnotation::Ref | BindingAnnotation::RefMut);
 
             if let ExprKind::Block(block, None) = &arms[0].body.kind;
             if block.stmts.is_empty();
             if let Some(trailing_expr) = &block.expr;
-            if let ExprKind::Path(path) = &trailing_expr.kind;
-            if match_qpath(path, &[&bind.as_str()]);
+            if path_to_local_id(trailing_expr, bind_id);
 
             if let PatKind::Wild = arms[1].pat.kind;
             if Self::expression_returns_none(cx, arms[1].body);
diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
index 3a6151dce71..b565c77aaec 100644
--- a/clippy_lints/src/returns.rs
+++ b/clippy_lints/src/returns.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::snippet_opt;
-use clippy_utils::{fn_def_id, in_macro, match_qpath};
+use clippy_utils::{fn_def_id, in_macro, path_to_local_id};
 use if_chain::if_chain;
 use rustc_ast::ast::Attribute;
 use rustc_errors::Applicability;
@@ -84,9 +84,8 @@ impl<'tcx> LateLintPass<'tcx> for Return {
             if local.ty.is_none();
             if cx.tcx.hir().attrs(local.hir_id).is_empty();
             if let Some(initexpr) = &local.init;
-            if let PatKind::Binding(.., ident, _) = local.pat.kind;
-            if let ExprKind::Path(qpath) = &retexpr.kind;
-            if match_qpath(qpath, &[&*ident.name.as_str()]);
+            if let PatKind::Binding(_, local_id, _, _) = local.pat.kind;
+            if path_to_local_id(retexpr, local_id);
             if !last_statement_borrows(cx, initexpr);
             if !in_external_macro(cx.sess(), initexpr.span);
             if !in_external_macro(cx.sess(), retexpr.span);
diff --git a/clippy_lints/src/slow_vector_initialization.rs b/clippy_lints/src/slow_vector_initialization.rs
index 8cf89ae456e..191781be000 100644
--- a/clippy_lints/src/slow_vector_initialization.rs
+++ b/clippy_lints/src/slow_vector_initialization.rs
@@ -1,6 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::sugg::Sugg;
-use clippy_utils::{get_enclosing_block, match_qpath, SpanlessEq};
+use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::{get_enclosing_block, is_expr_path_def_path, path_to_local, path_to_local_id, paths, SpanlessEq};
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
@@ -9,7 +10,7 @@ use rustc_hir::{BindingAnnotation, Block, Expr, ExprKind, HirId, PatKind, QPath,
 use rustc_lint::{LateContext, LateLintPass, Lint};
 use rustc_middle::hir::map::Map;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::symbol::Symbol;
+use rustc_span::symbol::sym;
 
 declare_clippy_lint! {
     /// **What it does:** Checks slow zero-filled vector initialization
@@ -46,8 +47,8 @@ declare_lint_pass!(SlowVectorInit => [SLOW_VECTOR_INITIALIZATION]);
 /// assigned to a variable. For example, `let mut vec = Vec::with_capacity(0)` or
 /// `vec = Vec::with_capacity(0)`
 struct VecAllocation<'tcx> {
-    /// Symbol of the local variable name
-    variable_name: Symbol,
+    /// HirId of the variable
+    local_id: HirId,
 
     /// Reference to the expression which allocates the vector
     allocation_expr: &'tcx Expr<'tcx>,
@@ -72,16 +73,15 @@ impl<'tcx> LateLintPass<'tcx> for SlowVectorInit {
         if_chain! {
             if let ExprKind::Assign(left, right, _) = expr.kind;
 
-            // Extract variable name
-            if let ExprKind::Path(QPath::Resolved(_, path)) = left.kind;
-            if let Some(variable_name) = path.segments.get(0);
+            // Extract variable
+            if let Some(local_id) = path_to_local(left);
 
             // Extract len argument
-            if let Some(len_arg) = Self::is_vec_with_capacity(right);
+            if let Some(len_arg) = Self::is_vec_with_capacity(cx, right);
 
             then {
                 let vi = VecAllocation {
-                    variable_name: variable_name.ident.name,
+                    local_id,
                     allocation_expr: right,
                     len_expr: len_arg,
                 };
@@ -95,13 +95,13 @@ impl<'tcx> LateLintPass<'tcx> for SlowVectorInit {
         // Matches statements which initializes vectors. For example: `let mut vec = Vec::with_capacity(10)`
         if_chain! {
             if let StmtKind::Local(local) = stmt.kind;
-            if let PatKind::Binding(BindingAnnotation::Mutable, .., variable_name, None) = local.pat.kind;
+            if let PatKind::Binding(BindingAnnotation::Mutable, local_id, _, None) = local.pat.kind;
             if let Some(init) = local.init;
-            if let Some(len_arg) = Self::is_vec_with_capacity(init);
+            if let Some(len_arg) = Self::is_vec_with_capacity(cx, init);
 
             then {
                 let vi = VecAllocation {
-                    variable_name: variable_name.name,
+                    local_id,
                     allocation_expr: init,
                     len_expr: len_arg,
                 };
@@ -115,19 +115,18 @@ impl<'tcx> LateLintPass<'tcx> for SlowVectorInit {
 impl SlowVectorInit {
     /// Checks if the given expression is `Vec::with_capacity(..)`. It will return the expression
     /// of the first argument of `with_capacity` call if it matches or `None` if it does not.
-    fn is_vec_with_capacity<'tcx>(expr: &Expr<'tcx>) -> Option<&'tcx Expr<'tcx>> {
+    fn is_vec_with_capacity<'tcx>(cx: &LateContext<'_>, expr: &Expr<'tcx>) -> Option<&'tcx Expr<'tcx>> {
         if_chain! {
-            if let ExprKind::Call(func, args) = expr.kind;
-            if let ExprKind::Path(ref path) = func.kind;
-            if match_qpath(path, &["Vec", "with_capacity"]);
-            if args.len() == 1;
-
+            if let ExprKind::Call(func, [arg]) = expr.kind;
+            if let ExprKind::Path(QPath::TypeRelative(ty, name)) = func.kind;
+            if name.ident.as_str() == "with_capacity";
+            if is_type_diagnostic_item(cx, cx.typeck_results().node_type(ty.hir_id), sym::vec_type);
             then {
-                return Some(&args[0]);
+                Some(arg)
+            } else {
+                None
             }
         }
-
-        None
     }
 
     /// Search initialization for the given vector
@@ -208,11 +207,9 @@ impl<'a, 'tcx> VectorInitializationVisitor<'a, 'tcx> {
     fn search_slow_extend_filling(&mut self, expr: &'tcx Expr<'_>) {
         if_chain! {
             if self.initialization_found;
-            if let ExprKind::MethodCall(path, _, args, _) = expr.kind;
-            if let ExprKind::Path(ref qpath_subj) = args[0].kind;
-            if match_qpath(qpath_subj, &[&*self.vec_alloc.variable_name.as_str()]);
+            if let ExprKind::MethodCall(path, _, [self_arg, extend_arg], _) = expr.kind;
+            if path_to_local_id(self_arg, self.vec_alloc.local_id);
             if path.ident.name == sym!(extend);
-            if let Some(extend_arg) = args.get(1);
             if self.is_repeat_take(extend_arg);
 
             then {
@@ -225,11 +222,9 @@ impl<'a, 'tcx> VectorInitializationVisitor<'a, 'tcx> {
     fn search_slow_resize_filling(&mut self, expr: &'tcx Expr<'_>) {
         if_chain! {
             if self.initialization_found;
-            if let ExprKind::MethodCall(path, _, args, _) = expr.kind;
-            if let ExprKind::Path(ref qpath_subj) = args[0].kind;
-            if match_qpath(qpath_subj, &[&*self.vec_alloc.variable_name.as_str()]);
+            if let ExprKind::MethodCall(path, _, [self_arg, len_arg, fill_arg], _) = expr.kind;
+            if path_to_local_id(self_arg, self.vec_alloc.local_id);
             if path.ident.name == sym!(resize);
-            if let (Some(len_arg), Some(fill_arg)) = (args.get(1), args.get(2));
 
             // Check that is filled with 0
             if let ExprKind::Lit(ref lit) = fill_arg.kind;
@@ -252,7 +247,7 @@ impl<'a, 'tcx> VectorInitializationVisitor<'a, 'tcx> {
 
             // Check that take is applied to `repeat(0)`
             if let Some(repeat_expr) = take_args.get(0);
-            if Self::is_repeat_zero(repeat_expr);
+            if self.is_repeat_zero(repeat_expr);
 
             // Check that len expression is equals to `with_capacity` expression
             if let Some(len_arg) = take_args.get(1);
@@ -267,21 +262,19 @@ impl<'a, 'tcx> VectorInitializationVisitor<'a, 'tcx> {
     }
 
     /// Returns `true` if given expression is `repeat(0)`
-    fn is_repeat_zero(expr: &Expr<'_>) -> bool {
+    fn is_repeat_zero(&self, expr: &Expr<'_>) -> bool {
         if_chain! {
-            if let ExprKind::Call(fn_expr, repeat_args) = expr.kind;
-            if let ExprKind::Path(ref qpath_repeat) = fn_expr.kind;
-            if match_qpath(qpath_repeat, &["repeat"]);
-            if let Some(repeat_arg) = repeat_args.get(0);
+            if let ExprKind::Call(fn_expr, [repeat_arg]) = expr.kind;
+            if is_expr_path_def_path(self.cx, fn_expr, &paths::ITER_REPEAT);
             if let ExprKind::Lit(ref lit) = repeat_arg.kind;
             if let LitKind::Int(0, _) = lit.node;
 
             then {
-                return true
+                true
+            } else {
+                false
             }
         }
-
-        false
     }
 }
 
diff --git a/clippy_lints/src/transmuting_null.rs b/clippy_lints/src/transmuting_null.rs
index 755132da591..888ecab1046 100644
--- a/clippy_lints/src/transmuting_null.rs
+++ b/clippy_lints/src/transmuting_null.rs
@@ -1,6 +1,6 @@
 use crate::consts::{constant_context, Constant};
 use clippy_utils::diagnostics::span_lint;
-use clippy_utils::{match_def_path, paths};
+use clippy_utils::{is_expr_path_def_path, paths};
 use if_chain::if_chain;
 use rustc_ast::LitKind;
 use rustc_hir::{Expr, ExprKind};
@@ -37,18 +37,15 @@ impl<'tcx> LateLintPass<'tcx> for TransmutingNull {
         }
 
         if_chain! {
-            if let ExprKind::Call(func, args) = expr.kind;
-            if args.len() == 1;
-            if let ExprKind::Path(ref path) = func.kind;
-            if let Some(func_def_id) = cx.qpath_res(path, func.hir_id).opt_def_id();
-            if match_def_path(cx, func_def_id, &paths::TRANSMUTE);
-            then {
+            if let ExprKind::Call(func, [arg]) = expr.kind;
+            if is_expr_path_def_path(cx, func, &paths::TRANSMUTE);
 
+            then {
                 // Catching transmute over constants that resolve to `null`.
                 let mut const_eval_context = constant_context(cx, cx.typeck_results());
                 if_chain! {
-                    if let ExprKind::Path(ref _qpath) = args[0].kind;
-                    let x = const_eval_context.expr(&args[0]);
+                    if let ExprKind::Path(ref _qpath) = arg.kind;
+                    let x = const_eval_context.expr(arg);
                     if let Some(Constant::RawPtr(0)) = x;
                     then {
                         span_lint(cx, TRANSMUTING_NULL, expr.span, LINT_MSG)
@@ -58,7 +55,7 @@ impl<'tcx> LateLintPass<'tcx> for TransmutingNull {
                 // Catching:
                 // `std::mem::transmute(0 as *const i32)`
                 if_chain! {
-                    if let ExprKind::Cast(inner_expr, _cast_ty) = args[0].kind;
+                    if let ExprKind::Cast(inner_expr, _cast_ty) = arg.kind;
                     if let ExprKind::Lit(ref lit) = inner_expr.kind;
                     if let LitKind::Int(0, _) = lit.node;
                     then {
@@ -69,10 +66,8 @@ impl<'tcx> LateLintPass<'tcx> for TransmutingNull {
                 // Catching:
                 // `std::mem::transmute(std::ptr::null::<i32>())`
                 if_chain! {
-                    if let ExprKind::Call(func1, []) = args[0].kind;
-                    if let ExprKind::Path(ref path1) = func1.kind;
-                    if let Some(func1_def_id) = cx.qpath_res(path1, func1.hir_id).opt_def_id();
-                    if match_def_path(cx, func1_def_id, &paths::PTR_NULL);
+                    if let ExprKind::Call(func1, []) = arg.kind;
+                    if is_expr_path_def_path(cx, func1, &paths::PTR_NULL);
                     then {
                         span_lint(cx, TRANSMUTING_NULL, expr.span, LINT_MSG)
                     }
diff --git a/clippy_lints/src/types/borrowed_box.rs b/clippy_lints/src/types/borrowed_box.rs
index 1425d8f3f37..bdeff035e5e 100644
--- a/clippy_lints/src/types/borrowed_box.rs
+++ b/clippy_lints/src/types/borrowed_box.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet;
-use clippy_utils::{match_path, paths};
+use clippy_utils::{match_def_path, paths};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{
@@ -28,7 +28,7 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, lt: &Lifetime, m
                     _ => None,
                 });
                 then {
-                    if is_any_trait(inner) {
+                    if is_any_trait(cx, inner) {
                         // Ignore `Box<Any>` types; see issue #1884 for details.
                         return false;
                     }
@@ -84,13 +84,14 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, lt: &Lifetime, m
 }
 
 // Returns true if given type is `Any` trait.
-fn is_any_trait(t: &hir::Ty<'_>) -> bool {
+fn is_any_trait(cx: &LateContext<'_>, t: &hir::Ty<'_>) -> bool {
     if_chain! {
         if let TyKind::TraitObject(traits, ..) = t.kind;
         if !traits.is_empty();
+        if let Some(trait_did) = traits[0].trait_ref.trait_def_id();
         // Only Send/Sync can be used as additional traits, so it is enough to
         // check only the first trait.
-        if match_path(traits[0].trait_ref.path, &paths::ANY_TRAIT);
+        if match_def_path(cx, trait_did, &paths::ANY_TRAIT);
         then {
             return true;
         }
diff --git a/clippy_lints/src/unnecessary_wraps.rs b/clippy_lints/src/unnecessary_wraps.rs
index d2c0f60d296..f2f1410aed7 100644
--- a/clippy_lints/src/unnecessary_wraps.rs
+++ b/clippy_lints/src/unnecessary_wraps.rs
@@ -104,14 +104,12 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryWraps {
             if_chain! {
                 if !in_macro(ret_expr.span);
                 // Check if a function call.
-                if let ExprKind::Call(func, args) = ret_expr.kind;
-                // Get the Path of the function call.
-                if let ExprKind::Path(ref qpath) = func.kind;
+                if let ExprKind::Call(func, [arg]) = ret_expr.kind;
                 // Check if OPTION_SOME or RESULT_OK, depending on return type.
+                if let ExprKind::Path(qpath) = &func.kind;
                 if is_lang_ctor(cx, qpath, lang_item);
-                if args.len() == 1;
                 // Make sure the function argument does not contain a return expression.
-                if !contains_return(&args[0]);
+                if !contains_return(arg);
                 then {
                     suggs.push(
                         (
@@ -119,7 +117,7 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryWraps {
                             if inner_type.is_unit() {
                                 "".to_string()
                             } else {
-                                snippet(cx, args[0].span.source_callsite(), "..").to_string()
+                                snippet(cx, arg.span.source_callsite(), "..").to_string()
                             }
                         )
                     );
diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs
index cf8039d6059..3d3d0e19d26 100644
--- a/clippy_lints/src/utils/internal_lints.rs
+++ b/clippy_lints/src/utils/internal_lints.rs
@@ -3,7 +3,8 @@ use clippy_utils::diagnostics::{span_lint, span_lint_and_help, span_lint_and_sug
 use clippy_utils::source::snippet;
 use clippy_utils::ty::match_type;
 use clippy_utils::{
-    is_else_clause, is_expn_of, match_def_path, match_qpath, method_calls, path_to_res, paths, run_lints, SpanlessEq,
+    is_else_clause, is_expn_of, is_expr_path_def_path, match_def_path, method_calls, path_to_res, paths, run_lints,
+    SpanlessEq,
 };
 use if_chain::if_chain;
 use rustc_ast::ast::{Crate as AstCrate, ItemKind, LitKind, ModKind, NodeId};
@@ -578,8 +579,7 @@ impl<'tcx> LateLintPass<'tcx> for CollapsibleCalls {
 
         if_chain! {
             if let ExprKind::Call(func, and_then_args) = expr.kind;
-            if let ExprKind::Path(ref path) = func.kind;
-            if match_qpath(path, &["span_lint_and_then"]);
+            if is_expr_path_def_path(cx, func, &["clippy_utils", "diagnostics", "span_lint_and_then"]);
             if and_then_args.len() == 5;
             if let ExprKind::Closure(_, _, body_id, _, _) = &and_then_args[4].kind;
             let body = cx.tcx.hir().body(*body_id);
@@ -761,8 +761,7 @@ impl<'tcx> LateLintPass<'tcx> for MatchTypeOnDiagItem {
         if_chain! {
             // Check if this is a call to utils::match_type()
             if let ExprKind::Call(fn_path, [context, ty, ty_path]) = expr.kind;
-            if let ExprKind::Path(fn_qpath) = &fn_path.kind;
-            if match_qpath(fn_qpath, &["utils", "match_type"]);
+            if is_expr_path_def_path(cx, fn_path, &["clippy_utils", "ty", "match_type"]);
             // Extract the path to the matched type
             if let Some(segments) = path_to_matched_type(cx, ty_path);
             let segments: Vec<&str> = segments.iter().map(|sym| &**sym).collect();
@@ -771,6 +770,7 @@ impl<'tcx> LateLintPass<'tcx> for MatchTypeOnDiagItem {
             let diag_items = cx.tcx.diagnostic_items(ty_did.krate);
             if let Some(item_name) = diag_items.iter().find_map(|(k, v)| if *v == ty_did { Some(k) } else { None });
             then {
+                // TODO: check paths constants from external crates.
                 let cx_snippet = snippet(cx, context.span, "_");
                 let ty_snippet = snippet(cx, ty.span, "_");
 
@@ -778,9 +778,9 @@ impl<'tcx> LateLintPass<'tcx> for MatchTypeOnDiagItem {
                     cx,
                     MATCH_TYPE_ON_DIAGNOSTIC_ITEM,
                     expr.span,
-                    "usage of `utils::match_type()` on a type diagnostic item",
+                    "usage of `clippy_utils::ty::match_type()` on a type diagnostic item",
                     "try",
-                    format!("utils::is_type_diagnostic_item({}, {}, sym::{})", cx_snippet, ty_snippet, item_name),
+                    format!("clippy_utils::ty::is_type_diagnostic_item({}, {}, sym::{})", cx_snippet, ty_snippet, item_name),
                     Applicability::MaybeIncorrect,
                 );
             }
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 8e1a2105b96..4a523520a43 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -397,6 +397,29 @@ pub fn match_qpath(path: &QPath<'_>, segments: &[&str]) -> bool {
     }
 }
 
+/// If the expression is a path, resolve it. Otherwise, return `Res::Err`.
+pub fn expr_path_res(cx: &LateContext<'_>, expr: &Expr<'_>) -> Res {
+    if let ExprKind::Path(p) = &expr.kind {
+        cx.qpath_res(p, expr.hir_id)
+    } else {
+        Res::Err
+    }
+}
+
+/// Resolves the path to a `DefId` and checks if it matches the given path.
+pub fn is_qpath_def_path(cx: &LateContext<'_>, path: &QPath<'_>, hir_id: HirId, segments: &[&str]) -> bool {
+    cx.qpath_res(path, hir_id)
+        .opt_def_id()
+        .map_or(false, |id| match_def_path(cx, id, segments))
+}
+
+/// If the expression is a path, resolves it to a `DefId` and checks if it matches the given path.
+pub fn is_expr_path_def_path(cx: &LateContext<'_>, expr: &Expr<'_>, segments: &[&str]) -> bool {
+    expr_path_res(cx, expr)
+        .opt_def_id()
+        .map_or(false, |id| match_def_path(cx, id, segments))
+}
+
 /// THIS METHOD IS DEPRECATED and will eventually be removed since it does not match against the
 /// entire path or resolved `DefId`. Prefer using `match_def_path`. Consider getting a `DefId` from
 /// `QPath::Resolved.1.res.opt_def_id()`.
@@ -425,20 +448,6 @@ pub fn match_path(path: &Path<'_>, segments: &[&str]) -> bool {
         .all(|(a, b)| a.ident.name.as_str() == *b)
 }
 
-/// Matches a `Path` against a slice of segment string literals, e.g.
-///
-/// # Examples
-/// ```rust,ignore
-/// match_path_ast(path, &["std", "rt", "begin_unwind"])
-/// ```
-pub fn match_path_ast(path: &ast::Path, segments: &[&str]) -> bool {
-    path.segments
-        .iter()
-        .rev()
-        .zip(segments.iter().rev())
-        .all(|(a, b)| a.ident.name.as_str() == *b)
-}
-
 /// If the expression is a path to a local, returns the canonical `HirId` of the local.
 pub fn path_to_local(expr: &Expr<'_>) -> Option<HirId> {
     if let ExprKind::Path(QPath::Resolved(None, ref path)) = expr.kind {
@@ -1148,29 +1157,47 @@ pub fn match_function_call<'tcx>(
     None
 }
 
+/// Checks if the given `DefId` matches any of the paths. Returns the index of matching path, if
+/// any.
+pub fn match_any_def_paths(cx: &LateContext<'_>, did: DefId, paths: &[&[&str]]) -> Option<usize> {
+    let search_path = cx.get_def_path(did);
+    paths
+        .iter()
+        .position(|p| p.iter().map(|x| Symbol::intern(x)).eq(search_path.iter().cloned()))
+}
+
+/// Checks if the given `DefId` matches the path.
 pub fn match_def_path<'tcx>(cx: &LateContext<'tcx>, did: DefId, syms: &[&str]) -> bool {
-    // We have to convert `syms` to `&[Symbol]` here because rustc's `match_def_path`
-    // accepts only that. We should probably move to Symbols in Clippy as well.
-    let syms = syms.iter().map(|p| Symbol::intern(p)).collect::<Vec<Symbol>>();
-    cx.match_def_path(did, &syms)
+    // We should probably move to Symbols in Clippy as well rather than interning every time.
+    let path = cx.get_def_path(did);
+    syms.iter().map(|x| Symbol::intern(x)).eq(path.iter().cloned())
 }
 
-pub fn match_panic_call<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<&'tcx [Expr<'tcx>]> {
-    match_function_call(cx, expr, &paths::BEGIN_PANIC)
-        .or_else(|| match_function_call(cx, expr, &paths::BEGIN_PANIC_FMT))
-        .or_else(|| match_function_call(cx, expr, &paths::PANIC_ANY))
-        .or_else(|| match_function_call(cx, expr, &paths::PANICKING_PANIC))
-        .or_else(|| match_function_call(cx, expr, &paths::PANICKING_PANIC_FMT))
-        .or_else(|| match_function_call(cx, expr, &paths::PANICKING_PANIC_STR))
+pub fn match_panic_call(cx: &LateContext<'_>, expr: &'tcx Expr<'_>) -> Option<&'tcx Expr<'tcx>> {
+    if let ExprKind::Call(func, [arg]) = expr.kind {
+        expr_path_res(cx, func)
+            .opt_def_id()
+            .map_or(false, |id| match_panic_def_id(cx, id))
+            .then(|| arg)
+    } else {
+        None
+    }
 }
 
 pub fn match_panic_def_id(cx: &LateContext<'_>, did: DefId) -> bool {
-    match_def_path(cx, did, &paths::BEGIN_PANIC)
-        || match_def_path(cx, did, &paths::BEGIN_PANIC_FMT)
-        || match_def_path(cx, did, &paths::PANIC_ANY)
-        || match_def_path(cx, did, &paths::PANICKING_PANIC)
-        || match_def_path(cx, did, &paths::PANICKING_PANIC_FMT)
-        || match_def_path(cx, did, &paths::PANICKING_PANIC_STR)
+    match_any_def_paths(
+        cx,
+        did,
+        &[
+            &paths::BEGIN_PANIC,
+            &paths::BEGIN_PANIC_FMT,
+            &paths::PANIC_ANY,
+            &paths::PANICKING_PANIC,
+            &paths::PANICKING_PANIC_FMT,
+            &paths::PANICKING_PANIC_STR,
+        ],
+    )
+    .is_some()
 }
 
 /// Returns the list of condition expressions and the list of blocks in a
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index ed8915f59e1..21011dbded6 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -4,7 +4,7 @@
 //! Whenever possible, please consider diagnostic items over hardcoded paths.
 //! See <https://github.com/rust-lang/rust-clippy/issues/5393> for more information.
 
-pub const ANY_TRAIT: [&str; 3] = ["std", "any", "Any"];
+pub const ANY_TRAIT: [&str; 3] = ["core", "any", "Any"];
 pub const ARC_PTR_EQ: [&str; 4] = ["alloc", "sync", "Arc", "ptr_eq"];
 pub const ASMUT_TRAIT: [&str; 3] = ["core", "convert", "AsMut"];
 pub const ASREF_TRAIT: [&str; 3] = ["core", "convert", "AsRef"];
@@ -42,6 +42,8 @@ pub const FMT_ARGUMENTS_NEW_V1_FORMATTED: [&str; 4] = ["core", "fmt", "Arguments
 pub const FMT_ARGUMENTV1_NEW: [&str; 4] = ["core", "fmt", "ArgumentV1", "new"];
 pub const FROM_FROM: [&str; 4] = ["core", "convert", "From", "from"];
 pub const FROM_ITERATOR: [&str; 5] = ["core", "iter", "traits", "collect", "FromIterator"];
+pub const FROM_ITERATOR_METHOD: [&str; 6] = ["core", "iter", "traits", "collect", "FromIterator", "from_iter"];
+pub const FROM_STR_METHOD: [&str; 5] = ["core", "str", "traits", "FromStr", "from_str"];
 pub const FUTURE_FROM_GENERATOR: [&str; 3] = ["core", "future", "from_generator"];
 pub const HASH: [&str; 3] = ["core", "hash", "Hash"];
 pub const HASHMAP: [&str; 5] = ["std", "collections", "hash", "map", "HashMap"];
@@ -58,8 +60,9 @@ pub const INTO: [&str; 3] = ["core", "convert", "Into"];
 pub const INTO_ITERATOR: [&str; 5] = ["core", "iter", "traits", "collect", "IntoIterator"];
 pub const IO_READ: [&str; 3] = ["std", "io", "Read"];
 pub const IO_WRITE: [&str; 3] = ["std", "io", "Write"];
-pub const IPADDR_V4: [&str; 4] = ["std", "net", "IpAddr", "V4"];
-pub const IPADDR_V6: [&str; 4] = ["std", "net", "IpAddr", "V6"];
+pub const IPADDR_V4: [&str; 5] = ["std", "net", "ip", "IpAddr", "V4"];
+pub const IPADDR_V6: [&str; 5] = ["std", "net", "ip", "IpAddr", "V6"];
+pub const ITER_REPEAT: [&str; 5] = ["core", "iter", "sources", "repeat", "repeat"];
 #[cfg(feature = "internal-lints")]
 pub const KW_MODULE: [&str; 3] = ["rustc_span", "symbol", "kw"];
 #[cfg(feature = "internal-lints")]
@@ -126,7 +129,6 @@ pub const REGEX_BYTES_NEW: [&str; 4] = ["regex", "re_bytes", "Regex", "new"];
 pub const REGEX_BYTES_SET_NEW: [&str; 5] = ["regex", "re_set", "bytes", "RegexSet", "new"];
 pub const REGEX_NEW: [&str; 4] = ["regex", "re_unicode", "Regex", "new"];
 pub const REGEX_SET_NEW: [&str; 5] = ["regex", "re_set", "unicode", "RegexSet", "new"];
-pub const REPEAT: [&str; 3] = ["core", "iter", "repeat"];
 pub const RESULT: [&str; 3] = ["core", "result", "Result"];
 pub const RESULT_ERR: [&str; 4] = ["core", "result", "Result", "Err"];
 pub const RESULT_OK: [&str; 4] = ["core", "result", "Result", "Ok"];
@@ -140,7 +142,7 @@ pub const SLICE_INTO_VEC: [&str; 4] = ["alloc", "slice", "<impl [T]>", "into_vec
 pub const SLICE_ITER: [&str; 4] = ["core", "slice", "iter", "Iter"];
 pub const STDERR: [&str; 4] = ["std", "io", "stdio", "stderr"];
 pub const STDOUT: [&str; 4] = ["std", "io", "stdio", "stdout"];
-pub const STD_CONVERT_IDENTITY: [&str; 3] = ["std", "convert", "identity"];
+pub const CONVERT_IDENTITY: [&str; 3] = ["core", "convert", "identity"];
 pub const STD_FS_CREATE_DIR: [&str; 3] = ["std", "fs", "create_dir"];
 pub const STRING_AS_MUT_STR: [&str; 4] = ["alloc", "string", "String", "as_mut_str"];
 pub const STRING_AS_STR: [&str; 4] = ["alloc", "string", "String", "as_str"];
diff --git a/doc/adding_lints.md b/doc/adding_lints.md
index 99b86953d51..50f0d724016 100644
--- a/doc/adding_lints.md
+++ b/doc/adding_lints.md
@@ -625,7 +625,7 @@ in the following steps:
 Here are some pointers to things you are likely going to need for every lint:
 
 * [Clippy utils][utils] - Various helper functions. Maybe the function you need
-  is already in here (`implements_trait`, `match_path`, `snippet`, etc)
+  is already in here (`implements_trait`, `match_def_path`, `snippet`, etc)
 * [Clippy diagnostics][diagnostics]
 * [The `if_chain` macro][if_chain]
 * [`from_expansion`][from_expansion] and [`in_external_macro`][in_external_macro]
diff --git a/tests/ui-internal/collapsible_span_lint_calls.fixed b/tests/ui-internal/collapsible_span_lint_calls.fixed
index e588c23345e..7764cc8da78 100644
--- a/tests/ui-internal/collapsible_span_lint_calls.fixed
+++ b/tests/ui-internal/collapsible_span_lint_calls.fixed
@@ -2,58 +2,18 @@
 #![deny(clippy::internal)]
 #![feature(rustc_private)]
 
+extern crate clippy_utils;
 extern crate rustc_ast;
 extern crate rustc_errors;
 extern crate rustc_lint;
 extern crate rustc_session;
 extern crate rustc_span;
 
+use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_note, span_lint_and_sugg, span_lint_and_then};
 use rustc_ast::ast::Expr;
-use rustc_errors::{Applicability, DiagnosticBuilder};
-use rustc_lint::{EarlyContext, EarlyLintPass, Lint, LintContext};
+use rustc_errors::Applicability;
+use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::source_map::Span;
-
-#[allow(unused_variables)]
-pub fn span_lint_and_then<'a, T: LintContext, F>(cx: &'a T, lint: &'static Lint, sp: Span, msg: &str, f: F)
-where
-    F: for<'b> FnOnce(&mut DiagnosticBuilder<'b>),
-{
-}
-
-#[allow(unused_variables)]
-fn span_lint_and_help<'a, T: LintContext>(
-    cx: &'a T,
-    lint: &'static Lint,
-    span: Span,
-    msg: &str,
-    option_span: Option<Span>,
-    help: &str,
-) {
-}
-
-#[allow(unused_variables)]
-fn span_lint_and_note<'a, T: LintContext>(
-    cx: &'a T,
-    lint: &'static Lint,
-    span: Span,
-    msg: &str,
-    note_span: Option<Span>,
-    note: &str,
-) {
-}
-
-#[allow(unused_variables)]
-fn span_lint_and_sugg<'a, T: LintContext>(
-    cx: &'a T,
-    lint: &'static Lint,
-    sp: Span,
-    msg: &str,
-    help: &str,
-    sugg: String,
-    applicability: Applicability,
-) {
-}
 
 declare_tool_lint! {
     pub clippy::TEST_LINT,
diff --git a/tests/ui-internal/collapsible_span_lint_calls.rs b/tests/ui-internal/collapsible_span_lint_calls.rs
index d5dd3bb562b..bdd296db832 100644
--- a/tests/ui-internal/collapsible_span_lint_calls.rs
+++ b/tests/ui-internal/collapsible_span_lint_calls.rs
@@ -2,58 +2,18 @@
 #![deny(clippy::internal)]
 #![feature(rustc_private)]
 
+extern crate clippy_utils;
 extern crate rustc_ast;
 extern crate rustc_errors;
 extern crate rustc_lint;
 extern crate rustc_session;
 extern crate rustc_span;
 
+use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_note, span_lint_and_sugg, span_lint_and_then};
 use rustc_ast::ast::Expr;
-use rustc_errors::{Applicability, DiagnosticBuilder};
-use rustc_lint::{EarlyContext, EarlyLintPass, Lint, LintContext};
+use rustc_errors::Applicability;
+use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::source_map::Span;
-
-#[allow(unused_variables)]
-pub fn span_lint_and_then<'a, T: LintContext, F>(cx: &'a T, lint: &'static Lint, sp: Span, msg: &str, f: F)
-where
-    F: for<'b> FnOnce(&mut DiagnosticBuilder<'b>),
-{
-}
-
-#[allow(unused_variables)]
-fn span_lint_and_help<'a, T: LintContext>(
-    cx: &'a T,
-    lint: &'static Lint,
-    span: Span,
-    msg: &str,
-    option_span: Option<Span>,
-    help: &str,
-) {
-}
-
-#[allow(unused_variables)]
-fn span_lint_and_note<'a, T: LintContext>(
-    cx: &'a T,
-    lint: &'static Lint,
-    span: Span,
-    msg: &str,
-    note_span: Option<Span>,
-    note: &str,
-) {
-}
-
-#[allow(unused_variables)]
-fn span_lint_and_sugg<'a, T: LintContext>(
-    cx: &'a T,
-    lint: &'static Lint,
-    sp: Span,
-    msg: &str,
-    help: &str,
-    sugg: String,
-    applicability: Applicability,
-) {
-}
 
 declare_tool_lint! {
     pub clippy::TEST_LINT,
diff --git a/tests/ui-internal/collapsible_span_lint_calls.stderr b/tests/ui-internal/collapsible_span_lint_calls.stderr
index 874d4a9f255..0632b038577 100644
--- a/tests/ui-internal/collapsible_span_lint_calls.stderr
+++ b/tests/ui-internal/collapsible_span_lint_calls.stderr
@@ -1,5 +1,5 @@
 error: this call is collapsible
-  --> $DIR/collapsible_span_lint_calls.rs:75:9
+  --> $DIR/collapsible_span_lint_calls.rs:35:9
    |
 LL | /         span_lint_and_then(cx, TEST_LINT, expr.span, lint_msg, |db| {
 LL | |             db.span_suggestion(expr.span, help_msg, sugg.to_string(), Applicability::MachineApplicable);
@@ -14,7 +14,7 @@ LL | #![deny(clippy::internal)]
    = note: `#[deny(clippy::collapsible_span_lint_calls)]` implied by `#[deny(clippy::internal)]`
 
 error: this call is collapsible
-  --> $DIR/collapsible_span_lint_calls.rs:78:9
+  --> $DIR/collapsible_span_lint_calls.rs:38:9
    |
 LL | /         span_lint_and_then(cx, TEST_LINT, expr.span, lint_msg, |db| {
 LL | |             db.span_help(expr.span, help_msg);
@@ -22,7 +22,7 @@ LL | |         });
    | |__________^ help: collapse into: `span_lint_and_help(cx, TEST_LINT, expr.span, lint_msg, Some(expr.span), help_msg)`
 
 error: this call is collapsible
-  --> $DIR/collapsible_span_lint_calls.rs:81:9
+  --> $DIR/collapsible_span_lint_calls.rs:41:9
    |
 LL | /         span_lint_and_then(cx, TEST_LINT, expr.span, lint_msg, |db| {
 LL | |             db.help(help_msg);
@@ -30,7 +30,7 @@ LL | |         });
    | |__________^ help: collapse into: `span_lint_and_help(cx, TEST_LINT, expr.span, lint_msg, None, help_msg)`
 
 error: this call is collspible
-  --> $DIR/collapsible_span_lint_calls.rs:84:9
+  --> $DIR/collapsible_span_lint_calls.rs:44:9
    |
 LL | /         span_lint_and_then(cx, TEST_LINT, expr.span, lint_msg, |db| {
 LL | |             db.span_note(expr.span, note_msg);
@@ -38,7 +38,7 @@ LL | |         });
    | |__________^ help: collapse into: `span_lint_and_note(cx, TEST_LINT, expr.span, lint_msg, Some(expr.span), note_msg)`
 
 error: this call is collspible
-  --> $DIR/collapsible_span_lint_calls.rs:87:9
+  --> $DIR/collapsible_span_lint_calls.rs:47:9
    |
 LL | /         span_lint_and_then(cx, TEST_LINT, expr.span, lint_msg, |db| {
 LL | |             db.note(note_msg);
diff --git a/tests/ui-internal/match_type_on_diag_item.rs b/tests/ui-internal/match_type_on_diag_item.rs
index fe950b0aa7c..063f0c6460c 100644
--- a/tests/ui-internal/match_type_on_diag_item.rs
+++ b/tests/ui-internal/match_type_on_diag_item.rs
@@ -1,29 +1,18 @@
 #![deny(clippy::internal)]
 #![feature(rustc_private)]
 
+extern crate clippy_utils;
 extern crate rustc_hir;
 extern crate rustc_lint;
 extern crate rustc_middle;
+
 #[macro_use]
 extern crate rustc_session;
+use clippy_utils::{paths, ty::match_type};
 use rustc_hir::Expr;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::Ty;
 
-mod paths {
-    pub const VEC: [&str; 3] = ["alloc", "vec", "Vec"];
-}
-
-mod utils {
-    use super::*;
-
-    pub fn match_type(_cx: &LateContext<'_>, _ty: Ty<'_>, _path: &[&str]) -> bool {
-        false
-    }
-}
-
-use utils::match_type;
-
 declare_lint! {
     pub TEST_LINT,
     Warn,
@@ -38,12 +27,12 @@ impl<'tcx> LateLintPass<'tcx> for Pass {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr) {
         let ty = cx.typeck_results().expr_ty(expr);
 
-        let _ = match_type(cx, ty, &paths::VEC);
+        let _ = match_type(cx, ty, &paths::VEC); // FIXME: Doesn't lint external paths
         let _ = match_type(cx, ty, &OPTION);
         let _ = match_type(cx, ty, &["core", "result", "Result"]);
 
         let rc_path = &["alloc", "rc", "Rc"];
-        let _ = utils::match_type(cx, ty, rc_path);
+        let _ = clippy_utils::ty::match_type(cx, ty, rc_path);
     }
 }
 
diff --git a/tests/ui-internal/match_type_on_diag_item.stderr b/tests/ui-internal/match_type_on_diag_item.stderr
index 82465dbaf6e..71472960565 100644
--- a/tests/ui-internal/match_type_on_diag_item.stderr
+++ b/tests/ui-internal/match_type_on_diag_item.stderr
@@ -1,8 +1,8 @@
-error: usage of `utils::match_type()` on a type diagnostic item
-  --> $DIR/match_type_on_diag_item.rs:41:17
+error: usage of `clippy_utils::ty::match_type()` on a type diagnostic item
+  --> $DIR/match_type_on_diag_item.rs:31:17
    |
-LL |         let _ = match_type(cx, ty, &paths::VEC);
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `utils::is_type_diagnostic_item(cx, ty, sym::vec_type)`
+LL |         let _ = match_type(cx, ty, &OPTION);
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `clippy_utils::ty::is_type_diagnostic_item(cx, ty, sym::option_type)`
    |
 note: the lint level is defined here
   --> $DIR/match_type_on_diag_item.rs:1:9
@@ -11,23 +11,17 @@ LL | #![deny(clippy::internal)]
    |         ^^^^^^^^^^^^^^^^
    = note: `#[deny(clippy::match_type_on_diagnostic_item)]` implied by `#[deny(clippy::internal)]`
 
-error: usage of `utils::match_type()` on a type diagnostic item
-  --> $DIR/match_type_on_diag_item.rs:42:17
-   |
-LL |         let _ = match_type(cx, ty, &OPTION);
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `utils::is_type_diagnostic_item(cx, ty, sym::option_type)`
-
-error: usage of `utils::match_type()` on a type diagnostic item
-  --> $DIR/match_type_on_diag_item.rs:43:17
+error: usage of `clippy_utils::ty::match_type()` on a type diagnostic item
+  --> $DIR/match_type_on_diag_item.rs:32:17
    |
 LL |         let _ = match_type(cx, ty, &["core", "result", "Result"]);
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `utils::is_type_diagnostic_item(cx, ty, sym::result_type)`
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `clippy_utils::ty::is_type_diagnostic_item(cx, ty, sym::result_type)`
 
-error: usage of `utils::match_type()` on a type diagnostic item
-  --> $DIR/match_type_on_diag_item.rs:46:17
+error: usage of `clippy_utils::ty::match_type()` on a type diagnostic item
+  --> $DIR/match_type_on_diag_item.rs:35:17
    |
-LL |         let _ = utils::match_type(cx, ty, rc_path);
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `utils::is_type_diagnostic_item(cx, ty, sym::Rc)`
+LL |         let _ = clippy_utils::ty::match_type(cx, ty, rc_path);
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `clippy_utils::ty::is_type_diagnostic_item(cx, ty, sym::Rc)`
 
-error: aborting due to 4 previous errors
+error: aborting due to 3 previous errors
 
diff --git a/tests/ui/repl_uninit.rs b/tests/ui/repl_uninit.rs
index ad5b8e4857d..6c7e2b854dc 100644
--- a/tests/ui/repl_uninit.rs
+++ b/tests/ui/repl_uninit.rs
@@ -1,5 +1,5 @@
-#![allow(deprecated, invalid_value)]
-#![warn(clippy::all)]
+#![allow(deprecated, invalid_value, clippy::uninit_assumed_init)]
+#![warn(clippy::mem_replace_with_uninit)]
 
 use std::mem;
 
diff --git a/tests/ui/uninit.rs b/tests/ui/uninit.rs
index f42b884e0f0..1ed3883c1f0 100644
--- a/tests/ui/uninit.rs
+++ b/tests/ui/uninit.rs
@@ -1,6 +1,6 @@
 #![feature(stmt_expr_attributes)]
 
-use std::mem::MaybeUninit;
+use std::mem::{self, MaybeUninit};
 
 fn main() {
     let _: usize = unsafe { MaybeUninit::uninit().assume_init() };
@@ -19,4 +19,7 @@ fn main() {
 
     // This is OK, because all constitutent types are uninit-compatible.
     let _: (MaybeUninit<usize>, [MaybeUninit<bool>; 2]) = unsafe { MaybeUninit::uninit().assume_init() };
+
+    // Was a false negative.
+    let _: usize = unsafe { mem::MaybeUninit::uninit().assume_init() };
 }
diff --git a/tests/ui/uninit.stderr b/tests/ui/uninit.stderr
index a37233ecdda..85b64a8419a 100644
--- a/tests/ui/uninit.stderr
+++ b/tests/ui/uninit.stderr
@@ -12,5 +12,11 @@ error: this call for this type may be undefined behavior
 LL |     let _: [u8; 0] = unsafe { MaybeUninit::uninit().assume_init() };
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 2 previous errors
+error: this call for this type may be undefined behavior
+  --> $DIR/uninit.rs:24:29
+   |
+LL |     let _: usize = unsafe { mem::MaybeUninit::uninit().assume_init() };
+   |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 3 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From b6581636bd9cfb16337a9ffcecd1b38e68a6abce Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sun, 3 Jan 2021 14:01:01 -0500
Subject: Improve `redundant_pattern_matching` Add a note when the drop order
 change may result in different behaviour.

---
 clippy_lints/src/matches.rs                        | 229 ++++++++++++++++++---
 .../ui/redundant_pattern_matching_drop_order.fixed |  58 ++++++
 tests/ui/redundant_pattern_matching_drop_order.rs  |  58 ++++++
 .../redundant_pattern_matching_drop_order.stderr   | 171 +++++++++++++++
 tests/ui/redundant_pattern_matching_option.fixed   |   7 +-
 tests/ui/redundant_pattern_matching_option.rs      |   7 +-
 tests/ui/redundant_pattern_matching_option.stderr  |  38 ++--
 tests/ui/redundant_pattern_matching_poll.fixed     |   7 +-
 tests/ui/redundant_pattern_matching_poll.rs        |   7 +-
 tests/ui/redundant_pattern_matching_poll.stderr    |  36 ++--
 tests/ui/redundant_pattern_matching_result.fixed   |   3 +-
 tests/ui/redundant_pattern_matching_result.rs      |   3 +-
 tests/ui/redundant_pattern_matching_result.stderr  |  44 ++--
 13 files changed, 579 insertions(+), 89 deletions(-)
 create mode 100644 tests/ui/redundant_pattern_matching_drop_order.fixed
 create mode 100644 tests/ui/redundant_pattern_matching_drop_order.rs
 create mode 100644 tests/ui/redundant_pattern_matching_drop_order.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index 8f1112cff7b..dc5232085ed 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -423,7 +423,12 @@ declare_clippy_lint! {
     /// **Why is this bad?** It's more concise and clear to just use the proper
     /// utility function
     ///
-    /// **Known problems:** None.
+    /// **Known problems:** This will change the drop order for the matched type. Both `if let` and
+    /// `while let` will drop the value at the end of the block, both `if` and `while` will drop the
+    /// value before entering the block. For most types this change will not matter, but for a few
+    /// types this will not be an acceptable change (e.g. locks). See the
+    /// [reference](https://doc.rust-lang.org/reference/destructors.html#drop-scopes) for more about
+    /// drop order.
     ///
     /// **Example:**
     ///
@@ -1700,55 +1705,204 @@ where
 mod redundant_pattern_match {
     use super::REDUNDANT_PATTERN_MATCHING;
     use clippy_utils::diagnostics::span_lint_and_then;
-    use clippy_utils::source::snippet;
+    use clippy_utils::source::{snippet, snippet_with_applicability};
+    use clippy_utils::ty::{implements_trait, is_type_diagnostic_item, is_type_lang_item, match_type};
     use clippy_utils::{is_lang_ctor, is_qpath_def_path, is_trait_method, paths};
     use if_chain::if_chain;
     use rustc_ast::ast::LitKind;
     use rustc_errors::Applicability;
     use rustc_hir::LangItem::{OptionNone, OptionSome, PollPending, PollReady, ResultErr, ResultOk};
-    use rustc_hir::{Arm, Expr, ExprKind, MatchSource, PatKind, QPath};
+    use rustc_hir::{
+        intravisit::{walk_expr, ErasedMap, NestedVisitorMap, Visitor},
+        Arm, Block, Expr, ExprKind, LangItem, MatchSource, Node, PatKind, QPath,
+    };
     use rustc_lint::LateContext;
+    use rustc_middle::ty::{self, subst::GenericArgKind, Ty};
     use rustc_span::sym;
 
     pub fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if let ExprKind::Match(op, arms, ref match_source) = &expr.kind {
             match match_source {
                 MatchSource::Normal => find_sugg_for_match(cx, expr, op, arms),
-                MatchSource::IfLetDesugar { .. } => find_sugg_for_if_let(cx, expr, op, arms, "if"),
-                MatchSource::WhileLetDesugar => find_sugg_for_if_let(cx, expr, op, arms, "while"),
+                MatchSource::IfLetDesugar { contains_else_clause } => {
+                    find_sugg_for_if_let(cx, expr, op, &arms[0], "if", *contains_else_clause)
+                },
+                MatchSource::WhileLetDesugar => find_sugg_for_if_let(cx, expr, op, &arms[0], "while", false),
                 _ => {},
             }
         }
     }
 
+    // Check if the drop order for a type matters
+    fn type_needs_ordered_drop(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
+        if !ty.needs_drop(cx.tcx, cx.param_env) {
+            false
+        } else if cx
+            .tcx
+            .lang_items()
+            .drop_trait()
+            .map_or(false, |id| !implements_trait(cx, ty, id, &[]))
+        {
+            // This type doesn't implement drop, so no side effects here.
+            // Check if any component type has any.
+            match ty.kind() {
+                ty::Tuple(_) => ty.tuple_fields().any(|ty| type_needs_ordered_drop(cx, ty)),
+                ty::Array(ty, _) => type_needs_ordered_drop(cx, ty),
+                ty::Adt(adt, subs) => adt
+                    .all_fields()
+                    .map(|f| f.ty(cx.tcx, subs))
+                    .any(|ty| type_needs_ordered_drop(cx, ty)),
+                _ => true,
+            }
+        }
+        // Check for std types which implement drop, but only for memory allocation.
+        else if is_type_diagnostic_item(cx, ty, sym::vec_type)
+            || is_type_lang_item(cx, ty, LangItem::OwnedBox)
+            || is_type_diagnostic_item(cx, ty, sym::Rc)
+            || is_type_diagnostic_item(cx, ty, sym::Arc)
+            || is_type_diagnostic_item(cx, ty, sym::cstring_type)
+            || match_type(cx, ty, &paths::BTREEMAP)
+            || match_type(cx, ty, &paths::LINKED_LIST)
+            || match_type(cx, ty, &paths::WEAK_RC)
+            || match_type(cx, ty, &paths::WEAK_ARC)
+        {
+            // Check all of the generic arguments.
+            if let ty::Adt(_, subs) = ty.kind() {
+                subs.types().any(|ty| type_needs_ordered_drop(cx, ty))
+            } else {
+                true
+            }
+        } else {
+            true
+        }
+    }
+
+    // Extract the generic arguments out of a type
+    fn try_get_generic_ty(ty: Ty<'_>, index: usize) -> Option<Ty<'_>> {
+        if_chain! {
+            if let ty::Adt(_, subs) = ty.kind();
+            if let Some(sub) = subs.get(index);
+            if let GenericArgKind::Type(sub_ty) = sub.unpack();
+            then {
+                Some(sub_ty)
+            } else {
+                None
+            }
+        }
+    }
+
+    // Checks if there are any temporaries created in the given expression for which drop order
+    // matters.
+    fn temporaries_need_ordered_drop(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
+        struct V<'a, 'tcx> {
+            cx: &'a LateContext<'tcx>,
+            res: bool,
+        }
+        impl<'a, 'tcx> Visitor<'tcx> for V<'a, 'tcx> {
+            type Map = ErasedMap<'tcx>;
+            fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+                NestedVisitorMap::None
+            }
+
+            fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) {
+                match expr.kind {
+                    // Taking the reference of a value leaves a temporary
+                    // e.g. In `&String::new()` the string is a temporary value.
+                    // Remaining fields are temporary values
+                    // e.g. In `(String::new(), 0).1` the string is a temporary value.
+                    ExprKind::AddrOf(_, _, expr) | ExprKind::Field(expr, _) => {
+                        if !matches!(expr.kind, ExprKind::Path(_)) {
+                            if type_needs_ordered_drop(self.cx, self.cx.typeck_results().expr_ty(expr)) {
+                                self.res = true;
+                            } else {
+                                self.visit_expr(expr);
+                            }
+                        }
+                    },
+                    // the base type is alway taken by reference.
+                    // e.g. In `(vec![0])[0]` the vector is a temporary value.
+                    ExprKind::Index(base, index) => {
+                        if !matches!(base.kind, ExprKind::Path(_)) {
+                            if type_needs_ordered_drop(self.cx, self.cx.typeck_results().expr_ty(base)) {
+                                self.res = true;
+                            } else {
+                                self.visit_expr(base);
+                            }
+                        }
+                        self.visit_expr(index);
+                    },
+                    // Method calls can take self by reference.
+                    // e.g. In `String::new().len()` the string is a temporary value.
+                    ExprKind::MethodCall(_, _, [self_arg, args @ ..], _) => {
+                        if !matches!(self_arg.kind, ExprKind::Path(_)) {
+                            let self_by_ref = self
+                                .cx
+                                .typeck_results()
+                                .type_dependent_def_id(expr.hir_id)
+                                .map_or(false, |id| self.cx.tcx.fn_sig(id).skip_binder().inputs()[0].is_ref());
+                            if self_by_ref
+                                && type_needs_ordered_drop(self.cx, self.cx.typeck_results().expr_ty(self_arg))
+                            {
+                                self.res = true;
+                            } else {
+                                self.visit_expr(self_arg)
+                            }
+                        }
+                        args.iter().for_each(|arg| self.visit_expr(arg));
+                    },
+                    // Either explicitly drops values, or changes control flow.
+                    ExprKind::DropTemps(_)
+                    | ExprKind::Ret(_)
+                    | ExprKind::Break(..)
+                    | ExprKind::Yield(..)
+                    | ExprKind::Block(Block { expr: None, .. }, _)
+                    | ExprKind::Loop(..) => (),
+
+                    // Only consider the final expression.
+                    ExprKind::Block(Block { expr: Some(expr), .. }, _) => self.visit_expr(expr),
+
+                    _ => walk_expr(self, expr),
+                }
+            }
+        }
+
+        let mut v = V { cx, res: false };
+        v.visit_expr(expr);
+        v.res
+    }
+
     fn find_sugg_for_if_let<'tcx>(
         cx: &LateContext<'tcx>,
         expr: &'tcx Expr<'_>,
-        op: &Expr<'_>,
-        arms: &[Arm<'_>],
+        op: &'tcx Expr<'tcx>,
+        arm: &Arm<'_>,
         keyword: &'static str,
+        has_else: bool,
     ) {
         // also look inside refs
-        let mut kind = &arms[0].pat.kind;
+        let mut kind = &arm.pat.kind;
         // if we have &None for example, peel it so we can detect "if let None = x"
         if let PatKind::Ref(inner, _mutability) = kind {
             kind = &inner.kind;
         }
-        let good_method = match kind {
+        let op_ty = cx.typeck_results().expr_ty(op);
+        // Determine which function should be used, and the type contained by the corresponding
+        // variant.
+        let (good_method, inner_ty) = match kind {
             PatKind::TupleStruct(ref path, [sub_pat], _) => {
                 if let PatKind::Wild = sub_pat.kind {
                     if is_lang_ctor(cx, path, ResultOk) {
-                        "is_ok()"
+                        ("is_ok()", try_get_generic_ty(op_ty, 0).unwrap_or(op_ty))
                     } else if is_lang_ctor(cx, path, ResultErr) {
-                        "is_err()"
+                        ("is_err()", try_get_generic_ty(op_ty, 1).unwrap_or(op_ty))
                     } else if is_lang_ctor(cx, path, OptionSome) {
-                        "is_some()"
+                        ("is_some()", op_ty)
                     } else if is_lang_ctor(cx, path, PollReady) {
-                        "is_ready()"
+                        ("is_ready()", op_ty)
                     } else if is_qpath_def_path(cx, path, sub_pat.hir_id, &paths::IPADDR_V4) {
-                        "is_ipv4()"
+                        ("is_ipv4()", op_ty)
                     } else if is_qpath_def_path(cx, path, sub_pat.hir_id, &paths::IPADDR_V6) {
-                        "is_ipv6()"
+                        ("is_ipv6()", op_ty)
                     } else {
                         return;
                     }
@@ -1757,17 +1911,36 @@ mod redundant_pattern_match {
                 }
             },
             PatKind::Path(ref path) => {
-                if is_lang_ctor(cx, path, OptionNone) {
+                let method = if is_lang_ctor(cx, path, OptionNone) {
                     "is_none()"
                 } else if is_lang_ctor(cx, path, PollPending) {
                     "is_pending()"
                 } else {
                     return;
-                }
+                };
+                // `None` and `Pending` don't have an inner type.
+                (method, cx.tcx.types.unit)
             },
             _ => return,
         };
 
+        // If this is the last expression in a block or there is an else clause then the whole
+        // type needs to be considered, not just the inner type of the branch being matched on.
+        // Note the last expression in a block is dropped after all local bindings.
+        let check_ty = if has_else
+            || (keyword == "if" && matches!(cx.tcx.hir().parent_iter(expr.hir_id).next(), Some((_, Node::Block(..)))))
+        {
+            op_ty
+        } else {
+            inner_ty
+        };
+
+        // All temporaries created in the scrutinee expression are dropped at the same time as the
+        // scrutinee would be, so they have to be considered as well.
+        // e.g. in `if let Some(x) = foo.lock().unwrap().baz.as_ref() { .. }` the lock will be held
+        // for the duration if body.
+        let needs_drop = type_needs_ordered_drop(cx, check_ty) || temporaries_need_ordered_drop(cx, op);
+
         // check that `while_let_on_iterator` lint does not trigger
         if_chain! {
             if keyword == "while";
@@ -1786,7 +1959,7 @@ mod redundant_pattern_match {
         span_lint_and_then(
             cx,
             REDUNDANT_PATTERN_MATCHING,
-            arms[0].pat.span,
+            arm.pat.span,
             &format!("redundant pattern matching, consider using `{}`", good_method),
             |diag| {
                 // while let ... = ... { ... }
@@ -1800,12 +1973,20 @@ mod redundant_pattern_match {
                 // while let ... = ... { ... }
                 // ^^^^^^^^^^^^^^^^^^^
                 let span = expr_span.until(op_span.shrink_to_hi());
-                diag.span_suggestion(
-                    span,
-                    "try this",
-                    format!("{} {}.{}", keyword, snippet(cx, op_span, "_"), good_method),
-                    Applicability::MachineApplicable, // snippet
-                );
+
+                let mut app = if needs_drop {
+                    Applicability::MaybeIncorrect
+                } else {
+                    Applicability::MachineApplicable
+                };
+                let sugg = snippet_with_applicability(cx, op_span, "_", &mut app);
+
+                diag.span_suggestion(span, "try this", format!("{} {}.{}", keyword, sugg, good_method), app);
+
+                if needs_drop {
+                    diag.note("this will change drop order of the result, as well as all temporaries");
+                    diag.note("add `#[allow(clippy::redundant_pattern_matching)]` if this is important");
+                }
             },
         );
     }
diff --git a/tests/ui/redundant_pattern_matching_drop_order.fixed b/tests/ui/redundant_pattern_matching_drop_order.fixed
new file mode 100644
index 00000000000..794ed542435
--- /dev/null
+++ b/tests/ui/redundant_pattern_matching_drop_order.fixed
@@ -0,0 +1,58 @@
+// run-rustfix
+
+// Issue #5746
+#![warn(clippy::redundant_pattern_matching)]
+#![allow(clippy::if_same_then_else)]
+use std::task::Poll::{Pending, Ready};
+
+fn main() {
+    let m = std::sync::Mutex::new((0, 0));
+
+    // Result
+    if m.lock().is_ok() {}
+    if Err::<(), _>(m.lock().unwrap().0).is_err() {}
+
+    {
+        if Ok::<_, std::sync::MutexGuard<()>>(()).is_ok() {}
+    }
+    if Ok::<_, std::sync::MutexGuard<()>>(()).is_ok() {
+    } else {
+    }
+    if Ok::<_, std::sync::MutexGuard<()>>(()).is_ok() {}
+    if Err::<std::sync::MutexGuard<()>, _>(()).is_err() {}
+
+    if Ok::<_, ()>(String::new()).is_ok() {}
+    if Err::<(), _>((String::new(), ())).is_err() {}
+
+    // Option
+    if Some(m.lock()).is_some() {}
+    if Some(m.lock().unwrap().0).is_some() {}
+
+    {
+        if None::<std::sync::MutexGuard<()>>.is_none() {}
+    }
+    if None::<std::sync::MutexGuard<()>>.is_none() {
+    } else {
+    }
+
+    if None::<std::sync::MutexGuard<()>>.is_none() {}
+
+    if Some(String::new()).is_some() {}
+    if Some((String::new(), ())).is_some() {}
+
+    // Poll
+    if Ready(m.lock()).is_ready() {}
+    if Ready(m.lock().unwrap().0).is_ready() {}
+
+    {
+        if Pending::<std::sync::MutexGuard<()>>.is_pending() {}
+    }
+    if Pending::<std::sync::MutexGuard<()>>.is_pending() {
+    } else {
+    }
+
+    if Pending::<std::sync::MutexGuard<()>>.is_pending() {}
+
+    if Ready(String::new()).is_ready() {}
+    if Ready((String::new(), ())).is_ready() {}
+}
diff --git a/tests/ui/redundant_pattern_matching_drop_order.rs b/tests/ui/redundant_pattern_matching_drop_order.rs
new file mode 100644
index 00000000000..b9c82d86f61
--- /dev/null
+++ b/tests/ui/redundant_pattern_matching_drop_order.rs
@@ -0,0 +1,58 @@
+// run-rustfix
+
+// Issue #5746
+#![warn(clippy::redundant_pattern_matching)]
+#![allow(clippy::if_same_then_else)]
+use std::task::Poll::{Pending, Ready};
+
+fn main() {
+    let m = std::sync::Mutex::new((0, 0));
+
+    // Result
+    if let Ok(_) = m.lock() {}
+    if let Err(_) = Err::<(), _>(m.lock().unwrap().0) {}
+
+    {
+        if let Ok(_) = Ok::<_, std::sync::MutexGuard<()>>(()) {}
+    }
+    if let Ok(_) = Ok::<_, std::sync::MutexGuard<()>>(()) {
+    } else {
+    }
+    if let Ok(_) = Ok::<_, std::sync::MutexGuard<()>>(()) {}
+    if let Err(_) = Err::<std::sync::MutexGuard<()>, _>(()) {}
+
+    if let Ok(_) = Ok::<_, ()>(String::new()) {}
+    if let Err(_) = Err::<(), _>((String::new(), ())) {}
+
+    // Option
+    if let Some(_) = Some(m.lock()) {}
+    if let Some(_) = Some(m.lock().unwrap().0) {}
+
+    {
+        if let None = None::<std::sync::MutexGuard<()>> {}
+    }
+    if let None = None::<std::sync::MutexGuard<()>> {
+    } else {
+    }
+
+    if let None = None::<std::sync::MutexGuard<()>> {}
+
+    if let Some(_) = Some(String::new()) {}
+    if let Some(_) = Some((String::new(), ())) {}
+
+    // Poll
+    if let Ready(_) = Ready(m.lock()) {}
+    if let Ready(_) = Ready(m.lock().unwrap().0) {}
+
+    {
+        if let Pending = Pending::<std::sync::MutexGuard<()>> {}
+    }
+    if let Pending = Pending::<std::sync::MutexGuard<()>> {
+    } else {
+    }
+
+    if let Pending = Pending::<std::sync::MutexGuard<()>> {}
+
+    if let Ready(_) = Ready(String::new()) {}
+    if let Ready(_) = Ready((String::new(), ())) {}
+}
diff --git a/tests/ui/redundant_pattern_matching_drop_order.stderr b/tests/ui/redundant_pattern_matching_drop_order.stderr
new file mode 100644
index 00000000000..eb7aa70ee27
--- /dev/null
+++ b/tests/ui/redundant_pattern_matching_drop_order.stderr
@@ -0,0 +1,171 @@
+error: redundant pattern matching, consider using `is_ok()`
+  --> $DIR/redundant_pattern_matching_drop_order.rs:12:12
+   |
+LL |     if let Ok(_) = m.lock() {}
+   |     -------^^^^^----------- help: try this: `if m.lock().is_ok()`
+   |
+   = note: `-D clippy::redundant-pattern-matching` implied by `-D warnings`
+   = note: this will change drop order of the result, as well as all temporaries
+   = note: add `#[allow(clippy::redundant_pattern_matching)]` if this is important
+
+error: redundant pattern matching, consider using `is_err()`
+  --> $DIR/redundant_pattern_matching_drop_order.rs:13:12
+   |
+LL |     if let Err(_) = Err::<(), _>(m.lock().unwrap().0) {}
+   |     -------^^^^^^------------------------------------ help: try this: `if Err::<(), _>(m.lock().unwrap().0).is_err()`
+   |
+   = note: this will change drop order of the result, as well as all temporaries
+   = note: add `#[allow(clippy::redundant_pattern_matching)]` if this is important
+
+error: redundant pattern matching, consider using `is_ok()`
+  --> $DIR/redundant_pattern_matching_drop_order.rs:16:16
+   |
+LL |         if let Ok(_) = Ok::<_, std::sync::MutexGuard<()>>(()) {}
+   |         -------^^^^^----------------------------------------- help: try this: `if Ok::<_, std::sync::MutexGuard<()>>(()).is_ok()`
+   |
+   = note: this will change drop order of the result, as well as all temporaries
+   = note: add `#[allow(clippy::redundant_pattern_matching)]` if this is important
+
+error: redundant pattern matching, consider using `is_ok()`
+  --> $DIR/redundant_pattern_matching_drop_order.rs:18:12
+   |
+LL |     if let Ok(_) = Ok::<_, std::sync::MutexGuard<()>>(()) {
+   |     -------^^^^^----------------------------------------- help: try this: `if Ok::<_, std::sync::MutexGuard<()>>(()).is_ok()`
+   |
+   = note: this will change drop order of the result, as well as all temporaries
+   = note: add `#[allow(clippy::redundant_pattern_matching)]` if this is important
+
+error: redundant pattern matching, consider using `is_ok()`
+  --> $DIR/redundant_pattern_matching_drop_order.rs:21:12
+   |
+LL |     if let Ok(_) = Ok::<_, std::sync::MutexGuard<()>>(()) {}
+   |     -------^^^^^----------------------------------------- help: try this: `if Ok::<_, std::sync::MutexGuard<()>>(()).is_ok()`
+
+error: redundant pattern matching, consider using `is_err()`
+  --> $DIR/redundant_pattern_matching_drop_order.rs:22:12
+   |
+LL |     if let Err(_) = Err::<std::sync::MutexGuard<()>, _>(()) {}
+   |     -------^^^^^^------------------------------------------ help: try this: `if Err::<std::sync::MutexGuard<()>, _>(()).is_err()`
+
+error: redundant pattern matching, consider using `is_ok()`
+  --> $DIR/redundant_pattern_matching_drop_order.rs:24:12
+   |
+LL |     if let Ok(_) = Ok::<_, ()>(String::new()) {}
+   |     -------^^^^^----------------------------- help: try this: `if Ok::<_, ()>(String::new()).is_ok()`
+
+error: redundant pattern matching, consider using `is_err()`
+  --> $DIR/redundant_pattern_matching_drop_order.rs:25:12
+   |
+LL |     if let Err(_) = Err::<(), _>((String::new(), ())) {}
+   |     -------^^^^^^------------------------------------ help: try this: `if Err::<(), _>((String::new(), ())).is_err()`
+
+error: redundant pattern matching, consider using `is_some()`
+  --> $DIR/redundant_pattern_matching_drop_order.rs:28:12
+   |
+LL |     if let Some(_) = Some(m.lock()) {}
+   |     -------^^^^^^^----------------- help: try this: `if Some(m.lock()).is_some()`
+   |
+   = note: this will change drop order of the result, as well as all temporaries
+   = note: add `#[allow(clippy::redundant_pattern_matching)]` if this is important
+
+error: redundant pattern matching, consider using `is_some()`
+  --> $DIR/redundant_pattern_matching_drop_order.rs:29:12
+   |
+LL |     if let Some(_) = Some(m.lock().unwrap().0) {}
+   |     -------^^^^^^^---------------------------- help: try this: `if Some(m.lock().unwrap().0).is_some()`
+   |
+   = note: this will change drop order of the result, as well as all temporaries
+   = note: add `#[allow(clippy::redundant_pattern_matching)]` if this is important
+
+error: redundant pattern matching, consider using `is_none()`
+  --> $DIR/redundant_pattern_matching_drop_order.rs:32:16
+   |
+LL |         if let None = None::<std::sync::MutexGuard<()>> {}
+   |         -------^^^^------------------------------------ help: try this: `if None::<std::sync::MutexGuard<()>>.is_none()`
+   |
+   = note: this will change drop order of the result, as well as all temporaries
+   = note: add `#[allow(clippy::redundant_pattern_matching)]` if this is important
+
+error: redundant pattern matching, consider using `is_none()`
+  --> $DIR/redundant_pattern_matching_drop_order.rs:34:12
+   |
+LL |     if let None = None::<std::sync::MutexGuard<()>> {
+   |     -------^^^^------------------------------------ help: try this: `if None::<std::sync::MutexGuard<()>>.is_none()`
+   |
+   = note: this will change drop order of the result, as well as all temporaries
+   = note: add `#[allow(clippy::redundant_pattern_matching)]` if this is important
+
+error: redundant pattern matching, consider using `is_none()`
+  --> $DIR/redundant_pattern_matching_drop_order.rs:38:12
+   |
+LL |     if let None = None::<std::sync::MutexGuard<()>> {}
+   |     -------^^^^------------------------------------ help: try this: `if None::<std::sync::MutexGuard<()>>.is_none()`
+
+error: redundant pattern matching, consider using `is_some()`
+  --> $DIR/redundant_pattern_matching_drop_order.rs:40:12
+   |
+LL |     if let Some(_) = Some(String::new()) {}
+   |     -------^^^^^^^---------------------- help: try this: `if Some(String::new()).is_some()`
+
+error: redundant pattern matching, consider using `is_some()`
+  --> $DIR/redundant_pattern_matching_drop_order.rs:41:12
+   |
+LL |     if let Some(_) = Some((String::new(), ())) {}
+   |     -------^^^^^^^---------------------------- help: try this: `if Some((String::new(), ())).is_some()`
+
+error: redundant pattern matching, consider using `is_ready()`
+  --> $DIR/redundant_pattern_matching_drop_order.rs:44:12
+   |
+LL |     if let Ready(_) = Ready(m.lock()) {}
+   |     -------^^^^^^^^------------------ help: try this: `if Ready(m.lock()).is_ready()`
+   |
+   = note: this will change drop order of the result, as well as all temporaries
+   = note: add `#[allow(clippy::redundant_pattern_matching)]` if this is important
+
+error: redundant pattern matching, consider using `is_ready()`
+  --> $DIR/redundant_pattern_matching_drop_order.rs:45:12
+   |
+LL |     if let Ready(_) = Ready(m.lock().unwrap().0) {}
+   |     -------^^^^^^^^----------------------------- help: try this: `if Ready(m.lock().unwrap().0).is_ready()`
+   |
+   = note: this will change drop order of the result, as well as all temporaries
+   = note: add `#[allow(clippy::redundant_pattern_matching)]` if this is important
+
+error: redundant pattern matching, consider using `is_pending()`
+  --> $DIR/redundant_pattern_matching_drop_order.rs:48:16
+   |
+LL |         if let Pending = Pending::<std::sync::MutexGuard<()>> {}
+   |         -------^^^^^^^--------------------------------------- help: try this: `if Pending::<std::sync::MutexGuard<()>>.is_pending()`
+   |
+   = note: this will change drop order of the result, as well as all temporaries
+   = note: add `#[allow(clippy::redundant_pattern_matching)]` if this is important
+
+error: redundant pattern matching, consider using `is_pending()`
+  --> $DIR/redundant_pattern_matching_drop_order.rs:50:12
+   |
+LL |     if let Pending = Pending::<std::sync::MutexGuard<()>> {
+   |     -------^^^^^^^--------------------------------------- help: try this: `if Pending::<std::sync::MutexGuard<()>>.is_pending()`
+   |
+   = note: this will change drop order of the result, as well as all temporaries
+   = note: add `#[allow(clippy::redundant_pattern_matching)]` if this is important
+
+error: redundant pattern matching, consider using `is_pending()`
+  --> $DIR/redundant_pattern_matching_drop_order.rs:54:12
+   |
+LL |     if let Pending = Pending::<std::sync::MutexGuard<()>> {}
+   |     -------^^^^^^^--------------------------------------- help: try this: `if Pending::<std::sync::MutexGuard<()>>.is_pending()`
+
+error: redundant pattern matching, consider using `is_ready()`
+  --> $DIR/redundant_pattern_matching_drop_order.rs:56:12
+   |
+LL |     if let Ready(_) = Ready(String::new()) {}
+   |     -------^^^^^^^^----------------------- help: try this: `if Ready(String::new()).is_ready()`
+
+error: redundant pattern matching, consider using `is_ready()`
+  --> $DIR/redundant_pattern_matching_drop_order.rs:57:12
+   |
+LL |     if let Ready(_) = Ready((String::new(), ())) {}
+   |     -------^^^^^^^^----------------------------- help: try this: `if Ready((String::new(), ())).is_ready()`
+
+error: aborting due to 22 previous errors
+
diff --git a/tests/ui/redundant_pattern_matching_option.fixed b/tests/ui/redundant_pattern_matching_option.fixed
index 66f580a0a68..99714477266 100644
--- a/tests/ui/redundant_pattern_matching_option.fixed
+++ b/tests/ui/redundant_pattern_matching_option.fixed
@@ -2,7 +2,12 @@
 
 #![warn(clippy::all)]
 #![warn(clippy::redundant_pattern_matching)]
-#![allow(unused_must_use, clippy::needless_bool, clippy::match_like_matches_macro)]
+#![allow(
+    unused_must_use,
+    clippy::needless_bool,
+    clippy::match_like_matches_macro,
+    clippy::if_same_then_else
+)]
 
 fn main() {
     if None::<()>.is_none() {}
diff --git a/tests/ui/redundant_pattern_matching_option.rs b/tests/ui/redundant_pattern_matching_option.rs
index f18b27b8b95..8309847e181 100644
--- a/tests/ui/redundant_pattern_matching_option.rs
+++ b/tests/ui/redundant_pattern_matching_option.rs
@@ -2,7 +2,12 @@
 
 #![warn(clippy::all)]
 #![warn(clippy::redundant_pattern_matching)]
-#![allow(unused_must_use, clippy::needless_bool, clippy::match_like_matches_macro)]
+#![allow(
+    unused_must_use,
+    clippy::needless_bool,
+    clippy::match_like_matches_macro,
+    clippy::if_same_then_else
+)]
 
 fn main() {
     if let None = None::<()> {}
diff --git a/tests/ui/redundant_pattern_matching_option.stderr b/tests/ui/redundant_pattern_matching_option.stderr
index 58482a0ab70..613a30d4a48 100644
--- a/tests/ui/redundant_pattern_matching_option.stderr
+++ b/tests/ui/redundant_pattern_matching_option.stderr
@@ -1,5 +1,5 @@
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:8:12
+  --> $DIR/redundant_pattern_matching_option.rs:13:12
    |
 LL |     if let None = None::<()> {}
    |     -------^^^^------------- help: try this: `if None::<()>.is_none()`
@@ -7,43 +7,43 @@ LL |     if let None = 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:10:12
+  --> $DIR/redundant_pattern_matching_option.rs:15: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:12:12
+  --> $DIR/redundant_pattern_matching_option.rs:17: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:15
+  --> $DIR/redundant_pattern_matching_option.rs:23: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:20:15
+  --> $DIR/redundant_pattern_matching_option.rs:25: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:22:15
+  --> $DIR/redundant_pattern_matching_option.rs:27: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:25:15
+  --> $DIR/redundant_pattern_matching_option.rs:30: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:33:5
+  --> $DIR/redundant_pattern_matching_option.rs:38:5
    |
 LL | /     match Some(42) {
 LL | |         Some(_) => true,
@@ -52,7 +52,7 @@ LL | |     };
    | |_____^ help: try this: `Some(42).is_some()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:38:5
+  --> $DIR/redundant_pattern_matching_option.rs:43:5
    |
 LL | /     match None::<()> {
 LL | |         Some(_) => false,
@@ -61,7 +61,7 @@ LL | |     };
    | |_____^ help: try this: `None::<()>.is_none()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:43:13
+  --> $DIR/redundant_pattern_matching_option.rs:48:13
    |
 LL |       let _ = match None::<()> {
    |  _____________^
@@ -71,49 +71,49 @@ LL | |     };
    | |_____^ help: try this: `None::<()>.is_none()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/redundant_pattern_matching_option.rs:49:20
+  --> $DIR/redundant_pattern_matching_option.rs:54:20
    |
 LL |     let _ = 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:53:20
+  --> $DIR/redundant_pattern_matching_option.rs:58: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:55:19
+  --> $DIR/redundant_pattern_matching_option.rs:60: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:74:12
+  --> $DIR/redundant_pattern_matching_option.rs:79: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:76:12
+  --> $DIR/redundant_pattern_matching_option.rs:81: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:78:15
+  --> $DIR/redundant_pattern_matching_option.rs:83: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:80:15
+  --> $DIR/redundant_pattern_matching_option.rs:85: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:82:5
+  --> $DIR/redundant_pattern_matching_option.rs:87:5
    |
 LL | /     match Some(42) {
 LL | |         Some(_) => true,
@@ -122,7 +122,7 @@ LL | |     };
    | |_____^ help: try this: `Some(42).is_some()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:87:5
+  --> $DIR/redundant_pattern_matching_option.rs:92:5
    |
 LL | /     match None::<()> {
 LL | |         Some(_) => false,
diff --git a/tests/ui/redundant_pattern_matching_poll.fixed b/tests/ui/redundant_pattern_matching_poll.fixed
index 465aa80dac2..c2977453804 100644
--- a/tests/ui/redundant_pattern_matching_poll.fixed
+++ b/tests/ui/redundant_pattern_matching_poll.fixed
@@ -2,7 +2,12 @@
 
 #![warn(clippy::all)]
 #![warn(clippy::redundant_pattern_matching)]
-#![allow(unused_must_use, clippy::needless_bool, clippy::match_like_matches_macro)]
+#![allow(
+    unused_must_use,
+    clippy::needless_bool,
+    clippy::match_like_matches_macro,
+    clippy::if_same_then_else
+)]
 
 use std::task::Poll::{self, Pending, Ready};
 
diff --git a/tests/ui/redundant_pattern_matching_poll.rs b/tests/ui/redundant_pattern_matching_poll.rs
index 7891ff353b1..665c8c41750 100644
--- a/tests/ui/redundant_pattern_matching_poll.rs
+++ b/tests/ui/redundant_pattern_matching_poll.rs
@@ -2,7 +2,12 @@
 
 #![warn(clippy::all)]
 #![warn(clippy::redundant_pattern_matching)]
-#![allow(unused_must_use, clippy::needless_bool, clippy::match_like_matches_macro)]
+#![allow(
+    unused_must_use,
+    clippy::needless_bool,
+    clippy::match_like_matches_macro,
+    clippy::if_same_then_else
+)]
 
 use std::task::Poll::{self, Pending, Ready};
 
diff --git a/tests/ui/redundant_pattern_matching_poll.stderr b/tests/ui/redundant_pattern_matching_poll.stderr
index 5ffc6c47c90..5ecf024a733 100644
--- a/tests/ui/redundant_pattern_matching_poll.stderr
+++ b/tests/ui/redundant_pattern_matching_poll.stderr
@@ -1,5 +1,5 @@
 error: redundant pattern matching, consider using `is_pending()`
-  --> $DIR/redundant_pattern_matching_poll.rs:10:12
+  --> $DIR/redundant_pattern_matching_poll.rs:15:12
    |
 LL |     if let Pending = Pending::<()> {}
    |     -------^^^^^^^---------------- help: try this: `if Pending::<()>.is_pending()`
@@ -7,37 +7,37 @@ LL |     if let Pending = Pending::<()> {}
    = note: `-D clippy::redundant-pattern-matching` implied by `-D warnings`
 
 error: redundant pattern matching, consider using `is_ready()`
-  --> $DIR/redundant_pattern_matching_poll.rs:12:12
+  --> $DIR/redundant_pattern_matching_poll.rs:17:12
    |
 LL |     if let Ready(_) = Ready(42) {}
    |     -------^^^^^^^^------------ help: try this: `if Ready(42).is_ready()`
 
 error: redundant pattern matching, consider using `is_ready()`
-  --> $DIR/redundant_pattern_matching_poll.rs:14:12
+  --> $DIR/redundant_pattern_matching_poll.rs:19:12
    |
 LL |     if let Ready(_) = Ready(42) {
    |     -------^^^^^^^^------------ help: try this: `if Ready(42).is_ready()`
 
 error: redundant pattern matching, consider using `is_ready()`
-  --> $DIR/redundant_pattern_matching_poll.rs:20:15
+  --> $DIR/redundant_pattern_matching_poll.rs:25:15
    |
 LL |     while let Ready(_) = Ready(42) {}
    |     ----------^^^^^^^^------------ help: try this: `while Ready(42).is_ready()`
 
 error: redundant pattern matching, consider using `is_pending()`
-  --> $DIR/redundant_pattern_matching_poll.rs:22:15
+  --> $DIR/redundant_pattern_matching_poll.rs:27:15
    |
 LL |     while let Pending = Ready(42) {}
    |     ----------^^^^^^^------------ help: try this: `while Ready(42).is_pending()`
 
 error: redundant pattern matching, consider using `is_pending()`
-  --> $DIR/redundant_pattern_matching_poll.rs:24:15
+  --> $DIR/redundant_pattern_matching_poll.rs:29:15
    |
 LL |     while let Pending = Pending::<()> {}
    |     ----------^^^^^^^---------------- help: try this: `while Pending::<()>.is_pending()`
 
 error: redundant pattern matching, consider using `is_ready()`
-  --> $DIR/redundant_pattern_matching_poll.rs:30:5
+  --> $DIR/redundant_pattern_matching_poll.rs:35:5
    |
 LL | /     match Ready(42) {
 LL | |         Ready(_) => true,
@@ -46,7 +46,7 @@ LL | |     };
    | |_____^ help: try this: `Ready(42).is_ready()`
 
 error: redundant pattern matching, consider using `is_pending()`
-  --> $DIR/redundant_pattern_matching_poll.rs:35:5
+  --> $DIR/redundant_pattern_matching_poll.rs:40:5
    |
 LL | /     match Pending::<()> {
 LL | |         Ready(_) => false,
@@ -55,7 +55,7 @@ LL | |     };
    | |_____^ help: try this: `Pending::<()>.is_pending()`
 
 error: redundant pattern matching, consider using `is_pending()`
-  --> $DIR/redundant_pattern_matching_poll.rs:40:13
+  --> $DIR/redundant_pattern_matching_poll.rs:45:13
    |
 LL |       let _ = match Pending::<()> {
    |  _____________^
@@ -65,49 +65,49 @@ LL | |     };
    | |_____^ help: try this: `Pending::<()>.is_pending()`
 
 error: redundant pattern matching, consider using `is_ready()`
-  --> $DIR/redundant_pattern_matching_poll.rs:46:20
+  --> $DIR/redundant_pattern_matching_poll.rs:51:20
    |
 LL |     let _ = if let Ready(_) = poll { true } else { false };
    |             -------^^^^^^^^------- help: try this: `if poll.is_ready()`
 
 error: redundant pattern matching, consider using `is_ready()`
-  --> $DIR/redundant_pattern_matching_poll.rs:50:20
+  --> $DIR/redundant_pattern_matching_poll.rs:55:20
    |
 LL |     let _ = if let Ready(_) = gen_poll() {
    |             -------^^^^^^^^------------- help: try this: `if gen_poll().is_ready()`
 
 error: redundant pattern matching, consider using `is_pending()`
-  --> $DIR/redundant_pattern_matching_poll.rs:52:19
+  --> $DIR/redundant_pattern_matching_poll.rs:57:19
    |
 LL |     } else if let Pending = gen_poll() {
    |            -------^^^^^^^------------- help: try this: `if gen_poll().is_pending()`
 
 error: redundant pattern matching, consider using `is_ready()`
-  --> $DIR/redundant_pattern_matching_poll.rs:68:12
+  --> $DIR/redundant_pattern_matching_poll.rs:73:12
    |
 LL |     if let Ready(_) = Ready(42) {}
    |     -------^^^^^^^^------------ help: try this: `if Ready(42).is_ready()`
 
 error: redundant pattern matching, consider using `is_pending()`
-  --> $DIR/redundant_pattern_matching_poll.rs:70:12
+  --> $DIR/redundant_pattern_matching_poll.rs:75:12
    |
 LL |     if let Pending = Pending::<()> {}
    |     -------^^^^^^^---------------- help: try this: `if Pending::<()>.is_pending()`
 
 error: redundant pattern matching, consider using `is_ready()`
-  --> $DIR/redundant_pattern_matching_poll.rs:72:15
+  --> $DIR/redundant_pattern_matching_poll.rs:77:15
    |
 LL |     while let Ready(_) = Ready(42) {}
    |     ----------^^^^^^^^------------ help: try this: `while Ready(42).is_ready()`
 
 error: redundant pattern matching, consider using `is_pending()`
-  --> $DIR/redundant_pattern_matching_poll.rs:74:15
+  --> $DIR/redundant_pattern_matching_poll.rs:79:15
    |
 LL |     while let Pending = Pending::<()> {}
    |     ----------^^^^^^^---------------- help: try this: `while Pending::<()>.is_pending()`
 
 error: redundant pattern matching, consider using `is_ready()`
-  --> $DIR/redundant_pattern_matching_poll.rs:76:5
+  --> $DIR/redundant_pattern_matching_poll.rs:81:5
    |
 LL | /     match Ready(42) {
 LL | |         Ready(_) => true,
@@ -116,7 +116,7 @@ LL | |     };
    | |_____^ help: try this: `Ready(42).is_ready()`
 
 error: redundant pattern matching, consider using `is_pending()`
-  --> $DIR/redundant_pattern_matching_poll.rs:81:5
+  --> $DIR/redundant_pattern_matching_poll.rs:86:5
    |
 LL | /     match Pending::<()> {
 LL | |         Ready(_) => false,
diff --git a/tests/ui/redundant_pattern_matching_result.fixed b/tests/ui/redundant_pattern_matching_result.fixed
index e94c5704b48..d7af5d762ae 100644
--- a/tests/ui/redundant_pattern_matching_result.fixed
+++ b/tests/ui/redundant_pattern_matching_result.fixed
@@ -7,7 +7,8 @@
     clippy::needless_bool,
     clippy::match_like_matches_macro,
     clippy::unnecessary_wraps,
-    deprecated
+    deprecated,
+    clippy::if_same_then_else
 )]
 
 fn main() {
diff --git a/tests/ui/redundant_pattern_matching_result.rs b/tests/ui/redundant_pattern_matching_result.rs
index 5d175294232..e06d4485ae4 100644
--- a/tests/ui/redundant_pattern_matching_result.rs
+++ b/tests/ui/redundant_pattern_matching_result.rs
@@ -7,7 +7,8 @@
     clippy::needless_bool,
     clippy::match_like_matches_macro,
     clippy::unnecessary_wraps,
-    deprecated
+    deprecated,
+    clippy::if_same_then_else
 )]
 
 fn main() {
diff --git a/tests/ui/redundant_pattern_matching_result.stderr b/tests/ui/redundant_pattern_matching_result.stderr
index d6a46babb77..e06f095da20 100644
--- a/tests/ui/redundant_pattern_matching_result.stderr
+++ b/tests/ui/redundant_pattern_matching_result.stderr
@@ -1,5 +1,5 @@
 error: redundant pattern matching, consider using `is_ok()`
-  --> $DIR/redundant_pattern_matching_result.rs:15:12
+  --> $DIR/redundant_pattern_matching_result.rs:16:12
    |
 LL |     if let Ok(_) = &result {}
    |     -------^^^^^---------- help: try this: `if result.is_ok()`
@@ -7,31 +7,31 @@ LL |     if let Ok(_) = &result {}
    = note: `-D clippy::redundant-pattern-matching` implied by `-D warnings`
 
 error: redundant pattern matching, consider using `is_ok()`
-  --> $DIR/redundant_pattern_matching_result.rs:17:12
+  --> $DIR/redundant_pattern_matching_result.rs:18: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_result.rs:19:12
+  --> $DIR/redundant_pattern_matching_result.rs:20: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_result.rs:21:15
+  --> $DIR/redundant_pattern_matching_result.rs:22: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_result.rs:23:15
+  --> $DIR/redundant_pattern_matching_result.rs:24: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_result.rs:33:5
+  --> $DIR/redundant_pattern_matching_result.rs:34:5
    |
 LL | /     match Ok::<i32, i32>(42) {
 LL | |         Ok(_) => true,
@@ -40,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_result.rs:38:5
+  --> $DIR/redundant_pattern_matching_result.rs:39:5
    |
 LL | /     match Ok::<i32, i32>(42) {
 LL | |         Ok(_) => false,
@@ -49,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_result.rs:43:5
+  --> $DIR/redundant_pattern_matching_result.rs:44:5
    |
 LL | /     match Err::<i32, i32>(42) {
 LL | |         Ok(_) => false,
@@ -58,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_result.rs:48:5
+  --> $DIR/redundant_pattern_matching_result.rs:49:5
    |
 LL | /     match Err::<i32, i32>(42) {
 LL | |         Ok(_) => true,
@@ -67,73 +67,73 @@ LL | |     };
    | |_____^ help: try this: `Err::<i32, i32>(42).is_ok()`
 
 error: redundant pattern matching, consider using `is_ok()`
-  --> $DIR/redundant_pattern_matching_result.rs:53:20
+  --> $DIR/redundant_pattern_matching_result.rs:54: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_ok()`
-  --> $DIR/redundant_pattern_matching_result.rs:59:20
+  --> $DIR/redundant_pattern_matching_result.rs:60:20
    |
 LL |     let _ = if let Ok(_) = gen_res() {
    |             -------^^^^^------------ help: try this: `if gen_res().is_ok()`
 
 error: redundant pattern matching, consider using `is_err()`
-  --> $DIR/redundant_pattern_matching_result.rs:61:19
+  --> $DIR/redundant_pattern_matching_result.rs:62: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_result.rs:84:19
+  --> $DIR/redundant_pattern_matching_result.rs:85: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_result.rs:85:16
+  --> $DIR/redundant_pattern_matching_result.rs:86: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_result.rs:91:12
+  --> $DIR/redundant_pattern_matching_result.rs:92: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_result.rs:92:15
+  --> $DIR/redundant_pattern_matching_result.rs:93:15
    |
 LL |     while let Some(_) = m!() {}
    |     ----------^^^^^^^------- help: try this: `while m!().is_some()`
 
 error: redundant pattern matching, consider using `is_ok()`
-  --> $DIR/redundant_pattern_matching_result.rs:110:12
+  --> $DIR/redundant_pattern_matching_result.rs:111: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_result.rs:112:12
+  --> $DIR/redundant_pattern_matching_result.rs:113: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_result.rs:114:15
+  --> $DIR/redundant_pattern_matching_result.rs:115: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_result.rs:116:15
+  --> $DIR/redundant_pattern_matching_result.rs:117: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_result.rs:118:5
+  --> $DIR/redundant_pattern_matching_result.rs:119:5
    |
 LL | /     match Ok::<i32, i32>(42) {
 LL | |         Ok(_) => true,
@@ -142,7 +142,7 @@ LL | |     };
    | |_____^ help: try this: `Ok::<i32, i32>(42).is_ok()`
 
 error: redundant pattern matching, consider using `is_err()`
-  --> $DIR/redundant_pattern_matching_result.rs:123:5
+  --> $DIR/redundant_pattern_matching_result.rs:124:5
    |
 LL | /     match Err::<i32, i32>(42) {
 LL | |         Ok(_) => false,
-- 
cgit 1.4.1-3-g733a5


From c02baba1dcd9847d07762f42412d10eed7cff3e9 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Fri, 2 Apr 2021 19:04:45 -0400
Subject: `redundant_pattern_matching` fix inverted boolean when missing `Drop`
 trait

# Please enter the commit message for your changes. Lines starting
#
 with '#' will be ignored, and an empty message aborts the commit.
#
# Date:  
    Fri Apr 2 19:04:45 2021 -0400
#
# On branch redundant_pattern_matching
#
 Your branch is ahead of 'origin/redundant_pattern_matching' by 1 commit.
#  
 (use "git push" to publish your local commits)
#
# Changes to be committed:
#
 modified:   clippy_lints/src/matches.rs
#

# Please enter the commit message
 for your changes. Lines starting
# with '#' will be ignored, and an empty
 message aborts the commit.
#
# Date:      Fri Apr 2 19:04:45 2021 -0400
#
#
 interactive rebase in progress; onto ebc64690d
# Last commands done (6
 commands done):
#    pick 25d211ad8 Code cleanup and additional std types
 checked
#    r 0c71ce56f `redundant_pattern_matching` fix inverted boolean
 when missing `Drop` trait
# No commands remaining.
# You are currently
 editing a commit while rebasing branch 'redundant_pattern_matching' on
 'ebc64690d'.
#
# Changes to be committed:
#	modified:  
 clippy_lints/src/matches.rs
#

---
 clippy_lints/src/matches.rs | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index dc5232085ed..ddfc27e8460 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -1733,15 +1733,17 @@ mod redundant_pattern_match {
         }
     }
 
-    // Check if the drop order for a type matters
+    /// Checks if the drop order for a type matters. Some std types implement drop solely to
+    /// deallocate memory. For these types, and composites containing them, changing the drop order
+    /// won't result in any observable side effects.
     fn type_needs_ordered_drop(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
         if !ty.needs_drop(cx.tcx, cx.param_env) {
             false
-        } else if cx
+        } else if !cx
             .tcx
             .lang_items()
             .drop_trait()
-            .map_or(false, |id| !implements_trait(cx, ty, id, &[]))
+            .map_or(false, |id| implements_trait(cx, ty, id, &[]))
         {
             // This type doesn't implement drop, so no side effects here.
             // Check if any component type has any.
-- 
cgit 1.4.1-3-g733a5


From 9a55c0c1763cc5894ce1dbf1c40d03119e3de5f3 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Thu, 15 Apr 2021 22:05:37 -0400
Subject: Fix `single_match` Check for `PartialEq` in addition to
 `StructuralPartialEq` before suggesting `==`

---
 clippy_lints/src/matches.rs  |  7 +++++--
 tests/ui/single_match.rs     |  8 ++++++++
 tests/ui/single_match.stderr | 11 ++++++++++-
 3 files changed, 23 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index 8f1112cff7b..e4d1451b369 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -738,8 +738,11 @@ fn report_single_match_single_pattern(
     let (msg, sugg) = if_chain! {
         if let PatKind::Path(_) | PatKind::Lit(_) = pat.kind;
         let (ty, ty_ref_count) = peel_mid_ty_refs(cx.typeck_results().expr_ty(ex));
-        if let Some(trait_id) = cx.tcx.lang_items().structural_peq_trait();
-        if ty.is_integral() || ty.is_char() || ty.is_str() || implements_trait(cx, ty, trait_id, &[]);
+        if let Some(spe_trait_id) = cx.tcx.lang_items().structural_peq_trait();
+        if let Some(pe_trait_id) = cx.tcx.lang_items().eq_trait();
+        if ty.is_integral() || ty.is_char() || ty.is_str()
+            || (implements_trait(cx, ty, spe_trait_id, &[])
+                && implements_trait(cx, ty, pe_trait_id, &[ty.into()]));
         then {
             // scrutinee derives PartialEq and the pattern is a constant.
             let pat_ref_count = match pat.kind {
diff --git a/tests/ui/single_match.rs b/tests/ui/single_match.rs
index ca884b41c45..b1819e08d53 100644
--- a/tests/ui/single_match.rs
+++ b/tests/ui/single_match.rs
@@ -135,6 +135,14 @@ fn if_suggestion() {
         Bar::A => println!(),
         _ => (),
     }
+
+    // issue #7038
+    struct X;
+    let x = Some(X);
+    match x {
+        None => println!(),
+        _ => (),
+    };
 }
 
 macro_rules! single_match {
diff --git a/tests/ui/single_match.stderr b/tests/ui/single_match.stderr
index 7ea6955b740..9ef2a8668a6 100644
--- a/tests/ui/single_match.stderr
+++ b/tests/ui/single_match.stderr
@@ -119,5 +119,14 @@ LL | |         _ => (),
 LL | |     }
    | |_____^ help: try this: `if let Bar::A = x { println!() }`
 
-error: aborting due to 12 previous errors
+error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
+  --> $DIR/single_match.rs:142:5
+   |
+LL | /     match x {
+LL | |         None => println!(),
+LL | |         _ => (),
+LL | |     };
+   | |_____^ help: try this: `if let None = x { println!() }`
+
+error: aborting due to 13 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 61230f4cb822081ee17e8a660bc45a7b6ed0220d Mon Sep 17 00:00:00 2001
From: Yawara ISHIDA <ni732h.sphl@gmail.com>
Date: Fri, 16 Apr 2021 22:50:04 +0900
Subject: Fixed incosistent_struct_constructor triggers in macro-generated code

---
 clippy_lints/src/inconsistent_struct_constructor.rs | 1 +
 1 file changed, 1 insertion(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/inconsistent_struct_constructor.rs b/clippy_lints/src/inconsistent_struct_constructor.rs
index d7ca24487a8..7532f182360 100644
--- a/clippy_lints/src/inconsistent_struct_constructor.rs
+++ b/clippy_lints/src/inconsistent_struct_constructor.rs
@@ -66,6 +66,7 @@ declare_lint_pass!(InconsistentStructConstructor => [INCONSISTENT_STRUCT_CONSTRU
 impl LateLintPass<'_> for InconsistentStructConstructor {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
         if_chain! {
+            if !expr.span.from_expansion();
             if let ExprKind::Struct(qpath, fields, base) = expr.kind;
             let ty = cx.typeck_results().expr_ty(expr);
             if let Some(adt_def) = ty.ty_adt_def();
-- 
cgit 1.4.1-3-g733a5


From 0462666c7067d8992501aa8997d16e18da021ee5 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Fri, 16 Apr 2021 11:00:08 -0500
Subject: Add cloned_instead_of_copied lint

---
 CHANGELOG.md                                       |  1 +
 clippy_lints/src/lib.rs                            |  2 ++
 .../src/methods/cloned_instead_of_copied.rs        | 38 ++++++++++++++++++++++
 clippy_lints/src/methods/mod.rs                    | 26 +++++++++++++++
 clippy_utils/src/ty.rs                             | 21 +++++++++++-
 tests/ui/cloned_instead_of_copied.fixed            | 15 +++++++++
 tests/ui/cloned_instead_of_copied.rs               | 15 +++++++++
 tests/ui/cloned_instead_of_copied.stderr           | 34 +++++++++++++++++++
 8 files changed, 151 insertions(+), 1 deletion(-)
 create mode 100644 clippy_lints/src/methods/cloned_instead_of_copied.rs
 create mode 100644 tests/ui/cloned_instead_of_copied.fixed
 create mode 100644 tests/ui/cloned_instead_of_copied.rs
 create mode 100644 tests/ui/cloned_instead_of_copied.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 7885bdfb12c..483365b5e91 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2148,6 +2148,7 @@ Released 2018-09-13
 [`clone_double_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#clone_double_ref
 [`clone_on_copy`]: https://rust-lang.github.io/rust-clippy/master/index.html#clone_on_copy
 [`clone_on_ref_ptr`]: https://rust-lang.github.io/rust-clippy/master/index.html#clone_on_ref_ptr
+[`cloned_instead_of_copied`]: https://rust-lang.github.io/rust-clippy/master/index.html#cloned_instead_of_copied
 [`cmp_nan`]: https://rust-lang.github.io/rust-clippy/master/index.html#cmp_nan
 [`cmp_null`]: https://rust-lang.github.io/rust-clippy/master/index.html#cmp_null
 [`cmp_owned`]: https://rust-lang.github.io/rust-clippy/master/index.html#cmp_owned
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 93631c5669b..0f48799d339 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -759,6 +759,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         methods::BYTES_NTH,
         methods::CHARS_LAST_CMP,
         methods::CHARS_NEXT_CMP,
+        methods::CLONED_INSTEAD_OF_COPIED,
         methods::CLONE_DOUBLE_REF,
         methods::CLONE_ON_COPY,
         methods::CLONE_ON_REF_PTR,
@@ -1380,6 +1381,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(matches::MATCH_WILDCARD_FOR_SINGLE_VARIANTS),
         LintId::of(matches::MATCH_WILD_ERR_ARM),
         LintId::of(matches::SINGLE_MATCH_ELSE),
+        LintId::of(methods::CLONED_INSTEAD_OF_COPIED),
         LintId::of(methods::FILTER_MAP_NEXT),
         LintId::of(methods::IMPLICIT_CLONE),
         LintId::of(methods::INEFFICIENT_TO_STRING),
diff --git a/clippy_lints/src/methods/cloned_instead_of_copied.rs b/clippy_lints/src/methods/cloned_instead_of_copied.rs
new file mode 100644
index 00000000000..ba97ab3900c
--- /dev/null
+++ b/clippy_lints/src/methods/cloned_instead_of_copied.rs
@@ -0,0 +1,38 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::is_trait_method;
+use clippy_utils::ty::{get_iterator_item_ty, is_copy};
+use rustc_errors::Applicability;
+use rustc_hir::Expr;
+use rustc_lint::LateContext;
+use rustc_middle::ty;
+use rustc_span::{sym, Span};
+
+use super::CLONED_INSTEAD_OF_COPIED;
+
+pub fn check(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'_>, span: Span) {
+    let recv_ty = cx.typeck_results().expr_ty_adjusted(recv);
+    let inner_ty = match recv_ty.kind() {
+        // `Option<T>` -> `T`
+        ty::Adt(adt, subst) if cx.tcx.is_diagnostic_item(sym::option_type, adt.did) => subst.type_at(0),
+        _ if is_trait_method(cx, expr, sym::Iterator) => match get_iterator_item_ty(cx, recv_ty) {
+            // <T as Iterator>::Item
+            Some(ty) => ty,
+            _ => return,
+        },
+        _ => return,
+    };
+    match inner_ty.kind() {
+        // &T where T: Copy
+        ty::Ref(_, ty, _) if is_copy(cx, ty) => {},
+        _ => return,
+    };
+    span_lint_and_sugg(
+        cx,
+        CLONED_INSTEAD_OF_COPIED,
+        span,
+        "used `cloned` where `copied` could be used instead",
+        "try",
+        "copied".into(),
+        Applicability::MachineApplicable,
+    )
+}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 6c21ff0f6c2..49a9af2a465 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -8,6 +8,7 @@ mod chars_next_cmp;
 mod chars_next_cmp_with_unwrap;
 mod clone_on_copy;
 mod clone_on_ref_ptr;
+mod cloned_instead_of_copied;
 mod expect_fun_call;
 mod expect_used;
 mod filetype_is_file;
@@ -73,6 +74,29 @@ use rustc_span::symbol::SymbolStr;
 use rustc_span::{sym, Span};
 use rustc_typeck::hir_ty_to_ty;
 
+declare_clippy_lint! {
+    /// **What it does:** Checks for usages of `cloned()` on an `Iterator` or `Option` where
+    /// `copied()` could be used instead.
+    ///
+    /// **Why is this bad?** `copied()` is better because it guarantees that the type being cloned
+    /// implements `Copy`.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// [1, 2, 3].iter().cloned();
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// [1, 2, 3].iter().copied();
+    /// ```
+    pub CLONED_INSTEAD_OF_COPIED,
+    pedantic,
+    "used `cloned` where `copied` could be used instead"
+}
+
 declare_clippy_lint! {
     /// **What it does:** Checks for `.unwrap()` calls on `Option`s and on `Result`s.
     ///
@@ -1638,6 +1662,7 @@ impl_lint_pass!(Methods => [
     CLONE_ON_COPY,
     CLONE_ON_REF_PTR,
     CLONE_DOUBLE_REF,
+    CLONED_INSTEAD_OF_COPIED,
     INEFFICIENT_TO_STRING,
     NEW_RET_NO_SELF,
     SINGLE_CHAR_PATTERN,
@@ -1909,6 +1934,7 @@ fn check_methods<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, msrv: Optio
             ("as_mut", []) => useless_asref::check(cx, expr, "as_mut", recv),
             ("as_ref", []) => useless_asref::check(cx, expr, "as_ref", recv),
             ("assume_init", []) => uninit_assumed_init::check(cx, expr, recv),
+            ("cloned", []) => cloned_instead_of_copied::check(cx, expr, recv, span),
             ("collect", []) => match method_call!(recv) {
                 Some(("cloned", [recv2], _)) => iter_cloned_collect::check(cx, expr, recv2),
                 Some(("map", [m_recv, m_arg], _)) => {
diff --git a/clippy_utils/src/ty.rs b/clippy_utils/src/ty.rs
index 807cfbc4c7f..64a80f2554f 100644
--- a/clippy_utils/src/ty.rs
+++ b/clippy_utils/src/ty.rs
@@ -13,7 +13,7 @@ use rustc_lint::LateContext;
 use rustc_middle::ty::subst::{GenericArg, GenericArgKind};
 use rustc_middle::ty::{self, AdtDef, IntTy, Ty, TypeFoldable, UintTy};
 use rustc_span::sym;
-use rustc_span::symbol::Symbol;
+use rustc_span::symbol::{Ident, Symbol};
 use rustc_span::DUMMY_SP;
 use rustc_trait_selection::traits::query::normalize::AtExt;
 
@@ -52,6 +52,25 @@ pub fn contains_adt_constructor(ty: Ty<'_>, adt: &AdtDef) -> bool {
     })
 }
 
+/// Resolves `<T as Iterator>::Item` for `T`
+/// Do not invoke without first verifying that the type implements `Iterator`
+pub fn get_iterator_item_ty<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Option<Ty<'tcx>> {
+    cx.tcx
+        .get_diagnostic_item(sym::Iterator)
+        .and_then(|iter_did| {
+            cx.tcx.associated_items(iter_did).find_by_name_and_kind(
+                cx.tcx,
+                Ident::from_str("Item"),
+                ty::AssocKind::Type,
+                iter_did,
+            )
+        })
+        .map(|assoc| {
+            let proj = cx.tcx.mk_projection(assoc.def_id, cx.tcx.mk_substs_trait(ty, &[]));
+            cx.tcx.normalize_erasing_regions(cx.param_env, proj)
+        })
+}
+
 /// Returns true if ty has `iter` or `iter_mut` methods
 pub fn has_iter_method(cx: &LateContext<'_>, probably_ref_ty: Ty<'_>) -> Option<Symbol> {
     // FIXME: instead of this hard-coded list, we should check if `<adt>::iter`
diff --git a/tests/ui/cloned_instead_of_copied.fixed b/tests/ui/cloned_instead_of_copied.fixed
new file mode 100644
index 00000000000..4eb999e18e6
--- /dev/null
+++ b/tests/ui/cloned_instead_of_copied.fixed
@@ -0,0 +1,15 @@
+// run-rustfix
+#![warn(clippy::cloned_instead_of_copied)]
+
+fn main() {
+    // yay
+    let _ = [1].iter().copied();
+    let _ = vec!["hi"].iter().copied();
+    let _ = Some(&1).copied();
+    let _ = Box::new([1].iter()).copied();
+    let _ = Box::new(Some(&1)).copied();
+
+    // nay
+    let _ = [String::new()].iter().cloned();
+    let _ = Some(&String::new()).cloned();
+}
diff --git a/tests/ui/cloned_instead_of_copied.rs b/tests/ui/cloned_instead_of_copied.rs
new file mode 100644
index 00000000000..894496c0ebb
--- /dev/null
+++ b/tests/ui/cloned_instead_of_copied.rs
@@ -0,0 +1,15 @@
+// run-rustfix
+#![warn(clippy::cloned_instead_of_copied)]
+
+fn main() {
+    // yay
+    let _ = [1].iter().cloned();
+    let _ = vec!["hi"].iter().cloned();
+    let _ = Some(&1).cloned();
+    let _ = Box::new([1].iter()).cloned();
+    let _ = Box::new(Some(&1)).cloned();
+
+    // nay
+    let _ = [String::new()].iter().cloned();
+    let _ = Some(&String::new()).cloned();
+}
diff --git a/tests/ui/cloned_instead_of_copied.stderr b/tests/ui/cloned_instead_of_copied.stderr
new file mode 100644
index 00000000000..e0707d32146
--- /dev/null
+++ b/tests/ui/cloned_instead_of_copied.stderr
@@ -0,0 +1,34 @@
+error: used `cloned` where `copied` could be used instead
+  --> $DIR/cloned_instead_of_copied.rs:6:24
+   |
+LL |     let _ = [1].iter().cloned();
+   |                        ^^^^^^ help: try: `copied`
+   |
+   = note: `-D clippy::cloned-instead-of-copied` implied by `-D warnings`
+
+error: used `cloned` where `copied` could be used instead
+  --> $DIR/cloned_instead_of_copied.rs:7:31
+   |
+LL |     let _ = vec!["hi"].iter().cloned();
+   |                               ^^^^^^ help: try: `copied`
+
+error: used `cloned` where `copied` could be used instead
+  --> $DIR/cloned_instead_of_copied.rs:8:22
+   |
+LL |     let _ = Some(&1).cloned();
+   |                      ^^^^^^ help: try: `copied`
+
+error: used `cloned` where `copied` could be used instead
+  --> $DIR/cloned_instead_of_copied.rs:9:34
+   |
+LL |     let _ = Box::new([1].iter()).cloned();
+   |                                  ^^^^^^ help: try: `copied`
+
+error: used `cloned` where `copied` could be used instead
+  --> $DIR/cloned_instead_of_copied.rs:10:32
+   |
+LL |     let _ = Box::new(Some(&1)).cloned();
+   |                                ^^^^^^ help: try: `copied`
+
+error: aborting due to 5 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From b049c88fbe661f2ef1f1f7806788fed59dc1bfa8 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Fri, 16 Apr 2021 11:07:08 -0500
Subject: Eat dogfood

---
 clippy_lints/src/booleans.rs                       | 2 +-
 clippy_lints/src/checked_conversions.rs            | 4 ++--
 clippy_lints/src/loops/never_loop.rs               | 2 +-
 clippy_lints/src/matches.rs                        | 2 +-
 clippy_lints/src/needless_pass_by_value.rs         | 2 +-
 clippy_lints/src/suspicious_operation_groupings.rs | 2 +-
 clippy_lints/src/write.rs                          | 2 +-
 clippy_utils/src/hir_utils.rs                      | 2 +-
 clippy_utils/src/lib.rs                            | 6 +++---
 9 files changed, 12 insertions(+), 12 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/booleans.rs b/clippy_lints/src/booleans.rs
index 58d9aa9c005..67f0e0c7870 100644
--- a/clippy_lints/src/booleans.rs
+++ b/clippy_lints/src/booleans.rs
@@ -261,7 +261,7 @@ fn simplify_not(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<String> {
             }
             METHODS_WITH_NEGATION
                 .iter()
-                .cloned()
+                .copied()
                 .flat_map(|(a, b)| vec![(a, b), (b, a)])
                 .find(|&(a, _)| {
                     let path: &str = &path.ident.name.as_str();
diff --git a/clippy_lints/src/checked_conversions.rs b/clippy_lints/src/checked_conversions.rs
index d7136f84cc3..6a2666bc6c0 100644
--- a/clippy_lints/src/checked_conversions.rs
+++ b/clippy_lints/src/checked_conversions.rs
@@ -323,7 +323,7 @@ fn get_implementing_type<'a>(path: &QPath<'_>, candidates: &'a [&str], function:
         if let [int] = &*tp.segments;
         then {
             let name = &int.ident.name.as_str();
-            candidates.iter().find(|c| name == *c).cloned()
+            candidates.iter().find(|c| name == *c).copied()
         } else {
             None
         }
@@ -337,7 +337,7 @@ fn int_ty_to_sym<'tcx>(path: &QPath<'_>) -> Option<&'tcx str> {
         if let [ty] = &*path.segments;
         then {
             let name = &ty.ident.name.as_str();
-            INTS.iter().find(|c| name == *c).cloned()
+            INTS.iter().find(|c| name == *c).copied()
         } else {
             None
         }
diff --git a/clippy_lints/src/loops/never_loop.rs b/clippy_lints/src/loops/never_loop.rs
index 96720764e16..e97b7c94170 100644
--- a/clippy_lints/src/loops/never_loop.rs
+++ b/clippy_lints/src/loops/never_loop.rs
@@ -100,7 +100,7 @@ fn never_loop_expr(expr: &Expr<'_>, main_loop_id: HirId) -> NeverLoopResult {
         ExprKind::Binary(_, e1, e2)
         | ExprKind::Assign(e1, e2, _)
         | ExprKind::AssignOp(_, e1, e2)
-        | ExprKind::Index(e1, e2) => never_loop_expr_all(&mut [e1, e2].iter().cloned(), main_loop_id),
+        | ExprKind::Index(e1, e2) => never_loop_expr_all(&mut [e1, e2].iter().copied(), main_loop_id),
         ExprKind::Loop(b, _, _, _) => {
             // Break can come from the inner loop so remove them.
             absorb_break(&never_loop_block(b, main_loop_id))
diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index e4d1451b369..f4102709d7e 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -1124,7 +1124,7 @@ fn check_wild_enum_match(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>])
             Applicability::MaybeIncorrect,
         ),
         variants => {
-            let mut suggestions: Vec<_> = variants.iter().cloned().map(format_suggestion).collect();
+            let mut suggestions: Vec<_> = variants.iter().copied().map(format_suggestion).collect();
             let message = if adt_def.is_variant_list_non_exhaustive() {
                 suggestions.push("_".into());
                 "wildcard matches known variants and will also match future added variants"
diff --git a/clippy_lints/src/needless_pass_by_value.rs b/clippy_lints/src/needless_pass_by_value.rs
index 780e2241293..e33a33e2386 100644
--- a/clippy_lints/src/needless_pass_by_value.rs
+++ b/clippy_lints/src/needless_pass_by_value.rs
@@ -279,7 +279,7 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByValue {
                             spans.extend(
                                 deref_span
                                     .iter()
-                                    .cloned()
+                                    .copied()
                                     .map(|span| (span, format!("*{}", snippet(cx, span, "<expr>")))),
                             );
                             spans.sort_by_key(|&(span, _)| span);
diff --git a/clippy_lints/src/suspicious_operation_groupings.rs b/clippy_lints/src/suspicious_operation_groupings.rs
index cb2237e5312..4272935bc31 100644
--- a/clippy_lints/src/suspicious_operation_groupings.rs
+++ b/clippy_lints/src/suspicious_operation_groupings.rs
@@ -195,7 +195,7 @@ fn attempt_to_emit_no_difference_lint(
     i: usize,
     expected_loc: IdentLocation,
 ) {
-    if let Some(binop) = binops.get(i).cloned() {
+    if let Some(binop) = binops.get(i).copied() {
         // We need to try and figure out which identifier we should
         // suggest using instead. Since there could be multiple
         // replacement candidates in a given expression, and we're
diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs
index 12a47a6b703..7e962472c07 100644
--- a/clippy_lints/src/write.rs
+++ b/clippy_lints/src/write.rs
@@ -573,7 +573,7 @@ impl Write {
                         diag.multipart_suggestion(
                             "try this",
                             iter::once((comma_span.to(token_expr.span), String::new()))
-                                .chain(fmt_spans.iter().cloned().zip(iter::repeat(replacement)))
+                                .chain(fmt_spans.iter().copied().zip(iter::repeat(replacement)))
                                 .collect(),
                             Applicability::MachineApplicable,
                         );
diff --git a/clippy_utils/src/hir_utils.rs b/clippy_utils/src/hir_utils.rs
index f695f1a61e7..3ad1ac75e56 100644
--- a/clippy_utils/src/hir_utils.rs
+++ b/clippy_utils/src/hir_utils.rs
@@ -424,7 +424,7 @@ fn reduce_exprkind<'hir>(cx: &LateContext<'_>, kind: &'hir ExprKind<'hir>) -> &'
                                 TokenKind::LineComment { .. } | TokenKind::BlockComment { .. } | TokenKind::Whitespace
                             )
                         })
-                        .ne([TokenKind::OpenBrace, TokenKind::CloseBrace].iter().cloned()) =>
+                        .ne([TokenKind::OpenBrace, TokenKind::CloseBrace].iter().copied()) =>
                 {
                     kind
                 },
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 6c8a3302aa4..a5986ed00da 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -1053,7 +1053,7 @@ pub fn is_refutable(cx: &LateContext<'_>, pat: &Pat<'_>) -> bool {
 /// the function once on the given pattern.
 pub fn recurse_or_patterns<'tcx, F: FnMut(&'tcx Pat<'tcx>)>(pat: &'tcx Pat<'tcx>, mut f: F) {
     if let PatKind::Or(pats) = pat.kind {
-        pats.iter().cloned().for_each(f)
+        pats.iter().copied().for_each(f)
     } else {
         f(pat)
     }
@@ -1230,14 +1230,14 @@ pub fn match_any_def_paths(cx: &LateContext<'_>, did: DefId, paths: &[&[&str]])
     let search_path = cx.get_def_path(did);
     paths
         .iter()
-        .position(|p| p.iter().map(|x| Symbol::intern(x)).eq(search_path.iter().cloned()))
+        .position(|p| p.iter().map(|x| Symbol::intern(x)).eq(search_path.iter().copied()))
 }
 
 /// Checks if the given `DefId` matches the path.
 pub fn match_def_path<'tcx>(cx: &LateContext<'tcx>, did: DefId, syms: &[&str]) -> bool {
     // We should probably move to Symbols in Clippy as well rather than interning every time.
     let path = cx.get_def_path(did);
-    syms.iter().map(|x| Symbol::intern(x)).eq(path.iter().cloned())
+    syms.iter().map(|x| Symbol::intern(x)).eq(path.iter().copied())
 }
 
 pub fn match_panic_call(cx: &LateContext<'_>, expr: &'tcx Expr<'_>) -> Option<&'tcx Expr<'tcx>> {
-- 
cgit 1.4.1-3-g733a5


From 2d050f4b2f6057ea0ac63a3d8d37c05992e4ee3e Mon Sep 17 00:00:00 2001
From: Aliénore Bouttefeux <alienore.bouttefeux@gmail.com>
Date: Fri, 16 Apr 2021 19:38:01 +0200
Subject: add type in help of from over Into

---
 clippy_lints/src/from_over_into.rs | 2 +-
 tests/ui/from_over_into.stderr     | 3 +--
 2 files changed, 2 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/from_over_into.rs b/clippy_lints/src/from_over_into.rs
index e5ec245e502..5e2baba8943 100644
--- a/clippy_lints/src/from_over_into.rs
+++ b/clippy_lints/src/from_over_into.rs
@@ -73,7 +73,7 @@ impl LateLintPass<'_> for FromOverInto {
                     cx.tcx.sess.source_map().guess_head_span(item.span),
                     "an implementation of `From` is preferred since it gives you `Into<_>` for free where the reverse isn't true",
                     None,
-                    "consider to implement `From` instead",
+                    &format!("consider to implement `From<{}>` instead", impl_trait_ref.self_ty()),
                 );
             }
         }
diff --git a/tests/ui/from_over_into.stderr b/tests/ui/from_over_into.stderr
index b101d2704fb..fb391759dce 100644
--- a/tests/ui/from_over_into.stderr
+++ b/tests/ui/from_over_into.stderr
@@ -5,7 +5,6 @@ LL | impl Into<StringWrapper> for String {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::from-over-into` implied by `-D warnings`
-   = help: consider to implement `From` instead
+   = help: consider to implement `From<std::string::String>` instead
 
 error: aborting due to previous error
-
-- 
cgit 1.4.1-3-g733a5


From 559deddb3b5e376b79a019491bbdbf75eba2826d Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Thu, 15 Apr 2021 11:49:45 -0400
Subject: Allow allman style braces in `suspicious_else_formatting`

---
 clippy_lints/src/formatting.rs             | 17 +++++++++++--
 tests/ui/suspicious_else_formatting.rs     | 26 ++++++++++++++++++++
 tests/ui/suspicious_else_formatting.stderr | 39 ++++++++++++++++++++----------
 3 files changed, 67 insertions(+), 15 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/formatting.rs b/clippy_lints/src/formatting.rs
index 48612befc68..3bd6a09d365 100644
--- a/clippy_lints/src/formatting.rs
+++ b/clippy_lints/src/formatting.rs
@@ -215,9 +215,22 @@ fn check_else(cx: &EarlyContext<'_>, expr: &Expr) {
         // the snippet should look like " else \n    " with maybe comments anywhere
         // it’s bad when there is a ‘\n’ after the “else”
         if let Some(else_snippet) = snippet_opt(cx, else_span);
-        if let Some(else_pos) = else_snippet.find("else");
-        if else_snippet[else_pos..].contains('\n');
+        if let Some((pre_else, post_else)) = else_snippet.split_once("else");
+        if let Some((_, post_else_post_eol)) = post_else.split_once('\n');
+
         then {
+            // Allow allman style braces `} \n else \n {`
+            if_chain! {
+                if is_block(else_);
+                if let Some((_, pre_else_post_eol)) = pre_else.split_once('\n');
+                // Exactly one eol before and after the else
+                if !pre_else_post_eol.contains('\n');
+                if !post_else_post_eol.contains('\n');
+                then {
+                    return;
+                }
+            }
+
             let else_desc = if is_if(else_) { "if" } else { "{..}" };
             span_lint_and_note(
                 cx,
diff --git a/tests/ui/suspicious_else_formatting.rs b/tests/ui/suspicious_else_formatting.rs
index 226010ec6df..547615b10d9 100644
--- a/tests/ui/suspicious_else_formatting.rs
+++ b/tests/ui/suspicious_else_formatting.rs
@@ -40,6 +40,7 @@ fn main() {
     {
     }
 
+    // This is fine, though weird. Allman style braces on the else.
     if foo() {
     }
     else
@@ -76,4 +77,29 @@ fn main() {
     }
     if foo() {
     }
+
+    // Almost Allman style braces. Lint these.
+    if foo() {
+    }
+
+    else
+    {
+
+    }
+
+    if foo() {
+    }
+    else
+
+    {
+
+    }
+
+    // #3864 - Allman style braces
+    if foo()
+    {
+    }
+    else
+    {
+    }
 }
diff --git a/tests/ui/suspicious_else_formatting.stderr b/tests/ui/suspicious_else_formatting.stderr
index bbc036d376f..d8d67b4138a 100644
--- a/tests/ui/suspicious_else_formatting.stderr
+++ b/tests/ui/suspicious_else_formatting.stderr
@@ -41,37 +41,50 @@ LL | |     {
    |
    = note: to remove this lint, remove the `else` or remove the new line between `else` and `{..}`
 
-error: this is an `else {..}` but the formatting might hide it
-  --> $DIR/suspicious_else_formatting.rs:44:6
+error: this is an `else if` but the formatting might hide it
+  --> $DIR/suspicious_else_formatting.rs:51:6
    |
-LL |       }
+LL |       } else
    |  ______^
-LL | |     else
-LL | |     {
+LL | |     if foo() { // the span of the above error should continue here
    | |____^
    |
-   = note: to remove this lint, remove the `else` or remove the new line between `else` and `{..}`
+   = note: to remove this lint, remove the `else` or remove the new line between `else` and `if`
 
 error: this is an `else if` but the formatting might hide it
-  --> $DIR/suspicious_else_formatting.rs:50:6
+  --> $DIR/suspicious_else_formatting.rs:56:6
    |
-LL |       } else
+LL |       }
    |  ______^
+LL | |     else
 LL | |     if foo() { // the span of the above error should continue here
    | |____^
    |
    = note: to remove this lint, remove the `else` or remove the new line between `else` and `if`
 
-error: this is an `else if` but the formatting might hide it
-  --> $DIR/suspicious_else_formatting.rs:55:6
+error: this is an `else {..}` but the formatting might hide it
+  --> $DIR/suspicious_else_formatting.rs:83:6
    |
 LL |       }
    |  ______^
+LL | |
 LL | |     else
-LL | |     if foo() { // the span of the above error should continue here
+LL | |     {
    | |____^
    |
-   = note: to remove this lint, remove the `else` or remove the new line between `else` and `if`
+   = note: to remove this lint, remove the `else` or remove the new line between `else` and `{..}`
+
+error: this is an `else {..}` but the formatting might hide it
+  --> $DIR/suspicious_else_formatting.rs:91:6
+   |
+LL |       }
+   |  ______^
+LL | |     else
+LL | |
+LL | |     {
+   | |____^
+   |
+   = note: to remove this lint, remove the `else` or remove the new line between `else` and `{..}`
 
-error: aborting due to 8 previous errors
+error: aborting due to 9 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 5af078ac1b705abde41cc2e7c71be38701943cdb Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Fri, 16 Apr 2021 15:06:21 -0500
Subject: Add flat_map_option lint

---
 CHANGELOG.md                                |  1 +
 clippy_lints/src/lib.rs                     |  2 ++
 clippy_lints/src/matches.rs                 |  2 +-
 clippy_lints/src/methods/flat_map_option.rs | 34 +++++++++++++++++++++++++++++
 clippy_lints/src/methods/mod.rs             | 30 ++++++++++++++++++++++++-
 clippy_utils/src/attrs.rs                   |  2 +-
 tests/ui/flat_map_option.fixed              | 13 +++++++++++
 tests/ui/flat_map_option.rs                 | 13 +++++++++++
 tests/ui/flat_map_option.stderr             | 16 ++++++++++++++
 9 files changed, 110 insertions(+), 3 deletions(-)
 create mode 100644 clippy_lints/src/methods/flat_map_option.rs
 create mode 100644 tests/ui/flat_map_option.fixed
 create mode 100644 tests/ui/flat_map_option.rs
 create mode 100644 tests/ui/flat_map_option.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 483365b5e91..56cdd356469 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2216,6 +2216,7 @@ Released 2018-09-13
 [`filter_next`]: https://rust-lang.github.io/rust-clippy/master/index.html#filter_next
 [`find_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#find_map
 [`flat_map_identity`]: https://rust-lang.github.io/rust-clippy/master/index.html#flat_map_identity
+[`flat_map_option`]: https://rust-lang.github.io/rust-clippy/master/index.html#flat_map_option
 [`float_arithmetic`]: https://rust-lang.github.io/rust-clippy/master/index.html#float_arithmetic
 [`float_cmp`]: https://rust-lang.github.io/rust-clippy/master/index.html#float_cmp
 [`float_cmp_const`]: https://rust-lang.github.io/rust-clippy/master/index.html#float_cmp_const
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 0f48799d339..a7871b7aba7 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -770,6 +770,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         methods::FILTER_MAP_NEXT,
         methods::FILTER_NEXT,
         methods::FLAT_MAP_IDENTITY,
+        methods::FLAT_MAP_OPTION,
         methods::FROM_ITER_INSTEAD_OF_COLLECT,
         methods::GET_UNWRAP,
         methods::IMPLICIT_CLONE,
@@ -1383,6 +1384,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(matches::SINGLE_MATCH_ELSE),
         LintId::of(methods::CLONED_INSTEAD_OF_COPIED),
         LintId::of(methods::FILTER_MAP_NEXT),
+        LintId::of(methods::FLAT_MAP_OPTION),
         LintId::of(methods::IMPLICIT_CLONE),
         LintId::of(methods::INEFFICIENT_TO_STRING),
         LintId::of(methods::MAP_FLATTEN),
diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index 2c8d8a0f132..44b4eb29035 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -1509,7 +1509,7 @@ fn opt_parent_let<'a>(cx: &LateContext<'a>, ex: &Expr<'a>) -> Option<&'a Local<'
 /// Gets all arms that are unbounded `PatRange`s.
 fn all_ranges<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>], ty: Ty<'tcx>) -> Vec<SpannedRange<Constant>> {
     arms.iter()
-        .flat_map(|arm| {
+        .filter_map(|arm| {
             if let Arm { pat, guard: None, .. } = *arm {
                 if let PatKind::Range(ref lhs, ref rhs, range_end) = pat.kind {
                     let lhs = match lhs {
diff --git a/clippy_lints/src/methods/flat_map_option.rs b/clippy_lints/src/methods/flat_map_option.rs
new file mode 100644
index 00000000000..12d560653ed
--- /dev/null
+++ b/clippy_lints/src/methods/flat_map_option.rs
@@ -0,0 +1,34 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::is_trait_method;
+use rustc_errors::Applicability;
+use rustc_hir as hir;
+use rustc_lint::LateContext;
+use rustc_middle::ty;
+use rustc_span::{source_map::Span, sym};
+
+use super::FLAT_MAP_OPTION;
+use clippy_utils::ty::is_type_diagnostic_item;
+
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, arg: &'tcx hir::Expr<'_>, span: Span) {
+    if !is_trait_method(cx, expr, sym::Iterator) {
+        return;
+    }
+    let arg_ty = cx.typeck_results().expr_ty_adjusted(arg);
+    let sig = match arg_ty.kind() {
+        ty::Closure(_, substs) => substs.as_closure().sig(),
+        _ if arg_ty.is_fn() => arg_ty.fn_sig(cx.tcx),
+        _ => return,
+    };
+    if !is_type_diagnostic_item(cx, sig.output().skip_binder(), sym::option_type) {
+        return;
+    }
+    span_lint_and_sugg(
+        cx,
+        FLAT_MAP_OPTION,
+        span,
+        "used `flat_map` where `filter_map` could be used instead",
+        "try",
+        "filter_map".into(),
+        Applicability::MachineApplicable,
+    )
+}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 49a9af2a465..c2cd3011d14 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -17,6 +17,7 @@ mod filter_map_identity;
 mod filter_map_next;
 mod filter_next;
 mod flat_map_identity;
+mod flat_map_option;
 mod from_iter_instead_of_collect;
 mod get_unwrap;
 mod implicit_clone;
@@ -97,6 +98,29 @@ declare_clippy_lint! {
     "used `cloned` where `copied` could be used instead"
 }
 
+declare_clippy_lint! {
+    /// **What it does:** Checks for usages of `Iterator::flat_map()` where `filter_map()` could be
+    /// used instead.
+    ///
+    /// **Why is this bad?** When applicable, `filter_map()` is more clear since it shows that
+    /// `Option` is used to produce 0 or 1 items.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// let nums: Vec<i32> = ["1", "2", "whee!"].iter().flat_map(|x| x.parse().ok()).collect();
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// let nums: Vec<i32> = ["1", "2", "whee!"].iter().filter_map(|x| x.parse().ok()).collect();
+    /// ```
+    pub FLAT_MAP_OPTION,
+    pedantic,
+    "used `flat_map` where `filter_map` could be used instead"
+}
+
 declare_clippy_lint! {
     /// **What it does:** Checks for `.unwrap()` calls on `Option`s and on `Result`s.
     ///
@@ -1663,6 +1687,7 @@ impl_lint_pass!(Methods => [
     CLONE_ON_REF_PTR,
     CLONE_DOUBLE_REF,
     CLONED_INSTEAD_OF_COPIED,
+    FLAT_MAP_OPTION,
     INEFFICIENT_TO_STRING,
     NEW_RET_NO_SELF,
     SINGLE_CHAR_PATTERN,
@@ -1958,7 +1983,10 @@ fn check_methods<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, msrv: Optio
                 unnecessary_filter_map::check(cx, expr, arg);
                 filter_map_identity::check(cx, expr, arg, span);
             },
-            ("flat_map", [flm_arg]) => flat_map_identity::check(cx, expr, flm_arg, span),
+            ("flat_map", [arg]) => {
+                flat_map_identity::check(cx, expr, arg, span);
+                flat_map_option::check(cx, expr, arg, span);
+            },
             ("flatten", []) => {
                 if let Some(("map", [recv, map_arg], _)) = method_call!(recv) {
                     map_flatten::check(cx, expr, recv, map_arg);
diff --git a/clippy_utils/src/attrs.rs b/clippy_utils/src/attrs.rs
index 5e44c7b3ee0..c0584e1e226 100644
--- a/clippy_utils/src/attrs.rs
+++ b/clippy_utils/src/attrs.rs
@@ -154,6 +154,6 @@ pub fn is_doc_hidden(attrs: &[ast::Attribute]) -> bool {
     attrs
         .iter()
         .filter(|attr| attr.has_name(sym::doc))
-        .flat_map(ast::Attribute::meta_item_list)
+        .filter_map(ast::Attribute::meta_item_list)
         .any(|l| attr::list_contains_name(&l, sym::hidden))
 }
diff --git a/tests/ui/flat_map_option.fixed b/tests/ui/flat_map_option.fixed
new file mode 100644
index 00000000000..6a34f008995
--- /dev/null
+++ b/tests/ui/flat_map_option.fixed
@@ -0,0 +1,13 @@
+// run-rustfix
+#![warn(clippy::flat_map_option)]
+#![allow(clippy::redundant_closure, clippy::unnecessary_filter_map)]
+
+fn main() {
+    // yay
+    let c = |x| Some(x);
+    let _ = [1].iter().filter_map(c);
+    let _ = [1].iter().filter_map(Some);
+
+    // nay
+    let _ = [1].iter().flat_map(|_| &Some(1));
+}
diff --git a/tests/ui/flat_map_option.rs b/tests/ui/flat_map_option.rs
new file mode 100644
index 00000000000..2479abddbf0
--- /dev/null
+++ b/tests/ui/flat_map_option.rs
@@ -0,0 +1,13 @@
+// run-rustfix
+#![warn(clippy::flat_map_option)]
+#![allow(clippy::redundant_closure, clippy::unnecessary_filter_map)]
+
+fn main() {
+    // yay
+    let c = |x| Some(x);
+    let _ = [1].iter().flat_map(c);
+    let _ = [1].iter().flat_map(Some);
+
+    // nay
+    let _ = [1].iter().flat_map(|_| &Some(1));
+}
diff --git a/tests/ui/flat_map_option.stderr b/tests/ui/flat_map_option.stderr
new file mode 100644
index 00000000000..a9d8056dee9
--- /dev/null
+++ b/tests/ui/flat_map_option.stderr
@@ -0,0 +1,16 @@
+error: used `flat_map` where `filter_map` could be used instead
+  --> $DIR/flat_map_option.rs:8:24
+   |
+LL |     let _ = [1].iter().flat_map(c);
+   |                        ^^^^^^^^ help: try: `filter_map`
+   |
+   = note: `-D clippy::flat-map-option` implied by `-D warnings`
+
+error: used `flat_map` where `filter_map` could be used instead
+  --> $DIR/flat_map_option.rs:9:24
+   |
+LL |     let _ = [1].iter().flat_map(Some);
+   |                        ^^^^^^^^ help: try: `filter_map`
+
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 8b5faf4ab0cfc54bc9cc23b6f013bc571c62c360 Mon Sep 17 00:00:00 2001
From: JP Sugarbroad <taralx@gmail.com>
Date: Fri, 16 Apr 2021 14:29:23 -0700
Subject: Switch transmute_ptr_to_ptr to "pedantic" class.

Per discussion in https://github.com/rust-lang/rust-clippy/issues/6372, this lint has significant false positives.
---
 clippy_lints/src/lib.rs           | 3 +--
 clippy_lints/src/transmute/mod.rs | 2 +-
 2 files changed, 2 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 0f48799d339..f7255d32c99 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1405,6 +1405,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(strings::STRING_ADD_ASSIGN),
         LintId::of(trait_bounds::TRAIT_DUPLICATION_IN_BOUNDS),
         LintId::of(trait_bounds::TYPE_REPETITION_IN_BOUNDS),
+        LintId::of(transmute::TRANSMUTE_PTR_TO_PTR),
         LintId::of(types::LINKEDLIST),
         LintId::of(types::OPTION_OPTION),
         LintId::of(unicode::NON_ASCII_LITERAL),
@@ -1693,7 +1694,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(transmute::TRANSMUTE_INT_TO_BOOL),
         LintId::of(transmute::TRANSMUTE_INT_TO_CHAR),
         LintId::of(transmute::TRANSMUTE_INT_TO_FLOAT),
-        LintId::of(transmute::TRANSMUTE_PTR_TO_PTR),
         LintId::of(transmute::TRANSMUTE_PTR_TO_REF),
         LintId::of(transmute::UNSOUND_COLLECTION_TRANSMUTE),
         LintId::of(transmute::WRONG_TRANSMUTE),
@@ -1927,7 +1927,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(transmute::TRANSMUTE_INT_TO_BOOL),
         LintId::of(transmute::TRANSMUTE_INT_TO_CHAR),
         LintId::of(transmute::TRANSMUTE_INT_TO_FLOAT),
-        LintId::of(transmute::TRANSMUTE_PTR_TO_PTR),
         LintId::of(transmute::TRANSMUTE_PTR_TO_REF),
         LintId::of(types::BORROWED_BOX),
         LintId::of(types::TYPE_COMPLEXITY),
diff --git a/clippy_lints/src/transmute/mod.rs b/clippy_lints/src/transmute/mod.rs
index 86ac916df6c..569113910c9 100644
--- a/clippy_lints/src/transmute/mod.rs
+++ b/clippy_lints/src/transmute/mod.rs
@@ -274,7 +274,7 @@ declare_clippy_lint! {
     /// let _ = unsafe{ &*(&1u32 as *const u32 as *const f32) };
     /// ```
     pub TRANSMUTE_PTR_TO_PTR,
-    complexity,
+    pedantic,
     "transmutes from a pointer to a pointer / a reference to a reference"
 }
 
-- 
cgit 1.4.1-3-g733a5


From 243dc4625050d791eb8f91b6b4da2f8dc8449a8d Mon Sep 17 00:00:00 2001
From: Andre Bogus <bogusandre@gmail.com>
Date: Sun, 18 Apr 2021 23:49:54 +0200
Subject: un-double `return` on try_err

---
 clippy_lints/src/try_err.rs | 11 ++++++++---
 tests/ui/try_err.fixed      |  8 ++++++++
 tests/ui/try_err.rs         |  8 ++++++++
 tests/ui/try_err.stderr     |  8 +++++++-
 4 files changed, 31 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/try_err.rs b/clippy_lints/src/try_err.rs
index 0b8c03c6865..ebb39ea4877 100644
--- a/clippy_lints/src/try_err.rs
+++ b/clippy_lints/src/try_err.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::{snippet, snippet_with_macro_callsite};
 use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{differing_macro_contexts, in_macro, is_lang_ctor, match_def_path, paths};
+use clippy_utils::{differing_macro_contexts, get_parent_expr, in_macro, is_lang_ctor, match_def_path, paths};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::LangItem::ResultErr;
@@ -102,10 +102,15 @@ impl<'tcx> LateLintPass<'tcx> for TryErr {
                 } else {
                     snippet(cx, err_arg.span, "_")
                 };
+                let ret_prefix = if get_parent_expr(cx, expr).map_or(false, |e| matches!(e.kind, ExprKind::Ret(_))) {
+                    "" // already returns
+                } else {
+                    "return "
+                };
                 let suggestion = if err_ty == expr_err_ty {
-                    format!("return {}{}{}", prefix, origin_snippet, suffix)
+                    format!("{}{}{}{}", ret_prefix, prefix, origin_snippet, suffix)
                 } else {
-                    format!("return {}{}.into(){}", prefix, origin_snippet, suffix)
+                    format!("{}{}{}.into(){}", ret_prefix, prefix, origin_snippet, suffix)
                 };
 
                 span_lint_and_sugg(
diff --git a/tests/ui/try_err.fixed b/tests/ui/try_err.fixed
index 5b96bb59c5f..264194419c7 100644
--- a/tests/ui/try_err.fixed
+++ b/tests/ui/try_err.fixed
@@ -160,3 +160,11 @@ pub fn poll_next(ready: bool) -> Poll<Option<io::Result<()>>> {
 
     Poll::Ready(None)
 }
+
+// Tests that `return` is not duplicated
+pub fn try_return(x: bool) -> Result<i32, i32> {
+    if x {
+        return Err(42);
+    }
+    Ok(0)
+}
diff --git a/tests/ui/try_err.rs b/tests/ui/try_err.rs
index f220d697d2c..bc6979bf457 100644
--- a/tests/ui/try_err.rs
+++ b/tests/ui/try_err.rs
@@ -160,3 +160,11 @@ pub fn poll_next(ready: bool) -> Poll<Option<io::Result<()>>> {
 
     Poll::Ready(None)
 }
+
+// Tests that `return` is not duplicated
+pub fn try_return(x: bool) -> Result<i32, i32> {
+    if x {
+        return Err(42)?;
+    }
+    Ok(0)
+}
diff --git a/tests/ui/try_err.stderr b/tests/ui/try_err.stderr
index 2c01d37192e..8f332a9b649 100644
--- a/tests/ui/try_err.stderr
+++ b/tests/ui/try_err.stderr
@@ -74,5 +74,11 @@ error: returning an `Err(_)` with the `?` operator
 LL |         Err(io::ErrorKind::NotFound)?
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `return Poll::Ready(Some(Err(io::ErrorKind::NotFound.into())))`
 
-error: aborting due to 10 previous errors
+error: returning an `Err(_)` with the `?` operator
+  --> $DIR/try_err.rs:167:16
+   |
+LL |         return Err(42)?;
+   |                ^^^^^^^^ help: try this: `Err(42)`
+
+error: aborting due to 11 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From c6b381c59bffe8ce62fcf9569fb1a39189234dcc Mon Sep 17 00:00:00 2001
From: Basavesh Shivakumar <basavesh.shivakumar@gmail.com>
Date: Mon, 19 Apr 2021 17:20:21 +0200
Subject: useless use of format! should return function directly

---
 clippy_lints/src/format.rs | 11 ++++++-----
 tests/ui/format.fixed      |  4 ++++
 tests/ui/format.rs         |  4 ++++
 tests/ui/format.stderr     |  8 +++++++-
 4 files changed, 21 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/format.rs b/clippy_lints/src/format.rs
index 4729abbd8e3..c2b055ed648 100644
--- a/clippy_lints/src/format.rs
+++ b/clippy_lints/src/format.rs
@@ -1,6 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::paths;
 use clippy_utils::source::{snippet, snippet_opt};
+use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::{is_expn_of, last_path_segment, match_def_path, match_function_call};
 use if_chain::if_chain;
@@ -100,15 +101,15 @@ fn on_argumentv1_new<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, arms: &
                     return Some(format!("{:?}.to_string()", s.as_str()));
                 }
             } else {
-                let snip = snippet(cx, format_args.span, "<arg>");
+                let sugg = Sugg::hir(cx, format_args, "<arg>");
                 if let ExprKind::MethodCall(path, _, _, _) = format_args.kind {
                     if path.ident.name == sym!(to_string) {
-                        return Some(format!("{}", snip));
+                        return Some(format!("{}", sugg));
                     }
                 } else if let ExprKind::Binary(..) = format_args.kind {
-                    return Some(format!("{}", snip));
+                    return Some(format!("{}", sugg));
                 }
-                return Some(format!("{}.to_string()", snip));
+                return Some(format!("{}.to_string()", sugg.maybe_par()));
             }
         }
     }
@@ -136,7 +137,7 @@ fn on_new_v1<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<Strin
                 if let Some(s_src) = snippet_opt(cx, lit.span) {
                     // Simulate macro expansion, converting {{ and }} to { and }.
                     let s_expand = s_src.replace("{{", "{").replace("}}", "}");
-                    return Some(format!("{}.to_string()", s_expand))
+                    return Some(format!("{}.to_string()", s_expand));
                 }
             } else if s.as_str().is_empty() {
                 return on_argumentv1_new(cx, &tup[0], arms);
diff --git a/tests/ui/format.fixed b/tests/ui/format.fixed
index 740a22a07d7..e4cfb005fd1 100644
--- a/tests/ui/format.fixed
+++ b/tests/ui/format.fixed
@@ -65,4 +65,8 @@ fn main() {
     // False positive
     let a = "foo".to_string();
     let _ = Some(a + "bar");
+
+    // Wrap it with braces
+    let v: Vec<String> = vec!["foo".to_string(), "bar".to_string()];
+    let _s: String = (&*v.join("\n")).to_string();
 }
diff --git a/tests/ui/format.rs b/tests/ui/format.rs
index b604d79cca3..683957f0ff0 100644
--- a/tests/ui/format.rs
+++ b/tests/ui/format.rs
@@ -67,4 +67,8 @@ fn main() {
     // False positive
     let a = "foo".to_string();
     let _ = Some(format!("{}", a + "bar"));
+
+    // Wrap it with braces
+    let v: Vec<String> = vec!["foo".to_string(), "bar".to_string()];
+    let _s: String = format!("{}", &*v.join("\n"));
 }
diff --git a/tests/ui/format.stderr b/tests/ui/format.stderr
index 96df7f37f77..2017eb2b383 100644
--- a/tests/ui/format.stderr
+++ b/tests/ui/format.stderr
@@ -87,5 +87,11 @@ error: useless use of `format!`
 LL |     let _ = Some(format!("{}", a + "bar"));
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `a + "bar"`
 
-error: aborting due to 13 previous errors
+error: useless use of `format!`
+  --> $DIR/format.rs:73:22
+   |
+LL |     let _s: String = format!("{}", &*v.join("/n"));
+   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `(&*v.join("/n")).to_string()`
+
+error: aborting due to 14 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From e2e104b993277a8096299a2d2eb99d4641f1e318 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Thu, 15 Apr 2021 15:26:57 +0200
Subject: Add lint to check for boolean comparison in assert macro calls

---
 CHANGELOG.md                               |   1 +
 clippy_lints/src/bool_assert_comparison.rs |  75 +++++++++++++++++++
 clippy_lints/src/lib.rs                    |   5 ++
 clippy_utils/src/ast_utils.rs              |  32 +++++++++
 tests/ui/bool_assert_comparison.rs         |  59 +++++++++++++++
 tests/ui/bool_assert_comparison.stderr     | 112 +++++++++++++++++++++++++++++
 6 files changed, 284 insertions(+)
 create mode 100644 clippy_lints/src/bool_assert_comparison.rs
 create mode 100644 tests/ui/bool_assert_comparison.rs
 create mode 100644 tests/ui/bool_assert_comparison.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 7885bdfb12c..830a3efb7df 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2124,6 +2124,7 @@ Released 2018-09-13
 [`blacklisted_name`]: https://rust-lang.github.io/rust-clippy/master/index.html#blacklisted_name
 [`blanket_clippy_restriction_lints`]: https://rust-lang.github.io/rust-clippy/master/index.html#blanket_clippy_restriction_lints
 [`blocks_in_if_conditions`]: https://rust-lang.github.io/rust-clippy/master/index.html#blocks_in_if_conditions
+[`bool_assert_comparison`]: https://rust-lang.github.io/rust-clippy/master/index.html#bool_assert_comparison
 [`bool_comparison`]: https://rust-lang.github.io/rust-clippy/master/index.html#bool_comparison
 [`borrow_interior_mutable_const`]: https://rust-lang.github.io/rust-clippy/master/index.html#borrow_interior_mutable_const
 [`borrowed_box`]: https://rust-lang.github.io/rust-clippy/master/index.html#borrowed_box
diff --git a/clippy_lints/src/bool_assert_comparison.rs b/clippy_lints/src/bool_assert_comparison.rs
new file mode 100644
index 00000000000..bee706ed402
--- /dev/null
+++ b/clippy_lints/src/bool_assert_comparison.rs
@@ -0,0 +1,75 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::{ast_utils, is_direct_expn_of};
+use rustc_ast::ast::{Expr, ExprKind, Lit, LitKind};
+use rustc_errors::Applicability;
+use rustc_lint::{EarlyContext, EarlyLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// **What it does:** This lint warns about boolean comparisons in assert-like macros.
+    ///
+    /// **Why is this bad?** It is shorter to use the equivalent.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// // Bad
+    /// assert_eq!("a".is_empty(), false);
+    /// assert_ne!("a".is_empty(), true);
+    ///
+    /// // Good
+    /// assert!(!"a".is_empty());
+    /// ```
+    pub BOOL_ASSERT_COMPARISON,
+    style,
+    "Using a boolean as comparison value in an assert_* macro when there is no need"
+}
+
+declare_lint_pass!(BoolAssertComparison => [BOOL_ASSERT_COMPARISON]);
+
+fn is_bool_lit(e: &Expr) -> bool {
+    matches!(
+        e.kind,
+        ExprKind::Lit(Lit {
+            kind: LitKind::Bool(_),
+            ..
+        })
+    ) && !e.span.from_expansion()
+}
+
+impl EarlyLintPass for BoolAssertComparison {
+    fn check_expr(&mut self, cx: &EarlyContext<'_>, e: &Expr) {
+        let macros = ["assert_eq", "debug_assert_eq"];
+        let inverted_macros = ["assert_ne", "debug_assert_ne"];
+
+        for mac in macros.iter().chain(inverted_macros.iter()) {
+            if let Some(span) = is_direct_expn_of(e.span, mac) {
+                if let Some([a, b]) = ast_utils::extract_assert_macro_args(e) {
+                    let nb_bool_args = is_bool_lit(a) as usize + is_bool_lit(b) as usize;
+
+                    if nb_bool_args != 1 {
+                        // If there are two boolean arguments, we definitely don't understand
+                        // what's going on, so better leave things as is...
+                        //
+                        // Or there is simply no boolean and then we can leave things as is!
+                        return;
+                    }
+
+                    let non_eq_mac = &mac[..mac.len() - 3];
+                    span_lint_and_sugg(
+                        cx,
+                        BOOL_ASSERT_COMPARISON,
+                        span,
+                        &format!("used `{}!` with a literal bool", mac),
+                        "replace it with",
+                        format!("{}!(..)", non_eq_mac),
+                        Applicability::MaybeIncorrect,
+                    );
+                    return;
+                }
+            }
+        }
+    }
+}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 78a95b00403..f08388f9037 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -178,6 +178,7 @@ mod await_holding_invalid;
 mod bit_mask;
 mod blacklisted_name;
 mod blocks_in_if_conditions;
+mod bool_assert_comparison;
 mod booleans;
 mod bytecount;
 mod cargo_common_metadata;
@@ -567,6 +568,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         bit_mask::VERBOSE_BIT_MASK,
         blacklisted_name::BLACKLISTED_NAME,
         blocks_in_if_conditions::BLOCKS_IN_IF_CONDITIONS,
+        bool_assert_comparison::BOOL_ASSERT_COMPARISON,
         booleans::LOGIC_BUG,
         booleans::NONMINIMAL_BOOL,
         bytecount::NAIVE_BYTECOUNT,
@@ -1270,6 +1272,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box from_str_radix_10::FromStrRadix10);
     store.register_late_pass(|| box manual_map::ManualMap);
     store.register_late_pass(move || box if_then_some_else_none::IfThenSomeElseNone::new(msrv));
+    store.register_early_pass(|| box bool_assert_comparison::BoolAssertComparison);
 
     store.register_group(true, "clippy::restriction", Some("clippy_restriction"), vec![
         LintId::of(arithmetic::FLOAT_ARITHMETIC),
@@ -1448,6 +1451,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(bit_mask::INEFFECTIVE_BIT_MASK),
         LintId::of(blacklisted_name::BLACKLISTED_NAME),
         LintId::of(blocks_in_if_conditions::BLOCKS_IN_IF_CONDITIONS),
+        LintId::of(bool_assert_comparison::BOOL_ASSERT_COMPARISON),
         LintId::of(booleans::LOGIC_BUG),
         LintId::of(booleans::NONMINIMAL_BOOL),
         LintId::of(casts::CAST_REF_TO_MUT),
@@ -1734,6 +1738,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(attrs::BLANKET_CLIPPY_RESTRICTION_LINTS),
         LintId::of(blacklisted_name::BLACKLISTED_NAME),
         LintId::of(blocks_in_if_conditions::BLOCKS_IN_IF_CONDITIONS),
+        LintId::of(bool_assert_comparison::BOOL_ASSERT_COMPARISON),
         LintId::of(casts::FN_TO_NUMERIC_CAST),
         LintId::of(casts::FN_TO_NUMERIC_CAST_WITH_TRUNCATION),
         LintId::of(collapsible_if::COLLAPSIBLE_ELSE_IF),
diff --git a/clippy_utils/src/ast_utils.rs b/clippy_utils/src/ast_utils.rs
index eaea3e636f9..93e10c836cc 100644
--- a/clippy_utils/src/ast_utils.rs
+++ b/clippy_utils/src/ast_utils.rs
@@ -5,6 +5,7 @@
 #![allow(clippy::similar_names, clippy::wildcard_imports, clippy::enum_glob_use)]
 
 use crate::{both, over};
+use if_chain::if_chain;
 use rustc_ast::ptr::P;
 use rustc_ast::{self as ast, *};
 use rustc_span::symbol::Ident;
@@ -571,3 +572,34 @@ pub fn eq_mac_args(l: &MacArgs, r: &MacArgs) -> bool {
         _ => false,
     }
 }
+
+/// Extract args from an assert-like macro.
+///
+/// Currently working with:
+/// - `assert_eq!` and `assert_ne!`
+/// - `debug_assert_eq!` and `debug_assert_ne!`
+///
+/// For example:
+///
+/// `debug_assert_eq!(a, b)` will return Some([a, b])
+pub fn extract_assert_macro_args(mut expr: &Expr) -> Option<[&Expr; 2]> {
+    if_chain! {
+        if let ExprKind::If(_, ref block, _) = expr.kind;
+        if let StmtKind::Semi(ref e) = block.stmts.get(0)?.kind;
+        then {
+            expr = e;
+        }
+    }
+    if_chain! {
+        if let ExprKind::Block(ref block, _) = expr.kind;
+        if let StmtKind::Expr(ref expr) = block.stmts.get(0)?.kind;
+        if let ExprKind::Match(ref match_expr, _) = expr.kind;
+        if let ExprKind::Tup(ref tup) = match_expr.kind;
+        if let [a, b, ..] = tup.as_slice();
+        if let (&ExprKind::AddrOf(_, _, ref a), &ExprKind::AddrOf(_, _, ref b)) = (&a.kind, &b.kind);
+        then {
+            return Some([&*a, &*b]);
+        }
+    }
+    None
+}
diff --git a/tests/ui/bool_assert_comparison.rs b/tests/ui/bool_assert_comparison.rs
new file mode 100644
index 00000000000..2de402fae8c
--- /dev/null
+++ b/tests/ui/bool_assert_comparison.rs
@@ -0,0 +1,59 @@
+#![warn(clippy::bool_assert_comparison)]
+
+macro_rules! a {
+    () => {
+        true
+    };
+}
+macro_rules! b {
+    () => {
+        true
+    };
+}
+
+fn main() {
+    assert_eq!("a".len(), 1);
+    assert_eq!("a".is_empty(), false);
+    assert_eq!("".is_empty(), true);
+    assert_eq!(true, "".is_empty());
+    assert_eq!(a!(), b!());
+    assert_eq!(a!(), "".is_empty());
+    assert_eq!("".is_empty(), b!());
+
+    assert_ne!("a".len(), 1);
+    assert_ne!("a".is_empty(), false);
+    assert_ne!("".is_empty(), true);
+    assert_ne!(true, "".is_empty());
+    assert_ne!(a!(), b!());
+    assert_ne!(a!(), "".is_empty());
+    assert_ne!("".is_empty(), b!());
+
+    debug_assert_eq!("a".len(), 1);
+    debug_assert_eq!("a".is_empty(), false);
+    debug_assert_eq!("".is_empty(), true);
+    debug_assert_eq!(true, "".is_empty());
+    debug_assert_eq!(a!(), b!());
+    debug_assert_eq!(a!(), "".is_empty());
+    debug_assert_eq!("".is_empty(), b!());
+
+    debug_assert_ne!("a".len(), 1);
+    debug_assert_ne!("a".is_empty(), false);
+    debug_assert_ne!("".is_empty(), true);
+    debug_assert_ne!(true, "".is_empty());
+    debug_assert_ne!(a!(), b!());
+    debug_assert_ne!(a!(), "".is_empty());
+    debug_assert_ne!("".is_empty(), b!());
+
+    // assert with error messages
+    assert_eq!("a".len(), 1, "tadam {}", 1);
+    assert_eq!("a".len(), 1, "tadam {}", true);
+    assert_eq!("a".is_empty(), false, "tadam {}", 1);
+    assert_eq!("a".is_empty(), false, "tadam {}", true);
+    assert_eq!(false, "a".is_empty(), "tadam {}", true);
+
+    debug_assert_eq!("a".len(), 1, "tadam {}", 1);
+    debug_assert_eq!("a".len(), 1, "tadam {}", true);
+    debug_assert_eq!("a".is_empty(), false, "tadam {}", 1);
+    debug_assert_eq!("a".is_empty(), false, "tadam {}", true);
+    debug_assert_eq!(false, "a".is_empty(), "tadam {}", true);
+}
diff --git a/tests/ui/bool_assert_comparison.stderr b/tests/ui/bool_assert_comparison.stderr
new file mode 100644
index 00000000000..f57acf520d5
--- /dev/null
+++ b/tests/ui/bool_assert_comparison.stderr
@@ -0,0 +1,112 @@
+error: used `assert_eq!` with a literal bool
+  --> $DIR/bool_assert_comparison.rs:16:5
+   |
+LL |     assert_eq!("a".is_empty(), false);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `assert!(..)`
+   |
+   = note: `-D clippy::bool-assert-comparison` implied by `-D warnings`
+
+error: used `assert_eq!` with a literal bool
+  --> $DIR/bool_assert_comparison.rs:17:5
+   |
+LL |     assert_eq!("".is_empty(), true);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `assert!(..)`
+
+error: used `assert_eq!` with a literal bool
+  --> $DIR/bool_assert_comparison.rs:18:5
+   |
+LL |     assert_eq!(true, "".is_empty());
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `assert!(..)`
+
+error: used `assert_ne!` with a literal bool
+  --> $DIR/bool_assert_comparison.rs:24:5
+   |
+LL |     assert_ne!("a".is_empty(), false);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `assert!(..)`
+
+error: used `assert_ne!` with a literal bool
+  --> $DIR/bool_assert_comparison.rs:25:5
+   |
+LL |     assert_ne!("".is_empty(), true);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `assert!(..)`
+
+error: used `assert_ne!` with a literal bool
+  --> $DIR/bool_assert_comparison.rs:26:5
+   |
+LL |     assert_ne!(true, "".is_empty());
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `assert!(..)`
+
+error: used `debug_assert_eq!` with a literal bool
+  --> $DIR/bool_assert_comparison.rs:32:5
+   |
+LL |     debug_assert_eq!("a".is_empty(), false);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `debug_assert!(..)`
+
+error: used `debug_assert_eq!` with a literal bool
+  --> $DIR/bool_assert_comparison.rs:33:5
+   |
+LL |     debug_assert_eq!("".is_empty(), true);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `debug_assert!(..)`
+
+error: used `debug_assert_eq!` with a literal bool
+  --> $DIR/bool_assert_comparison.rs:34:5
+   |
+LL |     debug_assert_eq!(true, "".is_empty());
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `debug_assert!(..)`
+
+error: used `debug_assert_ne!` with a literal bool
+  --> $DIR/bool_assert_comparison.rs:40:5
+   |
+LL |     debug_assert_ne!("a".is_empty(), false);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `debug_assert!(..)`
+
+error: used `debug_assert_ne!` with a literal bool
+  --> $DIR/bool_assert_comparison.rs:41:5
+   |
+LL |     debug_assert_ne!("".is_empty(), true);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `debug_assert!(..)`
+
+error: used `debug_assert_ne!` with a literal bool
+  --> $DIR/bool_assert_comparison.rs:42:5
+   |
+LL |     debug_assert_ne!(true, "".is_empty());
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `debug_assert!(..)`
+
+error: used `assert_eq!` with a literal bool
+  --> $DIR/bool_assert_comparison.rs:50:5
+   |
+LL |     assert_eq!("a".is_empty(), false, "tadam {}", 1);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `assert!(..)`
+
+error: used `assert_eq!` with a literal bool
+  --> $DIR/bool_assert_comparison.rs:51:5
+   |
+LL |     assert_eq!("a".is_empty(), false, "tadam {}", true);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `assert!(..)`
+
+error: used `assert_eq!` with a literal bool
+  --> $DIR/bool_assert_comparison.rs:52:5
+   |
+LL |     assert_eq!(false, "a".is_empty(), "tadam {}", true);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `assert!(..)`
+
+error: used `debug_assert_eq!` with a literal bool
+  --> $DIR/bool_assert_comparison.rs:56:5
+   |
+LL |     debug_assert_eq!("a".is_empty(), false, "tadam {}", 1);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `debug_assert!(..)`
+
+error: used `debug_assert_eq!` with a literal bool
+  --> $DIR/bool_assert_comparison.rs:57:5
+   |
+LL |     debug_assert_eq!("a".is_empty(), false, "tadam {}", true);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `debug_assert!(..)`
+
+error: used `debug_assert_eq!` with a literal bool
+  --> $DIR/bool_assert_comparison.rs:58:5
+   |
+LL |     debug_assert_eq!(false, "a".is_empty(), "tadam {}", true);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `debug_assert!(..)`
+
+error: aborting due to 18 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 6eae905808fe830a731ed37e3f4a6264ae98e129 Mon Sep 17 00:00:00 2001
From: Yawara ISHIDA <ni732h.sphl@gmail.com>
Date: Tue, 20 Apr 2021 13:33:39 +0900
Subject: Add a test for FP in macro expansion

---
 clippy_lints/src/inconsistent_struct_constructor.rs |  3 ++-
 tests/ui/inconsistent_struct_constructor.fixed      | 13 +++++++++++++
 tests/ui/inconsistent_struct_constructor.rs         | 13 +++++++++++++
 tests/ui/inconsistent_struct_constructor.stderr     |  4 ++--
 4 files changed, 30 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/inconsistent_struct_constructor.rs b/clippy_lints/src/inconsistent_struct_constructor.rs
index 7532f182360..d138c3a8acf 100644
--- a/clippy_lints/src/inconsistent_struct_constructor.rs
+++ b/clippy_lints/src/inconsistent_struct_constructor.rs
@@ -1,4 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::in_macro;
 use clippy_utils::source::snippet;
 use if_chain::if_chain;
 use rustc_data_structures::fx::FxHashMap;
@@ -66,7 +67,7 @@ declare_lint_pass!(InconsistentStructConstructor => [INCONSISTENT_STRUCT_CONSTRU
 impl LateLintPass<'_> for InconsistentStructConstructor {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
         if_chain! {
-            if !expr.span.from_expansion();
+            if !in_macro(expr.span);
             if let ExprKind::Struct(qpath, fields, base) = expr.kind;
             let ty = cx.typeck_results().expr_ty(expr);
             if let Some(adt_def) = ty.ty_adt_def();
diff --git a/tests/ui/inconsistent_struct_constructor.fixed b/tests/ui/inconsistent_struct_constructor.fixed
index 8d9c3110035..d1025743790 100644
--- a/tests/ui/inconsistent_struct_constructor.fixed
+++ b/tests/ui/inconsistent_struct_constructor.fixed
@@ -13,6 +13,15 @@ struct Foo {
     z: i32,
 }
 
+macro_rules! new_foo {
+    () => {
+        let x = 1;
+        let y = 1;
+        let z = 1;
+        Foo { y, x, z }
+    };
+}
+
 mod without_base {
     use super::Foo;
 
@@ -24,6 +33,10 @@ mod without_base {
         // Should lint.
         Foo { x, y, z };
 
+        // Should NOT lint.
+        // issue #7069.
+        new_foo!();
+
         // Shoule NOT lint because the order is the same as in the definition.
         Foo { x, y, z };
 
diff --git a/tests/ui/inconsistent_struct_constructor.rs b/tests/ui/inconsistent_struct_constructor.rs
index 63fac910501..b095aa64a21 100644
--- a/tests/ui/inconsistent_struct_constructor.rs
+++ b/tests/ui/inconsistent_struct_constructor.rs
@@ -13,6 +13,15 @@ struct Foo {
     z: i32,
 }
 
+macro_rules! new_foo {
+    () => {
+        let x = 1;
+        let y = 1;
+        let z = 1;
+        Foo { y, x, z }
+    };
+}
+
 mod without_base {
     use super::Foo;
 
@@ -24,6 +33,10 @@ mod without_base {
         // Should lint.
         Foo { y, x, z };
 
+        // Should NOT lint.
+        // issue #7069.
+        new_foo!();
+
         // Shoule NOT lint because the order is the same as in the definition.
         Foo { x, y, z };
 
diff --git a/tests/ui/inconsistent_struct_constructor.stderr b/tests/ui/inconsistent_struct_constructor.stderr
index d021bb19579..ef308dedb16 100644
--- a/tests/ui/inconsistent_struct_constructor.stderr
+++ b/tests/ui/inconsistent_struct_constructor.stderr
@@ -1,5 +1,5 @@
 error: struct constructor field order is inconsistent with struct definition field order
-  --> $DIR/inconsistent_struct_constructor.rs:25:9
+  --> $DIR/inconsistent_struct_constructor.rs:34:9
    |
 LL |         Foo { y, x, z };
    |         ^^^^^^^^^^^^^^^ help: try: `Foo { x, y, z }`
@@ -7,7 +7,7 @@ LL |         Foo { y, x, z };
    = note: `-D clippy::inconsistent-struct-constructor` implied by `-D warnings`
 
 error: struct constructor field order is inconsistent with struct definition field order
-  --> $DIR/inconsistent_struct_constructor.rs:43:9
+  --> $DIR/inconsistent_struct_constructor.rs:56:9
    |
 LL | /         Foo {
 LL | |             z,
-- 
cgit 1.4.1-3-g733a5


From 224881b94df5215952c7a955acaefacb388c50c5 Mon Sep 17 00:00:00 2001
From: Elliot Bobrow <elliotgreybobrow@gmail.com>
Date: Mon, 12 Apr 2021 18:24:47 -0700
Subject: add unnecessary_self_imports lint

---
 CHANGELOG.md                                 |  1 +
 clippy_lints/src/lib.rs                      |  4 ++
 clippy_lints/src/modulo_arithmetic.rs        |  2 +-
 clippy_lints/src/unnecessary_self_imports.rs | 67 ++++++++++++++++++++++++++++
 tests/ui/unnecessary_self_imports.fixed      | 10 +++++
 tests/ui/unnecessary_self_imports.rs         | 10 +++++
 tests/ui/unnecessary_self_imports.stderr     | 23 ++++++++++
 7 files changed, 116 insertions(+), 1 deletion(-)
 create mode 100644 clippy_lints/src/unnecessary_self_imports.rs
 create mode 100644 tests/ui/unnecessary_self_imports.fixed
 create mode 100644 tests/ui/unnecessary_self_imports.rs
 create mode 100644 tests/ui/unnecessary_self_imports.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 7885bdfb12c..d9a198f8243 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2519,6 +2519,7 @@ Released 2018-09-13
 [`unnecessary_lazy_evaluations`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_lazy_evaluations
 [`unnecessary_mut_passed`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_mut_passed
 [`unnecessary_operation`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_operation
+[`unnecessary_self_imports`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_self_imports
 [`unnecessary_sort_by`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_sort_by
 [`unnecessary_unwrap`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_unwrap
 [`unnecessary_wraps`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_wraps
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 78a95b00403..7e12e9be4aa 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -356,6 +356,7 @@ mod unicode;
 mod unit_return_expecting_ord;
 mod unit_types;
 mod unnamed_address;
+mod unnecessary_self_imports;
 mod unnecessary_sort_by;
 mod unnecessary_wraps;
 mod unnested_or_patterns;
@@ -963,6 +964,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         unit_types::UNIT_CMP,
         unnamed_address::FN_ADDRESS_COMPARISONS,
         unnamed_address::VTABLE_ADDRESS_COMPARISONS,
+        unnecessary_self_imports::UNNECESSARY_SELF_IMPORTS,
         unnecessary_sort_by::UNNECESSARY_SORT_BY,
         unnecessary_wraps::UNNECESSARY_WRAPS,
         unnested_or_patterns::UNNESTED_OR_PATTERNS,
@@ -1048,6 +1050,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box default_numeric_fallback::DefaultNumericFallback);
     store.register_late_pass(|| box inconsistent_struct_constructor::InconsistentStructConstructor);
     store.register_late_pass(|| box non_octal_unix_permissions::NonOctalUnixPermissions);
+    store.register_early_pass(|| box unnecessary_self_imports::UnnecessarySelfImports);
 
     let msrv = conf.msrv.as_ref().and_then(|s| {
         parse_msrv(s, None, None).or_else(|| {
@@ -1320,6 +1323,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(strings::STRING_TO_STRING),
         LintId::of(strings::STR_TO_STRING),
         LintId::of(types::RC_BUFFER),
+        LintId::of(unnecessary_self_imports::UNNECESSARY_SELF_IMPORTS),
         LintId::of(unwrap_in_result::UNWRAP_IN_RESULT),
         LintId::of(verbose_file_reads::VERBOSE_FILE_READS),
         LintId::of(write::PRINT_STDERR),
diff --git a/clippy_lints/src/modulo_arithmetic.rs b/clippy_lints/src/modulo_arithmetic.rs
index 6a52de4f713..64e9dc85466 100644
--- a/clippy_lints/src/modulo_arithmetic.rs
+++ b/clippy_lints/src/modulo_arithmetic.rs
@@ -4,7 +4,7 @@ use clippy_utils::sext;
 use if_chain::if_chain;
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty::{self};
+use rustc_middle::ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use std::fmt::Display;
 
diff --git a/clippy_lints/src/unnecessary_self_imports.rs b/clippy_lints/src/unnecessary_self_imports.rs
new file mode 100644
index 00000000000..48c54d79cf1
--- /dev/null
+++ b/clippy_lints/src/unnecessary_self_imports.rs
@@ -0,0 +1,67 @@
+use clippy_utils::diagnostics::span_lint_and_then;
+use if_chain::if_chain;
+use rustc_ast::{Item, ItemKind, UseTreeKind};
+use rustc_errors::Applicability;
+use rustc_lint::{EarlyContext, EarlyLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::symbol::kw;
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for imports ending in `::{self}`.
+    ///
+    /// **Why is this bad?** In most cases, this can be written much more cleanly by omitting `::{self}`.
+    ///
+    /// **Known problems:** Removing `::{self}` will cause any non-module items at the same path to also be imported.
+    /// This might cause a naming conflict (https://github.com/rust-lang/rustfmt/issues/3568). This lint makes no attempt
+    /// to detect this scenario and that is why it is a restriction lint.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// use std::io::{self};
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// use std::io;
+    /// ```
+    pub UNNECESSARY_SELF_IMPORTS,
+    restriction,
+    "imports ending in `::{self}`, which can be omitted"
+}
+
+declare_lint_pass!(UnnecessarySelfImports => [UNNECESSARY_SELF_IMPORTS]);
+
+impl EarlyLintPass for UnnecessarySelfImports {
+    fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {
+        if_chain! {
+            if let ItemKind::Use(use_tree) = &item.kind;
+            if let UseTreeKind::Nested(nodes) = &use_tree.kind;
+            if let [(self_tree, _)] = &**nodes;
+            if let [self_seg] = &*self_tree.prefix.segments;
+            if self_seg.ident.name == kw::SelfLower;
+            if let Some(last_segment) = use_tree.prefix.segments.last();
+
+            then {
+                span_lint_and_then(
+                    cx,
+                    UNNECESSARY_SELF_IMPORTS,
+                    item.span,
+                    "import ending with `::{self}`",
+                    |diag| {
+                        diag.span_suggestion(
+                            last_segment.span().with_hi(item.span.hi()),
+                            "consider omitting `::{self}`",
+                            format!(
+                                "{}{};",
+                                last_segment.ident,
+                                if let UseTreeKind::Simple(Some(alias), ..) = self_tree.kind { format!(" as {}", alias) } else { String::new() },
+                            ),
+                            Applicability::MaybeIncorrect,
+                        );
+                        diag.note("this will slightly change semantics; any non-module items at the same path will also be imported");
+                    },
+                );
+            }
+        }
+    }
+}
diff --git a/tests/ui/unnecessary_self_imports.fixed b/tests/ui/unnecessary_self_imports.fixed
new file mode 100644
index 00000000000..1185eaa1d55
--- /dev/null
+++ b/tests/ui/unnecessary_self_imports.fixed
@@ -0,0 +1,10 @@
+// run-rustfix
+#![warn(clippy::unnecessary_self_imports)]
+#![allow(unused_imports, dead_code)]
+
+use std::collections::hash_map::{self, *};
+use std::fs as alias;
+use std::io::{self, Read};
+use std::rc;
+
+fn main() {}
diff --git a/tests/ui/unnecessary_self_imports.rs b/tests/ui/unnecessary_self_imports.rs
new file mode 100644
index 00000000000..56bfbc09402
--- /dev/null
+++ b/tests/ui/unnecessary_self_imports.rs
@@ -0,0 +1,10 @@
+// run-rustfix
+#![warn(clippy::unnecessary_self_imports)]
+#![allow(unused_imports, dead_code)]
+
+use std::collections::hash_map::{self, *};
+use std::fs::{self as alias};
+use std::io::{self, Read};
+use std::rc::{self};
+
+fn main() {}
diff --git a/tests/ui/unnecessary_self_imports.stderr b/tests/ui/unnecessary_self_imports.stderr
new file mode 100644
index 00000000000..83a5618c983
--- /dev/null
+++ b/tests/ui/unnecessary_self_imports.stderr
@@ -0,0 +1,23 @@
+error: import ending with `::{self}`
+  --> $DIR/unnecessary_self_imports.rs:6:1
+   |
+LL | use std::fs::{self as alias};
+   | ^^^^^^^^^--------------------
+   |          |
+   |          help: consider omitting `::{self}`: `fs as alias;`
+   |
+   = note: `-D clippy::unnecessary-self-imports` implied by `-D warnings`
+   = note: this will slightly change semantics; any non-module items at the same path will also be imported
+
+error: import ending with `::{self}`
+  --> $DIR/unnecessary_self_imports.rs:8:1
+   |
+LL | use std::rc::{self};
+   | ^^^^^^^^^-----------
+   |          |
+   |          help: consider omitting `::{self}`: `rc;`
+   |
+   = note: this will slightly change semantics; any non-module items at the same path will also be imported
+
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 65778fa5e886c641422501e68ec7ffbe690abafc Mon Sep 17 00:00:00 2001
From: Takayuki <takoyaki0316@gmail.com>
Date: Thu, 22 Apr 2021 16:52:34 +0900
Subject: fix a false-positive inside const fn in comparison_chain

---
 clippy_lints/src/comparison_chain.rs | 14 +++++++++++++-
 tests/ui/comparison_chain.rs         | 28 ++++++++++++++++++++++++++++
 2 files changed, 41 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/comparison_chain.rs b/clippy_lints/src/comparison_chain.rs
index 42e153909ce..150d8a3d673 100644
--- a/clippy_lints/src/comparison_chain.rs
+++ b/clippy_lints/src/comparison_chain.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::ty::implements_trait;
 use clippy_utils::{get_trait_def_id, if_sequence, is_else_clause, paths, SpanlessEq};
-use rustc_hir::{BinOpKind, Expr, ExprKind};
+use rustc_hir::{BinOpKind, Expr, ExprKind, Node};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
@@ -64,6 +64,10 @@ impl<'tcx> LateLintPass<'tcx> for ComparisonChain {
             return;
         }
 
+        if parent_node_is_if_const_fn(cx, expr) {
+            return;
+        }
+
         // Check that there exists at least one explicit else condition
         let (conds, _) = if_sequence(expr);
         if conds.len() < 2 {
@@ -123,3 +127,11 @@ impl<'tcx> LateLintPass<'tcx> for ComparisonChain {
 fn kind_is_cmp(kind: BinOpKind) -> bool {
     matches!(kind, BinOpKind::Lt | BinOpKind::Gt | BinOpKind::Eq)
 }
+
+fn parent_node_is_if_const_fn(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+    match cx.tcx.hir().find(cx.tcx.hir().get_parent_item(expr.hir_id)) {
+        Some(Node::Item(item)) => rustc_mir::const_eval::is_const_fn(cx.tcx, item.def_id.to_def_id()),
+        Some(Node::ImplItem(impl_item)) => rustc_mir::const_eval::is_const_fn(cx.tcx, impl_item.def_id.to_def_id()),
+        _ => false,
+    }
+}
diff --git a/tests/ui/comparison_chain.rs b/tests/ui/comparison_chain.rs
index 3b03f8c7dfe..c12c6a31027 100644
--- a/tests/ui/comparison_chain.rs
+++ b/tests/ui/comparison_chain.rs
@@ -203,4 +203,32 @@ mod issue_5212 {
     }
 }
 
+enum Sign {
+    Negative,
+    Positive,
+    Zero,
+}
+
+impl Sign {
+    const fn sign_i8(n: i8) -> Self {
+        if n == 0 {
+            Sign::Zero
+        } else if n > 0 {
+            Sign::Positive
+        } else {
+            Sign::Negative
+        }
+    }
+}
+
+const fn sign_i8(n: i8) -> Sign {
+    if n == 0 {
+        Sign::Zero
+    } else if n > 0 {
+        Sign::Positive
+    } else {
+        Sign::Negative
+    }
+}
+
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From b48699e4cfd8af15669227049f3c6056d4084aba Mon Sep 17 00:00:00 2001
From: cherryblossom <31467609+cherryblossom000@users.noreply.github.com>
Date: Thu, 22 Apr 2021 19:34:36 +1000
Subject: `single_component_path_imports`: ignore `pub(crate) use some_macro;`
 (fixes #7106)

---
 clippy_lints/src/single_component_path_imports.rs  | 36 ++++++++++++++++++----
 tests/ui/single_component_path_imports_macro.fixed | 21 +++++++++++++
 tests/ui/single_component_path_imports_macro.rs    | 21 +++++++++++++
 .../ui/single_component_path_imports_macro.stderr  | 10 ++++++
 4 files changed, 82 insertions(+), 6 deletions(-)
 create mode 100644 tests/ui/single_component_path_imports_macro.fixed
 create mode 100644 tests/ui/single_component_path_imports_macro.rs
 create mode 100644 tests/ui/single_component_path_imports_macro.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/single_component_path_imports.rs b/clippy_lints/src/single_component_path_imports.rs
index 6104103580e..a45bb102389 100644
--- a/clippy_lints/src/single_component_path_imports.rs
+++ b/clippy_lints/src/single_component_path_imports.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg};
 use clippy_utils::in_macro;
-use rustc_ast::{ptr::P, Crate, Item, ItemKind, ModKind, UseTreeKind};
+use rustc_ast::{ptr::P, Crate, Item, ItemKind, MacroDef, ModKind, UseTreeKind, VisibilityKind};
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -60,8 +60,21 @@ fn check_mod(cx: &EarlyContext<'_>, items: &[P<Item>]) {
     // ```
     let mut single_use_usages = Vec::new();
 
+    // keep track of macros defined in the module as we don't want it to trigger on this (#7106)
+    // ```rust,ignore
+    // macro_rules! foo { () => {} };
+    // pub(crate) use foo;
+    // ```
+    let mut macros = Vec::new();
+
     for item in items {
-        track_uses(cx, &item, &mut imports_reused_with_self, &mut single_use_usages);
+        track_uses(
+            cx,
+            &item,
+            &mut imports_reused_with_self,
+            &mut single_use_usages,
+            &mut macros,
+        );
     }
 
     for single_use in &single_use_usages {
@@ -96,6 +109,7 @@ fn track_uses(
     item: &Item,
     imports_reused_with_self: &mut Vec<Symbol>,
     single_use_usages: &mut Vec<(Symbol, Span, bool)>,
+    macros: &mut Vec<Symbol>,
 ) {
     if in_macro(item.span) || item.vis.kind.is_pub() {
         return;
@@ -105,14 +119,22 @@ fn track_uses(
         ItemKind::Mod(_, ModKind::Loaded(ref items, ..)) => {
             check_mod(cx, &items);
         },
+        ItemKind::MacroDef(MacroDef { macro_rules: true, .. }) => {
+            macros.push(item.ident.name);
+        },
         ItemKind::Use(use_tree) => {
             let segments = &use_tree.prefix.segments;
 
+            let should_report =
+                |name: &Symbol| !macros.contains(name) || matches!(item.vis.kind, VisibilityKind::Inherited);
+
             // keep track of `use some_module;` usages
             if segments.len() == 1 {
                 if let UseTreeKind::Simple(None, _, _) = use_tree.kind {
-                    let ident = &segments[0].ident;
-                    single_use_usages.push((ident.name, item.span, true));
+                    let name = segments[0].ident.name;
+                    if should_report(&name) {
+                        single_use_usages.push((name, item.span, true));
+                    }
                 }
                 return;
             }
@@ -124,8 +146,10 @@ fn track_uses(
                         let segments = &tree.0.prefix.segments;
                         if segments.len() == 1 {
                             if let UseTreeKind::Simple(None, _, _) = tree.0.kind {
-                                let ident = &segments[0].ident;
-                                single_use_usages.push((ident.name, tree.0.span, false));
+                                let name = segments[0].ident.name;
+                                if should_report(&name) {
+                                    single_use_usages.push((name, tree.0.span, false));
+                                }
                             }
                         }
                     }
diff --git a/tests/ui/single_component_path_imports_macro.fixed b/tests/ui/single_component_path_imports_macro.fixed
new file mode 100644
index 00000000000..05863f9a2bf
--- /dev/null
+++ b/tests/ui/single_component_path_imports_macro.fixed
@@ -0,0 +1,21 @@
+// run-rustfix
+// edition:2018
+#![warn(clippy::single_component_path_imports)]
+#![allow(unused_imports)]
+
+// #7106: use statements exporting a macro within a crate should not trigger lint
+
+macro_rules! m1 {
+    () => {};
+}
+pub(crate) use m1; // ok
+
+macro_rules! m2 {
+    () => {};
+}
+ // fail
+
+fn main() {
+    m1!();
+    m2!();
+}
diff --git a/tests/ui/single_component_path_imports_macro.rs b/tests/ui/single_component_path_imports_macro.rs
new file mode 100644
index 00000000000..633deea348b
--- /dev/null
+++ b/tests/ui/single_component_path_imports_macro.rs
@@ -0,0 +1,21 @@
+// run-rustfix
+// edition:2018
+#![warn(clippy::single_component_path_imports)]
+#![allow(unused_imports)]
+
+// #7106: use statements exporting a macro within a crate should not trigger lint
+
+macro_rules! m1 {
+    () => {};
+}
+pub(crate) use m1; // ok
+
+macro_rules! m2 {
+    () => {};
+}
+use m2; // fail
+
+fn main() {
+    m1!();
+    m2!();
+}
diff --git a/tests/ui/single_component_path_imports_macro.stderr b/tests/ui/single_component_path_imports_macro.stderr
new file mode 100644
index 00000000000..239efb393b1
--- /dev/null
+++ b/tests/ui/single_component_path_imports_macro.stderr
@@ -0,0 +1,10 @@
+error: this import is redundant
+  --> $DIR/single_component_path_imports_macro.rs:16:1
+   |
+LL | use m2; // fail
+   | ^^^^^^^ help: remove it entirely
+   |
+   = note: `-D clippy::single-component-path-imports` implied by `-D warnings`
+
+error: aborting due to previous error
+
-- 
cgit 1.4.1-3-g733a5


From 22f8c13cf5650d6c9d6ee7b4f0e88bffba9076ca Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Thu, 1 Apr 2021 22:46:10 -0400
Subject: Improve `implicit_return` Better suggestions when returning macro
 calls. Suggest changeing all the break expressions in a loop, not just the
 final statement. Don't lint divergent functions. Don't suggest returning the
 result of any divergent fuction.

---
 clippy_lints/src/implicit_return.rs | 241 ++++++++++++++++++++++++------------
 clippy_utils/src/source.rs          |  31 +++--
 clippy_utils/src/visitors.rs        |  55 +++++++-
 tests/ui/implicit_return.fixed      |  62 +++++++---
 tests/ui/implicit_return.rs         |  62 +++++++---
 tests/ui/implicit_return.stderr     |  55 ++++++--
 6 files changed, 366 insertions(+), 140 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/implicit_return.rs b/clippy_lints/src/implicit_return.rs
index 6b379b0d59b..251a7361871 100644
--- a/clippy_lints/src/implicit_return.rs
+++ b/clippy_lints/src/implicit_return.rs
@@ -1,13 +1,15 @@
-use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::match_panic_def_id;
-use clippy_utils::source::snippet_opt;
-use if_chain::if_chain;
+use clippy_utils::{
+    diagnostics::span_lint_and_sugg,
+    source::{snippet_with_applicability, snippet_with_context, walk_span_to_context},
+    visitors::visit_break_exprs,
+};
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::FnKind;
-use rustc_hir::{Body, Expr, ExprKind, FnDecl, HirId, MatchSource, StmtKind};
-use rustc_lint::{LateContext, LateLintPass};
+use rustc_hir::{Block, Body, Expr, ExprKind, FnDecl, FnRetTy, HirId};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::source_map::Span;
+use rustc_span::{Span, SyntaxContext};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for missing return statements at the end of a block.
@@ -39,89 +41,159 @@ declare_clippy_lint! {
 
 declare_lint_pass!(ImplicitReturn => [IMPLICIT_RETURN]);
 
-static LINT_BREAK: &str = "change `break` to `return` as shown";
-static LINT_RETURN: &str = "add `return` as shown";
-
-fn lint(cx: &LateContext<'_>, outer_span: Span, inner_span: Span, msg: &str) {
-    let outer_span = outer_span.source_callsite();
-    let inner_span = inner_span.source_callsite();
-
-    span_lint_and_then(cx, IMPLICIT_RETURN, outer_span, "missing `return` statement", |diag| {
-        if let Some(snippet) = snippet_opt(cx, inner_span) {
-            diag.span_suggestion(
-                outer_span,
-                msg,
-                format!("return {}", snippet),
-                Applicability::MachineApplicable,
-            );
-        }
-    });
+fn lint_return(cx: &LateContext<'_>, span: Span) {
+    let mut app = Applicability::MachineApplicable;
+    let snip = snippet_with_applicability(cx, span, "..", &mut app);
+    span_lint_and_sugg(
+        cx,
+        IMPLICIT_RETURN,
+        span,
+        "missing `return` statement",
+        "add `return` as shown",
+        format!("return {}", snip),
+        app,
+    );
+}
+
+fn lint_break(cx: &LateContext<'_>, break_span: Span, expr_span: Span) {
+    let mut app = Applicability::MachineApplicable;
+    let snip = snippet_with_context(cx, expr_span, break_span.ctxt(), "..", &mut app).0;
+    span_lint_and_sugg(
+        cx,
+        IMPLICIT_RETURN,
+        break_span,
+        "missing `return` statement",
+        "change `break` to `return` as shown",
+        format!("return {}", snip),
+        app,
+    )
+}
+
+enum LintLocation {
+    /// The lint was applied to a parent expression.
+    Parent,
+    /// The lint was applied to this expression, a child, or not applied.
+    Inner,
 }
+impl LintLocation {
+    fn still_parent(self, b: bool) -> Self {
+        if b { self } else { Self::Inner }
+    }
 
-fn expr_match(cx: &LateContext<'_>, expr: &Expr<'_>) {
+    fn is_parent(&self) -> bool {
+        matches!(*self, Self::Parent)
+    }
+}
+
+// Gets the call site if the span is in a child context. Otherwise returns `None`.
+fn get_call_site(span: Span, ctxt: SyntaxContext) -> Option<Span> {
+    (span.ctxt() != ctxt).then(|| walk_span_to_context(span, ctxt).unwrap_or(span))
+}
+
+fn lint_implicit_returns(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx Expr<'_>,
+    // The context of the function body.
+    ctxt: SyntaxContext,
+    // Whether the expression is from a macro expansion.
+    call_site_span: Option<Span>,
+) -> LintLocation {
     match expr.kind {
-        // loops could be using `break` instead of `return`
-        ExprKind::Block(block, ..) | ExprKind::Loop(block, ..) => {
-            if let Some(expr) = &block.expr {
-                expr_match(cx, expr);
-            }
-            // only needed in the case of `break` with `;` at the end
-            else if let Some(stmt) = block.stmts.last() {
-                if_chain! {
-                    if let StmtKind::Semi(expr, ..) = &stmt.kind;
-                    // make sure it's a break, otherwise we want to skip
-                    if let ExprKind::Break(.., Some(break_expr)) = &expr.kind;
-                    then {
-                            lint(cx, expr.span, break_expr.span, LINT_BREAK);
-                    }
-                }
-            }
-        },
-        // use `return` instead of `break`
-        ExprKind::Break(.., break_expr) => {
-            if let Some(break_expr) = break_expr {
-                lint(cx, expr.span, break_expr.span, LINT_BREAK);
+        ExprKind::Block(
+            Block {
+                expr: Some(block_expr), ..
+            },
+            _,
+        ) => lint_implicit_returns(
+            cx,
+            block_expr,
+            ctxt,
+            call_site_span.or_else(|| get_call_site(block_expr.span, ctxt)),
+        )
+        .still_parent(call_site_span.is_some()),
+
+        ExprKind::If(_, then_expr, Some(else_expr)) => {
+            // Both `then_expr` or `else_expr` are required to be blocks in the same context as the `if`. Don't
+            // bother checking.
+            let res = lint_implicit_returns(cx, then_expr, ctxt, call_site_span).still_parent(call_site_span.is_some());
+            if res.is_parent() {
+                // The return was added as a parent of this if expression.
+                return res;
             }
+            lint_implicit_returns(cx, else_expr, ctxt, call_site_span).still_parent(call_site_span.is_some())
         },
-        ExprKind::If(.., if_expr, else_expr) => {
-            expr_match(cx, if_expr);
 
-            if let Some(else_expr) = else_expr {
-                expr_match(cx, else_expr);
+        ExprKind::Match(_, arms, _) => {
+            for arm in arms {
+                let res = lint_implicit_returns(
+                    cx,
+                    arm.body,
+                    ctxt,
+                    call_site_span.or_else(|| get_call_site(arm.body.span, ctxt)),
+                )
+                .still_parent(call_site_span.is_some());
+                if res.is_parent() {
+                    // The return was added as a parent of this match expression.
+                    return res;
+                }
             }
+            LintLocation::Inner
         },
-        ExprKind::Match(.., arms, source) => {
-            let check_all_arms = match source {
-                MatchSource::IfLetDesugar {
-                    contains_else_clause: has_else,
-                } => has_else,
-                _ => true,
-            };
-
-            if check_all_arms {
-                for arm in arms {
-                    expr_match(cx, arm.body);
+
+        ExprKind::Loop(block, ..) => {
+            let mut add_return = false;
+            visit_break_exprs(block, |break_expr, dest, sub_expr| {
+                if dest.target_id.ok() == Some(expr.hir_id) {
+                    if call_site_span.is_none() && break_expr.span.ctxt() == ctxt {
+                        lint_break(cx, break_expr.span, sub_expr.unwrap().span);
+                    } else {
+                        // the break expression is from a macro call, add a return to the loop
+                        add_return = true;
+                    }
+                }
+            });
+            if add_return {
+                #[allow(clippy::option_if_let_else)]
+                if let Some(span) = call_site_span {
+                    lint_return(cx, span);
+                    LintLocation::Parent
+                } else {
+                    lint_return(cx, expr.span);
+                    LintLocation::Inner
                 }
             } else {
-                expr_match(cx, arms.first().expect("`if let` doesn't have a single arm").body);
+                LintLocation::Inner
             }
         },
-        // skip if it already has a return statement
-        ExprKind::Ret(..) => (),
-        // make sure it's not a call that panics
-        ExprKind::Call(expr, ..) => {
-            if_chain! {
-                if let ExprKind::Path(qpath) = &expr.kind;
-                if let Some(path_def_id) = cx.qpath_res(qpath, expr.hir_id).opt_def_id();
-                if match_panic_def_id(cx, path_def_id);
-                then { }
-                else {
-                    lint(cx, expr.span, expr.span, LINT_RETURN)
-                }
+
+        // If expressions without an else clause, and blocks without a final expression can only be the final expression
+        // if they are divergent, or return the unit type.
+        ExprKind::If(_, _, None) | ExprKind::Block(Block { expr: None, .. }, _) | ExprKind::Ret(_) => {
+            LintLocation::Inner
+        },
+
+        // Any divergent expression doesn't need a return statement.
+        ExprKind::MethodCall(..)
+        | ExprKind::Call(..)
+        | ExprKind::Binary(..)
+        | ExprKind::Unary(..)
+        | ExprKind::Index(..)
+            if cx.typeck_results().expr_ty(expr).is_never() =>
+        {
+            LintLocation::Inner
+        },
+
+        _ =>
+        {
+            #[allow(clippy::option_if_let_else)]
+            if let Some(span) = call_site_span {
+                lint_return(cx, span);
+                LintLocation::Parent
+            } else {
+                lint_return(cx, expr.span);
+                LintLocation::Inner
             }
         },
-        // everything else is missing `return`
-        _ => lint(cx, expr.span, expr.span, LINT_RETURN),
     }
 }
 
@@ -129,19 +201,24 @@ impl<'tcx> LateLintPass<'tcx> for ImplicitReturn {
     fn check_fn(
         &mut self,
         cx: &LateContext<'tcx>,
-        _: FnKind<'tcx>,
-        _: &'tcx FnDecl<'_>,
+        kind: FnKind<'tcx>,
+        decl: &'tcx FnDecl<'_>,
         body: &'tcx Body<'_>,
         span: Span,
         _: HirId,
     ) {
-        if span.from_expansion() {
+        if (!matches!(kind, FnKind::Closure) && matches!(decl.output, FnRetTy::DefaultReturn(_)))
+            || span.ctxt() != body.value.span.ctxt()
+            || in_external_macro(cx.sess(), span)
+        {
             return;
         }
-        let body = cx.tcx.hir().body(body.id());
-        if cx.typeck_results().expr_ty(&body.value).is_unit() {
+
+        let res_ty = cx.typeck_results().expr_ty(&body.value);
+        if res_ty.is_unit() || res_ty.is_never() {
             return;
         }
-        expr_match(cx, &body.value);
+
+        lint_implicit_returns(cx, &body.value, body.value.span.ctxt(), None);
     }
 }
diff --git a/clippy_utils/src/source.rs b/clippy_utils/src/source.rs
index 53180d1f9f5..2e731c182ec 100644
--- a/clippy_utils/src/source.rs
+++ b/clippy_utils/src/source.rs
@@ -280,17 +280,17 @@ pub fn snippet_with_context(
     default: &'a str,
     applicability: &mut Applicability,
 ) -> (Cow<'a, str>, bool) {
-    let outer_span = hygiene::walk_chain(span, outer);
-    let (span, is_macro_call) = if outer_span.ctxt() == outer {
-        (outer_span, span.ctxt() != outer)
-    } else {
-        // The span is from a macro argument, and the outer context is the macro using the argument
-        if *applicability != Applicability::Unspecified {
-            *applicability = Applicability::MaybeIncorrect;
-        }
-        // TODO: get the argument span.
-        (span, false)
-    };
+    let (span, is_macro_call) = walk_span_to_context(span, outer).map_or_else(
+        || {
+            // The span is from a macro argument, and the outer context is the macro using the argument
+            if *applicability != Applicability::Unspecified {
+                *applicability = Applicability::MaybeIncorrect;
+            }
+            // TODO: get the argument span.
+            (span, false)
+        },
+        |outer_span| (outer_span, span.ctxt() != outer),
+    );
 
     (
         snippet_with_applicability(cx, span, default, applicability),
@@ -298,6 +298,15 @@ pub fn snippet_with_context(
     )
 }
 
+/// Walks the span up to the target context, thereby returning the macro call site if the span is
+/// inside a macro expansion, or the original span if it is not. Note this will return `None` in the
+/// case of the span being in a macro expansion, but the target context is from expanding a macro
+/// argument.
+pub fn walk_span_to_context(span: Span, outer: SyntaxContext) -> Option<Span> {
+    let outer_span = hygiene::walk_chain(span, outer);
+    (outer_span.ctxt() == outer).then(|| outer_span)
+}
+
 /// Removes block comments from the given `Vec` of lines.
 ///
 /// # Examples
diff --git a/clippy_utils/src/visitors.rs b/clippy_utils/src/visitors.rs
index 5a8c629e333..d431bdf34ee 100644
--- a/clippy_utils/src/visitors.rs
+++ b/clippy_utils/src/visitors.rs
@@ -1,7 +1,7 @@
 use crate::path_to_local_id;
 use rustc_hir as hir;
-use rustc_hir::intravisit::{self, walk_expr, NestedVisitorMap, Visitor};
-use rustc_hir::{Arm, Body, Expr, HirId, Stmt};
+use rustc_hir::intravisit::{self, walk_expr, ErasedMap, NestedVisitorMap, Visitor};
+use rustc_hir::{Arm, Block, Body, Destination, Expr, ExprKind, HirId, Stmt};
 use rustc_lint::LateContext;
 use rustc_middle::hir::map::Map;
 
@@ -188,3 +188,54 @@ impl<'v> Visitor<'v> for LocalUsedVisitor<'v> {
         NestedVisitorMap::OnlyBodies(self.hir)
     }
 }
+
+pub trait Visitable<'tcx> {
+    fn visit<V: Visitor<'tcx>>(self, v: &mut V);
+}
+impl Visitable<'tcx> for &'tcx Expr<'tcx> {
+    fn visit<V: Visitor<'tcx>>(self, v: &mut V) {
+        v.visit_expr(self)
+    }
+}
+impl Visitable<'tcx> for &'tcx Block<'tcx> {
+    fn visit<V: Visitor<'tcx>>(self, v: &mut V) {
+        v.visit_block(self)
+    }
+}
+impl<'tcx> Visitable<'tcx> for &'tcx Stmt<'tcx> {
+    fn visit<V: Visitor<'tcx>>(self, v: &mut V) {
+        v.visit_stmt(self)
+    }
+}
+impl<'tcx> Visitable<'tcx> for &'tcx Body<'tcx> {
+    fn visit<V: Visitor<'tcx>>(self, v: &mut V) {
+        v.visit_body(self)
+    }
+}
+impl<'tcx> Visitable<'tcx> for &'tcx Arm<'tcx> {
+    fn visit<V: Visitor<'tcx>>(self, v: &mut V) {
+        v.visit_arm(self)
+    }
+}
+
+pub fn visit_break_exprs<'tcx>(
+    node: impl Visitable<'tcx>,
+    f: impl FnMut(&'tcx Expr<'tcx>, Destination, Option<&'tcx Expr<'tcx>>),
+) {
+    struct V<F>(F);
+    impl<'tcx, F: FnMut(&'tcx Expr<'tcx>, Destination, Option<&'tcx Expr<'tcx>>)> Visitor<'tcx> for V<F> {
+        type Map = ErasedMap<'tcx>;
+        fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+            NestedVisitorMap::None
+        }
+
+        fn visit_expr(&mut self, e: &'tcx Expr<'_>) {
+            if let ExprKind::Break(dest, sub_expr) = e.kind {
+                self.0(e, dest, sub_expr)
+            }
+            walk_expr(self, e);
+        }
+    }
+
+    node.visit(&mut V(f));
+}
diff --git a/tests/ui/implicit_return.fixed b/tests/ui/implicit_return.fixed
index 59f7ad9c106..c0fc4b926a0 100644
--- a/tests/ui/implicit_return.fixed
+++ b/tests/ui/implicit_return.fixed
@@ -1,7 +1,7 @@
 // run-rustfix
 
 #![warn(clippy::implicit_return)]
-#![allow(clippy::needless_return, unused)]
+#![allow(clippy::needless_return, clippy::needless_bool, unused, clippy::never_loop)]
 
 fn test_end_of_fn() -> bool {
     if true {
@@ -12,7 +12,6 @@ fn test_end_of_fn() -> bool {
     return true
 }
 
-#[allow(clippy::needless_bool)]
 fn test_if_block() -> bool {
     if true { return true } else { return false }
 }
@@ -25,7 +24,6 @@ fn test_match(x: bool) -> bool {
     }
 }
 
-#[allow(clippy::needless_return)]
 fn test_match_with_unreachable(x: bool) -> bool {
     match x {
         true => return false,
@@ -33,14 +31,12 @@ fn test_match_with_unreachable(x: bool) -> bool {
     }
 }
 
-#[allow(clippy::never_loop)]
 fn test_loop() -> bool {
     loop {
         return true;
     }
 }
 
-#[allow(clippy::never_loop)]
 fn test_loop_with_block() -> bool {
     loop {
         {
@@ -49,7 +45,6 @@ fn test_loop_with_block() -> bool {
     }
 }
 
-#[allow(clippy::never_loop)]
 fn test_loop_with_nests() -> bool {
     loop {
         if true {
@@ -83,15 +78,48 @@ fn test_return_macro() -> String {
     return format!("test {}", "test")
 }
 
-fn main() {
-    let _ = test_end_of_fn();
-    let _ = test_if_block();
-    let _ = test_match(true);
-    let _ = test_match_with_unreachable(true);
-    let _ = test_loop();
-    let _ = test_loop_with_block();
-    let _ = test_loop_with_nests();
-    let _ = test_loop_with_if_let();
-    test_closure();
-    let _ = test_return_macro();
+fn macro_branch_test() -> bool {
+    macro_rules! m {
+        ($t:expr, $f:expr) => {
+            if true { $t } else { $f }
+        };
+    }
+    return m!(true, false)
+}
+
+fn loop_test() -> bool {
+    'outer: loop {
+        if true {
+            return true;
+        }
+
+        let _ = loop {
+            if false {
+                return false;
+            }
+            if true {
+                break true;
+            }
+        };
+    }
 }
+
+fn loop_macro_test() -> bool {
+    macro_rules! m {
+        ($e:expr) => {
+            break $e
+        };
+    }
+    return loop {
+        m!(true);
+    }
+}
+
+fn divergent_test() -> bool {
+    fn diverge() -> ! {
+        panic!()
+    }
+    diverge()
+}
+
+fn main() {}
diff --git a/tests/ui/implicit_return.rs b/tests/ui/implicit_return.rs
index 2c1bc046515..737ffd5ddce 100644
--- a/tests/ui/implicit_return.rs
+++ b/tests/ui/implicit_return.rs
@@ -1,7 +1,7 @@
 // run-rustfix
 
 #![warn(clippy::implicit_return)]
-#![allow(clippy::needless_return, unused)]
+#![allow(clippy::needless_return, clippy::needless_bool, unused, clippy::never_loop)]
 
 fn test_end_of_fn() -> bool {
     if true {
@@ -12,7 +12,6 @@ fn test_end_of_fn() -> bool {
     true
 }
 
-#[allow(clippy::needless_bool)]
 fn test_if_block() -> bool {
     if true { true } else { false }
 }
@@ -25,7 +24,6 @@ fn test_match(x: bool) -> bool {
     }
 }
 
-#[allow(clippy::needless_return)]
 fn test_match_with_unreachable(x: bool) -> bool {
     match x {
         true => return false,
@@ -33,14 +31,12 @@ fn test_match_with_unreachable(x: bool) -> bool {
     }
 }
 
-#[allow(clippy::never_loop)]
 fn test_loop() -> bool {
     loop {
         break true;
     }
 }
 
-#[allow(clippy::never_loop)]
 fn test_loop_with_block() -> bool {
     loop {
         {
@@ -49,7 +45,6 @@ fn test_loop_with_block() -> bool {
     }
 }
 
-#[allow(clippy::never_loop)]
 fn test_loop_with_nests() -> bool {
     loop {
         if true {
@@ -83,15 +78,48 @@ fn test_return_macro() -> String {
     format!("test {}", "test")
 }
 
-fn main() {
-    let _ = test_end_of_fn();
-    let _ = test_if_block();
-    let _ = test_match(true);
-    let _ = test_match_with_unreachable(true);
-    let _ = test_loop();
-    let _ = test_loop_with_block();
-    let _ = test_loop_with_nests();
-    let _ = test_loop_with_if_let();
-    test_closure();
-    let _ = test_return_macro();
+fn macro_branch_test() -> bool {
+    macro_rules! m {
+        ($t:expr, $f:expr) => {
+            if true { $t } else { $f }
+        };
+    }
+    m!(true, false)
 }
+
+fn loop_test() -> bool {
+    'outer: loop {
+        if true {
+            break true;
+        }
+
+        let _ = loop {
+            if false {
+                break 'outer false;
+            }
+            if true {
+                break true;
+            }
+        };
+    }
+}
+
+fn loop_macro_test() -> bool {
+    macro_rules! m {
+        ($e:expr) => {
+            break $e
+        };
+    }
+    loop {
+        m!(true);
+    }
+}
+
+fn divergent_test() -> bool {
+    fn diverge() -> ! {
+        panic!()
+    }
+    diverge()
+}
+
+fn main() {}
diff --git a/tests/ui/implicit_return.stderr b/tests/ui/implicit_return.stderr
index 3608319e5bd..632e30cbdc6 100644
--- a/tests/ui/implicit_return.stderr
+++ b/tests/ui/implicit_return.stderr
@@ -7,64 +7,97 @@ LL |     true
    = note: `-D clippy::implicit-return` implied by `-D warnings`
 
 error: missing `return` statement
-  --> $DIR/implicit_return.rs:17:15
+  --> $DIR/implicit_return.rs:16:15
    |
 LL |     if true { true } else { false }
    |               ^^^^ help: add `return` as shown: `return true`
 
 error: missing `return` statement
-  --> $DIR/implicit_return.rs:17:29
+  --> $DIR/implicit_return.rs:16:29
    |
 LL |     if true { true } else { false }
    |                             ^^^^^ help: add `return` as shown: `return false`
 
 error: missing `return` statement
-  --> $DIR/implicit_return.rs:23:17
+  --> $DIR/implicit_return.rs:22:17
    |
 LL |         true => false,
    |                 ^^^^^ help: add `return` as shown: `return false`
 
 error: missing `return` statement
-  --> $DIR/implicit_return.rs:24:20
+  --> $DIR/implicit_return.rs:23:20
    |
 LL |         false => { true },
    |                    ^^^^ help: add `return` as shown: `return true`
 
 error: missing `return` statement
-  --> $DIR/implicit_return.rs:39:9
+  --> $DIR/implicit_return.rs:36:9
    |
 LL |         break true;
    |         ^^^^^^^^^^ help: change `break` to `return` as shown: `return true`
 
 error: missing `return` statement
-  --> $DIR/implicit_return.rs:47:13
+  --> $DIR/implicit_return.rs:43:13
    |
 LL |             break true;
    |             ^^^^^^^^^^ help: change `break` to `return` as shown: `return true`
 
 error: missing `return` statement
-  --> $DIR/implicit_return.rs:56:13
+  --> $DIR/implicit_return.rs:51:13
    |
 LL |             break true;
    |             ^^^^^^^^^^ help: change `break` to `return` as shown: `return true`
 
 error: missing `return` statement
-  --> $DIR/implicit_return.rs:74:18
+  --> $DIR/implicit_return.rs:69:18
    |
 LL |     let _ = || { true };
    |                  ^^^^ help: add `return` as shown: `return true`
 
 error: missing `return` statement
-  --> $DIR/implicit_return.rs:75:16
+  --> $DIR/implicit_return.rs:70:16
    |
 LL |     let _ = || true;
    |                ^^^^ help: add `return` as shown: `return true`
 
 error: missing `return` statement
-  --> $DIR/implicit_return.rs:83:5
+  --> $DIR/implicit_return.rs:78:5
    |
 LL |     format!("test {}", "test")
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: add `return` as shown: `return format!("test {}", "test")`
 
-error: aborting due to 11 previous errors
+error: missing `return` statement
+  --> $DIR/implicit_return.rs:87:5
+   |
+LL |     m!(true, false)
+   |     ^^^^^^^^^^^^^^^ help: add `return` as shown: `return m!(true, false)`
+
+error: missing `return` statement
+  --> $DIR/implicit_return.rs:93:13
+   |
+LL |             break true;
+   |             ^^^^^^^^^^ help: change `break` to `return` as shown: `return true`
+
+error: missing `return` statement
+  --> $DIR/implicit_return.rs:98:17
+   |
+LL |                 break 'outer false;
+   |                 ^^^^^^^^^^^^^^^^^^ help: change `break` to `return` as shown: `return false`
+
+error: missing `return` statement
+  --> $DIR/implicit_return.rs:113:5
+   |
+LL | /     loop {
+LL | |         m!(true);
+LL | |     }
+   | |_____^
+   |
+help: add `return` as shown
+   |
+LL |     return loop {
+LL |         m!(true);
+LL |     }
+   |
+
+error: aborting due to 15 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 74cf5f2fc6c121ae0eaaa709c9a303cd82fe9b30 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Fri, 2 Apr 2021 17:53:14 -0400
Subject: Fix `implicit_return` suggestion for async functions

---
 clippy_lints/src/implicit_return.rs | 11 +++++++++-
 clippy_utils/src/lib.rs             | 40 ++++++++++++++++++++++++++++++++++---
 tests/ui/implicit_return.fixed      |  6 ++++++
 tests/ui/implicit_return.rs         |  6 ++++++
 tests/ui/implicit_return.stderr     | 38 ++++++++++++++++++++---------------
 5 files changed, 81 insertions(+), 20 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/implicit_return.rs b/clippy_lints/src/implicit_return.rs
index 251a7361871..39612dbf050 100644
--- a/clippy_lints/src/implicit_return.rs
+++ b/clippy_lints/src/implicit_return.rs
@@ -1,5 +1,6 @@
 use clippy_utils::{
     diagnostics::span_lint_and_sugg,
+    get_async_fn_body, is_async_fn,
     source::{snippet_with_applicability, snippet_with_context, walk_span_to_context},
     visitors::visit_break_exprs,
 };
@@ -219,6 +220,14 @@ impl<'tcx> LateLintPass<'tcx> for ImplicitReturn {
             return;
         }
 
-        lint_implicit_returns(cx, &body.value, body.value.span.ctxt(), None);
+        let expr = if is_async_fn(kind) {
+            match get_async_fn_body(cx.tcx, body) {
+                Some(e) => e,
+                None => return,
+            }
+        } else {
+            &body.value
+        };
+        lint_implicit_returns(cx, expr, expr.span.ctxt(), None);
     }
 }
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index b7017411927..6dc96e51a6b 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -60,12 +60,12 @@ use rustc_data_structures::fx::FxHashMap;
 use rustc_hir as hir;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::def_id::{DefId, LOCAL_CRATE};
-use rustc_hir::intravisit::{self, walk_expr, ErasedMap, NestedVisitorMap, Visitor};
+use rustc_hir::intravisit::{self, walk_expr, ErasedMap, FnKind, NestedVisitorMap, Visitor};
 use rustc_hir::LangItem::{ResultErr, ResultOk};
 use rustc_hir::{
     def, Arm, BindingAnnotation, Block, Body, Constness, Destination, Expr, ExprKind, FnDecl, GenericArgs, HirId, Impl,
-    ImplItem, ImplItemKind, Item, ItemKind, LangItem, Local, MatchSource, Node, Param, Pat, PatKind, Path, PathSegment,
-    QPath, Stmt, StmtKind, TraitItem, TraitItemKind, TraitRef, TyKind,
+    ImplItem, ImplItemKind, IsAsync, Item, ItemKind, LangItem, Local, MatchSource, Node, Param, Pat, PatKind, Path,
+    PathSegment, QPath, Stmt, StmtKind, TraitItem, TraitItemKind, TraitRef, TyKind,
 };
 use rustc_lint::{LateContext, Level, Lint, LintContext};
 use rustc_middle::hir::exports::Export;
@@ -1300,6 +1300,40 @@ pub fn if_sequence<'tcx>(mut expr: &'tcx Expr<'tcx>) -> (Vec<&'tcx Expr<'tcx>>,
     (conds, blocks)
 }
 
+/// Checks if the given function kind is an async function.
+pub fn is_async_fn(kind: FnKind) -> bool {
+    matches!(kind, FnKind::ItemFn(_, _, header, _) if header.asyncness == IsAsync::Async)
+}
+
+/// Peels away all the compiler generated code surrounding the body of an async function,
+pub fn get_async_fn_body(tcx: TyCtxt<'tcx>, body: &Body<'_>) -> Option<&'tcx Expr<'tcx>> {
+    if let ExprKind::Call(
+        _,
+        &[Expr {
+            kind: ExprKind::Closure(_, _, body, _, _),
+            ..
+        }],
+    ) = body.value.kind
+    {
+        if let ExprKind::Block(
+            Block {
+                stmts: [],
+                expr:
+                    Some(Expr {
+                        kind: ExprKind::DropTemps(expr),
+                        ..
+                    }),
+                ..
+            },
+            _,
+        ) = tcx.hir().body(body).value.kind
+        {
+            return Some(expr);
+        }
+    };
+    None
+}
+
 // Finds the `#[must_use]` attribute, if any
 pub fn must_use_attr(attrs: &[Attribute]) -> Option<&Attribute> {
     attrs.iter().find(|a| a.has_name(sym::must_use))
diff --git a/tests/ui/implicit_return.fixed b/tests/ui/implicit_return.fixed
index c0fc4b926a0..7698b88a88c 100644
--- a/tests/ui/implicit_return.fixed
+++ b/tests/ui/implicit_return.fixed
@@ -1,3 +1,4 @@
+// edition:2018
 // run-rustfix
 
 #![warn(clippy::implicit_return)]
@@ -122,4 +123,9 @@ fn divergent_test() -> bool {
     diverge()
 }
 
+// issue #6940
+async fn foo() -> bool {
+    return true
+}
+
 fn main() {}
diff --git a/tests/ui/implicit_return.rs b/tests/ui/implicit_return.rs
index 737ffd5ddce..45bbc2ec670 100644
--- a/tests/ui/implicit_return.rs
+++ b/tests/ui/implicit_return.rs
@@ -1,3 +1,4 @@
+// edition:2018
 // run-rustfix
 
 #![warn(clippy::implicit_return)]
@@ -122,4 +123,9 @@ fn divergent_test() -> bool {
     diverge()
 }
 
+// issue #6940
+async fn foo() -> bool {
+    true
+}
+
 fn main() {}
diff --git a/tests/ui/implicit_return.stderr b/tests/ui/implicit_return.stderr
index 632e30cbdc6..16fe9ed444f 100644
--- a/tests/ui/implicit_return.stderr
+++ b/tests/ui/implicit_return.stderr
@@ -1,5 +1,5 @@
 error: missing `return` statement
-  --> $DIR/implicit_return.rs:12:5
+  --> $DIR/implicit_return.rs:13:5
    |
 LL |     true
    |     ^^^^ help: add `return` as shown: `return true`
@@ -7,85 +7,85 @@ LL |     true
    = note: `-D clippy::implicit-return` implied by `-D warnings`
 
 error: missing `return` statement
-  --> $DIR/implicit_return.rs:16:15
+  --> $DIR/implicit_return.rs:17:15
    |
 LL |     if true { true } else { false }
    |               ^^^^ help: add `return` as shown: `return true`
 
 error: missing `return` statement
-  --> $DIR/implicit_return.rs:16:29
+  --> $DIR/implicit_return.rs:17:29
    |
 LL |     if true { true } else { false }
    |                             ^^^^^ help: add `return` as shown: `return false`
 
 error: missing `return` statement
-  --> $DIR/implicit_return.rs:22:17
+  --> $DIR/implicit_return.rs:23:17
    |
 LL |         true => false,
    |                 ^^^^^ help: add `return` as shown: `return false`
 
 error: missing `return` statement
-  --> $DIR/implicit_return.rs:23:20
+  --> $DIR/implicit_return.rs:24:20
    |
 LL |         false => { true },
    |                    ^^^^ help: add `return` as shown: `return true`
 
 error: missing `return` statement
-  --> $DIR/implicit_return.rs:36:9
+  --> $DIR/implicit_return.rs:37:9
    |
 LL |         break true;
    |         ^^^^^^^^^^ help: change `break` to `return` as shown: `return true`
 
 error: missing `return` statement
-  --> $DIR/implicit_return.rs:43:13
+  --> $DIR/implicit_return.rs:44:13
    |
 LL |             break true;
    |             ^^^^^^^^^^ help: change `break` to `return` as shown: `return true`
 
 error: missing `return` statement
-  --> $DIR/implicit_return.rs:51:13
+  --> $DIR/implicit_return.rs:52:13
    |
 LL |             break true;
    |             ^^^^^^^^^^ help: change `break` to `return` as shown: `return true`
 
 error: missing `return` statement
-  --> $DIR/implicit_return.rs:69:18
+  --> $DIR/implicit_return.rs:70:18
    |
 LL |     let _ = || { true };
    |                  ^^^^ help: add `return` as shown: `return true`
 
 error: missing `return` statement
-  --> $DIR/implicit_return.rs:70:16
+  --> $DIR/implicit_return.rs:71:16
    |
 LL |     let _ = || true;
    |                ^^^^ help: add `return` as shown: `return true`
 
 error: missing `return` statement
-  --> $DIR/implicit_return.rs:78:5
+  --> $DIR/implicit_return.rs:79:5
    |
 LL |     format!("test {}", "test")
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: add `return` as shown: `return format!("test {}", "test")`
 
 error: missing `return` statement
-  --> $DIR/implicit_return.rs:87:5
+  --> $DIR/implicit_return.rs:88:5
    |
 LL |     m!(true, false)
    |     ^^^^^^^^^^^^^^^ help: add `return` as shown: `return m!(true, false)`
 
 error: missing `return` statement
-  --> $DIR/implicit_return.rs:93:13
+  --> $DIR/implicit_return.rs:94:13
    |
 LL |             break true;
    |             ^^^^^^^^^^ help: change `break` to `return` as shown: `return true`
 
 error: missing `return` statement
-  --> $DIR/implicit_return.rs:98:17
+  --> $DIR/implicit_return.rs:99:17
    |
 LL |                 break 'outer false;
    |                 ^^^^^^^^^^^^^^^^^^ help: change `break` to `return` as shown: `return false`
 
 error: missing `return` statement
-  --> $DIR/implicit_return.rs:113:5
+  --> $DIR/implicit_return.rs:114:5
    |
 LL | /     loop {
 LL | |         m!(true);
@@ -99,5 +99,11 @@ LL |         m!(true);
 LL |     }
    |
 
-error: aborting due to 15 previous errors
+error: missing `return` statement
+  --> $DIR/implicit_return.rs:128:5
+   |
+LL |     true
+   |     ^^^^ help: add `return` as shown: `return true`
+
+error: aborting due to 16 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 3d793f3111845c8d5836310387b65622ea86b01f Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Thu, 22 Apr 2021 09:11:36 -0400
Subject: Minor cleanup of `implicit_return`

---
 clippy_lints/src/implicit_return.rs | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/implicit_return.rs b/clippy_lints/src/implicit_return.rs
index 39612dbf050..30174fa2100 100644
--- a/clippy_lints/src/implicit_return.rs
+++ b/clippy_lints/src/implicit_return.rs
@@ -70,6 +70,7 @@ fn lint_break(cx: &LateContext<'_>, break_span: Span, expr_span: Span) {
     )
 }
 
+#[derive(Clone, Copy, PartialEq, Eq)]
 enum LintLocation {
     /// The lint was applied to a parent expression.
     Parent,
@@ -81,8 +82,8 @@ impl LintLocation {
         if b { self } else { Self::Inner }
     }
 
-    fn is_parent(&self) -> bool {
-        matches!(*self, Self::Parent)
+    fn is_parent(self) -> bool {
+        self == Self::Parent
     }
 }
 
-- 
cgit 1.4.1-3-g733a5


From 5625d58f9f3fbff3d81cbab76fbbcfc5ff06c833 Mon Sep 17 00:00:00 2001
From: Aliénore Bouttefeux <alienore.bouttefeux@gmail.com>
Date: Fri, 16 Apr 2021 20:12:16 +0200
Subject: add detection unused_io_amount of "or", "or_else" and "ok"

---
 clippy_lints/src/unused_io_amount.rs | 20 +++++++++++++-----
 tests/ui/unused_io_amount.rs         | 41 +++++++++++++++++++++++++++++++++++-
 tests/ui/unused_io_amount.stderr     | 30 +++++++++++++++++++++++++-
 3 files changed, 84 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unused_io_amount.rs b/clippy_lints/src/unused_io_amount.rs
index 5e8e530f480..3387f35bac3 100644
--- a/clippy_lints/src/unused_io_amount.rs
+++ b/clippy_lints/src/unused_io_amount.rs
@@ -47,25 +47,35 @@ impl<'tcx> LateLintPass<'tcx> for UnusedIoAmount {
                         func.kind,
                         hir::ExprKind::Path(hir::QPath::LangItem(hir::LangItem::TryIntoResult, _))
                     ) {
-                        check_method_call(cx, &args[0], expr);
+                        check_map_error(cx, &args[0], expr);
                     }
                 } else {
-                    check_method_call(cx, res, expr);
+                    check_map_error(cx, res, expr);
                 }
             },
-
             hir::ExprKind::MethodCall(path, _, args, _) => match &*path.ident.as_str() {
                 "expect" | "unwrap" | "unwrap_or" | "unwrap_or_else" => {
-                    check_method_call(cx, &args[0], expr);
+                    check_map_error(cx, &args[0], expr);
                 },
                 _ => (),
             },
-
             _ => (),
         }
     }
 }
 
+fn check_map_error(cx: &LateContext<'_>, call: &hir::Expr<'_>, expr: &hir::Expr<'_>) {
+    let mut call = call;
+    while let hir::ExprKind::MethodCall(ref path, _, ref args, _) = call.kind {
+        if matches!(&*path.ident.as_str(), "or" | "or_else" | "ok") {
+            call = &args[0];
+        } else {
+            break;
+        }
+    }
+    check_method_call(cx, call, expr);
+}
+
 fn check_method_call(cx: &LateContext<'_>, call: &hir::Expr<'_>, expr: &hir::Expr<'_>) {
     if let hir::ExprKind::MethodCall(path, _, _, _) = call.kind {
         let symbol = &*path.ident.as_str();
diff --git a/tests/ui/unused_io_amount.rs b/tests/ui/unused_io_amount.rs
index ebaba9629db..8b141e25942 100644
--- a/tests/ui/unused_io_amount.rs
+++ b/tests/ui/unused_io_amount.rs
@@ -1,7 +1,7 @@
 #![allow(dead_code)]
 #![warn(clippy::unused_io_amount)]
 
-use std::io;
+use std::io::{self, Read};
 
 fn question_mark<T: io::Read + io::Write>(s: &mut T) -> io::Result<()> {
     s.write(b"test")?;
@@ -22,4 +22,43 @@ fn vectored<T: io::Read + io::Write>(s: &mut T) -> io::Result<()> {
     Ok(())
 }
 
+fn ok(file: &str) -> Option<()> {
+    let mut reader = std::fs::File::open(file).ok()?;
+    let mut result = [0u8; 0];
+    reader.read(&mut result).ok()?;
+    Some(())
+}
+
+#[allow(clippy::redundant_closure)]
+#[allow(clippy::bind_instead_of_map)]
+fn or_else(file: &str) -> io::Result<()> {
+    let mut reader = std::fs::File::open(file)?;
+    let mut result = [0u8; 0];
+    reader.read(&mut result).or_else(|err| Err(err))?;
+    Ok(())
+}
+
+#[derive(Debug)]
+enum Error {
+    Kind,
+}
+
+fn or(file: &str) -> Result<(), Error> {
+    let mut reader = std::fs::File::open(file).unwrap();
+    let mut result = [0u8; 0];
+    reader.read(&mut result).or(Err(Error::Kind))?;
+    Ok(())
+}
+
+fn combine_or(file: &str) -> Result<(), Error> {
+    let mut reader = std::fs::File::open(file).unwrap();
+    let mut result = [0u8; 0];
+    reader
+        .read(&mut result)
+        .or(Err(Error::Kind))
+        .or(Err(Error::Kind))
+        .expect("error");
+    Ok(())
+}
+
 fn main() {}
diff --git a/tests/ui/unused_io_amount.stderr b/tests/ui/unused_io_amount.stderr
index 5219d63980b..d8dfc0e5a79 100644
--- a/tests/ui/unused_io_amount.stderr
+++ b/tests/ui/unused_io_amount.stderr
@@ -36,5 +36,33 @@ error: written amount is not handled
 LL |     s.write_vectored(&[io::IoSlice::new(&[])])?;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 6 previous errors
+error: read amount is not handled. Use `Read::read_exact` instead
+  --> $DIR/unused_io_amount.rs:28:5
+   |
+LL |     reader.read(&mut result).ok()?;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: read amount is not handled. Use `Read::read_exact` instead
+  --> $DIR/unused_io_amount.rs:37:5
+   |
+LL |     reader.read(&mut result).or_else(|err| Err(err))?;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: read amount is not handled. Use `Read::read_exact` instead
+  --> $DIR/unused_io_amount.rs:49:5
+   |
+LL |     reader.read(&mut result).or(Err(Error::Kind))?;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: read amount is not handled. Use `Read::read_exact` instead
+  --> $DIR/unused_io_amount.rs:56:5
+   |
+LL | /     reader
+LL | |         .read(&mut result)
+LL | |         .or(Err(Error::Kind))
+LL | |         .or(Err(Error::Kind))
+LL | |         .expect("error");
+   | |________________________^
+
+error: aborting due to 10 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 3f5be5e2357d11ed3273d4e286e2cb9efe46cd28 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Sun, 25 Apr 2021 09:51:44 -0500
Subject: Fix cloned_instead_of_copied MSRV

---
 .../src/methods/cloned_instead_of_copied.rs        | 24 +++++++++++++++-------
 clippy_lints/src/methods/mod.rs                    |  2 +-
 2 files changed, 18 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/cloned_instead_of_copied.rs b/clippy_lints/src/methods/cloned_instead_of_copied.rs
index ba97ab3900c..9c1b6f55c88 100644
--- a/clippy_lints/src/methods/cloned_instead_of_copied.rs
+++ b/clippy_lints/src/methods/cloned_instead_of_copied.rs
@@ -1,23 +1,33 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::is_trait_method;
 use clippy_utils::ty::{get_iterator_item_ty, is_copy};
+use clippy_utils::{is_trait_method, meets_msrv};
 use rustc_errors::Applicability;
 use rustc_hir::Expr;
 use rustc_lint::LateContext;
 use rustc_middle::ty;
+use rustc_semver::RustcVersion;
 use rustc_span::{sym, Span};
 
 use super::CLONED_INSTEAD_OF_COPIED;
 
-pub fn check(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'_>, span: Span) {
+const ITERATOR_COPIED_MSRV: RustcVersion = RustcVersion::new(1, 36, 0);
+const OPTION_COPIED_MSRV: RustcVersion = RustcVersion::new(1, 35, 0);
+
+pub fn check(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'_>, span: Span, msrv: Option<&RustcVersion>) {
     let recv_ty = cx.typeck_results().expr_ty_adjusted(recv);
     let inner_ty = match recv_ty.kind() {
         // `Option<T>` -> `T`
-        ty::Adt(adt, subst) if cx.tcx.is_diagnostic_item(sym::option_type, adt.did) => subst.type_at(0),
-        _ if is_trait_method(cx, expr, sym::Iterator) => match get_iterator_item_ty(cx, recv_ty) {
-            // <T as Iterator>::Item
-            Some(ty) => ty,
-            _ => return,
+        ty::Adt(adt, subst)
+            if cx.tcx.is_diagnostic_item(sym::option_type, adt.did) && meets_msrv(msrv, &OPTION_COPIED_MSRV) =>
+        {
+            subst.type_at(0)
+        },
+        _ if is_trait_method(cx, expr, sym::Iterator) && meets_msrv(msrv, &ITERATOR_COPIED_MSRV) => {
+            match get_iterator_item_ty(cx, recv_ty) {
+                // <T as Iterator>::Item
+                Some(ty) => ty,
+                _ => return,
+            }
         },
         _ => return,
     };
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index c2cd3011d14..e15dbb899b3 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1959,7 +1959,7 @@ fn check_methods<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, msrv: Optio
             ("as_mut", []) => useless_asref::check(cx, expr, "as_mut", recv),
             ("as_ref", []) => useless_asref::check(cx, expr, "as_ref", recv),
             ("assume_init", []) => uninit_assumed_init::check(cx, expr, recv),
-            ("cloned", []) => cloned_instead_of_copied::check(cx, expr, recv, span),
+            ("cloned", []) => cloned_instead_of_copied::check(cx, expr, recv, span, msrv),
             ("collect", []) => match method_call!(recv) {
                 Some(("cloned", [recv2], _)) => iter_cloned_collect::check(cx, expr, recv2),
                 Some(("map", [m_recv, m_arg], _)) => {
-- 
cgit 1.4.1-3-g733a5


From efc4c6c957ea2b0d870f4728fa934042213da5e8 Mon Sep 17 00:00:00 2001
From: Andre Bogus <bogusandre@gmail.com>
Date: Sun, 25 Apr 2021 18:10:38 +0200
Subject: extend `single_element_loop` to match `.iter()`

---
 clippy_lints/src/loops/single_element_loop.rs |  8 +++++++-
 tests/ui/single_element_loop.fixed            |  5 +++++
 tests/ui/single_element_loop.rs               |  4 ++++
 tests/ui/single_element_loop.stderr           | 18 +++++++++++++++++-
 4 files changed, 33 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/single_element_loop.rs b/clippy_lints/src/loops/single_element_loop.rs
index fc067e81bca..0fd09ff7197 100644
--- a/clippy_lints/src/loops/single_element_loop.rs
+++ b/clippy_lints/src/loops/single_element_loop.rs
@@ -14,8 +14,14 @@ pub(super) fn check<'tcx>(
     body: &'tcx Expr<'_>,
     expr: &'tcx Expr<'_>,
 ) {
+    let arg_expr = match arg.kind {
+        ExprKind::AddrOf(BorrowKind::Ref, _, ref_arg) => ref_arg,
+        ExprKind::MethodCall(method, _, args, _) if args.len() == 1 && method.ident.name == rustc_span::sym::iter => {
+            &args[0]
+        },
+        _ => return,
+    };
     if_chain! {
-        if let ExprKind::AddrOf(BorrowKind::Ref, _, arg_expr) = arg.kind;
         if let PatKind::Binding(.., target, _) = pat.kind;
         if let ExprKind::Array([arg_expression]) = arg_expr.kind;
         if let ExprKind::Path(ref list_item) = arg_expression.kind;
diff --git a/tests/ui/single_element_loop.fixed b/tests/ui/single_element_loop.fixed
index 8ca068293a6..c307afffcb8 100644
--- a/tests/ui/single_element_loop.fixed
+++ b/tests/ui/single_element_loop.fixed
@@ -8,4 +8,9 @@ fn main() {
         let item = &item1;
         println!("{}", item);
     }
+
+    {
+        let item = &item1;
+        println!("{:?}", item);
+    }
 }
diff --git a/tests/ui/single_element_loop.rs b/tests/ui/single_element_loop.rs
index 57e9336a31f..2c0c03b7211 100644
--- a/tests/ui/single_element_loop.rs
+++ b/tests/ui/single_element_loop.rs
@@ -7,4 +7,8 @@ fn main() {
     for item in &[item1] {
         println!("{}", item);
     }
+
+    for item in [item1].iter() {
+        println!("{:?}", item);
+    }
 }
diff --git a/tests/ui/single_element_loop.stderr b/tests/ui/single_element_loop.stderr
index 90be1dc3283..0e35a33ded5 100644
--- a/tests/ui/single_element_loop.stderr
+++ b/tests/ui/single_element_loop.stderr
@@ -15,5 +15,21 @@ LL |         println!("{}", item);
 LL |     }
    |
 
-error: aborting due to previous error
+error: for loop over a single element
+  --> $DIR/single_element_loop.rs:11:5
+   |
+LL | /     for item in [item1].iter() {
+LL | |         println!("{:?}", item);
+LL | |     }
+   | |_____^
+   |
+help: try
+   |
+LL |     {
+LL |         let item = &item1;
+LL |         println!("{:?}", item);
+LL |     }
+   |
+
+error: aborting due to 2 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From dcf4e07458c4136f2107d5ff26590c47f9590b1a Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Mon, 26 Apr 2021 11:09:24 -0500
Subject: Finish MSRV for cloned_instead_of_copied

---
 clippy_lints/src/utils/conf.rs        | 2 +-
 tests/ui/min_rust_version_attr.rs     | 4 ++++
 tests/ui/min_rust_version_attr.stderr | 8 ++++----
 3 files changed, 9 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 147f823491d..2f8714b1799 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -106,7 +106,7 @@ macro_rules! define_Conf {
 
 pub use self::helpers::Conf;
 define_Conf! {
-    /// Lint: REDUNDANT_FIELD_NAMES, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, NEEDLESS_QUESTION_MARK, PTR_AS_PTR. The minimum rust version that the project supports
+    /// Lint: CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, NEEDLESS_QUESTION_MARK, PTR_AS_PTR. The minimum rust version that the project supports
     (msrv, "msrv": Option<String>, None),
     /// Lint: BLACKLISTED_NAME. The list of blacklisted names to lint about. NB: `bar` is not here since it has legitimate uses
     (blacklisted_names, "blacklisted_names": Vec<String>, ["foo", "baz", "quux"].iter().map(ToString::to_string).collect()),
diff --git a/tests/ui/min_rust_version_attr.rs b/tests/ui/min_rust_version_attr.rs
index 49ace1ca128..7f9f7ddc535 100644
--- a/tests/ui/min_rust_version_attr.rs
+++ b/tests/ui/min_rust_version_attr.rs
@@ -4,6 +4,10 @@
 
 use std::ops::{Deref, RangeFrom};
 
+fn cloned_instead_of_copied() {
+    let _ = [1].iter().cloned();
+}
+
 fn option_as_ref_deref() {
     let mut opt = Some(String::from("123"));
 
diff --git a/tests/ui/min_rust_version_attr.stderr b/tests/ui/min_rust_version_attr.stderr
index 8d3575c2da8..ddb1e1f3724 100644
--- a/tests/ui/min_rust_version_attr.stderr
+++ b/tests/ui/min_rust_version_attr.stderr
@@ -1,12 +1,12 @@
 error: stripping a prefix manually
-  --> $DIR/min_rust_version_attr.rs:156:24
+  --> $DIR/min_rust_version_attr.rs:160:24
    |
 LL |             assert_eq!(s["hello, ".len()..].to_uppercase(), "WORLD!");
    |                        ^^^^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::manual-strip` implied by `-D warnings`
 note: the prefix was tested here
-  --> $DIR/min_rust_version_attr.rs:155:9
+  --> $DIR/min_rust_version_attr.rs:159:9
    |
 LL |         if s.starts_with("hello, ") {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -17,13 +17,13 @@ LL |             assert_eq!(<stripped>.to_uppercase(), "WORLD!");
    |
 
 error: stripping a prefix manually
-  --> $DIR/min_rust_version_attr.rs:168:24
+  --> $DIR/min_rust_version_attr.rs:172:24
    |
 LL |             assert_eq!(s["hello, ".len()..].to_uppercase(), "WORLD!");
    |                        ^^^^^^^^^^^^^^^^^^^^
    |
 note: the prefix was tested here
-  --> $DIR/min_rust_version_attr.rs:167:9
+  --> $DIR/min_rust_version_attr.rs:171:9
    |
 LL |         if s.starts_with("hello, ") {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From 84003aa7a18f2673b20340dd20344dda8265ba7a Mon Sep 17 00:00:00 2001
From: Mateusz Gacek <96mateusz.gacek@gmail.com>
Date: Mon, 26 Apr 2021 12:08:24 -0700
Subject: fix invalid code suggestion in `manual_unwrap_or`, due to macro
 expansion

---
 clippy_lints/src/manual_unwrap_or.rs | 11 ++++++++++-
 tests/ui/manual_unwrap_or.fixed      | 12 ++++++++++++
 tests/ui/manual_unwrap_or.rs         | 15 +++++++++++++++
 tests/ui/manual_unwrap_or.stderr     | 12 +++++++++++-
 4 files changed, 48 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_unwrap_or.rs b/clippy_lints/src/manual_unwrap_or.rs
index 65baa2552cc..520162559e5 100644
--- a/clippy_lints/src/manual_unwrap_or.rs
+++ b/clippy_lints/src/manual_unwrap_or.rs
@@ -112,6 +112,15 @@ fn lint_manual_unwrap_or<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
         then {
             let reindented_or_body =
                 reindent_multiline(or_body_snippet.into(), true, Some(indent));
+
+            let suggestion = if scrutinee.span.from_expansion() {
+                    // we don't want parenthesis around macro, e.g. `(some_macro!()).unwrap_or(0)`
+                    sugg::Sugg::hir_with_macro_callsite(cx, scrutinee, "..")
+                }
+                else {
+                    sugg::Sugg::hir(cx, scrutinee, "..").maybe_par()
+                };
+
             span_lint_and_sugg(
                 cx,
                 MANUAL_UNWRAP_OR, expr.span,
@@ -119,7 +128,7 @@ fn lint_manual_unwrap_or<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
                 "replace with",
                 format!(
                     "{}.unwrap_or({})",
-                    sugg::Sugg::hir(cx, scrutinee, "..").maybe_par(),
+                    suggestion,
                     reindented_or_body,
                 ),
                 Applicability::MachineApplicable,
diff --git a/tests/ui/manual_unwrap_or.fixed b/tests/ui/manual_unwrap_or.fixed
index f1d3252230b..e7a29596b73 100644
--- a/tests/ui/manual_unwrap_or.fixed
+++ b/tests/ui/manual_unwrap_or.fixed
@@ -151,4 +151,16 @@ const fn const_fn_result_unwrap_or() {
     };
 }
 
+mod issue6965 {
+    macro_rules! some_macro {
+        () => {
+            if 1 > 2 { Some(1) } else { None }
+        };
+    }
+
+    fn test() {
+        let _ = some_macro!().unwrap_or(0);
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/manual_unwrap_or.rs b/tests/ui/manual_unwrap_or.rs
index c9eee25a5b1..66006b6c616 100644
--- a/tests/ui/manual_unwrap_or.rs
+++ b/tests/ui/manual_unwrap_or.rs
@@ -190,4 +190,19 @@ const fn const_fn_result_unwrap_or() {
     };
 }
 
+mod issue6965 {
+    macro_rules! some_macro {
+        () => {
+            if 1 > 2 { Some(1) } else { None }
+        };
+    }
+
+    fn test() {
+        let _ = match some_macro!() {
+            Some(val) => val,
+            None => 0,
+        };
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/manual_unwrap_or.stderr b/tests/ui/manual_unwrap_or.stderr
index fc174c4c270..99625b789b6 100644
--- a/tests/ui/manual_unwrap_or.stderr
+++ b/tests/ui/manual_unwrap_or.stderr
@@ -141,5 +141,15 @@ LL | |         Err(_) => "Alice",
 LL | |     };
    | |_____^ help: replace with: `Ok::<&str, &str>("Bob").unwrap_or("Alice")`
 
-error: aborting due to 13 previous errors
+error: this pattern reimplements `Option::unwrap_or`
+  --> $DIR/manual_unwrap_or.rs:201:17
+   |
+LL |           let _ = match some_macro!() {
+   |  _________________^
+LL | |             Some(val) => val,
+LL | |             None => 0,
+LL | |         };
+   | |_________^ help: replace with: `some_macro!().unwrap_or(0)`
+
+error: aborting due to 14 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From d7627dcfc8a60aaedccf002738dc44a2576fa8fd Mon Sep 17 00:00:00 2001
From: Mateusz Gacek <96mateusz.gacek@gmail.com>
Date: Mon, 26 Apr 2021 13:03:51 -0700
Subject: Fix FN in `iter_cloned_collect` with a large array

---
 clippy_lints/src/methods/utils.rs   | 4 +---
 tests/ui/iter_cloned_collect.fixed  | 4 ++++
 tests/ui/iter_cloned_collect.rs     | 4 ++++
 tests/ui/iter_cloned_collect.stderr | 8 +++++++-
 4 files changed, 16 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/utils.rs b/clippy_lints/src/methods/utils.rs
index f6bf37e08b9..0daea47816a 100644
--- a/clippy_lints/src/methods/utils.rs
+++ b/clippy_lints/src/methods/utils.rs
@@ -18,9 +18,7 @@ pub(super) fn derefs_to_slice<'tcx>(
             ty::Slice(_) => true,
             ty::Adt(def, _) if def.is_box() => may_slice(cx, ty.boxed_ty()),
             ty::Adt(..) => is_type_diagnostic_item(cx, ty, sym::vec_type),
-            ty::Array(_, size) => size
-                .try_eval_usize(cx.tcx, cx.param_env)
-                .map_or(false, |size| size < 32),
+            ty::Array(_, size) => size.try_eval_usize(cx.tcx, cx.param_env).is_some(),
             ty::Ref(_, inner, _) => may_slice(cx, inner),
             _ => false,
         }
diff --git a/tests/ui/iter_cloned_collect.fixed b/tests/ui/iter_cloned_collect.fixed
index 2773227e26b..39cc58cd298 100644
--- a/tests/ui/iter_cloned_collect.fixed
+++ b/tests/ui/iter_cloned_collect.fixed
@@ -19,4 +19,8 @@ fn main() {
         let _: Vec<u8> = std::ffi::CStr::from_ptr(std::ptr::null())
             .to_bytes().to_vec();
     }
+
+    // Issue #6808
+    let arr: [u8; 64] = [0; 64];
+    let _: Vec<_> = arr.to_vec();
 }
diff --git a/tests/ui/iter_cloned_collect.rs b/tests/ui/iter_cloned_collect.rs
index 60a4eac23c7..c2a036ec09f 100644
--- a/tests/ui/iter_cloned_collect.rs
+++ b/tests/ui/iter_cloned_collect.rs
@@ -22,4 +22,8 @@ fn main() {
             .cloned()
             .collect();
     }
+
+    // Issue #6808
+    let arr: [u8; 64] = [0; 64];
+    let _: Vec<_> = arr.iter().cloned().collect();
 }
diff --git a/tests/ui/iter_cloned_collect.stderr b/tests/ui/iter_cloned_collect.stderr
index b90a1e6c919..e1df61794ce 100644
--- a/tests/ui/iter_cloned_collect.stderr
+++ b/tests/ui/iter_cloned_collect.stderr
@@ -22,5 +22,11 @@ LL | |             .cloned()
 LL | |             .collect();
    | |______________________^ help: try: `.to_vec()`
 
-error: aborting due to 3 previous errors
+error: called `iter().cloned().collect()` on a slice to create a `Vec`. Calling `to_vec()` is both faster and more readable
+  --> $DIR/iter_cloned_collect.rs:28:24
+   |
+LL |     let _: Vec<_> = arr.iter().cloned().collect();
+   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `.to_vec()`
+
+error: aborting due to 4 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 33ed8b5b24caf1e3d1d4d8020f61ca65102c87f8 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Mon, 26 Apr 2021 15:49:25 -0500
Subject: Remove needless_question_mark MSRV

---
 clippy_lints/src/lib.rs                    |  2 +-
 clippy_lints/src/needless_question_mark.rs | 42 ++++-------------
 clippy_lints/src/utils/conf.rs             |  2 +-
 tests/ui/needless_question_mark.fixed      | 72 ------------------------------
 tests/ui/needless_question_mark.rs         | 72 ------------------------------
 tests/ui/needless_question_mark.stderr     | 22 +--------
 6 files changed, 13 insertions(+), 199 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 2ff633bcda5..c84890299df 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1076,7 +1076,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(move || box from_over_into::FromOverInto::new(msrv));
     store.register_late_pass(move || box use_self::UseSelf::new(msrv));
     store.register_late_pass(move || box missing_const_for_fn::MissingConstForFn::new(msrv));
-    store.register_late_pass(move || box needless_question_mark::NeedlessQuestionMark::new(msrv));
+    store.register_late_pass(move || box needless_question_mark::NeedlessQuestionMark);
     store.register_late_pass(move || box casts::Casts::new(msrv));
     store.register_early_pass(move || box unnested_or_patterns::UnnestedOrPatterns::new(msrv));
 
diff --git a/clippy_lints/src/needless_question_mark.rs b/clippy_lints/src/needless_question_mark.rs
index cfe7ae6630e..7b156a8c49d 100644
--- a/clippy_lints/src/needless_question_mark.rs
+++ b/clippy_lints/src/needless_question_mark.rs
@@ -1,15 +1,13 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::is_lang_ctor;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{differing_macro_contexts, meets_msrv};
+use clippy_utils::{differing_macro_contexts, is_lang_ctor};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::LangItem::{OptionSome, ResultOk};
 use rustc_hir::{Body, Expr, ExprKind, LangItem, MatchSource, QPath};
-use rustc_lint::{LateContext, LateLintPass, LintContext};
-use rustc_semver::RustcVersion;
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::sym;
 
 declare_clippy_lint! {
@@ -63,21 +61,7 @@ declare_clippy_lint! {
     "Suggest `value.inner_option` instead of `Some(value.inner_option?)`. The same goes for `Result<T, E>`."
 }
 
-const NEEDLESS_QUESTION_MARK_RESULT_MSRV: RustcVersion = RustcVersion::new(1, 13, 0);
-const NEEDLESS_QUESTION_MARK_OPTION_MSRV: RustcVersion = RustcVersion::new(1, 22, 0);
-
-pub struct NeedlessQuestionMark {
-    msrv: Option<RustcVersion>,
-}
-
-impl NeedlessQuestionMark {
-    #[must_use]
-    pub fn new(msrv: Option<RustcVersion>) -> Self {
-        Self { msrv }
-    }
-}
-
-impl_lint_pass!(NeedlessQuestionMark => [NEEDLESS_QUESTION_MARK]);
+declare_lint_pass!(NeedlessQuestionMark => [NEEDLESS_QUESTION_MARK]);
 
 #[derive(Debug)]
 enum SomeOkCall<'a> {
@@ -111,7 +95,7 @@ impl LateLintPass<'_> for NeedlessQuestionMark {
             _ => return,
         };
 
-        if let Some(ok_some_call) = is_some_or_ok_call(self, cx, e) {
+        if let Some(ok_some_call) = is_some_or_ok_call(cx, e) {
             emit_lint(cx, &ok_some_call);
         }
     }
@@ -127,14 +111,12 @@ impl LateLintPass<'_> for NeedlessQuestionMark {
 
         if_chain! {
             if let Some(expr) = expr_opt;
-            if let Some(ok_some_call) = is_some_or_ok_call(self, cx, expr);
+            if let Some(ok_some_call) = is_some_or_ok_call(cx, expr);
             then {
                 emit_lint(cx, &ok_some_call);
             }
         };
     }
-
-    extract_msrv_attr!(LateContext);
 }
 
 fn emit_lint(cx: &LateContext<'_>, expr: &SomeOkCall<'_>) {
@@ -153,11 +135,7 @@ fn emit_lint(cx: &LateContext<'_>, expr: &SomeOkCall<'_>) {
     );
 }
 
-fn is_some_or_ok_call<'a>(
-    nqml: &NeedlessQuestionMark,
-    cx: &'a LateContext<'_>,
-    expr: &'a Expr<'_>,
-) -> Option<SomeOkCall<'a>> {
+fn is_some_or_ok_call<'a>(cx: &'a LateContext<'_>, expr: &'a Expr<'_>) -> Option<SomeOkCall<'a>> {
     if_chain! {
         // Check outer expression matches CALL_IDENT(ARGUMENT) format
         if let ExprKind::Call(path, args) = &expr.kind;
@@ -188,8 +166,7 @@ fn is_some_or_ok_call<'a>(
             let inner_is_some = is_type_diagnostic_item(cx, inner_ty, sym::option_type);
 
             // Check for Option MSRV
-            let meets_option_msrv = meets_msrv(nqml.msrv.as_ref(), &NEEDLESS_QUESTION_MARK_OPTION_MSRV);
-            if outer_is_some && inner_is_some && meets_option_msrv {
+            if outer_is_some && inner_is_some {
                 return Some(SomeOkCall::SomeCall(expr, inner_expr));
             }
 
@@ -202,8 +179,7 @@ fn is_some_or_ok_call<'a>(
             let does_not_call_from = !has_implicit_error_from(cx, expr, inner_expr);
 
             // Must meet Result MSRV
-            let meets_result_msrv = meets_msrv(nqml.msrv.as_ref(), &NEEDLESS_QUESTION_MARK_RESULT_MSRV);
-            if outer_is_result && inner_is_result && does_not_call_from && meets_result_msrv {
+            if outer_is_result && inner_is_result && does_not_call_from {
                 return Some(SomeOkCall::OkCall(expr, inner_expr));
             }
         }
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 2f8714b1799..d56855a71c1 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -106,7 +106,7 @@ macro_rules! define_Conf {
 
 pub use self::helpers::Conf;
 define_Conf! {
-    /// Lint: CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, NEEDLESS_QUESTION_MARK, PTR_AS_PTR. The minimum rust version that the project supports
+    /// Lint: CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR. The minimum rust version that the project supports
     (msrv, "msrv": Option<String>, None),
     /// Lint: BLACKLISTED_NAME. The list of blacklisted names to lint about. NB: `bar` is not here since it has legitimate uses
     (blacklisted_names, "blacklisted_names": Vec<String>, ["foo", "baz", "quux"].iter().map(ToString::to_string).collect()),
diff --git a/tests/ui/needless_question_mark.fixed b/tests/ui/needless_question_mark.fixed
index fd8433870bb..52ddd9d2dc8 100644
--- a/tests/ui/needless_question_mark.fixed
+++ b/tests/ui/needless_question_mark.fixed
@@ -96,78 +96,6 @@ where
 
 fn main() {}
 
-mod question_mark_none {
-    #![clippy::msrv = "1.12.0"]
-    fn needless_question_mark_option() -> Option<usize> {
-        struct TO {
-            magic: Option<usize>,
-        }
-        let to = TO { magic: None };
-        Some(to.magic?) // should not be triggered
-    }
-
-    fn needless_question_mark_result() -> Result<usize, bool> {
-        struct TO {
-            magic: Result<usize, bool>,
-        }
-        let to = TO { magic: Ok(1_usize) };
-        Ok(to.magic?) // should not be triggered
-    }
-
-    fn main() {
-        needless_question_mark_option();
-        needless_question_mark_result();
-    }
-}
-
-mod question_mark_result {
-    #![clippy::msrv = "1.21.0"]
-    fn needless_question_mark_option() -> Option<usize> {
-        struct TO {
-            magic: Option<usize>,
-        }
-        let to = TO { magic: None };
-        Some(to.magic?) // should not be triggered
-    }
-
-    fn needless_question_mark_result() -> Result<usize, bool> {
-        struct TO {
-            magic: Result<usize, bool>,
-        }
-        let to = TO { magic: Ok(1_usize) };
-        to.magic // should be triggered
-    }
-
-    fn main() {
-        needless_question_mark_option();
-        needless_question_mark_result();
-    }
-}
-
-mod question_mark_both {
-    #![clippy::msrv = "1.22.0"]
-    fn needless_question_mark_option() -> Option<usize> {
-        struct TO {
-            magic: Option<usize>,
-        }
-        let to = TO { magic: None };
-        to.magic // should be triggered
-    }
-
-    fn needless_question_mark_result() -> Result<usize, bool> {
-        struct TO {
-            magic: Result<usize, bool>,
-        }
-        let to = TO { magic: Ok(1_usize) };
-        to.magic // should be triggered
-    }
-
-    fn main() {
-        needless_question_mark_option();
-        needless_question_mark_result();
-    }
-}
-
 // #6921 if a macro wraps an expr in Some(  ) and the ? is in the macro use,
 // the suggestion fails to apply; do not lint
 macro_rules! some_in_macro {
diff --git a/tests/ui/needless_question_mark.rs b/tests/ui/needless_question_mark.rs
index 36d45ac7e03..1ea4ba0d83f 100644
--- a/tests/ui/needless_question_mark.rs
+++ b/tests/ui/needless_question_mark.rs
@@ -96,78 +96,6 @@ where
 
 fn main() {}
 
-mod question_mark_none {
-    #![clippy::msrv = "1.12.0"]
-    fn needless_question_mark_option() -> Option<usize> {
-        struct TO {
-            magic: Option<usize>,
-        }
-        let to = TO { magic: None };
-        Some(to.magic?) // should not be triggered
-    }
-
-    fn needless_question_mark_result() -> Result<usize, bool> {
-        struct TO {
-            magic: Result<usize, bool>,
-        }
-        let to = TO { magic: Ok(1_usize) };
-        Ok(to.magic?) // should not be triggered
-    }
-
-    fn main() {
-        needless_question_mark_option();
-        needless_question_mark_result();
-    }
-}
-
-mod question_mark_result {
-    #![clippy::msrv = "1.21.0"]
-    fn needless_question_mark_option() -> Option<usize> {
-        struct TO {
-            magic: Option<usize>,
-        }
-        let to = TO { magic: None };
-        Some(to.magic?) // should not be triggered
-    }
-
-    fn needless_question_mark_result() -> Result<usize, bool> {
-        struct TO {
-            magic: Result<usize, bool>,
-        }
-        let to = TO { magic: Ok(1_usize) };
-        Ok(to.magic?) // should be triggered
-    }
-
-    fn main() {
-        needless_question_mark_option();
-        needless_question_mark_result();
-    }
-}
-
-mod question_mark_both {
-    #![clippy::msrv = "1.22.0"]
-    fn needless_question_mark_option() -> Option<usize> {
-        struct TO {
-            magic: Option<usize>,
-        }
-        let to = TO { magic: None };
-        Some(to.magic?) // should be triggered
-    }
-
-    fn needless_question_mark_result() -> Result<usize, bool> {
-        struct TO {
-            magic: Result<usize, bool>,
-        }
-        let to = TO { magic: Ok(1_usize) };
-        Ok(to.magic?) // should be triggered
-    }
-
-    fn main() {
-        needless_question_mark_option();
-        needless_question_mark_result();
-    }
-}
-
 // #6921 if a macro wraps an expr in Some(  ) and the ? is in the macro use,
 // the suggestion fails to apply; do not lint
 macro_rules! some_in_macro {
diff --git a/tests/ui/needless_question_mark.stderr b/tests/ui/needless_question_mark.stderr
index 7cbf1e505ad..afd68d91e51 100644
--- a/tests/ui/needless_question_mark.stderr
+++ b/tests/ui/needless_question_mark.stderr
@@ -67,25 +67,7 @@ LL |         return Ok(t.magic?);
    |                ^^^^^^^^^^^^ help: try: `t.magic`
 
 error: question mark operator is useless here
-  --> $DIR/needless_question_mark.rs:138:9
-   |
-LL |         Ok(to.magic?) // should be triggered
-   |         ^^^^^^^^^^^^^ help: try: `to.magic`
-
-error: question mark operator is useless here
-  --> $DIR/needless_question_mark.rs:154:9
-   |
-LL |         Some(to.magic?) // should be triggered
-   |         ^^^^^^^^^^^^^^^ help: try: `to.magic`
-
-error: question mark operator is useless here
-  --> $DIR/needless_question_mark.rs:162:9
-   |
-LL |         Ok(to.magic?) // should be triggered
-   |         ^^^^^^^^^^^^^ help: try: `to.magic`
-
-error: question mark operator is useless here
-  --> $DIR/needless_question_mark.rs:187:27
+  --> $DIR/needless_question_mark.rs:115:27
    |
 LL |         || -> Option<_> { Some(Some($expr)?) }()
    |                           ^^^^^^^^^^^^^^^^^^ help: try: `Some($expr)`
@@ -95,5 +77,5 @@ LL |     let _x = some_and_qmark_in_macro!(x?);
    |
    = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to 15 previous errors
+error: aborting due to 12 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 340b570ea0479dc3a9f9bbe1031f8686c9f660e1 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Mon, 26 Apr 2021 14:10:32 -0500
Subject: Refactor MSRV aliases

---
 clippy_lints/src/casts/ptr_as_ptr.rs               |  6 ++---
 clippy_lints/src/checked_conversions.rs            |  6 ++---
 clippy_lints/src/from_over_into.rs                 |  6 ++---
 clippy_lints/src/if_then_some_else_none.rs         |  6 ++---
 clippy_lints/src/manual_non_exhaustive.rs          |  6 ++---
 clippy_lints/src/manual_strip.rs                   |  6 ++---
 clippy_lints/src/matches.rs                        |  9 +++----
 clippy_lints/src/mem_replace.rs                    |  6 ++---
 .../src/methods/cloned_instead_of_copied.rs        |  9 +++----
 clippy_lints/src/methods/filter_map_next.rs        |  6 ++---
 clippy_lints/src/methods/map_unwrap_or.rs          | 11 ++++----
 clippy_lints/src/methods/option_as_ref_deref.rs    |  6 ++---
 clippy_lints/src/missing_const_for_fn.rs           |  6 ++---
 clippy_lints/src/ranges.rs                         |  6 ++---
 clippy_lints/src/redundant_field_names.rs          |  6 ++---
 clippy_lints/src/redundant_static_lifetimes.rs     |  6 ++---
 clippy_lints/src/unnested_or_patterns.rs           | 17 +++++--------
 clippy_lints/src/use_self.rs                       | 11 ++++----
 clippy_utils/src/lib.rs                            |  1 +
 clippy_utils/src/msrvs.rs                          | 29 ++++++++++++++++++++++
 20 files changed, 80 insertions(+), 85 deletions(-)
 create mode 100644 clippy_utils/src/msrvs.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/ptr_as_ptr.rs b/clippy_lints/src/casts/ptr_as_ptr.rs
index 9113e5a0920..3132d3a5cf0 100644
--- a/clippy_lints/src/casts/ptr_as_ptr.rs
+++ b/clippy_lints/src/casts/ptr_as_ptr.rs
@@ -1,8 +1,8 @@
 use std::borrow::Cow;
 
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::meets_msrv;
 use clippy_utils::sugg::Sugg;
+use clippy_utils::{meets_msrv, msrvs};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, Mutability, TyKind};
@@ -12,10 +12,8 @@ use rustc_semver::RustcVersion;
 
 use super::PTR_AS_PTR;
 
-const PTR_AS_PTR_MSRV: RustcVersion = RustcVersion::new(1, 38, 0);
-
 pub(super) fn check(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, msrv: &Option<RustcVersion>) {
-    if !meets_msrv(msrv.as_ref(), &PTR_AS_PTR_MSRV) {
+    if !meets_msrv(msrv.as_ref(), &msrvs::POINTER_CAST) {
         return;
     }
 
diff --git a/clippy_lints/src/checked_conversions.rs b/clippy_lints/src/checked_conversions.rs
index 6a2666bc6c0..8d3123e1ec8 100644
--- a/clippy_lints/src/checked_conversions.rs
+++ b/clippy_lints/src/checked_conversions.rs
@@ -2,7 +2,7 @@
 
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::{meets_msrv, SpanlessEq};
+use clippy_utils::{meets_msrv, msrvs, SpanlessEq};
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
@@ -12,8 +12,6 @@ use rustc_middle::lint::in_external_macro;
 use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 
-const CHECKED_CONVERSIONS_MSRV: RustcVersion = RustcVersion::new(1, 34, 0);
-
 declare_clippy_lint! {
     /// **What it does:** Checks for explicit bounds checking when casting.
     ///
@@ -58,7 +56,7 @@ impl_lint_pass!(CheckedConversions => [CHECKED_CONVERSIONS]);
 
 impl<'tcx> LateLintPass<'tcx> for CheckedConversions {
     fn check_expr(&mut self, cx: &LateContext<'_>, item: &Expr<'_>) {
-        if !meets_msrv(self.msrv.as_ref(), &CHECKED_CONVERSIONS_MSRV) {
+        if !meets_msrv(self.msrv.as_ref(), &msrvs::TRY_FROM) {
             return;
         }
 
diff --git a/clippy_lints/src/from_over_into.rs b/clippy_lints/src/from_over_into.rs
index 5e2baba8943..3560672a748 100644
--- a/clippy_lints/src/from_over_into.rs
+++ b/clippy_lints/src/from_over_into.rs
@@ -1,14 +1,12 @@
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::paths::INTO;
-use clippy_utils::{match_def_path, meets_msrv};
+use clippy_utils::{match_def_path, meets_msrv, msrvs};
 use if_chain::if_chain;
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 
-const FROM_OVER_INTO_MSRV: RustcVersion = RustcVersion::new(1, 41, 0);
-
 declare_clippy_lint! {
     /// **What it does:** Searches for implementations of the `Into<..>` trait and suggests to implement `From<..>` instead.
     ///
@@ -57,7 +55,7 @@ impl_lint_pass!(FromOverInto => [FROM_OVER_INTO]);
 
 impl LateLintPass<'_> for FromOverInto {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) {
-        if !meets_msrv(self.msrv.as_ref(), &FROM_OVER_INTO_MSRV) {
+        if !meets_msrv(self.msrv.as_ref(), &msrvs::RE_REBALANCING_COHERENCE) {
             return;
         }
 
diff --git a/clippy_lints/src/if_then_some_else_none.rs b/clippy_lints/src/if_then_some_else_none.rs
index 85c95f1151f..eadcd0867a8 100644
--- a/clippy_lints/src/if_then_some_else_none.rs
+++ b/clippy_lints/src/if_then_some_else_none.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::source::snippet_with_macro_callsite;
-use clippy_utils::{is_else_clause, is_lang_ctor, meets_msrv};
+use clippy_utils::{is_else_clause, is_lang_ctor, meets_msrv, msrvs};
 use if_chain::if_chain;
 use rustc_hir::LangItem::{OptionNone, OptionSome};
 use rustc_hir::{Expr, ExprKind};
@@ -9,8 +9,6 @@ use rustc_middle::lint::in_external_macro;
 use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 
-const IF_THEN_SOME_ELSE_NONE_MSRV: RustcVersion = RustcVersion::new(1, 50, 0);
-
 declare_clippy_lint! {
     /// **What it does:** Checks for if-else that could be written to `bool::then`.
     ///
@@ -59,7 +57,7 @@ impl_lint_pass!(IfThenSomeElseNone => [IF_THEN_SOME_ELSE_NONE]);
 
 impl LateLintPass<'_> for IfThenSomeElseNone {
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &'tcx Expr<'_>) {
-        if !meets_msrv(self.msrv.as_ref(), &IF_THEN_SOME_ELSE_NONE_MSRV) {
+        if !meets_msrv(self.msrv.as_ref(), &msrvs::BOOL_THEN) {
             return;
         }
 
diff --git a/clippy_lints/src/manual_non_exhaustive.rs b/clippy_lints/src/manual_non_exhaustive.rs
index dc19805b50a..54f714b54b6 100644
--- a/clippy_lints/src/manual_non_exhaustive.rs
+++ b/clippy_lints/src/manual_non_exhaustive.rs
@@ -1,7 +1,7 @@
 use clippy_utils::attrs::is_doc_hidden;
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::meets_msrv;
 use clippy_utils::source::snippet_opt;
+use clippy_utils::{meets_msrv, msrvs};
 use if_chain::if_chain;
 use rustc_ast::ast::{FieldDef, Item, ItemKind, Variant, VariantData, VisibilityKind};
 use rustc_errors::Applicability;
@@ -10,8 +10,6 @@ use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::{sym, Span};
 
-const MANUAL_NON_EXHAUSTIVE_MSRV: RustcVersion = RustcVersion::new(1, 40, 0);
-
 declare_clippy_lint! {
     /// **What it does:** Checks for manual implementations of the non-exhaustive pattern.
     ///
@@ -76,7 +74,7 @@ impl_lint_pass!(ManualNonExhaustive => [MANUAL_NON_EXHAUSTIVE]);
 
 impl EarlyLintPass for ManualNonExhaustive {
     fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {
-        if !meets_msrv(self.msrv.as_ref(), &MANUAL_NON_EXHAUSTIVE_MSRV) {
+        if !meets_msrv(self.msrv.as_ref(), &msrvs::NON_EXHAUSTIVE) {
             return;
         }
 
diff --git a/clippy_lints/src/manual_strip.rs b/clippy_lints/src/manual_strip.rs
index dfa464ddb81..23428524dee 100644
--- a/clippy_lints/src/manual_strip.rs
+++ b/clippy_lints/src/manual_strip.rs
@@ -2,7 +2,7 @@ use crate::consts::{constant, Constant};
 use clippy_utils::diagnostics::{multispan_sugg, span_lint_and_then};
 use clippy_utils::source::snippet;
 use clippy_utils::usage::mutated_variables;
-use clippy_utils::{eq_expr_value, higher, match_def_path, meets_msrv, paths};
+use clippy_utils::{eq_expr_value, higher, match_def_path, meets_msrv, msrvs, paths};
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
 use rustc_hir::def::Res;
@@ -17,8 +17,6 @@ use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::Spanned;
 use rustc_span::Span;
 
-const MANUAL_STRIP_MSRV: RustcVersion = RustcVersion::new(1, 45, 0);
-
 declare_clippy_lint! {
     /// **What it does:**
     /// Suggests using `strip_{prefix,suffix}` over `str::{starts,ends}_with` and slicing using
@@ -74,7 +72,7 @@ enum StripKind {
 
 impl<'tcx> LateLintPass<'tcx> for ManualStrip {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if !meets_msrv(self.msrv.as_ref(), &MANUAL_STRIP_MSRV) {
+        if !meets_msrv(self.msrv.as_ref(), &msrvs::STR_STRIP_PREFIX) {
             return;
         }
 
diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index 44b4eb29035..13b2a834b0a 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -7,8 +7,9 @@ use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::{implements_trait, is_type_diagnostic_item, match_type, peel_mid_ty_refs};
 use clippy_utils::visitors::LocalUsedVisitor;
 use clippy_utils::{
-    get_parent_expr, in_macro, is_allowed, is_expn_of, is_lang_ctor, is_refutable, is_wild, meets_msrv, path_to_local,
-    path_to_local_id, peel_hir_pat_refs, peel_n_hir_expr_refs, recurse_or_patterns, remove_blocks, strip_pat_refs,
+    get_parent_expr, in_macro, is_allowed, is_expn_of, is_lang_ctor, is_refutable, is_wild, meets_msrv, msrvs,
+    path_to_local, path_to_local_id, peel_hir_pat_refs, peel_n_hir_expr_refs, recurse_or_patterns, remove_blocks,
+    strip_pat_refs,
 };
 use clippy_utils::{paths, search_same, SpanlessEq, SpanlessHash};
 use if_chain::if_chain;
@@ -578,8 +579,6 @@ impl_lint_pass!(Matches => [
     MATCH_SAME_ARMS,
 ]);
 
-const MATCH_LIKE_MATCHES_MACRO_MSRV: RustcVersion = RustcVersion::new(1, 42, 0);
-
 impl<'tcx> LateLintPass<'tcx> for Matches {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if in_external_macro(cx.sess(), expr.span) || in_macro(expr.span) {
@@ -588,7 +587,7 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
 
         redundant_pattern_match::check(cx, expr);
 
-        if meets_msrv(self.msrv.as_ref(), &MATCH_LIKE_MATCHES_MACRO_MSRV) {
+        if meets_msrv(self.msrv.as_ref(), &msrvs::MATCHES_MACRO) {
             if !check_match_like_matches(cx, expr) {
                 lint_match_arms(cx, expr);
             }
diff --git a/clippy_lints/src/mem_replace.rs b/clippy_lints/src/mem_replace.rs
index ec60bffe955..183daee3617 100644
--- a/clippy_lints/src/mem_replace.rs
+++ b/clippy_lints/src/mem_replace.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::{snippet, snippet_with_applicability};
-use clippy_utils::{in_macro, is_diag_trait_item, is_lang_ctor, match_def_path, meets_msrv, paths};
+use clippy_utils::{in_macro, is_diag_trait_item, is_lang_ctor, match_def_path, meets_msrv, msrvs, paths};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::def_id::DefId;
@@ -256,8 +256,6 @@ fn check_replace_with_default(cx: &LateContext<'_>, src: &Expr<'_>, dest: &Expr<
     }
 }
 
-const MEM_REPLACE_WITH_DEFAULT_MSRV: RustcVersion = RustcVersion::new(1, 40, 0);
-
 pub struct MemReplace {
     msrv: Option<RustcVersion>,
 }
@@ -281,7 +279,7 @@ impl<'tcx> LateLintPass<'tcx> for MemReplace {
             then {
                 check_replace_option_with_none(cx, src, dest, expr.span);
                 check_replace_with_uninit(cx, src, dest, expr.span);
-                if meets_msrv(self.msrv.as_ref(), &MEM_REPLACE_WITH_DEFAULT_MSRV) {
+                if meets_msrv(self.msrv.as_ref(), &msrvs::MEM_TAKE) {
                     check_replace_with_default(cx, src, dest, expr.span);
                 }
             }
diff --git a/clippy_lints/src/methods/cloned_instead_of_copied.rs b/clippy_lints/src/methods/cloned_instead_of_copied.rs
index 9c1b6f55c88..ecec6da3aa0 100644
--- a/clippy_lints/src/methods/cloned_instead_of_copied.rs
+++ b/clippy_lints/src/methods/cloned_instead_of_copied.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::ty::{get_iterator_item_ty, is_copy};
-use clippy_utils::{is_trait_method, meets_msrv};
+use clippy_utils::{is_trait_method, meets_msrv, msrvs};
 use rustc_errors::Applicability;
 use rustc_hir::Expr;
 use rustc_lint::LateContext;
@@ -10,19 +10,16 @@ use rustc_span::{sym, Span};
 
 use super::CLONED_INSTEAD_OF_COPIED;
 
-const ITERATOR_COPIED_MSRV: RustcVersion = RustcVersion::new(1, 36, 0);
-const OPTION_COPIED_MSRV: RustcVersion = RustcVersion::new(1, 35, 0);
-
 pub fn check(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'_>, span: Span, msrv: Option<&RustcVersion>) {
     let recv_ty = cx.typeck_results().expr_ty_adjusted(recv);
     let inner_ty = match recv_ty.kind() {
         // `Option<T>` -> `T`
         ty::Adt(adt, subst)
-            if cx.tcx.is_diagnostic_item(sym::option_type, adt.did) && meets_msrv(msrv, &OPTION_COPIED_MSRV) =>
+            if cx.tcx.is_diagnostic_item(sym::option_type, adt.did) && meets_msrv(msrv, &msrvs::OPTION_COPIED) =>
         {
             subst.type_at(0)
         },
-        _ if is_trait_method(cx, expr, sym::Iterator) && meets_msrv(msrv, &ITERATOR_COPIED_MSRV) => {
+        _ if is_trait_method(cx, expr, sym::Iterator) && meets_msrv(msrv, &msrvs::ITERATOR_COPIED) => {
             match get_iterator_item_ty(cx, recv_ty) {
                 // <T as Iterator>::Item
                 Some(ty) => ty,
diff --git a/clippy_lints/src/methods/filter_map_next.rs b/clippy_lints/src/methods/filter_map_next.rs
index 2b19e4ee8c0..f0d69a1f42e 100644
--- a/clippy_lints/src/methods/filter_map_next.rs
+++ b/clippy_lints/src/methods/filter_map_next.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg};
 use clippy_utils::source::snippet;
-use clippy_utils::{is_trait_method, meets_msrv};
+use clippy_utils::{is_trait_method, meets_msrv, msrvs};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
@@ -9,8 +9,6 @@ use rustc_span::sym;
 
 use super::FILTER_MAP_NEXT;
 
-const FILTER_MAP_NEXT_MSRV: RustcVersion = RustcVersion::new(1, 30, 0);
-
 pub(super) fn check<'tcx>(
     cx: &LateContext<'tcx>,
     expr: &'tcx hir::Expr<'_>,
@@ -19,7 +17,7 @@ pub(super) fn check<'tcx>(
     msrv: Option<&RustcVersion>,
 ) {
     if is_trait_method(cx, expr, sym::Iterator) {
-        if !meets_msrv(msrv, &FILTER_MAP_NEXT_MSRV) {
+        if !meets_msrv(msrv, &msrvs::ITERATOR_FIND_MAP) {
             return;
         }
 
diff --git a/clippy_lints/src/methods/map_unwrap_or.rs b/clippy_lints/src/methods/map_unwrap_or.rs
index 4330fea727b..4d8365fcda1 100644
--- a/clippy_lints/src/methods/map_unwrap_or.rs
+++ b/clippy_lints/src/methods/map_unwrap_or.rs
@@ -1,8 +1,8 @@
 use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg};
-use clippy_utils::meets_msrv;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::usage::mutated_variables;
+use clippy_utils::{meets_msrv, msrvs};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
@@ -11,8 +11,6 @@ use rustc_span::symbol::sym;
 
 use super::MAP_UNWRAP_OR;
 
-const MAP_UNWRAP_OR_MSRV: RustcVersion = RustcVersion::new(1, 41, 0);
-
 /// lint use of `map().unwrap_or_else()` for `Option`s and `Result`s
 /// Return true if lint triggered
 pub(super) fn check<'tcx>(
@@ -23,13 +21,14 @@ pub(super) fn check<'tcx>(
     unwrap_arg: &'tcx hir::Expr<'_>,
     msrv: Option<&RustcVersion>,
 ) -> bool {
-    if !meets_msrv(msrv, &MAP_UNWRAP_OR_MSRV) {
-        return false;
-    }
     // lint if the caller of `map()` is an `Option`
     let is_option = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(recv), sym::option_type);
     let is_result = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(recv), sym::result_type);
 
+    if is_result && !meets_msrv(msrv, &msrvs::RESULT_MAP_OR_ELSE) {
+        return false;
+    }
+
     if is_option || is_result {
         // Don't make a suggestion that may fail to compile due to mutably borrowing
         // the same variable twice.
diff --git a/clippy_lints/src/methods/option_as_ref_deref.rs b/clippy_lints/src/methods/option_as_ref_deref.rs
index 7e9c8fa829d..5a57135038f 100644
--- a/clippy_lints/src/methods/option_as_ref_deref.rs
+++ b/clippy_lints/src/methods/option_as_ref_deref.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{match_def_path, meets_msrv, path_to_local_id, paths, remove_blocks};
+use clippy_utils::{match_def_path, meets_msrv, msrvs, path_to_local_id, paths, remove_blocks};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
@@ -12,8 +12,6 @@ use rustc_span::sym;
 
 use super::OPTION_AS_REF_DEREF;
 
-const OPTION_AS_REF_DEREF_MSRV: RustcVersion = RustcVersion::new(1, 40, 0);
-
 /// lint use of `_.as_ref().map(Deref::deref)` for `Option`s
 pub(super) fn check<'tcx>(
     cx: &LateContext<'tcx>,
@@ -23,7 +21,7 @@ pub(super) fn check<'tcx>(
     is_mut: bool,
     msrv: Option<&RustcVersion>,
 ) {
-    if !meets_msrv(msrv, &OPTION_AS_REF_DEREF_MSRV) {
+    if !meets_msrv(msrv, &msrvs::OPTION_AS_DEREF) {
         return;
     }
 
diff --git a/clippy_lints/src/missing_const_for_fn.rs b/clippy_lints/src/missing_const_for_fn.rs
index 93b7a897405..27b5a07c1bc 100644
--- a/clippy_lints/src/missing_const_for_fn.rs
+++ b/clippy_lints/src/missing_const_for_fn.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::qualify_min_const_fn::is_min_const_fn;
 use clippy_utils::ty::has_drop;
-use clippy_utils::{fn_has_unsatisfiable_preds, is_entrypoint_fn, meets_msrv, trait_ref_of_method};
+use clippy_utils::{fn_has_unsatisfiable_preds, is_entrypoint_fn, meets_msrv, msrvs, trait_ref_of_method};
 use rustc_hir as hir;
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::{Body, Constness, FnDecl, GenericParamKind, HirId};
@@ -12,8 +12,6 @@ use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::Span;
 use rustc_typeck::hir_ty_to_ty;
 
-const MISSING_CONST_FOR_FN_MSRV: RustcVersion = RustcVersion::new(1, 37, 0);
-
 declare_clippy_lint! {
     /// **What it does:**
     ///
@@ -97,7 +95,7 @@ impl<'tcx> LateLintPass<'tcx> for MissingConstForFn {
         span: Span,
         hir_id: HirId,
     ) {
-        if !meets_msrv(self.msrv.as_ref(), &MISSING_CONST_FOR_FN_MSRV) {
+        if !meets_msrv(self.msrv.as_ref(), &msrvs::CONST_IF_MATCH) {
             return;
         }
 
diff --git a/clippy_lints/src/ranges.rs b/clippy_lints/src/ranges.rs
index 1c3c125e579..7169f96eaf1 100644
--- a/clippy_lints/src/ranges.rs
+++ b/clippy_lints/src/ranges.rs
@@ -2,7 +2,7 @@ use crate::consts::{constant, Constant};
 use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::{snippet, snippet_opt, snippet_with_applicability};
 use clippy_utils::sugg::Sugg;
-use clippy_utils::{get_parent_expr, in_constant, is_integer_const, meets_msrv, single_segment_path};
+use clippy_utils::{get_parent_expr, in_constant, is_integer_const, meets_msrv, msrvs, single_segment_path};
 use clippy_utils::{higher, SpanlessEq};
 use if_chain::if_chain;
 use rustc_ast::ast::RangeLimits;
@@ -159,8 +159,6 @@ declare_clippy_lint! {
     "manually reimplementing {`Range`, `RangeInclusive`}`::contains`"
 }
 
-const MANUAL_RANGE_CONTAINS_MSRV: RustcVersion = RustcVersion::new(1, 35, 0);
-
 pub struct Ranges {
     msrv: Option<RustcVersion>,
 }
@@ -187,7 +185,7 @@ impl<'tcx> LateLintPass<'tcx> for Ranges {
                 check_range_zip_with_len(cx, path, args, expr.span);
             },
             ExprKind::Binary(ref op, l, r) => {
-                if meets_msrv(self.msrv.as_ref(), &MANUAL_RANGE_CONTAINS_MSRV) {
+                if meets_msrv(self.msrv.as_ref(), &msrvs::RANGE_CONTAINS) {
                     check_possible_range_contains(cx, op.node, l, r, expr);
                 }
             },
diff --git a/clippy_lints/src/redundant_field_names.rs b/clippy_lints/src/redundant_field_names.rs
index abebd422797..d5ee8d3468d 100644
--- a/clippy_lints/src/redundant_field_names.rs
+++ b/clippy_lints/src/redundant_field_names.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::meets_msrv;
+use clippy_utils::{meets_msrv, msrvs};
 use rustc_ast::ast::{Expr, ExprKind};
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass};
@@ -7,8 +7,6 @@ use rustc_middle::lint::in_external_macro;
 use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 
-const REDUNDANT_FIELD_NAMES_MSRV: RustcVersion = RustcVersion::new(1, 17, 0);
-
 declare_clippy_lint! {
     /// **What it does:** Checks for fields in struct literals where shorthands
     /// could be used.
@@ -52,7 +50,7 @@ impl_lint_pass!(RedundantFieldNames => [REDUNDANT_FIELD_NAMES]);
 
 impl EarlyLintPass for RedundantFieldNames {
     fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
-        if !meets_msrv(self.msrv.as_ref(), &REDUNDANT_FIELD_NAMES_MSRV) {
+        if !meets_msrv(self.msrv.as_ref(), &msrvs::FIELD_INIT_SHORTHAND) {
             return;
         }
 
diff --git a/clippy_lints/src/redundant_static_lifetimes.rs b/clippy_lints/src/redundant_static_lifetimes.rs
index 32b57698ec5..48107d9c037 100644
--- a/clippy_lints/src/redundant_static_lifetimes.rs
+++ b/clippy_lints/src/redundant_static_lifetimes.rs
@@ -1,14 +1,12 @@
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::meets_msrv;
 use clippy_utils::source::snippet;
+use clippy_utils::{meets_msrv, msrvs};
 use rustc_ast::ast::{Item, ItemKind, Ty, TyKind};
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 
-const REDUNDANT_STATIC_LIFETIMES_MSRV: RustcVersion = RustcVersion::new(1, 17, 0);
-
 declare_clippy_lint! {
     /// **What it does:** Checks for constants and statics with an explicit `'static` lifetime.
     ///
@@ -100,7 +98,7 @@ impl RedundantStaticLifetimes {
 
 impl EarlyLintPass for RedundantStaticLifetimes {
     fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {
-        if !meets_msrv(self.msrv.as_ref(), &REDUNDANT_STATIC_LIFETIMES_MSRV) {
+        if !meets_msrv(self.msrv.as_ref(), &msrvs::STATIC_IN_CONST) {
             return;
         }
 
diff --git a/clippy_lints/src/unnested_or_patterns.rs b/clippy_lints/src/unnested_or_patterns.rs
index 9376a2cf66a..3e985fa72b8 100644
--- a/clippy_lints/src/unnested_or_patterns.rs
+++ b/clippy_lints/src/unnested_or_patterns.rs
@@ -1,11 +1,8 @@
 #![allow(clippy::wildcard_imports, clippy::enum_glob_use)]
 
+use clippy_utils::ast_utils::{eq_field_pat, eq_id, eq_pat, eq_path};
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::over;
-use clippy_utils::{
-    ast_utils::{eq_field_pat, eq_id, eq_pat, eq_path},
-    meets_msrv,
-};
+use clippy_utils::{meets_msrv, msrvs, over};
 use rustc_ast::mut_visit::*;
 use rustc_ast::ptr::P;
 use rustc_ast::{self as ast, Pat, PatKind, PatKind::*, DUMMY_NODE_ID};
@@ -54,8 +51,6 @@ declare_clippy_lint! {
     "unnested or-patterns, e.g., `Foo(Bar) | Foo(Baz) instead of `Foo(Bar | Baz)`"
 }
 
-const UNNESTED_OR_PATTERNS_MSRV: RustcVersion = RustcVersion::new(1, 53, 0);
-
 #[derive(Clone, Copy)]
 pub struct UnnestedOrPatterns {
     msrv: Option<RustcVersion>,
@@ -72,13 +67,13 @@ impl_lint_pass!(UnnestedOrPatterns => [UNNESTED_OR_PATTERNS]);
 
 impl EarlyLintPass for UnnestedOrPatterns {
     fn check_arm(&mut self, cx: &EarlyContext<'_>, a: &ast::Arm) {
-        if meets_msrv(self.msrv.as_ref(), &UNNESTED_OR_PATTERNS_MSRV) {
+        if meets_msrv(self.msrv.as_ref(), &msrvs::OR_PATTERNS) {
             lint_unnested_or_patterns(cx, &a.pat);
         }
     }
 
     fn check_expr(&mut self, cx: &EarlyContext<'_>, e: &ast::Expr) {
-        if meets_msrv(self.msrv.as_ref(), &UNNESTED_OR_PATTERNS_MSRV) {
+        if meets_msrv(self.msrv.as_ref(), &msrvs::OR_PATTERNS) {
             if let ast::ExprKind::Let(pat, _) = &e.kind {
                 lint_unnested_or_patterns(cx, pat);
             }
@@ -86,13 +81,13 @@ impl EarlyLintPass for UnnestedOrPatterns {
     }
 
     fn check_param(&mut self, cx: &EarlyContext<'_>, p: &ast::Param) {
-        if meets_msrv(self.msrv.as_ref(), &UNNESTED_OR_PATTERNS_MSRV) {
+        if meets_msrv(self.msrv.as_ref(), &msrvs::OR_PATTERNS) {
             lint_unnested_or_patterns(cx, &p.pat);
         }
     }
 
     fn check_local(&mut self, cx: &EarlyContext<'_>, l: &ast::Local) {
-        if meets_msrv(self.msrv.as_ref(), &UNNESTED_OR_PATTERNS_MSRV) {
+        if meets_msrv(self.msrv.as_ref(), &msrvs::OR_PATTERNS) {
             lint_unnested_or_patterns(cx, &l.pat);
         }
     }
diff --git a/clippy_lints/src/use_self.rs b/clippy_lints/src/use_self.rs
index c6a3c58a9a2..aa4d16633ff 100644
--- a/clippy_lints/src/use_self.rs
+++ b/clippy_lints/src/use_self.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_opt;
-use clippy_utils::{in_macro, meets_msrv};
+use clippy_utils::{in_macro, meets_msrv, msrvs};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
@@ -62,8 +62,6 @@ pub struct UseSelf {
     stack: Vec<StackItem>,
 }
 
-const USE_SELF_MSRV: RustcVersion = RustcVersion::new(1, 37, 0);
-
 impl UseSelf {
     #[must_use]
     pub fn new(msrv: Option<RustcVersion>) -> Self {
@@ -236,7 +234,10 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
     }
 
     fn check_ty(&mut self, cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>) {
-        if in_macro(hir_ty.span) | in_impl(cx, hir_ty) | !meets_msrv(self.msrv.as_ref(), &USE_SELF_MSRV) {
+        if in_macro(hir_ty.span)
+            || in_impl(cx, hir_ty)
+            || !meets_msrv(self.msrv.as_ref(), &msrvs::TYPE_ALIAS_ENUM_VARIANTS)
+        {
             return;
         }
 
@@ -288,7 +289,7 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
             }
         }
 
-        if in_macro(expr.span) | !meets_msrv(self.msrv.as_ref(), &USE_SELF_MSRV) {
+        if in_macro(expr.span) || !meets_msrv(self.msrv.as_ref(), &msrvs::TYPE_ALIAS_ENUM_VARIANTS) {
             return;
         }
 
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index b7017411927..9b60c92bca1 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -38,6 +38,7 @@ pub mod diagnostics;
 pub mod eager_or_lazy;
 pub mod higher;
 mod hir_utils;
+pub mod msrvs;
 pub mod numeric_literal;
 pub mod paths;
 pub mod ptr;
diff --git a/clippy_utils/src/msrvs.rs b/clippy_utils/src/msrvs.rs
new file mode 100644
index 00000000000..00df04c0144
--- /dev/null
+++ b/clippy_utils/src/msrvs.rs
@@ -0,0 +1,29 @@
+use rustc_semver::RustcVersion;
+
+macro_rules! msrv_aliases {
+    ($($major:literal,$minor:literal,$patch:literal {
+        $($name:ident),* $(,)?
+    })*) => {
+        $($(
+        pub const $name: RustcVersion = RustcVersion::new($major, $minor, $patch);
+        )*)*
+    };
+}
+
+// names may refer to stabilized feature flags or library items
+msrv_aliases! {
+    1,53,0 { OR_PATTERNS }
+    1,50,0 { BOOL_THEN }
+    1,46,0 { CONST_IF_MATCH }
+    1,45,0 { STR_STRIP_PREFIX }
+    1,42,0 { MATCHES_MACRO }
+    1,41,0 { RE_REBALANCING_COHERENCE, RESULT_MAP_OR_ELSE }
+    1,40,0 { MEM_TAKE, NON_EXHAUSTIVE, OPTION_AS_DEREF }
+    1,38,0 { POINTER_CAST }
+    1,37,0 { TYPE_ALIAS_ENUM_VARIANTS }
+    1,36,0 { ITERATOR_COPIED }
+    1,35,0 { OPTION_COPIED, RANGE_CONTAINS }
+    1,34,0 { TRY_FROM }
+    1,30,0 { ITERATOR_FIND_MAP }
+    1,17,0 { FIELD_INIT_SHORTHAND, STATIC_IN_CONST }
+}
-- 
cgit 1.4.1-3-g733a5


From 572c405da063d2628378b74a8f659ce90e0e7779 Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Tue, 27 Apr 2021 23:16:19 +0200
Subject: fix ice when checking rustc libstd

thread 'rustc' panicked at 'index out of bounds: the len is 0 but the index is 0', src/tools/clippy/clippy_lints/src/matches.rs:1595:53
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

I don't have a minimised testcase because I don't have time to reduce libstd down to a few lines right now.
---
 clippy_lints/src/matches.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index 13b2a834b0a..c7a25095bf6 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -1590,9 +1590,9 @@ fn is_none_arm(cx: &LateContext<'_>, arm: &Arm<'_>) -> bool {
 // Checks if arm has the form `Some(ref v) => Some(v)` (checks for `ref` and `ref mut`)
 fn is_ref_some_arm(cx: &LateContext<'_>, arm: &Arm<'_>) -> Option<BindingAnnotation> {
     if_chain! {
-        if let PatKind::TupleStruct(ref qpath, pats, _) = arm.pat.kind;
+        if let PatKind::TupleStruct(ref qpath, [first_pat, ..], _) = arm.pat.kind;
         if is_lang_ctor(cx, qpath, OptionSome);
-        if let PatKind::Binding(rb, .., ident, _) = pats[0].kind;
+        if let PatKind::Binding(rb, .., ident, _) = first_pat.kind;
         if rb == BindingAnnotation::Ref || rb == BindingAnnotation::RefMut;
         if let ExprKind::Call(e, args) = remove_blocks(arm.body).kind;
         if let ExprKind::Path(ref some_path) = e.kind;
-- 
cgit 1.4.1-3-g733a5


From 32351d6b9f7caa2fd197a23a190fb32392ab9dfd Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Wed, 28 Apr 2021 14:29:13 -0500
Subject: Remove leftover plugin conf_file code

---
 clippy_lints/src/lib.rs        | 75 +++++++++++++++++-------------------------
 clippy_lints/src/utils/conf.rs | 23 -------------
 src/driver.rs                  |  2 +-
 3 files changed, 31 insertions(+), 69 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index c84890299df..57843afaddb 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -399,56 +399,41 @@ pub fn register_pre_expansion_lints(store: &mut rustc_lint::LintStore) {
 }
 
 #[doc(hidden)]
-pub fn read_conf(args: &[rustc_ast::NestedMetaItem], sess: &Session) -> Conf {
+pub fn read_conf(sess: &Session) -> Conf {
     use std::path::Path;
-    match utils::conf::file_from_args(args) {
-        Ok(file_name) => {
-            // if the user specified a file, it must exist, otherwise default to `clippy.toml` but
-            // do not require the file to exist
-            let file_name = match file_name {
-                Some(file_name) => file_name,
-                None => match utils::conf::lookup_conf_file() {
-                    Ok(Some(path)) => path,
-                    Ok(None) => return Conf::default(),
-                    Err(error) => {
-                        sess.struct_err(&format!("error finding Clippy's configuration file: {}", error))
-                            .emit();
-                        return Conf::default();
-                    },
-                },
-            };
-
-            let file_name = if file_name.is_relative() {
-                sess.local_crate_source_file
-                    .as_deref()
-                    .and_then(Path::parent)
-                    .unwrap_or_else(|| Path::new(""))
-                    .join(file_name)
-            } else {
-                file_name
-            };
+    let file_name = match utils::conf::lookup_conf_file() {
+        Ok(Some(path)) => path,
+        Ok(None) => return Conf::default(),
+        Err(error) => {
+            sess.struct_err(&format!("error finding Clippy's configuration file: {}", error))
+                .emit();
+            return Conf::default();
+        },
+    };
 
-            let (conf, errors) = utils::conf::read(&file_name);
+    let file_name = if file_name.is_relative() {
+        sess.local_crate_source_file
+            .as_deref()
+            .and_then(Path::parent)
+            .unwrap_or_else(|| Path::new(""))
+            .join(file_name)
+    } else {
+        file_name
+    };
 
-            // all conf errors are non-fatal, we just use the default conf in case of error
-            for error in errors {
-                sess.struct_err(&format!(
-                    "error reading Clippy's configuration file `{}`: {}",
-                    file_name.display(),
-                    error
-                ))
-                .emit();
-            }
+    let (conf, errors) = utils::conf::read(&file_name);
 
-            conf
-        },
-        Err((err, span)) => {
-            sess.struct_span_err(span, err)
-                .span_note(span, "Clippy will use default configuration")
-                .emit();
-            Conf::default()
-        },
+    // all conf errors are non-fatal, we just use the default conf in case of error
+    for error in errors {
+        sess.struct_err(&format!(
+            "error reading Clippy's configuration file `{}`: {}",
+            file_name.display(),
+            error
+        ))
+        .emit();
     }
+
+    conf
 }
 
 /// Register all lints and lint groups with the rustc plugin registry
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index d56855a71c1..e221be63538 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -2,34 +2,11 @@
 
 #![deny(clippy::missing_docs_in_private_items)]
 
-use rustc_ast::ast::{LitKind, MetaItemKind, NestedMetaItem};
-use rustc_span::source_map;
-use source_map::Span;
 use std::lazy::SyncLazy;
 use std::path::{Path, PathBuf};
 use std::sync::Mutex;
 use std::{env, fmt, fs, io};
 
-/// Gets the configuration file from arguments.
-pub fn file_from_args(args: &[NestedMetaItem]) -> Result<Option<PathBuf>, (&'static str, Span)> {
-    for arg in args.iter().filter_map(NestedMetaItem::meta_item) {
-        if arg.has_name(sym!(conf_file)) {
-            return match arg.kind {
-                MetaItemKind::Word | MetaItemKind::List(_) => Err(("`conf_file` must be a named value", arg.span)),
-                MetaItemKind::NameValue(ref value) => {
-                    if let LitKind::Str(ref file, _) = value.kind {
-                        Ok(Some(file.to_string().into()))
-                    } else {
-                        Err(("`conf_file` value must be a string", value.span))
-                    }
-                },
-            };
-        }
-    }
-
-    Ok(None)
-}
-
 /// Error from reading a configuration file.
 #[derive(Debug)]
 pub enum Error {
diff --git a/src/driver.rs b/src/driver.rs
index fa0c5f01430..221474e55d4 100644
--- a/src/driver.rs
+++ b/src/driver.rs
@@ -106,7 +106,7 @@ impl rustc_driver::Callbacks for ClippyCallbacks {
                 (previous)(sess, lint_store);
             }
 
-            let conf = clippy_lints::read_conf(&[], sess);
+            let conf = clippy_lints::read_conf(sess);
             clippy_lints::register_plugins(lint_store, sess, &conf);
             clippy_lints::register_pre_expansion_lints(lint_store);
             clippy_lints::register_renamed(lint_store);
-- 
cgit 1.4.1-3-g733a5


From 63425de77db7f4dee55cfceeed7e174bfe986b0d Mon Sep 17 00:00:00 2001
From: Andre Bogus <bogusandre@gmail.com>
Date: Thu, 29 Apr 2021 10:10:58 +0200
Subject: while_immutable_cond: check condition for mutation

---
 clippy_lints/src/loops/while_immutable_condition.rs | 13 ++++++++-----
 tests/ui/infinite_loop.rs                           | 12 ++++++++++++
 2 files changed, 20 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/while_immutable_condition.rs b/clippy_lints/src/loops/while_immutable_condition.rs
index de267cc77d2..55404b87ec9 100644
--- a/clippy_lints/src/loops/while_immutable_condition.rs
+++ b/clippy_lints/src/loops/while_immutable_condition.rs
@@ -28,11 +28,14 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, cond: &'tcx Expr<'_>, expr: &'
         return;
     }
     let used_in_condition = &var_visitor.ids;
-    let no_cond_variable_mutated = if let Some(used_mutably) = mutated_variables(expr, cx) {
-        used_in_condition.is_disjoint(&used_mutably)
-    } else {
-        return;
-    };
+    let mutated_in_body = mutated_variables(expr, cx);
+    let mutated_in_condition = mutated_variables(cond, cx);
+    let no_cond_variable_mutated =
+        if let (Some(used_mutably_body), Some(used_mutably_cond)) = (mutated_in_body, mutated_in_condition) {
+            used_in_condition.is_disjoint(&used_mutably_body) && used_in_condition.is_disjoint(&used_mutably_cond)
+        } else {
+            return;
+        };
     let mutable_static_in_cond = var_visitor.def_ids.iter().any(|(_, v)| *v);
 
     let mut has_break_or_return_visitor = HasBreakOrReturnVisitor {
diff --git a/tests/ui/infinite_loop.rs b/tests/ui/infinite_loop.rs
index 72591f12baf..3d8fb8507e5 100644
--- a/tests/ui/infinite_loop.rs
+++ b/tests/ui/infinite_loop.rs
@@ -192,11 +192,23 @@ fn while_loop_with_break_and_return() {
     }
 }
 
+fn immutable_condition_false_positive(mut n: u64) -> u32 {
+    let mut count = 0;
+    while {
+        n >>= 1;
+        n != 0
+    } {
+        count += 1;
+    }
+    count
+}
+
 fn main() {
     immutable_condition();
     unused_var();
     used_immutable();
     internally_mutable();
+    immutable_condition_false_positive(5);
 
     let mut c = Counter { count: 0 };
     c.inc_n(5);
-- 
cgit 1.4.1-3-g733a5


From 0dff377a62b3ae24ceb88ff0a9070f3a4e3d5552 Mon Sep 17 00:00:00 2001
From: Takayuki <takoyaki0316@gmail.com>
Date: Fri, 30 Apr 2021 14:40:35 +0900
Subject: use `in_constant`

---
 clippy_lints/src/comparison_chain.rs | 14 +++-----------
 1 file changed, 3 insertions(+), 11 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/comparison_chain.rs b/clippy_lints/src/comparison_chain.rs
index 150d8a3d673..2a61d58e653 100644
--- a/clippy_lints/src/comparison_chain.rs
+++ b/clippy_lints/src/comparison_chain.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::ty::implements_trait;
-use clippy_utils::{get_trait_def_id, if_sequence, is_else_clause, paths, SpanlessEq};
-use rustc_hir::{BinOpKind, Expr, ExprKind, Node};
+use clippy_utils::{get_trait_def_id, if_sequence, in_constant, is_else_clause, paths, SpanlessEq};
+use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
@@ -64,7 +64,7 @@ impl<'tcx> LateLintPass<'tcx> for ComparisonChain {
             return;
         }
 
-        if parent_node_is_if_const_fn(cx, expr) {
+        if in_constant(cx, expr.hir_id) {
             return;
         }
 
@@ -127,11 +127,3 @@ impl<'tcx> LateLintPass<'tcx> for ComparisonChain {
 fn kind_is_cmp(kind: BinOpKind) -> bool {
     matches!(kind, BinOpKind::Lt | BinOpKind::Gt | BinOpKind::Eq)
 }
-
-fn parent_node_is_if_const_fn(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-    match cx.tcx.hir().find(cx.tcx.hir().get_parent_item(expr.hir_id)) {
-        Some(Node::Item(item)) => rustc_mir::const_eval::is_const_fn(cx.tcx, item.def_id.to_def_id()),
-        Some(Node::ImplItem(impl_item)) => rustc_mir::const_eval::is_const_fn(cx.tcx, impl_item.def_id.to_def_id()),
-        _ => false,
-    }
-}
-- 
cgit 1.4.1-3-g733a5


From b9c8e683d609d204fd1192e236a92099d94cbef2 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Tue, 27 Apr 2021 21:03:48 -0500
Subject: Disable default_trait_access in macros

---
 clippy_lints/src/default.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/default.rs b/clippy_lints/src/default.rs
index 710da8fe9e0..7a53d390bb4 100644
--- a/clippy_lints/src/default.rs
+++ b/clippy_lints/src/default.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::{span_lint_and_note, span_lint_and_sugg};
 use clippy_utils::source::snippet_with_macro_callsite;
-use clippy_utils::{any_parent_is_automatically_derived, contains_name, match_def_path, paths};
+use clippy_utils::{any_parent_is_automatically_derived, contains_name, in_macro, match_def_path, paths};
 use if_chain::if_chain;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Applicability;
@@ -75,6 +75,7 @@ impl_lint_pass!(Default => [DEFAULT_TRAIT_ACCESS, FIELD_REASSIGN_WITH_DEFAULT]);
 impl LateLintPass<'_> for Default {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if_chain! {
+            if !in_macro(expr.span);
             // Avoid cases already linted by `field_reassign_with_default`
             if !self.reassigned_linted.contains(&expr.span);
             if let ExprKind::Call(path, ..) = expr.kind;
-- 
cgit 1.4.1-3-g733a5


From 1e22e564e4d272c296a6acb8596831fbaa05bc7b Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Tue, 27 Apr 2021 21:04:06 -0500
Subject: Refactor config deserialization

---
 clippy_lints/src/lib.rs                            |   4 +-
 clippy_lints/src/utils/conf.rs                     | 232 +++++++++------------
 tests/ui-toml/bad_toml_type/conf_bad_type.stderr   |   2 +-
 .../conf_deprecated_key/conf_deprecated_key.stderr |   2 +-
 4 files changed, 108 insertions(+), 132 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 57843afaddb..40a793e48cf 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -382,6 +382,7 @@ mod zero_sized_map_values;
 // end lints modules, do not remove this comment, it’s used in `update_lints`
 
 pub use crate::utils::conf::Conf;
+use crate::utils::conf::TryConf;
 
 /// Register all pre expansion lints
 ///
@@ -421,8 +422,7 @@ pub fn read_conf(sess: &Session) -> Conf {
         file_name
     };
 
-    let (conf, errors) = utils::conf::read(&file_name);
-
+    let TryConf { conf, errors } = utils::conf::read(&file_name);
     // all conf errors are non-fatal, we just use the default conf in case of error
     for error in errors {
         sess.struct_err(&format!(
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index e221be63538..747d92dd742 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -1,98 +1,111 @@
 //! Read configurations files.
 
-#![deny(clippy::missing_docs_in_private_items)]
+#![allow(clippy::module_name_repetitions)]
 
-use std::lazy::SyncLazy;
+use serde::de::{Deserializer, IgnoredAny, IntoDeserializer, MapAccess, Visitor};
+use serde::Deserialize;
+use std::error::Error;
 use std::path::{Path, PathBuf};
-use std::sync::Mutex;
 use std::{env, fmt, fs, io};
 
-/// Error from reading a configuration file.
-#[derive(Debug)]
-pub enum Error {
-    /// An I/O error.
-    Io(io::Error),
-    /// Not valid toml or doesn't fit the expected config format
-    Toml(String),
+/// Conf with parse errors
+#[derive(Default)]
+pub struct TryConf {
+    pub conf: Conf,
+    pub errors: Vec<String>,
 }
 
-impl fmt::Display for Error {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Self::Io(err) => err.fmt(f),
-            Self::Toml(err) => err.fmt(f),
+impl TryConf {
+    fn from_error(error: impl Error) -> Self {
+        Self {
+            conf: Conf::default(),
+            errors: vec![error.to_string()],
         }
     }
 }
 
-impl From<io::Error> for Error {
-    fn from(e: io::Error) -> Self {
-        Self::Io(e)
-    }
-}
+macro_rules! define_Conf {
+    ($(
+        #[$doc:meta]
+        $(#[conf_deprecated($dep:literal)])?
+        ($name:ident: $ty:ty $(= $default:expr)?),
+    )*) => {
+        /// Clippy lint configuration
+        pub struct Conf {
+            $(#[$doc] pub $name: $ty,)*
+        }
 
-/// Vec of errors that might be collected during config toml parsing
-static ERRORS: SyncLazy<Mutex<Vec<Error>>> = SyncLazy::new(|| Mutex::new(Vec::new()));
+        mod defaults {
+            $(pub fn $name() -> $ty { define_Conf!(@default $($default)?) })*
+        }
 
-macro_rules! define_Conf {
-    ($(#[$doc:meta] ($config:ident, $config_str:literal: $Ty:ty, $default:expr),)+) => {
-        mod helpers {
-            use serde::Deserialize;
-            /// Type used to store lint configuration.
-            #[derive(Deserialize)]
-            #[serde(rename_all = "kebab-case", deny_unknown_fields)]
-            pub struct Conf {
-                $(
-                    #[$doc]
-                    #[serde(default = $config_str)]
-                    #[serde(with = $config_str)]
-                    pub $config: $Ty,
-                )+
-                #[allow(dead_code)]
-                #[serde(default)]
-                third_party: Option<::toml::Value>,
+        impl Default for Conf {
+            fn default() -> Self {
+                Self { $($name: defaults::$name(),)* }
             }
+        }
 
-            $(
-                mod $config {
-                    use serde::Deserialize;
-                    pub fn deserialize<'de, D: serde::Deserializer<'de>>(deserializer: D) -> Result<$Ty, D::Error> {
-                        use super::super::{ERRORS, Error};
-
-                        Ok(
-                            <$Ty>::deserialize(deserializer).unwrap_or_else(|e| {
-                                ERRORS
-                                    .lock()
-                                    .expect("no threading here")
-                                    .push(Error::Toml(e.to_string()));
-                                super::$config()
-                            })
-                        )
-                    }
-                }
+        impl<'de> Deserialize<'de> for TryConf {
+            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de> {
+                deserializer.deserialize_map(ConfVisitor)
+            }
+        }
+
+        #[derive(Deserialize)]
+        #[serde(field_identifier, rename_all = "kebab-case")]
+        #[allow(non_camel_case_types)]
+        enum Field { $($name,)* third_party, }
+
+        struct ConfVisitor;
+
+        impl<'de> Visitor<'de> for ConfVisitor {
+            type Value = TryConf;
+
+            fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+                formatter.write_str("Conf")
+            }
 
-                #[must_use]
-                fn $config() -> $Ty {
-                    let x = $default;
-                    x
+            fn visit_map<V>(self, mut map: V) -> Result<Self::Value, V::Error> where V: MapAccess<'de> {
+                let mut errors = Vec::new();
+                $(let mut $name = None;)*
+                // could get `Field` here directly, but get `str` first for diagnostics
+                while let Some(name) = map.next_key::<&str>()? {
+                    match Field::deserialize(name.into_deserializer())? {
+                        $(Field::$name => {
+                            $(errors.push(format!("deprecated field `{}`. {}", name, $dep));)?
+                            match map.next_value() {
+                                Err(e) => errors.push(e.to_string()),
+                                Ok(value) => match $name {
+                                    Some(_) => errors.push(format!("duplicate field `{}`", name)),
+                                    None => $name = Some(value),
+                                }
+                            }
+                        })*
+                        // white-listed; ignore
+                        Field::third_party => drop(map.next_value::<IgnoredAny>())
+                    }
                 }
-            )+
+                let conf = Conf { $($name: $name.unwrap_or_else(defaults::$name),)* };
+                Ok(TryConf { conf, errors })
+            }
         }
     };
+    (@default) => (Default::default());
+    (@default $default:expr) => ($default);
 }
 
-pub use self::helpers::Conf;
 define_Conf! {
     /// Lint: CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR. The minimum rust version that the project supports
-    (msrv, "msrv": Option<String>, None),
+    (msrv: Option<String>),
     /// Lint: BLACKLISTED_NAME. The list of blacklisted names to lint about. NB: `bar` is not here since it has legitimate uses
-    (blacklisted_names, "blacklisted_names": Vec<String>, ["foo", "baz", "quux"].iter().map(ToString::to_string).collect()),
+    (blacklisted_names: Vec<String> = ["foo", "baz", "quux"].iter().map(ToString::to_string).collect()),
     /// Lint: COGNITIVE_COMPLEXITY. The maximum cognitive complexity a function can have
-    (cognitive_complexity_threshold, "cognitive_complexity_threshold": u64, 25),
+    (cognitive_complexity_threshold: u64 = 25),
     /// DEPRECATED LINT: CYCLOMATIC_COMPLEXITY. Use the Cognitive Complexity lint instead.
-    (cyclomatic_complexity_threshold, "cyclomatic_complexity_threshold": Option<u64>, None),
+    #[conf_deprecated("Please use `cognitive-complexity-threshold` instead.")]
+    (cyclomatic_complexity_threshold: Option<u64>),
     /// Lint: DOC_MARKDOWN. The list of words this lint should not consider as identifiers needing ticks
-    (doc_valid_idents, "doc_valid_idents": Vec<String>, [
+    (doc_valid_idents: Vec<String> = [
         "KiB", "MiB", "GiB", "TiB", "PiB", "EiB",
         "DirectX",
         "ECMAScript",
@@ -113,54 +126,47 @@ define_Conf! {
         "CamelCase",
     ].iter().map(ToString::to_string).collect()),
     /// Lint: TOO_MANY_ARGUMENTS. The maximum number of argument a function or method can have
-    (too_many_arguments_threshold, "too_many_arguments_threshold": u64, 7),
+    (too_many_arguments_threshold: u64 = 7),
     /// Lint: TYPE_COMPLEXITY. The maximum complexity a type can have
-    (type_complexity_threshold, "type_complexity_threshold": u64, 250),
+    (type_complexity_threshold: u64 = 250),
     /// Lint: MANY_SINGLE_CHAR_NAMES. The maximum number of single char bindings a scope may have
-    (single_char_binding_names_threshold, "single_char_binding_names_threshold": u64, 4),
+    (single_char_binding_names_threshold: u64 = 4),
     /// Lint: BOXED_LOCAL, USELESS_VEC. The maximum size of objects (in bytes) that will be linted. Larger objects are ok on the heap
-    (too_large_for_stack, "too_large_for_stack": u64, 200),
+    (too_large_for_stack: u64 = 200),
     /// Lint: ENUM_VARIANT_NAMES. The minimum number of enum variants for the lints about variant names to trigger
-    (enum_variant_name_threshold, "enum_variant_name_threshold": u64, 3),
+    (enum_variant_name_threshold: u64 = 3),
     /// Lint: LARGE_ENUM_VARIANT. The maximum size of a enum's variant to avoid box suggestion
-    (enum_variant_size_threshold, "enum_variant_size_threshold": u64, 200),
+    (enum_variant_size_threshold: u64 = 200),
     /// Lint: VERBOSE_BIT_MASK. The maximum allowed size of a bit mask before suggesting to use 'trailing_zeros'
-    (verbose_bit_mask_threshold, "verbose_bit_mask_threshold": u64, 1),
+    (verbose_bit_mask_threshold: u64 = 1),
     /// Lint: DECIMAL_LITERAL_REPRESENTATION. The lower bound for linting decimal literals
-    (literal_representation_threshold, "literal_representation_threshold": u64, 16384),
+    (literal_representation_threshold: u64 = 16384),
     /// Lint: TRIVIALLY_COPY_PASS_BY_REF. The maximum size (in bytes) to consider a `Copy` type for passing by value instead of by reference.
-    (trivial_copy_size_limit, "trivial_copy_size_limit": Option<u64>, None),
+    (trivial_copy_size_limit: Option<u64>),
     /// Lint: LARGE_TYPE_PASS_BY_MOVE. The minimum size (in bytes) to consider a type for passing by reference instead of by value.
-    (pass_by_value_size_limit, "pass_by_value_size_limit": u64, 256),
+    (pass_by_value_size_limit: u64 = 256),
     /// Lint: TOO_MANY_LINES. The maximum number of lines a function or method can have
-    (too_many_lines_threshold, "too_many_lines_threshold": u64, 100),
+    (too_many_lines_threshold: u64 = 100),
     /// Lint: LARGE_STACK_ARRAYS, LARGE_CONST_ARRAYS. The maximum allowed size for arrays on the stack
-    (array_size_threshold, "array_size_threshold": u64, 512_000),
+    (array_size_threshold: u64 = 512_000),
     /// Lint: VEC_BOX. The size of the boxed type in bytes, where boxing in a `Vec` is allowed
-    (vec_box_size_threshold, "vec_box_size_threshold": u64, 4096),
+    (vec_box_size_threshold: u64 = 4096),
     /// Lint: TYPE_REPETITION_IN_BOUNDS. The maximum number of bounds a trait can have to be linted
-    (max_trait_bounds, "max_trait_bounds": u64, 3),
+    (max_trait_bounds: u64 = 3),
     /// Lint: STRUCT_EXCESSIVE_BOOLS. The maximum number of bools a struct can have
-    (max_struct_bools, "max_struct_bools": u64, 3),
+    (max_struct_bools: u64 = 3),
     /// Lint: FN_PARAMS_EXCESSIVE_BOOLS. The maximum number of bools function parameters can have
-    (max_fn_params_bools, "max_fn_params_bools": u64, 3),
+    (max_fn_params_bools: u64 = 3),
     /// Lint: WILDCARD_IMPORTS. Whether to allow certain wildcard imports (prelude, super in tests).
-    (warn_on_all_wildcard_imports, "warn_on_all_wildcard_imports": bool, false),
+    (warn_on_all_wildcard_imports: bool),
     /// Lint: DISALLOWED_METHOD. The list of disallowed methods, written as fully qualified paths.
-    (disallowed_methods, "disallowed_methods": Vec<String>, Vec::<String>::new()),
+    (disallowed_methods: Vec<String>),
     /// Lint: UNREADABLE_LITERAL. Should the fraction of a decimal be linted to include separators.
-    (unreadable_literal_lint_fractions, "unreadable_literal_lint_fractions": bool, true),
+    (unreadable_literal_lint_fractions: bool = true),
     /// Lint: UPPER_CASE_ACRONYMS. Enables verbose mode. Triggers if there is more than one uppercase char next to each other
-    (upper_case_acronyms_aggressive, "upper_case_acronyms_aggressive": bool, false),
+    (upper_case_acronyms_aggressive: bool),
     /// Lint: _CARGO_COMMON_METADATA. For internal testing only, ignores the current `publish` settings in the Cargo manifest.
-    (cargo_ignore_publish, "cargo_ignore_publish": bool, false),
-}
-
-impl Default for Conf {
-    #[must_use]
-    fn default() -> Self {
-        toml::from_str("").expect("we never error on empty config files")
-    }
+    (cargo_ignore_publish: bool),
 }
 
 /// Search for the configuration file.
@@ -194,43 +200,13 @@ pub fn lookup_conf_file() -> io::Result<Option<PathBuf>> {
     }
 }
 
-/// Produces a `Conf` filled with the default values and forwards the errors
-///
-/// Used internally for convenience
-fn default(errors: Vec<Error>) -> (Conf, Vec<Error>) {
-    (Conf::default(), errors)
-}
-
 /// Read the `toml` configuration file.
 ///
 /// In case of error, the function tries to continue as much as possible.
-pub fn read(path: &Path) -> (Conf, Vec<Error>) {
+pub fn read(path: &Path) -> TryConf {
     let content = match fs::read_to_string(path) {
+        Err(e) => return TryConf::from_error(e),
         Ok(content) => content,
-        Err(err) => return default(vec![err.into()]),
     };
-
-    assert!(ERRORS.lock().expect("no threading -> mutex always safe").is_empty());
-    match toml::from_str(&content) {
-        Ok(toml) => {
-            let mut errors = ERRORS.lock().expect("no threading -> mutex always safe").split_off(0);
-
-            let toml_ref: &Conf = &toml;
-
-            let cyc_field: Option<u64> = toml_ref.cyclomatic_complexity_threshold;
-
-            if cyc_field.is_some() {
-                let cyc_err = "found deprecated field `cyclomatic-complexity-threshold`. Please use `cognitive-complexity-threshold` instead.".to_string();
-                errors.push(Error::Toml(cyc_err));
-            }
-
-            (toml, errors)
-        },
-        Err(e) => {
-            let mut errors = ERRORS.lock().expect("no threading -> mutex always safe").split_off(0);
-            errors.push(Error::Toml(e.to_string()));
-
-            default(errors)
-        },
-    }
+    toml::from_str(&content).unwrap_or_else(TryConf::from_error)
 }
diff --git a/tests/ui-toml/bad_toml_type/conf_bad_type.stderr b/tests/ui-toml/bad_toml_type/conf_bad_type.stderr
index efd02bcbb6e..c7bc261de6c 100644
--- a/tests/ui-toml/bad_toml_type/conf_bad_type.stderr
+++ b/tests/ui-toml/bad_toml_type/conf_bad_type.stderr
@@ -1,4 +1,4 @@
-error: error reading Clippy's configuration file `$DIR/clippy.toml`: invalid type: integer `42`, expected a sequence
+error: error reading Clippy's configuration file `$DIR/clippy.toml`: invalid type: integer `42`, expected a sequence for key `blacklisted-names`
 
 error: aborting due to previous error
 
diff --git a/tests/ui-toml/conf_deprecated_key/conf_deprecated_key.stderr b/tests/ui-toml/conf_deprecated_key/conf_deprecated_key.stderr
index 34267c0daf7..8bf9fe64c6d 100644
--- a/tests/ui-toml/conf_deprecated_key/conf_deprecated_key.stderr
+++ b/tests/ui-toml/conf_deprecated_key/conf_deprecated_key.stderr
@@ -1,4 +1,4 @@
-error: error reading Clippy's configuration file `$DIR/clippy.toml`: found deprecated field `cyclomatic-complexity-threshold`. Please use `cognitive-complexity-threshold` instead.
+error: error reading Clippy's configuration file `$DIR/clippy.toml`: deprecated field `cyclomatic-complexity-threshold`. Please use `cognitive-complexity-threshold` instead.
 
 error: aborting due to previous error
 
-- 
cgit 1.4.1-3-g733a5


From 857d9f15da507adbc3e59560f3c15568cd0ae0e5 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Sun, 2 May 2021 16:56:46 -0500
Subject: Fix error punctuation

---
 clippy_lints/src/utils/conf.rs                               | 2 +-
 tests/ui-toml/conf_deprecated_key/conf_deprecated_key.stderr | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 747d92dd742..aeca5b9ccce 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -102,7 +102,7 @@ define_Conf! {
     /// Lint: COGNITIVE_COMPLEXITY. The maximum cognitive complexity a function can have
     (cognitive_complexity_threshold: u64 = 25),
     /// DEPRECATED LINT: CYCLOMATIC_COMPLEXITY. Use the Cognitive Complexity lint instead.
-    #[conf_deprecated("Please use `cognitive-complexity-threshold` instead.")]
+    #[conf_deprecated("Please use `cognitive-complexity-threshold` instead")]
     (cyclomatic_complexity_threshold: Option<u64>),
     /// Lint: DOC_MARKDOWN. The list of words this lint should not consider as identifiers needing ticks
     (doc_valid_idents: Vec<String> = [
diff --git a/tests/ui-toml/conf_deprecated_key/conf_deprecated_key.stderr b/tests/ui-toml/conf_deprecated_key/conf_deprecated_key.stderr
index 8bf9fe64c6d..90021a034a3 100644
--- a/tests/ui-toml/conf_deprecated_key/conf_deprecated_key.stderr
+++ b/tests/ui-toml/conf_deprecated_key/conf_deprecated_key.stderr
@@ -1,4 +1,4 @@
-error: error reading Clippy's configuration file `$DIR/clippy.toml`: deprecated field `cyclomatic-complexity-threshold`. Please use `cognitive-complexity-threshold` instead.
+error: error reading Clippy's configuration file `$DIR/clippy.toml`: deprecated field `cyclomatic-complexity-threshold`. Please use `cognitive-complexity-threshold` instead
 
 error: aborting due to previous error
 
-- 
cgit 1.4.1-3-g733a5


From 499813026f1e84456c9a108b249ed1005c624181 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Sun, 2 May 2021 17:50:22 -0500
Subject: Fix config parsing

---
 clippy_lints/src/utils/conf.rs | 21 ++++++++++-----------
 util/lintlib.py                |  2 +-
 2 files changed, 11 insertions(+), 12 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index aeca5b9ccce..dc079663fc9 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -28,7 +28,7 @@ macro_rules! define_Conf {
     ($(
         #[$doc:meta]
         $(#[conf_deprecated($dep:literal)])?
-        ($name:ident: $ty:ty $(= $default:expr)?),
+        ($name:ident: $ty:ty = $default:expr),
     )*) => {
         /// Clippy lint configuration
         pub struct Conf {
@@ -36,7 +36,7 @@ macro_rules! define_Conf {
         }
 
         mod defaults {
-            $(pub fn $name() -> $ty { define_Conf!(@default $($default)?) })*
+            $(pub fn $name() -> $ty { $default })*
         }
 
         impl Default for Conf {
@@ -90,20 +90,19 @@ macro_rules! define_Conf {
             }
         }
     };
-    (@default) => (Default::default());
-    (@default $default:expr) => ($default);
 }
 
+// N.B., this macro is parsed by util/lintlib.py
 define_Conf! {
     /// Lint: CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR. The minimum rust version that the project supports
-    (msrv: Option<String>),
+    (msrv: Option<String> = None),
     /// Lint: BLACKLISTED_NAME. The list of blacklisted names to lint about. NB: `bar` is not here since it has legitimate uses
     (blacklisted_names: Vec<String> = ["foo", "baz", "quux"].iter().map(ToString::to_string).collect()),
     /// Lint: COGNITIVE_COMPLEXITY. The maximum cognitive complexity a function can have
     (cognitive_complexity_threshold: u64 = 25),
     /// DEPRECATED LINT: CYCLOMATIC_COMPLEXITY. Use the Cognitive Complexity lint instead.
     #[conf_deprecated("Please use `cognitive-complexity-threshold` instead")]
-    (cyclomatic_complexity_threshold: Option<u64>),
+    (cyclomatic_complexity_threshold: Option<u64> = None),
     /// Lint: DOC_MARKDOWN. The list of words this lint should not consider as identifiers needing ticks
     (doc_valid_idents: Vec<String> = [
         "KiB", "MiB", "GiB", "TiB", "PiB", "EiB",
@@ -142,7 +141,7 @@ define_Conf! {
     /// Lint: DECIMAL_LITERAL_REPRESENTATION. The lower bound for linting decimal literals
     (literal_representation_threshold: u64 = 16384),
     /// Lint: TRIVIALLY_COPY_PASS_BY_REF. The maximum size (in bytes) to consider a `Copy` type for passing by value instead of by reference.
-    (trivial_copy_size_limit: Option<u64>),
+    (trivial_copy_size_limit: Option<u64> = None),
     /// Lint: LARGE_TYPE_PASS_BY_MOVE. The minimum size (in bytes) to consider a type for passing by reference instead of by value.
     (pass_by_value_size_limit: u64 = 256),
     /// Lint: TOO_MANY_LINES. The maximum number of lines a function or method can have
@@ -158,15 +157,15 @@ define_Conf! {
     /// Lint: FN_PARAMS_EXCESSIVE_BOOLS. The maximum number of bools function parameters can have
     (max_fn_params_bools: u64 = 3),
     /// Lint: WILDCARD_IMPORTS. Whether to allow certain wildcard imports (prelude, super in tests).
-    (warn_on_all_wildcard_imports: bool),
+    (warn_on_all_wildcard_imports: bool = false),
     /// Lint: DISALLOWED_METHOD. The list of disallowed methods, written as fully qualified paths.
-    (disallowed_methods: Vec<String>),
+    (disallowed_methods: Vec<String> = Vec::new()),
     /// Lint: UNREADABLE_LITERAL. Should the fraction of a decimal be linted to include separators.
     (unreadable_literal_lint_fractions: bool = true),
     /// Lint: UPPER_CASE_ACRONYMS. Enables verbose mode. Triggers if there is more than one uppercase char next to each other
-    (upper_case_acronyms_aggressive: bool),
+    (upper_case_acronyms_aggressive: bool = false),
     /// Lint: _CARGO_COMMON_METADATA. For internal testing only, ignores the current `publish` settings in the Cargo manifest.
-    (cargo_ignore_publish: bool),
+    (cargo_ignore_publish: bool = false),
 }
 
 /// Search for the configuration file.
diff --git a/util/lintlib.py b/util/lintlib.py
index d0d9beb9b2d..5707cf0ce0f 100644
--- a/util/lintlib.py
+++ b/util/lintlib.py
@@ -14,7 +14,7 @@ lintname_re = re.compile(r'''pub\s+([A-Z_][A-Z_0-9]*)''')
 group_re = re.compile(r'''\s*([a-z_][a-z_0-9]+)''')
 conf_re = re.compile(r'''define_Conf! {\n([^}]*)\n}''', re.MULTILINE)
 confvar_re = re.compile(
-    r'''/// Lint: ([\w,\s]+)\. (.*)\n\s*\([^,]+,\s+"([^"]+)":\s+([^,]+),\s+([^\.\)]+).*\),''', re.MULTILINE)
+    r'''/// Lint: ([\w,\s]+)\. (.*)\n\s*\(([^:]+):\s*([^\s=]+)\s*=\s*([^\.\)]+).*\),''', re.MULTILINE)
 comment_re = re.compile(r'''\s*/// ?(.*)''')
 
 lint_levels = {
-- 
cgit 1.4.1-3-g733a5


From c0808998481402cb1cd502ad6aa54e253840efc6 Mon Sep 17 00:00:00 2001
From: Marcel Hellwig <github@cookiesoft.de>
Date: Mon, 3 May 2021 16:18:41 +0200
Subject: add strip_{prefix,suffix} to PATTERN_METHODS

this will warn, if a single_char_pattern is used in one of the above
methods
---
 clippy_lints/src/methods/mod.rs     |  4 +++-
 tests/ui/single_char_pattern.fixed  |  2 ++
 tests/ui/single_char_pattern.rs     |  2 ++
 tests/ui/single_char_pattern.stderr | 34 +++++++++++++++++++++++-----------
 4 files changed, 30 insertions(+), 12 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index e15dbb899b3..5ea989aa684 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -2190,7 +2190,7 @@ const TRAIT_METHODS: [ShouldImplTraitCase; 30] = [
 ];
 
 #[rustfmt::skip]
-const PATTERN_METHODS: [(&str, usize); 17] = [
+const PATTERN_METHODS: [(&str, usize); 19] = [
     ("contains", 1),
     ("starts_with", 1),
     ("ends_with", 1),
@@ -2206,6 +2206,8 @@ const PATTERN_METHODS: [(&str, usize); 17] = [
     ("rmatches", 1),
     ("match_indices", 1),
     ("rmatch_indices", 1),
+    ("strip_prefix", 1),
+    ("strip_suffix", 1),
     ("trim_start_matches", 1),
     ("trim_end_matches", 1),
 ];
diff --git a/tests/ui/single_char_pattern.fixed b/tests/ui/single_char_pattern.fixed
index d8b5f19e144..fcbe9af9f56 100644
--- a/tests/ui/single_char_pattern.fixed
+++ b/tests/ui/single_char_pattern.fixed
@@ -33,6 +33,8 @@ fn main() {
     x.rmatch_indices('x');
     x.trim_start_matches('x');
     x.trim_end_matches('x');
+    x.strip_prefix('x');
+    x.strip_suffix('x');
     // Make sure we escape characters correctly.
     x.split('\n');
     x.split('\'');
diff --git a/tests/ui/single_char_pattern.rs b/tests/ui/single_char_pattern.rs
index a7bc73e3756..b8bc20f4070 100644
--- a/tests/ui/single_char_pattern.rs
+++ b/tests/ui/single_char_pattern.rs
@@ -33,6 +33,8 @@ fn main() {
     x.rmatch_indices("x");
     x.trim_start_matches("x");
     x.trim_end_matches("x");
+    x.strip_prefix("x");
+    x.strip_suffix("x");
     // Make sure we escape characters correctly.
     x.split("\n");
     x.split("'");
diff --git a/tests/ui/single_char_pattern.stderr b/tests/ui/single_char_pattern.stderr
index ee4e7e50efd..6d94d8a34e3 100644
--- a/tests/ui/single_char_pattern.stderr
+++ b/tests/ui/single_char_pattern.stderr
@@ -121,64 +121,76 @@ LL |     x.trim_end_matches("x");
    |                        ^^^ help: try using a `char` instead: `'x'`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:37:13
+  --> $DIR/single_char_pattern.rs:36:20
+   |
+LL |     x.strip_prefix("x");
+   |                    ^^^ help: try using a `char` instead: `'x'`
+
+error: single-character string constant used as pattern
+  --> $DIR/single_char_pattern.rs:37:20
+   |
+LL |     x.strip_suffix("x");
+   |                    ^^^ help: try using a `char` instead: `'x'`
+
+error: single-character string constant used as pattern
+  --> $DIR/single_char_pattern.rs:39:13
    |
 LL |     x.split("/n");
    |             ^^^^ help: try using a `char` instead: `'/n'`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:38:13
+  --> $DIR/single_char_pattern.rs:40:13
    |
 LL |     x.split("'");
    |             ^^^ help: try using a `char` instead: `'/''`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:39:13
+  --> $DIR/single_char_pattern.rs:41:13
    |
 LL |     x.split("/'");
    |             ^^^^ help: try using a `char` instead: `'/''`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:44:31
+  --> $DIR/single_char_pattern.rs:46:31
    |
 LL |     x.replace(";", ",").split(","); // issue #2978
    |                               ^^^ help: try using a `char` instead: `','`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:45:19
+  --> $DIR/single_char_pattern.rs:47:19
    |
 LL |     x.starts_with("/x03"); // issue #2996
    |                   ^^^^^^ help: try using a `char` instead: `'/x03'`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:52:13
+  --> $DIR/single_char_pattern.rs:54:13
    |
 LL |     x.split(r"a");
    |             ^^^^ help: try using a `char` instead: `'a'`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:53:13
+  --> $DIR/single_char_pattern.rs:55:13
    |
 LL |     x.split(r#"a"#);
    |             ^^^^^^ help: try using a `char` instead: `'a'`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:54:13
+  --> $DIR/single_char_pattern.rs:56:13
    |
 LL |     x.split(r###"a"###);
    |             ^^^^^^^^^^ help: try using a `char` instead: `'a'`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:55:13
+  --> $DIR/single_char_pattern.rs:57:13
    |
 LL |     x.split(r###"'"###);
    |             ^^^^^^^^^^ help: try using a `char` instead: `'/''`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:56:13
+  --> $DIR/single_char_pattern.rs:58:13
    |
 LL |     x.split(r###"#"###);
    |             ^^^^^^^^^^ help: try using a `char` instead: `'#'`
 
-error: aborting due to 30 previous errors
+error: aborting due to 32 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 19e7448c7f6a4e3a07507c2742bef07d56f1a4a3 Mon Sep 17 00:00:00 2001
From: Marcel Hellwig <github@cookiesoft.de>
Date: Mon, 3 May 2021 16:21:27 +0200
Subject: move PATTERN_METHODS table directly into file

also removed rustfmt::skip
---
 clippy_lints/src/methods/mod.rs                 | 23 -----------------------
 clippy_lints/src/methods/single_char_pattern.rs | 24 +++++++++++++++++++++++-
 2 files changed, 23 insertions(+), 24 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 5ea989aa684..0b1b6304def 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -2189,29 +2189,6 @@ const TRAIT_METHODS: [ShouldImplTraitCase; 30] = [
     ShouldImplTraitCase::new("std::ops::Sub", "sub",  2,  FN_HEADER,  SelfKind::Value,  OutType::Any, true),
 ];
 
-#[rustfmt::skip]
-const PATTERN_METHODS: [(&str, usize); 19] = [
-    ("contains", 1),
-    ("starts_with", 1),
-    ("ends_with", 1),
-    ("find", 1),
-    ("rfind", 1),
-    ("split", 1),
-    ("rsplit", 1),
-    ("split_terminator", 1),
-    ("rsplit_terminator", 1),
-    ("splitn", 2),
-    ("rsplitn", 2),
-    ("matches", 1),
-    ("rmatches", 1),
-    ("match_indices", 1),
-    ("rmatch_indices", 1),
-    ("strip_prefix", 1),
-    ("strip_suffix", 1),
-    ("trim_start_matches", 1),
-    ("trim_end_matches", 1),
-];
-
 #[derive(Clone, Copy, PartialEq, Debug)]
 enum SelfKind {
     Value,
diff --git a/clippy_lints/src/methods/single_char_pattern.rs b/clippy_lints/src/methods/single_char_pattern.rs
index f4090c7c617..d313a3db479 100644
--- a/clippy_lints/src/methods/single_char_pattern.rs
+++ b/clippy_lints/src/methods/single_char_pattern.rs
@@ -9,9 +9,31 @@ use rustc_span::symbol::Symbol;
 
 use super::SINGLE_CHAR_PATTERN;
 
+const PATTERN_METHODS: [(&str, usize); 19] = [
+    ("contains", 1),
+    ("starts_with", 1),
+    ("ends_with", 1),
+    ("find", 1),
+    ("rfind", 1),
+    ("split", 1),
+    ("rsplit", 1),
+    ("split_terminator", 1),
+    ("rsplit_terminator", 1),
+    ("splitn", 2),
+    ("rsplitn", 2),
+    ("matches", 1),
+    ("rmatches", 1),
+    ("match_indices", 1),
+    ("rmatch_indices", 1),
+    ("strip_prefix", 1),
+    ("strip_suffix", 1),
+    ("trim_start_matches", 1),
+    ("trim_end_matches", 1),
+];
+
 /// lint for length-1 `str`s for methods in `PATTERN_METHODS`
 pub(super) fn check(cx: &LateContext<'_>, _expr: &hir::Expr<'_>, method_name: Symbol, args: &[hir::Expr<'_>]) {
-    for &(method, pos) in &crate::methods::PATTERN_METHODS {
+    for &(method, pos) in &PATTERN_METHODS {
         if_chain! {
             if let ty::Ref(_, ty, _) = cx.typeck_results().expr_ty_adjusted(&args[0]).kind();
             if *ty.kind() == ty::Str;
-- 
cgit 1.4.1-3-g733a5


From 91a8611b4426c7da8c72317516626affb812d20b Mon Sep 17 00:00:00 2001
From: Takayuki <takoyaki0316@gmail.com>
Date: Tue, 4 May 2021 16:38:34 +0900
Subject: move misc_early to misc_early/mod.rs

---
 clippy_lints/src/misc_early.rs     | 569 -------------------------------------
 clippy_lints/src/misc_early/mod.rs | 569 +++++++++++++++++++++++++++++++++++++
 2 files changed, 569 insertions(+), 569 deletions(-)
 delete mode 100644 clippy_lints/src/misc_early.rs
 create mode 100644 clippy_lints/src/misc_early/mod.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/misc_early.rs b/clippy_lints/src/misc_early.rs
deleted file mode 100644
index 3c6a7071c24..00000000000
--- a/clippy_lints/src/misc_early.rs
+++ /dev/null
@@ -1,569 +0,0 @@
-use clippy_utils::diagnostics::{span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then};
-use clippy_utils::source::snippet_opt;
-use rustc_ast::ast::{
-    BindingMode, Expr, ExprKind, GenericParamKind, Generics, Lit, LitFloatType, LitIntType, LitKind, Mutability,
-    NodeId, Pat, PatKind, UnOp,
-};
-use rustc_ast::visit::FnKind;
-use rustc_data_structures::fx::FxHashMap;
-use rustc_errors::Applicability;
-use rustc_hir::PrimTy;
-use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
-use rustc_middle::lint::in_external_macro;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::source_map::Span;
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for structure field patterns bound to wildcards.
-    ///
-    /// **Why is this bad?** Using `..` instead is shorter and leaves the focus on
-    /// the fields that are actually bound.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    /// ```rust
-    /// # struct Foo {
-    /// #     a: i32,
-    /// #     b: i32,
-    /// #     c: i32,
-    /// # }
-    /// let f = Foo { a: 0, b: 0, c: 0 };
-    ///
-    /// // Bad
-    /// match f {
-    ///     Foo { a: _, b: 0, .. } => {},
-    ///     Foo { a: _, b: _, c: _ } => {},
-    /// }
-    ///
-    /// // Good
-    /// match f {
-    ///     Foo { b: 0, .. } => {},
-    ///     Foo { .. } => {},
-    /// }
-    /// ```
-    pub UNNEEDED_FIELD_PATTERN,
-    restriction,
-    "struct fields bound to a wildcard instead of using `..`"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for function arguments having the similar names
-    /// differing by an underscore.
-    ///
-    /// **Why is this bad?** It affects code readability.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    /// ```rust
-    /// // Bad
-    /// fn foo(a: i32, _a: i32) {}
-    ///
-    /// // Good
-    /// fn bar(a: i32, _b: i32) {}
-    /// ```
-    pub DUPLICATE_UNDERSCORE_ARGUMENT,
-    style,
-    "function arguments having names which only differ by an underscore"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Detects expressions of the form `--x`.
-    ///
-    /// **Why is this bad?** It can mislead C/C++ programmers to think `x` was
-    /// decremented.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    /// ```rust
-    /// let mut x = 3;
-    /// --x;
-    /// ```
-    pub DOUBLE_NEG,
-    style,
-    "`--x`, which is a double negation of `x` and not a pre-decrement as in C/C++"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Warns on hexadecimal literals with mixed-case letter
-    /// digits.
-    ///
-    /// **Why is this bad?** It looks confusing.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    /// ```rust
-    /// // Bad
-    /// let y = 0x1a9BAcD;
-    ///
-    /// // Good
-    /// let y = 0x1A9BACD;
-    /// ```
-    pub MIXED_CASE_HEX_LITERALS,
-    style,
-    "hex literals whose letter digits are not consistently upper- or lowercased"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Warns if literal suffixes are not separated by an
-    /// underscore.
-    ///
-    /// **Why is this bad?** It is much less readable.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    /// ```rust
-    /// // Bad
-    /// let y = 123832i32;
-    ///
-    /// // Good
-    /// let y = 123832_i32;
-    /// ```
-    pub UNSEPARATED_LITERAL_SUFFIX,
-    pedantic,
-    "literals whose suffix is not separated by an underscore"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Warns if an integral constant literal starts with `0`.
-    ///
-    /// **Why is this bad?** In some languages (including the infamous C language
-    /// and most of its
-    /// family), this marks an octal constant. In Rust however, this is a decimal
-    /// constant. This could
-    /// be confusing for both the writer and a reader of the constant.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
-    /// In Rust:
-    /// ```rust
-    /// fn main() {
-    ///     let a = 0123;
-    ///     println!("{}", a);
-    /// }
-    /// ```
-    ///
-    /// prints `123`, while in C:
-    ///
-    /// ```c
-    /// #include <stdio.h>
-    ///
-    /// int main() {
-    ///     int a = 0123;
-    ///     printf("%d\n", a);
-    /// }
-    /// ```
-    ///
-    /// prints `83` (as `83 == 0o123` while `123 == 0o173`).
-    pub ZERO_PREFIXED_LITERAL,
-    complexity,
-    "integer literals starting with `0`"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Warns if a generic shadows a built-in type.
-    ///
-    /// **Why is this bad?** This gives surprising type errors.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
-    /// ```ignore
-    /// impl<u32> Foo<u32> {
-    ///     fn impl_func(&self) -> u32 {
-    ///         42
-    ///     }
-    /// }
-    /// ```
-    pub BUILTIN_TYPE_SHADOW,
-    style,
-    "shadowing a builtin type"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for patterns in the form `name @ _`.
-    ///
-    /// **Why is this bad?** It's almost always more readable to just use direct
-    /// bindings.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    /// ```rust
-    /// # let v = Some("abc");
-    ///
-    /// // Bad
-    /// match v {
-    ///     Some(x) => (),
-    ///     y @ _ => (),
-    /// }
-    ///
-    /// // Good
-    /// match v {
-    ///     Some(x) => (),
-    ///     y => (),
-    /// }
-    /// ```
-    pub REDUNDANT_PATTERN,
-    style,
-    "using `name @ _` in a pattern"
-}
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for tuple patterns with a wildcard
-    /// pattern (`_`) is next to a rest pattern (`..`).
-    ///
-    /// _NOTE_: While `_, ..` means there is at least one element left, `..`
-    /// means there are 0 or more elements left. This can make a difference
-    /// when refactoring, but shouldn't result in errors in the refactored code,
-    /// since the wildcard pattern isn't used anyway.
-    /// **Why is this bad?** The wildcard pattern is unneeded as the rest pattern
-    /// can match that element as well.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    /// ```rust
-    /// # struct TupleStruct(u32, u32, u32);
-    /// # let t = TupleStruct(1, 2, 3);
-    /// // Bad
-    /// match t {
-    ///     TupleStruct(0, .., _) => (),
-    ///     _ => (),
-    /// }
-    ///
-    /// // Good
-    /// match t {
-    ///     TupleStruct(0, ..) => (),
-    ///     _ => (),
-    /// }
-    /// ```
-    pub UNNEEDED_WILDCARD_PATTERN,
-    complexity,
-    "tuple patterns with a wildcard pattern (`_`) is next to a rest pattern (`..`)"
-}
-
-declare_lint_pass!(MiscEarlyLints => [
-    UNNEEDED_FIELD_PATTERN,
-    DUPLICATE_UNDERSCORE_ARGUMENT,
-    DOUBLE_NEG,
-    MIXED_CASE_HEX_LITERALS,
-    UNSEPARATED_LITERAL_SUFFIX,
-    ZERO_PREFIXED_LITERAL,
-    BUILTIN_TYPE_SHADOW,
-    REDUNDANT_PATTERN,
-    UNNEEDED_WILDCARD_PATTERN,
-]);
-
-impl EarlyLintPass for MiscEarlyLints {
-    fn check_generics(&mut self, cx: &EarlyContext<'_>, gen: &Generics) {
-        for param in &gen.params {
-            if let GenericParamKind::Type { .. } = param.kind {
-                if let Some(prim_ty) = PrimTy::from_name(param.ident.name) {
-                    span_lint(
-                        cx,
-                        BUILTIN_TYPE_SHADOW,
-                        param.ident.span,
-                        &format!("this generic shadows the built-in type `{}`", prim_ty.name()),
-                    );
-                }
-            }
-        }
-    }
-
-    fn check_pat(&mut self, cx: &EarlyContext<'_>, pat: &Pat) {
-        if let PatKind::Struct(ref npat, ref pfields, _) = pat.kind {
-            let mut wilds = 0;
-            let type_name = npat
-                .segments
-                .last()
-                .expect("A path must have at least one segment")
-                .ident
-                .name;
-
-            for field in pfields {
-                if let PatKind::Wild = field.pat.kind {
-                    wilds += 1;
-                }
-            }
-            if !pfields.is_empty() && wilds == pfields.len() {
-                span_lint_and_help(
-                    cx,
-                    UNNEEDED_FIELD_PATTERN,
-                    pat.span,
-                    "all the struct fields are matched to a wildcard pattern, consider using `..`",
-                    None,
-                    &format!("try with `{} {{ .. }}` instead", type_name),
-                );
-                return;
-            }
-            if wilds > 0 {
-                for field in pfields {
-                    if let PatKind::Wild = field.pat.kind {
-                        wilds -= 1;
-                        if wilds > 0 {
-                            span_lint(
-                                cx,
-                                UNNEEDED_FIELD_PATTERN,
-                                field.span,
-                                "you matched a field with a wildcard pattern, consider using `..` instead",
-                            );
-                        } else {
-                            let mut normal = vec![];
-
-                            for field in pfields {
-                                match field.pat.kind {
-                                    PatKind::Wild => {},
-                                    _ => {
-                                        if let Ok(n) = cx.sess().source_map().span_to_snippet(field.span) {
-                                            normal.push(n);
-                                        }
-                                    },
-                                }
-                            }
-
-                            span_lint_and_help(
-                                cx,
-                                UNNEEDED_FIELD_PATTERN,
-                                field.span,
-                                "you matched a field with a wildcard pattern, consider using `..` \
-                                 instead",
-                                None,
-                                &format!("try with `{} {{ {}, .. }}`", type_name, normal[..].join(", ")),
-                            );
-                        }
-                    }
-                }
-            }
-        }
-
-        if let PatKind::Ident(left, ident, Some(ref right)) = pat.kind {
-            let left_binding = match left {
-                BindingMode::ByRef(Mutability::Mut) => "ref mut ",
-                BindingMode::ByRef(Mutability::Not) => "ref ",
-                BindingMode::ByValue(..) => "",
-            };
-
-            if let PatKind::Wild = right.kind {
-                span_lint_and_sugg(
-                    cx,
-                    REDUNDANT_PATTERN,
-                    pat.span,
-                    &format!(
-                        "the `{} @ _` pattern can be written as just `{}`",
-                        ident.name, ident.name,
-                    ),
-                    "try",
-                    format!("{}{}", left_binding, ident.name),
-                    Applicability::MachineApplicable,
-                );
-            }
-        }
-
-        check_unneeded_wildcard_pattern(cx, pat);
-    }
-
-    fn check_fn(&mut self, cx: &EarlyContext<'_>, fn_kind: FnKind<'_>, _: Span, _: NodeId) {
-        let mut registered_names: FxHashMap<String, Span> = FxHashMap::default();
-
-        for arg in &fn_kind.decl().inputs {
-            if let PatKind::Ident(_, ident, None) = arg.pat.kind {
-                let arg_name = ident.to_string();
-
-                if let Some(arg_name) = arg_name.strip_prefix('_') {
-                    if let Some(correspondence) = registered_names.get(arg_name) {
-                        span_lint(
-                            cx,
-                            DUPLICATE_UNDERSCORE_ARGUMENT,
-                            *correspondence,
-                            &format!(
-                                "`{}` already exists, having another argument having almost the same \
-                                 name makes code comprehension and documentation more difficult",
-                                arg_name
-                            ),
-                        );
-                    }
-                } else {
-                    registered_names.insert(arg_name, arg.pat.span);
-                }
-            }
-        }
-    }
-
-    fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
-        if in_external_macro(cx.sess(), expr.span) {
-            return;
-        }
-        match expr.kind {
-            ExprKind::Unary(UnOp::Neg, ref inner) => {
-                if let ExprKind::Unary(UnOp::Neg, _) = inner.kind {
-                    span_lint(
-                        cx,
-                        DOUBLE_NEG,
-                        expr.span,
-                        "`--x` could be misinterpreted as pre-decrement by C programmers, is usually a no-op",
-                    );
-                }
-            },
-            ExprKind::Lit(ref lit) => Self::check_lit(cx, lit),
-            _ => (),
-        }
-    }
-}
-
-impl MiscEarlyLints {
-    fn check_lit(cx: &EarlyContext<'_>, lit: &Lit) {
-        // We test if first character in snippet is a number, because the snippet could be an expansion
-        // from a built-in macro like `line!()` or a proc-macro like `#[wasm_bindgen]`.
-        // Note that this check also covers special case that `line!()` is eagerly expanded by compiler.
-        // See <https://github.com/rust-lang/rust-clippy/issues/4507> for a regression.
-        // FIXME: Find a better way to detect those cases.
-        let lit_snip = match snippet_opt(cx, lit.span) {
-            Some(snip) if snip.chars().next().map_or(false, |c| c.is_digit(10)) => snip,
-            _ => return,
-        };
-
-        if let LitKind::Int(value, lit_int_type) = lit.kind {
-            let suffix = match lit_int_type {
-                LitIntType::Signed(ty) => ty.name_str(),
-                LitIntType::Unsigned(ty) => ty.name_str(),
-                LitIntType::Unsuffixed => "",
-            };
-
-            let maybe_last_sep_idx = if let Some(val) = lit_snip.len().checked_sub(suffix.len() + 1) {
-                val
-            } else {
-                return; // It's useless so shouldn't lint.
-            };
-            // Do not lint when literal is unsuffixed.
-            if !suffix.is_empty() && lit_snip.as_bytes()[maybe_last_sep_idx] != b'_' {
-                span_lint_and_sugg(
-                    cx,
-                    UNSEPARATED_LITERAL_SUFFIX,
-                    lit.span,
-                    "integer type suffix should be separated by an underscore",
-                    "add an underscore",
-                    format!("{}_{}", &lit_snip[..=maybe_last_sep_idx], suffix),
-                    Applicability::MachineApplicable,
-                );
-            }
-
-            if lit_snip.starts_with("0x") {
-                if maybe_last_sep_idx <= 2 {
-                    // It's meaningless or causes range error.
-                    return;
-                }
-                let mut seen = (false, false);
-                for ch in lit_snip.as_bytes()[2..=maybe_last_sep_idx].iter() {
-                    match ch {
-                        b'a'..=b'f' => seen.0 = true,
-                        b'A'..=b'F' => seen.1 = true,
-                        _ => {},
-                    }
-                    if seen.0 && seen.1 {
-                        span_lint(
-                            cx,
-                            MIXED_CASE_HEX_LITERALS,
-                            lit.span,
-                            "inconsistent casing in hexadecimal literal",
-                        );
-                        break;
-                    }
-                }
-            } else if lit_snip.starts_with("0b") || lit_snip.starts_with("0o") {
-                /* nothing to do */
-            } else if value != 0 && lit_snip.starts_with('0') {
-                span_lint_and_then(
-                    cx,
-                    ZERO_PREFIXED_LITERAL,
-                    lit.span,
-                    "this is a decimal constant",
-                    |diag| {
-                        diag.span_suggestion(
-                            lit.span,
-                            "if you mean to use a decimal constant, remove the `0` to avoid confusion",
-                            lit_snip.trim_start_matches(|c| c == '_' || c == '0').to_string(),
-                            Applicability::MaybeIncorrect,
-                        );
-                        diag.span_suggestion(
-                            lit.span,
-                            "if you mean to use an octal constant, use `0o`",
-                            format!("0o{}", lit_snip.trim_start_matches(|c| c == '_' || c == '0')),
-                            Applicability::MaybeIncorrect,
-                        );
-                    },
-                );
-            }
-        } else if let LitKind::Float(_, LitFloatType::Suffixed(float_ty)) = lit.kind {
-            let suffix = float_ty.name_str();
-            let maybe_last_sep_idx = if let Some(val) = lit_snip.len().checked_sub(suffix.len() + 1) {
-                val
-            } else {
-                return; // It's useless so shouldn't lint.
-            };
-            if lit_snip.as_bytes()[maybe_last_sep_idx] != b'_' {
-                span_lint_and_sugg(
-                    cx,
-                    UNSEPARATED_LITERAL_SUFFIX,
-                    lit.span,
-                    "float type suffix should be separated by an underscore",
-                    "add an underscore",
-                    format!("{}_{}", &lit_snip[..=maybe_last_sep_idx], suffix),
-                    Applicability::MachineApplicable,
-                );
-            }
-        }
-    }
-}
-
-fn check_unneeded_wildcard_pattern(cx: &EarlyContext<'_>, pat: &Pat) {
-    if let PatKind::TupleStruct(_, ref patterns) | PatKind::Tuple(ref patterns) = pat.kind {
-        fn span_lint(cx: &EarlyContext<'_>, span: Span, only_one: bool) {
-            span_lint_and_sugg(
-                cx,
-                UNNEEDED_WILDCARD_PATTERN,
-                span,
-                if only_one {
-                    "this pattern is unneeded as the `..` pattern can match that element"
-                } else {
-                    "these patterns are unneeded as the `..` pattern can match those elements"
-                },
-                if only_one { "remove it" } else { "remove them" },
-                "".to_string(),
-                Applicability::MachineApplicable,
-            );
-        }
-
-        if let Some(rest_index) = patterns.iter().position(|pat| pat.is_rest()) {
-            if let Some((left_index, left_pat)) = patterns[..rest_index]
-                .iter()
-                .rev()
-                .take_while(|pat| matches!(pat.kind, PatKind::Wild))
-                .enumerate()
-                .last()
-            {
-                span_lint(cx, left_pat.span.until(patterns[rest_index].span), left_index == 0);
-            }
-
-            if let Some((right_index, right_pat)) = patterns[rest_index + 1..]
-                .iter()
-                .take_while(|pat| matches!(pat.kind, PatKind::Wild))
-                .enumerate()
-                .last()
-            {
-                span_lint(
-                    cx,
-                    patterns[rest_index].span.shrink_to_hi().to(right_pat.span),
-                    right_index == 0,
-                );
-            }
-        }
-    }
-}
diff --git a/clippy_lints/src/misc_early/mod.rs b/clippy_lints/src/misc_early/mod.rs
new file mode 100644
index 00000000000..3c6a7071c24
--- /dev/null
+++ b/clippy_lints/src/misc_early/mod.rs
@@ -0,0 +1,569 @@
+use clippy_utils::diagnostics::{span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then};
+use clippy_utils::source::snippet_opt;
+use rustc_ast::ast::{
+    BindingMode, Expr, ExprKind, GenericParamKind, Generics, Lit, LitFloatType, LitIntType, LitKind, Mutability,
+    NodeId, Pat, PatKind, UnOp,
+};
+use rustc_ast::visit::FnKind;
+use rustc_data_structures::fx::FxHashMap;
+use rustc_errors::Applicability;
+use rustc_hir::PrimTy;
+use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
+use rustc_middle::lint::in_external_macro;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::source_map::Span;
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for structure field patterns bound to wildcards.
+    ///
+    /// **Why is this bad?** Using `..` instead is shorter and leaves the focus on
+    /// the fields that are actually bound.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// ```rust
+    /// # struct Foo {
+    /// #     a: i32,
+    /// #     b: i32,
+    /// #     c: i32,
+    /// # }
+    /// let f = Foo { a: 0, b: 0, c: 0 };
+    ///
+    /// // Bad
+    /// match f {
+    ///     Foo { a: _, b: 0, .. } => {},
+    ///     Foo { a: _, b: _, c: _ } => {},
+    /// }
+    ///
+    /// // Good
+    /// match f {
+    ///     Foo { b: 0, .. } => {},
+    ///     Foo { .. } => {},
+    /// }
+    /// ```
+    pub UNNEEDED_FIELD_PATTERN,
+    restriction,
+    "struct fields bound to a wildcard instead of using `..`"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for function arguments having the similar names
+    /// differing by an underscore.
+    ///
+    /// **Why is this bad?** It affects code readability.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// ```rust
+    /// // Bad
+    /// fn foo(a: i32, _a: i32) {}
+    ///
+    /// // Good
+    /// fn bar(a: i32, _b: i32) {}
+    /// ```
+    pub DUPLICATE_UNDERSCORE_ARGUMENT,
+    style,
+    "function arguments having names which only differ by an underscore"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Detects expressions of the form `--x`.
+    ///
+    /// **Why is this bad?** It can mislead C/C++ programmers to think `x` was
+    /// decremented.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// ```rust
+    /// let mut x = 3;
+    /// --x;
+    /// ```
+    pub DOUBLE_NEG,
+    style,
+    "`--x`, which is a double negation of `x` and not a pre-decrement as in C/C++"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Warns on hexadecimal literals with mixed-case letter
+    /// digits.
+    ///
+    /// **Why is this bad?** It looks confusing.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// ```rust
+    /// // Bad
+    /// let y = 0x1a9BAcD;
+    ///
+    /// // Good
+    /// let y = 0x1A9BACD;
+    /// ```
+    pub MIXED_CASE_HEX_LITERALS,
+    style,
+    "hex literals whose letter digits are not consistently upper- or lowercased"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Warns if literal suffixes are not separated by an
+    /// underscore.
+    ///
+    /// **Why is this bad?** It is much less readable.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// ```rust
+    /// // Bad
+    /// let y = 123832i32;
+    ///
+    /// // Good
+    /// let y = 123832_i32;
+    /// ```
+    pub UNSEPARATED_LITERAL_SUFFIX,
+    pedantic,
+    "literals whose suffix is not separated by an underscore"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Warns if an integral constant literal starts with `0`.
+    ///
+    /// **Why is this bad?** In some languages (including the infamous C language
+    /// and most of its
+    /// family), this marks an octal constant. In Rust however, this is a decimal
+    /// constant. This could
+    /// be confusing for both the writer and a reader of the constant.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// In Rust:
+    /// ```rust
+    /// fn main() {
+    ///     let a = 0123;
+    ///     println!("{}", a);
+    /// }
+    /// ```
+    ///
+    /// prints `123`, while in C:
+    ///
+    /// ```c
+    /// #include <stdio.h>
+    ///
+    /// int main() {
+    ///     int a = 0123;
+    ///     printf("%d\n", a);
+    /// }
+    /// ```
+    ///
+    /// prints `83` (as `83 == 0o123` while `123 == 0o173`).
+    pub ZERO_PREFIXED_LITERAL,
+    complexity,
+    "integer literals starting with `0`"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Warns if a generic shadows a built-in type.
+    ///
+    /// **Why is this bad?** This gives surprising type errors.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```ignore
+    /// impl<u32> Foo<u32> {
+    ///     fn impl_func(&self) -> u32 {
+    ///         42
+    ///     }
+    /// }
+    /// ```
+    pub BUILTIN_TYPE_SHADOW,
+    style,
+    "shadowing a builtin type"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for patterns in the form `name @ _`.
+    ///
+    /// **Why is this bad?** It's almost always more readable to just use direct
+    /// bindings.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// ```rust
+    /// # let v = Some("abc");
+    ///
+    /// // Bad
+    /// match v {
+    ///     Some(x) => (),
+    ///     y @ _ => (),
+    /// }
+    ///
+    /// // Good
+    /// match v {
+    ///     Some(x) => (),
+    ///     y => (),
+    /// }
+    /// ```
+    pub REDUNDANT_PATTERN,
+    style,
+    "using `name @ _` in a pattern"
+}
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for tuple patterns with a wildcard
+    /// pattern (`_`) is next to a rest pattern (`..`).
+    ///
+    /// _NOTE_: While `_, ..` means there is at least one element left, `..`
+    /// means there are 0 or more elements left. This can make a difference
+    /// when refactoring, but shouldn't result in errors in the refactored code,
+    /// since the wildcard pattern isn't used anyway.
+    /// **Why is this bad?** The wildcard pattern is unneeded as the rest pattern
+    /// can match that element as well.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// ```rust
+    /// # struct TupleStruct(u32, u32, u32);
+    /// # let t = TupleStruct(1, 2, 3);
+    /// // Bad
+    /// match t {
+    ///     TupleStruct(0, .., _) => (),
+    ///     _ => (),
+    /// }
+    ///
+    /// // Good
+    /// match t {
+    ///     TupleStruct(0, ..) => (),
+    ///     _ => (),
+    /// }
+    /// ```
+    pub UNNEEDED_WILDCARD_PATTERN,
+    complexity,
+    "tuple patterns with a wildcard pattern (`_`) is next to a rest pattern (`..`)"
+}
+
+declare_lint_pass!(MiscEarlyLints => [
+    UNNEEDED_FIELD_PATTERN,
+    DUPLICATE_UNDERSCORE_ARGUMENT,
+    DOUBLE_NEG,
+    MIXED_CASE_HEX_LITERALS,
+    UNSEPARATED_LITERAL_SUFFIX,
+    ZERO_PREFIXED_LITERAL,
+    BUILTIN_TYPE_SHADOW,
+    REDUNDANT_PATTERN,
+    UNNEEDED_WILDCARD_PATTERN,
+]);
+
+impl EarlyLintPass for MiscEarlyLints {
+    fn check_generics(&mut self, cx: &EarlyContext<'_>, gen: &Generics) {
+        for param in &gen.params {
+            if let GenericParamKind::Type { .. } = param.kind {
+                if let Some(prim_ty) = PrimTy::from_name(param.ident.name) {
+                    span_lint(
+                        cx,
+                        BUILTIN_TYPE_SHADOW,
+                        param.ident.span,
+                        &format!("this generic shadows the built-in type `{}`", prim_ty.name()),
+                    );
+                }
+            }
+        }
+    }
+
+    fn check_pat(&mut self, cx: &EarlyContext<'_>, pat: &Pat) {
+        if let PatKind::Struct(ref npat, ref pfields, _) = pat.kind {
+            let mut wilds = 0;
+            let type_name = npat
+                .segments
+                .last()
+                .expect("A path must have at least one segment")
+                .ident
+                .name;
+
+            for field in pfields {
+                if let PatKind::Wild = field.pat.kind {
+                    wilds += 1;
+                }
+            }
+            if !pfields.is_empty() && wilds == pfields.len() {
+                span_lint_and_help(
+                    cx,
+                    UNNEEDED_FIELD_PATTERN,
+                    pat.span,
+                    "all the struct fields are matched to a wildcard pattern, consider using `..`",
+                    None,
+                    &format!("try with `{} {{ .. }}` instead", type_name),
+                );
+                return;
+            }
+            if wilds > 0 {
+                for field in pfields {
+                    if let PatKind::Wild = field.pat.kind {
+                        wilds -= 1;
+                        if wilds > 0 {
+                            span_lint(
+                                cx,
+                                UNNEEDED_FIELD_PATTERN,
+                                field.span,
+                                "you matched a field with a wildcard pattern, consider using `..` instead",
+                            );
+                        } else {
+                            let mut normal = vec![];
+
+                            for field in pfields {
+                                match field.pat.kind {
+                                    PatKind::Wild => {},
+                                    _ => {
+                                        if let Ok(n) = cx.sess().source_map().span_to_snippet(field.span) {
+                                            normal.push(n);
+                                        }
+                                    },
+                                }
+                            }
+
+                            span_lint_and_help(
+                                cx,
+                                UNNEEDED_FIELD_PATTERN,
+                                field.span,
+                                "you matched a field with a wildcard pattern, consider using `..` \
+                                 instead",
+                                None,
+                                &format!("try with `{} {{ {}, .. }}`", type_name, normal[..].join(", ")),
+                            );
+                        }
+                    }
+                }
+            }
+        }
+
+        if let PatKind::Ident(left, ident, Some(ref right)) = pat.kind {
+            let left_binding = match left {
+                BindingMode::ByRef(Mutability::Mut) => "ref mut ",
+                BindingMode::ByRef(Mutability::Not) => "ref ",
+                BindingMode::ByValue(..) => "",
+            };
+
+            if let PatKind::Wild = right.kind {
+                span_lint_and_sugg(
+                    cx,
+                    REDUNDANT_PATTERN,
+                    pat.span,
+                    &format!(
+                        "the `{} @ _` pattern can be written as just `{}`",
+                        ident.name, ident.name,
+                    ),
+                    "try",
+                    format!("{}{}", left_binding, ident.name),
+                    Applicability::MachineApplicable,
+                );
+            }
+        }
+
+        check_unneeded_wildcard_pattern(cx, pat);
+    }
+
+    fn check_fn(&mut self, cx: &EarlyContext<'_>, fn_kind: FnKind<'_>, _: Span, _: NodeId) {
+        let mut registered_names: FxHashMap<String, Span> = FxHashMap::default();
+
+        for arg in &fn_kind.decl().inputs {
+            if let PatKind::Ident(_, ident, None) = arg.pat.kind {
+                let arg_name = ident.to_string();
+
+                if let Some(arg_name) = arg_name.strip_prefix('_') {
+                    if let Some(correspondence) = registered_names.get(arg_name) {
+                        span_lint(
+                            cx,
+                            DUPLICATE_UNDERSCORE_ARGUMENT,
+                            *correspondence,
+                            &format!(
+                                "`{}` already exists, having another argument having almost the same \
+                                 name makes code comprehension and documentation more difficult",
+                                arg_name
+                            ),
+                        );
+                    }
+                } else {
+                    registered_names.insert(arg_name, arg.pat.span);
+                }
+            }
+        }
+    }
+
+    fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
+        if in_external_macro(cx.sess(), expr.span) {
+            return;
+        }
+        match expr.kind {
+            ExprKind::Unary(UnOp::Neg, ref inner) => {
+                if let ExprKind::Unary(UnOp::Neg, _) = inner.kind {
+                    span_lint(
+                        cx,
+                        DOUBLE_NEG,
+                        expr.span,
+                        "`--x` could be misinterpreted as pre-decrement by C programmers, is usually a no-op",
+                    );
+                }
+            },
+            ExprKind::Lit(ref lit) => Self::check_lit(cx, lit),
+            _ => (),
+        }
+    }
+}
+
+impl MiscEarlyLints {
+    fn check_lit(cx: &EarlyContext<'_>, lit: &Lit) {
+        // We test if first character in snippet is a number, because the snippet could be an expansion
+        // from a built-in macro like `line!()` or a proc-macro like `#[wasm_bindgen]`.
+        // Note that this check also covers special case that `line!()` is eagerly expanded by compiler.
+        // See <https://github.com/rust-lang/rust-clippy/issues/4507> for a regression.
+        // FIXME: Find a better way to detect those cases.
+        let lit_snip = match snippet_opt(cx, lit.span) {
+            Some(snip) if snip.chars().next().map_or(false, |c| c.is_digit(10)) => snip,
+            _ => return,
+        };
+
+        if let LitKind::Int(value, lit_int_type) = lit.kind {
+            let suffix = match lit_int_type {
+                LitIntType::Signed(ty) => ty.name_str(),
+                LitIntType::Unsigned(ty) => ty.name_str(),
+                LitIntType::Unsuffixed => "",
+            };
+
+            let maybe_last_sep_idx = if let Some(val) = lit_snip.len().checked_sub(suffix.len() + 1) {
+                val
+            } else {
+                return; // It's useless so shouldn't lint.
+            };
+            // Do not lint when literal is unsuffixed.
+            if !suffix.is_empty() && lit_snip.as_bytes()[maybe_last_sep_idx] != b'_' {
+                span_lint_and_sugg(
+                    cx,
+                    UNSEPARATED_LITERAL_SUFFIX,
+                    lit.span,
+                    "integer type suffix should be separated by an underscore",
+                    "add an underscore",
+                    format!("{}_{}", &lit_snip[..=maybe_last_sep_idx], suffix),
+                    Applicability::MachineApplicable,
+                );
+            }
+
+            if lit_snip.starts_with("0x") {
+                if maybe_last_sep_idx <= 2 {
+                    // It's meaningless or causes range error.
+                    return;
+                }
+                let mut seen = (false, false);
+                for ch in lit_snip.as_bytes()[2..=maybe_last_sep_idx].iter() {
+                    match ch {
+                        b'a'..=b'f' => seen.0 = true,
+                        b'A'..=b'F' => seen.1 = true,
+                        _ => {},
+                    }
+                    if seen.0 && seen.1 {
+                        span_lint(
+                            cx,
+                            MIXED_CASE_HEX_LITERALS,
+                            lit.span,
+                            "inconsistent casing in hexadecimal literal",
+                        );
+                        break;
+                    }
+                }
+            } else if lit_snip.starts_with("0b") || lit_snip.starts_with("0o") {
+                /* nothing to do */
+            } else if value != 0 && lit_snip.starts_with('0') {
+                span_lint_and_then(
+                    cx,
+                    ZERO_PREFIXED_LITERAL,
+                    lit.span,
+                    "this is a decimal constant",
+                    |diag| {
+                        diag.span_suggestion(
+                            lit.span,
+                            "if you mean to use a decimal constant, remove the `0` to avoid confusion",
+                            lit_snip.trim_start_matches(|c| c == '_' || c == '0').to_string(),
+                            Applicability::MaybeIncorrect,
+                        );
+                        diag.span_suggestion(
+                            lit.span,
+                            "if you mean to use an octal constant, use `0o`",
+                            format!("0o{}", lit_snip.trim_start_matches(|c| c == '_' || c == '0')),
+                            Applicability::MaybeIncorrect,
+                        );
+                    },
+                );
+            }
+        } else if let LitKind::Float(_, LitFloatType::Suffixed(float_ty)) = lit.kind {
+            let suffix = float_ty.name_str();
+            let maybe_last_sep_idx = if let Some(val) = lit_snip.len().checked_sub(suffix.len() + 1) {
+                val
+            } else {
+                return; // It's useless so shouldn't lint.
+            };
+            if lit_snip.as_bytes()[maybe_last_sep_idx] != b'_' {
+                span_lint_and_sugg(
+                    cx,
+                    UNSEPARATED_LITERAL_SUFFIX,
+                    lit.span,
+                    "float type suffix should be separated by an underscore",
+                    "add an underscore",
+                    format!("{}_{}", &lit_snip[..=maybe_last_sep_idx], suffix),
+                    Applicability::MachineApplicable,
+                );
+            }
+        }
+    }
+}
+
+fn check_unneeded_wildcard_pattern(cx: &EarlyContext<'_>, pat: &Pat) {
+    if let PatKind::TupleStruct(_, ref patterns) | PatKind::Tuple(ref patterns) = pat.kind {
+        fn span_lint(cx: &EarlyContext<'_>, span: Span, only_one: bool) {
+            span_lint_and_sugg(
+                cx,
+                UNNEEDED_WILDCARD_PATTERN,
+                span,
+                if only_one {
+                    "this pattern is unneeded as the `..` pattern can match that element"
+                } else {
+                    "these patterns are unneeded as the `..` pattern can match those elements"
+                },
+                if only_one { "remove it" } else { "remove them" },
+                "".to_string(),
+                Applicability::MachineApplicable,
+            );
+        }
+
+        if let Some(rest_index) = patterns.iter().position(|pat| pat.is_rest()) {
+            if let Some((left_index, left_pat)) = patterns[..rest_index]
+                .iter()
+                .rev()
+                .take_while(|pat| matches!(pat.kind, PatKind::Wild))
+                .enumerate()
+                .last()
+            {
+                span_lint(cx, left_pat.span.until(patterns[rest_index].span), left_index == 0);
+            }
+
+            if let Some((right_index, right_pat)) = patterns[rest_index + 1..]
+                .iter()
+                .take_while(|pat| matches!(pat.kind, PatKind::Wild))
+                .enumerate()
+                .last()
+            {
+                span_lint(
+                    cx,
+                    patterns[rest_index].span.shrink_to_hi().to(right_pat.span),
+                    right_index == 0,
+                );
+            }
+        }
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 64eb18e6759f4375d01d7e3352447ff6b4305184 Mon Sep 17 00:00:00 2001
From: Takayuki <takoyaki0316@gmail.com>
Date: Tue, 4 May 2021 17:04:10 +0900
Subject: move builtin_type_shadow to its own module

---
 clippy_lints/src/misc_early/builtin_type_shadow.rs | 19 +++++++++++++++++
 clippy_lints/src/misc_early/mod.rs                 | 18 +++++-----------
 tests/ui/builtin-type-shadow.rs                    |  9 --------
 tests/ui/builtin-type-shadow.stderr                | 24 ----------------------
 tests/ui/builtin_type_shadow.rs                    |  9 ++++++++
 tests/ui/builtin_type_shadow.stderr                | 24 ++++++++++++++++++++++
 6 files changed, 57 insertions(+), 46 deletions(-)
 create mode 100644 clippy_lints/src/misc_early/builtin_type_shadow.rs
 delete mode 100644 tests/ui/builtin-type-shadow.rs
 delete mode 100644 tests/ui/builtin-type-shadow.stderr
 create mode 100644 tests/ui/builtin_type_shadow.rs
 create mode 100644 tests/ui/builtin_type_shadow.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/misc_early/builtin_type_shadow.rs b/clippy_lints/src/misc_early/builtin_type_shadow.rs
new file mode 100644
index 00000000000..9f6b0bdc7a4
--- /dev/null
+++ b/clippy_lints/src/misc_early/builtin_type_shadow.rs
@@ -0,0 +1,19 @@
+use clippy_utils::diagnostics::span_lint;
+use rustc_ast::ast::{GenericParam, GenericParamKind};
+use rustc_hir::PrimTy;
+use rustc_lint::EarlyContext;
+
+use super::BUILTIN_TYPE_SHADOW;
+
+pub(super) fn check(cx: &EarlyContext<'_>, param: &GenericParam) {
+    if let GenericParamKind::Type { .. } = param.kind {
+        if let Some(prim_ty) = PrimTy::from_name(param.ident.name) {
+            span_lint(
+                cx,
+                BUILTIN_TYPE_SHADOW,
+                param.ident.span,
+                &format!("this generic shadows the built-in type `{}`", prim_ty.name()),
+            );
+        }
+    }
+}
diff --git a/clippy_lints/src/misc_early/mod.rs b/clippy_lints/src/misc_early/mod.rs
index 3c6a7071c24..94740093d3b 100644
--- a/clippy_lints/src/misc_early/mod.rs
+++ b/clippy_lints/src/misc_early/mod.rs
@@ -1,13 +1,14 @@
+mod builtin_type_shadow;
+
 use clippy_utils::diagnostics::{span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::snippet_opt;
 use rustc_ast::ast::{
-    BindingMode, Expr, ExprKind, GenericParamKind, Generics, Lit, LitFloatType, LitIntType, LitKind, Mutability,
-    NodeId, Pat, PatKind, UnOp,
+    BindingMode, Expr, ExprKind, Generics, Lit, LitFloatType, LitIntType, LitKind, Mutability, NodeId, Pat, PatKind,
+    UnOp,
 };
 use rustc_ast::visit::FnKind;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::Applicability;
-use rustc_hir::PrimTy;
 use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -265,16 +266,7 @@ declare_lint_pass!(MiscEarlyLints => [
 impl EarlyLintPass for MiscEarlyLints {
     fn check_generics(&mut self, cx: &EarlyContext<'_>, gen: &Generics) {
         for param in &gen.params {
-            if let GenericParamKind::Type { .. } = param.kind {
-                if let Some(prim_ty) = PrimTy::from_name(param.ident.name) {
-                    span_lint(
-                        cx,
-                        BUILTIN_TYPE_SHADOW,
-                        param.ident.span,
-                        &format!("this generic shadows the built-in type `{}`", prim_ty.name()),
-                    );
-                }
-            }
+            builtin_type_shadow::check(cx, param);
         }
     }
 
diff --git a/tests/ui/builtin-type-shadow.rs b/tests/ui/builtin-type-shadow.rs
deleted file mode 100644
index 69b8b6a0e68..00000000000
--- a/tests/ui/builtin-type-shadow.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-#![warn(clippy::builtin_type_shadow)]
-#![allow(non_camel_case_types)]
-
-fn foo<u32>(a: u32) -> u32 {
-    42
-    // ^ rustc's type error
-}
-
-fn main() {}
diff --git a/tests/ui/builtin-type-shadow.stderr b/tests/ui/builtin-type-shadow.stderr
deleted file mode 100644
index f42b246afd2..00000000000
--- a/tests/ui/builtin-type-shadow.stderr
+++ /dev/null
@@ -1,24 +0,0 @@
-error: this generic shadows the built-in type `u32`
-  --> $DIR/builtin-type-shadow.rs:4:8
-   |
-LL | fn foo<u32>(a: u32) -> u32 {
-   |        ^^^
-   |
-   = note: `-D clippy::builtin-type-shadow` implied by `-D warnings`
-
-error[E0308]: mismatched types
-  --> $DIR/builtin-type-shadow.rs:5:5
-   |
-LL | fn foo<u32>(a: u32) -> u32 {
-   |        ---             --- expected `u32` because of return type
-   |        |
-   |        this type parameter
-LL |     42
-   |     ^^ expected type parameter `u32`, found integer
-   |
-   = note: expected type parameter `u32`
-                        found type `{integer}`
-
-error: aborting due to 2 previous errors
-
-For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/builtin_type_shadow.rs b/tests/ui/builtin_type_shadow.rs
new file mode 100644
index 00000000000..69b8b6a0e68
--- /dev/null
+++ b/tests/ui/builtin_type_shadow.rs
@@ -0,0 +1,9 @@
+#![warn(clippy::builtin_type_shadow)]
+#![allow(non_camel_case_types)]
+
+fn foo<u32>(a: u32) -> u32 {
+    42
+    // ^ rustc's type error
+}
+
+fn main() {}
diff --git a/tests/ui/builtin_type_shadow.stderr b/tests/ui/builtin_type_shadow.stderr
new file mode 100644
index 00000000000..47a8a1e623e
--- /dev/null
+++ b/tests/ui/builtin_type_shadow.stderr
@@ -0,0 +1,24 @@
+error: this generic shadows the built-in type `u32`
+  --> $DIR/builtin_type_shadow.rs:4:8
+   |
+LL | fn foo<u32>(a: u32) -> u32 {
+   |        ^^^
+   |
+   = note: `-D clippy::builtin-type-shadow` implied by `-D warnings`
+
+error[E0308]: mismatched types
+  --> $DIR/builtin_type_shadow.rs:5:5
+   |
+LL | fn foo<u32>(a: u32) -> u32 {
+   |        ---             --- expected `u32` because of return type
+   |        |
+   |        this type parameter
+LL |     42
+   |     ^^ expected type parameter `u32`, found integer
+   |
+   = note: expected type parameter `u32`
+                        found type `{integer}`
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0308`.
-- 
cgit 1.4.1-3-g733a5


From 55af0cee15cf5c85cbb50ef41eafb4498bde24e3 Mon Sep 17 00:00:00 2001
From: Takayuki <takoyaki0316@gmail.com>
Date: Tue, 4 May 2021 17:20:22 +0900
Subject: move double_neg to its own module

---
 clippy_lints/src/misc_early/double_neg.rs | 23 +++++++++++++++++++++++
 clippy_lints/src/misc_early/mod.rs        | 19 +++----------------
 2 files changed, 26 insertions(+), 16 deletions(-)
 create mode 100644 clippy_lints/src/misc_early/double_neg.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/misc_early/double_neg.rs b/clippy_lints/src/misc_early/double_neg.rs
new file mode 100644
index 00000000000..6f65778e119
--- /dev/null
+++ b/clippy_lints/src/misc_early/double_neg.rs
@@ -0,0 +1,23 @@
+use super::MiscEarlyLints;
+use clippy_utils::diagnostics::span_lint;
+use rustc_ast::ast::{Expr, ExprKind, UnOp};
+use rustc_lint::EarlyContext;
+
+use super::DOUBLE_NEG;
+
+pub(super) fn check(cx: &EarlyContext<'_>, expr: &Expr) {
+    match expr.kind {
+        ExprKind::Unary(UnOp::Neg, ref inner) => {
+            if let ExprKind::Unary(UnOp::Neg, _) = inner.kind {
+                span_lint(
+                    cx,
+                    DOUBLE_NEG,
+                    expr.span,
+                    "`--x` could be misinterpreted as pre-decrement by C programmers, is usually a no-op",
+                );
+            }
+        },
+        ExprKind::Lit(ref lit) => MiscEarlyLints::check_lit(cx, lit),
+        _ => (),
+    }
+}
diff --git a/clippy_lints/src/misc_early/mod.rs b/clippy_lints/src/misc_early/mod.rs
index 94740093d3b..47cc87dfffb 100644
--- a/clippy_lints/src/misc_early/mod.rs
+++ b/clippy_lints/src/misc_early/mod.rs
@@ -1,10 +1,10 @@
 mod builtin_type_shadow;
+mod double_neg;
 
 use clippy_utils::diagnostics::{span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::snippet_opt;
 use rustc_ast::ast::{
-    BindingMode, Expr, ExprKind, Generics, Lit, LitFloatType, LitIntType, LitKind, Mutability, NodeId, Pat, PatKind,
-    UnOp,
+    BindingMode, Expr, Generics, Lit, LitFloatType, LitIntType, LitKind, Mutability, NodeId, Pat, PatKind,
 };
 use rustc_ast::visit::FnKind;
 use rustc_data_structures::fx::FxHashMap;
@@ -393,20 +393,7 @@ impl EarlyLintPass for MiscEarlyLints {
         if in_external_macro(cx.sess(), expr.span) {
             return;
         }
-        match expr.kind {
-            ExprKind::Unary(UnOp::Neg, ref inner) => {
-                if let ExprKind::Unary(UnOp::Neg, _) = inner.kind {
-                    span_lint(
-                        cx,
-                        DOUBLE_NEG,
-                        expr.span,
-                        "`--x` could be misinterpreted as pre-decrement by C programmers, is usually a no-op",
-                    );
-                }
-            },
-            ExprKind::Lit(ref lit) => Self::check_lit(cx, lit),
-            _ => (),
-        }
+        double_neg::check(cx, expr)
     }
 }
 
-- 
cgit 1.4.1-3-g733a5


From 52cfde058668ddce3a191c0c608ac07603175d04 Mon Sep 17 00:00:00 2001
From: Takayuki <takoyaki0316@gmail.com>
Date: Tue, 4 May 2021 17:28:32 +0900
Subject: move redundant_pattern to its own module

---
 clippy_lints/src/misc_early/mod.rs               | 29 +++-------------------
 clippy_lints/src/misc_early/redundant_pattern.rs | 31 ++++++++++++++++++++++++
 2 files changed, 34 insertions(+), 26 deletions(-)
 create mode 100644 clippy_lints/src/misc_early/redundant_pattern.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/misc_early/mod.rs b/clippy_lints/src/misc_early/mod.rs
index 47cc87dfffb..564afdb7f8d 100644
--- a/clippy_lints/src/misc_early/mod.rs
+++ b/clippy_lints/src/misc_early/mod.rs
@@ -1,11 +1,10 @@
 mod builtin_type_shadow;
 mod double_neg;
+mod redundant_pattern;
 
 use clippy_utils::diagnostics::{span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::snippet_opt;
-use rustc_ast::ast::{
-    BindingMode, Expr, Generics, Lit, LitFloatType, LitIntType, LitKind, Mutability, NodeId, Pat, PatKind,
-};
+use rustc_ast::ast::{Expr, Generics, Lit, LitFloatType, LitIntType, LitKind, NodeId, Pat, PatKind};
 use rustc_ast::visit::FnKind;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::Applicability;
@@ -336,29 +335,7 @@ impl EarlyLintPass for MiscEarlyLints {
             }
         }
 
-        if let PatKind::Ident(left, ident, Some(ref right)) = pat.kind {
-            let left_binding = match left {
-                BindingMode::ByRef(Mutability::Mut) => "ref mut ",
-                BindingMode::ByRef(Mutability::Not) => "ref ",
-                BindingMode::ByValue(..) => "",
-            };
-
-            if let PatKind::Wild = right.kind {
-                span_lint_and_sugg(
-                    cx,
-                    REDUNDANT_PATTERN,
-                    pat.span,
-                    &format!(
-                        "the `{} @ _` pattern can be written as just `{}`",
-                        ident.name, ident.name,
-                    ),
-                    "try",
-                    format!("{}{}", left_binding, ident.name),
-                    Applicability::MachineApplicable,
-                );
-            }
-        }
-
+        redundant_pattern::check(cx, pat);
         check_unneeded_wildcard_pattern(cx, pat);
     }
 
diff --git a/clippy_lints/src/misc_early/redundant_pattern.rs b/clippy_lints/src/misc_early/redundant_pattern.rs
new file mode 100644
index 00000000000..525dbf7757c
--- /dev/null
+++ b/clippy_lints/src/misc_early/redundant_pattern.rs
@@ -0,0 +1,31 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use rustc_ast::ast::{BindingMode, Mutability, Pat, PatKind};
+use rustc_errors::Applicability;
+use rustc_lint::EarlyContext;
+
+use super::REDUNDANT_PATTERN;
+
+pub(super) fn check(cx: &EarlyContext<'_>, pat: &Pat) {
+    if let PatKind::Ident(left, ident, Some(ref right)) = pat.kind {
+        let left_binding = match left {
+            BindingMode::ByRef(Mutability::Mut) => "ref mut ",
+            BindingMode::ByRef(Mutability::Not) => "ref ",
+            BindingMode::ByValue(..) => "",
+        };
+
+        if let PatKind::Wild = right.kind {
+            span_lint_and_sugg(
+                cx,
+                REDUNDANT_PATTERN,
+                pat.span,
+                &format!(
+                    "the `{} @ _` pattern can be written as just `{}`",
+                    ident.name, ident.name,
+                ),
+                "try",
+                format!("{}{}", left_binding, ident.name),
+                Applicability::MachineApplicable,
+            );
+        }
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From c0a106e25214a16cb01c87f7f01fd7c95d3534c2 Mon Sep 17 00:00:00 2001
From: Takayuki <takoyaki0316@gmail.com>
Date: Tue, 4 May 2021 19:50:48 +0900
Subject: move unneeded_wildcard_pattern to its own module

---
 clippy_lints/src/misc_early/mod.rs                 | 48 +-------------------
 .../src/misc_early/unneeded_wildcard_pattern.rs    | 52 ++++++++++++++++++++++
 2 files changed, 54 insertions(+), 46 deletions(-)
 create mode 100644 clippy_lints/src/misc_early/unneeded_wildcard_pattern.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/misc_early/mod.rs b/clippy_lints/src/misc_early/mod.rs
index 564afdb7f8d..7d1cd81f49f 100644
--- a/clippy_lints/src/misc_early/mod.rs
+++ b/clippy_lints/src/misc_early/mod.rs
@@ -1,6 +1,7 @@
 mod builtin_type_shadow;
 mod double_neg;
 mod redundant_pattern;
+mod unneeded_wildcard_pattern;
 
 use clippy_utils::diagnostics::{span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::snippet_opt;
@@ -336,7 +337,7 @@ impl EarlyLintPass for MiscEarlyLints {
         }
 
         redundant_pattern::check(cx, pat);
-        check_unneeded_wildcard_pattern(cx, pat);
+        unneeded_wildcard_pattern::check(cx, pat);
     }
 
     fn check_fn(&mut self, cx: &EarlyContext<'_>, fn_kind: FnKind<'_>, _: Span, _: NodeId) {
@@ -478,48 +479,3 @@ impl MiscEarlyLints {
         }
     }
 }
-
-fn check_unneeded_wildcard_pattern(cx: &EarlyContext<'_>, pat: &Pat) {
-    if let PatKind::TupleStruct(_, ref patterns) | PatKind::Tuple(ref patterns) = pat.kind {
-        fn span_lint(cx: &EarlyContext<'_>, span: Span, only_one: bool) {
-            span_lint_and_sugg(
-                cx,
-                UNNEEDED_WILDCARD_PATTERN,
-                span,
-                if only_one {
-                    "this pattern is unneeded as the `..` pattern can match that element"
-                } else {
-                    "these patterns are unneeded as the `..` pattern can match those elements"
-                },
-                if only_one { "remove it" } else { "remove them" },
-                "".to_string(),
-                Applicability::MachineApplicable,
-            );
-        }
-
-        if let Some(rest_index) = patterns.iter().position(|pat| pat.is_rest()) {
-            if let Some((left_index, left_pat)) = patterns[..rest_index]
-                .iter()
-                .rev()
-                .take_while(|pat| matches!(pat.kind, PatKind::Wild))
-                .enumerate()
-                .last()
-            {
-                span_lint(cx, left_pat.span.until(patterns[rest_index].span), left_index == 0);
-            }
-
-            if let Some((right_index, right_pat)) = patterns[rest_index + 1..]
-                .iter()
-                .take_while(|pat| matches!(pat.kind, PatKind::Wild))
-                .enumerate()
-                .last()
-            {
-                span_lint(
-                    cx,
-                    patterns[rest_index].span.shrink_to_hi().to(right_pat.span),
-                    right_index == 0,
-                );
-            }
-        }
-    }
-}
diff --git a/clippy_lints/src/misc_early/unneeded_wildcard_pattern.rs b/clippy_lints/src/misc_early/unneeded_wildcard_pattern.rs
new file mode 100644
index 00000000000..4dd032d78f1
--- /dev/null
+++ b/clippy_lints/src/misc_early/unneeded_wildcard_pattern.rs
@@ -0,0 +1,52 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use rustc_ast::ast::{Pat, PatKind};
+use rustc_errors::Applicability;
+use rustc_lint::EarlyContext;
+use rustc_span::source_map::Span;
+
+use super::UNNEEDED_WILDCARD_PATTERN;
+
+pub(super) fn check(cx: &EarlyContext<'_>, pat: &Pat) {
+    if let PatKind::TupleStruct(_, ref patterns) | PatKind::Tuple(ref patterns) = pat.kind {
+        if let Some(rest_index) = patterns.iter().position(|pat| pat.is_rest()) {
+            if let Some((left_index, left_pat)) = patterns[..rest_index]
+                .iter()
+                .rev()
+                .take_while(|pat| matches!(pat.kind, PatKind::Wild))
+                .enumerate()
+                .last()
+            {
+                span_lint(cx, left_pat.span.until(patterns[rest_index].span), left_index == 0);
+            }
+
+            if let Some((right_index, right_pat)) = patterns[rest_index + 1..]
+                .iter()
+                .take_while(|pat| matches!(pat.kind, PatKind::Wild))
+                .enumerate()
+                .last()
+            {
+                span_lint(
+                    cx,
+                    patterns[rest_index].span.shrink_to_hi().to(right_pat.span),
+                    right_index == 0,
+                );
+            }
+        }
+    }
+}
+
+fn span_lint(cx: &EarlyContext<'_>, span: Span, only_one: bool) {
+    span_lint_and_sugg(
+        cx,
+        UNNEEDED_WILDCARD_PATTERN,
+        span,
+        if only_one {
+            "this pattern is unneeded as the `..` pattern can match that element"
+        } else {
+            "these patterns are unneeded as the `..` pattern can match those elements"
+        },
+        if only_one { "remove it" } else { "remove them" },
+        "".to_string(),
+        Applicability::MachineApplicable,
+    );
+}
-- 
cgit 1.4.1-3-g733a5


From 0854f0caee1d6d16e57eb1d3f5abf539b3bee3f0 Mon Sep 17 00:00:00 2001
From: flip1995 <philipp.krones@embecosm.com>
Date: Tue, 4 May 2021 16:48:25 +0200
Subject: Don't trigger `field_reassign_with_default` in macros

Producing a good suggestion for this lint is already hard when no macros
are involved. With macros the lint message and the suggestion are just
confusing. Since both, producing a good suggestion and figuring out if
this pattern can be re-written inside a macro is nearly impossible, just
bail out.
---
 clippy_lints/src/default.rs                 |  3 +--
 tests/ui/field_reassign_with_default.rs     | 20 ++++++++++++++++
 tests/ui/field_reassign_with_default.stderr | 36 ++++++++++++++---------------
 3 files changed, 39 insertions(+), 20 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/default.rs b/clippy_lints/src/default.rs
index 7a53d390bb4..947479db8f5 100644
--- a/clippy_lints/src/default.rs
+++ b/clippy_lints/src/default.rs
@@ -7,7 +7,6 @@ use rustc_errors::Applicability;
 use rustc_hir::def::Res;
 use rustc_hir::{Block, Expr, ExprKind, PatKind, QPath, Stmt, StmtKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::symbol::{Ident, Symbol};
@@ -122,7 +121,7 @@ impl LateLintPass<'_> for Default {
                 if let StmtKind::Local(local) = stmt.kind;
                 if let Some(expr) = local.init;
                 if !any_parent_is_automatically_derived(cx.tcx, expr.hir_id);
-                if !in_external_macro(cx.tcx.sess, expr.span);
+                if !in_macro(expr.span);
                 // only take bindings to identifiers
                 if let PatKind::Binding(_, binding_id, ident, _) = local.pat.kind;
                 // only when assigning `... = Default::default()`
diff --git a/tests/ui/field_reassign_with_default.rs b/tests/ui/field_reassign_with_default.rs
index 1368c5d7984..787053fb000 100644
--- a/tests/ui/field_reassign_with_default.rs
+++ b/tests/ui/field_reassign_with_default.rs
@@ -29,6 +29,21 @@ struct C {
     i: Vec<i32>,
     j: i64,
 }
+
+#[derive(Default)]
+struct D {
+    a: Option<i32>,
+    b: Option<i32>,
+}
+
+macro_rules! m {
+    ($key:ident: $value:tt) => {{
+        let mut data = $crate::D::default();
+        data.$key = Some($value);
+        data
+    }};
+}
+
 /// Implements .next() that returns a different number each time.
 struct SideEffect(i32);
 
@@ -143,6 +158,11 @@ fn main() {
 
     let mut a: WrapperMulti<i32, i64> = Default::default();
     a.i = 42;
+
+    // Don't lint in macros
+    m! {
+        a: 42
+    };
 }
 
 mod m {
diff --git a/tests/ui/field_reassign_with_default.stderr b/tests/ui/field_reassign_with_default.stderr
index dd7c0360bb1..b56db08ec8a 100644
--- a/tests/ui/field_reassign_with_default.stderr
+++ b/tests/ui/field_reassign_with_default.stderr
@@ -1,108 +1,108 @@
 error: field assignment outside of initializer for an instance created with Default::default()
-  --> $DIR/field_reassign_with_default.rs:48:5
+  --> $DIR/field_reassign_with_default.rs:63:5
    |
 LL |     a.i = 42;
    |     ^^^^^^^^^
    |
    = note: `-D clippy::field-reassign-with-default` implied by `-D warnings`
 note: consider initializing the variable with `main::A { i: 42, ..Default::default() }` and removing relevant reassignments
-  --> $DIR/field_reassign_with_default.rs:47:5
+  --> $DIR/field_reassign_with_default.rs:62:5
    |
 LL |     let mut a: A = Default::default();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: field assignment outside of initializer for an instance created with Default::default()
-  --> $DIR/field_reassign_with_default.rs:88:5
+  --> $DIR/field_reassign_with_default.rs:103:5
    |
 LL |     a.j = 43;
    |     ^^^^^^^^^
    |
 note: consider initializing the variable with `main::A { j: 43, i: 42 }` and removing relevant reassignments
-  --> $DIR/field_reassign_with_default.rs:87:5
+  --> $DIR/field_reassign_with_default.rs:102:5
    |
 LL |     let mut a: A = Default::default();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: field assignment outside of initializer for an instance created with Default::default()
-  --> $DIR/field_reassign_with_default.rs:93:5
+  --> $DIR/field_reassign_with_default.rs:108:5
    |
 LL |     a.i = 42;
    |     ^^^^^^^^^
    |
 note: consider initializing the variable with `main::A { i: 42, j: 44 }` and removing relevant reassignments
-  --> $DIR/field_reassign_with_default.rs:92:5
+  --> $DIR/field_reassign_with_default.rs:107:5
    |
 LL |     let mut a: A = Default::default();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: field assignment outside of initializer for an instance created with Default::default()
-  --> $DIR/field_reassign_with_default.rs:99:5
+  --> $DIR/field_reassign_with_default.rs:114:5
    |
 LL |     a.i = 42;
    |     ^^^^^^^^^
    |
 note: consider initializing the variable with `main::A { i: 42, ..Default::default() }` and removing relevant reassignments
-  --> $DIR/field_reassign_with_default.rs:98:5
+  --> $DIR/field_reassign_with_default.rs:113:5
    |
 LL |     let mut a = A::default();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: field assignment outside of initializer for an instance created with Default::default()
-  --> $DIR/field_reassign_with_default.rs:109:5
+  --> $DIR/field_reassign_with_default.rs:124:5
    |
 LL |     a.i = Default::default();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: consider initializing the variable with `main::A { i: Default::default(), ..Default::default() }` and removing relevant reassignments
-  --> $DIR/field_reassign_with_default.rs:108:5
+  --> $DIR/field_reassign_with_default.rs:123:5
    |
 LL |     let mut a: A = Default::default();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: field assignment outside of initializer for an instance created with Default::default()
-  --> $DIR/field_reassign_with_default.rs:113:5
+  --> $DIR/field_reassign_with_default.rs:128:5
    |
 LL |     a.i = Default::default();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: consider initializing the variable with `main::A { i: Default::default(), j: 45 }` and removing relevant reassignments
-  --> $DIR/field_reassign_with_default.rs:112:5
+  --> $DIR/field_reassign_with_default.rs:127:5
    |
 LL |     let mut a: A = Default::default();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: field assignment outside of initializer for an instance created with Default::default()
-  --> $DIR/field_reassign_with_default.rs:135:5
+  --> $DIR/field_reassign_with_default.rs:150:5
    |
 LL |     a.i = vec![1];
    |     ^^^^^^^^^^^^^^
    |
 note: consider initializing the variable with `C { i: vec![1], ..Default::default() }` and removing relevant reassignments
-  --> $DIR/field_reassign_with_default.rs:134:5
+  --> $DIR/field_reassign_with_default.rs:149:5
    |
 LL |     let mut a: C = C::default();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: field assignment outside of initializer for an instance created with Default::default()
-  --> $DIR/field_reassign_with_default.rs:142:5
+  --> $DIR/field_reassign_with_default.rs:157:5
    |
 LL |     a.i = true;
    |     ^^^^^^^^^^^
    |
 note: consider initializing the variable with `Wrapper::<bool> { i: true }` and removing relevant reassignments
-  --> $DIR/field_reassign_with_default.rs:141:5
+  --> $DIR/field_reassign_with_default.rs:156:5
    |
 LL |     let mut a: Wrapper<bool> = Default::default();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: field assignment outside of initializer for an instance created with Default::default()
-  --> $DIR/field_reassign_with_default.rs:145:5
+  --> $DIR/field_reassign_with_default.rs:160:5
    |
 LL |     a.i = 42;
    |     ^^^^^^^^^
    |
 note: consider initializing the variable with `WrapperMulti::<i32, i64> { i: 42, ..Default::default() }` and removing relevant reassignments
-  --> $DIR/field_reassign_with_default.rs:144:5
+  --> $DIR/field_reassign_with_default.rs:159:5
    |
 LL |     let mut a: WrapperMulti<i32, i64> = Default::default();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From 829fde5e1f1163b3218409244863ce64d8c7dd19 Mon Sep 17 00:00:00 2001
From: Takayuki <takoyaki0316@gmail.com>
Date: Wed, 5 May 2021 01:44:38 +0900
Subject: move unneeded_field_pattern to its own module

---
 clippy_lints/src/misc_early/mod.rs                 | 69 +--------------------
 .../src/misc_early/unneeded_field_pattern.rs       | 72 ++++++++++++++++++++++
 2 files changed, 75 insertions(+), 66 deletions(-)
 create mode 100644 clippy_lints/src/misc_early/unneeded_field_pattern.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/misc_early/mod.rs b/clippy_lints/src/misc_early/mod.rs
index 7d1cd81f49f..ee1bff8bf8a 100644
--- a/clippy_lints/src/misc_early/mod.rs
+++ b/clippy_lints/src/misc_early/mod.rs
@@ -1,9 +1,10 @@
 mod builtin_type_shadow;
 mod double_neg;
 mod redundant_pattern;
+mod unneeded_field_pattern;
 mod unneeded_wildcard_pattern;
 
-use clippy_utils::diagnostics::{span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then};
+use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::snippet_opt;
 use rustc_ast::ast::{Expr, Generics, Lit, LitFloatType, LitIntType, LitKind, NodeId, Pat, PatKind};
 use rustc_ast::visit::FnKind;
@@ -271,71 +272,7 @@ impl EarlyLintPass for MiscEarlyLints {
     }
 
     fn check_pat(&mut self, cx: &EarlyContext<'_>, pat: &Pat) {
-        if let PatKind::Struct(ref npat, ref pfields, _) = pat.kind {
-            let mut wilds = 0;
-            let type_name = npat
-                .segments
-                .last()
-                .expect("A path must have at least one segment")
-                .ident
-                .name;
-
-            for field in pfields {
-                if let PatKind::Wild = field.pat.kind {
-                    wilds += 1;
-                }
-            }
-            if !pfields.is_empty() && wilds == pfields.len() {
-                span_lint_and_help(
-                    cx,
-                    UNNEEDED_FIELD_PATTERN,
-                    pat.span,
-                    "all the struct fields are matched to a wildcard pattern, consider using `..`",
-                    None,
-                    &format!("try with `{} {{ .. }}` instead", type_name),
-                );
-                return;
-            }
-            if wilds > 0 {
-                for field in pfields {
-                    if let PatKind::Wild = field.pat.kind {
-                        wilds -= 1;
-                        if wilds > 0 {
-                            span_lint(
-                                cx,
-                                UNNEEDED_FIELD_PATTERN,
-                                field.span,
-                                "you matched a field with a wildcard pattern, consider using `..` instead",
-                            );
-                        } else {
-                            let mut normal = vec![];
-
-                            for field in pfields {
-                                match field.pat.kind {
-                                    PatKind::Wild => {},
-                                    _ => {
-                                        if let Ok(n) = cx.sess().source_map().span_to_snippet(field.span) {
-                                            normal.push(n);
-                                        }
-                                    },
-                                }
-                            }
-
-                            span_lint_and_help(
-                                cx,
-                                UNNEEDED_FIELD_PATTERN,
-                                field.span,
-                                "you matched a field with a wildcard pattern, consider using `..` \
-                                 instead",
-                                None,
-                                &format!("try with `{} {{ {}, .. }}`", type_name, normal[..].join(", ")),
-                            );
-                        }
-                    }
-                }
-            }
-        }
-
+        unneeded_field_pattern::check(cx, pat);
         redundant_pattern::check(cx, pat);
         unneeded_wildcard_pattern::check(cx, pat);
     }
diff --git a/clippy_lints/src/misc_early/unneeded_field_pattern.rs b/clippy_lints/src/misc_early/unneeded_field_pattern.rs
new file mode 100644
index 00000000000..329a0009a3e
--- /dev/null
+++ b/clippy_lints/src/misc_early/unneeded_field_pattern.rs
@@ -0,0 +1,72 @@
+use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
+use rustc_ast::ast::{Pat, PatKind};
+use rustc_lint::{EarlyContext, LintContext};
+
+use super::UNNEEDED_FIELD_PATTERN;
+
+pub(super) fn check(cx: &EarlyContext<'_>, pat: &Pat) {
+    if let PatKind::Struct(ref npat, ref pfields, _) = pat.kind {
+        let mut wilds = 0;
+        let type_name = npat
+            .segments
+            .last()
+            .expect("A path must have at least one segment")
+            .ident
+            .name;
+
+        for field in pfields {
+            if let PatKind::Wild = field.pat.kind {
+                wilds += 1;
+            }
+        }
+        if !pfields.is_empty() && wilds == pfields.len() {
+            span_lint_and_help(
+                cx,
+                UNNEEDED_FIELD_PATTERN,
+                pat.span,
+                "all the struct fields are matched to a wildcard pattern, consider using `..`",
+                None,
+                &format!("try with `{} {{ .. }}` instead", type_name),
+            );
+            return;
+        }
+        if wilds > 0 {
+            for field in pfields {
+                if let PatKind::Wild = field.pat.kind {
+                    wilds -= 1;
+                    if wilds > 0 {
+                        span_lint(
+                            cx,
+                            UNNEEDED_FIELD_PATTERN,
+                            field.span,
+                            "you matched a field with a wildcard pattern, consider using `..` instead",
+                        );
+                    } else {
+                        let mut normal = vec![];
+
+                        for field in pfields {
+                            match field.pat.kind {
+                                PatKind::Wild => {},
+                                _ => {
+                                    if let Ok(n) = cx.sess().source_map().span_to_snippet(field.span) {
+                                        normal.push(n);
+                                    }
+                                },
+                            }
+                        }
+
+                        span_lint_and_help(
+                            cx,
+                            UNNEEDED_FIELD_PATTERN,
+                            field.span,
+                            "you matched a field with a wildcard pattern, consider using `..` \
+                             instead",
+                            None,
+                            &format!("try with `{} {{ {}, .. }}`", type_name, normal[..].join(", ")),
+                        );
+                    }
+                }
+            }
+        }
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From f012e0e3de04ca5b8022a0b8856a12d47d746b5b Mon Sep 17 00:00:00 2001
From: Takayuki <takoyaki0316@gmail.com>
Date: Wed, 5 May 2021 02:10:24 +0900
Subject: move unseparated_literal_suffix to its own module

---
 clippy_lints/src/misc_early/mod.rs                 | 19 ++-------------
 .../src/misc_early/unseparated_literal_suffix.rs   | 27 ++++++++++++++++++++++
 2 files changed, 29 insertions(+), 17 deletions(-)
 create mode 100644 clippy_lints/src/misc_early/unseparated_literal_suffix.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/misc_early/mod.rs b/clippy_lints/src/misc_early/mod.rs
index ee1bff8bf8a..182218e77f6 100644
--- a/clippy_lints/src/misc_early/mod.rs
+++ b/clippy_lints/src/misc_early/mod.rs
@@ -3,6 +3,7 @@ mod double_neg;
 mod redundant_pattern;
 mod unneeded_field_pattern;
 mod unneeded_wildcard_pattern;
+mod unseparated_literal_suffix;
 
 use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::snippet_opt;
@@ -396,23 +397,7 @@ impl MiscEarlyLints {
                 );
             }
         } else if let LitKind::Float(_, LitFloatType::Suffixed(float_ty)) = lit.kind {
-            let suffix = float_ty.name_str();
-            let maybe_last_sep_idx = if let Some(val) = lit_snip.len().checked_sub(suffix.len() + 1) {
-                val
-            } else {
-                return; // It's useless so shouldn't lint.
-            };
-            if lit_snip.as_bytes()[maybe_last_sep_idx] != b'_' {
-                span_lint_and_sugg(
-                    cx,
-                    UNSEPARATED_LITERAL_SUFFIX,
-                    lit.span,
-                    "float type suffix should be separated by an underscore",
-                    "add an underscore",
-                    format!("{}_{}", &lit_snip[..=maybe_last_sep_idx], suffix),
-                    Applicability::MachineApplicable,
-                );
-            }
+            unseparated_literal_suffix::check(cx, lit, float_ty, lit_snip)
         }
     }
 }
diff --git a/clippy_lints/src/misc_early/unseparated_literal_suffix.rs b/clippy_lints/src/misc_early/unseparated_literal_suffix.rs
new file mode 100644
index 00000000000..ffdd5d93a38
--- /dev/null
+++ b/clippy_lints/src/misc_early/unseparated_literal_suffix.rs
@@ -0,0 +1,27 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use rustc_ast::ast::FloatTy;
+use rustc_ast::ast::Lit;
+use rustc_errors::Applicability;
+use rustc_lint::EarlyContext;
+
+use super::UNSEPARATED_LITERAL_SUFFIX;
+
+pub(super) fn check(cx: &EarlyContext<'_>, lit: &Lit, float_ty: FloatTy, lit_snip: String) {
+    let suffix = float_ty.name_str();
+    let maybe_last_sep_idx = if let Some(val) = lit_snip.len().checked_sub(suffix.len() + 1) {
+        val
+    } else {
+        return; // It's useless so shouldn't lint.
+    };
+    if lit_snip.as_bytes()[maybe_last_sep_idx] != b'_' {
+        span_lint_and_sugg(
+            cx,
+            UNSEPARATED_LITERAL_SUFFIX,
+            lit.span,
+            "float type suffix should be separated by an underscore",
+            "add an underscore",
+            format!("{}_{}", &lit_snip[..=maybe_last_sep_idx], suffix),
+            Applicability::MachineApplicable,
+        );
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 0773d8afdb792a3147de53ad590b620be9eef006 Mon Sep 17 00:00:00 2001
From: Takayuki <takoyaki0316@gmail.com>
Date: Wed, 5 May 2021 02:21:26 +0900
Subject: move mixed_case_hex_literals to its own module

---
 .../src/misc_early/mixed_case_hex_literals.rs      | 29 ++++++++++++++++++++++
 clippy_lints/src/misc_early/mod.rs                 | 23 ++---------------
 2 files changed, 31 insertions(+), 21 deletions(-)
 create mode 100644 clippy_lints/src/misc_early/mixed_case_hex_literals.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/misc_early/mixed_case_hex_literals.rs b/clippy_lints/src/misc_early/mixed_case_hex_literals.rs
new file mode 100644
index 00000000000..fbcbfa2556f
--- /dev/null
+++ b/clippy_lints/src/misc_early/mixed_case_hex_literals.rs
@@ -0,0 +1,29 @@
+use clippy_utils::diagnostics::span_lint;
+use rustc_ast::ast::Lit;
+use rustc_lint::EarlyContext;
+
+use super::MIXED_CASE_HEX_LITERALS;
+
+pub(super) fn check(cx: &EarlyContext<'_>, lit: &Lit, maybe_last_sep_idx: usize, lit_snip: String) {
+    if maybe_last_sep_idx <= 2 {
+        // It's meaningless or causes range error.
+        return;
+    }
+    let mut seen = (false, false);
+    for ch in lit_snip.as_bytes()[2..=maybe_last_sep_idx].iter() {
+        match ch {
+            b'a'..=b'f' => seen.0 = true,
+            b'A'..=b'F' => seen.1 = true,
+            _ => {},
+        }
+        if seen.0 && seen.1 {
+            span_lint(
+                cx,
+                MIXED_CASE_HEX_LITERALS,
+                lit.span,
+                "inconsistent casing in hexadecimal literal",
+            );
+            break;
+        }
+    }
+}
diff --git a/clippy_lints/src/misc_early/mod.rs b/clippy_lints/src/misc_early/mod.rs
index 182218e77f6..0bfa6833aac 100644
--- a/clippy_lints/src/misc_early/mod.rs
+++ b/clippy_lints/src/misc_early/mod.rs
@@ -1,5 +1,6 @@
 mod builtin_type_shadow;
 mod double_neg;
+mod mixed_case_hex_literals;
 mod redundant_pattern;
 mod unneeded_field_pattern;
 mod unneeded_wildcard_pattern;
@@ -351,27 +352,7 @@ impl MiscEarlyLints {
             }
 
             if lit_snip.starts_with("0x") {
-                if maybe_last_sep_idx <= 2 {
-                    // It's meaningless or causes range error.
-                    return;
-                }
-                let mut seen = (false, false);
-                for ch in lit_snip.as_bytes()[2..=maybe_last_sep_idx].iter() {
-                    match ch {
-                        b'a'..=b'f' => seen.0 = true,
-                        b'A'..=b'F' => seen.1 = true,
-                        _ => {},
-                    }
-                    if seen.0 && seen.1 {
-                        span_lint(
-                            cx,
-                            MIXED_CASE_HEX_LITERALS,
-                            lit.span,
-                            "inconsistent casing in hexadecimal literal",
-                        );
-                        break;
-                    }
-                }
+                mixed_case_hex_literals::check(cx, lit, maybe_last_sep_idx, lit_snip)
             } else if lit_snip.starts_with("0b") || lit_snip.starts_with("0o") {
                 /* nothing to do */
             } else if value != 0 && lit_snip.starts_with('0') {
-- 
cgit 1.4.1-3-g733a5


From b1faaaeb0cfb3310c2679f22a33d5ec855f8aaf8 Mon Sep 17 00:00:00 2001
From: Mateusz Gacek <96mateusz.gacek@gmail.com>
Date: Mon, 3 May 2021 13:36:08 -0700
Subject: needless_collect: Lint cases with type annotations

---
 clippy_lints/src/loops/needless_collect.rs | 23 ++++++++++++----
 tests/ui/needless_collect_indirect.rs      | 29 +++++++++++++++++++-
 tests/ui/needless_collect_indirect.stderr  | 44 +++++++++++++++++++++++++++++-
 3 files changed, 89 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/needless_collect.rs b/clippy_lints/src/loops/needless_collect.rs
index 4d73aef76e8..293dd8b6b79 100644
--- a/clippy_lints/src/loops/needless_collect.rs
+++ b/clippy_lints/src/loops/needless_collect.rs
@@ -7,9 +7,10 @@ use clippy_utils::{is_trait_method, path_to_local_id, paths};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_block, walk_expr, NestedVisitorMap, Visitor};
-use rustc_hir::{Block, Expr, ExprKind, GenericArg, HirId, Local, Pat, PatKind, QPath, StmtKind};
+use rustc_hir::{Block, Expr, ExprKind, GenericArg, GenericArgs, HirId, Local, Pat, PatKind, QPath, StmtKind, Ty};
 use rustc_lint::LateContext;
 use rustc_middle::hir::map::Map;
+
 use rustc_span::symbol::{sym, Ident};
 use rustc_span::{MultiSpan, Span};
 
@@ -58,18 +59,30 @@ fn check_needless_collect_direct_usage<'tcx>(expr: &'tcx Expr<'_>, cx: &LateCont
 }
 
 fn check_needless_collect_indirect_usage<'tcx>(expr: &'tcx Expr<'_>, cx: &LateContext<'tcx>) {
+    fn get_hir_id<'tcx>(ty: Option<&Ty<'tcx>>, method_args: Option<&GenericArgs<'tcx>>) -> Option<HirId> {
+        if let Some(ty) = ty {
+            return Some(ty.hir_id);
+        }
+
+        if let Some(generic_args) = method_args {
+            if let Some(GenericArg::Type(ref ty)) = generic_args.args.get(0) {
+                return Some(ty.hir_id);
+            }
+        }
+
+        None
+    }
     if let ExprKind::Block(block, _) = expr.kind {
         for stmt in block.stmts {
             if_chain! {
                 if let StmtKind::Local(
                     Local { pat: Pat { hir_id: pat_id, kind: PatKind::Binding(_, _, ident, .. ), .. },
-                    init: Some(init_expr), .. }
+                    init: Some(init_expr), ty, .. }
                 ) = stmt.kind;
                 if let ExprKind::MethodCall(method_name, collect_span, &[ref iter_source], ..) = init_expr.kind;
                 if method_name.ident.name == sym!(collect) && is_trait_method(cx, init_expr, sym::Iterator);
-                if let Some(generic_args) = method_name.args;
-                if let Some(GenericArg::Type(ref ty)) = generic_args.args.get(0);
-                if let ty = cx.typeck_results().node_type(ty.hir_id);
+                if let Some(hir_id) = get_hir_id(*ty, method_name.args);
+                if let ty = cx.typeck_results().node_type(hir_id);
                 if is_type_diagnostic_item(cx, ty, sym::vec_type) ||
                     is_type_diagnostic_item(cx, ty, sym::vecdeque_type) ||
                     match_type(cx, ty, &paths::LINKED_LIST);
diff --git a/tests/ui/needless_collect_indirect.rs b/tests/ui/needless_collect_indirect.rs
index 0918a6868ab..2647c6401a4 100644
--- a/tests/ui/needless_collect_indirect.rs
+++ b/tests/ui/needless_collect_indirect.rs
@@ -1,4 +1,4 @@
-use std::collections::{HashMap, VecDeque};
+use std::collections::{HashMap, LinkedList, VecDeque};
 
 fn main() {
     let sample = [1; 5];
@@ -43,3 +43,30 @@ fn main() {
             .collect::<Vec<_>>();
     }
 }
+
+mod issue7110 {
+    // #7110 - lint for type annotation cases
+    use super::*;
+
+    fn lint_vec(string: &str) -> usize {
+        let buffer: Vec<&str> = string.split('/').collect();
+        buffer.len()
+    }
+    fn lint_vec_deque() -> usize {
+        let sample = [1; 5];
+        let indirect_len: VecDeque<_> = sample.iter().collect();
+        indirect_len.len()
+    }
+    fn lint_linked_list() -> usize {
+        let sample = [1; 5];
+        let indirect_len: LinkedList<_> = sample.iter().collect();
+        indirect_len.len()
+    }
+    fn dont_lint(string: &str) -> usize {
+        let buffer: Vec<&str> = string.split('/').collect();
+        for buff in &buffer {
+            println!("{}", buff);
+        }
+        buffer.len()
+    }
+}
diff --git a/tests/ui/needless_collect_indirect.stderr b/tests/ui/needless_collect_indirect.stderr
index c773b841f3b..642beb2865a 100644
--- a/tests/ui/needless_collect_indirect.stderr
+++ b/tests/ui/needless_collect_indirect.stderr
@@ -69,5 +69,47 @@ LL |
 LL |     sample.into_iter().any(|x| x == a);
    |
 
-error: aborting due to 5 previous errors
+error: avoid using `collect()` when not needed
+  --> $DIR/needless_collect_indirect.rs:52:51
+   |
+LL |         let buffer: Vec<&str> = string.split('/').collect();
+   |                                                   ^^^^^^^
+LL |         buffer.len()
+   |         ------------ the iterator could be used here instead
+   |
+help: take the original Iterator's count instead of collecting it and finding the length
+   |
+LL |         
+LL |         string.split('/').count()
+   |
+
+error: avoid using `collect()` when not needed
+  --> $DIR/needless_collect_indirect.rs:57:55
+   |
+LL |         let indirect_len: VecDeque<_> = sample.iter().collect();
+   |                                                       ^^^^^^^
+LL |         indirect_len.len()
+   |         ------------------ the iterator could be used here instead
+   |
+help: take the original Iterator's count instead of collecting it and finding the length
+   |
+LL |         
+LL |         sample.iter().count()
+   |
+
+error: avoid using `collect()` when not needed
+  --> $DIR/needless_collect_indirect.rs:62:57
+   |
+LL |         let indirect_len: LinkedList<_> = sample.iter().collect();
+   |                                                         ^^^^^^^
+LL |         indirect_len.len()
+   |         ------------------ the iterator could be used here instead
+   |
+help: take the original Iterator's count instead of collecting it and finding the length
+   |
+LL |         
+LL |         sample.iter().count()
+   |
+
+error: aborting due to 8 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 1835d8a2383c8ae3d26cdcba594fdb933a41f3fb Mon Sep 17 00:00:00 2001
From: Mateusz Gacek <96mateusz.gacek@gmail.com>
Date: Tue, 4 May 2021 12:36:20 -0700
Subject: needless_collect: Add `BinaryHeap` for indirect usage lint

---
 clippy_lints/src/loops/needless_collect.rs |  1 +
 tests/ui/needless_collect_indirect.rs      |  7 ++++++-
 tests/ui/needless_collect_indirect.stderr  | 16 +++++++++++++++-
 3 files changed, 22 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/needless_collect.rs b/clippy_lints/src/loops/needless_collect.rs
index 293dd8b6b79..88d586c9346 100644
--- a/clippy_lints/src/loops/needless_collect.rs
+++ b/clippy_lints/src/loops/needless_collect.rs
@@ -85,6 +85,7 @@ fn check_needless_collect_indirect_usage<'tcx>(expr: &'tcx Expr<'_>, cx: &LateCo
                 if let ty = cx.typeck_results().node_type(hir_id);
                 if is_type_diagnostic_item(cx, ty, sym::vec_type) ||
                     is_type_diagnostic_item(cx, ty, sym::vecdeque_type) ||
+                    is_type_diagnostic_item(cx, ty, sym::BinaryHeap) ||
                     match_type(cx, ty, &paths::LINKED_LIST);
                 if let Some(iter_calls) = detect_iter_and_into_iters(block, *ident);
                 if let [iter_call] = &*iter_calls;
diff --git a/tests/ui/needless_collect_indirect.rs b/tests/ui/needless_collect_indirect.rs
index 2647c6401a4..2458bf1e490 100644
--- a/tests/ui/needless_collect_indirect.rs
+++ b/tests/ui/needless_collect_indirect.rs
@@ -1,4 +1,4 @@
-use std::collections::{HashMap, LinkedList, VecDeque};
+use std::collections::{BinaryHeap, HashMap, LinkedList, VecDeque};
 
 fn main() {
     let sample = [1; 5];
@@ -62,6 +62,11 @@ mod issue7110 {
         let indirect_len: LinkedList<_> = sample.iter().collect();
         indirect_len.len()
     }
+    fn lint_binary_heap() -> usize {
+        let sample = [1; 5];
+        let indirect_len: BinaryHeap<_> = sample.iter().collect();
+        indirect_len.len()
+    }
     fn dont_lint(string: &str) -> usize {
         let buffer: Vec<&str> = string.split('/').collect();
         for buff in &buffer {
diff --git a/tests/ui/needless_collect_indirect.stderr b/tests/ui/needless_collect_indirect.stderr
index 642beb2865a..f094e182a48 100644
--- a/tests/ui/needless_collect_indirect.stderr
+++ b/tests/ui/needless_collect_indirect.stderr
@@ -111,5 +111,19 @@ LL |
 LL |         sample.iter().count()
    |
 
-error: aborting due to 8 previous errors
+error: avoid using `collect()` when not needed
+  --> $DIR/needless_collect_indirect.rs:67:57
+   |
+LL |         let indirect_len: BinaryHeap<_> = sample.iter().collect();
+   |                                                         ^^^^^^^
+LL |         indirect_len.len()
+   |         ------------------ the iterator could be used here instead
+   |
+help: take the original Iterator's count instead of collecting it and finding the length
+   |
+LL |         
+LL |         sample.iter().count()
+   |
+
+error: aborting due to 9 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From b1567f4466388df8377512580d72513e1e4e0e48 Mon Sep 17 00:00:00 2001
From: Takayuki <takoyaki0316@gmail.com>
Date: Wed, 5 May 2021 06:18:58 +0900
Subject: move zero_prefixed_literal to its own module

---
 clippy_lints/src/misc_early/mod.rs                 | 24 +++---------------
 .../src/misc_early/zero_prefixed_literal.rs        | 29 ++++++++++++++++++++++
 2 files changed, 32 insertions(+), 21 deletions(-)
 create mode 100644 clippy_lints/src/misc_early/zero_prefixed_literal.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/misc_early/mod.rs b/clippy_lints/src/misc_early/mod.rs
index 0bfa6833aac..4b1d55beca8 100644
--- a/clippy_lints/src/misc_early/mod.rs
+++ b/clippy_lints/src/misc_early/mod.rs
@@ -5,8 +5,9 @@ mod redundant_pattern;
 mod unneeded_field_pattern;
 mod unneeded_wildcard_pattern;
 mod unseparated_literal_suffix;
+mod zero_prefixed_literal;
 
-use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg, span_lint_and_then};
+use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg};
 use clippy_utils::source::snippet_opt;
 use rustc_ast::ast::{Expr, Generics, Lit, LitFloatType, LitIntType, LitKind, NodeId, Pat, PatKind};
 use rustc_ast::visit::FnKind;
@@ -356,26 +357,7 @@ impl MiscEarlyLints {
             } else if lit_snip.starts_with("0b") || lit_snip.starts_with("0o") {
                 /* nothing to do */
             } else if value != 0 && lit_snip.starts_with('0') {
-                span_lint_and_then(
-                    cx,
-                    ZERO_PREFIXED_LITERAL,
-                    lit.span,
-                    "this is a decimal constant",
-                    |diag| {
-                        diag.span_suggestion(
-                            lit.span,
-                            "if you mean to use a decimal constant, remove the `0` to avoid confusion",
-                            lit_snip.trim_start_matches(|c| c == '_' || c == '0').to_string(),
-                            Applicability::MaybeIncorrect,
-                        );
-                        diag.span_suggestion(
-                            lit.span,
-                            "if you mean to use an octal constant, use `0o`",
-                            format!("0o{}", lit_snip.trim_start_matches(|c| c == '_' || c == '0')),
-                            Applicability::MaybeIncorrect,
-                        );
-                    },
-                );
+                zero_prefixed_literal::check(cx, lit, lit_snip)
             }
         } else if let LitKind::Float(_, LitFloatType::Suffixed(float_ty)) = lit.kind {
             unseparated_literal_suffix::check(cx, lit, float_ty, lit_snip)
diff --git a/clippy_lints/src/misc_early/zero_prefixed_literal.rs b/clippy_lints/src/misc_early/zero_prefixed_literal.rs
new file mode 100644
index 00000000000..16add0fa1b4
--- /dev/null
+++ b/clippy_lints/src/misc_early/zero_prefixed_literal.rs
@@ -0,0 +1,29 @@
+use clippy_utils::diagnostics::span_lint_and_then;
+use rustc_ast::ast::Lit;
+use rustc_errors::Applicability;
+use rustc_lint::EarlyContext;
+
+use super::ZERO_PREFIXED_LITERAL;
+
+pub(super) fn check(cx: &EarlyContext<'_>, lit: &Lit, lit_snip: String) {
+    span_lint_and_then(
+        cx,
+        ZERO_PREFIXED_LITERAL,
+        lit.span,
+        "this is a decimal constant",
+        |diag| {
+            diag.span_suggestion(
+                lit.span,
+                "if you mean to use a decimal constant, remove the `0` to avoid confusion",
+                lit_snip.trim_start_matches(|c| c == '_' || c == '0').to_string(),
+                Applicability::MaybeIncorrect,
+            );
+            diag.span_suggestion(
+                lit.span,
+                "if you mean to use an octal constant, use `0o`",
+                format!("0o{}", lit_snip.trim_start_matches(|c| c == '_' || c == '0')),
+                Applicability::MaybeIncorrect,
+            );
+        },
+    );
+}
-- 
cgit 1.4.1-3-g733a5


From 919ed2ba03f6bf7b02df6eda53d1cbfc28161448 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Tue, 4 May 2021 16:22:43 -0500
Subject: Fix needless_quesiton_mark false positive

---
 clippy_lints/src/needless_question_mark.rs | 112 +++++------------------------
 tests/ui/needless_question_mark.fixed      |   5 ++
 tests/ui/needless_question_mark.rs         |   5 ++
 tests/ui/needless_question_mark.stderr     |   2 +-
 4 files changed, 30 insertions(+), 94 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/needless_question_mark.rs b/clippy_lints/src/needless_question_mark.rs
index 7b156a8c49d..5c9cce6aad4 100644
--- a/clippy_lints/src/needless_question_mark.rs
+++ b/clippy_lints/src/needless_question_mark.rs
@@ -1,14 +1,13 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::is_lang_ctor;
 use clippy_utils::source::snippet;
-use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{differing_macro_contexts, is_lang_ctor};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::LangItem::{OptionSome, ResultOk};
 use rustc_hir::{Body, Expr, ExprKind, LangItem, MatchSource, QPath};
 use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::TyS;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::sym;
 
 declare_clippy_lint! {
     /// **What it does:**
@@ -63,12 +62,6 @@ declare_clippy_lint! {
 
 declare_lint_pass!(NeedlessQuestionMark => [NEEDLESS_QUESTION_MARK]);
 
-#[derive(Debug)]
-enum SomeOkCall<'a> {
-    SomeCall(&'a Expr<'a>, &'a Expr<'a>),
-    OkCall(&'a Expr<'a>, &'a Expr<'a>),
-}
-
 impl LateLintPass<'_> for NeedlessQuestionMark {
     /*
      * The question mark operator is compatible with both Result<T, E> and Option<T>,
@@ -90,104 +83,37 @@ impl LateLintPass<'_> for NeedlessQuestionMark {
      */
 
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &'_ Expr<'_>) {
-        let e = match &expr.kind {
-            ExprKind::Ret(Some(e)) => e,
-            _ => return,
-        };
-
-        if let Some(ok_some_call) = is_some_or_ok_call(cx, e) {
-            emit_lint(cx, &ok_some_call);
+        if let ExprKind::Ret(Some(e)) = expr.kind {
+            check(cx, e);
         }
     }
 
     fn check_body(&mut self, cx: &LateContext<'_>, body: &'_ Body<'_>) {
-        // Function / Closure block
-        let expr_opt = if let ExprKind::Block(block, _) = &body.value.kind {
-            block.expr
-        } else {
-            // Single line closure
-            Some(&body.value)
-        };
-
-        if_chain! {
-            if let Some(expr) = expr_opt;
-            if let Some(ok_some_call) = is_some_or_ok_call(cx, expr);
-            then {
-                emit_lint(cx, &ok_some_call);
-            }
-        };
+        check(cx, body.value.peel_blocks());
     }
 }
 
-fn emit_lint(cx: &LateContext<'_>, expr: &SomeOkCall<'_>) {
-    let (entire_expr, inner_expr) = match expr {
-        SomeOkCall::OkCall(outer, inner) | SomeOkCall::SomeCall(outer, inner) => (outer, inner),
+fn check(cx: &LateContext<'_>, expr: &Expr<'_>) {
+    let inner_expr = if_chain! {
+        if let ExprKind::Call(path, [arg]) = &expr.kind;
+        if let ExprKind::Path(ref qpath) = &path.kind;
+        if is_lang_ctor(cx, qpath, OptionSome) || is_lang_ctor(cx, qpath, ResultOk);
+        if let ExprKind::Match(inner_expr_with_q, _, MatchSource::TryDesugar) = &arg.kind;
+        if let ExprKind::Call(called, [inner_expr]) = &inner_expr_with_q.kind;
+        if let ExprKind::Path(QPath::LangItem(LangItem::TryIntoResult, _)) = &called.kind;
+        if expr.span.ctxt() == inner_expr.span.ctxt();
+        let expr_ty = cx.typeck_results().expr_ty(expr);
+        let inner_ty = cx.typeck_results().expr_ty(inner_expr);
+        if TyS::same_type(expr_ty, inner_ty);
+        then { inner_expr } else { return; }
     };
-
     span_lint_and_sugg(
         cx,
         NEEDLESS_QUESTION_MARK,
-        entire_expr.span,
+        expr.span,
         "question mark operator is useless here",
         "try",
         format!("{}", snippet(cx, inner_expr.span, r#""...""#)),
         Applicability::MachineApplicable,
     );
 }
-
-fn is_some_or_ok_call<'a>(cx: &'a LateContext<'_>, expr: &'a Expr<'_>) -> Option<SomeOkCall<'a>> {
-    if_chain! {
-        // Check outer expression matches CALL_IDENT(ARGUMENT) format
-        if let ExprKind::Call(path, args) = &expr.kind;
-        if let ExprKind::Path(ref qpath) = &path.kind;
-        if is_lang_ctor(cx, qpath, OptionSome) || is_lang_ctor(cx, qpath, ResultOk);
-
-        // Extract inner expression from ARGUMENT
-        if let ExprKind::Match(inner_expr_with_q, _, MatchSource::TryDesugar) = &args[0].kind;
-        if let ExprKind::Call(called, args) = &inner_expr_with_q.kind;
-        if args.len() == 1;
-
-        if let ExprKind::Path(QPath::LangItem(LangItem::TryIntoResult, _)) = &called.kind;
-        then {
-            // Extract inner expr type from match argument generated by
-            // question mark operator
-            let inner_expr = &args[0];
-
-            // if the inner expr is inside macro but the outer one is not, do not lint (#6921)
-            if  differing_macro_contexts(expr.span, inner_expr.span) {
-                return None;
-            }
-
-            let inner_ty = cx.typeck_results().expr_ty(inner_expr);
-            let outer_ty = cx.typeck_results().expr_ty(expr);
-
-            // Check if outer and inner type are Option
-            let outer_is_some = is_type_diagnostic_item(cx, outer_ty, sym::option_type);
-            let inner_is_some = is_type_diagnostic_item(cx, inner_ty, sym::option_type);
-
-            // Check for Option MSRV
-            if outer_is_some && inner_is_some {
-                return Some(SomeOkCall::SomeCall(expr, inner_expr));
-            }
-
-            // Check if outer and inner type are Result
-            let outer_is_result = is_type_diagnostic_item(cx, outer_ty, sym::result_type);
-            let inner_is_result = is_type_diagnostic_item(cx, inner_ty, sym::result_type);
-
-            // Additional check: if the error type of the Result can be converted
-            // via the From trait, then don't match
-            let does_not_call_from = !has_implicit_error_from(cx, expr, inner_expr);
-
-            // Must meet Result MSRV
-            if outer_is_result && inner_is_result && does_not_call_from {
-                return Some(SomeOkCall::OkCall(expr, inner_expr));
-            }
-        }
-    }
-
-    None
-}
-
-fn has_implicit_error_from(cx: &LateContext<'_>, entire_expr: &Expr<'_>, inner_result_expr: &Expr<'_>) -> bool {
-    return cx.typeck_results().expr_ty(entire_expr) != cx.typeck_results().expr_ty(inner_result_expr);
-}
diff --git a/tests/ui/needless_question_mark.fixed b/tests/ui/needless_question_mark.fixed
index 52ddd9d2dc8..f1fc81aa12b 100644
--- a/tests/ui/needless_question_mark.fixed
+++ b/tests/ui/needless_question_mark.fixed
@@ -94,6 +94,11 @@ where
     Ok(x?)
 }
 
+// not quite needless
+fn deref_ref(s: Option<&String>) -> Option<&str> {
+    Some(s?)
+}
+
 fn main() {}
 
 // #6921 if a macro wraps an expr in Some(  ) and the ? is in the macro use,
diff --git a/tests/ui/needless_question_mark.rs b/tests/ui/needless_question_mark.rs
index 1ea4ba0d83f..44a0c5f61b5 100644
--- a/tests/ui/needless_question_mark.rs
+++ b/tests/ui/needless_question_mark.rs
@@ -94,6 +94,11 @@ where
     Ok(x?)
 }
 
+// not quite needless
+fn deref_ref(s: Option<&String>) -> Option<&str> {
+    Some(s?)
+}
+
 fn main() {}
 
 // #6921 if a macro wraps an expr in Some(  ) and the ? is in the macro use,
diff --git a/tests/ui/needless_question_mark.stderr b/tests/ui/needless_question_mark.stderr
index afd68d91e51..fa698224530 100644
--- a/tests/ui/needless_question_mark.stderr
+++ b/tests/ui/needless_question_mark.stderr
@@ -67,7 +67,7 @@ LL |         return Ok(t.magic?);
    |                ^^^^^^^^^^^^ help: try: `t.magic`
 
 error: question mark operator is useless here
-  --> $DIR/needless_question_mark.rs:115:27
+  --> $DIR/needless_question_mark.rs:120:27
    |
 LL |         || -> Option<_> { Some(Some($expr)?) }()
    |                           ^^^^^^^^^^^^^^^^^^ help: try: `Some($expr)`
-- 
cgit 1.4.1-3-g733a5


From 2dfb246d8e8db3280326330b9ca67aee5d3214e9 Mon Sep 17 00:00:00 2001
From: Takayuki <takoyaki0316@gmail.com>
Date: Wed, 5 May 2021 06:39:38 +0900
Subject: refactor unseparated_literal_suffix

---
 .../src/misc_early/mixed_case_hex_literals.rs      |  7 +++++-
 clippy_lints/src/misc_early/mod.rs                 | 28 ++++------------------
 .../src/misc_early/unseparated_literal_suffix.rs   |  9 ++++---
 3 files changed, 15 insertions(+), 29 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/misc_early/mixed_case_hex_literals.rs b/clippy_lints/src/misc_early/mixed_case_hex_literals.rs
index fbcbfa2556f..98b0f7b5664 100644
--- a/clippy_lints/src/misc_early/mixed_case_hex_literals.rs
+++ b/clippy_lints/src/misc_early/mixed_case_hex_literals.rs
@@ -4,7 +4,12 @@ use rustc_lint::EarlyContext;
 
 use super::MIXED_CASE_HEX_LITERALS;
 
-pub(super) fn check(cx: &EarlyContext<'_>, lit: &Lit, maybe_last_sep_idx: usize, lit_snip: String) {
+pub(super) fn check(cx: &EarlyContext<'_>, lit: &Lit, suffix: &str, lit_snip: String) {
+    let maybe_last_sep_idx = if let Some(val) = lit_snip.len().checked_sub(suffix.len() + 1) {
+        val
+    } else {
+        return; // It's useless so shouldn't lint.
+    };
     if maybe_last_sep_idx <= 2 {
         // It's meaningless or causes range error.
         return;
diff --git a/clippy_lints/src/misc_early/mod.rs b/clippy_lints/src/misc_early/mod.rs
index 4b1d55beca8..146d0c367a8 100644
--- a/clippy_lints/src/misc_early/mod.rs
+++ b/clippy_lints/src/misc_early/mod.rs
@@ -7,12 +7,11 @@ mod unneeded_wildcard_pattern;
 mod unseparated_literal_suffix;
 mod zero_prefixed_literal;
 
-use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg};
+use clippy_utils::diagnostics::span_lint;
 use clippy_utils::source::snippet_opt;
 use rustc_ast::ast::{Expr, Generics, Lit, LitFloatType, LitIntType, LitKind, NodeId, Pat, PatKind};
 use rustc_ast::visit::FnKind;
 use rustc_data_structures::fx::FxHashMap;
-use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -333,34 +332,17 @@ impl MiscEarlyLints {
                 LitIntType::Unsigned(ty) => ty.name_str(),
                 LitIntType::Unsuffixed => "",
             };
-
-            let maybe_last_sep_idx = if let Some(val) = lit_snip.len().checked_sub(suffix.len() + 1) {
-                val
-            } else {
-                return; // It's useless so shouldn't lint.
-            };
-            // Do not lint when literal is unsuffixed.
-            if !suffix.is_empty() && lit_snip.as_bytes()[maybe_last_sep_idx] != b'_' {
-                span_lint_and_sugg(
-                    cx,
-                    UNSEPARATED_LITERAL_SUFFIX,
-                    lit.span,
-                    "integer type suffix should be separated by an underscore",
-                    "add an underscore",
-                    format!("{}_{}", &lit_snip[..=maybe_last_sep_idx], suffix),
-                    Applicability::MachineApplicable,
-                );
-            }
-
+            unseparated_literal_suffix::check(cx, lit, &lit_snip, suffix, "integer");
             if lit_snip.starts_with("0x") {
-                mixed_case_hex_literals::check(cx, lit, maybe_last_sep_idx, lit_snip)
+                mixed_case_hex_literals::check(cx, lit, suffix, lit_snip)
             } else if lit_snip.starts_with("0b") || lit_snip.starts_with("0o") {
                 /* nothing to do */
             } else if value != 0 && lit_snip.starts_with('0') {
                 zero_prefixed_literal::check(cx, lit, lit_snip)
             }
         } else if let LitKind::Float(_, LitFloatType::Suffixed(float_ty)) = lit.kind {
-            unseparated_literal_suffix::check(cx, lit, float_ty, lit_snip)
+            let suffix = float_ty.name_str();
+            unseparated_literal_suffix::check(cx, lit, &lit_snip, suffix, "float")
         }
     }
 }
diff --git a/clippy_lints/src/misc_early/unseparated_literal_suffix.rs b/clippy_lints/src/misc_early/unseparated_literal_suffix.rs
index ffdd5d93a38..1ffdd4cf676 100644
--- a/clippy_lints/src/misc_early/unseparated_literal_suffix.rs
+++ b/clippy_lints/src/misc_early/unseparated_literal_suffix.rs
@@ -1,24 +1,23 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use rustc_ast::ast::FloatTy;
 use rustc_ast::ast::Lit;
 use rustc_errors::Applicability;
 use rustc_lint::EarlyContext;
 
 use super::UNSEPARATED_LITERAL_SUFFIX;
 
-pub(super) fn check(cx: &EarlyContext<'_>, lit: &Lit, float_ty: FloatTy, lit_snip: String) {
-    let suffix = float_ty.name_str();
+pub(super) fn check(cx: &EarlyContext<'_>, lit: &Lit, lit_snip: &String, suffix: &str, sugg_type: &str) {
     let maybe_last_sep_idx = if let Some(val) = lit_snip.len().checked_sub(suffix.len() + 1) {
         val
     } else {
         return; // It's useless so shouldn't lint.
     };
-    if lit_snip.as_bytes()[maybe_last_sep_idx] != b'_' {
+    // Do not lint when literal is unsuffixed.
+    if !suffix.is_empty() && lit_snip.as_bytes()[maybe_last_sep_idx] != b'_' {
         span_lint_and_sugg(
             cx,
             UNSEPARATED_LITERAL_SUFFIX,
             lit.span,
-            "float type suffix should be separated by an underscore",
+            &format!("{} type suffix should be separated by an underscore", sugg_type),
             "add an underscore",
             format!("{}_{}", &lit_snip[..=maybe_last_sep_idx], suffix),
             Applicability::MachineApplicable,
-- 
cgit 1.4.1-3-g733a5


From 3fbb060379485605fc8649ba5e749b141fbb9335 Mon Sep 17 00:00:00 2001
From: Takayuki <takoyaki0316@gmail.com>
Date: Wed, 5 May 2021 06:53:04 +0900
Subject: replace lit_snip type with &str

---
 clippy_lints/src/misc_early/mixed_case_hex_literals.rs    | 2 +-
 clippy_lints/src/misc_early/mod.rs                        | 4 ++--
 clippy_lints/src/misc_early/unseparated_literal_suffix.rs | 2 +-
 clippy_lints/src/misc_early/zero_prefixed_literal.rs      | 2 +-
 4 files changed, 5 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/misc_early/mixed_case_hex_literals.rs b/clippy_lints/src/misc_early/mixed_case_hex_literals.rs
index 98b0f7b5664..80e24213100 100644
--- a/clippy_lints/src/misc_early/mixed_case_hex_literals.rs
+++ b/clippy_lints/src/misc_early/mixed_case_hex_literals.rs
@@ -4,7 +4,7 @@ use rustc_lint::EarlyContext;
 
 use super::MIXED_CASE_HEX_LITERALS;
 
-pub(super) fn check(cx: &EarlyContext<'_>, lit: &Lit, suffix: &str, lit_snip: String) {
+pub(super) fn check(cx: &EarlyContext<'_>, lit: &Lit, suffix: &str, lit_snip: &str) {
     let maybe_last_sep_idx = if let Some(val) = lit_snip.len().checked_sub(suffix.len() + 1) {
         val
     } else {
diff --git a/clippy_lints/src/misc_early/mod.rs b/clippy_lints/src/misc_early/mod.rs
index 146d0c367a8..dd38316fa25 100644
--- a/clippy_lints/src/misc_early/mod.rs
+++ b/clippy_lints/src/misc_early/mod.rs
@@ -334,11 +334,11 @@ impl MiscEarlyLints {
             };
             unseparated_literal_suffix::check(cx, lit, &lit_snip, suffix, "integer");
             if lit_snip.starts_with("0x") {
-                mixed_case_hex_literals::check(cx, lit, suffix, lit_snip)
+                mixed_case_hex_literals::check(cx, lit, suffix, &lit_snip)
             } else if lit_snip.starts_with("0b") || lit_snip.starts_with("0o") {
                 /* nothing to do */
             } else if value != 0 && lit_snip.starts_with('0') {
-                zero_prefixed_literal::check(cx, lit, lit_snip)
+                zero_prefixed_literal::check(cx, lit, &lit_snip)
             }
         } else if let LitKind::Float(_, LitFloatType::Suffixed(float_ty)) = lit.kind {
             let suffix = float_ty.name_str();
diff --git a/clippy_lints/src/misc_early/unseparated_literal_suffix.rs b/clippy_lints/src/misc_early/unseparated_literal_suffix.rs
index 1ffdd4cf676..2018aa6184a 100644
--- a/clippy_lints/src/misc_early/unseparated_literal_suffix.rs
+++ b/clippy_lints/src/misc_early/unseparated_literal_suffix.rs
@@ -5,7 +5,7 @@ use rustc_lint::EarlyContext;
 
 use super::UNSEPARATED_LITERAL_SUFFIX;
 
-pub(super) fn check(cx: &EarlyContext<'_>, lit: &Lit, lit_snip: &String, suffix: &str, sugg_type: &str) {
+pub(super) fn check(cx: &EarlyContext<'_>, lit: &Lit, lit_snip: &str, suffix: &str, sugg_type: &str) {
     let maybe_last_sep_idx = if let Some(val) = lit_snip.len().checked_sub(suffix.len() + 1) {
         val
     } else {
diff --git a/clippy_lints/src/misc_early/zero_prefixed_literal.rs b/clippy_lints/src/misc_early/zero_prefixed_literal.rs
index 16add0fa1b4..4963bba82f2 100644
--- a/clippy_lints/src/misc_early/zero_prefixed_literal.rs
+++ b/clippy_lints/src/misc_early/zero_prefixed_literal.rs
@@ -5,7 +5,7 @@ use rustc_lint::EarlyContext;
 
 use super::ZERO_PREFIXED_LITERAL;
 
-pub(super) fn check(cx: &EarlyContext<'_>, lit: &Lit, lit_snip: String) {
+pub(super) fn check(cx: &EarlyContext<'_>, lit: &Lit, lit_snip: &str) {
     span_lint_and_then(
         cx,
         ZERO_PREFIXED_LITERAL,
-- 
cgit 1.4.1-3-g733a5


From 83329ec7050da5093b0310ba3140c8c5ec093321 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Tue, 4 May 2021 17:20:15 -0500
Subject: Fix unused_unit macro false positive

---
 clippy_lints/src/unused_unit.rs | 4 +++-
 tests/ui/unused_unit.fixed      | 7 +++++++
 tests/ui/unused_unit.rs         | 7 +++++++
 3 files changed, 17 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unused_unit.rs b/clippy_lints/src/unused_unit.rs
index ce2d0b3ab2f..e14945651f5 100644
--- a/clippy_lints/src/unused_unit.rs
+++ b/clippy_lints/src/unused_unit.rs
@@ -47,7 +47,9 @@ impl EarlyLintPass for UnusedUnit {
         if_chain! {
             if let Some(stmt) = block.stmts.last();
             if let ast::StmtKind::Expr(ref expr) = stmt.kind;
-            if is_unit_expr(expr) && !stmt.span.from_expansion();
+            if is_unit_expr(expr);
+            let ctxt = block.span.ctxt();
+            if stmt.span.ctxt() == ctxt && expr.span.ctxt() == ctxt;
             then {
                 let sp = expr.span;
                 span_lint_and_sugg(
diff --git a/tests/ui/unused_unit.fixed b/tests/ui/unused_unit.fixed
index a192ebde3eb..7bb43cf7ae8 100644
--- a/tests/ui/unused_unit.fixed
+++ b/tests/ui/unused_unit.fixed
@@ -80,3 +80,10 @@ fn test2(){}
 
 #[rustfmt::skip]
 fn test3(){}
+
+fn macro_expr() {
+    macro_rules! e {
+        () => (());
+    }
+    e!()
+}
diff --git a/tests/ui/unused_unit.rs b/tests/ui/unused_unit.rs
index 96041a7dd85..21073fb802a 100644
--- a/tests/ui/unused_unit.rs
+++ b/tests/ui/unused_unit.rs
@@ -80,3 +80,10 @@ fn test2() ->(){}
 
 #[rustfmt::skip]
 fn test3()-> (){}
+
+fn macro_expr() {
+    macro_rules! e {
+        () => (());
+    }
+    e!()
+}
-- 
cgit 1.4.1-3-g733a5


From f79a2a3990e88cba2a2d4c55828a97d2293d6992 Mon Sep 17 00:00:00 2001
From: Mateusz Gacek <96mateusz.gacek@gmail.com>
Date: Wed, 5 May 2021 04:52:03 -0700
Subject: needless_collect: use `node_type_opt` instead of `node_type`

It may prevent future ICEs.
---
 clippy_lints/src/loops/needless_collect.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/needless_collect.rs b/clippy_lints/src/loops/needless_collect.rs
index 88d586c9346..9662a0b22a3 100644
--- a/clippy_lints/src/loops/needless_collect.rs
+++ b/clippy_lints/src/loops/needless_collect.rs
@@ -27,7 +27,7 @@ fn check_needless_collect_direct_usage<'tcx>(expr: &'tcx Expr<'_>, cx: &LateCont
         if chain_method.ident.name == sym!(collect) && is_trait_method(cx, &args[0], sym::Iterator);
         if let Some(generic_args) = chain_method.args;
         if let Some(GenericArg::Type(ref ty)) = generic_args.args.get(0);
-        let ty = cx.typeck_results().node_type(ty.hir_id);
+        if let Some(ty) = cx.typeck_results().node_type_opt(ty.hir_id);
         if is_type_diagnostic_item(cx, ty, sym::vec_type)
             || is_type_diagnostic_item(cx, ty, sym::vecdeque_type)
             || match_type(cx, ty, &paths::BTREEMAP)
@@ -82,7 +82,7 @@ fn check_needless_collect_indirect_usage<'tcx>(expr: &'tcx Expr<'_>, cx: &LateCo
                 if let ExprKind::MethodCall(method_name, collect_span, &[ref iter_source], ..) = init_expr.kind;
                 if method_name.ident.name == sym!(collect) && is_trait_method(cx, init_expr, sym::Iterator);
                 if let Some(hir_id) = get_hir_id(*ty, method_name.args);
-                if let ty = cx.typeck_results().node_type(hir_id);
+                if let Some(ty) = cx.typeck_results().node_type_opt(hir_id);
                 if is_type_diagnostic_item(cx, ty, sym::vec_type) ||
                     is_type_diagnostic_item(cx, ty, sym::vecdeque_type) ||
                     is_type_diagnostic_item(cx, ty, sym::BinaryHeap) ||
-- 
cgit 1.4.1-3-g733a5


From 344f04bea6fd61a10d079ca51d331307f4747288 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Wed, 5 May 2021 08:57:09 -0500
Subject: Fix stack overflow in `redundant_pattern_matching`

---
 clippy_lints/src/matches.rs | 16 ++++++++++++----
 1 file changed, 12 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index c7a25095bf6..a70e8b26087 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -1712,6 +1712,7 @@ mod redundant_pattern_match {
     use clippy_utils::{is_lang_ctor, is_qpath_def_path, is_trait_method, paths};
     use if_chain::if_chain;
     use rustc_ast::ast::LitKind;
+    use rustc_data_structures::fx::FxHashSet;
     use rustc_errors::Applicability;
     use rustc_hir::LangItem::{OptionNone, OptionSome, PollPending, PollReady, ResultErr, ResultOk};
     use rustc_hir::{
@@ -1739,6 +1740,13 @@ mod redundant_pattern_match {
     /// deallocate memory. For these types, and composites containing them, changing the drop order
     /// won't result in any observable side effects.
     fn type_needs_ordered_drop(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
+        type_needs_ordered_drop_inner(cx, ty, &mut FxHashSet::default())
+    }
+
+    fn type_needs_ordered_drop_inner(cx: &LateContext<'tcx>, ty: Ty<'tcx>, seen: &mut FxHashSet<Ty<'tcx>>) -> bool {
+        if !seen.insert(ty) {
+            return false;
+        }
         if !ty.needs_drop(cx.tcx, cx.param_env) {
             false
         } else if !cx
@@ -1750,12 +1758,12 @@ mod redundant_pattern_match {
             // This type doesn't implement drop, so no side effects here.
             // Check if any component type has any.
             match ty.kind() {
-                ty::Tuple(_) => ty.tuple_fields().any(|ty| type_needs_ordered_drop(cx, ty)),
-                ty::Array(ty, _) => type_needs_ordered_drop(cx, ty),
+                ty::Tuple(_) => ty.tuple_fields().any(|ty| type_needs_ordered_drop_inner(cx, ty, seen)),
+                ty::Array(ty, _) => type_needs_ordered_drop_inner(cx, ty, seen),
                 ty::Adt(adt, subs) => adt
                     .all_fields()
                     .map(|f| f.ty(cx.tcx, subs))
-                    .any(|ty| type_needs_ordered_drop(cx, ty)),
+                    .any(|ty| type_needs_ordered_drop_inner(cx, ty, seen)),
                 _ => true,
             }
         }
@@ -1772,7 +1780,7 @@ mod redundant_pattern_match {
         {
             // Check all of the generic arguments.
             if let ty::Adt(_, subs) = ty.kind() {
-                subs.types().any(|ty| type_needs_ordered_drop(cx, ty))
+                subs.types().any(|ty| type_needs_ordered_drop_inner(cx, ty, seen))
             } else {
                 true
             }
-- 
cgit 1.4.1-3-g733a5


From 637751ff62662247480ae1641042a019d8e6609a Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Sun, 31 Jan 2021 14:46:09 +0100
Subject: Metadata collection lint: Basic lint collection

WIP-2021-02-01

WIP-2021-02-01

WIP-2021-02-13
---
 .gitignore                                         |   1 +
 Cargo.toml                                         |   1 +
 clippy_lints/Cargo.toml                            |   2 +
 clippy_lints/src/lib.rs                            |   3 +
 clippy_lints/src/utils/internal_lints.rs           |   3 +
 .../src/utils/internal_lints/metadata_collector.rs | 206 +++++++++++++++++++++
 clippy_lints/src/utils/mod.rs                      |   2 +-
 tests/dogfood.rs                                   |   9 +
 8 files changed, 226 insertions(+), 1 deletion(-)
 create mode 100644 clippy_lints/src/utils/internal_lints/metadata_collector.rs

(limited to 'clippy_lints/src')

diff --git a/.gitignore b/.gitignore
index 376528e3085..523bab18828 100644
--- a/.gitignore
+++ b/.gitignore
@@ -29,6 +29,7 @@ out
 
 # gh pages docs
 util/gh-pages/lints.json
+**/metadata_collection.json
 
 # rustfmt backups
 *.rs.bk
diff --git a/Cargo.toml b/Cargo.toml
index cade44a0a9a..bdee8e40821 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -52,6 +52,7 @@ rustc_tools_util = { version = "0.2.0", path = "rustc_tools_util" }
 deny-warnings = []
 integration = ["tempfile"]
 internal-lints = ["clippy_lints/internal-lints"]
+metadata-collector-lint = ["clippy_lints/metadata-collector-lint"]
 
 [package.metadata.rust-analyzer]
 # This package uses #[feature(rustc_private)]
diff --git a/clippy_lints/Cargo.toml b/clippy_lints/Cargo.toml
index 05cdd9d064a..d1d56fc84f9 100644
--- a/clippy_lints/Cargo.toml
+++ b/clippy_lints/Cargo.toml
@@ -20,6 +20,7 @@ pulldown-cmark = { version = "0.8", default-features = false }
 quine-mc_cluskey = "0.2.2"
 regex-syntax = "0.6"
 serde = { version = "1.0", features = ["derive"] }
+serde_json = { version = "1.0", optional = true }
 toml = "0.5.3"
 unicode-normalization = "0.1"
 semver = "0.11"
@@ -32,6 +33,7 @@ url = { version = "2.1.0", features = ["serde"] }
 deny-warnings = []
 # build clippy with internal lints enabled, off by default
 internal-lints = ["clippy_utils/internal-lints"]
+metadata-collector-lint = ["serde_json"]
 
 [package.metadata.rust-analyzer]
 # This crate uses #[feature(rustc_private)]
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 40a793e48cf..7668d4dd0b1 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1004,6 +1004,9 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         store.register_late_pass(|| box utils::internal_lints::MatchTypeOnDiagItem);
         store.register_late_pass(|| box utils::internal_lints::OuterExpnDataPass);
     }
+    #[cfg(feature = "metadata-collector-lint")]
+    store.register_late_pass(|| box utils::internal_lints::metadata_collector::MetadataCollector::default());
+
     store.register_late_pass(|| box utils::author::Author);
     store.register_late_pass(|| box await_holding_invalid::AwaitHolding);
     store.register_late_pass(|| box serde_api::SerdeApi);
diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs
index 3d3d0e19d26..ee7be24eae8 100644
--- a/clippy_lints/src/utils/internal_lints.rs
+++ b/clippy_lints/src/utils/internal_lints.rs
@@ -32,6 +32,9 @@ use rustc_typeck::hir_ty_to_ty;
 
 use std::borrow::{Borrow, Cow};
 
+#[cfg(feature = "metadata-collector-lint")]
+pub mod metadata_collector;
+
 declare_clippy_lint! {
     /// **What it does:** Checks for various things we like to keep tidy in clippy.
     ///
diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
new file mode 100644
index 00000000000..dc4267697cb
--- /dev/null
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -0,0 +1,206 @@
+//! This lint is used to collect metadata about clippy lints. This metadata is exported as a json
+//! file and then used to generate the [clippy lint list](https://rust-lang.github.io/rust-clippy/master/index.html)
+//!
+//! This module and therefor the entire lint is guarded by a feature flag called
+//! `internal_metadata_lint`
+//!
+//! The metadata currently contains:
+//! - [ ] TODO The lint declaration line for [#1303](https://github.com/rust-lang/rust-clippy/issues/1303)
+//!   and [#6492](https://github.com/rust-lang/rust-clippy/issues/6492)
+//! - [ ] TODO The Applicability for each lint for [#4310](https://github.com/rust-lang/rust-clippy/issues/4310)
+
+// # Applicability
+// - TODO xFrednet 2021-01-17: Find all methods that take and modify applicability or predefine
+//   them?
+// - TODO xFrednet 2021-01-17: Find lint emit and collect applicability
+// # NITs
+// - TODO xFrednet 2021-02-13: Collect depreciations and maybe renames
+
+use if_chain::if_chain;
+use rustc_hir::{ExprKind, Item, ItemKind, Mutability};
+use rustc_lint::{CheckLintNameResult, LateContext, LateLintPass, LintContext, LintId};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::{sym, Loc, Span};
+use serde::Serialize;
+use std::fs::OpenOptions;
+use std::io::prelude::*;
+
+use crate::utils::internal_lints::is_lint_ref_type;
+use crate::utils::span_lint;
+
+const OUTPUT_FILE: &str = "metadata_collection.json";
+const BLACK_LISTED_LINTS: [&str; 2] = ["lint_author", "deep_code_inspection"];
+
+declare_clippy_lint! {
+    /// **What it does:** Collects metadata about clippy lints for the website.
+    ///
+    /// This lint will be used to report problems of syntax parsing. You should hopefully never
+    /// see this but never say never I guess ^^
+    ///
+    /// **Why is this bad?** This is not a bad thing but definitely a hacky way to do it. See
+    /// issue [#4310](https://github.com/rust-lang/rust-clippy/issues/4310) for a discussion
+    /// about the implementation.
+    ///
+    /// **Known problems:** Hopefully none. It would be pretty uncool to have a problem here :)
+    ///
+    /// **Example output:**
+    /// ```json,ignore
+    /// {
+    ///     "id": "internal_metadata_collector",
+    ///     "id_span": {
+    ///         "path": "clippy_lints/src/utils/internal_lints/metadata_collector.rs",
+    ///         "line": 1
+    ///     },
+    ///     "group": "clippy::internal",
+    ///     "docs": " **What it does:** Collects metadata about clippy lints for the website. [...] "
+    /// }
+    /// ```
+    pub INTERNAL_METADATA_COLLECTOR,
+    internal,
+    "A busy bee collection metadata about lints"
+}
+
+impl_lint_pass!(MetadataCollector => [INTERNAL_METADATA_COLLECTOR]);
+
+#[allow(clippy::module_name_repetitions)]
+#[derive(Debug, Clone, Default)]
+pub struct MetadataCollector {
+    lints: Vec<LintMetadata>,
+}
+
+impl Drop for MetadataCollector {
+    fn drop(&mut self) {
+        // You might ask: How hacky is this?
+        // My answer:     YES
+        let mut file = OpenOptions::new().write(true).create(true).open(OUTPUT_FILE).unwrap();
+        writeln!(file, "{}", serde_json::to_string_pretty(&self.lints).unwrap()).unwrap();
+    }
+}
+
+#[derive(Debug, Clone, Serialize)]
+struct LintMetadata {
+    id: String,
+    id_span: SerializableSpan,
+    group: String,
+    docs: String,
+}
+
+#[derive(Debug, Clone, Serialize)]
+struct SerializableSpan {
+    path: String,
+    line: usize,
+}
+
+impl SerializableSpan {
+    fn from_item(cx: &LateContext<'_>, item: &Item<'_>) -> Self {
+        Self::from_span(cx, item.ident.span)
+    }
+
+    fn from_span(cx: &LateContext<'_>, span: Span) -> Self {
+        let loc: Loc = cx.sess().source_map().lookup_char_pos(span.lo());
+
+        Self {
+            path: format!("{}", loc.file.name),
+            line: 1,
+        }
+    }
+}
+
+impl<'tcx> LateLintPass<'tcx> for MetadataCollector {
+    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
+        if_chain! {
+            if let ItemKind::Static(ref ty, Mutability::Not, body_id) = item.kind;
+            if is_lint_ref_type(cx, ty);
+            let expr = &cx.tcx.hir().body(body_id).value;
+            if let ExprKind::AddrOf(_, _, ref inner_exp) = expr.kind;
+            if let ExprKind::Struct(_, _, _) = inner_exp.kind;
+            then {
+                let lint_name = item.ident.name.as_str().to_string().to_ascii_lowercase();
+                if BLACK_LISTED_LINTS.contains(&lint_name.as_str()) {
+                    return;
+                }
+
+                let group: String;
+                let result = cx.lint_store.check_lint_name(lint_name.as_str(), Some(sym::clippy));
+                if let CheckLintNameResult::Tool(Ok(lint_lst)) = result {
+                    if let Some(group_some) = get_lint_group(cx, lint_lst[0]) {
+                        group = group_some;
+                    } else {
+                        lint_collection_error(cx, item, "Unable to determine lint group");
+                        return;
+                    }
+                } else {
+                    lint_collection_error(cx, item, "Unable to find lint in lint_store");
+                    return;
+                }
+
+                let docs: String;
+                if let Some(docs_some) = extract_attr_docs(item) {
+                    docs = docs_some;
+                } else {
+                    lint_collection_error(cx, item, "could not collect the lint documentation");
+                    return;
+                };
+
+                self.lints.push(LintMetadata {
+                    id: lint_name,
+                    id_span: SerializableSpan::from_item(cx, item),
+                    group,
+                    docs,
+                });
+            }
+        }
+    }
+}
+
+/// This function collects all documentation that has been added to an item using
+/// `#[doc = r""]` attributes. Several attributes are aggravated using line breaks
+///
+/// ```ignore
+/// #[doc = r"Hello world!"]
+/// #[doc = r"=^.^="]
+/// struct SomeItem {}
+/// ```
+///
+/// Would result in `Hello world!\n=^.^=\n`
+fn extract_attr_docs(item: &Item<'_>) -> Option<String> {
+    item.attrs
+        .iter()
+        .filter_map(|ref x| x.doc_str())
+        .fold(None, |acc, sym| {
+            let mut doc_str = sym.as_str().to_string();
+            doc_str.push('\n');
+
+            #[allow(clippy::option_if_let_else)] // See clippy#6737
+            if let Some(mut x) = acc {
+                x.push_str(&doc_str);
+                Some(x)
+            } else {
+                Some(doc_str)
+            }
+
+            // acc.map_or(Some(doc_str), |mut x| {
+            //     x.push_str(&doc_str);
+            //     Some(x)
+            // })
+        })
+}
+
+fn get_lint_group(cx: &LateContext<'_>, lint_id: LintId) -> Option<String> {
+    for (group_name, lints, _) in &cx.lint_store.get_lint_groups() {
+        if lints.iter().any(|x| *x == lint_id) {
+            return Some((*group_name).to_string());
+        }
+    }
+
+    None
+}
+
+fn lint_collection_error(cx: &LateContext<'_>, item: &Item<'_>, message: &str) {
+    span_lint(
+        cx,
+        INTERNAL_METADATA_COLLECTOR,
+        item.ident.span,
+        &format!("Metadata collection error for `{}`: {}", item.ident.name, message),
+    );
+}
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index d8b31344e6d..b67448e3a57 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -1,5 +1,5 @@
 pub mod author;
 pub mod conf;
 pub mod inspector;
-#[cfg(feature = "internal-lints")]
+#[cfg(any(feature = "internal-lints", feature = "metadata-collector-lint"))]
 pub mod internal_lints;
diff --git a/tests/dogfood.rs b/tests/dogfood.rs
index d92530f073f..b0da0bfcc35 100644
--- a/tests/dogfood.rs
+++ b/tests/dogfood.rs
@@ -1,3 +1,8 @@
+//! This test is a part of quality control and makes clippy eat what it produces. Awesome lints and
+//! long error messages
+//!
+//! See [Eating your own dog food](https://en.wikipedia.org/wiki/Eating_your_own_dog_food) for context
+
 // Dogfood cannot run on Windows
 #![cfg(not(windows))]
 #![feature(once_cell)]
@@ -36,6 +41,10 @@ fn dogfood_clippy() {
         command.args(&["-D", "clippy::internal"]);
     }
 
+    if cfg!(feature = "metadata-collector-lint") {
+        command.args(&["-D", "clippy::internal"]);
+    }
+
     let output = command.output().unwrap();
 
     println!("status: {}", output.status);
-- 
cgit 1.4.1-3-g733a5


From 060e0e9f9382cb7975165cede8d04b7bbe26bcb2 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Sun, 14 Feb 2021 16:17:07 +0100
Subject: Metadata collection lint: Basic applicability collection

---
 .../src/utils/internal_lints/metadata_collector.rs | 178 +++++++++++++++++----
 clippy_utils/src/paths.rs                          |   2 +
 2 files changed, 147 insertions(+), 33 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index dc4267697cb..677f9fcc83f 100644
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -2,10 +2,14 @@
 //! file and then used to generate the [clippy lint list](https://rust-lang.github.io/rust-clippy/master/index.html)
 //!
 //! This module and therefor the entire lint is guarded by a feature flag called
-//! `internal_metadata_lint`
+//! `metadata-collector-lint`
+//!
+//! The module transforms all lint names to ascii lowercase to ensure that we don't have mismatches
+//! during any comparison or mapping. (Please take care of this, it's not fun to spend time on such
+//! a simple mistake)
 //!
 //! The metadata currently contains:
-//! - [ ] TODO The lint declaration line for [#1303](https://github.com/rust-lang/rust-clippy/issues/1303)
+//! - [x] TODO The lint declaration line for [#1303](https://github.com/rust-lang/rust-clippy/issues/1303)
 //!   and [#6492](https://github.com/rust-lang/rust-clippy/issues/6492)
 //! - [ ] TODO The Applicability for each lint for [#4310](https://github.com/rust-lang/rust-clippy/issues/4310)
 
@@ -17,20 +21,34 @@
 // - TODO xFrednet 2021-02-13: Collect depreciations and maybe renames
 
 use if_chain::if_chain;
-use rustc_hir::{ExprKind, Item, ItemKind, Mutability};
+use rustc_data_structures::fx::{FxHashMap, FxHashSet};
+use rustc_hir::{self as hir, ExprKind, Item, ItemKind, Mutability};
 use rustc_lint::{CheckLintNameResult, LateContext, LateLintPass, LintContext, LintId};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::{sym, Loc, Span};
+use rustc_span::{sym, Loc, Span, Symbol};
 use serde::Serialize;
 use std::fs::OpenOptions;
 use std::io::prelude::*;
 
 use crate::utils::internal_lints::is_lint_ref_type;
-use crate::utils::span_lint;
+use crate::utils::{last_path_segment, match_function_call, match_type, paths, span_lint, walk_ptrs_ty_depth};
 
+/// This is the output file of the lint collector.
 const OUTPUT_FILE: &str = "metadata_collection.json";
+/// These lints are excluded from the export.
 const BLACK_LISTED_LINTS: [&str; 2] = ["lint_author", "deep_code_inspection"];
 
+// TODO xFrednet 2021-02-15: `span_lint_and_then` & `span_lint_hir_and_then` requires special
+// handling
+#[rustfmt::skip]
+const LINT_EMISSION_FUNCTIONS: [&[&str]; 5] = [
+    &["clippy_lints", "utils", "diagnostics", "span_lint"],
+    &["clippy_lints", "utils", "diagnostics", "span_lint_and_help"],
+    &["clippy_lints", "utils", "diagnostics", "span_lint_and_note"],
+    &["clippy_lints", "utils", "diagnostics", "span_lint_hir"],
+    &["clippy_lints", "utils", "diagnostics", "span_lint_and_sugg"],
+];
+
 declare_clippy_lint! {
     /// **What it does:** Collects metadata about clippy lints for the website.
     ///
@@ -66,12 +84,21 @@ impl_lint_pass!(MetadataCollector => [INTERNAL_METADATA_COLLECTOR]);
 #[derive(Debug, Clone, Default)]
 pub struct MetadataCollector {
     lints: Vec<LintMetadata>,
+    applicability_into: FxHashMap<String, ApplicabilityInfo>,
 }
 
 impl Drop for MetadataCollector {
+    /// You might ask: How hacky is this?
+    /// My answer:     YES
     fn drop(&mut self) {
-        // You might ask: How hacky is this?
-        // My answer:     YES
+        let mut applicability_info = std::mem::take(&mut self.applicability_into);
+
+        // Mapping the final data
+        self.lints
+            .iter_mut()
+            .for_each(|x| x.applicability = applicability_info.remove(&x.id));
+
+        // Outputting
         let mut file = OpenOptions::new().write(true).create(true).open(OUTPUT_FILE).unwrap();
         writeln!(file, "{}", serde_json::to_string_pretty(&self.lints).unwrap()).unwrap();
     }
@@ -83,6 +110,21 @@ struct LintMetadata {
     id_span: SerializableSpan,
     group: String,
     docs: String,
+    /// This field is only used in the output and will only be
+    /// mapped shortly before the actual output.
+    applicability: Option<ApplicabilityInfo>,
+}
+
+impl LintMetadata {
+    fn new(id: String, id_span: SerializableSpan, group: String, docs: String) -> Self {
+        Self {
+            id,
+            id_span,
+            group,
+            docs,
+            applicability: None,
+        }
+    }
 }
 
 #[derive(Debug, Clone, Serialize)]
@@ -101,12 +143,31 @@ impl SerializableSpan {
 
         Self {
             path: format!("{}", loc.file.name),
-            line: 1,
+            line: loc.line,
         }
     }
 }
 
+#[derive(Debug, Clone, Default, Serialize)]
+struct ApplicabilityInfo {
+    /// Indicates if any of the lint emissions uses multiple spans. This is related to
+    /// [rustfix#141](https://github.com/rust-lang/rustfix/issues/141) as such suggestions can
+    /// currently not be applied automatically.
+    has_multi_suggestion: bool,
+    /// These are all the available applicability values for the lint suggestions
+    applicabilities: FxHashSet<String>,
+}
+
 impl<'tcx> LateLintPass<'tcx> for MetadataCollector {
+    /// Collecting lint declarations like:
+    /// ```rust, ignore
+    /// declare_clippy_lint! {
+    ///     /// **What it does:** Something IDK.
+    ///     pub SOME_LINT,
+    ///     internal,
+    ///     "Who am I?"
+    /// }
+    /// ```
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
         if_chain! {
             if let ItemKind::Static(ref ty, Mutability::Not, body_id) = item.kind;
@@ -115,7 +176,7 @@ impl<'tcx> LateLintPass<'tcx> for MetadataCollector {
             if let ExprKind::AddrOf(_, _, ref inner_exp) = expr.kind;
             if let ExprKind::Struct(_, _, _) = inner_exp.kind;
             then {
-                let lint_name = item.ident.name.as_str().to_string().to_ascii_lowercase();
+                let lint_name = sym_to_string(item.ident.name).to_ascii_lowercase();
                 if BLACK_LISTED_LINTS.contains(&lint_name.as_str()) {
                     return;
                 }
@@ -126,11 +187,11 @@ impl<'tcx> LateLintPass<'tcx> for MetadataCollector {
                     if let Some(group_some) = get_lint_group(cx, lint_lst[0]) {
                         group = group_some;
                     } else {
-                        lint_collection_error(cx, item, "Unable to determine lint group");
+                        lint_collection_error_item(cx, item, "Unable to determine lint group");
                         return;
                     }
                 } else {
-                    lint_collection_error(cx, item, "Unable to find lint in lint_store");
+                    lint_collection_error_item(cx, item, "Unable to find lint in lint_store");
                     return;
                 }
 
@@ -138,21 +199,38 @@ impl<'tcx> LateLintPass<'tcx> for MetadataCollector {
                 if let Some(docs_some) = extract_attr_docs(item) {
                     docs = docs_some;
                 } else {
-                    lint_collection_error(cx, item, "could not collect the lint documentation");
+                    lint_collection_error_item(cx, item, "could not collect the lint documentation");
                     return;
                 };
 
-                self.lints.push(LintMetadata {
-                    id: lint_name,
-                    id_span: SerializableSpan::from_item(cx, item),
+                self.lints.push(LintMetadata::new(
+                    lint_name,
+                    SerializableSpan::from_item(cx, item),
                     group,
                     docs,
+                ));
+            }
+        }
+    }
+
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
+        if let Some(args) = match_simple_lint_emission(cx, expr) {
+            if let Some((lint_name, mut applicability)) = extract_emission_info(cx, args) {
+                let app_info = self.applicability_into.entry(lint_name).or_default();
+                applicability.drain(..).for_each(|x| {
+                    app_info.applicabilities.insert(x);
                 });
+            } else {
+                lint_collection_error_span(cx, expr.span, "I found this but I can't get the lint or applicability");
             }
         }
     }
 }
 
+fn sym_to_string(sym: Symbol) -> String {
+    sym.as_str().to_string()
+}
+
 /// This function collects all documentation that has been added to an item using
 /// `#[doc = r""]` attributes. Several attributes are aggravated using line breaks
 ///
@@ -166,23 +244,11 @@ impl<'tcx> LateLintPass<'tcx> for MetadataCollector {
 fn extract_attr_docs(item: &Item<'_>) -> Option<String> {
     item.attrs
         .iter()
-        .filter_map(|ref x| x.doc_str())
-        .fold(None, |acc, sym| {
-            let mut doc_str = sym.as_str().to_string();
-            doc_str.push('\n');
-
-            #[allow(clippy::option_if_let_else)] // See clippy#6737
-            if let Some(mut x) = acc {
-                x.push_str(&doc_str);
-                Some(x)
-            } else {
-                Some(doc_str)
-            }
-
-            // acc.map_or(Some(doc_str), |mut x| {
-            //     x.push_str(&doc_str);
-            //     Some(x)
-            // })
+        .filter_map(|ref x| x.doc_str().map(|sym| sym.as_str().to_string()))
+        .reduce(|mut acc, sym| {
+            acc.push_str(&sym);
+            acc.push('\n');
+            acc
         })
 }
 
@@ -196,7 +262,7 @@ fn get_lint_group(cx: &LateContext<'_>, lint_id: LintId) -> Option<String> {
     None
 }
 
-fn lint_collection_error(cx: &LateContext<'_>, item: &Item<'_>, message: &str) {
+fn lint_collection_error_item(cx: &LateContext<'_>, item: &Item<'_>, message: &str) {
     span_lint(
         cx,
         INTERNAL_METADATA_COLLECTOR,
@@ -204,3 +270,49 @@ fn lint_collection_error(cx: &LateContext<'_>, item: &Item<'_>, message: &str) {
         &format!("Metadata collection error for `{}`: {}", item.ident.name, message),
     );
 }
+
+fn lint_collection_error_span(cx: &LateContext<'_>, span: Span, message: &str) {
+    span_lint(
+        cx,
+        INTERNAL_METADATA_COLLECTOR,
+        span,
+        &format!("Metadata collection error: {}", message),
+    );
+}
+
+fn match_simple_lint_emission<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx hir::Expr<'_>,
+) -> Option<&'tcx [hir::Expr<'tcx>]> {
+    LINT_EMISSION_FUNCTIONS
+        .iter()
+        .find_map(|emission_fn| match_function_call(cx, expr, emission_fn).map(|args| args))
+}
+
+/// This returns the lint name and the possible applicability of this emission
+fn extract_emission_info<'tcx>(cx: &LateContext<'tcx>, args: &[hir::Expr<'_>]) -> Option<(String, Vec<String>)> {
+    let mut lint_name = None;
+    let mut applicability = None;
+
+    for arg in args {
+        let (arg_ty, _) = walk_ptrs_ty_depth(cx.typeck_results().expr_ty(&arg));
+
+        if match_type(cx, arg_ty, &paths::LINT) {
+            // If we found the lint arg, extract the lint name
+            if let ExprKind::Path(ref lint_path) = arg.kind {
+                lint_name = Some(last_path_segment(lint_path).ident.name)
+            }
+        } else if match_type(cx, arg_ty, &paths::APPLICABILITY) {
+            if let ExprKind::Path(ref path) = arg.kind {
+                applicability = Some(last_path_segment(path).ident.name)
+            }
+        }
+    }
+
+    lint_name.map(|lint_name| {
+        (
+            sym_to_string(lint_name).to_ascii_lowercase(),
+            applicability.map(sym_to_string).map_or_else(Vec::new, |x| vec![x]),
+        )
+    })
+}
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index 5e6733a300f..91e5cd6c046 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -5,6 +5,8 @@
 //! See <https://github.com/rust-lang/rust-clippy/issues/5393> for more information.
 
 pub const ANY_TRAIT: [&str; 3] = ["core", "any", "Any"];
+#[cfg(feature = "metadata-collector-lint")]
+pub const APPLICABILITY: [&str; 2] = ["rustc_lint_defs", "Applicability"];
 pub const ARC_PTR_EQ: [&str; 4] = ["alloc", "sync", "Arc", "ptr_eq"];
 pub const ASMUT_TRAIT: [&str; 3] = ["core", "convert", "AsMut"];
 pub const ASREF_TRAIT: [&str; 3] = ["core", "convert", "AsRef"];
-- 
cgit 1.4.1-3-g733a5


From 68d702f88ded863b9cde999f1850b32c6531fe11 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Thu, 18 Feb 2021 00:20:19 +0100
Subject: Metadata collection lint: Start Applicability value tracking

---
 .../src/utils/internal_lints/metadata_collector.rs | 158 ++++++++++++++++++++-
 1 file changed, 155 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index 677f9fcc83f..2bdb92376ca 100644
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -24,14 +24,21 @@ use if_chain::if_chain;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_hir::{self as hir, ExprKind, Item, ItemKind, Mutability};
 use rustc_lint::{CheckLintNameResult, LateContext, LateLintPass, LintContext, LintId};
+use rustc_middle::ty::BorrowKind;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::{sym, Loc, Span, Symbol};
+use rustc_trait_selection::infer::TyCtxtInferExt;
+use rustc_typeck::expr_use_visitor::{ConsumeMode, Delegate, ExprUseVisitor, PlaceWithHirId};
+use rustc_typeck::hir_ty_to_ty;
 use serde::Serialize;
-use std::fs::OpenOptions;
+use std::fs::{self, OpenOptions};
 use std::io::prelude::*;
+use std::path::Path;
 
 use crate::utils::internal_lints::is_lint_ref_type;
-use crate::utils::{last_path_segment, match_function_call, match_type, paths, span_lint, walk_ptrs_ty_depth};
+use crate::utils::{
+    last_path_segment, match_function_call, match_type, path_to_local_id, paths, span_lint, walk_ptrs_ty_depth,
+};
 
 /// This is the output file of the lint collector.
 const OUTPUT_FILE: &str = "metadata_collection.json";
@@ -91,6 +98,10 @@ impl Drop for MetadataCollector {
     /// You might ask: How hacky is this?
     /// My answer:     YES
     fn drop(&mut self) {
+        if self.lints.is_empty() {
+            return;
+        }
+
         let mut applicability_info = std::mem::take(&mut self.applicability_into);
 
         // Mapping the final data
@@ -99,6 +110,9 @@ impl Drop for MetadataCollector {
             .for_each(|x| x.applicability = applicability_info.remove(&x.id));
 
         // Outputting
+        if Path::new(OUTPUT_FILE).exists() {
+            fs::remove_file(OUTPUT_FILE).unwrap();
+        }
         let mut file = OpenOptions::new().write(true).create(true).open(OUTPUT_FILE).unwrap();
         writeln!(file, "{}", serde_json::to_string_pretty(&self.lints).unwrap()).unwrap();
     }
@@ -158,6 +172,17 @@ struct ApplicabilityInfo {
     applicabilities: FxHashSet<String>,
 }
 
+fn log_to_file(msg: &str) {
+    let mut file = OpenOptions::new()
+        .write(true)
+        .append(true)
+        .create(true)
+        .open("metadata-lint.log")
+        .unwrap();
+
+    write!(file, "{}", msg).unwrap();
+}
+
 impl<'tcx> LateLintPass<'tcx> for MetadataCollector {
     /// Collecting lint declarations like:
     /// ```rust, ignore
@@ -213,6 +238,20 @@ impl<'tcx> LateLintPass<'tcx> for MetadataCollector {
         }
     }
 
+    /// Collecting constant applicability from the actual lint emissions
+    ///
+    /// Example:
+    /// ```rust, ignore
+    /// span_lint_and_sugg(
+    ///     cx,
+    ///     SOME_LINT,
+    ///     item.span,
+    ///     "Le lint message",
+    ///     "Here comes help:",
+    ///     "#![allow(clippy::all)]",
+    ///     Applicability::MachineApplicable, // <-- Extracts this constant value
+    /// );
+    /// ```
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
         if let Some(args) = match_simple_lint_emission(cx, expr) {
             if let Some((lint_name, mut applicability)) = extract_emission_info(cx, args) {
@@ -225,6 +264,73 @@ impl<'tcx> LateLintPass<'tcx> for MetadataCollector {
             }
         }
     }
+
+    /// Tracking and hopefully collecting dynamic applicability values
+    ///
+    /// Example:
+    /// ```rust, ignore
+    /// // vvv Applicability value to track
+    /// let mut applicability = Applicability::MachineApplicable;
+    /// // vvv Value Mutation
+    /// let suggestion = snippet_with_applicability(cx, expr.span, "_", &mut applicability);
+    /// // vvv Emission to link the value to the lint
+    /// span_lint_and_sugg(
+    ///     cx,
+    ///     SOME_LINT,
+    ///     expr.span,
+    ///     "This can be improved",
+    ///     "try",
+    ///     suggestion,
+    ///     applicability,
+    /// );
+    /// ```
+    fn check_local(&mut self, cx: &LateContext<'tcx>, local: &'tcx hir::Local<'tcx>) {
+        if let Some(tc) = cx.maybe_typeck_results() {
+            // TODO xFrednet 2021-02-14: support nested applicability (only in tuples)
+            let local_ty = if let Some(ty) = local.ty {
+                hir_ty_to_ty(cx.tcx, ty)
+            } else if let Some(init) = local.init {
+                tc.expr_ty(init)
+            } else {
+                return;
+            };
+
+            if_chain! {
+                if match_type(cx, local_ty, &paths::APPLICABILITY);
+                if let Some(body) = get_parent_body(cx, local.hir_id);
+                then {
+                    let span = SerializableSpan::from_span(cx, local.span);
+                    let local_str = crate::utils::snippet(cx, local.span, "_");
+                    let value_life = format!("{} -- {}:{}\n", local_str, span.path.rsplit('/').next().unwrap_or_default(), span.line);
+                    let value_hir_id = local.pat.hir_id;
+                    let mut tracker = ValueTracker {cx, value_hir_id, value_life};
+
+                    cx.tcx.infer_ctxt().enter(|infcx| {
+                        let body_owner_id = cx.tcx.hir().body_owner_def_id(body.id());
+                        ExprUseVisitor::new(
+                            &mut tracker,
+                            &infcx,
+                            body_owner_id,
+                            cx.param_env,
+                            cx.typeck_results()
+                        )
+                        .consume_body(body);
+                    });
+
+                    log_to_file(&tracker.value_life);
+                    lint_collection_error_span(cx, local.span, "Applicability value found");
+                }
+            }
+        }
+    }
+}
+
+fn get_parent_body<'a, 'tcx>(cx: &'a LateContext<'tcx>, id: hir::HirId) -> Option<&'tcx hir::Body<'tcx>> {
+    let map = cx.tcx.hir();
+
+    map.parent_iter(id)
+        .find_map(|(parent, _)| map.maybe_body_owned_by(parent))
+        .map(|body| map.body(body))
 }
 
 fn sym_to_string(sym: Symbol) -> String {
@@ -262,6 +368,9 @@ fn get_lint_group(cx: &LateContext<'_>, lint_id: LintId) -> Option<String> {
     None
 }
 
+// ==================================================================
+// Lint emission
+// ==================================================================
 fn lint_collection_error_item(cx: &LateContext<'_>, item: &Item<'_>, message: &str) {
     span_lint(
         cx,
@@ -280,13 +389,16 @@ fn lint_collection_error_span(cx: &LateContext<'_>, span: Span, message: &str) {
     );
 }
 
+// ==================================================================
+// Applicability
+// ==================================================================
 fn match_simple_lint_emission<'tcx>(
     cx: &LateContext<'tcx>,
     expr: &'tcx hir::Expr<'_>,
 ) -> Option<&'tcx [hir::Expr<'tcx>]> {
     LINT_EMISSION_FUNCTIONS
         .iter()
-        .find_map(|emission_fn| match_function_call(cx, expr, emission_fn).map(|args| args))
+        .find_map(|emission_fn| match_function_call(cx, expr, emission_fn))
 }
 
 /// This returns the lint name and the possible applicability of this emission
@@ -316,3 +428,43 @@ fn extract_emission_info<'tcx>(cx: &LateContext<'tcx>, args: &[hir::Expr<'_>]) -
         )
     })
 }
+
+struct ValueTracker<'a, 'tcx> {
+    cx: &'a LateContext<'tcx>,
+    value_hir_id: hir::HirId,
+    value_life: String,
+}
+
+impl<'a, 'tcx> ValueTracker<'a, 'tcx> {
+    fn is_value_expr(&self, expr_id: hir::HirId) -> bool {
+        match self.cx.tcx.hir().find(expr_id) {
+            Some(hir::Node::Expr(expr)) => path_to_local_id(expr, self.value_hir_id),
+            _ => false,
+        }
+    }
+}
+
+impl<'a, 'tcx> Delegate<'tcx> for ValueTracker<'a, 'tcx> {
+    fn consume(&mut self, _place_with_id: &PlaceWithHirId<'tcx>, expr_id: hir::HirId, _: ConsumeMode) {
+        if self.is_value_expr(expr_id) {
+            // TODO xFrednet 2021-02-17: Check if lint emission and extract lint ID
+            todo!();
+        }
+    }
+
+    fn borrow(&mut self, _place_with_id: &PlaceWithHirId<'tcx>, expr_id: hir::HirId, bk: BorrowKind) {
+        if self.is_value_expr(expr_id) {
+            if let BorrowKind::MutBorrow = bk {
+                // TODO xFrednet 2021-02-17: Save the function
+                todo!();
+            }
+        }
+    }
+
+    fn mutate(&mut self, _assignee_place: &PlaceWithHirId<'tcx>, expr_id: hir::HirId) {
+        if self.is_value_expr(expr_id) {
+            // TODO xFrednet 2021-02-17: Save the new value as a mutation
+            todo!();
+        }
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 8dca1b8f618fdec3f1b354d9bafa01b32ecc8ab6 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Thu, 18 Feb 2021 23:40:33 +0100
Subject: Metadata collection: Collecting Applicability assign values

---
 .../src/utils/internal_lints/metadata_collector.rs | 249 ++++++++++++++++-----
 clippy_utils/src/paths.rs                          |   7 +
 .../track_applicability_value.rs                   |  46 ++++
 3 files changed, 248 insertions(+), 54 deletions(-)
 create mode 100644 tests/ui-internal/metadata-collector/track_applicability_value.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index 2bdb92376ca..e22aa285f17 100644
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -24,7 +24,7 @@ use if_chain::if_chain;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_hir::{self as hir, ExprKind, Item, ItemKind, Mutability};
 use rustc_lint::{CheckLintNameResult, LateContext, LateLintPass, LintContext, LintId};
-use rustc_middle::ty::BorrowKind;
+use rustc_middle::ty::{BorrowKind, Ty};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::{sym, Loc, Span, Symbol};
 use rustc_trait_selection::infer::TyCtxtInferExt;
@@ -37,7 +37,8 @@ use std::path::Path;
 
 use crate::utils::internal_lints::is_lint_ref_type;
 use crate::utils::{
-    last_path_segment, match_function_call, match_type, path_to_local_id, paths, span_lint, walk_ptrs_ty_depth,
+    get_enclosing_body, get_parent_expr_for_hir, last_path_segment, match_function_call, match_qpath, match_type,
+    path_to_local_id, paths, span_lint, walk_ptrs_ty_depth,
 };
 
 /// This is the output file of the lint collector.
@@ -147,6 +148,12 @@ struct SerializableSpan {
     line: usize,
 }
 
+impl std::fmt::Display for SerializableSpan {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}:{}", self.path.rsplit('/').next().unwrap_or_default(), self.line)
+    }
+}
+
 impl SerializableSpan {
     fn from_item(cx: &LateContext<'_>, item: &Item<'_>) -> Self {
         Self::from_span(cx, item.ident.span)
@@ -285,52 +292,54 @@ impl<'tcx> LateLintPass<'tcx> for MetadataCollector {
     /// );
     /// ```
     fn check_local(&mut self, cx: &LateContext<'tcx>, local: &'tcx hir::Local<'tcx>) {
-        if let Some(tc) = cx.maybe_typeck_results() {
-            // TODO xFrednet 2021-02-14: support nested applicability (only in tuples)
-            let local_ty = if let Some(ty) = local.ty {
-                hir_ty_to_ty(cx.tcx, ty)
-            } else if let Some(init) = local.init {
-                tc.expr_ty(init)
-            } else {
-                return;
-            };
-
-            if_chain! {
-                if match_type(cx, local_ty, &paths::APPLICABILITY);
-                if let Some(body) = get_parent_body(cx, local.hir_id);
-                then {
-                    let span = SerializableSpan::from_span(cx, local.span);
-                    let local_str = crate::utils::snippet(cx, local.span, "_");
-                    let value_life = format!("{} -- {}:{}\n", local_str, span.path.rsplit('/').next().unwrap_or_default(), span.line);
-                    let value_hir_id = local.pat.hir_id;
-                    let mut tracker = ValueTracker {cx, value_hir_id, value_life};
-
-                    cx.tcx.infer_ctxt().enter(|infcx| {
-                        let body_owner_id = cx.tcx.hir().body_owner_def_id(body.id());
-                        ExprUseVisitor::new(
-                            &mut tracker,
-                            &infcx,
-                            body_owner_id,
-                            cx.param_env,
-                            cx.typeck_results()
-                        )
-                        .consume_body(body);
-                    });
-
-                    log_to_file(&tracker.value_life);
-                    lint_collection_error_span(cx, local.span, "Applicability value found");
+        if_chain! {
+            if let Some(local_ty) = get_local_type(cx, local);
+            if match_type(cx, local_ty, &paths::APPLICABILITY);
+            if let Some(body) = get_enclosing_body(cx, local.hir_id);
+            then {
+                // TODO xFrednet: 2021-02-19: Remove debug code
+                let span = SerializableSpan::from_span(cx, local.span);
+                let local_str = crate::utils::snippet(cx, local.span, "_");
+                log_to_file(&format!("{} -- {}\n", local_str, span));
+                
+                let value_hir_id = local.pat.hir_id;
+                let mut tracker = ValueTracker::new(cx, value_hir_id);
+                if let Some(init_expr) = local.init {
+                    tracker.process_assign_expr(init_expr)
                 }
+
+                // TODO xFrednet 2021-02-18: Support nested bodies
+                // Note: The `ExprUseVisitor` only searches though one body, this means that values
+                // references in nested bodies like closures are not found by this simple visitor.
+                cx.tcx.infer_ctxt().enter(|infcx| {
+                    let body_owner_id = cx.tcx.hir().body_owner_def_id(body.id());
+                    ExprUseVisitor::new(
+                        &mut tracker,
+                        &infcx,
+                        body_owner_id,
+                        cx.param_env,
+                        cx.typeck_results()
+                    )
+                    .consume_body(body);
+                });
+
+                log_to_file(&format!("{:?}\n", tracker.value_mutations));
             }
         }
     }
 }
 
-fn get_parent_body<'a, 'tcx>(cx: &'a LateContext<'tcx>, id: hir::HirId) -> Option<&'tcx hir::Body<'tcx>> {
-    let map = cx.tcx.hir();
+fn get_local_type<'a>(cx: &'a LateContext<'_>, local: &'a hir::Local<'_>) -> Option<Ty<'a>> {
+    // TODO xFrednet 2021-02-14: support nested applicability (only in tuples)
+    if let Some(tc) = cx.maybe_typeck_results() {
+        if let Some(ty) = local.ty {
+            return Some(hir_ty_to_ty(cx.tcx, ty));
+        } else if let Some(init) = local.init {
+            return Some(tc.expr_ty(init));
+        }
+    }
 
-    map.parent_iter(id)
-        .find_map(|(parent, _)| map.maybe_body_owned_by(parent))
-        .map(|body| map.body(body))
+    None
 }
 
 fn sym_to_string(sym: Symbol) -> String {
@@ -429,42 +438,174 @@ fn extract_emission_info<'tcx>(cx: &LateContext<'tcx>, args: &[hir::Expr<'_>]) -
     })
 }
 
-struct ValueTracker<'a, 'tcx> {
-    cx: &'a LateContext<'tcx>,
+#[allow(dead_code)]
+struct ValueTracker<'a, 'hir> {
+    cx: &'a LateContext<'hir>,
     value_hir_id: hir::HirId,
-    value_life: String,
+    value_mutations: Vec<ApplicabilityModifier<'hir>>,
 }
 
-impl<'a, 'tcx> ValueTracker<'a, 'tcx> {
+impl<'a, 'hir> ValueTracker<'a, 'hir> {
+    fn new(cx: &'a LateContext<'hir>, value_hir_id: hir::HirId) -> Self {
+        Self {
+            cx,
+            value_hir_id,
+            value_mutations: Vec::new(),
+        }
+    }
+
     fn is_value_expr(&self, expr_id: hir::HirId) -> bool {
         match self.cx.tcx.hir().find(expr_id) {
             Some(hir::Node::Expr(expr)) => path_to_local_id(expr, self.value_hir_id),
             _ => false,
         }
     }
+
+    /// This function extracts possible `ApplicabilityModifier` from an assign statement like this:
+    ///
+    /// ```rust, ignore
+    /// //          vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv The expression to process
+    /// let value = Applicability::MachineApplicable;
+    /// ```
+    fn process_assign_expr(&mut self, expr: &'hir hir::Expr<'hir>) {
+        // This is a bit more complicated. I'll therefor settle on the simple solution of
+        // simplifying the cases we support.
+        match &expr.kind {
+            hir::ExprKind::Call(func_expr, ..) => {
+                // We only deal with resolved paths as this is the usual case. Other expression kinds like closures
+                // etc. are hard to track but might be a worthy improvement in the future
+                if let hir::ExprKind::Path(hir::QPath::Resolved(_, path)) = func_expr.kind {
+                    self.value_mutations.push(ApplicabilityModifier::Producer(path));
+                } else {
+                    let msg = format!(
+                        "Unsupported Call expression at: {}",
+                        SerializableSpan::from_span(self.cx, func_expr.span)
+                    );
+                    self.value_mutations.push(ApplicabilityModifier::Unknown(msg));
+                }
+            },
+            hir::ExprKind::MethodCall(..) => {
+                let msg = format!(
+                    "Unsupported MethodCall expression at: {}",
+                    SerializableSpan::from_span(self.cx, expr.span)
+                );
+                self.value_mutations.push(ApplicabilityModifier::Unknown(msg));
+            },
+            // We can ignore ifs without an else block because those can't be used as an assignment
+            hir::ExprKind::If(_con, if_block, Some(else_block)) => {
+                self.process_assign_expr(if_block);
+                self.process_assign_expr(else_block);
+            },
+            hir::ExprKind::Match(_expr, arms, _) => {
+                for arm in *arms {
+                    self.process_assign_expr(arm.body);
+                }
+            },
+            hir::ExprKind::Loop(block, ..) | hir::ExprKind::Block(block, ..) => {
+                if let Some(block_expr) = block.expr {
+                    self.process_assign_expr(block_expr);
+                }
+            },
+            hir::ExprKind::Path(path) => {
+                for enum_value in &paths::APPLICABILITY_VALUES {
+                    if match_qpath(path, enum_value) {
+                        self.value_mutations
+                            .push(ApplicabilityModifier::ConstValue(enum_value[2].to_string()));
+                    }
+                }
+            },
+            // hir::ExprKind::Field(expr, ident) => not supported
+            // hir::ExprKind::Index(expr, expr) => not supported
+            _ => {
+                let msg = format!(
+                    "Unexpected expression at: {}",
+                    SerializableSpan::from_span(self.cx, expr.span)
+                );
+                self.value_mutations.push(ApplicabilityModifier::Unknown(msg));
+            },
+        }
+    }
 }
 
-impl<'a, 'tcx> Delegate<'tcx> for ValueTracker<'a, 'tcx> {
-    fn consume(&mut self, _place_with_id: &PlaceWithHirId<'tcx>, expr_id: hir::HirId, _: ConsumeMode) {
+impl<'a, 'hir> Delegate<'hir> for ValueTracker<'a, 'hir> {
+    fn consume(&mut self, _place_with_id: &PlaceWithHirId<'hir>, expr_id: hir::HirId, _: ConsumeMode) {
         if self.is_value_expr(expr_id) {
             // TODO xFrednet 2021-02-17: Check if lint emission and extract lint ID
-            todo!();
+            if let Some(hir::Node::Expr(expr)) = self.cx.tcx.hir().find(expr_id) {
+                let span = SerializableSpan::from_span(self.cx, expr.span);
+                log_to_file(&format!("- consume {}\n", span));
+            }
         }
     }
 
-    fn borrow(&mut self, _place_with_id: &PlaceWithHirId<'tcx>, expr_id: hir::HirId, bk: BorrowKind) {
+    fn borrow(&mut self, _place_with_id: &PlaceWithHirId<'hir>, expr_id: hir::HirId, bk: BorrowKind) {
         if self.is_value_expr(expr_id) {
             if let BorrowKind::MutBorrow = bk {
                 // TODO xFrednet 2021-02-17: Save the function
-                todo!();
+                if let Some(hir::Node::Expr(expr)) = self.cx.tcx.hir().find(expr_id) {
+                    let span = SerializableSpan::from_span(self.cx, expr.span);
+                    log_to_file(&format!("- &mut     {}\n", span));
+                }
             }
         }
     }
 
-    fn mutate(&mut self, _assignee_place: &PlaceWithHirId<'tcx>, expr_id: hir::HirId) {
-        if self.is_value_expr(expr_id) {
-            // TODO xFrednet 2021-02-17: Save the new value as a mutation
-            todo!();
+    fn mutate(&mut self, _assignee_place: &PlaceWithHirId<'hir>, expr_id: hir::HirId) {
+        if_chain! {
+            if self.is_value_expr(expr_id);
+            if let Some(expr) = get_parent_expr_for_hir(self.cx, expr_id);
+            if let hir::ExprKind::Assign(_value_expr, assign_expr, ..) = expr.kind;
+            then {
+                self.process_assign_expr(assign_expr);
+            }
         }
     }
 }
+
+/// The life of a value in Rust is a true adventure. These are the corner stones of such a
+/// fairy tale. Let me introduce you to the possible stepping stones a value might have in
+/// in our crazy word:
+#[derive(Debug)]
+#[allow(dead_code)]
+enum ApplicabilityModifier<'hir> {
+    Unknown(String),
+    /// A simple constant value.
+    ///
+    /// This is the actual character of a value. It's baseline. This only defines where the value
+    /// started. As in real life it can still change and fully decide who it wants to be.
+    ConstValue(String),
+    /// A producer is a function that returns an applicability value.
+    ///
+    /// This is the heritage of this value. This value comes from a long family tree and is not
+    /// just a black piece of paper. The evaluation of this stepping stone needs additional
+    /// context. We therefore only add a reference. This reference will later be used to ask
+    /// the librarian about the possible initial character that this value might have.
+    Producer(&'hir hir::Path<'hir>),
+    /// A modifier that takes the given applicability and might modify it
+    ///
+    /// What would an RPG be without it's NPCs. The special thing about modifiers is that they can
+    /// be actively interested in the story of the value and might make decisions based on the
+    /// character of this hero. This means that a modifier doesn't just force its way into the life
+    /// of our hero but it actually asks him how he's been. The possible modification is a result
+    /// of the situation.
+    ///
+    /// Take this part of our heroes life very seriously!
+    Modifier(&'hir hir::Path<'hir>),
+    /// The actual emission of a lint
+    ///
+    /// All good things must come to an end. Even the life of your awesome applicability hero. He
+    /// was the bravest soul that has ever wondered this earth. Songs will be written about his
+    /// heroic deeds. Castles will be named after him and the world how we know it will never be
+    /// the same!
+    ///
+    /// Is this a happy ending? Did he archive what he wanted in his life? Yes, YES, he has lived a
+    /// life and he will continue to live in all the lint suggestions that can be applied or just
+    /// displayed by Clippy. He might be no more, but his legacy will serve generations to come.
+    LintEmit(LintEmission),
+}
+
+#[derive(Debug)]
+struct LintEmission {
+    lint: String,
+    is_multi_line_sugg: bool,
+}
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index 91e5cd6c046..46f58b788e6 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -7,6 +7,13 @@
 pub const ANY_TRAIT: [&str; 3] = ["core", "any", "Any"];
 #[cfg(feature = "metadata-collector-lint")]
 pub const APPLICABILITY: [&str; 2] = ["rustc_lint_defs", "Applicability"];
+#[cfg(feature = "metadata-collector-lint")]
+pub const APPLICABILITY_VALUES: [[&str; 3]; 4] = [
+    ["rustc_lint_defs", "Applicability", "MachineApplicable"],
+    ["rustc_lint_defs", "Applicability", "MaybeIncorrect"],
+    ["rustc_lint_defs", "Applicability", "HasPlaceholders"],
+    ["rustc_lint_defs", "Applicability", "Unspecified"],
+];
 pub const ARC_PTR_EQ: [&str; 4] = ["alloc", "sync", "Arc", "ptr_eq"];
 pub const ASMUT_TRAIT: [&str; 3] = ["core", "convert", "AsMut"];
 pub const ASREF_TRAIT: [&str; 3] = ["core", "convert", "AsRef"];
diff --git a/tests/ui-internal/metadata-collector/track_applicability_value.rs b/tests/ui-internal/metadata-collector/track_applicability_value.rs
new file mode 100644
index 00000000000..75fae623e61
--- /dev/null
+++ b/tests/ui-internal/metadata-collector/track_applicability_value.rs
@@ -0,0 +1,46 @@
+#![deny(clippy::internal)]
+#![feature(rustc_private)]
+
+extern crate rustc_ast;
+extern crate rustc_errors;
+extern crate rustc_lint;
+extern crate rustc_session;
+extern crate rustc_span;
+
+use rustc_ast::ast::Expr;
+use rustc_errors::{Applicability, DiagnosticBuilder};
+use rustc_lint::{EarlyContext, EarlyLintPass, Lint, LintContext};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::source_map::Span;
+
+fn producer_fn() -> Applicability {
+    Applicability::MachineApplicable
+}
+
+fn modifier_fn(applicability: &mut Applicability) {
+    if let Applicability::MaybeIncorrect = applicability {
+        *applicability = Applicability::HasPlaceholders;
+    }
+}
+
+struct Muh;
+
+impl Muh {
+    fn producer_method() -> Applicability {
+        Applicability::MachineApplicable
+    }
+}
+
+fn main() {
+    let mut applicability = producer_fn();
+    applicability = Applicability::MachineApplicable;
+    applicability = Muh::producer_method();
+
+    applicability = if true {
+        Applicability::HasPlaceholders
+    } else {
+        Applicability::MaybeIncorrect
+    };
+
+    modifier_fn(&mut applicability);
+}
-- 
cgit 1.4.1-3-g733a5


From ee130d066d362118cd0bf756de42ee08a2bfc301 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Sat, 20 Feb 2021 00:35:28 +0100
Subject: Metadata collection: Tracking Applicability mut borrows

---
 .../src/utils/internal_lints/metadata_collector.rs | 57 ++++++++++++++++++----
 1 file changed, 48 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index e22aa285f17..c8637531d94 100644
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -38,7 +38,7 @@ use std::path::Path;
 use crate::utils::internal_lints::is_lint_ref_type;
 use crate::utils::{
     get_enclosing_body, get_parent_expr_for_hir, last_path_segment, match_function_call, match_qpath, match_type,
-    path_to_local_id, paths, span_lint, walk_ptrs_ty_depth,
+    path_to_local_id, paths, span_lint, walk_ptrs_ty_depth, get_parent_expr
 };
 
 /// This is the output file of the lint collector.
@@ -478,7 +478,7 @@ impl<'a, 'hir> ValueTracker<'a, 'hir> {
                     self.value_mutations.push(ApplicabilityModifier::Producer(path));
                 } else {
                     let msg = format!(
-                        "Unsupported Call expression at: {}",
+                        "Unsupported assign Call expression at: {}",
                         SerializableSpan::from_span(self.cx, func_expr.span)
                     );
                     self.value_mutations.push(ApplicabilityModifier::Unknown(msg));
@@ -486,7 +486,7 @@ impl<'a, 'hir> ValueTracker<'a, 'hir> {
             },
             hir::ExprKind::MethodCall(..) => {
                 let msg = format!(
-                    "Unsupported MethodCall expression at: {}",
+                    "Unsupported assign MethodCall expression at: {}",
                     SerializableSpan::from_span(self.cx, expr.span)
                 );
                 self.value_mutations.push(ApplicabilityModifier::Unknown(msg));
@@ -518,13 +518,56 @@ impl<'a, 'hir> ValueTracker<'a, 'hir> {
             // hir::ExprKind::Index(expr, expr) => not supported
             _ => {
                 let msg = format!(
-                    "Unexpected expression at: {}",
+                    "Unexpected assign expression at: {}",
                     SerializableSpan::from_span(self.cx, expr.span)
                 );
                 self.value_mutations.push(ApplicabilityModifier::Unknown(msg));
             },
         }
     }
+
+    fn process_borrow_expr(&mut self, access_hir_id: hir::HirId) {
+        let borrower: &rustc_hir::Expr<'_>;
+        if let Some(addr_of_expr) = get_parent_expr_for_hir(self.cx, access_hir_id) {
+            if let Some(borrower_expr) = get_parent_expr(self.cx, addr_of_expr) {
+                borrower = borrower_expr
+            } else {
+                return;
+            }
+        } else {
+            return;
+        }
+
+        match &borrower.kind {
+            hir::ExprKind::Call(func_expr, ..) => {
+                // We only deal with resolved paths as this is the usual case. Other expression kinds like closures
+                // etc. are hard to track but might be a worthy improvement in the future
+                if let hir::ExprKind::Path(hir::QPath::Resolved(_, path)) = func_expr.kind {
+                    self.value_mutations.push(ApplicabilityModifier::Modifier(path));
+                } else {
+                    let msg = format!(
+                        "Unsupported borrow in Call at: {}",
+                        SerializableSpan::from_span(self.cx, func_expr.span)
+                    );
+                    self.value_mutations.push(ApplicabilityModifier::Unknown(msg));
+                }
+            },
+            hir::ExprKind::MethodCall(..) => {
+                let msg = format!(
+                    "Unsupported borrow in MethodCall at: {}",
+                    SerializableSpan::from_span(self.cx, borrower.span)
+                );
+                self.value_mutations.push(ApplicabilityModifier::Unknown(msg));
+            },
+            _ => {
+                let msg = format!(
+                    "Unexpected borrow at: {}",
+                    SerializableSpan::from_span(self.cx, borrower.span)
+                );
+                self.value_mutations.push(ApplicabilityModifier::Unknown(msg));
+            },
+        }
+    }
 }
 
 impl<'a, 'hir> Delegate<'hir> for ValueTracker<'a, 'hir> {
@@ -541,11 +584,7 @@ impl<'a, 'hir> Delegate<'hir> for ValueTracker<'a, 'hir> {
     fn borrow(&mut self, _place_with_id: &PlaceWithHirId<'hir>, expr_id: hir::HirId, bk: BorrowKind) {
         if self.is_value_expr(expr_id) {
             if let BorrowKind::MutBorrow = bk {
-                // TODO xFrednet 2021-02-17: Save the function
-                if let Some(hir::Node::Expr(expr)) = self.cx.tcx.hir().find(expr_id) {
-                    let span = SerializableSpan::from_span(self.cx, expr.span);
-                    log_to_file(&format!("- &mut     {}\n", span));
-                }
+                self.process_borrow_expr(expr_id);
             }
         }
     }
-- 
cgit 1.4.1-3-g733a5


From a39912cfbbd682270b5f3d534bc69eedfaa73a7b Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Sat, 20 Feb 2021 13:12:30 +0100
Subject: Metadata collection: Some refactoring for readability

---
 .../src/utils/internal_lints/metadata_collector.rs | 104 +++++++++++----------
 .../track_applicability_value.rs                   |   4 +
 2 files changed, 57 insertions(+), 51 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index c8637531d94..de94e47047b 100644
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -37,8 +37,8 @@ use std::path::Path;
 
 use crate::utils::internal_lints::is_lint_ref_type;
 use crate::utils::{
-    get_enclosing_body, get_parent_expr_for_hir, last_path_segment, match_function_call, match_qpath, match_type,
-    path_to_local_id, paths, span_lint, walk_ptrs_ty_depth, get_parent_expr
+    get_enclosing_body, get_parent_expr, get_parent_expr_for_hir, last_path_segment, match_function_call, match_qpath,
+    match_type, path_to_local_id, paths, span_lint, walk_ptrs_ty_depth,
 };
 
 /// This is the output file of the lint collector.
@@ -202,39 +202,19 @@ impl<'tcx> LateLintPass<'tcx> for MetadataCollector {
     /// ```
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
         if_chain! {
+            // item validation
             if let ItemKind::Static(ref ty, Mutability::Not, body_id) = item.kind;
             if is_lint_ref_type(cx, ty);
             let expr = &cx.tcx.hir().body(body_id).value;
             if let ExprKind::AddrOf(_, _, ref inner_exp) = expr.kind;
             if let ExprKind::Struct(_, _, _) = inner_exp.kind;
+            // blacklist check
+            let lint_name = sym_to_string(item.ident.name).to_ascii_lowercase();
+            if !BLACK_LISTED_LINTS.contains(&lint_name.as_str());
+            // metadata extraction
+            if let Some(group) = get_lint_group_or_lint(cx, &lint_name, item);
+            if let Some(docs) = extract_attr_docs_or_lint(cx, item);
             then {
-                let lint_name = sym_to_string(item.ident.name).to_ascii_lowercase();
-                if BLACK_LISTED_LINTS.contains(&lint_name.as_str()) {
-                    return;
-                }
-
-                let group: String;
-                let result = cx.lint_store.check_lint_name(lint_name.as_str(), Some(sym::clippy));
-                if let CheckLintNameResult::Tool(Ok(lint_lst)) = result {
-                    if let Some(group_some) = get_lint_group(cx, lint_lst[0]) {
-                        group = group_some;
-                    } else {
-                        lint_collection_error_item(cx, item, "Unable to determine lint group");
-                        return;
-                    }
-                } else {
-                    lint_collection_error_item(cx, item, "Unable to find lint in lint_store");
-                    return;
-                }
-
-                let docs: String;
-                if let Some(docs_some) = extract_attr_docs(item) {
-                    docs = docs_some;
-                } else {
-                    lint_collection_error_item(cx, item, "could not collect the lint documentation");
-                    return;
-                };
-
                 self.lints.push(LintMetadata::new(
                     lint_name,
                     SerializableSpan::from_item(cx, item),
@@ -301,7 +281,7 @@ impl<'tcx> LateLintPass<'tcx> for MetadataCollector {
                 let span = SerializableSpan::from_span(cx, local.span);
                 let local_str = crate::utils::snippet(cx, local.span, "_");
                 log_to_file(&format!("{} -- {}\n", local_str, span));
-                
+
                 let value_hir_id = local.pat.hir_id;
                 let mut tracker = ValueTracker::new(cx, value_hir_id);
                 if let Some(init_expr) = local.init {
@@ -342,10 +322,21 @@ fn get_local_type<'a>(cx: &'a LateContext<'_>, local: &'a hir::Local<'_>) -> Opt
     None
 }
 
+// ==================================================================
+// Lint definition extraction
+// ==================================================================
+
 fn sym_to_string(sym: Symbol) -> String {
     sym.as_str().to_string()
 }
 
+fn extract_attr_docs_or_lint(cx: &LateContext<'_>, item: &Item<'_>) -> Option<String> {
+    extract_attr_docs(item).or_else(|| {
+        lint_collection_error_item(cx, item, "could not collect the lint documentation");
+        None
+    })
+}
+
 /// This function collects all documentation that has been added to an item using
 /// `#[doc = r""]` attributes. Several attributes are aggravated using line breaks
 ///
@@ -367,6 +358,19 @@ fn extract_attr_docs(item: &Item<'_>) -> Option<String> {
         })
 }
 
+fn get_lint_group_or_lint(cx: &LateContext<'_>, lint_name: &str, item: &'tcx Item<'_>) -> Option<String> {
+    let result = cx.lint_store.check_lint_name(lint_name, Some(sym::clippy));
+    if let CheckLintNameResult::Tool(Ok(lint_lst)) = result {
+        get_lint_group(cx, lint_lst[0]).or_else(|| {
+            lint_collection_error_item(cx, item, "Unable to determine lint group");
+            None
+        })
+    } else {
+        lint_collection_error_item(cx, item, "Unable to find lint in lint_store");
+        None
+    }
+}
+
 fn get_lint_group(cx: &LateContext<'_>, lint_id: LintId) -> Option<String> {
     for (group_name, lints, _) in &cx.lint_store.get_lint_groups() {
         if lints.iter().any(|x| *x == lint_id) {
@@ -526,19 +530,8 @@ impl<'a, 'hir> ValueTracker<'a, 'hir> {
         }
     }
 
-    fn process_borrow_expr(&mut self, access_hir_id: hir::HirId) {
-        let borrower: &rustc_hir::Expr<'_>;
-        if let Some(addr_of_expr) = get_parent_expr_for_hir(self.cx, access_hir_id) {
-            if let Some(borrower_expr) = get_parent_expr(self.cx, addr_of_expr) {
-                borrower = borrower_expr
-            } else {
-                return;
-            }
-        } else {
-            return;
-        }
-
-        match &borrower.kind {
+    fn process_borrow_expr(&mut self, borrower_expr: &'hir rustc_hir::Expr<'hir>) {
+        match &borrower_expr.kind {
             hir::ExprKind::Call(func_expr, ..) => {
                 // We only deal with resolved paths as this is the usual case. Other expression kinds like closures
                 // etc. are hard to track but might be a worthy improvement in the future
@@ -555,36 +548,45 @@ impl<'a, 'hir> ValueTracker<'a, 'hir> {
             hir::ExprKind::MethodCall(..) => {
                 let msg = format!(
                     "Unsupported borrow in MethodCall at: {}",
-                    SerializableSpan::from_span(self.cx, borrower.span)
+                    SerializableSpan::from_span(self.cx, borrower_expr.span)
                 );
                 self.value_mutations.push(ApplicabilityModifier::Unknown(msg));
             },
             _ => {
                 let msg = format!(
                     "Unexpected borrow at: {}",
-                    SerializableSpan::from_span(self.cx, borrower.span)
+                    SerializableSpan::from_span(self.cx, borrower_expr.span)
                 );
                 self.value_mutations.push(ApplicabilityModifier::Unknown(msg));
             },
         }
     }
+
+    fn process_consume_expr(&mut self, consume_expr: &'hir rustc_hir::Expr<'hir>) {
+        // We are only interested in lint emissions. Other types like assignments might be
+        // interesting for further use or improvement but are to complex for now.
+        if let hir::ExprKind::Call(func_expr, ..) = &consume_expr.kind {}
+    }
 }
 
 impl<'a, 'hir> Delegate<'hir> for ValueTracker<'a, 'hir> {
     fn consume(&mut self, _place_with_id: &PlaceWithHirId<'hir>, expr_id: hir::HirId, _: ConsumeMode) {
         if self.is_value_expr(expr_id) {
             // TODO xFrednet 2021-02-17: Check if lint emission and extract lint ID
-            if let Some(hir::Node::Expr(expr)) = self.cx.tcx.hir().find(expr_id) {
-                let span = SerializableSpan::from_span(self.cx, expr.span);
-                log_to_file(&format!("- consume {}\n", span));
+            if let Some(expr) = get_parent_expr_for_hir(self.cx, expr_id) {
+                log_to_file(&format!("- consume {:?}\n", expr));
             }
         }
     }
 
     fn borrow(&mut self, _place_with_id: &PlaceWithHirId<'hir>, expr_id: hir::HirId, bk: BorrowKind) {
-        if self.is_value_expr(expr_id) {
-            if let BorrowKind::MutBorrow = bk {
-                self.process_borrow_expr(expr_id);
+        if_chain! {
+            if self.is_value_expr(expr_id);
+            if let BorrowKind::MutBorrow = bk;
+            if let Some(addr_of_expr) = get_parent_expr_for_hir(self.cx, expr_id);
+            if let Some(borrower_expr) = get_parent_expr(self.cx, addr_of_expr);
+            then {
+                self.process_borrow_expr(borrower_expr);
             }
         }
     }
diff --git a/tests/ui-internal/metadata-collector/track_applicability_value.rs b/tests/ui-internal/metadata-collector/track_applicability_value.rs
index 75fae623e61..b0f59e5cf8a 100644
--- a/tests/ui-internal/metadata-collector/track_applicability_value.rs
+++ b/tests/ui-internal/metadata-collector/track_applicability_value.rs
@@ -23,6 +23,8 @@ fn modifier_fn(applicability: &mut Applicability) {
     }
 }
 
+fn consumer_fn(_applicability: Applicability) {}
+
 struct Muh;
 
 impl Muh {
@@ -43,4 +45,6 @@ fn main() {
     };
 
     modifier_fn(&mut applicability);
+
+    consumer_fn(applicability);
 }
-- 
cgit 1.4.1-3-g733a5


From ee8a99a1140880e10677fa0b03167cd364fece3f Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Sat, 20 Feb 2021 13:50:09 +0100
Subject: Metadata collection: Collecting Applicability assign values

---
 clippy_lints/Cargo.toml                            |   2 +-
 .../src/utils/internal_lints/metadata_collector.rs | 361 ++++-----------------
 clippy_utils/Cargo.toml                            |   1 +
 clippy_utils/src/lib.rs                            |   8 +-
 4 files changed, 73 insertions(+), 299 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/Cargo.toml b/clippy_lints/Cargo.toml
index d1d56fc84f9..42218c2c00a 100644
--- a/clippy_lints/Cargo.toml
+++ b/clippy_lints/Cargo.toml
@@ -33,7 +33,7 @@ url = { version = "2.1.0", features = ["serde"] }
 deny-warnings = []
 # build clippy with internal lints enabled, off by default
 internal-lints = ["clippy_utils/internal-lints"]
-metadata-collector-lint = ["serde_json"]
+metadata-collector-lint = ["serde_json", "clippy_utils/metadata-collector-lint"]
 
 [package.metadata.rust-analyzer]
 # This crate uses #[feature(rustc_private)]
diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index de94e47047b..a16f7c2ea5e 100644
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -21,15 +21,11 @@
 // - TODO xFrednet 2021-02-13: Collect depreciations and maybe renames
 
 use if_chain::if_chain;
-use rustc_data_structures::fx::{FxHashMap, FxHashSet};
+use rustc_data_structures::fx::FxHashMap;
 use rustc_hir::{self as hir, ExprKind, Item, ItemKind, Mutability};
 use rustc_lint::{CheckLintNameResult, LateContext, LateLintPass, LintContext, LintId};
-use rustc_middle::ty::{BorrowKind, Ty};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::{sym, Loc, Span, Symbol};
-use rustc_trait_selection::infer::TyCtxtInferExt;
-use rustc_typeck::expr_use_visitor::{ConsumeMode, Delegate, ExprUseVisitor, PlaceWithHirId};
-use rustc_typeck::hir_ty_to_ty;
 use serde::Serialize;
 use std::fs::{self, OpenOptions};
 use std::io::prelude::*;
@@ -37,8 +33,7 @@ use std::path::Path;
 
 use crate::utils::internal_lints::is_lint_ref_type;
 use crate::utils::{
-    get_enclosing_body, get_parent_expr, get_parent_expr_for_hir, last_path_segment, match_function_call, match_qpath,
-    match_type, path_to_local_id, paths, span_lint, walk_ptrs_ty_depth,
+    last_path_segment, match_function_call, match_type, paths, span_lint, walk_ptrs_ty_depth, match_path,
 };
 
 /// This is the output file of the lint collector.
@@ -50,11 +45,11 @@ const BLACK_LISTED_LINTS: [&str; 2] = ["lint_author", "deep_code_inspection"];
 // handling
 #[rustfmt::skip]
 const LINT_EMISSION_FUNCTIONS: [&[&str]; 5] = [
-    &["clippy_lints", "utils", "diagnostics", "span_lint"],
-    &["clippy_lints", "utils", "diagnostics", "span_lint_and_help"],
-    &["clippy_lints", "utils", "diagnostics", "span_lint_and_note"],
-    &["clippy_lints", "utils", "diagnostics", "span_lint_hir"],
-    &["clippy_lints", "utils", "diagnostics", "span_lint_and_sugg"],
+    &["clippy_utils", "diagnostics", "span_lint"],
+    &["clippy_utils", "diagnostics", "span_lint_and_help"],
+    &["clippy_utils", "diagnostics", "span_lint_and_note"],
+    &["clippy_utils", "diagnostics", "span_lint_hir"],
+    &["clippy_utils", "diagnostics", "span_lint_and_sugg"],
 ];
 
 declare_clippy_lint! {
@@ -175,10 +170,10 @@ struct ApplicabilityInfo {
     /// [rustfix#141](https://github.com/rust-lang/rustfix/issues/141) as such suggestions can
     /// currently not be applied automatically.
     has_multi_suggestion: bool,
-    /// These are all the available applicability values for the lint suggestions
-    applicabilities: FxHashSet<String>,
+    applicability: Option<String>,
 }
 
+#[allow(dead_code)]
 fn log_to_file(msg: &str) {
     let mut file = OpenOptions::new()
         .write(true)
@@ -190,7 +185,7 @@ fn log_to_file(msg: &str) {
     write!(file, "{}", msg).unwrap();
 }
 
-impl<'tcx> LateLintPass<'tcx> for MetadataCollector {
+impl<'hir> LateLintPass<'hir> for MetadataCollector {
     /// Collecting lint declarations like:
     /// ```rust, ignore
     /// declare_clippy_lint! {
@@ -200,7 +195,7 @@ impl<'tcx> LateLintPass<'tcx> for MetadataCollector {
     ///     "Who am I?"
     /// }
     /// ```
-    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
+    fn check_item(&mut self, cx: &LateContext<'hir>, item: &'hir Item<'_>) {
         if_chain! {
             // item validation
             if let ItemKind::Static(ref ty, Mutability::Not, body_id) = item.kind;
@@ -239,87 +234,16 @@ impl<'tcx> LateLintPass<'tcx> for MetadataCollector {
     ///     Applicability::MachineApplicable, // <-- Extracts this constant value
     /// );
     /// ```
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
+    fn check_expr(&mut self, cx: &LateContext<'hir>, expr: &'hir hir::Expr<'_>) {
         if let Some(args) = match_simple_lint_emission(cx, expr) {
-            if let Some((lint_name, mut applicability)) = extract_emission_info(cx, args) {
+            if let Some((lint_name, applicability)) = extract_emission_info(cx, args) {
                 let app_info = self.applicability_into.entry(lint_name).or_default();
-                applicability.drain(..).for_each(|x| {
-                    app_info.applicabilities.insert(x);
-                });
+                app_info.applicability = applicability;
             } else {
                 lint_collection_error_span(cx, expr.span, "I found this but I can't get the lint or applicability");
             }
         }
     }
-
-    /// Tracking and hopefully collecting dynamic applicability values
-    ///
-    /// Example:
-    /// ```rust, ignore
-    /// // vvv Applicability value to track
-    /// let mut applicability = Applicability::MachineApplicable;
-    /// // vvv Value Mutation
-    /// let suggestion = snippet_with_applicability(cx, expr.span, "_", &mut applicability);
-    /// // vvv Emission to link the value to the lint
-    /// span_lint_and_sugg(
-    ///     cx,
-    ///     SOME_LINT,
-    ///     expr.span,
-    ///     "This can be improved",
-    ///     "try",
-    ///     suggestion,
-    ///     applicability,
-    /// );
-    /// ```
-    fn check_local(&mut self, cx: &LateContext<'tcx>, local: &'tcx hir::Local<'tcx>) {
-        if_chain! {
-            if let Some(local_ty) = get_local_type(cx, local);
-            if match_type(cx, local_ty, &paths::APPLICABILITY);
-            if let Some(body) = get_enclosing_body(cx, local.hir_id);
-            then {
-                // TODO xFrednet: 2021-02-19: Remove debug code
-                let span = SerializableSpan::from_span(cx, local.span);
-                let local_str = crate::utils::snippet(cx, local.span, "_");
-                log_to_file(&format!("{} -- {}\n", local_str, span));
-
-                let value_hir_id = local.pat.hir_id;
-                let mut tracker = ValueTracker::new(cx, value_hir_id);
-                if let Some(init_expr) = local.init {
-                    tracker.process_assign_expr(init_expr)
-                }
-
-                // TODO xFrednet 2021-02-18: Support nested bodies
-                // Note: The `ExprUseVisitor` only searches though one body, this means that values
-                // references in nested bodies like closures are not found by this simple visitor.
-                cx.tcx.infer_ctxt().enter(|infcx| {
-                    let body_owner_id = cx.tcx.hir().body_owner_def_id(body.id());
-                    ExprUseVisitor::new(
-                        &mut tracker,
-                        &infcx,
-                        body_owner_id,
-                        cx.param_env,
-                        cx.typeck_results()
-                    )
-                    .consume_body(body);
-                });
-
-                log_to_file(&format!("{:?}\n", tracker.value_mutations));
-            }
-        }
-    }
-}
-
-fn get_local_type<'a>(cx: &'a LateContext<'_>, local: &'a hir::Local<'_>) -> Option<Ty<'a>> {
-    // TODO xFrednet 2021-02-14: support nested applicability (only in tuples)
-    if let Some(tc) = cx.maybe_typeck_results() {
-        if let Some(ty) = local.ty {
-            return Some(hir_ty_to_ty(cx.tcx, ty));
-        } else if let Some(init) = local.init {
-            return Some(tc.expr_ty(init));
-        }
-    }
-
-    None
 }
 
 // ==================================================================
@@ -358,7 +282,7 @@ fn extract_attr_docs(item: &Item<'_>) -> Option<String> {
         })
 }
 
-fn get_lint_group_or_lint(cx: &LateContext<'_>, lint_name: &str, item: &'tcx Item<'_>) -> Option<String> {
+fn get_lint_group_or_lint(cx: &LateContext<'_>, lint_name: &str, item: &'hir Item<'_>) -> Option<String> {
     let result = cx.lint_store.check_lint_name(lint_name, Some(sym::clippy));
     if let CheckLintNameResult::Tool(Ok(lint_lst)) = result {
         get_lint_group(cx, lint_lst[0]).or_else(|| {
@@ -405,17 +329,19 @@ fn lint_collection_error_span(cx: &LateContext<'_>, span: Span, message: &str) {
 // ==================================================================
 // Applicability
 // ==================================================================
-fn match_simple_lint_emission<'tcx>(
-    cx: &LateContext<'tcx>,
-    expr: &'tcx hir::Expr<'_>,
-) -> Option<&'tcx [hir::Expr<'tcx>]> {
+/// This function checks if a given expression is equal to a simple lint emission function call.
+/// It will return the function arguments if the emission matched any function.
+fn match_simple_lint_emission<'hir>(
+    cx: &LateContext<'hir>,
+    expr: &'hir hir::Expr<'_>,
+) -> Option<&'hir [hir::Expr<'hir>]> {
     LINT_EMISSION_FUNCTIONS
         .iter()
         .find_map(|emission_fn| match_function_call(cx, expr, emission_fn))
 }
 
 /// This returns the lint name and the possible applicability of this emission
-fn extract_emission_info<'tcx>(cx: &LateContext<'tcx>, args: &[hir::Expr<'_>]) -> Option<(String, Vec<String>)> {
+fn extract_emission_info<'hir>(cx: &LateContext<'hir>, args: &[hir::Expr<'_>]) -> Option<(String, Option<String>)> {
     let mut lint_name = None;
     let mut applicability = None;
 
@@ -425,228 +351,69 @@ fn extract_emission_info<'tcx>(cx: &LateContext<'tcx>, args: &[hir::Expr<'_>]) -
         if match_type(cx, arg_ty, &paths::LINT) {
             // If we found the lint arg, extract the lint name
             if let ExprKind::Path(ref lint_path) = arg.kind {
-                lint_name = Some(last_path_segment(lint_path).ident.name)
+                lint_name = Some(last_path_segment(lint_path).ident.name);
             }
         } else if match_type(cx, arg_ty, &paths::APPLICABILITY) {
-            if let ExprKind::Path(ref path) = arg.kind {
-                applicability = Some(last_path_segment(path).ident.name)
-            }
+            applicability = resolve_applicability(cx, arg);
         }
     }
 
     lint_name.map(|lint_name| {
         (
             sym_to_string(lint_name).to_ascii_lowercase(),
-            applicability.map(sym_to_string).map_or_else(Vec::new, |x| vec![x]),
+            applicability,
         )
     })
 }
 
-#[allow(dead_code)]
-struct ValueTracker<'a, 'hir> {
-    cx: &'a LateContext<'hir>,
-    value_hir_id: hir::HirId,
-    value_mutations: Vec<ApplicabilityModifier<'hir>>,
-}
-
-impl<'a, 'hir> ValueTracker<'a, 'hir> {
-    fn new(cx: &'a LateContext<'hir>, value_hir_id: hir::HirId) -> Self {
-        Self {
-            cx,
-            value_hir_id,
-            value_mutations: Vec::new(),
-        }
-    }
-
-    fn is_value_expr(&self, expr_id: hir::HirId) -> bool {
-        match self.cx.tcx.hir().find(expr_id) {
-            Some(hir::Node::Expr(expr)) => path_to_local_id(expr, self.value_hir_id),
-            _ => false,
-        }
-    }
-
-    /// This function extracts possible `ApplicabilityModifier` from an assign statement like this:
-    ///
-    /// ```rust, ignore
-    /// //          vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv The expression to process
-    /// let value = Applicability::MachineApplicable;
-    /// ```
-    fn process_assign_expr(&mut self, expr: &'hir hir::Expr<'hir>) {
-        // This is a bit more complicated. I'll therefor settle on the simple solution of
-        // simplifying the cases we support.
-        match &expr.kind {
-            hir::ExprKind::Call(func_expr, ..) => {
-                // We only deal with resolved paths as this is the usual case. Other expression kinds like closures
-                // etc. are hard to track but might be a worthy improvement in the future
-                if let hir::ExprKind::Path(hir::QPath::Resolved(_, path)) = func_expr.kind {
-                    self.value_mutations.push(ApplicabilityModifier::Producer(path));
-                } else {
-                    let msg = format!(
-                        "Unsupported assign Call expression at: {}",
-                        SerializableSpan::from_span(self.cx, func_expr.span)
-                    );
-                    self.value_mutations.push(ApplicabilityModifier::Unknown(msg));
-                }
-            },
-            hir::ExprKind::MethodCall(..) => {
-                let msg = format!(
-                    "Unsupported assign MethodCall expression at: {}",
-                    SerializableSpan::from_span(self.cx, expr.span)
-                );
-                self.value_mutations.push(ApplicabilityModifier::Unknown(msg));
-            },
-            // We can ignore ifs without an else block because those can't be used as an assignment
-            hir::ExprKind::If(_con, if_block, Some(else_block)) => {
-                self.process_assign_expr(if_block);
-                self.process_assign_expr(else_block);
-            },
-            hir::ExprKind::Match(_expr, arms, _) => {
-                for arm in *arms {
-                    self.process_assign_expr(arm.body);
-                }
-            },
-            hir::ExprKind::Loop(block, ..) | hir::ExprKind::Block(block, ..) => {
-                if let Some(block_expr) = block.expr {
-                    self.process_assign_expr(block_expr);
+fn resolve_applicability(cx: &LateContext<'hir>, expr: &hir::Expr<'_>) -> Option<String> {
+    match expr.kind {
+        // We can ignore ifs without an else block because those can't be used as an assignment
+        hir::ExprKind::If(_con, _if_block, Some(_else_block)) => {
+            // self.process_assign_expr(if_block);
+            // self.process_assign_expr(else_block);
+            return Some("TODO IF EXPR".to_string());
+        },
+        hir::ExprKind::Match(_expr, _arms, _) => {
+            // for arm in *arms {
+            //     self.process_assign_expr(arm.body);
+            // }
+            return Some("TODO MATCH EXPR".to_string());
+        },
+        hir::ExprKind::Loop(block, ..) | hir::ExprKind::Block(block, ..) => {
+            if let Some(block_expr) = block.expr {
+                return resolve_applicability(cx, block_expr);
+            }
+        },
+        ExprKind::Path(hir::QPath::Resolved(_, path)) => {
+            // direct applicabilities are simple:
+            for enum_value in &paths::APPLICABILITY_VALUES {
+                if match_path(path, enum_value) {
+                    return Some(enum_value[2].to_string());
                 }
-            },
-            hir::ExprKind::Path(path) => {
-                for enum_value in &paths::APPLICABILITY_VALUES {
-                    if match_qpath(path, enum_value) {
-                        self.value_mutations
-                            .push(ApplicabilityModifier::ConstValue(enum_value[2].to_string()));
+            }
+    
+            // Values yay
+            if let hir::def::Res::Local(local_hir) = path.res {
+                if let Some(local) = get_parent_local(cx, local_hir) {
+                    if let Some(local_init) = local.init {
+                        return resolve_applicability(cx, local_init);
                     }
                 }
-            },
-            // hir::ExprKind::Field(expr, ident) => not supported
-            // hir::ExprKind::Index(expr, expr) => not supported
-            _ => {
-                let msg = format!(
-                    "Unexpected assign expression at: {}",
-                    SerializableSpan::from_span(self.cx, expr.span)
-                );
-                self.value_mutations.push(ApplicabilityModifier::Unknown(msg));
-            },
-        }
-    }
-
-    fn process_borrow_expr(&mut self, borrower_expr: &'hir rustc_hir::Expr<'hir>) {
-        match &borrower_expr.kind {
-            hir::ExprKind::Call(func_expr, ..) => {
-                // We only deal with resolved paths as this is the usual case. Other expression kinds like closures
-                // etc. are hard to track but might be a worthy improvement in the future
-                if let hir::ExprKind::Path(hir::QPath::Resolved(_, path)) = func_expr.kind {
-                    self.value_mutations.push(ApplicabilityModifier::Modifier(path));
-                } else {
-                    let msg = format!(
-                        "Unsupported borrow in Call at: {}",
-                        SerializableSpan::from_span(self.cx, func_expr.span)
-                    );
-                    self.value_mutations.push(ApplicabilityModifier::Unknown(msg));
-                }
-            },
-            hir::ExprKind::MethodCall(..) => {
-                let msg = format!(
-                    "Unsupported borrow in MethodCall at: {}",
-                    SerializableSpan::from_span(self.cx, borrower_expr.span)
-                );
-                self.value_mutations.push(ApplicabilityModifier::Unknown(msg));
-            },
-            _ => {
-                let msg = format!(
-                    "Unexpected borrow at: {}",
-                    SerializableSpan::from_span(self.cx, borrower_expr.span)
-                );
-                self.value_mutations.push(ApplicabilityModifier::Unknown(msg));
-            },
-        }
-    }
-
-    fn process_consume_expr(&mut self, consume_expr: &'hir rustc_hir::Expr<'hir>) {
-        // We are only interested in lint emissions. Other types like assignments might be
-        // interesting for further use or improvement but are to complex for now.
-        if let hir::ExprKind::Call(func_expr, ..) = &consume_expr.kind {}
-    }
-}
-
-impl<'a, 'hir> Delegate<'hir> for ValueTracker<'a, 'hir> {
-    fn consume(&mut self, _place_with_id: &PlaceWithHirId<'hir>, expr_id: hir::HirId, _: ConsumeMode) {
-        if self.is_value_expr(expr_id) {
-            // TODO xFrednet 2021-02-17: Check if lint emission and extract lint ID
-            if let Some(expr) = get_parent_expr_for_hir(self.cx, expr_id) {
-                log_to_file(&format!("- consume {:?}\n", expr));
             }
         }
+        _ => {}
     }
 
-    fn borrow(&mut self, _place_with_id: &PlaceWithHirId<'hir>, expr_id: hir::HirId, bk: BorrowKind) {
-        if_chain! {
-            if self.is_value_expr(expr_id);
-            if let BorrowKind::MutBorrow = bk;
-            if let Some(addr_of_expr) = get_parent_expr_for_hir(self.cx, expr_id);
-            if let Some(borrower_expr) = get_parent_expr(self.cx, addr_of_expr);
-            then {
-                self.process_borrow_expr(borrower_expr);
-            }
-        }
-    }
 
-    fn mutate(&mut self, _assignee_place: &PlaceWithHirId<'hir>, expr_id: hir::HirId) {
-        if_chain! {
-            if self.is_value_expr(expr_id);
-            if let Some(expr) = get_parent_expr_for_hir(self.cx, expr_id);
-            if let hir::ExprKind::Assign(_value_expr, assign_expr, ..) = expr.kind;
-            then {
-                self.process_assign_expr(assign_expr);
-            }
-        }
-    }
+    Some("TODO".to_string())
 }
 
-/// The life of a value in Rust is a true adventure. These are the corner stones of such a
-/// fairy tale. Let me introduce you to the possible stepping stones a value might have in
-/// in our crazy word:
-#[derive(Debug)]
-#[allow(dead_code)]
-enum ApplicabilityModifier<'hir> {
-    Unknown(String),
-    /// A simple constant value.
-    ///
-    /// This is the actual character of a value. It's baseline. This only defines where the value
-    /// started. As in real life it can still change and fully decide who it wants to be.
-    ConstValue(String),
-    /// A producer is a function that returns an applicability value.
-    ///
-    /// This is the heritage of this value. This value comes from a long family tree and is not
-    /// just a black piece of paper. The evaluation of this stepping stone needs additional
-    /// context. We therefore only add a reference. This reference will later be used to ask
-    /// the librarian about the possible initial character that this value might have.
-    Producer(&'hir hir::Path<'hir>),
-    /// A modifier that takes the given applicability and might modify it
-    ///
-    /// What would an RPG be without it's NPCs. The special thing about modifiers is that they can
-    /// be actively interested in the story of the value and might make decisions based on the
-    /// character of this hero. This means that a modifier doesn't just force its way into the life
-    /// of our hero but it actually asks him how he's been. The possible modification is a result
-    /// of the situation.
-    ///
-    /// Take this part of our heroes life very seriously!
-    Modifier(&'hir hir::Path<'hir>),
-    /// The actual emission of a lint
-    ///
-    /// All good things must come to an end. Even the life of your awesome applicability hero. He
-    /// was the bravest soul that has ever wondered this earth. Songs will be written about his
-    /// heroic deeds. Castles will be named after him and the world how we know it will never be
-    /// the same!
-    ///
-    /// Is this a happy ending? Did he archive what he wanted in his life? Yes, YES, he has lived a
-    /// life and he will continue to live in all the lint suggestions that can be applied or just
-    /// displayed by Clippy. He might be no more, but his legacy will serve generations to come.
-    LintEmit(LintEmission),
-}
+fn get_parent_local(cx: &LateContext<'hir>, hir_id: hir::HirId) -> Option<&'hir hir::Local<'hir>> {
+    let map = cx.tcx.hir();
+    if let Some(hir::Node::Local(local)) = map.find(map.get_parent_node(hir_id)) {
+        return Some(local);
+    }
 
-#[derive(Debug)]
-struct LintEmission {
-    lint: String,
-    is_multi_line_sugg: bool,
+    None
 }
diff --git a/clippy_utils/Cargo.toml b/clippy_utils/Cargo.toml
index d04c5f889dd..6e158c8ce72 100644
--- a/clippy_utils/Cargo.toml
+++ b/clippy_utils/Cargo.toml
@@ -15,6 +15,7 @@ rustc-semver="1.1.0"
 
 [features]
 internal-lints = []
+metadata-collector-lint = []
 
 [package.metadata.rust-analyzer]
 # This crate uses #[feature(rustc_private)]
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 94eade0c932..d4bc42657f4 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -821,7 +821,13 @@ pub fn get_parent_node(tcx: TyCtxt<'_>, id: HirId) -> Option<Node<'_>> {
 
 /// Gets the parent expression, if any –- this is useful to constrain a lint.
 pub fn get_parent_expr<'tcx>(cx: &LateContext<'tcx>, e: &Expr<'_>) -> Option<&'tcx Expr<'tcx>> {
-    match get_parent_node(cx.tcx, e.hir_id) {
+    get_parent_expr_for_hir(cx, e.hir_id)
+}
+
+/// This retrieves the parent for the given `HirId` if it's an expression. This is useful for
+/// constraint lints
+pub fn get_parent_expr_for_hir<'tcx>(cx: &LateContext<'tcx>, hir_id: hir::HirId) -> Option<&'tcx Expr<'tcx>> {
+    match get_parent_node(cx.tcx, hir_id) {
         Some(Node::Expr(parent)) => Some(parent),
         _ => None,
     }
-- 
cgit 1.4.1-3-g733a5


From 5830fa7c6064480863d1f90513c0c9b05630a9d3 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Sat, 27 Feb 2021 18:39:02 +0100
Subject: Metadata Collection: Collecting direct emission applicabilities
 (324/455)

---
 .../src/utils/internal_lints/metadata_collector.rs | 126 +++++++++++++++------
 1 file changed, 93 insertions(+), 33 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index a16f7c2ea5e..964ddb36e26 100644
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -14,16 +14,19 @@
 //! - [ ] TODO The Applicability for each lint for [#4310](https://github.com/rust-lang/rust-clippy/issues/4310)
 
 // # Applicability
-// - TODO xFrednet 2021-01-17: Find all methods that take and modify applicability or predefine
-//   them?
 // - TODO xFrednet 2021-01-17: Find lint emit and collect applicability
+// - TODO xFrednet 2021-02-27: Link applicability from function parameters
+//   - (Examples: suspicious_operation_groupings:267, needless_bool.rs:311)
+// - TODO xFrednet 2021-02-27: Tuple if let thingy
+//   - (Examples: unused_unit.rs:140, misc.rs:694)
 // # NITs
 // - TODO xFrednet 2021-02-13: Collect depreciations and maybe renames
 
 use if_chain::if_chain;
 use rustc_data_structures::fx::FxHashMap;
-use rustc_hir::{self as hir, ExprKind, Item, ItemKind, Mutability};
+use rustc_hir::{self as hir, intravisit, ExprKind, Item, ItemKind, Mutability};
 use rustc_lint::{CheckLintNameResult, LateContext, LateLintPass, LintContext, LintId};
+use rustc_middle::hir::map::Map;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::{sym, Loc, Span, Symbol};
 use serde::Serialize;
@@ -33,13 +36,15 @@ use std::path::Path;
 
 use crate::utils::internal_lints::is_lint_ref_type;
 use crate::utils::{
-    last_path_segment, match_function_call, match_type, paths, span_lint, walk_ptrs_ty_depth, match_path,
+    last_path_segment, match_function_call, match_path, match_type, paths, span_lint, walk_ptrs_ty_depth,
 };
 
 /// This is the output file of the lint collector.
 const OUTPUT_FILE: &str = "metadata_collection.json";
 /// These lints are excluded from the export.
 const BLACK_LISTED_LINTS: [&str; 2] = ["lint_author", "deep_code_inspection"];
+/// These groups will be ignored by the lint group matcher
+const BLACK_LISTED_LINT_GROUP: [&str; 1] = ["clippy::all"];
 
 // TODO xFrednet 2021-02-15: `span_lint_and_then` & `span_lint_hir_and_then` requires special
 // handling
@@ -52,6 +57,9 @@ const LINT_EMISSION_FUNCTIONS: [&[&str]; 5] = [
     &["clippy_utils", "diagnostics", "span_lint_and_sugg"],
 ];
 
+/// The index of the applicability name of `paths::APPLICABILITY_VALUES`
+const APPLICABILITY_NAME_INDEX: usize = 2;
+
 declare_clippy_lint! {
     /// **What it does:** Collects metadata about clippy lints for the website.
     ///
@@ -297,6 +305,10 @@ fn get_lint_group_or_lint(cx: &LateContext<'_>, lint_name: &str, item: &'hir Ite
 
 fn get_lint_group(cx: &LateContext<'_>, lint_id: LintId) -> Option<String> {
     for (group_name, lints, _) in &cx.lint_store.get_lint_groups() {
+        if BLACK_LISTED_LINT_GROUP.contains(group_name) {
+            continue;
+        }
+
         if lints.iter().any(|x| *x == lint_id) {
             return Some((*group_name).to_string());
         }
@@ -341,7 +353,10 @@ fn match_simple_lint_emission<'hir>(
 }
 
 /// This returns the lint name and the possible applicability of this emission
-fn extract_emission_info<'hir>(cx: &LateContext<'hir>, args: &[hir::Expr<'_>]) -> Option<(String, Option<String>)> {
+fn extract_emission_info<'hir>(
+    cx: &LateContext<'hir>,
+    args: &'hir [hir::Expr<'hir>],
+) -> Option<(String, Option<String>)> {
     let mut lint_name = None;
     let mut applicability = None;
 
@@ -358,41 +373,38 @@ fn extract_emission_info<'hir>(cx: &LateContext<'hir>, args: &[hir::Expr<'_>]) -
         }
     }
 
-    lint_name.map(|lint_name| {
-        (
-            sym_to_string(lint_name).to_ascii_lowercase(),
-            applicability,
-        )
-    })
+    lint_name.map(|lint_name| (sym_to_string(lint_name).to_ascii_lowercase(), applicability))
 }
 
-fn resolve_applicability(cx: &LateContext<'hir>, expr: &hir::Expr<'_>) -> Option<String> {
+/// This function tries to resolve the linked applicability to the given expression.
+fn resolve_applicability(cx: &LateContext<'hir>, expr: &'hir hir::Expr<'hir>) -> Option<String> {
     match expr.kind {
         // We can ignore ifs without an else block because those can't be used as an assignment
-        hir::ExprKind::If(_con, _if_block, Some(_else_block)) => {
-            // self.process_assign_expr(if_block);
-            // self.process_assign_expr(else_block);
-            return Some("TODO IF EXPR".to_string());
+        hir::ExprKind::If(_con, if_block, Some(else_block)) => {
+            let mut visitor = ApplicabilityVisitor::new(cx);
+            intravisit::walk_expr(&mut visitor, if_block);
+            intravisit::walk_expr(&mut visitor, else_block);
+            visitor.complete()
         },
-        hir::ExprKind::Match(_expr, _arms, _) => {
-            // for arm in *arms {
-            //     self.process_assign_expr(arm.body);
-            // }
-            return Some("TODO MATCH EXPR".to_string());
+        hir::ExprKind::Match(_expr, arms, _) => {
+            let mut visitor = ApplicabilityVisitor::new(cx);
+            arms.iter()
+                .for_each(|arm| intravisit::walk_expr(&mut visitor, arm.body));
+            visitor.complete()
         },
         hir::ExprKind::Loop(block, ..) | hir::ExprKind::Block(block, ..) => {
-            if let Some(block_expr) = block.expr {
-                return resolve_applicability(cx, block_expr);
-            }
+            let mut visitor = ApplicabilityVisitor::new(cx);
+            intravisit::walk_block(&mut visitor, block);
+            visitor.complete()
         },
         ExprKind::Path(hir::QPath::Resolved(_, path)) => {
             // direct applicabilities are simple:
             for enum_value in &paths::APPLICABILITY_VALUES {
                 if match_path(path, enum_value) {
-                    return Some(enum_value[2].to_string());
+                    return Some(enum_value[APPLICABILITY_NAME_INDEX].to_string());
                 }
             }
-    
+
             // Values yay
             if let hir::def::Res::Local(local_hir) = path.res {
                 if let Some(local) = get_parent_local(cx, local_hir) {
@@ -401,19 +413,67 @@ fn resolve_applicability(cx: &LateContext<'hir>, expr: &hir::Expr<'_>) -> Option
                     }
                 }
             }
+
+            // This is true for paths that are linked to function parameters. They might be a bit more work so
+            // not today :)
+            None
+        },
+        _ => None,
+    }
+}
+
+fn get_parent_local(cx: &LateContext<'hir>, hir_id: hir::HirId) -> Option<&'hir hir::Local<'hir>> {
+    let map = cx.tcx.hir();
+
+    match map.find(map.get_parent_node(hir_id)) {
+        Some(hir::Node::Local(local)) => Some(local),
+        Some(hir::Node::Pat(pattern)) => get_parent_local(cx, pattern.hir_id),
+        _ => None,
+    }
+}
+
+/// This visitor finds the highest applicability value in the visited expressions
+struct ApplicabilityVisitor<'a, 'hir> {
+    cx: &'a LateContext<'hir>,
+    /// This is the index of hightest `Applicability` for
+    /// `clippy_utils::paths::APPLICABILITY_VALUES`
+    applicability_index: Option<usize>,
+}
+
+impl<'a, 'hir> ApplicabilityVisitor<'a, 'hir> {
+    fn new(cx: &'a LateContext<'hir>) -> Self {
+        Self {
+            cx,
+            applicability_index: None,
         }
-        _ => {}
     }
 
+    fn add_new_index(&mut self, new_index: usize) {
+        self.applicability_index = self
+            .applicability_index
+            .map_or(new_index, |old_index| old_index.min(new_index))
+            .into();
+    }
 
-    Some("TODO".to_string())
+    fn complete(self) -> Option<String> {
+        self.applicability_index
+            .map(|index| paths::APPLICABILITY_VALUES[index][APPLICABILITY_NAME_INDEX].to_string())
+    }
 }
 
-fn get_parent_local(cx: &LateContext<'hir>, hir_id: hir::HirId) -> Option<&'hir hir::Local<'hir>> {
-    let map = cx.tcx.hir();
-    if let Some(hir::Node::Local(local)) = map.find(map.get_parent_node(hir_id)) {
-        return Some(local);
+impl<'a, 'hir> intravisit::Visitor<'hir> for ApplicabilityVisitor<'a, 'hir> {
+    type Map = Map<'hir>;
+
+    fn nested_visit_map(&mut self) -> intravisit::NestedVisitorMap<Self::Map> {
+        intravisit::NestedVisitorMap::All(self.cx.tcx.hir())
     }
 
-    None
+    fn visit_path(&mut self, path: &hir::Path<'_>, _id: hir::HirId) {
+        for (index, enum_value) in paths::APPLICABILITY_VALUES.iter().enumerate() {
+            if match_path(path, enum_value) {
+                self.add_new_index(index);
+                break;
+            }
+        }
+    }
 }
-- 
cgit 1.4.1-3-g733a5


From 6658db1044bbd19e70bfbf1b74b39bd16d3c4a2c Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Sun, 28 Feb 2021 16:11:45 +0100
Subject: Metadata collection: processing emission closures (417/455)

---
 clippy_lints/src/slow_vector_initialization.rs     |  20 +--
 .../src/utils/internal_lints/metadata_collector.rs | 197 +++++++++++++++++++--
 clippy_utils/src/paths.rs                          |   2 +
 3 files changed, 190 insertions(+), 29 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/slow_vector_initialization.rs b/clippy_lints/src/slow_vector_initialization.rs
index 191781be000..5a51e1141fb 100644
--- a/clippy_lints/src/slow_vector_initialization.rs
+++ b/clippy_lints/src/slow_vector_initialization.rs
@@ -157,26 +157,16 @@ impl SlowVectorInit {
         vec_alloc: &VecAllocation<'_>,
     ) {
         match initialization {
-            InitializationType::Extend(e) | InitializationType::Resize(e) => Self::emit_lint(
-                cx,
-                e,
-                vec_alloc,
-                "slow zero-filling initialization",
-                SLOW_VECTOR_INITIALIZATION,
-            ),
+            InitializationType::Extend(e) | InitializationType::Resize(e) => {
+                Self::emit_lint(cx, e, vec_alloc, "slow zero-filling initialization")
+            },
         };
     }
 
-    fn emit_lint<'tcx>(
-        cx: &LateContext<'tcx>,
-        slow_fill: &Expr<'_>,
-        vec_alloc: &VecAllocation<'_>,
-        msg: &str,
-        lint: &'static Lint,
-    ) {
+    fn emit_lint<'tcx>(cx: &LateContext<'tcx>, slow_fill: &Expr<'_>, vec_alloc: &VecAllocation<'_>, msg: &str) {
         let len_expr = Sugg::hir(cx, vec_alloc.len_expr, "len");
 
-        span_lint_and_then(cx, lint, slow_fill.span, msg, |diag| {
+        span_lint_and_then(cx, SLOW_VECTOR_INITIALIZATION, slow_fill.span, msg, |diag| {
             diag.span_suggestion(
                 vec_alloc.allocation_expr.span,
                 "consider replace allocation with",
diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index 964ddb36e26..20bd2a669aa 100644
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -15,16 +15,25 @@
 
 // # Applicability
 // - TODO xFrednet 2021-01-17: Find lint emit and collect applicability
-// - TODO xFrednet 2021-02-27: Link applicability from function parameters
-//   - (Examples: suspicious_operation_groupings:267, needless_bool.rs:311)
-// - TODO xFrednet 2021-02-27: Tuple if let thingy
-//   - (Examples: unused_unit.rs:140, misc.rs:694)
+//   - TODO xFrednet 2021-02-28:  1x reference to closure
+//     - See clippy_lints/src/needless_pass_by_value.rs@NeedlessPassByValue::check_fn
+//   - TODO xFrednet 2021-02-28:  4x weird emission forwarding
+//     - See clippy_lints/src/enum_variants.rs@EnumVariantNames::check_name
+//   - TODO xFrednet 2021-02-28:  6x emission forwarding with local that is initializes from
+//     function.
+//     - See clippy_lints/src/methods/mod.rs@lint_binary_expr_with_method_call
+//   - TODO xFrednet 2021-02-28:  2x lint from local from function call
+//     - See clippy_lints/src/misc.rs@check_binary
+//   - TODO xFrednet 2021-02-28:  2x lint from local from method call
+//     - See clippy_lints/src/non_copy_const.rs@lint
+//   - TODO xFrednet 2021-02-28: 20x lint from local
+//     - See clippy_lints/src/map_unit_fn.rs@lint_map_unit_fn
 // # NITs
 // - TODO xFrednet 2021-02-13: Collect depreciations and maybe renames
 
 use if_chain::if_chain;
 use rustc_data_structures::fx::FxHashMap;
-use rustc_hir::{self as hir, intravisit, ExprKind, Item, ItemKind, Mutability};
+use rustc_hir::{self as hir, intravisit, ExprKind, Item, ItemKind, Mutability, QPath};
 use rustc_lint::{CheckLintNameResult, LateContext, LateLintPass, LintContext, LintId};
 use rustc_middle::hir::map::Map;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
@@ -44,18 +53,36 @@ const OUTPUT_FILE: &str = "metadata_collection.json";
 /// These lints are excluded from the export.
 const BLACK_LISTED_LINTS: [&str; 2] = ["lint_author", "deep_code_inspection"];
 /// These groups will be ignored by the lint group matcher
-const BLACK_LISTED_LINT_GROUP: [&str; 1] = ["clippy::all"];
+const BLACK_LISTED_LINT_GROUP: [&str; 1] = ["clippy::all", "clippy::internal"];
 
 // TODO xFrednet 2021-02-15: `span_lint_and_then` & `span_lint_hir_and_then` requires special
 // handling
-#[rustfmt::skip]
-const LINT_EMISSION_FUNCTIONS: [&[&str]; 5] = [
+const SIMPLE_LINT_EMISSION_FUNCTIONS: [&[&str]; 5] = [
     &["clippy_utils", "diagnostics", "span_lint"],
     &["clippy_utils", "diagnostics", "span_lint_and_help"],
     &["clippy_utils", "diagnostics", "span_lint_and_note"],
     &["clippy_utils", "diagnostics", "span_lint_hir"],
     &["clippy_utils", "diagnostics", "span_lint_and_sugg"],
 ];
+const COMPLEX_LINT_EMISSION_FUNCTIONS: [&[&str]; 2] = [
+    &["clippy_utils", "diagnostics", "span_lint_and_then"],
+    &["clippy_utils", "diagnostics", "span_lint_hir_and_then"],
+];
+const SUGGESTION_DIAGNOSTIC_BUILDER_METHODS: [(&str, bool); 9] = [
+    ("span_suggestion", false),
+    ("span_suggestion_short", false),
+    ("span_suggestion_verbose", false),
+    ("span_suggestion_hidden", false),
+    ("tool_only_span_suggestion", false),
+    ("multipart_suggestion", true),
+    ("multipart_suggestions", true),
+    ("tool_only_multipart_suggestion", true),
+    ("span_suggestions", true),
+];
+const SUGGESTION_FUNCTIONS: [&[&str]; 2] = [
+    &["clippy_utils", "diagnostics", "mutispan_sugg"],
+    &["clippy_utils", "diagnostics", "multispan_sugg_with_applicability"],
+];
 
 /// The index of the applicability name of `paths::APPLICABILITY_VALUES`
 const APPLICABILITY_NAME_INDEX: usize = 2;
@@ -177,7 +204,7 @@ struct ApplicabilityInfo {
     /// Indicates if any of the lint emissions uses multiple spans. This is related to
     /// [rustfix#141](https://github.com/rust-lang/rustfix/issues/141) as such suggestions can
     /// currently not be applied automatically.
-    has_multi_suggestion: bool,
+    is_multi_suggestion: bool,
     applicability: Option<String>,
 }
 
@@ -250,6 +277,14 @@ impl<'hir> LateLintPass<'hir> for MetadataCollector {
             } else {
                 lint_collection_error_span(cx, expr.span, "I found this but I can't get the lint or applicability");
             }
+        } else if let Some(args) = match_complex_lint_emission(cx, expr) {
+            if let Some((lint_name, applicability, is_multi_span)) = extract_complex_emission_info(cx, args) {
+                let app_info = self.applicability_into.entry(lint_name).or_default();
+                app_info.applicability = applicability;
+                app_info.is_multi_suggestion = is_multi_span;
+            } else {
+                lint_collection_error_span(cx, expr.span, "Look, here ... I have no clue what todo with it");
+            }
         }
     }
 }
@@ -347,7 +382,16 @@ fn match_simple_lint_emission<'hir>(
     cx: &LateContext<'hir>,
     expr: &'hir hir::Expr<'_>,
 ) -> Option<&'hir [hir::Expr<'hir>]> {
-    LINT_EMISSION_FUNCTIONS
+    SIMPLE_LINT_EMISSION_FUNCTIONS
+        .iter()
+        .find_map(|emission_fn| match_function_call(cx, expr, emission_fn))
+}
+
+fn match_complex_lint_emission<'hir>(
+    cx: &LateContext<'hir>,
+    expr: &'hir hir::Expr<'_>,
+) -> Option<&'hir [hir::Expr<'hir>]> {
+    COMPLEX_LINT_EMISSION_FUNCTIONS
         .iter()
         .find_map(|emission_fn| match_function_call(cx, expr, emission_fn))
 }
@@ -376,28 +420,60 @@ fn extract_emission_info<'hir>(
     lint_name.map(|lint_name| (sym_to_string(lint_name).to_ascii_lowercase(), applicability))
 }
 
+fn extract_complex_emission_info<'hir>(
+    cx: &LateContext<'hir>,
+    args: &'hir [hir::Expr<'hir>],
+) -> Option<(String, Option<String>, bool)> {
+    let mut lint_name = None;
+    let mut applicability = None;
+    let mut multi_span = false;
+
+    for arg in args {
+        let (arg_ty, _) = walk_ptrs_ty_depth(cx.typeck_results().expr_ty(&arg));
+
+        if match_type(cx, arg_ty, &paths::LINT) {
+            // If we found the lint arg, extract the lint name
+            if let ExprKind::Path(ref lint_path) = arg.kind {
+                lint_name = Some(last_path_segment(lint_path).ident.name);
+            }
+        } else if arg_ty.is_closure() {
+            if let ExprKind::Closure(_, _, body_id, _, _) = arg.kind {
+                let mut visitor = EmissionClosureVisitor::new(cx);
+                intravisit::walk_body(&mut visitor, cx.tcx.hir().body(body_id));
+                multi_span = visitor.found_multi_span();
+                applicability = visitor.complete();
+            } else {
+                // TODO xfrednet 2021-02-28: linked closures, see: needless_pass_by_value.rs:292
+                return None;
+            }
+        }
+    }
+
+    lint_name.map(|lint_name| (sym_to_string(lint_name).to_ascii_lowercase(), applicability, multi_span))
+}
+
 /// This function tries to resolve the linked applicability to the given expression.
 fn resolve_applicability(cx: &LateContext<'hir>, expr: &'hir hir::Expr<'hir>) -> Option<String> {
     match expr.kind {
         // We can ignore ifs without an else block because those can't be used as an assignment
-        hir::ExprKind::If(_con, if_block, Some(else_block)) => {
+        ExprKind::If(_con, if_block, Some(else_block)) => {
             let mut visitor = ApplicabilityVisitor::new(cx);
             intravisit::walk_expr(&mut visitor, if_block);
             intravisit::walk_expr(&mut visitor, else_block);
             visitor.complete()
         },
-        hir::ExprKind::Match(_expr, arms, _) => {
+        ExprKind::Match(_expr, arms, _) => {
             let mut visitor = ApplicabilityVisitor::new(cx);
             arms.iter()
                 .for_each(|arm| intravisit::walk_expr(&mut visitor, arm.body));
             visitor.complete()
         },
-        hir::ExprKind::Loop(block, ..) | hir::ExprKind::Block(block, ..) => {
+        ExprKind::Loop(block, ..) | ExprKind::Block(block, ..) => {
             let mut visitor = ApplicabilityVisitor::new(cx);
             intravisit::walk_block(&mut visitor, block);
             visitor.complete()
         },
-        ExprKind::Path(hir::QPath::Resolved(_, path)) => {
+        ExprKind::Path(QPath::Resolved(_, path)) => {
             // direct applicabilities are simple:
             for enum_value in &paths::APPLICABILITY_VALUES {
                 if match_path(path, enum_value) {
@@ -477,3 +553,96 @@ impl<'a, 'hir> intravisit::Visitor<'hir> for ApplicabilityVisitor<'a, 'hir> {
         }
     }
 }
+
+/// This visitor finds the highest applicability value in the visited expressions
+struct EmissionClosureVisitor<'a, 'hir> {
+    cx: &'a LateContext<'hir>,
+    /// This is the index of hightest `Applicability` for
+    /// `clippy_utils::paths::APPLICABILITY_VALUES`
+    applicability_index: Option<usize>,
+    suggestion_count: usize,
+}
+
+impl<'a, 'hir> EmissionClosureVisitor<'a, 'hir> {
+    fn new(cx: &'a LateContext<'hir>) -> Self {
+        Self {
+            cx,
+            applicability_index: None,
+            suggestion_count: 0,
+        }
+    }
+
+    fn add_new_index(&mut self, new_index: usize) {
+        self.applicability_index = self
+            .applicability_index
+            .map_or(new_index, |old_index| old_index.min(new_index))
+            .into();
+    }
+
+    fn found_multi_span(&self) -> bool {
+        self.suggestion_count > 1
+    }
+
+    fn complete(self) -> Option<String> {
+        self.applicability_index
+            .map(|index| paths::APPLICABILITY_VALUES[index][APPLICABILITY_NAME_INDEX].to_string())
+    }
+}
+
+impl<'a, 'hir> intravisit::Visitor<'hir> for EmissionClosureVisitor<'a, 'hir> {
+    type Map = Map<'hir>;
+
+    fn nested_visit_map(&mut self) -> intravisit::NestedVisitorMap<Self::Map> {
+        intravisit::NestedVisitorMap::All(self.cx.tcx.hir())
+    }
+
+    fn visit_path(&mut self, path: &hir::Path<'_>, _id: hir::HirId) {
+        for (index, enum_value) in paths::APPLICABILITY_VALUES.iter().enumerate() {
+            if match_path(path, enum_value) {
+                self.add_new_index(index);
+                break;
+            }
+        }
+    }
+
+    fn visit_expr(&mut self, expr: &'hir hir::Expr<'hir>) {
+        match &expr.kind {
+            ExprKind::Call(fn_expr, _args) => {
+                let found_function = SUGGESTION_FUNCTIONS
+                    .iter()
+                    .any(|func_path| match_function_call(self.cx, fn_expr, func_path).is_some());
+                if found_function {
+                    // These functions are all multi part suggestions
+                    self.suggestion_count += 2;
+                }
+            },
+            ExprKind::MethodCall(path, _path_span, arg, _arg_span) => {
+                let (self_ty, _) = walk_ptrs_ty_depth(self.cx.typeck_results().expr_ty(&arg[0]));
+                if match_type(self.cx, self_ty, &paths::DIAGNOSTIC_BUILDER) {
+                    let called_method = path.ident.name.as_str().to_string();
+                    let found_suggestion =
+                        SUGGESTION_DIAGNOSTIC_BUILDER_METHODS
+                            .iter()
+                            .find_map(|(method_name, is_multi_part)| {
+                                if *method_name == called_method {
+                                    Some(*is_multi_part)
+                                } else {
+                                    None
+                                }
+                            });
+                    if let Some(multi_part) = found_suggestion {
+                        if multi_part {
+                            // two is enough to have it marked as a multipart suggestion
+                            self.suggestion_count += 2;
+                        } else {
+                            self.suggestion_count += 1;
+                        }
+                    }
+                }
+            },
+            _ => {},
+        }
+
+        intravisit::walk_expr(self, expr);
+    }
+}
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index 46f58b788e6..a6292b87768 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -14,6 +14,8 @@ pub const APPLICABILITY_VALUES: [[&str; 3]; 4] = [
     ["rustc_lint_defs", "Applicability", "HasPlaceholders"],
     ["rustc_lint_defs", "Applicability", "Unspecified"],
 ];
+#[cfg(feature = "metadata-collector-lint")]
+pub const DIAGNOSTIC_BUILDER: [&str; 3] = ["rustc_errors", "diagnostic_builder", "DiagnosticBuilder"];
 pub const ARC_PTR_EQ: [&str; 4] = ["alloc", "sync", "Arc", "ptr_eq"];
 pub const ASMUT_TRAIT: [&str; 3] = ["core", "convert", "AsMut"];
 pub const ASREF_TRAIT: [&str; 3] = ["core", "convert", "AsRef"];
-- 
cgit 1.4.1-3-g733a5


From 2ce5e368d84887a5a2cee669b467160d4ad7b933 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Mon, 1 Mar 2021 12:25:14 +0100
Subject: Metadata collection: Refining the implementation

---
 .gitignore                                         |    2 +-
 clippy_lints/src/slow_vector_initialization.rs     |    2 +-
 .../src/utils/internal_lints/metadata_collector.rs |  280 +-
 metadata_collection.json                           | 5698 ++++++++++++++++++++
 4 files changed, 5809 insertions(+), 173 deletions(-)
 create mode 100644 metadata_collection.json

(limited to 'clippy_lints/src')

diff --git a/.gitignore b/.gitignore
index 523bab18828..565327a7f83 100644
--- a/.gitignore
+++ b/.gitignore
@@ -29,7 +29,7 @@ out
 
 # gh pages docs
 util/gh-pages/lints.json
-**/metadata_collection.json
+# **/metadata_collection.json
 
 # rustfmt backups
 *.rs.bk
diff --git a/clippy_lints/src/slow_vector_initialization.rs b/clippy_lints/src/slow_vector_initialization.rs
index 5a51e1141fb..a9ae2b77119 100644
--- a/clippy_lints/src/slow_vector_initialization.rs
+++ b/clippy_lints/src/slow_vector_initialization.rs
@@ -7,7 +7,7 @@ use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_block, walk_expr, walk_stmt, NestedVisitorMap, Visitor};
 use rustc_hir::{BindingAnnotation, Block, Expr, ExprKind, HirId, PatKind, QPath, Stmt, StmtKind};
-use rustc_lint::{LateContext, LateLintPass, Lint};
+use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::map::Map;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::symbol::sym;
diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index 20bd2a669aa..b2cc6372277 100644
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -33,7 +33,7 @@
 
 use if_chain::if_chain;
 use rustc_data_structures::fx::FxHashMap;
-use rustc_hir::{self as hir, intravisit, ExprKind, Item, ItemKind, Mutability, QPath};
+use rustc_hir::{self as hir, intravisit, intravisit::Visitor, ExprKind, Item, ItemKind, Mutability, QPath};
 use rustc_lint::{CheckLintNameResult, LateContext, LateLintPass, LintContext, LintId};
 use rustc_middle::hir::map::Map;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
@@ -52,19 +52,18 @@ use crate::utils::{
 const OUTPUT_FILE: &str = "metadata_collection.json";
 /// These lints are excluded from the export.
 const BLACK_LISTED_LINTS: [&str; 2] = ["lint_author", "deep_code_inspection"];
-/// These groups will be ignored by the lint group matcher
-const BLACK_LISTED_LINT_GROUP: [&str; 1] = ["clippy::all", "clippy::internal"];
+/// These groups will be ignored by the lint group matcher. This is useful for collections like
+/// `clippy::all`
+const IGNORED_LINT_GROUPS: [&str; 1] = ["clippy::all"];
+/// Lints within this group will be excluded from the collection
+const EXCLUDED_LINT_GROUPS: [&str; 1] = ["clippy::internal"];
 
-// TODO xFrednet 2021-02-15: `span_lint_and_then` & `span_lint_hir_and_then` requires special
-// handling
-const SIMPLE_LINT_EMISSION_FUNCTIONS: [&[&str]; 5] = [
+const LINT_EMISSION_FUNCTIONS: [&[&str]; 7] = [
     &["clippy_utils", "diagnostics", "span_lint"],
     &["clippy_utils", "diagnostics", "span_lint_and_help"],
     &["clippy_utils", "diagnostics", "span_lint_and_note"],
     &["clippy_utils", "diagnostics", "span_lint_hir"],
     &["clippy_utils", "diagnostics", "span_lint_and_sugg"],
-];
-const COMPLEX_LINT_EMISSION_FUNCTIONS: [&[&str]; 2] = [
     &["clippy_utils", "diagnostics", "span_lint_and_then"],
     &["clippy_utils", "diagnostics", "span_lint_hir_and_then"],
 ];
@@ -270,18 +269,11 @@ impl<'hir> LateLintPass<'hir> for MetadataCollector {
     /// );
     /// ```
     fn check_expr(&mut self, cx: &LateContext<'hir>, expr: &'hir hir::Expr<'_>) {
-        if let Some(args) = match_simple_lint_emission(cx, expr) {
-            if let Some((lint_name, applicability)) = extract_emission_info(cx, args) {
+        if let Some(args) = match_lint_emission(cx, expr) {
+            if let Some((lint_name, applicability, is_multi_part)) = extract_complex_emission_info(cx, args) {
                 let app_info = self.applicability_into.entry(lint_name).or_default();
                 app_info.applicability = applicability;
-            } else {
-                lint_collection_error_span(cx, expr.span, "I found this but I can't get the lint or applicability");
-            }
-        } else if let Some(args) = match_complex_lint_emission(cx, expr) {
-            if let Some((lint_name, applicability, is_multi_span)) = extract_complex_emission_info(cx, args) {
-                let app_info = self.applicability_into.entry(lint_name).or_default();
-                app_info.applicability = applicability;
-                app_info.is_multi_suggestion = is_multi_span;
+                app_info.is_multi_suggestion = is_multi_part;
             } else {
                 lint_collection_error_span(cx, expr.span, "Look, here ... I have no clue what todo with it");
             }
@@ -292,7 +284,6 @@ impl<'hir> LateLintPass<'hir> for MetadataCollector {
 // ==================================================================
 // Lint definition extraction
 // ==================================================================
-
 fn sym_to_string(sym: Symbol) -> String {
     sym.as_str().to_string()
 }
@@ -328,10 +319,12 @@ fn extract_attr_docs(item: &Item<'_>) -> Option<String> {
 fn get_lint_group_or_lint(cx: &LateContext<'_>, lint_name: &str, item: &'hir Item<'_>) -> Option<String> {
     let result = cx.lint_store.check_lint_name(lint_name, Some(sym::clippy));
     if let CheckLintNameResult::Tool(Ok(lint_lst)) = result {
-        get_lint_group(cx, lint_lst[0]).or_else(|| {
-            lint_collection_error_item(cx, item, "Unable to determine lint group");
-            None
-        })
+        get_lint_group(cx, lint_lst[0])
+            .or_else(|| {
+                lint_collection_error_item(cx, item, "Unable to determine lint group");
+                None
+            })
+            .filter(|group| !EXCLUDED_LINT_GROUPS.contains(&group.as_str()))
     } else {
         lint_collection_error_item(cx, item, "Unable to find lint in lint_store");
         None
@@ -340,7 +333,7 @@ fn get_lint_group_or_lint(cx: &LateContext<'_>, lint_name: &str, item: &'hir Ite
 
 fn get_lint_group(cx: &LateContext<'_>, lint_id: LintId) -> Option<String> {
     for (group_name, lints, _) in &cx.lint_store.get_lint_groups() {
-        if BLACK_LISTED_LINT_GROUP.contains(group_name) {
+        if IGNORED_LINT_GROUPS.contains(group_name) {
             continue;
         }
 
@@ -378,55 +371,19 @@ fn lint_collection_error_span(cx: &LateContext<'_>, span: Span, message: &str) {
 // ==================================================================
 /// This function checks if a given expression is equal to a simple lint emission function call.
 /// It will return the function arguments if the emission matched any function.
-fn match_simple_lint_emission<'hir>(
-    cx: &LateContext<'hir>,
-    expr: &'hir hir::Expr<'_>,
-) -> Option<&'hir [hir::Expr<'hir>]> {
-    SIMPLE_LINT_EMISSION_FUNCTIONS
-        .iter()
-        .find_map(|emission_fn| match_function_call(cx, expr, emission_fn))
-}
-
-fn match_complex_lint_emission<'hir>(
-    cx: &LateContext<'hir>,
-    expr: &'hir hir::Expr<'_>,
-) -> Option<&'hir [hir::Expr<'hir>]> {
-    COMPLEX_LINT_EMISSION_FUNCTIONS
+fn match_lint_emission<'hir>(cx: &LateContext<'hir>, expr: &'hir hir::Expr<'_>) -> Option<&'hir [hir::Expr<'hir>]> {
+    LINT_EMISSION_FUNCTIONS
         .iter()
         .find_map(|emission_fn| match_function_call(cx, expr, emission_fn))
 }
 
-/// This returns the lint name and the possible applicability of this emission
-fn extract_emission_info<'hir>(
-    cx: &LateContext<'hir>,
-    args: &'hir [hir::Expr<'hir>],
-) -> Option<(String, Option<String>)> {
-    let mut lint_name = None;
-    let mut applicability = None;
-
-    for arg in args {
-        let (arg_ty, _) = walk_ptrs_ty_depth(cx.typeck_results().expr_ty(&arg));
-
-        if match_type(cx, arg_ty, &paths::LINT) {
-            // If we found the lint arg, extract the lint name
-            if let ExprKind::Path(ref lint_path) = arg.kind {
-                lint_name = Some(last_path_segment(lint_path).ident.name);
-            }
-        } else if match_type(cx, arg_ty, &paths::APPLICABILITY) {
-            applicability = resolve_applicability(cx, arg);
-        }
-    }
-
-    lint_name.map(|lint_name| (sym_to_string(lint_name).to_ascii_lowercase(), applicability))
-}
-
 fn extract_complex_emission_info<'hir>(
     cx: &LateContext<'hir>,
     args: &'hir [hir::Expr<'hir>],
 ) -> Option<(String, Option<String>, bool)> {
     let mut lint_name = None;
     let mut applicability = None;
-    let mut multi_span = false;
+    let mut multi_part = false;
 
     for arg in args {
         let (arg_ty, _) = walk_ptrs_ty_depth(cx.typeck_results().expr_ty(&arg));
@@ -436,87 +393,47 @@ fn extract_complex_emission_info<'hir>(
             if let ExprKind::Path(ref lint_path) = arg.kind {
                 lint_name = Some(last_path_segment(lint_path).ident.name);
             }
+        } else if match_type(cx, arg_ty, &paths::APPLICABILITY) {
+            applicability = resolve_applicability(cx, arg);
         } else if arg_ty.is_closure() {
-            if let ExprKind::Closure(_, _, body_id, _, _) = arg.kind {
-                let mut visitor = EmissionClosureVisitor::new(cx);
-                intravisit::walk_body(&mut visitor, cx.tcx.hir().body(body_id));
-                multi_span = visitor.found_multi_span();
-                applicability = visitor.complete();
-            } else {
-                // TODO xfrednet 2021-02-28: linked closures, see: needless_pass_by_value.rs:292
-                return None;
-            }
+            multi_part |= check_is_multi_part(cx, arg);
+            // TODO xFrednet 2021-03-01: don't use or_else but rather a comparison
+            applicability = applicability.or_else(|| resolve_applicability(cx, arg));
         }
     }
 
-    lint_name.map(|lint_name| (sym_to_string(lint_name).to_ascii_lowercase(), applicability, multi_span))
+    lint_name.map(|lint_name| (sym_to_string(lint_name).to_ascii_lowercase(), applicability, multi_part))
 }
 
 /// This function tries to resolve the linked applicability to the given expression.
 fn resolve_applicability(cx: &LateContext<'hir>, expr: &'hir hir::Expr<'hir>) -> Option<String> {
-    match expr.kind {
-        // We can ignore ifs without an else block because those can't be used as an assignment
-        ExprKind::If(_con, if_block, Some(else_block)) => {
-            let mut visitor = ApplicabilityVisitor::new(cx);
-            intravisit::walk_expr(&mut visitor, if_block);
-            intravisit::walk_expr(&mut visitor, else_block);
-            visitor.complete()
-        },
-        ExprKind::Match(_expr, arms, _) => {
-            let mut visitor = ApplicabilityVisitor::new(cx);
-            arms.iter()
-                .for_each(|arm| intravisit::walk_expr(&mut visitor, arm.body));
-            visitor.complete()
-        },
-        ExprKind::Loop(block, ..) | ExprKind::Block(block, ..) => {
-            let mut visitor = ApplicabilityVisitor::new(cx);
-            intravisit::walk_block(&mut visitor, block);
-            visitor.complete()
-        },
-        ExprKind::Path(QPath::Resolved(_, path)) => {
-            // direct applicabilities are simple:
-            for enum_value in &paths::APPLICABILITY_VALUES {
-                if match_path(path, enum_value) {
-                    return Some(enum_value[APPLICABILITY_NAME_INDEX].to_string());
-                }
-            }
-
-            // Values yay
-            if let hir::def::Res::Local(local_hir) = path.res {
-                if let Some(local) = get_parent_local(cx, local_hir) {
-                    if let Some(local_init) = local.init {
-                        return resolve_applicability(cx, local_init);
-                    }
-                }
-            }
-
-            // This is true for paths that are linked to function parameters. They might be a bit more work so
-            // not today :)
-            None
-        },
-        _ => None,
-    }
+    let mut resolver = ApplicabilityResolver::new(cx);
+    resolver.visit_expr(expr);
+    resolver.complete()
 }
 
-fn get_parent_local(cx: &LateContext<'hir>, hir_id: hir::HirId) -> Option<&'hir hir::Local<'hir>> {
-    let map = cx.tcx.hir();
-
-    match map.find(map.get_parent_node(hir_id)) {
-        Some(hir::Node::Local(local)) => Some(local),
-        Some(hir::Node::Pat(pattern)) => get_parent_local(cx, pattern.hir_id),
-        _ => None,
+fn check_is_multi_part(cx: &LateContext<'hir>, closure_expr: &'hir hir::Expr<'hir>) -> bool {
+    if let ExprKind::Closure(_, _, body_id, _, _) = closure_expr.kind {
+        let mut scanner = IsMultiSpanScanner::new(cx);
+        intravisit::walk_body(&mut scanner, cx.tcx.hir().body(body_id));
+        return scanner.is_multi_part();
+    } else if let Some(local) = get_parent_local(cx, closure_expr) {
+        if let Some(local_init) = local.init {
+            return check_is_multi_part(cx, local_init);
+        }
     }
+
+    false
 }
 
 /// This visitor finds the highest applicability value in the visited expressions
-struct ApplicabilityVisitor<'a, 'hir> {
+struct ApplicabilityResolver<'a, 'hir> {
     cx: &'a LateContext<'hir>,
-    /// This is the index of hightest `Applicability` for
-    /// `clippy_utils::paths::APPLICABILITY_VALUES`
+    /// This is the index of hightest `Applicability` for `paths::APPLICABILITY_VALUES`
     applicability_index: Option<usize>,
 }
 
-impl<'a, 'hir> ApplicabilityVisitor<'a, 'hir> {
+impl<'a, 'hir> ApplicabilityResolver<'a, 'hir> {
     fn new(cx: &'a LateContext<'hir>) -> Self {
         Self {
             cx,
@@ -537,75 +454,104 @@ impl<'a, 'hir> ApplicabilityVisitor<'a, 'hir> {
     }
 }
 
-impl<'a, 'hir> intravisit::Visitor<'hir> for ApplicabilityVisitor<'a, 'hir> {
+impl<'a, 'hir> intravisit::Visitor<'hir> for ApplicabilityResolver<'a, 'hir> {
     type Map = Map<'hir>;
 
     fn nested_visit_map(&mut self) -> intravisit::NestedVisitorMap<Self::Map> {
         intravisit::NestedVisitorMap::All(self.cx.tcx.hir())
     }
 
-    fn visit_path(&mut self, path: &hir::Path<'_>, _id: hir::HirId) {
+    fn visit_path(&mut self, path: &'hir hir::Path<'hir>, _id: hir::HirId) {
         for (index, enum_value) in paths::APPLICABILITY_VALUES.iter().enumerate() {
             if match_path(path, enum_value) {
                 self.add_new_index(index);
-                break;
+                return;
+            }
+        }
+    }
+
+    fn visit_expr(&mut self, expr: &'hir hir::Expr<'hir>) {
+        let (expr_ty, _) = walk_ptrs_ty_depth(self.cx.typeck_results().expr_ty(&expr));
+
+        if_chain! {
+            if match_type(self.cx, expr_ty, &paths::APPLICABILITY);
+            if let Some(local) = get_parent_local(self.cx, expr);
+            if let Some(local_init) = local.init;
+            then {
+                intravisit::walk_expr(self, local_init);
             }
+        };
+
+        // TODO xFrednet 2021-03-01: support function arguments?
+
+        intravisit::walk_expr(self, expr);
+    }
+}
+
+/// This returns the parent local node if the expression is a reference to
+fn get_parent_local(cx: &LateContext<'hir>, expr: &'hir hir::Expr<'hir>) -> Option<&'hir hir::Local<'hir>> {
+    if let ExprKind::Path(QPath::Resolved(_, path)) = expr.kind {
+        if let hir::def::Res::Local(local_hir) = path.res {
+            return get_parent_local_hir_id(cx, local_hir);
         }
     }
+
+    None
+}
+
+fn get_parent_local_hir_id(cx: &LateContext<'hir>, hir_id: hir::HirId) -> Option<&'hir hir::Local<'hir>> {
+    let map = cx.tcx.hir();
+
+    match map.find(map.get_parent_node(hir_id)) {
+        Some(hir::Node::Local(local)) => Some(local),
+        Some(hir::Node::Pat(pattern)) => get_parent_local_hir_id(cx, pattern.hir_id),
+        _ => None,
+    }
 }
 
 /// This visitor finds the highest applicability value in the visited expressions
-struct EmissionClosureVisitor<'a, 'hir> {
+struct IsMultiSpanScanner<'a, 'hir> {
     cx: &'a LateContext<'hir>,
-    /// This is the index of hightest `Applicability` for
-    /// `clippy_utils::paths::APPLICABILITY_VALUES`
-    applicability_index: Option<usize>,
     suggestion_count: usize,
 }
 
-impl<'a, 'hir> EmissionClosureVisitor<'a, 'hir> {
+impl<'a, 'hir> IsMultiSpanScanner<'a, 'hir> {
     fn new(cx: &'a LateContext<'hir>) -> Self {
         Self {
             cx,
-            applicability_index: None,
             suggestion_count: 0,
         }
     }
 
-    fn add_new_index(&mut self, new_index: usize) {
-        self.applicability_index = self
-            .applicability_index
-            .map_or(new_index, |old_index| old_index.min(new_index))
-            .into();
+    /// Add a new single expression suggestion to the counter
+    fn add_singe_span_suggestion(&mut self) {
+        self.suggestion_count += 1;
     }
 
-    fn found_multi_span(&self) -> bool {
-        self.suggestion_count > 1
+    /// Signals that a suggestion with possible multiple spans was found
+    fn add_multi_part_suggestion(&mut self) {
+        self.suggestion_count += 2;
     }
 
-    fn complete(self) -> Option<String> {
-        self.applicability_index
-            .map(|index| paths::APPLICABILITY_VALUES[index][APPLICABILITY_NAME_INDEX].to_string())
+    /// Checks if the suggestions include multiple spanns
+    fn is_multi_part(&self) -> bool {
+        self.suggestion_count > 1
     }
 }
 
-impl<'a, 'hir> intravisit::Visitor<'hir> for EmissionClosureVisitor<'a, 'hir> {
+impl<'a, 'hir> intravisit::Visitor<'hir> for IsMultiSpanScanner<'a, 'hir> {
     type Map = Map<'hir>;
 
     fn nested_visit_map(&mut self) -> intravisit::NestedVisitorMap<Self::Map> {
         intravisit::NestedVisitorMap::All(self.cx.tcx.hir())
     }
 
-    fn visit_path(&mut self, path: &hir::Path<'_>, _id: hir::HirId) {
-        for (index, enum_value) in paths::APPLICABILITY_VALUES.iter().enumerate() {
-            if match_path(path, enum_value) {
-                self.add_new_index(index);
-                break;
-            }
+    fn visit_expr(&mut self, expr: &'hir hir::Expr<'hir>) {
+        // Early return if the lint is already multi span
+        if self.is_multi_part() {
+            return;
         }
-    }
 
-    fn visit_expr(&mut self, expr: &'hir hir::Expr<'hir>) {
         match &expr.kind {
             ExprKind::Call(fn_expr, _args) => {
                 let found_function = SUGGESTION_FUNCTIONS
@@ -613,29 +559,21 @@ impl<'a, 'hir> intravisit::Visitor<'hir> for EmissionClosureVisitor<'a, 'hir> {
                     .any(|func_path| match_function_call(self.cx, fn_expr, func_path).is_some());
                 if found_function {
                     // These functions are all multi part suggestions
-                    self.suggestion_count += 2;
+                    self.add_singe_span_suggestion()
                 }
             },
             ExprKind::MethodCall(path, _path_span, arg, _arg_span) => {
                 let (self_ty, _) = walk_ptrs_ty_depth(self.cx.typeck_results().expr_ty(&arg[0]));
                 if match_type(self.cx, self_ty, &paths::DIAGNOSTIC_BUILDER) {
                     let called_method = path.ident.name.as_str().to_string();
-                    let found_suggestion =
-                        SUGGESTION_DIAGNOSTIC_BUILDER_METHODS
-                            .iter()
-                            .find_map(|(method_name, is_multi_part)| {
-                                if *method_name == called_method {
-                                    Some(*is_multi_part)
-                                } else {
-                                    None
-                                }
-                            });
-                    if let Some(multi_part) = found_suggestion {
-                        if multi_part {
-                            // two is enough to have it marked as a multipart suggestion
-                            self.suggestion_count += 2;
-                        } else {
-                            self.suggestion_count += 1;
+                    for (method_name, is_multi_part) in &SUGGESTION_DIAGNOSTIC_BUILDER_METHODS {
+                        if *method_name == called_method {
+                            if *is_multi_part {
+                                self.add_multi_part_suggestion();
+                            } else {
+                                self.add_singe_span_suggestion();
+                            }
+                            break;
                         }
                     }
                 }
diff --git a/metadata_collection.json b/metadata_collection.json
new file mode 100644
index 00000000000..507752a782c
--- /dev/null
+++ b/metadata_collection.json
@@ -0,0 +1,5698 @@
+[
+  {
+    "id": "approx_constant",
+    "id_span": {
+      "path": "clippy_lints/src/approx_const.rs",
+      "line": 34
+    },
+    "group": "clippy::correctness",
+    "docs": " **What it does:** Checks for floating point literals that approximate constants which are defined in\n [`std::f32::consts`](https://doc.rust-lang.org/stable/std/f32/consts/#constants)\n or\n [`std::f64::consts`](https://doc.rust-lang.org/stable/std/f64/consts/#constants),\n respectively, suggesting to use the predefined constant.\n\n **Why is this bad?** Usually, the definition in the standard library is more\n precise than what people come up with. If you find that your definition is\n actually more precise, please [file a Rust\n issue](https://github.com/rust-lang/rust/issues).\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n let x = 3.14;\n let y = 1_f64 / x;\n ```\n Use predefined constants instead:\n ```rust\n let x = std::f32::consts::PI;\n let y = std::f64::consts::FRAC_1_PI;\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "integer_arithmetic",
+    "id_span": {
+      "path": "clippy_lints/src/arithmetic.rs",
+      "line": 28
+    },
+    "group": "clippy::restriction",
+    "docs": " **What it does:** Checks for integer arithmetic operations which could overflow or panic.\n Specifically, checks for any operators (`+`, `-`, `*`, `<<`, etc) which are capable\n of overflowing according to the [Rust\n Reference](https://doc.rust-lang.org/reference/expressions/operator-expr.html#overflow),\n or which can panic (`/`, `%`). No bounds analysis or sophisticated reasoning is\n attempted.\n\n **Why is this bad?** Integer overflow will trigger a panic in debug builds or will wrap in\n release mode. Division by zero will cause a panic in either mode. In some applications one\n wants explicitly checked, wrapping or saturating arithmetic.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # let a = 0;\n a + 1;\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "float_arithmetic",
+    "id_span": {
+      "path": "clippy_lints/src/arithmetic.rs",
+      "line": 46
+    },
+    "group": "clippy::restriction",
+    "docs": " **What it does:** Checks for float arithmetic.\n **Why is this bad?** For some embedded systems or kernel development, it\n can be useful to rule out floating-point numbers.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # let a = 0.0;\n a + 1.0;\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "as_conversions",
+    "id_span": {
+      "path": "clippy_lints/src/as_conversions.rs",
+      "line": 42
+    },
+    "group": "clippy::restriction",
+    "docs": " **What it does:** Checks for usage of `as` conversions.\n Note that this lint is specialized in linting *every single* use of `as`\n regardless of whether good alternatives exist or not.\n If you want more precise lints for `as`, please consider using these separate lints:\n `unnecessary_cast`, `cast_lossless/possible_truncation/possible_wrap/precision_loss/sign_loss`,\n `fn_to_numeric_cast(_with_truncation)`, `char_lit_as_u8`, `ref_to_mut` and `ptr_as_ptr`.\n There is a good explanation the reason why this lint should work in this way and how it is useful\n [in this issue](https://github.com/rust-lang/rust-clippy/issues/5122).\n\n **Why is this bad?** `as` conversions will perform many kinds of\n conversions, including silently lossy conversions and dangerous coercions.\n There are cases when it makes sense to use `as`, so the lint is\n Allow by default.\n\n **Known problems:** None.\n\n **Example:**\n ```rust,ignore\n let a: u32;\n ...\n f(a as u16);\n ```\n\n Usually better represents the semantics you expect:\n ```rust,ignore\n f(a.try_into()?);\n ```\n or\n ```rust,ignore\n f(a.try_into().expect(\"Unexpected u16 overflow in f\"));\n ```\n\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "inline_asm_x86_intel_syntax",
+    "id_span": {
+      "path": "clippy_lints/src/asm_syntax.rs",
+      "line": 78
+    },
+    "group": "clippy::restriction",
+    "docs": " **What it does:** Checks for usage of Intel x86 assembly syntax.\n **Why is this bad?** The lint has been enabled to indicate a preference\n for AT&T x86 assembly syntax.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust,no_run\n # #![feature(asm)]\n # unsafe { let ptr = \"\".as_ptr();\n asm!(\"lea {}, [{}]\", lateout(reg) _, in(reg) ptr);\n # }\n ```\n Use instead:\n ```rust,no_run\n # #![feature(asm)]\n # unsafe { let ptr = \"\".as_ptr();\n asm!(\"lea ({}), {}\", in(reg) ptr, lateout(reg) _, options(att_syntax));\n # }\n ```\n",
+    "applicability": null
+  },
+  {
+    "id": "inline_asm_x86_att_syntax",
+    "id_span": {
+      "path": "clippy_lints/src/asm_syntax.rs",
+      "line": 114
+    },
+    "group": "clippy::restriction",
+    "docs": " **What it does:** Checks for usage of AT&T x86 assembly syntax.\n **Why is this bad?** The lint has been enabled to indicate a preference\n for Intel x86 assembly syntax.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust,no_run\n # #![feature(asm)]\n # unsafe { let ptr = \"\".as_ptr();\n asm!(\"lea ({}), {}\", in(reg) ptr, lateout(reg) _, options(att_syntax));\n # }\n ```\n Use instead:\n ```rust,no_run\n # #![feature(asm)]\n # unsafe { let ptr = \"\".as_ptr();\n asm!(\"lea {}, [{}]\", lateout(reg) _, in(reg) ptr);\n # }\n ```\n",
+    "applicability": null
+  },
+  {
+    "id": "assertions_on_constants",
+    "id_span": {
+      "path": "clippy_lints/src/assertions_on_constants.rs",
+      "line": 23
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for `assert!(true)` and `assert!(false)` calls.\n **Why is this bad?** Will be optimized out by the compiler or should probably be replaced by a\n `panic!()` or `unreachable!()`\n\n **Known problems:** None\n\n **Example:**\n ```rust,ignore\n assert!(false)\n assert!(true)\n const B: bool = false;\n assert!(B)\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "assign_op_pattern",
+    "id_span": {
+      "path": "clippy_lints/src/assign_ops.rs",
+      "line": 33
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for `a = a op b` or `a = b commutative_op a` patterns.\n\n **Why is this bad?** These can be written as the shorter `a op= b`.\n\n **Known problems:** While forbidden by the spec, `OpAssign` traits may have\n implementations that differ from the regular `Op` impl.\n\n **Example:**\n ```rust\n let mut a = 5;\n let b = 0;\n // ...\n // Bad\n a = a + b;\n\n // Good\n a += b;\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "misrefactored_assign_op",
+    "id_span": {
+      "path": "clippy_lints/src/assign_ops.rs",
+      "line": 56
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks for `a op= a op b` or `a op= b op a` patterns.\n **Why is this bad?** Most likely these are bugs where one meant to write `a\n op= b`.\n\n **Known problems:** Clippy cannot know for sure if `a op= a op b` should have\n been `a = a op a op b` or `a = a op b`/`a op= b`. Therefore, it suggests both.\n If `a op= a op b` is really the correct behaviour it should be\n written as `a = a op a op b` as it's less confusing.\n\n **Example:**\n ```rust\n let mut a = 5;\n let b = 2;\n // ...\n a += a + b;\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": true,
+      "applicability": "MaybeIncorrect"
+    }
+  },
+  {
+    "id": "async_yields_async",
+    "id_span": {
+      "path": "clippy_lints/src/async_yields_async.rs",
+      "line": 36
+    },
+    "group": "clippy::correctness",
+    "docs": " **What it does:** Checks for async blocks that yield values of types that can themselves be awaited.\n\n **Why is this bad?** An await is likely missing.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n async fn foo() {}\n\n fn bar() {\n   let x = async {\n     foo()\n   };\n }\n ```\n Use instead:\n ```rust\n async fn foo() {}\n\n fn bar() {\n   let x = async {\n     foo().await\n   };\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MaybeIncorrect"
+    }
+  },
+  {
+    "id": "invalid_atomic_ordering",
+    "id_span": {
+      "path": "clippy_lints/src/atomic_ordering.rs",
+      "line": 47
+    },
+    "group": "clippy::correctness",
+    "docs": " **What it does:** Checks for usage of invalid atomic ordering in atomic loads/stores/exchanges/updates and\n memory fences.\n\n **Why is this bad?** Using an invalid atomic ordering\n will cause a panic at run-time.\n\n **Known problems:** None.\n\n **Example:**\n ```rust,no_run\n # use std::sync::atomic::{self, AtomicU8, Ordering};\n\n let x = AtomicU8::new(0);\n\n // Bad: `Release` and `AcqRel` cannot be used for `load`.\n let _ = x.load(Ordering::Release);\n let _ = x.load(Ordering::AcqRel);\n\n // Bad: `Acquire` and `AcqRel` cannot be used for `store`.\n x.store(1, Ordering::Acquire);\n x.store(2, Ordering::AcqRel);\n\n // Bad: `Relaxed` cannot be used as a fence's ordering.\n atomic::fence(Ordering::Relaxed);\n atomic::compiler_fence(Ordering::Relaxed);\n\n // Bad: `Release` and `AcqRel` are both always invalid\n // for the failure ordering (the last arg).\n let _ = x.compare_exchange(1, 2, Ordering::SeqCst, Ordering::Release);\n let _ = x.compare_exchange_weak(2, 3, Ordering::AcqRel, Ordering::AcqRel);\n\n // Bad: The failure ordering is not allowed to be\n // stronger than the success order, and `SeqCst` is\n // stronger than `Relaxed`.\n let _ = x.fetch_update(Ordering::Relaxed, Ordering::SeqCst, |val| Some(val + val));\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "inline_always",
+    "id_span": {
+      "path": "clippy_lints/src/attrs.rs",
+      "line": 65
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Checks for items annotated with `#[inline(always)]`, unless the annotated function is empty or simply panics.\n\n **Why is this bad?** While there are valid uses of this annotation (and once\n you know when to use it, by all means `allow` this lint), it's a common\n newbie-mistake to pepper one's code with it.\n\n As a rule of thumb, before slapping `#[inline(always)]` on a function,\n measure if that additional function call really affects your runtime profile\n sufficiently to make up for the increase in compile time.\n\n **Known problems:** False positives, big time. This lint is meant to be\n deactivated by everyone doing serious performance work. This means having\n done the measurement.\n\n **Example:**\n ```ignore\n #[inline(always)]\n fn not_quite_hot_code(..) { ... }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "useless_attribute",
+    "id_span": {
+      "path": "clippy_lints/src/attrs.rs",
+      "line": 99
+    },
+    "group": "clippy::correctness",
+    "docs": " **What it does:** Checks for `extern crate` and `use` items annotated with lint attributes.\n\n This lint permits `#[allow(unused_imports)]`, `#[allow(deprecated)]`,\n `#[allow(unreachable_pub)]`, `#[allow(clippy::wildcard_imports)]` and\n `#[allow(clippy::enum_glob_use)]` on `use` items and `#[allow(unused_imports)]` on\n `extern crate` items with a `#[macro_use]` attribute.\n\n **Why is this bad?** Lint attributes have no effect on crate imports. Most\n likely a `!` was forgotten.\n\n **Known problems:** None.\n\n **Example:**\n ```ignore\n // Bad\n #[deny(dead_code)]\n extern crate foo;\n #[forbid(dead_code)]\n use foo::bar;\n\n // Ok\n #[allow(unused_imports)]\n use foo::baz;\n #[allow(unused_imports)]\n #[macro_use]\n extern crate baz;\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MaybeIncorrect"
+    }
+  },
+  {
+    "id": "deprecated_semver",
+    "id_span": {
+      "path": "clippy_lints/src/attrs.rs",
+      "line": 118
+    },
+    "group": "clippy::correctness",
+    "docs": " **What it does:** Checks for `#[deprecated]` annotations with a `since` field that is not a valid semantic version.\n\n **Why is this bad?** For checking the version of the deprecation, it must be\n a valid semver. Failing that, the contained information is useless.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n #[deprecated(since = \"forever\")]\n fn something_else() { /* ... */ }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "empty_line_after_outer_attr",
+    "id_span": {
+      "path": "clippy_lints/src/attrs.rs",
+      "line": 153
+    },
+    "group": "clippy::nursery",
+    "docs": " **What it does:** Checks for empty lines after outer attributes\n **Why is this bad?**\n Most likely the attribute was meant to be an inner attribute using a '!'.\n If it was meant to be an outer attribute, then the following item\n should not be separated by empty lines.\n\n **Known problems:** Can cause false positives.\n\n From the clippy side it's difficult to detect empty lines between an attributes and the\n following item because empty lines and comments are not part of the AST. The parsing\n currently works for basic cases but is not perfect.\n\n **Example:**\n ```rust\n // Good (as inner attribute)\n #![allow(dead_code)]\n\n fn this_is_fine() { }\n\n // Bad\n #[allow(dead_code)]\n\n fn not_quite_good_code() { }\n\n // Good (as outer attribute)\n #[allow(dead_code)]\n fn this_is_fine_too() { }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "blanket_clippy_restriction_lints",
+    "id_span": {
+      "path": "clippy_lints/src/attrs.rs",
+      "line": 176
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for `warn`/`deny`/`forbid` attributes targeting the whole clippy::restriction category.\n **Why is this bad?** Restriction lints sometimes are in contrast with other lints or even go against idiomatic rust.\n These lints should only be enabled on a lint-by-lint basis and with careful consideration.\n\n **Known problems:** None.\n\n **Example:**\n Bad:\n ```rust\n #![deny(clippy::restriction)]\n ```\n\n Good:\n ```rust\n #![deny(clippy::as_conversions)]\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "deprecated_cfg_attr",
+    "id_span": {
+      "path": "clippy_lints/src/attrs.rs",
+      "line": 205
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks for `#[cfg_attr(rustfmt, rustfmt_skip)]` and suggests to replace it with `#[rustfmt::skip]`.\n\n **Why is this bad?** Since tool_attributes ([rust-lang/rust#44690](https://github.com/rust-lang/rust/issues/44690))\n are stable now, they should be used instead of the old `cfg_attr(rustfmt)` attributes.\n\n **Known problems:** This lint doesn't detect crate level inner attributes, because they get\n processed before the PreExpansionPass lints get executed. See\n [#3123](https://github.com/rust-lang/rust-clippy/pull/3123#issuecomment-422321765)\n\n **Example:**\n\n Bad:\n ```rust\n #[cfg_attr(rustfmt, rustfmt_skip)]\n fn main() { }\n ```\n\n Good:\n ```rust\n #[rustfmt::skip]\n fn main() { }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "mismatched_target_os",
+    "id_span": {
+      "path": "clippy_lints/src/attrs.rs",
+      "line": 238
+    },
+    "group": "clippy::correctness",
+    "docs": " **What it does:** Checks for cfg attributes having operating systems used in target family position.\n **Why is this bad?** The configuration option will not be recognised and the related item will not be included\n by the conditional compilation engine.\n\n **Known problems:** None.\n\n **Example:**\n\n Bad:\n ```rust\n #[cfg(linux)]\n fn conditional() { }\n ```\n\n Good:\n ```rust\n #[cfg(target_os = \"linux\")]\n fn conditional() { }\n ```\n\n Or:\n ```rust\n #[cfg(unix)]\n fn conditional() { }\n ```\n Check the [Rust Reference](https://doc.rust-lang.org/reference/conditional-compilation.html#target_os) for more details.\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MaybeIncorrect"
+    }
+  },
+  {
+    "id": "await_holding_lock",
+    "id_span": {
+      "path": "clippy_lints/src/await_holding_invalid.rs",
+      "line": 47
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Checks for calls to await while holding a non-async-aware MutexGuard.\n\n **Why is this bad?** The Mutex types found in std::sync and parking_lot\n are not designed to operate in an async context across await points.\n\n There are two potential solutions. One is to use an asynx-aware Mutex\n type. Many asynchronous foundation crates provide such a Mutex type. The\n other solution is to ensure the mutex is unlocked before calling await,\n either by introducing a scope or an explicit call to Drop::drop.\n\n **Known problems:** Will report false positive for explicitly dropped guards ([#6446](https://github.com/rust-lang/rust-clippy/issues/6446)).\n\n **Example:**\n\n ```rust,ignore\n use std::sync::Mutex;\n\n async fn foo(x: &Mutex<u32>) {\n   let guard = x.lock().unwrap();\n   *guard += 1;\n   bar.await;\n }\n ```\n\n Use instead:\n ```rust,ignore\n use std::sync::Mutex;\n\n async fn foo(x: &Mutex<u32>) {\n   {\n     let guard = x.lock().unwrap();\n     *guard += 1;\n   }\n   bar.await;\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "await_holding_refcell_ref",
+    "id_span": {
+      "path": "clippy_lints/src/await_holding_invalid.rs",
+      "line": 86
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Checks for calls to await while holding a `RefCell` `Ref` or `RefMut`.\n\n **Why is this bad?** `RefCell` refs only check for exclusive mutable access\n at runtime. Holding onto a `RefCell` ref across an `await` suspension point\n risks panics from a mutable ref shared while other refs are outstanding.\n\n **Known problems:** Will report false positive for explicitly dropped refs ([#6353](https://github.com/rust-lang/rust-clippy/issues/6353)).\n\n **Example:**\n\n ```rust,ignore\n use std::cell::RefCell;\n\n async fn foo(x: &RefCell<u32>) {\n   let mut y = x.borrow_mut();\n   *y += 1;\n   bar.await;\n }\n ```\n\n Use instead:\n ```rust,ignore\n use std::cell::RefCell;\n\n async fn foo(x: &RefCell<u32>) {\n   {\n      let mut y = x.borrow_mut();\n      *y += 1;\n   }\n   bar.await;\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "bad_bit_mask",
+    "id_span": {
+      "path": "clippy_lints/src/bit_mask.rs",
+      "line": 44
+    },
+    "group": "clippy::correctness",
+    "docs": " **What it does:** Checks for incompatible bit masks in comparisons.\n The formula for detecting if an expression of the type `_ <bit_op> m\n <cmp_op> c` (where `<bit_op>` is one of {`&`, `|`} and `<cmp_op>` is one of\n {`!=`, `>=`, `>`, `!=`, `>=`, `>`}) can be determined from the following\n table:\n\n |Comparison  |Bit Op|Example     |is always|Formula               |\n |------------|------|------------|---------|----------------------|\n |`==` or `!=`| `&`  |`x & 2 == 3`|`false`  |`c & m != c`          |\n |`<`  or `>=`| `&`  |`x & 2 < 3` |`true`   |`m < c`               |\n |`>`  or `<=`| `&`  |`x & 1 > 1` |`false`  |`m <= c`              |\n |`==` or `!=`| `|`  |`x | 1 == 0`|`false`  |`c | m != c`          |\n |`<`  or `>=`| `|`  |`x | 1 < 1` |`false`  |`m >= c`              |\n |`<=` or `>` | `|`  |`x | 1 > 0` |`true`   |`m > c`               |\n\n **Why is this bad?** If the bits that the comparison cares about are always\n set to zero or one by the bit mask, the comparison is constant `true` or\n `false` (depending on mask, compared value, and operators).\n\n So the code is actively misleading, and the only reason someone would write\n this intentionally is to win an underhanded Rust contest or create a\n test-case for this lint.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # let x = 1;\n if (x & 1 == 2) { }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "ineffective_bit_mask",
+    "id_span": {
+      "path": "clippy_lints/src/bit_mask.rs",
+      "line": 73
+    },
+    "group": "clippy::correctness",
+    "docs": " **What it does:** Checks for bit masks in comparisons which can be removed without changing the outcome. The basic structure can be seen in the\n following table:\n\n |Comparison| Bit Op  |Example    |equals |\n |----------|---------|-----------|-------|\n |`>` / `<=`|`|` / `^`|`x | 2 > 3`|`x > 3`|\n |`<` / `>=`|`|` / `^`|`x ^ 1 < 4`|`x < 4`|\n\n **Why is this bad?** Not equally evil as [`bad_bit_mask`](#bad_bit_mask),\n but still a bit misleading, because the bit mask is ineffective.\n\n **Known problems:** False negatives: This lint will only match instances\n where we have figured out the math (which is for a power-of-two compared\n value). This means things like `x | 1 >= 7` (which would be better written\n as `x >= 6`) will not be reported (but bit masks like this are fairly\n uncommon).\n\n **Example:**\n ```rust\n # let x = 1;\n if (x | 1 > 3) {  }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "verbose_bit_mask",
+    "id_span": {
+      "path": "clippy_lints/src/bit_mask.rs",
+      "line": 92
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Checks for bit masks that can be replaced by a call to `trailing_zeros`\n\n **Why is this bad?** `x.trailing_zeros() > 4` is much clearer than `x & 15\n == 0`\n\n **Known problems:** llvm generates better code for `x & 15 == 0` on x86\n\n **Example:**\n ```rust\n # let x = 1;\n if x & 0b1111 == 0 { }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MaybeIncorrect"
+    }
+  },
+  {
+    "id": "blacklisted_name",
+    "id_span": {
+      "path": "clippy_lints/src/blacklisted_name.rs",
+      "line": 20
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for usage of blacklisted names for variables, such as `foo`.\n\n **Why is this bad?** These names are usually placeholder names and should be\n avoided.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n let foo = 3.14;\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "blocks_in_if_conditions",
+    "id_span": {
+      "path": "clippy_lints/src/blocks_in_if_conditions.rs",
+      "line": 42
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for `if` conditions that use blocks containing an expression, statements or conditions that use closures with blocks.\n\n **Why is this bad?** Style, using blocks in the condition makes it hard to read.\n\n **Known problems:** None.\n\n **Examples:**\n ```rust\n // Bad\n if { true } { /* ... */ }\n\n // Good\n if true { /* ... */ }\n ```\n\n // or\n\n ```rust\n # fn somefunc() -> bool { true };\n // Bad\n if { let x = somefunc(); x } { /* ... */ }\n\n // Good\n let res = { let x = somefunc(); x };\n if res { /* ... */ }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "nonminimal_bool",
+    "id_span": {
+      "path": "clippy_lints/src/booleans.rs",
+      "line": 31
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks for boolean expressions that can be written more concisely.\n\n **Why is this bad?** Readability of boolean expressions suffers from\n unnecessary duplication.\n\n **Known problems:** Ignores short circuiting behavior of `||` and\n `&&`. Ignores `|`, `&` and `^`.\n\n **Example:**\n ```ignore\n if a && true  // should be: if a\n if !(a == b)  // should be: if a != b\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "logic_bug",
+    "id_span": {
+      "path": "clippy_lints/src/booleans.rs",
+      "line": 49
+    },
+    "group": "clippy::correctness",
+    "docs": " **What it does:** Checks for boolean expressions that contain terminals that can be eliminated.\n\n **Why is this bad?** This is most likely a logic bug.\n\n **Known problems:** Ignores short circuiting behavior.\n\n **Example:**\n ```ignore\n if a && b || a { ... }\n ```\n The `b` is unnecessary, the expression is equivalent to `if a`.\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "Unspecified"
+    }
+  },
+  {
+    "id": "naive_bytecount",
+    "id_span": {
+      "path": "clippy_lints/src/bytecount.rs",
+      "line": 30
+    },
+    "group": "clippy::perf",
+    "docs": " **What it does:** Checks for naive byte counts\n **Why is this bad?** The [`bytecount`](https://crates.io/crates/bytecount)\n crate has methods to count your bytes faster, especially for large slices.\n\n **Known problems:** If you have predominantly small slices, the\n `bytecount::count(..)` method may actually be slower. However, if you can\n ensure that less than 2³²-1 matches arise, the `naive_count_32(..)` can be\n faster in those cases.\n\n **Example:**\n\n ```rust\n # let vec = vec![1_u8];\n &vec.iter().filter(|x| **x == 0u8).count(); // use bytecount::count instead\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MaybeIncorrect"
+    }
+  },
+  {
+    "id": "cargo_common_metadata",
+    "id_span": {
+      "path": "clippy_lints/src/cargo_common_metadata.rs",
+      "line": 49
+    },
+    "group": "clippy::cargo",
+    "docs": " **What it does:** Checks to see if all common metadata is defined in `Cargo.toml`. See: https://rust-lang-nursery.github.io/api-guidelines/documentation.html#cargotoml-includes-all-common-metadata-c-metadata\n\n **Why is this bad?** It will be more difficult for users to discover the\n purpose of the crate, and key information related to it.\n\n **Known problems:** None.\n\n **Example:**\n ```toml\n # This `Cargo.toml` is missing an authors field:\n [package]\n name = \"clippy\"\n version = \"0.0.212\"\n description = \"A bunch of helpful lints to avoid common pitfalls in Rust\"\n repository = \"https://github.com/rust-lang/rust-clippy\"\n readme = \"README.md\"\n license = \"MIT OR Apache-2.0\"\n keywords = [\"clippy\", \"lint\", \"plugin\"]\n categories = [\"development-tools\", \"development-tools::cargo-plugins\"]\n ```\n\n Should include an authors field like:\n\n ```toml\n # This `Cargo.toml` includes all common metadata\n [package]\n name = \"clippy\"\n version = \"0.0.212\"\n authors = [\"Someone <someone@rust-lang.org>\"]\n description = \"A bunch of helpful lints to avoid common pitfalls in Rust\"\n repository = \"https://github.com/rust-lang/rust-clippy\"\n readme = \"README.md\"\n license = \"MIT OR Apache-2.0\"\n keywords = [\"clippy\", \"lint\", \"plugin\"]\n categories = [\"development-tools\", \"development-tools::cargo-plugins\"]\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "case_sensitive_file_extension_comparisons",
+    "id_span": {
+      "path": "clippy_lints/src/case_sensitive_file_extension_comparisons.rs",
+      "line": 34
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Checks for calls to `ends_with` with possible file extensions\n and suggests to use a case-insensitive approach instead.\n\n **Why is this bad?**\n `ends_with` is case-sensitive and may not detect files with a valid extension.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n fn is_rust_file(filename: &str) -> bool {\n     filename.ends_with(\".rs\")\n }\n ```\n Use instead:\n ```rust\n fn is_rust_file(filename: &str) -> bool {\n     filename.rsplit('.').next().map(|ext| ext.eq_ignore_ascii_case(\"rs\")) == Some(true)\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "checked_conversions",
+    "id_span": {
+      "path": "clippy_lints/src/checked_conversions.rs",
+      "line": 40
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Checks for explicit bounds checking when casting.\n **Why is this bad?** Reduces the readability of statements & is error prone.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # let foo: u32 = 5;\n # let _ =\n foo <= i32::MAX as u32\n # ;\n ```\n\n Could be written:\n\n ```rust\n # use std::convert::TryFrom;\n # let foo = 1;\n # let _ =\n i32::try_from(foo).is_ok()\n # ;\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "cognitive_complexity",
+    "id_span": {
+      "path": "clippy_lints/src/cognitive_complexity.rs",
+      "line": 24
+    },
+    "group": "clippy::nursery",
+    "docs": " **What it does:** Checks for methods with high cognitive complexity.\n **Why is this bad?** Methods of high cognitive complexity tend to be hard to\n both read and maintain. Also LLVM will tend to optimize small methods better.\n\n **Known problems:** Sometimes it's hard to find a way to reduce the\n complexity.\n\n **Example:** No. You'll see it when you get the warning.\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "collapsible_if",
+    "id_span": {
+      "path": "clippy_lints/src/collapsible_if.rs",
+      "line": 50
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for nested `if` statements which can be collapsed by `&&`-combining their conditions.\n\n **Why is this bad?** Each `if`-statement adds one level of nesting, which\n makes code look more complex than it really is.\n\n **Known problems:** None.\n\n **Example:**\n ```rust,ignore\n if x {\n     if y {\n         …\n     }\n }\n\n ```\n\n Should be written:\n\n ```rust.ignore\n if x && y {\n     …\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "collapsible_else_if",
+    "id_span": {
+      "path": "clippy_lints/src/collapsible_if.rs",
+      "line": 85
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for collapsible `else { if ... }` expressions that can be collapsed to `else if ...`.\n\n **Why is this bad?** Each `if`-statement adds one level of nesting, which\n makes code look more complex than it really is.\n\n **Known problems:** None.\n\n **Example:**\n ```rust,ignore\n\n if x {\n     …\n } else {\n     if y {\n         …\n     }\n }\n ```\n\n Should be written:\n\n ```rust.ignore\n if x {\n     …\n } else if y {\n     …\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "collapsible_match",
+    "id_span": {
+      "path": "clippy_lints/src/collapsible_match.rs",
+      "line": 44
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Finds nested `match` or `if let` expressions where the patterns may be \"collapsed\" together without adding any branches.\n\n Note that this lint is not intended to find _all_ cases where nested match patterns can be merged, but only\n cases where merging would most likely make the code more readable.\n\n **Why is this bad?** It is unnecessarily verbose and complex.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n fn func(opt: Option<Result<u64, String>>) {\n     let n = match opt {\n         Some(n) => match n {\n             Ok(n) => n,\n             _ => return,\n         }\n         None => return,\n     };\n }\n ```\n Use instead:\n ```rust\n fn func(opt: Option<Result<u64, String>>) {\n     let n = match opt {\n         Some(Ok(n)) => n,\n         _ => return,\n     };\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "comparison_chain",
+    "id_span": {
+      "path": "clippy_lints/src/comparison_chain.rs",
+      "line": 49
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks comparison chains written with `if` that can be rewritten with `match` and `cmp`.\n\n **Why is this bad?** `if` is not guaranteed to be exhaustive and conditionals can get\n repetitive\n\n **Known problems:** The match statement may be slower due to the compiler\n not inlining the call to cmp. See issue [#5354](https://github.com/rust-lang/rust-clippy/issues/5354)\n\n **Example:**\n ```rust,ignore\n # fn a() {}\n # fn b() {}\n # fn c() {}\n fn f(x: u8, y: u8) {\n     if x > y {\n         a()\n     } else if x < y {\n         b()\n     } else {\n         c()\n     }\n }\n ```\n\n Could be written:\n\n ```rust,ignore\n use std::cmp::Ordering;\n # fn a() {}\n # fn b() {}\n # fn c() {}\n fn f(x: u8, y: u8) {\n      match x.cmp(&y) {\n          Ordering::Greater => a(),\n          Ordering::Less => b(),\n          Ordering::Equal => c()\n      }\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "ifs_same_cond",
+    "id_span": {
+      "path": "clippy_lints/src/copies.rs",
+      "line": 33
+    },
+    "group": "clippy::correctness",
+    "docs": " **What it does:** Checks for consecutive `if`s with the same condition.\n **Why is this bad?** This is probably a copy & paste error.\n\n **Known problems:** Hopefully none.\n\n **Example:**\n ```ignore\n if a == b {\n     …\n } else if a == b {\n     …\n }\n ```\n\n Note that this lint ignores all conditions with a function call as it could\n have side effects:\n\n ```ignore\n if foo() {\n     …\n } else if foo() { // not linted\n     …\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "same_functions_in_if_condition",
+    "id_span": {
+      "path": "clippy_lints/src/copies.rs",
+      "line": 80
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Checks for consecutive `if`s with the same function call.\n **Why is this bad?** This is probably a copy & paste error.\n Despite the fact that function can have side effects and `if` works as\n intended, such an approach is implicit and can be considered a \"code smell\".\n\n **Known problems:** Hopefully none.\n\n **Example:**\n ```ignore\n if foo() == bar {\n     …\n } else if foo() == bar {\n     …\n }\n ```\n\n This probably should be:\n ```ignore\n if foo() == bar {\n     …\n } else if foo() == baz {\n     …\n }\n ```\n\n or if the original code was not a typo and called function mutates a state,\n consider move the mutation out of the `if` condition to avoid similarity to\n a copy & paste error:\n\n ```ignore\n let first = foo();\n if first == bar {\n     …\n } else {\n     let second = foo();\n     if second == bar {\n     …\n     }\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "if_same_then_else",
+    "id_span": {
+      "path": "clippy_lints/src/copies.rs",
+      "line": 101
+    },
+    "group": "clippy::correctness",
+    "docs": " **What it does:** Checks for `if/else` with the same body as the *then* part and the *else* part.\n\n **Why is this bad?** This is probably a copy & paste error.\n\n **Known problems:** Hopefully none.\n\n **Example:**\n ```ignore\n let foo = if … {\n     42\n } else {\n     42\n };\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "copy_iterator",
+    "id_span": {
+      "path": "clippy_lints/src/copy_iterator.rs",
+      "line": 27
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Checks for types that implement `Copy` as well as `Iterator`.\n\n **Why is this bad?** Implicit copies can be confusing when working with\n iterator combinators.\n\n **Known problems:** None.\n\n **Example:**\n ```rust,ignore\n #[derive(Copy, Clone)]\n struct Countdown(u8);\n\n impl Iterator for Countdown {\n     // ...\n }\n\n let a: Vec<_> = my_iterator.take(1).collect();\n let b: Vec<_> = my_iterator.collect();\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "create_dir",
+    "id_span": {
+      "path": "clippy_lints/src/create_dir.rs",
+      "line": 24
+    },
+    "group": "clippy::restriction",
+    "docs": " **What it does:** Checks usage of `std::fs::create_dir` and suggest using `std::fs::create_dir_all` instead.\n **Why is this bad?** Sometimes `std::fs::create_dir` is mistakenly chosen over `std::fs::create_dir_all`.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n std::fs::create_dir(\"foo\");\n ```\n Use instead:\n ```rust\n std::fs::create_dir_all(\"foo\");\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MaybeIncorrect"
+    }
+  },
+  {
+    "id": "dbg_macro",
+    "id_span": {
+      "path": "clippy_lints/src/dbg_macro.rs",
+      "line": 25
+    },
+    "group": "clippy::restriction",
+    "docs": " **What it does:** Checks for usage of dbg!() macro.\n **Why is this bad?** `dbg!` macro is intended as a debugging tool. It\n should not be in version control.\n\n **Known problems:** None.\n\n **Example:**\n ```rust,ignore\n // Bad\n dbg!(true)\n\n // Good\n true\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "default_trait_access",
+    "id_span": {
+      "path": "clippy_lints/src/default.rs",
+      "line": 33
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Checks for literal calls to `Default::default()`.\n **Why is this bad?** It's more clear to the reader to use the name of the type whose default is\n being gotten than the generic `Default`.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n // Bad\n let s: String = Default::default();\n\n // Good\n let s = String::default();\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "Unspecified"
+    }
+  },
+  {
+    "id": "field_reassign_with_default",
+    "id_span": {
+      "path": "clippy_lints/src/default.rs",
+      "line": 63
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for immediate reassignment of fields initialized with Default::default().\n\n **Why is this bad?**It's more idiomatic to use the [functional update syntax](https://doc.rust-lang.org/reference/expressions/struct-expr.html#functional-update-syntax).\n\n **Known problems:** Assignments to patterns that are of tuple type are not linted.\n\n **Example:**\n Bad:\n ```\n # #[derive(Default)]\n # struct A { i: i32 }\n let mut a: A = Default::default();\n a.i = 42;\n ```\n Use instead:\n ```\n # #[derive(Default)]\n # struct A { i: i32 }\n let a = A {\n     i: 42,\n     .. Default::default()\n };\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "default_numeric_fallback",
+    "id_span": {
+      "path": "clippy_lints/src/default_numeric_fallback.rs",
+      "line": 44
+    },
+    "group": "clippy::restriction",
+    "docs": " **What it does:** Checks for usage of unconstrained numeric literals which may cause default numeric fallback in type inference.\n\n Default numeric fallback means that if numeric types have not yet been bound to concrete\n types at the end of type inference, then integer type is bound to `i32`, and similarly\n floating type is bound to `f64`.\n\n See [RFC0212](https://github.com/rust-lang/rfcs/blob/master/text/0212-restore-int-fallback.md) for more information about the fallback.\n\n **Why is this bad?** For those who are very careful about types, default numeric fallback\n can be a pitfall that cause unexpected runtime behavior.\n\n **Known problems:** This lint can only be allowed at the function level or above.\n\n **Example:**\n ```rust\n let i = 10;\n let f = 1.23;\n ```\n\n Use instead:\n ```rust\n let i = 10i32;\n let f = 1.23f64;\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MaybeIncorrect"
+    }
+  },
+  {
+    "id": "explicit_deref_methods",
+    "id_span": {
+      "path": "clippy_lints/src/dereference.rs",
+      "line": 32
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Checks for explicit `deref()` or `deref_mut()` method calls.\n **Why is this bad?** Dereferencing by `&*x` or `&mut *x` is clearer and more concise,\n when not part of a method chain.\n\n **Example:**\n ```rust\n use std::ops::Deref;\n let a: &mut String = &mut String::from(\"foo\");\n let b: &str = a.deref();\n ```\n Could be written as:\n ```rust\n let a: &mut String = &mut String::from(\"foo\");\n let b = &*a;\n ```\n\n This lint excludes\n ```rust,ignore\n let _ = d.unwrap().deref();\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "derive_hash_xor_eq",
+    "id_span": {
+      "path": "clippy_lints/src/derive.rs",
+      "line": 42
+    },
+    "group": "clippy::correctness",
+    "docs": " **What it does:** Checks for deriving `Hash` but implementing `PartialEq` explicitly or vice versa.\n\n **Why is this bad?** The implementation of these traits must agree (for\n example for use with `HashMap`) so it’s probably a bad idea to use a\n default-generated `Hash` implementation with an explicitly defined\n `PartialEq`. In particular, the following must hold for any type:\n\n ```text\n k1 == k2 ⇒ hash(k1) == hash(k2)\n ```\n\n **Known problems:** None.\n\n **Example:**\n ```ignore\n #[derive(Hash)]\n struct Foo;\n\n impl PartialEq for Foo {\n     ...\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "derive_ord_xor_partial_ord",
+    "id_span": {
+      "path": "clippy_lints/src/derive.rs",
+      "line": 93
+    },
+    "group": "clippy::correctness",
+    "docs": " **What it does:** Checks for deriving `Ord` but implementing `PartialOrd` explicitly or vice versa.\n\n **Why is this bad?** The implementation of these traits must agree (for\n example for use with `sort`) so it’s probably a bad idea to use a\n default-generated `Ord` implementation with an explicitly defined\n `PartialOrd`. In particular, the following must hold for any type\n implementing `Ord`:\n\n ```text\n k1.cmp(&k2) == k1.partial_cmp(&k2).unwrap()\n ```\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust,ignore\n #[derive(Ord, PartialEq, Eq)]\n struct Foo;\n\n impl PartialOrd for Foo {\n     ...\n }\n ```\n Use instead:\n ```rust,ignore\n #[derive(PartialEq, Eq)]\n struct Foo;\n\n impl PartialOrd for Foo {\n     fn partial_cmp(&self, other: &Foo) -> Option<Ordering> {\n        Some(self.cmp(other))\n     }\n }\n\n impl Ord for Foo {\n     ...\n }\n ```\n or, if you don't need a custom ordering:\n ```rust,ignore\n #[derive(Ord, PartialOrd, PartialEq, Eq)]\n struct Foo;\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "expl_impl_clone_on_copy",
+    "id_span": {
+      "path": "clippy_lints/src/derive.rs",
+      "line": 119
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Checks for explicit `Clone` implementations for `Copy` types.\n\n **Why is this bad?** To avoid surprising behaviour, these traits should\n agree and the behaviour of `Copy` cannot be overridden. In almost all\n situations a `Copy` type should have a `Clone` implementation that does\n nothing more than copy the object, which is what `#[derive(Copy, Clone)]`\n gets you.\n\n **Known problems:** Bounds of generic types are sometimes wrong: https://github.com/rust-lang/rust/issues/26925\n\n **Example:**\n ```rust,ignore\n #[derive(Copy)]\n struct Foo;\n\n impl Clone for Foo {\n     // ..\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "unsafe_derive_deserialize",
+    "id_span": {
+      "path": "clippy_lints/src/derive.rs",
+      "line": 153
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Checks for deriving `serde::Deserialize` on a type that has methods using `unsafe`.\n\n **Why is this bad?** Deriving `serde::Deserialize` will create a constructor\n that may violate invariants hold by another constructor.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust,ignore\n use serde::Deserialize;\n\n #[derive(Deserialize)]\n pub struct Foo {\n     // ..\n }\n\n impl Foo {\n     pub fn new() -> Self {\n         // setup here ..\n     }\n\n     pub unsafe fn parts() -> (&str, &str) {\n         // assumes invariants hold\n     }\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "disallowed_method",
+    "id_span": {
+      "path": "clippy_lints/src/disallowed_method.rs",
+      "line": 46
+    },
+    "group": "clippy::nursery",
+    "docs": " **What it does:** Denies the configured methods and functions in clippy.toml\n **Why is this bad?** Some methods are undesirable in certain contexts,\n and it's beneficial to lint for them as needed.\n\n **Known problems:** Currently, you must write each function as a\n fully-qualified path. This lint doesn't support aliases or reexported\n names; be aware that many types in `std` are actually reexports.\n\n For example, if you want to disallow `Duration::as_secs`, your clippy.toml\n configuration would look like\n `disallowed-methods = [\"core::time::Duration::as_secs\"]` and not\n `disallowed-methods = [\"std::time::Duration::as_secs\"]` as you might expect.\n\n **Example:**\n\n An example clippy.toml configuration:\n ```toml\n # clippy.toml\n disallowed-methods = [\"alloc::vec::Vec::leak\", \"std::time::Instant::now\"]\n ```\n\n ```rust,ignore\n // Example code where clippy issues a warning\n let xs = vec![1, 2, 3, 4];\n xs.leak(); // Vec::leak is disallowed in the config.\n\n let _now = Instant::now(); // Instant::now is disallowed in the config.\n ```\n\n Use instead:\n ```rust,ignore\n // Example code which does not raise clippy warning\n let mut xs = Vec::new(); // Vec::new is _not_ disallowed in the config.\n xs.push(123); // Vec::push is _not_ disallowed in the config.\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "doc_markdown",
+    "id_span": {
+      "path": "clippy_lints/src/doc.rs",
+      "line": 63
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Checks for the presence of `_`, `::` or camel-case words outside ticks in documentation.\n\n **Why is this bad?** *Rustdoc* supports markdown formatting, `_`, `::` and\n camel-case probably indicates some code which should be included between\n ticks. `_` can also be used for emphasis in markdown, this lint tries to\n consider that.\n\n **Known problems:** Lots of bad docs won’t be fixed, what the lint checks\n for is limited, and there are still false positives.\n\n In addition, when writing documentation comments, including `[]` brackets\n inside a link text would trip the parser. Therfore, documenting link with\n `[`SmallVec<[T; INLINE_CAPACITY]>`]` and then [`SmallVec<[T; INLINE_CAPACITY]>`]: SmallVec\n would fail.\n\n **Examples:**\n ```rust\n /// Do something with the foo_bar parameter. See also\n /// that::other::module::foo.\n // ^ `foo_bar` and `that::other::module::foo` should be ticked.\n fn doit(foo_bar: usize) {}\n ```\n\n ```rust\n // Link text with `[]` brackets should be written as following:\n /// Consume the array and return the inner\n /// [`SmallVec<[T; INLINE_CAPACITY]>`][SmallVec].\n /// [SmallVec]: SmallVec\n fn main() {}\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "missing_safety_doc",
+    "id_span": {
+      "path": "clippy_lints/src/doc.rs",
+      "line": 97
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for the doc comments of publicly visible unsafe functions and warns if there is no `# Safety` section.\n\n **Why is this bad?** Unsafe functions should document their safety\n preconditions, so that users can be sure they are using them safely.\n\n **Known problems:** None.\n\n **Examples:**\n ```rust\n# type Universe = ();\n /// This function should really be documented\n pub unsafe fn start_apocalypse(u: &mut Universe) {\n     unimplemented!();\n }\n ```\n\n At least write a line about safety:\n\n ```rust\n# type Universe = ();\n /// # Safety\n ///\n /// This function should not be called before the horsemen are ready.\n pub unsafe fn start_apocalypse(u: &mut Universe) {\n     unimplemented!();\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "missing_errors_doc",
+    "id_span": {
+      "path": "clippy_lints/src/doc.rs",
+      "line": 126
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Checks the doc comments of publicly visible functions that return a `Result` type and warns if there is no `# Errors` section.\n\n **Why is this bad?** Documenting the type of errors that can be returned from a\n function can help callers write code to handle the errors appropriately.\n\n **Known problems:** None.\n\n **Examples:**\n\n Since the following function returns a `Result` it has an `# Errors` section in\n its doc comment:\n\n ```rust\n# use std::io;\n /// # Errors\n ///\n /// Will return `Err` if `filename` does not exist or the user does not have\n /// permission to read it.\n pub fn read(filename: String) -> io::Result<String> {\n     unimplemented!();\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "missing_panics_doc",
+    "id_span": {
+      "path": "clippy_lints/src/doc.rs",
+      "line": 157
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Checks the doc comments of publicly visible functions that may panic and warns if there is no `# Panics` section.\n\n **Why is this bad?** Documenting the scenarios in which panicking occurs\n can help callers who do not want to panic to avoid those situations.\n\n **Known problems:** None.\n\n **Examples:**\n\n Since the following function may panic it has a `# Panics` section in\n its doc comment:\n\n ```rust\n /// # Panics\n ///\n /// Will panic if y is 0\n pub fn divide_by(x: i32, y: i32) -> i32 {\n     if y == 0 {\n         panic!(\"Cannot divide by 0\")\n     } else {\n         x / y\n     }\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "needless_doctest_main",
+    "id_span": {
+      "path": "clippy_lints/src/doc.rs",
+      "line": 185
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for `fn main() { .. }` in doctests\n **Why is this bad?** The test can be shorter (and likely more readable)\n if the `fn main()` is left implicit.\n\n **Known problems:** None.\n\n **Examples:**\n ``````rust\n /// An example of a doctest with a `main()` function\n ///\n /// # Examples\n ///\n /// ```\n /// fn main() {\n ///     // this needs not be in an `fn`\n /// }\n /// ```\n fn needless_main() {\n     unimplemented!();\n }\n ``````\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "double_comparisons",
+    "id_span": {
+      "path": "clippy_lints/src/double_comparison.rs",
+      "line": 33
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks for double comparisons that could be simplified to a single expression.\n\n **Why is this bad?** Readability.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # let x = 1;\n # let y = 2;\n if x == y || x < y {}\n ```\n\n Could be written as:\n\n ```rust\n # let x = 1;\n # let y = 2;\n if x <= y {}\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "double_parens",
+    "id_span": {
+      "path": "clippy_lints/src/double_parens.rs",
+      "line": 35
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks for unnecessary double parentheses.\n **Why is this bad?** This makes code harder to read and might indicate a\n mistake.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n // Bad\n fn simple_double_parens() -> i32 {\n     ((0))\n }\n\n // Good\n fn simple_no_parens() -> i32 {\n     0\n }\n\n // or\n\n # fn foo(bar: usize) {}\n // Bad\n foo((0));\n\n // Good\n foo(0);\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "drop_ref",
+    "id_span": {
+      "path": "clippy_lints/src/drop_forget_ref.rs",
+      "line": 26
+    },
+    "group": "clippy::correctness",
+    "docs": " **What it does:** Checks for calls to `std::mem::drop` with a reference instead of an owned value.\n\n **Why is this bad?** Calling `drop` on a reference will only drop the\n reference itself, which is a no-op. It will not call the `drop` method (from\n the `Drop` trait implementation) on the underlying referenced value, which\n is likely what was intended.\n\n **Known problems:** None.\n\n **Example:**\n ```ignore\n let mut lock_guard = mutex.lock();\n std::mem::drop(&lock_guard) // Should have been drop(lock_guard), mutex\n // still locked\n operation_that_requires_mutex_to_be_unlocked();\n ```\n",
+    "applicability": null
+  },
+  {
+    "id": "forget_ref",
+    "id_span": {
+      "path": "clippy_lints/src/drop_forget_ref.rs",
+      "line": 47
+    },
+    "group": "clippy::correctness",
+    "docs": " **What it does:** Checks for calls to `std::mem::forget` with a reference instead of an owned value.\n\n **Why is this bad?** Calling `forget` on a reference will only forget the\n reference itself, which is a no-op. It will not forget the underlying\n referenced\n value, which is likely what was intended.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n let x = Box::new(1);\n std::mem::forget(&x) // Should have been forget(x), x will still be dropped\n ```\n",
+    "applicability": null
+  },
+  {
+    "id": "drop_copy",
+    "id_span": {
+      "path": "clippy_lints/src/drop_forget_ref.rs",
+      "line": 68
+    },
+    "group": "clippy::correctness",
+    "docs": " **What it does:** Checks for calls to `std::mem::drop` with a value that derives the Copy trait\n\n **Why is this bad?** Calling `std::mem::drop` [does nothing for types that\n implement Copy](https://doc.rust-lang.org/std/mem/fn.drop.html), since the\n value will be copied and moved into the function on invocation.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n let x: i32 = 42; // i32 implements Copy\n std::mem::drop(x) // A copy of x is passed to the function, leaving the\n                   // original unaffected\n ```\n",
+    "applicability": null
+  },
+  {
+    "id": "forget_copy",
+    "id_span": {
+      "path": "clippy_lints/src/drop_forget_ref.rs",
+      "line": 95
+    },
+    "group": "clippy::correctness",
+    "docs": " **What it does:** Checks for calls to `std::mem::forget` with a value that derives the Copy trait\n\n **Why is this bad?** Calling `std::mem::forget` [does nothing for types that\n implement Copy](https://doc.rust-lang.org/std/mem/fn.drop.html) since the\n value will be copied and moved into the function on invocation.\n\n An alternative, but also valid, explanation is that Copy types do not\n implement\n the Drop trait, which means they have no destructors. Without a destructor,\n there\n is nothing for `std::mem::forget` to ignore.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n let x: i32 = 42; // i32 implements Copy\n std::mem::forget(x) // A copy of x is passed to the function, leaving the\n                     // original unaffected\n ```\n",
+    "applicability": null
+  },
+  {
+    "id": "duration_subsec",
+    "id_span": {
+      "path": "clippy_lints/src/duration_subsec.rs",
+      "line": 34
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks for calculation of subsecond microseconds or milliseconds from other `Duration` methods.\n\n **Why is this bad?** It's more concise to call `Duration::subsec_micros()` or\n `Duration::subsec_millis()` than to calculate them.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # use std::time::Duration;\n let dur = Duration::new(5, 0);\n\n // Bad\n let _micros = dur.subsec_nanos() / 1_000;\n let _millis = dur.subsec_nanos() / 1_000_000;\n\n // Good\n let _micros = dur.subsec_micros();\n let _millis = dur.subsec_millis();\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "else_if_without_else",
+    "id_span": {
+      "path": "clippy_lints/src/else_if_without_else.rs",
+      "line": 44
+    },
+    "group": "clippy::restriction",
+    "docs": " **What it does:** Checks for usage of if expressions with an `else if` branch, but without a final `else` branch.\n\n **Why is this bad?** Some coding guidelines require this (e.g., MISRA-C:2004 Rule 14.10).\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # fn a() {}\n # fn b() {}\n # let x: i32 = 1;\n if x.is_positive() {\n     a();\n } else if x.is_negative() {\n     b();\n }\n ```\n\n Could be written:\n\n ```rust\n # fn a() {}\n # fn b() {}\n # let x: i32 = 1;\n if x.is_positive() {\n     a();\n } else if x.is_negative() {\n     b();\n } else {\n     // We don't care about zero.\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "empty_enum",
+    "id_span": {
+      "path": "clippy_lints/src/empty_enum.rs",
+      "line": 38
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Checks for `enum`s with no variants.\n As of this writing, the `never_type` is still a\n nightly-only experimental API. Therefore, this lint is only triggered\n if the `never_type` is enabled.\n\n **Why is this bad?** If you want to introduce a type which\n can't be instantiated, you should use `!` (the primitive type \"never\"),\n or a wrapper around it, because `!` has more extensive\n compiler support (type inference, etc...) and wrappers\n around it are the conventional way to define an uninhabited type.\n For further information visit [never type documentation](https://doc.rust-lang.org/std/primitive.never.html)\n\n\n **Known problems:** None.\n\n **Example:**\n\n Bad:\n ```rust\n enum Test {}\n ```\n\n Good:\n ```rust\n #![feature(never_type)]\n\n struct Test(!);\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "map_entry",
+    "id_span": {
+      "path": "clippy_lints/src/entry.rs",
+      "line": 48
+    },
+    "group": "clippy::perf",
+    "docs": " **What it does:** Checks for uses of `contains_key` + `insert` on `HashMap` or `BTreeMap`.\n\n **Why is this bad?** Using `entry` is more efficient.\n\n **Known problems:** Some false negatives, eg.:\n ```rust\n # use std::collections::HashMap;\n # let mut map = HashMap::new();\n # let v = 1;\n # let k = 1;\n if !map.contains_key(&k) {\n     map.insert(k.clone(), v);\n }\n ```\n\n **Example:**\n ```rust\n # use std::collections::HashMap;\n # let mut map = HashMap::new();\n # let k = 1;\n # let v = 1;\n if !map.contains_key(&k) {\n     map.insert(k, v);\n }\n ```\n can both be rewritten as:\n ```rust\n # use std::collections::HashMap;\n # let mut map = HashMap::new();\n # let k = 1;\n # let v = 1;\n map.entry(k).or_insert(v);\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "enum_clike_unportable_variant",
+    "id_span": {
+      "path": "clippy_lints/src/enum_clike.rs",
+      "line": 31
+    },
+    "group": "clippy::correctness",
+    "docs": " **What it does:** Checks for C-like enumerations that are `repr(isize/usize)` and have values that don't fit into an `i32`.\n\n **Why is this bad?** This will truncate the variant value on 32 bit\n architectures, but works fine on 64 bit.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # #[cfg(target_pointer_width = \"64\")]\n #[repr(usize)]\n enum NonPortable {\n     X = 0x1_0000_0000,\n     Y = 0,\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "enum_variant_names",
+    "id_span": {
+      "path": "clippy_lints/src/enum_variants.rs",
+      "line": 36
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Detects enumeration variants that are prefixed or suffixed by the same characters.\n\n **Why is this bad?** Enumeration variant names should specify their variant,\n not repeat the enumeration name.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n enum Cake {\n     BlackForestCake,\n     HummingbirdCake,\n     BattenbergCake,\n }\n ```\n Could be written as:\n ```rust\n enum Cake {\n     BlackForest,\n     Hummingbird,\n     Battenberg,\n }\n ```\n",
+    "applicability": null
+  },
+  {
+    "id": "pub_enum_variant_names",
+    "id_span": {
+      "path": "clippy_lints/src/enum_variants.rs",
+      "line": 66
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Detects public enumeration variants that are prefixed or suffixed by the same characters.\n\n **Why is this bad?** Public enumeration variant names should specify their variant,\n not repeat the enumeration name.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n pub enum Cake {\n     BlackForestCake,\n     HummingbirdCake,\n     BattenbergCake,\n }\n ```\n Could be written as:\n ```rust\n pub enum Cake {\n     BlackForest,\n     Hummingbird,\n     Battenberg,\n }\n ```\n",
+    "applicability": null
+  },
+  {
+    "id": "module_name_repetitions",
+    "id_span": {
+      "path": "clippy_lints/src/enum_variants.rs",
+      "line": 91
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Detects type names that are prefixed or suffixed by the containing module's name.\n\n **Why is this bad?** It requires the user to type the module name twice.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n mod cake {\n     struct BlackForestCake;\n }\n ```\n Could be written as:\n ```rust\n mod cake {\n     struct BlackForest;\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "module_inception",
+    "id_span": {
+      "path": "clippy_lints/src/enum_variants.rs",
+      "line": 121
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for modules that have the same name as their parent module\n\n **Why is this bad?** A typical beginner mistake is to have `mod foo;` and\n again `mod foo { ..\n }` in `foo.rs`.\n The expectation is that items inside the inner `mod foo { .. }` are then\n available\n through `foo::x`, but they are only available through\n `foo::foo::x`.\n If this is done on purpose, it would be better to choose a more\n representative module name.\n\n **Known problems:** None.\n\n **Example:**\n ```ignore\n // lib.rs\n mod foo;\n // foo.rs\n mod foo {\n     ...\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "eq_op",
+    "id_span": {
+      "path": "clippy_lints/src/eq_op.rs",
+      "line": 34
+    },
+    "group": "clippy::correctness",
+    "docs": " **What it does:** Checks for equal operands to comparison, logical and bitwise, difference and division binary operators (`==`, `>`, etc., `&&`,\n `||`, `&`, `|`, `^`, `-` and `/`).\n\n **Why is this bad?** This is usually just a typo or a copy and paste error.\n\n **Known problems:** False negatives: We had some false positives regarding\n calls (notably [racer](https://github.com/phildawes/racer) had one instance\n of `x.pop() && x.pop()`), so we removed matching any function or method\n calls. We may introduce a list of known pure functions in the future.\n\n **Example:**\n ```rust\n # let x = 1;\n if x + 1 == x + 1 {}\n ```\n or\n ```rust\n # let a = 3;\n # let b = 4;\n assert_eq!(a, a);\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "op_ref",
+    "id_span": {
+      "path": "clippy_lints/src/eq_op.rs",
+      "line": 56
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for arguments to `==` which have their address taken to satisfy a bound\n and suggests to dereference the other argument instead\n\n **Why is this bad?** It is more idiomatic to dereference the other argument.\n\n **Known problems:** None\n\n **Example:**\n ```ignore\n // Bad\n &x == y\n\n // Good\n x == *y\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MaybeIncorrect"
+    }
+  },
+  {
+    "id": "erasing_op",
+    "id_span": {
+      "path": "clippy_lints/src/erasing_op.rs",
+      "line": 25
+    },
+    "group": "clippy::correctness",
+    "docs": " **What it does:** Checks for erasing operations, e.g., `x * 0`.\n **Why is this bad?** The whole expression can be replaced by zero.\n This is most likely not the intended outcome and should probably be\n corrected\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n let x = 1;\n 0 / x;\n 0 * x;\n x & 0;\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "boxed_local",
+    "id_span": {
+      "path": "clippy_lints/src/escape.rs",
+      "line": 43
+    },
+    "group": "clippy::perf",
+    "docs": " **What it does:** Checks for usage of `Box<T>` where an unboxed `T` would work fine.\n\n **Why is this bad?** This is an unnecessary allocation, and bad for\n performance. It is only necessary to allocate if you wish to move the box\n into something.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # fn foo(bar: usize) {}\n // Bad\n let x = Box::new(1);\n foo(*x);\n println!(\"{}\", *x);\n\n // Good\n let x = 1;\n foo(x);\n println!(\"{}\", x);\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "redundant_closure",
+    "id_span": {
+      "path": "clippy_lints/src/eta_reduction.rs",
+      "line": 37
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for closures which just call another function where the function can be called directly. `unsafe` functions or calls where types\n get adjusted are ignored.\n\n **Why is this bad?** Needlessly creating a closure adds code for no benefit\n and gives the optimizer more work.\n\n **Known problems:** If creating the closure inside the closure has a side-\n effect then moving the closure creation out will change when that side-\n effect runs.\n See [#1439](https://github.com/rust-lang/rust-clippy/issues/1439) for more details.\n\n **Example:**\n ```rust,ignore\n // Bad\n xs.map(|x| foo(x))\n\n // Good\n xs.map(foo)\n ```\n where `foo(_)` is a plain function that takes the exact argument type of\n `x`.\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "redundant_closure_for_method_calls",
+    "id_span": {
+      "path": "clippy_lints/src/eta_reduction.rs",
+      "line": 61
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Checks for closures which only invoke a method on the closure argument and can be replaced by referencing the method directly.\n\n **Why is this bad?** It's unnecessary to create the closure.\n\n **Known problems:** [#3071](https://github.com/rust-lang/rust-clippy/issues/3071),\n [#3942](https://github.com/rust-lang/rust-clippy/issues/3942),\n [#4002](https://github.com/rust-lang/rust-clippy/issues/4002)\n\n\n **Example:**\n ```rust,ignore\n Some('a').map(|s| s.to_uppercase());\n ```\n may be rewritten as\n ```rust,ignore\n Some('a').map(char::to_uppercase);\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "eval_order_dependence",
+    "id_span": {
+      "path": "clippy_lints/src/eval_order_dependence.rs",
+      "line": 38
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks for a read and a write to the same variable where whether the read occurs before or after the write depends on the evaluation\n order of sub-expressions.\n\n **Why is this bad?** It is often confusing to read. In addition, the\n sub-expression evaluation order for Rust is not well documented.\n\n **Known problems:** Code which intentionally depends on the evaluation\n order, or which is correct for any evaluation order.\n\n **Example:**\n ```rust\n let mut x = 0;\n\n // Bad\n let a = {\n     x = 1;\n     1\n } + x;\n // Unclear whether a is 1 or 2.\n\n // Good\n let tmp = {\n     x = 1;\n     1\n };\n let a = tmp + x;\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "diverging_sub_expression",
+    "id_span": {
+      "path": "clippy_lints/src/eval_order_dependence.rs",
+      "line": 62
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks for diverging calls that are not match arms or statements.\n\n **Why is this bad?** It is often confusing to read. In addition, the\n sub-expression evaluation order for Rust is not well documented.\n\n **Known problems:** Someone might want to use `some_bool || panic!()` as a\n shorthand.\n\n **Example:**\n ```rust,no_run\n # fn b() -> bool { true }\n # fn c() -> bool { true }\n let a = b() || panic!() || c();\n // `c()` is dead, `panic!()` is only called if `b()` returns `false`\n let x = (a, b, c, panic!());\n // can simply be replaced by `panic!()`\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "struct_excessive_bools",
+    "id_span": {
+      "path": "clippy_lints/src/excessive_bools.rs",
+      "line": 40
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Checks for excessive use of bools in structs.\n\n **Why is this bad?** Excessive bools in a struct\n is often a sign that it's used as a state machine,\n which is much better implemented as an enum.\n If it's not the case, excessive bools usually benefit\n from refactoring into two-variant enums for better\n readability and API.\n\n **Known problems:** None.\n\n **Example:**\n Bad:\n ```rust\n struct S {\n     is_pending: bool,\n     is_processing: bool,\n     is_finished: bool,\n }\n ```\n\n Good:\n ```rust\n enum S {\n     Pending,\n     Processing,\n     Finished,\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "fn_params_excessive_bools",
+    "id_span": {
+      "path": "clippy_lints/src/excessive_bools.rs",
+      "line": 78
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Checks for excessive use of bools in function definitions.\n\n **Why is this bad?** Calls to such functions\n are confusing and error prone, because it's\n hard to remember argument order and you have\n no type system support to back you up. Using\n two-variant enums instead of bools often makes\n API easier to use.\n\n **Known problems:** None.\n\n **Example:**\n Bad:\n ```rust,ignore\n fn f(is_round: bool, is_hot: bool) { ... }\n ```\n\n Good:\n ```rust,ignore\n enum Shape {\n     Round,\n     Spiky,\n }\n\n enum Temperature {\n     Hot,\n     IceCold,\n }\n\n fn f(shape: Shape, temperature: Temperature) { ... }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "exhaustive_enums",
+    "id_span": {
+      "path": "clippy_lints/src/exhaustive_items.rs",
+      "line": 34
+    },
+    "group": "clippy::restriction",
+    "docs": " **What it does:** Warns on any exported `enum`s that are not tagged `#[non_exhaustive]`\n **Why is this bad?** Exhaustive enums are typically fine, but a project which does\n not wish to make a stability commitment around exported enums may wish to\n disable them by default.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n enum Foo {\n     Bar,\n     Baz\n }\n ```\n Use instead:\n ```rust\n #[non_exhaustive]\n enum Foo {\n     Bar,\n     Baz\n }\n ```\n",
+    "applicability": null
+  },
+  {
+    "id": "exhaustive_structs",
+    "id_span": {
+      "path": "clippy_lints/src/exhaustive_items.rs",
+      "line": 64
+    },
+    "group": "clippy::restriction",
+    "docs": " **What it does:** Warns on any exported `structs`s that are not tagged `#[non_exhaustive]`\n **Why is this bad?** Exhaustive structs are typically fine, but a project which does\n not wish to make a stability commitment around exported structs may wish to\n disable them by default.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n struct Foo {\n     bar: u8,\n     baz: String,\n }\n ```\n Use instead:\n ```rust\n #[non_exhaustive]\n struct Foo {\n     bar: u8,\n     baz: String,\n }\n ```\n",
+    "applicability": null
+  },
+  {
+    "id": "exit",
+    "id_span": {
+      "path": "clippy_lints/src/exit.rs",
+      "line": 20
+    },
+    "group": "clippy::restriction",
+    "docs": " **What it does:** `exit()`  terminates the program and doesn't provide a stack trace.\n\n **Why is this bad?** Ideally a program is terminated by finishing\n the main function.\n\n **Known problems:** None.\n\n **Example:**\n ```ignore\n std::process::exit(0)\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "explicit_write",
+    "id_span": {
+      "path": "clippy_lints/src/explicit_write.rs",
+      "line": 25
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks for usage of `write!()` / `writeln()!` which can be replaced with `(e)print!()` / `(e)println!()`\n\n **Why is this bad?** Using `(e)println! is clearer and more concise\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # use std::io::Write;\n # let bar = \"furchtbar\";\n // this would be clearer as `eprintln!(\"foo: {:?}\", bar);`\n writeln!(&mut std::io::stderr(), \"foo: {:?}\", bar).unwrap();\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "fallible_impl_from",
+    "id_span": {
+      "path": "clippy_lints/src/fallible_impl_from.rs",
+      "line": 45
+    },
+    "group": "clippy::nursery",
+    "docs": " **What it does:** Checks for impls of `From<..>` that contain `panic!()` or `unwrap()`\n **Why is this bad?** `TryFrom` should be used if there's a possibility of failure.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n struct Foo(i32);\n\n // Bad\n impl From<String> for Foo {\n     fn from(s: String) -> Self {\n         Foo(s.parse().unwrap())\n     }\n }\n ```\n\n ```rust\n // Good\n struct Foo(i32);\n\n use std::convert::TryFrom;\n impl TryFrom<String> for Foo {\n     type Error = ();\n     fn try_from(s: String) -> Result<Self, Self::Error> {\n         if let Ok(parsed) = s.parse() {\n             Ok(Foo(parsed))\n         } else {\n             Err(())\n         }\n     }\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "float_equality_without_abs",
+    "id_span": {
+      "path": "clippy_lints/src/float_equality_without_abs.rs",
+      "line": 37
+    },
+    "group": "clippy::correctness",
+    "docs": " **What it does:** Checks for statements of the form `(a - b) < f32::EPSILON` or `(a - b) < f64::EPSILON`. Notes the missing `.abs()`.\n\n **Why is this bad?** The code without `.abs()` is more likely to have a bug.\n\n **Known problems:** If the user can ensure that b is larger than a, the `.abs()` is\n technically unneccessary. However, it will make the code more robust and doesn't have any\n large performance implications. If the abs call was deliberately left out for performance\n reasons, it is probably better to state this explicitly in the code, which then can be done\n with an allow.\n\n **Example:**\n\n ```rust\n pub fn is_roughly_equal(a: f32, b: f32) -> bool {\n     (a - b) < f32::EPSILON\n }\n ```\n Use instead:\n ```rust\n pub fn is_roughly_equal(a: f32, b: f32) -> bool {\n     (a - b).abs() < f32::EPSILON\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MaybeIncorrect"
+    }
+  },
+  {
+    "id": "excessive_precision",
+    "id_span": {
+      "path": "clippy_lints/src/float_literal.rs",
+      "line": 30
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for float literals with a precision greater than that supported by the underlying type.\n\n **Why is this bad?** Rust will truncate the literal silently.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n // Bad\n let v: f32 = 0.123_456_789_9;\n println!(\"{}\", v); //  0.123_456_789\n\n // Good\n let v: f64 = 0.123_456_789_9;\n println!(\"{}\", v); //  0.123_456_789_9\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "lossy_float_literal",
+    "id_span": {
+      "path": "clippy_lints/src/float_literal.rs",
+      "line": 54
+    },
+    "group": "clippy::restriction",
+    "docs": " **What it does:** Checks for whole number float literals that cannot be represented as the underlying type without loss.\n\n **Why is this bad?** Rust will silently lose precision during\n conversion to a float.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n // Bad\n let _: f32 = 16_777_217.0; // 16_777_216.0\n\n // Good\n let _: f32 = 16_777_216.0;\n let _: f64 = 16_777_217.0;\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "imprecise_flops",
+    "id_span": {
+      "path": "clippy_lints/src/floating_point_arithmetic.rs",
+      "line": 45
+    },
+    "group": "clippy::nursery",
+    "docs": " **What it does:** Looks for floating-point expressions that can be expressed using built-in methods to improve accuracy\n at the cost of performance.\n\n **Why is this bad?** Negatively impacts accuracy.\n\n **Known problems:** None\n\n **Example:**\n\n ```rust\n let a = 3f32;\n let _ = a.powf(1.0 / 3.0);\n let _ = (1.0 + a).ln();\n let _ = a.exp() - 1.0;\n ```\n\n is better expressed as\n\n ```rust\n let a = 3f32;\n let _ = a.cbrt();\n let _ = a.ln_1p();\n let _ = a.exp_m1();\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "suboptimal_flops",
+    "id_span": {
+      "path": "clippy_lints/src/floating_point_arithmetic.rs",
+      "line": 102
+    },
+    "group": "clippy::nursery",
+    "docs": " **What it does:** Looks for floating-point expressions that can be expressed using built-in methods to improve both\n accuracy and performance.\n\n **Why is this bad?** Negatively impacts accuracy and performance.\n\n **Known problems:** None\n\n **Example:**\n\n ```rust\n use std::f32::consts::E;\n\n let a = 3f32;\n let _ = (2f32).powf(a);\n let _ = E.powf(a);\n let _ = a.powf(1.0 / 2.0);\n let _ = a.log(2.0);\n let _ = a.log(10.0);\n let _ = a.log(E);\n let _ = a.powf(2.0);\n let _ = a * 2.0 + 4.0;\n let _ = if a < 0.0 {\n     -a\n } else {\n     a\n };\n let _ = if a < 0.0 {\n     a\n } else {\n     -a\n };\n ```\n\n is better expressed as\n\n ```rust\n use std::f32::consts::E;\n\n let a = 3f32;\n let _ = a.exp2();\n let _ = a.exp();\n let _ = a.sqrt();\n let _ = a.log2();\n let _ = a.log10();\n let _ = a.ln();\n let _ = a.powi(2);\n let _ = a.mul_add(2.0, 4.0);\n let _ = a.abs();\n let _ = -a.abs();\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "useless_format",
+    "id_span": {
+      "path": "clippy_lints/src/format.rs",
+      "line": 37
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks for the use of `format!(\"string literal with no argument\")` and `format!(\"{}\", foo)` where `foo` is a string.\n\n **Why is this bad?** There is no point of doing that. `format!(\"foo\")` can\n be replaced by `\"foo\".to_owned()` if you really need a `String`. The even\n worse `&format!(\"foo\")` is often encountered in the wild. `format!(\"{}\",\n foo)` can be replaced by `foo.clone()` if `foo: String` or `foo.to_owned()`\n if `foo: &str`.\n\n **Known problems:** None.\n\n **Examples:**\n ```rust\n\n // Bad\n # let foo = \"foo\";\n format!(\"{}\", foo);\n\n // Good\n format!(\"foo\");\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "suspicious_assignment_formatting",
+    "id_span": {
+      "path": "clippy_lints/src/formatting.rs",
+      "line": 22
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for use of the non-existent `=*`, `=!` and `=-` operators.\n\n **Why is this bad?** This is either a typo of `*=`, `!=` or `-=` or\n confusing.\n\n **Known problems:** None.\n\n **Example:**\n ```rust,ignore\n a =- 42; // confusing, should it be `a -= 42` or `a = -42`?\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "suspicious_unary_op_formatting",
+    "id_span": {
+      "path": "clippy_lints/src/formatting.rs",
+      "line": 44
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks the formatting of a unary operator on the right hand side of a binary operator. It lints if there is no space between the binary and unary operators,\n but there is a space between the unary and its operand.\n\n **Why is this bad?** This is either a typo in the binary operator or confusing.\n\n **Known problems:** None.\n\n **Example:**\n ```rust,ignore\n if foo <- 30 { // this should be `foo < -30` but looks like a different operator\n }\n\n if foo &&! bar { // this should be `foo && !bar` but looks like a different operator\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "suspicious_else_formatting",
+    "id_span": {
+      "path": "clippy_lints/src/formatting.rs",
+      "line": 80
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for formatting of `else`. It lints if the `else` is followed immediately by a newline or the `else` seems to be missing.\n\n **Why is this bad?** This is probably some refactoring remnant, even if the\n code is correct, it might look confusing.\n\n **Known problems:** None.\n\n **Example:**\n ```rust,ignore\n if foo {\n } { // looks like an `else` is missing here\n }\n\n if foo {\n } if bar { // looks like an `else` is missing here\n }\n\n if foo {\n } else\n\n { // this is the `else` block of the previous `if`, but should it be?\n }\n\n if foo {\n } else\n\n if bar { // this is the `else` block of the previous `if`, but should it be?\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "possible_missing_comma",
+    "id_span": {
+      "path": "clippy_lints/src/formatting.rs",
+      "line": 100
+    },
+    "group": "clippy::correctness",
+    "docs": " **What it does:** Checks for possible missing comma in an array. It lints if an array element is a binary operator expression and it lies on two lines.\n\n **Why is this bad?** This could lead to unexpected results.\n\n **Known problems:** None.\n\n **Example:**\n ```rust,ignore\n let a = &[\n     -1, -2, -3 // <= no comma here\n     -4, -5, -6\n ];\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "from_over_into",
+    "id_span": {
+      "path": "clippy_lints/src/from_over_into.rs",
+      "line": 39
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Searches for implementations of the `Into<..>` trait and suggests to implement `From<..>` instead.\n **Why is this bad?** According the std docs implementing `From<..>` is preferred since it gives you `Into<..>` for free where the reverse isn't true.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n struct StringWrapper(String);\n\n impl Into<StringWrapper> for String {\n     fn into(self) -> StringWrapper {\n         StringWrapper(self)\n     }\n }\n ```\n Use instead:\n ```rust\n struct StringWrapper(String);\n\n impl From<String> for StringWrapper {\n     fn from(s: String) -> StringWrapper {\n         StringWrapper(s)\n     }\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "from_str_radix_10",
+    "id_span": {
+      "path": "clippy_lints/src/from_str_radix_10.rs",
+      "line": 37
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for function invocations of the form `primitive::from_str_radix(s, 10)`\n\n **Why is this bad?**\n This specific common use case can be rewritten as `s.parse::<primitive>()`\n (and in most cases, the turbofish can be removed), which reduces code length\n and complexity.\n\n **Known problems:**\n This lint may suggest using (&<expression>).parse() instead of <expression>.parse() directly\n in some cases, which is correct but adds unnecessary complexity to the code.\n\n **Example:**\n\n ```ignore\n let input: &str = get_input();\n let num = u16::from_str_radix(input, 10)?;\n ```\n Use instead:\n ```ignore\n let input: &str = get_input();\n let num: u16 = input.parse()?;\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MaybeIncorrect"
+    }
+  },
+  {
+    "id": "too_many_arguments",
+    "id_span": {
+      "path": "clippy_lints/src/functions.rs",
+      "line": 39
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks for functions with too many parameters.\n **Why is this bad?** Functions with lots of parameters are considered bad\n style and reduce readability (“what does the 5th parameter mean?”). Consider\n grouping some parameters into a new type.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # struct Color;\n fn foo(x: u32, y: u32, name: &str, c: Color, w: f32, h: f32, a: f32, b: f32) {\n     // ..\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "too_many_lines",
+    "id_span": {
+      "path": "clippy_lints/src/functions.rs",
+      "line": 62
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Checks for functions with a large amount of lines.\n **Why is this bad?** Functions with a lot of lines are harder to understand\n due to having to look at a larger amount of code to understand what the\n function is doing. Consider splitting the body of the function into\n multiple functions.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n fn im_too_long() {\n     println!(\"\");\n     // ... 100 more LoC\n     println!(\"\");\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "not_unsafe_ptr_arg_deref",
+    "id_span": {
+      "path": "clippy_lints/src/functions.rs",
+      "line": 96
+    },
+    "group": "clippy::correctness",
+    "docs": " **What it does:** Checks for public functions that dereference raw pointer arguments but are not marked unsafe.\n\n **Why is this bad?** The function should probably be marked `unsafe`, since\n for an arbitrary raw pointer, there is no way of telling for sure if it is\n valid.\n\n **Known problems:**\n\n * It does not check functions recursively so if the pointer is passed to a\n private non-`unsafe` function which does the dereferencing, the lint won't\n trigger.\n * It only checks for arguments whose type are raw pointers, not raw pointers\n got from an argument in some other way (`fn foo(bar: &[*const u8])` or\n `some_argument.get_raw_ptr()`).\n\n **Example:**\n ```rust,ignore\n // Bad\n pub fn foo(x: *const u8) {\n     println!(\"{}\", unsafe { *x });\n }\n\n // Good\n pub unsafe fn foo(x: *const u8) {\n     println!(\"{}\", unsafe { *x });\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "must_use_unit",
+    "id_span": {
+      "path": "clippy_lints/src/functions.rs",
+      "line": 117
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for a [`#[must_use]`] attribute on unit-returning functions and methods.\n\n [`#[must_use]`]: https://doc.rust-lang.org/reference/attributes/diagnostics.html#the-must_use-attribute\n\n **Why is this bad?** Unit values are useless. The attribute is likely\n a remnant of a refactoring that removed the return type.\n\n **Known problems:** None.\n\n **Examples:**\n ```rust\n #[must_use]\n fn useless() { }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "double_must_use",
+    "id_span": {
+      "path": "clippy_lints/src/functions.rs",
+      "line": 142
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for a [`#[must_use]`] attribute without further information on functions and methods that return a type already\n marked as `#[must_use]`.\n\n [`#[must_use]`]: https://doc.rust-lang.org/reference/attributes/diagnostics.html#the-must_use-attribute\n\n **Why is this bad?** The attribute isn't needed. Not using the result\n will already be reported. Alternatively, one can add some text to the\n attribute to improve the lint message.\n\n **Known problems:** None.\n\n **Examples:**\n ```rust\n #[must_use]\n fn double_must_use() -> Result<(), ()> {\n     unimplemented!();\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "must_use_candidate",
+    "id_span": {
+      "path": "clippy_lints/src/functions.rs",
+      "line": 170
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Checks for public functions that have no [`#[must_use]`] attribute, but return something not already marked\n must-use, have no mutable arg and mutate no statics.\n\n [`#[must_use]`]: https://doc.rust-lang.org/reference/attributes/diagnostics.html#the-must_use-attribute\n\n **Why is this bad?** Not bad at all, this lint just shows places where\n you could add the attribute.\n\n **Known problems:** The lint only checks the arguments for mutable\n types without looking if they are actually changed. On the other hand,\n it also ignores a broad range of potentially interesting side effects,\n because we cannot decide whether the programmer intends the function to\n be called for the side effect or the result. Expect many false\n positives. At least we don't lint if the result type is unit or already\n `#[must_use]`.\n\n **Examples:**\n ```rust\n // this could be annotated with `#[must_use]`.\n fn id<T>(t: T) -> T { t }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "result_unit_err",
+    "id_span": {
+      "path": "clippy_lints/src/functions.rs",
+      "line": 216
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for public functions that return a `Result` with an `Err` type of `()`. It suggests using a custom type that\n implements [`std::error::Error`].\n\n **Why is this bad?** Unit does not implement `Error` and carries no\n further information about what went wrong.\n\n **Known problems:** Of course, this lint assumes that `Result` is used\n for a fallible operation (which is after all the intended use). However\n code may opt to (mis)use it as a basic two-variant-enum. In that case,\n the suggestion is misguided, and the code should use a custom enum\n instead.\n\n **Examples:**\n ```rust\n pub fn read_u8() -> Result<u8, ()> { Err(()) }\n ```\n should become\n ```rust,should_panic\n use std::fmt;\n\n #[derive(Debug)]\n pub struct EndOfStream;\n\n impl fmt::Display for EndOfStream {\n     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\n         write!(f, \"End of Stream\")\n     }\n }\n\n impl std::error::Error for EndOfStream { }\n\n pub fn read_u8() -> Result<u8, EndOfStream> { Err(EndOfStream) }\n# fn main() {\n#     read_u8().unwrap();\n# }\n ```\n\n Note that there are crates that simplify creating the error type, e.g.\n [`thiserror`](https://docs.rs/thiserror).\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "future_not_send",
+    "id_span": {
+      "path": "clippy_lints/src/future_not_send.rs",
+      "line": 44
+    },
+    "group": "clippy::nursery",
+    "docs": " **What it does:** This lint requires Future implementations returned from functions and methods to implement the `Send` marker trait. It is mostly\n used by library authors (public and internal) that target an audience where\n multithreaded executors are likely to be used for running these Futures.\n\n **Why is this bad?** A Future implementation captures some state that it\n needs to eventually produce its final value. When targeting a multithreaded\n executor (which is the norm on non-embedded devices) this means that this\n state may need to be transported to other threads, in other words the\n whole Future needs to implement the `Send` marker trait. If it does not,\n then the resulting Future cannot be submitted to a thread pool in the\n end user’s code.\n\n Especially for generic functions it can be confusing to leave the\n discovery of this problem to the end user: the reported error location\n will be far from its cause and can in many cases not even be fixed without\n modifying the library where the offending Future implementation is\n produced.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n async fn not_send(bytes: std::rc::Rc<[u8]>) {}\n ```\n Use instead:\n ```rust\n async fn is_send(bytes: std::sync::Arc<[u8]>) {}\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "get_last_with_len",
+    "id_span": {
+      "path": "clippy_lints/src/get_last_with_len.rs",
+      "line": 40
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks for using `x.get(x.len() - 1)` instead of `x.last()`.\n\n **Why is this bad?** Using `x.last()` is easier to read and has the same\n result.\n\n Note that using `x[x.len() - 1]` is semantically different from\n `x.last()`.  Indexing into the array will panic on out-of-bounds\n accesses, while `x.get()` and `x.last()` will return `None`.\n\n There is another lint (get_unwrap) that covers the case of using\n `x.get(index).unwrap()` instead of `x[index]`.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n // Bad\n let x = vec![2, 3, 5];\n let last_element = x.get(x.len() - 1);\n\n // Good\n let x = vec![2, 3, 5];\n let last_element = x.last();\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "identity_op",
+    "id_span": {
+      "path": "clippy_lints/src/identity_op.rs",
+      "line": 24
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks for identity operations, e.g., `x + 0`.\n **Why is this bad?** This code can be removed without changing the\n meaning. So it just obscures what's going on. Delete it mercilessly.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # let x = 1;\n x / 1 + 0 * 1 - 0 | 0;\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "if_let_mutex",
+    "id_span": {
+      "path": "clippy_lints/src/if_let_mutex.rs",
+      "line": 36
+    },
+    "group": "clippy::correctness",
+    "docs": " **What it does:** Checks for `Mutex::lock` calls in `if let` expression with lock calls in any of the else blocks.\n\n **Why is this bad?** The Mutex lock remains held for the whole\n `if let ... else` block and deadlocks.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust,ignore\n if let Ok(thing) = mutex.lock() {\n     do_thing();\n } else {\n     mutex.lock();\n }\n ```\n Should be written\n ```rust,ignore\n let locked = mutex.lock();\n if let Ok(thing) = locked {\n     do_thing(thing);\n } else {\n     use_locked(locked);\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "if_let_some_result",
+    "id_span": {
+      "path": "clippy_lints/src/if_let_some_result.rs",
+      "line": 34
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:*** Checks for unnecessary `ok()` in if let.\n **Why is this bad?** Calling `ok()` in if let is unnecessary, instead match\n on `Ok(pat)`\n\n **Known problems:** None.\n\n **Example:**\n ```ignore\n for i in iter {\n     if let Some(value) = i.parse().ok() {\n         vec.push(value)\n     }\n }\n ```\n Could be written:\n\n ```ignore\n for i in iter {\n     if let Ok(value) = i.parse() {\n         vec.push(value)\n     }\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "if_not_else",
+    "id_span": {
+      "path": "clippy_lints/src/if_not_else.rs",
+      "line": 43
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Checks for usage of `!` or `!=` in an if condition with an else branch.\n\n **Why is this bad?** Negations reduce the readability of statements.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # let v: Vec<usize> = vec![];\n # fn a() {}\n # fn b() {}\n if !v.is_empty() {\n     a()\n } else {\n     b()\n }\n ```\n\n Could be written:\n\n ```rust\n # let v: Vec<usize> = vec![];\n # fn a() {}\n # fn b() {}\n if v.is_empty() {\n     b()\n } else {\n     a()\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "implicit_return",
+    "id_span": {
+      "path": "clippy_lints/src/implicit_return.rs",
+      "line": 33
+    },
+    "group": "clippy::restriction",
+    "docs": " **What it does:** Checks for missing return statements at the end of a block.\n **Why is this bad?** Actually omitting the return keyword is idiomatic Rust code. Programmers\n coming from other languages might prefer the expressiveness of `return`. It's possible to miss\n the last returning statement because the only difference is a missing `;`. Especially in bigger\n code with multiple return paths having a `return` keyword makes it easier to find the\n corresponding statements.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n fn foo(x: usize) -> usize {\n     x\n }\n ```\n add return\n ```rust\n fn foo(x: usize) -> usize {\n     return x;\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "implicit_saturating_sub",
+    "id_span": {
+      "path": "clippy_lints/src/implicit_saturating_sub.rs",
+      "line": 32
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Checks for implicit saturating subtraction.\n **Why is this bad?** Simplicity and readability. Instead we can easily use an builtin function.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n let end: u32 = 10;\n let start: u32 = 5;\n\n let mut i: u32 = end - start;\n\n // Bad\n if i != 0 {\n     i -= 1;\n }\n\n // Good\n i = i.saturating_sub(1);\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "inconsistent_struct_constructor",
+    "id_span": {
+      "path": "clippy_lints/src/inconsistent_struct_constructor.rs",
+      "line": 58
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for struct constructors where the order of the field init shorthand in the constructor is inconsistent with the order in the struct definition.\n\n **Why is this bad?** Since the order of fields in a constructor doesn't affect the\n resulted instance as the below example indicates,\n\n ```rust\n #[derive(Debug, PartialEq, Eq)]\n struct Foo {\n     x: i32,\n     y: i32,\n }\n let x = 1;\n let y = 2;\n\n // This assertion never fails.\n assert_eq!(Foo { x, y }, Foo { y, x });\n ```\n\n inconsistent order means nothing and just decreases readability and consistency.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n struct Foo {\n     x: i32,\n     y: i32,\n }\n let x = 1;\n let y = 2;\n Foo { y, x };\n ```\n\n Use instead:\n ```rust\n # struct Foo {\n #     x: i32,\n #     y: i32,\n # }\n # let x = 1;\n # let y = 2;\n Foo { x, y };\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "out_of_bounds_indexing",
+    "id_span": {
+      "path": "clippy_lints/src/indexing_slicing.rs",
+      "line": 32
+    },
+    "group": "clippy::correctness",
+    "docs": " **What it does:** Checks for out of bounds array indexing with a constant index.\n\n **Why is this bad?** This will always panic at runtime.\n\n **Known problems:** Hopefully none.\n\n **Example:**\n ```no_run\n # #![allow(const_err)]\n let x = [1, 2, 3, 4];\n\n // Bad\n x[9];\n &x[2..9];\n\n // Good\n x[0];\n x[3];\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "indexing_slicing",
+    "id_span": {
+      "path": "clippy_lints/src/indexing_slicing.rs",
+      "line": 81
+    },
+    "group": "clippy::restriction",
+    "docs": " **What it does:** Checks for usage of indexing or slicing. Arrays are special cases, this lint does report on arrays if we can tell that slicing operations are in bounds and does not\n lint on constant `usize` indexing on arrays because that is handled by rustc's `const_err` lint.\n\n **Why is this bad?** Indexing and slicing can panic at runtime and there are\n safe alternatives.\n\n **Known problems:** Hopefully none.\n\n **Example:**\n ```rust,no_run\n // Vector\n let x = vec![0; 5];\n\n // Bad\n x[2];\n &x[2..100];\n &x[2..];\n &x[..100];\n\n // Good\n x.get(2);\n x.get(2..100);\n x.get(2..);\n x.get(..100);\n\n // Array\n let y = [0, 1, 2, 3];\n\n // Bad\n &y[10..100];\n &y[10..];\n &y[..100];\n\n // Good\n &y[2..];\n &y[..2];\n &y[0..3];\n y.get(10);\n y.get(10..100);\n y.get(10..);\n y.get(..100);\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "infinite_iter",
+    "id_span": {
+      "path": "clippy_lints/src/infinite_iter.rs",
+      "line": 21
+    },
+    "group": "clippy::correctness",
+    "docs": " **What it does:** Checks for iteration that is guaranteed to be infinite.\n **Why is this bad?** While there may be places where this is acceptable\n (e.g., in event streams), in most cases this is simply an error.\n\n **Known problems:** None.\n\n **Example:**\n ```no_run\n use std::iter;\n\n iter::repeat(1_u8).collect::<Vec<_>>();\n ```\n",
+    "applicability": null
+  },
+  {
+    "id": "maybe_infinite_iter",
+    "id_span": {
+      "path": "clippy_lints/src/infinite_iter.rs",
+      "line": 40
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Checks for iteration that may be infinite.\n **Why is this bad?** While there may be places where this is acceptable\n (e.g., in event streams), in most cases this is simply an error.\n\n **Known problems:** The code may have a condition to stop iteration, but\n this lint is not clever enough to analyze it.\n\n **Example:**\n ```rust\n let infinite_iter = 0..;\n [0..].iter().zip(infinite_iter.take_while(|x| *x > 5));\n ```\n",
+    "applicability": null
+  },
+  {
+    "id": "multiple_inherent_impl",
+    "id_span": {
+      "path": "clippy_lints/src/inherent_impl.rs",
+      "line": 37
+    },
+    "group": "clippy::restriction",
+    "docs": " **What it does:** Checks for multiple inherent implementations of a struct\n **Why is this bad?** Splitting the implementation of a type makes the code harder to navigate.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n struct X;\n impl X {\n     fn one() {}\n }\n impl X {\n     fn other() {}\n }\n ```\n\n Could be written:\n\n ```rust\n struct X;\n impl X {\n     fn one() {}\n     fn other() {}\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "inherent_to_string",
+    "id_span": {
+      "path": "clippy_lints/src/inherent_to_string.rs",
+      "line": 44
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for the definition of inherent methods with a signature of `to_string(&self) -> String`.\n **Why is this bad?** This method is also implicitly defined if a type implements the `Display` trait. As the functionality of `Display` is much more versatile, it should be preferred.\n\n **Known problems:** None\n\n ** Example:**\n\n ```rust\n // Bad\n pub struct A;\n\n impl A {\n     pub fn to_string(&self) -> String {\n         \"I am A\".to_string()\n     }\n }\n ```\n\n ```rust\n // Good\n use std::fmt;\n\n pub struct A;\n\n impl fmt::Display for A {\n     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n         write!(f, \"I am A\")\n     }\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "inherent_to_string_shadow_display",
+    "id_span": {
+      "path": "clippy_lints/src/inherent_to_string.rs",
+      "line": 89
+    },
+    "group": "clippy::correctness",
+    "docs": " **What it does:** Checks for the definition of inherent methods with a signature of `to_string(&self) -> String` and if the type implementing this method also implements the `Display` trait.\n **Why is this bad?** This method is also implicitly defined if a type implements the `Display` trait. The less versatile inherent method will then shadow the implementation introduced by `Display`.\n\n **Known problems:** None\n\n ** Example:**\n\n ```rust\n // Bad\n use std::fmt;\n\n pub struct A;\n\n impl A {\n     pub fn to_string(&self) -> String {\n         \"I am A\".to_string()\n     }\n }\n\n impl fmt::Display for A {\n     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n         write!(f, \"I am A, too\")\n     }\n }\n ```\n\n ```rust\n // Good\n use std::fmt;\n\n pub struct A;\n\n impl fmt::Display for A {\n     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n         write!(f, \"I am A\")\n     }\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "inline_fn_without_body",
+    "id_span": {
+      "path": "clippy_lints/src/inline_fn_without_body.rs",
+      "line": 27
+    },
+    "group": "clippy::correctness",
+    "docs": " **What it does:** Checks for `#[inline]` on trait methods without bodies\n **Why is this bad?** Only implementations of trait methods may be inlined.\n The inline attribute is ignored for trait methods without bodies.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n trait Animal {\n     #[inline]\n     fn name(&self) -> &'static str;\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "int_plus_one",
+    "id_span": {
+      "path": "clippy_lints/src/int_plus_one.rs",
+      "line": 31
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks for usage of `x >= y + 1` or `x - 1 >= y` (and `<=`) in a block\n **Why is this bad?** Readability -- better to use `> y` instead of `>= y + 1`.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # let x = 1;\n # let y = 1;\n if x >= y + 1 {}\n ```\n\n Could be written as:\n\n ```rust\n # let x = 1;\n # let y = 1;\n if x > y {}\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "integer_division",
+    "id_span": {
+      "path": "clippy_lints/src/integer_division.rs",
+      "line": 26
+    },
+    "group": "clippy::restriction",
+    "docs": " **What it does:** Checks for division of integers\n **Why is this bad?** When outside of some very specific algorithms,\n integer division is very often a mistake because it discards the\n remainder.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n // Bad\n let x = 3 / 2;\n println!(\"{}\", x);\n\n // Good\n let x = 3f32 / 2f32;\n println!(\"{}\", x);\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "items_after_statements",
+    "id_span": {
+      "path": "clippy_lints/src/items_after_statements.rs",
+      "line": 48
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Checks for items declared after some statement in a block.\n **Why is this bad?** Items live for the entire scope they are declared\n in. But statements are processed in order. This might cause confusion as\n it's hard to figure out which item is meant in a statement.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n // Bad\n fn foo() {\n     println!(\"cake\");\n }\n\n fn main() {\n     foo(); // prints \"foo\"\n     fn foo() {\n         println!(\"foo\");\n     }\n     foo(); // prints \"foo\"\n }\n ```\n\n ```rust\n // Good\n fn foo() {\n     println!(\"cake\");\n }\n\n fn main() {\n     fn foo() {\n         println!(\"foo\");\n     }\n     foo(); // prints \"foo\"\n     foo(); // prints \"foo\"\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "large_const_arrays",
+    "id_span": {
+      "path": "clippy_lints/src/large_const_arrays.rs",
+      "line": 30
+    },
+    "group": "clippy::perf",
+    "docs": " **What it does:** Checks for large `const` arrays that should be defined as `static` instead.\n\n **Why is this bad?** Performance: const variables are inlined upon use.\n Static items result in only one instance and has a fixed location in memory.\n\n **Known problems:** None.\n\n **Example:**\n ```rust,ignore\n // Bad\n pub const a = [0u32; 1_000_000];\n\n // Good\n pub static a = [0u32; 1_000_000];\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "large_enum_variant",
+    "id_span": {
+      "path": "clippy_lints/src/large_enum_variant.rs",
+      "line": 39
+    },
+    "group": "clippy::perf",
+    "docs": " **What it does:** Checks for large size differences between variants on `enum`s.\n\n **Why is this bad?** Enum size is bounded by the largest variant. Having a\n large variant can penalize the memory layout of that enum.\n\n **Known problems:** This lint obviously cannot take the distribution of\n variants in your running program into account. It is possible that the\n smaller variants make up less than 1% of all instances, in which case\n the overhead is negligible and the boxing is counter-productive. Always\n measure the change this lint suggests.\n\n **Example:**\n\n ```rust\n // Bad\n enum Test {\n     A(i32),\n     B([i32; 8000]),\n }\n\n // Possibly better\n enum Test2 {\n     A(i32),\n     B(Box<[i32; 8000]>),\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MaybeIncorrect"
+    }
+  },
+  {
+    "id": "large_stack_arrays",
+    "id_span": {
+      "path": "clippy_lints/src/large_stack_arrays.rs",
+      "line": 23
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Checks for local arrays that may be too large.\n **Why is this bad?** Large local arrays may cause stack overflow.\n\n **Known problems:** None.\n\n **Example:**\n ```rust,ignore\n let a = [0u32; 1_000_000];\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "len_zero",
+    "id_span": {
+      "path": "clippy_lints/src/len_zero.rs",
+      "line": 41
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for getting the length of something via `.len()` just to compare to zero, and suggests using `.is_empty()` where applicable.\n\n **Why is this bad?** Some structures can answer `.is_empty()` much faster\n than calculating their length. So it is good to get into the habit of using\n `.is_empty()`, and having it is cheap.\n Besides, it makes the intent clearer than a manual comparison in some contexts.\n\n **Known problems:** None.\n\n **Example:**\n ```ignore\n if x.len() == 0 {\n     ..\n }\n if y.len() != 0 {\n     ..\n }\n ```\n instead use\n ```ignore\n if x.is_empty() {\n     ..\n }\n if !y.is_empty() {\n     ..\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "len_without_is_empty",
+    "id_span": {
+      "path": "clippy_lints/src/len_zero.rs",
+      "line": 66
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for items that implement `.len()` but not `.is_empty()`.\n\n **Why is this bad?** It is good custom to have both methods, because for\n some data structures, asking about the length will be a costly operation,\n whereas `.is_empty()` can usually answer in constant time. Also it used to\n lead to false positives on the [`len_zero`](#len_zero) lint – currently that\n lint will ignore such entities.\n\n **Known problems:** None.\n\n **Example:**\n ```ignore\n impl X {\n     pub fn len(&self) -> usize {\n         ..\n     }\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "comparison_to_empty",
+    "id_span": {
+      "path": "clippy_lints/src/len_zero.rs",
+      "line": 103
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for comparing to an empty slice such as `\"\"` or `[]`, and suggests using `.is_empty()` where applicable.\n\n **Why is this bad?** Some structures can answer `.is_empty()` much faster\n than checking for equality. So it is good to get into the habit of using\n `.is_empty()`, and having it is cheap.\n Besides, it makes the intent clearer than a manual comparison in some contexts.\n\n **Known problems:** None.\n\n **Example:**\n\n ```ignore\n if s == \"\" {\n     ..\n }\n\n if arr == [] {\n     ..\n }\n ```\n Use instead:\n ```ignore\n if s.is_empty() {\n     ..\n }\n\n if arr.is_empty() {\n     ..\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "useless_let_if_seq",
+    "id_span": {
+      "path": "clippy_lints/src/let_if_seq.rs",
+      "line": 49
+    },
+    "group": "clippy::nursery",
+    "docs": " **What it does:** Checks for variable declarations immediately followed by a conditional affectation.\n\n **Why is this bad?** This is not idiomatic Rust.\n\n **Known problems:** None.\n\n **Example:**\n ```rust,ignore\n let foo;\n\n if bar() {\n     foo = 42;\n } else {\n     foo = 0;\n }\n\n let mut baz = None;\n\n if bar() {\n     baz = Some(42);\n }\n ```\n\n should be written\n\n ```rust,ignore\n let foo = if bar() {\n     42\n } else {\n     0\n };\n\n let baz = if bar() {\n     Some(42)\n } else {\n     None\n };\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "HasPlaceholders"
+    }
+  },
+  {
+    "id": "let_underscore_must_use",
+    "id_span": {
+      "path": "clippy_lints/src/let_underscore.rs",
+      "line": 29
+    },
+    "group": "clippy::restriction",
+    "docs": " **What it does:** Checks for `let _ = <expr>` where expr is #[must_use]\n\n **Why is this bad?** It's better to explicitly\n handle the value of a #[must_use] expr\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n fn f() -> Result<u32, u32> {\n     Ok(0)\n }\n\n let _ = f();\n // is_ok() is marked #[must_use]\n let _ = f().is_ok();\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "let_underscore_lock",
+    "id_span": {
+      "path": "clippy_lints/src/let_underscore.rs",
+      "line": 56
+    },
+    "group": "clippy::correctness",
+    "docs": " **What it does:** Checks for `let _ = sync_lock`\n **Why is this bad?** This statement immediately drops the lock instead of\n extending its lifetime to the end of the scope, which is often not intended.\n To extend lock lifetime to the end of the scope, use an underscore-prefixed\n name instead (i.e. _lock). If you want to explicitly drop the lock,\n `std::mem::drop` conveys your intention better and is less error-prone.\n\n **Known problems:** None.\n\n **Example:**\n\n Bad:\n ```rust,ignore\n let _ = mutex.lock();\n ```\n\n Good:\n ```rust,ignore\n let _lock = mutex.lock();\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "let_underscore_drop",
+    "id_span": {
+      "path": "clippy_lints/src/let_underscore.rs",
+      "line": 97
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Checks for `let _ = <expr>` where expr has a type that implements `Drop`\n\n **Why is this bad?** This statement immediately drops the initializer\n expression instead of extending its lifetime to the end of the scope, which\n is often not intended. To extend the expression's lifetime to the end of the\n scope, use an underscore-prefixed name instead (i.e. _var). If you want to\n explicitly drop the expression, `std::mem::drop` conveys your intention\n better and is less error-prone.\n\n **Known problems:** None.\n\n **Example:**\n\n Bad:\n ```rust,ignore\n struct Droppable;\n impl Drop for Droppable {\n     fn drop(&mut self) {}\n }\n {\n     let _ = Droppable;\n     //               ^ dropped here\n     /* more code */\n }\n ```\n\n Good:\n ```rust,ignore\n {\n     let _droppable = Droppable;\n     /* more code */\n     // dropped at end of scope\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "needless_lifetimes",
+    "id_span": {
+      "path": "clippy_lints/src/lifetimes.rs",
+      "line": 46
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks for lifetime annotations which can be removed by relying on lifetime elision.\n\n **Why is this bad?** The additional lifetimes make the code look more\n complicated, while there is nothing out of the ordinary going on. Removing\n them leads to more readable code.\n\n **Known problems:**\n - We bail out if the function has a `where` clause where lifetimes\n are mentioned due to potenial false positives.\n - Lifetime bounds such as `impl Foo + 'a` and `T: 'a` must be elided with the\n placeholder notation `'_` because the fully elided notation leaves the type bound to `'static`.\n\n **Example:**\n ```rust\n // Bad: unnecessary lifetime annotations\n fn in_and_out<'a>(x: &'a u8, y: u8) -> &'a u8 {\n     x\n }\n\n // Good\n fn elided(x: &u8, y: u8) -> &u8 {\n     x\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "extra_unused_lifetimes",
+    "id_span": {
+      "path": "clippy_lints/src/lifetimes.rs",
+      "line": 74
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks for lifetimes in generics that are never used anywhere else.\n\n **Why is this bad?** The additional lifetimes make the code look more\n complicated, while there is nothing out of the ordinary going on. Removing\n them leads to more readable code.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n // Bad: unnecessary lifetimes\n fn unused_lifetime<'a>(x: u8) {\n     // ..\n }\n\n // Good\n fn no_lifetime(x: u8) {\n     // ...\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "unreadable_literal",
+    "id_span": {
+      "path": "clippy_lints/src/literal_representation.rs",
+      "line": 33
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Warns if a long integral or floating-point constant does not contain underscores.\n\n **Why is this bad?** Reading long numbers is difficult without separators.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n // Bad\n let x: u64 = 61864918973511;\n\n // Good\n let x: u64 = 61_864_918_973_511;\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "mistyped_literal_suffixes",
+    "id_span": {
+      "path": "clippy_lints/src/literal_representation.rs",
+      "line": 57
+    },
+    "group": "clippy::correctness",
+    "docs": " **What it does:** Warns for mistyped suffix in literals\n **Why is this bad?** This is most probably a typo\n\n **Known problems:**\n - Recommends a signed suffix, even though the number might be too big and an unsigned\n   suffix is required\n - Does not match on `_127` since that is a valid grouping for decimal and octal numbers\n\n **Example:**\n\n ```rust\n // Probably mistyped\n 2_32;\n\n // Good\n 2_i32;\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MaybeIncorrect"
+    }
+  },
+  {
+    "id": "inconsistent_digit_grouping",
+    "id_span": {
+      "path": "clippy_lints/src/literal_representation.rs",
+      "line": 80
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Warns if an integral or floating-point constant is grouped inconsistently with underscores.\n\n **Why is this bad?** Readers may incorrectly interpret inconsistently\n grouped digits.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n // Bad\n let x: u64 = 618_64_9189_73_511;\n\n // Good\n let x: u64 = 61_864_918_973_511;\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "unusual_byte_groupings",
+    "id_span": {
+      "path": "clippy_lints/src/literal_representation.rs",
+      "line": 99
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Warns if hexadecimal or binary literals are not grouped by nibble or byte.\n\n **Why is this bad?** Negatively impacts readability.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n let x: u32 = 0xFFF_FFF;\n let y: u8 = 0b01_011_101;\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "large_digit_groups",
+    "id_span": {
+      "path": "clippy_lints/src/literal_representation.rs",
+      "line": 118
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Warns if the digits of an integral or floating-point constant are grouped into groups that\n are too large.\n\n **Why is this bad?** Negatively impacts readability.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n let x: u64 = 6186491_8973511;\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "decimal_literal_representation",
+    "id_span": {
+      "path": "clippy_lints/src/literal_representation.rs",
+      "line": 136
+    },
+    "group": "clippy::restriction",
+    "docs": " **What it does:** Warns if there is a better representation for a numeric literal.\n **Why is this bad?** Especially for big powers of 2 a hexadecimal representation is more\n readable than a decimal representation.\n\n **Known problems:** None.\n\n **Example:**\n\n `255` => `0xFF`\n `65_535` => `0xFFFF`\n `4_042_322_160` => `0xF0F0_F0F0`\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "manual_memcpy",
+    "id_span": {
+      "path": "clippy_lints/src/loops.rs",
+      "line": 57
+    },
+    "group": "clippy::perf",
+    "docs": " **What it does:** Checks for for-loops that manually copy items between slices that could be optimized by having a memcpy.\n\n **Why is this bad?** It is not as fast as a memcpy.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # let src = vec![1];\n # let mut dst = vec![0; 65];\n for i in 0..src.len() {\n     dst[i + 64] = src[i];\n }\n ```\n Could be written as:\n ```rust\n # let src = vec![1];\n # let mut dst = vec![0; 65];\n dst[64..(src.len() + 64)].clone_from_slice(&src[..]);\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "Unspecified"
+    }
+  },
+  {
+    "id": "needless_range_loop",
+    "id_span": {
+      "path": "clippy_lints/src/loops.rs",
+      "line": 85
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for looping over the range of `0..len` of some collection just to get the values by index.\n\n **Why is this bad?** Just iterating the collection itself makes the intent\n more clear and is probably faster.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n let vec = vec!['a', 'b', 'c'];\n for i in 0..vec.len() {\n     println!(\"{}\", vec[i]);\n }\n ```\n Could be written as:\n ```rust\n let vec = vec!['a', 'b', 'c'];\n for i in vec {\n     println!(\"{}\", i);\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "explicit_iter_loop",
+    "id_span": {
+      "path": "clippy_lints/src/loops.rs",
+      "line": 114
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Checks for loops on `x.iter()` where `&x` will do, and suggests the latter.\n\n **Why is this bad?** Readability.\n\n **Known problems:** False negatives. We currently only warn on some known\n types.\n\n **Example:**\n ```rust\n // with `y` a `Vec` or slice:\n # let y = vec![1];\n for x in y.iter() {\n     // ..\n }\n ```\n can be rewritten to\n ```rust\n # let y = vec![1];\n for x in &y {\n     // ..\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "explicit_into_iter_loop",
+    "id_span": {
+      "path": "clippy_lints/src/loops.rs",
+      "line": 142
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Checks for loops on `y.into_iter()` where `y` will do, and suggests the latter.\n\n **Why is this bad?** Readability.\n\n **Known problems:** None\n\n **Example:**\n ```rust\n # let y = vec![1];\n // with `y` a `Vec` or slice:\n for x in y.into_iter() {\n     // ..\n }\n ```\n can be rewritten to\n ```rust\n # let y = vec![1];\n for x in y {\n     // ..\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "iter_next_loop",
+    "id_span": {
+      "path": "clippy_lints/src/loops.rs",
+      "line": 165
+    },
+    "group": "clippy::correctness",
+    "docs": " **What it does:** Checks for loops on `x.next()`.\n **Why is this bad?** `next()` returns either `Some(value)` if there was a\n value, or `None` otherwise. The insidious thing is that `Option<_>`\n implements `IntoIterator`, so that possibly one value will be iterated,\n leading to some hard to find bugs. No one will want to write such code\n [except to win an Underhanded Rust\n Contest](https://www.reddit.com/r/rust/comments/3hb0wm/underhanded_rust_contest/cu5yuhr).\n\n **Known problems:** None.\n\n **Example:**\n ```ignore\n for x in y.next() {\n     ..\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "for_loops_over_fallibles",
+    "id_span": {
+      "path": "clippy_lints/src/loops.rs",
+      "line": 208
+    },
+    "group": "clippy::correctness",
+    "docs": " **What it does:** Checks for `for` loops over `Option` or `Result` values.\n **Why is this bad?** Readability. This is more clearly expressed as an `if\n let`.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # let opt = Some(1);\n\n // Bad\n for x in opt {\n     // ..\n }\n\n // Good\n if let Some(x) = opt {\n     // ..\n }\n ```\n\n // or\n\n ```rust\n # let res: Result<i32, std::io::Error> = Ok(1);\n\n // Bad\n for x in &res {\n     // ..\n }\n\n // Good\n if let Ok(x) = res {\n     // ..\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "while_let_loop",
+    "id_span": {
+      "path": "clippy_lints/src/loops.rs",
+      "line": 237
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Detects `loop + match` combinations that are easier written as a `while let` loop.\n\n **Why is this bad?** The `while let` loop is usually shorter and more\n readable.\n\n **Known problems:** Sometimes the wrong binding is displayed ([#383](https://github.com/rust-lang/rust-clippy/issues/383)).\n\n **Example:**\n ```rust,no_run\n # let y = Some(1);\n loop {\n     let x = match y {\n         Some(x) => x,\n         None => break,\n     };\n     // .. do something with x\n }\n // is easier written as\n while let Some(x) = y {\n     // .. do something with x\n };\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "HasPlaceholders"
+    }
+  },
+  {
+    "id": "needless_collect",
+    "id_span": {
+      "path": "clippy_lints/src/loops.rs",
+      "line": 259
+    },
+    "group": "clippy::perf",
+    "docs": " **What it does:** Checks for functions collecting an iterator when collect is not needed.\n\n **Why is this bad?** `collect` causes the allocation of a new data structure,\n when this allocation may not be needed.\n\n **Known problems:**\n None\n\n **Example:**\n ```rust\n # let iterator = vec![1].into_iter();\n let len = iterator.clone().collect::<Vec<_>>().len();\n // should be\n let len = iterator.count();\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": true,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "explicit_counter_loop",
+    "id_span": {
+      "path": "clippy_lints/src/loops.rs",
+      "line": 289
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks `for` loops over slices with an explicit counter and suggests the use of `.enumerate()`.\n\n **Why is it bad?** Using `.enumerate()` makes the intent more clear,\n declutters the code and may be faster in some instances.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # let v = vec![1];\n # fn bar(bar: usize, baz: usize) {}\n let mut i = 0;\n for item in &v {\n     bar(i, *item);\n     i += 1;\n }\n ```\n Could be written as\n ```rust\n # let v = vec![1];\n # fn bar(bar: usize, baz: usize) {}\n for (i, item) in v.iter().enumerate() { bar(i, *item); }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "empty_loop",
+    "id_span": {
+      "path": "clippy_lints/src/loops.rs",
+      "line": 322
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for empty `loop` expressions.\n **Why is this bad?** These busy loops burn CPU cycles without doing\n anything. It is _almost always_ a better idea to `panic!` than to have\n a busy loop.\n\n If panicking isn't possible, think of the environment and either:\n   - block on something\n   - sleep the thread for some microseconds\n   - yield or pause the thread\n\n For `std` targets, this can be done with\n [`std::thread::sleep`](https://doc.rust-lang.org/std/thread/fn.sleep.html)\n or [`std::thread::yield_now`](https://doc.rust-lang.org/std/thread/fn.yield_now.html).\n\n For `no_std` targets, doing this is more complicated, especially because\n `#[panic_handler]`s can't panic. To stop/pause the thread, you will\n probably need to invoke some target-specific intrinsic. Examples include:\n   - [`x86_64::instructions::hlt`](https://docs.rs/x86_64/0.12.2/x86_64/instructions/fn.hlt.html)\n   - [`cortex_m::asm::wfi`](https://docs.rs/cortex-m/0.6.3/cortex_m/asm/fn.wfi.html)\n\n **Known problems:** None.\n\n **Example:**\n ```no_run\n loop {}\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "while_let_on_iterator",
+    "id_span": {
+      "path": "clippy_lints/src/loops.rs",
+      "line": 341
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for `while let` expressions on iterators.\n **Why is this bad?** Readability. A simple `for` loop is shorter and conveys\n the intent better.\n\n **Known problems:** None.\n\n **Example:**\n ```ignore\n while let Some(val) = iter() {\n     ..\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "for_kv_map",
+    "id_span": {
+      "path": "clippy_lints/src/loops.rs",
+      "line": 369
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for iterating a map (`HashMap` or `BTreeMap`) and ignoring either the keys or values.\n\n **Why is this bad?** Readability. There are `keys` and `values` methods that\n can be used to express that don't need the values or keys.\n\n **Known problems:** None.\n\n **Example:**\n ```ignore\n for (k, _) in &map {\n     ..\n }\n ```\n\n could be replaced by\n\n ```ignore\n for k in map.keys() {\n     ..\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "never_loop",
+    "id_span": {
+      "path": "clippy_lints/src/loops.rs",
+      "line": 390
+    },
+    "group": "clippy::correctness",
+    "docs": " **What it does:** Checks for loops that will always `break`, `return` or `continue` an outer loop.\n\n **Why is this bad?** This loop never loops, all it does is obfuscating the\n code.\n\n **Known problems:** None\n\n **Example:**\n ```rust\n loop {\n     ..;\n     break;\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "mut_range_bound",
+    "id_span": {
+      "path": "clippy_lints/src/loops.rs",
+      "line": 410
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks for loops which have a range bound that is a mutable variable\n **Why is this bad?** One might think that modifying the mutable variable changes the loop bounds\n\n **Known problems:** None\n\n **Example:**\n ```rust\n let mut foo = 42;\n for i in 0..foo {\n     foo -= 1;\n     println!(\"{}\", i); // prints numbers from 0 to 42, not 0 to 21\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "while_immutable_condition",
+    "id_span": {
+      "path": "clippy_lints/src/loops.rs",
+      "line": 433
+    },
+    "group": "clippy::correctness",
+    "docs": " **What it does:** Checks whether variables used within while loop condition can be (and are) mutated in the body.\n\n **Why is this bad?** If the condition is unchanged, entering the body of the loop\n will lead to an infinite loop.\n\n **Known problems:** If the `while`-loop is in a closure, the check for mutation of the\n condition variables in the body can cause false negatives. For example when only `Upvar` `a` is\n in the condition and only `Upvar` `b` gets mutated in the body, the lint will not trigger.\n\n **Example:**\n ```rust\n let i = 0;\n while i > 10 {\n     println!(\"let me loop forever!\");\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "same_item_push",
+    "id_span": {
+      "path": "clippy_lints/src/loops.rs",
+      "line": 466
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks whether a for loop is being used to push a constant value into a Vec.\n\n **Why is this bad?** This kind of operation can be expressed more succinctly with\n `vec![item;SIZE]` or `vec.resize(NEW_SIZE, item)` and using these alternatives may also\n have better performance.\n **Known problems:** None\n\n **Example:**\n ```rust\n let item1 = 2;\n let item2 = 3;\n let mut vec: Vec<u8> = Vec::new();\n for _ in 0..20 {\n    vec.push(item1);\n }\n for _ in 0..30 {\n     vec.push(item2);\n }\n ```\n could be written as\n ```rust\n let item1 = 2;\n let item2 = 3;\n let mut vec: Vec<u8> = vec![item1; 20];\n vec.resize(20 + 30, item2);\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "single_element_loop",
+    "id_span": {
+      "path": "clippy_lints/src/loops.rs",
+      "line": 491
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks whether a for loop has a single element.\n **Why is this bad?** There is no reason to have a loop of a\n single element.\n **Known problems:** None\n\n **Example:**\n ```rust\n let item1 = 2;\n for item in &[item1] {\n     println!(\"{}\", item);\n }\n ```\n could be written as\n ```rust\n let item1 = 2;\n let item = &item1;\n println!(\"{}\", item);\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "manual_flatten",
+    "id_span": {
+      "path": "clippy_lints/src/loops.rs",
+      "line": 522
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Check for unnecessary `if let` usage in a for loop where only the `Some` or `Ok` variant of the iterator element is used.\n\n **Why is this bad?** It is verbose and can be simplified\n by first calling the `flatten` method on the `Iterator`.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n let x = vec![Some(1), Some(2), Some(3)];\n for n in x {\n     if let Some(n) = n {\n         println!(\"{}\", n);\n     }\n }\n ```\n Use instead:\n ```rust\n let x = vec![Some(1), Some(2), Some(3)];\n for n in x.into_iter().flatten() {\n     println!(\"{}\", n);\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MaybeIncorrect"
+    }
+  },
+  {
+    "id": "macro_use_imports",
+    "id_span": {
+      "path": "clippy_lints/src/macro_use.rs",
+      "line": 25
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Checks for `#[macro_use] use...`.\n **Why is this bad?** Since the Rust 2018 edition you can import\n macro's directly, this is considered idiomatic.\n\n **Known problems:** None.\n\n **Example:**\n ```rust,ignore\n #[macro_use]\n use some_macro;\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MaybeIncorrect"
+    }
+  },
+  {
+    "id": "main_recursion",
+    "id_span": {
+      "path": "clippy_lints/src/main_recursion.rs",
+      "line": 22
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for recursion using the entrypoint.\n **Why is this bad?** Apart from special setups (which we could detect following attributes like #![no_std]),\n recursing into main() seems like an unintuitive antipattern we should be able to detect.\n\n **Known problems:** None.\n\n **Example:**\n ```no_run\n fn main() {\n     main();\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "manual_async_fn",
+    "id_span": {
+      "path": "clippy_lints/src/manual_async_fn.rs",
+      "line": 32
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** It checks for manual implementations of `async` functions.\n **Why is this bad?** It's more idiomatic to use the dedicated syntax.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n use std::future::Future;\n\n fn foo() -> impl Future<Output = i32> { async { 42 } }\n ```\n Use instead:\n ```rust\n async fn foo() -> i32 { 42 }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": true,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "manual_map",
+    "id_span": {
+      "path": "clippy_lints/src/manual_map.rs",
+      "line": 36
+    },
+    "group": "clippy::nursery",
+    "docs": " **What it does:** Checks for usages of `match` which could be implemented using `map`\n **Why is this bad?** Using the `map` method is clearer and more concise.\n\n **Known problems:** `map` is not capable of representing some control flow which works fine in `match`.\n\n **Example:**\n\n ```rust\n match Some(0) {\n     Some(x) => Some(x + 1),\n     None => None,\n };\n ```\n Use instead:\n ```rust\n Some(0).map(|x| x + 1);\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "manual_non_exhaustive",
+    "id_span": {
+      "path": "clippy_lints/src/manual_non_exhaustive.rs",
+      "line": 56
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for manual implementations of the non-exhaustive pattern.\n **Why is this bad?** Using the #[non_exhaustive] attribute expresses better the intent\n and allows possible optimizations when applied to enums.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n struct S {\n     pub a: i32,\n     pub b: i32,\n     _c: (),\n }\n\n enum E {\n     A,\n     B,\n     #[doc(hidden)]\n     _C,\n }\n\n struct T(pub i32, pub i32, ());\n ```\n Use instead:\n ```rust\n #[non_exhaustive]\n struct S {\n     pub a: i32,\n     pub b: i32,\n }\n\n #[non_exhaustive]\n enum E {\n     A,\n     B,\n }\n\n #[non_exhaustive]\n struct T(pub i32, pub i32);\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "Unspecified"
+    }
+  },
+  {
+    "id": "manual_ok_or",
+    "id_span": {
+      "path": "clippy_lints/src/manual_ok_or.rs",
+      "line": 34
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Finds patterns that reimplement `Option::ok_or`.\n\n **Why is this bad?**\n Concise code helps focusing on behavior instead of boilerplate.\n\n **Known problems:** None.\n\n **Examples:**\n ```rust\n let foo: Option<i32> = None;\n foo.map_or(Err(\"error\"), |v| Ok(v));\n ```\n\n Use instead:\n ```rust\n let foo: Option<i32> = None;\n foo.ok_or(\"error\");\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "manual_strip",
+    "id_span": {
+      "path": "clippy_lints/src/manual_strip.rs",
+      "line": 52
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Suggests using `strip_{prefix,suffix}` over `str::{starts,ends}_with` and slicing using\n the pattern's length.\n\n **Why is this bad?**\n Using `str:strip_{prefix,suffix}` is safer and may have better performance as there is no\n slicing which may panic and the compiler does not need to insert this panic code. It is\n also sometimes more readable as it removes the need for duplicating or storing the pattern\n used by `str::{starts,ends}_with` and in the slicing.\n\n **Known problems:**\n None.\n\n **Example:**\n\n ```rust\n let s = \"hello, world!\";\n if s.starts_with(\"hello, \") {\n     assert_eq!(s[\"hello, \".len()..].to_uppercase(), \"WORLD!\");\n }\n ```\n Use instead:\n ```rust\n let s = \"hello, world!\";\n if let Some(end) = s.strip_prefix(\"hello, \") {\n     assert_eq!(end.to_uppercase(), \"WORLD!\");\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "manual_unwrap_or",
+    "id_span": {
+      "path": "clippy_lints/src/manual_unwrap_or.rs",
+      "line": 36
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Finds patterns that reimplement `Option::unwrap_or` or `Result::unwrap_or`.\n\n **Why is this bad?**\n Concise code helps focusing on behavior instead of boilerplate.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n let foo: Option<i32> = None;\n match foo {\n     Some(v) => v,\n     None => 1,\n };\n ```\n\n Use instead:\n ```rust\n let foo: Option<i32> = None;\n foo.unwrap_or(1);\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "map_clone",
+    "id_span": {
+      "path": "clippy_lints/src/map_clone.rs",
+      "line": 40
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for usage of `map(|x| x.clone())` or dereferencing closures for `Copy` types, on `Iterator` or `Option`,\n and suggests `cloned()` or `copied()` instead\n\n **Why is this bad?** Readability, this can be written more concisely\n\n **Known problems:** None\n\n **Example:**\n\n ```rust\n let x = vec![42, 43];\n let y = x.iter();\n let z = y.map(|i| *i);\n ```\n\n The correct use would be:\n\n ```rust\n let x = vec![42, 43];\n let y = x.iter();\n let z = y.cloned();\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "map_err_ignore",
+    "id_span": {
+      "path": "clippy_lints/src/map_err_ignore.rs",
+      "line": 101
+    },
+    "group": "clippy::restriction",
+    "docs": " **What it does:** Checks for instances of `map_err(|_| Some::Enum)`\n **Why is this bad?** This `map_err` throws away the original error rather than allowing the enum to contain and report the cause of the error\n\n **Known problems:** None.\n\n **Example:**\n Before:\n ```rust\n use std::fmt;\n\n #[derive(Debug)]\n enum Error {\n     Indivisible,\n     Remainder(u8),\n }\n\n impl fmt::Display for Error {\n     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\n         match self {\n             Error::Indivisible => write!(f, \"could not divide input by three\"),\n             Error::Remainder(remainder) => write!(\n                 f,\n                 \"input is not divisible by three, remainder = {}\",\n                 remainder\n             ),\n         }\n     }\n }\n\n impl std::error::Error for Error {}\n\n fn divisible_by_3(input: &str) -> Result<(), Error> {\n     input\n         .parse::<i32>()\n         .map_err(|_| Error::Indivisible)\n         .map(|v| v % 3)\n         .and_then(|remainder| {\n             if remainder == 0 {\n                 Ok(())\n             } else {\n                 Err(Error::Remainder(remainder as u8))\n             }\n         })\n }\n  ```\n\n  After:\n  ```rust\n use std::{fmt, num::ParseIntError};\n\n #[derive(Debug)]\n enum Error {\n     Indivisible(ParseIntError),\n     Remainder(u8),\n }\n\n impl fmt::Display for Error {\n     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\n         match self {\n             Error::Indivisible(_) => write!(f, \"could not divide input by three\"),\n             Error::Remainder(remainder) => write!(\n                 f,\n                 \"input is not divisible by three, remainder = {}\",\n                 remainder\n             ),\n         }\n     }\n }\n\n impl std::error::Error for Error {\n     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {\n         match self {\n             Error::Indivisible(source) => Some(source),\n             _ => None,\n         }\n     }\n }\n\n fn divisible_by_3(input: &str) -> Result<(), Error> {\n     input\n         .parse::<i32>()\n         .map_err(Error::Indivisible)\n         .map(|v| v % 3)\n         .and_then(|remainder| {\n             if remainder == 0 {\n                 Ok(())\n             } else {\n                 Err(Error::Remainder(remainder as u8))\n             }\n         })\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "map_identity",
+    "id_span": {
+      "path": "clippy_lints/src/map_identity.rs",
+      "line": 30
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks for instances of `map(f)` where `f` is the identity function.\n **Why is this bad?** It can be written more concisely without the call to `map`.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n let x = [1, 2, 3];\n let y: Vec<_> = x.iter().map(|x| x).map(|x| 2*x).collect();\n ```\n Use instead:\n ```rust\n let x = [1, 2, 3];\n let y: Vec<_> = x.iter().map(|x| 2*x).collect();\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "option_map_unit_fn",
+    "id_span": {
+      "path": "clippy_lints/src/map_unit_fn.rs",
+      "line": 48
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks for usage of `option.map(f)` where f is a function or closure that returns the unit type `()`.\n\n **Why is this bad?** Readability, this can be written more clearly with\n an if let statement\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n # fn do_stuff() -> Option<String> { Some(String::new()) }\n # fn log_err_msg(foo: String) -> Option<String> { Some(foo) }\n # fn format_msg(foo: String) -> String { String::new() }\n let x: Option<String> = do_stuff();\n x.map(log_err_msg);\n # let x: Option<String> = do_stuff();\n x.map(|msg| log_err_msg(format_msg(msg)));\n ```\n\n The correct use would be:\n\n ```rust\n # fn do_stuff() -> Option<String> { Some(String::new()) }\n # fn log_err_msg(foo: String) -> Option<String> { Some(foo) }\n # fn format_msg(foo: String) -> String { String::new() }\n let x: Option<String> = do_stuff();\n if let Some(msg) = x {\n     log_err_msg(msg);\n }\n\n # let x: Option<String> = do_stuff();\n if let Some(msg) = x {\n     log_err_msg(format_msg(msg));\n }\n ```\n",
+    "applicability": null
+  },
+  {
+    "id": "result_map_unit_fn",
+    "id_span": {
+      "path": "clippy_lints/src/map_unit_fn.rs",
+      "line": 89
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks for usage of `result.map(f)` where f is a function or closure that returns the unit type `()`.\n\n **Why is this bad?** Readability, this can be written more clearly with\n an if let statement\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n # fn do_stuff() -> Result<String, String> { Ok(String::new()) }\n # fn log_err_msg(foo: String) -> Result<String, String> { Ok(foo) }\n # fn format_msg(foo: String) -> String { String::new() }\n let x: Result<String, String> = do_stuff();\n x.map(log_err_msg);\n # let x: Result<String, String> = do_stuff();\n x.map(|msg| log_err_msg(format_msg(msg)));\n ```\n\n The correct use would be:\n\n ```rust\n # fn do_stuff() -> Result<String, String> { Ok(String::new()) }\n # fn log_err_msg(foo: String) -> Result<String, String> { Ok(foo) }\n # fn format_msg(foo: String) -> String { String::new() }\n let x: Result<String, String> = do_stuff();\n if let Ok(msg) = x {\n     log_err_msg(msg);\n };\n # let x: Result<String, String> = do_stuff();\n if let Ok(msg) = x {\n     log_err_msg(format_msg(msg));\n };\n ```\n",
+    "applicability": null
+  },
+  {
+    "id": "match_on_vec_items",
+    "id_span": {
+      "path": "clippy_lints/src/match_on_vec_items.rs",
+      "line": 41
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Checks for `match vec[idx]` or `match vec[n..m]`.\n **Why is this bad?** This can panic at runtime.\n\n **Known problems:** None.\n\n **Example:**\n ```rust, no_run\n let arr = vec![0, 1, 2, 3];\n let idx = 1;\n\n // Bad\n match arr[idx] {\n     0 => println!(\"{}\", 0),\n     1 => println!(\"{}\", 3),\n     _ => {},\n }\n ```\n Use instead:\n ```rust, no_run\n let arr = vec![0, 1, 2, 3];\n let idx = 1;\n\n // Good\n match arr.get(idx) {\n     Some(0) => println!(\"{}\", 0),\n     Some(1) => println!(\"{}\", 3),\n     _ => {},\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MaybeIncorrect"
+    }
+  },
+  {
+    "id": "single_match",
+    "id_span": {
+      "path": "clippy_lints/src/matches.rs",
+      "line": 55
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for matches with a single arm where an `if let` will usually suffice.\n\n **Why is this bad?** Just readability – `if let` nests less than a `match`.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # fn bar(stool: &str) {}\n # let x = Some(\"abc\");\n // Bad\n match x {\n     Some(ref foo) => bar(foo),\n     _ => (),\n }\n\n // Good\n if let Some(ref foo) = x {\n     bar(foo);\n }\n ```\n",
+    "applicability": null
+  },
+  {
+    "id": "single_match_else",
+    "id_span": {
+      "path": "clippy_lints/src/matches.rs",
+      "line": 94
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Checks for matches with two arms where an `if let else` will usually suffice.\n\n **Why is this bad?** Just readability – `if let` nests less than a `match`.\n\n **Known problems:** Personal style preferences may differ.\n\n **Example:**\n\n Using `match`:\n\n ```rust\n # fn bar(foo: &usize) {}\n # let other_ref: usize = 1;\n # let x: Option<&usize> = Some(&1);\n match x {\n     Some(ref foo) => bar(foo),\n     _ => bar(&other_ref),\n }\n ```\n\n Using `if let` with `else`:\n\n ```rust\n # fn bar(foo: &usize) {}\n # let other_ref: usize = 1;\n # let x: Option<&usize> = Some(&1);\n if let Some(ref foo) = x {\n     bar(foo);\n } else {\n     bar(&other_ref);\n }\n ```\n",
+    "applicability": null
+  },
+  {
+    "id": "match_ref_pats",
+    "id_span": {
+      "path": "clippy_lints/src/matches.rs",
+      "line": 125
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for matches where all arms match a reference, suggesting to remove the reference and deref the matched expression\n instead. It also checks for `if let &foo = bar` blocks.\n\n **Why is this bad?** It just makes the code less readable. That reference\n destructuring adds nothing to the code.\n\n **Known problems:** None.\n\n **Example:**\n ```rust,ignore\n // Bad\n match x {\n     &A(ref y) => foo(y),\n     &B => bar(),\n     _ => frob(&x),\n }\n\n // Good\n match *x {\n     A(ref y) => foo(y),\n     B => bar(),\n     _ => frob(x),\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "match_bool",
+    "id_span": {
+      "path": "clippy_lints/src/matches.rs",
+      "line": 159
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Checks for matches where match expression is a `bool`. It suggests to replace the expression with an `if...else` block.\n\n **Why is this bad?** It makes the code less readable.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # fn foo() {}\n # fn bar() {}\n let condition: bool = true;\n match condition {\n     true => foo(),\n     false => bar(),\n }\n ```\n Use if/else instead:\n ```rust\n # fn foo() {}\n # fn bar() {}\n let condition: bool = true;\n if condition {\n     foo();\n } else {\n     bar();\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "HasPlaceholders"
+    }
+  },
+  {
+    "id": "match_overlapping_arm",
+    "id_span": {
+      "path": "clippy_lints/src/matches.rs",
+      "line": 181
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for overlapping match arms.\n **Why is this bad?** It is likely to be an error and if not, makes the code\n less obvious.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n let x = 5;\n match x {\n     1...10 => println!(\"1 ... 10\"),\n     5...15 => println!(\"5 ... 15\"),\n     _ => (),\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "match_wild_err_arm",
+    "id_span": {
+      "path": "clippy_lints/src/matches.rs",
+      "line": 203
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Checks for arm which matches all errors with `Err(_)` and take drastic actions like `panic!`.\n\n **Why is this bad?** It is generally a bad practice, similar to\n catching all exceptions in java with `catch(Exception)`\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n let x: Result<i32, &str> = Ok(3);\n match x {\n     Ok(_) => println!(\"ok\"),\n     Err(_) => panic!(\"err\"),\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "match_as_ref",
+    "id_span": {
+      "path": "clippy_lints/src/matches.rs",
+      "line": 229
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks for match which is used to add a reference to an `Option` value.\n\n **Why is this bad?** Using `as_ref()` or `as_mut()` instead is shorter.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n let x: Option<()> = None;\n\n // Bad\n let r: Option<&()> = match x {\n     None => None,\n     Some(ref v) => Some(v),\n };\n\n // Good\n let r: Option<&()> = x.as_ref();\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "wildcard_enum_match_arm",
+    "id_span": {
+      "path": "clippy_lints/src/matches.rs",
+      "line": 258
+    },
+    "group": "clippy::restriction",
+    "docs": " **What it does:** Checks for wildcard enum matches using `_`.\n **Why is this bad?** New enum variants added by library updates can be missed.\n\n **Known problems:** Suggested replacements may be incorrect if guards exhaustively cover some\n variants, and also may not use correct path to enum if it's not present in the current scope.\n\n **Example:**\n ```rust\n # enum Foo { A(usize), B(usize) }\n # let x = Foo::B(1);\n // Bad\n match x {\n     Foo::A(_) => {},\n     _ => {},\n }\n\n // Good\n match x {\n     Foo::A(_) => {},\n     Foo::B(_) => {},\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MaybeIncorrect"
+    }
+  },
+  {
+    "id": "match_wildcard_for_single_variants",
+    "id_span": {
+      "path": "clippy_lints/src/matches.rs",
+      "line": 290
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Checks for wildcard enum matches for a single variant.\n **Why is this bad?** New enum variants added by library updates can be missed.\n\n **Known problems:** Suggested replacements may not use correct path to enum\n if it's not present in the current scope.\n\n **Example:**\n\n ```rust\n # enum Foo { A, B, C }\n # let x = Foo::B;\n // Bad\n match x {\n     Foo::A => {},\n     Foo::B => {},\n     _ => {},\n }\n\n // Good\n match x {\n     Foo::A => {},\n     Foo::B => {},\n     Foo::C => {},\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MaybeIncorrect"
+    }
+  },
+  {
+    "id": "wildcard_in_or_patterns",
+    "id_span": {
+      "path": "clippy_lints/src/matches.rs",
+      "line": 317
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks for wildcard pattern used with others patterns in same match arm.\n **Why is this bad?** Wildcard pattern already covers any other pattern as it will match anyway.\n It makes the code less readable, especially to spot wildcard pattern use in match arm.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n // Bad\n match \"foo\" {\n     \"a\" => {},\n     \"bar\" | _ => {},\n }\n\n // Good\n match \"foo\" {\n     \"a\" => {},\n     _ => {},\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "infallible_destructuring_match",
+    "id_span": {
+      "path": "clippy_lints/src/matches.rs",
+      "line": 352
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for matches being used to destructure a single-variant enum or tuple struct where a `let` will suffice.\n\n **Why is this bad?** Just readability – `let` doesn't nest, whereas a `match` does.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n enum Wrapper {\n     Data(i32),\n }\n\n let wrapper = Wrapper::Data(42);\n\n let data = match wrapper {\n     Wrapper::Data(i) => i,\n };\n ```\n\n The correct use would be:\n ```rust\n enum Wrapper {\n     Data(i32),\n }\n\n let wrapper = Wrapper::Data(42);\n let Wrapper::Data(data) = wrapper;\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "match_single_binding",
+    "id_span": {
+      "path": "clippy_lints/src/matches.rs",
+      "line": 380
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks for useless match that binds to only one value.\n **Why is this bad?** Readability and needless complexity.\n\n **Known problems:**  Suggested replacements may be incorrect when `match`\n is actually binding temporary value, bringing a 'dropped while borrowed' error.\n\n **Example:**\n ```rust\n # let a = 1;\n # let b = 2;\n\n // Bad\n match (a, b) {\n     (c, d) => {\n         // useless match\n     }\n }\n\n // Good\n let (c, d) = (a, b);\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "rest_pat_in_fully_bound_structs",
+    "id_span": {
+      "path": "clippy_lints/src/matches.rs",
+      "line": 410
+    },
+    "group": "clippy::restriction",
+    "docs": " **What it does:** Checks for unnecessary '..' pattern binding on struct when all fields are explicitly matched.\n **Why is this bad?** Correctness and readability. It's like having a wildcard pattern after\n matching all enum variants explicitly.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # struct A { a: i32 }\n let a = A { a: 5 };\n\n // Bad\n match a {\n     A { a: 5, .. } => {},\n     _ => {},\n }\n\n // Good\n match a {\n     A { a: 5 } => {},\n     _ => {},\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "redundant_pattern_matching",
+    "id_span": {
+      "path": "clippy_lints/src/matches.rs",
+      "line": 458
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Lint for redundant pattern matching over `Result`, `Option`, `std::task::Poll` or `std::net::IpAddr`\n\n **Why is this bad?** It's more concise and clear to just use the proper\n utility function\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n # use std::task::Poll;\n # use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};\n if let Ok(_) = Ok::<i32, i32>(42) {}\n if let Err(_) = Err::<i32, i32>(42) {}\n if let None = None::<()> {}\n if let Some(_) = Some(42) {}\n if let Poll::Pending = Poll::Pending::<()> {}\n if let Poll::Ready(_) = Poll::Ready(42) {}\n if let IpAddr::V4(_) = IpAddr::V4(Ipv4Addr::LOCALHOST) {}\n if let IpAddr::V6(_) = IpAddr::V6(Ipv6Addr::LOCALHOST) {}\n match Ok::<i32, i32>(42) {\n     Ok(_) => true,\n     Err(_) => false,\n };\n ```\n\n The more idiomatic use would be:\n\n ```rust\n # use std::task::Poll;\n # use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};\n if Ok::<i32, i32>(42).is_ok() {}\n if Err::<i32, i32>(42).is_err() {}\n if None::<()>.is_none() {}\n if Some(42).is_some() {}\n if Poll::Pending::<()>.is_pending() {}\n if Poll::Ready(42).is_ready() {}\n if IpAddr::V4(Ipv4Addr::LOCALHOST).is_ipv4() {}\n if IpAddr::V6(Ipv6Addr::LOCALHOST).is_ipv6() {}\n Ok::<i32, i32>(42).is_ok();\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MaybeIncorrect"
+    }
+  },
+  {
+    "id": "match_like_matches_macro",
+    "id_span": {
+      "path": "clippy_lints/src/matches.rs",
+      "line": 491
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for `match`  or `if let` expressions producing a `bool` that could be written using `matches!`\n\n **Why is this bad?** Readability and needless complexity.\n\n **Known problems:** This lint falsely triggers, if there are arms with\n `cfg` attributes that remove an arm evaluating to `false`.\n\n **Example:**\n ```rust\n let x = Some(5);\n\n // Bad\n let a = match x {\n     Some(0) => true,\n     _ => false,\n };\n\n let a = if let Some(0) = x {\n     true\n } else {\n     false\n };\n\n // Good\n let a = matches!(x, Some(0));\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MaybeIncorrect"
+    }
+  },
+  {
+    "id": "match_same_arms",
+    "id_span": {
+      "path": "clippy_lints/src/matches.rs",
+      "line": 532
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Checks for `match` with identical arm bodies.\n **Why is this bad?** This is probably a copy & paste error. If arm bodies\n are the same on purpose, you can factor them\n [using `|`](https://doc.rust-lang.org/book/patterns.html#multiple-patterns).\n\n **Known problems:** False positive possible with order dependent `match`\n (see issue\n [#860](https://github.com/rust-lang/rust-clippy/issues/860)).\n\n **Example:**\n ```rust,ignore\n match foo {\n     Bar => bar(),\n     Quz => quz(),\n     Baz => bar(), // <= oops\n }\n ```\n\n This should probably be\n ```rust,ignore\n match foo {\n     Bar => bar(),\n     Quz => quz(),\n     Baz => baz(), // <= fixed\n }\n ```\n\n or if the original code was not a typo:\n ```rust,ignore\n match foo {\n     Bar | Baz => bar(), // <= shows the intent better\n     Quz => quz(),\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "mem_discriminant_non_enum",
+    "id_span": {
+      "path": "clippy_lints/src/mem_discriminant.rs",
+      "line": 25
+    },
+    "group": "clippy::correctness",
+    "docs": " **What it does:** Checks for calls of `mem::discriminant()` on a non-enum type.\n **Why is this bad?** The value of `mem::discriminant()` on non-enum types\n is unspecified.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n use std::mem;\n\n mem::discriminant(&\"hello\");\n mem::discriminant(&&Some(2));\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "mem_forget",
+    "id_span": {
+      "path": "clippy_lints/src/mem_forget.rs",
+      "line": 21
+    },
+    "group": "clippy::restriction",
+    "docs": " **What it does:** Checks for usage of `std::mem::forget(t)` where `t` is `Drop`.\n\n **Why is this bad?** `std::mem::forget(t)` prevents `t` from running its\n destructor, possibly causing leaks.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # use std::mem;\n # use std::rc::Rc;\n mem::forget(Rc::new(55))\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "mem_replace_option_with_none",
+    "id_span": {
+      "path": "clippy_lints/src/mem_replace.rs",
+      "line": 37
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for `mem::replace()` on an `Option` with `None`.\n\n **Why is this bad?** `Option` already has the method `take()` for\n taking its current value (Some(..) or None) and replacing it with\n `None`.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n use std::mem;\n\n let mut an_option = Some(0);\n let replaced = mem::replace(&mut an_option, None);\n ```\n Is better expressed with:\n ```rust\n let mut an_option = Some(0);\n let taken = an_option.take();\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "mem_replace_with_uninit",
+    "id_span": {
+      "path": "clippy_lints/src/mem_replace.rs",
+      "line": 69
+    },
+    "group": "clippy::correctness",
+    "docs": " **What it does:** Checks for `mem::replace(&mut _, mem::uninitialized())` and `mem::replace(&mut _, mem::zeroed())`.\n\n **Why is this bad?** This will lead to undefined behavior even if the\n value is overwritten later, because the uninitialized value may be\n observed in the case of a panic.\n\n **Known problems:** None.\n\n **Example:**\n\n ```\n use std::mem;\n# fn may_panic(v: Vec<i32>) -> Vec<i32> { v }\n\n #[allow(deprecated, invalid_value)]\n fn myfunc (v: &mut Vec<i32>) {\n     let taken_v = unsafe { mem::replace(v, mem::uninitialized()) };\n     let new_v = may_panic(taken_v); // undefined behavior on panic\n     mem::forget(mem::replace(v, new_v));\n }\n ```\n\n The [take_mut](https://docs.rs/take_mut) crate offers a sound solution,\n at the cost of either lazily creating a replacement value or aborting\n on panic, to ensure that the uninitialized value cannot be observed.\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "mem_replace_with_default",
+    "id_span": {
+      "path": "clippy_lints/src/mem_replace.rs",
+      "line": 93
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for `std::mem::replace` on a value of type `T` with `T::default()`.\n\n **Why is this bad?** `std::mem` module already has the method `take` to\n take the current value and replace it with the default value of that type.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n let mut text = String::from(\"foo\");\n let replaced = std::mem::replace(&mut text, String::default());\n ```\n Is better expressed with:\n ```rust\n let mut text = String::from(\"foo\");\n let taken = std::mem::take(&mut text);\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "unwrap_used",
+    "id_span": {
+      "path": "clippy_lints/src/methods/mod.rs",
+      "line": 82
+    },
+    "group": "clippy::restriction",
+    "docs": " **What it does:** Checks for `.unwrap()` calls on `Option`s and on `Result`s.\n **Why is this bad?** It is better to handle the `None` or `Err` case,\n or at least call `.expect(_)` with a more helpful message. Still, for a lot of\n quick-and-dirty code, `unwrap` is a good choice, which is why this lint is\n `Allow` by default.\n\n `result.unwrap()` will let the thread panic on `Err` values.\n Normally, you want to implement more sophisticated error handling,\n and propagate errors upwards with `?` operator.\n\n Even if you want to panic on errors, not all `Error`s implement good\n messages on display. Therefore, it may be beneficial to look at the places\n where they may get displayed. Activate this lint to do just that.\n\n **Known problems:** None.\n\n **Examples:**\n ```rust\n # let opt = Some(1);\n\n // Bad\n opt.unwrap();\n\n // Good\n opt.expect(\"more helpful message\");\n ```\n\n // or\n\n ```rust\n # let res: Result<usize, ()> = Ok(1);\n\n // Bad\n res.unwrap();\n\n // Good\n res.expect(\"more helpful message\");\n ```\n",
+    "applicability": null
+  },
+  {
+    "id": "expect_used",
+    "id_span": {
+      "path": "clippy_lints/src/methods/mod.rs",
+      "line": 124
+    },
+    "group": "clippy::restriction",
+    "docs": " **What it does:** Checks for `.expect()` calls on `Option`s and `Result`s.\n **Why is this bad?** Usually it is better to handle the `None` or `Err` case.\n Still, for a lot of quick-and-dirty code, `expect` is a good choice, which is why\n this lint is `Allow` by default.\n\n `result.expect()` will let the thread panic on `Err`\n values. Normally, you want to implement more sophisticated error handling,\n and propagate errors upwards with `?` operator.\n\n **Known problems:** None.\n\n **Examples:**\n ```rust,ignore\n # let opt = Some(1);\n\n // Bad\n opt.expect(\"one\");\n\n // Good\n let opt = Some(1);\n opt?;\n ```\n\n // or\n\n ```rust\n # let res: Result<usize, ()> = Ok(1);\n\n // Bad\n res.expect(\"one\");\n\n // Good\n res?;\n # Ok::<(), ()>(())\n ```\n",
+    "applicability": null
+  },
+  {
+    "id": "should_implement_trait",
+    "id_span": {
+      "path": "clippy_lints/src/methods/mod.rs",
+      "line": 153
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for methods that should live in a trait implementation of a `std` trait (see [llogiq's blog\n post](http://llogiq.github.io/2015/07/30/traits.html) for further\n information) instead of an inherent implementation.\n\n **Why is this bad?** Implementing the traits improve ergonomics for users of\n the code, often with very little cost. Also people seeing a `mul(...)`\n method\n may expect `*` to work equally, so you should have good reason to disappoint\n them.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n struct X;\n impl X {\n     fn add(&self, other: &X) -> X {\n         // ..\n # X\n     }\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "wrong_self_convention",
+    "id_span": {
+      "path": "clippy_lints/src/methods/mod.rs",
+      "line": 186
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for methods with certain name prefixes and which doesn't match how self is taken. The actual rules are:\n\n |Prefix |`self` taken          |\n |-------|----------------------|\n |`as_`  |`&self` or `&mut self`|\n |`from_`| none                 |\n |`into_`|`self`                |\n |`is_`  |`&self` or none       |\n |`to_`  |`&self`               |\n\n **Why is this bad?** Consistency breeds readability. If you follow the\n conventions, your users won't be surprised that they, e.g., need to supply a\n mutable reference to a `as_..` function.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # struct X;\n impl X {\n     fn as_str(self) -> &'static str {\n         // ..\n # \"\"\n     }\n }\n ```\n",
+    "applicability": null
+  },
+  {
+    "id": "wrong_pub_self_convention",
+    "id_span": {
+      "path": "clippy_lints/src/methods/mod.rs",
+      "line": 210
+    },
+    "group": "clippy::restriction",
+    "docs": " **What it does:** This is the same as [`wrong_self_convention`](#wrong_self_convention), but for public items.\n\n **Why is this bad?** See [`wrong_self_convention`](#wrong_self_convention).\n\n **Known problems:** Actually *renaming* the function may break clients if\n the function is part of the public interface. In that case, be mindful of\n the stability guarantees you've given your users.\n\n **Example:**\n ```rust\n # struct X;\n impl<'a> X {\n     pub fn as_str(self) -> &'a str {\n         \"foo\"\n     }\n }\n ```\n",
+    "applicability": null
+  },
+  {
+    "id": "ok_expect",
+    "id_span": {
+      "path": "clippy_lints/src/methods/mod.rs",
+      "line": 233
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for usage of `ok().expect(..)`.\n **Why is this bad?** Because you usually call `expect()` on the `Result`\n directly to get a better error message.\n\n **Known problems:** The error type needs to implement `Debug`\n\n **Example:**\n ```rust\n # let x = Ok::<_, ()>(());\n\n // Bad\n x.ok().expect(\"why did I do this again?\");\n\n // Good\n x.expect(\"why did I do this again?\");\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "map_unwrap_or",
+    "id_span": {
+      "path": "clippy_lints/src/methods/mod.rs",
+      "line": 270
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Checks for usage of `option.map(_).unwrap_or(_)` or `option.map(_).unwrap_or_else(_)` or `result.map(_).unwrap_or_else(_)`.\n\n **Why is this bad?** Readability, these can be written more concisely (resp.) as\n `option.map_or(_, _)`, `option.map_or_else(_, _)` and `result.map_or_else(_, _)`.\n\n **Known problems:** The order of the arguments is not in execution order\n\n **Examples:**\n ```rust\n # let x = Some(1);\n\n // Bad\n x.map(|a| a + 1).unwrap_or(0);\n\n // Good\n x.map_or(0, |a| a + 1);\n ```\n\n // or\n\n ```rust\n # let x: Result<usize, ()> = Ok(1);\n # fn some_function(foo: ()) -> usize { 1 }\n\n // Bad\n x.map(|a| a + 1).unwrap_or_else(some_function);\n\n // Good\n x.map_or_else(some_function, |a| a + 1);\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "option_map_or_none",
+    "id_span": {
+      "path": "clippy_lints/src/methods/mod.rs",
+      "line": 293
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for usage of `_.map_or(None, _)`.\n **Why is this bad?** Readability, this can be written more concisely as\n `_.and_then(_)`.\n\n **Known problems:** The order of the arguments is not in execution order.\n\n **Example:**\n ```rust\n # let opt = Some(1);\n\n // Bad\n opt.map_or(None, |a| Some(a + 1));\n\n // Good\n opt.and_then(|a| Some(a + 1));\n ```\n",
+    "applicability": null
+  },
+  {
+    "id": "result_map_or_into_option",
+    "id_span": {
+      "path": "clippy_lints/src/methods/mod.rs",
+      "line": 319
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for usage of `_.map_or(None, Some)`.\n **Why is this bad?** Readability, this can be written more concisely as\n `_.ok()`.\n\n **Known problems:** None.\n\n **Example:**\n\n Bad:\n ```rust\n # let r: Result<u32, &str> = Ok(1);\n assert_eq!(Some(1), r.map_or(None, Some));\n ```\n\n Good:\n ```rust\n # let r: Result<u32, &str> = Ok(1);\n assert_eq!(Some(1), r.ok());\n ```\n",
+    "applicability": null
+  },
+  {
+    "id": "bind_instead_of_map",
+    "id_span": {
+      "path": "clippy_lints/src/methods/mod.rs",
+      "line": 352
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks for usage of `_.and_then(|x| Some(y))`, `_.and_then(|x| Ok(y))` or `_.or_else(|x| Err(y))`.\n\n **Why is this bad?** Readability, this can be written more concisely as\n `_.map(|x| y)` or `_.map_err(|x| y)`.\n\n **Known problems:** None\n\n **Example:**\n\n ```rust\n # fn opt() -> Option<&'static str> { Some(\"42\") }\n # fn res() -> Result<&'static str, &'static str> { Ok(\"42\") }\n let _ = opt().and_then(|s| Some(s.len()));\n let _ = res().and_then(|s| if s.len() == 42 { Ok(10) } else { Ok(20) });\n let _ = res().or_else(|s| if s.len() == 42 { Err(10) } else { Err(20) });\n ```\n\n The correct use would be:\n\n ```rust\n # fn opt() -> Option<&'static str> { Some(\"42\") }\n # fn res() -> Result<&'static str, &'static str> { Ok(\"42\") }\n let _ = opt().map(|s| s.len());\n let _ = res().map(|s| if s.len() == 42 { 10 } else { 20 });\n let _ = res().map_err(|s| if s.len() == 42 { 10 } else { 20 });\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "filter_next",
+    "id_span": {
+      "path": "clippy_lints/src/methods/mod.rs",
+      "line": 375
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks for usage of `_.filter(_).next()`.\n **Why is this bad?** Readability, this can be written more concisely as\n `_.find(_)`.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # let vec = vec![1];\n vec.iter().filter(|x| **x == 0).next();\n ```\n Could be written as\n ```rust\n # let vec = vec![1];\n vec.iter().find(|x| **x == 0);\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "skip_while_next",
+    "id_span": {
+      "path": "clippy_lints/src/methods/mod.rs",
+      "line": 398
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks for usage of `_.skip_while(condition).next()`.\n **Why is this bad?** Readability, this can be written more concisely as\n `_.find(!condition)`.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # let vec = vec![1];\n vec.iter().skip_while(|x| **x == 0).next();\n ```\n Could be written as\n ```rust\n # let vec = vec![1];\n vec.iter().find(|x| **x != 0);\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "map_flatten",
+    "id_span": {
+      "path": "clippy_lints/src/methods/mod.rs",
+      "line": 421
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Checks for usage of `_.map(_).flatten(_)`,\n **Why is this bad?** Readability, this can be written more concisely as\n `_.flat_map(_)`\n\n **Known problems:**\n\n **Example:**\n ```rust\n let vec = vec![vec![1]];\n\n // Bad\n vec.iter().map(|x| x.iter()).flatten();\n\n // Good\n vec.iter().flat_map(|x| x.iter());\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "filter_map",
+    "id_span": {
+      "path": "clippy_lints/src/methods/mod.rs",
+      "line": 450
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Checks for usage of `_.filter(_).map(_)`, `_.filter(_).flat_map(_)`, `_.filter_map(_).flat_map(_)` and similar.\n\n **Why is this bad?** Readability, this can be written more concisely as\n `_.filter_map(_)`.\n\n **Known problems:** Often requires a condition + Option/Iterator creation\n inside the closure.\n\n **Example:**\n ```rust\n let vec = vec![1];\n\n // Bad\n vec.iter().filter(|x| **x == 0).map(|x| *x * 2);\n\n // Good\n vec.iter().filter_map(|x| if *x == 0 {\n     Some(*x * 2)\n } else {\n     None\n });\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "manual_filter_map",
+    "id_span": {
+      "path": "clippy_lints/src/methods/mod.rs",
+      "line": 476
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks for usage of `_.filter(_).map(_)` that can be written more simply as `filter_map(_)`.\n\n **Why is this bad?** Redundant code in the `filter` and `map` operations is poor style and\n less performant.\n\n **Known problems:** None.\n\n **Example:**\n Bad:\n ```rust\n (0_i32..10)\n     .filter(|n| n.checked_add(1).is_some())\n     .map(|n| n.checked_add(1).unwrap());\n ```\n\n Good:\n ```rust\n (0_i32..10).filter_map(|n| n.checked_add(1));\n ```\n",
+    "applicability": null
+  },
+  {
+    "id": "manual_find_map",
+    "id_span": {
+      "path": "clippy_lints/src/methods/mod.rs",
+      "line": 502
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks for usage of `_.find(_).map(_)` that can be written more simply as `find_map(_)`.\n\n **Why is this bad?** Redundant code in the `find` and `map` operations is poor style and\n less performant.\n\n **Known problems:** None.\n\n **Example:**\n Bad:\n ```rust\n (0_i32..10)\n     .find(|n| n.checked_add(1).is_some())\n     .map(|n| n.checked_add(1).unwrap());\n ```\n\n Good:\n ```rust\n (0_i32..10).find_map(|n| n.checked_add(1));\n ```\n",
+    "applicability": null
+  },
+  {
+    "id": "filter_map_next",
+    "id_span": {
+      "path": "clippy_lints/src/methods/mod.rs",
+      "line": 524
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Checks for usage of `_.filter_map(_).next()`.\n **Why is this bad?** Readability, this can be written more concisely as\n `_.find_map(_)`.\n\n **Known problems:** None\n\n **Example:**\n ```rust\n  (0..3).filter_map(|x| if x == 2 { Some(x) } else { None }).next();\n ```\n Can be written as\n\n ```rust\n  (0..3).find_map(|x| if x == 2 { Some(x) } else { None });\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "flat_map_identity",
+    "id_span": {
+      "path": "clippy_lints/src/methods/mod.rs",
+      "line": 546
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks for usage of `flat_map(|x| x)`.\n **Why is this bad?** Readability, this can be written more concisely by using `flatten`.\n\n **Known problems:** None\n\n **Example:**\n ```rust\n # let iter = vec![vec![0]].into_iter();\n iter.flat_map(|x| x);\n ```\n Can be written as\n ```rust\n # let iter = vec![vec![0]].into_iter();\n iter.flatten();\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "search_is_some",
+    "id_span": {
+      "path": "clippy_lints/src/methods/mod.rs",
+      "line": 570
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks for an iterator or string search (such as `find()`, `position()`, or `rposition()`) followed by a call to `is_some()`.\n\n **Why is this bad?** Readability, this can be written more concisely as\n `_.any(_)` or `_.contains(_)`.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # let vec = vec![1];\n vec.iter().find(|x| **x == 0).is_some();\n ```\n Could be written as\n ```rust\n # let vec = vec![1];\n vec.iter().any(|x| *x == 0);\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "chars_next_cmp",
+    "id_span": {
+      "path": "clippy_lints/src/methods/mod.rs",
+      "line": 594
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for usage of `.chars().next()` on a `str` to check if it starts with a given char.\n\n **Why is this bad?** Readability, this can be written more concisely as\n `_.starts_with(_)`.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n let name = \"foo\";\n if name.chars().next() == Some('_') {};\n ```\n Could be written as\n ```rust\n let name = \"foo\";\n if name.starts_with('_') {};\n ```\n",
+    "applicability": null
+  },
+  {
+    "id": "or_fun_call",
+    "id_span": {
+      "path": "clippy_lints/src/methods/mod.rs",
+      "line": 625
+    },
+    "group": "clippy::perf",
+    "docs": " **What it does:** Checks for calls to `.or(foo(..))`, `.unwrap_or(foo(..))`, etc., and suggests to use `or_else`, `unwrap_or_else`, etc., or\n `unwrap_or_default` instead.\n\n **Why is this bad?** The function will always be called and potentially\n allocate an object acting as the default.\n\n **Known problems:** If the function has side-effects, not calling it will\n change the semantic of the program, but you shouldn't rely on that anyway.\n\n **Example:**\n ```rust\n # let foo = Some(String::new());\n foo.unwrap_or(String::new());\n ```\n this can instead be written:\n ```rust\n # let foo = Some(String::new());\n foo.unwrap_or_else(String::new);\n ```\n or\n ```rust\n # let foo = Some(String::new());\n foo.unwrap_or_default();\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "HasPlaceholders"
+    }
+  },
+  {
+    "id": "expect_fun_call",
+    "id_span": {
+      "path": "clippy_lints/src/methods/mod.rs",
+      "line": 660
+    },
+    "group": "clippy::perf",
+    "docs": " **What it does:** Checks for calls to `.expect(&format!(...))`, `.expect(foo(..))`, etc., and suggests to use `unwrap_or_else` instead\n\n **Why is this bad?** The function will always be called.\n\n **Known problems:** If the function has side-effects, not calling it will\n change the semantics of the program, but you shouldn't rely on that anyway.\n\n **Example:**\n ```rust\n # let foo = Some(String::new());\n # let err_code = \"418\";\n # let err_msg = \"I'm a teapot\";\n foo.expect(&format!(\"Err {}: {}\", err_code, err_msg));\n ```\n or\n ```rust\n # let foo = Some(String::new());\n # let err_code = \"418\";\n # let err_msg = \"I'm a teapot\";\n foo.expect(format!(\"Err {}: {}\", err_code, err_msg).as_str());\n ```\n this can instead be written:\n ```rust\n # let foo = Some(String::new());\n # let err_code = \"418\";\n # let err_msg = \"I'm a teapot\";\n foo.unwrap_or_else(|| panic!(\"Err {}: {}\", err_code, err_msg));\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "clone_on_copy",
+    "id_span": {
+      "path": "clippy_lints/src/methods/mod.rs",
+      "line": 677
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks for usage of `.clone()` on a `Copy` type.\n **Why is this bad?** The only reason `Copy` types implement `Clone` is for\n generics, not for using the `clone` method on a concrete type.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n 42u64.clone();\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "clone_on_ref_ptr",
+    "id_span": {
+      "path": "clippy_lints/src/methods/mod.rs",
+      "line": 702
+    },
+    "group": "clippy::restriction",
+    "docs": " **What it does:** Checks for usage of `.clone()` on a ref-counted pointer, (`Rc`, `Arc`, `rc::Weak`, or `sync::Weak`), and suggests calling Clone via unified\n function syntax instead (e.g., `Rc::clone(foo)`).\n\n **Why is this bad?** Calling '.clone()' on an Rc, Arc, or Weak\n can obscure the fact that only the pointer is being cloned, not the underlying\n data.\n\n **Example:**\n ```rust\n # use std::rc::Rc;\n let x = Rc::new(1);\n\n // Bad\n x.clone();\n\n // Good\n Rc::clone(&x);\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "Unspecified"
+    }
+  },
+  {
+    "id": "clone_double_ref",
+    "id_span": {
+      "path": "clippy_lints/src/methods/mod.rs",
+      "line": 724
+    },
+    "group": "clippy::correctness",
+    "docs": " **What it does:** Checks for usage of `.clone()` on an `&&T`.\n **Why is this bad?** Cloning an `&&T` copies the inner `&T`, instead of\n cloning the underlying `T`.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n fn main() {\n     let x = vec![1];\n     let y = &&x;\n     let z = y.clone();\n     println!(\"{:p} {:p}\", *y, z); // prints out the same pointer\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": true,
+      "applicability": "MaybeIncorrect"
+    }
+  },
+  {
+    "id": "inefficient_to_string",
+    "id_span": {
+      "path": "clippy_lints/src/methods/mod.rs",
+      "line": 747
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Checks for usage of `.to_string()` on an `&&T` where `T` implements `ToString` directly (like `&&str` or `&&String`).\n\n **Why is this bad?** This bypasses the specialized implementation of\n `ToString` and instead goes through the more expensive string formatting\n facilities.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n // Generic implementation for `T: Display` is used (slow)\n [\"foo\", \"bar\"].iter().map(|s| s.to_string());\n\n // OK, the specialized impl is used\n [\"foo\", \"bar\"].iter().map(|&s| s.to_string());\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "new_ret_no_self",
+    "id_span": {
+      "path": "clippy_lints/src/methods/mod.rs",
+      "line": 808
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for `new` not returning a type that contains `Self`.\n **Why is this bad?** As a convention, `new` methods are used to make a new\n instance of a type.\n\n **Known problems:** None.\n\n **Example:**\n In an impl block:\n ```rust\n # struct Foo;\n # struct NotAFoo;\n impl Foo {\n     fn new() -> NotAFoo {\n # NotAFoo\n     }\n }\n ```\n\n ```rust\n # struct Foo;\n struct Bar(Foo);\n impl Foo {\n     // Bad. The type name must contain `Self`\n     fn new() -> Bar {\n # Bar(Foo)\n     }\n }\n ```\n\n ```rust\n # struct Foo;\n # struct FooError;\n impl Foo {\n     // Good. Return type contains `Self`\n     fn new() -> Result<Foo, FooError> {\n # Ok(Foo)\n     }\n }\n ```\n\n Or in a trait definition:\n ```rust\n pub trait Trait {\n     // Bad. The type name must contain `Self`\n     fn new();\n }\n ```\n\n ```rust\n pub trait Trait {\n     // Good. Return type contains `Self`\n     fn new() -> Self;\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "single_char_pattern",
+    "id_span": {
+      "path": "clippy_lints/src/methods/mod.rs",
+      "line": 829
+    },
+    "group": "clippy::perf",
+    "docs": " **What it does:** Checks for string methods that receive a single-character `str` as an argument, e.g., `_.split(\"x\")`.\n\n **Why is this bad?** Performing these methods using a `char` is faster than\n using a `str`.\n\n **Known problems:** Does not catch multi-byte unicode characters.\n\n **Example:**\n ```rust,ignore\n // Bad\n _.split(\"x\");\n\n // Good\n _.split('x');\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "iterator_step_by_zero",
+    "id_span": {
+      "path": "clippy_lints/src/methods/mod.rs",
+      "line": 848
+    },
+    "group": "clippy::correctness",
+    "docs": " **What it does:** Checks for calling `.step_by(0)` on iterators which panics.\n **Why is this bad?** This very much looks like an oversight. Use `panic!()` instead if you\n actually intend to panic.\n\n **Known problems:** None.\n\n **Example:**\n ```rust,should_panic\n for x in (0..100).step_by(0) {\n     //..\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "iter_nth_zero",
+    "id_span": {
+      "path": "clippy_lints/src/methods/mod.rs",
+      "line": 876
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for the use of `iter.nth(0)`.\n **Why is this bad?** `iter.next()` is equivalent to\n `iter.nth(0)`, as they both consume the next element,\n  but is more readable.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n # use std::collections::HashSet;\n // Bad\n # let mut s = HashSet::new();\n # s.insert(1);\n let x = s.iter().nth(0);\n\n // Good\n # let mut s = HashSet::new();\n # s.insert(1);\n let x = s.iter().next();\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "iter_nth",
+    "id_span": {
+      "path": "clippy_lints/src/methods/mod.rs",
+      "line": 902
+    },
+    "group": "clippy::perf",
+    "docs": " **What it does:** Checks for use of `.iter().nth()` (and the related `.iter_mut().nth()`) on standard library types with O(1) element access.\n\n **Why is this bad?** `.get()` and `.get_mut()` are more efficient and more\n readable.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n let some_vec = vec![0, 1, 2, 3];\n let bad_vec = some_vec.iter().nth(3);\n let bad_slice = &some_vec[..].iter().nth(3);\n ```\n The correct use would be:\n ```rust\n let some_vec = vec![0, 1, 2, 3];\n let bad_vec = some_vec.get(3);\n let bad_slice = &some_vec[..].get(3);\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "iter_skip_next",
+    "id_span": {
+      "path": "clippy_lints/src/methods/mod.rs",
+      "line": 926
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for use of `.skip(x).next()` on iterators.\n **Why is this bad?** `.nth(x)` is cleaner\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n let some_vec = vec![0, 1, 2, 3];\n let bad_vec = some_vec.iter().skip(3).next();\n let bad_slice = &some_vec[..].iter().skip(3).next();\n ```\n The correct use would be:\n ```rust\n let some_vec = vec![0, 1, 2, 3];\n let bad_vec = some_vec.iter().nth(3);\n let bad_slice = &some_vec[..].iter().nth(3);\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "get_unwrap",
+    "id_span": {
+      "path": "clippy_lints/src/methods/mod.rs",
+      "line": 959
+    },
+    "group": "clippy::restriction",
+    "docs": " **What it does:** Checks for use of `.get().unwrap()` (or `.get_mut().unwrap`) on a standard library type which implements `Index`\n\n **Why is this bad?** Using the Index trait (`[]`) is more clear and more\n concise.\n\n **Known problems:** Not a replacement for error handling: Using either\n `.unwrap()` or the Index trait (`[]`) carries the risk of causing a `panic`\n if the value being accessed is `None`. If the use of `.get().unwrap()` is a\n temporary placeholder for dealing with the `Option` type, then this does\n not mitigate the need for error handling. If there is a chance that `.get()`\n will be `None` in your program, then it is advisable that the `None` case\n is handled in a future refactor instead of using `.unwrap()` or the Index\n trait.\n\n **Example:**\n ```rust\n let mut some_vec = vec![0, 1, 2, 3];\n let last = some_vec.get(3).unwrap();\n *some_vec.get_mut(0).unwrap() = 1;\n ```\n The correct use would be:\n ```rust\n let mut some_vec = vec![0, 1, 2, 3];\n let last = some_vec[3];\n some_vec[0] = 1;\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "string_extend_chars",
+    "id_span": {
+      "path": "clippy_lints/src/methods/mod.rs",
+      "line": 988
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for the use of `.extend(s.chars())` where s is a `&str` or `String`.\n\n **Why is this bad?** `.push_str(s)` is clearer\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n let abc = \"abc\";\n let def = String::from(\"def\");\n let mut s = String::new();\n s.extend(abc.chars());\n s.extend(def.chars());\n ```\n The correct use would be:\n ```rust\n let abc = \"abc\";\n let def = String::from(\"def\");\n let mut s = String::new();\n s.push_str(abc);\n s.push_str(&def);\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "iter_cloned_collect",
+    "id_span": {
+      "path": "clippy_lints/src/methods/mod.rs",
+      "line": 1011
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for the use of `.cloned().collect()` on slice to create a `Vec`.\n\n **Why is this bad?** `.to_vec()` is clearer\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n let s = [1, 2, 3, 4, 5];\n let s2: Vec<isize> = s[..].iter().cloned().collect();\n ```\n The better use would be:\n ```rust\n let s = [1, 2, 3, 4, 5];\n let s2: Vec<isize> = s.to_vec();\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "chars_last_cmp",
+    "id_span": {
+      "path": "clippy_lints/src/methods/mod.rs",
+      "line": 1035
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for usage of `_.chars().last()` or `_.chars().next_back()` on a `str` to check if it ends with a given char.\n\n **Why is this bad?** Readability, this can be written more concisely as\n `_.ends_with(_)`.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # let name = \"_\";\n\n // Bad\n name.chars().last() == Some('_') || name.chars().next_back() == Some('-');\n\n // Good\n name.ends_with('_') || name.ends_with('-');\n ```\n",
+    "applicability": null
+  },
+  {
+    "id": "useless_asref",
+    "id_span": {
+      "path": "clippy_lints/src/methods/mod.rs",
+      "line": 1060
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks for usage of `.as_ref()` or `.as_mut()` where the types before and after the call are the same.\n\n **Why is this bad?** The call is unnecessary.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # fn do_stuff(x: &[i32]) {}\n let x: &[i32] = &[1, 2, 3, 4, 5];\n do_stuff(x.as_ref());\n ```\n The correct use would be:\n ```rust\n # fn do_stuff(x: &[i32]) {}\n let x: &[i32] = &[1, 2, 3, 4, 5];\n do_stuff(x);\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "unnecessary_fold",
+    "id_span": {
+      "path": "clippy_lints/src/methods/mod.rs",
+      "line": 1082
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for using `fold` when a more succinct alternative exists. Specifically, this checks for `fold`s which could be replaced by `any`, `all`,\n `sum` or `product`.\n\n **Why is this bad?** Readability.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n let _ = (0..3).fold(false, |acc, x| acc || x > 2);\n ```\n This could be written as:\n ```rust\n let _ = (0..3).any(|x| x > 2);\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "unnecessary_filter_map",
+    "id_span": {
+      "path": "clippy_lints/src/methods/mod.rs",
+      "line": 1111
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks for `filter_map` calls which could be replaced by `filter` or `map`. More specifically it checks if the closure provided is only performing one of the\n filter or map operations and suggests the appropriate option.\n\n **Why is this bad?** Complexity. The intent is also clearer if only a single\n operation is being performed.\n\n **Known problems:** None\n\n **Example:**\n ```rust\n let _ = (0..3).filter_map(|x| if x > 2 { Some(x) } else { None });\n\n // As there is no transformation of the argument this could be written as:\n let _ = (0..3).filter(|&x| x > 2);\n ```\n\n ```rust\n let _ = (0..4).filter_map(|x| Some(x + 1));\n\n // As there is no conditional check on the argument this could be written as:\n let _ = (0..4).map(|x| x + 1);\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "into_iter_on_ref",
+    "id_span": {
+      "path": "clippy_lints/src/methods/mod.rs",
+      "line": 1135
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for `into_iter` calls on references which should be replaced by `iter` or `iter_mut`.\n\n **Why is this bad?** Readability. Calling `into_iter` on a reference will not move out its\n content into the resulting iterator, which is confusing. It is better just call `iter` or\n `iter_mut` directly.\n\n **Known problems:** None\n\n **Example:**\n\n ```rust\n // Bad\n let _ = (&vec![3, 4, 5]).into_iter();\n\n // Good\n let _ = (&vec![3, 4, 5]).iter();\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "suspicious_map",
+    "id_span": {
+      "path": "clippy_lints/src/methods/mod.rs",
+      "line": 1154
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks for calls to `map` followed by a `count`.\n **Why is this bad?** It looks suspicious. Maybe `map` was confused with `filter`.\n If the `map` call is intentional, this should be rewritten. Or, if you intend to\n drive the iterator to completion, you can just use `for_each` instead.\n\n **Known problems:** None\n\n **Example:**\n\n ```rust\n let _ = (0..3).map(|x| x + 2).count();\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "uninit_assumed_init",
+    "id_span": {
+      "path": "clippy_lints/src/methods/mod.rs",
+      "line": 1186
+    },
+    "group": "clippy::correctness",
+    "docs": " **What it does:** Checks for `MaybeUninit::uninit().assume_init()`.\n **Why is this bad?** For most types, this is undefined behavior.\n\n **Known problems:** For now, we accept empty tuples and tuples / arrays\n of `MaybeUninit`. There may be other types that allow uninitialized\n data, but those are not yet rigorously defined.\n\n **Example:**\n\n ```rust\n // Beware the UB\n use std::mem::MaybeUninit;\n\n let _: usize = unsafe { MaybeUninit::uninit().assume_init() };\n ```\n\n Note that the following is OK:\n\n ```rust\n use std::mem::MaybeUninit;\n\n let _: [MaybeUninit<bool>; 5] = unsafe {\n     MaybeUninit::uninit().assume_init()\n };\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "manual_saturating_arithmetic",
+    "id_span": {
+      "path": "clippy_lints/src/methods/mod.rs",
+      "line": 1213
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for `.checked_add/sub(x).unwrap_or(MAX/MIN)`.\n **Why is this bad?** These can be written simply with `saturating_add/sub` methods.\n\n **Example:**\n\n ```rust\n # let y: u32 = 0;\n # let x: u32 = 100;\n let add = x.checked_add(y).unwrap_or(u32::MAX);\n let sub = x.checked_sub(y).unwrap_or(u32::MIN);\n ```\n\n can be written using dedicated methods for saturating addition/subtraction as:\n\n ```rust\n # let y: u32 = 0;\n # let x: u32 = 100;\n let add = x.saturating_add(y);\n let sub = x.saturating_sub(y);\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "zst_offset",
+    "id_span": {
+      "path": "clippy_lints/src/methods/mod.rs",
+      "line": 1230
+    },
+    "group": "clippy::correctness",
+    "docs": " **What it does:** Checks for `offset(_)`, `wrapping_`{`add`, `sub`}, etc. on raw pointers to zero-sized types\n\n **Why is this bad?** This is a no-op, and likely unintended\n\n **Known problems:** None\n\n **Example:**\n ```rust\n unsafe { (&() as *const ()).offset(1) };\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "filetype_is_file",
+    "id_span": {
+      "path": "clippy_lints/src/methods/mod.rs",
+      "line": 1270
+    },
+    "group": "clippy::restriction",
+    "docs": " **What it does:** Checks for `FileType::is_file()`.\n **Why is this bad?** When people testing a file type with `FileType::is_file`\n they are testing whether a path is something they can get bytes from. But\n `is_file` doesn't cover special file types in unix-like systems, and doesn't cover\n symlink in windows. Using `!FileType::is_dir()` is a better way to that intention.\n\n **Example:**\n\n ```rust\n # || {\n let metadata = std::fs::metadata(\"foo.txt\")?;\n let filetype = metadata.file_type();\n\n if filetype.is_file() {\n     // read file\n }\n # Ok::<_, std::io::Error>(())\n # };\n ```\n\n should be written as:\n\n ```rust\n # || {\n let metadata = std::fs::metadata(\"foo.txt\")?;\n let filetype = metadata.file_type();\n\n if !filetype.is_dir() {\n     // read file\n }\n # Ok::<_, std::io::Error>(())\n # };\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "option_as_ref_deref",
+    "id_span": {
+      "path": "clippy_lints/src/methods/mod.rs",
+      "line": 1295
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks for usage of `_.as_ref().map(Deref::deref)` or it's aliases (such as String::as_str).\n **Why is this bad?** Readability, this can be written more concisely as\n `_.as_deref()`.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # let opt = Some(\"\".to_string());\n opt.as_ref().map(String::as_str)\n # ;\n ```\n Can be written as\n ```rust\n # let opt = Some(\"\".to_string());\n opt.as_deref()\n # ;\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "iter_next_slice",
+    "id_span": {
+      "path": "clippy_lints/src/methods/mod.rs",
+      "line": 1321
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for usage of `iter().next()` on a Slice or an Array\n **Why is this bad?** These can be shortened into `.get()`\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # let a = [1, 2, 3];\n # let b = vec![1, 2, 3];\n a[2..].iter().next();\n b.iter().next();\n ```\n should be written as:\n ```rust\n # let a = [1, 2, 3];\n # let b = vec![1, 2, 3];\n a.get(2);\n b.get(0);\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "single_char_add_str",
+    "id_span": {
+      "path": "clippy_lints/src/methods/mod.rs",
+      "line": 1346
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Warns when using `push_str`/`insert_str` with a single-character string literal where `push`/`insert` with a `char` would work fine.\n\n **Why is this bad?** It's less clear that we are pushing a single character.\n\n **Known problems:** None\n\n **Example:**\n ```rust\n let mut string = String::new();\n string.insert_str(0, \"R\");\n string.push_str(\"R\");\n ```\n Could be written as\n ```rust\n let mut string = String::new();\n string.insert(0, 'R');\n string.push('R');\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "unnecessary_lazy_evaluations",
+    "id_span": {
+      "path": "clippy_lints/src/methods/mod.rs",
+      "line": 1382
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** As the counterpart to `or_fun_call`, this lint looks for unnecessary lazily evaluated closures on `Option` and `Result`.\n\n This lint suggests changing the following functions, when eager evaluation results in\n simpler code:\n  - `unwrap_or_else` to `unwrap_or`\n  - `and_then` to `and`\n  - `or_else` to `or`\n  - `get_or_insert_with` to `get_or_insert`\n  - `ok_or_else` to `ok_or`\n\n **Why is this bad?** Using eager evaluation is shorter and simpler in some cases.\n\n **Known problems:** It is possible, but not recommended for `Deref` and `Index` to have\n side effects. Eagerly evaluating them can change the semantics of the program.\n\n **Example:**\n\n ```rust\n // example code where clippy issues a warning\n let opt: Option<u32> = None;\n\n opt.unwrap_or_else(|| 42);\n ```\n Use instead:\n ```rust\n let opt: Option<u32> = None;\n\n opt.unwrap_or(42);\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "map_collect_result_unit",
+    "id_span": {
+      "path": "clippy_lints/src/methods/mod.rs",
+      "line": 1403
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for usage of `_.map(_).collect::<Result<(), _>()`.\n **Why is this bad?** Using `try_for_each` instead is more readable and idiomatic.\n\n **Known problems:** None\n\n **Example:**\n\n ```rust\n (0..3).map(|t| Err(t)).collect::<Result<(), _>>();\n ```\n Use instead:\n ```rust\n (0..3).try_for_each(|t| Err(t));\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "from_iter_instead_of_collect",
+    "id_span": {
+      "path": "clippy_lints/src/methods/mod.rs",
+      "line": 1436
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for `from_iter()` function calls on types that implement the `FromIterator` trait.\n\n **Why is this bad?** It is recommended style to use collect. See\n [FromIterator documentation](https://doc.rust-lang.org/std/iter/trait.FromIterator.html)\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n use std::iter::FromIterator;\n\n let five_fives = std::iter::repeat(5).take(5);\n\n let v = Vec::from_iter(five_fives);\n\n assert_eq!(v, vec![5, 5, 5, 5, 5]);\n ```\n Use instead:\n ```rust\n let five_fives = std::iter::repeat(5).take(5);\n\n let v: Vec<i32> = five_fives.collect();\n\n assert_eq!(v, vec![5, 5, 5, 5, 5]);\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MaybeIncorrect"
+    }
+  },
+  {
+    "id": "inspect_for_each",
+    "id_span": {
+      "path": "clippy_lints/src/methods/mod.rs",
+      "line": 1466
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks for usage of `inspect().for_each()`.\n **Why is this bad?** It is the same as performing the computation\n inside `inspect` at the beginning of the closure in `for_each`.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n [1,2,3,4,5].iter()\n .inspect(|&x| println!(\"inspect the number: {}\", x))\n .for_each(|&x| {\n     assert!(x >= 0);\n });\n ```\n Can be written as\n ```rust\n [1,2,3,4,5].iter()\n .for_each(|&x| {\n     println!(\"inspect the number: {}\", x);\n     assert!(x >= 0);\n });\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "filter_map_identity",
+    "id_span": {
+      "path": "clippy_lints/src/methods/mod.rs",
+      "line": 1489
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks for usage of `filter_map(|x| x)`.\n **Why is this bad?** Readability, this can be written more concisely by using `flatten`.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n # let iter = vec![Some(1)].into_iter();\n iter.filter_map(|x| x);\n ```\n Use instead:\n ```rust\n # let iter = vec![Some(1)].into_iter();\n iter.flatten();\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "bytes_nth",
+    "id_span": {
+      "path": "clippy_lints/src/methods/mod.rs",
+      "line": 1511
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for the use of `.bytes().nth()`.\n **Why is this bad?** `.as_bytes().get()` is more efficient and more\n readable.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n // Bad\n let _ = \"Hello\".bytes().nth(3);\n\n // Good\n let _ = \"Hello\".as_bytes().get(3);\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "min_max",
+    "id_span": {
+      "path": "clippy_lints/src/minmax.rs",
+      "line": 28
+    },
+    "group": "clippy::correctness",
+    "docs": " **What it does:** Checks for expressions where `std::cmp::min` and `max` are used to clamp values, but switched so that the result is constant.\n\n **Why is this bad?** This is in all probability not the intended outcome. At\n the least it hurts readability of the code.\n\n **Known problems:** None\n\n **Example:**\n ```ignore\n min(0, max(100, x))\n ```\n or\n ```ignore\n x.max(100).min(0)\n ```\n It will always be equal to `0`. Probably the author meant to clamp the value\n between 0 and 100, but has erroneously swapped `min` and `max`.\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "toplevel_ref_arg",
+    "id_span": {
+      "path": "clippy_lints/src/misc.rs",
+      "line": 53
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for function arguments and let bindings denoted as `ref`.\n\n **Why is this bad?** The `ref` declaration makes the function take an owned\n value, but turns the argument into a reference (which means that the value\n is destroyed when exiting the function). This adds not much value: either\n take a reference type, or take an owned value and create references in the\n body.\n\n For let bindings, `let x = &foo;` is preferred over `let ref x = foo`. The\n type of `x` is more obvious with the former.\n\n **Known problems:** If the argument is dereferenced within the function,\n removing the `ref` will lead to errors. This can be fixed by removing the\n dereferences, e.g., changing `*x` to `x` within the function.\n\n **Example:**\n ```rust,ignore\n // Bad\n fn foo(ref x: u8) -> bool {\n     true\n }\n\n // Good\n fn foo(x: &u8) -> bool {\n     true\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "cmp_nan",
+    "id_span": {
+      "path": "clippy_lints/src/misc.rs",
+      "line": 76
+    },
+    "group": "clippy::correctness",
+    "docs": " **What it does:** Checks for comparisons to NaN.\n **Why is this bad?** NaN does not compare meaningfully to anything – not\n even itself – so those comparisons are simply wrong.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # let x = 1.0;\n\n // Bad\n if x == f32::NAN { }\n\n // Good\n if x.is_nan() { }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "float_cmp",
+    "id_span": {
+      "path": "clippy_lints/src/misc.rs",
+      "line": 109
+    },
+    "group": "clippy::correctness",
+    "docs": " **What it does:** Checks for (in-)equality comparisons on floating-point values (apart from zero), except in functions called `*eq*` (which probably\n implement equality for a type involving floats).\n\n **Why is this bad?** Floating point calculations are usually imprecise, so\n asking if two values are *exactly* equal is asking for trouble. For a good\n guide on what to do, see [the floating point\n guide](http://www.floating-point-gui.de/errors/comparison).\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n let x = 1.2331f64;\n let y = 1.2332f64;\n\n // Bad\n if y == 1.23f64 { }\n if y != x {} // where both are floats\n\n // Good\n let error_margin = f64::EPSILON; // Use an epsilon for comparison\n // Or, if Rust <= 1.42, use `std::f64::EPSILON` constant instead.\n // let error_margin = std::f64::EPSILON;\n if (y - 1.23f64).abs() < error_margin { }\n if (y - x).abs() > error_margin { }\n ```\n",
+    "applicability": null
+  },
+  {
+    "id": "cmp_owned",
+    "id_span": {
+      "path": "clippy_lints/src/misc.rs",
+      "line": 136
+    },
+    "group": "clippy::perf",
+    "docs": " **What it does:** Checks for conversions to owned values just for the sake of a comparison.\n\n **Why is this bad?** The comparison can operate on a reference, so creating\n an owned value effectively throws it away directly afterwards, which is\n needlessly consuming code and heap space.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # let x = \"foo\";\n # let y = String::from(\"foo\");\n if x.to_owned() == y {}\n ```\n Could be written as\n ```rust\n # let x = \"foo\";\n # let y = String::from(\"foo\");\n if x == y {}\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "modulo_one",
+    "id_span": {
+      "path": "clippy_lints/src/misc.rs",
+      "line": 159
+    },
+    "group": "clippy::correctness",
+    "docs": " **What it does:** Checks for getting the remainder of a division by one or minus one.\n\n **Why is this bad?** The result for a divisor of one can only ever be zero; for\n minus one it can cause panic/overflow (if the left operand is the minimal value of\n the respective integer type) or results in zero. No one will write such code\n deliberately, unless trying to win an Underhanded Rust Contest. Even for that\n contest, it's probably a bad idea. Use something more underhanded.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # let x = 1;\n let a = x % 1;\n let a = x % -1;\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "used_underscore_binding",
+    "id_span": {
+      "path": "clippy_lints/src/misc.rs",
+      "line": 181
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Checks for the use of bindings with a single leading underscore.\n\n **Why is this bad?** A single leading underscore is usually used to indicate\n that a binding will not be used. Using such a binding breaks this\n expectation.\n\n **Known problems:** The lint does not work properly with desugaring and\n macro, it has been allowed in the mean time.\n\n **Example:**\n ```rust\n let _x = 0;\n let y = _x + 1; // Here we are using `_x`, even though it has a leading\n                 // underscore. We should rename `_x` to `x`\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "short_circuit_statement",
+    "id_span": {
+      "path": "clippy_lints/src/misc.rs",
+      "line": 201
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks for the use of short circuit boolean conditions as a\n statement.\n\n **Why is this bad?** Using a short circuit boolean condition as a statement\n may hide the fact that the second part is executed or not depending on the\n outcome of the first part.\n\n **Known problems:** None.\n\n **Example:**\n ```rust,ignore\n f() && g(); // We should write `if f() { g(); }`.\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "zero_ptr",
+    "id_span": {
+      "path": "clippy_lints/src/misc.rs",
+      "line": 223
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Catch casts from `0` to some pointer type\n **Why is this bad?** This generally means `null` and is better expressed as\n {`std`, `core`}`::ptr::`{`null`, `null_mut`}.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n // Bad\n let a = 0 as *const u32;\n\n // Good\n let a = std::ptr::null::<u32>();\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "float_cmp_const",
+    "id_span": {
+      "path": "clippy_lints/src/misc.rs",
+      "line": 254
+    },
+    "group": "clippy::restriction",
+    "docs": " **What it does:** Checks for (in-)equality comparisons on floating-point value and constant, except in functions called `*eq*` (which probably\n implement equality for a type involving floats).\n\n **Why is this bad?** Floating point calculations are usually imprecise, so\n asking if two values are *exactly* equal is asking for trouble. For a good\n guide on what to do, see [the floating point\n guide](http://www.floating-point-gui.de/errors/comparison).\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n let x: f64 = 1.0;\n const ONE: f64 = 1.00;\n\n // Bad\n if x == ONE { } // where both are floats\n\n // Good\n let error_margin = f64::EPSILON; // Use an epsilon for comparison\n // Or, if Rust <= 1.42, use `std::f64::EPSILON` constant instead.\n // let error_margin = std::f64::EPSILON;\n if (x - ONE).abs() < error_margin { }\n ```\n",
+    "applicability": null
+  },
+  {
+    "id": "unneeded_field_pattern",
+    "id_span": {
+      "path": "clippy_lints/src/misc_early.rs",
+      "line": 44
+    },
+    "group": "clippy::restriction",
+    "docs": " **What it does:** Checks for structure field patterns bound to wildcards.\n **Why is this bad?** Using `..` instead is shorter and leaves the focus on\n the fields that are actually bound.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # struct Foo {\n #     a: i32,\n #     b: i32,\n #     c: i32,\n # }\n let f = Foo { a: 0, b: 0, c: 0 };\n\n // Bad\n match f {\n     Foo { a: _, b: 0, .. } => {},\n     Foo { a: _, b: _, c: _ } => {},\n }\n\n // Good\n match f {\n     Foo { b: 0, .. } => {},\n     Foo { .. } => {},\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "duplicate_underscore_argument",
+    "id_span": {
+      "path": "clippy_lints/src/misc_early.rs",
+      "line": 65
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for function arguments having the similar names differing by an underscore.\n\n **Why is this bad?** It affects code readability.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n // Bad\n fn foo(a: i32, _a: i32) {}\n\n // Good\n fn bar(a: i32, _b: i32) {}\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "double_neg",
+    "id_span": {
+      "path": "clippy_lints/src/misc_early.rs",
+      "line": 83
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Detects expressions of the form `--x`.\n **Why is this bad?** It can mislead C/C++ programmers to think `x` was\n decremented.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n let mut x = 3;\n --x;\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "mixed_case_hex_literals",
+    "id_span": {
+      "path": "clippy_lints/src/misc_early.rs",
+      "line": 104
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Warns on hexadecimal literals with mixed-case letter digits.\n\n **Why is this bad?** It looks confusing.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n // Bad\n let y = 0x1a9BAcD;\n\n // Good\n let y = 0x1A9BACD;\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "unseparated_literal_suffix",
+    "id_span": {
+      "path": "clippy_lints/src/misc_early.rs",
+      "line": 125
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Warns if literal suffixes are not separated by an underscore.\n\n **Why is this bad?** It is much less readable.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n // Bad\n let y = 123832i32;\n\n // Good\n let y = 123832_i32;\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "zero_prefixed_literal",
+    "id_span": {
+      "path": "clippy_lints/src/misc_early.rs",
+      "line": 163
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Warns if an integral constant literal starts with `0`.\n **Why is this bad?** In some languages (including the infamous C language\n and most of its\n family), this marks an octal constant. In Rust however, this is a decimal\n constant. This could\n be confusing for both the writer and a reader of the constant.\n\n **Known problems:** None.\n\n **Example:**\n\n In Rust:\n ```rust\n fn main() {\n     let a = 0123;\n     println!(\"{}\", a);\n }\n ```\n\n prints `123`, while in C:\n\n ```c\n #include <stdio.h>\n\n int main() {\n     int a = 0123;\n     printf(\"%d\\n\", a);\n }\n ```\n\n prints `83` (as `83 == 0o123` while `123 == 0o173`).\n",
+    "applicability": {
+      "is_multi_suggestion": true,
+      "applicability": "MaybeIncorrect"
+    }
+  },
+  {
+    "id": "builtin_type_shadow",
+    "id_span": {
+      "path": "clippy_lints/src/misc_early.rs",
+      "line": 184
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Warns if a generic shadows a built-in type.\n **Why is this bad?** This gives surprising type errors.\n\n **Known problems:** None.\n\n **Example:**\n\n ```ignore\n impl<u32> Foo<u32> {\n     fn impl_func(&self) -> u32 {\n         42\n     }\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "redundant_pattern",
+    "id_span": {
+      "path": "clippy_lints/src/misc_early.rs",
+      "line": 213
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for patterns in the form `name @ _`.\n **Why is this bad?** It's almost always more readable to just use direct\n bindings.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # let v = Some(\"abc\");\n\n // Bad\n match v {\n     Some(x) => (),\n     y @ _ => (),\n }\n\n // Good\n match v {\n     Some(x) => (),\n     y => (),\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "unneeded_wildcard_pattern",
+    "id_span": {
+      "path": "clippy_lints/src/misc_early.rs",
+      "line": 247
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks for tuple patterns with a wildcard pattern (`_`) is next to a rest pattern (`..`).\n\n _NOTE_: While `_, ..` means there is at least one element left, `..`\n means there are 0 or more elements left. This can make a difference\n when refactoring, but shouldn't result in errors in the refactored code,\n since the wildcard pattern isn't used anyway.\n **Why is this bad?** The wildcard pattern is unneeded as the rest pattern\n can match that element as well.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # struct TupleStruct(u32, u32, u32);\n # let t = TupleStruct(1, 2, 3);\n // Bad\n match t {\n     TupleStruct(0, .., _) => (),\n     _ => (),\n }\n\n // Good\n match t {\n     TupleStruct(0, ..) => (),\n     _ => (),\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "missing_const_for_fn",
+    "id_span": {
+      "path": "clippy_lints/src/missing_const_for_fn.rs",
+      "line": 72
+    },
+    "group": "clippy::nursery",
+    "docs": " **What it does:**\n Suggests the use of `const` in functions and methods where possible.\n\n **Why is this bad?**\n\n Not having the function const prevents callers of the function from being const as well.\n\n **Known problems:**\n\n Const functions are currently still being worked on, with some features only being available\n on nightly. This lint does not consider all edge cases currently and the suggestions may be\n incorrect if you are using this lint on stable.\n\n Also, the lint only runs one pass over the code. Consider these two non-const functions:\n\n ```rust\n fn a() -> i32 {\n     0\n }\n fn b() -> i32 {\n     a()\n }\n ```\n\n When running Clippy, the lint will only suggest to make `a` const, because `b` at this time\n can't be const as it calls a non-const function. Making `a` const and running Clippy again,\n will suggest to make `b` const, too.\n\n **Example:**\n\n ```rust\n # struct Foo {\n #     random_number: usize,\n # }\n # impl Foo {\n fn new() -> Self {\n     Self { random_number: 42 }\n }\n # }\n ```\n\n Could be a const fn:\n\n ```rust\n # struct Foo {\n #     random_number: usize,\n # }\n # impl Foo {\n const fn new() -> Self {\n     Self { random_number: 42 }\n }\n # }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "missing_docs_in_private_items",
+    "id_span": {
+      "path": "clippy_lints/src/missing_doc.rs",
+      "line": 29
+    },
+    "group": "clippy::restriction",
+    "docs": " **What it does:** Warns if there is missing doc for any documentable item (public or private).\n\n **Why is this bad?** Doc is good. *rustc* has a `MISSING_DOCS`\n allowed-by-default lint for\n public members, but has no way to enforce documentation of private items.\n This lint fixes that.\n\n **Known problems:** None.\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "missing_inline_in_public_items",
+    "id_span": {
+      "path": "clippy_lints/src/missing_inline.rs",
+      "line": 55
+    },
+    "group": "clippy::restriction",
+    "docs": " **What it does:** it lints if an exported function, method, trait method with default impl, or trait method impl is not `#[inline]`.\n\n **Why is this bad?** In general, it is not. Functions can be inlined across\n crates when that's profitable as long as any form of LTO is used. When LTO is disabled,\n functions that are not `#[inline]` cannot be inlined across crates. Certain types of crates\n might intend for most of the methods in their public API to be able to be inlined across\n crates even when LTO is disabled. For these types of crates, enabling this lint might make\n sense. It allows the crate to require all exported methods to be `#[inline]` by default, and\n then opt out for specific methods where this might not make sense.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n pub fn foo() {} // missing #[inline]\n fn ok() {} // ok\n #[inline] pub fn bar() {} // ok\n #[inline(always)] pub fn baz() {} // ok\n\n pub trait Bar {\n   fn bar(); // ok\n   fn def_bar() {} // missing #[inline]\n }\n\n struct Baz;\n impl Baz {\n    fn private() {} // ok\n }\n\n impl Bar for Baz {\n   fn bar() {} // ok - Baz is not exported\n }\n\n pub struct PubBaz;\n impl PubBaz {\n    fn private() {} // ok\n    pub fn not_ptrivate() {} // missing #[inline]\n }\n\n impl Bar for PubBaz {\n    fn bar() {} // missing #[inline]\n    fn def_bar() {} // missing #[inline]\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "modulo_arithmetic",
+    "id_span": {
+      "path": "clippy_lints/src/modulo_arithmetic.rs",
+      "line": 26
+    },
+    "group": "clippy::restriction",
+    "docs": " **What it does:** Checks for modulo arithmetic.\n **Why is this bad?** The results of modulo (%) operation might differ\n depending on the language, when negative numbers are involved.\n If you interop with different languages it might be beneficial\n to double check all places that use modulo arithmetic.\n\n For example, in Rust `17 % -3 = 2`, but in Python `17 % -3 = -1`.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n let x = -17 % 3;\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "multiple_crate_versions",
+    "id_span": {
+      "path": "clippy_lints/src/multiple_crate_versions.rs",
+      "line": 32
+    },
+    "group": "clippy::cargo",
+    "docs": " **What it does:** Checks to see if multiple versions of a crate are being used.\n\n **Why is this bad?** This bloats the size of targets, and can lead to\n confusing error messages when structs or traits are used interchangeably\n between different versions of a crate.\n\n **Known problems:** Because this can be caused purely by the dependencies\n themselves, it's not always possible to fix this issue.\n\n **Example:**\n ```toml\n # This will pull in both winapi v0.3.x and v0.2.x, triggering a warning.\n [dependencies]\n ctrlc = \"=3.1.0\"\n ansi_term = \"=0.11.0\"\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "mutable_key_type",
+    "id_span": {
+      "path": "clippy_lints/src/mut_key.rs",
+      "line": 50
+    },
+    "group": "clippy::correctness",
+    "docs": " **What it does:** Checks for sets/maps with mutable key types.\n **Why is this bad?** All of `HashMap`, `HashSet`, `BTreeMap` and\n `BtreeSet` rely on either the hash or the order of keys be unchanging,\n so having types with interior mutability is a bad idea.\n\n **Known problems:** It's correct to use a struct, that contains interior mutability\n as a key, when its `Hash` implementation doesn't access any of the interior mutable types.\n However, this lint is unable to recognize this, so it causes a false positive in theses cases.\n The `bytes` crate is a great example of this.\n\n **Example:**\n ```rust\n use std::cmp::{PartialEq, Eq};\n use std::collections::HashSet;\n use std::hash::{Hash, Hasher};\n use std::sync::atomic::AtomicUsize;\n# #[allow(unused)]\n\n struct Bad(AtomicUsize);\n impl PartialEq for Bad {\n     fn eq(&self, rhs: &Self) -> bool {\n          ..\n ; unimplemented!();\n     }\n }\n\n impl Eq for Bad {}\n\n impl Hash for Bad {\n     fn hash<H: Hasher>(&self, h: &mut H) {\n         ..\n ; unimplemented!();\n     }\n }\n\n fn main() {\n     let _: HashSet<Bad> = HashSet::new();\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "mut_mut",
+    "id_span": {
+      "path": "clippy_lints/src/mut_mut.rs",
+      "line": 24
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Checks for instances of `mut mut` references.\n **Why is this bad?** Multiple `mut`s don't add anything meaningful to the\n source. This is either a copy'n'paste error, or it shows a fundamental\n misunderstanding of references.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # let mut y = 1;\n let x = &mut &mut y;\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "mut_mutex_lock",
+    "id_span": {
+      "path": "clippy_lints/src/mut_mutex_lock.rs",
+      "line": 40
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for `&mut Mutex::lock` calls\n **Why is this bad?** `Mutex::lock` is less efficient than\n calling `Mutex::get_mut`. In addition you also have a statically\n guarantee that the mutex isn't locked, instead of just a runtime\n guarantee.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n use std::sync::{Arc, Mutex};\n\n let mut value_rc = Arc::new(Mutex::new(42_u8));\n let value_mutex = Arc::get_mut(&mut value_rc).unwrap();\n\n let mut value = value_mutex.lock().unwrap();\n *value += 1;\n ```\n Use instead:\n ```rust\n use std::sync::{Arc, Mutex};\n\n let mut value_rc = Arc::new(Mutex::new(42_u8));\n let value_mutex = Arc::get_mut(&mut value_rc).unwrap();\n\n let value = value_mutex.get_mut().unwrap();\n *value += 1;\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MaybeIncorrect"
+    }
+  },
+  {
+    "id": "unnecessary_mut_passed",
+    "id_span": {
+      "path": "clippy_lints/src/mut_reference.rs",
+      "line": 25
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Detects passing a mutable reference to a function that only requires an immutable reference.\n\n **Why is this bad?** The mutable reference rules out all other references to\n the value. Also the code misleads about the intent of the call site.\n\n **Known problems:** None.\n\n **Example:**\n ```ignore\n // Bad\n my_vec.push(&mut value)\n\n // Good\n my_vec.push(&value)\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "debug_assert_with_mut_call",
+    "id_span": {
+      "path": "clippy_lints/src/mutable_debug_assertion.rs",
+      "line": 28
+    },
+    "group": "clippy::nursery",
+    "docs": " **What it does:** Checks for function/method calls with a mutable parameter in `debug_assert!`, `debug_assert_eq!` and `debug_assert_ne!` macros.\n\n **Why is this bad?** In release builds `debug_assert!` macros are optimized out by the\n compiler.\n Therefore mutating something in a `debug_assert!` macro results in different behaviour\n between a release and debug build.\n\n **Known problems:** None\n\n **Example:**\n ```rust,ignore\n debug_assert_eq!(vec![3].pop(), Some(3));\n // or\n fn take_a_mut_parameter(_: &mut u32) -> bool { unimplemented!() }\n debug_assert!(take_a_mut_parameter(&mut 5));\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "mutex_atomic",
+    "id_span": {
+      "path": "clippy_lints/src/mutex_atomic.rs",
+      "line": 34
+    },
+    "group": "clippy::perf",
+    "docs": " **What it does:** Checks for usages of `Mutex<X>` where an atomic will do.\n **Why is this bad?** Using a mutex just to make access to a plain bool or\n reference sequential is shooting flies with cannons.\n `std::sync::atomic::AtomicBool` and `std::sync::atomic::AtomicPtr` are leaner and\n faster.\n\n **Known problems:** This lint cannot detect if the mutex is actually used\n for waiting before a critical section.\n\n **Example:**\n ```rust\n # let y = true;\n\n // Bad\n # use std::sync::Mutex;\n let x = Mutex::new(&y);\n\n // Good\n # use std::sync::atomic::AtomicBool;\n let x = AtomicBool::new(y);\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "mutex_integer",
+    "id_span": {
+      "path": "clippy_lints/src/mutex_atomic.rs",
+      "line": 59
+    },
+    "group": "clippy::nursery",
+    "docs": " **What it does:** Checks for usages of `Mutex<X>` where `X` is an integral type.\n\n **Why is this bad?** Using a mutex just to make access to a plain integer\n sequential is\n shooting flies with cannons. `std::sync::atomic::AtomicUsize` is leaner and faster.\n\n **Known problems:** This lint cannot detect if the mutex is actually used\n for waiting before a critical section.\n\n **Example:**\n ```rust\n # use std::sync::Mutex;\n let x = Mutex::new(0usize);\n\n // Good\n # use std::sync::atomic::AtomicUsize;\n let x = AtomicUsize::new(0usize);\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "needless_arbitrary_self_type",
+    "id_span": {
+      "path": "clippy_lints/src/needless_arbitrary_self_type.rs",
+      "line": 55
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** The lint checks for `self` in fn parameters that specify the `Self`-type explicitly\n **Why is this bad?** Increases the amount and decreases the readability of code\n\n **Known problems:** None\n\n **Example:**\n ```rust\n enum ValType {\n     I32,\n     I64,\n     F32,\n     F64,\n }\n\n impl ValType {\n     pub fn bytes(self: Self) -> usize {\n         match self {\n             Self::I32 | Self::F32 => 4,\n             Self::I64 | Self::F64 => 8,\n         }\n     }\n }\n ```\n\n Could be rewritten as\n\n ```rust\n enum ValType {\n     I32,\n     I64,\n     F32,\n     F64,\n }\n\n impl ValType {\n     pub fn bytes(self) -> usize {\n         match self {\n             Self::I32 | Self::F32 => 4,\n             Self::I64 | Self::F64 => 8,\n         }\n     }\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "needless_bool",
+    "id_span": {
+      "path": "clippy_lints/src/needless_bool.rs",
+      "line": 38
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks for expressions of the form `if c { true } else { false }` (or vice versa) and suggests using the condition directly.\n\n **Why is this bad?** Redundant code.\n\n **Known problems:** Maybe false positives: Sometimes, the two branches are\n painstakingly documented (which we, of course, do not detect), so they *may*\n have some value. Even then, the documentation can be rewritten to match the\n shorter code.\n\n **Example:**\n ```rust,ignore\n if x {\n     false\n } else {\n     true\n }\n ```\n Could be written as\n ```rust,ignore\n !x\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "bool_comparison",
+    "id_span": {
+      "path": "clippy_lints/src/needless_bool.rs",
+      "line": 62
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks for expressions of the form `x == true`, `x != true` and order comparisons such as `x < true` (or vice versa) and\n suggest using the variable directly.\n\n **Why is this bad?** Unnecessary code.\n\n **Known problems:** None.\n\n **Example:**\n ```rust,ignore\n if x == true {}\n if y == false {}\n ```\n use `x` directly:\n ```rust,ignore\n if x {}\n if !y {}\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "needless_borrow",
+    "id_span": {
+      "path": "clippy_lints/src/needless_borrow.rs",
+      "line": 32
+    },
+    "group": "clippy::nursery",
+    "docs": " **What it does:** Checks for address of operations (`&`) that are going to be dereferenced immediately by the compiler.\n\n **Why is this bad?** Suggests that the receiver of the expression borrows\n the expression.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n // Bad\n let x: &i32 = &&&&&&5;\n\n // Good\n let x: &i32 = &5;\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "needless_borrowed_reference",
+    "id_span": {
+      "path": "clippy_lints/src/needless_borrowed_ref.rs",
+      "line": 48
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks for useless borrowed references.\n **Why is this bad?** It is mostly useless and make the code look more\n complex than it\n actually is.\n\n **Known problems:** It seems that the `&ref` pattern is sometimes useful.\n For instance in the following snippet:\n ```rust,ignore\n enum Animal {\n     Cat(u64),\n     Dog(u64),\n }\n\n fn foo(a: &Animal, b: &Animal) {\n     match (a, b) {\n         (&Animal::Cat(v), k) | (k, &Animal::Cat(v)) => (), // lifetime mismatch error\n         (&Animal::Dog(ref c), &Animal::Dog(_)) => ()\n     }\n }\n ```\n There is a lifetime mismatch error for `k` (indeed a and b have distinct\n lifetime).\n This can be fixed by using the `&ref` pattern.\n However, the code can also be fixed by much cleaner ways\n\n **Example:**\n ```rust\n let mut v = Vec::<String>::new();\n let _ = v.iter_mut().filter(|&ref a| a.is_empty());\n ```\n This closure takes a reference on something that has been matched as a\n reference and\n de-referenced.\n As such, it could just be |a| a.is_empty()\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "needless_continue",
+    "id_span": {
+      "path": "clippy_lints/src/needless_continue.rs",
+      "line": 114
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** The lint checks for `if`-statements appearing in loops that contain a `continue` statement in either their main blocks or their\n `else`-blocks, when omitting the `else`-block possibly with some\n rearrangement of code can make the code easier to understand.\n\n **Why is this bad?** Having explicit `else` blocks for `if` statements\n containing `continue` in their THEN branch adds unnecessary branching and\n nesting to the code. Having an else block containing just `continue` can\n also be better written by grouping the statements following the whole `if`\n statement within the THEN block and omitting the else block completely.\n\n **Known problems:** None\n\n **Example:**\n ```rust\n # fn condition() -> bool { false }\n # fn update_condition() {}\n # let x = false;\n while condition() {\n     update_condition();\n     if x {\n         // ...\n     } else {\n         continue;\n     }\n     println!(\"Hello, world\");\n }\n ```\n\n Could be rewritten as\n\n ```rust\n # fn condition() -> bool { false }\n # fn update_condition() {}\n # let x = false;\n while condition() {\n     update_condition();\n     if x {\n         // ...\n         println!(\"Hello, world\");\n     }\n }\n ```\n\n As another example, the following code\n\n ```rust\n # fn waiting() -> bool { false }\n loop {\n     if waiting() {\n         continue;\n     } else {\n         // Do something useful\n     }\n     # break;\n }\n ```\n Could be rewritten as\n\n ```rust\n # fn waiting() -> bool { false }\n loop {\n     if waiting() {\n         continue;\n     }\n     // Do something useful\n     # break;\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "needless_pass_by_value",
+    "id_span": {
+      "path": "clippy_lints/src/needless_pass_by_value.rs",
+      "line": 50
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Checks for functions taking arguments by value, but not consuming them in its\n body.\n\n **Why is this bad?** Taking arguments by reference is more flexible and can\n sometimes avoid\n unnecessary allocations.\n\n **Known problems:**\n * This lint suggests taking an argument by reference,\n however sometimes it is better to let users decide the argument type\n (by using `Borrow` trait, for example), depending on how the function is used.\n\n **Example:**\n ```rust\n fn foo(v: Vec<i32>) {\n     assert_eq!(v.len(), 42);\n }\n ```\n should be\n ```rust\n fn foo(v: &[i32]) {\n     assert_eq!(v.len(), 42);\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": true,
+      "applicability": null
+    }
+  },
+  {
+    "id": "needless_question_mark",
+    "id_span": {
+      "path": "clippy_lints/src/needless_question_mark.rs",
+      "line": 57
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Suggests alternatives for useless applications of `?` in terminating expressions\n\n **Why is this bad?** There's no reason to use `?` to short-circuit when execution of the body will end there anyway.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n struct TO {\n     magic: Option<usize>,\n }\n\n fn f(to: TO) -> Option<usize> {\n     Some(to.magic?)\n }\n\n struct TR {\n     magic: Result<usize, bool>,\n }\n\n fn g(tr: Result<TR, bool>) -> Result<usize, bool> {\n     tr.and_then(|t| Ok(t.magic?))\n }\n\n ```\n Use instead:\n ```rust\n struct TO {\n     magic: Option<usize>,\n }\n\n fn f(to: TO) -> Option<usize> {\n    to.magic\n }\n\n struct TR {\n     magic: Result<usize, bool>,\n }\n\n fn g(tr: Result<TR, bool>) -> Result<usize, bool> {\n     tr.and_then(|t| t.magic)\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "needless_update",
+    "id_span": {
+      "path": "clippy_lints/src/needless_update.rs",
+      "line": 43
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks for needlessly including a base struct on update when all fields are changed anyway.\n\n This lint is not applied to structs marked with\n [non_exhaustive](https://doc.rust-lang.org/reference/attributes/type_system.html).\n\n **Why is this bad?** This will cost resources (because the base has to be\n somewhere), and make the code less readable.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # struct Point {\n #     x: i32,\n #     y: i32,\n #     z: i32,\n # }\n # let zero_point = Point { x: 0, y: 0, z: 0 };\n\n // Bad\n Point {\n     x: 1,\n     y: 1,\n     z: 1,\n     ..zero_point\n };\n\n // Ok\n Point {\n     x: 1,\n     y: 1,\n     ..zero_point\n };\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "neg_cmp_op_on_partial_ord",
+    "id_span": {
+      "path": "clippy_lints/src/neg_cmp_op_on_partial_ord.rs",
+      "line": 41
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks for the usage of negated comparison operators on types which only implement\n `PartialOrd` (e.g., `f64`).\n\n **Why is this bad?**\n These operators make it easy to forget that the underlying types actually allow not only three\n potential Orderings (Less, Equal, Greater) but also a fourth one (Uncomparable). This is\n especially easy to miss if the operator based comparison result is negated.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n use std::cmp::Ordering;\n\n // Bad\n let a = 1.0;\n let b = f64::NAN;\n\n let _not_less_or_equal = !(a <= b);\n\n // Good\n let a = 1.0;\n let b = f64::NAN;\n\n let _not_less_or_equal = match a.partial_cmp(&b) {\n     None | Some(Ordering::Greater) => true,\n     _ => false,\n };\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "neg_multiply",
+    "id_span": {
+      "path": "clippy_lints/src/neg_multiply.rs",
+      "line": 21
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for multiplication by -1 as a form of negation.\n **Why is this bad?** It's more readable to just negate.\n\n **Known problems:** This only catches integers (for now).\n\n **Example:**\n ```ignore\n x * -1\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "new_without_default",
+    "id_span": {
+      "path": "clippy_lints/src/new_without_default.rs",
+      "line": 48
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for types with a `fn new() -> Self` method and no implementation of\n [`Default`](https://doc.rust-lang.org/std/default/trait.Default.html).\n\n **Why is this bad?** The user might expect to be able to use\n [`Default`](https://doc.rust-lang.org/std/default/trait.Default.html) as the\n type can be constructed without arguments.\n\n **Known problems:** Hopefully none.\n\n **Example:**\n\n ```ignore\n struct Foo(Bar);\n\n impl Foo {\n     fn new() -> Self {\n         Foo(Bar::new())\n     }\n }\n ```\n\n To fix the lint, add a `Default` implementation that delegates to `new`:\n\n ```ignore\n struct Foo(Bar);\n\n impl Default for Foo {\n     fn default() -> Self {\n         Foo::new()\n     }\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MaybeIncorrect"
+    }
+  },
+  {
+    "id": "no_effect",
+    "id_span": {
+      "path": "clippy_lints/src/no_effect.rs",
+      "line": 22
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks for statements which have no effect.\n **Why is this bad?** Similar to dead code, these statements are actually\n executed. However, as they have no effect, all they do is make the code less\n readable.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n 0;\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "unnecessary_operation",
+    "id_span": {
+      "path": "clippy_lints/src/no_effect.rs",
+      "line": 40
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks for expression statements that can be reduced to a sub-expression.\n\n **Why is this bad?** Expressions by themselves often have no side-effects.\n Having such expressions reduces readability.\n\n **Known problems:** None.\n\n **Example:**\n ```rust,ignore\n compute_array()[0];\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "declare_interior_mutable_const",
+    "id_span": {
+      "path": "clippy_lints/src/non_copy_const.rs",
+      "line": 69
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for declaration of `const` items which is interior mutable (e.g., contains a `Cell`, `Mutex`, `AtomicXxxx`, etc.).\n\n **Why is this bad?** Consts are copied everywhere they are referenced, i.e.,\n every time you refer to the const a fresh instance of the `Cell` or `Mutex`\n or `AtomicXxxx` will be created, which defeats the whole purpose of using\n these types in the first place.\n\n The `const` should better be replaced by a `static` item if a global\n variable is wanted, or replaced by a `const fn` if a constructor is wanted.\n\n **Known problems:** A \"non-constant\" const item is a legacy way to supply an\n initialized value to downstream `static` items (e.g., the\n `std::sync::ONCE_INIT` constant). In this case the use of `const` is legit,\n and this lint should be suppressed.\n\n Even though the lint avoids triggering on a constant whose type has enums that have variants\n with interior mutability, and its value uses non interior mutable variants (see\n [#3962](https://github.com/rust-lang/rust-clippy/issues/3962) and\n [#3825](https://github.com/rust-lang/rust-clippy/issues/3825) for examples);\n it complains about associated constants without default values only based on its types;\n which might not be preferable.\n There're other enums plus associated constants cases that the lint cannot handle.\n\n Types that have underlying or potential interior mutability trigger the lint whether\n the interior mutable field is used or not. See issues\n [#5812](https://github.com/rust-lang/rust-clippy/issues/5812) and\n\n **Example:**\n ```rust\n use std::sync::atomic::{AtomicUsize, Ordering::SeqCst};\n\n // Bad.\n const CONST_ATOM: AtomicUsize = AtomicUsize::new(12);\n CONST_ATOM.store(6, SeqCst); // the content of the atomic is unchanged\n assert_eq!(CONST_ATOM.load(SeqCst), 12); // because the CONST_ATOM in these lines are distinct\n\n // Good.\n static STATIC_ATOM: AtomicUsize = AtomicUsize::new(15);\n STATIC_ATOM.store(9, SeqCst);\n assert_eq!(STATIC_ATOM.load(SeqCst), 9); // use a `static` item to refer to the same instance\n ```\n",
+    "applicability": null
+  },
+  {
+    "id": "borrow_interior_mutable_const",
+    "id_span": {
+      "path": "clippy_lints/src/non_copy_const.rs",
+      "line": 110
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks if `const` items which is interior mutable (e.g., contains a `Cell`, `Mutex`, `AtomicXxxx`, etc.) has been borrowed directly.\n\n **Why is this bad?** Consts are copied everywhere they are referenced, i.e.,\n every time you refer to the const a fresh instance of the `Cell` or `Mutex`\n or `AtomicXxxx` will be created, which defeats the whole purpose of using\n these types in the first place.\n\n The `const` value should be stored inside a `static` item.\n\n **Known problems:** When an enum has variants with interior mutability, use of its non\n interior mutable variants can generate false positives. See issue\n [#3962](https://github.com/rust-lang/rust-clippy/issues/3962)\n\n Types that have underlying or potential interior mutability trigger the lint whether\n the interior mutable field is used or not. See issues\n [#5812](https://github.com/rust-lang/rust-clippy/issues/5812) and\n [#3825](https://github.com/rust-lang/rust-clippy/issues/3825)\n\n **Example:**\n ```rust\n use std::sync::atomic::{AtomicUsize, Ordering::SeqCst};\n const CONST_ATOM: AtomicUsize = AtomicUsize::new(12);\n\n // Bad.\n CONST_ATOM.store(6, SeqCst); // the content of the atomic is unchanged\n assert_eq!(CONST_ATOM.load(SeqCst), 12); // because the CONST_ATOM in these lines are distinct\n\n // Good.\n static STATIC_ATOM: AtomicUsize = CONST_ATOM;\n STATIC_ATOM.store(9, SeqCst);\n assert_eq!(STATIC_ATOM.load(SeqCst), 9); // use a `static` item to refer to the same instance\n ```\n",
+    "applicability": null
+  },
+  {
+    "id": "similar_names",
+    "id_span": {
+      "path": "clippy_lints/src/non_expressive_names.rs",
+      "line": 27
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Checks for names that are very similar and thus confusing.\n **Why is this bad?** It's hard to distinguish between names that differ only\n by a single character.\n\n **Known problems:** None?\n\n **Example:**\n ```ignore\n let checked_exp = something;\n let checked_expr = something_else;\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "many_single_char_names",
+    "id_span": {
+      "path": "clippy_lints/src/non_expressive_names.rs",
+      "line": 45
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for too many variables whose name consists of a single character.\n\n **Why is this bad?** It's hard to memorize what a variable means without a\n descriptive name.\n\n **Known problems:** None?\n\n **Example:**\n ```ignore\n let (a, b, c, d, e, f, g) = (...);\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "just_underscores_and_digits",
+    "id_span": {
+      "path": "clippy_lints/src/non_expressive_names.rs",
+      "line": 65
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks if you have variables whose name consists of just underscores and digits.\n\n **Why is this bad?** It's hard to memorize what a variable means without a\n descriptive name.\n\n **Known problems:** None?\n\n **Example:**\n ```rust\n let _1 = 1;\n let ___1 = 1;\n let __1___2 = 11;\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "nonsensical_open_options",
+    "id_span": {
+      "path": "clippy_lints/src/open_options.rs",
+      "line": 23
+    },
+    "group": "clippy::correctness",
+    "docs": " **What it does:** Checks for duplicate open options as well as combinations that make no sense.\n\n **Why is this bad?** In the best case, the code will be harder to read than\n necessary. I don't know the worst case.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n use std::fs::OpenOptions;\n\n OpenOptions::new().read(true).truncate(true);\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "option_env_unwrap",
+    "id_span": {
+      "path": "clippy_lints/src/option_env_unwrap.rs",
+      "line": 28
+    },
+    "group": "clippy::correctness",
+    "docs": " **What it does:** Checks for usage of `option_env!(...).unwrap()` and suggests usage of the `env!` macro.\n\n **Why is this bad?** Unwrapping the result of `option_env!` will panic\n at run-time if the environment variable doesn't exist, whereas `env!`\n catches it at compile-time.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust,no_run\n let _ = option_env!(\"HOME\").unwrap();\n ```\n\n Is better expressed as:\n\n ```rust,no_run\n let _ = env!(\"HOME\");\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "option_if_let_else",
+    "id_span": {
+      "path": "clippy_lints/src/option_if_let_else.rs",
+      "line": 59
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Lints usage of `if let Some(v) = ... { y } else { x }` which is more\n idiomatically done with `Option::map_or` (if the else bit is a pure\n expression) or `Option::map_or_else` (if the else bit is an impure\n expression).\n\n **Why is this bad?**\n Using the dedicated functions of the Option type is clearer and\n more concise than an `if let` expression.\n\n **Known problems:**\n This lint uses a deliberately conservative metric for checking\n if the inside of either body contains breaks or continues which will\n cause it to not suggest a fix if either block contains a loop with\n continues or breaks contained within the loop.\n\n **Example:**\n\n ```rust\n # let optional: Option<u32> = Some(0);\n # fn do_complicated_function() -> u32 { 5 };\n let _ = if let Some(foo) = optional {\n     foo\n } else {\n     5\n };\n let _ = if let Some(foo) = optional {\n     foo\n } else {\n     let y = do_complicated_function();\n     y*y\n };\n ```\n\n should be\n\n ```rust\n # let optional: Option<u32> = Some(0);\n # fn do_complicated_function() -> u32 { 5 };\n let _ = optional.map_or(5, |foo| foo);\n let _ = optional.map_or_else(||{\n     let y = do_complicated_function();\n     y*y\n }, |foo| foo);\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MaybeIncorrect"
+    }
+  },
+  {
+    "id": "overflow_check_conditional",
+    "id_span": {
+      "path": "clippy_lints/src/overflow_check_conditional.rs",
+      "line": 21
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Detects classic underflow/overflow checks.\n **Why is this bad?** Most classic C underflow/overflow checks will fail in\n Rust. Users can use functions like `overflowing_*` and `wrapping_*` instead.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # let a = 1;\n # let b = 2;\n a + b < a;\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "panic_in_result_fn",
+    "id_span": {
+      "path": "clippy_lints/src/panic_in_result_fn.rs",
+      "line": 29
+    },
+    "group": "clippy::restriction",
+    "docs": " **What it does:** Checks for usage of `panic!`, `unimplemented!`, `todo!`, `unreachable!` or assertions in a function of type result.\n **Why is this bad?** For some codebases, it is desirable for functions of type result to return an error instead of crashing. Hence panicking macros should be avoided.\n\n **Known problems:** Functions called from a function returning a `Result` may invoke a panicking macro. This is not checked.\n\n **Example:**\n\n ```rust\n fn result_with_panic() -> Result<bool, String>\n {\n     panic!(\"error\");\n }\n ```\n Use instead:\n ```rust\n fn result_without_panic() -> Result<bool, String> {\n     Err(String::from(\"error\"))\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "panic",
+    "id_span": {
+      "path": "clippy_lints/src/panic_unimplemented.rs",
+      "line": 19
+    },
+    "group": "clippy::restriction",
+    "docs": " **What it does:** Checks for usage of `panic!`.\n **Why is this bad?** `panic!` will stop the execution of the executable\n\n **Known problems:** None.\n\n **Example:**\n ```no_run\n panic!(\"even with a good reason\");\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "unimplemented",
+    "id_span": {
+      "path": "clippy_lints/src/panic_unimplemented.rs",
+      "line": 35
+    },
+    "group": "clippy::restriction",
+    "docs": " **What it does:** Checks for usage of `unimplemented!`.\n **Why is this bad?** This macro should not be present in production code\n\n **Known problems:** None.\n\n **Example:**\n ```no_run\n unimplemented!();\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "todo",
+    "id_span": {
+      "path": "clippy_lints/src/panic_unimplemented.rs",
+      "line": 51
+    },
+    "group": "clippy::restriction",
+    "docs": " **What it does:** Checks for usage of `todo!`.\n **Why is this bad?** This macro should not be present in production code\n\n **Known problems:** None.\n\n **Example:**\n ```no_run\n todo!();\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "unreachable",
+    "id_span": {
+      "path": "clippy_lints/src/panic_unimplemented.rs",
+      "line": 67
+    },
+    "group": "clippy::restriction",
+    "docs": " **What it does:** Checks for usage of `unreachable!`.\n **Why is this bad?** This macro can cause code to panic\n\n **Known problems:** None.\n\n **Example:**\n ```no_run\n unreachable!();\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "partialeq_ne_impl",
+    "id_span": {
+      "path": "clippy_lints/src/partialeq_ne_impl.rs",
+      "line": 27
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks for manual re-implementations of `PartialEq::ne`.\n **Why is this bad?** `PartialEq::ne` is required to always return the\n negated result of `PartialEq::eq`, which is exactly what the default\n implementation does. Therefore, there should never be any need to\n re-implement it.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n struct Foo;\n\n impl PartialEq for Foo {\n    fn eq(&self, other: &Foo) -> bool { true }\n    fn ne(&self, other: &Foo) -> bool { !(self == other) }\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "trivially_copy_pass_by_ref",
+    "id_span": {
+      "path": "clippy_lints/src/pass_by_ref_or_value.rs",
+      "line": 52
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Checks for functions taking arguments by reference, where the argument type is `Copy` and small enough to be more efficient to always\n pass by value.\n\n **Why is this bad?** In many calling conventions instances of structs will\n be passed through registers if they fit into two or less general purpose\n registers.\n\n **Known problems:** This lint is target register size dependent, it is\n limited to 32-bit to try and reduce portability problems between 32 and\n 64-bit, but if you are compiling for 8 or 16-bit targets then the limit\n will be different.\n\n The configuration option `trivial_copy_size_limit` can be set to override\n this limit for a project.\n\n This lint attempts to allow passing arguments by reference if a reference\n to that argument is returned. This is implemented by comparing the lifetime\n of the argument and return value for equality. However, this can cause\n false positives in cases involving multiple lifetimes that are bounded by\n each other.\n\n **Example:**\n\n ```rust\n // Bad\n fn foo(v: &u32) {}\n ```\n\n ```rust\n // Better\n fn foo(v: u32) {}\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "Unspecified"
+    }
+  },
+  {
+    "id": "large_types_passed_by_value",
+    "id_span": {
+      "path": "clippy_lints/src/pass_by_ref_or_value.rs",
+      "line": 84
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Checks for functions taking arguments by value, where the argument type is `Copy` and large enough to be worth considering\n passing by reference. Does not trigger if the function is being exported,\n because that might induce API breakage, if the parameter is declared as mutable,\n or if the argument is a `self`.\n\n **Why is this bad?** Arguments passed by value might result in an unnecessary\n shallow copy, taking up more space in the stack and requiring a call to\n `memcpy`, which can be expensive.\n\n **Example:**\n\n ```rust\n #[derive(Clone, Copy)]\n struct TooLarge([u8; 2048]);\n\n // Bad\n fn foo(v: TooLarge) {}\n ```\n ```rust\n #[derive(Clone, Copy)]\n struct TooLarge([u8; 2048]);\n\n // Good\n fn foo(v: &TooLarge) {}\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MaybeIncorrect"
+    }
+  },
+  {
+    "id": "path_buf_push_overwrite",
+    "id_span": {
+      "path": "clippy_lints/src/path_buf_push_overwrite.rs",
+      "line": 36
+    },
+    "group": "clippy::nursery",
+    "docs": " **What it does:*** Checks for [push](https://doc.rust-lang.org/std/path/struct.PathBuf.html#method.push) calls on `PathBuf` that can cause overwrites.\n\n **Why is this bad?** Calling `push` with a root path at the start can overwrite the\n previous defined path.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n use std::path::PathBuf;\n\n let mut x = PathBuf::from(\"/foo\");\n x.push(\"/bar\");\n assert_eq!(x, PathBuf::from(\"/bar\"));\n ```\n Could be written:\n\n ```rust\n use std::path::PathBuf;\n\n let mut x = PathBuf::from(\"/foo\");\n x.push(\"bar\");\n assert_eq!(x, PathBuf::from(\"/foo/bar\"));\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "pattern_type_mismatch",
+    "id_span": {
+      "path": "clippy_lints/src/pattern_type_mismatch.rs",
+      "line": 79
+    },
+    "group": "clippy::restriction",
+    "docs": " **What it does:** Checks for patterns that aren't exact representations of the types they are applied to.\n\n To satisfy this lint, you will have to adjust either the expression that is matched\n against or the pattern itself, as well as the bindings that are introduced by the\n adjusted patterns. For matching you will have to either dereference the expression\n with the `*` operator, or amend the patterns to explicitly match against `&<pattern>`\n or `&mut <pattern>` depending on the reference mutability. For the bindings you need\n to use the inverse. You can leave them as plain bindings if you wish for the value\n to be copied, but you must use `ref mut <variable>` or `ref <variable>` to construct\n a reference into the matched structure.\n\n If you are looking for a way to learn about ownership semantics in more detail, it\n is recommended to look at IDE options available to you to highlight types, lifetimes\n and reference semantics in your code. The available tooling would expose these things\n in a general way even outside of the various pattern matching mechanics. Of course\n this lint can still be used to highlight areas of interest and ensure a good understanding\n of ownership semantics.\n\n **Why is this bad?** It isn't bad in general. But in some contexts it can be desirable\n because it increases ownership hints in the code, and will guard against some changes\n in ownership.\n\n **Known problems:** None.\n\n **Example:**\n\n This example shows the basic adjustments necessary to satisfy the lint. Note how\n the matched expression is explicitly dereferenced with `*` and the `inner` variable\n is bound to a shared borrow via `ref inner`.\n\n ```rust,ignore\n // Bad\n let value = &Some(Box::new(23));\n match value {\n     Some(inner) => println!(\"{}\", inner),\n     None => println!(\"none\"),\n }\n\n // Good\n let value = &Some(Box::new(23));\n match *value {\n     Some(ref inner) => println!(\"{}\", inner),\n     None => println!(\"none\"),\n }\n ```\n\n The following example demonstrates one of the advantages of the more verbose style.\n Note how the second version uses `ref mut a` to explicitly declare `a` a shared mutable\n borrow, while `b` is simply taken by value. This ensures that the loop body cannot\n accidentally modify the wrong part of the structure.\n\n ```rust,ignore\n // Bad\n let mut values = vec![(2, 3), (3, 4)];\n for (a, b) in &mut values {\n     *a += *b;\n }\n\n // Good\n let mut values = vec![(2, 3), (3, 4)];\n for &mut (ref mut a, b) in &mut values {\n     *a += b;\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "precedence",
+    "id_span": {
+      "path": "clippy_lints/src/precedence.rs",
+      "line": 44
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks for operations where precedence may be unclear and suggests to add parentheses. Currently it catches the following:\n * mixed usage of arithmetic and bit shifting/combining operators without\n parentheses\n * a \"negative\" numeric literal (which is really a unary `-` followed by a\n numeric literal)\n   followed by a method call\n\n **Why is this bad?** Not everyone knows the precedence of those operators by\n heart, so expressions like these may trip others trying to reason about the\n code.\n\n **Known problems:** None.\n\n **Example:**\n * `1 << 2 + 3` equals 32, while `(1 << 2) + 3` equals 7\n * `-1i32.abs()` equals -1, while `(-1i32).abs()` equals 1\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "ptr_arg",
+    "id_span": {
+      "path": "clippy_lints/src/ptr.rs",
+      "line": 69
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** This lint checks for function arguments of type `&String` or `&Vec` unless the references are mutable. It will also suggest you\n replace `.clone()` calls with the appropriate `.to_owned()`/`to_string()`\n calls.\n\n **Why is this bad?** Requiring the argument to be of the specific size\n makes the function less useful for no benefit; slices in the form of `&[T]`\n or `&str` usually suffice and can be obtained from other types, too.\n\n **Known problems:** The lint does not follow data. So if you have an\n argument `x` and write `let y = x; y.clone()` the lint will not suggest\n changing that `.clone()` to `.to_owned()`.\n\n Other functions called from this function taking a `&String` or `&Vec`\n argument may also fail to compile if you change the argument. Applying\n this lint on them will fix the problem, but they may be in other crates.\n\n One notable example of a function that may cause issues, and which cannot\n easily be changed due to being in the standard library is `Vec::contains`.\n when called on a `Vec<Vec<T>>`. If a `&Vec` is passed to that method then\n it will compile, but if a `&[T]` is passed then it will not compile.\n\n ```ignore\n fn cannot_take_a_slice(v: &Vec<u8>) -> bool {\n     let vec_of_vecs: Vec<Vec<u8>> = some_other_fn();\n\n     vec_of_vecs.contains(v)\n }\n ```\n\n Also there may be `fn(&Vec)`-typed references pointing to your function.\n If you have them, you will get a compiler error after applying this lint's\n suggestions. You then have the choice to undo your changes or change the\n type of the reference.\n\n Note that if the function is part of your public interface, there may be\n other crates referencing it, of which you may not be aware. Carefully\n deprecate the function before applying the lint suggestions in this case.\n\n **Example:**\n ```ignore\n // Bad\n fn foo(&Vec<u32>) { .. }\n\n // Good\n fn foo(&[u32]) { .. }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "Unspecified"
+    }
+  },
+  {
+    "id": "cmp_null",
+    "id_span": {
+      "path": "clippy_lints/src/ptr.rs",
+      "line": 95
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** This lint checks for equality comparisons with `ptr::null`\n **Why is this bad?** It's easier and more readable to use the inherent\n `.is_null()`\n method instead\n\n **Known problems:** None.\n\n **Example:**\n ```ignore\n // Bad\n if x == ptr::null {\n     ..\n }\n\n // Good\n if x.is_null() {\n     ..\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "mut_from_ref",
+    "id_span": {
+      "path": "clippy_lints/src/ptr.rs",
+      "line": 117
+    },
+    "group": "clippy::correctness",
+    "docs": " **What it does:** This lint checks for functions that take immutable references and return mutable ones.\n\n **Why is this bad?** This is trivially unsound, as one can create two\n mutable references from the same (immutable!) source.\n This [error](https://github.com/rust-lang/rust/issues/39465)\n actually lead to an interim Rust release 1.15.1.\n\n **Known problems:** To be on the conservative side, if there's at least one\n mutable reference with the output lifetime, this lint will not trigger.\n In practice, this case is unlikely anyway.\n\n **Example:**\n ```ignore\n fn foo(&Foo) -> &mut Bar { .. }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "ptr_eq",
+    "id_span": {
+      "path": "clippy_lints/src/ptr_eq.rs",
+      "line": 32
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Use `std::ptr::eq` when applicable\n **Why is this bad?** `ptr::eq` can be used to compare `&T` references\n (which coerce to `*const T` implicitly) by their address rather than\n comparing the values they point to.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n let a = &[1, 2, 3];\n let b = &[1, 2, 3];\n\n assert!(a as *const _ as usize == b as *const _ as usize);\n ```\n Use instead:\n ```rust\n let a = &[1, 2, 3];\n let b = &[1, 2, 3];\n\n assert!(std::ptr::eq(a, b));\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "ptr_offset_with_cast",
+    "id_span": {
+      "path": "clippy_lints/src/ptr_offset_with_cast.rs",
+      "line": 40
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks for usage of the `offset` pointer method with a `usize` casted to an `isize`.\n\n **Why is this bad?** If we’re always increasing the pointer address, we can avoid the numeric\n cast by using the `add` method instead.\n\n **Known problems:** None\n\n **Example:**\n ```rust\n let vec = vec![b'a', b'b', b'c'];\n let ptr = vec.as_ptr();\n let offset = 1_usize;\n\n unsafe {\n     ptr.offset(offset as isize);\n }\n ```\n\n Could be written:\n\n ```rust\n let vec = vec![b'a', b'b', b'c'];\n let ptr = vec.as_ptr();\n let offset = 1_usize;\n\n unsafe {\n     ptr.add(offset);\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "question_mark",
+    "id_span": {
+      "path": "clippy_lints/src/question_mark.rs",
+      "line": 34
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for expressions that could be replaced by the question mark operator.\n **Why is this bad?** Question mark usage is more idiomatic.\n\n **Known problems:** None\n\n **Example:**\n ```ignore\n if option.is_none() {\n     return None;\n }\n ```\n\n Could be written:\n\n ```ignore\n option?;\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "range_zip_with_len",
+    "id_span": {
+      "path": "clippy_lints/src/ranges.rs",
+      "line": 40
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks for zipping a collection with the range of `0.._.len()`.\n\n **Why is this bad?** The code is better expressed with `.enumerate()`.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # let x = vec![1];\n x.iter().zip(0..x.len());\n ```\n Could be written as\n ```rust\n # let x = vec![1];\n x.iter().enumerate();\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "range_plus_one",
+    "id_span": {
+      "path": "clippy_lints/src/ranges.rs",
+      "line": 74
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Checks for exclusive ranges where 1 is added to the upper bound, e.g., `x..(y+1)`.\n\n **Why is this bad?** The code is more readable with an inclusive range\n like `x..=y`.\n\n **Known problems:** Will add unnecessary pair of parentheses when the\n expression is not wrapped in a pair but starts with a opening parenthesis\n and ends with a closing one.\n I.e., `let _ = (f()+1)..(f()+1)` results in `let _ = ((f()+1)..=f())`.\n\n Also in many cases, inclusive ranges are still slower to run than\n exclusive ranges, because they essentially add an extra branch that\n LLVM may fail to hoist out of the loop.\n\n This will cause a warning that cannot be fixed if the consumer of the\n range only accepts a specific range type, instead of the generic\n `RangeBounds` trait\n ([#3307](https://github.com/rust-lang/rust-clippy/issues/3307)).\n\n **Example:**\n ```rust,ignore\n for x..(y+1) { .. }\n ```\n Could be written as\n ```rust,ignore\n for x..=y { .. }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": true,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "range_minus_one",
+    "id_span": {
+      "path": "clippy_lints/src/ranges.rs",
+      "line": 99
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Checks for inclusive ranges where 1 is subtracted from the upper bound, e.g., `x..=(y-1)`.\n\n **Why is this bad?** The code is more readable with an exclusive range\n like `x..y`.\n\n **Known problems:** This will cause a warning that cannot be fixed if\n the consumer of the range only accepts a specific range type, instead of\n the generic `RangeBounds` trait\n ([#3307](https://github.com/rust-lang/rust-clippy/issues/3307)).\n\n **Example:**\n ```rust,ignore\n for x..=(y-1) { .. }\n ```\n Could be written as\n ```rust,ignore\n for x..y { .. }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "reversed_empty_ranges",
+    "id_span": {
+      "path": "clippy_lints/src/ranges.rs",
+      "line": 132
+    },
+    "group": "clippy::correctness",
+    "docs": " **What it does:** Checks for range expressions `x..y` where both `x` and `y` are constant and `x` is greater or equal to `y`.\n\n **Why is this bad?** Empty ranges yield no values so iterating them is a no-op.\n Moreover, trying to use a reversed range to index a slice will panic at run-time.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust,no_run\n fn main() {\n     (10..=0).for_each(|x| println!(\"{}\", x));\n\n     let arr = [1, 2, 3, 4, 5];\n     let sub = &arr[3..1];\n }\n ```\n Use instead:\n ```rust\n fn main() {\n     (0..=10).rev().for_each(|x| println!(\"{}\", x));\n\n     let arr = [1, 2, 3, 4, 5];\n     let sub = &arr[1..3];\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MaybeIncorrect"
+    }
+  },
+  {
+    "id": "manual_range_contains",
+    "id_span": {
+      "path": "clippy_lints/src/ranges.rs",
+      "line": 159
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for expressions like `x >= 3 && x < 8` that could be more readably expressed as `(3..8).contains(x)`.\n\n **Why is this bad?** `contains` expresses the intent better and has less\n failure modes (such as fencepost errors or using `||` instead of `&&`).\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n // given\n let x = 6;\n\n assert!(x >= 3 && x < 8);\n ```\n Use instead:\n ```rust\n# let x = 6;\n assert!((3..8).contains(&x));\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "redundant_clone",
+    "id_span": {
+      "path": "clippy_lints/src/redundant_clone.rs",
+      "line": 63
+    },
+    "group": "clippy::perf",
+    "docs": " **What it does:** Checks for a redundant `clone()` (and its relatives) which clones an owned value that is going to be dropped without further use.\n\n **Why is this bad?** It is not always possible for the compiler to eliminate useless\n allocations and deallocations generated by redundant `clone()`s.\n\n **Known problems:**\n\n False-negatives: analysis performed by this lint is conservative and limited.\n\n **Example:**\n ```rust\n # use std::path::Path;\n # #[derive(Clone)]\n # struct Foo;\n # impl Foo {\n #     fn new() -> Self { Foo {} }\n # }\n # fn call(x: Foo) {}\n {\n     let x = Foo::new();\n     call(x.clone());\n     call(x.clone()); // this can just pass `x`\n }\n\n [\"lorem\", \"ipsum\"].join(\" \").to_string();\n\n Path::new(\"/a/b\").join(\"c\").to_path_buf();\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "redundant_closure_call",
+    "id_span": {
+      "path": "clippy_lints/src/redundant_closure_call.rs",
+      "line": 32
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Detects closures called in the same expression where they are defined.\n\n **Why is this bad?** It is unnecessarily adding to the expression's\n complexity.\n\n **Known problems:** None.\n\n **Example:**\n ```rust,ignore\n // Bad\n let a = (|| 42)()\n\n // Good\n let a = 42\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "redundant_else",
+    "id_span": {
+      "path": "clippy_lints/src/redundant_else.rs",
+      "line": 37
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Checks for `else` blocks that can be removed without changing semantics.\n **Why is this bad?** The `else` block adds unnecessary indentation and verbosity.\n\n **Known problems:** Some may prefer to keep the `else` block for clarity.\n\n **Example:**\n\n ```rust\n fn my_func(count: u32) {\n     if count == 0 {\n         print!(\"Nothing to do\");\n         return;\n     } else {\n         print!(\"Moving on...\");\n     }\n }\n ```\n Use instead:\n ```rust\n fn my_func(count: u32) {\n     if count == 0 {\n         print!(\"Nothing to do\");\n         return;\n     }\n     print!(\"Moving on...\");\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "redundant_field_names",
+    "id_span": {
+      "path": "clippy_lints/src/redundant_field_names.rs",
+      "line": 34
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for fields in struct literals where shorthands could be used.\n\n **Why is this bad?** If the field and variable names are the same,\n the field name is redundant.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n let bar: u8 = 123;\n\n struct Foo {\n     bar: u8,\n }\n\n let foo = Foo { bar: bar };\n ```\n the last line can be simplified to\n ```ignore\n let foo = Foo { bar };\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "redundant_pub_crate",
+    "id_span": {
+      "path": "clippy_lints/src/redundant_pub_crate.rs",
+      "line": 30
+    },
+    "group": "clippy::nursery",
+    "docs": " **What it does:** Checks for items declared `pub(crate)` that are not crate visible because they are inside a private module.\n\n **Why is this bad?** Writing `pub(crate)` is misleading when it's redundant due to the parent\n module's visibility.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n mod internal {\n     pub(crate) fn internal_fn() { }\n }\n ```\n This function is not visible outside the module and it can be declared with `pub` or\n private visibility\n ```rust\n mod internal {\n     pub fn internal_fn() { }\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "redundant_slicing",
+    "id_span": {
+      "path": "clippy_lints/src/redundant_slicing.rs",
+      "line": 33
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks for redundant slicing expressions which use the full range, and do not change the type.\n\n **Why is this bad?** It unnecessarily adds complexity to the expression.\n\n **Known problems:** If the type being sliced has an implementation of `Index<RangeFull>`\n that actually changes anything then it can't be removed. However, this would be surprising\n to people reading the code and should have a note with it.\n\n **Example:**\n\n ```ignore\n fn get_slice(x: &[u32]) -> &[u32] {\n     &x[..]\n }\n ```\n Use instead:\n ```ignore\n fn get_slice(x: &[u32]) -> &[u32] {\n     x\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "redundant_static_lifetimes",
+    "id_span": {
+      "path": "clippy_lints/src/redundant_static_lifetimes.rs",
+      "line": 30
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for constants and statics with an explicit `'static` lifetime.\n **Why is this bad?** Adding `'static` to every reference can create very\n complicated types.\n\n **Known problems:** None.\n\n **Example:**\n ```ignore\n const FOO: &'static [(&'static str, &'static str, fn(&Bar) -> bool)] =\n &[...]\n static FOO: &'static [(&'static str, &'static str, fn(&Bar) -> bool)] =\n &[...]\n ```\n This code can be rewritten as\n ```ignore\n  const FOO: &[(&str, &str, fn(&Bar) -> bool)] = &[...]\n  static FOO: &[(&str, &str, fn(&Bar) -> bool)] = &[...]\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "ref_option_ref",
+    "id_span": {
+      "path": "clippy_lints/src/ref_option_ref.rs",
+      "line": 28
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Checks for usage of `&Option<&T>`.\n **Why is this bad?** Since `&` is Copy, it's useless to have a\n reference on `Option<&T>`.\n\n **Known problems:** It may be irrelevant to use this lint on\n public API code as it will make a breaking change to apply it.\n\n **Example:**\n\n ```rust,ignore\n let x: &Option<&u32> = &Some(&0u32);\n ```\n Use instead:\n ```rust,ignore\n let x: Option<&u32> = Some(&0u32);\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MaybeIncorrect"
+    }
+  },
+  {
+    "id": "deref_addrof",
+    "id_span": {
+      "path": "clippy_lints/src/reference.rs",
+      "line": 29
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks for usage of `*&` and `*&mut` in expressions.\n **Why is this bad?** Immediately dereferencing a reference is no-op and\n makes the code less clear.\n\n **Known problems:** Multiple dereference/addrof pairs are not handled so\n the suggested fix for `x = **&&y` is `x = *&y`, which is still incorrect.\n\n **Example:**\n ```rust,ignore\n // Bad\n let a = f(*&mut b);\n let c = *&d;\n\n // Good\n let a = f(b);\n let c = d;\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "ref_in_deref",
+    "id_span": {
+      "path": "clippy_lints/src/reference.rs",
+      "line": 120
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks for references in expressions that use auto dereference.\n\n **Why is this bad?** The reference is a no-op and is automatically\n dereferenced by the compiler and makes the code less clear.\n\n **Example:**\n ```rust\n struct Point(u32, u32);\n let point = Point(30, 20);\n let x = (&point).0;\n ```\n Use instead:\n ```rust\n # struct Point(u32, u32);\n # let point = Point(30, 20);\n let x = point.0;\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "invalid_regex",
+    "id_span": {
+      "path": "clippy_lints/src/regex.rs",
+      "line": 25
+    },
+    "group": "clippy::correctness",
+    "docs": " **What it does:** Checks [regex](https://crates.io/crates/regex) creation (with `Regex::new`, `RegexBuilder::new`, or `RegexSet::new`) for correct\n regex syntax.\n\n **Why is this bad?** This will lead to a runtime panic.\n\n **Known problems:** None.\n\n **Example:**\n ```ignore\n Regex::new(\"|\")\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "trivial_regex",
+    "id_span": {
+      "path": "clippy_lints/src/regex.rs",
+      "line": 46
+    },
+    "group": "clippy::nursery",
+    "docs": " **What it does:** Checks for trivial [regex](https://crates.io/crates/regex) creation (with `Regex::new`, `RegexBuilder::new`, or `RegexSet::new`).\n\n **Why is this bad?** Matching the regex can likely be replaced by `==` or\n `str::starts_with`, `str::ends_with` or `std::contains` or other `str`\n methods.\n\n **Known problems:** If the same regex is going to be applied to multiple\n inputs, the precomputations done by `Regex` construction can give\n significantly better performance than any of the `str`-based methods.\n\n **Example:**\n ```ignore\n Regex::new(\"^foobar\")\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "repeat_once",
+    "id_span": {
+      "path": "clippy_lints/src/repeat_once.rs",
+      "line": 33
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks for usage of `.repeat(1)` and suggest the following method for each types. - `.to_string()` for `str`\n - `.clone()` for `String`\n - `.to_vec()` for `slice`\n\n **Why is this bad?** For example, `String.repeat(1)` is equivalent to `.clone()`. If cloning the string is the intention behind this, `clone()` should be used.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n fn main() {\n     let x = String::from(\"hello world\").repeat(1);\n }\n ```\n Use instead:\n ```rust\n fn main() {\n     let x = String::from(\"hello world\").clone();\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "let_and_return",
+    "id_span": {
+      "path": "clippy_lints/src/returns.rs",
+      "line": 38
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for `let`-bindings, which are subsequently returned.\n\n **Why is this bad?** It is just extraneous code. Remove it to make your code\n more rusty.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n fn foo() -> String {\n     let x = String::new();\n     x\n }\n ```\n instead, use\n ```\n fn foo() -> String {\n     String::new()\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": true,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "needless_return",
+    "id_span": {
+      "path": "clippy_lints/src/returns.rs",
+      "line": 63
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for return statements at the end of a block.\n **Why is this bad?** Removing the `return` and semicolon will make the code\n more rusty.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n fn foo(x: usize) -> usize {\n     return x;\n }\n ```\n simplify to\n ```rust\n fn foo(x: usize) -> usize {\n     x\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "self_assignment",
+    "id_span": {
+      "path": "clippy_lints/src/self_assignment.rs",
+      "line": 29
+    },
+    "group": "clippy::correctness",
+    "docs": " **What it does:** Checks for explicit self-assignments.\n **Why is this bad?** Self-assignments are redundant and unlikely to be\n intentional.\n\n **Known problems:** If expression contains any deref coercions or\n indexing operations they are assumed not to have any side effects.\n\n **Example:**\n\n ```rust\n struct Event {\n     id: usize,\n     x: i32,\n     y: i32,\n }\n\n fn copy_position(a: &mut Event, b: &Event) {\n     a.x = b.x;\n     a.y = a.y;\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "semicolon_if_nothing_returned",
+    "id_span": {
+      "path": "clippy_lints/src/semicolon_if_nothing_returned.rs",
+      "line": 30
+    },
+    "group": "clippy::restriction",
+    "docs": " **What it does:** Looks for blocks of expressions and fires if the last expression returns `()` but is not followed by a semicolon.\n\n **Why is this bad?** The semicolon might be optional but when\n extending the block with new code, it doesn't require a change in previous last line.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n fn main() {\n     println!(\"Hello world\")\n }\n ```\n Use instead:\n ```rust\n fn main() {\n     println!(\"Hello world\");\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MaybeIncorrect"
+    }
+  },
+  {
+    "id": "serde_api_misuse",
+    "id_span": {
+      "path": "clippy_lints/src/serde_api.rs",
+      "line": 16
+    },
+    "group": "clippy::correctness",
+    "docs": " **What it does:** Checks for mis-uses of the serde API.\n **Why is this bad?** Serde is very finnicky about how its API should be\n used, but the type system can't be used to enforce it (yet?).\n\n **Known problems:** None.\n\n **Example:** Implementing `Visitor::visit_string` but not\n `Visitor::visit_str`.\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "shadow_same",
+    "id_span": {
+      "path": "clippy_lints/src/shadow.rs",
+      "line": 34
+    },
+    "group": "clippy::restriction",
+    "docs": " **What it does:** Checks for bindings that shadow other bindings already in scope, while just changing reference level or mutability.\n\n **Why is this bad?** Not much, in fact it's a very common pattern in Rust\n code. Still, some may opt to avoid it in their code base, they can set this\n lint to `Warn`.\n\n **Known problems:** This lint, as the other shadowing related lints,\n currently only catches very simple patterns.\n\n **Example:**\n ```rust\n # let x = 1;\n // Bad\n let x = &x;\n\n // Good\n let y = &x; // use different variable name\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "shadow_reuse",
+    "id_span": {
+      "path": "clippy_lints/src/shadow.rs",
+      "line": 61
+    },
+    "group": "clippy::restriction",
+    "docs": " **What it does:** Checks for bindings that shadow other bindings already in scope, while reusing the original value.\n\n **Why is this bad?** Not too much, in fact it's a common pattern in Rust\n code. Still, some argue that name shadowing like this hurts readability,\n because a value may be bound to different things depending on position in\n the code.\n\n **Known problems:** This lint, as the other shadowing related lints,\n currently only catches very simple patterns.\n\n **Example:**\n ```rust\n let x = 2;\n let x = x + 1;\n ```\n use different variable name:\n ```rust\n let x = 2;\n let y = x + 1;\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "shadow_unrelated",
+    "id_span": {
+      "path": "clippy_lints/src/shadow.rs",
+      "line": 93
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Checks for bindings that shadow other bindings already in scope, either without a initialization or with one that does not even use\n the original value.\n\n **Why is this bad?** Name shadowing can hurt readability, especially in\n large code bases, because it is easy to lose track of the active binding at\n any place in the code. This can be alleviated by either giving more specific\n names to bindings or introducing more scopes to contain the bindings.\n\n **Known problems:** This lint, as the other shadowing related lints,\n currently only catches very simple patterns. Note that\n `allow`/`warn`/`deny`/`forbid` attributes only work on the function level\n for this lint.\n\n **Example:**\n ```rust\n # let y = 1;\n # let z = 2;\n let x = y;\n\n // Bad\n let x = z; // shadows the earlier binding\n\n // Good\n let w = z; // use different variable name\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "single_component_path_imports",
+    "id_span": {
+      "path": "clippy_lints/src/single_component_path_imports.rs",
+      "line": 32
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checking for imports with single component use path.\n **Why is this bad?** Import with single component use path such as `use cratename;`\n is not necessary, and thus should be removed.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust,ignore\n use regex;\n\n fn main() {\n     regex::Regex::new(r\"^\\d{4}-\\d{2}-\\d{2}$\").unwrap();\n }\n ```\n Better as\n ```rust,ignore\n fn main() {\n     regex::Regex::new(r\"^\\d{4}-\\d{2}-\\d{2}$\").unwrap();\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "size_of_in_element_count",
+    "id_span": {
+      "path": "clippy_lints/src/size_of_in_element_count.rs",
+      "line": 31
+    },
+    "group": "clippy::correctness",
+    "docs": " **What it does:** Detects expressions where `size_of::<T>` or `size_of_val::<T>` is used as a\n count of elements of type `T`\n\n **Why is this bad?** These functions expect a count\n of `T` and not a number of bytes\n\n **Known problems:** None.\n\n **Example:**\n ```rust,no_run\n # use std::ptr::copy_nonoverlapping;\n # use std::mem::size_of;\n const SIZE: usize = 128;\n let x = [2u8; SIZE];\n let mut y = [2u8; SIZE];\n unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>() * SIZE) };\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "slow_vector_initialization",
+    "id_span": {
+      "path": "clippy_lints/src/slow_vector_initialization.rs",
+      "line": 37
+    },
+    "group": "clippy::perf",
+    "docs": " **What it does:** Checks slow zero-filled vector initialization\n **Why is this bad?** These structures are non-idiomatic and less efficient than simply using\n `vec![0; len]`.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # use core::iter::repeat;\n # let len = 4;\n\n // Bad\n let mut vec1 = Vec::with_capacity(len);\n vec1.resize(len, 0);\n\n let mut vec2 = Vec::with_capacity(len);\n vec2.extend(repeat(0).take(len));\n\n // Good\n let mut vec1 = vec![0; len];\n let mut vec2 = vec![0; len];\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "Unspecified"
+    }
+  },
+  {
+    "id": "stable_sort_primitive",
+    "id_span": {
+      "path": "clippy_lints/src/stable_sort_primitive.rs",
+      "line": 36
+    },
+    "group": "clippy::perf",
+    "docs": " **What it does:** When sorting primitive values (integers, bools, chars, as well\n as arrays, slices, and tuples of such items), it is better to\n use an unstable sort than a stable sort.\n\n **Why is this bad?**\n Using a stable sort consumes more memory and cpu cycles. Because\n values which compare equal are identical, preserving their\n relative order (the guarantee that a stable sort provides) means\n nothing, while the extra costs still apply.\n\n **Known problems:**\n None\n\n **Example:**\n\n ```rust\n let mut vec = vec![2, 1, 3];\n vec.sort();\n ```\n Use instead:\n ```rust\n let mut vec = vec![2, 1, 3];\n vec.sort_unstable();\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "string_add_assign",
+    "id_span": {
+      "path": "clippy_lints/src/strings.rs",
+      "line": 37
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Checks for string appends of the form `x = x + y` (without `let`!).\n\n **Why is this bad?** It's not really bad, but some people think that the\n `.push_str(_)` method is more readable.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n let mut x = \"Hello\".to_owned();\n x = x + \", World\";\n\n // More readable\n x += \", World\";\n x.push_str(\", World\");\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "string_add",
+    "id_span": {
+      "path": "clippy_lints/src/strings.rs",
+      "line": 65
+    },
+    "group": "clippy::restriction",
+    "docs": " **What it does:** Checks for all instances of `x + _` where `x` is of type `String`, but only if [`string_add_assign`](#string_add_assign) does *not*\n match.\n\n **Why is this bad?** It's not bad in and of itself. However, this particular\n `Add` implementation is asymmetric (the other operand need not be `String`,\n but `x` does), while addition as mathematically defined is symmetric, also\n the `String::push_str(_)` function is a perfectly good replacement.\n Therefore, some dislike it and wish not to have it in their code.\n\n That said, other people think that string addition, having a long tradition\n in other languages is actually fine, which is why we decided to make this\n particular lint `allow` by default.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n let x = \"Hello\".to_owned();\n x + \", World\";\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "string_lit_as_bytes",
+    "id_span": {
+      "path": "clippy_lints/src/strings.rs",
+      "line": 107
+    },
+    "group": "clippy::nursery",
+    "docs": " **What it does:** Checks for the `as_bytes` method called on string literals that contain only ASCII characters.\n\n **Why is this bad?** Byte string literals (e.g., `b\"foo\"`) can be used\n instead. They are shorter but less discoverable than `as_bytes()`.\n\n **Known Problems:**\n `\"str\".as_bytes()` and the suggested replacement of `b\"str\"` are not\n equivalent because they have different types. The former is `&[u8]`\n while the latter is `&[u8; 3]`. That means in general they will have a\n different set of methods and different trait implementations.\n\n ```compile_fail\n fn f(v: Vec<u8>) {}\n\n f(\"...\".as_bytes().to_owned()); // works\n f(b\"...\".to_owned()); // does not work, because arg is [u8; 3] not Vec<u8>\n\n fn g(r: impl std::io::Read) {}\n\n g(\"...\".as_bytes()); // works\n g(b\"...\"); // does not work\n ```\n\n The actual equivalent of `\"str\".as_bytes()` with the same type is not\n `b\"str\"` but `&b\"str\"[..]`, which is a great deal of punctuation and not\n more readable than a function call.\n\n **Example:**\n ```rust\n // Bad\n let bs = \"a byte string\".as_bytes();\n\n // Good\n let bs = b\"a byte string\";\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "string_from_utf8_as_bytes",
+    "id_span": {
+      "path": "clippy_lints/src/strings.rs",
+      "line": 196
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Check if the string is transformed to byte array and casted back to string.\n **Why is this bad?** It's unnecessary, the string can be used directly.\n\n **Known problems:** None\n\n **Example:**\n ```rust\n let _ = std::str::from_utf8(&\"Hello World!\".as_bytes()[6..11]).unwrap();\n ```\n could be written as\n ```rust\n let _ = &\"Hello World!\"[6..11];\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "str_to_string",
+    "id_span": {
+      "path": "clippy_lints/src/strings.rs",
+      "line": 313
+    },
+    "group": "clippy::restriction",
+    "docs": " **What it does:** This lint checks for `.to_string()` method calls on values of type `&str`.\n **Why is this bad?** The `to_string` method is also used on other types to convert them to a string.\n When called on a `&str` it turns the `&str` into the owned variant `String`, which can be better\n expressed with `.to_owned()`.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n // example code where clippy issues a warning\n let _ = \"str\".to_string();\n ```\n Use instead:\n ```rust\n // example code which does not raise clippy warning\n let _ = \"str\".to_owned();\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "string_to_string",
+    "id_span": {
+      "path": "clippy_lints/src/strings.rs",
+      "line": 362
+    },
+    "group": "clippy::restriction",
+    "docs": " **What it does:** This lint checks for `.to_string()` method calls on values of type `String`.\n **Why is this bad?** The `to_string` method is also used on other types to convert them to a string.\n When called on a `String` it only clones the `String`, which can be better expressed with `.clone()`.\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n // example code where clippy issues a warning\n let msg = String::from(\"Hello World\");\n let _ = msg.to_string();\n ```\n Use instead:\n ```rust\n // example code which does not raise clippy warning\n let msg = String::from(\"Hello World\");\n let _ = msg.clone();\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "suspicious_operation_groupings",
+    "id_span": {
+      "path": "clippy_lints/src/suspicious_operation_groupings.rs",
+      "line": 60
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for unlikely usages of binary operators that are almost\n certainly typos and/or copy/paste errors, given the other usages\n of binary operators nearby.\n **Why is this bad?**\n They are probably bugs and if they aren't then they look like bugs\n and you should add a comment explaining why you are doing such an\n odd set of operations.\n **Known problems:**\n There may be some false positives if you are trying to do something\n unusual that happens to look like a typo.\n\n **Example:**\n\n ```rust\n struct Vec3 {\n     x: f64,\n     y: f64,\n     z: f64,\n }\n\n impl Eq for Vec3 {}\n\n impl PartialEq for Vec3 {\n     fn eq(&self, other: &Self) -> bool {\n         // This should trigger the lint because `self.x` is compared to `other.y`\n         self.x == other.y && self.y == other.y && self.z == other.z\n     }\n }\n ```\n Use instead:\n ```rust\n # struct Vec3 {\n #     x: f64,\n #     y: f64,\n #     z: f64,\n # }\n // same as above except:\n impl PartialEq for Vec3 {\n     fn eq(&self, other: &Self) -> bool {\n         // Note we now compare other.x to self.x\n         self.x == other.x && self.y == other.y && self.z == other.z\n     }\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "suspicious_arithmetic_impl",
+    "id_span": {
+      "path": "clippy_lints/src/suspicious_trait_impl.rs",
+      "line": 27
+    },
+    "group": "clippy::correctness",
+    "docs": " **What it does:** Lints for suspicious operations in impls of arithmetic operators, e.g. subtracting elements in an Add impl.\n\n **Why this is bad?** This is probably a typo or copy-and-paste error and not intended.\n\n **Known problems:** None.\n\n **Example:**\n ```ignore\n impl Add for Foo {\n     type Output = Foo;\n\n     fn add(self, other: Foo) -> Foo {\n         Foo(self.0 - other.0)\n     }\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "suspicious_op_assign_impl",
+    "id_span": {
+      "path": "clippy_lints/src/suspicious_trait_impl.rs",
+      "line": 48
+    },
+    "group": "clippy::correctness",
+    "docs": " **What it does:** Lints for suspicious operations in impls of OpAssign, e.g. subtracting elements in an AddAssign impl.\n\n **Why this is bad?** This is probably a typo or copy-and-paste error and not intended.\n\n **Known problems:** None.\n\n **Example:**\n ```ignore\n impl AddAssign for Foo {\n     fn add_assign(&mut self, other: Foo) {\n         *self = *self - other;\n     }\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "manual_swap",
+    "id_span": {
+      "path": "clippy_lints/src/swap.rs",
+      "line": 36
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks for manual swapping.\n **Why is this bad?** The `std::mem::swap` function exposes the intent better\n without deinitializing or copying either variable.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n let mut a = 42;\n let mut b = 1337;\n\n let t = b;\n b = a;\n a = t;\n ```\n Use std::mem::swap():\n ```rust\n let mut a = 1;\n let mut b = 2;\n std::mem::swap(&mut a, &mut b);\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "almost_swapped",
+    "id_span": {
+      "path": "clippy_lints/src/swap.rs",
+      "line": 61
+    },
+    "group": "clippy::correctness",
+    "docs": " **What it does:** Checks for `foo = bar; bar = foo` sequences.\n **Why is this bad?** This looks like a failed attempt to swap.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # let mut a = 1;\n # let mut b = 2;\n a = b;\n b = a;\n ```\n If swapping is intended, use `swap()` instead:\n ```rust\n # let mut a = 1;\n # let mut b = 2;\n std::mem::swap(&mut a, &mut b);\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MaybeIncorrect"
+    }
+  },
+  {
+    "id": "tabs_in_doc_comments",
+    "id_span": {
+      "path": "clippy_lints/src/tabs_in_doc_comments.rs",
+      "line": 54
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks doc comments for usage of tab characters.\n **Why is this bad?** The rust style-guide promotes spaces instead of tabs for indentation.\n To keep a consistent view on the source, also doc comments should not have tabs.\n Also, explaining ascii-diagrams containing tabs can get displayed incorrectly when the\n display settings of the author and reader differ.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n ///\n /// Struct to hold two strings:\n /// \t- first\t\tone\n /// \t- second\tone\n pub struct DoubleString {\n    ///\n    /// \t- First String:\n    /// \t\t- needs to be inside here\n    first_string: String,\n    ///\n    /// \t- Second String:\n    /// \t\t- needs to be inside here\n    second_string: String,\n}\n ```\n\n Will be converted to:\n ```rust\n ///\n /// Struct to hold two strings:\n ///     - first        one\n ///     - second    one\n pub struct DoubleString {\n    ///\n    ///     - First String:\n    ///         - needs to be inside here\n    first_string: String,\n    ///\n    ///     - Second String:\n    ///         - needs to be inside here\n    second_string: String,\n}\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MaybeIncorrect"
+    }
+  },
+  {
+    "id": "temporary_assignment",
+    "id_span": {
+      "path": "clippy_lints/src/temporary_assignment.rs",
+      "line": 19
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks for construction of a structure or tuple just to assign a value in it.\n\n **Why is this bad?** Readability. If the structure is only created to be\n updated, why not write the structure you want in the first place?\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n (0, 0).0 = 1\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "to_digit_is_some",
+    "id_span": {
+      "path": "clippy_lints/src/to_digit_is_some.rs",
+      "line": 27
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for `.to_digit(..).is_some()` on `char`s.\n **Why is this bad?** This is a convoluted way of checking if a `char` is a digit. It's\n more straight forward to use the dedicated `is_digit` method.\n\n **Example:**\n ```rust\n # let c = 'c';\n # let radix = 10;\n let is_digit = c.to_digit(radix).is_some();\n ```\n can be written as:\n ```\n # let c = 'c';\n # let radix = 10;\n let is_digit = c.is_digit(radix);\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "to_string_in_display",
+    "id_span": {
+      "path": "clippy_lints/src/to_string_in_display.rs",
+      "line": 40
+    },
+    "group": "clippy::correctness",
+    "docs": " **What it does:** Checks for uses of `to_string()` in `Display` traits.\n **Why is this bad?** Usually `to_string` is implemented indirectly\n via `Display`. Hence using it while implementing `Display` would\n lead to infinite recursion.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n use std::fmt;\n\n struct Structure(i32);\n impl fmt::Display for Structure {\n     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n         write!(f, \"{}\", self.to_string())\n     }\n }\n\n ```\n Use instead:\n ```rust\n use std::fmt;\n\n struct Structure(i32);\n impl fmt::Display for Structure {\n     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n         write!(f, \"{}\", self.0)\n     }\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "type_repetition_in_bounds",
+    "id_span": {
+      "path": "clippy_lints/src/trait_bounds.rs",
+      "line": 28
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** This lint warns about unnecessary type repetitions in trait bounds\n **Why is this bad?** Repeating the type for every bound makes the code\n less readable than combining the bounds\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n pub fn foo<T>(t: T) where T: Copy, T: Clone {}\n ```\n\n Could be written as:\n\n ```rust\n pub fn foo<T>(t: T) where T: Copy + Clone {}\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "trait_duplication_in_bounds",
+    "id_span": {
+      "path": "clippy_lints/src/trait_bounds.rs",
+      "line": 57
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Checks for cases where generics are being used and multiple syntax specifications for trait bounds are used simultaneously.\n\n **Why is this bad?** Duplicate bounds makes the code\n less readable than specifing them only once.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n fn func<T: Clone + Default>(arg: T) where T: Clone + Default {}\n ```\n\n Could be written as:\n\n ```rust\n fn func<T: Clone + Default>(arg: T) {}\n ```\n or\n\n ```rust\n fn func<T>(arg: T) where T: Clone + Default {}\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "wrong_transmute",
+    "id_span": {
+      "path": "clippy_lints/src/transmute.rs",
+      "line": 29
+    },
+    "group": "clippy::correctness",
+    "docs": " **What it does:** Checks for transmutes that can't ever be correct on any architecture.\n\n **Why is this bad?** It's basically guaranteed to be undefined behaviour.\n\n **Known problems:** When accessing C, users might want to store pointer\n sized objects in `extradata` arguments to save an allocation.\n\n **Example:**\n ```ignore\n let ptr: *const T = core::intrinsics::transmute('x')\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "useless_transmute",
+    "id_span": {
+      "path": "clippy_lints/src/transmute.rs",
+      "line": 48
+    },
+    "group": "clippy::nursery",
+    "docs": " **What it does:** Checks for transmutes to the original type of the object and transmutes that could be a cast.\n\n **Why is this bad?** Readability. The code tricks people into thinking that\n something complex is going on.\n\n **Known problems:** None.\n\n **Example:**\n ```rust,ignore\n core::intrinsics::transmute(t); // where the result type is the same as `t`'s\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "Unspecified"
+    }
+  },
+  {
+    "id": "transmutes_expressible_as_ptr_casts",
+    "id_span": {
+      "path": "clippy_lints/src/transmute.rs",
+      "line": 73
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:**Checks for transmutes that could be a pointer cast.\n **Why is this bad?** Readability. The code tricks people into thinking that\n something complex is going on.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n # let p: *const [i32] = &[];\n unsafe { std::mem::transmute::<*const [i32], *const [u16]>(p) };\n ```\n Use instead:\n ```rust\n # let p: *const [i32] = &[];\n p as *const [u16];\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "crosspointer_transmute",
+    "id_span": {
+      "path": "clippy_lints/src/transmute.rs",
+      "line": 91
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks for transmutes between a type `T` and `*T`.\n **Why is this bad?** It's easy to mistakenly transmute between a type and a\n pointer to that type.\n\n **Known problems:** None.\n\n **Example:**\n ```rust,ignore\n core::intrinsics::transmute(t) // where the result type is the same as\n                                // `*t` or `&t`'s\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "transmute_ptr_to_ref",
+    "id_span": {
+      "path": "clippy_lints/src/transmute.rs",
+      "line": 116
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks for transmutes from a pointer to a reference.\n **Why is this bad?** This can always be rewritten with `&` and `*`.\n\n **Known problems:**\n - `mem::transmute` in statics and constants is stable from Rust 1.46.0,\n while dereferencing raw pointer is not stable yet.\n If you need to do this in those places,\n you would have to use `transmute` instead.\n\n **Example:**\n ```rust,ignore\n unsafe {\n     let _: &T = std::mem::transmute(p); // where p: *const T\n }\n\n // can be written:\n let _: &T = &*p;\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "Unspecified"
+    }
+  },
+  {
+    "id": "transmute_int_to_char",
+    "id_span": {
+      "path": "clippy_lints/src/transmute.rs",
+      "line": 147
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks for transmutes from an integer to a `char`.\n **Why is this bad?** Not every integer is a Unicode scalar value.\n\n **Known problems:**\n - [`from_u32`] which this lint suggests using is slower than `transmute`\n as it needs to validate the input.\n If you are certain that the input is always a valid Unicode scalar value,\n use [`from_u32_unchecked`] which is as fast as `transmute`\n but has a semantically meaningful name.\n - You might want to handle `None` returned from [`from_u32`] instead of calling `unwrap`.\n\n [`from_u32`]: https://doc.rust-lang.org/std/char/fn.from_u32.html\n [`from_u32_unchecked`]: https://doc.rust-lang.org/std/char/fn.from_u32_unchecked.html\n\n **Example:**\n ```rust\n let x = 1_u32;\n unsafe {\n     let _: char = std::mem::transmute(x); // where x: u32\n }\n\n // should be:\n let _ = std::char::from_u32(x).unwrap();\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "Unspecified"
+    }
+  },
+  {
+    "id": "transmute_bytes_to_str",
+    "id_span": {
+      "path": "clippy_lints/src/transmute.rs",
+      "line": 178
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks for transmutes from a `&[u8]` to a `&str`.\n **Why is this bad?** Not every byte slice is a valid UTF-8 string.\n\n **Known problems:**\n - [`from_utf8`] which this lint suggests using is slower than `transmute`\n as it needs to validate the input.\n If you are certain that the input is always a valid UTF-8,\n use [`from_utf8_unchecked`] which is as fast as `transmute`\n but has a semantically meaningful name.\n - You might want to handle errors returned from [`from_utf8`] instead of calling `unwrap`.\n\n [`from_utf8`]: https://doc.rust-lang.org/std/str/fn.from_utf8.html\n [`from_utf8_unchecked`]: https://doc.rust-lang.org/std/str/fn.from_utf8_unchecked.html\n\n **Example:**\n ```rust\n let b: &[u8] = &[1_u8, 2_u8];\n unsafe {\n     let _: &str = std::mem::transmute(b); // where b: &[u8]\n }\n\n // should be:\n let _ = std::str::from_utf8(b).unwrap();\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "Unspecified"
+    }
+  },
+  {
+    "id": "transmute_int_to_bool",
+    "id_span": {
+      "path": "clippy_lints/src/transmute.rs",
+      "line": 200
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks for transmutes from an integer to a `bool`.\n **Why is this bad?** This might result in an invalid in-memory representation of a `bool`.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n let x = 1_u8;\n unsafe {\n     let _: bool = std::mem::transmute(x); // where x: u8\n }\n\n // should be:\n let _: bool = x != 0;\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "Unspecified"
+    }
+  },
+  {
+    "id": "transmute_int_to_float",
+    "id_span": {
+      "path": "clippy_lints/src/transmute.rs",
+      "line": 222
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks for transmutes from an integer to a float.\n **Why is this bad?** Transmutes are dangerous and error-prone, whereas `from_bits` is intuitive\n and safe.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n unsafe {\n     let _: f32 = std::mem::transmute(1_u32); // where x: u32\n }\n\n // should be:\n let _: f32 = f32::from_bits(1_u32);\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "Unspecified"
+    }
+  },
+  {
+    "id": "transmute_float_to_int",
+    "id_span": {
+      "path": "clippy_lints/src/transmute.rs",
+      "line": 244
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks for transmutes from a float to an integer.\n **Why is this bad?** Transmutes are dangerous and error-prone, whereas `to_bits` is intuitive\n and safe.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n unsafe {\n     let _: u32 = std::mem::transmute(1f32);\n }\n\n // should be:\n let _: u32 = 1f32.to_bits();\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "Unspecified"
+    }
+  },
+  {
+    "id": "transmute_ptr_to_ptr",
+    "id_span": {
+      "path": "clippy_lints/src/transmute.rs",
+      "line": 271
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks for transmutes from a pointer to a pointer, or from a reference to a reference.\n\n **Why is this bad?** Transmutes are dangerous, and these can instead be\n written as casts.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n let ptr = &1u32 as *const u32;\n unsafe {\n     // pointer-to-pointer transmute\n     let _: *const f32 = std::mem::transmute(ptr);\n     // ref-ref transmute\n     let _: &f32 = std::mem::transmute(&1u32);\n }\n // These can be respectively written:\n let _ = ptr as *const f32;\n let _ = unsafe{ &*(&1u32 as *const u32 as *const f32) };\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "Unspecified"
+    }
+  },
+  {
+    "id": "unsound_collection_transmute",
+    "id_span": {
+      "path": "clippy_lints/src/transmute.rs",
+      "line": 299
+    },
+    "group": "clippy::correctness",
+    "docs": " **What it does:** Checks for transmutes between collections whose types have different ABI, size or alignment.\n\n **Why is this bad?** This is undefined behavior.\n\n **Known problems:** Currently, we cannot know whether a type is a\n collection, so we just lint the ones that come with `std`.\n\n **Example:**\n ```rust\n // different size, therefore likely out-of-bounds memory access\n // You absolutely do not want this in your code!\n unsafe {\n     std::mem::transmute::<_, Vec<u32>>(vec![2_u16])\n };\n ```\n\n You must always iterate, map and collect the values:\n\n ```rust\n vec![2_u16].into_iter().map(u32::from).collect::<Vec<_>>();\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "transmuting_null",
+    "id_span": {
+      "path": "clippy_lints/src/transmuting_null.rs",
+      "line": 23
+    },
+    "group": "clippy::correctness",
+    "docs": " **What it does:** Checks for transmute calls which would receive a null pointer.\n **Why is this bad?** Transmuting a null pointer is undefined behavior.\n\n **Known problems:** Not all cases can be detected at the moment of this writing.\n For example, variables which hold a null pointer and are then fed to a `transmute`\n call, aren't detectable yet.\n\n **Example:**\n ```rust\n let null_ref: &u64 = unsafe { std::mem::transmute(0 as *const u64) };\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "try_err",
+    "id_span": {
+      "path": "clippy_lints/src/try_err.rs",
+      "line": 43
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for usages of `Err(x)?`.\n **Why is this bad?** The `?` operator is designed to allow calls that\n can fail to be easily chained. For example, `foo()?.bar()` or\n `foo(bar()?)`. Because `Err(x)?` can't be used that way (it will\n always return), it is more clear to write `return Err(x)`.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n fn foo(fail: bool) -> Result<i32, String> {\n     if fail {\n       Err(\"failed\")?;\n     }\n     Ok(0)\n }\n ```\n Could be written:\n\n ```rust\n fn foo(fail: bool) -> Result<i32, String> {\n     if fail {\n       return Err(\"failed\".into());\n     }\n     Ok(0)\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "box_vec",
+    "id_span": {
+      "path": "clippy_lints/src/types.rs",
+      "line": 66
+    },
+    "group": "clippy::perf",
+    "docs": " **What it does:** Checks for use of `Box<Vec<_>>` anywhere in the code. Check the [Box documentation](https://doc.rust-lang.org/std/boxed/index.html) for more information.\n\n **Why is this bad?** `Vec` already keeps its contents in a separate area on\n the heap. So if you `Box` it, you just add another level of indirection\n without any benefit whatsoever.\n\n **Known problems:** None.\n\n **Example:**\n ```rust,ignore\n struct X {\n     values: Box<Vec<Foo>>,\n }\n ```\n\n Better:\n\n ```rust,ignore\n struct X {\n     values: Vec<Foo>,\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "vec_box",
+    "id_span": {
+      "path": "clippy_lints/src/types.rs",
+      "line": 95
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks for use of `Vec<Box<T>>` where T: Sized anywhere in the code. Check the [Box documentation](https://doc.rust-lang.org/std/boxed/index.html) for more information.\n\n **Why is this bad?** `Vec` already keeps its contents in a separate area on\n the heap. So if you `Box` its contents, you just add another level of indirection.\n\n **Known problems:** Vec<Box<T: Sized>> makes sense if T is a large type (see [#3530](https://github.com/rust-lang/rust-clippy/issues/3530),\n 1st comment).\n\n **Example:**\n ```rust\n struct X {\n     values: Vec<Box<i32>>,\n }\n ```\n\n Better:\n\n ```rust\n struct X {\n     values: Vec<i32>,\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "option_option",
+    "id_span": {
+      "path": "clippy_lints/src/types.rs",
+      "line": 133
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Checks for use of `Option<Option<_>>` in function signatures and type definitions\n\n **Why is this bad?** `Option<_>` represents an optional value. `Option<Option<_>>`\n represents an optional optional value which is logically the same thing as an optional\n value but has an unneeded extra level of wrapping.\n\n If you have a case where `Some(Some(_))`, `Some(None)` and `None` are distinct cases,\n consider a custom `enum` instead, with clear names for each case.\n\n **Known problems:** None.\n\n **Example**\n ```rust\n fn get_data() -> Option<Option<u32>> {\n     None\n }\n ```\n\n Better:\n\n ```rust\n pub enum Contents {\n     Data(Vec<u8>), // Was Some(Some(Vec<u8>))\n     NotYetFetched, // Was Some(None)\n     None,          // Was None\n }\n\n fn get_data() -> Contents {\n     Contents::None\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "linkedlist",
+    "id_span": {
+      "path": "clippy_lints/src/types.rs",
+      "line": 169
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Checks for usage of any `LinkedList`, suggesting to use a `Vec` or a `VecDeque` (formerly called `RingBuf`).\n\n **Why is this bad?** Gankro says:\n\n > The TL;DR of `LinkedList` is that it's built on a massive amount of\n pointers and indirection.\n > It wastes memory, it has terrible cache locality, and is all-around slow.\n `RingBuf`, while\n > \"only\" amortized for push/pop, should be faster in the general case for\n almost every possible\n > workload, and isn't even amortized at all if you can predict the capacity\n you need.\n >\n > `LinkedList`s are only really good if you're doing a lot of merging or\n splitting of lists.\n > This is because they can just mangle some pointers instead of actually\n copying the data. Even\n > if you're doing a lot of insertion in the middle of the list, `RingBuf`\n can still be better\n > because of how expensive it is to seek to the middle of a `LinkedList`.\n\n **Known problems:** False positives – the instances where using a\n `LinkedList` makes sense are few and far between, but they can still happen.\n\n **Example:**\n ```rust\n # use std::collections::LinkedList;\n let x: LinkedList<usize> = LinkedList::new();\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "borrowed_box",
+    "id_span": {
+      "path": "clippy_lints/src/types.rs",
+      "line": 193
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks for use of `&Box<T>` anywhere in the code. Check the [Box documentation](https://doc.rust-lang.org/std/boxed/index.html) for more information.\n\n **Why is this bad?** Any `&Box<T>` can also be a `&T`, which is more\n general.\n\n **Known problems:** None.\n\n **Example:**\n ```rust,ignore\n fn foo(bar: &Box<T>) { ... }\n ```\n\n Better:\n\n ```rust,ignore\n fn foo(bar: &T) { ... }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "Unspecified"
+    }
+  },
+  {
+    "id": "redundant_allocation",
+    "id_span": {
+      "path": "clippy_lints/src/types.rs",
+      "line": 217
+    },
+    "group": "clippy::perf",
+    "docs": " **What it does:** Checks for use of redundant allocations anywhere in the code.\n **Why is this bad?** Expressions such as `Rc<&T>`, `Rc<Rc<T>>`, `Rc<Box<T>>`, `Box<&T>`\n add an unnecessary level of indirection.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # use std::rc::Rc;\n fn foo(bar: Rc<&usize>) {}\n ```\n\n Better:\n\n ```rust\n fn foo(bar: &usize) {}\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "rc_buffer",
+    "id_span": {
+      "path": "clippy_lints/src/types.rs",
+      "line": 248
+    },
+    "group": "clippy::restriction",
+    "docs": " **What it does:** Checks for `Rc<T>` and `Arc<T>` when `T` is a mutable buffer type such as `String` or `Vec`.\n **Why is this bad?** Expressions such as `Rc<String>` usually have no advantage over `Rc<str>`, since\n it is larger and involves an extra level of indirection, and doesn't implement `Borrow<str>`.\n\n While mutating a buffer type would still be possible with `Rc::get_mut()`, it only\n works if there are no additional references yet, which usually defeats the purpose of\n enclosing it in a shared ownership type. Instead, additionally wrapping the inner\n type with an interior mutable container (such as `RefCell` or `Mutex`) would normally\n be used.\n\n **Known problems:** This pattern can be desirable to avoid the overhead of a `RefCell` or `Mutex` for\n cases where mutation only happens before there are any additional references.\n\n **Example:**\n ```rust,ignore\n # use std::rc::Rc;\n fn foo(interned: Rc<String>) { ... }\n ```\n\n Better:\n\n ```rust,ignore\n fn foo(interned: Rc<str>) { ... }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "let_unit_value",
+    "id_span": {
+      "path": "clippy_lints/src/types.rs",
+      "line": 768
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Checks for binding a unit value.\n **Why is this bad?** A unit value cannot usefully be used anywhere. So\n binding one is kind of pointless.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n let x = {\n     1;\n };\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "unit_cmp",
+    "id_span": {
+      "path": "clippy_lints/src/types.rs",
+      "line": 849
+    },
+    "group": "clippy::correctness",
+    "docs": " **What it does:** Checks for comparisons to unit. This includes all binary comparisons (like `==` and `<`) and asserts.\n\n **Why is this bad?** Unit is always equal to itself, and thus is just a\n clumsily written constant. Mostly this happens when someone accidentally\n adds semicolons at the end of the operands.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # fn foo() {};\n # fn bar() {};\n # fn baz() {};\n if {\n     foo();\n } == {\n     bar();\n } {\n     baz();\n }\n ```\n is equal to\n ```rust\n # fn foo() {};\n # fn bar() {};\n # fn baz() {};\n {\n     foo();\n     bar();\n     baz();\n }\n ```\n\n For asserts:\n ```rust\n # fn foo() {};\n # fn bar() {};\n assert_eq!({ foo(); }, { bar(); });\n ```\n will always succeed\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "unit_arg",
+    "id_span": {
+      "path": "clippy_lints/src/types.rs",
+      "line": 922
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks for passing a unit value as an argument to a function without using a unit literal (`()`).\n\n **Why is this bad?** This is likely the result of an accidental semicolon.\n\n **Known problems:** None.\n\n **Example:**\n ```rust,ignore\n foo({\n     let a = bar();\n     baz(a);\n })\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": true,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "cast_precision_loss",
+    "id_span": {
+      "path": "clippy_lints/src/types.rs",
+      "line": 1158
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Checks for casts from any numerical to a float type where the receiving type cannot store all values from the original type without\n rounding errors. This possible rounding is to be expected, so this lint is\n `Allow` by default.\n\n Basically, this warns on casting any integer with 32 or more bits to `f32`\n or any 64-bit integer to `f64`.\n\n **Why is this bad?** It's not bad at all. But in some applications it can be\n helpful to know where precision loss can take place. This lint can help find\n those places in the code.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n let x = u64::MAX;\n x as f64;\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "cast_sign_loss",
+    "id_span": {
+      "path": "clippy_lints/src/types.rs",
+      "line": 1179
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Checks for casts from a signed to an unsigned numerical type. In this case, negative values wrap around to large positive values,\n which can be quite surprising in practice. However, as the cast works as\n defined, this lint is `Allow` by default.\n\n **Why is this bad?** Possibly surprising results. You can activate this lint\n as a one-time check to see where numerical wrapping can arise.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n let y: i8 = -1;\n y as u128; // will return 18446744073709551615\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "cast_possible_truncation",
+    "id_span": {
+      "path": "clippy_lints/src/types.rs",
+      "line": 1201
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Checks for casts between numerical types that may truncate large values. This is expected behavior, so the cast is `Allow` by\n default.\n\n **Why is this bad?** In some problem domains, it is good practice to avoid\n truncation. This lint can be activated to help assess where additional\n checks could be beneficial.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n fn as_u8(x: u64) -> u8 {\n     x as u8\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "cast_possible_wrap",
+    "id_span": {
+      "path": "clippy_lints/src/types.rs",
+      "line": 1224
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Checks for casts from an unsigned type to a signed type of the same size. Performing such a cast is a 'no-op' for the compiler,\n i.e., nothing is changed at the bit level, and the binary representation of\n the value is reinterpreted. This can cause wrapping if the value is too big\n for the target signed type. However, the cast works as defined, so this lint\n is `Allow` by default.\n\n **Why is this bad?** While such a cast is not bad in itself, the results can\n be surprising when this is not the intended behavior, as demonstrated by the\n example below.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n u32::MAX as i32; // will yield a value of `-1`\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "cast_lossless",
+    "id_span": {
+      "path": "clippy_lints/src/types.rs",
+      "line": 1256
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Checks for casts between numerical types that may be replaced by safe conversion functions.\n\n **Why is this bad?** Rust's `as` keyword will perform many kinds of\n conversions, including silently lossy conversions. Conversion functions such\n as `i32::from` will only perform lossless conversions. Using the conversion\n functions prevents conversions from turning into silent lossy conversions if\n the types of the input expressions ever change, and make it easier for\n people reading the code to know that the conversion is lossless.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n fn as_u64(x: u8) -> u64 {\n     x as u64\n }\n ```\n\n Using `::from` would look like this:\n\n ```rust\n fn as_u64(x: u8) -> u64 {\n     u64::from(x)\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "unnecessary_cast",
+    "id_span": {
+      "path": "clippy_lints/src/types.rs",
+      "line": 1281
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks for casts to the same type, casts of int literals to integer types and casts of float literals to float types.\n\n **Why is this bad?** It's just unnecessary.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n let _ = 2i32 as i32;\n let _ = 0.5 as f32;\n ```\n\n Better:\n\n ```rust\n let _ = 2_i32;\n let _ = 0.5_f32;\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "cast_ptr_alignment",
+    "id_span": {
+      "path": "clippy_lints/src/types.rs",
+      "line": 1305
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Checks for casts, using `as` or `pointer::cast`, from a less-strictly-aligned pointer to a more-strictly-aligned pointer\n\n **Why is this bad?** Dereferencing the resulting pointer may be undefined\n behavior.\n\n **Known problems:** Using `std::ptr::read_unaligned` and `std::ptr::write_unaligned` or similar\n on the resulting pointer is fine. Is over-zealous: Casts with manual alignment checks or casts like\n u64-> u8 -> u16 can be fine. Miri is able to do a more in-depth analysis.\n\n **Example:**\n ```rust\n let _ = (&1u8 as *const u8) as *const u16;\n let _ = (&mut 1u8 as *mut u8) as *mut u16;\n\n (&1u8 as *const u8).cast::<u16>();\n (&mut 1u8 as *mut u8).cast::<u16>();\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "fn_to_numeric_cast",
+    "id_span": {
+      "path": "clippy_lints/src/types.rs",
+      "line": 1332
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for casts of function pointers to something other than usize\n **Why is this bad?**\n Casting a function pointer to anything other than usize/isize is not portable across\n architectures, because you end up losing bits if the target type is too small or end up with a\n bunch of extra bits that waste space and add more instructions to the final binary than\n strictly necessary for the problem\n\n Casting to isize also doesn't make sense since there are no signed addresses.\n\n **Example**\n\n ```rust\n // Bad\n fn fun() -> i32 { 1 }\n let a = fun as i64;\n\n // Good\n fn fun2() -> i32 { 1 }\n let a = fun2 as usize;\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MaybeIncorrect"
+    }
+  },
+  {
+    "id": "fn_to_numeric_cast_with_truncation",
+    "id_span": {
+      "path": "clippy_lints/src/types.rs",
+      "line": 1362
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for casts of a function pointer to a numeric type not wide enough to store address.\n\n **Why is this bad?**\n Such a cast discards some bits of the function's address. If this is intended, it would be more\n clearly expressed by casting to usize first, then casting the usize to the intended type (with\n a comment) to perform the truncation.\n\n **Example**\n\n ```rust\n // Bad\n fn fn1() -> i16 {\n     1\n };\n let _ = fn1 as i32;\n\n // Better: Cast to usize first, then comment with the reason for the truncation\n fn fn2() -> i16 {\n     1\n };\n let fn_ptr = fn2 as usize;\n let fn_ptr_truncated = fn_ptr as i32;\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MaybeIncorrect"
+    }
+  },
+  {
+    "id": "type_complexity",
+    "id_span": {
+      "path": "clippy_lints/src/types.rs",
+      "line": 1897
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks for types used in structs, parameters and `let` declarations above a certain complexity threshold.\n\n **Why is this bad?** Too complex types make the code less readable. Consider\n using a `type` definition to simplify them.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # use std::rc::Rc;\n struct Foo {\n     inner: Rc<Vec<Vec<Box<(u32, u32, u32, u32)>>>>,\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "char_lit_as_u8",
+    "id_span": {
+      "path": "clippy_lints/src/types.rs",
+      "line": 2068
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks for expressions where a character literal is cast to `u8` and suggests using a byte literal instead.\n\n **Why is this bad?** In general, casting values to smaller types is\n error-prone and should be avoided where possible. In the particular case of\n converting a character literal to u8, it is easy to avoid by just using a\n byte literal instead. As an added bonus, `b'a'` is even slightly shorter\n than `'a' as u8`.\n\n **Known problems:** None.\n\n **Example:**\n ```rust,ignore\n 'x' as u8\n ```\n\n A better version, using the byte literal:\n\n ```rust,ignore\n b'x'\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "absurd_extreme_comparisons",
+    "id_span": {
+      "path": "clippy_lints/src/types.rs",
+      "line": 2133
+    },
+    "group": "clippy::correctness",
+    "docs": " **What it does:** Checks for comparisons where one side of the relation is either the minimum or maximum value for its type and warns if it involves a\n case that is always true or always false. Only integer and boolean types are\n checked.\n\n **Why is this bad?** An expression like `min <= x` may misleadingly imply\n that it is possible for `x` to be less than the minimum. Expressions like\n `max < x` are probably mistakes.\n\n **Known problems:** For `usize` the size of the current compile target will\n be assumed (e.g., 64 bits on 64 bit systems). This means code that uses such\n a comparison to detect target pointer width will trigger this lint. One can\n use `mem::sizeof` and compare its value or conditional compilation\n attributes\n like `#[cfg(target_pointer_width = \"64\")] ..` instead.\n\n **Example:**\n\n ```rust\n let vec: Vec<isize> = Vec::new();\n if vec.len() <= 0 {}\n if 100 > i32::MAX {}\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "invalid_upcast_comparisons",
+    "id_span": {
+      "path": "clippy_lints/src/types.rs",
+      "line": 2294
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Checks for comparisons where the relation is always either true or false, but where one side has been upcast so that the comparison is\n necessary. Only integer types are checked.\n\n **Why is this bad?** An expression like `let x : u8 = ...; (x as u32) > 300`\n will mistakenly imply that it is possible for `x` to be outside the range of\n `u8`.\n\n **Known problems:**\n https://github.com/rust-lang/rust-clippy/issues/886\n\n **Example:**\n ```rust\n let x: u8 = 1;\n (x as u32) > 300;\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "implicit_hasher",
+    "id_span": {
+      "path": "clippy_lints/src/types.rs",
+      "line": 2515
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Checks for public `impl` or `fn` missing generalization over different hashers and implicitly defaulting to the default hashing\n algorithm (`SipHash`).\n\n **Why is this bad?** `HashMap` or `HashSet` with custom hashers cannot be\n used with them.\n\n **Known problems:** Suggestions for replacing constructors can contain\n false-positives. Also applying suggestions can require modification of other\n pieces of code, possibly including external crates.\n\n **Example:**\n ```rust\n # use std::collections::HashMap;\n # use std::hash::{Hash, BuildHasher};\n # trait Serialize {};\n impl<K: Hash + Eq, V> Serialize for HashMap<K, V> { }\n\n pub fn foo(map: &mut HashMap<i32, i32>) { }\n ```\n could be rewritten as\n ```rust\n # use std::collections::HashMap;\n # use std::hash::{Hash, BuildHasher};\n # trait Serialize {};\n impl<K: Hash + Eq, V, S: BuildHasher> Serialize for HashMap<K, V, S> { }\n\n pub fn foo<S: BuildHasher>(map: &mut HashMap<i32, i32, S>) { }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "cast_ref_to_mut",
+    "id_span": {
+      "path": "clippy_lints/src/types.rs",
+      "line": 2866
+    },
+    "group": "clippy::correctness",
+    "docs": " **What it does:** Checks for casts of `&T` to `&mut T` anywhere in the code.\n **Why is this bad?** It’s basically guaranteed to be undefined behaviour.\n `UnsafeCell` is the only way to obtain aliasable data that is considered\n mutable.\n\n **Known problems:** None.\n\n **Example:**\n ```rust,ignore\n fn x(r: &i32) {\n     unsafe {\n         *(r as *const _ as *mut _) += 1;\n     }\n }\n ```\n\n Instead consider using interior mutability types.\n\n ```rust\n use std::cell::UnsafeCell;\n\n fn x(r: &UnsafeCell<i32>) {\n     unsafe {\n         *r.get() += 1;\n     }\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "ptr_as_ptr",
+    "id_span": {
+      "path": "clippy_lints/src/types.rs",
+      "line": 2922
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Checks for `as` casts between raw pointers without changing its mutability,\n namely `*const T` to `*const U` and `*mut T` to `*mut U`.\n\n **Why is this bad?**\n Though `as` casts between raw pointers is not terrible, `pointer::cast` is safer because\n it cannot accidentally change the pointer's mutability nor cast the pointer to other types like `usize`.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n let ptr: *const u32 = &42_u32;\n let mut_ptr: *mut u32 = &mut 42_u32;\n let _ = ptr as *const i32;\n let _ = mut_ptr as *mut i32;\n ```\n Use instead:\n ```rust\n let ptr: *const u32 = &42_u32;\n let mut_ptr: *mut u32 = &mut 42_u32;\n let _ = ptr.cast::<i32>();\n let _ = mut_ptr.cast::<i32>();\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "undropped_manually_drops",
+    "id_span": {
+      "path": "clippy_lints/src/undropped_manually_drops.rs",
+      "line": 27
+    },
+    "group": "clippy::correctness",
+    "docs": " **What it does:** Prevents the safe `std::mem::drop` function from being called on `std::mem::ManuallyDrop`.\n **Why is this bad?** The safe `drop` function does not drop the inner value of a `ManuallyDrop`.\n\n **Known problems:** Does not catch cases if the user binds `std::mem::drop`\n to a different name and calls it that way.\n\n **Example:**\n\n ```rust\n struct S;\n drop(std::mem::ManuallyDrop::new(S));\n ```\n Use instead:\n ```rust\n struct S;\n unsafe {\n     std::mem::ManuallyDrop::drop(&mut std::mem::ManuallyDrop::new(S));\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "invisible_characters",
+    "id_span": {
+      "path": "clippy_lints/src/unicode.rs",
+      "line": 20
+    },
+    "group": "clippy::correctness",
+    "docs": " **What it does:** Checks for invisible Unicode characters in the code.\n **Why is this bad?** Having an invisible character in the code makes for all\n sorts of April fools, but otherwise is very much frowned upon.\n\n **Known problems:** None.\n\n **Example:** You don't see it, but there may be a zero-width space or soft hyphen\n some­where in this text.\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "non_ascii_literal",
+    "id_span": {
+      "path": "clippy_lints/src/unicode.rs",
+      "line": 44
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Checks for non-ASCII characters in string literals.\n **Why is this bad?** Yeah, we know, the 90's called and wanted their charset\n back. Even so, there still are editors and other programs out there that\n don't work well with Unicode. So if the code is meant to be used\n internationally, on multiple operating systems, or has other portability\n requirements, activating this lint could be useful.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n let x = String::from(\"€\");\n ```\n Could be written as:\n ```rust\n let x = String::from(\"\\u{20ac}\");\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "unicode_not_nfc",
+    "id_span": {
+      "path": "clippy_lints/src/unicode.rs",
+      "line": 61
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Checks for string literals that contain Unicode in a form that is not equal to its\n [NFC-recomposition](http://www.unicode.org/reports/tr15/#Norm_Forms).\n\n **Why is this bad?** If such a string is compared to another, the results\n may be surprising.\n\n **Known problems** None.\n\n **Example:** You may not see it, but \"à\"\" and \"à\"\" aren't the same string. The\n former when escaped is actually `\"a\\u{300}\"` while the latter is `\"\\u{e0}\"`.\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "unit_return_expecting_ord",
+    "id_span": {
+      "path": "clippy_lints/src/unit_return_expecting_ord.rs",
+      "line": 30
+    },
+    "group": "clippy::correctness",
+    "docs": " **What it does:** Checks for functions that expect closures of type Fn(...) -> Ord where the implemented closure returns the unit type.\n The lint also suggests to remove the semi-colon at the end of the statement if present.\n\n **Why is this bad?** Likely, returning the unit type is unintentional, and\n could simply be caused by an extra semi-colon. Since () implements Ord\n it doesn't cause a compilation error.\n This is the same reasoning behind the unit_cmp lint.\n\n **Known problems:** If returning unit is intentional, then there is no\n way of specifying this without triggering needless_return lint\n\n **Example:**\n\n ```rust\n let mut twins = vec!((1, 1), (2, 2));\n twins.sort_by_key(|x| { x.1; });\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "fn_address_comparisons",
+    "id_span": {
+      "path": "clippy_lints/src/unnamed_address.rs",
+      "line": 27
+    },
+    "group": "clippy::correctness",
+    "docs": " **What it does:** Checks for comparisons with an address of a function item.\n **Why is this bad?** Function item address is not guaranteed to be unique and could vary\n between different code generation units. Furthermore different function items could have\n the same address after being merged together.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n type F = fn();\n fn a() {}\n let f: F = a;\n if f == a {\n     // ...\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "vtable_address_comparisons",
+    "id_span": {
+      "path": "clippy_lints/src/unnamed_address.rs",
+      "line": 51
+    },
+    "group": "clippy::correctness",
+    "docs": " **What it does:** Checks for comparisons with an address of a trait vtable.\n **Why is this bad?** Comparing trait objects pointers compares an vtable addresses which\n are not guaranteed to be unique and could vary between different code generation units.\n Furthermore vtables for different types could have the same address after being merged\n together.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust,ignore\n let a: Rc<dyn Trait> = ...\n let b: Rc<dyn Trait> = ...\n if Rc::ptr_eq(&a, &b) {\n     ...\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "unnecessary_sort_by",
+    "id_span": {
+      "path": "clippy_lints/src/unnecessary_sort_by.rs",
+      "line": 41
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Detects uses of `Vec::sort_by` passing in a closure\n which compares the two arguments, either directly or indirectly.\n\n **Why is this bad?**\n It is more clear to use `Vec::sort_by_key` (or `Vec::sort` if\n possible) than to use `Vec::sort_by` and a more complicated\n closure.\n\n **Known problems:**\n If the suggested `Vec::sort_by_key` uses Reverse and it isn't already\n imported by a use statement, then it will need to be added manually.\n\n **Example:**\n\n ```rust\n # struct A;\n # impl A { fn foo(&self) {} }\n # let mut vec: Vec<A> = Vec::new();\n vec.sort_by(|a, b| a.foo().cmp(&b.foo()));\n ```\n Use instead:\n ```rust\n # struct A;\n # impl A { fn foo(&self) {} }\n # let mut vec: Vec<A> = Vec::new();\n vec.sort_by_key(|a| a.foo());\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "unnecessary_wraps",
+    "id_span": {
+      "path": "clippy_lints/src/unnecessary_wraps.rs",
+      "line": 50
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Checks for private functions that only return `Ok` or `Some`.\n **Why is this bad?** It is not meaningful to wrap values when no `None` or `Err` is returned.\n\n **Known problems:** There can be false positives if the function signature is designed to\n fit some external requirement.\n\n **Example:**\n\n ```rust\n fn get_cool_number(a: bool, b: bool) -> Option<i32> {\n     if a && b {\n         return Some(50);\n     }\n     if a {\n         Some(0)\n     } else {\n         Some(10)\n     }\n }\n ```\n Use instead:\n ```rust\n fn get_cool_number(a: bool, b: bool) -> i32 {\n     if a && b {\n         return 50;\n     }\n     if a {\n         0\n     } else {\n         10\n     }\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": true,
+      "applicability": "MaybeIncorrect"
+    }
+  },
+  {
+    "id": "unnested_or_patterns",
+    "id_span": {
+      "path": "clippy_lints/src/unnested_or_patterns.rs",
+      "line": 47
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:**\n Checks for unnested or-patterns, e.g., `Some(0) | Some(2)` and\n suggests replacing the pattern with a nested one, `Some(0 | 2)`.\n\n Another way to think of this is that it rewrites patterns in\n *disjunctive normal form (DNF)* into *conjunctive normal form (CNF)*.\n\n **Why is this bad?**\n\n In the example above, `Some` is repeated, which unncessarily complicates the pattern.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n fn main() {\n     if let Some(0) | Some(2) = Some(0) {}\n }\n ```\n Use instead:\n ```rust\n #![feature(or_patterns)]\n\n fn main() {\n     if let Some(0 | 2) = Some(0) {}\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "unsafe_removed_from_name",
+    "id_span": {
+      "path": "clippy_lints/src/unsafe_removed_from_name.rs",
+      "line": 24
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for imports that remove \"unsafe\" from an item's name.\n\n **Why is this bad?** Renaming makes it less clear which traits and\n structures are unsafe.\n\n **Known problems:** None.\n\n **Example:**\n ```rust,ignore\n use std::cell::{UnsafeCell as TotallySafeCell};\n\n extern crate crossbeam;\n use crossbeam::{spawn_unsafe as spawn};\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "unused_io_amount",
+    "id_span": {
+      "path": "clippy_lints/src/unused_io_amount.rs",
+      "line": 28
+    },
+    "group": "clippy::correctness",
+    "docs": " **What it does:** Checks for unused written/read amount.\n **Why is this bad?** `io::Write::write(_vectored)` and\n `io::Read::read(_vectored)` are not guaranteed to\n process the entire buffer. They return how many bytes were processed, which\n might be smaller\n than a given buffer's length. If you don't need to deal with\n partial-write/read, use\n `write_all`/`read_exact` instead.\n\n **Known problems:** Detects only common patterns.\n\n **Example:**\n ```rust,ignore\n use std::io;\n fn foo<W: io::Write>(w: &mut W) -> io::Result<()> {\n     // must be `w.write_all(b\"foo\")?;`\n     w.write(b\"foo\")?;\n     Ok(())\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "unused_self",
+    "id_span": {
+      "path": "clippy_lints/src/unused_self.rs",
+      "line": 33
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Checks methods that contain a `self` argument but don't use it\n **Why is this bad?** It may be clearer to define the method as an associated function instead\n of an instance method if it doesn't require `self`.\n\n **Known problems:** None.\n\n **Example:**\n ```rust,ignore\n struct A;\n impl A {\n     fn method(&self) {}\n }\n ```\n\n Could be written:\n\n ```rust,ignore\n struct A;\n impl A {\n     fn method() {}\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "unused_unit",
+    "id_span": {
+      "path": "clippy_lints/src/unused_unit.rs",
+      "line": 27
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for unit (`()`) expressions that can be removed.\n **Why is this bad?** Such expressions add no value, but can make the code\n less readable. Depending on formatting they can make a `break` or `return`\n statement look like a function call.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n fn return_unit() -> () {\n     ()\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "unnecessary_unwrap",
+    "id_span": {
+      "path": "clippy_lints/src/unwrap.rs",
+      "line": 40
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks for calls of `unwrap[_err]()` that cannot fail.\n **Why is this bad?** Using `if let` or `match` is more idiomatic.\n\n **Known problems:** None\n\n **Example:**\n ```rust\n # let option = Some(0);\n # fn do_something_with(_x: usize) {}\n if option.is_some() {\n     do_something_with(option.unwrap())\n }\n ```\n\n Could be written:\n\n ```rust\n # let option = Some(0);\n # fn do_something_with(_x: usize) {}\n if let Some(value) = option {\n     do_something_with(value)\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "panicking_unwrap",
+    "id_span": {
+      "path": "clippy_lints/src/unwrap.rs",
+      "line": 63
+    },
+    "group": "clippy::correctness",
+    "docs": " **What it does:** Checks for calls of `unwrap[_err]()` that will always fail.\n **Why is this bad?** If panicking is desired, an explicit `panic!()` should be used.\n\n **Known problems:** This lint only checks `if` conditions not assignments.\n So something like `let x: Option<()> = None; x.unwrap();` will not be recognized.\n\n **Example:**\n ```rust\n # let option = Some(0);\n # fn do_something_with(_x: usize) {}\n if option.is_none() {\n     do_something_with(option.unwrap())\n }\n ```\n\n This code will always panic. The if condition should probably be inverted.\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "unwrap_in_result",
+    "id_span": {
+      "path": "clippy_lints/src/unwrap_in_result.rs",
+      "line": 47
+    },
+    "group": "clippy::restriction",
+    "docs": " **What it does:** Checks for functions of type Result that contain `expect()` or `unwrap()`\n **Why is this bad?** These functions promote recoverable errors to non-recoverable errors which may be undesirable in code bases which wish to avoid panics.\n\n **Known problems:** This can cause false positives in functions that handle both recoverable and non recoverable errors.\n\n **Example:**\n Before:\n ```rust\n fn divisible_by_3(i_str: String) -> Result<(), String> {\n     let i = i_str\n         .parse::<i32>()\n         .expect(\"cannot divide the input by three\");\n\n     if i % 3 != 0 {\n         Err(\"Number is not divisible by 3\")?\n     }\n\n     Ok(())\n }\n ```\n\n After:\n ```rust\n fn divisible_by_3(i_str: String) -> Result<(), String> {\n     let i = i_str\n         .parse::<i32>()\n         .map_err(|e| format!(\"cannot divide the input by three: {}\", e))?;\n\n     if i % 3 != 0 {\n         Err(\"Number is not divisible by 3\")?\n     }\n\n     Ok(())\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "upper_case_acronyms",
+    "id_span": {
+      "path": "clippy_lints/src/upper_case_acronyms.rs",
+      "line": 35
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for fully capitalized names and optionally names containing a capitalized acronym.\n **Why is this bad?** In CamelCase, acronyms count as one word.\n See [naming conventions](https://rust-lang.github.io/api-guidelines/naming.html#casing-conforms-to-rfc-430-c-case)\n for more.\n\n By default, the lint only triggers on fully-capitalized names.\n You can use the `upper-case-acronyms-aggressive: true` config option to enable linting\n on all camel case names\n\n **Known problems:** When two acronyms are contiguous, the lint can't tell where\n the first acronym ends and the second starts, so it suggests to lowercase all of\n the letters in the second acronym.\n\n **Example:**\n\n ```rust\n struct HTTPResponse;\n ```\n Use instead:\n ```rust\n struct HttpResponse;\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MaybeIncorrect"
+    }
+  },
+  {
+    "id": "use_self",
+    "id_span": {
+      "path": "clippy_lints/src/use_self.rs",
+      "line": 53
+    },
+    "group": "clippy::nursery",
+    "docs": " **What it does:** Checks for unnecessary repetition of structure name when a replacement with `Self` is applicable.\n\n **Why is this bad?** Unnecessary repetition. Mixed use of `Self` and struct\n name\n feels inconsistent.\n\n **Known problems:**\n - Unaddressed false negative in fn bodies of trait implementations\n - False positive with assotiated types in traits (#4140)\n\n **Example:**\n\n ```rust\n struct Foo {}\n impl Foo {\n     fn new() -> Foo {\n         Foo {}\n     }\n }\n ```\n could be\n ```rust\n struct Foo {}\n impl Foo {\n     fn new() -> Self {\n         Self {}\n     }\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "useless_conversion",
+    "id_span": {
+      "path": "clippy_lints/src/useless_conversion.rs",
+      "line": 32
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks for `Into`, `TryInto`, `From`, `TryFrom`, or `IntoIter` calls which uselessly convert to the same type.\n\n **Why is this bad?** Redundant code.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n // Bad\n // format!() returns a `String`\n let s: String = format!(\"hello\").into();\n\n // Good\n let s: String = format!(\"hello\");\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "useless_vec",
+    "id_span": {
+      "path": "clippy_lints/src/vec.rs",
+      "line": 36
+    },
+    "group": "clippy::perf",
+    "docs": " **What it does:** Checks for usage of `&vec![..]` when using `&[..]` would be possible.\n\n **Why is this bad?** This is less efficient.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # fn foo(my_vec: &[u8]) {}\n\n // Bad\n foo(&vec![1, 2]);\n\n // Good\n foo(&[1, 2]);\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "vec_init_then_push",
+    "id_span": {
+      "path": "clippy_lints/src/vec_init_then_push.rs",
+      "line": 32
+    },
+    "group": "clippy::perf",
+    "docs": " **What it does:** Checks for calls to `push` immediately after creating a new `Vec`.\n **Why is this bad?** The `vec![]` macro is both more performant and easier to read than\n multiple `push` calls.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n let mut v = Vec::new();\n v.push(0);\n ```\n Use instead:\n ```rust\n let v = vec![0];\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "HasPlaceholders"
+    }
+  },
+  {
+    "id": "vec_resize_to_zero",
+    "id_span": {
+      "path": "clippy_lints/src/vec_resize_to_zero.rs",
+      "line": 24
+    },
+    "group": "clippy::correctness",
+    "docs": " **What it does:** Finds occurrences of `Vec::resize(0, an_int)`\n **Why is this bad?** This is probably an argument inversion mistake.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n vec!(1, 2, 3, 4, 5).resize(0, 5)\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MaybeIncorrect"
+    }
+  },
+  {
+    "id": "verbose_file_reads",
+    "id_span": {
+      "path": "clippy_lints/src/verbose_file_reads.rs",
+      "line": 29
+    },
+    "group": "clippy::restriction",
+    "docs": " **What it does:** Checks for use of File::read_to_end and File::read_to_string.\n **Why is this bad?** `fs::{read, read_to_string}` provide the same functionality when `buf` is empty with fewer imports and no intermediate values.\n See also: [fs::read docs](https://doc.rust-lang.org/std/fs/fn.read.html), [fs::read_to_string docs](https://doc.rust-lang.org/std/fs/fn.read_to_string.html)\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust,no_run\n # use std::io::Read;\n # use std::fs::File;\n let mut f = File::open(\"foo.txt\").unwrap();\n let mut bytes = Vec::new();\n f.read_to_end(&mut bytes).unwrap();\n ```\n Can be written more concisely as\n ```rust,no_run\n # use std::fs;\n let mut bytes = fs::read(\"foo.txt\").unwrap();\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "wildcard_dependencies",
+    "id_span": {
+      "path": "clippy_lints/src/wildcard_dependencies.rs",
+      "line": 24
+    },
+    "group": "clippy::cargo",
+    "docs": " **What it does:** Checks for wildcard dependencies in the `Cargo.toml`.\n **Why is this bad?** [As the edition guide says](https://rust-lang-nursery.github.io/edition-guide/rust-2018/cargo-and-crates-io/crates-io-disallows-wildcard-dependencies.html),\n it is highly unlikely that you work with any possible version of your dependency,\n and wildcard dependencies would cause unnecessary breakage in the ecosystem.\n\n **Known problems:** None.\n\n **Example:**\n\n ```toml\n [dependencies]\n regex = \"*\"\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "enum_glob_use",
+    "id_span": {
+      "path": "clippy_lints/src/wildcard_imports.rs",
+      "line": 32
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Checks for `use Enum::*`.\n **Why is this bad?** It is usually better style to use the prefixed name of\n an enumeration variant, rather than importing variants.\n\n **Known problems:** Old-style enumerations that prefix the variants are\n still around.\n\n **Example:**\n ```rust,ignore\n // Bad\n use std::cmp::Ordering::*;\n foo(Less);\n\n // Good\n use std::cmp::Ordering;\n foo(Ordering::Less)\n ```\n",
+    "applicability": null
+  },
+  {
+    "id": "wildcard_imports",
+    "id_span": {
+      "path": "clippy_lints/src/wildcard_imports.rs",
+      "line": 83
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Checks for wildcard imports `use _::*`.\n **Why is this bad?** wildcard imports can pollute the namespace. This is especially bad if\n you try to import something through a wildcard, that already has been imported by name from\n a different source:\n\n ```rust,ignore\n use crate1::foo; // Imports a function named foo\n use crate2::*; // Has a function named foo\n\n foo(); // Calls crate1::foo\n ```\n\n This can lead to confusing error messages at best and to unexpected behavior at worst.\n\n **Exceptions:**\n\n Wildcard imports are allowed from modules named `prelude`. Many crates (including the standard library)\n provide modules named \"prelude\" specifically designed for wildcard import.\n\n `use super::*` is allowed in test modules. This is defined as any module with \"test\" in the name.\n\n These exceptions can be disabled using the `warn-on-all-wildcard-imports` configuration flag.\n\n **Known problems:** If macros are imported through the wildcard, this macro is not included\n by the suggestion and has to be added by hand.\n\n Applying the suggestion when explicit imports of the things imported with a glob import\n exist, may result in `unused_imports` warnings.\n\n **Example:**\n\n ```rust,ignore\n // Bad\n use crate1::*;\n\n foo();\n ```\n\n ```rust,ignore\n // Good\n use crate1::foo;\n\n foo();\n ```\n",
+    "applicability": null
+  },
+  {
+    "id": "println_empty_string",
+    "id_span": {
+      "path": "clippy_lints/src/write.rs",
+      "line": 33
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** This lint warns when you use `println!(\"\")` to print a newline.\n\n **Why is this bad?** You should use `println!()`, which is simpler.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n // Bad\n println!(\"\");\n\n // Good\n println!();\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "print_with_newline",
+    "id_span": {
+      "path": "clippy_lints/src/write.rs",
+      "line": 57
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** This lint warns when you use `print!()` with a format string that ends in a newline.\n\n **Why is this bad?** You should use `println!()` instead, which appends the\n newline.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # let name = \"World\";\n print!(\"Hello {}!\\n\", name);\n ```\n use println!() instead\n ```rust\n # let name = \"World\";\n println!(\"Hello {}!\", name);\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": true,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "print_stdout",
+    "id_span": {
+      "path": "clippy_lints/src/write.rs",
+      "line": 75
+    },
+    "group": "clippy::restriction",
+    "docs": " **What it does:** Checks for printing on *stdout*. The purpose of this lint is to catch debugging remnants.\n\n **Why is this bad?** People often print on *stdout* while debugging an\n application and might forget to remove those prints afterward.\n\n **Known problems:** Only catches `print!` and `println!` calls.\n\n **Example:**\n ```rust\n println!(\"Hello world!\");\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "print_stderr",
+    "id_span": {
+      "path": "clippy_lints/src/write.rs",
+      "line": 93
+    },
+    "group": "clippy::restriction",
+    "docs": " **What it does:** Checks for printing on *stderr*. The purpose of this lint is to catch debugging remnants.\n\n **Why is this bad?** People often print on *stderr* while debugging an\n application and might forget to remove those prints afterward.\n\n **Known problems:** Only catches `eprint!` and `eprintln!` calls.\n\n **Example:**\n ```rust\n eprintln!(\"Hello world!\");\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "use_debug",
+    "id_span": {
+      "path": "clippy_lints/src/write.rs",
+      "line": 110
+    },
+    "group": "clippy::restriction",
+    "docs": " **What it does:** Checks for use of `Debug` formatting. The purpose of this lint is to catch debugging remnants.\n\n **Why is this bad?** The purpose of the `Debug` trait is to facilitate\n debugging Rust code. It should not be used in user-facing output.\n\n **Example:**\n ```rust\n # let foo = \"bar\";\n println!(\"{:?}\", foo);\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "print_literal",
+    "id_span": {
+      "path": "clippy_lints/src/write.rs",
+      "line": 133
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** This lint warns about the use of literals as `print!`/`println!` args.\n **Why is this bad?** Using literals as `println!` args is inefficient\n (c.f., https://github.com/matthiaskrgr/rust-str-bench) and unnecessary\n (i.e., just put the literal in the format string)\n\n **Known problems:** Will also warn with macro calls as arguments that expand to literals\n -- e.g., `println!(\"{}\", env!(\"FOO\"))`.\n\n **Example:**\n ```rust\n println!(\"{}\", \"foo\");\n ```\n use the literal without formatting:\n ```rust\n println!(\"foo\");\n ```\n",
+    "applicability": null
+  },
+  {
+    "id": "writeln_empty_string",
+    "id_span": {
+      "path": "clippy_lints/src/write.rs",
+      "line": 156
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** This lint warns when you use `writeln!(buf, \"\")` to print a newline.\n\n **Why is this bad?** You should use `writeln!(buf)`, which is simpler.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # use std::fmt::Write;\n # let mut buf = String::new();\n // Bad\n writeln!(buf, \"\");\n\n // Good\n writeln!(buf);\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "write_with_newline",
+    "id_span": {
+      "path": "clippy_lints/src/write.rs",
+      "line": 182
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** This lint warns when you use `write!()` with a format string that\n ends in a newline.\n\n **Why is this bad?** You should use `writeln!()` instead, which appends the\n newline.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # use std::fmt::Write;\n # let mut buf = String::new();\n # let name = \"World\";\n // Bad\n write!(buf, \"Hello {}!\\n\", name);\n\n // Good\n writeln!(buf, \"Hello {}!\", name);\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": true,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "write_literal",
+    "id_span": {
+      "path": "clippy_lints/src/write.rs",
+      "line": 207
+    },
+    "group": "clippy::style",
+    "docs": " **What it does:** This lint warns about the use of literals as `write!`/`writeln!` args.\n **Why is this bad?** Using literals as `writeln!` args is inefficient\n (c.f., https://github.com/matthiaskrgr/rust-str-bench) and unnecessary\n (i.e., just put the literal in the format string)\n\n **Known problems:** Will also warn with macro calls as arguments that expand to literals\n -- e.g., `writeln!(buf, \"{}\", env!(\"FOO\"))`.\n\n **Example:**\n ```rust\n # use std::fmt::Write;\n # let mut buf = String::new();\n // Bad\n writeln!(buf, \"{}\", \"foo\");\n\n // Good\n writeln!(buf, \"foo\");\n ```\n",
+    "applicability": null
+  },
+  {
+    "id": "zero_divided_by_zero",
+    "id_span": {
+      "path": "clippy_lints/src/zero_div_zero.rs",
+      "line": 23
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks for `0.0 / 0.0`.\n **Why is this bad?** It's less readable than `f32::NAN` or `f64::NAN`.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n // Bad\n let nan = 0.0f32 / 0.0;\n\n // Good\n let nan = f32::NAN;\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  },
+  {
+    "id": "zero_sized_map_values",
+    "id_span": {
+      "path": "clippy_lints/src/zero_sized_map_values.rs",
+      "line": 37
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Checks for maps with zero-sized value types anywhere in the code.\n **Why is this bad?** Since there is only a single value for a zero-sized type, a map\n containing zero sized values is effectively a set. Using a set in that case improves\n readability and communicates intent more clearly.\n\n **Known problems:**\n * A zero-sized type cannot be recovered later if it contains private fields.\n * This lints the signature of public items\n\n **Example:**\n\n ```rust\n # use std::collections::HashMap;\n fn unique_words(text: &str) -> HashMap<&str, ()> {\n     todo!();\n }\n ```\n Use instead:\n ```rust\n # use std::collections::HashSet;\n fn unique_words(text: &str) -> HashSet<&str> {\n     todo!();\n }\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
+  }
+]
-- 
cgit 1.4.1-3-g733a5


From 35844d0a48e0a644072ae81857782a6e0bd54740 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Sat, 6 Mar 2021 01:11:41 +0100
Subject: Metadata collection: Resolve lint from locals

---
 .../src/utils/internal_lints/metadata_collector.rs |   82 +-
 clippy_utils/src/paths.rs                          |    2 +-
 metadata_collection.json                           | 1184 +++++++++++---------
 3 files changed, 699 insertions(+), 569 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index b2cc6372277..0425689b0dd 100644
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -15,8 +15,6 @@
 
 // # Applicability
 // - TODO xFrednet 2021-01-17: Find lint emit and collect applicability
-//   - TODO xFrednet 2021-02-28:  1x reference to closure
-//     - See clippy_lints/src/needless_pass_by_value.rs@NeedlessPassByValue::check_fn
 //   - TODO xFrednet 2021-02-28:  4x weird emission forwarding
 //     - See clippy_lints/src/enum_variants.rs@EnumVariantNames::check_name
 //   - TODO xFrednet 2021-02-28:  6x emission forwarding with local that is initializes from
@@ -26,14 +24,12 @@
 //     - See clippy_lints/src/misc.rs@check_binary
 //   - TODO xFrednet 2021-02-28:  2x lint from local from method call
 //     - See clippy_lints/src/non_copy_const.rs@lint
-//   - TODO xFrednet 2021-02-28: 20x lint from local
-//     - See clippy_lints/src/map_unit_fn.rs@lint_map_unit_fn
 // # NITs
 // - TODO xFrednet 2021-02-13: Collect depreciations and maybe renames
 
 use if_chain::if_chain;
 use rustc_data_structures::fx::FxHashMap;
-use rustc_hir::{self as hir, intravisit, intravisit::Visitor, ExprKind, Item, ItemKind, Mutability, QPath};
+use rustc_hir::{self as hir, intravisit, intravisit::Visitor, ExprKind, Item, ItemKind, Mutability, QPath, def::DefKind};
 use rustc_lint::{CheckLintNameResult, LateContext, LateLintPass, LintContext, LintId};
 use rustc_middle::hir::map::Map;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
@@ -49,7 +45,7 @@ use crate::utils::{
 };
 
 /// This is the output file of the lint collector.
-const OUTPUT_FILE: &str = "metadata_collection.json";
+const OUTPUT_FILE: &str = "../metadata_collection.json";
 /// These lints are excluded from the export.
 const BLACK_LISTED_LINTS: [&str; 2] = ["lint_author", "deep_code_inspection"];
 /// These groups will be ignored by the lint group matcher. This is useful for collections like
@@ -270,12 +266,16 @@ impl<'hir> LateLintPass<'hir> for MetadataCollector {
     /// ```
     fn check_expr(&mut self, cx: &LateContext<'hir>, expr: &'hir hir::Expr<'_>) {
         if let Some(args) = match_lint_emission(cx, expr) {
-            if let Some((lint_name, applicability, is_multi_part)) = extract_complex_emission_info(cx, args) {
+            let mut emission_info = extract_complex_emission_info(cx, args);
+            if emission_info.is_empty() {
+                lint_collection_error_span(cx, expr.span, "Look, here ... I have no clue what todo with it");
+                return;
+            }
+
+            for (lint_name, applicability, is_multi_part) in emission_info.drain(..) {
                 let app_info = self.applicability_into.entry(lint_name).or_default();
                 app_info.applicability = applicability;
                 app_info.is_multi_suggestion = is_multi_part;
-            } else {
-                lint_collection_error_span(cx, expr.span, "Look, here ... I have no clue what todo with it");
             }
         }
     }
@@ -380,8 +380,8 @@ fn match_lint_emission<'hir>(cx: &LateContext<'hir>, expr: &'hir hir::Expr<'_>)
 fn extract_complex_emission_info<'hir>(
     cx: &LateContext<'hir>,
     args: &'hir [hir::Expr<'hir>],
-) -> Option<(String, Option<String>, bool)> {
-    let mut lint_name = None;
+) -> Vec<(String, Option<String>, bool)> {
+    let mut lints= Vec::new();
     let mut applicability = None;
     let mut multi_part = false;
 
@@ -390,9 +390,8 @@ fn extract_complex_emission_info<'hir>(
 
         if match_type(cx, arg_ty, &paths::LINT) {
             // If we found the lint arg, extract the lint name
-            if let ExprKind::Path(ref lint_path) = arg.kind {
-                lint_name = Some(last_path_segment(lint_path).ident.name);
-            }
+            let mut resolved_lints = resolve_lints(cx, arg);
+            lints.append(&mut resolved_lints);
         } else if match_type(cx, arg_ty, &paths::APPLICABILITY) {
             applicability = resolve_applicability(cx, arg);
         } else if arg_ty.is_closure() {
@@ -402,7 +401,14 @@ fn extract_complex_emission_info<'hir>(
         }
     }
 
-    lint_name.map(|lint_name| (sym_to_string(lint_name).to_ascii_lowercase(), applicability, multi_part))
+    lints.drain(..).map(|lint_name| (lint_name, applicability.clone(), multi_part)).collect()
+}
+
+/// Resolves the possible lints that this expression could reference
+fn resolve_lints(cx: &LateContext<'hir>, expr: &'hir hir::Expr<'hir>) -> Vec<String> {
+    let mut resolver = LintResolver::new(cx);
+    resolver.visit_expr(expr);
+    resolver.lints
 }
 
 /// This function tries to resolve the linked applicability to the given expression.
@@ -426,6 +432,50 @@ fn check_is_multi_part(cx: &LateContext<'hir>, closure_expr: &'hir hir::Expr<'hi
     false
 }
 
+struct LintResolver<'a, 'hir> {
+    cx: &'a LateContext<'hir>,
+    lints: Vec<String>,
+}
+
+impl<'a, 'hir> LintResolver<'a, 'hir> {
+    fn new(cx: &'a LateContext<'hir>) -> Self {
+        Self {
+            cx,
+            lints: Vec::<String>::default(),
+        }
+    }
+}
+
+impl<'a, 'hir> intravisit::Visitor<'hir> for LintResolver<'a, 'hir> {
+    type Map = Map<'hir>;
+
+    fn nested_visit_map(&mut self) -> intravisit::NestedVisitorMap<Self::Map> {
+        intravisit::NestedVisitorMap::All(self.cx.tcx.hir())
+    }
+
+    fn visit_expr(&mut self, expr: &'hir hir::Expr<'hir>) {
+        if_chain! {
+            if let ExprKind::Path(qpath) = &expr.kind;
+            if let QPath::Resolved(_, path) = qpath;
+            
+            let (expr_ty, _) = walk_ptrs_ty_depth(self.cx.typeck_results().expr_ty(&expr));
+            if match_type(self.cx, expr_ty, &paths::LINT);
+            then {
+                if let hir::def::Res::Def(DefKind::Static, _) = path.res {
+                    let lint_name = last_path_segment(qpath).ident.name;
+                    self.lints.push(sym_to_string(lint_name).to_ascii_lowercase());
+                } else if let Some(local) = get_parent_local(self.cx, expr) {
+                    if let Some(local_init) = local.init {
+                        intravisit::walk_expr(self, local_init);
+                    }
+                }
+            }
+        }
+
+        intravisit::walk_expr(self, expr);
+    }
+}
+
 /// This visitor finds the highest applicability value in the visited expressions
 struct ApplicabilityResolver<'a, 'hir> {
     cx: &'a LateContext<'hir>,
@@ -488,7 +538,7 @@ impl<'a, 'hir> intravisit::Visitor<'hir> for ApplicabilityResolver<'a, 'hir> {
     }
 }
 
-/// This returns the parent local node if the expression is a reference to
+/// This returns the parent local node if the expression is a reference one
 fn get_parent_local(cx: &LateContext<'hir>, expr: &'hir hir::Expr<'hir>) -> Option<&'hir hir::Local<'hir>> {
     if let ExprKind::Path(QPath::Resolved(_, path)) = expr.kind {
         if let hir::def::Res::Local(local_hir) = path.res {
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index a6292b87768..1f19724ad25 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -83,7 +83,7 @@ pub const KW_MODULE: [&str; 3] = ["rustc_span", "symbol", "kw"];
 #[cfg(feature = "internal-lints")]
 pub const LATE_CONTEXT: [&str; 2] = ["rustc_lint", "LateContext"];
 pub const LINKED_LIST: [&str; 4] = ["alloc", "collections", "linked_list", "LinkedList"];
-#[cfg(feature = "internal-lints")]
+#[cfg(any(feature = "internal-lints", feature = "metadata-collector-lint"))]
 pub const LINT: [&str; 2] = ["rustc_lint_defs", "Lint"];
 pub const MEM_DISCRIMINANT: [&str; 3] = ["core", "mem", "discriminant"];
 pub const MEM_FORGET: [&str; 3] = ["core", "mem", "forget"];
diff --git a/metadata_collection.json b/metadata_collection.json
index 507752a782c..f6f72ffa5fa 100644
--- a/metadata_collection.json
+++ b/metadata_collection.json
@@ -2,7 +2,7 @@
   {
     "id": "approx_constant",
     "id_span": {
-      "path": "clippy_lints/src/approx_const.rs",
+      "path": "src/approx_const.rs",
       "line": 34
     },
     "group": "clippy::correctness",
@@ -15,7 +15,7 @@
   {
     "id": "integer_arithmetic",
     "id_span": {
-      "path": "clippy_lints/src/arithmetic.rs",
+      "path": "src/arithmetic.rs",
       "line": 28
     },
     "group": "clippy::restriction",
@@ -28,7 +28,7 @@
   {
     "id": "float_arithmetic",
     "id_span": {
-      "path": "clippy_lints/src/arithmetic.rs",
+      "path": "src/arithmetic.rs",
       "line": 46
     },
     "group": "clippy::restriction",
@@ -41,7 +41,7 @@
   {
     "id": "as_conversions",
     "id_span": {
-      "path": "clippy_lints/src/as_conversions.rs",
+      "path": "src/as_conversions.rs",
       "line": 42
     },
     "group": "clippy::restriction",
@@ -54,7 +54,7 @@
   {
     "id": "inline_asm_x86_intel_syntax",
     "id_span": {
-      "path": "clippy_lints/src/asm_syntax.rs",
+      "path": "src/asm_syntax.rs",
       "line": 78
     },
     "group": "clippy::restriction",
@@ -64,7 +64,7 @@
   {
     "id": "inline_asm_x86_att_syntax",
     "id_span": {
-      "path": "clippy_lints/src/asm_syntax.rs",
+      "path": "src/asm_syntax.rs",
       "line": 114
     },
     "group": "clippy::restriction",
@@ -74,7 +74,7 @@
   {
     "id": "assertions_on_constants",
     "id_span": {
-      "path": "clippy_lints/src/assertions_on_constants.rs",
+      "path": "src/assertions_on_constants.rs",
       "line": 23
     },
     "group": "clippy::style",
@@ -87,7 +87,7 @@
   {
     "id": "assign_op_pattern",
     "id_span": {
-      "path": "clippy_lints/src/assign_ops.rs",
+      "path": "src/assign_ops.rs",
       "line": 33
     },
     "group": "clippy::style",
@@ -100,7 +100,7 @@
   {
     "id": "misrefactored_assign_op",
     "id_span": {
-      "path": "clippy_lints/src/assign_ops.rs",
+      "path": "src/assign_ops.rs",
       "line": 56
     },
     "group": "clippy::complexity",
@@ -113,7 +113,7 @@
   {
     "id": "async_yields_async",
     "id_span": {
-      "path": "clippy_lints/src/async_yields_async.rs",
+      "path": "src/async_yields_async.rs",
       "line": 36
     },
     "group": "clippy::correctness",
@@ -126,7 +126,7 @@
   {
     "id": "invalid_atomic_ordering",
     "id_span": {
-      "path": "clippy_lints/src/atomic_ordering.rs",
+      "path": "src/atomic_ordering.rs",
       "line": 47
     },
     "group": "clippy::correctness",
@@ -139,7 +139,7 @@
   {
     "id": "inline_always",
     "id_span": {
-      "path": "clippy_lints/src/attrs.rs",
+      "path": "src/attrs.rs",
       "line": 65
     },
     "group": "clippy::pedantic",
@@ -152,7 +152,7 @@
   {
     "id": "useless_attribute",
     "id_span": {
-      "path": "clippy_lints/src/attrs.rs",
+      "path": "src/attrs.rs",
       "line": 99
     },
     "group": "clippy::correctness",
@@ -165,7 +165,7 @@
   {
     "id": "deprecated_semver",
     "id_span": {
-      "path": "clippy_lints/src/attrs.rs",
+      "path": "src/attrs.rs",
       "line": 118
     },
     "group": "clippy::correctness",
@@ -178,7 +178,7 @@
   {
     "id": "empty_line_after_outer_attr",
     "id_span": {
-      "path": "clippy_lints/src/attrs.rs",
+      "path": "src/attrs.rs",
       "line": 153
     },
     "group": "clippy::nursery",
@@ -191,7 +191,7 @@
   {
     "id": "blanket_clippy_restriction_lints",
     "id_span": {
-      "path": "clippy_lints/src/attrs.rs",
+      "path": "src/attrs.rs",
       "line": 176
     },
     "group": "clippy::style",
@@ -204,7 +204,7 @@
   {
     "id": "deprecated_cfg_attr",
     "id_span": {
-      "path": "clippy_lints/src/attrs.rs",
+      "path": "src/attrs.rs",
       "line": 205
     },
     "group": "clippy::complexity",
@@ -217,7 +217,7 @@
   {
     "id": "mismatched_target_os",
     "id_span": {
-      "path": "clippy_lints/src/attrs.rs",
+      "path": "src/attrs.rs",
       "line": 238
     },
     "group": "clippy::correctness",
@@ -230,7 +230,7 @@
   {
     "id": "await_holding_lock",
     "id_span": {
-      "path": "clippy_lints/src/await_holding_invalid.rs",
+      "path": "src/await_holding_invalid.rs",
       "line": 47
     },
     "group": "clippy::pedantic",
@@ -243,7 +243,7 @@
   {
     "id": "await_holding_refcell_ref",
     "id_span": {
-      "path": "clippy_lints/src/await_holding_invalid.rs",
+      "path": "src/await_holding_invalid.rs",
       "line": 86
     },
     "group": "clippy::pedantic",
@@ -256,7 +256,7 @@
   {
     "id": "bad_bit_mask",
     "id_span": {
-      "path": "clippy_lints/src/bit_mask.rs",
+      "path": "src/bit_mask.rs",
       "line": 44
     },
     "group": "clippy::correctness",
@@ -269,7 +269,7 @@
   {
     "id": "ineffective_bit_mask",
     "id_span": {
-      "path": "clippy_lints/src/bit_mask.rs",
+      "path": "src/bit_mask.rs",
       "line": 73
     },
     "group": "clippy::correctness",
@@ -282,7 +282,7 @@
   {
     "id": "verbose_bit_mask",
     "id_span": {
-      "path": "clippy_lints/src/bit_mask.rs",
+      "path": "src/bit_mask.rs",
       "line": 92
     },
     "group": "clippy::pedantic",
@@ -295,7 +295,7 @@
   {
     "id": "blacklisted_name",
     "id_span": {
-      "path": "clippy_lints/src/blacklisted_name.rs",
+      "path": "src/blacklisted_name.rs",
       "line": 20
     },
     "group": "clippy::style",
@@ -308,7 +308,7 @@
   {
     "id": "blocks_in_if_conditions",
     "id_span": {
-      "path": "clippy_lints/src/blocks_in_if_conditions.rs",
+      "path": "src/blocks_in_if_conditions.rs",
       "line": 42
     },
     "group": "clippy::style",
@@ -321,7 +321,7 @@
   {
     "id": "nonminimal_bool",
     "id_span": {
-      "path": "clippy_lints/src/booleans.rs",
+      "path": "src/booleans.rs",
       "line": 31
     },
     "group": "clippy::complexity",
@@ -334,7 +334,7 @@
   {
     "id": "logic_bug",
     "id_span": {
-      "path": "clippy_lints/src/booleans.rs",
+      "path": "src/booleans.rs",
       "line": 49
     },
     "group": "clippy::correctness",
@@ -347,10 +347,10 @@
   {
     "id": "naive_bytecount",
     "id_span": {
-      "path": "clippy_lints/src/bytecount.rs",
+      "path": "src/bytecount.rs",
       "line": 30
     },
-    "group": "clippy::perf",
+    "group": "clippy::pedantic",
     "docs": " **What it does:** Checks for naive byte counts\n **Why is this bad?** The [`bytecount`](https://crates.io/crates/bytecount)\n crate has methods to count your bytes faster, especially for large slices.\n\n **Known problems:** If you have predominantly small slices, the\n `bytecount::count(..)` method may actually be slower. However, if you can\n ensure that less than 2³²-1 matches arise, the `naive_count_32(..)` can be\n faster in those cases.\n\n **Example:**\n\n ```rust\n # let vec = vec![1_u8];\n &vec.iter().filter(|x| **x == 0u8).count(); // use bytecount::count instead\n ```\n",
     "applicability": {
       "is_multi_suggestion": false,
@@ -360,7 +360,7 @@
   {
     "id": "cargo_common_metadata",
     "id_span": {
-      "path": "clippy_lints/src/cargo_common_metadata.rs",
+      "path": "src/cargo_common_metadata.rs",
       "line": 49
     },
     "group": "clippy::cargo",
@@ -373,7 +373,7 @@
   {
     "id": "case_sensitive_file_extension_comparisons",
     "id_span": {
-      "path": "clippy_lints/src/case_sensitive_file_extension_comparisons.rs",
+      "path": "src/case_sensitive_file_extension_comparisons.rs",
       "line": 34
     },
     "group": "clippy::pedantic",
@@ -386,7 +386,7 @@
   {
     "id": "checked_conversions",
     "id_span": {
-      "path": "clippy_lints/src/checked_conversions.rs",
+      "path": "src/checked_conversions.rs",
       "line": 40
     },
     "group": "clippy::pedantic",
@@ -399,7 +399,7 @@
   {
     "id": "cognitive_complexity",
     "id_span": {
-      "path": "clippy_lints/src/cognitive_complexity.rs",
+      "path": "src/cognitive_complexity.rs",
       "line": 24
     },
     "group": "clippy::nursery",
@@ -412,7 +412,7 @@
   {
     "id": "collapsible_if",
     "id_span": {
-      "path": "clippy_lints/src/collapsible_if.rs",
+      "path": "src/collapsible_if.rs",
       "line": 50
     },
     "group": "clippy::style",
@@ -425,7 +425,7 @@
   {
     "id": "collapsible_else_if",
     "id_span": {
-      "path": "clippy_lints/src/collapsible_if.rs",
+      "path": "src/collapsible_if.rs",
       "line": 85
     },
     "group": "clippy::style",
@@ -438,7 +438,7 @@
   {
     "id": "collapsible_match",
     "id_span": {
-      "path": "clippy_lints/src/collapsible_match.rs",
+      "path": "src/collapsible_match.rs",
       "line": 44
     },
     "group": "clippy::style",
@@ -451,7 +451,7 @@
   {
     "id": "comparison_chain",
     "id_span": {
-      "path": "clippy_lints/src/comparison_chain.rs",
+      "path": "src/comparison_chain.rs",
       "line": 49
     },
     "group": "clippy::style",
@@ -464,7 +464,7 @@
   {
     "id": "ifs_same_cond",
     "id_span": {
-      "path": "clippy_lints/src/copies.rs",
+      "path": "src/copies.rs",
       "line": 33
     },
     "group": "clippy::correctness",
@@ -477,7 +477,7 @@
   {
     "id": "same_functions_in_if_condition",
     "id_span": {
-      "path": "clippy_lints/src/copies.rs",
+      "path": "src/copies.rs",
       "line": 80
     },
     "group": "clippy::pedantic",
@@ -490,7 +490,7 @@
   {
     "id": "if_same_then_else",
     "id_span": {
-      "path": "clippy_lints/src/copies.rs",
+      "path": "src/copies.rs",
       "line": 101
     },
     "group": "clippy::correctness",
@@ -503,7 +503,7 @@
   {
     "id": "copy_iterator",
     "id_span": {
-      "path": "clippy_lints/src/copy_iterator.rs",
+      "path": "src/copy_iterator.rs",
       "line": 27
     },
     "group": "clippy::pedantic",
@@ -516,7 +516,7 @@
   {
     "id": "create_dir",
     "id_span": {
-      "path": "clippy_lints/src/create_dir.rs",
+      "path": "src/create_dir.rs",
       "line": 24
     },
     "group": "clippy::restriction",
@@ -529,7 +529,7 @@
   {
     "id": "dbg_macro",
     "id_span": {
-      "path": "clippy_lints/src/dbg_macro.rs",
+      "path": "src/dbg_macro.rs",
       "line": 25
     },
     "group": "clippy::restriction",
@@ -542,7 +542,7 @@
   {
     "id": "default_trait_access",
     "id_span": {
-      "path": "clippy_lints/src/default.rs",
+      "path": "src/default.rs",
       "line": 33
     },
     "group": "clippy::pedantic",
@@ -555,7 +555,7 @@
   {
     "id": "field_reassign_with_default",
     "id_span": {
-      "path": "clippy_lints/src/default.rs",
+      "path": "src/default.rs",
       "line": 63
     },
     "group": "clippy::style",
@@ -568,7 +568,7 @@
   {
     "id": "default_numeric_fallback",
     "id_span": {
-      "path": "clippy_lints/src/default_numeric_fallback.rs",
+      "path": "src/default_numeric_fallback.rs",
       "line": 44
     },
     "group": "clippy::restriction",
@@ -581,7 +581,7 @@
   {
     "id": "explicit_deref_methods",
     "id_span": {
-      "path": "clippy_lints/src/dereference.rs",
+      "path": "src/dereference.rs",
       "line": 32
     },
     "group": "clippy::pedantic",
@@ -594,7 +594,7 @@
   {
     "id": "derive_hash_xor_eq",
     "id_span": {
-      "path": "clippy_lints/src/derive.rs",
+      "path": "src/derive.rs",
       "line": 42
     },
     "group": "clippy::correctness",
@@ -607,7 +607,7 @@
   {
     "id": "derive_ord_xor_partial_ord",
     "id_span": {
-      "path": "clippy_lints/src/derive.rs",
+      "path": "src/derive.rs",
       "line": 93
     },
     "group": "clippy::correctness",
@@ -620,7 +620,7 @@
   {
     "id": "expl_impl_clone_on_copy",
     "id_span": {
-      "path": "clippy_lints/src/derive.rs",
+      "path": "src/derive.rs",
       "line": 119
     },
     "group": "clippy::pedantic",
@@ -633,7 +633,7 @@
   {
     "id": "unsafe_derive_deserialize",
     "id_span": {
-      "path": "clippy_lints/src/derive.rs",
+      "path": "src/derive.rs",
       "line": 153
     },
     "group": "clippy::pedantic",
@@ -646,7 +646,7 @@
   {
     "id": "disallowed_method",
     "id_span": {
-      "path": "clippy_lints/src/disallowed_method.rs",
+      "path": "src/disallowed_method.rs",
       "line": 46
     },
     "group": "clippy::nursery",
@@ -659,7 +659,7 @@
   {
     "id": "doc_markdown",
     "id_span": {
-      "path": "clippy_lints/src/doc.rs",
+      "path": "src/doc.rs",
       "line": 63
     },
     "group": "clippy::pedantic",
@@ -672,7 +672,7 @@
   {
     "id": "missing_safety_doc",
     "id_span": {
-      "path": "clippy_lints/src/doc.rs",
+      "path": "src/doc.rs",
       "line": 97
     },
     "group": "clippy::style",
@@ -685,7 +685,7 @@
   {
     "id": "missing_errors_doc",
     "id_span": {
-      "path": "clippy_lints/src/doc.rs",
+      "path": "src/doc.rs",
       "line": 126
     },
     "group": "clippy::pedantic",
@@ -698,7 +698,7 @@
   {
     "id": "missing_panics_doc",
     "id_span": {
-      "path": "clippy_lints/src/doc.rs",
+      "path": "src/doc.rs",
       "line": 157
     },
     "group": "clippy::pedantic",
@@ -711,7 +711,7 @@
   {
     "id": "needless_doctest_main",
     "id_span": {
-      "path": "clippy_lints/src/doc.rs",
+      "path": "src/doc.rs",
       "line": 185
     },
     "group": "clippy::style",
@@ -724,7 +724,7 @@
   {
     "id": "double_comparisons",
     "id_span": {
-      "path": "clippy_lints/src/double_comparison.rs",
+      "path": "src/double_comparison.rs",
       "line": 33
     },
     "group": "clippy::complexity",
@@ -737,7 +737,7 @@
   {
     "id": "double_parens",
     "id_span": {
-      "path": "clippy_lints/src/double_parens.rs",
+      "path": "src/double_parens.rs",
       "line": 35
     },
     "group": "clippy::complexity",
@@ -750,7 +750,7 @@
   {
     "id": "drop_ref",
     "id_span": {
-      "path": "clippy_lints/src/drop_forget_ref.rs",
+      "path": "src/drop_forget_ref.rs",
       "line": 26
     },
     "group": "clippy::correctness",
@@ -760,7 +760,7 @@
   {
     "id": "forget_ref",
     "id_span": {
-      "path": "clippy_lints/src/drop_forget_ref.rs",
+      "path": "src/drop_forget_ref.rs",
       "line": 47
     },
     "group": "clippy::correctness",
@@ -770,7 +770,7 @@
   {
     "id": "drop_copy",
     "id_span": {
-      "path": "clippy_lints/src/drop_forget_ref.rs",
+      "path": "src/drop_forget_ref.rs",
       "line": 68
     },
     "group": "clippy::correctness",
@@ -780,7 +780,7 @@
   {
     "id": "forget_copy",
     "id_span": {
-      "path": "clippy_lints/src/drop_forget_ref.rs",
+      "path": "src/drop_forget_ref.rs",
       "line": 95
     },
     "group": "clippy::correctness",
@@ -790,7 +790,7 @@
   {
     "id": "duration_subsec",
     "id_span": {
-      "path": "clippy_lints/src/duration_subsec.rs",
+      "path": "src/duration_subsec.rs",
       "line": 34
     },
     "group": "clippy::complexity",
@@ -803,7 +803,7 @@
   {
     "id": "else_if_without_else",
     "id_span": {
-      "path": "clippy_lints/src/else_if_without_else.rs",
+      "path": "src/else_if_without_else.rs",
       "line": 44
     },
     "group": "clippy::restriction",
@@ -816,7 +816,7 @@
   {
     "id": "empty_enum",
     "id_span": {
-      "path": "clippy_lints/src/empty_enum.rs",
+      "path": "src/empty_enum.rs",
       "line": 38
     },
     "group": "clippy::pedantic",
@@ -829,7 +829,7 @@
   {
     "id": "map_entry",
     "id_span": {
-      "path": "clippy_lints/src/entry.rs",
+      "path": "src/entry.rs",
       "line": 48
     },
     "group": "clippy::perf",
@@ -842,7 +842,7 @@
   {
     "id": "enum_clike_unportable_variant",
     "id_span": {
-      "path": "clippy_lints/src/enum_clike.rs",
+      "path": "src/enum_clike.rs",
       "line": 31
     },
     "group": "clippy::correctness",
@@ -855,7 +855,7 @@
   {
     "id": "enum_variant_names",
     "id_span": {
-      "path": "clippy_lints/src/enum_variants.rs",
+      "path": "src/enum_variants.rs",
       "line": 36
     },
     "group": "clippy::style",
@@ -865,7 +865,7 @@
   {
     "id": "pub_enum_variant_names",
     "id_span": {
-      "path": "clippy_lints/src/enum_variants.rs",
+      "path": "src/enum_variants.rs",
       "line": 66
     },
     "group": "clippy::pedantic",
@@ -875,7 +875,7 @@
   {
     "id": "module_name_repetitions",
     "id_span": {
-      "path": "clippy_lints/src/enum_variants.rs",
+      "path": "src/enum_variants.rs",
       "line": 91
     },
     "group": "clippy::pedantic",
@@ -888,7 +888,7 @@
   {
     "id": "module_inception",
     "id_span": {
-      "path": "clippy_lints/src/enum_variants.rs",
+      "path": "src/enum_variants.rs",
       "line": 121
     },
     "group": "clippy::style",
@@ -901,7 +901,7 @@
   {
     "id": "eq_op",
     "id_span": {
-      "path": "clippy_lints/src/eq_op.rs",
+      "path": "src/eq_op.rs",
       "line": 34
     },
     "group": "clippy::correctness",
@@ -914,7 +914,7 @@
   {
     "id": "op_ref",
     "id_span": {
-      "path": "clippy_lints/src/eq_op.rs",
+      "path": "src/eq_op.rs",
       "line": 56
     },
     "group": "clippy::style",
@@ -927,7 +927,7 @@
   {
     "id": "erasing_op",
     "id_span": {
-      "path": "clippy_lints/src/erasing_op.rs",
+      "path": "src/erasing_op.rs",
       "line": 25
     },
     "group": "clippy::correctness",
@@ -940,7 +940,7 @@
   {
     "id": "boxed_local",
     "id_span": {
-      "path": "clippy_lints/src/escape.rs",
+      "path": "src/escape.rs",
       "line": 43
     },
     "group": "clippy::perf",
@@ -953,7 +953,7 @@
   {
     "id": "redundant_closure",
     "id_span": {
-      "path": "clippy_lints/src/eta_reduction.rs",
+      "path": "src/eta_reduction.rs",
       "line": 37
     },
     "group": "clippy::style",
@@ -966,7 +966,7 @@
   {
     "id": "redundant_closure_for_method_calls",
     "id_span": {
-      "path": "clippy_lints/src/eta_reduction.rs",
+      "path": "src/eta_reduction.rs",
       "line": 61
     },
     "group": "clippy::pedantic",
@@ -979,7 +979,7 @@
   {
     "id": "eval_order_dependence",
     "id_span": {
-      "path": "clippy_lints/src/eval_order_dependence.rs",
+      "path": "src/eval_order_dependence.rs",
       "line": 38
     },
     "group": "clippy::complexity",
@@ -992,7 +992,7 @@
   {
     "id": "diverging_sub_expression",
     "id_span": {
-      "path": "clippy_lints/src/eval_order_dependence.rs",
+      "path": "src/eval_order_dependence.rs",
       "line": 62
     },
     "group": "clippy::complexity",
@@ -1005,7 +1005,7 @@
   {
     "id": "struct_excessive_bools",
     "id_span": {
-      "path": "clippy_lints/src/excessive_bools.rs",
+      "path": "src/excessive_bools.rs",
       "line": 40
     },
     "group": "clippy::pedantic",
@@ -1018,7 +1018,7 @@
   {
     "id": "fn_params_excessive_bools",
     "id_span": {
-      "path": "clippy_lints/src/excessive_bools.rs",
+      "path": "src/excessive_bools.rs",
       "line": 78
     },
     "group": "clippy::pedantic",
@@ -1031,27 +1031,33 @@
   {
     "id": "exhaustive_enums",
     "id_span": {
-      "path": "clippy_lints/src/exhaustive_items.rs",
+      "path": "src/exhaustive_items.rs",
       "line": 34
     },
     "group": "clippy::restriction",
     "docs": " **What it does:** Warns on any exported `enum`s that are not tagged `#[non_exhaustive]`\n **Why is this bad?** Exhaustive enums are typically fine, but a project which does\n not wish to make a stability commitment around exported enums may wish to\n disable them by default.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n enum Foo {\n     Bar,\n     Baz\n }\n ```\n Use instead:\n ```rust\n #[non_exhaustive]\n enum Foo {\n     Bar,\n     Baz\n }\n ```\n",
-    "applicability": null
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MaybeIncorrect"
+    }
   },
   {
     "id": "exhaustive_structs",
     "id_span": {
-      "path": "clippy_lints/src/exhaustive_items.rs",
+      "path": "src/exhaustive_items.rs",
       "line": 64
     },
     "group": "clippy::restriction",
     "docs": " **What it does:** Warns on any exported `structs`s that are not tagged `#[non_exhaustive]`\n **Why is this bad?** Exhaustive structs are typically fine, but a project which does\n not wish to make a stability commitment around exported structs may wish to\n disable them by default.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n struct Foo {\n     bar: u8,\n     baz: String,\n }\n ```\n Use instead:\n ```rust\n #[non_exhaustive]\n struct Foo {\n     bar: u8,\n     baz: String,\n }\n ```\n",
-    "applicability": null
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MaybeIncorrect"
+    }
   },
   {
     "id": "exit",
     "id_span": {
-      "path": "clippy_lints/src/exit.rs",
+      "path": "src/exit.rs",
       "line": 20
     },
     "group": "clippy::restriction",
@@ -1064,7 +1070,7 @@
   {
     "id": "explicit_write",
     "id_span": {
-      "path": "clippy_lints/src/explicit_write.rs",
+      "path": "src/explicit_write.rs",
       "line": 25
     },
     "group": "clippy::complexity",
@@ -1077,7 +1083,7 @@
   {
     "id": "fallible_impl_from",
     "id_span": {
-      "path": "clippy_lints/src/fallible_impl_from.rs",
+      "path": "src/fallible_impl_from.rs",
       "line": 45
     },
     "group": "clippy::nursery",
@@ -1090,7 +1096,7 @@
   {
     "id": "float_equality_without_abs",
     "id_span": {
-      "path": "clippy_lints/src/float_equality_without_abs.rs",
+      "path": "src/float_equality_without_abs.rs",
       "line": 37
     },
     "group": "clippy::correctness",
@@ -1103,7 +1109,7 @@
   {
     "id": "excessive_precision",
     "id_span": {
-      "path": "clippy_lints/src/float_literal.rs",
+      "path": "src/float_literal.rs",
       "line": 30
     },
     "group": "clippy::style",
@@ -1116,7 +1122,7 @@
   {
     "id": "lossy_float_literal",
     "id_span": {
-      "path": "clippy_lints/src/float_literal.rs",
+      "path": "src/float_literal.rs",
       "line": 54
     },
     "group": "clippy::restriction",
@@ -1129,7 +1135,7 @@
   {
     "id": "imprecise_flops",
     "id_span": {
-      "path": "clippy_lints/src/floating_point_arithmetic.rs",
+      "path": "src/floating_point_arithmetic.rs",
       "line": 45
     },
     "group": "clippy::nursery",
@@ -1142,7 +1148,7 @@
   {
     "id": "suboptimal_flops",
     "id_span": {
-      "path": "clippy_lints/src/floating_point_arithmetic.rs",
+      "path": "src/floating_point_arithmetic.rs",
       "line": 102
     },
     "group": "clippy::nursery",
@@ -1155,7 +1161,7 @@
   {
     "id": "useless_format",
     "id_span": {
-      "path": "clippy_lints/src/format.rs",
+      "path": "src/format.rs",
       "line": 37
     },
     "group": "clippy::complexity",
@@ -1168,7 +1174,7 @@
   {
     "id": "suspicious_assignment_formatting",
     "id_span": {
-      "path": "clippy_lints/src/formatting.rs",
+      "path": "src/formatting.rs",
       "line": 22
     },
     "group": "clippy::style",
@@ -1181,7 +1187,7 @@
   {
     "id": "suspicious_unary_op_formatting",
     "id_span": {
-      "path": "clippy_lints/src/formatting.rs",
+      "path": "src/formatting.rs",
       "line": 44
     },
     "group": "clippy::style",
@@ -1194,7 +1200,7 @@
   {
     "id": "suspicious_else_formatting",
     "id_span": {
-      "path": "clippy_lints/src/formatting.rs",
+      "path": "src/formatting.rs",
       "line": 80
     },
     "group": "clippy::style",
@@ -1207,7 +1213,7 @@
   {
     "id": "possible_missing_comma",
     "id_span": {
-      "path": "clippy_lints/src/formatting.rs",
+      "path": "src/formatting.rs",
       "line": 100
     },
     "group": "clippy::correctness",
@@ -1220,7 +1226,7 @@
   {
     "id": "from_over_into",
     "id_span": {
-      "path": "clippy_lints/src/from_over_into.rs",
+      "path": "src/from_over_into.rs",
       "line": 39
     },
     "group": "clippy::style",
@@ -1233,7 +1239,7 @@
   {
     "id": "from_str_radix_10",
     "id_span": {
-      "path": "clippy_lints/src/from_str_radix_10.rs",
+      "path": "src/from_str_radix_10.rs",
       "line": 37
     },
     "group": "clippy::style",
@@ -1246,7 +1252,7 @@
   {
     "id": "too_many_arguments",
     "id_span": {
-      "path": "clippy_lints/src/functions.rs",
+      "path": "src/functions.rs",
       "line": 39
     },
     "group": "clippy::complexity",
@@ -1259,7 +1265,7 @@
   {
     "id": "too_many_lines",
     "id_span": {
-      "path": "clippy_lints/src/functions.rs",
+      "path": "src/functions.rs",
       "line": 62
     },
     "group": "clippy::pedantic",
@@ -1272,7 +1278,7 @@
   {
     "id": "not_unsafe_ptr_arg_deref",
     "id_span": {
-      "path": "clippy_lints/src/functions.rs",
+      "path": "src/functions.rs",
       "line": 96
     },
     "group": "clippy::correctness",
@@ -1285,7 +1291,7 @@
   {
     "id": "must_use_unit",
     "id_span": {
-      "path": "clippy_lints/src/functions.rs",
+      "path": "src/functions.rs",
       "line": 117
     },
     "group": "clippy::style",
@@ -1298,7 +1304,7 @@
   {
     "id": "double_must_use",
     "id_span": {
-      "path": "clippy_lints/src/functions.rs",
+      "path": "src/functions.rs",
       "line": 142
     },
     "group": "clippy::style",
@@ -1311,7 +1317,7 @@
   {
     "id": "must_use_candidate",
     "id_span": {
-      "path": "clippy_lints/src/functions.rs",
+      "path": "src/functions.rs",
       "line": 170
     },
     "group": "clippy::pedantic",
@@ -1324,7 +1330,7 @@
   {
     "id": "result_unit_err",
     "id_span": {
-      "path": "clippy_lints/src/functions.rs",
+      "path": "src/functions.rs",
       "line": 216
     },
     "group": "clippy::style",
@@ -1337,7 +1343,7 @@
   {
     "id": "future_not_send",
     "id_span": {
-      "path": "clippy_lints/src/future_not_send.rs",
+      "path": "src/future_not_send.rs",
       "line": 44
     },
     "group": "clippy::nursery",
@@ -1350,7 +1356,7 @@
   {
     "id": "get_last_with_len",
     "id_span": {
-      "path": "clippy_lints/src/get_last_with_len.rs",
+      "path": "src/get_last_with_len.rs",
       "line": 40
     },
     "group": "clippy::complexity",
@@ -1363,7 +1369,7 @@
   {
     "id": "identity_op",
     "id_span": {
-      "path": "clippy_lints/src/identity_op.rs",
+      "path": "src/identity_op.rs",
       "line": 24
     },
     "group": "clippy::complexity",
@@ -1376,7 +1382,7 @@
   {
     "id": "if_let_mutex",
     "id_span": {
-      "path": "clippy_lints/src/if_let_mutex.rs",
+      "path": "src/if_let_mutex.rs",
       "line": 36
     },
     "group": "clippy::correctness",
@@ -1389,7 +1395,7 @@
   {
     "id": "if_let_some_result",
     "id_span": {
-      "path": "clippy_lints/src/if_let_some_result.rs",
+      "path": "src/if_let_some_result.rs",
       "line": 34
     },
     "group": "clippy::style",
@@ -1402,7 +1408,7 @@
   {
     "id": "if_not_else",
     "id_span": {
-      "path": "clippy_lints/src/if_not_else.rs",
+      "path": "src/if_not_else.rs",
       "line": 43
     },
     "group": "clippy::pedantic",
@@ -1415,7 +1421,7 @@
   {
     "id": "implicit_return",
     "id_span": {
-      "path": "clippy_lints/src/implicit_return.rs",
+      "path": "src/implicit_return.rs",
       "line": 33
     },
     "group": "clippy::restriction",
@@ -1428,7 +1434,7 @@
   {
     "id": "implicit_saturating_sub",
     "id_span": {
-      "path": "clippy_lints/src/implicit_saturating_sub.rs",
+      "path": "src/implicit_saturating_sub.rs",
       "line": 32
     },
     "group": "clippy::pedantic",
@@ -1441,7 +1447,7 @@
   {
     "id": "inconsistent_struct_constructor",
     "id_span": {
-      "path": "clippy_lints/src/inconsistent_struct_constructor.rs",
+      "path": "src/inconsistent_struct_constructor.rs",
       "line": 58
     },
     "group": "clippy::style",
@@ -1454,7 +1460,7 @@
   {
     "id": "out_of_bounds_indexing",
     "id_span": {
-      "path": "clippy_lints/src/indexing_slicing.rs",
+      "path": "src/indexing_slicing.rs",
       "line": 32
     },
     "group": "clippy::correctness",
@@ -1467,7 +1473,7 @@
   {
     "id": "indexing_slicing",
     "id_span": {
-      "path": "clippy_lints/src/indexing_slicing.rs",
+      "path": "src/indexing_slicing.rs",
       "line": 81
     },
     "group": "clippy::restriction",
@@ -1480,27 +1486,33 @@
   {
     "id": "infinite_iter",
     "id_span": {
-      "path": "clippy_lints/src/infinite_iter.rs",
+      "path": "src/infinite_iter.rs",
       "line": 21
     },
     "group": "clippy::correctness",
     "docs": " **What it does:** Checks for iteration that is guaranteed to be infinite.\n **Why is this bad?** While there may be places where this is acceptable\n (e.g., in event streams), in most cases this is simply an error.\n\n **Known problems:** None.\n\n **Example:**\n ```no_run\n use std::iter;\n\n iter::repeat(1_u8).collect::<Vec<_>>();\n ```\n",
-    "applicability": null
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
   },
   {
     "id": "maybe_infinite_iter",
     "id_span": {
-      "path": "clippy_lints/src/infinite_iter.rs",
+      "path": "src/infinite_iter.rs",
       "line": 40
     },
     "group": "clippy::pedantic",
     "docs": " **What it does:** Checks for iteration that may be infinite.\n **Why is this bad?** While there may be places where this is acceptable\n (e.g., in event streams), in most cases this is simply an error.\n\n **Known problems:** The code may have a condition to stop iteration, but\n this lint is not clever enough to analyze it.\n\n **Example:**\n ```rust\n let infinite_iter = 0..;\n [0..].iter().zip(infinite_iter.take_while(|x| *x > 5));\n ```\n",
-    "applicability": null
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
   },
   {
     "id": "multiple_inherent_impl",
     "id_span": {
-      "path": "clippy_lints/src/inherent_impl.rs",
+      "path": "src/inherent_impl.rs",
       "line": 37
     },
     "group": "clippy::restriction",
@@ -1513,7 +1525,7 @@
   {
     "id": "inherent_to_string",
     "id_span": {
-      "path": "clippy_lints/src/inherent_to_string.rs",
+      "path": "src/inherent_to_string.rs",
       "line": 44
     },
     "group": "clippy::style",
@@ -1526,7 +1538,7 @@
   {
     "id": "inherent_to_string_shadow_display",
     "id_span": {
-      "path": "clippy_lints/src/inherent_to_string.rs",
+      "path": "src/inherent_to_string.rs",
       "line": 89
     },
     "group": "clippy::correctness",
@@ -1539,7 +1551,7 @@
   {
     "id": "inline_fn_without_body",
     "id_span": {
-      "path": "clippy_lints/src/inline_fn_without_body.rs",
+      "path": "src/inline_fn_without_body.rs",
       "line": 27
     },
     "group": "clippy::correctness",
@@ -1552,7 +1564,7 @@
   {
     "id": "int_plus_one",
     "id_span": {
-      "path": "clippy_lints/src/int_plus_one.rs",
+      "path": "src/int_plus_one.rs",
       "line": 31
     },
     "group": "clippy::complexity",
@@ -1565,7 +1577,7 @@
   {
     "id": "integer_division",
     "id_span": {
-      "path": "clippy_lints/src/integer_division.rs",
+      "path": "src/integer_division.rs",
       "line": 26
     },
     "group": "clippy::restriction",
@@ -1578,7 +1590,7 @@
   {
     "id": "items_after_statements",
     "id_span": {
-      "path": "clippy_lints/src/items_after_statements.rs",
+      "path": "src/items_after_statements.rs",
       "line": 48
     },
     "group": "clippy::pedantic",
@@ -1591,7 +1603,7 @@
   {
     "id": "large_const_arrays",
     "id_span": {
-      "path": "clippy_lints/src/large_const_arrays.rs",
+      "path": "src/large_const_arrays.rs",
       "line": 30
     },
     "group": "clippy::perf",
@@ -1604,7 +1616,7 @@
   {
     "id": "large_enum_variant",
     "id_span": {
-      "path": "clippy_lints/src/large_enum_variant.rs",
+      "path": "src/large_enum_variant.rs",
       "line": 39
     },
     "group": "clippy::perf",
@@ -1617,7 +1629,7 @@
   {
     "id": "large_stack_arrays",
     "id_span": {
-      "path": "clippy_lints/src/large_stack_arrays.rs",
+      "path": "src/large_stack_arrays.rs",
       "line": 23
     },
     "group": "clippy::pedantic",
@@ -1630,7 +1642,7 @@
   {
     "id": "len_zero",
     "id_span": {
-      "path": "clippy_lints/src/len_zero.rs",
+      "path": "src/len_zero.rs",
       "line": 41
     },
     "group": "clippy::style",
@@ -1643,7 +1655,7 @@
   {
     "id": "len_without_is_empty",
     "id_span": {
-      "path": "clippy_lints/src/len_zero.rs",
+      "path": "src/len_zero.rs",
       "line": 66
     },
     "group": "clippy::style",
@@ -1656,7 +1668,7 @@
   {
     "id": "comparison_to_empty",
     "id_span": {
-      "path": "clippy_lints/src/len_zero.rs",
+      "path": "src/len_zero.rs",
       "line": 103
     },
     "group": "clippy::style",
@@ -1669,7 +1681,7 @@
   {
     "id": "useless_let_if_seq",
     "id_span": {
-      "path": "clippy_lints/src/let_if_seq.rs",
+      "path": "src/let_if_seq.rs",
       "line": 49
     },
     "group": "clippy::nursery",
@@ -1682,7 +1694,7 @@
   {
     "id": "let_underscore_must_use",
     "id_span": {
-      "path": "clippy_lints/src/let_underscore.rs",
+      "path": "src/let_underscore.rs",
       "line": 29
     },
     "group": "clippy::restriction",
@@ -1695,7 +1707,7 @@
   {
     "id": "let_underscore_lock",
     "id_span": {
-      "path": "clippy_lints/src/let_underscore.rs",
+      "path": "src/let_underscore.rs",
       "line": 56
     },
     "group": "clippy::correctness",
@@ -1708,7 +1720,7 @@
   {
     "id": "let_underscore_drop",
     "id_span": {
-      "path": "clippy_lints/src/let_underscore.rs",
+      "path": "src/let_underscore.rs",
       "line": 97
     },
     "group": "clippy::pedantic",
@@ -1721,7 +1733,7 @@
   {
     "id": "needless_lifetimes",
     "id_span": {
-      "path": "clippy_lints/src/lifetimes.rs",
+      "path": "src/lifetimes.rs",
       "line": 46
     },
     "group": "clippy::complexity",
@@ -1734,7 +1746,7 @@
   {
     "id": "extra_unused_lifetimes",
     "id_span": {
-      "path": "clippy_lints/src/lifetimes.rs",
+      "path": "src/lifetimes.rs",
       "line": 74
     },
     "group": "clippy::complexity",
@@ -1747,7 +1759,7 @@
   {
     "id": "unreadable_literal",
     "id_span": {
-      "path": "clippy_lints/src/literal_representation.rs",
+      "path": "src/literal_representation.rs",
       "line": 33
     },
     "group": "clippy::pedantic",
@@ -1760,7 +1772,7 @@
   {
     "id": "mistyped_literal_suffixes",
     "id_span": {
-      "path": "clippy_lints/src/literal_representation.rs",
+      "path": "src/literal_representation.rs",
       "line": 57
     },
     "group": "clippy::correctness",
@@ -1773,7 +1785,7 @@
   {
     "id": "inconsistent_digit_grouping",
     "id_span": {
-      "path": "clippy_lints/src/literal_representation.rs",
+      "path": "src/literal_representation.rs",
       "line": 80
     },
     "group": "clippy::style",
@@ -1786,7 +1798,7 @@
   {
     "id": "unusual_byte_groupings",
     "id_span": {
-      "path": "clippy_lints/src/literal_representation.rs",
+      "path": "src/literal_representation.rs",
       "line": 99
     },
     "group": "clippy::style",
@@ -1799,7 +1811,7 @@
   {
     "id": "large_digit_groups",
     "id_span": {
-      "path": "clippy_lints/src/literal_representation.rs",
+      "path": "src/literal_representation.rs",
       "line": 118
     },
     "group": "clippy::pedantic",
@@ -1812,7 +1824,7 @@
   {
     "id": "decimal_literal_representation",
     "id_span": {
-      "path": "clippy_lints/src/literal_representation.rs",
+      "path": "src/literal_representation.rs",
       "line": 136
     },
     "group": "clippy::restriction",
@@ -1825,8 +1837,8 @@
   {
     "id": "manual_memcpy",
     "id_span": {
-      "path": "clippy_lints/src/loops.rs",
-      "line": 57
+      "path": "src/loops/mod.rs",
+      "line": 50
     },
     "group": "clippy::perf",
     "docs": " **What it does:** Checks for for-loops that manually copy items between slices that could be optimized by having a memcpy.\n\n **Why is this bad?** It is not as fast as a memcpy.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # let src = vec![1];\n # let mut dst = vec![0; 65];\n for i in 0..src.len() {\n     dst[i + 64] = src[i];\n }\n ```\n Could be written as:\n ```rust\n # let src = vec![1];\n # let mut dst = vec![0; 65];\n dst[64..(src.len() + 64)].clone_from_slice(&src[..]);\n ```\n",
@@ -1838,8 +1850,8 @@
   {
     "id": "needless_range_loop",
     "id_span": {
-      "path": "clippy_lints/src/loops.rs",
-      "line": 85
+      "path": "src/loops/mod.rs",
+      "line": 78
     },
     "group": "clippy::style",
     "docs": " **What it does:** Checks for looping over the range of `0..len` of some collection just to get the values by index.\n\n **Why is this bad?** Just iterating the collection itself makes the intent\n more clear and is probably faster.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n let vec = vec!['a', 'b', 'c'];\n for i in 0..vec.len() {\n     println!(\"{}\", vec[i]);\n }\n ```\n Could be written as:\n ```rust\n let vec = vec!['a', 'b', 'c'];\n for i in vec {\n     println!(\"{}\", i);\n }\n ```\n",
@@ -1851,8 +1863,8 @@
   {
     "id": "explicit_iter_loop",
     "id_span": {
-      "path": "clippy_lints/src/loops.rs",
-      "line": 114
+      "path": "src/loops/mod.rs",
+      "line": 107
     },
     "group": "clippy::pedantic",
     "docs": " **What it does:** Checks for loops on `x.iter()` where `&x` will do, and suggests the latter.\n\n **Why is this bad?** Readability.\n\n **Known problems:** False negatives. We currently only warn on some known\n types.\n\n **Example:**\n ```rust\n // with `y` a `Vec` or slice:\n # let y = vec![1];\n for x in y.iter() {\n     // ..\n }\n ```\n can be rewritten to\n ```rust\n # let y = vec![1];\n for x in &y {\n     // ..\n }\n ```\n",
@@ -1864,8 +1876,8 @@
   {
     "id": "explicit_into_iter_loop",
     "id_span": {
-      "path": "clippy_lints/src/loops.rs",
-      "line": 142
+      "path": "src/loops/mod.rs",
+      "line": 135
     },
     "group": "clippy::pedantic",
     "docs": " **What it does:** Checks for loops on `y.into_iter()` where `y` will do, and suggests the latter.\n\n **Why is this bad?** Readability.\n\n **Known problems:** None\n\n **Example:**\n ```rust\n # let y = vec![1];\n // with `y` a `Vec` or slice:\n for x in y.into_iter() {\n     // ..\n }\n ```\n can be rewritten to\n ```rust\n # let y = vec![1];\n for x in y {\n     // ..\n }\n ```\n",
@@ -1877,8 +1889,8 @@
   {
     "id": "iter_next_loop",
     "id_span": {
-      "path": "clippy_lints/src/loops.rs",
-      "line": 165
+      "path": "src/loops/mod.rs",
+      "line": 158
     },
     "group": "clippy::correctness",
     "docs": " **What it does:** Checks for loops on `x.next()`.\n **Why is this bad?** `next()` returns either `Some(value)` if there was a\n value, or `None` otherwise. The insidious thing is that `Option<_>`\n implements `IntoIterator`, so that possibly one value will be iterated,\n leading to some hard to find bugs. No one will want to write such code\n [except to win an Underhanded Rust\n Contest](https://www.reddit.com/r/rust/comments/3hb0wm/underhanded_rust_contest/cu5yuhr).\n\n **Known problems:** None.\n\n **Example:**\n ```ignore\n for x in y.next() {\n     ..\n }\n ```\n",
@@ -1890,8 +1902,8 @@
   {
     "id": "for_loops_over_fallibles",
     "id_span": {
-      "path": "clippy_lints/src/loops.rs",
-      "line": 208
+      "path": "src/loops/mod.rs",
+      "line": 201
     },
     "group": "clippy::correctness",
     "docs": " **What it does:** Checks for `for` loops over `Option` or `Result` values.\n **Why is this bad?** Readability. This is more clearly expressed as an `if\n let`.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # let opt = Some(1);\n\n // Bad\n for x in opt {\n     // ..\n }\n\n // Good\n if let Some(x) = opt {\n     // ..\n }\n ```\n\n // or\n\n ```rust\n # let res: Result<i32, std::io::Error> = Ok(1);\n\n // Bad\n for x in &res {\n     // ..\n }\n\n // Good\n if let Ok(x) = res {\n     // ..\n }\n ```\n",
@@ -1903,8 +1915,8 @@
   {
     "id": "while_let_loop",
     "id_span": {
-      "path": "clippy_lints/src/loops.rs",
-      "line": 237
+      "path": "src/loops/mod.rs",
+      "line": 230
     },
     "group": "clippy::complexity",
     "docs": " **What it does:** Detects `loop + match` combinations that are easier written as a `while let` loop.\n\n **Why is this bad?** The `while let` loop is usually shorter and more\n readable.\n\n **Known problems:** Sometimes the wrong binding is displayed ([#383](https://github.com/rust-lang/rust-clippy/issues/383)).\n\n **Example:**\n ```rust,no_run\n # let y = Some(1);\n loop {\n     let x = match y {\n         Some(x) => x,\n         None => break,\n     };\n     // .. do something with x\n }\n // is easier written as\n while let Some(x) = y {\n     // .. do something with x\n };\n ```\n",
@@ -1916,8 +1928,8 @@
   {
     "id": "needless_collect",
     "id_span": {
-      "path": "clippy_lints/src/loops.rs",
-      "line": 259
+      "path": "src/loops/mod.rs",
+      "line": 252
     },
     "group": "clippy::perf",
     "docs": " **What it does:** Checks for functions collecting an iterator when collect is not needed.\n\n **Why is this bad?** `collect` causes the allocation of a new data structure,\n when this allocation may not be needed.\n\n **Known problems:**\n None\n\n **Example:**\n ```rust\n # let iterator = vec![1].into_iter();\n let len = iterator.clone().collect::<Vec<_>>().len();\n // should be\n let len = iterator.count();\n ```\n",
@@ -1929,8 +1941,8 @@
   {
     "id": "explicit_counter_loop",
     "id_span": {
-      "path": "clippy_lints/src/loops.rs",
-      "line": 289
+      "path": "src/loops/mod.rs",
+      "line": 282
     },
     "group": "clippy::complexity",
     "docs": " **What it does:** Checks `for` loops over slices with an explicit counter and suggests the use of `.enumerate()`.\n\n **Why is it bad?** Using `.enumerate()` makes the intent more clear,\n declutters the code and may be faster in some instances.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # let v = vec![1];\n # fn bar(bar: usize, baz: usize) {}\n let mut i = 0;\n for item in &v {\n     bar(i, *item);\n     i += 1;\n }\n ```\n Could be written as\n ```rust\n # let v = vec![1];\n # fn bar(bar: usize, baz: usize) {}\n for (i, item) in v.iter().enumerate() { bar(i, *item); }\n ```\n",
@@ -1942,8 +1954,8 @@
   {
     "id": "empty_loop",
     "id_span": {
-      "path": "clippy_lints/src/loops.rs",
-      "line": 322
+      "path": "src/loops/mod.rs",
+      "line": 315
     },
     "group": "clippy::style",
     "docs": " **What it does:** Checks for empty `loop` expressions.\n **Why is this bad?** These busy loops burn CPU cycles without doing\n anything. It is _almost always_ a better idea to `panic!` than to have\n a busy loop.\n\n If panicking isn't possible, think of the environment and either:\n   - block on something\n   - sleep the thread for some microseconds\n   - yield or pause the thread\n\n For `std` targets, this can be done with\n [`std::thread::sleep`](https://doc.rust-lang.org/std/thread/fn.sleep.html)\n or [`std::thread::yield_now`](https://doc.rust-lang.org/std/thread/fn.yield_now.html).\n\n For `no_std` targets, doing this is more complicated, especially because\n `#[panic_handler]`s can't panic. To stop/pause the thread, you will\n probably need to invoke some target-specific intrinsic. Examples include:\n   - [`x86_64::instructions::hlt`](https://docs.rs/x86_64/0.12.2/x86_64/instructions/fn.hlt.html)\n   - [`cortex_m::asm::wfi`](https://docs.rs/cortex-m/0.6.3/cortex_m/asm/fn.wfi.html)\n\n **Known problems:** None.\n\n **Example:**\n ```no_run\n loop {}\n ```\n",
@@ -1955,8 +1967,8 @@
   {
     "id": "while_let_on_iterator",
     "id_span": {
-      "path": "clippy_lints/src/loops.rs",
-      "line": 341
+      "path": "src/loops/mod.rs",
+      "line": 334
     },
     "group": "clippy::style",
     "docs": " **What it does:** Checks for `while let` expressions on iterators.\n **Why is this bad?** Readability. A simple `for` loop is shorter and conveys\n the intent better.\n\n **Known problems:** None.\n\n **Example:**\n ```ignore\n while let Some(val) = iter() {\n     ..\n }\n ```\n",
@@ -1968,8 +1980,8 @@
   {
     "id": "for_kv_map",
     "id_span": {
-      "path": "clippy_lints/src/loops.rs",
-      "line": 369
+      "path": "src/loops/mod.rs",
+      "line": 362
     },
     "group": "clippy::style",
     "docs": " **What it does:** Checks for iterating a map (`HashMap` or `BTreeMap`) and ignoring either the keys or values.\n\n **Why is this bad?** Readability. There are `keys` and `values` methods that\n can be used to express that don't need the values or keys.\n\n **Known problems:** None.\n\n **Example:**\n ```ignore\n for (k, _) in &map {\n     ..\n }\n ```\n\n could be replaced by\n\n ```ignore\n for k in map.keys() {\n     ..\n }\n ```\n",
@@ -1981,8 +1993,8 @@
   {
     "id": "never_loop",
     "id_span": {
-      "path": "clippy_lints/src/loops.rs",
-      "line": 390
+      "path": "src/loops/mod.rs",
+      "line": 383
     },
     "group": "clippy::correctness",
     "docs": " **What it does:** Checks for loops that will always `break`, `return` or `continue` an outer loop.\n\n **Why is this bad?** This loop never loops, all it does is obfuscating the\n code.\n\n **Known problems:** None\n\n **Example:**\n ```rust\n loop {\n     ..;\n     break;\n }\n ```\n",
@@ -1994,8 +2006,8 @@
   {
     "id": "mut_range_bound",
     "id_span": {
-      "path": "clippy_lints/src/loops.rs",
-      "line": 410
+      "path": "src/loops/mod.rs",
+      "line": 403
     },
     "group": "clippy::complexity",
     "docs": " **What it does:** Checks for loops which have a range bound that is a mutable variable\n **Why is this bad?** One might think that modifying the mutable variable changes the loop bounds\n\n **Known problems:** None\n\n **Example:**\n ```rust\n let mut foo = 42;\n for i in 0..foo {\n     foo -= 1;\n     println!(\"{}\", i); // prints numbers from 0 to 42, not 0 to 21\n }\n ```\n",
@@ -2007,8 +2019,8 @@
   {
     "id": "while_immutable_condition",
     "id_span": {
-      "path": "clippy_lints/src/loops.rs",
-      "line": 433
+      "path": "src/loops/mod.rs",
+      "line": 426
     },
     "group": "clippy::correctness",
     "docs": " **What it does:** Checks whether variables used within while loop condition can be (and are) mutated in the body.\n\n **Why is this bad?** If the condition is unchanged, entering the body of the loop\n will lead to an infinite loop.\n\n **Known problems:** If the `while`-loop is in a closure, the check for mutation of the\n condition variables in the body can cause false negatives. For example when only `Upvar` `a` is\n in the condition and only `Upvar` `b` gets mutated in the body, the lint will not trigger.\n\n **Example:**\n ```rust\n let i = 0;\n while i > 10 {\n     println!(\"let me loop forever!\");\n }\n ```\n",
@@ -2020,8 +2032,8 @@
   {
     "id": "same_item_push",
     "id_span": {
-      "path": "clippy_lints/src/loops.rs",
-      "line": 466
+      "path": "src/loops/mod.rs",
+      "line": 459
     },
     "group": "clippy::style",
     "docs": " **What it does:** Checks whether a for loop is being used to push a constant value into a Vec.\n\n **Why is this bad?** This kind of operation can be expressed more succinctly with\n `vec![item;SIZE]` or `vec.resize(NEW_SIZE, item)` and using these alternatives may also\n have better performance.\n **Known problems:** None\n\n **Example:**\n ```rust\n let item1 = 2;\n let item2 = 3;\n let mut vec: Vec<u8> = Vec::new();\n for _ in 0..20 {\n    vec.push(item1);\n }\n for _ in 0..30 {\n     vec.push(item2);\n }\n ```\n could be written as\n ```rust\n let item1 = 2;\n let item2 = 3;\n let mut vec: Vec<u8> = vec![item1; 20];\n vec.resize(20 + 30, item2);\n ```\n",
@@ -2033,8 +2045,8 @@
   {
     "id": "single_element_loop",
     "id_span": {
-      "path": "clippy_lints/src/loops.rs",
-      "line": 491
+      "path": "src/loops/mod.rs",
+      "line": 484
     },
     "group": "clippy::complexity",
     "docs": " **What it does:** Checks whether a for loop has a single element.\n **Why is this bad?** There is no reason to have a loop of a\n single element.\n **Known problems:** None\n\n **Example:**\n ```rust\n let item1 = 2;\n for item in &[item1] {\n     println!(\"{}\", item);\n }\n ```\n could be written as\n ```rust\n let item1 = 2;\n let item = &item1;\n println!(\"{}\", item);\n ```\n",
@@ -2046,8 +2058,8 @@
   {
     "id": "manual_flatten",
     "id_span": {
-      "path": "clippy_lints/src/loops.rs",
-      "line": 522
+      "path": "src/loops/mod.rs",
+      "line": 515
     },
     "group": "clippy::complexity",
     "docs": " **What it does:** Check for unnecessary `if let` usage in a for loop where only the `Some` or `Ok` variant of the iterator element is used.\n\n **Why is this bad?** It is verbose and can be simplified\n by first calling the `flatten` method on the `Iterator`.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n let x = vec![Some(1), Some(2), Some(3)];\n for n in x {\n     if let Some(n) = n {\n         println!(\"{}\", n);\n     }\n }\n ```\n Use instead:\n ```rust\n let x = vec![Some(1), Some(2), Some(3)];\n for n in x.into_iter().flatten() {\n     println!(\"{}\", n);\n }\n ```\n",
@@ -2059,7 +2071,7 @@
   {
     "id": "macro_use_imports",
     "id_span": {
-      "path": "clippy_lints/src/macro_use.rs",
+      "path": "src/macro_use.rs",
       "line": 25
     },
     "group": "clippy::pedantic",
@@ -2072,7 +2084,7 @@
   {
     "id": "main_recursion",
     "id_span": {
-      "path": "clippy_lints/src/main_recursion.rs",
+      "path": "src/main_recursion.rs",
       "line": 22
     },
     "group": "clippy::style",
@@ -2085,7 +2097,7 @@
   {
     "id": "manual_async_fn",
     "id_span": {
-      "path": "clippy_lints/src/manual_async_fn.rs",
+      "path": "src/manual_async_fn.rs",
       "line": 32
     },
     "group": "clippy::style",
@@ -2098,11 +2110,11 @@
   {
     "id": "manual_map",
     "id_span": {
-      "path": "clippy_lints/src/manual_map.rs",
-      "line": 36
+      "path": "src/manual_map.rs",
+      "line": 44
     },
-    "group": "clippy::nursery",
-    "docs": " **What it does:** Checks for usages of `match` which could be implemented using `map`\n **Why is this bad?** Using the `map` method is clearer and more concise.\n\n **Known problems:** `map` is not capable of representing some control flow which works fine in `match`.\n\n **Example:**\n\n ```rust\n match Some(0) {\n     Some(x) => Some(x + 1),\n     None => None,\n };\n ```\n Use instead:\n ```rust\n Some(0).map(|x| x + 1);\n ```\n",
+    "group": "clippy::style",
+    "docs": " **What it does:** Checks for usages of `match` which could be implemented using `map`\n **Why is this bad?** Using the `map` method is clearer and more concise.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n match Some(0) {\n     Some(x) => Some(x + 1),\n     None => None,\n };\n ```\n Use instead:\n ```rust\n Some(0).map(|x| x + 1);\n ```\n",
     "applicability": {
       "is_multi_suggestion": false,
       "applicability": "MachineApplicable"
@@ -2111,7 +2123,7 @@
   {
     "id": "manual_non_exhaustive",
     "id_span": {
-      "path": "clippy_lints/src/manual_non_exhaustive.rs",
+      "path": "src/manual_non_exhaustive.rs",
       "line": 56
     },
     "group": "clippy::style",
@@ -2124,7 +2136,7 @@
   {
     "id": "manual_ok_or",
     "id_span": {
-      "path": "clippy_lints/src/manual_ok_or.rs",
+      "path": "src/manual_ok_or.rs",
       "line": 34
     },
     "group": "clippy::pedantic",
@@ -2137,7 +2149,7 @@
   {
     "id": "manual_strip",
     "id_span": {
-      "path": "clippy_lints/src/manual_strip.rs",
+      "path": "src/manual_strip.rs",
       "line": 52
     },
     "group": "clippy::complexity",
@@ -2150,7 +2162,7 @@
   {
     "id": "manual_unwrap_or",
     "id_span": {
-      "path": "clippy_lints/src/manual_unwrap_or.rs",
+      "path": "src/manual_unwrap_or.rs",
       "line": 36
     },
     "group": "clippy::complexity",
@@ -2163,7 +2175,7 @@
   {
     "id": "map_clone",
     "id_span": {
-      "path": "clippy_lints/src/map_clone.rs",
+      "path": "src/map_clone.rs",
       "line": 40
     },
     "group": "clippy::style",
@@ -2176,7 +2188,7 @@
   {
     "id": "map_err_ignore",
     "id_span": {
-      "path": "clippy_lints/src/map_err_ignore.rs",
+      "path": "src/map_err_ignore.rs",
       "line": 101
     },
     "group": "clippy::restriction",
@@ -2189,7 +2201,7 @@
   {
     "id": "map_identity",
     "id_span": {
-      "path": "clippy_lints/src/map_identity.rs",
+      "path": "src/map_identity.rs",
       "line": 30
     },
     "group": "clippy::complexity",
@@ -2202,27 +2214,33 @@
   {
     "id": "option_map_unit_fn",
     "id_span": {
-      "path": "clippy_lints/src/map_unit_fn.rs",
+      "path": "src/map_unit_fn.rs",
       "line": 48
     },
     "group": "clippy::complexity",
     "docs": " **What it does:** Checks for usage of `option.map(f)` where f is a function or closure that returns the unit type `()`.\n\n **Why is this bad?** Readability, this can be written more clearly with\n an if let statement\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n # fn do_stuff() -> Option<String> { Some(String::new()) }\n # fn log_err_msg(foo: String) -> Option<String> { Some(foo) }\n # fn format_msg(foo: String) -> String { String::new() }\n let x: Option<String> = do_stuff();\n x.map(log_err_msg);\n # let x: Option<String> = do_stuff();\n x.map(|msg| log_err_msg(format_msg(msg)));\n ```\n\n The correct use would be:\n\n ```rust\n # fn do_stuff() -> Option<String> { Some(String::new()) }\n # fn log_err_msg(foo: String) -> Option<String> { Some(foo) }\n # fn format_msg(foo: String) -> String { String::new() }\n let x: Option<String> = do_stuff();\n if let Some(msg) = x {\n     log_err_msg(msg);\n }\n\n # let x: Option<String> = do_stuff();\n if let Some(msg) = x {\n     log_err_msg(format_msg(msg));\n }\n ```\n",
-    "applicability": null
+    "applicability": {
+      "is_multi_suggestion": true,
+      "applicability": "MachineApplicable"
+    }
   },
   {
     "id": "result_map_unit_fn",
     "id_span": {
-      "path": "clippy_lints/src/map_unit_fn.rs",
+      "path": "src/map_unit_fn.rs",
       "line": 89
     },
     "group": "clippy::complexity",
     "docs": " **What it does:** Checks for usage of `result.map(f)` where f is a function or closure that returns the unit type `()`.\n\n **Why is this bad?** Readability, this can be written more clearly with\n an if let statement\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n # fn do_stuff() -> Result<String, String> { Ok(String::new()) }\n # fn log_err_msg(foo: String) -> Result<String, String> { Ok(foo) }\n # fn format_msg(foo: String) -> String { String::new() }\n let x: Result<String, String> = do_stuff();\n x.map(log_err_msg);\n # let x: Result<String, String> = do_stuff();\n x.map(|msg| log_err_msg(format_msg(msg)));\n ```\n\n The correct use would be:\n\n ```rust\n # fn do_stuff() -> Result<String, String> { Ok(String::new()) }\n # fn log_err_msg(foo: String) -> Result<String, String> { Ok(foo) }\n # fn format_msg(foo: String) -> String { String::new() }\n let x: Result<String, String> = do_stuff();\n if let Ok(msg) = x {\n     log_err_msg(msg);\n };\n # let x: Result<String, String> = do_stuff();\n if let Ok(msg) = x {\n     log_err_msg(format_msg(msg));\n };\n ```\n",
-    "applicability": null
+    "applicability": {
+      "is_multi_suggestion": true,
+      "applicability": "MachineApplicable"
+    }
   },
   {
     "id": "match_on_vec_items",
     "id_span": {
-      "path": "clippy_lints/src/match_on_vec_items.rs",
+      "path": "src/match_on_vec_items.rs",
       "line": 41
     },
     "group": "clippy::pedantic",
@@ -2235,27 +2253,33 @@
   {
     "id": "single_match",
     "id_span": {
-      "path": "clippy_lints/src/matches.rs",
+      "path": "src/matches.rs",
       "line": 55
     },
     "group": "clippy::style",
     "docs": " **What it does:** Checks for matches with a single arm where an `if let` will usually suffice.\n\n **Why is this bad?** Just readability – `if let` nests less than a `match`.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # fn bar(stool: &str) {}\n # let x = Some(\"abc\");\n // Bad\n match x {\n     Some(ref foo) => bar(foo),\n     _ => (),\n }\n\n // Good\n if let Some(ref foo) = x {\n     bar(foo);\n }\n ```\n",
-    "applicability": null
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "HasPlaceholders"
+    }
   },
   {
     "id": "single_match_else",
     "id_span": {
-      "path": "clippy_lints/src/matches.rs",
+      "path": "src/matches.rs",
       "line": 94
     },
     "group": "clippy::pedantic",
     "docs": " **What it does:** Checks for matches with two arms where an `if let else` will usually suffice.\n\n **Why is this bad?** Just readability – `if let` nests less than a `match`.\n\n **Known problems:** Personal style preferences may differ.\n\n **Example:**\n\n Using `match`:\n\n ```rust\n # fn bar(foo: &usize) {}\n # let other_ref: usize = 1;\n # let x: Option<&usize> = Some(&1);\n match x {\n     Some(ref foo) => bar(foo),\n     _ => bar(&other_ref),\n }\n ```\n\n Using `if let` with `else`:\n\n ```rust\n # fn bar(foo: &usize) {}\n # let other_ref: usize = 1;\n # let x: Option<&usize> = Some(&1);\n if let Some(ref foo) = x {\n     bar(foo);\n } else {\n     bar(&other_ref);\n }\n ```\n",
-    "applicability": null
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "HasPlaceholders"
+    }
   },
   {
     "id": "match_ref_pats",
     "id_span": {
-      "path": "clippy_lints/src/matches.rs",
+      "path": "src/matches.rs",
       "line": 125
     },
     "group": "clippy::style",
@@ -2268,7 +2292,7 @@
   {
     "id": "match_bool",
     "id_span": {
-      "path": "clippy_lints/src/matches.rs",
+      "path": "src/matches.rs",
       "line": 159
     },
     "group": "clippy::pedantic",
@@ -2281,7 +2305,7 @@
   {
     "id": "match_overlapping_arm",
     "id_span": {
-      "path": "clippy_lints/src/matches.rs",
+      "path": "src/matches.rs",
       "line": 181
     },
     "group": "clippy::style",
@@ -2294,7 +2318,7 @@
   {
     "id": "match_wild_err_arm",
     "id_span": {
-      "path": "clippy_lints/src/matches.rs",
+      "path": "src/matches.rs",
       "line": 203
     },
     "group": "clippy::pedantic",
@@ -2307,7 +2331,7 @@
   {
     "id": "match_as_ref",
     "id_span": {
-      "path": "clippy_lints/src/matches.rs",
+      "path": "src/matches.rs",
       "line": 229
     },
     "group": "clippy::complexity",
@@ -2320,7 +2344,7 @@
   {
     "id": "wildcard_enum_match_arm",
     "id_span": {
-      "path": "clippy_lints/src/matches.rs",
+      "path": "src/matches.rs",
       "line": 258
     },
     "group": "clippy::restriction",
@@ -2333,7 +2357,7 @@
   {
     "id": "match_wildcard_for_single_variants",
     "id_span": {
-      "path": "clippy_lints/src/matches.rs",
+      "path": "src/matches.rs",
       "line": 290
     },
     "group": "clippy::pedantic",
@@ -2346,7 +2370,7 @@
   {
     "id": "wildcard_in_or_patterns",
     "id_span": {
-      "path": "clippy_lints/src/matches.rs",
+      "path": "src/matches.rs",
       "line": 317
     },
     "group": "clippy::complexity",
@@ -2359,7 +2383,7 @@
   {
     "id": "infallible_destructuring_match",
     "id_span": {
-      "path": "clippy_lints/src/matches.rs",
+      "path": "src/matches.rs",
       "line": 352
     },
     "group": "clippy::style",
@@ -2372,7 +2396,7 @@
   {
     "id": "match_single_binding",
     "id_span": {
-      "path": "clippy_lints/src/matches.rs",
+      "path": "src/matches.rs",
       "line": 380
     },
     "group": "clippy::complexity",
@@ -2385,7 +2409,7 @@
   {
     "id": "rest_pat_in_fully_bound_structs",
     "id_span": {
-      "path": "clippy_lints/src/matches.rs",
+      "path": "src/matches.rs",
       "line": 410
     },
     "group": "clippy::restriction",
@@ -2398,7 +2422,7 @@
   {
     "id": "redundant_pattern_matching",
     "id_span": {
-      "path": "clippy_lints/src/matches.rs",
+      "path": "src/matches.rs",
       "line": 458
     },
     "group": "clippy::style",
@@ -2411,7 +2435,7 @@
   {
     "id": "match_like_matches_macro",
     "id_span": {
-      "path": "clippy_lints/src/matches.rs",
+      "path": "src/matches.rs",
       "line": 491
     },
     "group": "clippy::style",
@@ -2424,7 +2448,7 @@
   {
     "id": "match_same_arms",
     "id_span": {
-      "path": "clippy_lints/src/matches.rs",
+      "path": "src/matches.rs",
       "line": 532
     },
     "group": "clippy::pedantic",
@@ -2437,7 +2461,7 @@
   {
     "id": "mem_discriminant_non_enum",
     "id_span": {
-      "path": "clippy_lints/src/mem_discriminant.rs",
+      "path": "src/mem_discriminant.rs",
       "line": 25
     },
     "group": "clippy::correctness",
@@ -2450,7 +2474,7 @@
   {
     "id": "mem_forget",
     "id_span": {
-      "path": "clippy_lints/src/mem_forget.rs",
+      "path": "src/mem_forget.rs",
       "line": 21
     },
     "group": "clippy::restriction",
@@ -2463,7 +2487,7 @@
   {
     "id": "mem_replace_option_with_none",
     "id_span": {
-      "path": "clippy_lints/src/mem_replace.rs",
+      "path": "src/mem_replace.rs",
       "line": 37
     },
     "group": "clippy::style",
@@ -2476,7 +2500,7 @@
   {
     "id": "mem_replace_with_uninit",
     "id_span": {
-      "path": "clippy_lints/src/mem_replace.rs",
+      "path": "src/mem_replace.rs",
       "line": 69
     },
     "group": "clippy::correctness",
@@ -2489,7 +2513,7 @@
   {
     "id": "mem_replace_with_default",
     "id_span": {
-      "path": "clippy_lints/src/mem_replace.rs",
+      "path": "src/mem_replace.rs",
       "line": 93
     },
     "group": "clippy::style",
@@ -2502,8 +2526,8 @@
   {
     "id": "unwrap_used",
     "id_span": {
-      "path": "clippy_lints/src/methods/mod.rs",
-      "line": 82
+      "path": "src/methods/mod.rs",
+      "line": 84
     },
     "group": "clippy::restriction",
     "docs": " **What it does:** Checks for `.unwrap()` calls on `Option`s and on `Result`s.\n **Why is this bad?** It is better to handle the `None` or `Err` case,\n or at least call `.expect(_)` with a more helpful message. Still, for a lot of\n quick-and-dirty code, `unwrap` is a good choice, which is why this lint is\n `Allow` by default.\n\n `result.unwrap()` will let the thread panic on `Err` values.\n Normally, you want to implement more sophisticated error handling,\n and propagate errors upwards with `?` operator.\n\n Even if you want to panic on errors, not all `Error`s implement good\n messages on display. Therefore, it may be beneficial to look at the places\n where they may get displayed. Activate this lint to do just that.\n\n **Known problems:** None.\n\n **Examples:**\n ```rust\n # let opt = Some(1);\n\n // Bad\n opt.unwrap();\n\n // Good\n opt.expect(\"more helpful message\");\n ```\n\n // or\n\n ```rust\n # let res: Result<usize, ()> = Ok(1);\n\n // Bad\n res.unwrap();\n\n // Good\n res.expect(\"more helpful message\");\n ```\n",
@@ -2512,8 +2536,8 @@
   {
     "id": "expect_used",
     "id_span": {
-      "path": "clippy_lints/src/methods/mod.rs",
-      "line": 124
+      "path": "src/methods/mod.rs",
+      "line": 126
     },
     "group": "clippy::restriction",
     "docs": " **What it does:** Checks for `.expect()` calls on `Option`s and `Result`s.\n **Why is this bad?** Usually it is better to handle the `None` or `Err` case.\n Still, for a lot of quick-and-dirty code, `expect` is a good choice, which is why\n this lint is `Allow` by default.\n\n `result.expect()` will let the thread panic on `Err`\n values. Normally, you want to implement more sophisticated error handling,\n and propagate errors upwards with `?` operator.\n\n **Known problems:** None.\n\n **Examples:**\n ```rust,ignore\n # let opt = Some(1);\n\n // Bad\n opt.expect(\"one\");\n\n // Good\n let opt = Some(1);\n opt?;\n ```\n\n // or\n\n ```rust\n # let res: Result<usize, ()> = Ok(1);\n\n // Bad\n res.expect(\"one\");\n\n // Good\n res?;\n # Ok::<(), ()>(())\n ```\n",
@@ -2522,8 +2546,8 @@
   {
     "id": "should_implement_trait",
     "id_span": {
-      "path": "clippy_lints/src/methods/mod.rs",
-      "line": 153
+      "path": "src/methods/mod.rs",
+      "line": 155
     },
     "group": "clippy::style",
     "docs": " **What it does:** Checks for methods that should live in a trait implementation of a `std` trait (see [llogiq's blog\n post](http://llogiq.github.io/2015/07/30/traits.html) for further\n information) instead of an inherent implementation.\n\n **Why is this bad?** Implementing the traits improve ergonomics for users of\n the code, often with very little cost. Also people seeing a `mul(...)`\n method\n may expect `*` to work equally, so you should have good reason to disappoint\n them.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n struct X;\n impl X {\n     fn add(&self, other: &X) -> X {\n         // ..\n # X\n     }\n }\n ```\n",
@@ -2535,28 +2559,34 @@
   {
     "id": "wrong_self_convention",
     "id_span": {
-      "path": "clippy_lints/src/methods/mod.rs",
-      "line": 186
+      "path": "src/methods/mod.rs",
+      "line": 188
     },
     "group": "clippy::style",
     "docs": " **What it does:** Checks for methods with certain name prefixes and which doesn't match how self is taken. The actual rules are:\n\n |Prefix |`self` taken          |\n |-------|----------------------|\n |`as_`  |`&self` or `&mut self`|\n |`from_`| none                 |\n |`into_`|`self`                |\n |`is_`  |`&self` or none       |\n |`to_`  |`&self`               |\n\n **Why is this bad?** Consistency breeds readability. If you follow the\n conventions, your users won't be surprised that they, e.g., need to supply a\n mutable reference to a `as_..` function.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # struct X;\n impl X {\n     fn as_str(self) -> &'static str {\n         // ..\n # \"\"\n     }\n }\n ```\n",
-    "applicability": null
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
   },
   {
     "id": "wrong_pub_self_convention",
     "id_span": {
-      "path": "clippy_lints/src/methods/mod.rs",
-      "line": 210
+      "path": "src/methods/mod.rs",
+      "line": 212
     },
     "group": "clippy::restriction",
     "docs": " **What it does:** This is the same as [`wrong_self_convention`](#wrong_self_convention), but for public items.\n\n **Why is this bad?** See [`wrong_self_convention`](#wrong_self_convention).\n\n **Known problems:** Actually *renaming* the function may break clients if\n the function is part of the public interface. In that case, be mindful of\n the stability guarantees you've given your users.\n\n **Example:**\n ```rust\n # struct X;\n impl<'a> X {\n     pub fn as_str(self) -> &'a str {\n         \"foo\"\n     }\n }\n ```\n",
-    "applicability": null
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
   },
   {
     "id": "ok_expect",
     "id_span": {
-      "path": "clippy_lints/src/methods/mod.rs",
-      "line": 233
+      "path": "src/methods/mod.rs",
+      "line": 235
     },
     "group": "clippy::style",
     "docs": " **What it does:** Checks for usage of `ok().expect(..)`.\n **Why is this bad?** Because you usually call `expect()` on the `Result`\n directly to get a better error message.\n\n **Known problems:** The error type needs to implement `Debug`\n\n **Example:**\n ```rust\n # let x = Ok::<_, ()>(());\n\n // Bad\n x.ok().expect(\"why did I do this again?\");\n\n // Good\n x.expect(\"why did I do this again?\");\n ```\n",
@@ -2568,8 +2598,8 @@
   {
     "id": "map_unwrap_or",
     "id_span": {
-      "path": "clippy_lints/src/methods/mod.rs",
-      "line": 270
+      "path": "src/methods/mod.rs",
+      "line": 272
     },
     "group": "clippy::pedantic",
     "docs": " **What it does:** Checks for usage of `option.map(_).unwrap_or(_)` or `option.map(_).unwrap_or_else(_)` or `result.map(_).unwrap_or_else(_)`.\n\n **Why is this bad?** Readability, these can be written more concisely (resp.) as\n `option.map_or(_, _)`, `option.map_or_else(_, _)` and `result.map_or_else(_, _)`.\n\n **Known problems:** The order of the arguments is not in execution order\n\n **Examples:**\n ```rust\n # let x = Some(1);\n\n // Bad\n x.map(|a| a + 1).unwrap_or(0);\n\n // Good\n x.map_or(0, |a| a + 1);\n ```\n\n // or\n\n ```rust\n # let x: Result<usize, ()> = Ok(1);\n # fn some_function(foo: ()) -> usize { 1 }\n\n // Bad\n x.map(|a| a + 1).unwrap_or_else(some_function);\n\n // Good\n x.map_or_else(some_function, |a| a + 1);\n ```\n",
@@ -2581,28 +2611,34 @@
   {
     "id": "option_map_or_none",
     "id_span": {
-      "path": "clippy_lints/src/methods/mod.rs",
-      "line": 293
+      "path": "src/methods/mod.rs",
+      "line": 295
     },
     "group": "clippy::style",
     "docs": " **What it does:** Checks for usage of `_.map_or(None, _)`.\n **Why is this bad?** Readability, this can be written more concisely as\n `_.and_then(_)`.\n\n **Known problems:** The order of the arguments is not in execution order.\n\n **Example:**\n ```rust\n # let opt = Some(1);\n\n // Bad\n opt.map_or(None, |a| Some(a + 1));\n\n // Good\n opt.and_then(|a| Some(a + 1));\n ```\n",
-    "applicability": null
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
   },
   {
     "id": "result_map_or_into_option",
     "id_span": {
-      "path": "clippy_lints/src/methods/mod.rs",
-      "line": 319
+      "path": "src/methods/mod.rs",
+      "line": 321
     },
     "group": "clippy::style",
     "docs": " **What it does:** Checks for usage of `_.map_or(None, Some)`.\n **Why is this bad?** Readability, this can be written more concisely as\n `_.ok()`.\n\n **Known problems:** None.\n\n **Example:**\n\n Bad:\n ```rust\n # let r: Result<u32, &str> = Ok(1);\n assert_eq!(Some(1), r.map_or(None, Some));\n ```\n\n Good:\n ```rust\n # let r: Result<u32, &str> = Ok(1);\n assert_eq!(Some(1), r.ok());\n ```\n",
-    "applicability": null
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
   },
   {
     "id": "bind_instead_of_map",
     "id_span": {
-      "path": "clippy_lints/src/methods/mod.rs",
-      "line": 352
+      "path": "src/methods/mod.rs",
+      "line": 354
     },
     "group": "clippy::complexity",
     "docs": " **What it does:** Checks for usage of `_.and_then(|x| Some(y))`, `_.and_then(|x| Ok(y))` or `_.or_else(|x| Err(y))`.\n\n **Why is this bad?** Readability, this can be written more concisely as\n `_.map(|x| y)` or `_.map_err(|x| y)`.\n\n **Known problems:** None\n\n **Example:**\n\n ```rust\n # fn opt() -> Option<&'static str> { Some(\"42\") }\n # fn res() -> Result<&'static str, &'static str> { Ok(\"42\") }\n let _ = opt().and_then(|s| Some(s.len()));\n let _ = res().and_then(|s| if s.len() == 42 { Ok(10) } else { Ok(20) });\n let _ = res().or_else(|s| if s.len() == 42 { Err(10) } else { Err(20) });\n ```\n\n The correct use would be:\n\n ```rust\n # fn opt() -> Option<&'static str> { Some(\"42\") }\n # fn res() -> Result<&'static str, &'static str> { Ok(\"42\") }\n let _ = opt().map(|s| s.len());\n let _ = res().map(|s| if s.len() == 42 { 10 } else { 20 });\n let _ = res().map_err(|s| if s.len() == 42 { 10 } else { 20 });\n ```\n",
@@ -2614,8 +2650,8 @@
   {
     "id": "filter_next",
     "id_span": {
-      "path": "clippy_lints/src/methods/mod.rs",
-      "line": 375
+      "path": "src/methods/mod.rs",
+      "line": 377
     },
     "group": "clippy::complexity",
     "docs": " **What it does:** Checks for usage of `_.filter(_).next()`.\n **Why is this bad?** Readability, this can be written more concisely as\n `_.find(_)`.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # let vec = vec![1];\n vec.iter().filter(|x| **x == 0).next();\n ```\n Could be written as\n ```rust\n # let vec = vec![1];\n vec.iter().find(|x| **x == 0);\n ```\n",
@@ -2627,8 +2663,8 @@
   {
     "id": "skip_while_next",
     "id_span": {
-      "path": "clippy_lints/src/methods/mod.rs",
-      "line": 398
+      "path": "src/methods/mod.rs",
+      "line": 400
     },
     "group": "clippy::complexity",
     "docs": " **What it does:** Checks for usage of `_.skip_while(condition).next()`.\n **Why is this bad?** Readability, this can be written more concisely as\n `_.find(!condition)`.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # let vec = vec![1];\n vec.iter().skip_while(|x| **x == 0).next();\n ```\n Could be written as\n ```rust\n # let vec = vec![1];\n vec.iter().find(|x| **x != 0);\n ```\n",
@@ -2640,8 +2676,8 @@
   {
     "id": "map_flatten",
     "id_span": {
-      "path": "clippy_lints/src/methods/mod.rs",
-      "line": 421
+      "path": "src/methods/mod.rs",
+      "line": 423
     },
     "group": "clippy::pedantic",
     "docs": " **What it does:** Checks for usage of `_.map(_).flatten(_)`,\n **Why is this bad?** Readability, this can be written more concisely as\n `_.flat_map(_)`\n\n **Known problems:**\n\n **Example:**\n ```rust\n let vec = vec![vec![1]];\n\n // Bad\n vec.iter().map(|x| x.iter()).flatten();\n\n // Good\n vec.iter().flat_map(|x| x.iter());\n ```\n",
@@ -2653,8 +2689,8 @@
   {
     "id": "filter_map",
     "id_span": {
-      "path": "clippy_lints/src/methods/mod.rs",
-      "line": 450
+      "path": "src/methods/mod.rs",
+      "line": 452
     },
     "group": "clippy::pedantic",
     "docs": " **What it does:** Checks for usage of `_.filter(_).map(_)`, `_.filter(_).flat_map(_)`, `_.filter_map(_).flat_map(_)` and similar.\n\n **Why is this bad?** Readability, this can be written more concisely as\n `_.filter_map(_)`.\n\n **Known problems:** Often requires a condition + Option/Iterator creation\n inside the closure.\n\n **Example:**\n ```rust\n let vec = vec![1];\n\n // Bad\n vec.iter().filter(|x| **x == 0).map(|x| *x * 2);\n\n // Good\n vec.iter().filter_map(|x| if *x == 0 {\n     Some(*x * 2)\n } else {\n     None\n });\n ```\n",
@@ -2666,28 +2702,34 @@
   {
     "id": "manual_filter_map",
     "id_span": {
-      "path": "clippy_lints/src/methods/mod.rs",
-      "line": 476
+      "path": "src/methods/mod.rs",
+      "line": 478
     },
     "group": "clippy::complexity",
     "docs": " **What it does:** Checks for usage of `_.filter(_).map(_)` that can be written more simply as `filter_map(_)`.\n\n **Why is this bad?** Redundant code in the `filter` and `map` operations is poor style and\n less performant.\n\n **Known problems:** None.\n\n **Example:**\n Bad:\n ```rust\n (0_i32..10)\n     .filter(|n| n.checked_add(1).is_some())\n     .map(|n| n.checked_add(1).unwrap());\n ```\n\n Good:\n ```rust\n (0_i32..10).filter_map(|n| n.checked_add(1));\n ```\n",
-    "applicability": null
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
   },
   {
     "id": "manual_find_map",
     "id_span": {
-      "path": "clippy_lints/src/methods/mod.rs",
-      "line": 502
+      "path": "src/methods/mod.rs",
+      "line": 504
     },
     "group": "clippy::complexity",
     "docs": " **What it does:** Checks for usage of `_.find(_).map(_)` that can be written more simply as `find_map(_)`.\n\n **Why is this bad?** Redundant code in the `find` and `map` operations is poor style and\n less performant.\n\n **Known problems:** None.\n\n **Example:**\n Bad:\n ```rust\n (0_i32..10)\n     .find(|n| n.checked_add(1).is_some())\n     .map(|n| n.checked_add(1).unwrap());\n ```\n\n Good:\n ```rust\n (0_i32..10).find_map(|n| n.checked_add(1));\n ```\n",
-    "applicability": null
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
   },
   {
     "id": "filter_map_next",
     "id_span": {
-      "path": "clippy_lints/src/methods/mod.rs",
-      "line": 524
+      "path": "src/methods/mod.rs",
+      "line": 526
     },
     "group": "clippy::pedantic",
     "docs": " **What it does:** Checks for usage of `_.filter_map(_).next()`.\n **Why is this bad?** Readability, this can be written more concisely as\n `_.find_map(_)`.\n\n **Known problems:** None\n\n **Example:**\n ```rust\n  (0..3).filter_map(|x| if x == 2 { Some(x) } else { None }).next();\n ```\n Can be written as\n\n ```rust\n  (0..3).find_map(|x| if x == 2 { Some(x) } else { None });\n ```\n",
@@ -2699,8 +2741,8 @@
   {
     "id": "flat_map_identity",
     "id_span": {
-      "path": "clippy_lints/src/methods/mod.rs",
-      "line": 546
+      "path": "src/methods/mod.rs",
+      "line": 548
     },
     "group": "clippy::complexity",
     "docs": " **What it does:** Checks for usage of `flat_map(|x| x)`.\n **Why is this bad?** Readability, this can be written more concisely by using `flatten`.\n\n **Known problems:** None\n\n **Example:**\n ```rust\n # let iter = vec![vec![0]].into_iter();\n iter.flat_map(|x| x);\n ```\n Can be written as\n ```rust\n # let iter = vec![vec![0]].into_iter();\n iter.flatten();\n ```\n",
@@ -2712,8 +2754,8 @@
   {
     "id": "search_is_some",
     "id_span": {
-      "path": "clippy_lints/src/methods/mod.rs",
-      "line": 570
+      "path": "src/methods/mod.rs",
+      "line": 572
     },
     "group": "clippy::complexity",
     "docs": " **What it does:** Checks for an iterator or string search (such as `find()`, `position()`, or `rposition()`) followed by a call to `is_some()`.\n\n **Why is this bad?** Readability, this can be written more concisely as\n `_.any(_)` or `_.contains(_)`.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # let vec = vec![1];\n vec.iter().find(|x| **x == 0).is_some();\n ```\n Could be written as\n ```rust\n # let vec = vec![1];\n vec.iter().any(|x| *x == 0);\n ```\n",
@@ -2725,8 +2767,8 @@
   {
     "id": "chars_next_cmp",
     "id_span": {
-      "path": "clippy_lints/src/methods/mod.rs",
-      "line": 594
+      "path": "src/methods/mod.rs",
+      "line": 596
     },
     "group": "clippy::style",
     "docs": " **What it does:** Checks for usage of `.chars().next()` on a `str` to check if it starts with a given char.\n\n **Why is this bad?** Readability, this can be written more concisely as\n `_.starts_with(_)`.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n let name = \"foo\";\n if name.chars().next() == Some('_') {};\n ```\n Could be written as\n ```rust\n let name = \"foo\";\n if name.starts_with('_') {};\n ```\n",
@@ -2735,8 +2777,8 @@
   {
     "id": "or_fun_call",
     "id_span": {
-      "path": "clippy_lints/src/methods/mod.rs",
-      "line": 625
+      "path": "src/methods/mod.rs",
+      "line": 627
     },
     "group": "clippy::perf",
     "docs": " **What it does:** Checks for calls to `.or(foo(..))`, `.unwrap_or(foo(..))`, etc., and suggests to use `or_else`, `unwrap_or_else`, etc., or\n `unwrap_or_default` instead.\n\n **Why is this bad?** The function will always be called and potentially\n allocate an object acting as the default.\n\n **Known problems:** If the function has side-effects, not calling it will\n change the semantic of the program, but you shouldn't rely on that anyway.\n\n **Example:**\n ```rust\n # let foo = Some(String::new());\n foo.unwrap_or(String::new());\n ```\n this can instead be written:\n ```rust\n # let foo = Some(String::new());\n foo.unwrap_or_else(String::new);\n ```\n or\n ```rust\n # let foo = Some(String::new());\n foo.unwrap_or_default();\n ```\n",
@@ -2748,8 +2790,8 @@
   {
     "id": "expect_fun_call",
     "id_span": {
-      "path": "clippy_lints/src/methods/mod.rs",
-      "line": 660
+      "path": "src/methods/mod.rs",
+      "line": 662
     },
     "group": "clippy::perf",
     "docs": " **What it does:** Checks for calls to `.expect(&format!(...))`, `.expect(foo(..))`, etc., and suggests to use `unwrap_or_else` instead\n\n **Why is this bad?** The function will always be called.\n\n **Known problems:** If the function has side-effects, not calling it will\n change the semantics of the program, but you shouldn't rely on that anyway.\n\n **Example:**\n ```rust\n # let foo = Some(String::new());\n # let err_code = \"418\";\n # let err_msg = \"I'm a teapot\";\n foo.expect(&format!(\"Err {}: {}\", err_code, err_msg));\n ```\n or\n ```rust\n # let foo = Some(String::new());\n # let err_code = \"418\";\n # let err_msg = \"I'm a teapot\";\n foo.expect(format!(\"Err {}: {}\", err_code, err_msg).as_str());\n ```\n this can instead be written:\n ```rust\n # let foo = Some(String::new());\n # let err_code = \"418\";\n # let err_msg = \"I'm a teapot\";\n foo.unwrap_or_else(|| panic!(\"Err {}: {}\", err_code, err_msg));\n ```\n",
@@ -2761,8 +2803,8 @@
   {
     "id": "clone_on_copy",
     "id_span": {
-      "path": "clippy_lints/src/methods/mod.rs",
-      "line": 677
+      "path": "src/methods/mod.rs",
+      "line": 679
     },
     "group": "clippy::complexity",
     "docs": " **What it does:** Checks for usage of `.clone()` on a `Copy` type.\n **Why is this bad?** The only reason `Copy` types implement `Clone` is for\n generics, not for using the `clone` method on a concrete type.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n 42u64.clone();\n ```\n",
@@ -2774,8 +2816,8 @@
   {
     "id": "clone_on_ref_ptr",
     "id_span": {
-      "path": "clippy_lints/src/methods/mod.rs",
-      "line": 702
+      "path": "src/methods/mod.rs",
+      "line": 704
     },
     "group": "clippy::restriction",
     "docs": " **What it does:** Checks for usage of `.clone()` on a ref-counted pointer, (`Rc`, `Arc`, `rc::Weak`, or `sync::Weak`), and suggests calling Clone via unified\n function syntax instead (e.g., `Rc::clone(foo)`).\n\n **Why is this bad?** Calling '.clone()' on an Rc, Arc, or Weak\n can obscure the fact that only the pointer is being cloned, not the underlying\n data.\n\n **Example:**\n ```rust\n # use std::rc::Rc;\n let x = Rc::new(1);\n\n // Bad\n x.clone();\n\n // Good\n Rc::clone(&x);\n ```\n",
@@ -2787,8 +2829,8 @@
   {
     "id": "clone_double_ref",
     "id_span": {
-      "path": "clippy_lints/src/methods/mod.rs",
-      "line": 724
+      "path": "src/methods/mod.rs",
+      "line": 726
     },
     "group": "clippy::correctness",
     "docs": " **What it does:** Checks for usage of `.clone()` on an `&&T`.\n **Why is this bad?** Cloning an `&&T` copies the inner `&T`, instead of\n cloning the underlying `T`.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n fn main() {\n     let x = vec![1];\n     let y = &&x;\n     let z = y.clone();\n     println!(\"{:p} {:p}\", *y, z); // prints out the same pointer\n }\n ```\n",
@@ -2800,8 +2842,8 @@
   {
     "id": "inefficient_to_string",
     "id_span": {
-      "path": "clippy_lints/src/methods/mod.rs",
-      "line": 747
+      "path": "src/methods/mod.rs",
+      "line": 749
     },
     "group": "clippy::pedantic",
     "docs": " **What it does:** Checks for usage of `.to_string()` on an `&&T` where `T` implements `ToString` directly (like `&&str` or `&&String`).\n\n **Why is this bad?** This bypasses the specialized implementation of\n `ToString` and instead goes through the more expensive string formatting\n facilities.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n // Generic implementation for `T: Display` is used (slow)\n [\"foo\", \"bar\"].iter().map(|s| s.to_string());\n\n // OK, the specialized impl is used\n [\"foo\", \"bar\"].iter().map(|&s| s.to_string());\n ```\n",
@@ -2813,8 +2855,8 @@
   {
     "id": "new_ret_no_self",
     "id_span": {
-      "path": "clippy_lints/src/methods/mod.rs",
-      "line": 808
+      "path": "src/methods/mod.rs",
+      "line": 810
     },
     "group": "clippy::style",
     "docs": " **What it does:** Checks for `new` not returning a type that contains `Self`.\n **Why is this bad?** As a convention, `new` methods are used to make a new\n instance of a type.\n\n **Known problems:** None.\n\n **Example:**\n In an impl block:\n ```rust\n # struct Foo;\n # struct NotAFoo;\n impl Foo {\n     fn new() -> NotAFoo {\n # NotAFoo\n     }\n }\n ```\n\n ```rust\n # struct Foo;\n struct Bar(Foo);\n impl Foo {\n     // Bad. The type name must contain `Self`\n     fn new() -> Bar {\n # Bar(Foo)\n     }\n }\n ```\n\n ```rust\n # struct Foo;\n # struct FooError;\n impl Foo {\n     // Good. Return type contains `Self`\n     fn new() -> Result<Foo, FooError> {\n # Ok(Foo)\n     }\n }\n ```\n\n Or in a trait definition:\n ```rust\n pub trait Trait {\n     // Bad. The type name must contain `Self`\n     fn new();\n }\n ```\n\n ```rust\n pub trait Trait {\n     // Good. Return type contains `Self`\n     fn new() -> Self;\n }\n ```\n",
@@ -2826,8 +2868,8 @@
   {
     "id": "single_char_pattern",
     "id_span": {
-      "path": "clippy_lints/src/methods/mod.rs",
-      "line": 829
+      "path": "src/methods/mod.rs",
+      "line": 831
     },
     "group": "clippy::perf",
     "docs": " **What it does:** Checks for string methods that receive a single-character `str` as an argument, e.g., `_.split(\"x\")`.\n\n **Why is this bad?** Performing these methods using a `char` is faster than\n using a `str`.\n\n **Known problems:** Does not catch multi-byte unicode characters.\n\n **Example:**\n ```rust,ignore\n // Bad\n _.split(\"x\");\n\n // Good\n _.split('x');\n",
@@ -2839,8 +2881,8 @@
   {
     "id": "iterator_step_by_zero",
     "id_span": {
-      "path": "clippy_lints/src/methods/mod.rs",
-      "line": 848
+      "path": "src/methods/mod.rs",
+      "line": 850
     },
     "group": "clippy::correctness",
     "docs": " **What it does:** Checks for calling `.step_by(0)` on iterators which panics.\n **Why is this bad?** This very much looks like an oversight. Use `panic!()` instead if you\n actually intend to panic.\n\n **Known problems:** None.\n\n **Example:**\n ```rust,should_panic\n for x in (0..100).step_by(0) {\n     //..\n }\n ```\n",
@@ -2852,8 +2894,8 @@
   {
     "id": "iter_nth_zero",
     "id_span": {
-      "path": "clippy_lints/src/methods/mod.rs",
-      "line": 876
+      "path": "src/methods/mod.rs",
+      "line": 878
     },
     "group": "clippy::style",
     "docs": " **What it does:** Checks for the use of `iter.nth(0)`.\n **Why is this bad?** `iter.next()` is equivalent to\n `iter.nth(0)`, as they both consume the next element,\n  but is more readable.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n # use std::collections::HashSet;\n // Bad\n # let mut s = HashSet::new();\n # s.insert(1);\n let x = s.iter().nth(0);\n\n // Good\n # let mut s = HashSet::new();\n # s.insert(1);\n let x = s.iter().next();\n ```\n",
@@ -2865,8 +2907,8 @@
   {
     "id": "iter_nth",
     "id_span": {
-      "path": "clippy_lints/src/methods/mod.rs",
-      "line": 902
+      "path": "src/methods/mod.rs",
+      "line": 904
     },
     "group": "clippy::perf",
     "docs": " **What it does:** Checks for use of `.iter().nth()` (and the related `.iter_mut().nth()`) on standard library types with O(1) element access.\n\n **Why is this bad?** `.get()` and `.get_mut()` are more efficient and more\n readable.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n let some_vec = vec![0, 1, 2, 3];\n let bad_vec = some_vec.iter().nth(3);\n let bad_slice = &some_vec[..].iter().nth(3);\n ```\n The correct use would be:\n ```rust\n let some_vec = vec![0, 1, 2, 3];\n let bad_vec = some_vec.get(3);\n let bad_slice = &some_vec[..].get(3);\n ```\n",
@@ -2878,8 +2920,8 @@
   {
     "id": "iter_skip_next",
     "id_span": {
-      "path": "clippy_lints/src/methods/mod.rs",
-      "line": 926
+      "path": "src/methods/mod.rs",
+      "line": 928
     },
     "group": "clippy::style",
     "docs": " **What it does:** Checks for use of `.skip(x).next()` on iterators.\n **Why is this bad?** `.nth(x)` is cleaner\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n let some_vec = vec![0, 1, 2, 3];\n let bad_vec = some_vec.iter().skip(3).next();\n let bad_slice = &some_vec[..].iter().skip(3).next();\n ```\n The correct use would be:\n ```rust\n let some_vec = vec![0, 1, 2, 3];\n let bad_vec = some_vec.iter().nth(3);\n let bad_slice = &some_vec[..].iter().nth(3);\n ```\n",
@@ -2891,8 +2933,8 @@
   {
     "id": "get_unwrap",
     "id_span": {
-      "path": "clippy_lints/src/methods/mod.rs",
-      "line": 959
+      "path": "src/methods/mod.rs",
+      "line": 961
     },
     "group": "clippy::restriction",
     "docs": " **What it does:** Checks for use of `.get().unwrap()` (or `.get_mut().unwrap`) on a standard library type which implements `Index`\n\n **Why is this bad?** Using the Index trait (`[]`) is more clear and more\n concise.\n\n **Known problems:** Not a replacement for error handling: Using either\n `.unwrap()` or the Index trait (`[]`) carries the risk of causing a `panic`\n if the value being accessed is `None`. If the use of `.get().unwrap()` is a\n temporary placeholder for dealing with the `Option` type, then this does\n not mitigate the need for error handling. If there is a chance that `.get()`\n will be `None` in your program, then it is advisable that the `None` case\n is handled in a future refactor instead of using `.unwrap()` or the Index\n trait.\n\n **Example:**\n ```rust\n let mut some_vec = vec![0, 1, 2, 3];\n let last = some_vec.get(3).unwrap();\n *some_vec.get_mut(0).unwrap() = 1;\n ```\n The correct use would be:\n ```rust\n let mut some_vec = vec![0, 1, 2, 3];\n let last = some_vec[3];\n some_vec[0] = 1;\n ```\n",
@@ -2904,8 +2946,8 @@
   {
     "id": "string_extend_chars",
     "id_span": {
-      "path": "clippy_lints/src/methods/mod.rs",
-      "line": 988
+      "path": "src/methods/mod.rs",
+      "line": 990
     },
     "group": "clippy::style",
     "docs": " **What it does:** Checks for the use of `.extend(s.chars())` where s is a `&str` or `String`.\n\n **Why is this bad?** `.push_str(s)` is clearer\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n let abc = \"abc\";\n let def = String::from(\"def\");\n let mut s = String::new();\n s.extend(abc.chars());\n s.extend(def.chars());\n ```\n The correct use would be:\n ```rust\n let abc = \"abc\";\n let def = String::from(\"def\");\n let mut s = String::new();\n s.push_str(abc);\n s.push_str(&def);\n ```\n",
@@ -2917,8 +2959,8 @@
   {
     "id": "iter_cloned_collect",
     "id_span": {
-      "path": "clippy_lints/src/methods/mod.rs",
-      "line": 1011
+      "path": "src/methods/mod.rs",
+      "line": 1013
     },
     "group": "clippy::style",
     "docs": " **What it does:** Checks for the use of `.cloned().collect()` on slice to create a `Vec`.\n\n **Why is this bad?** `.to_vec()` is clearer\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n let s = [1, 2, 3, 4, 5];\n let s2: Vec<isize> = s[..].iter().cloned().collect();\n ```\n The better use would be:\n ```rust\n let s = [1, 2, 3, 4, 5];\n let s2: Vec<isize> = s.to_vec();\n ```\n",
@@ -2930,8 +2972,8 @@
   {
     "id": "chars_last_cmp",
     "id_span": {
-      "path": "clippy_lints/src/methods/mod.rs",
-      "line": 1035
+      "path": "src/methods/mod.rs",
+      "line": 1037
     },
     "group": "clippy::style",
     "docs": " **What it does:** Checks for usage of `_.chars().last()` or `_.chars().next_back()` on a `str` to check if it ends with a given char.\n\n **Why is this bad?** Readability, this can be written more concisely as\n `_.ends_with(_)`.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # let name = \"_\";\n\n // Bad\n name.chars().last() == Some('_') || name.chars().next_back() == Some('-');\n\n // Good\n name.ends_with('_') || name.ends_with('-');\n ```\n",
@@ -2940,8 +2982,8 @@
   {
     "id": "useless_asref",
     "id_span": {
-      "path": "clippy_lints/src/methods/mod.rs",
-      "line": 1060
+      "path": "src/methods/mod.rs",
+      "line": 1062
     },
     "group": "clippy::complexity",
     "docs": " **What it does:** Checks for usage of `.as_ref()` or `.as_mut()` where the types before and after the call are the same.\n\n **Why is this bad?** The call is unnecessary.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # fn do_stuff(x: &[i32]) {}\n let x: &[i32] = &[1, 2, 3, 4, 5];\n do_stuff(x.as_ref());\n ```\n The correct use would be:\n ```rust\n # fn do_stuff(x: &[i32]) {}\n let x: &[i32] = &[1, 2, 3, 4, 5];\n do_stuff(x);\n ```\n",
@@ -2953,8 +2995,8 @@
   {
     "id": "unnecessary_fold",
     "id_span": {
-      "path": "clippy_lints/src/methods/mod.rs",
-      "line": 1082
+      "path": "src/methods/mod.rs",
+      "line": 1084
     },
     "group": "clippy::style",
     "docs": " **What it does:** Checks for using `fold` when a more succinct alternative exists. Specifically, this checks for `fold`s which could be replaced by `any`, `all`,\n `sum` or `product`.\n\n **Why is this bad?** Readability.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n let _ = (0..3).fold(false, |acc, x| acc || x > 2);\n ```\n This could be written as:\n ```rust\n let _ = (0..3).any(|x| x > 2);\n ```\n",
@@ -2966,8 +3008,8 @@
   {
     "id": "unnecessary_filter_map",
     "id_span": {
-      "path": "clippy_lints/src/methods/mod.rs",
-      "line": 1111
+      "path": "src/methods/mod.rs",
+      "line": 1113
     },
     "group": "clippy::complexity",
     "docs": " **What it does:** Checks for `filter_map` calls which could be replaced by `filter` or `map`. More specifically it checks if the closure provided is only performing one of the\n filter or map operations and suggests the appropriate option.\n\n **Why is this bad?** Complexity. The intent is also clearer if only a single\n operation is being performed.\n\n **Known problems:** None\n\n **Example:**\n ```rust\n let _ = (0..3).filter_map(|x| if x > 2 { Some(x) } else { None });\n\n // As there is no transformation of the argument this could be written as:\n let _ = (0..3).filter(|&x| x > 2);\n ```\n\n ```rust\n let _ = (0..4).filter_map(|x| Some(x + 1));\n\n // As there is no conditional check on the argument this could be written as:\n let _ = (0..4).map(|x| x + 1);\n ```\n",
@@ -2979,8 +3021,8 @@
   {
     "id": "into_iter_on_ref",
     "id_span": {
-      "path": "clippy_lints/src/methods/mod.rs",
-      "line": 1135
+      "path": "src/methods/mod.rs",
+      "line": 1137
     },
     "group": "clippy::style",
     "docs": " **What it does:** Checks for `into_iter` calls on references which should be replaced by `iter` or `iter_mut`.\n\n **Why is this bad?** Readability. Calling `into_iter` on a reference will not move out its\n content into the resulting iterator, which is confusing. It is better just call `iter` or\n `iter_mut` directly.\n\n **Known problems:** None\n\n **Example:**\n\n ```rust\n // Bad\n let _ = (&vec![3, 4, 5]).into_iter();\n\n // Good\n let _ = (&vec![3, 4, 5]).iter();\n ```\n",
@@ -2992,8 +3034,8 @@
   {
     "id": "suspicious_map",
     "id_span": {
-      "path": "clippy_lints/src/methods/mod.rs",
-      "line": 1154
+      "path": "src/methods/mod.rs",
+      "line": 1156
     },
     "group": "clippy::complexity",
     "docs": " **What it does:** Checks for calls to `map` followed by a `count`.\n **Why is this bad?** It looks suspicious. Maybe `map` was confused with `filter`.\n If the `map` call is intentional, this should be rewritten. Or, if you intend to\n drive the iterator to completion, you can just use `for_each` instead.\n\n **Known problems:** None\n\n **Example:**\n\n ```rust\n let _ = (0..3).map(|x| x + 2).count();\n ```\n",
@@ -3005,8 +3047,8 @@
   {
     "id": "uninit_assumed_init",
     "id_span": {
-      "path": "clippy_lints/src/methods/mod.rs",
-      "line": 1186
+      "path": "src/methods/mod.rs",
+      "line": 1188
     },
     "group": "clippy::correctness",
     "docs": " **What it does:** Checks for `MaybeUninit::uninit().assume_init()`.\n **Why is this bad?** For most types, this is undefined behavior.\n\n **Known problems:** For now, we accept empty tuples and tuples / arrays\n of `MaybeUninit`. There may be other types that allow uninitialized\n data, but those are not yet rigorously defined.\n\n **Example:**\n\n ```rust\n // Beware the UB\n use std::mem::MaybeUninit;\n\n let _: usize = unsafe { MaybeUninit::uninit().assume_init() };\n ```\n\n Note that the following is OK:\n\n ```rust\n use std::mem::MaybeUninit;\n\n let _: [MaybeUninit<bool>; 5] = unsafe {\n     MaybeUninit::uninit().assume_init()\n };\n ```\n",
@@ -3018,8 +3060,8 @@
   {
     "id": "manual_saturating_arithmetic",
     "id_span": {
-      "path": "clippy_lints/src/methods/mod.rs",
-      "line": 1213
+      "path": "src/methods/mod.rs",
+      "line": 1215
     },
     "group": "clippy::style",
     "docs": " **What it does:** Checks for `.checked_add/sub(x).unwrap_or(MAX/MIN)`.\n **Why is this bad?** These can be written simply with `saturating_add/sub` methods.\n\n **Example:**\n\n ```rust\n # let y: u32 = 0;\n # let x: u32 = 100;\n let add = x.checked_add(y).unwrap_or(u32::MAX);\n let sub = x.checked_sub(y).unwrap_or(u32::MIN);\n ```\n\n can be written using dedicated methods for saturating addition/subtraction as:\n\n ```rust\n # let y: u32 = 0;\n # let x: u32 = 100;\n let add = x.saturating_add(y);\n let sub = x.saturating_sub(y);\n ```\n",
@@ -3031,8 +3073,8 @@
   {
     "id": "zst_offset",
     "id_span": {
-      "path": "clippy_lints/src/methods/mod.rs",
-      "line": 1230
+      "path": "src/methods/mod.rs",
+      "line": 1232
     },
     "group": "clippy::correctness",
     "docs": " **What it does:** Checks for `offset(_)`, `wrapping_`{`add`, `sub`}, etc. on raw pointers to zero-sized types\n\n **Why is this bad?** This is a no-op, and likely unintended\n\n **Known problems:** None\n\n **Example:**\n ```rust\n unsafe { (&() as *const ()).offset(1) };\n ```\n",
@@ -3044,8 +3086,8 @@
   {
     "id": "filetype_is_file",
     "id_span": {
-      "path": "clippy_lints/src/methods/mod.rs",
-      "line": 1270
+      "path": "src/methods/mod.rs",
+      "line": 1272
     },
     "group": "clippy::restriction",
     "docs": " **What it does:** Checks for `FileType::is_file()`.\n **Why is this bad?** When people testing a file type with `FileType::is_file`\n they are testing whether a path is something they can get bytes from. But\n `is_file` doesn't cover special file types in unix-like systems, and doesn't cover\n symlink in windows. Using `!FileType::is_dir()` is a better way to that intention.\n\n **Example:**\n\n ```rust\n # || {\n let metadata = std::fs::metadata(\"foo.txt\")?;\n let filetype = metadata.file_type();\n\n if filetype.is_file() {\n     // read file\n }\n # Ok::<_, std::io::Error>(())\n # };\n ```\n\n should be written as:\n\n ```rust\n # || {\n let metadata = std::fs::metadata(\"foo.txt\")?;\n let filetype = metadata.file_type();\n\n if !filetype.is_dir() {\n     // read file\n }\n # Ok::<_, std::io::Error>(())\n # };\n ```\n",
@@ -3057,8 +3099,8 @@
   {
     "id": "option_as_ref_deref",
     "id_span": {
-      "path": "clippy_lints/src/methods/mod.rs",
-      "line": 1295
+      "path": "src/methods/mod.rs",
+      "line": 1297
     },
     "group": "clippy::complexity",
     "docs": " **What it does:** Checks for usage of `_.as_ref().map(Deref::deref)` or it's aliases (such as String::as_str).\n **Why is this bad?** Readability, this can be written more concisely as\n `_.as_deref()`.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # let opt = Some(\"\".to_string());\n opt.as_ref().map(String::as_str)\n # ;\n ```\n Can be written as\n ```rust\n # let opt = Some(\"\".to_string());\n opt.as_deref()\n # ;\n ```\n",
@@ -3070,8 +3112,8 @@
   {
     "id": "iter_next_slice",
     "id_span": {
-      "path": "clippy_lints/src/methods/mod.rs",
-      "line": 1321
+      "path": "src/methods/mod.rs",
+      "line": 1323
     },
     "group": "clippy::style",
     "docs": " **What it does:** Checks for usage of `iter().next()` on a Slice or an Array\n **Why is this bad?** These can be shortened into `.get()`\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # let a = [1, 2, 3];\n # let b = vec![1, 2, 3];\n a[2..].iter().next();\n b.iter().next();\n ```\n should be written as:\n ```rust\n # let a = [1, 2, 3];\n # let b = vec![1, 2, 3];\n a.get(2);\n b.get(0);\n ```\n",
@@ -3083,8 +3125,8 @@
   {
     "id": "single_char_add_str",
     "id_span": {
-      "path": "clippy_lints/src/methods/mod.rs",
-      "line": 1346
+      "path": "src/methods/mod.rs",
+      "line": 1348
     },
     "group": "clippy::style",
     "docs": " **What it does:** Warns when using `push_str`/`insert_str` with a single-character string literal where `push`/`insert` with a `char` would work fine.\n\n **Why is this bad?** It's less clear that we are pushing a single character.\n\n **Known problems:** None\n\n **Example:**\n ```rust\n let mut string = String::new();\n string.insert_str(0, \"R\");\n string.push_str(\"R\");\n ```\n Could be written as\n ```rust\n let mut string = String::new();\n string.insert(0, 'R');\n string.push('R');\n ```\n",
@@ -3096,8 +3138,8 @@
   {
     "id": "unnecessary_lazy_evaluations",
     "id_span": {
-      "path": "clippy_lints/src/methods/mod.rs",
-      "line": 1382
+      "path": "src/methods/mod.rs",
+      "line": 1384
     },
     "group": "clippy::style",
     "docs": " **What it does:** As the counterpart to `or_fun_call`, this lint looks for unnecessary lazily evaluated closures on `Option` and `Result`.\n\n This lint suggests changing the following functions, when eager evaluation results in\n simpler code:\n  - `unwrap_or_else` to `unwrap_or`\n  - `and_then` to `and`\n  - `or_else` to `or`\n  - `get_or_insert_with` to `get_or_insert`\n  - `ok_or_else` to `ok_or`\n\n **Why is this bad?** Using eager evaluation is shorter and simpler in some cases.\n\n **Known problems:** It is possible, but not recommended for `Deref` and `Index` to have\n side effects. Eagerly evaluating them can change the semantics of the program.\n\n **Example:**\n\n ```rust\n // example code where clippy issues a warning\n let opt: Option<u32> = None;\n\n opt.unwrap_or_else(|| 42);\n ```\n Use instead:\n ```rust\n let opt: Option<u32> = None;\n\n opt.unwrap_or(42);\n ```\n",
@@ -3109,8 +3151,8 @@
   {
     "id": "map_collect_result_unit",
     "id_span": {
-      "path": "clippy_lints/src/methods/mod.rs",
-      "line": 1403
+      "path": "src/methods/mod.rs",
+      "line": 1405
     },
     "group": "clippy::style",
     "docs": " **What it does:** Checks for usage of `_.map(_).collect::<Result<(), _>()`.\n **Why is this bad?** Using `try_for_each` instead is more readable and idiomatic.\n\n **Known problems:** None\n\n **Example:**\n\n ```rust\n (0..3).map(|t| Err(t)).collect::<Result<(), _>>();\n ```\n Use instead:\n ```rust\n (0..3).try_for_each(|t| Err(t));\n ```\n",
@@ -3122,8 +3164,8 @@
   {
     "id": "from_iter_instead_of_collect",
     "id_span": {
-      "path": "clippy_lints/src/methods/mod.rs",
-      "line": 1436
+      "path": "src/methods/mod.rs",
+      "line": 1438
     },
     "group": "clippy::style",
     "docs": " **What it does:** Checks for `from_iter()` function calls on types that implement the `FromIterator` trait.\n\n **Why is this bad?** It is recommended style to use collect. See\n [FromIterator documentation](https://doc.rust-lang.org/std/iter/trait.FromIterator.html)\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n use std::iter::FromIterator;\n\n let five_fives = std::iter::repeat(5).take(5);\n\n let v = Vec::from_iter(five_fives);\n\n assert_eq!(v, vec![5, 5, 5, 5, 5]);\n ```\n Use instead:\n ```rust\n let five_fives = std::iter::repeat(5).take(5);\n\n let v: Vec<i32> = five_fives.collect();\n\n assert_eq!(v, vec![5, 5, 5, 5, 5]);\n ```\n",
@@ -3135,8 +3177,8 @@
   {
     "id": "inspect_for_each",
     "id_span": {
-      "path": "clippy_lints/src/methods/mod.rs",
-      "line": 1466
+      "path": "src/methods/mod.rs",
+      "line": 1468
     },
     "group": "clippy::complexity",
     "docs": " **What it does:** Checks for usage of `inspect().for_each()`.\n **Why is this bad?** It is the same as performing the computation\n inside `inspect` at the beginning of the closure in `for_each`.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n [1,2,3,4,5].iter()\n .inspect(|&x| println!(\"inspect the number: {}\", x))\n .for_each(|&x| {\n     assert!(x >= 0);\n });\n ```\n Can be written as\n ```rust\n [1,2,3,4,5].iter()\n .for_each(|&x| {\n     println!(\"inspect the number: {}\", x);\n     assert!(x >= 0);\n });\n ```\n",
@@ -3148,8 +3190,8 @@
   {
     "id": "filter_map_identity",
     "id_span": {
-      "path": "clippy_lints/src/methods/mod.rs",
-      "line": 1489
+      "path": "src/methods/mod.rs",
+      "line": 1491
     },
     "group": "clippy::complexity",
     "docs": " **What it does:** Checks for usage of `filter_map(|x| x)`.\n **Why is this bad?** Readability, this can be written more concisely by using `flatten`.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n # let iter = vec![Some(1)].into_iter();\n iter.filter_map(|x| x);\n ```\n Use instead:\n ```rust\n # let iter = vec![Some(1)].into_iter();\n iter.flatten();\n ```\n",
@@ -3161,8 +3203,8 @@
   {
     "id": "bytes_nth",
     "id_span": {
-      "path": "clippy_lints/src/methods/mod.rs",
-      "line": 1511
+      "path": "src/methods/mod.rs",
+      "line": 1513
     },
     "group": "clippy::style",
     "docs": " **What it does:** Checks for the use of `.bytes().nth()`.\n **Why is this bad?** `.as_bytes().get()` is more efficient and more\n readable.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n // Bad\n let _ = \"Hello\".bytes().nth(3);\n\n // Good\n let _ = \"Hello\".as_bytes().get(3);\n ```\n",
@@ -3171,10 +3213,36 @@
       "applicability": "MachineApplicable"
     }
   },
+  {
+    "id": "implicit_clone",
+    "id_span": {
+      "path": "src/methods/mod.rs",
+      "line": 1539
+    },
+    "group": "clippy::pedantic",
+    "docs": " **What it does:** Checks for the usage of `_.to_owned()`, `vec.to_vec()`, or similar when calling `_.clone()` would be clearer.\n **Why is this bad?** These methods do the same thing as `_.clone()` but may be confusing as\n to why we are calling `to_vec` on something that is already a `Vec` or calling `to_owned` on something that is already owned.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n let a = vec![1, 2, 3];\n let b = a.to_vec();\n let c = a.to_owned();\n ```\n Use instead:\n ```rust\n let a = vec![1, 2, 3];\n let b = a.clone();\n let c = a.clone();\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
+  {
+    "id": "iter_count",
+    "id_span": {
+      "path": "src/methods/mod.rs",
+      "line": 1565
+    },
+    "group": "clippy::complexity",
+    "docs": " **What it does:** Checks for the use of `.iter().count()`.\n **Why is this bad?** `.len()` is more efficient and more\n readable.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n // Bad\n let some_vec = vec![0, 1, 2, 3];\n let _ = some_vec.iter().count();\n let _ = &some_vec[..].iter().count();\n\n // Good\n let some_vec = vec![0, 1, 2, 3];\n let _ = some_vec.len();\n let _ = &some_vec[..].len();\n ```\n",
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
+  },
   {
     "id": "min_max",
     "id_span": {
-      "path": "clippy_lints/src/minmax.rs",
+      "path": "src/minmax.rs",
       "line": 28
     },
     "group": "clippy::correctness",
@@ -3187,7 +3255,7 @@
   {
     "id": "toplevel_ref_arg",
     "id_span": {
-      "path": "clippy_lints/src/misc.rs",
+      "path": "src/misc.rs",
       "line": 53
     },
     "group": "clippy::style",
@@ -3200,7 +3268,7 @@
   {
     "id": "cmp_nan",
     "id_span": {
-      "path": "clippy_lints/src/misc.rs",
+      "path": "src/misc.rs",
       "line": 76
     },
     "group": "clippy::correctness",
@@ -3213,7 +3281,7 @@
   {
     "id": "float_cmp",
     "id_span": {
-      "path": "clippy_lints/src/misc.rs",
+      "path": "src/misc.rs",
       "line": 109
     },
     "group": "clippy::correctness",
@@ -3223,7 +3291,7 @@
   {
     "id": "cmp_owned",
     "id_span": {
-      "path": "clippy_lints/src/misc.rs",
+      "path": "src/misc.rs",
       "line": 136
     },
     "group": "clippy::perf",
@@ -3236,7 +3304,7 @@
   {
     "id": "modulo_one",
     "id_span": {
-      "path": "clippy_lints/src/misc.rs",
+      "path": "src/misc.rs",
       "line": 159
     },
     "group": "clippy::correctness",
@@ -3249,7 +3317,7 @@
   {
     "id": "used_underscore_binding",
     "id_span": {
-      "path": "clippy_lints/src/misc.rs",
+      "path": "src/misc.rs",
       "line": 181
     },
     "group": "clippy::pedantic",
@@ -3262,7 +3330,7 @@
   {
     "id": "short_circuit_statement",
     "id_span": {
-      "path": "clippy_lints/src/misc.rs",
+      "path": "src/misc.rs",
       "line": 201
     },
     "group": "clippy::complexity",
@@ -3275,7 +3343,7 @@
   {
     "id": "zero_ptr",
     "id_span": {
-      "path": "clippy_lints/src/misc.rs",
+      "path": "src/misc.rs",
       "line": 223
     },
     "group": "clippy::style",
@@ -3288,7 +3356,7 @@
   {
     "id": "float_cmp_const",
     "id_span": {
-      "path": "clippy_lints/src/misc.rs",
+      "path": "src/misc.rs",
       "line": 254
     },
     "group": "clippy::restriction",
@@ -3298,7 +3366,7 @@
   {
     "id": "unneeded_field_pattern",
     "id_span": {
-      "path": "clippy_lints/src/misc_early.rs",
+      "path": "src/misc_early.rs",
       "line": 44
     },
     "group": "clippy::restriction",
@@ -3311,7 +3379,7 @@
   {
     "id": "duplicate_underscore_argument",
     "id_span": {
-      "path": "clippy_lints/src/misc_early.rs",
+      "path": "src/misc_early.rs",
       "line": 65
     },
     "group": "clippy::style",
@@ -3324,7 +3392,7 @@
   {
     "id": "double_neg",
     "id_span": {
-      "path": "clippy_lints/src/misc_early.rs",
+      "path": "src/misc_early.rs",
       "line": 83
     },
     "group": "clippy::style",
@@ -3337,7 +3405,7 @@
   {
     "id": "mixed_case_hex_literals",
     "id_span": {
-      "path": "clippy_lints/src/misc_early.rs",
+      "path": "src/misc_early.rs",
       "line": 104
     },
     "group": "clippy::style",
@@ -3350,7 +3418,7 @@
   {
     "id": "unseparated_literal_suffix",
     "id_span": {
-      "path": "clippy_lints/src/misc_early.rs",
+      "path": "src/misc_early.rs",
       "line": 125
     },
     "group": "clippy::pedantic",
@@ -3363,7 +3431,7 @@
   {
     "id": "zero_prefixed_literal",
     "id_span": {
-      "path": "clippy_lints/src/misc_early.rs",
+      "path": "src/misc_early.rs",
       "line": 163
     },
     "group": "clippy::complexity",
@@ -3376,7 +3444,7 @@
   {
     "id": "builtin_type_shadow",
     "id_span": {
-      "path": "clippy_lints/src/misc_early.rs",
+      "path": "src/misc_early.rs",
       "line": 184
     },
     "group": "clippy::style",
@@ -3389,7 +3457,7 @@
   {
     "id": "redundant_pattern",
     "id_span": {
-      "path": "clippy_lints/src/misc_early.rs",
+      "path": "src/misc_early.rs",
       "line": 213
     },
     "group": "clippy::style",
@@ -3402,7 +3470,7 @@
   {
     "id": "unneeded_wildcard_pattern",
     "id_span": {
-      "path": "clippy_lints/src/misc_early.rs",
+      "path": "src/misc_early.rs",
       "line": 247
     },
     "group": "clippy::complexity",
@@ -3415,7 +3483,7 @@
   {
     "id": "missing_const_for_fn",
     "id_span": {
-      "path": "clippy_lints/src/missing_const_for_fn.rs",
+      "path": "src/missing_const_for_fn.rs",
       "line": 72
     },
     "group": "clippy::nursery",
@@ -3428,7 +3496,7 @@
   {
     "id": "missing_docs_in_private_items",
     "id_span": {
-      "path": "clippy_lints/src/missing_doc.rs",
+      "path": "src/missing_doc.rs",
       "line": 29
     },
     "group": "clippy::restriction",
@@ -3441,7 +3509,7 @@
   {
     "id": "missing_inline_in_public_items",
     "id_span": {
-      "path": "clippy_lints/src/missing_inline.rs",
+      "path": "src/missing_inline.rs",
       "line": 55
     },
     "group": "clippy::restriction",
@@ -3454,7 +3522,7 @@
   {
     "id": "modulo_arithmetic",
     "id_span": {
-      "path": "clippy_lints/src/modulo_arithmetic.rs",
+      "path": "src/modulo_arithmetic.rs",
       "line": 26
     },
     "group": "clippy::restriction",
@@ -3467,7 +3535,7 @@
   {
     "id": "multiple_crate_versions",
     "id_span": {
-      "path": "clippy_lints/src/multiple_crate_versions.rs",
+      "path": "src/multiple_crate_versions.rs",
       "line": 32
     },
     "group": "clippy::cargo",
@@ -3480,7 +3548,7 @@
   {
     "id": "mutable_key_type",
     "id_span": {
-      "path": "clippy_lints/src/mut_key.rs",
+      "path": "src/mut_key.rs",
       "line": 50
     },
     "group": "clippy::correctness",
@@ -3493,7 +3561,7 @@
   {
     "id": "mut_mut",
     "id_span": {
-      "path": "clippy_lints/src/mut_mut.rs",
+      "path": "src/mut_mut.rs",
       "line": 24
     },
     "group": "clippy::pedantic",
@@ -3506,7 +3574,7 @@
   {
     "id": "mut_mutex_lock",
     "id_span": {
-      "path": "clippy_lints/src/mut_mutex_lock.rs",
+      "path": "src/mut_mutex_lock.rs",
       "line": 40
     },
     "group": "clippy::style",
@@ -3519,7 +3587,7 @@
   {
     "id": "unnecessary_mut_passed",
     "id_span": {
-      "path": "clippy_lints/src/mut_reference.rs",
+      "path": "src/mut_reference.rs",
       "line": 25
     },
     "group": "clippy::style",
@@ -3532,7 +3600,7 @@
   {
     "id": "debug_assert_with_mut_call",
     "id_span": {
-      "path": "clippy_lints/src/mutable_debug_assertion.rs",
+      "path": "src/mutable_debug_assertion.rs",
       "line": 28
     },
     "group": "clippy::nursery",
@@ -3545,7 +3613,7 @@
   {
     "id": "mutex_atomic",
     "id_span": {
-      "path": "clippy_lints/src/mutex_atomic.rs",
+      "path": "src/mutex_atomic.rs",
       "line": 34
     },
     "group": "clippy::perf",
@@ -3558,7 +3626,7 @@
   {
     "id": "mutex_integer",
     "id_span": {
-      "path": "clippy_lints/src/mutex_atomic.rs",
+      "path": "src/mutex_atomic.rs",
       "line": 59
     },
     "group": "clippy::nursery",
@@ -3571,7 +3639,7 @@
   {
     "id": "needless_arbitrary_self_type",
     "id_span": {
-      "path": "clippy_lints/src/needless_arbitrary_self_type.rs",
+      "path": "src/needless_arbitrary_self_type.rs",
       "line": 55
     },
     "group": "clippy::complexity",
@@ -3584,7 +3652,7 @@
   {
     "id": "needless_bool",
     "id_span": {
-      "path": "clippy_lints/src/needless_bool.rs",
+      "path": "src/needless_bool.rs",
       "line": 38
     },
     "group": "clippy::complexity",
@@ -3597,7 +3665,7 @@
   {
     "id": "bool_comparison",
     "id_span": {
-      "path": "clippy_lints/src/needless_bool.rs",
+      "path": "src/needless_bool.rs",
       "line": 62
     },
     "group": "clippy::complexity",
@@ -3610,7 +3678,7 @@
   {
     "id": "needless_borrow",
     "id_span": {
-      "path": "clippy_lints/src/needless_borrow.rs",
+      "path": "src/needless_borrow.rs",
       "line": 32
     },
     "group": "clippy::nursery",
@@ -3623,7 +3691,7 @@
   {
     "id": "needless_borrowed_reference",
     "id_span": {
-      "path": "clippy_lints/src/needless_borrowed_ref.rs",
+      "path": "src/needless_borrowed_ref.rs",
       "line": 48
     },
     "group": "clippy::complexity",
@@ -3636,7 +3704,7 @@
   {
     "id": "needless_continue",
     "id_span": {
-      "path": "clippy_lints/src/needless_continue.rs",
+      "path": "src/needless_continue.rs",
       "line": 114
     },
     "group": "clippy::pedantic",
@@ -3649,7 +3717,7 @@
   {
     "id": "needless_pass_by_value",
     "id_span": {
-      "path": "clippy_lints/src/needless_pass_by_value.rs",
+      "path": "src/needless_pass_by_value.rs",
       "line": 50
     },
     "group": "clippy::pedantic",
@@ -3662,7 +3730,7 @@
   {
     "id": "needless_question_mark",
     "id_span": {
-      "path": "clippy_lints/src/needless_question_mark.rs",
+      "path": "src/needless_question_mark.rs",
       "line": 57
     },
     "group": "clippy::complexity",
@@ -3675,7 +3743,7 @@
   {
     "id": "needless_update",
     "id_span": {
-      "path": "clippy_lints/src/needless_update.rs",
+      "path": "src/needless_update.rs",
       "line": 43
     },
     "group": "clippy::complexity",
@@ -3688,7 +3756,7 @@
   {
     "id": "neg_cmp_op_on_partial_ord",
     "id_span": {
-      "path": "clippy_lints/src/neg_cmp_op_on_partial_ord.rs",
+      "path": "src/neg_cmp_op_on_partial_ord.rs",
       "line": 41
     },
     "group": "clippy::complexity",
@@ -3701,7 +3769,7 @@
   {
     "id": "neg_multiply",
     "id_span": {
-      "path": "clippy_lints/src/neg_multiply.rs",
+      "path": "src/neg_multiply.rs",
       "line": 21
     },
     "group": "clippy::style",
@@ -3714,7 +3782,7 @@
   {
     "id": "new_without_default",
     "id_span": {
-      "path": "clippy_lints/src/new_without_default.rs",
+      "path": "src/new_without_default.rs",
       "line": 48
     },
     "group": "clippy::style",
@@ -3727,7 +3795,7 @@
   {
     "id": "no_effect",
     "id_span": {
-      "path": "clippy_lints/src/no_effect.rs",
+      "path": "src/no_effect.rs",
       "line": 22
     },
     "group": "clippy::complexity",
@@ -3740,7 +3808,7 @@
   {
     "id": "unnecessary_operation",
     "id_span": {
-      "path": "clippy_lints/src/no_effect.rs",
+      "path": "src/no_effect.rs",
       "line": 40
     },
     "group": "clippy::complexity",
@@ -3753,7 +3821,7 @@
   {
     "id": "declare_interior_mutable_const",
     "id_span": {
-      "path": "clippy_lints/src/non_copy_const.rs",
+      "path": "src/non_copy_const.rs",
       "line": 69
     },
     "group": "clippy::style",
@@ -3763,7 +3831,7 @@
   {
     "id": "borrow_interior_mutable_const",
     "id_span": {
-      "path": "clippy_lints/src/non_copy_const.rs",
+      "path": "src/non_copy_const.rs",
       "line": 110
     },
     "group": "clippy::style",
@@ -3773,7 +3841,7 @@
   {
     "id": "similar_names",
     "id_span": {
-      "path": "clippy_lints/src/non_expressive_names.rs",
+      "path": "src/non_expressive_names.rs",
       "line": 27
     },
     "group": "clippy::pedantic",
@@ -3786,7 +3854,7 @@
   {
     "id": "many_single_char_names",
     "id_span": {
-      "path": "clippy_lints/src/non_expressive_names.rs",
+      "path": "src/non_expressive_names.rs",
       "line": 45
     },
     "group": "clippy::style",
@@ -3799,7 +3867,7 @@
   {
     "id": "just_underscores_and_digits",
     "id_span": {
-      "path": "clippy_lints/src/non_expressive_names.rs",
+      "path": "src/non_expressive_names.rs",
       "line": 65
     },
     "group": "clippy::style",
@@ -3812,7 +3880,7 @@
   {
     "id": "nonsensical_open_options",
     "id_span": {
-      "path": "clippy_lints/src/open_options.rs",
+      "path": "src/open_options.rs",
       "line": 23
     },
     "group": "clippy::correctness",
@@ -3825,7 +3893,7 @@
   {
     "id": "option_env_unwrap",
     "id_span": {
-      "path": "clippy_lints/src/option_env_unwrap.rs",
+      "path": "src/option_env_unwrap.rs",
       "line": 28
     },
     "group": "clippy::correctness",
@@ -3838,7 +3906,7 @@
   {
     "id": "option_if_let_else",
     "id_span": {
-      "path": "clippy_lints/src/option_if_let_else.rs",
+      "path": "src/option_if_let_else.rs",
       "line": 59
     },
     "group": "clippy::pedantic",
@@ -3851,7 +3919,7 @@
   {
     "id": "overflow_check_conditional",
     "id_span": {
-      "path": "clippy_lints/src/overflow_check_conditional.rs",
+      "path": "src/overflow_check_conditional.rs",
       "line": 21
     },
     "group": "clippy::complexity",
@@ -3864,7 +3932,7 @@
   {
     "id": "panic_in_result_fn",
     "id_span": {
-      "path": "clippy_lints/src/panic_in_result_fn.rs",
+      "path": "src/panic_in_result_fn.rs",
       "line": 29
     },
     "group": "clippy::restriction",
@@ -3877,7 +3945,7 @@
   {
     "id": "panic",
     "id_span": {
-      "path": "clippy_lints/src/panic_unimplemented.rs",
+      "path": "src/panic_unimplemented.rs",
       "line": 19
     },
     "group": "clippy::restriction",
@@ -3890,7 +3958,7 @@
   {
     "id": "unimplemented",
     "id_span": {
-      "path": "clippy_lints/src/panic_unimplemented.rs",
+      "path": "src/panic_unimplemented.rs",
       "line": 35
     },
     "group": "clippy::restriction",
@@ -3903,7 +3971,7 @@
   {
     "id": "todo",
     "id_span": {
-      "path": "clippy_lints/src/panic_unimplemented.rs",
+      "path": "src/panic_unimplemented.rs",
       "line": 51
     },
     "group": "clippy::restriction",
@@ -3916,7 +3984,7 @@
   {
     "id": "unreachable",
     "id_span": {
-      "path": "clippy_lints/src/panic_unimplemented.rs",
+      "path": "src/panic_unimplemented.rs",
       "line": 67
     },
     "group": "clippy::restriction",
@@ -3929,7 +3997,7 @@
   {
     "id": "partialeq_ne_impl",
     "id_span": {
-      "path": "clippy_lints/src/partialeq_ne_impl.rs",
+      "path": "src/partialeq_ne_impl.rs",
       "line": 27
     },
     "group": "clippy::complexity",
@@ -3942,7 +4010,7 @@
   {
     "id": "trivially_copy_pass_by_ref",
     "id_span": {
-      "path": "clippy_lints/src/pass_by_ref_or_value.rs",
+      "path": "src/pass_by_ref_or_value.rs",
       "line": 52
     },
     "group": "clippy::pedantic",
@@ -3955,7 +4023,7 @@
   {
     "id": "large_types_passed_by_value",
     "id_span": {
-      "path": "clippy_lints/src/pass_by_ref_or_value.rs",
+      "path": "src/pass_by_ref_or_value.rs",
       "line": 84
     },
     "group": "clippy::pedantic",
@@ -3968,7 +4036,7 @@
   {
     "id": "path_buf_push_overwrite",
     "id_span": {
-      "path": "clippy_lints/src/path_buf_push_overwrite.rs",
+      "path": "src/path_buf_push_overwrite.rs",
       "line": 36
     },
     "group": "clippy::nursery",
@@ -3981,7 +4049,7 @@
   {
     "id": "pattern_type_mismatch",
     "id_span": {
-      "path": "clippy_lints/src/pattern_type_mismatch.rs",
+      "path": "src/pattern_type_mismatch.rs",
       "line": 79
     },
     "group": "clippy::restriction",
@@ -3994,7 +4062,7 @@
   {
     "id": "precedence",
     "id_span": {
-      "path": "clippy_lints/src/precedence.rs",
+      "path": "src/precedence.rs",
       "line": 44
     },
     "group": "clippy::complexity",
@@ -4007,7 +4075,7 @@
   {
     "id": "ptr_arg",
     "id_span": {
-      "path": "clippy_lints/src/ptr.rs",
+      "path": "src/ptr.rs",
       "line": 69
     },
     "group": "clippy::style",
@@ -4020,7 +4088,7 @@
   {
     "id": "cmp_null",
     "id_span": {
-      "path": "clippy_lints/src/ptr.rs",
+      "path": "src/ptr.rs",
       "line": 95
     },
     "group": "clippy::style",
@@ -4033,7 +4101,7 @@
   {
     "id": "mut_from_ref",
     "id_span": {
-      "path": "clippy_lints/src/ptr.rs",
+      "path": "src/ptr.rs",
       "line": 117
     },
     "group": "clippy::correctness",
@@ -4046,7 +4114,7 @@
   {
     "id": "ptr_eq",
     "id_span": {
-      "path": "clippy_lints/src/ptr_eq.rs",
+      "path": "src/ptr_eq.rs",
       "line": 32
     },
     "group": "clippy::style",
@@ -4059,7 +4127,7 @@
   {
     "id": "ptr_offset_with_cast",
     "id_span": {
-      "path": "clippy_lints/src/ptr_offset_with_cast.rs",
+      "path": "src/ptr_offset_with_cast.rs",
       "line": 40
     },
     "group": "clippy::complexity",
@@ -4072,7 +4140,7 @@
   {
     "id": "question_mark",
     "id_span": {
-      "path": "clippy_lints/src/question_mark.rs",
+      "path": "src/question_mark.rs",
       "line": 34
     },
     "group": "clippy::style",
@@ -4085,7 +4153,7 @@
   {
     "id": "range_zip_with_len",
     "id_span": {
-      "path": "clippy_lints/src/ranges.rs",
+      "path": "src/ranges.rs",
       "line": 40
     },
     "group": "clippy::complexity",
@@ -4098,7 +4166,7 @@
   {
     "id": "range_plus_one",
     "id_span": {
-      "path": "clippy_lints/src/ranges.rs",
+      "path": "src/ranges.rs",
       "line": 74
     },
     "group": "clippy::pedantic",
@@ -4111,7 +4179,7 @@
   {
     "id": "range_minus_one",
     "id_span": {
-      "path": "clippy_lints/src/ranges.rs",
+      "path": "src/ranges.rs",
       "line": 99
     },
     "group": "clippy::pedantic",
@@ -4124,7 +4192,7 @@
   {
     "id": "reversed_empty_ranges",
     "id_span": {
-      "path": "clippy_lints/src/ranges.rs",
+      "path": "src/ranges.rs",
       "line": 132
     },
     "group": "clippy::correctness",
@@ -4137,7 +4205,7 @@
   {
     "id": "manual_range_contains",
     "id_span": {
-      "path": "clippy_lints/src/ranges.rs",
+      "path": "src/ranges.rs",
       "line": 159
     },
     "group": "clippy::style",
@@ -4150,7 +4218,7 @@
   {
     "id": "redundant_clone",
     "id_span": {
-      "path": "clippy_lints/src/redundant_clone.rs",
+      "path": "src/redundant_clone.rs",
       "line": 63
     },
     "group": "clippy::perf",
@@ -4163,7 +4231,7 @@
   {
     "id": "redundant_closure_call",
     "id_span": {
-      "path": "clippy_lints/src/redundant_closure_call.rs",
+      "path": "src/redundant_closure_call.rs",
       "line": 32
     },
     "group": "clippy::complexity",
@@ -4176,7 +4244,7 @@
   {
     "id": "redundant_else",
     "id_span": {
-      "path": "clippy_lints/src/redundant_else.rs",
+      "path": "src/redundant_else.rs",
       "line": 37
     },
     "group": "clippy::pedantic",
@@ -4189,7 +4257,7 @@
   {
     "id": "redundant_field_names",
     "id_span": {
-      "path": "clippy_lints/src/redundant_field_names.rs",
+      "path": "src/redundant_field_names.rs",
       "line": 34
     },
     "group": "clippy::style",
@@ -4202,7 +4270,7 @@
   {
     "id": "redundant_pub_crate",
     "id_span": {
-      "path": "clippy_lints/src/redundant_pub_crate.rs",
+      "path": "src/redundant_pub_crate.rs",
       "line": 30
     },
     "group": "clippy::nursery",
@@ -4215,7 +4283,7 @@
   {
     "id": "redundant_slicing",
     "id_span": {
-      "path": "clippy_lints/src/redundant_slicing.rs",
+      "path": "src/redundant_slicing.rs",
       "line": 33
     },
     "group": "clippy::complexity",
@@ -4228,7 +4296,7 @@
   {
     "id": "redundant_static_lifetimes",
     "id_span": {
-      "path": "clippy_lints/src/redundant_static_lifetimes.rs",
+      "path": "src/redundant_static_lifetimes.rs",
       "line": 30
     },
     "group": "clippy::style",
@@ -4241,7 +4309,7 @@
   {
     "id": "ref_option_ref",
     "id_span": {
-      "path": "clippy_lints/src/ref_option_ref.rs",
+      "path": "src/ref_option_ref.rs",
       "line": 28
     },
     "group": "clippy::pedantic",
@@ -4254,7 +4322,7 @@
   {
     "id": "deref_addrof",
     "id_span": {
-      "path": "clippy_lints/src/reference.rs",
+      "path": "src/reference.rs",
       "line": 29
     },
     "group": "clippy::complexity",
@@ -4267,7 +4335,7 @@
   {
     "id": "ref_in_deref",
     "id_span": {
-      "path": "clippy_lints/src/reference.rs",
+      "path": "src/reference.rs",
       "line": 120
     },
     "group": "clippy::complexity",
@@ -4280,7 +4348,7 @@
   {
     "id": "invalid_regex",
     "id_span": {
-      "path": "clippy_lints/src/regex.rs",
+      "path": "src/regex.rs",
       "line": 25
     },
     "group": "clippy::correctness",
@@ -4293,7 +4361,7 @@
   {
     "id": "trivial_regex",
     "id_span": {
-      "path": "clippy_lints/src/regex.rs",
+      "path": "src/regex.rs",
       "line": 46
     },
     "group": "clippy::nursery",
@@ -4306,7 +4374,7 @@
   {
     "id": "repeat_once",
     "id_span": {
-      "path": "clippy_lints/src/repeat_once.rs",
+      "path": "src/repeat_once.rs",
       "line": 33
     },
     "group": "clippy::complexity",
@@ -4319,7 +4387,7 @@
   {
     "id": "let_and_return",
     "id_span": {
-      "path": "clippy_lints/src/returns.rs",
+      "path": "src/returns.rs",
       "line": 38
     },
     "group": "clippy::style",
@@ -4332,7 +4400,7 @@
   {
     "id": "needless_return",
     "id_span": {
-      "path": "clippy_lints/src/returns.rs",
+      "path": "src/returns.rs",
       "line": 63
     },
     "group": "clippy::style",
@@ -4345,7 +4413,7 @@
   {
     "id": "self_assignment",
     "id_span": {
-      "path": "clippy_lints/src/self_assignment.rs",
+      "path": "src/self_assignment.rs",
       "line": 29
     },
     "group": "clippy::correctness",
@@ -4358,7 +4426,7 @@
   {
     "id": "semicolon_if_nothing_returned",
     "id_span": {
-      "path": "clippy_lints/src/semicolon_if_nothing_returned.rs",
+      "path": "src/semicolon_if_nothing_returned.rs",
       "line": 30
     },
     "group": "clippy::restriction",
@@ -4371,7 +4439,7 @@
   {
     "id": "serde_api_misuse",
     "id_span": {
-      "path": "clippy_lints/src/serde_api.rs",
+      "path": "src/serde_api.rs",
       "line": 16
     },
     "group": "clippy::correctness",
@@ -4384,7 +4452,7 @@
   {
     "id": "shadow_same",
     "id_span": {
-      "path": "clippy_lints/src/shadow.rs",
+      "path": "src/shadow.rs",
       "line": 34
     },
     "group": "clippy::restriction",
@@ -4397,7 +4465,7 @@
   {
     "id": "shadow_reuse",
     "id_span": {
-      "path": "clippy_lints/src/shadow.rs",
+      "path": "src/shadow.rs",
       "line": 61
     },
     "group": "clippy::restriction",
@@ -4410,7 +4478,7 @@
   {
     "id": "shadow_unrelated",
     "id_span": {
-      "path": "clippy_lints/src/shadow.rs",
+      "path": "src/shadow.rs",
       "line": 93
     },
     "group": "clippy::pedantic",
@@ -4423,7 +4491,7 @@
   {
     "id": "single_component_path_imports",
     "id_span": {
-      "path": "clippy_lints/src/single_component_path_imports.rs",
+      "path": "src/single_component_path_imports.rs",
       "line": 32
     },
     "group": "clippy::style",
@@ -4436,7 +4504,7 @@
   {
     "id": "size_of_in_element_count",
     "id_span": {
-      "path": "clippy_lints/src/size_of_in_element_count.rs",
+      "path": "src/size_of_in_element_count.rs",
       "line": 31
     },
     "group": "clippy::correctness",
@@ -4449,7 +4517,7 @@
   {
     "id": "slow_vector_initialization",
     "id_span": {
-      "path": "clippy_lints/src/slow_vector_initialization.rs",
+      "path": "src/slow_vector_initialization.rs",
       "line": 37
     },
     "group": "clippy::perf",
@@ -4462,7 +4530,7 @@
   {
     "id": "stable_sort_primitive",
     "id_span": {
-      "path": "clippy_lints/src/stable_sort_primitive.rs",
+      "path": "src/stable_sort_primitive.rs",
       "line": 36
     },
     "group": "clippy::perf",
@@ -4475,7 +4543,7 @@
   {
     "id": "string_add_assign",
     "id_span": {
-      "path": "clippy_lints/src/strings.rs",
+      "path": "src/strings.rs",
       "line": 37
     },
     "group": "clippy::pedantic",
@@ -4488,7 +4556,7 @@
   {
     "id": "string_add",
     "id_span": {
-      "path": "clippy_lints/src/strings.rs",
+      "path": "src/strings.rs",
       "line": 65
     },
     "group": "clippy::restriction",
@@ -4501,7 +4569,7 @@
   {
     "id": "string_lit_as_bytes",
     "id_span": {
-      "path": "clippy_lints/src/strings.rs",
+      "path": "src/strings.rs",
       "line": 107
     },
     "group": "clippy::nursery",
@@ -4514,7 +4582,7 @@
   {
     "id": "string_from_utf8_as_bytes",
     "id_span": {
-      "path": "clippy_lints/src/strings.rs",
+      "path": "src/strings.rs",
       "line": 196
     },
     "group": "clippy::complexity",
@@ -4527,7 +4595,7 @@
   {
     "id": "str_to_string",
     "id_span": {
-      "path": "clippy_lints/src/strings.rs",
+      "path": "src/strings.rs",
       "line": 313
     },
     "group": "clippy::restriction",
@@ -4540,7 +4608,7 @@
   {
     "id": "string_to_string",
     "id_span": {
-      "path": "clippy_lints/src/strings.rs",
+      "path": "src/strings.rs",
       "line": 362
     },
     "group": "clippy::restriction",
@@ -4553,7 +4621,7 @@
   {
     "id": "suspicious_operation_groupings",
     "id_span": {
-      "path": "clippy_lints/src/suspicious_operation_groupings.rs",
+      "path": "src/suspicious_operation_groupings.rs",
       "line": 60
     },
     "group": "clippy::style",
@@ -4566,7 +4634,7 @@
   {
     "id": "suspicious_arithmetic_impl",
     "id_span": {
-      "path": "clippy_lints/src/suspicious_trait_impl.rs",
+      "path": "src/suspicious_trait_impl.rs",
       "line": 27
     },
     "group": "clippy::correctness",
@@ -4579,7 +4647,7 @@
   {
     "id": "suspicious_op_assign_impl",
     "id_span": {
-      "path": "clippy_lints/src/suspicious_trait_impl.rs",
+      "path": "src/suspicious_trait_impl.rs",
       "line": 48
     },
     "group": "clippy::correctness",
@@ -4592,7 +4660,7 @@
   {
     "id": "manual_swap",
     "id_span": {
-      "path": "clippy_lints/src/swap.rs",
+      "path": "src/swap.rs",
       "line": 36
     },
     "group": "clippy::complexity",
@@ -4605,7 +4673,7 @@
   {
     "id": "almost_swapped",
     "id_span": {
-      "path": "clippy_lints/src/swap.rs",
+      "path": "src/swap.rs",
       "line": 61
     },
     "group": "clippy::correctness",
@@ -4618,7 +4686,7 @@
   {
     "id": "tabs_in_doc_comments",
     "id_span": {
-      "path": "clippy_lints/src/tabs_in_doc_comments.rs",
+      "path": "src/tabs_in_doc_comments.rs",
       "line": 54
     },
     "group": "clippy::style",
@@ -4631,7 +4699,7 @@
   {
     "id": "temporary_assignment",
     "id_span": {
-      "path": "clippy_lints/src/temporary_assignment.rs",
+      "path": "src/temporary_assignment.rs",
       "line": 19
     },
     "group": "clippy::complexity",
@@ -4644,7 +4712,7 @@
   {
     "id": "to_digit_is_some",
     "id_span": {
-      "path": "clippy_lints/src/to_digit_is_some.rs",
+      "path": "src/to_digit_is_some.rs",
       "line": 27
     },
     "group": "clippy::style",
@@ -4657,7 +4725,7 @@
   {
     "id": "to_string_in_display",
     "id_span": {
-      "path": "clippy_lints/src/to_string_in_display.rs",
+      "path": "src/to_string_in_display.rs",
       "line": 40
     },
     "group": "clippy::correctness",
@@ -4670,7 +4738,7 @@
   {
     "id": "type_repetition_in_bounds",
     "id_span": {
-      "path": "clippy_lints/src/trait_bounds.rs",
+      "path": "src/trait_bounds.rs",
       "line": 28
     },
     "group": "clippy::pedantic",
@@ -4683,7 +4751,7 @@
   {
     "id": "trait_duplication_in_bounds",
     "id_span": {
-      "path": "clippy_lints/src/trait_bounds.rs",
+      "path": "src/trait_bounds.rs",
       "line": 57
     },
     "group": "clippy::pedantic",
@@ -4696,8 +4764,8 @@
   {
     "id": "wrong_transmute",
     "id_span": {
-      "path": "clippy_lints/src/transmute.rs",
-      "line": 29
+      "path": "src/transmute/mod.rs",
+      "line": 34
     },
     "group": "clippy::correctness",
     "docs": " **What it does:** Checks for transmutes that can't ever be correct on any architecture.\n\n **Why is this bad?** It's basically guaranteed to be undefined behaviour.\n\n **Known problems:** When accessing C, users might want to store pointer\n sized objects in `extradata` arguments to save an allocation.\n\n **Example:**\n ```ignore\n let ptr: *const T = core::intrinsics::transmute('x')\n ```\n",
@@ -4709,8 +4777,8 @@
   {
     "id": "useless_transmute",
     "id_span": {
-      "path": "clippy_lints/src/transmute.rs",
-      "line": 48
+      "path": "src/transmute/mod.rs",
+      "line": 53
     },
     "group": "clippy::nursery",
     "docs": " **What it does:** Checks for transmutes to the original type of the object and transmutes that could be a cast.\n\n **Why is this bad?** Readability. The code tricks people into thinking that\n something complex is going on.\n\n **Known problems:** None.\n\n **Example:**\n ```rust,ignore\n core::intrinsics::transmute(t); // where the result type is the same as `t`'s\n ```\n",
@@ -4722,8 +4790,8 @@
   {
     "id": "transmutes_expressible_as_ptr_casts",
     "id_span": {
-      "path": "clippy_lints/src/transmute.rs",
-      "line": 73
+      "path": "src/transmute/mod.rs",
+      "line": 78
     },
     "group": "clippy::complexity",
     "docs": " **What it does:**Checks for transmutes that could be a pointer cast.\n **Why is this bad?** Readability. The code tricks people into thinking that\n something complex is going on.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n # let p: *const [i32] = &[];\n unsafe { std::mem::transmute::<*const [i32], *const [u16]>(p) };\n ```\n Use instead:\n ```rust\n # let p: *const [i32] = &[];\n p as *const [u16];\n ```\n",
@@ -4735,8 +4803,8 @@
   {
     "id": "crosspointer_transmute",
     "id_span": {
-      "path": "clippy_lints/src/transmute.rs",
-      "line": 91
+      "path": "src/transmute/mod.rs",
+      "line": 96
     },
     "group": "clippy::complexity",
     "docs": " **What it does:** Checks for transmutes between a type `T` and `*T`.\n **Why is this bad?** It's easy to mistakenly transmute between a type and a\n pointer to that type.\n\n **Known problems:** None.\n\n **Example:**\n ```rust,ignore\n core::intrinsics::transmute(t) // where the result type is the same as\n                                // `*t` or `&t`'s\n ```\n",
@@ -4748,8 +4816,8 @@
   {
     "id": "transmute_ptr_to_ref",
     "id_span": {
-      "path": "clippy_lints/src/transmute.rs",
-      "line": 116
+      "path": "src/transmute/mod.rs",
+      "line": 121
     },
     "group": "clippy::complexity",
     "docs": " **What it does:** Checks for transmutes from a pointer to a reference.\n **Why is this bad?** This can always be rewritten with `&` and `*`.\n\n **Known problems:**\n - `mem::transmute` in statics and constants is stable from Rust 1.46.0,\n while dereferencing raw pointer is not stable yet.\n If you need to do this in those places,\n you would have to use `transmute` instead.\n\n **Example:**\n ```rust,ignore\n unsafe {\n     let _: &T = std::mem::transmute(p); // where p: *const T\n }\n\n // can be written:\n let _: &T = &*p;\n ```\n",
@@ -4761,8 +4829,8 @@
   {
     "id": "transmute_int_to_char",
     "id_span": {
-      "path": "clippy_lints/src/transmute.rs",
-      "line": 147
+      "path": "src/transmute/mod.rs",
+      "line": 152
     },
     "group": "clippy::complexity",
     "docs": " **What it does:** Checks for transmutes from an integer to a `char`.\n **Why is this bad?** Not every integer is a Unicode scalar value.\n\n **Known problems:**\n - [`from_u32`] which this lint suggests using is slower than `transmute`\n as it needs to validate the input.\n If you are certain that the input is always a valid Unicode scalar value,\n use [`from_u32_unchecked`] which is as fast as `transmute`\n but has a semantically meaningful name.\n - You might want to handle `None` returned from [`from_u32`] instead of calling `unwrap`.\n\n [`from_u32`]: https://doc.rust-lang.org/std/char/fn.from_u32.html\n [`from_u32_unchecked`]: https://doc.rust-lang.org/std/char/fn.from_u32_unchecked.html\n\n **Example:**\n ```rust\n let x = 1_u32;\n unsafe {\n     let _: char = std::mem::transmute(x); // where x: u32\n }\n\n // should be:\n let _ = std::char::from_u32(x).unwrap();\n ```\n",
@@ -4774,8 +4842,8 @@
   {
     "id": "transmute_bytes_to_str",
     "id_span": {
-      "path": "clippy_lints/src/transmute.rs",
-      "line": 178
+      "path": "src/transmute/mod.rs",
+      "line": 183
     },
     "group": "clippy::complexity",
     "docs": " **What it does:** Checks for transmutes from a `&[u8]` to a `&str`.\n **Why is this bad?** Not every byte slice is a valid UTF-8 string.\n\n **Known problems:**\n - [`from_utf8`] which this lint suggests using is slower than `transmute`\n as it needs to validate the input.\n If you are certain that the input is always a valid UTF-8,\n use [`from_utf8_unchecked`] which is as fast as `transmute`\n but has a semantically meaningful name.\n - You might want to handle errors returned from [`from_utf8`] instead of calling `unwrap`.\n\n [`from_utf8`]: https://doc.rust-lang.org/std/str/fn.from_utf8.html\n [`from_utf8_unchecked`]: https://doc.rust-lang.org/std/str/fn.from_utf8_unchecked.html\n\n **Example:**\n ```rust\n let b: &[u8] = &[1_u8, 2_u8];\n unsafe {\n     let _: &str = std::mem::transmute(b); // where b: &[u8]\n }\n\n // should be:\n let _ = std::str::from_utf8(b).unwrap();\n ```\n",
@@ -4787,8 +4855,8 @@
   {
     "id": "transmute_int_to_bool",
     "id_span": {
-      "path": "clippy_lints/src/transmute.rs",
-      "line": 200
+      "path": "src/transmute/mod.rs",
+      "line": 205
     },
     "group": "clippy::complexity",
     "docs": " **What it does:** Checks for transmutes from an integer to a `bool`.\n **Why is this bad?** This might result in an invalid in-memory representation of a `bool`.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n let x = 1_u8;\n unsafe {\n     let _: bool = std::mem::transmute(x); // where x: u8\n }\n\n // should be:\n let _: bool = x != 0;\n ```\n",
@@ -4800,8 +4868,8 @@
   {
     "id": "transmute_int_to_float",
     "id_span": {
-      "path": "clippy_lints/src/transmute.rs",
-      "line": 222
+      "path": "src/transmute/mod.rs",
+      "line": 227
     },
     "group": "clippy::complexity",
     "docs": " **What it does:** Checks for transmutes from an integer to a float.\n **Why is this bad?** Transmutes are dangerous and error-prone, whereas `from_bits` is intuitive\n and safe.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n unsafe {\n     let _: f32 = std::mem::transmute(1_u32); // where x: u32\n }\n\n // should be:\n let _: f32 = f32::from_bits(1_u32);\n ```\n",
@@ -4813,8 +4881,8 @@
   {
     "id": "transmute_float_to_int",
     "id_span": {
-      "path": "clippy_lints/src/transmute.rs",
-      "line": 244
+      "path": "src/transmute/mod.rs",
+      "line": 249
     },
     "group": "clippy::complexity",
     "docs": " **What it does:** Checks for transmutes from a float to an integer.\n **Why is this bad?** Transmutes are dangerous and error-prone, whereas `to_bits` is intuitive\n and safe.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n unsafe {\n     let _: u32 = std::mem::transmute(1f32);\n }\n\n // should be:\n let _: u32 = 1f32.to_bits();\n ```\n",
@@ -4826,8 +4894,8 @@
   {
     "id": "transmute_ptr_to_ptr",
     "id_span": {
-      "path": "clippy_lints/src/transmute.rs",
-      "line": 271
+      "path": "src/transmute/mod.rs",
+      "line": 276
     },
     "group": "clippy::complexity",
     "docs": " **What it does:** Checks for transmutes from a pointer to a pointer, or from a reference to a reference.\n\n **Why is this bad?** Transmutes are dangerous, and these can instead be\n written as casts.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n let ptr = &1u32 as *const u32;\n unsafe {\n     // pointer-to-pointer transmute\n     let _: *const f32 = std::mem::transmute(ptr);\n     // ref-ref transmute\n     let _: &f32 = std::mem::transmute(&1u32);\n }\n // These can be respectively written:\n let _ = ptr as *const f32;\n let _ = unsafe{ &*(&1u32 as *const u32 as *const f32) };\n ```\n",
@@ -4839,8 +4907,8 @@
   {
     "id": "unsound_collection_transmute",
     "id_span": {
-      "path": "clippy_lints/src/transmute.rs",
-      "line": 299
+      "path": "src/transmute/mod.rs",
+      "line": 304
     },
     "group": "clippy::correctness",
     "docs": " **What it does:** Checks for transmutes between collections whose types have different ABI, size or alignment.\n\n **Why is this bad?** This is undefined behavior.\n\n **Known problems:** Currently, we cannot know whether a type is a\n collection, so we just lint the ones that come with `std`.\n\n **Example:**\n ```rust\n // different size, therefore likely out-of-bounds memory access\n // You absolutely do not want this in your code!\n unsafe {\n     std::mem::transmute::<_, Vec<u32>>(vec![2_u16])\n };\n ```\n\n You must always iterate, map and collect the values:\n\n ```rust\n vec![2_u16].into_iter().map(u32::from).collect::<Vec<_>>();\n ```\n",
@@ -4852,7 +4920,7 @@
   {
     "id": "transmuting_null",
     "id_span": {
-      "path": "clippy_lints/src/transmuting_null.rs",
+      "path": "src/transmuting_null.rs",
       "line": 23
     },
     "group": "clippy::correctness",
@@ -4865,7 +4933,7 @@
   {
     "id": "try_err",
     "id_span": {
-      "path": "clippy_lints/src/try_err.rs",
+      "path": "src/try_err.rs",
       "line": 43
     },
     "group": "clippy::style",
@@ -4878,7 +4946,7 @@
   {
     "id": "box_vec",
     "id_span": {
-      "path": "clippy_lints/src/types.rs",
+      "path": "src/types.rs",
       "line": 66
     },
     "group": "clippy::perf",
@@ -4891,7 +4959,7 @@
   {
     "id": "vec_box",
     "id_span": {
-      "path": "clippy_lints/src/types.rs",
+      "path": "src/types.rs",
       "line": 95
     },
     "group": "clippy::complexity",
@@ -4904,7 +4972,7 @@
   {
     "id": "option_option",
     "id_span": {
-      "path": "clippy_lints/src/types.rs",
+      "path": "src/types.rs",
       "line": 133
     },
     "group": "clippy::pedantic",
@@ -4917,7 +4985,7 @@
   {
     "id": "linkedlist",
     "id_span": {
-      "path": "clippy_lints/src/types.rs",
+      "path": "src/types.rs",
       "line": 169
     },
     "group": "clippy::pedantic",
@@ -4930,7 +4998,7 @@
   {
     "id": "borrowed_box",
     "id_span": {
-      "path": "clippy_lints/src/types.rs",
+      "path": "src/types.rs",
       "line": 193
     },
     "group": "clippy::complexity",
@@ -4943,7 +5011,7 @@
   {
     "id": "redundant_allocation",
     "id_span": {
-      "path": "clippy_lints/src/types.rs",
+      "path": "src/types.rs",
       "line": 217
     },
     "group": "clippy::perf",
@@ -4956,7 +5024,7 @@
   {
     "id": "rc_buffer",
     "id_span": {
-      "path": "clippy_lints/src/types.rs",
+      "path": "src/types.rs",
       "line": 248
     },
     "group": "clippy::restriction",
@@ -4969,7 +5037,7 @@
   {
     "id": "let_unit_value",
     "id_span": {
-      "path": "clippy_lints/src/types.rs",
+      "path": "src/types.rs",
       "line": 768
     },
     "group": "clippy::pedantic",
@@ -4982,7 +5050,7 @@
   {
     "id": "unit_cmp",
     "id_span": {
-      "path": "clippy_lints/src/types.rs",
+      "path": "src/types.rs",
       "line": 849
     },
     "group": "clippy::correctness",
@@ -4995,7 +5063,7 @@
   {
     "id": "unit_arg",
     "id_span": {
-      "path": "clippy_lints/src/types.rs",
+      "path": "src/types.rs",
       "line": 922
     },
     "group": "clippy::complexity",
@@ -5008,7 +5076,7 @@
   {
     "id": "cast_precision_loss",
     "id_span": {
-      "path": "clippy_lints/src/types.rs",
+      "path": "src/types.rs",
       "line": 1158
     },
     "group": "clippy::pedantic",
@@ -5021,7 +5089,7 @@
   {
     "id": "cast_sign_loss",
     "id_span": {
-      "path": "clippy_lints/src/types.rs",
+      "path": "src/types.rs",
       "line": 1179
     },
     "group": "clippy::pedantic",
@@ -5034,7 +5102,7 @@
   {
     "id": "cast_possible_truncation",
     "id_span": {
-      "path": "clippy_lints/src/types.rs",
+      "path": "src/types.rs",
       "line": 1201
     },
     "group": "clippy::pedantic",
@@ -5047,7 +5115,7 @@
   {
     "id": "cast_possible_wrap",
     "id_span": {
-      "path": "clippy_lints/src/types.rs",
+      "path": "src/types.rs",
       "line": 1224
     },
     "group": "clippy::pedantic",
@@ -5060,7 +5128,7 @@
   {
     "id": "cast_lossless",
     "id_span": {
-      "path": "clippy_lints/src/types.rs",
+      "path": "src/types.rs",
       "line": 1256
     },
     "group": "clippy::pedantic",
@@ -5073,7 +5141,7 @@
   {
     "id": "unnecessary_cast",
     "id_span": {
-      "path": "clippy_lints/src/types.rs",
+      "path": "src/types.rs",
       "line": 1281
     },
     "group": "clippy::complexity",
@@ -5086,7 +5154,7 @@
   {
     "id": "cast_ptr_alignment",
     "id_span": {
-      "path": "clippy_lints/src/types.rs",
+      "path": "src/types.rs",
       "line": 1305
     },
     "group": "clippy::pedantic",
@@ -5099,7 +5167,7 @@
   {
     "id": "fn_to_numeric_cast",
     "id_span": {
-      "path": "clippy_lints/src/types.rs",
+      "path": "src/types.rs",
       "line": 1332
     },
     "group": "clippy::style",
@@ -5112,7 +5180,7 @@
   {
     "id": "fn_to_numeric_cast_with_truncation",
     "id_span": {
-      "path": "clippy_lints/src/types.rs",
+      "path": "src/types.rs",
       "line": 1362
     },
     "group": "clippy::style",
@@ -5125,7 +5193,7 @@
   {
     "id": "type_complexity",
     "id_span": {
-      "path": "clippy_lints/src/types.rs",
+      "path": "src/types.rs",
       "line": 1897
     },
     "group": "clippy::complexity",
@@ -5138,7 +5206,7 @@
   {
     "id": "char_lit_as_u8",
     "id_span": {
-      "path": "clippy_lints/src/types.rs",
+      "path": "src/types.rs",
       "line": 2068
     },
     "group": "clippy::complexity",
@@ -5151,7 +5219,7 @@
   {
     "id": "absurd_extreme_comparisons",
     "id_span": {
-      "path": "clippy_lints/src/types.rs",
+      "path": "src/types.rs",
       "line": 2133
     },
     "group": "clippy::correctness",
@@ -5164,7 +5232,7 @@
   {
     "id": "invalid_upcast_comparisons",
     "id_span": {
-      "path": "clippy_lints/src/types.rs",
+      "path": "src/types.rs",
       "line": 2294
     },
     "group": "clippy::pedantic",
@@ -5177,7 +5245,7 @@
   {
     "id": "implicit_hasher",
     "id_span": {
-      "path": "clippy_lints/src/types.rs",
+      "path": "src/types.rs",
       "line": 2515
     },
     "group": "clippy::pedantic",
@@ -5190,7 +5258,7 @@
   {
     "id": "cast_ref_to_mut",
     "id_span": {
-      "path": "clippy_lints/src/types.rs",
+      "path": "src/types.rs",
       "line": 2866
     },
     "group": "clippy::correctness",
@@ -5203,7 +5271,7 @@
   {
     "id": "ptr_as_ptr",
     "id_span": {
-      "path": "clippy_lints/src/types.rs",
+      "path": "src/types.rs",
       "line": 2922
     },
     "group": "clippy::pedantic",
@@ -5216,7 +5284,7 @@
   {
     "id": "undropped_manually_drops",
     "id_span": {
-      "path": "clippy_lints/src/undropped_manually_drops.rs",
+      "path": "src/undropped_manually_drops.rs",
       "line": 27
     },
     "group": "clippy::correctness",
@@ -5229,7 +5297,7 @@
   {
     "id": "invisible_characters",
     "id_span": {
-      "path": "clippy_lints/src/unicode.rs",
+      "path": "src/unicode.rs",
       "line": 20
     },
     "group": "clippy::correctness",
@@ -5242,7 +5310,7 @@
   {
     "id": "non_ascii_literal",
     "id_span": {
-      "path": "clippy_lints/src/unicode.rs",
+      "path": "src/unicode.rs",
       "line": 44
     },
     "group": "clippy::pedantic",
@@ -5255,7 +5323,7 @@
   {
     "id": "unicode_not_nfc",
     "id_span": {
-      "path": "clippy_lints/src/unicode.rs",
+      "path": "src/unicode.rs",
       "line": 61
     },
     "group": "clippy::pedantic",
@@ -5268,7 +5336,7 @@
   {
     "id": "unit_return_expecting_ord",
     "id_span": {
-      "path": "clippy_lints/src/unit_return_expecting_ord.rs",
+      "path": "src/unit_return_expecting_ord.rs",
       "line": 30
     },
     "group": "clippy::correctness",
@@ -5281,7 +5349,7 @@
   {
     "id": "fn_address_comparisons",
     "id_span": {
-      "path": "clippy_lints/src/unnamed_address.rs",
+      "path": "src/unnamed_address.rs",
       "line": 27
     },
     "group": "clippy::correctness",
@@ -5294,7 +5362,7 @@
   {
     "id": "vtable_address_comparisons",
     "id_span": {
-      "path": "clippy_lints/src/unnamed_address.rs",
+      "path": "src/unnamed_address.rs",
       "line": 51
     },
     "group": "clippy::correctness",
@@ -5307,7 +5375,7 @@
   {
     "id": "unnecessary_sort_by",
     "id_span": {
-      "path": "clippy_lints/src/unnecessary_sort_by.rs",
+      "path": "src/unnecessary_sort_by.rs",
       "line": 41
     },
     "group": "clippy::complexity",
@@ -5320,7 +5388,7 @@
   {
     "id": "unnecessary_wraps",
     "id_span": {
-      "path": "clippy_lints/src/unnecessary_wraps.rs",
+      "path": "src/unnecessary_wraps.rs",
       "line": 50
     },
     "group": "clippy::pedantic",
@@ -5333,7 +5401,7 @@
   {
     "id": "unnested_or_patterns",
     "id_span": {
-      "path": "clippy_lints/src/unnested_or_patterns.rs",
+      "path": "src/unnested_or_patterns.rs",
       "line": 47
     },
     "group": "clippy::pedantic",
@@ -5346,7 +5414,7 @@
   {
     "id": "unsafe_removed_from_name",
     "id_span": {
-      "path": "clippy_lints/src/unsafe_removed_from_name.rs",
+      "path": "src/unsafe_removed_from_name.rs",
       "line": 24
     },
     "group": "clippy::style",
@@ -5359,7 +5427,7 @@
   {
     "id": "unused_io_amount",
     "id_span": {
-      "path": "clippy_lints/src/unused_io_amount.rs",
+      "path": "src/unused_io_amount.rs",
       "line": 28
     },
     "group": "clippy::correctness",
@@ -5372,7 +5440,7 @@
   {
     "id": "unused_self",
     "id_span": {
-      "path": "clippy_lints/src/unused_self.rs",
+      "path": "src/unused_self.rs",
       "line": 33
     },
     "group": "clippy::pedantic",
@@ -5385,7 +5453,7 @@
   {
     "id": "unused_unit",
     "id_span": {
-      "path": "clippy_lints/src/unused_unit.rs",
+      "path": "src/unused_unit.rs",
       "line": 27
     },
     "group": "clippy::style",
@@ -5398,7 +5466,7 @@
   {
     "id": "unnecessary_unwrap",
     "id_span": {
-      "path": "clippy_lints/src/unwrap.rs",
+      "path": "src/unwrap.rs",
       "line": 40
     },
     "group": "clippy::complexity",
@@ -5411,7 +5479,7 @@
   {
     "id": "panicking_unwrap",
     "id_span": {
-      "path": "clippy_lints/src/unwrap.rs",
+      "path": "src/unwrap.rs",
       "line": 63
     },
     "group": "clippy::correctness",
@@ -5424,7 +5492,7 @@
   {
     "id": "unwrap_in_result",
     "id_span": {
-      "path": "clippy_lints/src/unwrap_in_result.rs",
+      "path": "src/unwrap_in_result.rs",
       "line": 47
     },
     "group": "clippy::restriction",
@@ -5437,7 +5505,7 @@
   {
     "id": "upper_case_acronyms",
     "id_span": {
-      "path": "clippy_lints/src/upper_case_acronyms.rs",
+      "path": "src/upper_case_acronyms.rs",
       "line": 35
     },
     "group": "clippy::style",
@@ -5450,7 +5518,7 @@
   {
     "id": "use_self",
     "id_span": {
-      "path": "clippy_lints/src/use_self.rs",
+      "path": "src/use_self.rs",
       "line": 53
     },
     "group": "clippy::nursery",
@@ -5463,7 +5531,7 @@
   {
     "id": "useless_conversion",
     "id_span": {
-      "path": "clippy_lints/src/useless_conversion.rs",
+      "path": "src/useless_conversion.rs",
       "line": 32
     },
     "group": "clippy::complexity",
@@ -5476,7 +5544,7 @@
   {
     "id": "useless_vec",
     "id_span": {
-      "path": "clippy_lints/src/vec.rs",
+      "path": "src/vec.rs",
       "line": 36
     },
     "group": "clippy::perf",
@@ -5489,7 +5557,7 @@
   {
     "id": "vec_init_then_push",
     "id_span": {
-      "path": "clippy_lints/src/vec_init_then_push.rs",
+      "path": "src/vec_init_then_push.rs",
       "line": 32
     },
     "group": "clippy::perf",
@@ -5502,7 +5570,7 @@
   {
     "id": "vec_resize_to_zero",
     "id_span": {
-      "path": "clippy_lints/src/vec_resize_to_zero.rs",
+      "path": "src/vec_resize_to_zero.rs",
       "line": 24
     },
     "group": "clippy::correctness",
@@ -5515,7 +5583,7 @@
   {
     "id": "verbose_file_reads",
     "id_span": {
-      "path": "clippy_lints/src/verbose_file_reads.rs",
+      "path": "src/verbose_file_reads.rs",
       "line": 29
     },
     "group": "clippy::restriction",
@@ -5528,7 +5596,7 @@
   {
     "id": "wildcard_dependencies",
     "id_span": {
-      "path": "clippy_lints/src/wildcard_dependencies.rs",
+      "path": "src/wildcard_dependencies.rs",
       "line": 24
     },
     "group": "clippy::cargo",
@@ -5541,27 +5609,33 @@
   {
     "id": "enum_glob_use",
     "id_span": {
-      "path": "clippy_lints/src/wildcard_imports.rs",
+      "path": "src/wildcard_imports.rs",
       "line": 32
     },
     "group": "clippy::pedantic",
     "docs": " **What it does:** Checks for `use Enum::*`.\n **Why is this bad?** It is usually better style to use the prefixed name of\n an enumeration variant, rather than importing variants.\n\n **Known problems:** Old-style enumerations that prefix the variants are\n still around.\n\n **Example:**\n ```rust,ignore\n // Bad\n use std::cmp::Ordering::*;\n foo(Less);\n\n // Good\n use std::cmp::Ordering;\n foo(Ordering::Less)\n ```\n",
-    "applicability": null
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
   },
   {
     "id": "wildcard_imports",
     "id_span": {
-      "path": "clippy_lints/src/wildcard_imports.rs",
+      "path": "src/wildcard_imports.rs",
       "line": 83
     },
     "group": "clippy::pedantic",
     "docs": " **What it does:** Checks for wildcard imports `use _::*`.\n **Why is this bad?** wildcard imports can pollute the namespace. This is especially bad if\n you try to import something through a wildcard, that already has been imported by name from\n a different source:\n\n ```rust,ignore\n use crate1::foo; // Imports a function named foo\n use crate2::*; // Has a function named foo\n\n foo(); // Calls crate1::foo\n ```\n\n This can lead to confusing error messages at best and to unexpected behavior at worst.\n\n **Exceptions:**\n\n Wildcard imports are allowed from modules named `prelude`. Many crates (including the standard library)\n provide modules named \"prelude\" specifically designed for wildcard import.\n\n `use super::*` is allowed in test modules. This is defined as any module with \"test\" in the name.\n\n These exceptions can be disabled using the `warn-on-all-wildcard-imports` configuration flag.\n\n **Known problems:** If macros are imported through the wildcard, this macro is not included\n by the suggestion and has to be added by hand.\n\n Applying the suggestion when explicit imports of the things imported with a glob import\n exist, may result in `unused_imports` warnings.\n\n **Example:**\n\n ```rust,ignore\n // Bad\n use crate1::*;\n\n foo();\n ```\n\n ```rust,ignore\n // Good\n use crate1::foo;\n\n foo();\n ```\n",
-    "applicability": null
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": "MachineApplicable"
+    }
   },
   {
     "id": "println_empty_string",
     "id_span": {
-      "path": "clippy_lints/src/write.rs",
+      "path": "src/write.rs",
       "line": 33
     },
     "group": "clippy::style",
@@ -5574,7 +5648,7 @@
   {
     "id": "print_with_newline",
     "id_span": {
-      "path": "clippy_lints/src/write.rs",
+      "path": "src/write.rs",
       "line": 57
     },
     "group": "clippy::style",
@@ -5587,7 +5661,7 @@
   {
     "id": "print_stdout",
     "id_span": {
-      "path": "clippy_lints/src/write.rs",
+      "path": "src/write.rs",
       "line": 75
     },
     "group": "clippy::restriction",
@@ -5600,7 +5674,7 @@
   {
     "id": "print_stderr",
     "id_span": {
-      "path": "clippy_lints/src/write.rs",
+      "path": "src/write.rs",
       "line": 93
     },
     "group": "clippy::restriction",
@@ -5613,7 +5687,7 @@
   {
     "id": "use_debug",
     "id_span": {
-      "path": "clippy_lints/src/write.rs",
+      "path": "src/write.rs",
       "line": 110
     },
     "group": "clippy::restriction",
@@ -5626,17 +5700,20 @@
   {
     "id": "print_literal",
     "id_span": {
-      "path": "clippy_lints/src/write.rs",
+      "path": "src/write.rs",
       "line": 133
     },
     "group": "clippy::style",
     "docs": " **What it does:** This lint warns about the use of literals as `print!`/`println!` args.\n **Why is this bad?** Using literals as `println!` args is inefficient\n (c.f., https://github.com/matthiaskrgr/rust-str-bench) and unnecessary\n (i.e., just put the literal in the format string)\n\n **Known problems:** Will also warn with macro calls as arguments that expand to literals\n -- e.g., `println!(\"{}\", env!(\"FOO\"))`.\n\n **Example:**\n ```rust\n println!(\"{}\", \"foo\");\n ```\n use the literal without formatting:\n ```rust\n println!(\"foo\");\n ```\n",
-    "applicability": null
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
   },
   {
     "id": "writeln_empty_string",
     "id_span": {
-      "path": "clippy_lints/src/write.rs",
+      "path": "src/write.rs",
       "line": 156
     },
     "group": "clippy::style",
@@ -5649,7 +5726,7 @@
   {
     "id": "write_with_newline",
     "id_span": {
-      "path": "clippy_lints/src/write.rs",
+      "path": "src/write.rs",
       "line": 182
     },
     "group": "clippy::style",
@@ -5662,17 +5739,20 @@
   {
     "id": "write_literal",
     "id_span": {
-      "path": "clippy_lints/src/write.rs",
+      "path": "src/write.rs",
       "line": 207
     },
     "group": "clippy::style",
     "docs": " **What it does:** This lint warns about the use of literals as `write!`/`writeln!` args.\n **Why is this bad?** Using literals as `writeln!` args is inefficient\n (c.f., https://github.com/matthiaskrgr/rust-str-bench) and unnecessary\n (i.e., just put the literal in the format string)\n\n **Known problems:** Will also warn with macro calls as arguments that expand to literals\n -- e.g., `writeln!(buf, \"{}\", env!(\"FOO\"))`.\n\n **Example:**\n ```rust\n # use std::fmt::Write;\n # let mut buf = String::new();\n // Bad\n writeln!(buf, \"{}\", \"foo\");\n\n // Good\n writeln!(buf, \"foo\");\n ```\n",
-    "applicability": null
+    "applicability": {
+      "is_multi_suggestion": false,
+      "applicability": null
+    }
   },
   {
     "id": "zero_divided_by_zero",
     "id_span": {
-      "path": "clippy_lints/src/zero_div_zero.rs",
+      "path": "src/zero_div_zero.rs",
       "line": 23
     },
     "group": "clippy::complexity",
@@ -5685,7 +5765,7 @@
   {
     "id": "zero_sized_map_values",
     "id_span": {
-      "path": "clippy_lints/src/zero_sized_map_values.rs",
+      "path": "src/zero_sized_map_values.rs",
       "line": 37
     },
     "group": "clippy::pedantic",
-- 
cgit 1.4.1-3-g733a5


From 4fc960301bcd4370bfc2238415c7ba3d2d8f9312 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Wed, 10 Mar 2021 23:04:12 +0100
Subject: Metadata collection: Rounding up the implementation

---
 .gitignore                                         |    2 +-
 .../src/utils/internal_lints/metadata_collector.rs |  152 +-
 clippy_utils/src/paths.rs                          |    6 +-
 metadata_collection.json                           | 5778 --------------------
 tests/dogfood.rs                                   |    4 -
 .../track_applicability_value.rs                   |   50 -
 6 files changed, 88 insertions(+), 5904 deletions(-)
 delete mode 100644 metadata_collection.json
 delete mode 100644 tests/ui-internal/metadata-collector/track_applicability_value.rs

(limited to 'clippy_lints/src')

diff --git a/.gitignore b/.gitignore
index 565327a7f83..523bab18828 100644
--- a/.gitignore
+++ b/.gitignore
@@ -29,7 +29,7 @@ out
 
 # gh pages docs
 util/gh-pages/lints.json
-# **/metadata_collection.json
+**/metadata_collection.json
 
 # rustfmt backups
 *.rs.bk
diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index 0425689b0dd..37e90bf8686 100644
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -7,34 +7,21 @@
 //! The module transforms all lint names to ascii lowercase to ensure that we don't have mismatches
 //! during any comparison or mapping. (Please take care of this, it's not fun to spend time on such
 //! a simple mistake)
-//!
-//! The metadata currently contains:
-//! - [x] TODO The lint declaration line for [#1303](https://github.com/rust-lang/rust-clippy/issues/1303)
-//!   and [#6492](https://github.com/rust-lang/rust-clippy/issues/6492)
-//! - [ ] TODO The Applicability for each lint for [#4310](https://github.com/rust-lang/rust-clippy/issues/4310)
-
-// # Applicability
-// - TODO xFrednet 2021-01-17: Find lint emit and collect applicability
-//   - TODO xFrednet 2021-02-28:  4x weird emission forwarding
-//     - See clippy_lints/src/enum_variants.rs@EnumVariantNames::check_name
-//   - TODO xFrednet 2021-02-28:  6x emission forwarding with local that is initializes from
-//     function.
-//     - See clippy_lints/src/methods/mod.rs@lint_binary_expr_with_method_call
-//   - TODO xFrednet 2021-02-28:  2x lint from local from function call
-//     - See clippy_lints/src/misc.rs@check_binary
-//   - TODO xFrednet 2021-02-28:  2x lint from local from method call
-//     - See clippy_lints/src/non_copy_const.rs@lint
+
 // # NITs
 // - TODO xFrednet 2021-02-13: Collect depreciations and maybe renames
 
 use if_chain::if_chain;
 use rustc_data_structures::fx::FxHashMap;
-use rustc_hir::{self as hir, intravisit, intravisit::Visitor, ExprKind, Item, ItemKind, Mutability, QPath, def::DefKind};
+use rustc_hir::{
+    self as hir, def::DefKind, intravisit, intravisit::Visitor, ExprKind, Item, ItemKind, Mutability, QPath,
+};
 use rustc_lint::{CheckLintNameResult, LateContext, LateLintPass, LintContext, LintId};
 use rustc_middle::hir::map::Map;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::{sym, Loc, Span, Symbol};
-use serde::Serialize;
+use serde::{ser::SerializeStruct, Serialize, Serializer};
+use std::collections::BinaryHeap;
 use std::fs::{self, OpenOptions};
 use std::io::prelude::*;
 use std::path::Path;
@@ -47,7 +34,7 @@ use crate::utils::{
 /// This is the output file of the lint collector.
 const OUTPUT_FILE: &str = "../metadata_collection.json";
 /// These lints are excluded from the export.
-const BLACK_LISTED_LINTS: [&str; 2] = ["lint_author", "deep_code_inspection"];
+const BLACK_LISTED_LINTS: [&str; 3] = ["lint_author", "deep_code_inspection", "internal_metadata_collector"];
 /// These groups will be ignored by the lint group matcher. This is useful for collections like
 /// `clippy::all`
 const IGNORED_LINT_GROUPS: [&str; 1] = ["clippy::all"];
@@ -107,7 +94,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     pub INTERNAL_METADATA_COLLECTOR,
-    internal,
+    internal_warn,
     "A busy bee collection metadata about lints"
 }
 
@@ -116,7 +103,10 @@ impl_lint_pass!(MetadataCollector => [INTERNAL_METADATA_COLLECTOR]);
 #[allow(clippy::module_name_repetitions)]
 #[derive(Debug, Clone, Default)]
 pub struct MetadataCollector {
-    lints: Vec<LintMetadata>,
+    /// All collected lints
+    ///
+    /// We use a Heap here to have the lints added in alphabetic order in the export
+    lints: BinaryHeap<LintMetadata>,
     applicability_into: FxHashMap<String, ApplicabilityInfo>,
 }
 
@@ -124,6 +114,8 @@ impl Drop for MetadataCollector {
     /// You might ask: How hacky is this?
     /// My answer:     YES
     fn drop(&mut self) {
+        // The metadata collector gets dropped twice, this makes sure that we only write
+        // when the list is full
         if self.lints.is_empty() {
             return;
         }
@@ -131,7 +123,8 @@ impl Drop for MetadataCollector {
         let mut applicability_info = std::mem::take(&mut self.applicability_into);
 
         // Mapping the final data
-        self.lints
+        let mut lints = std::mem::take(&mut self.lints).into_sorted_vec();
+        lints
             .iter_mut()
             .for_each(|x| x.applicability = applicability_info.remove(&x.id));
 
@@ -140,11 +133,11 @@ impl Drop for MetadataCollector {
             fs::remove_file(OUTPUT_FILE).unwrap();
         }
         let mut file = OpenOptions::new().write(true).create(true).open(OUTPUT_FILE).unwrap();
-        writeln!(file, "{}", serde_json::to_string_pretty(&self.lints).unwrap()).unwrap();
+        writeln!(file, "{}", serde_json::to_string_pretty(&lints).unwrap()).unwrap();
     }
 }
 
-#[derive(Debug, Clone, Serialize)]
+#[derive(Debug, Clone, Serialize, PartialEq, Eq, PartialOrd, Ord)]
 struct LintMetadata {
     id: String,
     id_span: SerializableSpan,
@@ -155,6 +148,24 @@ struct LintMetadata {
     applicability: Option<ApplicabilityInfo>,
 }
 
+// impl Ord for LintMetadata {
+//     fn cmp(&self, other: &Self) -> Ordering {
+//         self.id.cmp(&other.id)
+//     }
+// }
+//
+// impl PartialOrd for LintMetadata {
+//     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+//         Some(self.cmp(other))
+//     }
+// }
+//
+// impl PartialEq for LintMetadata {
+//     fn eq(&self, other: &Self) -> bool {
+//         self.id == other.id
+//     }
+// }
+
 impl LintMetadata {
     fn new(id: String, id_span: SerializableSpan, group: String, docs: String) -> Self {
         Self {
@@ -167,7 +178,7 @@ impl LintMetadata {
     }
 }
 
-#[derive(Debug, Clone, Serialize)]
+#[derive(Debug, Clone, Serialize, PartialEq, Eq, PartialOrd, Ord)]
 struct SerializableSpan {
     path: String,
     line: usize,
@@ -194,25 +205,30 @@ impl SerializableSpan {
     }
 }
 
-#[derive(Debug, Clone, Default, Serialize)]
+#[derive(Debug, Clone, Default, PartialEq, Eq, PartialOrd, Ord)]
 struct ApplicabilityInfo {
     /// Indicates if any of the lint emissions uses multiple spans. This is related to
     /// [rustfix#141](https://github.com/rust-lang/rustfix/issues/141) as such suggestions can
     /// currently not be applied automatically.
-    is_multi_suggestion: bool,
-    applicability: Option<String>,
-}
-
-#[allow(dead_code)]
-fn log_to_file(msg: &str) {
-    let mut file = OpenOptions::new()
-        .write(true)
-        .append(true)
-        .create(true)
-        .open("metadata-lint.log")
-        .unwrap();
-
-    write!(file, "{}", msg).unwrap();
+    is_multi_part_suggestion: bool,
+    applicability: Option<usize>,
+}
+
+impl Serialize for ApplicabilityInfo {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let index = self.applicability.unwrap_or_default();
+
+        let mut s = serializer.serialize_struct("ApplicabilityInfo", 2)?;
+        s.serialize_field("is_multi_part_suggestion", &self.is_multi_part_suggestion)?;
+        s.serialize_field(
+            "applicability",
+            &paths::APPLICABILITY_VALUES[index][APPLICABILITY_NAME_INDEX],
+        )?;
+        s.end()
+    }
 }
 
 impl<'hir> LateLintPass<'hir> for MetadataCollector {
@@ -266,16 +282,20 @@ impl<'hir> LateLintPass<'hir> for MetadataCollector {
     /// ```
     fn check_expr(&mut self, cx: &LateContext<'hir>, expr: &'hir hir::Expr<'_>) {
         if let Some(args) = match_lint_emission(cx, expr) {
-            let mut emission_info = extract_complex_emission_info(cx, args);
+            let mut emission_info = extract_emission_info(cx, args);
             if emission_info.is_empty() {
-                lint_collection_error_span(cx, expr.span, "Look, here ... I have no clue what todo with it");
+                // See:
+                // - src/misc.rs:734:9
+                // - src/methods/mod.rs:3545:13
+                // - src/methods/mod.rs:3496:13
+                // We are basically unable to resolve the lint name it self.
                 return;
             }
 
             for (lint_name, applicability, is_multi_part) in emission_info.drain(..) {
                 let app_info = self.applicability_into.entry(lint_name).or_default();
                 app_info.applicability = applicability;
-                app_info.is_multi_suggestion = is_multi_part;
+                app_info.is_multi_part_suggestion = is_multi_part;
             }
         }
     }
@@ -289,7 +309,7 @@ fn sym_to_string(sym: Symbol) -> String {
 }
 
 fn extract_attr_docs_or_lint(cx: &LateContext<'_>, item: &Item<'_>) -> Option<String> {
-    extract_attr_docs(item).or_else(|| {
+    extract_attr_docs(cx, item).or_else(|| {
         lint_collection_error_item(cx, item, "could not collect the lint documentation");
         None
     })
@@ -305,8 +325,10 @@ fn extract_attr_docs_or_lint(cx: &LateContext<'_>, item: &Item<'_>) -> Option<St
 /// ```
 ///
 /// Would result in `Hello world!\n=^.^=\n`
-fn extract_attr_docs(item: &Item<'_>) -> Option<String> {
-    item.attrs
+fn extract_attr_docs(cx: &LateContext<'_>, item: &Item<'_>) -> Option<String> {
+    cx.tcx
+        .hir()
+        .attrs(item.hir_id())
         .iter()
         .filter_map(|ref x| x.doc_str().map(|sym| sym.as_str().to_string()))
         .reduce(|mut acc, sym| {
@@ -357,15 +379,6 @@ fn lint_collection_error_item(cx: &LateContext<'_>, item: &Item<'_>, message: &s
     );
 }
 
-fn lint_collection_error_span(cx: &LateContext<'_>, span: Span, message: &str) {
-    span_lint(
-        cx,
-        INTERNAL_METADATA_COLLECTOR,
-        span,
-        &format!("Metadata collection error: {}", message),
-    );
-}
-
 // ==================================================================
 // Applicability
 // ==================================================================
@@ -377,11 +390,15 @@ fn match_lint_emission<'hir>(cx: &LateContext<'hir>, expr: &'hir hir::Expr<'_>)
         .find_map(|emission_fn| match_function_call(cx, expr, emission_fn))
 }
 
-fn extract_complex_emission_info<'hir>(
+fn take_higher_applicability(a: Option<usize>, b: Option<usize>) -> Option<usize> {
+    a.map_or(b, |a| a.max(b.unwrap_or_default()).into())
+}
+
+fn extract_emission_info<'hir>(
     cx: &LateContext<'hir>,
     args: &'hir [hir::Expr<'hir>],
-) -> Vec<(String, Option<String>, bool)> {
-    let mut lints= Vec::new();
+) -> Vec<(String, Option<usize>, bool)> {
+    let mut lints = Vec::new();
     let mut applicability = None;
     let mut multi_part = false;
 
@@ -401,7 +418,10 @@ fn extract_complex_emission_info<'hir>(
         }
     }
 
-    lints.drain(..).map(|lint_name| (lint_name, applicability.clone(), multi_part)).collect()
+    lints
+        .drain(..)
+        .map(|lint_name| (lint_name, applicability, multi_part))
+        .collect()
 }
 
 /// Resolves the possible lints that this expression could reference
@@ -412,7 +432,7 @@ fn resolve_lints(cx: &LateContext<'hir>, expr: &'hir hir::Expr<'hir>) -> Vec<Str
 }
 
 /// This function tries to resolve the linked applicability to the given expression.
-fn resolve_applicability(cx: &LateContext<'hir>, expr: &'hir hir::Expr<'hir>) -> Option<String> {
+fn resolve_applicability(cx: &LateContext<'hir>, expr: &'hir hir::Expr<'hir>) -> Option<usize> {
     let mut resolver = ApplicabilityResolver::new(cx);
     resolver.visit_expr(expr);
     resolver.complete()
@@ -457,7 +477,7 @@ impl<'a, 'hir> intravisit::Visitor<'hir> for LintResolver<'a, 'hir> {
         if_chain! {
             if let ExprKind::Path(qpath) = &expr.kind;
             if let QPath::Resolved(_, path) = qpath;
-            
+
             let (expr_ty, _) = walk_ptrs_ty_depth(self.cx.typeck_results().expr_ty(&expr));
             if match_type(self.cx, expr_ty, &paths::LINT);
             then {
@@ -492,15 +512,11 @@ impl<'a, 'hir> ApplicabilityResolver<'a, 'hir> {
     }
 
     fn add_new_index(&mut self, new_index: usize) {
-        self.applicability_index = self
-            .applicability_index
-            .map_or(new_index, |old_index| old_index.min(new_index))
-            .into();
+        self.applicability_index = take_higher_applicability(self.applicability_index, Some(new_index));
     }
 
-    fn complete(self) -> Option<String> {
+    fn complete(self) -> Option<usize> {
         self.applicability_index
-            .map(|index| paths::APPLICABILITY_VALUES[index][APPLICABILITY_NAME_INDEX].to_string())
     }
 }
 
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index 1f19724ad25..7c7bb9b02b1 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -9,10 +9,10 @@ pub const ANY_TRAIT: [&str; 3] = ["core", "any", "Any"];
 pub const APPLICABILITY: [&str; 2] = ["rustc_lint_defs", "Applicability"];
 #[cfg(feature = "metadata-collector-lint")]
 pub const APPLICABILITY_VALUES: [[&str; 3]; 4] = [
-    ["rustc_lint_defs", "Applicability", "MachineApplicable"],
-    ["rustc_lint_defs", "Applicability", "MaybeIncorrect"],
-    ["rustc_lint_defs", "Applicability", "HasPlaceholders"],
     ["rustc_lint_defs", "Applicability", "Unspecified"],
+    ["rustc_lint_defs", "Applicability", "HasPlaceholders"],
+    ["rustc_lint_defs", "Applicability", "MaybeIncorrect"],
+    ["rustc_lint_defs", "Applicability", "MachineApplicable"],
 ];
 #[cfg(feature = "metadata-collector-lint")]
 pub const DIAGNOSTIC_BUILDER: [&str; 3] = ["rustc_errors", "diagnostic_builder", "DiagnosticBuilder"];
diff --git a/metadata_collection.json b/metadata_collection.json
deleted file mode 100644
index f6f72ffa5fa..00000000000
--- a/metadata_collection.json
+++ /dev/null
@@ -1,5778 +0,0 @@
-[
-  {
-    "id": "approx_constant",
-    "id_span": {
-      "path": "src/approx_const.rs",
-      "line": 34
-    },
-    "group": "clippy::correctness",
-    "docs": " **What it does:** Checks for floating point literals that approximate constants which are defined in\n [`std::f32::consts`](https://doc.rust-lang.org/stable/std/f32/consts/#constants)\n or\n [`std::f64::consts`](https://doc.rust-lang.org/stable/std/f64/consts/#constants),\n respectively, suggesting to use the predefined constant.\n\n **Why is this bad?** Usually, the definition in the standard library is more\n precise than what people come up with. If you find that your definition is\n actually more precise, please [file a Rust\n issue](https://github.com/rust-lang/rust/issues).\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n let x = 3.14;\n let y = 1_f64 / x;\n ```\n Use predefined constants instead:\n ```rust\n let x = std::f32::consts::PI;\n let y = std::f64::consts::FRAC_1_PI;\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "integer_arithmetic",
-    "id_span": {
-      "path": "src/arithmetic.rs",
-      "line": 28
-    },
-    "group": "clippy::restriction",
-    "docs": " **What it does:** Checks for integer arithmetic operations which could overflow or panic.\n Specifically, checks for any operators (`+`, `-`, `*`, `<<`, etc) which are capable\n of overflowing according to the [Rust\n Reference](https://doc.rust-lang.org/reference/expressions/operator-expr.html#overflow),\n or which can panic (`/`, `%`). No bounds analysis or sophisticated reasoning is\n attempted.\n\n **Why is this bad?** Integer overflow will trigger a panic in debug builds or will wrap in\n release mode. Division by zero will cause a panic in either mode. In some applications one\n wants explicitly checked, wrapping or saturating arithmetic.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # let a = 0;\n a + 1;\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "float_arithmetic",
-    "id_span": {
-      "path": "src/arithmetic.rs",
-      "line": 46
-    },
-    "group": "clippy::restriction",
-    "docs": " **What it does:** Checks for float arithmetic.\n **Why is this bad?** For some embedded systems or kernel development, it\n can be useful to rule out floating-point numbers.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # let a = 0.0;\n a + 1.0;\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "as_conversions",
-    "id_span": {
-      "path": "src/as_conversions.rs",
-      "line": 42
-    },
-    "group": "clippy::restriction",
-    "docs": " **What it does:** Checks for usage of `as` conversions.\n Note that this lint is specialized in linting *every single* use of `as`\n regardless of whether good alternatives exist or not.\n If you want more precise lints for `as`, please consider using these separate lints:\n `unnecessary_cast`, `cast_lossless/possible_truncation/possible_wrap/precision_loss/sign_loss`,\n `fn_to_numeric_cast(_with_truncation)`, `char_lit_as_u8`, `ref_to_mut` and `ptr_as_ptr`.\n There is a good explanation the reason why this lint should work in this way and how it is useful\n [in this issue](https://github.com/rust-lang/rust-clippy/issues/5122).\n\n **Why is this bad?** `as` conversions will perform many kinds of\n conversions, including silently lossy conversions and dangerous coercions.\n There are cases when it makes sense to use `as`, so the lint is\n Allow by default.\n\n **Known problems:** None.\n\n **Example:**\n ```rust,ignore\n let a: u32;\n ...\n f(a as u16);\n ```\n\n Usually better represents the semantics you expect:\n ```rust,ignore\n f(a.try_into()?);\n ```\n or\n ```rust,ignore\n f(a.try_into().expect(\"Unexpected u16 overflow in f\"));\n ```\n\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "inline_asm_x86_intel_syntax",
-    "id_span": {
-      "path": "src/asm_syntax.rs",
-      "line": 78
-    },
-    "group": "clippy::restriction",
-    "docs": " **What it does:** Checks for usage of Intel x86 assembly syntax.\n **Why is this bad?** The lint has been enabled to indicate a preference\n for AT&T x86 assembly syntax.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust,no_run\n # #![feature(asm)]\n # unsafe { let ptr = \"\".as_ptr();\n asm!(\"lea {}, [{}]\", lateout(reg) _, in(reg) ptr);\n # }\n ```\n Use instead:\n ```rust,no_run\n # #![feature(asm)]\n # unsafe { let ptr = \"\".as_ptr();\n asm!(\"lea ({}), {}\", in(reg) ptr, lateout(reg) _, options(att_syntax));\n # }\n ```\n",
-    "applicability": null
-  },
-  {
-    "id": "inline_asm_x86_att_syntax",
-    "id_span": {
-      "path": "src/asm_syntax.rs",
-      "line": 114
-    },
-    "group": "clippy::restriction",
-    "docs": " **What it does:** Checks for usage of AT&T x86 assembly syntax.\n **Why is this bad?** The lint has been enabled to indicate a preference\n for Intel x86 assembly syntax.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust,no_run\n # #![feature(asm)]\n # unsafe { let ptr = \"\".as_ptr();\n asm!(\"lea ({}), {}\", in(reg) ptr, lateout(reg) _, options(att_syntax));\n # }\n ```\n Use instead:\n ```rust,no_run\n # #![feature(asm)]\n # unsafe { let ptr = \"\".as_ptr();\n asm!(\"lea {}, [{}]\", lateout(reg) _, in(reg) ptr);\n # }\n ```\n",
-    "applicability": null
-  },
-  {
-    "id": "assertions_on_constants",
-    "id_span": {
-      "path": "src/assertions_on_constants.rs",
-      "line": 23
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for `assert!(true)` and `assert!(false)` calls.\n **Why is this bad?** Will be optimized out by the compiler or should probably be replaced by a\n `panic!()` or `unreachable!()`\n\n **Known problems:** None\n\n **Example:**\n ```rust,ignore\n assert!(false)\n assert!(true)\n const B: bool = false;\n assert!(B)\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "assign_op_pattern",
-    "id_span": {
-      "path": "src/assign_ops.rs",
-      "line": 33
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for `a = a op b` or `a = b commutative_op a` patterns.\n\n **Why is this bad?** These can be written as the shorter `a op= b`.\n\n **Known problems:** While forbidden by the spec, `OpAssign` traits may have\n implementations that differ from the regular `Op` impl.\n\n **Example:**\n ```rust\n let mut a = 5;\n let b = 0;\n // ...\n // Bad\n a = a + b;\n\n // Good\n a += b;\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "misrefactored_assign_op",
-    "id_span": {
-      "path": "src/assign_ops.rs",
-      "line": 56
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks for `a op= a op b` or `a op= b op a` patterns.\n **Why is this bad?** Most likely these are bugs where one meant to write `a\n op= b`.\n\n **Known problems:** Clippy cannot know for sure if `a op= a op b` should have\n been `a = a op a op b` or `a = a op b`/`a op= b`. Therefore, it suggests both.\n If `a op= a op b` is really the correct behaviour it should be\n written as `a = a op a op b` as it's less confusing.\n\n **Example:**\n ```rust\n let mut a = 5;\n let b = 2;\n // ...\n a += a + b;\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": true,
-      "applicability": "MaybeIncorrect"
-    }
-  },
-  {
-    "id": "async_yields_async",
-    "id_span": {
-      "path": "src/async_yields_async.rs",
-      "line": 36
-    },
-    "group": "clippy::correctness",
-    "docs": " **What it does:** Checks for async blocks that yield values of types that can themselves be awaited.\n\n **Why is this bad?** An await is likely missing.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n async fn foo() {}\n\n fn bar() {\n   let x = async {\n     foo()\n   };\n }\n ```\n Use instead:\n ```rust\n async fn foo() {}\n\n fn bar() {\n   let x = async {\n     foo().await\n   };\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MaybeIncorrect"
-    }
-  },
-  {
-    "id": "invalid_atomic_ordering",
-    "id_span": {
-      "path": "src/atomic_ordering.rs",
-      "line": 47
-    },
-    "group": "clippy::correctness",
-    "docs": " **What it does:** Checks for usage of invalid atomic ordering in atomic loads/stores/exchanges/updates and\n memory fences.\n\n **Why is this bad?** Using an invalid atomic ordering\n will cause a panic at run-time.\n\n **Known problems:** None.\n\n **Example:**\n ```rust,no_run\n # use std::sync::atomic::{self, AtomicU8, Ordering};\n\n let x = AtomicU8::new(0);\n\n // Bad: `Release` and `AcqRel` cannot be used for `load`.\n let _ = x.load(Ordering::Release);\n let _ = x.load(Ordering::AcqRel);\n\n // Bad: `Acquire` and `AcqRel` cannot be used for `store`.\n x.store(1, Ordering::Acquire);\n x.store(2, Ordering::AcqRel);\n\n // Bad: `Relaxed` cannot be used as a fence's ordering.\n atomic::fence(Ordering::Relaxed);\n atomic::compiler_fence(Ordering::Relaxed);\n\n // Bad: `Release` and `AcqRel` are both always invalid\n // for the failure ordering (the last arg).\n let _ = x.compare_exchange(1, 2, Ordering::SeqCst, Ordering::Release);\n let _ = x.compare_exchange_weak(2, 3, Ordering::AcqRel, Ordering::AcqRel);\n\n // Bad: The failure ordering is not allowed to be\n // stronger than the success order, and `SeqCst` is\n // stronger than `Relaxed`.\n let _ = x.fetch_update(Ordering::Relaxed, Ordering::SeqCst, |val| Some(val + val));\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "inline_always",
-    "id_span": {
-      "path": "src/attrs.rs",
-      "line": 65
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Checks for items annotated with `#[inline(always)]`, unless the annotated function is empty or simply panics.\n\n **Why is this bad?** While there are valid uses of this annotation (and once\n you know when to use it, by all means `allow` this lint), it's a common\n newbie-mistake to pepper one's code with it.\n\n As a rule of thumb, before slapping `#[inline(always)]` on a function,\n measure if that additional function call really affects your runtime profile\n sufficiently to make up for the increase in compile time.\n\n **Known problems:** False positives, big time. This lint is meant to be\n deactivated by everyone doing serious performance work. This means having\n done the measurement.\n\n **Example:**\n ```ignore\n #[inline(always)]\n fn not_quite_hot_code(..) { ... }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "useless_attribute",
-    "id_span": {
-      "path": "src/attrs.rs",
-      "line": 99
-    },
-    "group": "clippy::correctness",
-    "docs": " **What it does:** Checks for `extern crate` and `use` items annotated with lint attributes.\n\n This lint permits `#[allow(unused_imports)]`, `#[allow(deprecated)]`,\n `#[allow(unreachable_pub)]`, `#[allow(clippy::wildcard_imports)]` and\n `#[allow(clippy::enum_glob_use)]` on `use` items and `#[allow(unused_imports)]` on\n `extern crate` items with a `#[macro_use]` attribute.\n\n **Why is this bad?** Lint attributes have no effect on crate imports. Most\n likely a `!` was forgotten.\n\n **Known problems:** None.\n\n **Example:**\n ```ignore\n // Bad\n #[deny(dead_code)]\n extern crate foo;\n #[forbid(dead_code)]\n use foo::bar;\n\n // Ok\n #[allow(unused_imports)]\n use foo::baz;\n #[allow(unused_imports)]\n #[macro_use]\n extern crate baz;\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MaybeIncorrect"
-    }
-  },
-  {
-    "id": "deprecated_semver",
-    "id_span": {
-      "path": "src/attrs.rs",
-      "line": 118
-    },
-    "group": "clippy::correctness",
-    "docs": " **What it does:** Checks for `#[deprecated]` annotations with a `since` field that is not a valid semantic version.\n\n **Why is this bad?** For checking the version of the deprecation, it must be\n a valid semver. Failing that, the contained information is useless.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n #[deprecated(since = \"forever\")]\n fn something_else() { /* ... */ }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "empty_line_after_outer_attr",
-    "id_span": {
-      "path": "src/attrs.rs",
-      "line": 153
-    },
-    "group": "clippy::nursery",
-    "docs": " **What it does:** Checks for empty lines after outer attributes\n **Why is this bad?**\n Most likely the attribute was meant to be an inner attribute using a '!'.\n If it was meant to be an outer attribute, then the following item\n should not be separated by empty lines.\n\n **Known problems:** Can cause false positives.\n\n From the clippy side it's difficult to detect empty lines between an attributes and the\n following item because empty lines and comments are not part of the AST. The parsing\n currently works for basic cases but is not perfect.\n\n **Example:**\n ```rust\n // Good (as inner attribute)\n #![allow(dead_code)]\n\n fn this_is_fine() { }\n\n // Bad\n #[allow(dead_code)]\n\n fn not_quite_good_code() { }\n\n // Good (as outer attribute)\n #[allow(dead_code)]\n fn this_is_fine_too() { }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "blanket_clippy_restriction_lints",
-    "id_span": {
-      "path": "src/attrs.rs",
-      "line": 176
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for `warn`/`deny`/`forbid` attributes targeting the whole clippy::restriction category.\n **Why is this bad?** Restriction lints sometimes are in contrast with other lints or even go against idiomatic rust.\n These lints should only be enabled on a lint-by-lint basis and with careful consideration.\n\n **Known problems:** None.\n\n **Example:**\n Bad:\n ```rust\n #![deny(clippy::restriction)]\n ```\n\n Good:\n ```rust\n #![deny(clippy::as_conversions)]\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "deprecated_cfg_attr",
-    "id_span": {
-      "path": "src/attrs.rs",
-      "line": 205
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks for `#[cfg_attr(rustfmt, rustfmt_skip)]` and suggests to replace it with `#[rustfmt::skip]`.\n\n **Why is this bad?** Since tool_attributes ([rust-lang/rust#44690](https://github.com/rust-lang/rust/issues/44690))\n are stable now, they should be used instead of the old `cfg_attr(rustfmt)` attributes.\n\n **Known problems:** This lint doesn't detect crate level inner attributes, because they get\n processed before the PreExpansionPass lints get executed. See\n [#3123](https://github.com/rust-lang/rust-clippy/pull/3123#issuecomment-422321765)\n\n **Example:**\n\n Bad:\n ```rust\n #[cfg_attr(rustfmt, rustfmt_skip)]\n fn main() { }\n ```\n\n Good:\n ```rust\n #[rustfmt::skip]\n fn main() { }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "mismatched_target_os",
-    "id_span": {
-      "path": "src/attrs.rs",
-      "line": 238
-    },
-    "group": "clippy::correctness",
-    "docs": " **What it does:** Checks for cfg attributes having operating systems used in target family position.\n **Why is this bad?** The configuration option will not be recognised and the related item will not be included\n by the conditional compilation engine.\n\n **Known problems:** None.\n\n **Example:**\n\n Bad:\n ```rust\n #[cfg(linux)]\n fn conditional() { }\n ```\n\n Good:\n ```rust\n #[cfg(target_os = \"linux\")]\n fn conditional() { }\n ```\n\n Or:\n ```rust\n #[cfg(unix)]\n fn conditional() { }\n ```\n Check the [Rust Reference](https://doc.rust-lang.org/reference/conditional-compilation.html#target_os) for more details.\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MaybeIncorrect"
-    }
-  },
-  {
-    "id": "await_holding_lock",
-    "id_span": {
-      "path": "src/await_holding_invalid.rs",
-      "line": 47
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Checks for calls to await while holding a non-async-aware MutexGuard.\n\n **Why is this bad?** The Mutex types found in std::sync and parking_lot\n are not designed to operate in an async context across await points.\n\n There are two potential solutions. One is to use an asynx-aware Mutex\n type. Many asynchronous foundation crates provide such a Mutex type. The\n other solution is to ensure the mutex is unlocked before calling await,\n either by introducing a scope or an explicit call to Drop::drop.\n\n **Known problems:** Will report false positive for explicitly dropped guards ([#6446](https://github.com/rust-lang/rust-clippy/issues/6446)).\n\n **Example:**\n\n ```rust,ignore\n use std::sync::Mutex;\n\n async fn foo(x: &Mutex<u32>) {\n   let guard = x.lock().unwrap();\n   *guard += 1;\n   bar.await;\n }\n ```\n\n Use instead:\n ```rust,ignore\n use std::sync::Mutex;\n\n async fn foo(x: &Mutex<u32>) {\n   {\n     let guard = x.lock().unwrap();\n     *guard += 1;\n   }\n   bar.await;\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "await_holding_refcell_ref",
-    "id_span": {
-      "path": "src/await_holding_invalid.rs",
-      "line": 86
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Checks for calls to await while holding a `RefCell` `Ref` or `RefMut`.\n\n **Why is this bad?** `RefCell` refs only check for exclusive mutable access\n at runtime. Holding onto a `RefCell` ref across an `await` suspension point\n risks panics from a mutable ref shared while other refs are outstanding.\n\n **Known problems:** Will report false positive for explicitly dropped refs ([#6353](https://github.com/rust-lang/rust-clippy/issues/6353)).\n\n **Example:**\n\n ```rust,ignore\n use std::cell::RefCell;\n\n async fn foo(x: &RefCell<u32>) {\n   let mut y = x.borrow_mut();\n   *y += 1;\n   bar.await;\n }\n ```\n\n Use instead:\n ```rust,ignore\n use std::cell::RefCell;\n\n async fn foo(x: &RefCell<u32>) {\n   {\n      let mut y = x.borrow_mut();\n      *y += 1;\n   }\n   bar.await;\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "bad_bit_mask",
-    "id_span": {
-      "path": "src/bit_mask.rs",
-      "line": 44
-    },
-    "group": "clippy::correctness",
-    "docs": " **What it does:** Checks for incompatible bit masks in comparisons.\n The formula for detecting if an expression of the type `_ <bit_op> m\n <cmp_op> c` (where `<bit_op>` is one of {`&`, `|`} and `<cmp_op>` is one of\n {`!=`, `>=`, `>`, `!=`, `>=`, `>`}) can be determined from the following\n table:\n\n |Comparison  |Bit Op|Example     |is always|Formula               |\n |------------|------|------------|---------|----------------------|\n |`==` or `!=`| `&`  |`x & 2 == 3`|`false`  |`c & m != c`          |\n |`<`  or `>=`| `&`  |`x & 2 < 3` |`true`   |`m < c`               |\n |`>`  or `<=`| `&`  |`x & 1 > 1` |`false`  |`m <= c`              |\n |`==` or `!=`| `|`  |`x | 1 == 0`|`false`  |`c | m != c`          |\n |`<`  or `>=`| `|`  |`x | 1 < 1` |`false`  |`m >= c`              |\n |`<=` or `>` | `|`  |`x | 1 > 0` |`true`   |`m > c`               |\n\n **Why is this bad?** If the bits that the comparison cares about are always\n set to zero or one by the bit mask, the comparison is constant `true` or\n `false` (depending on mask, compared value, and operators).\n\n So the code is actively misleading, and the only reason someone would write\n this intentionally is to win an underhanded Rust contest or create a\n test-case for this lint.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # let x = 1;\n if (x & 1 == 2) { }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "ineffective_bit_mask",
-    "id_span": {
-      "path": "src/bit_mask.rs",
-      "line": 73
-    },
-    "group": "clippy::correctness",
-    "docs": " **What it does:** Checks for bit masks in comparisons which can be removed without changing the outcome. The basic structure can be seen in the\n following table:\n\n |Comparison| Bit Op  |Example    |equals |\n |----------|---------|-----------|-------|\n |`>` / `<=`|`|` / `^`|`x | 2 > 3`|`x > 3`|\n |`<` / `>=`|`|` / `^`|`x ^ 1 < 4`|`x < 4`|\n\n **Why is this bad?** Not equally evil as [`bad_bit_mask`](#bad_bit_mask),\n but still a bit misleading, because the bit mask is ineffective.\n\n **Known problems:** False negatives: This lint will only match instances\n where we have figured out the math (which is for a power-of-two compared\n value). This means things like `x | 1 >= 7` (which would be better written\n as `x >= 6`) will not be reported (but bit masks like this are fairly\n uncommon).\n\n **Example:**\n ```rust\n # let x = 1;\n if (x | 1 > 3) {  }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "verbose_bit_mask",
-    "id_span": {
-      "path": "src/bit_mask.rs",
-      "line": 92
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Checks for bit masks that can be replaced by a call to `trailing_zeros`\n\n **Why is this bad?** `x.trailing_zeros() > 4` is much clearer than `x & 15\n == 0`\n\n **Known problems:** llvm generates better code for `x & 15 == 0` on x86\n\n **Example:**\n ```rust\n # let x = 1;\n if x & 0b1111 == 0 { }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MaybeIncorrect"
-    }
-  },
-  {
-    "id": "blacklisted_name",
-    "id_span": {
-      "path": "src/blacklisted_name.rs",
-      "line": 20
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for usage of blacklisted names for variables, such as `foo`.\n\n **Why is this bad?** These names are usually placeholder names and should be\n avoided.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n let foo = 3.14;\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "blocks_in_if_conditions",
-    "id_span": {
-      "path": "src/blocks_in_if_conditions.rs",
-      "line": 42
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for `if` conditions that use blocks containing an expression, statements or conditions that use closures with blocks.\n\n **Why is this bad?** Style, using blocks in the condition makes it hard to read.\n\n **Known problems:** None.\n\n **Examples:**\n ```rust\n // Bad\n if { true } { /* ... */ }\n\n // Good\n if true { /* ... */ }\n ```\n\n // or\n\n ```rust\n # fn somefunc() -> bool { true };\n // Bad\n if { let x = somefunc(); x } { /* ... */ }\n\n // Good\n let res = { let x = somefunc(); x };\n if res { /* ... */ }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "nonminimal_bool",
-    "id_span": {
-      "path": "src/booleans.rs",
-      "line": 31
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks for boolean expressions that can be written more concisely.\n\n **Why is this bad?** Readability of boolean expressions suffers from\n unnecessary duplication.\n\n **Known problems:** Ignores short circuiting behavior of `||` and\n `&&`. Ignores `|`, `&` and `^`.\n\n **Example:**\n ```ignore\n if a && true  // should be: if a\n if !(a == b)  // should be: if a != b\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "logic_bug",
-    "id_span": {
-      "path": "src/booleans.rs",
-      "line": 49
-    },
-    "group": "clippy::correctness",
-    "docs": " **What it does:** Checks for boolean expressions that contain terminals that can be eliminated.\n\n **Why is this bad?** This is most likely a logic bug.\n\n **Known problems:** Ignores short circuiting behavior.\n\n **Example:**\n ```ignore\n if a && b || a { ... }\n ```\n The `b` is unnecessary, the expression is equivalent to `if a`.\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "Unspecified"
-    }
-  },
-  {
-    "id": "naive_bytecount",
-    "id_span": {
-      "path": "src/bytecount.rs",
-      "line": 30
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Checks for naive byte counts\n **Why is this bad?** The [`bytecount`](https://crates.io/crates/bytecount)\n crate has methods to count your bytes faster, especially for large slices.\n\n **Known problems:** If you have predominantly small slices, the\n `bytecount::count(..)` method may actually be slower. However, if you can\n ensure that less than 2³²-1 matches arise, the `naive_count_32(..)` can be\n faster in those cases.\n\n **Example:**\n\n ```rust\n # let vec = vec![1_u8];\n &vec.iter().filter(|x| **x == 0u8).count(); // use bytecount::count instead\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MaybeIncorrect"
-    }
-  },
-  {
-    "id": "cargo_common_metadata",
-    "id_span": {
-      "path": "src/cargo_common_metadata.rs",
-      "line": 49
-    },
-    "group": "clippy::cargo",
-    "docs": " **What it does:** Checks to see if all common metadata is defined in `Cargo.toml`. See: https://rust-lang-nursery.github.io/api-guidelines/documentation.html#cargotoml-includes-all-common-metadata-c-metadata\n\n **Why is this bad?** It will be more difficult for users to discover the\n purpose of the crate, and key information related to it.\n\n **Known problems:** None.\n\n **Example:**\n ```toml\n # This `Cargo.toml` is missing an authors field:\n [package]\n name = \"clippy\"\n version = \"0.0.212\"\n description = \"A bunch of helpful lints to avoid common pitfalls in Rust\"\n repository = \"https://github.com/rust-lang/rust-clippy\"\n readme = \"README.md\"\n license = \"MIT OR Apache-2.0\"\n keywords = [\"clippy\", \"lint\", \"plugin\"]\n categories = [\"development-tools\", \"development-tools::cargo-plugins\"]\n ```\n\n Should include an authors field like:\n\n ```toml\n # This `Cargo.toml` includes all common metadata\n [package]\n name = \"clippy\"\n version = \"0.0.212\"\n authors = [\"Someone <someone@rust-lang.org>\"]\n description = \"A bunch of helpful lints to avoid common pitfalls in Rust\"\n repository = \"https://github.com/rust-lang/rust-clippy\"\n readme = \"README.md\"\n license = \"MIT OR Apache-2.0\"\n keywords = [\"clippy\", \"lint\", \"plugin\"]\n categories = [\"development-tools\", \"development-tools::cargo-plugins\"]\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "case_sensitive_file_extension_comparisons",
-    "id_span": {
-      "path": "src/case_sensitive_file_extension_comparisons.rs",
-      "line": 34
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Checks for calls to `ends_with` with possible file extensions\n and suggests to use a case-insensitive approach instead.\n\n **Why is this bad?**\n `ends_with` is case-sensitive and may not detect files with a valid extension.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n fn is_rust_file(filename: &str) -> bool {\n     filename.ends_with(\".rs\")\n }\n ```\n Use instead:\n ```rust\n fn is_rust_file(filename: &str) -> bool {\n     filename.rsplit('.').next().map(|ext| ext.eq_ignore_ascii_case(\"rs\")) == Some(true)\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "checked_conversions",
-    "id_span": {
-      "path": "src/checked_conversions.rs",
-      "line": 40
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Checks for explicit bounds checking when casting.\n **Why is this bad?** Reduces the readability of statements & is error prone.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # let foo: u32 = 5;\n # let _ =\n foo <= i32::MAX as u32\n # ;\n ```\n\n Could be written:\n\n ```rust\n # use std::convert::TryFrom;\n # let foo = 1;\n # let _ =\n i32::try_from(foo).is_ok()\n # ;\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "cognitive_complexity",
-    "id_span": {
-      "path": "src/cognitive_complexity.rs",
-      "line": 24
-    },
-    "group": "clippy::nursery",
-    "docs": " **What it does:** Checks for methods with high cognitive complexity.\n **Why is this bad?** Methods of high cognitive complexity tend to be hard to\n both read and maintain. Also LLVM will tend to optimize small methods better.\n\n **Known problems:** Sometimes it's hard to find a way to reduce the\n complexity.\n\n **Example:** No. You'll see it when you get the warning.\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "collapsible_if",
-    "id_span": {
-      "path": "src/collapsible_if.rs",
-      "line": 50
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for nested `if` statements which can be collapsed by `&&`-combining their conditions.\n\n **Why is this bad?** Each `if`-statement adds one level of nesting, which\n makes code look more complex than it really is.\n\n **Known problems:** None.\n\n **Example:**\n ```rust,ignore\n if x {\n     if y {\n         …\n     }\n }\n\n ```\n\n Should be written:\n\n ```rust.ignore\n if x && y {\n     …\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "collapsible_else_if",
-    "id_span": {
-      "path": "src/collapsible_if.rs",
-      "line": 85
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for collapsible `else { if ... }` expressions that can be collapsed to `else if ...`.\n\n **Why is this bad?** Each `if`-statement adds one level of nesting, which\n makes code look more complex than it really is.\n\n **Known problems:** None.\n\n **Example:**\n ```rust,ignore\n\n if x {\n     …\n } else {\n     if y {\n         …\n     }\n }\n ```\n\n Should be written:\n\n ```rust.ignore\n if x {\n     …\n } else if y {\n     …\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "collapsible_match",
-    "id_span": {
-      "path": "src/collapsible_match.rs",
-      "line": 44
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Finds nested `match` or `if let` expressions where the patterns may be \"collapsed\" together without adding any branches.\n\n Note that this lint is not intended to find _all_ cases where nested match patterns can be merged, but only\n cases where merging would most likely make the code more readable.\n\n **Why is this bad?** It is unnecessarily verbose and complex.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n fn func(opt: Option<Result<u64, String>>) {\n     let n = match opt {\n         Some(n) => match n {\n             Ok(n) => n,\n             _ => return,\n         }\n         None => return,\n     };\n }\n ```\n Use instead:\n ```rust\n fn func(opt: Option<Result<u64, String>>) {\n     let n = match opt {\n         Some(Ok(n)) => n,\n         _ => return,\n     };\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "comparison_chain",
-    "id_span": {
-      "path": "src/comparison_chain.rs",
-      "line": 49
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks comparison chains written with `if` that can be rewritten with `match` and `cmp`.\n\n **Why is this bad?** `if` is not guaranteed to be exhaustive and conditionals can get\n repetitive\n\n **Known problems:** The match statement may be slower due to the compiler\n not inlining the call to cmp. See issue [#5354](https://github.com/rust-lang/rust-clippy/issues/5354)\n\n **Example:**\n ```rust,ignore\n # fn a() {}\n # fn b() {}\n # fn c() {}\n fn f(x: u8, y: u8) {\n     if x > y {\n         a()\n     } else if x < y {\n         b()\n     } else {\n         c()\n     }\n }\n ```\n\n Could be written:\n\n ```rust,ignore\n use std::cmp::Ordering;\n # fn a() {}\n # fn b() {}\n # fn c() {}\n fn f(x: u8, y: u8) {\n      match x.cmp(&y) {\n          Ordering::Greater => a(),\n          Ordering::Less => b(),\n          Ordering::Equal => c()\n      }\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "ifs_same_cond",
-    "id_span": {
-      "path": "src/copies.rs",
-      "line": 33
-    },
-    "group": "clippy::correctness",
-    "docs": " **What it does:** Checks for consecutive `if`s with the same condition.\n **Why is this bad?** This is probably a copy & paste error.\n\n **Known problems:** Hopefully none.\n\n **Example:**\n ```ignore\n if a == b {\n     …\n } else if a == b {\n     …\n }\n ```\n\n Note that this lint ignores all conditions with a function call as it could\n have side effects:\n\n ```ignore\n if foo() {\n     …\n } else if foo() { // not linted\n     …\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "same_functions_in_if_condition",
-    "id_span": {
-      "path": "src/copies.rs",
-      "line": 80
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Checks for consecutive `if`s with the same function call.\n **Why is this bad?** This is probably a copy & paste error.\n Despite the fact that function can have side effects and `if` works as\n intended, such an approach is implicit and can be considered a \"code smell\".\n\n **Known problems:** Hopefully none.\n\n **Example:**\n ```ignore\n if foo() == bar {\n     …\n } else if foo() == bar {\n     …\n }\n ```\n\n This probably should be:\n ```ignore\n if foo() == bar {\n     …\n } else if foo() == baz {\n     …\n }\n ```\n\n or if the original code was not a typo and called function mutates a state,\n consider move the mutation out of the `if` condition to avoid similarity to\n a copy & paste error:\n\n ```ignore\n let first = foo();\n if first == bar {\n     …\n } else {\n     let second = foo();\n     if second == bar {\n     …\n     }\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "if_same_then_else",
-    "id_span": {
-      "path": "src/copies.rs",
-      "line": 101
-    },
-    "group": "clippy::correctness",
-    "docs": " **What it does:** Checks for `if/else` with the same body as the *then* part and the *else* part.\n\n **Why is this bad?** This is probably a copy & paste error.\n\n **Known problems:** Hopefully none.\n\n **Example:**\n ```ignore\n let foo = if … {\n     42\n } else {\n     42\n };\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "copy_iterator",
-    "id_span": {
-      "path": "src/copy_iterator.rs",
-      "line": 27
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Checks for types that implement `Copy` as well as `Iterator`.\n\n **Why is this bad?** Implicit copies can be confusing when working with\n iterator combinators.\n\n **Known problems:** None.\n\n **Example:**\n ```rust,ignore\n #[derive(Copy, Clone)]\n struct Countdown(u8);\n\n impl Iterator for Countdown {\n     // ...\n }\n\n let a: Vec<_> = my_iterator.take(1).collect();\n let b: Vec<_> = my_iterator.collect();\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "create_dir",
-    "id_span": {
-      "path": "src/create_dir.rs",
-      "line": 24
-    },
-    "group": "clippy::restriction",
-    "docs": " **What it does:** Checks usage of `std::fs::create_dir` and suggest using `std::fs::create_dir_all` instead.\n **Why is this bad?** Sometimes `std::fs::create_dir` is mistakenly chosen over `std::fs::create_dir_all`.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n std::fs::create_dir(\"foo\");\n ```\n Use instead:\n ```rust\n std::fs::create_dir_all(\"foo\");\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MaybeIncorrect"
-    }
-  },
-  {
-    "id": "dbg_macro",
-    "id_span": {
-      "path": "src/dbg_macro.rs",
-      "line": 25
-    },
-    "group": "clippy::restriction",
-    "docs": " **What it does:** Checks for usage of dbg!() macro.\n **Why is this bad?** `dbg!` macro is intended as a debugging tool. It\n should not be in version control.\n\n **Known problems:** None.\n\n **Example:**\n ```rust,ignore\n // Bad\n dbg!(true)\n\n // Good\n true\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "default_trait_access",
-    "id_span": {
-      "path": "src/default.rs",
-      "line": 33
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Checks for literal calls to `Default::default()`.\n **Why is this bad?** It's more clear to the reader to use the name of the type whose default is\n being gotten than the generic `Default`.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n // Bad\n let s: String = Default::default();\n\n // Good\n let s = String::default();\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "Unspecified"
-    }
-  },
-  {
-    "id": "field_reassign_with_default",
-    "id_span": {
-      "path": "src/default.rs",
-      "line": 63
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for immediate reassignment of fields initialized with Default::default().\n\n **Why is this bad?**It's more idiomatic to use the [functional update syntax](https://doc.rust-lang.org/reference/expressions/struct-expr.html#functional-update-syntax).\n\n **Known problems:** Assignments to patterns that are of tuple type are not linted.\n\n **Example:**\n Bad:\n ```\n # #[derive(Default)]\n # struct A { i: i32 }\n let mut a: A = Default::default();\n a.i = 42;\n ```\n Use instead:\n ```\n # #[derive(Default)]\n # struct A { i: i32 }\n let a = A {\n     i: 42,\n     .. Default::default()\n };\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "default_numeric_fallback",
-    "id_span": {
-      "path": "src/default_numeric_fallback.rs",
-      "line": 44
-    },
-    "group": "clippy::restriction",
-    "docs": " **What it does:** Checks for usage of unconstrained numeric literals which may cause default numeric fallback in type inference.\n\n Default numeric fallback means that if numeric types have not yet been bound to concrete\n types at the end of type inference, then integer type is bound to `i32`, and similarly\n floating type is bound to `f64`.\n\n See [RFC0212](https://github.com/rust-lang/rfcs/blob/master/text/0212-restore-int-fallback.md) for more information about the fallback.\n\n **Why is this bad?** For those who are very careful about types, default numeric fallback\n can be a pitfall that cause unexpected runtime behavior.\n\n **Known problems:** This lint can only be allowed at the function level or above.\n\n **Example:**\n ```rust\n let i = 10;\n let f = 1.23;\n ```\n\n Use instead:\n ```rust\n let i = 10i32;\n let f = 1.23f64;\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MaybeIncorrect"
-    }
-  },
-  {
-    "id": "explicit_deref_methods",
-    "id_span": {
-      "path": "src/dereference.rs",
-      "line": 32
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Checks for explicit `deref()` or `deref_mut()` method calls.\n **Why is this bad?** Dereferencing by `&*x` or `&mut *x` is clearer and more concise,\n when not part of a method chain.\n\n **Example:**\n ```rust\n use std::ops::Deref;\n let a: &mut String = &mut String::from(\"foo\");\n let b: &str = a.deref();\n ```\n Could be written as:\n ```rust\n let a: &mut String = &mut String::from(\"foo\");\n let b = &*a;\n ```\n\n This lint excludes\n ```rust,ignore\n let _ = d.unwrap().deref();\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "derive_hash_xor_eq",
-    "id_span": {
-      "path": "src/derive.rs",
-      "line": 42
-    },
-    "group": "clippy::correctness",
-    "docs": " **What it does:** Checks for deriving `Hash` but implementing `PartialEq` explicitly or vice versa.\n\n **Why is this bad?** The implementation of these traits must agree (for\n example for use with `HashMap`) so it’s probably a bad idea to use a\n default-generated `Hash` implementation with an explicitly defined\n `PartialEq`. In particular, the following must hold for any type:\n\n ```text\n k1 == k2 ⇒ hash(k1) == hash(k2)\n ```\n\n **Known problems:** None.\n\n **Example:**\n ```ignore\n #[derive(Hash)]\n struct Foo;\n\n impl PartialEq for Foo {\n     ...\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "derive_ord_xor_partial_ord",
-    "id_span": {
-      "path": "src/derive.rs",
-      "line": 93
-    },
-    "group": "clippy::correctness",
-    "docs": " **What it does:** Checks for deriving `Ord` but implementing `PartialOrd` explicitly or vice versa.\n\n **Why is this bad?** The implementation of these traits must agree (for\n example for use with `sort`) so it’s probably a bad idea to use a\n default-generated `Ord` implementation with an explicitly defined\n `PartialOrd`. In particular, the following must hold for any type\n implementing `Ord`:\n\n ```text\n k1.cmp(&k2) == k1.partial_cmp(&k2).unwrap()\n ```\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust,ignore\n #[derive(Ord, PartialEq, Eq)]\n struct Foo;\n\n impl PartialOrd for Foo {\n     ...\n }\n ```\n Use instead:\n ```rust,ignore\n #[derive(PartialEq, Eq)]\n struct Foo;\n\n impl PartialOrd for Foo {\n     fn partial_cmp(&self, other: &Foo) -> Option<Ordering> {\n        Some(self.cmp(other))\n     }\n }\n\n impl Ord for Foo {\n     ...\n }\n ```\n or, if you don't need a custom ordering:\n ```rust,ignore\n #[derive(Ord, PartialOrd, PartialEq, Eq)]\n struct Foo;\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "expl_impl_clone_on_copy",
-    "id_span": {
-      "path": "src/derive.rs",
-      "line": 119
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Checks for explicit `Clone` implementations for `Copy` types.\n\n **Why is this bad?** To avoid surprising behaviour, these traits should\n agree and the behaviour of `Copy` cannot be overridden. In almost all\n situations a `Copy` type should have a `Clone` implementation that does\n nothing more than copy the object, which is what `#[derive(Copy, Clone)]`\n gets you.\n\n **Known problems:** Bounds of generic types are sometimes wrong: https://github.com/rust-lang/rust/issues/26925\n\n **Example:**\n ```rust,ignore\n #[derive(Copy)]\n struct Foo;\n\n impl Clone for Foo {\n     // ..\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "unsafe_derive_deserialize",
-    "id_span": {
-      "path": "src/derive.rs",
-      "line": 153
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Checks for deriving `serde::Deserialize` on a type that has methods using `unsafe`.\n\n **Why is this bad?** Deriving `serde::Deserialize` will create a constructor\n that may violate invariants hold by another constructor.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust,ignore\n use serde::Deserialize;\n\n #[derive(Deserialize)]\n pub struct Foo {\n     // ..\n }\n\n impl Foo {\n     pub fn new() -> Self {\n         // setup here ..\n     }\n\n     pub unsafe fn parts() -> (&str, &str) {\n         // assumes invariants hold\n     }\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "disallowed_method",
-    "id_span": {
-      "path": "src/disallowed_method.rs",
-      "line": 46
-    },
-    "group": "clippy::nursery",
-    "docs": " **What it does:** Denies the configured methods and functions in clippy.toml\n **Why is this bad?** Some methods are undesirable in certain contexts,\n and it's beneficial to lint for them as needed.\n\n **Known problems:** Currently, you must write each function as a\n fully-qualified path. This lint doesn't support aliases or reexported\n names; be aware that many types in `std` are actually reexports.\n\n For example, if you want to disallow `Duration::as_secs`, your clippy.toml\n configuration would look like\n `disallowed-methods = [\"core::time::Duration::as_secs\"]` and not\n `disallowed-methods = [\"std::time::Duration::as_secs\"]` as you might expect.\n\n **Example:**\n\n An example clippy.toml configuration:\n ```toml\n # clippy.toml\n disallowed-methods = [\"alloc::vec::Vec::leak\", \"std::time::Instant::now\"]\n ```\n\n ```rust,ignore\n // Example code where clippy issues a warning\n let xs = vec![1, 2, 3, 4];\n xs.leak(); // Vec::leak is disallowed in the config.\n\n let _now = Instant::now(); // Instant::now is disallowed in the config.\n ```\n\n Use instead:\n ```rust,ignore\n // Example code which does not raise clippy warning\n let mut xs = Vec::new(); // Vec::new is _not_ disallowed in the config.\n xs.push(123); // Vec::push is _not_ disallowed in the config.\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "doc_markdown",
-    "id_span": {
-      "path": "src/doc.rs",
-      "line": 63
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Checks for the presence of `_`, `::` or camel-case words outside ticks in documentation.\n\n **Why is this bad?** *Rustdoc* supports markdown formatting, `_`, `::` and\n camel-case probably indicates some code which should be included between\n ticks. `_` can also be used for emphasis in markdown, this lint tries to\n consider that.\n\n **Known problems:** Lots of bad docs won’t be fixed, what the lint checks\n for is limited, and there are still false positives.\n\n In addition, when writing documentation comments, including `[]` brackets\n inside a link text would trip the parser. Therfore, documenting link with\n `[`SmallVec<[T; INLINE_CAPACITY]>`]` and then [`SmallVec<[T; INLINE_CAPACITY]>`]: SmallVec\n would fail.\n\n **Examples:**\n ```rust\n /// Do something with the foo_bar parameter. See also\n /// that::other::module::foo.\n // ^ `foo_bar` and `that::other::module::foo` should be ticked.\n fn doit(foo_bar: usize) {}\n ```\n\n ```rust\n // Link text with `[]` brackets should be written as following:\n /// Consume the array and return the inner\n /// [`SmallVec<[T; INLINE_CAPACITY]>`][SmallVec].\n /// [SmallVec]: SmallVec\n fn main() {}\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "missing_safety_doc",
-    "id_span": {
-      "path": "src/doc.rs",
-      "line": 97
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for the doc comments of publicly visible unsafe functions and warns if there is no `# Safety` section.\n\n **Why is this bad?** Unsafe functions should document their safety\n preconditions, so that users can be sure they are using them safely.\n\n **Known problems:** None.\n\n **Examples:**\n ```rust\n# type Universe = ();\n /// This function should really be documented\n pub unsafe fn start_apocalypse(u: &mut Universe) {\n     unimplemented!();\n }\n ```\n\n At least write a line about safety:\n\n ```rust\n# type Universe = ();\n /// # Safety\n ///\n /// This function should not be called before the horsemen are ready.\n pub unsafe fn start_apocalypse(u: &mut Universe) {\n     unimplemented!();\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "missing_errors_doc",
-    "id_span": {
-      "path": "src/doc.rs",
-      "line": 126
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Checks the doc comments of publicly visible functions that return a `Result` type and warns if there is no `# Errors` section.\n\n **Why is this bad?** Documenting the type of errors that can be returned from a\n function can help callers write code to handle the errors appropriately.\n\n **Known problems:** None.\n\n **Examples:**\n\n Since the following function returns a `Result` it has an `# Errors` section in\n its doc comment:\n\n ```rust\n# use std::io;\n /// # Errors\n ///\n /// Will return `Err` if `filename` does not exist or the user does not have\n /// permission to read it.\n pub fn read(filename: String) -> io::Result<String> {\n     unimplemented!();\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "missing_panics_doc",
-    "id_span": {
-      "path": "src/doc.rs",
-      "line": 157
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Checks the doc comments of publicly visible functions that may panic and warns if there is no `# Panics` section.\n\n **Why is this bad?** Documenting the scenarios in which panicking occurs\n can help callers who do not want to panic to avoid those situations.\n\n **Known problems:** None.\n\n **Examples:**\n\n Since the following function may panic it has a `# Panics` section in\n its doc comment:\n\n ```rust\n /// # Panics\n ///\n /// Will panic if y is 0\n pub fn divide_by(x: i32, y: i32) -> i32 {\n     if y == 0 {\n         panic!(\"Cannot divide by 0\")\n     } else {\n         x / y\n     }\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "needless_doctest_main",
-    "id_span": {
-      "path": "src/doc.rs",
-      "line": 185
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for `fn main() { .. }` in doctests\n **Why is this bad?** The test can be shorter (and likely more readable)\n if the `fn main()` is left implicit.\n\n **Known problems:** None.\n\n **Examples:**\n ``````rust\n /// An example of a doctest with a `main()` function\n ///\n /// # Examples\n ///\n /// ```\n /// fn main() {\n ///     // this needs not be in an `fn`\n /// }\n /// ```\n fn needless_main() {\n     unimplemented!();\n }\n ``````\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "double_comparisons",
-    "id_span": {
-      "path": "src/double_comparison.rs",
-      "line": 33
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks for double comparisons that could be simplified to a single expression.\n\n **Why is this bad?** Readability.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # let x = 1;\n # let y = 2;\n if x == y || x < y {}\n ```\n\n Could be written as:\n\n ```rust\n # let x = 1;\n # let y = 2;\n if x <= y {}\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "double_parens",
-    "id_span": {
-      "path": "src/double_parens.rs",
-      "line": 35
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks for unnecessary double parentheses.\n **Why is this bad?** This makes code harder to read and might indicate a\n mistake.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n // Bad\n fn simple_double_parens() -> i32 {\n     ((0))\n }\n\n // Good\n fn simple_no_parens() -> i32 {\n     0\n }\n\n // or\n\n # fn foo(bar: usize) {}\n // Bad\n foo((0));\n\n // Good\n foo(0);\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "drop_ref",
-    "id_span": {
-      "path": "src/drop_forget_ref.rs",
-      "line": 26
-    },
-    "group": "clippy::correctness",
-    "docs": " **What it does:** Checks for calls to `std::mem::drop` with a reference instead of an owned value.\n\n **Why is this bad?** Calling `drop` on a reference will only drop the\n reference itself, which is a no-op. It will not call the `drop` method (from\n the `Drop` trait implementation) on the underlying referenced value, which\n is likely what was intended.\n\n **Known problems:** None.\n\n **Example:**\n ```ignore\n let mut lock_guard = mutex.lock();\n std::mem::drop(&lock_guard) // Should have been drop(lock_guard), mutex\n // still locked\n operation_that_requires_mutex_to_be_unlocked();\n ```\n",
-    "applicability": null
-  },
-  {
-    "id": "forget_ref",
-    "id_span": {
-      "path": "src/drop_forget_ref.rs",
-      "line": 47
-    },
-    "group": "clippy::correctness",
-    "docs": " **What it does:** Checks for calls to `std::mem::forget` with a reference instead of an owned value.\n\n **Why is this bad?** Calling `forget` on a reference will only forget the\n reference itself, which is a no-op. It will not forget the underlying\n referenced\n value, which is likely what was intended.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n let x = Box::new(1);\n std::mem::forget(&x) // Should have been forget(x), x will still be dropped\n ```\n",
-    "applicability": null
-  },
-  {
-    "id": "drop_copy",
-    "id_span": {
-      "path": "src/drop_forget_ref.rs",
-      "line": 68
-    },
-    "group": "clippy::correctness",
-    "docs": " **What it does:** Checks for calls to `std::mem::drop` with a value that derives the Copy trait\n\n **Why is this bad?** Calling `std::mem::drop` [does nothing for types that\n implement Copy](https://doc.rust-lang.org/std/mem/fn.drop.html), since the\n value will be copied and moved into the function on invocation.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n let x: i32 = 42; // i32 implements Copy\n std::mem::drop(x) // A copy of x is passed to the function, leaving the\n                   // original unaffected\n ```\n",
-    "applicability": null
-  },
-  {
-    "id": "forget_copy",
-    "id_span": {
-      "path": "src/drop_forget_ref.rs",
-      "line": 95
-    },
-    "group": "clippy::correctness",
-    "docs": " **What it does:** Checks for calls to `std::mem::forget` with a value that derives the Copy trait\n\n **Why is this bad?** Calling `std::mem::forget` [does nothing for types that\n implement Copy](https://doc.rust-lang.org/std/mem/fn.drop.html) since the\n value will be copied and moved into the function on invocation.\n\n An alternative, but also valid, explanation is that Copy types do not\n implement\n the Drop trait, which means they have no destructors. Without a destructor,\n there\n is nothing for `std::mem::forget` to ignore.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n let x: i32 = 42; // i32 implements Copy\n std::mem::forget(x) // A copy of x is passed to the function, leaving the\n                     // original unaffected\n ```\n",
-    "applicability": null
-  },
-  {
-    "id": "duration_subsec",
-    "id_span": {
-      "path": "src/duration_subsec.rs",
-      "line": 34
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks for calculation of subsecond microseconds or milliseconds from other `Duration` methods.\n\n **Why is this bad?** It's more concise to call `Duration::subsec_micros()` or\n `Duration::subsec_millis()` than to calculate them.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # use std::time::Duration;\n let dur = Duration::new(5, 0);\n\n // Bad\n let _micros = dur.subsec_nanos() / 1_000;\n let _millis = dur.subsec_nanos() / 1_000_000;\n\n // Good\n let _micros = dur.subsec_micros();\n let _millis = dur.subsec_millis();\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "else_if_without_else",
-    "id_span": {
-      "path": "src/else_if_without_else.rs",
-      "line": 44
-    },
-    "group": "clippy::restriction",
-    "docs": " **What it does:** Checks for usage of if expressions with an `else if` branch, but without a final `else` branch.\n\n **Why is this bad?** Some coding guidelines require this (e.g., MISRA-C:2004 Rule 14.10).\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # fn a() {}\n # fn b() {}\n # let x: i32 = 1;\n if x.is_positive() {\n     a();\n } else if x.is_negative() {\n     b();\n }\n ```\n\n Could be written:\n\n ```rust\n # fn a() {}\n # fn b() {}\n # let x: i32 = 1;\n if x.is_positive() {\n     a();\n } else if x.is_negative() {\n     b();\n } else {\n     // We don't care about zero.\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "empty_enum",
-    "id_span": {
-      "path": "src/empty_enum.rs",
-      "line": 38
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Checks for `enum`s with no variants.\n As of this writing, the `never_type` is still a\n nightly-only experimental API. Therefore, this lint is only triggered\n if the `never_type` is enabled.\n\n **Why is this bad?** If you want to introduce a type which\n can't be instantiated, you should use `!` (the primitive type \"never\"),\n or a wrapper around it, because `!` has more extensive\n compiler support (type inference, etc...) and wrappers\n around it are the conventional way to define an uninhabited type.\n For further information visit [never type documentation](https://doc.rust-lang.org/std/primitive.never.html)\n\n\n **Known problems:** None.\n\n **Example:**\n\n Bad:\n ```rust\n enum Test {}\n ```\n\n Good:\n ```rust\n #![feature(never_type)]\n\n struct Test(!);\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "map_entry",
-    "id_span": {
-      "path": "src/entry.rs",
-      "line": 48
-    },
-    "group": "clippy::perf",
-    "docs": " **What it does:** Checks for uses of `contains_key` + `insert` on `HashMap` or `BTreeMap`.\n\n **Why is this bad?** Using `entry` is more efficient.\n\n **Known problems:** Some false negatives, eg.:\n ```rust\n # use std::collections::HashMap;\n # let mut map = HashMap::new();\n # let v = 1;\n # let k = 1;\n if !map.contains_key(&k) {\n     map.insert(k.clone(), v);\n }\n ```\n\n **Example:**\n ```rust\n # use std::collections::HashMap;\n # let mut map = HashMap::new();\n # let k = 1;\n # let v = 1;\n if !map.contains_key(&k) {\n     map.insert(k, v);\n }\n ```\n can both be rewritten as:\n ```rust\n # use std::collections::HashMap;\n # let mut map = HashMap::new();\n # let k = 1;\n # let v = 1;\n map.entry(k).or_insert(v);\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "enum_clike_unportable_variant",
-    "id_span": {
-      "path": "src/enum_clike.rs",
-      "line": 31
-    },
-    "group": "clippy::correctness",
-    "docs": " **What it does:** Checks for C-like enumerations that are `repr(isize/usize)` and have values that don't fit into an `i32`.\n\n **Why is this bad?** This will truncate the variant value on 32 bit\n architectures, but works fine on 64 bit.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # #[cfg(target_pointer_width = \"64\")]\n #[repr(usize)]\n enum NonPortable {\n     X = 0x1_0000_0000,\n     Y = 0,\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "enum_variant_names",
-    "id_span": {
-      "path": "src/enum_variants.rs",
-      "line": 36
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Detects enumeration variants that are prefixed or suffixed by the same characters.\n\n **Why is this bad?** Enumeration variant names should specify their variant,\n not repeat the enumeration name.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n enum Cake {\n     BlackForestCake,\n     HummingbirdCake,\n     BattenbergCake,\n }\n ```\n Could be written as:\n ```rust\n enum Cake {\n     BlackForest,\n     Hummingbird,\n     Battenberg,\n }\n ```\n",
-    "applicability": null
-  },
-  {
-    "id": "pub_enum_variant_names",
-    "id_span": {
-      "path": "src/enum_variants.rs",
-      "line": 66
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Detects public enumeration variants that are prefixed or suffixed by the same characters.\n\n **Why is this bad?** Public enumeration variant names should specify their variant,\n not repeat the enumeration name.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n pub enum Cake {\n     BlackForestCake,\n     HummingbirdCake,\n     BattenbergCake,\n }\n ```\n Could be written as:\n ```rust\n pub enum Cake {\n     BlackForest,\n     Hummingbird,\n     Battenberg,\n }\n ```\n",
-    "applicability": null
-  },
-  {
-    "id": "module_name_repetitions",
-    "id_span": {
-      "path": "src/enum_variants.rs",
-      "line": 91
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Detects type names that are prefixed or suffixed by the containing module's name.\n\n **Why is this bad?** It requires the user to type the module name twice.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n mod cake {\n     struct BlackForestCake;\n }\n ```\n Could be written as:\n ```rust\n mod cake {\n     struct BlackForest;\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "module_inception",
-    "id_span": {
-      "path": "src/enum_variants.rs",
-      "line": 121
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for modules that have the same name as their parent module\n\n **Why is this bad?** A typical beginner mistake is to have `mod foo;` and\n again `mod foo { ..\n }` in `foo.rs`.\n The expectation is that items inside the inner `mod foo { .. }` are then\n available\n through `foo::x`, but they are only available through\n `foo::foo::x`.\n If this is done on purpose, it would be better to choose a more\n representative module name.\n\n **Known problems:** None.\n\n **Example:**\n ```ignore\n // lib.rs\n mod foo;\n // foo.rs\n mod foo {\n     ...\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "eq_op",
-    "id_span": {
-      "path": "src/eq_op.rs",
-      "line": 34
-    },
-    "group": "clippy::correctness",
-    "docs": " **What it does:** Checks for equal operands to comparison, logical and bitwise, difference and division binary operators (`==`, `>`, etc., `&&`,\n `||`, `&`, `|`, `^`, `-` and `/`).\n\n **Why is this bad?** This is usually just a typo or a copy and paste error.\n\n **Known problems:** False negatives: We had some false positives regarding\n calls (notably [racer](https://github.com/phildawes/racer) had one instance\n of `x.pop() && x.pop()`), so we removed matching any function or method\n calls. We may introduce a list of known pure functions in the future.\n\n **Example:**\n ```rust\n # let x = 1;\n if x + 1 == x + 1 {}\n ```\n or\n ```rust\n # let a = 3;\n # let b = 4;\n assert_eq!(a, a);\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "op_ref",
-    "id_span": {
-      "path": "src/eq_op.rs",
-      "line": 56
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for arguments to `==` which have their address taken to satisfy a bound\n and suggests to dereference the other argument instead\n\n **Why is this bad?** It is more idiomatic to dereference the other argument.\n\n **Known problems:** None\n\n **Example:**\n ```ignore\n // Bad\n &x == y\n\n // Good\n x == *y\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MaybeIncorrect"
-    }
-  },
-  {
-    "id": "erasing_op",
-    "id_span": {
-      "path": "src/erasing_op.rs",
-      "line": 25
-    },
-    "group": "clippy::correctness",
-    "docs": " **What it does:** Checks for erasing operations, e.g., `x * 0`.\n **Why is this bad?** The whole expression can be replaced by zero.\n This is most likely not the intended outcome and should probably be\n corrected\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n let x = 1;\n 0 / x;\n 0 * x;\n x & 0;\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "boxed_local",
-    "id_span": {
-      "path": "src/escape.rs",
-      "line": 43
-    },
-    "group": "clippy::perf",
-    "docs": " **What it does:** Checks for usage of `Box<T>` where an unboxed `T` would work fine.\n\n **Why is this bad?** This is an unnecessary allocation, and bad for\n performance. It is only necessary to allocate if you wish to move the box\n into something.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # fn foo(bar: usize) {}\n // Bad\n let x = Box::new(1);\n foo(*x);\n println!(\"{}\", *x);\n\n // Good\n let x = 1;\n foo(x);\n println!(\"{}\", x);\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "redundant_closure",
-    "id_span": {
-      "path": "src/eta_reduction.rs",
-      "line": 37
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for closures which just call another function where the function can be called directly. `unsafe` functions or calls where types\n get adjusted are ignored.\n\n **Why is this bad?** Needlessly creating a closure adds code for no benefit\n and gives the optimizer more work.\n\n **Known problems:** If creating the closure inside the closure has a side-\n effect then moving the closure creation out will change when that side-\n effect runs.\n See [#1439](https://github.com/rust-lang/rust-clippy/issues/1439) for more details.\n\n **Example:**\n ```rust,ignore\n // Bad\n xs.map(|x| foo(x))\n\n // Good\n xs.map(foo)\n ```\n where `foo(_)` is a plain function that takes the exact argument type of\n `x`.\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "redundant_closure_for_method_calls",
-    "id_span": {
-      "path": "src/eta_reduction.rs",
-      "line": 61
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Checks for closures which only invoke a method on the closure argument and can be replaced by referencing the method directly.\n\n **Why is this bad?** It's unnecessary to create the closure.\n\n **Known problems:** [#3071](https://github.com/rust-lang/rust-clippy/issues/3071),\n [#3942](https://github.com/rust-lang/rust-clippy/issues/3942),\n [#4002](https://github.com/rust-lang/rust-clippy/issues/4002)\n\n\n **Example:**\n ```rust,ignore\n Some('a').map(|s| s.to_uppercase());\n ```\n may be rewritten as\n ```rust,ignore\n Some('a').map(char::to_uppercase);\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "eval_order_dependence",
-    "id_span": {
-      "path": "src/eval_order_dependence.rs",
-      "line": 38
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks for a read and a write to the same variable where whether the read occurs before or after the write depends on the evaluation\n order of sub-expressions.\n\n **Why is this bad?** It is often confusing to read. In addition, the\n sub-expression evaluation order for Rust is not well documented.\n\n **Known problems:** Code which intentionally depends on the evaluation\n order, or which is correct for any evaluation order.\n\n **Example:**\n ```rust\n let mut x = 0;\n\n // Bad\n let a = {\n     x = 1;\n     1\n } + x;\n // Unclear whether a is 1 or 2.\n\n // Good\n let tmp = {\n     x = 1;\n     1\n };\n let a = tmp + x;\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "diverging_sub_expression",
-    "id_span": {
-      "path": "src/eval_order_dependence.rs",
-      "line": 62
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks for diverging calls that are not match arms or statements.\n\n **Why is this bad?** It is often confusing to read. In addition, the\n sub-expression evaluation order for Rust is not well documented.\n\n **Known problems:** Someone might want to use `some_bool || panic!()` as a\n shorthand.\n\n **Example:**\n ```rust,no_run\n # fn b() -> bool { true }\n # fn c() -> bool { true }\n let a = b() || panic!() || c();\n // `c()` is dead, `panic!()` is only called if `b()` returns `false`\n let x = (a, b, c, panic!());\n // can simply be replaced by `panic!()`\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "struct_excessive_bools",
-    "id_span": {
-      "path": "src/excessive_bools.rs",
-      "line": 40
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Checks for excessive use of bools in structs.\n\n **Why is this bad?** Excessive bools in a struct\n is often a sign that it's used as a state machine,\n which is much better implemented as an enum.\n If it's not the case, excessive bools usually benefit\n from refactoring into two-variant enums for better\n readability and API.\n\n **Known problems:** None.\n\n **Example:**\n Bad:\n ```rust\n struct S {\n     is_pending: bool,\n     is_processing: bool,\n     is_finished: bool,\n }\n ```\n\n Good:\n ```rust\n enum S {\n     Pending,\n     Processing,\n     Finished,\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "fn_params_excessive_bools",
-    "id_span": {
-      "path": "src/excessive_bools.rs",
-      "line": 78
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Checks for excessive use of bools in function definitions.\n\n **Why is this bad?** Calls to such functions\n are confusing and error prone, because it's\n hard to remember argument order and you have\n no type system support to back you up. Using\n two-variant enums instead of bools often makes\n API easier to use.\n\n **Known problems:** None.\n\n **Example:**\n Bad:\n ```rust,ignore\n fn f(is_round: bool, is_hot: bool) { ... }\n ```\n\n Good:\n ```rust,ignore\n enum Shape {\n     Round,\n     Spiky,\n }\n\n enum Temperature {\n     Hot,\n     IceCold,\n }\n\n fn f(shape: Shape, temperature: Temperature) { ... }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "exhaustive_enums",
-    "id_span": {
-      "path": "src/exhaustive_items.rs",
-      "line": 34
-    },
-    "group": "clippy::restriction",
-    "docs": " **What it does:** Warns on any exported `enum`s that are not tagged `#[non_exhaustive]`\n **Why is this bad?** Exhaustive enums are typically fine, but a project which does\n not wish to make a stability commitment around exported enums may wish to\n disable them by default.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n enum Foo {\n     Bar,\n     Baz\n }\n ```\n Use instead:\n ```rust\n #[non_exhaustive]\n enum Foo {\n     Bar,\n     Baz\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MaybeIncorrect"
-    }
-  },
-  {
-    "id": "exhaustive_structs",
-    "id_span": {
-      "path": "src/exhaustive_items.rs",
-      "line": 64
-    },
-    "group": "clippy::restriction",
-    "docs": " **What it does:** Warns on any exported `structs`s that are not tagged `#[non_exhaustive]`\n **Why is this bad?** Exhaustive structs are typically fine, but a project which does\n not wish to make a stability commitment around exported structs may wish to\n disable them by default.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n struct Foo {\n     bar: u8,\n     baz: String,\n }\n ```\n Use instead:\n ```rust\n #[non_exhaustive]\n struct Foo {\n     bar: u8,\n     baz: String,\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MaybeIncorrect"
-    }
-  },
-  {
-    "id": "exit",
-    "id_span": {
-      "path": "src/exit.rs",
-      "line": 20
-    },
-    "group": "clippy::restriction",
-    "docs": " **What it does:** `exit()`  terminates the program and doesn't provide a stack trace.\n\n **Why is this bad?** Ideally a program is terminated by finishing\n the main function.\n\n **Known problems:** None.\n\n **Example:**\n ```ignore\n std::process::exit(0)\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "explicit_write",
-    "id_span": {
-      "path": "src/explicit_write.rs",
-      "line": 25
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks for usage of `write!()` / `writeln()!` which can be replaced with `(e)print!()` / `(e)println!()`\n\n **Why is this bad?** Using `(e)println! is clearer and more concise\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # use std::io::Write;\n # let bar = \"furchtbar\";\n // this would be clearer as `eprintln!(\"foo: {:?}\", bar);`\n writeln!(&mut std::io::stderr(), \"foo: {:?}\", bar).unwrap();\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "fallible_impl_from",
-    "id_span": {
-      "path": "src/fallible_impl_from.rs",
-      "line": 45
-    },
-    "group": "clippy::nursery",
-    "docs": " **What it does:** Checks for impls of `From<..>` that contain `panic!()` or `unwrap()`\n **Why is this bad?** `TryFrom` should be used if there's a possibility of failure.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n struct Foo(i32);\n\n // Bad\n impl From<String> for Foo {\n     fn from(s: String) -> Self {\n         Foo(s.parse().unwrap())\n     }\n }\n ```\n\n ```rust\n // Good\n struct Foo(i32);\n\n use std::convert::TryFrom;\n impl TryFrom<String> for Foo {\n     type Error = ();\n     fn try_from(s: String) -> Result<Self, Self::Error> {\n         if let Ok(parsed) = s.parse() {\n             Ok(Foo(parsed))\n         } else {\n             Err(())\n         }\n     }\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "float_equality_without_abs",
-    "id_span": {
-      "path": "src/float_equality_without_abs.rs",
-      "line": 37
-    },
-    "group": "clippy::correctness",
-    "docs": " **What it does:** Checks for statements of the form `(a - b) < f32::EPSILON` or `(a - b) < f64::EPSILON`. Notes the missing `.abs()`.\n\n **Why is this bad?** The code without `.abs()` is more likely to have a bug.\n\n **Known problems:** If the user can ensure that b is larger than a, the `.abs()` is\n technically unneccessary. However, it will make the code more robust and doesn't have any\n large performance implications. If the abs call was deliberately left out for performance\n reasons, it is probably better to state this explicitly in the code, which then can be done\n with an allow.\n\n **Example:**\n\n ```rust\n pub fn is_roughly_equal(a: f32, b: f32) -> bool {\n     (a - b) < f32::EPSILON\n }\n ```\n Use instead:\n ```rust\n pub fn is_roughly_equal(a: f32, b: f32) -> bool {\n     (a - b).abs() < f32::EPSILON\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MaybeIncorrect"
-    }
-  },
-  {
-    "id": "excessive_precision",
-    "id_span": {
-      "path": "src/float_literal.rs",
-      "line": 30
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for float literals with a precision greater than that supported by the underlying type.\n\n **Why is this bad?** Rust will truncate the literal silently.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n // Bad\n let v: f32 = 0.123_456_789_9;\n println!(\"{}\", v); //  0.123_456_789\n\n // Good\n let v: f64 = 0.123_456_789_9;\n println!(\"{}\", v); //  0.123_456_789_9\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "lossy_float_literal",
-    "id_span": {
-      "path": "src/float_literal.rs",
-      "line": 54
-    },
-    "group": "clippy::restriction",
-    "docs": " **What it does:** Checks for whole number float literals that cannot be represented as the underlying type without loss.\n\n **Why is this bad?** Rust will silently lose precision during\n conversion to a float.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n // Bad\n let _: f32 = 16_777_217.0; // 16_777_216.0\n\n // Good\n let _: f32 = 16_777_216.0;\n let _: f64 = 16_777_217.0;\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "imprecise_flops",
-    "id_span": {
-      "path": "src/floating_point_arithmetic.rs",
-      "line": 45
-    },
-    "group": "clippy::nursery",
-    "docs": " **What it does:** Looks for floating-point expressions that can be expressed using built-in methods to improve accuracy\n at the cost of performance.\n\n **Why is this bad?** Negatively impacts accuracy.\n\n **Known problems:** None\n\n **Example:**\n\n ```rust\n let a = 3f32;\n let _ = a.powf(1.0 / 3.0);\n let _ = (1.0 + a).ln();\n let _ = a.exp() - 1.0;\n ```\n\n is better expressed as\n\n ```rust\n let a = 3f32;\n let _ = a.cbrt();\n let _ = a.ln_1p();\n let _ = a.exp_m1();\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "suboptimal_flops",
-    "id_span": {
-      "path": "src/floating_point_arithmetic.rs",
-      "line": 102
-    },
-    "group": "clippy::nursery",
-    "docs": " **What it does:** Looks for floating-point expressions that can be expressed using built-in methods to improve both\n accuracy and performance.\n\n **Why is this bad?** Negatively impacts accuracy and performance.\n\n **Known problems:** None\n\n **Example:**\n\n ```rust\n use std::f32::consts::E;\n\n let a = 3f32;\n let _ = (2f32).powf(a);\n let _ = E.powf(a);\n let _ = a.powf(1.0 / 2.0);\n let _ = a.log(2.0);\n let _ = a.log(10.0);\n let _ = a.log(E);\n let _ = a.powf(2.0);\n let _ = a * 2.0 + 4.0;\n let _ = if a < 0.0 {\n     -a\n } else {\n     a\n };\n let _ = if a < 0.0 {\n     a\n } else {\n     -a\n };\n ```\n\n is better expressed as\n\n ```rust\n use std::f32::consts::E;\n\n let a = 3f32;\n let _ = a.exp2();\n let _ = a.exp();\n let _ = a.sqrt();\n let _ = a.log2();\n let _ = a.log10();\n let _ = a.ln();\n let _ = a.powi(2);\n let _ = a.mul_add(2.0, 4.0);\n let _ = a.abs();\n let _ = -a.abs();\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "useless_format",
-    "id_span": {
-      "path": "src/format.rs",
-      "line": 37
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks for the use of `format!(\"string literal with no argument\")` and `format!(\"{}\", foo)` where `foo` is a string.\n\n **Why is this bad?** There is no point of doing that. `format!(\"foo\")` can\n be replaced by `\"foo\".to_owned()` if you really need a `String`. The even\n worse `&format!(\"foo\")` is often encountered in the wild. `format!(\"{}\",\n foo)` can be replaced by `foo.clone()` if `foo: String` or `foo.to_owned()`\n if `foo: &str`.\n\n **Known problems:** None.\n\n **Examples:**\n ```rust\n\n // Bad\n # let foo = \"foo\";\n format!(\"{}\", foo);\n\n // Good\n format!(\"foo\");\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "suspicious_assignment_formatting",
-    "id_span": {
-      "path": "src/formatting.rs",
-      "line": 22
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for use of the non-existent `=*`, `=!` and `=-` operators.\n\n **Why is this bad?** This is either a typo of `*=`, `!=` or `-=` or\n confusing.\n\n **Known problems:** None.\n\n **Example:**\n ```rust,ignore\n a =- 42; // confusing, should it be `a -= 42` or `a = -42`?\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "suspicious_unary_op_formatting",
-    "id_span": {
-      "path": "src/formatting.rs",
-      "line": 44
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks the formatting of a unary operator on the right hand side of a binary operator. It lints if there is no space between the binary and unary operators,\n but there is a space between the unary and its operand.\n\n **Why is this bad?** This is either a typo in the binary operator or confusing.\n\n **Known problems:** None.\n\n **Example:**\n ```rust,ignore\n if foo <- 30 { // this should be `foo < -30` but looks like a different operator\n }\n\n if foo &&! bar { // this should be `foo && !bar` but looks like a different operator\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "suspicious_else_formatting",
-    "id_span": {
-      "path": "src/formatting.rs",
-      "line": 80
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for formatting of `else`. It lints if the `else` is followed immediately by a newline or the `else` seems to be missing.\n\n **Why is this bad?** This is probably some refactoring remnant, even if the\n code is correct, it might look confusing.\n\n **Known problems:** None.\n\n **Example:**\n ```rust,ignore\n if foo {\n } { // looks like an `else` is missing here\n }\n\n if foo {\n } if bar { // looks like an `else` is missing here\n }\n\n if foo {\n } else\n\n { // this is the `else` block of the previous `if`, but should it be?\n }\n\n if foo {\n } else\n\n if bar { // this is the `else` block of the previous `if`, but should it be?\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "possible_missing_comma",
-    "id_span": {
-      "path": "src/formatting.rs",
-      "line": 100
-    },
-    "group": "clippy::correctness",
-    "docs": " **What it does:** Checks for possible missing comma in an array. It lints if an array element is a binary operator expression and it lies on two lines.\n\n **Why is this bad?** This could lead to unexpected results.\n\n **Known problems:** None.\n\n **Example:**\n ```rust,ignore\n let a = &[\n     -1, -2, -3 // <= no comma here\n     -4, -5, -6\n ];\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "from_over_into",
-    "id_span": {
-      "path": "src/from_over_into.rs",
-      "line": 39
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Searches for implementations of the `Into<..>` trait and suggests to implement `From<..>` instead.\n **Why is this bad?** According the std docs implementing `From<..>` is preferred since it gives you `Into<..>` for free where the reverse isn't true.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n struct StringWrapper(String);\n\n impl Into<StringWrapper> for String {\n     fn into(self) -> StringWrapper {\n         StringWrapper(self)\n     }\n }\n ```\n Use instead:\n ```rust\n struct StringWrapper(String);\n\n impl From<String> for StringWrapper {\n     fn from(s: String) -> StringWrapper {\n         StringWrapper(s)\n     }\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "from_str_radix_10",
-    "id_span": {
-      "path": "src/from_str_radix_10.rs",
-      "line": 37
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for function invocations of the form `primitive::from_str_radix(s, 10)`\n\n **Why is this bad?**\n This specific common use case can be rewritten as `s.parse::<primitive>()`\n (and in most cases, the turbofish can be removed), which reduces code length\n and complexity.\n\n **Known problems:**\n This lint may suggest using (&<expression>).parse() instead of <expression>.parse() directly\n in some cases, which is correct but adds unnecessary complexity to the code.\n\n **Example:**\n\n ```ignore\n let input: &str = get_input();\n let num = u16::from_str_radix(input, 10)?;\n ```\n Use instead:\n ```ignore\n let input: &str = get_input();\n let num: u16 = input.parse()?;\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MaybeIncorrect"
-    }
-  },
-  {
-    "id": "too_many_arguments",
-    "id_span": {
-      "path": "src/functions.rs",
-      "line": 39
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks for functions with too many parameters.\n **Why is this bad?** Functions with lots of parameters are considered bad\n style and reduce readability (“what does the 5th parameter mean?”). Consider\n grouping some parameters into a new type.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # struct Color;\n fn foo(x: u32, y: u32, name: &str, c: Color, w: f32, h: f32, a: f32, b: f32) {\n     // ..\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "too_many_lines",
-    "id_span": {
-      "path": "src/functions.rs",
-      "line": 62
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Checks for functions with a large amount of lines.\n **Why is this bad?** Functions with a lot of lines are harder to understand\n due to having to look at a larger amount of code to understand what the\n function is doing. Consider splitting the body of the function into\n multiple functions.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n fn im_too_long() {\n     println!(\"\");\n     // ... 100 more LoC\n     println!(\"\");\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "not_unsafe_ptr_arg_deref",
-    "id_span": {
-      "path": "src/functions.rs",
-      "line": 96
-    },
-    "group": "clippy::correctness",
-    "docs": " **What it does:** Checks for public functions that dereference raw pointer arguments but are not marked unsafe.\n\n **Why is this bad?** The function should probably be marked `unsafe`, since\n for an arbitrary raw pointer, there is no way of telling for sure if it is\n valid.\n\n **Known problems:**\n\n * It does not check functions recursively so if the pointer is passed to a\n private non-`unsafe` function which does the dereferencing, the lint won't\n trigger.\n * It only checks for arguments whose type are raw pointers, not raw pointers\n got from an argument in some other way (`fn foo(bar: &[*const u8])` or\n `some_argument.get_raw_ptr()`).\n\n **Example:**\n ```rust,ignore\n // Bad\n pub fn foo(x: *const u8) {\n     println!(\"{}\", unsafe { *x });\n }\n\n // Good\n pub unsafe fn foo(x: *const u8) {\n     println!(\"{}\", unsafe { *x });\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "must_use_unit",
-    "id_span": {
-      "path": "src/functions.rs",
-      "line": 117
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for a [`#[must_use]`] attribute on unit-returning functions and methods.\n\n [`#[must_use]`]: https://doc.rust-lang.org/reference/attributes/diagnostics.html#the-must_use-attribute\n\n **Why is this bad?** Unit values are useless. The attribute is likely\n a remnant of a refactoring that removed the return type.\n\n **Known problems:** None.\n\n **Examples:**\n ```rust\n #[must_use]\n fn useless() { }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "double_must_use",
-    "id_span": {
-      "path": "src/functions.rs",
-      "line": 142
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for a [`#[must_use]`] attribute without further information on functions and methods that return a type already\n marked as `#[must_use]`.\n\n [`#[must_use]`]: https://doc.rust-lang.org/reference/attributes/diagnostics.html#the-must_use-attribute\n\n **Why is this bad?** The attribute isn't needed. Not using the result\n will already be reported. Alternatively, one can add some text to the\n attribute to improve the lint message.\n\n **Known problems:** None.\n\n **Examples:**\n ```rust\n #[must_use]\n fn double_must_use() -> Result<(), ()> {\n     unimplemented!();\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "must_use_candidate",
-    "id_span": {
-      "path": "src/functions.rs",
-      "line": 170
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Checks for public functions that have no [`#[must_use]`] attribute, but return something not already marked\n must-use, have no mutable arg and mutate no statics.\n\n [`#[must_use]`]: https://doc.rust-lang.org/reference/attributes/diagnostics.html#the-must_use-attribute\n\n **Why is this bad?** Not bad at all, this lint just shows places where\n you could add the attribute.\n\n **Known problems:** The lint only checks the arguments for mutable\n types without looking if they are actually changed. On the other hand,\n it also ignores a broad range of potentially interesting side effects,\n because we cannot decide whether the programmer intends the function to\n be called for the side effect or the result. Expect many false\n positives. At least we don't lint if the result type is unit or already\n `#[must_use]`.\n\n **Examples:**\n ```rust\n // this could be annotated with `#[must_use]`.\n fn id<T>(t: T) -> T { t }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "result_unit_err",
-    "id_span": {
-      "path": "src/functions.rs",
-      "line": 216
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for public functions that return a `Result` with an `Err` type of `()`. It suggests using a custom type that\n implements [`std::error::Error`].\n\n **Why is this bad?** Unit does not implement `Error` and carries no\n further information about what went wrong.\n\n **Known problems:** Of course, this lint assumes that `Result` is used\n for a fallible operation (which is after all the intended use). However\n code may opt to (mis)use it as a basic two-variant-enum. In that case,\n the suggestion is misguided, and the code should use a custom enum\n instead.\n\n **Examples:**\n ```rust\n pub fn read_u8() -> Result<u8, ()> { Err(()) }\n ```\n should become\n ```rust,should_panic\n use std::fmt;\n\n #[derive(Debug)]\n pub struct EndOfStream;\n\n impl fmt::Display for EndOfStream {\n     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\n         write!(f, \"End of Stream\")\n     }\n }\n\n impl std::error::Error for EndOfStream { }\n\n pub fn read_u8() -> Result<u8, EndOfStream> { Err(EndOfStream) }\n# fn main() {\n#     read_u8().unwrap();\n# }\n ```\n\n Note that there are crates that simplify creating the error type, e.g.\n [`thiserror`](https://docs.rs/thiserror).\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "future_not_send",
-    "id_span": {
-      "path": "src/future_not_send.rs",
-      "line": 44
-    },
-    "group": "clippy::nursery",
-    "docs": " **What it does:** This lint requires Future implementations returned from functions and methods to implement the `Send` marker trait. It is mostly\n used by library authors (public and internal) that target an audience where\n multithreaded executors are likely to be used for running these Futures.\n\n **Why is this bad?** A Future implementation captures some state that it\n needs to eventually produce its final value. When targeting a multithreaded\n executor (which is the norm on non-embedded devices) this means that this\n state may need to be transported to other threads, in other words the\n whole Future needs to implement the `Send` marker trait. If it does not,\n then the resulting Future cannot be submitted to a thread pool in the\n end user’s code.\n\n Especially for generic functions it can be confusing to leave the\n discovery of this problem to the end user: the reported error location\n will be far from its cause and can in many cases not even be fixed without\n modifying the library where the offending Future implementation is\n produced.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n async fn not_send(bytes: std::rc::Rc<[u8]>) {}\n ```\n Use instead:\n ```rust\n async fn is_send(bytes: std::sync::Arc<[u8]>) {}\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "get_last_with_len",
-    "id_span": {
-      "path": "src/get_last_with_len.rs",
-      "line": 40
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks for using `x.get(x.len() - 1)` instead of `x.last()`.\n\n **Why is this bad?** Using `x.last()` is easier to read and has the same\n result.\n\n Note that using `x[x.len() - 1]` is semantically different from\n `x.last()`.  Indexing into the array will panic on out-of-bounds\n accesses, while `x.get()` and `x.last()` will return `None`.\n\n There is another lint (get_unwrap) that covers the case of using\n `x.get(index).unwrap()` instead of `x[index]`.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n // Bad\n let x = vec![2, 3, 5];\n let last_element = x.get(x.len() - 1);\n\n // Good\n let x = vec![2, 3, 5];\n let last_element = x.last();\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "identity_op",
-    "id_span": {
-      "path": "src/identity_op.rs",
-      "line": 24
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks for identity operations, e.g., `x + 0`.\n **Why is this bad?** This code can be removed without changing the\n meaning. So it just obscures what's going on. Delete it mercilessly.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # let x = 1;\n x / 1 + 0 * 1 - 0 | 0;\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "if_let_mutex",
-    "id_span": {
-      "path": "src/if_let_mutex.rs",
-      "line": 36
-    },
-    "group": "clippy::correctness",
-    "docs": " **What it does:** Checks for `Mutex::lock` calls in `if let` expression with lock calls in any of the else blocks.\n\n **Why is this bad?** The Mutex lock remains held for the whole\n `if let ... else` block and deadlocks.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust,ignore\n if let Ok(thing) = mutex.lock() {\n     do_thing();\n } else {\n     mutex.lock();\n }\n ```\n Should be written\n ```rust,ignore\n let locked = mutex.lock();\n if let Ok(thing) = locked {\n     do_thing(thing);\n } else {\n     use_locked(locked);\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "if_let_some_result",
-    "id_span": {
-      "path": "src/if_let_some_result.rs",
-      "line": 34
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:*** Checks for unnecessary `ok()` in if let.\n **Why is this bad?** Calling `ok()` in if let is unnecessary, instead match\n on `Ok(pat)`\n\n **Known problems:** None.\n\n **Example:**\n ```ignore\n for i in iter {\n     if let Some(value) = i.parse().ok() {\n         vec.push(value)\n     }\n }\n ```\n Could be written:\n\n ```ignore\n for i in iter {\n     if let Ok(value) = i.parse() {\n         vec.push(value)\n     }\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "if_not_else",
-    "id_span": {
-      "path": "src/if_not_else.rs",
-      "line": 43
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Checks for usage of `!` or `!=` in an if condition with an else branch.\n\n **Why is this bad?** Negations reduce the readability of statements.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # let v: Vec<usize> = vec![];\n # fn a() {}\n # fn b() {}\n if !v.is_empty() {\n     a()\n } else {\n     b()\n }\n ```\n\n Could be written:\n\n ```rust\n # let v: Vec<usize> = vec![];\n # fn a() {}\n # fn b() {}\n if v.is_empty() {\n     b()\n } else {\n     a()\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "implicit_return",
-    "id_span": {
-      "path": "src/implicit_return.rs",
-      "line": 33
-    },
-    "group": "clippy::restriction",
-    "docs": " **What it does:** Checks for missing return statements at the end of a block.\n **Why is this bad?** Actually omitting the return keyword is idiomatic Rust code. Programmers\n coming from other languages might prefer the expressiveness of `return`. It's possible to miss\n the last returning statement because the only difference is a missing `;`. Especially in bigger\n code with multiple return paths having a `return` keyword makes it easier to find the\n corresponding statements.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n fn foo(x: usize) -> usize {\n     x\n }\n ```\n add return\n ```rust\n fn foo(x: usize) -> usize {\n     return x;\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "implicit_saturating_sub",
-    "id_span": {
-      "path": "src/implicit_saturating_sub.rs",
-      "line": 32
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Checks for implicit saturating subtraction.\n **Why is this bad?** Simplicity and readability. Instead we can easily use an builtin function.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n let end: u32 = 10;\n let start: u32 = 5;\n\n let mut i: u32 = end - start;\n\n // Bad\n if i != 0 {\n     i -= 1;\n }\n\n // Good\n i = i.saturating_sub(1);\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "inconsistent_struct_constructor",
-    "id_span": {
-      "path": "src/inconsistent_struct_constructor.rs",
-      "line": 58
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for struct constructors where the order of the field init shorthand in the constructor is inconsistent with the order in the struct definition.\n\n **Why is this bad?** Since the order of fields in a constructor doesn't affect the\n resulted instance as the below example indicates,\n\n ```rust\n #[derive(Debug, PartialEq, Eq)]\n struct Foo {\n     x: i32,\n     y: i32,\n }\n let x = 1;\n let y = 2;\n\n // This assertion never fails.\n assert_eq!(Foo { x, y }, Foo { y, x });\n ```\n\n inconsistent order means nothing and just decreases readability and consistency.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n struct Foo {\n     x: i32,\n     y: i32,\n }\n let x = 1;\n let y = 2;\n Foo { y, x };\n ```\n\n Use instead:\n ```rust\n # struct Foo {\n #     x: i32,\n #     y: i32,\n # }\n # let x = 1;\n # let y = 2;\n Foo { x, y };\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "out_of_bounds_indexing",
-    "id_span": {
-      "path": "src/indexing_slicing.rs",
-      "line": 32
-    },
-    "group": "clippy::correctness",
-    "docs": " **What it does:** Checks for out of bounds array indexing with a constant index.\n\n **Why is this bad?** This will always panic at runtime.\n\n **Known problems:** Hopefully none.\n\n **Example:**\n ```no_run\n # #![allow(const_err)]\n let x = [1, 2, 3, 4];\n\n // Bad\n x[9];\n &x[2..9];\n\n // Good\n x[0];\n x[3];\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "indexing_slicing",
-    "id_span": {
-      "path": "src/indexing_slicing.rs",
-      "line": 81
-    },
-    "group": "clippy::restriction",
-    "docs": " **What it does:** Checks for usage of indexing or slicing. Arrays are special cases, this lint does report on arrays if we can tell that slicing operations are in bounds and does not\n lint on constant `usize` indexing on arrays because that is handled by rustc's `const_err` lint.\n\n **Why is this bad?** Indexing and slicing can panic at runtime and there are\n safe alternatives.\n\n **Known problems:** Hopefully none.\n\n **Example:**\n ```rust,no_run\n // Vector\n let x = vec![0; 5];\n\n // Bad\n x[2];\n &x[2..100];\n &x[2..];\n &x[..100];\n\n // Good\n x.get(2);\n x.get(2..100);\n x.get(2..);\n x.get(..100);\n\n // Array\n let y = [0, 1, 2, 3];\n\n // Bad\n &y[10..100];\n &y[10..];\n &y[..100];\n\n // Good\n &y[2..];\n &y[..2];\n &y[0..3];\n y.get(10);\n y.get(10..100);\n y.get(10..);\n y.get(..100);\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "infinite_iter",
-    "id_span": {
-      "path": "src/infinite_iter.rs",
-      "line": 21
-    },
-    "group": "clippy::correctness",
-    "docs": " **What it does:** Checks for iteration that is guaranteed to be infinite.\n **Why is this bad?** While there may be places where this is acceptable\n (e.g., in event streams), in most cases this is simply an error.\n\n **Known problems:** None.\n\n **Example:**\n ```no_run\n use std::iter;\n\n iter::repeat(1_u8).collect::<Vec<_>>();\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "maybe_infinite_iter",
-    "id_span": {
-      "path": "src/infinite_iter.rs",
-      "line": 40
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Checks for iteration that may be infinite.\n **Why is this bad?** While there may be places where this is acceptable\n (e.g., in event streams), in most cases this is simply an error.\n\n **Known problems:** The code may have a condition to stop iteration, but\n this lint is not clever enough to analyze it.\n\n **Example:**\n ```rust\n let infinite_iter = 0..;\n [0..].iter().zip(infinite_iter.take_while(|x| *x > 5));\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "multiple_inherent_impl",
-    "id_span": {
-      "path": "src/inherent_impl.rs",
-      "line": 37
-    },
-    "group": "clippy::restriction",
-    "docs": " **What it does:** Checks for multiple inherent implementations of a struct\n **Why is this bad?** Splitting the implementation of a type makes the code harder to navigate.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n struct X;\n impl X {\n     fn one() {}\n }\n impl X {\n     fn other() {}\n }\n ```\n\n Could be written:\n\n ```rust\n struct X;\n impl X {\n     fn one() {}\n     fn other() {}\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "inherent_to_string",
-    "id_span": {
-      "path": "src/inherent_to_string.rs",
-      "line": 44
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for the definition of inherent methods with a signature of `to_string(&self) -> String`.\n **Why is this bad?** This method is also implicitly defined if a type implements the `Display` trait. As the functionality of `Display` is much more versatile, it should be preferred.\n\n **Known problems:** None\n\n ** Example:**\n\n ```rust\n // Bad\n pub struct A;\n\n impl A {\n     pub fn to_string(&self) -> String {\n         \"I am A\".to_string()\n     }\n }\n ```\n\n ```rust\n // Good\n use std::fmt;\n\n pub struct A;\n\n impl fmt::Display for A {\n     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n         write!(f, \"I am A\")\n     }\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "inherent_to_string_shadow_display",
-    "id_span": {
-      "path": "src/inherent_to_string.rs",
-      "line": 89
-    },
-    "group": "clippy::correctness",
-    "docs": " **What it does:** Checks for the definition of inherent methods with a signature of `to_string(&self) -> String` and if the type implementing this method also implements the `Display` trait.\n **Why is this bad?** This method is also implicitly defined if a type implements the `Display` trait. The less versatile inherent method will then shadow the implementation introduced by `Display`.\n\n **Known problems:** None\n\n ** Example:**\n\n ```rust\n // Bad\n use std::fmt;\n\n pub struct A;\n\n impl A {\n     pub fn to_string(&self) -> String {\n         \"I am A\".to_string()\n     }\n }\n\n impl fmt::Display for A {\n     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n         write!(f, \"I am A, too\")\n     }\n }\n ```\n\n ```rust\n // Good\n use std::fmt;\n\n pub struct A;\n\n impl fmt::Display for A {\n     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n         write!(f, \"I am A\")\n     }\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "inline_fn_without_body",
-    "id_span": {
-      "path": "src/inline_fn_without_body.rs",
-      "line": 27
-    },
-    "group": "clippy::correctness",
-    "docs": " **What it does:** Checks for `#[inline]` on trait methods without bodies\n **Why is this bad?** Only implementations of trait methods may be inlined.\n The inline attribute is ignored for trait methods without bodies.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n trait Animal {\n     #[inline]\n     fn name(&self) -> &'static str;\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "int_plus_one",
-    "id_span": {
-      "path": "src/int_plus_one.rs",
-      "line": 31
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks for usage of `x >= y + 1` or `x - 1 >= y` (and `<=`) in a block\n **Why is this bad?** Readability -- better to use `> y` instead of `>= y + 1`.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # let x = 1;\n # let y = 1;\n if x >= y + 1 {}\n ```\n\n Could be written as:\n\n ```rust\n # let x = 1;\n # let y = 1;\n if x > y {}\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "integer_division",
-    "id_span": {
-      "path": "src/integer_division.rs",
-      "line": 26
-    },
-    "group": "clippy::restriction",
-    "docs": " **What it does:** Checks for division of integers\n **Why is this bad?** When outside of some very specific algorithms,\n integer division is very often a mistake because it discards the\n remainder.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n // Bad\n let x = 3 / 2;\n println!(\"{}\", x);\n\n // Good\n let x = 3f32 / 2f32;\n println!(\"{}\", x);\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "items_after_statements",
-    "id_span": {
-      "path": "src/items_after_statements.rs",
-      "line": 48
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Checks for items declared after some statement in a block.\n **Why is this bad?** Items live for the entire scope they are declared\n in. But statements are processed in order. This might cause confusion as\n it's hard to figure out which item is meant in a statement.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n // Bad\n fn foo() {\n     println!(\"cake\");\n }\n\n fn main() {\n     foo(); // prints \"foo\"\n     fn foo() {\n         println!(\"foo\");\n     }\n     foo(); // prints \"foo\"\n }\n ```\n\n ```rust\n // Good\n fn foo() {\n     println!(\"cake\");\n }\n\n fn main() {\n     fn foo() {\n         println!(\"foo\");\n     }\n     foo(); // prints \"foo\"\n     foo(); // prints \"foo\"\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "large_const_arrays",
-    "id_span": {
-      "path": "src/large_const_arrays.rs",
-      "line": 30
-    },
-    "group": "clippy::perf",
-    "docs": " **What it does:** Checks for large `const` arrays that should be defined as `static` instead.\n\n **Why is this bad?** Performance: const variables are inlined upon use.\n Static items result in only one instance and has a fixed location in memory.\n\n **Known problems:** None.\n\n **Example:**\n ```rust,ignore\n // Bad\n pub const a = [0u32; 1_000_000];\n\n // Good\n pub static a = [0u32; 1_000_000];\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "large_enum_variant",
-    "id_span": {
-      "path": "src/large_enum_variant.rs",
-      "line": 39
-    },
-    "group": "clippy::perf",
-    "docs": " **What it does:** Checks for large size differences between variants on `enum`s.\n\n **Why is this bad?** Enum size is bounded by the largest variant. Having a\n large variant can penalize the memory layout of that enum.\n\n **Known problems:** This lint obviously cannot take the distribution of\n variants in your running program into account. It is possible that the\n smaller variants make up less than 1% of all instances, in which case\n the overhead is negligible and the boxing is counter-productive. Always\n measure the change this lint suggests.\n\n **Example:**\n\n ```rust\n // Bad\n enum Test {\n     A(i32),\n     B([i32; 8000]),\n }\n\n // Possibly better\n enum Test2 {\n     A(i32),\n     B(Box<[i32; 8000]>),\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MaybeIncorrect"
-    }
-  },
-  {
-    "id": "large_stack_arrays",
-    "id_span": {
-      "path": "src/large_stack_arrays.rs",
-      "line": 23
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Checks for local arrays that may be too large.\n **Why is this bad?** Large local arrays may cause stack overflow.\n\n **Known problems:** None.\n\n **Example:**\n ```rust,ignore\n let a = [0u32; 1_000_000];\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "len_zero",
-    "id_span": {
-      "path": "src/len_zero.rs",
-      "line": 41
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for getting the length of something via `.len()` just to compare to zero, and suggests using `.is_empty()` where applicable.\n\n **Why is this bad?** Some structures can answer `.is_empty()` much faster\n than calculating their length. So it is good to get into the habit of using\n `.is_empty()`, and having it is cheap.\n Besides, it makes the intent clearer than a manual comparison in some contexts.\n\n **Known problems:** None.\n\n **Example:**\n ```ignore\n if x.len() == 0 {\n     ..\n }\n if y.len() != 0 {\n     ..\n }\n ```\n instead use\n ```ignore\n if x.is_empty() {\n     ..\n }\n if !y.is_empty() {\n     ..\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "len_without_is_empty",
-    "id_span": {
-      "path": "src/len_zero.rs",
-      "line": 66
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for items that implement `.len()` but not `.is_empty()`.\n\n **Why is this bad?** It is good custom to have both methods, because for\n some data structures, asking about the length will be a costly operation,\n whereas `.is_empty()` can usually answer in constant time. Also it used to\n lead to false positives on the [`len_zero`](#len_zero) lint – currently that\n lint will ignore such entities.\n\n **Known problems:** None.\n\n **Example:**\n ```ignore\n impl X {\n     pub fn len(&self) -> usize {\n         ..\n     }\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "comparison_to_empty",
-    "id_span": {
-      "path": "src/len_zero.rs",
-      "line": 103
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for comparing to an empty slice such as `\"\"` or `[]`, and suggests using `.is_empty()` where applicable.\n\n **Why is this bad?** Some structures can answer `.is_empty()` much faster\n than checking for equality. So it is good to get into the habit of using\n `.is_empty()`, and having it is cheap.\n Besides, it makes the intent clearer than a manual comparison in some contexts.\n\n **Known problems:** None.\n\n **Example:**\n\n ```ignore\n if s == \"\" {\n     ..\n }\n\n if arr == [] {\n     ..\n }\n ```\n Use instead:\n ```ignore\n if s.is_empty() {\n     ..\n }\n\n if arr.is_empty() {\n     ..\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "useless_let_if_seq",
-    "id_span": {
-      "path": "src/let_if_seq.rs",
-      "line": 49
-    },
-    "group": "clippy::nursery",
-    "docs": " **What it does:** Checks for variable declarations immediately followed by a conditional affectation.\n\n **Why is this bad?** This is not idiomatic Rust.\n\n **Known problems:** None.\n\n **Example:**\n ```rust,ignore\n let foo;\n\n if bar() {\n     foo = 42;\n } else {\n     foo = 0;\n }\n\n let mut baz = None;\n\n if bar() {\n     baz = Some(42);\n }\n ```\n\n should be written\n\n ```rust,ignore\n let foo = if bar() {\n     42\n } else {\n     0\n };\n\n let baz = if bar() {\n     Some(42)\n } else {\n     None\n };\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "HasPlaceholders"
-    }
-  },
-  {
-    "id": "let_underscore_must_use",
-    "id_span": {
-      "path": "src/let_underscore.rs",
-      "line": 29
-    },
-    "group": "clippy::restriction",
-    "docs": " **What it does:** Checks for `let _ = <expr>` where expr is #[must_use]\n\n **Why is this bad?** It's better to explicitly\n handle the value of a #[must_use] expr\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n fn f() -> Result<u32, u32> {\n     Ok(0)\n }\n\n let _ = f();\n // is_ok() is marked #[must_use]\n let _ = f().is_ok();\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "let_underscore_lock",
-    "id_span": {
-      "path": "src/let_underscore.rs",
-      "line": 56
-    },
-    "group": "clippy::correctness",
-    "docs": " **What it does:** Checks for `let _ = sync_lock`\n **Why is this bad?** This statement immediately drops the lock instead of\n extending its lifetime to the end of the scope, which is often not intended.\n To extend lock lifetime to the end of the scope, use an underscore-prefixed\n name instead (i.e. _lock). If you want to explicitly drop the lock,\n `std::mem::drop` conveys your intention better and is less error-prone.\n\n **Known problems:** None.\n\n **Example:**\n\n Bad:\n ```rust,ignore\n let _ = mutex.lock();\n ```\n\n Good:\n ```rust,ignore\n let _lock = mutex.lock();\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "let_underscore_drop",
-    "id_span": {
-      "path": "src/let_underscore.rs",
-      "line": 97
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Checks for `let _ = <expr>` where expr has a type that implements `Drop`\n\n **Why is this bad?** This statement immediately drops the initializer\n expression instead of extending its lifetime to the end of the scope, which\n is often not intended. To extend the expression's lifetime to the end of the\n scope, use an underscore-prefixed name instead (i.e. _var). If you want to\n explicitly drop the expression, `std::mem::drop` conveys your intention\n better and is less error-prone.\n\n **Known problems:** None.\n\n **Example:**\n\n Bad:\n ```rust,ignore\n struct Droppable;\n impl Drop for Droppable {\n     fn drop(&mut self) {}\n }\n {\n     let _ = Droppable;\n     //               ^ dropped here\n     /* more code */\n }\n ```\n\n Good:\n ```rust,ignore\n {\n     let _droppable = Droppable;\n     /* more code */\n     // dropped at end of scope\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "needless_lifetimes",
-    "id_span": {
-      "path": "src/lifetimes.rs",
-      "line": 46
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks for lifetime annotations which can be removed by relying on lifetime elision.\n\n **Why is this bad?** The additional lifetimes make the code look more\n complicated, while there is nothing out of the ordinary going on. Removing\n them leads to more readable code.\n\n **Known problems:**\n - We bail out if the function has a `where` clause where lifetimes\n are mentioned due to potenial false positives.\n - Lifetime bounds such as `impl Foo + 'a` and `T: 'a` must be elided with the\n placeholder notation `'_` because the fully elided notation leaves the type bound to `'static`.\n\n **Example:**\n ```rust\n // Bad: unnecessary lifetime annotations\n fn in_and_out<'a>(x: &'a u8, y: u8) -> &'a u8 {\n     x\n }\n\n // Good\n fn elided(x: &u8, y: u8) -> &u8 {\n     x\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "extra_unused_lifetimes",
-    "id_span": {
-      "path": "src/lifetimes.rs",
-      "line": 74
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks for lifetimes in generics that are never used anywhere else.\n\n **Why is this bad?** The additional lifetimes make the code look more\n complicated, while there is nothing out of the ordinary going on. Removing\n them leads to more readable code.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n // Bad: unnecessary lifetimes\n fn unused_lifetime<'a>(x: u8) {\n     // ..\n }\n\n // Good\n fn no_lifetime(x: u8) {\n     // ...\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "unreadable_literal",
-    "id_span": {
-      "path": "src/literal_representation.rs",
-      "line": 33
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Warns if a long integral or floating-point constant does not contain underscores.\n\n **Why is this bad?** Reading long numbers is difficult without separators.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n // Bad\n let x: u64 = 61864918973511;\n\n // Good\n let x: u64 = 61_864_918_973_511;\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "mistyped_literal_suffixes",
-    "id_span": {
-      "path": "src/literal_representation.rs",
-      "line": 57
-    },
-    "group": "clippy::correctness",
-    "docs": " **What it does:** Warns for mistyped suffix in literals\n **Why is this bad?** This is most probably a typo\n\n **Known problems:**\n - Recommends a signed suffix, even though the number might be too big and an unsigned\n   suffix is required\n - Does not match on `_127` since that is a valid grouping for decimal and octal numbers\n\n **Example:**\n\n ```rust\n // Probably mistyped\n 2_32;\n\n // Good\n 2_i32;\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MaybeIncorrect"
-    }
-  },
-  {
-    "id": "inconsistent_digit_grouping",
-    "id_span": {
-      "path": "src/literal_representation.rs",
-      "line": 80
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Warns if an integral or floating-point constant is grouped inconsistently with underscores.\n\n **Why is this bad?** Readers may incorrectly interpret inconsistently\n grouped digits.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n // Bad\n let x: u64 = 618_64_9189_73_511;\n\n // Good\n let x: u64 = 61_864_918_973_511;\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "unusual_byte_groupings",
-    "id_span": {
-      "path": "src/literal_representation.rs",
-      "line": 99
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Warns if hexadecimal or binary literals are not grouped by nibble or byte.\n\n **Why is this bad?** Negatively impacts readability.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n let x: u32 = 0xFFF_FFF;\n let y: u8 = 0b01_011_101;\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "large_digit_groups",
-    "id_span": {
-      "path": "src/literal_representation.rs",
-      "line": 118
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Warns if the digits of an integral or floating-point constant are grouped into groups that\n are too large.\n\n **Why is this bad?** Negatively impacts readability.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n let x: u64 = 6186491_8973511;\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "decimal_literal_representation",
-    "id_span": {
-      "path": "src/literal_representation.rs",
-      "line": 136
-    },
-    "group": "clippy::restriction",
-    "docs": " **What it does:** Warns if there is a better representation for a numeric literal.\n **Why is this bad?** Especially for big powers of 2 a hexadecimal representation is more\n readable than a decimal representation.\n\n **Known problems:** None.\n\n **Example:**\n\n `255` => `0xFF`\n `65_535` => `0xFFFF`\n `4_042_322_160` => `0xF0F0_F0F0`\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "manual_memcpy",
-    "id_span": {
-      "path": "src/loops/mod.rs",
-      "line": 50
-    },
-    "group": "clippy::perf",
-    "docs": " **What it does:** Checks for for-loops that manually copy items between slices that could be optimized by having a memcpy.\n\n **Why is this bad?** It is not as fast as a memcpy.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # let src = vec![1];\n # let mut dst = vec![0; 65];\n for i in 0..src.len() {\n     dst[i + 64] = src[i];\n }\n ```\n Could be written as:\n ```rust\n # let src = vec![1];\n # let mut dst = vec![0; 65];\n dst[64..(src.len() + 64)].clone_from_slice(&src[..]);\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "Unspecified"
-    }
-  },
-  {
-    "id": "needless_range_loop",
-    "id_span": {
-      "path": "src/loops/mod.rs",
-      "line": 78
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for looping over the range of `0..len` of some collection just to get the values by index.\n\n **Why is this bad?** Just iterating the collection itself makes the intent\n more clear and is probably faster.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n let vec = vec!['a', 'b', 'c'];\n for i in 0..vec.len() {\n     println!(\"{}\", vec[i]);\n }\n ```\n Could be written as:\n ```rust\n let vec = vec!['a', 'b', 'c'];\n for i in vec {\n     println!(\"{}\", i);\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "explicit_iter_loop",
-    "id_span": {
-      "path": "src/loops/mod.rs",
-      "line": 107
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Checks for loops on `x.iter()` where `&x` will do, and suggests the latter.\n\n **Why is this bad?** Readability.\n\n **Known problems:** False negatives. We currently only warn on some known\n types.\n\n **Example:**\n ```rust\n // with `y` a `Vec` or slice:\n # let y = vec![1];\n for x in y.iter() {\n     // ..\n }\n ```\n can be rewritten to\n ```rust\n # let y = vec![1];\n for x in &y {\n     // ..\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "explicit_into_iter_loop",
-    "id_span": {
-      "path": "src/loops/mod.rs",
-      "line": 135
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Checks for loops on `y.into_iter()` where `y` will do, and suggests the latter.\n\n **Why is this bad?** Readability.\n\n **Known problems:** None\n\n **Example:**\n ```rust\n # let y = vec![1];\n // with `y` a `Vec` or slice:\n for x in y.into_iter() {\n     // ..\n }\n ```\n can be rewritten to\n ```rust\n # let y = vec![1];\n for x in y {\n     // ..\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "iter_next_loop",
-    "id_span": {
-      "path": "src/loops/mod.rs",
-      "line": 158
-    },
-    "group": "clippy::correctness",
-    "docs": " **What it does:** Checks for loops on `x.next()`.\n **Why is this bad?** `next()` returns either `Some(value)` if there was a\n value, or `None` otherwise. The insidious thing is that `Option<_>`\n implements `IntoIterator`, so that possibly one value will be iterated,\n leading to some hard to find bugs. No one will want to write such code\n [except to win an Underhanded Rust\n Contest](https://www.reddit.com/r/rust/comments/3hb0wm/underhanded_rust_contest/cu5yuhr).\n\n **Known problems:** None.\n\n **Example:**\n ```ignore\n for x in y.next() {\n     ..\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "for_loops_over_fallibles",
-    "id_span": {
-      "path": "src/loops/mod.rs",
-      "line": 201
-    },
-    "group": "clippy::correctness",
-    "docs": " **What it does:** Checks for `for` loops over `Option` or `Result` values.\n **Why is this bad?** Readability. This is more clearly expressed as an `if\n let`.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # let opt = Some(1);\n\n // Bad\n for x in opt {\n     // ..\n }\n\n // Good\n if let Some(x) = opt {\n     // ..\n }\n ```\n\n // or\n\n ```rust\n # let res: Result<i32, std::io::Error> = Ok(1);\n\n // Bad\n for x in &res {\n     // ..\n }\n\n // Good\n if let Ok(x) = res {\n     // ..\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "while_let_loop",
-    "id_span": {
-      "path": "src/loops/mod.rs",
-      "line": 230
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Detects `loop + match` combinations that are easier written as a `while let` loop.\n\n **Why is this bad?** The `while let` loop is usually shorter and more\n readable.\n\n **Known problems:** Sometimes the wrong binding is displayed ([#383](https://github.com/rust-lang/rust-clippy/issues/383)).\n\n **Example:**\n ```rust,no_run\n # let y = Some(1);\n loop {\n     let x = match y {\n         Some(x) => x,\n         None => break,\n     };\n     // .. do something with x\n }\n // is easier written as\n while let Some(x) = y {\n     // .. do something with x\n };\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "HasPlaceholders"
-    }
-  },
-  {
-    "id": "needless_collect",
-    "id_span": {
-      "path": "src/loops/mod.rs",
-      "line": 252
-    },
-    "group": "clippy::perf",
-    "docs": " **What it does:** Checks for functions collecting an iterator when collect is not needed.\n\n **Why is this bad?** `collect` causes the allocation of a new data structure,\n when this allocation may not be needed.\n\n **Known problems:**\n None\n\n **Example:**\n ```rust\n # let iterator = vec![1].into_iter();\n let len = iterator.clone().collect::<Vec<_>>().len();\n // should be\n let len = iterator.count();\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": true,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "explicit_counter_loop",
-    "id_span": {
-      "path": "src/loops/mod.rs",
-      "line": 282
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks `for` loops over slices with an explicit counter and suggests the use of `.enumerate()`.\n\n **Why is it bad?** Using `.enumerate()` makes the intent more clear,\n declutters the code and may be faster in some instances.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # let v = vec![1];\n # fn bar(bar: usize, baz: usize) {}\n let mut i = 0;\n for item in &v {\n     bar(i, *item);\n     i += 1;\n }\n ```\n Could be written as\n ```rust\n # let v = vec![1];\n # fn bar(bar: usize, baz: usize) {}\n for (i, item) in v.iter().enumerate() { bar(i, *item); }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "empty_loop",
-    "id_span": {
-      "path": "src/loops/mod.rs",
-      "line": 315
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for empty `loop` expressions.\n **Why is this bad?** These busy loops burn CPU cycles without doing\n anything. It is _almost always_ a better idea to `panic!` than to have\n a busy loop.\n\n If panicking isn't possible, think of the environment and either:\n   - block on something\n   - sleep the thread for some microseconds\n   - yield or pause the thread\n\n For `std` targets, this can be done with\n [`std::thread::sleep`](https://doc.rust-lang.org/std/thread/fn.sleep.html)\n or [`std::thread::yield_now`](https://doc.rust-lang.org/std/thread/fn.yield_now.html).\n\n For `no_std` targets, doing this is more complicated, especially because\n `#[panic_handler]`s can't panic. To stop/pause the thread, you will\n probably need to invoke some target-specific intrinsic. Examples include:\n   - [`x86_64::instructions::hlt`](https://docs.rs/x86_64/0.12.2/x86_64/instructions/fn.hlt.html)\n   - [`cortex_m::asm::wfi`](https://docs.rs/cortex-m/0.6.3/cortex_m/asm/fn.wfi.html)\n\n **Known problems:** None.\n\n **Example:**\n ```no_run\n loop {}\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "while_let_on_iterator",
-    "id_span": {
-      "path": "src/loops/mod.rs",
-      "line": 334
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for `while let` expressions on iterators.\n **Why is this bad?** Readability. A simple `for` loop is shorter and conveys\n the intent better.\n\n **Known problems:** None.\n\n **Example:**\n ```ignore\n while let Some(val) = iter() {\n     ..\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "for_kv_map",
-    "id_span": {
-      "path": "src/loops/mod.rs",
-      "line": 362
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for iterating a map (`HashMap` or `BTreeMap`) and ignoring either the keys or values.\n\n **Why is this bad?** Readability. There are `keys` and `values` methods that\n can be used to express that don't need the values or keys.\n\n **Known problems:** None.\n\n **Example:**\n ```ignore\n for (k, _) in &map {\n     ..\n }\n ```\n\n could be replaced by\n\n ```ignore\n for k in map.keys() {\n     ..\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "never_loop",
-    "id_span": {
-      "path": "src/loops/mod.rs",
-      "line": 383
-    },
-    "group": "clippy::correctness",
-    "docs": " **What it does:** Checks for loops that will always `break`, `return` or `continue` an outer loop.\n\n **Why is this bad?** This loop never loops, all it does is obfuscating the\n code.\n\n **Known problems:** None\n\n **Example:**\n ```rust\n loop {\n     ..;\n     break;\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "mut_range_bound",
-    "id_span": {
-      "path": "src/loops/mod.rs",
-      "line": 403
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks for loops which have a range bound that is a mutable variable\n **Why is this bad?** One might think that modifying the mutable variable changes the loop bounds\n\n **Known problems:** None\n\n **Example:**\n ```rust\n let mut foo = 42;\n for i in 0..foo {\n     foo -= 1;\n     println!(\"{}\", i); // prints numbers from 0 to 42, not 0 to 21\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "while_immutable_condition",
-    "id_span": {
-      "path": "src/loops/mod.rs",
-      "line": 426
-    },
-    "group": "clippy::correctness",
-    "docs": " **What it does:** Checks whether variables used within while loop condition can be (and are) mutated in the body.\n\n **Why is this bad?** If the condition is unchanged, entering the body of the loop\n will lead to an infinite loop.\n\n **Known problems:** If the `while`-loop is in a closure, the check for mutation of the\n condition variables in the body can cause false negatives. For example when only `Upvar` `a` is\n in the condition and only `Upvar` `b` gets mutated in the body, the lint will not trigger.\n\n **Example:**\n ```rust\n let i = 0;\n while i > 10 {\n     println!(\"let me loop forever!\");\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "same_item_push",
-    "id_span": {
-      "path": "src/loops/mod.rs",
-      "line": 459
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks whether a for loop is being used to push a constant value into a Vec.\n\n **Why is this bad?** This kind of operation can be expressed more succinctly with\n `vec![item;SIZE]` or `vec.resize(NEW_SIZE, item)` and using these alternatives may also\n have better performance.\n **Known problems:** None\n\n **Example:**\n ```rust\n let item1 = 2;\n let item2 = 3;\n let mut vec: Vec<u8> = Vec::new();\n for _ in 0..20 {\n    vec.push(item1);\n }\n for _ in 0..30 {\n     vec.push(item2);\n }\n ```\n could be written as\n ```rust\n let item1 = 2;\n let item2 = 3;\n let mut vec: Vec<u8> = vec![item1; 20];\n vec.resize(20 + 30, item2);\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "single_element_loop",
-    "id_span": {
-      "path": "src/loops/mod.rs",
-      "line": 484
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks whether a for loop has a single element.\n **Why is this bad?** There is no reason to have a loop of a\n single element.\n **Known problems:** None\n\n **Example:**\n ```rust\n let item1 = 2;\n for item in &[item1] {\n     println!(\"{}\", item);\n }\n ```\n could be written as\n ```rust\n let item1 = 2;\n let item = &item1;\n println!(\"{}\", item);\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "manual_flatten",
-    "id_span": {
-      "path": "src/loops/mod.rs",
-      "line": 515
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Check for unnecessary `if let` usage in a for loop where only the `Some` or `Ok` variant of the iterator element is used.\n\n **Why is this bad?** It is verbose and can be simplified\n by first calling the `flatten` method on the `Iterator`.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n let x = vec![Some(1), Some(2), Some(3)];\n for n in x {\n     if let Some(n) = n {\n         println!(\"{}\", n);\n     }\n }\n ```\n Use instead:\n ```rust\n let x = vec![Some(1), Some(2), Some(3)];\n for n in x.into_iter().flatten() {\n     println!(\"{}\", n);\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MaybeIncorrect"
-    }
-  },
-  {
-    "id": "macro_use_imports",
-    "id_span": {
-      "path": "src/macro_use.rs",
-      "line": 25
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Checks for `#[macro_use] use...`.\n **Why is this bad?** Since the Rust 2018 edition you can import\n macro's directly, this is considered idiomatic.\n\n **Known problems:** None.\n\n **Example:**\n ```rust,ignore\n #[macro_use]\n use some_macro;\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MaybeIncorrect"
-    }
-  },
-  {
-    "id": "main_recursion",
-    "id_span": {
-      "path": "src/main_recursion.rs",
-      "line": 22
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for recursion using the entrypoint.\n **Why is this bad?** Apart from special setups (which we could detect following attributes like #![no_std]),\n recursing into main() seems like an unintuitive antipattern we should be able to detect.\n\n **Known problems:** None.\n\n **Example:**\n ```no_run\n fn main() {\n     main();\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "manual_async_fn",
-    "id_span": {
-      "path": "src/manual_async_fn.rs",
-      "line": 32
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** It checks for manual implementations of `async` functions.\n **Why is this bad?** It's more idiomatic to use the dedicated syntax.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n use std::future::Future;\n\n fn foo() -> impl Future<Output = i32> { async { 42 } }\n ```\n Use instead:\n ```rust\n async fn foo() -> i32 { 42 }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": true,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "manual_map",
-    "id_span": {
-      "path": "src/manual_map.rs",
-      "line": 44
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for usages of `match` which could be implemented using `map`\n **Why is this bad?** Using the `map` method is clearer and more concise.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n match Some(0) {\n     Some(x) => Some(x + 1),\n     None => None,\n };\n ```\n Use instead:\n ```rust\n Some(0).map(|x| x + 1);\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "manual_non_exhaustive",
-    "id_span": {
-      "path": "src/manual_non_exhaustive.rs",
-      "line": 56
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for manual implementations of the non-exhaustive pattern.\n **Why is this bad?** Using the #[non_exhaustive] attribute expresses better the intent\n and allows possible optimizations when applied to enums.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n struct S {\n     pub a: i32,\n     pub b: i32,\n     _c: (),\n }\n\n enum E {\n     A,\n     B,\n     #[doc(hidden)]\n     _C,\n }\n\n struct T(pub i32, pub i32, ());\n ```\n Use instead:\n ```rust\n #[non_exhaustive]\n struct S {\n     pub a: i32,\n     pub b: i32,\n }\n\n #[non_exhaustive]\n enum E {\n     A,\n     B,\n }\n\n #[non_exhaustive]\n struct T(pub i32, pub i32);\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "Unspecified"
-    }
-  },
-  {
-    "id": "manual_ok_or",
-    "id_span": {
-      "path": "src/manual_ok_or.rs",
-      "line": 34
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Finds patterns that reimplement `Option::ok_or`.\n\n **Why is this bad?**\n Concise code helps focusing on behavior instead of boilerplate.\n\n **Known problems:** None.\n\n **Examples:**\n ```rust\n let foo: Option<i32> = None;\n foo.map_or(Err(\"error\"), |v| Ok(v));\n ```\n\n Use instead:\n ```rust\n let foo: Option<i32> = None;\n foo.ok_or(\"error\");\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "manual_strip",
-    "id_span": {
-      "path": "src/manual_strip.rs",
-      "line": 52
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Suggests using `strip_{prefix,suffix}` over `str::{starts,ends}_with` and slicing using\n the pattern's length.\n\n **Why is this bad?**\n Using `str:strip_{prefix,suffix}` is safer and may have better performance as there is no\n slicing which may panic and the compiler does not need to insert this panic code. It is\n also sometimes more readable as it removes the need for duplicating or storing the pattern\n used by `str::{starts,ends}_with` and in the slicing.\n\n **Known problems:**\n None.\n\n **Example:**\n\n ```rust\n let s = \"hello, world!\";\n if s.starts_with(\"hello, \") {\n     assert_eq!(s[\"hello, \".len()..].to_uppercase(), \"WORLD!\");\n }\n ```\n Use instead:\n ```rust\n let s = \"hello, world!\";\n if let Some(end) = s.strip_prefix(\"hello, \") {\n     assert_eq!(end.to_uppercase(), \"WORLD!\");\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "manual_unwrap_or",
-    "id_span": {
-      "path": "src/manual_unwrap_or.rs",
-      "line": 36
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Finds patterns that reimplement `Option::unwrap_or` or `Result::unwrap_or`.\n\n **Why is this bad?**\n Concise code helps focusing on behavior instead of boilerplate.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n let foo: Option<i32> = None;\n match foo {\n     Some(v) => v,\n     None => 1,\n };\n ```\n\n Use instead:\n ```rust\n let foo: Option<i32> = None;\n foo.unwrap_or(1);\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "map_clone",
-    "id_span": {
-      "path": "src/map_clone.rs",
-      "line": 40
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for usage of `map(|x| x.clone())` or dereferencing closures for `Copy` types, on `Iterator` or `Option`,\n and suggests `cloned()` or `copied()` instead\n\n **Why is this bad?** Readability, this can be written more concisely\n\n **Known problems:** None\n\n **Example:**\n\n ```rust\n let x = vec![42, 43];\n let y = x.iter();\n let z = y.map(|i| *i);\n ```\n\n The correct use would be:\n\n ```rust\n let x = vec![42, 43];\n let y = x.iter();\n let z = y.cloned();\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "map_err_ignore",
-    "id_span": {
-      "path": "src/map_err_ignore.rs",
-      "line": 101
-    },
-    "group": "clippy::restriction",
-    "docs": " **What it does:** Checks for instances of `map_err(|_| Some::Enum)`\n **Why is this bad?** This `map_err` throws away the original error rather than allowing the enum to contain and report the cause of the error\n\n **Known problems:** None.\n\n **Example:**\n Before:\n ```rust\n use std::fmt;\n\n #[derive(Debug)]\n enum Error {\n     Indivisible,\n     Remainder(u8),\n }\n\n impl fmt::Display for Error {\n     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\n         match self {\n             Error::Indivisible => write!(f, \"could not divide input by three\"),\n             Error::Remainder(remainder) => write!(\n                 f,\n                 \"input is not divisible by three, remainder = {}\",\n                 remainder\n             ),\n         }\n     }\n }\n\n impl std::error::Error for Error {}\n\n fn divisible_by_3(input: &str) -> Result<(), Error> {\n     input\n         .parse::<i32>()\n         .map_err(|_| Error::Indivisible)\n         .map(|v| v % 3)\n         .and_then(|remainder| {\n             if remainder == 0 {\n                 Ok(())\n             } else {\n                 Err(Error::Remainder(remainder as u8))\n             }\n         })\n }\n  ```\n\n  After:\n  ```rust\n use std::{fmt, num::ParseIntError};\n\n #[derive(Debug)]\n enum Error {\n     Indivisible(ParseIntError),\n     Remainder(u8),\n }\n\n impl fmt::Display for Error {\n     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\n         match self {\n             Error::Indivisible(_) => write!(f, \"could not divide input by three\"),\n             Error::Remainder(remainder) => write!(\n                 f,\n                 \"input is not divisible by three, remainder = {}\",\n                 remainder\n             ),\n         }\n     }\n }\n\n impl std::error::Error for Error {\n     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {\n         match self {\n             Error::Indivisible(source) => Some(source),\n             _ => None,\n         }\n     }\n }\n\n fn divisible_by_3(input: &str) -> Result<(), Error> {\n     input\n         .parse::<i32>()\n         .map_err(Error::Indivisible)\n         .map(|v| v % 3)\n         .and_then(|remainder| {\n             if remainder == 0 {\n                 Ok(())\n             } else {\n                 Err(Error::Remainder(remainder as u8))\n             }\n         })\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "map_identity",
-    "id_span": {
-      "path": "src/map_identity.rs",
-      "line": 30
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks for instances of `map(f)` where `f` is the identity function.\n **Why is this bad?** It can be written more concisely without the call to `map`.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n let x = [1, 2, 3];\n let y: Vec<_> = x.iter().map(|x| x).map(|x| 2*x).collect();\n ```\n Use instead:\n ```rust\n let x = [1, 2, 3];\n let y: Vec<_> = x.iter().map(|x| 2*x).collect();\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "option_map_unit_fn",
-    "id_span": {
-      "path": "src/map_unit_fn.rs",
-      "line": 48
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks for usage of `option.map(f)` where f is a function or closure that returns the unit type `()`.\n\n **Why is this bad?** Readability, this can be written more clearly with\n an if let statement\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n # fn do_stuff() -> Option<String> { Some(String::new()) }\n # fn log_err_msg(foo: String) -> Option<String> { Some(foo) }\n # fn format_msg(foo: String) -> String { String::new() }\n let x: Option<String> = do_stuff();\n x.map(log_err_msg);\n # let x: Option<String> = do_stuff();\n x.map(|msg| log_err_msg(format_msg(msg)));\n ```\n\n The correct use would be:\n\n ```rust\n # fn do_stuff() -> Option<String> { Some(String::new()) }\n # fn log_err_msg(foo: String) -> Option<String> { Some(foo) }\n # fn format_msg(foo: String) -> String { String::new() }\n let x: Option<String> = do_stuff();\n if let Some(msg) = x {\n     log_err_msg(msg);\n }\n\n # let x: Option<String> = do_stuff();\n if let Some(msg) = x {\n     log_err_msg(format_msg(msg));\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": true,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "result_map_unit_fn",
-    "id_span": {
-      "path": "src/map_unit_fn.rs",
-      "line": 89
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks for usage of `result.map(f)` where f is a function or closure that returns the unit type `()`.\n\n **Why is this bad?** Readability, this can be written more clearly with\n an if let statement\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n # fn do_stuff() -> Result<String, String> { Ok(String::new()) }\n # fn log_err_msg(foo: String) -> Result<String, String> { Ok(foo) }\n # fn format_msg(foo: String) -> String { String::new() }\n let x: Result<String, String> = do_stuff();\n x.map(log_err_msg);\n # let x: Result<String, String> = do_stuff();\n x.map(|msg| log_err_msg(format_msg(msg)));\n ```\n\n The correct use would be:\n\n ```rust\n # fn do_stuff() -> Result<String, String> { Ok(String::new()) }\n # fn log_err_msg(foo: String) -> Result<String, String> { Ok(foo) }\n # fn format_msg(foo: String) -> String { String::new() }\n let x: Result<String, String> = do_stuff();\n if let Ok(msg) = x {\n     log_err_msg(msg);\n };\n # let x: Result<String, String> = do_stuff();\n if let Ok(msg) = x {\n     log_err_msg(format_msg(msg));\n };\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": true,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "match_on_vec_items",
-    "id_span": {
-      "path": "src/match_on_vec_items.rs",
-      "line": 41
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Checks for `match vec[idx]` or `match vec[n..m]`.\n **Why is this bad?** This can panic at runtime.\n\n **Known problems:** None.\n\n **Example:**\n ```rust, no_run\n let arr = vec![0, 1, 2, 3];\n let idx = 1;\n\n // Bad\n match arr[idx] {\n     0 => println!(\"{}\", 0),\n     1 => println!(\"{}\", 3),\n     _ => {},\n }\n ```\n Use instead:\n ```rust, no_run\n let arr = vec![0, 1, 2, 3];\n let idx = 1;\n\n // Good\n match arr.get(idx) {\n     Some(0) => println!(\"{}\", 0),\n     Some(1) => println!(\"{}\", 3),\n     _ => {},\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MaybeIncorrect"
-    }
-  },
-  {
-    "id": "single_match",
-    "id_span": {
-      "path": "src/matches.rs",
-      "line": 55
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for matches with a single arm where an `if let` will usually suffice.\n\n **Why is this bad?** Just readability – `if let` nests less than a `match`.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # fn bar(stool: &str) {}\n # let x = Some(\"abc\");\n // Bad\n match x {\n     Some(ref foo) => bar(foo),\n     _ => (),\n }\n\n // Good\n if let Some(ref foo) = x {\n     bar(foo);\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "HasPlaceholders"
-    }
-  },
-  {
-    "id": "single_match_else",
-    "id_span": {
-      "path": "src/matches.rs",
-      "line": 94
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Checks for matches with two arms where an `if let else` will usually suffice.\n\n **Why is this bad?** Just readability – `if let` nests less than a `match`.\n\n **Known problems:** Personal style preferences may differ.\n\n **Example:**\n\n Using `match`:\n\n ```rust\n # fn bar(foo: &usize) {}\n # let other_ref: usize = 1;\n # let x: Option<&usize> = Some(&1);\n match x {\n     Some(ref foo) => bar(foo),\n     _ => bar(&other_ref),\n }\n ```\n\n Using `if let` with `else`:\n\n ```rust\n # fn bar(foo: &usize) {}\n # let other_ref: usize = 1;\n # let x: Option<&usize> = Some(&1);\n if let Some(ref foo) = x {\n     bar(foo);\n } else {\n     bar(&other_ref);\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "HasPlaceholders"
-    }
-  },
-  {
-    "id": "match_ref_pats",
-    "id_span": {
-      "path": "src/matches.rs",
-      "line": 125
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for matches where all arms match a reference, suggesting to remove the reference and deref the matched expression\n instead. It also checks for `if let &foo = bar` blocks.\n\n **Why is this bad?** It just makes the code less readable. That reference\n destructuring adds nothing to the code.\n\n **Known problems:** None.\n\n **Example:**\n ```rust,ignore\n // Bad\n match x {\n     &A(ref y) => foo(y),\n     &B => bar(),\n     _ => frob(&x),\n }\n\n // Good\n match *x {\n     A(ref y) => foo(y),\n     B => bar(),\n     _ => frob(x),\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "match_bool",
-    "id_span": {
-      "path": "src/matches.rs",
-      "line": 159
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Checks for matches where match expression is a `bool`. It suggests to replace the expression with an `if...else` block.\n\n **Why is this bad?** It makes the code less readable.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # fn foo() {}\n # fn bar() {}\n let condition: bool = true;\n match condition {\n     true => foo(),\n     false => bar(),\n }\n ```\n Use if/else instead:\n ```rust\n # fn foo() {}\n # fn bar() {}\n let condition: bool = true;\n if condition {\n     foo();\n } else {\n     bar();\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "HasPlaceholders"
-    }
-  },
-  {
-    "id": "match_overlapping_arm",
-    "id_span": {
-      "path": "src/matches.rs",
-      "line": 181
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for overlapping match arms.\n **Why is this bad?** It is likely to be an error and if not, makes the code\n less obvious.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n let x = 5;\n match x {\n     1...10 => println!(\"1 ... 10\"),\n     5...15 => println!(\"5 ... 15\"),\n     _ => (),\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "match_wild_err_arm",
-    "id_span": {
-      "path": "src/matches.rs",
-      "line": 203
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Checks for arm which matches all errors with `Err(_)` and take drastic actions like `panic!`.\n\n **Why is this bad?** It is generally a bad practice, similar to\n catching all exceptions in java with `catch(Exception)`\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n let x: Result<i32, &str> = Ok(3);\n match x {\n     Ok(_) => println!(\"ok\"),\n     Err(_) => panic!(\"err\"),\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "match_as_ref",
-    "id_span": {
-      "path": "src/matches.rs",
-      "line": 229
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks for match which is used to add a reference to an `Option` value.\n\n **Why is this bad?** Using `as_ref()` or `as_mut()` instead is shorter.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n let x: Option<()> = None;\n\n // Bad\n let r: Option<&()> = match x {\n     None => None,\n     Some(ref v) => Some(v),\n };\n\n // Good\n let r: Option<&()> = x.as_ref();\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "wildcard_enum_match_arm",
-    "id_span": {
-      "path": "src/matches.rs",
-      "line": 258
-    },
-    "group": "clippy::restriction",
-    "docs": " **What it does:** Checks for wildcard enum matches using `_`.\n **Why is this bad?** New enum variants added by library updates can be missed.\n\n **Known problems:** Suggested replacements may be incorrect if guards exhaustively cover some\n variants, and also may not use correct path to enum if it's not present in the current scope.\n\n **Example:**\n ```rust\n # enum Foo { A(usize), B(usize) }\n # let x = Foo::B(1);\n // Bad\n match x {\n     Foo::A(_) => {},\n     _ => {},\n }\n\n // Good\n match x {\n     Foo::A(_) => {},\n     Foo::B(_) => {},\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MaybeIncorrect"
-    }
-  },
-  {
-    "id": "match_wildcard_for_single_variants",
-    "id_span": {
-      "path": "src/matches.rs",
-      "line": 290
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Checks for wildcard enum matches for a single variant.\n **Why is this bad?** New enum variants added by library updates can be missed.\n\n **Known problems:** Suggested replacements may not use correct path to enum\n if it's not present in the current scope.\n\n **Example:**\n\n ```rust\n # enum Foo { A, B, C }\n # let x = Foo::B;\n // Bad\n match x {\n     Foo::A => {},\n     Foo::B => {},\n     _ => {},\n }\n\n // Good\n match x {\n     Foo::A => {},\n     Foo::B => {},\n     Foo::C => {},\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MaybeIncorrect"
-    }
-  },
-  {
-    "id": "wildcard_in_or_patterns",
-    "id_span": {
-      "path": "src/matches.rs",
-      "line": 317
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks for wildcard pattern used with others patterns in same match arm.\n **Why is this bad?** Wildcard pattern already covers any other pattern as it will match anyway.\n It makes the code less readable, especially to spot wildcard pattern use in match arm.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n // Bad\n match \"foo\" {\n     \"a\" => {},\n     \"bar\" | _ => {},\n }\n\n // Good\n match \"foo\" {\n     \"a\" => {},\n     _ => {},\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "infallible_destructuring_match",
-    "id_span": {
-      "path": "src/matches.rs",
-      "line": 352
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for matches being used to destructure a single-variant enum or tuple struct where a `let` will suffice.\n\n **Why is this bad?** Just readability – `let` doesn't nest, whereas a `match` does.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n enum Wrapper {\n     Data(i32),\n }\n\n let wrapper = Wrapper::Data(42);\n\n let data = match wrapper {\n     Wrapper::Data(i) => i,\n };\n ```\n\n The correct use would be:\n ```rust\n enum Wrapper {\n     Data(i32),\n }\n\n let wrapper = Wrapper::Data(42);\n let Wrapper::Data(data) = wrapper;\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "match_single_binding",
-    "id_span": {
-      "path": "src/matches.rs",
-      "line": 380
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks for useless match that binds to only one value.\n **Why is this bad?** Readability and needless complexity.\n\n **Known problems:**  Suggested replacements may be incorrect when `match`\n is actually binding temporary value, bringing a 'dropped while borrowed' error.\n\n **Example:**\n ```rust\n # let a = 1;\n # let b = 2;\n\n // Bad\n match (a, b) {\n     (c, d) => {\n         // useless match\n     }\n }\n\n // Good\n let (c, d) = (a, b);\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "rest_pat_in_fully_bound_structs",
-    "id_span": {
-      "path": "src/matches.rs",
-      "line": 410
-    },
-    "group": "clippy::restriction",
-    "docs": " **What it does:** Checks for unnecessary '..' pattern binding on struct when all fields are explicitly matched.\n **Why is this bad?** Correctness and readability. It's like having a wildcard pattern after\n matching all enum variants explicitly.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # struct A { a: i32 }\n let a = A { a: 5 };\n\n // Bad\n match a {\n     A { a: 5, .. } => {},\n     _ => {},\n }\n\n // Good\n match a {\n     A { a: 5 } => {},\n     _ => {},\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "redundant_pattern_matching",
-    "id_span": {
-      "path": "src/matches.rs",
-      "line": 458
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Lint for redundant pattern matching over `Result`, `Option`, `std::task::Poll` or `std::net::IpAddr`\n\n **Why is this bad?** It's more concise and clear to just use the proper\n utility function\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n # use std::task::Poll;\n # use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};\n if let Ok(_) = Ok::<i32, i32>(42) {}\n if let Err(_) = Err::<i32, i32>(42) {}\n if let None = None::<()> {}\n if let Some(_) = Some(42) {}\n if let Poll::Pending = Poll::Pending::<()> {}\n if let Poll::Ready(_) = Poll::Ready(42) {}\n if let IpAddr::V4(_) = IpAddr::V4(Ipv4Addr::LOCALHOST) {}\n if let IpAddr::V6(_) = IpAddr::V6(Ipv6Addr::LOCALHOST) {}\n match Ok::<i32, i32>(42) {\n     Ok(_) => true,\n     Err(_) => false,\n };\n ```\n\n The more idiomatic use would be:\n\n ```rust\n # use std::task::Poll;\n # use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};\n if Ok::<i32, i32>(42).is_ok() {}\n if Err::<i32, i32>(42).is_err() {}\n if None::<()>.is_none() {}\n if Some(42).is_some() {}\n if Poll::Pending::<()>.is_pending() {}\n if Poll::Ready(42).is_ready() {}\n if IpAddr::V4(Ipv4Addr::LOCALHOST).is_ipv4() {}\n if IpAddr::V6(Ipv6Addr::LOCALHOST).is_ipv6() {}\n Ok::<i32, i32>(42).is_ok();\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MaybeIncorrect"
-    }
-  },
-  {
-    "id": "match_like_matches_macro",
-    "id_span": {
-      "path": "src/matches.rs",
-      "line": 491
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for `match`  or `if let` expressions producing a `bool` that could be written using `matches!`\n\n **Why is this bad?** Readability and needless complexity.\n\n **Known problems:** This lint falsely triggers, if there are arms with\n `cfg` attributes that remove an arm evaluating to `false`.\n\n **Example:**\n ```rust\n let x = Some(5);\n\n // Bad\n let a = match x {\n     Some(0) => true,\n     _ => false,\n };\n\n let a = if let Some(0) = x {\n     true\n } else {\n     false\n };\n\n // Good\n let a = matches!(x, Some(0));\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MaybeIncorrect"
-    }
-  },
-  {
-    "id": "match_same_arms",
-    "id_span": {
-      "path": "src/matches.rs",
-      "line": 532
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Checks for `match` with identical arm bodies.\n **Why is this bad?** This is probably a copy & paste error. If arm bodies\n are the same on purpose, you can factor them\n [using `|`](https://doc.rust-lang.org/book/patterns.html#multiple-patterns).\n\n **Known problems:** False positive possible with order dependent `match`\n (see issue\n [#860](https://github.com/rust-lang/rust-clippy/issues/860)).\n\n **Example:**\n ```rust,ignore\n match foo {\n     Bar => bar(),\n     Quz => quz(),\n     Baz => bar(), // <= oops\n }\n ```\n\n This should probably be\n ```rust,ignore\n match foo {\n     Bar => bar(),\n     Quz => quz(),\n     Baz => baz(), // <= fixed\n }\n ```\n\n or if the original code was not a typo:\n ```rust,ignore\n match foo {\n     Bar | Baz => bar(), // <= shows the intent better\n     Quz => quz(),\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "mem_discriminant_non_enum",
-    "id_span": {
-      "path": "src/mem_discriminant.rs",
-      "line": 25
-    },
-    "group": "clippy::correctness",
-    "docs": " **What it does:** Checks for calls of `mem::discriminant()` on a non-enum type.\n **Why is this bad?** The value of `mem::discriminant()` on non-enum types\n is unspecified.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n use std::mem;\n\n mem::discriminant(&\"hello\");\n mem::discriminant(&&Some(2));\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "mem_forget",
-    "id_span": {
-      "path": "src/mem_forget.rs",
-      "line": 21
-    },
-    "group": "clippy::restriction",
-    "docs": " **What it does:** Checks for usage of `std::mem::forget(t)` where `t` is `Drop`.\n\n **Why is this bad?** `std::mem::forget(t)` prevents `t` from running its\n destructor, possibly causing leaks.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # use std::mem;\n # use std::rc::Rc;\n mem::forget(Rc::new(55))\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "mem_replace_option_with_none",
-    "id_span": {
-      "path": "src/mem_replace.rs",
-      "line": 37
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for `mem::replace()` on an `Option` with `None`.\n\n **Why is this bad?** `Option` already has the method `take()` for\n taking its current value (Some(..) or None) and replacing it with\n `None`.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n use std::mem;\n\n let mut an_option = Some(0);\n let replaced = mem::replace(&mut an_option, None);\n ```\n Is better expressed with:\n ```rust\n let mut an_option = Some(0);\n let taken = an_option.take();\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "mem_replace_with_uninit",
-    "id_span": {
-      "path": "src/mem_replace.rs",
-      "line": 69
-    },
-    "group": "clippy::correctness",
-    "docs": " **What it does:** Checks for `mem::replace(&mut _, mem::uninitialized())` and `mem::replace(&mut _, mem::zeroed())`.\n\n **Why is this bad?** This will lead to undefined behavior even if the\n value is overwritten later, because the uninitialized value may be\n observed in the case of a panic.\n\n **Known problems:** None.\n\n **Example:**\n\n ```\n use std::mem;\n# fn may_panic(v: Vec<i32>) -> Vec<i32> { v }\n\n #[allow(deprecated, invalid_value)]\n fn myfunc (v: &mut Vec<i32>) {\n     let taken_v = unsafe { mem::replace(v, mem::uninitialized()) };\n     let new_v = may_panic(taken_v); // undefined behavior on panic\n     mem::forget(mem::replace(v, new_v));\n }\n ```\n\n The [take_mut](https://docs.rs/take_mut) crate offers a sound solution,\n at the cost of either lazily creating a replacement value or aborting\n on panic, to ensure that the uninitialized value cannot be observed.\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "mem_replace_with_default",
-    "id_span": {
-      "path": "src/mem_replace.rs",
-      "line": 93
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for `std::mem::replace` on a value of type `T` with `T::default()`.\n\n **Why is this bad?** `std::mem` module already has the method `take` to\n take the current value and replace it with the default value of that type.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n let mut text = String::from(\"foo\");\n let replaced = std::mem::replace(&mut text, String::default());\n ```\n Is better expressed with:\n ```rust\n let mut text = String::from(\"foo\");\n let taken = std::mem::take(&mut text);\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "unwrap_used",
-    "id_span": {
-      "path": "src/methods/mod.rs",
-      "line": 84
-    },
-    "group": "clippy::restriction",
-    "docs": " **What it does:** Checks for `.unwrap()` calls on `Option`s and on `Result`s.\n **Why is this bad?** It is better to handle the `None` or `Err` case,\n or at least call `.expect(_)` with a more helpful message. Still, for a lot of\n quick-and-dirty code, `unwrap` is a good choice, which is why this lint is\n `Allow` by default.\n\n `result.unwrap()` will let the thread panic on `Err` values.\n Normally, you want to implement more sophisticated error handling,\n and propagate errors upwards with `?` operator.\n\n Even if you want to panic on errors, not all `Error`s implement good\n messages on display. Therefore, it may be beneficial to look at the places\n where they may get displayed. Activate this lint to do just that.\n\n **Known problems:** None.\n\n **Examples:**\n ```rust\n # let opt = Some(1);\n\n // Bad\n opt.unwrap();\n\n // Good\n opt.expect(\"more helpful message\");\n ```\n\n // or\n\n ```rust\n # let res: Result<usize, ()> = Ok(1);\n\n // Bad\n res.unwrap();\n\n // Good\n res.expect(\"more helpful message\");\n ```\n",
-    "applicability": null
-  },
-  {
-    "id": "expect_used",
-    "id_span": {
-      "path": "src/methods/mod.rs",
-      "line": 126
-    },
-    "group": "clippy::restriction",
-    "docs": " **What it does:** Checks for `.expect()` calls on `Option`s and `Result`s.\n **Why is this bad?** Usually it is better to handle the `None` or `Err` case.\n Still, for a lot of quick-and-dirty code, `expect` is a good choice, which is why\n this lint is `Allow` by default.\n\n `result.expect()` will let the thread panic on `Err`\n values. Normally, you want to implement more sophisticated error handling,\n and propagate errors upwards with `?` operator.\n\n **Known problems:** None.\n\n **Examples:**\n ```rust,ignore\n # let opt = Some(1);\n\n // Bad\n opt.expect(\"one\");\n\n // Good\n let opt = Some(1);\n opt?;\n ```\n\n // or\n\n ```rust\n # let res: Result<usize, ()> = Ok(1);\n\n // Bad\n res.expect(\"one\");\n\n // Good\n res?;\n # Ok::<(), ()>(())\n ```\n",
-    "applicability": null
-  },
-  {
-    "id": "should_implement_trait",
-    "id_span": {
-      "path": "src/methods/mod.rs",
-      "line": 155
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for methods that should live in a trait implementation of a `std` trait (see [llogiq's blog\n post](http://llogiq.github.io/2015/07/30/traits.html) for further\n information) instead of an inherent implementation.\n\n **Why is this bad?** Implementing the traits improve ergonomics for users of\n the code, often with very little cost. Also people seeing a `mul(...)`\n method\n may expect `*` to work equally, so you should have good reason to disappoint\n them.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n struct X;\n impl X {\n     fn add(&self, other: &X) -> X {\n         // ..\n # X\n     }\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "wrong_self_convention",
-    "id_span": {
-      "path": "src/methods/mod.rs",
-      "line": 188
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for methods with certain name prefixes and which doesn't match how self is taken. The actual rules are:\n\n |Prefix |`self` taken          |\n |-------|----------------------|\n |`as_`  |`&self` or `&mut self`|\n |`from_`| none                 |\n |`into_`|`self`                |\n |`is_`  |`&self` or none       |\n |`to_`  |`&self`               |\n\n **Why is this bad?** Consistency breeds readability. If you follow the\n conventions, your users won't be surprised that they, e.g., need to supply a\n mutable reference to a `as_..` function.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # struct X;\n impl X {\n     fn as_str(self) -> &'static str {\n         // ..\n # \"\"\n     }\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "wrong_pub_self_convention",
-    "id_span": {
-      "path": "src/methods/mod.rs",
-      "line": 212
-    },
-    "group": "clippy::restriction",
-    "docs": " **What it does:** This is the same as [`wrong_self_convention`](#wrong_self_convention), but for public items.\n\n **Why is this bad?** See [`wrong_self_convention`](#wrong_self_convention).\n\n **Known problems:** Actually *renaming* the function may break clients if\n the function is part of the public interface. In that case, be mindful of\n the stability guarantees you've given your users.\n\n **Example:**\n ```rust\n # struct X;\n impl<'a> X {\n     pub fn as_str(self) -> &'a str {\n         \"foo\"\n     }\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "ok_expect",
-    "id_span": {
-      "path": "src/methods/mod.rs",
-      "line": 235
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for usage of `ok().expect(..)`.\n **Why is this bad?** Because you usually call `expect()` on the `Result`\n directly to get a better error message.\n\n **Known problems:** The error type needs to implement `Debug`\n\n **Example:**\n ```rust\n # let x = Ok::<_, ()>(());\n\n // Bad\n x.ok().expect(\"why did I do this again?\");\n\n // Good\n x.expect(\"why did I do this again?\");\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "map_unwrap_or",
-    "id_span": {
-      "path": "src/methods/mod.rs",
-      "line": 272
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Checks for usage of `option.map(_).unwrap_or(_)` or `option.map(_).unwrap_or_else(_)` or `result.map(_).unwrap_or_else(_)`.\n\n **Why is this bad?** Readability, these can be written more concisely (resp.) as\n `option.map_or(_, _)`, `option.map_or_else(_, _)` and `result.map_or_else(_, _)`.\n\n **Known problems:** The order of the arguments is not in execution order\n\n **Examples:**\n ```rust\n # let x = Some(1);\n\n // Bad\n x.map(|a| a + 1).unwrap_or(0);\n\n // Good\n x.map_or(0, |a| a + 1);\n ```\n\n // or\n\n ```rust\n # let x: Result<usize, ()> = Ok(1);\n # fn some_function(foo: ()) -> usize { 1 }\n\n // Bad\n x.map(|a| a + 1).unwrap_or_else(some_function);\n\n // Good\n x.map_or_else(some_function, |a| a + 1);\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "option_map_or_none",
-    "id_span": {
-      "path": "src/methods/mod.rs",
-      "line": 295
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for usage of `_.map_or(None, _)`.\n **Why is this bad?** Readability, this can be written more concisely as\n `_.and_then(_)`.\n\n **Known problems:** The order of the arguments is not in execution order.\n\n **Example:**\n ```rust\n # let opt = Some(1);\n\n // Bad\n opt.map_or(None, |a| Some(a + 1));\n\n // Good\n opt.and_then(|a| Some(a + 1));\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "result_map_or_into_option",
-    "id_span": {
-      "path": "src/methods/mod.rs",
-      "line": 321
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for usage of `_.map_or(None, Some)`.\n **Why is this bad?** Readability, this can be written more concisely as\n `_.ok()`.\n\n **Known problems:** None.\n\n **Example:**\n\n Bad:\n ```rust\n # let r: Result<u32, &str> = Ok(1);\n assert_eq!(Some(1), r.map_or(None, Some));\n ```\n\n Good:\n ```rust\n # let r: Result<u32, &str> = Ok(1);\n assert_eq!(Some(1), r.ok());\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "bind_instead_of_map",
-    "id_span": {
-      "path": "src/methods/mod.rs",
-      "line": 354
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks for usage of `_.and_then(|x| Some(y))`, `_.and_then(|x| Ok(y))` or `_.or_else(|x| Err(y))`.\n\n **Why is this bad?** Readability, this can be written more concisely as\n `_.map(|x| y)` or `_.map_err(|x| y)`.\n\n **Known problems:** None\n\n **Example:**\n\n ```rust\n # fn opt() -> Option<&'static str> { Some(\"42\") }\n # fn res() -> Result<&'static str, &'static str> { Ok(\"42\") }\n let _ = opt().and_then(|s| Some(s.len()));\n let _ = res().and_then(|s| if s.len() == 42 { Ok(10) } else { Ok(20) });\n let _ = res().or_else(|s| if s.len() == 42 { Err(10) } else { Err(20) });\n ```\n\n The correct use would be:\n\n ```rust\n # fn opt() -> Option<&'static str> { Some(\"42\") }\n # fn res() -> Result<&'static str, &'static str> { Ok(\"42\") }\n let _ = opt().map(|s| s.len());\n let _ = res().map(|s| if s.len() == 42 { 10 } else { 20 });\n let _ = res().map_err(|s| if s.len() == 42 { 10 } else { 20 });\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "filter_next",
-    "id_span": {
-      "path": "src/methods/mod.rs",
-      "line": 377
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks for usage of `_.filter(_).next()`.\n **Why is this bad?** Readability, this can be written more concisely as\n `_.find(_)`.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # let vec = vec![1];\n vec.iter().filter(|x| **x == 0).next();\n ```\n Could be written as\n ```rust\n # let vec = vec![1];\n vec.iter().find(|x| **x == 0);\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "skip_while_next",
-    "id_span": {
-      "path": "src/methods/mod.rs",
-      "line": 400
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks for usage of `_.skip_while(condition).next()`.\n **Why is this bad?** Readability, this can be written more concisely as\n `_.find(!condition)`.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # let vec = vec![1];\n vec.iter().skip_while(|x| **x == 0).next();\n ```\n Could be written as\n ```rust\n # let vec = vec![1];\n vec.iter().find(|x| **x != 0);\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "map_flatten",
-    "id_span": {
-      "path": "src/methods/mod.rs",
-      "line": 423
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Checks for usage of `_.map(_).flatten(_)`,\n **Why is this bad?** Readability, this can be written more concisely as\n `_.flat_map(_)`\n\n **Known problems:**\n\n **Example:**\n ```rust\n let vec = vec![vec![1]];\n\n // Bad\n vec.iter().map(|x| x.iter()).flatten();\n\n // Good\n vec.iter().flat_map(|x| x.iter());\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "filter_map",
-    "id_span": {
-      "path": "src/methods/mod.rs",
-      "line": 452
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Checks for usage of `_.filter(_).map(_)`, `_.filter(_).flat_map(_)`, `_.filter_map(_).flat_map(_)` and similar.\n\n **Why is this bad?** Readability, this can be written more concisely as\n `_.filter_map(_)`.\n\n **Known problems:** Often requires a condition + Option/Iterator creation\n inside the closure.\n\n **Example:**\n ```rust\n let vec = vec![1];\n\n // Bad\n vec.iter().filter(|x| **x == 0).map(|x| *x * 2);\n\n // Good\n vec.iter().filter_map(|x| if *x == 0 {\n     Some(*x * 2)\n } else {\n     None\n });\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "manual_filter_map",
-    "id_span": {
-      "path": "src/methods/mod.rs",
-      "line": 478
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks for usage of `_.filter(_).map(_)` that can be written more simply as `filter_map(_)`.\n\n **Why is this bad?** Redundant code in the `filter` and `map` operations is poor style and\n less performant.\n\n **Known problems:** None.\n\n **Example:**\n Bad:\n ```rust\n (0_i32..10)\n     .filter(|n| n.checked_add(1).is_some())\n     .map(|n| n.checked_add(1).unwrap());\n ```\n\n Good:\n ```rust\n (0_i32..10).filter_map(|n| n.checked_add(1));\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "manual_find_map",
-    "id_span": {
-      "path": "src/methods/mod.rs",
-      "line": 504
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks for usage of `_.find(_).map(_)` that can be written more simply as `find_map(_)`.\n\n **Why is this bad?** Redundant code in the `find` and `map` operations is poor style and\n less performant.\n\n **Known problems:** None.\n\n **Example:**\n Bad:\n ```rust\n (0_i32..10)\n     .find(|n| n.checked_add(1).is_some())\n     .map(|n| n.checked_add(1).unwrap());\n ```\n\n Good:\n ```rust\n (0_i32..10).find_map(|n| n.checked_add(1));\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "filter_map_next",
-    "id_span": {
-      "path": "src/methods/mod.rs",
-      "line": 526
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Checks for usage of `_.filter_map(_).next()`.\n **Why is this bad?** Readability, this can be written more concisely as\n `_.find_map(_)`.\n\n **Known problems:** None\n\n **Example:**\n ```rust\n  (0..3).filter_map(|x| if x == 2 { Some(x) } else { None }).next();\n ```\n Can be written as\n\n ```rust\n  (0..3).find_map(|x| if x == 2 { Some(x) } else { None });\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "flat_map_identity",
-    "id_span": {
-      "path": "src/methods/mod.rs",
-      "line": 548
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks for usage of `flat_map(|x| x)`.\n **Why is this bad?** Readability, this can be written more concisely by using `flatten`.\n\n **Known problems:** None\n\n **Example:**\n ```rust\n # let iter = vec![vec![0]].into_iter();\n iter.flat_map(|x| x);\n ```\n Can be written as\n ```rust\n # let iter = vec![vec![0]].into_iter();\n iter.flatten();\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "search_is_some",
-    "id_span": {
-      "path": "src/methods/mod.rs",
-      "line": 572
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks for an iterator or string search (such as `find()`, `position()`, or `rposition()`) followed by a call to `is_some()`.\n\n **Why is this bad?** Readability, this can be written more concisely as\n `_.any(_)` or `_.contains(_)`.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # let vec = vec![1];\n vec.iter().find(|x| **x == 0).is_some();\n ```\n Could be written as\n ```rust\n # let vec = vec![1];\n vec.iter().any(|x| *x == 0);\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "chars_next_cmp",
-    "id_span": {
-      "path": "src/methods/mod.rs",
-      "line": 596
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for usage of `.chars().next()` on a `str` to check if it starts with a given char.\n\n **Why is this bad?** Readability, this can be written more concisely as\n `_.starts_with(_)`.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n let name = \"foo\";\n if name.chars().next() == Some('_') {};\n ```\n Could be written as\n ```rust\n let name = \"foo\";\n if name.starts_with('_') {};\n ```\n",
-    "applicability": null
-  },
-  {
-    "id": "or_fun_call",
-    "id_span": {
-      "path": "src/methods/mod.rs",
-      "line": 627
-    },
-    "group": "clippy::perf",
-    "docs": " **What it does:** Checks for calls to `.or(foo(..))`, `.unwrap_or(foo(..))`, etc., and suggests to use `or_else`, `unwrap_or_else`, etc., or\n `unwrap_or_default` instead.\n\n **Why is this bad?** The function will always be called and potentially\n allocate an object acting as the default.\n\n **Known problems:** If the function has side-effects, not calling it will\n change the semantic of the program, but you shouldn't rely on that anyway.\n\n **Example:**\n ```rust\n # let foo = Some(String::new());\n foo.unwrap_or(String::new());\n ```\n this can instead be written:\n ```rust\n # let foo = Some(String::new());\n foo.unwrap_or_else(String::new);\n ```\n or\n ```rust\n # let foo = Some(String::new());\n foo.unwrap_or_default();\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "HasPlaceholders"
-    }
-  },
-  {
-    "id": "expect_fun_call",
-    "id_span": {
-      "path": "src/methods/mod.rs",
-      "line": 662
-    },
-    "group": "clippy::perf",
-    "docs": " **What it does:** Checks for calls to `.expect(&format!(...))`, `.expect(foo(..))`, etc., and suggests to use `unwrap_or_else` instead\n\n **Why is this bad?** The function will always be called.\n\n **Known problems:** If the function has side-effects, not calling it will\n change the semantics of the program, but you shouldn't rely on that anyway.\n\n **Example:**\n ```rust\n # let foo = Some(String::new());\n # let err_code = \"418\";\n # let err_msg = \"I'm a teapot\";\n foo.expect(&format!(\"Err {}: {}\", err_code, err_msg));\n ```\n or\n ```rust\n # let foo = Some(String::new());\n # let err_code = \"418\";\n # let err_msg = \"I'm a teapot\";\n foo.expect(format!(\"Err {}: {}\", err_code, err_msg).as_str());\n ```\n this can instead be written:\n ```rust\n # let foo = Some(String::new());\n # let err_code = \"418\";\n # let err_msg = \"I'm a teapot\";\n foo.unwrap_or_else(|| panic!(\"Err {}: {}\", err_code, err_msg));\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "clone_on_copy",
-    "id_span": {
-      "path": "src/methods/mod.rs",
-      "line": 679
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks for usage of `.clone()` on a `Copy` type.\n **Why is this bad?** The only reason `Copy` types implement `Clone` is for\n generics, not for using the `clone` method on a concrete type.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n 42u64.clone();\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "clone_on_ref_ptr",
-    "id_span": {
-      "path": "src/methods/mod.rs",
-      "line": 704
-    },
-    "group": "clippy::restriction",
-    "docs": " **What it does:** Checks for usage of `.clone()` on a ref-counted pointer, (`Rc`, `Arc`, `rc::Weak`, or `sync::Weak`), and suggests calling Clone via unified\n function syntax instead (e.g., `Rc::clone(foo)`).\n\n **Why is this bad?** Calling '.clone()' on an Rc, Arc, or Weak\n can obscure the fact that only the pointer is being cloned, not the underlying\n data.\n\n **Example:**\n ```rust\n # use std::rc::Rc;\n let x = Rc::new(1);\n\n // Bad\n x.clone();\n\n // Good\n Rc::clone(&x);\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "Unspecified"
-    }
-  },
-  {
-    "id": "clone_double_ref",
-    "id_span": {
-      "path": "src/methods/mod.rs",
-      "line": 726
-    },
-    "group": "clippy::correctness",
-    "docs": " **What it does:** Checks for usage of `.clone()` on an `&&T`.\n **Why is this bad?** Cloning an `&&T` copies the inner `&T`, instead of\n cloning the underlying `T`.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n fn main() {\n     let x = vec![1];\n     let y = &&x;\n     let z = y.clone();\n     println!(\"{:p} {:p}\", *y, z); // prints out the same pointer\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": true,
-      "applicability": "MaybeIncorrect"
-    }
-  },
-  {
-    "id": "inefficient_to_string",
-    "id_span": {
-      "path": "src/methods/mod.rs",
-      "line": 749
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Checks for usage of `.to_string()` on an `&&T` where `T` implements `ToString` directly (like `&&str` or `&&String`).\n\n **Why is this bad?** This bypasses the specialized implementation of\n `ToString` and instead goes through the more expensive string formatting\n facilities.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n // Generic implementation for `T: Display` is used (slow)\n [\"foo\", \"bar\"].iter().map(|s| s.to_string());\n\n // OK, the specialized impl is used\n [\"foo\", \"bar\"].iter().map(|&s| s.to_string());\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "new_ret_no_self",
-    "id_span": {
-      "path": "src/methods/mod.rs",
-      "line": 810
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for `new` not returning a type that contains `Self`.\n **Why is this bad?** As a convention, `new` methods are used to make a new\n instance of a type.\n\n **Known problems:** None.\n\n **Example:**\n In an impl block:\n ```rust\n # struct Foo;\n # struct NotAFoo;\n impl Foo {\n     fn new() -> NotAFoo {\n # NotAFoo\n     }\n }\n ```\n\n ```rust\n # struct Foo;\n struct Bar(Foo);\n impl Foo {\n     // Bad. The type name must contain `Self`\n     fn new() -> Bar {\n # Bar(Foo)\n     }\n }\n ```\n\n ```rust\n # struct Foo;\n # struct FooError;\n impl Foo {\n     // Good. Return type contains `Self`\n     fn new() -> Result<Foo, FooError> {\n # Ok(Foo)\n     }\n }\n ```\n\n Or in a trait definition:\n ```rust\n pub trait Trait {\n     // Bad. The type name must contain `Self`\n     fn new();\n }\n ```\n\n ```rust\n pub trait Trait {\n     // Good. Return type contains `Self`\n     fn new() -> Self;\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "single_char_pattern",
-    "id_span": {
-      "path": "src/methods/mod.rs",
-      "line": 831
-    },
-    "group": "clippy::perf",
-    "docs": " **What it does:** Checks for string methods that receive a single-character `str` as an argument, e.g., `_.split(\"x\")`.\n\n **Why is this bad?** Performing these methods using a `char` is faster than\n using a `str`.\n\n **Known problems:** Does not catch multi-byte unicode characters.\n\n **Example:**\n ```rust,ignore\n // Bad\n _.split(\"x\");\n\n // Good\n _.split('x');\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "iterator_step_by_zero",
-    "id_span": {
-      "path": "src/methods/mod.rs",
-      "line": 850
-    },
-    "group": "clippy::correctness",
-    "docs": " **What it does:** Checks for calling `.step_by(0)` on iterators which panics.\n **Why is this bad?** This very much looks like an oversight. Use `panic!()` instead if you\n actually intend to panic.\n\n **Known problems:** None.\n\n **Example:**\n ```rust,should_panic\n for x in (0..100).step_by(0) {\n     //..\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "iter_nth_zero",
-    "id_span": {
-      "path": "src/methods/mod.rs",
-      "line": 878
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for the use of `iter.nth(0)`.\n **Why is this bad?** `iter.next()` is equivalent to\n `iter.nth(0)`, as they both consume the next element,\n  but is more readable.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n # use std::collections::HashSet;\n // Bad\n # let mut s = HashSet::new();\n # s.insert(1);\n let x = s.iter().nth(0);\n\n // Good\n # let mut s = HashSet::new();\n # s.insert(1);\n let x = s.iter().next();\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "iter_nth",
-    "id_span": {
-      "path": "src/methods/mod.rs",
-      "line": 904
-    },
-    "group": "clippy::perf",
-    "docs": " **What it does:** Checks for use of `.iter().nth()` (and the related `.iter_mut().nth()`) on standard library types with O(1) element access.\n\n **Why is this bad?** `.get()` and `.get_mut()` are more efficient and more\n readable.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n let some_vec = vec![0, 1, 2, 3];\n let bad_vec = some_vec.iter().nth(3);\n let bad_slice = &some_vec[..].iter().nth(3);\n ```\n The correct use would be:\n ```rust\n let some_vec = vec![0, 1, 2, 3];\n let bad_vec = some_vec.get(3);\n let bad_slice = &some_vec[..].get(3);\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "iter_skip_next",
-    "id_span": {
-      "path": "src/methods/mod.rs",
-      "line": 928
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for use of `.skip(x).next()` on iterators.\n **Why is this bad?** `.nth(x)` is cleaner\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n let some_vec = vec![0, 1, 2, 3];\n let bad_vec = some_vec.iter().skip(3).next();\n let bad_slice = &some_vec[..].iter().skip(3).next();\n ```\n The correct use would be:\n ```rust\n let some_vec = vec![0, 1, 2, 3];\n let bad_vec = some_vec.iter().nth(3);\n let bad_slice = &some_vec[..].iter().nth(3);\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "get_unwrap",
-    "id_span": {
-      "path": "src/methods/mod.rs",
-      "line": 961
-    },
-    "group": "clippy::restriction",
-    "docs": " **What it does:** Checks for use of `.get().unwrap()` (or `.get_mut().unwrap`) on a standard library type which implements `Index`\n\n **Why is this bad?** Using the Index trait (`[]`) is more clear and more\n concise.\n\n **Known problems:** Not a replacement for error handling: Using either\n `.unwrap()` or the Index trait (`[]`) carries the risk of causing a `panic`\n if the value being accessed is `None`. If the use of `.get().unwrap()` is a\n temporary placeholder for dealing with the `Option` type, then this does\n not mitigate the need for error handling. If there is a chance that `.get()`\n will be `None` in your program, then it is advisable that the `None` case\n is handled in a future refactor instead of using `.unwrap()` or the Index\n trait.\n\n **Example:**\n ```rust\n let mut some_vec = vec![0, 1, 2, 3];\n let last = some_vec.get(3).unwrap();\n *some_vec.get_mut(0).unwrap() = 1;\n ```\n The correct use would be:\n ```rust\n let mut some_vec = vec![0, 1, 2, 3];\n let last = some_vec[3];\n some_vec[0] = 1;\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "string_extend_chars",
-    "id_span": {
-      "path": "src/methods/mod.rs",
-      "line": 990
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for the use of `.extend(s.chars())` where s is a `&str` or `String`.\n\n **Why is this bad?** `.push_str(s)` is clearer\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n let abc = \"abc\";\n let def = String::from(\"def\");\n let mut s = String::new();\n s.extend(abc.chars());\n s.extend(def.chars());\n ```\n The correct use would be:\n ```rust\n let abc = \"abc\";\n let def = String::from(\"def\");\n let mut s = String::new();\n s.push_str(abc);\n s.push_str(&def);\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "iter_cloned_collect",
-    "id_span": {
-      "path": "src/methods/mod.rs",
-      "line": 1013
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for the use of `.cloned().collect()` on slice to create a `Vec`.\n\n **Why is this bad?** `.to_vec()` is clearer\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n let s = [1, 2, 3, 4, 5];\n let s2: Vec<isize> = s[..].iter().cloned().collect();\n ```\n The better use would be:\n ```rust\n let s = [1, 2, 3, 4, 5];\n let s2: Vec<isize> = s.to_vec();\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "chars_last_cmp",
-    "id_span": {
-      "path": "src/methods/mod.rs",
-      "line": 1037
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for usage of `_.chars().last()` or `_.chars().next_back()` on a `str` to check if it ends with a given char.\n\n **Why is this bad?** Readability, this can be written more concisely as\n `_.ends_with(_)`.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # let name = \"_\";\n\n // Bad\n name.chars().last() == Some('_') || name.chars().next_back() == Some('-');\n\n // Good\n name.ends_with('_') || name.ends_with('-');\n ```\n",
-    "applicability": null
-  },
-  {
-    "id": "useless_asref",
-    "id_span": {
-      "path": "src/methods/mod.rs",
-      "line": 1062
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks for usage of `.as_ref()` or `.as_mut()` where the types before and after the call are the same.\n\n **Why is this bad?** The call is unnecessary.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # fn do_stuff(x: &[i32]) {}\n let x: &[i32] = &[1, 2, 3, 4, 5];\n do_stuff(x.as_ref());\n ```\n The correct use would be:\n ```rust\n # fn do_stuff(x: &[i32]) {}\n let x: &[i32] = &[1, 2, 3, 4, 5];\n do_stuff(x);\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "unnecessary_fold",
-    "id_span": {
-      "path": "src/methods/mod.rs",
-      "line": 1084
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for using `fold` when a more succinct alternative exists. Specifically, this checks for `fold`s which could be replaced by `any`, `all`,\n `sum` or `product`.\n\n **Why is this bad?** Readability.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n let _ = (0..3).fold(false, |acc, x| acc || x > 2);\n ```\n This could be written as:\n ```rust\n let _ = (0..3).any(|x| x > 2);\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "unnecessary_filter_map",
-    "id_span": {
-      "path": "src/methods/mod.rs",
-      "line": 1113
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks for `filter_map` calls which could be replaced by `filter` or `map`. More specifically it checks if the closure provided is only performing one of the\n filter or map operations and suggests the appropriate option.\n\n **Why is this bad?** Complexity. The intent is also clearer if only a single\n operation is being performed.\n\n **Known problems:** None\n\n **Example:**\n ```rust\n let _ = (0..3).filter_map(|x| if x > 2 { Some(x) } else { None });\n\n // As there is no transformation of the argument this could be written as:\n let _ = (0..3).filter(|&x| x > 2);\n ```\n\n ```rust\n let _ = (0..4).filter_map(|x| Some(x + 1));\n\n // As there is no conditional check on the argument this could be written as:\n let _ = (0..4).map(|x| x + 1);\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "into_iter_on_ref",
-    "id_span": {
-      "path": "src/methods/mod.rs",
-      "line": 1137
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for `into_iter` calls on references which should be replaced by `iter` or `iter_mut`.\n\n **Why is this bad?** Readability. Calling `into_iter` on a reference will not move out its\n content into the resulting iterator, which is confusing. It is better just call `iter` or\n `iter_mut` directly.\n\n **Known problems:** None\n\n **Example:**\n\n ```rust\n // Bad\n let _ = (&vec![3, 4, 5]).into_iter();\n\n // Good\n let _ = (&vec![3, 4, 5]).iter();\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "suspicious_map",
-    "id_span": {
-      "path": "src/methods/mod.rs",
-      "line": 1156
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks for calls to `map` followed by a `count`.\n **Why is this bad?** It looks suspicious. Maybe `map` was confused with `filter`.\n If the `map` call is intentional, this should be rewritten. Or, if you intend to\n drive the iterator to completion, you can just use `for_each` instead.\n\n **Known problems:** None\n\n **Example:**\n\n ```rust\n let _ = (0..3).map(|x| x + 2).count();\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "uninit_assumed_init",
-    "id_span": {
-      "path": "src/methods/mod.rs",
-      "line": 1188
-    },
-    "group": "clippy::correctness",
-    "docs": " **What it does:** Checks for `MaybeUninit::uninit().assume_init()`.\n **Why is this bad?** For most types, this is undefined behavior.\n\n **Known problems:** For now, we accept empty tuples and tuples / arrays\n of `MaybeUninit`. There may be other types that allow uninitialized\n data, but those are not yet rigorously defined.\n\n **Example:**\n\n ```rust\n // Beware the UB\n use std::mem::MaybeUninit;\n\n let _: usize = unsafe { MaybeUninit::uninit().assume_init() };\n ```\n\n Note that the following is OK:\n\n ```rust\n use std::mem::MaybeUninit;\n\n let _: [MaybeUninit<bool>; 5] = unsafe {\n     MaybeUninit::uninit().assume_init()\n };\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "manual_saturating_arithmetic",
-    "id_span": {
-      "path": "src/methods/mod.rs",
-      "line": 1215
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for `.checked_add/sub(x).unwrap_or(MAX/MIN)`.\n **Why is this bad?** These can be written simply with `saturating_add/sub` methods.\n\n **Example:**\n\n ```rust\n # let y: u32 = 0;\n # let x: u32 = 100;\n let add = x.checked_add(y).unwrap_or(u32::MAX);\n let sub = x.checked_sub(y).unwrap_or(u32::MIN);\n ```\n\n can be written using dedicated methods for saturating addition/subtraction as:\n\n ```rust\n # let y: u32 = 0;\n # let x: u32 = 100;\n let add = x.saturating_add(y);\n let sub = x.saturating_sub(y);\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "zst_offset",
-    "id_span": {
-      "path": "src/methods/mod.rs",
-      "line": 1232
-    },
-    "group": "clippy::correctness",
-    "docs": " **What it does:** Checks for `offset(_)`, `wrapping_`{`add`, `sub`}, etc. on raw pointers to zero-sized types\n\n **Why is this bad?** This is a no-op, and likely unintended\n\n **Known problems:** None\n\n **Example:**\n ```rust\n unsafe { (&() as *const ()).offset(1) };\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "filetype_is_file",
-    "id_span": {
-      "path": "src/methods/mod.rs",
-      "line": 1272
-    },
-    "group": "clippy::restriction",
-    "docs": " **What it does:** Checks for `FileType::is_file()`.\n **Why is this bad?** When people testing a file type with `FileType::is_file`\n they are testing whether a path is something they can get bytes from. But\n `is_file` doesn't cover special file types in unix-like systems, and doesn't cover\n symlink in windows. Using `!FileType::is_dir()` is a better way to that intention.\n\n **Example:**\n\n ```rust\n # || {\n let metadata = std::fs::metadata(\"foo.txt\")?;\n let filetype = metadata.file_type();\n\n if filetype.is_file() {\n     // read file\n }\n # Ok::<_, std::io::Error>(())\n # };\n ```\n\n should be written as:\n\n ```rust\n # || {\n let metadata = std::fs::metadata(\"foo.txt\")?;\n let filetype = metadata.file_type();\n\n if !filetype.is_dir() {\n     // read file\n }\n # Ok::<_, std::io::Error>(())\n # };\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "option_as_ref_deref",
-    "id_span": {
-      "path": "src/methods/mod.rs",
-      "line": 1297
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks for usage of `_.as_ref().map(Deref::deref)` or it's aliases (such as String::as_str).\n **Why is this bad?** Readability, this can be written more concisely as\n `_.as_deref()`.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # let opt = Some(\"\".to_string());\n opt.as_ref().map(String::as_str)\n # ;\n ```\n Can be written as\n ```rust\n # let opt = Some(\"\".to_string());\n opt.as_deref()\n # ;\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "iter_next_slice",
-    "id_span": {
-      "path": "src/methods/mod.rs",
-      "line": 1323
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for usage of `iter().next()` on a Slice or an Array\n **Why is this bad?** These can be shortened into `.get()`\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # let a = [1, 2, 3];\n # let b = vec![1, 2, 3];\n a[2..].iter().next();\n b.iter().next();\n ```\n should be written as:\n ```rust\n # let a = [1, 2, 3];\n # let b = vec![1, 2, 3];\n a.get(2);\n b.get(0);\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "single_char_add_str",
-    "id_span": {
-      "path": "src/methods/mod.rs",
-      "line": 1348
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Warns when using `push_str`/`insert_str` with a single-character string literal where `push`/`insert` with a `char` would work fine.\n\n **Why is this bad?** It's less clear that we are pushing a single character.\n\n **Known problems:** None\n\n **Example:**\n ```rust\n let mut string = String::new();\n string.insert_str(0, \"R\");\n string.push_str(\"R\");\n ```\n Could be written as\n ```rust\n let mut string = String::new();\n string.insert(0, 'R');\n string.push('R');\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "unnecessary_lazy_evaluations",
-    "id_span": {
-      "path": "src/methods/mod.rs",
-      "line": 1384
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** As the counterpart to `or_fun_call`, this lint looks for unnecessary lazily evaluated closures on `Option` and `Result`.\n\n This lint suggests changing the following functions, when eager evaluation results in\n simpler code:\n  - `unwrap_or_else` to `unwrap_or`\n  - `and_then` to `and`\n  - `or_else` to `or`\n  - `get_or_insert_with` to `get_or_insert`\n  - `ok_or_else` to `ok_or`\n\n **Why is this bad?** Using eager evaluation is shorter and simpler in some cases.\n\n **Known problems:** It is possible, but not recommended for `Deref` and `Index` to have\n side effects. Eagerly evaluating them can change the semantics of the program.\n\n **Example:**\n\n ```rust\n // example code where clippy issues a warning\n let opt: Option<u32> = None;\n\n opt.unwrap_or_else(|| 42);\n ```\n Use instead:\n ```rust\n let opt: Option<u32> = None;\n\n opt.unwrap_or(42);\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "map_collect_result_unit",
-    "id_span": {
-      "path": "src/methods/mod.rs",
-      "line": 1405
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for usage of `_.map(_).collect::<Result<(), _>()`.\n **Why is this bad?** Using `try_for_each` instead is more readable and idiomatic.\n\n **Known problems:** None\n\n **Example:**\n\n ```rust\n (0..3).map(|t| Err(t)).collect::<Result<(), _>>();\n ```\n Use instead:\n ```rust\n (0..3).try_for_each(|t| Err(t));\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "from_iter_instead_of_collect",
-    "id_span": {
-      "path": "src/methods/mod.rs",
-      "line": 1438
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for `from_iter()` function calls on types that implement the `FromIterator` trait.\n\n **Why is this bad?** It is recommended style to use collect. See\n [FromIterator documentation](https://doc.rust-lang.org/std/iter/trait.FromIterator.html)\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n use std::iter::FromIterator;\n\n let five_fives = std::iter::repeat(5).take(5);\n\n let v = Vec::from_iter(five_fives);\n\n assert_eq!(v, vec![5, 5, 5, 5, 5]);\n ```\n Use instead:\n ```rust\n let five_fives = std::iter::repeat(5).take(5);\n\n let v: Vec<i32> = five_fives.collect();\n\n assert_eq!(v, vec![5, 5, 5, 5, 5]);\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MaybeIncorrect"
-    }
-  },
-  {
-    "id": "inspect_for_each",
-    "id_span": {
-      "path": "src/methods/mod.rs",
-      "line": 1468
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks for usage of `inspect().for_each()`.\n **Why is this bad?** It is the same as performing the computation\n inside `inspect` at the beginning of the closure in `for_each`.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n [1,2,3,4,5].iter()\n .inspect(|&x| println!(\"inspect the number: {}\", x))\n .for_each(|&x| {\n     assert!(x >= 0);\n });\n ```\n Can be written as\n ```rust\n [1,2,3,4,5].iter()\n .for_each(|&x| {\n     println!(\"inspect the number: {}\", x);\n     assert!(x >= 0);\n });\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "filter_map_identity",
-    "id_span": {
-      "path": "src/methods/mod.rs",
-      "line": 1491
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks for usage of `filter_map(|x| x)`.\n **Why is this bad?** Readability, this can be written more concisely by using `flatten`.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n # let iter = vec![Some(1)].into_iter();\n iter.filter_map(|x| x);\n ```\n Use instead:\n ```rust\n # let iter = vec![Some(1)].into_iter();\n iter.flatten();\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "bytes_nth",
-    "id_span": {
-      "path": "src/methods/mod.rs",
-      "line": 1513
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for the use of `.bytes().nth()`.\n **Why is this bad?** `.as_bytes().get()` is more efficient and more\n readable.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n // Bad\n let _ = \"Hello\".bytes().nth(3);\n\n // Good\n let _ = \"Hello\".as_bytes().get(3);\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "implicit_clone",
-    "id_span": {
-      "path": "src/methods/mod.rs",
-      "line": 1539
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Checks for the usage of `_.to_owned()`, `vec.to_vec()`, or similar when calling `_.clone()` would be clearer.\n **Why is this bad?** These methods do the same thing as `_.clone()` but may be confusing as\n to why we are calling `to_vec` on something that is already a `Vec` or calling `to_owned` on something that is already owned.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n let a = vec![1, 2, 3];\n let b = a.to_vec();\n let c = a.to_owned();\n ```\n Use instead:\n ```rust\n let a = vec![1, 2, 3];\n let b = a.clone();\n let c = a.clone();\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "iter_count",
-    "id_span": {
-      "path": "src/methods/mod.rs",
-      "line": 1565
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks for the use of `.iter().count()`.\n **Why is this bad?** `.len()` is more efficient and more\n readable.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n // Bad\n let some_vec = vec![0, 1, 2, 3];\n let _ = some_vec.iter().count();\n let _ = &some_vec[..].iter().count();\n\n // Good\n let some_vec = vec![0, 1, 2, 3];\n let _ = some_vec.len();\n let _ = &some_vec[..].len();\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "min_max",
-    "id_span": {
-      "path": "src/minmax.rs",
-      "line": 28
-    },
-    "group": "clippy::correctness",
-    "docs": " **What it does:** Checks for expressions where `std::cmp::min` and `max` are used to clamp values, but switched so that the result is constant.\n\n **Why is this bad?** This is in all probability not the intended outcome. At\n the least it hurts readability of the code.\n\n **Known problems:** None\n\n **Example:**\n ```ignore\n min(0, max(100, x))\n ```\n or\n ```ignore\n x.max(100).min(0)\n ```\n It will always be equal to `0`. Probably the author meant to clamp the value\n between 0 and 100, but has erroneously swapped `min` and `max`.\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "toplevel_ref_arg",
-    "id_span": {
-      "path": "src/misc.rs",
-      "line": 53
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for function arguments and let bindings denoted as `ref`.\n\n **Why is this bad?** The `ref` declaration makes the function take an owned\n value, but turns the argument into a reference (which means that the value\n is destroyed when exiting the function). This adds not much value: either\n take a reference type, or take an owned value and create references in the\n body.\n\n For let bindings, `let x = &foo;` is preferred over `let ref x = foo`. The\n type of `x` is more obvious with the former.\n\n **Known problems:** If the argument is dereferenced within the function,\n removing the `ref` will lead to errors. This can be fixed by removing the\n dereferences, e.g., changing `*x` to `x` within the function.\n\n **Example:**\n ```rust,ignore\n // Bad\n fn foo(ref x: u8) -> bool {\n     true\n }\n\n // Good\n fn foo(x: &u8) -> bool {\n     true\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "cmp_nan",
-    "id_span": {
-      "path": "src/misc.rs",
-      "line": 76
-    },
-    "group": "clippy::correctness",
-    "docs": " **What it does:** Checks for comparisons to NaN.\n **Why is this bad?** NaN does not compare meaningfully to anything – not\n even itself – so those comparisons are simply wrong.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # let x = 1.0;\n\n // Bad\n if x == f32::NAN { }\n\n // Good\n if x.is_nan() { }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "float_cmp",
-    "id_span": {
-      "path": "src/misc.rs",
-      "line": 109
-    },
-    "group": "clippy::correctness",
-    "docs": " **What it does:** Checks for (in-)equality comparisons on floating-point values (apart from zero), except in functions called `*eq*` (which probably\n implement equality for a type involving floats).\n\n **Why is this bad?** Floating point calculations are usually imprecise, so\n asking if two values are *exactly* equal is asking for trouble. For a good\n guide on what to do, see [the floating point\n guide](http://www.floating-point-gui.de/errors/comparison).\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n let x = 1.2331f64;\n let y = 1.2332f64;\n\n // Bad\n if y == 1.23f64 { }\n if y != x {} // where both are floats\n\n // Good\n let error_margin = f64::EPSILON; // Use an epsilon for comparison\n // Or, if Rust <= 1.42, use `std::f64::EPSILON` constant instead.\n // let error_margin = std::f64::EPSILON;\n if (y - 1.23f64).abs() < error_margin { }\n if (y - x).abs() > error_margin { }\n ```\n",
-    "applicability": null
-  },
-  {
-    "id": "cmp_owned",
-    "id_span": {
-      "path": "src/misc.rs",
-      "line": 136
-    },
-    "group": "clippy::perf",
-    "docs": " **What it does:** Checks for conversions to owned values just for the sake of a comparison.\n\n **Why is this bad?** The comparison can operate on a reference, so creating\n an owned value effectively throws it away directly afterwards, which is\n needlessly consuming code and heap space.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # let x = \"foo\";\n # let y = String::from(\"foo\");\n if x.to_owned() == y {}\n ```\n Could be written as\n ```rust\n # let x = \"foo\";\n # let y = String::from(\"foo\");\n if x == y {}\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "modulo_one",
-    "id_span": {
-      "path": "src/misc.rs",
-      "line": 159
-    },
-    "group": "clippy::correctness",
-    "docs": " **What it does:** Checks for getting the remainder of a division by one or minus one.\n\n **Why is this bad?** The result for a divisor of one can only ever be zero; for\n minus one it can cause panic/overflow (if the left operand is the minimal value of\n the respective integer type) or results in zero. No one will write such code\n deliberately, unless trying to win an Underhanded Rust Contest. Even for that\n contest, it's probably a bad idea. Use something more underhanded.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # let x = 1;\n let a = x % 1;\n let a = x % -1;\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "used_underscore_binding",
-    "id_span": {
-      "path": "src/misc.rs",
-      "line": 181
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Checks for the use of bindings with a single leading underscore.\n\n **Why is this bad?** A single leading underscore is usually used to indicate\n that a binding will not be used. Using such a binding breaks this\n expectation.\n\n **Known problems:** The lint does not work properly with desugaring and\n macro, it has been allowed in the mean time.\n\n **Example:**\n ```rust\n let _x = 0;\n let y = _x + 1; // Here we are using `_x`, even though it has a leading\n                 // underscore. We should rename `_x` to `x`\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "short_circuit_statement",
-    "id_span": {
-      "path": "src/misc.rs",
-      "line": 201
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks for the use of short circuit boolean conditions as a\n statement.\n\n **Why is this bad?** Using a short circuit boolean condition as a statement\n may hide the fact that the second part is executed or not depending on the\n outcome of the first part.\n\n **Known problems:** None.\n\n **Example:**\n ```rust,ignore\n f() && g(); // We should write `if f() { g(); }`.\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "zero_ptr",
-    "id_span": {
-      "path": "src/misc.rs",
-      "line": 223
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Catch casts from `0` to some pointer type\n **Why is this bad?** This generally means `null` and is better expressed as\n {`std`, `core`}`::ptr::`{`null`, `null_mut`}.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n // Bad\n let a = 0 as *const u32;\n\n // Good\n let a = std::ptr::null::<u32>();\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "float_cmp_const",
-    "id_span": {
-      "path": "src/misc.rs",
-      "line": 254
-    },
-    "group": "clippy::restriction",
-    "docs": " **What it does:** Checks for (in-)equality comparisons on floating-point value and constant, except in functions called `*eq*` (which probably\n implement equality for a type involving floats).\n\n **Why is this bad?** Floating point calculations are usually imprecise, so\n asking if two values are *exactly* equal is asking for trouble. For a good\n guide on what to do, see [the floating point\n guide](http://www.floating-point-gui.de/errors/comparison).\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n let x: f64 = 1.0;\n const ONE: f64 = 1.00;\n\n // Bad\n if x == ONE { } // where both are floats\n\n // Good\n let error_margin = f64::EPSILON; // Use an epsilon for comparison\n // Or, if Rust <= 1.42, use `std::f64::EPSILON` constant instead.\n // let error_margin = std::f64::EPSILON;\n if (x - ONE).abs() < error_margin { }\n ```\n",
-    "applicability": null
-  },
-  {
-    "id": "unneeded_field_pattern",
-    "id_span": {
-      "path": "src/misc_early.rs",
-      "line": 44
-    },
-    "group": "clippy::restriction",
-    "docs": " **What it does:** Checks for structure field patterns bound to wildcards.\n **Why is this bad?** Using `..` instead is shorter and leaves the focus on\n the fields that are actually bound.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # struct Foo {\n #     a: i32,\n #     b: i32,\n #     c: i32,\n # }\n let f = Foo { a: 0, b: 0, c: 0 };\n\n // Bad\n match f {\n     Foo { a: _, b: 0, .. } => {},\n     Foo { a: _, b: _, c: _ } => {},\n }\n\n // Good\n match f {\n     Foo { b: 0, .. } => {},\n     Foo { .. } => {},\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "duplicate_underscore_argument",
-    "id_span": {
-      "path": "src/misc_early.rs",
-      "line": 65
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for function arguments having the similar names differing by an underscore.\n\n **Why is this bad?** It affects code readability.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n // Bad\n fn foo(a: i32, _a: i32) {}\n\n // Good\n fn bar(a: i32, _b: i32) {}\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "double_neg",
-    "id_span": {
-      "path": "src/misc_early.rs",
-      "line": 83
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Detects expressions of the form `--x`.\n **Why is this bad?** It can mislead C/C++ programmers to think `x` was\n decremented.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n let mut x = 3;\n --x;\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "mixed_case_hex_literals",
-    "id_span": {
-      "path": "src/misc_early.rs",
-      "line": 104
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Warns on hexadecimal literals with mixed-case letter digits.\n\n **Why is this bad?** It looks confusing.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n // Bad\n let y = 0x1a9BAcD;\n\n // Good\n let y = 0x1A9BACD;\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "unseparated_literal_suffix",
-    "id_span": {
-      "path": "src/misc_early.rs",
-      "line": 125
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Warns if literal suffixes are not separated by an underscore.\n\n **Why is this bad?** It is much less readable.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n // Bad\n let y = 123832i32;\n\n // Good\n let y = 123832_i32;\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "zero_prefixed_literal",
-    "id_span": {
-      "path": "src/misc_early.rs",
-      "line": 163
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Warns if an integral constant literal starts with `0`.\n **Why is this bad?** In some languages (including the infamous C language\n and most of its\n family), this marks an octal constant. In Rust however, this is a decimal\n constant. This could\n be confusing for both the writer and a reader of the constant.\n\n **Known problems:** None.\n\n **Example:**\n\n In Rust:\n ```rust\n fn main() {\n     let a = 0123;\n     println!(\"{}\", a);\n }\n ```\n\n prints `123`, while in C:\n\n ```c\n #include <stdio.h>\n\n int main() {\n     int a = 0123;\n     printf(\"%d\\n\", a);\n }\n ```\n\n prints `83` (as `83 == 0o123` while `123 == 0o173`).\n",
-    "applicability": {
-      "is_multi_suggestion": true,
-      "applicability": "MaybeIncorrect"
-    }
-  },
-  {
-    "id": "builtin_type_shadow",
-    "id_span": {
-      "path": "src/misc_early.rs",
-      "line": 184
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Warns if a generic shadows a built-in type.\n **Why is this bad?** This gives surprising type errors.\n\n **Known problems:** None.\n\n **Example:**\n\n ```ignore\n impl<u32> Foo<u32> {\n     fn impl_func(&self) -> u32 {\n         42\n     }\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "redundant_pattern",
-    "id_span": {
-      "path": "src/misc_early.rs",
-      "line": 213
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for patterns in the form `name @ _`.\n **Why is this bad?** It's almost always more readable to just use direct\n bindings.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # let v = Some(\"abc\");\n\n // Bad\n match v {\n     Some(x) => (),\n     y @ _ => (),\n }\n\n // Good\n match v {\n     Some(x) => (),\n     y => (),\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "unneeded_wildcard_pattern",
-    "id_span": {
-      "path": "src/misc_early.rs",
-      "line": 247
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks for tuple patterns with a wildcard pattern (`_`) is next to a rest pattern (`..`).\n\n _NOTE_: While `_, ..` means there is at least one element left, `..`\n means there are 0 or more elements left. This can make a difference\n when refactoring, but shouldn't result in errors in the refactored code,\n since the wildcard pattern isn't used anyway.\n **Why is this bad?** The wildcard pattern is unneeded as the rest pattern\n can match that element as well.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # struct TupleStruct(u32, u32, u32);\n # let t = TupleStruct(1, 2, 3);\n // Bad\n match t {\n     TupleStruct(0, .., _) => (),\n     _ => (),\n }\n\n // Good\n match t {\n     TupleStruct(0, ..) => (),\n     _ => (),\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "missing_const_for_fn",
-    "id_span": {
-      "path": "src/missing_const_for_fn.rs",
-      "line": 72
-    },
-    "group": "clippy::nursery",
-    "docs": " **What it does:**\n Suggests the use of `const` in functions and methods where possible.\n\n **Why is this bad?**\n\n Not having the function const prevents callers of the function from being const as well.\n\n **Known problems:**\n\n Const functions are currently still being worked on, with some features only being available\n on nightly. This lint does not consider all edge cases currently and the suggestions may be\n incorrect if you are using this lint on stable.\n\n Also, the lint only runs one pass over the code. Consider these two non-const functions:\n\n ```rust\n fn a() -> i32 {\n     0\n }\n fn b() -> i32 {\n     a()\n }\n ```\n\n When running Clippy, the lint will only suggest to make `a` const, because `b` at this time\n can't be const as it calls a non-const function. Making `a` const and running Clippy again,\n will suggest to make `b` const, too.\n\n **Example:**\n\n ```rust\n # struct Foo {\n #     random_number: usize,\n # }\n # impl Foo {\n fn new() -> Self {\n     Self { random_number: 42 }\n }\n # }\n ```\n\n Could be a const fn:\n\n ```rust\n # struct Foo {\n #     random_number: usize,\n # }\n # impl Foo {\n const fn new() -> Self {\n     Self { random_number: 42 }\n }\n # }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "missing_docs_in_private_items",
-    "id_span": {
-      "path": "src/missing_doc.rs",
-      "line": 29
-    },
-    "group": "clippy::restriction",
-    "docs": " **What it does:** Warns if there is missing doc for any documentable item (public or private).\n\n **Why is this bad?** Doc is good. *rustc* has a `MISSING_DOCS`\n allowed-by-default lint for\n public members, but has no way to enforce documentation of private items.\n This lint fixes that.\n\n **Known problems:** None.\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "missing_inline_in_public_items",
-    "id_span": {
-      "path": "src/missing_inline.rs",
-      "line": 55
-    },
-    "group": "clippy::restriction",
-    "docs": " **What it does:** it lints if an exported function, method, trait method with default impl, or trait method impl is not `#[inline]`.\n\n **Why is this bad?** In general, it is not. Functions can be inlined across\n crates when that's profitable as long as any form of LTO is used. When LTO is disabled,\n functions that are not `#[inline]` cannot be inlined across crates. Certain types of crates\n might intend for most of the methods in their public API to be able to be inlined across\n crates even when LTO is disabled. For these types of crates, enabling this lint might make\n sense. It allows the crate to require all exported methods to be `#[inline]` by default, and\n then opt out for specific methods where this might not make sense.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n pub fn foo() {} // missing #[inline]\n fn ok() {} // ok\n #[inline] pub fn bar() {} // ok\n #[inline(always)] pub fn baz() {} // ok\n\n pub trait Bar {\n   fn bar(); // ok\n   fn def_bar() {} // missing #[inline]\n }\n\n struct Baz;\n impl Baz {\n    fn private() {} // ok\n }\n\n impl Bar for Baz {\n   fn bar() {} // ok - Baz is not exported\n }\n\n pub struct PubBaz;\n impl PubBaz {\n    fn private() {} // ok\n    pub fn not_ptrivate() {} // missing #[inline]\n }\n\n impl Bar for PubBaz {\n    fn bar() {} // missing #[inline]\n    fn def_bar() {} // missing #[inline]\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "modulo_arithmetic",
-    "id_span": {
-      "path": "src/modulo_arithmetic.rs",
-      "line": 26
-    },
-    "group": "clippy::restriction",
-    "docs": " **What it does:** Checks for modulo arithmetic.\n **Why is this bad?** The results of modulo (%) operation might differ\n depending on the language, when negative numbers are involved.\n If you interop with different languages it might be beneficial\n to double check all places that use modulo arithmetic.\n\n For example, in Rust `17 % -3 = 2`, but in Python `17 % -3 = -1`.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n let x = -17 % 3;\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "multiple_crate_versions",
-    "id_span": {
-      "path": "src/multiple_crate_versions.rs",
-      "line": 32
-    },
-    "group": "clippy::cargo",
-    "docs": " **What it does:** Checks to see if multiple versions of a crate are being used.\n\n **Why is this bad?** This bloats the size of targets, and can lead to\n confusing error messages when structs or traits are used interchangeably\n between different versions of a crate.\n\n **Known problems:** Because this can be caused purely by the dependencies\n themselves, it's not always possible to fix this issue.\n\n **Example:**\n ```toml\n # This will pull in both winapi v0.3.x and v0.2.x, triggering a warning.\n [dependencies]\n ctrlc = \"=3.1.0\"\n ansi_term = \"=0.11.0\"\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "mutable_key_type",
-    "id_span": {
-      "path": "src/mut_key.rs",
-      "line": 50
-    },
-    "group": "clippy::correctness",
-    "docs": " **What it does:** Checks for sets/maps with mutable key types.\n **Why is this bad?** All of `HashMap`, `HashSet`, `BTreeMap` and\n `BtreeSet` rely on either the hash or the order of keys be unchanging,\n so having types with interior mutability is a bad idea.\n\n **Known problems:** It's correct to use a struct, that contains interior mutability\n as a key, when its `Hash` implementation doesn't access any of the interior mutable types.\n However, this lint is unable to recognize this, so it causes a false positive in theses cases.\n The `bytes` crate is a great example of this.\n\n **Example:**\n ```rust\n use std::cmp::{PartialEq, Eq};\n use std::collections::HashSet;\n use std::hash::{Hash, Hasher};\n use std::sync::atomic::AtomicUsize;\n# #[allow(unused)]\n\n struct Bad(AtomicUsize);\n impl PartialEq for Bad {\n     fn eq(&self, rhs: &Self) -> bool {\n          ..\n ; unimplemented!();\n     }\n }\n\n impl Eq for Bad {}\n\n impl Hash for Bad {\n     fn hash<H: Hasher>(&self, h: &mut H) {\n         ..\n ; unimplemented!();\n     }\n }\n\n fn main() {\n     let _: HashSet<Bad> = HashSet::new();\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "mut_mut",
-    "id_span": {
-      "path": "src/mut_mut.rs",
-      "line": 24
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Checks for instances of `mut mut` references.\n **Why is this bad?** Multiple `mut`s don't add anything meaningful to the\n source. This is either a copy'n'paste error, or it shows a fundamental\n misunderstanding of references.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # let mut y = 1;\n let x = &mut &mut y;\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "mut_mutex_lock",
-    "id_span": {
-      "path": "src/mut_mutex_lock.rs",
-      "line": 40
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for `&mut Mutex::lock` calls\n **Why is this bad?** `Mutex::lock` is less efficient than\n calling `Mutex::get_mut`. In addition you also have a statically\n guarantee that the mutex isn't locked, instead of just a runtime\n guarantee.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n use std::sync::{Arc, Mutex};\n\n let mut value_rc = Arc::new(Mutex::new(42_u8));\n let value_mutex = Arc::get_mut(&mut value_rc).unwrap();\n\n let mut value = value_mutex.lock().unwrap();\n *value += 1;\n ```\n Use instead:\n ```rust\n use std::sync::{Arc, Mutex};\n\n let mut value_rc = Arc::new(Mutex::new(42_u8));\n let value_mutex = Arc::get_mut(&mut value_rc).unwrap();\n\n let value = value_mutex.get_mut().unwrap();\n *value += 1;\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MaybeIncorrect"
-    }
-  },
-  {
-    "id": "unnecessary_mut_passed",
-    "id_span": {
-      "path": "src/mut_reference.rs",
-      "line": 25
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Detects passing a mutable reference to a function that only requires an immutable reference.\n\n **Why is this bad?** The mutable reference rules out all other references to\n the value. Also the code misleads about the intent of the call site.\n\n **Known problems:** None.\n\n **Example:**\n ```ignore\n // Bad\n my_vec.push(&mut value)\n\n // Good\n my_vec.push(&value)\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "debug_assert_with_mut_call",
-    "id_span": {
-      "path": "src/mutable_debug_assertion.rs",
-      "line": 28
-    },
-    "group": "clippy::nursery",
-    "docs": " **What it does:** Checks for function/method calls with a mutable parameter in `debug_assert!`, `debug_assert_eq!` and `debug_assert_ne!` macros.\n\n **Why is this bad?** In release builds `debug_assert!` macros are optimized out by the\n compiler.\n Therefore mutating something in a `debug_assert!` macro results in different behaviour\n between a release and debug build.\n\n **Known problems:** None\n\n **Example:**\n ```rust,ignore\n debug_assert_eq!(vec![3].pop(), Some(3));\n // or\n fn take_a_mut_parameter(_: &mut u32) -> bool { unimplemented!() }\n debug_assert!(take_a_mut_parameter(&mut 5));\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "mutex_atomic",
-    "id_span": {
-      "path": "src/mutex_atomic.rs",
-      "line": 34
-    },
-    "group": "clippy::perf",
-    "docs": " **What it does:** Checks for usages of `Mutex<X>` where an atomic will do.\n **Why is this bad?** Using a mutex just to make access to a plain bool or\n reference sequential is shooting flies with cannons.\n `std::sync::atomic::AtomicBool` and `std::sync::atomic::AtomicPtr` are leaner and\n faster.\n\n **Known problems:** This lint cannot detect if the mutex is actually used\n for waiting before a critical section.\n\n **Example:**\n ```rust\n # let y = true;\n\n // Bad\n # use std::sync::Mutex;\n let x = Mutex::new(&y);\n\n // Good\n # use std::sync::atomic::AtomicBool;\n let x = AtomicBool::new(y);\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "mutex_integer",
-    "id_span": {
-      "path": "src/mutex_atomic.rs",
-      "line": 59
-    },
-    "group": "clippy::nursery",
-    "docs": " **What it does:** Checks for usages of `Mutex<X>` where `X` is an integral type.\n\n **Why is this bad?** Using a mutex just to make access to a plain integer\n sequential is\n shooting flies with cannons. `std::sync::atomic::AtomicUsize` is leaner and faster.\n\n **Known problems:** This lint cannot detect if the mutex is actually used\n for waiting before a critical section.\n\n **Example:**\n ```rust\n # use std::sync::Mutex;\n let x = Mutex::new(0usize);\n\n // Good\n # use std::sync::atomic::AtomicUsize;\n let x = AtomicUsize::new(0usize);\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "needless_arbitrary_self_type",
-    "id_span": {
-      "path": "src/needless_arbitrary_self_type.rs",
-      "line": 55
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** The lint checks for `self` in fn parameters that specify the `Self`-type explicitly\n **Why is this bad?** Increases the amount and decreases the readability of code\n\n **Known problems:** None\n\n **Example:**\n ```rust\n enum ValType {\n     I32,\n     I64,\n     F32,\n     F64,\n }\n\n impl ValType {\n     pub fn bytes(self: Self) -> usize {\n         match self {\n             Self::I32 | Self::F32 => 4,\n             Self::I64 | Self::F64 => 8,\n         }\n     }\n }\n ```\n\n Could be rewritten as\n\n ```rust\n enum ValType {\n     I32,\n     I64,\n     F32,\n     F64,\n }\n\n impl ValType {\n     pub fn bytes(self) -> usize {\n         match self {\n             Self::I32 | Self::F32 => 4,\n             Self::I64 | Self::F64 => 8,\n         }\n     }\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "needless_bool",
-    "id_span": {
-      "path": "src/needless_bool.rs",
-      "line": 38
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks for expressions of the form `if c { true } else { false }` (or vice versa) and suggests using the condition directly.\n\n **Why is this bad?** Redundant code.\n\n **Known problems:** Maybe false positives: Sometimes, the two branches are\n painstakingly documented (which we, of course, do not detect), so they *may*\n have some value. Even then, the documentation can be rewritten to match the\n shorter code.\n\n **Example:**\n ```rust,ignore\n if x {\n     false\n } else {\n     true\n }\n ```\n Could be written as\n ```rust,ignore\n !x\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "bool_comparison",
-    "id_span": {
-      "path": "src/needless_bool.rs",
-      "line": 62
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks for expressions of the form `x == true`, `x != true` and order comparisons such as `x < true` (or vice versa) and\n suggest using the variable directly.\n\n **Why is this bad?** Unnecessary code.\n\n **Known problems:** None.\n\n **Example:**\n ```rust,ignore\n if x == true {}\n if y == false {}\n ```\n use `x` directly:\n ```rust,ignore\n if x {}\n if !y {}\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "needless_borrow",
-    "id_span": {
-      "path": "src/needless_borrow.rs",
-      "line": 32
-    },
-    "group": "clippy::nursery",
-    "docs": " **What it does:** Checks for address of operations (`&`) that are going to be dereferenced immediately by the compiler.\n\n **Why is this bad?** Suggests that the receiver of the expression borrows\n the expression.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n // Bad\n let x: &i32 = &&&&&&5;\n\n // Good\n let x: &i32 = &5;\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "needless_borrowed_reference",
-    "id_span": {
-      "path": "src/needless_borrowed_ref.rs",
-      "line": 48
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks for useless borrowed references.\n **Why is this bad?** It is mostly useless and make the code look more\n complex than it\n actually is.\n\n **Known problems:** It seems that the `&ref` pattern is sometimes useful.\n For instance in the following snippet:\n ```rust,ignore\n enum Animal {\n     Cat(u64),\n     Dog(u64),\n }\n\n fn foo(a: &Animal, b: &Animal) {\n     match (a, b) {\n         (&Animal::Cat(v), k) | (k, &Animal::Cat(v)) => (), // lifetime mismatch error\n         (&Animal::Dog(ref c), &Animal::Dog(_)) => ()\n     }\n }\n ```\n There is a lifetime mismatch error for `k` (indeed a and b have distinct\n lifetime).\n This can be fixed by using the `&ref` pattern.\n However, the code can also be fixed by much cleaner ways\n\n **Example:**\n ```rust\n let mut v = Vec::<String>::new();\n let _ = v.iter_mut().filter(|&ref a| a.is_empty());\n ```\n This closure takes a reference on something that has been matched as a\n reference and\n de-referenced.\n As such, it could just be |a| a.is_empty()\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "needless_continue",
-    "id_span": {
-      "path": "src/needless_continue.rs",
-      "line": 114
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** The lint checks for `if`-statements appearing in loops that contain a `continue` statement in either their main blocks or their\n `else`-blocks, when omitting the `else`-block possibly with some\n rearrangement of code can make the code easier to understand.\n\n **Why is this bad?** Having explicit `else` blocks for `if` statements\n containing `continue` in their THEN branch adds unnecessary branching and\n nesting to the code. Having an else block containing just `continue` can\n also be better written by grouping the statements following the whole `if`\n statement within the THEN block and omitting the else block completely.\n\n **Known problems:** None\n\n **Example:**\n ```rust\n # fn condition() -> bool { false }\n # fn update_condition() {}\n # let x = false;\n while condition() {\n     update_condition();\n     if x {\n         // ...\n     } else {\n         continue;\n     }\n     println!(\"Hello, world\");\n }\n ```\n\n Could be rewritten as\n\n ```rust\n # fn condition() -> bool { false }\n # fn update_condition() {}\n # let x = false;\n while condition() {\n     update_condition();\n     if x {\n         // ...\n         println!(\"Hello, world\");\n     }\n }\n ```\n\n As another example, the following code\n\n ```rust\n # fn waiting() -> bool { false }\n loop {\n     if waiting() {\n         continue;\n     } else {\n         // Do something useful\n     }\n     # break;\n }\n ```\n Could be rewritten as\n\n ```rust\n # fn waiting() -> bool { false }\n loop {\n     if waiting() {\n         continue;\n     }\n     // Do something useful\n     # break;\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "needless_pass_by_value",
-    "id_span": {
-      "path": "src/needless_pass_by_value.rs",
-      "line": 50
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Checks for functions taking arguments by value, but not consuming them in its\n body.\n\n **Why is this bad?** Taking arguments by reference is more flexible and can\n sometimes avoid\n unnecessary allocations.\n\n **Known problems:**\n * This lint suggests taking an argument by reference,\n however sometimes it is better to let users decide the argument type\n (by using `Borrow` trait, for example), depending on how the function is used.\n\n **Example:**\n ```rust\n fn foo(v: Vec<i32>) {\n     assert_eq!(v.len(), 42);\n }\n ```\n should be\n ```rust\n fn foo(v: &[i32]) {\n     assert_eq!(v.len(), 42);\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": true,
-      "applicability": null
-    }
-  },
-  {
-    "id": "needless_question_mark",
-    "id_span": {
-      "path": "src/needless_question_mark.rs",
-      "line": 57
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Suggests alternatives for useless applications of `?` in terminating expressions\n\n **Why is this bad?** There's no reason to use `?` to short-circuit when execution of the body will end there anyway.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n struct TO {\n     magic: Option<usize>,\n }\n\n fn f(to: TO) -> Option<usize> {\n     Some(to.magic?)\n }\n\n struct TR {\n     magic: Result<usize, bool>,\n }\n\n fn g(tr: Result<TR, bool>) -> Result<usize, bool> {\n     tr.and_then(|t| Ok(t.magic?))\n }\n\n ```\n Use instead:\n ```rust\n struct TO {\n     magic: Option<usize>,\n }\n\n fn f(to: TO) -> Option<usize> {\n    to.magic\n }\n\n struct TR {\n     magic: Result<usize, bool>,\n }\n\n fn g(tr: Result<TR, bool>) -> Result<usize, bool> {\n     tr.and_then(|t| t.magic)\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "needless_update",
-    "id_span": {
-      "path": "src/needless_update.rs",
-      "line": 43
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks for needlessly including a base struct on update when all fields are changed anyway.\n\n This lint is not applied to structs marked with\n [non_exhaustive](https://doc.rust-lang.org/reference/attributes/type_system.html).\n\n **Why is this bad?** This will cost resources (because the base has to be\n somewhere), and make the code less readable.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # struct Point {\n #     x: i32,\n #     y: i32,\n #     z: i32,\n # }\n # let zero_point = Point { x: 0, y: 0, z: 0 };\n\n // Bad\n Point {\n     x: 1,\n     y: 1,\n     z: 1,\n     ..zero_point\n };\n\n // Ok\n Point {\n     x: 1,\n     y: 1,\n     ..zero_point\n };\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "neg_cmp_op_on_partial_ord",
-    "id_span": {
-      "path": "src/neg_cmp_op_on_partial_ord.rs",
-      "line": 41
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks for the usage of negated comparison operators on types which only implement\n `PartialOrd` (e.g., `f64`).\n\n **Why is this bad?**\n These operators make it easy to forget that the underlying types actually allow not only three\n potential Orderings (Less, Equal, Greater) but also a fourth one (Uncomparable). This is\n especially easy to miss if the operator based comparison result is negated.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n use std::cmp::Ordering;\n\n // Bad\n let a = 1.0;\n let b = f64::NAN;\n\n let _not_less_or_equal = !(a <= b);\n\n // Good\n let a = 1.0;\n let b = f64::NAN;\n\n let _not_less_or_equal = match a.partial_cmp(&b) {\n     None | Some(Ordering::Greater) => true,\n     _ => false,\n };\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "neg_multiply",
-    "id_span": {
-      "path": "src/neg_multiply.rs",
-      "line": 21
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for multiplication by -1 as a form of negation.\n **Why is this bad?** It's more readable to just negate.\n\n **Known problems:** This only catches integers (for now).\n\n **Example:**\n ```ignore\n x * -1\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "new_without_default",
-    "id_span": {
-      "path": "src/new_without_default.rs",
-      "line": 48
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for types with a `fn new() -> Self` method and no implementation of\n [`Default`](https://doc.rust-lang.org/std/default/trait.Default.html).\n\n **Why is this bad?** The user might expect to be able to use\n [`Default`](https://doc.rust-lang.org/std/default/trait.Default.html) as the\n type can be constructed without arguments.\n\n **Known problems:** Hopefully none.\n\n **Example:**\n\n ```ignore\n struct Foo(Bar);\n\n impl Foo {\n     fn new() -> Self {\n         Foo(Bar::new())\n     }\n }\n ```\n\n To fix the lint, add a `Default` implementation that delegates to `new`:\n\n ```ignore\n struct Foo(Bar);\n\n impl Default for Foo {\n     fn default() -> Self {\n         Foo::new()\n     }\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MaybeIncorrect"
-    }
-  },
-  {
-    "id": "no_effect",
-    "id_span": {
-      "path": "src/no_effect.rs",
-      "line": 22
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks for statements which have no effect.\n **Why is this bad?** Similar to dead code, these statements are actually\n executed. However, as they have no effect, all they do is make the code less\n readable.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n 0;\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "unnecessary_operation",
-    "id_span": {
-      "path": "src/no_effect.rs",
-      "line": 40
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks for expression statements that can be reduced to a sub-expression.\n\n **Why is this bad?** Expressions by themselves often have no side-effects.\n Having such expressions reduces readability.\n\n **Known problems:** None.\n\n **Example:**\n ```rust,ignore\n compute_array()[0];\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "declare_interior_mutable_const",
-    "id_span": {
-      "path": "src/non_copy_const.rs",
-      "line": 69
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for declaration of `const` items which is interior mutable (e.g., contains a `Cell`, `Mutex`, `AtomicXxxx`, etc.).\n\n **Why is this bad?** Consts are copied everywhere they are referenced, i.e.,\n every time you refer to the const a fresh instance of the `Cell` or `Mutex`\n or `AtomicXxxx` will be created, which defeats the whole purpose of using\n these types in the first place.\n\n The `const` should better be replaced by a `static` item if a global\n variable is wanted, or replaced by a `const fn` if a constructor is wanted.\n\n **Known problems:** A \"non-constant\" const item is a legacy way to supply an\n initialized value to downstream `static` items (e.g., the\n `std::sync::ONCE_INIT` constant). In this case the use of `const` is legit,\n and this lint should be suppressed.\n\n Even though the lint avoids triggering on a constant whose type has enums that have variants\n with interior mutability, and its value uses non interior mutable variants (see\n [#3962](https://github.com/rust-lang/rust-clippy/issues/3962) and\n [#3825](https://github.com/rust-lang/rust-clippy/issues/3825) for examples);\n it complains about associated constants without default values only based on its types;\n which might not be preferable.\n There're other enums plus associated constants cases that the lint cannot handle.\n\n Types that have underlying or potential interior mutability trigger the lint whether\n the interior mutable field is used or not. See issues\n [#5812](https://github.com/rust-lang/rust-clippy/issues/5812) and\n\n **Example:**\n ```rust\n use std::sync::atomic::{AtomicUsize, Ordering::SeqCst};\n\n // Bad.\n const CONST_ATOM: AtomicUsize = AtomicUsize::new(12);\n CONST_ATOM.store(6, SeqCst); // the content of the atomic is unchanged\n assert_eq!(CONST_ATOM.load(SeqCst), 12); // because the CONST_ATOM in these lines are distinct\n\n // Good.\n static STATIC_ATOM: AtomicUsize = AtomicUsize::new(15);\n STATIC_ATOM.store(9, SeqCst);\n assert_eq!(STATIC_ATOM.load(SeqCst), 9); // use a `static` item to refer to the same instance\n ```\n",
-    "applicability": null
-  },
-  {
-    "id": "borrow_interior_mutable_const",
-    "id_span": {
-      "path": "src/non_copy_const.rs",
-      "line": 110
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks if `const` items which is interior mutable (e.g., contains a `Cell`, `Mutex`, `AtomicXxxx`, etc.) has been borrowed directly.\n\n **Why is this bad?** Consts are copied everywhere they are referenced, i.e.,\n every time you refer to the const a fresh instance of the `Cell` or `Mutex`\n or `AtomicXxxx` will be created, which defeats the whole purpose of using\n these types in the first place.\n\n The `const` value should be stored inside a `static` item.\n\n **Known problems:** When an enum has variants with interior mutability, use of its non\n interior mutable variants can generate false positives. See issue\n [#3962](https://github.com/rust-lang/rust-clippy/issues/3962)\n\n Types that have underlying or potential interior mutability trigger the lint whether\n the interior mutable field is used or not. See issues\n [#5812](https://github.com/rust-lang/rust-clippy/issues/5812) and\n [#3825](https://github.com/rust-lang/rust-clippy/issues/3825)\n\n **Example:**\n ```rust\n use std::sync::atomic::{AtomicUsize, Ordering::SeqCst};\n const CONST_ATOM: AtomicUsize = AtomicUsize::new(12);\n\n // Bad.\n CONST_ATOM.store(6, SeqCst); // the content of the atomic is unchanged\n assert_eq!(CONST_ATOM.load(SeqCst), 12); // because the CONST_ATOM in these lines are distinct\n\n // Good.\n static STATIC_ATOM: AtomicUsize = CONST_ATOM;\n STATIC_ATOM.store(9, SeqCst);\n assert_eq!(STATIC_ATOM.load(SeqCst), 9); // use a `static` item to refer to the same instance\n ```\n",
-    "applicability": null
-  },
-  {
-    "id": "similar_names",
-    "id_span": {
-      "path": "src/non_expressive_names.rs",
-      "line": 27
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Checks for names that are very similar and thus confusing.\n **Why is this bad?** It's hard to distinguish between names that differ only\n by a single character.\n\n **Known problems:** None?\n\n **Example:**\n ```ignore\n let checked_exp = something;\n let checked_expr = something_else;\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "many_single_char_names",
-    "id_span": {
-      "path": "src/non_expressive_names.rs",
-      "line": 45
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for too many variables whose name consists of a single character.\n\n **Why is this bad?** It's hard to memorize what a variable means without a\n descriptive name.\n\n **Known problems:** None?\n\n **Example:**\n ```ignore\n let (a, b, c, d, e, f, g) = (...);\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "just_underscores_and_digits",
-    "id_span": {
-      "path": "src/non_expressive_names.rs",
-      "line": 65
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks if you have variables whose name consists of just underscores and digits.\n\n **Why is this bad?** It's hard to memorize what a variable means without a\n descriptive name.\n\n **Known problems:** None?\n\n **Example:**\n ```rust\n let _1 = 1;\n let ___1 = 1;\n let __1___2 = 11;\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "nonsensical_open_options",
-    "id_span": {
-      "path": "src/open_options.rs",
-      "line": 23
-    },
-    "group": "clippy::correctness",
-    "docs": " **What it does:** Checks for duplicate open options as well as combinations that make no sense.\n\n **Why is this bad?** In the best case, the code will be harder to read than\n necessary. I don't know the worst case.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n use std::fs::OpenOptions;\n\n OpenOptions::new().read(true).truncate(true);\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "option_env_unwrap",
-    "id_span": {
-      "path": "src/option_env_unwrap.rs",
-      "line": 28
-    },
-    "group": "clippy::correctness",
-    "docs": " **What it does:** Checks for usage of `option_env!(...).unwrap()` and suggests usage of the `env!` macro.\n\n **Why is this bad?** Unwrapping the result of `option_env!` will panic\n at run-time if the environment variable doesn't exist, whereas `env!`\n catches it at compile-time.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust,no_run\n let _ = option_env!(\"HOME\").unwrap();\n ```\n\n Is better expressed as:\n\n ```rust,no_run\n let _ = env!(\"HOME\");\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "option_if_let_else",
-    "id_span": {
-      "path": "src/option_if_let_else.rs",
-      "line": 59
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Lints usage of `if let Some(v) = ... { y } else { x }` which is more\n idiomatically done with `Option::map_or` (if the else bit is a pure\n expression) or `Option::map_or_else` (if the else bit is an impure\n expression).\n\n **Why is this bad?**\n Using the dedicated functions of the Option type is clearer and\n more concise than an `if let` expression.\n\n **Known problems:**\n This lint uses a deliberately conservative metric for checking\n if the inside of either body contains breaks or continues which will\n cause it to not suggest a fix if either block contains a loop with\n continues or breaks contained within the loop.\n\n **Example:**\n\n ```rust\n # let optional: Option<u32> = Some(0);\n # fn do_complicated_function() -> u32 { 5 };\n let _ = if let Some(foo) = optional {\n     foo\n } else {\n     5\n };\n let _ = if let Some(foo) = optional {\n     foo\n } else {\n     let y = do_complicated_function();\n     y*y\n };\n ```\n\n should be\n\n ```rust\n # let optional: Option<u32> = Some(0);\n # fn do_complicated_function() -> u32 { 5 };\n let _ = optional.map_or(5, |foo| foo);\n let _ = optional.map_or_else(||{\n     let y = do_complicated_function();\n     y*y\n }, |foo| foo);\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MaybeIncorrect"
-    }
-  },
-  {
-    "id": "overflow_check_conditional",
-    "id_span": {
-      "path": "src/overflow_check_conditional.rs",
-      "line": 21
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Detects classic underflow/overflow checks.\n **Why is this bad?** Most classic C underflow/overflow checks will fail in\n Rust. Users can use functions like `overflowing_*` and `wrapping_*` instead.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # let a = 1;\n # let b = 2;\n a + b < a;\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "panic_in_result_fn",
-    "id_span": {
-      "path": "src/panic_in_result_fn.rs",
-      "line": 29
-    },
-    "group": "clippy::restriction",
-    "docs": " **What it does:** Checks for usage of `panic!`, `unimplemented!`, `todo!`, `unreachable!` or assertions in a function of type result.\n **Why is this bad?** For some codebases, it is desirable for functions of type result to return an error instead of crashing. Hence panicking macros should be avoided.\n\n **Known problems:** Functions called from a function returning a `Result` may invoke a panicking macro. This is not checked.\n\n **Example:**\n\n ```rust\n fn result_with_panic() -> Result<bool, String>\n {\n     panic!(\"error\");\n }\n ```\n Use instead:\n ```rust\n fn result_without_panic() -> Result<bool, String> {\n     Err(String::from(\"error\"))\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "panic",
-    "id_span": {
-      "path": "src/panic_unimplemented.rs",
-      "line": 19
-    },
-    "group": "clippy::restriction",
-    "docs": " **What it does:** Checks for usage of `panic!`.\n **Why is this bad?** `panic!` will stop the execution of the executable\n\n **Known problems:** None.\n\n **Example:**\n ```no_run\n panic!(\"even with a good reason\");\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "unimplemented",
-    "id_span": {
-      "path": "src/panic_unimplemented.rs",
-      "line": 35
-    },
-    "group": "clippy::restriction",
-    "docs": " **What it does:** Checks for usage of `unimplemented!`.\n **Why is this bad?** This macro should not be present in production code\n\n **Known problems:** None.\n\n **Example:**\n ```no_run\n unimplemented!();\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "todo",
-    "id_span": {
-      "path": "src/panic_unimplemented.rs",
-      "line": 51
-    },
-    "group": "clippy::restriction",
-    "docs": " **What it does:** Checks for usage of `todo!`.\n **Why is this bad?** This macro should not be present in production code\n\n **Known problems:** None.\n\n **Example:**\n ```no_run\n todo!();\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "unreachable",
-    "id_span": {
-      "path": "src/panic_unimplemented.rs",
-      "line": 67
-    },
-    "group": "clippy::restriction",
-    "docs": " **What it does:** Checks for usage of `unreachable!`.\n **Why is this bad?** This macro can cause code to panic\n\n **Known problems:** None.\n\n **Example:**\n ```no_run\n unreachable!();\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "partialeq_ne_impl",
-    "id_span": {
-      "path": "src/partialeq_ne_impl.rs",
-      "line": 27
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks for manual re-implementations of `PartialEq::ne`.\n **Why is this bad?** `PartialEq::ne` is required to always return the\n negated result of `PartialEq::eq`, which is exactly what the default\n implementation does. Therefore, there should never be any need to\n re-implement it.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n struct Foo;\n\n impl PartialEq for Foo {\n    fn eq(&self, other: &Foo) -> bool { true }\n    fn ne(&self, other: &Foo) -> bool { !(self == other) }\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "trivially_copy_pass_by_ref",
-    "id_span": {
-      "path": "src/pass_by_ref_or_value.rs",
-      "line": 52
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Checks for functions taking arguments by reference, where the argument type is `Copy` and small enough to be more efficient to always\n pass by value.\n\n **Why is this bad?** In many calling conventions instances of structs will\n be passed through registers if they fit into two or less general purpose\n registers.\n\n **Known problems:** This lint is target register size dependent, it is\n limited to 32-bit to try and reduce portability problems between 32 and\n 64-bit, but if you are compiling for 8 or 16-bit targets then the limit\n will be different.\n\n The configuration option `trivial_copy_size_limit` can be set to override\n this limit for a project.\n\n This lint attempts to allow passing arguments by reference if a reference\n to that argument is returned. This is implemented by comparing the lifetime\n of the argument and return value for equality. However, this can cause\n false positives in cases involving multiple lifetimes that are bounded by\n each other.\n\n **Example:**\n\n ```rust\n // Bad\n fn foo(v: &u32) {}\n ```\n\n ```rust\n // Better\n fn foo(v: u32) {}\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "Unspecified"
-    }
-  },
-  {
-    "id": "large_types_passed_by_value",
-    "id_span": {
-      "path": "src/pass_by_ref_or_value.rs",
-      "line": 84
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Checks for functions taking arguments by value, where the argument type is `Copy` and large enough to be worth considering\n passing by reference. Does not trigger if the function is being exported,\n because that might induce API breakage, if the parameter is declared as mutable,\n or if the argument is a `self`.\n\n **Why is this bad?** Arguments passed by value might result in an unnecessary\n shallow copy, taking up more space in the stack and requiring a call to\n `memcpy`, which can be expensive.\n\n **Example:**\n\n ```rust\n #[derive(Clone, Copy)]\n struct TooLarge([u8; 2048]);\n\n // Bad\n fn foo(v: TooLarge) {}\n ```\n ```rust\n #[derive(Clone, Copy)]\n struct TooLarge([u8; 2048]);\n\n // Good\n fn foo(v: &TooLarge) {}\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MaybeIncorrect"
-    }
-  },
-  {
-    "id": "path_buf_push_overwrite",
-    "id_span": {
-      "path": "src/path_buf_push_overwrite.rs",
-      "line": 36
-    },
-    "group": "clippy::nursery",
-    "docs": " **What it does:*** Checks for [push](https://doc.rust-lang.org/std/path/struct.PathBuf.html#method.push) calls on `PathBuf` that can cause overwrites.\n\n **Why is this bad?** Calling `push` with a root path at the start can overwrite the\n previous defined path.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n use std::path::PathBuf;\n\n let mut x = PathBuf::from(\"/foo\");\n x.push(\"/bar\");\n assert_eq!(x, PathBuf::from(\"/bar\"));\n ```\n Could be written:\n\n ```rust\n use std::path::PathBuf;\n\n let mut x = PathBuf::from(\"/foo\");\n x.push(\"bar\");\n assert_eq!(x, PathBuf::from(\"/foo/bar\"));\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "pattern_type_mismatch",
-    "id_span": {
-      "path": "src/pattern_type_mismatch.rs",
-      "line": 79
-    },
-    "group": "clippy::restriction",
-    "docs": " **What it does:** Checks for patterns that aren't exact representations of the types they are applied to.\n\n To satisfy this lint, you will have to adjust either the expression that is matched\n against or the pattern itself, as well as the bindings that are introduced by the\n adjusted patterns. For matching you will have to either dereference the expression\n with the `*` operator, or amend the patterns to explicitly match against `&<pattern>`\n or `&mut <pattern>` depending on the reference mutability. For the bindings you need\n to use the inverse. You can leave them as plain bindings if you wish for the value\n to be copied, but you must use `ref mut <variable>` or `ref <variable>` to construct\n a reference into the matched structure.\n\n If you are looking for a way to learn about ownership semantics in more detail, it\n is recommended to look at IDE options available to you to highlight types, lifetimes\n and reference semantics in your code. The available tooling would expose these things\n in a general way even outside of the various pattern matching mechanics. Of course\n this lint can still be used to highlight areas of interest and ensure a good understanding\n of ownership semantics.\n\n **Why is this bad?** It isn't bad in general. But in some contexts it can be desirable\n because it increases ownership hints in the code, and will guard against some changes\n in ownership.\n\n **Known problems:** None.\n\n **Example:**\n\n This example shows the basic adjustments necessary to satisfy the lint. Note how\n the matched expression is explicitly dereferenced with `*` and the `inner` variable\n is bound to a shared borrow via `ref inner`.\n\n ```rust,ignore\n // Bad\n let value = &Some(Box::new(23));\n match value {\n     Some(inner) => println!(\"{}\", inner),\n     None => println!(\"none\"),\n }\n\n // Good\n let value = &Some(Box::new(23));\n match *value {\n     Some(ref inner) => println!(\"{}\", inner),\n     None => println!(\"none\"),\n }\n ```\n\n The following example demonstrates one of the advantages of the more verbose style.\n Note how the second version uses `ref mut a` to explicitly declare `a` a shared mutable\n borrow, while `b` is simply taken by value. This ensures that the loop body cannot\n accidentally modify the wrong part of the structure.\n\n ```rust,ignore\n // Bad\n let mut values = vec![(2, 3), (3, 4)];\n for (a, b) in &mut values {\n     *a += *b;\n }\n\n // Good\n let mut values = vec![(2, 3), (3, 4)];\n for &mut (ref mut a, b) in &mut values {\n     *a += b;\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "precedence",
-    "id_span": {
-      "path": "src/precedence.rs",
-      "line": 44
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks for operations where precedence may be unclear and suggests to add parentheses. Currently it catches the following:\n * mixed usage of arithmetic and bit shifting/combining operators without\n parentheses\n * a \"negative\" numeric literal (which is really a unary `-` followed by a\n numeric literal)\n   followed by a method call\n\n **Why is this bad?** Not everyone knows the precedence of those operators by\n heart, so expressions like these may trip others trying to reason about the\n code.\n\n **Known problems:** None.\n\n **Example:**\n * `1 << 2 + 3` equals 32, while `(1 << 2) + 3` equals 7\n * `-1i32.abs()` equals -1, while `(-1i32).abs()` equals 1\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "ptr_arg",
-    "id_span": {
-      "path": "src/ptr.rs",
-      "line": 69
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** This lint checks for function arguments of type `&String` or `&Vec` unless the references are mutable. It will also suggest you\n replace `.clone()` calls with the appropriate `.to_owned()`/`to_string()`\n calls.\n\n **Why is this bad?** Requiring the argument to be of the specific size\n makes the function less useful for no benefit; slices in the form of `&[T]`\n or `&str` usually suffice and can be obtained from other types, too.\n\n **Known problems:** The lint does not follow data. So if you have an\n argument `x` and write `let y = x; y.clone()` the lint will not suggest\n changing that `.clone()` to `.to_owned()`.\n\n Other functions called from this function taking a `&String` or `&Vec`\n argument may also fail to compile if you change the argument. Applying\n this lint on them will fix the problem, but they may be in other crates.\n\n One notable example of a function that may cause issues, and which cannot\n easily be changed due to being in the standard library is `Vec::contains`.\n when called on a `Vec<Vec<T>>`. If a `&Vec` is passed to that method then\n it will compile, but if a `&[T]` is passed then it will not compile.\n\n ```ignore\n fn cannot_take_a_slice(v: &Vec<u8>) -> bool {\n     let vec_of_vecs: Vec<Vec<u8>> = some_other_fn();\n\n     vec_of_vecs.contains(v)\n }\n ```\n\n Also there may be `fn(&Vec)`-typed references pointing to your function.\n If you have them, you will get a compiler error after applying this lint's\n suggestions. You then have the choice to undo your changes or change the\n type of the reference.\n\n Note that if the function is part of your public interface, there may be\n other crates referencing it, of which you may not be aware. Carefully\n deprecate the function before applying the lint suggestions in this case.\n\n **Example:**\n ```ignore\n // Bad\n fn foo(&Vec<u32>) { .. }\n\n // Good\n fn foo(&[u32]) { .. }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "Unspecified"
-    }
-  },
-  {
-    "id": "cmp_null",
-    "id_span": {
-      "path": "src/ptr.rs",
-      "line": 95
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** This lint checks for equality comparisons with `ptr::null`\n **Why is this bad?** It's easier and more readable to use the inherent\n `.is_null()`\n method instead\n\n **Known problems:** None.\n\n **Example:**\n ```ignore\n // Bad\n if x == ptr::null {\n     ..\n }\n\n // Good\n if x.is_null() {\n     ..\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "mut_from_ref",
-    "id_span": {
-      "path": "src/ptr.rs",
-      "line": 117
-    },
-    "group": "clippy::correctness",
-    "docs": " **What it does:** This lint checks for functions that take immutable references and return mutable ones.\n\n **Why is this bad?** This is trivially unsound, as one can create two\n mutable references from the same (immutable!) source.\n This [error](https://github.com/rust-lang/rust/issues/39465)\n actually lead to an interim Rust release 1.15.1.\n\n **Known problems:** To be on the conservative side, if there's at least one\n mutable reference with the output lifetime, this lint will not trigger.\n In practice, this case is unlikely anyway.\n\n **Example:**\n ```ignore\n fn foo(&Foo) -> &mut Bar { .. }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "ptr_eq",
-    "id_span": {
-      "path": "src/ptr_eq.rs",
-      "line": 32
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Use `std::ptr::eq` when applicable\n **Why is this bad?** `ptr::eq` can be used to compare `&T` references\n (which coerce to `*const T` implicitly) by their address rather than\n comparing the values they point to.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n let a = &[1, 2, 3];\n let b = &[1, 2, 3];\n\n assert!(a as *const _ as usize == b as *const _ as usize);\n ```\n Use instead:\n ```rust\n let a = &[1, 2, 3];\n let b = &[1, 2, 3];\n\n assert!(std::ptr::eq(a, b));\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "ptr_offset_with_cast",
-    "id_span": {
-      "path": "src/ptr_offset_with_cast.rs",
-      "line": 40
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks for usage of the `offset` pointer method with a `usize` casted to an `isize`.\n\n **Why is this bad?** If we’re always increasing the pointer address, we can avoid the numeric\n cast by using the `add` method instead.\n\n **Known problems:** None\n\n **Example:**\n ```rust\n let vec = vec![b'a', b'b', b'c'];\n let ptr = vec.as_ptr();\n let offset = 1_usize;\n\n unsafe {\n     ptr.offset(offset as isize);\n }\n ```\n\n Could be written:\n\n ```rust\n let vec = vec![b'a', b'b', b'c'];\n let ptr = vec.as_ptr();\n let offset = 1_usize;\n\n unsafe {\n     ptr.add(offset);\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "question_mark",
-    "id_span": {
-      "path": "src/question_mark.rs",
-      "line": 34
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for expressions that could be replaced by the question mark operator.\n **Why is this bad?** Question mark usage is more idiomatic.\n\n **Known problems:** None\n\n **Example:**\n ```ignore\n if option.is_none() {\n     return None;\n }\n ```\n\n Could be written:\n\n ```ignore\n option?;\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "range_zip_with_len",
-    "id_span": {
-      "path": "src/ranges.rs",
-      "line": 40
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks for zipping a collection with the range of `0.._.len()`.\n\n **Why is this bad?** The code is better expressed with `.enumerate()`.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # let x = vec![1];\n x.iter().zip(0..x.len());\n ```\n Could be written as\n ```rust\n # let x = vec![1];\n x.iter().enumerate();\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "range_plus_one",
-    "id_span": {
-      "path": "src/ranges.rs",
-      "line": 74
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Checks for exclusive ranges where 1 is added to the upper bound, e.g., `x..(y+1)`.\n\n **Why is this bad?** The code is more readable with an inclusive range\n like `x..=y`.\n\n **Known problems:** Will add unnecessary pair of parentheses when the\n expression is not wrapped in a pair but starts with a opening parenthesis\n and ends with a closing one.\n I.e., `let _ = (f()+1)..(f()+1)` results in `let _ = ((f()+1)..=f())`.\n\n Also in many cases, inclusive ranges are still slower to run than\n exclusive ranges, because they essentially add an extra branch that\n LLVM may fail to hoist out of the loop.\n\n This will cause a warning that cannot be fixed if the consumer of the\n range only accepts a specific range type, instead of the generic\n `RangeBounds` trait\n ([#3307](https://github.com/rust-lang/rust-clippy/issues/3307)).\n\n **Example:**\n ```rust,ignore\n for x..(y+1) { .. }\n ```\n Could be written as\n ```rust,ignore\n for x..=y { .. }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": true,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "range_minus_one",
-    "id_span": {
-      "path": "src/ranges.rs",
-      "line": 99
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Checks for inclusive ranges where 1 is subtracted from the upper bound, e.g., `x..=(y-1)`.\n\n **Why is this bad?** The code is more readable with an exclusive range\n like `x..y`.\n\n **Known problems:** This will cause a warning that cannot be fixed if\n the consumer of the range only accepts a specific range type, instead of\n the generic `RangeBounds` trait\n ([#3307](https://github.com/rust-lang/rust-clippy/issues/3307)).\n\n **Example:**\n ```rust,ignore\n for x..=(y-1) { .. }\n ```\n Could be written as\n ```rust,ignore\n for x..y { .. }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "reversed_empty_ranges",
-    "id_span": {
-      "path": "src/ranges.rs",
-      "line": 132
-    },
-    "group": "clippy::correctness",
-    "docs": " **What it does:** Checks for range expressions `x..y` where both `x` and `y` are constant and `x` is greater or equal to `y`.\n\n **Why is this bad?** Empty ranges yield no values so iterating them is a no-op.\n Moreover, trying to use a reversed range to index a slice will panic at run-time.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust,no_run\n fn main() {\n     (10..=0).for_each(|x| println!(\"{}\", x));\n\n     let arr = [1, 2, 3, 4, 5];\n     let sub = &arr[3..1];\n }\n ```\n Use instead:\n ```rust\n fn main() {\n     (0..=10).rev().for_each(|x| println!(\"{}\", x));\n\n     let arr = [1, 2, 3, 4, 5];\n     let sub = &arr[1..3];\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MaybeIncorrect"
-    }
-  },
-  {
-    "id": "manual_range_contains",
-    "id_span": {
-      "path": "src/ranges.rs",
-      "line": 159
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for expressions like `x >= 3 && x < 8` that could be more readably expressed as `(3..8).contains(x)`.\n\n **Why is this bad?** `contains` expresses the intent better and has less\n failure modes (such as fencepost errors or using `||` instead of `&&`).\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n // given\n let x = 6;\n\n assert!(x >= 3 && x < 8);\n ```\n Use instead:\n ```rust\n# let x = 6;\n assert!((3..8).contains(&x));\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "redundant_clone",
-    "id_span": {
-      "path": "src/redundant_clone.rs",
-      "line": 63
-    },
-    "group": "clippy::perf",
-    "docs": " **What it does:** Checks for a redundant `clone()` (and its relatives) which clones an owned value that is going to be dropped without further use.\n\n **Why is this bad?** It is not always possible for the compiler to eliminate useless\n allocations and deallocations generated by redundant `clone()`s.\n\n **Known problems:**\n\n False-negatives: analysis performed by this lint is conservative and limited.\n\n **Example:**\n ```rust\n # use std::path::Path;\n # #[derive(Clone)]\n # struct Foo;\n # impl Foo {\n #     fn new() -> Self { Foo {} }\n # }\n # fn call(x: Foo) {}\n {\n     let x = Foo::new();\n     call(x.clone());\n     call(x.clone()); // this can just pass `x`\n }\n\n [\"lorem\", \"ipsum\"].join(\" \").to_string();\n\n Path::new(\"/a/b\").join(\"c\").to_path_buf();\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "redundant_closure_call",
-    "id_span": {
-      "path": "src/redundant_closure_call.rs",
-      "line": 32
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Detects closures called in the same expression where they are defined.\n\n **Why is this bad?** It is unnecessarily adding to the expression's\n complexity.\n\n **Known problems:** None.\n\n **Example:**\n ```rust,ignore\n // Bad\n let a = (|| 42)()\n\n // Good\n let a = 42\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "redundant_else",
-    "id_span": {
-      "path": "src/redundant_else.rs",
-      "line": 37
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Checks for `else` blocks that can be removed without changing semantics.\n **Why is this bad?** The `else` block adds unnecessary indentation and verbosity.\n\n **Known problems:** Some may prefer to keep the `else` block for clarity.\n\n **Example:**\n\n ```rust\n fn my_func(count: u32) {\n     if count == 0 {\n         print!(\"Nothing to do\");\n         return;\n     } else {\n         print!(\"Moving on...\");\n     }\n }\n ```\n Use instead:\n ```rust\n fn my_func(count: u32) {\n     if count == 0 {\n         print!(\"Nothing to do\");\n         return;\n     }\n     print!(\"Moving on...\");\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "redundant_field_names",
-    "id_span": {
-      "path": "src/redundant_field_names.rs",
-      "line": 34
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for fields in struct literals where shorthands could be used.\n\n **Why is this bad?** If the field and variable names are the same,\n the field name is redundant.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n let bar: u8 = 123;\n\n struct Foo {\n     bar: u8,\n }\n\n let foo = Foo { bar: bar };\n ```\n the last line can be simplified to\n ```ignore\n let foo = Foo { bar };\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "redundant_pub_crate",
-    "id_span": {
-      "path": "src/redundant_pub_crate.rs",
-      "line": 30
-    },
-    "group": "clippy::nursery",
-    "docs": " **What it does:** Checks for items declared `pub(crate)` that are not crate visible because they are inside a private module.\n\n **Why is this bad?** Writing `pub(crate)` is misleading when it's redundant due to the parent\n module's visibility.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n mod internal {\n     pub(crate) fn internal_fn() { }\n }\n ```\n This function is not visible outside the module and it can be declared with `pub` or\n private visibility\n ```rust\n mod internal {\n     pub fn internal_fn() { }\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "redundant_slicing",
-    "id_span": {
-      "path": "src/redundant_slicing.rs",
-      "line": 33
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks for redundant slicing expressions which use the full range, and do not change the type.\n\n **Why is this bad?** It unnecessarily adds complexity to the expression.\n\n **Known problems:** If the type being sliced has an implementation of `Index<RangeFull>`\n that actually changes anything then it can't be removed. However, this would be surprising\n to people reading the code and should have a note with it.\n\n **Example:**\n\n ```ignore\n fn get_slice(x: &[u32]) -> &[u32] {\n     &x[..]\n }\n ```\n Use instead:\n ```ignore\n fn get_slice(x: &[u32]) -> &[u32] {\n     x\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "redundant_static_lifetimes",
-    "id_span": {
-      "path": "src/redundant_static_lifetimes.rs",
-      "line": 30
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for constants and statics with an explicit `'static` lifetime.\n **Why is this bad?** Adding `'static` to every reference can create very\n complicated types.\n\n **Known problems:** None.\n\n **Example:**\n ```ignore\n const FOO: &'static [(&'static str, &'static str, fn(&Bar) -> bool)] =\n &[...]\n static FOO: &'static [(&'static str, &'static str, fn(&Bar) -> bool)] =\n &[...]\n ```\n This code can be rewritten as\n ```ignore\n  const FOO: &[(&str, &str, fn(&Bar) -> bool)] = &[...]\n  static FOO: &[(&str, &str, fn(&Bar) -> bool)] = &[...]\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "ref_option_ref",
-    "id_span": {
-      "path": "src/ref_option_ref.rs",
-      "line": 28
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Checks for usage of `&Option<&T>`.\n **Why is this bad?** Since `&` is Copy, it's useless to have a\n reference on `Option<&T>`.\n\n **Known problems:** It may be irrelevant to use this lint on\n public API code as it will make a breaking change to apply it.\n\n **Example:**\n\n ```rust,ignore\n let x: &Option<&u32> = &Some(&0u32);\n ```\n Use instead:\n ```rust,ignore\n let x: Option<&u32> = Some(&0u32);\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MaybeIncorrect"
-    }
-  },
-  {
-    "id": "deref_addrof",
-    "id_span": {
-      "path": "src/reference.rs",
-      "line": 29
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks for usage of `*&` and `*&mut` in expressions.\n **Why is this bad?** Immediately dereferencing a reference is no-op and\n makes the code less clear.\n\n **Known problems:** Multiple dereference/addrof pairs are not handled so\n the suggested fix for `x = **&&y` is `x = *&y`, which is still incorrect.\n\n **Example:**\n ```rust,ignore\n // Bad\n let a = f(*&mut b);\n let c = *&d;\n\n // Good\n let a = f(b);\n let c = d;\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "ref_in_deref",
-    "id_span": {
-      "path": "src/reference.rs",
-      "line": 120
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks for references in expressions that use auto dereference.\n\n **Why is this bad?** The reference is a no-op and is automatically\n dereferenced by the compiler and makes the code less clear.\n\n **Example:**\n ```rust\n struct Point(u32, u32);\n let point = Point(30, 20);\n let x = (&point).0;\n ```\n Use instead:\n ```rust\n # struct Point(u32, u32);\n # let point = Point(30, 20);\n let x = point.0;\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "invalid_regex",
-    "id_span": {
-      "path": "src/regex.rs",
-      "line": 25
-    },
-    "group": "clippy::correctness",
-    "docs": " **What it does:** Checks [regex](https://crates.io/crates/regex) creation (with `Regex::new`, `RegexBuilder::new`, or `RegexSet::new`) for correct\n regex syntax.\n\n **Why is this bad?** This will lead to a runtime panic.\n\n **Known problems:** None.\n\n **Example:**\n ```ignore\n Regex::new(\"|\")\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "trivial_regex",
-    "id_span": {
-      "path": "src/regex.rs",
-      "line": 46
-    },
-    "group": "clippy::nursery",
-    "docs": " **What it does:** Checks for trivial [regex](https://crates.io/crates/regex) creation (with `Regex::new`, `RegexBuilder::new`, or `RegexSet::new`).\n\n **Why is this bad?** Matching the regex can likely be replaced by `==` or\n `str::starts_with`, `str::ends_with` or `std::contains` or other `str`\n methods.\n\n **Known problems:** If the same regex is going to be applied to multiple\n inputs, the precomputations done by `Regex` construction can give\n significantly better performance than any of the `str`-based methods.\n\n **Example:**\n ```ignore\n Regex::new(\"^foobar\")\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "repeat_once",
-    "id_span": {
-      "path": "src/repeat_once.rs",
-      "line": 33
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks for usage of `.repeat(1)` and suggest the following method for each types. - `.to_string()` for `str`\n - `.clone()` for `String`\n - `.to_vec()` for `slice`\n\n **Why is this bad?** For example, `String.repeat(1)` is equivalent to `.clone()`. If cloning the string is the intention behind this, `clone()` should be used.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n fn main() {\n     let x = String::from(\"hello world\").repeat(1);\n }\n ```\n Use instead:\n ```rust\n fn main() {\n     let x = String::from(\"hello world\").clone();\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "let_and_return",
-    "id_span": {
-      "path": "src/returns.rs",
-      "line": 38
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for `let`-bindings, which are subsequently returned.\n\n **Why is this bad?** It is just extraneous code. Remove it to make your code\n more rusty.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n fn foo() -> String {\n     let x = String::new();\n     x\n }\n ```\n instead, use\n ```\n fn foo() -> String {\n     String::new()\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": true,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "needless_return",
-    "id_span": {
-      "path": "src/returns.rs",
-      "line": 63
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for return statements at the end of a block.\n **Why is this bad?** Removing the `return` and semicolon will make the code\n more rusty.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n fn foo(x: usize) -> usize {\n     return x;\n }\n ```\n simplify to\n ```rust\n fn foo(x: usize) -> usize {\n     x\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "self_assignment",
-    "id_span": {
-      "path": "src/self_assignment.rs",
-      "line": 29
-    },
-    "group": "clippy::correctness",
-    "docs": " **What it does:** Checks for explicit self-assignments.\n **Why is this bad?** Self-assignments are redundant and unlikely to be\n intentional.\n\n **Known problems:** If expression contains any deref coercions or\n indexing operations they are assumed not to have any side effects.\n\n **Example:**\n\n ```rust\n struct Event {\n     id: usize,\n     x: i32,\n     y: i32,\n }\n\n fn copy_position(a: &mut Event, b: &Event) {\n     a.x = b.x;\n     a.y = a.y;\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "semicolon_if_nothing_returned",
-    "id_span": {
-      "path": "src/semicolon_if_nothing_returned.rs",
-      "line": 30
-    },
-    "group": "clippy::restriction",
-    "docs": " **What it does:** Looks for blocks of expressions and fires if the last expression returns `()` but is not followed by a semicolon.\n\n **Why is this bad?** The semicolon might be optional but when\n extending the block with new code, it doesn't require a change in previous last line.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n fn main() {\n     println!(\"Hello world\")\n }\n ```\n Use instead:\n ```rust\n fn main() {\n     println!(\"Hello world\");\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MaybeIncorrect"
-    }
-  },
-  {
-    "id": "serde_api_misuse",
-    "id_span": {
-      "path": "src/serde_api.rs",
-      "line": 16
-    },
-    "group": "clippy::correctness",
-    "docs": " **What it does:** Checks for mis-uses of the serde API.\n **Why is this bad?** Serde is very finnicky about how its API should be\n used, but the type system can't be used to enforce it (yet?).\n\n **Known problems:** None.\n\n **Example:** Implementing `Visitor::visit_string` but not\n `Visitor::visit_str`.\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "shadow_same",
-    "id_span": {
-      "path": "src/shadow.rs",
-      "line": 34
-    },
-    "group": "clippy::restriction",
-    "docs": " **What it does:** Checks for bindings that shadow other bindings already in scope, while just changing reference level or mutability.\n\n **Why is this bad?** Not much, in fact it's a very common pattern in Rust\n code. Still, some may opt to avoid it in their code base, they can set this\n lint to `Warn`.\n\n **Known problems:** This lint, as the other shadowing related lints,\n currently only catches very simple patterns.\n\n **Example:**\n ```rust\n # let x = 1;\n // Bad\n let x = &x;\n\n // Good\n let y = &x; // use different variable name\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "shadow_reuse",
-    "id_span": {
-      "path": "src/shadow.rs",
-      "line": 61
-    },
-    "group": "clippy::restriction",
-    "docs": " **What it does:** Checks for bindings that shadow other bindings already in scope, while reusing the original value.\n\n **Why is this bad?** Not too much, in fact it's a common pattern in Rust\n code. Still, some argue that name shadowing like this hurts readability,\n because a value may be bound to different things depending on position in\n the code.\n\n **Known problems:** This lint, as the other shadowing related lints,\n currently only catches very simple patterns.\n\n **Example:**\n ```rust\n let x = 2;\n let x = x + 1;\n ```\n use different variable name:\n ```rust\n let x = 2;\n let y = x + 1;\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "shadow_unrelated",
-    "id_span": {
-      "path": "src/shadow.rs",
-      "line": 93
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Checks for bindings that shadow other bindings already in scope, either without a initialization or with one that does not even use\n the original value.\n\n **Why is this bad?** Name shadowing can hurt readability, especially in\n large code bases, because it is easy to lose track of the active binding at\n any place in the code. This can be alleviated by either giving more specific\n names to bindings or introducing more scopes to contain the bindings.\n\n **Known problems:** This lint, as the other shadowing related lints,\n currently only catches very simple patterns. Note that\n `allow`/`warn`/`deny`/`forbid` attributes only work on the function level\n for this lint.\n\n **Example:**\n ```rust\n # let y = 1;\n # let z = 2;\n let x = y;\n\n // Bad\n let x = z; // shadows the earlier binding\n\n // Good\n let w = z; // use different variable name\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "single_component_path_imports",
-    "id_span": {
-      "path": "src/single_component_path_imports.rs",
-      "line": 32
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checking for imports with single component use path.\n **Why is this bad?** Import with single component use path such as `use cratename;`\n is not necessary, and thus should be removed.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust,ignore\n use regex;\n\n fn main() {\n     regex::Regex::new(r\"^\\d{4}-\\d{2}-\\d{2}$\").unwrap();\n }\n ```\n Better as\n ```rust,ignore\n fn main() {\n     regex::Regex::new(r\"^\\d{4}-\\d{2}-\\d{2}$\").unwrap();\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "size_of_in_element_count",
-    "id_span": {
-      "path": "src/size_of_in_element_count.rs",
-      "line": 31
-    },
-    "group": "clippy::correctness",
-    "docs": " **What it does:** Detects expressions where `size_of::<T>` or `size_of_val::<T>` is used as a\n count of elements of type `T`\n\n **Why is this bad?** These functions expect a count\n of `T` and not a number of bytes\n\n **Known problems:** None.\n\n **Example:**\n ```rust,no_run\n # use std::ptr::copy_nonoverlapping;\n # use std::mem::size_of;\n const SIZE: usize = 128;\n let x = [2u8; SIZE];\n let mut y = [2u8; SIZE];\n unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>() * SIZE) };\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "slow_vector_initialization",
-    "id_span": {
-      "path": "src/slow_vector_initialization.rs",
-      "line": 37
-    },
-    "group": "clippy::perf",
-    "docs": " **What it does:** Checks slow zero-filled vector initialization\n **Why is this bad?** These structures are non-idiomatic and less efficient than simply using\n `vec![0; len]`.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # use core::iter::repeat;\n # let len = 4;\n\n // Bad\n let mut vec1 = Vec::with_capacity(len);\n vec1.resize(len, 0);\n\n let mut vec2 = Vec::with_capacity(len);\n vec2.extend(repeat(0).take(len));\n\n // Good\n let mut vec1 = vec![0; len];\n let mut vec2 = vec![0; len];\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "Unspecified"
-    }
-  },
-  {
-    "id": "stable_sort_primitive",
-    "id_span": {
-      "path": "src/stable_sort_primitive.rs",
-      "line": 36
-    },
-    "group": "clippy::perf",
-    "docs": " **What it does:** When sorting primitive values (integers, bools, chars, as well\n as arrays, slices, and tuples of such items), it is better to\n use an unstable sort than a stable sort.\n\n **Why is this bad?**\n Using a stable sort consumes more memory and cpu cycles. Because\n values which compare equal are identical, preserving their\n relative order (the guarantee that a stable sort provides) means\n nothing, while the extra costs still apply.\n\n **Known problems:**\n None\n\n **Example:**\n\n ```rust\n let mut vec = vec![2, 1, 3];\n vec.sort();\n ```\n Use instead:\n ```rust\n let mut vec = vec![2, 1, 3];\n vec.sort_unstable();\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "string_add_assign",
-    "id_span": {
-      "path": "src/strings.rs",
-      "line": 37
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Checks for string appends of the form `x = x + y` (without `let`!).\n\n **Why is this bad?** It's not really bad, but some people think that the\n `.push_str(_)` method is more readable.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n let mut x = \"Hello\".to_owned();\n x = x + \", World\";\n\n // More readable\n x += \", World\";\n x.push_str(\", World\");\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "string_add",
-    "id_span": {
-      "path": "src/strings.rs",
-      "line": 65
-    },
-    "group": "clippy::restriction",
-    "docs": " **What it does:** Checks for all instances of `x + _` where `x` is of type `String`, but only if [`string_add_assign`](#string_add_assign) does *not*\n match.\n\n **Why is this bad?** It's not bad in and of itself. However, this particular\n `Add` implementation is asymmetric (the other operand need not be `String`,\n but `x` does), while addition as mathematically defined is symmetric, also\n the `String::push_str(_)` function is a perfectly good replacement.\n Therefore, some dislike it and wish not to have it in their code.\n\n That said, other people think that string addition, having a long tradition\n in other languages is actually fine, which is why we decided to make this\n particular lint `allow` by default.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n let x = \"Hello\".to_owned();\n x + \", World\";\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "string_lit_as_bytes",
-    "id_span": {
-      "path": "src/strings.rs",
-      "line": 107
-    },
-    "group": "clippy::nursery",
-    "docs": " **What it does:** Checks for the `as_bytes` method called on string literals that contain only ASCII characters.\n\n **Why is this bad?** Byte string literals (e.g., `b\"foo\"`) can be used\n instead. They are shorter but less discoverable than `as_bytes()`.\n\n **Known Problems:**\n `\"str\".as_bytes()` and the suggested replacement of `b\"str\"` are not\n equivalent because they have different types. The former is `&[u8]`\n while the latter is `&[u8; 3]`. That means in general they will have a\n different set of methods and different trait implementations.\n\n ```compile_fail\n fn f(v: Vec<u8>) {}\n\n f(\"...\".as_bytes().to_owned()); // works\n f(b\"...\".to_owned()); // does not work, because arg is [u8; 3] not Vec<u8>\n\n fn g(r: impl std::io::Read) {}\n\n g(\"...\".as_bytes()); // works\n g(b\"...\"); // does not work\n ```\n\n The actual equivalent of `\"str\".as_bytes()` with the same type is not\n `b\"str\"` but `&b\"str\"[..]`, which is a great deal of punctuation and not\n more readable than a function call.\n\n **Example:**\n ```rust\n // Bad\n let bs = \"a byte string\".as_bytes();\n\n // Good\n let bs = b\"a byte string\";\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "string_from_utf8_as_bytes",
-    "id_span": {
-      "path": "src/strings.rs",
-      "line": 196
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Check if the string is transformed to byte array and casted back to string.\n **Why is this bad?** It's unnecessary, the string can be used directly.\n\n **Known problems:** None\n\n **Example:**\n ```rust\n let _ = std::str::from_utf8(&\"Hello World!\".as_bytes()[6..11]).unwrap();\n ```\n could be written as\n ```rust\n let _ = &\"Hello World!\"[6..11];\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "str_to_string",
-    "id_span": {
-      "path": "src/strings.rs",
-      "line": 313
-    },
-    "group": "clippy::restriction",
-    "docs": " **What it does:** This lint checks for `.to_string()` method calls on values of type `&str`.\n **Why is this bad?** The `to_string` method is also used on other types to convert them to a string.\n When called on a `&str` it turns the `&str` into the owned variant `String`, which can be better\n expressed with `.to_owned()`.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n // example code where clippy issues a warning\n let _ = \"str\".to_string();\n ```\n Use instead:\n ```rust\n // example code which does not raise clippy warning\n let _ = \"str\".to_owned();\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "string_to_string",
-    "id_span": {
-      "path": "src/strings.rs",
-      "line": 362
-    },
-    "group": "clippy::restriction",
-    "docs": " **What it does:** This lint checks for `.to_string()` method calls on values of type `String`.\n **Why is this bad?** The `to_string` method is also used on other types to convert them to a string.\n When called on a `String` it only clones the `String`, which can be better expressed with `.clone()`.\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n // example code where clippy issues a warning\n let msg = String::from(\"Hello World\");\n let _ = msg.to_string();\n ```\n Use instead:\n ```rust\n // example code which does not raise clippy warning\n let msg = String::from(\"Hello World\");\n let _ = msg.clone();\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "suspicious_operation_groupings",
-    "id_span": {
-      "path": "src/suspicious_operation_groupings.rs",
-      "line": 60
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for unlikely usages of binary operators that are almost\n certainly typos and/or copy/paste errors, given the other usages\n of binary operators nearby.\n **Why is this bad?**\n They are probably bugs and if they aren't then they look like bugs\n and you should add a comment explaining why you are doing such an\n odd set of operations.\n **Known problems:**\n There may be some false positives if you are trying to do something\n unusual that happens to look like a typo.\n\n **Example:**\n\n ```rust\n struct Vec3 {\n     x: f64,\n     y: f64,\n     z: f64,\n }\n\n impl Eq for Vec3 {}\n\n impl PartialEq for Vec3 {\n     fn eq(&self, other: &Self) -> bool {\n         // This should trigger the lint because `self.x` is compared to `other.y`\n         self.x == other.y && self.y == other.y && self.z == other.z\n     }\n }\n ```\n Use instead:\n ```rust\n # struct Vec3 {\n #     x: f64,\n #     y: f64,\n #     z: f64,\n # }\n // same as above except:\n impl PartialEq for Vec3 {\n     fn eq(&self, other: &Self) -> bool {\n         // Note we now compare other.x to self.x\n         self.x == other.x && self.y == other.y && self.z == other.z\n     }\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "suspicious_arithmetic_impl",
-    "id_span": {
-      "path": "src/suspicious_trait_impl.rs",
-      "line": 27
-    },
-    "group": "clippy::correctness",
-    "docs": " **What it does:** Lints for suspicious operations in impls of arithmetic operators, e.g. subtracting elements in an Add impl.\n\n **Why this is bad?** This is probably a typo or copy-and-paste error and not intended.\n\n **Known problems:** None.\n\n **Example:**\n ```ignore\n impl Add for Foo {\n     type Output = Foo;\n\n     fn add(self, other: Foo) -> Foo {\n         Foo(self.0 - other.0)\n     }\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "suspicious_op_assign_impl",
-    "id_span": {
-      "path": "src/suspicious_trait_impl.rs",
-      "line": 48
-    },
-    "group": "clippy::correctness",
-    "docs": " **What it does:** Lints for suspicious operations in impls of OpAssign, e.g. subtracting elements in an AddAssign impl.\n\n **Why this is bad?** This is probably a typo or copy-and-paste error and not intended.\n\n **Known problems:** None.\n\n **Example:**\n ```ignore\n impl AddAssign for Foo {\n     fn add_assign(&mut self, other: Foo) {\n         *self = *self - other;\n     }\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "manual_swap",
-    "id_span": {
-      "path": "src/swap.rs",
-      "line": 36
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks for manual swapping.\n **Why is this bad?** The `std::mem::swap` function exposes the intent better\n without deinitializing or copying either variable.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n let mut a = 42;\n let mut b = 1337;\n\n let t = b;\n b = a;\n a = t;\n ```\n Use std::mem::swap():\n ```rust\n let mut a = 1;\n let mut b = 2;\n std::mem::swap(&mut a, &mut b);\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "almost_swapped",
-    "id_span": {
-      "path": "src/swap.rs",
-      "line": 61
-    },
-    "group": "clippy::correctness",
-    "docs": " **What it does:** Checks for `foo = bar; bar = foo` sequences.\n **Why is this bad?** This looks like a failed attempt to swap.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # let mut a = 1;\n # let mut b = 2;\n a = b;\n b = a;\n ```\n If swapping is intended, use `swap()` instead:\n ```rust\n # let mut a = 1;\n # let mut b = 2;\n std::mem::swap(&mut a, &mut b);\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MaybeIncorrect"
-    }
-  },
-  {
-    "id": "tabs_in_doc_comments",
-    "id_span": {
-      "path": "src/tabs_in_doc_comments.rs",
-      "line": 54
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks doc comments for usage of tab characters.\n **Why is this bad?** The rust style-guide promotes spaces instead of tabs for indentation.\n To keep a consistent view on the source, also doc comments should not have tabs.\n Also, explaining ascii-diagrams containing tabs can get displayed incorrectly when the\n display settings of the author and reader differ.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n ///\n /// Struct to hold two strings:\n /// \t- first\t\tone\n /// \t- second\tone\n pub struct DoubleString {\n    ///\n    /// \t- First String:\n    /// \t\t- needs to be inside here\n    first_string: String,\n    ///\n    /// \t- Second String:\n    /// \t\t- needs to be inside here\n    second_string: String,\n}\n ```\n\n Will be converted to:\n ```rust\n ///\n /// Struct to hold two strings:\n ///     - first        one\n ///     - second    one\n pub struct DoubleString {\n    ///\n    ///     - First String:\n    ///         - needs to be inside here\n    first_string: String,\n    ///\n    ///     - Second String:\n    ///         - needs to be inside here\n    second_string: String,\n}\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MaybeIncorrect"
-    }
-  },
-  {
-    "id": "temporary_assignment",
-    "id_span": {
-      "path": "src/temporary_assignment.rs",
-      "line": 19
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks for construction of a structure or tuple just to assign a value in it.\n\n **Why is this bad?** Readability. If the structure is only created to be\n updated, why not write the structure you want in the first place?\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n (0, 0).0 = 1\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "to_digit_is_some",
-    "id_span": {
-      "path": "src/to_digit_is_some.rs",
-      "line": 27
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for `.to_digit(..).is_some()` on `char`s.\n **Why is this bad?** This is a convoluted way of checking if a `char` is a digit. It's\n more straight forward to use the dedicated `is_digit` method.\n\n **Example:**\n ```rust\n # let c = 'c';\n # let radix = 10;\n let is_digit = c.to_digit(radix).is_some();\n ```\n can be written as:\n ```\n # let c = 'c';\n # let radix = 10;\n let is_digit = c.is_digit(radix);\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "to_string_in_display",
-    "id_span": {
-      "path": "src/to_string_in_display.rs",
-      "line": 40
-    },
-    "group": "clippy::correctness",
-    "docs": " **What it does:** Checks for uses of `to_string()` in `Display` traits.\n **Why is this bad?** Usually `to_string` is implemented indirectly\n via `Display`. Hence using it while implementing `Display` would\n lead to infinite recursion.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n use std::fmt;\n\n struct Structure(i32);\n impl fmt::Display for Structure {\n     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n         write!(f, \"{}\", self.to_string())\n     }\n }\n\n ```\n Use instead:\n ```rust\n use std::fmt;\n\n struct Structure(i32);\n impl fmt::Display for Structure {\n     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n         write!(f, \"{}\", self.0)\n     }\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "type_repetition_in_bounds",
-    "id_span": {
-      "path": "src/trait_bounds.rs",
-      "line": 28
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** This lint warns about unnecessary type repetitions in trait bounds\n **Why is this bad?** Repeating the type for every bound makes the code\n less readable than combining the bounds\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n pub fn foo<T>(t: T) where T: Copy, T: Clone {}\n ```\n\n Could be written as:\n\n ```rust\n pub fn foo<T>(t: T) where T: Copy + Clone {}\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "trait_duplication_in_bounds",
-    "id_span": {
-      "path": "src/trait_bounds.rs",
-      "line": 57
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Checks for cases where generics are being used and multiple syntax specifications for trait bounds are used simultaneously.\n\n **Why is this bad?** Duplicate bounds makes the code\n less readable than specifing them only once.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n fn func<T: Clone + Default>(arg: T) where T: Clone + Default {}\n ```\n\n Could be written as:\n\n ```rust\n fn func<T: Clone + Default>(arg: T) {}\n ```\n or\n\n ```rust\n fn func<T>(arg: T) where T: Clone + Default {}\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "wrong_transmute",
-    "id_span": {
-      "path": "src/transmute/mod.rs",
-      "line": 34
-    },
-    "group": "clippy::correctness",
-    "docs": " **What it does:** Checks for transmutes that can't ever be correct on any architecture.\n\n **Why is this bad?** It's basically guaranteed to be undefined behaviour.\n\n **Known problems:** When accessing C, users might want to store pointer\n sized objects in `extradata` arguments to save an allocation.\n\n **Example:**\n ```ignore\n let ptr: *const T = core::intrinsics::transmute('x')\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "useless_transmute",
-    "id_span": {
-      "path": "src/transmute/mod.rs",
-      "line": 53
-    },
-    "group": "clippy::nursery",
-    "docs": " **What it does:** Checks for transmutes to the original type of the object and transmutes that could be a cast.\n\n **Why is this bad?** Readability. The code tricks people into thinking that\n something complex is going on.\n\n **Known problems:** None.\n\n **Example:**\n ```rust,ignore\n core::intrinsics::transmute(t); // where the result type is the same as `t`'s\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "Unspecified"
-    }
-  },
-  {
-    "id": "transmutes_expressible_as_ptr_casts",
-    "id_span": {
-      "path": "src/transmute/mod.rs",
-      "line": 78
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:**Checks for transmutes that could be a pointer cast.\n **Why is this bad?** Readability. The code tricks people into thinking that\n something complex is going on.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n # let p: *const [i32] = &[];\n unsafe { std::mem::transmute::<*const [i32], *const [u16]>(p) };\n ```\n Use instead:\n ```rust\n # let p: *const [i32] = &[];\n p as *const [u16];\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "crosspointer_transmute",
-    "id_span": {
-      "path": "src/transmute/mod.rs",
-      "line": 96
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks for transmutes between a type `T` and `*T`.\n **Why is this bad?** It's easy to mistakenly transmute between a type and a\n pointer to that type.\n\n **Known problems:** None.\n\n **Example:**\n ```rust,ignore\n core::intrinsics::transmute(t) // where the result type is the same as\n                                // `*t` or `&t`'s\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "transmute_ptr_to_ref",
-    "id_span": {
-      "path": "src/transmute/mod.rs",
-      "line": 121
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks for transmutes from a pointer to a reference.\n **Why is this bad?** This can always be rewritten with `&` and `*`.\n\n **Known problems:**\n - `mem::transmute` in statics and constants is stable from Rust 1.46.0,\n while dereferencing raw pointer is not stable yet.\n If you need to do this in those places,\n you would have to use `transmute` instead.\n\n **Example:**\n ```rust,ignore\n unsafe {\n     let _: &T = std::mem::transmute(p); // where p: *const T\n }\n\n // can be written:\n let _: &T = &*p;\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "Unspecified"
-    }
-  },
-  {
-    "id": "transmute_int_to_char",
-    "id_span": {
-      "path": "src/transmute/mod.rs",
-      "line": 152
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks for transmutes from an integer to a `char`.\n **Why is this bad?** Not every integer is a Unicode scalar value.\n\n **Known problems:**\n - [`from_u32`] which this lint suggests using is slower than `transmute`\n as it needs to validate the input.\n If you are certain that the input is always a valid Unicode scalar value,\n use [`from_u32_unchecked`] which is as fast as `transmute`\n but has a semantically meaningful name.\n - You might want to handle `None` returned from [`from_u32`] instead of calling `unwrap`.\n\n [`from_u32`]: https://doc.rust-lang.org/std/char/fn.from_u32.html\n [`from_u32_unchecked`]: https://doc.rust-lang.org/std/char/fn.from_u32_unchecked.html\n\n **Example:**\n ```rust\n let x = 1_u32;\n unsafe {\n     let _: char = std::mem::transmute(x); // where x: u32\n }\n\n // should be:\n let _ = std::char::from_u32(x).unwrap();\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "Unspecified"
-    }
-  },
-  {
-    "id": "transmute_bytes_to_str",
-    "id_span": {
-      "path": "src/transmute/mod.rs",
-      "line": 183
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks for transmutes from a `&[u8]` to a `&str`.\n **Why is this bad?** Not every byte slice is a valid UTF-8 string.\n\n **Known problems:**\n - [`from_utf8`] which this lint suggests using is slower than `transmute`\n as it needs to validate the input.\n If you are certain that the input is always a valid UTF-8,\n use [`from_utf8_unchecked`] which is as fast as `transmute`\n but has a semantically meaningful name.\n - You might want to handle errors returned from [`from_utf8`] instead of calling `unwrap`.\n\n [`from_utf8`]: https://doc.rust-lang.org/std/str/fn.from_utf8.html\n [`from_utf8_unchecked`]: https://doc.rust-lang.org/std/str/fn.from_utf8_unchecked.html\n\n **Example:**\n ```rust\n let b: &[u8] = &[1_u8, 2_u8];\n unsafe {\n     let _: &str = std::mem::transmute(b); // where b: &[u8]\n }\n\n // should be:\n let _ = std::str::from_utf8(b).unwrap();\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "Unspecified"
-    }
-  },
-  {
-    "id": "transmute_int_to_bool",
-    "id_span": {
-      "path": "src/transmute/mod.rs",
-      "line": 205
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks for transmutes from an integer to a `bool`.\n **Why is this bad?** This might result in an invalid in-memory representation of a `bool`.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n let x = 1_u8;\n unsafe {\n     let _: bool = std::mem::transmute(x); // where x: u8\n }\n\n // should be:\n let _: bool = x != 0;\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "Unspecified"
-    }
-  },
-  {
-    "id": "transmute_int_to_float",
-    "id_span": {
-      "path": "src/transmute/mod.rs",
-      "line": 227
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks for transmutes from an integer to a float.\n **Why is this bad?** Transmutes are dangerous and error-prone, whereas `from_bits` is intuitive\n and safe.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n unsafe {\n     let _: f32 = std::mem::transmute(1_u32); // where x: u32\n }\n\n // should be:\n let _: f32 = f32::from_bits(1_u32);\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "Unspecified"
-    }
-  },
-  {
-    "id": "transmute_float_to_int",
-    "id_span": {
-      "path": "src/transmute/mod.rs",
-      "line": 249
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks for transmutes from a float to an integer.\n **Why is this bad?** Transmutes are dangerous and error-prone, whereas `to_bits` is intuitive\n and safe.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n unsafe {\n     let _: u32 = std::mem::transmute(1f32);\n }\n\n // should be:\n let _: u32 = 1f32.to_bits();\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "Unspecified"
-    }
-  },
-  {
-    "id": "transmute_ptr_to_ptr",
-    "id_span": {
-      "path": "src/transmute/mod.rs",
-      "line": 276
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks for transmutes from a pointer to a pointer, or from a reference to a reference.\n\n **Why is this bad?** Transmutes are dangerous, and these can instead be\n written as casts.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n let ptr = &1u32 as *const u32;\n unsafe {\n     // pointer-to-pointer transmute\n     let _: *const f32 = std::mem::transmute(ptr);\n     // ref-ref transmute\n     let _: &f32 = std::mem::transmute(&1u32);\n }\n // These can be respectively written:\n let _ = ptr as *const f32;\n let _ = unsafe{ &*(&1u32 as *const u32 as *const f32) };\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "Unspecified"
-    }
-  },
-  {
-    "id": "unsound_collection_transmute",
-    "id_span": {
-      "path": "src/transmute/mod.rs",
-      "line": 304
-    },
-    "group": "clippy::correctness",
-    "docs": " **What it does:** Checks for transmutes between collections whose types have different ABI, size or alignment.\n\n **Why is this bad?** This is undefined behavior.\n\n **Known problems:** Currently, we cannot know whether a type is a\n collection, so we just lint the ones that come with `std`.\n\n **Example:**\n ```rust\n // different size, therefore likely out-of-bounds memory access\n // You absolutely do not want this in your code!\n unsafe {\n     std::mem::transmute::<_, Vec<u32>>(vec![2_u16])\n };\n ```\n\n You must always iterate, map and collect the values:\n\n ```rust\n vec![2_u16].into_iter().map(u32::from).collect::<Vec<_>>();\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "transmuting_null",
-    "id_span": {
-      "path": "src/transmuting_null.rs",
-      "line": 23
-    },
-    "group": "clippy::correctness",
-    "docs": " **What it does:** Checks for transmute calls which would receive a null pointer.\n **Why is this bad?** Transmuting a null pointer is undefined behavior.\n\n **Known problems:** Not all cases can be detected at the moment of this writing.\n For example, variables which hold a null pointer and are then fed to a `transmute`\n call, aren't detectable yet.\n\n **Example:**\n ```rust\n let null_ref: &u64 = unsafe { std::mem::transmute(0 as *const u64) };\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "try_err",
-    "id_span": {
-      "path": "src/try_err.rs",
-      "line": 43
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for usages of `Err(x)?`.\n **Why is this bad?** The `?` operator is designed to allow calls that\n can fail to be easily chained. For example, `foo()?.bar()` or\n `foo(bar()?)`. Because `Err(x)?` can't be used that way (it will\n always return), it is more clear to write `return Err(x)`.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n fn foo(fail: bool) -> Result<i32, String> {\n     if fail {\n       Err(\"failed\")?;\n     }\n     Ok(0)\n }\n ```\n Could be written:\n\n ```rust\n fn foo(fail: bool) -> Result<i32, String> {\n     if fail {\n       return Err(\"failed\".into());\n     }\n     Ok(0)\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "box_vec",
-    "id_span": {
-      "path": "src/types.rs",
-      "line": 66
-    },
-    "group": "clippy::perf",
-    "docs": " **What it does:** Checks for use of `Box<Vec<_>>` anywhere in the code. Check the [Box documentation](https://doc.rust-lang.org/std/boxed/index.html) for more information.\n\n **Why is this bad?** `Vec` already keeps its contents in a separate area on\n the heap. So if you `Box` it, you just add another level of indirection\n without any benefit whatsoever.\n\n **Known problems:** None.\n\n **Example:**\n ```rust,ignore\n struct X {\n     values: Box<Vec<Foo>>,\n }\n ```\n\n Better:\n\n ```rust,ignore\n struct X {\n     values: Vec<Foo>,\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "vec_box",
-    "id_span": {
-      "path": "src/types.rs",
-      "line": 95
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks for use of `Vec<Box<T>>` where T: Sized anywhere in the code. Check the [Box documentation](https://doc.rust-lang.org/std/boxed/index.html) for more information.\n\n **Why is this bad?** `Vec` already keeps its contents in a separate area on\n the heap. So if you `Box` its contents, you just add another level of indirection.\n\n **Known problems:** Vec<Box<T: Sized>> makes sense if T is a large type (see [#3530](https://github.com/rust-lang/rust-clippy/issues/3530),\n 1st comment).\n\n **Example:**\n ```rust\n struct X {\n     values: Vec<Box<i32>>,\n }\n ```\n\n Better:\n\n ```rust\n struct X {\n     values: Vec<i32>,\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "option_option",
-    "id_span": {
-      "path": "src/types.rs",
-      "line": 133
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Checks for use of `Option<Option<_>>` in function signatures and type definitions\n\n **Why is this bad?** `Option<_>` represents an optional value. `Option<Option<_>>`\n represents an optional optional value which is logically the same thing as an optional\n value but has an unneeded extra level of wrapping.\n\n If you have a case where `Some(Some(_))`, `Some(None)` and `None` are distinct cases,\n consider a custom `enum` instead, with clear names for each case.\n\n **Known problems:** None.\n\n **Example**\n ```rust\n fn get_data() -> Option<Option<u32>> {\n     None\n }\n ```\n\n Better:\n\n ```rust\n pub enum Contents {\n     Data(Vec<u8>), // Was Some(Some(Vec<u8>))\n     NotYetFetched, // Was Some(None)\n     None,          // Was None\n }\n\n fn get_data() -> Contents {\n     Contents::None\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "linkedlist",
-    "id_span": {
-      "path": "src/types.rs",
-      "line": 169
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Checks for usage of any `LinkedList`, suggesting to use a `Vec` or a `VecDeque` (formerly called `RingBuf`).\n\n **Why is this bad?** Gankro says:\n\n > The TL;DR of `LinkedList` is that it's built on a massive amount of\n pointers and indirection.\n > It wastes memory, it has terrible cache locality, and is all-around slow.\n `RingBuf`, while\n > \"only\" amortized for push/pop, should be faster in the general case for\n almost every possible\n > workload, and isn't even amortized at all if you can predict the capacity\n you need.\n >\n > `LinkedList`s are only really good if you're doing a lot of merging or\n splitting of lists.\n > This is because they can just mangle some pointers instead of actually\n copying the data. Even\n > if you're doing a lot of insertion in the middle of the list, `RingBuf`\n can still be better\n > because of how expensive it is to seek to the middle of a `LinkedList`.\n\n **Known problems:** False positives – the instances where using a\n `LinkedList` makes sense are few and far between, but they can still happen.\n\n **Example:**\n ```rust\n # use std::collections::LinkedList;\n let x: LinkedList<usize> = LinkedList::new();\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "borrowed_box",
-    "id_span": {
-      "path": "src/types.rs",
-      "line": 193
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks for use of `&Box<T>` anywhere in the code. Check the [Box documentation](https://doc.rust-lang.org/std/boxed/index.html) for more information.\n\n **Why is this bad?** Any `&Box<T>` can also be a `&T`, which is more\n general.\n\n **Known problems:** None.\n\n **Example:**\n ```rust,ignore\n fn foo(bar: &Box<T>) { ... }\n ```\n\n Better:\n\n ```rust,ignore\n fn foo(bar: &T) { ... }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "Unspecified"
-    }
-  },
-  {
-    "id": "redundant_allocation",
-    "id_span": {
-      "path": "src/types.rs",
-      "line": 217
-    },
-    "group": "clippy::perf",
-    "docs": " **What it does:** Checks for use of redundant allocations anywhere in the code.\n **Why is this bad?** Expressions such as `Rc<&T>`, `Rc<Rc<T>>`, `Rc<Box<T>>`, `Box<&T>`\n add an unnecessary level of indirection.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # use std::rc::Rc;\n fn foo(bar: Rc<&usize>) {}\n ```\n\n Better:\n\n ```rust\n fn foo(bar: &usize) {}\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "rc_buffer",
-    "id_span": {
-      "path": "src/types.rs",
-      "line": 248
-    },
-    "group": "clippy::restriction",
-    "docs": " **What it does:** Checks for `Rc<T>` and `Arc<T>` when `T` is a mutable buffer type such as `String` or `Vec`.\n **Why is this bad?** Expressions such as `Rc<String>` usually have no advantage over `Rc<str>`, since\n it is larger and involves an extra level of indirection, and doesn't implement `Borrow<str>`.\n\n While mutating a buffer type would still be possible with `Rc::get_mut()`, it only\n works if there are no additional references yet, which usually defeats the purpose of\n enclosing it in a shared ownership type. Instead, additionally wrapping the inner\n type with an interior mutable container (such as `RefCell` or `Mutex`) would normally\n be used.\n\n **Known problems:** This pattern can be desirable to avoid the overhead of a `RefCell` or `Mutex` for\n cases where mutation only happens before there are any additional references.\n\n **Example:**\n ```rust,ignore\n # use std::rc::Rc;\n fn foo(interned: Rc<String>) { ... }\n ```\n\n Better:\n\n ```rust,ignore\n fn foo(interned: Rc<str>) { ... }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "let_unit_value",
-    "id_span": {
-      "path": "src/types.rs",
-      "line": 768
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Checks for binding a unit value.\n **Why is this bad?** A unit value cannot usefully be used anywhere. So\n binding one is kind of pointless.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n let x = {\n     1;\n };\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "unit_cmp",
-    "id_span": {
-      "path": "src/types.rs",
-      "line": 849
-    },
-    "group": "clippy::correctness",
-    "docs": " **What it does:** Checks for comparisons to unit. This includes all binary comparisons (like `==` and `<`) and asserts.\n\n **Why is this bad?** Unit is always equal to itself, and thus is just a\n clumsily written constant. Mostly this happens when someone accidentally\n adds semicolons at the end of the operands.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # fn foo() {};\n # fn bar() {};\n # fn baz() {};\n if {\n     foo();\n } == {\n     bar();\n } {\n     baz();\n }\n ```\n is equal to\n ```rust\n # fn foo() {};\n # fn bar() {};\n # fn baz() {};\n {\n     foo();\n     bar();\n     baz();\n }\n ```\n\n For asserts:\n ```rust\n # fn foo() {};\n # fn bar() {};\n assert_eq!({ foo(); }, { bar(); });\n ```\n will always succeed\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "unit_arg",
-    "id_span": {
-      "path": "src/types.rs",
-      "line": 922
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks for passing a unit value as an argument to a function without using a unit literal (`()`).\n\n **Why is this bad?** This is likely the result of an accidental semicolon.\n\n **Known problems:** None.\n\n **Example:**\n ```rust,ignore\n foo({\n     let a = bar();\n     baz(a);\n })\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": true,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "cast_precision_loss",
-    "id_span": {
-      "path": "src/types.rs",
-      "line": 1158
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Checks for casts from any numerical to a float type where the receiving type cannot store all values from the original type without\n rounding errors. This possible rounding is to be expected, so this lint is\n `Allow` by default.\n\n Basically, this warns on casting any integer with 32 or more bits to `f32`\n or any 64-bit integer to `f64`.\n\n **Why is this bad?** It's not bad at all. But in some applications it can be\n helpful to know where precision loss can take place. This lint can help find\n those places in the code.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n let x = u64::MAX;\n x as f64;\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "cast_sign_loss",
-    "id_span": {
-      "path": "src/types.rs",
-      "line": 1179
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Checks for casts from a signed to an unsigned numerical type. In this case, negative values wrap around to large positive values,\n which can be quite surprising in practice. However, as the cast works as\n defined, this lint is `Allow` by default.\n\n **Why is this bad?** Possibly surprising results. You can activate this lint\n as a one-time check to see where numerical wrapping can arise.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n let y: i8 = -1;\n y as u128; // will return 18446744073709551615\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "cast_possible_truncation",
-    "id_span": {
-      "path": "src/types.rs",
-      "line": 1201
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Checks for casts between numerical types that may truncate large values. This is expected behavior, so the cast is `Allow` by\n default.\n\n **Why is this bad?** In some problem domains, it is good practice to avoid\n truncation. This lint can be activated to help assess where additional\n checks could be beneficial.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n fn as_u8(x: u64) -> u8 {\n     x as u8\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "cast_possible_wrap",
-    "id_span": {
-      "path": "src/types.rs",
-      "line": 1224
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Checks for casts from an unsigned type to a signed type of the same size. Performing such a cast is a 'no-op' for the compiler,\n i.e., nothing is changed at the bit level, and the binary representation of\n the value is reinterpreted. This can cause wrapping if the value is too big\n for the target signed type. However, the cast works as defined, so this lint\n is `Allow` by default.\n\n **Why is this bad?** While such a cast is not bad in itself, the results can\n be surprising when this is not the intended behavior, as demonstrated by the\n example below.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n u32::MAX as i32; // will yield a value of `-1`\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "cast_lossless",
-    "id_span": {
-      "path": "src/types.rs",
-      "line": 1256
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Checks for casts between numerical types that may be replaced by safe conversion functions.\n\n **Why is this bad?** Rust's `as` keyword will perform many kinds of\n conversions, including silently lossy conversions. Conversion functions such\n as `i32::from` will only perform lossless conversions. Using the conversion\n functions prevents conversions from turning into silent lossy conversions if\n the types of the input expressions ever change, and make it easier for\n people reading the code to know that the conversion is lossless.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n fn as_u64(x: u8) -> u64 {\n     x as u64\n }\n ```\n\n Using `::from` would look like this:\n\n ```rust\n fn as_u64(x: u8) -> u64 {\n     u64::from(x)\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "unnecessary_cast",
-    "id_span": {
-      "path": "src/types.rs",
-      "line": 1281
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks for casts to the same type, casts of int literals to integer types and casts of float literals to float types.\n\n **Why is this bad?** It's just unnecessary.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n let _ = 2i32 as i32;\n let _ = 0.5 as f32;\n ```\n\n Better:\n\n ```rust\n let _ = 2_i32;\n let _ = 0.5_f32;\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "cast_ptr_alignment",
-    "id_span": {
-      "path": "src/types.rs",
-      "line": 1305
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Checks for casts, using `as` or `pointer::cast`, from a less-strictly-aligned pointer to a more-strictly-aligned pointer\n\n **Why is this bad?** Dereferencing the resulting pointer may be undefined\n behavior.\n\n **Known problems:** Using `std::ptr::read_unaligned` and `std::ptr::write_unaligned` or similar\n on the resulting pointer is fine. Is over-zealous: Casts with manual alignment checks or casts like\n u64-> u8 -> u16 can be fine. Miri is able to do a more in-depth analysis.\n\n **Example:**\n ```rust\n let _ = (&1u8 as *const u8) as *const u16;\n let _ = (&mut 1u8 as *mut u8) as *mut u16;\n\n (&1u8 as *const u8).cast::<u16>();\n (&mut 1u8 as *mut u8).cast::<u16>();\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "fn_to_numeric_cast",
-    "id_span": {
-      "path": "src/types.rs",
-      "line": 1332
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for casts of function pointers to something other than usize\n **Why is this bad?**\n Casting a function pointer to anything other than usize/isize is not portable across\n architectures, because you end up losing bits if the target type is too small or end up with a\n bunch of extra bits that waste space and add more instructions to the final binary than\n strictly necessary for the problem\n\n Casting to isize also doesn't make sense since there are no signed addresses.\n\n **Example**\n\n ```rust\n // Bad\n fn fun() -> i32 { 1 }\n let a = fun as i64;\n\n // Good\n fn fun2() -> i32 { 1 }\n let a = fun2 as usize;\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MaybeIncorrect"
-    }
-  },
-  {
-    "id": "fn_to_numeric_cast_with_truncation",
-    "id_span": {
-      "path": "src/types.rs",
-      "line": 1362
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for casts of a function pointer to a numeric type not wide enough to store address.\n\n **Why is this bad?**\n Such a cast discards some bits of the function's address. If this is intended, it would be more\n clearly expressed by casting to usize first, then casting the usize to the intended type (with\n a comment) to perform the truncation.\n\n **Example**\n\n ```rust\n // Bad\n fn fn1() -> i16 {\n     1\n };\n let _ = fn1 as i32;\n\n // Better: Cast to usize first, then comment with the reason for the truncation\n fn fn2() -> i16 {\n     1\n };\n let fn_ptr = fn2 as usize;\n let fn_ptr_truncated = fn_ptr as i32;\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MaybeIncorrect"
-    }
-  },
-  {
-    "id": "type_complexity",
-    "id_span": {
-      "path": "src/types.rs",
-      "line": 1897
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks for types used in structs, parameters and `let` declarations above a certain complexity threshold.\n\n **Why is this bad?** Too complex types make the code less readable. Consider\n using a `type` definition to simplify them.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # use std::rc::Rc;\n struct Foo {\n     inner: Rc<Vec<Vec<Box<(u32, u32, u32, u32)>>>>,\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "char_lit_as_u8",
-    "id_span": {
-      "path": "src/types.rs",
-      "line": 2068
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks for expressions where a character literal is cast to `u8` and suggests using a byte literal instead.\n\n **Why is this bad?** In general, casting values to smaller types is\n error-prone and should be avoided where possible. In the particular case of\n converting a character literal to u8, it is easy to avoid by just using a\n byte literal instead. As an added bonus, `b'a'` is even slightly shorter\n than `'a' as u8`.\n\n **Known problems:** None.\n\n **Example:**\n ```rust,ignore\n 'x' as u8\n ```\n\n A better version, using the byte literal:\n\n ```rust,ignore\n b'x'\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "absurd_extreme_comparisons",
-    "id_span": {
-      "path": "src/types.rs",
-      "line": 2133
-    },
-    "group": "clippy::correctness",
-    "docs": " **What it does:** Checks for comparisons where one side of the relation is either the minimum or maximum value for its type and warns if it involves a\n case that is always true or always false. Only integer and boolean types are\n checked.\n\n **Why is this bad?** An expression like `min <= x` may misleadingly imply\n that it is possible for `x` to be less than the minimum. Expressions like\n `max < x` are probably mistakes.\n\n **Known problems:** For `usize` the size of the current compile target will\n be assumed (e.g., 64 bits on 64 bit systems). This means code that uses such\n a comparison to detect target pointer width will trigger this lint. One can\n use `mem::sizeof` and compare its value or conditional compilation\n attributes\n like `#[cfg(target_pointer_width = \"64\")] ..` instead.\n\n **Example:**\n\n ```rust\n let vec: Vec<isize> = Vec::new();\n if vec.len() <= 0 {}\n if 100 > i32::MAX {}\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "invalid_upcast_comparisons",
-    "id_span": {
-      "path": "src/types.rs",
-      "line": 2294
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Checks for comparisons where the relation is always either true or false, but where one side has been upcast so that the comparison is\n necessary. Only integer types are checked.\n\n **Why is this bad?** An expression like `let x : u8 = ...; (x as u32) > 300`\n will mistakenly imply that it is possible for `x` to be outside the range of\n `u8`.\n\n **Known problems:**\n https://github.com/rust-lang/rust-clippy/issues/886\n\n **Example:**\n ```rust\n let x: u8 = 1;\n (x as u32) > 300;\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "implicit_hasher",
-    "id_span": {
-      "path": "src/types.rs",
-      "line": 2515
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Checks for public `impl` or `fn` missing generalization over different hashers and implicitly defaulting to the default hashing\n algorithm (`SipHash`).\n\n **Why is this bad?** `HashMap` or `HashSet` with custom hashers cannot be\n used with them.\n\n **Known problems:** Suggestions for replacing constructors can contain\n false-positives. Also applying suggestions can require modification of other\n pieces of code, possibly including external crates.\n\n **Example:**\n ```rust\n # use std::collections::HashMap;\n # use std::hash::{Hash, BuildHasher};\n # trait Serialize {};\n impl<K: Hash + Eq, V> Serialize for HashMap<K, V> { }\n\n pub fn foo(map: &mut HashMap<i32, i32>) { }\n ```\n could be rewritten as\n ```rust\n # use std::collections::HashMap;\n # use std::hash::{Hash, BuildHasher};\n # trait Serialize {};\n impl<K: Hash + Eq, V, S: BuildHasher> Serialize for HashMap<K, V, S> { }\n\n pub fn foo<S: BuildHasher>(map: &mut HashMap<i32, i32, S>) { }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "cast_ref_to_mut",
-    "id_span": {
-      "path": "src/types.rs",
-      "line": 2866
-    },
-    "group": "clippy::correctness",
-    "docs": " **What it does:** Checks for casts of `&T` to `&mut T` anywhere in the code.\n **Why is this bad?** It’s basically guaranteed to be undefined behaviour.\n `UnsafeCell` is the only way to obtain aliasable data that is considered\n mutable.\n\n **Known problems:** None.\n\n **Example:**\n ```rust,ignore\n fn x(r: &i32) {\n     unsafe {\n         *(r as *const _ as *mut _) += 1;\n     }\n }\n ```\n\n Instead consider using interior mutability types.\n\n ```rust\n use std::cell::UnsafeCell;\n\n fn x(r: &UnsafeCell<i32>) {\n     unsafe {\n         *r.get() += 1;\n     }\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "ptr_as_ptr",
-    "id_span": {
-      "path": "src/types.rs",
-      "line": 2922
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Checks for `as` casts between raw pointers without changing its mutability,\n namely `*const T` to `*const U` and `*mut T` to `*mut U`.\n\n **Why is this bad?**\n Though `as` casts between raw pointers is not terrible, `pointer::cast` is safer because\n it cannot accidentally change the pointer's mutability nor cast the pointer to other types like `usize`.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n let ptr: *const u32 = &42_u32;\n let mut_ptr: *mut u32 = &mut 42_u32;\n let _ = ptr as *const i32;\n let _ = mut_ptr as *mut i32;\n ```\n Use instead:\n ```rust\n let ptr: *const u32 = &42_u32;\n let mut_ptr: *mut u32 = &mut 42_u32;\n let _ = ptr.cast::<i32>();\n let _ = mut_ptr.cast::<i32>();\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "undropped_manually_drops",
-    "id_span": {
-      "path": "src/undropped_manually_drops.rs",
-      "line": 27
-    },
-    "group": "clippy::correctness",
-    "docs": " **What it does:** Prevents the safe `std::mem::drop` function from being called on `std::mem::ManuallyDrop`.\n **Why is this bad?** The safe `drop` function does not drop the inner value of a `ManuallyDrop`.\n\n **Known problems:** Does not catch cases if the user binds `std::mem::drop`\n to a different name and calls it that way.\n\n **Example:**\n\n ```rust\n struct S;\n drop(std::mem::ManuallyDrop::new(S));\n ```\n Use instead:\n ```rust\n struct S;\n unsafe {\n     std::mem::ManuallyDrop::drop(&mut std::mem::ManuallyDrop::new(S));\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "invisible_characters",
-    "id_span": {
-      "path": "src/unicode.rs",
-      "line": 20
-    },
-    "group": "clippy::correctness",
-    "docs": " **What it does:** Checks for invisible Unicode characters in the code.\n **Why is this bad?** Having an invisible character in the code makes for all\n sorts of April fools, but otherwise is very much frowned upon.\n\n **Known problems:** None.\n\n **Example:** You don't see it, but there may be a zero-width space or soft hyphen\n some­where in this text.\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "non_ascii_literal",
-    "id_span": {
-      "path": "src/unicode.rs",
-      "line": 44
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Checks for non-ASCII characters in string literals.\n **Why is this bad?** Yeah, we know, the 90's called and wanted their charset\n back. Even so, there still are editors and other programs out there that\n don't work well with Unicode. So if the code is meant to be used\n internationally, on multiple operating systems, or has other portability\n requirements, activating this lint could be useful.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n let x = String::from(\"€\");\n ```\n Could be written as:\n ```rust\n let x = String::from(\"\\u{20ac}\");\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "unicode_not_nfc",
-    "id_span": {
-      "path": "src/unicode.rs",
-      "line": 61
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Checks for string literals that contain Unicode in a form that is not equal to its\n [NFC-recomposition](http://www.unicode.org/reports/tr15/#Norm_Forms).\n\n **Why is this bad?** If such a string is compared to another, the results\n may be surprising.\n\n **Known problems** None.\n\n **Example:** You may not see it, but \"à\"\" and \"à\"\" aren't the same string. The\n former when escaped is actually `\"a\\u{300}\"` while the latter is `\"\\u{e0}\"`.\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "unit_return_expecting_ord",
-    "id_span": {
-      "path": "src/unit_return_expecting_ord.rs",
-      "line": 30
-    },
-    "group": "clippy::correctness",
-    "docs": " **What it does:** Checks for functions that expect closures of type Fn(...) -> Ord where the implemented closure returns the unit type.\n The lint also suggests to remove the semi-colon at the end of the statement if present.\n\n **Why is this bad?** Likely, returning the unit type is unintentional, and\n could simply be caused by an extra semi-colon. Since () implements Ord\n it doesn't cause a compilation error.\n This is the same reasoning behind the unit_cmp lint.\n\n **Known problems:** If returning unit is intentional, then there is no\n way of specifying this without triggering needless_return lint\n\n **Example:**\n\n ```rust\n let mut twins = vec!((1, 1), (2, 2));\n twins.sort_by_key(|x| { x.1; });\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "fn_address_comparisons",
-    "id_span": {
-      "path": "src/unnamed_address.rs",
-      "line": 27
-    },
-    "group": "clippy::correctness",
-    "docs": " **What it does:** Checks for comparisons with an address of a function item.\n **Why is this bad?** Function item address is not guaranteed to be unique and could vary\n between different code generation units. Furthermore different function items could have\n the same address after being merged together.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n type F = fn();\n fn a() {}\n let f: F = a;\n if f == a {\n     // ...\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "vtable_address_comparisons",
-    "id_span": {
-      "path": "src/unnamed_address.rs",
-      "line": 51
-    },
-    "group": "clippy::correctness",
-    "docs": " **What it does:** Checks for comparisons with an address of a trait vtable.\n **Why is this bad?** Comparing trait objects pointers compares an vtable addresses which\n are not guaranteed to be unique and could vary between different code generation units.\n Furthermore vtables for different types could have the same address after being merged\n together.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust,ignore\n let a: Rc<dyn Trait> = ...\n let b: Rc<dyn Trait> = ...\n if Rc::ptr_eq(&a, &b) {\n     ...\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "unnecessary_sort_by",
-    "id_span": {
-      "path": "src/unnecessary_sort_by.rs",
-      "line": 41
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Detects uses of `Vec::sort_by` passing in a closure\n which compares the two arguments, either directly or indirectly.\n\n **Why is this bad?**\n It is more clear to use `Vec::sort_by_key` (or `Vec::sort` if\n possible) than to use `Vec::sort_by` and a more complicated\n closure.\n\n **Known problems:**\n If the suggested `Vec::sort_by_key` uses Reverse and it isn't already\n imported by a use statement, then it will need to be added manually.\n\n **Example:**\n\n ```rust\n # struct A;\n # impl A { fn foo(&self) {} }\n # let mut vec: Vec<A> = Vec::new();\n vec.sort_by(|a, b| a.foo().cmp(&b.foo()));\n ```\n Use instead:\n ```rust\n # struct A;\n # impl A { fn foo(&self) {} }\n # let mut vec: Vec<A> = Vec::new();\n vec.sort_by_key(|a| a.foo());\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "unnecessary_wraps",
-    "id_span": {
-      "path": "src/unnecessary_wraps.rs",
-      "line": 50
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Checks for private functions that only return `Ok` or `Some`.\n **Why is this bad?** It is not meaningful to wrap values when no `None` or `Err` is returned.\n\n **Known problems:** There can be false positives if the function signature is designed to\n fit some external requirement.\n\n **Example:**\n\n ```rust\n fn get_cool_number(a: bool, b: bool) -> Option<i32> {\n     if a && b {\n         return Some(50);\n     }\n     if a {\n         Some(0)\n     } else {\n         Some(10)\n     }\n }\n ```\n Use instead:\n ```rust\n fn get_cool_number(a: bool, b: bool) -> i32 {\n     if a && b {\n         return 50;\n     }\n     if a {\n         0\n     } else {\n         10\n     }\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": true,
-      "applicability": "MaybeIncorrect"
-    }
-  },
-  {
-    "id": "unnested_or_patterns",
-    "id_span": {
-      "path": "src/unnested_or_patterns.rs",
-      "line": 47
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:**\n Checks for unnested or-patterns, e.g., `Some(0) | Some(2)` and\n suggests replacing the pattern with a nested one, `Some(0 | 2)`.\n\n Another way to think of this is that it rewrites patterns in\n *disjunctive normal form (DNF)* into *conjunctive normal form (CNF)*.\n\n **Why is this bad?**\n\n In the example above, `Some` is repeated, which unncessarily complicates the pattern.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n fn main() {\n     if let Some(0) | Some(2) = Some(0) {}\n }\n ```\n Use instead:\n ```rust\n #![feature(or_patterns)]\n\n fn main() {\n     if let Some(0 | 2) = Some(0) {}\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "unsafe_removed_from_name",
-    "id_span": {
-      "path": "src/unsafe_removed_from_name.rs",
-      "line": 24
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for imports that remove \"unsafe\" from an item's name.\n\n **Why is this bad?** Renaming makes it less clear which traits and\n structures are unsafe.\n\n **Known problems:** None.\n\n **Example:**\n ```rust,ignore\n use std::cell::{UnsafeCell as TotallySafeCell};\n\n extern crate crossbeam;\n use crossbeam::{spawn_unsafe as spawn};\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "unused_io_amount",
-    "id_span": {
-      "path": "src/unused_io_amount.rs",
-      "line": 28
-    },
-    "group": "clippy::correctness",
-    "docs": " **What it does:** Checks for unused written/read amount.\n **Why is this bad?** `io::Write::write(_vectored)` and\n `io::Read::read(_vectored)` are not guaranteed to\n process the entire buffer. They return how many bytes were processed, which\n might be smaller\n than a given buffer's length. If you don't need to deal with\n partial-write/read, use\n `write_all`/`read_exact` instead.\n\n **Known problems:** Detects only common patterns.\n\n **Example:**\n ```rust,ignore\n use std::io;\n fn foo<W: io::Write>(w: &mut W) -> io::Result<()> {\n     // must be `w.write_all(b\"foo\")?;`\n     w.write(b\"foo\")?;\n     Ok(())\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "unused_self",
-    "id_span": {
-      "path": "src/unused_self.rs",
-      "line": 33
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Checks methods that contain a `self` argument but don't use it\n **Why is this bad?** It may be clearer to define the method as an associated function instead\n of an instance method if it doesn't require `self`.\n\n **Known problems:** None.\n\n **Example:**\n ```rust,ignore\n struct A;\n impl A {\n     fn method(&self) {}\n }\n ```\n\n Could be written:\n\n ```rust,ignore\n struct A;\n impl A {\n     fn method() {}\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "unused_unit",
-    "id_span": {
-      "path": "src/unused_unit.rs",
-      "line": 27
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for unit (`()`) expressions that can be removed.\n **Why is this bad?** Such expressions add no value, but can make the code\n less readable. Depending on formatting they can make a `break` or `return`\n statement look like a function call.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n fn return_unit() -> () {\n     ()\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "unnecessary_unwrap",
-    "id_span": {
-      "path": "src/unwrap.rs",
-      "line": 40
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks for calls of `unwrap[_err]()` that cannot fail.\n **Why is this bad?** Using `if let` or `match` is more idiomatic.\n\n **Known problems:** None\n\n **Example:**\n ```rust\n # let option = Some(0);\n # fn do_something_with(_x: usize) {}\n if option.is_some() {\n     do_something_with(option.unwrap())\n }\n ```\n\n Could be written:\n\n ```rust\n # let option = Some(0);\n # fn do_something_with(_x: usize) {}\n if let Some(value) = option {\n     do_something_with(value)\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "panicking_unwrap",
-    "id_span": {
-      "path": "src/unwrap.rs",
-      "line": 63
-    },
-    "group": "clippy::correctness",
-    "docs": " **What it does:** Checks for calls of `unwrap[_err]()` that will always fail.\n **Why is this bad?** If panicking is desired, an explicit `panic!()` should be used.\n\n **Known problems:** This lint only checks `if` conditions not assignments.\n So something like `let x: Option<()> = None; x.unwrap();` will not be recognized.\n\n **Example:**\n ```rust\n # let option = Some(0);\n # fn do_something_with(_x: usize) {}\n if option.is_none() {\n     do_something_with(option.unwrap())\n }\n ```\n\n This code will always panic. The if condition should probably be inverted.\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "unwrap_in_result",
-    "id_span": {
-      "path": "src/unwrap_in_result.rs",
-      "line": 47
-    },
-    "group": "clippy::restriction",
-    "docs": " **What it does:** Checks for functions of type Result that contain `expect()` or `unwrap()`\n **Why is this bad?** These functions promote recoverable errors to non-recoverable errors which may be undesirable in code bases which wish to avoid panics.\n\n **Known problems:** This can cause false positives in functions that handle both recoverable and non recoverable errors.\n\n **Example:**\n Before:\n ```rust\n fn divisible_by_3(i_str: String) -> Result<(), String> {\n     let i = i_str\n         .parse::<i32>()\n         .expect(\"cannot divide the input by three\");\n\n     if i % 3 != 0 {\n         Err(\"Number is not divisible by 3\")?\n     }\n\n     Ok(())\n }\n ```\n\n After:\n ```rust\n fn divisible_by_3(i_str: String) -> Result<(), String> {\n     let i = i_str\n         .parse::<i32>()\n         .map_err(|e| format!(\"cannot divide the input by three: {}\", e))?;\n\n     if i % 3 != 0 {\n         Err(\"Number is not divisible by 3\")?\n     }\n\n     Ok(())\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "upper_case_acronyms",
-    "id_span": {
-      "path": "src/upper_case_acronyms.rs",
-      "line": 35
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** Checks for fully capitalized names and optionally names containing a capitalized acronym.\n **Why is this bad?** In CamelCase, acronyms count as one word.\n See [naming conventions](https://rust-lang.github.io/api-guidelines/naming.html#casing-conforms-to-rfc-430-c-case)\n for more.\n\n By default, the lint only triggers on fully-capitalized names.\n You can use the `upper-case-acronyms-aggressive: true` config option to enable linting\n on all camel case names\n\n **Known problems:** When two acronyms are contiguous, the lint can't tell where\n the first acronym ends and the second starts, so it suggests to lowercase all of\n the letters in the second acronym.\n\n **Example:**\n\n ```rust\n struct HTTPResponse;\n ```\n Use instead:\n ```rust\n struct HttpResponse;\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MaybeIncorrect"
-    }
-  },
-  {
-    "id": "use_self",
-    "id_span": {
-      "path": "src/use_self.rs",
-      "line": 53
-    },
-    "group": "clippy::nursery",
-    "docs": " **What it does:** Checks for unnecessary repetition of structure name when a replacement with `Self` is applicable.\n\n **Why is this bad?** Unnecessary repetition. Mixed use of `Self` and struct\n name\n feels inconsistent.\n\n **Known problems:**\n - Unaddressed false negative in fn bodies of trait implementations\n - False positive with assotiated types in traits (#4140)\n\n **Example:**\n\n ```rust\n struct Foo {}\n impl Foo {\n     fn new() -> Foo {\n         Foo {}\n     }\n }\n ```\n could be\n ```rust\n struct Foo {}\n impl Foo {\n     fn new() -> Self {\n         Self {}\n     }\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "useless_conversion",
-    "id_span": {
-      "path": "src/useless_conversion.rs",
-      "line": 32
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks for `Into`, `TryInto`, `From`, `TryFrom`, or `IntoIter` calls which uselessly convert to the same type.\n\n **Why is this bad?** Redundant code.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n // Bad\n // format!() returns a `String`\n let s: String = format!(\"hello\").into();\n\n // Good\n let s: String = format!(\"hello\");\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "useless_vec",
-    "id_span": {
-      "path": "src/vec.rs",
-      "line": 36
-    },
-    "group": "clippy::perf",
-    "docs": " **What it does:** Checks for usage of `&vec![..]` when using `&[..]` would be possible.\n\n **Why is this bad?** This is less efficient.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # fn foo(my_vec: &[u8]) {}\n\n // Bad\n foo(&vec![1, 2]);\n\n // Good\n foo(&[1, 2]);\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "vec_init_then_push",
-    "id_span": {
-      "path": "src/vec_init_then_push.rs",
-      "line": 32
-    },
-    "group": "clippy::perf",
-    "docs": " **What it does:** Checks for calls to `push` immediately after creating a new `Vec`.\n **Why is this bad?** The `vec![]` macro is both more performant and easier to read than\n multiple `push` calls.\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust\n let mut v = Vec::new();\n v.push(0);\n ```\n Use instead:\n ```rust\n let v = vec![0];\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "HasPlaceholders"
-    }
-  },
-  {
-    "id": "vec_resize_to_zero",
-    "id_span": {
-      "path": "src/vec_resize_to_zero.rs",
-      "line": 24
-    },
-    "group": "clippy::correctness",
-    "docs": " **What it does:** Finds occurrences of `Vec::resize(0, an_int)`\n **Why is this bad?** This is probably an argument inversion mistake.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n vec!(1, 2, 3, 4, 5).resize(0, 5)\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MaybeIncorrect"
-    }
-  },
-  {
-    "id": "verbose_file_reads",
-    "id_span": {
-      "path": "src/verbose_file_reads.rs",
-      "line": 29
-    },
-    "group": "clippy::restriction",
-    "docs": " **What it does:** Checks for use of File::read_to_end and File::read_to_string.\n **Why is this bad?** `fs::{read, read_to_string}` provide the same functionality when `buf` is empty with fewer imports and no intermediate values.\n See also: [fs::read docs](https://doc.rust-lang.org/std/fs/fn.read.html), [fs::read_to_string docs](https://doc.rust-lang.org/std/fs/fn.read_to_string.html)\n\n **Known problems:** None.\n\n **Example:**\n\n ```rust,no_run\n # use std::io::Read;\n # use std::fs::File;\n let mut f = File::open(\"foo.txt\").unwrap();\n let mut bytes = Vec::new();\n f.read_to_end(&mut bytes).unwrap();\n ```\n Can be written more concisely as\n ```rust,no_run\n # use std::fs;\n let mut bytes = fs::read(\"foo.txt\").unwrap();\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "wildcard_dependencies",
-    "id_span": {
-      "path": "src/wildcard_dependencies.rs",
-      "line": 24
-    },
-    "group": "clippy::cargo",
-    "docs": " **What it does:** Checks for wildcard dependencies in the `Cargo.toml`.\n **Why is this bad?** [As the edition guide says](https://rust-lang-nursery.github.io/edition-guide/rust-2018/cargo-and-crates-io/crates-io-disallows-wildcard-dependencies.html),\n it is highly unlikely that you work with any possible version of your dependency,\n and wildcard dependencies would cause unnecessary breakage in the ecosystem.\n\n **Known problems:** None.\n\n **Example:**\n\n ```toml\n [dependencies]\n regex = \"*\"\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "enum_glob_use",
-    "id_span": {
-      "path": "src/wildcard_imports.rs",
-      "line": 32
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Checks for `use Enum::*`.\n **Why is this bad?** It is usually better style to use the prefixed name of\n an enumeration variant, rather than importing variants.\n\n **Known problems:** Old-style enumerations that prefix the variants are\n still around.\n\n **Example:**\n ```rust,ignore\n // Bad\n use std::cmp::Ordering::*;\n foo(Less);\n\n // Good\n use std::cmp::Ordering;\n foo(Ordering::Less)\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "wildcard_imports",
-    "id_span": {
-      "path": "src/wildcard_imports.rs",
-      "line": 83
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Checks for wildcard imports `use _::*`.\n **Why is this bad?** wildcard imports can pollute the namespace. This is especially bad if\n you try to import something through a wildcard, that already has been imported by name from\n a different source:\n\n ```rust,ignore\n use crate1::foo; // Imports a function named foo\n use crate2::*; // Has a function named foo\n\n foo(); // Calls crate1::foo\n ```\n\n This can lead to confusing error messages at best and to unexpected behavior at worst.\n\n **Exceptions:**\n\n Wildcard imports are allowed from modules named `prelude`. Many crates (including the standard library)\n provide modules named \"prelude\" specifically designed for wildcard import.\n\n `use super::*` is allowed in test modules. This is defined as any module with \"test\" in the name.\n\n These exceptions can be disabled using the `warn-on-all-wildcard-imports` configuration flag.\n\n **Known problems:** If macros are imported through the wildcard, this macro is not included\n by the suggestion and has to be added by hand.\n\n Applying the suggestion when explicit imports of the things imported with a glob import\n exist, may result in `unused_imports` warnings.\n\n **Example:**\n\n ```rust,ignore\n // Bad\n use crate1::*;\n\n foo();\n ```\n\n ```rust,ignore\n // Good\n use crate1::foo;\n\n foo();\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "println_empty_string",
-    "id_span": {
-      "path": "src/write.rs",
-      "line": 33
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** This lint warns when you use `println!(\"\")` to print a newline.\n\n **Why is this bad?** You should use `println!()`, which is simpler.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n // Bad\n println!(\"\");\n\n // Good\n println!();\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "print_with_newline",
-    "id_span": {
-      "path": "src/write.rs",
-      "line": 57
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** This lint warns when you use `print!()` with a format string that ends in a newline.\n\n **Why is this bad?** You should use `println!()` instead, which appends the\n newline.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # let name = \"World\";\n print!(\"Hello {}!\\n\", name);\n ```\n use println!() instead\n ```rust\n # let name = \"World\";\n println!(\"Hello {}!\", name);\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": true,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "print_stdout",
-    "id_span": {
-      "path": "src/write.rs",
-      "line": 75
-    },
-    "group": "clippy::restriction",
-    "docs": " **What it does:** Checks for printing on *stdout*. The purpose of this lint is to catch debugging remnants.\n\n **Why is this bad?** People often print on *stdout* while debugging an\n application and might forget to remove those prints afterward.\n\n **Known problems:** Only catches `print!` and `println!` calls.\n\n **Example:**\n ```rust\n println!(\"Hello world!\");\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "print_stderr",
-    "id_span": {
-      "path": "src/write.rs",
-      "line": 93
-    },
-    "group": "clippy::restriction",
-    "docs": " **What it does:** Checks for printing on *stderr*. The purpose of this lint is to catch debugging remnants.\n\n **Why is this bad?** People often print on *stderr* while debugging an\n application and might forget to remove those prints afterward.\n\n **Known problems:** Only catches `eprint!` and `eprintln!` calls.\n\n **Example:**\n ```rust\n eprintln!(\"Hello world!\");\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "use_debug",
-    "id_span": {
-      "path": "src/write.rs",
-      "line": 110
-    },
-    "group": "clippy::restriction",
-    "docs": " **What it does:** Checks for use of `Debug` formatting. The purpose of this lint is to catch debugging remnants.\n\n **Why is this bad?** The purpose of the `Debug` trait is to facilitate\n debugging Rust code. It should not be used in user-facing output.\n\n **Example:**\n ```rust\n # let foo = \"bar\";\n println!(\"{:?}\", foo);\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "print_literal",
-    "id_span": {
-      "path": "src/write.rs",
-      "line": 133
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** This lint warns about the use of literals as `print!`/`println!` args.\n **Why is this bad?** Using literals as `println!` args is inefficient\n (c.f., https://github.com/matthiaskrgr/rust-str-bench) and unnecessary\n (i.e., just put the literal in the format string)\n\n **Known problems:** Will also warn with macro calls as arguments that expand to literals\n -- e.g., `println!(\"{}\", env!(\"FOO\"))`.\n\n **Example:**\n ```rust\n println!(\"{}\", \"foo\");\n ```\n use the literal without formatting:\n ```rust\n println!(\"foo\");\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "writeln_empty_string",
-    "id_span": {
-      "path": "src/write.rs",
-      "line": 156
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** This lint warns when you use `writeln!(buf, \"\")` to print a newline.\n\n **Why is this bad?** You should use `writeln!(buf)`, which is simpler.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # use std::fmt::Write;\n # let mut buf = String::new();\n // Bad\n writeln!(buf, \"\");\n\n // Good\n writeln!(buf);\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "write_with_newline",
-    "id_span": {
-      "path": "src/write.rs",
-      "line": 182
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** This lint warns when you use `write!()` with a format string that\n ends in a newline.\n\n **Why is this bad?** You should use `writeln!()` instead, which appends the\n newline.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n # use std::fmt::Write;\n # let mut buf = String::new();\n # let name = \"World\";\n // Bad\n write!(buf, \"Hello {}!\\n\", name);\n\n // Good\n writeln!(buf, \"Hello {}!\", name);\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": true,
-      "applicability": "MachineApplicable"
-    }
-  },
-  {
-    "id": "write_literal",
-    "id_span": {
-      "path": "src/write.rs",
-      "line": 207
-    },
-    "group": "clippy::style",
-    "docs": " **What it does:** This lint warns about the use of literals as `write!`/`writeln!` args.\n **Why is this bad?** Using literals as `writeln!` args is inefficient\n (c.f., https://github.com/matthiaskrgr/rust-str-bench) and unnecessary\n (i.e., just put the literal in the format string)\n\n **Known problems:** Will also warn with macro calls as arguments that expand to literals\n -- e.g., `writeln!(buf, \"{}\", env!(\"FOO\"))`.\n\n **Example:**\n ```rust\n # use std::fmt::Write;\n # let mut buf = String::new();\n // Bad\n writeln!(buf, \"{}\", \"foo\");\n\n // Good\n writeln!(buf, \"foo\");\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "zero_divided_by_zero",
-    "id_span": {
-      "path": "src/zero_div_zero.rs",
-      "line": 23
-    },
-    "group": "clippy::complexity",
-    "docs": " **What it does:** Checks for `0.0 / 0.0`.\n **Why is this bad?** It's less readable than `f32::NAN` or `f64::NAN`.\n\n **Known problems:** None.\n\n **Example:**\n ```rust\n // Bad\n let nan = 0.0f32 / 0.0;\n\n // Good\n let nan = f32::NAN;\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  },
-  {
-    "id": "zero_sized_map_values",
-    "id_span": {
-      "path": "src/zero_sized_map_values.rs",
-      "line": 37
-    },
-    "group": "clippy::pedantic",
-    "docs": " **What it does:** Checks for maps with zero-sized value types anywhere in the code.\n **Why is this bad?** Since there is only a single value for a zero-sized type, a map\n containing zero sized values is effectively a set. Using a set in that case improves\n readability and communicates intent more clearly.\n\n **Known problems:**\n * A zero-sized type cannot be recovered later if it contains private fields.\n * This lints the signature of public items\n\n **Example:**\n\n ```rust\n # use std::collections::HashMap;\n fn unique_words(text: &str) -> HashMap<&str, ()> {\n     todo!();\n }\n ```\n Use instead:\n ```rust\n # use std::collections::HashSet;\n fn unique_words(text: &str) -> HashSet<&str> {\n     todo!();\n }\n ```\n",
-    "applicability": {
-      "is_multi_suggestion": false,
-      "applicability": null
-    }
-  }
-]
diff --git a/tests/dogfood.rs b/tests/dogfood.rs
index b0da0bfcc35..604968ad8b0 100644
--- a/tests/dogfood.rs
+++ b/tests/dogfood.rs
@@ -41,10 +41,6 @@ fn dogfood_clippy() {
         command.args(&["-D", "clippy::internal"]);
     }
 
-    if cfg!(feature = "metadata-collector-lint") {
-        command.args(&["-D", "clippy::internal"]);
-    }
-
     let output = command.output().unwrap();
 
     println!("status: {}", output.status);
diff --git a/tests/ui-internal/metadata-collector/track_applicability_value.rs b/tests/ui-internal/metadata-collector/track_applicability_value.rs
deleted file mode 100644
index b0f59e5cf8a..00000000000
--- a/tests/ui-internal/metadata-collector/track_applicability_value.rs
+++ /dev/null
@@ -1,50 +0,0 @@
-#![deny(clippy::internal)]
-#![feature(rustc_private)]
-
-extern crate rustc_ast;
-extern crate rustc_errors;
-extern crate rustc_lint;
-extern crate rustc_session;
-extern crate rustc_span;
-
-use rustc_ast::ast::Expr;
-use rustc_errors::{Applicability, DiagnosticBuilder};
-use rustc_lint::{EarlyContext, EarlyLintPass, Lint, LintContext};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::source_map::Span;
-
-fn producer_fn() -> Applicability {
-    Applicability::MachineApplicable
-}
-
-fn modifier_fn(applicability: &mut Applicability) {
-    if let Applicability::MaybeIncorrect = applicability {
-        *applicability = Applicability::HasPlaceholders;
-    }
-}
-
-fn consumer_fn(_applicability: Applicability) {}
-
-struct Muh;
-
-impl Muh {
-    fn producer_method() -> Applicability {
-        Applicability::MachineApplicable
-    }
-}
-
-fn main() {
-    let mut applicability = producer_fn();
-    applicability = Applicability::MachineApplicable;
-    applicability = Muh::producer_method();
-
-    applicability = if true {
-        Applicability::HasPlaceholders
-    } else {
-        Applicability::MaybeIncorrect
-    };
-
-    modifier_fn(&mut applicability);
-
-    consumer_fn(applicability);
-}
-- 
cgit 1.4.1-3-g733a5


From c1fa1102d484b74cb7bc425994fa4246dd690ad3 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Fri, 12 Mar 2021 21:52:01 +0100
Subject: ENABLE_METADATA_COLLECTION env-value to disable default metadata
 collection

---
 clippy_lints/src/lib.rs                                |  6 +++++-
 .../src/utils/internal_lints/metadata_collector.rs     | 18 ------------------
 tests/dogfood.rs                                       |  2 ++
 3 files changed, 7 insertions(+), 19 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 7668d4dd0b1..1a74f641554 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1005,7 +1005,11 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         store.register_late_pass(|| box utils::internal_lints::OuterExpnDataPass);
     }
     #[cfg(feature = "metadata-collector-lint")]
-    store.register_late_pass(|| box utils::internal_lints::metadata_collector::MetadataCollector::default());
+    {
+        if std::env::var("ENABLE_METADATA_COLLECTION").eq(&Ok("1".to_string())) {
+            store.register_late_pass(|| box utils::internal_lints::metadata_collector::MetadataCollector::default());
+        }
+    }
 
     store.register_late_pass(|| box utils::author::Author);
     store.register_late_pass(|| box await_holding_invalid::AwaitHolding);
diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index 37e90bf8686..07abae31386 100644
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -148,24 +148,6 @@ struct LintMetadata {
     applicability: Option<ApplicabilityInfo>,
 }
 
-// impl Ord for LintMetadata {
-//     fn cmp(&self, other: &Self) -> Ordering {
-//         self.id.cmp(&other.id)
-//     }
-// }
-//
-// impl PartialOrd for LintMetadata {
-//     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-//         Some(self.cmp(other))
-//     }
-// }
-//
-// impl PartialEq for LintMetadata {
-//     fn eq(&self, other: &Self) -> bool {
-//         self.id == other.id
-//     }
-// }
-
 impl LintMetadata {
     fn new(id: String, id_span: SerializableSpan, group: String, docs: String) -> Self {
         Self {
diff --git a/tests/dogfood.rs b/tests/dogfood.rs
index 604968ad8b0..6524fd4706c 100644
--- a/tests/dogfood.rs
+++ b/tests/dogfood.rs
@@ -22,12 +22,14 @@ fn dogfood_clippy() {
         return;
     }
     let root_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+    let enable_metadata_collection = std::env::var("ENABLE_METADATA_COLLECTION").unwrap_or_else(|_| "0".to_string());
 
     let mut command = Command::new(&*CLIPPY_PATH);
     command
         .current_dir(root_dir)
         .env("CLIPPY_DOGFOOD", "1")
         .env("CARGO_INCREMENTAL", "0")
+        .env("ENABLE_METADATA_COLLECTION", &enable_metadata_collection)
         .arg("clippy")
         .arg("--all-targets")
         .arg("--all-features")
-- 
cgit 1.4.1-3-g733a5


From 62cafe2c02440cb1cc7cc9cbf1abe63942a19e51 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Fri, 12 Mar 2021 20:59:41 +0100
Subject: Applying PR suggestions

---
 clippy_lints/src/utils/internal_lints/metadata_collector.rs | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index 07abae31386..b7bb557f957 100644
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -32,7 +32,7 @@ use crate::utils::{
 };
 
 /// This is the output file of the lint collector.
-const OUTPUT_FILE: &str = "../metadata_collection.json";
+const OUTPUT_FILE: &str = "../util/gh-pages/metadata_collection.json";
 /// These lints are excluded from the export.
 const BLACK_LISTED_LINTS: [&str; 3] = ["lint_author", "deep_code_inspection", "internal_metadata_collector"];
 /// These groups will be ignored by the lint group matcher. This is useful for collections like
@@ -62,7 +62,7 @@ const SUGGESTION_DIAGNOSTIC_BUILDER_METHODS: [(&str, bool); 9] = [
     ("span_suggestions", true),
 ];
 const SUGGESTION_FUNCTIONS: [&[&str]; 2] = [
-    &["clippy_utils", "diagnostics", "mutispan_sugg"],
+    &["clippy_utils", "diagnostics", "multispan_sugg"],
     &["clippy_utils", "diagnostics", "multispan_sugg_with_applicability"],
 ];
 
@@ -226,11 +226,8 @@ impl<'hir> LateLintPass<'hir> for MetadataCollector {
     fn check_item(&mut self, cx: &LateContext<'hir>, item: &'hir Item<'_>) {
         if_chain! {
             // item validation
-            if let ItemKind::Static(ref ty, Mutability::Not, body_id) = item.kind;
+            if let ItemKind::Static(ref ty, Mutability::Not, _) = item.kind;
             if is_lint_ref_type(cx, ty);
-            let expr = &cx.tcx.hir().body(body_id).value;
-            if let ExprKind::AddrOf(_, _, ref inner_exp) = expr.kind;
-            if let ExprKind::Struct(_, _, _) = inner_exp.kind;
             // blacklist check
             let lint_name = sym_to_string(item.ident.name).to_ascii_lowercase();
             if !BLACK_LISTED_LINTS.contains(&lint_name.as_str());
-- 
cgit 1.4.1-3-g733a5


From e0eb29c936602553f7952a4d12c7d193bc3a7513 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Wed, 31 Mar 2021 20:03:38 +0200
Subject: Applying PR suggestions (mostly typos) Co-authored-by: flip1995
 <hello@philkrones.com> Co-authored-by: phansch <dev@phansch.net>

---
 Cargo.toml                                            |  2 +-
 .../src/utils/internal_lints/metadata_collector.rs    | 19 ++++++++++---------
 clippy_utils/src/diagnostics.rs                       |  8 ++++++++
 3 files changed, 19 insertions(+), 10 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/Cargo.toml b/Cargo.toml
index bdee8e40821..23a035f9715 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -52,7 +52,7 @@ rustc_tools_util = { version = "0.2.0", path = "rustc_tools_util" }
 deny-warnings = []
 integration = ["tempfile"]
 internal-lints = ["clippy_lints/internal-lints"]
-metadata-collector-lint = ["clippy_lints/metadata-collector-lint"]
+metadata-collector-lint = ["internal-lints", "clippy_lints/metadata-collector-lint"]
 
 [package.metadata.rust-analyzer]
 # This package uses #[feature(rustc_private)]
diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index b7bb557f957..e85637ca758 100644
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -27,8 +27,9 @@ use std::io::prelude::*;
 use std::path::Path;
 
 use crate::utils::internal_lints::is_lint_ref_type;
-use crate::utils::{
-    last_path_segment, match_function_call, match_path, match_type, paths, span_lint, walk_ptrs_ty_depth,
+use clippy_utils::{
+    diagnostics::span_lint, last_path_segment, match_function_call, match_path, paths, ty::match_type,
+    ty::walk_ptrs_ty_depth,
 };
 
 /// This is the output file of the lint collector.
@@ -107,7 +108,7 @@ pub struct MetadataCollector {
     ///
     /// We use a Heap here to have the lints added in alphabetic order in the export
     lints: BinaryHeap<LintMetadata>,
-    applicability_into: FxHashMap<String, ApplicabilityInfo>,
+    applicability_info: FxHashMap<String, ApplicabilityInfo>,
 }
 
 impl Drop for MetadataCollector {
@@ -120,7 +121,7 @@ impl Drop for MetadataCollector {
             return;
         }
 
-        let mut applicability_info = std::mem::take(&mut self.applicability_into);
+        let mut applicability_info = std::mem::take(&mut self.applicability_info);
 
         // Mapping the final data
         let mut lints = std::mem::take(&mut self.lints).into_sorted_vec();
@@ -272,7 +273,7 @@ impl<'hir> LateLintPass<'hir> for MetadataCollector {
             }
 
             for (lint_name, applicability, is_multi_part) in emission_info.drain(..) {
-                let app_info = self.applicability_into.entry(lint_name).or_default();
+                let app_info = self.applicability_info.entry(lint_name).or_default();
                 app_info.applicability = applicability;
                 app_info.is_multi_part_suggestion = is_multi_part;
             }
@@ -354,7 +355,7 @@ fn lint_collection_error_item(cx: &LateContext<'_>, item: &Item<'_>, message: &s
         cx,
         INTERNAL_METADATA_COLLECTOR,
         item.ident.span,
-        &format!("Metadata collection error for `{}`: {}", item.ident.name, message),
+        &format!("metadata collection error for `{}`: {}", item.ident.name, message),
     );
 }
 
@@ -569,7 +570,7 @@ impl<'a, 'hir> IsMultiSpanScanner<'a, 'hir> {
     }
 
     /// Add a new single expression suggestion to the counter
-    fn add_singe_span_suggestion(&mut self) {
+    fn add_single_span_suggestion(&mut self) {
         self.suggestion_count += 1;
     }
 
@@ -604,7 +605,7 @@ impl<'a, 'hir> intravisit::Visitor<'hir> for IsMultiSpanScanner<'a, 'hir> {
                     .any(|func_path| match_function_call(self.cx, fn_expr, func_path).is_some());
                 if found_function {
                     // These functions are all multi part suggestions
-                    self.add_singe_span_suggestion()
+                    self.add_single_span_suggestion()
                 }
             },
             ExprKind::MethodCall(path, _path_span, arg, _arg_span) => {
@@ -616,7 +617,7 @@ impl<'a, 'hir> intravisit::Visitor<'hir> for IsMultiSpanScanner<'a, 'hir> {
                             if *is_multi_part {
                                 self.add_multi_part_suggestion();
                             } else {
-                                self.add_singe_span_suggestion();
+                                self.add_single_span_suggestion();
                             }
                             break;
                         }
diff --git a/clippy_utils/src/diagnostics.rs b/clippy_utils/src/diagnostics.rs
index 7f827f1759d..a4efae54894 100644
--- a/clippy_utils/src/diagnostics.rs
+++ b/clippy_utils/src/diagnostics.rs
@@ -1,4 +1,12 @@
 //! Clippy wrappers around rustc's diagnostic functions.
+//!
+//! These functions are used by the `INTERNAL_METADATA_COLLECTOR` lint to collect the corresponding
+//! lint applicability. Please make sure that you update the `LINT_EMISSION_FUNCTIONS` variable in
+//! `clippy_lints::utils::internal_lints::metadata_collector` when a new function is added
+//! or renamed.
+//!
+//! Thank you!
+//! ~The `INTERNAL_METADATA_COLLECTOR` lint
 
 use rustc_errors::{Applicability, DiagnosticBuilder};
 use rustc_hir::HirId;
-- 
cgit 1.4.1-3-g733a5


From 2b38399920ad97cc9db61e50549fd4af54d4b38d Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Wed, 5 May 2021 14:44:32 -0500
Subject: Improve eval_order_dependence output

---
 clippy_lints/src/eval_order_dependence.rs | 2 +-
 tests/ui/eval_order_dependence.stderr     | 8 ++++----
 2 files changed, 5 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/eval_order_dependence.rs b/clippy_lints/src/eval_order_dependence.rs
index 762f64fe37a..8815ca27494 100644
--- a/clippy_lints/src/eval_order_dependence.rs
+++ b/clippy_lints/src/eval_order_dependence.rs
@@ -305,7 +305,7 @@ impl<'a, 'tcx> Visitor<'tcx> for ReadVisitor<'a, 'tcx> {
                     self.cx,
                     EVAL_ORDER_DEPENDENCE,
                     expr.span,
-                    "unsequenced read of a variable",
+                    &format!("unsequenced read of `{}`", self.cx.tcx.hir().name(self.var)),
                     Some(self.write_expr.span),
                     "whether read occurs before this write depends on evaluation order",
                 );
diff --git a/tests/ui/eval_order_dependence.stderr b/tests/ui/eval_order_dependence.stderr
index 8f4fa2228f7..cf4adbdfa24 100644
--- a/tests/ui/eval_order_dependence.stderr
+++ b/tests/ui/eval_order_dependence.stderr
@@ -1,4 +1,4 @@
-error: unsequenced read of a variable
+error: unsequenced read of `x`
   --> $DIR/eval_order_dependence.rs:15:9
    |
 LL |     } + x;
@@ -11,7 +11,7 @@ note: whether read occurs before this write depends on evaluation order
 LL |         x = 1;
    |         ^^^^^
 
-error: unsequenced read of a variable
+error: unsequenced read of `x`
   --> $DIR/eval_order_dependence.rs:18:5
    |
 LL |     x += {
@@ -23,7 +23,7 @@ note: whether read occurs before this write depends on evaluation order
 LL |         x = 20;
    |         ^^^^^^
 
-error: unsequenced read of a variable
+error: unsequenced read of `x`
   --> $DIR/eval_order_dependence.rs:31:12
    |
 LL |         a: x,
@@ -35,7 +35,7 @@ note: whether read occurs before this write depends on evaluation order
 LL |             x = 6;
    |             ^^^^^
 
-error: unsequenced read of a variable
+error: unsequenced read of `x`
   --> $DIR/eval_order_dependence.rs:40:9
    |
 LL |         x += {
-- 
cgit 1.4.1-3-g733a5


From 7a7b8bd3e885ec97725579d89ba3ac12a1e6f93f Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Wed, 5 May 2021 15:02:47 -0500
Subject: Fix eval_order_dependence async false positive

---
 clippy_lints/src/eval_order_dependence.rs | 28 ++++++++++++++--------------
 tests/ui/eval_order_dependence.rs         |  6 ++++++
 tests/ui/eval_order_dependence.stderr     | 16 ++++++++--------
 3 files changed, 28 insertions(+), 22 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/eval_order_dependence.rs b/clippy_lints/src/eval_order_dependence.rs
index 8815ca27494..41acf55dd7d 100644
--- a/clippy_lints/src/eval_order_dependence.rs
+++ b/clippy_lints/src/eval_order_dependence.rs
@@ -1,5 +1,6 @@
 use clippy_utils::diagnostics::{span_lint, span_lint_and_note};
 use clippy_utils::{get_parent_expr, path_to_local, path_to_local_id};
+use if_chain::if_chain;
 use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
 use rustc_hir::{BinOpKind, Block, Expr, ExprKind, Guard, HirId, Local, Node, Stmt, StmtKind};
 use rustc_lint::{LateContext, LateLintPass};
@@ -70,20 +71,19 @@ declare_lint_pass!(EvalOrderDependence => [EVAL_ORDER_DEPENDENCE, DIVERGING_SUB_
 impl<'tcx> LateLintPass<'tcx> for EvalOrderDependence {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         // Find a write to a local variable.
-        match expr.kind {
-            ExprKind::Assign(lhs, ..) | ExprKind::AssignOp(_, lhs, _) => {
-                if let Some(var) = path_to_local(lhs) {
-                    let mut visitor = ReadVisitor {
-                        cx,
-                        var,
-                        write_expr: expr,
-                        last_expr: expr,
-                    };
-                    check_for_unsequenced_reads(&mut visitor);
-                }
-            },
-            _ => {},
-        }
+        let var = if_chain! {
+            if let ExprKind::Assign(lhs, ..) | ExprKind::AssignOp(_, lhs, _) = expr.kind;
+            if let Some(var) = path_to_local(lhs);
+            if expr.span.desugaring_kind().is_none();
+            then { var } else { return; }
+        };
+        let mut visitor = ReadVisitor {
+            cx,
+            var,
+            write_expr: expr,
+            last_expr: expr,
+        };
+        check_for_unsequenced_reads(&mut visitor);
     }
     fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) {
         match stmt.kind {
diff --git a/tests/ui/eval_order_dependence.rs b/tests/ui/eval_order_dependence.rs
index d806bc6d401..d742856bc41 100644
--- a/tests/ui/eval_order_dependence.rs
+++ b/tests/ui/eval_order_dependence.rs
@@ -1,3 +1,5 @@
+// edition:2018
+
 #[warn(clippy::eval_order_dependence)]
 #[allow(
     unused_assignments,
@@ -107,3 +109,7 @@ fn main() {
         },
     );
 }
+
+async fn issue_6925() {
+    let _ = vec![async { true }.await, async { false }.await];
+}
diff --git a/tests/ui/eval_order_dependence.stderr b/tests/ui/eval_order_dependence.stderr
index cf4adbdfa24..35eb85e95a3 100644
--- a/tests/ui/eval_order_dependence.stderr
+++ b/tests/ui/eval_order_dependence.stderr
@@ -1,48 +1,48 @@
 error: unsequenced read of `x`
-  --> $DIR/eval_order_dependence.rs:15:9
+  --> $DIR/eval_order_dependence.rs:17:9
    |
 LL |     } + x;
    |         ^
    |
    = note: `-D clippy::eval-order-dependence` implied by `-D warnings`
 note: whether read occurs before this write depends on evaluation order
-  --> $DIR/eval_order_dependence.rs:13:9
+  --> $DIR/eval_order_dependence.rs:15:9
    |
 LL |         x = 1;
    |         ^^^^^
 
 error: unsequenced read of `x`
-  --> $DIR/eval_order_dependence.rs:18:5
+  --> $DIR/eval_order_dependence.rs:20:5
    |
 LL |     x += {
    |     ^
    |
 note: whether read occurs before this write depends on evaluation order
-  --> $DIR/eval_order_dependence.rs:19:9
+  --> $DIR/eval_order_dependence.rs:21:9
    |
 LL |         x = 20;
    |         ^^^^^^
 
 error: unsequenced read of `x`
-  --> $DIR/eval_order_dependence.rs:31:12
+  --> $DIR/eval_order_dependence.rs:33:12
    |
 LL |         a: x,
    |            ^
    |
 note: whether read occurs before this write depends on evaluation order
-  --> $DIR/eval_order_dependence.rs:33:13
+  --> $DIR/eval_order_dependence.rs:35:13
    |
 LL |             x = 6;
    |             ^^^^^
 
 error: unsequenced read of `x`
-  --> $DIR/eval_order_dependence.rs:40:9
+  --> $DIR/eval_order_dependence.rs:42:9
    |
 LL |         x += {
    |         ^
    |
 note: whether read occurs before this write depends on evaluation order
-  --> $DIR/eval_order_dependence.rs:41:13
+  --> $DIR/eval_order_dependence.rs:43:13
    |
 LL |             x = 20;
    |             ^^^^^^
-- 
cgit 1.4.1-3-g733a5


From d66d37303c7074e8e26a0f67bba5a36cd6b12e29 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Wed, 5 May 2021 16:05:16 -0500
Subject: Fix unnecessary_filter_map false positive

---
 clippy_lints/src/methods/unnecessary_filter_map.rs | 40 ++++++++++++----------
 tests/ui/unnecessary_filter_map.rs                 |  4 +++
 2 files changed, 26 insertions(+), 18 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/unnecessary_filter_map.rs b/clippy_lints/src/methods/unnecessary_filter_map.rs
index b61c4ffe9b3..8b66587bfd1 100644
--- a/clippy_lints/src/methods/unnecessary_filter_map.rs
+++ b/clippy_lints/src/methods/unnecessary_filter_map.rs
@@ -6,6 +6,7 @@ use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
 use rustc_hir::LangItem::{OptionNone, OptionSome};
 use rustc_lint::LateContext;
 use rustc_middle::hir::map::Map;
+use rustc_middle::ty::{self, TyS};
 use rustc_span::sym;
 
 use super::UNNECESSARY_FILTER_MAP;
@@ -28,25 +29,28 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, arg: &hir::Expr<
         found_mapping |= return_visitor.found_mapping;
         found_filtering |= return_visitor.found_filtering;
 
-        if !found_filtering {
-            span_lint(
-                cx,
-                UNNECESSARY_FILTER_MAP,
-                expr.span,
-                "this `.filter_map` can be written more simply using `.map`",
-            );
-            return;
-        }
-
-        if !found_mapping && !mutates_arg {
-            span_lint(
-                cx,
-                UNNECESSARY_FILTER_MAP,
-                expr.span,
-                "this `.filter_map` can be written more simply using `.filter`",
-            );
+        let sugg = if !found_filtering {
+            "map"
+        } else if !found_mapping && !mutates_arg {
+            let in_ty = cx.typeck_results().node_type(body.params[0].hir_id);
+            match cx.typeck_results().expr_ty(&body.value).kind() {
+                ty::Adt(adt, subst)
+                    if cx.tcx.is_diagnostic_item(sym::option_type, adt.did)
+                        && TyS::same_type(in_ty, subst.type_at(0)) =>
+                {
+                    "filter"
+                },
+                _ => return,
+            }
+        } else {
             return;
-        }
+        };
+        span_lint(
+            cx,
+            UNNECESSARY_FILTER_MAP,
+            expr.span,
+            &format!("this `.filter_map` can be written more simply using `.{}`", sugg),
+        );
     }
 }
 
diff --git a/tests/ui/unnecessary_filter_map.rs b/tests/ui/unnecessary_filter_map.rs
index af858e4abcf..c58181f518d 100644
--- a/tests/ui/unnecessary_filter_map.rs
+++ b/tests/ui/unnecessary_filter_map.rs
@@ -15,3 +15,7 @@ fn main() {
 
     let _ = (0..4).filter_map(i32::checked_abs);
 }
+
+fn filter_map_none_changes_item_type() -> impl Iterator<Item = bool> {
+    "".chars().filter_map(|_| None)
+}
-- 
cgit 1.4.1-3-g733a5


From b8046fab238029c32285c30dca6adefb2a5dce24 Mon Sep 17 00:00:00 2001
From: Takayuki Nakata <f.seasons017@gmail.com>
Date: Thu, 6 May 2021 14:04:50 +0900
Subject: Add a missing lint to MSRV config doc

---
 clippy_lints/src/utils/conf.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index dc079663fc9..52c1dc3bdd2 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -94,7 +94,7 @@ macro_rules! define_Conf {
 
 // N.B., this macro is parsed by util/lintlib.py
 define_Conf! {
-    /// Lint: CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR. The minimum rust version that the project supports
+    /// Lint: CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR, IF_THEN_SOME_ELSE_NONE. The minimum rust version that the project supports
     (msrv: Option<String> = None),
     /// Lint: BLACKLISTED_NAME. The list of blacklisted names to lint about. NB: `bar` is not here since it has legitimate uses
     (blacklisted_names: Vec<String> = ["foo", "baz", "quux"].iter().map(ToString::to_string).collect()),
-- 
cgit 1.4.1-3-g733a5


From ab3094b3dbf0bf6423a9cf0509a170eee89f106e Mon Sep 17 00:00:00 2001
From: Mateusz Gacek <96mateusz.gacek@gmail.com>
Date: Thu, 6 May 2021 10:49:31 -0700
Subject: wrong_self_convention: For `to_*` variant don't lint in trait impl
 taking `self` when non-`Copy` type

It relaxes rules for `to_*` variant, so it doesn't lint in trait definitions
and implementations anymore.
Although, non-`Copy` type implementing trait's `to_*` method taking
`self` feels not good (consumes ownership, so should be rather named `into_`), it would be better if this case was a pedantic lint (allow-by-default) instead.
---
 clippy_lints/src/methods/wrong_self_convention.rs |  2 +-
 tests/ui/wrong_self_convention2.rs                |  2 +-
 tests/ui/wrong_self_convention2.stderr            | 11 -----------
 3 files changed, 2 insertions(+), 13 deletions(-)
 delete mode 100644 tests/ui/wrong_self_convention2.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/wrong_self_convention.rs b/clippy_lints/src/methods/wrong_self_convention.rs
index 6e2bcb113c2..1773c26c251 100644
--- a/clippy_lints/src/methods/wrong_self_convention.rs
+++ b/clippy_lints/src/methods/wrong_self_convention.rs
@@ -22,7 +22,7 @@ const CONVENTIONS: [(&[Convention], &[SelfKind]); 9] = [
     // Conversion using `to_` can use borrowed (non-Copy types) or owned (Copy types).
     // Source: https://rust-lang.github.io/api-guidelines/naming.html#ad-hoc-conversions-follow-as_-to_-into_-conventions-c-conv
     (&[Convention::StartsWith("to_"), Convention::NotEndsWith("_mut"), Convention::IsSelfTypeCopy(false), 
-    Convention::IsTraitItem(false)], &[SelfKind::Ref]),
+    Convention::IsTraitItem(false), Convention::ImplementsTrait(false)], &[SelfKind::Ref]),
     (&[Convention::StartsWith("to_"), Convention::NotEndsWith("_mut"), Convention::IsSelfTypeCopy(true), 
     Convention::IsTraitItem(false), Convention::ImplementsTrait(false)], &[SelfKind::Value]),
 ];
diff --git a/tests/ui/wrong_self_convention2.rs b/tests/ui/wrong_self_convention2.rs
index ae3a740d405..18202ef2989 100644
--- a/tests/ui/wrong_self_convention2.rs
+++ b/tests/ui/wrong_self_convention2.rs
@@ -23,7 +23,7 @@ mod issue6983 {
     }
 
     struct FooNoCopy;
-    // trigger lint
+    // don't trigger
     impl ToU64 for FooNoCopy {
         fn to_u64(self) -> u64 {
             2
diff --git a/tests/ui/wrong_self_convention2.stderr b/tests/ui/wrong_self_convention2.stderr
deleted file mode 100644
index 0ca1a390974..00000000000
--- a/tests/ui/wrong_self_convention2.stderr
+++ /dev/null
@@ -1,11 +0,0 @@
-error: methods with the following characteristics: (`to_*` and `self` type is not `Copy`) usually take `self` by reference
-  --> $DIR/wrong_self_convention2.rs:28:19
-   |
-LL |         fn to_u64(self) -> u64 {
-   |                   ^^^^
-   |
-   = note: `-D clippy::wrong-self-convention` implied by `-D warnings`
-   = help: consider choosing a less ambiguous name
-
-error: aborting due to previous error
-
-- 
cgit 1.4.1-3-g733a5


From 5f3aae61af8ab129b743d13b14ec5519e97cc445 Mon Sep 17 00:00:00 2001
From: Thomas Otto <th1000s@posteo.net>
Date: Thu, 6 May 2021 23:51:01 +0200
Subject: Handle write!(buf, "\n") case better

Make `write!(buf, "\n")` suggest `writeln!(buf)` by removing
the trailing comma from `writeln!(buf, )`.

changelog: [`write_with_newline`] suggestion on only "\n" improved
---
 clippy_lints/src/write.rs          | 23 ++++++++++++++---------
 tests/ui/write_with_newline.stderr |  4 ++--
 2 files changed, 16 insertions(+), 11 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs
index 7e962472c07..d0e79efa70d 100644
--- a/clippy_lints/src/write.rs
+++ b/clippy_lints/src/write.rs
@@ -279,8 +279,15 @@ impl EarlyLintPass for Write {
             span_lint(cx, PRINT_STDERR, mac.span(), "use of `eprintln!`");
             self.lint_println_empty_string(cx, mac);
         } else if mac.path == sym!(write) {
-            if let (Some(fmt_str), _) = self.check_tts(cx, mac.args.inner_tokens(), true) {
+            if let (Some(fmt_str), dest) = self.check_tts(cx, mac.args.inner_tokens(), true) {
                 if check_newlines(&fmt_str) {
+                    let (nl_span, only_nl) = newline_span(&fmt_str);
+                    let nl_span = match (dest, only_nl) {
+                        // Special case of `write!(buf, "\n")`: Mark everything from the end of
+                        // `buf` for removal so no trailing comma [`writeln!(buf, )`] remains.
+                        (Some(dest_expr), true) => Span::new(dest_expr.span.hi(), nl_span.hi(), nl_span.ctxt()),
+                        _ => nl_span,
+                    };
                     span_lint_and_then(
                         cx,
                         WRITE_WITH_NEWLINE,
@@ -289,10 +296,7 @@ impl EarlyLintPass for Write {
                         |err| {
                             err.multipart_suggestion(
                                 "use `writeln!()` instead",
-                                vec![
-                                    (mac.path.span, String::from("writeln")),
-                                    (newline_span(&fmt_str), String::new()),
-                                ],
+                                vec![(mac.path.span, String::from("writeln")), (nl_span, String::new())],
                                 Applicability::MachineApplicable,
                             );
                         },
@@ -329,12 +333,13 @@ impl EarlyLintPass for Write {
 
 /// Given a format string that ends in a newline and its span, calculates the span of the
 /// newline, or the format string itself if the format string consists solely of a newline.
-fn newline_span(fmtstr: &StrLit) -> Span {
+/// Return this and a boolean indicating whether it only consisted of a newline.
+fn newline_span(fmtstr: &StrLit) -> (Span, bool) {
     let sp = fmtstr.span;
     let contents = &fmtstr.symbol.as_str();
 
     if *contents == r"\n" {
-        return sp;
+        return (sp, true);
     }
 
     let newline_sp_hi = sp.hi()
@@ -351,7 +356,7 @@ fn newline_span(fmtstr: &StrLit) -> Span {
         panic!("expected format string to contain a newline");
     };
 
-    sp.with_lo(newline_sp_hi - newline_sp_len).with_hi(newline_sp_hi)
+    (sp.with_lo(newline_sp_hi - newline_sp_len).with_hi(newline_sp_hi), false)
 }
 
 /// Stores a list of replacement spans for each argument, but only if all the replacements used an
@@ -613,7 +618,7 @@ impl Write {
                     |err| {
                         err.multipart_suggestion(
                             &format!("use `{}!` instead", suggested),
-                            vec![(mac.path.span, suggested), (newline_span(&fmt_str), String::new())],
+                            vec![(mac.path.span, suggested), (newline_span(&fmt_str).0, String::new())],
                             Applicability::MachineApplicable,
                         );
                     },
diff --git a/tests/ui/write_with_newline.stderr b/tests/ui/write_with_newline.stderr
index a14e86122ee..cecc2ea9406 100644
--- a/tests/ui/write_with_newline.stderr
+++ b/tests/ui/write_with_newline.stderr
@@ -51,8 +51,8 @@ LL |     write!(&mut v, "/n");
    |
 help: use `writeln!()` instead
    |
-LL |     writeln!(&mut v, );
-   |     ^^^^^^^         --
+LL |     writeln!(&mut v);
+   |     ^^^^^^^       --
 
 error: using `write!()` with a format string that ends in a single newline
   --> $DIR/write_with_newline.rs:36:5
-- 
cgit 1.4.1-3-g733a5


From a21607d9b504281a00325065955dd825334ad6ef Mon Sep 17 00:00:00 2001
From: Mateusz Gacek <96mateusz.gacek@gmail.com>
Date: Wed, 5 May 2021 12:08:24 -0700
Subject: needless_collect: For `BTreeMap` and `HashMap` lint only `is_empty`

- `len` might produce different results than `count`
- they don't have `contain` but `contains_key` method
---
 clippy_lints/src/loops/needless_collect.rs | 64 ++++++++++++++++++------------
 tests/ui/needless_collect.fixed            | 10 ++++-
 tests/ui/needless_collect.rs               |  8 +++-
 tests/ui/needless_collect.stderr           | 14 +++++--
 4 files changed, 63 insertions(+), 33 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/needless_collect.rs b/clippy_lints/src/loops/needless_collect.rs
index 9662a0b22a3..1ed58faa925 100644
--- a/clippy_lints/src/loops/needless_collect.rs
+++ b/clippy_lints/src/loops/needless_collect.rs
@@ -10,7 +10,6 @@ use rustc_hir::intravisit::{walk_block, walk_expr, NestedVisitorMap, Visitor};
 use rustc_hir::{Block, Expr, ExprKind, GenericArg, GenericArgs, HirId, Local, Pat, PatKind, QPath, StmtKind, Ty};
 use rustc_lint::LateContext;
 use rustc_middle::hir::map::Map;
-
 use rustc_span::symbol::{sym, Ident};
 use rustc_span::{MultiSpan, Span};
 
@@ -28,32 +27,45 @@ fn check_needless_collect_direct_usage<'tcx>(expr: &'tcx Expr<'_>, cx: &LateCont
         if let Some(generic_args) = chain_method.args;
         if let Some(GenericArg::Type(ref ty)) = generic_args.args.get(0);
         if let Some(ty) = cx.typeck_results().node_type_opt(ty.hir_id);
-        if is_type_diagnostic_item(cx, ty, sym::vec_type)
-            || is_type_diagnostic_item(cx, ty, sym::vecdeque_type)
-            || match_type(cx, ty, &paths::BTREEMAP)
-            || is_type_diagnostic_item(cx, ty, sym::hashmap_type);
-        if let Some(sugg) = match &*method.ident.name.as_str() {
-            "len" => Some("count()".to_string()),
-            "is_empty" => Some("next().is_none()".to_string()),
-            "contains" => {
-                let contains_arg = snippet(cx, args[1].span, "??");
-                let (arg, pred) = contains_arg
-                    .strip_prefix('&')
-                    .map_or(("&x", &*contains_arg), |s| ("x", s));
-                Some(format!("any(|{}| x == {})", arg, pred))
-            }
-            _ => None,
-        };
         then {
-            span_lint_and_sugg(
-                cx,
-                NEEDLESS_COLLECT,
-                method0_span.with_hi(expr.span.hi()),
-                NEEDLESS_COLLECT_MSG,
-                "replace with",
-                sugg,
-                Applicability::MachineApplicable,
-            );
+            let is_empty_sugg = Some("next().is_none()".to_string());
+            let method_name = &*method.ident.name.as_str();
+            let sugg = if is_type_diagnostic_item(cx, ty, sym::vec_type) || 
+                        is_type_diagnostic_item(cx, ty, sym::vecdeque_type) {
+                match method_name {
+                    "len" => Some("count()".to_string()),
+                    "is_empty" => is_empty_sugg,
+                    "contains" => {
+                        let contains_arg = snippet(cx, args[1].span, "??");
+                        let (arg, pred) = contains_arg
+                            .strip_prefix('&')
+                            .map_or(("&x", &*contains_arg), |s| ("x", s));
+                        Some(format!("any(|{}| x == {})", arg, pred))
+                    }
+                    _ => None,
+                }
+            }
+            else if match_type(cx, ty, &paths::BTREEMAP) ||
+                is_type_diagnostic_item(cx, ty, sym::hashmap_type) {
+                match method_name {
+                    "is_empty" => is_empty_sugg,
+                    _ => None,
+                }
+            }
+            else {
+                None
+            };
+            if let Some(sugg) = sugg {
+                span_lint_and_sugg(
+                    cx,
+                    NEEDLESS_COLLECT,
+                    method0_span.with_hi(expr.span.hi()),
+                    NEEDLESS_COLLECT_MSG,
+                    "replace with",
+                    sugg,
+                    Applicability::MachineApplicable,
+                );
+            }
         }
     }
 }
diff --git a/tests/ui/needless_collect.fixed b/tests/ui/needless_collect.fixed
index af6c7bf15ea..d7595569681 100644
--- a/tests/ui/needless_collect.fixed
+++ b/tests/ui/needless_collect.fixed
@@ -2,7 +2,7 @@
 
 #![allow(unused, clippy::suspicious_map, clippy::iter_count)]
 
-use std::collections::{BTreeSet, HashMap, HashSet};
+use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
 
 #[warn(clippy::needless_collect)]
 #[allow(unused_variables, clippy::iter_cloned_collect, clippy::iter_next_slice)]
@@ -13,7 +13,13 @@ fn main() {
         // Empty
     }
     sample.iter().cloned().any(|x| x == 1);
-    sample.iter().map(|x| (x, x)).count();
+    // #7164 HashMap's and BTreeMap's `len` usage should not be linted
+    sample.iter().map(|x| (x, x)).collect::<HashMap<_, _>>().len();
+    sample.iter().map(|x| (x, x)).collect::<BTreeMap<_, _>>().len();
+
+    sample.iter().map(|x| (x, x)).next().is_none();
+    sample.iter().map(|x| (x, x)).next().is_none();
+
     // Notice the `HashSet`--this should not be linted
     sample.iter().collect::<HashSet<_>>().len();
     // Neither should this
diff --git a/tests/ui/needless_collect.rs b/tests/ui/needless_collect.rs
index 6ae14f370b1..9883c75b745 100644
--- a/tests/ui/needless_collect.rs
+++ b/tests/ui/needless_collect.rs
@@ -2,7 +2,7 @@
 
 #![allow(unused, clippy::suspicious_map, clippy::iter_count)]
 
-use std::collections::{BTreeSet, HashMap, HashSet};
+use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
 
 #[warn(clippy::needless_collect)]
 #[allow(unused_variables, clippy::iter_cloned_collect, clippy::iter_next_slice)]
@@ -13,7 +13,13 @@ fn main() {
         // Empty
     }
     sample.iter().cloned().collect::<Vec<_>>().contains(&1);
+    // #7164 HashMap's and BTreeMap's `len` usage should not be linted
     sample.iter().map(|x| (x, x)).collect::<HashMap<_, _>>().len();
+    sample.iter().map(|x| (x, x)).collect::<BTreeMap<_, _>>().len();
+
+    sample.iter().map(|x| (x, x)).collect::<HashMap<_, _>>().is_empty();
+    sample.iter().map(|x| (x, x)).collect::<BTreeMap<_, _>>().is_empty();
+
     // Notice the `HashSet`--this should not be linted
     sample.iter().collect::<HashSet<_>>().len();
     // Neither should this
diff --git a/tests/ui/needless_collect.stderr b/tests/ui/needless_collect.stderr
index 2a9539d5975..3acdf66a42e 100644
--- a/tests/ui/needless_collect.stderr
+++ b/tests/ui/needless_collect.stderr
@@ -19,10 +19,16 @@ LL |     sample.iter().cloned().collect::<Vec<_>>().contains(&1);
    |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `any(|x| x == 1)`
 
 error: avoid using `collect()` when not needed
-  --> $DIR/needless_collect.rs:16:35
+  --> $DIR/needless_collect.rs:20:35
    |
-LL |     sample.iter().map(|x| (x, x)).collect::<HashMap<_, _>>().len();
-   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `count()`
+LL |     sample.iter().map(|x| (x, x)).collect::<HashMap<_, _>>().is_empty();
+   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `next().is_none()`
 
-error: aborting due to 4 previous errors
+error: avoid using `collect()` when not needed
+  --> $DIR/needless_collect.rs:21:35
+   |
+LL |     sample.iter().map(|x| (x, x)).collect::<BTreeMap<_, _>>().is_empty();
+   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `next().is_none()`
+
+error: aborting due to 5 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 59ccc1efb368a9a3b036510f7b2d56519608da85 Mon Sep 17 00:00:00 2001
From: Mateusz Gacek <96mateusz.gacek@gmail.com>
Date: Wed, 5 May 2021 12:16:57 -0700
Subject: needless_collect: replace paths with diag items

Related to: #5393
---
 clippy_lints/src/loops/needless_collect.rs | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/needless_collect.rs b/clippy_lints/src/loops/needless_collect.rs
index 1ed58faa925..6a9aa08426c 100644
--- a/clippy_lints/src/loops/needless_collect.rs
+++ b/clippy_lints/src/loops/needless_collect.rs
@@ -2,8 +2,8 @@ use super::NEEDLESS_COLLECT;
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::snippet;
 use clippy_utils::sugg::Sugg;
-use clippy_utils::ty::{is_type_diagnostic_item, match_type};
-use clippy_utils::{is_trait_method, path_to_local_id, paths};
+use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::{is_trait_method, path_to_local_id};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_block, walk_expr, NestedVisitorMap, Visitor};
@@ -30,7 +30,7 @@ fn check_needless_collect_direct_usage<'tcx>(expr: &'tcx Expr<'_>, cx: &LateCont
         then {
             let is_empty_sugg = Some("next().is_none()".to_string());
             let method_name = &*method.ident.name.as_str();
-            let sugg = if is_type_diagnostic_item(cx, ty, sym::vec_type) || 
+            let sugg = if is_type_diagnostic_item(cx, ty, sym::vec_type) ||
                         is_type_diagnostic_item(cx, ty, sym::vecdeque_type) {
                 match method_name {
                     "len" => Some("count()".to_string()),
@@ -45,7 +45,7 @@ fn check_needless_collect_direct_usage<'tcx>(expr: &'tcx Expr<'_>, cx: &LateCont
                     _ => None,
                 }
             }
-            else if match_type(cx, ty, &paths::BTREEMAP) ||
+            else if is_type_diagnostic_item(cx, ty, sym::BTreeMap) ||
                 is_type_diagnostic_item(cx, ty, sym::hashmap_type) {
                 match method_name {
                     "is_empty" => is_empty_sugg,
@@ -98,7 +98,7 @@ fn check_needless_collect_indirect_usage<'tcx>(expr: &'tcx Expr<'_>, cx: &LateCo
                 if is_type_diagnostic_item(cx, ty, sym::vec_type) ||
                     is_type_diagnostic_item(cx, ty, sym::vecdeque_type) ||
                     is_type_diagnostic_item(cx, ty, sym::BinaryHeap) ||
-                    match_type(cx, ty, &paths::LINKED_LIST);
+                    is_type_diagnostic_item(cx, ty, sym::LinkedList);
                 if let Some(iter_calls) = detect_iter_and_into_iters(block, *ident);
                 if let [iter_call] = &*iter_calls;
                 then {
-- 
cgit 1.4.1-3-g733a5


From 171789eb4526fe4ef65514f26056ca4551915cca Mon Sep 17 00:00:00 2001
From: Mateusz Gacek <96mateusz.gacek@gmail.com>
Date: Wed, 5 May 2021 12:17:49 -0700
Subject: needless_collect: Lint `LinkedList` and `BinaryHeap` in direct usage.

Those two types are supported already when used indirectly.
This commit adds support for direct usage as well.
---
 clippy_lints/src/loops/needless_collect.rs |  4 +++-
 tests/ui/needless_collect.fixed            | 11 ++++++++-
 tests/ui/needless_collect.rs               | 11 ++++++++-
 tests/ui/needless_collect.stderr           | 38 +++++++++++++++++++++++++++++-
 4 files changed, 60 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/needless_collect.rs b/clippy_lints/src/loops/needless_collect.rs
index 6a9aa08426c..89c95f3d127 100644
--- a/clippy_lints/src/loops/needless_collect.rs
+++ b/clippy_lints/src/loops/needless_collect.rs
@@ -31,7 +31,9 @@ fn check_needless_collect_direct_usage<'tcx>(expr: &'tcx Expr<'_>, cx: &LateCont
             let is_empty_sugg = Some("next().is_none()".to_string());
             let method_name = &*method.ident.name.as_str();
             let sugg = if is_type_diagnostic_item(cx, ty, sym::vec_type) ||
-                        is_type_diagnostic_item(cx, ty, sym::vecdeque_type) {
+                        is_type_diagnostic_item(cx, ty, sym::vecdeque_type) ||
+                        is_type_diagnostic_item(cx, ty, sym::LinkedList) ||
+                        is_type_diagnostic_item(cx, ty, sym::BinaryHeap) {
                 match method_name {
                     "len" => Some("count()".to_string()),
                     "is_empty" => is_empty_sugg,
diff --git a/tests/ui/needless_collect.fixed b/tests/ui/needless_collect.fixed
index d7595569681..6ecbbcb6249 100644
--- a/tests/ui/needless_collect.fixed
+++ b/tests/ui/needless_collect.fixed
@@ -2,7 +2,7 @@
 
 #![allow(unused, clippy::suspicious_map, clippy::iter_count)]
 
-use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
+use std::collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, LinkedList};
 
 #[warn(clippy::needless_collect)]
 #[allow(unused_variables, clippy::iter_cloned_collect, clippy::iter_next_slice)]
@@ -24,4 +24,13 @@ fn main() {
     sample.iter().collect::<HashSet<_>>().len();
     // Neither should this
     sample.iter().collect::<BTreeSet<_>>().len();
+
+    sample.iter().count();
+    sample.iter().next().is_none();
+    sample.iter().cloned().any(|x| x == 1);
+    sample.iter().any(|x| x == &1);
+
+    // `BinaryHeap` doesn't have `contains` method
+    sample.iter().count();
+    sample.iter().next().is_none();
 }
diff --git a/tests/ui/needless_collect.rs b/tests/ui/needless_collect.rs
index 9883c75b745..8dc69bcf5b3 100644
--- a/tests/ui/needless_collect.rs
+++ b/tests/ui/needless_collect.rs
@@ -2,7 +2,7 @@
 
 #![allow(unused, clippy::suspicious_map, clippy::iter_count)]
 
-use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
+use std::collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, LinkedList};
 
 #[warn(clippy::needless_collect)]
 #[allow(unused_variables, clippy::iter_cloned_collect, clippy::iter_next_slice)]
@@ -24,4 +24,13 @@ fn main() {
     sample.iter().collect::<HashSet<_>>().len();
     // Neither should this
     sample.iter().collect::<BTreeSet<_>>().len();
+
+    sample.iter().collect::<LinkedList<_>>().len();
+    sample.iter().collect::<LinkedList<_>>().is_empty();
+    sample.iter().cloned().collect::<LinkedList<_>>().contains(&1);
+    sample.iter().collect::<LinkedList<_>>().contains(&&1);
+
+    // `BinaryHeap` doesn't have `contains` method
+    sample.iter().collect::<BinaryHeap<_>>().len();
+    sample.iter().collect::<BinaryHeap<_>>().is_empty();
 }
diff --git a/tests/ui/needless_collect.stderr b/tests/ui/needless_collect.stderr
index 3acdf66a42e..039091627a8 100644
--- a/tests/ui/needless_collect.stderr
+++ b/tests/ui/needless_collect.stderr
@@ -30,5 +30,41 @@ error: avoid using `collect()` when not needed
 LL |     sample.iter().map(|x| (x, x)).collect::<BTreeMap<_, _>>().is_empty();
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `next().is_none()`
 
-error: aborting due to 5 previous errors
+error: avoid using `collect()` when not needed
+  --> $DIR/needless_collect.rs:28:19
+   |
+LL |     sample.iter().collect::<LinkedList<_>>().len();
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `count()`
+
+error: avoid using `collect()` when not needed
+  --> $DIR/needless_collect.rs:29:19
+   |
+LL |     sample.iter().collect::<LinkedList<_>>().is_empty();
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `next().is_none()`
+
+error: avoid using `collect()` when not needed
+  --> $DIR/needless_collect.rs:30:28
+   |
+LL |     sample.iter().cloned().collect::<LinkedList<_>>().contains(&1);
+   |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `any(|x| x == 1)`
+
+error: avoid using `collect()` when not needed
+  --> $DIR/needless_collect.rs:31:19
+   |
+LL |     sample.iter().collect::<LinkedList<_>>().contains(&&1);
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `any(|x| x == &1)`
+
+error: avoid using `collect()` when not needed
+  --> $DIR/needless_collect.rs:34:19
+   |
+LL |     sample.iter().collect::<BinaryHeap<_>>().len();
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `count()`
+
+error: avoid using `collect()` when not needed
+  --> $DIR/needless_collect.rs:35:19
+   |
+LL |     sample.iter().collect::<BinaryHeap<_>>().is_empty();
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `next().is_none()`
+
+error: aborting due to 11 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 1b2ca3067e042b3c490d7f9b38258205bc2096f0 Mon Sep 17 00:00:00 2001
From: William Chargin <wchargin@gmail.com>
Date: Fri, 7 May 2021 20:24:07 -0700
Subject: Move `inconsistent_struct_constructor` to pedantic

The whole point of named fields is that we don't have to worry about
order. The names, not the position, communicate the information, so
worrying about consistency for consistency's sake is pedantic to a *T*.

Fixes #7192.

wchargin-branch: inconsistent-struct-constructor-pedantic
wchargin-source: 4fe078a21c77ceb625e58fa3b90b613fc4fa6a76
---
 clippy_lints/src/inconsistent_struct_constructor.rs | 2 +-
 clippy_lints/src/lib.rs                             | 3 +--
 2 files changed, 2 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/inconsistent_struct_constructor.rs b/clippy_lints/src/inconsistent_struct_constructor.rs
index d138c3a8acf..3b635071f28 100644
--- a/clippy_lints/src/inconsistent_struct_constructor.rs
+++ b/clippy_lints/src/inconsistent_struct_constructor.rs
@@ -58,7 +58,7 @@ declare_clippy_lint! {
     /// Foo { x, y };
     /// ```
     pub INCONSISTENT_STRUCT_CONSTRUCTOR,
-    style,
+    pedantic,
     "the order of the field init shorthand is inconsistent with the order in the struct definition"
 }
 
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 79fe4d06d07..783bef73214 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1364,6 +1364,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(if_not_else::IF_NOT_ELSE),
         LintId::of(implicit_hasher::IMPLICIT_HASHER),
         LintId::of(implicit_saturating_sub::IMPLICIT_SATURATING_SUB),
+        LintId::of(inconsistent_struct_constructor::INCONSISTENT_STRUCT_CONSTRUCTOR),
         LintId::of(infinite_iter::MAYBE_INFINITE_ITER),
         LintId::of(invalid_upcast_comparisons::INVALID_UPCAST_COMPARISONS),
         LintId::of(items_after_statements::ITEMS_AFTER_STATEMENTS),
@@ -1510,7 +1511,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(identity_op::IDENTITY_OP),
         LintId::of(if_let_mutex::IF_LET_MUTEX),
         LintId::of(if_let_some_result::IF_LET_SOME_RESULT),
-        LintId::of(inconsistent_struct_constructor::INCONSISTENT_STRUCT_CONSTRUCTOR),
         LintId::of(indexing_slicing::OUT_OF_BOUNDS_INDEXING),
         LintId::of(infinite_iter::INFINITE_ITER),
         LintId::of(inherent_to_string::INHERENT_TO_STRING),
@@ -1763,7 +1763,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(functions::MUST_USE_UNIT),
         LintId::of(functions::RESULT_UNIT_ERR),
         LintId::of(if_let_some_result::IF_LET_SOME_RESULT),
-        LintId::of(inconsistent_struct_constructor::INCONSISTENT_STRUCT_CONSTRUCTOR),
         LintId::of(inherent_to_string::INHERENT_TO_STRING),
         LintId::of(len_zero::COMPARISON_TO_EMPTY),
         LintId::of(len_zero::LEN_WITHOUT_IS_EMPTY),
-- 
cgit 1.4.1-3-g733a5


From d849e9586ecd203e63bfc549098f80fa11725252 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Sat, 8 May 2021 13:29:59 +0200
Subject: Metadata collection monster eating deprecated lints

---
 clippy_lints/src/deprecated_lints.rs               | 11 +++-
 clippy_lints/src/lib.rs                            |  2 +
 .../src/utils/internal_lints/metadata_collector.rs | 70 ++++++++++++++++------
 3 files changed, 62 insertions(+), 21 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/deprecated_lints.rs b/clippy_lints/src/deprecated_lints.rs
index 4688b3d5105..fa8add20688 100644
--- a/clippy_lints/src/deprecated_lints.rs
+++ b/clippy_lints/src/deprecated_lints.rs
@@ -1,6 +1,13 @@
+/// This struct fakes the `Lint` declaration that is usually created by `declare_lint!`. This
+/// enables the simple extraction of the metadata without changing the current depreciation
+/// declaration.
+pub struct ClippyDeprecatedLint;
+
 macro_rules! declare_deprecated_lint {
-    (pub $name: ident, $_reason: expr) => {
-        declare_lint!(pub $name, Allow, "deprecated lint")
+    { $(#[$attr:meta])* pub $name: ident, $_reason: expr} => {
+        $(#[$attr])*
+        #[allow(dead_code)]
+        pub static $name: ClippyDeprecatedLint = ClippyDeprecatedLint {};
     }
 }
 
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 79fe4d06d07..8bdd041576f 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -162,6 +162,8 @@ macro_rules! extract_msrv_attr {
 mod consts;
 #[macro_use]
 mod utils;
+#[cfg(feature = "metadata-collector-lint")]
+mod deprecated_lints;
 
 // begin lints modules, do not remove this comment, it’s used in `update_lints`
 mod absurd_extreme_comparisons;
diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index e85637ca758..af734fa5572 100644
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -28,7 +28,7 @@ use std::path::Path;
 
 use crate::utils::internal_lints::is_lint_ref_type;
 use clippy_utils::{
-    diagnostics::span_lint, last_path_segment, match_function_call, match_path, paths, ty::match_type,
+    diagnostics::span_lint, last_path_segment, match_def_path, match_function_call, match_path, paths, ty::match_type,
     ty::walk_ptrs_ty_depth,
 };
 
@@ -41,6 +41,8 @@ const BLACK_LISTED_LINTS: [&str; 3] = ["lint_author", "deep_code_inspection", "i
 const IGNORED_LINT_GROUPS: [&str; 1] = ["clippy::all"];
 /// Lints within this group will be excluded from the collection
 const EXCLUDED_LINT_GROUPS: [&str; 1] = ["clippy::internal"];
+/// Collected deprecated lint will be assigned to this group in the JSON output
+const DEPRECATED_LINT_GROUP_STR: &str = "DEPRECATED";
 
 const LINT_EMISSION_FUNCTIONS: [&[&str]; 7] = [
     &["clippy_utils", "diagnostics", "span_lint"],
@@ -66,6 +68,7 @@ const SUGGESTION_FUNCTIONS: [&[&str]; 2] = [
     &["clippy_utils", "diagnostics", "multispan_sugg"],
     &["clippy_utils", "diagnostics", "multispan_sugg_with_applicability"],
 ];
+const DEPRECATED_LINT_TYPE: [&str; 3] = ["clippy_lints", "deprecated_lints", "ClippyDeprecatedLint"];
 
 /// The index of the applicability name of `paths::APPLICABILITY_VALUES`
 const APPLICABILITY_NAME_INDEX: usize = 2;
@@ -225,23 +228,42 @@ impl<'hir> LateLintPass<'hir> for MetadataCollector {
     /// }
     /// ```
     fn check_item(&mut self, cx: &LateContext<'hir>, item: &'hir Item<'_>) {
-        if_chain! {
-            // item validation
-            if let ItemKind::Static(ref ty, Mutability::Not, _) = item.kind;
-            if is_lint_ref_type(cx, ty);
-            // blacklist check
-            let lint_name = sym_to_string(item.ident.name).to_ascii_lowercase();
-            if !BLACK_LISTED_LINTS.contains(&lint_name.as_str());
-            // metadata extraction
-            if let Some(group) = get_lint_group_or_lint(cx, &lint_name, item);
-            if let Some(docs) = extract_attr_docs_or_lint(cx, item);
-            then {
-                self.lints.push(LintMetadata::new(
-                    lint_name,
-                    SerializableSpan::from_item(cx, item),
-                    group,
-                    docs,
-                ));
+        if let ItemKind::Static(ref ty, Mutability::Not, _) = item.kind {
+            // Normal lint
+            if_chain! {
+                // item validation
+                if is_lint_ref_type(cx, ty);
+                // blacklist check
+                let lint_name = sym_to_string(item.ident.name).to_ascii_lowercase();
+                if !BLACK_LISTED_LINTS.contains(&lint_name.as_str());
+                // metadata extraction
+                if let Some(group) = get_lint_group_or_lint(cx, &lint_name, item);
+                if let Some(docs) = extract_attr_docs_or_lint(cx, item);
+                then {
+                    self.lints.push(LintMetadata::new(
+                        lint_name,
+                        SerializableSpan::from_item(cx, item),
+                        group,
+                        docs,
+                    ));
+                }
+            }
+
+            if_chain! {
+                if is_deprecated_lint(cx, ty);
+                // blacklist check
+                let lint_name = sym_to_string(item.ident.name).to_ascii_lowercase();
+                if !BLACK_LISTED_LINTS.contains(&lint_name.as_str());
+                // Metadata the little we can get from a deprecated lint
+                if let Some(docs) = extract_attr_docs_or_lint(cx, item);
+                then {
+                    self.lints.push(LintMetadata::new(
+                        lint_name,
+                        SerializableSpan::from_item(cx, item),
+                        DEPRECATED_LINT_GROUP_STR.to_string(),
+                        docs,
+                    ));
+                }
             }
         }
     }
@@ -268,7 +290,7 @@ impl<'hir> LateLintPass<'hir> for MetadataCollector {
                 // - src/misc.rs:734:9
                 // - src/methods/mod.rs:3545:13
                 // - src/methods/mod.rs:3496:13
-                // We are basically unable to resolve the lint name it self.
+                // We are basically unable to resolve the lint name itself.
                 return;
             }
 
@@ -347,6 +369,16 @@ fn get_lint_group(cx: &LateContext<'_>, lint_id: LintId) -> Option<String> {
     None
 }
 
+fn is_deprecated_lint(cx: &LateContext<'_>, ty: &hir::Ty<'_>) -> bool {
+    if let hir::TyKind::Path(ref path) = ty.kind {
+        if let hir::def::Res::Def(DefKind::Struct, def_id) = cx.qpath_res(path, ty.hir_id) {
+            return match_def_path(cx, def_id, &DEPRECATED_LINT_TYPE);
+        }
+    }
+
+    false
+}
+
 // ==================================================================
 // Lint emission
 // ==================================================================
-- 
cgit 1.4.1-3-g733a5


From a988a90e112a68dd48222105f57556f97ea35fbd Mon Sep 17 00:00:00 2001
From: Fridtjof Stoldt <xFrednet@gmail.com>
Date: Mon, 10 May 2021 12:24:24 +0200
Subject: Update clippy_lints/src/deprecated_lints.rs

Co-authored-by: Philipp Krones <hello@philkrones.com>
---
 clippy_lints/src/deprecated_lints.rs                        | 2 +-
 clippy_lints/src/utils/internal_lints/metadata_collector.rs | 3 ---
 2 files changed, 1 insertion(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/deprecated_lints.rs b/clippy_lints/src/deprecated_lints.rs
index fa8add20688..50ffc2e3f19 100644
--- a/clippy_lints/src/deprecated_lints.rs
+++ b/clippy_lints/src/deprecated_lints.rs
@@ -1,5 +1,5 @@
 /// This struct fakes the `Lint` declaration that is usually created by `declare_lint!`. This
-/// enables the simple extraction of the metadata without changing the current depreciation
+/// enables the simple extraction of the metadata without changing the current deprecation
 /// declaration.
 pub struct ClippyDeprecatedLint;
 
diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index af734fa5572..fc4912ba52f 100644
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -8,9 +8,6 @@
 //! during any comparison or mapping. (Please take care of this, it's not fun to spend time on such
 //! a simple mistake)
 
-// # NITs
-// - TODO xFrednet 2021-02-13: Collect depreciations and maybe renames
-
 use if_chain::if_chain;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_hir::{
-- 
cgit 1.4.1-3-g733a5


From 5ba236f3039241077302fddd7acb671e62195af6 Mon Sep 17 00:00:00 2001
From: Arya Kumar <arkumar@umich.edu>
Date: Tue, 11 May 2021 19:34:14 +0000
Subject: added `needless_bitwise_bool` lint

---
 CHANGELOG.md                              |  1 +
 clippy_lints/src/lib.rs                   |  4 ++
 clippy_lints/src/needless_bitwise_bool.rs | 84 +++++++++++++++++++++++++++++++
 tests/ui/needless_bitwise_bool.fixed      | 40 +++++++++++++++
 tests/ui/needless_bitwise_bool.rs         | 40 +++++++++++++++
 tests/ui/needless_bitwise_bool.stderr     | 10 ++++
 6 files changed, 179 insertions(+)
 create mode 100644 clippy_lints/src/needless_bitwise_bool.rs
 create mode 100644 tests/ui/needless_bitwise_bool.fixed
 create mode 100644 tests/ui/needless_bitwise_bool.rs
 create mode 100644 tests/ui/needless_bitwise_bool.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 0a328a20dd4..3645f27427d 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2549,6 +2549,7 @@ Released 2018-09-13
 [`mutex_integer`]: https://rust-lang.github.io/rust-clippy/master/index.html#mutex_integer
 [`naive_bytecount`]: https://rust-lang.github.io/rust-clippy/master/index.html#naive_bytecount
 [`needless_arbitrary_self_type`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_arbitrary_self_type
+[`needless_bitwise_bool`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_bitwise_bool
 [`needless_bool`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_bool
 [`needless_borrow`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow
 [`needless_borrowed_reference`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrowed_reference
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 783bef73214..5b5fc452771 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -288,6 +288,7 @@ mod mut_reference;
 mod mutable_debug_assertion;
 mod mutex_atomic;
 mod needless_arbitrary_self_type;
+mod needless_bitwise_bool;
 mod needless_bool;
 mod needless_borrow;
 mod needless_borrowed_ref;
@@ -833,6 +834,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         mutex_atomic::MUTEX_ATOMIC,
         mutex_atomic::MUTEX_INTEGER,
         needless_arbitrary_self_type::NEEDLESS_ARBITRARY_SELF_TYPE,
+        needless_bitwise_bool::NEEDLESS_BITWISE_BOOL,
         needless_bool::BOOL_COMPARISON,
         needless_bool::NEEDLESS_BOOL,
         needless_borrow::NEEDLESS_BORROW,
@@ -1018,6 +1020,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     let type_complexity_threshold = conf.type_complexity_threshold;
     store.register_late_pass(move || box types::Types::new(vec_box_size_threshold, type_complexity_threshold));
     store.register_late_pass(|| box booleans::NonminimalBool);
+    store.register_late_pass(|| box needless_bitwise_bool::NeedlessBitwiseBool);
     store.register_late_pass(|| box eq_op::EqOp);
     store.register_late_pass(|| box enum_clike::UnportableVariant);
     store.register_late_pass(|| box float_literal::FloatLiteral);
@@ -1392,6 +1395,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(misc::USED_UNDERSCORE_BINDING),
         LintId::of(misc_early::UNSEPARATED_LITERAL_SUFFIX),
         LintId::of(mut_mut::MUT_MUT),
+        LintId::of(needless_bitwise_bool::NEEDLESS_BITWISE_BOOL),
         LintId::of(needless_continue::NEEDLESS_CONTINUE),
         LintId::of(needless_for_each::NEEDLESS_FOR_EACH),
         LintId::of(needless_pass_by_value::NEEDLESS_PASS_BY_VALUE),
diff --git a/clippy_lints/src/needless_bitwise_bool.rs b/clippy_lints/src/needless_bitwise_bool.rs
new file mode 100644
index 00000000000..95febf4a2ad
--- /dev/null
+++ b/clippy_lints/src/needless_bitwise_bool.rs
@@ -0,0 +1,84 @@
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::in_macro;
+use clippy_utils::source::snippet_opt;
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir::{BinOpKind, Expr, ExprKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// **What it does:**
+    /// Checks for uses of bitwise and/or operators between booleans, where performance may be improved by using
+    /// a lazy and.
+    ///
+    /// **Why is this bad?**
+    /// The bitwise operators do not support short-circuiting, so it may hinder code performance.
+    /// Additionally, boolean logic "masked" as bitwise logic is not caught by lints like `unnecessary_fold`
+    ///
+    /// **Known problems:**
+    /// This lint evaluates only when the right side is determined to have no side effects. At this time, that
+    /// determination is quite conservative.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// if x & !y {} // where both x and y are booleans
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// if x && !y {}
+    /// ```
+    pub NEEDLESS_BITWISE_BOOL,
+    pedantic,
+    "Boolean expressions that use bitwise rather than lazy operators"
+}
+
+declare_lint_pass!(NeedlessBitwiseBool => [NEEDLESS_BITWISE_BOOL]);
+
+fn is_bitwise_operation(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+    let ty = cx.typeck_results().expr_ty(expr);
+    if_chain! {
+        if !in_macro(expr.span);
+        if let (&ExprKind::Binary(ref op, _, right), &ty::Bool) = (&expr.kind, &ty.kind());
+        if op.node == BinOpKind::BitAnd || op.node == BinOpKind::BitOr;
+        if let ExprKind::Call(..) | ExprKind::MethodCall(..) | ExprKind::Binary(..) | ExprKind::Unary(..) = right.kind;
+        if !right.can_have_side_effects();
+        then {
+            return true;
+        }
+    }
+    false
+}
+
+fn suggession_snippet(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<String> {
+    if let ExprKind::Binary(ref op, left, right) = expr.kind {
+        if let (Some(l_snippet), Some(r_snippet)) = (snippet_opt(cx, left.span), snippet_opt(cx, right.span)) {
+            let op_snippet = match op.node {
+                BinOpKind::BitAnd => "&&",
+                _ => "||",
+            };
+            return Some(format!("{} {} {}", l_snippet, op_snippet, r_snippet));
+        }
+    }
+    None
+}
+
+impl LateLintPass<'_> for NeedlessBitwiseBool {
+    fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
+        if is_bitwise_operation(cx, expr) {
+            span_lint_and_then(
+                cx,
+                NEEDLESS_BITWISE_BOOL,
+                expr.span,
+                "use of bitwise operator instead of lazy operator between booleans",
+                |diag| {
+                    if let Some(sugg) = suggession_snippet(cx, expr) {
+                        diag.span_suggestion(expr.span, "try", sugg, Applicability::MachineApplicable);
+                    }
+                },
+            );
+        }
+    }
+}
diff --git a/tests/ui/needless_bitwise_bool.fixed b/tests/ui/needless_bitwise_bool.fixed
new file mode 100644
index 00000000000..5e1ea663a10
--- /dev/null
+++ b/tests/ui/needless_bitwise_bool.fixed
@@ -0,0 +1,40 @@
+// run-rustfix
+
+#![warn(clippy::needless_bitwise_bool)]
+
+fn returns_bool() -> bool {
+    true
+}
+
+const fn const_returns_bool() -> bool {
+    false
+}
+
+fn main() {
+    let (x, y) = (false, true);
+    if x & y {
+        println!("true")
+    }
+    if returns_bool() & x {
+        println!("true")
+    }
+    if !returns_bool() & returns_bool() {
+        println!("true")
+    }
+    if y && !x {
+        println!("true")
+    }
+
+    // BELOW: lints we hope to catch as `Expr::can_have_side_effects` improves.
+    if y & !const_returns_bool() {
+        println!("true") // This is a const function, in an UnOp
+    }
+
+    if y & "abcD".is_empty() {
+        println!("true") // This is a const method call
+    }
+
+    if y & (0 < 1) {
+        println!("true") // This is a BinOp with no side effects
+    }
+}
diff --git a/tests/ui/needless_bitwise_bool.rs b/tests/ui/needless_bitwise_bool.rs
new file mode 100644
index 00000000000..f3075fba0a2
--- /dev/null
+++ b/tests/ui/needless_bitwise_bool.rs
@@ -0,0 +1,40 @@
+// run-rustfix
+
+#![warn(clippy::needless_bitwise_bool)]
+
+fn returns_bool() -> bool {
+    true
+}
+
+const fn const_returns_bool() -> bool {
+    false
+}
+
+fn main() {
+    let (x, y) = (false, true);
+    if x & y {
+        println!("true")
+    }
+    if returns_bool() & x {
+        println!("true")
+    }
+    if !returns_bool() & returns_bool() {
+        println!("true")
+    }
+    if y & !x {
+        println!("true")
+    }
+
+    // BELOW: lints we hope to catch as `Expr::can_have_side_effects` improves.
+    if y & !const_returns_bool() {
+        println!("true") // This is a const function, in an UnOp
+    }
+
+    if y & "abcD".is_empty() {
+        println!("true") // This is a const method call
+    }
+
+    if y & (0 < 1) {
+        println!("true") // This is a BinOp with no side effects
+    }
+}
diff --git a/tests/ui/needless_bitwise_bool.stderr b/tests/ui/needless_bitwise_bool.stderr
new file mode 100644
index 00000000000..63c88ef63f5
--- /dev/null
+++ b/tests/ui/needless_bitwise_bool.stderr
@@ -0,0 +1,10 @@
+error: use of bitwise operator instead of lazy operator between booleans
+  --> $DIR/needless_bitwise_bool.rs:24:8
+   |
+LL |     if y & !x {
+   |        ^^^^^^ help: try: `y && !x`
+   |
+   = note: `-D clippy::needless-bitwise-bool` implied by `-D warnings`
+
+error: aborting due to previous error
+
-- 
cgit 1.4.1-3-g733a5


From 210ec728e5d7f428b22b78ee721ed6507cc6f925 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Tue, 11 May 2021 20:23:52 +0200
Subject: Metadata collection monster searching for configurations

---
 clippy_lints/src/lib.rs                            |  2 +-
 clippy_lints/src/utils/conf.rs                     | 24 +++++-
 .../src/utils/internal_lints/metadata_collector.rs | 88 +++++++++++++++++++++-
 3 files changed, 109 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 0c86441cf3f..f0fae6ee1c7 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1009,7 +1009,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     #[cfg(feature = "metadata-collector-lint")]
     {
         if std::env::var("ENABLE_METADATA_COLLECTION").eq(&Ok("1".to_string())) {
-            store.register_late_pass(|| box utils::internal_lints::metadata_collector::MetadataCollector::default());
+            store.register_late_pass(|| box utils::internal_lints::metadata_collector::MetadataCollector::new());
         }
     }
 
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 52c1dc3bdd2..98b86f73a1f 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -26,13 +26,13 @@ impl TryConf {
 
 macro_rules! define_Conf {
     ($(
-        #[$doc:meta]
+        #[doc = $doc:literal]
         $(#[conf_deprecated($dep:literal)])?
         ($name:ident: $ty:ty = $default:expr),
     )*) => {
         /// Clippy lint configuration
         pub struct Conf {
-            $(#[$doc] pub $name: $ty,)*
+            $(#[doc = $doc] pub $name: $ty,)*
         }
 
         mod defaults {
@@ -89,6 +89,24 @@ macro_rules! define_Conf {
                 Ok(TryConf { conf, errors })
             }
         }
+
+        #[cfg(feature = "metadata-collector-lint")]
+        pub mod metadata {
+            use crate::utils::internal_lints::metadata_collector::ClippyConfigurationBasicInfo;
+
+            pub(crate) fn get_configuration_metadata() -> Vec<ClippyConfigurationBasicInfo> {
+                vec![
+                    $(
+                        ClippyConfigurationBasicInfo {
+                            name: stringify!($name),
+                            config_type: stringify!($ty),
+                            default: stringify!($default),
+                            doc_comment: $doc,
+                        },
+                    )+
+                ]
+            }
+        }
     };
 }
 
@@ -100,7 +118,7 @@ define_Conf! {
     (blacklisted_names: Vec<String> = ["foo", "baz", "quux"].iter().map(ToString::to_string).collect()),
     /// Lint: COGNITIVE_COMPLEXITY. The maximum cognitive complexity a function can have
     (cognitive_complexity_threshold: u64 = 25),
-    /// DEPRECATED LINT: CYCLOMATIC_COMPLEXITY. Use the Cognitive Complexity lint instead.
+    /// Lint: CYCLOMATIC_COMPLEXITY. Use the Cognitive Complexity lint instead.
     #[conf_deprecated("Please use `cognitive-complexity-threshold` instead")]
     (cyclomatic_complexity_threshold: Option<u64> = None),
     /// Lint: DOC_MARKDOWN. The list of words this lint should not consider as identifiers needing ticks
diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index fc4912ba52f..308f61beec3 100644
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -102,13 +102,24 @@ declare_clippy_lint! {
 impl_lint_pass!(MetadataCollector => [INTERNAL_METADATA_COLLECTOR]);
 
 #[allow(clippy::module_name_repetitions)]
-#[derive(Debug, Clone, Default)]
+#[derive(Debug, Clone)]
 pub struct MetadataCollector {
     /// All collected lints
     ///
     /// We use a Heap here to have the lints added in alphabetic order in the export
     lints: BinaryHeap<LintMetadata>,
     applicability_info: FxHashMap<String, ApplicabilityInfo>,
+    config: Vec<ClippyConfiguration>,
+}
+
+impl MetadataCollector {
+    pub fn new() -> Self {
+        Self {
+            lints: BinaryHeap::<LintMetadata>::default(),
+            applicability_info: FxHashMap::<String, ApplicabilityInfo>::default(),
+            config: collect_configs(),
+        }
+    }
 }
 
 impl Drop for MetadataCollector {
@@ -214,6 +225,81 @@ impl Serialize for ApplicabilityInfo {
     }
 }
 
+#[derive(Debug)]
+pub(crate) struct ClippyConfigurationBasicInfo {
+    pub name: &'static str,
+    pub config_type: &'static str,
+    pub default: &'static str,
+    pub doc_comment: &'static str,
+}
+
+#[derive(Debug, Clone, Default)]
+struct ClippyConfiguration {
+    name: String,
+    lints: Vec<String>,
+    doc: String,
+    config_type: &'static str,
+    default: String,
+}
+
+// ==================================================================
+// Configuration
+// ==================================================================
+fn collect_configs() -> Vec<ClippyConfiguration> {
+    let cons = crate::utils::conf::metadata::get_configuration_metadata();
+    cons.iter()
+        .map(move |x| {
+            let (lints, doc) = parse_config_field_doc(x.doc_comment)
+                .unwrap_or_else(|| (vec![], "[ERROR] MALFORMED DOC COMMENT".to_string()));
+
+            ClippyConfiguration {
+                name: to_kebab(x.name),
+                lints,
+                doc,
+                config_type: x.config_type,
+                default: x.default.to_string(),
+            }
+        })
+        .collect()
+}
+
+/// This parses the field documentation of the config struct.
+///
+/// ```rust, ignore
+/// parse_config_field_doc(cx, "Lint: LINT_NAME_1, LINT_NAME_2. Papa penguin, papa penguin")
+/// ```
+///
+/// Would yield:
+/// ```rust, ignore
+/// Some(["lint_name_1", "lint_name_2"], "Papa penguin, papa penguin")
+/// ```
+fn parse_config_field_doc(doc_comment: &str) -> Option<(Vec<String>, String)> {
+    const DOC_START: &str = " Lint: ";
+    if_chain! {
+        if doc_comment.starts_with(DOC_START);
+        if let Some(split_pos) = doc_comment.find('.');
+        then {
+            let mut doc_comment = doc_comment.to_string();
+            let documentation = doc_comment.split_off(split_pos);
+
+            doc_comment.make_ascii_lowercase();
+            let lints: Vec<String> = doc_comment.split_off(DOC_START.len()).split(", ").map(str::to_string).collect();
+
+            Some((lints, documentation))
+        } else {
+            None
+        }
+    }
+}
+
+/// Transforms a given `snake_case_string` to a tasty `kebab-case-string`
+fn to_kebab(config_name: &str) -> String {
+    config_name.replace('_', "-")
+}
+
+// ==================================================================
+// Lint pass
+// ==================================================================
 impl<'hir> LateLintPass<'hir> for MetadataCollector {
     /// Collecting lint declarations like:
     /// ```rust, ignore
-- 
cgit 1.4.1-3-g733a5


From 88ae2d1155c48d1c2b0dc4d049f0411778a94035 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Tue, 11 May 2021 21:47:10 +0200
Subject: Metadata formatting the configuration section

---
 .../src/utils/internal_lints/metadata_collector.rs | 58 ++++++++++++++++++++--
 1 file changed, 54 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index 308f61beec3..bb1c8ae9585 100644
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -19,6 +19,7 @@ use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::{sym, Loc, Span, Symbol};
 use serde::{ser::SerializeStruct, Serialize, Serializer};
 use std::collections::BinaryHeap;
+use std::fmt;
 use std::fs::{self, OpenOptions};
 use std::io::prelude::*;
 use std::path::Path;
@@ -41,6 +42,30 @@ const EXCLUDED_LINT_GROUPS: [&str; 1] = ["clippy::internal"];
 /// Collected deprecated lint will be assigned to this group in the JSON output
 const DEPRECATED_LINT_GROUP_STR: &str = "DEPRECATED";
 
+/// This template will be used to format the configuration section in the lint documentation.
+/// The `configurations` parameter will be replaced with one or multiple formatted
+/// `ClippyConfiguration` instances. See `CONFIGURATION_VALUE_TEMPLATE` for further customizations
+macro_rules! CONFIGURATION_SECTION_TEMPLATE {
+    () => {
+        r#"
+**Configuration**
+This lint has the following configuration variables:
+
+{configurations}
+"#
+    };
+}
+/// This template will be used to format an individual `ClippyConfiguration` instance in the
+/// lint documentation.
+///
+/// The format function will provide strings for the following parameters: `name`, `ty`, `doc` and
+/// `default`
+macro_rules! CONFIGURATION_VALUE_TEMPLATE {
+    () => {
+        "* {name}: {ty}: {doc} (defaults to `{default}`)\n"
+    };
+}
+
 const LINT_EMISSION_FUNCTIONS: [&[&str]; 7] = [
     &["clippy_utils", "diagnostics", "span_lint"],
     &["clippy_utils", "diagnostics", "span_lint_and_help"],
@@ -120,6 +145,14 @@ impl MetadataCollector {
             config: collect_configs(),
         }
     }
+
+    fn get_lint_configs(&self, lint_name: &str) -> Option<String> {
+        self.config
+            .iter()
+            .filter_map(|x| x.lints.iter().any(|x| x == lint_name).then(|| format!("{}", x)))
+            .reduce(|acc, x| acc + &x)
+            .map(|configurations| format!(CONFIGURATION_SECTION_TEMPLATE!(), configurations = configurations))
+    }
 }
 
 impl Drop for MetadataCollector {
@@ -225,6 +258,9 @@ impl Serialize for ApplicabilityInfo {
     }
 }
 
+// ==================================================================
+// Configuration
+// ==================================================================
 #[derive(Debug)]
 pub(crate) struct ClippyConfigurationBasicInfo {
     pub name: &'static str,
@@ -242,9 +278,6 @@ struct ClippyConfiguration {
     default: String,
 }
 
-// ==================================================================
-// Configuration
-// ==================================================================
 fn collect_configs() -> Vec<ClippyConfiguration> {
     let cons = crate::utils::conf::metadata::get_configuration_metadata();
     cons.iter()
@@ -297,6 +330,19 @@ fn to_kebab(config_name: &str) -> String {
     config_name.replace('_', "-")
 }
 
+impl fmt::Display for ClippyConfiguration {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            CONFIGURATION_VALUE_TEMPLATE!(),
+            name = self.name,
+            ty = self.config_type,
+            doc = self.doc,
+            default = self.default
+        )
+    }
+}
+
 // ==================================================================
 // Lint pass
 // ==================================================================
@@ -321,8 +367,12 @@ impl<'hir> LateLintPass<'hir> for MetadataCollector {
                 if !BLACK_LISTED_LINTS.contains(&lint_name.as_str());
                 // metadata extraction
                 if let Some(group) = get_lint_group_or_lint(cx, &lint_name, item);
-                if let Some(docs) = extract_attr_docs_or_lint(cx, item);
+                if let Some(mut docs) = extract_attr_docs_or_lint(cx, item);
                 then {
+                    if let Some(configuration_section) = self.get_lint_configs(&lint_name) {
+                        docs.push_str(&configuration_section);
+                    }
+
                     self.lints.push(LintMetadata::new(
                         lint_name,
                         SerializableSpan::from_item(cx, item),
-- 
cgit 1.4.1-3-g733a5


From b03642e51f4c1cfc51858dd792aa689b0e6597d7 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Wed, 12 May 2021 17:30:04 +0200
Subject: Metadata collection clarifying default configuration values

---
 clippy_lints/src/utils/internal_lints/metadata_collector.rs | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index bb1c8ae9585..4a8a46be041 100644
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -290,12 +290,22 @@ fn collect_configs() -> Vec<ClippyConfiguration> {
                 lints,
                 doc,
                 config_type: x.config_type,
-                default: x.default.to_string(),
+                default: clarify_default(x.default),
             }
         })
         .collect()
 }
 
+fn clarify_default(default: &'static str) -> String {
+    if let Some((_start, init))  = default.split_once('[') {
+        if let Some((init, _end)) = init.split_once(']') {
+            return format!("[{}]", init);
+        }
+    }
+    
+    default.to_string()
+}
+
 /// This parses the field documentation of the config struct.
 ///
 /// ```rust, ignore
-- 
cgit 1.4.1-3-g733a5


From b740a04dc49b32185e69a2128bcb8425d82b0c66 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Wed, 12 May 2021 18:47:32 +0200
Subject: Metadata collection collecting configuration deprecation reason

---
 clippy_lints/src/utils/conf.rs                      | 21 +++++++++++++++------
 .../src/utils/internal_lints/metadata_collector.rs  |  7 +++++--
 2 files changed, 20 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 98b86f73a1f..25163bb9f37 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -97,11 +97,20 @@ macro_rules! define_Conf {
             pub(crate) fn get_configuration_metadata() -> Vec<ClippyConfigurationBasicInfo> {
                 vec![
                     $(
-                        ClippyConfigurationBasicInfo {
-                            name: stringify!($name),
-                            config_type: stringify!($ty),
-                            default: stringify!($default),
-                            doc_comment: $doc,
+                        {
+                            #[allow(unused_mut, unused_assignments)]
+                            let mut deprecation_reason = None;
+
+                            // only set if a deprecation reason was set
+                            $(deprecation_reason = Some(stringify!($dep));)?
+
+                            ClippyConfigurationBasicInfo {
+                                name: stringify!($name),
+                                config_type: stringify!($ty),
+                                default: stringify!($default),
+                                doc_comment: $doc,
+                                deprecation_reason,
+                            }
                         },
                     )+
                 ]
@@ -118,7 +127,7 @@ define_Conf! {
     (blacklisted_names: Vec<String> = ["foo", "baz", "quux"].iter().map(ToString::to_string).collect()),
     /// Lint: COGNITIVE_COMPLEXITY. The maximum cognitive complexity a function can have
     (cognitive_complexity_threshold: u64 = 25),
-    /// Lint: CYCLOMATIC_COMPLEXITY. Use the Cognitive Complexity lint instead.
+    /// DEPRECATED LINT: CYCLOMATIC_COMPLEXITY. Use the Cognitive Complexity lint instead.
     #[conf_deprecated("Please use `cognitive-complexity-threshold` instead")]
     (cyclomatic_complexity_threshold: Option<u64> = None),
     /// Lint: DOC_MARKDOWN. The list of words this lint should not consider as identifiers needing ticks
diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index 4a8a46be041..bd0de8ad034 100644
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -267,6 +267,7 @@ pub(crate) struct ClippyConfigurationBasicInfo {
     pub config_type: &'static str,
     pub default: &'static str,
     pub doc_comment: &'static str,
+    pub deprecation_reason: Option<&'static str>,
 }
 
 #[derive(Debug, Clone, Default)]
@@ -276,6 +277,7 @@ struct ClippyConfiguration {
     doc: String,
     config_type: &'static str,
     default: String,
+    deprecation_reason: Option<&'static str>,
 }
 
 fn collect_configs() -> Vec<ClippyConfiguration> {
@@ -291,18 +293,19 @@ fn collect_configs() -> Vec<ClippyConfiguration> {
                 doc,
                 config_type: x.config_type,
                 default: clarify_default(x.default),
+                deprecation_reason: x.deprecation_reason,
             }
         })
         .collect()
 }
 
 fn clarify_default(default: &'static str) -> String {
-    if let Some((_start, init))  = default.split_once('[') {
+    if let Some((_start, init)) = default.split_once('[') {
         if let Some((init, _end)) = init.split_once(']') {
             return format!("[{}]", init);
         }
     }
-    
+
     default.to_string()
 }
 
-- 
cgit 1.4.1-3-g733a5


From 8214bf04450db9e57975993290d3c35a66a40707 Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Fri, 16 Apr 2021 16:07:20 +0900
Subject: match_single_binding: Fix invalid suggestion when match scrutinee has
 side effects

---
 clippy_lints/src/matches.rs           | 37 ++++++++++++++++++++++++++---------
 tests/ui/match_single_binding.fixed   |  5 +----
 tests/ui/match_single_binding.rs      | 10 +---------
 tests/ui/match_single_binding.stderr  | 13 +-----------
 tests/ui/match_single_binding2.fixed  | 16 +++++++++++++++
 tests/ui/match_single_binding2.rs     | 18 +++++++++++++++++
 tests/ui/match_single_binding2.stderr | 36 +++++++++++++++++++++++++++++++++-
 7 files changed, 100 insertions(+), 35 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index 44b4eb29035..345b360e633 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -1479,15 +1479,34 @@ fn check_match_single_binding<'a>(cx: &LateContext<'a>, ex: &Expr<'a>, arms: &[A
             );
         },
         PatKind::Wild => {
-            span_lint_and_sugg(
-                cx,
-                MATCH_SINGLE_BINDING,
-                expr.span,
-                "this match could be replaced by its body itself",
-                "consider using the match body instead",
-                snippet_body,
-                Applicability::MachineApplicable,
-            );
+            if ex.can_have_side_effects() {
+                let indent = " ".repeat(indent_of(cx, expr.span).unwrap_or(0));
+                let sugg = format!(
+                    "{};\n{}{}",
+                    snippet_with_applicability(cx, ex.span, "..", &mut applicability),
+                    indent,
+                    snippet_body
+                );
+                span_lint_and_sugg(
+                    cx,
+                    MATCH_SINGLE_BINDING,
+                    expr.span,
+                    "this match could be replaced by its scrutinee and body",
+                    "consider using the scrutinee and body instead",
+                    sugg,
+                    applicability,
+                )
+            } else {
+                span_lint_and_sugg(
+                    cx,
+                    MATCH_SINGLE_BINDING,
+                    expr.span,
+                    "this match could be replaced by its body itself",
+                    "consider using the match body instead",
+                    snippet_body,
+                    Applicability::MachineApplicable,
+                );
+            }
         },
         _ => (),
     }
diff --git a/tests/ui/match_single_binding.fixed b/tests/ui/match_single_binding.fixed
index 526e94b10bd..30bf6402253 100644
--- a/tests/ui/match_single_binding.fixed
+++ b/tests/ui/match_single_binding.fixed
@@ -94,10 +94,7 @@ fn main() {
         0 => println!("Disabled branch"),
         _ => println!("Enabled branch"),
     }
-    // Lint
-    let x = 1;
-    let y = 1;
-    println!("Single branch");
+
     // Ok
     let x = 1;
     let y = 1;
diff --git a/tests/ui/match_single_binding.rs b/tests/ui/match_single_binding.rs
index 6a2ca7c5e93..d8bb80d8b96 100644
--- a/tests/ui/match_single_binding.rs
+++ b/tests/ui/match_single_binding.rs
@@ -106,15 +106,7 @@ fn main() {
         0 => println!("Disabled branch"),
         _ => println!("Enabled branch"),
     }
-    // Lint
-    let x = 1;
-    let y = 1;
-    match match y {
-        0 => 1,
-        _ => 2,
-    } {
-        _ => println!("Single branch"),
-    }
+
     // Ok
     let x = 1;
     let y = 1;
diff --git a/tests/ui/match_single_binding.stderr b/tests/ui/match_single_binding.stderr
index cbbf5d29c02..795c8c3e24d 100644
--- a/tests/ui/match_single_binding.stderr
+++ b/tests/ui/match_single_binding.stderr
@@ -167,16 +167,5 @@ LL |             unwrapped
 LL |         })
    |
 
-error: this match could be replaced by its body itself
-  --> $DIR/match_single_binding.rs:112:5
-   |
-LL | /     match match y {
-LL | |         0 => 1,
-LL | |         _ => 2,
-LL | |     } {
-LL | |         _ => println!("Single branch"),
-LL | |     }
-   | |_____^ help: consider using the match body instead: `println!("Single branch");`
-
-error: aborting due to 12 previous errors
+error: aborting due to 11 previous errors
 
diff --git a/tests/ui/match_single_binding2.fixed b/tests/ui/match_single_binding2.fixed
index e73a85b73d7..a91fcc2125d 100644
--- a/tests/ui/match_single_binding2.fixed
+++ b/tests/ui/match_single_binding2.fixed
@@ -34,4 +34,20 @@ fn main() {
         },
         None => println!("nothing"),
     }
+
+    fn side_effects() {}
+
+    // Lint (scrutinee has side effects)
+    // issue #7094
+    side_effects();
+    println!("Side effects");
+
+    // Lint (scrutinee has side effects)
+    // issue #7094
+    let x = 1;
+    match x {
+        0 => 1,
+        _ => 2,
+    };
+    println!("Single branch");
 }
diff --git a/tests/ui/match_single_binding2.rs b/tests/ui/match_single_binding2.rs
index 7362cb390e5..476386ebabe 100644
--- a/tests/ui/match_single_binding2.rs
+++ b/tests/ui/match_single_binding2.rs
@@ -34,4 +34,22 @@ fn main() {
         },
         None => println!("nothing"),
     }
+
+    fn side_effects() {}
+
+    // Lint (scrutinee has side effects)
+    // issue #7094
+    match side_effects() {
+        _ => println!("Side effects"),
+    }
+
+    // Lint (scrutinee has side effects)
+    // issue #7094
+    let x = 1;
+    match match x {
+        0 => 1,
+        _ => 2,
+    } {
+        _ => println!("Single branch"),
+    }
 }
diff --git a/tests/ui/match_single_binding2.stderr b/tests/ui/match_single_binding2.stderr
index bc18d191aa3..4372f55af87 100644
--- a/tests/ui/match_single_binding2.stderr
+++ b/tests/ui/match_single_binding2.stderr
@@ -30,5 +30,39 @@ LL |             let (a, b) = get_tup();
 LL |             println!("a {:?} and b {:?}", a, b);
    |
 
-error: aborting due to 2 previous errors
+error: this match could be replaced by its scrutinee and body
+  --> $DIR/match_single_binding2.rs:42:5
+   |
+LL | /     match side_effects() {
+LL | |         _ => println!("Side effects"),
+LL | |     }
+   | |_____^
+   |
+help: consider using the scrutinee and body instead
+   |
+LL |     side_effects();
+LL |     println!("Side effects");
+   |
+
+error: this match could be replaced by its scrutinee and body
+  --> $DIR/match_single_binding2.rs:49:5
+   |
+LL | /     match match x {
+LL | |         0 => 1,
+LL | |         _ => 2,
+LL | |     } {
+LL | |         _ => println!("Single branch"),
+LL | |     }
+   | |_____^
+   |
+help: consider using the scrutinee and body instead
+   |
+LL |     match x {
+LL |         0 => 1,
+LL |         _ => 2,
+LL |     };
+LL |     println!("Single branch");
+   |
+
+error: aborting due to 4 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From daca50a515f28218142d9945ca714f7420b4fc75 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Wed, 24 Mar 2021 09:32:29 -0400
Subject: Improvements to `while_let_on_iterator`

* Suggest `&mut iter` when the iterator is used after the loop.
* Suggest `&mut iter` when the iterator is a field in a struct.
* Don't lint when the iterator is a field in a struct, and the struct is
used in the loop.
* Lint when the loop is nested in another loop, but suggest `&mut iter`
unless the iterator is from a local declared inside the loop.
---
 clippy_lints/src/doc.rs                         |   2 +-
 clippy_lints/src/loops/while_let_on_iterator.rs | 445 +++++++++++++++++-------
 clippy_utils/src/lib.rs                         |  18 +
 clippy_utils/src/sugg.rs                        |   2 +-
 clippy_utils/src/visitors.rs                    |  36 +-
 tests/ui/while_let_on_iterator.fixed            | 164 +++++++--
 tests/ui/while_let_on_iterator.rs               | 164 +++++++--
 tests/ui/while_let_on_iterator.stderr           |  72 +++-
 8 files changed, 706 insertions(+), 197 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/doc.rs b/clippy_lints/src/doc.rs
index fb53b55ebd6..e67ec4e06c5 100644
--- a/clippy_lints/src/doc.rs
+++ b/clippy_lints/src/doc.rs
@@ -383,7 +383,7 @@ pub fn strip_doc_comment_decoration(doc: &str, comment_kind: CommentKind, span:
     let mut no_stars = String::with_capacity(doc.len());
     for line in doc.lines() {
         let mut chars = line.chars();
-        while let Some(c) = chars.next() {
+        for c in &mut chars {
             if c.is_whitespace() {
                 no_stars.push(c);
             } else {
diff --git a/clippy_lints/src/loops/while_let_on_iterator.rs b/clippy_lints/src/loops/while_let_on_iterator.rs
index 82715d9bafa..75e92f08df1 100644
--- a/clippy_lints/src/loops/while_let_on_iterator.rs
+++ b/clippy_lints/src/loops/while_let_on_iterator.rs
@@ -1,170 +1,353 @@
-use super::utils::{LoopNestVisitor, Nesting};
 use super::WHILE_LET_ON_ITERATOR;
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::ty::implements_trait;
-use clippy_utils::usage::mutated_variables;
-use clippy_utils::{
-    get_enclosing_block, is_refutable, is_trait_method, last_path_segment, path_to_local, path_to_local_id,
-};
-use if_chain::if_chain;
+use clippy_utils::{get_enclosing_loop, is_refutable, is_trait_method, match_def_path, paths, visitors::is_res_used};
 use rustc_errors::Applicability;
-use rustc_hir::intravisit::{walk_block, walk_expr, NestedVisitorMap, Visitor};
-use rustc_hir::{Expr, ExprKind, HirId, MatchSource, Node, PatKind};
+use rustc_hir::intravisit::{walk_expr, ErasedMap, NestedVisitorMap, Visitor};
+use rustc_hir::{def::Res, Expr, ExprKind, HirId, Local, MatchSource, Node, PatKind, QPath, UnOp};
 use rustc_lint::LateContext;
-use rustc_middle::hir::map::Map;
-use rustc_span::symbol::sym;
+use rustc_span::{symbol::sym, Span, Symbol};
 
 pub(super) fn check(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-    if let ExprKind::Match(match_expr, arms, MatchSource::WhileLetDesugar) = expr.kind {
-        let pat = &arms[0].pat.kind;
-        if let (&PatKind::TupleStruct(ref qpath, pat_args, _), &ExprKind::MethodCall(method_path, _, method_args, _)) =
-            (pat, &match_expr.kind)
-        {
-            let iter_expr = &method_args[0];
-
-            // Don't lint when the iterator is recreated on every iteration
-            if_chain! {
-                if let ExprKind::MethodCall(..) | ExprKind::Call(..) = iter_expr.kind;
-                if let Some(iter_def_id) = cx.tcx.get_diagnostic_item(sym::Iterator);
-                if implements_trait(cx, cx.typeck_results().expr_ty(iter_expr), iter_def_id, &[]);
-                then {
-                    return;
-                }
-            }
+    if let ExprKind::Match(scrutinee_expr, [arm, _], MatchSource::WhileLetDesugar) = expr.kind {
+        let some_pat = match arm.pat.kind {
+            PatKind::TupleStruct(QPath::Resolved(None, path), sub_pats, _) => match path.res {
+                Res::Def(_, id) if match_def_path(cx, id, &paths::OPTION_SOME) => sub_pats.first(),
+                _ => return,
+            },
+            _ => return,
+        };
 
-            let lhs_constructor = last_path_segment(qpath);
-            if method_path.ident.name == sym::next
-                && is_trait_method(cx, match_expr, sym::Iterator)
-                && lhs_constructor.ident.name == sym::Some
-                && (pat_args.is_empty()
-                    || !is_refutable(cx, pat_args[0])
-                        && !is_used_inside(cx, iter_expr, arms[0].body)
-                        && !is_iterator_used_after_while_let(cx, iter_expr)
-                        && !is_nested(cx, expr, &method_args[0]))
+        let iter_expr = match scrutinee_expr.kind {
+            ExprKind::MethodCall(name, _, [iter_expr], _)
+                if name.ident.name == sym::next && is_trait_method(cx, scrutinee_expr, sym::Iterator) =>
             {
-                let mut applicability = Applicability::MachineApplicable;
-                let iterator = snippet_with_applicability(cx, method_args[0].span, "_", &mut applicability);
-                let loop_var = if pat_args.is_empty() {
-                    "_".to_string()
+                if let Some(iter_expr) = try_parse_iter_expr(cx, iter_expr) {
+                    iter_expr
                 } else {
-                    snippet_with_applicability(cx, pat_args[0].span, "_", &mut applicability).into_owned()
-                };
-                span_lint_and_sugg(
-                    cx,
-                    WHILE_LET_ON_ITERATOR,
-                    expr.span.with_hi(match_expr.span.hi()),
-                    "this loop could be written as a `for` loop",
-                    "try",
-                    format!("for {} in {}", loop_var, iterator),
-                    applicability,
-                );
+                    return;
+                }
             }
+            _ => return,
+        };
+
+        // Needed to find an outer loop, if there are any.
+        let loop_expr = if let Some((_, Node::Expr(e))) = cx.tcx.hir().parent_iter(expr.hir_id).nth(1) {
+            e
+        } else {
+            return;
+        };
+
+        // Refutable patterns don't work with for loops.
+        // The iterator also can't be accessed withing the loop.
+        if some_pat.map_or(true, |p| is_refutable(cx, p)) || uses_iter(cx, &iter_expr, arm.body) {
+            return;
         }
+
+        // If the iterator is a field or the iterator is accessed after the loop is complete it needs to be
+        // borrowed mutably.
+        // TODO: If the struct can be partially moved from and the struct isn't used afterwards a mutable
+        // borrow of a field isn't necessary.
+        let ref_mut = if !iter_expr.fields.is_empty() || needs_mutable_borrow(cx, &iter_expr, loop_expr) {
+            "&mut "
+        } else {
+            ""
+        };
+        let mut applicability = Applicability::MachineApplicable;
+        let iterator = snippet_with_applicability(cx, iter_expr.span, "_", &mut applicability);
+        let loop_var = some_pat.map_or_else(
+            || "_".into(),
+            |pat| snippet_with_applicability(cx, pat.span, "_", &mut applicability).into_owned(),
+        );
+        span_lint_and_sugg(
+            cx,
+            WHILE_LET_ON_ITERATOR,
+            expr.span.with_hi(scrutinee_expr.span.hi()),
+            "this loop could be written as a `for` loop",
+            "try",
+            format!("for {} in {}{}", loop_var, ref_mut, iterator),
+            applicability,
+        );
     }
 }
 
-fn is_used_inside<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, container: &'tcx Expr<'_>) -> bool {
-    let def_id = match path_to_local(expr) {
-        Some(id) => id,
-        None => return false,
-    };
-    if let Some(used_mutably) = mutated_variables(container, cx) {
-        if used_mutably.contains(&def_id) {
-            return true;
+#[derive(Debug)]
+struct IterExpr {
+    /// The span of the whole expression, not just the path and fields stored here.
+    span: Span,
+    /// The fields used, in order of child to parent.
+    fields: Vec<Symbol>,
+    /// The path being used.
+    path: Res,
+}
+/// Parses any expression to find out which field of which variable is used. Will return `None` if
+/// the expression might have side effects.
+fn try_parse_iter_expr(cx: &LateContext<'_>, mut e: &Expr<'_>) -> Option<IterExpr> {
+    let span = e.span;
+    let mut fields = Vec::new();
+    loop {
+        match e.kind {
+            ExprKind::Path(ref path) => {
+                break Some(IterExpr {
+                    span,
+                    fields,
+                    path: cx.qpath_res(path, e.hir_id),
+                });
+            },
+            ExprKind::Field(base, name) => {
+                fields.push(name.name);
+                e = base;
+            },
+            // Dereferencing a pointer has no side effects and doesn't affect which field is being used.
+            ExprKind::Unary(UnOp::Deref, base) if cx.typeck_results().expr_ty(base).is_ref() => e = base,
+
+            // Shouldn't have side effects, but there's no way to trace which field is used. So forget which fields have
+            // already been seen.
+            ExprKind::Index(base, idx) if !idx.can_have_side_effects() => {
+                fields.clear();
+                e = base;
+            },
+            ExprKind::Unary(UnOp::Deref, base) => {
+                fields.clear();
+                e = base;
+            },
+
+            // No effect and doesn't affect which field is being used.
+            ExprKind::DropTemps(base) | ExprKind::AddrOf(_, _, base) | ExprKind::Type(base, _) => e = base,
+            _ => break None,
         }
     }
-    false
 }
 
-fn is_iterator_used_after_while_let<'tcx>(cx: &LateContext<'tcx>, iter_expr: &'tcx Expr<'_>) -> bool {
-    let def_id = match path_to_local(iter_expr) {
-        Some(id) => id,
-        None => return false,
-    };
-    let mut visitor = VarUsedAfterLoopVisitor {
-        def_id,
-        iter_expr_id: iter_expr.hir_id,
-        past_while_let: false,
-        var_used_after_while_let: false,
-    };
-    if let Some(enclosing_block) = get_enclosing_block(cx, def_id) {
-        walk_block(&mut visitor, enclosing_block);
+fn is_expr_same_field(cx: &LateContext<'_>, mut e: &Expr<'_>, mut fields: &[Symbol], path_res: Res) -> bool {
+    loop {
+        match (&e.kind, fields) {
+            (&ExprKind::Field(base, name), [head_field, tail_fields @ ..]) if name.name == *head_field => {
+                e = base;
+                fields = tail_fields;
+            },
+            (ExprKind::Path(path), []) => {
+                break cx.qpath_res(path, e.hir_id) == path_res;
+            },
+            (&(ExprKind::DropTemps(base) | ExprKind::AddrOf(_, _, base) | ExprKind::Type(base, _)), _) => e = base,
+            _ => break false,
+        }
     }
-    visitor.var_used_after_while_let
 }
 
-fn is_nested(cx: &LateContext<'_>, match_expr: &Expr<'_>, iter_expr: &Expr<'_>) -> bool {
-    if_chain! {
-        if let Some(loop_block) = get_enclosing_block(cx, match_expr.hir_id);
-        let parent_node = cx.tcx.hir().get_parent_node(loop_block.hir_id);
-        if let Some(Node::Expr(loop_expr)) = cx.tcx.hir().find(parent_node);
-        then {
-            return is_loop_nested(cx, loop_expr, iter_expr)
-        }
+/// Checks if the given expression is the same field as, is a child of, of the parent of the given
+/// field. Used to check if the expression can be used while the given field is borrowed.
+fn is_expr_same_child_or_parent_field(cx: &LateContext<'_>, expr: &Expr<'_>, fields: &[Symbol], path_res: Res) -> bool {
+    match expr.kind {
+        ExprKind::Field(base, name) => {
+            if let Some((head_field, tail_fields)) = fields.split_first() {
+                if name.name == *head_field && is_expr_same_field(cx, base, fields, path_res) {
+                    return true;
+                }
+                // Check if the expression is a parent field
+                let mut fields_iter = tail_fields.iter();
+                while let Some(field) = fields_iter.next() {
+                    if *field == name.name && is_expr_same_field(cx, base, fields_iter.as_slice(), path_res) {
+                        return true;
+                    }
+                }
+            }
+
+            // Check if the expression is a child field.
+            let mut e = base;
+            loop {
+                match e.kind {
+                    ExprKind::Field(..) if is_expr_same_field(cx, e, fields, path_res) => break true,
+                    ExprKind::Field(base, _) | ExprKind::DropTemps(base) | ExprKind::Type(base, _) => e = base,
+                    ExprKind::Path(ref path) if fields.is_empty() => {
+                        break cx.qpath_res(path, e.hir_id) == path_res;
+                    },
+                    _ => break false,
+                }
+            }
+        },
+        // If the path matches, this is either an exact match, of the expression is a parent of the field.
+        ExprKind::Path(ref path) => cx.qpath_res(path, expr.hir_id) == path_res,
+        ExprKind::DropTemps(base) | ExprKind::Type(base, _) | ExprKind::AddrOf(_, _, base) => {
+            is_expr_same_child_or_parent_field(cx, base, fields, path_res)
+        },
+        _ => false,
     }
-    false
 }
 
-fn is_loop_nested(cx: &LateContext<'_>, loop_expr: &Expr<'_>, iter_expr: &Expr<'_>) -> bool {
-    let mut id = loop_expr.hir_id;
-    let iter_id = if let Some(id) = path_to_local(iter_expr) {
-        id
-    } else {
-        return true;
+/// Strips off all field and path expressions. Used to skip them after failing to check for
+/// equality.
+fn skip_fields_and_path(expr: &'tcx Expr<'_>) -> (Option<&'tcx Expr<'tcx>>, bool) {
+    let mut e = expr;
+    let e = loop {
+        match e.kind {
+            ExprKind::Field(base, _) | ExprKind::DropTemps(base) | ExprKind::Type(base, _) => e = base,
+            ExprKind::Path(_) => return (None, true),
+            _ => break e,
+        }
     };
-    loop {
-        let parent = cx.tcx.hir().get_parent_node(id);
-        if parent == id {
-            return false;
+    (Some(e), e.hir_id != expr.hir_id)
+}
+
+/// Checks if the given expression uses the iterator.
+fn uses_iter(cx: &LateContext<'tcx>, iter_expr: &IterExpr, container: &'tcx Expr<'_>) -> bool {
+    struct V<'a, 'b, 'tcx> {
+        cx: &'a LateContext<'tcx>,
+        iter_expr: &'b IterExpr,
+        uses_iter: bool,
+    }
+    impl Visitor<'tcx> for V<'_, '_, 'tcx> {
+        type Map = ErasedMap<'tcx>;
+        fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+            NestedVisitorMap::None
         }
-        match cx.tcx.hir().find(parent) {
-            Some(Node::Expr(expr)) => {
-                if let ExprKind::Loop(..) = expr.kind {
-                    return true;
-                };
-            },
-            Some(Node::Block(block)) => {
-                let mut block_visitor = LoopNestVisitor {
-                    hir_id: id,
-                    iterator: iter_id,
-                    nesting: Nesting::Unknown,
-                };
-                walk_block(&mut block_visitor, block);
-                if block_visitor.nesting == Nesting::RuledOut {
-                    return false;
+
+        fn visit_expr(&mut self, e: &'tcx Expr<'_>) {
+            if self.uses_iter {
+                // return
+            } else if is_expr_same_child_or_parent_field(self.cx, e, &self.iter_expr.fields, self.iter_expr.path) {
+                self.uses_iter = true;
+            } else if let (e, true) = skip_fields_and_path(e) {
+                if let Some(e) = e {
+                    self.visit_expr(e);
                 }
-            },
-            Some(Node::Stmt(_)) => (),
-            _ => {
-                return false;
-            },
+            } else if let ExprKind::Closure(_, _, id, _, _) = e.kind {
+                if is_res_used(self.cx, self.iter_expr.path, id) {
+                    self.uses_iter = true;
+                }
+            } else {
+                walk_expr(self, e);
+            }
         }
-        id = parent;
     }
-}
 
-struct VarUsedAfterLoopVisitor {
-    def_id: HirId,
-    iter_expr_id: HirId,
-    past_while_let: bool,
-    var_used_after_while_let: bool,
+    let mut v = V {
+        cx,
+        iter_expr,
+        uses_iter: false,
+    };
+    v.visit_expr(container);
+    v.uses_iter
 }
 
-impl<'tcx> Visitor<'tcx> for VarUsedAfterLoopVisitor {
-    type Map = Map<'tcx>;
+#[allow(clippy::too_many_lines)]
+fn needs_mutable_borrow(cx: &LateContext<'tcx>, iter_expr: &IterExpr, loop_expr: &'tcx Expr<'_>) -> bool {
+    struct AfterLoopVisitor<'a, 'b, 'tcx> {
+        cx: &'a LateContext<'tcx>,
+        iter_expr: &'b IterExpr,
+        loop_id: HirId,
+        after_loop: bool,
+        used_iter: bool,
+    }
+    impl Visitor<'tcx> for AfterLoopVisitor<'_, '_, 'tcx> {
+        type Map = ErasedMap<'tcx>;
+        fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+            NestedVisitorMap::None
+        }
+
+        fn visit_expr(&mut self, e: &'tcx Expr<'_>) {
+            if self.used_iter {
+                return;
+            }
+            if self.after_loop {
+                if is_expr_same_child_or_parent_field(self.cx, e, &self.iter_expr.fields, self.iter_expr.path) {
+                    self.used_iter = true;
+                } else if let (e, true) = skip_fields_and_path(e) {
+                    if let Some(e) = e {
+                        self.visit_expr(e);
+                    }
+                } else if let ExprKind::Closure(_, _, id, _, _) = e.kind {
+                    self.used_iter |= is_res_used(self.cx, self.iter_expr.path, id);
+                } else {
+                    walk_expr(self, e);
+                }
+            } else if self.loop_id == e.hir_id {
+                self.after_loop = true;
+            } else {
+                walk_expr(self, e);
+            }
+        }
+    }
+
+    struct NestedLoopVisitor<'a, 'b, 'tcx> {
+        cx: &'a LateContext<'tcx>,
+        iter_expr: &'b IterExpr,
+        local_id: HirId,
+        loop_id: HirId,
+        after_loop: bool,
+        found_local: bool,
+        used_after: bool,
+    }
+    impl Visitor<'tcx> for NestedLoopVisitor<'a, 'b, 'tcx> {
+        type Map = ErasedMap<'tcx>;
+        fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+            NestedVisitorMap::None
+        }
 
-    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
-        if self.past_while_let {
-            if path_to_local_id(expr, self.def_id) {
-                self.var_used_after_while_let = true;
+        fn visit_local(&mut self, l: &'tcx Local<'_>) {
+            if !self.after_loop {
+                l.pat.each_binding_or_first(&mut |_, id, _, _| {
+                    if id == self.local_id {
+                        self.found_local = true;
+                    }
+                });
+            }
+            if let Some(e) = l.init {
+                self.visit_expr(e);
+            }
+        }
+
+        fn visit_expr(&mut self, e: &'tcx Expr<'_>) {
+            if self.used_after {
+                return;
+            }
+            if self.after_loop {
+                if is_expr_same_child_or_parent_field(self.cx, e, &self.iter_expr.fields, self.iter_expr.path) {
+                    self.used_after = true;
+                } else if let (e, true) = skip_fields_and_path(e) {
+                    if let Some(e) = e {
+                        self.visit_expr(e);
+                    }
+                } else if let ExprKind::Closure(_, _, id, _, _) = e.kind {
+                    self.used_after |= is_res_used(self.cx, self.iter_expr.path, id);
+                } else {
+                    walk_expr(self, e);
+                }
+            } else if e.hir_id == self.loop_id {
+                self.after_loop = true;
+            } else {
+                walk_expr(self, e);
             }
-        } else if self.iter_expr_id == expr.hir_id {
-            self.past_while_let = true;
         }
-        walk_expr(self, expr);
     }
-    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-        NestedVisitorMap::None
+
+    if let Some(e) = get_enclosing_loop(cx.tcx, loop_expr) {
+        // The iterator expression will be used on the next iteration unless it is declared within the outer
+        // loop.
+        let local_id = match iter_expr.path {
+            Res::Local(id) => id,
+            _ => return true,
+        };
+        let mut v = NestedLoopVisitor {
+            cx,
+            iter_expr,
+            local_id,
+            loop_id: loop_expr.hir_id,
+            after_loop: false,
+            found_local: false,
+            used_after: false,
+        };
+        v.visit_expr(e);
+        v.used_after || !v.found_local
+    } else {
+        let mut v = AfterLoopVisitor {
+            cx,
+            iter_expr,
+            loop_id: loop_expr.hir_id,
+            after_loop: false,
+            used_iter: false,
+        };
+        v.visit_expr(&cx.tcx.hir().body(cx.enclosing_body.unwrap()).value);
+        v.used_iter
     }
 }
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 7ca9d3a860d..371fe23bedc 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -855,6 +855,24 @@ pub fn get_enclosing_block<'tcx>(cx: &LateContext<'tcx>, hir_id: HirId) -> Optio
     })
 }
 
+/// Gets the loop enclosing the given expression, if any.
+pub fn get_enclosing_loop(tcx: TyCtxt<'tcx>, expr: &Expr<'_>) -> Option<&'tcx Expr<'tcx>> {
+    let map = tcx.hir();
+    for (_, node) in map.parent_iter(expr.hir_id) {
+        match node {
+            Node::Expr(
+                e @ Expr {
+                    kind: ExprKind::Loop(..),
+                    ..
+                },
+            ) => return Some(e),
+            Node::Expr(_) | Node::Stmt(_) | Node::Block(_) | Node::Local(_) | Node::Arm(_) => (),
+            _ => break,
+        }
+    }
+    None
+}
+
 /// Gets the parent node if it's an impl block.
 pub fn get_parent_as_impl(tcx: TyCtxt<'_>, id: HirId) -> Option<&Impl<'_>> {
     let map = tcx.hir();
diff --git a/clippy_utils/src/sugg.rs b/clippy_utils/src/sugg.rs
index 0633a19391f..0c950661757 100644
--- a/clippy_utils/src/sugg.rs
+++ b/clippy_utils/src/sugg.rs
@@ -289,7 +289,7 @@ fn has_enclosing_paren(sugg: impl AsRef<str>) -> bool {
     let mut chars = sugg.as_ref().chars();
     if let Some('(') = chars.next() {
         let mut depth = 1;
-        while let Some(c) = chars.next() {
+        for c in &mut chars {
             if c == '(' {
                 depth += 1;
             } else if c == ')' {
diff --git a/clippy_utils/src/visitors.rs b/clippy_utils/src/visitors.rs
index d431bdf34ee..ffd15076026 100644
--- a/clippy_utils/src/visitors.rs
+++ b/clippy_utils/src/visitors.rs
@@ -1,7 +1,7 @@
 use crate::path_to_local_id;
 use rustc_hir as hir;
 use rustc_hir::intravisit::{self, walk_expr, ErasedMap, NestedVisitorMap, Visitor};
-use rustc_hir::{Arm, Block, Body, Destination, Expr, ExprKind, HirId, Stmt};
+use rustc_hir::{def::Res, Arm, Block, Body, BodyId, Destination, Expr, ExprKind, HirId, Stmt};
 use rustc_lint::LateContext;
 use rustc_middle::hir::map::Map;
 
@@ -218,6 +218,7 @@ impl<'tcx> Visitable<'tcx> for &'tcx Arm<'tcx> {
     }
 }
 
+/// Calls the given function for each break expression.
 pub fn visit_break_exprs<'tcx>(
     node: impl Visitable<'tcx>,
     f: impl FnMut(&'tcx Expr<'tcx>, Destination, Option<&'tcx Expr<'tcx>>),
@@ -239,3 +240,36 @@ pub fn visit_break_exprs<'tcx>(
 
     node.visit(&mut V(f));
 }
+
+/// Checks if the given resolved path is used the body.
+pub fn is_res_used(cx: &LateContext<'_>, res: Res, body: BodyId) -> bool {
+    struct V<'a, 'tcx> {
+        cx: &'a LateContext<'tcx>,
+        res: Res,
+        found: bool,
+    }
+    impl Visitor<'tcx> for V<'_, 'tcx> {
+        type Map = Map<'tcx>;
+        fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+            NestedVisitorMap::OnlyBodies(self.cx.tcx.hir())
+        }
+
+        fn visit_expr(&mut self, e: &'tcx Expr<'_>) {
+            if self.found {
+                return;
+            }
+
+            if let ExprKind::Path(p) = &e.kind {
+                if self.cx.qpath_res(p, e.hir_id) == self.res {
+                    self.found = true;
+                }
+            } else {
+                walk_expr(self, e)
+            }
+        }
+    }
+
+    let mut v = V { cx, res, found: false };
+    v.visit_expr(&cx.tcx.hir().body(body).value);
+    v.found
+}
diff --git a/tests/ui/while_let_on_iterator.fixed b/tests/ui/while_let_on_iterator.fixed
index 749393db124..0562db48a88 100644
--- a/tests/ui/while_let_on_iterator.fixed
+++ b/tests/ui/while_let_on_iterator.fixed
@@ -1,7 +1,7 @@
 // run-rustfix
 
 #![warn(clippy::while_let_on_iterator)]
-#![allow(clippy::never_loop, unreachable_code, unused_mut)]
+#![allow(clippy::never_loop, unreachable_code, unused_mut, dead_code)]
 
 fn base() {
     let mut iter = 1..20;
@@ -38,13 +38,6 @@ fn base() {
         println!("next: {:?}", iter.next());
     }
 
-    // or this
-    let mut iter = 1u32..20;
-    while let Some(_) = iter.next() {
-        break;
-    }
-    println!("Remaining iter {:?}", iter);
-
     // or this
     let mut iter = 1u32..20;
     while let Some(_) = iter.next() {
@@ -135,18 +128,6 @@ fn refutable2() {
 
 fn nested_loops() {
     let a = [42, 1337];
-    let mut y = a.iter();
-    loop {
-        // x is reused, so don't lint here
-        while let Some(_) = y.next() {}
-    }
-
-    let mut y = a.iter();
-    for _ in 0..2 {
-        while let Some(_) = y.next() {
-            // y is reused, don't lint
-        }
-    }
 
     loop {
         let mut y = a.iter();
@@ -205,13 +186,138 @@ fn issue1654() {
     }
 }
 
-fn main() {
-    base();
-    refutable();
-    refutable2();
-    nested_loops();
-    issue1121();
-    issue2965();
-    issue3670();
-    issue1654();
+fn issue6491() {
+    // Used in outer loop, needs &mut
+    let mut it = 1..40;
+    while let Some(n) = it.next() {
+        for m in &mut it {
+            if m % 10 == 0 {
+                break;
+            }
+            println!("doing something with m: {}", m);
+        }
+        println!("n still is {}", n);
+    }
+
+    // This is fine, inner loop uses a new iterator.
+    let mut it = 1..40;
+    for n in it {
+        let mut it = 1..40;
+        for m in it {
+            if m % 10 == 0 {
+                break;
+            }
+            println!("doing something with m: {}", m);
+        }
+
+        // Weird binding shouldn't change anything.
+        let (mut it, _) = (1..40, 0);
+        for m in it {
+            if m % 10 == 0 {
+                break;
+            }
+            println!("doing something with m: {}", m);
+        }
+
+        // Used after the loop, needs &mut.
+        let mut it = 1..40;
+        for m in &mut it {
+            if m % 10 == 0 {
+                break;
+            }
+            println!("doing something with m: {}", m);
+        }
+        println!("next item {}", it.next().unwrap());
+
+        println!("n still is {}", n);
+    }
+}
+
+fn issue6231() {
+    // Closure in the outer loop, needs &mut
+    let mut it = 1..40;
+    let mut opt = Some(0);
+    while let Some(n) = opt.take().or_else(|| it.next()) {
+        for m in &mut it {
+            if n % 10 == 0 {
+                break;
+            }
+            println!("doing something with m: {}", m);
+        }
+        println!("n still is {}", n);
+    }
 }
+
+fn issue1924() {
+    struct S<T>(T);
+    impl<T: Iterator<Item = u32>> S<T> {
+        fn f(&mut self) -> Option<u32> {
+            // Used as a field.
+            for i in &mut self.0 {
+                if !(3..=7).contains(&i) {
+                    return Some(i);
+                }
+            }
+            None
+        }
+
+        fn f2(&mut self) -> Option<u32> {
+            // Don't lint, self borrowed inside the loop
+            while let Some(i) = self.0.next() {
+                if i == 1 {
+                    return self.f();
+                }
+            }
+            None
+        }
+    }
+    impl<T: Iterator<Item = u32>> S<(S<T>, Option<u32>)> {
+        fn f3(&mut self) -> Option<u32> {
+            // Don't lint, self borrowed inside the loop
+            while let Some(i) = self.0.0.0.next() {
+                if i == 1 {
+                    return self.0.0.f();
+                }
+            }
+            while let Some(i) = self.0.0.0.next() {
+                if i == 1 {
+                    return self.f3();
+                }
+            }
+            // This one is fine, a different field is borrowed
+            for i in &mut self.0.0.0 {
+                if i == 1 {
+                    return self.0.1.take();
+                }
+            }
+            None
+        }
+    }
+
+    struct S2<T>(T, u32);
+    impl<T: Iterator<Item = u32>> Iterator for S2<T> {
+        type Item = u32;
+        fn next(&mut self) -> Option<u32> {
+            self.0.next()
+        }
+    }
+
+    // Don't lint, field of the iterator is accessed in the loop
+    let mut it = S2(1..40, 0);
+    while let Some(n) = it.next() {
+        if n == it.1 {
+            break;
+        }
+    }
+
+    // Needs &mut, field of the iterator is accessed after the loop
+    let mut it = S2(1..40, 0);
+    for n in &mut it {
+        if n == 0 {
+            break;
+        }
+    }
+    println!("iterator field {}", it.1);
+}
+
+fn main() {}
diff --git a/tests/ui/while_let_on_iterator.rs b/tests/ui/while_let_on_iterator.rs
index 30e3b82a7cc..a7c217dc7fd 100644
--- a/tests/ui/while_let_on_iterator.rs
+++ b/tests/ui/while_let_on_iterator.rs
@@ -1,7 +1,7 @@
 // run-rustfix
 
 #![warn(clippy::while_let_on_iterator)]
-#![allow(clippy::never_loop, unreachable_code, unused_mut)]
+#![allow(clippy::never_loop, unreachable_code, unused_mut, dead_code)]
 
 fn base() {
     let mut iter = 1..20;
@@ -38,13 +38,6 @@ fn base() {
         println!("next: {:?}", iter.next());
     }
 
-    // or this
-    let mut iter = 1u32..20;
-    while let Some(_) = iter.next() {
-        break;
-    }
-    println!("Remaining iter {:?}", iter);
-
     // or this
     let mut iter = 1u32..20;
     while let Some(_) = iter.next() {
@@ -135,18 +128,6 @@ fn refutable2() {
 
 fn nested_loops() {
     let a = [42, 1337];
-    let mut y = a.iter();
-    loop {
-        // x is reused, so don't lint here
-        while let Some(_) = y.next() {}
-    }
-
-    let mut y = a.iter();
-    for _ in 0..2 {
-        while let Some(_) = y.next() {
-            // y is reused, don't lint
-        }
-    }
 
     loop {
         let mut y = a.iter();
@@ -205,13 +186,138 @@ fn issue1654() {
     }
 }
 
-fn main() {
-    base();
-    refutable();
-    refutable2();
-    nested_loops();
-    issue1121();
-    issue2965();
-    issue3670();
-    issue1654();
+fn issue6491() {
+    // Used in outer loop, needs &mut
+    let mut it = 1..40;
+    while let Some(n) = it.next() {
+        while let Some(m) = it.next() {
+            if m % 10 == 0 {
+                break;
+            }
+            println!("doing something with m: {}", m);
+        }
+        println!("n still is {}", n);
+    }
+
+    // This is fine, inner loop uses a new iterator.
+    let mut it = 1..40;
+    while let Some(n) = it.next() {
+        let mut it = 1..40;
+        while let Some(m) = it.next() {
+            if m % 10 == 0 {
+                break;
+            }
+            println!("doing something with m: {}", m);
+        }
+
+        // Weird binding shouldn't change anything.
+        let (mut it, _) = (1..40, 0);
+        while let Some(m) = it.next() {
+            if m % 10 == 0 {
+                break;
+            }
+            println!("doing something with m: {}", m);
+        }
+
+        // Used after the loop, needs &mut.
+        let mut it = 1..40;
+        while let Some(m) = it.next() {
+            if m % 10 == 0 {
+                break;
+            }
+            println!("doing something with m: {}", m);
+        }
+        println!("next item {}", it.next().unwrap());
+
+        println!("n still is {}", n);
+    }
 }
+
+fn issue6231() {
+    // Closure in the outer loop, needs &mut
+    let mut it = 1..40;
+    let mut opt = Some(0);
+    while let Some(n) = opt.take().or_else(|| it.next()) {
+        while let Some(m) = it.next() {
+            if n % 10 == 0 {
+                break;
+            }
+            println!("doing something with m: {}", m);
+        }
+        println!("n still is {}", n);
+    }
+}
+
+fn issue1924() {
+    struct S<T>(T);
+    impl<T: Iterator<Item = u32>> S<T> {
+        fn f(&mut self) -> Option<u32> {
+            // Used as a field.
+            while let Some(i) = self.0.next() {
+                if i < 3 || i > 7 {
+                    return Some(i);
+                }
+            }
+            None
+        }
+
+        fn f2(&mut self) -> Option<u32> {
+            // Don't lint, self borrowed inside the loop
+            while let Some(i) = self.0.next() {
+                if i == 1 {
+                    return self.f();
+                }
+            }
+            None
+        }
+    }
+    impl<T: Iterator<Item = u32>> S<(S<T>, Option<u32>)> {
+        fn f3(&mut self) -> Option<u32> {
+            // Don't lint, self borrowed inside the loop
+            while let Some(i) = self.0.0.0.next() {
+                if i == 1 {
+                    return self.0.0.f();
+                }
+            }
+            while let Some(i) = self.0.0.0.next() {
+                if i == 1 {
+                    return self.f3();
+                }
+            }
+            // This one is fine, a different field is borrowed
+            while let Some(i) = self.0.0.0.next() {
+                if i == 1 {
+                    return self.0.1.take();
+                }
+            }
+            None
+        }
+    }
+
+    struct S2<T>(T, u32);
+    impl<T: Iterator<Item = u32>> Iterator for S2<T> {
+        type Item = u32;
+        fn next(&mut self) -> Option<u32> {
+            self.0.next()
+        }
+    }
+
+    // Don't lint, field of the iterator is accessed in the loop
+    let mut it = S2(1..40, 0);
+    while let Some(n) = it.next() {
+        if n == it.1 {
+            break;
+        }
+    }
+
+    // Needs &mut, field of the iterator is accessed after the loop
+    let mut it = S2(1..40, 0);
+    while let Some(n) = it.next() {
+        if n == 0 {
+            break;
+        }
+    }
+    println!("iterator field {}", it.1);
+}
+
+fn main() {}
diff --git a/tests/ui/while_let_on_iterator.stderr b/tests/ui/while_let_on_iterator.stderr
index 6554977c798..0feca257410 100644
--- a/tests/ui/while_let_on_iterator.stderr
+++ b/tests/ui/while_let_on_iterator.stderr
@@ -19,28 +19,90 @@ LL |     while let Some(_) = iter.next() {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for _ in iter`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:101:9
+  --> $DIR/while_let_on_iterator.rs:94:9
    |
 LL |         while let Some([..]) = it.next() {}
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for [..] in it`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:108:9
+  --> $DIR/while_let_on_iterator.rs:101:9
    |
 LL |         while let Some([_x]) = it.next() {}
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for [_x] in it`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:121:9
+  --> $DIR/while_let_on_iterator.rs:114:9
    |
 LL |         while let Some(x @ [_]) = it.next() {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for x @ [_] in it`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:153:9
+  --> $DIR/while_let_on_iterator.rs:134:9
    |
 LL |         while let Some(_) = y.next() {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for _ in y`
 
-error: aborting due to 7 previous errors
+error: this loop could be written as a `for` loop
+  --> $DIR/while_let_on_iterator.rs:193:9
+   |
+LL |         while let Some(m) = it.next() {
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for m in &mut it`
+
+error: this loop could be written as a `for` loop
+  --> $DIR/while_let_on_iterator.rs:204:5
+   |
+LL |     while let Some(n) = it.next() {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for n in it`
+
+error: this loop could be written as a `for` loop
+  --> $DIR/while_let_on_iterator.rs:206:9
+   |
+LL |         while let Some(m) = it.next() {
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for m in it`
+
+error: this loop could be written as a `for` loop
+  --> $DIR/while_let_on_iterator.rs:215:9
+   |
+LL |         while let Some(m) = it.next() {
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for m in it`
+
+error: this loop could be written as a `for` loop
+  --> $DIR/while_let_on_iterator.rs:224:9
+   |
+LL |         while let Some(m) = it.next() {
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for m in &mut it`
+
+error: this loop could be written as a `for` loop
+  --> $DIR/while_let_on_iterator.rs:241:9
+   |
+LL |         while let Some(m) = it.next() {
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for m in &mut it`
+
+error: this loop could be written as a `for` loop
+  --> $DIR/while_let_on_iterator.rs:256:13
+   |
+LL |             while let Some(i) = self.0.next() {
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for i in &mut self.0`
+
+error: manual `!RangeInclusive::contains` implementation
+  --> $DIR/while_let_on_iterator.rs:257:20
+   |
+LL |                 if i < 3 || i > 7 {
+   |                    ^^^^^^^^^^^^^^ help: use: `!(3..=7).contains(&i)`
+   |
+   = note: `-D clippy::manual-range-contains` implied by `-D warnings`
+
+error: this loop could be written as a `for` loop
+  --> $DIR/while_let_on_iterator.rs:288:13
+   |
+LL |             while let Some(i) = self.0.0.0.next() {
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for i in &mut self.0.0.0`
+
+error: this loop could be written as a `for` loop
+  --> $DIR/while_let_on_iterator.rs:315:5
+   |
+LL |     while let Some(n) = it.next() {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for n in &mut it`
+
+error: aborting due to 17 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 4713e25ab07badc863fff05fcd5bcf9852cf375e Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Tue, 13 Apr 2021 09:30:01 -0400
Subject: Cleanup of `while_let_on_iterator`

---
 clippy_lints/src/loops/while_let_on_iterator.rs | 116 +++++++++++-------------
 clippy_utils/src/visitors.rs                    |   2 +-
 tests/ui/while_let_on_iterator.fixed            |   9 +-
 tests/ui/while_let_on_iterator.rs               |   9 +-
 tests/ui/while_let_on_iterator.stderr           |  10 +-
 5 files changed, 80 insertions(+), 66 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/while_let_on_iterator.rs b/clippy_lints/src/loops/while_let_on_iterator.rs
index 75e92f08df1..63560047578 100644
--- a/clippy_lints/src/loops/while_let_on_iterator.rs
+++ b/clippy_lints/src/loops/while_let_on_iterator.rs
@@ -2,6 +2,7 @@ use super::WHILE_LET_ON_ITERATOR;
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::{get_enclosing_loop, is_refutable, is_trait_method, match_def_path, paths, visitors::is_res_used};
+use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_expr, ErasedMap, NestedVisitorMap, Visitor};
 use rustc_hir::{def::Res, Expr, ExprKind, HirId, Local, MatchSource, Node, PatKind, QPath, UnOp};
@@ -9,66 +10,57 @@ use rustc_lint::LateContext;
 use rustc_span::{symbol::sym, Span, Symbol};
 
 pub(super) fn check(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-    if let ExprKind::Match(scrutinee_expr, [arm, _], MatchSource::WhileLetDesugar) = expr.kind {
-        let some_pat = match arm.pat.kind {
-            PatKind::TupleStruct(QPath::Resolved(None, path), sub_pats, _) => match path.res {
-                Res::Def(_, id) if match_def_path(cx, id, &paths::OPTION_SOME) => sub_pats.first(),
-                _ => return,
-            },
-            _ => return,
-        };
-
-        let iter_expr = match scrutinee_expr.kind {
-            ExprKind::MethodCall(name, _, [iter_expr], _)
-                if name.ident.name == sym::next && is_trait_method(cx, scrutinee_expr, sym::Iterator) =>
-            {
-                if let Some(iter_expr) = try_parse_iter_expr(cx, iter_expr) {
-                    iter_expr
-                } else {
-                    return;
-                }
-            }
-            _ => return,
-        };
-
-        // Needed to find an outer loop, if there are any.
-        let loop_expr = if let Some((_, Node::Expr(e))) = cx.tcx.hir().parent_iter(expr.hir_id).nth(1) {
-            e
+    let (scrutinee_expr, iter_expr, some_pat, loop_expr) = if_chain! {
+        if let ExprKind::Match(scrutinee_expr, [arm, _], MatchSource::WhileLetDesugar) = expr.kind;
+        // check for `Some(..)` pattern
+        if let PatKind::TupleStruct(QPath::Resolved(None, pat_path), some_pat, _) = arm.pat.kind;
+        if let Res::Def(_, pat_did) = pat_path.res;
+        if match_def_path(cx, pat_did, &paths::OPTION_SOME);
+        // check for call to `Iterator::next`
+        if let ExprKind::MethodCall(method_name, _, [iter_expr], _) = scrutinee_expr.kind;
+        if method_name.ident.name == sym::next;
+        if is_trait_method(cx, scrutinee_expr, sym::Iterator);
+        if let Some(iter_expr) = try_parse_iter_expr(cx, iter_expr);
+        // get the loop containing the match expression
+        if let Some((_, Node::Expr(loop_expr))) = cx.tcx.hir().parent_iter(expr.hir_id).nth(1);
+        if !uses_iter(cx, &iter_expr, arm.body);
+        then {
+            (scrutinee_expr, iter_expr, some_pat, loop_expr)
         } else {
             return;
-        };
+        }
+    };
 
-        // Refutable patterns don't work with for loops.
-        // The iterator also can't be accessed withing the loop.
-        if some_pat.map_or(true, |p| is_refutable(cx, p)) || uses_iter(cx, &iter_expr, arm.body) {
+    let mut applicability = Applicability::MachineApplicable;
+    let loop_var = if let Some(some_pat) = some_pat.first() {
+        if is_refutable(cx, some_pat) {
+            // Refutable patterns don't work with for loops.
             return;
         }
+        snippet_with_applicability(cx, some_pat.span, "..", &mut applicability)
+    } else {
+        "_".into()
+    };
 
-        // If the iterator is a field or the iterator is accessed after the loop is complete it needs to be
-        // borrowed mutably.
-        // TODO: If the struct can be partially moved from and the struct isn't used afterwards a mutable
-        // borrow of a field isn't necessary.
-        let ref_mut = if !iter_expr.fields.is_empty() || needs_mutable_borrow(cx, &iter_expr, loop_expr) {
-            "&mut "
-        } else {
-            ""
-        };
-        let mut applicability = Applicability::MachineApplicable;
-        let iterator = snippet_with_applicability(cx, iter_expr.span, "_", &mut applicability);
-        let loop_var = some_pat.map_or_else(
-            || "_".into(),
-            |pat| snippet_with_applicability(cx, pat.span, "_", &mut applicability).into_owned(),
-        );
-        span_lint_and_sugg(
-            cx,
-            WHILE_LET_ON_ITERATOR,
-            expr.span.with_hi(scrutinee_expr.span.hi()),
-            "this loop could be written as a `for` loop",
-            "try",
-            format!("for {} in {}{}", loop_var, ref_mut, iterator),
-            applicability,
-        );
-    }
+    // If the iterator is a field or the iterator is accessed after the loop is complete it needs to be
+    // borrowed mutably. TODO: If the struct can be partially moved from and the struct isn't used
+    // afterwards a mutable borrow of a field isn't necessary.
+    let ref_mut = if !iter_expr.fields.is_empty() || needs_mutable_borrow(cx, &iter_expr, loop_expr) {
+        "&mut "
+    } else {
+        ""
+    };
+
+    let iterator = snippet_with_applicability(cx, iter_expr.span, "_", &mut applicability);
+    span_lint_and_sugg(
+        cx,
+        WHILE_LET_ON_ITERATOR,
+        expr.span.with_hi(scrutinee_expr.span.hi()),
+        "this loop could be written as a `for` loop",
+        "try",
+        format!("for {} in {}{}", loop_var, ref_mut, iterator),
+        applicability,
+    );
 }
 
 #[derive(Debug)]
@@ -135,8 +127,10 @@ fn is_expr_same_field(cx: &LateContext<'_>, mut e: &Expr<'_>, mut fields: &[Symb
     }
 }
 
-/// Checks if the given expression is the same field as, is a child of, of the parent of the given
-/// field. Used to check if the expression can be used while the given field is borrowed.
+/// Checks if the given expression is the same field as, is a child of, or is the parent of the
+/// given field. Used to check if the expression can be used while the given field is borrowed
+/// mutably. e.g. if checking for `x.y`, then `x.y`, `x.y.z`, and `x` will all return true, but
+/// `x.z`, and `y` will return false.
 fn is_expr_same_child_or_parent_field(cx: &LateContext<'_>, expr: &Expr<'_>, fields: &[Symbol], path_res: Res) -> bool {
     match expr.kind {
         ExprKind::Field(base, name) => {
@@ -166,7 +160,7 @@ fn is_expr_same_child_or_parent_field(cx: &LateContext<'_>, expr: &Expr<'_>, fie
                 }
             }
         },
-        // If the path matches, this is either an exact match, of the expression is a parent of the field.
+        // If the path matches, this is either an exact match, or the expression is a parent of the field.
         ExprKind::Path(ref path) => cx.qpath_res(path, expr.hir_id) == path_res,
         ExprKind::DropTemps(base) | ExprKind::Type(base, _) | ExprKind::AddrOf(_, _, base) => {
             is_expr_same_child_or_parent_field(cx, base, fields, path_res)
@@ -175,8 +169,8 @@ fn is_expr_same_child_or_parent_field(cx: &LateContext<'_>, expr: &Expr<'_>, fie
     }
 }
 
-/// Strips off all field and path expressions. Used to skip them after failing to check for
-/// equality.
+/// Strips off all field and path expressions. This will return true if a field or path has been
+/// skipped. Used to skip them after failing to check for equality.
 fn skip_fields_and_path(expr: &'tcx Expr<'_>) -> (Option<&'tcx Expr<'tcx>>, bool) {
     let mut e = expr;
     let e = loop {
@@ -257,7 +251,7 @@ fn needs_mutable_borrow(cx: &LateContext<'tcx>, iter_expr: &IterExpr, loop_expr:
                         self.visit_expr(e);
                     }
                 } else if let ExprKind::Closure(_, _, id, _, _) = e.kind {
-                    self.used_iter |= is_res_used(self.cx, self.iter_expr.path, id);
+                    self.used_iter = is_res_used(self.cx, self.iter_expr.path, id);
                 } else {
                     walk_expr(self, e);
                 }
@@ -309,7 +303,7 @@ fn needs_mutable_borrow(cx: &LateContext<'tcx>, iter_expr: &IterExpr, loop_expr:
                         self.visit_expr(e);
                     }
                 } else if let ExprKind::Closure(_, _, id, _, _) = e.kind {
-                    self.used_after |= is_res_used(self.cx, self.iter_expr.path, id);
+                    self.used_after = is_res_used(self.cx, self.iter_expr.path, id);
                 } else {
                     walk_expr(self, e);
                 }
diff --git a/clippy_utils/src/visitors.rs b/clippy_utils/src/visitors.rs
index ffd15076026..ecdc666b5f6 100644
--- a/clippy_utils/src/visitors.rs
+++ b/clippy_utils/src/visitors.rs
@@ -241,7 +241,7 @@ pub fn visit_break_exprs<'tcx>(
     node.visit(&mut V(f));
 }
 
-/// Checks if the given resolved path is used the body.
+/// Checks if the given resolved path is used in the given body.
 pub fn is_res_used(cx: &LateContext<'_>, res: Res, body: BodyId) -> bool {
     struct V<'a, 'tcx> {
         cx: &'a LateContext<'tcx>,
diff --git a/tests/ui/while_let_on_iterator.fixed b/tests/ui/while_let_on_iterator.fixed
index 0562db48a88..389297eff0c 100644
--- a/tests/ui/while_let_on_iterator.fixed
+++ b/tests/ui/while_let_on_iterator.fixed
@@ -288,6 +288,8 @@ fn issue1924() {
             for i in &mut self.0.0.0 {
                 if i == 1 {
                     return self.0.1.take();
+                } else {
+                    self.0.1 = Some(i);
                 }
             }
             None
@@ -320,4 +322,9 @@ fn issue1924() {
     println!("iterator field {}", it.1);
 }
 
-fn main() {}
+fn main() {
+    let mut it = 0..20;
+    for _ in it {
+        println!("test");
+    }
+}
diff --git a/tests/ui/while_let_on_iterator.rs b/tests/ui/while_let_on_iterator.rs
index a7c217dc7fd..df932724a0d 100644
--- a/tests/ui/while_let_on_iterator.rs
+++ b/tests/ui/while_let_on_iterator.rs
@@ -288,6 +288,8 @@ fn issue1924() {
             while let Some(i) = self.0.0.0.next() {
                 if i == 1 {
                     return self.0.1.take();
+                } else {
+                    self.0.1 = Some(i);
                 }
             }
             None
@@ -320,4 +322,9 @@ fn issue1924() {
     println!("iterator field {}", it.1);
 }
 
-fn main() {}
+fn main() {
+    let mut it = 0..20;
+    while let Some(..) = it.next() {
+        println!("test");
+    }
+}
diff --git a/tests/ui/while_let_on_iterator.stderr b/tests/ui/while_let_on_iterator.stderr
index 0feca257410..e8741f74981 100644
--- a/tests/ui/while_let_on_iterator.stderr
+++ b/tests/ui/while_let_on_iterator.stderr
@@ -99,10 +99,16 @@ LL |             while let Some(i) = self.0.0.0.next() {
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for i in &mut self.0.0.0`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:315:5
+  --> $DIR/while_let_on_iterator.rs:317:5
    |
 LL |     while let Some(n) = it.next() {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for n in &mut it`
 
-error: aborting due to 17 previous errors
+error: this loop could be written as a `for` loop
+  --> $DIR/while_let_on_iterator.rs:327:5
+   |
+LL |     while let Some(..) = it.next() {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for _ in it`
+
+error: aborting due to 18 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From cd241b33cb8379311286f53c4afc6e671ddfded1 Mon Sep 17 00:00:00 2001
From: ThibsG <thibsg@pm.me>
Date: Thu, 13 May 2021 10:24:29 +0200
Subject: Trigger `wrong_self_convention` only if it has implicit self

---
 clippy_lints/src/methods/mod.rs        | 24 ++++++++++++++----------
 tests/ui/wrong_self_convention2.rs     | 23 +++++++++++++++++++++++
 tests/ui/wrong_self_convention2.stderr | 19 +++++++++++++++++++
 3 files changed, 56 insertions(+), 10 deletions(-)
 create mode 100644 tests/ui/wrong_self_convention2.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 0b1b6304def..e0d29682146 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1838,16 +1838,18 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
                     }
                 }
 
-                wrong_self_convention::check(
-                    cx,
-                    &name,
-                    item.vis.node.is_pub(),
-                    self_ty,
-                    first_arg_ty,
-                    first_arg.pat.span,
-                    implements_trait,
-                    false
-                );
+                if sig.decl.implicit_self.has_implicit_self() {
+                    wrong_self_convention::check(
+                        cx,
+                        &name,
+                        item.vis.node.is_pub(),
+                        self_ty,
+                        first_arg_ty,
+                        first_arg.pat.span,
+                        implements_trait,
+                        false
+                    );
+                }
             }
         }
 
@@ -1903,7 +1905,9 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
 
         if_chain! {
             if let TraitItemKind::Fn(ref sig, _) = item.kind;
+            if sig.decl.implicit_self.has_implicit_self();
             if let Some(first_arg_ty) = sig.decl.inputs.iter().next();
+
             then {
                 let first_arg_span = first_arg_ty.span;
                 let first_arg_ty = hir_ty_to_ty(cx.tcx, first_arg_ty);
diff --git a/tests/ui/wrong_self_convention2.rs b/tests/ui/wrong_self_convention2.rs
index 18202ef2989..b2c6503de49 100644
--- a/tests/ui/wrong_self_convention2.rs
+++ b/tests/ui/wrong_self_convention2.rs
@@ -42,3 +42,26 @@ mod issue7032 {
         }
     }
 }
+
+mod issue7179 {
+    pub struct S(i32);
+
+    impl S {
+        // don't trigger (`s` is not `self`)
+        pub fn from_be(s: Self) -> Self {
+            S(i32::from_be(s.0))
+        }
+
+        // lint
+        pub fn from_be_self(self) -> Self {
+            S(i32::from_be(self.0))
+        }
+    }
+
+    trait T {
+        // don't trigger (`s` is not `self`)
+        fn from_be(s: Self) -> Self;
+        // lint
+        fn from_be_self(self) -> Self;
+    }
+}
diff --git a/tests/ui/wrong_self_convention2.stderr b/tests/ui/wrong_self_convention2.stderr
new file mode 100644
index 00000000000..d2d74ce099e
--- /dev/null
+++ b/tests/ui/wrong_self_convention2.stderr
@@ -0,0 +1,19 @@
+error: methods called `from_*` usually take no `self`
+  --> $DIR/wrong_self_convention2.rs:56:29
+   |
+LL |         pub fn from_be_self(self) -> Self {
+   |                             ^^^^
+   |
+   = note: `-D clippy::wrong-self-convention` implied by `-D warnings`
+   = help: consider choosing a less ambiguous name
+
+error: methods called `from_*` usually take no `self`
+  --> $DIR/wrong_self_convention2.rs:65:25
+   |
+LL |         fn from_be_self(self) -> Self;
+   |                         ^^^^
+   |
+   = help: consider choosing a less ambiguous name
+
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 368e621265ab7f3066d1e3e56b0633bca3f7e831 Mon Sep 17 00:00:00 2001
From: ThibsG <thibsg@pm.me>
Date: Thu, 13 May 2021 11:50:25 +0200
Subject: Stop linting `else if let` pattern in `option_if_let_else` lint

---
 clippy_lints/src/option_if_let_else.rs |  4 +++-
 tests/ui/option_if_let_else.fixed      |  6 +++++-
 tests/ui/option_if_let_else.stderr     | 13 +------------
 3 files changed, 9 insertions(+), 14 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/option_if_let_else.rs b/clippy_lints/src/option_if_let_else.rs
index e527adbb892..2d98b275de7 100644
--- a/clippy_lints/src/option_if_let_else.rs
+++ b/clippy_lints/src/option_if_let_else.rs
@@ -2,7 +2,7 @@ use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::usage::contains_return_break_continue_macro;
-use clippy_utils::{eager_or_lazy, get_enclosing_block, in_macro, is_lang_ctor};
+use clippy_utils::{eager_or_lazy, get_enclosing_block, in_macro, is_else_clause, is_lang_ctor};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::LangItem::OptionSome;
@@ -161,6 +161,7 @@ fn detect_option_if_let_else<'tcx>(
     if_chain! {
         if !in_macro(expr.span); // Don't lint macros, because it behaves weirdly
         if let ExprKind::Match(cond_expr, arms, MatchSource::IfLetDesugar{contains_else_clause: true}) = &expr.kind;
+        if !is_else_clause(cx.tcx, expr);
         if arms.len() == 2;
         if !is_result_ok(cx, cond_expr); // Don't lint on Result::ok because a different lint does it already
         if let PatKind::TupleStruct(struct_qpath, &[inner_pat], _) = &arms[0].pat.kind;
@@ -168,6 +169,7 @@ fn detect_option_if_let_else<'tcx>(
         if let PatKind::Binding(bind_annotation, _, id, _) = &inner_pat.kind;
         if !contains_return_break_continue_macro(arms[0].body);
         if !contains_return_break_continue_macro(arms[1].body);
+
         then {
             let capture_mut = if bind_annotation == &BindingAnnotation::Mutable { "mut " } else { "" };
             let some_body = extract_body_from_arm(&arms[0])?;
diff --git a/tests/ui/option_if_let_else.fixed b/tests/ui/option_if_let_else.fixed
index 47e7460fa7a..769ccc14bc1 100644
--- a/tests/ui/option_if_let_else.fixed
+++ b/tests/ui/option_if_let_else.fixed
@@ -10,7 +10,11 @@ fn bad1(string: Option<&str>) -> (bool, &str) {
 fn else_if_option(string: Option<&str>) -> Option<(bool, &str)> {
     if string.is_none() {
         None
-    } else { string.map_or(Some((false, "")), |x| Some((true, x))) }
+    } else if let Some(x) = string {
+        Some((true, x))
+    } else {
+        Some((false, ""))
+    }
 }
 
 fn unop_bad(string: &Option<&str>, mut num: Option<i32>) {
diff --git a/tests/ui/option_if_let_else.stderr b/tests/ui/option_if_let_else.stderr
index 7aab068800a..4ebb068d22e 100644
--- a/tests/ui/option_if_let_else.stderr
+++ b/tests/ui/option_if_let_else.stderr
@@ -10,17 +10,6 @@ LL | |     }
    |
    = note: `-D clippy::option-if-let-else` implied by `-D warnings`
 
-error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:17:12
-   |
-LL |       } else if let Some(x) = string {
-   |  ____________^
-LL | |         Some((true, x))
-LL | |     } else {
-LL | |         Some((false, ""))
-LL | |     }
-   | |_____^ help: try: `{ string.map_or(Some((false, "")), |x| Some((true, x))) }`
-
 error: use Option::map_or instead of an if let/else
   --> $DIR/option_if_let_else.rs:25:13
    |
@@ -159,5 +148,5 @@ error: use Option::map_or instead of an if let/else
 LL |     let _ = if let Some(x) = optional { x + 2 } else { 5 };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `optional.map_or(5, |x| x + 2)`
 
-error: aborting due to 12 previous errors
+error: aborting due to 11 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From b24929044877b0a3710f40b3cf27b61d79b5d5df Mon Sep 17 00:00:00 2001
From: Mateusz Gacek <96mateusz.gacek@gmail.com>
Date: Thu, 13 May 2021 17:09:59 +0200
Subject: needless_collect: use snippet_with_applicability

+ small code refactor - using early returns.
---
 clippy_lints/src/loops/needless_collect.rs | 37 +++++++++++++++---------------
 1 file changed, 18 insertions(+), 19 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/needless_collect.rs b/clippy_lints/src/loops/needless_collect.rs
index 89c95f3d127..d3406780888 100644
--- a/clippy_lints/src/loops/needless_collect.rs
+++ b/clippy_lints/src/loops/needless_collect.rs
@@ -1,6 +1,6 @@
 use super::NEEDLESS_COLLECT;
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
-use clippy_utils::source::snippet;
+use clippy_utils::source::{snippet, snippet_with_applicability};
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::{is_trait_method, path_to_local_id};
@@ -28,46 +28,45 @@ fn check_needless_collect_direct_usage<'tcx>(expr: &'tcx Expr<'_>, cx: &LateCont
         if let Some(GenericArg::Type(ref ty)) = generic_args.args.get(0);
         if let Some(ty) = cx.typeck_results().node_type_opt(ty.hir_id);
         then {
-            let is_empty_sugg = Some("next().is_none()".to_string());
+            let mut applicability = Applicability::MachineApplicable;
+            let is_empty_sugg = "next().is_none()".to_string();
             let method_name = &*method.ident.name.as_str();
             let sugg = if is_type_diagnostic_item(cx, ty, sym::vec_type) ||
                         is_type_diagnostic_item(cx, ty, sym::vecdeque_type) ||
                         is_type_diagnostic_item(cx, ty, sym::LinkedList) ||
                         is_type_diagnostic_item(cx, ty, sym::BinaryHeap) {
                 match method_name {
-                    "len" => Some("count()".to_string()),
+                    "len" => "count()".to_string(),
                     "is_empty" => is_empty_sugg,
                     "contains" => {
-                        let contains_arg = snippet(cx, args[1].span, "??");
+                        let contains_arg = snippet_with_applicability(cx, args[1].span, "??", &mut applicability);
                         let (arg, pred) = contains_arg
                             .strip_prefix('&')
                             .map_or(("&x", &*contains_arg), |s| ("x", s));
-                        Some(format!("any(|{}| x == {})", arg, pred))
+                        format!("any(|{}| x == {})", arg, pred)
                     }
-                    _ => None,
+                    _ => return,
                 }
             }
             else if is_type_diagnostic_item(cx, ty, sym::BTreeMap) ||
                 is_type_diagnostic_item(cx, ty, sym::hashmap_type) {
                 match method_name {
                     "is_empty" => is_empty_sugg,
-                    _ => None,
+                    _ => return,
                 }
             }
             else {
-                None
+                return;
             };
-            if let Some(sugg) = sugg {
-                span_lint_and_sugg(
-                    cx,
-                    NEEDLESS_COLLECT,
-                    method0_span.with_hi(expr.span.hi()),
-                    NEEDLESS_COLLECT_MSG,
-                    "replace with",
-                    sugg,
-                    Applicability::MachineApplicable,
-                );
-            }
+            span_lint_and_sugg(
+                cx,
+                NEEDLESS_COLLECT,
+                method0_span.with_hi(expr.span.hi()),
+                NEEDLESS_COLLECT_MSG,
+                "replace with",
+                sugg,
+                applicability,
+            );
         }
     }
 }
-- 
cgit 1.4.1-3-g733a5


From c6e0e843d279c0c4703e2b3326826423b791dee2 Mon Sep 17 00:00:00 2001
From: Jackson Lewis <jackson.lewis@agilebits.com>
Date: Fri, 14 May 2021 16:45:18 -0700
Subject: Implement unnecessary-async and UI test

---
 clippy_lints/src/lib.rs               |  4 ++
 clippy_lints/src/unnecessary_async.rs | 92 +++++++++++++++++++++++++++++++++++
 tests/ui/unnecessary_async.rs         | 15 ++++++
 tests/ui/unnecessary_async.stderr     | 13 +++++
 4 files changed, 124 insertions(+)
 create mode 100644 clippy_lints/src/unnecessary_async.rs
 create mode 100644 tests/ui/unnecessary_async.rs
 create mode 100644 tests/ui/unnecessary_async.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 1a74f641554..e8b8b2e9117 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -360,6 +360,7 @@ mod unnamed_address;
 mod unnecessary_self_imports;
 mod unnecessary_sort_by;
 mod unnecessary_wraps;
+mod unnecessary_async;
 mod unnested_or_patterns;
 mod unsafe_removed_from_name;
 mod unused_io_amount;
@@ -954,6 +955,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         unit_types::UNIT_CMP,
         unnamed_address::FN_ADDRESS_COMPARISONS,
         unnamed_address::VTABLE_ADDRESS_COMPARISONS,
+        unnecessary_async::UNNECESSARY_ASYNC,
         unnecessary_self_imports::UNNECESSARY_SELF_IMPORTS,
         unnecessary_sort_by::UNNECESSARY_SORT_BY,
         unnecessary_wraps::UNNECESSARY_WRAPS,
@@ -1271,6 +1273,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box manual_map::ManualMap);
     store.register_late_pass(move || box if_then_some_else_none::IfThenSomeElseNone::new(msrv));
     store.register_early_pass(|| box bool_assert_comparison::BoolAssertComparison);
+    store.register_late_pass(|| box unnecessary_async::UnnecessaryAsync);
 
     store.register_group(true, "clippy::restriction", Some("clippy_restriction"), vec![
         LintId::of(arithmetic::FLOAT_ARITHMETIC),
@@ -1412,6 +1415,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(unicode::NON_ASCII_LITERAL),
         LintId::of(unicode::UNICODE_NOT_NFC),
         LintId::of(unit_types::LET_UNIT_VALUE),
+        LintId::of(unnecessary_async::UNNECESSARY_ASYNC),
         LintId::of(unnecessary_wraps::UNNECESSARY_WRAPS),
         LintId::of(unnested_or_patterns::UNNESTED_OR_PATTERNS),
         LintId::of(unused_self::UNUSED_SELF),
diff --git a/clippy_lints/src/unnecessary_async.rs b/clippy_lints/src/unnecessary_async.rs
new file mode 100644
index 00000000000..15a90ba42d2
--- /dev/null
+++ b/clippy_lints/src/unnecessary_async.rs
@@ -0,0 +1,92 @@
+use clippy_utils::diagnostics::span_lint_and_help;
+use rustc_hir::intravisit::{walk_expr, walk_fn, FnKind, NestedVisitorMap, Visitor};
+use rustc_hir::{Body, Expr, ExprKind, FnDecl, FnHeader, HirId, IsAsync, Item, ItemKind, YieldSource};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::hir::map::Map;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::Span;
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for functions that are declared `async` but have no `.await`s inside of them.
+    ///
+    /// **Why is this bad?** Async functions with no async code create overhead, both mentally and computationally.
+    /// Callers of async methods either need to be calling from an async function themselves or run it on an executor, both of which
+    /// causes runtime overhead and hassle for the caller.
+    ///
+    /// **Known problems:** None
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// // Bad
+    /// async fn get_random_number() -> i64 {
+    ///     4 // Chosen by fair dice roll. Guaranteed to be random.
+    /// }
+    /// let number_future = get_random_number();
+    ///
+    /// // Good
+    /// fn get_random_number_improved() -> i64 {
+    ///     4 // Chosen by fair dice roll. Guaranteed to be random.
+    /// }
+    /// let number_future = async { get_random_number_improved() };
+    /// ```
+    pub UNNECESSARY_ASYNC,
+    pedantic,
+    "finds async functions with no await statements"
+}
+
+declare_lint_pass!(UnnecessaryAsync => [UNNECESSARY_ASYNC]);
+
+struct AsyncFnVisitor<'a, 'tcx> {
+    cx: &'a LateContext<'tcx>,
+    found_await: bool,
+}
+
+impl<'a, 'tcx> Visitor<'tcx> for AsyncFnVisitor<'a, 'tcx> {
+    type Map = Map<'tcx>;
+
+    fn visit_expr(&mut self, ex: &'tcx Expr<'tcx>) {
+        if let ExprKind::Yield(_, YieldSource::Await { .. }) = ex.kind {
+            self.found_await = true;
+        }
+        walk_expr(self, ex);
+    }
+
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::OnlyBodies(self.cx.tcx.hir())
+    }
+}
+
+impl<'tcx> LateLintPass<'tcx> for UnnecessaryAsync {
+    fn check_item(&mut self, _: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
+        if let ItemKind::Trait(..) = item.kind {
+            return;
+        }
+    }
+    fn check_fn(
+        &mut self,
+        cx: &LateContext<'tcx>,
+        fn_kind: FnKind<'tcx>,
+        fn_decl: &'tcx FnDecl<'tcx>,
+        body: &Body<'tcx>,
+        span: Span,
+        hir_id: HirId,
+    ) {
+        if let FnKind::ItemFn(_, _, FnHeader { asyncness, .. }, _) = &fn_kind {
+            if matches!(asyncness, IsAsync::Async) {
+                let mut visitor = AsyncFnVisitor { cx, found_await: false };
+                walk_fn(&mut visitor, fn_kind, fn_decl, body.id(), span, hir_id);
+                if !visitor.found_await {
+                    span_lint_and_help(
+                        cx,
+                        UNNECESSARY_ASYNC,
+                        span,
+                        "unnecessary `async` for function with no await statements",
+                        None,
+                        "consider removing the `async` from this function",
+                    );
+                }
+            }
+        }
+    }
+}
diff --git a/tests/ui/unnecessary_async.rs b/tests/ui/unnecessary_async.rs
new file mode 100644
index 00000000000..7d63083b13e
--- /dev/null
+++ b/tests/ui/unnecessary_async.rs
@@ -0,0 +1,15 @@
+// edition:2018
+#![warn(clippy::unnecessary_async)]
+
+async fn foo() -> i32 {
+    4
+}
+
+async fn bar() -> i32 {
+    foo().await
+}
+
+fn main() {
+    foo();
+    bar();
+}
diff --git a/tests/ui/unnecessary_async.stderr b/tests/ui/unnecessary_async.stderr
new file mode 100644
index 00000000000..5542580e45d
--- /dev/null
+++ b/tests/ui/unnecessary_async.stderr
@@ -0,0 +1,13 @@
+error: unnecessary `async` for function with no await statements
+  --> $DIR/unnecessary_async.rs:4:1
+   |
+LL | / async fn foo() -> i32 {
+LL | |     4
+LL | | }
+   | |_^
+   |
+   = note: `-D clippy::unnecessary-async` implied by `-D warnings`
+   = help: consider removing the `async` from this function
+
+error: aborting due to previous error
+
-- 
cgit 1.4.1-3-g733a5


From 1d8f3b51e662bb66e2b696d0c13057d6ba89f979 Mon Sep 17 00:00:00 2001
From: Jackson Lewis <jackson.lewis@agilebits.com>
Date: Fri, 14 May 2021 17:07:30 -0700
Subject: Unnecessary -> Unused

---
 clippy_lints/src/lib.rs               |  8 +--
 clippy_lints/src/unnecessary_async.rs | 92 -----------------------------------
 clippy_lints/src/unused_async.rs      | 92 +++++++++++++++++++++++++++++++++++
 tests/ui/unnecessary_async.rs         | 15 ------
 tests/ui/unnecessary_async.stderr     | 13 -----
 tests/ui/unused_async.rs              | 15 ++++++
 tests/ui/unused_async.stderr          | 13 +++++
 7 files changed, 124 insertions(+), 124 deletions(-)
 delete mode 100644 clippy_lints/src/unnecessary_async.rs
 create mode 100644 clippy_lints/src/unused_async.rs
 delete mode 100644 tests/ui/unnecessary_async.rs
 delete mode 100644 tests/ui/unnecessary_async.stderr
 create mode 100644 tests/ui/unused_async.rs
 create mode 100644 tests/ui/unused_async.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index e8b8b2e9117..52e64d6a48f 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -360,7 +360,7 @@ mod unnamed_address;
 mod unnecessary_self_imports;
 mod unnecessary_sort_by;
 mod unnecessary_wraps;
-mod unnecessary_async;
+mod unused_async;
 mod unnested_or_patterns;
 mod unsafe_removed_from_name;
 mod unused_io_amount;
@@ -955,7 +955,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         unit_types::UNIT_CMP,
         unnamed_address::FN_ADDRESS_COMPARISONS,
         unnamed_address::VTABLE_ADDRESS_COMPARISONS,
-        unnecessary_async::UNNECESSARY_ASYNC,
+        unused_async::UNUSED_ASYNC,
         unnecessary_self_imports::UNNECESSARY_SELF_IMPORTS,
         unnecessary_sort_by::UNNECESSARY_SORT_BY,
         unnecessary_wraps::UNNECESSARY_WRAPS,
@@ -1273,7 +1273,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box manual_map::ManualMap);
     store.register_late_pass(move || box if_then_some_else_none::IfThenSomeElseNone::new(msrv));
     store.register_early_pass(|| box bool_assert_comparison::BoolAssertComparison);
-    store.register_late_pass(|| box unnecessary_async::UnnecessaryAsync);
+    store.register_late_pass(|| box unused_async::UnusedAsync);
 
     store.register_group(true, "clippy::restriction", Some("clippy_restriction"), vec![
         LintId::of(arithmetic::FLOAT_ARITHMETIC),
@@ -1415,7 +1415,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(unicode::NON_ASCII_LITERAL),
         LintId::of(unicode::UNICODE_NOT_NFC),
         LintId::of(unit_types::LET_UNIT_VALUE),
-        LintId::of(unnecessary_async::UNNECESSARY_ASYNC),
+        LintId::of(unused_async::UNUSED_ASYNC),
         LintId::of(unnecessary_wraps::UNNECESSARY_WRAPS),
         LintId::of(unnested_or_patterns::UNNESTED_OR_PATTERNS),
         LintId::of(unused_self::UNUSED_SELF),
diff --git a/clippy_lints/src/unnecessary_async.rs b/clippy_lints/src/unnecessary_async.rs
deleted file mode 100644
index 15a90ba42d2..00000000000
--- a/clippy_lints/src/unnecessary_async.rs
+++ /dev/null
@@ -1,92 +0,0 @@
-use clippy_utils::diagnostics::span_lint_and_help;
-use rustc_hir::intravisit::{walk_expr, walk_fn, FnKind, NestedVisitorMap, Visitor};
-use rustc_hir::{Body, Expr, ExprKind, FnDecl, FnHeader, HirId, IsAsync, Item, ItemKind, YieldSource};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::hir::map::Map;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::Span;
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for functions that are declared `async` but have no `.await`s inside of them.
-    ///
-    /// **Why is this bad?** Async functions with no async code create overhead, both mentally and computationally.
-    /// Callers of async methods either need to be calling from an async function themselves or run it on an executor, both of which
-    /// causes runtime overhead and hassle for the caller.
-    ///
-    /// **Known problems:** None
-    ///
-    /// **Example:**
-    ///
-    /// ```rust
-    /// // Bad
-    /// async fn get_random_number() -> i64 {
-    ///     4 // Chosen by fair dice roll. Guaranteed to be random.
-    /// }
-    /// let number_future = get_random_number();
-    ///
-    /// // Good
-    /// fn get_random_number_improved() -> i64 {
-    ///     4 // Chosen by fair dice roll. Guaranteed to be random.
-    /// }
-    /// let number_future = async { get_random_number_improved() };
-    /// ```
-    pub UNNECESSARY_ASYNC,
-    pedantic,
-    "finds async functions with no await statements"
-}
-
-declare_lint_pass!(UnnecessaryAsync => [UNNECESSARY_ASYNC]);
-
-struct AsyncFnVisitor<'a, 'tcx> {
-    cx: &'a LateContext<'tcx>,
-    found_await: bool,
-}
-
-impl<'a, 'tcx> Visitor<'tcx> for AsyncFnVisitor<'a, 'tcx> {
-    type Map = Map<'tcx>;
-
-    fn visit_expr(&mut self, ex: &'tcx Expr<'tcx>) {
-        if let ExprKind::Yield(_, YieldSource::Await { .. }) = ex.kind {
-            self.found_await = true;
-        }
-        walk_expr(self, ex);
-    }
-
-    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-        NestedVisitorMap::OnlyBodies(self.cx.tcx.hir())
-    }
-}
-
-impl<'tcx> LateLintPass<'tcx> for UnnecessaryAsync {
-    fn check_item(&mut self, _: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
-        if let ItemKind::Trait(..) = item.kind {
-            return;
-        }
-    }
-    fn check_fn(
-        &mut self,
-        cx: &LateContext<'tcx>,
-        fn_kind: FnKind<'tcx>,
-        fn_decl: &'tcx FnDecl<'tcx>,
-        body: &Body<'tcx>,
-        span: Span,
-        hir_id: HirId,
-    ) {
-        if let FnKind::ItemFn(_, _, FnHeader { asyncness, .. }, _) = &fn_kind {
-            if matches!(asyncness, IsAsync::Async) {
-                let mut visitor = AsyncFnVisitor { cx, found_await: false };
-                walk_fn(&mut visitor, fn_kind, fn_decl, body.id(), span, hir_id);
-                if !visitor.found_await {
-                    span_lint_and_help(
-                        cx,
-                        UNNECESSARY_ASYNC,
-                        span,
-                        "unnecessary `async` for function with no await statements",
-                        None,
-                        "consider removing the `async` from this function",
-                    );
-                }
-            }
-        }
-    }
-}
diff --git a/clippy_lints/src/unused_async.rs b/clippy_lints/src/unused_async.rs
new file mode 100644
index 00000000000..18ee07d3a95
--- /dev/null
+++ b/clippy_lints/src/unused_async.rs
@@ -0,0 +1,92 @@
+use clippy_utils::diagnostics::span_lint_and_help;
+use rustc_hir::intravisit::{walk_expr, walk_fn, FnKind, NestedVisitorMap, Visitor};
+use rustc_hir::{Body, Expr, ExprKind, FnDecl, FnHeader, HirId, IsAsync, Item, ItemKind, YieldSource};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::hir::map::Map;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::Span;
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for functions that are declared `async` but have no `.await`s inside of them.
+    ///
+    /// **Why is this bad?** Async functions with no async code create overhead, both mentally and computationally.
+    /// Callers of async methods either need to be calling from an async function themselves or run it on an executor, both of which
+    /// causes runtime overhead and hassle for the caller.
+    ///
+    /// **Known problems:** None
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// // Bad
+    /// async fn get_random_number() -> i64 {
+    ///     4 // Chosen by fair dice roll. Guaranteed to be random.
+    /// }
+    /// let number_future = get_random_number();
+    ///
+    /// // Good
+    /// fn get_random_number_improved() -> i64 {
+    ///     4 // Chosen by fair dice roll. Guaranteed to be random.
+    /// }
+    /// let number_future = async { get_random_number_improved() };
+    /// ```
+    pub UNUSED_ASYNC,
+    pedantic,
+    "finds async functions with no await statements"
+}
+
+declare_lint_pass!(UnusedAsync => [UNUSED_ASYNC]);
+
+struct AsyncFnVisitor<'a, 'tcx> {
+    cx: &'a LateContext<'tcx>,
+    found_await: bool,
+}
+
+impl<'a, 'tcx> Visitor<'tcx> for AsyncFnVisitor<'a, 'tcx> {
+    type Map = Map<'tcx>;
+
+    fn visit_expr(&mut self, ex: &'tcx Expr<'tcx>) {
+        if let ExprKind::Yield(_, YieldSource::Await { .. }) = ex.kind {
+            self.found_await = true;
+        }
+        walk_expr(self, ex);
+    }
+
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::OnlyBodies(self.cx.tcx.hir())
+    }
+}
+
+impl<'tcx> LateLintPass<'tcx> for UnusedAsync {
+    fn check_item(&mut self, _: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
+        if let ItemKind::Trait(..) = item.kind {
+            return;
+        }
+    }
+    fn check_fn(
+        &mut self,
+        cx: &LateContext<'tcx>,
+        fn_kind: FnKind<'tcx>,
+        fn_decl: &'tcx FnDecl<'tcx>,
+        body: &Body<'tcx>,
+        span: Span,
+        hir_id: HirId,
+    ) {
+        if let FnKind::ItemFn(_, _, FnHeader { asyncness, .. }, _) = &fn_kind {
+            if matches!(asyncness, IsAsync::Async) {
+                let mut visitor = AsyncFnVisitor { cx, found_await: false };
+                walk_fn(&mut visitor, fn_kind, fn_decl, body.id(), span, hir_id);
+                if !visitor.found_await {
+                    span_lint_and_help(
+                        cx,
+                        UNUSED_ASYNC,
+                        span,
+                        "unused `async` for function with no await statements",
+                        None,
+                        "consider removing the `async` from this function",
+                    );
+                }
+            }
+        }
+    }
+}
diff --git a/tests/ui/unnecessary_async.rs b/tests/ui/unnecessary_async.rs
deleted file mode 100644
index 7d63083b13e..00000000000
--- a/tests/ui/unnecessary_async.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-// edition:2018
-#![warn(clippy::unnecessary_async)]
-
-async fn foo() -> i32 {
-    4
-}
-
-async fn bar() -> i32 {
-    foo().await
-}
-
-fn main() {
-    foo();
-    bar();
-}
diff --git a/tests/ui/unnecessary_async.stderr b/tests/ui/unnecessary_async.stderr
deleted file mode 100644
index 5542580e45d..00000000000
--- a/tests/ui/unnecessary_async.stderr
+++ /dev/null
@@ -1,13 +0,0 @@
-error: unnecessary `async` for function with no await statements
-  --> $DIR/unnecessary_async.rs:4:1
-   |
-LL | / async fn foo() -> i32 {
-LL | |     4
-LL | | }
-   | |_^
-   |
-   = note: `-D clippy::unnecessary-async` implied by `-D warnings`
-   = help: consider removing the `async` from this function
-
-error: aborting due to previous error
-
diff --git a/tests/ui/unused_async.rs b/tests/ui/unused_async.rs
new file mode 100644
index 00000000000..4f4203f5fdb
--- /dev/null
+++ b/tests/ui/unused_async.rs
@@ -0,0 +1,15 @@
+// edition:2018
+#![warn(clippy::unused_async)]
+
+async fn foo() -> i32 {
+    4
+}
+
+async fn bar() -> i32 {
+    foo().await
+}
+
+fn main() {
+    foo();
+    bar();
+}
diff --git a/tests/ui/unused_async.stderr b/tests/ui/unused_async.stderr
new file mode 100644
index 00000000000..8b834d205b1
--- /dev/null
+++ b/tests/ui/unused_async.stderr
@@ -0,0 +1,13 @@
+error: unused `async` for function with no await statements
+  --> $DIR/unused_async.rs:4:1
+   |
+LL | / async fn foo() -> i32 {
+LL | |     4
+LL | | }
+   | |_^
+   |
+   = note: `-D clippy::unused-async` implied by `-D warnings`
+   = help: consider removing the `async` from this function
+
+error: aborting due to previous error
+
-- 
cgit 1.4.1-3-g733a5


From 75ef9dc708e669bccbc18c3be4873c613058ef30 Mon Sep 17 00:00:00 2001
From: Jackson Lewis <jackson.lewis@agilebits.com>
Date: Fri, 14 May 2021 17:12:25 -0700
Subject: update_lints

---
 CHANGELOG.md            | 1 +
 clippy_lints/src/lib.rs | 6 +++---
 2 files changed, 4 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 204d56e2a98..c922cc7e763 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2538,6 +2538,7 @@ Released 2018-09-13
 [`unsound_collection_transmute`]: https://rust-lang.github.io/rust-clippy/master/index.html#unsound_collection_transmute
 [`unstable_as_mut_slice`]: https://rust-lang.github.io/rust-clippy/master/index.html#unstable_as_mut_slice
 [`unstable_as_slice`]: https://rust-lang.github.io/rust-clippy/master/index.html#unstable_as_slice
+[`unused_async`]: https://rust-lang.github.io/rust-clippy/master/index.html#unused_async
 [`unused_collect`]: https://rust-lang.github.io/rust-clippy/master/index.html#unused_collect
 [`unused_io_amount`]: https://rust-lang.github.io/rust-clippy/master/index.html#unused_io_amount
 [`unused_self`]: https://rust-lang.github.io/rust-clippy/master/index.html#unused_self
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 52e64d6a48f..2f5642f24f2 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -360,9 +360,9 @@ mod unnamed_address;
 mod unnecessary_self_imports;
 mod unnecessary_sort_by;
 mod unnecessary_wraps;
-mod unused_async;
 mod unnested_or_patterns;
 mod unsafe_removed_from_name;
+mod unused_async;
 mod unused_io_amount;
 mod unused_self;
 mod unused_unit;
@@ -955,12 +955,12 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         unit_types::UNIT_CMP,
         unnamed_address::FN_ADDRESS_COMPARISONS,
         unnamed_address::VTABLE_ADDRESS_COMPARISONS,
-        unused_async::UNUSED_ASYNC,
         unnecessary_self_imports::UNNECESSARY_SELF_IMPORTS,
         unnecessary_sort_by::UNNECESSARY_SORT_BY,
         unnecessary_wraps::UNNECESSARY_WRAPS,
         unnested_or_patterns::UNNESTED_OR_PATTERNS,
         unsafe_removed_from_name::UNSAFE_REMOVED_FROM_NAME,
+        unused_async::UNUSED_ASYNC,
         unused_io_amount::UNUSED_IO_AMOUNT,
         unused_self::UNUSED_SELF,
         unused_unit::UNUSED_UNIT,
@@ -1415,9 +1415,9 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(unicode::NON_ASCII_LITERAL),
         LintId::of(unicode::UNICODE_NOT_NFC),
         LintId::of(unit_types::LET_UNIT_VALUE),
-        LintId::of(unused_async::UNUSED_ASYNC),
         LintId::of(unnecessary_wraps::UNNECESSARY_WRAPS),
         LintId::of(unnested_or_patterns::UNNESTED_OR_PATTERNS),
+        LintId::of(unused_async::UNUSED_ASYNC),
         LintId::of(unused_self::UNUSED_SELF),
         LintId::of(wildcard_imports::ENUM_GLOB_USE),
         LintId::of(wildcard_imports::WILDCARD_IMPORTS),
-- 
cgit 1.4.1-3-g733a5


From f810c11d3c44af357ad7af6cf9fc9ab582591c01 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Sat, 15 May 2021 19:00:49 +0200
Subject: Applying PR suggestions and cleaning up

---
 clippy_lints/src/utils/conf.rs                     | 27 +++++-----
 .../src/utils/internal_lints/metadata_collector.rs | 61 +++++++++-------------
 2 files changed, 39 insertions(+), 49 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 25163bb9f37..fd2dddb3b96 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -92,25 +92,26 @@ macro_rules! define_Conf {
 
         #[cfg(feature = "metadata-collector-lint")]
         pub mod metadata {
-            use crate::utils::internal_lints::metadata_collector::ClippyConfigurationBasicInfo;
+            use crate::utils::internal_lints::metadata_collector::ClippyConfiguration;
 
-            pub(crate) fn get_configuration_metadata() -> Vec<ClippyConfigurationBasicInfo> {
+            macro_rules! wrap_option {
+                () => (None);
+                ($x:literal) => (Some($x));
+            }
+
+            pub(crate) fn get_configuration_metadata() -> Vec<ClippyConfiguration> {
                 vec![
                     $(
                         {
-                            #[allow(unused_mut, unused_assignments)]
-                            let mut deprecation_reason = None;
+                            let deprecation_reason = wrap_option!($($dep)?);
 
-                            // only set if a deprecation reason was set
-                            $(deprecation_reason = Some(stringify!($dep));)?
-
-                            ClippyConfigurationBasicInfo {
-                                name: stringify!($name),
-                                config_type: stringify!($ty),
-                                default: stringify!($default),
-                                doc_comment: $doc,
+                            ClippyConfiguration::new(
+                                stringify!($name),
+                                stringify!($ty),
+                                format!("{:?}", super::defaults::$name()),
+                                $doc,
                                 deprecation_reason,
-                            }
+                            )
                         },
                     )+
                 ]
diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index bd0de8ad034..b7c86ae6e18 100644
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -149,7 +149,8 @@ impl MetadataCollector {
     fn get_lint_configs(&self, lint_name: &str) -> Option<String> {
         self.config
             .iter()
-            .filter_map(|x| x.lints.iter().any(|x| x == lint_name).then(|| format!("{}", x)))
+            .filter(|config| config.lints.iter().any(|lint| lint == lint_name))
+            .map(ToString::to_string)
             .reduce(|acc, x| acc + &x)
             .map(|configurations| format!(CONFIGURATION_SECTION_TEMPLATE!(), configurations = configurations))
     }
@@ -261,52 +262,40 @@ impl Serialize for ApplicabilityInfo {
 // ==================================================================
 // Configuration
 // ==================================================================
-#[derive(Debug)]
-pub(crate) struct ClippyConfigurationBasicInfo {
-    pub name: &'static str,
-    pub config_type: &'static str,
-    pub default: &'static str,
-    pub doc_comment: &'static str,
-    pub deprecation_reason: Option<&'static str>,
-}
-
 #[derive(Debug, Clone, Default)]
-struct ClippyConfiguration {
+pub struct ClippyConfiguration {
     name: String,
-    lints: Vec<String>,
-    doc: String,
     config_type: &'static str,
     default: String,
+    lints: Vec<String>,
+    doc: String,
     deprecation_reason: Option<&'static str>,
 }
 
-fn collect_configs() -> Vec<ClippyConfiguration> {
-    let cons = crate::utils::conf::metadata::get_configuration_metadata();
-    cons.iter()
-        .map(move |x| {
-            let (lints, doc) = parse_config_field_doc(x.doc_comment)
-                .unwrap_or_else(|| (vec![], "[ERROR] MALFORMED DOC COMMENT".to_string()));
-
-            ClippyConfiguration {
-                name: to_kebab(x.name),
-                lints,
-                doc,
-                config_type: x.config_type,
-                default: clarify_default(x.default),
-                deprecation_reason: x.deprecation_reason,
-            }
-        })
-        .collect()
-}
+impl ClippyConfiguration {
+    pub fn new(
+        name: &'static str,
+        config_type: &'static str,
+        default: String,
+        doc_comment: &'static str,
+        deprecation_reason: Option<&'static str>,
+    ) -> Self {
+        let (lints, doc) = parse_config_field_doc(doc_comment)
+            .unwrap_or_else(|| (vec![], "[ERROR] MALFORMED DOC COMMENT".to_string()));
 
-fn clarify_default(default: &'static str) -> String {
-    if let Some((_start, init)) = default.split_once('[') {
-        if let Some((init, _end)) = init.split_once(']') {
-            return format!("[{}]", init);
+        Self {
+            name: to_kebab(name),
+            lints,
+            doc,
+            config_type,
+            default,
+            deprecation_reason,
         }
     }
+}
 
-    default.to_string()
+fn collect_configs() -> Vec<ClippyConfiguration> {
+    crate::utils::conf::metadata::get_configuration_metadata()
 }
 
 /// This parses the field documentation of the config struct.
-- 
cgit 1.4.1-3-g733a5


From ebf065e5172227a99743f4032c5bfff80d5630e6 Mon Sep 17 00:00:00 2001
From: Takayuki Nakata <f.seasons017@gmail.com>
Date: Mon, 17 May 2021 22:18:50 +0900
Subject: Fix a `manual_unwrap_or` FP with deref coercion

---
 clippy_lints/src/manual_unwrap_or.rs | 3 +++
 tests/ui/manual_unwrap_or.fixed      | 8 ++++++++
 tests/ui/manual_unwrap_or.rs         | 8 ++++++++
 3 files changed, 19 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_unwrap_or.rs b/clippy_lints/src/manual_unwrap_or.rs
index 520162559e5..cf183d4c16f 100644
--- a/clippy_lints/src/manual_unwrap_or.rs
+++ b/clippy_lints/src/manual_unwrap_or.rs
@@ -11,6 +11,7 @@ use rustc_hir::{Arm, Expr, ExprKind, PatKind};
 use rustc_lint::LintContext;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::lint::in_external_macro;
+use rustc_middle::ty::adjustment::Adjust;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::sym;
 
@@ -87,6 +88,8 @@ fn lint_manual_unwrap_or<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
             if let PatKind::Binding(_, binding_hir_id, ..) = unwrap_pat.kind;
             if path_to_local_id(unwrap_arm.body, binding_hir_id);
             if !contains_return_break_continue_macro(or_arm.body);
+            if !cx.typeck_results().expr_adjustments(unwrap_arm.body).iter()
+                .any(|a| matches!(a.kind, Adjust::Deref(Some(..))));
             then {
                 Some(or_arm)
             } else {
diff --git a/tests/ui/manual_unwrap_or.fixed b/tests/ui/manual_unwrap_or.fixed
index e7a29596b73..1efecb0ba12 100644
--- a/tests/ui/manual_unwrap_or.fixed
+++ b/tests/ui/manual_unwrap_or.fixed
@@ -163,4 +163,12 @@ mod issue6965 {
     }
 }
 
+use std::rc::Rc;
+fn format_name(name: Option<&Rc<str>>) -> &str {
+    match name {
+        None => "<anon>",
+        Some(name) => name,
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/manual_unwrap_or.rs b/tests/ui/manual_unwrap_or.rs
index 66006b6c616..95d585ad18a 100644
--- a/tests/ui/manual_unwrap_or.rs
+++ b/tests/ui/manual_unwrap_or.rs
@@ -205,4 +205,12 @@ mod issue6965 {
     }
 }
 
+use std::rc::Rc;
+fn format_name(name: Option<&Rc<str>>) -> &str {
+    match name {
+        None => "<anon>",
+        Some(name) => name,
+    }
+}
+
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 0dcde712246d417c9cdfedb73b518edaa2b8c60a Mon Sep 17 00:00:00 2001
From: Arya Kumar <arkumar@umich.edu>
Date: Mon, 17 May 2021 15:00:15 +0000
Subject: Fix missing variable init in lint example

---
 clippy_lints/src/needless_bitwise_bool.rs | 2 ++
 1 file changed, 2 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/needless_bitwise_bool.rs b/clippy_lints/src/needless_bitwise_bool.rs
index 95febf4a2ad..b30bfbd4294 100644
--- a/clippy_lints/src/needless_bitwise_bool.rs
+++ b/clippy_lints/src/needless_bitwise_bool.rs
@@ -24,10 +24,12 @@ declare_clippy_lint! {
     /// **Example:**
     ///
     /// ```rust
+    /// let (x,y) = (true, false);
     /// if x & !y {} // where both x and y are booleans
     /// ```
     /// Use instead:
     /// ```rust
+    /// let (x,y) = (true, false);
     /// if x && !y {}
     /// ```
     pub NEEDLESS_BITWISE_BOOL,
-- 
cgit 1.4.1-3-g733a5


From 2fb35ce4f0ea8d33bbe207c8a1c8822ebb90c813 Mon Sep 17 00:00:00 2001
From: ThibsG <thibsg@pm.me>
Date: Thu, 13 May 2021 21:40:20 +0200
Subject: Add generic args for comparison in `use_self` and
 `useless_conversion` lints

---
 clippy_lints/src/use_self.rs           | 10 +++++-----
 clippy_lints/src/useless_conversion.rs | 15 ++++++++-------
 clippy_utils/src/ty.rs                 | 24 ++++++++++++++++++++++++
 tests/ui/use_self.fixed                | 30 ++++++++++++++++++++++++++++++
 tests/ui/use_self.rs                   | 30 ++++++++++++++++++++++++++++++
 tests/ui/use_self.stderr               |  8 +++++++-
 tests/ui/useless_conversion.fixed      | 19 +++++++++++++++++++
 tests/ui/useless_conversion.rs         | 19 +++++++++++++++++++
 tests/ui/useless_conversion.stderr     | 20 +++++++++++++++++++-
 9 files changed, 161 insertions(+), 14 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/use_self.rs b/clippy_lints/src/use_self.rs
index aa4d16633ff..2ad6fa77f48 100644
--- a/clippy_lints/src/use_self.rs
+++ b/clippy_lints/src/use_self.rs
@@ -1,12 +1,12 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_opt;
+use clippy_utils::ty::same_type_and_consts;
 use clippy_utils::{in_macro, meets_msrv, msrvs};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
-use rustc_hir as hir;
-use rustc_hir::def::DefKind;
 use rustc_hir::{
-    def,
+    self as hir,
+    def::{self, DefKind},
     def_id::LocalDefId,
     intravisit::{walk_ty, NestedVisitorMap, Visitor},
     Expr, ExprKind, FnRetTy, FnSig, GenericArg, HirId, Impl, ImplItemKind, Item, ItemKind, Node, Path, PathSegment,
@@ -14,7 +14,7 @@ use rustc_hir::{
 };
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::hir::map::Map;
-use rustc_middle::ty::{AssocKind, Ty, TyS};
+use rustc_middle::ty::{AssocKind, Ty};
 use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::{BytePos, Span};
@@ -459,7 +459,7 @@ fn in_impl(cx: &LateContext<'tcx>, hir_ty: &hir::Ty<'_>) -> bool {
 
 fn should_lint_ty(hir_ty: &hir::Ty<'_>, ty: Ty<'_>, self_ty: Ty<'_>) -> bool {
     if_chain! {
-        if TyS::same_type(ty, self_ty);
+        if same_type_and_consts(ty, self_ty);
         if let TyKind::Path(QPath::Resolved(_, path)) = hir_ty.kind;
         then {
             !matches!(path.res, def::Res::SelfTy(..))
diff --git a/clippy_lints/src/useless_conversion.rs b/clippy_lints/src/useless_conversion.rs
index 7edb280be73..2be99fb761b 100644
--- a/clippy_lints/src/useless_conversion.rs
+++ b/clippy_lints/src/useless_conversion.rs
@@ -1,13 +1,13 @@
 use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg};
 use clippy_utils::source::{snippet, snippet_with_macro_callsite};
 use clippy_utils::sugg::Sugg;
-use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::ty::{is_type_diagnostic_item, same_type_and_consts};
 use clippy_utils::{get_parent_expr, match_def_path, match_trait_method, paths};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, HirId, MatchSource};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty::{self, TyS};
+use rustc_middle::ty;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::sym;
 
@@ -67,7 +67,7 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
                 if match_trait_method(cx, e, &paths::INTO) && &*name.ident.as_str() == "into" {
                     let a = cx.typeck_results().expr_ty(e);
                     let b = cx.typeck_results().expr_ty(&args[0]);
-                    if TyS::same_type(a, b) {
+                    if same_type_and_consts(a, b) {
                         let sugg = snippet_with_macro_callsite(cx, args[0].span, "<expr>").to_string();
                         span_lint_and_sugg(
                             cx,
@@ -90,7 +90,7 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
                     }
                     let a = cx.typeck_results().expr_ty(e);
                     let b = cx.typeck_results().expr_ty(&args[0]);
-                    if TyS::same_type(a, b) {
+                    if same_type_and_consts(a, b) {
                         let sugg = snippet(cx, args[0].span, "<expr>").into_owned();
                         span_lint_and_sugg(
                             cx,
@@ -110,7 +110,8 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
                     if is_type_diagnostic_item(cx, a, sym::result_type);
                     if let ty::Adt(_, substs) = a.kind();
                     if let Some(a_type) = substs.types().next();
-                    if TyS::same_type(a_type, b);
+                    if same_type_and_consts(a_type, b);
+
                     then {
                         span_lint_and_help(
                             cx,
@@ -137,7 +138,7 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
                             if is_type_diagnostic_item(cx, a, sym::result_type);
                             if let ty::Adt(_, substs) = a.kind();
                             if let Some(a_type) = substs.types().next();
-                            if TyS::same_type(a_type, b);
+                            if same_type_and_consts(a_type, b);
 
                             then {
                                 let hint = format!("consider removing `{}()`", snippet(cx, path.span, "TryFrom::try_from"));
@@ -154,7 +155,7 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
 
                         if_chain! {
                             if match_def_path(cx, def_id, &paths::FROM_FROM);
-                            if TyS::same_type(a, b);
+                            if same_type_and_consts(a, b);
 
                             then {
                                 let sugg = Sugg::hir_with_macro_callsite(cx, &args[0], "<expr>").maybe_par();
diff --git a/clippy_utils/src/ty.rs b/clippy_utils/src/ty.rs
index 64a80f2554f..e1f8aff3740 100644
--- a/clippy_utils/src/ty.rs
+++ b/clippy_utils/src/ty.rs
@@ -322,3 +322,27 @@ pub fn walk_ptrs_ty_depth(ty: Ty<'_>) -> (Ty<'_>, usize) {
     }
     inner(ty, 0)
 }
+
+/// Returns `true` if types `a` and `b` are same types having same `Const` generic args,
+/// otherwise returns `false`
+pub fn same_type_and_consts(a: Ty<'tcx>, b: Ty<'tcx>) -> bool {
+    match (&a.kind(), &b.kind()) {
+        (&ty::Adt(did_a, substs_a), &ty::Adt(did_b, substs_b)) => {
+            if did_a != did_b {
+                return false;
+            }
+
+            substs_a
+                .iter()
+                .zip(substs_b.iter())
+                .all(|(arg_a, arg_b)| match (arg_a.unpack(), arg_b.unpack()) {
+                    (GenericArgKind::Const(inner_a), GenericArgKind::Const(inner_b)) => inner_a == inner_b,
+                    (GenericArgKind::Type(type_a), GenericArgKind::Type(type_b)) => {
+                        same_type_and_consts(type_a, type_b)
+                    },
+                    _ => true,
+                })
+        },
+        _ => a == b,
+    }
+}
diff --git a/tests/ui/use_self.fixed b/tests/ui/use_self.fixed
index 1282befdfb3..631da6fe066 100644
--- a/tests/ui/use_self.fixed
+++ b/tests/ui/use_self.fixed
@@ -462,3 +462,33 @@ mod issue6818 {
         a: i32,
     }
 }
+
+mod issue7206 {
+    struct MyStruct<const C: char>;
+    impl From<MyStruct<'a'>> for MyStruct<'b'> {
+        fn from(_s: MyStruct<'a'>) -> Self {
+            Self
+        }
+    }
+
+    // keep linting non-`Const` generic args
+    struct S<'a> {
+        inner: &'a str,
+    }
+
+    struct S2<T> {
+        inner: T,
+    }
+
+    impl<T> S2<T> {
+        fn new() -> Self {
+            unimplemented!();
+        }
+    }
+
+    impl<'a> S2<S<'a>> {
+        fn new_again() -> Self {
+            Self::new()
+        }
+    }
+}
diff --git a/tests/ui/use_self.rs b/tests/ui/use_self.rs
index 7aaac7b2414..7a10d755faa 100644
--- a/tests/ui/use_self.rs
+++ b/tests/ui/use_self.rs
@@ -462,3 +462,33 @@ mod issue6818 {
         a: i32,
     }
 }
+
+mod issue7206 {
+    struct MyStruct<const C: char>;
+    impl From<MyStruct<'a'>> for MyStruct<'b'> {
+        fn from(_s: MyStruct<'a'>) -> Self {
+            Self
+        }
+    }
+
+    // keep linting non-`Const` generic args
+    struct S<'a> {
+        inner: &'a str,
+    }
+
+    struct S2<T> {
+        inner: T,
+    }
+
+    impl<T> S2<T> {
+        fn new() -> Self {
+            unimplemented!();
+        }
+    }
+
+    impl<'a> S2<S<'a>> {
+        fn new_again() -> Self {
+            S2::new()
+        }
+    }
+}
diff --git a/tests/ui/use_self.stderr b/tests/ui/use_self.stderr
index a32a9b9157d..cf6222c9b45 100644
--- a/tests/ui/use_self.stderr
+++ b/tests/ui/use_self.stderr
@@ -162,5 +162,11 @@ error: unnecessary structure name repetition
 LL |             A::new::<submod::B>(submod::B {})
    |             ^ help: use the applicable keyword: `Self`
 
-error: aborting due to 27 previous errors
+error: unnecessary structure name repetition
+  --> $DIR/use_self.rs:491:13
+   |
+LL |             S2::new()
+   |             ^^ help: use the applicable keyword: `Self`
+
+error: aborting due to 28 previous errors
 
diff --git a/tests/ui/useless_conversion.fixed b/tests/ui/useless_conversion.fixed
index 03977de9455..76aa82068d6 100644
--- a/tests/ui/useless_conversion.fixed
+++ b/tests/ui/useless_conversion.fixed
@@ -70,4 +70,23 @@ fn main() {
     let a: i32 = 1;
     let b: i32 = 1;
     let _ = (a + b) * 3;
+
+    // see #7205
+    let s: Foo<'a'> = Foo;
+    let _: Foo<'b'> = s.into();
+    let s2: Foo<'a'> = Foo;
+    let _: Foo<'a'> = s2;
+    let s3: Foo<'a'> = Foo;
+    let _ = s3;
+    let s4: Foo<'a'> = Foo;
+    let _ = vec![s4, s4, s4].into_iter();
+}
+
+#[derive(Copy, Clone)]
+struct Foo<const C: char>;
+
+impl From<Foo<'a'>> for Foo<'b'> {
+    fn from(_s: Foo<'a'>) -> Self {
+        Foo
+    }
 }
diff --git a/tests/ui/useless_conversion.rs b/tests/ui/useless_conversion.rs
index f6e094c1661..ccee7abb404 100644
--- a/tests/ui/useless_conversion.rs
+++ b/tests/ui/useless_conversion.rs
@@ -70,4 +70,23 @@ fn main() {
     let a: i32 = 1;
     let b: i32 = 1;
     let _ = i32::from(a + b) * 3;
+
+    // see #7205
+    let s: Foo<'a'> = Foo;
+    let _: Foo<'b'> = s.into();
+    let s2: Foo<'a'> = Foo;
+    let _: Foo<'a'> = s2.into();
+    let s3: Foo<'a'> = Foo;
+    let _ = Foo::<'a'>::from(s3);
+    let s4: Foo<'a'> = Foo;
+    let _ = vec![s4, s4, s4].into_iter().into_iter();
+}
+
+#[derive(Copy, Clone)]
+struct Foo<const C: char>;
+
+impl From<Foo<'a'>> for Foo<'b'> {
+    fn from(_s: Foo<'a'>) -> Self {
+        Foo
+    }
 }
diff --git a/tests/ui/useless_conversion.stderr b/tests/ui/useless_conversion.stderr
index 26a33595031..e6760f700f3 100644
--- a/tests/ui/useless_conversion.stderr
+++ b/tests/ui/useless_conversion.stderr
@@ -70,5 +70,23 @@ error: useless conversion to the same type: `i32`
 LL |     let _ = i32::from(a + b) * 3;
    |             ^^^^^^^^^^^^^^^^ help: consider removing `i32::from()`: `(a + b)`
 
-error: aborting due to 11 previous errors
+error: useless conversion to the same type: `Foo<'a'>`
+  --> $DIR/useless_conversion.rs:78:23
+   |
+LL |     let _: Foo<'a'> = s2.into();
+   |                       ^^^^^^^^^ help: consider removing `.into()`: `s2`
+
+error: useless conversion to the same type: `Foo<'a'>`
+  --> $DIR/useless_conversion.rs:80:13
+   |
+LL |     let _ = Foo::<'a'>::from(s3);
+   |             ^^^^^^^^^^^^^^^^^^^^ help: consider removing `Foo::<'a'>::from()`: `s3`
+
+error: useless conversion to the same type: `std::vec::IntoIter<Foo<'a'>>`
+  --> $DIR/useless_conversion.rs:82:13
+   |
+LL |     let _ = vec![s4, s4, s4].into_iter().into_iter();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `vec![s4, s4, s4].into_iter()`
+
+error: aborting due to 14 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From b2270e1f459cbeb1b6f4281d230990a40fe993d8 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Sun, 16 May 2021 17:40:29 -0500
Subject: Simplify manual_unwrap_or

---
 clippy_lints/src/manual_unwrap_or.rs | 23 ++++-------------------
 1 file changed, 4 insertions(+), 19 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_unwrap_or.rs b/clippy_lints/src/manual_unwrap_or.rs
index cf183d4c16f..d7e8d180f7e 100644
--- a/clippy_lints/src/manual_unwrap_or.rs
+++ b/clippy_lints/src/manual_unwrap_or.rs
@@ -54,21 +54,6 @@ impl LateLintPass<'_> for ManualUnwrapOr {
     }
 }
 
-#[derive(Copy, Clone)]
-enum Case {
-    Option,
-    Result,
-}
-
-impl Case {
-    fn unwrap_fn_path(&self) -> &str {
-        match self {
-            Case::Option => "Option::unwrap_or",
-            Case::Result => "Result::unwrap_or",
-        }
-    }
-}
-
 fn lint_manual_unwrap_or<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
     fn applicable_or_arm<'a>(cx: &LateContext<'_>, arms: &'a [Arm<'a>]) -> Option<&'a Arm<'a>> {
         if_chain! {
@@ -101,10 +86,10 @@ fn lint_manual_unwrap_or<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
     if_chain! {
         if let ExprKind::Match(scrutinee, match_arms, _) = expr.kind;
         let ty = cx.typeck_results().expr_ty(scrutinee);
-        if let Some(case) = if is_type_diagnostic_item(cx, ty, sym::option_type) {
-            Some(Case::Option)
+        if let Some(ty_name) = if is_type_diagnostic_item(cx, ty, sym::option_type) {
+            Some("Option")
         } else if is_type_diagnostic_item(cx, ty, sym::result_type) {
-            Some(Case::Result)
+            Some("Result")
         } else {
             None
         };
@@ -127,7 +112,7 @@ fn lint_manual_unwrap_or<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
             span_lint_and_sugg(
                 cx,
                 MANUAL_UNWRAP_OR, expr.span,
-                &format!("this pattern reimplements `{}`", case.unwrap_fn_path()),
+                &format!("this pattern reimplements `{}::unwrap_or`", ty_name),
                 "replace with",
                 format!(
                     "{}.unwrap_or({})",
-- 
cgit 1.4.1-3-g733a5


From ca0f0002a4dd7a1572fc571483771a67d1d73a37 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Mon, 17 May 2021 14:02:42 -0500
Subject: Remove dead code after not linting else if let

---
 clippy_lints/src/option_if_let_else.rs | 45 +++-------------------------------
 1 file changed, 3 insertions(+), 42 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/option_if_let_else.rs b/clippy_lints/src/option_if_let_else.rs
index 2d98b275de7..b6af4175edf 100644
--- a/clippy_lints/src/option_if_let_else.rs
+++ b/clippy_lints/src/option_if_let_else.rs
@@ -2,7 +2,7 @@ use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::usage::contains_return_break_continue_macro;
-use clippy_utils::{eager_or_lazy, get_enclosing_block, in_macro, is_else_clause, is_lang_ctor};
+use clippy_utils::{eager_or_lazy, in_macro, is_else_clause, is_lang_ctor};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::LangItem::OptionSome;
@@ -81,7 +81,6 @@ struct OptionIfLetElseOccurence {
     method_sugg: String,
     some_expr: String,
     none_expr: String,
-    wrap_braces: bool,
 }
 
 /// Extracts the body of a given arm. If the arm contains only an expression,
@@ -106,37 +105,6 @@ fn extract_body_from_arm<'a>(arm: &'a Arm<'a>) -> Option<&'a Expr<'a>> {
     }
 }
 
-/// If this is the else body of an if/else expression, then we need to wrap
-/// it in curly braces. Otherwise, we don't.
-fn should_wrap_in_braces(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-    get_enclosing_block(cx, expr.hir_id).map_or(false, |parent| {
-        let mut should_wrap = false;
-
-        if let Some(Expr {
-            kind:
-                ExprKind::Match(
-                    _,
-                    arms,
-                    MatchSource::IfLetDesugar {
-                        contains_else_clause: true,
-                    },
-                ),
-            ..
-        }) = parent.expr
-        {
-            should_wrap = expr.hir_id == arms[1].body.hir_id;
-        } else if let Some(Expr {
-            kind: ExprKind::If(_, _, Some(else_clause)),
-            ..
-        }) = parent.expr
-        {
-            should_wrap = expr.hir_id == else_clause.hir_id;
-        }
-
-        should_wrap
-    })
-}
-
 fn format_option_in_sugg(cx: &LateContext<'_>, cond_expr: &Expr<'_>, as_ref: bool, as_mut: bool) -> String {
     format!(
         "{}{}",
@@ -176,7 +144,6 @@ fn detect_option_if_let_else<'tcx>(
             let none_body = extract_body_from_arm(&arms[1])?;
             let method_sugg = if eager_or_lazy::is_eagerness_candidate(cx, none_body) { "map_or" } else { "map_or_else" };
             let capture_name = id.name.to_ident_string();
-            let wrap_braces = should_wrap_in_braces(cx, expr);
             let (as_ref, as_mut) = match &cond_expr.kind {
                 ExprKind::AddrOf(_, Mutability::Not, _) => (true, false),
                 ExprKind::AddrOf(_, Mutability::Mut, _) => (false, true),
@@ -192,7 +159,6 @@ fn detect_option_if_let_else<'tcx>(
                 method_sugg: method_sugg.to_string(),
                 some_expr: format!("|{}{}| {}", capture_mut, capture_name, Sugg::hir(cx, some_body, "..")),
                 none_expr: format!("{}{}", if method_sugg == "map_or" { "" } else { "|| " }, Sugg::hir(cx, none_body, "..")),
-                wrap_braces,
             })
         } else {
             None
@@ -210,13 +176,8 @@ impl<'tcx> LateLintPass<'tcx> for OptionIfLetElse {
                 format!("use Option::{} instead of an if let/else", detection.method_sugg).as_str(),
                 "try",
                 format!(
-                    "{}{}.{}({}, {}){}",
-                    if detection.wrap_braces { "{ " } else { "" },
-                    detection.option,
-                    detection.method_sugg,
-                    detection.none_expr,
-                    detection.some_expr,
-                    if detection.wrap_braces { " }" } else { "" },
+                    "{}.{}({}, {})",
+                    detection.option, detection.method_sugg, detection.none_expr, detection.some_expr,
                 ),
                 Applicability::MaybeIncorrect,
             );
-- 
cgit 1.4.1-3-g733a5


From 8356c485a99890339022a7afd99fc13ae09e5805 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Mon, 17 May 2021 14:20:26 -0500
Subject: Fix manual_unwrap_or FP deref reference

---
 clippy_lints/src/manual_unwrap_or.rs | 4 +---
 tests/ui/manual_unwrap_or.fixed      | 7 +++++++
 tests/ui/manual_unwrap_or.rs         | 7 +++++++
 3 files changed, 15 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_unwrap_or.rs b/clippy_lints/src/manual_unwrap_or.rs
index d7e8d180f7e..2f579edd6ad 100644
--- a/clippy_lints/src/manual_unwrap_or.rs
+++ b/clippy_lints/src/manual_unwrap_or.rs
@@ -11,7 +11,6 @@ use rustc_hir::{Arm, Expr, ExprKind, PatKind};
 use rustc_lint::LintContext;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::lint::in_external_macro;
-use rustc_middle::ty::adjustment::Adjust;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::sym;
 
@@ -72,9 +71,8 @@ fn lint_manual_unwrap_or<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
             if is_lang_ctor(cx, qpath, OptionSome) || is_lang_ctor(cx, qpath, ResultOk);
             if let PatKind::Binding(_, binding_hir_id, ..) = unwrap_pat.kind;
             if path_to_local_id(unwrap_arm.body, binding_hir_id);
+            if cx.typeck_results().expr_adjustments(unwrap_arm.body).is_empty();
             if !contains_return_break_continue_macro(or_arm.body);
-            if !cx.typeck_results().expr_adjustments(unwrap_arm.body).iter()
-                .any(|a| matches!(a.kind, Adjust::Deref(Some(..))));
             then {
                 Some(or_arm)
             } else {
diff --git a/tests/ui/manual_unwrap_or.fixed b/tests/ui/manual_unwrap_or.fixed
index 1efecb0ba12..3717f962745 100644
--- a/tests/ui/manual_unwrap_or.fixed
+++ b/tests/ui/manual_unwrap_or.fixed
@@ -171,4 +171,11 @@ fn format_name(name: Option<&Rc<str>>) -> &str {
     }
 }
 
+fn implicit_deref_ref() {
+    let _: &str = match Some(&"bye") {
+        None => "hi",
+        Some(s) => s,
+    };
+}
+
 fn main() {}
diff --git a/tests/ui/manual_unwrap_or.rs b/tests/ui/manual_unwrap_or.rs
index 95d585ad18a..989adde1f5b 100644
--- a/tests/ui/manual_unwrap_or.rs
+++ b/tests/ui/manual_unwrap_or.rs
@@ -213,4 +213,11 @@ fn format_name(name: Option<&Rc<str>>) -> &str {
     }
 }
 
+fn implicit_deref_ref() {
+    let _: &str = match Some(&"bye") {
+        None => "hi",
+        Some(s) => s,
+    };
+}
+
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From be540e65965d6ab0e3a04d6fa05651a701e6b8a4 Mon Sep 17 00:00:00 2001
From: "Bruno A. Muciño" <mucinoab@gmail.com>
Date: Mon, 17 May 2021 21:59:08 -0500
Subject: Remove powi, "square can be computed more efficiently"

powi(2) produces exactly the same native code as x * x
---
 clippy_lints/src/floating_point_arithmetic.rs | 12 +---------
 tests/ui/floating_point_powi.fixed            |  5 ++--
 tests/ui/floating_point_powi.rs               |  5 ++--
 tests/ui/floating_point_powi.stderr           | 34 +++++++++------------------
 4 files changed, 18 insertions(+), 38 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/floating_point_arithmetic.rs b/clippy_lints/src/floating_point_arithmetic.rs
index e0b687b0205..08f28cd54c5 100644
--- a/clippy_lints/src/floating_point_arithmetic.rs
+++ b/clippy_lints/src/floating_point_arithmetic.rs
@@ -323,7 +323,7 @@ fn check_powi(cx: &LateContext<'_>, expr: &Expr<'_>, args: &[Expr<'_>]) {
                         cx,
                         SUBOPTIMAL_FLOPS,
                         parent.span,
-                        "square can be computed more efficiently",
+                        "multiply and add expressions can be calculated more efficiently and accurately",
                         "consider using",
                         format!(
                             "{}.mul_add({}, {})",
@@ -337,16 +337,6 @@ fn check_powi(cx: &LateContext<'_>, expr: &Expr<'_>, args: &[Expr<'_>]) {
                     return;
                 }
             }
-
-            span_lint_and_sugg(
-                cx,
-                SUBOPTIMAL_FLOPS,
-                expr.span,
-                "square can be computed more efficiently",
-                "consider using",
-                format!("{} * {}", Sugg::hir(cx, &args[0], ".."), Sugg::hir(cx, &args[0], "..")),
-                Applicability::MachineApplicable,
-            );
         }
     }
 }
diff --git a/tests/ui/floating_point_powi.fixed b/tests/ui/floating_point_powi.fixed
index 56762400593..85f7c531e39 100644
--- a/tests/ui/floating_point_powi.fixed
+++ b/tests/ui/floating_point_powi.fixed
@@ -4,8 +4,6 @@
 fn main() {
     let one = 1;
     let x = 3f32;
-    let _ = x * x;
-    let _ = x * x;
 
     let y = 4f32;
     let _ = x.mul_add(x, y);
@@ -13,7 +11,10 @@ fn main() {
     let _ = x.mul_add(x, y).sqrt();
     let _ = y.mul_add(y, x).sqrt();
     // Cases where the lint shouldn't be applied
+    let _ = x.powi(2);
+    let _ = x.powi(1 + 1);
     let _ = x.powi(3);
+    let _ = x.powi(4) + y;
     let _ = x.powi(one + 1);
     let _ = (x.powi(2) + y.powi(2)).sqrt();
 }
diff --git a/tests/ui/floating_point_powi.rs b/tests/ui/floating_point_powi.rs
index 1f800e4628d..ece61d1bec4 100644
--- a/tests/ui/floating_point_powi.rs
+++ b/tests/ui/floating_point_powi.rs
@@ -4,8 +4,6 @@
 fn main() {
     let one = 1;
     let x = 3f32;
-    let _ = x.powi(2);
-    let _ = x.powi(1 + 1);
 
     let y = 4f32;
     let _ = x.powi(2) + y;
@@ -13,7 +11,10 @@ fn main() {
     let _ = (x.powi(2) + y).sqrt();
     let _ = (x + y.powi(2)).sqrt();
     // Cases where the lint shouldn't be applied
+    let _ = x.powi(2);
+    let _ = x.powi(1 + 1);
     let _ = x.powi(3);
+    let _ = x.powi(4) + y;
     let _ = x.powi(one + 1);
     let _ = (x.powi(2) + y.powi(2)).sqrt();
 }
diff --git a/tests/ui/floating_point_powi.stderr b/tests/ui/floating_point_powi.stderr
index d5a5f1bcca1..37d840988bb 100644
--- a/tests/ui/floating_point_powi.stderr
+++ b/tests/ui/floating_point_powi.stderr
@@ -1,40 +1,28 @@
-error: square can be computed more efficiently
-  --> $DIR/floating_point_powi.rs:7:13
-   |
-LL |     let _ = x.powi(2);
-   |             ^^^^^^^^^ help: consider using: `x * x`
-   |
-   = note: `-D clippy::suboptimal-flops` implied by `-D warnings`
-
-error: square can be computed more efficiently
-  --> $DIR/floating_point_powi.rs:8:13
-   |
-LL |     let _ = x.powi(1 + 1);
-   |             ^^^^^^^^^^^^^ help: consider using: `x * x`
-
-error: square can be computed more efficiently
-  --> $DIR/floating_point_powi.rs:11:13
+error: multiply and add expressions can be calculated more efficiently and accurately
+  --> $DIR/floating_point_powi.rs:9:13
    |
 LL |     let _ = x.powi(2) + y;
    |             ^^^^^^^^^^^^^ help: consider using: `x.mul_add(x, y)`
+   |
+   = note: `-D clippy::suboptimal-flops` implied by `-D warnings`
 
-error: square can be computed more efficiently
-  --> $DIR/floating_point_powi.rs:12:13
+error: multiply and add expressions can be calculated more efficiently and accurately
+  --> $DIR/floating_point_powi.rs:10:13
    |
 LL |     let _ = x + y.powi(2);
    |             ^^^^^^^^^^^^^ help: consider using: `y.mul_add(y, x)`
 
-error: square can be computed more efficiently
-  --> $DIR/floating_point_powi.rs:13:13
+error: multiply and add expressions can be calculated more efficiently and accurately
+  --> $DIR/floating_point_powi.rs:11:13
    |
 LL |     let _ = (x.powi(2) + y).sqrt();
    |             ^^^^^^^^^^^^^^^ help: consider using: `x.mul_add(x, y)`
 
-error: square can be computed more efficiently
-  --> $DIR/floating_point_powi.rs:14:13
+error: multiply and add expressions can be calculated more efficiently and accurately
+  --> $DIR/floating_point_powi.rs:12:13
    |
 LL |     let _ = (x + y.powi(2)).sqrt();
    |             ^^^^^^^^^^^^^^^ help: consider using: `y.mul_add(y, x)`
 
-error: aborting due to 6 previous errors
+error: aborting due to 4 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From a149ba26fa07b42b40f6e38f69ef74ecd756d68f Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Tue, 18 May 2021 10:51:59 -0400
Subject: Fix ICE in `implicit_return` async functions always return a value

---
 clippy_lints/src/implicit_return.rs |  6 +++++-
 tests/ui/crashes/ice-7231.rs        | 10 ++++++++++
 2 files changed, 15 insertions(+), 1 deletion(-)
 create mode 100644 tests/ui/crashes/ice-7231.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/implicit_return.rs b/clippy_lints/src/implicit_return.rs
index 30174fa2100..260a8f50157 100644
--- a/clippy_lints/src/implicit_return.rs
+++ b/clippy_lints/src/implicit_return.rs
@@ -147,7 +147,11 @@ fn lint_implicit_returns(
             visit_break_exprs(block, |break_expr, dest, sub_expr| {
                 if dest.target_id.ok() == Some(expr.hir_id) {
                     if call_site_span.is_none() && break_expr.span.ctxt() == ctxt {
-                        lint_break(cx, break_expr.span, sub_expr.unwrap().span);
+                        // At this point sub_expr can be `None` in async functions which either diverge, or return the
+                        // unit type.
+                        if let Some(sub_expr) = sub_expr {
+                            lint_break(cx, break_expr.span, sub_expr.span);
+                        }
                     } else {
                         // the break expression is from a macro call, add a return to the loop
                         add_return = true;
diff --git a/tests/ui/crashes/ice-7231.rs b/tests/ui/crashes/ice-7231.rs
new file mode 100644
index 00000000000..5595d8d1d62
--- /dev/null
+++ b/tests/ui/crashes/ice-7231.rs
@@ -0,0 +1,10 @@
+// edition:2018
+#![allow(clippy::never_loop)]
+
+async fn f() {
+    loop {
+        break;
+    }
+}
+
+fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 760f70312e6b894427cfc68a066bc1e87513337c Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Thu, 15 Apr 2021 12:20:43 -0400
Subject: Improve `multiple_inherent_impl` lint Treat different generic
 arguments as different types. Allow the lint to be ignored on the type
 definition, or any impl blocks.

---
 clippy_lints/src/inherent_impl.rs | 137 ++++++++++++++++++++++++++------------
 clippy_lints/src/lib.rs           |   2 +-
 tests/ui/impl.rs                  |  31 +++++++++
 tests/ui/impl.stderr              |  30 ++++++++-
 4 files changed, 154 insertions(+), 46 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/inherent_impl.rs b/clippy_lints/src/inherent_impl.rs
index c31013e49be..980bcc78f5d 100644
--- a/clippy_lints/src/inherent_impl.rs
+++ b/clippy_lints/src/inherent_impl.rs
@@ -1,12 +1,16 @@
 //! lint on inherent implementations
 
-use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::in_macro;
-use rustc_hir::def_id::DefIdMap;
-use rustc_hir::{def_id, Crate, Impl, Item, ItemKind};
+use clippy_utils::diagnostics::span_lint_and_note;
+use clippy_utils::{in_macro, is_allowed};
+use rustc_data_structures::fx::FxHashMap;
+use rustc_hir::{
+    def_id::{LocalDefId, LOCAL_CRATE},
+    Crate, Item, ItemKind, Node,
+};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::Span;
+use std::collections::hash_map::Entry;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for multiple inherent implementations of a struct
@@ -40,51 +44,96 @@ declare_clippy_lint! {
     "Multiple inherent impl that could be grouped"
 }
 
-#[allow(clippy::module_name_repetitions)]
-#[derive(Default)]
-pub struct MultipleInherentImpl {
-    impls: DefIdMap<Span>,
-}
-
-impl_lint_pass!(MultipleInherentImpl => [MULTIPLE_INHERENT_IMPL]);
+declare_lint_pass!(MultipleInherentImpl => [MULTIPLE_INHERENT_IMPL]);
 
 impl<'tcx> LateLintPass<'tcx> for MultipleInherentImpl {
-    fn check_item(&mut self, _: &LateContext<'tcx>, item: &'tcx Item<'_>) {
-        if let ItemKind::Impl(Impl {
-            ref generics,
-            of_trait: None,
-            ..
-        }) = item.kind
+    fn check_crate_post(&mut self, cx: &LateContext<'tcx>, _: &'tcx Crate<'_>) {
+        // Map from a type to it's first impl block. Needed to distinguish generic arguments.
+        // e.g. `Foo<Bar>` and `Foo<Baz>`
+        let mut type_map = FxHashMap::default();
+        // List of spans to lint. (lint_span, first_span)
+        let mut lint_spans = Vec::new();
+
+        for (_, impl_ids) in cx
+            .tcx
+            .crate_inherent_impls(LOCAL_CRATE)
+            .inherent_impls
+            .iter()
+            .filter(|(id, impls)| {
+                impls.len() > 1
+                    // Check for `#[allow]` on the type definition
+                    && !is_allowed(
+                        cx,
+                        MULTIPLE_INHERENT_IMPL,
+                        cx.tcx.hir().local_def_id_to_hir_id(id.expect_local()),
+                    )
+            })
         {
-            // Remember for each inherent implementation encountered its span and generics
-            // but filter out implementations that have generic params (type or lifetime)
-            // or are derived from a macro
-            if !in_macro(item.span) && generics.params.is_empty() {
-                self.impls.insert(item.def_id.to_def_id(), item.span);
+            for impl_id in impl_ids.iter().map(|id| id.expect_local()) {
+                match type_map.entry(cx.tcx.type_of(impl_id)) {
+                    Entry::Vacant(e) => {
+                        // Store the id for the first impl block of this type. The span is retrieved lazily.
+                        e.insert(IdOrSpan::Id(impl_id));
+                    },
+                    Entry::Occupied(mut e) => {
+                        if let Some(span) = get_impl_span(cx, impl_id) {
+                            let first_span = match *e.get() {
+                                IdOrSpan::Span(s) => s,
+                                IdOrSpan::Id(id) => {
+                                    if let Some(s) = get_impl_span(cx, id) {
+                                        // Remember the span of the first block.
+                                        *e.get_mut() = IdOrSpan::Span(s);
+                                        s
+                                    } else {
+                                        // The first impl block isn't considered by the lint. Replace it with the
+                                        // current one.
+                                        *e.get_mut() = IdOrSpan::Span(span);
+                                        continue;
+                                    }
+                                },
+                            };
+                            lint_spans.push((span, first_span));
+                        }
+                    },
+                }
             }
+
+            // Switching to the next type definition, no need to keep the current entries around.
+            type_map.clear();
         }
-    }
 
-    fn check_crate_post(&mut self, cx: &LateContext<'tcx>, krate: &'tcx Crate<'_>) {
-        if !krate.items.is_empty() {
-            // Retrieve all inherent implementations from the crate, grouped by type
-            for impls in cx.tcx.crate_inherent_impls(def_id::LOCAL_CRATE).inherent_impls.values() {
-                // Filter out implementations that have generic params (type or lifetime)
-                let mut impl_spans = impls.iter().filter_map(|impl_def| self.impls.get(impl_def));
-                if let Some(initial_span) = impl_spans.next() {
-                    impl_spans.for_each(|additional_span| {
-                        span_lint_and_then(
-                            cx,
-                            MULTIPLE_INHERENT_IMPL,
-                            *additional_span,
-                            "multiple implementations of this structure",
-                            |diag| {
-                                diag.span_note(*initial_span, "first implementation here");
-                            },
-                        )
-                    })
-                }
-            }
+        // `TyCtxt::crate_inherent_impls` doesn't have a defined order. Sort the lint output first.
+        lint_spans.sort_by_key(|x| x.0.lo());
+        for (span, first_span) in lint_spans {
+            span_lint_and_note(
+                cx,
+                MULTIPLE_INHERENT_IMPL,
+                span,
+                "multiple implementations of this structure",
+                Some(first_span),
+                "first implementation here",
+            );
         }
     }
 }
+
+/// Gets the span for the given impl block unless it's not being considered by the lint.
+fn get_impl_span(cx: &LateContext<'_>, id: LocalDefId) -> Option<Span> {
+    let id = cx.tcx.hir().local_def_id_to_hir_id(id);
+    if let Node::Item(&Item {
+        kind: ItemKind::Impl(ref impl_item),
+        span,
+        ..
+    }) = cx.tcx.hir().get(id)
+    {
+        (!in_macro(span) && impl_item.generics.params.is_empty() && !is_allowed(cx, MULTIPLE_INHERENT_IMPL, id))
+            .then(|| span)
+    } else {
+        None
+    }
+}
+
+enum IdOrSpan {
+    Id(LocalDefId),
+    Span(Span),
+}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 78a95b00403..47c576bac48 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1154,7 +1154,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_early_pass(|| box suspicious_operation_groupings::SuspiciousOperationGroupings);
     store.register_late_pass(|| box suspicious_trait_impl::SuspiciousImpl);
     store.register_late_pass(|| box map_unit_fn::MapUnit);
-    store.register_late_pass(|| box inherent_impl::MultipleInherentImpl::default());
+    store.register_late_pass(|| box inherent_impl::MultipleInherentImpl);
     store.register_late_pass(|| box neg_cmp_op_on_partial_ord::NoNegCompOpForPartialOrd);
     store.register_late_pass(|| box unwrap::Unwrap);
     store.register_late_pass(|| box duration_subsec::DurationSubsec);
diff --git a/tests/ui/impl.rs b/tests/ui/impl.rs
index 1c46e3a5337..39443775015 100644
--- a/tests/ui/impl.rs
+++ b/tests/ui/impl.rs
@@ -33,4 +33,35 @@ impl fmt::Debug for MyStruct {
     }
 }
 
+// issue #5772
+struct WithArgs<T>(T);
+impl WithArgs<u32> {
+    fn f1() {}
+}
+impl WithArgs<u64> {
+    fn f2() {}
+}
+impl WithArgs<u64> {
+    fn f3() {}
+}
+
+// Ok, the struct is allowed to have multiple impls.
+#[allow(clippy::multiple_inherent_impl)]
+struct Allowed;
+impl Allowed {}
+impl Allowed {}
+impl Allowed {}
+
+struct AllowedImpl;
+#[allow(clippy::multiple_inherent_impl)]
+impl AllowedImpl {}
+// Ok, the first block is skipped by this lint.
+impl AllowedImpl {}
+
+struct OneAllowedImpl;
+impl OneAllowedImpl {}
+#[allow(clippy::multiple_inherent_impl)]
+impl OneAllowedImpl {}
+impl OneAllowedImpl {} // Lint, only one of the three blocks is allowed.
+
 fn main() {}
diff --git a/tests/ui/impl.stderr b/tests/ui/impl.stderr
index aab688cc2d8..8703ecac93e 100644
--- a/tests/ui/impl.stderr
+++ b/tests/ui/impl.stderr
@@ -31,5 +31,33 @@ LL | |     fn first() {}
 LL | | }
    | |_^
 
-error: aborting due to 2 previous errors
+error: multiple implementations of this structure
+  --> $DIR/impl.rs:44:1
+   |
+LL | / impl WithArgs<u64> {
+LL | |     fn f3() {}
+LL | | }
+   | |_^
+   |
+note: first implementation here
+  --> $DIR/impl.rs:41:1
+   |
+LL | / impl WithArgs<u64> {
+LL | |     fn f2() {}
+LL | | }
+   | |_^
+
+error: multiple implementations of this structure
+  --> $DIR/impl.rs:65:1
+   |
+LL | impl OneAllowedImpl {} // Lint, only one of the three blocks is allowed.
+   | ^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: first implementation here
+  --> $DIR/impl.rs:62:1
+   |
+LL | impl OneAllowedImpl {}
+   | ^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 4 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 8036d7f7842e77fde3be49b4c475665a61d9f560 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Wed, 19 May 2021 16:32:09 +0200
Subject: Adding the default lint level to the metadata collection

And stripping the clippy:: prefix from the group
---
 .../src/utils/internal_lints/metadata_collector.rs | 72 ++++++++++++++++++----
 1 file changed, 59 insertions(+), 13 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index b7c86ae6e18..19f20376c6f 100644
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -37,10 +37,28 @@ const BLACK_LISTED_LINTS: [&str; 3] = ["lint_author", "deep_code_inspection", "i
 /// These groups will be ignored by the lint group matcher. This is useful for collections like
 /// `clippy::all`
 const IGNORED_LINT_GROUPS: [&str; 1] = ["clippy::all"];
-/// Lints within this group will be excluded from the collection
-const EXCLUDED_LINT_GROUPS: [&str; 1] = ["clippy::internal"];
+/// Lints within this group will be excluded from the collection. These groups
+/// have to be defined without the `clippy::` prefix.
+const EXCLUDED_LINT_GROUPS: [&str; 1] = ["internal"];
 /// Collected deprecated lint will be assigned to this group in the JSON output
-const DEPRECATED_LINT_GROUP_STR: &str = "DEPRECATED";
+const DEPRECATED_LINT_GROUP_STR: &str = "deprecated";
+/// This is the lint level for deprecated lints that will be displayed in the lint list
+const DEPRECATED_LINT_LEVEL: &str = "none";
+/// This array holds Clippy's lint groups with their corresponding default lint level. The
+/// lint level for deprecated lints is set in `DEPRECATED_LINT_LEVEL`.
+const DEFAULT_LINT_LEVELS: [(&str, &str); 8] = [
+    ("correctness", "deny"),
+    ("restriction", "allow"),
+    ("style", "warm"),
+    ("pedantic", "allow"),
+    ("complexity", "warn"),
+    ("perf", "warn"),
+    ("cargo", "allow"),
+    ("nursery", "allow"),
+];
+/// This prefix is in front of the lint groups in the lint store. The prefix will be trimmed
+/// to only keep the actual lint group in the output.
+const CLIPPY_LINT_GROUP_PREFIX: &str = "clippy::";
 
 /// This template will be used to format the configuration section in the lint documentation.
 /// The `configurations` parameter will be replaced with one or multiple formatted
@@ -188,6 +206,7 @@ struct LintMetadata {
     id: String,
     id_span: SerializableSpan,
     group: String,
+    level: &'static str,
     docs: String,
     /// This field is only used in the output and will only be
     /// mapped shortly before the actual output.
@@ -195,11 +214,12 @@ struct LintMetadata {
 }
 
 impl LintMetadata {
-    fn new(id: String, id_span: SerializableSpan, group: String, docs: String) -> Self {
+    fn new(id: String, id_span: SerializableSpan, group: String, level: &'static str, docs: String) -> Self {
         Self {
             id,
             id_span,
             group,
+            level,
             docs,
             applicability: None,
         }
@@ -368,7 +388,7 @@ impl<'hir> LateLintPass<'hir> for MetadataCollector {
                 let lint_name = sym_to_string(item.ident.name).to_ascii_lowercase();
                 if !BLACK_LISTED_LINTS.contains(&lint_name.as_str());
                 // metadata extraction
-                if let Some(group) = get_lint_group_or_lint(cx, &lint_name, item);
+                if let Some((group, level)) = get_lint_group_and_level_or_lint(cx, &lint_name, item);
                 if let Some(mut docs) = extract_attr_docs_or_lint(cx, item);
                 then {
                     if let Some(configuration_section) = self.get_lint_configs(&lint_name) {
@@ -379,6 +399,7 @@ impl<'hir> LateLintPass<'hir> for MetadataCollector {
                         lint_name,
                         SerializableSpan::from_item(cx, item),
                         group,
+                        level,
                         docs,
                     ));
                 }
@@ -396,6 +417,7 @@ impl<'hir> LateLintPass<'hir> for MetadataCollector {
                         lint_name,
                         SerializableSpan::from_item(cx, item),
                         DEPRECATED_LINT_GROUP_STR.to_string(),
+                        DEPRECATED_LINT_LEVEL,
                         docs,
                     ));
                 }
@@ -475,15 +497,32 @@ fn extract_attr_docs(cx: &LateContext<'_>, item: &Item<'_>) -> Option<String> {
         })
 }
 
-fn get_lint_group_or_lint(cx: &LateContext<'_>, lint_name: &str, item: &'hir Item<'_>) -> Option<String> {
+fn get_lint_group_and_level_or_lint(
+    cx: &LateContext<'_>,
+    lint_name: &str,
+    item: &'hir Item<'_>,
+) -> Option<(String, &'static str)> {
     let result = cx.lint_store.check_lint_name(lint_name, Some(sym::clippy));
     if let CheckLintNameResult::Tool(Ok(lint_lst)) = result {
-        get_lint_group(cx, lint_lst[0])
-            .or_else(|| {
-                lint_collection_error_item(cx, item, "Unable to determine lint group");
+        if let Some(group) = get_lint_group(cx, lint_lst[0]) {
+            if EXCLUDED_LINT_GROUPS.contains(&group.as_str()) {
+                return None;
+            }
+
+            if let Some(level) = get_lint_level_from_group(&group) {
+                Some((group, level))
+            } else {
+                lint_collection_error_item(
+                    cx,
+                    item,
+                    &format!("Unable to determine lint level for found group `{}`", group),
+                );
                 None
-            })
-            .filter(|group| !EXCLUDED_LINT_GROUPS.contains(&group.as_str()))
+            }
+        } else {
+            lint_collection_error_item(cx, item, "Unable to determine lint group");
+            None
+        }
     } else {
         lint_collection_error_item(cx, item, "Unable to find lint in lint_store");
         None
@@ -496,14 +535,21 @@ fn get_lint_group(cx: &LateContext<'_>, lint_id: LintId) -> Option<String> {
             continue;
         }
 
-        if lints.iter().any(|x| *x == lint_id) {
-            return Some((*group_name).to_string());
+        if lints.iter().any(|group_lint| *group_lint == lint_id) {
+            let group = group_name.strip_prefix(CLIPPY_LINT_GROUP_PREFIX).unwrap_or(group_name);
+            return Some((*group).to_string());
         }
     }
 
     None
 }
 
+fn get_lint_level_from_group(lint_group: &str) -> Option<&'static str> {
+    DEFAULT_LINT_LEVELS
+        .iter()
+        .find_map(|(group_name, group_level)| (*group_name == lint_group).then(|| *group_level))
+}
+
 fn is_deprecated_lint(cx: &LateContext<'_>, ty: &hir::Ty<'_>) -> bool {
     if let hir::TyKind::Path(ref path) = ty.kind {
         if let hir::def::Res::Def(DefKind::Struct, def_id) = cx.qpath_res(path, ty.hir_id) {
-- 
cgit 1.4.1-3-g733a5


From 9dc366bc4d8a32197f28cb94b9c0e0a51108c809 Mon Sep 17 00:00:00 2001
From: Fridtjof Stoldt <xFrednet@gmail.com>
Date: Wed, 19 May 2021 17:23:33 +0200
Subject: Fixed a type

Co-authored-by: Philipp Krones <hello@philkrones.com>
---
 clippy_lints/src/utils/internal_lints/metadata_collector.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index 19f20376c6f..d6879022057 100644
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -49,7 +49,7 @@ const DEPRECATED_LINT_LEVEL: &str = "none";
 const DEFAULT_LINT_LEVELS: [(&str, &str); 8] = [
     ("correctness", "deny"),
     ("restriction", "allow"),
-    ("style", "warm"),
+    ("style", "warn"),
     ("pedantic", "allow"),
     ("complexity", "warn"),
     ("perf", "warn"),
-- 
cgit 1.4.1-3-g733a5


From 73048291157e845877a987cab5da8f0dbf1309ef Mon Sep 17 00:00:00 2001
From: flip1995 <philipp.krones@embecosm.com>
Date: Thu, 20 May 2021 13:57:52 +0200
Subject: Early return from LintPass registration when collecting metadata

This speeds up the metadata collection by 2-2.5x on my machine. During
metadata collection other lint passes don't have to be registered, only
the lints themselves.
---
 clippy_lints/src/lib.rs | 951 ++++++++++++++++++++++++------------------------
 1 file changed, 477 insertions(+), 474 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 2c83409b402..d1c129eba82 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -995,457 +995,172 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     ]);
     // end register lints, do not remove this comment, it’s used in `update_lints`
 
-    // all the internal lints
-    #[cfg(feature = "internal-lints")]
-    {
-        store.register_early_pass(|| box utils::internal_lints::ClippyLintsInternal);
-        store.register_early_pass(|| box utils::internal_lints::ProduceIce);
-        store.register_late_pass(|| box utils::inspector::DeepCodeInspector);
-        store.register_late_pass(|| box utils::internal_lints::CollapsibleCalls);
-        store.register_late_pass(|| box utils::internal_lints::CompilerLintFunctions::new());
-        store.register_late_pass(|| box utils::internal_lints::IfChainStyle);
-        store.register_late_pass(|| box utils::internal_lints::InvalidPaths);
-        store.register_late_pass(|| box utils::internal_lints::InterningDefinedSymbol::default());
-        store.register_late_pass(|| box utils::internal_lints::LintWithoutLintPass::default());
-        store.register_late_pass(|| box utils::internal_lints::MatchTypeOnDiagItem);
-        store.register_late_pass(|| box utils::internal_lints::OuterExpnDataPass);
-    }
-    #[cfg(feature = "metadata-collector-lint")]
-    {
-        if std::env::var("ENABLE_METADATA_COLLECTION").eq(&Ok("1".to_string())) {
-            store.register_late_pass(|| box utils::internal_lints::metadata_collector::MetadataCollector::new());
-        }
-    }
-
-    store.register_late_pass(|| box utils::author::Author);
-    store.register_late_pass(|| box await_holding_invalid::AwaitHolding);
-    store.register_late_pass(|| box serde_api::SerdeApi);
-    let vec_box_size_threshold = conf.vec_box_size_threshold;
-    let type_complexity_threshold = conf.type_complexity_threshold;
-    store.register_late_pass(move || box types::Types::new(vec_box_size_threshold, type_complexity_threshold));
-    store.register_late_pass(|| box booleans::NonminimalBool);
-    store.register_late_pass(|| box needless_bitwise_bool::NeedlessBitwiseBool);
-    store.register_late_pass(|| box eq_op::EqOp);
-    store.register_late_pass(|| box enum_clike::UnportableVariant);
-    store.register_late_pass(|| box float_literal::FloatLiteral);
-    let verbose_bit_mask_threshold = conf.verbose_bit_mask_threshold;
-    store.register_late_pass(move || box bit_mask::BitMask::new(verbose_bit_mask_threshold));
-    store.register_late_pass(|| box ptr::Ptr);
-    store.register_late_pass(|| box ptr_eq::PtrEq);
-    store.register_late_pass(|| box needless_bool::NeedlessBool);
-    store.register_late_pass(|| box needless_bool::BoolComparison);
-    store.register_late_pass(|| box needless_for_each::NeedlessForEach);
-    store.register_late_pass(|| box approx_const::ApproxConstant);
-    store.register_late_pass(|| box misc::MiscLints);
-    store.register_late_pass(|| box eta_reduction::EtaReduction);
-    store.register_late_pass(|| box identity_op::IdentityOp);
-    store.register_late_pass(|| box erasing_op::ErasingOp);
-    store.register_late_pass(|| box mut_mut::MutMut);
-    store.register_late_pass(|| box mut_reference::UnnecessaryMutPassed);
-    store.register_late_pass(|| box len_zero::LenZero);
-    store.register_late_pass(|| box attrs::Attributes);
-    store.register_late_pass(|| box blocks_in_if_conditions::BlocksInIfConditions);
-    store.register_late_pass(|| box collapsible_match::CollapsibleMatch);
-    store.register_late_pass(|| box unicode::Unicode);
-    store.register_late_pass(|| box unit_return_expecting_ord::UnitReturnExpectingOrd);
-    store.register_late_pass(|| box strings::StringAdd);
-    store.register_late_pass(|| box implicit_return::ImplicitReturn);
-    store.register_late_pass(|| box implicit_saturating_sub::ImplicitSaturatingSub);
-    store.register_late_pass(|| box default_numeric_fallback::DefaultNumericFallback);
-    store.register_late_pass(|| box inconsistent_struct_constructor::InconsistentStructConstructor);
-    store.register_late_pass(|| box non_octal_unix_permissions::NonOctalUnixPermissions);
-    store.register_early_pass(|| box unnecessary_self_imports::UnnecessarySelfImports);
+    store.register_group(true, "clippy::restriction", Some("clippy_restriction"), vec![
+        LintId::of(arithmetic::FLOAT_ARITHMETIC),
+        LintId::of(arithmetic::INTEGER_ARITHMETIC),
+        LintId::of(as_conversions::AS_CONVERSIONS),
+        LintId::of(asm_syntax::INLINE_ASM_X86_ATT_SYNTAX),
+        LintId::of(asm_syntax::INLINE_ASM_X86_INTEL_SYNTAX),
+        LintId::of(create_dir::CREATE_DIR),
+        LintId::of(dbg_macro::DBG_MACRO),
+        LintId::of(default_numeric_fallback::DEFAULT_NUMERIC_FALLBACK),
+        LintId::of(else_if_without_else::ELSE_IF_WITHOUT_ELSE),
+        LintId::of(exhaustive_items::EXHAUSTIVE_ENUMS),
+        LintId::of(exhaustive_items::EXHAUSTIVE_STRUCTS),
+        LintId::of(exit::EXIT),
+        LintId::of(float_literal::LOSSY_FLOAT_LITERAL),
+        LintId::of(if_then_some_else_none::IF_THEN_SOME_ELSE_NONE),
+        LintId::of(implicit_return::IMPLICIT_RETURN),
+        LintId::of(indexing_slicing::INDEXING_SLICING),
+        LintId::of(inherent_impl::MULTIPLE_INHERENT_IMPL),
+        LintId::of(integer_division::INTEGER_DIVISION),
+        LintId::of(let_underscore::LET_UNDERSCORE_MUST_USE),
+        LintId::of(literal_representation::DECIMAL_LITERAL_REPRESENTATION),
+        LintId::of(map_err_ignore::MAP_ERR_IGNORE),
+        LintId::of(matches::REST_PAT_IN_FULLY_BOUND_STRUCTS),
+        LintId::of(matches::WILDCARD_ENUM_MATCH_ARM),
+        LintId::of(mem_forget::MEM_FORGET),
+        LintId::of(methods::CLONE_ON_REF_PTR),
+        LintId::of(methods::EXPECT_USED),
+        LintId::of(methods::FILETYPE_IS_FILE),
+        LintId::of(methods::GET_UNWRAP),
+        LintId::of(methods::UNWRAP_USED),
+        LintId::of(methods::WRONG_PUB_SELF_CONVENTION),
+        LintId::of(misc::FLOAT_CMP_CONST),
+        LintId::of(misc_early::UNNEEDED_FIELD_PATTERN),
+        LintId::of(missing_doc::MISSING_DOCS_IN_PRIVATE_ITEMS),
+        LintId::of(missing_inline::MISSING_INLINE_IN_PUBLIC_ITEMS),
+        LintId::of(modulo_arithmetic::MODULO_ARITHMETIC),
+        LintId::of(panic_in_result_fn::PANIC_IN_RESULT_FN),
+        LintId::of(panic_unimplemented::PANIC),
+        LintId::of(panic_unimplemented::TODO),
+        LintId::of(panic_unimplemented::UNIMPLEMENTED),
+        LintId::of(panic_unimplemented::UNREACHABLE),
+        LintId::of(pattern_type_mismatch::PATTERN_TYPE_MISMATCH),
+        LintId::of(semicolon_if_nothing_returned::SEMICOLON_IF_NOTHING_RETURNED),
+        LintId::of(shadow::SHADOW_REUSE),
+        LintId::of(shadow::SHADOW_SAME),
+        LintId::of(strings::STRING_ADD),
+        LintId::of(strings::STRING_TO_STRING),
+        LintId::of(strings::STR_TO_STRING),
+        LintId::of(types::RC_BUFFER),
+        LintId::of(unnecessary_self_imports::UNNECESSARY_SELF_IMPORTS),
+        LintId::of(unwrap_in_result::UNWRAP_IN_RESULT),
+        LintId::of(verbose_file_reads::VERBOSE_FILE_READS),
+        LintId::of(write::PRINT_STDERR),
+        LintId::of(write::PRINT_STDOUT),
+        LintId::of(write::USE_DEBUG),
+    ]);
 
-    let msrv = conf.msrv.as_ref().and_then(|s| {
-        parse_msrv(s, None, None).or_else(|| {
-            sess.err(&format!("error reading Clippy's configuration file. `{}` is not a valid Rust version", s));
-            None
-        })
-    });
+    store.register_group(true, "clippy::pedantic", Some("clippy_pedantic"), vec![
+        LintId::of(attrs::INLINE_ALWAYS),
+        LintId::of(await_holding_invalid::AWAIT_HOLDING_LOCK),
+        LintId::of(await_holding_invalid::AWAIT_HOLDING_REFCELL_REF),
+        LintId::of(bit_mask::VERBOSE_BIT_MASK),
+        LintId::of(bytecount::NAIVE_BYTECOUNT),
+        LintId::of(case_sensitive_file_extension_comparisons::CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS),
+        LintId::of(casts::CAST_LOSSLESS),
+        LintId::of(casts::CAST_POSSIBLE_TRUNCATION),
+        LintId::of(casts::CAST_POSSIBLE_WRAP),
+        LintId::of(casts::CAST_PRECISION_LOSS),
+        LintId::of(casts::CAST_PTR_ALIGNMENT),
+        LintId::of(casts::CAST_SIGN_LOSS),
+        LintId::of(casts::PTR_AS_PTR),
+        LintId::of(checked_conversions::CHECKED_CONVERSIONS),
+        LintId::of(copies::SAME_FUNCTIONS_IN_IF_CONDITION),
+        LintId::of(copy_iterator::COPY_ITERATOR),
+        LintId::of(default::DEFAULT_TRAIT_ACCESS),
+        LintId::of(dereference::EXPLICIT_DEREF_METHODS),
+        LintId::of(derive::EXPL_IMPL_CLONE_ON_COPY),
+        LintId::of(derive::UNSAFE_DERIVE_DESERIALIZE),
+        LintId::of(doc::DOC_MARKDOWN),
+        LintId::of(doc::MISSING_ERRORS_DOC),
+        LintId::of(doc::MISSING_PANICS_DOC),
+        LintId::of(empty_enum::EMPTY_ENUM),
+        LintId::of(enum_variants::MODULE_NAME_REPETITIONS),
+        LintId::of(enum_variants::PUB_ENUM_VARIANT_NAMES),
+        LintId::of(eta_reduction::REDUNDANT_CLOSURE_FOR_METHOD_CALLS),
+        LintId::of(excessive_bools::FN_PARAMS_EXCESSIVE_BOOLS),
+        LintId::of(excessive_bools::STRUCT_EXCESSIVE_BOOLS),
+        LintId::of(functions::MUST_USE_CANDIDATE),
+        LintId::of(functions::TOO_MANY_LINES),
+        LintId::of(if_not_else::IF_NOT_ELSE),
+        LintId::of(implicit_hasher::IMPLICIT_HASHER),
+        LintId::of(implicit_saturating_sub::IMPLICIT_SATURATING_SUB),
+        LintId::of(inconsistent_struct_constructor::INCONSISTENT_STRUCT_CONSTRUCTOR),
+        LintId::of(infinite_iter::MAYBE_INFINITE_ITER),
+        LintId::of(invalid_upcast_comparisons::INVALID_UPCAST_COMPARISONS),
+        LintId::of(items_after_statements::ITEMS_AFTER_STATEMENTS),
+        LintId::of(large_stack_arrays::LARGE_STACK_ARRAYS),
+        LintId::of(let_underscore::LET_UNDERSCORE_DROP),
+        LintId::of(literal_representation::LARGE_DIGIT_GROUPS),
+        LintId::of(literal_representation::UNREADABLE_LITERAL),
+        LintId::of(loops::EXPLICIT_INTO_ITER_LOOP),
+        LintId::of(loops::EXPLICIT_ITER_LOOP),
+        LintId::of(macro_use::MACRO_USE_IMPORTS),
+        LintId::of(manual_ok_or::MANUAL_OK_OR),
+        LintId::of(match_on_vec_items::MATCH_ON_VEC_ITEMS),
+        LintId::of(matches::MATCH_BOOL),
+        LintId::of(matches::MATCH_SAME_ARMS),
+        LintId::of(matches::MATCH_WILDCARD_FOR_SINGLE_VARIANTS),
+        LintId::of(matches::MATCH_WILD_ERR_ARM),
+        LintId::of(matches::SINGLE_MATCH_ELSE),
+        LintId::of(methods::CLONED_INSTEAD_OF_COPIED),
+        LintId::of(methods::FILTER_MAP_NEXT),
+        LintId::of(methods::FLAT_MAP_OPTION),
+        LintId::of(methods::IMPLICIT_CLONE),
+        LintId::of(methods::INEFFICIENT_TO_STRING),
+        LintId::of(methods::MAP_FLATTEN),
+        LintId::of(methods::MAP_UNWRAP_OR),
+        LintId::of(misc::USED_UNDERSCORE_BINDING),
+        LintId::of(misc_early::UNSEPARATED_LITERAL_SUFFIX),
+        LintId::of(mut_mut::MUT_MUT),
+        LintId::of(needless_bitwise_bool::NEEDLESS_BITWISE_BOOL),
+        LintId::of(needless_continue::NEEDLESS_CONTINUE),
+        LintId::of(needless_for_each::NEEDLESS_FOR_EACH),
+        LintId::of(needless_pass_by_value::NEEDLESS_PASS_BY_VALUE),
+        LintId::of(non_expressive_names::SIMILAR_NAMES),
+        LintId::of(option_if_let_else::OPTION_IF_LET_ELSE),
+        LintId::of(pass_by_ref_or_value::LARGE_TYPES_PASSED_BY_VALUE),
+        LintId::of(pass_by_ref_or_value::TRIVIALLY_COPY_PASS_BY_REF),
+        LintId::of(ranges::RANGE_MINUS_ONE),
+        LintId::of(ranges::RANGE_PLUS_ONE),
+        LintId::of(redundant_else::REDUNDANT_ELSE),
+        LintId::of(ref_option_ref::REF_OPTION_REF),
+        LintId::of(shadow::SHADOW_UNRELATED),
+        LintId::of(strings::STRING_ADD_ASSIGN),
+        LintId::of(trait_bounds::TRAIT_DUPLICATION_IN_BOUNDS),
+        LintId::of(trait_bounds::TYPE_REPETITION_IN_BOUNDS),
+        LintId::of(transmute::TRANSMUTE_PTR_TO_PTR),
+        LintId::of(types::LINKEDLIST),
+        LintId::of(types::OPTION_OPTION),
+        LintId::of(unicode::NON_ASCII_LITERAL),
+        LintId::of(unicode::UNICODE_NOT_NFC),
+        LintId::of(unit_types::LET_UNIT_VALUE),
+        LintId::of(unnecessary_wraps::UNNECESSARY_WRAPS),
+        LintId::of(unnested_or_patterns::UNNESTED_OR_PATTERNS),
+        LintId::of(unused_async::UNUSED_ASYNC),
+        LintId::of(unused_self::UNUSED_SELF),
+        LintId::of(wildcard_imports::ENUM_GLOB_USE),
+        LintId::of(wildcard_imports::WILDCARD_IMPORTS),
+        LintId::of(zero_sized_map_values::ZERO_SIZED_MAP_VALUES),
+    ]);
 
-    store.register_late_pass(move || box methods::Methods::new(msrv));
-    store.register_late_pass(move || box matches::Matches::new(msrv));
-    store.register_early_pass(move || box manual_non_exhaustive::ManualNonExhaustive::new(msrv));
-    store.register_late_pass(move || box manual_strip::ManualStrip::new(msrv));
-    store.register_early_pass(move || box redundant_static_lifetimes::RedundantStaticLifetimes::new(msrv));
-    store.register_early_pass(move || box redundant_field_names::RedundantFieldNames::new(msrv));
-    store.register_late_pass(move || box checked_conversions::CheckedConversions::new(msrv));
-    store.register_late_pass(move || box mem_replace::MemReplace::new(msrv));
-    store.register_late_pass(move || box ranges::Ranges::new(msrv));
-    store.register_late_pass(move || box from_over_into::FromOverInto::new(msrv));
-    store.register_late_pass(move || box use_self::UseSelf::new(msrv));
-    store.register_late_pass(move || box missing_const_for_fn::MissingConstForFn::new(msrv));
-    store.register_late_pass(move || box needless_question_mark::NeedlessQuestionMark);
-    store.register_late_pass(move || box casts::Casts::new(msrv));
-    store.register_early_pass(move || box unnested_or_patterns::UnnestedOrPatterns::new(msrv));
-
-    store.register_late_pass(|| box size_of_in_element_count::SizeOfInElementCount);
-    store.register_late_pass(|| box map_clone::MapClone);
-    store.register_late_pass(|| box map_err_ignore::MapErrIgnore);
-    store.register_late_pass(|| box shadow::Shadow);
-    store.register_late_pass(|| box unit_types::UnitTypes);
-    store.register_late_pass(|| box loops::Loops);
-    store.register_late_pass(|| box main_recursion::MainRecursion::default());
-    store.register_late_pass(|| box lifetimes::Lifetimes);
-    store.register_late_pass(|| box entry::HashMapPass);
-    store.register_late_pass(|| box minmax::MinMaxPass);
-    store.register_late_pass(|| box open_options::OpenOptions);
-    store.register_late_pass(|| box zero_div_zero::ZeroDiv);
-    store.register_late_pass(|| box mutex_atomic::Mutex);
-    store.register_late_pass(|| box needless_update::NeedlessUpdate);
-    store.register_late_pass(|| box needless_borrow::NeedlessBorrow::default());
-    store.register_late_pass(|| box needless_borrowed_ref::NeedlessBorrowedRef);
-    store.register_late_pass(|| box no_effect::NoEffect);
-    store.register_late_pass(|| box temporary_assignment::TemporaryAssignment);
-    store.register_late_pass(|| box transmute::Transmute);
-    let cognitive_complexity_threshold = conf.cognitive_complexity_threshold;
-    store.register_late_pass(move || box cognitive_complexity::CognitiveComplexity::new(cognitive_complexity_threshold));
-    let too_large_for_stack = conf.too_large_for_stack;
-    store.register_late_pass(move || box escape::BoxedLocal{too_large_for_stack});
-    store.register_late_pass(move || box vec::UselessVec{too_large_for_stack});
-    store.register_late_pass(|| box panic_unimplemented::PanicUnimplemented);
-    store.register_late_pass(|| box strings::StringLitAsBytes);
-    store.register_late_pass(|| box derive::Derive);
-    store.register_late_pass(|| box get_last_with_len::GetLastWithLen);
-    store.register_late_pass(|| box drop_forget_ref::DropForgetRef);
-    store.register_late_pass(|| box empty_enum::EmptyEnum);
-    store.register_late_pass(|| box absurd_extreme_comparisons::AbsurdExtremeComparisons);
-    store.register_late_pass(|| box invalid_upcast_comparisons::InvalidUpcastComparisons);
-    store.register_late_pass(|| box regex::Regex::default());
-    store.register_late_pass(|| box copies::CopyAndPaste);
-    store.register_late_pass(|| box copy_iterator::CopyIterator);
-    store.register_late_pass(|| box format::UselessFormat);
-    store.register_late_pass(|| box swap::Swap);
-    store.register_late_pass(|| box overflow_check_conditional::OverflowCheckConditional);
-    store.register_late_pass(|| box new_without_default::NewWithoutDefault::default());
-    let blacklisted_names = conf.blacklisted_names.iter().cloned().collect::<FxHashSet<_>>();
-    store.register_late_pass(move || box blacklisted_name::BlacklistedName::new(blacklisted_names.clone()));
-    let too_many_arguments_threshold = conf.too_many_arguments_threshold;
-    let too_many_lines_threshold = conf.too_many_lines_threshold;
-    store.register_late_pass(move || box functions::Functions::new(too_many_arguments_threshold, too_many_lines_threshold));
-    let doc_valid_idents = conf.doc_valid_idents.iter().cloned().collect::<FxHashSet<_>>();
-    store.register_late_pass(move || box doc::DocMarkdown::new(doc_valid_idents.clone()));
-    store.register_late_pass(|| box neg_multiply::NegMultiply);
-    store.register_late_pass(|| box mem_discriminant::MemDiscriminant);
-    store.register_late_pass(|| box mem_forget::MemForget);
-    store.register_late_pass(|| box arithmetic::Arithmetic::default());
-    store.register_late_pass(|| box assign_ops::AssignOps);
-    store.register_late_pass(|| box let_if_seq::LetIfSeq);
-    store.register_late_pass(|| box eval_order_dependence::EvalOrderDependence);
-    store.register_late_pass(|| box missing_doc::MissingDoc::new());
-    store.register_late_pass(|| box missing_inline::MissingInline);
-    store.register_late_pass(move || box exhaustive_items::ExhaustiveItems);
-    store.register_late_pass(|| box if_let_some_result::OkIfLet);
-    store.register_late_pass(|| box partialeq_ne_impl::PartialEqNeImpl);
-    store.register_late_pass(|| box unused_io_amount::UnusedIoAmount);
-    let enum_variant_size_threshold = conf.enum_variant_size_threshold;
-    store.register_late_pass(move || box large_enum_variant::LargeEnumVariant::new(enum_variant_size_threshold));
-    store.register_late_pass(|| box explicit_write::ExplicitWrite);
-    store.register_late_pass(|| box needless_pass_by_value::NeedlessPassByValue);
-    let pass_by_ref_or_value = pass_by_ref_or_value::PassByRefOrValue::new(
-        conf.trivial_copy_size_limit,
-        conf.pass_by_value_size_limit,
-        &sess.target,
-    );
-    store.register_late_pass(move || box pass_by_ref_or_value);
-    store.register_late_pass(|| box ref_option_ref::RefOptionRef);
-    store.register_late_pass(|| box try_err::TryErr);
-    store.register_late_pass(|| box bytecount::ByteCount);
-    store.register_late_pass(|| box infinite_iter::InfiniteIter);
-    store.register_late_pass(|| box inline_fn_without_body::InlineFnWithoutBody);
-    store.register_late_pass(|| box useless_conversion::UselessConversion::default());
-    store.register_late_pass(|| box implicit_hasher::ImplicitHasher);
-    store.register_late_pass(|| box fallible_impl_from::FallibleImplFrom);
-    store.register_late_pass(|| box double_comparison::DoubleComparisons);
-    store.register_late_pass(|| box question_mark::QuestionMark);
-    store.register_early_pass(|| box suspicious_operation_groupings::SuspiciousOperationGroupings);
-    store.register_late_pass(|| box suspicious_trait_impl::SuspiciousImpl);
-    store.register_late_pass(|| box map_unit_fn::MapUnit);
-    store.register_late_pass(|| box inherent_impl::MultipleInherentImpl);
-    store.register_late_pass(|| box neg_cmp_op_on_partial_ord::NoNegCompOpForPartialOrd);
-    store.register_late_pass(|| box unwrap::Unwrap);
-    store.register_late_pass(|| box duration_subsec::DurationSubsec);
-    store.register_late_pass(|| box indexing_slicing::IndexingSlicing);
-    store.register_late_pass(|| box non_copy_const::NonCopyConst);
-    store.register_late_pass(|| box ptr_offset_with_cast::PtrOffsetWithCast);
-    store.register_late_pass(|| box redundant_clone::RedundantClone);
-    store.register_late_pass(|| box slow_vector_initialization::SlowVectorInit);
-    store.register_late_pass(|| box unnecessary_sort_by::UnnecessarySortBy);
-    store.register_late_pass(|| box unnecessary_wraps::UnnecessaryWraps);
-    store.register_late_pass(|| box assertions_on_constants::AssertionsOnConstants);
-    store.register_late_pass(|| box transmuting_null::TransmutingNull);
-    store.register_late_pass(|| box path_buf_push_overwrite::PathBufPushOverwrite);
-    store.register_late_pass(|| box integer_division::IntegerDivision);
-    store.register_late_pass(|| box inherent_to_string::InherentToString);
-    let max_trait_bounds = conf.max_trait_bounds;
-    store.register_late_pass(move || box trait_bounds::TraitBounds::new(max_trait_bounds));
-    store.register_late_pass(|| box comparison_chain::ComparisonChain);
-    store.register_late_pass(|| box mut_key::MutableKeyType);
-    store.register_late_pass(|| box modulo_arithmetic::ModuloArithmetic);
-    store.register_early_pass(|| box reference::DerefAddrOf);
-    store.register_early_pass(|| box reference::RefInDeref);
-    store.register_early_pass(|| box double_parens::DoubleParens);
-    store.register_late_pass(|| box to_string_in_display::ToStringInDisplay::new());
-    store.register_early_pass(|| box unsafe_removed_from_name::UnsafeNameRemoval);
-    store.register_early_pass(|| box if_not_else::IfNotElse);
-    store.register_early_pass(|| box else_if_without_else::ElseIfWithoutElse);
-    store.register_early_pass(|| box int_plus_one::IntPlusOne);
-    store.register_early_pass(|| box formatting::Formatting);
-    store.register_early_pass(|| box misc_early::MiscEarlyLints);
-    store.register_early_pass(|| box redundant_closure_call::RedundantClosureCall);
-    store.register_late_pass(|| box redundant_closure_call::RedundantClosureCall);
-    store.register_early_pass(|| box unused_unit::UnusedUnit);
-    store.register_late_pass(|| box returns::Return);
-    store.register_early_pass(|| box collapsible_if::CollapsibleIf);
-    store.register_early_pass(|| box items_after_statements::ItemsAfterStatements);
-    store.register_early_pass(|| box precedence::Precedence);
-    store.register_early_pass(|| box needless_continue::NeedlessContinue);
-    store.register_early_pass(|| box redundant_else::RedundantElse);
-    store.register_late_pass(|| box create_dir::CreateDir);
-    store.register_early_pass(|| box needless_arbitrary_self_type::NeedlessArbitrarySelfType);
-    let cargo_ignore_publish = conf.cargo_ignore_publish;
-    store.register_late_pass(move || box cargo_common_metadata::CargoCommonMetadata::new(cargo_ignore_publish));
-    store.register_late_pass(|| box multiple_crate_versions::MultipleCrateVersions);
-    store.register_late_pass(|| box wildcard_dependencies::WildcardDependencies);
-    let literal_representation_lint_fraction_readability = conf.unreadable_literal_lint_fractions;
-    store.register_early_pass(move || box literal_representation::LiteralDigitGrouping::new(literal_representation_lint_fraction_readability));
-    let literal_representation_threshold = conf.literal_representation_threshold;
-    store.register_early_pass(move || box literal_representation::DecimalLiteralRepresentation::new(literal_representation_threshold));
-    let enum_variant_name_threshold = conf.enum_variant_name_threshold;
-    store.register_early_pass(move || box enum_variants::EnumVariantNames::new(enum_variant_name_threshold));
-    store.register_early_pass(|| box tabs_in_doc_comments::TabsInDocComments);
-    let upper_case_acronyms_aggressive = conf.upper_case_acronyms_aggressive;
-    store.register_early_pass(move || box upper_case_acronyms::UpperCaseAcronyms::new(upper_case_acronyms_aggressive));
-    store.register_late_pass(|| box default::Default::default());
-    store.register_late_pass(|| box unused_self::UnusedSelf);
-    store.register_late_pass(|| box mutable_debug_assertion::DebugAssertWithMutCall);
-    store.register_late_pass(|| box exit::Exit);
-    store.register_late_pass(|| box to_digit_is_some::ToDigitIsSome);
-    let array_size_threshold = conf.array_size_threshold;
-    store.register_late_pass(move || box large_stack_arrays::LargeStackArrays::new(array_size_threshold));
-    store.register_late_pass(move || box large_const_arrays::LargeConstArrays::new(array_size_threshold));
-    store.register_late_pass(|| box floating_point_arithmetic::FloatingPointArithmetic);
-    store.register_early_pass(|| box as_conversions::AsConversions);
-    store.register_late_pass(|| box let_underscore::LetUnderscore);
-    store.register_late_pass(|| box atomic_ordering::AtomicOrdering);
-    store.register_early_pass(|| box single_component_path_imports::SingleComponentPathImports);
-    let max_fn_params_bools = conf.max_fn_params_bools;
-    let max_struct_bools = conf.max_struct_bools;
-    store.register_early_pass(move || box excessive_bools::ExcessiveBools::new(max_struct_bools, max_fn_params_bools));
-    store.register_early_pass(|| box option_env_unwrap::OptionEnvUnwrap);
-    let warn_on_all_wildcard_imports = conf.warn_on_all_wildcard_imports;
-    store.register_late_pass(move || box wildcard_imports::WildcardImports::new(warn_on_all_wildcard_imports));
-    store.register_late_pass(|| box verbose_file_reads::VerboseFileReads);
-    store.register_late_pass(|| box redundant_pub_crate::RedundantPubCrate::default());
-    store.register_late_pass(|| box unnamed_address::UnnamedAddress);
-    store.register_late_pass(|| box dereference::Dereferencing::default());
-    store.register_late_pass(|| box option_if_let_else::OptionIfLetElse);
-    store.register_late_pass(|| box future_not_send::FutureNotSend);
-    store.register_late_pass(|| box if_let_mutex::IfLetMutex);
-    store.register_late_pass(|| box mut_mutex_lock::MutMutexLock);
-    store.register_late_pass(|| box match_on_vec_items::MatchOnVecItems);
-    store.register_late_pass(|| box manual_async_fn::ManualAsyncFn);
-    store.register_late_pass(|| box vec_resize_to_zero::VecResizeToZero);
-    store.register_late_pass(|| box panic_in_result_fn::PanicInResultFn);
-    let single_char_binding_names_threshold = conf.single_char_binding_names_threshold;
-    store.register_early_pass(move || box non_expressive_names::NonExpressiveNames {
-        single_char_binding_names_threshold,
-    });
-    store.register_late_pass(|| box macro_use::MacroUseImports::default());
-    store.register_late_pass(|| box map_identity::MapIdentity);
-    store.register_late_pass(|| box pattern_type_mismatch::PatternTypeMismatch);
-    store.register_late_pass(|| box stable_sort_primitive::StableSortPrimitive);
-    store.register_late_pass(|| box repeat_once::RepeatOnce);
-    store.register_late_pass(|| box unwrap_in_result::UnwrapInResult);
-    store.register_late_pass(|| box self_assignment::SelfAssignment);
-    store.register_late_pass(|| box manual_unwrap_or::ManualUnwrapOr);
-    store.register_late_pass(|| box manual_ok_or::ManualOkOr);
-    store.register_late_pass(|| box float_equality_without_abs::FloatEqualityWithoutAbs);
-    store.register_late_pass(|| box semicolon_if_nothing_returned::SemicolonIfNothingReturned);
-    store.register_late_pass(|| box async_yields_async::AsyncYieldsAsync);
-    let disallowed_methods = conf.disallowed_methods.iter().cloned().collect::<FxHashSet<_>>();
-    store.register_late_pass(move || box disallowed_method::DisallowedMethod::new(&disallowed_methods));
-    store.register_early_pass(|| box asm_syntax::InlineAsmX86AttSyntax);
-    store.register_early_pass(|| box asm_syntax::InlineAsmX86IntelSyntax);
-    store.register_late_pass(|| box undropped_manually_drops::UndroppedManuallyDrops);
-    store.register_late_pass(|| box strings::StrToString);
-    store.register_late_pass(|| box strings::StringToString);
-    store.register_late_pass(|| box zero_sized_map_values::ZeroSizedMapValues);
-    store.register_late_pass(|| box vec_init_then_push::VecInitThenPush::default());
-    store.register_late_pass(|| box case_sensitive_file_extension_comparisons::CaseSensitiveFileExtensionComparisons);
-    store.register_late_pass(|| box redundant_slicing::RedundantSlicing);
-    store.register_late_pass(|| box from_str_radix_10::FromStrRadix10);
-    store.register_late_pass(|| box manual_map::ManualMap);
-    store.register_late_pass(move || box if_then_some_else_none::IfThenSomeElseNone::new(msrv));
-    store.register_early_pass(|| box bool_assert_comparison::BoolAssertComparison);
-    store.register_late_pass(|| box unused_async::UnusedAsync);
-
-    store.register_group(true, "clippy::restriction", Some("clippy_restriction"), vec![
-        LintId::of(arithmetic::FLOAT_ARITHMETIC),
-        LintId::of(arithmetic::INTEGER_ARITHMETIC),
-        LintId::of(as_conversions::AS_CONVERSIONS),
-        LintId::of(asm_syntax::INLINE_ASM_X86_ATT_SYNTAX),
-        LintId::of(asm_syntax::INLINE_ASM_X86_INTEL_SYNTAX),
-        LintId::of(create_dir::CREATE_DIR),
-        LintId::of(dbg_macro::DBG_MACRO),
-        LintId::of(default_numeric_fallback::DEFAULT_NUMERIC_FALLBACK),
-        LintId::of(else_if_without_else::ELSE_IF_WITHOUT_ELSE),
-        LintId::of(exhaustive_items::EXHAUSTIVE_ENUMS),
-        LintId::of(exhaustive_items::EXHAUSTIVE_STRUCTS),
-        LintId::of(exit::EXIT),
-        LintId::of(float_literal::LOSSY_FLOAT_LITERAL),
-        LintId::of(if_then_some_else_none::IF_THEN_SOME_ELSE_NONE),
-        LintId::of(implicit_return::IMPLICIT_RETURN),
-        LintId::of(indexing_slicing::INDEXING_SLICING),
-        LintId::of(inherent_impl::MULTIPLE_INHERENT_IMPL),
-        LintId::of(integer_division::INTEGER_DIVISION),
-        LintId::of(let_underscore::LET_UNDERSCORE_MUST_USE),
-        LintId::of(literal_representation::DECIMAL_LITERAL_REPRESENTATION),
-        LintId::of(map_err_ignore::MAP_ERR_IGNORE),
-        LintId::of(matches::REST_PAT_IN_FULLY_BOUND_STRUCTS),
-        LintId::of(matches::WILDCARD_ENUM_MATCH_ARM),
-        LintId::of(mem_forget::MEM_FORGET),
-        LintId::of(methods::CLONE_ON_REF_PTR),
-        LintId::of(methods::EXPECT_USED),
-        LintId::of(methods::FILETYPE_IS_FILE),
-        LintId::of(methods::GET_UNWRAP),
-        LintId::of(methods::UNWRAP_USED),
-        LintId::of(methods::WRONG_PUB_SELF_CONVENTION),
-        LintId::of(misc::FLOAT_CMP_CONST),
-        LintId::of(misc_early::UNNEEDED_FIELD_PATTERN),
-        LintId::of(missing_doc::MISSING_DOCS_IN_PRIVATE_ITEMS),
-        LintId::of(missing_inline::MISSING_INLINE_IN_PUBLIC_ITEMS),
-        LintId::of(modulo_arithmetic::MODULO_ARITHMETIC),
-        LintId::of(panic_in_result_fn::PANIC_IN_RESULT_FN),
-        LintId::of(panic_unimplemented::PANIC),
-        LintId::of(panic_unimplemented::TODO),
-        LintId::of(panic_unimplemented::UNIMPLEMENTED),
-        LintId::of(panic_unimplemented::UNREACHABLE),
-        LintId::of(pattern_type_mismatch::PATTERN_TYPE_MISMATCH),
-        LintId::of(semicolon_if_nothing_returned::SEMICOLON_IF_NOTHING_RETURNED),
-        LintId::of(shadow::SHADOW_REUSE),
-        LintId::of(shadow::SHADOW_SAME),
-        LintId::of(strings::STRING_ADD),
-        LintId::of(strings::STRING_TO_STRING),
-        LintId::of(strings::STR_TO_STRING),
-        LintId::of(types::RC_BUFFER),
-        LintId::of(unnecessary_self_imports::UNNECESSARY_SELF_IMPORTS),
-        LintId::of(unwrap_in_result::UNWRAP_IN_RESULT),
-        LintId::of(verbose_file_reads::VERBOSE_FILE_READS),
-        LintId::of(write::PRINT_STDERR),
-        LintId::of(write::PRINT_STDOUT),
-        LintId::of(write::USE_DEBUG),
-    ]);
-
-    store.register_group(true, "clippy::pedantic", Some("clippy_pedantic"), vec![
-        LintId::of(attrs::INLINE_ALWAYS),
-        LintId::of(await_holding_invalid::AWAIT_HOLDING_LOCK),
-        LintId::of(await_holding_invalid::AWAIT_HOLDING_REFCELL_REF),
-        LintId::of(bit_mask::VERBOSE_BIT_MASK),
-        LintId::of(bytecount::NAIVE_BYTECOUNT),
-        LintId::of(case_sensitive_file_extension_comparisons::CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS),
-        LintId::of(casts::CAST_LOSSLESS),
-        LintId::of(casts::CAST_POSSIBLE_TRUNCATION),
-        LintId::of(casts::CAST_POSSIBLE_WRAP),
-        LintId::of(casts::CAST_PRECISION_LOSS),
-        LintId::of(casts::CAST_PTR_ALIGNMENT),
-        LintId::of(casts::CAST_SIGN_LOSS),
-        LintId::of(casts::PTR_AS_PTR),
-        LintId::of(checked_conversions::CHECKED_CONVERSIONS),
-        LintId::of(copies::SAME_FUNCTIONS_IN_IF_CONDITION),
-        LintId::of(copy_iterator::COPY_ITERATOR),
-        LintId::of(default::DEFAULT_TRAIT_ACCESS),
-        LintId::of(dereference::EXPLICIT_DEREF_METHODS),
-        LintId::of(derive::EXPL_IMPL_CLONE_ON_COPY),
-        LintId::of(derive::UNSAFE_DERIVE_DESERIALIZE),
-        LintId::of(doc::DOC_MARKDOWN),
-        LintId::of(doc::MISSING_ERRORS_DOC),
-        LintId::of(doc::MISSING_PANICS_DOC),
-        LintId::of(empty_enum::EMPTY_ENUM),
-        LintId::of(enum_variants::MODULE_NAME_REPETITIONS),
-        LintId::of(enum_variants::PUB_ENUM_VARIANT_NAMES),
-        LintId::of(eta_reduction::REDUNDANT_CLOSURE_FOR_METHOD_CALLS),
-        LintId::of(excessive_bools::FN_PARAMS_EXCESSIVE_BOOLS),
-        LintId::of(excessive_bools::STRUCT_EXCESSIVE_BOOLS),
-        LintId::of(functions::MUST_USE_CANDIDATE),
-        LintId::of(functions::TOO_MANY_LINES),
-        LintId::of(if_not_else::IF_NOT_ELSE),
-        LintId::of(implicit_hasher::IMPLICIT_HASHER),
-        LintId::of(implicit_saturating_sub::IMPLICIT_SATURATING_SUB),
-        LintId::of(inconsistent_struct_constructor::INCONSISTENT_STRUCT_CONSTRUCTOR),
-        LintId::of(infinite_iter::MAYBE_INFINITE_ITER),
-        LintId::of(invalid_upcast_comparisons::INVALID_UPCAST_COMPARISONS),
-        LintId::of(items_after_statements::ITEMS_AFTER_STATEMENTS),
-        LintId::of(large_stack_arrays::LARGE_STACK_ARRAYS),
-        LintId::of(let_underscore::LET_UNDERSCORE_DROP),
-        LintId::of(literal_representation::LARGE_DIGIT_GROUPS),
-        LintId::of(literal_representation::UNREADABLE_LITERAL),
-        LintId::of(loops::EXPLICIT_INTO_ITER_LOOP),
-        LintId::of(loops::EXPLICIT_ITER_LOOP),
-        LintId::of(macro_use::MACRO_USE_IMPORTS),
-        LintId::of(manual_ok_or::MANUAL_OK_OR),
-        LintId::of(match_on_vec_items::MATCH_ON_VEC_ITEMS),
-        LintId::of(matches::MATCH_BOOL),
-        LintId::of(matches::MATCH_SAME_ARMS),
-        LintId::of(matches::MATCH_WILDCARD_FOR_SINGLE_VARIANTS),
-        LintId::of(matches::MATCH_WILD_ERR_ARM),
-        LintId::of(matches::SINGLE_MATCH_ELSE),
-        LintId::of(methods::CLONED_INSTEAD_OF_COPIED),
-        LintId::of(methods::FILTER_MAP_NEXT),
-        LintId::of(methods::FLAT_MAP_OPTION),
-        LintId::of(methods::IMPLICIT_CLONE),
-        LintId::of(methods::INEFFICIENT_TO_STRING),
-        LintId::of(methods::MAP_FLATTEN),
-        LintId::of(methods::MAP_UNWRAP_OR),
-        LintId::of(misc::USED_UNDERSCORE_BINDING),
-        LintId::of(misc_early::UNSEPARATED_LITERAL_SUFFIX),
-        LintId::of(mut_mut::MUT_MUT),
-        LintId::of(needless_bitwise_bool::NEEDLESS_BITWISE_BOOL),
-        LintId::of(needless_continue::NEEDLESS_CONTINUE),
-        LintId::of(needless_for_each::NEEDLESS_FOR_EACH),
-        LintId::of(needless_pass_by_value::NEEDLESS_PASS_BY_VALUE),
-        LintId::of(non_expressive_names::SIMILAR_NAMES),
-        LintId::of(option_if_let_else::OPTION_IF_LET_ELSE),
-        LintId::of(pass_by_ref_or_value::LARGE_TYPES_PASSED_BY_VALUE),
-        LintId::of(pass_by_ref_or_value::TRIVIALLY_COPY_PASS_BY_REF),
-        LintId::of(ranges::RANGE_MINUS_ONE),
-        LintId::of(ranges::RANGE_PLUS_ONE),
-        LintId::of(redundant_else::REDUNDANT_ELSE),
-        LintId::of(ref_option_ref::REF_OPTION_REF),
-        LintId::of(shadow::SHADOW_UNRELATED),
-        LintId::of(strings::STRING_ADD_ASSIGN),
-        LintId::of(trait_bounds::TRAIT_DUPLICATION_IN_BOUNDS),
-        LintId::of(trait_bounds::TYPE_REPETITION_IN_BOUNDS),
-        LintId::of(transmute::TRANSMUTE_PTR_TO_PTR),
-        LintId::of(types::LINKEDLIST),
-        LintId::of(types::OPTION_OPTION),
-        LintId::of(unicode::NON_ASCII_LITERAL),
-        LintId::of(unicode::UNICODE_NOT_NFC),
-        LintId::of(unit_types::LET_UNIT_VALUE),
-        LintId::of(unnecessary_wraps::UNNECESSARY_WRAPS),
-        LintId::of(unnested_or_patterns::UNNESTED_OR_PATTERNS),
-        LintId::of(unused_async::UNUSED_ASYNC),
-        LintId::of(unused_self::UNUSED_SELF),
-        LintId::of(wildcard_imports::ENUM_GLOB_USE),
-        LintId::of(wildcard_imports::WILDCARD_IMPORTS),
-        LintId::of(zero_sized_map_values::ZERO_SIZED_MAP_VALUES),
-    ]);
-
-    #[cfg(feature = "internal-lints")]
-    store.register_group(true, "clippy::internal", Some("clippy_internal"), vec![
-        LintId::of(utils::internal_lints::CLIPPY_LINTS_INTERNAL),
-        LintId::of(utils::internal_lints::COLLAPSIBLE_SPAN_LINT_CALLS),
-        LintId::of(utils::internal_lints::COMPILER_LINT_FUNCTIONS),
-        LintId::of(utils::internal_lints::DEFAULT_LINT),
-        LintId::of(utils::internal_lints::IF_CHAIN_STYLE),
-        LintId::of(utils::internal_lints::INTERNING_DEFINED_SYMBOL),
-        LintId::of(utils::internal_lints::INVALID_PATHS),
-        LintId::of(utils::internal_lints::LINT_WITHOUT_LINT_PASS),
-        LintId::of(utils::internal_lints::MATCH_TYPE_ON_DIAGNOSTIC_ITEM),
-        LintId::of(utils::internal_lints::OUTER_EXPN_EXPN_DATA),
-        LintId::of(utils::internal_lints::PRODUCE_ICE),
-        LintId::of(utils::internal_lints::UNNECESSARY_SYMBOL_STR),
-    ]);
+    #[cfg(feature = "internal-lints")]
+    store.register_group(true, "clippy::internal", Some("clippy_internal"), vec![
+        LintId::of(utils::internal_lints::CLIPPY_LINTS_INTERNAL),
+        LintId::of(utils::internal_lints::COLLAPSIBLE_SPAN_LINT_CALLS),
+        LintId::of(utils::internal_lints::COMPILER_LINT_FUNCTIONS),
+        LintId::of(utils::internal_lints::DEFAULT_LINT),
+        LintId::of(utils::internal_lints::IF_CHAIN_STYLE),
+        LintId::of(utils::internal_lints::INTERNING_DEFINED_SYMBOL),
+        LintId::of(utils::internal_lints::INVALID_PATHS),
+        LintId::of(utils::internal_lints::LINT_WITHOUT_LINT_PASS),
+        LintId::of(utils::internal_lints::MATCH_TYPE_ON_DIAGNOSTIC_ITEM),
+        LintId::of(utils::internal_lints::OUTER_EXPN_EXPN_DATA),
+        LintId::of(utils::internal_lints::PRODUCE_ICE),
+        LintId::of(utils::internal_lints::UNNECESSARY_SYMBOL_STR),
+    ]);
 
     store.register_group(true, "clippy::all", Some("clippy"), vec![
         LintId::of(absurd_extreme_comparisons::ABSURD_EXTREME_COMPARISONS),
@@ -2048,32 +1763,320 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(vec_init_then_push::VEC_INIT_THEN_PUSH),
     ]);
 
-    store.register_group(true, "clippy::cargo", Some("clippy_cargo"), vec![
-        LintId::of(cargo_common_metadata::CARGO_COMMON_METADATA),
-        LintId::of(multiple_crate_versions::MULTIPLE_CRATE_VERSIONS),
-        LintId::of(wildcard_dependencies::WILDCARD_DEPENDENCIES),
-    ]);
+    store.register_group(true, "clippy::cargo", Some("clippy_cargo"), vec![
+        LintId::of(cargo_common_metadata::CARGO_COMMON_METADATA),
+        LintId::of(multiple_crate_versions::MULTIPLE_CRATE_VERSIONS),
+        LintId::of(wildcard_dependencies::WILDCARD_DEPENDENCIES),
+    ]);
+
+    store.register_group(true, "clippy::nursery", Some("clippy_nursery"), vec![
+        LintId::of(attrs::EMPTY_LINE_AFTER_OUTER_ATTR),
+        LintId::of(cognitive_complexity::COGNITIVE_COMPLEXITY),
+        LintId::of(disallowed_method::DISALLOWED_METHOD),
+        LintId::of(fallible_impl_from::FALLIBLE_IMPL_FROM),
+        LintId::of(floating_point_arithmetic::IMPRECISE_FLOPS),
+        LintId::of(floating_point_arithmetic::SUBOPTIMAL_FLOPS),
+        LintId::of(future_not_send::FUTURE_NOT_SEND),
+        LintId::of(let_if_seq::USELESS_LET_IF_SEQ),
+        LintId::of(missing_const_for_fn::MISSING_CONST_FOR_FN),
+        LintId::of(mutable_debug_assertion::DEBUG_ASSERT_WITH_MUT_CALL),
+        LintId::of(mutex_atomic::MUTEX_INTEGER),
+        LintId::of(needless_borrow::NEEDLESS_BORROW),
+        LintId::of(path_buf_push_overwrite::PATH_BUF_PUSH_OVERWRITE),
+        LintId::of(redundant_pub_crate::REDUNDANT_PUB_CRATE),
+        LintId::of(regex::TRIVIAL_REGEX),
+        LintId::of(strings::STRING_LIT_AS_BYTES),
+        LintId::of(transmute::USELESS_TRANSMUTE),
+        LintId::of(use_self::USE_SELF),
+    ]);
+
+    #[cfg(feature = "metadata-collector-lint")]
+    {
+        if std::env::var("ENABLE_METADATA_COLLECTION").eq(&Ok("1".to_string())) {
+            store.register_late_pass(|| box utils::internal_lints::metadata_collector::MetadataCollector::new());
+            return;
+        }
+    }
+
+    // all the internal lints
+    #[cfg(feature = "internal-lints")]
+    {
+        store.register_early_pass(|| box utils::internal_lints::ClippyLintsInternal);
+        store.register_early_pass(|| box utils::internal_lints::ProduceIce);
+        store.register_late_pass(|| box utils::inspector::DeepCodeInspector);
+        store.register_late_pass(|| box utils::internal_lints::CollapsibleCalls);
+        store.register_late_pass(|| box utils::internal_lints::CompilerLintFunctions::new());
+        store.register_late_pass(|| box utils::internal_lints::IfChainStyle);
+        store.register_late_pass(|| box utils::internal_lints::InvalidPaths);
+        store.register_late_pass(|| box utils::internal_lints::InterningDefinedSymbol::default());
+        store.register_late_pass(|| box utils::internal_lints::LintWithoutLintPass::default());
+        store.register_late_pass(|| box utils::internal_lints::MatchTypeOnDiagItem);
+        store.register_late_pass(|| box utils::internal_lints::OuterExpnDataPass);
+    }
+
+    store.register_late_pass(|| box utils::author::Author);
+    store.register_late_pass(|| box await_holding_invalid::AwaitHolding);
+    store.register_late_pass(|| box serde_api::SerdeApi);
+    let vec_box_size_threshold = conf.vec_box_size_threshold;
+    let type_complexity_threshold = conf.type_complexity_threshold;
+    store.register_late_pass(move || box types::Types::new(vec_box_size_threshold, type_complexity_threshold));
+    store.register_late_pass(|| box booleans::NonminimalBool);
+    store.register_late_pass(|| box needless_bitwise_bool::NeedlessBitwiseBool);
+    store.register_late_pass(|| box eq_op::EqOp);
+    store.register_late_pass(|| box enum_clike::UnportableVariant);
+    store.register_late_pass(|| box float_literal::FloatLiteral);
+    let verbose_bit_mask_threshold = conf.verbose_bit_mask_threshold;
+    store.register_late_pass(move || box bit_mask::BitMask::new(verbose_bit_mask_threshold));
+    store.register_late_pass(|| box ptr::Ptr);
+    store.register_late_pass(|| box ptr_eq::PtrEq);
+    store.register_late_pass(|| box needless_bool::NeedlessBool);
+    store.register_late_pass(|| box needless_bool::BoolComparison);
+    store.register_late_pass(|| box needless_for_each::NeedlessForEach);
+    store.register_late_pass(|| box approx_const::ApproxConstant);
+    store.register_late_pass(|| box misc::MiscLints);
+    store.register_late_pass(|| box eta_reduction::EtaReduction);
+    store.register_late_pass(|| box identity_op::IdentityOp);
+    store.register_late_pass(|| box erasing_op::ErasingOp);
+    store.register_late_pass(|| box mut_mut::MutMut);
+    store.register_late_pass(|| box mut_reference::UnnecessaryMutPassed);
+    store.register_late_pass(|| box len_zero::LenZero);
+    store.register_late_pass(|| box attrs::Attributes);
+    store.register_late_pass(|| box blocks_in_if_conditions::BlocksInIfConditions);
+    store.register_late_pass(|| box collapsible_match::CollapsibleMatch);
+    store.register_late_pass(|| box unicode::Unicode);
+    store.register_late_pass(|| box unit_return_expecting_ord::UnitReturnExpectingOrd);
+    store.register_late_pass(|| box strings::StringAdd);
+    store.register_late_pass(|| box implicit_return::ImplicitReturn);
+    store.register_late_pass(|| box implicit_saturating_sub::ImplicitSaturatingSub);
+    store.register_late_pass(|| box default_numeric_fallback::DefaultNumericFallback);
+    store.register_late_pass(|| box inconsistent_struct_constructor::InconsistentStructConstructor);
+    store.register_late_pass(|| box non_octal_unix_permissions::NonOctalUnixPermissions);
+    store.register_early_pass(|| box unnecessary_self_imports::UnnecessarySelfImports);
+
+    let msrv = conf.msrv.as_ref().and_then(|s| {
+        parse_msrv(s, None, None).or_else(|| {
+            sess.err(&format!("error reading Clippy's configuration file. `{}` is not a valid Rust version", s));
+            None
+        })
+    });
+
+    store.register_late_pass(move || box methods::Methods::new(msrv));
+    store.register_late_pass(move || box matches::Matches::new(msrv));
+    store.register_early_pass(move || box manual_non_exhaustive::ManualNonExhaustive::new(msrv));
+    store.register_late_pass(move || box manual_strip::ManualStrip::new(msrv));
+    store.register_early_pass(move || box redundant_static_lifetimes::RedundantStaticLifetimes::new(msrv));
+    store.register_early_pass(move || box redundant_field_names::RedundantFieldNames::new(msrv));
+    store.register_late_pass(move || box checked_conversions::CheckedConversions::new(msrv));
+    store.register_late_pass(move || box mem_replace::MemReplace::new(msrv));
+    store.register_late_pass(move || box ranges::Ranges::new(msrv));
+    store.register_late_pass(move || box from_over_into::FromOverInto::new(msrv));
+    store.register_late_pass(move || box use_self::UseSelf::new(msrv));
+    store.register_late_pass(move || box missing_const_for_fn::MissingConstForFn::new(msrv));
+    store.register_late_pass(move || box needless_question_mark::NeedlessQuestionMark);
+    store.register_late_pass(move || box casts::Casts::new(msrv));
+    store.register_early_pass(move || box unnested_or_patterns::UnnestedOrPatterns::new(msrv));
+
+    store.register_late_pass(|| box size_of_in_element_count::SizeOfInElementCount);
+    store.register_late_pass(|| box map_clone::MapClone);
+    store.register_late_pass(|| box map_err_ignore::MapErrIgnore);
+    store.register_late_pass(|| box shadow::Shadow);
+    store.register_late_pass(|| box unit_types::UnitTypes);
+    store.register_late_pass(|| box loops::Loops);
+    store.register_late_pass(|| box main_recursion::MainRecursion::default());
+    store.register_late_pass(|| box lifetimes::Lifetimes);
+    store.register_late_pass(|| box entry::HashMapPass);
+    store.register_late_pass(|| box minmax::MinMaxPass);
+    store.register_late_pass(|| box open_options::OpenOptions);
+    store.register_late_pass(|| box zero_div_zero::ZeroDiv);
+    store.register_late_pass(|| box mutex_atomic::Mutex);
+    store.register_late_pass(|| box needless_update::NeedlessUpdate);
+    store.register_late_pass(|| box needless_borrow::NeedlessBorrow::default());
+    store.register_late_pass(|| box needless_borrowed_ref::NeedlessBorrowedRef);
+    store.register_late_pass(|| box no_effect::NoEffect);
+    store.register_late_pass(|| box temporary_assignment::TemporaryAssignment);
+    store.register_late_pass(|| box transmute::Transmute);
+    let cognitive_complexity_threshold = conf.cognitive_complexity_threshold;
+    store.register_late_pass(move || box cognitive_complexity::CognitiveComplexity::new(cognitive_complexity_threshold));
+    let too_large_for_stack = conf.too_large_for_stack;
+    store.register_late_pass(move || box escape::BoxedLocal{too_large_for_stack});
+    store.register_late_pass(move || box vec::UselessVec{too_large_for_stack});
+    store.register_late_pass(|| box panic_unimplemented::PanicUnimplemented);
+    store.register_late_pass(|| box strings::StringLitAsBytes);
+    store.register_late_pass(|| box derive::Derive);
+    store.register_late_pass(|| box get_last_with_len::GetLastWithLen);
+    store.register_late_pass(|| box drop_forget_ref::DropForgetRef);
+    store.register_late_pass(|| box empty_enum::EmptyEnum);
+    store.register_late_pass(|| box absurd_extreme_comparisons::AbsurdExtremeComparisons);
+    store.register_late_pass(|| box invalid_upcast_comparisons::InvalidUpcastComparisons);
+    store.register_late_pass(|| box regex::Regex::default());
+    store.register_late_pass(|| box copies::CopyAndPaste);
+    store.register_late_pass(|| box copy_iterator::CopyIterator);
+    store.register_late_pass(|| box format::UselessFormat);
+    store.register_late_pass(|| box swap::Swap);
+    store.register_late_pass(|| box overflow_check_conditional::OverflowCheckConditional);
+    store.register_late_pass(|| box new_without_default::NewWithoutDefault::default());
+    let blacklisted_names = conf.blacklisted_names.iter().cloned().collect::<FxHashSet<_>>();
+    store.register_late_pass(move || box blacklisted_name::BlacklistedName::new(blacklisted_names.clone()));
+    let too_many_arguments_threshold = conf.too_many_arguments_threshold;
+    let too_many_lines_threshold = conf.too_many_lines_threshold;
+    store.register_late_pass(move || box functions::Functions::new(too_many_arguments_threshold, too_many_lines_threshold));
+    let doc_valid_idents = conf.doc_valid_idents.iter().cloned().collect::<FxHashSet<_>>();
+    store.register_late_pass(move || box doc::DocMarkdown::new(doc_valid_idents.clone()));
+    store.register_late_pass(|| box neg_multiply::NegMultiply);
+    store.register_late_pass(|| box mem_discriminant::MemDiscriminant);
+    store.register_late_pass(|| box mem_forget::MemForget);
+    store.register_late_pass(|| box arithmetic::Arithmetic::default());
+    store.register_late_pass(|| box assign_ops::AssignOps);
+    store.register_late_pass(|| box let_if_seq::LetIfSeq);
+    store.register_late_pass(|| box eval_order_dependence::EvalOrderDependence);
+    store.register_late_pass(|| box missing_doc::MissingDoc::new());
+    store.register_late_pass(|| box missing_inline::MissingInline);
+    store.register_late_pass(move || box exhaustive_items::ExhaustiveItems);
+    store.register_late_pass(|| box if_let_some_result::OkIfLet);
+    store.register_late_pass(|| box partialeq_ne_impl::PartialEqNeImpl);
+    store.register_late_pass(|| box unused_io_amount::UnusedIoAmount);
+    let enum_variant_size_threshold = conf.enum_variant_size_threshold;
+    store.register_late_pass(move || box large_enum_variant::LargeEnumVariant::new(enum_variant_size_threshold));
+    store.register_late_pass(|| box explicit_write::ExplicitWrite);
+    store.register_late_pass(|| box needless_pass_by_value::NeedlessPassByValue);
+    let pass_by_ref_or_value = pass_by_ref_or_value::PassByRefOrValue::new(
+        conf.trivial_copy_size_limit,
+        conf.pass_by_value_size_limit,
+        &sess.target,
+    );
+    store.register_late_pass(move || box pass_by_ref_or_value);
+    store.register_late_pass(|| box ref_option_ref::RefOptionRef);
+    store.register_late_pass(|| box try_err::TryErr);
+    store.register_late_pass(|| box bytecount::ByteCount);
+    store.register_late_pass(|| box infinite_iter::InfiniteIter);
+    store.register_late_pass(|| box inline_fn_without_body::InlineFnWithoutBody);
+    store.register_late_pass(|| box useless_conversion::UselessConversion::default());
+    store.register_late_pass(|| box implicit_hasher::ImplicitHasher);
+    store.register_late_pass(|| box fallible_impl_from::FallibleImplFrom);
+    store.register_late_pass(|| box double_comparison::DoubleComparisons);
+    store.register_late_pass(|| box question_mark::QuestionMark);
+    store.register_early_pass(|| box suspicious_operation_groupings::SuspiciousOperationGroupings);
+    store.register_late_pass(|| box suspicious_trait_impl::SuspiciousImpl);
+    store.register_late_pass(|| box map_unit_fn::MapUnit);
+    store.register_late_pass(|| box inherent_impl::MultipleInherentImpl);
+    store.register_late_pass(|| box neg_cmp_op_on_partial_ord::NoNegCompOpForPartialOrd);
+    store.register_late_pass(|| box unwrap::Unwrap);
+    store.register_late_pass(|| box duration_subsec::DurationSubsec);
+    store.register_late_pass(|| box indexing_slicing::IndexingSlicing);
+    store.register_late_pass(|| box non_copy_const::NonCopyConst);
+    store.register_late_pass(|| box ptr_offset_with_cast::PtrOffsetWithCast);
+    store.register_late_pass(|| box redundant_clone::RedundantClone);
+    store.register_late_pass(|| box slow_vector_initialization::SlowVectorInit);
+    store.register_late_pass(|| box unnecessary_sort_by::UnnecessarySortBy);
+    store.register_late_pass(|| box unnecessary_wraps::UnnecessaryWraps);
+    store.register_late_pass(|| box assertions_on_constants::AssertionsOnConstants);
+    store.register_late_pass(|| box transmuting_null::TransmutingNull);
+    store.register_late_pass(|| box path_buf_push_overwrite::PathBufPushOverwrite);
+    store.register_late_pass(|| box integer_division::IntegerDivision);
+    store.register_late_pass(|| box inherent_to_string::InherentToString);
+    let max_trait_bounds = conf.max_trait_bounds;
+    store.register_late_pass(move || box trait_bounds::TraitBounds::new(max_trait_bounds));
+    store.register_late_pass(|| box comparison_chain::ComparisonChain);
+    store.register_late_pass(|| box mut_key::MutableKeyType);
+    store.register_late_pass(|| box modulo_arithmetic::ModuloArithmetic);
+    store.register_early_pass(|| box reference::DerefAddrOf);
+    store.register_early_pass(|| box reference::RefInDeref);
+    store.register_early_pass(|| box double_parens::DoubleParens);
+    store.register_late_pass(|| box to_string_in_display::ToStringInDisplay::new());
+    store.register_early_pass(|| box unsafe_removed_from_name::UnsafeNameRemoval);
+    store.register_early_pass(|| box if_not_else::IfNotElse);
+    store.register_early_pass(|| box else_if_without_else::ElseIfWithoutElse);
+    store.register_early_pass(|| box int_plus_one::IntPlusOne);
+    store.register_early_pass(|| box formatting::Formatting);
+    store.register_early_pass(|| box misc_early::MiscEarlyLints);
+    store.register_early_pass(|| box redundant_closure_call::RedundantClosureCall);
+    store.register_late_pass(|| box redundant_closure_call::RedundantClosureCall);
+    store.register_early_pass(|| box unused_unit::UnusedUnit);
+    store.register_late_pass(|| box returns::Return);
+    store.register_early_pass(|| box collapsible_if::CollapsibleIf);
+    store.register_early_pass(|| box items_after_statements::ItemsAfterStatements);
+    store.register_early_pass(|| box precedence::Precedence);
+    store.register_early_pass(|| box needless_continue::NeedlessContinue);
+    store.register_early_pass(|| box redundant_else::RedundantElse);
+    store.register_late_pass(|| box create_dir::CreateDir);
+    store.register_early_pass(|| box needless_arbitrary_self_type::NeedlessArbitrarySelfType);
+    let cargo_ignore_publish = conf.cargo_ignore_publish;
+    store.register_late_pass(move || box cargo_common_metadata::CargoCommonMetadata::new(cargo_ignore_publish));
+    store.register_late_pass(|| box multiple_crate_versions::MultipleCrateVersions);
+    store.register_late_pass(|| box wildcard_dependencies::WildcardDependencies);
+    let literal_representation_lint_fraction_readability = conf.unreadable_literal_lint_fractions;
+    store.register_early_pass(move || box literal_representation::LiteralDigitGrouping::new(literal_representation_lint_fraction_readability));
+    let literal_representation_threshold = conf.literal_representation_threshold;
+    store.register_early_pass(move || box literal_representation::DecimalLiteralRepresentation::new(literal_representation_threshold));
+    let enum_variant_name_threshold = conf.enum_variant_name_threshold;
+    store.register_early_pass(move || box enum_variants::EnumVariantNames::new(enum_variant_name_threshold));
+    store.register_early_pass(|| box tabs_in_doc_comments::TabsInDocComments);
+    let upper_case_acronyms_aggressive = conf.upper_case_acronyms_aggressive;
+    store.register_early_pass(move || box upper_case_acronyms::UpperCaseAcronyms::new(upper_case_acronyms_aggressive));
+    store.register_late_pass(|| box default::Default::default());
+    store.register_late_pass(|| box unused_self::UnusedSelf);
+    store.register_late_pass(|| box mutable_debug_assertion::DebugAssertWithMutCall);
+    store.register_late_pass(|| box exit::Exit);
+    store.register_late_pass(|| box to_digit_is_some::ToDigitIsSome);
+    let array_size_threshold = conf.array_size_threshold;
+    store.register_late_pass(move || box large_stack_arrays::LargeStackArrays::new(array_size_threshold));
+    store.register_late_pass(move || box large_const_arrays::LargeConstArrays::new(array_size_threshold));
+    store.register_late_pass(|| box floating_point_arithmetic::FloatingPointArithmetic);
+    store.register_early_pass(|| box as_conversions::AsConversions);
+    store.register_late_pass(|| box let_underscore::LetUnderscore);
+    store.register_late_pass(|| box atomic_ordering::AtomicOrdering);
+    store.register_early_pass(|| box single_component_path_imports::SingleComponentPathImports);
+    let max_fn_params_bools = conf.max_fn_params_bools;
+    let max_struct_bools = conf.max_struct_bools;
+    store.register_early_pass(move || box excessive_bools::ExcessiveBools::new(max_struct_bools, max_fn_params_bools));
+    store.register_early_pass(|| box option_env_unwrap::OptionEnvUnwrap);
+    let warn_on_all_wildcard_imports = conf.warn_on_all_wildcard_imports;
+    store.register_late_pass(move || box wildcard_imports::WildcardImports::new(warn_on_all_wildcard_imports));
+    store.register_late_pass(|| box verbose_file_reads::VerboseFileReads);
+    store.register_late_pass(|| box redundant_pub_crate::RedundantPubCrate::default());
+    store.register_late_pass(|| box unnamed_address::UnnamedAddress);
+    store.register_late_pass(|| box dereference::Dereferencing::default());
+    store.register_late_pass(|| box option_if_let_else::OptionIfLetElse);
+    store.register_late_pass(|| box future_not_send::FutureNotSend);
+    store.register_late_pass(|| box if_let_mutex::IfLetMutex);
+    store.register_late_pass(|| box mut_mutex_lock::MutMutexLock);
+    store.register_late_pass(|| box match_on_vec_items::MatchOnVecItems);
+    store.register_late_pass(|| box manual_async_fn::ManualAsyncFn);
+    store.register_late_pass(|| box vec_resize_to_zero::VecResizeToZero);
+    store.register_late_pass(|| box panic_in_result_fn::PanicInResultFn);
+    let single_char_binding_names_threshold = conf.single_char_binding_names_threshold;
+    store.register_early_pass(move || box non_expressive_names::NonExpressiveNames {
+        single_char_binding_names_threshold,
+    });
+    store.register_late_pass(|| box macro_use::MacroUseImports::default());
+    store.register_late_pass(|| box map_identity::MapIdentity);
+    store.register_late_pass(|| box pattern_type_mismatch::PatternTypeMismatch);
+    store.register_late_pass(|| box stable_sort_primitive::StableSortPrimitive);
+    store.register_late_pass(|| box repeat_once::RepeatOnce);
+    store.register_late_pass(|| box unwrap_in_result::UnwrapInResult);
+    store.register_late_pass(|| box self_assignment::SelfAssignment);
+    store.register_late_pass(|| box manual_unwrap_or::ManualUnwrapOr);
+    store.register_late_pass(|| box manual_ok_or::ManualOkOr);
+    store.register_late_pass(|| box float_equality_without_abs::FloatEqualityWithoutAbs);
+    store.register_late_pass(|| box semicolon_if_nothing_returned::SemicolonIfNothingReturned);
+    store.register_late_pass(|| box async_yields_async::AsyncYieldsAsync);
+    let disallowed_methods = conf.disallowed_methods.iter().cloned().collect::<FxHashSet<_>>();
+    store.register_late_pass(move || box disallowed_method::DisallowedMethod::new(&disallowed_methods));
+    store.register_early_pass(|| box asm_syntax::InlineAsmX86AttSyntax);
+    store.register_early_pass(|| box asm_syntax::InlineAsmX86IntelSyntax);
+    store.register_late_pass(|| box undropped_manually_drops::UndroppedManuallyDrops);
+    store.register_late_pass(|| box strings::StrToString);
+    store.register_late_pass(|| box strings::StringToString);
+    store.register_late_pass(|| box zero_sized_map_values::ZeroSizedMapValues);
+    store.register_late_pass(|| box vec_init_then_push::VecInitThenPush::default());
+    store.register_late_pass(|| box case_sensitive_file_extension_comparisons::CaseSensitiveFileExtensionComparisons);
+    store.register_late_pass(|| box redundant_slicing::RedundantSlicing);
+    store.register_late_pass(|| box from_str_radix_10::FromStrRadix10);
+    store.register_late_pass(|| box manual_map::ManualMap);
+    store.register_late_pass(move || box if_then_some_else_none::IfThenSomeElseNone::new(msrv));
+    store.register_early_pass(|| box bool_assert_comparison::BoolAssertComparison);
+    store.register_late_pass(|| box unused_async::UnusedAsync);
 
-    store.register_group(true, "clippy::nursery", Some("clippy_nursery"), vec![
-        LintId::of(attrs::EMPTY_LINE_AFTER_OUTER_ATTR),
-        LintId::of(cognitive_complexity::COGNITIVE_COMPLEXITY),
-        LintId::of(disallowed_method::DISALLOWED_METHOD),
-        LintId::of(fallible_impl_from::FALLIBLE_IMPL_FROM),
-        LintId::of(floating_point_arithmetic::IMPRECISE_FLOPS),
-        LintId::of(floating_point_arithmetic::SUBOPTIMAL_FLOPS),
-        LintId::of(future_not_send::FUTURE_NOT_SEND),
-        LintId::of(let_if_seq::USELESS_LET_IF_SEQ),
-        LintId::of(missing_const_for_fn::MISSING_CONST_FOR_FN),
-        LintId::of(mutable_debug_assertion::DEBUG_ASSERT_WITH_MUT_CALL),
-        LintId::of(mutex_atomic::MUTEX_INTEGER),
-        LintId::of(needless_borrow::NEEDLESS_BORROW),
-        LintId::of(path_buf_push_overwrite::PATH_BUF_PUSH_OVERWRITE),
-        LintId::of(redundant_pub_crate::REDUNDANT_PUB_CRATE),
-        LintId::of(regex::TRIVIAL_REGEX),
-        LintId::of(strings::STRING_LIT_AS_BYTES),
-        LintId::of(transmute::USELESS_TRANSMUTE),
-        LintId::of(use_self::USE_SELF),
-    ]);
 }
 
 #[rustfmt::skip]
-- 
cgit 1.4.1-3-g733a5


From 6e03a306ac44c6670064c68197df8813fe1cac06 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sat, 17 Apr 2021 20:46:13 -0400
Subject: Remove fix for rustc bug from `needless_borrow` The spans given for
 derived traits used to not indicate they were from a macro expansion.

---
 clippy_lints/src/lib.rs             |  2 +-
 clippy_lints/src/needless_borrow.rs | 28 ++++------------------------
 2 files changed, 5 insertions(+), 25 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index d1c129eba82..5cd7d5f14e3 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1890,7 +1890,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box zero_div_zero::ZeroDiv);
     store.register_late_pass(|| box mutex_atomic::Mutex);
     store.register_late_pass(|| box needless_update::NeedlessUpdate);
-    store.register_late_pass(|| box needless_borrow::NeedlessBorrow::default());
+    store.register_late_pass(|| box needless_borrow::NeedlessBorrow);
     store.register_late_pass(|| box needless_borrowed_ref::NeedlessBorrowedRef);
     store.register_late_pass(|| box no_effect::NoEffect);
     store.register_late_pass(|| box temporary_assignment::TemporaryAssignment);
diff --git a/clippy_lints/src/needless_borrow.rs b/clippy_lints/src/needless_borrow.rs
index eef3c16730b..3adbbfb8e89 100644
--- a/clippy_lints/src/needless_borrow.rs
+++ b/clippy_lints/src/needless_borrow.rs
@@ -3,16 +3,14 @@
 //! This lint is **warn** by default
 
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::is_automatically_derived;
 use clippy_utils::source::snippet_opt;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
-use rustc_hir::{BindingAnnotation, BorrowKind, Expr, ExprKind, Item, Mutability, Pat, PatKind};
+use rustc_hir::{BindingAnnotation, BorrowKind, Expr, ExprKind, Mutability, Pat, PatKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
 use rustc_middle::ty::adjustment::{Adjust, Adjustment};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::def_id::LocalDefId;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for address of operations (`&`) that are going to
@@ -37,15 +35,13 @@ declare_clippy_lint! {
 }
 
 #[derive(Default)]
-pub struct NeedlessBorrow {
-    derived_item: Option<LocalDefId>,
-}
+pub struct NeedlessBorrow;
 
 impl_lint_pass!(NeedlessBorrow => [NEEDLESS_BORROW]);
 
 impl<'tcx> LateLintPass<'tcx> for NeedlessBorrow {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
-        if e.span.from_expansion() || self.derived_item.is_some() {
+        if e.span.from_expansion() {
             return;
         }
         if let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Not, inner) = e.kind {
@@ -86,7 +82,7 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessBorrow {
         }
     }
     fn check_pat(&mut self, cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>) {
-        if pat.span.from_expansion() || self.derived_item.is_some() {
+        if pat.span.from_expansion() {
             return;
         }
         if_chain! {
@@ -116,20 +112,4 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessBorrow {
             }
         }
     }
-
-    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
-        let attrs = cx.tcx.hir().attrs(item.hir_id());
-        if is_automatically_derived(attrs) {
-            debug_assert!(self.derived_item.is_none());
-            self.derived_item = Some(item.def_id);
-        }
-    }
-
-    fn check_item_post(&mut self, _: &LateContext<'tcx>, item: &'tcx Item<'_>) {
-        if let Some(id) = self.derived_item {
-            if item.def_id == id {
-                self.derived_item = None;
-            }
-        }
-    }
 }
-- 
cgit 1.4.1-3-g733a5


From 6d4dc35882a55610e9da81237d62bea1c0c1634e Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sat, 17 Apr 2021 20:35:39 -0400
Subject: Improve `needless_borrow` lint Suggest changing usages of ref
 bindings to match the new type Split out some cases into new lint
 `ref_binding_to_reference`

---
 CHANGELOG.md                             |   1 +
 clippy_lints/src/lib.rs                  |   4 +-
 clippy_lints/src/needless_borrow.rs      | 203 +++++++++++++++++++++++++++----
 clippy_utils/src/higher.rs               |   2 +-
 clippy_utils/src/lib.rs                  |   4 +-
 clippy_utils/src/visitors.rs             |  37 ++----
 tests/ui/needless_borrow.fixed           |  17 ---
 tests/ui/needless_borrow.rs              |  17 ---
 tests/ui/needless_borrow.stderr          |  16 +--
 tests/ui/needless_borrow_pat.rs          | 151 +++++++++++++++++++++++
 tests/ui/needless_borrow_pat.stderr      | 112 +++++++++++++++++
 tests/ui/ref_binding_to_reference.rs     |  76 ++++++++++++
 tests/ui/ref_binding_to_reference.stderr |  88 ++++++++++++++
 13 files changed, 626 insertions(+), 102 deletions(-)
 create mode 100644 tests/ui/needless_borrow_pat.rs
 create mode 100644 tests/ui/needless_borrow_pat.stderr
 create mode 100644 tests/ui/ref_binding_to_reference.rs
 create mode 100644 tests/ui/ref_binding_to_reference.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index da5a0712c95..abfe7f91f4b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2622,6 +2622,7 @@ Released 2018-09-13
 [`redundant_pub_crate`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_pub_crate
 [`redundant_slicing`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_slicing
 [`redundant_static_lifetimes`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_static_lifetimes
+[`ref_binding_to_reference`]: https://rust-lang.github.io/rust-clippy/master/index.html#ref_binding_to_reference
 [`ref_in_deref`]: https://rust-lang.github.io/rust-clippy/master/index.html#ref_in_deref
 [`ref_option_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#ref_option_ref
 [`regex_macro`]: https://rust-lang.github.io/rust-clippy/master/index.html#regex_macro
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 5cd7d5f14e3..a263e8b0ca4 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -841,6 +841,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         needless_bool::BOOL_COMPARISON,
         needless_bool::NEEDLESS_BOOL,
         needless_borrow::NEEDLESS_BORROW,
+        needless_borrow::REF_BINDING_TO_REFERENCE,
         needless_borrowed_ref::NEEDLESS_BORROWED_REFERENCE,
         needless_continue::NEEDLESS_CONTINUE,
         needless_for_each::NEEDLESS_FOR_EACH,
@@ -1116,6 +1117,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(misc_early::UNSEPARATED_LITERAL_SUFFIX),
         LintId::of(mut_mut::MUT_MUT),
         LintId::of(needless_bitwise_bool::NEEDLESS_BITWISE_BOOL),
+        LintId::of(needless_borrow::REF_BINDING_TO_REFERENCE),
         LintId::of(needless_continue::NEEDLESS_CONTINUE),
         LintId::of(needless_for_each::NEEDLESS_FOR_EACH),
         LintId::of(needless_pass_by_value::NEEDLESS_PASS_BY_VALUE),
@@ -1890,7 +1892,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box zero_div_zero::ZeroDiv);
     store.register_late_pass(|| box mutex_atomic::Mutex);
     store.register_late_pass(|| box needless_update::NeedlessUpdate);
-    store.register_late_pass(|| box needless_borrow::NeedlessBorrow);
+    store.register_late_pass(|| box needless_borrow::NeedlessBorrow::default());
     store.register_late_pass(|| box needless_borrowed_ref::NeedlessBorrowedRef);
     store.register_late_pass(|| box no_effect::NoEffect);
     store.register_late_pass(|| box temporary_assignment::TemporaryAssignment);
diff --git a/clippy_lints/src/needless_borrow.rs b/clippy_lints/src/needless_borrow.rs
index 3adbbfb8e89..965b131770e 100644
--- a/clippy_lints/src/needless_borrow.rs
+++ b/clippy_lints/src/needless_borrow.rs
@@ -3,14 +3,18 @@
 //! This lint is **warn** by default
 
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::source::snippet_opt;
+use clippy_utils::source::{snippet_opt, snippet_with_applicability, snippet_with_context};
+use clippy_utils::{get_parent_expr, in_macro, path_to_local};
 use if_chain::if_chain;
+use rustc_ast::util::parser::PREC_POSTFIX;
+use rustc_data_structures::fx::FxIndexMap;
 use rustc_errors::Applicability;
-use rustc_hir::{BindingAnnotation, BorrowKind, Expr, ExprKind, Mutability, Pat, PatKind};
+use rustc_hir::{BindingAnnotation, Body, BodyId, BorrowKind, Expr, ExprKind, HirId, Mutability, Pat, PatKind, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
 use rustc_middle::ty::adjustment::{Adjust, Adjustment};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::Span;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for address of operations (`&`) that are going to
@@ -34,13 +38,65 @@ declare_clippy_lint! {
     "taking a reference that is going to be automatically dereferenced"
 }
 
+declare_clippy_lint! {
+    /// **What it does:** Checks for `ref` bindings which create a reference to a reference.
+    ///
+    /// **Why is this bad?** The address-of operator at the use site is clearer about the need for a reference.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// ```rust
+    /// // Bad
+    /// let x = Some("");
+    /// if let Some(ref x) = x {
+    ///     // use `x` here
+    /// }
+    ///
+    /// // Good
+    /// let x = Some("");
+    /// if let Some(x) = x {
+    ///     // use `&x` here
+    /// }
+    /// ```
+    pub REF_BINDING_TO_REFERENCE,
+    pedantic,
+    "`ref` binding to a reference"
+}
+
+impl_lint_pass!(NeedlessBorrow => [NEEDLESS_BORROW, REF_BINDING_TO_REFERENCE]);
 #[derive(Default)]
-pub struct NeedlessBorrow;
+pub struct NeedlessBorrow {
+    /// The body the first local was found in. Used to emit lints when the traversal of the body has
+    /// been finished. Note we can't lint at the end of every body as they can be nested within each
+    /// other.
+    current_body: Option<BodyId>,
+    /// The list of locals currently being checked by the lint.
+    /// If the value is `None`, then the binding has been seen as a ref pattern, but is not linted.
+    /// This is needed for or patterns where one of the branches can be linted, but another can not
+    /// be.
+    ///
+    /// e.g. `m!(x) | Foo::Bar(ref x)`
+    ref_locals: FxIndexMap<HirId, Option<RefPat>>,
+}
 
-impl_lint_pass!(NeedlessBorrow => [NEEDLESS_BORROW]);
+struct RefPat {
+    /// Whether every usage of the binding is dereferenced.
+    always_deref: bool,
+    /// The spans of all the ref bindings for this local.
+    spans: Vec<Span>,
+    /// The applicability of this suggestion.
+    app: Applicability,
+    /// All the replacements which need to be made.
+    replacements: Vec<(Span, String)>,
+}
 
 impl<'tcx> LateLintPass<'tcx> for NeedlessBorrow {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
+        if let Some(local) = path_to_local(e) {
+            self.check_local_usage(cx, e, local);
+        }
+
         if e.span.from_expansion() {
             return;
         }
@@ -81,35 +137,132 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessBorrow {
             }
         }
     }
+
     fn check_pat(&mut self, cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>) {
-        if pat.span.from_expansion() {
-            return;
+        if let PatKind::Binding(BindingAnnotation::Ref, id, name, _) = pat.kind {
+            if let Some(opt_prev_pat) = self.ref_locals.get_mut(&id) {
+                // This binding id has been seen before. Add this pattern to the list of changes.
+                if let Some(prev_pat) = opt_prev_pat {
+                    if in_macro(pat.span) {
+                        // Doesn't match the context of the previous pattern. Can't lint here.
+                        *opt_prev_pat = None;
+                    } else {
+                        prev_pat.spans.push(pat.span);
+                        prev_pat.replacements.push((
+                            pat.span,
+                            snippet_with_context(cx, name.span, pat.span.ctxt(), "..", &mut prev_pat.app)
+                                .0
+                                .into(),
+                        ));
+                    }
+                }
+                return;
+            }
+
+            if_chain! {
+                if !in_macro(pat.span);
+                if let ty::Ref(_, tam, _) = *cx.typeck_results().pat_ty(pat).kind();
+                // only lint immutable refs, because borrowed `&mut T` cannot be moved out
+                if let ty::Ref(_, _, Mutability::Not) = *tam.kind();
+                then {
+                    let mut app = Applicability::MachineApplicable;
+                    let snip = snippet_with_context(cx, name.span, pat.span.ctxt(), "..", &mut app).0;
+                    self.current_body = self.current_body.or(cx.enclosing_body);
+                    self.ref_locals.insert(
+                        id,
+                        Some(RefPat {
+                            always_deref: true,
+                            spans: vec![pat.span],
+                            app,
+                            replacements: vec![(pat.span, snip.into())],
+                        }),
+                    );
+                }
+            }
         }
-        if_chain! {
-            if let PatKind::Binding(BindingAnnotation::Ref, .., name, _) = pat.kind;
-            if let ty::Ref(_, tam, mutbl) = *cx.typeck_results().pat_ty(pat).kind();
-            if mutbl == Mutability::Not;
-            if let ty::Ref(_, _, mutbl) = *tam.kind();
-            // only lint immutable refs, because borrowed `&mut T` cannot be moved out
-            if mutbl == Mutability::Not;
-            then {
+    }
+
+    fn check_body_post(&mut self, cx: &LateContext<'tcx>, body: &'tcx Body<'_>) {
+        if Some(body.id()) == self.current_body {
+            for pat in self.ref_locals.drain(..).filter_map(|(_, x)| x) {
+                let replacements = pat.replacements;
+                let app = pat.app;
                 span_lint_and_then(
                     cx,
-                    NEEDLESS_BORROW,
-                    pat.span,
+                    if pat.always_deref {
+                        NEEDLESS_BORROW
+                    } else {
+                        REF_BINDING_TO_REFERENCE
+                    },
+                    pat.spans,
                     "this pattern creates a reference to a reference",
                     |diag| {
-                        if let Some(snippet) = snippet_opt(cx, name.span) {
-                            diag.span_suggestion(
-                                pat.span,
-                                "change this to",
-                                snippet,
-                                Applicability::MachineApplicable,
-                            );
-                        }
-                    }
+                        diag.multipart_suggestion("try this", replacements, app);
+                    },
                 )
             }
+            self.current_body = None;
+        }
+    }
+}
+impl NeedlessBorrow {
+    fn check_local_usage(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>, local: HirId) {
+        if let Some(outer_pat) = self.ref_locals.get_mut(&local) {
+            if let Some(pat) = outer_pat {
+                // Check for auto-deref
+                if !matches!(
+                    cx.typeck_results().expr_adjustments(e),
+                    [
+                        Adjustment {
+                            kind: Adjust::Deref(_),
+                            ..
+                        },
+                        Adjustment {
+                            kind: Adjust::Deref(_),
+                            ..
+                        },
+                        ..
+                    ]
+                ) {
+                    match get_parent_expr(cx, e) {
+                        // Field accesses are the same no matter the number of references.
+                        Some(Expr {
+                            kind: ExprKind::Field(..),
+                            ..
+                        }) => (),
+                        Some(&Expr {
+                            span,
+                            kind: ExprKind::Unary(UnOp::Deref, _),
+                            ..
+                        }) if !in_macro(span) => {
+                            // Remove explicit deref.
+                            let snip = snippet_with_context(cx, e.span, span.ctxt(), "..", &mut pat.app).0;
+                            pat.replacements.push((span, snip.into()));
+                        },
+                        Some(parent) if !in_macro(parent.span) => {
+                            // Double reference might be needed at this point.
+                            if parent.precedence().order() == PREC_POSTFIX {
+                                // Parentheses would be needed here, don't lint.
+                                *outer_pat = None;
+                            } else {
+                                pat.always_deref = false;
+                                let snip = snippet_with_context(cx, e.span, parent.span.ctxt(), "..", &mut pat.app).0;
+                                pat.replacements.push((e.span, format!("&{}", snip)));
+                            }
+                        },
+                        _ if !in_macro(e.span) => {
+                            // Double reference might be needed at this point.
+                            pat.always_deref = false;
+                            let snip = snippet_with_applicability(cx, e.span, "..", &mut pat.app);
+                            pat.replacements.push((e.span, format!("&{}", snip)));
+                        },
+                        // Edge case for macros. The span of the identifier will usually match the context of the
+                        // binding, but not if the identifier was created in a macro. e.g. `concat_idents` and proc
+                        // macros
+                        _ => *outer_pat = None,
+                    }
+                }
+            }
         }
     }
 }
diff --git a/clippy_utils/src/higher.rs b/clippy_utils/src/higher.rs
index 0c0e4d3b4ce..25b4491616c 100644
--- a/clippy_utils/src/higher.rs
+++ b/clippy_utils/src/higher.rs
@@ -70,7 +70,7 @@ pub fn range<'a>(expr: &'a hir::Expr<'_>) -> Option<Range<'a>> {
                 limits: ast::RangeLimits::Closed,
             })
         },
-        hir::ExprKind::Struct(ref path, ref fields, None) => match path {
+        hir::ExprKind::Struct(path, ref fields, None) => match path {
             hir::QPath::LangItem(hir::LangItem::RangeFull, _) => Some(Range {
                 start: None,
                 end: None,
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 82250151aab..2b9b214daa7 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -1254,12 +1254,12 @@ pub fn match_function_call<'tcx>(
     path: &[&str],
 ) -> Option<&'tcx [Expr<'tcx>]> {
     if_chain! {
-        if let ExprKind::Call(ref fun, ref args) = expr.kind;
+        if let ExprKind::Call(ref fun, args) = expr.kind;
         if let ExprKind::Path(ref qpath) = fun.kind;
         if let Some(fun_def_id) = cx.qpath_res(qpath, fun.hir_id).opt_def_id();
         if match_def_path(cx, fun_def_id, path);
         then {
-            return Some(&args)
+            return Some(args)
         }
     };
     None
diff --git a/clippy_utils/src/visitors.rs b/clippy_utils/src/visitors.rs
index ecdc666b5f6..73f132eef4d 100644
--- a/clippy_utils/src/visitors.rs
+++ b/clippy_utils/src/visitors.rs
@@ -189,34 +189,21 @@ impl<'v> Visitor<'v> for LocalUsedVisitor<'v> {
     }
 }
 
+/// A type which can be visited.
 pub trait Visitable<'tcx> {
-    fn visit<V: Visitor<'tcx>>(self, v: &mut V);
+    /// Calls the corresponding `visit_*` function on the visitor.
+    fn visit<V: Visitor<'tcx>>(self, visitor: &mut V);
 }
-impl Visitable<'tcx> for &'tcx Expr<'tcx> {
-    fn visit<V: Visitor<'tcx>>(self, v: &mut V) {
-        v.visit_expr(self)
-    }
-}
-impl Visitable<'tcx> for &'tcx Block<'tcx> {
-    fn visit<V: Visitor<'tcx>>(self, v: &mut V) {
-        v.visit_block(self)
-    }
-}
-impl<'tcx> Visitable<'tcx> for &'tcx Stmt<'tcx> {
-    fn visit<V: Visitor<'tcx>>(self, v: &mut V) {
-        v.visit_stmt(self)
-    }
-}
-impl<'tcx> Visitable<'tcx> for &'tcx Body<'tcx> {
-    fn visit<V: Visitor<'tcx>>(self, v: &mut V) {
-        v.visit_body(self)
-    }
-}
-impl<'tcx> Visitable<'tcx> for &'tcx Arm<'tcx> {
-    fn visit<V: Visitor<'tcx>>(self, v: &mut V) {
-        v.visit_arm(self)
-    }
+macro_rules! visitable_ref {
+    ($t:ident, $f:ident) => {
+        impl Visitable<'tcx> for &'tcx $t<'tcx> {
+            fn visit<V: Visitor<'tcx>>(self, visitor: &mut V) {
+                visitor.$f(self);
+            }
+        }
+    };
 }
+visitable_ref!(Block, visit_block);
 
 /// Calls the given function for each break expression.
 pub fn visit_break_exprs<'tcx>(
diff --git a/tests/ui/needless_borrow.fixed b/tests/ui/needless_borrow.fixed
index 5ae4a0e79b9..a87171dc3f2 100644
--- a/tests/ui/needless_borrow.fixed
+++ b/tests/ui/needless_borrow.fixed
@@ -18,7 +18,6 @@ fn main() {
     let vec = Vec::new();
     let vec_val = g(&vec); // should not error, because `&Vec<T>` derefs to `&[T]`
     h(&"foo"); // should not error, because the `&&str` is required, due to `&Trait`
-    if let Some(cake) = Some(&5) {}
     let garbl = match 42 {
         44 => &a,
         45 => {
@@ -43,19 +42,3 @@ trait Trait {}
 impl<'a> Trait for &'a str {}
 
 fn h(_: &dyn Trait) {}
-#[warn(clippy::needless_borrow)]
-#[allow(dead_code)]
-fn issue_1432() {
-    let mut v = Vec::<String>::new();
-    let _ = v.iter_mut().filter(|&ref a| a.is_empty());
-    let _ = v.iter().filter(|&a| a.is_empty());
-
-    let _ = v.iter().filter(|&a| a.is_empty());
-}
-
-#[allow(dead_code)]
-#[warn(clippy::needless_borrow)]
-#[derive(Debug)]
-enum Foo<'a> {
-    Str(&'a str),
-}
diff --git a/tests/ui/needless_borrow.rs b/tests/ui/needless_borrow.rs
index 1e281316c8a..059dc8ceac3 100644
--- a/tests/ui/needless_borrow.rs
+++ b/tests/ui/needless_borrow.rs
@@ -18,7 +18,6 @@ fn main() {
     let vec = Vec::new();
     let vec_val = g(&vec); // should not error, because `&Vec<T>` derefs to `&[T]`
     h(&"foo"); // should not error, because the `&&str` is required, due to `&Trait`
-    if let Some(ref cake) = Some(&5) {}
     let garbl = match 42 {
         44 => &a,
         45 => {
@@ -43,19 +42,3 @@ trait Trait {}
 impl<'a> Trait for &'a str {}
 
 fn h(_: &dyn Trait) {}
-#[warn(clippy::needless_borrow)]
-#[allow(dead_code)]
-fn issue_1432() {
-    let mut v = Vec::<String>::new();
-    let _ = v.iter_mut().filter(|&ref a| a.is_empty());
-    let _ = v.iter().filter(|&ref a| a.is_empty());
-
-    let _ = v.iter().filter(|&a| a.is_empty());
-}
-
-#[allow(dead_code)]
-#[warn(clippy::needless_borrow)]
-#[derive(Debug)]
-enum Foo<'a> {
-    Str(&'a str),
-}
diff --git a/tests/ui/needless_borrow.stderr b/tests/ui/needless_borrow.stderr
index bea4b41b803..6eddf26db06 100644
--- a/tests/ui/needless_borrow.stderr
+++ b/tests/ui/needless_borrow.stderr
@@ -6,23 +6,11 @@ LL |     let c = x(&&a);
    |
    = note: `-D clippy::needless-borrow` implied by `-D warnings`
 
-error: this pattern creates a reference to a reference
-  --> $DIR/needless_borrow.rs:21:17
-   |
-LL |     if let Some(ref cake) = Some(&5) {}
-   |                 ^^^^^^^^ help: change this to: `cake`
-
 error: this expression borrows a reference (`&i32`) that is immediately dereferenced by the compiler
-  --> $DIR/needless_borrow.rs:28:15
+  --> $DIR/needless_borrow.rs:27:15
    |
 LL |         46 => &&a,
    |               ^^^ help: change this to: `&a`
 
-error: this pattern creates a reference to a reference
-  --> $DIR/needless_borrow.rs:51:31
-   |
-LL |     let _ = v.iter().filter(|&ref a| a.is_empty());
-   |                               ^^^^^ help: change this to: `a`
-
-error: aborting due to 4 previous errors
+error: aborting due to 2 previous errors
 
diff --git a/tests/ui/needless_borrow_pat.rs b/tests/ui/needless_borrow_pat.rs
new file mode 100644
index 00000000000..f0926220755
--- /dev/null
+++ b/tests/ui/needless_borrow_pat.rs
@@ -0,0 +1,151 @@
+// edition:2018
+// FIXME: run-rustfix waiting on multi-span suggestions
+
+#![warn(clippy::needless_borrow)]
+#![allow(clippy::needless_borrowed_reference)]
+
+fn f1(_: &str) {}
+macro_rules! m1 {
+    ($e:expr) => {
+        f1($e);
+    };
+}
+macro_rules! m3 {
+    ($i:ident) => {
+        Some(ref $i)
+    };
+}
+macro_rules! if_chain {
+    (if $e:expr; $($rest:tt)*) => {
+        if $e {
+            if_chain!($($rest)*)
+        }
+    };
+
+    (if let $p:pat = $e:expr; $($rest:tt)*) => {
+        if let $p = $e {
+            if_chain!($($rest)*)
+        }
+    };
+
+    (then $b:block) => {
+        $b
+    };
+}
+
+#[allow(dead_code)]
+fn main() {
+    let x = String::new();
+
+    // Ok, reference to a String.
+    let _: &String = match Some(x.clone()) {
+        Some(ref x) => x,
+        None => return,
+    };
+
+    // Ok, reference to a &mut String
+    let _: &&mut String = match Some(&mut x.clone()) {
+        Some(ref x) => x,
+        None => return,
+    };
+
+    // Ok, the pattern is from a macro
+    let _: &String = match Some(&x) {
+        m3!(x) => x,
+        None => return,
+    };
+
+    // Err, reference to a &String
+    let _: &String = match Some(&x) {
+        Some(ref x) => x,
+        None => return,
+    };
+
+    // Err, reference to a &String.
+    let _: &String = match Some(&x) {
+        Some(ref x) => *x,
+        None => return,
+    };
+
+    // Err, reference to a &String
+    let _: &String = match Some(&x) {
+        Some(ref x) => {
+            f1(x);
+            f1(*x);
+            x
+        },
+        None => return,
+    };
+
+    // Err, reference to a &String
+    match Some(&x) {
+        Some(ref x) => m1!(x),
+        None => return,
+    };
+
+    // Err, reference to a &String
+    let _ = |&ref x: &&String| {
+        let _: &String = x;
+    };
+
+    // Err, reference to a &String
+    let (ref y,) = (&x,);
+    let _: &String = *y;
+
+    let y = &&x;
+    // Ok, different y
+    let _: &String = *y;
+
+    let x = (0, 0);
+    // Err, reference to a &u32. Don't suggest adding a reference to the field access.
+    let _: u32 = match Some(&x) {
+        Some(ref x) => x.0,
+        None => return,
+    };
+
+    enum E {
+        A(&'static u32),
+        B(&'static u32),
+    }
+    // Err, reference to &u32.
+    let _: &u32 = match E::A(&0) {
+        E::A(ref x) | E::B(ref x) => *x,
+    };
+
+    // Err, reference to &String.
+    if_chain! {
+        if true;
+        if let Some(ref x) = Some(&String::new());
+        then {
+            f1(x);
+        }
+    }
+}
+
+// Err, reference to a &String
+fn f2<'a>(&ref x: &&'a String) -> &'a String {
+    let _: &String = x;
+    *x
+}
+
+trait T1 {
+    // Err, reference to a &String
+    fn f(&ref x: &&String) {
+        let _: &String = x;
+    }
+}
+
+struct S;
+impl T1 for S {
+    // Err, reference to a &String
+    fn f(&ref x: &&String) {
+        let _: &String = *x;
+    }
+}
+
+// Ok - used to error due to rustc bug
+#[allow(dead_code)]
+#[derive(Debug)]
+enum Foo<'a> {
+    Str(&'a str),
+}
diff --git a/tests/ui/needless_borrow_pat.stderr b/tests/ui/needless_borrow_pat.stderr
new file mode 100644
index 00000000000..32913d59f7a
--- /dev/null
+++ b/tests/ui/needless_borrow_pat.stderr
@@ -0,0 +1,112 @@
+error: this pattern creates a reference to a reference
+  --> $DIR/needless_borrow_pat.rs:60:14
+   |
+LL |         Some(ref x) => x,
+   |              ^^^^^ help: try this: `x`
+   |
+   = note: `-D clippy::needless-borrow` implied by `-D warnings`
+
+error: this pattern creates a reference to a reference
+  --> $DIR/needless_borrow_pat.rs:66:14
+   |
+LL |         Some(ref x) => *x,
+   |              ^^^^^
+   |
+help: try this
+   |
+LL |         Some(x) => x,
+   |              ^     ^
+
+error: this pattern creates a reference to a reference
+  --> $DIR/needless_borrow_pat.rs:72:14
+   |
+LL |         Some(ref x) => {
+   |              ^^^^^
+   |
+help: try this
+   |
+LL |         Some(x) => {
+LL |             f1(x);
+LL |             f1(x);
+   |
+
+error: this pattern creates a reference to a reference
+  --> $DIR/needless_borrow_pat.rs:82:14
+   |
+LL |         Some(ref x) => m1!(x),
+   |              ^^^^^ help: try this: `x`
+
+error: this pattern creates a reference to a reference
+  --> $DIR/needless_borrow_pat.rs:87:15
+   |
+LL |     let _ = |&ref x: &&String| {
+   |               ^^^^^ help: try this: `x`
+
+error: this pattern creates a reference to a reference
+  --> $DIR/needless_borrow_pat.rs:92:10
+   |
+LL |     let (ref y,) = (&x,);
+   |          ^^^^^
+   |
+help: try this
+   |
+LL |     let (y,) = (&x,);
+LL |     let _: &String = y;
+   |
+
+error: this pattern creates a reference to a reference
+  --> $DIR/needless_borrow_pat.rs:102:14
+   |
+LL |         Some(ref x) => x.0,
+   |              ^^^^^ help: try this: `x`
+
+error: this pattern creates a reference to a reference
+  --> $DIR/needless_borrow_pat.rs:112:14
+   |
+LL |         E::A(ref x) | E::B(ref x) => *x,
+   |              ^^^^^         ^^^^^
+   |
+help: try this
+   |
+LL |         E::A(x) | E::B(x) => x,
+   |              ^         ^     ^
+
+error: this pattern creates a reference to a reference
+  --> $DIR/needless_borrow_pat.rs:118:21
+   |
+LL |         if let Some(ref x) = Some(&String::new());
+   |                     ^^^^^ help: try this: `x`
+
+error: this pattern creates a reference to a reference
+  --> $DIR/needless_borrow_pat.rs:126:12
+   |
+LL | fn f2<'a>(&ref x: &&'a String) -> &'a String {
+   |            ^^^^^
+   |
+help: try this
+   |
+LL | fn f2<'a>(&x: &&'a String) -> &'a String {
+LL |     let _: &String = x;
+LL |     x
+   |
+
+error: this pattern creates a reference to a reference
+  --> $DIR/needless_borrow_pat.rs:133:11
+   |
+LL |     fn f(&ref x: &&String) {
+   |           ^^^^^ help: try this: `x`
+
+error: this pattern creates a reference to a reference
+  --> $DIR/needless_borrow_pat.rs:141:11
+   |
+LL |     fn f(&ref x: &&String) {
+   |           ^^^^^
+   |
+help: try this
+   |
+LL |     fn f(&x: &&String) {
+LL |         let _: &String = x;
+   |
+
+error: aborting due to 12 previous errors
+
diff --git a/tests/ui/ref_binding_to_reference.rs b/tests/ui/ref_binding_to_reference.rs
new file mode 100644
index 00000000000..c7235e1c221
--- /dev/null
+++ b/tests/ui/ref_binding_to_reference.rs
@@ -0,0 +1,76 @@
+// edition:2018
+// FIXME: run-rustfix waiting on multi-span suggestions
+
+#![warn(clippy::ref_binding_to_reference)]
+#![allow(clippy::needless_borrowed_reference)]
+
+fn f1(_: &str) {}
+macro_rules! m2 {
+    ($e:expr) => {
+        f1(*$e);
+    };
+}
+macro_rules! m3 {
+    ($i:ident) => {
+        Some(ref $i)
+    };
+}
+
+#[allow(dead_code)]
+fn main() {
+    let x = String::new();
+
+    // Ok, the pattern is from a macro
+    let _: &&String = match Some(&x) {
+        m3!(x) => x,
+        None => return,
+    };
+
+    // Err, reference to a &String
+    let _: &&String = match Some(&x) {
+        Some(ref x) => x,
+        None => return,
+    };
+
+    // Err, reference to a &String
+    let _: &&String = match Some(&x) {
+        Some(ref x) => {
+            f1(x);
+            f1(*x);
+            x
+        },
+        None => return,
+    };
+
+    // Err, reference to a &String
+    match Some(&x) {
+        Some(ref x) => m2!(x),
+        None => return,
+    }
+
+    // Err, reference to a &String
+    let _ = |&ref x: &&String| {
+        let _: &&String = x;
+    };
+}
+
+// Err, reference to a &String
+fn f2<'a>(&ref x: &&'a String) -> &'a String {
+    let _: &&String = x;
+    *x
+}
+
+trait T1 {
+    // Err, reference to a &String
+    fn f(&ref x: &&String) {
+        let _: &&String = x;
+    }
+}
+
+struct S;
+impl T1 for S {
+    // Err, reference to a &String
+    fn f(&ref x: &&String) {
+        let _: &&String = x;
+    }
+}
diff --git a/tests/ui/ref_binding_to_reference.stderr b/tests/ui/ref_binding_to_reference.stderr
new file mode 100644
index 00000000000..00aeff4fefa
--- /dev/null
+++ b/tests/ui/ref_binding_to_reference.stderr
@@ -0,0 +1,88 @@
+error: this pattern creates a reference to a reference
+  --> $DIR/ref_binding_to_reference.rs:31:14
+   |
+LL |         Some(ref x) => x,
+   |              ^^^^^
+   |
+   = note: `-D clippy::ref-binding-to-reference` implied by `-D warnings`
+help: try this
+   |
+LL |         Some(x) => &x,
+   |              ^     ^^
+
+error: this pattern creates a reference to a reference
+  --> $DIR/ref_binding_to_reference.rs:37:14
+   |
+LL |         Some(ref x) => {
+   |              ^^^^^
+   |
+help: try this
+   |
+LL |         Some(x) => {
+LL |             f1(x);
+LL |             f1(x);
+LL |             &x
+   |
+
+error: this pattern creates a reference to a reference
+  --> $DIR/ref_binding_to_reference.rs:47:14
+   |
+LL |         Some(ref x) => m2!(x),
+   |              ^^^^^
+   |
+help: try this
+   |
+LL |         Some(x) => m2!(&x),
+   |              ^         ^^
+
+error: this pattern creates a reference to a reference
+  --> $DIR/ref_binding_to_reference.rs:52:15
+   |
+LL |     let _ = |&ref x: &&String| {
+   |               ^^^^^
+   |
+help: try this
+   |
+LL |     let _ = |&x: &&String| {
+LL |         let _: &&String = &x;
+   |
+
+error: this pattern creates a reference to a reference
+  --> $DIR/ref_binding_to_reference.rs:58:12
+   |
+LL | fn f2<'a>(&ref x: &&'a String) -> &'a String {
+   |            ^^^^^
+   |
+help: try this
+   |
+LL | fn f2<'a>(&x: &&'a String) -> &'a String {
+LL |     let _: &&String = &x;
+LL |     x
+   |
+
+error: this pattern creates a reference to a reference
+  --> $DIR/ref_binding_to_reference.rs:65:11
+   |
+LL |     fn f(&ref x: &&String) {
+   |           ^^^^^
+   |
+help: try this
+   |
+LL |     fn f(&x: &&String) {
+LL |         let _: &&String = &x;
+   |
+
+error: this pattern creates a reference to a reference
+  --> $DIR/ref_binding_to_reference.rs:73:11
+   |
+LL |     fn f(&ref x: &&String) {
+   |           ^^^^^
+   |
+help: try this
+   |
+LL |     fn f(&x: &&String) {
+LL |         let _: &&String = &x;
+   |
+
+error: aborting due to 7 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 2eafec182d82fe85bcf88f78bd76ea143b5a6fba Mon Sep 17 00:00:00 2001
From: John Simon <john@whatisaph.one>
Date: Thu, 20 May 2021 10:12:54 -0400
Subject: Allow wparam and lparam in similar_names

---
 clippy_lints/src/non_expressive_names.rs | 1 +
 tests/ui/similar_names.rs                | 4 ++++
 tests/ui/similar_names.stderr            | 4 ++--
 3 files changed, 7 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/non_expressive_names.rs b/clippy_lints/src/non_expressive_names.rs
index 52661416de6..7b12363a3fe 100644
--- a/clippy_lints/src/non_expressive_names.rs
+++ b/clippy_lints/src/non_expressive_names.rs
@@ -125,6 +125,7 @@ const ALLOWED_TO_BE_SIMILAR: &[&[&str]] = &[
     &["args", "arms"],
     &["qpath", "path"],
     &["lit", "lint"],
+    &["wparam", "lparam"],
 ];
 
 struct SimilarNamesNameVisitor<'a, 'tcx, 'b>(&'b mut SimilarNamesLocalVisitor<'a, 'tcx>);
diff --git a/tests/ui/similar_names.rs b/tests/ui/similar_names.rs
index 5981980988b..2b1bc1f4859 100644
--- a/tests/ui/similar_names.rs
+++ b/tests/ui/similar_names.rs
@@ -72,6 +72,10 @@ fn main() {
     let rx1: i32;
     let tx_cake: i32;
     let rx_cake: i32;
+
+    // names often used in win32 code (for example WindowProc)
+    let wparam: i32;
+    let lparam: i32;
 }
 
 fn foo() {
diff --git a/tests/ui/similar_names.stderr b/tests/ui/similar_names.stderr
index 0256f126a94..a7eb2be0778 100644
--- a/tests/ui/similar_names.stderr
+++ b/tests/ui/similar_names.stderr
@@ -92,13 +92,13 @@ LL |     let parsee: i32;
    |         ^^^^^^
 
 error: binding's name is too similar to existing binding
-  --> $DIR/similar_names.rs:81:16
+  --> $DIR/similar_names.rs:85:16
    |
 LL |         bpple: sprang,
    |                ^^^^^^
    |
 note: existing binding defined here
-  --> $DIR/similar_names.rs:80:16
+  --> $DIR/similar_names.rs:84:16
    |
 LL |         apple: spring,
    |                ^^^^^^
-- 
cgit 1.4.1-3-g733a5


From f355aebf107bb4de078525bbafb16952cc9ecb34 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Wed, 19 May 2021 16:27:06 -0400
Subject: Move `needless_borrow` to style

---
 clippy_lints/src/lib.rs                            |   3 +-
 clippy_lints/src/needless_borrow.rs                |   2 +-
 clippy_lints/src/ptr.rs                            |   2 +-
 clippy_lints/src/single_component_path_imports.rs  |   4 +-
 clippy_lints/src/unused_io_amount.rs               |   2 +-
 .../src/utils/internal_lints/metadata_collector.rs |  10 +-
 clippy_utils/src/consts.rs                         |  22 +--
 clippy_utils/src/higher.rs                         |  36 ++---
 clippy_utils/src/hir_utils.rs                      | 163 ++++++++++-----------
 clippy_utils/src/lib.rs                            |  64 ++++----
 clippy_utils/src/numeric_literal.rs                |   2 +-
 clippy_utils/src/ptr.rs                            |   4 +-
 clippy_utils/src/qualify_min_const_fn.rs           |   2 +-
 clippy_utils/src/ty.rs                             |  17 +--
 clippy_utils/src/usage.rs                          |   4 +-
 15 files changed, 164 insertions(+), 173 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index a263e8b0ca4..877d9054d7b 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1361,6 +1361,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(needless_arbitrary_self_type::NEEDLESS_ARBITRARY_SELF_TYPE),
         LintId::of(needless_bool::BOOL_COMPARISON),
         LintId::of(needless_bool::NEEDLESS_BOOL),
+        LintId::of(needless_borrow::NEEDLESS_BORROW),
         LintId::of(needless_borrowed_ref::NEEDLESS_BORROWED_REFERENCE),
         LintId::of(needless_question_mark::NEEDLESS_QUESTION_MARK),
         LintId::of(needless_update::NEEDLESS_UPDATE),
@@ -1544,6 +1545,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(misc_early::REDUNDANT_PATTERN),
         LintId::of(mut_mutex_lock::MUT_MUTEX_LOCK),
         LintId::of(mut_reference::UNNECESSARY_MUT_PASSED),
+        LintId::of(needless_borrow::NEEDLESS_BORROW),
         LintId::of(neg_multiply::NEG_MULTIPLY),
         LintId::of(new_without_default::NEW_WITHOUT_DEFAULT),
         LintId::of(non_copy_const::BORROW_INTERIOR_MUTABLE_CONST),
@@ -1783,7 +1785,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(missing_const_for_fn::MISSING_CONST_FOR_FN),
         LintId::of(mutable_debug_assertion::DEBUG_ASSERT_WITH_MUT_CALL),
         LintId::of(mutex_atomic::MUTEX_INTEGER),
-        LintId::of(needless_borrow::NEEDLESS_BORROW),
         LintId::of(path_buf_push_overwrite::PATH_BUF_PUSH_OVERWRITE),
         LintId::of(redundant_pub_crate::REDUNDANT_PUB_CRATE),
         LintId::of(regex::TRIVIAL_REGEX),
diff --git a/clippy_lints/src/needless_borrow.rs b/clippy_lints/src/needless_borrow.rs
index 965b131770e..bcedebfccc7 100644
--- a/clippy_lints/src/needless_borrow.rs
+++ b/clippy_lints/src/needless_borrow.rs
@@ -34,7 +34,7 @@ declare_clippy_lint! {
     /// let x: &i32 = &5;
     /// ```
     pub NEEDLESS_BORROW,
-    nursery,
+    style,
     "taking a reference that is going to be automatically dereferenced"
 }
 
diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs
index b0674f90678..12c44436874 100644
--- a/clippy_lints/src/ptr.rs
+++ b/clippy_lints/src/ptr.rs
@@ -211,7 +211,7 @@ fn check_invalid_ptr_usage<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
     ];
 
     if_chain! {
-        if let ExprKind::Call(ref fun, ref args) = expr.kind;
+        if let ExprKind::Call(fun, args) = expr.kind;
         if let ExprKind::Path(ref qpath) = fun.kind;
         if let Some(fun_def_id) = cx.qpath_res(qpath, fun.hir_id).opt_def_id();
         let fun_def_path = cx.get_def_path(fun_def_id).into_iter().map(Symbol::to_ident_string).collect::<Vec<_>>();
diff --git a/clippy_lints/src/single_component_path_imports.rs b/clippy_lints/src/single_component_path_imports.rs
index a45bb102389..1eaad438237 100644
--- a/clippy_lints/src/single_component_path_imports.rs
+++ b/clippy_lints/src/single_component_path_imports.rs
@@ -70,7 +70,7 @@ fn check_mod(cx: &EarlyContext<'_>, items: &[P<Item>]) {
     for item in items {
         track_uses(
             cx,
-            &item,
+            item,
             &mut imports_reused_with_self,
             &mut single_use_usages,
             &mut macros,
@@ -117,7 +117,7 @@ fn track_uses(
 
     match &item.kind {
         ItemKind::Mod(_, ModKind::Loaded(ref items, ..)) => {
-            check_mod(cx, &items);
+            check_mod(cx, items);
         },
         ItemKind::MacroDef(MacroDef { macro_rules: true, .. }) => {
             macros.push(item.ident.name);
diff --git a/clippy_lints/src/unused_io_amount.rs b/clippy_lints/src/unused_io_amount.rs
index c27a6d4e347..ee082d30d93 100644
--- a/clippy_lints/src/unused_io_amount.rs
+++ b/clippy_lints/src/unused_io_amount.rs
@@ -66,7 +66,7 @@ impl<'tcx> LateLintPass<'tcx> for UnusedIoAmount {
 
 fn check_map_error(cx: &LateContext<'_>, call: &hir::Expr<'_>, expr: &hir::Expr<'_>) {
     let mut call = call;
-    while let hir::ExprKind::MethodCall(ref path, _, ref args, _) = call.kind {
+    while let hir::ExprKind::MethodCall(path, _, args, _) = call.kind {
         if matches!(&*path.ident.as_str(), "or" | "or_else" | "ok") {
             call = &args[0];
         } else {
diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index e9fa043b20f..a672af88271 100644
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -379,7 +379,7 @@ impl<'hir> LateLintPass<'hir> for MetadataCollector {
     /// }
     /// ```
     fn check_item(&mut self, cx: &LateContext<'hir>, item: &'hir Item<'_>) {
-        if let ItemKind::Static(ref ty, Mutability::Not, _) = item.kind {
+        if let ItemKind::Static(ty, Mutability::Not, _) = item.kind {
             // Normal lint
             if_chain! {
                 // item validation
@@ -489,7 +489,7 @@ fn extract_attr_docs(cx: &LateContext<'_>, item: &Item<'_>) -> Option<String> {
         .hir()
         .attrs(item.hir_id())
         .iter()
-        .filter_map(|ref x| x.doc_str().map(|sym| sym.as_str().to_string()))
+        .filter_map(|x| x.doc_str().map(|sym| sym.as_str().to_string()))
         .reduce(|mut acc, sym| {
             acc.push_str(&sym);
             acc.push('\n');
@@ -596,7 +596,7 @@ fn extract_emission_info<'hir>(
     let mut multi_part = false;
 
     for arg in args {
-        let (arg_ty, _) = walk_ptrs_ty_depth(cx.typeck_results().expr_ty(&arg));
+        let (arg_ty, _) = walk_ptrs_ty_depth(cx.typeck_results().expr_ty(arg));
 
         if match_type(cx, arg_ty, &paths::LINT) {
             // If we found the lint arg, extract the lint name
@@ -671,7 +671,7 @@ impl<'a, 'hir> intravisit::Visitor<'hir> for LintResolver<'a, 'hir> {
             if let ExprKind::Path(qpath) = &expr.kind;
             if let QPath::Resolved(_, path) = qpath;
 
-            let (expr_ty, _) = walk_ptrs_ty_depth(self.cx.typeck_results().expr_ty(&expr));
+            let (expr_ty, _) = walk_ptrs_ty_depth(self.cx.typeck_results().expr_ty(expr));
             if match_type(self.cx, expr_ty, &paths::LINT);
             then {
                 if let hir::def::Res::Def(DefKind::Static, _) = path.res {
@@ -730,7 +730,7 @@ impl<'a, 'hir> intravisit::Visitor<'hir> for ApplicabilityResolver<'a, 'hir> {
     }
 
     fn visit_expr(&mut self, expr: &'hir hir::Expr<'hir>) {
-        let (expr_ty, _) = walk_ptrs_ty_depth(self.cx.typeck_results().expr_ty(&expr));
+        let (expr_ty, _) = walk_ptrs_ty_depth(self.cx.typeck_results().expr_ty(expr));
 
         if_chain! {
             if match_type(self.cx, expr_ty, &paths::APPLICABILITY);
diff --git a/clippy_utils/src/consts.rs b/clippy_utils/src/consts.rs
index 2a305d8bcbe..0d7fdeeb920 100644
--- a/clippy_utils/src/consts.rs
+++ b/clippy_utils/src/consts.rs
@@ -229,25 +229,25 @@ impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
     pub fn expr(&mut self, e: &Expr<'_>) -> Option<Constant> {
         match e.kind {
             ExprKind::Path(ref qpath) => self.fetch_path(qpath, e.hir_id, self.typeck_results.expr_ty(e)),
-            ExprKind::Block(ref block, _) => self.block(block),
+            ExprKind::Block(block, _) => self.block(block),
             ExprKind::Lit(ref lit) => Some(lit_to_constant(&lit.node, self.typeck_results.expr_ty_opt(e))),
-            ExprKind::Array(ref vec) => self.multi(vec).map(Constant::Vec),
-            ExprKind::Tup(ref tup) => self.multi(tup).map(Constant::Tuple),
-            ExprKind::Repeat(ref value, _) => {
+            ExprKind::Array(vec) => self.multi(vec).map(Constant::Vec),
+            ExprKind::Tup(tup) => self.multi(tup).map(Constant::Tuple),
+            ExprKind::Repeat(value, _) => {
                 let n = match self.typeck_results.expr_ty(e).kind() {
                     ty::Array(_, n) => n.try_eval_usize(self.lcx.tcx, self.lcx.param_env)?,
                     _ => span_bug!(e.span, "typeck error"),
                 };
                 self.expr(value).map(|v| Constant::Repeat(Box::new(v), n))
             },
-            ExprKind::Unary(op, ref operand) => self.expr(operand).and_then(|o| match op {
+            ExprKind::Unary(op, operand) => self.expr(operand).and_then(|o| match op {
                 UnOp::Not => self.constant_not(&o, self.typeck_results.expr_ty(e)),
                 UnOp::Neg => self.constant_negate(&o, self.typeck_results.expr_ty(e)),
                 UnOp::Deref => Some(if let Constant::Ref(r) = o { *r } else { o }),
             }),
-            ExprKind::If(ref cond, ref then, ref otherwise) => self.ifthenelse(cond, then, *otherwise),
-            ExprKind::Binary(op, ref left, ref right) => self.binop(op, left, right),
-            ExprKind::Call(ref callee, ref args) => {
+            ExprKind::If(cond, then, ref otherwise) => self.ifthenelse(cond, then, *otherwise),
+            ExprKind::Binary(op, left, right) => self.binop(op, left, right),
+            ExprKind::Call(callee, args) => {
                 // We only handle a few const functions for now.
                 if_chain! {
                     if args.is_empty();
@@ -273,8 +273,8 @@ impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
                     }
                 }
             },
-            ExprKind::Index(ref arr, ref index) => self.index(arr, index),
-            ExprKind::AddrOf(_, _, ref inner) => self.expr(inner).map(|r| Constant::Ref(Box::new(r))),
+            ExprKind::Index(arr, index) => self.index(arr, index),
+            ExprKind::AddrOf(_, _, inner) => self.expr(inner).map(|r| Constant::Ref(Box::new(r))),
             // TODO: add other expressions.
             _ => None,
         }
@@ -349,7 +349,7 @@ impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
                     )
                     .ok()
                     .map(|val| rustc_middle::ty::Const::from_value(self.lcx.tcx, val, ty))?;
-                let result = miri_to_const(&result);
+                let result = miri_to_const(result);
                 if result.is_some() {
                     self.needed_resolution = true;
                 }
diff --git a/clippy_utils/src/higher.rs b/clippy_utils/src/higher.rs
index 25b4491616c..8be36756b33 100644
--- a/clippy_utils/src/higher.rs
+++ b/clippy_utils/src/higher.rs
@@ -58,7 +58,7 @@ pub fn range<'a>(expr: &'a hir::Expr<'_>) -> Option<Range<'a>> {
     }
 
     match expr.kind {
-        hir::ExprKind::Call(ref path, ref args)
+        hir::ExprKind::Call(path, args)
             if matches!(
                 path.kind,
                 hir::ExprKind::Path(hir::QPath::LangItem(hir::LangItem::RangeInclusiveNew, _))
@@ -70,7 +70,7 @@ pub fn range<'a>(expr: &'a hir::Expr<'_>) -> Option<Range<'a>> {
                 limits: ast::RangeLimits::Closed,
             })
         },
-        hir::ExprKind::Struct(path, ref fields, None) => match path {
+        hir::ExprKind::Struct(path, fields, None) => match path {
             hir::QPath::LangItem(hir::LangItem::RangeFull, _) => Some(Range {
                 start: None,
                 end: None,
@@ -112,7 +112,7 @@ pub fn is_from_for_desugar(local: &hir::Local<'_>) -> bool {
     // }
     // ```
     if_chain! {
-        if let Some(ref expr) = local.init;
+        if let Some(expr) = local.init;
         if let hir::ExprKind::Match(_, _, hir::MatchSource::ForLoopDesugar) = expr.kind;
         then {
             return true;
@@ -140,14 +140,14 @@ pub fn for_loop<'tcx>(
     expr: &'tcx hir::Expr<'tcx>,
 ) -> Option<(&hir::Pat<'_>, &'tcx hir::Expr<'tcx>, &'tcx hir::Expr<'tcx>, Span)> {
     if_chain! {
-        if let hir::ExprKind::Match(ref iterexpr, ref arms, hir::MatchSource::ForLoopDesugar) = expr.kind;
-        if let hir::ExprKind::Call(_, ref iterargs) = iterexpr.kind;
+        if let hir::ExprKind::Match(iterexpr, arms, hir::MatchSource::ForLoopDesugar) = expr.kind;
+        if let hir::ExprKind::Call(_, iterargs) = iterexpr.kind;
         if iterargs.len() == 1 && arms.len() == 1 && arms[0].guard.is_none();
-        if let hir::ExprKind::Loop(ref block, ..) = arms[0].body.kind;
+        if let hir::ExprKind::Loop(block, ..) = arms[0].body.kind;
         if block.expr.is_none();
         if let [ _, _, ref let_stmt, ref body ] = *block.stmts;
-        if let hir::StmtKind::Local(ref local) = let_stmt.kind;
-        if let hir::StmtKind::Expr(ref expr) = body.kind;
+        if let hir::StmtKind::Local(local) = let_stmt.kind;
+        if let hir::StmtKind::Expr(expr) = body.kind;
         then {
             return Some((&*local.pat, &iterargs[0], expr, arms[0].span));
         }
@@ -182,7 +182,7 @@ pub enum VecArgs<'a> {
 /// from `vec!`.
 pub fn vec_macro<'e>(cx: &LateContext<'_>, expr: &'e hir::Expr<'_>) -> Option<VecArgs<'e>> {
     if_chain! {
-        if let hir::ExprKind::Call(ref fun, ref args) = expr.kind;
+        if let hir::ExprKind::Call(fun, args) = expr.kind;
         if let hir::ExprKind::Path(ref qpath) = fun.kind;
         if is_expn_of(fun.span, "vec").is_some();
         if let Some(fun_def_id) = cx.qpath_res(qpath, fun.hir_id).opt_def_id();
@@ -194,8 +194,8 @@ pub fn vec_macro<'e>(cx: &LateContext<'_>, expr: &'e hir::Expr<'_>) -> Option<Ve
             else if match_def_path(cx, fun_def_id, &paths::SLICE_INTO_VEC) && args.len() == 1 {
                 // `vec![a, b, c]` case
                 if_chain! {
-                    if let hir::ExprKind::Box(ref boxed) = args[0].kind;
-                    if let hir::ExprKind::Array(ref args) = boxed.kind;
+                    if let hir::ExprKind::Box(boxed) = args[0].kind;
+                    if let hir::ExprKind::Array(args) = boxed.kind;
                     then {
                         return Some(VecArgs::Vec(&*args));
                     }
@@ -227,7 +227,7 @@ pub fn extract_assert_macro_args<'tcx>(e: &'tcx Expr<'tcx>) -> Option<Vec<&'tcx
     /// compared
     fn ast_matchblock(matchblock_expr: &'tcx Expr<'tcx>) -> Option<Vec<&Expr<'_>>> {
         if_chain! {
-            if let ExprKind::Match(ref headerexpr, _, _) = &matchblock_expr.kind;
+            if let ExprKind::Match(headerexpr, _, _) = &matchblock_expr.kind;
             if let ExprKind::Tup([lhs, rhs]) = &headerexpr.kind;
             if let ExprKind::AddrOf(BorrowKind::Ref, _, lhs) = lhs.kind;
             if let ExprKind::AddrOf(BorrowKind::Ref, _, rhs) = rhs.kind;
@@ -238,12 +238,12 @@ pub fn extract_assert_macro_args<'tcx>(e: &'tcx Expr<'tcx>) -> Option<Vec<&'tcx
         None
     }
 
-    if let ExprKind::Block(ref block, _) = e.kind {
+    if let ExprKind::Block(block, _) = e.kind {
         if block.stmts.len() == 1 {
-            if let StmtKind::Semi(ref matchexpr) = block.stmts.get(0)?.kind {
+            if let StmtKind::Semi(matchexpr) = block.stmts.get(0)?.kind {
                 // macros with unique arg: `{debug_}assert!` (e.g., `debug_assert!(some_condition)`)
                 if_chain! {
-                    if let ExprKind::If(ref clause, _, _)  = matchexpr.kind;
+                    if let ExprKind::If(clause, _, _)  = matchexpr.kind;
                     if let ExprKind::Unary(UnOp::Not, condition) = clause.kind;
                     then {
                         return Some(vec![condition]);
@@ -252,8 +252,8 @@ pub fn extract_assert_macro_args<'tcx>(e: &'tcx Expr<'tcx>) -> Option<Vec<&'tcx
 
                 // debug macros with two args: `debug_assert_{ne, eq}` (e.g., `assert_ne!(a, b)`)
                 if_chain! {
-                    if let ExprKind::Block(ref matchblock,_) = matchexpr.kind;
-                    if let Some(ref matchblock_expr) = matchblock.expr;
+                    if let ExprKind::Block(matchblock,_) = matchexpr.kind;
+                    if let Some(matchblock_expr) = matchblock.expr;
                     then {
                         return ast_matchblock(matchblock_expr);
                     }
@@ -261,7 +261,7 @@ pub fn extract_assert_macro_args<'tcx>(e: &'tcx Expr<'tcx>) -> Option<Vec<&'tcx
             }
         } else if let Some(matchblock_expr) = block.expr {
             // macros with two args: `assert_{ne, eq}` (e.g., `assert_ne!(a, b)`)
-            return ast_matchblock(&matchblock_expr);
+            return ast_matchblock(matchblock_expr);
         }
     }
     None
diff --git a/clippy_utils/src/hir_utils.rs b/clippy_utils/src/hir_utils.rs
index 3b01158acd9..2fc12702f48 100644
--- a/clippy_utils/src/hir_utils.rs
+++ b/clippy_utils/src/hir_utils.rs
@@ -95,12 +95,12 @@ pub struct HirEqInterExpr<'a, 'b, 'tcx> {
 impl HirEqInterExpr<'_, '_, '_> {
     pub fn eq_stmt(&mut self, left: &Stmt<'_>, right: &Stmt<'_>) -> bool {
         match (&left.kind, &right.kind) {
-            (&StmtKind::Local(ref l), &StmtKind::Local(ref r)) => {
+            (&StmtKind::Local(l), &StmtKind::Local(r)) => {
                 // This additional check ensures that the type of the locals are equivalent even if the init
                 // expression or type have some inferred parts.
                 if let Some(typeck) = self.inner.maybe_typeck_results {
-                    let l_ty = typeck.pat_ty(&l.pat);
-                    let r_ty = typeck.pat_ty(&r.pat);
+                    let l_ty = typeck.pat_ty(l.pat);
+                    let r_ty = typeck.pat_ty(r.pat);
                     if !rustc_middle::ty::TyS::same_type(l_ty, r_ty) {
                         return false;
                     }
@@ -110,11 +110,9 @@ impl HirEqInterExpr<'_, '_, '_> {
                 // these only get added if the init and type is equal.
                 both(&l.init, &r.init, |l, r| self.eq_expr(l, r))
                     && both(&l.ty, &r.ty, |l, r| self.eq_ty(l, r))
-                    && self.eq_pat(&l.pat, &r.pat)
-            },
-            (&StmtKind::Expr(ref l), &StmtKind::Expr(ref r)) | (&StmtKind::Semi(ref l), &StmtKind::Semi(ref r)) => {
-                self.eq_expr(l, r)
+                    && self.eq_pat(l.pat, r.pat)
             },
+            (&StmtKind::Expr(l), &StmtKind::Expr(r)) | (&StmtKind::Semi(l), &StmtKind::Semi(r)) => self.eq_expr(l, r),
             _ => false,
         }
     }
@@ -165,7 +163,7 @@ impl HirEqInterExpr<'_, '_, '_> {
                 left.eq(right)
             },
             _ => {
-                over(&left.stmts, &right.stmts, |l, r| self.eq_stmt(l, r))
+                over(left.stmts, right.stmts, |l, r| self.eq_stmt(l, r))
                     && both(&left.expr, &right.expr, |l, r| self.eq_expr(l, r))
             },
         }
@@ -192,20 +190,20 @@ impl HirEqInterExpr<'_, '_, '_> {
             &reduce_exprkind(self.inner.cx, &left.kind),
             &reduce_exprkind(self.inner.cx, &right.kind),
         ) {
-            (&ExprKind::AddrOf(lb, l_mut, ref le), &ExprKind::AddrOf(rb, r_mut, ref re)) => {
+            (&ExprKind::AddrOf(lb, l_mut, le), &ExprKind::AddrOf(rb, r_mut, re)) => {
                 lb == rb && l_mut == r_mut && self.eq_expr(le, re)
             },
             (&ExprKind::Continue(li), &ExprKind::Continue(ri)) => {
                 both(&li.label, &ri.label, |l, r| l.ident.name == r.ident.name)
             },
-            (&ExprKind::Assign(ref ll, ref lr, _), &ExprKind::Assign(ref rl, ref rr, _)) => {
+            (&ExprKind::Assign(ll, lr, _), &ExprKind::Assign(rl, rr, _)) => {
                 self.inner.allow_side_effects && self.eq_expr(ll, rl) && self.eq_expr(lr, rr)
             },
-            (&ExprKind::AssignOp(ref lo, ref ll, ref lr), &ExprKind::AssignOp(ref ro, ref rl, ref rr)) => {
+            (&ExprKind::AssignOp(ref lo, ll, lr), &ExprKind::AssignOp(ref ro, rl, rr)) => {
                 self.inner.allow_side_effects && lo.node == ro.node && self.eq_expr(ll, rl) && self.eq_expr(lr, rr)
             },
-            (&ExprKind::Block(ref l, _), &ExprKind::Block(ref r, _)) => self.eq_block(l, r),
-            (&ExprKind::Binary(l_op, ref ll, ref lr), &ExprKind::Binary(r_op, ref rl, ref rr)) => {
+            (&ExprKind::Block(l, _), &ExprKind::Block(r, _)) => self.eq_block(l, r),
+            (&ExprKind::Binary(l_op, ll, lr), &ExprKind::Binary(r_op, rl, rr)) => {
                 l_op.node == r_op.node && self.eq_expr(ll, rl) && self.eq_expr(lr, rr)
                     || swap_binop(l_op.node, ll, lr).map_or(false, |(l_op, ll, lr)| {
                         l_op == r_op.node && self.eq_expr(ll, rl) && self.eq_expr(lr, rr)
@@ -215,40 +213,37 @@ impl HirEqInterExpr<'_, '_, '_> {
                 both(&li.label, &ri.label, |l, r| l.ident.name == r.ident.name)
                     && both(le, re, |l, r| self.eq_expr(l, r))
             },
-            (&ExprKind::Box(ref l), &ExprKind::Box(ref r)) => self.eq_expr(l, r),
+            (&ExprKind::Box(l), &ExprKind::Box(r)) => self.eq_expr(l, r),
             (&ExprKind::Call(l_fun, l_args), &ExprKind::Call(r_fun, r_args)) => {
                 self.inner.allow_side_effects && self.eq_expr(l_fun, r_fun) && self.eq_exprs(l_args, r_args)
             },
-            (&ExprKind::Cast(ref lx, ref lt), &ExprKind::Cast(ref rx, ref rt))
-            | (&ExprKind::Type(ref lx, ref lt), &ExprKind::Type(ref rx, ref rt)) => {
+            (&ExprKind::Cast(lx, lt), &ExprKind::Cast(rx, rt)) | (&ExprKind::Type(lx, lt), &ExprKind::Type(rx, rt)) => {
                 self.eq_expr(lx, rx) && self.eq_ty(lt, rt)
             },
-            (&ExprKind::Field(ref l_f_exp, ref l_f_ident), &ExprKind::Field(ref r_f_exp, ref r_f_ident)) => {
+            (&ExprKind::Field(l_f_exp, ref l_f_ident), &ExprKind::Field(r_f_exp, ref r_f_ident)) => {
                 l_f_ident.name == r_f_ident.name && self.eq_expr(l_f_exp, r_f_exp)
             },
-            (&ExprKind::Index(ref la, ref li), &ExprKind::Index(ref ra, ref ri)) => {
-                self.eq_expr(la, ra) && self.eq_expr(li, ri)
-            },
-            (&ExprKind::If(ref lc, ref lt, ref le), &ExprKind::If(ref rc, ref rt, ref re)) => {
+            (&ExprKind::Index(la, li), &ExprKind::Index(ra, ri)) => self.eq_expr(la, ra) && self.eq_expr(li, ri),
+            (&ExprKind::If(lc, lt, ref le), &ExprKind::If(rc, rt, ref re)) => {
                 self.eq_expr(lc, rc) && self.eq_expr(&**lt, &**rt) && both(le, re, |l, r| self.eq_expr(l, r))
             },
             (&ExprKind::Lit(ref l), &ExprKind::Lit(ref r)) => l.node == r.node,
-            (&ExprKind::Loop(ref lb, ref ll, ref lls, _), &ExprKind::Loop(ref rb, ref rl, ref rls, _)) => {
+            (&ExprKind::Loop(lb, ref ll, ref lls, _), &ExprKind::Loop(rb, ref rl, ref rls, _)) => {
                 lls == rls && self.eq_block(lb, rb) && both(ll, rl, |l, r| l.ident.name == r.ident.name)
             },
-            (&ExprKind::Match(ref le, ref la, ref ls), &ExprKind::Match(ref re, ref ra, ref rs)) => {
+            (&ExprKind::Match(le, la, ref ls), &ExprKind::Match(re, ra, ref rs)) => {
                 ls == rs
                     && self.eq_expr(le, re)
                     && over(la, ra, |l, r| {
-                        self.eq_pat(&l.pat, &r.pat)
+                        self.eq_pat(l.pat, r.pat)
                             && both(&l.guard, &r.guard, |l, r| self.eq_guard(l, r))
-                            && self.eq_expr(&l.body, &r.body)
+                            && self.eq_expr(l.body, r.body)
                     })
             },
             (&ExprKind::MethodCall(l_path, _, l_args, _), &ExprKind::MethodCall(r_path, _, r_args, _)) => {
                 self.inner.allow_side_effects && self.eq_path_segment(l_path, r_path) && self.eq_exprs(l_args, r_args)
             },
-            (&ExprKind::Repeat(ref le, ref ll_id), &ExprKind::Repeat(ref re, ref rl_id)) => {
+            (&ExprKind::Repeat(le, ref ll_id), &ExprKind::Repeat(re, ref rl_id)) => {
                 let mut celcx = constant_context(self.inner.cx, self.inner.cx.tcx.typeck_body(ll_id.body));
                 let ll = celcx.expr(&self.inner.cx.tcx.hir().body(ll_id.body).value);
                 let mut celcx = constant_context(self.inner.cx, self.inner.cx.tcx.typeck_body(rl_id.body));
@@ -258,15 +253,15 @@ impl HirEqInterExpr<'_, '_, '_> {
             },
             (&ExprKind::Ret(ref l), &ExprKind::Ret(ref r)) => both(l, r, |l, r| self.eq_expr(l, r)),
             (&ExprKind::Path(ref l), &ExprKind::Path(ref r)) => self.eq_qpath(l, r),
-            (&ExprKind::Struct(ref l_path, ref lf, ref lo), &ExprKind::Struct(ref r_path, ref rf, ref ro)) => {
+            (&ExprKind::Struct(l_path, lf, ref lo), &ExprKind::Struct(r_path, rf, ref ro)) => {
                 self.eq_qpath(l_path, r_path)
                     && both(lo, ro, |l, r| self.eq_expr(l, r))
                     && over(lf, rf, |l, r| self.eq_expr_field(l, r))
             },
             (&ExprKind::Tup(l_tup), &ExprKind::Tup(r_tup)) => self.eq_exprs(l_tup, r_tup),
-            (&ExprKind::Unary(l_op, ref le), &ExprKind::Unary(r_op, ref re)) => l_op == r_op && self.eq_expr(le, re),
+            (&ExprKind::Unary(l_op, le), &ExprKind::Unary(r_op, re)) => l_op == r_op && self.eq_expr(le, re),
             (&ExprKind::Array(l), &ExprKind::Array(r)) => self.eq_exprs(l, r),
-            (&ExprKind::DropTemps(ref le), &ExprKind::DropTemps(ref re)) => self.eq_expr(le, re),
+            (&ExprKind::DropTemps(le), &ExprKind::DropTemps(re)) => self.eq_expr(le, re),
             _ => false,
         };
         is_eq || self.inner.expr_fallback.as_mut().map_or(false, |f| f(left, right))
@@ -277,7 +272,7 @@ impl HirEqInterExpr<'_, '_, '_> {
     }
 
     fn eq_expr_field(&mut self, left: &ExprField<'_>, right: &ExprField<'_>) -> bool {
-        left.ident.name == right.ident.name && self.eq_expr(&left.expr, &right.expr)
+        left.ident.name == right.ident.name && self.eq_expr(left.expr, right.expr)
     }
 
     fn eq_guard(&mut self, left: &Guard<'_>, right: &Guard<'_>) -> bool {
@@ -308,11 +303,11 @@ impl HirEqInterExpr<'_, '_, '_> {
     /// Checks whether two patterns are the same.
     fn eq_pat(&mut self, left: &Pat<'_>, right: &Pat<'_>) -> bool {
         match (&left.kind, &right.kind) {
-            (&PatKind::Box(ref l), &PatKind::Box(ref r)) => self.eq_pat(l, r),
-            (&PatKind::Struct(ref lp, ref la, ..), &PatKind::Struct(ref rp, ref ra, ..)) => {
+            (&PatKind::Box(l), &PatKind::Box(r)) => self.eq_pat(l, r),
+            (&PatKind::Struct(ref lp, la, ..), &PatKind::Struct(ref rp, ra, ..)) => {
                 self.eq_qpath(lp, rp) && over(la, ra, |l, r| self.eq_pat_field(l, r))
             },
-            (&PatKind::TupleStruct(ref lp, ref la, ls), &PatKind::TupleStruct(ref rp, ref ra, rs)) => {
+            (&PatKind::TupleStruct(ref lp, la, ls), &PatKind::TupleStruct(ref rp, ra, rs)) => {
                 self.eq_qpath(lp, rp) && over(la, ra, |l, r| self.eq_pat(l, r)) && ls == rs
             },
             (&PatKind::Binding(lb, li, _, ref lp), &PatKind::Binding(rb, ri, _, ref rp)) => {
@@ -323,15 +318,13 @@ impl HirEqInterExpr<'_, '_, '_> {
                 eq
             },
             (&PatKind::Path(ref l), &PatKind::Path(ref r)) => self.eq_qpath(l, r),
-            (&PatKind::Lit(ref l), &PatKind::Lit(ref r)) => self.eq_expr(l, r),
-            (&PatKind::Tuple(ref l, ls), &PatKind::Tuple(ref r, rs)) => {
-                ls == rs && over(l, r, |l, r| self.eq_pat(l, r))
-            },
+            (&PatKind::Lit(l), &PatKind::Lit(r)) => self.eq_expr(l, r),
+            (&PatKind::Tuple(l, ls), &PatKind::Tuple(r, rs)) => ls == rs && over(l, r, |l, r| self.eq_pat(l, r)),
             (&PatKind::Range(ref ls, ref le, li), &PatKind::Range(ref rs, ref re, ri)) => {
                 both(ls, rs, |a, b| self.eq_expr(a, b)) && both(le, re, |a, b| self.eq_expr(a, b)) && (li == ri)
             },
-            (&PatKind::Ref(ref le, ref lm), &PatKind::Ref(ref re, ref rm)) => lm == rm && self.eq_pat(le, re),
-            (&PatKind::Slice(ref ls, ref li, ref le), &PatKind::Slice(ref rs, ref ri, ref re)) => {
+            (&PatKind::Ref(le, ref lm), &PatKind::Ref(re, ref rm)) => lm == rm && self.eq_pat(le, re),
+            (&PatKind::Slice(ls, ref li, le), &PatKind::Slice(rs, ref ri, re)) => {
                 over(ls, rs, |l, r| self.eq_pat(l, r))
                     && over(le, re, |l, r| self.eq_pat(l, r))
                     && both(li, ri, |l, r| self.eq_pat(l, r))
@@ -344,10 +337,10 @@ impl HirEqInterExpr<'_, '_, '_> {
     #[allow(clippy::similar_names)]
     fn eq_qpath(&mut self, left: &QPath<'_>, right: &QPath<'_>) -> bool {
         match (left, right) {
-            (&QPath::Resolved(ref lty, ref lpath), &QPath::Resolved(ref rty, ref rpath)) => {
+            (&QPath::Resolved(ref lty, lpath), &QPath::Resolved(ref rty, rpath)) => {
                 both(lty, rty, |l, r| self.eq_ty(l, r)) && self.eq_path(lpath, rpath)
             },
-            (&QPath::TypeRelative(ref lty, ref lseg), &QPath::TypeRelative(ref rty, ref rseg)) => {
+            (&QPath::TypeRelative(lty, lseg), &QPath::TypeRelative(rty, rseg)) => {
                 self.eq_ty(lty, rty) && self.eq_path_segment(lseg, rseg)
             },
             (&QPath::LangItem(llang_item, _), &QPath::LangItem(rlang_item, _)) => llang_item == rlang_item,
@@ -359,14 +352,14 @@ impl HirEqInterExpr<'_, '_, '_> {
         match (left.res, right.res) {
             (Res::Local(l), Res::Local(r)) => l == r || self.locals.get(&l) == Some(&r),
             (Res::Local(_), _) | (_, Res::Local(_)) => false,
-            _ => over(&left.segments, &right.segments, |l, r| self.eq_path_segment(l, r)),
+            _ => over(left.segments, right.segments, |l, r| self.eq_path_segment(l, r)),
         }
     }
 
     fn eq_path_parameters(&mut self, left: &GenericArgs<'_>, right: &GenericArgs<'_>) -> bool {
         if !(left.parenthesized || right.parenthesized) {
-            over(&left.args, &right.args, |l, r| self.eq_generic_arg(l, r)) // FIXME(flip1995): may not work
-                && over(&left.bindings, &right.bindings, |l, r| self.eq_type_binding(l, r))
+            over(left.args, right.args, |l, r| self.eq_generic_arg(l, r)) // FIXME(flip1995): may not work
+                && over(left.bindings, right.bindings, |l, r| self.eq_type_binding(l, r))
         } else if left.parenthesized && right.parenthesized {
             over(left.inputs(), right.inputs(), |l, r| self.eq_ty(l, r))
                 && both(&Some(&left.bindings[0].ty()), &Some(&right.bindings[0].ty()), |l, r| {
@@ -390,8 +383,8 @@ impl HirEqInterExpr<'_, '_, '_> {
     #[allow(clippy::similar_names)]
     fn eq_ty(&mut self, left: &Ty<'_>, right: &Ty<'_>) -> bool {
         match (&left.kind, &right.kind) {
-            (&TyKind::Slice(ref l_vec), &TyKind::Slice(ref r_vec)) => self.eq_ty(l_vec, r_vec),
-            (&TyKind::Array(ref lt, ref ll_id), &TyKind::Array(ref rt, ref rl_id)) => {
+            (&TyKind::Slice(l_vec), &TyKind::Slice(r_vec)) => self.eq_ty(l_vec, r_vec),
+            (&TyKind::Array(lt, ref ll_id), &TyKind::Array(rt, ref rl_id)) => {
                 let cx = self.inner.cx;
                 let eval_const =
                     |body| constant_context(cx, cx.tcx.typeck_body(body)).expr(&cx.tcx.hir().body(body).value);
@@ -404,14 +397,14 @@ impl HirEqInterExpr<'_, '_, '_> {
                 l_rmut.mutbl == r_rmut.mutbl && self.eq_ty(&*l_rmut.ty, &*r_rmut.ty)
             },
             (&TyKind::Path(ref l), &TyKind::Path(ref r)) => self.eq_qpath(l, r),
-            (&TyKind::Tup(ref l), &TyKind::Tup(ref r)) => over(l, r, |l, r| self.eq_ty(l, r)),
+            (&TyKind::Tup(l), &TyKind::Tup(r)) => over(l, r, |l, r| self.eq_ty(l, r)),
             (&TyKind::Infer, &TyKind::Infer) => true,
             _ => false,
         }
     }
 
     fn eq_type_binding(&mut self, left: &TypeBinding<'_>, right: &TypeBinding<'_>) -> bool {
-        left.ident.name == right.ident.name && self.eq_ty(&left.ty(), &right.ty())
+        left.ident.name == right.ident.name && self.eq_ty(left.ty(), right.ty())
     }
 }
 
@@ -540,7 +533,7 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> {
             self.hash_stmt(s);
         }
 
-        if let Some(ref e) = b.expr {
+        if let Some(e) = b.expr {
             self.hash_expr(e);
         }
 
@@ -570,7 +563,7 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> {
         std::mem::discriminant(&e.kind).hash(&mut self.s);
 
         match e.kind {
-            ExprKind::AddrOf(kind, m, ref e) => {
+            ExprKind::AddrOf(kind, m, e) => {
                 match kind {
                     BorrowKind::Ref => 0,
                     BorrowKind::Raw => 1,
@@ -584,20 +577,20 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> {
                     self.hash_name(i.ident.name);
                 }
             },
-            ExprKind::Assign(ref l, ref r, _) => {
+            ExprKind::Assign(l, r, _) => {
                 self.hash_expr(l);
                 self.hash_expr(r);
             },
-            ExprKind::AssignOp(ref o, ref l, ref r) => {
+            ExprKind::AssignOp(ref o, l, r) => {
                 o.node
                     .hash_stable(&mut self.cx.tcx.get_stable_hashing_context(), &mut self.s);
                 self.hash_expr(l);
                 self.hash_expr(r);
             },
-            ExprKind::Block(ref b, _) => {
+            ExprKind::Block(b, _) => {
                 self.hash_block(b);
             },
-            ExprKind::Binary(op, ref l, ref r) => {
+            ExprKind::Binary(op, l, r) => {
                 op.node
                     .hash_stable(&mut self.cx.tcx.get_stable_hashing_context(), &mut self.s);
                 self.hash_expr(l);
@@ -607,18 +600,18 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> {
                 if let Some(i) = i.label {
                     self.hash_name(i.ident.name);
                 }
-                if let Some(ref j) = *j {
+                if let Some(j) = *j {
                     self.hash_expr(&*j);
                 }
             },
-            ExprKind::Box(ref e) | ExprKind::DropTemps(ref e) | ExprKind::Yield(ref e, _) => {
+            ExprKind::Box(e) | ExprKind::DropTemps(e) | ExprKind::Yield(e, _) => {
                 self.hash_expr(e);
             },
-            ExprKind::Call(ref fun, args) => {
+            ExprKind::Call(fun, args) => {
                 self.hash_expr(fun);
                 self.hash_exprs(args);
             },
-            ExprKind::Cast(ref e, ref ty) | ExprKind::Type(ref e, ref ty) => {
+            ExprKind::Cast(e, ty) | ExprKind::Type(e, ty) => {
                 self.hash_expr(e);
                 self.hash_ty(ty);
             },
@@ -631,15 +624,15 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> {
                 // closures inherit TypeckResults
                 self.hash_expr(&self.cx.tcx.hir().body(eid).value);
             },
-            ExprKind::Field(ref e, ref f) => {
+            ExprKind::Field(e, ref f) => {
                 self.hash_expr(e);
                 self.hash_name(f.name);
             },
-            ExprKind::Index(ref a, ref i) => {
+            ExprKind::Index(a, i) => {
                 self.hash_expr(a);
                 self.hash_expr(i);
             },
-            ExprKind::InlineAsm(ref asm) => {
+            ExprKind::InlineAsm(asm) => {
                 for piece in asm.template {
                     match piece {
                         InlineAsmTemplatePiece::String(s) => s.hash(&mut self.s),
@@ -694,22 +687,22 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> {
             ExprKind::Lit(ref l) => {
                 l.node.hash(&mut self.s);
             },
-            ExprKind::Loop(ref b, ref i, ..) => {
+            ExprKind::Loop(b, ref i, ..) => {
                 self.hash_block(b);
                 if let Some(i) = *i {
                     self.hash_name(i.ident.name);
                 }
             },
-            ExprKind::If(ref cond, ref then, ref else_opt) => {
+            ExprKind::If(cond, then, ref else_opt) => {
                 let c: fn(_, _, _) -> _ = ExprKind::If;
                 c.hash(&mut self.s);
                 self.hash_expr(cond);
-                self.hash_expr(&**then);
-                if let Some(ref e) = *else_opt {
+                self.hash_expr(then);
+                if let Some(e) = *else_opt {
                     self.hash_expr(e);
                 }
             },
-            ExprKind::Match(ref e, arms, ref s) => {
+            ExprKind::Match(e, arms, ref s) => {
                 self.hash_expr(e);
 
                 for arm in arms {
@@ -717,39 +710,39 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> {
                     if let Some(ref e) = arm.guard {
                         self.hash_guard(e);
                     }
-                    self.hash_expr(&arm.body);
+                    self.hash_expr(arm.body);
                 }
 
                 s.hash(&mut self.s);
             },
-            ExprKind::MethodCall(ref path, ref _tys, args, ref _fn_span) => {
+            ExprKind::MethodCall(path, ref _tys, args, ref _fn_span) => {
                 self.hash_name(path.ident.name);
                 self.hash_exprs(args);
             },
             ExprKind::ConstBlock(ref l_id) => {
                 self.hash_body(l_id.body);
             },
-            ExprKind::Repeat(ref e, ref l_id) => {
+            ExprKind::Repeat(e, ref l_id) => {
                 self.hash_expr(e);
                 self.hash_body(l_id.body);
             },
             ExprKind::Ret(ref e) => {
-                if let Some(ref e) = *e {
+                if let Some(e) = *e {
                     self.hash_expr(e);
                 }
             },
             ExprKind::Path(ref qpath) => {
                 self.hash_qpath(qpath);
             },
-            ExprKind::Struct(ref path, fields, ref expr) => {
+            ExprKind::Struct(path, fields, ref expr) => {
                 self.hash_qpath(path);
 
                 for f in fields {
                     self.hash_name(f.ident.name);
-                    self.hash_expr(&f.expr);
+                    self.hash_expr(f.expr);
                 }
 
-                if let Some(ref e) = *expr {
+                if let Some(e) = *expr {
                     self.hash_expr(e);
                 }
             },
@@ -759,7 +752,7 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> {
             ExprKind::Array(v) => {
                 self.hash_exprs(v);
             },
-            ExprKind::Unary(lop, ref le) => {
+            ExprKind::Unary(lop, le) => {
                 lop.hash_stable(&mut self.cx.tcx.get_stable_hashing_context(), &mut self.s);
                 self.hash_expr(le);
             },
@@ -778,10 +771,10 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> {
 
     pub fn hash_qpath(&mut self, p: &QPath<'_>) {
         match *p {
-            QPath::Resolved(_, ref path) => {
+            QPath::Resolved(_, path) => {
                 self.hash_path(path);
             },
-            QPath::TypeRelative(_, ref path) => {
+            QPath::TypeRelative(_, path) => {
                 self.hash_name(path.ident.name);
             },
             QPath::LangItem(lang_item, ..) => {
@@ -875,7 +868,7 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> {
         match &b.kind {
             StmtKind::Local(local) => {
                 self.hash_pat(local.pat);
-                if let Some(ref init) = local.init {
+                if let Some(init) = local.init {
                     self.hash_expr(init);
                 }
             },
@@ -888,7 +881,7 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> {
 
     pub fn hash_guard(&mut self, g: &Guard<'_>) {
         match g {
-            Guard::If(ref expr) | Guard::IfLet(_, ref expr) => {
+            Guard::If(expr) | Guard::IfLet(_, expr) => {
                 self.hash_expr(expr);
             },
         }
@@ -921,25 +914,25 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> {
                 self.hash_body(anon_const.body);
             },
             TyKind::Ptr(ref mut_ty) => {
-                self.hash_ty(&mut_ty.ty);
+                self.hash_ty(mut_ty.ty);
                 mut_ty.mutbl.hash(&mut self.s);
             },
             TyKind::Rptr(lifetime, ref mut_ty) => {
                 self.hash_lifetime(lifetime);
-                self.hash_ty(&mut_ty.ty);
+                self.hash_ty(mut_ty.ty);
                 mut_ty.mutbl.hash(&mut self.s);
             },
             TyKind::BareFn(bfn) => {
                 bfn.unsafety.hash(&mut self.s);
                 bfn.abi.hash(&mut self.s);
                 for arg in bfn.decl.inputs {
-                    self.hash_ty(&arg);
+                    self.hash_ty(arg);
                 }
                 match bfn.decl.output {
                     FnRetTy::DefaultReturn(_) => {
                         ().hash(&mut self.s);
                     },
-                    FnRetTy::Return(ref ty) => {
+                    FnRetTy::Return(ty) => {
                         self.hash_ty(ty);
                     },
                 }
@@ -951,8 +944,8 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> {
                 }
             },
             TyKind::Path(ref qpath) => match qpath {
-                QPath::Resolved(ref maybe_ty, ref path) => {
-                    if let Some(ref ty) = maybe_ty {
+                QPath::Resolved(ref maybe_ty, path) => {
+                    if let Some(ty) = maybe_ty {
                         self.hash_ty(ty);
                     }
                     for segment in path.segments {
@@ -960,7 +953,7 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> {
                         self.hash_generic_args(segment.args().args);
                     }
                 },
-                QPath::TypeRelative(ref ty, ref segment) => {
+                QPath::TypeRelative(ty, segment) => {
                     self.hash_ty(ty);
                     segment.ident.name.hash(&mut self.s);
                 },
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 2b9b214daa7..610011af059 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -328,7 +328,7 @@ pub fn is_trait_method(cx: &LateContext<'_>, expr: &Expr<'_>, diag_item: Symbol)
 
 /// Checks if an expression references a variable of the given name.
 pub fn match_var(expr: &Expr<'_>, var: Symbol) -> bool {
-    if let ExprKind::Path(QPath::Resolved(None, ref path)) = expr.kind {
+    if let ExprKind::Path(QPath::Resolved(None, path)) = expr.kind {
         if let [p] = path.segments {
             return p.ident.name == var;
         }
@@ -338,8 +338,8 @@ pub fn match_var(expr: &Expr<'_>, var: Symbol) -> bool {
 
 pub fn last_path_segment<'tcx>(path: &QPath<'tcx>) -> &'tcx PathSegment<'tcx> {
     match *path {
-        QPath::Resolved(_, ref path) => path.segments.last().expect("A path must have at least one segment"),
-        QPath::TypeRelative(_, ref seg) => seg,
+        QPath::Resolved(_, path) => path.segments.last().expect("A path must have at least one segment"),
+        QPath::TypeRelative(_, seg) => seg,
         QPath::LangItem(..) => panic!("last_path_segment: lang item has no path segments"),
     }
 }
@@ -367,8 +367,8 @@ pub fn get_qpath_generic_tys(path: &QPath<'tcx>) -> impl Iterator<Item = &'tcx h
 
 pub fn single_segment_path<'tcx>(path: &QPath<'tcx>) -> Option<&'tcx PathSegment<'tcx>> {
     match *path {
-        QPath::Resolved(_, ref path) => path.segments.get(0),
-        QPath::TypeRelative(_, ref seg) => Some(seg),
+        QPath::Resolved(_, path) => path.segments.get(0),
+        QPath::TypeRelative(_, seg) => Some(seg),
         QPath::LangItem(..) => None,
     }
 }
@@ -388,8 +388,8 @@ pub fn single_segment_path<'tcx>(path: &QPath<'tcx>) -> Option<&'tcx PathSegment
 /// ```
 pub fn match_qpath(path: &QPath<'_>, segments: &[&str]) -> bool {
     match *path {
-        QPath::Resolved(_, ref path) => match_path(path, segments),
-        QPath::TypeRelative(ref ty, ref segment) => match ty.kind {
+        QPath::Resolved(_, path) => match_path(path, segments),
+        QPath::TypeRelative(ty, segment) => match ty.kind {
             TyKind::Path(ref inner_path) => {
                 if let [prefix @ .., end] = segments {
                     if match_qpath(inner_path, prefix) {
@@ -457,7 +457,7 @@ pub fn match_path(path: &Path<'_>, segments: &[&str]) -> bool {
 
 /// If the expression is a path to a local, returns the canonical `HirId` of the local.
 pub fn path_to_local(expr: &Expr<'_>) -> Option<HirId> {
-    if let ExprKind::Path(QPath::Resolved(None, ref path)) = expr.kind {
+    if let ExprKind::Path(QPath::Resolved(None, path)) = expr.kind {
         if let Res::Local(id) = path.res {
             return Some(id);
         }
@@ -661,12 +661,12 @@ pub fn method_chain_args<'a>(expr: &'a Expr<'_>, methods: &[&str]) -> Option<Vec
     let mut matched = Vec::with_capacity(methods.len());
     for method_name in methods.iter().rev() {
         // method chains are stored last -> first
-        if let ExprKind::MethodCall(ref path, _, ref args, _) = current.kind {
+        if let ExprKind::MethodCall(path, _, args, _) = current.kind {
             if path.ident.name.as_str() == *method_name {
                 if args.iter().any(|e| e.span.from_expansion()) {
                     return None;
                 }
-                matched.push(&**args); // build up `matched` backwards
+                matched.push(args); // build up `matched` backwards
                 current = &args[0] // go to parent expression
             } else {
                 return None;
@@ -712,7 +712,7 @@ pub fn get_pat_name(pat: &Pat<'_>) -> Option<Symbol> {
     match pat.kind {
         PatKind::Binding(.., ref spname, _) => Some(spname.name),
         PatKind::Path(ref qpath) => single_segment_path(qpath).map(|ps| ps.ident.name),
-        PatKind::Box(ref p) | PatKind::Ref(ref p, _) => get_pat_name(&*p),
+        PatKind::Box(p) | PatKind::Ref(p, _) => get_pat_name(&*p),
         _ => None,
     }
 }
@@ -854,7 +854,7 @@ pub fn get_enclosing_block<'tcx>(cx: &LateContext<'tcx>, hir_id: HirId) -> Optio
             kind: ImplItemKind::Fn(_, eid),
             ..
         }) => match cx.tcx.hir().body(eid).value.kind {
-            ExprKind::Block(ref block, _) => Some(block),
+            ExprKind::Block(block, _) => Some(block),
             _ => None,
         },
         _ => None,
@@ -1028,7 +1028,7 @@ pub fn return_ty<'tcx>(cx: &LateContext<'tcx>, fn_item: hir::HirId) -> Ty<'tcx>
 
 /// Checks if an expression is constructing a tuple-like enum variant or struct
 pub fn is_ctor_or_promotable_const_function(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-    if let ExprKind::Call(ref fun, _) = expr.kind {
+    if let ExprKind::Call(fun, _) = expr.kind {
         if let ExprKind::Path(ref qp) = fun.kind {
             let res = cx.qpath_res(qp, fun.hir_id);
             return match res {
@@ -1058,21 +1058,21 @@ pub fn is_refutable(cx: &LateContext<'_>, pat: &Pat<'_>) -> bool {
     match pat.kind {
         PatKind::Wild => false,
         PatKind::Binding(_, _, _, pat) => pat.map_or(false, |pat| is_refutable(cx, pat)),
-        PatKind::Box(ref pat) | PatKind::Ref(ref pat, _) => is_refutable(cx, pat),
+        PatKind::Box(pat) | PatKind::Ref(pat, _) => is_refutable(cx, pat),
         PatKind::Lit(..) | PatKind::Range(..) => true,
         PatKind::Path(ref qpath) => is_enum_variant(cx, qpath, pat.hir_id),
-        PatKind::Or(ref pats) => {
+        PatKind::Or(pats) => {
             // TODO: should be the honest check, that pats is exhaustive set
             are_refutable(cx, pats.iter().map(|pat| &**pat))
         },
-        PatKind::Tuple(ref pats, _) => are_refutable(cx, pats.iter().map(|pat| &**pat)),
-        PatKind::Struct(ref qpath, ref fields, _) => {
+        PatKind::Tuple(pats, _) => are_refutable(cx, pats.iter().map(|pat| &**pat)),
+        PatKind::Struct(ref qpath, fields, _) => {
             is_enum_variant(cx, qpath, pat.hir_id) || are_refutable(cx, fields.iter().map(|field| &*field.pat))
         },
-        PatKind::TupleStruct(ref qpath, ref pats, _) => {
+        PatKind::TupleStruct(ref qpath, pats, _) => {
             is_enum_variant(cx, qpath, pat.hir_id) || are_refutable(cx, pats.iter().map(|pat| &**pat))
         },
-        PatKind::Slice(ref head, ref middle, ref tail) => {
+        PatKind::Slice(head, ref middle, tail) => {
             match &cx.typeck_results().node_type(pat.hir_id).kind() {
                 rustc_ty::Slice(..) => {
                     // [..] is the only irrefutable slice pattern.
@@ -1111,7 +1111,7 @@ pub fn is_automatically_derived(attrs: &[ast::Attribute]) -> bool {
 /// Ie. `x`, `{ x }` and `{{{{ x }}}}` all give `x`. `{ x; y }` and `{}` return
 /// themselves.
 pub fn remove_blocks<'tcx>(mut expr: &'tcx Expr<'tcx>) -> &'tcx Expr<'tcx> {
-    while let ExprKind::Block(ref block, ..) = expr.kind {
+    while let ExprKind::Block(block, ..) = expr.kind {
         match (block.stmts.is_empty(), block.expr.as_ref()) {
             (true, Some(e)) => expr = e,
             _ => break,
@@ -1130,7 +1130,7 @@ pub fn is_self(slf: &Param<'_>) -> bool {
 
 pub fn is_self_ty(slf: &hir::Ty<'_>) -> bool {
     if_chain! {
-        if let TyKind::Path(QPath::Resolved(None, ref path)) = slf.kind;
+        if let TyKind::Path(QPath::Resolved(None, path)) = slf.kind;
         if let Res::SelfTy(..) = path.res;
         then {
             return true
@@ -1148,7 +1148,7 @@ pub fn iter_input_pats<'tcx>(decl: &FnDecl<'_>, body: &'tcx Body<'_>) -> impl It
 pub fn is_try<'tcx>(cx: &LateContext<'_>, expr: &'tcx Expr<'tcx>) -> Option<&'tcx Expr<'tcx>> {
     fn is_ok(cx: &LateContext<'_>, arm: &Arm<'_>) -> bool {
         if_chain! {
-            if let PatKind::TupleStruct(ref path, ref pat, None) = arm.pat.kind;
+            if let PatKind::TupleStruct(ref path, pat, None) = arm.pat.kind;
             if is_lang_ctor(cx, path, ResultOk);
             if let PatKind::Binding(_, hir_id, _, None) = pat[0].kind;
             if path_to_local_id(arm.body, hir_id);
@@ -1167,7 +1167,7 @@ pub fn is_try<'tcx>(cx: &LateContext<'_>, expr: &'tcx Expr<'tcx>) -> Option<&'tc
         }
     }
 
-    if let ExprKind::Match(_, ref arms, ref source) = expr.kind {
+    if let ExprKind::Match(_, arms, ref source) = expr.kind {
         // desugared from a `?` operator
         if let MatchSource::TryDesugar = *source {
             return Some(expr);
@@ -1254,7 +1254,7 @@ pub fn match_function_call<'tcx>(
     path: &[&str],
 ) -> Option<&'tcx [Expr<'tcx>]> {
     if_chain! {
-        if let ExprKind::Call(ref fun, args) = expr.kind;
+        if let ExprKind::Call(fun, args) = expr.kind;
         if let ExprKind::Path(ref qpath) = fun.kind;
         if let Some(fun_def_id) = cx.qpath_res(qpath, fun.hir_id).opt_def_id();
         if match_def_path(cx, fun_def_id, path);
@@ -1316,15 +1316,15 @@ pub fn if_sequence<'tcx>(mut expr: &'tcx Expr<'tcx>) -> (Vec<&'tcx Expr<'tcx>>,
     let mut conds = Vec::new();
     let mut blocks: Vec<&Block<'_>> = Vec::new();
 
-    while let ExprKind::If(ref cond, ref then_expr, ref else_expr) = expr.kind {
-        conds.push(&**cond);
-        if let ExprKind::Block(ref block, _) = then_expr.kind {
+    while let ExprKind::If(cond, then_expr, ref else_expr) = expr.kind {
+        conds.push(cond);
+        if let ExprKind::Block(block, _) = then_expr.kind {
             blocks.push(block);
         } else {
             panic!("ExprKind::If node is not an ExprKind::Block");
         }
 
-        if let Some(ref else_expr) = *else_expr {
+        if let Some(else_expr) = *else_expr {
             expr = else_expr;
         } else {
             break;
@@ -1333,8 +1333,8 @@ pub fn if_sequence<'tcx>(mut expr: &'tcx Expr<'tcx>) -> (Vec<&'tcx Expr<'tcx>>,
 
     // final `else {..}`
     if !blocks.is_empty() {
-        if let ExprKind::Block(ref block, _) = expr.kind {
-            blocks.push(&**block);
+        if let ExprKind::Block(block, _) = expr.kind {
+            blocks.push(block);
         }
     }
 
@@ -1383,7 +1383,7 @@ pub fn must_use_attr(attrs: &[Attribute]) -> Option<&Attribute> {
 // check if expr is calling method or function with #[must_use] attribute
 pub fn is_must_use_func_call(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
     let did = match expr.kind {
-        ExprKind::Call(ref path, _) => if_chain! {
+        ExprKind::Call(path, _) => if_chain! {
             if let ExprKind::Path(ref qpath) = path.kind;
             if let def::Res::Def(_, did) = cx.qpath_res(qpath, path.hir_id);
             then {
@@ -1396,7 +1396,7 @@ pub fn is_must_use_func_call(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
         _ => None,
     };
 
-    did.map_or(false, |did| must_use_attr(&cx.tcx.get_attrs(did)).is_some())
+    did.map_or(false, |did| must_use_attr(cx.tcx.get_attrs(did)).is_some())
 }
 
 /// Gets the node where an expression is either used, or it's type is unified with another branch.
diff --git a/clippy_utils/src/numeric_literal.rs b/clippy_utils/src/numeric_literal.rs
index 268bc5b3205..546706d51d7 100644
--- a/clippy_utils/src/numeric_literal.rs
+++ b/clippy_utils/src/numeric_literal.rs
@@ -52,7 +52,7 @@ impl<'a> NumericLiteral<'a> {
 
     pub fn from_lit_kind(src: &'a str, lit_kind: &LitKind) -> Option<NumericLiteral<'a>> {
         if lit_kind.is_numeric() && src.chars().next().map_or(false, |c| c.is_digit(10)) {
-            let (unsuffixed, suffix) = split_suffix(&src, lit_kind);
+            let (unsuffixed, suffix) = split_suffix(src, lit_kind);
             let float = matches!(lit_kind, LitKind::Float(..));
             Some(NumericLiteral::new(unsuffixed, suffix, float))
         } else {
diff --git a/clippy_utils/src/ptr.rs b/clippy_utils/src/ptr.rs
index 5885cc83560..791688cd194 100644
--- a/clippy_utils/src/ptr.rs
+++ b/clippy_utils/src/ptr.rs
@@ -55,7 +55,7 @@ impl<'a, 'tcx> Visitor<'tcx> for PtrCloneVisitor<'a, 'tcx> {
         if self.abort {
             return;
         }
-        if let ExprKind::MethodCall(ref seg, _, ref args, _) = expr.kind {
+        if let ExprKind::MethodCall(seg, _, args, _) = expr.kind {
             if args.len() == 1 && match_var(&args[0], self.name) {
                 if seg.ident.name.as_str() == "capacity" {
                     self.abort = true;
@@ -79,5 +79,5 @@ impl<'a, 'tcx> Visitor<'tcx> for PtrCloneVisitor<'a, 'tcx> {
 }
 
 fn get_binding_name(arg: &Param<'_>) -> Option<Symbol> {
-    get_pat_name(&arg.pat)
+    get_pat_name(arg.pat)
 }
diff --git a/clippy_utils/src/qualify_min_const_fn.rs b/clippy_utils/src/qualify_min_const_fn.rs
index a08dcf19e5b..0e6ead675c2 100644
--- a/clippy_utils/src/qualify_min_const_fn.rs
+++ b/clippy_utils/src/qualify_min_const_fn.rs
@@ -255,7 +255,7 @@ fn check_place(tcx: TyCtxt<'tcx>, place: Place<'tcx>, span: Span, body: &Body<'t
         cursor = proj_base;
         match elem {
             ProjectionElem::Field(..) => {
-                let base_ty = Place::ty_from(place.local, &proj_base, body, tcx).ty;
+                let base_ty = Place::ty_from(place.local, proj_base, body, tcx).ty;
                 if let Some(def) = base_ty.ty_adt_def() {
                     // No union field accesses in `const fn`
                     if def.is_union() {
diff --git a/clippy_utils/src/ty.rs b/clippy_utils/src/ty.rs
index c36e215f184..a92d3be5d3c 100644
--- a/clippy_utils/src/ty.rs
+++ b/clippy_utils/src/ty.rs
@@ -142,21 +142,18 @@ pub fn has_drop<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
 // Returns whether the type has #[must_use] attribute
 pub fn is_must_use_ty<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
     match ty.kind() {
-        ty::Adt(ref adt, _) => must_use_attr(&cx.tcx.get_attrs(adt.did)).is_some(),
-        ty::Foreign(ref did) => must_use_attr(&cx.tcx.get_attrs(*did)).is_some(),
-        ty::Slice(ref ty)
-        | ty::Array(ref ty, _)
-        | ty::RawPtr(ty::TypeAndMut { ref ty, .. })
-        | ty::Ref(_, ref ty, _) => {
+        ty::Adt(adt, _) => must_use_attr(cx.tcx.get_attrs(adt.did)).is_some(),
+        ty::Foreign(ref did) => must_use_attr(cx.tcx.get_attrs(*did)).is_some(),
+        ty::Slice(ty) | ty::Array(ty, _) | ty::RawPtr(ty::TypeAndMut { ty, .. }) | ty::Ref(_, ty, _) => {
             // for the Array case we don't need to care for the len == 0 case
             // because we don't want to lint functions returning empty arrays
             is_must_use_ty(cx, *ty)
         },
-        ty::Tuple(ref substs) => substs.types().any(|ty| is_must_use_ty(cx, ty)),
+        ty::Tuple(substs) => substs.types().any(|ty| is_must_use_ty(cx, ty)),
         ty::Opaque(ref def_id, _) => {
             for (predicate, _) in cx.tcx.explicit_item_bounds(*def_id) {
                 if let ty::PredicateKind::Trait(trait_predicate, _) = predicate.kind().skip_binder() {
-                    if must_use_attr(&cx.tcx.get_attrs(trait_predicate.trait_ref.def_id)).is_some() {
+                    if must_use_attr(cx.tcx.get_attrs(trait_predicate.trait_ref.def_id)).is_some() {
                         return true;
                     }
                 }
@@ -166,7 +163,7 @@ pub fn is_must_use_ty<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
         ty::Dynamic(binder, _) => {
             for predicate in binder.iter() {
                 if let ty::ExistentialPredicate::Trait(ref trait_ref) = predicate.skip_binder() {
-                    if must_use_attr(&cx.tcx.get_attrs(trait_ref.def_id)).is_some() {
+                    if must_use_attr(cx.tcx.get_attrs(trait_ref.def_id)).is_some() {
                         return true;
                     }
                 }
@@ -305,7 +302,7 @@ pub fn type_is_unsafe_function<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bo
 /// Returns the base type for HIR references and pointers.
 pub fn walk_ptrs_hir_ty<'tcx>(ty: &'tcx hir::Ty<'tcx>) -> &'tcx hir::Ty<'tcx> {
     match ty.kind {
-        TyKind::Ptr(ref mut_ty) | TyKind::Rptr(_, ref mut_ty) => walk_ptrs_hir_ty(&mut_ty.ty),
+        TyKind::Ptr(ref mut_ty) | TyKind::Rptr(_, ref mut_ty) => walk_ptrs_hir_ty(mut_ty.ty),
         _ => ty,
     }
 }
diff --git a/clippy_utils/src/usage.rs b/clippy_utils/src/usage.rs
index 650b70c63af..31d5a888c69 100644
--- a/clippy_utils/src/usage.rs
+++ b/clippy_utils/src/usage.rs
@@ -71,12 +71,12 @@ impl<'tcx> Delegate<'tcx> for MutVarsDelegate {
 
     fn borrow(&mut self, cmt: &PlaceWithHirId<'tcx>, _: HirId, bk: ty::BorrowKind) {
         if let ty::BorrowKind::MutBorrow = bk {
-            self.update(&cmt)
+            self.update(cmt)
         }
     }
 
     fn mutate(&mut self, cmt: &PlaceWithHirId<'tcx>, _: HirId) {
-        self.update(&cmt)
+        self.update(cmt)
     }
 
     fn fake_read(&mut self, _: rustc_typeck::expr_use_visitor::Place<'tcx>, _: FakeReadCause, _: HirId) {}
-- 
cgit 1.4.1-3-g733a5


From 7db0e4f791cf8baf3fe8e978a9056d0d8464a1bd Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Fri, 21 May 2021 12:27:40 -0400
Subject: Suggest `&mut iter` inside a closure for `while_let_on_iterator`

---
 clippy_lints/src/loops/while_let_on_iterator.rs | 11 +++++++----
 clippy_utils/src/lib.rs                         | 10 ++++++----
 tests/ui/while_let_on_iterator.fixed            | 14 ++++++++++++++
 tests/ui/while_let_on_iterator.rs               | 14 ++++++++++++++
 tests/ui/while_let_on_iterator.stderr           | 10 ++++++++--
 5 files changed, 49 insertions(+), 10 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/while_let_on_iterator.rs b/clippy_lints/src/loops/while_let_on_iterator.rs
index 63560047578..d57588716a5 100644
--- a/clippy_lints/src/loops/while_let_on_iterator.rs
+++ b/clippy_lints/src/loops/while_let_on_iterator.rs
@@ -1,7 +1,9 @@
 use super::WHILE_LET_ON_ITERATOR;
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::{get_enclosing_loop, is_refutable, is_trait_method, match_def_path, paths, visitors::is_res_used};
+use clippy_utils::{
+    get_enclosing_loop_or_closure, is_refutable, is_trait_method, match_def_path, paths, visitors::is_res_used,
+};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_expr, ErasedMap, NestedVisitorMap, Visitor};
@@ -315,9 +317,10 @@ fn needs_mutable_borrow(cx: &LateContext<'tcx>, iter_expr: &IterExpr, loop_expr:
         }
     }
 
-    if let Some(e) = get_enclosing_loop(cx.tcx, loop_expr) {
-        // The iterator expression will be used on the next iteration unless it is declared within the outer
-        // loop.
+    if let Some(e) = get_enclosing_loop_or_closure(cx.tcx, loop_expr) {
+        // The iterator expression will be used on the next iteration (for loops), or on the next call (for
+        // closures) unless it is declared within the enclosing expression. TODO: Check for closures
+        // used where an `FnOnce` type is expected.
         let local_id = match iter_expr.path {
             Res::Local(id) => id,
             _ => return true,
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 2b9b214daa7..d32c3ec929a 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -861,14 +861,16 @@ pub fn get_enclosing_block<'tcx>(cx: &LateContext<'tcx>, hir_id: HirId) -> Optio
     })
 }
 
-/// Gets the loop enclosing the given expression, if any.
-pub fn get_enclosing_loop(tcx: TyCtxt<'tcx>, expr: &Expr<'_>) -> Option<&'tcx Expr<'tcx>> {
+/// Gets the loop or closure enclosing the given expression, if any.
+pub fn get_enclosing_loop_or_closure(tcx: TyCtxt<'tcx>, expr: &Expr<'_>) -> Option<&'tcx Expr<'tcx>> {
     let map = tcx.hir();
     for (_, node) in map.parent_iter(expr.hir_id) {
         match node {
             Node::Expr(
-                e @ Expr {
-                    kind: ExprKind::Loop(..),
+                e
+                @
+                Expr {
+                    kind: ExprKind::Loop(..) | ExprKind::Closure(..),
                     ..
                 },
             ) => return Some(e),
diff --git a/tests/ui/while_let_on_iterator.fixed b/tests/ui/while_let_on_iterator.fixed
index c3e2cf0c4a4..52e80ceee83 100644
--- a/tests/ui/while_let_on_iterator.fixed
+++ b/tests/ui/while_let_on_iterator.fixed
@@ -320,6 +320,20 @@ fn issue1924() {
     println!("iterator field {}", it.1);
 }
 
+fn issue7249() {
+    let mut it = 0..10;
+    let mut x = || {
+        // Needs &mut, the closure can be called multiple times
+        for x in &mut it {
+            if x % 2 == 0 {
+                break;
+            }
+        }
+    };
+    x();
+    x();
+}
+
 fn main() {
     let mut it = 0..20;
     for _ in it {
diff --git a/tests/ui/while_let_on_iterator.rs b/tests/ui/while_let_on_iterator.rs
index 1717006a449..5078a3c9028 100644
--- a/tests/ui/while_let_on_iterator.rs
+++ b/tests/ui/while_let_on_iterator.rs
@@ -320,6 +320,20 @@ fn issue1924() {
     println!("iterator field {}", it.1);
 }
 
+fn issue7249() {
+    let mut it = 0..10;
+    let mut x = || {
+        // Needs &mut, the closure can be called multiple times
+        while let Some(x) = it.next() {
+            if x % 2 == 0 {
+                break;
+            }
+        }
+    };
+    x();
+    x();
+}
+
 fn main() {
     let mut it = 0..20;
     while let Some(..) = it.next() {
diff --git a/tests/ui/while_let_on_iterator.stderr b/tests/ui/while_let_on_iterator.stderr
index eff559bef7e..cb0afeae15e 100644
--- a/tests/ui/while_let_on_iterator.stderr
+++ b/tests/ui/while_let_on_iterator.stderr
@@ -105,10 +105,16 @@ LL |     while let Some(n) = it.next() {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for n in &mut it`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:325:5
+  --> $DIR/while_let_on_iterator.rs:327:9
+   |
+LL |         while let Some(x) = it.next() {
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for x in &mut it`
+
+error: this loop could be written as a `for` loop
+  --> $DIR/while_let_on_iterator.rs:339:5
    |
 LL |     while let Some(..) = it.next() {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for _ in it`
 
-error: aborting due to 18 previous errors
+error: aborting due to 19 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 60dd2b65dcb10f10c02e90300941bc698fa4a39b Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Fri, 21 May 2021 15:42:57 -0400
Subject: Fix `redundant_closure` for `vec![]` macro in a closure with
 arguments

---
 clippy_lints/src/eta_reduction.rs | 24 +++++++++++++-----------
 tests/ui/eta.fixed                |  3 +++
 tests/ui/eta.rs                   |  3 +++
 tests/ui/eta.stderr               | 16 ++++++++--------
 4 files changed, 27 insertions(+), 19 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/eta_reduction.rs b/clippy_lints/src/eta_reduction.rs
index 2f1aa53236d..afc5d546474 100644
--- a/clippy_lints/src/eta_reduction.rs
+++ b/clippy_lints/src/eta_reduction.rs
@@ -92,17 +92,19 @@ fn check_closure(cx: &LateContext<'_>, expr: &Expr<'_>) {
         let ex = &body.value;
 
         if ex.span.ctxt() != expr.span.ctxt() {
-            if let Some(VecArgs::Vec(&[])) = higher::vec_macro(cx, ex) {
-                // replace `|| vec![]` with `Vec::new`
-                span_lint_and_sugg(
-                    cx,
-                    REDUNDANT_CLOSURE,
-                    expr.span,
-                    "redundant closure",
-                    "replace the closure with `Vec::new`",
-                    "std::vec::Vec::new".into(),
-                    Applicability::MachineApplicable,
-                );
+            if decl.inputs.is_empty() {
+                if let Some(VecArgs::Vec(&[])) = higher::vec_macro(cx, ex) {
+                    // replace `|| vec![]` with `Vec::new`
+                    span_lint_and_sugg(
+                        cx,
+                        REDUNDANT_CLOSURE,
+                        expr.span,
+                        "redundant closure",
+                        "replace the closure with `Vec::new`",
+                        "std::vec::Vec::new".into(),
+                        Applicability::MachineApplicable,
+                    );
+                }
             }
             // skip `foo(|| macro!())`
             return;
diff --git a/tests/ui/eta.fixed b/tests/ui/eta.fixed
index 2be2283e3fd..9e752311c67 100644
--- a/tests/ui/eta.fixed
+++ b/tests/ui/eta.fixed
@@ -48,6 +48,9 @@ fn main() {
     // See #515
     let a: Option<Box<dyn (::std::ops::Deref<Target = [i32]>)>> =
         Some(vec![1i32, 2]).map(|v| -> Box<dyn (::std::ops::Deref<Target = [i32]>)> { Box::new(v) });
+
+    // issue #7224
+    let _: Option<Vec<u32>> = Some(0).map(|_| vec![]);
 }
 
 trait TestTrait {
diff --git a/tests/ui/eta.rs b/tests/ui/eta.rs
index f0373f9ccf6..44be4628cbd 100644
--- a/tests/ui/eta.rs
+++ b/tests/ui/eta.rs
@@ -48,6 +48,9 @@ fn main() {
     // See #515
     let a: Option<Box<dyn (::std::ops::Deref<Target = [i32]>)>> =
         Some(vec![1i32, 2]).map(|v| -> Box<dyn (::std::ops::Deref<Target = [i32]>)> { Box::new(v) });
+
+    // issue #7224
+    let _: Option<Vec<u32>> = Some(0).map(|_| vec![]);
 }
 
 trait TestTrait {
diff --git a/tests/ui/eta.stderr b/tests/ui/eta.stderr
index 57ed6527966..8795d3b42c6 100644
--- a/tests/ui/eta.stderr
+++ b/tests/ui/eta.stderr
@@ -33,7 +33,7 @@ LL |     let e = Some(1u8).map(|a| generic(a));
    |                           ^^^^^^^^^^^^^^ help: replace the closure with the function itself: `generic`
 
 error: redundant closure
-  --> $DIR/eta.rs:89:51
+  --> $DIR/eta.rs:92:51
    |
 LL |     let e = Some(TestStruct { some_ref: &i }).map(|a| a.foo());
    |                                                   ^^^^^^^^^^^ help: replace the closure with the method itself: `TestStruct::foo`
@@ -41,43 +41,43 @@ LL |     let e = Some(TestStruct { some_ref: &i }).map(|a| a.foo());
    = note: `-D clippy::redundant-closure-for-method-calls` implied by `-D warnings`
 
 error: redundant closure
-  --> $DIR/eta.rs:91:51
+  --> $DIR/eta.rs:94:51
    |
 LL |     let e = Some(TestStruct { some_ref: &i }).map(|a| a.trait_foo());
    |                                                   ^^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `TestTrait::trait_foo`
 
 error: redundant closure
-  --> $DIR/eta.rs:94:42
+  --> $DIR/eta.rs:97:42
    |
 LL |     let e = Some(&mut vec![1, 2, 3]).map(|v| v.clear());
    |                                          ^^^^^^^^^^^^^ help: replace the closure with the method itself: `std::vec::Vec::clear`
 
 error: redundant closure
-  --> $DIR/eta.rs:99:29
+  --> $DIR/eta.rs:102:29
    |
 LL |     let e = Some("str").map(|s| s.to_string());
    |                             ^^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `std::string::ToString::to_string`
 
 error: redundant closure
-  --> $DIR/eta.rs:101:27
+  --> $DIR/eta.rs:104:27
    |
 LL |     let e = Some('a').map(|s| s.to_uppercase());
    |                           ^^^^^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `char::to_uppercase`
 
 error: redundant closure
-  --> $DIR/eta.rs:104:65
+  --> $DIR/eta.rs:107:65
    |
 LL |     let e: std::vec::Vec<char> = vec!['a', 'b', 'c'].iter().map(|c| c.to_ascii_uppercase()).collect();
    |                                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `char::to_ascii_uppercase`
 
 error: redundant closure
-  --> $DIR/eta.rs:187:27
+  --> $DIR/eta.rs:190:27
    |
 LL |     let a = Some(1u8).map(|a| foo_ptr(a));
    |                           ^^^^^^^^^^^^^^ help: replace the closure with the function itself: `foo_ptr`
 
 error: redundant closure
-  --> $DIR/eta.rs:192:27
+  --> $DIR/eta.rs:195:27
    |
 LL |     let a = Some(1u8).map(|a| closure(a));
    |                           ^^^^^^^^^^^^^^ help: replace the closure with the function itself: `closure`
-- 
cgit 1.4.1-3-g733a5


From ae0d4da764fd751494fb270fd04c2c686eac1302 Mon Sep 17 00:00:00 2001
From: Yotam Ofek <yotam.ofek@gmail.com>
Date: Sat, 22 May 2021 21:47:11 +0300
Subject: Fix invalid syntax in `from_iter_instead_of_collect` suggestion with
 "as Trait"

---
 .../src/methods/from_iter_instead_of_collect.rs    | 47 ++++++++++++++--------
 tests/ui/from_iter_instead_of_collect.fixed        | 14 +++++++
 tests/ui/from_iter_instead_of_collect.rs           | 14 +++++++
 tests/ui/from_iter_instead_of_collect.stderr       | 40 ++++++++++--------
 4 files changed, 81 insertions(+), 34 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/from_iter_instead_of_collect.rs b/clippy_lints/src/methods/from_iter_instead_of_collect.rs
index 28d0e8cd4ae..b4188d9ed30 100644
--- a/clippy_lints/src/methods/from_iter_instead_of_collect.rs
+++ b/clippy_lints/src/methods/from_iter_instead_of_collect.rs
@@ -37,6 +37,10 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::Exp
 }
 
 fn extract_turbofish(cx: &LateContext<'_>, expr: &hir::Expr<'_>, ty: Ty<'tcx>) -> String {
+    fn strip_angle_brackets(s: &str) -> Option<&str> {
+        s.strip_prefix('<')?.strip_suffix('>')
+    }
+
     let call_site = expr.span.source_callsite();
     if_chain! {
         if let Ok(snippet) = cx.sess().source_map().span_to_snippet(call_site);
@@ -44,23 +48,32 @@ fn extract_turbofish(cx: &LateContext<'_>, expr: &hir::Expr<'_>, ty: Ty<'tcx>) -
         if let Some((_, elements)) = snippet_split.split_last();
 
         then {
-            // is there a type specifier? (i.e.: like `<u32>` in `collections::BTreeSet::<u32>::`)
-            if let Some(type_specifier) = snippet_split.iter().find(|e| e.starts_with('<') && e.ends_with('>')) {
-                // remove the type specifier from the path elements
-                let without_ts = elements.iter().filter_map(|e| {
-                    if e == type_specifier { None } else { Some((*e).to_string()) }
-                }).collect::<Vec<_>>();
-                // join and add the type specifier at the end (i.e.: `collections::BTreeSet<u32>`)
-                format!("{}{}", without_ts.join("::"), type_specifier)
-            } else {
-                // type is not explicitly specified so wildcards are needed
-                // i.e.: 2 wildcards in `std::collections::BTreeMap<&i32, &char>`
-                let ty_str = ty.to_string();
-                let start = ty_str.find('<').unwrap_or(0);
-                let end = ty_str.find('>').unwrap_or_else(|| ty_str.len());
-                let nb_wildcard = ty_str[start..end].split(',').count();
-                let wildcards = format!("_{}", ", _".repeat(nb_wildcard - 1));
-                format!("{}<{}>", elements.join("::"), wildcards)
+            if_chain! {
+                if let [type_specifier, _] = snippet_split.as_slice();
+                if let Some(type_specifier) = strip_angle_brackets(type_specifier);
+                if let Some((type_specifier, ..)) = type_specifier.split_once(" as ");
+                then {
+                    type_specifier.to_string()
+                } else {
+                    // is there a type specifier? (i.e.: like `<u32>` in `collections::BTreeSet::<u32>::`)
+                    if let Some(type_specifier) = snippet_split.iter().find(|e| strip_angle_brackets(e).is_some()) {
+                        // remove the type specifier from the path elements
+                        let without_ts = elements.iter().filter_map(|e| {
+                            if e == type_specifier { None } else { Some((*e).to_string()) }
+                        }).collect::<Vec<_>>();
+                        // join and add the type specifier at the end (i.e.: `collections::BTreeSet<u32>`)
+                        format!("{}{}", without_ts.join("::"), type_specifier)
+                    } else {
+                        // type is not explicitly specified so wildcards are needed
+                        // i.e.: 2 wildcards in `std::collections::BTreeMap<&i32, &char>`
+                        let ty_str = ty.to_string();
+                        let start = ty_str.find('<').unwrap_or(0);
+                        let end = ty_str.find('>').unwrap_or_else(|| ty_str.len());
+                        let nb_wildcard = ty_str[start..end].split(',').count();
+                        let wildcards = format!("_{}", ", _".repeat(nb_wildcard - 1));
+                        format!("{}<{}>", elements.join("::"), wildcards)
+                    }
+                }
             }
         } else {
             ty.to_string()
diff --git a/tests/ui/from_iter_instead_of_collect.fixed b/tests/ui/from_iter_instead_of_collect.fixed
index b5f548810e6..12db43b5343 100644
--- a/tests/ui/from_iter_instead_of_collect.fixed
+++ b/tests/ui/from_iter_instead_of_collect.fixed
@@ -6,6 +6,20 @@
 use std::collections::{BTreeMap, BTreeSet, HashMap, VecDeque};
 use std::iter::FromIterator;
 
+struct Foo(Vec<bool>);
+
+impl FromIterator<bool> for Foo {
+    fn from_iter<T: IntoIterator<Item = bool>>(_: T) -> Self {
+        todo!()
+    }
+}
+
+impl<'a> FromIterator<&'a bool> for Foo {
+    fn from_iter<T: IntoIterator<Item = &'a bool>>(iter: T) -> Self {
+        iter.into_iter().copied().collect::<Self>()
+    }
+}
+
 fn main() {
     let iter_expr = std::iter::repeat(5).take(5);
     let _ = iter_expr.collect::<Vec<_>>();
diff --git a/tests/ui/from_iter_instead_of_collect.rs b/tests/ui/from_iter_instead_of_collect.rs
index b842b5451d1..f5ec190e0cd 100644
--- a/tests/ui/from_iter_instead_of_collect.rs
+++ b/tests/ui/from_iter_instead_of_collect.rs
@@ -6,6 +6,20 @@
 use std::collections::{BTreeMap, BTreeSet, HashMap, VecDeque};
 use std::iter::FromIterator;
 
+struct Foo(Vec<bool>);
+
+impl FromIterator<bool> for Foo {
+    fn from_iter<T: IntoIterator<Item = bool>>(_: T) -> Self {
+        todo!()
+    }
+}
+
+impl<'a> FromIterator<&'a bool> for Foo {
+    fn from_iter<T: IntoIterator<Item = &'a bool>>(iter: T) -> Self {
+        <Self as FromIterator<bool>>::from_iter(iter.into_iter().copied())
+    }
+}
+
 fn main() {
     let iter_expr = std::iter::repeat(5).take(5);
     let _ = Vec::from_iter(iter_expr);
diff --git a/tests/ui/from_iter_instead_of_collect.stderr b/tests/ui/from_iter_instead_of_collect.stderr
index 434734c9a21..8f08ac8c3ff 100644
--- a/tests/ui/from_iter_instead_of_collect.stderr
+++ b/tests/ui/from_iter_instead_of_collect.stderr
@@ -1,88 +1,94 @@
 error: usage of `FromIterator::from_iter`
-  --> $DIR/from_iter_instead_of_collect.rs:11:13
+  --> $DIR/from_iter_instead_of_collect.rs:19:9
    |
-LL |     let _ = Vec::from_iter(iter_expr);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `iter_expr.collect::<Vec<_>>()`
+LL |         <Self as FromIterator<bool>>::from_iter(iter.into_iter().copied())
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `iter.into_iter().copied().collect::<Self>()`
    |
    = note: `-D clippy::from-iter-instead-of-collect` implied by `-D warnings`
 
 error: usage of `FromIterator::from_iter`
-  --> $DIR/from_iter_instead_of_collect.rs:13:13
+  --> $DIR/from_iter_instead_of_collect.rs:25:13
+   |
+LL |     let _ = Vec::from_iter(iter_expr);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `iter_expr.collect::<Vec<_>>()`
+
+error: usage of `FromIterator::from_iter`
+  --> $DIR/from_iter_instead_of_collect.rs:27:13
    |
 LL |     let _ = HashMap::<usize, &i8>::from_iter(vec![5, 5, 5, 5].iter().enumerate());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `vec![5, 5, 5, 5].iter().enumerate().collect::<HashMap<usize, &i8>>()`
 
 error: usage of `FromIterator::from_iter`
-  --> $DIR/from_iter_instead_of_collect.rs:18:19
+  --> $DIR/from_iter_instead_of_collect.rs:32:19
    |
 LL |     assert_eq!(a, Vec::from_iter(0..3));
    |                   ^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `(0..3).collect::<Vec<_>>()`
 
 error: usage of `FromIterator::from_iter`
-  --> $DIR/from_iter_instead_of_collect.rs:19:19
+  --> $DIR/from_iter_instead_of_collect.rs:33:19
    |
 LL |     assert_eq!(a, Vec::<i32>::from_iter(0..3));
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `(0..3).collect::<Vec<i32>>()`
 
 error: usage of `FromIterator::from_iter`
-  --> $DIR/from_iter_instead_of_collect.rs:21:17
+  --> $DIR/from_iter_instead_of_collect.rs:35:17
    |
 LL |     let mut b = VecDeque::from_iter(0..3);
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `(0..3).collect::<VecDeque<_>>()`
 
 error: usage of `FromIterator::from_iter`
-  --> $DIR/from_iter_instead_of_collect.rs:24:17
+  --> $DIR/from_iter_instead_of_collect.rs:38:17
    |
 LL |     let mut b = VecDeque::<i32>::from_iter(0..3);
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `(0..3).collect::<VecDeque<i32>>()`
 
 error: usage of `FromIterator::from_iter`
-  --> $DIR/from_iter_instead_of_collect.rs:29:21
+  --> $DIR/from_iter_instead_of_collect.rs:43:21
    |
 LL |         let mut b = collections::VecDeque::<i32>::from_iter(0..3);
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `(0..3).collect::<collections::VecDeque<i32>>()`
 
 error: usage of `FromIterator::from_iter`
-  --> $DIR/from_iter_instead_of_collect.rs:34:14
+  --> $DIR/from_iter_instead_of_collect.rs:48:14
    |
 LL |     let bm = BTreeMap::from_iter(values.iter().cloned());
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `values.iter().cloned().collect::<BTreeMap<_, _>>()`
 
 error: usage of `FromIterator::from_iter`
-  --> $DIR/from_iter_instead_of_collect.rs:35:19
+  --> $DIR/from_iter_instead_of_collect.rs:49:19
    |
 LL |     let mut bar = BTreeMap::from_iter(bm.range(0..2));
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `bm.range(0..2).collect::<BTreeMap<_, _>>()`
 
 error: usage of `FromIterator::from_iter`
-  --> $DIR/from_iter_instead_of_collect.rs:38:19
+  --> $DIR/from_iter_instead_of_collect.rs:52:19
    |
 LL |     let mut bts = BTreeSet::from_iter(0..3);
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `(0..3).collect::<BTreeSet<_>>()`
 
 error: usage of `FromIterator::from_iter`
-  --> $DIR/from_iter_instead_of_collect.rs:42:17
+  --> $DIR/from_iter_instead_of_collect.rs:56:17
    |
 LL |         let _ = collections::BTreeSet::from_iter(0..3);
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `(0..3).collect::<collections::BTreeSet<_>>()`
 
 error: usage of `FromIterator::from_iter`
-  --> $DIR/from_iter_instead_of_collect.rs:43:17
+  --> $DIR/from_iter_instead_of_collect.rs:57:17
    |
 LL |         let _ = collections::BTreeSet::<u32>::from_iter(0..3);
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `(0..3).collect::<collections::BTreeSet<u32>>()`
 
 error: usage of `FromIterator::from_iter`
-  --> $DIR/from_iter_instead_of_collect.rs:46:15
+  --> $DIR/from_iter_instead_of_collect.rs:60:15
    |
 LL |     for _i in Vec::from_iter([1, 2, 3].iter()) {}
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `[1, 2, 3].iter().collect::<Vec<_>>()`
 
 error: usage of `FromIterator::from_iter`
-  --> $DIR/from_iter_instead_of_collect.rs:47:15
+  --> $DIR/from_iter_instead_of_collect.rs:61:15
    |
 LL |     for _i in Vec::<&i32>::from_iter([1, 2, 3].iter()) {}
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `[1, 2, 3].iter().collect::<Vec<&i32>>()`
 
-error: aborting due to 14 previous errors
+error: aborting due to 15 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 2f78d57d8b4328867b33928f613e6d773f310869 Mon Sep 17 00:00:00 2001
From: Michael Wright <mikerite@lavabit.com>
Date: Mon, 24 May 2021 06:42:20 +0200
Subject: Downgrade suspicious_op..._groupings to Nursery

This addresses #6722.
---
 clippy_lints/src/lib.rs                            | 3 +--
 clippy_lints/src/suspicious_operation_groupings.rs | 2 +-
 2 files changed, 2 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 877d9054d7b..60029d17374 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1408,7 +1408,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(slow_vector_initialization::SLOW_VECTOR_INITIALIZATION),
         LintId::of(stable_sort_primitive::STABLE_SORT_PRIMITIVE),
         LintId::of(strings::STRING_FROM_UTF8_AS_BYTES),
-        LintId::of(suspicious_operation_groupings::SUSPICIOUS_OPERATION_GROUPINGS),
         LintId::of(suspicious_trait_impl::SUSPICIOUS_ARITHMETIC_IMPL),
         LintId::of(suspicious_trait_impl::SUSPICIOUS_OP_ASSIGN_IMPL),
         LintId::of(swap::ALMOST_SWAPPED),
@@ -1562,7 +1561,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(returns::LET_AND_RETURN),
         LintId::of(returns::NEEDLESS_RETURN),
         LintId::of(single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS),
-        LintId::of(suspicious_operation_groupings::SUSPICIOUS_OPERATION_GROUPINGS),
         LintId::of(tabs_in_doc_comments::TABS_IN_DOC_COMMENTS),
         LintId::of(to_digit_is_some::TO_DIGIT_IS_SOME),
         LintId::of(try_err::TRY_ERR),
@@ -1789,6 +1787,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(redundant_pub_crate::REDUNDANT_PUB_CRATE),
         LintId::of(regex::TRIVIAL_REGEX),
         LintId::of(strings::STRING_LIT_AS_BYTES),
+        LintId::of(suspicious_operation_groupings::SUSPICIOUS_OPERATION_GROUPINGS),
         LintId::of(transmute::USELESS_TRANSMUTE),
         LintId::of(use_self::USE_SELF),
     ]);
diff --git a/clippy_lints/src/suspicious_operation_groupings.rs b/clippy_lints/src/suspicious_operation_groupings.rs
index 4272935bc31..8056887d714 100644
--- a/clippy_lints/src/suspicious_operation_groupings.rs
+++ b/clippy_lints/src/suspicious_operation_groupings.rs
@@ -59,7 +59,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     pub SUSPICIOUS_OPERATION_GROUPINGS,
-    style,
+    nursery,
     "groupings of binary operations that look suspiciously like typos"
 }
 
-- 
cgit 1.4.1-3-g733a5


From 24743b39683ef1f69e3156c312ab12d9265ca7bb Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Wed, 12 May 2021 10:50:19 -0500
Subject: Use UnhashMap

---
 clippy_lints/src/trait_bounds.rs | 3 ++-
 clippy_utils/src/lib.rs          | 6 +++---
 2 files changed, 5 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/trait_bounds.rs b/clippy_lints/src/trait_bounds.rs
index b0589b0512e..74a94db1800 100644
--- a/clippy_lints/src/trait_bounds.rs
+++ b/clippy_lints/src/trait_bounds.rs
@@ -3,6 +3,7 @@ use clippy_utils::source::{snippet, snippet_with_applicability};
 use clippy_utils::{in_macro, SpanlessHash};
 use if_chain::if_chain;
 use rustc_data_structures::fx::FxHashMap;
+use rustc_data_structures::unhash::UnhashMap;
 use rustc_errors::Applicability;
 use rustc_hir::{def::Res, GenericBound, Generics, ParamName, Path, QPath, TyKind, WherePredicate};
 use rustc_lint::{LateContext, LateLintPass};
@@ -100,7 +101,7 @@ impl TraitBounds {
             hasher.hash_ty(ty);
             hasher.finish()
         };
-        let mut map = FxHashMap::default();
+        let mut map: UnhashMap<u64, Vec<&GenericBound<'_>>> = UnhashMap::default();
         let mut applicability = Applicability::MaybeIncorrect;
         for bound in gen.where_clause.predicates {
             if_chain! {
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 610011af059..18b7e6cd4bc 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -63,7 +63,7 @@ use std::hash::BuildHasherDefault;
 
 use if_chain::if_chain;
 use rustc_ast::ast::{self, Attribute, BorrowKind, LitKind};
-use rustc_data_structures::fx::FxHashMap;
+use rustc_data_structures::unhash::UnhashMap;
 use rustc_hir as hir;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::def_id::DefId;
@@ -1578,8 +1578,8 @@ where
 
     let mut match_expr_list: Vec<(&T, &T)> = Vec::new();
 
-    let mut map: FxHashMap<_, Vec<&_>> =
-        FxHashMap::with_capacity_and_hasher(exprs.len(), BuildHasherDefault::default());
+    let mut map: UnhashMap<u64, Vec<&_>> =
+        UnhashMap::with_capacity_and_hasher(exprs.len(), BuildHasherDefault::default());
 
     for expr in exprs {
         match map.entry(hash(expr)) {
-- 
cgit 1.4.1-3-g733a5


From 1ac7e19b4c2303e6d3168f7c1ba5b8e93c77c455 Mon Sep 17 00:00:00 2001
From: mbartlett21 <29034492+mbartlett21@users.noreply.github.com>
Date: Mon, 24 May 2021 22:09:07 +0000
Subject: Move `semicolon_if_nothing_returned` to `pedantic`

---
 clippy_lints/src/lib.rs                           |  2 +-
 clippy_lints/src/semicolon_if_nothing_returned.rs | 10 +++++-----
 2 files changed, 6 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 60029d17374..cf54021202f 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1038,7 +1038,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(panic_unimplemented::UNIMPLEMENTED),
         LintId::of(panic_unimplemented::UNREACHABLE),
         LintId::of(pattern_type_mismatch::PATTERN_TYPE_MISMATCH),
-        LintId::of(semicolon_if_nothing_returned::SEMICOLON_IF_NOTHING_RETURNED),
         LintId::of(shadow::SHADOW_REUSE),
         LintId::of(shadow::SHADOW_SAME),
         LintId::of(strings::STRING_ADD),
@@ -1129,6 +1128,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(ranges::RANGE_PLUS_ONE),
         LintId::of(redundant_else::REDUNDANT_ELSE),
         LintId::of(ref_option_ref::REF_OPTION_REF),
+        LintId::of(semicolon_if_nothing_returned::SEMICOLON_IF_NOTHING_RETURNED),
         LintId::of(shadow::SHADOW_UNRELATED),
         LintId::of(strings::STRING_ADD_ASSIGN),
         LintId::of(trait_bounds::TRAIT_DUPLICATION_IN_BOUNDS),
diff --git a/clippy_lints/src/semicolon_if_nothing_returned.rs b/clippy_lints/src/semicolon_if_nothing_returned.rs
index 553987a426b..16e4d73851f 100644
--- a/clippy_lints/src/semicolon_if_nothing_returned.rs
+++ b/clippy_lints/src/semicolon_if_nothing_returned.rs
@@ -8,11 +8,11 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
-    /// **What it does:** Looks for blocks of expressions and fires if the last expression returns `()`
-    /// but is not followed by a semicolon.
+    /// **What it does:** Looks for blocks of expressions and fires if the last expression returns
+    /// `()` but is not followed by a semicolon.
     ///
-    /// **Why is this bad?** The semicolon might be optional but when
-    /// extending the block with new code, it doesn't require a change in previous last line.
+    /// **Why is this bad?** The semicolon might be optional but when extending the block with new
+    /// code, it doesn't require a change in previous last line.
     ///
     /// **Known problems:** None.
     ///
@@ -30,7 +30,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     pub SEMICOLON_IF_NOTHING_RETURNED,
-    restriction,
+    pedantic,
     "add a semicolon if nothing is returned"
 }
 
-- 
cgit 1.4.1-3-g733a5


From cadad20da1e970e62ea28f32a2f4a9177e8ca859 Mon Sep 17 00:00:00 2001
From: mbartlett21 <29034492+mbartlett21@users.noreply.github.com>
Date: Tue, 25 May 2021 00:54:50 +0000
Subject: Add semicolons up to `needless_for_each.rs`

---
 clippy_lints/src/assertions_on_constants.rs            |  2 +-
 clippy_lints/src/attrs.rs                              |  6 +++---
 clippy_lints/src/bit_mask.rs                           |  6 +++---
 clippy_lints/src/booleans.rs                           |  6 +++---
 clippy_lints/src/collapsible_if.rs                     |  2 +-
 clippy_lints/src/comparison_chain.rs                   |  2 +-
 clippy_lints/src/copies.rs                             |  2 +-
 clippy_lints/src/default_numeric_fallback.rs           |  4 ++--
 clippy_lints/src/double_comparison.rs                  |  8 ++++----
 clippy_lints/src/entry.rs                              |  2 +-
 clippy_lints/src/eq_op.rs                              | 12 ++++++------
 clippy_lints/src/eta_reduction.rs                      |  7 ++++---
 clippy_lints/src/eval_order_dependence.rs              |  2 +-
 clippy_lints/src/functions/must_use.rs                 |  2 +-
 clippy_lints/src/functions/too_many_lines.rs           |  2 +-
 clippy_lints/src/future_not_send.rs                    |  2 +-
 clippy_lints/src/implicit_return.rs                    |  2 +-
 clippy_lints/src/infinite_iter.rs                      |  2 +-
 clippy_lints/src/invalid_upcast_comparisons.rs         |  4 ++--
 clippy_lints/src/len_zero.rs                           |  4 ++--
 clippy_lints/src/let_underscore.rs                     |  8 ++++----
 clippy_lints/src/lifetimes.rs                          |  4 ++--
 clippy_lints/src/literal_representation.rs             |  8 ++++----
 clippy_lints/src/loops/explicit_iter_loop.rs           |  2 +-
 clippy_lints/src/loops/mut_range_bound.rs              |  8 ++++----
 clippy_lints/src/loops/same_item_push.rs               |  4 ++--
 clippy_lints/src/loops/utils.rs                        |  8 ++++----
 clippy_lints/src/macro_use.rs                          |  6 +++---
 clippy_lints/src/manual_strip.rs                       |  2 +-
 clippy_lints/src/map_clone.rs                          |  6 +++---
 clippy_lints/src/matches.rs                            | 10 +++++-----
 clippy_lints/src/methods/bind_instead_of_map.rs        |  2 +-
 clippy_lints/src/methods/cloned_instead_of_copied.rs   |  2 +-
 clippy_lints/src/methods/flat_map_option.rs            |  2 +-
 clippy_lints/src/methods/mod.rs                        |  8 ++++----
 clippy_lints/src/methods/unnecessary_fold.rs           |  2 +-
 clippy_lints/src/misc_early/mod.rs                     | 10 +++++-----
 clippy_lints/src/mut_reference.rs                      |  2 +-
 clippy_lints/src/mutable_debug_assertion.rs            |  2 +-
 clippy_lints/src/needless_arbitrary_self_type.rs       |  4 ++--
 clippy_lints/src/needless_bool.rs                      | 18 +++++++++---------
 clippy_lints/src/needless_borrow.rs                    |  2 +-
 clippy_lints/src/needless_for_each.rs                  |  2 +-
 clippy_lints/src/utils/author.rs                       |  2 +-
 clippy_lints/src/utils/internal_lints.rs               |  4 ++--
 .../src/utils/internal_lints/metadata_collector.rs     |  2 +-
 46 files changed, 105 insertions(+), 104 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/assertions_on_constants.rs b/clippy_lints/src/assertions_on_constants.rs
index c565e29d078..6c9ceaa45c2 100644
--- a/clippy_lints/src/assertions_on_constants.rs
+++ b/clippy_lints/src/assertions_on_constants.rs
@@ -63,7 +63,7 @@ impl<'tcx> LateLintPass<'tcx> for AssertionsOnConstants {
                 &format!("`assert!(false, {})` should probably be replaced", panic_message),
                 None,
                 &format!("use `panic!({})` or `unreachable!({})`", panic_message, panic_message),
-            )
+            );
         };
 
         if let Some(debug_assert_span) = is_expn_of(e.span, "debug_assert") {
diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs
index c5b01461c1c..932cd58bf62 100644
--- a/clippy_lints/src/attrs.rs
+++ b/clippy_lints/src/attrs.rs
@@ -273,7 +273,7 @@ impl<'tcx> LateLintPass<'tcx> for Attributes {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
         let attrs = cx.tcx.hir().attrs(item.hir_id());
         if is_relevant_item(cx, item) {
-            check_attrs(cx, item.span, item.ident.name, attrs)
+            check_attrs(cx, item.span, item.ident.name, attrs);
         }
         match item.kind {
             ItemKind::ExternCrate(..) | ItemKind::Use(..) => {
@@ -343,13 +343,13 @@ impl<'tcx> LateLintPass<'tcx> for Attributes {
 
     fn check_impl_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx ImplItem<'_>) {
         if is_relevant_impl(cx, item) {
-            check_attrs(cx, item.span, item.ident.name, cx.tcx.hir().attrs(item.hir_id()))
+            check_attrs(cx, item.span, item.ident.name, cx.tcx.hir().attrs(item.hir_id()));
         }
     }
 
     fn check_trait_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx TraitItem<'_>) {
         if is_relevant_trait(cx, item) {
-            check_attrs(cx, item.span, item.ident.name, cx.tcx.hir().attrs(item.hir_id()))
+            check_attrs(cx, item.span, item.ident.name, cx.tcx.hir().attrs(item.hir_id()));
         }
     }
 }
diff --git a/clippy_lints/src/bit_mask.rs b/clippy_lints/src/bit_mask.rs
index f7daf3dab49..0ac6dc28e73 100644
--- a/clippy_lints/src/bit_mask.rs
+++ b/clippy_lints/src/bit_mask.rs
@@ -115,9 +115,9 @@ impl<'tcx> LateLintPass<'tcx> for BitMask {
         if let ExprKind::Binary(cmp, left, right) = &e.kind {
             if cmp.node.is_comparison() {
                 if let Some(cmp_opt) = fetch_int_literal(cx, right) {
-                    check_compare(cx, left, cmp.node, cmp_opt, e.span)
+                    check_compare(cx, left, cmp.node, cmp_opt, e.span);
                 } else if let Some(cmp_val) = fetch_int_literal(cx, left) {
-                    check_compare(cx, right, invert_cmp(cmp.node), cmp_val, e.span)
+                    check_compare(cx, right, invert_cmp(cmp.node), cmp_val, e.span);
                 }
             }
         }
@@ -171,7 +171,7 @@ fn check_compare(cx: &LateContext<'_>, bit_op: &Expr<'_>, cmp_op: BinOpKind, cmp
         }
         fetch_int_literal(cx, right)
             .or_else(|| fetch_int_literal(cx, left))
-            .map_or((), |mask| check_bit_mask(cx, op.node, cmp_op, mask, cmp_value, span))
+            .map_or((), |mask| check_bit_mask(cx, op.node, cmp_op, mask, cmp_value, span));
     }
 }
 
diff --git a/clippy_lints/src/booleans.rs b/clippy_lints/src/booleans.rs
index 67f0e0c7870..e72399af232 100644
--- a/clippy_lints/src/booleans.rs
+++ b/clippy_lints/src/booleans.rs
@@ -66,7 +66,7 @@ impl<'tcx> LateLintPass<'tcx> for NonminimalBool {
         _: Span,
         _: HirId,
     ) {
-        NonminimalBoolVisitor { cx }.visit_body(body)
+        NonminimalBoolVisitor { cx }.visit_body(body);
     }
 }
 
@@ -184,7 +184,7 @@ impl<'a, 'tcx, 'v> SuggestContext<'a, 'tcx, 'v> {
                 Term(n) => {
                     let terminal = self.terminals[n as usize];
                     if let Some(str) = simplify_not(self.cx, terminal) {
-                        self.output.push_str(&str)
+                        self.output.push_str(&str);
                     } else {
                         self.output.push('!');
                         let snip = snippet_opt(self.cx, terminal.span)?;
@@ -452,7 +452,7 @@ impl<'a, 'tcx> Visitor<'tcx> for NonminimalBoolVisitor<'a, 'tcx> {
         }
         match &e.kind {
             ExprKind::Binary(binop, _, _) if binop.node == BinOpKind::Or || binop.node == BinOpKind::And => {
-                self.bool_expr(e)
+                self.bool_expr(e);
             },
             ExprKind::Unary(UnOp::Not, inner) => {
                 if self.cx.typeck_results().node_types()[inner.hir_id].is_bool() {
diff --git a/clippy_lints/src/collapsible_if.rs b/clippy_lints/src/collapsible_if.rs
index dae5c86bd44..6e950738239 100644
--- a/clippy_lints/src/collapsible_if.rs
+++ b/clippy_lints/src/collapsible_if.rs
@@ -92,7 +92,7 @@ declare_lint_pass!(CollapsibleIf => [COLLAPSIBLE_IF, COLLAPSIBLE_ELSE_IF]);
 impl EarlyLintPass for CollapsibleIf {
     fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &ast::Expr) {
         if !expr.span.from_expansion() {
-            check_if(cx, expr)
+            check_if(cx, expr);
         }
     }
 }
diff --git a/clippy_lints/src/comparison_chain.rs b/clippy_lints/src/comparison_chain.rs
index 2a61d58e653..b6999bef6e7 100644
--- a/clippy_lints/src/comparison_chain.rs
+++ b/clippy_lints/src/comparison_chain.rs
@@ -120,7 +120,7 @@ impl<'tcx> LateLintPass<'tcx> for ComparisonChain {
             "`if` chain can be rewritten with `match`",
             None,
             "consider rewriting the `if` chain to use `cmp` and `match`",
-        )
+        );
     }
 }
 
diff --git a/clippy_lints/src/copies.rs b/clippy_lints/src/copies.rs
index f956d171bfb..376a14b8181 100644
--- a/clippy_lints/src/copies.rs
+++ b/clippy_lints/src/copies.rs
@@ -476,7 +476,7 @@ fn emit_branches_sharing_code_lint(
         }
 
         suggestions.push(("end", span, suggestion.to_string()));
-        add_expr_note = !cx.typeck_results().expr_ty(if_expr).is_unit()
+        add_expr_note = !cx.typeck_results().expr_ty(if_expr).is_unit();
     }
 
     let add_optional_msgs = |diag: &mut DiagnosticBuilder<'_>| {
diff --git a/clippy_lints/src/default_numeric_fallback.rs b/clippy_lints/src/default_numeric_fallback.rs
index 6e883942680..759f7d4062d 100644
--- a/clippy_lints/src/default_numeric_fallback.rs
+++ b/clippy_lints/src/default_numeric_fallback.rs
@@ -181,9 +181,9 @@ impl<'a, 'tcx> Visitor<'tcx> for NumericFallbackVisitor<'a, 'tcx> {
         match stmt.kind {
             StmtKind::Local(local) => {
                 if local.ty.is_some() {
-                    self.ty_bounds.push(TyBound::Any)
+                    self.ty_bounds.push(TyBound::Any);
                 } else {
-                    self.ty_bounds.push(TyBound::Nothing)
+                    self.ty_bounds.push(TyBound::Nothing);
                 }
             },
 
diff --git a/clippy_lints/src/double_comparison.rs b/clippy_lints/src/double_comparison.rs
index 58543ae6e4e..4966638cb1b 100644
--- a/clippy_lints/src/double_comparison.rs
+++ b/clippy_lints/src/double_comparison.rs
@@ -70,16 +70,16 @@ impl<'tcx> DoubleComparisons {
         #[rustfmt::skip]
         match (op, lkind, rkind) {
             (BinOpKind::Or, BinOpKind::Eq, BinOpKind::Lt) | (BinOpKind::Or, BinOpKind::Lt, BinOpKind::Eq) => {
-                lint_double_comparison!(<=)
+                lint_double_comparison!(<=);
             },
             (BinOpKind::Or, BinOpKind::Eq, BinOpKind::Gt) | (BinOpKind::Or, BinOpKind::Gt, BinOpKind::Eq) => {
-                lint_double_comparison!(>=)
+                lint_double_comparison!(>=);
             },
             (BinOpKind::Or, BinOpKind::Lt, BinOpKind::Gt) | (BinOpKind::Or, BinOpKind::Gt, BinOpKind::Lt) => {
-                lint_double_comparison!(!=)
+                lint_double_comparison!(!=);
             },
             (BinOpKind::And, BinOpKind::Le, BinOpKind::Ge) | (BinOpKind::And, BinOpKind::Ge, BinOpKind::Le) => {
-                lint_double_comparison!(==)
+                lint_double_comparison!(==);
             },
             _ => (),
         };
diff --git a/clippy_lints/src/entry.rs b/clippy_lints/src/entry.rs
index 8db5050a5ac..2eb8b1422ed 100644
--- a/clippy_lints/src/entry.rs
+++ b/clippy_lints/src/entry.rs
@@ -469,7 +469,7 @@ impl<'tcx> Visitor<'tcx> for InsertSearcher<'_, 'tcx> {
                     let mut is_map_used = self.is_map_used;
                     for arm in arms {
                         if let Some(Guard::If(guard) | Guard::IfLet(_, guard)) = arm.guard {
-                            self.visit_non_tail_expr(guard)
+                            self.visit_non_tail_expr(guard);
                         }
                         is_map_used |= self.visit_cond_arm(arm.body);
                     }
diff --git a/clippy_lints/src/eq_op.rs b/clippy_lints/src/eq_op.rs
index 90f391b5f5c..47fe4e0de0d 100644
--- a/clippy_lints/src/eq_op.rs
+++ b/clippy_lints/src/eq_op.rs
@@ -156,7 +156,7 @@ impl<'tcx> LateLintPass<'tcx> for EqOp {
                                         vec![(left.span, lsnip), (right.span, rsnip)],
                                     );
                                 },
-                            )
+                            );
                         } else if lcpy
                             && !rcpy
                             && implements_trait(cx, lty, trait_id, &[cx.typeck_results().expr_ty(right).into()])
@@ -175,7 +175,7 @@ impl<'tcx> LateLintPass<'tcx> for EqOp {
                                         Applicability::MaybeIncorrect, // FIXME #2597
                                     );
                                 },
-                            )
+                            );
                         } else if !lcpy
                             && rcpy
                             && implements_trait(cx, cx.typeck_results().expr_ty(left), trait_id, &[rty.into()])
@@ -194,7 +194,7 @@ impl<'tcx> LateLintPass<'tcx> for EqOp {
                                         Applicability::MaybeIncorrect, // FIXME #2597
                                     );
                                 },
-                            )
+                            );
                         }
                     },
                     // &foo == bar
@@ -218,9 +218,9 @@ impl<'tcx> LateLintPass<'tcx> for EqOp {
                                         Applicability::MaybeIncorrect, // FIXME #2597
                                     );
                                 },
-                            )
+                            );
                         }
-                    },
+                   },
                     // foo == &bar
                     (_, &ExprKind::AddrOf(BorrowKind::Ref, _, r)) => {
                         let rty = cx.typeck_results().expr_ty(r);
@@ -236,7 +236,7 @@ impl<'tcx> LateLintPass<'tcx> for EqOp {
                                     rsnip,
                                     Applicability::MaybeIncorrect, // FIXME #2597
                                 );
-                            })
+                            });
                         }
                     },
                     _ => {},
diff --git a/clippy_lints/src/eta_reduction.rs b/clippy_lints/src/eta_reduction.rs
index afc5d546474..8d066f305ee 100644
--- a/clippy_lints/src/eta_reduction.rs
+++ b/clippy_lints/src/eta_reduction.rs
@@ -77,7 +77,7 @@ impl<'tcx> LateLintPass<'tcx> for EtaReduction {
                 for arg in args {
                     // skip `foo(macro!())`
                     if arg.span.ctxt() == expr.span.ctxt() {
-                        check_closure(cx, arg)
+                        check_closure(cx, arg);
                     }
                 }
             },
@@ -190,9 +190,10 @@ fn get_ufcs_type_name(cx: &LateContext<'_>, method_def_id: def_id::DefId, self_a
     cx.tcx.impl_of_method(method_def_id).and_then(|_| {
         //a type may implicitly implement other type's methods (e.g. Deref)
         if match_types(expected_type_of_self, actual_type_of_self) {
-            return Some(get_type_name(cx, actual_type_of_self));
+            Some(get_type_name(cx, actual_type_of_self))
+        } else {
+            None
         }
-        None
     })
 }
 
diff --git a/clippy_lints/src/eval_order_dependence.rs b/clippy_lints/src/eval_order_dependence.rs
index 41acf55dd7d..5fdf5bc9e9d 100644
--- a/clippy_lints/src/eval_order_dependence.rs
+++ b/clippy_lints/src/eval_order_dependence.rs
@@ -110,7 +110,7 @@ impl<'a, 'tcx> DivergenceVisitor<'a, 'tcx> {
                 self.visit_expr(e);
                 for arm in arms {
                     if let Some(Guard::If(if_expr)) = arm.guard {
-                        self.visit_expr(if_expr)
+                        self.visit_expr(if_expr);
                     }
                     // make sure top level arm expressions aren't linted
                     self.maybe_walk_expr(&*arm.body);
diff --git a/clippy_lints/src/functions/must_use.rs b/clippy_lints/src/functions/must_use.rs
index 20288427b4a..7f4fb68cf2f 100644
--- a/clippy_lints/src/functions/must_use.rs
+++ b/clippy_lints/src/functions/must_use.rs
@@ -240,7 +240,7 @@ impl<'a, 'tcx> intravisit::Visitor<'tcx> for StaticMutVisitor<'a, 'tcx> {
                 }
             },
             Assign(target, ..) | AssignOp(_, target, _) | AddrOf(_, hir::Mutability::Mut, target) => {
-                self.mutates_static |= is_mutated_static(target)
+                self.mutates_static |= is_mutated_static(target);
             },
             _ => {},
         }
diff --git a/clippy_lints/src/functions/too_many_lines.rs b/clippy_lints/src/functions/too_many_lines.rs
index aa5494d5a7d..c02c343dc58 100644
--- a/clippy_lints/src/functions/too_many_lines.rs
+++ b/clippy_lints/src/functions/too_many_lines.rs
@@ -63,6 +63,6 @@ pub(super) fn check_fn(cx: &LateContext<'_>, span: Span, body: &'tcx hir::Body<'
                 "this function has too many lines ({}/{})",
                 line_count, too_many_lines_threshold
             ),
-        )
+        );
     }
 }
diff --git a/clippy_lints/src/future_not_send.rs b/clippy_lints/src/future_not_send.rs
index 04730ace887..515b8887453 100644
--- a/clippy_lints/src/future_not_send.rs
+++ b/clippy_lints/src/future_not_send.rs
@@ -102,7 +102,7 @@ impl<'tcx> LateLintPass<'tcx> for FutureNotSend {
                                         ));
                                     }
                                 }
-                            })
+                            });
                         },
                     );
                 }
diff --git a/clippy_lints/src/implicit_return.rs b/clippy_lints/src/implicit_return.rs
index 260a8f50157..f2f830ca5c0 100644
--- a/clippy_lints/src/implicit_return.rs
+++ b/clippy_lints/src/implicit_return.rs
@@ -67,7 +67,7 @@ fn lint_break(cx: &LateContext<'_>, break_span: Span, expr_span: Span) {
         "change `break` to `return` as shown",
         format!("return {}", snip),
         app,
-    )
+    );
 }
 
 #[derive(Clone, Copy, PartialEq, Eq)]
diff --git a/clippy_lints/src/infinite_iter.rs b/clippy_lints/src/infinite_iter.rs
index afee20ce43e..6b887da2630 100644
--- a/clippy_lints/src/infinite_iter.rs
+++ b/clippy_lints/src/infinite_iter.rs
@@ -54,7 +54,7 @@ impl<'tcx> LateLintPass<'tcx> for InfiniteIter {
                 return;
             },
         };
-        span_lint(cx, lint, expr.span, msg)
+        span_lint(cx, lint, expr.span, msg);
     }
 }
 
diff --git a/clippy_lints/src/invalid_upcast_comparisons.rs b/clippy_lints/src/invalid_upcast_comparisons.rs
index c67c02eefa5..aafdebef248 100644
--- a/clippy_lints/src/invalid_upcast_comparisons.rs
+++ b/clippy_lints/src/invalid_upcast_comparisons.rs
@@ -177,7 +177,7 @@ fn upcast_comparison_bounds_err<'tcx>(
                 },
                 Rel::Eq | Rel::Ne => unreachable!(),
             } {
-                err_upcast_comparison(cx, span, lhs, true)
+                err_upcast_comparison(cx, span, lhs, true);
             } else if match rel {
                 Rel::Lt => {
                     if invert {
@@ -195,7 +195,7 @@ fn upcast_comparison_bounds_err<'tcx>(
                 },
                 Rel::Eq | Rel::Ne => unreachable!(),
             } {
-                err_upcast_comparison(cx, span, lhs, false)
+                err_upcast_comparison(cx, span, lhs, false);
             }
         }
     }
diff --git a/clippy_lints/src/len_zero.rs b/clippy_lints/src/len_zero.rs
index bb57adff7be..583514b22f9 100644
--- a/clippy_lints/src/len_zero.rs
+++ b/clippy_lints/src/len_zero.rs
@@ -380,9 +380,9 @@ fn check_cmp(cx: &LateContext<'_>, span: Span, method: &Expr<'_>, lit: &Expr<'_>
             }
         }
 
-        check_len(cx, span, method_path.ident.name, args, &lit.node, op, compare_to)
+        check_len(cx, span, method_path.ident.name, args, &lit.node, op, compare_to);
     } else {
-        check_empty_expr(cx, span, method, lit, op)
+        check_empty_expr(cx, span, method, lit, op);
     }
 }
 
diff --git a/clippy_lints/src/let_underscore.rs b/clippy_lints/src/let_underscore.rs
index 17e23781db7..e627b1385bc 100644
--- a/clippy_lints/src/let_underscore.rs
+++ b/clippy_lints/src/let_underscore.rs
@@ -135,7 +135,7 @@ impl<'tcx> LateLintPass<'tcx> for LetUnderscore {
                         None,
                         "consider using an underscore-prefixed named \
                             binding or dropping explicitly with `std::mem::drop`"
-                    )
+                    );
                 } else if init_ty.needs_drop(cx.tcx, cx.param_env) {
                     span_lint_and_help(
                         cx,
@@ -145,7 +145,7 @@ impl<'tcx> LateLintPass<'tcx> for LetUnderscore {
                         None,
                         "consider using an underscore-prefixed named \
                             binding or dropping explicitly with `std::mem::drop`"
-                    )
+                    );
                 } else if is_must_use_ty(cx, cx.typeck_results().expr_ty(init)) {
                     span_lint_and_help(
                         cx,
@@ -154,7 +154,7 @@ impl<'tcx> LateLintPass<'tcx> for LetUnderscore {
                         "non-binding let on an expression with `#[must_use]` type",
                         None,
                         "consider explicitly using expression value"
-                    )
+                    );
                 } else if is_must_use_func_call(cx, init) {
                     span_lint_and_help(
                         cx,
@@ -163,7 +163,7 @@ impl<'tcx> LateLintPass<'tcx> for LetUnderscore {
                         "non-binding let on a result of a `#[must_use]` function",
                         None,
                         "consider explicitly using function result"
-                    )
+                    );
                 }
             }
         }
diff --git a/clippy_lints/src/lifetimes.rs b/clippy_lints/src/lifetimes.rs
index 116ad072837..5ae68ba5b2f 100644
--- a/clippy_lints/src/lifetimes.rs
+++ b/clippy_lints/src/lifetimes.rs
@@ -205,7 +205,7 @@ fn could_use_elision<'tcx>(
         output_visitor.visit_ty(ty);
     }
     for lt in named_generics {
-        input_visitor.visit_generic_param(lt)
+        input_visitor.visit_generic_param(lt);
     }
 
     if input_visitor.abort() || output_visitor.abort() {
@@ -463,7 +463,7 @@ impl<'tcx> Visitor<'tcx> for LifetimeChecker {
         // `'b` in `'a: 'b` is useless unless used elsewhere in
         // a non-lifetime bound
         if let GenericParamKind::Type { .. } = param.kind {
-            walk_generic_param(self, param)
+            walk_generic_param(self, param);
         }
     }
     fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
diff --git a/clippy_lints/src/literal_representation.rs b/clippy_lints/src/literal_representation.rs
index e93b2e36b86..e0c5578bd60 100644
--- a/clippy_lints/src/literal_representation.rs
+++ b/clippy_lints/src/literal_representation.rs
@@ -231,7 +231,7 @@ impl EarlyLintPass for LiteralDigitGrouping {
         }
 
         if let ExprKind::Lit(ref lit) = expr.kind {
-            self.check_lit(cx, lit)
+            self.check_lit(cx, lit);
         }
     }
 }
@@ -294,7 +294,7 @@ impl LiteralDigitGrouping {
                         }
                     };
                     if should_warn {
-                        warning_type.display(num_lit.format(), cx, lit.span)
+                        warning_type.display(num_lit.format(), cx, lit.span);
                     }
                 }
             }
@@ -424,7 +424,7 @@ impl EarlyLintPass for DecimalLiteralRepresentation {
         }
 
         if let ExprKind::Lit(ref lit) = expr.kind {
-            self.check_lit(cx, lit)
+            self.check_lit(cx, lit);
         }
     }
 }
@@ -446,7 +446,7 @@ impl DecimalLiteralRepresentation {
                 let hex = format!("{:#X}", val);
                 let num_lit = NumericLiteral::new(&hex, num_lit.suffix, false);
                 let _ = Self::do_lint(num_lit.integer).map_err(|warning_type| {
-                    warning_type.display(num_lit.format(), cx, lit.span)
+                    warning_type.display(num_lit.format(), cx, lit.span);
                 });
             }
         }
diff --git a/clippy_lints/src/loops/explicit_iter_loop.rs b/clippy_lints/src/loops/explicit_iter_loop.rs
index ce02ad013be..f0327b5d777 100644
--- a/clippy_lints/src/loops/explicit_iter_loop.rs
+++ b/clippy_lints/src/loops/explicit_iter_loop.rs
@@ -43,7 +43,7 @@ pub(super) fn check(cx: &LateContext<'_>, self_arg: &Expr<'_>, arg: &Expr<'_>, m
         "to write this more concisely, try",
         format!("&{}{}", muta, object),
         applicability,
-    )
+    );
 }
 
 /// Returns `true` if the type of expr is one that provides `IntoIterator` impls
diff --git a/clippy_lints/src/loops/mut_range_bound.rs b/clippy_lints/src/loops/mut_range_bound.rs
index 1425d50f560..d07b5a93b67 100644
--- a/clippy_lints/src/loops/mut_range_bound.rs
+++ b/clippy_lints/src/loops/mut_range_bound.rs
@@ -88,10 +88,10 @@ impl<'tcx> Delegate<'tcx> for MutatePairDelegate<'_, 'tcx> {
         if let ty::BorrowKind::MutBorrow = bk {
             if let PlaceBase::Local(id) = cmt.place.base {
                 if Some(id) == self.hir_id_low {
-                    self.span_low = Some(self.cx.tcx.hir().span(diag_expr_id))
+                    self.span_low = Some(self.cx.tcx.hir().span(diag_expr_id));
                 }
                 if Some(id) == self.hir_id_high {
-                    self.span_high = Some(self.cx.tcx.hir().span(diag_expr_id))
+                    self.span_high = Some(self.cx.tcx.hir().span(diag_expr_id));
                 }
             }
         }
@@ -100,10 +100,10 @@ impl<'tcx> Delegate<'tcx> for MutatePairDelegate<'_, 'tcx> {
     fn mutate(&mut self, cmt: &PlaceWithHirId<'tcx>, diag_expr_id: HirId) {
         if let PlaceBase::Local(id) = cmt.place.base {
             if Some(id) == self.hir_id_low {
-                self.span_low = Some(self.cx.tcx.hir().span(diag_expr_id))
+                self.span_low = Some(self.cx.tcx.hir().span(diag_expr_id));
             }
             if Some(id) == self.hir_id_high {
-                self.span_high = Some(self.cx.tcx.hir().span(diag_expr_id))
+                self.span_high = Some(self.cx.tcx.hir().span(diag_expr_id));
             }
         }
     }
diff --git a/clippy_lints/src/loops/same_item_push.rs b/clippy_lints/src/loops/same_item_push.rs
index cb2c83e9029..f2e0a0f7003 100644
--- a/clippy_lints/src/loops/same_item_push.rs
+++ b/clippy_lints/src/loops/same_item_push.rs
@@ -32,10 +32,10 @@ pub(super) fn check<'tcx>(
             "it looks like the same item is being pushed into this Vec",
             None,
             &format!(
-                "try using vec![{};SIZE] or {}.resize(NEW_SIZE, {})",
+                "try using vec![{}; SIZE] or {}.resize(NEW_SIZE, {})",
                 item_str, vec_str, item_str
             ),
-        )
+        );
     }
 
     if !matches!(pat.kind, PatKind::Wild) {
diff --git a/clippy_lints/src/loops/utils.rs b/clippy_lints/src/loops/utils.rs
index 4db6644b9d7..2f7360210ba 100644
--- a/clippy_lints/src/loops/utils.rs
+++ b/clippy_lints/src/loops/utils.rs
@@ -80,10 +80,10 @@ impl<'a, 'tcx> Visitor<'tcx> for IncrementVisitor<'a, 'tcx> {
                         }
                     },
                     ExprKind::Assign(lhs, _, _) if lhs.hir_id == expr.hir_id => {
-                        *state = IncrementVisitorVarState::DontWarn
+                        *state = IncrementVisitorVarState::DontWarn;
                     },
                     ExprKind::AddrOf(BorrowKind::Ref, mutability, _) if mutability == Mutability::Mut => {
-                        *state = IncrementVisitorVarState::DontWarn
+                        *state = IncrementVisitorVarState::DontWarn;
                     },
                     _ => (),
                 }
@@ -207,7 +207,7 @@ impl<'a, 'tcx> Visitor<'tcx> for InitializeVisitor<'a, 'tcx> {
                         }
                     },
                     ExprKind::AddrOf(BorrowKind::Ref, mutability, _) if mutability == Mutability::Mut => {
-                        self.state = InitializeVisitorState::DontWarn
+                        self.state = InitializeVisitorState::DontWarn;
                     },
                     _ => (),
                 }
@@ -292,7 +292,7 @@ impl<'tcx> Visitor<'tcx> for LoopNestVisitor {
                 return;
             }
         }
-        walk_pat(self, pat)
+        walk_pat(self, pat);
     }
 
     fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
diff --git a/clippy_lints/src/macro_use.rs b/clippy_lints/src/macro_use.rs
index 914b583186c..66479ae264e 100644
--- a/clippy_lints/src/macro_use.rs
+++ b/clippy_lints/src/macro_use.rs
@@ -212,9 +212,9 @@ impl<'tcx> LateLintPass<'tcx> for MacroUseImports {
         let mut suggestions = vec![];
         for ((root, span), path) in used {
             if path.len() == 1 {
-                suggestions.push((span, format!("{}::{}", root, path[0])))
+                suggestions.push((span, format!("{}::{}", root, path[0])));
             } else {
-                suggestions.push((span, format!("{}::{{{}}}", root, path.join(", "))))
+                suggestions.push((span, format!("{}::{{{}}}", root, path.join(", "))));
             }
         }
 
@@ -231,7 +231,7 @@ impl<'tcx> LateLintPass<'tcx> for MacroUseImports {
                     "remove the attribute and import the macro directly, try",
                     help,
                     Applicability::MaybeIncorrect,
-                )
+                );
             }
         }
     }
diff --git a/clippy_lints/src/manual_strip.rs b/clippy_lints/src/manual_strip.rs
index 23428524dee..6a06090f6e2 100644
--- a/clippy_lints/src/manual_strip.rs
+++ b/clippy_lints/src/manual_strip.rs
@@ -123,7 +123,7 @@ impl<'tcx> LateLintPass<'tcx> for ManualStrip {
                                           kind_word,
                                           snippet(cx, pattern.span, "..")))]
                             .into_iter().chain(strippings.into_iter().map(|span| (span, "<stripped>".into()))),
-                        )
+                        );
                     });
                 }
             }
diff --git a/clippy_lints/src/map_clone.rs b/clippy_lints/src/map_clone.rs
index 99c35ae3bbf..e1f80ab025c 100644
--- a/clippy_lints/src/map_clone.rs
+++ b/clippy_lints/src/map_clone.rs
@@ -125,7 +125,7 @@ fn lint_needless_cloning(cx: &LateContext<'_>, root: Span, receiver: Span) {
         "remove the `map` call",
         String::new(),
         Applicability::MachineApplicable,
-    )
+    );
 }
 
 fn lint(cx: &LateContext<'_>, replace: Span, root: Span, copied: bool) {
@@ -142,7 +142,7 @@ fn lint(cx: &LateContext<'_>, replace: Span, root: Span, copied: bool) {
                 snippet_with_applicability(cx, root, "..", &mut applicability)
             ),
             applicability,
-        )
+        );
     } else {
         span_lint_and_sugg(
             cx,
@@ -155,6 +155,6 @@ fn lint(cx: &LateContext<'_>, replace: Span, root: Span, copied: bool) {
                 snippet_with_applicability(cx, root, "..", &mut applicability)
             ),
             applicability,
-        )
+        );
     }
 }
diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index fcd37687010..e07d8ea56e4 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -1144,7 +1144,7 @@ fn check_wild_enum_match(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>])
                 "try this",
                 suggestions.join(" | "),
                 Applicability::MaybeIncorrect,
-            )
+            );
         },
     };
 }
@@ -1242,7 +1242,7 @@ fn check_match_as_ref(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>], exp
                     cast,
                 ),
                 applicability,
-            )
+            );
         }
     }
 }
@@ -1494,7 +1494,7 @@ fn check_match_single_binding<'a>(cx: &LateContext<'a>, ex: &Expr<'a>, arms: &[A
                     "consider using the scrutinee and body instead",
                     sugg,
                     applicability,
-                )
+                );
             } else {
                 span_lint_and_sugg(
                     cx,
@@ -1747,7 +1747,7 @@ mod redundant_pattern_match {
             match match_source {
                 MatchSource::Normal => find_sugg_for_match(cx, expr, op, arms),
                 MatchSource::IfLetDesugar { contains_else_clause } => {
-                    find_sugg_for_if_let(cx, expr, op, &arms[0], "if", *contains_else_clause)
+                    find_sugg_for_if_let(cx, expr, op, &arms[0], "if", *contains_else_clause);
                 },
                 MatchSource::WhileLetDesugar => find_sugg_for_if_let(cx, expr, op, &arms[0], "while", false),
                 _ => {},
@@ -1876,7 +1876,7 @@ mod redundant_pattern_match {
                             {
                                 self.res = true;
                             } else {
-                                self.visit_expr(self_arg)
+                                self.visit_expr(self_arg);
                             }
                         }
                         args.iter().for_each(|arg| self.visit_expr(arg));
diff --git a/clippy_lints/src/methods/bind_instead_of_map.rs b/clippy_lints/src/methods/bind_instead_of_map.rs
index 287bff886bf..da428a7b487 100644
--- a/clippy_lints/src/methods/bind_instead_of_map.rs
+++ b/clippy_lints/src/methods/bind_instead_of_map.rs
@@ -135,7 +135,7 @@ pub(crate) trait BindInsteadOfMap {
                         .into_iter()
                         .map(|(span1, span2)| (span1, snippet(cx, span2, "_").into())),
                 ),
-            )
+            );
         });
         true
     }
diff --git a/clippy_lints/src/methods/cloned_instead_of_copied.rs b/clippy_lints/src/methods/cloned_instead_of_copied.rs
index ecec6da3aa0..f5b4b6bf8ea 100644
--- a/clippy_lints/src/methods/cloned_instead_of_copied.rs
+++ b/clippy_lints/src/methods/cloned_instead_of_copied.rs
@@ -41,5 +41,5 @@ pub fn check(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'_>, span: Span,
         "try",
         "copied".into(),
         Applicability::MachineApplicable,
-    )
+    );
 }
diff --git a/clippy_lints/src/methods/flat_map_option.rs b/clippy_lints/src/methods/flat_map_option.rs
index 12d560653ed..32d40d97bf4 100644
--- a/clippy_lints/src/methods/flat_map_option.rs
+++ b/clippy_lints/src/methods/flat_map_option.rs
@@ -30,5 +30,5 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, arg
         "try",
         "filter_map".into(),
         Applicability::MachineApplicable,
-    )
+    );
 }
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index e0d29682146..cabfe8023ef 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1951,7 +1951,7 @@ fn check_methods<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, msrv: Optio
     if let Some((name, [recv, args @ ..], span)) = method_call!(expr) {
         match (name, args) {
             ("add" | "offset" | "sub" | "wrapping_offset" | "wrapping_add" | "wrapping_sub", [recv, _]) => {
-                zst_offset::check(cx, expr, recv)
+                zst_offset::check(cx, expr, recv);
             },
             ("and_then", [arg]) => {
                 let biom_option_linted = bind_instead_of_map::OptionAndThenSome::check(cx, expr, recv, arg);
@@ -2012,7 +2012,7 @@ fn check_methods<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, msrv: Optio
                         ("as_mut", []) => option_as_ref_deref::check(cx, expr, recv2, m_arg, true, msrv),
                         ("as_ref", []) => option_as_ref_deref::check(cx, expr, recv2, m_arg, false, msrv),
                         ("filter", [f_arg]) => {
-                            filter_map::check(cx, expr, recv2, f_arg, span2, recv, m_arg, span, false)
+                            filter_map::check(cx, expr, recv2, f_arg, span2, recv, m_arg, span, false);
                         },
                         ("find", [f_arg]) => filter_map::check(cx, expr, recv2, f_arg, span2, recv, m_arg, span, true),
                         _ => {},
@@ -2058,7 +2058,7 @@ fn check_methods<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, msrv: Optio
                     manual_saturating_arithmetic::check(cx, expr, lhs, rhs, u_arg, &arith["checked_".len()..]);
                 },
                 Some(("map", [m_recv, m_arg], span)) => {
-                    option_map_unwrap_or::check(cx, expr, m_recv, m_arg, recv, u_arg, span)
+                    option_map_unwrap_or::check(cx, expr, m_recv, m_arg, recv, u_arg, span);
                 },
                 _ => {},
             },
@@ -2073,7 +2073,7 @@ fn check_methods<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, msrv: Optio
 
 fn check_is_some_is_none(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'_>, is_some: bool) {
     if let Some((name @ ("find" | "position" | "rposition"), [f_recv, arg], span)) = method_call!(recv) {
-        search_is_some::check(cx, expr, name, is_some, f_recv, arg, recv, span)
+        search_is_some::check(cx, expr, name, is_some, f_recv, arg, recv, span);
     }
 }
 
diff --git a/clippy_lints/src/methods/unnecessary_fold.rs b/clippy_lints/src/methods/unnecessary_fold.rs
index 75517c48a21..4c4034437da 100644
--- a/clippy_lints/src/methods/unnecessary_fold.rs
+++ b/clippy_lints/src/methods/unnecessary_fold.rs
@@ -87,7 +87,7 @@ pub(super) fn check(
             ast::LitKind::Bool(true) => check_fold_with_op(cx, expr, acc, fold_span, hir::BinOpKind::And, "all", true),
             ast::LitKind::Int(0, _) => check_fold_with_op(cx, expr, acc, fold_span, hir::BinOpKind::Add, "sum", false),
             ast::LitKind::Int(1, _) => {
-                check_fold_with_op(cx, expr, acc, fold_span, hir::BinOpKind::Mul, "product", false)
+                check_fold_with_op(cx, expr, acc, fold_span, hir::BinOpKind::Mul, "product", false);
             },
             _ => (),
         }
diff --git a/clippy_lints/src/misc_early/mod.rs b/clippy_lints/src/misc_early/mod.rs
index dd38316fa25..050b6805b7c 100644
--- a/clippy_lints/src/misc_early/mod.rs
+++ b/clippy_lints/src/misc_early/mod.rs
@@ -310,7 +310,7 @@ impl EarlyLintPass for MiscEarlyLints {
         if in_external_macro(cx.sess(), expr.span) {
             return;
         }
-        double_neg::check(cx, expr)
+        double_neg::check(cx, expr);
     }
 }
 
@@ -334,15 +334,15 @@ impl MiscEarlyLints {
             };
             unseparated_literal_suffix::check(cx, lit, &lit_snip, suffix, "integer");
             if lit_snip.starts_with("0x") {
-                mixed_case_hex_literals::check(cx, lit, suffix, &lit_snip)
+                mixed_case_hex_literals::check(cx, lit, suffix, &lit_snip);
             } else if lit_snip.starts_with("0b") || lit_snip.starts_with("0o") {
-                /* nothing to do */
+                // nothing to do
             } else if value != 0 && lit_snip.starts_with('0') {
-                zero_prefixed_literal::check(cx, lit, &lit_snip)
+                zero_prefixed_literal::check(cx, lit, &lit_snip);
             }
         } else if let LitKind::Float(_, LitFloatType::Suffixed(float_ty)) = lit.kind {
             let suffix = float_ty.name_str();
-            unseparated_literal_suffix::check(cx, lit, &lit_snip, suffix, "float")
+            unseparated_literal_suffix::check(cx, lit, &lit_snip, suffix, "float");
         }
     }
 }
diff --git a/clippy_lints/src/mut_reference.rs b/clippy_lints/src/mut_reference.rs
index cea6fce1195..6efe8ffcde0 100644
--- a/clippy_lints/src/mut_reference.rs
+++ b/clippy_lints/src/mut_reference.rs
@@ -48,7 +48,7 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryMutPassed {
                 let def_id = cx.typeck_results().type_dependent_def_id(e.hir_id).unwrap();
                 let substs = cx.typeck_results().node_substs(e.hir_id);
                 let method_type = cx.tcx.type_of(def_id).subst(cx.tcx, substs);
-                check_arguments(cx, arguments, method_type, &path.ident.as_str(), "method")
+                check_arguments(cx, arguments, method_type, &path.ident.as_str(), "method");
             },
             _ => (),
         }
diff --git a/clippy_lints/src/mutable_debug_assertion.rs b/clippy_lints/src/mutable_debug_assertion.rs
index 533c5a22db0..81bf853300f 100644
--- a/clippy_lints/src/mutable_debug_assertion.rs
+++ b/clippy_lints/src/mutable_debug_assertion.rs
@@ -103,7 +103,7 @@ impl<'a, 'tcx> Visitor<'tcx> for MutArgVisitor<'a, 'tcx> {
             _ if !self.found => self.expr_span = Some(expr.span),
             _ => return,
         }
-        walk_expr(self, expr)
+        walk_expr(self, expr);
     }
 
     fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
diff --git a/clippy_lints/src/needless_arbitrary_self_type.rs b/clippy_lints/src/needless_arbitrary_self_type.rs
index 3e2b2782ed5..fe3c4455be5 100644
--- a/clippy_lints/src/needless_arbitrary_self_type.rs
+++ b/clippy_lints/src/needless_arbitrary_self_type.rs
@@ -121,7 +121,7 @@ impl EarlyLintPass for NeedlessArbitrarySelfType {
         match &p.ty.kind {
             TyKind::Path(None, path) => {
                 if let PatKind::Ident(BindingMode::ByValue(mutbl), _, _) = p.pat.kind {
-                    check_param_inner(cx, path, p.span.to(p.ty.span), &Mode::Value, mutbl)
+                    check_param_inner(cx, path, p.span.to(p.ty.span), &Mode::Value, mutbl);
                 }
             },
             TyKind::Rptr(lifetime, mut_ty) => {
@@ -129,7 +129,7 @@ impl EarlyLintPass for NeedlessArbitrarySelfType {
                 if let TyKind::Path(None, path) = &mut_ty.ty.kind;
                 if let PatKind::Ident(BindingMode::ByValue(Mutability::Not), _, _) = p.pat.kind;
                     then {
-                        check_param_inner(cx, path, p.span.to(p.ty.span), &Mode::Ref(*lifetime), mut_ty.mutbl)
+                        check_param_inner(cx, path, p.span.to(p.ty.span), &Mode::Ref(*lifetime), mut_ty.mutbl);
                     }
                 }
             },
diff --git a/clippy_lints/src/needless_bool.rs b/clippy_lints/src/needless_bool.rs
index dd458198637..3b3736fd3a1 100644
--- a/clippy_lints/src/needless_bool.rs
+++ b/clippy_lints/src/needless_bool.rs
@@ -82,7 +82,7 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessBool {
                 }
 
                 if is_else_clause(cx.tcx, e) {
-                    snip = snip.blockify()
+                    snip = snip.blockify();
                 }
 
                 span_lint_and_sugg(
@@ -144,7 +144,7 @@ impl<'tcx> LateLintPass<'tcx> for BoolComparison {
                         |h: Sugg<'_>| !h,
                         "equality checks against false can be replaced by a negation",
                     ));
-                    check_comparison(cx, e, true_case, false_case, true_case, false_case, ignore_no_literal)
+                    check_comparison(cx, e, true_case, false_case, true_case, false_case, ignore_no_literal);
                 },
                 BinOpKind::Ne => {
                     let true_case = Some((
@@ -152,7 +152,7 @@ impl<'tcx> LateLintPass<'tcx> for BoolComparison {
                         "inequality checks against true can be replaced by a negation",
                     ));
                     let false_case = Some((|h| h, "inequality checks against false are unnecessary"));
-                    check_comparison(cx, e, true_case, false_case, true_case, false_case, ignore_no_literal)
+                    check_comparison(cx, e, true_case, false_case, true_case, false_case, ignore_no_literal);
                 },
                 BinOpKind::Lt => check_comparison(
                     cx,
@@ -251,22 +251,22 @@ fn check_comparison<'a, 'tcx>(
                             snippet_with_applicability(cx, expression_info.right_span, "..", &mut applicability)
                         ),
                         applicability,
-                    )
+                    );
                 }
             }
 
             match (fetch_bool_expr(left_side), fetch_bool_expr(right_side)) {
                 (Bool(true), Other) => left_true.map_or((), |(h, m)| {
-                    suggest_bool_comparison(cx, e, right_side, applicability, m, h)
+                    suggest_bool_comparison(cx, e, right_side, applicability, m, h);
                 }),
                 (Other, Bool(true)) => right_true.map_or((), |(h, m)| {
-                    suggest_bool_comparison(cx, e, left_side, applicability, m, h)
+                    suggest_bool_comparison(cx, e, left_side, applicability, m, h);
                 }),
                 (Bool(false), Other) => left_false.map_or((), |(h, m)| {
-                    suggest_bool_comparison(cx, e, right_side, applicability, m, h)
+                    suggest_bool_comparison(cx, e, right_side, applicability, m, h);
                 }),
                 (Other, Bool(false)) => right_false.map_or((), |(h, m)| {
-                    suggest_bool_comparison(cx, e, left_side, applicability, m, h)
+                    suggest_bool_comparison(cx, e, left_side, applicability, m, h);
                 }),
                 (Other, Other) => no_literal.map_or((), |(h, m)| {
                     let left_side = Sugg::hir_with_applicability(cx, left_side, "..", &mut applicability);
@@ -279,7 +279,7 @@ fn check_comparison<'a, 'tcx>(
                         "try simplifying it as shown",
                         h(left_side, right_side).to_string(),
                         applicability,
-                    )
+                    );
                 }),
                 _ => (),
             }
diff --git a/clippy_lints/src/needless_borrow.rs b/clippy_lints/src/needless_borrow.rs
index bcedebfccc7..dd1dfa2bdfb 100644
--- a/clippy_lints/src/needless_borrow.rs
+++ b/clippy_lints/src/needless_borrow.rs
@@ -199,7 +199,7 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessBorrow {
                     |diag| {
                         diag.multipart_suggestion("try this", replacements, app);
                     },
-                )
+                );
             }
             self.current_body = None;
         }
diff --git a/clippy_lints/src/needless_for_each.rs b/clippy_lints/src/needless_for_each.rs
index 079b6642d58..3b936e6aaef 100644
--- a/clippy_lints/src/needless_for_each.rs
+++ b/clippy_lints/src/needless_for_each.rs
@@ -145,7 +145,7 @@ impl<'tcx> Visitor<'tcx> for RetCollector {
                     self.ret_in_loop = true
                 }
 
-                self.spans.push(expr.span)
+                self.spans.push(expr.span);
             },
 
             ExprKind::Loop(..) => {
diff --git a/clippy_lints/src/utils/author.rs b/clippy_lints/src/utils/author.rs
index e70f8a09ebe..39ef170ae36 100644
--- a/clippy_lints/src/utils/author.rs
+++ b/clippy_lints/src/utils/author.rs
@@ -292,7 +292,7 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor {
                     LitKind::Str(ref text, _) => {
                         let str_pat = self.next("s");
                         println!("    if let LitKind::Str(ref {}, _) = {}.node;", str_pat, lit_pat);
-                        println!("    if {}.as_str() == {:?}", str_pat, &*text.as_str())
+                        println!("    if {}.as_str() == {:?}", str_pat, &*text.as_str());
                     },
                 }
             },
diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs
index ee7be24eae8..2c73c3d929b 100644
--- a/clippy_lints/src/utils/internal_lints.rs
+++ b/clippy_lints/src/utils/internal_lints.rs
@@ -1100,7 +1100,7 @@ impl<'tcx> LateLintPass<'tcx> for IfChainStyle {
                 IF_CHAIN_STYLE,
                 if_chain_local_span(cx, local, if_chain_span),
                 "`let` expression should be inside `then { .. }`",
-            )
+            );
         }
     }
 
@@ -1141,7 +1141,7 @@ impl<'tcx> LateLintPass<'tcx> for IfChainStyle {
         if is_first_if_chain_expr(cx, expr.hir_id, if_chain_span)
             && is_if_chain_then(then_block.stmts, then_block.expr, if_chain_span)
         {
-            span_lint(cx, IF_CHAIN_STYLE, expr.span, "`if_chain!` only has one `if`")
+            span_lint(cx, IF_CHAIN_STYLE, expr.span, "`if_chain!` only has one `if`");
         }
     }
 }
diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index a672af88271..46af03663b8 100644
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -818,7 +818,7 @@ impl<'a, 'hir> intravisit::Visitor<'hir> for IsMultiSpanScanner<'a, 'hir> {
                     .any(|func_path| match_function_call(self.cx, fn_expr, func_path).is_some());
                 if found_function {
                     // These functions are all multi part suggestions
-                    self.add_single_span_suggestion()
+                    self.add_single_span_suggestion();
                 }
             },
             ExprKind::MethodCall(path, _path_span, arg, _arg_span) => {
-- 
cgit 1.4.1-3-g733a5


From 527fb42a324296343f94548a116c51646de16065 Mon Sep 17 00:00:00 2001
From: mbartlett21 <29034492+mbartlett21@users.noreply.github.com>
Date: Tue, 25 May 2021 01:46:33 +0000
Subject: Add all the semicolons to `clippy_lints`

---
 clippy_lints/src/neg_cmp_op_on_partial_ord.rs      |  2 +-
 clippy_lints/src/open_options.rs                   | 10 +++++-----
 clippy_lints/src/question_mark.rs                  |  4 ++--
 clippy_lints/src/redundant_closure_call.rs         |  2 +-
 clippy_lints/src/redundant_pub_crate.rs            |  2 +-
 clippy_lints/src/returns.rs                        |  4 ++--
 clippy_lints/src/shadow.rs                         | 10 +++++-----
 clippy_lints/src/slow_vector_initialization.rs     |  4 ++--
 clippy_lints/src/suspicious_operation_groupings.rs |  6 +++---
 clippy_lints/src/types/mod.rs                      |  4 ++--
 clippy_lints/src/unicode.rs                        |  4 ++--
 clippy_lints/src/upper_case_acronyms.rs            |  2 +-
 clippy_lints/src/use_self.rs                       |  4 ++--
 clippy_lints/src/verbose_file_reads.rs             |  2 +-
 clippy_lints/src/write.rs                          |  2 +-
 15 files changed, 31 insertions(+), 31 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/neg_cmp_op_on_partial_ord.rs b/clippy_lints/src/neg_cmp_op_on_partial_ord.rs
index 0704173a011..c824f6f54b5 100644
--- a/clippy_lints/src/neg_cmp_op_on_partial_ord.rs
+++ b/clippy_lints/src/neg_cmp_op_on_partial_ord.rs
@@ -84,7 +84,7 @@ impl<'tcx> LateLintPass<'tcx> for NoNegCompOpForPartialOrd {
                         types produces code that is hard to read and refactor, please \
                         consider using the `partial_cmp` method instead, to make it \
                         clear that the two values could be incomparable"
-                    )
+                    );
                 }
             }
         }
diff --git a/clippy_lints/src/open_options.rs b/clippy_lints/src/open_options.rs
index 9efe45336bf..fded48038e3 100644
--- a/clippy_lints/src/open_options.rs
+++ b/clippy_lints/src/open_options.rs
@@ -123,7 +123,7 @@ fn check_open_options(cx: &LateContext<'_>, options: &[(OpenOption, Argument)],
                         "the method `create` is called more than once",
                     );
                 } else {
-                    create = true
+                    create = true;
                 }
                 create_arg = create_arg || (arg == Argument::True);
             },
@@ -136,7 +136,7 @@ fn check_open_options(cx: &LateContext<'_>, options: &[(OpenOption, Argument)],
                         "the method `append` is called more than once",
                     );
                 } else {
-                    append = true
+                    append = true;
                 }
                 append_arg = append_arg || (arg == Argument::True);
             },
@@ -149,7 +149,7 @@ fn check_open_options(cx: &LateContext<'_>, options: &[(OpenOption, Argument)],
                         "the method `truncate` is called more than once",
                     );
                 } else {
-                    truncate = true
+                    truncate = true;
                 }
                 truncate_arg = truncate_arg || (arg == Argument::True);
             },
@@ -162,7 +162,7 @@ fn check_open_options(cx: &LateContext<'_>, options: &[(OpenOption, Argument)],
                         "the method `read` is called more than once",
                     );
                 } else {
-                    read = true
+                    read = true;
                 }
                 read_arg = read_arg || (arg == Argument::True);
             },
@@ -175,7 +175,7 @@ fn check_open_options(cx: &LateContext<'_>, options: &[(OpenOption, Argument)],
                         "the method `write` is called more than once",
                     );
                 } else {
-                    write = true
+                    write = true;
                 }
                 write_arg = write_arg || (arg == Argument::True);
             },
diff --git a/clippy_lints/src/question_mark.rs b/clippy_lints/src/question_mark.rs
index 30bee213900..d66bac52243 100644
--- a/clippy_lints/src/question_mark.rs
+++ b/clippy_lints/src/question_mark.rs
@@ -88,7 +88,7 @@ impl QuestionMark {
                         "replace it with",
                         replacement_str,
                         applicability,
-                    )
+                    );
                 }
             }
         }
@@ -129,7 +129,7 @@ impl QuestionMark {
                     "replace it with",
                     replacement,
                     applicability,
-                )
+                );
             }
         }
     }
diff --git a/clippy_lints/src/redundant_closure_call.rs b/clippy_lints/src/redundant_closure_call.rs
index 92921bedf4d..8f56a21ac5b 100644
--- a/clippy_lints/src/redundant_closure_call.rs
+++ b/clippy_lints/src/redundant_closure_call.rs
@@ -57,7 +57,7 @@ impl<'ast> ast_visit::Visitor<'ast> for ReturnVisitor {
             self.found_return = true;
         }
 
-        ast_visit::walk_expr(self, ex)
+        ast_visit::walk_expr(self, ex);
     }
 }
 
diff --git a/clippy_lints/src/redundant_pub_crate.rs b/clippy_lints/src/redundant_pub_crate.rs
index e091095de13..05f9e01acb4 100644
--- a/clippy_lints/src/redundant_pub_crate.rs
+++ b/clippy_lints/src/redundant_pub_crate.rs
@@ -59,7 +59,7 @@ impl<'tcx> LateLintPass<'tcx> for RedundantPubCrate {
                                 Applicability::MachineApplicable,
                             );
                         },
-                    )
+                    );
                 }
             }
         }
diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
index b565c77aaec..251d527c265 100644
--- a/clippy_lints/src/returns.rs
+++ b/clippy_lints/src/returns.rs
@@ -139,7 +139,7 @@ impl<'tcx> LateLintPass<'tcx> for Return {
                 } else {
                     RetReplacement::Empty
                 };
-                check_final_expr(cx, &body.value, Some(body.value.span), replacement)
+                check_final_expr(cx, &body.value, Some(body.value.span), replacement);
             },
             FnKind::ItemFn(..) | FnKind::Method(..) => {
                 if let ExprKind::Block(block, _) = body.value.kind {
@@ -241,7 +241,7 @@ fn emit_return_lint(cx: &LateContext<'_>, ret_span: Span, inner_span: Option<Spa
                 if let Some(snippet) = snippet_opt(cx, inner_span) {
                     diag.span_suggestion(ret_span, "remove `return`", snippet, Applicability::MachineApplicable);
                 }
-            })
+            });
         },
         None => match replacement {
             RetReplacement::Empty => {
diff --git a/clippy_lints/src/shadow.rs b/clippy_lints/src/shadow.rs
index d6101bd5e36..ac3f7ebd14b 100644
--- a/clippy_lints/src/shadow.rs
+++ b/clippy_lints/src/shadow.rs
@@ -120,7 +120,7 @@ fn check_fn<'tcx>(cx: &LateContext<'tcx>, decl: &'tcx FnDecl<'_>, body: &'tcx Bo
     let mut bindings = Vec::with_capacity(decl.inputs.len());
     for arg in iter_input_pats(decl, body) {
         if let PatKind::Binding(.., ident, _) = arg.pat.kind {
-            bindings.push((ident.name, ident.span))
+            bindings.push((ident.name, ident.span));
         }
     }
     check_expr(cx, &body.value, &mut bindings);
@@ -156,7 +156,7 @@ fn check_local<'tcx>(cx: &LateContext<'tcx>, local: &'tcx Local<'_>, bindings: &
         ..
     } = *local;
     if let Some(t) = *ty {
-        check_ty(cx, t, bindings)
+        check_ty(cx, t, bindings);
     }
     if let Some(o) = *init {
         check_expr(cx, o, bindings);
@@ -324,14 +324,14 @@ fn check_expr<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, bindings: &mut
     }
     match expr.kind {
         ExprKind::Unary(_, e) | ExprKind::Field(e, _) | ExprKind::AddrOf(_, _, e) | ExprKind::Box(e) => {
-            check_expr(cx, e, bindings)
+            check_expr(cx, e, bindings);
         },
         ExprKind::Block(block, _) | ExprKind::Loop(block, ..) => check_block(cx, block, bindings),
         // ExprKind::Call
         // ExprKind::MethodCall
         ExprKind::Array(v) | ExprKind::Tup(v) => {
             for e in v {
-                check_expr(cx, e, bindings)
+                check_expr(cx, e, bindings);
             }
         },
         ExprKind::If(cond, then, ref otherwise) => {
@@ -374,7 +374,7 @@ fn check_ty<'tcx>(cx: &LateContext<'tcx>, ty: &'tcx Ty<'_>, bindings: &mut Vec<(
         TyKind::Ptr(MutTy { ty: mty, .. }) | TyKind::Rptr(_, MutTy { ty: mty, .. }) => check_ty(cx, mty, bindings),
         TyKind::Tup(tup) => {
             for t in tup {
-                check_ty(cx, t, bindings)
+                check_ty(cx, t, bindings);
             }
         },
         TyKind::Typeof(ref anon_const) => check_expr(cx, &cx.tcx.hir().body(anon_const.body).value, bindings),
diff --git a/clippy_lints/src/slow_vector_initialization.rs b/clippy_lints/src/slow_vector_initialization.rs
index a9ae2b77119..e5c58d70b60 100644
--- a/clippy_lints/src/slow_vector_initialization.rs
+++ b/clippy_lints/src/slow_vector_initialization.rs
@@ -158,7 +158,7 @@ impl SlowVectorInit {
     ) {
         match initialization {
             InitializationType::Extend(e) | InitializationType::Resize(e) => {
-                Self::emit_lint(cx, e, vec_alloc, "slow zero-filling initialization")
+                Self::emit_lint(cx, e, vec_alloc, "slow zero-filling initialization");
             },
         };
     }
@@ -290,7 +290,7 @@ impl<'a, 'tcx> Visitor<'tcx> for VectorInitializationVisitor<'a, 'tcx> {
     fn visit_block(&mut self, block: &'tcx Block<'_>) {
         if self.initialization_found {
             if let Some(s) = block.stmts.get(0) {
-                self.visit_stmt(s)
+                self.visit_stmt(s);
             }
 
             self.initialization_found = false;
diff --git a/clippy_lints/src/suspicious_operation_groupings.rs b/clippy_lints/src/suspicious_operation_groupings.rs
index 8056887d714..bb707f78fcc 100644
--- a/clippy_lints/src/suspicious_operation_groupings.rs
+++ b/clippy_lints/src/suspicious_operation_groupings.rs
@@ -266,7 +266,7 @@ fn emit_suggestion(cx: &EarlyContext<'_>, span: Span, sugg: String, applicabilit
         "did you mean",
         sugg,
         applicability,
-    )
+    );
 }
 
 fn ident_swap_sugg(
@@ -475,7 +475,7 @@ impl Add for IdentLocation {
 
 impl AddAssign for IdentLocation {
     fn add_assign(&mut self, other: Self) {
-        *self = *self + other
+        *self = *self + other;
     }
 }
 
@@ -506,7 +506,7 @@ impl Add for IdentDifference {
 
 impl AddAssign for IdentDifference {
     fn add_assign(&mut self, other: Self) {
-        *self = *self + other
+        *self = *self + other;
     }
 }
 
diff --git a/clippy_lints/src/types/mod.rs b/clippy_lints/src/types/mod.rs
index d9b47a699dc..70b9e8adef8 100644
--- a/clippy_lints/src/types/mod.rs
+++ b/clippy_lints/src/types/mod.rs
@@ -306,7 +306,7 @@ impl<'tcx> LateLintPass<'tcx> for Types {
     fn check_trait_item(&mut self, cx: &LateContext<'_>, item: &TraitItem<'_>) {
         match item.kind {
             TraitItemKind::Const(ty, _) | TraitItemKind::Type(_, Some(ty)) => {
-                self.check_ty(cx, ty, CheckTyContext::default())
+                self.check_ty(cx, ty, CheckTyContext::default());
             },
             TraitItemKind::Fn(ref sig, _) => self.check_fn_decl(cx, sig.decl, CheckTyContext::default()),
             TraitItemKind::Type(..) => (),
@@ -433,7 +433,7 @@ impl Types {
             },
             TyKind::Slice(ty) | TyKind::Array(ty, _) | TyKind::Ptr(MutTy { ty, .. }) => {
                 context.is_nested_call = true;
-                self.check_ty(cx, ty, context)
+                self.check_ty(cx, ty, context);
             },
             TyKind::Tup(tys) => {
                 context.is_nested_call = true;
diff --git a/clippy_lints/src/unicode.rs b/clippy_lints/src/unicode.rs
index d81e31f5a21..45291a120ed 100644
--- a/clippy_lints/src/unicode.rs
+++ b/clippy_lints/src/unicode.rs
@@ -71,7 +71,7 @@ impl LateLintPass<'_> for Unicode {
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &'_ Expr<'_>) {
         if let ExprKind::Lit(ref lit) = expr.kind {
             if let LitKind::Str(_, _) = lit.node {
-                check_str(cx, lit.span, expr.hir_id)
+                check_str(cx, lit.span, expr.hir_id);
             }
         }
     }
@@ -82,7 +82,7 @@ fn escape<T: Iterator<Item = char>>(s: T) -> String {
     for c in s {
         if c as u32 > 0x7F {
             for d in c.escape_unicode() {
-                result.push(d)
+                result.push(d);
             }
         } else {
             result.push(c);
diff --git a/clippy_lints/src/upper_case_acronyms.rs b/clippy_lints/src/upper_case_acronyms.rs
index 4ac2ec55b98..debbd86a59e 100644
--- a/clippy_lints/src/upper_case_acronyms.rs
+++ b/clippy_lints/src/upper_case_acronyms.rs
@@ -92,7 +92,7 @@ fn check_ident(cx: &EarlyContext<'_>, ident: &Ident, be_aggressive: bool) {
             "consider making the acronym lowercase, except the initial letter",
             corrected,
             Applicability::MaybeIncorrect,
-        )
+        );
     }
 }
 
diff --git a/clippy_lints/src/use_self.rs b/clippy_lints/src/use_self.rs
index 2ad6fa77f48..254b104bdef 100644
--- a/clippy_lints/src/use_self.rs
+++ b/clippy_lints/src/use_self.rs
@@ -356,7 +356,7 @@ impl<'tcx> Visitor<'tcx> for SkipTyCollector {
     fn visit_ty(&mut self, hir_ty: &hir::Ty<'_>) {
         self.types_to_skip.push(hir_ty.hir_id);
 
-        walk_ty(self, hir_ty)
+        walk_ty(self, hir_ty);
     }
 
     fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
@@ -385,7 +385,7 @@ impl<'a, 'tcx> Visitor<'tcx> for LintTyCollector<'a, 'tcx> {
             }
         }
 
-        walk_ty(self, hir_ty)
+        walk_ty(self, hir_ty);
     }
 
     fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
diff --git a/clippy_lints/src/verbose_file_reads.rs b/clippy_lints/src/verbose_file_reads.rs
index ec209b30951..3ab68df2b6d 100644
--- a/clippy_lints/src/verbose_file_reads.rs
+++ b/clippy_lints/src/verbose_file_reads.rs
@@ -54,7 +54,7 @@ impl<'tcx> LateLintPass<'tcx> for VerboseFileReads {
                 "use of `File::read_to_string`",
                 None,
                 "consider using `fs::read_to_string` instead",
-            )
+            );
         }
     }
 }
diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs
index d0e79efa70d..5229a705865 100644
--- a/clippy_lints/src/write.rs
+++ b/clippy_lints/src/write.rs
@@ -300,7 +300,7 @@ impl EarlyLintPass for Write {
                                 Applicability::MachineApplicable,
                             );
                         },
-                    )
+                    );
                 }
             }
         } else if mac.path == sym!(writeln) {
-- 
cgit 1.4.1-3-g733a5


From 6d737772246d9912ba7bbf9b906f467da02ef70e Mon Sep 17 00:00:00 2001
From: mbartlett21 <29034492+mbartlett21@users.noreply.github.com>
Date: Tue, 25 May 2021 02:03:31 +0000
Subject: Fix `same_item_push.rs`

---
 clippy_lints/src/loops/same_item_push.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/same_item_push.rs b/clippy_lints/src/loops/same_item_push.rs
index f2e0a0f7003..0f6cd5de761 100644
--- a/clippy_lints/src/loops/same_item_push.rs
+++ b/clippy_lints/src/loops/same_item_push.rs
@@ -32,7 +32,7 @@ pub(super) fn check<'tcx>(
             "it looks like the same item is being pushed into this Vec",
             None,
             &format!(
-                "try using vec![{}; SIZE] or {}.resize(NEW_SIZE, {})",
+                "try using vec![{};SIZE] or {}.resize(NEW_SIZE, {})",
                 item_str, vec_str, item_str
             ),
         );
-- 
cgit 1.4.1-3-g733a5


From 9cad27fce878977e40dd5b8042165b9a45e86c83 Mon Sep 17 00:00:00 2001
From: mbartlett21 <29034492+mbartlett21@users.noreply.github.com>
Date: Tue, 25 May 2021 02:06:45 +0000
Subject: Add semicolon in `needless_for_each.rs`

---
 clippy_lints/src/needless_for_each.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/needless_for_each.rs b/clippy_lints/src/needless_for_each.rs
index 3b936e6aaef..a723a472a25 100644
--- a/clippy_lints/src/needless_for_each.rs
+++ b/clippy_lints/src/needless_for_each.rs
@@ -142,7 +142,7 @@ impl<'tcx> Visitor<'tcx> for RetCollector {
         match expr.kind {
             ExprKind::Ret(..) => {
                 if self.loop_depth > 0 && !self.ret_in_loop {
-                    self.ret_in_loop = true
+                    self.ret_in_loop = true;
                 }
 
                 self.spans.push(expr.span);
-- 
cgit 1.4.1-3-g733a5


From bcebea65c1b4640113358dd2150ada3bf6bdd850 Mon Sep 17 00:00:00 2001
From: mbartlett21 <29034492+mbartlett21@users.noreply.github.com>
Date: Tue, 25 May 2021 06:05:52 +0000
Subject: Run `cargo fmt`

---
 clippy_lints/src/eq_op.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/eq_op.rs b/clippy_lints/src/eq_op.rs
index 47fe4e0de0d..a3a8e748d99 100644
--- a/clippy_lints/src/eq_op.rs
+++ b/clippy_lints/src/eq_op.rs
@@ -220,7 +220,7 @@ impl<'tcx> LateLintPass<'tcx> for EqOp {
                                 },
                             );
                         }
-                   },
+                    },
                     // foo == &bar
                     (_, &ExprKind::AddrOf(BorrowKind::Ref, _, r)) => {
                         let rty = cx.typeck_results().expr_ty(r);
-- 
cgit 1.4.1-3-g733a5


From 5cc6635fcfe9606729dc8a3cd26bf8012d3cdd55 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Wed, 26 May 2021 08:40:43 -0500
Subject: Add macro_use clippy_utils

---
 clippy_lints/src/lib.rs | 20 ++++----------------
 1 file changed, 4 insertions(+), 16 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 60029d17374..90b260e5d5b 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -41,6 +41,9 @@ extern crate rustc_target;
 extern crate rustc_trait_selection;
 extern crate rustc_typeck;
 
+#[macro_use]
+extern crate clippy_utils;
+
 use clippy_utils::parse_msrv;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_lint::LintId;
@@ -145,25 +148,10 @@ macro_rules! declare_clippy_lint {
     };
 }
 
-#[macro_export]
-macro_rules! sym {
-    ( $($x:tt)* ) => { clippy_utils::sym!($($x)*) }
-}
-
-#[macro_export]
-macro_rules! unwrap_cargo_metadata {
-    ( $($x:tt)* ) => { clippy_utils::unwrap_cargo_metadata!($($x)*) }
-}
-
-macro_rules! extract_msrv_attr {
-    ( $($x:tt)* ) => { clippy_utils::extract_msrv_attr!($($x)*); }
-}
-
 mod consts;
-#[macro_use]
-mod utils;
 #[cfg(feature = "metadata-collector-lint")]
 mod deprecated_lints;
+mod utils;
 
 // begin lints modules, do not remove this comment, it’s used in `update_lints`
 mod absurd_extreme_comparisons;
-- 
cgit 1.4.1-3-g733a5


From c21b965d43d5584c3e0df219e6638494d2dc3ea9 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Wed, 26 May 2021 16:13:57 -0500
Subject: Fix missing_docs_in_private_items FP

---
 clippy_lints/src/missing_doc.rs  | 6 +++---
 tests/ui/missing-doc-impl.rs     | 5 ++++-
 tests/ui/missing-doc-impl.stderr | 8 +++++---
 3 files changed, 12 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/missing_doc.rs b/clippy_lints/src/missing_doc.rs
index dfab3e8a931..ec1572c26c2 100644
--- a/clippy_lints/src/missing_doc.rs
+++ b/clippy_lints/src/missing_doc.rs
@@ -93,9 +93,9 @@ impl MissingDoc {
             return;
         }
 
-        let has_doc = attrs.iter().any(|a| {
-            a.is_doc_comment() || a.doc_str().is_some() || a.value_str().is_some() || Self::has_include(a.meta())
-        });
+        let has_doc = attrs
+            .iter()
+            .any(|a| a.doc_str().is_some() || Self::has_include(a.meta()));
         if !has_doc {
             span_lint(
                 cx,
diff --git a/tests/ui/missing-doc-impl.rs b/tests/ui/missing-doc-impl.rs
index 57af84dcdf4..bfa9ef01b0e 100644
--- a/tests/ui/missing-doc-impl.rs
+++ b/tests/ui/missing-doc-impl.rs
@@ -67,7 +67,10 @@ impl PubFoo {
     pub fn foo() {}
     /// dox
     pub fn foo1() {}
-    fn foo2() {}
+    #[must_use = "yep"]
+    fn foo2() -> u32 {
+        1
+    }
     #[allow(clippy::missing_docs_in_private_items)]
     pub fn foo3() {}
 }
diff --git a/tests/ui/missing-doc-impl.stderr b/tests/ui/missing-doc-impl.stderr
index 7e10404ca00..d33d512475b 100644
--- a/tests/ui/missing-doc-impl.stderr
+++ b/tests/ui/missing-doc-impl.stderr
@@ -94,10 +94,12 @@ LL |     pub fn foo() {}
    |     ^^^^^^^^^^^^^^^
 
 error: missing documentation for an associated function
-  --> $DIR/missing-doc-impl.rs:70:5
+  --> $DIR/missing-doc-impl.rs:71:5
    |
-LL |     fn foo2() {}
-   |     ^^^^^^^^^^^^
+LL | /     fn foo2() -> u32 {
+LL | |         1
+LL | |     }
+   | |_____^
 
 error: aborting due to 15 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 2e2021bbda7ce7b7095b79f07fe6a408a6cd8f07 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Thu, 6 May 2021 12:41:58 -0500
Subject: Add avoid_breaking_exported_api config option

---
 README.md                                              | 1 +
 clippy_lints/src/utils/conf.rs                         | 2 ++
 tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr | 2 +-
 3 files changed, 4 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/README.md b/README.md
index c6b67bb6221..6c556f579ca 100644
--- a/README.md
+++ b/README.md
@@ -147,6 +147,7 @@ Some lints can be configured in a TOML file named `clippy.toml` or `.clippy.toml
 value` mapping eg.
 
 ```toml
+avoid-breaking-exported-api = false
 blacklisted-names = ["toto", "tata", "titi"]
 cognitive-complexity-threshold = 30
 ```
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index fd2dddb3b96..d65270a9450 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -122,6 +122,8 @@ macro_rules! define_Conf {
 
 // N.B., this macro is parsed by util/lintlib.py
 define_Conf! {
+    /// Lint: ENUM_VARIANT_NAMES, LARGE_TYPES_PASSED_BY_VALUE, TRIVIALLY_COPY_PASS_BY_REF, UNNECESSARY_WRAPS, UPPER_CASE_ACRONYMS, WRONG_SELF_CONVENTION. Suppress lints whenever the suggested change would cause breakage for other crates.
+    (avoid_breaking_exported_api: bool = true),
     /// Lint: CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR, IF_THEN_SOME_ELSE_NONE. The minimum rust version that the project supports
     (msrv: Option<String> = None),
     /// Lint: BLACKLISTED_NAME. The list of blacklisted names to lint about. NB: `bar` is not here since it has legitimate uses
diff --git a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
index d83080b69f5..a7be00426c4 100644
--- a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
+++ b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
@@ -1,4 +1,4 @@
-error: error reading Clippy's configuration file `$DIR/clippy.toml`: unknown field `foobar`, expected one of `msrv`, `blacklisted-names`, `cognitive-complexity-threshold`, `cyclomatic-complexity-threshold`, `doc-valid-idents`, `too-many-arguments-threshold`, `type-complexity-threshold`, `single-char-binding-names-threshold`, `too-large-for-stack`, `enum-variant-name-threshold`, `enum-variant-size-threshold`, `verbose-bit-mask-threshold`, `literal-representation-threshold`, `trivial-copy-size-limit`, `pass-by-value-size-limit`, `too-many-lines-threshold`, `array-size-threshold`, `vec-box-size-threshold`, `max-trait-bounds`, `max-struct-bools`, `max-fn-params-bools`, `warn-on-all-wildcard-imports`, `disallowed-methods`, `unreadable-literal-lint-fractions`, `upper-case-acronyms-aggressive`, `cargo-ignore-publish`, `third-party` at line 5 column 1
+error: error reading Clippy's configuration file `$DIR/clippy.toml`: unknown field `foobar`, expected one of `avoid-breaking-exported-api`, `msrv`, `blacklisted-names`, `cognitive-complexity-threshold`, `cyclomatic-complexity-threshold`, `doc-valid-idents`, `too-many-arguments-threshold`, `type-complexity-threshold`, `single-char-binding-names-threshold`, `too-large-for-stack`, `enum-variant-name-threshold`, `enum-variant-size-threshold`, `verbose-bit-mask-threshold`, `literal-representation-threshold`, `trivial-copy-size-limit`, `pass-by-value-size-limit`, `too-many-lines-threshold`, `array-size-threshold`, `vec-box-size-threshold`, `max-trait-bounds`, `max-struct-bools`, `max-fn-params-bools`, `warn-on-all-wildcard-imports`, `disallowed-methods`, `unreadable-literal-lint-fractions`, `upper-case-acronyms-aggressive`, `cargo-ignore-publish`, `third-party` at line 5 column 1
 
 error: aborting due to previous error
 
-- 
cgit 1.4.1-3-g733a5


From d7f47f280ec267c0583f7d38fc149a2351b923e6 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Wed, 26 May 2021 16:39:39 -0500
Subject: Use break api config for wrong_pub_self_convention

---
 clippy_lints/src/deprecated_lints.rs              |  9 +++++
 clippy_lints/src/lib.rs                           |  9 +++--
 clippy_lints/src/methods/mod.rs                   | 40 +++++--------------
 clippy_lints/src/methods/wrong_self_convention.rs | 13 ++----
 tests/ui/def_id_nocore.rs                         |  2 +-
 tests/ui/module_name_repetitions.rs               |  8 ----
 tests/ui/wrong_self_convention.rs                 |  1 -
 tests/ui/wrong_self_convention.stderr             | 48 +++++++++++------------
 tests/ui/wrong_self_convention2.rs                |  1 -
 tests/ui/wrong_self_convention2.stderr            |  4 +-
 10 files changed, 55 insertions(+), 80 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/deprecated_lints.rs b/clippy_lints/src/deprecated_lints.rs
index 50ffc2e3f19..dd780ff87fe 100644
--- a/clippy_lints/src/deprecated_lints.rs
+++ b/clippy_lints/src/deprecated_lints.rs
@@ -141,3 +141,12 @@ declare_deprecated_lint! {
     pub FILTER_MAP,
     "this lint has been replaced by `manual_filter_map`, a more specific lint"
 }
+
+declare_deprecated_lint! {
+    /// **What it does:** Nothing. This lint has been deprecated.
+    ///
+    /// **Deprecation reason:** The `avoid_breaking_exported_api` config option was added, which
+    /// enables the `wrong_self_conversion` lint for public items.
+    pub WRONG_PUB_SELF_CONVENTION,
+    "set the `avoid_breaking_exported_api` config option to `false` to enable the `wrong_self_convention` lint for public items"
+}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index cf54021202f..6dd2486afae 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -505,6 +505,10 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         "clippy::filter_map",
         "this lint has been replaced by `manual_filter_map`, a more specific lint",
     );
+    store.register_removed(
+        "clippy::wrong_pub_self_convention",
+        "set the `avoid_breaking_exported_api` config option to `false` to enable the `wrong_self_convention` lint for public items",
+    );
     // end deprecated lints, do not remove this comment, it’s used in `update_lints`
 
     // begin register lints, do not remove this comment, it’s used in `update_lints`
@@ -802,7 +806,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         methods::UNNECESSARY_LAZY_EVALUATIONS,
         methods::UNWRAP_USED,
         methods::USELESS_ASREF,
-        methods::WRONG_PUB_SELF_CONVENTION,
         methods::WRONG_SELF_CONVENTION,
         methods::ZST_OFFSET,
         minmax::MIN_MAX,
@@ -1026,7 +1029,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(methods::FILETYPE_IS_FILE),
         LintId::of(methods::GET_UNWRAP),
         LintId::of(methods::UNWRAP_USED),
-        LintId::of(methods::WRONG_PUB_SELF_CONVENTION),
         LintId::of(misc::FLOAT_CMP_CONST),
         LintId::of(misc_early::UNNEEDED_FIELD_PATTERN),
         LintId::of(missing_doc::MISSING_DOCS_IN_PRIVATE_ITEMS),
@@ -1862,7 +1864,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         })
     });
 
-    store.register_late_pass(move || box methods::Methods::new(msrv));
+    let avoid_breaking_exported_api = conf.avoid_breaking_exported_api;
+    store.register_late_pass(move || box methods::Methods::new(avoid_breaking_exported_api, msrv));
     store.register_late_pass(move || box matches::Matches::new(msrv));
     store.register_early_pass(move || box manual_non_exhaustive::ManualNonExhaustive::new(msrv));
     store.register_late_pass(move || box manual_strip::ManualStrip::new(msrv));
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index cabfe8023ef..0b998dbf86c 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -282,30 +282,6 @@ declare_clippy_lint! {
     "defining a method named with an established prefix (like \"into_\") that takes `self` with the wrong convention"
 }
 
-declare_clippy_lint! {
-    /// **What it does:** This is the same as
-    /// [`wrong_self_convention`](#wrong_self_convention), but for public items.
-    ///
-    /// **Why is this bad?** See [`wrong_self_convention`](#wrong_self_convention).
-    ///
-    /// **Known problems:** Actually *renaming* the function may break clients if
-    /// the function is part of the public interface. In that case, be mindful of
-    /// the stability guarantees you've given your users.
-    ///
-    /// **Example:**
-    /// ```rust
-    /// # struct X;
-    /// impl<'a> X {
-    ///     pub fn as_str(self) -> &'a str {
-    ///         "foo"
-    ///     }
-    /// }
-    /// ```
-    pub WRONG_PUB_SELF_CONVENTION,
-    restriction,
-    "defining a public method named with an established prefix (like \"into_\") that takes `self` with the wrong convention"
-}
-
 declare_clippy_lint! {
     /// **What it does:** Checks for usage of `ok().expect(..)`.
     ///
@@ -1658,13 +1634,17 @@ declare_clippy_lint! {
 }
 
 pub struct Methods {
+    avoid_breaking_exported_api: bool,
     msrv: Option<RustcVersion>,
 }
 
 impl Methods {
     #[must_use]
-    pub fn new(msrv: Option<RustcVersion>) -> Self {
-        Self { msrv }
+    pub fn new(avoid_breaking_exported_api: bool, msrv: Option<RustcVersion>) -> Self {
+        Self {
+            avoid_breaking_exported_api,
+            msrv,
+        }
     }
 }
 
@@ -1673,7 +1653,6 @@ impl_lint_pass!(Methods => [
     EXPECT_USED,
     SHOULD_IMPLEMENT_TRAIT,
     WRONG_SELF_CONVENTION,
-    WRONG_PUB_SELF_CONVENTION,
     OK_EXPECT,
     MAP_UNWRAP_OR,
     RESULT_MAP_OR_INTO_OPTION,
@@ -1838,11 +1817,13 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
                     }
                 }
 
-                if sig.decl.implicit_self.has_implicit_self() {
+                if sig.decl.implicit_self.has_implicit_self()
+                    && !(self.avoid_breaking_exported_api
+                        && cx.access_levels.is_exported(impl_item.hir_id()))
+                {
                     wrong_self_convention::check(
                         cx,
                         &name,
-                        item.vis.node.is_pub(),
                         self_ty,
                         first_arg_ty,
                         first_arg.pat.span,
@@ -1915,7 +1896,6 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
                 wrong_self_convention::check(
                     cx,
                     &item.ident.name.as_str(),
-                    false,
                     self_ty,
                     first_arg_ty,
                     first_arg_span,
diff --git a/clippy_lints/src/methods/wrong_self_convention.rs b/clippy_lints/src/methods/wrong_self_convention.rs
index 1773c26c251..a2e09e5ecec 100644
--- a/clippy_lints/src/methods/wrong_self_convention.rs
+++ b/clippy_lints/src/methods/wrong_self_convention.rs
@@ -6,7 +6,6 @@ use rustc_middle::ty::TyS;
 use rustc_span::source_map::Span;
 use std::fmt;
 
-use super::WRONG_PUB_SELF_CONVENTION;
 use super::WRONG_SELF_CONVENTION;
 
 #[rustfmt::skip]
@@ -21,9 +20,9 @@ const CONVENTIONS: [(&[Convention], &[SelfKind]); 9] = [
 
     // Conversion using `to_` can use borrowed (non-Copy types) or owned (Copy types).
     // Source: https://rust-lang.github.io/api-guidelines/naming.html#ad-hoc-conversions-follow-as_-to_-into_-conventions-c-conv
-    (&[Convention::StartsWith("to_"), Convention::NotEndsWith("_mut"), Convention::IsSelfTypeCopy(false), 
+    (&[Convention::StartsWith("to_"), Convention::NotEndsWith("_mut"), Convention::IsSelfTypeCopy(false),
     Convention::IsTraitItem(false), Convention::ImplementsTrait(false)], &[SelfKind::Ref]),
-    (&[Convention::StartsWith("to_"), Convention::NotEndsWith("_mut"), Convention::IsSelfTypeCopy(true), 
+    (&[Convention::StartsWith("to_"), Convention::NotEndsWith("_mut"), Convention::IsSelfTypeCopy(true),
     Convention::IsTraitItem(false), Convention::ImplementsTrait(false)], &[SelfKind::Value]),
 ];
 
@@ -85,18 +84,12 @@ impl fmt::Display for Convention {
 pub(super) fn check<'tcx>(
     cx: &LateContext<'tcx>,
     item_name: &str,
-    is_pub: bool,
     self_ty: &'tcx TyS<'tcx>,
     first_arg_ty: &'tcx TyS<'tcx>,
     first_arg_span: Span,
     implements_trait: bool,
     is_trait_item: bool,
 ) {
-    let lint = if is_pub {
-        WRONG_PUB_SELF_CONVENTION
-    } else {
-        WRONG_SELF_CONVENTION
-    };
     if let Some((conventions, self_kinds)) = &CONVENTIONS.iter().find(|(convs, _)| {
         convs
             .iter()
@@ -142,7 +135,7 @@ pub(super) fn check<'tcx>(
 
             span_lint_and_help(
                 cx,
-                lint,
+                WRONG_SELF_CONVENTION,
                 first_arg_span,
                 &format!(
                     "{} usually take {}",
diff --git a/tests/ui/def_id_nocore.rs b/tests/ui/def_id_nocore.rs
index 2a948d60b10..cba7666c2d8 100644
--- a/tests/ui/def_id_nocore.rs
+++ b/tests/ui/def_id_nocore.rs
@@ -20,7 +20,7 @@ fn start(_argc: isize, _argv: *const *const u8) -> isize {
     0
 }
 
-pub struct A;
+struct A;
 
 impl A {
     pub fn as_ref(self) -> &'static str {
diff --git a/tests/ui/module_name_repetitions.rs b/tests/ui/module_name_repetitions.rs
index 669bf01a84c..f5908cb5701 100644
--- a/tests/ui/module_name_repetitions.rs
+++ b/tests/ui/module_name_repetitions.rs
@@ -15,12 +15,4 @@ mod foo {
     pub struct Foobar;
 }
 
-#[cfg(test)]
-mod test {
-    #[test]
-    fn it_works() {
-        assert_eq!(2 + 2, 4);
-    }
-}
-
 fn main() {}
diff --git a/tests/ui/wrong_self_convention.rs b/tests/ui/wrong_self_convention.rs
index cdfbdb8b0db..151dd0c27d5 100644
--- a/tests/ui/wrong_self_convention.rs
+++ b/tests/ui/wrong_self_convention.rs
@@ -1,6 +1,5 @@
 // edition:2018
 #![warn(clippy::wrong_self_convention)]
-#![warn(clippy::wrong_pub_self_convention)]
 #![allow(dead_code)]
 
 fn main() {}
diff --git a/tests/ui/wrong_self_convention.stderr b/tests/ui/wrong_self_convention.stderr
index 29f5ba82695..ce23317abf6 100644
--- a/tests/ui/wrong_self_convention.stderr
+++ b/tests/ui/wrong_self_convention.stderr
@@ -1,5 +1,5 @@
 error: methods called `from_*` usually take no `self`
-  --> $DIR/wrong_self_convention.rs:18:17
+  --> $DIR/wrong_self_convention.rs:17:17
    |
 LL |     fn from_i32(self) {}
    |                 ^^^^
@@ -8,7 +8,7 @@ LL |     fn from_i32(self) {}
    = help: consider choosing a less ambiguous name
 
 error: methods called `from_*` usually take no `self`
-  --> $DIR/wrong_self_convention.rs:24:21
+  --> $DIR/wrong_self_convention.rs:23:21
    |
 LL |     pub fn from_i64(self) {}
    |                     ^^^^
@@ -16,7 +16,7 @@ LL |     pub fn from_i64(self) {}
    = help: consider choosing a less ambiguous name
 
 error: methods called `as_*` usually take `self` by reference or `self` by mutable reference
-  --> $DIR/wrong_self_convention.rs:36:15
+  --> $DIR/wrong_self_convention.rs:35:15
    |
 LL |     fn as_i32(self) {}
    |               ^^^^
@@ -24,7 +24,7 @@ LL |     fn as_i32(self) {}
    = help: consider choosing a less ambiguous name
 
 error: methods called `into_*` usually take `self` by value
-  --> $DIR/wrong_self_convention.rs:38:17
+  --> $DIR/wrong_self_convention.rs:37:17
    |
 LL |     fn into_i32(&self) {}
    |                 ^^^^^
@@ -32,7 +32,7 @@ LL |     fn into_i32(&self) {}
    = help: consider choosing a less ambiguous name
 
 error: methods called `is_*` usually take `self` by reference or no `self`
-  --> $DIR/wrong_self_convention.rs:40:15
+  --> $DIR/wrong_self_convention.rs:39:15
    |
 LL |     fn is_i32(self) {}
    |               ^^^^
@@ -40,7 +40,7 @@ LL |     fn is_i32(self) {}
    = help: consider choosing a less ambiguous name
 
 error: methods with the following characteristics: (`to_*` and `self` type is not `Copy`) usually take `self` by reference
-  --> $DIR/wrong_self_convention.rs:42:15
+  --> $DIR/wrong_self_convention.rs:41:15
    |
 LL |     fn to_i32(self) {}
    |               ^^^^
@@ -48,7 +48,7 @@ LL |     fn to_i32(self) {}
    = help: consider choosing a less ambiguous name
 
 error: methods called `from_*` usually take no `self`
-  --> $DIR/wrong_self_convention.rs:44:17
+  --> $DIR/wrong_self_convention.rs:43:17
    |
 LL |     fn from_i32(self) {}
    |                 ^^^^
@@ -56,7 +56,7 @@ LL |     fn from_i32(self) {}
    = help: consider choosing a less ambiguous name
 
 error: methods called `as_*` usually take `self` by reference or `self` by mutable reference
-  --> $DIR/wrong_self_convention.rs:46:19
+  --> $DIR/wrong_self_convention.rs:45:19
    |
 LL |     pub fn as_i64(self) {}
    |                   ^^^^
@@ -64,7 +64,7 @@ LL |     pub fn as_i64(self) {}
    = help: consider choosing a less ambiguous name
 
 error: methods called `into_*` usually take `self` by value
-  --> $DIR/wrong_self_convention.rs:47:21
+  --> $DIR/wrong_self_convention.rs:46:21
    |
 LL |     pub fn into_i64(&self) {}
    |                     ^^^^^
@@ -72,7 +72,7 @@ LL |     pub fn into_i64(&self) {}
    = help: consider choosing a less ambiguous name
 
 error: methods called `is_*` usually take `self` by reference or no `self`
-  --> $DIR/wrong_self_convention.rs:48:19
+  --> $DIR/wrong_self_convention.rs:47:19
    |
 LL |     pub fn is_i64(self) {}
    |                   ^^^^
@@ -80,7 +80,7 @@ LL |     pub fn is_i64(self) {}
    = help: consider choosing a less ambiguous name
 
 error: methods with the following characteristics: (`to_*` and `self` type is not `Copy`) usually take `self` by reference
-  --> $DIR/wrong_self_convention.rs:49:19
+  --> $DIR/wrong_self_convention.rs:48:19
    |
 LL |     pub fn to_i64(self) {}
    |                   ^^^^
@@ -88,7 +88,7 @@ LL |     pub fn to_i64(self) {}
    = help: consider choosing a less ambiguous name
 
 error: methods called `from_*` usually take no `self`
-  --> $DIR/wrong_self_convention.rs:50:21
+  --> $DIR/wrong_self_convention.rs:49:21
    |
 LL |     pub fn from_i64(self) {}
    |                     ^^^^
@@ -96,7 +96,7 @@ LL |     pub fn from_i64(self) {}
    = help: consider choosing a less ambiguous name
 
 error: methods called `as_*` usually take `self` by reference or `self` by mutable reference
-  --> $DIR/wrong_self_convention.rs:95:19
+  --> $DIR/wrong_self_convention.rs:94:19
    |
 LL |         fn as_i32(self) {}
    |                   ^^^^
@@ -104,7 +104,7 @@ LL |         fn as_i32(self) {}
    = help: consider choosing a less ambiguous name
 
 error: methods called `into_*` usually take `self` by value
-  --> $DIR/wrong_self_convention.rs:98:25
+  --> $DIR/wrong_self_convention.rs:97:25
    |
 LL |         fn into_i32_ref(&self) {}
    |                         ^^^^^
@@ -112,7 +112,7 @@ LL |         fn into_i32_ref(&self) {}
    = help: consider choosing a less ambiguous name
 
 error: methods called `is_*` usually take `self` by reference or no `self`
-  --> $DIR/wrong_self_convention.rs:100:19
+  --> $DIR/wrong_self_convention.rs:99:19
    |
 LL |         fn is_i32(self) {}
    |                   ^^^^
@@ -120,7 +120,7 @@ LL |         fn is_i32(self) {}
    = help: consider choosing a less ambiguous name
 
 error: methods called `from_*` usually take no `self`
-  --> $DIR/wrong_self_convention.rs:104:21
+  --> $DIR/wrong_self_convention.rs:103:21
    |
 LL |         fn from_i32(self) {}
    |                     ^^^^
@@ -128,7 +128,7 @@ LL |         fn from_i32(self) {}
    = help: consider choosing a less ambiguous name
 
 error: methods called `as_*` usually take `self` by reference or `self` by mutable reference
-  --> $DIR/wrong_self_convention.rs:119:19
+  --> $DIR/wrong_self_convention.rs:118:19
    |
 LL |         fn as_i32(self);
    |                   ^^^^
@@ -136,7 +136,7 @@ LL |         fn as_i32(self);
    = help: consider choosing a less ambiguous name
 
 error: methods called `into_*` usually take `self` by value
-  --> $DIR/wrong_self_convention.rs:122:25
+  --> $DIR/wrong_self_convention.rs:121:25
    |
 LL |         fn into_i32_ref(&self);
    |                         ^^^^^
@@ -144,7 +144,7 @@ LL |         fn into_i32_ref(&self);
    = help: consider choosing a less ambiguous name
 
 error: methods called `is_*` usually take `self` by reference or no `self`
-  --> $DIR/wrong_self_convention.rs:124:19
+  --> $DIR/wrong_self_convention.rs:123:19
    |
 LL |         fn is_i32(self);
    |                   ^^^^
@@ -152,7 +152,7 @@ LL |         fn is_i32(self);
    = help: consider choosing a less ambiguous name
 
 error: methods called `from_*` usually take no `self`
-  --> $DIR/wrong_self_convention.rs:128:21
+  --> $DIR/wrong_self_convention.rs:127:21
    |
 LL |         fn from_i32(self);
    |                     ^^^^
@@ -160,7 +160,7 @@ LL |         fn from_i32(self);
    = help: consider choosing a less ambiguous name
 
 error: methods called `into_*` usually take `self` by value
-  --> $DIR/wrong_self_convention.rs:146:25
+  --> $DIR/wrong_self_convention.rs:145:25
    |
 LL |         fn into_i32_ref(&self);
    |                         ^^^^^
@@ -168,7 +168,7 @@ LL |         fn into_i32_ref(&self);
    = help: consider choosing a less ambiguous name
 
 error: methods called `from_*` usually take no `self`
-  --> $DIR/wrong_self_convention.rs:152:21
+  --> $DIR/wrong_self_convention.rs:151:21
    |
 LL |         fn from_i32(self);
    |                     ^^^^
@@ -176,7 +176,7 @@ LL |         fn from_i32(self);
    = help: consider choosing a less ambiguous name
 
 error: methods with the following characteristics: (`to_*` and `self` type is `Copy`) usually take `self` by value
-  --> $DIR/wrong_self_convention.rs:176:22
+  --> $DIR/wrong_self_convention.rs:175:22
    |
 LL |         fn to_u64_v2(&self) -> u64 {
    |                      ^^^^^
@@ -184,7 +184,7 @@ LL |         fn to_u64_v2(&self) -> u64 {
    = help: consider choosing a less ambiguous name
 
 error: methods with the following characteristics: (`to_*` and `self` type is not `Copy`) usually take `self` by reference
-  --> $DIR/wrong_self_convention.rs:185:19
+  --> $DIR/wrong_self_convention.rs:184:19
    |
 LL |         fn to_u64(self) -> u64 {
    |                   ^^^^
diff --git a/tests/ui/wrong_self_convention2.rs b/tests/ui/wrong_self_convention2.rs
index 3a72174d03d..501bc1e6a85 100644
--- a/tests/ui/wrong_self_convention2.rs
+++ b/tests/ui/wrong_self_convention2.rs
@@ -1,6 +1,5 @@
 // edition:2018
 #![warn(clippy::wrong_self_convention)]
-#![warn(clippy::wrong_pub_self_convention)]
 #![allow(dead_code)]
 
 fn main() {}
diff --git a/tests/ui/wrong_self_convention2.stderr b/tests/ui/wrong_self_convention2.stderr
index d2d74ce099e..0e0d066d656 100644
--- a/tests/ui/wrong_self_convention2.stderr
+++ b/tests/ui/wrong_self_convention2.stderr
@@ -1,5 +1,5 @@
 error: methods called `from_*` usually take no `self`
-  --> $DIR/wrong_self_convention2.rs:56:29
+  --> $DIR/wrong_self_convention2.rs:55:29
    |
 LL |         pub fn from_be_self(self) -> Self {
    |                             ^^^^
@@ -8,7 +8,7 @@ LL |         pub fn from_be_self(self) -> Self {
    = help: consider choosing a less ambiguous name
 
 error: methods called `from_*` usually take no `self`
-  --> $DIR/wrong_self_convention2.rs:65:25
+  --> $DIR/wrong_self_convention2.rs:64:25
    |
 LL |         fn from_be_self(self) -> Self;
    |                         ^^^^
-- 
cgit 1.4.1-3-g733a5


From ee79077d8008006f25fb591946bdc17e99c0b91a Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Thu, 6 May 2021 12:45:21 -0500
Subject: Use break api config for pass by value or ref

---
 clippy_lints/src/lib.rs                    |  1 +
 clippy_lints/src/pass_by_ref_or_value.rs   | 13 +++++++++++--
 tests/ui/trivially_copy_pass_by_ref.stderr |  8 +-------
 3 files changed, 13 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 6dd2486afae..30db45a34f9 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1947,6 +1947,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     let pass_by_ref_or_value = pass_by_ref_or_value::PassByRefOrValue::new(
         conf.trivial_copy_size_limit,
         conf.pass_by_value_size_limit,
+        conf.avoid_breaking_exported_api,
         &sess.target,
     );
     store.register_late_pass(move || box pass_by_ref_or_value);
diff --git a/clippy_lints/src/pass_by_ref_or_value.rs b/clippy_lints/src/pass_by_ref_or_value.rs
index 6b64846c24d..f6a70478559 100644
--- a/clippy_lints/src/pass_by_ref_or_value.rs
+++ b/clippy_lints/src/pass_by_ref_or_value.rs
@@ -102,10 +102,16 @@ declare_clippy_lint! {
 pub struct PassByRefOrValue {
     ref_min_size: u64,
     value_max_size: u64,
+    avoid_breaking_exported_api: bool,
 }
 
 impl<'tcx> PassByRefOrValue {
-    pub fn new(ref_min_size: Option<u64>, value_max_size: u64, target: &Target) -> Self {
+    pub fn new(
+        ref_min_size: Option<u64>,
+        value_max_size: u64,
+        avoid_breaking_exported_api: bool,
+        target: &Target,
+    ) -> Self {
         let ref_min_size = ref_min_size.unwrap_or_else(|| {
             let bit_width = u64::from(target.pointer_width);
             // Cap the calculated bit width at 32-bits to reduce
@@ -120,10 +126,14 @@ impl<'tcx> PassByRefOrValue {
         Self {
             ref_min_size,
             value_max_size,
+            avoid_breaking_exported_api,
         }
     }
 
     fn check_poly_fn(&mut self, cx: &LateContext<'tcx>, hir_id: HirId, decl: &FnDecl<'_>, span: Option<Span>) {
+        if self.avoid_breaking_exported_api && cx.access_levels.is_exported(hir_id) {
+            return;
+        }
         let fn_def_id = cx.tcx.hir().local_def_id(hir_id);
 
         let fn_sig = cx.tcx.fn_sig(fn_def_id);
@@ -184,7 +194,6 @@ impl<'tcx> PassByRefOrValue {
                     }
 
                     if_chain! {
-                        if !cx.access_levels.is_exported(hir_id);
                         if is_copy(cx, ty);
                         if !is_self_ty(input);
                         if let Some(size) = cx.layout_of(ty).ok().map(|l| l.size.bytes());
diff --git a/tests/ui/trivially_copy_pass_by_ref.stderr b/tests/ui/trivially_copy_pass_by_ref.stderr
index ccc3cdb2b74..2b0005bbff1 100644
--- a/tests/ui/trivially_copy_pass_by_ref.stderr
+++ b/tests/ui/trivially_copy_pass_by_ref.stderr
@@ -88,12 +88,6 @@ error: this argument (N byte) is passed by reference, but would be more efficien
 LL |     fn trait_method(&self, _foo: &Foo);
    |                                  ^^^^ help: consider passing by value instead: `Foo`
 
-error: this argument (N byte) is passed by reference, but would be more efficient if passed by value (limit: N byte)
-  --> $DIR/trivially_copy_pass_by_ref.rs:80:37
-   |
-LL |     fn trait_method2(&self, _color: &Color);
-   |                                     ^^^^^^ help: consider passing by value instead: `Color`
-
 error: this argument (N byte) is passed by reference, but would be more efficient if passed by value (limit: N byte)
   --> $DIR/trivially_copy_pass_by_ref.rs:108:21
    |
@@ -106,5 +100,5 @@ error: this argument (N byte) is passed by reference, but would be more efficien
 LL |     fn foo(x: &i32) {
    |               ^^^^ help: consider passing by value instead: `i32`
 
-error: aborting due to 17 previous errors
+error: aborting due to 16 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 3d77a2b8617f914b1e5503dd93f67a8334693ce0 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Thu, 6 May 2021 14:02:24 -0500
Subject: Use break api config for enum_variant_names

---
 clippy_lints/src/deprecated_lints.rs | 10 +++++
 clippy_lints/src/enum_variants.rs    | 80 +++++++++++++-----------------------
 clippy_lints/src/lib.rs              |  8 ++--
 tests/ui/enum_variants.rs            |  7 ++--
 tests/ui/enum_variants.stderr        | 37 ++++++-----------
 5 files changed, 59 insertions(+), 83 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/deprecated_lints.rs b/clippy_lints/src/deprecated_lints.rs
index dd780ff87fe..04f3d77464f 100644
--- a/clippy_lints/src/deprecated_lints.rs
+++ b/clippy_lints/src/deprecated_lints.rs
@@ -142,6 +142,16 @@ declare_deprecated_lint! {
     "this lint has been replaced by `manual_filter_map`, a more specific lint"
 }
 
+declare_deprecated_lint! {
+    /// **What it does:** Nothing. This lint has been deprecated.
+    ///
+    /// **Deprecation reason:** The `avoid_breaking_exported_api` config option was added, which
+    /// enables the `enum_variant_names` lint for public items.
+    /// ```
+    pub PUB_ENUM_VARIANT_NAMES,
+    "set the `avoid_breaking_exported_api` config option to `false` to enable the `enum_variant_names` lint for public items"
+}
+
 declare_deprecated_lint! {
     /// **What it does:** Nothing. This lint has been deprecated.
     ///
diff --git a/clippy_lints/src/enum_variants.rs b/clippy_lints/src/enum_variants.rs
index 0ecc0bc3eb6..b1a105a51c1 100644
--- a/clippy_lints/src/enum_variants.rs
+++ b/clippy_lints/src/enum_variants.rs
@@ -3,8 +3,8 @@
 use clippy_utils::camel_case;
 use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
 use clippy_utils::source::is_present_in_source;
-use rustc_ast::ast::{EnumDef, Item, ItemKind, VisibilityKind};
-use rustc_lint::{EarlyContext, EarlyLintPass, Lint};
+use rustc_hir::{EnumDef, Item, ItemKind};
+use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::Span;
 use rustc_span::symbol::Symbol;
@@ -39,36 +39,6 @@ declare_clippy_lint! {
     "enums where all variants share a prefix/postfix"
 }
 
-declare_clippy_lint! {
-    /// **What it does:** Detects public enumeration variants that are
-    /// prefixed or suffixed by the same characters.
-    ///
-    /// **Why is this bad?** Public enumeration variant names should specify their variant,
-    /// not repeat the enumeration name.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    /// ```rust
-    /// pub enum Cake {
-    ///     BlackForestCake,
-    ///     HummingbirdCake,
-    ///     BattenbergCake,
-    /// }
-    /// ```
-    /// Could be written as:
-    /// ```rust
-    /// pub enum Cake {
-    ///     BlackForest,
-    ///     Hummingbird,
-    ///     Battenberg,
-    /// }
-    /// ```
-    pub PUB_ENUM_VARIANT_NAMES,
-    pedantic,
-    "public enums where all variants share a prefix/postfix"
-}
-
 declare_clippy_lint! {
     /// **What it does:** Detects type names that are prefixed or suffixed by the
     /// containing module's name.
@@ -127,21 +97,22 @@ declare_clippy_lint! {
 pub struct EnumVariantNames {
     modules: Vec<(Symbol, String)>,
     threshold: u64,
+    avoid_breaking_exported_api: bool,
 }
 
 impl EnumVariantNames {
     #[must_use]
-    pub fn new(threshold: u64) -> Self {
+    pub fn new(threshold: u64, avoid_breaking_exported_api: bool) -> Self {
         Self {
             modules: Vec::new(),
             threshold,
+            avoid_breaking_exported_api,
         }
     }
 }
 
 impl_lint_pass!(EnumVariantNames => [
     ENUM_VARIANT_NAMES,
-    PUB_ENUM_VARIANT_NAMES,
     MODULE_NAME_REPETITIONS,
     MODULE_INCEPTION
 ]);
@@ -167,33 +138,42 @@ fn partial_rmatch(post: &str, name: &str) -> usize {
 }
 
 fn check_variant(
-    cx: &EarlyContext<'_>,
+    cx: &LateContext<'_>,
     threshold: u64,
-    def: &EnumDef,
+    def: &EnumDef<'_>,
     item_name: &str,
     item_name_chars: usize,
     span: Span,
-    lint: &'static Lint,
 ) {
     if (def.variants.len() as u64) < threshold {
         return;
     }
-    for var in &def.variants {
+    for var in def.variants {
         let name = var.ident.name.as_str();
         if partial_match(item_name, &name) == item_name_chars
             && name.chars().nth(item_name_chars).map_or(false, |c| !c.is_lowercase())
             && name.chars().nth(item_name_chars + 1).map_or(false, |c| !c.is_numeric())
         {
-            span_lint(cx, lint, var.span, "variant name starts with the enum's name");
+            span_lint(
+                cx,
+                ENUM_VARIANT_NAMES,
+                var.span,
+                "variant name starts with the enum's name",
+            );
         }
         if partial_rmatch(item_name, &name) == item_name_chars {
-            span_lint(cx, lint, var.span, "variant name ends with the enum's name");
+            span_lint(
+                cx,
+                ENUM_VARIANT_NAMES,
+                var.span,
+                "variant name ends with the enum's name",
+            );
         }
     }
     let first = &def.variants[0].ident.name.as_str();
     let mut pre = &first[..camel_case::until(&*first)];
     let mut post = &first[camel_case::from(&*first)..];
-    for var in &def.variants {
+    for var in def.variants {
         let name = var.ident.name.as_str();
 
         let pre_match = partial_match(pre, &name);
@@ -226,7 +206,7 @@ fn check_variant(
     };
     span_lint_and_help(
         cx,
-        lint,
+        ENUM_VARIANT_NAMES,
         span,
         &format!("all variants have the same {}fix: `{}`", what, value),
         None,
@@ -261,14 +241,14 @@ fn to_camel_case(item_name: &str) -> String {
     s
 }
 
-impl EarlyLintPass for EnumVariantNames {
-    fn check_item_post(&mut self, _cx: &EarlyContext<'_>, _item: &Item) {
+impl LateLintPass<'_> for EnumVariantNames {
+    fn check_item_post(&mut self, _cx: &LateContext<'_>, _item: &Item<'_>) {
         let last = self.modules.pop();
         assert!(last.is_some());
     }
 
     #[allow(clippy::similar_names)]
-    fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {
+    fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
         let item_name = item.ident.name.as_str();
         let item_name_chars = item_name.chars().count();
         let item_camel = to_camel_case(&item_name);
@@ -286,7 +266,7 @@ impl EarlyLintPass for EnumVariantNames {
                             );
                         }
                     }
-                    if item.vis.kind.is_pub() {
+                    if item.vis.node.is_pub() {
                         let matching = partial_match(mod_camel, &item_camel);
                         let rmatching = partial_rmatch(mod_camel, &item_camel);
                         let nchars = mod_camel.chars().count();
@@ -317,11 +297,9 @@ impl EarlyLintPass for EnumVariantNames {
             }
         }
         if let ItemKind::Enum(ref def, _) = item.kind {
-            let lint = match item.vis.kind {
-                VisibilityKind::Public => PUB_ENUM_VARIANT_NAMES,
-                _ => ENUM_VARIANT_NAMES,
-            };
-            check_variant(cx, self.threshold, def, &item_name, item_name_chars, item.span, lint);
+            if !(self.avoid_breaking_exported_api && cx.access_levels.is_exported(item.hir_id())) {
+                check_variant(cx, self.threshold, def, &item_name, item_name_chars, item.span);
+            }
         }
         self.modules.push((item.ident.name, item_camel));
     }
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 30db45a34f9..bab389d2c05 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -505,6 +505,10 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         "clippy::filter_map",
         "this lint has been replaced by `manual_filter_map`, a more specific lint",
     );
+    store.register_removed(
+        "clippy::pub_enum_variant_names",
+        "set the `avoid_breaking_exported_api` config option to `false` to enable the `enum_variant_names` lint for public items",
+    );
     store.register_removed(
         "clippy::wrong_pub_self_convention",
         "set the `avoid_breaking_exported_api` config option to `false` to enable the `wrong_self_convention` lint for public items",
@@ -622,7 +626,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         enum_variants::ENUM_VARIANT_NAMES,
         enum_variants::MODULE_INCEPTION,
         enum_variants::MODULE_NAME_REPETITIONS,
-        enum_variants::PUB_ENUM_VARIANT_NAMES,
         eq_op::EQ_OP,
         eq_op::OP_REF,
         erasing_op::ERASING_OP,
@@ -1080,7 +1083,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(doc::MISSING_PANICS_DOC),
         LintId::of(empty_enum::EMPTY_ENUM),
         LintId::of(enum_variants::MODULE_NAME_REPETITIONS),
-        LintId::of(enum_variants::PUB_ENUM_VARIANT_NAMES),
         LintId::of(eta_reduction::REDUNDANT_CLOSURE_FOR_METHOD_CALLS),
         LintId::of(excessive_bools::FN_PARAMS_EXCESSIVE_BOOLS),
         LintId::of(excessive_bools::STRUCT_EXCESSIVE_BOOLS),
@@ -2015,7 +2017,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     let literal_representation_threshold = conf.literal_representation_threshold;
     store.register_early_pass(move || box literal_representation::DecimalLiteralRepresentation::new(literal_representation_threshold));
     let enum_variant_name_threshold = conf.enum_variant_name_threshold;
-    store.register_early_pass(move || box enum_variants::EnumVariantNames::new(enum_variant_name_threshold));
+    store.register_late_pass(move || box enum_variants::EnumVariantNames::new(enum_variant_name_threshold, avoid_breaking_exported_api));
     store.register_early_pass(|| box tabs_in_doc_comments::TabsInDocComments);
     let upper_case_acronyms_aggressive = conf.upper_case_acronyms_aggressive;
     store.register_early_pass(move || box upper_case_acronyms::UpperCaseAcronyms::new(upper_case_acronyms_aggressive));
diff --git a/tests/ui/enum_variants.rs b/tests/ui/enum_variants.rs
index 4fefc0b43f1..083f5143e6e 100644
--- a/tests/ui/enum_variants.rs
+++ b/tests/ui/enum_variants.rs
@@ -1,5 +1,4 @@
-#![feature(non_ascii_idents)]
-#![warn(clippy::enum_variant_names, clippy::pub_enum_variant_names)]
+#![warn(clippy::enum_variant_names)]
 #![allow(non_camel_case_types, clippy::upper_case_acronyms)]
 
 enum FakeCallType {
@@ -97,8 +96,8 @@ pub enum PubSeall {
     WithOut,
 }
 
-#[allow(clippy::pub_enum_variant_names)]
-mod allowed {
+#[allow(clippy::enum_variant_names)]
+pub mod allowed {
     pub enum PubAllowed {
         SomeThis,
         SomeThat,
diff --git a/tests/ui/enum_variants.stderr b/tests/ui/enum_variants.stderr
index ab7fff4507a..447fbb9e1bf 100644
--- a/tests/ui/enum_variants.stderr
+++ b/tests/ui/enum_variants.stderr
@@ -1,5 +1,5 @@
 error: variant name ends with the enum's name
-  --> $DIR/enum_variants.rs:16:5
+  --> $DIR/enum_variants.rs:15:5
    |
 LL |     cFoo,
    |     ^^^^
@@ -7,25 +7,25 @@ LL |     cFoo,
    = note: `-D clippy::enum-variant-names` implied by `-D warnings`
 
 error: variant name starts with the enum's name
-  --> $DIR/enum_variants.rs:27:5
+  --> $DIR/enum_variants.rs:26:5
    |
 LL |     FoodGood,
    |     ^^^^^^^^
 
 error: variant name starts with the enum's name
-  --> $DIR/enum_variants.rs:28:5
+  --> $DIR/enum_variants.rs:27:5
    |
 LL |     FoodMiddle,
    |     ^^^^^^^^^^
 
 error: variant name starts with the enum's name
-  --> $DIR/enum_variants.rs:29:5
+  --> $DIR/enum_variants.rs:28:5
    |
 LL |     FoodBad,
    |     ^^^^^^^
 
 error: all variants have the same prefix: `Food`
-  --> $DIR/enum_variants.rs:26:1
+  --> $DIR/enum_variants.rs:25:1
    |
 LL | / enum Food {
 LL | |     FoodGood,
@@ -37,7 +37,7 @@ LL | | }
    = help: remove the prefixes and use full paths to the variants instead of glob imports
 
 error: all variants have the same prefix: `CallType`
-  --> $DIR/enum_variants.rs:36:1
+  --> $DIR/enum_variants.rs:35:1
    |
 LL | / enum BadCallType {
 LL | |     CallTypeCall,
@@ -49,7 +49,7 @@ LL | | }
    = help: remove the prefixes and use full paths to the variants instead of glob imports
 
 error: all variants have the same prefix: `Constant`
-  --> $DIR/enum_variants.rs:48:1
+  --> $DIR/enum_variants.rs:47:1
    |
 LL | / enum Consts {
 LL | |     ConstantInt,
@@ -61,7 +61,7 @@ LL | | }
    = help: remove the prefixes and use full paths to the variants instead of glob imports
 
 error: all variants have the same prefix: `With`
-  --> $DIR/enum_variants.rs:82:1
+  --> $DIR/enum_variants.rs:81:1
    |
 LL | / enum Seallll {
 LL | |     WithOutCake,
@@ -73,7 +73,7 @@ LL | | }
    = help: remove the prefixes and use full paths to the variants instead of glob imports
 
 error: all variants have the same prefix: `Prefix`
-  --> $DIR/enum_variants.rs:88:1
+  --> $DIR/enum_variants.rs:87:1
    |
 LL | / enum NonCaps {
 LL | |     Prefix的,
@@ -84,21 +84,8 @@ LL | | }
    |
    = help: remove the prefixes and use full paths to the variants instead of glob imports
 
-error: all variants have the same prefix: `With`
-  --> $DIR/enum_variants.rs:94:1
-   |
-LL | / pub enum PubSeall {
-LL | |     WithOutCake,
-LL | |     WithOutTea,
-LL | |     WithOut,
-LL | | }
-   | |_^
-   |
-   = note: `-D clippy::pub-enum-variant-names` implied by `-D warnings`
-   = help: remove the prefixes and use full paths to the variants instead of glob imports
-
 error: all variants have the same postfix: `IData`
-  --> $DIR/enum_variants.rs:137:1
+  --> $DIR/enum_variants.rs:136:1
    |
 LL | / enum IDataRequest {
 LL | |     PutIData(String),
@@ -110,7 +97,7 @@ LL | | }
    = help: remove the postfixes and use full paths to the variants instead of glob imports
 
 error: all variants have the same postfix: `HIData`
-  --> $DIR/enum_variants.rs:143:1
+  --> $DIR/enum_variants.rs:142:1
    |
 LL | / enum HIDataRequest {
 LL | |     PutHIData(String),
@@ -121,5 +108,5 @@ LL | | }
    |
    = help: remove the postfixes and use full paths to the variants instead of glob imports
 
-error: aborting due to 12 previous errors
+error: aborting due to 11 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 1ce581d70698466879dc7acec0629032fb9006fd Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Thu, 6 May 2021 14:33:23 -0500
Subject: Use break api config for unnecessary_wraps

---
 clippy_lints/src/lib.rs               |  2 +-
 clippy_lints/src/unnecessary_wraps.rs | 21 ++++++++++++++++-----
 tests/ui/unnecessary_wraps.rs         |  2 +-
 3 files changed, 18 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index bab389d2c05..9c9eba0d21e 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1976,7 +1976,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box redundant_clone::RedundantClone);
     store.register_late_pass(|| box slow_vector_initialization::SlowVectorInit);
     store.register_late_pass(|| box unnecessary_sort_by::UnnecessarySortBy);
-    store.register_late_pass(|| box unnecessary_wraps::UnnecessaryWraps);
+    store.register_late_pass(move || box unnecessary_wraps::UnnecessaryWraps::new(avoid_breaking_exported_api));
     store.register_late_pass(|| box assertions_on_constants::AssertionsOnConstants);
     store.register_late_pass(|| box transmuting_null::TransmutingNull);
     store.register_late_pass(|| box path_buf_push_overwrite::PathBufPushOverwrite);
diff --git a/clippy_lints/src/unnecessary_wraps.rs b/clippy_lints/src/unnecessary_wraps.rs
index f2f1410aed7..a85ffa6aa95 100644
--- a/clippy_lints/src/unnecessary_wraps.rs
+++ b/clippy_lints/src/unnecessary_wraps.rs
@@ -8,7 +8,7 @@ use rustc_hir::LangItem::{OptionSome, ResultOk};
 use rustc_hir::{Body, ExprKind, FnDecl, HirId, Impl, ItemKind, Node};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::symbol::sym;
 use rustc_span::Span;
 
@@ -52,7 +52,19 @@ declare_clippy_lint! {
     "functions that only return `Ok` or `Some`"
 }
 
-declare_lint_pass!(UnnecessaryWraps => [UNNECESSARY_WRAPS]);
+pub struct UnnecessaryWraps {
+    avoid_breaking_exported_api: bool,
+}
+
+impl_lint_pass!(UnnecessaryWraps => [UNNECESSARY_WRAPS]);
+
+impl UnnecessaryWraps {
+    pub fn new(avoid_breaking_exported_api: bool) -> Self {
+        Self {
+            avoid_breaking_exported_api,
+        }
+    }
+}
 
 impl<'tcx> LateLintPass<'tcx> for UnnecessaryWraps {
     fn check_fn(
@@ -66,13 +78,12 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryWraps {
     ) {
         // Abort if public function/method or closure.
         match fn_kind {
-            FnKind::ItemFn(.., visibility) | FnKind::Method(.., Some(visibility)) => {
-                if visibility.node.is_pub() {
+            FnKind::ItemFn(..) | FnKind::Method(..) => {
+                if self.avoid_breaking_exported_api && cx.access_levels.is_exported(hir_id) {
                     return;
                 }
             },
             FnKind::Closure => return,
-            FnKind::Method(..) => (),
         }
 
         // Abort if the method is implementing a trait or of it a trait method.
diff --git a/tests/ui/unnecessary_wraps.rs b/tests/ui/unnecessary_wraps.rs
index 54f22e3ee6a..63648ef5826 100644
--- a/tests/ui/unnecessary_wraps.rs
+++ b/tests/ui/unnecessary_wraps.rs
@@ -65,7 +65,7 @@ fn func10() -> Option<()> {
     unimplemented!()
 }
 
-struct A;
+pub struct A;
 
 impl A {
     // should not be linted
-- 
cgit 1.4.1-3-g733a5


From 55ccc7a8c6c353c3350332114c76b79f3108a9c2 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Thu, 6 May 2021 14:42:55 -0500
Subject: Use break api config for upper_case_acronyms

---
 clippy_lints/src/lib.rs                 |  2 +-
 clippy_lints/src/upper_case_acronyms.rs | 32 +++++++++++++++++++-------------
 2 files changed, 20 insertions(+), 14 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 9c9eba0d21e..5139b1464c4 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -2020,7 +2020,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(move || box enum_variants::EnumVariantNames::new(enum_variant_name_threshold, avoid_breaking_exported_api));
     store.register_early_pass(|| box tabs_in_doc_comments::TabsInDocComments);
     let upper_case_acronyms_aggressive = conf.upper_case_acronyms_aggressive;
-    store.register_early_pass(move || box upper_case_acronyms::UpperCaseAcronyms::new(upper_case_acronyms_aggressive));
+    store.register_late_pass(move || box upper_case_acronyms::UpperCaseAcronyms::new(avoid_breaking_exported_api, upper_case_acronyms_aggressive));
     store.register_late_pass(|| box default::Default::default());
     store.register_late_pass(|| box unused_self::UnusedSelf);
     store.register_late_pass(|| box mutable_debug_assertion::DebugAssertWithMutCall);
diff --git a/clippy_lints/src/upper_case_acronyms.rs b/clippy_lints/src/upper_case_acronyms.rs
index debbd86a59e..0b58c6c0917 100644
--- a/clippy_lints/src/upper_case_acronyms.rs
+++ b/clippy_lints/src/upper_case_acronyms.rs
@@ -1,8 +1,8 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use itertools::Itertools;
-use rustc_ast::ast::{Item, ItemKind, VisibilityKind};
 use rustc_errors::Applicability;
-use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
+use rustc_hir::{Item, ItemKind};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::symbol::Ident;
@@ -38,12 +38,14 @@ declare_clippy_lint! {
 
 #[derive(Default)]
 pub struct UpperCaseAcronyms {
+    avoid_breaking_exported_api: bool,
     upper_case_acronyms_aggressive: bool,
 }
 
 impl UpperCaseAcronyms {
-    pub fn new(aggressive: bool) -> Self {
+    pub fn new(avoid_breaking_exported_api: bool, aggressive: bool) -> Self {
         Self {
+            avoid_breaking_exported_api,
             upper_case_acronyms_aggressive: aggressive,
         }
     }
@@ -72,7 +74,7 @@ fn correct_ident(ident: &str) -> String {
     ident
 }
 
-fn check_ident(cx: &EarlyContext<'_>, ident: &Ident, be_aggressive: bool) {
+fn check_ident(cx: &LateContext<'_>, ident: &Ident, be_aggressive: bool) {
     let span = ident.span;
     let ident = &ident.as_str();
     let corrected = correct_ident(ident);
@@ -96,23 +98,27 @@ fn check_ident(cx: &EarlyContext<'_>, ident: &Ident, be_aggressive: bool) {
     }
 }
 
-impl EarlyLintPass for UpperCaseAcronyms {
-    fn check_item(&mut self, cx: &EarlyContext<'_>, it: &Item) {
+impl LateLintPass<'_> for UpperCaseAcronyms {
+    fn check_item(&mut self, cx: &LateContext<'_>, it: &Item<'_>) {
         // do not lint public items or in macros
-        if !in_external_macro(cx.sess(), it.span) && !matches!(it.vis.kind, VisibilityKind::Public) {
-            if matches!(
-                it.kind,
-                ItemKind::TyAlias(..) | ItemKind::Struct(..) | ItemKind::Trait(..)
-            ) {
+        if in_external_macro(cx.sess(), it.span)
+            || (self.avoid_breaking_exported_api && cx.access_levels.is_exported(it.hir_id()))
+        {
+            return;
+        }
+        match it.kind {
+            ItemKind::TyAlias(..) | ItemKind::Struct(..) | ItemKind::Trait(..) => {
                 check_ident(cx, &it.ident, self.upper_case_acronyms_aggressive);
-            } else if let ItemKind::Enum(ref enumdef, _) = it.kind {
+            },
+            ItemKind::Enum(ref enumdef, _) => {
                 // check enum variants seperately because again we only want to lint on private enums and
                 // the fn check_variant does not know about the vis of the enum of its variants
                 enumdef
                     .variants
                     .iter()
                     .for_each(|variant| check_ident(cx, &variant.ident, self.upper_case_acronyms_aggressive));
-            }
+            },
+            _ => {},
         }
     }
 }
-- 
cgit 1.4.1-3-g733a5


From 6eea598645be5489f518f91e4b80a0f04a315fda Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Fri, 7 May 2021 12:07:59 -0500
Subject: Fix config file lookup

---
 clippy_lints/src/lib.rs        | 11 -----------
 clippy_lints/src/utils/conf.rs | 16 +++++++---------
 2 files changed, 7 insertions(+), 20 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 5139b1464c4..b08a57a09b3 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -405,7 +405,6 @@ pub fn register_pre_expansion_lints(store: &mut rustc_lint::LintStore) {
 
 #[doc(hidden)]
 pub fn read_conf(sess: &Session) -> Conf {
-    use std::path::Path;
     let file_name = match utils::conf::lookup_conf_file() {
         Ok(Some(path)) => path,
         Ok(None) => return Conf::default(),
@@ -416,16 +415,6 @@ pub fn read_conf(sess: &Session) -> Conf {
         },
     };
 
-    let file_name = if file_name.is_relative() {
-        sess.local_crate_source_file
-            .as_deref()
-            .and_then(Path::parent)
-            .unwrap_or_else(|| Path::new(""))
-            .join(file_name)
-    } else {
-        file_name
-    };
-
     let TryConf { conf, errors } = utils::conf::read(&file_name);
     // all conf errors are non-fatal, we just use the default conf in case of error
     for error in errors {
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index d65270a9450..1bd38dc042c 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -210,15 +210,13 @@ pub fn lookup_conf_file() -> io::Result<Option<PathBuf>> {
         .map_or_else(|| PathBuf::from("."), PathBuf::from);
     loop {
         for config_file_name in &CONFIG_FILE_NAMES {
-            let config_file = current.join(config_file_name);
-            match fs::metadata(&config_file) {
-                // Only return if it's a file to handle the unlikely situation of a directory named
-                // `clippy.toml`.
-                Ok(ref md) if !md.is_dir() => return Ok(Some(config_file)),
-                // Return the error if it's something other than `NotFound`; otherwise we didn't
-                // find the project file yet, and continue searching.
-                Err(e) if e.kind() != io::ErrorKind::NotFound => return Err(e),
-                _ => {},
+            if let Ok(config_file) = current.join(config_file_name).canonicalize() {
+                match fs::metadata(&config_file) {
+                    Err(e) if e.kind() == io::ErrorKind::NotFound => {},
+                    Err(e) => return Err(e),
+                    Ok(md) if md.is_dir() => {},
+                    Ok(_) => return Ok(Some(config_file)),
+                }
             }
         }
 
-- 
cgit 1.4.1-3-g733a5


From f3e77a454aef617998a016ca70c8dc0d281f208a Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Wed, 26 May 2021 22:07:53 -0500
Subject: Fix allow on some statement lints

---
 clippy_lints/src/loops/needless_collect.rs |  5 +++--
 clippy_lints/src/misc.rs                   |  4 +++-
 clippy_lints/src/no_effect.rs              | 13 +++++++------
 clippy_utils/src/diagnostics.rs            |  2 +-
 tests/ui/needless_collect_indirect.rs      |  8 +++++++-
 tests/ui/no_effect.rs                      |  3 +++
 6 files changed, 24 insertions(+), 11 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/needless_collect.rs b/clippy_lints/src/loops/needless_collect.rs
index d3406780888..eb82c9c27c3 100644
--- a/clippy_lints/src/loops/needless_collect.rs
+++ b/clippy_lints/src/loops/needless_collect.rs
@@ -1,5 +1,5 @@
 use super::NEEDLESS_COLLECT;
-use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
+use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_hir_and_then};
 use clippy_utils::source::{snippet, snippet_with_applicability};
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::is_type_diagnostic_item;
@@ -116,9 +116,10 @@ fn check_needless_collect_indirect_usage<'tcx>(expr: &'tcx Expr<'_>, cx: &LateCo
                     // Suggest replacing iter_call with iter_replacement, and removing stmt
                     let mut span = MultiSpan::from_span(collect_span);
                     span.push_span_label(iter_call.span, "the iterator could be used here instead".into());
-                    span_lint_and_then(
+                    span_lint_hir_and_then(
                         cx,
                         super::NEEDLESS_COLLECT,
+                        init_expr.hir_id,
                         span,
                         NEEDLESS_COLLECT_MSG,
                         |diag| {
diff --git a/clippy_lints/src/misc.rs b/clippy_lints/src/misc.rs
index b5d2549242b..5976b060ad2 100644
--- a/clippy_lints/src/misc.rs
+++ b/clippy_lints/src/misc.rs
@@ -355,8 +355,10 @@ impl<'tcx> LateLintPass<'tcx> for MiscLints {
             if binop.node == BinOpKind::And || binop.node == BinOpKind::Or;
             if let Some(sugg) = Sugg::hir_opt(cx, a);
             then {
-                span_lint_and_then(cx,
+                span_lint_hir_and_then(
+                    cx,
                     SHORT_CIRCUIT_STATEMENT,
+                    expr.hir_id,
                     stmt.span,
                     "boolean short circuit operator in statement may be clearer using an explicit test",
                     |diag| {
diff --git a/clippy_lints/src/no_effect.rs b/clippy_lints/src/no_effect.rs
index cfcaf509471..b2206a82208 100644
--- a/clippy_lints/src/no_effect.rs
+++ b/clippy_lints/src/no_effect.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg};
+use clippy_utils::diagnostics::{span_lint_hir, span_lint_hir_and_then};
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::has_drop;
 use rustc_errors::Applicability;
@@ -92,7 +92,7 @@ impl<'tcx> LateLintPass<'tcx> for NoEffect {
     fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) {
         if let StmtKind::Semi(expr) = stmt.kind {
             if has_no_effect(cx, expr) {
-                span_lint(cx, NO_EFFECT, stmt.span, "statement with no effect");
+                span_lint_hir(cx, NO_EFFECT, expr.hir_id, stmt.span, "statement with no effect");
             } else if let Some(reduced) = reduce_expression(cx, expr) {
                 let mut snippet = String::new();
                 for e in reduced {
@@ -106,14 +106,15 @@ impl<'tcx> LateLintPass<'tcx> for NoEffect {
                         return;
                     }
                 }
-                span_lint_and_sugg(
+                span_lint_hir_and_then(
                     cx,
                     UNNECESSARY_OPERATION,
+                    expr.hir_id,
                     stmt.span,
                     "statement can be reduced",
-                    "replace it with",
-                    snippet,
-                    Applicability::MachineApplicable,
+                    |diag| {
+                        diag.span_suggestion(stmt.span, "replace it with", snippet, Applicability::MachineApplicable);
+                    },
                 );
             }
         }
diff --git a/clippy_utils/src/diagnostics.rs b/clippy_utils/src/diagnostics.rs
index a1f5f5f3338..7c94474cb35 100644
--- a/clippy_utils/src/diagnostics.rs
+++ b/clippy_utils/src/diagnostics.rs
@@ -167,7 +167,7 @@ pub fn span_lint_hir_and_then(
     cx: &LateContext<'_>,
     lint: &'static Lint,
     hir_id: HirId,
-    sp: Span,
+    sp: impl Into<MultiSpan>,
     msg: &str,
     f: impl FnOnce(&mut DiagnosticBuilder<'_>),
 ) {
diff --git a/tests/ui/needless_collect_indirect.rs b/tests/ui/needless_collect_indirect.rs
index 2458bf1e490..2c94235b8f5 100644
--- a/tests/ui/needless_collect_indirect.rs
+++ b/tests/ui/needless_collect_indirect.rs
@@ -1,4 +1,4 @@
-use std::collections::{BinaryHeap, HashMap, LinkedList, VecDeque};
+use std::collections::{BinaryHeap, HashMap, HashSet, LinkedList, VecDeque};
 
 fn main() {
     let sample = [1; 5];
@@ -75,3 +75,9 @@ mod issue7110 {
         buffer.len()
     }
 }
+
+fn allow_test() {
+    #[allow(clippy::needless_collect)]
+    let v = [1].iter().collect::<Vec<_>>();
+    v.into_iter().collect::<HashSet<_>>();
+}
diff --git a/tests/ui/no_effect.rs b/tests/ui/no_effect.rs
index 8fbfcb79860..7ec845adfaa 100644
--- a/tests/ui/no_effect.rs
+++ b/tests/ui/no_effect.rs
@@ -91,6 +91,9 @@ fn main() {
     let s: String = "foo".into();
     FooString { s: s };
 
+    #[allow(clippy::no_effect)]
+    0;
+
     // Do not warn
     get_number();
     unsafe { unsafe_fn() };
-- 
cgit 1.4.1-3-g733a5


From d39a11cbe151d9578432e0c7c64364b7eaffe89c Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Thu, 27 May 2021 08:49:37 -0500
Subject: Remove clippy_utils::consts re-export

---
 clippy_lints/src/absurd_extreme_comparisons.rs      | 3 +--
 clippy_lints/src/arithmetic.rs                      | 2 +-
 clippy_lints/src/assertions_on_constants.rs         | 2 +-
 clippy_lints/src/bit_mask.rs                        | 2 +-
 clippy_lints/src/casts/cast_sign_loss.rs            | 2 +-
 clippy_lints/src/consts.rs                          | 1 -
 clippy_lints/src/duration_subsec.rs                 | 2 +-
 clippy_lints/src/enum_clike.rs                      | 2 +-
 clippy_lints/src/erasing_op.rs                      | 3 +--
 clippy_lints/src/floating_point_arithmetic.rs       | 2 +-
 clippy_lints/src/identity_op.rs                     | 2 +-
 clippy_lints/src/indexing_slicing.rs                | 2 +-
 clippy_lints/src/invalid_upcast_comparisons.rs      | 3 +--
 clippy_lints/src/lib.rs                             | 1 -
 clippy_lints/src/loops/while_immutable_condition.rs | 2 +-
 clippy_lints/src/manual_strip.rs                    | 2 +-
 clippy_lints/src/manual_unwrap_or.rs                | 2 +-
 clippy_lints/src/matches.rs                         | 2 +-
 clippy_lints/src/methods/iter_nth_zero.rs           | 2 +-
 clippy_lints/src/methods/iterator_step_by_zero.rs   | 2 +-
 clippy_lints/src/minmax.rs                          | 2 +-
 clippy_lints/src/misc.rs                            | 2 +-
 clippy_lints/src/modulo_arithmetic.rs               | 2 +-
 clippy_lints/src/neg_multiply.rs                    | 3 +--
 clippy_lints/src/ranges.rs                          | 2 +-
 clippy_lints/src/regex.rs                           | 2 +-
 clippy_lints/src/repeat_once.rs                     | 2 +-
 clippy_lints/src/transmuting_null.rs                | 2 +-
 clippy_lints/src/utils/internal_lints.rs            | 2 +-
 clippy_lints/src/vec.rs                             | 2 +-
 clippy_lints/src/zero_div_zero.rs                   | 2 +-
 31 files changed, 29 insertions(+), 35 deletions(-)
 delete mode 100644 clippy_lints/src/consts.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/absurd_extreme_comparisons.rs b/clippy_lints/src/absurd_extreme_comparisons.rs
index 5fbf4bdbd18..49d4350123f 100644
--- a/clippy_lints/src/absurd_extreme_comparisons.rs
+++ b/clippy_lints/src/absurd_extreme_comparisons.rs
@@ -3,9 +3,8 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
-use crate::consts::{constant, Constant};
-
 use clippy_utils::comparisons::{normalize_comparison, Rel};
+use clippy_utils::consts::{constant, Constant};
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::is_isize_or_usize;
diff --git a/clippy_lints/src/arithmetic.rs b/clippy_lints/src/arithmetic.rs
index c560f545d6a..24c2a972811 100644
--- a/clippy_lints/src/arithmetic.rs
+++ b/clippy_lints/src/arithmetic.rs
@@ -1,4 +1,4 @@
-use crate::consts::constant_simple;
+use clippy_utils::consts::constant_simple;
 use clippy_utils::diagnostics::span_lint;
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/assertions_on_constants.rs b/clippy_lints/src/assertions_on_constants.rs
index 6c9ceaa45c2..5235b2642d1 100644
--- a/clippy_lints/src/assertions_on_constants.rs
+++ b/clippy_lints/src/assertions_on_constants.rs
@@ -1,4 +1,4 @@
-use crate::consts::{constant, Constant};
+use clippy_utils::consts::{constant, Constant};
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::source::snippet_opt;
 use clippy_utils::{is_direct_expn_of, is_expn_of, match_panic_call};
diff --git a/clippy_lints/src/bit_mask.rs b/clippy_lints/src/bit_mask.rs
index 0ac6dc28e73..991ed94572c 100644
--- a/clippy_lints/src/bit_mask.rs
+++ b/clippy_lints/src/bit_mask.rs
@@ -1,4 +1,4 @@
-use crate::consts::{constant, Constant};
+use clippy_utils::consts::{constant, Constant};
 use clippy_utils::diagnostics::{span_lint, span_lint_and_then};
 use clippy_utils::sugg::Sugg;
 use if_chain::if_chain;
diff --git a/clippy_lints/src/casts/cast_sign_loss.rs b/clippy_lints/src/casts/cast_sign_loss.rs
index 040e0ca8864..c9c111a2847 100644
--- a/clippy_lints/src/casts/cast_sign_loss.rs
+++ b/clippy_lints/src/casts/cast_sign_loss.rs
@@ -1,4 +1,4 @@
-use crate::consts::{constant, Constant};
+use clippy_utils::consts::{constant, Constant};
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::{method_chain_args, sext};
 use if_chain::if_chain;
diff --git a/clippy_lints/src/consts.rs b/clippy_lints/src/consts.rs
deleted file mode 100644
index 7e87f53e3fb..00000000000
--- a/clippy_lints/src/consts.rs
+++ /dev/null
@@ -1 +0,0 @@
-pub use clippy_utils::consts::*;
diff --git a/clippy_lints/src/duration_subsec.rs b/clippy_lints/src/duration_subsec.rs
index 529807770f3..94b09bf7173 100644
--- a/clippy_lints/src/duration_subsec.rs
+++ b/clippy_lints/src/duration_subsec.rs
@@ -7,7 +7,7 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Spanned;
 
-use crate::consts::{constant, Constant};
+use clippy_utils::consts::{constant, Constant};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::paths;
 
diff --git a/clippy_lints/src/enum_clike.rs b/clippy_lints/src/enum_clike.rs
index 7a98ae39d3a..021136ac5e0 100644
--- a/clippy_lints/src/enum_clike.rs
+++ b/clippy_lints/src/enum_clike.rs
@@ -1,7 +1,7 @@
 //! lint on C-like enums that are `repr(isize/usize)` and have values that
 //! don't fit into an `i32`
 
-use crate::consts::{miri_to_const, Constant};
+use clippy_utils::consts::{miri_to_const, Constant};
 use clippy_utils::diagnostics::span_lint;
 use rustc_hir::{Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/erasing_op.rs b/clippy_lints/src/erasing_op.rs
index f95ca86a2d0..4aa9c25b1b0 100644
--- a/clippy_lints/src/erasing_op.rs
+++ b/clippy_lints/src/erasing_op.rs
@@ -1,11 +1,10 @@
+use clippy_utils::consts::{constant_simple, Constant};
 use clippy_utils::diagnostics::span_lint;
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
 
-use crate::consts::{constant_simple, Constant};
-
 declare_clippy_lint! {
     /// **What it does:** Checks for erasing operations, e.g., `x * 0`.
     ///
diff --git a/clippy_lints/src/floating_point_arithmetic.rs b/clippy_lints/src/floating_point_arithmetic.rs
index 08f28cd54c5..e38384b01d4 100644
--- a/clippy_lints/src/floating_point_arithmetic.rs
+++ b/clippy_lints/src/floating_point_arithmetic.rs
@@ -1,4 +1,4 @@
-use crate::consts::{
+use clippy_utils::consts::{
     constant, constant_simple, Constant,
     Constant::{Int, F32, F64},
 };
diff --git a/clippy_lints/src/identity_op.rs b/clippy_lints/src/identity_op.rs
index 366b3b46a8a..99c461930e4 100644
--- a/clippy_lints/src/identity_op.rs
+++ b/clippy_lints/src/identity_op.rs
@@ -6,7 +6,7 @@ use rustc_middle::ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
 
-use crate::consts::{constant_simple, Constant};
+use clippy_utils::consts::{constant_simple, Constant};
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::{clip, unsext};
 
diff --git a/clippy_lints/src/indexing_slicing.rs b/clippy_lints/src/indexing_slicing.rs
index 1c54599abc4..bfa284f333a 100644
--- a/clippy_lints/src/indexing_slicing.rs
+++ b/clippy_lints/src/indexing_slicing.rs
@@ -1,6 +1,6 @@
 //! lint on indexing and slicing operations
 
-use crate::consts::{constant, Constant};
+use clippy_utils::consts::{constant, Constant};
 use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
 use clippy_utils::higher;
 use rustc_ast::ast::RangeLimits;
diff --git a/clippy_lints/src/invalid_upcast_comparisons.rs b/clippy_lints/src/invalid_upcast_comparisons.rs
index aafdebef248..37011f5578d 100644
--- a/clippy_lints/src/invalid_upcast_comparisons.rs
+++ b/clippy_lints/src/invalid_upcast_comparisons.rs
@@ -7,9 +7,8 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::Span;
 use rustc_target::abi::LayoutOf;
 
-use crate::consts::{constant, Constant};
-
 use clippy_utils::comparisons::Rel;
+use clippy_utils::consts::{constant, Constant};
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::source::snippet;
 use clippy_utils::{comparisons, sext};
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index fb91fac659e..4c9c44f55d1 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -148,7 +148,6 @@ macro_rules! declare_clippy_lint {
     };
 }
 
-mod consts;
 #[cfg(feature = "metadata-collector-lint")]
 mod deprecated_lints;
 mod utils;
diff --git a/clippy_lints/src/loops/while_immutable_condition.rs b/clippy_lints/src/loops/while_immutable_condition.rs
index 55404b87ec9..5f9ebad25e8 100644
--- a/clippy_lints/src/loops/while_immutable_condition.rs
+++ b/clippy_lints/src/loops/while_immutable_condition.rs
@@ -1,5 +1,5 @@
 use super::WHILE_IMMUTABLE_CONDITION;
-use crate::consts::constant;
+use clippy_utils::consts::constant;
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::usage::mutated_variables;
 use if_chain::if_chain;
diff --git a/clippy_lints/src/manual_strip.rs b/clippy_lints/src/manual_strip.rs
index 6a06090f6e2..61b5fe81fa9 100644
--- a/clippy_lints/src/manual_strip.rs
+++ b/clippy_lints/src/manual_strip.rs
@@ -1,4 +1,4 @@
-use crate::consts::{constant, Constant};
+use clippy_utils::consts::{constant, Constant};
 use clippy_utils::diagnostics::{multispan_sugg, span_lint_and_then};
 use clippy_utils::source::snippet;
 use clippy_utils::usage::mutated_variables;
diff --git a/clippy_lints/src/manual_unwrap_or.rs b/clippy_lints/src/manual_unwrap_or.rs
index 2f579edd6ad..18038dd7819 100644
--- a/clippy_lints/src/manual_unwrap_or.rs
+++ b/clippy_lints/src/manual_unwrap_or.rs
@@ -1,4 +1,4 @@
-use crate::consts::constant_simple;
+use clippy_utils::consts::constant_simple;
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::{indent_of, reindent_multiline, snippet_opt};
 use clippy_utils::ty::is_type_diagnostic_item;
diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index e07d8ea56e4..cd3e3b97928 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -1,4 +1,4 @@
-use crate::consts::{constant, miri_to_const, Constant};
+use clippy_utils::consts::{constant, miri_to_const, Constant};
 use clippy_utils::diagnostics::{
     multispan_sugg, span_lint_and_help, span_lint_and_note, span_lint_and_sugg, span_lint_and_then,
 };
diff --git a/clippy_lints/src/methods/iter_nth_zero.rs b/clippy_lints/src/methods/iter_nth_zero.rs
index 52d7c15332e..68d906c3ea3 100644
--- a/clippy_lints/src/methods/iter_nth_zero.rs
+++ b/clippy_lints/src/methods/iter_nth_zero.rs
@@ -1,4 +1,4 @@
-use crate::consts::{constant, Constant};
+use clippy_utils::consts::{constant, Constant};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::is_trait_method;
 use clippy_utils::source::snippet_with_applicability;
diff --git a/clippy_lints/src/methods/iterator_step_by_zero.rs b/clippy_lints/src/methods/iterator_step_by_zero.rs
index 06b12998b1a..64c09214a76 100644
--- a/clippy_lints/src/methods/iterator_step_by_zero.rs
+++ b/clippy_lints/src/methods/iterator_step_by_zero.rs
@@ -1,4 +1,4 @@
-use crate::consts::{constant, Constant};
+use clippy_utils::consts::{constant, Constant};
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::is_trait_method;
 use rustc_hir as hir;
diff --git a/clippy_lints/src/minmax.rs b/clippy_lints/src/minmax.rs
index 45948f4d926..ff3473b744e 100644
--- a/clippy_lints/src/minmax.rs
+++ b/clippy_lints/src/minmax.rs
@@ -1,4 +1,4 @@
-use crate::consts::{constant_simple, Constant};
+use clippy_utils::consts::{constant_simple, Constant};
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::{match_def_path, match_trait_method, paths};
 use if_chain::if_chain;
diff --git a/clippy_lints/src/misc.rs b/clippy_lints/src/misc.rs
index 5976b060ad2..804c04fe1b8 100644
--- a/clippy_lints/src/misc.rs
+++ b/clippy_lints/src/misc.rs
@@ -17,7 +17,7 @@ use rustc_span::hygiene::DesugaringKind;
 use rustc_span::source_map::{ExpnKind, Span};
 use rustc_span::symbol::sym;
 
-use crate::consts::{constant, Constant};
+use clippy_utils::consts::{constant, Constant};
 use clippy_utils::sugg::Sugg;
 use clippy_utils::{
     expr_path_res, get_item_name, get_parent_expr, higher, in_constant, is_diag_trait_item, is_integer_const,
diff --git a/clippy_lints/src/modulo_arithmetic.rs b/clippy_lints/src/modulo_arithmetic.rs
index 64e9dc85466..1414fdc1b11 100644
--- a/clippy_lints/src/modulo_arithmetic.rs
+++ b/clippy_lints/src/modulo_arithmetic.rs
@@ -1,4 +1,4 @@
-use crate::consts::{constant, Constant};
+use clippy_utils::consts::{constant, Constant};
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::sext;
 use if_chain::if_chain;
diff --git a/clippy_lints/src/neg_multiply.rs b/clippy_lints/src/neg_multiply.rs
index 34fd012572f..d5e1ea6d242 100644
--- a/clippy_lints/src/neg_multiply.rs
+++ b/clippy_lints/src/neg_multiply.rs
@@ -1,3 +1,4 @@
+use clippy_utils::consts::{self, Constant};
 use clippy_utils::diagnostics::span_lint;
 use if_chain::if_chain;
 use rustc_hir::{BinOpKind, Expr, ExprKind, UnOp};
@@ -5,8 +6,6 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
 
-use crate::consts::{self, Constant};
-
 declare_clippy_lint! {
     /// **What it does:** Checks for multiplication by -1 as a form of negation.
     ///
diff --git a/clippy_lints/src/ranges.rs b/clippy_lints/src/ranges.rs
index 7169f96eaf1..ae5f0627fd6 100644
--- a/clippy_lints/src/ranges.rs
+++ b/clippy_lints/src/ranges.rs
@@ -1,4 +1,4 @@
-use crate::consts::{constant, Constant};
+use clippy_utils::consts::{constant, Constant};
 use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::{snippet, snippet_opt, snippet_with_applicability};
 use clippy_utils::sugg::Sugg;
diff --git a/clippy_lints/src/regex.rs b/clippy_lints/src/regex.rs
index 4b5306de58e..75151167454 100644
--- a/clippy_lints/src/regex.rs
+++ b/clippy_lints/src/regex.rs
@@ -1,4 +1,4 @@
-use crate::consts::{constant, Constant};
+use clippy_utils::consts::{constant, Constant};
 use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
 use clippy_utils::{match_def_path, paths};
 use if_chain::if_chain;
diff --git a/clippy_lints/src/repeat_once.rs b/clippy_lints/src/repeat_once.rs
index 560a5e7c920..b479c40bca6 100644
--- a/clippy_lints/src/repeat_once.rs
+++ b/clippy_lints/src/repeat_once.rs
@@ -1,4 +1,4 @@
-use crate::consts::{constant_context, Constant};
+use clippy_utils::consts::{constant_context, Constant};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::in_macro;
 use clippy_utils::source::snippet;
diff --git a/clippy_lints/src/transmuting_null.rs b/clippy_lints/src/transmuting_null.rs
index 888ecab1046..b57d158293d 100644
--- a/clippy_lints/src/transmuting_null.rs
+++ b/clippy_lints/src/transmuting_null.rs
@@ -1,4 +1,4 @@
-use crate::consts::{constant_context, Constant};
+use clippy_utils::consts::{constant_context, Constant};
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::{is_expr_path_def_path, paths};
 use if_chain::if_chain;
diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs
index 2c73c3d929b..b1523e032af 100644
--- a/clippy_lints/src/utils/internal_lints.rs
+++ b/clippy_lints/src/utils/internal_lints.rs
@@ -1,4 +1,4 @@
-use crate::consts::{constant_simple, Constant};
+use clippy_utils::consts::{constant_simple, Constant};
 use clippy_utils::diagnostics::{span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::snippet;
 use clippy_utils::ty::match_type;
diff --git a/clippy_lints/src/vec.rs b/clippy_lints/src/vec.rs
index febd4b6ff7b..1d5b7c98d31 100644
--- a/clippy_lints/src/vec.rs
+++ b/clippy_lints/src/vec.rs
@@ -1,5 +1,5 @@
-use crate::consts::{constant, Constant};
 use crate::rustc_target::abi::LayoutOf;
+use clippy_utils::consts::{constant, Constant};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::higher;
 use clippy_utils::source::snippet_with_applicability;
diff --git a/clippy_lints/src/zero_div_zero.rs b/clippy_lints/src/zero_div_zero.rs
index 350b1cf25ff..a1ea743ba80 100644
--- a/clippy_lints/src/zero_div_zero.rs
+++ b/clippy_lints/src/zero_div_zero.rs
@@ -1,4 +1,4 @@
-use crate::consts::{constant_simple, Constant};
+use clippy_utils::consts::{constant_simple, Constant};
 use clippy_utils::diagnostics::span_lint_and_help;
 use if_chain::if_chain;
 use rustc_hir::{BinOpKind, Expr, ExprKind};
-- 
cgit 1.4.1-3-g733a5


From d3c20c835f63f1953c3940d9b1f9ce8a943a0bc8 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Thu, 27 May 2021 16:10:35 -0500
Subject: Some cleanup for use_self

---
 clippy_lints/src/use_self.rs | 178 +++++++++++++------------------------------
 1 file changed, 51 insertions(+), 127 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/use_self.rs b/clippy_lints/src/use_self.rs
index 254b104bdef..e79983134e4 100644
--- a/clippy_lints/src/use_self.rs
+++ b/clippy_lints/src/use_self.rs
@@ -1,23 +1,21 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::same_type_and_consts;
 use clippy_utils::{in_macro, meets_msrv, msrvs};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{
     self as hir,
-    def::{self, DefKind},
+    def::{CtorOf, DefKind, Res},
     def_id::LocalDefId,
     intravisit::{walk_ty, NestedVisitorMap, Visitor},
-    Expr, ExprKind, FnRetTy, FnSig, GenericArg, HirId, Impl, ImplItemKind, Item, ItemKind, Node, Path, PathSegment,
-    QPath, TyKind,
+    Expr, ExprKind, FnRetTy, FnSig, GenericArg, HirId, Impl, ImplItemKind, Item, ItemKind, Node, Path, QPath, TyKind,
 };
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::hir::map::Map;
 use rustc_middle::ty::{AssocKind, Ty};
 use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::{BytePos, Span};
+use rustc_span::Span;
 use rustc_typeck::hir_ty_to_ty;
 
 declare_clippy_lint! {
@@ -234,111 +232,58 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
     }
 
     fn check_ty(&mut self, cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>) {
-        if in_macro(hir_ty.span)
-            || in_impl(cx, hir_ty)
-            || !meets_msrv(self.msrv.as_ref(), &msrvs::TYPE_ALIAS_ENUM_VARIANTS)
-        {
-            return;
-        }
-
-        let lint_dependend_on_expr_kind = if let Some(StackItem::Check {
-            hir_id,
-            types_to_lint,
-            types_to_skip,
-            ..
-        }) = self.stack.last()
-        {
-            if types_to_skip.contains(&hir_ty.hir_id) {
-                false
-            } else if types_to_lint.contains(&hir_ty.hir_id) {
-                true
-            } else {
-                let self_ty = ty_from_hir_id(cx, *hir_id);
-                should_lint_ty(hir_ty, hir_ty_to_ty(cx.tcx, hir_ty), self_ty)
-            }
-        } else {
-            false
-        };
-
-        if lint_dependend_on_expr_kind {
-            // FIXME: this span manipulation should not be necessary
-            // @flip1995 found an ast lowering issue in
-            // https://github.com/rust-lang/rust/blob/master/src/librustc_ast_lowering/path.rs#l142-l162
+        if_chain! {
+            if !in_macro(hir_ty.span) && !in_impl(cx, hir_ty);
+            if meets_msrv(self.msrv.as_ref(), &msrvs::TYPE_ALIAS_ENUM_VARIANTS);
+            if let Some(StackItem::Check {
+                hir_id,
+                types_to_lint,
+                types_to_skip,
+                ..
+            }) = self.stack.last();
+            if !types_to_skip.contains(&hir_ty.hir_id);
+            if types_to_lint.contains(&hir_ty.hir_id)
+                || {
+                    let self_ty = ty_from_hir_id(cx, *hir_id);
+                    should_lint_ty(hir_ty, hir_ty_to_ty(cx.tcx, hir_ty), self_ty)
+                };
             let hir = cx.tcx.hir();
             let id = hir.get_parent_node(hir_ty.hir_id);
-
-            if !hir.opt_span(id).map_or(false, in_macro) {
-                match hir.find(id) {
-                    Some(Node::Expr(Expr {
-                        kind: ExprKind::Path(QPath::TypeRelative(_, segment)),
-                        ..
-                    })) => span_lint_until_last_segment(cx, hir_ty.span, segment),
-                    _ => span_lint(cx, hir_ty.span),
-                }
+            if !hir.opt_span(id).map_or(false, in_macro);
+            then {
+                span_lint(cx, hir_ty.span);
             }
         }
     }
 
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
-        fn expr_ty_matches(cx: &LateContext<'_>, expr: &Expr<'_>, self_ty: Ty<'_>) -> bool {
-            let def_id = expr.hir_id.owner;
-            if cx.tcx.has_typeck_results(def_id) {
-                cx.tcx.typeck(def_id).expr_ty_opt(expr) == Some(self_ty)
-            } else {
-                false
-            }
-        }
-
-        if in_macro(expr.span) || !meets_msrv(self.msrv.as_ref(), &msrvs::TYPE_ALIAS_ENUM_VARIANTS) {
-            return;
+        if_chain! {
+            if !in_macro(expr.span);
+            if meets_msrv(self.msrv.as_ref(), &msrvs::TYPE_ALIAS_ENUM_VARIANTS);
+            if let Some(StackItem::Check { hir_id, .. }) = self.stack.last();
+            if cx.typeck_results().expr_ty(expr) == ty_from_hir_id(cx, *hir_id);
+            then {} else { return; }
         }
-
-        if let Some(StackItem::Check { hir_id, .. }) = self.stack.last() {
-            let self_ty = ty_from_hir_id(cx, *hir_id);
-
-            match &expr.kind {
-                ExprKind::Struct(QPath::Resolved(_, path), ..) => {
-                    if expr_ty_matches(cx, expr, self_ty) {
-                        match path.res {
-                            def::Res::SelfTy(..) => (),
-                            def::Res::Def(DefKind::Variant, _) => span_lint_on_path_until_last_segment(cx, path),
-                            _ => {
-                                span_lint(cx, path.span);
-                            },
-                        }
-                    }
-                },
-                // tuple struct instantiation (`Foo(arg)` or `Enum::Foo(arg)`)
-                ExprKind::Call(fun, _) => {
-                    if let Expr {
-                        kind: ExprKind::Path(ref qpath),
-                        ..
-                    } = fun
-                    {
-                        if expr_ty_matches(cx, expr, self_ty) {
-                            let res = cx.qpath_res(qpath, fun.hir_id);
-
-                            if let def::Res::Def(DefKind::Ctor(ctor_of, _), ..) = res {
-                                match ctor_of {
-                                    def::CtorOf::Variant => {
-                                        span_lint_on_qpath_resolved(cx, qpath, true);
-                                    },
-                                    def::CtorOf::Struct => {
-                                        span_lint_on_qpath_resolved(cx, qpath, false);
-                                    },
-                                }
-                            }
+        match expr.kind {
+            ExprKind::Struct(QPath::Resolved(_, path), ..) => match path.res {
+                Res::SelfTy(..) => (),
+                Res::Def(DefKind::Variant, _) => lint_path_to_variant(cx, path),
+                _ => span_lint(cx, path.span),
+            },
+            // tuple struct instantiation (`Foo(arg)` or `Enum::Foo(arg)`)
+            ExprKind::Call(fun, _) => {
+                if let ExprKind::Path(QPath::Resolved(_, path)) = fun.kind {
+                    if let Res::Def(DefKind::Ctor(ctor_of, _), ..) = path.res {
+                        match ctor_of {
+                            CtorOf::Variant => lint_path_to_variant(cx, path),
+                            CtorOf::Struct => span_lint(cx, path.span),
                         }
                     }
-                },
-                // unit enum variants (`Enum::A`)
-                ExprKind::Path(qpath) => {
-                    if expr_ty_matches(cx, expr, self_ty) {
-                        span_lint_on_qpath_resolved(cx, qpath, true);
-                    }
-                },
-                _ => (),
-            }
+                }
+            },
+            // unit enum variants (`Enum::A`)
+            ExprKind::Path(QPath::Resolved(_, path)) => lint_path_to_variant(cx, path),
+            _ => (),
         }
     }
 
@@ -405,33 +350,12 @@ fn span_lint(cx: &LateContext<'_>, span: Span) {
     );
 }
 
-#[allow(clippy::cast_possible_truncation)]
-fn span_lint_until_last_segment(cx: &LateContext<'_>, span: Span, segment: &PathSegment<'_>) {
-    let sp = span.with_hi(segment.ident.span.lo());
-    // remove the trailing ::
-    let span_without_last_segment = match snippet_opt(cx, sp) {
-        Some(snippet) => match snippet.rfind("::") {
-            Some(bidx) => sp.with_hi(sp.lo() + BytePos(bidx as u32)),
-            None => sp,
-        },
-        None => sp,
-    };
-    span_lint(cx, span_without_last_segment);
-}
-
-fn span_lint_on_path_until_last_segment(cx: &LateContext<'_>, path: &Path<'_>) {
-    if path.segments.len() > 1 {
-        span_lint_until_last_segment(cx, path.span, path.segments.last().unwrap());
-    }
-}
-
-fn span_lint_on_qpath_resolved(cx: &LateContext<'_>, qpath: &QPath<'_>, until_last_segment: bool) {
-    if let QPath::Resolved(_, path) = qpath {
-        if until_last_segment {
-            span_lint_on_path_until_last_segment(cx, path);
-        } else {
-            span_lint(cx, path.span);
-        }
+fn lint_path_to_variant(cx: &LateContext<'_>, path: &Path<'_>) {
+    if let [.., self_seg, _variant] = path.segments {
+        let span = path
+            .span
+            .with_hi(self_seg.args().span_ext().unwrap_or(self_seg.ident.span).hi());
+        span_lint(cx, span);
     }
 }
 
-- 
cgit 1.4.1-3-g733a5


From 29b4b4c10d89b2278485ac0e24a393ef58290672 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Thu, 27 May 2021 16:25:37 -0500
Subject: Do not lint use_self on type parameters

---
 clippy_lints/src/use_self.rs |  2 +-
 tests/ui/use_self.fixed      | 23 +++++++++++++++++++++++
 tests/ui/use_self.rs         | 25 ++++++++++++++++++++++++-
 tests/ui/use_self.stderr     |  4 ++--
 4 files changed, 50 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/use_self.rs b/clippy_lints/src/use_self.rs
index e79983134e4..f71dfd02499 100644
--- a/clippy_lints/src/use_self.rs
+++ b/clippy_lints/src/use_self.rs
@@ -386,7 +386,7 @@ fn should_lint_ty(hir_ty: &hir::Ty<'_>, ty: Ty<'_>, self_ty: Ty<'_>) -> bool {
         if same_type_and_consts(ty, self_ty);
         if let TyKind::Path(QPath::Resolved(_, path)) = hir_ty.kind;
         then {
-            !matches!(path.res, def::Res::SelfTy(..))
+            !matches!(path.res, Res::SelfTy(..) | Res::Def(DefKind::TyParam, _))
         } else {
             false
         }
diff --git a/tests/ui/use_self.fixed b/tests/ui/use_self.fixed
index 631da6fe066..e2c28542efc 100644
--- a/tests/ui/use_self.fixed
+++ b/tests/ui/use_self.fixed
@@ -492,3 +492,26 @@ mod issue7206 {
         }
     }
 }
+
+mod self_is_ty_param {
+    trait Trait {
+        type Type;
+        type Hi;
+
+        fn test();
+    }
+
+    impl<I> Trait for I
+    where
+        I: Iterator,
+        I::Item: Trait, // changing this to Self would require <Self as Iterator>
+    {
+        type Type = I;
+        type Hi = I::Item;
+
+        fn test() {
+            let _: I::Item;
+            let _: I; // this could lint, but is questionable
+        }
+    }
+}
diff --git a/tests/ui/use_self.rs b/tests/ui/use_self.rs
index 7a10d755faa..3cd99b9f5cd 100644
--- a/tests/ui/use_self.rs
+++ b/tests/ui/use_self.rs
@@ -279,7 +279,7 @@ mod generics {
     impl<T> Foo<T> {
         // `Self` is applicable here
         fn foo(value: T) -> Foo<T> {
-            Foo { value }
+            Foo::<T> { value }
         }
 
         // `Cannot` use `Self` as a return type as the generic types are different
@@ -492,3 +492,26 @@ mod issue7206 {
         }
     }
 }
+
+mod self_is_ty_param {
+    trait Trait {
+        type Type;
+        type Hi;
+
+        fn test();
+    }
+
+    impl<I> Trait for I
+    where
+        I: Iterator,
+        I::Item: Trait, // changing this to Self would require <Self as Iterator>
+    {
+        type Type = I;
+        type Hi = I::Item;
+
+        fn test() {
+            let _: I::Item;
+            let _: I; // this could lint, but is questionable
+        }
+    }
+}
diff --git a/tests/ui/use_self.stderr b/tests/ui/use_self.stderr
index cf6222c9b45..6ac26c9e5a9 100644
--- a/tests/ui/use_self.stderr
+++ b/tests/ui/use_self.stderr
@@ -153,8 +153,8 @@ LL |         fn foo(value: T) -> Foo<T> {
 error: unnecessary structure name repetition
   --> $DIR/use_self.rs:282:13
    |
-LL |             Foo { value }
-   |             ^^^ help: use the applicable keyword: `Self`
+LL |             Foo::<T> { value }
+   |             ^^^^^^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
   --> $DIR/use_self.rs:454:13
-- 
cgit 1.4.1-3-g733a5


From 6c1ba7c1bc1a1113b68c7100894f33f2fb5f7ebf Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Thu, 27 May 2021 20:39:20 -0500
Subject: Fix needless_collect with binding shadowing

---
 clippy_lints/src/loops/needless_collect.rs | 79 +++++++++++++-----------------
 1 file changed, 35 insertions(+), 44 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/needless_collect.rs b/clippy_lints/src/loops/needless_collect.rs
index eb82c9c27c3..b3992157cd4 100644
--- a/clippy_lints/src/loops/needless_collect.rs
+++ b/clippy_lints/src/loops/needless_collect.rs
@@ -7,10 +7,10 @@ use clippy_utils::{is_trait_method, path_to_local_id};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_block, walk_expr, NestedVisitorMap, Visitor};
-use rustc_hir::{Block, Expr, ExprKind, GenericArg, GenericArgs, HirId, Local, Pat, PatKind, QPath, StmtKind, Ty};
+use rustc_hir::{Block, Expr, ExprKind, GenericArg, GenericArgs, HirId, PatKind, StmtKind, Ty};
 use rustc_lint::LateContext;
 use rustc_middle::hir::map::Map;
-use rustc_span::symbol::{sym, Ident};
+use rustc_span::sym;
 use rustc_span::{MultiSpan, Span};
 
 const NEEDLESS_COLLECT_MSG: &str = "avoid using `collect()` when not needed";
@@ -88,24 +88,23 @@ fn check_needless_collect_indirect_usage<'tcx>(expr: &'tcx Expr<'_>, cx: &LateCo
     if let ExprKind::Block(block, _) = expr.kind {
         for stmt in block.stmts {
             if_chain! {
-                if let StmtKind::Local(
-                    Local { pat: Pat { hir_id: pat_id, kind: PatKind::Binding(_, _, ident, .. ), .. },
-                    init: Some(init_expr), ty, .. }
-                ) = stmt.kind;
+                if let StmtKind::Local(local) = stmt.kind;
+                if let PatKind::Binding(_, id, ..) = local.pat.kind;
+                if let Some(init_expr) = local.init;
                 if let ExprKind::MethodCall(method_name, collect_span, &[ref iter_source], ..) = init_expr.kind;
                 if method_name.ident.name == sym!(collect) && is_trait_method(cx, init_expr, sym::Iterator);
-                if let Some(hir_id) = get_hir_id(*ty, method_name.args);
+                if let Some(hir_id) = get_hir_id(local.ty, method_name.args);
                 if let Some(ty) = cx.typeck_results().node_type_opt(hir_id);
                 if is_type_diagnostic_item(cx, ty, sym::vec_type) ||
                     is_type_diagnostic_item(cx, ty, sym::vecdeque_type) ||
                     is_type_diagnostic_item(cx, ty, sym::BinaryHeap) ||
                     is_type_diagnostic_item(cx, ty, sym::LinkedList);
-                if let Some(iter_calls) = detect_iter_and_into_iters(block, *ident);
+                if let Some(iter_calls) = detect_iter_and_into_iters(block, id);
                 if let [iter_call] = &*iter_calls;
                 then {
                     let mut used_count_visitor = UsedCountVisitor {
                         cx,
-                        id: *pat_id,
+                        id,
                         count: 0,
                     };
                     walk_block(&mut used_count_visitor, block);
@@ -187,48 +186,40 @@ enum IterFunctionKind {
 struct IterFunctionVisitor {
     uses: Vec<IterFunction>,
     seen_other: bool,
-    target: Ident,
+    target: HirId,
 }
 impl<'tcx> Visitor<'tcx> for IterFunctionVisitor {
     fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) {
         // Check function calls on our collection
-        if_chain! {
-            if let ExprKind::MethodCall(method_name, _, args, _) = &expr.kind;
-            if let Some(Expr { kind: ExprKind::Path(QPath::Resolved(_, path)), .. }) = args.get(0);
-            if let &[name] = &path.segments;
-            if name.ident == self.target;
-            then {
-                let len = sym!(len);
-                let is_empty = sym!(is_empty);
-                let contains = sym!(contains);
-                match method_name.ident.name {
-                    sym::into_iter => self.uses.push(
-                        IterFunction { func: IterFunctionKind::IntoIter, span: expr.span }
-                    ),
-                    name if name == len => self.uses.push(
-                        IterFunction { func: IterFunctionKind::Len, span: expr.span }
-                    ),
-                    name if name == is_empty => self.uses.push(
-                        IterFunction { func: IterFunctionKind::IsEmpty, span: expr.span }
-                    ),
-                    name if name == contains => self.uses.push(
-                        IterFunction { func: IterFunctionKind::Contains(args[1].span), span: expr.span }
-                    ),
+        if let ExprKind::MethodCall(method_name, _, [recv, args @ ..], _) = &expr.kind {
+            if path_to_local_id(recv, self.target) {
+                match &*method_name.ident.name.as_str() {
+                    "into_iter" => self.uses.push(IterFunction {
+                        func: IterFunctionKind::IntoIter,
+                        span: expr.span,
+                    }),
+                    "len" => self.uses.push(IterFunction {
+                        func: IterFunctionKind::Len,
+                        span: expr.span,
+                    }),
+                    "is_empty" => self.uses.push(IterFunction {
+                        func: IterFunctionKind::IsEmpty,
+                        span: expr.span,
+                    }),
+                    "contains" => self.uses.push(IterFunction {
+                        func: IterFunctionKind::Contains(args[0].span),
+                        span: expr.span,
+                    }),
                     _ => self.seen_other = true,
                 }
-                return
+                return;
             }
         }
         // Check if the collection is used for anything else
-        if_chain! {
-            if let Expr { kind: ExprKind::Path(QPath::Resolved(_, path)), .. } = expr;
-            if let &[name] = &path.segments;
-            if name.ident == self.target;
-            then {
-                self.seen_other = true;
-            } else {
-                walk_expr(self, expr);
-            }
+        if path_to_local_id(expr, self.target) {
+            self.seen_other = true;
+        } else {
+            walk_expr(self, expr);
         }
     }
 
@@ -262,10 +253,10 @@ impl<'a, 'tcx> Visitor<'tcx> for UsedCountVisitor<'a, 'tcx> {
 
 /// Detect the occurrences of calls to `iter` or `into_iter` for the
 /// given identifier
-fn detect_iter_and_into_iters<'tcx>(block: &'tcx Block<'tcx>, identifier: Ident) -> Option<Vec<IterFunction>> {
+fn detect_iter_and_into_iters<'tcx>(block: &'tcx Block<'tcx>, id: HirId) -> Option<Vec<IterFunction>> {
     let mut visitor = IterFunctionVisitor {
         uses: Vec::new(),
-        target: identifier,
+        target: id,
         seen_other: false,
     };
     visitor.visit_block(block);
-- 
cgit 1.4.1-3-g733a5


From 21c829e0c81697bbace7c325b47856d32fad33df Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Thu, 27 May 2021 20:54:56 -0500
Subject: Simplify collect expr_ty

---
 clippy_lints/src/loops/needless_collect.rs | 22 +++-------------------
 1 file changed, 3 insertions(+), 19 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/needless_collect.rs b/clippy_lints/src/loops/needless_collect.rs
index b3992157cd4..51d7def137e 100644
--- a/clippy_lints/src/loops/needless_collect.rs
+++ b/clippy_lints/src/loops/needless_collect.rs
@@ -7,7 +7,7 @@ use clippy_utils::{is_trait_method, path_to_local_id};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_block, walk_expr, NestedVisitorMap, Visitor};
-use rustc_hir::{Block, Expr, ExprKind, GenericArg, GenericArgs, HirId, PatKind, StmtKind, Ty};
+use rustc_hir::{Block, Expr, ExprKind, HirId, PatKind, StmtKind};
 use rustc_lint::LateContext;
 use rustc_middle::hir::map::Map;
 use rustc_span::sym;
@@ -24,10 +24,8 @@ fn check_needless_collect_direct_usage<'tcx>(expr: &'tcx Expr<'_>, cx: &LateCont
         if let ExprKind::MethodCall(method, _, args, _) = expr.kind;
         if let ExprKind::MethodCall(chain_method, method0_span, _, _) = args[0].kind;
         if chain_method.ident.name == sym!(collect) && is_trait_method(cx, &args[0], sym::Iterator);
-        if let Some(generic_args) = chain_method.args;
-        if let Some(GenericArg::Type(ref ty)) = generic_args.args.get(0);
-        if let Some(ty) = cx.typeck_results().node_type_opt(ty.hir_id);
         then {
+            let ty = cx.typeck_results().expr_ty(&args[0]);
             let mut applicability = Applicability::MachineApplicable;
             let is_empty_sugg = "next().is_none()".to_string();
             let method_name = &*method.ident.name.as_str();
@@ -72,19 +70,6 @@ fn check_needless_collect_direct_usage<'tcx>(expr: &'tcx Expr<'_>, cx: &LateCont
 }
 
 fn check_needless_collect_indirect_usage<'tcx>(expr: &'tcx Expr<'_>, cx: &LateContext<'tcx>) {
-    fn get_hir_id<'tcx>(ty: Option<&Ty<'tcx>>, method_args: Option<&GenericArgs<'tcx>>) -> Option<HirId> {
-        if let Some(ty) = ty {
-            return Some(ty.hir_id);
-        }
-
-        if let Some(generic_args) = method_args {
-            if let Some(GenericArg::Type(ref ty)) = generic_args.args.get(0) {
-                return Some(ty.hir_id);
-            }
-        }
-
-        None
-    }
     if let ExprKind::Block(block, _) = expr.kind {
         for stmt in block.stmts {
             if_chain! {
@@ -93,8 +78,7 @@ fn check_needless_collect_indirect_usage<'tcx>(expr: &'tcx Expr<'_>, cx: &LateCo
                 if let Some(init_expr) = local.init;
                 if let ExprKind::MethodCall(method_name, collect_span, &[ref iter_source], ..) = init_expr.kind;
                 if method_name.ident.name == sym!(collect) && is_trait_method(cx, init_expr, sym::Iterator);
-                if let Some(hir_id) = get_hir_id(local.ty, method_name.args);
-                if let Some(ty) = cx.typeck_results().node_type_opt(hir_id);
+                let ty = cx.typeck_results().expr_ty(init_expr);
                 if is_type_diagnostic_item(cx, ty, sym::vec_type) ||
                     is_type_diagnostic_item(cx, ty, sym::vecdeque_type) ||
                     is_type_diagnostic_item(cx, ty, sym::BinaryHeap) ||
-- 
cgit 1.4.1-3-g733a5


From 4ba6afd1922b679eb533b8523f6e47a0da152afb Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Thu, 27 May 2021 15:16:26 -0400
Subject: Fix ICE in `too_many_lines` due to wrong assumptions on braces.

---
 clippy_lints/src/functions/too_many_lines.rs | 22 ++++++++++++++++------
 tests/ui/crashes/auxiliary/ice-7272-aux.rs   | 14 ++++++++++++++
 tests/ui/crashes/ice-7272.rs                 | 12 ++++++++++++
 3 files changed, 42 insertions(+), 6 deletions(-)
 create mode 100644 tests/ui/crashes/auxiliary/ice-7272-aux.rs
 create mode 100644 tests/ui/crashes/ice-7272.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/functions/too_many_lines.rs b/clippy_lints/src/functions/too_many_lines.rs
index c02c343dc58..a666fee1a4a 100644
--- a/clippy_lints/src/functions/too_many_lines.rs
+++ b/clippy_lints/src/functions/too_many_lines.rs
@@ -4,7 +4,7 @@ use rustc_middle::lint::in_external_macro;
 use rustc_span::Span;
 
 use clippy_utils::diagnostics::span_lint;
-use clippy_utils::source::snippet;
+use clippy_utils::source::snippet_opt;
 
 use super::TOO_MANY_LINES;
 
@@ -13,15 +13,25 @@ pub(super) fn check_fn(cx: &LateContext<'_>, span: Span, body: &'tcx hir::Body<'
         return;
     }
 
-    let code_snippet = snippet(cx, body.value.span, "..");
+    let code_snippet = match snippet_opt(cx, body.value.span) {
+        Some(s) => s,
+        _ => return,
+    };
     let mut line_count: u64 = 0;
     let mut in_comment = false;
     let mut code_in_line;
 
-    // Skip the surrounding function decl.
-    let start_brace_idx = code_snippet.find('{').map_or(0, |i| i + 1);
-    let end_brace_idx = code_snippet.rfind('}').unwrap_or_else(|| code_snippet.len());
-    let function_lines = code_snippet[start_brace_idx..end_brace_idx].lines();
+    let function_lines = if matches!(body.value.kind, hir::ExprKind::Block(..))
+        && code_snippet.as_bytes().first().copied() == Some(b'{')
+        && code_snippet.as_bytes().last().copied() == Some(b'}')
+    {
+        // Removing the braces from the enclosing block
+        &code_snippet[1..code_snippet.len() - 1]
+    } else {
+        &code_snippet
+    }
+    .trim() // Remove leading and trailing blank lines
+    .lines();
 
     for mut line in function_lines {
         code_in_line = false;
diff --git a/tests/ui/crashes/auxiliary/ice-7272-aux.rs b/tests/ui/crashes/auxiliary/ice-7272-aux.rs
new file mode 100644
index 00000000000..780797e3c6a
--- /dev/null
+++ b/tests/ui/crashes/auxiliary/ice-7272-aux.rs
@@ -0,0 +1,14 @@
+pub fn warn<T>(_: T) {}
+
+macro_rules! define_macro {
+    ($d:tt $lower:ident $upper:ident) => {
+        #[macro_export]
+        macro_rules! $upper {
+            ($arg:tt) => {
+                $crate::$lower($arg)
+            };
+        }
+    };
+}
+
+define_macro! {$ warn  WARNING}
diff --git a/tests/ui/crashes/ice-7272.rs b/tests/ui/crashes/ice-7272.rs
new file mode 100644
index 00000000000..57ab6ca14f8
--- /dev/null
+++ b/tests/ui/crashes/ice-7272.rs
@@ -0,0 +1,12 @@
+// aux-build:ice-7272-aux.rs
+
+#![allow(clippy::no_effect)]
+
+extern crate ice_7272_aux;
+
+use ice_7272_aux::*;
+
+pub fn main() {
+    || WARNING!("Style changed!");
+    || "}{";
+}
-- 
cgit 1.4.1-3-g733a5


From 898b6a0e072c4f8ba741e83bd7fd12a4c2ccb1a2 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sun, 30 May 2021 09:35:06 -0400
Subject: Add lint `suspicious_splitn`

---
 CHANGELOG.md                                  |  1 +
 clippy_lints/src/lib.rs                       |  3 ++
 clippy_lints/src/methods/mod.rs               | 36 +++++++++++++++-
 clippy_lints/src/methods/suspicious_splitn.rs | 52 +++++++++++++++++++++++
 tests/ui/single_char_pattern.fixed            |  4 +-
 tests/ui/single_char_pattern.rs               |  4 +-
 tests/ui/single_char_pattern.stderr           |  4 +-
 tests/ui/suspicious_splitn.rs                 | 16 ++++++++
 tests/ui/suspicious_splitn.stderr             | 59 +++++++++++++++++++++++++++
 9 files changed, 172 insertions(+), 7 deletions(-)
 create mode 100644 clippy_lints/src/methods/suspicious_splitn.rs
 create mode 100644 tests/ui/suspicious_splitn.rs
 create mode 100644 tests/ui/suspicious_splitn.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index abfe7f91f4b..59daa074282 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2671,6 +2671,7 @@ Released 2018-09-13
 [`suspicious_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_map
 [`suspicious_op_assign_impl`]: https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_op_assign_impl
 [`suspicious_operation_groupings`]: https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_operation_groupings
+[`suspicious_splitn`]: https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_splitn
 [`suspicious_unary_op_formatting`]: https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_unary_op_formatting
 [`tabs_in_doc_comments`]: https://rust-lang.github.io/rust-clippy/master/index.html#tabs_in_doc_comments
 [`temporary_assignment`]: https://rust-lang.github.io/rust-clippy/master/index.html#temporary_assignment
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 4c9c44f55d1..0e815be9bd5 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -779,6 +779,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         methods::SKIP_WHILE_NEXT,
         methods::STRING_EXTEND_CHARS,
         methods::SUSPICIOUS_MAP,
+        methods::SUSPICIOUS_SPLITN,
         methods::UNINIT_ASSUMED_INIT,
         methods::UNNECESSARY_FILTER_MAP,
         methods::UNNECESSARY_FOLD,
@@ -1312,6 +1313,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(methods::SKIP_WHILE_NEXT),
         LintId::of(methods::STRING_EXTEND_CHARS),
         LintId::of(methods::SUSPICIOUS_MAP),
+        LintId::of(methods::SUSPICIOUS_SPLITN),
         LintId::of(methods::UNINIT_ASSUMED_INIT),
         LintId::of(methods::UNNECESSARY_FILTER_MAP),
         LintId::of(methods::UNNECESSARY_FOLD),
@@ -1688,6 +1690,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(mem_replace::MEM_REPLACE_WITH_UNINIT),
         LintId::of(methods::CLONE_DOUBLE_REF),
         LintId::of(methods::ITERATOR_STEP_BY_ZERO),
+        LintId::of(methods::SUSPICIOUS_SPLITN),
         LintId::of(methods::UNINIT_ASSUMED_INIT),
         LintId::of(methods::ZST_OFFSET),
         LintId::of(minmax::MIN_MAX),
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 0b998dbf86c..3904572c627 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -48,6 +48,7 @@ mod single_char_push_string;
 mod skip_while_next;
 mod string_extend_chars;
 mod suspicious_map;
+mod suspicious_splitn;
 mod uninit_assumed_init;
 mod unnecessary_filter_map;
 mod unnecessary_fold;
@@ -1633,6 +1634,35 @@ declare_clippy_lint! {
     "replace `.iter().count()` with `.len()`"
 }
 
+declare_clippy_lint! {
+    /// **What it does:** Checks for calls to `splitn` and related functions with
+    /// either zero or one splits.
+    ///
+    /// **Why is this bad?** These calls don't actually split the value and are
+    /// likely to be intended as a different number.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// // Bad
+    /// let s = "";
+    /// for x in s.splitn(1, ":") {
+    ///     // use x
+    /// }
+    ///
+    /// // Good
+    /// let s = "";
+    /// for x in s.splitn(2, ":") {
+    ///     // use x
+    /// }
+    /// ```
+    pub SUSPICIOUS_SPLITN,
+    correctness,
+    "checks for `.splitn(0, ..)` and `.splitn(1, ..)`"
+}
+
 pub struct Methods {
     avoid_breaking_exported_api: bool,
     msrv: Option<RustcVersion>,
@@ -1705,7 +1735,8 @@ impl_lint_pass!(Methods => [
     MAP_COLLECT_RESULT_UNIT,
     FROM_ITER_INSTEAD_OF_COLLECT,
     INSPECT_FOR_EACH,
-    IMPLICIT_CLONE
+    IMPLICIT_CLONE,
+    SUSPICIOUS_SPLITN
 ]);
 
 /// Extracts a method call name, args, and `Span` of the method name.
@@ -2024,6 +2055,9 @@ fn check_methods<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, msrv: Optio
                     unnecessary_lazy_eval::check(cx, expr, recv, arg, "or");
                 }
             },
+            ("splitn" | "splitn_mut" | "rsplitn" | "rsplitn_mut", [count_arg, _]) => {
+                suspicious_splitn::check(cx, name, expr, recv, count_arg);
+            },
             ("step_by", [arg]) => iterator_step_by_zero::check(cx, expr, arg),
             ("to_os_string" | "to_owned" | "to_path_buf" | "to_vec", []) => {
                 implicit_clone::check(cx, name, expr, recv, span);
diff --git a/clippy_lints/src/methods/suspicious_splitn.rs b/clippy_lints/src/methods/suspicious_splitn.rs
new file mode 100644
index 00000000000..43affe20dc5
--- /dev/null
+++ b/clippy_lints/src/methods/suspicious_splitn.rs
@@ -0,0 +1,52 @@
+use clippy_utils::diagnostics::span_lint_and_note;
+use if_chain::if_chain;
+use rustc_ast::LitKind;
+use rustc_hir::{Expr, ExprKind};
+use rustc_lint::LateContext;
+use rustc_span::source_map::Spanned;
+
+use super::SUSPICIOUS_SPLITN;
+
+pub(super) fn check(
+    cx: &LateContext<'_>,
+    method_name: &str,
+    expr: &Expr<'_>,
+    self_arg: &Expr<'_>,
+    count_arg: &Expr<'_>,
+) {
+    if_chain! {
+        // Ignore empty slice literal
+        if !matches!(self_arg.kind, ExprKind::Array([]));
+        // Ignore empty string literal
+        if !matches!(self_arg.kind, ExprKind::Lit(Spanned { node: LitKind::Str(s, _), .. }) if s.is_empty());
+        if let ExprKind::Lit(count_lit) = &count_arg.kind;
+        if let LitKind::Int(count, _) = count_lit.node;
+        if count <= 1;
+        if let Some(call_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
+        if let Some(impl_id) = cx.tcx.impl_of_method(call_id);
+        let lang_items = cx.tcx.lang_items();
+        if lang_items.slice_impl() == Some(impl_id) || lang_items.str_impl() == Some(impl_id);
+        then {
+            let (msg, note_msg) = if count == 0 {
+                (format!("`{}` called with `0` splits", method_name),
+                "the resulting iterator will always return `None`")
+            } else {
+                (format!("`{}` called with `1` split", method_name),
+                if lang_items.slice_impl() == Some(impl_id) {
+                    "the resulting iterator will always return the entire slice followed by `None`"
+                } else {
+                    "the resulting iterator will always return the entire string followed by `None`"
+                })
+            };
+
+            span_lint_and_note(
+                cx,
+                SUSPICIOUS_SPLITN,
+                expr.span,
+                &msg,
+                None,
+                note_msg,
+            );
+        }
+    }
+}
diff --git a/tests/ui/single_char_pattern.fixed b/tests/ui/single_char_pattern.fixed
index fcbe9af9f56..1abd2b7883d 100644
--- a/tests/ui/single_char_pattern.fixed
+++ b/tests/ui/single_char_pattern.fixed
@@ -25,8 +25,8 @@ fn main() {
     x.rsplit('x');
     x.split_terminator('x');
     x.rsplit_terminator('x');
-    x.splitn(0, 'x');
-    x.rsplitn(0, 'x');
+    x.splitn(2, 'x');
+    x.rsplitn(2, 'x');
     x.matches('x');
     x.rmatches('x');
     x.match_indices('x');
diff --git a/tests/ui/single_char_pattern.rs b/tests/ui/single_char_pattern.rs
index b8bc20f4070..e662bf34be2 100644
--- a/tests/ui/single_char_pattern.rs
+++ b/tests/ui/single_char_pattern.rs
@@ -25,8 +25,8 @@ fn main() {
     x.rsplit("x");
     x.split_terminator("x");
     x.rsplit_terminator("x");
-    x.splitn(0, "x");
-    x.rsplitn(0, "x");
+    x.splitn(2, "x");
+    x.rsplitn(2, "x");
     x.matches("x");
     x.rmatches("x");
     x.match_indices("x");
diff --git a/tests/ui/single_char_pattern.stderr b/tests/ui/single_char_pattern.stderr
index 6d94d8a34e3..22d4b2d460f 100644
--- a/tests/ui/single_char_pattern.stderr
+++ b/tests/ui/single_char_pattern.stderr
@@ -75,13 +75,13 @@ LL |     x.rsplit_terminator("x");
 error: single-character string constant used as pattern
   --> $DIR/single_char_pattern.rs:28:17
    |
-LL |     x.splitn(0, "x");
+LL |     x.splitn(2, "x");
    |                 ^^^ help: try using a `char` instead: `'x'`
 
 error: single-character string constant used as pattern
   --> $DIR/single_char_pattern.rs:29:18
    |
-LL |     x.rsplitn(0, "x");
+LL |     x.rsplitn(2, "x");
    |                  ^^^ help: try using a `char` instead: `'x'`
 
 error: single-character string constant used as pattern
diff --git a/tests/ui/suspicious_splitn.rs b/tests/ui/suspicious_splitn.rs
new file mode 100644
index 00000000000..a944aa79cfe
--- /dev/null
+++ b/tests/ui/suspicious_splitn.rs
@@ -0,0 +1,16 @@
+#![warn(clippy::suspicious_splitn)]
+
+fn main() {
+    let _ = "a,b,c".splitn(3, ',');
+    let _ = [0, 1, 2, 1, 3].splitn(3, |&x| x == 1);
+    let _ = "".splitn(0, ',');
+    let _ = [].splitn(0, |&x: &u32| x == 1);
+
+    let _ = "a,b".splitn(0, ',');
+    let _ = "a,b".rsplitn(0, ',');
+    let _ = "a,b".splitn(1, ',');
+    let _ = [0, 1, 2].splitn(0, |&x| x == 1);
+    let _ = [0, 1, 2].splitn_mut(0, |&x| x == 1);
+    let _ = [0, 1, 2].splitn(1, |&x| x == 1);
+    let _ = [0, 1, 2].rsplitn_mut(1, |&x| x == 1);
+}
diff --git a/tests/ui/suspicious_splitn.stderr b/tests/ui/suspicious_splitn.stderr
new file mode 100644
index 00000000000..2e4bfe93b94
--- /dev/null
+++ b/tests/ui/suspicious_splitn.stderr
@@ -0,0 +1,59 @@
+error: `splitn` called with `0` splits
+  --> $DIR/suspicious_splitn.rs:9:13
+   |
+LL |     let _ = "a,b".splitn(0, ',');
+   |             ^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::suspicious-splitn` implied by `-D warnings`
+   = note: the resulting iterator will always return `None`
+
+error: `rsplitn` called with `0` splits
+  --> $DIR/suspicious_splitn.rs:10:13
+   |
+LL |     let _ = "a,b".rsplitn(0, ',');
+   |             ^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: the resulting iterator will always return `None`
+
+error: `splitn` called with `1` split
+  --> $DIR/suspicious_splitn.rs:11:13
+   |
+LL |     let _ = "a,b".splitn(1, ',');
+   |             ^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: the resulting iterator will always return the entire string followed by `None`
+
+error: `splitn` called with `0` splits
+  --> $DIR/suspicious_splitn.rs:12:13
+   |
+LL |     let _ = [0, 1, 2].splitn(0, |&x| x == 1);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: the resulting iterator will always return `None`
+
+error: `splitn_mut` called with `0` splits
+  --> $DIR/suspicious_splitn.rs:13:13
+   |
+LL |     let _ = [0, 1, 2].splitn_mut(0, |&x| x == 1);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: the resulting iterator will always return `None`
+
+error: `splitn` called with `1` split
+  --> $DIR/suspicious_splitn.rs:14:13
+   |
+LL |     let _ = [0, 1, 2].splitn(1, |&x| x == 1);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: the resulting iterator will always return the entire slice followed by `None`
+
+error: `rsplitn_mut` called with `1` split
+  --> $DIR/suspicious_splitn.rs:15:13
+   |
+LL |     let _ = [0, 1, 2].rsplitn_mut(1, |&x| x == 1);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: the resulting iterator will always return the entire slice followed by `None`
+
+error: aborting due to 7 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 5fa08eaf53f0c895e73f4841c240389fda951554 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sun, 30 May 2021 13:25:24 -0400
Subject: Evaluate constant expressions in `suspicious_splitn`

---
 clippy_lints/src/methods/mod.rs               |  5 +++--
 clippy_lints/src/methods/suspicious_splitn.rs | 16 ++++++++++------
 tests/ui/suspicious_splitn.rs                 |  4 ++++
 tests/ui/suspicious_splitn.stderr             | 18 +++++++++++++++++-
 4 files changed, 34 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 3904572c627..a6e2e0baadb 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1635,8 +1635,9 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for calls to `splitn` and related functions with
-    /// either zero or one splits.
+    /// **What it does:** Checks for calls to [`splitn`]
+    /// (https://doc.rust-lang.org/std/primitive.str.html#method.splitn) and
+    /// related functions with either zero or one splits.
     ///
     /// **Why is this bad?** These calls don't actually split the value and are
     /// likely to be intended as a different number.
diff --git a/clippy_lints/src/methods/suspicious_splitn.rs b/clippy_lints/src/methods/suspicious_splitn.rs
index 43affe20dc5..a271df60572 100644
--- a/clippy_lints/src/methods/suspicious_splitn.rs
+++ b/clippy_lints/src/methods/suspicious_splitn.rs
@@ -1,3 +1,4 @@
+use clippy_utils::consts::{constant, Constant};
 use clippy_utils::diagnostics::span_lint_and_note;
 use if_chain::if_chain;
 use rustc_ast::LitKind;
@@ -15,18 +16,21 @@ pub(super) fn check(
     count_arg: &Expr<'_>,
 ) {
     if_chain! {
-        // Ignore empty slice literal
-        if !matches!(self_arg.kind, ExprKind::Array([]));
-        // Ignore empty string literal
-        if !matches!(self_arg.kind, ExprKind::Lit(Spanned { node: LitKind::Str(s, _), .. }) if s.is_empty());
-        if let ExprKind::Lit(count_lit) = &count_arg.kind;
-        if let LitKind::Int(count, _) = count_lit.node;
+        if let Some((Constant::Int(count), _)) = constant(cx, cx.typeck_results(), count_arg);
         if count <= 1;
         if let Some(call_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
         if let Some(impl_id) = cx.tcx.impl_of_method(call_id);
         let lang_items = cx.tcx.lang_items();
         if lang_items.slice_impl() == Some(impl_id) || lang_items.str_impl() == Some(impl_id);
         then {
+            // Ignore empty slice and string literals when used with a literal count.
+            if (matches!(self_arg.kind, ExprKind::Array([]))
+                || matches!(self_arg.kind, ExprKind::Lit(Spanned { node: LitKind::Str(s, _), .. }) if s.is_empty())
+            ) && matches!(count_arg.kind, ExprKind::Lit(_))
+            {
+                return;
+            }
+
             let (msg, note_msg) = if count == 0 {
                 (format!("`{}` called with `0` splits", method_name),
                 "the resulting iterator will always return `None`")
diff --git a/tests/ui/suspicious_splitn.rs b/tests/ui/suspicious_splitn.rs
index a944aa79cfe..a21d94cf20b 100644
--- a/tests/ui/suspicious_splitn.rs
+++ b/tests/ui/suspicious_splitn.rs
@@ -13,4 +13,8 @@ fn main() {
     let _ = [0, 1, 2].splitn_mut(0, |&x| x == 1);
     let _ = [0, 1, 2].splitn(1, |&x| x == 1);
     let _ = [0, 1, 2].rsplitn_mut(1, |&x| x == 1);
+
+    const X: usize = 0;
+    let _ = "a,b".splitn(X + 1, ',');
+    let _ = "a,b".splitn(X, ',');
 }
diff --git a/tests/ui/suspicious_splitn.stderr b/tests/ui/suspicious_splitn.stderr
index 2e4bfe93b94..b6220ae2393 100644
--- a/tests/ui/suspicious_splitn.stderr
+++ b/tests/ui/suspicious_splitn.stderr
@@ -55,5 +55,21 @@ LL |     let _ = [0, 1, 2].rsplitn_mut(1, |&x| x == 1);
    |
    = note: the resulting iterator will always return the entire slice followed by `None`
 
-error: aborting due to 7 previous errors
+error: `splitn` called with `1` split
+  --> $DIR/suspicious_splitn.rs:18:13
+   |
+LL |     let _ = "a,b".splitn(X + 1, ',');
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: the resulting iterator will always return the entire string followed by `None`
+
+error: `splitn` called with `0` splits
+  --> $DIR/suspicious_splitn.rs:19:13
+   |
+LL |     let _ = "a,b".splitn(X, ',');
+   |             ^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: the resulting iterator will always return `None`
+
+error: aborting due to 9 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 58491d386a35b7103dc6ab93f9c69eb1b8891fb9 Mon Sep 17 00:00:00 2001
From: Steven Engler <smengler3@gmail.com>
Date: Sun, 30 May 2021 20:19:57 -0400
Subject: Update message for 'not_unsafe_ptr_arg_deref' lint

---
 clippy_lints/src/functions/not_unsafe_ptr_arg_deref.rs |  2 +-
 tests/ui/functions.stderr                              | 18 +++++++++---------
 2 files changed, 10 insertions(+), 10 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/functions/not_unsafe_ptr_arg_deref.rs b/clippy_lints/src/functions/not_unsafe_ptr_arg_deref.rs
index b8ea6990866..af759a48e10 100644
--- a/clippy_lints/src/functions/not_unsafe_ptr_arg_deref.rs
+++ b/clippy_lints/src/functions/not_unsafe_ptr_arg_deref.rs
@@ -116,7 +116,7 @@ impl<'a, 'tcx> DerefVisitor<'a, 'tcx> {
                     self.cx,
                     NOT_UNSAFE_PTR_ARG_DEREF,
                     ptr.span,
-                    "this public function dereferences a raw pointer but is not marked `unsafe`",
+                    "this public function might dereference a raw pointer but is not marked `unsafe`",
                 );
             }
         }
diff --git a/tests/ui/functions.stderr b/tests/ui/functions.stderr
index 0a86568b18d..a2b8c2a384b 100644
--- a/tests/ui/functions.stderr
+++ b/tests/ui/functions.stderr
@@ -30,7 +30,7 @@ error: this function has too many arguments (8/7)
 LL |     fn bad_method(_one: u32, _two: u32, _three: &str, _four: bool, _five: f32, _six: f32, _seven: bool, _eight: ()) {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: this public function dereferences a raw pointer but is not marked `unsafe`
+error: this public function might dereference a raw pointer but is not marked `unsafe`
   --> $DIR/functions.rs:63:34
    |
 LL |         println!("{}", unsafe { *p });
@@ -38,49 +38,49 @@ LL |         println!("{}", unsafe { *p });
    |
    = note: `-D clippy::not-unsafe-ptr-arg-deref` implied by `-D warnings`
 
-error: this public function dereferences a raw pointer but is not marked `unsafe`
+error: this public function might dereference a raw pointer but is not marked `unsafe`
   --> $DIR/functions.rs:64:35
    |
 LL |         println!("{:?}", unsafe { p.as_ref() });
    |                                   ^
 
-error: this public function dereferences a raw pointer but is not marked `unsafe`
+error: this public function might dereference a raw pointer but is not marked `unsafe`
   --> $DIR/functions.rs:65:33
    |
 LL |         unsafe { std::ptr::read(p) };
    |                                 ^
 
-error: this public function dereferences a raw pointer but is not marked `unsafe`
+error: this public function might dereference a raw pointer but is not marked `unsafe`
   --> $DIR/functions.rs:76:30
    |
 LL |     println!("{}", unsafe { *p });
    |                              ^
 
-error: this public function dereferences a raw pointer but is not marked `unsafe`
+error: this public function might dereference a raw pointer but is not marked `unsafe`
   --> $DIR/functions.rs:77:31
    |
 LL |     println!("{:?}", unsafe { p.as_ref() });
    |                               ^
 
-error: this public function dereferences a raw pointer but is not marked `unsafe`
+error: this public function might dereference a raw pointer but is not marked `unsafe`
   --> $DIR/functions.rs:78:29
    |
 LL |     unsafe { std::ptr::read(p) };
    |                             ^
 
-error: this public function dereferences a raw pointer but is not marked `unsafe`
+error: this public function might dereference a raw pointer but is not marked `unsafe`
   --> $DIR/functions.rs:87:34
    |
 LL |         println!("{}", unsafe { *p });
    |                                  ^
 
-error: this public function dereferences a raw pointer but is not marked `unsafe`
+error: this public function might dereference a raw pointer but is not marked `unsafe`
   --> $DIR/functions.rs:88:35
    |
 LL |         println!("{:?}", unsafe { p.as_ref() });
    |                                   ^
 
-error: this public function dereferences a raw pointer but is not marked `unsafe`
+error: this public function might dereference a raw pointer but is not marked `unsafe`
   --> $DIR/functions.rs:89:33
    |
 LL |         unsafe { std::ptr::read(p) };
-- 
cgit 1.4.1-3-g733a5


From 97311f0906ca89656f5942b326a665fe98d84c17 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sat, 22 May 2021 17:08:17 -0400
Subject: Add lint `manual_str_repeat`

---
 CHANGELOG.md                                  |  1 +
 clippy_lints/src/lib.rs                       |  3 +
 clippy_lints/src/mem_discriminant.rs          |  3 +-
 clippy_lints/src/methods/clone_on_copy.rs     |  5 +-
 clippy_lints/src/methods/manual_str_repeat.rs | 89 +++++++++++++++++++++++++++
 clippy_lints/src/methods/mod.rs               | 35 ++++++++++-
 clippy_utils/src/msrvs.rs                     |  1 +
 tests/ui/manual_str_repeat.fixed              | 31 ++++++++++
 tests/ui/manual_str_repeat.rs                 | 31 ++++++++++
 tests/ui/manual_str_repeat.stderr             | 46 ++++++++++++++
 10 files changed, 238 insertions(+), 7 deletions(-)
 create mode 100644 clippy_lints/src/methods/manual_str_repeat.rs
 create mode 100644 tests/ui/manual_str_repeat.fixed
 create mode 100644 tests/ui/manual_str_repeat.rs
 create mode 100644 tests/ui/manual_str_repeat.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 59daa074282..41af8e190dd 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2493,6 +2493,7 @@ Released 2018-09-13
 [`manual_ok_or`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_ok_or
 [`manual_range_contains`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_range_contains
 [`manual_saturating_arithmetic`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_saturating_arithmetic
+[`manual_str_repeat`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_str_repeat
 [`manual_strip`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_strip
 [`manual_swap`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_swap
 [`manual_unwrap_or`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_unwrap_or
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 0e815be9bd5..e7dd3952b3a 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -762,6 +762,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         methods::MANUAL_FILTER_MAP,
         methods::MANUAL_FIND_MAP,
         methods::MANUAL_SATURATING_ARITHMETIC,
+        methods::MANUAL_STR_REPEAT,
         methods::MAP_COLLECT_RESULT_UNIT,
         methods::MAP_FLATTEN,
         methods::MAP_UNWRAP_OR,
@@ -1298,6 +1299,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(methods::MANUAL_FILTER_MAP),
         LintId::of(methods::MANUAL_FIND_MAP),
         LintId::of(methods::MANUAL_SATURATING_ARITHMETIC),
+        LintId::of(methods::MANUAL_STR_REPEAT),
         LintId::of(methods::MAP_COLLECT_RESULT_UNIT),
         LintId::of(methods::NEW_RET_NO_SELF),
         LintId::of(methods::OK_EXPECT),
@@ -1735,6 +1737,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(loops::NEEDLESS_COLLECT),
         LintId::of(methods::EXPECT_FUN_CALL),
         LintId::of(methods::ITER_NTH),
+        LintId::of(methods::MANUAL_STR_REPEAT),
         LintId::of(methods::OR_FUN_CALL),
         LintId::of(methods::SINGLE_CHAR_PATTERN),
         LintId::of(misc::CMP_OWNED),
diff --git a/clippy_lints/src/mem_discriminant.rs b/clippy_lints/src/mem_discriminant.rs
index a735c616f6e..aca96e06ef2 100644
--- a/clippy_lints/src/mem_discriminant.rs
+++ b/clippy_lints/src/mem_discriminant.rs
@@ -7,7 +7,6 @@ use rustc_errors::Applicability;
 use rustc_hir::{BorrowKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use std::iter;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for calls of `mem::discriminant()` on a non-enum type.
@@ -67,7 +66,7 @@ impl<'tcx> LateLintPass<'tcx> for MemDiscriminant {
                                 }
                             }
 
-                            let derefs: String = iter::repeat('*').take(derefs_needed).collect();
+                            let derefs = "*".repeat(derefs_needed);
                             diag.span_suggestion(
                                 param.span,
                                 "try dereferencing",
diff --git a/clippy_lints/src/methods/clone_on_copy.rs b/clippy_lints/src/methods/clone_on_copy.rs
index ce2e8fa8b10..1a32af5dc7a 100644
--- a/clippy_lints/src/methods/clone_on_copy.rs
+++ b/clippy_lints/src/methods/clone_on_copy.rs
@@ -8,7 +8,6 @@ use rustc_hir::{BindingAnnotation, Expr, ExprKind, MatchSource, Node, PatKind};
 use rustc_lint::LateContext;
 use rustc_middle::ty::{self, adjustment::Adjust};
 use rustc_span::symbol::{sym, Symbol};
-use std::iter;
 
 use super::CLONE_DOUBLE_REF;
 use super::CLONE_ON_COPY;
@@ -54,8 +53,8 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, method_name: Symbol,
                             ty = inner;
                             n += 1;
                         }
-                        let refs: String = iter::repeat('&').take(n + 1).collect();
-                        let derefs: String = iter::repeat('*').take(n).collect();
+                        let refs = "&".repeat(n + 1);
+                        let derefs = "*".repeat(n);
                         let explicit = format!("<{}{}>::clone({})", refs, ty, snip);
                         diag.span_suggestion(
                             expr.span,
diff --git a/clippy_lints/src/methods/manual_str_repeat.rs b/clippy_lints/src/methods/manual_str_repeat.rs
new file mode 100644
index 00000000000..3f28412fbf7
--- /dev/null
+++ b/clippy_lints/src/methods/manual_str_repeat.rs
@@ -0,0 +1,89 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet_with_context;
+use clippy_utils::ty::{is_type_diagnostic_item, is_type_lang_item, match_type};
+use clippy_utils::{is_expr_path_def_path, paths};
+use if_chain::if_chain;
+use rustc_ast::util::parser::PREC_POSTFIX;
+use rustc_ast::LitKind;
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind, LangItem};
+use rustc_lint::LateContext;
+use rustc_span::symbol::{sym, Symbol};
+
+use super::MANUAL_STR_REPEAT;
+
+enum RepeatKind {
+    Str,
+    String,
+    Char,
+}
+
+fn parse_repeat_arg(cx: &LateContext<'_>, e: &Expr<'_>) -> Option<RepeatKind> {
+    if let ExprKind::Lit(lit) = &e.kind {
+        match lit.node {
+            LitKind::Str(..) => Some(RepeatKind::Str),
+            LitKind::Char(_) => Some(RepeatKind::Char),
+            _ => None,
+        }
+    } else {
+        let ty = cx.typeck_results().expr_ty(e);
+        if is_type_diagnostic_item(cx, ty, sym::string_type)
+            || is_type_lang_item(cx, ty, LangItem::OwnedBox)
+            || match_type(cx, ty, &paths::COW)
+        {
+            Some(RepeatKind::String)
+        } else {
+            let ty = ty.peel_refs();
+            (ty.is_str() || is_type_diagnostic_item(cx, ty, sym::string_type)).then(|| RepeatKind::Str)
+        }
+    }
+}
+
+pub(super) fn check(
+    cx: &LateContext<'_>,
+    collect_expr: &Expr<'_>,
+    take_expr: &Expr<'_>,
+    take_self_arg: &Expr<'_>,
+    take_arg: &Expr<'_>,
+) {
+    if_chain! {
+        if let ExprKind::Call(repeat_fn, [repeat_arg]) = take_self_arg.kind;
+        if is_expr_path_def_path(cx, repeat_fn, &paths::ITER_REPEAT);
+        if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(collect_expr), sym::string_type);
+        if let Some(collect_id) = cx.typeck_results().type_dependent_def_id(collect_expr.hir_id);
+        if let Some(take_id) = cx.typeck_results().type_dependent_def_id(take_expr.hir_id);
+        if let Some(iter_trait_id) = cx.tcx.get_diagnostic_item(sym::Iterator);
+        if cx.tcx.trait_of_item(collect_id) == Some(iter_trait_id);
+        if cx.tcx.trait_of_item(take_id) == Some(iter_trait_id);
+        if let Some(repeat_kind) = parse_repeat_arg(cx, repeat_arg);
+        let ctxt = collect_expr.span.ctxt();
+        if ctxt == take_expr.span.ctxt();
+        if ctxt == take_self_arg.span.ctxt();
+        then {
+            let mut app = Applicability::MachineApplicable;
+            let (val_snip, val_is_mac) = snippet_with_context(cx, repeat_arg.span, ctxt, "..", &mut app);
+            let count_snip = snippet_with_context(cx, take_arg.span, ctxt, "..", &mut app).0;
+
+            let val_str = match repeat_kind {
+                RepeatKind::String => format!("(&{})", val_snip),
+                RepeatKind::Str if !val_is_mac && repeat_arg.precedence().order() < PREC_POSTFIX => {
+                    format!("({})", val_snip)
+                },
+                RepeatKind::Str => val_snip.into(),
+                RepeatKind::Char if val_snip == r#"'"'"# => r#""\"""#.into(),
+                RepeatKind::Char if val_snip == r#"'\''"# => r#""'""#.into(),
+                RepeatKind::Char => format!("\"{}\"", &val_snip[1..val_snip.len() - 1]),
+            };
+
+            span_lint_and_sugg(
+                cx,
+                MANUAL_STR_REPEAT,
+                collect_expr.span,
+                "manual implementation of `str::repeat` using iterators",
+                "try this",
+                format!("{}.repeat({})", val_str, count_snip),
+                app
+            )
+        }
+    }
+}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index a6e2e0baadb..62a56434b3c 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -32,6 +32,7 @@ mod iter_nth_zero;
 mod iter_skip_next;
 mod iterator_step_by_zero;
 mod manual_saturating_arithmetic;
+mod manual_str_repeat;
 mod map_collect_result_unit;
 mod map_flatten;
 mod map_unwrap_or;
@@ -60,9 +61,12 @@ mod wrong_self_convention;
 mod zst_offset;
 
 use bind_instead_of_map::BindInsteadOfMap;
-use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
 use clippy_utils::ty::{contains_adt_constructor, contains_ty, implements_trait, is_copy, is_type_diagnostic_item};
 use clippy_utils::{contains_return, get_trait_def_id, in_macro, iter_input_pats, paths, return_ty};
+use clippy_utils::{
+    diagnostics::{span_lint, span_lint_and_help},
+    meets_msrv, msrvs,
+};
 use if_chain::if_chain;
 use rustc_hir as hir;
 use rustc_hir::def::Res;
@@ -1664,6 +1668,27 @@ declare_clippy_lint! {
     "checks for `.splitn(0, ..)` and `.splitn(1, ..)`"
 }
 
+declare_clippy_lint! {
+    /// **What it does:** Checks for manual implementations of `str::repeat`
+    ///
+    /// **Why is this bad?** These are both harder to read, as well as less performant.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// // Bad
+    /// let x: String = std::iter::repeat('x').take(10).collect();
+    ///
+    /// // Good
+    /// let x: String = "x".repeat(10);
+    /// ```
+    pub MANUAL_STR_REPEAT,
+    perf,
+    "manual implementation of `str::repeat`"
+}
+
 pub struct Methods {
     avoid_breaking_exported_api: bool,
     msrv: Option<RustcVersion>,
@@ -1737,7 +1762,8 @@ impl_lint_pass!(Methods => [
     FROM_ITER_INSTEAD_OF_COLLECT,
     INSPECT_FOR_EACH,
     IMPLICIT_CLONE,
-    SUSPICIOUS_SPLITN
+    SUSPICIOUS_SPLITN,
+    MANUAL_STR_REPEAT
 ]);
 
 /// Extracts a method call name, args, and `Span` of the method name.
@@ -1981,6 +2007,11 @@ fn check_methods<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, msrv: Optio
                 Some(("map", [m_recv, m_arg], _)) => {
                     map_collect_result_unit::check(cx, expr, m_recv, m_arg, recv);
                 },
+                Some(("take", [take_self_arg, take_arg], _)) => {
+                    if meets_msrv(msrv, &msrvs::STR_REPEAT) {
+                        manual_str_repeat::check(cx, expr, recv, take_self_arg, take_arg);
+                    }
+                },
                 _ => {},
             },
             ("count", []) => match method_call!(recv) {
diff --git a/clippy_utils/src/msrvs.rs b/clippy_utils/src/msrvs.rs
index 00df04c0144..4a9c4fd0276 100644
--- a/clippy_utils/src/msrvs.rs
+++ b/clippy_utils/src/msrvs.rs
@@ -26,4 +26,5 @@ msrv_aliases! {
     1,34,0 { TRY_FROM }
     1,30,0 { ITERATOR_FIND_MAP }
     1,17,0 { FIELD_INIT_SHORTHAND, STATIC_IN_CONST }
+    1,16,0 { STR_REPEAT }
 }
diff --git a/tests/ui/manual_str_repeat.fixed b/tests/ui/manual_str_repeat.fixed
new file mode 100644
index 00000000000..62225e7a7f8
--- /dev/null
+++ b/tests/ui/manual_str_repeat.fixed
@@ -0,0 +1,31 @@
+// run-rustfix
+
+#![warn(clippy::manual_str_repeat)]
+
+use std::iter::repeat;
+
+fn main() {
+    let _: String = "test".repeat(10);
+    let _: String = "x".repeat(10);
+    let _: String = "'".repeat(10);
+    let _: String = "\"".repeat(10);
+
+    let x = "test";
+    let count = 10;
+    let _ = x.repeat(count + 2);
+
+    macro_rules! m {
+        ($e:expr) => {{ $e }};
+    }
+
+    let _: String = m!("test").repeat(m!(count));
+
+    let x = &x;
+    let _: String = (*x).repeat(count);
+
+    macro_rules! repeat_m {
+        ($e:expr) => {{ repeat($e) }};
+    }
+    // Don't lint, repeat is from a macro.
+    let _: String = repeat_m!("test").take(count).collect();
+}
diff --git a/tests/ui/manual_str_repeat.rs b/tests/ui/manual_str_repeat.rs
new file mode 100644
index 00000000000..1acd66da275
--- /dev/null
+++ b/tests/ui/manual_str_repeat.rs
@@ -0,0 +1,31 @@
+// run-rustfix
+
+#![warn(clippy::manual_str_repeat)]
+
+use std::iter::repeat;
+
+fn main() {
+    let _: String = std::iter::repeat("test").take(10).collect();
+    let _: String = std::iter::repeat('x').take(10).collect();
+    let _: String = std::iter::repeat('\'').take(10).collect();
+    let _: String = std::iter::repeat('"').take(10).collect();
+
+    let x = "test";
+    let count = 10;
+    let _ = repeat(x).take(count + 2).collect::<String>();
+
+    macro_rules! m {
+        ($e:expr) => {{ $e }};
+    }
+
+    let _: String = repeat(m!("test")).take(m!(count)).collect();
+
+    let x = &x;
+    let _: String = repeat(*x).take(count).collect();
+
+    macro_rules! repeat_m {
+        ($e:expr) => {{ repeat($e) }};
+    }
+    // Don't lint, repeat is from a macro.
+    let _: String = repeat_m!("test").take(count).collect();
+}
diff --git a/tests/ui/manual_str_repeat.stderr b/tests/ui/manual_str_repeat.stderr
new file mode 100644
index 00000000000..ef67ad2a1fd
--- /dev/null
+++ b/tests/ui/manual_str_repeat.stderr
@@ -0,0 +1,46 @@
+error: manual implementation of `str::repeat` using iterators
+  --> $DIR/manual_str_repeat.rs:8:21
+   |
+LL |     let _: String = std::iter::repeat("test").take(10).collect();
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `"test".repeat(10)`
+   |
+   = note: `-D clippy::manual-str-repeat` implied by `-D warnings`
+
+error: manual implementation of `str::repeat` using iterators
+  --> $DIR/manual_str_repeat.rs:9:21
+   |
+LL |     let _: String = std::iter::repeat('x').take(10).collect();
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `"x".repeat(10)`
+
+error: manual implementation of `str::repeat` using iterators
+  --> $DIR/manual_str_repeat.rs:10:21
+   |
+LL |     let _: String = std::iter::repeat('/'').take(10).collect();
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `"'".repeat(10)`
+
+error: manual implementation of `str::repeat` using iterators
+  --> $DIR/manual_str_repeat.rs:11:21
+   |
+LL |     let _: String = std::iter::repeat('"').take(10).collect();
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `"/"".repeat(10)`
+
+error: manual implementation of `str::repeat` using iterators
+  --> $DIR/manual_str_repeat.rs:15:13
+   |
+LL |     let _ = repeat(x).take(count + 2).collect::<String>();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `x.repeat(count + 2)`
+
+error: manual implementation of `str::repeat` using iterators
+  --> $DIR/manual_str_repeat.rs:21:21
+   |
+LL |     let _: String = repeat(m!("test")).take(m!(count)).collect();
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `m!("test").repeat(m!(count))`
+
+error: manual implementation of `str::repeat` using iterators
+  --> $DIR/manual_str_repeat.rs:24:21
+   |
+LL |     let _: String = repeat(*x).take(count).collect();
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `(*x).repeat(count)`
+
+error: aborting due to 7 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From cfddf0927bd71b859bc1e749ec159285433a3849 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sun, 23 May 2021 13:16:09 -0400
Subject: Fix type checks for `manual_str_repeat`

---
 clippy_lints/src/methods/manual_str_repeat.rs | 48 ++++++++++++++++-----------
 clippy_lints/src/methods/mod.rs               |  7 ++--
 clippy_lints/src/utils/conf.rs                |  2 +-
 clippy_utils/src/sugg.rs                      | 27 +++++++++++++--
 tests/ui/manual_str_repeat.fixed              | 41 +++++++++++++++++++++--
 tests/ui/manual_str_repeat.rs                 | 39 ++++++++++++++++++++--
 tests/ui/manual_str_repeat.stderr             | 42 ++++++++++++++++-------
 7 files changed, 162 insertions(+), 44 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/manual_str_repeat.rs b/clippy_lints/src/methods/manual_str_repeat.rs
index 3f28412fbf7..919e2628c52 100644
--- a/clippy_lints/src/methods/manual_str_repeat.rs
+++ b/clippy_lints/src/methods/manual_str_repeat.rs
@@ -1,40 +1,49 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::source::snippet_with_context;
+use clippy_utils::source::{snippet_with_applicability, snippet_with_context};
+use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::{is_type_diagnostic_item, is_type_lang_item, match_type};
 use clippy_utils::{is_expr_path_def_path, paths};
 use if_chain::if_chain;
-use rustc_ast::util::parser::PREC_POSTFIX;
 use rustc_ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, LangItem};
 use rustc_lint::LateContext;
-use rustc_span::symbol::{sym, Symbol};
+use rustc_middle::ty::{self, Ty, TyS};
+use rustc_span::symbol::sym;
+use std::borrow::Cow;
 
 use super::MANUAL_STR_REPEAT;
 
 enum RepeatKind {
-    Str,
     String,
-    Char,
+    Char(char),
+}
+
+fn get_ty_param(ty: Ty<'_>) -> Option<Ty<'_>> {
+    if let ty::Adt(_, subs) = ty.kind() {
+        subs.types().next()
+    } else {
+        None
+    }
 }
 
 fn parse_repeat_arg(cx: &LateContext<'_>, e: &Expr<'_>) -> Option<RepeatKind> {
     if let ExprKind::Lit(lit) = &e.kind {
         match lit.node {
-            LitKind::Str(..) => Some(RepeatKind::Str),
-            LitKind::Char(_) => Some(RepeatKind::Char),
+            LitKind::Str(..) => Some(RepeatKind::String),
+            LitKind::Char(c) => Some(RepeatKind::Char(c)),
             _ => None,
         }
     } else {
         let ty = cx.typeck_results().expr_ty(e);
         if is_type_diagnostic_item(cx, ty, sym::string_type)
-            || is_type_lang_item(cx, ty, LangItem::OwnedBox)
-            || match_type(cx, ty, &paths::COW)
+            || (is_type_lang_item(cx, ty, LangItem::OwnedBox) && get_ty_param(ty).map_or(false, TyS::is_str))
+            || (match_type(cx, ty, &paths::COW) && get_ty_param(ty).map_or(false, TyS::is_str))
         {
             Some(RepeatKind::String)
         } else {
             let ty = ty.peel_refs();
-            (ty.is_str() || is_type_diagnostic_item(cx, ty, sym::string_type)).then(|| RepeatKind::Str)
+            (ty.is_str() || is_type_diagnostic_item(cx, ty, sym::string_type)).then(|| RepeatKind::String)
         }
     }
 }
@@ -61,18 +70,19 @@ pub(super) fn check(
         if ctxt == take_self_arg.span.ctxt();
         then {
             let mut app = Applicability::MachineApplicable;
-            let (val_snip, val_is_mac) = snippet_with_context(cx, repeat_arg.span, ctxt, "..", &mut app);
             let count_snip = snippet_with_context(cx, take_arg.span, ctxt, "..", &mut app).0;
 
             let val_str = match repeat_kind {
-                RepeatKind::String => format!("(&{})", val_snip),
-                RepeatKind::Str if !val_is_mac && repeat_arg.precedence().order() < PREC_POSTFIX => {
-                    format!("({})", val_snip)
-                },
-                RepeatKind::Str => val_snip.into(),
-                RepeatKind::Char if val_snip == r#"'"'"# => r#""\"""#.into(),
-                RepeatKind::Char if val_snip == r#"'\''"# => r#""'""#.into(),
-                RepeatKind::Char => format!("\"{}\"", &val_snip[1..val_snip.len() - 1]),
+                RepeatKind::Char(_) if repeat_arg.span.ctxt() != ctxt => return,
+                RepeatKind::Char('\'') => r#""'""#.into(),
+                RepeatKind::Char('"') => r#""\"""#.into(),
+                RepeatKind::Char(_) =>
+                    match snippet_with_applicability(cx, repeat_arg.span, "..", &mut app) {
+                        Cow::Owned(s) => Cow::Owned(format!("\"{}\"", &s[1..s.len() - 1])),
+                        s @ Cow::Borrowed(_) => s,
+                    },
+                RepeatKind::String =>
+                    Sugg::hir_with_context(cx, repeat_arg, ctxt, "..", &mut app).maybe_par().to_string().into(),
             };
 
             span_lint_and_sugg(
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 62a56434b3c..c8ae972f18c 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -61,12 +61,9 @@ mod wrong_self_convention;
 mod zst_offset;
 
 use bind_instead_of_map::BindInsteadOfMap;
+use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
 use clippy_utils::ty::{contains_adt_constructor, contains_ty, implements_trait, is_copy, is_type_diagnostic_item};
-use clippy_utils::{contains_return, get_trait_def_id, in_macro, iter_input_pats, paths, return_ty};
-use clippy_utils::{
-    diagnostics::{span_lint, span_lint_and_help},
-    meets_msrv, msrvs,
-};
+use clippy_utils::{contains_return, get_trait_def_id, in_macro, iter_input_pats, meets_msrv, msrvs, paths, return_ty};
 use if_chain::if_chain;
 use rustc_hir as hir;
 use rustc_hir::def::Res;
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 1bd38dc042c..0e33ae740d9 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -124,7 +124,7 @@ macro_rules! define_Conf {
 define_Conf! {
     /// Lint: ENUM_VARIANT_NAMES, LARGE_TYPES_PASSED_BY_VALUE, TRIVIALLY_COPY_PASS_BY_REF, UNNECESSARY_WRAPS, UPPER_CASE_ACRONYMS, WRONG_SELF_CONVENTION. Suppress lints whenever the suggested change would cause breakage for other crates.
     (avoid_breaking_exported_api: bool = true),
-    /// Lint: CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR, IF_THEN_SOME_ELSE_NONE. The minimum rust version that the project supports
+    /// Lint: MANUAL_STR_REPEAT, CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR, IF_THEN_SOME_ELSE_NONE. The minimum rust version that the project supports
     (msrv: Option<String> = None),
     /// Lint: BLACKLISTED_NAME. The list of blacklisted names to lint about. NB: `bar` is not here since it has legitimate uses
     (blacklisted_names: Vec<String> = ["foo", "baz", "quux"].iter().map(ToString::to_string).collect()),
diff --git a/clippy_utils/src/sugg.rs b/clippy_utils/src/sugg.rs
index e5a70f0beac..efc0ec50fdc 100644
--- a/clippy_utils/src/sugg.rs
+++ b/clippy_utils/src/sugg.rs
@@ -2,7 +2,7 @@
 #![deny(clippy::missing_docs_in_private_items)]
 
 use crate::higher;
-use crate::source::{snippet, snippet_opt, snippet_with_macro_callsite};
+use crate::source::{snippet, snippet_opt, snippet_with_context, snippet_with_macro_callsite};
 use rustc_ast::util::parser::AssocOp;
 use rustc_ast::{ast, token};
 use rustc_ast_pretty::pprust::token_kind_to_string;
@@ -10,7 +10,7 @@ use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::{EarlyContext, LateContext, LintContext};
 use rustc_span::source_map::{CharPos, Span};
-use rustc_span::{BytePos, Pos};
+use rustc_span::{BytePos, Pos, SyntaxContext};
 use std::borrow::Cow;
 use std::convert::TryInto;
 use std::fmt::Display;
@@ -90,6 +90,29 @@ impl<'a> Sugg<'a> {
         Self::hir_from_snippet(expr, snippet)
     }
 
+    /// Same as `hir`, but first walks the span up to the given context. This will result in the
+    /// macro call, rather then the expansion, if the span is from a child context. If the span is
+    /// not from a child context, it will be used directly instead.
+    ///
+    /// e.g. Given the expression `&vec![]`, getting a snippet from the span for `vec![]` as a HIR
+    /// node would result in `box []`. If given the context of the address of expression, this
+    /// function will correctly get a snippet of `vec![]`.
+    pub fn hir_with_context(
+        cx: &LateContext<'_>,
+        expr: &hir::Expr<'_>,
+        ctxt: SyntaxContext,
+        default: &'a str,
+        applicability: &mut Applicability,
+    ) -> Self {
+        let (snippet, in_macro) = snippet_with_context(cx, expr.span, ctxt, default, applicability);
+
+        if in_macro {
+            Sugg::NonParen(snippet)
+        } else {
+            Self::hir_from_snippet(expr, snippet)
+        }
+    }
+
     /// Generate a suggestion for an expression with the given snippet. This is used by the `hir_*`
     /// function variants of `Sugg`, since these use different snippet functions.
     fn hir_from_snippet(expr: &hir::Expr<'_>, snippet: Cow<'a, str>) -> Self {
diff --git a/tests/ui/manual_str_repeat.fixed b/tests/ui/manual_str_repeat.fixed
index 62225e7a7f8..dc140257f32 100644
--- a/tests/ui/manual_str_repeat.fixed
+++ b/tests/ui/manual_str_repeat.fixed
@@ -1,8 +1,10 @@
 // run-rustfix
 
+#![feature(custom_inner_attributes)]
 #![warn(clippy::manual_str_repeat)]
 
-use std::iter::repeat;
+use std::borrow::Cow;
+use std::iter::{repeat, FromIterator};
 
 fn main() {
     let _: String = "test".repeat(10);
@@ -17,8 +19,8 @@ fn main() {
     macro_rules! m {
         ($e:expr) => {{ $e }};
     }
-
-    let _: String = m!("test").repeat(m!(count));
+    // FIXME: macro args are fine
+    let _: String = repeat(m!("test")).take(m!(count)).collect();
 
     let x = &x;
     let _: String = (*x).repeat(count);
@@ -28,4 +30,37 @@ fn main() {
     }
     // Don't lint, repeat is from a macro.
     let _: String = repeat_m!("test").take(count).collect();
+
+    let x: Box<str> = Box::from("test");
+    let _: String = x.repeat(count);
+
+    #[derive(Clone)]
+    struct S;
+    impl FromIterator<Box<S>> for String {
+        fn from_iter<T: IntoIterator<Item = Box<S>>>(_: T) -> Self {
+            Self::new()
+        }
+    }
+    // Don't lint, wrong box type
+    let _: String = repeat(Box::new(S)).take(count).collect();
+
+    let _: String = Cow::Borrowed("test").repeat(count);
+
+    let x = "x".to_owned();
+    let _: String = x.repeat(count);
+
+    let x = 'x';
+    // Don't lint, not char literal
+    let _: String = repeat(x).take(count).collect();
+}
+
+fn _msrv_1_15() {
+    #![clippy::msrv = "1.15"]
+    // `str::repeat` was stabilized in 1.16. Do not lint this
+    let _: String = std::iter::repeat("test").take(10).collect();
+}
+
+fn _msrv_1_16() {
+    #![clippy::msrv = "1.16"]
+    let _: String = "test".repeat(10);
 }
diff --git a/tests/ui/manual_str_repeat.rs b/tests/ui/manual_str_repeat.rs
index 1acd66da275..0d69c989b2e 100644
--- a/tests/ui/manual_str_repeat.rs
+++ b/tests/ui/manual_str_repeat.rs
@@ -1,8 +1,10 @@
 // run-rustfix
 
+#![feature(custom_inner_attributes)]
 #![warn(clippy::manual_str_repeat)]
 
-use std::iter::repeat;
+use std::borrow::Cow;
+use std::iter::{repeat, FromIterator};
 
 fn main() {
     let _: String = std::iter::repeat("test").take(10).collect();
@@ -17,7 +19,7 @@ fn main() {
     macro_rules! m {
         ($e:expr) => {{ $e }};
     }
-
+    // FIXME: macro args are fine
     let _: String = repeat(m!("test")).take(m!(count)).collect();
 
     let x = &x;
@@ -28,4 +30,37 @@ fn main() {
     }
     // Don't lint, repeat is from a macro.
     let _: String = repeat_m!("test").take(count).collect();
+
+    let x: Box<str> = Box::from("test");
+    let _: String = repeat(x).take(count).collect();
+
+    #[derive(Clone)]
+    struct S;
+    impl FromIterator<Box<S>> for String {
+        fn from_iter<T: IntoIterator<Item = Box<S>>>(_: T) -> Self {
+            Self::new()
+        }
+    }
+    // Don't lint, wrong box type
+    let _: String = repeat(Box::new(S)).take(count).collect();
+
+    let _: String = repeat(Cow::Borrowed("test")).take(count).collect();
+
+    let x = "x".to_owned();
+    let _: String = repeat(x).take(count).collect();
+
+    let x = 'x';
+    // Don't lint, not char literal
+    let _: String = repeat(x).take(count).collect();
+}
+
+fn _msrv_1_15() {
+    #![clippy::msrv = "1.15"]
+    // `str::repeat` was stabilized in 1.16. Do not lint this
+    let _: String = std::iter::repeat("test").take(10).collect();
+}
+
+fn _msrv_1_16() {
+    #![clippy::msrv = "1.16"]
+    let _: String = std::iter::repeat("test").take(10).collect();
 }
diff --git a/tests/ui/manual_str_repeat.stderr b/tests/ui/manual_str_repeat.stderr
index ef67ad2a1fd..c6511689716 100644
--- a/tests/ui/manual_str_repeat.stderr
+++ b/tests/ui/manual_str_repeat.stderr
@@ -1,5 +1,5 @@
 error: manual implementation of `str::repeat` using iterators
-  --> $DIR/manual_str_repeat.rs:8:21
+  --> $DIR/manual_str_repeat.rs:10:21
    |
 LL |     let _: String = std::iter::repeat("test").take(10).collect();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `"test".repeat(10)`
@@ -7,40 +7,58 @@ LL |     let _: String = std::iter::repeat("test").take(10).collect();
    = note: `-D clippy::manual-str-repeat` implied by `-D warnings`
 
 error: manual implementation of `str::repeat` using iterators
-  --> $DIR/manual_str_repeat.rs:9:21
+  --> $DIR/manual_str_repeat.rs:11:21
    |
 LL |     let _: String = std::iter::repeat('x').take(10).collect();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `"x".repeat(10)`
 
 error: manual implementation of `str::repeat` using iterators
-  --> $DIR/manual_str_repeat.rs:10:21
+  --> $DIR/manual_str_repeat.rs:12:21
    |
 LL |     let _: String = std::iter::repeat('/'').take(10).collect();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `"'".repeat(10)`
 
 error: manual implementation of `str::repeat` using iterators
-  --> $DIR/manual_str_repeat.rs:11:21
+  --> $DIR/manual_str_repeat.rs:13:21
    |
 LL |     let _: String = std::iter::repeat('"').take(10).collect();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `"/"".repeat(10)`
 
 error: manual implementation of `str::repeat` using iterators
-  --> $DIR/manual_str_repeat.rs:15:13
+  --> $DIR/manual_str_repeat.rs:17:13
    |
 LL |     let _ = repeat(x).take(count + 2).collect::<String>();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `x.repeat(count + 2)`
 
 error: manual implementation of `str::repeat` using iterators
-  --> $DIR/manual_str_repeat.rs:21:21
+  --> $DIR/manual_str_repeat.rs:26:21
    |
-LL |     let _: String = repeat(m!("test")).take(m!(count)).collect();
-   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `m!("test").repeat(m!(count))`
+LL |     let _: String = repeat(*x).take(count).collect();
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `(*x).repeat(count)`
 
 error: manual implementation of `str::repeat` using iterators
-  --> $DIR/manual_str_repeat.rs:24:21
+  --> $DIR/manual_str_repeat.rs:35:21
    |
-LL |     let _: String = repeat(*x).take(count).collect();
-   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `(*x).repeat(count)`
+LL |     let _: String = repeat(x).take(count).collect();
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `x.repeat(count)`
+
+error: manual implementation of `str::repeat` using iterators
+  --> $DIR/manual_str_repeat.rs:47:21
+   |
+LL |     let _: String = repeat(Cow::Borrowed("test")).take(count).collect();
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `Cow::Borrowed("test").repeat(count)`
+
+error: manual implementation of `str::repeat` using iterators
+  --> $DIR/manual_str_repeat.rs:50:21
+   |
+LL |     let _: String = repeat(x).take(count).collect();
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `x.repeat(count)`
+
+error: manual implementation of `str::repeat` using iterators
+  --> $DIR/manual_str_repeat.rs:65:21
+   |
+LL |     let _: String = std::iter::repeat("test").take(10).collect();
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `"test".repeat(10)`
 
-error: aborting due to 7 previous errors
+error: aborting due to 10 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 84c511facf6534394eaab76299c2953fcf47e76f Mon Sep 17 00:00:00 2001
From: lyj <lyj@everton>
Date: Wed, 2 Jun 2021 13:31:23 +0800
Subject: rc_mutex

---
 clippy_lints/src/types/mod.rs      | 11 ++++++++++-
 clippy_lints/src/types/rc_mutex.rs | 39 ++++++++++++++++++++++++++++++++++++++
 2 files changed, 49 insertions(+), 1 deletion(-)
 create mode 100644 clippy_lints/src/types/rc_mutex.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types/mod.rs b/clippy_lints/src/types/mod.rs
index 70b9e8adef8..acf00825b7a 100644
--- a/clippy_lints/src/types/mod.rs
+++ b/clippy_lints/src/types/mod.rs
@@ -7,6 +7,7 @@ mod redundant_allocation;
 mod type_complexity;
 mod utils;
 mod vec_box;
+mod rc_mutex;
 
 use rustc_hir as hir;
 use rustc_hir::intravisit::FnKind;
@@ -250,12 +251,19 @@ declare_clippy_lint! {
     "usage of very complex types that might be better factored into `type` definitions"
 }
 
+declare_clippy_lint! {
+    /// TODO
+    pub RC_MUTEX,
+    restriction,
+    "usage of Mutex inside Rc"
+}
+
 pub struct Types {
     vec_box_size_threshold: u64,
     type_complexity_threshold: u64,
 }
 
-impl_lint_pass!(Types => [BOX_VEC, VEC_BOX, OPTION_OPTION, LINKEDLIST, BORROWED_BOX, REDUNDANT_ALLOCATION, RC_BUFFER, TYPE_COMPLEXITY]);
+impl_lint_pass!(Types => [BOX_VEC, VEC_BOX, OPTION_OPTION, LINKEDLIST, BORROWED_BOX, REDUNDANT_ALLOCATION, RC_BUFFER, TYPE_COMPLEXITY,RC_MUTEX]);
 
 impl<'tcx> LateLintPass<'tcx> for Types {
     fn check_fn(&mut self, cx: &LateContext<'_>, _: FnKind<'_>, decl: &FnDecl<'_>, _: &Body<'_>, _: Span, id: HirId) {
@@ -375,6 +383,7 @@ impl Types {
                     triggered |= vec_box::check(cx, hir_ty, qpath, def_id, self.vec_box_size_threshold);
                     triggered |= option_option::check(cx, hir_ty, qpath, def_id);
                     triggered |= linked_list::check(cx, hir_ty, def_id);
+                    triggered |= rc_mutex::check(cx, hir_ty, qpath, def_id);
 
                     if triggered {
                         return;
diff --git a/clippy_lints/src/types/rc_mutex.rs b/clippy_lints/src/types/rc_mutex.rs
new file mode 100644
index 00000000000..b53b55fd01c
--- /dev/null
+++ b/clippy_lints/src/types/rc_mutex.rs
@@ -0,0 +1,39 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::{ get_qpath_generic_tys,is_ty_param_diagnostic_item};
+use clippy_utils::source::snippet_with_applicability;
+use rustc_errors::Applicability;
+use rustc_hir::{self as hir, def_id::DefId, QPath};
+use rustc_lint::LateContext;
+use rustc_span::symbol::sym;
+// use rustc_middle::ty::Adt;
+
+use super::RC_MUTEX;
+
+pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_>, def_id: DefId) -> bool {
+    if cx.tcx.is_diagnostic_item(sym::Rc, def_id) {
+        if let Some(ty) = is_ty_param_diagnostic_item(cx, qpath, sym!(mutex_type)) {
+            let mut applicability = Applicability::MachineApplicable;
+
+            let inner_span = match get_qpath_generic_tys(qpath).skip(1).next() {
+                Some(ty) => ty.span,
+                None => return false,
+            };
+
+            span_lint_and_sugg(
+                cx,
+                RC_MUTEX,
+                hir_ty.span,
+                "you seem to be trying to use `Rc<Mutex<T>>`. Consider using `Rc<RefCell<T>>`",
+                "try",
+                format!(
+                    "Rc<RefCell<{}>>",
+                    snippet_with_applicability(cx, inner_span, "..", &mut applicability)
+                ),
+                applicability,
+            );
+            return true;
+        }
+    }
+
+    false
+}
-- 
cgit 1.4.1-3-g733a5


From c0f3c2fe277102f22efc21ce64dc3e3423b777d4 Mon Sep 17 00:00:00 2001
From: lyj <lyj@everton>
Date: Thu, 3 Jun 2021 14:56:34 +0800
Subject: correct lint

---
 CHANGELOG.md                       |  1 +
 clippy_lints/src/lib.rs            |  2 ++
 clippy_lints/src/types/mod.rs      | 40 ++++++++++++++++++++++++++++++++++----
 clippy_lints/src/types/rc_mutex.rs | 16 +++++++++------
 tests/ui/rc_mutex.fixed            | 28 ++++++++++++++++++++++++++
 tests/ui/rc_mutex.rs               | 28 ++++++++++++++++++++++++++
 tests/ui/rc_mutex.stderr           | 22 +++++++++++++++++++++
 7 files changed, 127 insertions(+), 10 deletions(-)
 create mode 100644 tests/ui/rc_mutex.fixed
 create mode 100644 tests/ui/rc_mutex.rs
 create mode 100644 tests/ui/rc_mutex.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 41af8e190dd..4fb2ce8dfc8 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2611,6 +2611,7 @@ Released 2018-09-13
 [`range_step_by_zero`]: https://rust-lang.github.io/rust-clippy/master/index.html#range_step_by_zero
 [`range_zip_with_len`]: https://rust-lang.github.io/rust-clippy/master/index.html#range_zip_with_len
 [`rc_buffer`]: https://rust-lang.github.io/rust-clippy/master/index.html#rc_buffer
+[`rc_mutex`]: https://rust-lang.github.io/rust-clippy/master/index.html#rc_mutex
 [`redundant_allocation`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_allocation
 [`redundant_clone`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_clone
 [`redundant_closure`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_closure
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index e7dd3952b3a..2b999da15ca 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -931,6 +931,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         types::LINKEDLIST,
         types::OPTION_OPTION,
         types::RC_BUFFER,
+        types::RC_MUTEX,
         types::REDUNDANT_ALLOCATION,
         types::TYPE_COMPLEXITY,
         types::VEC_BOX,
@@ -1027,6 +1028,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(strings::STRING_TO_STRING),
         LintId::of(strings::STR_TO_STRING),
         LintId::of(types::RC_BUFFER),
+        LintId::of(types::RC_MUTEX),
         LintId::of(unnecessary_self_imports::UNNECESSARY_SELF_IMPORTS),
         LintId::of(unwrap_in_result::UNWRAP_IN_RESULT),
         LintId::of(verbose_file_reads::VERBOSE_FILE_READS),
diff --git a/clippy_lints/src/types/mod.rs b/clippy_lints/src/types/mod.rs
index acf00825b7a..07dec2de827 100644
--- a/clippy_lints/src/types/mod.rs
+++ b/clippy_lints/src/types/mod.rs
@@ -3,11 +3,11 @@ mod box_vec;
 mod linked_list;
 mod option_option;
 mod rc_buffer;
+mod rc_mutex;
 mod redundant_allocation;
 mod type_complexity;
 mod utils;
 mod vec_box;
-mod rc_mutex;
 
 use rustc_hir as hir;
 use rustc_hir::intravisit::FnKind;
@@ -252,10 +252,42 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// TODO
+    /// **What it does:** Checks for `Rc<Mutex<T>>`.
+    ///
+    /// **Why is this bad?** `Rc<Mutex<T>>` may introduce a deadlock in single thread. Consider
+    /// using `Rc<RefCell<T>>` instead.
+    /// ```rust
+    /// fn main() {
+    ///     use std::rc::Rc;
+    ///     use std::sync::Mutex;
+    ///
+    ///     let a: Rc<Mutex<i32>> = Rc::new(Mutex::new(1));
+    ///     let a_clone = a.clone();
+    ///     let mut data = a.lock().unwrap();
+    ///     println!("{:?}", *a_clone.lock().unwrap());
+    ///     *data = 10;
+    ///  }
+    /// ```
+    ///
+    /// **Known problems:** `Rc<RefCell<T>>` may panic in runtime.
+    ///
+    /// **Example:**
+    /// ```rust,ignore
+    /// use std::rc::Rc;
+    /// use std::sync::Mutex;
+    /// fn foo(interned: Rc<Mutex<i32>>) { ... }
+    /// ```
+    ///
+    /// Better:
+    ///
+    /// ```rust,ignore
+    /// use std::rc::Rc;
+    /// use std::cell::RefCell
+    /// fn foo(interned: Rc<RefCell<i32>>) { ... }
+    /// ```
     pub RC_MUTEX,
     restriction,
-    "usage of Mutex inside Rc"
+    "usage of `Rc<Mutex<T>>`"
 }
 
 pub struct Types {
@@ -263,7 +295,7 @@ pub struct Types {
     type_complexity_threshold: u64,
 }
 
-impl_lint_pass!(Types => [BOX_VEC, VEC_BOX, OPTION_OPTION, LINKEDLIST, BORROWED_BOX, REDUNDANT_ALLOCATION, RC_BUFFER, TYPE_COMPLEXITY,RC_MUTEX]);
+impl_lint_pass!(Types => [BOX_VEC, VEC_BOX, OPTION_OPTION, LINKEDLIST, BORROWED_BOX, REDUNDANT_ALLOCATION, RC_BUFFER, RC_MUTEX, TYPE_COMPLEXITY]);
 
 impl<'tcx> LateLintPass<'tcx> for Types {
     fn check_fn(&mut self, cx: &LateContext<'_>, _: FnKind<'_>, decl: &FnDecl<'_>, _: &Body<'_>, _: Span, id: HirId) {
diff --git a/clippy_lints/src/types/rc_mutex.rs b/clippy_lints/src/types/rc_mutex.rs
index b53b55fd01c..122df01d153 100644
--- a/clippy_lints/src/types/rc_mutex.rs
+++ b/clippy_lints/src/types/rc_mutex.rs
@@ -1,20 +1,24 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::{ get_qpath_generic_tys,is_ty_param_diagnostic_item};
 use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::{get_qpath_generic_tys, is_ty_param_diagnostic_item};
+use if_chain::if_chain;
 use rustc_errors::Applicability;
-use rustc_hir::{self as hir, def_id::DefId, QPath};
+use rustc_hir::{self as hir, def_id::DefId, QPath, TyKind};
 use rustc_lint::LateContext;
 use rustc_span::symbol::sym;
-// use rustc_middle::ty::Adt;
 
 use super::RC_MUTEX;
 
 pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_>, def_id: DefId) -> bool {
-    if cx.tcx.is_diagnostic_item(sym::Rc, def_id) {
-        if let Some(ty) = is_ty_param_diagnostic_item(cx, qpath, sym!(mutex_type)) {
+    if_chain! {
+        if cx.tcx.is_diagnostic_item(sym::Rc, def_id) ;
+        if let Some(ty) = is_ty_param_diagnostic_item(cx, qpath, sym!(mutex_type)) ;
+        if let TyKind::Path(ref qpath_inner)=ty.kind;
+
+        then{
             let mut applicability = Applicability::MachineApplicable;
 
-            let inner_span = match get_qpath_generic_tys(qpath).skip(1).next() {
+            let inner_span = match get_qpath_generic_tys(qpath_inner).next() {
                 Some(ty) => ty.span,
                 None => return false,
             };
diff --git a/tests/ui/rc_mutex.fixed b/tests/ui/rc_mutex.fixed
new file mode 100644
index 00000000000..b36b1d0914b
--- /dev/null
+++ b/tests/ui/rc_mutex.fixed
@@ -0,0 +1,28 @@
+// run-rustfix
+#![warn(clippy::rc_mutex)]
+#![allow(unused_imports)]
+#![allow(clippy::boxed_local, clippy::needless_pass_by_value)]
+#![allow(clippy::blacklisted_name, unused_variables, dead_code)]
+
+use std::cell::RefCell;
+use std::rc::Rc;
+use std::sync::Mutex;
+
+pub struct MyStruct {}
+
+pub struct SubT<T> {
+    foo: T,
+}
+
+pub enum MyEnum {
+    One,
+    Two,
+}
+
+pub fn test1<T>(foo: Rc<RefCell<T>>) {}
+
+pub fn test2(foo: Rc<RefCell<MyEnum>>) {}
+
+pub fn test3(foo: Rc<RefCell<SubT<usize>>>) {}
+
+fn main() {}
diff --git a/tests/ui/rc_mutex.rs b/tests/ui/rc_mutex.rs
new file mode 100644
index 00000000000..e6ec4549de9
--- /dev/null
+++ b/tests/ui/rc_mutex.rs
@@ -0,0 +1,28 @@
+// run-rustfix
+#![warn(clippy::rc_mutex)]
+#![allow(unused_imports)]
+#![allow(clippy::boxed_local, clippy::needless_pass_by_value)]
+#![allow(clippy::blacklisted_name, unused_variables, dead_code)]
+
+use std::cell::RefCell;
+use std::rc::Rc;
+use std::sync::Mutex;
+
+pub struct MyStruct {}
+
+pub struct SubT<T> {
+    foo: T,
+}
+
+pub enum MyEnum {
+    One,
+    Two,
+}
+
+pub fn test1<T>(foo: Rc<Mutex<T>>) {}
+
+pub fn test2(foo: Rc<Mutex<MyEnum>>) {}
+
+pub fn test3(foo: Rc<Mutex<SubT<usize>>>) {}
+
+fn main() {}
diff --git a/tests/ui/rc_mutex.stderr b/tests/ui/rc_mutex.stderr
new file mode 100644
index 00000000000..ad0340dcf55
--- /dev/null
+++ b/tests/ui/rc_mutex.stderr
@@ -0,0 +1,22 @@
+error: you seem to be trying to use `Rc<Mutex<T>>`. Consider using `Rc<RefCell<T>>`
+  --> $DIR/rc_mutex.rs:22:22
+   |
+LL | pub fn test1<T>(foo: Rc<Mutex<T>>) {}
+   |                      ^^^^^^^^^^^^ help: try: `Rc<RefCell<T>>`
+   |
+   = note: `-D clippy::rc-mutex` implied by `-D warnings`
+
+error: you seem to be trying to use `Rc<Mutex<T>>`. Consider using `Rc<RefCell<T>>`
+  --> $DIR/rc_mutex.rs:24:19
+   |
+LL | pub fn test2(foo: Rc<Mutex<MyEnum>>) {}
+   |                   ^^^^^^^^^^^^^^^^^ help: try: `Rc<RefCell<MyEnum>>`
+
+error: you seem to be trying to use `Rc<Mutex<T>>`. Consider using `Rc<RefCell<T>>`
+  --> $DIR/rc_mutex.rs:26:19
+   |
+LL | pub fn test3(foo: Rc<Mutex<SubT<usize>>>) {}
+   |                   ^^^^^^^^^^^^^^^^^^^^^^ help: try: `Rc<RefCell<SubT<usize>>>`
+
+error: aborting due to 3 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From a5ced1fc2bab6c23888a85b339f93dd4c6b40dac Mon Sep 17 00:00:00 2001
From: lyj <sjtu5140809011@gmail.com>
Date: Sat, 5 Jun 2021 20:53:24 +0800
Subject: rc_mutex use span_lint instead of span_lint_and_sugg

---
 clippy_lints/src/types/rc_mutex.rs | 28 ++++++----------------------
 tests/ui/rc_mutex.fixed            | 28 ----------------------------
 tests/ui/rc_mutex.rs               |  1 -
 tests/ui/rc_mutex.stderr           | 18 +++++++++---------
 4 files changed, 15 insertions(+), 60 deletions(-)
 delete mode 100644 tests/ui/rc_mutex.fixed

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types/rc_mutex.rs b/clippy_lints/src/types/rc_mutex.rs
index 122df01d153..e8109f12324 100644
--- a/clippy_lints/src/types/rc_mutex.rs
+++ b/clippy_lints/src/types/rc_mutex.rs
@@ -1,9 +1,7 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::{get_qpath_generic_tys, is_ty_param_diagnostic_item};
+use clippy_utils::diagnostics::span_lint;
+use clippy_utils::is_ty_param_diagnostic_item;
 use if_chain::if_chain;
-use rustc_errors::Applicability;
-use rustc_hir::{self as hir, def_id::DefId, QPath, TyKind};
+use rustc_hir::{self as hir, def_id::DefId, QPath};
 use rustc_lint::LateContext;
 use rustc_span::symbol::sym;
 
@@ -12,28 +10,14 @@ use super::RC_MUTEX;
 pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_>, def_id: DefId) -> bool {
     if_chain! {
         if cx.tcx.is_diagnostic_item(sym::Rc, def_id) ;
-        if let Some(ty) = is_ty_param_diagnostic_item(cx, qpath, sym!(mutex_type)) ;
-        if let TyKind::Path(ref qpath_inner)=ty.kind;
+        if let Some(_) = is_ty_param_diagnostic_item(cx, qpath, sym!(mutex_type)) ;
 
         then{
-            let mut applicability = Applicability::MachineApplicable;
-
-            let inner_span = match get_qpath_generic_tys(qpath_inner).next() {
-                Some(ty) => ty.span,
-                None => return false,
-            };
-
-            span_lint_and_sugg(
+            span_lint(
                 cx,
                 RC_MUTEX,
                 hir_ty.span,
-                "you seem to be trying to use `Rc<Mutex<T>>`. Consider using `Rc<RefCell<T>>`",
-                "try",
-                format!(
-                    "Rc<RefCell<{}>>",
-                    snippet_with_applicability(cx, inner_span, "..", &mut applicability)
-                ),
-                applicability,
+                "found `Rc<Mutex<_>>`. Consider using `Rc<RefCell<_>>` instead",
             );
             return true;
         }
diff --git a/tests/ui/rc_mutex.fixed b/tests/ui/rc_mutex.fixed
deleted file mode 100644
index b36b1d0914b..00000000000
--- a/tests/ui/rc_mutex.fixed
+++ /dev/null
@@ -1,28 +0,0 @@
-// run-rustfix
-#![warn(clippy::rc_mutex)]
-#![allow(unused_imports)]
-#![allow(clippy::boxed_local, clippy::needless_pass_by_value)]
-#![allow(clippy::blacklisted_name, unused_variables, dead_code)]
-
-use std::cell::RefCell;
-use std::rc::Rc;
-use std::sync::Mutex;
-
-pub struct MyStruct {}
-
-pub struct SubT<T> {
-    foo: T,
-}
-
-pub enum MyEnum {
-    One,
-    Two,
-}
-
-pub fn test1<T>(foo: Rc<RefCell<T>>) {}
-
-pub fn test2(foo: Rc<RefCell<MyEnum>>) {}
-
-pub fn test3(foo: Rc<RefCell<SubT<usize>>>) {}
-
-fn main() {}
diff --git a/tests/ui/rc_mutex.rs b/tests/ui/rc_mutex.rs
index e6ec4549de9..922ffbf8da1 100644
--- a/tests/ui/rc_mutex.rs
+++ b/tests/ui/rc_mutex.rs
@@ -1,4 +1,3 @@
-// run-rustfix
 #![warn(clippy::rc_mutex)]
 #![allow(unused_imports)]
 #![allow(clippy::boxed_local, clippy::needless_pass_by_value)]
diff --git a/tests/ui/rc_mutex.stderr b/tests/ui/rc_mutex.stderr
index ad0340dcf55..efd8abacd38 100644
--- a/tests/ui/rc_mutex.stderr
+++ b/tests/ui/rc_mutex.stderr
@@ -1,22 +1,22 @@
-error: you seem to be trying to use `Rc<Mutex<T>>`. Consider using `Rc<RefCell<T>>`
-  --> $DIR/rc_mutex.rs:22:22
+error: Found `Rc<Mutex<_>>`. Consider using `Rc<RefCell<_>>` instead
+  --> $DIR/rc_mutex.rs:21:22
    |
 LL | pub fn test1<T>(foo: Rc<Mutex<T>>) {}
-   |                      ^^^^^^^^^^^^ help: try: `Rc<RefCell<T>>`
+   |                      ^^^^^^^^^^^^
    |
    = note: `-D clippy::rc-mutex` implied by `-D warnings`
 
-error: you seem to be trying to use `Rc<Mutex<T>>`. Consider using `Rc<RefCell<T>>`
-  --> $DIR/rc_mutex.rs:24:19
+error: Found `Rc<Mutex<_>>`. Consider using `Rc<RefCell<_>>` instead
+  --> $DIR/rc_mutex.rs:23:19
    |
 LL | pub fn test2(foo: Rc<Mutex<MyEnum>>) {}
-   |                   ^^^^^^^^^^^^^^^^^ help: try: `Rc<RefCell<MyEnum>>`
+   |                   ^^^^^^^^^^^^^^^^^
 
-error: you seem to be trying to use `Rc<Mutex<T>>`. Consider using `Rc<RefCell<T>>`
-  --> $DIR/rc_mutex.rs:26:19
+error: Found `Rc<Mutex<_>>`. Consider using `Rc<RefCell<_>>` instead
+  --> $DIR/rc_mutex.rs:25:19
    |
 LL | pub fn test3(foo: Rc<Mutex<SubT<usize>>>) {}
-   |                   ^^^^^^^^^^^^^^^^^^^^^^ help: try: `Rc<RefCell<SubT<usize>>>`
+   |                   ^^^^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to 3 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 896c19e2cf314b4d1111afb3d89722a1e2878bd3 Mon Sep 17 00:00:00 2001
From: lyj <sjtu5140809011@gmail.com>
Date: Sat, 5 Jun 2021 21:28:52 +0800
Subject: rc_mutex: update doc

---
 clippy_lints/src/types/mod.rs      | 18 +++---------------
 clippy_lints/src/types/rc_mutex.rs |  2 +-
 tests/ui/rc_mutex.stderr           |  8 ++++----
 3 files changed, 8 insertions(+), 20 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types/mod.rs b/clippy_lints/src/types/mod.rs
index 07dec2de827..30b04e4174c 100644
--- a/clippy_lints/src/types/mod.rs
+++ b/clippy_lints/src/types/mod.rs
@@ -254,22 +254,10 @@ declare_clippy_lint! {
 declare_clippy_lint! {
     /// **What it does:** Checks for `Rc<Mutex<T>>`.
     ///
-    /// **Why is this bad?** `Rc<Mutex<T>>` may introduce a deadlock in single thread. Consider
-    /// using `Rc<RefCell<T>>` instead.
-    /// ```rust
-    /// fn main() {
-    ///     use std::rc::Rc;
-    ///     use std::sync::Mutex;
-    ///
-    ///     let a: Rc<Mutex<i32>> = Rc::new(Mutex::new(1));
-    ///     let a_clone = a.clone();
-    ///     let mut data = a.lock().unwrap();
-    ///     println!("{:?}", *a_clone.lock().unwrap());
-    ///     *data = 10;
-    ///  }
-    /// ```
+    /// **Why is this bad?** `Rc` is used in single thread and `Mutex` is used in multi thread.
+    /// Consider using `Rc<RefCell<T>>` in single thread or `Arc<Mutex<T>>` in multi thread.
     ///
-    /// **Known problems:** `Rc<RefCell<T>>` may panic in runtime.
+    /// **Known problems:** None.
     ///
     /// **Example:**
     /// ```rust,ignore
diff --git a/clippy_lints/src/types/rc_mutex.rs b/clippy_lints/src/types/rc_mutex.rs
index e8109f12324..bd7a0ee6408 100644
--- a/clippy_lints/src/types/rc_mutex.rs
+++ b/clippy_lints/src/types/rc_mutex.rs
@@ -17,7 +17,7 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_
                 cx,
                 RC_MUTEX,
                 hir_ty.span,
-                "found `Rc<Mutex<_>>`. Consider using `Rc<RefCell<_>>` instead",
+                "found `Rc<Mutex<_>>`. Consider using `Rc<RefCell<_>>` or `Arc<Mutex<_>>` instead",
             );
             return true;
         }
diff --git a/tests/ui/rc_mutex.stderr b/tests/ui/rc_mutex.stderr
index ab59337a960..c32780acf9f 100644
--- a/tests/ui/rc_mutex.stderr
+++ b/tests/ui/rc_mutex.stderr
@@ -1,4 +1,4 @@
-error: found `Rc<Mutex<_>>`. Consider using `Rc<RefCell<_>>` instead
+error: found `Rc<Mutex<_>>`. Consider using `Rc<RefCell<_>>` or `Arc<Mutex<_>>` instead
   --> $DIR/rc_mutex.rs:9:10
    |
 LL |     foo: Rc<Mutex<i32>>,
@@ -6,19 +6,19 @@ LL |     foo: Rc<Mutex<i32>>,
    |
    = note: `-D clippy::rc-mutex` implied by `-D warnings`
 
-error: found `Rc<Mutex<_>>`. Consider using `Rc<RefCell<_>>` instead
+error: found `Rc<Mutex<_>>`. Consider using `Rc<RefCell<_>>` or `Arc<Mutex<_>>` instead
   --> $DIR/rc_mutex.rs:21:22
    |
 LL | pub fn test1<T>(foo: Rc<Mutex<T>>) {}
    |                      ^^^^^^^^^^^^
 
-error: found `Rc<Mutex<_>>`. Consider using `Rc<RefCell<_>>` instead
+error: found `Rc<Mutex<_>>`. Consider using `Rc<RefCell<_>>` or `Arc<Mutex<_>>` instead
   --> $DIR/rc_mutex.rs:23:19
    |
 LL | pub fn test2(foo: Rc<Mutex<MyEnum>>) {}
    |                   ^^^^^^^^^^^^^^^^^
 
-error: found `Rc<Mutex<_>>`. Consider using `Rc<RefCell<_>>` instead
+error: found `Rc<Mutex<_>>`. Consider using `Rc<RefCell<_>>` or `Arc<Mutex<_>>` instead
   --> $DIR/rc_mutex.rs:25:19
    |
 LL | pub fn test3(foo: Rc<Mutex<SubT<usize>>>) {}
-- 
cgit 1.4.1-3-g733a5


From 96747c1a460a241c42a9aa262eeb37b910f06760 Mon Sep 17 00:00:00 2001
From: Bastian Kersting <bastian@cmbt.de>
Date: Sat, 5 Jun 2021 14:27:36 +0200
Subject: Enhance semicolon_if_nothing_returned according to #7324

---
 clippy_lints/src/semicolon_if_nothing_returned.rs | 20 +++++++++--
 clippy_utils/src/lib.rs                           |  5 +++
 tests/ui/semicolon_if_nothing_returned.rs         | 44 +++++++++++++++++++++++
 tests/ui/semicolon_if_nothing_returned.stderr     | 14 +++++++-
 4 files changed, 80 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/semicolon_if_nothing_returned.rs b/clippy_lints/src/semicolon_if_nothing_returned.rs
index 16e4d73851f..9e5d5b6e956 100644
--- a/clippy_lints/src/semicolon_if_nothing_returned.rs
+++ b/clippy_lints/src/semicolon_if_nothing_returned.rs
@@ -1,9 +1,9 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_macro_callsite;
-use clippy_utils::{in_macro, sugg};
+use clippy_utils::{get_parent_expr_for_hir, in_macro, spans_on_same_line, sugg};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
-use rustc_hir::{Block, ExprKind};
+use rustc_hir::{Block, BlockCheckMode, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
@@ -46,6 +46,22 @@ impl LateLintPass<'_> for SemicolonIfNothingReturned {
             if let snippet = snippet_with_macro_callsite(cx, expr.span, "}");
             if !snippet.ends_with('}');
             then {
+                // check if the block is inside a closure or an unsafe block and don't
+                // emit if the block is on the same line
+                if_chain! {
+                    if let Some(parent) = get_parent_expr_for_hir(cx, block.hir_id);
+
+                    if !matches!(block.rules, BlockCheckMode::DefaultBlock) ||
+                    matches!(parent.kind, ExprKind::Closure(..) | ExprKind::Block(..));
+
+                    if block.stmts.len() == 0;
+
+                    if spans_on_same_line(cx, parent.span, expr.span);
+                    then {
+                        return;
+                    }
+                }
+
                 // filter out the desugared `for` loop
                 if let ExprKind::DropTemps(..) = &expr.kind {
                     return;
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 769836aaf18..be625eb2655 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -820,6 +820,11 @@ fn line_span<T: LintContext>(cx: &T, span: Span) -> Span {
     Span::new(line_start, span.hi(), span.ctxt())
 }
 
+/// Checks if two spans begin on the same line.
+pub fn spans_on_same_line<T: LintContext>(cx: &T, left_span: Span, right_span: Span) -> bool {
+    line_span(cx, left_span).lo() == line_span(cx, right_span).lo()
+}
+
 /// Gets the parent node, if any.
 pub fn get_parent_node(tcx: TyCtxt<'_>, id: HirId) -> Option<Node<'_>> {
     tcx.hir().parent_iter(id).next().map(|(_, node)| node)
diff --git a/tests/ui/semicolon_if_nothing_returned.rs b/tests/ui/semicolon_if_nothing_returned.rs
index 0abe2cca267..79ba7402f1f 100644
--- a/tests/ui/semicolon_if_nothing_returned.rs
+++ b/tests/ui/semicolon_if_nothing_returned.rs
@@ -17,6 +17,24 @@ fn basic101(x: i32) {
     y = x + 1
 }
 
+#[rustfmt::skip]
+fn closure_error() {
+    let _d = || {
+        hello()
+    };
+}
+
+#[rustfmt::skip]
+fn unsafe_checks_error() {
+    use std::mem::MaybeUninit;
+    use std::ptr;
+
+    let mut s = MaybeUninit::<String>::uninit();
+    let _d = || unsafe { 
+        ptr::drop_in_place(s.as_mut_ptr()) 
+    };
+}
+
 // this is fine
 fn print_sum(a: i32, b: i32) {
     println!("{}", a + b);
@@ -53,3 +71,29 @@ fn loop_test(x: i32) {
         println!("{}", ext);
     }
 }
+
+fn closure() {
+    let _d = || hello();
+}
+
+#[rustfmt::skip]
+fn closure_block() {
+    let _d = || { hello() };
+}
+
+unsafe fn some_unsafe_op() {}
+unsafe fn some_other_unsafe_fn() {}
+
+fn do_something() {
+    unsafe { some_unsafe_op() };
+
+    unsafe { some_other_unsafe_fn() };
+}
+
+fn unsafe_checks() {
+    use std::mem::MaybeUninit;
+    use std::ptr;
+
+    let mut s = MaybeUninit::<String>::uninit();
+    let _d = || unsafe { ptr::drop_in_place(s.as_mut_ptr()) };
+}
diff --git a/tests/ui/semicolon_if_nothing_returned.stderr b/tests/ui/semicolon_if_nothing_returned.stderr
index b73f8967538..e88ebe2ad35 100644
--- a/tests/ui/semicolon_if_nothing_returned.stderr
+++ b/tests/ui/semicolon_if_nothing_returned.stderr
@@ -18,5 +18,17 @@ error: consider adding a `;` to the last statement for consistent formatting
 LL |     y = x + 1
    |     ^^^^^^^^^ help: add a `;` here: `y = x + 1;`
 
-error: aborting due to 3 previous errors
+error: consider adding a `;` to the last statement for consistent formatting
+  --> $DIR/semicolon_if_nothing_returned.rs:23:9
+   |
+LL |         hello()
+   |         ^^^^^^^ help: add a `;` here: `hello();`
+
+error: consider adding a `;` to the last statement for consistent formatting
+  --> $DIR/semicolon_if_nothing_returned.rs:34:9
+   |
+LL |         ptr::drop_in_place(s.as_mut_ptr()) 
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: add a `;` here: `ptr::drop_in_place(s.as_mut_ptr());`
+
+error: aborting due to 5 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 790888d520859543cf8fce8b5a3226d71e719539 Mon Sep 17 00:00:00 2001
From: Bastian Kersting <bastian@cmbt.de>
Date: Sat, 5 Jun 2021 15:38:38 +0200
Subject: Fixed failing tests

---
 clippy_lints/src/semicolon_if_nothing_returned.rs | 38 +++++++++++++----------
 1 file changed, 22 insertions(+), 16 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/semicolon_if_nothing_returned.rs b/clippy_lints/src/semicolon_if_nothing_returned.rs
index 9e5d5b6e956..3698e548bd2 100644
--- a/clippy_lints/src/semicolon_if_nothing_returned.rs
+++ b/clippy_lints/src/semicolon_if_nothing_returned.rs
@@ -3,6 +3,7 @@ use clippy_utils::source::snippet_with_macro_callsite;
 use clippy_utils::{get_parent_expr_for_hir, in_macro, spans_on_same_line, sugg};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
+use rustc_hir::Expr;
 use rustc_hir::{Block, BlockCheckMode, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -45,23 +46,8 @@ impl LateLintPass<'_> for SemicolonIfNothingReturned {
             if t_expr.is_unit();
             if let snippet = snippet_with_macro_callsite(cx, expr.span, "}");
             if !snippet.ends_with('}');
+            if !check_if_inside_block_on_same_line(cx, block, expr);
             then {
-                // check if the block is inside a closure or an unsafe block and don't
-                // emit if the block is on the same line
-                if_chain! {
-                    if let Some(parent) = get_parent_expr_for_hir(cx, block.hir_id);
-
-                    if !matches!(block.rules, BlockCheckMode::DefaultBlock) ||
-                    matches!(parent.kind, ExprKind::Closure(..) | ExprKind::Block(..));
-
-                    if block.stmts.len() == 0;
-
-                    if spans_on_same_line(cx, parent.span, expr.span);
-                    then {
-                        return;
-                    }
-                }
-
                 // filter out the desugared `for` loop
                 if let ExprKind::DropTemps(..) = &expr.kind {
                     return;
@@ -82,3 +68,23 @@ impl LateLintPass<'_> for SemicolonIfNothingReturned {
         }
     }
 }
+
+/// Check if this block is inside a closure or an unsafe block or a normal on the same line.
+fn check_if_inside_block_on_same_line<'tcx>(
+    cx: &LateContext<'tcx>,
+    block: &'tcx Block<'tcx>,
+    last_expr: &'tcx Expr<'_>,
+) -> bool {
+    if_chain! {
+        if let Some(parent) = get_parent_expr_for_hir(cx, block.hir_id);
+
+        if !matches!(block.rules, BlockCheckMode::DefaultBlock) ||
+        matches!(parent.kind, ExprKind::Closure(..) | ExprKind::Block(..));
+
+        if block.stmts.is_empty();
+        then {
+            return spans_on_same_line(cx, parent.span, last_expr.span);
+        }
+    }
+    false
+}
-- 
cgit 1.4.1-3-g733a5


From d7a380e4b9808cd62d3774f027ecf2395ef2b286 Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Sat, 5 Jun 2021 15:11:44 +0900
Subject: Fix FP in `default_numeric_fallback` with external macro expansion

---
 clippy_lints/src/default_numeric_fallback.rs |  4 +-
 tests/ui/auxiliary/macro_rules.rs            |  7 ++++
 tests/ui/default_numeric_fallback.rs         | 23 +++++++++++
 tests/ui/default_numeric_fallback.stderr     | 61 ++++++++++++++++------------
 4 files changed, 69 insertions(+), 26 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/default_numeric_fallback.rs b/clippy_lints/src/default_numeric_fallback.rs
index 759f7d4062d..a125376bffa 100644
--- a/clippy_lints/src/default_numeric_fallback.rs
+++ b/clippy_lints/src/default_numeric_fallback.rs
@@ -7,9 +7,10 @@ use rustc_hir::{
     intravisit::{walk_expr, walk_stmt, NestedVisitorMap, Visitor},
     Body, Expr, ExprKind, HirId, Lit, Stmt, StmtKind,
 };
-use rustc_lint::{LateContext, LateLintPass};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::{
     hir::map::Map,
+    lint::in_external_macro,
     ty::{self, FloatTy, IntTy, PolyFnSig, Ty},
 };
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -73,6 +74,7 @@ impl<'a, 'tcx> NumericFallbackVisitor<'a, 'tcx> {
     /// Check whether a passed literal has potential to cause fallback or not.
     fn check_lit(&self, lit: &Lit, lit_ty: Ty<'tcx>) {
         if_chain! {
+                if !in_external_macro(self.cx.sess(), lit.span);
                 if let Some(ty_bound) = self.ty_bounds.last();
                 if matches!(lit.node,
                             LitKind::Int(_, LitIntType::Unsuffixed) | LitKind::Float(_, LitFloatType::Unsuffixed));
diff --git a/tests/ui/auxiliary/macro_rules.rs b/tests/ui/auxiliary/macro_rules.rs
index d4470d3f407..170955e726c 100644
--- a/tests/ui/auxiliary/macro_rules.rs
+++ b/tests/ui/auxiliary/macro_rules.rs
@@ -106,3 +106,10 @@ macro_rules! field_reassign_with_default {
         }
     };
 }
+
+#[macro_export]
+macro_rules! default_numeric_fallback {
+    () => {
+        let x = 22;
+    };
+}
diff --git a/tests/ui/default_numeric_fallback.rs b/tests/ui/default_numeric_fallback.rs
index 43468872db0..c0625fd1b75 100644
--- a/tests/ui/default_numeric_fallback.rs
+++ b/tests/ui/default_numeric_fallback.rs
@@ -1,3 +1,5 @@
+// aux-build:macro_rules.rs
+
 #![warn(clippy::default_numeric_fallback)]
 #![allow(unused)]
 #![allow(clippy::never_loop)]
@@ -5,6 +7,9 @@
 #![allow(clippy::unnecessary_operation)]
 #![allow(clippy::branches_sharing_code)]
 
+#[macro_use]
+extern crate macro_rules;
+
 mod basic_expr {
     fn test() {
         // Should lint unsuffixed literals typed `i32`.
@@ -133,4 +138,22 @@ mod method_calls {
     }
 }
 
+mod in_macro {
+    macro_rules! internal_macro {
+        () => {
+            let x = 22;
+        };
+    }
+
+    // Should lint in internal macro.
+    fn internal() {
+        internal_macro!();
+    }
+
+    // Should NOT lint in external macro.
+    fn external() {
+        default_numeric_fallback!();
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/default_numeric_fallback.stderr b/tests/ui/default_numeric_fallback.stderr
index d1c4c8203dd..5862cd936ac 100644
--- a/tests/ui/default_numeric_fallback.stderr
+++ b/tests/ui/default_numeric_fallback.stderr
@@ -1,5 +1,5 @@
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:11:17
+  --> $DIR/default_numeric_fallback.rs:16:17
    |
 LL |         let x = 22;
    |                 ^^ help: consider adding suffix: `22_i32`
@@ -7,142 +7,153 @@ LL |         let x = 22;
    = note: `-D clippy::default-numeric-fallback` implied by `-D warnings`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:12:18
+  --> $DIR/default_numeric_fallback.rs:17:18
    |
 LL |         let x = [1, 2, 3];
    |                  ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:12:21
+  --> $DIR/default_numeric_fallback.rs:17:21
    |
 LL |         let x = [1, 2, 3];
    |                     ^ help: consider adding suffix: `2_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:12:24
+  --> $DIR/default_numeric_fallback.rs:17:24
    |
 LL |         let x = [1, 2, 3];
    |                        ^ help: consider adding suffix: `3_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:13:28
+  --> $DIR/default_numeric_fallback.rs:18:28
    |
 LL |         let x = if true { (1, 2) } else { (3, 4) };
    |                            ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:13:31
+  --> $DIR/default_numeric_fallback.rs:18:31
    |
 LL |         let x = if true { (1, 2) } else { (3, 4) };
    |                               ^ help: consider adding suffix: `2_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:13:44
+  --> $DIR/default_numeric_fallback.rs:18:44
    |
 LL |         let x = if true { (1, 2) } else { (3, 4) };
    |                                            ^ help: consider adding suffix: `3_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:13:47
+  --> $DIR/default_numeric_fallback.rs:18:47
    |
 LL |         let x = if true { (1, 2) } else { (3, 4) };
    |                                               ^ help: consider adding suffix: `4_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:14:23
+  --> $DIR/default_numeric_fallback.rs:19:23
    |
 LL |         let x = match 1 {
    |                       ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:15:13
+  --> $DIR/default_numeric_fallback.rs:20:13
    |
 LL |             1 => 1,
    |             ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:15:18
+  --> $DIR/default_numeric_fallback.rs:20:18
    |
 LL |             1 => 1,
    |                  ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:16:18
+  --> $DIR/default_numeric_fallback.rs:21:18
    |
 LL |             _ => 2,
    |                  ^ help: consider adding suffix: `2_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:20:17
+  --> $DIR/default_numeric_fallback.rs:25:17
    |
 LL |         let x = 0.12;
    |                 ^^^^ help: consider adding suffix: `0.12_f64`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:38:21
+  --> $DIR/default_numeric_fallback.rs:43:21
    |
 LL |             let y = 1;
    |                     ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:46:21
+  --> $DIR/default_numeric_fallback.rs:51:21
    |
 LL |             let y = 1;
    |                     ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:52:21
+  --> $DIR/default_numeric_fallback.rs:57:21
    |
 LL |             let y = 1;
    |                     ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:64:9
+  --> $DIR/default_numeric_fallback.rs:69:9
    |
 LL |         1
    |         ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:70:27
+  --> $DIR/default_numeric_fallback.rs:75:27
    |
 LL |         let f = || -> _ { 1 };
    |                           ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:74:29
+  --> $DIR/default_numeric_fallback.rs:79:29
    |
 LL |         let f = || -> i32 { 1 };
    |                             ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:88:21
+  --> $DIR/default_numeric_fallback.rs:93:21
    |
 LL |         generic_arg(1);
    |                     ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:91:32
+  --> $DIR/default_numeric_fallback.rs:96:32
    |
 LL |         let x: _ = generic_arg(1);
    |                                ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:109:28
+  --> $DIR/default_numeric_fallback.rs:114:28
    |
 LL |         GenericStruct { x: 1 };
    |                            ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:112:36
+  --> $DIR/default_numeric_fallback.rs:117:36
    |
 LL |         let _ = GenericStruct { x: 1 };
    |                                    ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:132:23
+  --> $DIR/default_numeric_fallback.rs:137:23
    |
 LL |         s.generic_arg(1);
    |                       ^ help: consider adding suffix: `1_i32`
 
-error: aborting due to 24 previous errors
+error: default numeric fallback might occur
+  --> $DIR/default_numeric_fallback.rs:144:21
+   |
+LL |             let x = 22;
+   |                     ^^ help: consider adding suffix: `22_i32`
+...
+LL |         internal_macro!();
+   |         ------------------ in this macro invocation
+   |
+   = note: this error originates in the macro `internal_macro` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: aborting due to 25 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 6bf8303c4768e91deb3ba02f4c8a846166b5600b Mon Sep 17 00:00:00 2001
From: Bastian Kersting <bastian@cmbt.de>
Date: Mon, 7 Jun 2021 21:44:04 +0200
Subject: Refactored the check for two spans on the same line

---
 clippy_lints/src/semicolon_if_nothing_returned.rs | 6 ++++--
 clippy_utils/src/lib.rs                           | 5 -----
 2 files changed, 4 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/semicolon_if_nothing_returned.rs b/clippy_lints/src/semicolon_if_nothing_returned.rs
index 3698e548bd2..eff6cdf36b4 100644
--- a/clippy_lints/src/semicolon_if_nothing_returned.rs
+++ b/clippy_lints/src/semicolon_if_nothing_returned.rs
@@ -1,6 +1,7 @@
+use crate::rustc_lint::LintContext;
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_macro_callsite;
-use clippy_utils::{get_parent_expr_for_hir, in_macro, spans_on_same_line, sugg};
+use clippy_utils::{get_parent_expr_for_hir, in_macro, sugg};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::Expr;
@@ -83,7 +84,8 @@ fn check_if_inside_block_on_same_line<'tcx>(
 
         if block.stmts.is_empty();
         then {
-            return spans_on_same_line(cx, parent.span, last_expr.span);
+            let source_map = cx.sess().source_map();
+            return !source_map.is_multiline(parent.span.to(last_expr.span));
         }
     }
     false
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index be625eb2655..769836aaf18 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -820,11 +820,6 @@ fn line_span<T: LintContext>(cx: &T, span: Span) -> Span {
     Span::new(line_start, span.hi(), span.ctxt())
 }
 
-/// Checks if two spans begin on the same line.
-pub fn spans_on_same_line<T: LintContext>(cx: &T, left_span: Span, right_span: Span) -> bool {
-    line_span(cx, left_span).lo() == line_span(cx, right_span).lo()
-}
-
 /// Gets the parent node, if any.
 pub fn get_parent_node(tcx: TyCtxt<'_>, id: HirId) -> Option<Node<'_>> {
     tcx.hir().parent_iter(id).next().map(|(_, node)| node)
-- 
cgit 1.4.1-3-g733a5


From 967d815a426dd16354dd42c96ad4b3f2eb036f09 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Mon, 7 Jun 2021 22:21:56 +0200
Subject: Extracting `is_expr_identity_function` into `clippy_utils` for
 reusability

---
 clippy_lints/src/map_identity.rs | 54 ++--------------------------------------
 clippy_utils/src/lib.rs          | 54 ++++++++++++++++++++++++++++++++++++++++
 2 files changed, 56 insertions(+), 52 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/map_identity.rs b/clippy_lints/src/map_identity.rs
index 41cda23510e..9bcb010ff6d 100644
--- a/clippy_lints/src/map_identity.rs
+++ b/clippy_lints/src/map_identity.rs
@@ -1,9 +1,9 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{is_adjusted, is_qpath_def_path, is_trait_method, match_var, paths, remove_blocks};
+use clippy_utils::{is_expr_identity_function, is_trait_method};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
-use rustc_hir::{Body, Expr, ExprKind, Pat, PatKind, QPath, StmtKind};
+use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::sym;
@@ -74,53 +74,3 @@ fn get_map_argument<'a>(cx: &LateContext<'_>, expr: &'a Expr<'a>) -> Option<&'a
         }
     }
 }
-
-/// Checks if an expression represents the identity function
-/// Only examines closures and `std::convert::identity`
-fn is_expr_identity_function(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-    match expr.kind {
-        ExprKind::Closure(_, _, body_id, _, _) => is_body_identity_function(cx, cx.tcx.hir().body(body_id)),
-        ExprKind::Path(ref path) => is_qpath_def_path(cx, path, expr.hir_id, &paths::CONVERT_IDENTITY),
-        _ => false,
-    }
-}
-
-/// Checks if a function's body represents the identity function
-/// Looks for bodies of the form `|x| x`, `|x| return x`, `|x| { return x }` or `|x| {
-/// return x; }`
-fn is_body_identity_function(cx: &LateContext<'_>, func: &Body<'_>) -> bool {
-    let params = func.params;
-    let body = remove_blocks(&func.value);
-
-    // if there's less/more than one parameter, then it is not the identity function
-    if params.len() != 1 {
-        return false;
-    }
-
-    match body.kind {
-        ExprKind::Path(QPath::Resolved(None, _)) => match_expr_param(cx, body, params[0].pat),
-        ExprKind::Ret(Some(ret_val)) => match_expr_param(cx, ret_val, params[0].pat),
-        ExprKind::Block(block, _) => {
-            if_chain! {
-                if block.stmts.len() == 1;
-                if let StmtKind::Semi(expr) | StmtKind::Expr(expr) = block.stmts[0].kind;
-                if let ExprKind::Ret(Some(ret_val)) = expr.kind;
-                then {
-                    match_expr_param(cx, ret_val, params[0].pat)
-                } else {
-                    false
-                }
-            }
-        },
-        _ => false,
-    }
-}
-
-/// Returns true iff an expression returns the same thing as a parameter's pattern
-fn match_expr_param(cx: &LateContext<'_>, expr: &Expr<'_>, pat: &Pat<'_>) -> bool {
-    if let PatKind::Binding(_, _, ident, _) = pat.kind {
-        match_var(expr, ident.name) && !(cx.typeck_results().hir_owner == expr.hir_id.owner && is_adjusted(cx, expr))
-    } else {
-        false
-    }
-}
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 769836aaf18..a765abe6b76 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -1399,6 +1399,60 @@ pub fn is_must_use_func_call(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
     did.map_or(false, |did| must_use_attr(cx.tcx.get_attrs(did)).is_some())
 }
 
+/// Checks if an expression represents the identity function
+/// Only examines closures and `std::convert::identity`
+pub fn is_expr_identity_function(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+    /// Returns true if the expression is a binding to the given pattern
+    fn is_expr_pat_binding(cx: &LateContext<'_>, expr: &Expr<'_>, pat: &Pat<'_>) -> bool {
+        if let PatKind::Binding(_, _, ident, _) = pat.kind {
+            if match_var(expr, ident.name) {
+                return !(cx.typeck_results().hir_owner == expr.hir_id.owner && is_adjusted(cx, expr));
+            }
+        }
+
+        false
+    }
+
+    /// Checks if a function's body represents the identity function. Looks for bodies of the form:
+    /// * `|x| x`
+    /// * `|x| return x`
+    /// * `|x| { return x }`
+    /// * `|x| { return x; }`
+    fn is_body_identity_function(cx: &LateContext<'_>, func: &Body<'_>) -> bool {
+        let body = remove_blocks(&func.value);
+
+        let value_pat = if let [value_param] = func.params {
+            value_param.pat
+        } else {
+            return false;
+        };
+
+        match body.kind {
+            ExprKind::Path(QPath::Resolved(None, _)) => is_expr_pat_binding(cx, body, value_pat),
+            ExprKind::Ret(Some(ret_val)) => is_expr_pat_binding(cx, ret_val, value_pat),
+            ExprKind::Block(block, _) => {
+                if_chain! {
+                    if let &[block_stmt] = &block.stmts;
+                    if let StmtKind::Semi(expr) | StmtKind::Expr(expr) = block_stmt.kind;
+                    if let ExprKind::Ret(Some(ret_val)) = expr.kind;
+                    then {
+                        is_expr_pat_binding(cx, ret_val, value_pat)
+                    } else {
+                        false
+                    }
+                }
+            },
+            _ => false,
+        }
+    }
+
+    match expr.kind {
+        ExprKind::Closure(_, _, body_id, _, _) => is_body_identity_function(cx, cx.tcx.hir().body(body_id)),
+        ExprKind::Path(ref path) => is_qpath_def_path(cx, path, expr.hir_id, &paths::CONVERT_IDENTITY),
+        _ => false,
+    }
+}
+
 /// Gets the node where an expression is either used, or it's type is unified with another branch.
 pub fn get_expr_use_or_unification_node(tcx: TyCtxt<'tcx>, expr: &Expr<'_>) -> Option<Node<'tcx>> {
     let map = tcx.hir();
-- 
cgit 1.4.1-3-g733a5


From bb3b58cfccdfbc4f95a2f03dc800aa87fd3fdd2c Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Mon, 7 Jun 2021 23:10:42 +0200
Subject: Reuse `is_expr_identity_function` for `flat_map_identity`

---
 clippy_lints/src/methods/flat_map_identity.rs | 44 +++++++--------------------
 tests/ui/flat_map_identity.fixed              |  5 ++-
 tests/ui/flat_map_identity.rs                 |  5 ++-
 tests/ui/flat_map_identity.stderr             | 12 ++++++--
 4 files changed, 28 insertions(+), 38 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/flat_map_identity.rs b/clippy_lints/src/methods/flat_map_identity.rs
index 25f8434cb94..6f911d79d0b 100644
--- a/clippy_lints/src/methods/flat_map_identity.rs
+++ b/clippy_lints/src/methods/flat_map_identity.rs
@@ -1,6 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::{is_expr_path_def_path, is_trait_method, paths};
-use if_chain::if_chain;
+use clippy_utils::{is_expr_identity_function, is_trait_method};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
@@ -15,36 +14,15 @@ pub(super) fn check<'tcx>(
     flat_map_arg: &'tcx hir::Expr<'_>,
     flat_map_span: Span,
 ) {
-    if is_trait_method(cx, expr, sym::Iterator) {
-        let apply_lint = |message: &str| {
-            span_lint_and_sugg(
-                cx,
-                FLAT_MAP_IDENTITY,
-                flat_map_span.with_hi(expr.span.hi()),
-                message,
-                "try",
-                "flatten()".to_string(),
-                Applicability::MachineApplicable,
-            );
-        };
-
-        if_chain! {
-            if let hir::ExprKind::Closure(_, _, body_id, _, _) = flat_map_arg.kind;
-            let body = cx.tcx.hir().body(body_id);
-
-            if let hir::PatKind::Binding(_, _, binding_ident, _) = body.params[0].pat.kind;
-            if let hir::ExprKind::Path(hir::QPath::Resolved(_, path)) = body.value.kind;
-
-            if path.segments.len() == 1;
-            if path.segments[0].ident.name == binding_ident.name;
-
-            then {
-                apply_lint("called `flat_map(|x| x)` on an `Iterator`");
-            }
-        }
-
-        if is_expr_path_def_path(cx, flat_map_arg, &paths::CONVERT_IDENTITY) {
-            apply_lint("called `flat_map(std::convert::identity)` on an `Iterator`");
-        }
+    if is_trait_method(cx, expr, sym::Iterator) && is_expr_identity_function(cx, flat_map_arg) {
+        span_lint_and_sugg(
+            cx,
+            FLAT_MAP_IDENTITY,
+            flat_map_span.with_hi(expr.span.hi()),
+            "use of `flat_map` with an identity function",
+            "try",
+            "flatten()".to_string(),
+            Applicability::MachineApplicable,
+        );
     }
 }
diff --git a/tests/ui/flat_map_identity.fixed b/tests/ui/flat_map_identity.fixed
index dfe3bd47e13..1f4b880ef5b 100644
--- a/tests/ui/flat_map_identity.fixed
+++ b/tests/ui/flat_map_identity.fixed
@@ -1,6 +1,6 @@
 // run-rustfix
 
-#![allow(unused_imports)]
+#![allow(unused_imports, clippy::needless_return)]
 #![warn(clippy::flat_map_identity)]
 
 use std::convert;
@@ -11,4 +11,7 @@ fn main() {
 
     let iterator = [[0, 1], [2, 3], [4, 5]].iter();
     let _ = iterator.flatten();
+
+    let iterator = [[0, 1], [2, 3], [4, 5]].iter();
+    let _ = iterator.flatten();
 }
diff --git a/tests/ui/flat_map_identity.rs b/tests/ui/flat_map_identity.rs
index 393b9569255..de14a06d4e6 100644
--- a/tests/ui/flat_map_identity.rs
+++ b/tests/ui/flat_map_identity.rs
@@ -1,6 +1,6 @@
 // run-rustfix
 
-#![allow(unused_imports)]
+#![allow(unused_imports, clippy::needless_return)]
 #![warn(clippy::flat_map_identity)]
 
 use std::convert;
@@ -11,4 +11,7 @@ fn main() {
 
     let iterator = [[0, 1], [2, 3], [4, 5]].iter();
     let _ = iterator.flat_map(convert::identity);
+
+    let iterator = [[0, 1], [2, 3], [4, 5]].iter();
+    let _ = iterator.flat_map(|x| return x);
 }
diff --git a/tests/ui/flat_map_identity.stderr b/tests/ui/flat_map_identity.stderr
index e4686ae5a54..e776c9fdf51 100644
--- a/tests/ui/flat_map_identity.stderr
+++ b/tests/ui/flat_map_identity.stderr
@@ -1,4 +1,4 @@
-error: called `flat_map(|x| x)` on an `Iterator`
+error: use of `flat_map` with an identity function
   --> $DIR/flat_map_identity.rs:10:22
    |
 LL |     let _ = iterator.flat_map(|x| x);
@@ -6,11 +6,17 @@ LL |     let _ = iterator.flat_map(|x| x);
    |
    = note: `-D clippy::flat-map-identity` implied by `-D warnings`
 
-error: called `flat_map(std::convert::identity)` on an `Iterator`
+error: use of `flat_map` with an identity function
   --> $DIR/flat_map_identity.rs:13:22
    |
 LL |     let _ = iterator.flat_map(convert::identity);
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `flatten()`
 
-error: aborting due to 2 previous errors
+error: use of `flat_map` with an identity function
+  --> $DIR/flat_map_identity.rs:16:22
+   |
+LL |     let _ = iterator.flat_map(|x| return x);
+   |                      ^^^^^^^^^^^^^^^^^^^^^^ help: try: `flatten()`
+
+error: aborting due to 3 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 9e54ce865c67af65370e1ec3822742a22fd20dfe Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Mon, 7 Jun 2021 23:31:17 +0200
Subject: Reuse `is_expr_identity_function` for `filter_map_identity`

---
 clippy_lints/src/methods/filter_map_identity.rs | 40 +++++++------------------
 tests/ui/filter_map_identity.fixed              |  5 +++-
 tests/ui/filter_map_identity.rs                 |  5 +++-
 tests/ui/filter_map_identity.stderr             | 14 ++++++---
 4 files changed, 29 insertions(+), 35 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/filter_map_identity.rs b/clippy_lints/src/methods/filter_map_identity.rs
index 403fe8d3546..d1b5e945dfd 100644
--- a/clippy_lints/src/methods/filter_map_identity.rs
+++ b/clippy_lints/src/methods/filter_map_identity.rs
@@ -1,6 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::{is_expr_path_def_path, is_trait_method, path_to_local_id, paths};
-use if_chain::if_chain;
+use clippy_utils::{is_expr_identity_function, is_trait_method};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
@@ -9,32 +8,15 @@ use rustc_span::{source_map::Span, sym};
 use super::FILTER_MAP_IDENTITY;
 
 pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, filter_map_arg: &hir::Expr<'_>, filter_map_span: Span) {
-    if is_trait_method(cx, expr, sym::Iterator) {
-        let apply_lint = |message: &str| {
-            span_lint_and_sugg(
-                cx,
-                FILTER_MAP_IDENTITY,
-                filter_map_span.with_hi(expr.span.hi()),
-                message,
-                "try",
-                "flatten()".to_string(),
-                Applicability::MachineApplicable,
-            );
-        };
-
-        if_chain! {
-            if let hir::ExprKind::Closure(_, _, body_id, _, _) = filter_map_arg.kind;
-            let body = cx.tcx.hir().body(body_id);
-
-            if let hir::PatKind::Binding(_, binding_id, ..) = body.params[0].pat.kind;
-            if path_to_local_id(&body.value, binding_id);
-            then {
-                apply_lint("called `filter_map(|x| x)` on an `Iterator`");
-            }
-        }
-
-        if is_expr_path_def_path(cx, filter_map_arg, &paths::CONVERT_IDENTITY) {
-            apply_lint("called `filter_map(std::convert::identity)` on an `Iterator`");
-        }
+    if is_trait_method(cx, expr, sym::Iterator) && is_expr_identity_function(cx, filter_map_arg) {
+        span_lint_and_sugg(
+            cx,
+            FILTER_MAP_IDENTITY,
+            filter_map_span.with_hi(expr.span.hi()),
+            "use of `filter_map` with an identity function",
+            "try",
+            "flatten()".to_string(),
+            Applicability::MachineApplicable,
+        );
     }
 }
diff --git a/tests/ui/filter_map_identity.fixed b/tests/ui/filter_map_identity.fixed
index 23ce28d8e9b..a5860aa49b3 100644
--- a/tests/ui/filter_map_identity.fixed
+++ b/tests/ui/filter_map_identity.fixed
@@ -1,6 +1,6 @@
 // run-rustfix
 
-#![allow(unused_imports)]
+#![allow(unused_imports, clippy::needless_return)]
 #![warn(clippy::filter_map_identity)]
 
 fn main() {
@@ -13,4 +13,7 @@ fn main() {
     use std::convert::identity;
     let iterator = vec![Some(1), None, Some(2)].into_iter();
     let _ = iterator.flatten();
+
+    let iterator = vec![Some(1), None, Some(2)].into_iter();
+    let _ = iterator.flatten();
 }
diff --git a/tests/ui/filter_map_identity.rs b/tests/ui/filter_map_identity.rs
index e698df13eea..7e998b9cdf7 100644
--- a/tests/ui/filter_map_identity.rs
+++ b/tests/ui/filter_map_identity.rs
@@ -1,6 +1,6 @@
 // run-rustfix
 
-#![allow(unused_imports)]
+#![allow(unused_imports, clippy::needless_return)]
 #![warn(clippy::filter_map_identity)]
 
 fn main() {
@@ -13,4 +13,7 @@ fn main() {
     use std::convert::identity;
     let iterator = vec![Some(1), None, Some(2)].into_iter();
     let _ = iterator.filter_map(identity);
+
+    let iterator = vec![Some(1), None, Some(2)].into_iter();
+    let _ = iterator.filter_map(|x| return x);
 }
diff --git a/tests/ui/filter_map_identity.stderr b/tests/ui/filter_map_identity.stderr
index 596a6320608..43c9fdca4fb 100644
--- a/tests/ui/filter_map_identity.stderr
+++ b/tests/ui/filter_map_identity.stderr
@@ -1,4 +1,4 @@
-error: called `filter_map(|x| x)` on an `Iterator`
+error: use of `filter_map` with an identity function
   --> $DIR/filter_map_identity.rs:8:22
    |
 LL |     let _ = iterator.filter_map(|x| x);
@@ -6,17 +6,23 @@ LL |     let _ = iterator.filter_map(|x| x);
    |
    = note: `-D clippy::filter-map-identity` implied by `-D warnings`
 
-error: called `filter_map(std::convert::identity)` on an `Iterator`
+error: use of `filter_map` with an identity function
   --> $DIR/filter_map_identity.rs:11:22
    |
 LL |     let _ = iterator.filter_map(std::convert::identity);
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `flatten()`
 
-error: called `filter_map(std::convert::identity)` on an `Iterator`
+error: use of `filter_map` with an identity function
   --> $DIR/filter_map_identity.rs:15:22
    |
 LL |     let _ = iterator.filter_map(identity);
    |                      ^^^^^^^^^^^^^^^^^^^^ help: try: `flatten()`
 
-error: aborting due to 3 previous errors
+error: use of `filter_map` with an identity function
+  --> $DIR/filter_map_identity.rs:18:22
+   |
+LL |     let _ = iterator.filter_map(|x| return x);
+   |                      ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `flatten()`
+
+error: aborting due to 4 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 5336f88403aae270e1e8bbf0aee31707311c590f Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Tue, 8 Jun 2021 00:14:43 +0200
Subject: Move `map_identity` into the `methods` module

---
 clippy_lints/src/lib.rs                  |  8 ++--
 clippy_lints/src/map_identity.rs         | 76 --------------------------------
 clippy_lints/src/methods/map_identity.rs | 38 ++++++++++++++++
 clippy_lints/src/methods/mod.rs          | 26 +++++++++++
 4 files changed, 67 insertions(+), 81 deletions(-)
 delete mode 100644 clippy_lints/src/map_identity.rs
 create mode 100644 clippy_lints/src/methods/map_identity.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index e7dd3952b3a..c6d9b378603 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -254,7 +254,6 @@ mod manual_strip;
 mod manual_unwrap_or;
 mod map_clone;
 mod map_err_ignore;
-mod map_identity;
 mod map_unit_fn;
 mod match_on_vec_items;
 mod matches;
@@ -705,7 +704,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         manual_unwrap_or::MANUAL_UNWRAP_OR,
         map_clone::MAP_CLONE,
         map_err_ignore::MAP_ERR_IGNORE,
-        map_identity::MAP_IDENTITY,
         map_unit_fn::OPTION_MAP_UNIT_FN,
         map_unit_fn::RESULT_MAP_UNIT_FN,
         match_on_vec_items::MATCH_ON_VEC_ITEMS,
@@ -765,6 +763,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         methods::MANUAL_STR_REPEAT,
         methods::MAP_COLLECT_RESULT_UNIT,
         methods::MAP_FLATTEN,
+        methods::MAP_IDENTITY,
         methods::MAP_UNWRAP_OR,
         methods::NEW_RET_NO_SELF,
         methods::OK_EXPECT,
@@ -1260,7 +1259,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(manual_strip::MANUAL_STRIP),
         LintId::of(manual_unwrap_or::MANUAL_UNWRAP_OR),
         LintId::of(map_clone::MAP_CLONE),
-        LintId::of(map_identity::MAP_IDENTITY),
         LintId::of(map_unit_fn::OPTION_MAP_UNIT_FN),
         LintId::of(map_unit_fn::RESULT_MAP_UNIT_FN),
         LintId::of(matches::INFALLIBLE_DESTRUCTURING_MATCH),
@@ -1301,6 +1299,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(methods::MANUAL_SATURATING_ARITHMETIC),
         LintId::of(methods::MANUAL_STR_REPEAT),
         LintId::of(methods::MAP_COLLECT_RESULT_UNIT),
+        LintId::of(methods::MAP_IDENTITY),
         LintId::of(methods::NEW_RET_NO_SELF),
         LintId::of(methods::OK_EXPECT),
         LintId::of(methods::OPTION_AS_REF_DEREF),
@@ -1586,7 +1585,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(loops::WHILE_LET_LOOP),
         LintId::of(manual_strip::MANUAL_STRIP),
         LintId::of(manual_unwrap_or::MANUAL_UNWRAP_OR),
-        LintId::of(map_identity::MAP_IDENTITY),
         LintId::of(map_unit_fn::OPTION_MAP_UNIT_FN),
         LintId::of(map_unit_fn::RESULT_MAP_UNIT_FN),
         LintId::of(matches::MATCH_AS_REF),
@@ -1601,6 +1599,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(methods::ITER_COUNT),
         LintId::of(methods::MANUAL_FILTER_MAP),
         LintId::of(methods::MANUAL_FIND_MAP),
+        LintId::of(methods::MAP_IDENTITY),
         LintId::of(methods::OPTION_AS_REF_DEREF),
         LintId::of(methods::OPTION_FILTER_MAP),
         LintId::of(methods::SEARCH_IS_SOME),
@@ -2039,7 +2038,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         single_char_binding_names_threshold,
     });
     store.register_late_pass(|| box macro_use::MacroUseImports::default());
-    store.register_late_pass(|| box map_identity::MapIdentity);
     store.register_late_pass(|| box pattern_type_mismatch::PatternTypeMismatch);
     store.register_late_pass(|| box stable_sort_primitive::StableSortPrimitive);
     store.register_late_pass(|| box repeat_once::RepeatOnce);
diff --git a/clippy_lints/src/map_identity.rs b/clippy_lints/src/map_identity.rs
deleted file mode 100644
index 9bcb010ff6d..00000000000
--- a/clippy_lints/src/map_identity.rs
+++ /dev/null
@@ -1,76 +0,0 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{is_expr_identity_function, is_trait_method};
-use if_chain::if_chain;
-use rustc_errors::Applicability;
-use rustc_hir::{Expr, ExprKind};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::sym;
-
-declare_clippy_lint! {
-    /// **What it does:** Checks for instances of `map(f)` where `f` is the identity function.
-    ///
-    /// **Why is this bad?** It can be written more concisely without the call to `map`.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
-    /// ```rust
-    /// let x = [1, 2, 3];
-    /// let y: Vec<_> = x.iter().map(|x| x).map(|x| 2*x).collect();
-    /// ```
-    /// Use instead:
-    /// ```rust
-    /// let x = [1, 2, 3];
-    /// let y: Vec<_> = x.iter().map(|x| 2*x).collect();
-    /// ```
-    pub MAP_IDENTITY,
-    complexity,
-    "using iterator.map(|x| x)"
-}
-
-declare_lint_pass!(MapIdentity => [MAP_IDENTITY]);
-
-impl<'tcx> LateLintPass<'tcx> for MapIdentity {
-    fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
-        if expr.span.from_expansion() {
-            return;
-        }
-
-        if_chain! {
-            if let Some([caller, func]) = get_map_argument(cx, expr);
-            if is_expr_identity_function(cx, func);
-            then {
-                span_lint_and_sugg(
-                    cx,
-                    MAP_IDENTITY,
-                    expr.span.trim_start(caller.span).unwrap(),
-                    "unnecessary map of the identity function",
-                    "remove the call to `map`",
-                    String::new(),
-                    Applicability::MachineApplicable
-                )
-            }
-        }
-    }
-}
-
-/// Returns the arguments passed into map() if the expression is a method call to
-/// map(). Otherwise, returns None.
-fn get_map_argument<'a>(cx: &LateContext<'_>, expr: &'a Expr<'a>) -> Option<&'a [Expr<'a>]> {
-    if_chain! {
-        if let ExprKind::MethodCall(method, _, args, _) = expr.kind;
-        if args.len() == 2 && method.ident.name == sym::map;
-        let caller_ty = cx.typeck_results().expr_ty(&args[0]);
-        if is_trait_method(cx, expr, sym::Iterator)
-            || is_type_diagnostic_item(cx, caller_ty, sym::result_type)
-            || is_type_diagnostic_item(cx, caller_ty, sym::option_type);
-        then {
-            Some(args)
-        } else {
-            None
-        }
-    }
-}
diff --git a/clippy_lints/src/methods/map_identity.rs b/clippy_lints/src/methods/map_identity.rs
new file mode 100644
index 00000000000..538a12566e3
--- /dev/null
+++ b/clippy_lints/src/methods/map_identity.rs
@@ -0,0 +1,38 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::{is_expr_identity_function, is_trait_method};
+use rustc_errors::Applicability;
+use rustc_hir as hir;
+use rustc_lint::LateContext;
+use rustc_span::{source_map::Span, sym};
+
+use super::MAP_IDENTITY;
+
+pub(super) fn check(
+    cx: &LateContext<'_>,
+    expr: &hir::Expr<'_>,
+    caller: &hir::Expr<'_>,
+    map_arg: &hir::Expr<'_>,
+    _map_span: Span,
+) {
+    let caller_ty = cx.typeck_results().expr_ty(caller);
+
+    if_chain! {
+        if is_trait_method(cx, expr, sym::Iterator)
+            || is_type_diagnostic_item(cx, caller_ty, sym::result_type)
+            || is_type_diagnostic_item(cx, caller_ty, sym::option_type);
+        if is_expr_identity_function(cx, map_arg);
+        if let Some(sugg_span) = expr.span.trim_start(caller.span);
+        then {
+            span_lint_and_sugg(
+                cx,
+                MAP_IDENTITY,
+                sugg_span,
+                "unnecessary map of the identity function",
+                "remove the call to `map`",
+                String::new(),
+                Applicability::MachineApplicable,
+            )
+        }
+    }
+}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index c8ae972f18c..d4f8cef4f37 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -35,6 +35,7 @@ mod manual_saturating_arithmetic;
 mod manual_str_repeat;
 mod map_collect_result_unit;
 mod map_flatten;
+mod map_identity;
 mod map_unwrap_or;
 mod ok_expect;
 mod option_as_ref_deref;
@@ -1561,6 +1562,29 @@ declare_clippy_lint! {
     "call to `filter_map` where `flatten` is sufficient"
 }
 
+declare_clippy_lint! {
+    /// **What it does:** Checks for instances of `map(f)` where `f` is the identity function.
+    ///
+    /// **Why is this bad?** It can be written more concisely without the call to `map`.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// let x = [1, 2, 3];
+    /// let y: Vec<_> = x.iter().map(|x| x).map(|x| 2*x).collect();
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// let x = [1, 2, 3];
+    /// let y: Vec<_> = x.iter().map(|x| 2*x).collect();
+    /// ```
+    pub MAP_IDENTITY,
+    complexity,
+    "using iterator.map(|x| x)"
+}
+
 declare_clippy_lint! {
     /// **What it does:** Checks for the use of `.bytes().nth()`.
     ///
@@ -1728,6 +1752,7 @@ impl_lint_pass!(Methods => [
     FILTER_NEXT,
     SKIP_WHILE_NEXT,
     FILTER_MAP_IDENTITY,
+    MAP_IDENTITY,
     MANUAL_FILTER_MAP,
     MANUAL_FIND_MAP,
     OPTION_FILTER_MAP,
@@ -2058,6 +2083,7 @@ fn check_methods<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, msrv: Optio
                         _ => {},
                     }
                 }
+                map_identity::check(cx, expr, recv, m_arg, span);
             },
             ("map_or", [def, map]) => option_map_or_none::check(cx, expr, recv, def, map),
             ("next", []) => {
-- 
cgit 1.4.1-3-g733a5


From fe549f711a002ddf6a509ff0bd4b17d271a7c1df Mon Sep 17 00:00:00 2001
From: lyj <sjtu5140809011@gmail.com>
Date: Wed, 9 Jun 2021 15:25:48 +0800
Subject: redundant_clone: fix comment

---
 clippy_lints/src/redundant_clone.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/redundant_clone.rs b/clippy_lints/src/redundant_clone.rs
index 19650c41b84..380557c81a1 100644
--- a/clippy_lints/src/redundant_clone.rs
+++ b/clippy_lints/src/redundant_clone.rs
@@ -132,7 +132,7 @@ impl<'tcx> LateLintPass<'tcx> for RedundantClone {
                 }
             }
 
-            // `{ cloned = &arg; clone(move cloned); }` or `{ cloned = &arg; to_path_buf(cloned); }`
+            // `{ arg = &cloned; clone(move arg); }` or `{ arg = &cloned; to_path_buf(arg); }`
             let (cloned, cannot_move_out) = unwrap_or_continue!(find_stmt_assigns_to(cx, mir, arg, from_borrow, bb));
 
             let loc = mir::Location {
-- 
cgit 1.4.1-3-g733a5


From 5ec80f32c75eae1fd27389ce0556ec4011144498 Mon Sep 17 00:00:00 2001
From: Bastian Kersting <bastian@cmbt.de>
Date: Wed, 9 Jun 2021 09:39:11 +0200
Subject: Refactored multiline check

---
 clippy_lints/src/semicolon_if_nothing_returned.rs | 28 +++--------------------
 1 file changed, 3 insertions(+), 25 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/semicolon_if_nothing_returned.rs b/clippy_lints/src/semicolon_if_nothing_returned.rs
index eff6cdf36b4..da3e30af35c 100644
--- a/clippy_lints/src/semicolon_if_nothing_returned.rs
+++ b/clippy_lints/src/semicolon_if_nothing_returned.rs
@@ -1,11 +1,10 @@
 use crate::rustc_lint::LintContext;
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_macro_callsite;
-use clippy_utils::{get_parent_expr_for_hir, in_macro, sugg};
+use clippy_utils::{in_macro, sugg};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
-use rustc_hir::Expr;
-use rustc_hir::{Block, BlockCheckMode, ExprKind};
+use rustc_hir::{Block, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
@@ -47,7 +46,7 @@ impl LateLintPass<'_> for SemicolonIfNothingReturned {
             if t_expr.is_unit();
             if let snippet = snippet_with_macro_callsite(cx, expr.span, "}");
             if !snippet.ends_with('}');
-            if !check_if_inside_block_on_same_line(cx, block, expr);
+            if cx.sess().source_map().is_multiline(block.span);
             then {
                 // filter out the desugared `for` loop
                 if let ExprKind::DropTemps(..) = &expr.kind {
@@ -69,24 +68,3 @@ impl LateLintPass<'_> for SemicolonIfNothingReturned {
         }
     }
 }
-
-/// Check if this block is inside a closure or an unsafe block or a normal on the same line.
-fn check_if_inside_block_on_same_line<'tcx>(
-    cx: &LateContext<'tcx>,
-    block: &'tcx Block<'tcx>,
-    last_expr: &'tcx Expr<'_>,
-) -> bool {
-    if_chain! {
-        if let Some(parent) = get_parent_expr_for_hir(cx, block.hir_id);
-
-        if !matches!(block.rules, BlockCheckMode::DefaultBlock) ||
-        matches!(parent.kind, ExprKind::Closure(..) | ExprKind::Block(..));
-
-        if block.stmts.is_empty();
-        then {
-            let source_map = cx.sess().source_map();
-            return !source_map.is_multiline(parent.span.to(last_expr.span));
-        }
-    }
-    false
-}
-- 
cgit 1.4.1-3-g733a5


From ea45e2a9cf13b59e6366a6cacb7f0088f9cadeda Mon Sep 17 00:00:00 2001
From: Devin Ragotzy <devin.ragotzy@gmail.com>
Date: Wed, 2 Jun 2021 07:20:45 -0400
Subject: Add disallowed_types lint, this adds a field to the Conf struct

Replace use of node_type -> node_type_opt, fix clippy warnings

Don't walk the hir unnecessarily let the visitor do it
---
 CHANGELOG.md                                       |   1 +
 clippy_lints/src/disallowed_type.rs                | 122 +++++++++++++++++++++
 clippy_lints/src/lib.rs                            |   5 +
 clippy_lints/src/utils/conf.rs                     |   2 +
 tests/ui-toml/toml_disallowed_type/clippy.toml     |   9 ++
 .../toml_disallowed_type/conf_disallowed_type.rs   |  35 ++++++
 .../conf_disallowed_type.stderr                    |  88 +++++++++++++++
 .../toml_unknown_key/conf_unknown_key.stderr       |   2 +-
 8 files changed, 263 insertions(+), 1 deletion(-)
 create mode 100644 clippy_lints/src/disallowed_type.rs
 create mode 100644 tests/ui-toml/toml_disallowed_type/clippy.toml
 create mode 100644 tests/ui-toml/toml_disallowed_type/conf_disallowed_type.rs
 create mode 100644 tests/ui-toml/toml_disallowed_type/conf_disallowed_type.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 41af8e190dd..13f0fc8f609 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2358,6 +2358,7 @@ Released 2018-09-13
 [`derive_hash_xor_eq`]: https://rust-lang.github.io/rust-clippy/master/index.html#derive_hash_xor_eq
 [`derive_ord_xor_partial_ord`]: https://rust-lang.github.io/rust-clippy/master/index.html#derive_ord_xor_partial_ord
 [`disallowed_method`]: https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_method
+[`disallowed_type`]: https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_type
 [`diverging_sub_expression`]: https://rust-lang.github.io/rust-clippy/master/index.html#diverging_sub_expression
 [`doc_markdown`]: https://rust-lang.github.io/rust-clippy/master/index.html#doc_markdown
 [`double_comparisons`]: https://rust-lang.github.io/rust-clippy/master/index.html#double_comparisons
diff --git a/clippy_lints/src/disallowed_type.rs b/clippy_lints/src/disallowed_type.rs
new file mode 100644
index 00000000000..f8ac7d76d8f
--- /dev/null
+++ b/clippy_lints/src/disallowed_type.rs
@@ -0,0 +1,122 @@
+use clippy_utils::diagnostics::span_lint;
+
+use rustc_data_structures::fx::FxHashSet;
+use rustc_hir::{def::Res, Item, ItemKind, PolyTraitRef, TraitBoundModifier, Ty, TyKind, UseKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::{Span, Symbol};
+
+declare_clippy_lint! {
+    /// **What it does:** Denies the configured types in clippy.toml.
+    ///
+    /// **Why is this bad?** Some types are undesirable in certain contexts.
+    ///
+    /// **Known problems:** The fully qualified path must be used. This lint
+    /// doesn't support aliases or reexported names; be aware that many types
+    /// in `std` are actually reexports.
+    ///
+    /// For example, if you want to disallow `BTreeMap`, your clippy.toml
+    /// configuration would look like
+    /// `disallowed-methods = ["alloc::collections::btree::map::BTreeMap"]` and not
+    /// `disallowed-methods = ["std::collections::BTreeMap"]` as you might expect.
+    ///
+    /// N.B. There is no way to ban primitive types.
+    ///
+    /// **Example:**
+    ///
+    /// An example clippy.toml configuration:
+    /// ```toml
+    /// # clippy.toml
+    /// disallowed-methods = ["alloc::collections::btree::map::BTreeMap"]
+    /// ```
+    ///
+    /// ```rust,ignore
+    /// use std::collections::BTreeMap;
+    /// // or its use
+    /// let x = std::collections::BTreeMap::new();
+    /// ```
+    /// Use instead:
+    /// ```rust,ignore
+    /// // A similar type that is allowed by the config
+    /// use std::collections::HashMap;
+    /// ```
+    pub DISALLOWED_TYPE,
+    nursery,
+    "use of a disallowed type"
+}
+#[derive(Clone, Debug)]
+pub struct DisallowedType {
+    disallowed: FxHashSet<Vec<Symbol>>,
+}
+
+impl DisallowedType {
+    pub fn new(disallowed: &FxHashSet<String>) -> Self {
+        Self {
+            disallowed: disallowed
+                .iter()
+                .map(|s| s.split("::").map(|seg| Symbol::intern(seg)).collect::<Vec<_>>())
+                .collect(),
+        }
+    }
+}
+
+impl_lint_pass!(DisallowedType => [DISALLOWED_TYPE]);
+
+impl<'tcx> LateLintPass<'tcx> for DisallowedType {
+    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
+        if_chain! {
+            if let ItemKind::Use(path, UseKind::Single) = &item.kind;
+            if let Res::Def(_, id) = path.res;
+            let use_path = cx.get_def_path(id);
+            if let Some(name) = self.disallowed.iter().find(|path| **path == use_path);
+            then {
+                emit(cx, name, item.span,);
+            }
+        }
+    }
+
+    fn check_ty(&mut self, cx: &LateContext<'tcx>, ty: &'tcx Ty<'tcx>) {
+        if_chain! {
+            if let TyKind::Path(path) = &ty.kind;
+            if let Some(did) = cx.qpath_res(path, ty.hir_id).opt_def_id();
+            let use_path = cx.get_def_path(did);
+            if let Some(name) = self.disallowed.iter().find(|path| **path == use_path);
+            then {
+                emit(cx, name, path.span());
+            }
+        }
+    }
+
+    fn check_poly_trait_ref(&mut self, cx: &LateContext<'tcx>, poly: &'tcx PolyTraitRef<'tcx>, _: TraitBoundModifier) {
+        if_chain! {
+            if let Res::Def(_, did) = poly.trait_ref.path.res;
+            let use_path = cx.get_def_path(did);
+            if let Some(name) = self.disallowed.iter().find(|path| **path == use_path);
+            then {
+                emit(cx, name, poly.trait_ref.path.span);
+            }
+        }
+    }
+
+    // TODO: if non primitive const generics are a thing
+    // fn check_generic_arg(&mut self, cx: &LateContext<'tcx>, arg: &'tcx GenericArg<'tcx>) {
+    //     match arg {
+    //         GenericArg::Const(c) => {},
+    //     }
+    // }
+    // fn check_generic_param(&mut self, cx: &LateContext<'tcx>, param: &'tcx GenericParam<'tcx>) {
+    //     match param.kind {
+    //         GenericParamKind::Const { .. } => {},
+    //     }
+    // }
+}
+
+fn emit(cx: &LateContext<'_>, name: &[Symbol], span: Span) {
+    let name = name.iter().map(|s| s.to_ident_string()).collect::<Vec<_>>().join("::");
+    span_lint(
+        cx,
+        DISALLOWED_TYPE,
+        span,
+        &format!("`{}` is not allowed according to config", name),
+    );
+}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index e7dd3952b3a..41c635d9e93 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -187,6 +187,7 @@ mod default_numeric_fallback;
 mod dereference;
 mod derive;
 mod disallowed_method;
+mod disallowed_type;
 mod doc;
 mod double_comparison;
 mod double_parens;
@@ -583,6 +584,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         derive::EXPL_IMPL_CLONE_ON_COPY,
         derive::UNSAFE_DERIVE_DESERIALIZE,
         disallowed_method::DISALLOWED_METHOD,
+        disallowed_type::DISALLOWED_TYPE,
         doc::DOC_MARKDOWN,
         doc::MISSING_ERRORS_DOC,
         doc::MISSING_PANICS_DOC,
@@ -1761,6 +1763,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(attrs::EMPTY_LINE_AFTER_OUTER_ATTR),
         LintId::of(cognitive_complexity::COGNITIVE_COMPLEXITY),
         LintId::of(disallowed_method::DISALLOWED_METHOD),
+        LintId::of(disallowed_type::DISALLOWED_TYPE),
         LintId::of(fallible_impl_from::FALLIBLE_IMPL_FROM),
         LintId::of(floating_point_arithmetic::IMPRECISE_FLOPS),
         LintId::of(floating_point_arithmetic::SUBOPTIMAL_FLOPS),
@@ -2066,6 +2069,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(move || box if_then_some_else_none::IfThenSomeElseNone::new(msrv));
     store.register_early_pass(|| box bool_assert_comparison::BoolAssertComparison);
     store.register_late_pass(|| box unused_async::UnusedAsync);
+    let disallowed_types = conf.disallowed_types.iter().cloned().collect::<FxHashSet<_>>();
+    store.register_late_pass(move || box disallowed_type::DisallowedType::new(&disallowed_types));
 
 }
 
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 0e33ae740d9..e7d901aa9f9 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -190,6 +190,8 @@ define_Conf! {
     (warn_on_all_wildcard_imports: bool = false),
     /// Lint: DISALLOWED_METHOD. The list of disallowed methods, written as fully qualified paths.
     (disallowed_methods: Vec<String> = Vec::new()),
+    /// Lint: DISALLOWED_TYPE. The list of disallowed types, written as fully qualified paths.
+    (disallowed_types: Vec<String> = Vec::new()),
     /// Lint: UNREADABLE_LITERAL. Should the fraction of a decimal be linted to include separators.
     (unreadable_literal_lint_fractions: bool = true),
     /// Lint: UPPER_CASE_ACRONYMS. Enables verbose mode. Triggers if there is more than one uppercase char next to each other
diff --git a/tests/ui-toml/toml_disallowed_type/clippy.toml b/tests/ui-toml/toml_disallowed_type/clippy.toml
new file mode 100644
index 00000000000..57dfdc584bb
--- /dev/null
+++ b/tests/ui-toml/toml_disallowed_type/clippy.toml
@@ -0,0 +1,9 @@
+disallowed-types = [
+    "std::collections::hash::map::HashMap",
+    "core::sync::atomic::AtomicU32",
+    "syn::ty::TypePath",
+    "proc_macro2::Ident",
+    "std::thread::Thread",
+    "std::time::Instant",
+    "std::io::Read",
+]
diff --git a/tests/ui-toml/toml_disallowed_type/conf_disallowed_type.rs b/tests/ui-toml/toml_disallowed_type/conf_disallowed_type.rs
new file mode 100644
index 00000000000..567afb5aec1
--- /dev/null
+++ b/tests/ui-toml/toml_disallowed_type/conf_disallowed_type.rs
@@ -0,0 +1,35 @@
+#![warn(clippy::disallowed_type)]
+
+extern crate quote;
+extern crate syn;
+
+use std::sync as foo;
+use std::sync::atomic::AtomicU32;
+use std::time::Instant as Sneaky;
+
+struct HashMap;
+
+fn bad_return_type() -> fn() -> Sneaky {
+    todo!()
+}
+
+fn bad_arg_type(_: impl Fn(Sneaky) -> foo::atomic::AtomicU32) {
+    todo!()
+}
+
+fn trait_obj(_: &dyn std::io::Read) {
+    todo!()
+}
+
+static BAD: foo::atomic::AtomicPtr<()> = foo::atomic::AtomicPtr::new(std::ptr::null_mut());
+
+#[allow(clippy::diverging_sub_expression)]
+fn main() {
+    let _: std::collections::HashMap<(), ()> = std::collections::HashMap::new();
+    let _ = Sneaky::now();
+    let _ = foo::atomic::AtomicU32::new(0);
+    static FOO: std::sync::atomic::AtomicU32 = foo::atomic::AtomicU32::new(1);
+    let _: std::collections::BTreeMap<(), syn::TypePath> = Default::default();
+    let _ = syn::Ident::new("", todo!());
+    let _ = HashMap;
+}
diff --git a/tests/ui-toml/toml_disallowed_type/conf_disallowed_type.stderr b/tests/ui-toml/toml_disallowed_type/conf_disallowed_type.stderr
new file mode 100644
index 00000000000..e5ea23cc0bc
--- /dev/null
+++ b/tests/ui-toml/toml_disallowed_type/conf_disallowed_type.stderr
@@ -0,0 +1,88 @@
+error: `core::sync::atomic::AtomicU32` is not allowed according to config
+  --> $DIR/conf_disallowed_type.rs:7:1
+   |
+LL | use std::sync::atomic::AtomicU32;
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::disallowed-type` implied by `-D warnings`
+
+error: `std::time::Instant` is not allowed according to config
+  --> $DIR/conf_disallowed_type.rs:8:1
+   |
+LL | use std::time::Instant as Sneaky;
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: `std::time::Instant` is not allowed according to config
+  --> $DIR/conf_disallowed_type.rs:12:33
+   |
+LL | fn bad_return_type() -> fn() -> Sneaky {
+   |                                 ^^^^^^
+
+error: `std::time::Instant` is not allowed according to config
+  --> $DIR/conf_disallowed_type.rs:16:28
+   |
+LL | fn bad_arg_type(_: impl Fn(Sneaky) -> foo::atomic::AtomicU32) {
+   |                            ^^^^^^
+
+error: `core::sync::atomic::AtomicU32` is not allowed according to config
+  --> $DIR/conf_disallowed_type.rs:16:39
+   |
+LL | fn bad_arg_type(_: impl Fn(Sneaky) -> foo::atomic::AtomicU32) {
+   |                                       ^^^^^^^^^^^^^^^^^^^^^^
+
+error: `std::io::Read` is not allowed according to config
+  --> $DIR/conf_disallowed_type.rs:20:22
+   |
+LL | fn trait_obj(_: &dyn std::io::Read) {
+   |                      ^^^^^^^^^^^^^
+
+error: `std::collections::hash::map::HashMap` is not allowed according to config
+  --> $DIR/conf_disallowed_type.rs:28:48
+   |
+LL |     let _: std::collections::HashMap<(), ()> = std::collections::HashMap::new();
+   |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: `std::collections::hash::map::HashMap` is not allowed according to config
+  --> $DIR/conf_disallowed_type.rs:28:12
+   |
+LL |     let _: std::collections::HashMap<(), ()> = std::collections::HashMap::new();
+   |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: `std::time::Instant` is not allowed according to config
+  --> $DIR/conf_disallowed_type.rs:29:13
+   |
+LL |     let _ = Sneaky::now();
+   |             ^^^^^^
+
+error: `core::sync::atomic::AtomicU32` is not allowed according to config
+  --> $DIR/conf_disallowed_type.rs:30:13
+   |
+LL |     let _ = foo::atomic::AtomicU32::new(0);
+   |             ^^^^^^^^^^^^^^^^^^^^^^
+
+error: `core::sync::atomic::AtomicU32` is not allowed according to config
+  --> $DIR/conf_disallowed_type.rs:31:17
+   |
+LL |     static FOO: std::sync::atomic::AtomicU32 = foo::atomic::AtomicU32::new(1);
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: `core::sync::atomic::AtomicU32` is not allowed according to config
+  --> $DIR/conf_disallowed_type.rs:31:48
+   |
+LL |     static FOO: std::sync::atomic::AtomicU32 = foo::atomic::AtomicU32::new(1);
+   |                                                ^^^^^^^^^^^^^^^^^^^^^^
+
+error: `syn::ty::TypePath` is not allowed according to config
+  --> $DIR/conf_disallowed_type.rs:32:43
+   |
+LL |     let _: std::collections::BTreeMap<(), syn::TypePath> = Default::default();
+   |                                           ^^^^^^^^^^^^^
+
+error: `proc_macro2::Ident` is not allowed according to config
+  --> $DIR/conf_disallowed_type.rs:33:13
+   |
+LL |     let _ = syn::Ident::new("", todo!());
+   |             ^^^^^^^^^^
+
+error: aborting due to 14 previous errors
+
diff --git a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
index a7be00426c4..06d70b66fda 100644
--- a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
+++ b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
@@ -1,4 +1,4 @@
-error: error reading Clippy's configuration file `$DIR/clippy.toml`: unknown field `foobar`, expected one of `avoid-breaking-exported-api`, `msrv`, `blacklisted-names`, `cognitive-complexity-threshold`, `cyclomatic-complexity-threshold`, `doc-valid-idents`, `too-many-arguments-threshold`, `type-complexity-threshold`, `single-char-binding-names-threshold`, `too-large-for-stack`, `enum-variant-name-threshold`, `enum-variant-size-threshold`, `verbose-bit-mask-threshold`, `literal-representation-threshold`, `trivial-copy-size-limit`, `pass-by-value-size-limit`, `too-many-lines-threshold`, `array-size-threshold`, `vec-box-size-threshold`, `max-trait-bounds`, `max-struct-bools`, `max-fn-params-bools`, `warn-on-all-wildcard-imports`, `disallowed-methods`, `unreadable-literal-lint-fractions`, `upper-case-acronyms-aggressive`, `cargo-ignore-publish`, `third-party` at line 5 column 1
+error: error reading Clippy's configuration file `$DIR/clippy.toml`: unknown field `foobar`, expected one of `avoid-breaking-exported-api`, `msrv`, `blacklisted-names`, `cognitive-complexity-threshold`, `cyclomatic-complexity-threshold`, `doc-valid-idents`, `too-many-arguments-threshold`, `type-complexity-threshold`, `single-char-binding-names-threshold`, `too-large-for-stack`, `enum-variant-name-threshold`, `enum-variant-size-threshold`, `verbose-bit-mask-threshold`, `literal-representation-threshold`, `trivial-copy-size-limit`, `pass-by-value-size-limit`, `too-many-lines-threshold`, `array-size-threshold`, `vec-box-size-threshold`, `max-trait-bounds`, `max-struct-bools`, `max-fn-params-bools`, `warn-on-all-wildcard-imports`, `disallowed-methods`, `disallowed-types`, `unreadable-literal-lint-fractions`, `upper-case-acronyms-aggressive`, `cargo-ignore-publish`, `third-party` at line 5 column 1
 
 error: aborting due to previous error
 
-- 
cgit 1.4.1-3-g733a5


From b792bb301c66e271d88d2e579ec79fec153b7b89 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Wed, 9 Jun 2021 09:17:34 -0500
Subject: Factor out match_var

---
 clippy_lints/src/bytecount.rs         | 70 ++++++++++----------------
 clippy_lints/src/collapsible_match.rs | 20 ++------
 clippy_lints/src/manual_map.rs        | 20 ++++----
 clippy_utils/src/lib.rs               | 94 +++++++++++++++--------------------
 clippy_utils/src/ptr.rs               | 32 ++++++------
 5 files changed, 92 insertions(+), 144 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/bytecount.rs b/clippy_lints/src/bytecount.rs
index 877ae002d36..4f7ffdcdfb4 100644
--- a/clippy_lints/src/bytecount.rs
+++ b/clippy_lints/src/bytecount.rs
@@ -1,15 +1,15 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::match_type;
-use clippy_utils::{contains_name, get_pat_name, paths, single_segment_path};
+use clippy_utils::visitors::LocalUsedVisitor;
+use clippy_utils::{path_to_local_id, paths, peel_ref_operators, remove_blocks, strip_pat_refs};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
-use rustc_hir::{BinOpKind, BorrowKind, Expr, ExprKind, UnOp};
+use rustc_hir::{BinOpKind, Expr, ExprKind, PatKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{self, UintTy};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::sym;
-use rustc_span::Symbol;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for naive byte counts
@@ -38,42 +38,43 @@ declare_lint_pass!(ByteCount => [NAIVE_BYTECOUNT]);
 impl<'tcx> LateLintPass<'tcx> for ByteCount {
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
         if_chain! {
-            if let ExprKind::MethodCall(count, _, count_args, _) = expr.kind;
+            if let ExprKind::MethodCall(count, _, [count_recv], _) = expr.kind;
             if count.ident.name == sym!(count);
-            if count_args.len() == 1;
-            if let ExprKind::MethodCall(filter, _, filter_args, _) = count_args[0].kind;
+            if let ExprKind::MethodCall(filter, _, [filter_recv, filter_arg], _) = count_recv.kind;
             if filter.ident.name == sym!(filter);
-            if filter_args.len() == 2;
-            if let ExprKind::Closure(_, _, body_id, _, _) = filter_args[1].kind;
+            if let ExprKind::Closure(_, _, body_id, _, _) = filter_arg.kind;
             let body = cx.tcx.hir().body(body_id);
-            if body.params.len() == 1;
-            if let Some(argname) = get_pat_name(body.params[0].pat);
+            if let [param] = body.params;
+            if let PatKind::Binding(_, arg_id, _, _) = strip_pat_refs(param.pat).kind;
             if let ExprKind::Binary(ref op, l, r) = body.value.kind;
             if op.node == BinOpKind::Eq;
             if match_type(cx,
-                       cx.typeck_results().expr_ty(&filter_args[0]).peel_refs(),
+                       cx.typeck_results().expr_ty(filter_recv).peel_refs(),
                        &paths::SLICE_ITER);
+            let operand_is_arg = |expr| {
+                let expr = peel_ref_operators(cx, remove_blocks(expr));
+                path_to_local_id(expr, arg_id)
+            };
+            let needle = if operand_is_arg(l) {
+                r
+            } else if operand_is_arg(r) {
+                l
+            } else {
+                return;
+            };
+            if ty::Uint(UintTy::U8) == *cx.typeck_results().expr_ty(needle).peel_refs().kind();
+            if !LocalUsedVisitor::new(cx, arg_id).check_expr(needle);
             then {
-                let needle = match get_path_name(l) {
-                    Some(name) if check_arg(name, argname, r) => r,
-                    _ => match get_path_name(r) {
-                        Some(name) if check_arg(name, argname, l) => l,
-                        _ => { return; }
-                    }
-                };
-                if ty::Uint(UintTy::U8) != *cx.typeck_results().expr_ty(needle).peel_refs().kind() {
-                    return;
-                }
                 let haystack = if let ExprKind::MethodCall(path, _, args, _) =
-                        filter_args[0].kind {
+                        filter_recv.kind {
                     let p = path.ident.name;
                     if (p == sym::iter || p == sym!(iter_mut)) && args.len() == 1 {
                         &args[0]
                     } else {
-                        &filter_args[0]
+                        &filter_recv
                     }
                 } else {
-                    &filter_args[0]
+                    &filter_recv
                 };
                 let mut applicability = Applicability::MaybeIncorrect;
                 span_lint_and_sugg(
@@ -91,24 +92,3 @@ impl<'tcx> LateLintPass<'tcx> for ByteCount {
         };
     }
 }
-
-fn check_arg(name: Symbol, arg: Symbol, needle: &Expr<'_>) -> bool {
-    name == arg && !contains_name(name, needle)
-}
-
-fn get_path_name(expr: &Expr<'_>) -> Option<Symbol> {
-    match expr.kind {
-        ExprKind::Box(e) | ExprKind::AddrOf(BorrowKind::Ref, _, e) | ExprKind::Unary(UnOp::Deref, e) => {
-            get_path_name(e)
-        },
-        ExprKind::Block(b, _) => {
-            if b.stmts.is_empty() {
-                b.expr.as_ref().and_then(|p| get_path_name(p))
-            } else {
-                None
-            }
-        },
-        ExprKind::Path(ref qpath) => single_segment_path(qpath).map(|ps| ps.ident.name),
-        _ => None,
-    }
-}
diff --git a/clippy_lints/src/collapsible_match.rs b/clippy_lints/src/collapsible_match.rs
index ab22578abd6..a6c3a5b0e83 100644
--- a/clippy_lints/src/collapsible_match.rs
+++ b/clippy_lints/src/collapsible_match.rs
@@ -1,11 +1,10 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::visitors::LocalUsedVisitor;
-use clippy_utils::{is_lang_ctor, path_to_local, SpanlessEq};
+use clippy_utils::{is_lang_ctor, path_to_local, peel_ref_operators, SpanlessEq};
 use if_chain::if_chain;
 use rustc_hir::LangItem::OptionNone;
-use rustc_hir::{Arm, Expr, ExprKind, Guard, HirId, Pat, PatKind, StmtKind, UnOp};
+use rustc_hir::{Arm, Expr, ExprKind, Guard, HirId, Pat, PatKind, StmtKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty::TypeckResults;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::{MultiSpan, Span};
 
@@ -73,7 +72,7 @@ fn check_arm<'tcx>(arm: &Arm<'tcx>, wild_outer_arm: &Arm<'tcx>, cx: &LateContext
         if arms_inner.iter().all(|arm| arm.guard.is_none());
         // match expression must be a local binding
         // match <local> { .. }
-        if let Some(binding_id) = path_to_local(strip_ref_operators(expr_in, cx.typeck_results()));
+        if let Some(binding_id) = path_to_local(peel_ref_operators(cx, expr_in));
         // one of the branches must be "wild-like"
         if let Some(wild_inner_arm_idx) = arms_inner.iter().rposition(|arm_inner| arm_is_wild_like(cx, arm_inner));
         let (wild_inner_arm, non_wild_inner_arm) =
@@ -163,16 +162,3 @@ fn pat_contains_or(pat: &Pat<'_>) -> bool {
     });
     result
 }
-
-/// Removes `AddrOf` operators (`&`) or deref operators (`*`), but only if a reference type is
-/// dereferenced. An overloaded deref such as `Vec` to slice would not be removed.
-fn strip_ref_operators<'hir>(mut expr: &'hir Expr<'hir>, typeck_results: &TypeckResults<'_>) -> &'hir Expr<'hir> {
-    loop {
-        match expr.kind {
-            ExprKind::AddrOf(_, _, e) => expr = e,
-            ExprKind::Unary(UnOp::Deref, e) if typeck_results.expr_ty(e).is_ref() => expr = e,
-            _ => break,
-        }
-    }
-    expr
-}
diff --git a/clippy_lints/src/manual_map.rs b/clippy_lints/src/manual_map.rs
index 0b873534f2c..97e4a983f32 100644
--- a/clippy_lints/src/manual_map.rs
+++ b/clippy_lints/src/manual_map.rs
@@ -3,19 +3,17 @@ use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::{snippet_with_applicability, snippet_with_context};
 use clippy_utils::ty::{is_type_diagnostic_item, peel_mid_ty_refs_is_mutable};
 use clippy_utils::{
-    can_move_expr_to_closure, in_constant, is_allowed, is_else_clause, is_lang_ctor, match_var, peel_hir_expr_refs,
+    can_move_expr_to_closure, in_constant, is_allowed, is_else_clause, is_lang_ctor, path_to_local_id,
+    peel_hir_expr_refs,
 };
 use rustc_ast::util::parser::PREC_POSTFIX;
 use rustc_errors::Applicability;
 use rustc_hir::LangItem::{OptionNone, OptionSome};
-use rustc_hir::{Arm, BindingAnnotation, Block, Expr, ExprKind, MatchSource, Mutability, Pat, PatKind};
+use rustc_hir::{Arm, BindingAnnotation, Block, Expr, ExprKind, HirId, MatchSource, Mutability, Pat, PatKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::{
-    symbol::{sym, Ident},
-    SyntaxContext,
-};
+use rustc_span::{sym, SyntaxContext};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for usages of `match` which could be implemented using `map`
@@ -141,13 +139,13 @@ impl LateLintPass<'_> for ManualMap {
                     scrutinee_str.into()
                 };
 
-            let body_str = if let PatKind::Binding(annotation, _, some_binding, None) = some_pat.kind {
-                match can_pass_as_func(cx, some_binding, some_expr) {
+            let body_str = if let PatKind::Binding(annotation, id, some_binding, None) = some_pat.kind {
+                match can_pass_as_func(cx, id, some_expr) {
                     Some(func) if func.span.ctxt() == some_expr.span.ctxt() => {
                         snippet_with_applicability(cx, func.span, "..", &mut app).into_owned()
                     },
                     _ => {
-                        if match_var(some_expr, some_binding.name)
+                        if path_to_local_id(some_expr, id)
                             && !is_allowed(cx, MATCH_AS_REF, expr.hir_id)
                             && binding_ref.is_some()
                         {
@@ -199,10 +197,10 @@ impl LateLintPass<'_> for ManualMap {
 
 // Checks whether the expression could be passed as a function, or whether a closure is needed.
 // Returns the function to be passed to `map` if it exists.
-fn can_pass_as_func(cx: &LateContext<'tcx>, binding: Ident, expr: &'tcx Expr<'_>) -> Option<&'tcx Expr<'tcx>> {
+fn can_pass_as_func(cx: &LateContext<'tcx>, binding: HirId, expr: &'tcx Expr<'_>) -> Option<&'tcx Expr<'tcx>> {
     match expr.kind {
         ExprKind::Call(func, [arg])
-            if match_var(arg, binding.name) && cx.typeck_results().expr_adjustments(arg).is_empty() =>
+            if path_to_local_id(arg, binding) && cx.typeck_results().expr_adjustments(arg).is_empty() =>
         {
             Some(func)
         },
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index d3efd32d727..66e75b0c206 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -72,7 +72,7 @@ use rustc_hir::LangItem::{ResultErr, ResultOk};
 use rustc_hir::{
     def, Arm, BindingAnnotation, Block, Body, Constness, Destination, Expr, ExprKind, FnDecl, GenericArgs, HirId, Impl,
     ImplItem, ImplItemKind, IsAsync, Item, ItemKind, LangItem, Local, MatchSource, Node, Param, Pat, PatKind, Path,
-    PathSegment, QPath, Stmt, StmtKind, TraitItem, TraitItemKind, TraitRef, TyKind,
+    PathSegment, QPath, Stmt, StmtKind, TraitItem, TraitItemKind, TraitRef, TyKind, UnOp,
 };
 use rustc_lint::{LateContext, Level, Lint, LintContext};
 use rustc_middle::hir::exports::Export;
@@ -326,16 +326,6 @@ pub fn is_trait_method(cx: &LateContext<'_>, expr: &Expr<'_>, diag_item: Symbol)
         .map_or(false, |did| is_diag_trait_item(cx, did, diag_item))
 }
 
-/// Checks if an expression references a variable of the given name.
-pub fn match_var(expr: &Expr<'_>, var: Symbol) -> bool {
-    if let ExprKind::Path(QPath::Resolved(None, path)) = expr.kind {
-        if let [p] = path.segments {
-            return p.ident.name == var;
-        }
-    }
-    false
-}
-
 pub fn last_path_segment<'tcx>(path: &QPath<'tcx>) -> &'tcx PathSegment<'tcx> {
     match *path {
         QPath::Resolved(_, path) => path.segments.last().expect("A path must have at least one segment"),
@@ -707,16 +697,6 @@ pub fn get_item_name(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<Symbol> {
     }
 }
 
-/// Gets the name of a `Pat`, if any.
-pub fn get_pat_name(pat: &Pat<'_>) -> Option<Symbol> {
-    match pat.kind {
-        PatKind::Binding(.., ref spname, _) => Some(spname.name),
-        PatKind::Path(ref qpath) => single_segment_path(qpath).map(|ps| ps.ident.name),
-        PatKind::Box(p) | PatKind::Ref(p, _) => get_pat_name(&*p),
-        _ => None,
-    }
-}
-
 pub struct ContainsName {
     pub name: Symbol,
     pub result: bool,
@@ -1404,47 +1384,42 @@ pub fn is_must_use_func_call(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
 /// Checks if an expression represents the identity function
 /// Only examines closures and `std::convert::identity`
 pub fn is_expr_identity_function(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-    /// Returns true if the expression is a binding to the given pattern
-    fn is_expr_pat_binding(cx: &LateContext<'_>, expr: &Expr<'_>, pat: &Pat<'_>) -> bool {
-        if let PatKind::Binding(_, _, ident, _) = pat.kind {
-            if match_var(expr, ident.name) {
-                return !(cx.typeck_results().hir_owner == expr.hir_id.owner && is_adjusted(cx, expr));
-            }
-        }
-
-        false
-    }
-
     /// Checks if a function's body represents the identity function. Looks for bodies of the form:
     /// * `|x| x`
     /// * `|x| return x`
     /// * `|x| { return x }`
     /// * `|x| { return x; }`
     fn is_body_identity_function(cx: &LateContext<'_>, func: &Body<'_>) -> bool {
-        let body = remove_blocks(&func.value);
-
-        let value_pat = if let [value_param] = func.params {
-            value_param.pat
-        } else {
-            return false;
+        let id = if_chain! {
+            if let [param] = func.params;
+            if let PatKind::Binding(_, id, _, _) = param.pat.kind;
+            then {
+                id
+            } else {
+                return false;
+            }
         };
 
-        match body.kind {
-            ExprKind::Path(QPath::Resolved(None, _)) => is_expr_pat_binding(cx, body, value_pat),
-            ExprKind::Ret(Some(ret_val)) => is_expr_pat_binding(cx, ret_val, value_pat),
-            ExprKind::Block(block, _) => {
-                if_chain! {
-                    if let &[block_stmt] = &block.stmts;
-                    if let StmtKind::Semi(expr) | StmtKind::Expr(expr) = block_stmt.kind;
-                    if let ExprKind::Ret(Some(ret_val)) = expr.kind;
-                    then {
-                        is_expr_pat_binding(cx, ret_val, value_pat)
-                    } else {
-                        false
+        let mut expr = &func.value;
+        loop {
+            match expr.kind {
+                #[rustfmt::skip]
+                ExprKind::Block(&Block { stmts: [], expr: Some(e), .. }, _, )
+                | ExprKind::Ret(Some(e)) => expr = e,
+                #[rustfmt::skip]
+                ExprKind::Block(&Block { stmts: [stmt], expr: None, .. }, _) => {
+                    if_chain! {
+                        if let StmtKind::Semi(e) | StmtKind::Expr(e) = stmt.kind;
+                        if let ExprKind::Ret(Some(ret_val)) = e.kind;
+                        then {
+                            expr = ret_val;
+                        } else {
+                            return false;
+                        }
                     }
-                }
-            },
-            _ => false,
+                },
+                _ => return path_to_local_id(expr, id) && cx.typeck_results().expr_adjustments(expr).is_empty(),
+            }
         }
     }
 
@@ -1710,6 +1685,19 @@ pub fn peel_hir_expr_refs(expr: &'a Expr<'a>) -> (&'a Expr<'a>, usize) {
     (e, count)
 }
 
+/// Removes `AddrOf` operators (`&`) or deref operators (`*`), but only if a reference type is
+/// dereferenced. An overloaded deref such as `Vec` to slice would not be removed.
+pub fn peel_ref_operators<'hir>(cx: &LateContext<'_>, mut expr: &'hir Expr<'hir>) -> &'hir Expr<'hir> {
+    loop {
+        match expr.kind {
+            ExprKind::AddrOf(_, _, e) => expr = e,
+            ExprKind::Unary(UnOp::Deref, e) if cx.typeck_results().expr_ty(e).is_ref() => expr = e,
+            _ => break,
+        }
+    }
+    expr
+}
+
 #[macro_export]
 macro_rules! unwrap_cargo_metadata {
     ($cx: ident, $lint: ident, $deps: expr) => {{
diff --git a/clippy_utils/src/ptr.rs b/clippy_utils/src/ptr.rs
index 791688cd194..8adb6915952 100644
--- a/clippy_utils/src/ptr.rs
+++ b/clippy_utils/src/ptr.rs
@@ -1,10 +1,10 @@
 use crate::source::snippet;
-use crate::{get_pat_name, match_var};
+use crate::{path_to_local_id, strip_pat_refs};
 use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
-use rustc_hir::{Body, BodyId, Expr, ExprKind, Param};
+use rustc_hir::{Body, BodyId, Expr, ExprKind, HirId, PatKind};
 use rustc_lint::LateContext;
 use rustc_middle::hir::map::Map;
-use rustc_span::{Span, Symbol};
+use rustc_span::Span;
 use std::borrow::Cow;
 
 pub fn get_spans(
@@ -14,10 +14,11 @@ pub fn get_spans(
     replacements: &[(&'static str, &'static str)],
 ) -> Option<Vec<(Span, Cow<'static, str>)>> {
     if let Some(body) = opt_body_id.map(|id| cx.tcx.hir().body(id)) {
-        get_binding_name(&body.params[idx]).map_or_else(
-            || Some(vec![]),
-            |name| extract_clone_suggestions(cx, name, replacements, body),
-        )
+        if let PatKind::Binding(_, binding_id, _, _) = strip_pat_refs(body.params[idx].pat).kind {
+            extract_clone_suggestions(cx, binding_id, replacements, body)
+        } else {
+            Some(vec![])
+        }
     } else {
         Some(vec![])
     }
@@ -25,13 +26,13 @@ pub fn get_spans(
 
 fn extract_clone_suggestions<'tcx>(
     cx: &LateContext<'tcx>,
-    name: Symbol,
+    id: HirId,
     replace: &[(&'static str, &'static str)],
     body: &'tcx Body<'_>,
 ) -> Option<Vec<(Span, Cow<'static, str>)>> {
     let mut visitor = PtrCloneVisitor {
         cx,
-        name,
+        id,
         replace,
         spans: vec![],
         abort: false,
@@ -42,7 +43,7 @@ fn extract_clone_suggestions<'tcx>(
 
 struct PtrCloneVisitor<'a, 'tcx> {
     cx: &'a LateContext<'tcx>,
-    name: Symbol,
+    id: HirId,
     replace: &'a [(&'static str, &'static str)],
     spans: Vec<(Span, Cow<'static, str>)>,
     abort: bool,
@@ -55,16 +56,15 @@ impl<'a, 'tcx> Visitor<'tcx> for PtrCloneVisitor<'a, 'tcx> {
         if self.abort {
             return;
         }
-        if let ExprKind::MethodCall(seg, _, args, _) = expr.kind {
-            if args.len() == 1 && match_var(&args[0], self.name) {
+        if let ExprKind::MethodCall(seg, _, [recv], _) = expr.kind {
+            if path_to_local_id(recv, self.id) {
                 if seg.ident.name.as_str() == "capacity" {
                     self.abort = true;
                     return;
                 }
                 for &(fn_name, suffix) in self.replace {
                     if seg.ident.name.as_str() == fn_name {
-                        self.spans
-                            .push((expr.span, snippet(self.cx, args[0].span, "_") + suffix));
+                        self.spans.push((expr.span, snippet(self.cx, recv.span, "_") + suffix));
                         return;
                     }
                 }
@@ -77,7 +77,3 @@ impl<'a, 'tcx> Visitor<'tcx> for PtrCloneVisitor<'a, 'tcx> {
         NestedVisitorMap::None
     }
 }
-
-fn get_binding_name(arg: &Param<'_>) -> Option<Symbol> {
-    get_pat_name(arg.pat)
-}
-- 
cgit 1.4.1-3-g733a5


From 0d3f289b66791912b976c6757a91842843b2c217 Mon Sep 17 00:00:00 2001
From: Thomas de Zeeuw <thomasdezeeuw@gmail.com>
Date: Wed, 9 Jun 2021 17:16:10 +0200
Subject: Add FreeBSD as identifier not needing ticks

For the doc-markdown lint.
---
 clippy_lints/src/utils/conf.rs | 2 +-
 tests/ui/doc.rs                | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 0e33ae740d9..d7744c09c11 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -149,7 +149,7 @@ define_Conf! {
         "WebGL",
         "TensorFlow",
         "TrueType",
-        "iOS", "macOS",
+        "iOS", "macOS", "FreeBSD",
         "TeX", "LaTeX", "BibTeX", "BibLaTeX",
         "MinGW",
         "CamelCase",
diff --git a/tests/ui/doc.rs b/tests/ui/doc.rs
index c946a047f1b..8afef6b23d4 100644
--- a/tests/ui/doc.rs
+++ b/tests/ui/doc.rs
@@ -64,7 +64,7 @@ fn test_units() {
 /// WebGL
 /// TensorFlow
 /// TrueType
-/// iOS macOS
+/// iOS macOS FreeBSD
 /// TeX LaTeX BibTeX BibLaTeX
 /// MinGW
 /// CamelCase (see also #2395)
-- 
cgit 1.4.1-3-g733a5


From 44608b1857951ba82b630853da6fc6c2f40fde53 Mon Sep 17 00:00:00 2001
From: valentine-mario <valentine13400@gmail.com>
Date: Thu, 10 Jun 2021 09:12:06 +0100
Subject: added lint to check for full range of vector and suggest append

---
 CHANGELOG.md                                       |  1 +
 clippy_lints/src/lib.rs                            |  3 ++
 .../src/methods/append_instead_of_extend.rs        | 41 ++++++++++++++++
 clippy_lints/src/methods/mod.rs                    | 33 ++++++++++++-
 tests/ui/append_instead_of_extend.fixed            | 55 ++++++++++++++++++++++
 tests/ui/append_instead_of_extend.rs               | 55 ++++++++++++++++++++++
 tests/ui/append_instead_of_extend.stderr           | 22 +++++++++
 7 files changed, 208 insertions(+), 2 deletions(-)
 create mode 100644 clippy_lints/src/methods/append_instead_of_extend.rs
 create mode 100644 tests/ui/append_instead_of_extend.fixed
 create mode 100644 tests/ui/append_instead_of_extend.rs
 create mode 100644 tests/ui/append_instead_of_extend.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 13f0fc8f609..52d0e8c7cde 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2295,6 +2295,7 @@ Released 2018-09-13
 <!-- begin autogenerated links to lint list -->
 [`absurd_extreme_comparisons`]: https://rust-lang.github.io/rust-clippy/master/index.html#absurd_extreme_comparisons
 [`almost_swapped`]: https://rust-lang.github.io/rust-clippy/master/index.html#almost_swapped
+[`append_instead_of_extend`]: https://rust-lang.github.io/rust-clippy/master/index.html#append_instead_of_extend
 [`approx_constant`]: https://rust-lang.github.io/rust-clippy/master/index.html#approx_constant
 [`as_conversions`]: https://rust-lang.github.io/rust-clippy/master/index.html#as_conversions
 [`assertions_on_constants`]: https://rust-lang.github.io/rust-clippy/master/index.html#assertions_on_constants
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 591bf68f927..5ab333f8aa1 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -730,6 +730,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         mem_replace::MEM_REPLACE_OPTION_WITH_NONE,
         mem_replace::MEM_REPLACE_WITH_DEFAULT,
         mem_replace::MEM_REPLACE_WITH_UNINIT,
+        methods::APPEND_INSTEAD_OF_EXTEND,
         methods::BIND_INSTEAD_OF_MAP,
         methods::BYTES_NTH,
         methods::CHARS_LAST_CMP,
@@ -1276,6 +1277,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(mem_replace::MEM_REPLACE_OPTION_WITH_NONE),
         LintId::of(mem_replace::MEM_REPLACE_WITH_DEFAULT),
         LintId::of(mem_replace::MEM_REPLACE_WITH_UNINIT),
+        LintId::of(methods::APPEND_INSTEAD_OF_EXTEND),
         LintId::of(methods::BIND_INSTEAD_OF_MAP),
         LintId::of(methods::BYTES_NTH),
         LintId::of(methods::CHARS_LAST_CMP),
@@ -1736,6 +1738,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(large_enum_variant::LARGE_ENUM_VARIANT),
         LintId::of(loops::MANUAL_MEMCPY),
         LintId::of(loops::NEEDLESS_COLLECT),
+        LintId::of(methods::APPEND_INSTEAD_OF_EXTEND),
         LintId::of(methods::EXPECT_FUN_CALL),
         LintId::of(methods::ITER_NTH),
         LintId::of(methods::MANUAL_STR_REPEAT),
diff --git a/clippy_lints/src/methods/append_instead_of_extend.rs b/clippy_lints/src/methods/append_instead_of_extend.rs
new file mode 100644
index 00000000000..e39a5a1efd1
--- /dev/null
+++ b/clippy_lints/src/methods/append_instead_of_extend.rs
@@ -0,0 +1,41 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::ty::{is_type_diagnostic_item, is_type_lang_item};
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind, LangItem};
+use rustc_lint::LateContext;
+use rustc_span::symbol::sym;
+
+use super::APPEND_INSTEAD_OF_EXTEND;
+
+pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'_>, arg: &Expr<'_>) {
+    let ty = cx.typeck_results().expr_ty(recv).peel_refs();
+    if_chain! {
+        if is_type_diagnostic_item(cx, ty, sym::vec_type);
+        //check source object
+        if let ExprKind::MethodCall(src_method, _, [drain_vec, drain_arg], _) = &arg.kind;
+        if src_method.ident.as_str() == "drain";
+        if let src_ty = cx.typeck_results().expr_ty(drain_vec).peel_refs();
+        if is_type_diagnostic_item(cx, src_ty, sym::vec_type);
+        //check drain range
+        if let src_ty_range = cx.typeck_results().expr_ty(drain_arg).peel_refs();
+        if is_type_lang_item(cx, src_ty_range, LangItem::RangeFull);
+        then {
+            let mut applicability = Applicability::MachineApplicable;
+            span_lint_and_sugg(
+                cx,
+                APPEND_INSTEAD_OF_EXTEND,
+                expr.span,
+                "use of `extend` instead of `append` for adding the full range of a second vector",
+                "try this",
+                format!(
+                    "{}.append(&mut {})",
+                    snippet_with_applicability(cx, recv.span, "..", &mut applicability),
+                    snippet_with_applicability(cx, drain_vec.span, "..", &mut applicability)
+                ),
+                applicability,
+            );
+        }
+    }
+}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index d4f8cef4f37..b556dcb4dfe 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1,3 +1,4 @@
+mod append_instead_of_extend;
 mod bind_instead_of_map;
 mod bytes_nth;
 mod chars_cmp;
@@ -1032,6 +1033,30 @@ declare_clippy_lint! {
     "using `.get().unwrap()` or `.get_mut().unwrap()` when using `[]` would work instead"
 }
 
+declare_clippy_lint! {
+    /// **What it does:** Checks for occurrences where one vector gets extended instead of append
+    ///
+    /// **Why is this bad?** Using `append` instead of `extend` is more concise and faster
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// let mut a = vec![1, 2, 3];
+    /// let mut b = vec![4, 5, 6];
+    ///
+    /// // Bad
+    /// a.extend(b.drain(..));
+    ///
+    /// // Good
+    /// a.append(&mut b);
+    /// ```
+    pub APPEND_INSTEAD_OF_EXTEND,
+    perf,
+    "using vec.append(&mut vec) to move the full range of a vecor to another"
+}
+
 declare_clippy_lint! {
     /// **What it does:** Checks for the use of `.extend(s.chars())` where s is a
     /// `&str` or `String`.
@@ -1785,7 +1810,8 @@ impl_lint_pass!(Methods => [
     INSPECT_FOR_EACH,
     IMPLICIT_CLONE,
     SUSPICIOUS_SPLITN,
-    MANUAL_STR_REPEAT
+    MANUAL_STR_REPEAT,
+    APPEND_INSTEAD_OF_EXTEND
 ]);
 
 /// Extracts a method call name, args, and `Span` of the method name.
@@ -2047,7 +2073,10 @@ fn check_methods<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, msrv: Optio
                 Some(("ok", [recv], _)) => ok_expect::check(cx, expr, recv),
                 _ => expect_used::check(cx, expr, recv),
             },
-            ("extend", [arg]) => string_extend_chars::check(cx, expr, recv, arg),
+            ("extend", [arg]) => {
+                string_extend_chars::check(cx, expr, recv, arg);
+                append_instead_of_extend::check(cx, expr, recv, arg);
+            },
             ("filter_map", [arg]) => {
                 unnecessary_filter_map::check(cx, expr, arg);
                 filter_map_identity::check(cx, expr, arg, span);
diff --git a/tests/ui/append_instead_of_extend.fixed b/tests/ui/append_instead_of_extend.fixed
new file mode 100644
index 00000000000..283358333cd
--- /dev/null
+++ b/tests/ui/append_instead_of_extend.fixed
@@ -0,0 +1,55 @@
+// run-rustfix
+#![warn(clippy::append_instead_of_extend)]
+use std::collections::BinaryHeap;
+fn main() {
+    //gets linted
+    let mut vec1 = vec![0u8; 1024];
+    let mut vec2: std::vec::Vec<u8> = Vec::new();
+
+    vec2.append(&mut vec1);
+
+    let mut vec3 = vec![0u8; 1024];
+    let mut vec4: std::vec::Vec<u8> = Vec::new();
+
+    vec4.append(&mut vec3);
+
+    let mut vec11: std::vec::Vec<u8> = Vec::new();
+
+    vec11.append(&mut return_vector());
+
+    //won't get linted it dosen't move the entire content of a vec into another
+    let mut test1 = vec![0u8, 10];
+    let mut test2: std::vec::Vec<u8> = Vec::new();
+
+    test2.extend(test1.drain(4..10));
+
+    let mut vec3 = vec![0u8; 104];
+    let mut vec7: std::vec::Vec<u8> = Vec::new();
+
+    vec3.append(&mut vec7);
+
+    let mut vec5 = vec![0u8; 1024];
+    let mut vec6: std::vec::Vec<u8> = Vec::new();
+
+    vec5.extend(vec6.drain(..4));
+
+    let mut vec9: std::vec::Vec<u8> = Vec::new();
+
+    return_vector().append(&mut vec9);
+
+    //won't get linted because it is not a vec
+
+    let mut heap = BinaryHeap::from(vec![1, 3]);
+    let mut heap2 = BinaryHeap::from(vec![]);
+    heap2.extend(heap.drain())
+}
+
+fn return_vector() -> Vec<u8> {
+    let mut new_vector = vec![];
+
+    for i in 1..10 {
+        new_vector.push(i)
+    }
+
+    new_vector
+}
diff --git a/tests/ui/append_instead_of_extend.rs b/tests/ui/append_instead_of_extend.rs
new file mode 100644
index 00000000000..abde5cdac5c
--- /dev/null
+++ b/tests/ui/append_instead_of_extend.rs
@@ -0,0 +1,55 @@
+// run-rustfix
+#![warn(clippy::append_instead_of_extend)]
+use std::collections::BinaryHeap;
+fn main() {
+    //gets linted
+    let mut vec1 = vec![0u8; 1024];
+    let mut vec2: std::vec::Vec<u8> = Vec::new();
+
+    vec2.extend(vec1.drain(..));
+
+    let mut vec3 = vec![0u8; 1024];
+    let mut vec4: std::vec::Vec<u8> = Vec::new();
+
+    vec4.extend(vec3.drain(..));
+
+    let mut vec11: std::vec::Vec<u8> = Vec::new();
+
+    vec11.extend(return_vector().drain(..));
+
+    //won't get linted it dosen't move the entire content of a vec into another
+    let mut test1 = vec![0u8, 10];
+    let mut test2: std::vec::Vec<u8> = Vec::new();
+
+    test2.extend(test1.drain(4..10));
+
+    let mut vec3 = vec![0u8; 104];
+    let mut vec7: std::vec::Vec<u8> = Vec::new();
+
+    vec3.append(&mut vec7);
+
+    let mut vec5 = vec![0u8; 1024];
+    let mut vec6: std::vec::Vec<u8> = Vec::new();
+
+    vec5.extend(vec6.drain(..4));
+
+    let mut vec9: std::vec::Vec<u8> = Vec::new();
+
+    return_vector().append(&mut vec9);
+
+    //won't get linted because it is not a vec
+
+    let mut heap = BinaryHeap::from(vec![1, 3]);
+    let mut heap2 = BinaryHeap::from(vec![]);
+    heap2.extend(heap.drain())
+}
+
+fn return_vector() -> Vec<u8> {
+    let mut new_vector = vec![];
+
+    for i in 1..10 {
+        new_vector.push(i)
+    }
+
+    new_vector
+}
diff --git a/tests/ui/append_instead_of_extend.stderr b/tests/ui/append_instead_of_extend.stderr
new file mode 100644
index 00000000000..9d309d981de
--- /dev/null
+++ b/tests/ui/append_instead_of_extend.stderr
@@ -0,0 +1,22 @@
+error: use of `extend` instead of `append` for adding the full range of a second vector
+  --> $DIR/append_instead_of_extend.rs:9:5
+   |
+LL |     vec2.extend(vec1.drain(..));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `vec2.append(&mut vec1)`
+   |
+   = note: `-D clippy::append-instead-of-extend` implied by `-D warnings`
+
+error: use of `extend` instead of `append` for adding the full range of a second vector
+  --> $DIR/append_instead_of_extend.rs:14:5
+   |
+LL |     vec4.extend(vec3.drain(..));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `vec4.append(&mut vec3)`
+
+error: use of `extend` instead of `append` for adding the full range of a second vector
+  --> $DIR/append_instead_of_extend.rs:18:5
+   |
+LL |     vec11.extend(return_vector().drain(..));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `vec11.append(&mut return_vector())`
+
+error: aborting due to 3 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 683c557afe9de3288478112a0db6d4092f0248ea Mon Sep 17 00:00:00 2001
From: lyj <sjtu5140809011@gmail.com>
Date: Fri, 11 Jun 2021 14:07:11 +0800
Subject: rc_mutex: add known problems

---
 clippy_lints/src/types/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types/mod.rs b/clippy_lints/src/types/mod.rs
index 30b04e4174c..5850a10d80f 100644
--- a/clippy_lints/src/types/mod.rs
+++ b/clippy_lints/src/types/mod.rs
@@ -257,7 +257,7 @@ declare_clippy_lint! {
     /// **Why is this bad?** `Rc` is used in single thread and `Mutex` is used in multi thread.
     /// Consider using `Rc<RefCell<T>>` in single thread or `Arc<Mutex<T>>` in multi thread.
     ///
-    /// **Known problems:** None.
+    /// **Known problems:** Maybe false positive on trait generic.
     ///
     /// **Example:**
     /// ```rust,ignore
-- 
cgit 1.4.1-3-g733a5


From 70ce0c2c55b18f7c9a4bc8d767c626f8d5948fae Mon Sep 17 00:00:00 2001
From: Devin Ragotzy <devin.ragotzy@gmail.com>
Date: Fri, 11 Jun 2021 17:25:32 -0400
Subject: Remove requirement of fully qualified path for disallowed_method/type

---
 clippy_lints/src/disallowed_method.rs              | 18 ++++++++++++---
 clippy_lints/src/disallowed_type.rs                | 27 +++++++++++++++-------
 tests/ui-toml/toml_disallowed_method/clippy.toml   |  6 ++++-
 tests/ui-toml/toml_disallowed_type/clippy.toml     |  6 ++---
 .../conf_disallowed_type.stderr                    | 16 ++++++-------
 5 files changed, 50 insertions(+), 23 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/disallowed_method.rs b/clippy_lints/src/disallowed_method.rs
index ded0a0fff54..76a0cba30e5 100644
--- a/clippy_lints/src/disallowed_method.rs
+++ b/clippy_lints/src/disallowed_method.rs
@@ -2,7 +2,7 @@ use clippy_utils::diagnostics::span_lint;
 use clippy_utils::fn_def_id;
 
 use rustc_data_structures::fx::FxHashSet;
-use rustc_hir::Expr;
+use rustc_hir::{def::Res, def_id::DefId, Crate, Expr};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::Symbol;
@@ -52,6 +52,7 @@ declare_clippy_lint! {
 #[derive(Clone, Debug)]
 pub struct DisallowedMethod {
     disallowed: FxHashSet<Vec<Symbol>>,
+    def_ids: FxHashSet<(DefId, Vec<Symbol>)>,
 }
 
 impl DisallowedMethod {
@@ -61,6 +62,7 @@ impl DisallowedMethod {
                 .iter()
                 .map(|s| s.split("::").map(|seg| Symbol::intern(seg)).collect::<Vec<_>>())
                 .collect(),
+            def_ids: FxHashSet::default(),
         }
     }
 }
@@ -68,10 +70,20 @@ impl DisallowedMethod {
 impl_lint_pass!(DisallowedMethod => [DISALLOWED_METHOD]);
 
 impl<'tcx> LateLintPass<'tcx> for DisallowedMethod {
+    fn check_crate(&mut self, cx: &LateContext<'_>, _: &Crate<'_>) {
+        for path in &self.disallowed {
+            let segs = path.iter().map(ToString::to_string).collect::<Vec<_>>();
+            if let Res::Def(_, id) = clippy_utils::path_to_res(cx, &segs.iter().map(String::as_str).collect::<Vec<_>>())
+            {
+                self.def_ids.insert((id, path.clone()));
+            }
+        }
+    }
+
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if let Some(def_id) = fn_def_id(cx, expr) {
-            let func_path = cx.get_def_path(def_id);
-            if self.disallowed.contains(&func_path) {
+            if self.def_ids.iter().any(|(id, _)| def_id == *id) {
+                let func_path = cx.get_def_path(def_id);
                 let func_path_string = func_path
                     .into_iter()
                     .map(Symbol::to_ident_string)
diff --git a/clippy_lints/src/disallowed_type.rs b/clippy_lints/src/disallowed_type.rs
index f8ac7d76d8f..ab775d99b08 100644
--- a/clippy_lints/src/disallowed_type.rs
+++ b/clippy_lints/src/disallowed_type.rs
@@ -1,7 +1,9 @@
 use clippy_utils::diagnostics::span_lint;
 
 use rustc_data_structures::fx::FxHashSet;
-use rustc_hir::{def::Res, Item, ItemKind, PolyTraitRef, TraitBoundModifier, Ty, TyKind, UseKind};
+use rustc_hir::{
+    def::Res, def_id::DefId, Crate, Item, ItemKind, PolyTraitRef, TraitBoundModifier, Ty, TyKind, UseKind,
+};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::{Span, Symbol};
@@ -47,6 +49,7 @@ declare_clippy_lint! {
 #[derive(Clone, Debug)]
 pub struct DisallowedType {
     disallowed: FxHashSet<Vec<Symbol>>,
+    def_ids: FxHashSet<(DefId, Vec<Symbol>)>,
 }
 
 impl DisallowedType {
@@ -56,6 +59,7 @@ impl DisallowedType {
                 .iter()
                 .map(|s| s.split("::").map(|seg| Symbol::intern(seg)).collect::<Vec<_>>())
                 .collect(),
+            def_ids: FxHashSet::default(),
         }
     }
 }
@@ -63,12 +67,21 @@ impl DisallowedType {
 impl_lint_pass!(DisallowedType => [DISALLOWED_TYPE]);
 
 impl<'tcx> LateLintPass<'tcx> for DisallowedType {
+    fn check_crate(&mut self, cx: &LateContext<'_>, _: &Crate<'_>) {
+        for path in &self.disallowed {
+            let segs = path.iter().map(ToString::to_string).collect::<Vec<_>>();
+            if let Res::Def(_, id) = clippy_utils::path_to_res(cx, &segs.iter().map(String::as_str).collect::<Vec<_>>())
+            {
+                self.def_ids.insert((id, path.clone()));
+            }
+        }
+    }
+
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
         if_chain! {
             if let ItemKind::Use(path, UseKind::Single) = &item.kind;
-            if let Res::Def(_, id) = path.res;
-            let use_path = cx.get_def_path(id);
-            if let Some(name) = self.disallowed.iter().find(|path| **path == use_path);
+            if let Res::Def(_, did) = path.res;
+            if let Some((_, name)) = self.def_ids.iter().find(|(id, _)| *id == did);
             then {
                 emit(cx, name, item.span,);
             }
@@ -79,8 +92,7 @@ impl<'tcx> LateLintPass<'tcx> for DisallowedType {
         if_chain! {
             if let TyKind::Path(path) = &ty.kind;
             if let Some(did) = cx.qpath_res(path, ty.hir_id).opt_def_id();
-            let use_path = cx.get_def_path(did);
-            if let Some(name) = self.disallowed.iter().find(|path| **path == use_path);
+            if let Some((_, name)) = self.def_ids.iter().find(|(id, _)| *id == did);
             then {
                 emit(cx, name, path.span());
             }
@@ -90,8 +102,7 @@ impl<'tcx> LateLintPass<'tcx> for DisallowedType {
     fn check_poly_trait_ref(&mut self, cx: &LateContext<'tcx>, poly: &'tcx PolyTraitRef<'tcx>, _: TraitBoundModifier) {
         if_chain! {
             if let Res::Def(_, did) = poly.trait_ref.path.res;
-            let use_path = cx.get_def_path(did);
-            if let Some(name) = self.disallowed.iter().find(|path| **path == use_path);
+            if let Some((_, name)) = self.def_ids.iter().find(|(id, _)| *id == did);
             then {
                 emit(cx, name, poly.trait_ref.path.span);
             }
diff --git a/tests/ui-toml/toml_disallowed_method/clippy.toml b/tests/ui-toml/toml_disallowed_method/clippy.toml
index c0df3b6e8af..a3245da6825 100644
--- a/tests/ui-toml/toml_disallowed_method/clippy.toml
+++ b/tests/ui-toml/toml_disallowed_method/clippy.toml
@@ -1 +1,5 @@
-disallowed-methods = ["core::iter::traits::iterator::Iterator::sum", "regex::re_unicode::Regex::is_match", "regex::re_unicode::Regex::new"]
+disallowed-methods = [
+    "std::iter::Iterator::sum",
+    "regex::Regex::is_match",
+    "regex::Regex::new"
+]
diff --git a/tests/ui-toml/toml_disallowed_type/clippy.toml b/tests/ui-toml/toml_disallowed_type/clippy.toml
index 57dfdc584bb..2eff854c22c 100644
--- a/tests/ui-toml/toml_disallowed_type/clippy.toml
+++ b/tests/ui-toml/toml_disallowed_type/clippy.toml
@@ -1,7 +1,7 @@
 disallowed-types = [
-    "std::collections::hash::map::HashMap",
-    "core::sync::atomic::AtomicU32",
-    "syn::ty::TypePath",
+    "std::collections::HashMap",
+    "std::sync::atomic::AtomicU32",
+    "syn::TypePath",
     "proc_macro2::Ident",
     "std::thread::Thread",
     "std::time::Instant",
diff --git a/tests/ui-toml/toml_disallowed_type/conf_disallowed_type.stderr b/tests/ui-toml/toml_disallowed_type/conf_disallowed_type.stderr
index e5ea23cc0bc..4e6fd91fba1 100644
--- a/tests/ui-toml/toml_disallowed_type/conf_disallowed_type.stderr
+++ b/tests/ui-toml/toml_disallowed_type/conf_disallowed_type.stderr
@@ -1,4 +1,4 @@
-error: `core::sync::atomic::AtomicU32` is not allowed according to config
+error: `std::sync::atomic::AtomicU32` is not allowed according to config
   --> $DIR/conf_disallowed_type.rs:7:1
    |
 LL | use std::sync::atomic::AtomicU32;
@@ -24,7 +24,7 @@ error: `std::time::Instant` is not allowed according to config
 LL | fn bad_arg_type(_: impl Fn(Sneaky) -> foo::atomic::AtomicU32) {
    |                            ^^^^^^
 
-error: `core::sync::atomic::AtomicU32` is not allowed according to config
+error: `std::sync::atomic::AtomicU32` is not allowed according to config
   --> $DIR/conf_disallowed_type.rs:16:39
    |
 LL | fn bad_arg_type(_: impl Fn(Sneaky) -> foo::atomic::AtomicU32) {
@@ -36,13 +36,13 @@ error: `std::io::Read` is not allowed according to config
 LL | fn trait_obj(_: &dyn std::io::Read) {
    |                      ^^^^^^^^^^^^^
 
-error: `std::collections::hash::map::HashMap` is not allowed according to config
+error: `std::collections::HashMap` is not allowed according to config
   --> $DIR/conf_disallowed_type.rs:28:48
    |
 LL |     let _: std::collections::HashMap<(), ()> = std::collections::HashMap::new();
    |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: `std::collections::hash::map::HashMap` is not allowed according to config
+error: `std::collections::HashMap` is not allowed according to config
   --> $DIR/conf_disallowed_type.rs:28:12
    |
 LL |     let _: std::collections::HashMap<(), ()> = std::collections::HashMap::new();
@@ -54,25 +54,25 @@ error: `std::time::Instant` is not allowed according to config
 LL |     let _ = Sneaky::now();
    |             ^^^^^^
 
-error: `core::sync::atomic::AtomicU32` is not allowed according to config
+error: `std::sync::atomic::AtomicU32` is not allowed according to config
   --> $DIR/conf_disallowed_type.rs:30:13
    |
 LL |     let _ = foo::atomic::AtomicU32::new(0);
    |             ^^^^^^^^^^^^^^^^^^^^^^
 
-error: `core::sync::atomic::AtomicU32` is not allowed according to config
+error: `std::sync::atomic::AtomicU32` is not allowed according to config
   --> $DIR/conf_disallowed_type.rs:31:17
    |
 LL |     static FOO: std::sync::atomic::AtomicU32 = foo::atomic::AtomicU32::new(1);
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: `core::sync::atomic::AtomicU32` is not allowed according to config
+error: `std::sync::atomic::AtomicU32` is not allowed according to config
   --> $DIR/conf_disallowed_type.rs:31:48
    |
 LL |     static FOO: std::sync::atomic::AtomicU32 = foo::atomic::AtomicU32::new(1);
    |                                                ^^^^^^^^^^^^^^^^^^^^^^
 
-error: `syn::ty::TypePath` is not allowed according to config
+error: `syn::TypePath` is not allowed according to config
   --> $DIR/conf_disallowed_type.rs:32:43
    |
 LL |     let _: std::collections::BTreeMap<(), syn::TypePath> = Default::default();
-- 
cgit 1.4.1-3-g733a5


From d4eff81282d4784951ae52ffc3b8fe1c948f872e Mon Sep 17 00:00:00 2001
From: Devin Ragotzy <devin.ragotzy@gmail.com>
Date: Sun, 13 Jun 2021 15:52:54 -0400
Subject: fixup! Remove requirement of fully qualified path for
 disallowed_method/type

---
 clippy_lints/src/disallowed_method.rs | 11 ++---------
 clippy_lints/src/disallowed_type.rs   | 11 ++---------
 2 files changed, 4 insertions(+), 18 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/disallowed_method.rs b/clippy_lints/src/disallowed_method.rs
index 76a0cba30e5..aa1a609afed 100644
--- a/clippy_lints/src/disallowed_method.rs
+++ b/clippy_lints/src/disallowed_method.rs
@@ -13,21 +13,14 @@ declare_clippy_lint! {
     /// **Why is this bad?** Some methods are undesirable in certain contexts,
     /// and it's beneficial to lint for them as needed.
     ///
-    /// **Known problems:** Currently, you must write each function as a
-    /// fully-qualified path. This lint doesn't support aliases or reexported
-    /// names; be aware that many types in `std` are actually reexports.
-    ///
-    /// For example, if you want to disallow `Duration::as_secs`, your clippy.toml
-    /// configuration would look like
-    /// `disallowed-methods = ["core::time::Duration::as_secs"]` and not
-    /// `disallowed-methods = ["std::time::Duration::as_secs"]` as you might expect.
+    /// **Known problems:** None.
     ///
     /// **Example:**
     ///
     /// An example clippy.toml configuration:
     /// ```toml
     /// # clippy.toml
-    /// disallowed-methods = ["alloc::vec::Vec::leak", "std::time::Instant::now"]
+    /// disallowed-methods = ["std::vec::Vec::leak", "std::time::Instant::now"]
     /// ```
     ///
     /// ```rust,ignore
diff --git a/clippy_lints/src/disallowed_type.rs b/clippy_lints/src/disallowed_type.rs
index ab775d99b08..e4a88c6324e 100644
--- a/clippy_lints/src/disallowed_type.rs
+++ b/clippy_lints/src/disallowed_type.rs
@@ -13,14 +13,7 @@ declare_clippy_lint! {
     ///
     /// **Why is this bad?** Some types are undesirable in certain contexts.
     ///
-    /// **Known problems:** The fully qualified path must be used. This lint
-    /// doesn't support aliases or reexported names; be aware that many types
-    /// in `std` are actually reexports.
-    ///
-    /// For example, if you want to disallow `BTreeMap`, your clippy.toml
-    /// configuration would look like
-    /// `disallowed-methods = ["alloc::collections::btree::map::BTreeMap"]` and not
-    /// `disallowed-methods = ["std::collections::BTreeMap"]` as you might expect.
+    /// **Known problems:** None.
     ///
     /// N.B. There is no way to ban primitive types.
     ///
@@ -29,7 +22,7 @@ declare_clippy_lint! {
     /// An example clippy.toml configuration:
     /// ```toml
     /// # clippy.toml
-    /// disallowed-methods = ["alloc::collections::btree::map::BTreeMap"]
+    /// disallowed-methods = ["std::collections::BTreeMap"]
     /// ```
     ///
     /// ```rust,ignore
-- 
cgit 1.4.1-3-g733a5


From a557f37bb4e03bc9ce75e4e22dea68c17f73f01b Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Mon, 14 Jun 2021 14:10:19 -0500
Subject: Improve metadata code block parsing

---
 .../src/utils/internal_lints/metadata_collector.rs | 37 ++++++++++++++++------
 1 file changed, 27 insertions(+), 10 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index 46af03663b8..c980a0246fd 100644
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -9,6 +9,7 @@
 //! a simple mistake)
 
 use if_chain::if_chain;
+use rustc_ast as ast;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_hir::{
     self as hir, def::DefKind, intravisit, intravisit::Visitor, ExprKind, Item, ItemKind, Mutability, QPath,
@@ -485,16 +486,32 @@ fn extract_attr_docs_or_lint(cx: &LateContext<'_>, item: &Item<'_>) -> Option<St
 ///
 /// Would result in `Hello world!\n=^.^=\n`
 fn extract_attr_docs(cx: &LateContext<'_>, item: &Item<'_>) -> Option<String> {
-    cx.tcx
-        .hir()
-        .attrs(item.hir_id())
-        .iter()
-        .filter_map(|x| x.doc_str().map(|sym| sym.as_str().to_string()))
-        .reduce(|mut acc, sym| {
-            acc.push_str(&sym);
-            acc.push('\n');
-            acc
-        })
+    let attrs = cx.tcx.hir().attrs(item.hir_id());
+    let mut lines = attrs.iter().filter_map(ast::Attribute::doc_str);
+    let mut docs = String::from(&*lines.next()?.as_str());
+    let mut in_code_block = false;
+    for line in lines {
+        docs.push('\n');
+        let line = line.as_str();
+        let line = &*line;
+        if let Some(info) = line.trim_start().strip_prefix("```") {
+            in_code_block = !in_code_block;
+            if in_code_block {
+                let lang = info
+                    .trim()
+                    .split(',')
+                    // remove rustdoc directives
+                    .find(|&s| !matches!(s, "" | "ignore" | "no_run" | "should_panic"))
+                    // if no language is present, fill in "rust"
+                    .unwrap_or("rust");
+                docs.push_str("```");
+                docs.push_str(lang);
+                continue;
+            }
+        }
+        docs.push_str(line);
+    }
+    Some(docs)
 }
 
 fn get_lint_group_and_level_or_lint(
-- 
cgit 1.4.1-3-g733a5


From 723f515b6006706b88d22c8edb05330df6365a63 Mon Sep 17 00:00:00 2001
From: Devin Ragotzy <devin.ragotzy@gmail.com>
Date: Sun, 30 May 2021 17:58:32 -0400
Subject: Add macro_braces lint to check for irregular brace use in certain
 macros

Rename unconventional -> nonstandard, add config field

Add standard_macro_braces fields so users can specify macro names and
brace combinations to lint for in the clippy.toml file.

Fix errors caused by nonstandard_macro_braces in other lint tests

Fix users ability to override the default nonstandard macro braces

Add type position macros impl `check_ty`
---
 CHANGELOG.md                                       |   1 +
 clippy_lints/src/lib.rs                            |   6 +
 clippy_lints/src/nonstandard_macro_braces.rs       | 276 +++++++++++++++++++++
 clippy_lints/src/utils/conf.rs                     |  16 +-
 tests/ui-toml/nonstandard_macro_braces/clippy.toml |   6 +
 .../conf_nonstandard_macro_braces.rs               |  44 ++++
 .../conf_nonstandard_macro_braces.stderr           |  94 +++++++
 .../toml_unknown_key/conf_unknown_key.stderr       |   2 +-
 tests/ui/unnecessary_cast_fixable.fixed            |   2 +-
 tests/ui/unnecessary_cast_fixable.rs               |   2 +-
 tests/ui/vec.fixed                                 |   2 +-
 tests/ui/vec.rs                                    |   2 +-
 12 files changed, 443 insertions(+), 10 deletions(-)
 create mode 100644 clippy_lints/src/nonstandard_macro_braces.rs
 create mode 100644 tests/ui-toml/nonstandard_macro_braces/clippy.toml
 create mode 100644 tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.rs
 create mode 100644 tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 13f0fc8f609..c30a0849348 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2575,6 +2575,7 @@ Released 2018-09-13
 [`non_octal_unix_permissions`]: https://rust-lang.github.io/rust-clippy/master/index.html#non_octal_unix_permissions
 [`nonminimal_bool`]: https://rust-lang.github.io/rust-clippy/master/index.html#nonminimal_bool
 [`nonsensical_open_options`]: https://rust-lang.github.io/rust-clippy/master/index.html#nonsensical_open_options
+[`nonstandard_macro_braces`]: https://rust-lang.github.io/rust-clippy/master/index.html#nonstandard_macro_braces
 [`not_unsafe_ptr_arg_deref`]: https://rust-lang.github.io/rust-clippy/master/index.html#not_unsafe_ptr_arg_deref
 [`ok_expect`]: https://rust-lang.github.io/rust-clippy/master/index.html#ok_expect
 [`op_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#op_ref
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 591bf68f927..e3fbd1adee9 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -293,6 +293,7 @@ mod no_effect;
 mod non_copy_const;
 mod non_expressive_names;
 mod non_octal_unix_permissions;
+mod nonstandard_macro_braces;
 mod open_options;
 mod option_env_unwrap;
 mod option_if_let_else;
@@ -844,6 +845,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         non_expressive_names::MANY_SINGLE_CHAR_NAMES,
         non_expressive_names::SIMILAR_NAMES,
         non_octal_unix_permissions::NON_OCTAL_UNIX_PERMISSIONS,
+        nonstandard_macro_braces::NONSTANDARD_MACRO_BRACES,
         open_options::NONSENSICAL_OPEN_OPTIONS,
         option_env_unwrap::OPTION_ENV_UNWRAP,
         option_if_let_else::OPTION_IF_LET_ELSE,
@@ -1360,6 +1362,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(non_expressive_names::JUST_UNDERSCORES_AND_DIGITS),
         LintId::of(non_expressive_names::MANY_SINGLE_CHAR_NAMES),
         LintId::of(non_octal_unix_permissions::NON_OCTAL_UNIX_PERMISSIONS),
+        LintId::of(nonstandard_macro_braces::NONSTANDARD_MACRO_BRACES),
         LintId::of(open_options::NONSENSICAL_OPEN_OPTIONS),
         LintId::of(option_env_unwrap::OPTION_ENV_UNWRAP),
         LintId::of(overflow_check_conditional::OVERFLOW_CHECK_CONDITIONAL),
@@ -1536,6 +1539,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(non_copy_const::DECLARE_INTERIOR_MUTABLE_CONST),
         LintId::of(non_expressive_names::JUST_UNDERSCORES_AND_DIGITS),
         LintId::of(non_expressive_names::MANY_SINGLE_CHAR_NAMES),
+        LintId::of(nonstandard_macro_braces::NONSTANDARD_MACRO_BRACES),
         LintId::of(ptr::CMP_NULL),
         LintId::of(ptr::PTR_ARG),
         LintId::of(ptr_eq::PTR_EQ),
@@ -2040,6 +2044,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_early_pass(move || box non_expressive_names::NonExpressiveNames {
         single_char_binding_names_threshold,
     });
+    let macro_matcher = conf.standard_macro_braces.iter().cloned().collect::<FxHashSet<_>>();
+    store.register_early_pass(move || box nonstandard_macro_braces::MacroBraces::new(&macro_matcher));
     store.register_late_pass(|| box macro_use::MacroUseImports::default());
     store.register_late_pass(|| box pattern_type_mismatch::PatternTypeMismatch);
     store.register_late_pass(|| box stable_sort_primitive::StableSortPrimitive);
diff --git a/clippy_lints/src/nonstandard_macro_braces.rs b/clippy_lints/src/nonstandard_macro_braces.rs
new file mode 100644
index 00000000000..1adad5be6dd
--- /dev/null
+++ b/clippy_lints/src/nonstandard_macro_braces.rs
@@ -0,0 +1,276 @@
+use std::{
+    fmt,
+    hash::{Hash, Hasher},
+};
+
+use clippy_utils::{diagnostics::span_lint_and_help, in_macro, is_direct_expn_of, source::snippet_opt};
+use if_chain::if_chain;
+use rustc_ast::ast;
+use rustc_data_structures::fx::{FxHashMap, FxHashSet};
+use rustc_lint::{EarlyContext, EarlyLintPass};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::Span;
+use serde::{de, Deserialize};
+
+declare_clippy_lint! {
+    /// **What it does:** Checks that common macros are used with consistent bracing.
+    ///
+    /// **Why is this bad?** This is mostly a consistency lint although using () or []
+    /// doesn't give you a semicolon in item position, which can be unexpected.
+    ///
+    /// **Known problems:**
+    /// None
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// vec!{1, 2, 3};
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// vec![1, 2, 3];
+    /// ```
+    pub NONSTANDARD_MACRO_BRACES,
+    style,
+    "check consistent use of braces in macro"
+}
+
+const BRACES: &[(&str, &str)] = &[("(", ")"), ("{", "}"), ("[", "]")];
+
+/// The (name, (open brace, close brace), source snippet)
+type MacroInfo<'a> = (&'a str, &'a (String, String), String);
+
+#[derive(Clone, Debug, Default)]
+pub struct MacroBraces {
+    macro_braces: FxHashMap<String, (String, String)>,
+    done: FxHashSet<Span>,
+}
+
+impl MacroBraces {
+    pub fn new(conf: &FxHashSet<MacroMatcher>) -> Self {
+        let macro_braces = macro_braces(conf.clone());
+        Self {
+            macro_braces,
+            done: FxHashSet::default(),
+        }
+    }
+}
+
+impl_lint_pass!(MacroBraces => [NONSTANDARD_MACRO_BRACES]);
+
+impl EarlyLintPass for MacroBraces {
+    fn check_item(&mut self, cx: &EarlyContext<'_>, item: &ast::Item) {
+        if let Some((name, braces, snip)) = is_offending_macro(cx, item.span, self) {
+            let span = item.span.ctxt().outer_expn_data().call_site;
+            emit_help(cx, snip, braces, name, span);
+            self.done.insert(span);
+        }
+    }
+
+    fn check_stmt(&mut self, cx: &EarlyContext<'_>, stmt: &ast::Stmt) {
+        if let Some((name, braces, snip)) = is_offending_macro(cx, stmt.span, self) {
+            let span = stmt.span.ctxt().outer_expn_data().call_site;
+            emit_help(cx, snip, braces, name, span);
+            self.done.insert(span);
+        }
+    }
+
+    fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &ast::Expr) {
+        if let Some((name, braces, snip)) = is_offending_macro(cx, expr.span, self) {
+            let span = expr.span.ctxt().outer_expn_data().call_site;
+            emit_help(cx, snip, braces, name, span);
+            self.done.insert(span);
+        }
+    }
+
+    fn check_ty(&mut self, cx: &EarlyContext<'_>, ty: &ast::Ty) {
+        if let Some((name, braces, snip)) = is_offending_macro(cx, ty.span, self) {
+            let span = ty.span.ctxt().outer_expn_data().call_site;
+            emit_help(cx, snip, braces, name, span);
+            self.done.insert(span);
+        }
+    }
+}
+
+fn is_offending_macro<'a>(cx: &EarlyContext<'_>, span: Span, this: &'a MacroBraces) -> Option<MacroInfo<'a>> {
+    if_chain! {
+        if in_macro(span);
+        if let Some((name, braces)) = find_matching_macro(span, &this.macro_braces);
+        if let Some(snip) = snippet_opt(cx, span.ctxt().outer_expn_data().call_site);
+        let c = snip.replace(" ", ""); // make formatting consistent
+        if !c.starts_with(&format!("{}!{}", name, braces.0));
+        if !this.done.contains(&span.ctxt().outer_expn_data().call_site);
+        then {
+            Some((name, braces, snip))
+        } else {
+            None
+        }
+    }
+}
+
+fn emit_help(cx: &EarlyContext<'_>, snip: String, braces: &(String, String), name: &str, span: Span) {
+    let with_space = &format!("! {}", braces.0);
+    let without_space = &format!("!{}", braces.0);
+    let mut help = snip;
+    for b in BRACES.iter().filter(|b| b.0 != braces.0) {
+        help = help.replace(b.0, &braces.0).replace(b.1, &braces.1);
+        // Only `{` traditionally has space before the brace
+        if braces.0 != "{" && help.contains(with_space) {
+            help = help.replace(with_space, without_space);
+        } else if braces.0 == "{" && help.contains(without_space) {
+            help = help.replace(without_space, with_space);
+        }
+    }
+    span_lint_and_help(
+        cx,
+        NONSTANDARD_MACRO_BRACES,
+        span,
+        &format!("use of irregular braces for `{}!` macro", name),
+        Some(span),
+        &format!("consider writing `{}`", help),
+    );
+}
+
+fn find_matching_macro(
+    span: Span,
+    braces: &FxHashMap<String, (String, String)>,
+) -> Option<(&String, &(String, String))> {
+    braces
+        .iter()
+        .find(|(macro_name, _)| is_direct_expn_of(span, macro_name).is_some())
+}
+
+fn macro_braces(conf: FxHashSet<MacroMatcher>) -> FxHashMap<String, (String, String)> {
+    let mut braces = vec![
+        macro_matcher!(
+            name: "print",
+            braces: ("(", ")"),
+        ),
+        macro_matcher!(
+            name: "println",
+            braces: ("(", ")"),
+        ),
+        macro_matcher!(
+            name: "eprint",
+            braces: ("(", ")"),
+        ),
+        macro_matcher!(
+            name: "eprintln",
+            braces: ("(", ")"),
+        ),
+        macro_matcher!(
+            name: "write",
+            braces: ("(", ")"),
+        ),
+        macro_matcher!(
+            name: "writeln",
+            braces: ("(", ")"),
+        ),
+        macro_matcher!(
+            name: "format",
+            braces: ("(", ")"),
+        ),
+        macro_matcher!(
+            name: "format_args",
+            braces: ("(", ")"),
+        ),
+        macro_matcher!(
+            name: "vec",
+            braces: ("[", "]"),
+        ),
+    ]
+    .into_iter()
+    .collect::<FxHashMap<_, _>>();
+    // We want users items to override any existing items
+    for it in conf {
+        braces.insert(it.name, it.braces);
+    }
+    braces
+}
+
+macro_rules! macro_matcher {
+    (name: $name:expr, braces: ($open:expr, $close:expr) $(,)?) => {
+        ($name.to_owned(), ($open.to_owned(), $close.to_owned()))
+    };
+}
+pub(crate) use macro_matcher;
+
+#[derive(Clone, Debug)]
+pub struct MacroMatcher {
+    name: String,
+    braces: (String, String),
+}
+
+impl Hash for MacroMatcher {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.name.hash(state);
+    }
+}
+
+impl PartialEq for MacroMatcher {
+    fn eq(&self, other: &Self) -> bool {
+        self.name == other.name
+    }
+}
+impl Eq for MacroMatcher {}
+
+impl<'de> Deserialize<'de> for MacroMatcher {
+    fn deserialize<D>(deser: D) -> Result<Self, D::Error>
+    where
+        D: de::Deserializer<'de>,
+    {
+        #[derive(Deserialize)]
+        #[serde(field_identifier, rename_all = "lowercase")]
+        enum Field {
+            Name,
+            Brace,
+        }
+        struct MacVisitor;
+        impl<'de> de::Visitor<'de> for MacVisitor {
+            type Value = MacroMatcher;
+
+            fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+                formatter.write_str("struct MacroMatcher")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> Result<Self::Value, V::Error>
+            where
+                V: de::MapAccess<'de>,
+            {
+                let mut name = None;
+                let mut brace: Option<&str> = None;
+                while let Some(key) = map.next_key()? {
+                    match key {
+                        Field::Name => {
+                            if name.is_some() {
+                                return Err(de::Error::duplicate_field("name"));
+                            }
+                            name = Some(map.next_value()?);
+                        },
+                        Field::Brace => {
+                            if brace.is_some() {
+                                return Err(de::Error::duplicate_field("brace"));
+                            }
+                            brace = Some(map.next_value()?);
+                        },
+                    }
+                }
+                let name = name.ok_or_else(|| de::Error::missing_field("name"))?;
+                let brace = brace.ok_or_else(|| de::Error::missing_field("brace"))?;
+                Ok(MacroMatcher {
+                    name,
+                    braces: BRACES
+                        .iter()
+                        .find(|b| b.0 == brace)
+                        .map(|(o, c)| ((*o).to_owned(), (*c).to_owned()))
+                        .ok_or_else(|| {
+                            de::Error::custom(&format!("expected one of `(`, `{{`, `[` found `{}`", brace))
+                        })?,
+                })
+            }
+        }
+
+        const FIELDS: &[&str] = &["name", "brace"];
+        deser.deserialize_struct("MacroMatcher", FIELDS, MacVisitor)
+    }
+}
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index ad2cb27650e..cb335522f61 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -26,13 +26,13 @@ impl TryConf {
 
 macro_rules! define_Conf {
     ($(
-        #[doc = $doc:literal]
+        $(#[doc = $doc:literal])*
         $(#[conf_deprecated($dep:literal)])?
         ($name:ident: $ty:ty = $default:expr),
     )*) => {
         /// Clippy lint configuration
         pub struct Conf {
-            $(#[doc = $doc] pub $name: $ty,)*
+            $($(#[doc = $doc])* pub $name: $ty,)*
         }
 
         mod defaults {
@@ -109,7 +109,7 @@ macro_rules! define_Conf {
                                 stringify!($name),
                                 stringify!($ty),
                                 format!("{:?}", super::defaults::$name()),
-                                $doc,
+                                concat!($($doc,)*),
                                 deprecation_reason,
                             )
                         },
@@ -182,9 +182,9 @@ define_Conf! {
     (vec_box_size_threshold: u64 = 4096),
     /// Lint: TYPE_REPETITION_IN_BOUNDS. The maximum number of bounds a trait can have to be linted
     (max_trait_bounds: u64 = 3),
-    /// Lint: STRUCT_EXCESSIVE_BOOLS. The maximum number of bools a struct can have
+    /// Lint: STRUCT_EXCESSIVE_BOOLS. The maximum number of bool fields a struct can have
     (max_struct_bools: u64 = 3),
-    /// Lint: FN_PARAMS_EXCESSIVE_BOOLS. The maximum number of bools function parameters can have
+    /// Lint: FN_PARAMS_EXCESSIVE_BOOLS. The maximum number of bool parameters a function can have
     (max_fn_params_bools: u64 = 3),
     /// Lint: WILDCARD_IMPORTS. Whether to allow certain wildcard imports (prelude, super in tests).
     (warn_on_all_wildcard_imports: bool = false),
@@ -198,6 +198,12 @@ define_Conf! {
     (upper_case_acronyms_aggressive: bool = false),
     /// Lint: _CARGO_COMMON_METADATA. For internal testing only, ignores the current `publish` settings in the Cargo manifest.
     (cargo_ignore_publish: bool = false),
+    /// Lint: NONSTANDARD_MACRO_BRACES. Enforce the named macros always use the braces specified.
+    ///
+    /// A `MacroMatcher` can be added like so `{ name = "macro_name", brace = "(" }`.
+    /// If the macro is could be used with a full path two `MacroMatcher`s have to be added one
+    /// with the full path `crate_name::macro_name` and one with just the macro name.
+    (standard_macro_braces: Vec<crate::nonstandard_macro_braces::MacroMatcher> = Vec::new()),
 }
 
 /// Search for the configuration file.
diff --git a/tests/ui-toml/nonstandard_macro_braces/clippy.toml b/tests/ui-toml/nonstandard_macro_braces/clippy.toml
new file mode 100644
index 00000000000..bced8948a02
--- /dev/null
+++ b/tests/ui-toml/nonstandard_macro_braces/clippy.toml
@@ -0,0 +1,6 @@
+standard-macro-braces = [
+    { name = "quote", brace = "{" },
+    { name = "quote::quote", brace = "{" },
+    { name = "eprint", brace = "[" },
+    { name = "type_pos", brace = "[" },
+]
diff --git a/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.rs b/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.rs
new file mode 100644
index 00000000000..4ae6864cbb0
--- /dev/null
+++ b/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.rs
@@ -0,0 +1,44 @@
+// #![warn(clippy::nonstandard_macro_braces)]
+
+extern crate quote;
+
+use quote::quote;
+
+#[rustfmt::skip]
+macro_rules! test {
+    () => {
+        vec!{0, 0, 0}
+    };
+}
+
+#[rustfmt::skip]
+macro_rules! test2 {
+    ($($arg:tt)*) => {
+        format_args!($($arg)*)
+    };
+}
+
+macro_rules! type_pos {
+    ($what:ty) => {
+        Vec<$what>
+    };
+}
+
+#[rustfmt::skip]
+fn main() {
+    let _ = vec! {1, 2, 3};
+    let _ = format!["ugh {} stop being such a good compiler", "hello"];
+    let _ = quote!(let x = 1;);
+    let _ = quote::quote!(match match match);
+    let _ = test!();
+    let _ = vec![1,2,3];
+
+    let _ = quote::quote! {true || false};
+    let _ = vec! [0 ,0 ,0];
+    let _ = format!("fds{}fds", 10);
+    let _ = test2!["{}{}{}", 1, 2, 3];
+
+    let _: type_pos!(usize) = vec![];
+
+    eprint!("test if user config overrides defaults");
+}
diff --git a/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.stderr b/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.stderr
new file mode 100644
index 00000000000..7bcd1829524
--- /dev/null
+++ b/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.stderr
@@ -0,0 +1,94 @@
+error: use of irregular braces for `vec!` macro
+  --> $DIR/conf_nonstandard_macro_braces.rs:29:13
+   |
+LL |     let _ = vec! {1, 2, 3};
+   |             ^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::nonstandard-macro-braces` implied by `-D warnings`
+help: consider writing `vec![1, 2, 3]`
+  --> $DIR/conf_nonstandard_macro_braces.rs:29:13
+   |
+LL |     let _ = vec! {1, 2, 3};
+   |             ^^^^^^^^^^^^^^
+
+error: use of irregular braces for `format!` macro
+  --> $DIR/conf_nonstandard_macro_braces.rs:30:13
+   |
+LL |     let _ = format!["ugh {} stop being such a good compiler", "hello"];
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider writing `format!("ugh () stop being such a good compiler", "hello")`
+  --> $DIR/conf_nonstandard_macro_braces.rs:30:13
+   |
+LL |     let _ = format!["ugh {} stop being such a good compiler", "hello"];
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: use of irregular braces for `quote!` macro
+  --> $DIR/conf_nonstandard_macro_braces.rs:31:13
+   |
+LL |     let _ = quote!(let x = 1;);
+   |             ^^^^^^^^^^^^^^^^^^
+   |
+help: consider writing `quote! {let x = 1;}`
+  --> $DIR/conf_nonstandard_macro_braces.rs:31:13
+   |
+LL |     let _ = quote!(let x = 1;);
+   |             ^^^^^^^^^^^^^^^^^^
+
+error: use of irregular braces for `quote::quote!` macro
+  --> $DIR/conf_nonstandard_macro_braces.rs:32:13
+   |
+LL |     let _ = quote::quote!(match match match);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider writing `quote::quote! {match match match}`
+  --> $DIR/conf_nonstandard_macro_braces.rs:32:13
+   |
+LL |     let _ = quote::quote!(match match match);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: use of irregular braces for `vec!` macro
+  --> $DIR/conf_nonstandard_macro_braces.rs:10:9
+   |
+LL |         vec!{0, 0, 0}
+   |         ^^^^^^^^^^^^^
+...
+LL |     let _ = test!();
+   |             ------- in this macro invocation
+   |
+help: consider writing `vec![0, 0, 0]`
+  --> $DIR/conf_nonstandard_macro_braces.rs:10:9
+   |
+LL |         vec!{0, 0, 0}
+   |         ^^^^^^^^^^^^^
+...
+LL |     let _ = test!();
+   |             ------- in this macro invocation
+   = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: use of irregular braces for `type_pos!` macro
+  --> $DIR/conf_nonstandard_macro_braces.rs:41:12
+   |
+LL |     let _: type_pos!(usize) = vec![];
+   |            ^^^^^^^^^^^^^^^^
+   |
+help: consider writing `type_pos![usize]`
+  --> $DIR/conf_nonstandard_macro_braces.rs:41:12
+   |
+LL |     let _: type_pos!(usize) = vec![];
+   |            ^^^^^^^^^^^^^^^^
+
+error: use of irregular braces for `eprint!` macro
+  --> $DIR/conf_nonstandard_macro_braces.rs:43:5
+   |
+LL |     eprint!("test if user config overrides defaults");
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider writing `eprint!["test if user config overrides defaults"];`
+  --> $DIR/conf_nonstandard_macro_braces.rs:43:5
+   |
+LL |     eprint!("test if user config overrides defaults");
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 7 previous errors
+
diff --git a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
index 06d70b66fda..f179479cbec 100644
--- a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
+++ b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
@@ -1,4 +1,4 @@
-error: error reading Clippy's configuration file `$DIR/clippy.toml`: unknown field `foobar`, expected one of `avoid-breaking-exported-api`, `msrv`, `blacklisted-names`, `cognitive-complexity-threshold`, `cyclomatic-complexity-threshold`, `doc-valid-idents`, `too-many-arguments-threshold`, `type-complexity-threshold`, `single-char-binding-names-threshold`, `too-large-for-stack`, `enum-variant-name-threshold`, `enum-variant-size-threshold`, `verbose-bit-mask-threshold`, `literal-representation-threshold`, `trivial-copy-size-limit`, `pass-by-value-size-limit`, `too-many-lines-threshold`, `array-size-threshold`, `vec-box-size-threshold`, `max-trait-bounds`, `max-struct-bools`, `max-fn-params-bools`, `warn-on-all-wildcard-imports`, `disallowed-methods`, `disallowed-types`, `unreadable-literal-lint-fractions`, `upper-case-acronyms-aggressive`, `cargo-ignore-publish`, `third-party` at line 5 column 1
+error: error reading Clippy's configuration file `$DIR/clippy.toml`: unknown field `foobar`, expected one of `avoid-breaking-exported-api`, `msrv`, `blacklisted-names`, `cognitive-complexity-threshold`, `cyclomatic-complexity-threshold`, `doc-valid-idents`, `too-many-arguments-threshold`, `type-complexity-threshold`, `single-char-binding-names-threshold`, `too-large-for-stack`, `enum-variant-name-threshold`, `enum-variant-size-threshold`, `verbose-bit-mask-threshold`, `literal-representation-threshold`, `trivial-copy-size-limit`, `pass-by-value-size-limit`, `too-many-lines-threshold`, `array-size-threshold`, `vec-box-size-threshold`, `max-trait-bounds`, `max-struct-bools`, `max-fn-params-bools`, `warn-on-all-wildcard-imports`, `disallowed-methods`, `disallowed-types`, `unreadable-literal-lint-fractions`, `upper-case-acronyms-aggressive`, `cargo-ignore-publish`, `standard-macro-braces`, `third-party` at line 5 column 1
 
 error: aborting due to previous error
 
diff --git a/tests/ui/unnecessary_cast_fixable.fixed b/tests/ui/unnecessary_cast_fixable.fixed
index 7fbce58a82f..bda0f2c47cd 100644
--- a/tests/ui/unnecessary_cast_fixable.fixed
+++ b/tests/ui/unnecessary_cast_fixable.fixed
@@ -1,7 +1,7 @@
 // run-rustfix
 
 #![warn(clippy::unnecessary_cast)]
-#![allow(clippy::no_effect, clippy::unnecessary_operation)]
+#![allow(clippy::no_effect, clippy::unnecessary_operation, clippy::nonstandard_macro_braces)]
 
 fn main() {
     // casting integer literal to float is unnecessary
diff --git a/tests/ui/unnecessary_cast_fixable.rs b/tests/ui/unnecessary_cast_fixable.rs
index a71363ea4d2..f7a4f2a5988 100644
--- a/tests/ui/unnecessary_cast_fixable.rs
+++ b/tests/ui/unnecessary_cast_fixable.rs
@@ -1,7 +1,7 @@
 // run-rustfix
 
 #![warn(clippy::unnecessary_cast)]
-#![allow(clippy::no_effect, clippy::unnecessary_operation)]
+#![allow(clippy::no_effect, clippy::unnecessary_operation, clippy::nonstandard_macro_braces)]
 
 fn main() {
     // casting integer literal to float is unnecessary
diff --git a/tests/ui/vec.fixed b/tests/ui/vec.fixed
index da35f2e5c1b..318f9c2dceb 100644
--- a/tests/ui/vec.fixed
+++ b/tests/ui/vec.fixed
@@ -1,5 +1,5 @@
 // run-rustfix
-
+#![allow(clippy::nonstandard_macro_braces)]
 #![warn(clippy::useless_vec)]
 
 #[derive(Debug)]
diff --git a/tests/ui/vec.rs b/tests/ui/vec.rs
index e9ed83e5c5a..d7673ce3e64 100644
--- a/tests/ui/vec.rs
+++ b/tests/ui/vec.rs
@@ -1,5 +1,5 @@
 // run-rustfix
-
+#![allow(clippy::nonstandard_macro_braces)]
 #![warn(clippy::useless_vec)]
 
 #[derive(Debug)]
-- 
cgit 1.4.1-3-g733a5


From a40fd6da7e49eea2c8b77a95f274d249186ba7ce Mon Sep 17 00:00:00 2001
From: Dirkjan Ochtman <dirkjan@ochtman.nl>
Date: Fri, 18 Jun 2021 22:18:16 +0200
Subject: Move from-iter-instead-of-collect to pedantic

Since FromIterator will become part of the prelude, this lint being
warn by default is incongruous with the libs team position on the topic.
---
 clippy_lints/src/lib.rs         | 3 +--
 clippy_lints/src/methods/mod.rs | 2 +-
 2 files changed, 2 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 5ab333f8aa1..f5082468a77 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1092,6 +1092,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(methods::CLONED_INSTEAD_OF_COPIED),
         LintId::of(methods::FILTER_MAP_NEXT),
         LintId::of(methods::FLAT_MAP_OPTION),
+        LintId::of(methods::FROM_ITER_INSTEAD_OF_COLLECT),
         LintId::of(methods::IMPLICIT_CLONE),
         LintId::of(methods::INEFFICIENT_TO_STRING),
         LintId::of(methods::MAP_FLATTEN),
@@ -1288,7 +1289,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(methods::FILTER_MAP_IDENTITY),
         LintId::of(methods::FILTER_NEXT),
         LintId::of(methods::FLAT_MAP_IDENTITY),
-        LintId::of(methods::FROM_ITER_INSTEAD_OF_COLLECT),
         LintId::of(methods::INSPECT_FOR_EACH),
         LintId::of(methods::INTO_ITER_ON_REF),
         LintId::of(methods::ITERATOR_STEP_BY_ZERO),
@@ -1504,7 +1504,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(methods::BYTES_NTH),
         LintId::of(methods::CHARS_LAST_CMP),
         LintId::of(methods::CHARS_NEXT_CMP),
-        LintId::of(methods::FROM_ITER_INSTEAD_OF_COLLECT),
         LintId::of(methods::INTO_ITER_ON_REF),
         LintId::of(methods::ITER_CLONED_COLLECT),
         LintId::of(methods::ITER_NEXT_SLICE),
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index b556dcb4dfe..c6bef7bc5d5 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1530,7 +1530,7 @@ declare_clippy_lint! {
     /// assert_eq!(v, vec![5, 5, 5, 5, 5]);
     /// ```
     pub FROM_ITER_INSTEAD_OF_COLLECT,
-    style,
+    pedantic,
     "use `.collect()` instead of `::from_iter()`"
 }
 
-- 
cgit 1.4.1-3-g733a5


From 8276f26a4d189e9898aabf09e16605f35fa92318 Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Sun, 20 Jun 2021 13:48:44 +0200
Subject: Fix wrong config option being suggested for deprecated
 wrong_pub_self_convention lint

Problem:
for code like
````
fn main() {
    println!("Hello, world!");
}
````
clippy will issue a warning to use a clippy.toml option instead:

````
warning: lint `clippy::wrong_pub_self_convention` has been removed: set the `avoid_breaking_exported_api` config option to `false` to enable the `wrong_self_convention` lint for public items
 --> src/main.rs:2:9
  |
2 | #![warn(clippy::wrong_pub_self_convention)]
  |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  |
  = note: `#[warn(renamed_and_removed_lints)]` on by default
````

But using the lint name as seen in the warning message
echo "avoid_breaking_exported_api = true\n" > clippy.toml

Will cause an error:
````
error: error reading Clippy's configuration file `/tmp/clippytest/clippy.toml`: unknown field `avoid_breaking_exported_api`, expected one of `avoid-breaking-exported-api`, ...
````

Replace the underscores with dashes in the deprecation message.

changelog: avoid_breaking_exported_api: suggest correct clippy config toml option in the deprecation message
---
 clippy_lints/src/deprecated_lints.rs | 4 ++--
 clippy_lints/src/lib.rs              | 4 ++--
 tests/ui/deprecated.stderr           | 4 ++--
 3 files changed, 6 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/deprecated_lints.rs b/clippy_lints/src/deprecated_lints.rs
index 04f3d77464f..2933fbc9341 100644
--- a/clippy_lints/src/deprecated_lints.rs
+++ b/clippy_lints/src/deprecated_lints.rs
@@ -149,7 +149,7 @@ declare_deprecated_lint! {
     /// enables the `enum_variant_names` lint for public items.
     /// ```
     pub PUB_ENUM_VARIANT_NAMES,
-    "set the `avoid_breaking_exported_api` config option to `false` to enable the `enum_variant_names` lint for public items"
+    "set the `avoid-breaking-exported-api` config option to `false` to enable the `enum_variant_names` lint for public items"
 }
 
 declare_deprecated_lint! {
@@ -158,5 +158,5 @@ declare_deprecated_lint! {
     /// **Deprecation reason:** The `avoid_breaking_exported_api` config option was added, which
     /// enables the `wrong_self_conversion` lint for public items.
     pub WRONG_PUB_SELF_CONVENTION,
-    "set the `avoid_breaking_exported_api` config option to `false` to enable the `wrong_self_convention` lint for public items"
+    "set the `avoid-breaking-exported-api` config option to `false` to enable the `wrong_self_convention` lint for public items"
 }
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index cc12d9b0d45..03e093f4c03 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -484,11 +484,11 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     );
     store.register_removed(
         "clippy::pub_enum_variant_names",
-        "set the `avoid_breaking_exported_api` config option to `false` to enable the `enum_variant_names` lint for public items",
+        "set the `avoid-breaking-exported-api` config option to `false` to enable the `enum_variant_names` lint for public items",
     );
     store.register_removed(
         "clippy::wrong_pub_self_convention",
-        "set the `avoid_breaking_exported_api` config option to `false` to enable the `wrong_self_convention` lint for public items",
+        "set the `avoid-breaking-exported-api` config option to `false` to enable the `wrong_self_convention` lint for public items",
     );
     // end deprecated lints, do not remove this comment, it’s used in `update_lints`
 
diff --git a/tests/ui/deprecated.stderr b/tests/ui/deprecated.stderr
index 03c9f438891..0af6b500115 100644
--- a/tests/ui/deprecated.stderr
+++ b/tests/ui/deprecated.stderr
@@ -84,13 +84,13 @@ error: lint `clippy::filter_map` has been removed: this lint has been replaced b
 LL | #[warn(clippy::filter_map)]
    |        ^^^^^^^^^^^^^^^^^^
 
-error: lint `clippy::pub_enum_variant_names` has been removed: set the `avoid_breaking_exported_api` config option to `false` to enable the `enum_variant_names` lint for public items
+error: lint `clippy::pub_enum_variant_names` has been removed: set the `avoid-breaking-exported-api` config option to `false` to enable the `enum_variant_names` lint for public items
   --> $DIR/deprecated.rs:15:8
    |
 LL | #[warn(clippy::pub_enum_variant_names)]
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: lint `clippy::wrong_pub_self_convention` has been removed: set the `avoid_breaking_exported_api` config option to `false` to enable the `wrong_self_convention` lint for public items
+error: lint `clippy::wrong_pub_self_convention` has been removed: set the `avoid-breaking-exported-api` config option to `false` to enable the `wrong_self_convention` lint for public items
   --> $DIR/deprecated.rs:16:8
    |
 LL | #[warn(clippy::wrong_pub_self_convention)]
-- 
cgit 1.4.1-3-g733a5


From 96a9786b1c95b6647ff7e1478947c100db78e3ca Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Sun, 20 Jun 2021 22:32:32 +0200
Subject: Fixed broken deploy script due to multiline configuration docs

---
 clippy_lints/src/utils/conf.rs | 15 +++++++--------
 util/lintlib.py                |  4 ++--
 2 files changed, 9 insertions(+), 10 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index cb335522f61..2f8064499fd 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -24,15 +24,18 @@ impl TryConf {
     }
 }
 
+/// Note that the configuration parsing currently doesn't support documentation that will
+/// that spans over several lines. This will be possible with the new implementation
+/// See (rust-clippy#7172)
 macro_rules! define_Conf {
     ($(
-        $(#[doc = $doc:literal])*
+        #[doc = $doc:literal]
         $(#[conf_deprecated($dep:literal)])?
         ($name:ident: $ty:ty = $default:expr),
     )*) => {
         /// Clippy lint configuration
         pub struct Conf {
-            $($(#[doc = $doc])* pub $name: $ty,)*
+            $(#[doc = $doc] pub $name: $ty,)*
         }
 
         mod defaults {
@@ -109,7 +112,7 @@ macro_rules! define_Conf {
                                 stringify!($name),
                                 stringify!($ty),
                                 format!("{:?}", super::defaults::$name()),
-                                concat!($($doc,)*),
+                                $doc,
                                 deprecation_reason,
                             )
                         },
@@ -198,11 +201,7 @@ define_Conf! {
     (upper_case_acronyms_aggressive: bool = false),
     /// Lint: _CARGO_COMMON_METADATA. For internal testing only, ignores the current `publish` settings in the Cargo manifest.
     (cargo_ignore_publish: bool = false),
-    /// Lint: NONSTANDARD_MACRO_BRACES. Enforce the named macros always use the braces specified.
-    ///
-    /// A `MacroMatcher` can be added like so `{ name = "macro_name", brace = "(" }`.
-    /// If the macro is could be used with a full path two `MacroMatcher`s have to be added one
-    /// with the full path `crate_name::macro_name` and one with just the macro name.
+    /// Lint: NONSTANDARD_MACRO_BRACES. Enforce the named macros always use the braces specified. <br> A `MacroMatcher` can be added like so `{ name = "macro_name", brace = "(" }`. If the macro is could be used with a full path two `MacroMatcher`s have to be added one with the full path `crate_name::macro_name` and one with just the macro name.
     (standard_macro_braces: Vec<crate::nonstandard_macro_braces::MacroMatcher> = Vec::new()),
 }
 
diff --git a/util/lintlib.py b/util/lintlib.py
index 5707cf0ce0f..3b6e8c372ed 100644
--- a/util/lintlib.py
+++ b/util/lintlib.py
@@ -12,7 +12,7 @@ Config = collections.namedtuple('Config', 'name ty doc default')
 
 lintname_re = re.compile(r'''pub\s+([A-Z_][A-Z_0-9]*)''')
 group_re = re.compile(r'''\s*([a-z_][a-z_0-9]+)''')
-conf_re = re.compile(r'''define_Conf! {\n([^}]*)\n}''', re.MULTILINE)
+conf_re = re.compile(r'''define_Conf! {\n((?!\n})[\s\S])*\n}''', re.MULTILINE)
 confvar_re = re.compile(
     r'''/// Lint: ([\w,\s]+)\. (.*)\n\s*\(([^:]+):\s*([^\s=]+)\s*=\s*([^\.\)]+).*\),''', re.MULTILINE)
 comment_re = re.compile(r'''\s*/// ?(.*)''')
@@ -91,7 +91,7 @@ def parse_configs(path):
         contents = fp.read()
 
     match = re.search(conf_re, contents)
-    confvars = re.findall(confvar_re, match.group(1))
+    confvars = re.findall(confvar_re, match.group(0))
 
     for (lints, doc, name, ty, default) in confvars:
         for lint in lints.split(','):
-- 
cgit 1.4.1-3-g733a5


From 20cb1bc7c1a381a702f4b81511ad4e92df69c34c Mon Sep 17 00:00:00 2001
From: Elliot Bobrow <elliotgreybobrow@gmail.com>
Date: Mon, 14 Jun 2021 12:23:33 -0700
Subject: check for unbalanced tick pairs in doc-markdown

---
 clippy_lints/src/doc.rs              |  64 +++++++---
 clippy_lints/src/if_let_mutex.rs     |   2 +-
 tests/ui/doc.rs                      | 221 -----------------------------------
 tests/ui/doc.stderr                  | 190 ------------------------------
 tests/ui/doc/doc.rs                  | 221 +++++++++++++++++++++++++++++++++++
 tests/ui/doc/doc.stderr              | 190 ++++++++++++++++++++++++++++++
 tests/ui/doc/unbalanced_ticks.rs     |  36 ++++++
 tests/ui/doc/unbalanced_ticks.stderr |  64 ++++++++++
 8 files changed, 562 insertions(+), 426 deletions(-)
 delete mode 100644 tests/ui/doc.rs
 delete mode 100644 tests/ui/doc.stderr
 create mode 100644 tests/ui/doc/doc.rs
 create mode 100644 tests/ui/doc/doc.stderr
 create mode 100644 tests/ui/doc/unbalanced_ticks.rs
 create mode 100644 tests/ui/doc/unbalanced_ticks.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/doc.rs b/clippy_lints/src/doc.rs
index e67ec4e06c5..4e164d33a05 100644
--- a/clippy_lints/src/doc.rs
+++ b/clippy_lints/src/doc.rs
@@ -1,4 +1,5 @@
-use clippy_utils::diagnostics::{span_lint, span_lint_and_note};
+use clippy_utils::diagnostics::{span_lint, span_lint_and_help, span_lint_and_note};
+use clippy_utils::source::first_line_of_span;
 use clippy_utils::ty::{implements_trait, is_type_diagnostic_item};
 use clippy_utils::{is_entrypoint_fn, is_expn_of, match_panic_def_id, method_chain_args, return_ty};
 use if_chain::if_chain;
@@ -37,7 +38,8 @@ declare_clippy_lint! {
     /// consider that.
     ///
     /// **Known problems:** Lots of bad docs won’t be fixed, what the lint checks
-    /// for is limited, and there are still false positives.
+    /// for is limited, and there are still false positives. HTML elements and their
+    /// content are not linted.
     ///
     /// In addition, when writing documentation comments, including `[]` brackets
     /// inside a link text would trip the parser. Therfore, documenting link with
@@ -469,11 +471,11 @@ fn check_doc<'a, Events: Iterator<Item = (pulldown_cmark::Event<'a>, Range<usize
     spans: &[(usize, Span)],
 ) -> DocHeaders {
     // true if a safety header was found
-    use pulldown_cmark::CodeBlockKind;
     use pulldown_cmark::Event::{
         Code, End, FootnoteReference, HardBreak, Html, Rule, SoftBreak, Start, TaskListMarker, Text,
     };
-    use pulldown_cmark::Tag::{CodeBlock, Heading, Link};
+    use pulldown_cmark::Tag::{CodeBlock, Heading, Item, Link, Paragraph};
+    use pulldown_cmark::{CodeBlockKind, CowStr};
 
     let mut headers = DocHeaders {
         safety: false,
@@ -485,6 +487,9 @@ fn check_doc<'a, Events: Iterator<Item = (pulldown_cmark::Event<'a>, Range<usize
     let mut in_heading = false;
     let mut is_rust = false;
     let mut edition = None;
+    let mut ticks_unbalanced = false;
+    let mut text_to_check: Vec<(CowStr<'_>, Span)> = Vec::new();
+    let mut paragraph_span = spans.get(0).expect("function isn't called if doc comment is empty").1;
     for (event, range) in events {
         match event {
             Start(CodeBlock(ref kind)) => {
@@ -510,13 +515,42 @@ fn check_doc<'a, Events: Iterator<Item = (pulldown_cmark::Event<'a>, Range<usize
             },
             Start(Link(_, url, _)) => in_link = Some(url),
             End(Link(..)) => in_link = None,
-            Start(Heading(_)) => in_heading = true,
-            End(Heading(_)) => in_heading = false,
+            Start(Heading(_) | Paragraph | Item) => {
+                if let Start(Heading(_)) = event {
+                    in_heading = true;
+                }
+                ticks_unbalanced = false;
+                let (_, span) = get_current_span(spans, range.start);
+                paragraph_span = first_line_of_span(cx, span);
+            },
+            End(Heading(_) | Paragraph | Item) => {
+                if let End(Heading(_)) = event {
+                    in_heading = false;
+                }
+                if ticks_unbalanced {
+                    span_lint_and_help(
+                        cx,
+                        DOC_MARKDOWN,
+                        paragraph_span,
+                        "backticks are unbalanced",
+                        None,
+                        "a backtick may be missing a pair",
+                    );
+                } else {
+                    for (text, span) in text_to_check {
+                        check_text(cx, valid_idents, &text, span);
+                    }
+                }
+                text_to_check = Vec::new();
+            },
             Start(_tag) | End(_tag) => (), // We don't care about other tags
             Html(_html) => (),             // HTML is weird, just ignore it
             SoftBreak | HardBreak | TaskListMarker(_) | Code(_) | Rule => (),
             FootnoteReference(text) | Text(text) => {
-                if Some(&text) == in_link.as_ref() {
+                let (begin, span) = get_current_span(spans, range.start);
+                paragraph_span = paragraph_span.with_hi(span.hi());
+                ticks_unbalanced |= text.contains('`');
+                if Some(&text) == in_link.as_ref() || ticks_unbalanced {
                     // Probably a link of the form `<http://example.com>`
                     // Which are represented as a link to "http://example.com" with
                     // text "http://example.com" by pulldown-cmark
@@ -525,11 +559,6 @@ fn check_doc<'a, Events: Iterator<Item = (pulldown_cmark::Event<'a>, Range<usize
                 headers.safety |= in_heading && text.trim() == "Safety";
                 headers.errors |= in_heading && text.trim() == "Errors";
                 headers.panics |= in_heading && text.trim() == "Panics";
-                let index = match spans.binary_search_by(|c| c.0.cmp(&range.start)) {
-                    Ok(o) => o,
-                    Err(e) => e - 1,
-                };
-                let (begin, span) = spans[index];
                 if in_code {
                     if is_rust {
                         let edition = edition.unwrap_or_else(|| cx.tcx.sess.edition());
@@ -538,8 +567,7 @@ fn check_doc<'a, Events: Iterator<Item = (pulldown_cmark::Event<'a>, Range<usize
                 } else {
                     // Adjust for the beginning of the current `Event`
                     let span = span.with_lo(span.lo() + BytePos::from_usize(range.start - begin));
-
-                    check_text(cx, valid_idents, &text, span);
+                    text_to_check.push((text, span));
                 }
             },
         }
@@ -547,6 +575,14 @@ fn check_doc<'a, Events: Iterator<Item = (pulldown_cmark::Event<'a>, Range<usize
     headers
 }
 
+fn get_current_span(spans: &[(usize, Span)], idx: usize) -> (usize, Span) {
+    let index = match spans.binary_search_by(|c| c.0.cmp(&idx)) {
+        Ok(o) => o,
+        Err(e) => e - 1,
+    };
+    spans[index]
+}
+
 fn check_code(cx: &LateContext<'_>, text: &str, edition: Edition, span: Span) {
     fn has_needless_main(code: &str, edition: Edition) -> bool {
         rustc_driver::catch_fatal_errors(|| {
diff --git a/clippy_lints/src/if_let_mutex.rs b/clippy_lints/src/if_let_mutex.rs
index f661f7ede82..5403d76ea30 100644
--- a/clippy_lints/src/if_let_mutex.rs
+++ b/clippy_lints/src/if_let_mutex.rs
@@ -83,7 +83,7 @@ impl<'tcx> LateLintPass<'tcx> for IfLetMutex {
     }
 }
 
-/// Checks if `Mutex::lock` is called in the `if let _ = expr.
+/// Checks if `Mutex::lock` is called in the `if let` expr.
 pub struct OppVisitor<'a, 'tcx> {
     mutex_lock_called: bool,
     found_mutex: Option<&'tcx Expr<'tcx>>,
diff --git a/tests/ui/doc.rs b/tests/ui/doc.rs
deleted file mode 100644
index 8afef6b23d4..00000000000
--- a/tests/ui/doc.rs
+++ /dev/null
@@ -1,221 +0,0 @@
-//! This file tests for the `DOC_MARKDOWN` lint.
-
-#![allow(dead_code, incomplete_features)]
-#![warn(clippy::doc_markdown)]
-#![feature(custom_inner_attributes, const_generics, const_evaluatable_checked, const_option)]
-#![rustfmt::skip]
-
-/// The foo_bar function does _nothing_. See also foo::bar. (note the dot there)
-/// Markdown is _weird_. I mean _really weird_. This \_ is ok. So is `_`. But not Foo::some_fun
-/// which should be reported only once despite being __doubly bad__.
-/// Here be ::a::global:path.
-/// That's not code ~NotInCodeBlock~.
-/// be_sure_we_got_to_the_end_of_it
-fn foo_bar() {
-}
-
-/// That one tests multiline ticks.
-/// ```rust
-/// foo_bar FOO_BAR
-/// _foo bar_
-/// ```
-///
-/// ~~~rust
-/// foo_bar FOO_BAR
-/// _foo bar_
-/// ~~~
-/// be_sure_we_got_to_the_end_of_it
-fn multiline_codeblock() {
-}
-
-/// This _is a test for
-/// multiline
-/// emphasis_.
-/// be_sure_we_got_to_the_end_of_it
-fn test_emphasis() {
-}
-
-/// This tests units. See also #835.
-/// kiB MiB GiB TiB PiB EiB
-/// kib Mib Gib Tib Pib Eib
-/// kB MB GB TB PB EB
-/// kb Mb Gb Tb Pb Eb
-/// 32kiB 32MiB 32GiB 32TiB 32PiB 32EiB
-/// 32kib 32Mib 32Gib 32Tib 32Pib 32Eib
-/// 32kB 32MB 32GB 32TB 32PB 32EB
-/// 32kb 32Mb 32Gb 32Tb 32Pb 32Eb
-/// NaN
-/// be_sure_we_got_to_the_end_of_it
-fn test_units() {
-}
-
-/// This tests allowed identifiers.
-/// KiB MiB GiB TiB PiB EiB
-/// DirectX
-/// ECMAScript
-/// GPLv2 GPLv3
-/// GitHub GitLab
-/// IPv4 IPv6
-/// ClojureScript CoffeeScript JavaScript PureScript TypeScript
-/// NaN NaNs
-/// OAuth GraphQL
-/// OCaml
-/// OpenGL OpenMP OpenSSH OpenSSL OpenStreetMap OpenDNS
-/// WebGL
-/// TensorFlow
-/// TrueType
-/// iOS macOS FreeBSD
-/// TeX LaTeX BibTeX BibLaTeX
-/// MinGW
-/// CamelCase (see also #2395)
-/// be_sure_we_got_to_the_end_of_it
-fn test_allowed() {
-}
-
-/// This test has [a link_with_underscores][chunked-example] inside it. See #823.
-/// See also [the issue tracker](https://github.com/rust-lang/rust-clippy/search?q=clippy::doc_markdown&type=Issues)
-/// on GitHub (which is a camel-cased word, but is OK). And here is another [inline link][inline_link].
-/// It can also be [inline_link2].
-///
-/// [chunked-example]: https://en.wikipedia.org/wiki/Chunked_transfer_encoding#Example
-/// [inline_link]: https://foobar
-/// [inline_link2]: https://foobar
-/// The `main` function is the entry point of the program. Here it only calls the `foo_bar` and
-/// `multiline_ticks` functions.
-///
-/// expression of the type  `_ <bit_op> m <cmp_op> c` (where `<bit_op>`
-/// is one of {`&`, '|'} and `<cmp_op>` is one of {`!=`, `>=`, `>` ,
-/// be_sure_we_got_to_the_end_of_it
-fn main() {
-    foo_bar();
-    multiline_codeblock();
-    test_emphasis();
-    test_units();
-}
-
-/// ## CamelCaseThing
-/// Talks about `CamelCaseThing`. Titles should be ignored; see issue #897.
-///
-/// # CamelCaseThing
-///
-/// Not a title #897 CamelCaseThing
-/// be_sure_we_got_to_the_end_of_it
-fn issue897() {
-}
-
-/// I am confused by brackets? (`x_y`)
-/// I am confused by brackets? (foo `x_y`)
-/// I am confused by brackets? (`x_y` foo)
-/// be_sure_we_got_to_the_end_of_it
-fn issue900() {
-}
-
-/// Diesel queries also have a similar problem to [Iterator][iterator], where
-/// /// More talking
-/// returning them from a function requires exposing the implementation of that
-/// function. The [`helper_types`][helper_types] module exists to help with this,
-/// but you might want to hide the return type or have it conditionally change.
-/// Boxing can achieve both.
-///
-/// [iterator]: https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html
-/// [helper_types]: ../helper_types/index.html
-/// be_sure_we_got_to_the_end_of_it
-fn issue883() {
-}
-
-/// `foo_bar
-/// baz_quz`
-/// [foo
-/// bar](https://doc.rust-lang.org/stable/std/iter/trait.IteratorFooBar.html)
-fn multiline() {
-}
-
-/** E.g., serialization of an empty list: FooBar
-```
-That's in a code block: `PackedNode`
-```
-
-And BarQuz too.
-be_sure_we_got_to_the_end_of_it
-*/
-fn issue1073() {
-}
-
-/** E.g., serialization of an empty list: FooBar
-```
-That's in a code block: PackedNode
-```
-
-And BarQuz too.
-be_sure_we_got_to_the_end_of_it
-*/
-fn issue1073_alt() {
-}
-
-/// Tests more than three quotes:
-/// ````
-/// DoNotWarn
-/// ```
-/// StillDont
-/// ````
-/// be_sure_we_got_to_the_end_of_it
-fn four_quotes() {
-}
-
-/// See [NIST SP 800-56A, revision 2].
-///
-/// [NIST SP 800-56A, revision 2]:
-///     https://github.com/rust-lang/rust-clippy/issues/902#issuecomment-261919419
-fn issue_902_comment() {}
-
-#[cfg_attr(feature = "a", doc = " ```")]
-#[cfg_attr(not(feature = "a"), doc = " ```ignore")]
-/// fn main() {
-///     let s = "localhost:10000".to_string();
-///     println!("{}", s);
-/// }
-/// ```
-fn issue_1469() {}
-
-/**
- * This is a doc comment that should not be a list
- *This would also be an error under a strict common mark interpretation
- */
-fn issue_1920() {}
-
-/// Ok: <http://www.unicode.org/reports/tr9/#Reordering_Resolved_Levels>
-///
-/// Not ok: http://www.unicode.org
-/// Not ok: https://www.unicode.org
-/// Not ok: http://www.unicode.org/
-/// Not ok: http://www.unicode.org/reports/tr9/#Reordering_Resolved_Levels
-fn issue_1832() {}
-
-/// An iterator over mycrate::Collection's values.
-/// It should not lint a `'static` lifetime in ticks.
-fn issue_2210() {}
-
-/// This should not cause the lint to trigger:
-/// #REQ-data-family.lint_partof_exists
-fn issue_2343() {}
-
-/// This should not cause an ICE:
-/// __|_ _|__||_|
-fn pulldown_cmark_crash() {}
-
-// issue #7033 - const_evaluatable_checked ICE
-struct S<T, const N: usize>
-where [(); N.checked_next_power_of_two().unwrap()]: {
-    arr: [T; N.checked_next_power_of_two().unwrap()],
-    n: usize,
-}
-
-impl<T: Copy + Default, const N: usize> S<T, N>
-where [(); N.checked_next_power_of_two().unwrap()]: {
-    fn new() -> Self {
-        Self {
-            arr: [T::default(); N.checked_next_power_of_two().unwrap()],
-            n: 0,
-        }
-    }
-}
diff --git a/tests/ui/doc.stderr b/tests/ui/doc.stderr
deleted file mode 100644
index 7eab8a85f09..00000000000
--- a/tests/ui/doc.stderr
+++ /dev/null
@@ -1,190 +0,0 @@
-error: you should put `foo_bar` between ticks in the documentation
-  --> $DIR/doc.rs:8:9
-   |
-LL | /// The foo_bar function does _nothing_. See also foo::bar. (note the dot there)
-   |         ^^^^^^^
-   |
-   = note: `-D clippy::doc-markdown` implied by `-D warnings`
-
-error: you should put `foo::bar` between ticks in the documentation
-  --> $DIR/doc.rs:8:51
-   |
-LL | /// The foo_bar function does _nothing_. See also foo::bar. (note the dot there)
-   |                                                   ^^^^^^^^
-
-error: you should put `Foo::some_fun` between ticks in the documentation
-  --> $DIR/doc.rs:9:83
-   |
-LL | /// Markdown is _weird_. I mean _really weird_. This /_ is ok. So is `_`. But not Foo::some_fun
-   |                                                                                   ^^^^^^^^^^^^^
-
-error: you should put `a::global:path` between ticks in the documentation
-  --> $DIR/doc.rs:11:15
-   |
-LL | /// Here be ::a::global:path.
-   |               ^^^^^^^^^^^^^^
-
-error: you should put `NotInCodeBlock` between ticks in the documentation
-  --> $DIR/doc.rs:12:22
-   |
-LL | /// That's not code ~NotInCodeBlock~.
-   |                      ^^^^^^^^^^^^^^
-
-error: you should put `be_sure_we_got_to_the_end_of_it` between ticks in the documentation
-  --> $DIR/doc.rs:13:5
-   |
-LL | /// be_sure_we_got_to_the_end_of_it
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: you should put `be_sure_we_got_to_the_end_of_it` between ticks in the documentation
-  --> $DIR/doc.rs:27:5
-   |
-LL | /// be_sure_we_got_to_the_end_of_it
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: you should put `be_sure_we_got_to_the_end_of_it` between ticks in the documentation
-  --> $DIR/doc.rs:34:5
-   |
-LL | /// be_sure_we_got_to_the_end_of_it
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: you should put `be_sure_we_got_to_the_end_of_it` between ticks in the documentation
-  --> $DIR/doc.rs:48:5
-   |
-LL | /// be_sure_we_got_to_the_end_of_it
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: you should put `be_sure_we_got_to_the_end_of_it` between ticks in the documentation
-  --> $DIR/doc.rs:71:5
-   |
-LL | /// be_sure_we_got_to_the_end_of_it
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: you should put `link_with_underscores` between ticks in the documentation
-  --> $DIR/doc.rs:75:22
-   |
-LL | /// This test has [a link_with_underscores][chunked-example] inside it. See #823.
-   |                      ^^^^^^^^^^^^^^^^^^^^^
-
-error: you should put `inline_link2` between ticks in the documentation
-  --> $DIR/doc.rs:78:21
-   |
-LL | /// It can also be [inline_link2].
-   |                     ^^^^^^^^^^^^
-
-error: you should put `be_sure_we_got_to_the_end_of_it` between ticks in the documentation
-  --> $DIR/doc.rs:88:5
-   |
-LL | /// be_sure_we_got_to_the_end_of_it
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: you should put `CamelCaseThing` between ticks in the documentation
-  --> $DIR/doc.rs:96:8
-   |
-LL | /// ## CamelCaseThing
-   |        ^^^^^^^^^^^^^^
-
-error: you should put `CamelCaseThing` between ticks in the documentation
-  --> $DIR/doc.rs:99:7
-   |
-LL | /// # CamelCaseThing
-   |       ^^^^^^^^^^^^^^
-
-error: you should put `CamelCaseThing` between ticks in the documentation
-  --> $DIR/doc.rs:101:22
-   |
-LL | /// Not a title #897 CamelCaseThing
-   |                      ^^^^^^^^^^^^^^
-
-error: you should put `be_sure_we_got_to_the_end_of_it` between ticks in the documentation
-  --> $DIR/doc.rs:102:5
-   |
-LL | /// be_sure_we_got_to_the_end_of_it
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: you should put `be_sure_we_got_to_the_end_of_it` between ticks in the documentation
-  --> $DIR/doc.rs:109:5
-   |
-LL | /// be_sure_we_got_to_the_end_of_it
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: you should put `be_sure_we_got_to_the_end_of_it` between ticks in the documentation
-  --> $DIR/doc.rs:122:5
-   |
-LL | /// be_sure_we_got_to_the_end_of_it
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: you should put `FooBar` between ticks in the documentation
-  --> $DIR/doc.rs:133:43
-   |
-LL | /** E.g., serialization of an empty list: FooBar
-   |                                           ^^^^^^
-
-error: you should put `BarQuz` between ticks in the documentation
-  --> $DIR/doc.rs:138:5
-   |
-LL | And BarQuz too.
-   |     ^^^^^^
-
-error: you should put `be_sure_we_got_to_the_end_of_it` between ticks in the documentation
-  --> $DIR/doc.rs:139:1
-   |
-LL | be_sure_we_got_to_the_end_of_it
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: you should put `FooBar` between ticks in the documentation
-  --> $DIR/doc.rs:144:43
-   |
-LL | /** E.g., serialization of an empty list: FooBar
-   |                                           ^^^^^^
-
-error: you should put `BarQuz` between ticks in the documentation
-  --> $DIR/doc.rs:149:5
-   |
-LL | And BarQuz too.
-   |     ^^^^^^
-
-error: you should put `be_sure_we_got_to_the_end_of_it` between ticks in the documentation
-  --> $DIR/doc.rs:150:1
-   |
-LL | be_sure_we_got_to_the_end_of_it
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: you should put `be_sure_we_got_to_the_end_of_it` between ticks in the documentation
-  --> $DIR/doc.rs:161:5
-   |
-LL | /// be_sure_we_got_to_the_end_of_it
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: you should put bare URLs between `<`/`>` or make a proper Markdown link
-  --> $DIR/doc.rs:188:13
-   |
-LL | /// Not ok: http://www.unicode.org
-   |             ^^^^^^^^^^^^^^^^^^^^^^
-
-error: you should put bare URLs between `<`/`>` or make a proper Markdown link
-  --> $DIR/doc.rs:189:13
-   |
-LL | /// Not ok: https://www.unicode.org
-   |             ^^^^^^^^^^^^^^^^^^^^^^^
-
-error: you should put bare URLs between `<`/`>` or make a proper Markdown link
-  --> $DIR/doc.rs:190:13
-   |
-LL | /// Not ok: http://www.unicode.org/
-   |             ^^^^^^^^^^^^^^^^^^^^^^
-
-error: you should put bare URLs between `<`/`>` or make a proper Markdown link
-  --> $DIR/doc.rs:191:13
-   |
-LL | /// Not ok: http://www.unicode.org/reports/tr9/#Reordering_Resolved_Levels
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: you should put `mycrate::Collection` between ticks in the documentation
-  --> $DIR/doc.rs:194:22
-   |
-LL | /// An iterator over mycrate::Collection's values.
-   |                      ^^^^^^^^^^^^^^^^^^^
-
-error: aborting due to 31 previous errors
-
diff --git a/tests/ui/doc/doc.rs b/tests/ui/doc/doc.rs
new file mode 100644
index 00000000000..8afef6b23d4
--- /dev/null
+++ b/tests/ui/doc/doc.rs
@@ -0,0 +1,221 @@
+//! This file tests for the `DOC_MARKDOWN` lint.
+
+#![allow(dead_code, incomplete_features)]
+#![warn(clippy::doc_markdown)]
+#![feature(custom_inner_attributes, const_generics, const_evaluatable_checked, const_option)]
+#![rustfmt::skip]
+
+/// The foo_bar function does _nothing_. See also foo::bar. (note the dot there)
+/// Markdown is _weird_. I mean _really weird_. This \_ is ok. So is `_`. But not Foo::some_fun
+/// which should be reported only once despite being __doubly bad__.
+/// Here be ::a::global:path.
+/// That's not code ~NotInCodeBlock~.
+/// be_sure_we_got_to_the_end_of_it
+fn foo_bar() {
+}
+
+/// That one tests multiline ticks.
+/// ```rust
+/// foo_bar FOO_BAR
+/// _foo bar_
+/// ```
+///
+/// ~~~rust
+/// foo_bar FOO_BAR
+/// _foo bar_
+/// ~~~
+/// be_sure_we_got_to_the_end_of_it
+fn multiline_codeblock() {
+}
+
+/// This _is a test for
+/// multiline
+/// emphasis_.
+/// be_sure_we_got_to_the_end_of_it
+fn test_emphasis() {
+}
+
+/// This tests units. See also #835.
+/// kiB MiB GiB TiB PiB EiB
+/// kib Mib Gib Tib Pib Eib
+/// kB MB GB TB PB EB
+/// kb Mb Gb Tb Pb Eb
+/// 32kiB 32MiB 32GiB 32TiB 32PiB 32EiB
+/// 32kib 32Mib 32Gib 32Tib 32Pib 32Eib
+/// 32kB 32MB 32GB 32TB 32PB 32EB
+/// 32kb 32Mb 32Gb 32Tb 32Pb 32Eb
+/// NaN
+/// be_sure_we_got_to_the_end_of_it
+fn test_units() {
+}
+
+/// This tests allowed identifiers.
+/// KiB MiB GiB TiB PiB EiB
+/// DirectX
+/// ECMAScript
+/// GPLv2 GPLv3
+/// GitHub GitLab
+/// IPv4 IPv6
+/// ClojureScript CoffeeScript JavaScript PureScript TypeScript
+/// NaN NaNs
+/// OAuth GraphQL
+/// OCaml
+/// OpenGL OpenMP OpenSSH OpenSSL OpenStreetMap OpenDNS
+/// WebGL
+/// TensorFlow
+/// TrueType
+/// iOS macOS FreeBSD
+/// TeX LaTeX BibTeX BibLaTeX
+/// MinGW
+/// CamelCase (see also #2395)
+/// be_sure_we_got_to_the_end_of_it
+fn test_allowed() {
+}
+
+/// This test has [a link_with_underscores][chunked-example] inside it. See #823.
+/// See also [the issue tracker](https://github.com/rust-lang/rust-clippy/search?q=clippy::doc_markdown&type=Issues)
+/// on GitHub (which is a camel-cased word, but is OK). And here is another [inline link][inline_link].
+/// It can also be [inline_link2].
+///
+/// [chunked-example]: https://en.wikipedia.org/wiki/Chunked_transfer_encoding#Example
+/// [inline_link]: https://foobar
+/// [inline_link2]: https://foobar
+/// The `main` function is the entry point of the program. Here it only calls the `foo_bar` and
+/// `multiline_ticks` functions.
+///
+/// expression of the type  `_ <bit_op> m <cmp_op> c` (where `<bit_op>`
+/// is one of {`&`, '|'} and `<cmp_op>` is one of {`!=`, `>=`, `>` ,
+/// be_sure_we_got_to_the_end_of_it
+fn main() {
+    foo_bar();
+    multiline_codeblock();
+    test_emphasis();
+    test_units();
+}
+
+/// ## CamelCaseThing
+/// Talks about `CamelCaseThing`. Titles should be ignored; see issue #897.
+///
+/// # CamelCaseThing
+///
+/// Not a title #897 CamelCaseThing
+/// be_sure_we_got_to_the_end_of_it
+fn issue897() {
+}
+
+/// I am confused by brackets? (`x_y`)
+/// I am confused by brackets? (foo `x_y`)
+/// I am confused by brackets? (`x_y` foo)
+/// be_sure_we_got_to_the_end_of_it
+fn issue900() {
+}
+
+/// Diesel queries also have a similar problem to [Iterator][iterator], where
+/// /// More talking
+/// returning them from a function requires exposing the implementation of that
+/// function. The [`helper_types`][helper_types] module exists to help with this,
+/// but you might want to hide the return type or have it conditionally change.
+/// Boxing can achieve both.
+///
+/// [iterator]: https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html
+/// [helper_types]: ../helper_types/index.html
+/// be_sure_we_got_to_the_end_of_it
+fn issue883() {
+}
+
+/// `foo_bar
+/// baz_quz`
+/// [foo
+/// bar](https://doc.rust-lang.org/stable/std/iter/trait.IteratorFooBar.html)
+fn multiline() {
+}
+
+/** E.g., serialization of an empty list: FooBar
+```
+That's in a code block: `PackedNode`
+```
+
+And BarQuz too.
+be_sure_we_got_to_the_end_of_it
+*/
+fn issue1073() {
+}
+
+/** E.g., serialization of an empty list: FooBar
+```
+That's in a code block: PackedNode
+```
+
+And BarQuz too.
+be_sure_we_got_to_the_end_of_it
+*/
+fn issue1073_alt() {
+}
+
+/// Tests more than three quotes:
+/// ````
+/// DoNotWarn
+/// ```
+/// StillDont
+/// ````
+/// be_sure_we_got_to_the_end_of_it
+fn four_quotes() {
+}
+
+/// See [NIST SP 800-56A, revision 2].
+///
+/// [NIST SP 800-56A, revision 2]:
+///     https://github.com/rust-lang/rust-clippy/issues/902#issuecomment-261919419
+fn issue_902_comment() {}
+
+#[cfg_attr(feature = "a", doc = " ```")]
+#[cfg_attr(not(feature = "a"), doc = " ```ignore")]
+/// fn main() {
+///     let s = "localhost:10000".to_string();
+///     println!("{}", s);
+/// }
+/// ```
+fn issue_1469() {}
+
+/**
+ * This is a doc comment that should not be a list
+ *This would also be an error under a strict common mark interpretation
+ */
+fn issue_1920() {}
+
+/// Ok: <http://www.unicode.org/reports/tr9/#Reordering_Resolved_Levels>
+///
+/// Not ok: http://www.unicode.org
+/// Not ok: https://www.unicode.org
+/// Not ok: http://www.unicode.org/
+/// Not ok: http://www.unicode.org/reports/tr9/#Reordering_Resolved_Levels
+fn issue_1832() {}
+
+/// An iterator over mycrate::Collection's values.
+/// It should not lint a `'static` lifetime in ticks.
+fn issue_2210() {}
+
+/// This should not cause the lint to trigger:
+/// #REQ-data-family.lint_partof_exists
+fn issue_2343() {}
+
+/// This should not cause an ICE:
+/// __|_ _|__||_|
+fn pulldown_cmark_crash() {}
+
+// issue #7033 - const_evaluatable_checked ICE
+struct S<T, const N: usize>
+where [(); N.checked_next_power_of_two().unwrap()]: {
+    arr: [T; N.checked_next_power_of_two().unwrap()],
+    n: usize,
+}
+
+impl<T: Copy + Default, const N: usize> S<T, N>
+where [(); N.checked_next_power_of_two().unwrap()]: {
+    fn new() -> Self {
+        Self {
+            arr: [T::default(); N.checked_next_power_of_two().unwrap()],
+            n: 0,
+        }
+    }
+}
diff --git a/tests/ui/doc/doc.stderr b/tests/ui/doc/doc.stderr
new file mode 100644
index 00000000000..7eab8a85f09
--- /dev/null
+++ b/tests/ui/doc/doc.stderr
@@ -0,0 +1,190 @@
+error: you should put `foo_bar` between ticks in the documentation
+  --> $DIR/doc.rs:8:9
+   |
+LL | /// The foo_bar function does _nothing_. See also foo::bar. (note the dot there)
+   |         ^^^^^^^
+   |
+   = note: `-D clippy::doc-markdown` implied by `-D warnings`
+
+error: you should put `foo::bar` between ticks in the documentation
+  --> $DIR/doc.rs:8:51
+   |
+LL | /// The foo_bar function does _nothing_. See also foo::bar. (note the dot there)
+   |                                                   ^^^^^^^^
+
+error: you should put `Foo::some_fun` between ticks in the documentation
+  --> $DIR/doc.rs:9:83
+   |
+LL | /// Markdown is _weird_. I mean _really weird_. This /_ is ok. So is `_`. But not Foo::some_fun
+   |                                                                                   ^^^^^^^^^^^^^
+
+error: you should put `a::global:path` between ticks in the documentation
+  --> $DIR/doc.rs:11:15
+   |
+LL | /// Here be ::a::global:path.
+   |               ^^^^^^^^^^^^^^
+
+error: you should put `NotInCodeBlock` between ticks in the documentation
+  --> $DIR/doc.rs:12:22
+   |
+LL | /// That's not code ~NotInCodeBlock~.
+   |                      ^^^^^^^^^^^^^^
+
+error: you should put `be_sure_we_got_to_the_end_of_it` between ticks in the documentation
+  --> $DIR/doc.rs:13:5
+   |
+LL | /// be_sure_we_got_to_the_end_of_it
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: you should put `be_sure_we_got_to_the_end_of_it` between ticks in the documentation
+  --> $DIR/doc.rs:27:5
+   |
+LL | /// be_sure_we_got_to_the_end_of_it
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: you should put `be_sure_we_got_to_the_end_of_it` between ticks in the documentation
+  --> $DIR/doc.rs:34:5
+   |
+LL | /// be_sure_we_got_to_the_end_of_it
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: you should put `be_sure_we_got_to_the_end_of_it` between ticks in the documentation
+  --> $DIR/doc.rs:48:5
+   |
+LL | /// be_sure_we_got_to_the_end_of_it
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: you should put `be_sure_we_got_to_the_end_of_it` between ticks in the documentation
+  --> $DIR/doc.rs:71:5
+   |
+LL | /// be_sure_we_got_to_the_end_of_it
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: you should put `link_with_underscores` between ticks in the documentation
+  --> $DIR/doc.rs:75:22
+   |
+LL | /// This test has [a link_with_underscores][chunked-example] inside it. See #823.
+   |                      ^^^^^^^^^^^^^^^^^^^^^
+
+error: you should put `inline_link2` between ticks in the documentation
+  --> $DIR/doc.rs:78:21
+   |
+LL | /// It can also be [inline_link2].
+   |                     ^^^^^^^^^^^^
+
+error: you should put `be_sure_we_got_to_the_end_of_it` between ticks in the documentation
+  --> $DIR/doc.rs:88:5
+   |
+LL | /// be_sure_we_got_to_the_end_of_it
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: you should put `CamelCaseThing` between ticks in the documentation
+  --> $DIR/doc.rs:96:8
+   |
+LL | /// ## CamelCaseThing
+   |        ^^^^^^^^^^^^^^
+
+error: you should put `CamelCaseThing` between ticks in the documentation
+  --> $DIR/doc.rs:99:7
+   |
+LL | /// # CamelCaseThing
+   |       ^^^^^^^^^^^^^^
+
+error: you should put `CamelCaseThing` between ticks in the documentation
+  --> $DIR/doc.rs:101:22
+   |
+LL | /// Not a title #897 CamelCaseThing
+   |                      ^^^^^^^^^^^^^^
+
+error: you should put `be_sure_we_got_to_the_end_of_it` between ticks in the documentation
+  --> $DIR/doc.rs:102:5
+   |
+LL | /// be_sure_we_got_to_the_end_of_it
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: you should put `be_sure_we_got_to_the_end_of_it` between ticks in the documentation
+  --> $DIR/doc.rs:109:5
+   |
+LL | /// be_sure_we_got_to_the_end_of_it
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: you should put `be_sure_we_got_to_the_end_of_it` between ticks in the documentation
+  --> $DIR/doc.rs:122:5
+   |
+LL | /// be_sure_we_got_to_the_end_of_it
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: you should put `FooBar` between ticks in the documentation
+  --> $DIR/doc.rs:133:43
+   |
+LL | /** E.g., serialization of an empty list: FooBar
+   |                                           ^^^^^^
+
+error: you should put `BarQuz` between ticks in the documentation
+  --> $DIR/doc.rs:138:5
+   |
+LL | And BarQuz too.
+   |     ^^^^^^
+
+error: you should put `be_sure_we_got_to_the_end_of_it` between ticks in the documentation
+  --> $DIR/doc.rs:139:1
+   |
+LL | be_sure_we_got_to_the_end_of_it
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: you should put `FooBar` between ticks in the documentation
+  --> $DIR/doc.rs:144:43
+   |
+LL | /** E.g., serialization of an empty list: FooBar
+   |                                           ^^^^^^
+
+error: you should put `BarQuz` between ticks in the documentation
+  --> $DIR/doc.rs:149:5
+   |
+LL | And BarQuz too.
+   |     ^^^^^^
+
+error: you should put `be_sure_we_got_to_the_end_of_it` between ticks in the documentation
+  --> $DIR/doc.rs:150:1
+   |
+LL | be_sure_we_got_to_the_end_of_it
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: you should put `be_sure_we_got_to_the_end_of_it` between ticks in the documentation
+  --> $DIR/doc.rs:161:5
+   |
+LL | /// be_sure_we_got_to_the_end_of_it
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: you should put bare URLs between `<`/`>` or make a proper Markdown link
+  --> $DIR/doc.rs:188:13
+   |
+LL | /// Not ok: http://www.unicode.org
+   |             ^^^^^^^^^^^^^^^^^^^^^^
+
+error: you should put bare URLs between `<`/`>` or make a proper Markdown link
+  --> $DIR/doc.rs:189:13
+   |
+LL | /// Not ok: https://www.unicode.org
+   |             ^^^^^^^^^^^^^^^^^^^^^^^
+
+error: you should put bare URLs between `<`/`>` or make a proper Markdown link
+  --> $DIR/doc.rs:190:13
+   |
+LL | /// Not ok: http://www.unicode.org/
+   |             ^^^^^^^^^^^^^^^^^^^^^^
+
+error: you should put bare URLs between `<`/`>` or make a proper Markdown link
+  --> $DIR/doc.rs:191:13
+   |
+LL | /// Not ok: http://www.unicode.org/reports/tr9/#Reordering_Resolved_Levels
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: you should put `mycrate::Collection` between ticks in the documentation
+  --> $DIR/doc.rs:194:22
+   |
+LL | /// An iterator over mycrate::Collection's values.
+   |                      ^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 31 previous errors
+
diff --git a/tests/ui/doc/unbalanced_ticks.rs b/tests/ui/doc/unbalanced_ticks.rs
new file mode 100644
index 00000000000..78e87bc6906
--- /dev/null
+++ b/tests/ui/doc/unbalanced_ticks.rs
@@ -0,0 +1,36 @@
+//! This file tests for the `DOC_MARKDOWN` lint, specifically cases
+//! where ticks are unbalanced (see issue #6753).
+
+#![allow(dead_code)]
+#![warn(clippy::doc_markdown)]
+
+/// This is a doc comment with `unbalanced_tick marks and several words that
+/// should be `encompassed_by` tick marks because they `contain_underscores`.
+/// Because of the initial `unbalanced_tick` pair, the error message is
+/// very `confusing_and_misleading`.
+fn main() {}
+
+/// This paragraph has `unbalanced_tick marks and should stop_linting.
+///
+/// This paragraph is fine and should_be linted normally.
+///
+/// Double unbalanced backtick from ``here to here` should lint.
+///
+/// Double balanced back ticks ``start end`` is fine.
+fn multiple_paragraphs() {}
+
+/// ```
+/// // Unbalanced tick mark in code block shouldn't warn:
+/// `
+/// ```
+fn in_code_block() {}
+
+/// # `Fine`
+///
+/// ## not_fine
+///
+/// ### `unbalanced
+///
+/// - This `item has unbalanced tick marks
+/// - This item needs backticks_here
+fn other_markdown() {}
diff --git a/tests/ui/doc/unbalanced_ticks.stderr b/tests/ui/doc/unbalanced_ticks.stderr
new file mode 100644
index 00000000000..45ca34e2a8c
--- /dev/null
+++ b/tests/ui/doc/unbalanced_ticks.stderr
@@ -0,0 +1,64 @@
+error: backticks are unbalanced
+  --> $DIR/unbalanced_ticks.rs:7:1
+   |
+LL | / /// This is a doc comment with `unbalanced_tick marks and several words that
+LL | | /// should be `encompassed_by` tick marks because they `contain_underscores`.
+LL | | /// Because of the initial `unbalanced_tick` pair, the error message is
+LL | | /// very `confusing_and_misleading`.
+   | |____________________________________^
+   |
+   = note: `-D clippy::doc-markdown` implied by `-D warnings`
+   = help: a backtick may be missing a pair
+
+error: backticks are unbalanced
+  --> $DIR/unbalanced_ticks.rs:13:1
+   |
+LL | /// This paragraph has `unbalanced_tick marks and should stop_linting.
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: a backtick may be missing a pair
+
+error: you should put `should_be` between ticks in the documentation
+  --> $DIR/unbalanced_ticks.rs:15:32
+   |
+LL | /// This paragraph is fine and should_be linted normally.
+   |                                ^^^^^^^^^
+
+error: backticks are unbalanced
+  --> $DIR/unbalanced_ticks.rs:17:1
+   |
+LL | /// Double unbalanced backtick from ``here to here` should lint.
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: a backtick may be missing a pair
+
+error: you should put `not_fine` between ticks in the documentation
+  --> $DIR/unbalanced_ticks.rs:30:8
+   |
+LL | /// ## not_fine
+   |        ^^^^^^^^
+
+error: backticks are unbalanced
+  --> $DIR/unbalanced_ticks.rs:32:1
+   |
+LL | /// ### `unbalanced
+   | ^^^^^^^^^^^^^^^^^^^
+   |
+   = help: a backtick may be missing a pair
+
+error: backticks are unbalanced
+  --> $DIR/unbalanced_ticks.rs:34:1
+   |
+LL | /// - This `item has unbalanced tick marks
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: a backtick may be missing a pair
+
+error: you should put `backticks_here` between ticks in the documentation
+  --> $DIR/unbalanced_ticks.rs:35:23
+   |
+LL | /// - This item needs backticks_here
+   |                       ^^^^^^^^^^^^^^
+
+error: aborting due to 8 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 10122e4a48c3a31276f8e117af66c949c8f962a3 Mon Sep 17 00:00:00 2001
From: Joe Ranweiler <joe@lemma.co>
Date: Tue, 22 Jun 2021 18:45:12 -0700
Subject: Remove shadowed receiver in check invocation

---
 clippy_lints/src/methods/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index c6bef7bc5d5..21585543b0a 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -2036,7 +2036,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
 fn check_methods<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, msrv: Option<&RustcVersion>) {
     if let Some((name, [recv, args @ ..], span)) = method_call!(expr) {
         match (name, args) {
-            ("add" | "offset" | "sub" | "wrapping_offset" | "wrapping_add" | "wrapping_sub", [recv, _]) => {
+            ("add" | "offset" | "sub" | "wrapping_offset" | "wrapping_add" | "wrapping_sub", [_arg]) => {
                 zst_offset::check(cx, expr, recv);
             },
             ("and_then", [arg]) => {
-- 
cgit 1.4.1-3-g733a5


From 9492de584319c0331619991e5b201ea6e00b9b2f Mon Sep 17 00:00:00 2001
From: Devin Ragotzy <devin.ragotzy@gmail.com>
Date: Mon, 31 May 2021 14:15:17 -0400
Subject: Add import_rename lint, this adds a field on the Conf struct

Rename lint and fix review issues
---
 CHANGELOG.md                                       |   1 +
 clippy_lints/src/lib.rs                            |   5 +
 clippy_lints/src/missing_enforced_import_rename.rs | 102 +++++++++++++++++++++
 clippy_lints/src/utils/conf.rs                     |   9 ++
 .../missing_enforced_import_rename/clippy.toml     |  10 ++
 .../conf_missing_enforced_import_rename.rs         |  16 ++++
 .../conf_missing_enforced_import_rename.stderr     |  40 ++++++++
 .../toml_unknown_key/conf_unknown_key.stderr       |   2 +-
 8 files changed, 184 insertions(+), 1 deletion(-)
 create mode 100644 clippy_lints/src/missing_enforced_import_rename.rs
 create mode 100644 tests/ui-toml/missing_enforced_import_rename/clippy.toml
 create mode 100644 tests/ui-toml/missing_enforced_import_rename/conf_missing_enforced_import_rename.rs
 create mode 100644 tests/ui-toml/missing_enforced_import_rename/conf_missing_enforced_import_rename.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 67c2b41b200..5f62a172035 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2657,6 +2657,7 @@ Released 2018-09-13
 [`misrefactored_assign_op`]: https://rust-lang.github.io/rust-clippy/master/index.html#misrefactored_assign_op
 [`missing_const_for_fn`]: https://rust-lang.github.io/rust-clippy/master/index.html#missing_const_for_fn
 [`missing_docs_in_private_items`]: https://rust-lang.github.io/rust-clippy/master/index.html#missing_docs_in_private_items
+[`missing_enforced_import_renames`]: https://rust-lang.github.io/rust-clippy/master/index.html#missing_enforced_import_renames
 [`missing_errors_doc`]: https://rust-lang.github.io/rust-clippy/master/index.html#missing_errors_doc
 [`missing_inline_in_public_items`]: https://rust-lang.github.io/rust-clippy/master/index.html#missing_inline_in_public_items
 [`missing_panics_doc`]: https://rust-lang.github.io/rust-clippy/master/index.html#missing_panics_doc
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 03e093f4c03..9cffeeb0224 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -267,6 +267,7 @@ mod misc;
 mod misc_early;
 mod missing_const_for_fn;
 mod missing_doc;
+mod missing_enforced_import_rename;
 mod missing_inline;
 mod modulo_arithmetic;
 mod multiple_crate_versions;
@@ -813,6 +814,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         misc_early::ZERO_PREFIXED_LITERAL,
         missing_const_for_fn::MISSING_CONST_FOR_FN,
         missing_doc::MISSING_DOCS_IN_PRIVATE_ITEMS,
+        missing_enforced_import_rename::MISSING_ENFORCED_IMPORT_RENAMES,
         missing_inline::MISSING_INLINE_IN_PUBLIC_ITEMS,
         modulo_arithmetic::MODULO_ARITHMETIC,
         multiple_crate_versions::MULTIPLE_CRATE_VERSIONS,
@@ -1017,6 +1019,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(misc::FLOAT_CMP_CONST),
         LintId::of(misc_early::UNNEEDED_FIELD_PATTERN),
         LintId::of(missing_doc::MISSING_DOCS_IN_PRIVATE_ITEMS),
+        LintId::of(missing_enforced_import_rename::MISSING_ENFORCED_IMPORT_RENAMES),
         LintId::of(missing_inline::MISSING_INLINE_IN_PUBLIC_ITEMS),
         LintId::of(modulo_arithmetic::MODULO_ARITHMETIC),
         LintId::of(panic_in_result_fn::PANIC_IN_RESULT_FN),
@@ -2077,6 +2080,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box unused_async::UnusedAsync);
     let disallowed_types = conf.disallowed_types.iter().cloned().collect::<FxHashSet<_>>();
     store.register_late_pass(move || box disallowed_type::DisallowedType::new(&disallowed_types));
+    let import_renames = conf.enforced_import_renames.clone();
+    store.register_late_pass(move || box missing_enforced_import_rename::ImportRename::new(import_renames.clone()));
 
 }
 
diff --git a/clippy_lints/src/missing_enforced_import_rename.rs b/clippy_lints/src/missing_enforced_import_rename.rs
new file mode 100644
index 00000000000..59565350f72
--- /dev/null
+++ b/clippy_lints/src/missing_enforced_import_rename.rs
@@ -0,0 +1,102 @@
+use clippy_utils::{diagnostics::span_lint_and_sugg, source::snippet_opt};
+
+use rustc_data_structures::fx::FxHashMap;
+use rustc_errors::Applicability;
+use rustc_hir::{def::Res, def_id::DefId, Crate, Item, ItemKind, UseKind};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::Symbol;
+
+use crate::utils::conf::Rename;
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for imports that do not rename the item as specified
+    /// in the `enforce-import-renames` config option.
+    ///
+    /// **Why is this bad?** Consistency is important, if a project has defined import
+    /// renames they should be followed. More practically, some item names are too
+    /// vague outside of their defining scope this can enforce a more meaningful naming.
+    ///
+    /// **Known problems:** None
+    ///
+    /// **Example:**
+    ///
+    /// An example clippy.toml configuration:
+    /// ```toml
+    /// # clippy.toml
+    /// enforced-import-renames = [ { path = "serde_json::Value", rename = "JsonValue" }]
+    /// ```
+    ///
+    /// ```rust,ignore
+    /// use serde_json::Value;
+    /// ```
+    /// Use instead:
+    /// ```rust,ignore
+    /// use serde_json::Value as JsonValue;
+    /// ```
+    pub MISSING_ENFORCED_IMPORT_RENAMES,
+    restriction,
+    "enforce import renames"
+}
+
+pub struct ImportRename {
+    conf_renames: Vec<Rename>,
+    renames: FxHashMap<DefId, Symbol>,
+}
+
+impl ImportRename {
+    pub fn new(conf_renames: Vec<Rename>) -> Self {
+        Self {
+            conf_renames,
+            renames: FxHashMap::default(),
+        }
+    }
+}
+
+impl_lint_pass!(ImportRename => [MISSING_ENFORCED_IMPORT_RENAMES]);
+
+impl LateLintPass<'_> for ImportRename {
+    fn check_crate(&mut self, cx: &LateContext<'_>, _: &Crate<'_>) {
+        for Rename { path, rename } in &self.conf_renames {
+            if let Res::Def(_, id) = clippy_utils::path_to_res(cx, &path.split("::").collect::<Vec<_>>()) {
+                self.renames.insert(id, Symbol::intern(rename));
+            }
+        }
+    }
+
+    fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
+        if_chain! {
+            if let ItemKind::Use(path, UseKind::Single) = &item.kind;
+            if let Res::Def(_, id) = path.res;
+            if let Some(name) = self.renames.get(&id);
+            // Remove semicolon since it is not present for nested imports
+            let span_without_semi = cx.sess().source_map().span_until_char(item.span, ';');
+            if let Some(snip) = snippet_opt(cx, span_without_semi);
+            if let Some(import) = match snip.split_once(" as ") {
+                None => Some(snip.as_str()),
+                Some((import, rename)) => {
+                    if rename.trim() == &*name.as_str() {
+                        None
+                    } else {
+                        Some(import.trim())
+                    }
+                },
+            };
+            then {
+                span_lint_and_sugg(
+                    cx,
+                    MISSING_ENFORCED_IMPORT_RENAMES,
+                    span_without_semi,
+                    "this import should be renamed",
+                    "try",
+                    format!(
+                        "{} as {}",
+                        import,
+                        name,
+                    ),
+                    Applicability::MachineApplicable,
+                );
+            }
+        }
+    }
+}
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 2f8064499fd..6fc4998318c 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -8,6 +8,13 @@ use std::error::Error;
 use std::path::{Path, PathBuf};
 use std::{env, fmt, fs, io};
 
+/// Holds information used by `MISSING_ENFORCED_IMPORT_RENAMES` lint.
+#[derive(Clone, Debug, Deserialize)]
+pub struct Rename {
+    pub path: String,
+    pub rename: String,
+}
+
 /// Conf with parse errors
 #[derive(Default)]
 pub struct TryConf {
@@ -203,6 +210,8 @@ define_Conf! {
     (cargo_ignore_publish: bool = false),
     /// Lint: NONSTANDARD_MACRO_BRACES. Enforce the named macros always use the braces specified. <br> A `MacroMatcher` can be added like so `{ name = "macro_name", brace = "(" }`. If the macro is could be used with a full path two `MacroMatcher`s have to be added one with the full path `crate_name::macro_name` and one with just the macro name.
     (standard_macro_braces: Vec<crate::nonstandard_macro_braces::MacroMatcher> = Vec::new()),
+    /// Lint: MISSING_ENFORCED_IMPORT_RENAMES. The list of imports to always rename, a fully qualified path followed by the rename.
+    (enforced_import_renames: Vec<crate::utils::conf::Rename> = Vec::new()),
 }
 
 /// Search for the configuration file.
diff --git a/tests/ui-toml/missing_enforced_import_rename/clippy.toml b/tests/ui-toml/missing_enforced_import_rename/clippy.toml
new file mode 100644
index 00000000000..05ba822874d
--- /dev/null
+++ b/tests/ui-toml/missing_enforced_import_rename/clippy.toml
@@ -0,0 +1,10 @@
+enforced-import-renames = [
+    { path = "std::option::Option", rename = "Maybe" },
+    { path = "std::process::Child", rename = "Kid" },
+    { path = "std::process::exit", rename = "goodbye" },
+    { path = "std::collections::BTreeMap", rename = "Map" },
+    { path = "std::clone", rename = "foo" },
+    { path = "std::thread::sleep", rename = "thread_sleep" },
+    { path = "std::any::type_name", rename = "ident" },
+    { path = "std::sync::Mutex", rename = "StdMutie" }
+]
diff --git a/tests/ui-toml/missing_enforced_import_rename/conf_missing_enforced_import_rename.rs b/tests/ui-toml/missing_enforced_import_rename/conf_missing_enforced_import_rename.rs
new file mode 100644
index 00000000000..f60058c8628
--- /dev/null
+++ b/tests/ui-toml/missing_enforced_import_rename/conf_missing_enforced_import_rename.rs
@@ -0,0 +1,16 @@
+#![warn(clippy::missing_enforced_import_renames)]
+
+use std::alloc as colla;
+use std::option::Option as Maybe;
+use std::process::{exit as wrong_exit, Child as Kid};
+use std::thread::sleep;
+#[rustfmt::skip]
+use std::{
+    any::{type_name, Any},
+    clone,
+    sync :: Mutex,
+};
+
+fn main() {
+    use std::collections::BTreeMap as OopsWrongRename;
+}
diff --git a/tests/ui-toml/missing_enforced_import_rename/conf_missing_enforced_import_rename.stderr b/tests/ui-toml/missing_enforced_import_rename/conf_missing_enforced_import_rename.stderr
new file mode 100644
index 00000000000..45de8fdffef
--- /dev/null
+++ b/tests/ui-toml/missing_enforced_import_rename/conf_missing_enforced_import_rename.stderr
@@ -0,0 +1,40 @@
+error: this import should be renamed
+  --> $DIR/conf_missing_enforced_import_rename.rs:5:20
+   |
+LL | use std::process::{exit as wrong_exit, Child as Kid};
+   |                    ^^^^^^^^^^^^^^^^^^ help: try: `exit as goodbye`
+   |
+   = note: `-D clippy::missing-enforced-import-renames` implied by `-D warnings`
+
+error: this import should be renamed
+  --> $DIR/conf_missing_enforced_import_rename.rs:6:1
+   |
+LL | use std::thread::sleep;
+   | ^^^^^^^^^^^^^^^^^^^^^^ help: try: `use std::thread::sleep as thread_sleep`
+
+error: this import should be renamed
+  --> $DIR/conf_missing_enforced_import_rename.rs:9:11
+   |
+LL |     any::{type_name, Any},
+   |           ^^^^^^^^^ help: try: `type_name as ident`
+
+error: this import should be renamed
+  --> $DIR/conf_missing_enforced_import_rename.rs:10:5
+   |
+LL |     clone,
+   |     ^^^^^ help: try: `clone as foo`
+
+error: this import should be renamed
+  --> $DIR/conf_missing_enforced_import_rename.rs:11:5
+   |
+LL |     sync :: Mutex,
+   |     ^^^^^^^^^^^^^ help: try: `sync :: Mutex as StdMutie`
+
+error: this import should be renamed
+  --> $DIR/conf_missing_enforced_import_rename.rs:15:5
+   |
+LL |     use std::collections::BTreeMap as OopsWrongRename;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `use std::collections::BTreeMap as Map`
+
+error: aborting due to 6 previous errors
+
diff --git a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
index f179479cbec..aa7bfa2cc8c 100644
--- a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
+++ b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
@@ -1,4 +1,4 @@
-error: error reading Clippy's configuration file `$DIR/clippy.toml`: unknown field `foobar`, expected one of `avoid-breaking-exported-api`, `msrv`, `blacklisted-names`, `cognitive-complexity-threshold`, `cyclomatic-complexity-threshold`, `doc-valid-idents`, `too-many-arguments-threshold`, `type-complexity-threshold`, `single-char-binding-names-threshold`, `too-large-for-stack`, `enum-variant-name-threshold`, `enum-variant-size-threshold`, `verbose-bit-mask-threshold`, `literal-representation-threshold`, `trivial-copy-size-limit`, `pass-by-value-size-limit`, `too-many-lines-threshold`, `array-size-threshold`, `vec-box-size-threshold`, `max-trait-bounds`, `max-struct-bools`, `max-fn-params-bools`, `warn-on-all-wildcard-imports`, `disallowed-methods`, `disallowed-types`, `unreadable-literal-lint-fractions`, `upper-case-acronyms-aggressive`, `cargo-ignore-publish`, `standard-macro-braces`, `third-party` at line 5 column 1
+error: error reading Clippy's configuration file `$DIR/clippy.toml`: unknown field `foobar`, expected one of `avoid-breaking-exported-api`, `msrv`, `blacklisted-names`, `cognitive-complexity-threshold`, `cyclomatic-complexity-threshold`, `doc-valid-idents`, `too-many-arguments-threshold`, `type-complexity-threshold`, `single-char-binding-names-threshold`, `too-large-for-stack`, `enum-variant-name-threshold`, `enum-variant-size-threshold`, `verbose-bit-mask-threshold`, `literal-representation-threshold`, `trivial-copy-size-limit`, `pass-by-value-size-limit`, `too-many-lines-threshold`, `array-size-threshold`, `vec-box-size-threshold`, `max-trait-bounds`, `max-struct-bools`, `max-fn-params-bools`, `warn-on-all-wildcard-imports`, `disallowed-methods`, `disallowed-types`, `unreadable-literal-lint-fractions`, `upper-case-acronyms-aggressive`, `cargo-ignore-publish`, `standard-macro-braces`, `enforced-import-renames`, `third-party` at line 5 column 1
 
 error: aborting due to previous error
 
-- 
cgit 1.4.1-3-g733a5


From 39856b17ec5a7deec4fa2c394e595616089fc6bd Mon Sep 17 00:00:00 2001
From: Igor Aleksanov <popzxc@yandex.ru>
Date: Tue, 22 Jun 2021 15:34:46 +0300
Subject: Improve lint message for match-same-arms lint

Simplify error message producing & remove extra example
---
 clippy_lints/src/matches.rs      | 3 ++-
 tests/ui/match_same_arms.stderr  | 7 +++++++
 tests/ui/match_same_arms2.stderr | 7 +++++++
 3 files changed, 16 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index cd3e3b97928..386349d9f59 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -2266,7 +2266,8 @@ fn lint_match_arms<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>) {
                             ),
                         );
                     } else {
-                        diag.span_help(i.pat.span, &format!("consider refactoring into `{} | {}`", lhs, rhs));
+                        diag.span_help(i.pat.span, &format!("consider refactoring into `{} | {}`", lhs, rhs,))
+                            .help("...or consider changing the match arm bodies");
                     }
                 },
             );
diff --git a/tests/ui/match_same_arms.stderr b/tests/ui/match_same_arms.stderr
index 0549886a1e8..e48451acfe8 100644
--- a/tests/ui/match_same_arms.stderr
+++ b/tests/ui/match_same_arms.stderr
@@ -32,6 +32,7 @@ help: consider refactoring into `(1, .., 3) | (.., 3)`
    |
 LL |         (1, .., 3) => 42,
    |         ^^^^^^^^^^
+   = help: ...or consider changing the match arm bodies
 
 error: this `match` has identical arm bodies
   --> $DIR/match_same_arms.rs:24:15
@@ -49,6 +50,7 @@ help: consider refactoring into `42 | 51`
    |
 LL |         42 => 1,
    |         ^^
+   = help: ...or consider changing the match arm bodies
 
 error: this `match` has identical arm bodies
   --> $DIR/match_same_arms.rs:26:15
@@ -66,6 +68,7 @@ help: consider refactoring into `41 | 52`
    |
 LL |         41 => 2,
    |         ^^
+   = help: ...or consider changing the match arm bodies
 
 error: this `match` has identical arm bodies
   --> $DIR/match_same_arms.rs:32:14
@@ -83,6 +86,7 @@ help: consider refactoring into `1 | 2`
    |
 LL |         1 => 2,
    |         ^
+   = help: ...or consider changing the match arm bodies
 
 error: this `match` has identical arm bodies
   --> $DIR/match_same_arms.rs:33:14
@@ -100,6 +104,7 @@ help: consider refactoring into `1 | 3`
    |
 LL |         1 => 2,
    |         ^
+   = help: ...or consider changing the match arm bodies
 
 error: this `match` has identical arm bodies
   --> $DIR/match_same_arms.rs:33:14
@@ -117,6 +122,7 @@ help: consider refactoring into `2 | 3`
    |
 LL |         2 => 2, //~ ERROR 2nd matched arms have same body
    |         ^
+   = help: ...or consider changing the match arm bodies
 
 error: this `match` has identical arm bodies
   --> $DIR/match_same_arms.rs:50:55
@@ -134,6 +140,7 @@ help: consider refactoring into `CommandInfo::BuiltIn { name, .. } | CommandInfo
    |
 LL |                 CommandInfo::BuiltIn { name, .. } => name.to_string(),
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   = help: ...or consider changing the match arm bodies
 
 error: aborting due to 8 previous errors
 
diff --git a/tests/ui/match_same_arms2.stderr b/tests/ui/match_same_arms2.stderr
index 430021a0f7f..e1ed12f9370 100644
--- a/tests/ui/match_same_arms2.stderr
+++ b/tests/ui/match_same_arms2.stderr
@@ -53,6 +53,7 @@ help: consider refactoring into `42 | 51`
    |
 LL |         42 => foo(),
    |         ^^
+   = help: ...or consider changing the match arm bodies
 
 error: this `match` has identical arm bodies
   --> $DIR/match_same_arms2.rs:40:17
@@ -70,6 +71,7 @@ help: consider refactoring into `Some(_) | None`
    |
 LL |         Some(_) => 24,
    |         ^^^^^^^
+   = help: ...or consider changing the match arm bodies
 
 error: this `match` has identical arm bodies
   --> $DIR/match_same_arms2.rs:62:28
@@ -87,6 +89,7 @@ help: consider refactoring into `(Some(a), None) | (None, Some(a))`
    |
 LL |         (Some(a), None) => bar(a),
    |         ^^^^^^^^^^^^^^^
+   = help: ...or consider changing the match arm bodies
 
 error: this `match` has identical arm bodies
   --> $DIR/match_same_arms2.rs:68:26
@@ -104,6 +107,7 @@ help: consider refactoring into `(Some(a), ..) | (.., Some(a))`
    |
 LL |         (Some(a), ..) => bar(a),
    |         ^^^^^^^^^^^^^
+   = help: ...or consider changing the match arm bodies
 
 error: this `match` has identical arm bodies
   --> $DIR/match_same_arms2.rs:102:29
@@ -121,6 +125,7 @@ help: consider refactoring into `(Ok(x), Some(_)) | (Ok(_), Some(x))`
    |
 LL |         (Ok(x), Some(_)) => println!("ok {}", x),
    |         ^^^^^^^^^^^^^^^^
+   = help: ...or consider changing the match arm bodies
    = note: this error originates in the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: this `match` has identical arm bodies
@@ -139,6 +144,7 @@ help: consider refactoring into `Ok(3) | Ok(_)`
    |
 LL |         Ok(3) => println!("ok"),
    |         ^^^^^
+   = help: ...or consider changing the match arm bodies
    = note: this error originates in the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: this `match` has identical arm bodies
@@ -163,6 +169,7 @@ help: consider refactoring into `0 | 1`
    |
 LL |         0 => {
    |         ^
+   = help: ...or consider changing the match arm bodies
 
 error: match expression looks like `matches!` macro
   --> $DIR/match_same_arms2.rs:162:16
-- 
cgit 1.4.1-3-g733a5


From 28d3873ef52fd1e4f9efa115d18235e92fecfa83 Mon Sep 17 00:00:00 2001
From: Igor Aleksanov <popzxc@yandex.ru>
Date: Sat, 19 Jun 2021 21:14:05 +0300
Subject: Do not spawn blacklisted_name lint in test context

Fix detecting of the 'test' attribute

Update UI test to actually check that warning is not triggered in the test code

Fix approach for detecting the test module

Add nested test case

Remove code duplication by extracting 'is_test_module_or_function' into 'clippy_utils'

Cleanup the code
---
 clippy_lints/src/blacklisted_name.rs | 31 ++++++++++++++++++++++++++++---
 clippy_lints/src/wildcard_imports.rs | 12 ++++--------
 clippy_utils/src/lib.rs              | 12 ++++++++++++
 tests/ui/blacklisted_name.rs         | 12 ++++++++++++
 4 files changed, 56 insertions(+), 11 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/blacklisted_name.rs b/clippy_lints/src/blacklisted_name.rs
index b26ef33e056..8eb94f3c28e 100644
--- a/clippy_lints/src/blacklisted_name.rs
+++ b/clippy_lints/src/blacklisted_name.rs
@@ -1,6 +1,6 @@
-use clippy_utils::diagnostics::span_lint;
+use clippy_utils::{diagnostics::span_lint, is_test_module_or_function};
 use rustc_data_structures::fx::FxHashSet;
-use rustc_hir::{Pat, PatKind};
+use rustc_hir::{Item, Pat, PatKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 
@@ -25,18 +25,37 @@ declare_clippy_lint! {
 #[derive(Clone, Debug)]
 pub struct BlacklistedName {
     blacklist: FxHashSet<String>,
+    test_modules_deep: u32,
 }
 
 impl BlacklistedName {
     pub fn new(blacklist: FxHashSet<String>) -> Self {
-        Self { blacklist }
+        Self {
+            blacklist,
+            test_modules_deep: 0,
+        }
+    }
+
+    fn in_test_module(&self) -> bool {
+        self.test_modules_deep != 0
     }
 }
 
 impl_lint_pass!(BlacklistedName => [BLACKLISTED_NAME]);
 
 impl<'tcx> LateLintPass<'tcx> for BlacklistedName {
+    fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
+        if is_test_module_or_function(cx.tcx, item) {
+            self.test_modules_deep = self.test_modules_deep.saturating_add(1);
+        }
+    }
+
     fn check_pat(&mut self, cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>) {
+        // Check whether we are under the `test` attribute.
+        if self.in_test_module() {
+            return;
+        }
+
         if let PatKind::Binding(.., ident, _) = pat.kind {
             if self.blacklist.contains(&ident.name.to_string()) {
                 span_lint(
@@ -48,4 +67,10 @@ impl<'tcx> LateLintPass<'tcx> for BlacklistedName {
             }
         }
     }
+
+    fn check_item_post(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
+        if is_test_module_or_function(cx.tcx, item) {
+            self.test_modules_deep = self.test_modules_deep.saturating_sub(1);
+        }
+    }
 }
diff --git a/clippy_lints/src/wildcard_imports.rs b/clippy_lints/src/wildcard_imports.rs
index 51c1117d206..520586b3a1f 100644
--- a/clippy_lints/src/wildcard_imports.rs
+++ b/clippy_lints/src/wildcard_imports.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::in_macro;
 use clippy_utils::source::{snippet, snippet_with_applicability};
+use clippy_utils::{in_macro, is_test_module_or_function};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{
@@ -106,7 +106,7 @@ impl_lint_pass!(WildcardImports => [ENUM_GLOB_USE, WILDCARD_IMPORTS]);
 
 impl LateLintPass<'_> for WildcardImports {
     fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
-        if is_test_module_or_function(item) {
+        if is_test_module_or_function(cx.tcx, item) {
             self.test_modules_deep = self.test_modules_deep.saturating_add(1);
         }
         if item.vis.node.is_pub() || item.vis.node.is_pub_restricted() {
@@ -183,8 +183,8 @@ impl LateLintPass<'_> for WildcardImports {
         }
     }
 
-    fn check_item_post(&mut self, _: &LateContext<'_>, item: &Item<'_>) {
-        if is_test_module_or_function(item) {
+    fn check_item_post(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
+        if is_test_module_or_function(cx.tcx, item) {
             self.test_modules_deep = self.test_modules_deep.saturating_sub(1);
         }
     }
@@ -208,7 +208,3 @@ fn is_prelude_import(segments: &[PathSegment<'_>]) -> bool {
 fn is_super_only_import(segments: &[PathSegment<'_>]) -> bool {
     segments.len() == 1 && segments[0].ident.name == kw::Super
 }
-
-fn is_test_module_or_function(item: &Item<'_>) -> bool {
-    matches!(item.kind, ItemKind::Mod(..)) && item.ident.name.as_str().contains("test")
-}
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 66e75b0c206..ef4854afc83 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -1727,3 +1727,15 @@ pub fn is_hir_ty_cfg_dependant(cx: &LateContext<'_>, ty: &hir::Ty<'_>) -> bool {
         }
     }
 }
+
+/// Checks whether item either has `test` attribute applied, or
+/// is a module with `test` in its name.
+pub fn is_test_module_or_function(tcx: TyCtxt<'_>, item: &Item<'_>) -> bool {
+    if let Some(def_id) = tcx.hir().opt_local_def_id(item.hir_id()) {
+        if tcx.has_attr(def_id.to_def_id(), sym::test) {
+            return true;
+        }
+    }
+
+    matches!(item.kind, ItemKind::Mod(..)) && item.ident.name.as_str().contains("test")
+}
diff --git a/tests/ui/blacklisted_name.rs b/tests/ui/blacklisted_name.rs
index cb15bdd2f1b..57d7139fef5 100644
--- a/tests/ui/blacklisted_name.rs
+++ b/tests/ui/blacklisted_name.rs
@@ -43,3 +43,15 @@ fn issue_1647_ref_mut() {
     let ref mut baz = 0;
     if let Some(ref mut quux) = Some(42) {}
 }
+
+mod tests {
+    fn issue_7305() {
+        // `blackisted_name` lint should not be triggered inside of the test code.
+        let foo = 0;
+
+        // Check that even in nested functions warning is still not triggere.
+        fn nested() {
+            let foo = 0;
+        }
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 7e21db5b5c18f47a5f43e36f0bf34f1bbd1a1466 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Mon, 14 Jun 2021 10:01:43 -0500
Subject: Add suspicious group

---
 README.md                                           | 21 +++++++++++----------
 clippy_dev/src/main.rs                              |  1 +
 clippy_dev/src/update_lints.rs                      |  5 ++++-
 clippy_lints/src/lib.rs                             | 11 ++++++++---
 .../src/utils/internal_lints/metadata_collector.rs  |  3 ++-
 util/lintlib.py                                     |  1 +
 6 files changed, 27 insertions(+), 15 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/README.md b/README.md
index 6c556f579ca..29bfebe4583 100644
--- a/README.md
+++ b/README.md
@@ -10,16 +10,17 @@ A collection of lints to catch common mistakes and improve your [Rust](https://g
 Lints are divided into categories, each with a default [lint level](https://doc.rust-lang.org/rustc/lints/levels.html).
 You can choose how much Clippy is supposed to ~~annoy~~ help you by changing the lint level by category.
 
-| Category              | Description                                                             | Default level |
-| --------------------- | ----------------------------------------------------------------------- | ------------- |
-| `clippy::all`         | all lints that are on by default (correctness, style, complexity, perf) | **warn/deny** |
-| `clippy::correctness` | code that is outright wrong or very useless                             | **deny**      |
-| `clippy::style`       | code that should be written in a more idiomatic way                     | **warn**      |
-| `clippy::complexity`  | code that does something simple but in a complex way                    | **warn**      |
-| `clippy::perf`        | code that can be written to run faster                                  | **warn**      |
-| `clippy::pedantic`    | lints which are rather strict or might have false positives             | allow         |
-| `clippy::nursery`     | new lints that are still under development                              | allow         |
-| `clippy::cargo`       | lints for the cargo manifest                                            | allow         |
+| Category              | Description                                                                         | Default level |
+| --------------------- | ----------------------------------------------------------------------------------- | ------------- |
+| `clippy::all`         | all lints that are on by default (correctness, suspicious, style, complexity, perf) | **warn/deny** |
+| `clippy::correctness` | code that is outright wrong or useless                                              | **deny**      |
+| `clippy::suspicious`  | code that is most likely wrong or useless                                           | **warn**      |
+| `clippy::style`       | code that should be written in a more idiomatic way                                 | **warn**      |
+| `clippy::complexity`  | code that does something simple but in a complex way                                | **warn**      |
+| `clippy::perf`        | code that can be written to run faster                                              | **warn**      |
+| `clippy::pedantic`    | lints which are rather strict or might have false positives                         | allow         |
+| `clippy::nursery`     | new lints that are still under development                                          | allow         |
+| `clippy::cargo`       | lints for the cargo manifest                                                        | allow         |
 
 More to come, please [file an issue](https://github.com/rust-lang/rust-clippy/issues) if you have ideas!
 
diff --git a/clippy_dev/src/main.rs b/clippy_dev/src/main.rs
index f5bd08657ea..fbc530eb606 100644
--- a/clippy_dev/src/main.rs
+++ b/clippy_dev/src/main.rs
@@ -137,6 +137,7 @@ fn get_clap_config<'a>() -> ArgMatches<'a> {
                         .possible_values(&[
                             "style",
                             "correctness",
+                            "suspicious",
                             "complexity",
                             "perf",
                             "pedantic",
diff --git a/clippy_dev/src/update_lints.rs b/clippy_dev/src/update_lints.rs
index edf6c5f57a4..db467c26f15 100644
--- a/clippy_dev/src/update_lints.rs
+++ b/clippy_dev/src/update_lints.rs
@@ -92,7 +92,10 @@ pub fn run(update_mode: UpdateMode) {
         || {
             // clippy::all should only include the following lint groups:
             let all_group_lints = usable_lints.iter().filter(|l| {
-                l.group == "correctness" || l.group == "style" || l.group == "complexity" || l.group == "perf"
+                matches!(
+                    &*l.group,
+                    "correctness" | "suspicious" | "style" | "complexity" | "perf"
+                )
             });
 
             gen_lint_group_list(all_group_lints)
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 9cffeeb0224..4ce1d511d27 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -60,9 +60,9 @@ use rustc_session::Session;
 /// 4. The `description` that contains a short explanation on what's wrong with code where the
 ///    lint is triggered.
 ///
-/// Currently the categories `style`, `correctness`, `complexity` and `perf` are enabled by default.
-/// As said in the README.md of this repository, if the lint level mapping changes, please update
-/// README.md.
+/// Currently the categories `style`, `correctness`, `suspicious`, `complexity` and `perf` are
+/// enabled by default. As said in the README.md of this repository, if the lint level mapping
+/// changes, please update README.md.
 ///
 /// # Example
 ///
@@ -106,6 +106,11 @@ macro_rules! declare_clippy_lint {
             $(#[$attr])* pub clippy::$name, Deny, $description, report_in_external_macro: true
         }
     };
+    { $(#[$attr:meta])* pub $name:tt, suspicious, $description:tt } => {
+        declare_tool_lint! {
+            $(#[$attr])* pub clippy::$name, Warn, $description, report_in_external_macro: true
+        }
+    };
     { $(#[$attr:meta])* pub $name:tt, complexity, $description:tt } => {
         declare_tool_lint! {
             $(#[$attr])* pub clippy::$name, Warn, $description, report_in_external_macro: true
diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index c980a0246fd..e877af09e28 100644
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -47,8 +47,9 @@ const DEPRECATED_LINT_GROUP_STR: &str = "deprecated";
 const DEPRECATED_LINT_LEVEL: &str = "none";
 /// This array holds Clippy's lint groups with their corresponding default lint level. The
 /// lint level for deprecated lints is set in `DEPRECATED_LINT_LEVEL`.
-const DEFAULT_LINT_LEVELS: [(&str, &str); 8] = [
+const DEFAULT_LINT_LEVELS: &[(&str, &str)] = &[
     ("correctness", "deny"),
+    ("suspicious", "warn"),
     ("restriction", "allow"),
     ("style", "warn"),
     ("pedantic", "allow"),
diff --git a/util/lintlib.py b/util/lintlib.py
index 3b6e8c372ed..9cefb2dbb19 100644
--- a/util/lintlib.py
+++ b/util/lintlib.py
@@ -19,6 +19,7 @@ comment_re = re.compile(r'''\s*/// ?(.*)''')
 
 lint_levels = {
     "correctness": 'Deny',
+    "suspicious": 'Warn',
     "style": 'Warn',
     "complexity": 'Warn',
     "perf": 'Warn',
-- 
cgit 1.4.1-3-g733a5


From f02632cee63137fb0184ecb3828fdd6d8f9ce6dd Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Mon, 14 Jun 2021 14:09:17 -0500
Subject: Move some lints to suspicious

---
 clippy_lints/src/assign_ops.rs                 |  2 +-
 clippy_lints/src/attrs.rs                      |  2 +-
 clippy_lints/src/eval_order_dependence.rs      |  2 +-
 clippy_lints/src/float_equality_without_abs.rs |  2 +-
 clippy_lints/src/formatting.rs                 |  6 ++---
 clippy_lints/src/lib.rs                        | 31 ++++++++++++++------------
 clippy_lints/src/loops/mod.rs                  |  6 ++---
 clippy_lints/src/methods/mod.rs                |  2 +-
 clippy_lints/src/mut_key.rs                    |  2 +-
 clippy_lints/src/suspicious_trait_impl.rs      |  4 ++--
 tests/ui/mut_key.stderr                        |  2 +-
 tests/ui/suspicious_arithmetic_impl.stderr     |  2 +-
 12 files changed, 33 insertions(+), 30 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/assign_ops.rs b/clippy_lints/src/assign_ops.rs
index bc6eec0051a..a8c527fe2e3 100644
--- a/clippy_lints/src/assign_ops.rs
+++ b/clippy_lints/src/assign_ops.rs
@@ -55,7 +55,7 @@ declare_clippy_lint! {
     /// a += a + b;
     /// ```
     pub MISREFACTORED_ASSIGN_OP,
-    complexity,
+    suspicious,
     "having a variable on both sides of an assign op"
 }
 
diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs
index 932cd58bf62..f272ed010a1 100644
--- a/clippy_lints/src/attrs.rs
+++ b/clippy_lints/src/attrs.rs
@@ -173,7 +173,7 @@ declare_clippy_lint! {
     /// #![deny(clippy::as_conversions)]
     /// ```
     pub BLANKET_CLIPPY_RESTRICTION_LINTS,
-    style,
+    suspicious,
     "enabling the complete restriction group"
 }
 
diff --git a/clippy_lints/src/eval_order_dependence.rs b/clippy_lints/src/eval_order_dependence.rs
index 5fdf5bc9e9d..03a8b40df55 100644
--- a/clippy_lints/src/eval_order_dependence.rs
+++ b/clippy_lints/src/eval_order_dependence.rs
@@ -38,7 +38,7 @@ declare_clippy_lint! {
     /// let a = tmp + x;
     /// ```
     pub EVAL_ORDER_DEPENDENCE,
-    complexity,
+    suspicious,
     "whether a variable read occurs before a write depends on sub-expression evaluation order"
 }
 
diff --git a/clippy_lints/src/float_equality_without_abs.rs b/clippy_lints/src/float_equality_without_abs.rs
index b5ebe5f90ba..1e503cc795c 100644
--- a/clippy_lints/src/float_equality_without_abs.rs
+++ b/clippy_lints/src/float_equality_without_abs.rs
@@ -36,7 +36,7 @@ declare_clippy_lint! {
      /// }
      /// ```
     pub FLOAT_EQUALITY_WITHOUT_ABS,
-    correctness,
+    suspicious,
     "float equality check without `.abs()`"
 }
 
diff --git a/clippy_lints/src/formatting.rs b/clippy_lints/src/formatting.rs
index 3bd6a09d365..8aefb8d46f6 100644
--- a/clippy_lints/src/formatting.rs
+++ b/clippy_lints/src/formatting.rs
@@ -22,7 +22,7 @@ declare_clippy_lint! {
     /// a =- 42; // confusing, should it be `a -= 42` or `a = -42`?
     /// ```
     pub SUSPICIOUS_ASSIGNMENT_FORMATTING,
-    style,
+    suspicious,
     "suspicious formatting of `*=`, `-=` or `!=`"
 }
 
@@ -44,7 +44,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     pub SUSPICIOUS_UNARY_OP_FORMATTING,
-    style,
+    suspicious,
     "suspicious formatting of unary `-` or `!` on the RHS of a BinOp"
 }
 
@@ -80,7 +80,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     pub SUSPICIOUS_ELSE_FORMATTING,
-    style,
+    suspicious,
     "suspicious formatting of `else`"
 }
 
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 4ce1d511d27..20eea61d78d 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1461,7 +1461,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_group(true, "clippy::style", Some("clippy_style"), vec![
         LintId::of(assertions_on_constants::ASSERTIONS_ON_CONSTANTS),
         LintId::of(assign_ops::ASSIGN_OP_PATTERN),
-        LintId::of(attrs::BLANKET_CLIPPY_RESTRICTION_LINTS),
         LintId::of(blacklisted_name::BLACKLISTED_NAME),
         LintId::of(blocks_in_if_conditions::BLOCKS_IN_IF_CONDITIONS),
         LintId::of(bool_assert_comparison::BOOL_ASSERT_COMPARISON),
@@ -1479,9 +1478,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(eq_op::OP_REF),
         LintId::of(eta_reduction::REDUNDANT_CLOSURE),
         LintId::of(float_literal::EXCESSIVE_PRECISION),
-        LintId::of(formatting::SUSPICIOUS_ASSIGNMENT_FORMATTING),
-        LintId::of(formatting::SUSPICIOUS_ELSE_FORMATTING),
-        LintId::of(formatting::SUSPICIOUS_UNARY_OP_FORMATTING),
         LintId::of(from_over_into::FROM_OVER_INTO),
         LintId::of(from_str_radix_10::FROM_STR_RADIX_10),
         LintId::of(functions::DOUBLE_MUST_USE),
@@ -1494,7 +1490,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(len_zero::LEN_ZERO),
         LintId::of(literal_representation::INCONSISTENT_DIGIT_GROUPING),
         LintId::of(literal_representation::UNUSUAL_BYTE_GROUPINGS),
-        LintId::of(loops::EMPTY_LOOP),
         LintId::of(loops::FOR_KV_MAP),
         LintId::of(loops::NEEDLESS_RANGE_LOOP),
         LintId::of(loops::SAME_ITEM_PUSH),
@@ -1574,7 +1569,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     ]);
 
     store.register_group(true, "clippy::complexity", Some("clippy_complexity"), vec![
-        LintId::of(assign_ops::MISREFACTORED_ASSIGN_OP),
         LintId::of(attrs::DEPRECATED_CFG_ATTR),
         LintId::of(booleans::NONMINIMAL_BOOL),
         LintId::of(casts::CHAR_LIT_AS_U8),
@@ -1584,7 +1578,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(double_parens::DOUBLE_PARENS),
         LintId::of(duration_subsec::DURATION_SUBSEC),
         LintId::of(eval_order_dependence::DIVERGING_SUB_EXPRESSION),
-        LintId::of(eval_order_dependence::EVAL_ORDER_DEPENDENCE),
         LintId::of(explicit_write::EXPLICIT_WRITE),
         LintId::of(format::USELESS_FORMAT),
         LintId::of(functions::TOO_MANY_ARGUMENTS),
@@ -1595,7 +1588,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(lifetimes::NEEDLESS_LIFETIMES),
         LintId::of(loops::EXPLICIT_COUNTER_LOOP),
         LintId::of(loops::MANUAL_FLATTEN),
-        LintId::of(loops::MUT_RANGE_BOUND),
         LintId::of(loops::SINGLE_ELEMENT_LOOP),
         LintId::of(loops::WHILE_LET_LOOP),
         LintId::of(manual_strip::MANUAL_STRIP),
@@ -1619,7 +1611,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(methods::OPTION_FILTER_MAP),
         LintId::of(methods::SEARCH_IS_SOME),
         LintId::of(methods::SKIP_WHILE_NEXT),
-        LintId::of(methods::SUSPICIOUS_MAP),
         LintId::of(methods::UNNECESSARY_FILTER_MAP),
         LintId::of(methods::USELESS_ASREF),
         LintId::of(misc::SHORT_CIRCUIT_STATEMENT),
@@ -1688,7 +1679,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(enum_clike::ENUM_CLIKE_UNPORTABLE_VARIANT),
         LintId::of(eq_op::EQ_OP),
         LintId::of(erasing_op::ERASING_OP),
-        LintId::of(float_equality_without_abs::FLOAT_EQUALITY_WITHOUT_ABS),
         LintId::of(formatting::POSSIBLE_MISSING_COMMA),
         LintId::of(functions::NOT_UNSAFE_PTR_ARG_DEREF),
         LintId::of(if_let_mutex::IF_LET_MUTEX),
@@ -1698,7 +1688,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(inline_fn_without_body::INLINE_FN_WITHOUT_BODY),
         LintId::of(let_underscore::LET_UNDERSCORE_LOCK),
         LintId::of(literal_representation::MISTYPED_LITERAL_SUFFIXES),
-        LintId::of(loops::FOR_LOOPS_OVER_FALLIBLES),
         LintId::of(loops::ITER_NEXT_LOOP),
         LintId::of(loops::NEVER_LOOP),
         LintId::of(loops::WHILE_IMMUTABLE_CONDITION),
@@ -1713,7 +1702,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(misc::CMP_NAN),
         LintId::of(misc::FLOAT_CMP),
         LintId::of(misc::MODULO_ONE),
-        LintId::of(mut_key::MUTABLE_KEY_TYPE),
         LintId::of(non_octal_unix_permissions::NON_OCTAL_UNIX_PERMISSIONS),
         LintId::of(open_options::NONSENSICAL_OPEN_OPTIONS),
         LintId::of(option_env_unwrap::OPTION_ENV_UNWRAP),
@@ -1724,8 +1712,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(self_assignment::SELF_ASSIGNMENT),
         LintId::of(serde_api::SERDE_API_MISUSE),
         LintId::of(size_of_in_element_count::SIZE_OF_IN_ELEMENT_COUNT),
-        LintId::of(suspicious_trait_impl::SUSPICIOUS_ARITHMETIC_IMPL),
-        LintId::of(suspicious_trait_impl::SUSPICIOUS_OP_ASSIGN_IMPL),
         LintId::of(swap::ALMOST_SWAPPED),
         LintId::of(to_string_in_display::TO_STRING_IN_DISPLAY),
         LintId::of(transmute::UNSOUND_COLLECTION_TRANSMUTE),
@@ -1742,6 +1728,23 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(vec_resize_to_zero::VEC_RESIZE_TO_ZERO),
     ]);
 
+    store.register_group(true, "clippy::suspicious", None, vec![
+        LintId::of(assign_ops::MISREFACTORED_ASSIGN_OP),
+        LintId::of(attrs::BLANKET_CLIPPY_RESTRICTION_LINTS),
+        LintId::of(eval_order_dependence::EVAL_ORDER_DEPENDENCE),
+        LintId::of(float_equality_without_abs::FLOAT_EQUALITY_WITHOUT_ABS),
+        LintId::of(formatting::SUSPICIOUS_ASSIGNMENT_FORMATTING),
+        LintId::of(formatting::SUSPICIOUS_ELSE_FORMATTING),
+        LintId::of(formatting::SUSPICIOUS_UNARY_OP_FORMATTING),
+        LintId::of(loops::EMPTY_LOOP),
+        LintId::of(loops::FOR_LOOPS_OVER_FALLIBLES),
+        LintId::of(loops::MUT_RANGE_BOUND),
+        LintId::of(methods::SUSPICIOUS_MAP),
+        LintId::of(mut_key::MUTABLE_KEY_TYPE),
+        LintId::of(suspicious_trait_impl::SUSPICIOUS_ARITHMETIC_IMPL),
+        LintId::of(suspicious_trait_impl::SUSPICIOUS_OP_ASSIGN_IMPL),
+    ]);
+
     store.register_group(true, "clippy::perf", Some("clippy_perf"), vec![
         LintId::of(entry::MAP_ENTRY),
         LintId::of(escape::BOXED_LOCAL),
diff --git a/clippy_lints/src/loops/mod.rs b/clippy_lints/src/loops/mod.rs
index a4bc3e6bd10..56a123b69c6 100644
--- a/clippy_lints/src/loops/mod.rs
+++ b/clippy_lints/src/loops/mod.rs
@@ -199,7 +199,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     pub FOR_LOOPS_OVER_FALLIBLES,
-    correctness,
+    suspicious,
     "for-looping over an `Option` or a `Result`, which is more clearly expressed as an `if let`"
 }
 
@@ -313,7 +313,7 @@ declare_clippy_lint! {
     /// loop {}
     /// ```
     pub EMPTY_LOOP,
-    style,
+    suspicious,
     "empty `loop {}`, which should block or sleep"
 }
 
@@ -401,7 +401,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     pub MUT_RANGE_BOUND,
-    complexity,
+    suspicious,
     "for loop over a range where one of the bounds is a mutable variable"
 }
 
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 21585543b0a..283fcf281df 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1248,7 +1248,7 @@ declare_clippy_lint! {
     /// let _ = (0..3).map(|x| x + 2).count();
     /// ```
     pub SUSPICIOUS_MAP,
-    complexity,
+    suspicious,
     "suspicious usage of map"
 }
 
diff --git a/clippy_lints/src/mut_key.rs b/clippy_lints/src/mut_key.rs
index 1786d5805d7..6c87136e5e1 100644
--- a/clippy_lints/src/mut_key.rs
+++ b/clippy_lints/src/mut_key.rs
@@ -50,7 +50,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     pub MUTABLE_KEY_TYPE,
-    correctness,
+    suspicious,
     "Check for mutable `Map`/`Set` key type"
 }
 
diff --git a/clippy_lints/src/suspicious_trait_impl.rs b/clippy_lints/src/suspicious_trait_impl.rs
index 512abde11a6..2203ab57b10 100644
--- a/clippy_lints/src/suspicious_trait_impl.rs
+++ b/clippy_lints/src/suspicious_trait_impl.rs
@@ -26,7 +26,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     pub SUSPICIOUS_ARITHMETIC_IMPL,
-    correctness,
+    suspicious,
     "suspicious use of operators in impl of arithmetic trait"
 }
 
@@ -47,7 +47,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     pub SUSPICIOUS_OP_ASSIGN_IMPL,
-    correctness,
+    suspicious,
     "suspicious use of operators in impl of OpAssign trait"
 }
 
diff --git a/tests/ui/mut_key.stderr b/tests/ui/mut_key.stderr
index 8d6a259c7e3..a8460b06ca6 100644
--- a/tests/ui/mut_key.stderr
+++ b/tests/ui/mut_key.stderr
@@ -4,7 +4,7 @@ error: mutable key type
 LL | fn should_not_take_this_arg(m: &mut HashMap<Key, usize>, _n: usize) -> HashSet<Key> {
    |                                ^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = note: `#[deny(clippy::mutable_key_type)]` on by default
+   = note: `-D clippy::mutable-key-type` implied by `-D warnings`
 
 error: mutable key type
   --> $DIR/mut_key.rs:27:72
diff --git a/tests/ui/suspicious_arithmetic_impl.stderr b/tests/ui/suspicious_arithmetic_impl.stderr
index 388fc740082..63fc9ecb79a 100644
--- a/tests/ui/suspicious_arithmetic_impl.stderr
+++ b/tests/ui/suspicious_arithmetic_impl.stderr
@@ -12,7 +12,7 @@ error: suspicious use of binary operator in `AddAssign` impl
 LL |         *self = *self - other;
    |                       ^
    |
-   = note: `#[deny(clippy::suspicious_op_assign_impl)]` on by default
+   = note: `-D clippy::suspicious-op-assign-impl` implied by `-D warnings`
 
 error: suspicious use of binary operator in `MulAssign` impl
   --> $DIR/suspicious_arithmetic_impl.rs:32:16
-- 
cgit 1.4.1-3-g733a5


From 38569c03eb0d0917698d83aea5fbbc35acf7305c Mon Sep 17 00:00:00 2001
From: Mara Bos <m-ou.se@m-ou.se>
Date: Sat, 26 Jun 2021 15:22:15 +0200
Subject: Don't suggest unstable and doc(hidden) variants.

---
 clippy_lints/src/matches.rs               | 8 ++++----
 clippy_utils/src/attrs.rs                 | 5 +++++
 tests/ui/auxiliary/non-exhaustive-enum.rs | 2 ++
 3 files changed, 11 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index cd3e3b97928..da5ac96e3db 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -992,9 +992,9 @@ impl CommonPrefixSearcher<'a> {
     }
 }
 
-fn is_doc_hidden(cx: &LateContext<'_>, variant_def: &VariantDef) -> bool {
+fn is_hidden(cx: &LateContext<'_>, variant_def: &VariantDef) -> bool {
     let attrs = cx.tcx.get_attrs(variant_def.def_id);
-    clippy_utils::attrs::is_doc_hidden(attrs)
+    clippy_utils::attrs::is_doc_hidden(attrs) || clippy_utils::attrs::is_unstable(attrs)
 }
 
 #[allow(clippy::too_many_lines)]
@@ -1033,7 +1033,7 @@ fn check_wild_enum_match(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>])
 
     // Accumulate the variants which should be put in place of the wildcard because they're not
     // already covered.
-    let mut missing_variants: Vec<_> = adt_def.variants.iter().collect();
+    let mut missing_variants: Vec<_> = adt_def.variants.iter().filter(|x| !is_hidden(cx, x)).collect();
 
     let mut path_prefix = CommonPrefixSearcher::None;
     for arm in arms {
@@ -1118,7 +1118,7 @@ fn check_wild_enum_match(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>])
 
     match missing_variants.as_slice() {
         [] => (),
-        [x] if !adt_def.is_variant_list_non_exhaustive() && !is_doc_hidden(cx, x) => span_lint_and_sugg(
+        [x] if !adt_def.is_variant_list_non_exhaustive() => span_lint_and_sugg(
             cx,
             MATCH_WILDCARD_FOR_SINGLE_VARIANTS,
             wildcard_span,
diff --git a/clippy_utils/src/attrs.rs b/clippy_utils/src/attrs.rs
index 0318c483959..c19b558cd8c 100644
--- a/clippy_utils/src/attrs.rs
+++ b/clippy_utils/src/attrs.rs
@@ -157,3 +157,8 @@ pub fn is_doc_hidden(attrs: &[ast::Attribute]) -> bool {
         .filter_map(ast::Attribute::meta_item_list)
         .any(|l| attr::list_contains_name(&l, sym::hidden))
 }
+
+/// Return true if the attributes contain `#[unstable]`
+pub fn is_unstable(attrs: &[ast::Attribute]) -> bool {
+    attrs.iter().any(|attr| attr.has_name(sym::unstable))
+}
diff --git a/tests/ui/auxiliary/non-exhaustive-enum.rs b/tests/ui/auxiliary/non-exhaustive-enum.rs
index 67d4d255701..18560bc5e1e 100644
--- a/tests/ui/auxiliary/non-exhaustive-enum.rs
+++ b/tests/ui/auxiliary/non-exhaustive-enum.rs
@@ -20,4 +20,6 @@ pub enum ErrorKind {
     UnexpectedEof,
     Unsupported,
     OutOfMemory,
+    #[doc(hidden)]
+    Uncategorized,
 }
-- 
cgit 1.4.1-3-g733a5


From 8827e96303a15f9accc7c02ae2a2bd42573b2739 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Thu, 17 Jun 2021 11:19:33 -0500
Subject: Make ItemKind check dry

---
 clippy_lints/src/use_self.rs | 79 ++++++++++++++++++++------------------------
 1 file changed, 35 insertions(+), 44 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/use_self.rs b/clippy_lints/src/use_self.rs
index f71dfd02499..9cac3b20ac5 100644
--- a/clippy_lints/src/use_self.rs
+++ b/clippy_lints/src/use_self.rs
@@ -87,59 +87,42 @@ const SEGMENTS_MSG: &str = "segments should be composed of at least 1 element";
 
 impl<'tcx> LateLintPass<'tcx> for UseSelf {
     fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
+        if !is_item_interesting(item) {
+            // This does two things:
+            //  1) Reduce needless churn on `self.stack`
+            //  2) Don't push `StackItem::NoCheck` when entering `ItemKind::OpaqueTy`,
+            //     in order to lint `foo() -> impl <..>`
+            return;
+        }
         // We push the self types of `impl`s on a stack here. Only the top type on the stack is
         // relevant for linting, since this is the self type of the `impl` we're currently in. To
         // avoid linting on nested items, we push `StackItem::NoCheck` on the stack to signal, that
         // we're in an `impl` or nested item, that we don't want to lint
-        //
-        // NB: If you push something on the stack in this method, remember to also pop it in the
-        // `check_item_post` method.
-        match &item.kind {
-            ItemKind::Impl(Impl {
-                self_ty: hir_self_ty,
-                of_trait,
-                ..
-            }) => {
-                let should_check = if let TyKind::Path(QPath::Resolved(_, item_path)) = hir_self_ty.kind {
-                    let parameters = &item_path.segments.last().expect(SEGMENTS_MSG).args;
-                    parameters.as_ref().map_or(true, |params| {
-                        !params.parenthesized && !params.args.iter().any(|arg| matches!(arg, GenericArg::Lifetime(_)))
-                    })
-                } else {
-                    false
-                };
+        let stack_item = if_chain! {
+            if let ItemKind::Impl(Impl { self_ty, ref of_trait, .. }) = item.kind;
+            if let TyKind::Path(QPath::Resolved(_, item_path)) = self_ty.kind;
+            let parameters = &item_path.segments.last().expect(SEGMENTS_MSG).args;
+            if parameters.as_ref().map_or(true, |params| {
+                !params.parenthesized && !params.args.iter().any(|arg| matches!(arg, GenericArg::Lifetime(_)))
+            });
+            then {
                 let impl_trait_ref_def_id = of_trait.as_ref().map(|_| cx.tcx.hir().local_def_id(item.hir_id()));
-                if should_check {
-                    self.stack.push(StackItem::Check {
-                        hir_id: hir_self_ty.hir_id,
-                        impl_trait_ref_def_id,
-                        types_to_lint: Vec::new(),
-                        types_to_skip: Vec::new(),
-                    });
-                } else {
-                    self.stack.push(StackItem::NoCheck);
+                StackItem::Check {
+                    hir_id: self_ty.hir_id,
+                    impl_trait_ref_def_id,
+                    types_to_lint: Vec::new(),
+                    types_to_skip: Vec::new(),
                 }
-            },
-            ItemKind::Static(..)
-            | ItemKind::Const(..)
-            | ItemKind::Fn(..)
-            | ItemKind::Enum(..)
-            | ItemKind::Struct(..)
-            | ItemKind::Union(..)
-            | ItemKind::Trait(..) => {
-                self.stack.push(StackItem::NoCheck);
-            },
-            _ => (),
-        }
+            } else {
+                StackItem::NoCheck
+            }
+        };
+        self.stack.push(stack_item);
     }
 
     fn check_item_post(&mut self, _: &LateContext<'_>, item: &Item<'_>) {
-        use ItemKind::{Const, Enum, Fn, Impl, Static, Struct, Trait, Union};
-        match item.kind {
-            Impl { .. } | Static(..) | Const(..) | Fn(..) | Enum(..) | Struct(..) | Union(..) | Trait(..) => {
-                self.stack.pop();
-            },
-            _ => (),
+        if is_item_interesting(item) {
+            self.stack.pop();
         }
     }
 
@@ -359,6 +342,14 @@ fn lint_path_to_variant(cx: &LateContext<'_>, path: &Path<'_>) {
     }
 }
 
+fn is_item_interesting(item: &Item<'_>) -> bool {
+    use rustc_hir::ItemKind::{Const, Enum, Fn, Impl, Static, Struct, Trait, Union};
+    matches!(
+        item.kind,
+        Impl { .. } | Static(..) | Const(..) | Fn(..) | Enum(..) | Struct(..) | Union(..) | Trait(..)
+    )
+}
+
 fn ty_from_hir_id<'tcx>(cx: &LateContext<'tcx>, hir_id: HirId) -> Ty<'tcx> {
     if let Some(Node::Ty(hir_ty)) = cx.tcx.hir().find(hir_id) {
         hir_ty_to_ty(cx.tcx, hir_ty)
-- 
cgit 1.4.1-3-g733a5


From 4913d82175366c1b303afce17071d070d8203874 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Wed, 16 Jun 2021 12:23:09 -0500
Subject: Simplify in impl check

---
 clippy_lints/src/use_self.rs | 21 ++++-----------------
 1 file changed, 4 insertions(+), 17 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/use_self.rs b/clippy_lints/src/use_self.rs
index 9cac3b20ac5..fea4b6c5c91 100644
--- a/clippy_lints/src/use_self.rs
+++ b/clippy_lints/src/use_self.rs
@@ -2,6 +2,7 @@ use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::ty::same_type_and_consts;
 use clippy_utils::{in_macro, meets_msrv, msrvs};
 use if_chain::if_chain;
+use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Applicability;
 use rustc_hir::{
     self as hir,
@@ -75,7 +76,7 @@ enum StackItem {
     Check {
         hir_id: HirId,
         impl_trait_ref_def_id: Option<LocalDefId>,
-        types_to_skip: Vec<HirId>,
+        types_to_skip: FxHashSet<HirId>,
         types_to_lint: Vec<HirId>,
     },
     NoCheck,
@@ -111,7 +112,7 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
                     hir_id: self_ty.hir_id,
                     impl_trait_ref_def_id,
                     types_to_lint: Vec::new(),
-                    types_to_skip: Vec::new(),
+                    types_to_skip: std::iter::once(self_ty.hir_id).collect(),
                 }
             } else {
                 StackItem::NoCheck
@@ -216,7 +217,7 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
 
     fn check_ty(&mut self, cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>) {
         if_chain! {
-            if !in_macro(hir_ty.span) && !in_impl(cx, hir_ty);
+            if !in_macro(hir_ty.span);
             if meets_msrv(self.msrv.as_ref(), &msrvs::TYPE_ALIAS_ENUM_VARIANTS);
             if let Some(StackItem::Check {
                 hir_id,
@@ -358,20 +359,6 @@ fn ty_from_hir_id<'tcx>(cx: &LateContext<'tcx>, hir_id: HirId) -> Ty<'tcx> {
     }
 }
 
-fn in_impl(cx: &LateContext<'tcx>, hir_ty: &hir::Ty<'_>) -> bool {
-    let map = cx.tcx.hir();
-    let parent = map.get_parent_node(hir_ty.hir_id);
-    if_chain! {
-        if let Some(Node::Item(item)) = map.find(parent);
-        if let ItemKind::Impl { .. } = item.kind;
-        then {
-            true
-        } else {
-            false
-        }
-    }
-}
-
 fn should_lint_ty(hir_ty: &hir::Ty<'_>, ty: Ty<'_>, self_ty: Ty<'_>) -> bool {
     if_chain! {
         if same_type_and_consts(ty, self_ty);
-- 
cgit 1.4.1-3-g733a5


From 6e801e251fb6de6dc9563b0203ea3dab14e3d3ec Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Wed, 16 Jun 2021 15:43:48 -0500
Subject: Use type_of for impl self type

---
 clippy_lints/src/use_self.rs | 38 +++++++++++++-------------------------
 1 file changed, 13 insertions(+), 25 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/use_self.rs b/clippy_lints/src/use_self.rs
index fea4b6c5c91..3623e5139f9 100644
--- a/clippy_lints/src/use_self.rs
+++ b/clippy_lints/src/use_self.rs
@@ -9,7 +9,7 @@ use rustc_hir::{
     def::{CtorOf, DefKind, Res},
     def_id::LocalDefId,
     intravisit::{walk_ty, NestedVisitorMap, Visitor},
-    Expr, ExprKind, FnRetTy, FnSig, GenericArg, HirId, Impl, ImplItemKind, Item, ItemKind, Node, Path, QPath, TyKind,
+    Expr, ExprKind, FnRetTy, FnSig, GenericArg, HirId, Impl, ImplItemKind, Item, ItemKind, Path, QPath, TyKind,
 };
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::hir::map::Map;
@@ -74,8 +74,7 @@ impl UseSelf {
 #[derive(Debug)]
 enum StackItem {
     Check {
-        hir_id: HirId,
-        impl_trait_ref_def_id: Option<LocalDefId>,
+        impl_id: LocalDefId,
         types_to_skip: FxHashSet<HirId>,
         types_to_lint: Vec<HirId>,
     },
@@ -87,7 +86,7 @@ impl_lint_pass!(UseSelf => [USE_SELF]);
 const SEGMENTS_MSG: &str = "segments should be composed of at least 1 element";
 
 impl<'tcx> LateLintPass<'tcx> for UseSelf {
-    fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
+    fn check_item(&mut self, _cx: &LateContext<'_>, item: &Item<'_>) {
         if !is_item_interesting(item) {
             // This does two things:
             //  1) Reduce needless churn on `self.stack`
@@ -100,17 +99,15 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
         // avoid linting on nested items, we push `StackItem::NoCheck` on the stack to signal, that
         // we're in an `impl` or nested item, that we don't want to lint
         let stack_item = if_chain! {
-            if let ItemKind::Impl(Impl { self_ty, ref of_trait, .. }) = item.kind;
+            if let ItemKind::Impl(Impl { self_ty, .. }) = item.kind;
             if let TyKind::Path(QPath::Resolved(_, item_path)) = self_ty.kind;
             let parameters = &item_path.segments.last().expect(SEGMENTS_MSG).args;
             if parameters.as_ref().map_or(true, |params| {
                 !params.parenthesized && !params.args.iter().any(|arg| matches!(arg, GenericArg::Lifetime(_)))
             });
             then {
-                let impl_trait_ref_def_id = of_trait.as_ref().map(|_| cx.tcx.hir().local_def_id(item.hir_id()));
                 StackItem::Check {
-                    hir_id: self_ty.hir_id,
-                    impl_trait_ref_def_id,
+                    impl_id: item.def_id,
                     types_to_lint: Vec::new(),
                     types_to_skip: std::iter::once(self_ty.hir_id).collect(),
                 }
@@ -133,11 +130,11 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
         if_chain! {
             if let ImplItemKind::Fn(FnSig { decl, .. }, ..) = impl_item.kind;
             if let Some(&mut StackItem::Check {
-                impl_trait_ref_def_id: Some(def_id),
+                impl_id,
                 ref mut types_to_skip,
                 ..
             }) = self.stack.last_mut();
-            if let Some(impl_trait_ref) = cx.tcx.impl_trait_ref(def_id);
+            if let Some(impl_trait_ref) = cx.tcx.impl_trait_ref(impl_id);
             then {
                 // `self_ty` is the semantic self type of `impl <trait> for <type>`. This cannot be
                 // `Self`.
@@ -195,13 +192,13 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
         // could only allow this lint on item scope. And we would have to check if those types are
         // already dealt with in `check_ty` anyway.
         if let Some(StackItem::Check {
-            hir_id,
+            impl_id,
             types_to_lint,
             types_to_skip,
             ..
         }) = self.stack.last_mut()
         {
-            let self_ty = ty_from_hir_id(cx, *hir_id);
+            let self_ty = cx.tcx.type_of(*impl_id);
 
             let mut visitor = LintTyCollector {
                 cx,
@@ -220,15 +217,14 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
             if !in_macro(hir_ty.span);
             if meets_msrv(self.msrv.as_ref(), &msrvs::TYPE_ALIAS_ENUM_VARIANTS);
             if let Some(StackItem::Check {
-                hir_id,
+                impl_id,
                 types_to_lint,
                 types_to_skip,
-                ..
             }) = self.stack.last();
             if !types_to_skip.contains(&hir_ty.hir_id);
             if types_to_lint.contains(&hir_ty.hir_id)
                 || {
-                    let self_ty = ty_from_hir_id(cx, *hir_id);
+                    let self_ty = cx.tcx.type_of(*impl_id);
                     should_lint_ty(hir_ty, hir_ty_to_ty(cx.tcx, hir_ty), self_ty)
                 };
             let hir = cx.tcx.hir();
@@ -244,8 +240,8 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
         if_chain! {
             if !in_macro(expr.span);
             if meets_msrv(self.msrv.as_ref(), &msrvs::TYPE_ALIAS_ENUM_VARIANTS);
-            if let Some(StackItem::Check { hir_id, .. }) = self.stack.last();
-            if cx.typeck_results().expr_ty(expr) == ty_from_hir_id(cx, *hir_id);
+            if let Some(&StackItem::Check { impl_id, .. }) = self.stack.last();
+            if cx.typeck_results().expr_ty(expr) == cx.tcx.type_of(impl_id);
             then {} else { return; }
         }
         match expr.kind {
@@ -351,14 +347,6 @@ fn is_item_interesting(item: &Item<'_>) -> bool {
     )
 }
 
-fn ty_from_hir_id<'tcx>(cx: &LateContext<'tcx>, hir_id: HirId) -> Ty<'tcx> {
-    if let Some(Node::Ty(hir_ty)) = cx.tcx.hir().find(hir_id) {
-        hir_ty_to_ty(cx.tcx, hir_ty)
-    } else {
-        unreachable!("This function should only be called with `HirId`s that are for sure `Node::Ty`")
-    }
-}
-
 fn should_lint_ty(hir_ty: &hir::Ty<'_>, ty: Ty<'_>, self_ty: Ty<'_>) -> bool {
     if_chain! {
         if same_type_and_consts(ty, self_ty);
-- 
cgit 1.4.1-3-g733a5


From bae76f9c1756e0a8d25c8ddc0b2c8225df1b364e Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Wed, 16 Jun 2021 12:14:23 -0500
Subject: Remove a visitor from use_self

---
 clippy_lints/src/use_self.rs | 97 ++++++++++----------------------------------
 1 file changed, 22 insertions(+), 75 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/use_self.rs b/clippy_lints/src/use_self.rs
index 3623e5139f9..906ac10f461 100644
--- a/clippy_lints/src/use_self.rs
+++ b/clippy_lints/src/use_self.rs
@@ -13,7 +13,7 @@ use rustc_hir::{
 };
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::hir::map::Map;
-use rustc_middle::ty::{AssocKind, Ty};
+use rustc_middle::ty::AssocKind;
 use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::Span;
@@ -75,8 +75,8 @@ impl UseSelf {
 enum StackItem {
     Check {
         impl_id: LocalDefId,
+        in_body: u32,
         types_to_skip: FxHashSet<HirId>,
-        types_to_lint: Vec<HirId>,
     },
     NoCheck,
 }
@@ -108,7 +108,7 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
             then {
                 StackItem::Check {
                     impl_id: item.def_id,
-                    types_to_lint: Vec::new(),
+                    in_body: 0,
                     types_to_skip: std::iter::once(self_ty.hir_id).collect(),
                 }
             } else {
@@ -182,33 +182,18 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
         }
     }
 
-    fn check_body(&mut self, cx: &LateContext<'tcx>, body: &'tcx hir::Body<'_>) {
+    fn check_body(&mut self, _: &LateContext<'_>, _: &hir::Body<'_>) {
         // `hir_ty_to_ty` cannot be called in `Body`s or it will panic (sometimes). But in bodies
         // we can use `cx.typeck_results.node_type(..)` to get the `ty::Ty` from a `hir::Ty`.
         // However the `node_type()` method can *only* be called in bodies.
-        //
-        // This method implementation determines which types should get linted in a `Body` and
-        // which shouldn't, with a visitor. We could directly lint in the visitor, but then we
-        // could only allow this lint on item scope. And we would have to check if those types are
-        // already dealt with in `check_ty` anyway.
-        if let Some(StackItem::Check {
-            impl_id,
-            types_to_lint,
-            types_to_skip,
-            ..
-        }) = self.stack.last_mut()
-        {
-            let self_ty = cx.tcx.type_of(*impl_id);
+        if let Some(&mut StackItem::Check { ref mut in_body, .. }) = self.stack.last_mut() {
+            *in_body = in_body.saturating_add(1);
+        }
+    }
 
-            let mut visitor = LintTyCollector {
-                cx,
-                self_ty,
-                types_to_lint: vec![],
-                types_to_skip: vec![],
-            };
-            visitor.visit_expr(&body.value);
-            types_to_lint.extend(visitor.types_to_lint);
-            types_to_skip.extend(visitor.types_to_skip);
+    fn check_body_post(&mut self, _: &LateContext<'_>, _: &hir::Body<'_>) {
+        if let Some(&mut StackItem::Check { ref mut in_body, .. }) = self.stack.last_mut() {
+            *in_body = in_body.saturating_sub(1);
         }
     }
 
@@ -216,17 +201,20 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
         if_chain! {
             if !in_macro(hir_ty.span);
             if meets_msrv(self.msrv.as_ref(), &msrvs::TYPE_ALIAS_ENUM_VARIANTS);
-            if let Some(StackItem::Check {
+            if let Some(&StackItem::Check {
                 impl_id,
-                types_to_lint,
-                types_to_skip,
+                in_body,
+                ref types_to_skip,
             }) = self.stack.last();
+            if let TyKind::Path(QPath::Resolved(_, path)) = hir_ty.kind;
+            if !matches!(path.res, Res::SelfTy(..) | Res::Def(DefKind::TyParam, _));
             if !types_to_skip.contains(&hir_ty.hir_id);
-            if types_to_lint.contains(&hir_ty.hir_id)
-                || {
-                    let self_ty = cx.tcx.type_of(*impl_id);
-                    should_lint_ty(hir_ty, hir_ty_to_ty(cx.tcx, hir_ty), self_ty)
-                };
+            let ty = if in_body > 0 {
+                cx.typeck_results().node_type(hir_ty.hir_id)
+            } else {
+                hir_ty_to_ty(cx.tcx, hir_ty)
+            };
+            if same_type_and_consts(ty, cx.tcx.type_of(impl_id));
             let hir = cx.tcx.hir();
             let id = hir.get_parent_node(hir_ty.hir_id);
             if !hir.opt_span(id).map_or(false, in_macro);
@@ -289,35 +277,6 @@ impl<'tcx> Visitor<'tcx> for SkipTyCollector {
     }
 }
 
-struct LintTyCollector<'a, 'tcx> {
-    cx: &'a LateContext<'tcx>,
-    self_ty: Ty<'tcx>,
-    types_to_lint: Vec<HirId>,
-    types_to_skip: Vec<HirId>,
-}
-
-impl<'a, 'tcx> Visitor<'tcx> for LintTyCollector<'a, 'tcx> {
-    type Map = Map<'tcx>;
-
-    fn visit_ty(&mut self, hir_ty: &'tcx hir::Ty<'_>) {
-        if_chain! {
-            if let Some(ty) = self.cx.typeck_results().node_type_opt(hir_ty.hir_id);
-            if should_lint_ty(hir_ty, ty, self.self_ty);
-            then {
-                self.types_to_lint.push(hir_ty.hir_id);
-            } else {
-                self.types_to_skip.push(hir_ty.hir_id);
-            }
-        }
-
-        walk_ty(self, hir_ty);
-    }
-
-    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-        NestedVisitorMap::None
-    }
-}
-
 fn span_lint(cx: &LateContext<'_>, span: Span) {
     span_lint_and_sugg(
         cx,
@@ -346,15 +305,3 @@ fn is_item_interesting(item: &Item<'_>) -> bool {
         Impl { .. } | Static(..) | Const(..) | Fn(..) | Enum(..) | Struct(..) | Union(..) | Trait(..)
     )
 }
-
-fn should_lint_ty(hir_ty: &hir::Ty<'_>, ty: Ty<'_>, self_ty: Ty<'_>) -> bool {
-    if_chain! {
-        if same_type_and_consts(ty, self_ty);
-        if let TyKind::Path(QPath::Resolved(_, path)) = hir_ty.kind;
-        then {
-            !matches!(path.res, Res::SelfTy(..) | Res::Def(DefKind::TyParam, _))
-        } else {
-            false
-        }
-    }
-}
-- 
cgit 1.4.1-3-g733a5


From 018be41deedd086191b8ce45895164e0aa7046b0 Mon Sep 17 00:00:00 2001
From: Igor Aleksanov <popzxc@yandex.ru>
Date: Wed, 30 Jun 2021 19:06:33 +0300
Subject: Implement 'disallowed_script_idents' lint

---
 CHANGELOG.md                                       |   1 +
 clippy_lints/Cargo.toml                            |   1 +
 clippy_lints/src/disallowed_script_idents.rs       | 112 +++++++++++++++++++++
 clippy_lints/src/lib.rs                            |   6 +-
 clippy_lints/src/utils/conf.rs                     |   2 +
 .../toml_unknown_key/conf_unknown_key.stderr       |   2 +-
 tests/ui/disallowed_script_idents.rs               |  10 ++
 tests/ui/disallowed_script_idents.stderr           |  20 ++++
 8 files changed, 152 insertions(+), 2 deletions(-)
 create mode 100644 clippy_lints/src/disallowed_script_idents.rs
 create mode 100644 tests/ui/disallowed_script_idents.rs
 create mode 100644 tests/ui/disallowed_script_idents.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5f62a172035..f3a80703238 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2487,6 +2487,7 @@ Released 2018-09-13
 [`derive_hash_xor_eq`]: https://rust-lang.github.io/rust-clippy/master/index.html#derive_hash_xor_eq
 [`derive_ord_xor_partial_ord`]: https://rust-lang.github.io/rust-clippy/master/index.html#derive_ord_xor_partial_ord
 [`disallowed_method`]: https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_method
+[`disallowed_script_idents`]: https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_script_idents
 [`disallowed_type`]: https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_type
 [`diverging_sub_expression`]: https://rust-lang.github.io/rust-clippy/master/index.html#diverging_sub_expression
 [`doc_markdown`]: https://rust-lang.github.io/rust-clippy/master/index.html#doc_markdown
diff --git a/clippy_lints/Cargo.toml b/clippy_lints/Cargo.toml
index d3d12062f07..42cf7547f51 100644
--- a/clippy_lints/Cargo.toml
+++ b/clippy_lints/Cargo.toml
@@ -23,6 +23,7 @@ serde = { version = "1.0", features = ["derive"] }
 serde_json = { version = "1.0", optional = true }
 toml = "0.5.3"
 unicode-normalization = "0.1"
+unicode-script = { version = "0.5.3", default-features = false }
 semver = "0.11"
 rustc-semver = "1.1.0"
 # NOTE: cargo requires serde feat in its url dep
diff --git a/clippy_lints/src/disallowed_script_idents.rs b/clippy_lints/src/disallowed_script_idents.rs
new file mode 100644
index 00000000000..12c525634c5
--- /dev/null
+++ b/clippy_lints/src/disallowed_script_idents.rs
@@ -0,0 +1,112 @@
+use clippy_utils::diagnostics::span_lint;
+use rustc_ast::ast;
+use rustc_data_structures::fx::FxHashSet;
+use rustc_lint::{EarlyContext, EarlyLintPass, Level};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+use unicode_script::{Script, UnicodeScript};
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for usage of unicode scripts other than those explicitly allowed
+    /// by the lint config.
+    ///
+    /// This lint doesn't take into account non-text scripts such as `Unknown` and `Linear_A`.
+    /// It also ignores the `Common` script type.
+    /// While configuring, be sure to use official script name [aliases] from
+    /// [the list of supported scripts][supported_scripts].
+    ///
+    /// See also: [`non_ascii_idents`].
+    ///
+    /// [aliases]: http://www.unicode.org/reports/tr24/tr24-31.html#Script_Value_Aliases
+    /// [supported_scripts]: https://www.unicode.org/iso15924/iso15924-codes.html
+    ///
+    /// **Why is this bad?** It may be not desired to have many different scripts for
+    /// identifiers in the codebase.
+    ///
+    /// Note that if you only want to allow plain English, you might want to use
+    /// built-in [`non_ascii_idents`] lint instead.
+    ///
+    /// [`non_ascii_idents`]: https://doc.rust-lang.org/rustc/lints/listing/allowed-by-default.html#non-ascii-idents
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// ```rust
+    /// // Assuming that `clippy.toml` contains the following line:
+    /// // allowed-locales = ["Latin", "Cyrillic"]
+    /// let counter = 10; // OK, latin is allowed.
+    /// let счётчик = 10; // OK, cyrillic is allowed.
+    /// let zähler = 10; // OK, it's still latin.
+    /// let カウンタ = 10; // Will spawn the lint.
+    /// ```
+    pub DISALLOWED_SCRIPT_IDENTS,
+    restriction,
+    "usage of non-allowed Unicode scripts"
+}
+
+#[derive(Clone, Debug)]
+pub struct DisallowedScriptIdents {
+    whitelist: FxHashSet<Script>,
+}
+
+impl DisallowedScriptIdents {
+    pub fn new(whitelist: &[String]) -> Self {
+        let whitelist = whitelist
+            .iter()
+            .map(String::as_str)
+            .filter_map(Script::from_full_name)
+            .collect();
+        Self { whitelist }
+    }
+}
+
+impl_lint_pass!(DisallowedScriptIdents => [DISALLOWED_SCRIPT_IDENTS]);
+
+impl EarlyLintPass for DisallowedScriptIdents {
+    fn check_crate(&mut self, cx: &EarlyContext<'_>, _: &ast::Crate) {
+        // Implementation is heavily inspired by the implementation of [`non_ascii_idents`] lint:
+        // https://github.com/rust-lang/rust/blob/master/compiler/rustc_lint/src/non_ascii_idents.rs
+
+        let check_disallowed_script_idents = cx.builder.lint_level(DISALLOWED_SCRIPT_IDENTS).0 != Level::Allow;
+        if !check_disallowed_script_idents {
+            return;
+        }
+
+        let symbols = cx.sess.parse_sess.symbol_gallery.symbols.lock();
+        // Sort by `Span` so that error messages make sense with respect to the
+        // order of identifier locations in the code.
+        let mut symbols: Vec<_> = symbols.iter().collect();
+        symbols.sort_unstable_by_key(|k| k.1);
+
+        for (symbol, &span) in &symbols {
+            // Note: `symbol.as_str()` is an expensive operation, thus should not be called
+            // more than once for a single symbol.
+            let symbol_str = symbol.as_str();
+            if symbol_str.is_ascii() {
+                continue;
+            }
+
+            for c in symbol_str.chars() {
+                // We want to iterate through all the scripts associated with this character
+                // and check whether at least of one scripts is in the whitelist.
+                let forbidden_script = c
+                    .script_extension()
+                    .iter()
+                    .find(|script| !self.whitelist.contains(script));
+                if let Some(script) = forbidden_script {
+                    span_lint(
+                        cx,
+                        DISALLOWED_SCRIPT_IDENTS,
+                        span,
+                        &format!(
+                            "identifier `{}` has a Unicode script that is not allowed by configuration: {}",
+                            symbol_str,
+                            script.full_name()
+                        ),
+                    );
+                    // We don't want to spawn warning multiple times over a single identifier.
+                    break;
+                }
+            }
+        }
+    }
+}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 9cffeeb0224..0eb824dabf3 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -187,6 +187,7 @@ mod default_numeric_fallback;
 mod dereference;
 mod derive;
 mod disallowed_method;
+mod disallowed_script_idents;
 mod disallowed_type;
 mod doc;
 mod double_comparison;
@@ -585,6 +586,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         derive::EXPL_IMPL_CLONE_ON_COPY,
         derive::UNSAFE_DERIVE_DESERIALIZE,
         disallowed_method::DISALLOWED_METHOD,
+        disallowed_script_idents::DISALLOWED_SCRIPT_IDENTS,
         disallowed_type::DISALLOWED_TYPE,
         doc::DOC_MARKDOWN,
         doc::MISSING_ERRORS_DOC,
@@ -995,6 +997,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(create_dir::CREATE_DIR),
         LintId::of(dbg_macro::DBG_MACRO),
         LintId::of(default_numeric_fallback::DEFAULT_NUMERIC_FALLBACK),
+        LintId::of(disallowed_script_idents::DISALLOWED_SCRIPT_IDENTS),
         LintId::of(else_if_without_else::ELSE_IF_WITHOUT_ELSE),
         LintId::of(exhaustive_items::EXHAUSTIVE_ENUMS),
         LintId::of(exhaustive_items::EXHAUSTIVE_STRUCTS),
@@ -2082,7 +2085,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(move || box disallowed_type::DisallowedType::new(&disallowed_types));
     let import_renames = conf.enforced_import_renames.clone();
     store.register_late_pass(move || box missing_enforced_import_rename::ImportRename::new(import_renames.clone()));
-
+    let scripts = conf.allowed_scripts.clone();
+    store.register_early_pass(move || box disallowed_script_idents::DisallowedScriptIdents::new(&scripts));
 }
 
 #[rustfmt::skip]
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 6fc4998318c..44d3d456342 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -212,6 +212,8 @@ define_Conf! {
     (standard_macro_braces: Vec<crate::nonstandard_macro_braces::MacroMatcher> = Vec::new()),
     /// Lint: MISSING_ENFORCED_IMPORT_RENAMES. The list of imports to always rename, a fully qualified path followed by the rename.
     (enforced_import_renames: Vec<crate::utils::conf::Rename> = Vec::new()),
+    /// Lint: RESTRICTED_SCRIPTS. The list of unicode scripts allowed to be used in the scope.
+    (allowed_scripts: Vec<String> = vec!["Latin".to_string()]),
 }
 
 /// Search for the configuration file.
diff --git a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
index aa7bfa2cc8c..e0029ebeb27 100644
--- a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
+++ b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
@@ -1,4 +1,4 @@
-error: error reading Clippy's configuration file `$DIR/clippy.toml`: unknown field `foobar`, expected one of `avoid-breaking-exported-api`, `msrv`, `blacklisted-names`, `cognitive-complexity-threshold`, `cyclomatic-complexity-threshold`, `doc-valid-idents`, `too-many-arguments-threshold`, `type-complexity-threshold`, `single-char-binding-names-threshold`, `too-large-for-stack`, `enum-variant-name-threshold`, `enum-variant-size-threshold`, `verbose-bit-mask-threshold`, `literal-representation-threshold`, `trivial-copy-size-limit`, `pass-by-value-size-limit`, `too-many-lines-threshold`, `array-size-threshold`, `vec-box-size-threshold`, `max-trait-bounds`, `max-struct-bools`, `max-fn-params-bools`, `warn-on-all-wildcard-imports`, `disallowed-methods`, `disallowed-types`, `unreadable-literal-lint-fractions`, `upper-case-acronyms-aggressive`, `cargo-ignore-publish`, `standard-macro-braces`, `enforced-import-renames`, `third-party` at line 5 column 1
+error: error reading Clippy's configuration file `$DIR/clippy.toml`: unknown field `foobar`, expected one of `avoid-breaking-exported-api`, `msrv`, `blacklisted-names`, `cognitive-complexity-threshold`, `cyclomatic-complexity-threshold`, `doc-valid-idents`, `too-many-arguments-threshold`, `type-complexity-threshold`, `single-char-binding-names-threshold`, `too-large-for-stack`, `enum-variant-name-threshold`, `enum-variant-size-threshold`, `verbose-bit-mask-threshold`, `literal-representation-threshold`, `trivial-copy-size-limit`, `pass-by-value-size-limit`, `too-many-lines-threshold`, `array-size-threshold`, `vec-box-size-threshold`, `max-trait-bounds`, `max-struct-bools`, `max-fn-params-bools`, `warn-on-all-wildcard-imports`, `disallowed-methods`, `disallowed-types`, `unreadable-literal-lint-fractions`, `upper-case-acronyms-aggressive`, `cargo-ignore-publish`, `standard-macro-braces`, `enforced-import-renames`, `allowed-scripts`, `third-party` at line 5 column 1
 
 error: aborting due to previous error
 
diff --git a/tests/ui/disallowed_script_idents.rs b/tests/ui/disallowed_script_idents.rs
new file mode 100644
index 00000000000..cfdda35971f
--- /dev/null
+++ b/tests/ui/disallowed_script_idents.rs
@@ -0,0 +1,10 @@
+#![deny(clippy::disallowed_script_idents)]
+#![allow(dead_code)]
+
+fn main() {
+    let counter = 10; // OK, latin is allowed.
+    let zähler = 10; // OK, it's still latin.
+
+    let счётчик = 10; // Cyrillic is not allowed by default.
+    let カウンタ = 10; // Same for japanese.
+}
diff --git a/tests/ui/disallowed_script_idents.stderr b/tests/ui/disallowed_script_idents.stderr
new file mode 100644
index 00000000000..cc84dc1d43c
--- /dev/null
+++ b/tests/ui/disallowed_script_idents.stderr
@@ -0,0 +1,20 @@
+error: identifier `счётчик` has a Unicode script that is not allowed by configuration: Cyrillic
+  --> $DIR/disallowed_script_idents.rs:8:9
+   |
+LL |     let счётчик = 10; // Cyrillic is not allowed by default.
+   |         ^^^^^^^
+   |
+note: the lint level is defined here
+  --> $DIR/disallowed_script_idents.rs:1:9
+   |
+LL | #![deny(clippy::disallowed_script_idents)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: identifier `カウンタ` has a Unicode script that is not allowed by configuration: Katakana
+  --> $DIR/disallowed_script_idents.rs:9:9
+   |
+LL |     let カウンタ = 10; // Same for japanese.
+   |         ^^^^^^^^
+
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From fae7a09eea5644567ff7239abc3970d1e9a2d159 Mon Sep 17 00:00:00 2001
From: flip1995 <philipp.krones@embecosm.com>
Date: Thu, 1 Jul 2021 12:35:16 +0200
Subject: match_wildcard_for_single_variants: don't produce bad suggestion

This fixes a bug where match_wildcard_for_single_variants produced a
bad suggestion where besides the missing variant, one or more hidden
variants were left.

This also adds tests to the ui-tests match_wildcard_for_single_variants
and wildcard_enum_match_arm to make sure that the correct suggestion is
produced.
---
 clippy_lints/src/matches.rs                       |  5 +++--
 tests/ui/match_wildcard_for_single_variants.fixed |  7 +++++++
 tests/ui/match_wildcard_for_single_variants.rs    |  7 +++++++
 tests/ui/wildcard_enum_match_arm.fixed            | 14 ++++++++++++++
 tests/ui/wildcard_enum_match_arm.rs               | 14 ++++++++++++++
 tests/ui/wildcard_enum_match_arm.stderr           |  8 +++++++-
 6 files changed, 52 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index da5ac96e3db..4c90b95a42b 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -1033,6 +1033,7 @@ fn check_wild_enum_match(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>])
 
     // Accumulate the variants which should be put in place of the wildcard because they're not
     // already covered.
+    let has_hidden = adt_def.variants.iter().any(|x| is_hidden(cx, x));
     let mut missing_variants: Vec<_> = adt_def.variants.iter().filter(|x| !is_hidden(cx, x)).collect();
 
     let mut path_prefix = CommonPrefixSearcher::None;
@@ -1118,7 +1119,7 @@ fn check_wild_enum_match(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>])
 
     match missing_variants.as_slice() {
         [] => (),
-        [x] if !adt_def.is_variant_list_non_exhaustive() => span_lint_and_sugg(
+        [x] if !adt_def.is_variant_list_non_exhaustive() && !has_hidden => span_lint_and_sugg(
             cx,
             MATCH_WILDCARD_FOR_SINGLE_VARIANTS,
             wildcard_span,
@@ -1129,7 +1130,7 @@ fn check_wild_enum_match(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>])
         ),
         variants => {
             let mut suggestions: Vec<_> = variants.iter().copied().map(format_suggestion).collect();
-            let message = if adt_def.is_variant_list_non_exhaustive() {
+            let message = if adt_def.is_variant_list_non_exhaustive() || has_hidden {
                 suggestions.push("_".into());
                 "wildcard matches known variants and will also match future added variants"
             } else {
diff --git a/tests/ui/match_wildcard_for_single_variants.fixed b/tests/ui/match_wildcard_for_single_variants.fixed
index 31b743f7a18..e675c183ea7 100644
--- a/tests/ui/match_wildcard_for_single_variants.fixed
+++ b/tests/ui/match_wildcard_for_single_variants.fixed
@@ -115,9 +115,16 @@ fn main() {
         pub enum Enum {
             A,
             B,
+            C,
             #[doc(hidden)]
             __Private,
         }
+        match Enum::A {
+            Enum::A => (),
+            Enum::B => (),
+            Enum::C => (),
+            _ => (),
+        }
         match Enum::A {
             Enum::A => (),
             Enum::B => (),
diff --git a/tests/ui/match_wildcard_for_single_variants.rs b/tests/ui/match_wildcard_for_single_variants.rs
index d19e6ab7eb2..38c3ffc00c7 100644
--- a/tests/ui/match_wildcard_for_single_variants.rs
+++ b/tests/ui/match_wildcard_for_single_variants.rs
@@ -115,9 +115,16 @@ fn main() {
         pub enum Enum {
             A,
             B,
+            C,
             #[doc(hidden)]
             __Private,
         }
+        match Enum::A {
+            Enum::A => (),
+            Enum::B => (),
+            Enum::C => (),
+            _ => (),
+        }
         match Enum::A {
             Enum::A => (),
             Enum::B => (),
diff --git a/tests/ui/wildcard_enum_match_arm.fixed b/tests/ui/wildcard_enum_match_arm.fixed
index 64aba68635a..3ee4ab48ac8 100644
--- a/tests/ui/wildcard_enum_match_arm.fixed
+++ b/tests/ui/wildcard_enum_match_arm.fixed
@@ -87,4 +87,18 @@ fn main() {
         ErrorKind::PermissionDenied => {},
         _ => {},
     }
+
+    {
+        #![allow(clippy::manual_non_exhaustive)]
+        pub enum Enum {
+            A,
+            B,
+            #[doc(hidden)]
+            __Private,
+        }
+        match Enum::A {
+            Enum::A => (),
+            Enum::B | _ => (),
+        }
+    }
 }
diff --git a/tests/ui/wildcard_enum_match_arm.rs b/tests/ui/wildcard_enum_match_arm.rs
index 5cafdf59bf5..46886550453 100644
--- a/tests/ui/wildcard_enum_match_arm.rs
+++ b/tests/ui/wildcard_enum_match_arm.rs
@@ -87,4 +87,18 @@ fn main() {
         ErrorKind::PermissionDenied => {},
         _ => {},
     }
+
+    {
+        #![allow(clippy::manual_non_exhaustive)]
+        pub enum Enum {
+            A,
+            B,
+            #[doc(hidden)]
+            __Private,
+        }
+        match Enum::A {
+            Enum::A => (),
+            _ => (),
+        }
+    }
 }
diff --git a/tests/ui/wildcard_enum_match_arm.stderr b/tests/ui/wildcard_enum_match_arm.stderr
index 807947582b0..d63f2090353 100644
--- a/tests/ui/wildcard_enum_match_arm.stderr
+++ b/tests/ui/wildcard_enum_match_arm.stderr
@@ -34,5 +34,11 @@ error: wildcard matches known variants and will also match future added variants
 LL |         _ => {},
    |         ^ help: try this: `ErrorKind::PermissionDenied | _`
 
-error: aborting due to 5 previous errors
+error: wildcard matches known variants and will also match future added variants
+  --> $DIR/wildcard_enum_match_arm.rs:101:13
+   |
+LL |             _ => (),
+   |             ^ help: try this: `Enum::B | _`
+
+error: aborting due to 6 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From b9cc2feaaa0111385db4ea0b1ff846202d6ab9b4 Mon Sep 17 00:00:00 2001
From: lyj <sjtu5140809011@gmail.com>
Date: Fri, 2 Jul 2021 22:10:13 +0800
Subject: rc_mutex: known problems

---
 clippy_lints/src/types/mod.rs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types/mod.rs b/clippy_lints/src/types/mod.rs
index 5850a10d80f..c26268a875c 100644
--- a/clippy_lints/src/types/mod.rs
+++ b/clippy_lints/src/types/mod.rs
@@ -257,7 +257,9 @@ declare_clippy_lint! {
     /// **Why is this bad?** `Rc` is used in single thread and `Mutex` is used in multi thread.
     /// Consider using `Rc<RefCell<T>>` in single thread or `Arc<Mutex<T>>` in multi thread.
     ///
-    /// **Known problems:** Maybe false positive on trait generic.
+    /// **Known problems:** Sometimes combining generic types can lead to the requirement that a
+    /// type use Rc in conjunction with Mutex. We must consider those cases false positives, but
+    /// alas they are quite hard to rule out. Luckily they are also rare.
     ///
     /// **Example:**
     /// ```rust,ignore
-- 
cgit 1.4.1-3-g733a5


From 0f662e5833ad61d54586cff1fe47e093a0bd9da1 Mon Sep 17 00:00:00 2001
From: David Tolnay <dtolnay@gmail.com>
Date: Fri, 2 Jul 2021 22:14:32 -0700
Subject: Downgrade nonstandard_macro_braces to nursery

---
 clippy_lints/src/lib.rs                                                | 3 +--
 clippy_lints/src/nonstandard_macro_braces.rs                           | 2 +-
 .../ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.rs  | 2 +-
 3 files changed, 3 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index e0325738466..71809df276c 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1375,7 +1375,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(non_expressive_names::JUST_UNDERSCORES_AND_DIGITS),
         LintId::of(non_expressive_names::MANY_SINGLE_CHAR_NAMES),
         LintId::of(non_octal_unix_permissions::NON_OCTAL_UNIX_PERMISSIONS),
-        LintId::of(nonstandard_macro_braces::NONSTANDARD_MACRO_BRACES),
         LintId::of(open_options::NONSENSICAL_OPEN_OPTIONS),
         LintId::of(option_env_unwrap::OPTION_ENV_UNWRAP),
         LintId::of(overflow_check_conditional::OVERFLOW_CHECK_CONDITIONAL),
@@ -1546,7 +1545,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(non_copy_const::DECLARE_INTERIOR_MUTABLE_CONST),
         LintId::of(non_expressive_names::JUST_UNDERSCORES_AND_DIGITS),
         LintId::of(non_expressive_names::MANY_SINGLE_CHAR_NAMES),
-        LintId::of(nonstandard_macro_braces::NONSTANDARD_MACRO_BRACES),
         LintId::of(ptr::CMP_NULL),
         LintId::of(ptr::PTR_ARG),
         LintId::of(ptr_eq::PTR_EQ),
@@ -1791,6 +1789,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(missing_const_for_fn::MISSING_CONST_FOR_FN),
         LintId::of(mutable_debug_assertion::DEBUG_ASSERT_WITH_MUT_CALL),
         LintId::of(mutex_atomic::MUTEX_INTEGER),
+        LintId::of(nonstandard_macro_braces::NONSTANDARD_MACRO_BRACES),
         LintId::of(path_buf_push_overwrite::PATH_BUF_PUSH_OVERWRITE),
         LintId::of(redundant_pub_crate::REDUNDANT_PUB_CRATE),
         LintId::of(regex::TRIVIAL_REGEX),
diff --git a/clippy_lints/src/nonstandard_macro_braces.rs b/clippy_lints/src/nonstandard_macro_braces.rs
index 1adad5be6dd..c62b5e6d007 100644
--- a/clippy_lints/src/nonstandard_macro_braces.rs
+++ b/clippy_lints/src/nonstandard_macro_braces.rs
@@ -31,7 +31,7 @@ declare_clippy_lint! {
     /// vec![1, 2, 3];
     /// ```
     pub NONSTANDARD_MACRO_BRACES,
-    style,
+    nursery,
     "check consistent use of braces in macro"
 }
 
diff --git a/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.rs b/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.rs
index 4ae6864cbb0..770c65aa602 100644
--- a/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.rs
+++ b/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.rs
@@ -1,4 +1,4 @@
-// #![warn(clippy::nonstandard_macro_braces)]
+#![warn(clippy::nonstandard_macro_braces)]
 
 extern crate quote;
 
-- 
cgit 1.4.1-3-g733a5


From e9a5694597a3dc480827abf6fb5b8c9e48801471 Mon Sep 17 00:00:00 2001
From: Elliot Bobrow <elliotgreybobrow@gmail.com>
Date: Sat, 3 Jul 2021 09:34:10 -0700
Subject: fix doc_markdown false positive

---
 clippy_lints/src/doc.rs          | 2 +-
 tests/ui/doc/unbalanced_ticks.rs | 7 +++++++
 2 files changed, 8 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/doc.rs b/clippy_lints/src/doc.rs
index 4e164d33a05..17d868f1ec8 100644
--- a/clippy_lints/src/doc.rs
+++ b/clippy_lints/src/doc.rs
@@ -549,7 +549,7 @@ fn check_doc<'a, Events: Iterator<Item = (pulldown_cmark::Event<'a>, Range<usize
             FootnoteReference(text) | Text(text) => {
                 let (begin, span) = get_current_span(spans, range.start);
                 paragraph_span = paragraph_span.with_hi(span.hi());
-                ticks_unbalanced |= text.contains('`');
+                ticks_unbalanced |= text.contains('`') && !in_code;
                 if Some(&text) == in_link.as_ref() || ticks_unbalanced {
                     // Probably a link of the form `<http://example.com>`
                     // Which are represented as a link to "http://example.com" with
diff --git a/tests/ui/doc/unbalanced_ticks.rs b/tests/ui/doc/unbalanced_ticks.rs
index 78e87bc6906..8e8324b30f0 100644
--- a/tests/ui/doc/unbalanced_ticks.rs
+++ b/tests/ui/doc/unbalanced_ticks.rs
@@ -34,3 +34,10 @@ fn in_code_block() {}
 /// - This `item has unbalanced tick marks
 /// - This item needs backticks_here
 fn other_markdown() {}
+
+#[rustfmt::skip]
+/// - ```rust
+///   /// `lol`
+///   pub struct Struct;
+///   ```
+fn iss_7421() {}
-- 
cgit 1.4.1-3-g733a5


From cb4670deb37dac43dc36ad22d97479921a971f71 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Sat, 3 Jul 2021 12:40:50 -0500
Subject: Fix use_self ICE

---
 clippy_lints/src/use_self.rs | 17 +++--------------
 tests/ui/crashes/ice-7423.rs | 13 +++++++++++++
 2 files changed, 16 insertions(+), 14 deletions(-)
 create mode 100644 tests/ui/crashes/ice-7423.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/use_self.rs b/clippy_lints/src/use_self.rs
index 906ac10f461..71117e967e3 100644
--- a/clippy_lints/src/use_self.rs
+++ b/clippy_lints/src/use_self.rs
@@ -87,11 +87,8 @@ const SEGMENTS_MSG: &str = "segments should be composed of at least 1 element";
 
 impl<'tcx> LateLintPass<'tcx> for UseSelf {
     fn check_item(&mut self, _cx: &LateContext<'_>, item: &Item<'_>) {
-        if !is_item_interesting(item) {
-            // This does two things:
-            //  1) Reduce needless churn on `self.stack`
-            //  2) Don't push `StackItem::NoCheck` when entering `ItemKind::OpaqueTy`,
-            //     in order to lint `foo() -> impl <..>`
+        if matches!(item.kind, ItemKind::OpaqueTy(_)) {
+            // skip over `ItemKind::OpaqueTy` in order to lint `foo() -> impl <..>`
             return;
         }
         // We push the self types of `impl`s on a stack here. Only the top type on the stack is
@@ -119,7 +116,7 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
     }
 
     fn check_item_post(&mut self, _: &LateContext<'_>, item: &Item<'_>) {
-        if is_item_interesting(item) {
+        if !matches!(item.kind, ItemKind::OpaqueTy(_)) {
             self.stack.pop();
         }
     }
@@ -297,11 +294,3 @@ fn lint_path_to_variant(cx: &LateContext<'_>, path: &Path<'_>) {
         span_lint(cx, span);
     }
 }
-
-fn is_item_interesting(item: &Item<'_>) -> bool {
-    use rustc_hir::ItemKind::{Const, Enum, Fn, Impl, Static, Struct, Trait, Union};
-    matches!(
-        item.kind,
-        Impl { .. } | Static(..) | Const(..) | Fn(..) | Enum(..) | Struct(..) | Union(..) | Trait(..)
-    )
-}
diff --git a/tests/ui/crashes/ice-7423.rs b/tests/ui/crashes/ice-7423.rs
new file mode 100644
index 00000000000..31340b012dd
--- /dev/null
+++ b/tests/ui/crashes/ice-7423.rs
@@ -0,0 +1,13 @@
+pub trait Trait {
+    fn f();
+}
+
+impl Trait for usize {
+    fn f() {
+        extern "C" {
+            fn g() -> usize;
+        }
+    }
+}
+
+fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 1d110f8c2e2221f1ea6a8c51d1d79cc8a3b65115 Mon Sep 17 00:00:00 2001
From: Devin Ragotzy <devin.ragotzy@gmail.com>
Date: Sun, 4 Jul 2021 07:06:23 -0400
Subject: Fix emitting in nested (proc_)macros for nonstandard_macro_braces
 lint

---
 clippy_lints/src/nonstandard_macro_braces.rs       | 12 ++++++----
 .../auxiliary/proc_macro_derive.rs                 | 18 ++++++++++++++
 .../conf_nonstandard_macro_braces.rs               |  8 +++++++
 .../conf_nonstandard_macro_braces.stderr           | 28 +++++++++++-----------
 4 files changed, 48 insertions(+), 18 deletions(-)
 create mode 100644 tests/ui-toml/nonstandard_macro_braces/auxiliary/proc_macro_derive.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/nonstandard_macro_braces.rs b/clippy_lints/src/nonstandard_macro_braces.rs
index c62b5e6d007..043e7fa30d6 100644
--- a/clippy_lints/src/nonstandard_macro_braces.rs
+++ b/clippy_lints/src/nonstandard_macro_braces.rs
@@ -92,14 +92,18 @@ impl EarlyLintPass for MacroBraces {
     }
 }
 
-fn is_offending_macro<'a>(cx: &EarlyContext<'_>, span: Span, this: &'a MacroBraces) -> Option<MacroInfo<'a>> {
+fn is_offending_macro<'a>(cx: &EarlyContext<'_>, span: Span, mac_braces: &'a MacroBraces) -> Option<MacroInfo<'a>> {
     if_chain! {
         if in_macro(span);
-        if let Some((name, braces)) = find_matching_macro(span, &this.macro_braces);
+        if let Some((name, braces)) = find_matching_macro(span, &mac_braces.macro_braces);
         if let Some(snip) = snippet_opt(cx, span.ctxt().outer_expn_data().call_site);
-        let c = snip.replace(" ", ""); // make formatting consistent
+        // we must check only invocation sites
+        // https://github.com/rust-lang/rust-clippy/issues/7422
+        if snip.starts_with(name);
+        // make formatting consistent
+        let c = snip.replace(" ", "");
         if !c.starts_with(&format!("{}!{}", name, braces.0));
-        if !this.done.contains(&span.ctxt().outer_expn_data().call_site);
+        if !mac_braces.done.contains(&span.ctxt().outer_expn_data().call_site);
         then {
             Some((name, braces, snip))
         } else {
diff --git a/tests/ui-toml/nonstandard_macro_braces/auxiliary/proc_macro_derive.rs b/tests/ui-toml/nonstandard_macro_braces/auxiliary/proc_macro_derive.rs
new file mode 100644
index 00000000000..6452189a461
--- /dev/null
+++ b/tests/ui-toml/nonstandard_macro_braces/auxiliary/proc_macro_derive.rs
@@ -0,0 +1,18 @@
+// compile-flags: --emit=link
+// no-prefer-dynamic
+
+#![crate_type = "proc-macro"]
+
+extern crate proc_macro;
+
+use proc_macro::TokenStream;
+
+#[proc_macro_derive(DeriveSomething)]
+pub fn derive(_: TokenStream) -> TokenStream {
+    "fn _f() -> Vec<u8> { vec![] }".parse().unwrap()
+}
+
+#[proc_macro]
+pub fn foo_bar(_: TokenStream) -> TokenStream {
+    "fn issue_7422() { eprintln!(); }".parse().unwrap()
+}
diff --git a/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.rs b/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.rs
index 770c65aa602..e9f042ddefc 100644
--- a/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.rs
+++ b/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.rs
@@ -1,9 +1,17 @@
+// aux-build:proc_macro_derive.rs
+
 #![warn(clippy::nonstandard_macro_braces)]
 
+extern crate proc_macro_derive;
 extern crate quote;
 
 use quote::quote;
 
+#[derive(proc_macro_derive::DeriveSomething)]
+pub struct S;
+
+proc_macro_derive::foo_bar!();
+
 #[rustfmt::skip]
 macro_rules! test {
     () => {
diff --git a/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.stderr b/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.stderr
index 7bcd1829524..86063a08280 100644
--- a/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.stderr
+++ b/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.stderr
@@ -1,54 +1,54 @@
 error: use of irregular braces for `vec!` macro
-  --> $DIR/conf_nonstandard_macro_braces.rs:29:13
+  --> $DIR/conf_nonstandard_macro_braces.rs:37:13
    |
 LL |     let _ = vec! {1, 2, 3};
    |             ^^^^^^^^^^^^^^
    |
    = note: `-D clippy::nonstandard-macro-braces` implied by `-D warnings`
 help: consider writing `vec![1, 2, 3]`
-  --> $DIR/conf_nonstandard_macro_braces.rs:29:13
+  --> $DIR/conf_nonstandard_macro_braces.rs:37:13
    |
 LL |     let _ = vec! {1, 2, 3};
    |             ^^^^^^^^^^^^^^
 
 error: use of irregular braces for `format!` macro
-  --> $DIR/conf_nonstandard_macro_braces.rs:30:13
+  --> $DIR/conf_nonstandard_macro_braces.rs:38:13
    |
 LL |     let _ = format!["ugh {} stop being such a good compiler", "hello"];
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: consider writing `format!("ugh () stop being such a good compiler", "hello")`
-  --> $DIR/conf_nonstandard_macro_braces.rs:30:13
+  --> $DIR/conf_nonstandard_macro_braces.rs:38:13
    |
 LL |     let _ = format!["ugh {} stop being such a good compiler", "hello"];
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: use of irregular braces for `quote!` macro
-  --> $DIR/conf_nonstandard_macro_braces.rs:31:13
+  --> $DIR/conf_nonstandard_macro_braces.rs:39:13
    |
 LL |     let _ = quote!(let x = 1;);
    |             ^^^^^^^^^^^^^^^^^^
    |
 help: consider writing `quote! {let x = 1;}`
-  --> $DIR/conf_nonstandard_macro_braces.rs:31:13
+  --> $DIR/conf_nonstandard_macro_braces.rs:39:13
    |
 LL |     let _ = quote!(let x = 1;);
    |             ^^^^^^^^^^^^^^^^^^
 
 error: use of irregular braces for `quote::quote!` macro
-  --> $DIR/conf_nonstandard_macro_braces.rs:32:13
+  --> $DIR/conf_nonstandard_macro_braces.rs:40:13
    |
 LL |     let _ = quote::quote!(match match match);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: consider writing `quote::quote! {match match match}`
-  --> $DIR/conf_nonstandard_macro_braces.rs:32:13
+  --> $DIR/conf_nonstandard_macro_braces.rs:40:13
    |
 LL |     let _ = quote::quote!(match match match);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: use of irregular braces for `vec!` macro
-  --> $DIR/conf_nonstandard_macro_braces.rs:10:9
+  --> $DIR/conf_nonstandard_macro_braces.rs:18:9
    |
 LL |         vec!{0, 0, 0}
    |         ^^^^^^^^^^^^^
@@ -57,7 +57,7 @@ LL |     let _ = test!();
    |             ------- in this macro invocation
    |
 help: consider writing `vec![0, 0, 0]`
-  --> $DIR/conf_nonstandard_macro_braces.rs:10:9
+  --> $DIR/conf_nonstandard_macro_braces.rs:18:9
    |
 LL |         vec!{0, 0, 0}
    |         ^^^^^^^^^^^^^
@@ -67,25 +67,25 @@ LL |     let _ = test!();
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: use of irregular braces for `type_pos!` macro
-  --> $DIR/conf_nonstandard_macro_braces.rs:41:12
+  --> $DIR/conf_nonstandard_macro_braces.rs:49:12
    |
 LL |     let _: type_pos!(usize) = vec![];
    |            ^^^^^^^^^^^^^^^^
    |
 help: consider writing `type_pos![usize]`
-  --> $DIR/conf_nonstandard_macro_braces.rs:41:12
+  --> $DIR/conf_nonstandard_macro_braces.rs:49:12
    |
 LL |     let _: type_pos!(usize) = vec![];
    |            ^^^^^^^^^^^^^^^^
 
 error: use of irregular braces for `eprint!` macro
-  --> $DIR/conf_nonstandard_macro_braces.rs:43:5
+  --> $DIR/conf_nonstandard_macro_braces.rs:51:5
    |
 LL |     eprint!("test if user config overrides defaults");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: consider writing `eprint!["test if user config overrides defaults"];`
-  --> $DIR/conf_nonstandard_macro_braces.rs:43:5
+  --> $DIR/conf_nonstandard_macro_braces.rs:51:5
    |
 LL |     eprint!("test if user config overrides defaults");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From 59a164e86c41b4ccfa1e41ec60d7bb8a0f2c87d2 Mon Sep 17 00:00:00 2001
From: Mateusz Gacek <96mateusz.gacek@gmail.com>
Date: Tue, 18 May 2021 15:19:56 +0200
Subject: Add new lint: strlen_on_c_strings

---
 CHANGELOG.md                            |  1 +
 clippy_lints/src/lib.rs                 |  5 ++
 clippy_lints/src/strlen_on_c_strings.rs | 82 +++++++++++++++++++++++++++++++++
 clippy_utils/src/paths.rs               |  1 +
 clippy_utils/src/ty.rs                  | 11 +++++
 tests/ui/strlen_on_c_strings.rs         | 16 +++++++
 tests/ui/strlen_on_c_strings.stderr     | 25 ++++++++++
 7 files changed, 141 insertions(+)
 create mode 100644 clippy_lints/src/strlen_on_c_strings.rs
 create mode 100644 tests/ui/strlen_on_c_strings.rs
 create mode 100644 tests/ui/strlen_on_c_strings.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 1dc43f77f83..ad3722d4d0b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2798,6 +2798,7 @@ Released 2018-09-13
 [`string_from_utf8_as_bytes`]: https://rust-lang.github.io/rust-clippy/master/index.html#string_from_utf8_as_bytes
 [`string_lit_as_bytes`]: https://rust-lang.github.io/rust-clippy/master/index.html#string_lit_as_bytes
 [`string_to_string`]: https://rust-lang.github.io/rust-clippy/master/index.html#string_to_string
+[`strlen_on_c_strings`]: https://rust-lang.github.io/rust-clippy/master/index.html#strlen_on_c_strings
 [`struct_excessive_bools`]: https://rust-lang.github.io/rust-clippy/master/index.html#struct_excessive_bools
 [`suboptimal_flops`]: https://rust-lang.github.io/rust-clippy/master/index.html#suboptimal_flops
 [`suspicious_arithmetic_impl`]: https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_arithmetic_impl
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 0a468ccf25a..82519a9b5b7 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -338,6 +338,7 @@ mod size_of_in_element_count;
 mod slow_vector_initialization;
 mod stable_sort_primitive;
 mod strings;
+mod strlen_on_c_strings;
 mod suspicious_operation_groupings;
 mod suspicious_trait_impl;
 mod swap;
@@ -914,6 +915,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         strings::STRING_LIT_AS_BYTES,
         strings::STRING_TO_STRING,
         strings::STR_TO_STRING,
+        strlen_on_c_strings::STRLEN_ON_C_STRINGS,
         suspicious_operation_groupings::SUSPICIOUS_OPERATION_GROUPINGS,
         suspicious_trait_impl::SUSPICIOUS_ARITHMETIC_IMPL,
         suspicious_trait_impl::SUSPICIOUS_OP_ASSIGN_IMPL,
@@ -1410,6 +1412,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(slow_vector_initialization::SLOW_VECTOR_INITIALIZATION),
         LintId::of(stable_sort_primitive::STABLE_SORT_PRIMITIVE),
         LintId::of(strings::STRING_FROM_UTF8_AS_BYTES),
+        LintId::of(strlen_on_c_strings::STRLEN_ON_C_STRINGS),
         LintId::of(suspicious_trait_impl::SUSPICIOUS_ARITHMETIC_IMPL),
         LintId::of(suspicious_trait_impl::SUSPICIOUS_OP_ASSIGN_IMPL),
         LintId::of(swap::ALMOST_SWAPPED),
@@ -1639,6 +1642,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(reference::REF_IN_DEREF),
         LintId::of(repeat_once::REPEAT_ONCE),
         LintId::of(strings::STRING_FROM_UTF8_AS_BYTES),
+        LintId::of(strlen_on_c_strings::STRLEN_ON_C_STRINGS),
         LintId::of(swap::MANUAL_SWAP),
         LintId::of(temporary_assignment::TEMPORARY_ASSIGNMENT),
         LintId::of(transmute::CROSSPOINTER_TRANSMUTE),
@@ -2096,6 +2100,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(move || box missing_enforced_import_rename::ImportRename::new(import_renames.clone()));
     let scripts = conf.allowed_scripts.clone();
     store.register_early_pass(move || box disallowed_script_idents::DisallowedScriptIdents::new(&scripts));
+    store.register_late_pass(|| box strlen_on_c_strings::StrlenOnCStrings);
 }
 
 #[rustfmt::skip]
diff --git a/clippy_lints/src/strlen_on_c_strings.rs b/clippy_lints/src/strlen_on_c_strings.rs
new file mode 100644
index 00000000000..2ccf3a3796d
--- /dev/null
+++ b/clippy_lints/src/strlen_on_c_strings.rs
@@ -0,0 +1,82 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::in_macro;
+use clippy_utils::paths;
+use clippy_utils::source::snippet_with_macro_callsite;
+use clippy_utils::ty::{is_type_diagnostic_item, is_type_ref_to_diagnostic_item};
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir as hir;
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::symbol::{sym, Symbol};
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for usage of `libc::strlen` on a `CString` or `CStr` value,
+    /// and suggest calling `as_bytes().len()` or `to_bytes().len()` respectively instead.
+    ///
+    /// **Why is this bad?** This avoids calling an unsafe `libc` function.
+    /// Currently, it also avoids calculating the length.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust, ignore
+    /// use std::ffi::CString;
+    /// let cstring = CString::new("foo").expect("CString::new failed");
+    /// let len = unsafe { libc::strlen(cstring.as_ptr()) };
+    /// ```
+    /// Use instead:
+    /// ```rust, no_run
+    /// use std::ffi::CString;
+    /// let cstring = CString::new("foo").expect("CString::new failed");
+    /// let len = cstring.as_bytes().len();
+    /// ```
+    pub STRLEN_ON_C_STRINGS,
+    complexity,
+    "using `libc::strlen` on a `CString` or `CStr` value, while `as_bytes().len()` or `to_bytes().len()` respectively can be used instead"
+}
+
+declare_lint_pass!(StrlenOnCStrings => [STRLEN_ON_C_STRINGS]);
+
+impl LateLintPass<'tcx> for StrlenOnCStrings {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
+        if in_macro(expr.span) {
+            return;
+        }
+
+        if_chain! {
+            if let hir::ExprKind::Call(func, [recv]) = expr.kind;
+            if let hir::ExprKind::Path(hir::QPath::Resolved(_, path)) = func.kind;
+
+            if (&paths::LIBC_STRLEN).iter().map(|x| Symbol::intern(x)).eq(
+                path.segments.iter().map(|seg| seg.ident.name));
+            if let hir::ExprKind::MethodCall(path, _, args, _) = recv.kind;
+            if args.len() == 1;
+            if !args.iter().any(|e| e.span.from_expansion());
+            if path.ident.name == sym::as_ptr;
+            then {
+                let cstring = &args[0];
+                let ty = cx.typeck_results().expr_ty(cstring);
+                let val_name = snippet_with_macro_callsite(cx, cstring.span, "..");
+                let sugg = if is_type_diagnostic_item(cx, ty, sym::cstring_type){
+                    format!("{}.as_bytes().len()", val_name)
+                } else if is_type_ref_to_diagnostic_item(cx, ty, sym::CStr){
+                    format!("{}.to_bytes().len()", val_name)
+                } else {
+                    return;
+                };
+
+                span_lint_and_sugg(
+                    cx,
+                    STRLEN_ON_C_STRINGS,
+                    expr.span,
+                    "using `libc::strlen` on a `CString` or `CStr` value",
+                    "try this (you might also need to get rid of `unsafe` block in some cases):",
+                    sugg,
+                    Applicability::Unspecified // Sometimes unnecessary `unsafe` block
+                );
+            }
+        }
+    }
+}
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index b913d1ce8b1..9ebfbd6b423 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -82,6 +82,7 @@ pub const ITER_REPEAT: [&str; 5] = ["core", "iter", "sources", "repeat", "repeat
 pub const KW_MODULE: [&str; 3] = ["rustc_span", "symbol", "kw"];
 #[cfg(feature = "internal-lints")]
 pub const LATE_CONTEXT: [&str; 2] = ["rustc_lint", "LateContext"];
+pub const LIBC_STRLEN: [&str; 2] = ["libc", "strlen"];
 pub const LINKED_LIST: [&str; 4] = ["alloc", "collections", "linked_list", "LinkedList"];
 #[cfg(any(feature = "internal-lints", feature = "metadata-collector-lint"))]
 pub const LINT: [&str; 2] = ["rustc_lint_defs", "Lint"];
diff --git a/clippy_utils/src/ty.rs b/clippy_utils/src/ty.rs
index a92d3be5d3c..9e271b71204 100644
--- a/clippy_utils/src/ty.rs
+++ b/clippy_utils/src/ty.rs
@@ -231,6 +231,17 @@ pub fn is_recursively_primitive_type(ty: Ty<'_>) -> bool {
     }
 }
 
+/// Checks if the type is a reference equals to a diagnostic item
+pub fn is_type_ref_to_diagnostic_item(cx: &LateContext<'_>, ty: Ty<'_>, diag_item: Symbol) -> bool {
+    match ty.kind() {
+        ty::Ref(_, ref_ty, _) => match ref_ty.kind() {
+            ty::Adt(adt, _) => cx.tcx.is_diagnostic_item(diag_item, adt.did),
+            _ => false,
+        },
+        _ => false,
+    }
+}
+
 /// Checks if the type is equal to a diagnostic item
 ///
 /// If you change the signature, remember to update the internal lint `MatchTypeOnDiagItem`
diff --git a/tests/ui/strlen_on_c_strings.rs b/tests/ui/strlen_on_c_strings.rs
new file mode 100644
index 00000000000..21902fa8483
--- /dev/null
+++ b/tests/ui/strlen_on_c_strings.rs
@@ -0,0 +1,16 @@
+#![warn(clippy::strlen_on_c_strings)]
+#![allow(dead_code)]
+#![feature(rustc_private)]
+extern crate libc;
+
+use std::ffi::{CStr, CString};
+
+fn main() {
+    // CString
+    let cstring = CString::new("foo").expect("CString::new failed");
+    let len = unsafe { libc::strlen(cstring.as_ptr()) };
+
+    // CStr
+    let cstr = CStr::from_bytes_with_nul(b"foo\0").expect("CStr::from_bytes_with_nul failed");
+    let len = unsafe { libc::strlen(cstr.as_ptr()) };
+}
diff --git a/tests/ui/strlen_on_c_strings.stderr b/tests/ui/strlen_on_c_strings.stderr
new file mode 100644
index 00000000000..a212bd327c3
--- /dev/null
+++ b/tests/ui/strlen_on_c_strings.stderr
@@ -0,0 +1,25 @@
+error: using `libc::strlen` on a `CString` or `CStr` value
+  --> $DIR/strlen_on_c_strings.rs:11:24
+   |
+LL |     let len = unsafe { libc::strlen(cstring.as_ptr()) };
+   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::strlen-on-c-strings` implied by `-D warnings`
+help: try this (you might also need to get rid of `unsafe` block in some cases):
+   |
+LL |     let len = unsafe { cstring.as_bytes().len() };
+   |                        ^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: using `libc::strlen` on a `CString` or `CStr` value
+  --> $DIR/strlen_on_c_strings.rs:15:24
+   |
+LL |     let len = unsafe { libc::strlen(cstr.as_ptr()) };
+   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: try this (you might also need to get rid of `unsafe` block in some cases):
+   |
+LL |     let len = unsafe { cstr.to_bytes().len() };
+   |                        ^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 357a8f03445e9719039cb846ffb080303eba21f8 Mon Sep 17 00:00:00 2001
From: Anthony Huang <anthony.huang@affirm.com>
Date: Fri, 25 Jun 2021 16:34:45 -0400
Subject: Add redundant_method_names lint

---
 CHANGELOG.md                                       |  1 +
 clippy_lints/src/lib.rs                            |  6 ++
 clippy_lints/src/self_named_constructor.rs         | 91 ++++++++++++++++++++++
 tests/ui/crashes/ice-6179.rs                       |  2 +-
 tests/ui/issue_4266.rs                             |  4 +-
 tests/ui/missing-doc-impl.rs                       |  4 +-
 tests/ui/missing-doc-impl.stderr                   | 12 +--
 tests/ui/missing_const_for_fn/cant_be_const.rs     |  2 +-
 .../ui/missing_const_for_fn/could_be_const.stderr  |  2 +-
 tests/ui/needless_bool/fixable.fixed               |  3 +-
 tests/ui/needless_bool/fixable.rs                  |  3 +-
 tests/ui/needless_bool/fixable.stderr              | 24 +++---
 tests/ui/self_named_constructor.rs                 | 59 ++++++++++++++
 tests/ui/self_named_constructor.stderr             | 12 +++
 tests/ui/unit_arg.rs                               |  3 +-
 tests/ui/unit_arg.stderr                           | 20 ++---
 tests/ui/use_self.fixed                            |  7 +-
 tests/ui/use_self.rs                               |  7 +-
 tests/ui/use_self.stderr                           | 56 ++++++-------
 19 files changed, 253 insertions(+), 65 deletions(-)
 create mode 100644 clippy_lints/src/self_named_constructor.rs
 create mode 100644 tests/ui/self_named_constructor.rs
 create mode 100644 tests/ui/self_named_constructor.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index ad3722d4d0b..1cc49774ec3 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2772,6 +2772,7 @@ Released 2018-09-13
 [`same_item_push`]: https://rust-lang.github.io/rust-clippy/master/index.html#same_item_push
 [`search_is_some`]: https://rust-lang.github.io/rust-clippy/master/index.html#search_is_some
 [`self_assignment`]: https://rust-lang.github.io/rust-clippy/master/index.html#self_assignment
+[`self_named_constructor`]: https://rust-lang.github.io/rust-clippy/master/index.html#self_named_constructor
 [`semicolon_if_nothing_returned`]: https://rust-lang.github.io/rust-clippy/master/index.html#semicolon_if_nothing_returned
 [`serde_api_misuse`]: https://rust-lang.github.io/rust-clippy/master/index.html#serde_api_misuse
 [`shadow_reuse`]: https://rust-lang.github.io/rust-clippy/master/index.html#shadow_reuse
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 82519a9b5b7..7889a571ead 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -330,6 +330,7 @@ mod regex;
 mod repeat_once;
 mod returns;
 mod self_assignment;
+mod self_named_constructor;
 mod semicolon_if_nothing_returned;
 mod serde_api;
 mod shadow;
@@ -900,6 +901,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         returns::LET_AND_RETURN,
         returns::NEEDLESS_RETURN,
         self_assignment::SELF_ASSIGNMENT,
+        self_named_constructor::SELF_NAMED_CONSTRUCTOR,
         semicolon_if_nothing_returned::SEMICOLON_IF_NOTHING_RETURNED,
         serde_api::SERDE_API_MISUSE,
         shadow::SHADOW_REUSE,
@@ -1406,6 +1408,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(returns::LET_AND_RETURN),
         LintId::of(returns::NEEDLESS_RETURN),
         LintId::of(self_assignment::SELF_ASSIGNMENT),
+        LintId::of(self_named_constructor::SELF_NAMED_CONSTRUCTOR),
         LintId::of(serde_api::SERDE_API_MISUSE),
         LintId::of(single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS),
         LintId::of(size_of_in_element_count::SIZE_OF_IN_ELEMENT_COUNT),
@@ -1559,6 +1562,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(redundant_static_lifetimes::REDUNDANT_STATIC_LIFETIMES),
         LintId::of(returns::LET_AND_RETURN),
         LintId::of(returns::NEEDLESS_RETURN),
+        LintId::of(self_named_constructor::SELF_NAMED_CONSTRUCTOR),
         LintId::of(single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS),
         LintId::of(tabs_in_doc_comments::TABS_IN_DOC_COMMENTS),
         LintId::of(to_digit_is_some::TO_DIGIT_IS_SOME),
@@ -2101,6 +2105,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     let scripts = conf.allowed_scripts.clone();
     store.register_early_pass(move || box disallowed_script_idents::DisallowedScriptIdents::new(&scripts));
     store.register_late_pass(|| box strlen_on_c_strings::StrlenOnCStrings);
+    store.register_late_pass(move || box self_named_constructor::SelfNamedConstructor);
+
 }
 
 #[rustfmt::skip]
diff --git a/clippy_lints/src/self_named_constructor.rs b/clippy_lints/src/self_named_constructor.rs
new file mode 100644
index 00000000000..da991e1d90c
--- /dev/null
+++ b/clippy_lints/src/self_named_constructor.rs
@@ -0,0 +1,91 @@
+use clippy_utils::diagnostics::span_lint;
+use clippy_utils::return_ty;
+use clippy_utils::ty::{contains_adt_constructor, contains_ty};
+use rustc_hir::{Impl, ImplItem, ImplItemKind, ItemKind, Node};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// **What it does:** Warns when constructors have the same name as their types.
+    ///
+    /// **Why is this bad?** Repeating the name of the type is redundant.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust,ignore
+    /// struct Foo {}
+    ///
+    /// impl Foo {
+    ///     pub fn foo() -> Foo {
+    ///         Foo {}
+    ///     }
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust,ignore
+    /// struct Foo {}
+    ///
+    /// impl Foo {
+    ///     pub fn new() -> Foo {
+    ///         Foo {}
+    ///     }
+    /// }
+    /// ```
+    pub SELF_NAMED_CONSTRUCTOR,
+    style,
+    "method should not have the same name as the type it is implemented for"
+}
+
+declare_lint_pass!(SelfNamedConstructor => [SELF_NAMED_CONSTRUCTOR]);
+
+impl<'tcx> LateLintPass<'tcx> for SelfNamedConstructor {
+    fn check_impl_item(&mut self, cx: &LateContext<'tcx>, impl_item: &'tcx ImplItem<'_>) {
+        match impl_item.kind {
+            ImplItemKind::Fn(ref sig, _) => {
+                if sig.decl.implicit_self.has_implicit_self() {
+                    return;
+                }
+            },
+            _ => return,
+        }
+
+        let parent = cx.tcx.hir().get_parent_item(impl_item.hir_id());
+        let item = cx.tcx.hir().expect_item(parent);
+        let self_ty = cx.tcx.type_of(item.def_id);
+        let ret_ty = return_ty(cx, impl_item.hir_id());
+
+        // Do not check trait impls
+        if matches!(item.kind, ItemKind::Impl(Impl { of_trait: Some(_), .. })) {
+            return;
+        }
+
+        // Ensure method is constructor-like
+        if let Some(self_adt) = self_ty.ty_adt_def() {
+            if !contains_adt_constructor(ret_ty, self_adt) {
+                return;
+            }
+        } else if !contains_ty(ret_ty, self_ty) {
+            return;
+        }
+
+        if_chain! {
+            if let Some(self_def) = self_ty.ty_adt_def();
+            if let Some(self_local_did) = self_def.did.as_local();
+            let self_id = cx.tcx.hir().local_def_id_to_hir_id(self_local_did);
+            if let Some(Node::Item(x)) = cx.tcx.hir().find(self_id);
+            let type_name = x.ident.name.as_str().to_lowercase();
+            if impl_item.ident.name.as_str() == type_name || impl_item.ident.name.as_str().replace("_", "") == type_name;
+
+            then {
+                span_lint(
+                    cx,
+                    SELF_NAMED_CONSTRUCTOR,
+                    impl_item.span,
+                    &format!("constructor `{}` has the same name as the type", impl_item.ident.name),
+                );
+            }
+        }
+    }
+}
diff --git a/tests/ui/crashes/ice-6179.rs b/tests/ui/crashes/ice-6179.rs
index f8c866a49aa..8d9a1af8ff1 100644
--- a/tests/ui/crashes/ice-6179.rs
+++ b/tests/ui/crashes/ice-6179.rs
@@ -7,7 +7,7 @@
 struct Foo {}
 
 impl Foo {
-    fn foo() -> Self {
+    fn new() -> Self {
         impl Foo {
             fn bar() {}
         }
diff --git a/tests/ui/issue_4266.rs b/tests/ui/issue_4266.rs
index 8a9d5a3d1d5..cc699b79e43 100644
--- a/tests/ui/issue_4266.rs
+++ b/tests/ui/issue_4266.rs
@@ -25,7 +25,9 @@ async fn all_to_one<'a>(a: &'a str, _b: &'a str) -> &'a str {
 struct Foo;
 impl Foo {
     // ok
-    pub async fn foo(&mut self) {}
+    pub async fn new(&mut self) -> Self {
+        Foo {}
+    }
 }
 
 // rust-lang/rust#61115
diff --git a/tests/ui/missing-doc-impl.rs b/tests/ui/missing-doc-impl.rs
index bfa9ef01b0e..d5724bf661c 100644
--- a/tests/ui/missing-doc-impl.rs
+++ b/tests/ui/missing-doc-impl.rs
@@ -59,7 +59,9 @@ pub trait E: Sized {
 }
 
 impl Foo {
-    pub fn foo() {}
+    pub fn new() -> Self {
+        Foo { a: 0, b: 0 }
+    }
     fn bar() {}
 }
 
diff --git a/tests/ui/missing-doc-impl.stderr b/tests/ui/missing-doc-impl.stderr
index d33d512475b..bda63d66a17 100644
--- a/tests/ui/missing-doc-impl.stderr
+++ b/tests/ui/missing-doc-impl.stderr
@@ -78,23 +78,25 @@ LL |     type AssociatedTypeDef = Self;
 error: missing documentation for an associated function
   --> $DIR/missing-doc-impl.rs:62:5
    |
-LL |     pub fn foo() {}
-   |     ^^^^^^^^^^^^^^^
+LL | /     pub fn new() -> Self {
+LL | |         Foo { a: 0, b: 0 }
+LL | |     }
+   | |_____^
 
 error: missing documentation for an associated function
-  --> $DIR/missing-doc-impl.rs:63:5
+  --> $DIR/missing-doc-impl.rs:65:5
    |
 LL |     fn bar() {}
    |     ^^^^^^^^^^^
 
 error: missing documentation for an associated function
-  --> $DIR/missing-doc-impl.rs:67:5
+  --> $DIR/missing-doc-impl.rs:69:5
    |
 LL |     pub fn foo() {}
    |     ^^^^^^^^^^^^^^^
 
 error: missing documentation for an associated function
-  --> $DIR/missing-doc-impl.rs:71:5
+  --> $DIR/missing-doc-impl.rs:73:5
    |
 LL | /     fn foo2() -> u32 {
 LL | |         1
diff --git a/tests/ui/missing_const_for_fn/cant_be_const.rs b/tests/ui/missing_const_for_fn/cant_be_const.rs
index 7cda1aaa3c2..6d2cbb6ad96 100644
--- a/tests/ui/missing_const_for_fn/cant_be_const.rs
+++ b/tests/ui/missing_const_for_fn/cant_be_const.rs
@@ -84,7 +84,7 @@ mod with_drop {
 
     impl A {
         // This can not be const because the type implements `Drop`.
-        pub fn a(self) -> B {
+        pub fn b(self) -> B {
             B
         }
     }
diff --git a/tests/ui/missing_const_for_fn/could_be_const.stderr b/tests/ui/missing_const_for_fn/could_be_const.stderr
index 63c211f39fa..18eff0d1466 100644
--- a/tests/ui/missing_const_for_fn/could_be_const.stderr
+++ b/tests/ui/missing_const_for_fn/could_be_const.stderr
@@ -60,7 +60,7 @@ LL | | }
 error: this could be a `const fn`
   --> $DIR/could_be_const.rs:68:9
    |
-LL | /         pub fn b(self, a: &A) -> B {
+LL | /         pub fn new(a: &A) -> B {
 LL | |             B
 LL | |         }
    | |_________^
diff --git a/tests/ui/needless_bool/fixable.fixed b/tests/ui/needless_bool/fixable.fixed
index 567dbc54100..5917ffc3e12 100644
--- a/tests/ui/needless_bool/fixable.fixed
+++ b/tests/ui/needless_bool/fixable.fixed
@@ -6,7 +6,8 @@
     dead_code,
     clippy::no_effect,
     clippy::if_same_then_else,
-    clippy::needless_return
+    clippy::needless_return,
+    clippy::self_named_constructor
 )]
 
 use std::cell::Cell;
diff --git a/tests/ui/needless_bool/fixable.rs b/tests/ui/needless_bool/fixable.rs
index 10126ad4dbb..d26dcb9fcc3 100644
--- a/tests/ui/needless_bool/fixable.rs
+++ b/tests/ui/needless_bool/fixable.rs
@@ -6,7 +6,8 @@
     dead_code,
     clippy::no_effect,
     clippy::if_same_then_else,
-    clippy::needless_return
+    clippy::needless_return,
+    clippy::self_named_constructor
 )]
 
 use std::cell::Cell;
diff --git a/tests/ui/needless_bool/fixable.stderr b/tests/ui/needless_bool/fixable.stderr
index 25abfb2a472..8026d643c44 100644
--- a/tests/ui/needless_bool/fixable.stderr
+++ b/tests/ui/needless_bool/fixable.stderr
@@ -1,5 +1,5 @@
 error: this if-then-else expression returns a bool literal
-  --> $DIR/fixable.rs:39:5
+  --> $DIR/fixable.rs:40:5
    |
 LL | /     if x {
 LL | |         true
@@ -11,7 +11,7 @@ LL | |     };
    = note: `-D clippy::needless-bool` implied by `-D warnings`
 
 error: this if-then-else expression returns a bool literal
-  --> $DIR/fixable.rs:44:5
+  --> $DIR/fixable.rs:45:5
    |
 LL | /     if x {
 LL | |         false
@@ -21,7 +21,7 @@ LL | |     };
    | |_____^ help: you can reduce it to: `!x`
 
 error: this if-then-else expression returns a bool literal
-  --> $DIR/fixable.rs:49:5
+  --> $DIR/fixable.rs:50:5
    |
 LL | /     if x && y {
 LL | |         false
@@ -31,7 +31,7 @@ LL | |     };
    | |_____^ help: you can reduce it to: `!(x && y)`
 
 error: this if-then-else expression returns a bool literal
-  --> $DIR/fixable.rs:69:5
+  --> $DIR/fixable.rs:70:5
    |
 LL | /     if x {
 LL | |         return true;
@@ -41,7 +41,7 @@ LL | |     };
    | |_____^ help: you can reduce it to: `return x`
 
 error: this if-then-else expression returns a bool literal
-  --> $DIR/fixable.rs:77:5
+  --> $DIR/fixable.rs:78:5
    |
 LL | /     if x {
 LL | |         return false;
@@ -51,7 +51,7 @@ LL | |     };
    | |_____^ help: you can reduce it to: `return !x`
 
 error: this if-then-else expression returns a bool literal
-  --> $DIR/fixable.rs:85:5
+  --> $DIR/fixable.rs:86:5
    |
 LL | /     if x && y {
 LL | |         return true;
@@ -61,7 +61,7 @@ LL | |     };
    | |_____^ help: you can reduce it to: `return x && y`
 
 error: this if-then-else expression returns a bool literal
-  --> $DIR/fixable.rs:93:5
+  --> $DIR/fixable.rs:94:5
    |
 LL | /     if x && y {
 LL | |         return false;
@@ -71,7 +71,7 @@ LL | |     };
    | |_____^ help: you can reduce it to: `return !(x && y)`
 
 error: equality checks against true are unnecessary
-  --> $DIR/fixable.rs:101:8
+  --> $DIR/fixable.rs:102:8
    |
 LL |     if x == true {};
    |        ^^^^^^^^^ help: try simplifying it as shown: `x`
@@ -79,25 +79,25 @@ LL |     if x == true {};
    = note: `-D clippy::bool-comparison` implied by `-D warnings`
 
 error: equality checks against false can be replaced by a negation
-  --> $DIR/fixable.rs:105:8
+  --> $DIR/fixable.rs:106:8
    |
 LL |     if x == false {};
    |        ^^^^^^^^^^ help: try simplifying it as shown: `!x`
 
 error: equality checks against true are unnecessary
-  --> $DIR/fixable.rs:115:8
+  --> $DIR/fixable.rs:116:8
    |
 LL |     if x == true {};
    |        ^^^^^^^^^ help: try simplifying it as shown: `x`
 
 error: equality checks against false can be replaced by a negation
-  --> $DIR/fixable.rs:116:8
+  --> $DIR/fixable.rs:117:8
    |
 LL |     if x == false {};
    |        ^^^^^^^^^^ help: try simplifying it as shown: `!x`
 
 error: this if-then-else expression returns a bool literal
-  --> $DIR/fixable.rs:125:12
+  --> $DIR/fixable.rs:126:12
    |
 LL |       } else if returns_bool() {
    |  ____________^
diff --git a/tests/ui/self_named_constructor.rs b/tests/ui/self_named_constructor.rs
new file mode 100644
index 00000000000..7658b86a8d6
--- /dev/null
+++ b/tests/ui/self_named_constructor.rs
@@ -0,0 +1,59 @@
+#![warn(clippy::self_named_constructor)]
+
+struct ShouldSpawn;
+struct ShouldNotSpawn;
+
+impl ShouldSpawn {
+    pub fn should_spawn() -> ShouldSpawn {
+        ShouldSpawn
+    }
+
+    fn should_not_spawn() -> ShouldNotSpawn {
+        ShouldNotSpawn
+    }
+}
+
+impl ShouldNotSpawn {
+    pub fn new() -> ShouldNotSpawn {
+        ShouldNotSpawn
+    }
+}
+
+struct ShouldNotSpawnWithTrait;
+
+trait ShouldNotSpawnTrait {
+    type Item;
+}
+
+impl ShouldNotSpawnTrait for ShouldNotSpawnWithTrait {
+    type Item = Self;
+}
+
+impl ShouldNotSpawnWithTrait {
+    pub fn should_not_spawn_with_trait() -> impl ShouldNotSpawnTrait<Item = Self> {
+        ShouldNotSpawnWithTrait
+    }
+}
+
+// Same trait name and same type name should not spawn the lint
+#[derive(Default)]
+pub struct Default;
+
+trait TraitSameTypeName {
+    fn should_not_spawn() -> Self;
+}
+impl TraitSameTypeName for ShouldNotSpawn {
+    fn should_not_spawn() -> Self {
+        ShouldNotSpawn
+    }
+}
+
+struct SelfMethodShouldNotSpawn;
+
+impl SelfMethodShouldNotSpawn {
+    fn self_method_should_not_spawn(self) -> Self {
+        SelfMethodShouldNotSpawn
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/self_named_constructor.stderr b/tests/ui/self_named_constructor.stderr
new file mode 100644
index 00000000000..1e2c34ac2f7
--- /dev/null
+++ b/tests/ui/self_named_constructor.stderr
@@ -0,0 +1,12 @@
+error: constructor `should_spawn` has the same name as the type
+  --> $DIR/self_named_constructor.rs:7:5
+   |
+LL | /     pub fn should_spawn() -> ShouldSpawn {
+LL | |         ShouldSpawn
+LL | |     }
+   | |_____^
+   |
+   = note: `-D clippy::self-named-constructor` implied by `-D warnings`
+
+error: aborting due to previous error
+
diff --git a/tests/ui/unit_arg.rs b/tests/ui/unit_arg.rs
index 938cc3c7859..df0fdaccb34 100644
--- a/tests/ui/unit_arg.rs
+++ b/tests/ui/unit_arg.rs
@@ -6,7 +6,8 @@
     clippy::unused_unit,
     clippy::unnecessary_wraps,
     clippy::or_fun_call,
-    clippy::needless_question_mark
+    clippy::needless_question_mark,
+    clippy::self_named_constructor
 )]
 
 use std::fmt::Debug;
diff --git a/tests/ui/unit_arg.stderr b/tests/ui/unit_arg.stderr
index 354fd51cd6b..8155c4ae110 100644
--- a/tests/ui/unit_arg.stderr
+++ b/tests/ui/unit_arg.stderr
@@ -1,5 +1,5 @@
 error: passing a unit value to a function
-  --> $DIR/unit_arg.rs:55:5
+  --> $DIR/unit_arg.rs:56:5
    |
 LL | /     foo({
 LL | |         1;
@@ -20,7 +20,7 @@ LL |     foo(());
    |
 
 error: passing a unit value to a function
-  --> $DIR/unit_arg.rs:58:5
+  --> $DIR/unit_arg.rs:59:5
    |
 LL |     foo(foo(1));
    |     ^^^^^^^^^^^
@@ -32,7 +32,7 @@ LL |     foo(());
    |
 
 error: passing a unit value to a function
-  --> $DIR/unit_arg.rs:59:5
+  --> $DIR/unit_arg.rs:60:5
    |
 LL | /     foo({
 LL | |         foo(1);
@@ -54,7 +54,7 @@ LL |     foo(());
    |
 
 error: passing a unit value to a function
-  --> $DIR/unit_arg.rs:64:5
+  --> $DIR/unit_arg.rs:65:5
    |
 LL | /     b.bar({
 LL | |         1;
@@ -74,7 +74,7 @@ LL |     b.bar(());
    |
 
 error: passing unit values to a function
-  --> $DIR/unit_arg.rs:67:5
+  --> $DIR/unit_arg.rs:68:5
    |
 LL |     taking_multiple_units(foo(0), foo(1));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -87,7 +87,7 @@ LL |     taking_multiple_units((), ());
    |
 
 error: passing unit values to a function
-  --> $DIR/unit_arg.rs:68:5
+  --> $DIR/unit_arg.rs:69:5
    |
 LL | /     taking_multiple_units(foo(0), {
 LL | |         foo(1);
@@ -110,7 +110,7 @@ LL |     taking_multiple_units((), ());
    |
 
 error: passing unit values to a function
-  --> $DIR/unit_arg.rs:72:5
+  --> $DIR/unit_arg.rs:73:5
    |
 LL | /     taking_multiple_units(
 LL | |         {
@@ -140,7 +140,7 @@ LL |         foo(2);
  ...
 
 error: passing a unit value to a function
-  --> $DIR/unit_arg.rs:83:13
+  --> $DIR/unit_arg.rs:84:13
    |
 LL |     None.or(Some(foo(2)));
    |             ^^^^^^^^^^^^
@@ -154,7 +154,7 @@ LL |     });
    |
 
 error: passing a unit value to a function
-  --> $DIR/unit_arg.rs:86:5
+  --> $DIR/unit_arg.rs:87:5
    |
 LL |     foo(foo(()));
    |     ^^^^^^^^^^^^
@@ -166,7 +166,7 @@ LL |     foo(());
    |
 
 error: passing a unit value to a function
-  --> $DIR/unit_arg.rs:123:5
+  --> $DIR/unit_arg.rs:124:5
    |
 LL |     Some(foo(1))
    |     ^^^^^^^^^^^^
diff --git a/tests/ui/use_self.fixed b/tests/ui/use_self.fixed
index e2c28542efc..23fc7632511 100644
--- a/tests/ui/use_self.fixed
+++ b/tests/ui/use_self.fixed
@@ -4,7 +4,12 @@
 
 #![warn(clippy::use_self)]
 #![allow(dead_code)]
-#![allow(clippy::should_implement_trait, clippy::upper_case_acronyms, clippy::from_over_into)]
+#![allow(
+    clippy::should_implement_trait,
+    clippy::upper_case_acronyms,
+    clippy::from_over_into,
+    clippy::self_named_constructor
+)]
 
 #[macro_use]
 extern crate proc_macro_derive;
diff --git a/tests/ui/use_self.rs b/tests/ui/use_self.rs
index 3cd99b9f5cd..bb46a339923 100644
--- a/tests/ui/use_self.rs
+++ b/tests/ui/use_self.rs
@@ -4,7 +4,12 @@
 
 #![warn(clippy::use_self)]
 #![allow(dead_code)]
-#![allow(clippy::should_implement_trait, clippy::upper_case_acronyms, clippy::from_over_into)]
+#![allow(
+    clippy::should_implement_trait,
+    clippy::upper_case_acronyms,
+    clippy::from_over_into,
+    clippy::self_named_constructor
+)]
 
 #[macro_use]
 extern crate proc_macro_derive;
diff --git a/tests/ui/use_self.stderr b/tests/ui/use_self.stderr
index 6ac26c9e5a9..e14368a11aa 100644
--- a/tests/ui/use_self.stderr
+++ b/tests/ui/use_self.stderr
@@ -1,5 +1,5 @@
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:18:21
+  --> $DIR/use_self.rs:23:21
    |
 LL |         fn new() -> Foo {
    |                     ^^^ help: use the applicable keyword: `Self`
@@ -7,163 +7,163 @@ LL |         fn new() -> Foo {
    = note: `-D clippy::use-self` implied by `-D warnings`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:19:13
+  --> $DIR/use_self.rs:24:13
    |
 LL |             Foo {}
    |             ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:21:22
+  --> $DIR/use_self.rs:26:22
    |
 LL |         fn test() -> Foo {
    |                      ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:22:13
+  --> $DIR/use_self.rs:27:13
    |
 LL |             Foo::new()
    |             ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:27:25
+  --> $DIR/use_self.rs:32:25
    |
 LL |         fn default() -> Foo {
    |                         ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:28:13
+  --> $DIR/use_self.rs:33:13
    |
 LL |             Foo::new()
    |             ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:93:24
+  --> $DIR/use_self.rs:98:24
    |
 LL |         fn bad(foos: &[Foo]) -> impl Iterator<Item = &Foo> {
    |                        ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:93:55
+  --> $DIR/use_self.rs:98:55
    |
 LL |         fn bad(foos: &[Foo]) -> impl Iterator<Item = &Foo> {
    |                                                       ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:108:13
+  --> $DIR/use_self.rs:113:13
    |
 LL |             TS(0)
    |             ^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:143:29
+  --> $DIR/use_self.rs:148:29
    |
 LL |                 fn bar() -> Bar {
    |                             ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:144:21
+  --> $DIR/use_self.rs:149:21
    |
 LL |                     Bar { foo: Foo {} }
    |                     ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:155:21
+  --> $DIR/use_self.rs:160:21
    |
 LL |         fn baz() -> Foo {
    |                     ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:156:13
+  --> $DIR/use_self.rs:161:13
    |
 LL |             Foo {}
    |             ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:173:21
+  --> $DIR/use_self.rs:178:21
    |
 LL |             let _ = Enum::B(42);
    |                     ^^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:174:21
+  --> $DIR/use_self.rs:179:21
    |
 LL |             let _ = Enum::C { field: true };
    |                     ^^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:175:21
+  --> $DIR/use_self.rs:180:21
    |
 LL |             let _ = Enum::A;
    |                     ^^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:217:13
+  --> $DIR/use_self.rs:222:13
    |
 LL |             nested::A::fun_1();
    |             ^^^^^^^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:218:13
+  --> $DIR/use_self.rs:223:13
    |
 LL |             nested::A::A;
    |             ^^^^^^^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:220:13
+  --> $DIR/use_self.rs:225:13
    |
 LL |             nested::A {};
    |             ^^^^^^^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:239:13
+  --> $DIR/use_self.rs:244:13
    |
 LL |             TestStruct::from_something()
    |             ^^^^^^^^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:253:25
+  --> $DIR/use_self.rs:258:25
    |
 LL |         async fn g() -> S {
    |                         ^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:254:13
+  --> $DIR/use_self.rs:259:13
    |
 LL |             S {}
    |             ^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:258:16
+  --> $DIR/use_self.rs:263:16
    |
 LL |             &p[S::A..S::B]
    |                ^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:258:22
+  --> $DIR/use_self.rs:263:22
    |
 LL |             &p[S::A..S::B]
    |                      ^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:281:29
+  --> $DIR/use_self.rs:286:29
    |
 LL |         fn foo(value: T) -> Foo<T> {
    |                             ^^^^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:282:13
+  --> $DIR/use_self.rs:287:13
    |
 LL |             Foo::<T> { value }
    |             ^^^^^^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:454:13
+  --> $DIR/use_self.rs:459:13
    |
 LL |             A::new::<submod::B>(submod::B {})
    |             ^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> $DIR/use_self.rs:491:13
+  --> $DIR/use_self.rs:496:13
    |
 LL |             S2::new()
    |             ^^ help: use the applicable keyword: `Self`
-- 
cgit 1.4.1-3-g733a5


From eeefbb7617c85cb1b51a4758f3d4743f01966578 Mon Sep 17 00:00:00 2001
From: iobtl <tedmundhtl@gmail.com>
Date: Tue, 6 Jul 2021 15:14:53 +0800
Subject: fix false positive (panic message) with assert macro using message
 parameter

---
 clippy_lints/src/panic_unimplemented.rs |  4 +++-
 tests/ui/panicking_macros.rs            | 16 ++++++++++++++++
 2 files changed, 19 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/panic_unimplemented.rs b/clippy_lints/src/panic_unimplemented.rs
index 1a680e7607e..dc28874c16e 100644
--- a/clippy_lints/src/panic_unimplemented.rs
+++ b/clippy_lints/src/panic_unimplemented.rs
@@ -74,7 +74,9 @@ declare_lint_pass!(PanicUnimplemented => [UNIMPLEMENTED, UNREACHABLE, TODO, PANI
 
 impl<'tcx> LateLintPass<'tcx> for PanicUnimplemented {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if match_panic_call(cx, expr).is_some() && is_expn_of(expr.span, "debug_assert").is_none() {
+        if match_panic_call(cx, expr).is_some()
+            && (is_expn_of(expr.span, "debug_assert").is_none() && is_expn_of(expr.span, "assert").is_none())
+        {
             let span = get_outer_span(expr);
             if is_expn_of(expr.span, "unimplemented").is_some() {
                 span_lint(
diff --git a/tests/ui/panicking_macros.rs b/tests/ui/panicking_macros.rs
index 93b236f7473..73380646462 100644
--- a/tests/ui/panicking_macros.rs
+++ b/tests/ui/panicking_macros.rs
@@ -43,6 +43,18 @@ fn core_versions() {
     unreachable!();
 }
 
+fn assert() {
+    assert!(true);
+    assert_eq!(true, true);
+    assert_ne!(true, false);
+}
+
+fn assert_msg() {
+    assert!(true, "this should not panic");
+    assert_eq!(true, true, "this should not panic");
+    assert_ne!(true, false, "this should not panic");
+}
+
 fn debug_assert() {
     debug_assert!(true);
     debug_assert_eq!(true, true);
@@ -61,4 +73,8 @@ fn main() {
     unimplemented();
     unreachable();
     core_versions();
+    assert();
+    assert_msg();
+    debug_assert();
+    debug_assert_msg();
 }
-- 
cgit 1.4.1-3-g733a5


From 3bc5abef6219f15929ffb6ff8ddedd998f013c63 Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Thu, 8 Jul 2021 11:37:12 +0900
Subject: default_numeric_fallback: Fix FP with floating literal

---
 clippy_lints/src/default_numeric_fallback.rs |  6 ++---
 tests/ui/default_numeric_fallback.rs         | 37 ++++++++++++++++++++++++++--
 tests/ui/default_numeric_fallback.stderr     | 32 ++++++++++++++++++------
 3 files changed, 63 insertions(+), 12 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/default_numeric_fallback.rs b/clippy_lints/src/default_numeric_fallback.rs
index a125376bffa..ea28644b9a4 100644
--- a/clippy_lints/src/default_numeric_fallback.rs
+++ b/clippy_lints/src/default_numeric_fallback.rs
@@ -78,7 +78,7 @@ impl<'a, 'tcx> NumericFallbackVisitor<'a, 'tcx> {
                 if let Some(ty_bound) = self.ty_bounds.last();
                 if matches!(lit.node,
                             LitKind::Int(_, LitIntType::Unsuffixed) | LitKind::Float(_, LitFloatType::Unsuffixed));
-                if !ty_bound.is_integral();
+                if !ty_bound.is_numeric();
                 then {
                     let suffix = match lit_ty.kind() {
                         ty::Int(IntTy::I32) => "i32",
@@ -219,10 +219,10 @@ enum TyBound<'tcx> {
 }
 
 impl<'tcx> TyBound<'tcx> {
-    fn is_integral(self) -> bool {
+    fn is_numeric(self) -> bool {
         match self {
             TyBound::Any => true,
-            TyBound::Ty(t) => t.is_integral(),
+            TyBound::Ty(t) => t.is_numeric(),
             TyBound::Nothing => false,
         }
     }
diff --git a/tests/ui/default_numeric_fallback.rs b/tests/ui/default_numeric_fallback.rs
index c0625fd1b75..58a7f377374 100644
--- a/tests/ui/default_numeric_fallback.rs
+++ b/tests/ui/default_numeric_fallback.rs
@@ -81,17 +81,25 @@ mod function_def {
 }
 
 mod function_calls {
-    fn concrete_arg(x: i32) {}
+    fn concrete_arg_i32(x: i32) {}
+
+    fn concrete_arg_f64(f: f64) {}
 
     fn generic_arg<T>(t: T) {}
 
     fn test() {
         // Should NOT lint this because the argument type is bound to a concrete type.
-        concrete_arg(1);
+        concrete_arg_i32(1);
+
+        // Should NOT lint this because the argument type is bound to a concrete type.
+        concrete_arg_f64(1.);
 
         // Should lint this because the argument type is inferred to `i32` and NOT bound to a concrete type.
         generic_arg(1);
 
+        // Should lint this because the argument type is inferred to `f32` and NOT bound to a concrete type.
+        generic_arg(1.0);
+
         // Should lint this because the argument type is inferred to `i32` and NOT bound to a concrete type.
         let x: _ = generic_arg(1);
     }
@@ -118,6 +126,31 @@ mod struct_ctor {
     }
 }
 
+mod enum_ctor {
+    enum ConcreteEnum {
+        X(i32),
+        Y(f64),
+    }
+
+    enum GenericEnum<T> {
+        X(T),
+    }
+
+    fn test() {
+        // Should NOT lint this because the field type is bound to a concrete type.
+        ConcreteEnum::X(1);
+
+        // Should NOT lint this because the field type is bound to a concrete type.
+        ConcreteEnum::Y(1.);
+
+        // Should lint this because the field type is inferred to `i32` and NOT bound to a concrete type.
+        GenericEnum::X(1);
+
+        // Should lint this because the field type is inferred to `f64` and NOT bound to a concrete type.
+        GenericEnum::X(1.);
+    }
+}
+
 mod method_calls {
     struct StructForMethodCallTest {}
 
diff --git a/tests/ui/default_numeric_fallback.stderr b/tests/ui/default_numeric_fallback.stderr
index 5862cd936ac..3965385189e 100644
--- a/tests/ui/default_numeric_fallback.stderr
+++ b/tests/ui/default_numeric_fallback.stderr
@@ -115,37 +115,55 @@ LL |         let f = || -> i32 { 1 };
    |                             ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:93:21
+  --> $DIR/default_numeric_fallback.rs:98:21
    |
 LL |         generic_arg(1);
    |                     ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:96:32
+  --> $DIR/default_numeric_fallback.rs:101:21
+   |
+LL |         generic_arg(1.0);
+   |                     ^^^ help: consider adding suffix: `1.0_f64`
+
+error: default numeric fallback might occur
+  --> $DIR/default_numeric_fallback.rs:104:32
    |
 LL |         let x: _ = generic_arg(1);
    |                                ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:114:28
+  --> $DIR/default_numeric_fallback.rs:122:28
    |
 LL |         GenericStruct { x: 1 };
    |                            ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:117:36
+  --> $DIR/default_numeric_fallback.rs:125:36
    |
 LL |         let _ = GenericStruct { x: 1 };
    |                                    ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:137:23
+  --> $DIR/default_numeric_fallback.rs:147:24
+   |
+LL |         GenericEnum::X(1);
+   |                        ^ help: consider adding suffix: `1_i32`
+
+error: default numeric fallback might occur
+  --> $DIR/default_numeric_fallback.rs:150:24
+   |
+LL |         GenericEnum::X(1.);
+   |                        ^^ help: consider adding suffix: `1._f64`
+
+error: default numeric fallback might occur
+  --> $DIR/default_numeric_fallback.rs:170:23
    |
 LL |         s.generic_arg(1);
    |                       ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback.rs:144:21
+  --> $DIR/default_numeric_fallback.rs:177:21
    |
 LL |             let x = 22;
    |                     ^^ help: consider adding suffix: `22_i32`
@@ -155,5 +173,5 @@ LL |         internal_macro!();
    |
    = note: this error originates in the macro `internal_macro` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to 25 previous errors
+error: aborting due to 28 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 795868dd88dfd0ba88813f6683287af1aaf1b801 Mon Sep 17 00:00:00 2001
From: flip1995 <philipp.krones@embecosm.com>
Date: Thu, 8 Jul 2021 15:45:19 +0200
Subject: Rename run_lints -> lints_enabled

---
 clippy_lints/src/cargo_common_metadata.rs   |  4 ++--
 clippy_lints/src/copies.rs                  |  6 +++---
 clippy_lints/src/multiple_crate_versions.rs |  4 ++--
 clippy_lints/src/utils/internal_lints.rs    | 14 +++++++-------
 clippy_lints/src/wildcard_dependencies.rs   |  4 ++--
 clippy_utils/src/lib.rs                     |  6 +++---
 6 files changed, 19 insertions(+), 19 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/cargo_common_metadata.rs b/clippy_lints/src/cargo_common_metadata.rs
index 8097a1c8326..a84d1d5d9a0 100644
--- a/clippy_lints/src/cargo_common_metadata.rs
+++ b/clippy_lints/src/cargo_common_metadata.rs
@@ -3,7 +3,7 @@
 use std::path::PathBuf;
 
 use clippy_utils::diagnostics::span_lint;
-use clippy_utils::run_lints;
+use clippy_utils::lints_enabled;
 use rustc_hir::{hir_id::CRATE_HIR_ID, Crate};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
@@ -85,7 +85,7 @@ fn is_empty_vec(value: &[String]) -> bool {
 
 impl LateLintPass<'_> for CargoCommonMetadata {
     fn check_crate(&mut self, cx: &LateContext<'_>, _: &Crate<'_>) {
-        if !run_lints(cx, &[CARGO_COMMON_METADATA], CRATE_HIR_ID) {
+        if !lints_enabled(cx, &[CARGO_COMMON_METADATA], CRATE_HIR_ID) {
             return;
         }
 
diff --git a/clippy_lints/src/copies.rs b/clippy_lints/src/copies.rs
index 376a14b8181..91e0f2a55d5 100644
--- a/clippy_lints/src/copies.rs
+++ b/clippy_lints/src/copies.rs
@@ -2,7 +2,7 @@ use clippy_utils::diagnostics::{span_lint_and_note, span_lint_and_then};
 use clippy_utils::source::{first_line_of_span, indent_of, reindent_multiline, snippet, snippet_opt};
 use clippy_utils::{
     both, count_eq, eq_expr_value, get_enclosing_block, get_parent_expr, if_sequence, in_macro, is_else_clause,
-    run_lints, search_same, ContainsName, SpanlessEq, SpanlessHash,
+    lints_enabled, search_same, ContainsName, SpanlessEq, SpanlessHash,
 };
 use if_chain::if_chain;
 use rustc_data_structures::fx::FxHashSet;
@@ -337,8 +337,8 @@ fn scan_block_for_eq(cx: &LateContext<'tcx>, blocks: &[&Block<'tcx>]) -> Option<
             if block_expr_eq;
             if l_stmts.len() == r_stmts.len();
             if l_stmts.len() == current_start_eq;
-            if run_lints(cx, &[IF_SAME_THEN_ELSE], win[0].hir_id);
-            if run_lints(cx, &[IF_SAME_THEN_ELSE], win[1].hir_id);
+            if lints_enabled(cx, &[IF_SAME_THEN_ELSE], win[0].hir_id);
+            if lints_enabled(cx, &[IF_SAME_THEN_ELSE], win[1].hir_id);
             then {
                 span_lint_and_note(
                     cx,
diff --git a/clippy_lints/src/multiple_crate_versions.rs b/clippy_lints/src/multiple_crate_versions.rs
index 584daa5e119..1eba7c124cf 100644
--- a/clippy_lints/src/multiple_crate_versions.rs
+++ b/clippy_lints/src/multiple_crate_versions.rs
@@ -1,7 +1,7 @@
 //! lint on multiple versions of a crate being used
 
 use clippy_utils::diagnostics::span_lint;
-use clippy_utils::run_lints;
+use clippy_utils::lints_enabled;
 use rustc_hir::def_id::LOCAL_CRATE;
 use rustc_hir::{Crate, CRATE_HIR_ID};
 use rustc_lint::{LateContext, LateLintPass};
@@ -39,7 +39,7 @@ declare_lint_pass!(MultipleCrateVersions => [MULTIPLE_CRATE_VERSIONS]);
 
 impl LateLintPass<'_> for MultipleCrateVersions {
     fn check_crate(&mut self, cx: &LateContext<'_>, _: &Crate<'_>) {
-        if !run_lints(cx, &[MULTIPLE_CRATE_VERSIONS], CRATE_HIR_ID) {
+        if !lints_enabled(cx, &[MULTIPLE_CRATE_VERSIONS], CRATE_HIR_ID) {
             return;
         }
 
diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs
index b1523e032af..e8b14ee8e0b 100644
--- a/clippy_lints/src/utils/internal_lints.rs
+++ b/clippy_lints/src/utils/internal_lints.rs
@@ -3,7 +3,7 @@ use clippy_utils::diagnostics::{span_lint, span_lint_and_help, span_lint_and_sug
 use clippy_utils::source::snippet;
 use clippy_utils::ty::match_type;
 use clippy_utils::{
-    is_else_clause, is_expn_of, is_expr_path_def_path, match_def_path, method_calls, path_to_res, paths, run_lints,
+    is_else_clause, is_expn_of, is_expr_path_def_path, lints_enabled, match_def_path, method_calls, path_to_res, paths,
     SpanlessEq,
 };
 use if_chain::if_chain;
@@ -353,7 +353,7 @@ impl_lint_pass!(LintWithoutLintPass => [DEFAULT_LINT, LINT_WITHOUT_LINT_PASS]);
 
 impl<'tcx> LateLintPass<'tcx> for LintWithoutLintPass {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
-        if !run_lints(cx, &[DEFAULT_LINT], item.hir_id()) {
+        if !lints_enabled(cx, &[DEFAULT_LINT], item.hir_id()) {
             return;
         }
 
@@ -411,7 +411,7 @@ impl<'tcx> LateLintPass<'tcx> for LintWithoutLintPass {
     }
 
     fn check_crate_post(&mut self, cx: &LateContext<'tcx>, _: &'tcx Crate<'_>) {
-        if !run_lints(cx, &[LINT_WITHOUT_LINT_PASS], CRATE_HIR_ID) {
+        if !lints_enabled(cx, &[LINT_WITHOUT_LINT_PASS], CRATE_HIR_ID) {
             return;
         }
 
@@ -497,7 +497,7 @@ impl_lint_pass!(CompilerLintFunctions => [COMPILER_LINT_FUNCTIONS]);
 
 impl<'tcx> LateLintPass<'tcx> for CompilerLintFunctions {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if !run_lints(cx, &[COMPILER_LINT_FUNCTIONS], expr.hir_id) {
+        if !lints_enabled(cx, &[COMPILER_LINT_FUNCTIONS], expr.hir_id) {
             return;
         }
 
@@ -526,7 +526,7 @@ declare_lint_pass!(OuterExpnDataPass => [OUTER_EXPN_EXPN_DATA]);
 
 impl<'tcx> LateLintPass<'tcx> for OuterExpnDataPass {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
-        if !run_lints(cx, &[OUTER_EXPN_EXPN_DATA], expr.hir_id) {
+        if !lints_enabled(cx, &[OUTER_EXPN_EXPN_DATA], expr.hir_id) {
             return;
         }
 
@@ -576,7 +576,7 @@ declare_lint_pass!(CollapsibleCalls => [COLLAPSIBLE_SPAN_LINT_CALLS]);
 
 impl<'tcx> LateLintPass<'tcx> for CollapsibleCalls {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
-        if !run_lints(cx, &[COLLAPSIBLE_SPAN_LINT_CALLS], expr.hir_id) {
+        if !lints_enabled(cx, &[COLLAPSIBLE_SPAN_LINT_CALLS], expr.hir_id) {
             return;
         }
 
@@ -757,7 +757,7 @@ declare_lint_pass!(MatchTypeOnDiagItem => [MATCH_TYPE_ON_DIAGNOSTIC_ITEM]);
 
 impl<'tcx> LateLintPass<'tcx> for MatchTypeOnDiagItem {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
-        if !run_lints(cx, &[MATCH_TYPE_ON_DIAGNOSTIC_ITEM], expr.hir_id) {
+        if !lints_enabled(cx, &[MATCH_TYPE_ON_DIAGNOSTIC_ITEM], expr.hir_id) {
             return;
         }
 
diff --git a/clippy_lints/src/wildcard_dependencies.rs b/clippy_lints/src/wildcard_dependencies.rs
index 60c3489a449..fe74698d7c2 100644
--- a/clippy_lints/src/wildcard_dependencies.rs
+++ b/clippy_lints/src/wildcard_dependencies.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint;
-use clippy_utils::run_lints;
+use clippy_utils::lints_enabled;
 use rustc_hir::{hir_id::CRATE_HIR_ID, Crate};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -31,7 +31,7 @@ declare_lint_pass!(WildcardDependencies => [WILDCARD_DEPENDENCIES]);
 
 impl LateLintPass<'_> for WildcardDependencies {
     fn check_crate(&mut self, cx: &LateContext<'_>, _: &Crate<'_>) {
-        if !run_lints(cx, &[WILDCARD_DEPENDENCIES], CRATE_HIR_ID) {
+        if !lints_enabled(cx, &[WILDCARD_DEPENDENCIES], CRATE_HIR_ID) {
             return;
         }
 
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index ef4854afc83..9f09027aadc 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -1546,12 +1546,12 @@ pub fn fn_def_id(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<DefId> {
 ///
 /// ```ignore
 /// #[deny(clippy::YOUR_AWESOME_LINT)]
-/// println!("Hello, World!"); // <- Clippy code: run_lints(cx, &[YOUR_AWESOME_LINT], id) == true
+/// println!("Hello, World!"); // <- Clippy code: lints_enabled(cx, &[YOUR_AWESOME_LINT], id) == true
 ///
 /// #[allow(clippy::YOUR_AWESOME_LINT)]
-/// println!("See you soon!"); // <- Clippy code: run_lints(cx, &[YOUR_AWESOME_LINT], id) == false
+/// println!("See you soon!"); // <- Clippy code: lints_enabled(cx, &[YOUR_AWESOME_LINT], id) == false
 /// ```
-pub fn run_lints(cx: &LateContext<'_>, lints: &[&'static Lint], id: HirId) -> bool {
+pub fn lints_enabled(cx: &LateContext<'_>, lints: &[&'static Lint], id: HirId) -> bool {
     lints.iter().any(|lint| {
         matches!(
             cx.tcx.lint_level_at_node(lint, id),
-- 
cgit 1.4.1-3-g733a5


From 5add651223a8d3ba8e2efccf942f9013d2f270a1 Mon Sep 17 00:00:00 2001
From: flip1995 <philipp.krones@embecosm.com>
Date: Fri, 9 Jul 2021 15:00:24 +0200
Subject: Remove lints_enabled function

This function was redundant with the is_allowed function. Now is_allowed
is used everywhere lints_enabled was used before.
---
 clippy_lints/src/cargo_common_metadata.rs   |  5 ++---
 clippy_lints/src/copies.rs                  |  8 ++++----
 clippy_lints/src/multiple_crate_versions.rs |  4 ++--
 clippy_lints/src/utils/internal_lints.rs    | 14 +++++++-------
 clippy_lints/src/wildcard_dependencies.rs   |  5 ++---
 clippy_utils/src/lib.rs                     | 19 -------------------
 6 files changed, 17 insertions(+), 38 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/cargo_common_metadata.rs b/clippy_lints/src/cargo_common_metadata.rs
index a84d1d5d9a0..edb60bc9b7d 100644
--- a/clippy_lints/src/cargo_common_metadata.rs
+++ b/clippy_lints/src/cargo_common_metadata.rs
@@ -2,8 +2,7 @@
 
 use std::path::PathBuf;
 
-use clippy_utils::diagnostics::span_lint;
-use clippy_utils::lints_enabled;
+use clippy_utils::{diagnostics::span_lint, is_allowed};
 use rustc_hir::{hir_id::CRATE_HIR_ID, Crate};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
@@ -85,7 +84,7 @@ fn is_empty_vec(value: &[String]) -> bool {
 
 impl LateLintPass<'_> for CargoCommonMetadata {
     fn check_crate(&mut self, cx: &LateContext<'_>, _: &Crate<'_>) {
-        if !lints_enabled(cx, &[CARGO_COMMON_METADATA], CRATE_HIR_ID) {
+        if is_allowed(cx, CARGO_COMMON_METADATA, CRATE_HIR_ID) {
             return;
         }
 
diff --git a/clippy_lints/src/copies.rs b/clippy_lints/src/copies.rs
index 91e0f2a55d5..7a0edfca4c2 100644
--- a/clippy_lints/src/copies.rs
+++ b/clippy_lints/src/copies.rs
@@ -1,8 +1,8 @@
 use clippy_utils::diagnostics::{span_lint_and_note, span_lint_and_then};
 use clippy_utils::source::{first_line_of_span, indent_of, reindent_multiline, snippet, snippet_opt};
 use clippy_utils::{
-    both, count_eq, eq_expr_value, get_enclosing_block, get_parent_expr, if_sequence, in_macro, is_else_clause,
-    lints_enabled, search_same, ContainsName, SpanlessEq, SpanlessHash,
+    both, count_eq, eq_expr_value, get_enclosing_block, get_parent_expr, if_sequence, in_macro, is_allowed,
+    is_else_clause, search_same, ContainsName, SpanlessEq, SpanlessHash,
 };
 use if_chain::if_chain;
 use rustc_data_structures::fx::FxHashSet;
@@ -337,8 +337,8 @@ fn scan_block_for_eq(cx: &LateContext<'tcx>, blocks: &[&Block<'tcx>]) -> Option<
             if block_expr_eq;
             if l_stmts.len() == r_stmts.len();
             if l_stmts.len() == current_start_eq;
-            if lints_enabled(cx, &[IF_SAME_THEN_ELSE], win[0].hir_id);
-            if lints_enabled(cx, &[IF_SAME_THEN_ELSE], win[1].hir_id);
+            if !is_allowed(cx, IF_SAME_THEN_ELSE, win[0].hir_id);
+            if !is_allowed(cx, IF_SAME_THEN_ELSE, win[1].hir_id);
             then {
                 span_lint_and_note(
                     cx,
diff --git a/clippy_lints/src/multiple_crate_versions.rs b/clippy_lints/src/multiple_crate_versions.rs
index 1eba7c124cf..6a50c970909 100644
--- a/clippy_lints/src/multiple_crate_versions.rs
+++ b/clippy_lints/src/multiple_crate_versions.rs
@@ -1,7 +1,7 @@
 //! lint on multiple versions of a crate being used
 
 use clippy_utils::diagnostics::span_lint;
-use clippy_utils::lints_enabled;
+use clippy_utils::is_allowed;
 use rustc_hir::def_id::LOCAL_CRATE;
 use rustc_hir::{Crate, CRATE_HIR_ID};
 use rustc_lint::{LateContext, LateLintPass};
@@ -39,7 +39,7 @@ declare_lint_pass!(MultipleCrateVersions => [MULTIPLE_CRATE_VERSIONS]);
 
 impl LateLintPass<'_> for MultipleCrateVersions {
     fn check_crate(&mut self, cx: &LateContext<'_>, _: &Crate<'_>) {
-        if !lints_enabled(cx, &[MULTIPLE_CRATE_VERSIONS], CRATE_HIR_ID) {
+        if is_allowed(cx, MULTIPLE_CRATE_VERSIONS, CRATE_HIR_ID) {
             return;
         }
 
diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs
index e8b14ee8e0b..cbaacddd804 100644
--- a/clippy_lints/src/utils/internal_lints.rs
+++ b/clippy_lints/src/utils/internal_lints.rs
@@ -3,7 +3,7 @@ use clippy_utils::diagnostics::{span_lint, span_lint_and_help, span_lint_and_sug
 use clippy_utils::source::snippet;
 use clippy_utils::ty::match_type;
 use clippy_utils::{
-    is_else_clause, is_expn_of, is_expr_path_def_path, lints_enabled, match_def_path, method_calls, path_to_res, paths,
+    is_allowed, is_else_clause, is_expn_of, is_expr_path_def_path, match_def_path, method_calls, path_to_res, paths,
     SpanlessEq,
 };
 use if_chain::if_chain;
@@ -353,7 +353,7 @@ impl_lint_pass!(LintWithoutLintPass => [DEFAULT_LINT, LINT_WITHOUT_LINT_PASS]);
 
 impl<'tcx> LateLintPass<'tcx> for LintWithoutLintPass {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
-        if !lints_enabled(cx, &[DEFAULT_LINT], item.hir_id()) {
+        if is_allowed(cx, DEFAULT_LINT, item.hir_id()) {
             return;
         }
 
@@ -411,7 +411,7 @@ impl<'tcx> LateLintPass<'tcx> for LintWithoutLintPass {
     }
 
     fn check_crate_post(&mut self, cx: &LateContext<'tcx>, _: &'tcx Crate<'_>) {
-        if !lints_enabled(cx, &[LINT_WITHOUT_LINT_PASS], CRATE_HIR_ID) {
+        if is_allowed(cx, LINT_WITHOUT_LINT_PASS, CRATE_HIR_ID) {
             return;
         }
 
@@ -497,7 +497,7 @@ impl_lint_pass!(CompilerLintFunctions => [COMPILER_LINT_FUNCTIONS]);
 
 impl<'tcx> LateLintPass<'tcx> for CompilerLintFunctions {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if !lints_enabled(cx, &[COMPILER_LINT_FUNCTIONS], expr.hir_id) {
+        if is_allowed(cx, COMPILER_LINT_FUNCTIONS, expr.hir_id) {
             return;
         }
 
@@ -526,7 +526,7 @@ declare_lint_pass!(OuterExpnDataPass => [OUTER_EXPN_EXPN_DATA]);
 
 impl<'tcx> LateLintPass<'tcx> for OuterExpnDataPass {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
-        if !lints_enabled(cx, &[OUTER_EXPN_EXPN_DATA], expr.hir_id) {
+        if is_allowed(cx, OUTER_EXPN_EXPN_DATA, expr.hir_id) {
             return;
         }
 
@@ -576,7 +576,7 @@ declare_lint_pass!(CollapsibleCalls => [COLLAPSIBLE_SPAN_LINT_CALLS]);
 
 impl<'tcx> LateLintPass<'tcx> for CollapsibleCalls {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
-        if !lints_enabled(cx, &[COLLAPSIBLE_SPAN_LINT_CALLS], expr.hir_id) {
+        if is_allowed(cx, COLLAPSIBLE_SPAN_LINT_CALLS, expr.hir_id) {
             return;
         }
 
@@ -757,7 +757,7 @@ declare_lint_pass!(MatchTypeOnDiagItem => [MATCH_TYPE_ON_DIAGNOSTIC_ITEM]);
 
 impl<'tcx> LateLintPass<'tcx> for MatchTypeOnDiagItem {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
-        if !lints_enabled(cx, &[MATCH_TYPE_ON_DIAGNOSTIC_ITEM], expr.hir_id) {
+        if is_allowed(cx, MATCH_TYPE_ON_DIAGNOSTIC_ITEM, expr.hir_id) {
             return;
         }
 
diff --git a/clippy_lints/src/wildcard_dependencies.rs b/clippy_lints/src/wildcard_dependencies.rs
index fe74698d7c2..df5127b00ee 100644
--- a/clippy_lints/src/wildcard_dependencies.rs
+++ b/clippy_lints/src/wildcard_dependencies.rs
@@ -1,5 +1,4 @@
-use clippy_utils::diagnostics::span_lint;
-use clippy_utils::lints_enabled;
+use clippy_utils::{diagnostics::span_lint, is_allowed};
 use rustc_hir::{hir_id::CRATE_HIR_ID, Crate};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -31,7 +30,7 @@ declare_lint_pass!(WildcardDependencies => [WILDCARD_DEPENDENCIES]);
 
 impl LateLintPass<'_> for WildcardDependencies {
     fn check_crate(&mut self, cx: &LateContext<'_>, _: &Crate<'_>) {
-        if !lints_enabled(cx, &[WILDCARD_DEPENDENCIES], CRATE_HIR_ID) {
+        if is_allowed(cx, WILDCARD_DEPENDENCIES, CRATE_HIR_ID) {
             return;
         }
 
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 9f09027aadc..121ca2da511 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -1541,25 +1541,6 @@ pub fn fn_def_id(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<DefId> {
     }
 }
 
-/// This function checks if any of the lints in the slice is enabled for the provided `HirId`.
-/// A lint counts as enabled with any of the levels: `Level::Forbid` | `Level::Deny` | `Level::Warn`
-///
-/// ```ignore
-/// #[deny(clippy::YOUR_AWESOME_LINT)]
-/// println!("Hello, World!"); // <- Clippy code: lints_enabled(cx, &[YOUR_AWESOME_LINT], id) == true
-///
-/// #[allow(clippy::YOUR_AWESOME_LINT)]
-/// println!("See you soon!"); // <- Clippy code: lints_enabled(cx, &[YOUR_AWESOME_LINT], id) == false
-/// ```
-pub fn lints_enabled(cx: &LateContext<'_>, lints: &[&'static Lint], id: HirId) -> bool {
-    lints.iter().any(|lint| {
-        matches!(
-            cx.tcx.lint_level_at_node(lint, id),
-            (Level::Forbid | Level::Deny | Level::Warn, _)
-        )
-    })
-}
-
 /// Returns Option<String> where String is a textual representation of the type encapsulated in the
 /// slice iff the given expression is a slice of primitives (as defined in the
 /// `is_recursively_primitive_type` function) and None otherwise.
-- 
cgit 1.4.1-3-g733a5


From d2c8f50bbed32a6bcec5f397043342c980e945b3 Mon Sep 17 00:00:00 2001
From: flip1995 <philipp.krones@embecosm.com>
Date: Fri, 9 Jul 2021 15:06:12 +0200
Subject: Rename `is_allowed` -> `is_lint_allowed`

---
 clippy_lints/src/cargo_common_metadata.rs   |  4 ++--
 clippy_lints/src/copies.rs                  |  8 ++++----
 clippy_lints/src/dereference.rs             |  4 ++--
 clippy_lints/src/derive.rs                  |  4 ++--
 clippy_lints/src/inherent_impl.rs           |  6 +++---
 clippy_lints/src/len_zero.rs                |  4 ++--
 clippy_lints/src/manual_map.rs              |  6 +++---
 clippy_lints/src/matches.rs                 |  4 ++--
 clippy_lints/src/multiple_crate_versions.rs |  4 ++--
 clippy_lints/src/ptr.rs                     |  4 ++--
 clippy_lints/src/strings.rs                 |  4 ++--
 clippy_lints/src/unicode.rs                 |  6 +++---
 clippy_lints/src/utils/internal_lints.rs    | 16 ++++++++--------
 clippy_lints/src/wildcard_dependencies.rs   |  4 ++--
 clippy_utils/src/lib.rs                     |  2 +-
 15 files changed, 40 insertions(+), 40 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/cargo_common_metadata.rs b/clippy_lints/src/cargo_common_metadata.rs
index edb60bc9b7d..21c7b2448ce 100644
--- a/clippy_lints/src/cargo_common_metadata.rs
+++ b/clippy_lints/src/cargo_common_metadata.rs
@@ -2,7 +2,7 @@
 
 use std::path::PathBuf;
 
-use clippy_utils::{diagnostics::span_lint, is_allowed};
+use clippy_utils::{diagnostics::span_lint, is_lint_allowed};
 use rustc_hir::{hir_id::CRATE_HIR_ID, Crate};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
@@ -84,7 +84,7 @@ fn is_empty_vec(value: &[String]) -> bool {
 
 impl LateLintPass<'_> for CargoCommonMetadata {
     fn check_crate(&mut self, cx: &LateContext<'_>, _: &Crate<'_>) {
-        if is_allowed(cx, CARGO_COMMON_METADATA, CRATE_HIR_ID) {
+        if is_lint_allowed(cx, CARGO_COMMON_METADATA, CRATE_HIR_ID) {
             return;
         }
 
diff --git a/clippy_lints/src/copies.rs b/clippy_lints/src/copies.rs
index 7a0edfca4c2..aea1accccc6 100644
--- a/clippy_lints/src/copies.rs
+++ b/clippy_lints/src/copies.rs
@@ -1,8 +1,8 @@
 use clippy_utils::diagnostics::{span_lint_and_note, span_lint_and_then};
 use clippy_utils::source::{first_line_of_span, indent_of, reindent_multiline, snippet, snippet_opt};
 use clippy_utils::{
-    both, count_eq, eq_expr_value, get_enclosing_block, get_parent_expr, if_sequence, in_macro, is_allowed,
-    is_else_clause, search_same, ContainsName, SpanlessEq, SpanlessHash,
+    both, count_eq, eq_expr_value, get_enclosing_block, get_parent_expr, if_sequence, in_macro, is_else_clause,
+    is_lint_allowed, search_same, ContainsName, SpanlessEq, SpanlessHash,
 };
 use if_chain::if_chain;
 use rustc_data_structures::fx::FxHashSet;
@@ -337,8 +337,8 @@ fn scan_block_for_eq(cx: &LateContext<'tcx>, blocks: &[&Block<'tcx>]) -> Option<
             if block_expr_eq;
             if l_stmts.len() == r_stmts.len();
             if l_stmts.len() == current_start_eq;
-            if !is_allowed(cx, IF_SAME_THEN_ELSE, win[0].hir_id);
-            if !is_allowed(cx, IF_SAME_THEN_ELSE, win[1].hir_id);
+            if !is_lint_allowed(cx, IF_SAME_THEN_ELSE, win[0].hir_id);
+            if !is_lint_allowed(cx, IF_SAME_THEN_ELSE, win[1].hir_id);
             then {
                 span_lint_and_note(
                     cx,
diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index 1415f8e235a..682003f9c2c 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_context;
 use clippy_utils::ty::peel_mid_ty_refs;
-use clippy_utils::{get_parent_node, in_macro, is_allowed};
+use clippy_utils::{get_parent_node, in_macro, is_lint_allowed};
 use rustc_ast::util::parser::PREC_PREFIX;
 use rustc_errors::Applicability;
 use rustc_hir::{BorrowKind, Expr, ExprKind, HirId, MatchSource, Mutability, Node, UnOp};
@@ -107,7 +107,7 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing {
 
                 match kind {
                     RefOp::Method(target_mut)
-                        if !is_allowed(cx, EXPLICIT_DEREF_METHODS, expr.hir_id)
+                        if !is_lint_allowed(cx, EXPLICIT_DEREF_METHODS, expr.hir_id)
                             && is_linted_explicit_deref_position(parent, expr.hir_id, expr.span) =>
                     {
                         self.state = Some((
diff --git a/clippy_lints/src/derive.rs b/clippy_lints/src/derive.rs
index 3ac20fd9849..7aafaf71383 100644
--- a/clippy_lints/src/derive.rs
+++ b/clippy_lints/src/derive.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_note, span_lint_and_then};
 use clippy_utils::paths;
 use clippy_utils::ty::{implements_trait, is_copy};
-use clippy_utils::{get_trait_def_id, is_allowed, is_automatically_derived, match_def_path};
+use clippy_utils::{get_trait_def_id, is_automatically_derived, is_lint_allowed, match_def_path};
 use if_chain::if_chain;
 use rustc_hir::def_id::DefId;
 use rustc_hir::intravisit::{walk_expr, walk_fn, walk_item, FnKind, NestedVisitorMap, Visitor};
@@ -362,7 +362,7 @@ fn check_unsafe_derive_deserialize<'tcx>(
         if let ty::Adt(def, _) = ty.kind();
         if let Some(local_def_id) = def.did.as_local();
         let adt_hir_id = cx.tcx.hir().local_def_id_to_hir_id(local_def_id);
-        if !is_allowed(cx, UNSAFE_DERIVE_DESERIALIZE, adt_hir_id);
+        if !is_lint_allowed(cx, UNSAFE_DERIVE_DESERIALIZE, adt_hir_id);
         if cx.tcx.inherent_impls(def.did)
             .iter()
             .map(|imp_did| item_from_def_id(cx, *imp_did))
diff --git a/clippy_lints/src/inherent_impl.rs b/clippy_lints/src/inherent_impl.rs
index ee41c4aea2f..9641784eb9a 100644
--- a/clippy_lints/src/inherent_impl.rs
+++ b/clippy_lints/src/inherent_impl.rs
@@ -1,7 +1,7 @@
 //! lint on inherent implementations
 
 use clippy_utils::diagnostics::span_lint_and_note;
-use clippy_utils::{in_macro, is_allowed};
+use clippy_utils::{in_macro, is_lint_allowed};
 use rustc_data_structures::fx::FxHashMap;
 use rustc_hir::{def_id::LocalDefId, Crate, Item, ItemKind, Node};
 use rustc_lint::{LateContext, LateLintPass};
@@ -59,7 +59,7 @@ impl<'tcx> LateLintPass<'tcx> for MultipleInherentImpl {
             .filter(|(&id, impls)| {
                 impls.len() > 1
                     // Check for `#[allow]` on the type definition
-                    && !is_allowed(
+                    && !is_lint_allowed(
                         cx,
                         MULTIPLE_INHERENT_IMPL,
                         cx.tcx.hir().local_def_id_to_hir_id(id),
@@ -123,7 +123,7 @@ fn get_impl_span(cx: &LateContext<'_>, id: LocalDefId) -> Option<Span> {
         ..
     }) = cx.tcx.hir().get(id)
     {
-        (!in_macro(span) && impl_item.generics.params.is_empty() && !is_allowed(cx, MULTIPLE_INHERENT_IMPL, id))
+        (!in_macro(span) && impl_item.generics.params.is_empty() && !is_lint_allowed(cx, MULTIPLE_INHERENT_IMPL, id))
             .then(|| span)
     } else {
         None
diff --git a/clippy_lints/src/len_zero.rs b/clippy_lints/src/len_zero.rs
index d69187f6746..892b3af0b32 100644
--- a/clippy_lints/src/len_zero.rs
+++ b/clippy_lints/src/len_zero.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::{get_item_name, get_parent_as_impl, is_allowed};
+use clippy_utils::{get_item_name, get_parent_as_impl, is_lint_allowed};
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
@@ -139,7 +139,7 @@ impl<'tcx> LateLintPass<'tcx> for LenZero {
             if let Some(ty_id) = cx.qpath_res(ty_path, imp.self_ty.hir_id).opt_def_id();
             if let Some(local_id) = ty_id.as_local();
             let ty_hir_id = cx.tcx.hir().local_def_id_to_hir_id(local_id);
-            if !is_allowed(cx, LEN_WITHOUT_IS_EMPTY, ty_hir_id);
+            if !is_lint_allowed(cx, LEN_WITHOUT_IS_EMPTY, ty_hir_id);
             if let Some(output) = parse_len_output(cx, cx.tcx.fn_sig(item.def_id).skip_binder());
             then {
                 let (name, kind) = match cx.tcx.hir().find(ty_hir_id) {
diff --git a/clippy_lints/src/manual_map.rs b/clippy_lints/src/manual_map.rs
index 97e4a983f32..563d5cdb5fb 100644
--- a/clippy_lints/src/manual_map.rs
+++ b/clippy_lints/src/manual_map.rs
@@ -3,7 +3,7 @@ use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::{snippet_with_applicability, snippet_with_context};
 use clippy_utils::ty::{is_type_diagnostic_item, peel_mid_ty_refs_is_mutable};
 use clippy_utils::{
-    can_move_expr_to_closure, in_constant, is_allowed, is_else_clause, is_lang_ctor, path_to_local_id,
+    can_move_expr_to_closure, in_constant, is_else_clause, is_lang_ctor, is_lint_allowed, path_to_local_id,
     peel_hir_expr_refs,
 };
 use rustc_ast::util::parser::PREC_POSTFIX;
@@ -102,7 +102,7 @@ impl LateLintPass<'_> for ManualMap {
 
             // These two lints will go back and forth with each other.
             if cx.typeck_results().expr_ty(some_expr) == cx.tcx.types.unit
-                && !is_allowed(cx, OPTION_MAP_UNIT_FN, expr.hir_id)
+                && !is_lint_allowed(cx, OPTION_MAP_UNIT_FN, expr.hir_id)
             {
                 return;
             }
@@ -146,7 +146,7 @@ impl LateLintPass<'_> for ManualMap {
                     },
                     _ => {
                         if path_to_local_id(some_expr, id)
-                            && !is_allowed(cx, MATCH_AS_REF, expr.hir_id)
+                            && !is_lint_allowed(cx, MATCH_AS_REF, expr.hir_id)
                             && binding_ref.is_some()
                         {
                             return;
diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index f1e3492c4ec..986469a2b69 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -7,7 +7,7 @@ use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::{implements_trait, is_type_diagnostic_item, match_type, peel_mid_ty_refs};
 use clippy_utils::visitors::LocalUsedVisitor;
 use clippy_utils::{
-    get_parent_expr, in_macro, is_allowed, is_expn_of, is_lang_ctor, is_refutable, is_wild, meets_msrv, msrvs,
+    get_parent_expr, in_macro, is_expn_of, is_lang_ctor, is_lint_allowed, is_refutable, is_wild, meets_msrv, msrvs,
     path_to_local, path_to_local_id, peel_hir_pat_refs, peel_n_hir_expr_refs, recurse_or_patterns, remove_blocks,
     strip_pat_refs,
 };
@@ -707,7 +707,7 @@ fn check_single_match(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>], exp
         };
 
         let ty = cx.typeck_results().expr_ty(ex);
-        if *ty.kind() != ty::Bool || is_allowed(cx, MATCH_BOOL, ex.hir_id) {
+        if *ty.kind() != ty::Bool || is_lint_allowed(cx, MATCH_BOOL, ex.hir_id) {
             check_single_match_single_pattern(cx, ex, arms, expr, els);
             check_single_match_opt_like(cx, ex, arms, expr, ty, els);
         }
diff --git a/clippy_lints/src/multiple_crate_versions.rs b/clippy_lints/src/multiple_crate_versions.rs
index 6a50c970909..f5ce3e32551 100644
--- a/clippy_lints/src/multiple_crate_versions.rs
+++ b/clippy_lints/src/multiple_crate_versions.rs
@@ -1,7 +1,7 @@
 //! lint on multiple versions of a crate being used
 
 use clippy_utils::diagnostics::span_lint;
-use clippy_utils::is_allowed;
+use clippy_utils::is_lint_allowed;
 use rustc_hir::def_id::LOCAL_CRATE;
 use rustc_hir::{Crate, CRATE_HIR_ID};
 use rustc_lint::{LateContext, LateLintPass};
@@ -39,7 +39,7 @@ declare_lint_pass!(MultipleCrateVersions => [MULTIPLE_CRATE_VERSIONS]);
 
 impl LateLintPass<'_> for MultipleCrateVersions {
     fn check_crate(&mut self, cx: &LateContext<'_>, _: &Crate<'_>) {
-        if is_allowed(cx, MULTIPLE_CRATE_VERSIONS, CRATE_HIR_ID) {
+        if is_lint_allowed(cx, MULTIPLE_CRATE_VERSIONS, CRATE_HIR_ID) {
             return;
         }
 
diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs
index 12c44436874..dba3b1805cd 100644
--- a/clippy_lints/src/ptr.rs
+++ b/clippy_lints/src/ptr.rs
@@ -4,7 +4,7 @@ use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg, span_lint_and_the
 use clippy_utils::ptr::get_spans;
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::{is_type_diagnostic_item, match_type, walk_ptrs_hir_ty};
-use clippy_utils::{expr_path_res, is_allowed, match_any_def_paths, paths};
+use clippy_utils::{expr_path_res, is_lint_allowed, match_any_def_paths, paths};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{
@@ -246,7 +246,7 @@ fn check_fn(cx: &LateContext<'_>, decl: &FnDecl<'_>, fn_id: HirId, opt_body_id:
     for (idx, (arg, ty)) in decl.inputs.iter().zip(fn_ty.inputs()).enumerate() {
         // Honor the allow attribute on parameters. See issue 5644.
         if let Some(body) = &body {
-            if is_allowed(cx, PTR_ARG, body.params[idx].hir_id) {
+            if is_lint_allowed(cx, PTR_ARG, body.params[idx].hir_id) {
                 continue;
             }
         }
diff --git a/clippy_lints/src/strings.rs b/clippy_lints/src/strings.rs
index 9d91b53e1bb..958e462125e 100644
--- a/clippy_lints/src/strings.rs
+++ b/clippy_lints/src/strings.rs
@@ -2,7 +2,7 @@ use clippy_utils::diagnostics::{span_lint, span_lint_and_help, span_lint_and_sug
 use clippy_utils::source::{snippet, snippet_with_applicability};
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::SpanlessEq;
-use clippy_utils::{get_parent_expr, is_allowed, match_function_call, method_calls, paths};
+use clippy_utils::{get_parent_expr, is_lint_allowed, match_function_call, method_calls, paths};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, BorrowKind, Expr, ExprKind, LangItem, QPath};
@@ -124,7 +124,7 @@ impl<'tcx> LateLintPass<'tcx> for StringAdd {
         ) = e.kind
         {
             if is_string(cx, left) {
-                if !is_allowed(cx, STRING_ADD_ASSIGN, e.hir_id) {
+                if !is_lint_allowed(cx, STRING_ADD_ASSIGN, e.hir_id) {
                     let parent = get_parent_expr(cx, e);
                     if let Some(p) = parent {
                         if let ExprKind::Assign(target, _, _) = p.kind {
diff --git a/clippy_lints/src/unicode.rs b/clippy_lints/src/unicode.rs
index 45291a120ed..2f0a61898ba 100644
--- a/clippy_lints/src/unicode.rs
+++ b/clippy_lints/src/unicode.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::is_allowed;
+use clippy_utils::is_lint_allowed;
 use clippy_utils::source::snippet;
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
@@ -114,7 +114,7 @@ fn check_str(cx: &LateContext<'_>, span: Span, id: HirId) {
             span,
             "literal non-ASCII character detected",
             "consider replacing the string with",
-            if is_allowed(cx, UNICODE_NOT_NFC, id) {
+            if is_lint_allowed(cx, UNICODE_NOT_NFC, id) {
                 escape(string.chars())
             } else {
                 escape(string.nfc())
@@ -122,7 +122,7 @@ fn check_str(cx: &LateContext<'_>, span: Span, id: HirId) {
             Applicability::MachineApplicable,
         );
     }
-    if is_allowed(cx, NON_ASCII_LITERAL, id) && string.chars().zip(string.nfc()).any(|(a, b)| a != b) {
+    if is_lint_allowed(cx, NON_ASCII_LITERAL, id) && string.chars().zip(string.nfc()).any(|(a, b)| a != b) {
         span_lint_and_sugg(
             cx,
             UNICODE_NOT_NFC,
diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs
index cbaacddd804..668807f499f 100644
--- a/clippy_lints/src/utils/internal_lints.rs
+++ b/clippy_lints/src/utils/internal_lints.rs
@@ -3,8 +3,8 @@ use clippy_utils::diagnostics::{span_lint, span_lint_and_help, span_lint_and_sug
 use clippy_utils::source::snippet;
 use clippy_utils::ty::match_type;
 use clippy_utils::{
-    is_allowed, is_else_clause, is_expn_of, is_expr_path_def_path, match_def_path, method_calls, path_to_res, paths,
-    SpanlessEq,
+    is_else_clause, is_expn_of, is_expr_path_def_path, is_lint_allowed, match_def_path, method_calls, path_to_res,
+    paths, SpanlessEq,
 };
 use if_chain::if_chain;
 use rustc_ast::ast::{Crate as AstCrate, ItemKind, LitKind, ModKind, NodeId};
@@ -353,7 +353,7 @@ impl_lint_pass!(LintWithoutLintPass => [DEFAULT_LINT, LINT_WITHOUT_LINT_PASS]);
 
 impl<'tcx> LateLintPass<'tcx> for LintWithoutLintPass {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
-        if is_allowed(cx, DEFAULT_LINT, item.hir_id()) {
+        if is_lint_allowed(cx, DEFAULT_LINT, item.hir_id()) {
             return;
         }
 
@@ -411,7 +411,7 @@ impl<'tcx> LateLintPass<'tcx> for LintWithoutLintPass {
     }
 
     fn check_crate_post(&mut self, cx: &LateContext<'tcx>, _: &'tcx Crate<'_>) {
-        if is_allowed(cx, LINT_WITHOUT_LINT_PASS, CRATE_HIR_ID) {
+        if is_lint_allowed(cx, LINT_WITHOUT_LINT_PASS, CRATE_HIR_ID) {
             return;
         }
 
@@ -497,7 +497,7 @@ impl_lint_pass!(CompilerLintFunctions => [COMPILER_LINT_FUNCTIONS]);
 
 impl<'tcx> LateLintPass<'tcx> for CompilerLintFunctions {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if is_allowed(cx, COMPILER_LINT_FUNCTIONS, expr.hir_id) {
+        if is_lint_allowed(cx, COMPILER_LINT_FUNCTIONS, expr.hir_id) {
             return;
         }
 
@@ -526,7 +526,7 @@ declare_lint_pass!(OuterExpnDataPass => [OUTER_EXPN_EXPN_DATA]);
 
 impl<'tcx> LateLintPass<'tcx> for OuterExpnDataPass {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
-        if is_allowed(cx, OUTER_EXPN_EXPN_DATA, expr.hir_id) {
+        if is_lint_allowed(cx, OUTER_EXPN_EXPN_DATA, expr.hir_id) {
             return;
         }
 
@@ -576,7 +576,7 @@ declare_lint_pass!(CollapsibleCalls => [COLLAPSIBLE_SPAN_LINT_CALLS]);
 
 impl<'tcx> LateLintPass<'tcx> for CollapsibleCalls {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
-        if is_allowed(cx, COLLAPSIBLE_SPAN_LINT_CALLS, expr.hir_id) {
+        if is_lint_allowed(cx, COLLAPSIBLE_SPAN_LINT_CALLS, expr.hir_id) {
             return;
         }
 
@@ -757,7 +757,7 @@ declare_lint_pass!(MatchTypeOnDiagItem => [MATCH_TYPE_ON_DIAGNOSTIC_ITEM]);
 
 impl<'tcx> LateLintPass<'tcx> for MatchTypeOnDiagItem {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
-        if is_allowed(cx, MATCH_TYPE_ON_DIAGNOSTIC_ITEM, expr.hir_id) {
+        if is_lint_allowed(cx, MATCH_TYPE_ON_DIAGNOSTIC_ITEM, expr.hir_id) {
             return;
         }
 
diff --git a/clippy_lints/src/wildcard_dependencies.rs b/clippy_lints/src/wildcard_dependencies.rs
index df5127b00ee..1ca1117a41e 100644
--- a/clippy_lints/src/wildcard_dependencies.rs
+++ b/clippy_lints/src/wildcard_dependencies.rs
@@ -1,4 +1,4 @@
-use clippy_utils::{diagnostics::span_lint, is_allowed};
+use clippy_utils::{diagnostics::span_lint, is_lint_allowed};
 use rustc_hir::{hir_id::CRATE_HIR_ID, Crate};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -30,7 +30,7 @@ declare_lint_pass!(WildcardDependencies => [WILDCARD_DEPENDENCIES]);
 
 impl LateLintPass<'_> for WildcardDependencies {
     fn check_crate(&mut self, cx: &LateContext<'_>, _: &Crate<'_>) {
-        if is_allowed(cx, WILDCARD_DEPENDENCIES, CRATE_HIR_ID) {
+        if is_lint_allowed(cx, WILDCARD_DEPENDENCIES, CRATE_HIR_ID) {
             return;
         }
 
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 121ca2da511..364ae536ecd 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -1173,7 +1173,7 @@ pub fn is_try<'tcx>(cx: &LateContext<'_>, expr: &'tcx Expr<'tcx>) -> Option<&'tc
 /// Returns `true` if the lint is allowed in the current context
 ///
 /// Useful for skipping long running code when it's unnecessary
-pub fn is_allowed(cx: &LateContext<'_>, lint: &'static Lint, id: HirId) -> bool {
+pub fn is_lint_allowed(cx: &LateContext<'_>, lint: &'static Lint, id: HirId) -> bool {
     cx.tcx.lint_level_at_node(lint, id).0 == Level::Allow
 }
 
-- 
cgit 1.4.1-3-g733a5


From f05949f9ce0d25f3b993a0a668909956818c0464 Mon Sep 17 00:00:00 2001
From: flip1995 <philipp.krones@embecosm.com>
Date: Tue, 13 Jul 2021 10:54:29 +0200
Subject: Add fixed example to unused_unit documentation

---
 clippy_lints/src/unused_unit.rs | 4 ++++
 1 file changed, 4 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unused_unit.rs b/clippy_lints/src/unused_unit.rs
index e14945651f5..ab0cdf75ffe 100644
--- a/clippy_lints/src/unused_unit.rs
+++ b/clippy_lints/src/unused_unit.rs
@@ -24,6 +24,10 @@ declare_clippy_lint! {
     ///     ()
     /// }
     /// ```
+    /// is equivalent to
+    /// ```rust
+    /// fn return_unit() {}
+    /// ```
     pub UNUSED_UNIT,
     style,
     "needless unit expression"
-- 
cgit 1.4.1-3-g733a5


From 3fc8dae46c0b4e4e297dcbd34e789af25da0dd37 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Wed, 9 Jun 2021 14:44:42 -0500
Subject: Allow needless_bool in macro

---
 clippy_lints/src/needless_bool.rs | 3 +++
 1 file changed, 3 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/needless_bool.rs b/clippy_lints/src/needless_bool.rs
index 3b3736fd3a1..780690548e5 100644
--- a/clippy_lints/src/needless_bool.rs
+++ b/clippy_lints/src/needless_bool.rs
@@ -71,6 +71,9 @@ declare_lint_pass!(NeedlessBool => [NEEDLESS_BOOL]);
 impl<'tcx> LateLintPass<'tcx> for NeedlessBool {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
         use self::Expression::{Bool, RetBool};
+        if e.span.from_expansion() {
+            return;
+        }
         if let ExprKind::If(pred, then_block, Some(else_expr)) = e.kind {
             let reduce = |ret, not| {
                 let mut applicability = Applicability::MachineApplicable;
-- 
cgit 1.4.1-3-g733a5


From 20dbb277cf1b12546e7e604066b46d7b0f575bb0 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Sun, 4 Jul 2021 16:34:22 -0500
Subject: Fix useless_format false positive

---
 clippy_lints/src/format.rs | 4 +++-
 tests/ui/format.fixed      | 2 ++
 tests/ui/format.rs         | 2 ++
 3 files changed, 7 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/format.rs b/clippy_lints/src/format.rs
index c2b055ed648..de1b3ffecd0 100644
--- a/clippy_lints/src/format.rs
+++ b/clippy_lints/src/format.rs
@@ -12,6 +12,7 @@ use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
 use rustc_span::sym;
+use rustc_span::symbol::kw;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for the use of `format!("string literal with no
@@ -157,7 +158,8 @@ fn on_new_v1_fmt<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<S
         if let ExprKind::Array(pieces) = arr.kind;
         if pieces.len() == 1;
         if let ExprKind::Lit(ref lit) = pieces[0].kind;
-        if let LitKind::Str(..) = lit.node;
+        if let LitKind::Str(symbol, _) = lit.node;
+        if symbol == kw::Empty;
         // Argument 2 in `new_v1_formatted()`
         if let ExprKind::AddrOf(BorrowKind::Ref, _, arg1) = args[1].kind;
         if let ExprKind::Match(matchee, arms, MatchSource::Normal) = arg1.kind;
diff --git a/tests/ui/format.fixed b/tests/ui/format.fixed
index e4cfb005fd1..5dd64140e81 100644
--- a/tests/ui/format.fixed
+++ b/tests/ui/format.fixed
@@ -69,4 +69,6 @@ fn main() {
     // Wrap it with braces
     let v: Vec<String> = vec!["foo".to_string(), "bar".to_string()];
     let _s: String = (&*v.join("\n")).to_string();
+
+    format!("prepend {:+}", "s");
 }
diff --git a/tests/ui/format.rs b/tests/ui/format.rs
index 683957f0ff0..4599fb5207e 100644
--- a/tests/ui/format.rs
+++ b/tests/ui/format.rs
@@ -71,4 +71,6 @@ fn main() {
     // Wrap it with braces
     let v: Vec<String> = vec!["foo".to_string(), "bar".to_string()];
     let _s: String = format!("{}", &*v.join("\n"));
+
+    format!("prepend {:+}", "s");
 }
-- 
cgit 1.4.1-3-g733a5


From e6ab222b814f20375041a5dd39e7605eed079c70 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Tue, 6 Jul 2021 11:51:15 -0500
Subject: Refactor format macro parsing

---
 clippy_lints/src/explicit_write.rs          |  44 ++-----
 clippy_lints/src/format.rs                  | 192 ++++++++++------------------
 clippy_lints/src/methods/expect_fun_call.rs |  72 +++--------
 clippy_utils/src/higher.rs                  | 108 +++++++++++++++-
 clippy_utils/src/paths.rs                   |   4 -
 5 files changed, 203 insertions(+), 217 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/explicit_write.rs b/clippy_lints/src/explicit_write.rs
index da4936ff25b..eaea70a4294 100644
--- a/clippy_lints/src/explicit_write.rs
+++ b/clippy_lints/src/explicit_write.rs
@@ -1,9 +1,9 @@
 use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg};
+use clippy_utils::higher::FormatArgsExpn;
 use clippy_utils::{is_expn_of, match_function_call, paths};
 use if_chain::if_chain;
-use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
-use rustc_hir::{BorrowKind, Expr, ExprKind};
+use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::sym;
@@ -34,29 +34,26 @@ impl<'tcx> LateLintPass<'tcx> for ExplicitWrite {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if_chain! {
             // match call to unwrap
-            if let ExprKind::MethodCall(unwrap_fun, _, unwrap_args, _) = expr.kind;
+            if let ExprKind::MethodCall(unwrap_fun, _, [write_call], _) = expr.kind;
             if unwrap_fun.ident.name == sym::unwrap;
             // match call to write_fmt
-            if !unwrap_args.is_empty();
-            if let ExprKind::MethodCall(write_fun, _, write_args, _) =
-                unwrap_args[0].kind;
+            if let ExprKind::MethodCall(write_fun, _, [write_recv, write_arg], _) = write_call.kind;
             if write_fun.ident.name == sym!(write_fmt);
             // match calls to std::io::stdout() / std::io::stderr ()
-            if !write_args.is_empty();
-            if let Some(dest_name) = if match_function_call(cx, &write_args[0], &paths::STDOUT).is_some() {
+            if let Some(dest_name) = if match_function_call(cx, write_recv, &paths::STDOUT).is_some() {
                 Some("stdout")
-            } else if match_function_call(cx, &write_args[0], &paths::STDERR).is_some() {
+            } else if match_function_call(cx, write_recv, &paths::STDERR).is_some() {
                 Some("stderr")
             } else {
                 None
             };
+            if let Some(format_args) = FormatArgsExpn::parse(write_arg);
             then {
-                let write_span = unwrap_args[0].span;
                 let calling_macro =
                     // ordering is important here, since `writeln!` uses `write!` internally
-                    if is_expn_of(write_span, "writeln").is_some() {
+                    if is_expn_of(write_call.span, "writeln").is_some() {
                         Some("writeln")
-                    } else if is_expn_of(write_span, "write").is_some() {
+                    } else if is_expn_of(write_call.span, "write").is_some() {
                         Some("write")
                     } else {
                         None
@@ -70,7 +67,8 @@ impl<'tcx> LateLintPass<'tcx> for ExplicitWrite {
                 // We need to remove the last trailing newline from the string because the
                 // underlying `fmt::write` function doesn't know whether `println!` or `print!` was
                 // used.
-                if let Some(mut write_output) = write_output_string(write_args) {
+                if let [write_output] = *format_args.format_string_symbols {
+                    let mut write_output = write_output.to_string();
                     if write_output.ends_with('\n') {
                         write_output.pop();
                     }
@@ -129,23 +127,3 @@ impl<'tcx> LateLintPass<'tcx> for ExplicitWrite {
         }
     }
 }
-
-// Extract the output string from the given `write_args`.
-fn write_output_string(write_args: &[Expr<'_>]) -> Option<String> {
-    if_chain! {
-        // Obtain the string that should be printed
-        if write_args.len() > 1;
-        if let ExprKind::Call(_, output_args) = write_args[1].kind;
-        if !output_args.is_empty();
-        if let ExprKind::AddrOf(BorrowKind::Ref, _, output_string_expr) = output_args[0].kind;
-        if let ExprKind::Array(string_exprs) = output_string_expr.kind;
-        // we only want to provide an automatic suggestion for simple (non-format) strings
-        if string_exprs.len() == 1;
-        if let ExprKind::Lit(ref lit) = string_exprs[0].kind;
-        if let LitKind::Str(ref write_output, _) = lit.node;
-        then {
-            return Some(write_output.to_string())
-        }
-    }
-    None
-}
diff --git a/clippy_lints/src/format.rs b/clippy_lints/src/format.rs
index de1b3ffecd0..ca3490d8eda 100644
--- a/clippy_lints/src/format.rs
+++ b/clippy_lints/src/format.rs
@@ -1,18 +1,16 @@
-use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::paths;
-use clippy_utils::source::{snippet, snippet_opt};
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::higher::FormatExpn;
+use clippy_utils::last_path_segment;
+use clippy_utils::source::{snippet_opt, snippet_with_applicability};
 use clippy_utils::sugg::Sugg;
-use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{is_expn_of, last_path_segment, match_def_path, match_function_call};
 use if_chain::if_chain;
-use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
-use rustc_hir::{Arm, BorrowKind, Expr, ExprKind, MatchSource, PatKind};
-use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_hir::{BorrowKind, Expr, ExprKind, QPath};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::source_map::Span;
-use rustc_span::sym;
 use rustc_span::symbol::kw;
+use rustc_span::{sym, Span};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for the use of `format!("string literal with no
@@ -45,131 +43,78 @@ declare_lint_pass!(UselessFormat => [USELESS_FORMAT]);
 
 impl<'tcx> LateLintPass<'tcx> for UselessFormat {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        let span = match is_expn_of(expr.span, "format") {
-            Some(s) if !s.from_expansion() => s,
+        let FormatExpn { call_site, format_args } = match FormatExpn::parse(expr) {
+            Some(e) if !e.call_site.from_expansion() => e,
             _ => return,
         };
 
-        // Operate on the only argument of `alloc::fmt::format`.
-        if let Some(sugg) = on_new_v1(cx, expr) {
-            span_useless_format(cx, span, "consider using `.to_string()`", sugg);
-        } else if let Some(sugg) = on_new_v1_fmt(cx, expr) {
-            span_useless_format(cx, span, "consider using `.to_string()`", sugg);
-        }
-    }
-}
-
-fn span_useless_format<T: LintContext>(cx: &T, span: Span, help: &str, mut sugg: String) {
-    let to_replace = span.source_callsite();
-
-    // The callsite span contains the statement semicolon for some reason.
-    let snippet = snippet(cx, to_replace, "..");
-    if snippet.ends_with(';') {
-        sugg.push(';');
-    }
-
-    span_lint_and_then(cx, USELESS_FORMAT, span, "useless use of `format!`", |diag| {
-        diag.span_suggestion(
-            to_replace,
-            help,
-            sugg,
-            Applicability::MachineApplicable, // snippet
-        );
-    });
-}
-
-fn on_argumentv1_new<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, arms: &'tcx [Arm<'_>]) -> Option<String> {
-    if_chain! {
-        if let ExprKind::AddrOf(BorrowKind::Ref, _, format_args) = expr.kind;
-        if let ExprKind::Array(elems) = arms[0].body.kind;
-        if elems.len() == 1;
-        if let Some(args) = match_function_call(cx, &elems[0], &paths::FMT_ARGUMENTV1_NEW);
-        // matches `core::fmt::Display::fmt`
-        if args.len() == 2;
-        if let ExprKind::Path(ref qpath) = args[1].kind;
-        if let Some(did) = cx.qpath_res(qpath, args[1].hir_id).opt_def_id();
-        if match_def_path(cx, did, &paths::DISPLAY_FMT_METHOD);
-        // check `(arg0,)` in match block
-        if let PatKind::Tuple(pats, None) = arms[0].pat.kind;
-        if pats.len() == 1;
-        then {
-            let ty = cx.typeck_results().pat_ty(pats[0]).peel_refs();
-            if *ty.kind() != rustc_middle::ty::Str && !is_type_diagnostic_item(cx, ty, sym::string_type) {
-                return None;
-            }
-            if let ExprKind::Lit(ref lit) = format_args.kind {
-                if let LitKind::Str(ref s, _) = lit.node {
-                    return Some(format!("{:?}.to_string()", s.as_str()));
+        let mut applicability = Applicability::MachineApplicable;
+        if format_args.value_args.is_empty() {
+            if_chain! {
+                if let [e] = &*format_args.format_string_parts;
+                if let ExprKind::Lit(lit) = &e.kind;
+                if let Some(s_src) = snippet_opt(cx, lit.span);
+                then {
+                    // Simulate macro expansion, converting {{ and }} to { and }.
+                    let s_expand = s_src.replace("{{", "{").replace("}}", "}");
+                    let sugg = format!("{}.to_string()", s_expand);
+                    span_useless_format(cx, call_site, sugg, applicability);
                 }
-            } else {
-                let sugg = Sugg::hir(cx, format_args, "<arg>");
-                if let ExprKind::MethodCall(path, _, _, _) = format_args.kind {
-                    if path.ident.name == sym!(to_string) {
-                        return Some(format!("{}", sugg));
-                    }
-                } else if let ExprKind::Binary(..) = format_args.kind {
-                    return Some(format!("{}", sugg));
+            }
+        } else if let [value] = *format_args.value_args {
+            if_chain! {
+                if format_args.format_string_symbols == [kw::Empty];
+                if match cx.typeck_results().expr_ty(value).peel_refs().kind() {
+                    ty::Adt(adt, _) => cx.tcx.is_diagnostic_item(sym::string_type, adt.did),
+                    ty::Str => true,
+                    _ => false,
+                };
+                if format_args.args.iter().all(|e| is_display_arg(e));
+                if format_args.fmt_expr.map_or(true, |e| check_unformatted(e));
+                then {
+                    let is_new_string = match value.kind {
+                        ExprKind::Binary(..) => true,
+                        ExprKind::MethodCall(path, ..) => path.ident.name.as_str() == "to_string",
+                        _ => false,
+                    };
+                    let sugg = if is_new_string {
+                        snippet_with_applicability(cx, value.span, "..", &mut applicability).into_owned()
+                    } else {
+                        let sugg = Sugg::hir_with_applicability(cx, value, "<arg>", &mut applicability);
+                        format!("{}.to_string()", sugg.maybe_par())
+                    };
+                    span_useless_format(cx, call_site, sugg, applicability);
                 }
-                return Some(format!("{}.to_string()", sugg.maybe_par()));
             }
-        }
+        };
     }
-    None
 }
 
-fn on_new_v1<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<String> {
-    if_chain! {
-        if let Some(args) = match_function_call(cx, expr, &paths::FMT_ARGUMENTS_NEW_V1);
-        if args.len() == 2;
-        // Argument 1 in `new_v1()`
-        if let ExprKind::AddrOf(BorrowKind::Ref, _, arr) = args[0].kind;
-        if let ExprKind::Array(pieces) = arr.kind;
-        if pieces.len() == 1;
-        if let ExprKind::Lit(ref lit) = pieces[0].kind;
-        if let LitKind::Str(ref s, _) = lit.node;
-        // Argument 2 in `new_v1()`
-        if let ExprKind::AddrOf(BorrowKind::Ref, _, arg1) = args[1].kind;
-        if let ExprKind::Match(matchee, arms, MatchSource::Normal) = arg1.kind;
-        if arms.len() == 1;
-        if let ExprKind::Tup(tup) = matchee.kind;
-        then {
-            // `format!("foo")` expansion contains `match () { () => [], }`
-            if tup.is_empty() {
-                if let Some(s_src) = snippet_opt(cx, lit.span) {
-                    // Simulate macro expansion, converting {{ and }} to { and }.
-                    let s_expand = s_src.replace("{{", "{").replace("}}", "}");
-                    return Some(format!("{}.to_string()", s_expand));
-                }
-            } else if s.as_str().is_empty() {
-                return on_argumentv1_new(cx, &tup[0], arms);
-            }
-        }
+fn span_useless_format(cx: &LateContext<'_>, span: Span, mut sugg: String, mut applicability: Applicability) {
+    // The callsite span contains the statement semicolon for some reason.
+    if snippet_with_applicability(cx, span, "..", &mut applicability).ends_with(';') {
+        sugg.push(';');
     }
-    None
+
+    span_lint_and_sugg(
+        cx,
+        USELESS_FORMAT,
+        span,
+        "useless use of `format!`",
+        "consider using `.to_string()`",
+        sugg,
+        applicability,
+    );
 }
 
-fn on_new_v1_fmt<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<String> {
+fn is_display_arg(expr: &Expr<'_>) -> bool {
     if_chain! {
-        if let Some(args) = match_function_call(cx, expr, &paths::FMT_ARGUMENTS_NEW_V1_FORMATTED);
-        if args.len() == 3;
-        if check_unformatted(&args[2]);
-        // Argument 1 in `new_v1_formatted()`
-        if let ExprKind::AddrOf(BorrowKind::Ref, _, arr) = args[0].kind;
-        if let ExprKind::Array(pieces) = arr.kind;
-        if pieces.len() == 1;
-        if let ExprKind::Lit(ref lit) = pieces[0].kind;
-        if let LitKind::Str(symbol, _) = lit.node;
-        if symbol == kw::Empty;
-        // Argument 2 in `new_v1_formatted()`
-        if let ExprKind::AddrOf(BorrowKind::Ref, _, arg1) = args[1].kind;
-        if let ExprKind::Match(matchee, arms, MatchSource::Normal) = arg1.kind;
-        if arms.len() == 1;
-        if let ExprKind::Tup(tup) = matchee.kind;
-        then {
-            return on_argumentv1_new(cx, &tup[0], arms);
-        }
+        if let ExprKind::Call(_, [_, fmt]) = expr.kind;
+        if let ExprKind::Path(QPath::Resolved(_, path)) = fmt.kind;
+        if let [.., t, _] = path.segments;
+        if t.ident.name.as_str() == "Display";
+        then { true } else { false }
     }
-    None
 }
 
 /// Checks if the expression matches
@@ -186,10 +131,9 @@ fn on_new_v1_fmt<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<S
 fn check_unformatted(expr: &Expr<'_>) -> bool {
     if_chain! {
         if let ExprKind::AddrOf(BorrowKind::Ref, _, expr) = expr.kind;
-        if let ExprKind::Array(exprs) = expr.kind;
-        if exprs.len() == 1;
+        if let ExprKind::Array([expr]) = expr.kind;
         // struct `core::fmt::rt::v1::Argument`
-        if let ExprKind::Struct(_, fields, _) = exprs[0].kind;
+        if let ExprKind::Struct(_, fields, _) = expr.kind;
         if let Some(format_field) = fields.iter().find(|f| f.ident.name == sym::format);
         // struct `core::fmt::rt::v1::FormatSpec`
         if let ExprKind::Struct(_, fields, _) = format_field.expr.kind;
diff --git a/clippy_lints/src/methods/expect_fun_call.rs b/clippy_lints/src/methods/expect_fun_call.rs
index 03cb41697d5..f8ee31a00df 100644
--- a/clippy_lints/src/methods/expect_fun_call.rs
+++ b/clippy_lints/src/methods/expect_fun_call.rs
@@ -1,8 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::is_expn_of;
-use clippy_utils::source::{snippet, snippet_with_applicability};
+use clippy_utils::higher::FormatExpn;
+use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::is_type_diagnostic_item;
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
@@ -94,27 +93,6 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, method_span: Spa
         }
     }
 
-    fn generate_format_arg_snippet(
-        cx: &LateContext<'_>,
-        a: &hir::Expr<'_>,
-        applicability: &mut Applicability,
-    ) -> Vec<String> {
-        if_chain! {
-            if let hir::ExprKind::AddrOf(hir::BorrowKind::Ref, _, format_arg) = a.kind;
-            if let hir::ExprKind::Match(format_arg_expr, _, _) = format_arg.kind;
-            if let hir::ExprKind::Tup(format_arg_expr_tup) = format_arg_expr.kind;
-
-            then {
-                format_arg_expr_tup
-                    .iter()
-                    .map(|a| snippet_with_applicability(cx, a.span, "..", applicability).into_owned())
-                    .collect()
-            } else {
-                unreachable!()
-            }
-        }
-    }
-
     fn is_call(node: &hir::ExprKind<'_>) -> bool {
         match node {
             hir::ExprKind::AddrOf(hir::BorrowKind::Ref, _, expr) => {
@@ -150,36 +128,22 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, method_span: Spa
     let mut applicability = Applicability::MachineApplicable;
 
     //Special handling for `format!` as arg_root
-    if_chain! {
-        if let hir::ExprKind::Block(block, None) = &arg_root.kind;
-        if block.stmts.len() == 1;
-        if let hir::StmtKind::Local(local) = &block.stmts[0].kind;
-        if let Some(arg_root) = &local.init;
-        if let hir::ExprKind::Call(inner_fun, inner_args) = arg_root.kind;
-        if is_expn_of(inner_fun.span, "format").is_some() && inner_args.len() == 1;
-        if let hir::ExprKind::Call(_, format_args) = &inner_args[0].kind;
-        then {
-            let fmt_spec = &format_args[0];
-            let fmt_args = &format_args[1];
-
-            let mut args = vec![snippet(cx, fmt_spec.span, "..").into_owned()];
-
-            args.extend(generate_format_arg_snippet(cx, fmt_args, &mut applicability));
-
-            let sugg = args.join(", ");
-
-            span_lint_and_sugg(
-                cx,
-                EXPECT_FUN_CALL,
-                span_replace_word,
-                &format!("use of `{}` followed by a function call", name),
-                "try this",
-                format!("unwrap_or_else({} panic!({}))", closure_args, sugg),
-                applicability,
-            );
-
-            return;
-        }
+    if let Some(format_expn) = FormatExpn::parse(arg_root) {
+        let span = match *format_expn.format_args.value_args {
+            [] => format_expn.format_args.format_string_span,
+            [.., last] => format_expn.format_args.format_string_span.to(last.span),
+        };
+        let sugg = snippet_with_applicability(cx, span, "..", &mut applicability);
+        span_lint_and_sugg(
+            cx,
+            EXPECT_FUN_CALL,
+            span_replace_word,
+            &format!("use of `{}` followed by a function call", name),
+            "try this",
+            format!("unwrap_or_else({} panic!({}))", closure_args, sugg),
+            applicability,
+        );
+        return;
     }
 
     let mut arg_root_snippet: Cow<'_, _> = snippet_with_applicability(cx, arg_root.span, "..", &mut applicability);
diff --git a/clippy_utils/src/higher.rs b/clippy_utils/src/higher.rs
index 8be36756b33..5ffd88f4140 100644
--- a/clippy_utils/src/higher.rs
+++ b/clippy_utils/src/higher.rs
@@ -5,11 +5,11 @@
 
 use crate::{is_expn_of, match_def_path, paths};
 use if_chain::if_chain;
-use rustc_ast::ast;
+use rustc_ast::ast::{self, LitKind};
 use rustc_hir as hir;
 use rustc_hir::{BorrowKind, Expr, ExprKind, StmtKind, UnOp};
 use rustc_lint::LateContext;
-use rustc_span::source_map::Span;
+use rustc_span::{sym, ExpnKind, Span, Symbol};
 
 /// Converts a hir binary operator to the corresponding `ast` type.
 #[must_use]
@@ -266,3 +266,107 @@ pub fn extract_assert_macro_args<'tcx>(e: &'tcx Expr<'tcx>) -> Option<Vec<&'tcx
     }
     None
 }
+
+/// A parsed `format!` expansion
+pub struct FormatExpn<'tcx> {
+    /// Span of `format!(..)`
+    pub call_site: Span,
+    /// Inner `format_args!` expansion
+    pub format_args: FormatArgsExpn<'tcx>,
+}
+
+impl FormatExpn<'tcx> {
+    /// Parses an expanded `format!` invocation
+    pub fn parse(expr: &'tcx Expr<'tcx>) -> Option<Self> {
+        if_chain! {
+            if let ExprKind::Block(block, _) = expr.kind;
+            if let [stmt] = block.stmts;
+            if let StmtKind::Local(local) = stmt.kind;
+            if let Some(init) = local.init;
+            if let ExprKind::Call(_, [format_args]) = init.kind;
+            let expn_data = expr.span.ctxt().outer_expn_data();
+            if let ExpnKind::Macro { name: sym::format, .. } = expn_data.kind;
+            if let Some(format_args) = FormatArgsExpn::parse(format_args);
+            then {
+                Some(FormatExpn {
+                    call_site: expn_data.call_site,
+                    format_args,
+                })
+            } else {
+                None
+            }
+        }
+    }
+}
+
+/// A parsed `format_args!` expansion
+pub struct FormatArgsExpn<'tcx> {
+    /// Span of the first argument, the format string
+    pub format_string_span: Span,
+    /// Values passed after the format string
+    pub value_args: Vec<&'tcx Expr<'tcx>>,
+
+    /// String literal expressions which represent the format string split by "{}"
+    pub format_string_parts: &'tcx [Expr<'tcx>],
+    /// Symbols corresponding to [`format_string_parts`]
+    pub format_string_symbols: Vec<Symbol>,
+    /// Expressions like `ArgumentV1::new(arg0, Debug::fmt)`
+    pub args: &'tcx [Expr<'tcx>],
+    /// The final argument passed to `Arguments::new_v1_formatted`, if applicable
+    pub fmt_expr: Option<&'tcx Expr<'tcx>>,
+}
+
+impl FormatArgsExpn<'tcx> {
+    /// Parses an expanded `format_args!` or `format_args_nl!` invocation
+    pub fn parse(expr: &'tcx Expr<'tcx>) -> Option<Self> {
+        if_chain! {
+            if let ExpnKind::Macro { name, .. } = expr.span.ctxt().outer_expn_data().kind;
+            let name = name.as_str();
+            if name.ends_with("format_args") || name.ends_with("format_args_nl");
+            if let ExprKind::Call(_, args) = expr.kind;
+            if let Some((strs_ref, args, fmt_expr)) = match args {
+                // Arguments::new_v1
+                [strs_ref, args] => Some((strs_ref, args, None)),
+                // Arguments::new_v1_formatted
+                [strs_ref, args, fmt_expr] => Some((strs_ref, args, Some(fmt_expr))),
+                _ => None,
+            };
+            if let ExprKind::AddrOf(BorrowKind::Ref, _, strs_arr) = strs_ref.kind;
+            if let ExprKind::Array(format_string_parts) = strs_arr.kind;
+            if let Some(format_string_symbols) = format_string_parts
+                .iter()
+                .map(|e| {
+                    if let ExprKind::Lit(lit) = &e.kind {
+                        if let LitKind::Str(symbol, _style) = lit.node {
+                            return Some(symbol);
+                        }
+                    }
+                    None
+                })
+                .collect();
+            if let ExprKind::AddrOf(BorrowKind::Ref, _, args) = args.kind;
+            if let ExprKind::Match(args, [arm], _) = args.kind;
+            if let ExprKind::Tup(value_args) = args.kind;
+            if let Some(value_args) = value_args
+                .iter()
+                .map(|e| match e.kind {
+                    ExprKind::AddrOf(_, _, e) => Some(e),
+                    _ => None,
+                })
+                .collect();
+            if let ExprKind::Array(args) = arm.body.kind;
+            then {
+                Some(FormatArgsExpn {
+                    format_string_span: strs_ref.span,
+                    value_args,
+                    format_string_parts,
+                    format_string_symbols,
+                    args,
+                    fmt_expr,
+                })
+            } else {
+                None
+            }
+        }
+    }
+}
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index 9ebfbd6b423..c960eec3064 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -38,7 +38,6 @@ pub const DEFAULT_TRAIT_METHOD: [&str; 4] = ["core", "default", "Default", "defa
 pub const DEREF_MUT_TRAIT_METHOD: [&str; 5] = ["core", "ops", "deref", "DerefMut", "deref_mut"];
 pub const DEREF_TRAIT_METHOD: [&str; 5] = ["core", "ops", "deref", "Deref", "deref"];
 pub const DIR_BUILDER: [&str; 3] = ["std", "fs", "DirBuilder"];
-pub const DISPLAY_FMT_METHOD: [&str; 4] = ["core", "fmt", "Display", "fmt"];
 pub const DISPLAY_TRAIT: [&str; 3] = ["core", "fmt", "Display"];
 pub const DOUBLE_ENDED_ITERATOR: [&str; 4] = ["core", "iter", "traits", "DoubleEndedIterator"];
 pub const DROP: [&str; 3] = ["core", "mem", "drop"];
@@ -50,9 +49,6 @@ pub const F32_EPSILON: [&str; 4] = ["core", "f32", "<impl f32>", "EPSILON"];
 pub const F64_EPSILON: [&str; 4] = ["core", "f64", "<impl f64>", "EPSILON"];
 pub const FILE: [&str; 3] = ["std", "fs", "File"];
 pub const FILE_TYPE: [&str; 3] = ["std", "fs", "FileType"];
-pub const FMT_ARGUMENTS_NEW_V1: [&str; 4] = ["core", "fmt", "Arguments", "new_v1"];
-pub const FMT_ARGUMENTS_NEW_V1_FORMATTED: [&str; 4] = ["core", "fmt", "Arguments", "new_v1_formatted"];
-pub const FMT_ARGUMENTV1_NEW: [&str; 4] = ["core", "fmt", "ArgumentV1", "new"];
 pub const FROM_FROM: [&str; 4] = ["core", "convert", "From", "from"];
 pub const FROM_ITERATOR: [&str; 5] = ["core", "iter", "traits", "collect", "FromIterator"];
 pub const FROM_ITERATOR_METHOD: [&str; 6] = ["core", "iter", "traits", "collect", "FromIterator", "from_iter"];
-- 
cgit 1.4.1-3-g733a5


From 73ffae6ea1b8639050ca19db9732a7a25daae482 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Sun, 11 Jul 2021 20:21:21 -0500
Subject: Reduce redundant code

---
 clippy_lints/src/explicit_write.rs | 71 +++++++++++++-------------------------
 1 file changed, 24 insertions(+), 47 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/explicit_write.rs b/clippy_lints/src/explicit_write.rs
index eaea70a4294..9a07d422b63 100644
--- a/clippy_lints/src/explicit_write.rs
+++ b/clippy_lints/src/explicit_write.rs
@@ -67,62 +67,39 @@ impl<'tcx> LateLintPass<'tcx> for ExplicitWrite {
                 // We need to remove the last trailing newline from the string because the
                 // underlying `fmt::write` function doesn't know whether `println!` or `print!` was
                 // used.
+                let (used, sugg_mac) = if let Some(macro_name) = calling_macro {
+                    (
+                        format!("{}!({}(), ...)", macro_name, dest_name),
+                        macro_name.replace("write", "print"),
+                    )
+                } else {
+                    (
+                        format!("{}().write_fmt(...)", dest_name),
+                        "print".into(),
+                    )
+                };
+                let msg = format!("use of `{}.unwrap()`", used);
                 if let [write_output] = *format_args.format_string_symbols {
                     let mut write_output = write_output.to_string();
                     if write_output.ends_with('\n') {
                         write_output.pop();
                     }
 
-                    if let Some(macro_name) = calling_macro {
-                        span_lint_and_sugg(
-                            cx,
-                            EXPLICIT_WRITE,
-                            expr.span,
-                            &format!(
-                                "use of `{}!({}(), ...).unwrap()`",
-                                macro_name,
-                                dest_name
-                            ),
-                            "try this",
-                            format!("{}{}!(\"{}\")", prefix, macro_name.replace("write", "print"), write_output.escape_default()),
-                            Applicability::MachineApplicable
-                        );
-                    } else {
-                        span_lint_and_sugg(
-                            cx,
-                            EXPLICIT_WRITE,
-                            expr.span,
-                            &format!("use of `{}().write_fmt(...).unwrap()`", dest_name),
-                            "try this",
-                            format!("{}print!(\"{}\")", prefix, write_output.escape_default()),
-                            Applicability::MachineApplicable
-                        );
-                    }
+                    let sugg = format!("{}{}!(\"{}\")", prefix, sugg_mac, write_output.escape_default());
+                    span_lint_and_sugg(
+                        cx,
+                        EXPLICIT_WRITE,
+                        expr.span,
+                        &msg,
+                        "try this",
+                        sugg,
+                        Applicability::MachineApplicable
+                    );
                 } else {
                     // We don't have a proper suggestion
-                    if let Some(macro_name) = calling_macro {
-                        span_lint(
-                            cx,
-                            EXPLICIT_WRITE,
-                            expr.span,
-                            &format!(
-                                "use of `{}!({}(), ...).unwrap()`. Consider using `{}{}!` instead",
-                                macro_name,
-                                dest_name,
-                                prefix,
-                                macro_name.replace("write", "print")
-                            )
-                        );
-                    } else {
-                        span_lint(
-                            cx,
-                            EXPLICIT_WRITE,
-                            expr.span,
-                            &format!("use of `{}().write_fmt(...).unwrap()`. Consider using `{}print!` instead", dest_name, prefix),
-                        );
-                    }
+                    let msg = format!("{}. Consider using `{}{}!` instead", msg, prefix, sugg_mac);
+                    span_lint(cx, EXPLICIT_WRITE, expr.span, &msg);
                 }
-
             }
         }
     }
-- 
cgit 1.4.1-3-g733a5


From 306f9e843d5474eb2de6907b3ca6941dc918ea23 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Sun, 11 Jul 2021 20:30:19 -0500
Subject: Split a lint message into help

---
 clippy_lints/src/explicit_write.rs         | 6 +++---
 tests/ui/explicit_write_non_rustfix.stderr | 3 ++-
 2 files changed, 5 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/explicit_write.rs b/clippy_lints/src/explicit_write.rs
index 9a07d422b63..66724294804 100644
--- a/clippy_lints/src/explicit_write.rs
+++ b/clippy_lints/src/explicit_write.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg};
+use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg};
 use clippy_utils::higher::FormatArgsExpn;
 use clippy_utils::{is_expn_of, match_function_call, paths};
 use if_chain::if_chain;
@@ -97,8 +97,8 @@ impl<'tcx> LateLintPass<'tcx> for ExplicitWrite {
                     );
                 } else {
                     // We don't have a proper suggestion
-                    let msg = format!("{}. Consider using `{}{}!` instead", msg, prefix, sugg_mac);
-                    span_lint(cx, EXPLICIT_WRITE, expr.span, &msg);
+                    let help = format!("consider using `{}{}!` instead", prefix, sugg_mac);
+                    span_lint_and_help(cx, EXPLICIT_WRITE, expr.span, &msg, None, &help);
                 }
             }
         }
diff --git a/tests/ui/explicit_write_non_rustfix.stderr b/tests/ui/explicit_write_non_rustfix.stderr
index 77cadb99bb5..b94ec6403dd 100644
--- a/tests/ui/explicit_write_non_rustfix.stderr
+++ b/tests/ui/explicit_write_non_rustfix.stderr
@@ -1,10 +1,11 @@
-error: use of `writeln!(stderr(), ...).unwrap()`. Consider using `eprintln!` instead
+error: use of `writeln!(stderr(), ...).unwrap()`
   --> $DIR/explicit_write_non_rustfix.rs:7:5
    |
 LL |     writeln!(std::io::stderr(), "foo {}", bar).unwrap();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::explicit-write` implied by `-D warnings`
+   = help: consider using `eprintln!` instead
 
 error: aborting due to previous error
 
-- 
cgit 1.4.1-3-g733a5


From 25e4c7d73fd4c929208edf151c827f6c97318374 Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Tue, 13 Jul 2021 22:57:47 +0900
Subject: `default_numeric_fallback`: Add rustfix tests

---
 clippy_lints/src/default_numeric_fallback.rs |  20 ++-
 tests/ui/default_numeric_fallback_f64.fixed  | 174 +++++++++++++++++++++++++++
 tests/ui/default_numeric_fallback_f64.rs     |   2 +-
 tests/ui/default_numeric_fallback_f64.stderr |  44 +++----
 tests/ui/default_numeric_fallback_i32.fixed  | 173 ++++++++++++++++++++++++++
 tests/ui/default_numeric_fallback_i32.rs     |   1 +
 tests/ui/default_numeric_fallback_i32.stderr |  50 ++++----
 7 files changed, 411 insertions(+), 53 deletions(-)
 create mode 100644 tests/ui/default_numeric_fallback_f64.fixed
 create mode 100644 tests/ui/default_numeric_fallback_i32.fixed

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/default_numeric_fallback.rs b/clippy_lints/src/default_numeric_fallback.rs
index ea28644b9a4..e719a1b0abf 100644
--- a/clippy_lints/src/default_numeric_fallback.rs
+++ b/clippy_lints/src/default_numeric_fallback.rs
@@ -1,5 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::source::snippet;
+use clippy_utils::numeric_literal;
+use clippy_utils::source::snippet_opt;
 use if_chain::if_chain;
 use rustc_ast::ast::{LitFloatType, LitIntType, LitKind};
 use rustc_errors::Applicability;
@@ -80,14 +81,23 @@ impl<'a, 'tcx> NumericFallbackVisitor<'a, 'tcx> {
                             LitKind::Int(_, LitIntType::Unsuffixed) | LitKind::Float(_, LitFloatType::Unsuffixed));
                 if !ty_bound.is_numeric();
                 then {
-                    let suffix = match lit_ty.kind() {
-                        ty::Int(IntTy::I32) => "i32",
-                        ty::Float(FloatTy::F64) => "f64",
+                    let (suffix, is_float) = match lit_ty.kind() {
+                        ty::Int(IntTy::I32) => ("i32", false),
+                        ty::Float(FloatTy::F64) => ("f64", true),
                         // Default numeric fallback never results in other types.
                         _ => return,
                     };
 
-                    let sugg = format!("{}_{}", snippet(self.cx, lit.span, ""), suffix);
+                    let src = if let Some(src) = snippet_opt(self.cx, lit.span) {
+                        src
+                    } else {
+                        match lit.node {
+                            LitKind::Int(src, _) => format!("{}", src),
+                            LitKind::Float(src, _) => format!("{}", src),
+                            _ => return,
+                        }
+                    };
+                    let sugg = numeric_literal::format(&src, Some(suffix), is_float);
                     span_lint_and_sugg(
                         self.cx,
                         DEFAULT_NUMERIC_FALLBACK,
diff --git a/tests/ui/default_numeric_fallback_f64.fixed b/tests/ui/default_numeric_fallback_f64.fixed
new file mode 100644
index 00000000000..1b0e7544e79
--- /dev/null
+++ b/tests/ui/default_numeric_fallback_f64.fixed
@@ -0,0 +1,174 @@
+// run-rustfix
+// aux-build:macro_rules.rs
+
+#![warn(clippy::default_numeric_fallback)]
+#![allow(unused)]
+#![allow(clippy::never_loop)]
+#![allow(clippy::no_effect)]
+#![allow(clippy::unnecessary_operation)]
+#![allow(clippy::branches_sharing_code)]
+#![allow(clippy::match_single_binding)]
+
+#[macro_use]
+extern crate macro_rules;
+
+mod basic_expr {
+    fn test() {
+        // Should lint unsuffixed literals typed `f64`.
+        let x = 0.12_f64;
+        let x = [1.0_f64, 2.0_f64, 3.0_f64];
+        let x = if true { (1.0_f64, 2.0_f64) } else { (3.0_f64, 4.0_f64) };
+        let x = match 1.0_f64 {
+            _ => 1.0_f64,
+        };
+
+        // Should NOT lint suffixed literals.
+        let x = 0.12_f64;
+
+        // Should NOT lint literals in init expr if `Local` has a type annotation.
+        let x: f64 = 0.1;
+        let x: [f64; 3] = [1., 2., 3.];
+        let x: (f64, f64) = if true { (1., 2.) } else { (3., 4.) };
+        let x: _ = 1.;
+    }
+}
+
+mod nested_local {
+    fn test() {
+        let x: _ = {
+            // Should lint this because this literal is not bound to any types.
+            let y = 1.0_f64;
+
+            // Should NOT lint this because this literal is bound to `_` of outer `Local`.
+            1.
+        };
+
+        let x: _ = if true {
+            // Should lint this because this literal is not bound to any types.
+            let y = 1.0_f64;
+
+            // Should NOT lint this because this literal is bound to `_` of outer `Local`.
+            1.
+        } else {
+            // Should lint this because this literal is not bound to any types.
+            let y = 1.0_f64;
+
+            // Should NOT lint this because this literal is bound to `_` of outer `Local`.
+            2.
+        };
+    }
+}
+
+mod function_def {
+    fn ret_f64() -> f64 {
+        // Even though the output type is specified,
+        // this unsuffixed literal is linted to reduce heuristics and keep codebase simple.
+        1.0_f64
+    }
+
+    fn test() {
+        // Should lint this because return type is inferred to `f64` and NOT bound to a concrete
+        // type.
+        let f = || -> _ { 1.0_f64 };
+
+        // Even though the output type is specified,
+        // this unsuffixed literal is linted to reduce heuristics and keep codebase simple.
+        let f = || -> f64 { 1.0_f64 };
+    }
+}
+
+mod function_calls {
+    fn concrete_arg(f: f64) {}
+
+    fn generic_arg<T>(t: T) {}
+
+    fn test() {
+        // Should NOT lint this because the argument type is bound to a concrete type.
+        concrete_arg(1.);
+
+        // Should lint this because the argument type is inferred to `f64` and NOT bound to a concrete type.
+        generic_arg(1.0_f64);
+
+        // Should lint this because the argument type is inferred to `f64` and NOT bound to a concrete type.
+        let x: _ = generic_arg(1.0_f64);
+    }
+}
+
+mod struct_ctor {
+    struct ConcreteStruct {
+        x: f64,
+    }
+
+    struct GenericStruct<T> {
+        x: T,
+    }
+
+    fn test() {
+        // Should NOT lint this because the field type is bound to a concrete type.
+        ConcreteStruct { x: 1. };
+
+        // Should lint this because the field type is inferred to `f64` and NOT bound to a concrete type.
+        GenericStruct { x: 1.0_f64 };
+
+        // Should lint this because the field type is inferred to `f64` and NOT bound to a concrete type.
+        let _ = GenericStruct { x: 1.0_f64 };
+    }
+}
+
+mod enum_ctor {
+    enum ConcreteEnum {
+        X(f64),
+    }
+
+    enum GenericEnum<T> {
+        X(T),
+    }
+
+    fn test() {
+        // Should NOT lint this because the field type is bound to a concrete type.
+        ConcreteEnum::X(1.);
+
+        // Should lint this because the field type is inferred to `f64` and NOT bound to a concrete type.
+        GenericEnum::X(1.0_f64);
+    }
+}
+
+mod method_calls {
+    struct StructForMethodCallTest {}
+
+    impl StructForMethodCallTest {
+        fn concrete_arg(&self, f: f64) {}
+
+        fn generic_arg<T>(&self, t: T) {}
+    }
+
+    fn test() {
+        let s = StructForMethodCallTest {};
+
+        // Should NOT lint this because the argument type is bound to a concrete type.
+        s.concrete_arg(1.);
+
+        // Should lint this because the argument type is bound to a concrete type.
+        s.generic_arg(1.0_f64);
+    }
+}
+
+mod in_macro {
+    macro_rules! internal_macro {
+        () => {
+            let x = 22.0_f64;
+        };
+    }
+
+    // Should lint in internal macro.
+    fn internal() {
+        internal_macro!();
+    }
+
+    // Should NOT lint in external macro.
+    fn external() {
+        default_numeric_fallback!();
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/default_numeric_fallback_f64.rs b/tests/ui/default_numeric_fallback_f64.rs
index fff6f95950d..e9687777bbd 100644
--- a/tests/ui/default_numeric_fallback_f64.rs
+++ b/tests/ui/default_numeric_fallback_f64.rs
@@ -1,3 +1,4 @@
+// run-rustfix
 // aux-build:macro_rules.rs
 
 #![warn(clippy::default_numeric_fallback)]
@@ -6,7 +7,6 @@
 #![allow(clippy::no_effect)]
 #![allow(clippy::unnecessary_operation)]
 #![allow(clippy::branches_sharing_code)]
-#![allow(clippy::branches_sharing_code)]
 #![allow(clippy::match_single_binding)]
 
 #[macro_use]
diff --git a/tests/ui/default_numeric_fallback_f64.stderr b/tests/ui/default_numeric_fallback_f64.stderr
index aed44843d89..961c7cb57c5 100644
--- a/tests/ui/default_numeric_fallback_f64.stderr
+++ b/tests/ui/default_numeric_fallback_f64.stderr
@@ -10,133 +10,133 @@ error: default numeric fallback might occur
   --> $DIR/default_numeric_fallback_f64.rs:19:18
    |
 LL |         let x = [1., 2., 3.];
-   |                  ^^ help: consider adding suffix: `1._f64`
+   |                  ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
   --> $DIR/default_numeric_fallback_f64.rs:19:22
    |
 LL |         let x = [1., 2., 3.];
-   |                      ^^ help: consider adding suffix: `2._f64`
+   |                      ^^ help: consider adding suffix: `2.0_f64`
 
 error: default numeric fallback might occur
   --> $DIR/default_numeric_fallback_f64.rs:19:26
    |
 LL |         let x = [1., 2., 3.];
-   |                          ^^ help: consider adding suffix: `3._f64`
+   |                          ^^ help: consider adding suffix: `3.0_f64`
 
 error: default numeric fallback might occur
   --> $DIR/default_numeric_fallback_f64.rs:20:28
    |
 LL |         let x = if true { (1., 2.) } else { (3., 4.) };
-   |                            ^^ help: consider adding suffix: `1._f64`
+   |                            ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
   --> $DIR/default_numeric_fallback_f64.rs:20:32
    |
 LL |         let x = if true { (1., 2.) } else { (3., 4.) };
-   |                                ^^ help: consider adding suffix: `2._f64`
+   |                                ^^ help: consider adding suffix: `2.0_f64`
 
 error: default numeric fallback might occur
   --> $DIR/default_numeric_fallback_f64.rs:20:46
    |
 LL |         let x = if true { (1., 2.) } else { (3., 4.) };
-   |                                              ^^ help: consider adding suffix: `3._f64`
+   |                                              ^^ help: consider adding suffix: `3.0_f64`
 
 error: default numeric fallback might occur
   --> $DIR/default_numeric_fallback_f64.rs:20:50
    |
 LL |         let x = if true { (1., 2.) } else { (3., 4.) };
-   |                                                  ^^ help: consider adding suffix: `4._f64`
+   |                                                  ^^ help: consider adding suffix: `4.0_f64`
 
 error: default numeric fallback might occur
   --> $DIR/default_numeric_fallback_f64.rs:21:23
    |
 LL |         let x = match 1. {
-   |                       ^^ help: consider adding suffix: `1._f64`
+   |                       ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
   --> $DIR/default_numeric_fallback_f64.rs:22:18
    |
 LL |             _ => 1.,
-   |                  ^^ help: consider adding suffix: `1._f64`
+   |                  ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
   --> $DIR/default_numeric_fallback_f64.rs:40:21
    |
 LL |             let y = 1.;
-   |                     ^^ help: consider adding suffix: `1._f64`
+   |                     ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
   --> $DIR/default_numeric_fallback_f64.rs:48:21
    |
 LL |             let y = 1.;
-   |                     ^^ help: consider adding suffix: `1._f64`
+   |                     ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
   --> $DIR/default_numeric_fallback_f64.rs:54:21
    |
 LL |             let y = 1.;
-   |                     ^^ help: consider adding suffix: `1._f64`
+   |                     ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
   --> $DIR/default_numeric_fallback_f64.rs:66:9
    |
 LL |         1.
-   |         ^^ help: consider adding suffix: `1._f64`
+   |         ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
   --> $DIR/default_numeric_fallback_f64.rs:72:27
    |
 LL |         let f = || -> _ { 1. };
-   |                           ^^ help: consider adding suffix: `1._f64`
+   |                           ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
   --> $DIR/default_numeric_fallback_f64.rs:76:29
    |
 LL |         let f = || -> f64 { 1. };
-   |                             ^^ help: consider adding suffix: `1._f64`
+   |                             ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
   --> $DIR/default_numeric_fallback_f64.rs:90:21
    |
 LL |         generic_arg(1.);
-   |                     ^^ help: consider adding suffix: `1._f64`
+   |                     ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
   --> $DIR/default_numeric_fallback_f64.rs:93:32
    |
 LL |         let x: _ = generic_arg(1.);
-   |                                ^^ help: consider adding suffix: `1._f64`
+   |                                ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
   --> $DIR/default_numeric_fallback_f64.rs:111:28
    |
 LL |         GenericStruct { x: 1. };
-   |                            ^^ help: consider adding suffix: `1._f64`
+   |                            ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
   --> $DIR/default_numeric_fallback_f64.rs:114:36
    |
 LL |         let _ = GenericStruct { x: 1. };
-   |                                    ^^ help: consider adding suffix: `1._f64`
+   |                                    ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
   --> $DIR/default_numeric_fallback_f64.rs:132:24
    |
 LL |         GenericEnum::X(1.);
-   |                        ^^ help: consider adding suffix: `1._f64`
+   |                        ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
   --> $DIR/default_numeric_fallback_f64.rs:152:23
    |
 LL |         s.generic_arg(1.);
-   |                       ^^ help: consider adding suffix: `1._f64`
+   |                       ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
   --> $DIR/default_numeric_fallback_f64.rs:159:21
    |
 LL |             let x = 22.;
-   |                     ^^^ help: consider adding suffix: `22._f64`
+   |                     ^^^ help: consider adding suffix: `22.0_f64`
 ...
 LL |         internal_macro!();
    |         ------------------ in this macro invocation
diff --git a/tests/ui/default_numeric_fallback_i32.fixed b/tests/ui/default_numeric_fallback_i32.fixed
new file mode 100644
index 00000000000..55c082fcb19
--- /dev/null
+++ b/tests/ui/default_numeric_fallback_i32.fixed
@@ -0,0 +1,173 @@
+// run-rustfix
+// aux-build:macro_rules.rs
+
+#![warn(clippy::default_numeric_fallback)]
+#![allow(unused)]
+#![allow(clippy::never_loop)]
+#![allow(clippy::no_effect)]
+#![allow(clippy::unnecessary_operation)]
+#![allow(clippy::branches_sharing_code)]
+
+#[macro_use]
+extern crate macro_rules;
+
+mod basic_expr {
+    fn test() {
+        // Should lint unsuffixed literals typed `i32`.
+        let x = 22_i32;
+        let x = [1_i32, 2_i32, 3_i32];
+        let x = if true { (1_i32, 2_i32) } else { (3_i32, 4_i32) };
+        let x = match 1_i32 {
+            1_i32 => 1_i32,
+            _ => 2_i32,
+        };
+
+        // Should NOT lint suffixed literals.
+        let x = 22_i32;
+
+        // Should NOT lint literals in init expr if `Local` has a type annotation.
+        let x: [i32; 3] = [1, 2, 3];
+        let x: (i32, i32) = if true { (1, 2) } else { (3, 4) };
+        let x: _ = 1;
+    }
+}
+
+mod nested_local {
+    fn test() {
+        let x: _ = {
+            // Should lint this because this literal is not bound to any types.
+            let y = 1_i32;
+
+            // Should NOT lint this because this literal is bound to `_` of outer `Local`.
+            1
+        };
+
+        let x: _ = if true {
+            // Should lint this because this literal is not bound to any types.
+            let y = 1_i32;
+
+            // Should NOT lint this because this literal is bound to `_` of outer `Local`.
+            1
+        } else {
+            // Should lint this because this literal is not bound to any types.
+            let y = 1_i32;
+
+            // Should NOT lint this because this literal is bound to `_` of outer `Local`.
+            2
+        };
+    }
+}
+
+mod function_def {
+    fn ret_i32() -> i32 {
+        // Even though the output type is specified,
+        // this unsuffixed literal is linted to reduce heuristics and keep codebase simple.
+        1_i32
+    }
+
+    fn test() {
+        // Should lint this because return type is inferred to `i32` and NOT bound to a concrete
+        // type.
+        let f = || -> _ { 1_i32 };
+
+        // Even though the output type is specified,
+        // this unsuffixed literal is linted to reduce heuristics and keep codebase simple.
+        let f = || -> i32 { 1_i32 };
+    }
+}
+
+mod function_calls {
+    fn concrete_arg(x: i32) {}
+
+    fn generic_arg<T>(t: T) {}
+
+    fn test() {
+        // Should NOT lint this because the argument type is bound to a concrete type.
+        concrete_arg(1);
+
+        // Should lint this because the argument type is inferred to `i32` and NOT bound to a concrete type.
+        generic_arg(1_i32);
+
+        // Should lint this because the argument type is inferred to `i32` and NOT bound to a concrete type.
+        let x: _ = generic_arg(1_i32);
+    }
+}
+
+mod struct_ctor {
+    struct ConcreteStruct {
+        x: i32,
+    }
+
+    struct GenericStruct<T> {
+        x: T,
+    }
+
+    fn test() {
+        // Should NOT lint this because the field type is bound to a concrete type.
+        ConcreteStruct { x: 1 };
+
+        // Should lint this because the field type is inferred to `i32` and NOT bound to a concrete type.
+        GenericStruct { x: 1_i32 };
+
+        // Should lint this because the field type is inferred to `i32` and NOT bound to a concrete type.
+        let _ = GenericStruct { x: 1_i32 };
+    }
+}
+
+mod enum_ctor {
+    enum ConcreteEnum {
+        X(i32),
+    }
+
+    enum GenericEnum<T> {
+        X(T),
+    }
+
+    fn test() {
+        // Should NOT lint this because the field type is bound to a concrete type.
+        ConcreteEnum::X(1);
+
+        // Should lint this because the field type is inferred to `i32` and NOT bound to a concrete type.
+        GenericEnum::X(1_i32);
+    }
+}
+
+mod method_calls {
+    struct StructForMethodCallTest {}
+
+    impl StructForMethodCallTest {
+        fn concrete_arg(&self, x: i32) {}
+
+        fn generic_arg<T>(&self, t: T) {}
+    }
+
+    fn test() {
+        let s = StructForMethodCallTest {};
+
+        // Should NOT lint this because the argument type is bound to a concrete type.
+        s.concrete_arg(1);
+
+        // Should lint this because the argument type is bound to a concrete type.
+        s.generic_arg(1_i32);
+    }
+}
+
+mod in_macro {
+    macro_rules! internal_macro {
+        () => {
+            let x = 22_i32;
+        };
+    }
+
+    // Should lint in internal macro.
+    fn internal() {
+        internal_macro!();
+    }
+
+    // Should NOT lint in external macro.
+    fn external() {
+        default_numeric_fallback!();
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/default_numeric_fallback_i32.rs b/tests/ui/default_numeric_fallback_i32.rs
index e84c70c344c..e0a4828ce9f 100644
--- a/tests/ui/default_numeric_fallback_i32.rs
+++ b/tests/ui/default_numeric_fallback_i32.rs
@@ -1,3 +1,4 @@
+// run-rustfix
 // aux-build:macro_rules.rs
 
 #![warn(clippy::default_numeric_fallback)]
diff --git a/tests/ui/default_numeric_fallback_i32.stderr b/tests/ui/default_numeric_fallback_i32.stderr
index 9b8f232366d..5edf48b2020 100644
--- a/tests/ui/default_numeric_fallback_i32.stderr
+++ b/tests/ui/default_numeric_fallback_i32.stderr
@@ -1,5 +1,5 @@
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:16:17
+  --> $DIR/default_numeric_fallback_i32.rs:17:17
    |
 LL |         let x = 22;
    |                 ^^ help: consider adding suffix: `22_i32`
@@ -7,145 +7,145 @@ LL |         let x = 22;
    = note: `-D clippy::default-numeric-fallback` implied by `-D warnings`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:17:18
+  --> $DIR/default_numeric_fallback_i32.rs:18:18
    |
 LL |         let x = [1, 2, 3];
    |                  ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:17:21
+  --> $DIR/default_numeric_fallback_i32.rs:18:21
    |
 LL |         let x = [1, 2, 3];
    |                     ^ help: consider adding suffix: `2_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:17:24
+  --> $DIR/default_numeric_fallback_i32.rs:18:24
    |
 LL |         let x = [1, 2, 3];
    |                        ^ help: consider adding suffix: `3_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:18:28
+  --> $DIR/default_numeric_fallback_i32.rs:19:28
    |
 LL |         let x = if true { (1, 2) } else { (3, 4) };
    |                            ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:18:31
+  --> $DIR/default_numeric_fallback_i32.rs:19:31
    |
 LL |         let x = if true { (1, 2) } else { (3, 4) };
    |                               ^ help: consider adding suffix: `2_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:18:44
+  --> $DIR/default_numeric_fallback_i32.rs:19:44
    |
 LL |         let x = if true { (1, 2) } else { (3, 4) };
    |                                            ^ help: consider adding suffix: `3_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:18:47
+  --> $DIR/default_numeric_fallback_i32.rs:19:47
    |
 LL |         let x = if true { (1, 2) } else { (3, 4) };
    |                                               ^ help: consider adding suffix: `4_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:19:23
+  --> $DIR/default_numeric_fallback_i32.rs:20:23
    |
 LL |         let x = match 1 {
    |                       ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:20:13
+  --> $DIR/default_numeric_fallback_i32.rs:21:13
    |
 LL |             1 => 1,
    |             ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:20:18
+  --> $DIR/default_numeric_fallback_i32.rs:21:18
    |
 LL |             1 => 1,
    |                  ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:21:18
+  --> $DIR/default_numeric_fallback_i32.rs:22:18
    |
 LL |             _ => 2,
    |                  ^ help: consider adding suffix: `2_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:38:21
+  --> $DIR/default_numeric_fallback_i32.rs:39:21
    |
 LL |             let y = 1;
    |                     ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:46:21
+  --> $DIR/default_numeric_fallback_i32.rs:47:21
    |
 LL |             let y = 1;
    |                     ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:52:21
+  --> $DIR/default_numeric_fallback_i32.rs:53:21
    |
 LL |             let y = 1;
    |                     ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:64:9
+  --> $DIR/default_numeric_fallback_i32.rs:65:9
    |
 LL |         1
    |         ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:70:27
+  --> $DIR/default_numeric_fallback_i32.rs:71:27
    |
 LL |         let f = || -> _ { 1 };
    |                           ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:74:29
+  --> $DIR/default_numeric_fallback_i32.rs:75:29
    |
 LL |         let f = || -> i32 { 1 };
    |                             ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:88:21
+  --> $DIR/default_numeric_fallback_i32.rs:89:21
    |
 LL |         generic_arg(1);
    |                     ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:91:32
+  --> $DIR/default_numeric_fallback_i32.rs:92:32
    |
 LL |         let x: _ = generic_arg(1);
    |                                ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:109:28
+  --> $DIR/default_numeric_fallback_i32.rs:110:28
    |
 LL |         GenericStruct { x: 1 };
    |                            ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:112:36
+  --> $DIR/default_numeric_fallback_i32.rs:113:36
    |
 LL |         let _ = GenericStruct { x: 1 };
    |                                    ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:130:24
+  --> $DIR/default_numeric_fallback_i32.rs:131:24
    |
 LL |         GenericEnum::X(1);
    |                        ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:150:23
+  --> $DIR/default_numeric_fallback_i32.rs:151:23
    |
 LL |         s.generic_arg(1);
    |                       ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:157:21
+  --> $DIR/default_numeric_fallback_i32.rs:158:21
    |
 LL |             let x = 22;
    |                     ^^ help: consider adding suffix: `22_i32`
-- 
cgit 1.4.1-3-g733a5


From e8f57c3ac4d57988e610ef6645d867ea76e8f25d Mon Sep 17 00:00:00 2001
From: Thomas Otto <th1000s@posteo.net>
Date: Thu, 13 May 2021 22:53:31 +0200
Subject: No longer suggest inserting or appending an underscore

changelog: [`similar_names`] lint no longer suggests to insert or add an underscore
to "fix" too similar names
---
 clippy_lints/src/non_expressive_names.rs | 14 --------------
 tests/ui/similar_names.stderr            | 20 --------------------
 2 files changed, 34 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/non_expressive_names.rs b/clippy_lints/src/non_expressive_names.rs
index b81f8d24a33..7183a7c3858 100644
--- a/clippy_lints/src/non_expressive_names.rs
+++ b/clippy_lints/src/non_expressive_names.rs
@@ -217,7 +217,6 @@ impl<'a, 'tcx, 'b> SimilarNamesNameVisitor<'a, 'tcx, 'b> {
             if allowed_to_be_similar(&interned_name, existing_name.exemptions) {
                 continue;
             }
-            let mut split_at = None;
             match existing_name.len.cmp(&count) {
                 Ordering::Greater => {
                     if existing_name.len - count != 1
@@ -268,7 +267,6 @@ impl<'a, 'tcx, 'b> SimilarNamesNameVisitor<'a, 'tcx, 'b> {
                                 // or too many chars differ (foo_x, boo_y) or (foox, booy)
                                 continue;
                             }
-                            split_at = interned_name.char_indices().rev().next().map(|(i, _)| i);
                         }
                     } else {
                         let second_i = interned_chars.next().expect("we know we have at least two chars");
@@ -281,7 +279,6 @@ impl<'a, 'tcx, 'b> SimilarNamesNameVisitor<'a, 'tcx, 'b> {
                             // or too many chars differ (x_foo, y_boo) or (xfoo, yboo)
                             continue;
                         }
-                        split_at = interned_name.chars().next().map(char::len_utf8);
                     }
                 },
             }
@@ -292,17 +289,6 @@ impl<'a, 'tcx, 'b> SimilarNamesNameVisitor<'a, 'tcx, 'b> {
                 "binding's name is too similar to existing binding",
                 |diag| {
                     diag.span_note(existing_name.span, "existing binding defined here");
-                    if let Some(split) = split_at {
-                        diag.span_help(
-                            ident.span,
-                            &format!(
-                                "separate the discriminating character by an \
-                                 underscore like: `{}_{}`",
-                                &interned_name[..split],
-                                &interned_name[split..]
-                            ),
-                        );
-                    }
                 },
             );
             return;
diff --git a/tests/ui/similar_names.stderr b/tests/ui/similar_names.stderr
index a7eb2be0778..b24accd962a 100644
--- a/tests/ui/similar_names.stderr
+++ b/tests/ui/similar_names.stderr
@@ -10,11 +10,6 @@ note: existing binding defined here
    |
 LL |     let apple: i32;
    |         ^^^^^
-help: separate the discriminating character by an underscore like: `b_pple`
-  --> $DIR/similar_names.rs:15:9
-   |
-LL |     let bpple: i32;
-   |         ^^^^^
 
 error: binding's name is too similar to existing binding
   --> $DIR/similar_names.rs:17:9
@@ -27,11 +22,6 @@ note: existing binding defined here
    |
 LL |     let apple: i32;
    |         ^^^^^
-help: separate the discriminating character by an underscore like: `c_pple`
-  --> $DIR/similar_names.rs:17:9
-   |
-LL |     let cpple: i32;
-   |         ^^^^^
 
 error: binding's name is too similar to existing binding
   --> $DIR/similar_names.rs:41:9
@@ -44,11 +34,6 @@ note: existing binding defined here
    |
 LL |     let blubx: i32;
    |         ^^^^^
-help: separate the discriminating character by an underscore like: `blub_y`
-  --> $DIR/similar_names.rs:41:9
-   |
-LL |     let bluby: i32;
-   |         ^^^^^
 
 error: binding's name is too similar to existing binding
   --> $DIR/similar_names.rs:45:9
@@ -85,11 +70,6 @@ note: existing binding defined here
    |
 LL |     let parser: i32;
    |         ^^^^^^
-help: separate the discriminating character by an underscore like: `parse_e`
-  --> $DIR/similar_names.rs:67:9
-   |
-LL |     let parsee: i32;
-   |         ^^^^^^
 
 error: binding's name is too similar to existing binding
   --> $DIR/similar_names.rs:85:16
-- 
cgit 1.4.1-3-g733a5


From 251c3b64dab8982be5d0d002fe695f693ec4a5ab Mon Sep 17 00:00:00 2001
From: lyj <sjtu5140809011@gmail.com>
Date: Fri, 11 Jun 2021 20:57:11 +0800
Subject: fix 5707

---
 clippy_lints/src/redundant_clone.rs | 111 ++++++++++++++++++++++++++++++++++--
 tests/ui/redundant_clone.fixed      |  28 +++++++++
 tests/ui/redundant_clone.rs         |  28 +++++++++
 tests/ui/redundant_clone.stderr     |  20 +++----
 4 files changed, 171 insertions(+), 16 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/redundant_clone.rs b/clippy_lints/src/redundant_clone.rs
index 380557c81a1..8253397160a 100644
--- a/clippy_lints/src/redundant_clone.rs
+++ b/clippy_lints/src/redundant_clone.rs
@@ -12,6 +12,7 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::mir::{
     self, traversal,
     visit::{MutatingUseContext, NonMutatingUseContext, PlaceContext, Visitor as _},
+    Mutability,
 };
 use rustc_middle::ty::{self, fold::TypeVisitor, Ty};
 use rustc_mir::dataflow::{Analysis, AnalysisDomain, GenKill, GenKillAnalysis, ResultsCursor};
@@ -87,13 +88,18 @@ impl<'tcx> LateLintPass<'tcx> for RedundantClone {
 
         let mir = cx.tcx.optimized_mir(def_id.to_def_id());
 
+        let possible_borrowed = {
+            let mut vis = PossibleBorrowedVisitor::new(mir);
+            vis.visit_body(mir);
+            vis.into_map(cx)
+        };
         let maybe_storage_live_result = MaybeStorageLive
             .into_engine(cx.tcx, mir)
             .pass_name("redundant_clone")
             .iterate_to_fixpoint()
             .into_results_cursor(mir);
         let mut possible_borrower = {
-            let mut vis = PossibleBorrowerVisitor::new(cx, mir);
+            let mut vis = PossibleBorrowerVisitor::new(cx, mir, possible_borrowed);
             vis.visit_body(mir);
             vis.into_map(cx, maybe_storage_live_result)
         };
@@ -509,14 +515,20 @@ struct PossibleBorrowerVisitor<'a, 'tcx> {
     possible_borrower: TransitiveRelation<mir::Local>,
     body: &'a mir::Body<'tcx>,
     cx: &'a LateContext<'tcx>,
+    possible_borrowed: FxHashMap<mir::Local, HybridBitSet<mir::Local>>,
 }
 
 impl<'a, 'tcx> PossibleBorrowerVisitor<'a, 'tcx> {
-    fn new(cx: &'a LateContext<'tcx>, body: &'a mir::Body<'tcx>) -> Self {
+    fn new(
+        cx: &'a LateContext<'tcx>,
+        body: &'a mir::Body<'tcx>,
+        possible_borrowed: FxHashMap<mir::Local, HybridBitSet<mir::Local>>,
+    ) -> Self {
         Self {
             possible_borrower: TransitiveRelation::default(),
             cx,
             body,
+            possible_borrowed,
         }
     }
 
@@ -585,21 +597,108 @@ impl<'a, 'tcx> mir::visit::Visitor<'tcx> for PossibleBorrowerVisitor<'a, 'tcx> {
             ..
         } = &terminator.kind
         {
+            // TODO add doc
             // If the call returns something with lifetimes,
             // let's conservatively assume the returned value contains lifetime of all the arguments.
             // For example, given `let y: Foo<'a> = foo(x)`, `y` is considered to be a possible borrower of `x`.
-            if ContainsRegion.visit_ty(self.body.local_decls[*dest].ty).is_continue() {
-                return;
-            }
+
+            let mut immutable_borrowers = vec![];
+            let mut mutable_borrowers = vec![];
 
             for op in args {
                 match op {
                     mir::Operand::Copy(p) | mir::Operand::Move(p) => {
-                        self.possible_borrower.add(p.local, *dest);
+                        if let ty::Ref(_, _, Mutability::Mut) = self.body.local_decls[p.local].ty.kind() {
+                            mutable_borrowers.push(p.local);
+                        } else {
+                            immutable_borrowers.push(p.local);
+                        }
                     },
                     mir::Operand::Constant(..) => (),
                 }
             }
+
+            let mut mutable_variables: Vec<mir::Local> = mutable_borrowers
+                .iter()
+                .filter_map(|r| self.possible_borrowed.get(r))
+                .flat_map(|r| r.iter())
+                .collect();
+
+            if ContainsRegion.visit_ty(self.body.local_decls[*dest].ty).is_break() {
+                mutable_variables.push(*dest);
+            }
+
+            for y in mutable_variables {
+                for x in &immutable_borrowers {
+                    self.possible_borrower.add(*x, y);
+                }
+                for x in &mutable_borrowers {
+                    self.possible_borrower.add(*x, y);
+                }
+            }
+        }
+    }
+}
+
+/// Collect possible borrowed for every `&mut` local.
+/// For exampel, `_1 = &mut _2` generate _1: {_2,...}
+/// Known Problems: not sure all borrowed are tracked
+struct PossibleBorrowedVisitor<'a, 'tcx> {
+    possible_borrowed: TransitiveRelation<mir::Local>,
+    body: &'a mir::Body<'tcx>,
+}
+
+impl<'a, 'tcx> PossibleBorrowedVisitor<'a, 'tcx> {
+    fn new(body: &'a mir::Body<'tcx>) -> Self {
+        Self {
+            possible_borrowed: TransitiveRelation::default(),
+            body,
+        }
+    }
+
+    fn into_map(self, cx: &LateContext<'tcx>) -> FxHashMap<mir::Local, HybridBitSet<mir::Local>> {
+        let mut map = FxHashMap::default();
+        for row in (1..self.body.local_decls.len()).map(mir::Local::from_usize) {
+            if is_copy(cx, self.body.local_decls[row].ty) {
+                continue;
+            }
+
+            let borrowers = self.possible_borrowed.reachable_from(&row);
+            if !borrowers.is_empty() {
+                let mut bs = HybridBitSet::new_empty(self.body.local_decls.len());
+                for &c in borrowers {
+                    if c != mir::Local::from_usize(0) {
+                        bs.insert(c);
+                    }
+                }
+
+                if !bs.is_empty() {
+                    map.insert(row, bs);
+                }
+            }
+        }
+        map
+    }
+}
+
+impl<'a, 'tcx> mir::visit::Visitor<'tcx> for PossibleBorrowedVisitor<'a, 'tcx> {
+    fn visit_assign(&mut self, place: &mir::Place<'tcx>, rvalue: &mir::Rvalue<'_>, _location: mir::Location) {
+        let lhs = place.local;
+        match rvalue {
+            // Only consider `&mut`, which can modify origin place
+            mir::Rvalue::Ref(_, rustc_middle::mir::BorrowKind::Mut { .. }, borrowed) => {
+                self.possible_borrowed.add(lhs, borrowed.local);
+            },
+            // _2: &mut _;
+            // _3 = move _2
+            mir::Rvalue::Use(mir::Operand::Move(borrowed)) => {
+                self.possible_borrowed.add(lhs, borrowed.local);
+            },
+            // _3 = move _2 as &mut _;
+            mir::Rvalue::Cast(_, mir::Operand::Move(borrowed), _) => {
+                self.possible_borrowed.add(lhs, borrowed.local);
+            },
+            _ => {},
         }
     }
 }
diff --git a/tests/ui/redundant_clone.fixed b/tests/ui/redundant_clone.fixed
index f5da703cd1d..2d711082746 100644
--- a/tests/ui/redundant_clone.fixed
+++ b/tests/ui/redundant_clone.fixed
@@ -55,6 +55,8 @@ fn main() {
     issue_5405();
     manually_drop();
     clone_then_move_cloned();
+    hashmap_neg();
+    false_negative_5707();
 }
 
 #[derive(Clone)]
@@ -206,3 +208,29 @@ fn clone_then_move_cloned() {
     let mut x = S(String::new());
     x.0.clone().chars().for_each(|_| x.m());
 }
+
+fn hashmap_neg() {
+    // issue 5707
+    use std::collections::HashMap;
+    use std::path::PathBuf;
+
+    let p = PathBuf::from("/");
+
+    let mut h: HashMap<&str, &str> = HashMap::new();
+    h.insert("orig-p", p.to_str().unwrap());
+
+    let mut q = p.clone();
+    q.push("foo");
+
+    println!("{:?} {}", h, q.display());
+}
+
+fn false_negative_5707() {
+    fn foo(_x: &Alpha, _y: &mut Alpha) {}
+
+    let x = Alpha;
+    let mut y = Alpha;
+    foo(&x, &mut y);
+    let _z = x.clone(); // pr 7346 can't lint on `x`
+    drop(y);
+}
diff --git a/tests/ui/redundant_clone.rs b/tests/ui/redundant_clone.rs
index fd7f31a1cc5..bd3d7365229 100644
--- a/tests/ui/redundant_clone.rs
+++ b/tests/ui/redundant_clone.rs
@@ -55,6 +55,8 @@ fn main() {
     issue_5405();
     manually_drop();
     clone_then_move_cloned();
+    hashmap_neg();
+    false_negative_5707();
 }
 
 #[derive(Clone)]
@@ -206,3 +208,29 @@ fn clone_then_move_cloned() {
     let mut x = S(String::new());
     x.0.clone().chars().for_each(|_| x.m());
 }
+
+fn hashmap_neg() {
+    // issue 5707
+    use std::collections::HashMap;
+    use std::path::PathBuf;
+
+    let p = PathBuf::from("/");
+
+    let mut h: HashMap<&str, &str> = HashMap::new();
+    h.insert("orig-p", p.to_str().unwrap());
+
+    let mut q = p.clone();
+    q.push("foo");
+
+    println!("{:?} {}", h, q.display());
+}
+
+fn false_negative_5707() {
+    fn foo(_x: &Alpha, _y: &mut Alpha) {}
+
+    let x = Alpha;
+    let mut y = Alpha;
+    foo(&x, &mut y);
+    let _z = x.clone(); // pr 7346 can't lint on `x`
+    drop(y);
+}
diff --git a/tests/ui/redundant_clone.stderr b/tests/ui/redundant_clone.stderr
index 529a6de91e2..fbc90493ae9 100644
--- a/tests/ui/redundant_clone.stderr
+++ b/tests/ui/redundant_clone.stderr
@@ -108,61 +108,61 @@ LL |     let _t = tup.0.clone();
    |              ^^^^^
 
 error: redundant clone
-  --> $DIR/redundant_clone.rs:63:25
+  --> $DIR/redundant_clone.rs:65:25
    |
 LL |     if b { (a.clone(), a.clone()) } else { (Alpha, a) }
    |                         ^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> $DIR/redundant_clone.rs:63:24
+  --> $DIR/redundant_clone.rs:65:24
    |
 LL |     if b { (a.clone(), a.clone()) } else { (Alpha, a) }
    |                        ^
 
 error: redundant clone
-  --> $DIR/redundant_clone.rs:120:15
+  --> $DIR/redundant_clone.rs:122:15
    |
 LL |     let _s = s.clone();
    |               ^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> $DIR/redundant_clone.rs:120:14
+  --> $DIR/redundant_clone.rs:122:14
    |
 LL |     let _s = s.clone();
    |              ^
 
 error: redundant clone
-  --> $DIR/redundant_clone.rs:121:15
+  --> $DIR/redundant_clone.rs:123:15
    |
 LL |     let _t = t.clone();
    |               ^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> $DIR/redundant_clone.rs:121:14
+  --> $DIR/redundant_clone.rs:123:14
    |
 LL |     let _t = t.clone();
    |              ^
 
 error: redundant clone
-  --> $DIR/redundant_clone.rs:131:19
+  --> $DIR/redundant_clone.rs:133:19
    |
 LL |         let _f = f.clone();
    |                   ^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> $DIR/redundant_clone.rs:131:18
+  --> $DIR/redundant_clone.rs:133:18
    |
 LL |         let _f = f.clone();
    |                  ^
 
 error: redundant clone
-  --> $DIR/redundant_clone.rs:143:14
+  --> $DIR/redundant_clone.rs:145:14
    |
 LL |     let y = x.clone().join("matthias");
    |              ^^^^^^^^ help: remove this
    |
 note: cloned value is neither consumed nor mutated
-  --> $DIR/redundant_clone.rs:143:13
+  --> $DIR/redundant_clone.rs:145:13
    |
 LL |     let y = x.clone().join("matthias");
    |             ^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From 10910020ecc56373336f294c827e6f1f62616d03 Mon Sep 17 00:00:00 2001
From: lyj <sjtu5140809011@gmail.com>
Date: Wed, 14 Jul 2021 11:29:39 +0800
Subject: rename possible_borrowed to possible_origin; pass dogfood

---
 clippy_lints/src/redundant_clone.rs | 41 +++++++++++++++++--------------------
 1 file changed, 19 insertions(+), 22 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/redundant_clone.rs b/clippy_lints/src/redundant_clone.rs
index 8253397160a..56ef95a88c8 100644
--- a/clippy_lints/src/redundant_clone.rs
+++ b/clippy_lints/src/redundant_clone.rs
@@ -88,8 +88,8 @@ impl<'tcx> LateLintPass<'tcx> for RedundantClone {
 
         let mir = cx.tcx.optimized_mir(def_id.to_def_id());
 
-        let possible_borrowed = {
-            let mut vis = PossibleBorrowedVisitor::new(mir);
+        let possible_origin = {
+            let mut vis = PossibleOriginVisitor::new(mir);
             vis.visit_body(mir);
             vis.into_map(cx)
         };
@@ -99,7 +99,7 @@ impl<'tcx> LateLintPass<'tcx> for RedundantClone {
             .iterate_to_fixpoint()
             .into_results_cursor(mir);
         let mut possible_borrower = {
-            let mut vis = PossibleBorrowerVisitor::new(cx, mir, possible_borrowed);
+            let mut vis = PossibleBorrowerVisitor::new(cx, mir, possible_origin);
             vis.visit_body(mir);
             vis.into_map(cx, maybe_storage_live_result)
         };
@@ -515,20 +515,20 @@ struct PossibleBorrowerVisitor<'a, 'tcx> {
     possible_borrower: TransitiveRelation<mir::Local>,
     body: &'a mir::Body<'tcx>,
     cx: &'a LateContext<'tcx>,
-    possible_borrowed: FxHashMap<mir::Local, HybridBitSet<mir::Local>>,
+    possible_origin: FxHashMap<mir::Local, HybridBitSet<mir::Local>>,
 }
 
 impl<'a, 'tcx> PossibleBorrowerVisitor<'a, 'tcx> {
     fn new(
         cx: &'a LateContext<'tcx>,
         body: &'a mir::Body<'tcx>,
-        possible_borrowed: FxHashMap<mir::Local, HybridBitSet<mir::Local>>,
+        possible_origin: FxHashMap<mir::Local, HybridBitSet<mir::Local>>,
     ) -> Self {
         Self {
             possible_borrower: TransitiveRelation::default(),
             cx,
             body,
-            possible_borrowed,
+            possible_origin,
         }
     }
 
@@ -620,8 +620,8 @@ impl<'a, 'tcx> mir::visit::Visitor<'tcx> for PossibleBorrowerVisitor<'a, 'tcx> {
 
             let mut mutable_variables: Vec<mir::Local> = mutable_borrowers
                 .iter()
-                .filter_map(|r| self.possible_borrowed.get(r))
-                .flat_map(|r| r.iter())
+                .filter_map(|r| self.possible_origin.get(r))
+                .flat_map(HybridBitSet::iter)
                 .collect();
 
             if ContainsRegion.visit_ty(self.body.local_decls[*dest].ty).is_break() {
@@ -643,15 +643,15 @@ impl<'a, 'tcx> mir::visit::Visitor<'tcx> for PossibleBorrowerVisitor<'a, 'tcx> {
 /// Collect possible borrowed for every `&mut` local.
 /// For exampel, `_1 = &mut _2` generate _1: {_2,...}
 /// Known Problems: not sure all borrowed are tracked
-struct PossibleBorrowedVisitor<'a, 'tcx> {
-    possible_borrowed: TransitiveRelation<mir::Local>,
+struct PossibleOriginVisitor<'a, 'tcx> {
+    possible_origin: TransitiveRelation<mir::Local>,
     body: &'a mir::Body<'tcx>,
 }
 
-impl<'a, 'tcx> PossibleBorrowedVisitor<'a, 'tcx> {
+impl<'a, 'tcx> PossibleOriginVisitor<'a, 'tcx> {
     fn new(body: &'a mir::Body<'tcx>) -> Self {
         Self {
-            possible_borrowed: TransitiveRelation::default(),
+            possible_origin: TransitiveRelation::default(),
             body,
         }
     }
@@ -663,7 +663,7 @@ impl<'a, 'tcx> PossibleBorrowedVisitor<'a, 'tcx> {
                 continue;
             }
 
-            let borrowers = self.possible_borrowed.reachable_from(&row);
+            let borrowers = self.possible_origin.reachable_from(&row);
             if !borrowers.is_empty() {
                 let mut bs = HybridBitSet::new_empty(self.body.local_decls.len());
                 for &c in borrowers {
@@ -681,22 +681,19 @@ impl<'a, 'tcx> PossibleBorrowedVisitor<'a, 'tcx> {
     }
 }
 
-impl<'a, 'tcx> mir::visit::Visitor<'tcx> for PossibleBorrowedVisitor<'a, 'tcx> {
+impl<'a, 'tcx> mir::visit::Visitor<'tcx> for PossibleOriginVisitor<'a, 'tcx> {
     fn visit_assign(&mut self, place: &mir::Place<'tcx>, rvalue: &mir::Rvalue<'_>, _location: mir::Location) {
         let lhs = place.local;
         match rvalue {
             // Only consider `&mut`, which can modify origin place
-            mir::Rvalue::Ref(_, rustc_middle::mir::BorrowKind::Mut { .. }, borrowed) => {
-                self.possible_borrowed.add(lhs, borrowed.local);
-            },
+            mir::Rvalue::Ref(_, rustc_middle::mir::BorrowKind::Mut { .. }, borrowed) |
             // _2: &mut _;
             // _3 = move _2
-            mir::Rvalue::Use(mir::Operand::Move(borrowed)) => {
-                self.possible_borrowed.add(lhs, borrowed.local);
-            },
+            mir::Rvalue::Use(mir::Operand::Move(borrowed))  |
             // _3 = move _2 as &mut _;
-            mir::Rvalue::Cast(_, mir::Operand::Move(borrowed), _) => {
-                self.possible_borrowed.add(lhs, borrowed.local);
+            mir::Rvalue::Cast(_, mir::Operand::Move(borrowed), _)
+                => {
+                self.possible_origin.add(lhs, borrowed.local);
             },
             _ => {},
         }
-- 
cgit 1.4.1-3-g733a5


From 4c398e07e042c21a4cf0e953669075275e656543 Mon Sep 17 00:00:00 2001
From: Elliot Bobrow <elliotgreybobrow@gmail.com>
Date: Fri, 2 Jul 2021 20:25:55 -0700
Subject: suggest `&mut` for redundant FnMut closures

---
 clippy_lints/src/eta_reduction.rs | 20 +++++++++++++----
 clippy_utils/src/usage.rs         | 47 +++++++++++++++++++++++++++++++++++++++
 tests/ui/eta.fixed                | 16 +++++++++++++
 tests/ui/eta.rs                   | 16 +++++++++++++
 tests/ui/eta.stderr               | 26 +++++++++++++++++++++-
 5 files changed, 120 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/eta_reduction.rs b/clippy_lints/src/eta_reduction.rs
index 8d066f305ee..667eb8eb283 100644
--- a/clippy_lints/src/eta_reduction.rs
+++ b/clippy_lints/src/eta_reduction.rs
@@ -1,15 +1,16 @@
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
-use clippy_utils::higher;
 use clippy_utils::higher::VecArgs;
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::{implements_trait, type_is_unsafe_function};
+use clippy_utils::usage::UsedAfterExprVisitor;
+use clippy_utils::{get_enclosing_loop_or_closure, higher};
 use clippy_utils::{is_adjusted, iter_input_pats};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{def_id, Expr, ExprKind, Param, PatKind, QPath};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_middle::ty::{self, Ty};
+use rustc_middle::ty::{self, ClosureKind, Ty};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
@@ -86,7 +87,7 @@ impl<'tcx> LateLintPass<'tcx> for EtaReduction {
     }
 }
 
-fn check_closure(cx: &LateContext<'_>, expr: &Expr<'_>) {
+fn check_closure<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
     if let ExprKind::Closure(_, decl, eid, _, _) = expr.kind {
         let body = cx.tcx.hir().body(eid);
         let ex = &body.value;
@@ -131,7 +132,18 @@ fn check_closure(cx: &LateContext<'_>, expr: &Expr<'_>) {
 
             then {
                 span_lint_and_then(cx, REDUNDANT_CLOSURE, expr.span, "redundant closure", |diag| {
-                    if let Some(snippet) = snippet_opt(cx, caller.span) {
+                    if let Some(mut snippet) = snippet_opt(cx, caller.span) {
+                        if_chain! {
+                            if let ty::Closure(_, substs) = fn_ty.kind();
+                            if let ClosureKind::FnMut = substs.as_closure().kind();
+                            if UsedAfterExprVisitor::is_found(cx, caller)
+                                || get_enclosing_loop_or_closure(cx.tcx, expr).is_some();
+
+                            then {
+                                // Mutable closure is used after current expr; we cannot consume it.
+                                snippet = format!("&mut {}", snippet);
+                            }
+                        }
                         diag.span_suggestion(
                             expr.span,
                             "replace the closure with the function itself",
diff --git a/clippy_utils/src/usage.rs b/clippy_utils/src/usage.rs
index 2c55021ac88..182d8cb11ea 100644
--- a/clippy_utils/src/usage.rs
+++ b/clippy_utils/src/usage.rs
@@ -199,3 +199,50 @@ pub fn contains_return_break_continue_macro(expression: &Expr<'_>) -> bool {
     recursive_visitor.visit_expr(expression);
     recursive_visitor.seen_return_break_continue
 }
+
+pub struct UsedAfterExprVisitor<'a, 'tcx> {
+    cx: &'a LateContext<'tcx>,
+    expr: &'tcx Expr<'tcx>,
+    definition: HirId,
+    past_expr: bool,
+    used_after_expr: bool,
+}
+impl<'a, 'tcx> UsedAfterExprVisitor<'a, 'tcx> {
+    pub fn is_found(cx: &'a LateContext<'tcx>, expr: &'tcx Expr<'_>) -> bool {
+        utils::path_to_local(expr).map_or(false, |definition| {
+            let mut visitor = UsedAfterExprVisitor {
+                cx,
+                expr,
+                definition,
+                past_expr: false,
+                used_after_expr: false,
+            };
+            utils::get_enclosing_block(cx, definition).map_or(false, |block| {
+                visitor.visit_block(block);
+                visitor.used_after_expr
+            })
+        })
+    }
+}
+
+impl<'a, 'tcx> intravisit::Visitor<'tcx> for UsedAfterExprVisitor<'a, 'tcx> {
+    type Map = Map<'tcx>;
+
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::OnlyBodies(self.cx.tcx.hir())
+    }
+
+    fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) {
+        if self.used_after_expr {
+            return;
+        }
+
+        if expr.hir_id == self.expr.hir_id {
+            self.past_expr = true;
+        } else if self.past_expr && utils::path_to_local_id(expr, self.definition) {
+            self.used_after_expr = true;
+        } else {
+            intravisit::walk_expr(self, expr);
+        }
+    }
+}
diff --git a/tests/ui/eta.fixed b/tests/ui/eta.fixed
index 9e752311c67..91b837f9a85 100644
--- a/tests/ui/eta.fixed
+++ b/tests/ui/eta.fixed
@@ -220,3 +220,19 @@ impl std::ops::Deref for Bar {
 fn test_deref_with_trait_method() {
     let _ = [Bar].iter().map(|s| s.to_string()).collect::<Vec<_>>();
 }
+
+fn mutable_closure_used_again(x: Vec<i32>, y: Vec<i32>, z: Vec<i32>) {
+    let mut res = Vec::new();
+    let mut add_to_res = |n| res.push(n);
+    x.into_iter().for_each(&mut add_to_res);
+    y.into_iter().for_each(&mut add_to_res);
+    z.into_iter().for_each(add_to_res);
+}
+
+fn mutable_closure_in_loop() {
+    let mut value = 0;
+    let mut closure = |n| value += n;
+    for _ in 0..5 {
+        Some(1).map(&mut closure);
+    }
+}
diff --git a/tests/ui/eta.rs b/tests/ui/eta.rs
index 44be4628cbd..1b53700289d 100644
--- a/tests/ui/eta.rs
+++ b/tests/ui/eta.rs
@@ -220,3 +220,19 @@ impl std::ops::Deref for Bar {
 fn test_deref_with_trait_method() {
     let _ = [Bar].iter().map(|s| s.to_string()).collect::<Vec<_>>();
 }
+
+fn mutable_closure_used_again(x: Vec<i32>, y: Vec<i32>, z: Vec<i32>) {
+    let mut res = Vec::new();
+    let mut add_to_res = |n| res.push(n);
+    x.into_iter().for_each(|x| add_to_res(x));
+    y.into_iter().for_each(|x| add_to_res(x));
+    z.into_iter().for_each(|x| add_to_res(x));
+}
+
+fn mutable_closure_in_loop() {
+    let mut value = 0;
+    let mut closure = |n| value += n;
+    for _ in 0..5 {
+        Some(1).map(|n| closure(n));
+    }
+}
diff --git a/tests/ui/eta.stderr b/tests/ui/eta.stderr
index 8795d3b42c6..28da8941346 100644
--- a/tests/ui/eta.stderr
+++ b/tests/ui/eta.stderr
@@ -82,5 +82,29 @@ error: redundant closure
 LL |     let a = Some(1u8).map(|a| closure(a));
    |                           ^^^^^^^^^^^^^^ help: replace the closure with the function itself: `closure`
 
-error: aborting due to 13 previous errors
+error: redundant closure
+  --> $DIR/eta.rs:227:28
+   |
+LL |     x.into_iter().for_each(|x| add_to_res(x));
+   |                            ^^^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `&mut add_to_res`
+
+error: redundant closure
+  --> $DIR/eta.rs:228:28
+   |
+LL |     y.into_iter().for_each(|x| add_to_res(x));
+   |                            ^^^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `&mut add_to_res`
+
+error: redundant closure
+  --> $DIR/eta.rs:229:28
+   |
+LL |     z.into_iter().for_each(|x| add_to_res(x));
+   |                            ^^^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `add_to_res`
+
+error: redundant closure
+  --> $DIR/eta.rs:236:21
+   |
+LL |         Some(1).map(|n| closure(n));
+   |                     ^^^^^^^^^^^^^^ help: replace the closure with the function itself: `&mut closure`
+
+error: aborting due to 17 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 61e280863fb68c26bb1f976acfa4a45a26d70545 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Tue, 13 Jul 2021 23:27:19 +0200
Subject: Fixed `branches_sharing_code` FP with block expressions in else

And added `branches_sharing_code` PF note to lint doc for `rust-clippy#7452`
---
 clippy_lints/src/copies.rs                        |  8 ++++---
 tests/ui/branches_sharing_code/false_positives.rs | 28 +++++++++++++++++++++++
 2 files changed, 33 insertions(+), 3 deletions(-)
 create mode 100644 tests/ui/branches_sharing_code/false_positives.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/copies.rs b/clippy_lints/src/copies.rs
index aea1accccc6..9cbcde59768 100644
--- a/clippy_lints/src/copies.rs
+++ b/clippy_lints/src/copies.rs
@@ -120,7 +120,10 @@ declare_clippy_lint! {
     ///
     /// **Why is this bad?** Duplicate code is less maintainable.
     ///
-    /// **Known problems:** Hopefully none.
+    /// **Known problems:**
+    /// * The lint doesn't check if the moved expressions modify values that are beeing used in
+    ///   the if condition. The suggestion can in that case modify the behavior of the program.
+    ///   See [rust-clippy#7452](https://github.com/rust-lang/rust-clippy/issues/7452)
     ///
     /// **Example:**
     /// ```ignore
@@ -358,8 +361,7 @@ fn scan_block_for_eq(cx: &LateContext<'tcx>, blocks: &[&Block<'tcx>]) -> Option<
         expr_eq &= block_expr_eq;
     }
 
-    let has_expr = blocks[0].expr.is_some();
-    if has_expr && !expr_eq {
+    if !expr_eq {
         end_eq = 0;
     }
 
diff --git a/tests/ui/branches_sharing_code/false_positives.rs b/tests/ui/branches_sharing_code/false_positives.rs
new file mode 100644
index 00000000000..7f42df46341
--- /dev/null
+++ b/tests/ui/branches_sharing_code/false_positives.rs
@@ -0,0 +1,28 @@
+#![allow(dead_code)]
+#![deny(clippy::if_same_then_else, clippy::branches_sharing_code)]
+
+// ##################################
+// # Issue clippy#7369
+// ##################################
+#[derive(Debug)]
+pub struct FooBar {
+    foo: Vec<u32>,
+}
+
+impl FooBar {
+    pub fn bar(&mut self) {
+        if true {
+            self.foo.pop();
+        } else {
+            self.baz();
+
+            self.foo.pop();
+
+            self.baz()
+        }
+    }
+
+    fn baz(&mut self) {}
+}
+
+fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 2ac21889bcc0634eabd1ff36491042fd0dae003f Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Wed, 14 Jul 2021 12:58:43 +0200
Subject: Use diagnostic items for `BinaryHeap`, `BTreeMap`, `BTreeSet`,
 `HashMap`, `HashSet`, `Borrow`, `Default`

---
 clippy_lints/src/implicit_hasher.rs          | 7 +++----
 clippy_lints/src/loops/explicit_iter_loop.rs | 6 +++---
 clippy_lints/src/loops/for_kv_map.rs         | 6 +++---
 clippy_lints/src/matches.rs                  | 2 +-
 clippy_lints/src/methods/get_unwrap.rs       | 6 +++---
 clippy_lints/src/methods/iter_count.rs       | 6 +++---
 clippy_lints/src/methods/or_fun_call.rs      | 4 ++--
 clippy_lints/src/mut_key.rs                  | 7 ++++---
 clippy_lints/src/needless_pass_by_value.rs   | 3 +--
 clippy_lints/src/new_without_default.rs      | 5 ++---
 clippy_lints/src/zero_sized_map_values.rs    | 5 ++---
 clippy_utils/src/paths.rs                    | 8 +++++++-
 12 files changed, 34 insertions(+), 31 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/implicit_hasher.rs b/clippy_lints/src/implicit_hasher.rs
index 03fe0d16d48..7a5a37e2201 100644
--- a/clippy_lints/src/implicit_hasher.rs
+++ b/clippy_lints/src/implicit_hasher.rs
@@ -19,10 +19,9 @@ use rustc_typeck::hir_ty_to_ty;
 use if_chain::if_chain;
 
 use clippy_utils::diagnostics::{multispan_sugg, span_lint_and_then};
-use clippy_utils::paths;
+use clippy_utils::differing_macro_contexts;
 use clippy_utils::source::{snippet, snippet_opt};
 use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{differing_macro_contexts, match_def_path};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for public `impl` or `fn` missing generalization
@@ -339,7 +338,7 @@ impl<'a, 'b, 'tcx> Visitor<'tcx> for ImplicitHasherConstructorVisitor<'a, 'b, 't
                     return;
                 }
 
-                if match_def_path(self.cx, ty_did, &paths::HASHMAP) {
+                if self.cx.tcx.is_diagnostic_item(sym::hashmap_type, ty_did) {
                     if method.ident.name == sym::new {
                         self.suggestions
                             .insert(e.span, "HashMap::default()".to_string());
@@ -352,7 +351,7 @@ impl<'a, 'b, 'tcx> Visitor<'tcx> for ImplicitHasherConstructorVisitor<'a, 'b, 't
                             ),
                         );
                     }
-                } else if match_def_path(self.cx, ty_did, &paths::HASHSET) {
+                } else if self.cx.tcx.is_diagnostic_item(sym::hashset_type, ty_did) {
                     if method.ident.name == sym::new {
                         self.suggestions
                             .insert(e.span, "HashSet::default()".to_string());
diff --git a/clippy_lints/src/loops/explicit_iter_loop.rs b/clippy_lints/src/loops/explicit_iter_loop.rs
index f0327b5d777..3ba56a9294f 100644
--- a/clippy_lints/src/loops/explicit_iter_loop.rs
+++ b/clippy_lints/src/loops/explicit_iter_loop.rs
@@ -59,9 +59,9 @@ fn is_ref_iterable_type(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
     is_type_diagnostic_item(cx, ty, sym::hashmap_type) ||
     is_type_diagnostic_item(cx, ty, sym::hashset_type) ||
     is_type_diagnostic_item(cx, ty, sym::vecdeque_type) ||
-    match_type(cx, ty, &paths::BINARY_HEAP) ||
-    match_type(cx, ty, &paths::BTREEMAP) ||
-    match_type(cx, ty, &paths::BTREESET)
+    is_type_diagnostic_item(cx, ty, sym::BinaryHeap) ||
+    is_type_diagnostic_item(cx, ty, sym::BTreeMap) ||
+    is_type_diagnostic_item(cx, ty, sym::BTreeSet)
 }
 
 fn is_iterable_array<'tcx>(ty: Ty<'tcx>, cx: &LateContext<'tcx>) -> bool {
diff --git a/clippy_lints/src/loops/for_kv_map.rs b/clippy_lints/src/loops/for_kv_map.rs
index 666b8c58728..82bf49f5b49 100644
--- a/clippy_lints/src/loops/for_kv_map.rs
+++ b/clippy_lints/src/loops/for_kv_map.rs
@@ -1,9 +1,9 @@
 use super::FOR_KV_MAP;
 use clippy_utils::diagnostics::{multispan_sugg, span_lint_and_then};
 use clippy_utils::source::snippet;
-use clippy_utils::ty::{is_type_diagnostic_item, match_type};
+use clippy_utils::sugg;
+use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::visitors::LocalUsedVisitor;
-use clippy_utils::{paths, sugg};
 use rustc_hir::{BorrowKind, Expr, ExprKind, Mutability, Pat, PatKind};
 use rustc_lint::LateContext;
 use rustc_middle::ty;
@@ -39,7 +39,7 @@ pub(super) fn check<'tcx>(
                 _ => arg,
             };
 
-            if is_type_diagnostic_item(cx, ty, sym::hashmap_type) || match_type(cx, ty, &paths::BTREEMAP) {
+            if is_type_diagnostic_item(cx, ty, sym::hashmap_type) || is_type_diagnostic_item(cx, ty, sym::BTreeMap) {
                 span_lint_and_then(
                     cx,
                     FOR_KV_MAP,
diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index 986469a2b69..de73af8bf60 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -1793,7 +1793,7 @@ mod redundant_pattern_match {
             || is_type_diagnostic_item(cx, ty, sym::Rc)
             || is_type_diagnostic_item(cx, ty, sym::Arc)
             || is_type_diagnostic_item(cx, ty, sym::cstring_type)
-            || match_type(cx, ty, &paths::BTREEMAP)
+            || is_type_diagnostic_item(cx, ty, sym::BTreeMap)
             || match_type(cx, ty, &paths::LINKED_LIST)
             || match_type(cx, ty, &paths::WEAK_RC)
             || match_type(cx, ty, &paths::WEAK_ARC)
diff --git a/clippy_lints/src/methods/get_unwrap.rs b/clippy_lints/src/methods/get_unwrap.rs
index 54f28064384..66fb85deae5 100644
--- a/clippy_lints/src/methods/get_unwrap.rs
+++ b/clippy_lints/src/methods/get_unwrap.rs
@@ -1,8 +1,8 @@
 use super::utils::derefs_to_slice;
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::get_parent_expr;
 use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::ty::{is_type_diagnostic_item, match_type};
-use clippy_utils::{get_parent_expr, paths};
+use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
@@ -36,7 +36,7 @@ pub(super) fn check<'tcx>(
     } else if !is_mut && is_type_diagnostic_item(cx, expr_ty, sym::hashmap_type) {
         needs_ref = true;
         "HashMap"
-    } else if !is_mut && match_type(cx, expr_ty, &paths::BTREEMAP) {
+    } else if !is_mut && is_type_diagnostic_item(cx, expr_ty, sym::BTreeMap) {
         needs_ref = true;
         "BTreeMap"
     } else {
diff --git a/clippy_lints/src/methods/iter_count.rs b/clippy_lints/src/methods/iter_count.rs
index c6b7c7cd179..f8a38e67d00 100644
--- a/clippy_lints/src/methods/iter_count.rs
+++ b/clippy_lints/src/methods/iter_count.rs
@@ -22,13 +22,13 @@ pub(crate) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, recv: &'tcx E
         "HashSet"
     } else if is_type_diagnostic_item(cx, ty, sym::hashmap_type) {
         "HashMap"
-    } else if match_type(cx, ty, &paths::BTREEMAP) {
+    } else if is_type_diagnostic_item(cx, ty, sym::BTreeMap) {
         "BTreeMap"
-    } else if match_type(cx, ty, &paths::BTREESET) {
+    } else if is_type_diagnostic_item(cx, ty, sym::BTreeSet) {
         "BTreeSet"
     } else if match_type(cx, ty, &paths::LINKED_LIST) {
         "LinkedList"
-    } else if match_type(cx, ty, &paths::BINARY_HEAP) {
+    } else if is_type_diagnostic_item(cx, ty, sym::BinaryHeap) {
         "BinaryHeap"
     } else {
         return;
diff --git a/clippy_lints/src/methods/or_fun_call.rs b/clippy_lints/src/methods/or_fun_call.rs
index 073c5570a88..ef615b0aa40 100644
--- a/clippy_lints/src/methods/or_fun_call.rs
+++ b/clippy_lints/src/methods/or_fun_call.rs
@@ -2,7 +2,7 @@ use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::eager_or_lazy::is_lazyness_candidate;
 use clippy_utils::source::{snippet, snippet_with_applicability, snippet_with_macro_callsite};
 use clippy_utils::ty::{implements_trait, is_type_diagnostic_item, match_type};
-use clippy_utils::{contains_return, get_trait_def_id, last_path_segment, paths};
+use clippy_utils::{contains_return, last_path_segment, paths};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
@@ -41,7 +41,7 @@ pub(super) fn check<'tcx>(
             let path = last_path_segment(qpath).ident.name;
             if matches!(path, kw::Default | sym::new);
             let arg_ty = cx.typeck_results().expr_ty(arg);
-            if let Some(default_trait_id) = get_trait_def_id(cx, &paths::DEFAULT_TRAIT);
+            if let Some(default_trait_id) = cx.tcx.get_diagnostic_item(sym::Default);
             if implements_trait(cx, arg_ty, default_trait_id, &[]);
 
             then {
diff --git a/clippy_lints/src/mut_key.rs b/clippy_lints/src/mut_key.rs
index 6c87136e5e1..d86f9b36f90 100644
--- a/clippy_lints/src/mut_key.rs
+++ b/clippy_lints/src/mut_key.rs
@@ -1,11 +1,12 @@
 use clippy_utils::diagnostics::span_lint;
-use clippy_utils::{match_def_path, paths, trait_ref_of_method};
+use clippy_utils::trait_ref_of_method;
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::TypeFoldable;
 use rustc_middle::ty::{Adt, Array, RawPtr, Ref, Slice, Tuple, Ty, TypeAndMut};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
+use rustc_span::symbol::sym;
 use std::iter;
 
 declare_clippy_lint! {
@@ -99,9 +100,9 @@ fn check_sig<'tcx>(cx: &LateContext<'tcx>, item_hir_id: hir::HirId, decl: &hir::
 fn check_ty<'tcx>(cx: &LateContext<'tcx>, span: Span, ty: Ty<'tcx>) {
     let ty = ty.peel_refs();
     if let Adt(def, substs) = ty.kind() {
-        if [&paths::HASHMAP, &paths::BTREEMAP, &paths::HASHSET, &paths::BTREESET]
+        if [sym::hashmap_type, sym::BTreeMap, sym::hashset_type, sym::BTreeMap]
             .iter()
-            .any(|path| match_def_path(cx, def.did, &**path))
+            .any(|diag_item| cx.tcx.is_diagnostic_item(*diag_item, def.did))
             && is_mutable_type(cx, substs.type_at(0), span)
         {
             span_lint(cx, MUTABLE_KEY_TYPE, span, "mutable key type");
diff --git a/clippy_lints/src/needless_pass_by_value.rs b/clippy_lints/src/needless_pass_by_value.rs
index e33a33e2386..e03b3d25721 100644
--- a/clippy_lints/src/needless_pass_by_value.rs
+++ b/clippy_lints/src/needless_pass_by_value.rs
@@ -103,7 +103,6 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByValue {
         }
 
         // Allow `Borrow` or functions to be taken by value
-        let borrow_trait = need!(get_trait_def_id(cx, &paths::BORROW_TRAIT));
         let allowed_traits = [
             need!(cx.tcx.lang_items().fn_trait()),
             need!(cx.tcx.lang_items().fn_once_trait()),
@@ -167,7 +166,7 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByValue {
                 let preds = preds.iter().filter(|t| t.self_ty() == ty).collect::<Vec<_>>();
 
                 (
-                    preds.iter().any(|t| t.def_id() == borrow_trait),
+                    preds.iter().any(|t| cx.tcx.is_diagnostic_item(sym::Borrow, t.def_id())),
                     !preds.is_empty() && {
                         let ty_empty_region = cx.tcx.mk_imm_ref(cx.tcx.lifetimes.re_root_empty, ty);
                         preds.iter().all(|t| {
diff --git a/clippy_lints/src/new_without_default.rs b/clippy_lints/src/new_without_default.rs
index a5f91eb035f..4d9ff7479d6 100644
--- a/clippy_lints/src/new_without_default.rs
+++ b/clippy_lints/src/new_without_default.rs
@@ -1,8 +1,7 @@
 use clippy_utils::diagnostics::span_lint_hir_and_then;
-use clippy_utils::paths;
+use clippy_utils::return_ty;
 use clippy_utils::source::snippet;
 use clippy_utils::sugg::DiagnosticBuilderExt;
-use clippy_utils::{get_trait_def_id, return_ty};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
@@ -104,7 +103,7 @@ impl<'tcx> LateLintPass<'tcx> for NewWithoutDefault {
                             let self_def_id = cx.tcx.hir().local_def_id(cx.tcx.hir().get_parent_item(id));
                             let self_ty = cx.tcx.type_of(self_def_id);
                             if TyS::same_type(self_ty, return_ty(cx, id));
-                            if let Some(default_trait_id) = get_trait_def_id(cx, &paths::DEFAULT_TRAIT);
+                            if let Some(default_trait_id) = cx.tcx.get_diagnostic_item(sym::Default);
                             then {
                                 if self.impling_types.is_none() {
                                     let mut impls = HirIdSet::default();
diff --git a/clippy_lints/src/zero_sized_map_values.rs b/clippy_lints/src/zero_sized_map_values.rs
index f93f0047f51..1475c90721c 100644
--- a/clippy_lints/src/zero_sized_map_values.rs
+++ b/clippy_lints/src/zero_sized_map_values.rs
@@ -1,6 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_help;
-use clippy_utils::paths;
-use clippy_utils::ty::{is_normalizable, is_type_diagnostic_item, match_type};
+use clippy_utils::ty::{is_normalizable, is_type_diagnostic_item};
 use if_chain::if_chain;
 use rustc_hir::{self as hir, HirId, ItemKind, Node};
 use rustc_lint::{LateContext, LateLintPass};
@@ -49,7 +48,7 @@ impl LateLintPass<'_> for ZeroSizedMapValues {
             if !hir_ty.span.from_expansion();
             if !in_trait_impl(cx, hir_ty.hir_id);
             let ty = ty_from_hir_ty(cx, hir_ty);
-            if is_type_diagnostic_item(cx, ty, sym::hashmap_type) || match_type(cx, ty, &paths::BTREEMAP);
+            if is_type_diagnostic_item(cx, ty, sym::hashmap_type) || is_type_diagnostic_item(cx, ty, sym::BTreeMap);
             if let Adt(_, substs) = ty.kind();
             let ty = substs.type_at(1);
             // Do this to prevent `layout_of` crashing, being unable to fully normalize `ty`.
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index c960eec3064..3acde01b8c9 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -21,21 +21,25 @@ pub const ASMUT_TRAIT: [&str; 3] = ["core", "convert", "AsMut"];
 pub const ASREF_TRAIT: [&str; 3] = ["core", "convert", "AsRef"];
 pub(super) const BEGIN_PANIC: [&str; 3] = ["std", "panicking", "begin_panic"];
 pub(super) const BEGIN_PANIC_FMT: [&str; 3] = ["std", "panicking", "begin_panic_fmt"];
+/// Preferably use the diagnostic item `sym::BinaryHeap` where possible
 pub const BINARY_HEAP: [&str; 4] = ["alloc", "collections", "binary_heap", "BinaryHeap"];
+/// Preferably use the diagnostic item `sym::Borrow` where possible
 pub const BORROW_TRAIT: [&str; 3] = ["core", "borrow", "Borrow"];
+/// Preferably use the diagnostic item `sym::BTreeMap` where possible
 pub const BTREEMAP: [&str; 5] = ["alloc", "collections", "btree", "map", "BTreeMap"];
 pub const BTREEMAP_CONTAINS_KEY: [&str; 6] = ["alloc", "collections", "btree", "map", "BTreeMap", "contains_key"];
 pub const BTREEMAP_ENTRY: [&str; 6] = ["alloc", "collections", "btree", "map", "entry", "Entry"];
 pub const BTREEMAP_INSERT: [&str; 6] = ["alloc", "collections", "btree", "map", "BTreeMap", "insert"];
+/// Preferably use the diagnostic item `sym::BTreeSet` where possible
 pub const BTREESET: [&str; 5] = ["alloc", "collections", "btree", "set", "BTreeSet"];
 pub const CLONE_TRAIT_METHOD: [&str; 4] = ["core", "clone", "Clone", "clone"];
 pub const CMP_MAX: [&str; 3] = ["core", "cmp", "max"];
 pub const CMP_MIN: [&str; 3] = ["core", "cmp", "min"];
 pub const COW: [&str; 3] = ["alloc", "borrow", "Cow"];
 pub const CSTRING_AS_C_STR: [&str; 5] = ["std", "ffi", "c_str", "CString", "as_c_str"];
-pub const DEFAULT_TRAIT: [&str; 3] = ["core", "default", "Default"];
 pub const DEFAULT_TRAIT_METHOD: [&str; 4] = ["core", "default", "Default", "default"];
 pub const DEREF_MUT_TRAIT_METHOD: [&str; 5] = ["core", "ops", "deref", "DerefMut", "deref_mut"];
+/// Preferably use the diagnostic item `sym::deref_method` where possible
 pub const DEREF_TRAIT_METHOD: [&str; 5] = ["core", "ops", "deref", "Deref", "deref"];
 pub const DIR_BUILDER: [&str; 3] = ["std", "fs", "DirBuilder"];
 pub const DISPLAY_TRAIT: [&str; 3] = ["core", "fmt", "Display"];
@@ -55,10 +59,12 @@ pub const FROM_ITERATOR_METHOD: [&str; 6] = ["core", "iter", "traits", "collect"
 pub const FROM_STR_METHOD: [&str; 5] = ["core", "str", "traits", "FromStr", "from_str"];
 pub const FUTURE_FROM_GENERATOR: [&str; 3] = ["core", "future", "from_generator"];
 pub const HASH: [&str; 3] = ["core", "hash", "Hash"];
+/// Preferably use the diagnostic item `sym::hashmap_type` where possible
 pub const HASHMAP: [&str; 5] = ["std", "collections", "hash", "map", "HashMap"];
 pub const HASHMAP_CONTAINS_KEY: [&str; 6] = ["std", "collections", "hash", "map", "HashMap", "contains_key"];
 pub const HASHMAP_ENTRY: [&str; 5] = ["std", "collections", "hash", "map", "Entry"];
 pub const HASHMAP_INSERT: [&str; 6] = ["std", "collections", "hash", "map", "HashMap", "insert"];
+/// Preferably use the diagnostic item `sym::hashset_type` where possible
 pub const HASHSET: [&str; 5] = ["std", "collections", "hash", "set", "HashSet"];
 #[cfg(feature = "internal-lints")]
 pub const IDENT: [&str; 3] = ["rustc_span", "symbol", "Ident"];
-- 
cgit 1.4.1-3-g733a5


From 6030428fd22912afeeaecfcc0220e979c2ffeb0a Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Wed, 14 Jul 2021 22:10:15 +0200
Subject: Use diagnostic items for `Into`, `IntoIterator`, `LinkedList`,
 `ptr::null`, `prt::null_mut`

---
 clippy_lints/src/from_over_into.rs                |  6 +++---
 clippy_lints/src/loops/explicit_into_iter_loop.rs |  5 +++--
 clippy_lints/src/loops/explicit_iter_loop.rs      |  8 ++++----
 clippy_lints/src/matches.rs                       |  2 +-
 clippy_lints/src/methods/iter_count.rs            |  5 ++---
 clippy_lints/src/ptr.rs                           |  4 ++--
 clippy_lints/src/transmuting_null.rs              |  5 +++--
 clippy_lints/src/types/linked_list.rs             |  4 ++--
 clippy_lints/src/useless_conversion.rs            |  6 +++---
 clippy_utils/src/lib.rs                           | 20 ++++++++++++++++++++
 clippy_utils/src/paths.rs                         |  6 ++----
 11 files changed, 45 insertions(+), 26 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/from_over_into.rs b/clippy_lints/src/from_over_into.rs
index 3560672a748..48316c3a61d 100644
--- a/clippy_lints/src/from_over_into.rs
+++ b/clippy_lints/src/from_over_into.rs
@@ -1,11 +1,11 @@
 use clippy_utils::diagnostics::span_lint_and_help;
-use clippy_utils::paths::INTO;
-use clippy_utils::{match_def_path, meets_msrv, msrvs};
+use clippy_utils::{meets_msrv, msrvs};
 use if_chain::if_chain;
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::symbol::sym;
 
 declare_clippy_lint! {
     /// **What it does:** Searches for implementations of the `Into<..>` trait and suggests to implement `From<..>` instead.
@@ -62,7 +62,7 @@ impl LateLintPass<'_> for FromOverInto {
         if_chain! {
             if let hir::ItemKind::Impl{ .. } = &item.kind;
             if let Some(impl_trait_ref) = cx.tcx.impl_trait_ref(item.def_id);
-            if match_def_path(cx, impl_trait_ref.def_id, &INTO);
+            if cx.tcx.is_diagnostic_item(sym::into_trait, impl_trait_ref.def_id);
 
             then {
                 span_lint_and_help(
diff --git a/clippy_lints/src/loops/explicit_into_iter_loop.rs b/clippy_lints/src/loops/explicit_into_iter_loop.rs
index c7a28f42ea1..1bab0d99b69 100644
--- a/clippy_lints/src/loops/explicit_into_iter_loop.rs
+++ b/clippy_lints/src/loops/explicit_into_iter_loop.rs
@@ -1,16 +1,17 @@
 use super::EXPLICIT_INTO_ITER_LOOP;
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::is_trait_method;
 use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::{match_trait_method, paths};
 use rustc_errors::Applicability;
 use rustc_hir::Expr;
 use rustc_lint::LateContext;
 use rustc_middle::ty::TyS;
+use rustc_span::symbol::sym;
 
 pub(super) fn check(cx: &LateContext<'_>, self_arg: &'hir Expr<'hir>, call_expr: &Expr<'_>) {
     let self_ty = cx.typeck_results().expr_ty(self_arg);
     let self_ty_adjusted = cx.typeck_results().expr_ty_adjusted(self_arg);
-    if !(TyS::same_type(self_ty, self_ty_adjusted) && match_trait_method(cx, call_expr, &paths::INTO_ITERATOR)) {
+    if !(TyS::same_type(self_ty, self_ty_adjusted) && is_trait_method(cx, call_expr, sym::IntoIterator)) {
         return;
     }
 
diff --git a/clippy_lints/src/loops/explicit_iter_loop.rs b/clippy_lints/src/loops/explicit_iter_loop.rs
index 3ba56a9294f..50bc096ba22 100644
--- a/clippy_lints/src/loops/explicit_iter_loop.rs
+++ b/clippy_lints/src/loops/explicit_iter_loop.rs
@@ -1,8 +1,8 @@
 use super::EXPLICIT_ITER_LOOP;
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::is_trait_method;
 use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::ty::{is_type_diagnostic_item, match_type};
-use clippy_utils::{match_trait_method, paths};
+use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, Mutability};
 use rustc_lint::LateContext;
@@ -12,7 +12,7 @@ use rustc_span::sym;
 pub(super) fn check(cx: &LateContext<'_>, self_arg: &Expr<'_>, arg: &Expr<'_>, method_name: &str) {
     let should_lint = match method_name {
         "iter" | "iter_mut" => is_ref_iterable_type(cx, self_arg),
-        "into_iter" if match_trait_method(cx, arg, &paths::INTO_ITERATOR) => {
+        "into_iter" if is_trait_method(cx, arg, sym::IntoIterator) => {
             let receiver_ty = cx.typeck_results().expr_ty(self_arg);
             let receiver_ty_adjusted = cx.typeck_results().expr_ty_adjusted(self_arg);
             let ref_receiver_ty = cx.tcx.mk_ref(
@@ -55,7 +55,7 @@ fn is_ref_iterable_type(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
     let ty = cx.typeck_results().expr_ty(e);
     is_iterable_array(ty, cx) ||
     is_type_diagnostic_item(cx, ty, sym::vec_type) ||
-    match_type(cx, ty, &paths::LINKED_LIST) ||
+    is_type_diagnostic_item(cx, ty, sym::LinkedList) ||
     is_type_diagnostic_item(cx, ty, sym::hashmap_type) ||
     is_type_diagnostic_item(cx, ty, sym::hashset_type) ||
     is_type_diagnostic_item(cx, ty, sym::vecdeque_type) ||
diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index de73af8bf60..e4f6aae7f82 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -1794,7 +1794,7 @@ mod redundant_pattern_match {
             || is_type_diagnostic_item(cx, ty, sym::Arc)
             || is_type_diagnostic_item(cx, ty, sym::cstring_type)
             || is_type_diagnostic_item(cx, ty, sym::BTreeMap)
-            || match_type(cx, ty, &paths::LINKED_LIST)
+            || is_type_diagnostic_item(cx, ty, sym::LinkedList)
             || match_type(cx, ty, &paths::WEAK_RC)
             || match_type(cx, ty, &paths::WEAK_ARC)
         {
diff --git a/clippy_lints/src/methods/iter_count.rs b/clippy_lints/src/methods/iter_count.rs
index f8a38e67d00..b69f57f50e0 100644
--- a/clippy_lints/src/methods/iter_count.rs
+++ b/clippy_lints/src/methods/iter_count.rs
@@ -1,8 +1,7 @@
 use super::utils::derefs_to_slice;
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::paths;
 use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::ty::{is_type_diagnostic_item, match_type};
+use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_errors::Applicability;
 use rustc_hir::Expr;
 use rustc_lint::LateContext;
@@ -26,7 +25,7 @@ pub(crate) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, recv: &'tcx E
         "BTreeMap"
     } else if is_type_diagnostic_item(cx, ty, sym::BTreeSet) {
         "BTreeSet"
-    } else if match_type(cx, ty, &paths::LINKED_LIST) {
+    } else if is_type_diagnostic_item(cx, ty, sym::LinkedList) {
         "LinkedList"
     } else if is_type_diagnostic_item(cx, ty, sym::BinaryHeap) {
         "BinaryHeap"
diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs
index dba3b1805cd..b15447622a8 100644
--- a/clippy_lints/src/ptr.rs
+++ b/clippy_lints/src/ptr.rs
@@ -4,7 +4,7 @@ use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg, span_lint_and_the
 use clippy_utils::ptr::get_spans;
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::{is_type_diagnostic_item, match_type, walk_ptrs_hir_ty};
-use clippy_utils::{expr_path_res, is_lint_allowed, match_any_def_paths, paths};
+use clippy_utils::{expr_path_res, is_lint_allowed, match_any_diagnostic_items, paths};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{
@@ -419,7 +419,7 @@ fn get_rptr_lm<'tcx>(ty: &'tcx Ty<'tcx>) -> Option<(&'tcx Lifetime, Mutability,
 fn is_null_path(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
     if let ExprKind::Call(pathexp, []) = expr.kind {
         expr_path_res(cx, pathexp).opt_def_id().map_or(false, |id| {
-            match_any_def_paths(cx, id, &[&paths::PTR_NULL, &paths::PTR_NULL_MUT]).is_some()
+            match_any_diagnostic_items(cx, id, &[sym::ptr_null, sym::ptr_null_mut]).is_some()
         })
     } else {
         false
diff --git a/clippy_lints/src/transmuting_null.rs b/clippy_lints/src/transmuting_null.rs
index b57d158293d..5bbaeedad5f 100644
--- a/clippy_lints/src/transmuting_null.rs
+++ b/clippy_lints/src/transmuting_null.rs
@@ -1,12 +1,13 @@
 use clippy_utils::consts::{constant_context, Constant};
 use clippy_utils::diagnostics::span_lint;
-use clippy_utils::{is_expr_path_def_path, paths};
+use clippy_utils::{is_expr_diagnostic_item, is_expr_path_def_path, paths};
 use if_chain::if_chain;
 use rustc_ast::LitKind;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::symbol::sym;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for transmute calls which would receive a null pointer.
@@ -67,7 +68,7 @@ impl<'tcx> LateLintPass<'tcx> for TransmutingNull {
                 // `std::mem::transmute(std::ptr::null::<i32>())`
                 if_chain! {
                     if let ExprKind::Call(func1, []) = arg.kind;
-                    if is_expr_path_def_path(cx, func1, &paths::PTR_NULL);
+                    if is_expr_diagnostic_item(cx, func1, sym::ptr_null);
                     then {
                         span_lint(cx, TRANSMUTING_NULL, expr.span, LINT_MSG)
                     }
diff --git a/clippy_lints/src/types/linked_list.rs b/clippy_lints/src/types/linked_list.rs
index a9fbe7aa315..5fb708741e5 100644
--- a/clippy_lints/src/types/linked_list.rs
+++ b/clippy_lints/src/types/linked_list.rs
@@ -1,12 +1,12 @@
 use clippy_utils::diagnostics::span_lint_and_help;
-use clippy_utils::{match_def_path, paths};
 use rustc_hir::{self as hir, def_id::DefId};
 use rustc_lint::LateContext;
+use rustc_span::symbol::sym;
 
 use super::LINKEDLIST;
 
 pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, def_id: DefId) -> bool {
-    if match_def_path(cx, def_id, &paths::LINKED_LIST) {
+    if cx.tcx.is_diagnostic_item(sym::LinkedList, def_id) {
         span_lint_and_help(
             cx,
             LINKEDLIST,
diff --git a/clippy_lints/src/useless_conversion.rs b/clippy_lints/src/useless_conversion.rs
index c97f7e1626e..a4bc8c09f53 100644
--- a/clippy_lints/src/useless_conversion.rs
+++ b/clippy_lints/src/useless_conversion.rs
@@ -2,7 +2,7 @@ use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg};
 use clippy_utils::source::{snippet, snippet_with_macro_callsite};
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::{is_type_diagnostic_item, same_type_and_consts};
-use clippy_utils::{get_parent_expr, match_def_path, match_trait_method, paths};
+use clippy_utils::{get_parent_expr, is_trait_method, match_def_path, match_trait_method, paths};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, HirId, MatchSource};
@@ -64,7 +64,7 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
             },
 
             ExprKind::MethodCall(name, .., args, _) => {
-                if match_trait_method(cx, e, &paths::INTO) && &*name.ident.as_str() == "into" {
+                if is_trait_method(cx, e, sym::into_trait) && &*name.ident.as_str() == "into" {
                     let a = cx.typeck_results().expr_ty(e);
                     let b = cx.typeck_results().expr_ty(&args[0]);
                     if same_type_and_consts(a, b) {
@@ -80,7 +80,7 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
                         );
                     }
                 }
-                if match_trait_method(cx, e, &paths::INTO_ITERATOR) && name.ident.name == sym::into_iter {
+                if is_trait_method(cx, e, sym::IntoIterator) && name.ident.name == sym::into_iter {
                     if let Some(parent_expr) = get_parent_expr(cx, e) {
                         if let ExprKind::MethodCall(parent_name, ..) = parent_expr.kind {
                             if parent_name.ident.name != sym::into_iter {
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 364ae536ecd..b19d1430b6e 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -411,12 +411,22 @@ pub fn is_qpath_def_path(cx: &LateContext<'_>, path: &QPath<'_>, hir_id: HirId,
 }
 
 /// If the expression is a path, resolves it to a `DefId` and checks if it matches the given path.
+///
+/// Please use `is_expr_diagnostic_item` if the target is a diagnostic item.
 pub fn is_expr_path_def_path(cx: &LateContext<'_>, expr: &Expr<'_>, segments: &[&str]) -> bool {
     expr_path_res(cx, expr)
         .opt_def_id()
         .map_or(false, |id| match_def_path(cx, id, segments))
 }
 
+/// If the expression is a path, resolves it to a `DefId` and checks if it matches the given
+/// diagnostic item.
+pub fn is_expr_diagnostic_item(cx: &LateContext<'_>, expr: &Expr<'_>, diag_item: Symbol) -> bool {
+    expr_path_res(cx, expr)
+        .opt_def_id()
+        .map_or(false, |id| cx.tcx.is_diagnostic_item(diag_item, id))
+}
+
 /// THIS METHOD IS DEPRECATED and will eventually be removed since it does not match against the
 /// entire path or resolved `DefId`. Prefer using `match_def_path`. Consider getting a `DefId` from
 /// `QPath::Resolved.1.res.opt_def_id()`.
@@ -1249,6 +1259,8 @@ pub fn match_function_call<'tcx>(
 
 /// Checks if the given `DefId` matches any of the paths. Returns the index of matching path, if
 /// any.
+///
+/// Please use `match_any_diagnostic_items` if the targets are all diagnostic items.
 pub fn match_any_def_paths(cx: &LateContext<'_>, did: DefId, paths: &[&[&str]]) -> Option<usize> {
     let search_path = cx.get_def_path(did);
     paths
@@ -1256,6 +1268,14 @@ pub fn match_any_def_paths(cx: &LateContext<'_>, did: DefId, paths: &[&[&str]])
         .position(|p| p.iter().map(|x| Symbol::intern(x)).eq(search_path.iter().copied()))
 }
 
+/// Checks if the given `DefId` matches any of provided diagnostic items. Returns the index of
+/// matching path, if any.
+pub fn match_any_diagnostic_items(cx: &LateContext<'_>, def_id: DefId, diag_items: &[Symbol]) -> Option<usize> {
+    diag_items
+        .iter()
+        .position(|item| cx.tcx.is_diagnostic_item(*item, def_id))
+}
+
 /// Checks if the given `DefId` matches the path.
 pub fn match_def_path<'tcx>(cx: &LateContext<'tcx>, did: DefId, syms: &[&str]) -> bool {
     // We should probably move to Symbols in Clippy as well rather than interning every time.
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index 3acde01b8c9..e9e371e3e3e 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -73,8 +73,6 @@ pub const IDENT_AS_STR: [&str; 4] = ["rustc_span", "symbol", "Ident", "as_str"];
 pub const INDEX: [&str; 3] = ["core", "ops", "Index"];
 pub const INDEX_MUT: [&str; 3] = ["core", "ops", "IndexMut"];
 pub const INSERT_STR: [&str; 4] = ["alloc", "string", "String", "insert_str"];
-pub const INTO: [&str; 3] = ["core", "convert", "Into"];
-pub const INTO_ITERATOR: [&str; 5] = ["core", "iter", "traits", "collect", "IntoIterator"];
 pub const IO_READ: [&str; 3] = ["std", "io", "Read"];
 pub const IO_WRITE: [&str; 3] = ["std", "io", "Write"];
 pub const IPADDR_V4: [&str; 5] = ["std", "net", "ip", "IpAddr", "V4"];
@@ -85,6 +83,7 @@ pub const KW_MODULE: [&str; 3] = ["rustc_span", "symbol", "kw"];
 #[cfg(feature = "internal-lints")]
 pub const LATE_CONTEXT: [&str; 2] = ["rustc_lint", "LateContext"];
 pub const LIBC_STRLEN: [&str; 2] = ["libc", "strlen"];
+/// Preferably use the diagnostic item `sym::LinkedList` where possible
 pub const LINKED_LIST: [&str; 4] = ["alloc", "collections", "linked_list", "LinkedList"];
 #[cfg(any(feature = "internal-lints", feature = "metadata-collector-lint"))]
 pub const LINT: [&str; 2] = ["rustc_lint_defs", "Lint"];
@@ -99,6 +98,7 @@ pub const MEM_SIZE_OF_VAL: [&str; 3] = ["core", "mem", "size_of_val"];
 pub const MUTEX_GUARD: [&str; 4] = ["std", "sync", "mutex", "MutexGuard"];
 pub const OPEN_OPTIONS: [&str; 3] = ["std", "fs", "OpenOptions"];
 pub const OPS_MODULE: [&str; 2] = ["core", "ops"];
+/// Preferably use the diagnostic item `sym::option_type` where possible
 pub const OPTION: [&str; 3] = ["core", "option", "Option"];
 pub const OPTION_NONE: [&str; 4] = ["core", "option", "Option", "None"];
 pub const OPTION_SOME: [&str; 4] = ["core", "option", "Option", "Some"];
@@ -122,8 +122,6 @@ pub const POLL_READY: [&str; 5] = ["core", "task", "poll", "Poll", "Ready"];
 pub const PTR_COPY: [&str; 3] = ["core", "intrinsics", "copy"];
 pub const PTR_COPY_NONOVERLAPPING: [&str; 3] = ["core", "intrinsics", "copy_nonoverlapping"];
 pub const PTR_EQ: [&str; 3] = ["core", "ptr", "eq"];
-pub const PTR_NULL: [&str; 3] = ["core", "ptr", "null"];
-pub const PTR_NULL_MUT: [&str; 3] = ["core", "ptr", "null_mut"];
 pub const PTR_SLICE_FROM_RAW_PARTS: [&str; 3] = ["core", "ptr", "slice_from_raw_parts"];
 pub const PTR_SLICE_FROM_RAW_PARTS_MUT: [&str; 3] = ["core", "ptr", "slice_from_raw_parts_mut"];
 pub const PTR_SWAP_NONOVERLAPPING: [&str; 3] = ["core", "ptr", "swap_nonoverlapping"];
-- 
cgit 1.4.1-3-g733a5


From 6ce6b29527f05e2b0fa09009053d5095f4d38aa1 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Wed, 14 Jul 2021 23:09:24 +0200
Subject: Use diagnostic items for `intrinsics::transmute`, `TryInto`

---
 clippy_lints/src/transmute/mod.rs      | 5 +++--
 clippy_lints/src/transmuting_null.rs   | 4 ++--
 clippy_lints/src/useless_conversion.rs | 4 ++--
 clippy_utils/src/paths.rs              | 4 ++--
 4 files changed, 9 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/transmute/mod.rs b/clippy_lints/src/transmute/mod.rs
index 569113910c9..89fd5faa165 100644
--- a/clippy_lints/src/transmute/mod.rs
+++ b/clippy_lints/src/transmute/mod.rs
@@ -12,11 +12,12 @@ mod useless_transmute;
 mod utils;
 mod wrong_transmute;
 
-use clippy_utils::{in_constant, match_def_path, paths};
+use clippy_utils::in_constant;
 use if_chain::if_chain;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::symbol::sym;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for transmutes that can't ever be correct on any
@@ -328,7 +329,7 @@ impl<'tcx> LateLintPass<'tcx> for Transmute {
             if let ExprKind::Call(path_expr, args) = e.kind;
             if let ExprKind::Path(ref qpath) = path_expr.kind;
             if let Some(def_id) = cx.qpath_res(qpath, path_expr.hir_id).opt_def_id();
-            if match_def_path(cx, def_id, &paths::TRANSMUTE);
+            if cx.tcx.is_diagnostic_item(sym::transmute, def_id);
             then {
                 // Avoid suggesting from/to bits and dereferencing raw pointers in const contexts.
                 // See https://github.com/rust-lang/rust/issues/73736 for progress on making them `const fn`.
diff --git a/clippy_lints/src/transmuting_null.rs b/clippy_lints/src/transmuting_null.rs
index 5bbaeedad5f..0c39d4d8cf4 100644
--- a/clippy_lints/src/transmuting_null.rs
+++ b/clippy_lints/src/transmuting_null.rs
@@ -1,6 +1,6 @@
 use clippy_utils::consts::{constant_context, Constant};
 use clippy_utils::diagnostics::span_lint;
-use clippy_utils::{is_expr_diagnostic_item, is_expr_path_def_path, paths};
+use clippy_utils::is_expr_diagnostic_item;
 use if_chain::if_chain;
 use rustc_ast::LitKind;
 use rustc_hir::{Expr, ExprKind};
@@ -39,7 +39,7 @@ impl<'tcx> LateLintPass<'tcx> for TransmutingNull {
 
         if_chain! {
             if let ExprKind::Call(func, [arg]) = expr.kind;
-            if is_expr_path_def_path(cx, func, &paths::TRANSMUTE);
+            if is_expr_diagnostic_item(cx, func, sym::transmute);
 
             then {
                 // Catching transmute over constants that resolve to `null`.
diff --git a/clippy_lints/src/useless_conversion.rs b/clippy_lints/src/useless_conversion.rs
index a4bc8c09f53..25a959d3e41 100644
--- a/clippy_lints/src/useless_conversion.rs
+++ b/clippy_lints/src/useless_conversion.rs
@@ -2,7 +2,7 @@ use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg};
 use clippy_utils::source::{snippet, snippet_with_macro_callsite};
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::{is_type_diagnostic_item, same_type_and_consts};
-use clippy_utils::{get_parent_expr, is_trait_method, match_def_path, match_trait_method, paths};
+use clippy_utils::{get_parent_expr, is_trait_method, match_def_path, paths};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, HirId, MatchSource};
@@ -104,7 +104,7 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
                     }
                 }
                 if_chain! {
-                    if match_trait_method(cx, e, &paths::TRY_INTO_TRAIT) && name.ident.name == sym::try_into;
+                    if is_trait_method(cx, e, sym::try_into_trait) && name.ident.name == sym::try_into;
                     let a = cx.typeck_results().expr_ty(e);
                     let b = cx.typeck_results().expr_ty(&args[0]);
                     if is_type_diagnostic_item(cx, a, sym::result_type);
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index e9e371e3e3e..5ef7b459667 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -145,6 +145,7 @@ pub const REGEX_BYTES_NEW: [&str; 4] = ["regex", "re_bytes", "Regex", "new"];
 pub const REGEX_BYTES_SET_NEW: [&str; 5] = ["regex", "re_set", "bytes", "RegexSet", "new"];
 pub const REGEX_NEW: [&str; 4] = ["regex", "re_unicode", "Regex", "new"];
 pub const REGEX_SET_NEW: [&str; 5] = ["regex", "re_set", "unicode", "RegexSet", "new"];
+/// Preferably use the diagnostic item `sym::result_type` where possible
 pub const RESULT: [&str; 3] = ["core", "result", "Result"];
 pub const RESULT_ERR: [&str; 4] = ["core", "result", "Result", "Err"];
 pub const RESULT_OK: [&str; 4] = ["core", "result", "Result", "Ok"];
@@ -180,9 +181,8 @@ pub const SYM_MODULE: [&str; 3] = ["rustc_span", "symbol", "sym"];
 pub const SYNTAX_CONTEXT: [&str; 3] = ["rustc_span", "hygiene", "SyntaxContext"];
 pub const TO_OWNED_METHOD: [&str; 4] = ["alloc", "borrow", "ToOwned", "to_owned"];
 pub const TO_STRING_METHOD: [&str; 4] = ["alloc", "string", "ToString", "to_string"];
-pub const TRANSMUTE: [&str; 4] = ["core", "intrinsics", "", "transmute"];
 pub const TRY_FROM: [&str; 4] = ["core", "convert", "TryFrom", "try_from"];
-pub const TRY_INTO_TRAIT: [&str; 3] = ["core", "convert", "TryInto"];
+
 pub const VEC: [&str; 3] = ["alloc", "vec", "Vec"];
 pub const VEC_AS_MUT_SLICE: [&str; 4] = ["alloc", "vec", "Vec", "as_mut_slice"];
 pub const VEC_AS_SLICE: [&str; 4] = ["alloc", "vec", "Vec", "as_slice"];
-- 
cgit 1.4.1-3-g733a5


From ecf85f4bdc319f9d9d853d1fff68a8a25e64c7a8 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Wed, 14 Jul 2021 23:34:34 +0200
Subject: Use diagnostic items for `Vec`, `VecDeque` and connected refactorings

---
 clippy_lints/src/infinite_iter.rs                  | 26 +++++++++++++---------
 clippy_lints/src/size_of_in_element_count.rs       |  2 +-
 .../src/transmute/unsound_collection_transmute.rs  | 21 ++++++++---------
 clippy_utils/src/paths.rs                          | 16 -------------
 tests/ui-internal/match_type_on_diag_item.rs       |  1 -
 tests/ui-internal/match_type_on_diag_item.stderr   |  6 ++---
 6 files changed, 30 insertions(+), 42 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/infinite_iter.rs b/clippy_lints/src/infinite_iter.rs
index 6b887da2630..295a4e1fccb 100644
--- a/clippy_lints/src/infinite_iter.rs
+++ b/clippy_lints/src/infinite_iter.rs
@@ -1,9 +1,10 @@
 use clippy_utils::diagnostics::span_lint;
-use clippy_utils::ty::{implements_trait, match_type};
+use clippy_utils::ty::{implements_trait, is_type_diagnostic_item};
 use clippy_utils::{get_trait_def_id, higher, is_qpath_def_path, paths};
 use rustc_hir::{BorrowKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::symbol::{sym, Symbol};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for iteration that is guaranteed to be infinite.
@@ -202,15 +203,15 @@ const COMPLETING_METHODS: [(&str, usize); 12] = [
 ];
 
 /// the paths of types that are known to be infinitely allocating
-const INFINITE_COLLECTORS: [&[&str]; 8] = [
-    &paths::BINARY_HEAP,
-    &paths::BTREEMAP,
-    &paths::BTREESET,
-    &paths::HASHMAP,
-    &paths::HASHSET,
-    &paths::LINKED_LIST,
-    &paths::VEC,
-    &paths::VEC_DEQUE,
+const INFINITE_COLLECTORS: &[Symbol] = &[
+    sym::BinaryHeap,
+    sym::BTreeMap,
+    sym::BTreeSet,
+    sym::hashmap_type,
+    sym::hashset_type,
+    sym::LinkedList,
+    sym::vec_type,
+    sym::vecdeque_type,
 ];
 
 fn complete_infinite_iter(cx: &LateContext<'_>, expr: &Expr<'_>) -> Finiteness {
@@ -235,7 +236,10 @@ fn complete_infinite_iter(cx: &LateContext<'_>, expr: &Expr<'_>) -> Finiteness {
                 }
             } else if method.ident.name == sym!(collect) {
                 let ty = cx.typeck_results().expr_ty(expr);
-                if INFINITE_COLLECTORS.iter().any(|path| match_type(cx, ty, path)) {
+                if INFINITE_COLLECTORS
+                    .iter()
+                    .any(|diag_item| is_type_diagnostic_item(cx, ty, *diag_item))
+                {
                     return is_infinite(cx, &args[0]);
                 }
             }
diff --git a/clippy_lints/src/size_of_in_element_count.rs b/clippy_lints/src/size_of_in_element_count.rs
index cd2bdec1707..b1965cfd601 100644
--- a/clippy_lints/src/size_of_in_element_count.rs
+++ b/clippy_lints/src/size_of_in_element_count.rs
@@ -67,7 +67,7 @@ fn get_pointee_ty_and_count_expr(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -
     const FUNCTIONS: [&[&str]; 8] = [
         &paths::PTR_COPY_NONOVERLAPPING,
         &paths::PTR_COPY,
-        &paths::WRITE_BYTES,
+        &paths::PTR_WRITE_BYTES,
         &paths::PTR_SWAP_NONOVERLAPPING,
         &paths::PTR_SLICE_FROM_RAW_PARTS,
         &paths::PTR_SLICE_FROM_RAW_PARTS_MUT,
diff --git a/clippy_lints/src/transmute/unsound_collection_transmute.rs b/clippy_lints/src/transmute/unsound_collection_transmute.rs
index de9277e016e..868c41aab43 100644
--- a/clippy_lints/src/transmute/unsound_collection_transmute.rs
+++ b/clippy_lints/src/transmute/unsound_collection_transmute.rs
@@ -1,20 +1,21 @@
 use super::utils::is_layout_incompatible;
 use super::UNSOUND_COLLECTION_TRANSMUTE;
 use clippy_utils::diagnostics::span_lint;
-use clippy_utils::{match_def_path, paths};
+use clippy_utils::match_any_diagnostic_items;
 use rustc_hir::Expr;
 use rustc_lint::LateContext;
 use rustc_middle::ty::{self, Ty};
+use rustc_span::symbol::{sym, Symbol};
 
 // used to check for UNSOUND_COLLECTION_TRANSMUTE
-static COLLECTIONS: &[&[&str]] = &[
-    &paths::VEC,
-    &paths::VEC_DEQUE,
-    &paths::BINARY_HEAP,
-    &paths::BTREESET,
-    &paths::BTREEMAP,
-    &paths::HASHSET,
-    &paths::HASHMAP,
+static COLLECTIONS: &[Symbol] = &[
+    sym::vec_type,
+    sym::vecdeque_type,
+    sym::BinaryHeap,
+    sym::BTreeSet,
+    sym::BTreeMap,
+    sym::hashset_type,
+    sym::hashmap_type,
 ];
 
 /// Checks for `unsound_collection_transmute` lint.
@@ -22,7 +23,7 @@ static COLLECTIONS: &[&[&str]] = &[
 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>, from_ty: Ty<'tcx>, to_ty: Ty<'tcx>) -> bool {
     match (&from_ty.kind(), &to_ty.kind()) {
         (ty::Adt(from_adt, from_substs), ty::Adt(to_adt, to_substs)) => {
-            if from_adt.did != to_adt.did || !COLLECTIONS.iter().any(|path| match_def_path(cx, to_adt.did, path)) {
+            if from_adt.did != to_adt.did || match_any_diagnostic_items(cx, to_adt.did, COLLECTIONS).is_none() {
                 return false;
             }
             if from_substs
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index 5ef7b459667..b0c3fe1e5a7 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -21,17 +21,11 @@ pub const ASMUT_TRAIT: [&str; 3] = ["core", "convert", "AsMut"];
 pub const ASREF_TRAIT: [&str; 3] = ["core", "convert", "AsRef"];
 pub(super) const BEGIN_PANIC: [&str; 3] = ["std", "panicking", "begin_panic"];
 pub(super) const BEGIN_PANIC_FMT: [&str; 3] = ["std", "panicking", "begin_panic_fmt"];
-/// Preferably use the diagnostic item `sym::BinaryHeap` where possible
-pub const BINARY_HEAP: [&str; 4] = ["alloc", "collections", "binary_heap", "BinaryHeap"];
 /// Preferably use the diagnostic item `sym::Borrow` where possible
 pub const BORROW_TRAIT: [&str; 3] = ["core", "borrow", "Borrow"];
-/// Preferably use the diagnostic item `sym::BTreeMap` where possible
-pub const BTREEMAP: [&str; 5] = ["alloc", "collections", "btree", "map", "BTreeMap"];
 pub const BTREEMAP_CONTAINS_KEY: [&str; 6] = ["alloc", "collections", "btree", "map", "BTreeMap", "contains_key"];
 pub const BTREEMAP_ENTRY: [&str; 6] = ["alloc", "collections", "btree", "map", "entry", "Entry"];
 pub const BTREEMAP_INSERT: [&str; 6] = ["alloc", "collections", "btree", "map", "BTreeMap", "insert"];
-/// Preferably use the diagnostic item `sym::BTreeSet` where possible
-pub const BTREESET: [&str; 5] = ["alloc", "collections", "btree", "set", "BTreeSet"];
 pub const CLONE_TRAIT_METHOD: [&str; 4] = ["core", "clone", "Clone", "clone"];
 pub const CMP_MAX: [&str; 3] = ["core", "cmp", "max"];
 pub const CMP_MIN: [&str; 3] = ["core", "cmp", "min"];
@@ -59,13 +53,9 @@ pub const FROM_ITERATOR_METHOD: [&str; 6] = ["core", "iter", "traits", "collect"
 pub const FROM_STR_METHOD: [&str; 5] = ["core", "str", "traits", "FromStr", "from_str"];
 pub const FUTURE_FROM_GENERATOR: [&str; 3] = ["core", "future", "from_generator"];
 pub const HASH: [&str; 3] = ["core", "hash", "Hash"];
-/// Preferably use the diagnostic item `sym::hashmap_type` where possible
-pub const HASHMAP: [&str; 5] = ["std", "collections", "hash", "map", "HashMap"];
 pub const HASHMAP_CONTAINS_KEY: [&str; 6] = ["std", "collections", "hash", "map", "HashMap", "contains_key"];
 pub const HASHMAP_ENTRY: [&str; 5] = ["std", "collections", "hash", "map", "Entry"];
 pub const HASHMAP_INSERT: [&str; 6] = ["std", "collections", "hash", "map", "HashMap", "insert"];
-/// Preferably use the diagnostic item `sym::hashset_type` where possible
-pub const HASHSET: [&str; 5] = ["std", "collections", "hash", "set", "HashSet"];
 #[cfg(feature = "internal-lints")]
 pub const IDENT: [&str; 3] = ["rustc_span", "symbol", "Ident"];
 #[cfg(feature = "internal-lints")]
@@ -83,8 +73,6 @@ pub const KW_MODULE: [&str; 3] = ["rustc_span", "symbol", "kw"];
 #[cfg(feature = "internal-lints")]
 pub const LATE_CONTEXT: [&str; 2] = ["rustc_lint", "LateContext"];
 pub const LIBC_STRLEN: [&str; 2] = ["libc", "strlen"];
-/// Preferably use the diagnostic item `sym::LinkedList` where possible
-pub const LINKED_LIST: [&str; 4] = ["alloc", "collections", "linked_list", "LinkedList"];
 #[cfg(any(feature = "internal-lints", feature = "metadata-collector-lint"))]
 pub const LINT: [&str; 2] = ["rustc_lint_defs", "Lint"];
 pub const MEM_DISCRIMINANT: [&str; 3] = ["core", "mem", "discriminant"];
@@ -182,14 +170,10 @@ pub const SYNTAX_CONTEXT: [&str; 3] = ["rustc_span", "hygiene", "SyntaxContext"]
 pub const TO_OWNED_METHOD: [&str; 4] = ["alloc", "borrow", "ToOwned", "to_owned"];
 pub const TO_STRING_METHOD: [&str; 4] = ["alloc", "string", "ToString", "to_string"];
 pub const TRY_FROM: [&str; 4] = ["core", "convert", "TryFrom", "try_from"];
-
-pub const VEC: [&str; 3] = ["alloc", "vec", "Vec"];
 pub const VEC_AS_MUT_SLICE: [&str; 4] = ["alloc", "vec", "Vec", "as_mut_slice"];
 pub const VEC_AS_SLICE: [&str; 4] = ["alloc", "vec", "Vec", "as_slice"];
-pub const VEC_DEQUE: [&str; 4] = ["alloc", "collections", "vec_deque", "VecDeque"];
 pub const VEC_FROM_ELEM: [&str; 3] = ["alloc", "vec", "from_elem"];
 pub const VEC_NEW: [&str; 4] = ["alloc", "vec", "Vec", "new"];
 pub const VEC_RESIZE: [&str; 4] = ["alloc", "vec", "Vec", "resize"];
 pub const WEAK_ARC: [&str; 3] = ["alloc", "sync", "Weak"];
 pub const WEAK_RC: [&str; 3] = ["alloc", "rc", "Weak"];
-pub const WRITE_BYTES: [&str; 3] = ["core", "intrinsics", "write_bytes"];
diff --git a/tests/ui-internal/match_type_on_diag_item.rs b/tests/ui-internal/match_type_on_diag_item.rs
index 063f0c6460c..be7b7a9af19 100644
--- a/tests/ui-internal/match_type_on_diag_item.rs
+++ b/tests/ui-internal/match_type_on_diag_item.rs
@@ -27,7 +27,6 @@ impl<'tcx> LateLintPass<'tcx> for Pass {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr) {
         let ty = cx.typeck_results().expr_ty(expr);
 
-        let _ = match_type(cx, ty, &paths::VEC); // FIXME: Doesn't lint external paths
         let _ = match_type(cx, ty, &OPTION);
         let _ = match_type(cx, ty, &["core", "result", "Result"]);
 
diff --git a/tests/ui-internal/match_type_on_diag_item.stderr b/tests/ui-internal/match_type_on_diag_item.stderr
index 71472960565..f5d92fc615c 100644
--- a/tests/ui-internal/match_type_on_diag_item.stderr
+++ b/tests/ui-internal/match_type_on_diag_item.stderr
@@ -1,5 +1,5 @@
 error: usage of `clippy_utils::ty::match_type()` on a type diagnostic item
-  --> $DIR/match_type_on_diag_item.rs:31:17
+  --> $DIR/match_type_on_diag_item.rs:30:17
    |
 LL |         let _ = match_type(cx, ty, &OPTION);
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `clippy_utils::ty::is_type_diagnostic_item(cx, ty, sym::option_type)`
@@ -12,13 +12,13 @@ LL | #![deny(clippy::internal)]
    = note: `#[deny(clippy::match_type_on_diagnostic_item)]` implied by `#[deny(clippy::internal)]`
 
 error: usage of `clippy_utils::ty::match_type()` on a type diagnostic item
-  --> $DIR/match_type_on_diag_item.rs:32:17
+  --> $DIR/match_type_on_diag_item.rs:31:17
    |
 LL |         let _ = match_type(cx, ty, &["core", "result", "Result"]);
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `clippy_utils::ty::is_type_diagnostic_item(cx, ty, sym::result_type)`
 
 error: usage of `clippy_utils::ty::match_type()` on a type diagnostic item
-  --> $DIR/match_type_on_diag_item.rs:35:17
+  --> $DIR/match_type_on_diag_item.rs:34:17
    |
 LL |         let _ = clippy_utils::ty::match_type(cx, ty, rc_path);
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `clippy_utils::ty::is_type_diagnostic_item(cx, ty, sym::Rc)`
-- 
cgit 1.4.1-3-g733a5


From e575610fb32c50236d56d7001f13d1143205ae5a Mon Sep 17 00:00:00 2001
From: lyj <sjtu5140809011@gmail.com>
Date: Wed, 2 Jun 2021 13:41:52 +0800
Subject: redundant_allocation: add Arc; some refractoring.

---
 clippy_lints/src/types/mod.rs                  |   4 +-
 clippy_lints/src/types/redundant_allocation.rs | 153 ++++++++++++++-----------
 tests/ui/redundant_allocation.fixed            |  48 --------
 tests/ui/redundant_allocation.rs               |  68 ++++++++---
 tests/ui/redundant_allocation.stderr           | 152 ++++++++++++++++++------
 tests/ui/redundant_allocation_fixable.fixed    |  75 ++++++++++++
 tests/ui/redundant_allocation_fixable.rs       |  75 ++++++++++++
 tests/ui/redundant_allocation_fixable.stderr   |  99 ++++++++++++++++
 8 files changed, 509 insertions(+), 165 deletions(-)
 delete mode 100644 tests/ui/redundant_allocation.fixed
 create mode 100644 tests/ui/redundant_allocation_fixable.fixed
 create mode 100644 tests/ui/redundant_allocation_fixable.rs
 create mode 100644 tests/ui/redundant_allocation_fixable.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types/mod.rs b/clippy_lints/src/types/mod.rs
index c26268a875c..7d629b5455b 100644
--- a/clippy_lints/src/types/mod.rs
+++ b/clippy_lints/src/types/mod.rs
@@ -178,8 +178,8 @@ declare_clippy_lint! {
 declare_clippy_lint! {
     /// **What it does:** Checks for use of redundant allocations anywhere in the code.
     ///
-    /// **Why is this bad?** Expressions such as `Rc<&T>`, `Rc<Rc<T>>`, `Rc<Box<T>>`, `Box<&T>`
-    /// add an unnecessary level of indirection.
+    /// **Why is this bad?** Expressions such as `Rc<&T>`, `Rc<Rc<T>>`, `Rc<Arc<T>>`, `Rc<Box<T>>`, Arc<&T>`, `Arc<Rc<T>>`,
+    /// `Arc<Arc<T>>`, `Arc<Box<T>>`, `Box<&T>`, `Box<Rc<T>>`, `Box<Arc<T>>`, `Box<Box<T>>`, add an unnecessary level of indirection.
     ///
     /// **Known problems:** None.
     ///
diff --git a/clippy_lints/src/types/redundant_allocation.rs b/clippy_lints/src/types/redundant_allocation.rs
index c0c1f340583..8e83dcbf704 100644
--- a/clippy_lints/src/types/redundant_allocation.rs
+++ b/clippy_lints/src/types/redundant_allocation.rs
@@ -1,5 +1,5 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::source::{snippet, snippet_with_applicability};
 use clippy_utils::{get_qpath_generic_tys, is_ty_param_diagnostic_item, is_ty_param_lang_item};
 use rustc_errors::Applicability;
 use rustc_hir::{self as hir, def_id::DefId, LangItem, QPath, TyKind};
@@ -9,74 +9,99 @@ use rustc_span::symbol::sym;
 use super::{utils, REDUNDANT_ALLOCATION};
 
 pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_>, def_id: DefId) -> bool {
-    if Some(def_id) == cx.tcx.lang_items().owned_box() {
-        if let Some(span) = utils::match_borrows_parameter(cx, qpath) {
-            let mut applicability = Applicability::MachineApplicable;
-            span_lint_and_sugg(
-                cx,
-                REDUNDANT_ALLOCATION,
-                hir_ty.span,
-                "usage of `Box<&T>`",
-                "try",
-                snippet_with_applicability(cx, span, "..", &mut applicability).to_string(),
-                applicability,
-            );
-            return true;
-        }
+    let outer_sym = if Some(def_id) == cx.tcx.lang_items().owned_box() {
+        "Box"
+    } else if cx.tcx.is_diagnostic_item(sym::Rc, def_id) {
+        "Rc"
+    } else if cx.tcx.is_diagnostic_item(sym::Arc, def_id) {
+        "Arc"
+    } else {
+        return false;
+    };
+
+    if let Some(span) = utils::match_borrows_parameter(cx, qpath) {
+        let mut applicability = Applicability::MaybeIncorrect;
+        let generic_snippet = snippet_with_applicability(cx, span, "..", &mut applicability);
+        span_lint_and_then(
+            cx,
+            REDUNDANT_ALLOCATION,
+            hir_ty.span,
+            &format!("usage of `{}<{}>`", outer_sym, generic_snippet),
+            |diag| {
+                diag.span_suggestion(hir_ty.span, "try", format!("{}", generic_snippet), applicability);
+                diag.note(&format!(
+                    "`{generic}` is already a pointer, `{outer}<{generic}>` allocates a pointer on the heap",
+                    outer = outer_sym,
+                    generic = generic_snippet
+                ));
+            },
+        );
+        return true;
     }
 
-    if cx.tcx.is_diagnostic_item(sym::Rc, def_id) {
-        if let Some(ty) = is_ty_param_diagnostic_item(cx, qpath, sym::Rc) {
-            let mut applicability = Applicability::MachineApplicable;
-            span_lint_and_sugg(
-                cx,
-                REDUNDANT_ALLOCATION,
-                hir_ty.span,
-                "usage of `Rc<Rc<T>>`",
-                "try",
-                snippet_with_applicability(cx, ty.span, "..", &mut applicability).to_string(),
-                applicability,
-            );
-            true
-        } else if let Some(ty) = is_ty_param_lang_item(cx, qpath, LangItem::OwnedBox) {
-            let qpath = match &ty.kind {
-                TyKind::Path(qpath) => qpath,
-                _ => return false,
-            };
-            let inner_span = match get_qpath_generic_tys(qpath).next() {
-                Some(ty) => ty.span,
-                None => return false,
-            };
-            let mut applicability = Applicability::MachineApplicable;
-            span_lint_and_sugg(
-                cx,
-                REDUNDANT_ALLOCATION,
-                hir_ty.span,
-                "usage of `Rc<Box<T>>`",
-                "try",
-                format!(
-                    "Rc<{}>",
-                    snippet_with_applicability(cx, inner_span, "..", &mut applicability)
-                ),
-                applicability,
-            );
-            true
-        } else {
-            utils::match_borrows_parameter(cx, qpath).map_or(false, |span| {
-                let mut applicability = Applicability::MachineApplicable;
-                span_lint_and_sugg(
-                    cx,
-                    REDUNDANT_ALLOCATION,
+    let (inner_sym, ty) = if let Some(ty) = is_ty_param_lang_item(cx, qpath, LangItem::OwnedBox) {
+        ("Box", ty)
+    } else if let Some(ty) = is_ty_param_diagnostic_item(cx, qpath, sym::Rc) {
+        ("Rc", ty)
+    } else if let Some(ty) = is_ty_param_diagnostic_item(cx, qpath, sym::Arc) {
+        ("Arc", ty)
+    } else {
+        return false;
+    };
+
+    let inner_qpath = match &ty.kind {
+        TyKind::Path(inner_qpath) => inner_qpath,
+        _ => return false,
+    };
+    let inner_span = match get_qpath_generic_tys(inner_qpath).next() {
+        Some(ty) => ty.span,
+        None => return false,
+    };
+    if inner_sym == outer_sym {
+        let mut applicability = Applicability::MaybeIncorrect;
+        let generic_snippet = snippet_with_applicability(cx, inner_span, "..", &mut applicability);
+        span_lint_and_then(
+            cx,
+            REDUNDANT_ALLOCATION,
+            hir_ty.span,
+            &format!("usage of `{}<{}<{}>>`", outer_sym, inner_sym, generic_snippet),
+            |diag| {
+                diag.span_suggestion(
                     hir_ty.span,
-                    "usage of `Rc<&T>`",
                     "try",
-                    snippet_with_applicability(cx, span, "..", &mut applicability).to_string(),
+                    format!("{}<{}>", outer_sym, generic_snippet),
                     applicability,
                 );
-                true
-            })
-        }
+                diag.note(&format!(
+                    "`{inner}<{generic}>` is already on the heap, `{outer}<{inner}<{generic}>>` makes an extra allocation",
+                    outer = outer_sym,
+                    inner = inner_sym,
+                    generic = generic_snippet
+                ));
+            },
+        );
     } else {
-        false
+        let generic_snippet = snippet(cx, inner_span, "..");
+        span_lint_and_then(
+            cx,
+            REDUNDANT_ALLOCATION,
+            hir_ty.span,
+            &format!("usage of `{}<{}<{}>>`", outer_sym, inner_sym, generic_snippet),
+            |diag| {
+                diag.note(&format!(
+                    "`{inner}<{generic}>` is already on the heap, `{outer}<{inner}<{generic}>>` makes an extra allocation",
+                    outer = outer_sym,
+                    inner = inner_sym,
+                    generic = generic_snippet
+                ));
+                diag.help(&format!(
+                    "consider using just `{outer}<{generic}>` or `{inner}<{generic}>`",
+                    outer = outer_sym,
+                    inner = inner_sym,
+                    generic = generic_snippet
+                ));
+            },
+        );
     }
+    true
 }
diff --git a/tests/ui/redundant_allocation.fixed b/tests/ui/redundant_allocation.fixed
deleted file mode 100644
index 6514fd6d1ac..00000000000
--- a/tests/ui/redundant_allocation.fixed
+++ /dev/null
@@ -1,48 +0,0 @@
-// run-rustfix
-#![warn(clippy::all)]
-#![allow(clippy::boxed_local, clippy::needless_pass_by_value)]
-#![allow(clippy::blacklisted_name, unused_variables, dead_code)]
-
-use std::boxed::Box;
-use std::rc::Rc;
-
-pub struct MyStruct {}
-
-pub struct SubT<T> {
-    foo: T,
-}
-
-pub enum MyEnum {
-    One,
-    Two,
-}
-
-// Rc<&T>
-
-pub fn test1<T>(foo: &T) {}
-
-pub fn test2(foo: &MyStruct) {}
-
-pub fn test3(foo: &MyEnum) {}
-
-pub fn test4_neg(foo: Rc<SubT<&usize>>) {}
-
-// Rc<Rc<T>>
-
-pub fn test5(a: Rc<bool>) {}
-
-// Rc<Box<T>>
-
-pub fn test6(a: Rc<bool>) {}
-
-// Box<&T>
-
-pub fn test7<T>(foo: &T) {}
-
-pub fn test8(foo: &MyStruct) {}
-
-pub fn test9(foo: &MyEnum) {}
-
-pub fn test10_neg(foo: Box<SubT<&usize>>) {}
-
-fn main() {}
diff --git a/tests/ui/redundant_allocation.rs b/tests/ui/redundant_allocation.rs
index 677b3e56d4d..1b4f2a66c70 100644
--- a/tests/ui/redundant_allocation.rs
+++ b/tests/ui/redundant_allocation.rs
@@ -1,10 +1,7 @@
-// run-rustfix
 #![warn(clippy::all)]
 #![allow(clippy::boxed_local, clippy::needless_pass_by_value)]
 #![allow(clippy::blacklisted_name, unused_variables, dead_code)]
-
-use std::boxed::Box;
-use std::rc::Rc;
+#![allow(unused_imports)]
 
 pub struct MyStruct {}
 
@@ -17,32 +14,67 @@ pub enum MyEnum {
     Two,
 }
 
-// Rc<&T>
+mod outer_box {
+    use crate::MyEnum;
+    use crate::MyStruct;
+    use crate::SubT;
+    use std::boxed::Box;
+    use std::rc::Rc;
+    use std::sync::Arc;
 
-pub fn test1<T>(foo: Rc<&T>) {}
+    pub fn box_test6<T>(foo: Box<Rc<T>>) {}
 
-pub fn test2(foo: Rc<&MyStruct>) {}
+    pub fn box_test7<T>(foo: Box<Arc<T>>) {}
 
-pub fn test3(foo: Rc<&MyEnum>) {}
+    pub fn box_test8() -> Box<Rc<SubT<usize>>> {
+        unimplemented!();
+    }
 
-pub fn test4_neg(foo: Rc<SubT<&usize>>) {}
+    pub fn box_test9<T>(foo: Box<Arc<T>>) -> Box<Arc<SubT<T>>> {
+        unimplemented!();
+    }
+}
 
-// Rc<Rc<T>>
+mod outer_rc {
+    use crate::MyEnum;
+    use crate::MyStruct;
+    use crate::SubT;
+    use std::boxed::Box;
+    use std::rc::Rc;
+    use std::sync::Arc;
 
-pub fn test5(a: Rc<Rc<bool>>) {}
+    pub fn rc_test5(a: Rc<Box<bool>>) {}
 
-// Rc<Box<T>>
+    pub fn rc_test7(a: Rc<Arc<bool>>) {}
 
-pub fn test6(a: Rc<Box<bool>>) {}
+    pub fn rc_test8() -> Rc<Box<SubT<usize>>> {
+        unimplemented!();
+    }
 
-// Box<&T>
+    pub fn rc_test9<T>(foo: Rc<Arc<T>>) -> Rc<Arc<SubT<T>>> {
+        unimplemented!();
+    }
+}
 
-pub fn test7<T>(foo: Box<&T>) {}
+mod outer_arc {
+    use crate::MyEnum;
+    use crate::MyStruct;
+    use crate::SubT;
+    use std::boxed::Box;
+    use std::rc::Rc;
+    use std::sync::Arc;
 
-pub fn test8(foo: Box<&MyStruct>) {}
+    pub fn arc_test5(a: Arc<Box<bool>>) {}
 
-pub fn test9(foo: Box<&MyEnum>) {}
+    pub fn arc_test6(a: Arc<Rc<bool>>) {}
 
-pub fn test10_neg(foo: Box<SubT<&usize>>) {}
+    pub fn arc_test8() -> Arc<Box<SubT<usize>>> {
+        unimplemented!();
+    }
+
+    pub fn arc_test9<T>(foo: Arc<Rc<T>>) -> Arc<Rc<SubT<T>>> {
+        unimplemented!();
+    }
+}
 
 fn main() {}
diff --git a/tests/ui/redundant_allocation.stderr b/tests/ui/redundant_allocation.stderr
index 92e4f67f5db..fdab74eb538 100644
--- a/tests/ui/redundant_allocation.stderr
+++ b/tests/ui/redundant_allocation.stderr
@@ -1,52 +1,138 @@
-error: usage of `Rc<&T>`
-  --> $DIR/redundant_allocation.rs:22:22
+error: usage of `Box<Rc<T>>`
+  --> $DIR/redundant_allocation.rs:25:30
    |
-LL | pub fn test1<T>(foo: Rc<&T>) {}
-   |                      ^^^^^^ help: try: `&T`
+LL |     pub fn box_test6<T>(foo: Box<Rc<T>>) {}
+   |                              ^^^^^^^^^^
    |
    = note: `-D clippy::redundant-allocation` implied by `-D warnings`
+   = note: `Rc<T>` is already on the heap, `Box<Rc<T>>` makes an extra allocation
+   = help: consider using just `Box<T>` or `Rc<T>`
 
-error: usage of `Rc<&T>`
-  --> $DIR/redundant_allocation.rs:24:19
+error: usage of `Box<Arc<T>>`
+  --> $DIR/redundant_allocation.rs:27:30
    |
-LL | pub fn test2(foo: Rc<&MyStruct>) {}
-   |                   ^^^^^^^^^^^^^ help: try: `&MyStruct`
+LL |     pub fn box_test7<T>(foo: Box<Arc<T>>) {}
+   |                              ^^^^^^^^^^^
+   |
+   = note: `Arc<T>` is already on the heap, `Box<Arc<T>>` makes an extra allocation
+   = help: consider using just `Box<T>` or `Arc<T>`
+
+error: usage of `Box<Rc<SubT<usize>>>`
+  --> $DIR/redundant_allocation.rs:29:27
+   |
+LL |     pub fn box_test8() -> Box<Rc<SubT<usize>>> {
+   |                           ^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `Rc<SubT<usize>>` is already on the heap, `Box<Rc<SubT<usize>>>` makes an extra allocation
+   = help: consider using just `Box<SubT<usize>>` or `Rc<SubT<usize>>`
+
+error: usage of `Box<Arc<T>>`
+  --> $DIR/redundant_allocation.rs:33:30
+   |
+LL |     pub fn box_test9<T>(foo: Box<Arc<T>>) -> Box<Arc<SubT<T>>> {
+   |                              ^^^^^^^^^^^
+   |
+   = note: `Arc<T>` is already on the heap, `Box<Arc<T>>` makes an extra allocation
+   = help: consider using just `Box<T>` or `Arc<T>`
+
+error: usage of `Box<Arc<SubT<T>>>`
+  --> $DIR/redundant_allocation.rs:33:46
+   |
+LL |     pub fn box_test9<T>(foo: Box<Arc<T>>) -> Box<Arc<SubT<T>>> {
+   |                                              ^^^^^^^^^^^^^^^^^
+   |
+   = note: `Arc<SubT<T>>` is already on the heap, `Box<Arc<SubT<T>>>` makes an extra allocation
+   = help: consider using just `Box<SubT<T>>` or `Arc<SubT<T>>`
+
+error: usage of `Rc<Box<bool>>`
+  --> $DIR/redundant_allocation.rs:46:24
+   |
+LL |     pub fn rc_test5(a: Rc<Box<bool>>) {}
+   |                        ^^^^^^^^^^^^^
+   |
+   = note: `Box<bool>` is already on the heap, `Rc<Box<bool>>` makes an extra allocation
+   = help: consider using just `Rc<bool>` or `Box<bool>`
+
+error: usage of `Rc<Arc<bool>>`
+  --> $DIR/redundant_allocation.rs:48:24
+   |
+LL |     pub fn rc_test7(a: Rc<Arc<bool>>) {}
+   |                        ^^^^^^^^^^^^^
+   |
+   = note: `Arc<bool>` is already on the heap, `Rc<Arc<bool>>` makes an extra allocation
+   = help: consider using just `Rc<bool>` or `Arc<bool>`
+
+error: usage of `Rc<Box<SubT<usize>>>`
+  --> $DIR/redundant_allocation.rs:50:26
+   |
+LL |     pub fn rc_test8() -> Rc<Box<SubT<usize>>> {
+   |                          ^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `Box<SubT<usize>>` is already on the heap, `Rc<Box<SubT<usize>>>` makes an extra allocation
+   = help: consider using just `Rc<SubT<usize>>` or `Box<SubT<usize>>`
+
+error: usage of `Rc<Arc<T>>`
+  --> $DIR/redundant_allocation.rs:54:29
+   |
+LL |     pub fn rc_test9<T>(foo: Rc<Arc<T>>) -> Rc<Arc<SubT<T>>> {
+   |                             ^^^^^^^^^^
+   |
+   = note: `Arc<T>` is already on the heap, `Rc<Arc<T>>` makes an extra allocation
+   = help: consider using just `Rc<T>` or `Arc<T>`
 
-error: usage of `Rc<&T>`
-  --> $DIR/redundant_allocation.rs:26:19
+error: usage of `Rc<Arc<SubT<T>>>`
+  --> $DIR/redundant_allocation.rs:54:44
+   |
+LL |     pub fn rc_test9<T>(foo: Rc<Arc<T>>) -> Rc<Arc<SubT<T>>> {
+   |                                            ^^^^^^^^^^^^^^^^
    |
-LL | pub fn test3(foo: Rc<&MyEnum>) {}
-   |                   ^^^^^^^^^^^ help: try: `&MyEnum`
+   = note: `Arc<SubT<T>>` is already on the heap, `Rc<Arc<SubT<T>>>` makes an extra allocation
+   = help: consider using just `Rc<SubT<T>>` or `Arc<SubT<T>>`
 
-error: usage of `Rc<Rc<T>>`
-  --> $DIR/redundant_allocation.rs:32:17
+error: usage of `Arc<Box<bool>>`
+  --> $DIR/redundant_allocation.rs:67:25
    |
-LL | pub fn test5(a: Rc<Rc<bool>>) {}
-   |                 ^^^^^^^^^^^^ help: try: `Rc<bool>`
+LL |     pub fn arc_test5(a: Arc<Box<bool>>) {}
+   |                         ^^^^^^^^^^^^^^
+   |
+   = note: `Box<bool>` is already on the heap, `Arc<Box<bool>>` makes an extra allocation
+   = help: consider using just `Arc<bool>` or `Box<bool>`
 
-error: usage of `Rc<Box<T>>`
-  --> $DIR/redundant_allocation.rs:36:17
+error: usage of `Arc<Rc<bool>>`
+  --> $DIR/redundant_allocation.rs:69:25
+   |
+LL |     pub fn arc_test6(a: Arc<Rc<bool>>) {}
+   |                         ^^^^^^^^^^^^^
    |
-LL | pub fn test6(a: Rc<Box<bool>>) {}
-   |                 ^^^^^^^^^^^^^ help: try: `Rc<bool>`
+   = note: `Rc<bool>` is already on the heap, `Arc<Rc<bool>>` makes an extra allocation
+   = help: consider using just `Arc<bool>` or `Rc<bool>`
 
-error: usage of `Box<&T>`
-  --> $DIR/redundant_allocation.rs:40:22
+error: usage of `Arc<Box<SubT<usize>>>`
+  --> $DIR/redundant_allocation.rs:71:27
    |
-LL | pub fn test7<T>(foo: Box<&T>) {}
-   |                      ^^^^^^^ help: try: `&T`
+LL |     pub fn arc_test8() -> Arc<Box<SubT<usize>>> {
+   |                           ^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `Box<SubT<usize>>` is already on the heap, `Arc<Box<SubT<usize>>>` makes an extra allocation
+   = help: consider using just `Arc<SubT<usize>>` or `Box<SubT<usize>>`
 
-error: usage of `Box<&T>`
-  --> $DIR/redundant_allocation.rs:42:19
+error: usage of `Arc<Rc<T>>`
+  --> $DIR/redundant_allocation.rs:75:30
+   |
+LL |     pub fn arc_test9<T>(foo: Arc<Rc<T>>) -> Arc<Rc<SubT<T>>> {
+   |                              ^^^^^^^^^^
    |
-LL | pub fn test8(foo: Box<&MyStruct>) {}
-   |                   ^^^^^^^^^^^^^^ help: try: `&MyStruct`
+   = note: `Rc<T>` is already on the heap, `Arc<Rc<T>>` makes an extra allocation
+   = help: consider using just `Arc<T>` or `Rc<T>`
 
-error: usage of `Box<&T>`
-  --> $DIR/redundant_allocation.rs:44:19
+error: usage of `Arc<Rc<SubT<T>>>`
+  --> $DIR/redundant_allocation.rs:75:45
+   |
+LL |     pub fn arc_test9<T>(foo: Arc<Rc<T>>) -> Arc<Rc<SubT<T>>> {
+   |                                             ^^^^^^^^^^^^^^^^
    |
-LL | pub fn test9(foo: Box<&MyEnum>) {}
-   |                   ^^^^^^^^^^^^ help: try: `&MyEnum`
+   = note: `Rc<SubT<T>>` is already on the heap, `Arc<Rc<SubT<T>>>` makes an extra allocation
+   = help: consider using just `Arc<SubT<T>>` or `Rc<SubT<T>>`
 
-error: aborting due to 8 previous errors
+error: aborting due to 15 previous errors
 
diff --git a/tests/ui/redundant_allocation_fixable.fixed b/tests/ui/redundant_allocation_fixable.fixed
new file mode 100644
index 00000000000..ef089b25f47
--- /dev/null
+++ b/tests/ui/redundant_allocation_fixable.fixed
@@ -0,0 +1,75 @@
+// run-rustfix
+#![warn(clippy::all)]
+#![allow(clippy::boxed_local, clippy::needless_pass_by_value)]
+#![allow(clippy::blacklisted_name, unused_variables, dead_code)]
+#![allow(unused_imports)]
+
+pub struct MyStruct {}
+
+pub struct SubT<T> {
+    foo: T,
+}
+
+pub enum MyEnum {
+    One,
+    Two,
+}
+
+mod outer_box {
+    use crate::MyEnum;
+    use crate::MyStruct;
+    use crate::SubT;
+    use std::boxed::Box;
+    use std::rc::Rc;
+    use std::sync::Arc;
+
+    pub fn box_test1<T>(foo: &T) {}
+
+    pub fn box_test2(foo: &MyStruct) {}
+
+    pub fn box_test3(foo: &MyEnum) {}
+
+    pub fn box_test4_neg(foo: Box<SubT<&usize>>) {}
+
+    pub fn box_test5<T>(foo: Box<T>) {}
+}
+
+mod outer_rc {
+    use crate::MyEnum;
+    use crate::MyStruct;
+    use crate::SubT;
+    use std::boxed::Box;
+    use std::rc::Rc;
+    use std::sync::Arc;
+
+    pub fn rc_test1<T>(foo: &T) {}
+
+    pub fn rc_test2(foo: &MyStruct) {}
+
+    pub fn rc_test3(foo: &MyEnum) {}
+
+    pub fn rc_test4_neg(foo: Rc<SubT<&usize>>) {}
+
+    pub fn rc_test6(a: Rc<bool>) {}
+}
+
+mod outer_arc {
+    use crate::MyEnum;
+    use crate::MyStruct;
+    use crate::SubT;
+    use std::boxed::Box;
+    use std::rc::Rc;
+    use std::sync::Arc;
+
+    pub fn arc_test1<T>(foo: &T) {}
+
+    pub fn arc_test2(foo: &MyStruct) {}
+
+    pub fn arc_test3(foo: &MyEnum) {}
+
+    pub fn arc_test4_neg(foo: Arc<SubT<&usize>>) {}
+
+    pub fn arc_test7(a: Arc<bool>) {}
+}
+
+fn main() {}
diff --git a/tests/ui/redundant_allocation_fixable.rs b/tests/ui/redundant_allocation_fixable.rs
new file mode 100644
index 00000000000..fefa87721d7
--- /dev/null
+++ b/tests/ui/redundant_allocation_fixable.rs
@@ -0,0 +1,75 @@
+// run-rustfix
+#![warn(clippy::all)]
+#![allow(clippy::boxed_local, clippy::needless_pass_by_value)]
+#![allow(clippy::blacklisted_name, unused_variables, dead_code)]
+#![allow(unused_imports)]
+
+pub struct MyStruct {}
+
+pub struct SubT<T> {
+    foo: T,
+}
+
+pub enum MyEnum {
+    One,
+    Two,
+}
+
+mod outer_box {
+    use crate::MyEnum;
+    use crate::MyStruct;
+    use crate::SubT;
+    use std::boxed::Box;
+    use std::rc::Rc;
+    use std::sync::Arc;
+
+    pub fn box_test1<T>(foo: Box<&T>) {}
+
+    pub fn box_test2(foo: Box<&MyStruct>) {}
+
+    pub fn box_test3(foo: Box<&MyEnum>) {}
+
+    pub fn box_test4_neg(foo: Box<SubT<&usize>>) {}
+
+    pub fn box_test5<T>(foo: Box<Box<T>>) {}
+}
+
+mod outer_rc {
+    use crate::MyEnum;
+    use crate::MyStruct;
+    use crate::SubT;
+    use std::boxed::Box;
+    use std::rc::Rc;
+    use std::sync::Arc;
+
+    pub fn rc_test1<T>(foo: Rc<&T>) {}
+
+    pub fn rc_test2(foo: Rc<&MyStruct>) {}
+
+    pub fn rc_test3(foo: Rc<&MyEnum>) {}
+
+    pub fn rc_test4_neg(foo: Rc<SubT<&usize>>) {}
+
+    pub fn rc_test6(a: Rc<Rc<bool>>) {}
+}
+
+mod outer_arc {
+    use crate::MyEnum;
+    use crate::MyStruct;
+    use crate::SubT;
+    use std::boxed::Box;
+    use std::rc::Rc;
+    use std::sync::Arc;
+
+    pub fn arc_test1<T>(foo: Arc<&T>) {}
+
+    pub fn arc_test2(foo: Arc<&MyStruct>) {}
+
+    pub fn arc_test3(foo: Arc<&MyEnum>) {}
+
+    pub fn arc_test4_neg(foo: Arc<SubT<&usize>>) {}
+
+    pub fn arc_test7(a: Arc<Arc<bool>>) {}
+}
+
+fn main() {}
diff --git a/tests/ui/redundant_allocation_fixable.stderr b/tests/ui/redundant_allocation_fixable.stderr
new file mode 100644
index 00000000000..fdd76ef17a5
--- /dev/null
+++ b/tests/ui/redundant_allocation_fixable.stderr
@@ -0,0 +1,99 @@
+error: usage of `Box<&T>`
+  --> $DIR/redundant_allocation_fixable.rs:26:30
+   |
+LL |     pub fn box_test1<T>(foo: Box<&T>) {}
+   |                              ^^^^^^^ help: try: `&T`
+   |
+   = note: `-D clippy::redundant-allocation` implied by `-D warnings`
+   = note: `&T` is already a pointer, `Box<&T>` allocates a pointer on the heap
+
+error: usage of `Box<&MyStruct>`
+  --> $DIR/redundant_allocation_fixable.rs:28:27
+   |
+LL |     pub fn box_test2(foo: Box<&MyStruct>) {}
+   |                           ^^^^^^^^^^^^^^ help: try: `&MyStruct`
+   |
+   = note: `&MyStruct` is already a pointer, `Box<&MyStruct>` allocates a pointer on the heap
+
+error: usage of `Box<&MyEnum>`
+  --> $DIR/redundant_allocation_fixable.rs:30:27
+   |
+LL |     pub fn box_test3(foo: Box<&MyEnum>) {}
+   |                           ^^^^^^^^^^^^ help: try: `&MyEnum`
+   |
+   = note: `&MyEnum` is already a pointer, `Box<&MyEnum>` allocates a pointer on the heap
+
+error: usage of `Box<Box<T>>`
+  --> $DIR/redundant_allocation_fixable.rs:34:30
+   |
+LL |     pub fn box_test5<T>(foo: Box<Box<T>>) {}
+   |                              ^^^^^^^^^^^ help: try: `Box<T>`
+   |
+   = note: `Box<T>` is already on the heap, `Box<Box<T>>` makes an extra allocation
+
+error: usage of `Rc<&T>`
+  --> $DIR/redundant_allocation_fixable.rs:45:29
+   |
+LL |     pub fn rc_test1<T>(foo: Rc<&T>) {}
+   |                             ^^^^^^ help: try: `&T`
+   |
+   = note: `&T` is already a pointer, `Rc<&T>` allocates a pointer on the heap
+
+error: usage of `Rc<&MyStruct>`
+  --> $DIR/redundant_allocation_fixable.rs:47:26
+   |
+LL |     pub fn rc_test2(foo: Rc<&MyStruct>) {}
+   |                          ^^^^^^^^^^^^^ help: try: `&MyStruct`
+   |
+   = note: `&MyStruct` is already a pointer, `Rc<&MyStruct>` allocates a pointer on the heap
+
+error: usage of `Rc<&MyEnum>`
+  --> $DIR/redundant_allocation_fixable.rs:49:26
+   |
+LL |     pub fn rc_test3(foo: Rc<&MyEnum>) {}
+   |                          ^^^^^^^^^^^ help: try: `&MyEnum`
+   |
+   = note: `&MyEnum` is already a pointer, `Rc<&MyEnum>` allocates a pointer on the heap
+
+error: usage of `Rc<Rc<bool>>`
+  --> $DIR/redundant_allocation_fixable.rs:53:24
+   |
+LL |     pub fn rc_test6(a: Rc<Rc<bool>>) {}
+   |                        ^^^^^^^^^^^^ help: try: `Rc<bool>`
+   |
+   = note: `Rc<bool>` is already on the heap, `Rc<Rc<bool>>` makes an extra allocation
+
+error: usage of `Arc<&T>`
+  --> $DIR/redundant_allocation_fixable.rs:64:30
+   |
+LL |     pub fn arc_test1<T>(foo: Arc<&T>) {}
+   |                              ^^^^^^^ help: try: `&T`
+   |
+   = note: `&T` is already a pointer, `Arc<&T>` allocates a pointer on the heap
+
+error: usage of `Arc<&MyStruct>`
+  --> $DIR/redundant_allocation_fixable.rs:66:27
+   |
+LL |     pub fn arc_test2(foo: Arc<&MyStruct>) {}
+   |                           ^^^^^^^^^^^^^^ help: try: `&MyStruct`
+   |
+   = note: `&MyStruct` is already a pointer, `Arc<&MyStruct>` allocates a pointer on the heap
+
+error: usage of `Arc<&MyEnum>`
+  --> $DIR/redundant_allocation_fixable.rs:68:27
+   |
+LL |     pub fn arc_test3(foo: Arc<&MyEnum>) {}
+   |                           ^^^^^^^^^^^^ help: try: `&MyEnum`
+   |
+   = note: `&MyEnum` is already a pointer, `Arc<&MyEnum>` allocates a pointer on the heap
+
+error: usage of `Arc<Arc<bool>>`
+  --> $DIR/redundant_allocation_fixable.rs:72:25
+   |
+LL |     pub fn arc_test7(a: Arc<Arc<bool>>) {}
+   |                         ^^^^^^^^^^^^^^ help: try: `Arc<bool>`
+   |
+   = note: `Arc<bool>` is already on the heap, `Arc<Arc<bool>>` makes an extra allocation
+
+error: aborting due to 12 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 7312611207b8f917f1ea9ed759c684d5ca817bfe Mon Sep 17 00:00:00 2001
From: Devin Ragotzy <devin.ragotzy@gmail.com>
Date: Thu, 15 Jul 2021 18:35:43 -0400
Subject: Add check if ty has_escaping_bound_vars in zero_sized_map_values lint

---
 clippy_lints/src/zero_sized_map_values.rs |  5 ++++-
 tests/ui/issue-7447.rs                    | 25 +++++++++++++++++++++++++
 2 files changed, 29 insertions(+), 1 deletion(-)
 create mode 100644 tests/ui/issue-7447.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/zero_sized_map_values.rs b/clippy_lints/src/zero_sized_map_values.rs
index f93f0047f51..053bbc9aea6 100644
--- a/clippy_lints/src/zero_sized_map_values.rs
+++ b/clippy_lints/src/zero_sized_map_values.rs
@@ -4,7 +4,7 @@ use clippy_utils::ty::{is_normalizable, is_type_diagnostic_item, match_type};
 use if_chain::if_chain;
 use rustc_hir::{self as hir, HirId, ItemKind, Node};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty::{Adt, Ty};
+use rustc_middle::ty::{Adt, Ty, TypeFoldable};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::sym;
 use rustc_target::abi::LayoutOf as _;
@@ -52,6 +52,9 @@ impl LateLintPass<'_> for ZeroSizedMapValues {
             if is_type_diagnostic_item(cx, ty, sym::hashmap_type) || match_type(cx, ty, &paths::BTREEMAP);
             if let Adt(_, substs) = ty.kind();
             let ty = substs.type_at(1);
+            // Fixes https://github.com/rust-lang/rust-clippy/issues/7447 because of
+            // https://github.com/rust-lang/rust/blob/master/compiler/rustc_middle/src/ty/sty.rs#L968
+            if !ty.has_escaping_bound_vars();
             // Do this to prevent `layout_of` crashing, being unable to fully normalize `ty`.
             if is_normalizable(cx, cx.param_env, ty);
             if let Ok(layout) = cx.layout_of(ty);
diff --git a/tests/ui/issue-7447.rs b/tests/ui/issue-7447.rs
new file mode 100644
index 00000000000..fdb77f32257
--- /dev/null
+++ b/tests/ui/issue-7447.rs
@@ -0,0 +1,25 @@
+use std::{borrow::Cow, collections::BTreeMap, marker::PhantomData, sync::Arc};
+
+fn byte_view<'a>(s: &'a ByteView<'_>) -> BTreeMap<&'a str, ByteView<'a>> {
+    panic!()
+}
+
+fn group_entries(s: &()) -> BTreeMap<Cow<'_, str>, Vec<Cow<'_, str>>> {
+    todo!()
+}
+
+struct Mmap;
+
+enum ByteViewBacking<'a> {
+    Buf(Cow<'a, [u8]>),
+    Mmap(Mmap),
+}
+
+pub struct ByteView<'a> {
+    backing: Arc<ByteViewBacking<'a>>,
+}
+
+fn main() {
+    byte_view(panic!());
+    group_entries(panic!());
+}
-- 
cgit 1.4.1-3-g733a5


From efbf7ca61e6d024cd73c75bbbe43999350b55ac1 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Mon, 28 Jun 2021 14:05:48 -0500
Subject: Use From to convert BinOpKind

---
 clippy_lints/src/assign_ops.rs |  4 ++--
 clippy_lints/src/eq_op.rs      |  2 +-
 clippy_utils/src/higher.rs     | 25 -------------------------
 clippy_utils/src/sugg.rs       |  2 +-
 4 files changed, 4 insertions(+), 29 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/assign_ops.rs b/clippy_lints/src/assign_ops.rs
index a8c527fe2e3..42194191837 100644
--- a/clippy_lints/src/assign_ops.rs
+++ b/clippy_lints/src/assign_ops.rs
@@ -2,7 +2,7 @@ use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::implements_trait;
 use clippy_utils::{eq_expr_value, get_trait_def_id, trait_ref_of_method};
-use clippy_utils::{higher, paths, sugg};
+use clippy_utils::{paths, sugg};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
@@ -206,7 +206,7 @@ fn lint_misrefactored_assign_op(
             if let (Some(snip_a), Some(snip_r)) = (snippet_opt(cx, assignee.span), snippet_opt(cx, rhs_other.span)) {
                 let a = &sugg::Sugg::hir(cx, assignee, "..");
                 let r = &sugg::Sugg::hir(cx, rhs, "..");
-                let long = format!("{} = {}", snip_a, sugg::make_binop(higher::binop(op.node), a, r));
+                let long = format!("{} = {}", snip_a, sugg::make_binop(op.node.into(), a, r));
                 diag.span_suggestion(
                     expr.span,
                     &format!(
diff --git a/clippy_lints/src/eq_op.rs b/clippy_lints/src/eq_op.rs
index a3a8e748d99..d39cabfb282 100644
--- a/clippy_lints/src/eq_op.rs
+++ b/clippy_lints/src/eq_op.rs
@@ -102,7 +102,7 @@ impl<'tcx> LateLintPass<'tcx> for EqOp {
             if macro_with_not_op(&left.kind) || macro_with_not_op(&right.kind) {
                 return;
             }
-            if is_useless_with_eq_exprs(higher::binop(op.node)) && eq_expr_value(cx, left, right) {
+            if is_useless_with_eq_exprs(op.node.into()) && eq_expr_value(cx, left, right) {
                 span_lint(
                     cx,
                     EQ_OP,
diff --git a/clippy_utils/src/higher.rs b/clippy_utils/src/higher.rs
index 3e3e472e99f..f32f1109b08 100644
--- a/clippy_utils/src/higher.rs
+++ b/clippy_utils/src/higher.rs
@@ -11,31 +11,6 @@ use rustc_hir::{BorrowKind, Expr, ExprKind, StmtKind, UnOp};
 use rustc_lint::LateContext;
 use rustc_span::{sym, ExpnKind, Span, Symbol};
 
-/// Converts a hir binary operator to the corresponding `ast` type.
-#[must_use]
-pub fn binop(op: hir::BinOpKind) -> ast::BinOpKind {
-    match op {
-        hir::BinOpKind::Eq => ast::BinOpKind::Eq,
-        hir::BinOpKind::Ge => ast::BinOpKind::Ge,
-        hir::BinOpKind::Gt => ast::BinOpKind::Gt,
-        hir::BinOpKind::Le => ast::BinOpKind::Le,
-        hir::BinOpKind::Lt => ast::BinOpKind::Lt,
-        hir::BinOpKind::Ne => ast::BinOpKind::Ne,
-        hir::BinOpKind::Or => ast::BinOpKind::Or,
-        hir::BinOpKind::Add => ast::BinOpKind::Add,
-        hir::BinOpKind::And => ast::BinOpKind::And,
-        hir::BinOpKind::BitAnd => ast::BinOpKind::BitAnd,
-        hir::BinOpKind::BitOr => ast::BinOpKind::BitOr,
-        hir::BinOpKind::BitXor => ast::BinOpKind::BitXor,
-        hir::BinOpKind::Div => ast::BinOpKind::Div,
-        hir::BinOpKind::Mul => ast::BinOpKind::Mul,
-        hir::BinOpKind::Rem => ast::BinOpKind::Rem,
-        hir::BinOpKind::Shl => ast::BinOpKind::Shl,
-        hir::BinOpKind::Shr => ast::BinOpKind::Shr,
-        hir::BinOpKind::Sub => ast::BinOpKind::Sub,
-    }
-}
-
 /// Represent a range akin to `ast::ExprKind::Range`.
 #[derive(Debug, Copy, Clone)]
 pub struct Range<'a> {
diff --git a/clippy_utils/src/sugg.rs b/clippy_utils/src/sugg.rs
index efc0ec50fdc..3bd75b10e90 100644
--- a/clippy_utils/src/sugg.rs
+++ b/clippy_utils/src/sugg.rs
@@ -154,7 +154,7 @@ impl<'a> Sugg<'a> {
             | hir::ExprKind::Err => Sugg::NonParen(snippet),
             hir::ExprKind::Assign(..) => Sugg::BinOp(AssocOp::Assign, snippet),
             hir::ExprKind::AssignOp(op, ..) => Sugg::BinOp(hirbinop2assignop(op), snippet),
-            hir::ExprKind::Binary(op, ..) => Sugg::BinOp(AssocOp::from_ast_binop(higher::binop(op.node)), snippet),
+            hir::ExprKind::Binary(op, ..) => Sugg::BinOp(AssocOp::from_ast_binop(op.node.into()), snippet),
             hir::ExprKind::Cast(..) => Sugg::BinOp(AssocOp::As, snippet),
             hir::ExprKind::Type(..) => Sugg::BinOp(AssocOp::Colon, snippet),
         }
-- 
cgit 1.4.1-3-g733a5


From 98c500cf8361ef1a6b7152a321515146e02cbd10 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Fri, 16 Jul 2021 14:41:19 -0500
Subject: Factor BinOp utils

---
 clippy_lints/src/assign_ops.rs             |  91 ++++++------------
 clippy_lints/src/suspicious_trait_impl.rs  | 143 ++++++-----------------------
 clippy_utils/src/lib.rs                    |  31 +++++++
 tests/ui/suspicious_arithmetic_impl.stderr |  18 ++--
 4 files changed, 95 insertions(+), 188 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/assign_ops.rs b/clippy_lints/src/assign_ops.rs
index 42194191837..17ce3cd809f 100644
--- a/clippy_lints/src/assign_ops.rs
+++ b/clippy_lints/src/assign_ops.rs
@@ -1,8 +1,8 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::implements_trait;
-use clippy_utils::{eq_expr_value, get_trait_def_id, trait_ref_of_method};
-use clippy_utils::{paths, sugg};
+use clippy_utils::{binop_traits, sugg};
+use clippy_utils::{eq_expr_value, trait_ref_of_method};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
@@ -85,71 +85,34 @@ impl<'tcx> LateLintPass<'tcx> for AssignOps {
                     let lint = |assignee: &hir::Expr<'_>, rhs: &hir::Expr<'_>| {
                         let ty = cx.typeck_results().expr_ty(assignee);
                         let rty = cx.typeck_results().expr_ty(rhs);
-                        macro_rules! ops {
-                            ($op:expr,
-                             $cx:expr,
-                             $ty:expr,
-                             $rty:expr,
-                             $($trait_name:ident),+) => {
-                                match $op {
-                                    $(hir::BinOpKind::$trait_name => {
-                                        let [krate, module] = paths::OPS_MODULE;
-                                        let path: [&str; 3] = [krate, module, concat!(stringify!($trait_name), "Assign")];
-                                        let trait_id = if let Some(trait_id) = get_trait_def_id($cx, &path) {
-                                            trait_id
-                                        } else {
-                                            return; // useless if the trait doesn't exist
-                                        };
-                                        // check that we are not inside an `impl AssignOp` of this exact operation
-                                        let parent_fn = cx.tcx.hir().get_parent_item(e.hir_id);
-                                        if_chain! {
-                                            if let Some(trait_ref) = trait_ref_of_method(cx, parent_fn);
-                                            if trait_ref.path.res.def_id() == trait_id;
-                                            then { return; }
+                        if_chain! {
+                            if let Some((_, lang_item)) = binop_traits(op.node);
+                            if let Ok(trait_id) = cx.tcx.lang_items().require(lang_item);
+                            let parent_fn = cx.tcx.hir().get_parent_item(e.hir_id);
+                            if trait_ref_of_method(cx, parent_fn)
+                                .map_or(true, |t| t.path.res.def_id() != trait_id);
+                            if implements_trait(cx, ty, trait_id, &[rty.into()]);
+                            then {
+                                span_lint_and_then(
+                                    cx,
+                                    ASSIGN_OP_PATTERN,
+                                    expr.span,
+                                    "manual implementation of an assign operation",
+                                    |diag| {
+                                        if let (Some(snip_a), Some(snip_r)) =
+                                            (snippet_opt(cx, assignee.span), snippet_opt(cx, rhs.span))
+                                        {
+                                            diag.span_suggestion(
+                                                expr.span,
+                                                "replace it with",
+                                                format!("{} {}= {}", snip_a, op.node.as_str(), snip_r),
+                                                Applicability::MachineApplicable,
+                                            );
                                         }
-                                        implements_trait($cx, $ty, trait_id, &[$rty])
-                                    },)*
-                                    _ => false,
-                                }
+                                    },
+                                );
                             }
                         }
-                        if ops!(
-                            op.node,
-                            cx,
-                            ty,
-                            rty.into(),
-                            Add,
-                            Sub,
-                            Mul,
-                            Div,
-                            Rem,
-                            And,
-                            Or,
-                            BitAnd,
-                            BitOr,
-                            BitXor,
-                            Shr,
-                            Shl
-                        ) {
-                            span_lint_and_then(
-                                cx,
-                                ASSIGN_OP_PATTERN,
-                                expr.span,
-                                "manual implementation of an assign operation",
-                                |diag| {
-                                    if let (Some(snip_a), Some(snip_r)) =
-                                        (snippet_opt(cx, assignee.span), snippet_opt(cx, rhs.span))
-                                    {
-                                        diag.span_suggestion(
-                                            expr.span,
-                                            "replace it with",
-                                            format!("{} {}= {}", snip_a, op.node.as_str(), snip_r),
-                                            Applicability::MachineApplicable,
-                                        );
-                                    }
-                                },
-                            );
-                        }
                     };
 
                     let mut visitor = ExprVisitor {
diff --git a/clippy_lints/src/suspicious_trait_impl.rs b/clippy_lints/src/suspicious_trait_impl.rs
index 2203ab57b10..f2bffd55321 100644
--- a/clippy_lints/src/suspicious_trait_impl.rs
+++ b/clippy_lints/src/suspicious_trait_impl.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint;
-use clippy_utils::{get_trait_def_id, paths, trait_ref_of_method};
+use clippy_utils::{binop_traits, trait_ref_of_method, BINOP_TRAITS, OP_ASSIGN_TRAITS};
 use if_chain::if_chain;
 use rustc_hir as hir;
 use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
@@ -55,135 +55,48 @@ declare_lint_pass!(SuspiciousImpl => [SUSPICIOUS_ARITHMETIC_IMPL, SUSPICIOUS_OP_
 
 impl<'tcx> LateLintPass<'tcx> for SuspiciousImpl {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
-        if let hir::ExprKind::Binary(binop, _, _) | hir::ExprKind::AssignOp(binop, ..) = expr.kind {
-            match binop.node {
-                hir::BinOpKind::Eq
-                | hir::BinOpKind::Lt
-                | hir::BinOpKind::Le
-                | hir::BinOpKind::Ne
-                | hir::BinOpKind::Ge
-                | hir::BinOpKind::Gt => return,
-                _ => {},
-            }
+        if_chain! {
+            if let hir::ExprKind::Binary(binop, _, _) | hir::ExprKind::AssignOp(binop, ..) = expr.kind;
+            if let Some((binop_trait_lang, op_assign_trait_lang)) = binop_traits(binop.node);
+            if let Ok(binop_trait_id) = cx.tcx.lang_items().require(binop_trait_lang);
+            if let Ok(op_assign_trait_id) = cx.tcx.lang_items().require(op_assign_trait_lang);
 
             // Check for more than one binary operation in the implemented function
             // Linting when multiple operations are involved can result in false positives
             let parent_fn = cx.tcx.hir().get_parent_item(expr.hir_id);
-            if_chain! {
-                if let hir::Node::ImplItem(impl_item) = cx.tcx.hir().get(parent_fn);
-                if let hir::ImplItemKind::Fn(_, body_id) = impl_item.kind;
-                then {
-                    let body = cx.tcx.hir().body(body_id);
-                    let mut visitor = BinaryExprVisitor { nb_binops: 0 };
-                    walk_expr(&mut visitor, &body.value);
-                    if visitor.nb_binops > 1 {
-                        return;
-                    }
-                }
-            }
-
-            if let Some(impl_trait) = check_binop(
-                cx,
-                expr,
-                binop.node,
-                &[
-                    "Add", "Sub", "Mul", "Div", "Rem", "BitAnd", "BitOr", "BitXor", "Shl", "Shr",
-                ],
-                &[
-                    hir::BinOpKind::Add,
-                    hir::BinOpKind::Sub,
-                    hir::BinOpKind::Mul,
-                    hir::BinOpKind::Div,
-                    hir::BinOpKind::Rem,
-                    hir::BinOpKind::BitAnd,
-                    hir::BinOpKind::BitOr,
-                    hir::BinOpKind::BitXor,
-                    hir::BinOpKind::Shl,
-                    hir::BinOpKind::Shr,
-                ],
-            ) {
-                span_lint(
-                    cx,
-                    SUSPICIOUS_ARITHMETIC_IMPL,
-                    binop.span,
-                    &format!("suspicious use of binary operator in `{}` impl", impl_trait),
-                );
-            }
-
-            if let Some(impl_trait) = check_binop(
-                cx,
-                expr,
-                binop.node,
-                &[
-                    "AddAssign",
-                    "SubAssign",
-                    "MulAssign",
-                    "DivAssign",
-                    "BitAndAssign",
-                    "BitOrAssign",
-                    "BitXorAssign",
-                    "RemAssign",
-                    "ShlAssign",
-                    "ShrAssign",
-                ],
-                &[
-                    hir::BinOpKind::Add,
-                    hir::BinOpKind::Sub,
-                    hir::BinOpKind::Mul,
-                    hir::BinOpKind::Div,
-                    hir::BinOpKind::BitAnd,
-                    hir::BinOpKind::BitOr,
-                    hir::BinOpKind::BitXor,
-                    hir::BinOpKind::Rem,
-                    hir::BinOpKind::Shl,
-                    hir::BinOpKind::Shr,
-                ],
-            ) {
+            if let hir::Node::ImplItem(impl_item) = cx.tcx.hir().get(parent_fn);
+            if let hir::ImplItemKind::Fn(_, body_id) = impl_item.kind;
+            let body = cx.tcx.hir().body(body_id);
+            let parent_fn = cx.tcx.hir().get_parent_item(expr.hir_id);
+            if let Some(trait_ref) = trait_ref_of_method(cx, parent_fn);
+            let trait_id = trait_ref.path.res.def_id();
+            if ![binop_trait_id, op_assign_trait_id].contains(&trait_id);
+            if let Some(&(_, lint)) = [
+                (&BINOP_TRAITS, SUSPICIOUS_ARITHMETIC_IMPL),
+                (&OP_ASSIGN_TRAITS, SUSPICIOUS_OP_ASSIGN_IMPL),
+            ]
+                .iter()
+                .find(|&(ts, _)| ts.iter().any(|&t| Ok(trait_id) == cx.tcx.lang_items().require(t)));
+            if count_binops(&body.value) == 1;
+            then {
                 span_lint(
                     cx,
-                    SUSPICIOUS_OP_ASSIGN_IMPL,
+                    lint,
                     binop.span,
-                    &format!("suspicious use of binary operator in `{}` impl", impl_trait),
+                    &format!("suspicious use of `{}` in `{}` impl", binop.node.as_str(), cx.tcx.item_name(trait_id)),
                 );
             }
         }
     }
 }
 
-fn check_binop(
-    cx: &LateContext<'_>,
-    expr: &hir::Expr<'_>,
-    binop: hir::BinOpKind,
-    traits: &[&'static str],
-    expected_ops: &[hir::BinOpKind],
-) -> Option<&'static str> {
-    let mut trait_ids = vec![];
-    let [krate, module] = paths::OPS_MODULE;
-
-    for &t in traits {
-        let path = [krate, module, t];
-        if let Some(trait_id) = get_trait_def_id(cx, &path) {
-            trait_ids.push(trait_id);
-        } else {
-            return None;
-        }
-    }
-
-    // Get the actually implemented trait
-    let parent_fn = cx.tcx.hir().get_parent_item(expr.hir_id);
-
-    if_chain! {
-        if let Some(trait_ref) = trait_ref_of_method(cx, parent_fn);
-        if let Some(idx) = trait_ids.iter().position(|&tid| tid == trait_ref.path.res.def_id());
-        if binop != expected_ops[idx];
-        then{
-            return Some(traits[idx])
-        }
-    }
-
-    None
+fn count_binops(expr: &hir::Expr<'_>) -> u32 {
+    let mut visitor = BinaryExprVisitor::default();
+    visitor.visit_expr(expr);
+    visitor.nb_binops
 }
 
+#[derive(Default)]
 struct BinaryExprVisitor {
     nb_binops: u32,
 }
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 6db221ab0fd..1fbbf4ac81f 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -1710,3 +1710,34 @@ pub fn is_test_module_or_function(tcx: TyCtxt<'_>, item: &Item<'_>) -> bool {
 
     matches!(item.kind, ItemKind::Mod(..)) && item.ident.name.as_str().contains("test")
 }
+
+macro_rules! op_utils {
+    ($($name:ident $assign:ident)*) => {
+        /// Binary operation traits like `LangItem::Add`
+        pub static BINOP_TRAITS: &[LangItem] = &[$(LangItem::$name,)*];
+
+        /// Operator-Assign traits like `LangItem::AddAssign`
+        pub static OP_ASSIGN_TRAITS: &[LangItem] = &[$(LangItem::$assign,)*];
+
+        /// Converts `BinOpKind::Add` to `(LangItem::Add, LangItem::AddAssign)`, for example
+        pub fn binop_traits(kind: hir::BinOpKind) -> Option<(LangItem, LangItem)> {
+            match kind {
+                $(hir::BinOpKind::$name => Some((LangItem::$name, LangItem::$assign)),)*
+                _ => None,
+            }
+        }
+    };
+}
+
+op_utils! {
+    Add    AddAssign
+    Sub    SubAssign
+    Mul    MulAssign
+    Div    DivAssign
+    Rem    RemAssign
+    BitXor BitXorAssign
+    BitAnd BitAndAssign
+    BitOr  BitOrAssign
+    Shl    ShlAssign
+    Shr    ShrAssign
+}
diff --git a/tests/ui/suspicious_arithmetic_impl.stderr b/tests/ui/suspicious_arithmetic_impl.stderr
index 63fc9ecb79a..ced1305874e 100644
--- a/tests/ui/suspicious_arithmetic_impl.stderr
+++ b/tests/ui/suspicious_arithmetic_impl.stderr
@@ -1,4 +1,4 @@
-error: suspicious use of binary operator in `Add` impl
+error: suspicious use of `-` in `Add` impl
   --> $DIR/suspicious_arithmetic_impl.rs:13:20
    |
 LL |         Foo(self.0 - other.0)
@@ -6,7 +6,7 @@ LL |         Foo(self.0 - other.0)
    |
    = note: `-D clippy::suspicious-arithmetic-impl` implied by `-D warnings`
 
-error: suspicious use of binary operator in `AddAssign` impl
+error: suspicious use of `-` in `AddAssign` impl
   --> $DIR/suspicious_arithmetic_impl.rs:19:23
    |
 LL |         *self = *self - other;
@@ -14,43 +14,43 @@ LL |         *self = *self - other;
    |
    = note: `-D clippy::suspicious-op-assign-impl` implied by `-D warnings`
 
-error: suspicious use of binary operator in `MulAssign` impl
+error: suspicious use of `/` in `MulAssign` impl
   --> $DIR/suspicious_arithmetic_impl.rs:32:16
    |
 LL |         self.0 /= other.0;
    |                ^^
 
-error: suspicious use of binary operator in `Rem` impl
+error: suspicious use of `/` in `Rem` impl
   --> $DIR/suspicious_arithmetic_impl.rs:70:20
    |
 LL |         Foo(self.0 / other.0)
    |                    ^
 
-error: suspicious use of binary operator in `BitAnd` impl
+error: suspicious use of `|` in `BitAnd` impl
   --> $DIR/suspicious_arithmetic_impl.rs:78:20
    |
 LL |         Foo(self.0 | other.0)
    |                    ^
 
-error: suspicious use of binary operator in `BitOr` impl
+error: suspicious use of `^` in `BitOr` impl
   --> $DIR/suspicious_arithmetic_impl.rs:86:20
    |
 LL |         Foo(self.0 ^ other.0)
    |                    ^
 
-error: suspicious use of binary operator in `BitXor` impl
+error: suspicious use of `&` in `BitXor` impl
   --> $DIR/suspicious_arithmetic_impl.rs:94:20
    |
 LL |         Foo(self.0 & other.0)
    |                    ^
 
-error: suspicious use of binary operator in `Shl` impl
+error: suspicious use of `>>` in `Shl` impl
   --> $DIR/suspicious_arithmetic_impl.rs:102:20
    |
 LL |         Foo(self.0 >> other.0)
    |                    ^^
 
-error: suspicious use of binary operator in `Shr` impl
+error: suspicious use of `<<` in `Shr` impl
   --> $DIR/suspicious_arithmetic_impl.rs:110:20
    |
 LL |         Foo(self.0 << other.0)
-- 
cgit 1.4.1-3-g733a5


From 24ec35a90433b40fcca4272dce27c107f7be51d9 Mon Sep 17 00:00:00 2001
From: F3real <stefan92ff@yandex.com>
Date: Tue, 20 Jul 2021 17:29:03 +0200
Subject: Enhance needless continue to detect loop {continue;}

---
 clippy_lints/src/needless_continue.rs | 20 ++++++++++++++++++++
 tests/ui/needless_continue.rs         |  3 +++
 tests/ui/needless_continue.stderr     | 14 +++++++++++---
 3 files changed, 34 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/needless_continue.rs b/clippy_lints/src/needless_continue.rs
index 91c97ef7c2a..6191747184b 100644
--- a/clippy_lints/src/needless_continue.rs
+++ b/clippy_lints/src/needless_continue.rs
@@ -273,6 +273,8 @@ struct LintData<'a> {
     block_stmts: &'a [ast::Stmt],
 }
 
+const MSG_REDUNDANT_CONTINUE_EXPRESSION: &str = "this `continue` expression is redundant";
+
 const MSG_REDUNDANT_ELSE_BLOCK: &str = "this `else` block is redundant";
 
 const MSG_ELSE_BLOCK_NOT_NEEDED: &str = "there is no need for an explicit `else` block for this `if` \
@@ -283,6 +285,8 @@ const DROP_ELSE_BLOCK_AND_MERGE_MSG: &str = "consider dropping the `else` clause
 
 const DROP_ELSE_BLOCK_MSG: &str = "consider dropping the `else` clause";
 
+const DROP_CONTINUE_EXPRESSION_MSG: &str = "consider dropping the `continue` expression";
+
 fn emit_warning<'a>(cx: &EarlyContext<'_>, data: &'a LintData<'_>, header: &str, typ: LintType) {
     // snip    is the whole *help* message that appears after the warning.
     // message is the warning message.
@@ -364,6 +368,22 @@ fn suggestion_snippet_for_continue_inside_else<'a>(cx: &EarlyContext<'_>, data:
 }
 
 fn check_and_warn<'a>(cx: &EarlyContext<'_>, expr: &'a ast::Expr) {
+    if_chain! {
+        if let ast::ExprKind::Loop(loop_block, ..) = &expr.kind;
+        if loop_block.stmts.len() == 1;
+        if let ast::StmtKind::Semi(ref statement) = loop_block.stmts.first().unwrap().kind;
+        if let ast::ExprKind::Continue(_) = statement.kind;
+        then {
+            span_lint_and_help(
+                cx,
+                NEEDLESS_CONTINUE,
+                loop_block.stmts.first().unwrap().span,
+                MSG_REDUNDANT_CONTINUE_EXPRESSION,
+                None,
+                DROP_CONTINUE_EXPRESSION_MSG,
+            );
+        }
+    }
     with_loop_block(expr, |loop_block, label| {
         for (i, stmt) in loop_block.stmts.iter().enumerate() {
             with_if_expr(stmt, |if_expr, cond, then_block, else_expr| {
diff --git a/tests/ui/needless_continue.rs b/tests/ui/needless_continue.rs
index 5da95647f2c..544b7e66a27 100644
--- a/tests/ui/needless_continue.rs
+++ b/tests/ui/needless_continue.rs
@@ -49,6 +49,9 @@ fn main() {
 
         println!("bleh");
     }
+    loop {
+        continue;
+    }
 }
 
 mod issue_2329 {
diff --git a/tests/ui/needless_continue.stderr b/tests/ui/needless_continue.stderr
index 8d6a37df960..6e81acdc358 100644
--- a/tests/ui/needless_continue.stderr
+++ b/tests/ui/needless_continue.stderr
@@ -54,8 +54,16 @@ LL | |         }
                        println!("Jabber");
                    }
 
+error: this `continue` expression is redundant
+  --> $DIR/needless_continue.rs:53:9
+   |
+LL |         continue;
+   |         ^^^^^^^^^
+   |
+   = help: consider dropping the `continue` expression
+
 error: this `else` block is redundant
-  --> $DIR/needless_continue.rs:100:24
+  --> $DIR/needless_continue.rs:103:24
    |
 LL |                   } else {
    |  ________________________^
@@ -78,7 +86,7 @@ LL | |                 }
                            }
 
 error: there is no need for an explicit `else` block for this `if` expression
-  --> $DIR/needless_continue.rs:106:17
+  --> $DIR/needless_continue.rs:109:17
    |
 LL | /                 if condition() {
 LL | |                     continue; // should lint here
@@ -95,5 +103,5 @@ LL | |                 }
                                println!("bar-5");
                            }
 
-error: aborting due to 4 previous errors
+error: aborting due to 5 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 9d6127cdb0bead8f3a19440e9029edc9bf2e9a25 Mon Sep 17 00:00:00 2001
From: F3real <stefan92ff@yandex.com>
Date: Wed, 21 Jul 2021 23:15:29 +0200
Subject: Emit needless_continue warning if loop ends on continue

---
 clippy_lints/src/needless_continue.rs |  6 +++---
 tests/ui/needless_continue.rs         | 12 +++++++++++-
 tests/ui/needless_continue.stderr     | 18 +++++++++++++-----
 3 files changed, 27 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/needless_continue.rs b/clippy_lints/src/needless_continue.rs
index 6191747184b..0c2b382b3d2 100644
--- a/clippy_lints/src/needless_continue.rs
+++ b/clippy_lints/src/needless_continue.rs
@@ -370,14 +370,14 @@ fn suggestion_snippet_for_continue_inside_else<'a>(cx: &EarlyContext<'_>, data:
 fn check_and_warn<'a>(cx: &EarlyContext<'_>, expr: &'a ast::Expr) {
     if_chain! {
         if let ast::ExprKind::Loop(loop_block, ..) = &expr.kind;
-        if loop_block.stmts.len() == 1;
-        if let ast::StmtKind::Semi(ref statement) = loop_block.stmts.first().unwrap().kind;
+        if !loop_block.stmts.is_empty();
+        if let ast::StmtKind::Semi(ref statement) = loop_block.stmts.last().unwrap().kind;
         if let ast::ExprKind::Continue(_) = statement.kind;
         then {
             span_lint_and_help(
                 cx,
                 NEEDLESS_CONTINUE,
-                loop_block.stmts.first().unwrap().span,
+                loop_block.stmts.last().unwrap().span,
                 MSG_REDUNDANT_CONTINUE_EXPRESSION,
                 None,
                 DROP_CONTINUE_EXPRESSION_MSG,
diff --git a/tests/ui/needless_continue.rs b/tests/ui/needless_continue.rs
index 544b7e66a27..443a21f0268 100644
--- a/tests/ui/needless_continue.rs
+++ b/tests/ui/needless_continue.rs
@@ -49,8 +49,18 @@ fn main() {
 
         println!("bleh");
     }
+}
+
+fn simple_loop() {
     loop {
-        continue;
+        continue; // should lint here
+    }
+}
+
+fn simple_loop2() {
+    loop {
+        println!("bleh");
+        continue; // should lint here
     }
 }
 
diff --git a/tests/ui/needless_continue.stderr b/tests/ui/needless_continue.stderr
index 6e81acdc358..8042b740c73 100644
--- a/tests/ui/needless_continue.stderr
+++ b/tests/ui/needless_continue.stderr
@@ -55,15 +55,23 @@ LL | |         }
                    }
 
 error: this `continue` expression is redundant
-  --> $DIR/needless_continue.rs:53:9
+  --> $DIR/needless_continue.rs:56:9
    |
-LL |         continue;
+LL |         continue; // should lint here
+   |         ^^^^^^^^^
+   |
+   = help: consider dropping the `continue` expression
+
+error: this `continue` expression is redundant
+  --> $DIR/needless_continue.rs:63:9
+   |
+LL |         continue; // should lint here
    |         ^^^^^^^^^
    |
    = help: consider dropping the `continue` expression
 
 error: this `else` block is redundant
-  --> $DIR/needless_continue.rs:103:24
+  --> $DIR/needless_continue.rs:113:24
    |
 LL |                   } else {
    |  ________________________^
@@ -86,7 +94,7 @@ LL | |                 }
                            }
 
 error: there is no need for an explicit `else` block for this `if` expression
-  --> $DIR/needless_continue.rs:109:17
+  --> $DIR/needless_continue.rs:119:17
    |
 LL | /                 if condition() {
 LL | |                     continue; // should lint here
@@ -103,5 +111,5 @@ LL | |                 }
                                println!("bar-5");
                            }
 
-error: aborting due to 5 previous errors
+error: aborting due to 6 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From c3452f3bd261e029b361c94ba8ed3bb909fde5fb Mon Sep 17 00:00:00 2001
From: F3real <stefan92ff@yandex.com>
Date: Thu, 22 Jul 2021 22:21:34 +0200
Subject: Lint on continue expression without semi-colon

---
 clippy_lints/src/needless_continue.rs |  3 ++-
 tests/ui/needless_continue.rs         | 15 +++++++++++++++
 tests/ui/needless_continue.stderr     | 22 +++++++++++++++++++---
 3 files changed, 36 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/needless_continue.rs b/clippy_lints/src/needless_continue.rs
index 0c2b382b3d2..a1f224e7d3a 100644
--- a/clippy_lints/src/needless_continue.rs
+++ b/clippy_lints/src/needless_continue.rs
@@ -371,7 +371,8 @@ fn check_and_warn<'a>(cx: &EarlyContext<'_>, expr: &'a ast::Expr) {
     if_chain! {
         if let ast::ExprKind::Loop(loop_block, ..) = &expr.kind;
         if !loop_block.stmts.is_empty();
-        if let ast::StmtKind::Semi(ref statement) = loop_block.stmts.last().unwrap().kind;
+        if let ast::StmtKind::Expr(ref statement)
+        | ast::StmtKind::Semi(ref statement) = loop_block.stmts.last().unwrap().kind;
         if let ast::ExprKind::Continue(_) = statement.kind;
         then {
             span_lint_and_help(
diff --git a/tests/ui/needless_continue.rs b/tests/ui/needless_continue.rs
index 443a21f0268..83ee27f4887 100644
--- a/tests/ui/needless_continue.rs
+++ b/tests/ui/needless_continue.rs
@@ -64,6 +64,21 @@ fn simple_loop2() {
     }
 }
 
+#[rustfmt::skip]
+fn simple_loop3() {
+    loop {
+        continue // should lint here
+    }
+}
+
+#[rustfmt::skip]
+fn simple_loop4() {
+    loop {
+        println!("bleh");
+        continue // should lint here
+    }
+}
+
 mod issue_2329 {
     fn condition() -> bool {
         unimplemented!()
diff --git a/tests/ui/needless_continue.stderr b/tests/ui/needless_continue.stderr
index 8042b740c73..22b86f25e8f 100644
--- a/tests/ui/needless_continue.stderr
+++ b/tests/ui/needless_continue.stderr
@@ -70,8 +70,24 @@ LL |         continue; // should lint here
    |
    = help: consider dropping the `continue` expression
 
+error: this `continue` expression is redundant
+  --> $DIR/needless_continue.rs:70:9
+   |
+LL |         continue // should lint here
+   |         ^^^^^^^^
+   |
+   = help: consider dropping the `continue` expression
+
+error: this `continue` expression is redundant
+  --> $DIR/needless_continue.rs:78:9
+   |
+LL |         continue // should lint here
+   |         ^^^^^^^^
+   |
+   = help: consider dropping the `continue` expression
+
 error: this `else` block is redundant
-  --> $DIR/needless_continue.rs:113:24
+  --> $DIR/needless_continue.rs:128:24
    |
 LL |                   } else {
    |  ________________________^
@@ -94,7 +110,7 @@ LL | |                 }
                            }
 
 error: there is no need for an explicit `else` block for this `if` expression
-  --> $DIR/needless_continue.rs:119:17
+  --> $DIR/needless_continue.rs:134:17
    |
 LL | /                 if condition() {
 LL | |                     continue; // should lint here
@@ -111,5 +127,5 @@ LL | |                 }
                                println!("bar-5");
                            }
 
-error: aborting due to 6 previous errors
+error: aborting due to 8 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 544c462d255e23c99d99c5ed67a7b16bf61eb563 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Fri, 23 Jul 2021 17:02:45 +0200
Subject: Documented constant expression evaluation for `repeat_once`

---
 clippy_lints/src/repeat_once.rs | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/repeat_once.rs b/clippy_lints/src/repeat_once.rs
index b479c40bca6..17cb96bc4eb 100644
--- a/clippy_lints/src/repeat_once.rs
+++ b/clippy_lints/src/repeat_once.rs
@@ -16,7 +16,11 @@ declare_clippy_lint! {
     /// - `.clone()` for `String`
     /// - `.to_vec()` for `slice`
     ///
-    /// **Why is this bad?** For example, `String.repeat(1)` is equivalent to `.clone()`. If cloning the string is the intention behind this, `clone()` should be used.
+    /// The lint will evaluate constant expressions and values as arguments of `.repeat(..)` and emit a message if
+    /// they are equivalent to `1`. (Related discussion in [rust-clippy#7306](https://github.com/rust-lang/rust-clippy/issues/7306))
+    ///
+    /// **Why is this bad?** For example, `String.repeat(1)` is equivalent to `.clone()`. If cloning
+    /// the string is the intention behind this, `clone()` should be used.
     ///
     /// **Known problems:** None.
     ///
-- 
cgit 1.4.1-3-g733a5


From 045dbb52d5bc3d97d30234c69a9c556f7d779732 Mon Sep 17 00:00:00 2001
From: F3real <stefan92ff@yandex.com>
Date: Fri, 23 Jul 2021 17:30:27 +0200
Subject: Clean up unnecessary unwraps

---
 clippy_lints/src/needless_continue.rs | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/needless_continue.rs b/clippy_lints/src/needless_continue.rs
index a1f224e7d3a..1d19413e0d0 100644
--- a/clippy_lints/src/needless_continue.rs
+++ b/clippy_lints/src/needless_continue.rs
@@ -370,15 +370,14 @@ fn suggestion_snippet_for_continue_inside_else<'a>(cx: &EarlyContext<'_>, data:
 fn check_and_warn<'a>(cx: &EarlyContext<'_>, expr: &'a ast::Expr) {
     if_chain! {
         if let ast::ExprKind::Loop(loop_block, ..) = &expr.kind;
-        if !loop_block.stmts.is_empty();
-        if let ast::StmtKind::Expr(ref statement)
-        | ast::StmtKind::Semi(ref statement) = loop_block.stmts.last().unwrap().kind;
-        if let ast::ExprKind::Continue(_) = statement.kind;
+        if let Some(last_stmt) = loop_block.stmts.last();
+        if let ast::StmtKind::Expr(inner_expr) | ast::StmtKind::Semi(inner_expr) = &last_stmt.kind;
+        if let ast::ExprKind::Continue(_) = inner_expr.kind;
         then {
             span_lint_and_help(
                 cx,
                 NEEDLESS_CONTINUE,
-                loop_block.stmts.last().unwrap().span,
+                last_stmt.span,
                 MSG_REDUNDANT_CONTINUE_EXPRESSION,
                 None,
                 DROP_CONTINUE_EXPRESSION_MSG,
-- 
cgit 1.4.1-3-g733a5


From afe5962d380d9c2caf5e5edb1aa3251ce2ec064d Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Fri, 23 Jul 2021 16:02:09 -0500
Subject: clippy::author improvements

---
 clippy_lints/src/utils/author.rs | 67 ++++++++++++++--------------------------
 tests/ui/author/blocks.rs        | 17 +++++-----
 tests/ui/author/blocks.stdout    | 30 ++++++++++++++++--
 tests/ui/author/for_loop.stdout  |  2 --
 tests/ui/author/if.stdout        |  2 --
 tests/ui/author/matches.stdout   |  4 ++-
 6 files changed, 62 insertions(+), 60 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/author.rs b/clippy_lints/src/utils/author.rs
index 39ef170ae36..d59f96b4bee 100644
--- a/clippy_lints/src/utils/author.rs
+++ b/clippy_lints/src/utils/author.rs
@@ -7,7 +7,7 @@ use rustc_ast::walk_list;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_hir as hir;
 use rustc_hir::intravisit::{NestedVisitorMap, Visitor};
-use rustc_hir::{BindingAnnotation, Block, Expr, ExprKind, Pat, PatKind, QPath, Stmt, StmtKind, TyKind};
+use rustc_hir::{Block, Expr, ExprKind, Pat, PatKind, QPath, Stmt, StmtKind, TyKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::hir::map::Map;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -132,6 +132,10 @@ impl<'tcx> LateLintPass<'tcx> for Author {
         if !has_attr(cx, stmt.hir_id) {
             return;
         }
+        match stmt.kind {
+            StmtKind::Expr(e) | StmtKind::Semi(e) if has_attr(cx, e.hir_id) => return,
+            _ => {},
+        }
         prelude();
         PrintVisitor::new("stmt").visit_stmt(stmt);
         done();
@@ -316,11 +320,13 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor {
                 self.current = cast_pat;
                 self.visit_expr(expr);
             },
-            ExprKind::Loop(body, _, desugaring, _) => {
+            ExprKind::Loop(body, _, des, _) => {
                 let body_pat = self.next("body");
-                let des = loop_desugaring_name(desugaring);
                 let label_pat = self.next("label");
-                println!("Loop(ref {}, ref {}, {}) = {};", body_pat, label_pat, des, current);
+                println!(
+                    "Loop(ref {}, ref {}, LoopSource::{:?}) = {};",
+                    body_pat, label_pat, des, current
+                );
                 self.current = body_pat;
                 self.visit_block(body);
             },
@@ -343,11 +349,13 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor {
                 self.current = then_pat;
                 self.visit_expr(then);
             },
-            ExprKind::Match(expr, arms, desugaring) => {
-                let des = desugaring_name(desugaring);
+            ExprKind::Match(expr, arms, des) => {
                 let expr_pat = self.next("expr");
                 let arms_pat = self.next("arms");
-                println!("Match(ref {}, ref {}, {}) = {};", expr_pat, arms_pat, des, current);
+                println!(
+                    "Match(ref {}, ref {}, MatchSource::{:?}) = {};",
+                    expr_pat, arms_pat, des, current
+                );
                 self.current = expr_pat;
                 self.visit_expr(expr);
                 println!("    if {}.len() == {};", arms_pat, arms.len());
@@ -536,14 +544,17 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor {
     }
 
     fn visit_block(&mut self, block: &Block<'_>) {
-        let trailing_pat = self.next("trailing_expr");
-        println!("    if let Some({}) = &{}.expr;", trailing_pat, self.current);
         println!("    if {}.stmts.len() == {};", self.current, block.stmts.len());
-        let current = self.current.clone();
+        let block_name = self.current.clone();
         for (i, stmt) in block.stmts.iter().enumerate() {
-            self.current = format!("{}.stmts[{}]", current, i);
+            self.current = format!("{}.stmts[{}]", block_name, i);
             self.visit_stmt(stmt);
         }
+        if let Some(expr) = block.expr {
+            self.current = self.next("trailing_expr");
+            println!("    if let Some({}) = &{}.expr;", self.current, block_name);
+            self.visit_expr(expr);
+        }
     }
 
     #[allow(clippy::too_many_lines)]
@@ -553,12 +564,7 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor {
         match pat.kind {
             PatKind::Wild => println!("Wild = {};", current),
             PatKind::Binding(anno, .., ident, ref sub) => {
-                let anno_pat = match anno {
-                    BindingAnnotation::Unannotated => "BindingAnnotation::Unannotated",
-                    BindingAnnotation::Mutable => "BindingAnnotation::Mutable",
-                    BindingAnnotation::Ref => "BindingAnnotation::Ref",
-                    BindingAnnotation::RefMut => "BindingAnnotation::RefMut",
-                };
+                let anno_pat = &format!("BindingAnnotation::{:?}", anno);
                 let name_pat = self.next("name");
                 if let Some(sub) = *sub {
                     let sub_pat = self.next("sub");
@@ -723,33 +729,6 @@ fn has_attr(cx: &LateContext<'_>, hir_id: hir::HirId) -> bool {
     get_attr(cx.sess(), attrs, "author").count() > 0
 }
 
-#[must_use]
-fn desugaring_name(des: hir::MatchSource) -> String {
-    match des {
-        hir::MatchSource::ForLoopDesugar => "MatchSource::ForLoopDesugar".to_string(),
-        hir::MatchSource::TryDesugar => "MatchSource::TryDesugar".to_string(),
-        hir::MatchSource::WhileDesugar => "MatchSource::WhileDesugar".to_string(),
-        hir::MatchSource::WhileLetDesugar => "MatchSource::WhileLetDesugar".to_string(),
-        hir::MatchSource::Normal => "MatchSource::Normal".to_string(),
-        hir::MatchSource::IfLetDesugar { contains_else_clause } => format!(
-            "MatchSource::IfLetDesugar {{ contains_else_clause: {} }}",
-            contains_else_clause
-        ),
-        hir::MatchSource::IfLetGuardDesugar => "MatchSource::IfLetGuardDesugar".to_string(),
-        hir::MatchSource::AwaitDesugar => "MatchSource::AwaitDesugar".to_string(),
-    }
-}
-
-#[must_use]
-fn loop_desugaring_name(des: hir::LoopSource) -> &'static str {
-    match des {
-        hir::LoopSource::ForLoop => "LoopSource::ForLoop",
-        hir::LoopSource::Loop => "LoopSource::Loop",
-        hir::LoopSource::While => "LoopSource::While",
-        hir::LoopSource::WhileLet => "LoopSource::WhileLet",
-    }
-}
-
 fn print_path(path: &QPath<'_>, first: &mut bool) {
     match *path {
         QPath::Resolved(_, path) => {
diff --git a/tests/ui/author/blocks.rs b/tests/ui/author/blocks.rs
index a8068436b70..c8465cd59aa 100644
--- a/tests/ui/author/blocks.rs
+++ b/tests/ui/author/blocks.rs
@@ -1,16 +1,15 @@
-#![feature(stmt_expr_attributes)]
 #![allow(redundant_semicolons, clippy::no_effect)]
 
 #[rustfmt::skip]
 fn main() {
     #[clippy::author]
     {
-        ;;;;
-    }
-}
-
-#[clippy::author]
-fn foo() {
-    let x = 42i32;
-    -x;
+        let x = 42i32;
+        -x;
+    };
+    #[clippy::author]
+    {
+        let expr = String::new();
+        drop(expr)
+    };
 }
diff --git a/tests/ui/author/blocks.stdout b/tests/ui/author/blocks.stdout
index c8ef75e48fc..4e3cde498af 100644
--- a/tests/ui/author/blocks.stdout
+++ b/tests/ui/author/blocks.stdout
@@ -1,12 +1,38 @@
 if_chain! {
     if let ExprKind::Block(ref block) = expr.kind;
-    if let Some(trailing_expr) = &block.expr;
-    if block.stmts.len() == 0;
+    if block.stmts.len() == 2;
+    if let StmtKind::Local(ref local) = block.stmts[0].kind;
+    if let Some(ref init) = local.init;
+    if let ExprKind::Lit(ref lit) = init.kind;
+    if let LitKind::Int(42, _) = lit.node;
+    if let PatKind::Binding(BindingAnnotation::Unannotated, _, name, None) = local.pat.kind;
+    if name.as_str() == "x";
+    if let StmtKind::Semi(ref e, _) = block.stmts[1].kind
+    if let ExprKind::Unary(UnOp::Neg, ref inner) = e.kind;
+    if let ExprKind::Path(ref path) = inner.kind;
+    if match_qpath(path, &["x"]);
     then {
         // report your lint here
     }
 }
 if_chain! {
+    if let ExprKind::Block(ref block) = expr.kind;
+    if block.stmts.len() == 1;
+    if let StmtKind::Local(ref local) = block.stmts[0].kind;
+    if let Some(ref init) = local.init;
+    if let ExprKind::Call(ref func, ref args) = init.kind;
+    if let ExprKind::Path(ref path) = func.kind;
+    if match_qpath(path, &["String", "new"]);
+    if args.len() == 0;
+    if let PatKind::Binding(BindingAnnotation::Unannotated, _, name, None) = local.pat.kind;
+    if name.as_str() == "expr";
+    if let Some(trailing_expr) = &block.expr;
+    if let ExprKind::Call(ref func1, ref args1) = trailing_expr.kind;
+    if let ExprKind::Path(ref path1) = func1.kind;
+    if match_qpath(path1, &["drop"]);
+    if args1.len() == 1;
+    if let ExprKind::Path(ref path2) = args1[0].kind;
+    if match_qpath(path2, &["expr"]);
     then {
         // report your lint here
     }
diff --git a/tests/ui/author/for_loop.stdout b/tests/ui/author/for_loop.stdout
index 3bf7607c62f..771f4f128f5 100644
--- a/tests/ui/author/for_loop.stdout
+++ b/tests/ui/author/for_loop.stdout
@@ -11,7 +11,6 @@ if_chain! {
     // unimplemented: field checks
     if arms.len() == 1;
     if let ExprKind::Loop(ref body, ref label, LoopSource::ForLoop) = arms[0].body.kind;
-    if let Some(trailing_expr) = &body.expr;
     if body.stmts.len() == 4;
     if let StmtKind::Local(ref local) = body.stmts[0].kind;
     if let PatKind::Binding(BindingAnnotation::Mutable, _, name, None) = local.pat.kind;
@@ -48,7 +47,6 @@ if_chain! {
     if name1.as_str() == "y";
     if let StmtKind::Expr(ref e1, _) = body.stmts[3].kind
     if let ExprKind::Block(ref block) = e1.kind;
-    if let Some(trailing_expr1) = &block.expr;
     if block.stmts.len() == 1;
     if let StmtKind::Local(ref local2) = block.stmts[0].kind;
     if let Some(ref init1) = local2.init;
diff --git a/tests/ui/author/if.stdout b/tests/ui/author/if.stdout
index cac64a3f40b..1b9ed366c19 100644
--- a/tests/ui/author/if.stdout
+++ b/tests/ui/author/if.stdout
@@ -3,7 +3,6 @@ if_chain! {
     if let Some(ref init) = local.init;
     if let ExprKind::If(ref cond, ref then, Some(ref else_)) = init.kind;
     if let ExprKind::Block(ref block) = else_.kind;
-    if let Some(trailing_expr) = &block.expr;
     if block.stmts.len() == 1;
     if let StmtKind::Semi(ref e, _) = block.stmts[0].kind
     if let ExprKind::Binary(ref op, ref left, ref right) = e.kind;
@@ -15,7 +14,6 @@ if_chain! {
     if let ExprKind::Lit(ref lit2) = cond.kind;
     if let LitKind::Bool(true) = lit2.node;
     if let ExprKind::Block(ref block1) = then.kind;
-    if let Some(trailing_expr1) = &block1.expr;
     if block1.stmts.len() == 1;
     if let StmtKind::Semi(ref e1, _) = block1.stmts[0].kind
     if let ExprKind::Binary(ref op1, ref left1, ref right1) = e1.kind;
diff --git a/tests/ui/author/matches.stdout b/tests/ui/author/matches.stdout
index 2e8f8227dca..68cc2b214eb 100644
--- a/tests/ui/author/matches.stdout
+++ b/tests/ui/author/matches.stdout
@@ -11,7 +11,6 @@ if_chain! {
     if let ExprKind::Lit(ref lit2) = lit_expr.kind;
     if let LitKind::Int(16, _) = lit2.node;
     if let ExprKind::Block(ref block) = arms[1].body.kind;
-    if let Some(trailing_expr) = &block.expr;
     if block.stmts.len() == 1;
     if let StmtKind::Local(ref local1) = block.stmts[0].kind;
     if let Some(ref init1) = local1.init;
@@ -19,6 +18,9 @@ if_chain! {
     if let LitKind::Int(3, _) = lit3.node;
     if let PatKind::Binding(BindingAnnotation::Unannotated, _, name, None) = local1.pat.kind;
     if name.as_str() == "x";
+    if let Some(trailing_expr) = &block.expr;
+    if let ExprKind::Path(ref path) = trailing_expr.kind;
+    if match_qpath(path, &["x"]);
     if let PatKind::Lit(ref lit_expr1) = arms[1].pat.kind
     if let ExprKind::Lit(ref lit4) = lit_expr1.kind;
     if let LitKind::Int(17, _) = lit4.node;
-- 
cgit 1.4.1-3-g733a5


From fb9b13a69ff7a65db793c442f8ac0381fe755da9 Mon Sep 17 00:00:00 2001
From: Devin Ragotzy <devin.ragotzy@gmail.com>
Date: Tue, 20 Jul 2021 19:02:48 -0400
Subject: Fix FP for nonstandard_macro_braces lint

---
 clippy_lints/src/nonstandard_macro_braces.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/nonstandard_macro_braces.rs b/clippy_lints/src/nonstandard_macro_braces.rs
index 043e7fa30d6..490ba5dce3a 100644
--- a/clippy_lints/src/nonstandard_macro_braces.rs
+++ b/clippy_lints/src/nonstandard_macro_braces.rs
@@ -99,7 +99,7 @@ fn is_offending_macro<'a>(cx: &EarlyContext<'_>, span: Span, mac_braces: &'a Mac
         if let Some(snip) = snippet_opt(cx, span.ctxt().outer_expn_data().call_site);
         // we must check only invocation sites
         // https://github.com/rust-lang/rust-clippy/issues/7422
-        if snip.starts_with(name);
+        if snip.starts_with(&format!("{}!", name));
         // make formatting consistent
         let c = snip.replace(" ", "");
         if !c.starts_with(&format!("{}!{}", name, braces.0));
-- 
cgit 1.4.1-3-g733a5


From f5c3ed4463acfcfd014a40f743b0a4863863e0f8 Mon Sep 17 00:00:00 2001
From: Devin Ragotzy <devin.ragotzy@gmail.com>
Date: Thu, 22 Jul 2021 08:55:45 -0400
Subject: Only trigger for one level of macros

---
 clippy_lints/src/nonstandard_macro_braces.rs       |  3 +-
 tests/ui-toml/nonstandard_macro_braces/clippy.toml |  1 -
 .../conf_nonstandard_macro_braces.rs               |  8 ++----
 .../conf_nonstandard_macro_braces.stderr           | 33 +---------------------
 4 files changed, 6 insertions(+), 39 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/nonstandard_macro_braces.rs b/clippy_lints/src/nonstandard_macro_braces.rs
index 490ba5dce3a..5d6d1018a68 100644
--- a/clippy_lints/src/nonstandard_macro_braces.rs
+++ b/clippy_lints/src/nonstandard_macro_braces.rs
@@ -94,7 +94,8 @@ impl EarlyLintPass for MacroBraces {
 
 fn is_offending_macro<'a>(cx: &EarlyContext<'_>, span: Span, mac_braces: &'a MacroBraces) -> Option<MacroInfo<'a>> {
     if_chain! {
-        if in_macro(span);
+        // Make sure we are only one level deep otherwise there are to many FP's
+        if in_macro(span) && !in_macro(span.ctxt().outer_expn_data().call_site);
         if let Some((name, braces)) = find_matching_macro(span, &mac_braces.macro_braces);
         if let Some(snip) = snippet_opt(cx, span.ctxt().outer_expn_data().call_site);
         // we must check only invocation sites
diff --git a/tests/ui-toml/nonstandard_macro_braces/clippy.toml b/tests/ui-toml/nonstandard_macro_braces/clippy.toml
index 50ee363c3ad..bced8948a02 100644
--- a/tests/ui-toml/nonstandard_macro_braces/clippy.toml
+++ b/tests/ui-toml/nonstandard_macro_braces/clippy.toml
@@ -3,5 +3,4 @@ standard-macro-braces = [
     { name = "quote::quote", brace = "{" },
     { name = "eprint", brace = "[" },
     { name = "type_pos", brace = "[" },
-    { name = "printlnfoo", brace = "[" },
 ]
diff --git a/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.rs b/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.rs
index 3d884abb4c6..f169fd5ba9c 100644
--- a/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.rs
+++ b/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.rs
@@ -34,7 +34,7 @@ macro_rules! type_pos {
 
 macro_rules! printlnfoo {
     ($thing:expr) => {
-        println!("hey {}", $thing)
+        println!("{}", $thing)
     };
 }
 
@@ -44,7 +44,7 @@ fn main() {
     let _ = format!["ugh {} stop being such a good compiler", "hello"];
     let _ = quote!(let x = 1;);
     let _ = quote::quote!(match match match);
-    let _ = test!();
+    let _ = test!(); // don't trigger for macro calls inside macros
     let _ = vec![1,2,3];
 
     let _ = quote::quote! {true || false};
@@ -56,7 +56,5 @@ fn main() {
 
     eprint!("test if user config overrides defaults");
 
-    println!("test if println triggers for printlnfoo");
-
-    printlnfoo!("you");
+    printlnfoo!["test if printlnfoo is triggered by println"];
 }
diff --git a/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.stderr b/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.stderr
index 4c3194e258e..846379def0c 100644
--- a/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.stderr
+++ b/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.stderr
@@ -47,25 +47,6 @@ help: consider writing `quote::quote! {match match match}`
 LL |     let _ = quote::quote!(match match match);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: use of irregular braces for `vec!` macro
-  --> $DIR/conf_nonstandard_macro_braces.rs:18:9
-   |
-LL |         vec!{0, 0, 0}
-   |         ^^^^^^^^^^^^^
-...
-LL |     let _ = test!();
-   |             ------- in this macro invocation
-   |
-help: consider writing `vec![0, 0, 0]`
-  --> $DIR/conf_nonstandard_macro_braces.rs:18:9
-   |
-LL |         vec!{0, 0, 0}
-   |         ^^^^^^^^^^^^^
-...
-LL |     let _ = test!();
-   |             ------- in this macro invocation
-   = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)
-
 error: use of irregular braces for `type_pos!` macro
   --> $DIR/conf_nonstandard_macro_braces.rs:55:12
    |
@@ -90,17 +71,5 @@ help: consider writing `eprint!["test if user config overrides defaults"];`
 LL |     eprint!("test if user config overrides defaults");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: use of irregular braces for `printlnfoo!` macro
-  --> $DIR/conf_nonstandard_macro_braces.rs:61:5
-   |
-LL |     printlnfoo!("you");
-   |     ^^^^^^^^^^^^^^^^^^^
-   |
-help: consider writing `printlnfoo!["you"];`
-  --> $DIR/conf_nonstandard_macro_braces.rs:61:5
-   |
-LL |     printlnfoo!("you");
-   |     ^^^^^^^^^^^^^^^^^^^
-
-error: aborting due to 8 previous errors
+error: aborting due to 6 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 44d37a44bc9d6382424c903a624080bd8d9fa966 Mon Sep 17 00:00:00 2001
From: Devin Ragotzy <devin.ragotzy@gmail.com>
Date: Sat, 24 Jul 2021 07:03:52 -0400
Subject: Lint inside macro when owned by current crate

---
 clippy_lints/src/nonstandard_macro_braces.rs        |  9 ++++++++-
 .../conf_nonstandard_macro_braces.rs                |  2 +-
 .../conf_nonstandard_macro_braces.stderr            | 21 ++++++++++++++++++++-
 3 files changed, 29 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/nonstandard_macro_braces.rs b/clippy_lints/src/nonstandard_macro_braces.rs
index 5d6d1018a68..2a318946656 100644
--- a/clippy_lints/src/nonstandard_macro_braces.rs
+++ b/clippy_lints/src/nonstandard_macro_braces.rs
@@ -93,14 +93,21 @@ impl EarlyLintPass for MacroBraces {
 }
 
 fn is_offending_macro<'a>(cx: &EarlyContext<'_>, span: Span, mac_braces: &'a MacroBraces) -> Option<MacroInfo<'a>> {
+    let unnested_or_local = || {
+        let nested = in_macro(span.ctxt().outer_expn_data().call_site);
+        let in_local_macro = nested
+            && matches!(span.macro_backtrace().last().and_then(|e| e.macro_def_id), Some(defid) if defid.is_local());
+        !nested || in_local_macro
+    };
     if_chain! {
         // Make sure we are only one level deep otherwise there are to many FP's
-        if in_macro(span) && !in_macro(span.ctxt().outer_expn_data().call_site);
+        if in_macro(span);
         if let Some((name, braces)) = find_matching_macro(span, &mac_braces.macro_braces);
         if let Some(snip) = snippet_opt(cx, span.ctxt().outer_expn_data().call_site);
         // we must check only invocation sites
         // https://github.com/rust-lang/rust-clippy/issues/7422
         if snip.starts_with(&format!("{}!", name));
+        if unnested_or_local();
         // make formatting consistent
         let c = snip.replace(" ", "");
         if !c.starts_with(&format!("{}!{}", name, braces.0));
diff --git a/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.rs b/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.rs
index f169fd5ba9c..5b4adc868df 100644
--- a/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.rs
+++ b/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.rs
@@ -44,7 +44,7 @@ fn main() {
     let _ = format!["ugh {} stop being such a good compiler", "hello"];
     let _ = quote!(let x = 1;);
     let _ = quote::quote!(match match match);
-    let _ = test!(); // don't trigger for macro calls inside macros
+    let _ = test!(); // trigger when macro def is inside our own crate
     let _ = vec![1,2,3];
 
     let _ = quote::quote! {true || false};
diff --git a/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.stderr b/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.stderr
index 846379def0c..87e962b9228 100644
--- a/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.stderr
+++ b/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.stderr
@@ -47,6 +47,25 @@ help: consider writing `quote::quote! {match match match}`
 LL |     let _ = quote::quote!(match match match);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
+error: use of irregular braces for `vec!` macro
+  --> $DIR/conf_nonstandard_macro_braces.rs:18:9
+   |
+LL |         vec!{0, 0, 0}
+   |         ^^^^^^^^^^^^^
+...
+LL |     let _ = test!(); // trigger when macro def is inside our own crate
+   |             ------- in this macro invocation
+   |
+help: consider writing `vec![0, 0, 0]`
+  --> $DIR/conf_nonstandard_macro_braces.rs:18:9
+   |
+LL |         vec!{0, 0, 0}
+   |         ^^^^^^^^^^^^^
+...
+LL |     let _ = test!(); // trigger when macro def is inside our own crate
+   |             ------- in this macro invocation
+   = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)
+
 error: use of irregular braces for `type_pos!` macro
   --> $DIR/conf_nonstandard_macro_braces.rs:55:12
    |
@@ -71,5 +90,5 @@ help: consider writing `eprint!["test if user config overrides defaults"];`
 LL |     eprint!("test if user config overrides defaults");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 6 previous errors
+error: aborting due to 7 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From d3492a0894429e1c9ab7abb876176dd94682b9c0 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Sun, 25 Jul 2021 16:35:35 -0500
Subject: author: check block.expr: None

---
 clippy_lints/src/utils/author.rs | 2 ++
 tests/ui/author/blocks.stdout    | 1 +
 tests/ui/author/for_loop.stdout  | 2 ++
 tests/ui/author/if.stdout        | 2 ++
 4 files changed, 7 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/author.rs b/clippy_lints/src/utils/author.rs
index d59f96b4bee..c1e7fd7fe95 100644
--- a/clippy_lints/src/utils/author.rs
+++ b/clippy_lints/src/utils/author.rs
@@ -554,6 +554,8 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor {
             self.current = self.next("trailing_expr");
             println!("    if let Some({}) = &{}.expr;", self.current, block_name);
             self.visit_expr(expr);
+        } else {
+            println!("    if {}.expr.is_none();", block_name);
         }
     }
 
diff --git a/tests/ui/author/blocks.stdout b/tests/ui/author/blocks.stdout
index 4e3cde498af..854bc28083a 100644
--- a/tests/ui/author/blocks.stdout
+++ b/tests/ui/author/blocks.stdout
@@ -11,6 +11,7 @@ if_chain! {
     if let ExprKind::Unary(UnOp::Neg, ref inner) = e.kind;
     if let ExprKind::Path(ref path) = inner.kind;
     if match_qpath(path, &["x"]);
+    if block.expr.is_none();
     then {
         // report your lint here
     }
diff --git a/tests/ui/author/for_loop.stdout b/tests/ui/author/for_loop.stdout
index 771f4f128f5..f1b4d4e096e 100644
--- a/tests/ui/author/for_loop.stdout
+++ b/tests/ui/author/for_loop.stdout
@@ -54,6 +54,8 @@ if_chain! {
     if match_qpath(path9, &["y"]);
     if let PatKind::Binding(BindingAnnotation::Unannotated, _, name2, None) = local2.pat.kind;
     if name2.as_str() == "z";
+    if block.expr.is_none();
+    if body.expr.is_none();
     if let PatKind::Binding(BindingAnnotation::Mutable, _, name3, None) = arms[0].pat.kind;
     if name3.as_str() == "iter";
     then {
diff --git a/tests/ui/author/if.stdout b/tests/ui/author/if.stdout
index 1b9ed366c19..502b38545b8 100644
--- a/tests/ui/author/if.stdout
+++ b/tests/ui/author/if.stdout
@@ -11,6 +11,7 @@ if_chain! {
     if let LitKind::Int(2, _) = lit.node;
     if let ExprKind::Lit(ref lit1) = right.kind;
     if let LitKind::Int(2, _) = lit1.node;
+    if block.expr.is_none();
     if let ExprKind::Lit(ref lit2) = cond.kind;
     if let LitKind::Bool(true) = lit2.node;
     if let ExprKind::Block(ref block1) = then.kind;
@@ -22,6 +23,7 @@ if_chain! {
     if let LitKind::Int(1, _) = lit3.node;
     if let ExprKind::Lit(ref lit4) = right1.kind;
     if let LitKind::Int(1, _) = lit4.node;
+    if block1.expr.is_none();
     if let PatKind::Wild = local.pat.kind;
     then {
         // report your lint here
-- 
cgit 1.4.1-3-g733a5


From 89c8c3f4cdf4bc3289007d52932564dea6b3bf6d Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Sun, 25 Jul 2021 20:35:51 +0200
Subject: Prefer a code snipped over formatting the self type
 (`new_without_default`)

---
 clippy_lints/src/new_without_default.rs | 15 +++++++++------
 tests/ui/new_without_default.rs         | 12 ++++++++++++
 tests/ui/new_without_default.stderr     | 32 +++++++++++++++++++++++++-------
 3 files changed, 46 insertions(+), 13 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/new_without_default.rs b/clippy_lints/src/new_without_default.rs
index a5f91eb035f..ae769c82081 100644
--- a/clippy_lints/src/new_without_default.rs
+++ b/clippy_lints/src/new_without_default.rs
@@ -9,7 +9,7 @@ use rustc_hir as hir;
 use rustc_hir::HirIdSet;
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_middle::ty::{Ty, TyS};
+use rustc_middle::ty::TyS;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::sym;
 
@@ -65,6 +65,7 @@ impl<'tcx> LateLintPass<'tcx> for NewWithoutDefault {
         if let hir::ItemKind::Impl(hir::Impl {
             of_trait: None,
             ref generics,
+            self_ty: impl_self_ty,
             items,
             ..
         }) = item.kind
@@ -132,6 +133,8 @@ impl<'tcx> LateLintPass<'tcx> for NewWithoutDefault {
                                 }
 
                                 let generics_sugg = snippet(cx, generics.span, "");
+                                let self_ty_fmt = self_ty.to_string();
+                                let self_type_snip = snippet(cx, impl_self_ty.span, &self_ty_fmt);
                                 span_lint_hir_and_then(
                                     cx,
                                     NEW_WITHOUT_DEFAULT,
@@ -139,14 +142,14 @@ impl<'tcx> LateLintPass<'tcx> for NewWithoutDefault {
                                     impl_item.span,
                                     &format!(
                                         "you should consider adding a `Default` implementation for `{}`",
-                                        self_ty
+                                        self_type_snip
                                     ),
                                     |diag| {
                                         diag.suggest_prepend_item(
                                             cx,
                                             item.span,
-                                            "try this",
-                                            &create_new_without_default_suggest_msg(self_ty, &generics_sugg),
+                                            "try adding this",
+                                            &create_new_without_default_suggest_msg(&self_type_snip, &generics_sugg),
                                             Applicability::MaybeIncorrect,
                                         );
                                     },
@@ -160,12 +163,12 @@ impl<'tcx> LateLintPass<'tcx> for NewWithoutDefault {
     }
 }
 
-fn create_new_without_default_suggest_msg(ty: Ty<'_>, generics_sugg: &str) -> String {
+fn create_new_without_default_suggest_msg(self_type_snip: &str, generics_sugg: &str) -> String {
     #[rustfmt::skip]
     format!(
 "impl{} Default for {} {{
     fn default() -> Self {{
         Self::new()
     }}
-}}", generics_sugg, ty)
+}}", generics_sugg, self_type_snip)
 }
diff --git a/tests/ui/new_without_default.rs b/tests/ui/new_without_default.rs
index 58094646b50..4b2e7444dcf 100644
--- a/tests/ui/new_without_default.rs
+++ b/tests/ui/new_without_default.rs
@@ -173,4 +173,16 @@ impl<T: Copy> BarGenerics<T> {
     }
 }
 
+pub mod issue7220 {
+    pub struct Foo<T> {
+        _bar: *mut T,
+    }
+
+    impl<T> Foo<T> {
+        pub fn new() -> Self {
+            todo!()
+        }
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/new_without_default.stderr b/tests/ui/new_without_default.stderr
index 56c5fe1c618..7c964000807 100644
--- a/tests/ui/new_without_default.stderr
+++ b/tests/ui/new_without_default.stderr
@@ -7,7 +7,7 @@ LL | |     }
    | |_____^
    |
    = note: `-D clippy::new-without-default` implied by `-D warnings`
-help: try this
+help: try adding this
    |
 LL | impl Default for Foo {
 LL |     fn default() -> Self {
@@ -24,7 +24,7 @@ LL | |         Bar
 LL | |     }
    | |_____^
    |
-help: try this
+help: try adding this
    |
 LL | impl Default for Bar {
 LL |     fn default() -> Self {
@@ -41,7 +41,7 @@ LL | |         unimplemented!()
 LL | |     }
    | |_____^
    |
-help: try this
+help: try adding this
    |
 LL | impl<'c> Default for LtKo<'c> {
 LL |     fn default() -> Self {
@@ -58,7 +58,7 @@ LL | |         NewNotEqualToDerive { foo: 1 }
 LL | |     }
    | |_____^
    |
-help: try this
+help: try adding this
    |
 LL | impl Default for NewNotEqualToDerive {
 LL |     fn default() -> Self {
@@ -75,7 +75,7 @@ LL | |         Self(Default::default())
 LL | |     }
    | |_____^
    |
-help: try this
+help: try adding this
    |
 LL | impl<T> Default for FooGenerics<T> {
 LL |     fn default() -> Self {
@@ -92,7 +92,7 @@ LL | |         Self(Default::default())
 LL | |     }
    | |_____^
    |
-help: try this
+help: try adding this
    |
 LL | impl<T: Copy> Default for BarGenerics<T> {
 LL |     fn default() -> Self {
@@ -101,5 +101,23 @@ LL |     }
 LL | }
    |
 
-error: aborting due to 6 previous errors
+error: you should consider adding a `Default` implementation for `Foo<T>`
+  --> $DIR/new_without_default.rs:182:9
+   |
+LL | /         pub fn new() -> Self {
+LL | |             todo!()
+LL | |         }
+   | |_________^
+   |
+help: try adding this
+   |
+LL |     impl<T> Default for Foo<T> {
+LL |         fn default() -> Self {
+LL |             Self::new()
+LL |         }
+LL |     }
+LL | 
+ ...
+
+error: aborting due to 7 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From a1bab3bc63d183d3d319d52742e31fa54ec7caae Mon Sep 17 00:00:00 2001
From: Devin Ragotzy <devin.ragotzy@gmail.com>
Date: Thu, 22 Jul 2021 08:40:24 -0400
Subject: Add primitive type support to disallowed_type lint

Fix docs of disallowed_type

Add ability to name primitive types without import path

Move primitive resolution to clippy_utils path_to_res fn

Refactor Res matching, fix naming and docs from review

Use tcx.def_path_str when emitting the lint
---
 clippy_lints/src/disallowed_type.rs                | 78 ++++++++++------------
 clippy_utils/src/lib.rs                            |  5 +-
 tests/ui-toml/toml_disallowed_type/clippy.toml     |  2 +
 .../toml_disallowed_type/conf_disallowed_type.rs   | 15 +++--
 .../conf_disallowed_type.stderr                    | 58 ++++++++++++----
 5 files changed, 94 insertions(+), 64 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/disallowed_type.rs b/clippy_lints/src/disallowed_type.rs
index e4a88c6324e..7c76e2322c2 100644
--- a/clippy_lints/src/disallowed_type.rs
+++ b/clippy_lints/src/disallowed_type.rs
@@ -2,7 +2,7 @@ use clippy_utils::diagnostics::span_lint;
 
 use rustc_data_structures::fx::FxHashSet;
 use rustc_hir::{
-    def::Res, def_id::DefId, Crate, Item, ItemKind, PolyTraitRef, TraitBoundModifier, Ty, TyKind, UseKind,
+    def::Res, def_id::DefId, Crate, Item, ItemKind, PolyTraitRef, PrimTy, TraitBoundModifier, Ty, TyKind, UseKind,
 };
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
@@ -15,14 +15,12 @@ declare_clippy_lint! {
     ///
     /// **Known problems:** None.
     ///
-    /// N.B. There is no way to ban primitive types.
-    ///
     /// **Example:**
     ///
     /// An example clippy.toml configuration:
     /// ```toml
     /// # clippy.toml
-    /// disallowed-methods = ["std::collections::BTreeMap"]
+    /// disallowed-types = ["std::collections::BTreeMap"]
     /// ```
     ///
     /// ```rust,ignore
@@ -42,7 +40,8 @@ declare_clippy_lint! {
 #[derive(Clone, Debug)]
 pub struct DisallowedType {
     disallowed: FxHashSet<Vec<Symbol>>,
-    def_ids: FxHashSet<(DefId, Vec<Symbol>)>,
+    def_ids: FxHashSet<DefId>,
+    prim_tys: FxHashSet<PrimTy>,
 }
 
 impl DisallowedType {
@@ -53,6 +52,23 @@ impl DisallowedType {
                 .map(|s| s.split("::").map(|seg| Symbol::intern(seg)).collect::<Vec<_>>())
                 .collect(),
             def_ids: FxHashSet::default(),
+            prim_tys: FxHashSet::default(),
+        }
+    }
+
+    fn check_res_emit(&self, cx: &LateContext<'_>, res: &Res, span: Span) {
+        match res {
+            Res::Def(_, did) => {
+                if self.def_ids.contains(did) {
+                    emit(cx, &cx.tcx.def_path_str(*did), span);
+                }
+            },
+            Res::PrimTy(prim) => {
+                if self.prim_tys.contains(prim) {
+                    emit(cx, prim.name_str(), span);
+                }
+            },
+            _ => {},
         }
     }
 }
@@ -63,60 +79,36 @@ impl<'tcx> LateLintPass<'tcx> for DisallowedType {
     fn check_crate(&mut self, cx: &LateContext<'_>, _: &Crate<'_>) {
         for path in &self.disallowed {
             let segs = path.iter().map(ToString::to_string).collect::<Vec<_>>();
-            if let Res::Def(_, id) = clippy_utils::path_to_res(cx, &segs.iter().map(String::as_str).collect::<Vec<_>>())
-            {
-                self.def_ids.insert((id, path.clone()));
+            match clippy_utils::path_to_res(cx, &segs.iter().map(String::as_str).collect::<Vec<_>>()) {
+                Res::Def(_, id) => {
+                    self.def_ids.insert(id);
+                },
+                Res::PrimTy(ty) => {
+                    self.prim_tys.insert(ty);
+                },
+                _ => {},
             }
         }
     }
 
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
-        if_chain! {
-            if let ItemKind::Use(path, UseKind::Single) = &item.kind;
-            if let Res::Def(_, did) = path.res;
-            if let Some((_, name)) = self.def_ids.iter().find(|(id, _)| *id == did);
-            then {
-                emit(cx, name, item.span,);
-            }
+        if let ItemKind::Use(path, UseKind::Single) = &item.kind {
+            self.check_res_emit(cx, &path.res, item.span);
         }
     }
 
     fn check_ty(&mut self, cx: &LateContext<'tcx>, ty: &'tcx Ty<'tcx>) {
-        if_chain! {
-            if let TyKind::Path(path) = &ty.kind;
-            if let Some(did) = cx.qpath_res(path, ty.hir_id).opt_def_id();
-            if let Some((_, name)) = self.def_ids.iter().find(|(id, _)| *id == did);
-            then {
-                emit(cx, name, path.span());
-            }
+        if let TyKind::Path(path) = &ty.kind {
+            self.check_res_emit(cx, &cx.qpath_res(path, ty.hir_id), ty.span);
         }
     }
 
     fn check_poly_trait_ref(&mut self, cx: &LateContext<'tcx>, poly: &'tcx PolyTraitRef<'tcx>, _: TraitBoundModifier) {
-        if_chain! {
-            if let Res::Def(_, did) = poly.trait_ref.path.res;
-            if let Some((_, name)) = self.def_ids.iter().find(|(id, _)| *id == did);
-            then {
-                emit(cx, name, poly.trait_ref.path.span);
-            }
-        }
+        self.check_res_emit(cx, &poly.trait_ref.path.res, poly.trait_ref.path.span);
     }
-
-    // TODO: if non primitive const generics are a thing
-    // fn check_generic_arg(&mut self, cx: &LateContext<'tcx>, arg: &'tcx GenericArg<'tcx>) {
-    //     match arg {
-    //         GenericArg::Const(c) => {},
-    //     }
-    // }
-    // fn check_generic_param(&mut self, cx: &LateContext<'tcx>, param: &'tcx GenericParam<'tcx>) {
-    //     match param.kind {
-    //         GenericParamKind::Const { .. } => {},
-    //     }
-    // }
 }
 
-fn emit(cx: &LateContext<'_>, name: &[Symbol], span: Span) {
-    let name = name.iter().map(|s| s.to_ident_string()).collect::<Vec<_>>().join("::");
+fn emit(cx: &LateContext<'_>, name: &str, span: Span) {
     span_lint(
         cx,
         DISALLOWED_TYPE,
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 6dfb8c38a76..59f878f8b20 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -72,7 +72,7 @@ use rustc_hir::LangItem::{ResultErr, ResultOk};
 use rustc_hir::{
     def, Arm, BindingAnnotation, Block, Body, Constness, Destination, Expr, ExprKind, FnDecl, GenericArgs, HirId, Impl,
     ImplItem, ImplItemKind, IsAsync, Item, ItemKind, LangItem, Local, MatchSource, Node, Param, Pat, PatKind, Path,
-    PathSegment, QPath, Stmt, StmtKind, TraitItem, TraitItemKind, TraitRef, TyKind, UnOp,
+    PathSegment, PrimTy, QPath, Stmt, StmtKind, TraitItem, TraitItemKind, TraitRef, TyKind, UnOp,
 };
 use rustc_lint::{LateContext, Level, Lint, LintContext};
 use rustc_middle::hir::exports::Export;
@@ -490,6 +490,9 @@ pub fn path_to_res(cx: &LateContext<'_>, path: &[&str]) -> Res {
 
     let (krate, first, path) = match *path {
         [krate, first, ref path @ ..] => (krate, first, path),
+        [primitive] => {
+            return PrimTy::from_name(Symbol::intern(primitive)).map_or(Res::Err, Res::PrimTy);
+        },
         _ => return Res::Err,
     };
     let tcx = cx.tcx;
diff --git a/tests/ui-toml/toml_disallowed_type/clippy.toml b/tests/ui-toml/toml_disallowed_type/clippy.toml
index 2eff854c22c..dac4446703b 100644
--- a/tests/ui-toml/toml_disallowed_type/clippy.toml
+++ b/tests/ui-toml/toml_disallowed_type/clippy.toml
@@ -6,4 +6,6 @@ disallowed-types = [
     "std::thread::Thread",
     "std::time::Instant",
     "std::io::Read",
+    "std::primitive::usize",
+    "bool"
 ]
diff --git a/tests/ui-toml/toml_disallowed_type/conf_disallowed_type.rs b/tests/ui-toml/toml_disallowed_type/conf_disallowed_type.rs
index 567afb5aec1..0871a3073ab 100644
--- a/tests/ui-toml/toml_disallowed_type/conf_disallowed_type.rs
+++ b/tests/ui-toml/toml_disallowed_type/conf_disallowed_type.rs
@@ -13,13 +13,15 @@ fn bad_return_type() -> fn() -> Sneaky {
     todo!()
 }
 
-fn bad_arg_type(_: impl Fn(Sneaky) -> foo::atomic::AtomicU32) {
-    todo!()
-}
+fn bad_arg_type(_: impl Fn(Sneaky) -> foo::atomic::AtomicU32) {}
 
-fn trait_obj(_: &dyn std::io::Read) {
-    todo!()
-}
+fn trait_obj(_: &dyn std::io::Read) {}
+
+fn full_and_single_path_prim(_: usize, _: bool) {}
+
+fn const_generics<const C: usize>() {}
+
+struct GenArg<const U: usize>([u8; U]);
 
 static BAD: foo::atomic::AtomicPtr<()> = foo::atomic::AtomicPtr::new(std::ptr::null_mut());
 
@@ -32,4 +34,5 @@ fn main() {
     let _: std::collections::BTreeMap<(), syn::TypePath> = Default::default();
     let _ = syn::Ident::new("", todo!());
     let _ = HashMap;
+    let _: usize = 64_usize;
 }
diff --git a/tests/ui-toml/toml_disallowed_type/conf_disallowed_type.stderr b/tests/ui-toml/toml_disallowed_type/conf_disallowed_type.stderr
index 4e6fd91fba1..90ce7db2cc4 100644
--- a/tests/ui-toml/toml_disallowed_type/conf_disallowed_type.stderr
+++ b/tests/ui-toml/toml_disallowed_type/conf_disallowed_type.stderr
@@ -21,68 +21,98 @@ LL | fn bad_return_type() -> fn() -> Sneaky {
 error: `std::time::Instant` is not allowed according to config
   --> $DIR/conf_disallowed_type.rs:16:28
    |
-LL | fn bad_arg_type(_: impl Fn(Sneaky) -> foo::atomic::AtomicU32) {
+LL | fn bad_arg_type(_: impl Fn(Sneaky) -> foo::atomic::AtomicU32) {}
    |                            ^^^^^^
 
 error: `std::sync::atomic::AtomicU32` is not allowed according to config
   --> $DIR/conf_disallowed_type.rs:16:39
    |
-LL | fn bad_arg_type(_: impl Fn(Sneaky) -> foo::atomic::AtomicU32) {
+LL | fn bad_arg_type(_: impl Fn(Sneaky) -> foo::atomic::AtomicU32) {}
    |                                       ^^^^^^^^^^^^^^^^^^^^^^
 
 error: `std::io::Read` is not allowed according to config
-  --> $DIR/conf_disallowed_type.rs:20:22
+  --> $DIR/conf_disallowed_type.rs:18:22
    |
-LL | fn trait_obj(_: &dyn std::io::Read) {
+LL | fn trait_obj(_: &dyn std::io::Read) {}
    |                      ^^^^^^^^^^^^^
 
+error: `usize` is not allowed according to config
+  --> $DIR/conf_disallowed_type.rs:20:33
+   |
+LL | fn full_and_single_path_prim(_: usize, _: bool) {}
+   |                                 ^^^^^
+
+error: `bool` is not allowed according to config
+  --> $DIR/conf_disallowed_type.rs:20:43
+   |
+LL | fn full_and_single_path_prim(_: usize, _: bool) {}
+   |                                           ^^^^
+
+error: `usize` is not allowed according to config
+  --> $DIR/conf_disallowed_type.rs:22:28
+   |
+LL | fn const_generics<const C: usize>() {}
+   |                            ^^^^^
+
+error: `usize` is not allowed according to config
+  --> $DIR/conf_disallowed_type.rs:24:24
+   |
+LL | struct GenArg<const U: usize>([u8; U]);
+   |                        ^^^^^
+
 error: `std::collections::HashMap` is not allowed according to config
-  --> $DIR/conf_disallowed_type.rs:28:48
+  --> $DIR/conf_disallowed_type.rs:30:48
    |
 LL |     let _: std::collections::HashMap<(), ()> = std::collections::HashMap::new();
    |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: `std::collections::HashMap` is not allowed according to config
-  --> $DIR/conf_disallowed_type.rs:28:12
+  --> $DIR/conf_disallowed_type.rs:30:12
    |
 LL |     let _: std::collections::HashMap<(), ()> = std::collections::HashMap::new();
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: `std::time::Instant` is not allowed according to config
-  --> $DIR/conf_disallowed_type.rs:29:13
+  --> $DIR/conf_disallowed_type.rs:31:13
    |
 LL |     let _ = Sneaky::now();
    |             ^^^^^^
 
 error: `std::sync::atomic::AtomicU32` is not allowed according to config
-  --> $DIR/conf_disallowed_type.rs:30:13
+  --> $DIR/conf_disallowed_type.rs:32:13
    |
 LL |     let _ = foo::atomic::AtomicU32::new(0);
    |             ^^^^^^^^^^^^^^^^^^^^^^
 
 error: `std::sync::atomic::AtomicU32` is not allowed according to config
-  --> $DIR/conf_disallowed_type.rs:31:17
+  --> $DIR/conf_disallowed_type.rs:33:17
    |
 LL |     static FOO: std::sync::atomic::AtomicU32 = foo::atomic::AtomicU32::new(1);
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: `std::sync::atomic::AtomicU32` is not allowed according to config
-  --> $DIR/conf_disallowed_type.rs:31:48
+  --> $DIR/conf_disallowed_type.rs:33:48
    |
 LL |     static FOO: std::sync::atomic::AtomicU32 = foo::atomic::AtomicU32::new(1);
    |                                                ^^^^^^^^^^^^^^^^^^^^^^
 
 error: `syn::TypePath` is not allowed according to config
-  --> $DIR/conf_disallowed_type.rs:32:43
+  --> $DIR/conf_disallowed_type.rs:34:43
    |
 LL |     let _: std::collections::BTreeMap<(), syn::TypePath> = Default::default();
    |                                           ^^^^^^^^^^^^^
 
-error: `proc_macro2::Ident` is not allowed according to config
-  --> $DIR/conf_disallowed_type.rs:33:13
+error: `syn::Ident` is not allowed according to config
+  --> $DIR/conf_disallowed_type.rs:35:13
    |
 LL |     let _ = syn::Ident::new("", todo!());
    |             ^^^^^^^^^^
 
-error: aborting due to 14 previous errors
+error: `usize` is not allowed according to config
+  --> $DIR/conf_disallowed_type.rs:37:12
+   |
+LL |     let _: usize = 64_usize;
+   |            ^^^^^
+
+error: aborting due to 19 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 6c5d199d57ee937dc8f4f036c38aa594751250ce Mon Sep 17 00:00:00 2001
From: flip1995 <philipp.krones@embecosm.com>
Date: Mon, 31 May 2021 17:46:20 +0200
Subject: Update deploy CI

This updates all the deploy scripts and the deploy workflow.

The deploy workflow now runs the metadata collector to collect the lint
documentation. It also changes the files that are checked out in the
deploy workflow from master and adds an explanation why we have to do
this.
---
 .github/deploy.sh                                       |  9 ++++-----
 .github/workflows/deploy.yml                            | 17 +++++++++++++++--
 .../src/utils/internal_lints/metadata_collector.rs      |  2 +-
 tests/dogfood.rs                                        |  2 +-
 4 files changed, 21 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/.github/deploy.sh b/.github/deploy.sh
index e85e8874ba6..a3c57232f55 100644
--- a/.github/deploy.sh
+++ b/.github/deploy.sh
@@ -8,13 +8,12 @@ rm -rf out/master/ || exit 0
 echo "Making the docs for master"
 mkdir out/master/
 cp util/gh-pages/index.html out/master
-python3 ./util/export.py out/master/lints.json
+cp util/gh-pages/lints.json out/master
 
 if [[ -n $TAG_NAME ]]; then
   echo "Save the doc for the current tag ($TAG_NAME) and point stable/ to it"
-  cp -r out/master "out/$TAG_NAME"
-  rm -f out/stable
-  ln -s "$TAG_NAME" out/stable
+  cp -Tr out/master "out/$TAG_NAME"
+  ln -sf "$TAG_NAME" out/stable
 fi
 
 if [[ $BETA = "true" ]]; then
@@ -28,8 +27,8 @@ cp util/gh-pages/versions.html out/index.html
 echo "Making the versions.json file"
 python3 ./util/versions.py out
 
-cd out
 # Now let's go have some fun with the cloned repo
+cd out
 git config user.name "GHA CI"
 git config user.email "gha@ci.invalid"
 
diff --git a/.github/workflows/deploy.yml b/.github/workflows/deploy.yml
index 15aeaf907dc..b8be730be32 100644
--- a/.github/workflows/deploy.yml
+++ b/.github/workflows/deploy.yml
@@ -39,10 +39,23 @@ jobs:
       if: github.ref == 'refs/heads/beta'
       run: echo "BETA=true" >> $GITHUB_ENV
 
-    - name: Use scripts and templates from master branch
+    # We need to check out all files that (transitively) depend on the
+    # structure of the gh-pages branch, so that we're able to change that
+    # structure without breaking the deployment.
+    - name: Use deploy files from master branch
       run: |
         git fetch --no-tags --prune --depth=1 origin master
-        git checkout origin/master -- .github/deploy.sh util/gh-pages/ util/*.py
+        git checkout origin/master -- .github/deploy.sh util/versions.py util/gh-pages/versions.html
+
+    # Generate lockfile for caching to avoid build problems with cached deps
+    - name: cargo generate-lockfile
+      run: cargo generate-lockfile
+
+    - name: Cache
+      uses: Swatinem/rust-cache@v1.3.0
+
+    - name: cargo collect-metadata
+      run: cargo collect-metadata
 
     - name: Deploy
       run: |
diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index 3eccc89cdeb..598450a725f 100644
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -32,7 +32,7 @@ use clippy_utils::{
 };
 
 /// This is the output file of the lint collector.
-const OUTPUT_FILE: &str = "../util/gh-pages/metadata_collection.json";
+const OUTPUT_FILE: &str = "../util/gh-pages/lints.json";
 /// These lints are excluded from the export.
 const BLACK_LISTED_LINTS: [&str; 3] = ["lint_author", "deep_code_inspection", "internal_metadata_collector"];
 /// These groups will be ignored by the lint group matcher. This is useful for collections like
diff --git a/tests/dogfood.rs b/tests/dogfood.rs
index a996f9df144..4ede20c5258 100644
--- a/tests/dogfood.rs
+++ b/tests/dogfood.rs
@@ -183,7 +183,7 @@ fn run_metadata_collection_lint() {
     use std::time::SystemTime;
 
     // Setup for validation
-    let metadata_output_path = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("util/gh-pages/metadata_collection.json");
+    let metadata_output_path = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("util/gh-pages/lints.json");
     let start_time = SystemTime::now();
 
     // Run collection as is
-- 
cgit 1.4.1-3-g733a5


From 12c61612f7a91df64121dd9c991828c26d665325 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Fri, 2 Jul 2021 20:37:11 +0200
Subject: Update lint documentation to use markdown headlines

---
 clippy_dev/src/new_lint.rs                         |   9 +-
 clippy_lints/src/absurd_extreme_comparisons.rs     |  12 +-
 clippy_lints/src/approx_const.rs                   |  10 +-
 clippy_lints/src/arithmetic.rs                     |  20 +-
 clippy_lints/src/as_conversions.rs                 |  10 +-
 clippy_lints/src/asm_syntax.rs                     |  20 +-
 clippy_lints/src/assertions_on_constants.rs        |  11 +-
 clippy_lints/src/assign_ops.rs                     |  22 +-
 clippy_lints/src/async_yields_async.rs             |  11 +-
 clippy_lints/src/atomic_ordering.rs                |  10 +-
 clippy_lints/src/attrs.rs                          |  74 +--
 clippy_lints/src/await_holding_invalid.rs          |  24 +-
 clippy_lints/src/bit_mask.rs                       |  32 +-
 clippy_lints/src/blacklisted_name.rs               |  10 +-
 clippy_lints/src/blocks_in_if_conditions.rs        |  10 +-
 clippy_lints/src/bool_assert_comparison.rs         |  11 +-
 clippy_lints/src/booleans.rs                       |  22 +-
 clippy_lints/src/bytecount.rs                      |  12 +-
 clippy_lints/src/cargo_common_metadata.rs          |  10 +-
 .../case_sensitive_file_extension_comparisons.rs   |   9 +-
 clippy_lints/src/casts/mod.rs                      | 116 ++--
 clippy_lints/src/checked_conversions.rs            |  10 +-
 clippy_lints/src/cognitive_complexity.rs           |  12 +-
 clippy_lints/src/collapsible_if.rs                 |  20 +-
 clippy_lints/src/collapsible_match.rs              |  11 +-
 clippy_lints/src/comparison_chain.rs               |  11 +-
 clippy_lints/src/copies.rs                         |  40 +-
 clippy_lints/src/copy_iterator.rs                  |  10 +-
 clippy_lints/src/create_dir.rs                     |  10 +-
 clippy_lints/src/dbg_macro.rs                      |  10 +-
 clippy_lints/src/default.rs                        |  21 +-
 clippy_lints/src/default_numeric_fallback.rs       |  11 +-
 clippy_lints/src/deprecated_lints.rs               |  96 ++--
 clippy_lints/src/dereference.rs                    |   8 +-
 clippy_lints/src/derive.rs                         |  43 +-
 clippy_lints/src/disallowed_method.rs              |  11 +-
 clippy_lints/src/disallowed_script_idents.rs       |  10 +-
 clippy_lints/src/disallowed_type.rs                |  11 +-
 clippy_lints/src/doc.rs                            |  53 +-
 clippy_lints/src/double_comparison.rs              |  10 +-
 clippy_lints/src/double_parens.rs                  |  10 +-
 clippy_lints/src/drop_forget_ref.rs                |  40 +-
 clippy_lints/src/duration_subsec.rs                |  10 +-
 clippy_lints/src/else_if_without_else.rs           |  10 +-
 clippy_lints/src/empty_enum.rs                     |  11 +-
 clippy_lints/src/entry.rs                          |  11 +-
 clippy_lints/src/enum_clike.rs                     |  10 +-
 clippy_lints/src/enum_variants.rs                  |  30 +-
 clippy_lints/src/eq_op.rs                          |  22 +-
 clippy_lints/src/erasing_op.rs                     |  10 +-
 clippy_lints/src/escape.rs                         |  10 +-
 clippy_lints/src/eta_reduction.rs                  |  22 +-
 clippy_lints/src/eval_order_dependence.rs          |  22 +-
 clippy_lints/src/excessive_bools.rs                |  20 +-
 clippy_lints/src/exhaustive_items.rs               |  22 +-
 clippy_lints/src/exit.rs                           |  10 +-
 clippy_lints/src/explicit_write.rs                 |  10 +-
 clippy_lints/src/fallible_impl_from.rs             |  10 +-
 clippy_lints/src/float_equality_without_abs.rs     |  50 +-
 clippy_lints/src/float_literal.rs                  |  22 +-
 clippy_lints/src/floating_point_arithmetic.rs      |  22 +-
 clippy_lints/src/format.rs                         |  10 +-
 clippy_lints/src/formatting.rs                     |  40 +-
 clippy_lints/src/from_over_into.rs                 |  11 +-
 clippy_lints/src/from_str_radix_10.rs              |  12 +-
 clippy_lints/src/functions/mod.rs                  |  73 +--
 clippy_lints/src/future_not_send.rs                |  11 +-
 clippy_lints/src/get_last_with_len.rs              |  11 +-
 clippy_lints/src/identity_op.rs                    |  10 +-
 clippy_lints/src/if_let_mutex.rs                   |  11 +-
 clippy_lints/src/if_let_some_result.rs             |  10 +-
 clippy_lints/src/if_not_else.rs                    |  10 +-
 clippy_lints/src/if_then_some_else_none.rs         |  11 +-
 clippy_lints/src/implicit_hasher.rs                |  11 +-
 clippy_lints/src/implicit_return.rs                |  10 +-
 clippy_lints/src/implicit_saturating_sub.rs        |  11 +-
 .../src/inconsistent_struct_constructor.rs         |  11 +-
 clippy_lints/src/indexing_slicing.rs               |  22 +-
 clippy_lints/src/infinite_iter.rs                  |  21 +-
 clippy_lints/src/inherent_impl.rs                  |  10 +-
 clippy_lints/src/inherent_to_string.rs             |  24 +-
 clippy_lints/src/inline_fn_without_body.rs         |  10 +-
 clippy_lints/src/int_plus_one.rs                   |  10 +-
 clippy_lints/src/integer_division.rs               |  10 +-
 clippy_lints/src/invalid_upcast_comparisons.rs     |  10 +-
 clippy_lints/src/items_after_statements.rs         |  10 +-
 clippy_lints/src/large_const_arrays.rs             |  10 +-
 clippy_lints/src/large_enum_variant.rs             |  12 +-
 clippy_lints/src/large_stack_arrays.rs             |  10 +-
 clippy_lints/src/len_zero.rs                       |  30 +-
 clippy_lints/src/let_if_seq.rs                     |  10 +-
 clippy_lints/src/let_underscore.rs                 |  30 +-
 clippy_lints/src/lib.rs                            |  11 +-
 clippy_lints/src/lifetimes.rs                      |  20 +-
 clippy_lints/src/literal_representation.rs         |  66 +--
 clippy_lints/src/loops/mod.rs                      | 182 +++---
 clippy_lints/src/macro_use.rs                      |  10 +-
 clippy_lints/src/main_recursion.rs                 |  10 +-
 clippy_lints/src/manual_async_fn.rs                |  11 +-
 clippy_lints/src/manual_map.rs                     |  11 +-
 clippy_lints/src/manual_non_exhaustive.rs          |  11 +-
 clippy_lints/src/manual_ok_or.rs                   |  10 +-
 clippy_lints/src/manual_strip.rs                   |  10 +-
 clippy_lints/src/manual_unwrap_or.rs               |   8 +-
 clippy_lints/src/map_clone.rs                      |  11 +-
 clippy_lints/src/map_err_ignore.rs                 |  10 +-
 clippy_lints/src/map_unit_fn.rs                    |  22 +-
 clippy_lints/src/match_on_vec_items.rs             |  10 +-
 clippy_lints/src/matches.rs                        | 170 +++---
 clippy_lints/src/mem_discriminant.rs               |  10 +-
 clippy_lints/src/mem_forget.rs                     |  10 +-
 clippy_lints/src/mem_replace.rs                    |  31 +-
 clippy_lints/src/methods/mod.rs                    | 636 +++++++++++----------
 clippy_lints/src/minmax.rs                         |  10 +-
 clippy_lints/src/misc.rs                           |  93 +--
 clippy_lints/src/misc_early/mod.rs                 |  90 +--
 clippy_lints/src/missing_const_for_fn.rs           |  12 +-
 clippy_lints/src/missing_doc.rs                    |   8 +-
 clippy_lints/src/missing_enforced_import_rename.rs |  11 +-
 clippy_lints/src/missing_inline.rs                 |  10 +-
 clippy_lints/src/modulo_arithmetic.rs              |  10 +-
 clippy_lints/src/multiple_crate_versions.rs        |  11 +-
 clippy_lints/src/mut_key.rs                        |  11 +-
 clippy_lints/src/mut_mut.rs                        |  10 +-
 clippy_lints/src/mut_mutex_lock.rs                 |  11 +-
 clippy_lints/src/mut_reference.rs                  |  10 +-
 clippy_lints/src/mutable_debug_assertion.rs        |  10 +-
 clippy_lints/src/mutex_atomic.rs                   |  22 +-
 clippy_lints/src/needless_arbitrary_self_type.rs   |  10 +-
 clippy_lints/src/needless_bitwise_bool.rs          |   9 +-
 clippy_lints/src/needless_bool.rs                  |  21 +-
 clippy_lints/src/needless_borrow.rs                |  20 +-
 clippy_lints/src/needless_borrowed_ref.rs          |  11 +-
 clippy_lints/src/needless_continue.rs              |  10 +-
 clippy_lints/src/needless_for_each.rs              |  11 +-
 clippy_lints/src/needless_pass_by_value.rs         |  10 +-
 clippy_lints/src/needless_question_mark.rs         |  10 +-
 clippy_lints/src/needless_update.rs                |  10 +-
 clippy_lints/src/neg_cmp_op_on_partial_ord.rs      |   9 +-
 clippy_lints/src/neg_multiply.rs                   |  11 +-
 clippy_lints/src/new_without_default.rs            |  11 +-
 clippy_lints/src/no_effect.rs                      |  20 +-
 clippy_lints/src/non_copy_const.rs                 |  22 +-
 clippy_lints/src/non_expressive_names.rs           |  30 +-
 clippy_lints/src/non_octal_unix_permissions.rs     |  11 +-
 clippy_lints/src/nonstandard_macro_braces.rs       |  12 +-
 clippy_lints/src/open_options.rs                   |  10 +-
 clippy_lints/src/option_env_unwrap.rs              |  11 +-
 clippy_lints/src/option_if_let_else.rs             |   9 +-
 clippy_lints/src/overflow_check_conditional.rs     |  10 +-
 clippy_lints/src/panic_in_result_fn.rs             |  12 +-
 clippy_lints/src/panic_unimplemented.rs            |  40 +-
 clippy_lints/src/partialeq_ne_impl.rs              |  10 +-
 clippy_lints/src/pass_by_ref_or_value.rs           |  20 +-
 clippy_lints/src/path_buf_push_overwrite.rs        |  10 +-
 clippy_lints/src/pattern_type_mismatch.rs          |  11 +-
 clippy_lints/src/precedence.rs                     |  10 +-
 clippy_lints/src/ptr.rs                            |  42 +-
 clippy_lints/src/ptr_eq.rs                         |  11 +-
 clippy_lints/src/ptr_offset_with_cast.rs           |  10 +-
 clippy_lints/src/question_mark.rs                  |  10 +-
 clippy_lints/src/ranges.rs                         |  54 +-
 clippy_lints/src/redundant_clone.rs                |  11 +-
 clippy_lints/src/redundant_closure_call.rs         |  10 +-
 clippy_lints/src/redundant_else.rs                 |  12 +-
 clippy_lints/src/redundant_field_names.rs          |  10 +-
 clippy_lints/src/redundant_pub_crate.rs            |  11 +-
 clippy_lints/src/redundant_slicing.rs              |  12 +-
 clippy_lints/src/redundant_static_lifetimes.rs     |  10 +-
 clippy_lints/src/ref_option_ref.rs                 |  12 +-
 clippy_lints/src/reference.rs                      |  19 +-
 clippy_lints/src/regex.rs                          |  21 +-
 clippy_lints/src/repeat_once.rs                    |  11 +-
 clippy_lints/src/returns.rs                        |  20 +-
 clippy_lints/src/self_assignment.rs                |  12 +-
 clippy_lints/src/self_named_constructor.rs         |  11 +-
 clippy_lints/src/semicolon_if_nothing_returned.rs  |  11 +-
 clippy_lints/src/serde_api.rs                      |  11 +-
 clippy_lints/src/shadow.rs                         |  33 +-
 clippy_lints/src/single_component_path_imports.rs  |  11 +-
 clippy_lints/src/size_of_in_element_count.rs       |  10 +-
 clippy_lints/src/slow_vector_initialization.rs     |  10 +-
 clippy_lints/src/stable_sort_primitive.rs          |  10 +-
 clippy_lints/src/strings.rs                        |  63 +-
 clippy_lints/src/strlen_on_c_strings.rs            |  11 +-
 clippy_lints/src/suspicious_operation_groupings.rs |  11 +-
 clippy_lints/src/suspicious_trait_impl.rs          |  20 +-
 clippy_lints/src/swap.rs                           |  20 +-
 clippy_lints/src/tabs_in_doc_comments.rs           |  10 +-
 clippy_lints/src/temporary_assignment.rs           |  10 +-
 clippy_lints/src/to_digit_is_some.rs               |   8 +-
 clippy_lints/src/to_string_in_display.rs           |  10 +-
 clippy_lints/src/trait_bounds.rs                   |  20 +-
 clippy_lints/src/transmute/mod.rs                  | 122 ++--
 clippy_lints/src/transmuting_null.rs               |  11 +-
 clippy_lints/src/try_err.rs                        |  10 +-
 clippy_lints/src/types/mod.rs                      |  94 +--
 clippy_lints/src/undropped_manually_drops.rs       |  12 +-
 clippy_lints/src/unicode.rs                        |  32 +-
 clippy_lints/src/unit_return_expecting_ord.rs      |  12 +-
 clippy_lints/src/unit_types/mod.rs                 |  30 +-
 clippy_lints/src/unnamed_address.rs                |  22 +-
 clippy_lints/src/unnecessary_self_imports.rs       |  12 +-
 clippy_lints/src/unnecessary_sort_by.rs            |   9 +-
 clippy_lints/src/unnecessary_wraps.rs              |  12 +-
 clippy_lints/src/unnested_or_patterns.rs           |  11 +-
 clippy_lints/src/unsafe_removed_from_name.rs       |  10 +-
 clippy_lints/src/unused_async.rs                   |  11 +-
 clippy_lints/src/unused_io_amount.rs               |  11 +-
 clippy_lints/src/unused_self.rs                    |  10 +-
 clippy_lints/src/unused_unit.rs                    |  10 +-
 clippy_lints/src/unwrap.rs                         |  21 +-
 clippy_lints/src/unwrap_in_result.rs               |  11 +-
 clippy_lints/src/upper_case_acronyms.rs            |  12 +-
 clippy_lints/src/use_self.rs                       |  11 +-
 clippy_lints/src/useless_conversion.rs             |  11 +-
 clippy_lints/src/utils/author.rs                   |   5 +-
 clippy_lints/src/utils/inspector.rs                |   5 +-
 clippy_lints/src/utils/internal_lints.rs           | 109 ++--
 .../src/utils/internal_lints/metadata_collector.rs |  16 +-
 clippy_lints/src/vec.rs                            |  10 +-
 clippy_lints/src/vec_init_then_push.rs             |  11 +-
 clippy_lints/src/vec_resize_to_zero.rs             |  10 +-
 clippy_lints/src/verbose_file_reads.rs             |  11 +-
 clippy_lints/src/wildcard_dependencies.rs          |  11 +-
 clippy_lints/src/wildcard_imports.rs               |  26 +-
 clippy_lints/src/write.rs                          |  92 +--
 clippy_lints/src/zero_div_zero.rs                  |  10 +-
 clippy_lints/src/zero_sized_map_values.rs          |  11 +-
 doc/adding_lints.md                                |  20 +-
 230 files changed, 2717 insertions(+), 2474 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_dev/src/new_lint.rs b/clippy_dev/src/new_lint.rs
index 4676c2affad..3a81aaba6de 100644
--- a/clippy_dev/src/new_lint.rs
+++ b/clippy_dev/src/new_lint.rs
@@ -169,14 +169,11 @@ use rustc_session::{{declare_lint_pass, declare_tool_lint}};
 {pass_import}
 
 declare_clippy_lint! {{
-    /// **What it does:**
+    /// ### What it does
     ///
-    /// **Why is this bad?**
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Why is this bad?
     ///
+    /// ### Example
     /// ```rust
     /// // example code where clippy issues a warning
     /// ```
diff --git a/clippy_lints/src/absurd_extreme_comparisons.rs b/clippy_lints/src/absurd_extreme_comparisons.rs
index 49d4350123f..1483f3f9185 100644
--- a/clippy_lints/src/absurd_extreme_comparisons.rs
+++ b/clippy_lints/src/absurd_extreme_comparisons.rs
@@ -11,24 +11,26 @@ use clippy_utils::ty::is_isize_or_usize;
 use clippy_utils::{clip, int_bits, unsext};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for comparisons where one side of the relation is
+    /// ### What it does
+    /// Checks for comparisons where one side of the relation is
     /// either the minimum or maximum value for its type and warns if it involves a
     /// case that is always true or always false. Only integer and boolean types are
     /// checked.
     ///
-    /// **Why is this bad?** An expression like `min <= x` may misleadingly imply
+    /// ### Why is this bad?
+    /// An expression like `min <= x` may misleadingly imply
     /// that it is possible for `x` to be less than the minimum. Expressions like
     /// `max < x` are probably mistakes.
     ///
-    /// **Known problems:** For `usize` the size of the current compile target will
+    /// ### Known problems
+    /// For `usize` the size of the current compile target will
     /// be assumed (e.g., 64 bits on 64 bit systems). This means code that uses such
     /// a comparison to detect target pointer width will trigger this lint. One can
     /// use `mem::sizeof` and compare its value or conditional compilation
     /// attributes
     /// like `#[cfg(target_pointer_width = "64")] ..` instead.
     ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust
     /// let vec: Vec<isize> = Vec::new();
     /// if vec.len() <= 0 {}
diff --git a/clippy_lints/src/approx_const.rs b/clippy_lints/src/approx_const.rs
index 3d04abe094d..6100f4e435a 100644
--- a/clippy_lints/src/approx_const.rs
+++ b/clippy_lints/src/approx_const.rs
@@ -7,21 +7,21 @@ use rustc_span::symbol;
 use std::f64::consts as f64;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for floating point literals that approximate
+    /// ### What it does
+    /// Checks for floating point literals that approximate
     /// constants which are defined in
     /// [`std::f32::consts`](https://doc.rust-lang.org/stable/std/f32/consts/#constants)
     /// or
     /// [`std::f64::consts`](https://doc.rust-lang.org/stable/std/f64/consts/#constants),
     /// respectively, suggesting to use the predefined constant.
     ///
-    /// **Why is this bad?** Usually, the definition in the standard library is more
+    /// ### Why is this bad?
+    /// Usually, the definition in the standard library is more
     /// precise than what people come up with. If you find that your definition is
     /// actually more precise, please [file a Rust
     /// issue](https://github.com/rust-lang/rust/issues).
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// let x = 3.14;
     /// let y = 1_f64 / x;
diff --git a/clippy_lints/src/arithmetic.rs b/clippy_lints/src/arithmetic.rs
index 24c2a972811..36fe7b7a867 100644
--- a/clippy_lints/src/arithmetic.rs
+++ b/clippy_lints/src/arithmetic.rs
@@ -6,7 +6,8 @@ use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::Span;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for integer arithmetic operations which could overflow or panic.
+    /// ### What it does
+    /// Checks for integer arithmetic operations which could overflow or panic.
     ///
     /// Specifically, checks for any operators (`+`, `-`, `*`, `<<`, etc) which are capable
     /// of overflowing according to the [Rust
@@ -14,13 +15,12 @@ declare_clippy_lint! {
     /// or which can panic (`/`, `%`). No bounds analysis or sophisticated reasoning is
     /// attempted.
     ///
-    /// **Why is this bad?** Integer overflow will trigger a panic in debug builds or will wrap in
+    /// ### Why is this bad?
+    /// Integer overflow will trigger a panic in debug builds or will wrap in
     /// release mode. Division by zero will cause a panic in either mode. In some applications one
     /// wants explicitly checked, wrapping or saturating arithmetic.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// # let a = 0;
     /// a + 1;
@@ -31,14 +31,14 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for float arithmetic.
+    /// ### What it does
+    /// Checks for float arithmetic.
     ///
-    /// **Why is this bad?** For some embedded systems or kernel development, it
+    /// ### Why is this bad?
+    /// For some embedded systems or kernel development, it
     /// can be useful to rule out floating-point numbers.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// # let a = 0.0;
     /// a + 1.0;
diff --git a/clippy_lints/src/as_conversions.rs b/clippy_lints/src/as_conversions.rs
index 4b31e16094e..7c39a3e2ce3 100644
--- a/clippy_lints/src/as_conversions.rs
+++ b/clippy_lints/src/as_conversions.rs
@@ -5,7 +5,8 @@ use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for usage of `as` conversions.
+    /// ### What it does
+    /// Checks for usage of `as` conversions.
     ///
     /// Note that this lint is specialized in linting *every single* use of `as`
     /// regardless of whether good alternatives exist or not.
@@ -15,14 +16,13 @@ declare_clippy_lint! {
     /// There is a good explanation the reason why this lint should work in this way and how it is useful
     /// [in this issue](https://github.com/rust-lang/rust-clippy/issues/5122).
     ///
-    /// **Why is this bad?** `as` conversions will perform many kinds of
+    /// ### Why is this bad?
+    /// `as` conversions will perform many kinds of
     /// conversions, including silently lossy conversions and dangerous coercions.
     /// There are cases when it makes sense to use `as`, so the lint is
     /// Allow by default.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust,ignore
     /// let a: u32;
     /// ...
diff --git a/clippy_lints/src/asm_syntax.rs b/clippy_lints/src/asm_syntax.rs
index b970c71b753..825832eb79d 100644
--- a/clippy_lints/src/asm_syntax.rs
+++ b/clippy_lints/src/asm_syntax.rs
@@ -53,14 +53,14 @@ fn check_expr_asm_syntax(lint: &'static Lint, cx: &EarlyContext<'_>, expr: &Expr
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for usage of Intel x86 assembly syntax.
+    /// ### What it does
+    /// Checks for usage of Intel x86 assembly syntax.
     ///
-    /// **Why is this bad?** The lint has been enabled to indicate a preference
+    /// ### Why is this bad?
+    /// The lint has been enabled to indicate a preference
     /// for AT&T x86 assembly syntax.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     ///
     /// ```rust,no_run
     /// # #![feature(asm)]
@@ -89,14 +89,14 @@ impl EarlyLintPass for InlineAsmX86IntelSyntax {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for usage of AT&T x86 assembly syntax.
+    /// ### What it does
+    /// Checks for usage of AT&T x86 assembly syntax.
     ///
-    /// **Why is this bad?** The lint has been enabled to indicate a preference
+    /// ### Why is this bad?
+    /// The lint has been enabled to indicate a preference
     /// for Intel x86 assembly syntax.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     ///
     /// ```rust,no_run
     /// # #![feature(asm)]
diff --git a/clippy_lints/src/assertions_on_constants.rs b/clippy_lints/src/assertions_on_constants.rs
index 5235b2642d1..cb9347a923d 100644
--- a/clippy_lints/src/assertions_on_constants.rs
+++ b/clippy_lints/src/assertions_on_constants.rs
@@ -8,14 +8,17 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for `assert!(true)` and `assert!(false)` calls.
+    /// ### What it does
+    /// Checks for `assert!(true)` and `assert!(false)` calls.
     ///
-    /// **Why is this bad?** Will be optimized out by the compiler or should probably be replaced by a
+    /// ### Why is this bad?
+    /// Will be optimized out by the compiler or should probably be replaced by a
     /// `panic!()` or `unreachable!()`
     ///
-    /// **Known problems:** None
+    /// ### Known problems
+    /// None
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust,ignore
     /// assert!(false)
     /// assert!(true)
diff --git a/clippy_lints/src/assign_ops.rs b/clippy_lints/src/assign_ops.rs
index 17ce3cd809f..2097a1feff9 100644
--- a/clippy_lints/src/assign_ops.rs
+++ b/clippy_lints/src/assign_ops.rs
@@ -12,15 +12,18 @@ use rustc_middle::hir::map::Map;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for `a = a op b` or `a = b commutative_op a`
+    /// ### What it does
+    /// Checks for `a = a op b` or `a = b commutative_op a`
     /// patterns.
     ///
-    /// **Why is this bad?** These can be written as the shorter `a op= b`.
+    /// ### Why is this bad?
+    /// These can be written as the shorter `a op= b`.
     ///
-    /// **Known problems:** While forbidden by the spec, `OpAssign` traits may have
+    /// ### Known problems
+    /// While forbidden by the spec, `OpAssign` traits may have
     /// implementations that differ from the regular `Op` impl.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// let mut a = 5;
     /// let b = 0;
@@ -37,17 +40,20 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for `a op= a op b` or `a op= b op a` patterns.
+    /// ### What it does
+    /// Checks for `a op= a op b` or `a op= b op a` patterns.
     ///
-    /// **Why is this bad?** Most likely these are bugs where one meant to write `a
+    /// ### Why is this bad?
+    /// Most likely these are bugs where one meant to write `a
     /// op= b`.
     ///
-    /// **Known problems:** Clippy cannot know for sure if `a op= a op b` should have
+    /// ### Known problems
+    /// Clippy cannot know for sure if `a op= a op b` should have
     /// been `a = a op a op b` or `a = a op b`/`a op= b`. Therefore, it suggests both.
     /// If `a op= a op b` is really the correct behaviour it should be
     /// written as `a = a op a op b` as it's less confusing.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// let mut a = 5;
     /// let b = 2;
diff --git a/clippy_lints/src/async_yields_async.rs b/clippy_lints/src/async_yields_async.rs
index e6c7c68f91a..182736a5a20 100644
--- a/clippy_lints/src/async_yields_async.rs
+++ b/clippy_lints/src/async_yields_async.rs
@@ -7,15 +7,14 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for async blocks that yield values of types
+    /// ### What it does
+    /// Checks for async blocks that yield values of types
     /// that can themselves be awaited.
     ///
-    /// **Why is this bad?** An await is likely missing.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Why is this bad?
+    /// An await is likely missing.
     ///
+    /// ### Example
     /// ```rust
     /// async fn foo() {}
     ///
diff --git a/clippy_lints/src/atomic_ordering.rs b/clippy_lints/src/atomic_ordering.rs
index 7ceb01f5590..cece28e8b3c 100644
--- a/clippy_lints/src/atomic_ordering.rs
+++ b/clippy_lints/src/atomic_ordering.rs
@@ -8,16 +8,16 @@ use rustc_middle::ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for usage of invalid atomic
+    /// ### What it does
+    /// Checks for usage of invalid atomic
     /// ordering in atomic loads/stores/exchanges/updates and
     /// memory fences.
     ///
-    /// **Why is this bad?** Using an invalid atomic ordering
+    /// ### Why is this bad?
+    /// Using an invalid atomic ordering
     /// will cause a panic at run-time.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust,no_run
     /// # use std::sync::atomic::{self, AtomicU8, Ordering};
     ///
diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs
index f272ed010a1..c9ff468874b 100644
--- a/clippy_lints/src/attrs.rs
+++ b/clippy_lints/src/attrs.rs
@@ -41,10 +41,12 @@ static UNIX_SYSTEMS: &[&str] = &[
 static NON_UNIX_SYSTEMS: &[&str] = &["hermit", "none", "wasi"];
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for items annotated with `#[inline(always)]`,
+    /// ### What it does
+    /// Checks for items annotated with `#[inline(always)]`,
     /// unless the annotated function is empty or simply panics.
     ///
-    /// **Why is this bad?** While there are valid uses of this annotation (and once
+    /// ### Why is this bad?
+    /// While there are valid uses of this annotation (and once
     /// you know when to use it, by all means `allow` this lint), it's a common
     /// newbie-mistake to pepper one's code with it.
     ///
@@ -52,11 +54,12 @@ declare_clippy_lint! {
     /// measure if that additional function call really affects your runtime profile
     /// sufficiently to make up for the increase in compile time.
     ///
-    /// **Known problems:** False positives, big time. This lint is meant to be
+    /// ### Known problems
+    /// False positives, big time. This lint is meant to be
     /// deactivated by everyone doing serious performance work. This means having
     /// done the measurement.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```ignore
     /// #[inline(always)]
     /// fn not_quite_hot_code(..) { ... }
@@ -67,7 +70,8 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for `extern crate` and `use` items annotated with
+    /// ### What it does
+    /// Checks for `extern crate` and `use` items annotated with
     /// lint attributes.
     ///
     /// This lint permits `#[allow(unused_imports)]`, `#[allow(deprecated)]`,
@@ -75,12 +79,11 @@ declare_clippy_lint! {
     /// `#[allow(clippy::enum_glob_use)]` on `use` items and `#[allow(unused_imports)]` on
     /// `extern crate` items with a `#[macro_use]` attribute.
     ///
-    /// **Why is this bad?** Lint attributes have no effect on crate imports. Most
+    /// ### Why is this bad?
+    /// Lint attributes have no effect on crate imports. Most
     /// likely a `!` was forgotten.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```ignore
     /// // Bad
     /// #[deny(dead_code)]
@@ -101,15 +104,15 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for `#[deprecated]` annotations with a `since`
+    /// ### What it does
+    /// Checks for `#[deprecated]` annotations with a `since`
     /// field that is not a valid semantic version.
     ///
-    /// **Why is this bad?** For checking the version of the deprecation, it must be
+    /// ### Why is this bad?
+    /// For checking the version of the deprecation, it must be
     /// a valid semver. Failing that, the contained information is useless.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// #[deprecated(since = "forever")]
     /// fn something_else() { /* ... */ }
@@ -120,20 +123,22 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for empty lines after outer attributes
+    /// ### What it does
+    /// Checks for empty lines after outer attributes
     ///
-    /// **Why is this bad?**
+    /// ### Why is this bad?
     /// Most likely the attribute was meant to be an inner attribute using a '!'.
     /// If it was meant to be an outer attribute, then the following item
     /// should not be separated by empty lines.
     ///
-    /// **Known problems:** Can cause false positives.
+    /// ### Known problems
+    /// Can cause false positives.
     ///
     /// From the clippy side it's difficult to detect empty lines between an attributes and the
     /// following item because empty lines and comments are not part of the AST. The parsing
     /// currently works for basic cases but is not perfect.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// // Good (as inner attribute)
     /// #![allow(dead_code)]
@@ -155,14 +160,14 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for `warn`/`deny`/`forbid` attributes targeting the whole clippy::restriction category.
+    /// ### What it does
+    /// Checks for `warn`/`deny`/`forbid` attributes targeting the whole clippy::restriction category.
     ///
-    /// **Why is this bad?** Restriction lints sometimes are in contrast with other lints or even go against idiomatic rust.
+    /// ### Why is this bad?
+    /// Restriction lints sometimes are in contrast with other lints or even go against idiomatic rust.
     /// These lints should only be enabled on a lint-by-lint basis and with careful consideration.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// Bad:
     /// ```rust
     /// #![deny(clippy::restriction)]
@@ -178,18 +183,20 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for `#[cfg_attr(rustfmt, rustfmt_skip)]` and suggests to replace it
+    /// ### What it does
+    /// Checks for `#[cfg_attr(rustfmt, rustfmt_skip)]` and suggests to replace it
     /// with `#[rustfmt::skip]`.
     ///
-    /// **Why is this bad?** Since tool_attributes ([rust-lang/rust#44690](https://github.com/rust-lang/rust/issues/44690))
+    /// ### Why is this bad?
+    /// Since tool_attributes ([rust-lang/rust#44690](https://github.com/rust-lang/rust/issues/44690))
     /// are stable now, they should be used instead of the old `cfg_attr(rustfmt)` attributes.
     ///
-    /// **Known problems:** This lint doesn't detect crate level inner attributes, because they get
+    /// ### Known problems
+    /// This lint doesn't detect crate level inner attributes, because they get
     /// processed before the PreExpansionPass lints get executed. See
     /// [#3123](https://github.com/rust-lang/rust-clippy/pull/3123#issuecomment-422321765)
     ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// Bad:
     /// ```rust
     /// #[cfg_attr(rustfmt, rustfmt_skip)]
@@ -207,15 +214,14 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for cfg attributes having operating systems used in target family position.
+    /// ### What it does
+    /// Checks for cfg attributes having operating systems used in target family position.
     ///
-    /// **Why is this bad?** The configuration option will not be recognised and the related item will not be included
+    /// ### Why is this bad?
+    /// The configuration option will not be recognised and the related item will not be included
     /// by the conditional compilation engine.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// Bad:
     /// ```rust
     /// #[cfg(linux)]
diff --git a/clippy_lints/src/await_holding_invalid.rs b/clippy_lints/src/await_holding_invalid.rs
index 1739a57a240..0cc79c8b6e8 100644
--- a/clippy_lints/src/await_holding_invalid.rs
+++ b/clippy_lints/src/await_holding_invalid.rs
@@ -8,10 +8,12 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::Span;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for calls to await while holding a
+    /// ### What it does
+    /// Checks for calls to await while holding a
     /// non-async-aware MutexGuard.
     ///
-    /// **Why is this bad?** The Mutex types found in std::sync and parking_lot
+    /// ### Why is this bad?
+    /// The Mutex types found in std::sync and parking_lot
     /// are not designed to operate in an async context across await points.
     ///
     /// There are two potential solutions. One is to use an asynx-aware Mutex
@@ -19,10 +21,10 @@ declare_clippy_lint! {
     /// other solution is to ensure the mutex is unlocked before calling await,
     /// either by introducing a scope or an explicit call to Drop::drop.
     ///
-    /// **Known problems:** Will report false positive for explicitly dropped guards ([#6446](https://github.com/rust-lang/rust-clippy/issues/6446)).
-    ///
-    /// **Example:**
+    /// ### Known problems
+    /// Will report false positive for explicitly dropped guards ([#6446](https://github.com/rust-lang/rust-clippy/issues/6446)).
     ///
+    /// ### Example
     /// ```rust,ignore
     /// use std::sync::Mutex;
     ///
@@ -51,17 +53,19 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for calls to await while holding a
+    /// ### What it does
+    /// Checks for calls to await while holding a
     /// `RefCell` `Ref` or `RefMut`.
     ///
-    /// **Why is this bad?** `RefCell` refs only check for exclusive mutable access
+    /// ### Why is this bad?
+    /// `RefCell` refs only check for exclusive mutable access
     /// at runtime. Holding onto a `RefCell` ref across an `await` suspension point
     /// risks panics from a mutable ref shared while other refs are outstanding.
     ///
-    /// **Known problems:** Will report false positive for explicitly dropped refs ([#6353](https://github.com/rust-lang/rust-clippy/issues/6353)).
-    ///
-    /// **Example:**
+    /// ### Known problems
+    /// Will report false positive for explicitly dropped refs ([#6353](https://github.com/rust-lang/rust-clippy/issues/6353)).
     ///
+    /// ### Example
     /// ```rust,ignore
     /// use std::cell::RefCell;
     ///
diff --git a/clippy_lints/src/bit_mask.rs b/clippy_lints/src/bit_mask.rs
index 991ed94572c..11346e7c96a 100644
--- a/clippy_lints/src/bit_mask.rs
+++ b/clippy_lints/src/bit_mask.rs
@@ -10,7 +10,8 @@ use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::Span;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for incompatible bit masks in comparisons.
+    /// ### What it does
+    /// Checks for incompatible bit masks in comparisons.
     ///
     /// The formula for detecting if an expression of the type `_ <bit_op> m
     /// <cmp_op> c` (where `<bit_op>` is one of {`&`, `|`} and `<cmp_op>` is one of
@@ -26,7 +27,8 @@ declare_clippy_lint! {
     /// |`<`  or `>=`| `|`  |`x | 1 < 1` |`false`  |`m >= c`              |
     /// |`<=` or `>` | `|`  |`x | 1 > 0` |`true`   |`m > c`               |
     ///
-    /// **Why is this bad?** If the bits that the comparison cares about are always
+    /// ### Why is this bad?
+    /// If the bits that the comparison cares about are always
     /// set to zero or one by the bit mask, the comparison is constant `true` or
     /// `false` (depending on mask, compared value, and operators).
     ///
@@ -34,9 +36,7 @@ declare_clippy_lint! {
     /// this intentionally is to win an underhanded Rust contest or create a
     /// test-case for this lint.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// # let x = 1;
     /// if (x & 1 == 2) { }
@@ -47,7 +47,8 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for bit masks in comparisons which can be removed
+    /// ### What it does
+    /// Checks for bit masks in comparisons which can be removed
     /// without changing the outcome. The basic structure can be seen in the
     /// following table:
     ///
@@ -56,16 +57,18 @@ declare_clippy_lint! {
     /// |`>` / `<=`|`|` / `^`|`x | 2 > 3`|`x > 3`|
     /// |`<` / `>=`|`|` / `^`|`x ^ 1 < 4`|`x < 4`|
     ///
-    /// **Why is this bad?** Not equally evil as [`bad_bit_mask`](#bad_bit_mask),
+    /// ### Why is this bad?
+    /// Not equally evil as [`bad_bit_mask`](#bad_bit_mask),
     /// but still a bit misleading, because the bit mask is ineffective.
     ///
-    /// **Known problems:** False negatives: This lint will only match instances
+    /// ### Known problems
+    /// False negatives: This lint will only match instances
     /// where we have figured out the math (which is for a power-of-two compared
     /// value). This means things like `x | 1 >= 7` (which would be better written
     /// as `x >= 6`) will not be reported (but bit masks like this are fairly
     /// uncommon).
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// # let x = 1;
     /// if (x | 1 > 3) {  }
@@ -76,15 +79,18 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for bit masks that can be replaced by a call
+    /// ### What it does
+    /// Checks for bit masks that can be replaced by a call
     /// to `trailing_zeros`
     ///
-    /// **Why is this bad?** `x.trailing_zeros() > 4` is much clearer than `x & 15
+    /// ### Why is this bad?
+    /// `x.trailing_zeros() > 4` is much clearer than `x & 15
     /// == 0`
     ///
-    /// **Known problems:** llvm generates better code for `x & 15 == 0` on x86
+    /// ### Known problems
+    /// llvm generates better code for `x & 15 == 0` on x86
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// # let x = 1;
     /// if x & 0b1111 == 0 { }
diff --git a/clippy_lints/src/blacklisted_name.rs b/clippy_lints/src/blacklisted_name.rs
index 8eb94f3c28e..916c78c982a 100644
--- a/clippy_lints/src/blacklisted_name.rs
+++ b/clippy_lints/src/blacklisted_name.rs
@@ -5,15 +5,15 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for usage of blacklisted names for variables, such
+    /// ### What it does
+    /// Checks for usage of blacklisted names for variables, such
     /// as `foo`.
     ///
-    /// **Why is this bad?** These names are usually placeholder names and should be
+    /// ### Why is this bad?
+    /// These names are usually placeholder names and should be
     /// avoided.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// let foo = 3.14;
     /// ```
diff --git a/clippy_lints/src/blocks_in_if_conditions.rs b/clippy_lints/src/blocks_in_if_conditions.rs
index badcf8d2a43..9b2e4f8998e 100644
--- a/clippy_lints/src/blocks_in_if_conditions.rs
+++ b/clippy_lints/src/blocks_in_if_conditions.rs
@@ -13,14 +13,14 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::sym;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for `if` conditions that use blocks containing an
+    /// ### What it does
+    /// Checks for `if` conditions that use blocks containing an
     /// expression, statements or conditions that use closures with blocks.
     ///
-    /// **Why is this bad?** Style, using blocks in the condition makes it hard to read.
+    /// ### Why is this bad?
+    /// Style, using blocks in the condition makes it hard to read.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Examples:**
+    /// ### Examples
     /// ```rust
     /// // Bad
     /// if { true } { /* ... */ }
diff --git a/clippy_lints/src/bool_assert_comparison.rs b/clippy_lints/src/bool_assert_comparison.rs
index bee706ed402..8d3f68565b2 100644
--- a/clippy_lints/src/bool_assert_comparison.rs
+++ b/clippy_lints/src/bool_assert_comparison.rs
@@ -6,14 +6,13 @@ use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
-    /// **What it does:** This lint warns about boolean comparisons in assert-like macros.
+    /// ### What it does
+    /// This lint warns about boolean comparisons in assert-like macros.
     ///
-    /// **Why is this bad?** It is shorter to use the equivalent.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Why is this bad?
+    /// It is shorter to use the equivalent.
     ///
+    /// ### Example
     /// ```rust
     /// // Bad
     /// assert_eq!("a".is_empty(), false);
diff --git a/clippy_lints/src/booleans.rs b/clippy_lints/src/booleans.rs
index e72399af232..4a83d35a568 100644
--- a/clippy_lints/src/booleans.rs
+++ b/clippy_lints/src/booleans.rs
@@ -14,16 +14,19 @@ use rustc_span::source_map::Span;
 use rustc_span::sym;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for boolean expressions that can be written more
+    /// ### What it does
+    /// Checks for boolean expressions that can be written more
     /// concisely.
     ///
-    /// **Why is this bad?** Readability of boolean expressions suffers from
+    /// ### Why is this bad?
+    /// Readability of boolean expressions suffers from
     /// unnecessary duplication.
     ///
-    /// **Known problems:** Ignores short circuiting behavior of `||` and
+    /// ### Known problems
+    /// Ignores short circuiting behavior of `||` and
     /// `&&`. Ignores `|`, `&` and `^`.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```ignore
     /// if a && true  // should be: if a
     /// if !(a == b)  // should be: if a != b
@@ -34,14 +37,17 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for boolean expressions that contain terminals that
+    /// ### What it does
+    /// Checks for boolean expressions that contain terminals that
     /// can be eliminated.
     ///
-    /// **Why is this bad?** This is most likely a logic bug.
+    /// ### Why is this bad?
+    /// This is most likely a logic bug.
     ///
-    /// **Known problems:** Ignores short circuiting behavior.
+    /// ### Known problems
+    /// Ignores short circuiting behavior.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```ignore
     /// if a && b || a { ... }
     /// ```
diff --git a/clippy_lints/src/bytecount.rs b/clippy_lints/src/bytecount.rs
index 4f7ffdcdfb4..c444984bc13 100644
--- a/clippy_lints/src/bytecount.rs
+++ b/clippy_lints/src/bytecount.rs
@@ -12,18 +12,20 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::sym;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for naive byte counts
+    /// ### What it does
+    /// Checks for naive byte counts
     ///
-    /// **Why is this bad?** The [`bytecount`](https://crates.io/crates/bytecount)
+    /// ### Why is this bad?
+    /// The [`bytecount`](https://crates.io/crates/bytecount)
     /// crate has methods to count your bytes faster, especially for large slices.
     ///
-    /// **Known problems:** If you have predominantly small slices, the
+    /// ### Known problems
+    /// If you have predominantly small slices, the
     /// `bytecount::count(..)` method may actually be slower. However, if you can
     /// ensure that less than 2³²-1 matches arise, the `naive_count_32(..)` can be
     /// faster in those cases.
     ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust
     /// # let vec = vec![1_u8];
     /// &vec.iter().filter(|x| **x == 0u8).count(); // use bytecount::count instead
diff --git a/clippy_lints/src/cargo_common_metadata.rs b/clippy_lints/src/cargo_common_metadata.rs
index 21c7b2448ce..bd5426ba707 100644
--- a/clippy_lints/src/cargo_common_metadata.rs
+++ b/clippy_lints/src/cargo_common_metadata.rs
@@ -9,15 +9,15 @@ use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::DUMMY_SP;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks to see if all common metadata is defined in
+    /// ### What it does
+    /// Checks to see if all common metadata is defined in
     /// `Cargo.toml`. See: https://rust-lang-nursery.github.io/api-guidelines/documentation.html#cargotoml-includes-all-common-metadata-c-metadata
     ///
-    /// **Why is this bad?** It will be more difficult for users to discover the
+    /// ### Why is this bad?
+    /// It will be more difficult for users to discover the
     /// purpose of the crate, and key information related to it.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```toml
     /// # This `Cargo.toml` is missing a description field:
     /// [package]
diff --git a/clippy_lints/src/case_sensitive_file_extension_comparisons.rs b/clippy_lints/src/case_sensitive_file_extension_comparisons.rs
index c9ef379be56..86b32475ceb 100644
--- a/clippy_lints/src/case_sensitive_file_extension_comparisons.rs
+++ b/clippy_lints/src/case_sensitive_file_extension_comparisons.rs
@@ -8,17 +8,14 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::{source_map::Spanned, symbol::sym, Span};
 
 declare_clippy_lint! {
-    /// **What it does:**
+    /// ### What it does
     /// Checks for calls to `ends_with` with possible file extensions
     /// and suggests to use a case-insensitive approach instead.
     ///
-    /// **Why is this bad?**
+    /// ### Why is this bad?
     /// `ends_with` is case-sensitive and may not detect files with a valid extension.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust
     /// fn is_rust_file(filename: &str) -> bool {
     ///     filename.ends_with(".rs")
diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index ae4fdd12c41..27e1bea7993 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -20,7 +20,8 @@ use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for casts from any numerical to a float type where
+    /// ### What it does
+    /// Checks for casts from any numerical to a float type where
     /// the receiving type cannot store all values from the original type without
     /// rounding errors. This possible rounding is to be expected, so this lint is
     /// `Allow` by default.
@@ -28,13 +29,12 @@ declare_clippy_lint! {
     /// Basically, this warns on casting any integer with 32 or more bits to `f32`
     /// or any 64-bit integer to `f64`.
     ///
-    /// **Why is this bad?** It's not bad at all. But in some applications it can be
+    /// ### Why is this bad?
+    /// It's not bad at all. But in some applications it can be
     /// helpful to know where precision loss can take place. This lint can help find
     /// those places in the code.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// let x = u64::MAX;
     /// x as f64;
@@ -45,17 +45,17 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for casts from a signed to an unsigned numerical
+    /// ### What it does
+    /// Checks for casts from a signed to an unsigned numerical
     /// type. In this case, negative values wrap around to large positive values,
     /// which can be quite surprising in practice. However, as the cast works as
     /// defined, this lint is `Allow` by default.
     ///
-    /// **Why is this bad?** Possibly surprising results. You can activate this lint
+    /// ### Why is this bad?
+    /// Possibly surprising results. You can activate this lint
     /// as a one-time check to see where numerical wrapping can arise.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// let y: i8 = -1;
     /// y as u128; // will return 18446744073709551615
@@ -66,17 +66,17 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for casts between numerical types that may
+    /// ### What it does
+    /// Checks for casts between numerical types that may
     /// truncate large values. This is expected behavior, so the cast is `Allow` by
     /// default.
     ///
-    /// **Why is this bad?** In some problem domains, it is good practice to avoid
+    /// ### Why is this bad?
+    /// In some problem domains, it is good practice to avoid
     /// truncation. This lint can be activated to help assess where additional
     /// checks could be beneficial.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// fn as_u8(x: u64) -> u8 {
     ///     x as u8
@@ -88,20 +88,20 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for casts from an unsigned type to a signed type of
+    /// ### What it does
+    /// Checks for casts from an unsigned type to a signed type of
     /// the same size. Performing such a cast is a 'no-op' for the compiler,
     /// i.e., nothing is changed at the bit level, and the binary representation of
     /// the value is reinterpreted. This can cause wrapping if the value is too big
     /// for the target signed type. However, the cast works as defined, so this lint
     /// is `Allow` by default.
     ///
-    /// **Why is this bad?** While such a cast is not bad in itself, the results can
+    /// ### Why is this bad?
+    /// While such a cast is not bad in itself, the results can
     /// be surprising when this is not the intended behavior, as demonstrated by the
     /// example below.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// u32::MAX as i32; // will yield a value of `-1`
     /// ```
@@ -111,19 +111,19 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for casts between numerical types that may
+    /// ### What it does
+    /// Checks for casts between numerical types that may
     /// be replaced by safe conversion functions.
     ///
-    /// **Why is this bad?** Rust's `as` keyword will perform many kinds of
+    /// ### Why is this bad?
+    /// Rust's `as` keyword will perform many kinds of
     /// conversions, including silently lossy conversions. Conversion functions such
     /// as `i32::from` will only perform lossless conversions. Using the conversion
     /// functions prevents conversions from turning into silent lossy conversions if
     /// the types of the input expressions ever change, and make it easier for
     /// people reading the code to know that the conversion is lossless.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// fn as_u64(x: u8) -> u64 {
     ///     x as u64
@@ -143,14 +143,14 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for casts to the same type, casts of int literals to integer types
+    /// ### What it does
+    /// Checks for casts to the same type, casts of int literals to integer types
     /// and casts of float literals to float types.
     ///
-    /// **Why is this bad?** It's just unnecessary.
-    ///
-    /// **Known problems:** None.
+    /// ### Why is this bad?
+    /// It's just unnecessary.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// let _ = 2i32 as i32;
     /// let _ = 0.5 as f32;
@@ -168,17 +168,20 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for casts, using `as` or `pointer::cast`,
+    /// ### What it does
+    /// Checks for casts, using `as` or `pointer::cast`,
     /// from a less-strictly-aligned pointer to a more-strictly-aligned pointer
     ///
-    /// **Why is this bad?** Dereferencing the resulting pointer may be undefined
+    /// ### Why is this bad?
+    /// Dereferencing the resulting pointer may be undefined
     /// behavior.
     ///
-    /// **Known problems:** Using `std::ptr::read_unaligned` and `std::ptr::write_unaligned` or similar
+    /// ### Known problems
+    /// Using `std::ptr::read_unaligned` and `std::ptr::write_unaligned` or similar
     /// on the resulting pointer is fine. Is over-zealous: Casts with manual alignment checks or casts like
     /// u64-> u8 -> u16 can be fine. Miri is able to do a more in-depth analysis.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// let _ = (&1u8 as *const u8) as *const u16;
     /// let _ = (&mut 1u8 as *mut u8) as *mut u16;
@@ -192,9 +195,10 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for casts of function pointers to something other than usize
+    /// ### What it does
+    /// Checks for casts of function pointers to something other than usize
     ///
-    /// **Why is this bad?**
+    /// ### Why is this bad?
     /// Casting a function pointer to anything other than usize/isize is not portable across
     /// architectures, because you end up losing bits if the target type is too small or end up with a
     /// bunch of extra bits that waste space and add more instructions to the final binary than
@@ -202,8 +206,7 @@ declare_clippy_lint! {
     ///
     /// Casting to isize also doesn't make sense since there are no signed addresses.
     ///
-    /// **Example**
-    ///
+    /// ### Example
     /// ```rust
     /// // Bad
     /// fn fun() -> i32 { 1 }
@@ -219,16 +222,16 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for casts of a function pointer to a numeric type not wide enough to
+    /// ### What it does
+    /// Checks for casts of a function pointer to a numeric type not wide enough to
     /// store address.
     ///
-    /// **Why is this bad?**
+    /// ### Why is this bad?
     /// Such a cast discards some bits of the function's address. If this is intended, it would be more
     /// clearly expressed by casting to usize first, then casting the usize to the intended type (with
     /// a comment) to perform the truncation.
     ///
-    /// **Example**
-    ///
+    /// ### Example
     /// ```rust
     /// // Bad
     /// fn fn1() -> i16 {
@@ -249,15 +252,15 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for casts of `&T` to `&mut T` anywhere in the code.
+    /// ### What it does
+    /// Checks for casts of `&T` to `&mut T` anywhere in the code.
     ///
-    /// **Why is this bad?** It’s basically guaranteed to be undefined behaviour.
+    /// ### Why is this bad?
+    /// It’s basically guaranteed to be undefined behaviour.
     /// `UnsafeCell` is the only way to obtain aliasable data that is considered
     /// mutable.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust,ignore
     /// fn x(r: &i32) {
     ///     unsafe {
@@ -283,18 +286,18 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for expressions where a character literal is cast
+    /// ### What it does
+    /// Checks for expressions where a character literal is cast
     /// to `u8` and suggests using a byte literal instead.
     ///
-    /// **Why is this bad?** In general, casting values to smaller types is
+    /// ### Why is this bad?
+    /// In general, casting values to smaller types is
     /// error-prone and should be avoided where possible. In the particular case of
     /// converting a character literal to u8, it is easy to avoid by just using a
     /// byte literal instead. As an added bonus, `b'a'` is even slightly shorter
     /// than `'a' as u8`.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust,ignore
     /// 'x' as u8
     /// ```
@@ -310,18 +313,15 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:**
+    /// ### What it does
     /// Checks for `as` casts between raw pointers without changing its mutability,
     /// namely `*const T` to `*const U` and `*mut T` to `*mut U`.
     ///
-    /// **Why is this bad?**
+    /// ### Why is this bad?
     /// Though `as` casts between raw pointers is not terrible, `pointer::cast` is safer because
     /// it cannot accidentally change the pointer's mutability nor cast the pointer to other types like `usize`.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust
     /// let ptr: *const u32 = &42_u32;
     /// let mut_ptr: *mut u32 = &mut 42_u32;
diff --git a/clippy_lints/src/checked_conversions.rs b/clippy_lints/src/checked_conversions.rs
index 8d3123e1ec8..842bbf006cc 100644
--- a/clippy_lints/src/checked_conversions.rs
+++ b/clippy_lints/src/checked_conversions.rs
@@ -13,13 +13,13 @@ use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for explicit bounds checking when casting.
+    /// ### What it does
+    /// Checks for explicit bounds checking when casting.
     ///
-    /// **Why is this bad?** Reduces the readability of statements & is error prone.
+    /// ### Why is this bad?
+    /// Reduces the readability of statements & is error prone.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// # let foo: u32 = 5;
     /// # let _ =
diff --git a/clippy_lints/src/cognitive_complexity.rs b/clippy_lints/src/cognitive_complexity.rs
index f62c6a9c325..96c30d57ee1 100644
--- a/clippy_lints/src/cognitive_complexity.rs
+++ b/clippy_lints/src/cognitive_complexity.rs
@@ -14,15 +14,19 @@ use rustc_span::source_map::Span;
 use rustc_span::{sym, BytePos};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for methods with high cognitive complexity.
+    /// ### What it does
+    /// Checks for methods with high cognitive complexity.
     ///
-    /// **Why is this bad?** Methods of high cognitive complexity tend to be hard to
+    /// ### Why is this bad?
+    /// Methods of high cognitive complexity tend to be hard to
     /// both read and maintain. Also LLVM will tend to optimize small methods better.
     ///
-    /// **Known problems:** Sometimes it's hard to find a way to reduce the
+    /// ### Known problems
+    /// Sometimes it's hard to find a way to reduce the
     /// complexity.
     ///
-    /// **Example:** No. You'll see it when you get the warning.
+    /// ### Example
+    /// No. You'll see it when you get the warning.
     pub COGNITIVE_COMPLEXITY,
     nursery,
     "functions that should be split up into multiple functions"
diff --git a/clippy_lints/src/collapsible_if.rs b/clippy_lints/src/collapsible_if.rs
index 6e950738239..4aa87980715 100644
--- a/clippy_lints/src/collapsible_if.rs
+++ b/clippy_lints/src/collapsible_if.rs
@@ -22,15 +22,15 @@ use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for nested `if` statements which can be collapsed
+    /// ### What it does
+    /// Checks for nested `if` statements which can be collapsed
     /// by `&&`-combining their conditions.
     ///
-    /// **Why is this bad?** Each `if`-statement adds one level of nesting, which
+    /// ### Why is this bad?
+    /// Each `if`-statement adds one level of nesting, which
     /// makes code look more complex than it really is.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust,ignore
     /// if x {
     ///     if y {
@@ -53,15 +53,15 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for collapsible `else { if ... }` expressions
+    /// ### What it does
+    /// Checks for collapsible `else { if ... }` expressions
     /// that can be collapsed to `else if ...`.
     ///
-    /// **Why is this bad?** Each `if`-statement adds one level of nesting, which
+    /// ### Why is this bad?
+    /// Each `if`-statement adds one level of nesting, which
     /// makes code look more complex than it really is.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust,ignore
     ///
     /// if x {
diff --git a/clippy_lints/src/collapsible_match.rs b/clippy_lints/src/collapsible_match.rs
index a6c3a5b0e83..a403a9846ba 100644
--- a/clippy_lints/src/collapsible_match.rs
+++ b/clippy_lints/src/collapsible_match.rs
@@ -9,18 +9,17 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::{MultiSpan, Span};
 
 declare_clippy_lint! {
-    /// **What it does:** Finds nested `match` or `if let` expressions where the patterns may be "collapsed" together
+    /// ### What it does
+    /// Finds nested `match` or `if let` expressions where the patterns may be "collapsed" together
     /// without adding any branches.
     ///
     /// Note that this lint is not intended to find _all_ cases where nested match patterns can be merged, but only
     /// cases where merging would most likely make the code more readable.
     ///
-    /// **Why is this bad?** It is unnecessarily verbose and complex.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Why is this bad?
+    /// It is unnecessarily verbose and complex.
     ///
+    /// ### Example
     /// ```rust
     /// fn func(opt: Option<Result<u64, String>>) {
     ///     let n = match opt {
diff --git a/clippy_lints/src/comparison_chain.rs b/clippy_lints/src/comparison_chain.rs
index b6999bef6e7..597a3c67024 100644
--- a/clippy_lints/src/comparison_chain.rs
+++ b/clippy_lints/src/comparison_chain.rs
@@ -6,16 +6,19 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks comparison chains written with `if` that can be
+    /// ### What it does
+    /// Checks comparison chains written with `if` that can be
     /// rewritten with `match` and `cmp`.
     ///
-    /// **Why is this bad?** `if` is not guaranteed to be exhaustive and conditionals can get
+    /// ### Why is this bad?
+    /// `if` is not guaranteed to be exhaustive and conditionals can get
     /// repetitive
     ///
-    /// **Known problems:** The match statement may be slower due to the compiler
+    /// ### Known problems
+    /// The match statement may be slower due to the compiler
     /// not inlining the call to cmp. See issue [#5354](https://github.com/rust-lang/rust-clippy/issues/5354)
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust,ignore
     /// # fn a() {}
     /// # fn b() {}
diff --git a/clippy_lints/src/copies.rs b/clippy_lints/src/copies.rs
index 9cbcde59768..2dcd5545799 100644
--- a/clippy_lints/src/copies.rs
+++ b/clippy_lints/src/copies.rs
@@ -16,13 +16,13 @@ use rustc_span::{source_map::Span, symbol::Symbol, BytePos};
 use std::borrow::Cow;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for consecutive `if`s with the same condition.
+    /// ### What it does
+    /// Checks for consecutive `if`s with the same condition.
     ///
-    /// **Why is this bad?** This is probably a copy & paste error.
+    /// ### Why is this bad?
+    /// This is probably a copy & paste error.
     ///
-    /// **Known problems:** Hopefully none.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```ignore
     /// if a == b {
     ///     …
@@ -47,15 +47,15 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for consecutive `if`s with the same function call.
+    /// ### What it does
+    /// Checks for consecutive `if`s with the same function call.
     ///
-    /// **Why is this bad?** This is probably a copy & paste error.
+    /// ### Why is this bad?
+    /// This is probably a copy & paste error.
     /// Despite the fact that function can have side effects and `if` works as
     /// intended, such an approach is implicit and can be considered a "code smell".
     ///
-    /// **Known problems:** Hopefully none.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```ignore
     /// if foo() == bar {
     ///     …
@@ -94,14 +94,14 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for `if/else` with the same body as the *then* part
+    /// ### What it does
+    /// Checks for `if/else` with the same body as the *then* part
     /// and the *else* part.
     ///
-    /// **Why is this bad?** This is probably a copy & paste error.
-    ///
-    /// **Known problems:** Hopefully none.
+    /// ### Why is this bad?
+    /// This is probably a copy & paste error.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```ignore
     /// let foo = if … {
     ///     42
@@ -115,17 +115,19 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks if the `if` and `else` block contain shared code that can be
+    /// ### What it does
+    /// Checks if the `if` and `else` block contain shared code that can be
     /// moved out of the blocks.
     ///
-    /// **Why is this bad?** Duplicate code is less maintainable.
+    /// ### Why is this bad?
+    /// Duplicate code is less maintainable.
     ///
-    /// **Known problems:**
+    /// ### Known problems
     /// * The lint doesn't check if the moved expressions modify values that are beeing used in
     ///   the if condition. The suggestion can in that case modify the behavior of the program.
     ///   See [rust-clippy#7452](https://github.com/rust-lang/rust-clippy/issues/7452)
     ///
-    /// **Example:**
+    /// ### Example
     /// ```ignore
     /// let foo = if … {
     ///     println!("Hello World");
diff --git a/clippy_lints/src/copy_iterator.rs b/clippy_lints/src/copy_iterator.rs
index 35079c6bedc..c2e9e8b3ab7 100644
--- a/clippy_lints/src/copy_iterator.rs
+++ b/clippy_lints/src/copy_iterator.rs
@@ -8,15 +8,15 @@ use rustc_span::sym;
 use if_chain::if_chain;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for types that implement `Copy` as well as
+    /// ### What it does
+    /// Checks for types that implement `Copy` as well as
     /// `Iterator`.
     ///
-    /// **Why is this bad?** Implicit copies can be confusing when working with
+    /// ### Why is this bad?
+    /// Implicit copies can be confusing when working with
     /// iterator combinators.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust,ignore
     /// #[derive(Copy, Clone)]
     /// struct Countdown(u8);
diff --git a/clippy_lints/src/create_dir.rs b/clippy_lints/src/create_dir.rs
index 7b5cce6462a..e4ee2772483 100644
--- a/clippy_lints/src/create_dir.rs
+++ b/clippy_lints/src/create_dir.rs
@@ -8,13 +8,13 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks usage of `std::fs::create_dir` and suggest using `std::fs::create_dir_all` instead.
+    /// ### What it does
+    /// Checks usage of `std::fs::create_dir` and suggest using `std::fs::create_dir_all` instead.
     ///
-    /// **Why is this bad?** Sometimes `std::fs::create_dir` is mistakenly chosen over `std::fs::create_dir_all`.
+    /// ### Why is this bad?
+    /// Sometimes `std::fs::create_dir` is mistakenly chosen over `std::fs::create_dir_all`.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     ///
     /// ```rust
     /// std::fs::create_dir("foo");
diff --git a/clippy_lints/src/dbg_macro.rs b/clippy_lints/src/dbg_macro.rs
index 286cc7e223e..bab4a696f83 100644
--- a/clippy_lints/src/dbg_macro.rs
+++ b/clippy_lints/src/dbg_macro.rs
@@ -8,14 +8,14 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for usage of dbg!() macro.
+    /// ### What it does
+    /// Checks for usage of dbg!() macro.
     ///
-    /// **Why is this bad?** `dbg!` macro is intended as a debugging tool. It
+    /// ### Why is this bad?
+    /// `dbg!` macro is intended as a debugging tool. It
     /// should not be in version control.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust,ignore
     /// // Bad
     /// dbg!(true)
diff --git a/clippy_lints/src/default.rs b/clippy_lints/src/default.rs
index 947479db8f5..db8f2171348 100644
--- a/clippy_lints/src/default.rs
+++ b/clippy_lints/src/default.rs
@@ -13,14 +13,14 @@ use rustc_span::symbol::{Ident, Symbol};
 use rustc_span::Span;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for literal calls to `Default::default()`.
+    /// ### What it does
+    /// Checks for literal calls to `Default::default()`.
     ///
-    /// **Why is this bad?** It's more clear to the reader to use the name of the type whose default is
+    /// ### Why is this bad?
+    /// It's more clear to the reader to use the name of the type whose default is
     /// being gotten than the generic `Default`.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// // Bad
     /// let s: String = Default::default();
@@ -34,14 +34,17 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for immediate reassignment of fields initialized
+    /// ### What it does
+    /// Checks for immediate reassignment of fields initialized
     /// with Default::default().
     ///
-    /// **Why is this bad?**It's more idiomatic to use the [functional update syntax](https://doc.rust-lang.org/reference/expressions/struct-expr.html#functional-update-syntax).
+    /// ### Why is this bad?
+    ///It's more idiomatic to use the [functional update syntax](https://doc.rust-lang.org/reference/expressions/struct-expr.html#functional-update-syntax).
     ///
-    /// **Known problems:** Assignments to patterns that are of tuple type are not linted.
+    /// ### Known problems
+    /// Assignments to patterns that are of tuple type are not linted.
     ///
-    /// **Example:**
+    /// ### Example
     /// Bad:
     /// ```
     /// # #[derive(Default)]
diff --git a/clippy_lints/src/default_numeric_fallback.rs b/clippy_lints/src/default_numeric_fallback.rs
index e719a1b0abf..3f1b7ea6214 100644
--- a/clippy_lints/src/default_numeric_fallback.rs
+++ b/clippy_lints/src/default_numeric_fallback.rs
@@ -18,7 +18,8 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use std::iter;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for usage of unconstrained numeric literals which may cause default numeric fallback in type
+    /// ### What it does
+    /// Checks for usage of unconstrained numeric literals which may cause default numeric fallback in type
     /// inference.
     ///
     /// Default numeric fallback means that if numeric types have not yet been bound to concrete
@@ -27,12 +28,14 @@ declare_clippy_lint! {
     ///
     /// See [RFC0212](https://github.com/rust-lang/rfcs/blob/master/text/0212-restore-int-fallback.md) for more information about the fallback.
     ///
-    /// **Why is this bad?** For those who are very careful about types, default numeric fallback
+    /// ### Why is this bad?
+    /// For those who are very careful about types, default numeric fallback
     /// can be a pitfall that cause unexpected runtime behavior.
     ///
-    /// **Known problems:** This lint can only be allowed at the function level or above.
+    /// ### Known problems
+    /// This lint can only be allowed at the function level or above.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// let i = 10;
     /// let f = 1.23;
diff --git a/clippy_lints/src/deprecated_lints.rs b/clippy_lints/src/deprecated_lints.rs
index 2933fbc9341..c604516742c 100644
--- a/clippy_lints/src/deprecated_lints.rs
+++ b/clippy_lints/src/deprecated_lints.rs
@@ -12,27 +12,33 @@ macro_rules! declare_deprecated_lint {
 }
 
 declare_deprecated_lint! {
-    /// **What it does:** Nothing. This lint has been deprecated.
+    /// ### What it does
+    /// Nothing. This lint has been deprecated.
     ///
-    /// **Deprecation reason:** This used to check for `assert!(a == b)` and recommend
+    /// ### Deprecation reason
+    /// This used to check for `assert!(a == b)` and recommend
     /// replacement with `assert_eq!(a, b)`, but this is no longer needed after RFC 2011.
     pub SHOULD_ASSERT_EQ,
     "`assert!()` will be more flexible with RFC 2011"
 }
 
 declare_deprecated_lint! {
-    /// **What it does:** Nothing. This lint has been deprecated.
+    /// ### What it does
+    /// Nothing. This lint has been deprecated.
     ///
-    /// **Deprecation reason:** This used to check for `Vec::extend`, which was slower than
+    /// ### Deprecation reason
+    /// This used to check for `Vec::extend`, which was slower than
     /// `Vec::extend_from_slice`. Thanks to specialization, this is no longer true.
     pub EXTEND_FROM_SLICE,
     "`.extend_from_slice(_)` is a faster way to extend a Vec by a slice"
 }
 
 declare_deprecated_lint! {
-    /// **What it does:** Nothing. This lint has been deprecated.
+    /// ### What it does
+    /// Nothing. This lint has been deprecated.
     ///
-    /// **Deprecation reason:** `Range::step_by(0)` used to be linted since it's
+    /// ### Deprecation reason
+    /// `Range::step_by(0)` used to be linted since it's
     /// an infinite iterator, which is better expressed by `iter::repeat`,
     /// but the method has been removed for `Iterator::step_by` which panics
     /// if given a zero
@@ -41,27 +47,33 @@ declare_deprecated_lint! {
 }
 
 declare_deprecated_lint! {
-    /// **What it does:** Nothing. This lint has been deprecated.
+    /// ### What it does
+    /// Nothing. This lint has been deprecated.
     ///
-    /// **Deprecation reason:** This used to check for `Vec::as_slice`, which was unstable with good
+    /// ### Deprecation reason
+    /// This used to check for `Vec::as_slice`, which was unstable with good
     /// stable alternatives. `Vec::as_slice` has now been stabilized.
     pub UNSTABLE_AS_SLICE,
     "`Vec::as_slice` has been stabilized in 1.7"
 }
 
 declare_deprecated_lint! {
-    /// **What it does:** Nothing. This lint has been deprecated.
+    /// ### What it does
+    /// Nothing. This lint has been deprecated.
     ///
-    /// **Deprecation reason:** This used to check for `Vec::as_mut_slice`, which was unstable with good
+    /// ### Deprecation reason
+    /// This used to check for `Vec::as_mut_slice`, which was unstable with good
     /// stable alternatives. `Vec::as_mut_slice` has now been stabilized.
     pub UNSTABLE_AS_MUT_SLICE,
     "`Vec::as_mut_slice` has been stabilized in 1.7"
 }
 
 declare_deprecated_lint! {
-    /// **What it does:** Nothing. This lint has been deprecated.
+    /// ### What it does
+    /// Nothing. This lint has been deprecated.
     ///
-    /// **Deprecation reason:** This lint should never have applied to non-pointer types, as transmuting
+    /// ### Deprecation reason
+    /// This lint should never have applied to non-pointer types, as transmuting
     /// between non-pointer types of differing alignment is well-defined behavior (it's semantically
     /// equivalent to a memcpy). This lint has thus been refactored into two separate lints:
     /// cast_ptr_alignment and transmute_ptr_to_ptr.
@@ -70,9 +82,11 @@ declare_deprecated_lint! {
 }
 
 declare_deprecated_lint! {
-    /// **What it does:** Nothing. This lint has been deprecated.
+    /// ### What it does
+    /// Nothing. This lint has been deprecated.
     ///
-    /// **Deprecation reason:** This lint is too subjective, not having a good reason for being in clippy.
+    /// ### Deprecation reason
+    /// This lint is too subjective, not having a good reason for being in clippy.
     /// Additionally, compound assignment operators may be overloaded separately from their non-assigning
     /// counterparts, so this lint may suggest a change in behavior or the code may not compile.
     pub ASSIGN_OPS,
@@ -80,9 +94,11 @@ declare_deprecated_lint! {
 }
 
 declare_deprecated_lint! {
-    /// **What it does:** Nothing. This lint has been deprecated.
+    /// ### What it does
+    /// Nothing. This lint has been deprecated.
     ///
-    /// **Deprecation reason:** The original rule will only lint for `if let`. After
+    /// ### Deprecation reason
+    /// The original rule will only lint for `if let`. After
     /// making it support to lint `match`, naming as `if let` is not suitable for it.
     /// So, this lint is deprecated.
     pub IF_LET_REDUNDANT_PATTERN_MATCHING,
@@ -90,9 +106,11 @@ declare_deprecated_lint! {
 }
 
 declare_deprecated_lint! {
-    /// **What it does:** Nothing. This lint has been deprecated.
+    /// ### What it does
+    /// Nothing. This lint has been deprecated.
     ///
-    /// **Deprecation reason:** This lint used to suggest replacing `let mut vec =
+    /// ### Deprecation reason
+    /// This lint used to suggest replacing `let mut vec =
     /// Vec::with_capacity(n); vec.set_len(n);` with `let vec = vec![0; n];`. The
     /// replacement has very different performance characteristics so the lint is
     /// deprecated.
@@ -101,51 +119,63 @@ declare_deprecated_lint! {
 }
 
 declare_deprecated_lint! {
-    /// **What it does:** Nothing. This lint has been deprecated.
+    /// ### What it does
+    /// Nothing. This lint has been deprecated.
     ///
-    /// **Deprecation reason:** This lint has been superseded by #[must_use] in rustc.
+    /// ### Deprecation reason
+    /// This lint has been superseded by #[must_use] in rustc.
     pub UNUSED_COLLECT,
     "`collect` has been marked as #[must_use] in rustc and that covers all cases of this lint"
 }
 
 declare_deprecated_lint! {
-    /// **What it does:** Nothing. This lint has been deprecated.
+    /// ### What it does
+    /// Nothing. This lint has been deprecated.
     ///
-    /// **Deprecation reason:** Associated-constants are now preferred.
+    /// ### Deprecation reason
+    /// Associated-constants are now preferred.
     pub REPLACE_CONSTS,
     "associated-constants `MIN`/`MAX` of integers are preferred to `{min,max}_value()` and module constants"
 }
 
 declare_deprecated_lint! {
-    /// **What it does:** Nothing. This lint has been deprecated.
+    /// ### What it does
+    /// Nothing. This lint has been deprecated.
     ///
-    /// **Deprecation reason:** The regex! macro does not exist anymore.
+    /// ### Deprecation reason
+    /// The regex! macro does not exist anymore.
     pub REGEX_MACRO,
     "the regex! macro has been removed from the regex crate in 2018"
 }
 
 declare_deprecated_lint! {
-    /// **What it does:** Nothing. This lint has been deprecated.
+    /// ### What it does
+    /// Nothing. This lint has been deprecated.
     ///
-    /// **Deprecation reason:** This lint has been replaced by `manual_find_map`, a
+    /// ### Deprecation reason
+    /// This lint has been replaced by `manual_find_map`, a
     /// more specific lint.
     pub FIND_MAP,
     "this lint has been replaced by `manual_find_map`, a more specific lint"
 }
 
 declare_deprecated_lint! {
-    /// **What it does:** Nothing. This lint has been deprecated.
+    /// ### What it does
+    /// Nothing. This lint has been deprecated.
     ///
-    /// **Deprecation reason:** This lint has been replaced by `manual_filter_map`, a
+    /// ### Deprecation reason
+    /// This lint has been replaced by `manual_filter_map`, a
     /// more specific lint.
     pub FILTER_MAP,
     "this lint has been replaced by `manual_filter_map`, a more specific lint"
 }
 
 declare_deprecated_lint! {
-    /// **What it does:** Nothing. This lint has been deprecated.
+    /// ### What it does
+    /// Nothing. This lint has been deprecated.
     ///
-    /// **Deprecation reason:** The `avoid_breaking_exported_api` config option was added, which
+    /// ### Deprecation reason
+    /// The `avoid_breaking_exported_api` config option was added, which
     /// enables the `enum_variant_names` lint for public items.
     /// ```
     pub PUB_ENUM_VARIANT_NAMES,
@@ -153,9 +183,11 @@ declare_deprecated_lint! {
 }
 
 declare_deprecated_lint! {
-    /// **What it does:** Nothing. This lint has been deprecated.
+    /// ### What it does
+    /// Nothing. This lint has been deprecated.
     ///
-    /// **Deprecation reason:** The `avoid_breaking_exported_api` config option was added, which
+    /// ### Deprecation reason
+    /// The `avoid_breaking_exported_api` config option was added, which
     /// enables the `wrong_self_conversion` lint for public items.
     pub WRONG_PUB_SELF_CONVENTION,
     "set the `avoid-breaking-exported-api` config option to `false` to enable the `wrong_self_convention` lint for public items"
diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index 682003f9c2c..ded7001ad8c 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -11,12 +11,14 @@ use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::{symbol::sym, Span};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for explicit `deref()` or `deref_mut()` method calls.
+    /// ### What it does
+    /// Checks for explicit `deref()` or `deref_mut()` method calls.
     ///
-    /// **Why is this bad?** Dereferencing by `&*x` or `&mut *x` is clearer and more concise,
+    /// ### Why is this bad?
+    /// Dereferencing by `&*x` or `&mut *x` is clearer and more concise,
     /// when not part of a method chain.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// use std::ops::Deref;
     /// let a: &mut String = &mut String::from("foo");
diff --git a/clippy_lints/src/derive.rs b/clippy_lints/src/derive.rs
index 7aafaf71383..dcfa5253f83 100644
--- a/clippy_lints/src/derive.rs
+++ b/clippy_lints/src/derive.rs
@@ -15,10 +15,12 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for deriving `Hash` but implementing `PartialEq`
+    /// ### What it does
+    /// Checks for deriving `Hash` but implementing `PartialEq`
     /// explicitly or vice versa.
     ///
-    /// **Why is this bad?** The implementation of these traits must agree (for
+    /// ### Why is this bad?
+    /// The implementation of these traits must agree (for
     /// example for use with `HashMap`) so it’s probably a bad idea to use a
     /// default-generated `Hash` implementation with an explicitly defined
     /// `PartialEq`. In particular, the following must hold for any type:
@@ -27,9 +29,7 @@ declare_clippy_lint! {
     /// k1 == k2 ⇒ hash(k1) == hash(k2)
     /// ```
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```ignore
     /// #[derive(Hash)]
     /// struct Foo;
@@ -44,10 +44,12 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for deriving `Ord` but implementing `PartialOrd`
+    /// ### What it does
+    /// Checks for deriving `Ord` but implementing `PartialOrd`
     /// explicitly or vice versa.
     ///
-    /// **Why is this bad?** The implementation of these traits must agree (for
+    /// ### Why is this bad?
+    /// The implementation of these traits must agree (for
     /// example for use with `sort`) so it’s probably a bad idea to use a
     /// default-generated `Ord` implementation with an explicitly defined
     /// `PartialOrd`. In particular, the following must hold for any type
@@ -57,10 +59,7 @@ declare_clippy_lint! {
     /// k1.cmp(&k2) == k1.partial_cmp(&k2).unwrap()
     /// ```
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust,ignore
     /// #[derive(Ord, PartialEq, Eq)]
     /// struct Foo;
@@ -95,18 +94,21 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for explicit `Clone` implementations for `Copy`
+    /// ### What it does
+    /// Checks for explicit `Clone` implementations for `Copy`
     /// types.
     ///
-    /// **Why is this bad?** To avoid surprising behaviour, these traits should
+    /// ### Why is this bad?
+    /// To avoid surprising behaviour, these traits should
     /// agree and the behaviour of `Copy` cannot be overridden. In almost all
     /// situations a `Copy` type should have a `Clone` implementation that does
     /// nothing more than copy the object, which is what `#[derive(Copy, Clone)]`
     /// gets you.
     ///
-    /// **Known problems:** Bounds of generic types are sometimes wrong: https://github.com/rust-lang/rust/issues/26925
+    /// ### Known problems
+    /// Bounds of generic types are sometimes wrong: https://github.com/rust-lang/rust/issues/26925
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust,ignore
     /// #[derive(Copy)]
     /// struct Foo;
@@ -121,16 +123,15 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for deriving `serde::Deserialize` on a type that
+    /// ### What it does
+    /// Checks for deriving `serde::Deserialize` on a type that
     /// has methods using `unsafe`.
     ///
-    /// **Why is this bad?** Deriving `serde::Deserialize` will create a constructor
+    /// ### Why is this bad?
+    /// Deriving `serde::Deserialize` will create a constructor
     /// that may violate invariants hold by another constructor.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust,ignore
     /// use serde::Deserialize;
     ///
diff --git a/clippy_lints/src/disallowed_method.rs b/clippy_lints/src/disallowed_method.rs
index aa1a609afed..7069cb4198c 100644
--- a/clippy_lints/src/disallowed_method.rs
+++ b/clippy_lints/src/disallowed_method.rs
@@ -8,15 +8,14 @@ use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::Symbol;
 
 declare_clippy_lint! {
-    /// **What it does:** Denies the configured methods and functions in clippy.toml
+    /// ### What it does
+    /// Denies the configured methods and functions in clippy.toml
     ///
-    /// **Why is this bad?** Some methods are undesirable in certain contexts,
+    /// ### Why is this bad?
+    /// Some methods are undesirable in certain contexts,
     /// and it's beneficial to lint for them as needed.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// An example clippy.toml configuration:
     /// ```toml
     /// # clippy.toml
diff --git a/clippy_lints/src/disallowed_script_idents.rs b/clippy_lints/src/disallowed_script_idents.rs
index 12c525634c5..6d38d30cd0b 100644
--- a/clippy_lints/src/disallowed_script_idents.rs
+++ b/clippy_lints/src/disallowed_script_idents.rs
@@ -6,7 +6,8 @@ use rustc_session::{declare_tool_lint, impl_lint_pass};
 use unicode_script::{Script, UnicodeScript};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for usage of unicode scripts other than those explicitly allowed
+    /// ### What it does
+    /// Checks for usage of unicode scripts other than those explicitly allowed
     /// by the lint config.
     ///
     /// This lint doesn't take into account non-text scripts such as `Unknown` and `Linear_A`.
@@ -19,7 +20,8 @@ declare_clippy_lint! {
     /// [aliases]: http://www.unicode.org/reports/tr24/tr24-31.html#Script_Value_Aliases
     /// [supported_scripts]: https://www.unicode.org/iso15924/iso15924-codes.html
     ///
-    /// **Why is this bad?** It may be not desired to have many different scripts for
+    /// ### Why is this bad?
+    /// It may be not desired to have many different scripts for
     /// identifiers in the codebase.
     ///
     /// Note that if you only want to allow plain English, you might want to use
@@ -27,9 +29,7 @@ declare_clippy_lint! {
     ///
     /// [`non_ascii_idents`]: https://doc.rust-lang.org/rustc/lints/listing/allowed-by-default.html#non-ascii-idents
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// // Assuming that `clippy.toml` contains the following line:
     /// // allowed-locales = ["Latin", "Cyrillic"]
diff --git a/clippy_lints/src/disallowed_type.rs b/clippy_lints/src/disallowed_type.rs
index 7c76e2322c2..e627168b932 100644
--- a/clippy_lints/src/disallowed_type.rs
+++ b/clippy_lints/src/disallowed_type.rs
@@ -9,14 +9,13 @@ use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::{Span, Symbol};
 
 declare_clippy_lint! {
-    /// **What it does:** Denies the configured types in clippy.toml.
+    /// ### What it does
+    /// Denies the configured types in clippy.toml.
     ///
-    /// **Why is this bad?** Some types are undesirable in certain contexts.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Why is this bad?
+    /// Some types are undesirable in certain contexts.
     ///
+    /// ### Example:
     /// An example clippy.toml configuration:
     /// ```toml
     /// # clippy.toml
diff --git a/clippy_lints/src/doc.rs b/clippy_lints/src/doc.rs
index 0c19988a975..c39829fdc7a 100644
--- a/clippy_lints/src/doc.rs
+++ b/clippy_lints/src/doc.rs
@@ -30,15 +30,18 @@ use std::thread;
 use url::Url;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for the presence of `_`, `::` or camel-case words
+    /// ### What it does
+    /// Checks for the presence of `_`, `::` or camel-case words
     /// outside ticks in documentation.
     ///
-    /// **Why is this bad?** *Rustdoc* supports markdown formatting, `_`, `::` and
+    /// ### Why is this bad?
+    /// *Rustdoc* supports markdown formatting, `_`, `::` and
     /// camel-case probably indicates some code which should be included between
     /// ticks. `_` can also be used for emphasis in markdown, this lint tries to
     /// consider that.
     ///
-    /// **Known problems:** Lots of bad docs won’t be fixed, what the lint checks
+    /// ### Known problems
+    /// Lots of bad docs won’t be fixed, what the lint checks
     /// for is limited, and there are still false positives. HTML elements and their
     /// content are not linted.
     ///
@@ -47,7 +50,7 @@ declare_clippy_lint! {
     /// `[`SmallVec<[T; INLINE_CAPACITY]>`]` and then [`SmallVec<[T; INLINE_CAPACITY]>`]: SmallVec
     /// would fail.
     ///
-    /// **Examples:**
+    /// ### Examples
     /// ```rust
     /// /// Do something with the foo_bar parameter. See also
     /// /// that::other::module::foo.
@@ -68,15 +71,15 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for the doc comments of publicly visible
+    /// ### What it does
+    /// Checks for the doc comments of publicly visible
     /// unsafe functions and warns if there is no `# Safety` section.
     ///
-    /// **Why is this bad?** Unsafe functions should document their safety
+    /// ### Why is this bad?
+    /// Unsafe functions should document their safety
     /// preconditions, so that users can be sure they are using them safely.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Examples:**
+    /// ### Examples
     /// ```rust
     ///# type Universe = ();
     /// /// This function should really be documented
@@ -102,16 +105,15 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks the doc comments of publicly visible functions that
+    /// ### What it does
+    /// Checks the doc comments of publicly visible functions that
     /// return a `Result` type and warns if there is no `# Errors` section.
     ///
-    /// **Why is this bad?** Documenting the type of errors that can be returned from a
+    /// ### Why is this bad?
+    /// Documenting the type of errors that can be returned from a
     /// function can help callers write code to handle the errors appropriately.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Examples:**
-    ///
+    /// ### Examples
     /// Since the following function returns a `Result` it has an `# Errors` section in
     /// its doc comment:
     ///
@@ -131,16 +133,15 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks the doc comments of publicly visible functions that
+    /// ### What it does
+    /// Checks the doc comments of publicly visible functions that
     /// may panic and warns if there is no `# Panics` section.
     ///
-    /// **Why is this bad?** Documenting the scenarios in which panicking occurs
+    /// ### Why is this bad?
+    /// Documenting the scenarios in which panicking occurs
     /// can help callers who do not want to panic to avoid those situations.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Examples:**
-    ///
+    /// ### Examples
     /// Since the following function may panic it has a `# Panics` section in
     /// its doc comment:
     ///
@@ -162,14 +163,14 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for `fn main() { .. }` in doctests
+    /// ### What it does
+    /// Checks for `fn main() { .. }` in doctests
     ///
-    /// **Why is this bad?** The test can be shorter (and likely more readable)
+    /// ### Why is this bad?
+    /// The test can be shorter (and likely more readable)
     /// if the `fn main()` is left implicit.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Examples:**
+    /// ### Examples
     /// ``````rust
     /// /// An example of a doctest with a `main()` function
     /// ///
diff --git a/clippy_lints/src/double_comparison.rs b/clippy_lints/src/double_comparison.rs
index 4966638cb1b..6520bb91faf 100644
--- a/clippy_lints/src/double_comparison.rs
+++ b/clippy_lints/src/double_comparison.rs
@@ -10,14 +10,14 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for double comparisons that could be simplified to a single expression.
+    /// ### What it does
+    /// Checks for double comparisons that could be simplified to a single expression.
     ///
     ///
-    /// **Why is this bad?** Readability.
+    /// ### Why is this bad?
+    /// Readability.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// # let x = 1;
     /// # let y = 2;
diff --git a/clippy_lints/src/double_parens.rs b/clippy_lints/src/double_parens.rs
index e4e4a93b011..d0d87b6df9a 100644
--- a/clippy_lints/src/double_parens.rs
+++ b/clippy_lints/src/double_parens.rs
@@ -4,14 +4,14 @@ use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for unnecessary double parentheses.
+    /// ### What it does
+    /// Checks for unnecessary double parentheses.
     ///
-    /// **Why is this bad?** This makes code harder to read and might indicate a
+    /// ### Why is this bad?
+    /// This makes code harder to read and might indicate a
     /// mistake.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// // Bad
     /// fn simple_double_parens() -> i32 {
diff --git a/clippy_lints/src/drop_forget_ref.rs b/clippy_lints/src/drop_forget_ref.rs
index b5b29760636..0f3dc866afb 100644
--- a/clippy_lints/src/drop_forget_ref.rs
+++ b/clippy_lints/src/drop_forget_ref.rs
@@ -8,17 +8,17 @@ use rustc_middle::ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for calls to `std::mem::drop` with a reference
+    /// ### What it does
+    /// Checks for calls to `std::mem::drop` with a reference
     /// instead of an owned value.
     ///
-    /// **Why is this bad?** Calling `drop` on a reference will only drop the
+    /// ### Why is this bad?
+    /// Calling `drop` on a reference will only drop the
     /// reference itself, which is a no-op. It will not call the `drop` method (from
     /// the `Drop` trait implementation) on the underlying referenced value, which
     /// is likely what was intended.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```ignore
     /// let mut lock_guard = mutex.lock();
     /// std::mem::drop(&lock_guard) // Should have been drop(lock_guard), mutex
@@ -31,17 +31,17 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for calls to `std::mem::forget` with a reference
+    /// ### What it does
+    /// Checks for calls to `std::mem::forget` with a reference
     /// instead of an owned value.
     ///
-    /// **Why is this bad?** Calling `forget` on a reference will only forget the
+    /// ### Why is this bad?
+    /// Calling `forget` on a reference will only forget the
     /// reference itself, which is a no-op. It will not forget the underlying
     /// referenced
     /// value, which is likely what was intended.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// let x = Box::new(1);
     /// std::mem::forget(&x) // Should have been forget(x), x will still be dropped
@@ -52,16 +52,16 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for calls to `std::mem::drop` with a value
+    /// ### What it does
+    /// Checks for calls to `std::mem::drop` with a value
     /// that derives the Copy trait
     ///
-    /// **Why is this bad?** Calling `std::mem::drop` [does nothing for types that
+    /// ### Why is this bad?
+    /// Calling `std::mem::drop` [does nothing for types that
     /// implement Copy](https://doc.rust-lang.org/std/mem/fn.drop.html), since the
     /// value will be copied and moved into the function on invocation.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// let x: i32 = 42; // i32 implements Copy
     /// std::mem::drop(x) // A copy of x is passed to the function, leaving the
@@ -73,10 +73,12 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for calls to `std::mem::forget` with a value that
+    /// ### What it does
+    /// Checks for calls to `std::mem::forget` with a value that
     /// derives the Copy trait
     ///
-    /// **Why is this bad?** Calling `std::mem::forget` [does nothing for types that
+    /// ### Why is this bad?
+    /// Calling `std::mem::forget` [does nothing for types that
     /// implement Copy](https://doc.rust-lang.org/std/mem/fn.drop.html) since the
     /// value will be copied and moved into the function on invocation.
     ///
@@ -86,9 +88,7 @@ declare_clippy_lint! {
     /// there
     /// is nothing for `std::mem::forget` to ignore.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// let x: i32 = 42; // i32 implements Copy
     /// std::mem::forget(x) // A copy of x is passed to the function, leaving the
diff --git a/clippy_lints/src/duration_subsec.rs b/clippy_lints/src/duration_subsec.rs
index 94b09bf7173..3774de62521 100644
--- a/clippy_lints/src/duration_subsec.rs
+++ b/clippy_lints/src/duration_subsec.rs
@@ -12,15 +12,15 @@ use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::paths;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for calculation of subsecond microseconds or milliseconds
+    /// ### What it does
+    /// Checks for calculation of subsecond microseconds or milliseconds
     /// from other `Duration` methods.
     ///
-    /// **Why is this bad?** It's more concise to call `Duration::subsec_micros()` or
+    /// ### Why is this bad?
+    /// It's more concise to call `Duration::subsec_micros()` or
     /// `Duration::subsec_millis()` than to calculate them.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// # use std::time::Duration;
     /// let dur = Duration::new(5, 0);
diff --git a/clippy_lints/src/else_if_without_else.rs b/clippy_lints/src/else_if_without_else.rs
index 26984df9539..0541ac5eccc 100644
--- a/clippy_lints/src/else_if_without_else.rs
+++ b/clippy_lints/src/else_if_without_else.rs
@@ -7,14 +7,14 @@ use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for usage of if expressions with an `else if` branch,
+    /// ### What it does
+    /// Checks for usage of if expressions with an `else if` branch,
     /// but without a final `else` branch.
     ///
-    /// **Why is this bad?** Some coding guidelines require this (e.g., MISRA-C:2004 Rule 14.10).
+    /// ### Why is this bad?
+    /// Some coding guidelines require this (e.g., MISRA-C:2004 Rule 14.10).
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// # fn a() {}
     /// # fn b() {}
diff --git a/clippy_lints/src/empty_enum.rs b/clippy_lints/src/empty_enum.rs
index c92984a9834..3453c2da278 100644
--- a/clippy_lints/src/empty_enum.rs
+++ b/clippy_lints/src/empty_enum.rs
@@ -6,13 +6,15 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for `enum`s with no variants.
+    /// ### What it does
+    /// Checks for `enum`s with no variants.
     ///
     /// As of this writing, the `never_type` is still a
     /// nightly-only experimental API. Therefore, this lint is only triggered
     /// if the `never_type` is enabled.
     ///
-    /// **Why is this bad?** If you want to introduce a type which
+    /// ### Why is this bad?
+    /// If you want to introduce a type which
     /// can't be instantiated, you should use `!` (the primitive type "never"),
     /// or a wrapper around it, because `!` has more extensive
     /// compiler support (type inference, etc...) and wrappers
@@ -20,10 +22,7 @@ declare_clippy_lint! {
     /// For further information visit [never type documentation](https://doc.rust-lang.org/std/primitive.never.html)
     ///
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// Bad:
     /// ```rust
     /// enum Test {}
diff --git a/clippy_lints/src/entry.rs b/clippy_lints/src/entry.rs
index 2eb8b1422ed..e1d0d65edb1 100644
--- a/clippy_lints/src/entry.rs
+++ b/clippy_lints/src/entry.rs
@@ -16,12 +16,15 @@ use rustc_span::{Span, SyntaxContext, DUMMY_SP};
 use std::fmt::Write;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for uses of `contains_key` + `insert` on `HashMap`
+    /// ### What it does
+    /// Checks for uses of `contains_key` + `insert` on `HashMap`
     /// or `BTreeMap`.
     ///
-    /// **Why is this bad?** Using `entry` is more efficient.
+    /// ### Why is this bad?
+    /// Using `entry` is more efficient.
     ///
-    /// **Known problems:** The suggestion may have type inference errors in some cases. e.g.
+    /// ### Known problems
+    /// The suggestion may have type inference errors in some cases. e.g.
     /// ```rust
     /// let mut map = std::collections::HashMap::new();
     /// let _ = if !map.contains_key(&0) {
@@ -31,7 +34,7 @@ declare_clippy_lint! {
     /// };
     /// ```
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// # use std::collections::HashMap;
     /// # let mut map = HashMap::new();
diff --git a/clippy_lints/src/enum_clike.rs b/clippy_lints/src/enum_clike.rs
index 021136ac5e0..a2c3c7a7b49 100644
--- a/clippy_lints/src/enum_clike.rs
+++ b/clippy_lints/src/enum_clike.rs
@@ -11,15 +11,15 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use std::convert::TryFrom;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for C-like enumerations that are
+    /// ### What it does
+    /// Checks for C-like enumerations that are
     /// `repr(isize/usize)` and have values that don't fit into an `i32`.
     ///
-    /// **Why is this bad?** This will truncate the variant value on 32 bit
+    /// ### Why is this bad?
+    /// This will truncate the variant value on 32 bit
     /// architectures, but works fine on 64 bit.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// # #[cfg(target_pointer_width = "64")]
     /// #[repr(usize)]
diff --git a/clippy_lints/src/enum_variants.rs b/clippy_lints/src/enum_variants.rs
index b1a105a51c1..32b95745b64 100644
--- a/clippy_lints/src/enum_variants.rs
+++ b/clippy_lints/src/enum_variants.rs
@@ -10,15 +10,15 @@ use rustc_span::source_map::Span;
 use rustc_span::symbol::Symbol;
 
 declare_clippy_lint! {
-    /// **What it does:** Detects enumeration variants that are prefixed or suffixed
+    /// ### What it does
+    /// Detects enumeration variants that are prefixed or suffixed
     /// by the same characters.
     ///
-    /// **Why is this bad?** Enumeration variant names should specify their variant,
+    /// ### Why is this bad?
+    /// Enumeration variant names should specify their variant,
     /// not repeat the enumeration name.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// enum Cake {
     ///     BlackForestCake,
@@ -40,14 +40,14 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Detects type names that are prefixed or suffixed by the
+    /// ### What it does
+    /// Detects type names that are prefixed or suffixed by the
     /// containing module's name.
     ///
-    /// **Why is this bad?** It requires the user to type the module name twice.
-    ///
-    /// **Known problems:** None.
+    /// ### Why is this bad?
+    /// It requires the user to type the module name twice.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// mod cake {
     ///     struct BlackForestCake;
@@ -65,10 +65,12 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for modules that have the same name as their
+    /// ### What it does
+    /// Checks for modules that have the same name as their
     /// parent module
     ///
-    /// **Why is this bad?** A typical beginner mistake is to have `mod foo;` and
+    /// ### Why is this bad?
+    /// A typical beginner mistake is to have `mod foo;` and
     /// again `mod foo { ..
     /// }` in `foo.rs`.
     /// The expectation is that items inside the inner `mod foo { .. }` are then
@@ -78,9 +80,7 @@ declare_clippy_lint! {
     /// If this is done on purpose, it would be better to choose a more
     /// representative module name.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```ignore
     /// // lib.rs
     /// mod foo;
diff --git a/clippy_lints/src/eq_op.rs b/clippy_lints/src/eq_op.rs
index d39cabfb282..51d5094e8c9 100644
--- a/clippy_lints/src/eq_op.rs
+++ b/clippy_lints/src/eq_op.rs
@@ -9,18 +9,21 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for equal operands to comparison, logical and
+    /// ### What it does
+    /// Checks for equal operands to comparison, logical and
     /// bitwise, difference and division binary operators (`==`, `>`, etc., `&&`,
     /// `||`, `&`, `|`, `^`, `-` and `/`).
     ///
-    /// **Why is this bad?** This is usually just a typo or a copy and paste error.
+    /// ### Why is this bad?
+    /// This is usually just a typo or a copy and paste error.
     ///
-    /// **Known problems:** False negatives: We had some false positives regarding
+    /// ### Known problems
+    /// False negatives: We had some false positives regarding
     /// calls (notably [racer](https://github.com/phildawes/racer) had one instance
     /// of `x.pop() && x.pop()`), so we removed matching any function or method
     /// calls. We may introduce a list of known pure functions in the future.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// # let x = 1;
     /// if x + 1 == x + 1 {}
@@ -37,15 +40,18 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for arguments to `==` which have their address
+    /// ### What it does
+    /// Checks for arguments to `==` which have their address
     /// taken to satisfy a bound
     /// and suggests to dereference the other argument instead
     ///
-    /// **Why is this bad?** It is more idiomatic to dereference the other argument.
+    /// ### Why is this bad?
+    /// It is more idiomatic to dereference the other argument.
     ///
-    /// **Known problems:** None
+    /// ### Known problems
+    /// None
     ///
-    /// **Example:**
+    /// ### Example
     /// ```ignore
     /// // Bad
     /// &x == y
diff --git a/clippy_lints/src/erasing_op.rs b/clippy_lints/src/erasing_op.rs
index 4aa9c25b1b0..026d14d0ea2 100644
--- a/clippy_lints/src/erasing_op.rs
+++ b/clippy_lints/src/erasing_op.rs
@@ -6,15 +6,15 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for erasing operations, e.g., `x * 0`.
+    /// ### What it does
+    /// Checks for erasing operations, e.g., `x * 0`.
     ///
-    /// **Why is this bad?** The whole expression can be replaced by zero.
+    /// ### Why is this bad?
+    /// The whole expression can be replaced by zero.
     /// This is most likely not the intended outcome and should probably be
     /// corrected
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// let x = 1;
     /// 0 / x;
diff --git a/clippy_lints/src/escape.rs b/clippy_lints/src/escape.rs
index 5f400d079da..8b0e9e6bc9b 100644
--- a/clippy_lints/src/escape.rs
+++ b/clippy_lints/src/escape.rs
@@ -19,16 +19,16 @@ pub struct BoxedLocal {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for usage of `Box<T>` where an unboxed `T` would
+    /// ### What it does
+    /// Checks for usage of `Box<T>` where an unboxed `T` would
     /// work fine.
     ///
-    /// **Why is this bad?** This is an unnecessary allocation, and bad for
+    /// ### Why is this bad?
+    /// This is an unnecessary allocation, and bad for
     /// performance. It is only necessary to allocate if you wish to move the box
     /// into something.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// # fn foo(bar: usize) {}
     /// // Bad
diff --git a/clippy_lints/src/eta_reduction.rs b/clippy_lints/src/eta_reduction.rs
index 667eb8eb283..192b69e18f9 100644
--- a/clippy_lints/src/eta_reduction.rs
+++ b/clippy_lints/src/eta_reduction.rs
@@ -14,19 +14,22 @@ use rustc_middle::ty::{self, ClosureKind, Ty};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for closures which just call another function where
+    /// ### What it does
+    /// Checks for closures which just call another function where
     /// the function can be called directly. `unsafe` functions or calls where types
     /// get adjusted are ignored.
     ///
-    /// **Why is this bad?** Needlessly creating a closure adds code for no benefit
+    /// ### Why is this bad?
+    /// Needlessly creating a closure adds code for no benefit
     /// and gives the optimizer more work.
     ///
-    /// **Known problems:** If creating the closure inside the closure has a side-
+    /// ### Known problems
+    /// If creating the closure inside the closure has a side-
     /// effect then moving the closure creation out will change when that side-
     /// effect runs.
     /// See [#1439](https://github.com/rust-lang/rust-clippy/issues/1439) for more details.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust,ignore
     /// // Bad
     /// xs.map(|x| foo(x))
@@ -42,17 +45,20 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for closures which only invoke a method on the closure
+    /// ### What it does
+    /// Checks for closures which only invoke a method on the closure
     /// argument and can be replaced by referencing the method directly.
     ///
-    /// **Why is this bad?** It's unnecessary to create the closure.
+    /// ### Why is this bad?
+    /// It's unnecessary to create the closure.
     ///
-    /// **Known problems:** [#3071](https://github.com/rust-lang/rust-clippy/issues/3071),
+    /// ### Known problems
+    /// [#3071](https://github.com/rust-lang/rust-clippy/issues/3071),
     /// [#3942](https://github.com/rust-lang/rust-clippy/issues/3942),
     /// [#4002](https://github.com/rust-lang/rust-clippy/issues/4002)
     ///
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust,ignore
     /// Some('a').map(|s| s.to_uppercase());
     /// ```
diff --git a/clippy_lints/src/eval_order_dependence.rs b/clippy_lints/src/eval_order_dependence.rs
index 03a8b40df55..f72a1e446d5 100644
--- a/clippy_lints/src/eval_order_dependence.rs
+++ b/clippy_lints/src/eval_order_dependence.rs
@@ -9,17 +9,20 @@ use rustc_middle::ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for a read and a write to the same variable where
+    /// ### What it does
+    /// Checks for a read and a write to the same variable where
     /// whether the read occurs before or after the write depends on the evaluation
     /// order of sub-expressions.
     ///
-    /// **Why is this bad?** It is often confusing to read. In addition, the
+    /// ### Why is this bad?
+    /// It is often confusing to read. In addition, the
     /// sub-expression evaluation order for Rust is not well documented.
     ///
-    /// **Known problems:** Code which intentionally depends on the evaluation
+    /// ### Known problems
+    /// Code which intentionally depends on the evaluation
     /// order, or which is correct for any evaluation order.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// let mut x = 0;
     ///
@@ -43,16 +46,19 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for diverging calls that are not match arms or
+    /// ### What it does
+    /// Checks for diverging calls that are not match arms or
     /// statements.
     ///
-    /// **Why is this bad?** It is often confusing to read. In addition, the
+    /// ### Why is this bad?
+    /// It is often confusing to read. In addition, the
     /// sub-expression evaluation order for Rust is not well documented.
     ///
-    /// **Known problems:** Someone might want to use `some_bool || panic!()` as a
+    /// ### Known problems
+    /// Someone might want to use `some_bool || panic!()` as a
     /// shorthand.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust,no_run
     /// # fn b() -> bool { true }
     /// # fn c() -> bool { true }
diff --git a/clippy_lints/src/excessive_bools.rs b/clippy_lints/src/excessive_bools.rs
index 4e2dbf005d5..476e6d23f12 100644
--- a/clippy_lints/src/excessive_bools.rs
+++ b/clippy_lints/src/excessive_bools.rs
@@ -8,19 +8,19 @@ use rustc_span::{sym, Span};
 use std::convert::TryInto;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for excessive
+    /// ### What it does
+    /// Checks for excessive
     /// use of bools in structs.
     ///
-    /// **Why is this bad?** Excessive bools in a struct
+    /// ### Why is this bad?
+    /// Excessive bools in a struct
     /// is often a sign that it's used as a state machine,
     /// which is much better implemented as an enum.
     /// If it's not the case, excessive bools usually benefit
     /// from refactoring into two-variant enums for better
     /// readability and API.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// Bad:
     /// ```rust
     /// struct S {
@@ -44,19 +44,19 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for excessive use of
+    /// ### What it does
+    /// Checks for excessive use of
     /// bools in function definitions.
     ///
-    /// **Why is this bad?** Calls to such functions
+    /// ### Why is this bad?
+    /// Calls to such functions
     /// are confusing and error prone, because it's
     /// hard to remember argument order and you have
     /// no type system support to back you up. Using
     /// two-variant enums instead of bools often makes
     /// API easier to use.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// Bad:
     /// ```rust,ignore
     /// fn f(is_round: bool, is_hot: bool) { ... }
diff --git a/clippy_lints/src/exhaustive_items.rs b/clippy_lints/src/exhaustive_items.rs
index 60ad2e8ee14..e00126046c0 100644
--- a/clippy_lints/src/exhaustive_items.rs
+++ b/clippy_lints/src/exhaustive_items.rs
@@ -8,16 +8,15 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::sym;
 
 declare_clippy_lint! {
-    /// **What it does:** Warns on any exported `enum`s that are not tagged `#[non_exhaustive]`
+    /// ### What it does
+    /// Warns on any exported `enum`s that are not tagged `#[non_exhaustive]`
     ///
-    /// **Why is this bad?** Exhaustive enums are typically fine, but a project which does
+    /// ### Why is this bad?
+    /// Exhaustive enums are typically fine, but a project which does
     /// not wish to make a stability commitment around exported enums may wish to
     /// disable them by default.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust
     /// enum Foo {
     ///     Bar,
@@ -38,16 +37,15 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Warns on any exported `structs`s that are not tagged `#[non_exhaustive]`
+    /// ### What it does
+    /// Warns on any exported `structs`s that are not tagged `#[non_exhaustive]`
     ///
-    /// **Why is this bad?** Exhaustive structs are typically fine, but a project which does
+    /// ### Why is this bad?
+    /// Exhaustive structs are typically fine, but a project which does
     /// not wish to make a stability commitment around exported structs may wish to
     /// disable them by default.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust
     /// struct Foo {
     ///     bar: u8,
diff --git a/clippy_lints/src/exit.rs b/clippy_lints/src/exit.rs
index 16246e548b6..9cd5b2d9f44 100644
--- a/clippy_lints/src/exit.rs
+++ b/clippy_lints/src/exit.rs
@@ -6,15 +6,15 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
-    /// **What it does:** `exit()`  terminates the program and doesn't provide a
+    /// ### What it does
+    /// `exit()`  terminates the program and doesn't provide a
     /// stack trace.
     ///
-    /// **Why is this bad?** Ideally a program is terminated by finishing
+    /// ### Why is this bad?
+    /// Ideally a program is terminated by finishing
     /// the main function.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```ignore
     /// std::process::exit(0)
     /// ```
diff --git a/clippy_lints/src/explicit_write.rs b/clippy_lints/src/explicit_write.rs
index 66724294804..4f46ef906f4 100644
--- a/clippy_lints/src/explicit_write.rs
+++ b/clippy_lints/src/explicit_write.rs
@@ -9,14 +9,14 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::sym;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for usage of `write!()` / `writeln()!` which can be
+    /// ### What it does
+    /// Checks for usage of `write!()` / `writeln()!` which can be
     /// replaced with `(e)print!()` / `(e)println!()`
     ///
-    /// **Why is this bad?** Using `(e)println! is clearer and more concise
+    /// ### Why is this bad?
+    /// Using `(e)println! is clearer and more concise
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// # use std::io::Write;
     /// # let bar = "furchtbar";
diff --git a/clippy_lints/src/fallible_impl_from.rs b/clippy_lints/src/fallible_impl_from.rs
index 2937fcb9ca0..7e4d1b3ef9f 100644
--- a/clippy_lints/src/fallible_impl_from.rs
+++ b/clippy_lints/src/fallible_impl_from.rs
@@ -10,13 +10,13 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::{sym, Span};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for impls of `From<..>` that contain `panic!()` or `unwrap()`
+    /// ### What it does
+    /// Checks for impls of `From<..>` that contain `panic!()` or `unwrap()`
     ///
-    /// **Why is this bad?** `TryFrom` should be used if there's a possibility of failure.
+    /// ### Why is this bad?
+    /// `TryFrom` should be used if there's a possibility of failure.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// struct Foo(i32);
     ///
diff --git a/clippy_lints/src/float_equality_without_abs.rs b/clippy_lints/src/float_equality_without_abs.rs
index 1e503cc795c..c33d80b8e8e 100644
--- a/clippy_lints/src/float_equality_without_abs.rs
+++ b/clippy_lints/src/float_equality_without_abs.rs
@@ -11,30 +11,32 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Spanned;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for statements of the form `(a - b) < f32::EPSILON` or
-     /// `(a - b) < f64::EPSILON`. Notes the missing `.abs()`.
-     ///
-     /// **Why is this bad?** The code without `.abs()` is more likely to have a bug.
-     ///
-     /// **Known problems:** If the user can ensure that b is larger than a, the `.abs()` is
-     /// technically unneccessary. However, it will make the code more robust and doesn't have any
-     /// large performance implications. If the abs call was deliberately left out for performance
-     /// reasons, it is probably better to state this explicitly in the code, which then can be done
-     /// with an allow.
-     ///
-     /// **Example:**
-     ///
-     /// ```rust
-     /// pub fn is_roughly_equal(a: f32, b: f32) -> bool {
-     ///     (a - b) < f32::EPSILON
-     /// }
-     /// ```
-     /// Use instead:
-     /// ```rust
-     /// pub fn is_roughly_equal(a: f32, b: f32) -> bool {
-     ///     (a - b).abs() < f32::EPSILON
-     /// }
-     /// ```
+    /// ### What it does
+    /// Checks for statements of the form `(a - b) < f32::EPSILON` or
+    /// `(a - b) < f64::EPSILON`. Notes the missing `.abs()`.
+    ///
+    /// ### Why is this bad?
+    /// The code without `.abs()` is more likely to have a bug.
+    ///
+    /// ### Known problems
+    /// If the user can ensure that b is larger than a, the `.abs()` is
+    /// technically unneccessary. However, it will make the code more robust and doesn't have any
+    /// large performance implications. If the abs call was deliberately left out for performance
+    /// reasons, it is probably better to state this explicitly in the code, which then can be done
+    /// with an allow.
+    ///
+    /// ### Example
+    /// ```rust
+    /// pub fn is_roughly_equal(a: f32, b: f32) -> bool {
+    ///     (a - b) < f32::EPSILON
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// pub fn is_roughly_equal(a: f32, b: f32) -> bool {
+    ///     (a - b).abs() < f32::EPSILON
+    /// }
+    /// ```
     pub FLOAT_EQUALITY_WITHOUT_ABS,
     suspicious,
     "float equality check without `.abs()`"
diff --git a/clippy_lints/src/float_literal.rs b/clippy_lints/src/float_literal.rs
index 7968e7b764d..a3d70f31f00 100644
--- a/clippy_lints/src/float_literal.rs
+++ b/clippy_lints/src/float_literal.rs
@@ -10,15 +10,14 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use std::fmt;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for float literals with a precision greater
+    /// ### What it does
+    /// Checks for float literals with a precision greater
     /// than that supported by the underlying type.
     ///
-    /// **Why is this bad?** Rust will truncate the literal silently.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Why is this bad?
+    /// Rust will truncate the literal silently.
     ///
+    /// ### Example
     /// ```rust
     /// // Bad
     /// let v: f32 = 0.123_456_789_9;
@@ -34,16 +33,15 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for whole number float literals that
+    /// ### What it does
+    /// Checks for whole number float literals that
     /// cannot be represented as the underlying type without loss.
     ///
-    /// **Why is this bad?** Rust will silently lose precision during
+    /// ### Why is this bad?
+    /// Rust will silently lose precision during
     /// conversion to a float.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust
     /// // Bad
     /// let _: f32 = 16_777_217.0; // 16_777_216.0
diff --git a/clippy_lints/src/floating_point_arithmetic.rs b/clippy_lints/src/floating_point_arithmetic.rs
index e38384b01d4..b01c0cdd846 100644
--- a/clippy_lints/src/floating_point_arithmetic.rs
+++ b/clippy_lints/src/floating_point_arithmetic.rs
@@ -18,16 +18,15 @@ use std::f64::consts as f64_consts;
 use sugg::Sugg;
 
 declare_clippy_lint! {
-    /// **What it does:** Looks for floating-point expressions that
+    /// ### What it does
+    /// Looks for floating-point expressions that
     /// can be expressed using built-in methods to improve accuracy
     /// at the cost of performance.
     ///
-    /// **Why is this bad?** Negatively impacts accuracy.
-    ///
-    /// **Known problems:** None
-    ///
-    /// **Example:**
+    /// ### Why is this bad?
+    /// Negatively impacts accuracy.
     ///
+    /// ### Example
     /// ```rust
     /// let a = 3f32;
     /// let _ = a.powf(1.0 / 3.0);
@@ -49,16 +48,15 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Looks for floating-point expressions that
+    /// ### What it does
+    /// Looks for floating-point expressions that
     /// can be expressed using built-in methods to improve both
     /// accuracy and performance.
     ///
-    /// **Why is this bad?** Negatively impacts accuracy and performance.
-    ///
-    /// **Known problems:** None
-    ///
-    /// **Example:**
+    /// ### Why is this bad?
+    /// Negatively impacts accuracy and performance.
     ///
+    /// ### Example
     /// ```rust
     /// use std::f32::consts::E;
     ///
diff --git a/clippy_lints/src/format.rs b/clippy_lints/src/format.rs
index ca3490d8eda..863c606f5a9 100644
--- a/clippy_lints/src/format.rs
+++ b/clippy_lints/src/format.rs
@@ -13,18 +13,18 @@ use rustc_span::symbol::kw;
 use rustc_span::{sym, Span};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for the use of `format!("string literal with no
+    /// ### What it does
+    /// Checks for the use of `format!("string literal with no
     /// argument")` and `format!("{}", foo)` where `foo` is a string.
     ///
-    /// **Why is this bad?** There is no point of doing that. `format!("foo")` can
+    /// ### Why is this bad?
+    /// There is no point of doing that. `format!("foo")` can
     /// be replaced by `"foo".to_owned()` if you really need a `String`. The even
     /// worse `&format!("foo")` is often encountered in the wild. `format!("{}",
     /// foo)` can be replaced by `foo.clone()` if `foo: String` or `foo.to_owned()`
     /// if `foo: &str`.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Examples:**
+    /// ### Examples
     /// ```rust
     ///
     /// // Bad
diff --git a/clippy_lints/src/formatting.rs b/clippy_lints/src/formatting.rs
index 8aefb8d46f6..b4cf1971d78 100644
--- a/clippy_lints/src/formatting.rs
+++ b/clippy_lints/src/formatting.rs
@@ -9,15 +9,15 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for use of the non-existent `=*`, `=!` and `=-`
+    /// ### What it does
+    /// Checks for use of the non-existent `=*`, `=!` and `=-`
     /// operators.
     ///
-    /// **Why is this bad?** This is either a typo of `*=`, `!=` or `-=` or
+    /// ### Why is this bad?
+    /// This is either a typo of `*=`, `!=` or `-=` or
     /// confusing.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust,ignore
     /// a =- 42; // confusing, should it be `a -= 42` or `a = -42`?
     /// ```
@@ -27,15 +27,15 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks the formatting of a unary operator on the right hand side
+    /// ### What it does
+    /// Checks the formatting of a unary operator on the right hand side
     /// of a binary operator. It lints if there is no space between the binary and unary operators,
     /// but there is a space between the unary and its operand.
     ///
-    /// **Why is this bad?** This is either a typo in the binary operator or confusing.
-    ///
-    /// **Known problems:** None.
+    /// ### Why is this bad?
+    /// This is either a typo in the binary operator or confusing.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust,ignore
     /// if foo <- 30 { // this should be `foo < -30` but looks like a different operator
     /// }
@@ -49,15 +49,15 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for formatting of `else`. It lints if the `else`
+    /// ### What it does
+    /// Checks for formatting of `else`. It lints if the `else`
     /// is followed immediately by a newline or the `else` seems to be missing.
     ///
-    /// **Why is this bad?** This is probably some refactoring remnant, even if the
+    /// ### Why is this bad?
+    /// This is probably some refactoring remnant, even if the
     /// code is correct, it might look confusing.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust,ignore
     /// if foo {
     /// } { // looks like an `else` is missing here
@@ -85,14 +85,14 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for possible missing comma in an array. It lints if
+    /// ### What it does
+    /// Checks for possible missing comma in an array. It lints if
     /// an array element is a binary operator expression and it lies on two lines.
     ///
-    /// **Why is this bad?** This could lead to unexpected results.
-    ///
-    /// **Known problems:** None.
+    /// ### Why is this bad?
+    /// This could lead to unexpected results.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust,ignore
     /// let a = &[
     ///     -1, -2, -3 // <= no comma here
diff --git a/clippy_lints/src/from_over_into.rs b/clippy_lints/src/from_over_into.rs
index 48316c3a61d..623546cd1de 100644
--- a/clippy_lints/src/from_over_into.rs
+++ b/clippy_lints/src/from_over_into.rs
@@ -8,14 +8,13 @@ use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::symbol::sym;
 
 declare_clippy_lint! {
-    /// **What it does:** Searches for implementations of the `Into<..>` trait and suggests to implement `From<..>` instead.
+    /// ### What it does
+    /// Searches for implementations of the `Into<..>` trait and suggests to implement `From<..>` instead.
     ///
-    /// **Why is this bad?** According the std docs implementing `From<..>` is preferred since it gives you `Into<..>` for free where the reverse isn't true.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Why is this bad?
+    /// According the std docs implementing `From<..>` is preferred since it gives you `Into<..>` for free where the reverse isn't true.
     ///
+    /// ### Example
     /// ```rust
     /// struct StringWrapper(String);
     ///
diff --git a/clippy_lints/src/from_str_radix_10.rs b/clippy_lints/src/from_str_radix_10.rs
index 3da5bc95b6d..cc4bb85c50f 100644
--- a/clippy_lints/src/from_str_radix_10.rs
+++ b/clippy_lints/src/from_str_radix_10.rs
@@ -10,20 +10,22 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::symbol::sym;
 
 declare_clippy_lint! {
-    /// **What it does:**
+    /// ### What it does
+    ///
     /// Checks for function invocations of the form `primitive::from_str_radix(s, 10)`
     ///
-    /// **Why is this bad?**
+    /// ### Why is this bad?
+    ///
     /// This specific common use case can be rewritten as `s.parse::<primitive>()`
     /// (and in most cases, the turbofish can be removed), which reduces code length
     /// and complexity.
     ///
-    /// **Known problems:**
+    /// ### Known problems
+    ///
     /// This lint may suggest using (&<expression>).parse() instead of <expression>.parse() directly
     /// in some cases, which is correct but adds unnecessary complexity to the code.
     ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```ignore
     /// let input: &str = get_input();
     /// let num = u16::from_str_radix(input, 10)?;
diff --git a/clippy_lints/src/functions/mod.rs b/clippy_lints/src/functions/mod.rs
index 2beb9bc94bf..ce23c0ce4a0 100644
--- a/clippy_lints/src/functions/mod.rs
+++ b/clippy_lints/src/functions/mod.rs
@@ -11,15 +11,15 @@ use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::Span;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for functions with too many parameters.
+    /// ### What it does
+    /// Checks for functions with too many parameters.
     ///
-    /// **Why is this bad?** Functions with lots of parameters are considered bad
+    /// ### Why is this bad?
+    /// Functions with lots of parameters are considered bad
     /// style and reduce readability (“what does the 5th parameter mean?”). Consider
     /// grouping some parameters into a new type.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// # struct Color;
     /// fn foo(x: u32, y: u32, name: &str, c: Color, w: f32, h: f32, a: f32, b: f32) {
@@ -32,16 +32,16 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for functions with a large amount of lines.
+    /// ### What it does
+    /// Checks for functions with a large amount of lines.
     ///
-    /// **Why is this bad?** Functions with a lot of lines are harder to understand
+    /// ### Why is this bad?
+    /// Functions with a lot of lines are harder to understand
     /// due to having to look at a larger amount of code to understand what the
     /// function is doing. Consider splitting the body of the function into
     /// multiple functions.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// fn im_too_long() {
     ///     println!("");
@@ -55,15 +55,16 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for public functions that dereference raw pointer
+    /// ### What it does
+    /// Checks for public functions that dereference raw pointer
     /// arguments but are not marked `unsafe`.
     ///
-    /// **Why is this bad?** The function should probably be marked `unsafe`, since
+    /// ### Why is this bad?
+    /// The function should probably be marked `unsafe`, since
     /// for an arbitrary raw pointer, there is no way of telling for sure if it is
     /// valid.
     ///
-    /// **Known problems:**
-    ///
+    /// ### Known problems
     /// * It does not check functions recursively so if the pointer is passed to a
     /// private non-`unsafe` function which does the dereferencing, the lint won't
     /// trigger.
@@ -71,7 +72,7 @@ declare_clippy_lint! {
     /// got from an argument in some other way (`fn foo(bar: &[*const u8])` or
     /// `some_argument.get_raw_ptr()`).
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust,ignore
     /// // Bad
     /// pub fn foo(x: *const u8) {
@@ -89,17 +90,17 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for a [`#[must_use]`] attribute on
+    /// ### What it does
+    /// Checks for a [`#[must_use]`] attribute on
     /// unit-returning functions and methods.
     ///
     /// [`#[must_use]`]: https://doc.rust-lang.org/reference/attributes/diagnostics.html#the-must_use-attribute
     ///
-    /// **Why is this bad?** Unit values are useless. The attribute is likely
+    /// ### Why is this bad?
+    /// Unit values are useless. The attribute is likely
     /// a remnant of a refactoring that removed the return type.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Examples:**
+    /// ### Examples
     /// ```rust
     /// #[must_use]
     /// fn useless() { }
@@ -110,19 +111,19 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for a [`#[must_use]`] attribute without
+    /// ### What it does
+    /// Checks for a [`#[must_use]`] attribute without
     /// further information on functions and methods that return a type already
     /// marked as `#[must_use]`.
     ///
     /// [`#[must_use]`]: https://doc.rust-lang.org/reference/attributes/diagnostics.html#the-must_use-attribute
     ///
-    /// **Why is this bad?** The attribute isn't needed. Not using the result
+    /// ### Why is this bad?
+    /// The attribute isn't needed. Not using the result
     /// will already be reported. Alternatively, one can add some text to the
     /// attribute to improve the lint message.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Examples:**
+    /// ### Examples
     /// ```rust
     /// #[must_use]
     /// fn double_must_use() -> Result<(), ()> {
@@ -135,16 +136,19 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for public functions that have no
+    /// ### What it does
+    /// Checks for public functions that have no
     /// [`#[must_use]`] attribute, but return something not already marked
     /// must-use, have no mutable arg and mutate no statics.
     ///
     /// [`#[must_use]`]: https://doc.rust-lang.org/reference/attributes/diagnostics.html#the-must_use-attribute
     ///
-    /// **Why is this bad?** Not bad at all, this lint just shows places where
+    /// ### Why is this bad?
+    /// Not bad at all, this lint just shows places where
     /// you could add the attribute.
     ///
-    /// **Known problems:** The lint only checks the arguments for mutable
+    /// ### Known problems
+    /// The lint only checks the arguments for mutable
     /// types without looking if they are actually changed. On the other hand,
     /// it also ignores a broad range of potentially interesting side effects,
     /// because we cannot decide whether the programmer intends the function to
@@ -152,7 +156,7 @@ declare_clippy_lint! {
     /// positives. At least we don't lint if the result type is unit or already
     /// `#[must_use]`.
     ///
-    /// **Examples:**
+    /// ### Examples
     /// ```rust
     /// // this could be annotated with `#[must_use]`.
     /// fn id<T>(t: T) -> T { t }
@@ -163,20 +167,23 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for public functions that return a `Result`
+    /// ### What it does
+    /// Checks for public functions that return a `Result`
     /// with an `Err` type of `()`. It suggests using a custom type that
     /// implements `std::error::Error`.
     ///
-    /// **Why is this bad?** Unit does not implement `Error` and carries no
+    /// ### Why is this bad?
+    /// Unit does not implement `Error` and carries no
     /// further information about what went wrong.
     ///
-    /// **Known problems:** Of course, this lint assumes that `Result` is used
+    /// ### Known problems
+    /// Of course, this lint assumes that `Result` is used
     /// for a fallible operation (which is after all the intended use). However
     /// code may opt to (mis)use it as a basic two-variant-enum. In that case,
     /// the suggestion is misguided, and the code should use a custom enum
     /// instead.
     ///
-    /// **Examples:**
+    /// ### Examples
     /// ```rust
     /// pub fn read_u8() -> Result<u8, ()> { Err(()) }
     /// ```
diff --git a/clippy_lints/src/future_not_send.rs b/clippy_lints/src/future_not_send.rs
index 515b8887453..0be03969bcb 100644
--- a/clippy_lints/src/future_not_send.rs
+++ b/clippy_lints/src/future_not_send.rs
@@ -12,12 +12,14 @@ use rustc_trait_selection::traits::error_reporting::suggestions::InferCtxtExt;
 use rustc_trait_selection::traits::{self, FulfillmentError, TraitEngine};
 
 declare_clippy_lint! {
-    /// **What it does:** This lint requires Future implementations returned from
+    /// ### What it does
+    /// This lint requires Future implementations returned from
     /// functions and methods to implement the `Send` marker trait. It is mostly
     /// used by library authors (public and internal) that target an audience where
     /// multithreaded executors are likely to be used for running these Futures.
     ///
-    /// **Why is this bad?** A Future implementation captures some state that it
+    /// ### Why is this bad?
+    /// A Future implementation captures some state that it
     /// needs to eventually produce its final value. When targeting a multithreaded
     /// executor (which is the norm on non-embedded devices) this means that this
     /// state may need to be transported to other threads, in other words the
@@ -31,10 +33,7 @@ declare_clippy_lint! {
     /// modifying the library where the offending Future implementation is
     /// produced.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust
     /// async fn not_send(bytes: std::rc::Rc<[u8]>) {}
     /// ```
diff --git a/clippy_lints/src/get_last_with_len.rs b/clippy_lints/src/get_last_with_len.rs
index 8e45fdfecc4..ced35030de8 100644
--- a/clippy_lints/src/get_last_with_len.rs
+++ b/clippy_lints/src/get_last_with_len.rs
@@ -14,10 +14,12 @@ use rustc_span::source_map::Spanned;
 use rustc_span::sym;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for using `x.get(x.len() - 1)` instead of
+    /// ### What it does
+    /// Checks for using `x.get(x.len() - 1)` instead of
     /// `x.last()`.
     ///
-    /// **Why is this bad?** Using `x.last()` is easier to read and has the same
+    /// ### Why is this bad?
+    /// Using `x.last()` is easier to read and has the same
     /// result.
     ///
     /// Note that using `x[x.len() - 1]` is semantically different from
@@ -27,10 +29,7 @@ declare_clippy_lint! {
     /// There is another lint (get_unwrap) that covers the case of using
     /// `x.get(index).unwrap()` instead of `x[index]`.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust
     /// // Bad
     /// let x = vec![2, 3, 5];
diff --git a/clippy_lints/src/identity_op.rs b/clippy_lints/src/identity_op.rs
index 99c461930e4..5feb0ce8dec 100644
--- a/clippy_lints/src/identity_op.rs
+++ b/clippy_lints/src/identity_op.rs
@@ -11,14 +11,14 @@ use clippy_utils::diagnostics::span_lint;
 use clippy_utils::{clip, unsext};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for identity operations, e.g., `x + 0`.
+    /// ### What it does
+    /// Checks for identity operations, e.g., `x + 0`.
     ///
-    /// **Why is this bad?** This code can be removed without changing the
+    /// ### Why is this bad?
+    /// This code can be removed without changing the
     /// meaning. So it just obscures what's going on. Delete it mercilessly.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// # let x = 1;
     /// x / 1 + 0 * 1 - 0 | 0;
diff --git a/clippy_lints/src/if_let_mutex.rs b/clippy_lints/src/if_let_mutex.rs
index 5403d76ea30..d3ddeda9fd1 100644
--- a/clippy_lints/src/if_let_mutex.rs
+++ b/clippy_lints/src/if_let_mutex.rs
@@ -9,16 +9,15 @@ use rustc_middle::hir::map::Map;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for `Mutex::lock` calls in `if let` expression
+    /// ### What it does
+    /// Checks for `Mutex::lock` calls in `if let` expression
     /// with lock calls in any of the else blocks.
     ///
-    /// **Why is this bad?** The Mutex lock remains held for the whole
+    /// ### Why is this bad?
+    /// The Mutex lock remains held for the whole
     /// `if let ... else` block and deadlocks.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust,ignore
     /// if let Ok(thing) = mutex.lock() {
     ///     do_thing();
diff --git a/clippy_lints/src/if_let_some_result.rs b/clippy_lints/src/if_let_some_result.rs
index 611da3744ee..587307811a1 100644
--- a/clippy_lints/src/if_let_some_result.rs
+++ b/clippy_lints/src/if_let_some_result.rs
@@ -10,14 +10,14 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::sym;
 
 declare_clippy_lint! {
-    /// **What it does:*** Checks for unnecessary `ok()` in if let.
+    /// ### What it does
+    ///* Checks for unnecessary `ok()` in if let.
     ///
-    /// **Why is this bad?** Calling `ok()` in if let is unnecessary, instead match
+    /// ### Why is this bad?
+    /// Calling `ok()` in if let is unnecessary, instead match
     /// on `Ok(pat)`
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```ignore
     /// for i in iter {
     ///     if let Some(value) = i.parse().ok() {
diff --git a/clippy_lints/src/if_not_else.rs b/clippy_lints/src/if_not_else.rs
index c56f67df061..28db7233d70 100644
--- a/clippy_lints/src/if_not_else.rs
+++ b/clippy_lints/src/if_not_else.rs
@@ -8,14 +8,14 @@ use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for usage of `!` or `!=` in an if condition with an
+    /// ### What it does
+    /// Checks for usage of `!` or `!=` in an if condition with an
     /// else branch.
     ///
-    /// **Why is this bad?** Negations reduce the readability of statements.
+    /// ### Why is this bad?
+    /// Negations reduce the readability of statements.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// # let v: Vec<usize> = vec![];
     /// # fn a() {}
diff --git a/clippy_lints/src/if_then_some_else_none.rs b/clippy_lints/src/if_then_some_else_none.rs
index eadcd0867a8..17b9a2f888e 100644
--- a/clippy_lints/src/if_then_some_else_none.rs
+++ b/clippy_lints/src/if_then_some_else_none.rs
@@ -10,14 +10,13 @@ use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for if-else that could be written to `bool::then`.
+    /// ### What it does
+    /// Checks for if-else that could be written to `bool::then`.
     ///
-    /// **Why is this bad?** Looks a little redundant. Using `bool::then` helps it have less lines of code.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Why is this bad?
+    /// Looks a little redundant. Using `bool::then` helps it have less lines of code.
     ///
+    /// ### Example
     /// ```rust
     /// # let v = vec![0];
     /// let a = if v.is_empty() {
diff --git a/clippy_lints/src/implicit_hasher.rs b/clippy_lints/src/implicit_hasher.rs
index 879d6a75bbe..aae44f64e66 100644
--- a/clippy_lints/src/implicit_hasher.rs
+++ b/clippy_lints/src/implicit_hasher.rs
@@ -22,18 +22,21 @@ use clippy_utils::source::{snippet, snippet_opt};
 use clippy_utils::ty::is_type_diagnostic_item;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for public `impl` or `fn` missing generalization
+    /// ### What it does
+    /// Checks for public `impl` or `fn` missing generalization
     /// over different hashers and implicitly defaulting to the default hashing
     /// algorithm (`SipHash`).
     ///
-    /// **Why is this bad?** `HashMap` or `HashSet` with custom hashers cannot be
+    /// ### Why is this bad?
+    /// `HashMap` or `HashSet` with custom hashers cannot be
     /// used with them.
     ///
-    /// **Known problems:** Suggestions for replacing constructors can contain
+    /// ### Known problems
+    /// Suggestions for replacing constructors can contain
     /// false-positives. Also applying suggestions can require modification of other
     /// pieces of code, possibly including external crates.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// # use std::collections::HashMap;
     /// # use std::hash::{Hash, BuildHasher};
diff --git a/clippy_lints/src/implicit_return.rs b/clippy_lints/src/implicit_return.rs
index f2f830ca5c0..fa7b5302cb1 100644
--- a/clippy_lints/src/implicit_return.rs
+++ b/clippy_lints/src/implicit_return.rs
@@ -13,17 +13,17 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::{Span, SyntaxContext};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for missing return statements at the end of a block.
+    /// ### What it does
+    /// Checks for missing return statements at the end of a block.
     ///
-    /// **Why is this bad?** Actually omitting the return keyword is idiomatic Rust code. Programmers
+    /// ### Why is this bad?
+    /// Actually omitting the return keyword is idiomatic Rust code. Programmers
     /// coming from other languages might prefer the expressiveness of `return`. It's possible to miss
     /// the last returning statement because the only difference is a missing `;`. Especially in bigger
     /// code with multiple return paths having a `return` keyword makes it easier to find the
     /// corresponding statements.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// fn foo(x: usize) -> usize {
     ///     x
diff --git a/clippy_lints/src/implicit_saturating_sub.rs b/clippy_lints/src/implicit_saturating_sub.rs
index 4069a685ea0..0a7d31dce2f 100644
--- a/clippy_lints/src/implicit_saturating_sub.rs
+++ b/clippy_lints/src/implicit_saturating_sub.rs
@@ -8,14 +8,13 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for implicit saturating subtraction.
+    /// ### What it does
+    /// Checks for implicit saturating subtraction.
     ///
-    /// **Why is this bad?** Simplicity and readability. Instead we can easily use an builtin function.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Why is this bad?
+    /// Simplicity and readability. Instead we can easily use an builtin function.
     ///
+    /// ### Example
     /// ```rust
     /// let end: u32 = 10;
     /// let start: u32 = 5;
diff --git a/clippy_lints/src/inconsistent_struct_constructor.rs b/clippy_lints/src/inconsistent_struct_constructor.rs
index 3b635071f28..1f8240a1f63 100644
--- a/clippy_lints/src/inconsistent_struct_constructor.rs
+++ b/clippy_lints/src/inconsistent_struct_constructor.rs
@@ -10,11 +10,13 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::symbol::Symbol;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for struct constructors where all fields are shorthand and
+    /// ### What it does
+    /// Checks for struct constructors where all fields are shorthand and
     /// the order of the field init shorthand in the constructor is inconsistent
     /// with the order in the struct definition.
     ///
-    /// **Why is this bad?** Since the order of fields in a constructor doesn't affect the
+    /// ### Why is this bad?
+    /// Since the order of fields in a constructor doesn't affect the
     /// resulted instance as the below example indicates,
     ///
     /// ```rust
@@ -32,10 +34,7 @@ declare_clippy_lint! {
     ///
     /// inconsistent order can be confusing and decreases readability and consistency.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust
     /// struct Foo {
     ///     x: i32,
diff --git a/clippy_lints/src/indexing_slicing.rs b/clippy_lints/src/indexing_slicing.rs
index bfa284f333a..8c1f1073309 100644
--- a/clippy_lints/src/indexing_slicing.rs
+++ b/clippy_lints/src/indexing_slicing.rs
@@ -10,14 +10,17 @@ use rustc_middle::ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for out of bounds array indexing with a constant
+    /// ### What it does
+    /// Checks for out of bounds array indexing with a constant
     /// index.
     ///
-    /// **Why is this bad?** This will always panic at runtime.
+    /// ### Why is this bad?
+    /// This will always panic at runtime.
     ///
-    /// **Known problems:** Hopefully none.
+    /// ### Known problems
+    /// Hopefully none.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```no_run
     /// # #![allow(const_err)]
     /// let x = [1, 2, 3, 4];
@@ -36,16 +39,19 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for usage of indexing or slicing. Arrays are special cases, this lint
+    /// ### What it does
+    /// Checks for usage of indexing or slicing. Arrays are special cases, this lint
     /// does report on arrays if we can tell that slicing operations are in bounds and does not
     /// lint on constant `usize` indexing on arrays because that is handled by rustc's `const_err` lint.
     ///
-    /// **Why is this bad?** Indexing and slicing can panic at runtime and there are
+    /// ### Why is this bad?
+    /// Indexing and slicing can panic at runtime and there are
     /// safe alternatives.
     ///
-    /// **Known problems:** Hopefully none.
+    /// ### Known problems
+    /// Hopefully none.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust,no_run
     /// // Vector
     /// let x = vec![0; 5];
diff --git a/clippy_lints/src/infinite_iter.rs b/clippy_lints/src/infinite_iter.rs
index 295a4e1fccb..2411a3175b9 100644
--- a/clippy_lints/src/infinite_iter.rs
+++ b/clippy_lints/src/infinite_iter.rs
@@ -7,14 +7,14 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::symbol::{sym, Symbol};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for iteration that is guaranteed to be infinite.
+    /// ### What it does
+    /// Checks for iteration that is guaranteed to be infinite.
     ///
-    /// **Why is this bad?** While there may be places where this is acceptable
+    /// ### Why is this bad?
+    /// While there may be places where this is acceptable
     /// (e.g., in event streams), in most cases this is simply an error.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```no_run
     /// use std::iter;
     ///
@@ -26,15 +26,18 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for iteration that may be infinite.
+    /// ### What it does
+    /// Checks for iteration that may be infinite.
     ///
-    /// **Why is this bad?** While there may be places where this is acceptable
+    /// ### Why is this bad?
+    /// While there may be places where this is acceptable
     /// (e.g., in event streams), in most cases this is simply an error.
     ///
-    /// **Known problems:** The code may have a condition to stop iteration, but
+    /// ### Known problems
+    /// The code may have a condition to stop iteration, but
     /// this lint is not clever enough to analyze it.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// let infinite_iter = 0..;
     /// [0..].iter().zip(infinite_iter.take_while(|x| *x > 5));
diff --git a/clippy_lints/src/inherent_impl.rs b/clippy_lints/src/inherent_impl.rs
index 9641784eb9a..d87055c842c 100644
--- a/clippy_lints/src/inherent_impl.rs
+++ b/clippy_lints/src/inherent_impl.rs
@@ -10,13 +10,13 @@ use rustc_span::Span;
 use std::collections::hash_map::Entry;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for multiple inherent implementations of a struct
+    /// ### What it does
+    /// Checks for multiple inherent implementations of a struct
     ///
-    /// **Why is this bad?** Splitting the implementation of a type makes the code harder to navigate.
+    /// ### Why is this bad?
+    /// Splitting the implementation of a type makes the code harder to navigate.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// struct X;
     /// impl X {
diff --git a/clippy_lints/src/inherent_to_string.rs b/clippy_lints/src/inherent_to_string.rs
index b023e13e846..b62fad4bd39 100644
--- a/clippy_lints/src/inherent_to_string.rs
+++ b/clippy_lints/src/inherent_to_string.rs
@@ -8,14 +8,16 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::sym;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for the definition of inherent methods with a signature of `to_string(&self) -> String`.
+    /// ### What it does
+    /// Checks for the definition of inherent methods with a signature of `to_string(&self) -> String`.
     ///
-    /// **Why is this bad?** This method is also implicitly defined if a type implements the `Display` trait. As the functionality of `Display` is much more versatile, it should be preferred.
+    /// ### Why is this bad?
+    /// This method is also implicitly defined if a type implements the `Display` trait. As the functionality of `Display` is much more versatile, it should be preferred.
     ///
-    /// **Known problems:** None
-    ///
-    /// ** Example:**
+    /// ### Known problems
+    /// None
     ///
+    /// ### Example
     /// ```rust
     /// // Bad
     /// pub struct A;
@@ -45,14 +47,16 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for the definition of inherent methods with a signature of `to_string(&self) -> String` and if the type implementing this method also implements the `Display` trait.
-    ///
-    /// **Why is this bad?** This method is also implicitly defined if a type implements the `Display` trait. The less versatile inherent method will then shadow the implementation introduced by `Display`.
+    /// ### What it does
+    /// Checks for the definition of inherent methods with a signature of `to_string(&self) -> String` and if the type implementing this method also implements the `Display` trait.
     ///
-    /// **Known problems:** None
+    /// ### Why is this bad?
+    /// This method is also implicitly defined if a type implements the `Display` trait. The less versatile inherent method will then shadow the implementation introduced by `Display`.
     ///
-    /// ** Example:**
+    /// ### Known problems
+    /// None
     ///
+    /// ### Example
     /// ```rust
     /// // Bad
     /// use std::fmt;
diff --git a/clippy_lints/src/inline_fn_without_body.rs b/clippy_lints/src/inline_fn_without_body.rs
index 20f00bd51ba..3e3df903f17 100644
--- a/clippy_lints/src/inline_fn_without_body.rs
+++ b/clippy_lints/src/inline_fn_without_body.rs
@@ -10,14 +10,14 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::{sym, Symbol};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for `#[inline]` on trait methods without bodies
+    /// ### What it does
+    /// Checks for `#[inline]` on trait methods without bodies
     ///
-    /// **Why is this bad?** Only implementations of trait methods may be inlined.
+    /// ### Why is this bad?
+    /// Only implementations of trait methods may be inlined.
     /// The inline attribute is ignored for trait methods without bodies.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// trait Animal {
     ///     #[inline]
diff --git a/clippy_lints/src/int_plus_one.rs b/clippy_lints/src/int_plus_one.rs
index c4a1222b51f..49b69dd072a 100644
--- a/clippy_lints/src/int_plus_one.rs
+++ b/clippy_lints/src/int_plus_one.rs
@@ -8,13 +8,13 @@ use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for usage of `x >= y + 1` or `x - 1 >= y` (and `<=`) in a block
+    /// ### What it does
+    /// Checks for usage of `x >= y + 1` or `x - 1 >= y` (and `<=`) in a block
     ///
-    /// **Why is this bad?** Readability -- better to use `> y` instead of `>= y + 1`.
+    /// ### Why is this bad?
+    /// Readability -- better to use `> y` instead of `>= y + 1`.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// # let x = 1;
     /// # let y = 1;
diff --git a/clippy_lints/src/integer_division.rs b/clippy_lints/src/integer_division.rs
index e5482f675e7..a0e6f12b812 100644
--- a/clippy_lints/src/integer_division.rs
+++ b/clippy_lints/src/integer_division.rs
@@ -5,15 +5,15 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for division of integers
+    /// ### What it does
+    /// Checks for division of integers
     ///
-    /// **Why is this bad?** When outside of some very specific algorithms,
+    /// ### Why is this bad?
+    /// When outside of some very specific algorithms,
     /// integer division is very often a mistake because it discards the
     /// remainder.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// // Bad
     /// let x = 3 / 2;
diff --git a/clippy_lints/src/invalid_upcast_comparisons.rs b/clippy_lints/src/invalid_upcast_comparisons.rs
index 37011f5578d..3b28b121204 100644
--- a/clippy_lints/src/invalid_upcast_comparisons.rs
+++ b/clippy_lints/src/invalid_upcast_comparisons.rs
@@ -14,18 +14,20 @@ use clippy_utils::source::snippet;
 use clippy_utils::{comparisons, sext};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for comparisons where the relation is always either
+    /// ### What it does
+    /// Checks for comparisons where the relation is always either
     /// true or false, but where one side has been upcast so that the comparison is
     /// necessary. Only integer types are checked.
     ///
-    /// **Why is this bad?** An expression like `let x : u8 = ...; (x as u32) > 300`
+    /// ### Why is this bad?
+    /// An expression like `let x : u8 = ...; (x as u32) > 300`
     /// will mistakenly imply that it is possible for `x` to be outside the range of
     /// `u8`.
     ///
-    /// **Known problems:**
+    /// ### Known problems
     /// https://github.com/rust-lang/rust-clippy/issues/886
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// let x: u8 = 1;
     /// (x as u32) > 300;
diff --git a/clippy_lints/src/items_after_statements.rs b/clippy_lints/src/items_after_statements.rs
index c69571f32a2..429c6ed7d2d 100644
--- a/clippy_lints/src/items_after_statements.rs
+++ b/clippy_lints/src/items_after_statements.rs
@@ -7,15 +7,15 @@ use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for items declared after some statement in a block.
+    /// ### What it does
+    /// Checks for items declared after some statement in a block.
     ///
-    /// **Why is this bad?** Items live for the entire scope they are declared
+    /// ### Why is this bad?
+    /// Items live for the entire scope they are declared
     /// in. But statements are processed in order. This might cause confusion as
     /// it's hard to figure out which item is meant in a statement.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// // Bad
     /// fn foo() {
diff --git a/clippy_lints/src/large_const_arrays.rs b/clippy_lints/src/large_const_arrays.rs
index 48dc5fefe99..5d4e06c2af0 100644
--- a/clippy_lints/src/large_const_arrays.rs
+++ b/clippy_lints/src/large_const_arrays.rs
@@ -11,15 +11,15 @@ use rustc_span::{BytePos, Pos, Span};
 use rustc_typeck::hir_ty_to_ty;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for large `const` arrays that should
+    /// ### What it does
+    /// Checks for large `const` arrays that should
     /// be defined as `static` instead.
     ///
-    /// **Why is this bad?** Performance: const variables are inlined upon use.
+    /// ### Why is this bad?
+    /// Performance: const variables are inlined upon use.
     /// Static items result in only one instance and has a fixed location in memory.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust,ignore
     /// // Bad
     /// pub const a = [0u32; 1_000_000];
diff --git a/clippy_lints/src/large_enum_variant.rs b/clippy_lints/src/large_enum_variant.rs
index f166748d86b..cde2336b690 100644
--- a/clippy_lints/src/large_enum_variant.rs
+++ b/clippy_lints/src/large_enum_variant.rs
@@ -10,20 +10,22 @@ use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_target::abi::LayoutOf;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for large size differences between variants on
+    /// ### What it does
+    /// Checks for large size differences between variants on
     /// `enum`s.
     ///
-    /// **Why is this bad?** Enum size is bounded by the largest variant. Having a
+    /// ### Why is this bad?
+    /// Enum size is bounded by the largest variant. Having a
     /// large variant can penalize the memory layout of that enum.
     ///
-    /// **Known problems:** This lint obviously cannot take the distribution of
+    /// ### Known problems
+    /// This lint obviously cannot take the distribution of
     /// variants in your running program into account. It is possible that the
     /// smaller variants make up less than 1% of all instances, in which case
     /// the overhead is negligible and the boxing is counter-productive. Always
     /// measure the change this lint suggests.
     ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust
     /// // Bad
     /// enum Test {
diff --git a/clippy_lints/src/large_stack_arrays.rs b/clippy_lints/src/large_stack_arrays.rs
index c46b98022c6..7088630bfdb 100644
--- a/clippy_lints/src/large_stack_arrays.rs
+++ b/clippy_lints/src/large_stack_arrays.rs
@@ -10,13 +10,13 @@ use rustc_session::{declare_tool_lint, impl_lint_pass};
 use crate::rustc_target::abi::LayoutOf;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for local arrays that may be too large.
+    /// ### What it does
+    /// Checks for local arrays that may be too large.
     ///
-    /// **Why is this bad?** Large local arrays may cause stack overflow.
+    /// ### Why is this bad?
+    /// Large local arrays may cause stack overflow.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust,ignore
     /// let a = [0u32; 1_000_000];
     /// ```
diff --git a/clippy_lints/src/len_zero.rs b/clippy_lints/src/len_zero.rs
index 892b3af0b32..b66d7a9f729 100644
--- a/clippy_lints/src/len_zero.rs
+++ b/clippy_lints/src/len_zero.rs
@@ -18,17 +18,17 @@ use rustc_span::{
 };
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for getting the length of something via `.len()`
+    /// ### What it does
+    /// Checks for getting the length of something via `.len()`
     /// just to compare to zero, and suggests using `.is_empty()` where applicable.
     ///
-    /// **Why is this bad?** Some structures can answer `.is_empty()` much faster
+    /// ### Why is this bad?
+    /// Some structures can answer `.is_empty()` much faster
     /// than calculating their length. So it is good to get into the habit of using
     /// `.is_empty()`, and having it is cheap.
     /// Besides, it makes the intent clearer than a manual comparison in some contexts.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```ignore
     /// if x.len() == 0 {
     ///     ..
@@ -52,18 +52,18 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for items that implement `.len()` but not
+    /// ### What it does
+    /// Checks for items that implement `.len()` but not
     /// `.is_empty()`.
     ///
-    /// **Why is this bad?** It is good custom to have both methods, because for
+    /// ### Why is this bad?
+    /// It is good custom to have both methods, because for
     /// some data structures, asking about the length will be a costly operation,
     /// whereas `.is_empty()` can usually answer in constant time. Also it used to
     /// lead to false positives on the [`len_zero`](#len_zero) lint – currently that
     /// lint will ignore such entities.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```ignore
     /// impl X {
     ///     pub fn len(&self) -> usize {
@@ -77,17 +77,17 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for comparing to an empty slice such as `""` or `[]`,
+    /// ### What it does
+    /// Checks for comparing to an empty slice such as `""` or `[]`,
     /// and suggests using `.is_empty()` where applicable.
     ///
-    /// **Why is this bad?** Some structures can answer `.is_empty()` much faster
+    /// ### Why is this bad?
+    /// Some structures can answer `.is_empty()` much faster
     /// than checking for equality. So it is good to get into the habit of using
     /// `.is_empty()`, and having it is cheap.
     /// Besides, it makes the intent clearer than a manual comparison in some contexts.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     ///
     /// ```ignore
     /// if s == "" {
diff --git a/clippy_lints/src/let_if_seq.rs b/clippy_lints/src/let_if_seq.rs
index 67eae4d87bb..13f0d43cf8d 100644
--- a/clippy_lints/src/let_if_seq.rs
+++ b/clippy_lints/src/let_if_seq.rs
@@ -9,14 +9,14 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for variable declarations immediately followed by a
+    /// ### What it does
+    /// Checks for variable declarations immediately followed by a
     /// conditional affectation.
     ///
-    /// **Why is this bad?** This is not idiomatic Rust.
+    /// ### Why is this bad?
+    /// This is not idiomatic Rust.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust,ignore
     /// let foo;
     ///
diff --git a/clippy_lints/src/let_underscore.rs b/clippy_lints/src/let_underscore.rs
index e627b1385bc..8992d25932c 100644
--- a/clippy_lints/src/let_underscore.rs
+++ b/clippy_lints/src/let_underscore.rs
@@ -9,15 +9,15 @@ use rustc_middle::ty::subst::GenericArgKind;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for `let _ = <expr>`
+    /// ### What it does
+    /// Checks for `let _ = <expr>`
     /// where expr is #[must_use]
     ///
-    /// **Why is this bad?** It's better to explicitly
+    /// ### Why is this bad?
+    /// It's better to explicitly
     /// handle the value of a #[must_use] expr
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// fn f() -> Result<u32, u32> {
     ///     Ok(0)
@@ -33,17 +33,17 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for `let _ = sync_lock`
+    /// ### What it does
+    /// Checks for `let _ = sync_lock`
     ///
-    /// **Why is this bad?** This statement immediately drops the lock instead of
+    /// ### Why is this bad?
+    /// This statement immediately drops the lock instead of
     /// extending its lifetime to the end of the scope, which is often not intended.
     /// To extend lock lifetime to the end of the scope, use an underscore-prefixed
     /// name instead (i.e. _lock). If you want to explicitly drop the lock,
     /// `std::mem::drop` conveys your intention better and is less error-prone.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     ///
     /// Bad:
     /// ```rust,ignore
@@ -60,19 +60,19 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for `let _ = <expr>`
+    /// ### What it does
+    /// Checks for `let _ = <expr>`
     /// where expr has a type that implements `Drop`
     ///
-    /// **Why is this bad?** This statement immediately drops the initializer
+    /// ### Why is this bad?
+    /// This statement immediately drops the initializer
     /// expression instead of extending its lifetime to the end of the scope, which
     /// is often not intended. To extend the expression's lifetime to the end of the
     /// scope, use an underscore-prefixed name instead (i.e. _var). If you want to
     /// explicitly drop the expression, `std::mem::drop` conveys your intention
     /// better and is less error-prone.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     ///
     /// Bad:
     /// ```rust,ignore
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index aa763b5c5e6..3cffb507f70 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -73,14 +73,13 @@ use rustc_session::Session;
 /// use clippy_lints::declare_clippy_lint;
 ///
 /// declare_clippy_lint! {
-///     /// **What it does:** Checks for ... (describe what the lint matches).
+///     /// ### What it does
+///     /// Checks for ... (describe what the lint matches).
 ///     ///
-///     /// **Why is this bad?** Supply the reason for linting the code.
-///     ///
-///     /// **Known problems:** None. (Or describe where it could go wrong.)
-///     ///
-///     /// **Example:**
+///     /// ### Why is this bad?
+///     /// Supply the reason for linting the code.
 ///     ///
+///     /// ### Example
 ///     /// ```rust
 ///     /// // Bad
 ///     /// Insert a short example of code that triggers the lint
diff --git a/clippy_lints/src/lifetimes.rs b/clippy_lints/src/lifetimes.rs
index 5ae68ba5b2f..e5e6f8d25cc 100644
--- a/clippy_lints/src/lifetimes.rs
+++ b/clippy_lints/src/lifetimes.rs
@@ -18,20 +18,22 @@ use rustc_span::source_map::Span;
 use rustc_span::symbol::{kw, Symbol};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for lifetime annotations which can be removed by
+    /// ### What it does
+    /// Checks for lifetime annotations which can be removed by
     /// relying on lifetime elision.
     ///
-    /// **Why is this bad?** The additional lifetimes make the code look more
+    /// ### Why is this bad?
+    /// The additional lifetimes make the code look more
     /// complicated, while there is nothing out of the ordinary going on. Removing
     /// them leads to more readable code.
     ///
-    /// **Known problems:**
+    /// ### Known problems
     /// - We bail out if the function has a `where` clause where lifetimes
     /// are mentioned due to potenial false positives.
     /// - Lifetime bounds such as `impl Foo + 'a` and `T: 'a` must be elided with the
     /// placeholder notation `'_` because the fully elided notation leaves the type bound to `'static`.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// // Bad: unnecessary lifetime annotations
     /// fn in_and_out<'a>(x: &'a u8, y: u8) -> &'a u8 {
@@ -50,16 +52,16 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for lifetimes in generics that are never used
+    /// ### What it does
+    /// Checks for lifetimes in generics that are never used
     /// anywhere else.
     ///
-    /// **Why is this bad?** The additional lifetimes make the code look more
+    /// ### Why is this bad?
+    /// The additional lifetimes make the code look more
     /// complicated, while there is nothing out of the ordinary going on. Removing
     /// them leads to more readable code.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// // Bad: unnecessary lifetimes
     /// fn unused_lifetime<'a>(x: u8) {
diff --git a/clippy_lints/src/literal_representation.rs b/clippy_lints/src/literal_representation.rs
index e0c5578bd60..699ddce0cff 100644
--- a/clippy_lints/src/literal_representation.rs
+++ b/clippy_lints/src/literal_representation.rs
@@ -16,15 +16,14 @@ use rustc_session::{declare_tool_lint, impl_lint_pass};
 use std::iter;
 
 declare_clippy_lint! {
-    /// **What it does:** Warns if a long integral or floating-point constant does
+    /// ### What it does
+    /// Warns if a long integral or floating-point constant does
     /// not contain underscores.
     ///
-    /// **Why is this bad?** Reading long numbers is difficult without separators.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Why is this bad?
+    /// Reading long numbers is difficult without separators.
     ///
+    /// ### Example
     /// ```rust
     /// // Bad
     /// let x: u64 = 61864918973511;
@@ -38,17 +37,18 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Warns for mistyped suffix in literals
+    /// ### What it does
+    /// Warns for mistyped suffix in literals
     ///
-    /// **Why is this bad?** This is most probably a typo
+    /// ### Why is this bad?
+    /// This is most probably a typo
     ///
-    /// **Known problems:**
+    /// ### Known problems
     /// - Recommends a signed suffix, even though the number might be too big and an unsigned
     ///   suffix is required
     /// - Does not match on `_127` since that is a valid grouping for decimal and octal numbers
     ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust
     /// // Probably mistyped
     /// 2_32;
@@ -62,16 +62,15 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Warns if an integral or floating-point constant is
+    /// ### What it does
+    /// Warns if an integral or floating-point constant is
     /// grouped inconsistently with underscores.
     ///
-    /// **Why is this bad?** Readers may incorrectly interpret inconsistently
+    /// ### Why is this bad?
+    /// Readers may incorrectly interpret inconsistently
     /// grouped digits.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust
     /// // Bad
     /// let x: u64 = 618_64_9189_73_511;
@@ -85,15 +84,14 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Warns if hexadecimal or binary literals are not grouped
+    /// ### What it does
+    /// Warns if hexadecimal or binary literals are not grouped
     /// by nibble or byte.
     ///
-    /// **Why is this bad?** Negatively impacts readability.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Why is this bad?
+    /// Negatively impacts readability.
     ///
+    /// ### Example
     /// ```rust
     /// let x: u32 = 0xFFF_FFF;
     /// let y: u8 = 0b01_011_101;
@@ -104,16 +102,15 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Warns if the digits of an integral or floating-point
+    /// ### What it does
+    /// Warns if the digits of an integral or floating-point
     /// constant are grouped into groups that
     /// are too large.
     ///
-    /// **Why is this bad?** Negatively impacts readability.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Why is this bad?
+    /// Negatively impacts readability.
     ///
+    /// ### Example
     /// ```rust
     /// let x: u64 = 6186491_8973511;
     /// ```
@@ -123,15 +120,14 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Warns if there is a better representation for a numeric literal.
+    /// ### What it does
+    /// Warns if there is a better representation for a numeric literal.
     ///
-    /// **Why is this bad?** Especially for big powers of 2 a hexadecimal representation is more
+    /// ### Why is this bad?
+    /// Especially for big powers of 2 a hexadecimal representation is more
     /// readable than a decimal representation.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// `255` => `0xFF`
     /// `65_535` => `0xFFFF`
     /// `4_042_322_160` => `0xF0F0_F0F0`
diff --git a/clippy_lints/src/loops/mod.rs b/clippy_lints/src/loops/mod.rs
index 56a123b69c6..7ca54d53972 100644
--- a/clippy_lints/src/loops/mod.rs
+++ b/clippy_lints/src/loops/mod.rs
@@ -26,14 +26,14 @@ use rustc_span::source_map::Span;
 use utils::{get_span_of_entire_for_loop, make_iterator_snippet, IncrementVisitor, InitializeVisitor};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for for-loops that manually copy items between
+    /// ### What it does
+    /// Checks for for-loops that manually copy items between
     /// slices that could be optimized by having a memcpy.
     ///
-    /// **Why is this bad?** It is not as fast as a memcpy.
+    /// ### Why is this bad?
+    /// It is not as fast as a memcpy.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// # let src = vec![1];
     /// # let mut dst = vec![0; 65];
@@ -53,15 +53,15 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for looping over the range of `0..len` of some
+    /// ### What it does
+    /// Checks for looping over the range of `0..len` of some
     /// collection just to get the values by index.
     ///
-    /// **Why is this bad?** Just iterating the collection itself makes the intent
+    /// ### Why is this bad?
+    /// Just iterating the collection itself makes the intent
     /// more clear and is probably faster.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// let vec = vec!['a', 'b', 'c'];
     /// for i in 0..vec.len() {
@@ -81,15 +81,18 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for loops on `x.iter()` where `&x` will do, and
+    /// ### What it does
+    /// Checks for loops on `x.iter()` where `&x` will do, and
     /// suggests the latter.
     ///
-    /// **Why is this bad?** Readability.
+    /// ### Why is this bad?
+    /// Readability.
     ///
-    /// **Known problems:** False negatives. We currently only warn on some known
+    /// ### Known problems
+    /// False negatives. We currently only warn on some known
     /// types.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// // with `y` a `Vec` or slice:
     /// # let y = vec![1];
@@ -110,14 +113,14 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for loops on `y.into_iter()` where `y` will do, and
+    /// ### What it does
+    /// Checks for loops on `y.into_iter()` where `y` will do, and
     /// suggests the latter.
     ///
-    /// **Why is this bad?** Readability.
+    /// ### Why is this bad?
+    /// Readability.
     ///
-    /// **Known problems:** None
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// # let y = vec![1];
     /// // with `y` a `Vec` or slice:
@@ -138,18 +141,18 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for loops on `x.next()`.
+    /// ### What it does
+    /// Checks for loops on `x.next()`.
     ///
-    /// **Why is this bad?** `next()` returns either `Some(value)` if there was a
+    /// ### Why is this bad?
+    /// `next()` returns either `Some(value)` if there was a
     /// value, or `None` otherwise. The insidious thing is that `Option<_>`
     /// implements `IntoIterator`, so that possibly one value will be iterated,
     /// leading to some hard to find bugs. No one will want to write such code
     /// [except to win an Underhanded Rust
     /// Contest](https://www.reddit.com/r/rust/comments/3hb0wm/underhanded_rust_contest/cu5yuhr).
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```ignore
     /// for x in y.next() {
     ///     ..
@@ -161,14 +164,14 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for `for` loops over `Option` or `Result` values.
+    /// ### What it does
+    /// Checks for `for` loops over `Option` or `Result` values.
     ///
-    /// **Why is this bad?** Readability. This is more clearly expressed as an `if
+    /// ### Why is this bad?
+    /// Readability. This is more clearly expressed as an `if
     /// let`.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// # let opt = Some(1);
     ///
@@ -204,15 +207,18 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Detects `loop + match` combinations that are easier
+    /// ### What it does
+    /// Detects `loop + match` combinations that are easier
     /// written as a `while let` loop.
     ///
-    /// **Why is this bad?** The `while let` loop is usually shorter and more
+    /// ### Why is this bad?
+    /// The `while let` loop is usually shorter and more
     /// readable.
     ///
-    /// **Known problems:** Sometimes the wrong binding is displayed ([#383](https://github.com/rust-lang/rust-clippy/issues/383)).
+    /// ### Known problems
+    /// Sometimes the wrong binding is displayed ([#383](https://github.com/rust-lang/rust-clippy/issues/383)).
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust,no_run
     /// # let y = Some(1);
     /// loop {
@@ -233,16 +239,15 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for functions collecting an iterator when collect
+    /// ### What it does
+    /// Checks for functions collecting an iterator when collect
     /// is not needed.
     ///
-    /// **Why is this bad?** `collect` causes the allocation of a new data structure,
+    /// ### Why is this bad?
+    /// `collect` causes the allocation of a new data structure,
     /// when this allocation may not be needed.
     ///
-    /// **Known problems:**
-    /// None
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// # let iterator = vec![1].into_iter();
     /// let len = iterator.clone().collect::<Vec<_>>().len();
@@ -255,15 +260,15 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks `for` loops over slices with an explicit counter
+    /// ### What it does
+    /// Checks `for` loops over slices with an explicit counter
     /// and suggests the use of `.enumerate()`.
     ///
-    /// **Why is it bad?** Using `.enumerate()` makes the intent more clear,
+    /// ### Why is this bad?
+    /// Using `.enumerate()` makes the intent more clear,
     /// declutters the code and may be faster in some instances.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// # let v = vec![1];
     /// # fn bar(bar: usize, baz: usize) {}
@@ -285,9 +290,11 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for empty `loop` expressions.
+    /// ### What it does
+    /// Checks for empty `loop` expressions.
     ///
-    /// **Why is this bad?** These busy loops burn CPU cycles without doing
+    /// ### Why is this bad?
+    /// These busy loops burn CPU cycles without doing
     /// anything. It is _almost always_ a better idea to `panic!` than to have
     /// a busy loop.
     ///
@@ -306,9 +313,7 @@ declare_clippy_lint! {
     ///   - [`x86_64::instructions::hlt`](https://docs.rs/x86_64/0.12.2/x86_64/instructions/fn.hlt.html)
     ///   - [`cortex_m::asm::wfi`](https://docs.rs/cortex-m/0.6.3/cortex_m/asm/fn.wfi.html)
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```no_run
     /// loop {}
     /// ```
@@ -318,14 +323,14 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for `while let` expressions on iterators.
+    /// ### What it does
+    /// Checks for `while let` expressions on iterators.
     ///
-    /// **Why is this bad?** Readability. A simple `for` loop is shorter and conveys
+    /// ### Why is this bad?
+    /// Readability. A simple `for` loop is shorter and conveys
     /// the intent better.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```ignore
     /// while let Some(val) = iter() {
     ///     ..
@@ -337,15 +342,15 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for iterating a map (`HashMap` or `BTreeMap`) and
+    /// ### What it does
+    /// Checks for iterating a map (`HashMap` or `BTreeMap`) and
     /// ignoring either the keys or values.
     ///
-    /// **Why is this bad?** Readability. There are `keys` and `values` methods that
+    /// ### Why is this bad?
+    /// Readability. There are `keys` and `values` methods that
     /// can be used to express that don't need the values or keys.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```ignore
     /// for (k, _) in &map {
     ///     ..
@@ -365,15 +370,15 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for loops that will always `break`, `return` or
+    /// ### What it does
+    /// Checks for loops that will always `break`, `return` or
     /// `continue` an outer loop.
     ///
-    /// **Why is this bad?** This loop never loops, all it does is obfuscating the
+    /// ### Why is this bad?
+    /// This loop never loops, all it does is obfuscating the
     /// code.
     ///
-    /// **Known problems:** None
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// loop {
     ///     ..;
@@ -386,13 +391,13 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for loops which have a range bound that is a mutable variable
-    ///
-    /// **Why is this bad?** One might think that modifying the mutable variable changes the loop bounds
+    /// ### What it does
+    /// Checks for loops which have a range bound that is a mutable variable
     ///
-    /// **Known problems:** None
+    /// ### Why is this bad?
+    /// One might think that modifying the mutable variable changes the loop bounds
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// let mut foo = 42;
     /// for i in 0..foo {
@@ -406,17 +411,20 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks whether variables used within while loop condition
+    /// ### What it does
+    /// Checks whether variables used within while loop condition
     /// can be (and are) mutated in the body.
     ///
-    /// **Why is this bad?** If the condition is unchanged, entering the body of the loop
+    /// ### Why is this bad?
+    /// If the condition is unchanged, entering the body of the loop
     /// will lead to an infinite loop.
     ///
-    /// **Known problems:** If the `while`-loop is in a closure, the check for mutation of the
+    /// ### Known problems
+    /// If the `while`-loop is in a closure, the check for mutation of the
     /// condition variables in the body can cause false negatives. For example when only `Upvar` `a` is
     /// in the condition and only `Upvar` `b` gets mutated in the body, the lint will not trigger.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// let i = 0;
     /// while i > 10 {
@@ -429,15 +437,16 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks whether a for loop is being used to push a constant
+    /// ### What it does
+    /// Checks whether a for loop is being used to push a constant
     /// value into a Vec.
     ///
-    /// **Why is this bad?** This kind of operation can be expressed more succinctly with
+    /// ### Why is this bad?
+    /// This kind of operation can be expressed more succinctly with
     /// `vec![item;SIZE]` or `vec.resize(NEW_SIZE, item)` and using these alternatives may also
     /// have better performance.
-    /// **Known problems:** None
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// let item1 = 2;
     /// let item2 = 3;
@@ -462,13 +471,14 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks whether a for loop has a single element.
+    /// ### What it does
+    /// Checks whether a for loop has a single element.
     ///
-    /// **Why is this bad?** There is no reason to have a loop of a
+    /// ### Why is this bad?
+    /// There is no reason to have a loop of a
     /// single element.
-    /// **Known problems:** None
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// let item1 = 2;
     /// for item in &[item1] {
@@ -487,15 +497,15 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Check for unnecessary `if let` usage in a for loop
+    /// ### What it does
+    /// Check for unnecessary `if let` usage in a for loop
     /// where only the `Some` or `Ok` variant of the iterator element is used.
     ///
-    /// **Why is this bad?** It is verbose and can be simplified
+    /// ### Why is this bad?
+    /// It is verbose and can be simplified
     /// by first calling the `flatten` method on the `Iterator`.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     ///
     /// ```rust
     /// let x = vec![Some(1), Some(2), Some(3)];
diff --git a/clippy_lints/src/macro_use.rs b/clippy_lints/src/macro_use.rs
index 66479ae264e..a371f8bbd3c 100644
--- a/clippy_lints/src/macro_use.rs
+++ b/clippy_lints/src/macro_use.rs
@@ -12,14 +12,14 @@ use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::{edition::Edition, sym, Span};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for `#[macro_use] use...`.
+    /// ### What it does
+    /// Checks for `#[macro_use] use...`.
     ///
-    /// **Why is this bad?** Since the Rust 2018 edition you can import
+    /// ### Why is this bad?
+    /// Since the Rust 2018 edition you can import
     /// macro's directly, this is considered idiomatic.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust,ignore
     /// #[macro_use]
     /// use some_macro;
diff --git a/clippy_lints/src/main_recursion.rs b/clippy_lints/src/main_recursion.rs
index 07d8a440aea..776e4b3fe76 100644
--- a/clippy_lints/src/main_recursion.rs
+++ b/clippy_lints/src/main_recursion.rs
@@ -7,14 +7,14 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for recursion using the entrypoint.
+    /// ### What it does
+    /// Checks for recursion using the entrypoint.
     ///
-    /// **Why is this bad?** Apart from special setups (which we could detect following attributes like #![no_std]),
+    /// ### Why is this bad?
+    /// Apart from special setups (which we could detect following attributes like #![no_std]),
     /// recursing into main() seems like an unintuitive antipattern we should be able to detect.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```no_run
     /// fn main() {
     ///     main();
diff --git a/clippy_lints/src/manual_async_fn.rs b/clippy_lints/src/manual_async_fn.rs
index 5d88ff3b99f..8e1385fb83a 100644
--- a/clippy_lints/src/manual_async_fn.rs
+++ b/clippy_lints/src/manual_async_fn.rs
@@ -14,14 +14,13 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::{sym, Span};
 
 declare_clippy_lint! {
-    /// **What it does:** It checks for manual implementations of `async` functions.
+    /// ### What it does
+    /// It checks for manual implementations of `async` functions.
     ///
-    /// **Why is this bad?** It's more idiomatic to use the dedicated syntax.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Why is this bad?
+    /// It's more idiomatic to use the dedicated syntax.
     ///
+    /// ### Example
     /// ```rust
     /// use std::future::Future;
     ///
diff --git a/clippy_lints/src/manual_map.rs b/clippy_lints/src/manual_map.rs
index 563d5cdb5fb..7dec1595e0d 100644
--- a/clippy_lints/src/manual_map.rs
+++ b/clippy_lints/src/manual_map.rs
@@ -16,14 +16,13 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::{sym, SyntaxContext};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for usages of `match` which could be implemented using `map`
+    /// ### What it does
+    /// Checks for usages of `match` which could be implemented using `map`
     ///
-    /// **Why is this bad?** Using the `map` method is clearer and more concise.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Why is this bad?
+    /// Using the `map` method is clearer and more concise.
     ///
+    /// ### Example
     /// ```rust
     /// match Some(0) {
     ///     Some(x) => Some(x + 1),
diff --git a/clippy_lints/src/manual_non_exhaustive.rs b/clippy_lints/src/manual_non_exhaustive.rs
index 54f714b54b6..335ea001ee4 100644
--- a/clippy_lints/src/manual_non_exhaustive.rs
+++ b/clippy_lints/src/manual_non_exhaustive.rs
@@ -11,15 +11,14 @@ use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::{sym, Span};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for manual implementations of the non-exhaustive pattern.
+    /// ### What it does
+    /// Checks for manual implementations of the non-exhaustive pattern.
     ///
-    /// **Why is this bad?** Using the #[non_exhaustive] attribute expresses better the intent
+    /// ### Why is this bad?
+    /// Using the #[non_exhaustive] attribute expresses better the intent
     /// and allows possible optimizations when applied to enums.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust
     /// struct S {
     ///     pub a: i32,
diff --git a/clippy_lints/src/manual_ok_or.rs b/clippy_lints/src/manual_ok_or.rs
index 847c8c648b0..b2f287af697 100644
--- a/clippy_lints/src/manual_ok_or.rs
+++ b/clippy_lints/src/manual_ok_or.rs
@@ -13,15 +13,15 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::symbol::sym;
 
 declare_clippy_lint! {
-    /// **What it does:**
+    /// ### What it does
+    ///
     /// Finds patterns that reimplement `Option::ok_or`.
     ///
-    /// **Why is this bad?**
-    /// Concise code helps focusing on behavior instead of boilerplate.
+    /// ### Why is this bad?
     ///
-    /// **Known problems:** None.
+    /// Concise code helps focusing on behavior instead of boilerplate.
     ///
-    /// **Examples:**
+    /// ### Examples
     /// ```rust
     /// let foo: Option<i32> = None;
     /// foo.map_or(Err("error"), |v| Ok(v));
diff --git a/clippy_lints/src/manual_strip.rs b/clippy_lints/src/manual_strip.rs
index 61b5fe81fa9..db12c377488 100644
--- a/clippy_lints/src/manual_strip.rs
+++ b/clippy_lints/src/manual_strip.rs
@@ -18,21 +18,17 @@ use rustc_span::source_map::Spanned;
 use rustc_span::Span;
 
 declare_clippy_lint! {
-    /// **What it does:**
+    /// ### What it does
     /// Suggests using `strip_{prefix,suffix}` over `str::{starts,ends}_with` and slicing using
     /// the pattern's length.
     ///
-    /// **Why is this bad?**
+    /// ### Why is this bad?
     /// Using `str:strip_{prefix,suffix}` is safer and may have better performance as there is no
     /// slicing which may panic and the compiler does not need to insert this panic code. It is
     /// also sometimes more readable as it removes the need for duplicating or storing the pattern
     /// used by `str::{starts,ends}_with` and in the slicing.
     ///
-    /// **Known problems:**
-    /// None.
-    ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust
     /// let s = "hello, world!";
     /// if s.starts_with("hello, ") {
diff --git a/clippy_lints/src/manual_unwrap_or.rs b/clippy_lints/src/manual_unwrap_or.rs
index 9d8d77cf8f0..426789742d5 100644
--- a/clippy_lints/src/manual_unwrap_or.rs
+++ b/clippy_lints/src/manual_unwrap_or.rs
@@ -15,15 +15,13 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::sym;
 
 declare_clippy_lint! {
-    /// **What it does:**
+    /// ### What it does
     /// Finds patterns that reimplement `Option::unwrap_or` or `Result::unwrap_or`.
     ///
-    /// **Why is this bad?**
+    /// ### Why is this bad?
     /// Concise code helps focusing on behavior instead of boilerplate.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// let foo: Option<i32> = None;
     /// match foo {
diff --git a/clippy_lints/src/map_clone.rs b/clippy_lints/src/map_clone.rs
index e1f80ab025c..394606200bb 100644
--- a/clippy_lints/src/map_clone.rs
+++ b/clippy_lints/src/map_clone.rs
@@ -15,16 +15,15 @@ use rustc_span::symbol::Ident;
 use rustc_span::{sym, Span};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for usage of `map(|x| x.clone())` or
+    /// ### What it does
+    /// Checks for usage of `map(|x| x.clone())` or
     /// dereferencing closures for `Copy` types, on `Iterator` or `Option`,
     /// and suggests `cloned()` or `copied()` instead
     ///
-    /// **Why is this bad?** Readability, this can be written more concisely
-    ///
-    /// **Known problems:** None
-    ///
-    /// **Example:**
+    /// ### Why is this bad?
+    /// Readability, this can be written more concisely
     ///
+    /// ### Example
     /// ```rust
     /// let x = vec![42, 43];
     /// let y = x.iter();
diff --git a/clippy_lints/src/map_err_ignore.rs b/clippy_lints/src/map_err_ignore.rs
index 425a9734e5f..82d3732326e 100644
--- a/clippy_lints/src/map_err_ignore.rs
+++ b/clippy_lints/src/map_err_ignore.rs
@@ -4,13 +4,13 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for instances of `map_err(|_| Some::Enum)`
+    /// ### What it does
+    /// Checks for instances of `map_err(|_| Some::Enum)`
     ///
-    /// **Why is this bad?** This `map_err` throws away the original error rather than allowing the enum to contain and report the cause of the error
+    /// ### Why is this bad?
+    /// This `map_err` throws away the original error rather than allowing the enum to contain and report the cause of the error
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// Before:
     /// ```rust
     /// use std::fmt;
diff --git a/clippy_lints/src/map_unit_fn.rs b/clippy_lints/src/map_unit_fn.rs
index 57cd907e77e..fd40590d077 100644
--- a/clippy_lints/src/map_unit_fn.rs
+++ b/clippy_lints/src/map_unit_fn.rs
@@ -12,16 +12,15 @@ use rustc_span::source_map::Span;
 use rustc_span::sym;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for usage of `option.map(f)` where f is a function
+    /// ### What it does
+    /// Checks for usage of `option.map(f)` where f is a function
     /// or closure that returns the unit type `()`.
     ///
-    /// **Why is this bad?** Readability, this can be written more clearly with
+    /// ### Why is this bad?
+    /// Readability, this can be written more clearly with
     /// an if let statement
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust
     /// # fn do_stuff() -> Option<String> { Some(String::new()) }
     /// # fn log_err_msg(foo: String) -> Option<String> { Some(foo) }
@@ -54,16 +53,15 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for usage of `result.map(f)` where f is a function
+    /// ### What it does
+    /// Checks for usage of `result.map(f)` where f is a function
     /// or closure that returns the unit type `()`.
     ///
-    /// **Why is this bad?** Readability, this can be written more clearly with
+    /// ### Why is this bad?
+    /// Readability, this can be written more clearly with
     /// an if let statement
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust
     /// # fn do_stuff() -> Result<String, String> { Ok(String::new()) }
     /// # fn log_err_msg(foo: String) -> Result<String, String> { Ok(foo) }
diff --git a/clippy_lints/src/match_on_vec_items.rs b/clippy_lints/src/match_on_vec_items.rs
index ca6fb0831fe..e66a35452f0 100644
--- a/clippy_lints/src/match_on_vec_items.rs
+++ b/clippy_lints/src/match_on_vec_items.rs
@@ -10,13 +10,13 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::sym;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for `match vec[idx]` or `match vec[n..m]`.
+    /// ### What it does
+    /// Checks for `match vec[idx]` or `match vec[n..m]`.
     ///
-    /// **Why is this bad?** This can panic at runtime.
+    /// ### Why is this bad?
+    /// This can panic at runtime.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust, no_run
     /// let arr = vec![0, 1, 2, 3];
     /// let idx = 1;
diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index d7f600b3ab2..5360c02f905 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -35,14 +35,14 @@ use std::iter;
 use std::ops::Bound;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for matches with a single arm where an `if let`
+    /// ### What it does
+    /// Checks for matches with a single arm where an `if let`
     /// will usually suffice.
     ///
-    /// **Why is this bad?** Just readability – `if let` nests less than a `match`.
+    /// ### Why is this bad?
+    /// Just readability – `if let` nests less than a `match`.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// # fn bar(stool: &str) {}
     /// # let x = Some("abc");
@@ -63,15 +63,17 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for matches with two arms where an `if let else` will
+    /// ### What it does
+    /// Checks for matches with two arms where an `if let else` will
     /// usually suffice.
     ///
-    /// **Why is this bad?** Just readability – `if let` nests less than a `match`.
-    ///
-    /// **Known problems:** Personal style preferences may differ.
+    /// ### Why is this bad?
+    /// Just readability – `if let` nests less than a `match`.
     ///
-    /// **Example:**
+    /// ### Known problems
+    /// Personal style preferences may differ.
     ///
+    /// ### Example
     /// Using `match`:
     ///
     /// ```rust
@@ -102,16 +104,16 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for matches where all arms match a reference,
+    /// ### What it does
+    /// Checks for matches where all arms match a reference,
     /// suggesting to remove the reference and deref the matched expression
     /// instead. It also checks for `if let &foo = bar` blocks.
     ///
-    /// **Why is this bad?** It just makes the code less readable. That reference
+    /// ### Why is this bad?
+    /// It just makes the code less readable. That reference
     /// destructuring adds nothing to the code.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust,ignore
     /// // Bad
     /// match x {
@@ -133,14 +135,14 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for matches where match expression is a `bool`. It
+    /// ### What it does
+    /// Checks for matches where match expression is a `bool`. It
     /// suggests to replace the expression with an `if...else` block.
     ///
-    /// **Why is this bad?** It makes the code less readable.
+    /// ### Why is this bad?
+    /// It makes the code less readable.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// # fn foo() {}
     /// # fn bar() {}
@@ -167,14 +169,14 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for overlapping match arms.
+    /// ### What it does
+    /// Checks for overlapping match arms.
     ///
-    /// **Why is this bad?** It is likely to be an error and if not, makes the code
+    /// ### Why is this bad?
+    /// It is likely to be an error and if not, makes the code
     /// less obvious.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// let x = 5;
     /// match x {
@@ -189,15 +191,15 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for arm which matches all errors with `Err(_)`
+    /// ### What it does
+    /// Checks for arm which matches all errors with `Err(_)`
     /// and take drastic actions like `panic!`.
     ///
-    /// **Why is this bad?** It is generally a bad practice, similar to
+    /// ### Why is this bad?
+    /// It is generally a bad practice, similar to
     /// catching all exceptions in java with `catch(Exception)`
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// let x: Result<i32, &str> = Ok(3);
     /// match x {
@@ -211,14 +213,14 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for match which is used to add a reference to an
+    /// ### What it does
+    /// Checks for match which is used to add a reference to an
     /// `Option` value.
     ///
-    /// **Why is this bad?** Using `as_ref()` or `as_mut()` instead is shorter.
+    /// ### Why is this bad?
+    /// Using `as_ref()` or `as_mut()` instead is shorter.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// let x: Option<()> = None;
     ///
@@ -237,14 +239,17 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for wildcard enum matches using `_`.
+    /// ### What it does
+    /// Checks for wildcard enum matches using `_`.
     ///
-    /// **Why is this bad?** New enum variants added by library updates can be missed.
+    /// ### Why is this bad?
+    /// New enum variants added by library updates can be missed.
     ///
-    /// **Known problems:** Suggested replacements may be incorrect if guards exhaustively cover some
+    /// ### Known problems
+    /// Suggested replacements may be incorrect if guards exhaustively cover some
     /// variants, and also may not use correct path to enum if it's not present in the current scope.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// # enum Foo { A(usize), B(usize) }
     /// # let x = Foo::B(1);
@@ -266,15 +271,17 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for wildcard enum matches for a single variant.
+    /// ### What it does
+    /// Checks for wildcard enum matches for a single variant.
     ///
-    /// **Why is this bad?** New enum variants added by library updates can be missed.
+    /// ### Why is this bad?
+    /// New enum variants added by library updates can be missed.
     ///
-    /// **Known problems:** Suggested replacements may not use correct path to enum
+    /// ### Known problems
+    /// Suggested replacements may not use correct path to enum
     /// if it's not present in the current scope.
     ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust
     /// # enum Foo { A, B, C }
     /// # let x = Foo::B;
@@ -298,14 +305,14 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for wildcard pattern used with others patterns in same match arm.
+    /// ### What it does
+    /// Checks for wildcard pattern used with others patterns in same match arm.
     ///
-    /// **Why is this bad?** Wildcard pattern already covers any other pattern as it will match anyway.
+    /// ### Why is this bad?
+    /// Wildcard pattern already covers any other pattern as it will match anyway.
     /// It makes the code less readable, especially to spot wildcard pattern use in match arm.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// // Bad
     /// match "foo" {
@@ -325,14 +332,14 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for matches being used to destructure a single-variant enum
+    /// ### What it does
+    /// Checks for matches being used to destructure a single-variant enum
     /// or tuple struct where a `let` will suffice.
     ///
-    /// **Why is this bad?** Just readability – `let` doesn't nest, whereas a `match` does.
+    /// ### Why is this bad?
+    /// Just readability – `let` doesn't nest, whereas a `match` does.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// enum Wrapper {
     ///     Data(i32),
@@ -360,14 +367,17 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for useless match that binds to only one value.
+    /// ### What it does
+    /// Checks for useless match that binds to only one value.
     ///
-    /// **Why is this bad?** Readability and needless complexity.
+    /// ### Why is this bad?
+    /// Readability and needless complexity.
     ///
-    /// **Known problems:**  Suggested replacements may be incorrect when `match`
+    /// ### Known problems
+    ///  Suggested replacements may be incorrect when `match`
     /// is actually binding temporary value, bringing a 'dropped while borrowed' error.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// # let a = 1;
     /// # let b = 2;
@@ -388,14 +398,14 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for unnecessary '..' pattern binding on struct when all fields are explicitly matched.
+    /// ### What it does
+    /// Checks for unnecessary '..' pattern binding on struct when all fields are explicitly matched.
     ///
-    /// **Why is this bad?** Correctness and readability. It's like having a wildcard pattern after
+    /// ### Why is this bad?
+    /// Correctness and readability. It's like having a wildcard pattern after
     /// matching all enum variants explicitly.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// # struct A { a: i32 }
     /// let a = A { a: 5 };
@@ -418,21 +428,23 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Lint for redundant pattern matching over `Result`, `Option`,
+    /// ### What it does
+    /// Lint for redundant pattern matching over `Result`, `Option`,
     /// `std::task::Poll` or `std::net::IpAddr`
     ///
-    /// **Why is this bad?** It's more concise and clear to just use the proper
+    /// ### Why is this bad?
+    /// It's more concise and clear to just use the proper
     /// utility function
     ///
-    /// **Known problems:** This will change the drop order for the matched type. Both `if let` and
+    /// ### Known problems
+    /// This will change the drop order for the matched type. Both `if let` and
     /// `while let` will drop the value at the end of the block, both `if` and `while` will drop the
     /// value before entering the block. For most types this change will not matter, but for a few
     /// types this will not be an acceptable change (e.g. locks). See the
     /// [reference](https://doc.rust-lang.org/reference/destructors.html#drop-scopes) for more about
     /// drop order.
     ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust
     /// # use std::task::Poll;
     /// # use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
@@ -471,15 +483,18 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for `match`  or `if let` expressions producing a
+    /// ### What it does
+    /// Checks for `match`  or `if let` expressions producing a
     /// `bool` that could be written using `matches!`
     ///
-    /// **Why is this bad?** Readability and needless complexity.
+    /// ### Why is this bad?
+    /// Readability and needless complexity.
     ///
-    /// **Known problems:** This lint falsely triggers, if there are arms with
+    /// ### Known problems
+    /// This lint falsely triggers, if there are arms with
     /// `cfg` attributes that remove an arm evaluating to `false`.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// let x = Some(5);
     ///
@@ -504,17 +519,20 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for `match` with identical arm bodies.
+    /// ### What it does
+    /// Checks for `match` with identical arm bodies.
     ///
-    /// **Why is this bad?** This is probably a copy & paste error. If arm bodies
+    /// ### Why is this bad?
+    /// This is probably a copy & paste error. If arm bodies
     /// are the same on purpose, you can factor them
     /// [using `|`](https://doc.rust-lang.org/book/patterns.html#multiple-patterns).
     ///
-    /// **Known problems:** False positive possible with order dependent `match`
+    /// ### Known problems
+    /// False positive possible with order dependent `match`
     /// (see issue
     /// [#860](https://github.com/rust-lang/rust-clippy/issues/860)).
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust,ignore
     /// match foo {
     ///     Bar => bar(),
diff --git a/clippy_lints/src/mem_discriminant.rs b/clippy_lints/src/mem_discriminant.rs
index aca96e06ef2..59176c4b846 100644
--- a/clippy_lints/src/mem_discriminant.rs
+++ b/clippy_lints/src/mem_discriminant.rs
@@ -9,14 +9,14 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for calls of `mem::discriminant()` on a non-enum type.
+    /// ### What it does
+    /// Checks for calls of `mem::discriminant()` on a non-enum type.
     ///
-    /// **Why is this bad?** The value of `mem::discriminant()` on non-enum types
+    /// ### Why is this bad?
+    /// The value of `mem::discriminant()` on non-enum types
     /// is unspecified.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// use std::mem;
     ///
diff --git a/clippy_lints/src/mem_forget.rs b/clippy_lints/src/mem_forget.rs
index a28cb5f32fe..07202a59c4b 100644
--- a/clippy_lints/src/mem_forget.rs
+++ b/clippy_lints/src/mem_forget.rs
@@ -5,15 +5,15 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for usage of `std::mem::forget(t)` where `t` is
+    /// ### What it does
+    /// Checks for usage of `std::mem::forget(t)` where `t` is
     /// `Drop`.
     ///
-    /// **Why is this bad?** `std::mem::forget(t)` prevents `t` from running its
+    /// ### Why is this bad?
+    /// `std::mem::forget(t)` prevents `t` from running its
     /// destructor, possibly causing leaks.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// # use std::mem;
     /// # use std::rc::Rc;
diff --git a/clippy_lints/src/mem_replace.rs b/clippy_lints/src/mem_replace.rs
index 183daee3617..3d071c9081b 100644
--- a/clippy_lints/src/mem_replace.rs
+++ b/clippy_lints/src/mem_replace.rs
@@ -14,16 +14,16 @@ use rustc_span::source_map::Span;
 use rustc_span::symbol::sym;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for `mem::replace()` on an `Option` with
+    /// ### What it does
+    /// Checks for `mem::replace()` on an `Option` with
     /// `None`.
     ///
-    /// **Why is this bad?** `Option` already has the method `take()` for
+    /// ### Why is this bad?
+    /// `Option` already has the method `take()` for
     /// taking its current value (Some(..) or None) and replacing it with
     /// `None`.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// use std::mem;
     ///
@@ -41,17 +41,16 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for `mem::replace(&mut _, mem::uninitialized())`
+    /// ### What it does
+    /// Checks for `mem::replace(&mut _, mem::uninitialized())`
     /// and `mem::replace(&mut _, mem::zeroed())`.
     ///
-    /// **Why is this bad?** This will lead to undefined behavior even if the
+    /// ### Why is this bad?
+    /// This will lead to undefined behavior even if the
     /// value is overwritten later, because the uninitialized value may be
     /// observed in the case of a panic.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```
     /// use std::mem;
     ///# fn may_panic(v: Vec<i32>) -> Vec<i32> { v }
@@ -73,15 +72,15 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for `std::mem::replace` on a value of type
+    /// ### What it does
+    /// Checks for `std::mem::replace` on a value of type
     /// `T` with `T::default()`.
     ///
-    /// **Why is this bad?** `std::mem` module already has the method `take` to
+    /// ### Why is this bad?
+    /// `std::mem` module already has the method `take` to
     /// take the current value and replace it with the default value of that type.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// let mut text = String::from("foo");
     /// let replaced = std::mem::replace(&mut text, String::default());
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 283fcf281df..d3e12023814 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -80,16 +80,15 @@ use rustc_span::{sym, Span};
 use rustc_typeck::hir_ty_to_ty;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for usages of `cloned()` on an `Iterator` or `Option` where
+    /// ### What it does
+    /// Checks for usages of `cloned()` on an `Iterator` or `Option` where
     /// `copied()` could be used instead.
     ///
-    /// **Why is this bad?** `copied()` is better because it guarantees that the type being cloned
+    /// ### Why is this bad?
+    /// `copied()` is better because it guarantees that the type being cloned
     /// implements `Copy`.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust
     /// [1, 2, 3].iter().cloned();
     /// ```
@@ -103,16 +102,15 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for usages of `Iterator::flat_map()` where `filter_map()` could be
+    /// ### What it does
+    /// Checks for usages of `Iterator::flat_map()` where `filter_map()` could be
     /// used instead.
     ///
-    /// **Why is this bad?** When applicable, `filter_map()` is more clear since it shows that
+    /// ### Why is this bad?
+    /// When applicable, `filter_map()` is more clear since it shows that
     /// `Option` is used to produce 0 or 1 items.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust
     /// let nums: Vec<i32> = ["1", "2", "whee!"].iter().flat_map(|x| x.parse().ok()).collect();
     /// ```
@@ -126,9 +124,11 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for `.unwrap()` calls on `Option`s and on `Result`s.
+    /// ### What it does
+    /// Checks for `.unwrap()` calls on `Option`s and on `Result`s.
     ///
-    /// **Why is this bad?** It is better to handle the `None` or `Err` case,
+    /// ### Why is this bad?
+    /// It is better to handle the `None` or `Err` case,
     /// or at least call `.expect(_)` with a more helpful message. Still, for a lot of
     /// quick-and-dirty code, `unwrap` is a good choice, which is why this lint is
     /// `Allow` by default.
@@ -141,9 +141,7 @@ declare_clippy_lint! {
     /// messages on display. Therefore, it may be beneficial to look at the places
     /// where they may get displayed. Activate this lint to do just that.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Examples:**
+    /// ### Examples
     /// ```rust
     /// # let opt = Some(1);
     ///
@@ -171,9 +169,11 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for `.expect()` calls on `Option`s and `Result`s.
+    /// ### What it does
+    /// Checks for `.expect()` calls on `Option`s and `Result`s.
     ///
-    /// **Why is this bad?** Usually it is better to handle the `None` or `Err` case.
+    /// ### Why is this bad?
+    /// Usually it is better to handle the `None` or `Err` case.
     /// Still, for a lot of quick-and-dirty code, `expect` is a good choice, which is why
     /// this lint is `Allow` by default.
     ///
@@ -181,9 +181,7 @@ declare_clippy_lint! {
     /// values. Normally, you want to implement more sophisticated error handling,
     /// and propagate errors upwards with `?` operator.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Examples:**
+    /// ### Examples
     /// ```rust,ignore
     /// # let opt = Some(1);
     ///
@@ -213,20 +211,20 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for methods that should live in a trait
+    /// ### What it does
+    /// Checks for methods that should live in a trait
     /// implementation of a `std` trait (see [llogiq's blog
     /// post](http://llogiq.github.io/2015/07/30/traits.html) for further
     /// information) instead of an inherent implementation.
     ///
-    /// **Why is this bad?** Implementing the traits improve ergonomics for users of
+    /// ### Why is this bad?
+    /// Implementing the traits improve ergonomics for users of
     /// the code, often with very little cost. Also people seeing a `mul(...)`
     /// method
     /// may expect `*` to work equally, so you should have good reason to disappoint
     /// them.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// struct X;
     /// impl X {
@@ -242,7 +240,8 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for methods with certain name prefixes and which
+    /// ### What it does
+    /// Checks for methods with certain name prefixes and which
     /// doesn't match how self is taken. The actual rules are:
     ///
     /// |Prefix |Postfix     |`self` taken           | `self` type  |
@@ -265,13 +264,12 @@ declare_clippy_lint! {
     /// Please find more info here:
     /// https://rust-lang.github.io/api-guidelines/naming.html#ad-hoc-conversions-follow-as_-to_-into_-conventions-c-conv
     ///
-    /// **Why is this bad?** Consistency breeds readability. If you follow the
+    /// ### Why is this bad?
+    /// Consistency breeds readability. If you follow the
     /// conventions, your users won't be surprised that they, e.g., need to supply a
     /// mutable reference to a `as_..` function.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// # struct X;
     /// impl X {
@@ -287,14 +285,17 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for usage of `ok().expect(..)`.
+    /// ### What it does
+    /// Checks for usage of `ok().expect(..)`.
     ///
-    /// **Why is this bad?** Because you usually call `expect()` on the `Result`
+    /// ### Why is this bad?
+    /// Because you usually call `expect()` on the `Result`
     /// directly to get a better error message.
     ///
-    /// **Known problems:** The error type needs to implement `Debug`
+    /// ### Known problems
+    /// The error type needs to implement `Debug`
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// # let x = Ok::<_, ()>(());
     ///
@@ -310,15 +311,18 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for usage of `option.map(_).unwrap_or(_)` or `option.map(_).unwrap_or_else(_)` or
+    /// ### What it does
+    /// Checks for usage of `option.map(_).unwrap_or(_)` or `option.map(_).unwrap_or_else(_)` or
     /// `result.map(_).unwrap_or_else(_)`.
     ///
-    /// **Why is this bad?** Readability, these can be written more concisely (resp.) as
+    /// ### Why is this bad?
+    /// Readability, these can be written more concisely (resp.) as
     /// `option.map_or(_, _)`, `option.map_or_else(_, _)` and `result.map_or_else(_, _)`.
     ///
-    /// **Known problems:** The order of the arguments is not in execution order
+    /// ### Known problems
+    /// The order of the arguments is not in execution order
     ///
-    /// **Examples:**
+    /// ### Examples
     /// ```rust
     /// # let x = Some(1);
     ///
@@ -347,14 +351,17 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for usage of `_.map_or(None, _)`.
+    /// ### What it does
+    /// Checks for usage of `_.map_or(None, _)`.
     ///
-    /// **Why is this bad?** Readability, this can be written more concisely as
+    /// ### Why is this bad?
+    /// Readability, this can be written more concisely as
     /// `_.and_then(_)`.
     ///
-    /// **Known problems:** The order of the arguments is not in execution order.
+    /// ### Known problems
+    /// The order of the arguments is not in execution order.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// # let opt = Some(1);
     ///
@@ -370,15 +377,14 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for usage of `_.map_or(None, Some)`.
+    /// ### What it does
+    /// Checks for usage of `_.map_or(None, Some)`.
     ///
-    /// **Why is this bad?** Readability, this can be written more concisely as
+    /// ### Why is this bad?
+    /// Readability, this can be written more concisely as
     /// `_.ok()`.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// Bad:
     /// ```rust
     /// # let r: Result<u32, &str> = Ok(1);
@@ -396,16 +402,15 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for usage of `_.and_then(|x| Some(y))`, `_.and_then(|x| Ok(y))` or
+    /// ### What it does
+    /// Checks for usage of `_.and_then(|x| Some(y))`, `_.and_then(|x| Ok(y))` or
     /// `_.or_else(|x| Err(y))`.
     ///
-    /// **Why is this bad?** Readability, this can be written more concisely as
+    /// ### Why is this bad?
+    /// Readability, this can be written more concisely as
     /// `_.map(|x| y)` or `_.map_err(|x| y)`.
     ///
-    /// **Known problems:** None
-    ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust
     /// # fn opt() -> Option<&'static str> { Some("42") }
     /// # fn res() -> Result<&'static str, &'static str> { Ok("42") }
@@ -429,14 +434,14 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for usage of `_.filter(_).next()`.
+    /// ### What it does
+    /// Checks for usage of `_.filter(_).next()`.
     ///
-    /// **Why is this bad?** Readability, this can be written more concisely as
+    /// ### Why is this bad?
+    /// Readability, this can be written more concisely as
     /// `_.find(_)`.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// # let vec = vec![1];
     /// vec.iter().filter(|x| **x == 0).next();
@@ -452,14 +457,14 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for usage of `_.skip_while(condition).next()`.
+    /// ### What it does
+    /// Checks for usage of `_.skip_while(condition).next()`.
     ///
-    /// **Why is this bad?** Readability, this can be written more concisely as
+    /// ### Why is this bad?
+    /// Readability, this can be written more concisely as
     /// `_.find(!condition)`.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// # let vec = vec![1];
     /// vec.iter().skip_while(|x| **x == 0).next();
@@ -475,14 +480,14 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for usage of `_.map(_).flatten(_)` on `Iterator` and `Option`
+    /// ### What it does
+    /// Checks for usage of `_.map(_).flatten(_)` on `Iterator` and `Option`
     ///
-    /// **Why is this bad?** Readability, this can be written more concisely as
+    /// ### Why is this bad?
+    /// Readability, this can be written more concisely as
     /// `_.flat_map(_)`
     ///
-    /// **Known problems:**
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// let vec = vec![vec![1]];
     ///
@@ -498,15 +503,15 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for usage of `_.filter(_).map(_)` that can be written more simply
+    /// ### What it does
+    /// Checks for usage of `_.filter(_).map(_)` that can be written more simply
     /// as `filter_map(_)`.
     ///
-    /// **Why is this bad?** Redundant code in the `filter` and `map` operations is poor style and
+    /// ### Why is this bad?
+    /// Redundant code in the `filter` and `map` operations is poor style and
     /// less performant.
     ///
-    /// **Known problems:** None.
-    ///
-     /// **Example:**
+     /// ### Example
     /// Bad:
     /// ```rust
     /// (0_i32..10)
@@ -524,15 +529,15 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for usage of `_.find(_).map(_)` that can be written more simply
+    /// ### What it does
+    /// Checks for usage of `_.find(_).map(_)` that can be written more simply
     /// as `find_map(_)`.
     ///
-    /// **Why is this bad?** Redundant code in the `find` and `map` operations is poor style and
+    /// ### Why is this bad?
+    /// Redundant code in the `find` and `map` operations is poor style and
     /// less performant.
     ///
-    /// **Known problems:** None.
-    ///
-     /// **Example:**
+     /// ### Example
     /// Bad:
     /// ```rust
     /// (0_i32..10)
@@ -550,14 +555,14 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for usage of `_.filter_map(_).next()`.
+    /// ### What it does
+    /// Checks for usage of `_.filter_map(_).next()`.
     ///
-    /// **Why is this bad?** Readability, this can be written more concisely as
+    /// ### Why is this bad?
+    /// Readability, this can be written more concisely as
     /// `_.find_map(_)`.
     ///
-    /// **Known problems:** None
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     ///  (0..3).filter_map(|x| if x == 2 { Some(x) } else { None }).next();
     /// ```
@@ -572,13 +577,13 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for usage of `flat_map(|x| x)`.
+    /// ### What it does
+    /// Checks for usage of `flat_map(|x| x)`.
     ///
-    /// **Why is this bad?** Readability, this can be written more concisely by using `flatten`.
+    /// ### Why is this bad?
+    /// Readability, this can be written more concisely by using `flatten`.
     ///
-    /// **Known problems:** None
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// # let iter = vec![vec![0]].into_iter();
     /// iter.flat_map(|x| x);
@@ -594,16 +599,16 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for an iterator or string search (such as `find()`,
+    /// ### What it does
+    /// Checks for an iterator or string search (such as `find()`,
     /// `position()`, or `rposition()`) followed by a call to `is_some()` or `is_none()`.
     ///
-    /// **Why is this bad?** Readability, this can be written more concisely as:
+    /// ### Why is this bad?
+    /// Readability, this can be written more concisely as:
     /// * `_.any(_)`, or `_.contains(_)` for `is_some()`,
     /// * `!_.any(_)`, or `!_.contains(_)` for `is_none()`.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// let vec = vec![1];
     /// vec.iter().find(|x| **x == 0).is_some();
@@ -623,15 +628,15 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for usage of `.chars().next()` on a `str` to check
+    /// ### What it does
+    /// Checks for usage of `.chars().next()` on a `str` to check
     /// if it starts with a given char.
     ///
-    /// **Why is this bad?** Readability, this can be written more concisely as
+    /// ### Why is this bad?
+    /// Readability, this can be written more concisely as
     /// `_.starts_with(_)`.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// let name = "foo";
     /// if name.chars().next() == Some('_') {};
@@ -647,17 +652,20 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for calls to `.or(foo(..))`, `.unwrap_or(foo(..))`,
+    /// ### What it does
+    /// Checks for calls to `.or(foo(..))`, `.unwrap_or(foo(..))`,
     /// etc., and suggests to use `or_else`, `unwrap_or_else`, etc., or
     /// `unwrap_or_default` instead.
     ///
-    /// **Why is this bad?** The function will always be called and potentially
+    /// ### Why is this bad?
+    /// The function will always be called and potentially
     /// allocate an object acting as the default.
     ///
-    /// **Known problems:** If the function has side-effects, not calling it will
+    /// ### Known problems
+    /// If the function has side-effects, not calling it will
     /// change the semantic of the program, but you shouldn't rely on that anyway.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// # let foo = Some(String::new());
     /// foo.unwrap_or(String::new());
@@ -678,15 +686,18 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for calls to `.expect(&format!(...))`, `.expect(foo(..))`,
+    /// ### What it does
+    /// Checks for calls to `.expect(&format!(...))`, `.expect(foo(..))`,
     /// etc., and suggests to use `unwrap_or_else` instead
     ///
-    /// **Why is this bad?** The function will always be called.
+    /// ### Why is this bad?
+    /// The function will always be called.
     ///
-    /// **Known problems:** If the function has side-effects, not calling it will
+    /// ### Known problems
+    /// If the function has side-effects, not calling it will
     /// change the semantics of the program, but you shouldn't rely on that anyway.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// # let foo = Some(String::new());
     /// # let err_code = "418";
@@ -713,14 +724,14 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for usage of `.clone()` on a `Copy` type.
+    /// ### What it does
+    /// Checks for usage of `.clone()` on a `Copy` type.
     ///
-    /// **Why is this bad?** The only reason `Copy` types implement `Clone` is for
+    /// ### Why is this bad?
+    /// The only reason `Copy` types implement `Clone` is for
     /// generics, not for using the `clone` method on a concrete type.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// 42u64.clone();
     /// ```
@@ -730,15 +741,17 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for usage of `.clone()` on a ref-counted pointer,
+    /// ### What it does
+    /// Checks for usage of `.clone()` on a ref-counted pointer,
     /// (`Rc`, `Arc`, `rc::Weak`, or `sync::Weak`), and suggests calling Clone via unified
     /// function syntax instead (e.g., `Rc::clone(foo)`).
     ///
-    /// **Why is this bad?** Calling '.clone()' on an Rc, Arc, or Weak
+    /// ### Why is this bad?
+    /// Calling '.clone()' on an Rc, Arc, or Weak
     /// can obscure the fact that only the pointer is being cloned, not the underlying
     /// data.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// # use std::rc::Rc;
     /// let x = Rc::new(1);
@@ -755,14 +768,14 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for usage of `.clone()` on an `&&T`.
+    /// ### What it does
+    /// Checks for usage of `.clone()` on an `&&T`.
     ///
-    /// **Why is this bad?** Cloning an `&&T` copies the inner `&T`, instead of
+    /// ### Why is this bad?
+    /// Cloning an `&&T` copies the inner `&T`, instead of
     /// cloning the underlying `T`.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// fn main() {
     ///     let x = vec![1];
@@ -777,16 +790,16 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for usage of `.to_string()` on an `&&T` where
+    /// ### What it does
+    /// Checks for usage of `.to_string()` on an `&&T` where
     /// `T` implements `ToString` directly (like `&&str` or `&&String`).
     ///
-    /// **Why is this bad?** This bypasses the specialized implementation of
+    /// ### Why is this bad?
+    /// This bypasses the specialized implementation of
     /// `ToString` and instead goes through the more expensive string formatting
     /// facilities.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// // Generic implementation for `T: Display` is used (slow)
     /// ["foo", "bar"].iter().map(|s| s.to_string());
@@ -800,14 +813,14 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for `new` not returning a type that contains `Self`.
+    /// ### What it does
+    /// Checks for `new` not returning a type that contains `Self`.
     ///
-    /// **Why is this bad?** As a convention, `new` methods are used to make a new
+    /// ### Why is this bad?
+    /// As a convention, `new` methods are used to make a new
     /// instance of a type.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// In an impl block:
     /// ```rust
     /// # struct Foo;
@@ -861,15 +874,18 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for string methods that receive a single-character
+    /// ### What it does
+    /// Checks for string methods that receive a single-character
     /// `str` as an argument, e.g., `_.split("x")`.
     ///
-    /// **Why is this bad?** Performing these methods using a `char` is faster than
+    /// ### Why is this bad?
+    /// Performing these methods using a `char` is faster than
     /// using a `str`.
     ///
-    /// **Known problems:** Does not catch multi-byte unicode characters.
+    /// ### Known problems
+    /// Does not catch multi-byte unicode characters.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust,ignore
     /// // Bad
     /// _.split("x");
@@ -882,14 +898,14 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for calling `.step_by(0)` on iterators which panics.
+    /// ### What it does
+    /// Checks for calling `.step_by(0)` on iterators which panics.
     ///
-    /// **Why is this bad?** This very much looks like an oversight. Use `panic!()` instead if you
+    /// ### Why is this bad?
+    /// This very much looks like an oversight. Use `panic!()` instead if you
     /// actually intend to panic.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust,should_panic
     /// for x in (0..100).step_by(0) {
     ///     //..
@@ -901,15 +917,14 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for indirect collection of populated `Option`
+    /// ### What it does
+    /// Checks for indirect collection of populated `Option`
     ///
-    /// **Why is this bad?** `Option` is like a collection of 0-1 things, so `flatten`
+    /// ### Why is this bad?
+    /// `Option` is like a collection of 0-1 things, so `flatten`
     /// automatically does this without suspicious-looking `unwrap` calls.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust
     /// let _ = std::iter::empty::<Option<i32>>().filter(Option::is_some).map(Option::unwrap);
     /// ```
@@ -923,16 +938,15 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for the use of `iter.nth(0)`.
+    /// ### What it does
+    /// Checks for the use of `iter.nth(0)`.
     ///
-    /// **Why is this bad?** `iter.next()` is equivalent to
+    /// ### Why is this bad?
+    /// `iter.next()` is equivalent to
     /// `iter.nth(0)`, as they both consume the next element,
     ///  but is more readable.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust
     /// # use std::collections::HashSet;
     /// // Bad
@@ -951,15 +965,15 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for use of `.iter().nth()` (and the related
+    /// ### What it does
+    /// Checks for use of `.iter().nth()` (and the related
     /// `.iter_mut().nth()`) on standard library types with O(1) element access.
     ///
-    /// **Why is this bad?** `.get()` and `.get_mut()` are more efficient and more
+    /// ### Why is this bad?
+    /// `.get()` and `.get_mut()` are more efficient and more
     /// readable.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// let some_vec = vec![0, 1, 2, 3];
     /// let bad_vec = some_vec.iter().nth(3);
@@ -977,13 +991,13 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for use of `.skip(x).next()` on iterators.
-    ///
-    /// **Why is this bad?** `.nth(x)` is cleaner
+    /// ### What it does
+    /// Checks for use of `.skip(x).next()` on iterators.
     ///
-    /// **Known problems:** None.
+    /// ### Why is this bad?
+    /// `.nth(x)` is cleaner
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// let some_vec = vec![0, 1, 2, 3];
     /// let bad_vec = some_vec.iter().skip(3).next();
@@ -1001,13 +1015,16 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for use of `.get().unwrap()` (or
+    /// ### What it does
+    /// Checks for use of `.get().unwrap()` (or
     /// `.get_mut().unwrap`) on a standard library type which implements `Index`
     ///
-    /// **Why is this bad?** Using the Index trait (`[]`) is more clear and more
+    /// ### Why is this bad?
+    /// Using the Index trait (`[]`) is more clear and more
     /// concise.
     ///
-    /// **Known problems:** Not a replacement for error handling: Using either
+    /// ### Known problems
+    /// Not a replacement for error handling: Using either
     /// `.unwrap()` or the Index trait (`[]`) carries the risk of causing a `panic`
     /// if the value being accessed is `None`. If the use of `.get().unwrap()` is a
     /// temporary placeholder for dealing with the `Option` type, then this does
@@ -1016,7 +1033,7 @@ declare_clippy_lint! {
     /// is handled in a future refactor instead of using `.unwrap()` or the Index
     /// trait.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// let mut some_vec = vec![0, 1, 2, 3];
     /// let last = some_vec.get(3).unwrap();
@@ -1034,14 +1051,13 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for occurrences where one vector gets extended instead of append
+    /// ### What it does
+    /// Checks for occurrences where one vector gets extended instead of append
     ///
-    /// **Why is this bad?** Using `append` instead of `extend` is more concise and faster
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Why is this bad?
+    /// Using `append` instead of `extend` is more concise and faster
     ///
+    /// ### Example
     /// ```rust
     /// let mut a = vec![1, 2, 3];
     /// let mut b = vec![4, 5, 6];
@@ -1058,14 +1074,14 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for the use of `.extend(s.chars())` where s is a
+    /// ### What it does
+    /// Checks for the use of `.extend(s.chars())` where s is a
     /// `&str` or `String`.
     ///
-    /// **Why is this bad?** `.push_str(s)` is clearer
+    /// ### Why is this bad?
+    /// `.push_str(s)` is clearer
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// let abc = "abc";
     /// let def = String::from("def");
@@ -1087,14 +1103,14 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for the use of `.cloned().collect()` on slice to
+    /// ### What it does
+    /// Checks for the use of `.cloned().collect()` on slice to
     /// create a `Vec`.
     ///
-    /// **Why is this bad?** `.to_vec()` is clearer
-    ///
-    /// **Known problems:** None.
+    /// ### Why is this bad?
+    /// `.to_vec()` is clearer
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// let s = [1, 2, 3, 4, 5];
     /// let s2: Vec<isize> = s[..].iter().cloned().collect();
@@ -1110,15 +1126,15 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for usage of `_.chars().last()` or
+    /// ### What it does
+    /// Checks for usage of `_.chars().last()` or
     /// `_.chars().next_back()` on a `str` to check if it ends with a given char.
     ///
-    /// **Why is this bad?** Readability, this can be written more concisely as
+    /// ### Why is this bad?
+    /// Readability, this can be written more concisely as
     /// `_.ends_with(_)`.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// # let name = "_";
     ///
@@ -1134,14 +1150,14 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for usage of `.as_ref()` or `.as_mut()` where the
+    /// ### What it does
+    /// Checks for usage of `.as_ref()` or `.as_mut()` where the
     /// types before and after the call are the same.
     ///
-    /// **Why is this bad?** The call is unnecessary.
-    ///
-    /// **Known problems:** None.
+    /// ### Why is this bad?
+    /// The call is unnecessary.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// # fn do_stuff(x: &[i32]) {}
     /// let x: &[i32] = &[1, 2, 3, 4, 5];
@@ -1159,15 +1175,15 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for using `fold` when a more succinct alternative exists.
+    /// ### What it does
+    /// Checks for using `fold` when a more succinct alternative exists.
     /// Specifically, this checks for `fold`s which could be replaced by `any`, `all`,
     /// `sum` or `product`.
     ///
-    /// **Why is this bad?** Readability.
-    ///
-    /// **Known problems:** None.
+    /// ### Why is this bad?
+    /// Readability.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// let _ = (0..3).fold(false, |acc, x| acc || x > 2);
     /// ```
@@ -1181,16 +1197,16 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for `filter_map` calls which could be replaced by `filter` or `map`.
+    /// ### What it does
+    /// Checks for `filter_map` calls which could be replaced by `filter` or `map`.
     /// More specifically it checks if the closure provided is only performing one of the
     /// filter or map operations and suggests the appropriate option.
     ///
-    /// **Why is this bad?** Complexity. The intent is also clearer if only a single
+    /// ### Why is this bad?
+    /// Complexity. The intent is also clearer if only a single
     /// operation is being performed.
     ///
-    /// **Known problems:** None
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// let _ = (0..3).filter_map(|x| if x > 2 { Some(x) } else { None });
     ///
@@ -1210,17 +1226,16 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for `into_iter` calls on references which should be replaced by `iter`
+    /// ### What it does
+    /// Checks for `into_iter` calls on references which should be replaced by `iter`
     /// or `iter_mut`.
     ///
-    /// **Why is this bad?** Readability. Calling `into_iter` on a reference will not move out its
+    /// ### Why is this bad?
+    /// Readability. Calling `into_iter` on a reference will not move out its
     /// content into the resulting iterator, which is confusing. It is better just call `iter` or
     /// `iter_mut` directly.
     ///
-    /// **Known problems:** None
-    ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust
     /// // Bad
     /// let _ = (&vec![3, 4, 5]).into_iter();
@@ -1234,16 +1249,15 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for calls to `map` followed by a `count`.
+    /// ### What it does
+    /// Checks for calls to `map` followed by a `count`.
     ///
-    /// **Why is this bad?** It looks suspicious. Maybe `map` was confused with `filter`.
+    /// ### Why is this bad?
+    /// It looks suspicious. Maybe `map` was confused with `filter`.
     /// If the `map` call is intentional, this should be rewritten. Or, if you intend to
     /// drive the iterator to completion, you can just use `for_each` instead.
     ///
-    /// **Known problems:** None
-    ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust
     /// let _ = (0..3).map(|x| x + 2).count();
     /// ```
@@ -1253,16 +1267,18 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for `MaybeUninit::uninit().assume_init()`.
+    /// ### What it does
+    /// Checks for `MaybeUninit::uninit().assume_init()`.
     ///
-    /// **Why is this bad?** For most types, this is undefined behavior.
+    /// ### Why is this bad?
+    /// For most types, this is undefined behavior.
     ///
-    /// **Known problems:** For now, we accept empty tuples and tuples / arrays
+    /// ### Known problems
+    /// For now, we accept empty tuples and tuples / arrays
     /// of `MaybeUninit`. There may be other types that allow uninitialized
     /// data, but those are not yet rigorously defined.
     ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust
     /// // Beware the UB
     /// use std::mem::MaybeUninit;
@@ -1285,12 +1301,13 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for `.checked_add/sub(x).unwrap_or(MAX/MIN)`.
+    /// ### What it does
+    /// Checks for `.checked_add/sub(x).unwrap_or(MAX/MIN)`.
     ///
-    /// **Why is this bad?** These can be written simply with `saturating_add/sub` methods.
-    ///
-    /// **Example:**
+    /// ### Why is this bad?
+    /// These can be written simply with `saturating_add/sub` methods.
     ///
+    /// ### Example
     /// ```rust
     /// # let y: u32 = 0;
     /// # let x: u32 = 100;
@@ -1312,14 +1329,14 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for `offset(_)`, `wrapping_`{`add`, `sub`}, etc. on raw pointers to
+    /// ### What it does
+    /// Checks for `offset(_)`, `wrapping_`{`add`, `sub`}, etc. on raw pointers to
     /// zero-sized types
     ///
-    /// **Why is this bad?** This is a no-op, and likely unintended
-    ///
-    /// **Known problems:** None
+    /// ### Why is this bad?
+    /// This is a no-op, and likely unintended
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// unsafe { (&() as *const ()).offset(1) };
     /// ```
@@ -1329,15 +1346,16 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for `FileType::is_file()`.
+    /// ### What it does
+    /// Checks for `FileType::is_file()`.
     ///
-    /// **Why is this bad?** When people testing a file type with `FileType::is_file`
+    /// ### Why is this bad?
+    /// When people testing a file type with `FileType::is_file`
     /// they are testing whether a path is something they can get bytes from. But
     /// `is_file` doesn't cover special file types in unix-like systems, and doesn't cover
     /// symlink in windows. Using `!FileType::is_dir()` is a better way to that intention.
     ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust
     /// # || {
     /// let metadata = std::fs::metadata("foo.txt")?;
@@ -1369,14 +1387,14 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for usage of `_.as_ref().map(Deref::deref)` or it's aliases (such as String::as_str).
+    /// ### What it does
+    /// Checks for usage of `_.as_ref().map(Deref::deref)` or it's aliases (such as String::as_str).
     ///
-    /// **Why is this bad?** Readability, this can be written more concisely as
+    /// ### Why is this bad?
+    /// Readability, this can be written more concisely as
     /// `_.as_deref()`.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// # let opt = Some("".to_string());
     /// opt.as_ref().map(String::as_str)
@@ -1394,13 +1412,13 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for usage of `iter().next()` on a Slice or an Array
-    ///
-    /// **Why is this bad?** These can be shortened into `.get()`
+    /// ### What it does
+    /// Checks for usage of `iter().next()` on a Slice or an Array
     ///
-    /// **Known problems:** None.
+    /// ### Why is this bad?
+    /// These can be shortened into `.get()`
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// # let a = [1, 2, 3];
     /// # let b = vec![1, 2, 3];
@@ -1420,14 +1438,14 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Warns when using `push_str`/`insert_str` with a single-character string literal
+    /// ### What it does
+    /// Warns when using `push_str`/`insert_str` with a single-character string literal
     /// where `push`/`insert` with a `char` would work fine.
     ///
-    /// **Why is this bad?** It's less clear that we are pushing a single character.
+    /// ### Why is this bad?
+    /// It's less clear that we are pushing a single character.
     ///
-    /// **Known problems:** None
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// let mut string = String::new();
     /// string.insert_str(0, "R");
@@ -1445,7 +1463,8 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** As the counterpart to `or_fun_call`, this lint looks for unnecessary
+    /// ### What it does
+    /// As the counterpart to `or_fun_call`, this lint looks for unnecessary
     /// lazily evaluated closures on `Option` and `Result`.
     ///
     /// This lint suggests changing the following functions, when eager evaluation results in
@@ -1456,13 +1475,14 @@ declare_clippy_lint! {
     ///  - `get_or_insert_with` to `get_or_insert`
     ///  - `ok_or_else` to `ok_or`
     ///
-    /// **Why is this bad?** Using eager evaluation is shorter and simpler in some cases.
+    /// ### Why is this bad?
+    /// Using eager evaluation is shorter and simpler in some cases.
     ///
-    /// **Known problems:** It is possible, but not recommended for `Deref` and `Index` to have
+    /// ### Known problems
+    /// It is possible, but not recommended for `Deref` and `Index` to have
     /// side effects. Eagerly evaluating them can change the semantics of the program.
     ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust
     /// // example code where clippy issues a warning
     /// let opt: Option<u32> = None;
@@ -1481,14 +1501,13 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for usage of `_.map(_).collect::<Result<(), _>()`.
-    ///
-    /// **Why is this bad?** Using `try_for_each` instead is more readable and idiomatic.
-    ///
-    /// **Known problems:** None
+    /// ### What it does
+    /// Checks for usage of `_.map(_).collect::<Result<(), _>()`.
     ///
-    /// **Example:**
+    /// ### Why is this bad?
+    /// Using `try_for_each` instead is more readable and idiomatic.
     ///
+    /// ### Example
     /// ```rust
     /// (0..3).map(|t| Err(t)).collect::<Result<(), _>>();
     /// ```
@@ -1502,16 +1521,15 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for `from_iter()` function calls on types that implement the `FromIterator`
+    /// ### What it does
+    /// Checks for `from_iter()` function calls on types that implement the `FromIterator`
     /// trait.
     ///
-    /// **Why is this bad?** It is recommended style to use collect. See
+    /// ### Why is this bad?
+    /// It is recommended style to use collect. See
     /// [FromIterator documentation](https://doc.rust-lang.org/std/iter/trait.FromIterator.html)
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust
     /// use std::iter::FromIterator;
     ///
@@ -1535,15 +1553,14 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for usage of `inspect().for_each()`.
+    /// ### What it does
+    /// Checks for usage of `inspect().for_each()`.
     ///
-    /// **Why is this bad?** It is the same as performing the computation
+    /// ### Why is this bad?
+    /// It is the same as performing the computation
     /// inside `inspect` at the beginning of the closure in `for_each`.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust
     /// [1,2,3,4,5].iter()
     /// .inspect(|&x| println!("inspect the number: {}", x))
@@ -1565,14 +1582,13 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for usage of `filter_map(|x| x)`.
-    ///
-    /// **Why is this bad?** Readability, this can be written more concisely by using `flatten`.
+    /// ### What it does
+    /// Checks for usage of `filter_map(|x| x)`.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Why is this bad?
+    /// Readability, this can be written more concisely by using `flatten`.
     ///
+    /// ### Example
     /// ```rust
     /// # let iter = vec![Some(1)].into_iter();
     /// iter.filter_map(|x| x);
@@ -1588,14 +1604,13 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for instances of `map(f)` where `f` is the identity function.
-    ///
-    /// **Why is this bad?** It can be written more concisely without the call to `map`.
+    /// ### What it does
+    /// Checks for instances of `map(f)` where `f` is the identity function.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Why is this bad?
+    /// It can be written more concisely without the call to `map`.
     ///
+    /// ### Example
     /// ```rust
     /// let x = [1, 2, 3];
     /// let y: Vec<_> = x.iter().map(|x| x).map(|x| 2*x).collect();
@@ -1611,15 +1626,14 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for the use of `.bytes().nth()`.
+    /// ### What it does
+    /// Checks for the use of `.bytes().nth()`.
     ///
-    /// **Why is this bad?** `.as_bytes().get()` is more efficient and more
+    /// ### Why is this bad?
+    /// `.as_bytes().get()` is more efficient and more
     /// readable.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust
     /// // Bad
     /// let _ = "Hello".bytes().nth(3);
@@ -1633,15 +1647,14 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for the usage of `_.to_owned()`, `vec.to_vec()`, or similar when calling `_.clone()` would be clearer.
+    /// ### What it does
+    /// Checks for the usage of `_.to_owned()`, `vec.to_vec()`, or similar when calling `_.clone()` would be clearer.
     ///
-    /// **Why is this bad?** These methods do the same thing as `_.clone()` but may be confusing as
+    /// ### Why is this bad?
+    /// These methods do the same thing as `_.clone()` but may be confusing as
     /// to why we are calling `to_vec` on something that is already a `Vec` or calling `to_owned` on something that is already owned.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust
     /// let a = vec![1, 2, 3];
     /// let b = a.to_vec();
@@ -1659,15 +1672,14 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for the use of `.iter().count()`.
+    /// ### What it does
+    /// Checks for the use of `.iter().count()`.
     ///
-    /// **Why is this bad?** `.len()` is more efficient and more
+    /// ### Why is this bad?
+    /// `.len()` is more efficient and more
     /// readable.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust
     /// // Bad
     /// let some_vec = vec![0, 1, 2, 3];
@@ -1685,17 +1697,16 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for calls to [`splitn`]
+    /// ### What it does
+    /// Checks for calls to [`splitn`]
     /// (https://doc.rust-lang.org/std/primitive.str.html#method.splitn) and
     /// related functions with either zero or one splits.
     ///
-    /// **Why is this bad?** These calls don't actually split the value and are
+    /// ### Why is this bad?
+    /// These calls don't actually split the value and are
     /// likely to be intended as a different number.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust
     /// // Bad
     /// let s = "";
@@ -1715,14 +1726,13 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for manual implementations of `str::repeat`
-    ///
-    /// **Why is this bad?** These are both harder to read, as well as less performant.
-    ///
-    /// **Known problems:** None.
+    /// ### What it does
+    /// Checks for manual implementations of `str::repeat`
     ///
-    /// **Example:**
+    /// ### Why is this bad?
+    /// These are both harder to read, as well as less performant.
     ///
+    /// ### Example
     /// ```rust
     /// // Bad
     /// let x: String = std::iter::repeat('x').take(10).collect();
diff --git a/clippy_lints/src/minmax.rs b/clippy_lints/src/minmax.rs
index ff3473b744e..dc2dd45e4ed 100644
--- a/clippy_lints/src/minmax.rs
+++ b/clippy_lints/src/minmax.rs
@@ -8,15 +8,15 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use std::cmp::Ordering;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for expressions where `std::cmp::min` and `max` are
+    /// ### What it does
+    /// Checks for expressions where `std::cmp::min` and `max` are
     /// used to clamp values, but switched so that the result is constant.
     ///
-    /// **Why is this bad?** This is in all probability not the intended outcome. At
+    /// ### Why is this bad?
+    /// This is in all probability not the intended outcome. At
     /// the least it hurts readability of the code.
     ///
-    /// **Known problems:** None
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```ignore
     /// min(0, max(100, x))
     /// ```
diff --git a/clippy_lints/src/misc.rs b/clippy_lints/src/misc.rs
index 7cfce2e61cc..c796abe9815 100644
--- a/clippy_lints/src/misc.rs
+++ b/clippy_lints/src/misc.rs
@@ -25,10 +25,12 @@ use clippy_utils::{
 };
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for function arguments and let bindings denoted as
+    /// ### What it does
+    /// Checks for function arguments and let bindings denoted as
     /// `ref`.
     ///
-    /// **Why is this bad?** The `ref` declaration makes the function take an owned
+    /// ### Why is this bad?
+    /// The `ref` declaration makes the function take an owned
     /// value, but turns the argument into a reference (which means that the value
     /// is destroyed when exiting the function). This adds not much value: either
     /// take a reference type, or take an owned value and create references in the
@@ -37,11 +39,12 @@ declare_clippy_lint! {
     /// For let bindings, `let x = &foo;` is preferred over `let ref x = foo`. The
     /// type of `x` is more obvious with the former.
     ///
-    /// **Known problems:** If the argument is dereferenced within the function,
+    /// ### Known problems
+    /// If the argument is dereferenced within the function,
     /// removing the `ref` will lead to errors. This can be fixed by removing the
     /// dereferences, e.g., changing `*x` to `x` within the function.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust,ignore
     /// // Bad
     /// fn foo(ref x: u8) -> bool {
@@ -59,14 +62,14 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for comparisons to NaN.
+    /// ### What it does
+    /// Checks for comparisons to NaN.
     ///
-    /// **Why is this bad?** NaN does not compare meaningfully to anything – not
+    /// ### Why is this bad?
+    /// NaN does not compare meaningfully to anything – not
     /// even itself – so those comparisons are simply wrong.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// # let x = 1.0;
     ///
@@ -82,18 +85,18 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for (in-)equality comparisons on floating-point
+    /// ### What it does
+    /// Checks for (in-)equality comparisons on floating-point
     /// values (apart from zero), except in functions called `*eq*` (which probably
     /// implement equality for a type involving floats).
     ///
-    /// **Why is this bad?** Floating point calculations are usually imprecise, so
+    /// ### Why is this bad?
+    /// Floating point calculations are usually imprecise, so
     /// asking if two values are *exactly* equal is asking for trouble. For a good
     /// guide on what to do, see [the floating point
     /// guide](http://www.floating-point-gui.de/errors/comparison).
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// let x = 1.2331f64;
     /// let y = 1.2332f64;
@@ -115,16 +118,16 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for conversions to owned values just for the sake
+    /// ### What it does
+    /// Checks for conversions to owned values just for the sake
     /// of a comparison.
     ///
-    /// **Why is this bad?** The comparison can operate on a reference, so creating
+    /// ### Why is this bad?
+    /// The comparison can operate on a reference, so creating
     /// an owned value effectively throws it away directly afterwards, which is
     /// needlessly consuming code and heap space.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// # let x = "foo";
     /// # let y = String::from("foo");
@@ -142,18 +145,18 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for getting the remainder of a division by one or minus
+    /// ### What it does
+    /// Checks for getting the remainder of a division by one or minus
     /// one.
     ///
-    /// **Why is this bad?** The result for a divisor of one can only ever be zero; for
+    /// ### Why is this bad?
+    /// The result for a divisor of one can only ever be zero; for
     /// minus one it can cause panic/overflow (if the left operand is the minimal value of
     /// the respective integer type) or results in zero. No one will write such code
     /// deliberately, unless trying to win an Underhanded Rust Contest. Even for that
     /// contest, it's probably a bad idea. Use something more underhanded.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// # let x = 1;
     /// let a = x % 1;
@@ -165,17 +168,20 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for the use of bindings with a single leading
+    /// ### What it does
+    /// Checks for the use of bindings with a single leading
     /// underscore.
     ///
-    /// **Why is this bad?** A single leading underscore is usually used to indicate
+    /// ### Why is this bad?
+    /// A single leading underscore is usually used to indicate
     /// that a binding will not be used. Using such a binding breaks this
     /// expectation.
     ///
-    /// **Known problems:** The lint does not work properly with desugaring and
+    /// ### Known problems
+    /// The lint does not work properly with desugaring and
     /// macro, it has been allowed in the mean time.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// let _x = 0;
     /// let y = _x + 1; // Here we are using `_x`, even though it has a leading
@@ -187,17 +193,17 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for the use of short circuit boolean conditions as
+    /// ### What it does
+    /// Checks for the use of short circuit boolean conditions as
     /// a
     /// statement.
     ///
-    /// **Why is this bad?** Using a short circuit boolean condition as a statement
+    /// ### Why is this bad?
+    /// Using a short circuit boolean condition as a statement
     /// may hide the fact that the second part is executed or not depending on the
     /// outcome of the first part.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust,ignore
     /// f() && g(); // We should write `if f() { g(); }`.
     /// ```
@@ -207,15 +213,14 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Catch casts from `0` to some pointer type
+    /// ### What it does
+    /// Catch casts from `0` to some pointer type
     ///
-    /// **Why is this bad?** This generally means `null` and is better expressed as
+    /// ### Why is this bad?
+    /// This generally means `null` and is better expressed as
     /// {`std`, `core`}`::ptr::`{`null`, `null_mut`}.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust
     /// // Bad
     /// let a = 0 as *const u32;
@@ -229,18 +234,18 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for (in-)equality comparisons on floating-point
+    /// ### What it does
+    /// Checks for (in-)equality comparisons on floating-point
     /// value and constant, except in functions called `*eq*` (which probably
     /// implement equality for a type involving floats).
     ///
-    /// **Why is this bad?** Floating point calculations are usually imprecise, so
+    /// ### Why is this bad?
+    /// Floating point calculations are usually imprecise, so
     /// asking if two values are *exactly* equal is asking for trouble. For a good
     /// guide on what to do, see [the floating point
     /// guide](http://www.floating-point-gui.de/errors/comparison).
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// let x: f64 = 1.0;
     /// const ONE: f64 = 1.00;
diff --git a/clippy_lints/src/misc_early/mod.rs b/clippy_lints/src/misc_early/mod.rs
index 050b6805b7c..06fe967dafc 100644
--- a/clippy_lints/src/misc_early/mod.rs
+++ b/clippy_lints/src/misc_early/mod.rs
@@ -18,14 +18,14 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for structure field patterns bound to wildcards.
+    /// ### What it does
+    /// Checks for structure field patterns bound to wildcards.
     ///
-    /// **Why is this bad?** Using `..` instead is shorter and leaves the focus on
+    /// ### Why is this bad?
+    /// Using `..` instead is shorter and leaves the focus on
     /// the fields that are actually bound.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// # struct Foo {
     /// #     a: i32,
@@ -52,14 +52,14 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for function arguments having the similar names
+    /// ### What it does
+    /// Checks for function arguments having the similar names
     /// differing by an underscore.
     ///
-    /// **Why is this bad?** It affects code readability.
-    ///
-    /// **Known problems:** None.
+    /// ### Why is this bad?
+    /// It affects code readability.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// // Bad
     /// fn foo(a: i32, _a: i32) {}
@@ -73,14 +73,14 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Detects expressions of the form `--x`.
+    /// ### What it does
+    /// Detects expressions of the form `--x`.
     ///
-    /// **Why is this bad?** It can mislead C/C++ programmers to think `x` was
+    /// ### Why is this bad?
+    /// It can mislead C/C++ programmers to think `x` was
     /// decremented.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// let mut x = 3;
     /// --x;
@@ -91,14 +91,14 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Warns on hexadecimal literals with mixed-case letter
+    /// ### What it does
+    /// Warns on hexadecimal literals with mixed-case letter
     /// digits.
     ///
-    /// **Why is this bad?** It looks confusing.
+    /// ### Why is this bad?
+    /// It looks confusing.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// // Bad
     /// let y = 0x1a9BAcD;
@@ -112,14 +112,14 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Warns if literal suffixes are not separated by an
+    /// ### What it does
+    /// Warns if literal suffixes are not separated by an
     /// underscore.
     ///
-    /// **Why is this bad?** It is much less readable.
-    ///
-    /// **Known problems:** None.
+    /// ### Why is this bad?
+    /// It is much less readable.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// // Bad
     /// let y = 123832i32;
@@ -133,17 +133,17 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Warns if an integral constant literal starts with `0`.
+    /// ### What it does
+    /// Warns if an integral constant literal starts with `0`.
     ///
-    /// **Why is this bad?** In some languages (including the infamous C language
+    /// ### Why is this bad?
+    /// In some languages (including the infamous C language
     /// and most of its
     /// family), this marks an octal constant. In Rust however, this is a decimal
     /// constant. This could
     /// be confusing for both the writer and a reader of the constant.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     ///
     /// In Rust:
     /// ```rust
@@ -171,13 +171,13 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Warns if a generic shadows a built-in type.
-    ///
-    /// **Why is this bad?** This gives surprising type errors.
+    /// ### What it does
+    /// Warns if a generic shadows a built-in type.
     ///
-    /// **Known problems:** None.
+    /// ### Why is this bad?
+    /// This gives surprising type errors.
     ///
-    /// **Example:**
+    /// ### Example
     ///
     /// ```ignore
     /// impl<u32> Foo<u32> {
@@ -192,14 +192,14 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for patterns in the form `name @ _`.
+    /// ### What it does
+    /// Checks for patterns in the form `name @ _`.
     ///
-    /// **Why is this bad?** It's almost always more readable to just use direct
+    /// ### Why is this bad?
+    /// It's almost always more readable to just use direct
     /// bindings.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// # let v = Some("abc");
     ///
@@ -221,19 +221,19 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for tuple patterns with a wildcard
+    /// ### What it does
+    /// Checks for tuple patterns with a wildcard
     /// pattern (`_`) is next to a rest pattern (`..`).
     ///
     /// _NOTE_: While `_, ..` means there is at least one element left, `..`
     /// means there are 0 or more elements left. This can make a difference
     /// when refactoring, but shouldn't result in errors in the refactored code,
     /// since the wildcard pattern isn't used anyway.
-    /// **Why is this bad?** The wildcard pattern is unneeded as the rest pattern
+    /// ### Why is this bad?
+    /// The wildcard pattern is unneeded as the rest pattern
     /// can match that element as well.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// # struct TupleStruct(u32, u32, u32);
     /// # let t = TupleStruct(1, 2, 3);
diff --git a/clippy_lints/src/missing_const_for_fn.rs b/clippy_lints/src/missing_const_for_fn.rs
index 59cbc481ed4..5b2584d43a1 100644
--- a/clippy_lints/src/missing_const_for_fn.rs
+++ b/clippy_lints/src/missing_const_for_fn.rs
@@ -13,16 +13,13 @@ use rustc_span::Span;
 use rustc_typeck::hir_ty_to_ty;
 
 declare_clippy_lint! {
-    /// **What it does:**
-    ///
+    /// ### What it does
     /// Suggests the use of `const` in functions and methods where possible.
     ///
-    /// **Why is this bad?**
-    ///
+    /// ### Why is this bad?
     /// Not having the function const prevents callers of the function from being const as well.
     ///
-    /// **Known problems:**
-    ///
+    /// ### Known problems
     /// Const functions are currently still being worked on, with some features only being available
     /// on nightly. This lint does not consider all edge cases currently and the suggestions may be
     /// incorrect if you are using this lint on stable.
@@ -42,8 +39,7 @@ declare_clippy_lint! {
     /// can't be const as it calls a non-const function. Making `a` const and running Clippy again,
     /// will suggest to make `b` const, too.
     ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust
     /// # struct Foo {
     /// #     random_number: usize,
diff --git a/clippy_lints/src/missing_doc.rs b/clippy_lints/src/missing_doc.rs
index ec1572c26c2..aeed8268902 100644
--- a/clippy_lints/src/missing_doc.rs
+++ b/clippy_lints/src/missing_doc.rs
@@ -17,15 +17,15 @@ use rustc_span::source_map::Span;
 use rustc_span::sym;
 
 declare_clippy_lint! {
-    /// **What it does:** Warns if there is missing doc for any documentable item
+    /// ### What it does
+    /// Warns if there is missing doc for any documentable item
     /// (public or private).
     ///
-    /// **Why is this bad?** Doc is good. *rustc* has a `MISSING_DOCS`
+    /// ### Why is this bad?
+    /// Doc is good. *rustc* has a `MISSING_DOCS`
     /// allowed-by-default lint for
     /// public members, but has no way to enforce documentation of private items.
     /// This lint fixes that.
-    ///
-    /// **Known problems:** None.
     pub MISSING_DOCS_IN_PRIVATE_ITEMS,
     restriction,
     "detects missing documentation for public and private members"
diff --git a/clippy_lints/src/missing_enforced_import_rename.rs b/clippy_lints/src/missing_enforced_import_rename.rs
index 59565350f72..9d27870321c 100644
--- a/clippy_lints/src/missing_enforced_import_rename.rs
+++ b/clippy_lints/src/missing_enforced_import_rename.rs
@@ -10,17 +10,16 @@ use rustc_span::Symbol;
 use crate::utils::conf::Rename;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for imports that do not rename the item as specified
+    /// ### What it does
+    /// Checks for imports that do not rename the item as specified
     /// in the `enforce-import-renames` config option.
     ///
-    /// **Why is this bad?** Consistency is important, if a project has defined import
+    /// ### Why is this bad?
+    /// Consistency is important, if a project has defined import
     /// renames they should be followed. More practically, some item names are too
     /// vague outside of their defining scope this can enforce a more meaningful naming.
     ///
-    /// **Known problems:** None
-    ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// An example clippy.toml configuration:
     /// ```toml
     /// # clippy.toml
diff --git a/clippy_lints/src/missing_inline.rs b/clippy_lints/src/missing_inline.rs
index 041fe64a1a9..be5b4b4006f 100644
--- a/clippy_lints/src/missing_inline.rs
+++ b/clippy_lints/src/missing_inline.rs
@@ -7,10 +7,12 @@ use rustc_span::source_map::Span;
 use rustc_span::sym;
 
 declare_clippy_lint! {
-    /// **What it does:** it lints if an exported function, method, trait method with default impl,
+    /// ### What it does
+    /// it lints if an exported function, method, trait method with default impl,
     /// or trait method impl is not `#[inline]`.
     ///
-    /// **Why is this bad?** In general, it is not. Functions can be inlined across
+    /// ### Why is this bad?
+    /// In general, it is not. Functions can be inlined across
     /// crates when that's profitable as long as any form of LTO is used. When LTO is disabled,
     /// functions that are not `#[inline]` cannot be inlined across crates. Certain types of crates
     /// might intend for most of the methods in their public API to be able to be inlined across
@@ -18,9 +20,7 @@ declare_clippy_lint! {
     /// sense. It allows the crate to require all exported methods to be `#[inline]` by default, and
     /// then opt out for specific methods where this might not make sense.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// pub fn foo() {} // missing #[inline]
     /// fn ok() {} // ok
diff --git a/clippy_lints/src/modulo_arithmetic.rs b/clippy_lints/src/modulo_arithmetic.rs
index 1414fdc1b11..2d14943b56c 100644
--- a/clippy_lints/src/modulo_arithmetic.rs
+++ b/clippy_lints/src/modulo_arithmetic.rs
@@ -9,18 +9,18 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use std::fmt::Display;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for modulo arithmetic.
+    /// ### What it does
+    /// Checks for modulo arithmetic.
     ///
-    /// **Why is this bad?** The results of modulo (%) operation might differ
+    /// ### Why is this bad?
+    /// The results of modulo (%) operation might differ
     /// depending on the language, when negative numbers are involved.
     /// If you interop with different languages it might be beneficial
     /// to double check all places that use modulo arithmetic.
     ///
     /// For example, in Rust `17 % -3 = 2`, but in Python `17 % -3 = -1`.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// let x = -17 % 3;
     /// ```
diff --git a/clippy_lints/src/multiple_crate_versions.rs b/clippy_lints/src/multiple_crate_versions.rs
index f5ce3e32551..1c61970fdc8 100644
--- a/clippy_lints/src/multiple_crate_versions.rs
+++ b/clippy_lints/src/multiple_crate_versions.rs
@@ -13,17 +13,20 @@ use if_chain::if_chain;
 use itertools::Itertools;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks to see if multiple versions of a crate are being
+    /// ### What it does
+    /// Checks to see if multiple versions of a crate are being
     /// used.
     ///
-    /// **Why is this bad?** This bloats the size of targets, and can lead to
+    /// ### Why is this bad?
+    /// This bloats the size of targets, and can lead to
     /// confusing error messages when structs or traits are used interchangeably
     /// between different versions of a crate.
     ///
-    /// **Known problems:** Because this can be caused purely by the dependencies
+    /// ### Known problems
+    /// Because this can be caused purely by the dependencies
     /// themselves, it's not always possible to fix this issue.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```toml
     /// # This will pull in both winapi v0.3.x and v0.2.x, triggering a warning.
     /// [dependencies]
diff --git a/clippy_lints/src/mut_key.rs b/clippy_lints/src/mut_key.rs
index 68f7cdf6ea0..2c7681c45a4 100644
--- a/clippy_lints/src/mut_key.rs
+++ b/clippy_lints/src/mut_key.rs
@@ -10,18 +10,21 @@ use rustc_span::symbol::sym;
 use std::iter;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for sets/maps with mutable key types.
+    /// ### What it does
+    /// Checks for sets/maps with mutable key types.
     ///
-    /// **Why is this bad?** All of `HashMap`, `HashSet`, `BTreeMap` and
+    /// ### Why is this bad?
+    /// All of `HashMap`, `HashSet`, `BTreeMap` and
     /// `BtreeSet` rely on either the hash or the order of keys be unchanging,
     /// so having types with interior mutability is a bad idea.
     ///
-    /// **Known problems:** It's correct to use a struct, that contains interior mutability
+    /// ### Known problems
+    /// It's correct to use a struct, that contains interior mutability
     /// as a key, when its `Hash` implementation doesn't access any of the interior mutable types.
     /// However, this lint is unable to recognize this, so it causes a false positive in theses cases.
     /// The `bytes` crate is a great example of this.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// use std::cmp::{PartialEq, Eq};
     /// use std::collections::HashSet;
diff --git a/clippy_lints/src/mut_mut.rs b/clippy_lints/src/mut_mut.rs
index 4b9c51d0c16..d5032c5ba7f 100644
--- a/clippy_lints/src/mut_mut.rs
+++ b/clippy_lints/src/mut_mut.rs
@@ -9,15 +9,15 @@ use rustc_middle::ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for instances of `mut mut` references.
+    /// ### What it does
+    /// Checks for instances of `mut mut` references.
     ///
-    /// **Why is this bad?** Multiple `mut`s don't add anything meaningful to the
+    /// ### Why is this bad?
+    /// Multiple `mut`s don't add anything meaningful to the
     /// source. This is either a copy'n'paste error, or it shows a fundamental
     /// misunderstanding of references.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// # let mut y = 1;
     /// let x = &mut &mut y;
diff --git a/clippy_lints/src/mut_mutex_lock.rs b/clippy_lints/src/mut_mutex_lock.rs
index b9ba74c7d02..85e870632a5 100644
--- a/clippy_lints/src/mut_mutex_lock.rs
+++ b/clippy_lints/src/mut_mutex_lock.rs
@@ -8,17 +8,16 @@ use rustc_middle::ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for `&mut Mutex::lock` calls
+    /// ### What it does
+    /// Checks for `&mut Mutex::lock` calls
     ///
-    /// **Why is this bad?** `Mutex::lock` is less efficient than
+    /// ### Why is this bad?
+    /// `Mutex::lock` is less efficient than
     /// calling `Mutex::get_mut`. In addition you also have a statically
     /// guarantee that the mutex isn't locked, instead of just a runtime
     /// guarantee.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust
     /// use std::sync::{Arc, Mutex};
     ///
diff --git a/clippy_lints/src/mut_reference.rs b/clippy_lints/src/mut_reference.rs
index 6efe8ffcde0..8d5d7951fc5 100644
--- a/clippy_lints/src/mut_reference.rs
+++ b/clippy_lints/src/mut_reference.rs
@@ -7,15 +7,15 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use std::iter;
 
 declare_clippy_lint! {
-    /// **What it does:** Detects passing a mutable reference to a function that only
+    /// ### What it does
+    /// Detects passing a mutable reference to a function that only
     /// requires an immutable reference.
     ///
-    /// **Why is this bad?** The mutable reference rules out all other references to
+    /// ### Why is this bad?
+    /// The mutable reference rules out all other references to
     /// the value. Also the code misleads about the intent of the call site.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```ignore
     /// // Bad
     /// my_vec.push(&mut value)
diff --git a/clippy_lints/src/mutable_debug_assertion.rs b/clippy_lints/src/mutable_debug_assertion.rs
index 81bf853300f..ee50891cc31 100644
--- a/clippy_lints/src/mutable_debug_assertion.rs
+++ b/clippy_lints/src/mutable_debug_assertion.rs
@@ -9,17 +9,17 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::Span;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for function/method calls with a mutable
+    /// ### What it does
+    /// Checks for function/method calls with a mutable
     /// parameter in `debug_assert!`, `debug_assert_eq!` and `debug_assert_ne!` macros.
     ///
-    /// **Why is this bad?** In release builds `debug_assert!` macros are optimized out by the
+    /// ### Why is this bad?
+    /// In release builds `debug_assert!` macros are optimized out by the
     /// compiler.
     /// Therefore mutating something in a `debug_assert!` macro results in different behaviour
     /// between a release and debug build.
     ///
-    /// **Known problems:** None
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust,ignore
     /// debug_assert_eq!(vec![3].pop(), Some(3));
     /// // or
diff --git a/clippy_lints/src/mutex_atomic.rs b/clippy_lints/src/mutex_atomic.rs
index 354e2c3fb74..436ceec6cfa 100644
--- a/clippy_lints/src/mutex_atomic.rs
+++ b/clippy_lints/src/mutex_atomic.rs
@@ -10,17 +10,20 @@ use rustc_middle::ty::{self, Ty};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for usages of `Mutex<X>` where an atomic will do.
+    /// ### What it does
+    /// Checks for usages of `Mutex<X>` where an atomic will do.
     ///
-    /// **Why is this bad?** Using a mutex just to make access to a plain bool or
+    /// ### Why is this bad?
+    /// Using a mutex just to make access to a plain bool or
     /// reference sequential is shooting flies with cannons.
     /// `std::sync::atomic::AtomicBool` and `std::sync::atomic::AtomicPtr` are leaner and
     /// faster.
     ///
-    /// **Known problems:** This lint cannot detect if the mutex is actually used
+    /// ### Known problems
+    /// This lint cannot detect if the mutex is actually used
     /// for waiting before a critical section.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// # let y = true;
     ///
@@ -38,17 +41,20 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for usages of `Mutex<X>` where `X` is an integral
+    /// ### What it does
+    /// Checks for usages of `Mutex<X>` where `X` is an integral
     /// type.
     ///
-    /// **Why is this bad?** Using a mutex just to make access to a plain integer
+    /// ### Why is this bad?
+    /// Using a mutex just to make access to a plain integer
     /// sequential is
     /// shooting flies with cannons. `std::sync::atomic::AtomicUsize` is leaner and faster.
     ///
-    /// **Known problems:** This lint cannot detect if the mutex is actually used
+    /// ### Known problems
+    /// This lint cannot detect if the mutex is actually used
     /// for waiting before a critical section.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// # use std::sync::Mutex;
     /// let x = Mutex::new(0usize);
diff --git a/clippy_lints/src/needless_arbitrary_self_type.rs b/clippy_lints/src/needless_arbitrary_self_type.rs
index fe3c4455be5..9a3d9383cd9 100644
--- a/clippy_lints/src/needless_arbitrary_self_type.rs
+++ b/clippy_lints/src/needless_arbitrary_self_type.rs
@@ -9,13 +9,13 @@ use rustc_span::symbol::kw;
 use rustc_span::Span;
 
 declare_clippy_lint! {
-    /// **What it does:** The lint checks for `self` in fn parameters that
+    /// ### What it does
+    /// The lint checks for `self` in fn parameters that
     /// specify the `Self`-type explicitly
-    /// **Why is this bad?** Increases the amount and decreases the readability of code
+    /// ### Why is this bad?
+    /// Increases the amount and decreases the readability of code
     ///
-    /// **Known problems:** None
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// enum ValType {
     ///     I32,
diff --git a/clippy_lints/src/needless_bitwise_bool.rs b/clippy_lints/src/needless_bitwise_bool.rs
index b30bfbd4294..203da29cb91 100644
--- a/clippy_lints/src/needless_bitwise_bool.rs
+++ b/clippy_lints/src/needless_bitwise_bool.rs
@@ -9,20 +9,19 @@ use rustc_middle::ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
-    /// **What it does:**
+    /// ### What it does
     /// Checks for uses of bitwise and/or operators between booleans, where performance may be improved by using
     /// a lazy and.
     ///
-    /// **Why is this bad?**
+    /// ### Why is this bad?
     /// The bitwise operators do not support short-circuiting, so it may hinder code performance.
     /// Additionally, boolean logic "masked" as bitwise logic is not caught by lints like `unnecessary_fold`
     ///
-    /// **Known problems:**
+    /// ### Known problems
     /// This lint evaluates only when the right side is determined to have no side effects. At this time, that
     /// determination is quite conservative.
     ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust
     /// let (x,y) = (true, false);
     /// if x & !y {} // where both x and y are booleans
diff --git a/clippy_lints/src/needless_bool.rs b/clippy_lints/src/needless_bool.rs
index 780690548e5..36f2829a5b9 100644
--- a/clippy_lints/src/needless_bool.rs
+++ b/clippy_lints/src/needless_bool.rs
@@ -15,17 +15,20 @@ use rustc_span::source_map::Spanned;
 use rustc_span::Span;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for expressions of the form `if c { true } else {
+    /// ### What it does
+    /// Checks for expressions of the form `if c { true } else {
     /// false }` (or vice versa) and suggests using the condition directly.
     ///
-    /// **Why is this bad?** Redundant code.
+    /// ### Why is this bad?
+    /// Redundant code.
     ///
-    /// **Known problems:** Maybe false positives: Sometimes, the two branches are
+    /// ### Known problems
+    /// Maybe false positives: Sometimes, the two branches are
     /// painstakingly documented (which we, of course, do not detect), so they *may*
     /// have some value. Even then, the documentation can be rewritten to match the
     /// shorter code.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust,ignore
     /// if x {
     ///     false
@@ -43,15 +46,15 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for expressions of the form `x == true`,
+    /// ### What it does
+    /// Checks for expressions of the form `x == true`,
     /// `x != true` and order comparisons such as `x < true` (or vice versa) and
     /// suggest using the variable directly.
     ///
-    /// **Why is this bad?** Unnecessary code.
+    /// ### Why is this bad?
+    /// Unnecessary code.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust,ignore
     /// if x == true {}
     /// if y == false {}
diff --git a/clippy_lints/src/needless_borrow.rs b/clippy_lints/src/needless_borrow.rs
index dd1dfa2bdfb..3f0b23ee4d3 100644
--- a/clippy_lints/src/needless_borrow.rs
+++ b/clippy_lints/src/needless_borrow.rs
@@ -17,15 +17,15 @@ use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::Span;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for address of operations (`&`) that are going to
+    /// ### What it does
+    /// Checks for address of operations (`&`) that are going to
     /// be dereferenced immediately by the compiler.
     ///
-    /// **Why is this bad?** Suggests that the receiver of the expression borrows
+    /// ### Why is this bad?
+    /// Suggests that the receiver of the expression borrows
     /// the expression.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// // Bad
     /// let x: &i32 = &&&&&&5;
@@ -39,13 +39,13 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for `ref` bindings which create a reference to a reference.
-    ///
-    /// **Why is this bad?** The address-of operator at the use site is clearer about the need for a reference.
+    /// ### What it does
+    /// Checks for `ref` bindings which create a reference to a reference.
     ///
-    /// **Known problems:** None.
+    /// ### Why is this bad?
+    /// The address-of operator at the use site is clearer about the need for a reference.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// // Bad
     /// let x = Some("");
diff --git a/clippy_lints/src/needless_borrowed_ref.rs b/clippy_lints/src/needless_borrowed_ref.rs
index 0e976b130eb..36879eda7c0 100644
--- a/clippy_lints/src/needless_borrowed_ref.rs
+++ b/clippy_lints/src/needless_borrowed_ref.rs
@@ -7,12 +7,15 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for bindings that destructure a reference and borrow the inner
+    /// ### What it does
+    /// Checks for bindings that destructure a reference and borrow the inner
     /// value with `&ref`.
     ///
-    /// **Why is this bad?** This pattern has no effect in almost all cases.
+    /// ### Why is this bad?
+    /// This pattern has no effect in almost all cases.
     ///
-    /// **Known problems:** In some cases, `&ref` is needed to avoid a lifetime mismatch error.
+    /// ### Known problems
+    /// In some cases, `&ref` is needed to avoid a lifetime mismatch error.
     /// Example:
     /// ```rust
     /// fn foo(a: &Option<String>, b: &Option<String>) {
@@ -23,7 +26,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     ///
-    /// **Example:**
+    /// ### Example
     /// Bad:
     /// ```rust
     /// let mut v = Vec::<String>::new();
diff --git a/clippy_lints/src/needless_continue.rs b/clippy_lints/src/needless_continue.rs
index 1d19413e0d0..5088b8bb0d3 100644
--- a/clippy_lints/src/needless_continue.rs
+++ b/clippy_lints/src/needless_continue.rs
@@ -42,20 +42,20 @@ use rustc_span::source_map::{original_sp, DUMMY_SP};
 use rustc_span::Span;
 
 declare_clippy_lint! {
-    /// **What it does:** The lint checks for `if`-statements appearing in loops
+    /// ### What it does
+    /// The lint checks for `if`-statements appearing in loops
     /// that contain a `continue` statement in either their main blocks or their
     /// `else`-blocks, when omitting the `else`-block possibly with some
     /// rearrangement of code can make the code easier to understand.
     ///
-    /// **Why is this bad?** Having explicit `else` blocks for `if` statements
+    /// ### Why is this bad?
+    /// Having explicit `else` blocks for `if` statements
     /// containing `continue` in their THEN branch adds unnecessary branching and
     /// nesting to the code. Having an else block containing just `continue` can
     /// also be better written by grouping the statements following the whole `if`
     /// statement within the THEN block and omitting the else block completely.
     ///
-    /// **Known problems:** None
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// # fn condition() -> bool { false }
     /// # fn update_condition() {}
diff --git a/clippy_lints/src/needless_for_each.rs b/clippy_lints/src/needless_for_each.rs
index a723a472a25..d9aa42fe8ee 100644
--- a/clippy_lints/src/needless_for_each.rs
+++ b/clippy_lints/src/needless_for_each.rs
@@ -16,18 +16,17 @@ use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::has_iter_method;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for usage of `for_each` that would be more simply written as a
+    /// ### What it does
+    /// Checks for usage of `for_each` that would be more simply written as a
     /// `for` loop.
     ///
-    /// **Why is this bad?** `for_each` may be used after applying iterator transformers like
+    /// ### Why is this bad?
+    /// `for_each` may be used after applying iterator transformers like
     /// `filter` for better readability and performance. It may also be used to fit a simple
     /// operation on one line.
     /// But when none of these apply, a simple `for` loop is more idiomatic.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust
     /// let v = vec![0, 1, 2];
     /// v.iter().for_each(|elem| {
diff --git a/clippy_lints/src/needless_pass_by_value.rs b/clippy_lints/src/needless_pass_by_value.rs
index 283b1847b6c..03eeb54d8d1 100644
--- a/clippy_lints/src/needless_pass_by_value.rs
+++ b/clippy_lints/src/needless_pass_by_value.rs
@@ -24,20 +24,22 @@ use rustc_typeck::expr_use_visitor as euv;
 use std::borrow::Cow;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for functions taking arguments by value, but not
+    /// ### What it does
+    /// Checks for functions taking arguments by value, but not
     /// consuming them in its
     /// body.
     ///
-    /// **Why is this bad?** Taking arguments by reference is more flexible and can
+    /// ### Why is this bad?
+    /// Taking arguments by reference is more flexible and can
     /// sometimes avoid
     /// unnecessary allocations.
     ///
-    /// **Known problems:**
+    /// ### Known problems
     /// * This lint suggests taking an argument by reference,
     /// however sometimes it is better to let users decide the argument type
     /// (by using `Borrow` trait, for example), depending on how the function is used.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// fn foo(v: Vec<i32>) {
     ///     assert_eq!(v.len(), 42);
diff --git a/clippy_lints/src/needless_question_mark.rs b/clippy_lints/src/needless_question_mark.rs
index c64491c63e2..42e48336e15 100644
--- a/clippy_lints/src/needless_question_mark.rs
+++ b/clippy_lints/src/needless_question_mark.rs
@@ -10,15 +10,13 @@ use rustc_middle::ty::TyS;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
-    /// **What it does:**
+    /// ### What it does
     /// Suggests alternatives for useless applications of `?` in terminating expressions
     ///
-    /// **Why is this bad?** There's no reason to use `?` to short-circuit when execution of the body will end there anyway.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Why is this bad?
+    /// There's no reason to use `?` to short-circuit when execution of the body will end there anyway.
     ///
+    /// ### Example
     /// ```rust
     /// struct TO {
     ///     magic: Option<usize>,
diff --git a/clippy_lints/src/needless_update.rs b/clippy_lints/src/needless_update.rs
index 8f325404deb..2a33b7392ca 100644
--- a/clippy_lints/src/needless_update.rs
+++ b/clippy_lints/src/needless_update.rs
@@ -5,18 +5,18 @@ use rustc_middle::ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for needlessly including a base struct on update
+    /// ### What it does
+    /// Checks for needlessly including a base struct on update
     /// when all fields are changed anyway.
     ///
     /// This lint is not applied to structs marked with
     /// [non_exhaustive](https://doc.rust-lang.org/reference/attributes/type_system.html).
     ///
-    /// **Why is this bad?** This will cost resources (because the base has to be
+    /// ### Why is this bad?
+    /// This will cost resources (because the base has to be
     /// somewhere), and make the code less readable.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// # struct Point {
     /// #     x: i32,
diff --git a/clippy_lints/src/neg_cmp_op_on_partial_ord.rs b/clippy_lints/src/neg_cmp_op_on_partial_ord.rs
index c824f6f54b5..6ad49b70605 100644
--- a/clippy_lints/src/neg_cmp_op_on_partial_ord.rs
+++ b/clippy_lints/src/neg_cmp_op_on_partial_ord.rs
@@ -8,19 +8,16 @@ use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
-    /// **What it does:**
+    /// ### What it does
     /// Checks for the usage of negated comparison operators on types which only implement
     /// `PartialOrd` (e.g., `f64`).
     ///
-    /// **Why is this bad?**
+    /// ### Why is this bad?
     /// These operators make it easy to forget that the underlying types actually allow not only three
     /// potential Orderings (Less, Equal, Greater) but also a fourth one (Uncomparable). This is
     /// especially easy to miss if the operator based comparison result is negated.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust
     /// use std::cmp::Ordering;
     ///
diff --git a/clippy_lints/src/neg_multiply.rs b/clippy_lints/src/neg_multiply.rs
index d5e1ea6d242..fa36d8fb1b3 100644
--- a/clippy_lints/src/neg_multiply.rs
+++ b/clippy_lints/src/neg_multiply.rs
@@ -7,13 +7,16 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for multiplication by -1 as a form of negation.
+    /// ### What it does
+    /// Checks for multiplication by -1 as a form of negation.
     ///
-    /// **Why is this bad?** It's more readable to just negate.
+    /// ### Why is this bad?
+    /// It's more readable to just negate.
     ///
-    /// **Known problems:** This only catches integers (for now).
+    /// ### Known problems
+    /// This only catches integers (for now).
     ///
-    /// **Example:**
+    /// ### Example
     /// ```ignore
     /// x * -1
     /// ```
diff --git a/clippy_lints/src/new_without_default.rs b/clippy_lints/src/new_without_default.rs
index bc409dd6efb..5c63d245bf1 100644
--- a/clippy_lints/src/new_without_default.rs
+++ b/clippy_lints/src/new_without_default.rs
@@ -13,18 +13,17 @@ use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::sym;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for types with a `fn new() -> Self` method and no
+    /// ### What it does
+    /// Checks for types with a `fn new() -> Self` method and no
     /// implementation of
     /// [`Default`](https://doc.rust-lang.org/std/default/trait.Default.html).
     ///
-    /// **Why is this bad?** The user might expect to be able to use
+    /// ### Why is this bad?
+    /// The user might expect to be able to use
     /// [`Default`](https://doc.rust-lang.org/std/default/trait.Default.html) as the
     /// type can be constructed without arguments.
     ///
-    /// **Known problems:** Hopefully none.
-    ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```ignore
     /// struct Foo(Bar);
     ///
diff --git a/clippy_lints/src/no_effect.rs b/clippy_lints/src/no_effect.rs
index 910b0536092..e07518b2586 100644
--- a/clippy_lints/src/no_effect.rs
+++ b/clippy_lints/src/no_effect.rs
@@ -9,15 +9,15 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use std::ops::Deref;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for statements which have no effect.
+    /// ### What it does
+    /// Checks for statements which have no effect.
     ///
-    /// **Why is this bad?** Similar to dead code, these statements are actually
+    /// ### Why is this bad?
+    /// Similar to dead code, these statements are actually
     /// executed. However, as they have no effect, all they do is make the code less
     /// readable.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// 0;
     /// ```
@@ -27,15 +27,15 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for expression statements that can be reduced to a
+    /// ### What it does
+    /// Checks for expression statements that can be reduced to a
     /// sub-expression.
     ///
-    /// **Why is this bad?** Expressions by themselves often have no side-effects.
+    /// ### Why is this bad?
+    /// Expressions by themselves often have no side-effects.
     /// Having such expressions reduces readability.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust,ignore
     /// compute_array()[0];
     /// ```
diff --git a/clippy_lints/src/non_copy_const.rs b/clippy_lints/src/non_copy_const.rs
index d775cd7c7f7..aa3067876eb 100644
--- a/clippy_lints/src/non_copy_const.rs
+++ b/clippy_lints/src/non_copy_const.rs
@@ -24,10 +24,12 @@ use rustc_typeck::hir_ty_to_ty;
 // FIXME: this is a correctness problem but there's no suitable
 // warn-by-default category.
 declare_clippy_lint! {
-    /// **What it does:** Checks for declaration of `const` items which is interior
+    /// ### What it does
+    /// Checks for declaration of `const` items which is interior
     /// mutable (e.g., contains a `Cell`, `Mutex`, `AtomicXxxx`, etc.).
     ///
-    /// **Why is this bad?** Consts are copied everywhere they are referenced, i.e.,
+    /// ### Why is this bad?
+    /// Consts are copied everywhere they are referenced, i.e.,
     /// every time you refer to the const a fresh instance of the `Cell` or `Mutex`
     /// or `AtomicXxxx` will be created, which defeats the whole purpose of using
     /// these types in the first place.
@@ -35,7 +37,8 @@ declare_clippy_lint! {
     /// The `const` should better be replaced by a `static` item if a global
     /// variable is wanted, or replaced by a `const fn` if a constructor is wanted.
     ///
-    /// **Known problems:** A "non-constant" const item is a legacy way to supply an
+    /// ### Known problems
+    /// A "non-constant" const item is a legacy way to supply an
     /// initialized value to downstream `static` items (e.g., the
     /// `std::sync::ONCE_INIT` constant). In this case the use of `const` is legit,
     /// and this lint should be suppressed.
@@ -52,7 +55,7 @@ declare_clippy_lint! {
     /// the interior mutable field is used or not. See issues
     /// [#5812](https://github.com/rust-lang/rust-clippy/issues/5812) and
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// use std::sync::atomic::{AtomicUsize, Ordering::SeqCst};
     ///
@@ -74,17 +77,20 @@ declare_clippy_lint! {
 // FIXME: this is a correctness problem but there's no suitable
 // warn-by-default category.
 declare_clippy_lint! {
-    /// **What it does:** Checks if `const` items which is interior mutable (e.g.,
+    /// ### What it does
+    /// Checks if `const` items which is interior mutable (e.g.,
     /// contains a `Cell`, `Mutex`, `AtomicXxxx`, etc.) has been borrowed directly.
     ///
-    /// **Why is this bad?** Consts are copied everywhere they are referenced, i.e.,
+    /// ### Why is this bad?
+    /// Consts are copied everywhere they are referenced, i.e.,
     /// every time you refer to the const a fresh instance of the `Cell` or `Mutex`
     /// or `AtomicXxxx` will be created, which defeats the whole purpose of using
     /// these types in the first place.
     ///
     /// The `const` value should be stored inside a `static` item.
     ///
-    /// **Known problems:** When an enum has variants with interior mutability, use of its non
+    /// ### Known problems
+    /// When an enum has variants with interior mutability, use of its non
     /// interior mutable variants can generate false positives. See issue
     /// [#3962](https://github.com/rust-lang/rust-clippy/issues/3962)
     ///
@@ -93,7 +99,7 @@ declare_clippy_lint! {
     /// [#5812](https://github.com/rust-lang/rust-clippy/issues/5812) and
     /// [#3825](https://github.com/rust-lang/rust-clippy/issues/3825)
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// use std::sync::atomic::{AtomicUsize, Ordering::SeqCst};
     /// const CONST_ATOM: AtomicUsize = AtomicUsize::new(12);
diff --git a/clippy_lints/src/non_expressive_names.rs b/clippy_lints/src/non_expressive_names.rs
index 7183a7c3858..dc55b103eb6 100644
--- a/clippy_lints/src/non_expressive_names.rs
+++ b/clippy_lints/src/non_expressive_names.rs
@@ -12,14 +12,14 @@ use rustc_span::symbol::{Ident, Symbol};
 use std::cmp::Ordering;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for names that are very similar and thus confusing.
+    /// ### What it does
+    /// Checks for names that are very similar and thus confusing.
     ///
-    /// **Why is this bad?** It's hard to distinguish between names that differ only
+    /// ### Why is this bad?
+    /// It's hard to distinguish between names that differ only
     /// by a single character.
     ///
-    /// **Known problems:** None?
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```ignore
     /// let checked_exp = something;
     /// let checked_expr = something_else;
@@ -30,15 +30,15 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for too many variables whose name consists of a
+    /// ### What it does
+    /// Checks for too many variables whose name consists of a
     /// single character.
     ///
-    /// **Why is this bad?** It's hard to memorize what a variable means without a
+    /// ### Why is this bad?
+    /// It's hard to memorize what a variable means without a
     /// descriptive name.
     ///
-    /// **Known problems:** None?
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```ignore
     /// let (a, b, c, d, e, f, g) = (...);
     /// ```
@@ -48,15 +48,15 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks if you have variables whose name consists of just
+    /// ### What it does
+    /// Checks if you have variables whose name consists of just
     /// underscores and digits.
     ///
-    /// **Why is this bad?** It's hard to memorize what a variable means without a
+    /// ### Why is this bad?
+    /// It's hard to memorize what a variable means without a
     /// descriptive name.
     ///
-    /// **Known problems:** None?
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// let _1 = 1;
     /// let ___1 = 1;
diff --git a/clippy_lints/src/non_octal_unix_permissions.rs b/clippy_lints/src/non_octal_unix_permissions.rs
index a83daea97bf..3b74f69d375 100644
--- a/clippy_lints/src/non_octal_unix_permissions.rs
+++ b/clippy_lints/src/non_octal_unix_permissions.rs
@@ -9,15 +9,14 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for non-octal values used to set Unix file permissions.
+    /// ### What it does
+    /// Checks for non-octal values used to set Unix file permissions.
     ///
-    /// **Why is this bad?** They will be converted into octal, creating potentially
+    /// ### Why is this bad?
+    /// They will be converted into octal, creating potentially
     /// unintended file permissions.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust,ignore
     /// use std::fs::OpenOptions;
     /// use std::os::unix::fs::OpenOptionsExt;
diff --git a/clippy_lints/src/nonstandard_macro_braces.rs b/clippy_lints/src/nonstandard_macro_braces.rs
index 043e7fa30d6..dbe9cbe0ded 100644
--- a/clippy_lints/src/nonstandard_macro_braces.rs
+++ b/clippy_lints/src/nonstandard_macro_braces.rs
@@ -13,16 +13,14 @@ use rustc_span::Span;
 use serde::{de, Deserialize};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks that common macros are used with consistent bracing.
+    /// ### What it does
+    /// Checks that common macros are used with consistent bracing.
     ///
-    /// **Why is this bad?** This is mostly a consistency lint although using () or []
+    /// ### Why is this bad?
+    /// This is mostly a consistency lint although using () or []
     /// doesn't give you a semicolon in item position, which can be unexpected.
     ///
-    /// **Known problems:**
-    /// None
-    ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust
     /// vec!{1, 2, 3};
     /// ```
diff --git a/clippy_lints/src/open_options.rs b/clippy_lints/src/open_options.rs
index fded48038e3..4064d94da2a 100644
--- a/clippy_lints/src/open_options.rs
+++ b/clippy_lints/src/open_options.rs
@@ -8,15 +8,15 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::{Span, Spanned};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for duplicate open options as well as combinations
+    /// ### What it does
+    /// Checks for duplicate open options as well as combinations
     /// that make no sense.
     ///
-    /// **Why is this bad?** In the best case, the code will be harder to read than
+    /// ### Why is this bad?
+    /// In the best case, the code will be harder to read than
     /// necessary. I don't know the worst case.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// use std::fs::OpenOptions;
     ///
diff --git a/clippy_lints/src/option_env_unwrap.rs b/clippy_lints/src/option_env_unwrap.rs
index b6f518661bd..d7306628030 100644
--- a/clippy_lints/src/option_env_unwrap.rs
+++ b/clippy_lints/src/option_env_unwrap.rs
@@ -7,17 +7,16 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::sym;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for usage of `option_env!(...).unwrap()` and
+    /// ### What it does
+    /// Checks for usage of `option_env!(...).unwrap()` and
     /// suggests usage of the `env!` macro.
     ///
-    /// **Why is this bad?** Unwrapping the result of `option_env!` will panic
+    /// ### Why is this bad?
+    /// Unwrapping the result of `option_env!` will panic
     /// at run-time if the environment variable doesn't exist, whereas `env!`
     /// catches it at compile-time.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust,no_run
     /// let _ = option_env!("HOME").unwrap();
     /// ```
diff --git a/clippy_lints/src/option_if_let_else.rs b/clippy_lints/src/option_if_let_else.rs
index b2be35bdddb..7aef3a5f34c 100644
--- a/clippy_lints/src/option_if_let_else.rs
+++ b/clippy_lints/src/option_if_let_else.rs
@@ -12,24 +12,23 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::sym;
 
 declare_clippy_lint! {
-    /// **What it does:**
+    /// ### What it does
     /// Lints usage of `if let Some(v) = ... { y } else { x }` which is more
     /// idiomatically done with `Option::map_or` (if the else bit is a pure
     /// expression) or `Option::map_or_else` (if the else bit is an impure
     /// expression).
     ///
-    /// **Why is this bad?**
+    /// ### Why is this bad?
     /// Using the dedicated functions of the Option type is clearer and
     /// more concise than an `if let` expression.
     ///
-    /// **Known problems:**
+    /// ### Known problems
     /// This lint uses a deliberately conservative metric for checking
     /// if the inside of either body contains breaks or continues which will
     /// cause it to not suggest a fix if either block contains a loop with
     /// continues or breaks contained within the loop.
     ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust
     /// # let optional: Option<u32> = Some(0);
     /// # fn do_complicated_function() -> u32 { 5 };
diff --git a/clippy_lints/src/overflow_check_conditional.rs b/clippy_lints/src/overflow_check_conditional.rs
index e222782c2cc..34755afdb72 100644
--- a/clippy_lints/src/overflow_check_conditional.rs
+++ b/clippy_lints/src/overflow_check_conditional.rs
@@ -6,14 +6,14 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
-    /// **What it does:** Detects classic underflow/overflow checks.
+    /// ### What it does
+    /// Detects classic underflow/overflow checks.
     ///
-    /// **Why is this bad?** Most classic C underflow/overflow checks will fail in
+    /// ### Why is this bad?
+    /// Most classic C underflow/overflow checks will fail in
     /// Rust. Users can use functions like `overflowing_*` and `wrapping_*` instead.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// # let a = 1;
     /// # let b = 2;
diff --git a/clippy_lints/src/panic_in_result_fn.rs b/clippy_lints/src/panic_in_result_fn.rs
index cef74d87e7c..e2b6ba8e2d2 100644
--- a/clippy_lints/src/panic_in_result_fn.rs
+++ b/clippy_lints/src/panic_in_result_fn.rs
@@ -8,14 +8,16 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::{sym, Span};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for usage of `panic!`, `unimplemented!`, `todo!`, `unreachable!` or assertions in a function of type result.
+    /// ### What it does
+    /// Checks for usage of `panic!`, `unimplemented!`, `todo!`, `unreachable!` or assertions in a function of type result.
     ///
-    /// **Why is this bad?** For some codebases, it is desirable for functions of type result to return an error instead of crashing. Hence panicking macros should be avoided.
+    /// ### Why is this bad?
+    /// For some codebases, it is desirable for functions of type result to return an error instead of crashing. Hence panicking macros should be avoided.
     ///
-    /// **Known problems:** Functions called from a function returning a `Result` may invoke a panicking macro. This is not checked.
-    ///
-    /// **Example:**
+    /// ### Known problems
+    /// Functions called from a function returning a `Result` may invoke a panicking macro. This is not checked.
     ///
+    /// ### Example
     /// ```rust
     /// fn result_with_panic() -> Result<bool, String>
     /// {
diff --git a/clippy_lints/src/panic_unimplemented.rs b/clippy_lints/src/panic_unimplemented.rs
index dc28874c16e..d8d9081d6f1 100644
--- a/clippy_lints/src/panic_unimplemented.rs
+++ b/clippy_lints/src/panic_unimplemented.rs
@@ -7,13 +7,13 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::Span;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for usage of `panic!`.
+    /// ### What it does
+    /// Checks for usage of `panic!`.
     ///
-    /// **Why is this bad?** `panic!` will stop the execution of the executable
+    /// ### Why is this bad?
+    /// `panic!` will stop the execution of the executable
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```no_run
     /// panic!("even with a good reason");
     /// ```
@@ -23,13 +23,13 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for usage of `unimplemented!`.
-    ///
-    /// **Why is this bad?** This macro should not be present in production code
+    /// ### What it does
+    /// Checks for usage of `unimplemented!`.
     ///
-    /// **Known problems:** None.
+    /// ### Why is this bad?
+    /// This macro should not be present in production code
     ///
-    /// **Example:**
+    /// ### Example
     /// ```no_run
     /// unimplemented!();
     /// ```
@@ -39,13 +39,13 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for usage of `todo!`.
+    /// ### What it does
+    /// Checks for usage of `todo!`.
     ///
-    /// **Why is this bad?** This macro should not be present in production code
+    /// ### Why is this bad?
+    /// This macro should not be present in production code
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```no_run
     /// todo!();
     /// ```
@@ -55,13 +55,13 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for usage of `unreachable!`.
-    ///
-    /// **Why is this bad?** This macro can cause code to panic
+    /// ### What it does
+    /// Checks for usage of `unreachable!`.
     ///
-    /// **Known problems:** None.
+    /// ### Why is this bad?
+    /// This macro can cause code to panic
     ///
-    /// **Example:**
+    /// ### Example
     /// ```no_run
     /// unreachable!();
     /// ```
diff --git a/clippy_lints/src/partialeq_ne_impl.rs b/clippy_lints/src/partialeq_ne_impl.rs
index 1251ddd9a02..4ec493e5f45 100644
--- a/clippy_lints/src/partialeq_ne_impl.rs
+++ b/clippy_lints/src/partialeq_ne_impl.rs
@@ -7,16 +7,16 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::sym;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for manual re-implementations of `PartialEq::ne`.
+    /// ### What it does
+    /// Checks for manual re-implementations of `PartialEq::ne`.
     ///
-    /// **Why is this bad?** `PartialEq::ne` is required to always return the
+    /// ### Why is this bad?
+    /// `PartialEq::ne` is required to always return the
     /// negated result of `PartialEq::eq`, which is exactly what the default
     /// implementation does. Therefore, there should never be any need to
     /// re-implement it.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// struct Foo;
     ///
diff --git a/clippy_lints/src/pass_by_ref_or_value.rs b/clippy_lints/src/pass_by_ref_or_value.rs
index f6a70478559..f738ac25417 100644
--- a/clippy_lints/src/pass_by_ref_or_value.rs
+++ b/clippy_lints/src/pass_by_ref_or_value.rs
@@ -20,15 +20,18 @@ use rustc_target::spec::abi::Abi;
 use rustc_target::spec::Target;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for functions taking arguments by reference, where
+    /// ### What it does
+    /// Checks for functions taking arguments by reference, where
     /// the argument type is `Copy` and small enough to be more efficient to always
     /// pass by value.
     ///
-    /// **Why is this bad?** In many calling conventions instances of structs will
+    /// ### Why is this bad?
+    /// In many calling conventions instances of structs will
     /// be passed through registers if they fit into two or less general purpose
     /// registers.
     ///
-    /// **Known problems:** This lint is target register size dependent, it is
+    /// ### Known problems
+    /// This lint is target register size dependent, it is
     /// limited to 32-bit to try and reduce portability problems between 32 and
     /// 64-bit, but if you are compiling for 8 or 16-bit targets then the limit
     /// will be different.
@@ -50,7 +53,7 @@ declare_clippy_lint! {
     /// that explains a real case in which this false positive
     /// led to an **undefined behaviour** introduced with unsafe code.
     ///
-    /// **Example:**
+    /// ### Example
     ///
     /// ```rust
     /// // Bad
@@ -67,18 +70,19 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for functions taking arguments by value, where
+    /// ### What it does
+    /// Checks for functions taking arguments by value, where
     /// the argument type is `Copy` and large enough to be worth considering
     /// passing by reference. Does not trigger if the function is being exported,
     /// because that might induce API breakage, if the parameter is declared as mutable,
     /// or if the argument is a `self`.
     ///
-    /// **Why is this bad?** Arguments passed by value might result in an unnecessary
+    /// ### Why is this bad?
+    /// Arguments passed by value might result in an unnecessary
     /// shallow copy, taking up more space in the stack and requiring a call to
     /// `memcpy`, which can be expensive.
     ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust
     /// #[derive(Clone, Copy)]
     /// struct TooLarge([u8; 2048]);
diff --git a/clippy_lints/src/path_buf_push_overwrite.rs b/clippy_lints/src/path_buf_push_overwrite.rs
index 00245926381..3df7a72d295 100644
--- a/clippy_lints/src/path_buf_push_overwrite.rs
+++ b/clippy_lints/src/path_buf_push_overwrite.rs
@@ -10,15 +10,15 @@ use rustc_span::symbol::sym;
 use std::path::{Component, Path};
 
 declare_clippy_lint! {
-    /// **What it does:*** Checks for [push](https://doc.rust-lang.org/std/path/struct.PathBuf.html#method.push)
+    /// ### What it does
+    ///* Checks for [push](https://doc.rust-lang.org/std/path/struct.PathBuf.html#method.push)
     /// calls on `PathBuf` that can cause overwrites.
     ///
-    /// **Why is this bad?** Calling `push` with a root path at the start can overwrite the
+    /// ### Why is this bad?
+    /// Calling `push` with a root path at the start can overwrite the
     /// previous defined path.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// use std::path::PathBuf;
     ///
diff --git a/clippy_lints/src/pattern_type_mismatch.rs b/clippy_lints/src/pattern_type_mismatch.rs
index ea4065d371b..4534f6e2516 100644
--- a/clippy_lints/src/pattern_type_mismatch.rs
+++ b/clippy_lints/src/pattern_type_mismatch.rs
@@ -13,7 +13,8 @@ use rustc_span::source_map::Span;
 use std::iter;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for patterns that aren't exact representations of the types
+    /// ### What it does
+    /// Checks for patterns that aren't exact representations of the types
     /// they are applied to.
     ///
     /// To satisfy this lint, you will have to adjust either the expression that is matched
@@ -32,14 +33,12 @@ declare_clippy_lint! {
     /// this lint can still be used to highlight areas of interest and ensure a good understanding
     /// of ownership semantics.
     ///
-    /// **Why is this bad?** It isn't bad in general. But in some contexts it can be desirable
+    /// ### Why is this bad?
+    /// It isn't bad in general. But in some contexts it can be desirable
     /// because it increases ownership hints in the code, and will guard against some changes
     /// in ownership.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// This example shows the basic adjustments necessary to satisfy the lint. Note how
     /// the matched expression is explicitly dereferenced with `*` and the `inner` variable
     /// is bound to a shared borrow via `ref inner`.
diff --git a/clippy_lints/src/precedence.rs b/clippy_lints/src/precedence.rs
index 9cf00c953b9..1a8da00d9d6 100644
--- a/clippy_lints/src/precedence.rs
+++ b/clippy_lints/src/precedence.rs
@@ -25,7 +25,8 @@ const ALLOWED_ODD_FUNCTIONS: [&str; 14] = [
 ];
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for operations where precedence may be unclear
+    /// ### What it does
+    /// Checks for operations where precedence may be unclear
     /// and suggests to add parentheses. Currently it catches the following:
     /// * mixed usage of arithmetic and bit shifting/combining operators without
     /// parentheses
@@ -33,13 +34,12 @@ declare_clippy_lint! {
     /// numeric literal)
     ///   followed by a method call
     ///
-    /// **Why is this bad?** Not everyone knows the precedence of those operators by
+    /// ### Why is this bad?
+    /// Not everyone knows the precedence of those operators by
     /// heart, so expressions like these may trip others trying to reason about the
     /// code.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// * `1 << 2 + 3` equals 32, while `(1 << 2) + 3` equals 7
     /// * `-1i32.abs()` equals -1, while `(-1i32).abs()` equals 1
     pub PRECEDENCE,
diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs
index b15447622a8..c0d1f1eb6e6 100644
--- a/clippy_lints/src/ptr.rs
+++ b/clippy_lints/src/ptr.rs
@@ -20,16 +20,19 @@ use rustc_span::{sym, MultiSpan};
 use std::borrow::Cow;
 
 declare_clippy_lint! {
-    /// **What it does:** This lint checks for function arguments of type `&String`
+    /// ### What it does
+    /// This lint checks for function arguments of type `&String`
     /// or `&Vec` unless the references are mutable. It will also suggest you
     /// replace `.clone()` calls with the appropriate `.to_owned()`/`to_string()`
     /// calls.
     ///
-    /// **Why is this bad?** Requiring the argument to be of the specific size
+    /// ### Why is this bad?
+    /// Requiring the argument to be of the specific size
     /// makes the function less useful for no benefit; slices in the form of `&[T]`
     /// or `&str` usually suffice and can be obtained from other types, too.
     ///
-    /// **Known problems:** The lint does not follow data. So if you have an
+    /// ### Known problems
+    /// The lint does not follow data. So if you have an
     /// argument `x` and write `let y = x; y.clone()` the lint will not suggest
     /// changing that `.clone()` to `.to_owned()`.
     ///
@@ -59,7 +62,7 @@ declare_clippy_lint! {
     /// other crates referencing it, of which you may not be aware. Carefully
     /// deprecate the function before applying the lint suggestions in this case.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```ignore
     /// // Bad
     /// fn foo(&Vec<u32>) { .. }
@@ -73,15 +76,15 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** This lint checks for equality comparisons with `ptr::null`
+    /// ### What it does
+    /// This lint checks for equality comparisons with `ptr::null`
     ///
-    /// **Why is this bad?** It's easier and more readable to use the inherent
+    /// ### Why is this bad?
+    /// It's easier and more readable to use the inherent
     /// `.is_null()`
     /// method instead
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```ignore
     /// // Bad
     /// if x == ptr::null {
@@ -99,19 +102,22 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** This lint checks for functions that take immutable
+    /// ### What it does
+    /// This lint checks for functions that take immutable
     /// references and return mutable ones.
     ///
-    /// **Why is this bad?** This is trivially unsound, as one can create two
+    /// ### Why is this bad?
+    /// This is trivially unsound, as one can create two
     /// mutable references from the same (immutable!) source.
     /// This [error](https://github.com/rust-lang/rust/issues/39465)
     /// actually lead to an interim Rust release 1.15.1.
     ///
-    /// **Known problems:** To be on the conservative side, if there's at least one
+    /// ### Known problems
+    /// To be on the conservative side, if there's at least one
     /// mutable reference with the output lifetime, this lint will not trigger.
     /// In practice, this case is unlikely anyway.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```ignore
     /// fn foo(&Foo) -> &mut Bar { .. }
     /// ```
@@ -121,13 +127,13 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** This lint checks for invalid usages of `ptr::null`.
-    ///
-    /// **Why is this bad?** This causes undefined behavior.
+    /// ### What it does
+    /// This lint checks for invalid usages of `ptr::null`.
     ///
-    /// **Known problems:** None.
+    /// ### Why is this bad?
+    /// This causes undefined behavior.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```ignore
     /// // Bad. Undefined behavior
     /// unsafe { std::slice::from_raw_parts(ptr::null(), 0); }
diff --git a/clippy_lints/src/ptr_eq.rs b/clippy_lints/src/ptr_eq.rs
index 77cfa3f6b17..d6d7049fb61 100644
--- a/clippy_lints/src/ptr_eq.rs
+++ b/clippy_lints/src/ptr_eq.rs
@@ -8,16 +8,15 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
-    /// **What it does:** Use `std::ptr::eq` when applicable
+    /// ### What it does
+    /// Use `std::ptr::eq` when applicable
     ///
-    /// **Why is this bad?** `ptr::eq` can be used to compare `&T` references
+    /// ### Why is this bad?
+    /// `ptr::eq` can be used to compare `&T` references
     /// (which coerce to `*const T` implicitly) by their address rather than
     /// comparing the values they point to.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust
     /// let a = &[1, 2, 3];
     /// let b = &[1, 2, 3];
diff --git a/clippy_lints/src/ptr_offset_with_cast.rs b/clippy_lints/src/ptr_offset_with_cast.rs
index afb198f4955..f1975056ddc 100644
--- a/clippy_lints/src/ptr_offset_with_cast.rs
+++ b/clippy_lints/src/ptr_offset_with_cast.rs
@@ -8,15 +8,15 @@ use rustc_span::sym;
 use std::fmt;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for usage of the `offset` pointer method with a `usize` casted to an
+    /// ### What it does
+    /// Checks for usage of the `offset` pointer method with a `usize` casted to an
     /// `isize`.
     ///
-    /// **Why is this bad?** If we’re always increasing the pointer address, we can avoid the numeric
+    /// ### Why is this bad?
+    /// If we’re always increasing the pointer address, we can avoid the numeric
     /// cast by using the `add` method instead.
     ///
-    /// **Known problems:** None
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// let vec = vec![b'a', b'b', b'c'];
     /// let ptr = vec.as_ptr();
diff --git a/clippy_lints/src/question_mark.rs b/clippy_lints/src/question_mark.rs
index d66bac52243..0e682c692c7 100644
--- a/clippy_lints/src/question_mark.rs
+++ b/clippy_lints/src/question_mark.rs
@@ -13,13 +13,13 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::sym;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for expressions that could be replaced by the question mark operator.
+    /// ### What it does
+    /// Checks for expressions that could be replaced by the question mark operator.
     ///
-    /// **Why is this bad?** Question mark usage is more idiomatic.
+    /// ### Why is this bad?
+    /// Question mark usage is more idiomatic.
     ///
-    /// **Known problems:** None
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```ignore
     /// if option.is_none() {
     ///     return None;
diff --git a/clippy_lints/src/ranges.rs b/clippy_lints/src/ranges.rs
index b41c478c266..0179bd48ee3 100644
--- a/clippy_lints/src/ranges.rs
+++ b/clippy_lints/src/ranges.rs
@@ -18,14 +18,14 @@ use rustc_span::symbol::Ident;
 use std::cmp::Ordering;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for zipping a collection with the range of
+    /// ### What it does
+    /// Checks for zipping a collection with the range of
     /// `0.._.len()`.
     ///
-    /// **Why is this bad?** The code is better expressed with `.enumerate()`.
+    /// ### Why is this bad?
+    /// The code is better expressed with `.enumerate()`.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// # let x = vec![1];
     /// x.iter().zip(0..x.len());
@@ -41,13 +41,16 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for exclusive ranges where 1 is added to the
+    /// ### What it does
+    /// Checks for exclusive ranges where 1 is added to the
     /// upper bound, e.g., `x..(y+1)`.
     ///
-    /// **Why is this bad?** The code is more readable with an inclusive range
+    /// ### Why is this bad?
+    /// The code is more readable with an inclusive range
     /// like `x..=y`.
     ///
-    /// **Known problems:** Will add unnecessary pair of parentheses when the
+    /// ### Known problems
+    /// Will add unnecessary pair of parentheses when the
     /// expression is not wrapped in a pair but starts with a opening parenthesis
     /// and ends with a closing one.
     /// I.e., `let _ = (f()+1)..(f()+1)` results in `let _ = ((f()+1)..=f())`.
@@ -61,7 +64,7 @@ declare_clippy_lint! {
     /// `RangeBounds` trait
     /// ([#3307](https://github.com/rust-lang/rust-clippy/issues/3307)).
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust,ignore
     /// for x..(y+1) { .. }
     /// ```
@@ -75,18 +78,21 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for inclusive ranges where 1 is subtracted from
+    /// ### What it does
+    /// Checks for inclusive ranges where 1 is subtracted from
     /// the upper bound, e.g., `x..=(y-1)`.
     ///
-    /// **Why is this bad?** The code is more readable with an exclusive range
+    /// ### Why is this bad?
+    /// The code is more readable with an exclusive range
     /// like `x..y`.
     ///
-    /// **Known problems:** This will cause a warning that cannot be fixed if
+    /// ### Known problems
+    /// This will cause a warning that cannot be fixed if
     /// the consumer of the range only accepts a specific range type, instead of
     /// the generic `RangeBounds` trait
     /// ([#3307](https://github.com/rust-lang/rust-clippy/issues/3307)).
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust,ignore
     /// for x..=(y-1) { .. }
     /// ```
@@ -100,16 +106,15 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for range expressions `x..y` where both `x` and `y`
+    /// ### What it does
+    /// Checks for range expressions `x..y` where both `x` and `y`
     /// are constant and `x` is greater or equal to `y`.
     ///
-    /// **Why is this bad?** Empty ranges yield no values so iterating them is a no-op.
+    /// ### Why is this bad?
+    /// Empty ranges yield no values so iterating them is a no-op.
     /// Moreover, trying to use a reversed range to index a slice will panic at run-time.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust,no_run
     /// fn main() {
     ///     (10..=0).for_each(|x| println!("{}", x));
@@ -133,16 +138,15 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for expressions like `x >= 3 && x < 8` that could
+    /// ### What it does
+    /// Checks for expressions like `x >= 3 && x < 8` that could
     /// be more readably expressed as `(3..8).contains(x)`.
     ///
-    /// **Why is this bad?** `contains` expresses the intent better and has less
+    /// ### Why is this bad?
+    /// `contains` expresses the intent better and has less
     /// failure modes (such as fencepost errors or using `||` instead of `&&`).
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust
     /// // given
     /// let x = 6;
diff --git a/clippy_lints/src/redundant_clone.rs b/clippy_lints/src/redundant_clone.rs
index 56ef95a88c8..530b3396abe 100644
--- a/clippy_lints/src/redundant_clone.rs
+++ b/clippy_lints/src/redundant_clone.rs
@@ -32,17 +32,18 @@ macro_rules! unwrap_or_continue {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for a redundant `clone()` (and its relatives) which clones an owned
+    /// ### What it does
+    /// Checks for a redundant `clone()` (and its relatives) which clones an owned
     /// value that is going to be dropped without further use.
     ///
-    /// **Why is this bad?** It is not always possible for the compiler to eliminate useless
+    /// ### Why is this bad?
+    /// It is not always possible for the compiler to eliminate useless
     /// allocations and deallocations generated by redundant `clone()`s.
     ///
-    /// **Known problems:**
-    ///
+    /// ### Known problems
     /// False-negatives: analysis performed by this lint is conservative and limited.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// # use std::path::Path;
     /// # #[derive(Clone)]
diff --git a/clippy_lints/src/redundant_closure_call.rs b/clippy_lints/src/redundant_closure_call.rs
index 8f56a21ac5b..a79b2fe76e2 100644
--- a/clippy_lints/src/redundant_closure_call.rs
+++ b/clippy_lints/src/redundant_closure_call.rs
@@ -14,15 +14,15 @@ use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
-    /// **What it does:** Detects closures called in the same expression where they
+    /// ### What it does
+    /// Detects closures called in the same expression where they
     /// are defined.
     ///
-    /// **Why is this bad?** It is unnecessarily adding to the expression's
+    /// ### Why is this bad?
+    /// It is unnecessarily adding to the expression's
     /// complexity.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust,ignore
     /// // Bad
     /// let a = (|| 42)()
diff --git a/clippy_lints/src/redundant_else.rs b/clippy_lints/src/redundant_else.rs
index 061526c6f09..68b256d2944 100644
--- a/clippy_lints/src/redundant_else.rs
+++ b/clippy_lints/src/redundant_else.rs
@@ -6,14 +6,16 @@ use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for `else` blocks that can be removed without changing semantics.
+    /// ### What it does
+    /// Checks for `else` blocks that can be removed without changing semantics.
     ///
-    /// **Why is this bad?** The `else` block adds unnecessary indentation and verbosity.
+    /// ### Why is this bad?
+    /// The `else` block adds unnecessary indentation and verbosity.
     ///
-    /// **Known problems:** Some may prefer to keep the `else` block for clarity.
-    ///
-    /// **Example:**
+    /// ### Known problems
+    /// Some may prefer to keep the `else` block for clarity.
     ///
+    /// ### Example
     /// ```rust
     /// fn my_func(count: u32) {
     ///     if count == 0 {
diff --git a/clippy_lints/src/redundant_field_names.rs b/clippy_lints/src/redundant_field_names.rs
index d5ee8d3468d..47df4917510 100644
--- a/clippy_lints/src/redundant_field_names.rs
+++ b/clippy_lints/src/redundant_field_names.rs
@@ -8,15 +8,15 @@ use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for fields in struct literals where shorthands
+    /// ### What it does
+    /// Checks for fields in struct literals where shorthands
     /// could be used.
     ///
-    /// **Why is this bad?** If the field and variable names are the same,
+    /// ### Why is this bad?
+    /// If the field and variable names are the same,
     /// the field name is redundant.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// let bar: u8 = 123;
     ///
diff --git a/clippy_lints/src/redundant_pub_crate.rs b/clippy_lints/src/redundant_pub_crate.rs
index 05f9e01acb4..59a55b9dffa 100644
--- a/clippy_lints/src/redundant_pub_crate.rs
+++ b/clippy_lints/src/redundant_pub_crate.rs
@@ -5,16 +5,15 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for items declared `pub(crate)` that are not crate visible because they
+    /// ### What it does
+    /// Checks for items declared `pub(crate)` that are not crate visible because they
     /// are inside a private module.
     ///
-    /// **Why is this bad?** Writing `pub(crate)` is misleading when it's redundant due to the parent
+    /// ### Why is this bad?
+    /// Writing `pub(crate)` is misleading when it's redundant due to the parent
     /// module's visibility.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust
     /// mod internal {
     ///     pub(crate) fn internal_fn() { }
diff --git a/clippy_lints/src/redundant_slicing.rs b/clippy_lints/src/redundant_slicing.rs
index 9c6cd7b4fa6..290348c4509 100644
--- a/clippy_lints/src/redundant_slicing.rs
+++ b/clippy_lints/src/redundant_slicing.rs
@@ -10,17 +10,19 @@ use rustc_middle::ty::TyS;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for redundant slicing expressions which use the full range, and
+    /// ### What it does
+    /// Checks for redundant slicing expressions which use the full range, and
     /// do not change the type.
     ///
-    /// **Why is this bad?** It unnecessarily adds complexity to the expression.
+    /// ### Why is this bad?
+    /// It unnecessarily adds complexity to the expression.
     ///
-    /// **Known problems:** If the type being sliced has an implementation of `Index<RangeFull>`
+    /// ### Known problems
+    /// If the type being sliced has an implementation of `Index<RangeFull>`
     /// that actually changes anything then it can't be removed. However, this would be surprising
     /// to people reading the code and should have a note with it.
     ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```ignore
     /// fn get_slice(x: &[u32]) -> &[u32] {
     ///     &x[..]
diff --git a/clippy_lints/src/redundant_static_lifetimes.rs b/clippy_lints/src/redundant_static_lifetimes.rs
index 48107d9c037..d5a1a61da6b 100644
--- a/clippy_lints/src/redundant_static_lifetimes.rs
+++ b/clippy_lints/src/redundant_static_lifetimes.rs
@@ -8,14 +8,14 @@ use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for constants and statics with an explicit `'static` lifetime.
+    /// ### What it does
+    /// Checks for constants and statics with an explicit `'static` lifetime.
     ///
-    /// **Why is this bad?** Adding `'static` to every reference can create very
+    /// ### Why is this bad?
+    /// Adding `'static` to every reference can create very
     /// complicated types.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```ignore
     /// const FOO: &'static [(&'static str, &'static str, fn(&Bar) -> bool)] =
     /// &[...]
diff --git a/clippy_lints/src/ref_option_ref.rs b/clippy_lints/src/ref_option_ref.rs
index 0cf4e0ce7fe..65ab6cac442 100644
--- a/clippy_lints/src/ref_option_ref.rs
+++ b/clippy_lints/src/ref_option_ref.rs
@@ -9,16 +9,18 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::symbol::sym;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for usage of `&Option<&T>`.
+    /// ### What it does
+    /// Checks for usage of `&Option<&T>`.
     ///
-    /// **Why is this bad?** Since `&` is Copy, it's useless to have a
+    /// ### Why is this bad?
+    /// Since `&` is Copy, it's useless to have a
     /// reference on `Option<&T>`.
     ///
-    /// **Known problems:** It may be irrelevant to use this lint on
+    /// ### Known problems
+    /// It may be irrelevant to use this lint on
     /// public API code as it will make a breaking change to apply it.
     ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust,ignore
     /// let x: &Option<&u32> = &Some(&0u32);
     /// ```
diff --git a/clippy_lints/src/reference.rs b/clippy_lints/src/reference.rs
index d6336389b0a..e0930d69ab9 100644
--- a/clippy_lints/src/reference.rs
+++ b/clippy_lints/src/reference.rs
@@ -10,15 +10,18 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::BytePos;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for usage of `*&` and `*&mut` in expressions.
+    /// ### What it does
+    /// Checks for usage of `*&` and `*&mut` in expressions.
     ///
-    /// **Why is this bad?** Immediately dereferencing a reference is no-op and
+    /// ### Why is this bad?
+    /// Immediately dereferencing a reference is no-op and
     /// makes the code less clear.
     ///
-    /// **Known problems:** Multiple dereference/addrof pairs are not handled so
+    /// ### Known problems
+    /// Multiple dereference/addrof pairs are not handled so
     /// the suggested fix for `x = **&&y` is `x = *&y`, which is still incorrect.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust,ignore
     /// // Bad
     /// let a = f(*&mut b);
@@ -101,13 +104,15 @@ impl EarlyLintPass for DerefAddrOf {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for references in expressions that use
+    /// ### What it does
+    /// Checks for references in expressions that use
     /// auto dereference.
     ///
-    /// **Why is this bad?** The reference is a no-op and is automatically
+    /// ### Why is this bad?
+    /// The reference is a no-op and is automatically
     /// dereferenced by the compiler and makes the code less clear.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// struct Point(u32, u32);
     /// let point = Point(30, 20);
diff --git a/clippy_lints/src/regex.rs b/clippy_lints/src/regex.rs
index 75151167454..eab09733730 100644
--- a/clippy_lints/src/regex.rs
+++ b/clippy_lints/src/regex.rs
@@ -11,15 +11,15 @@ use rustc_span::source_map::{BytePos, Span};
 use std::convert::TryFrom;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks [regex](https://crates.io/crates/regex) creation
+    /// ### What it does
+    /// Checks [regex](https://crates.io/crates/regex) creation
     /// (with `Regex::new`, `RegexBuilder::new`, or `RegexSet::new`) for correct
     /// regex syntax.
     ///
-    /// **Why is this bad?** This will lead to a runtime panic.
+    /// ### Why is this bad?
+    /// This will lead to a runtime panic.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```ignore
     /// Regex::new("|")
     /// ```
@@ -29,18 +29,21 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for trivial [regex](https://crates.io/crates/regex)
+    /// ### What it does
+    /// Checks for trivial [regex](https://crates.io/crates/regex)
     /// creation (with `Regex::new`, `RegexBuilder::new`, or `RegexSet::new`).
     ///
-    /// **Why is this bad?** Matching the regex can likely be replaced by `==` or
+    /// ### Why is this bad?
+    /// Matching the regex can likely be replaced by `==` or
     /// `str::starts_with`, `str::ends_with` or `std::contains` or other `str`
     /// methods.
     ///
-    /// **Known problems:** If the same regex is going to be applied to multiple
+    /// ### Known problems
+    /// If the same regex is going to be applied to multiple
     /// inputs, the precomputations done by `Regex` construction can give
     /// significantly better performance than any of the `str`-based methods.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```ignore
     /// Regex::new("^foobar")
     /// ```
diff --git a/clippy_lints/src/repeat_once.rs b/clippy_lints/src/repeat_once.rs
index 17cb96bc4eb..54b9c8b3275 100644
--- a/clippy_lints/src/repeat_once.rs
+++ b/clippy_lints/src/repeat_once.rs
@@ -11,7 +11,8 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::sym;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for usage of `.repeat(1)` and suggest the following method for each types.
+    /// ### What it does
+    /// Checks for usage of `.repeat(1)` and suggest the following method for each types.
     /// - `.to_string()` for `str`
     /// - `.clone()` for `String`
     /// - `.to_vec()` for `slice`
@@ -19,13 +20,11 @@ declare_clippy_lint! {
     /// The lint will evaluate constant expressions and values as arguments of `.repeat(..)` and emit a message if
     /// they are equivalent to `1`. (Related discussion in [rust-clippy#7306](https://github.com/rust-lang/rust-clippy/issues/7306))
     ///
-    /// **Why is this bad?** For example, `String.repeat(1)` is equivalent to `.clone()`. If cloning
+    /// ### Why is this bad?
+    /// For example, `String.repeat(1)` is equivalent to `.clone()`. If cloning
     /// the string is the intention behind this, `clone()` should be used.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust
     /// fn main() {
     ///     let x = String::from("hello world").repeat(1);
diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
index 251d527c265..db4b1002ce1 100644
--- a/clippy_lints/src/returns.rs
+++ b/clippy_lints/src/returns.rs
@@ -15,15 +15,15 @@ use rustc_span::source_map::Span;
 use rustc_span::sym;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for `let`-bindings, which are subsequently
+    /// ### What it does
+    /// Checks for `let`-bindings, which are subsequently
     /// returned.
     ///
-    /// **Why is this bad?** It is just extraneous code. Remove it to make your code
+    /// ### Why is this bad?
+    /// It is just extraneous code. Remove it to make your code
     /// more rusty.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// fn foo() -> String {
     ///     let x = String::new();
@@ -42,14 +42,14 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for return statements at the end of a block.
+    /// ### What it does
+    /// Checks for return statements at the end of a block.
     ///
-    /// **Why is this bad?** Removing the `return` and semicolon will make the code
+    /// ### Why is this bad?
+    /// Removing the `return` and semicolon will make the code
     /// more rusty.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// fn foo(x: usize) -> usize {
     ///     return x;
diff --git a/clippy_lints/src/self_assignment.rs b/clippy_lints/src/self_assignment.rs
index e7925c4fbde..fbd65fef7d1 100644
--- a/clippy_lints/src/self_assignment.rs
+++ b/clippy_lints/src/self_assignment.rs
@@ -6,16 +6,18 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for explicit self-assignments.
+    /// ### What it does
+    /// Checks for explicit self-assignments.
     ///
-    /// **Why is this bad?** Self-assignments are redundant and unlikely to be
+    /// ### Why is this bad?
+    /// Self-assignments are redundant and unlikely to be
     /// intentional.
     ///
-    /// **Known problems:** If expression contains any deref coercions or
+    /// ### Known problems
+    /// If expression contains any deref coercions or
     /// indexing operations they are assumed not to have any side effects.
     ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust
     /// struct Event {
     ///     id: usize,
diff --git a/clippy_lints/src/self_named_constructor.rs b/clippy_lints/src/self_named_constructor.rs
index da991e1d90c..2123a14cc1b 100644
--- a/clippy_lints/src/self_named_constructor.rs
+++ b/clippy_lints/src/self_named_constructor.rs
@@ -6,14 +6,13 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
-    /// **What it does:** Warns when constructors have the same name as their types.
+    /// ### What it does
+    /// Warns when constructors have the same name as their types.
     ///
-    /// **Why is this bad?** Repeating the name of the type is redundant.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Why is this bad?
+    /// Repeating the name of the type is redundant.
     ///
+    /// ### Example
     /// ```rust,ignore
     /// struct Foo {}
     ///
diff --git a/clippy_lints/src/semicolon_if_nothing_returned.rs b/clippy_lints/src/semicolon_if_nothing_returned.rs
index da3e30af35c..6966230156c 100644
--- a/clippy_lints/src/semicolon_if_nothing_returned.rs
+++ b/clippy_lints/src/semicolon_if_nothing_returned.rs
@@ -9,16 +9,15 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
-    /// **What it does:** Looks for blocks of expressions and fires if the last expression returns
+    /// ### What it does
+    /// Looks for blocks of expressions and fires if the last expression returns
     /// `()` but is not followed by a semicolon.
     ///
-    /// **Why is this bad?** The semicolon might be optional but when extending the block with new
+    /// ### Why is this bad?
+    /// The semicolon might be optional but when extending the block with new
     /// code, it doesn't require a change in previous last line.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust
     /// fn main() {
     ///     println!("Hello world")
diff --git a/clippy_lints/src/serde_api.rs b/clippy_lints/src/serde_api.rs
index 169f7d26285..2cd0f85999c 100644
--- a/clippy_lints/src/serde_api.rs
+++ b/clippy_lints/src/serde_api.rs
@@ -5,14 +5,15 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for mis-uses of the serde API.
+    /// ### What it does
+    /// Checks for mis-uses of the serde API.
     ///
-    /// **Why is this bad?** Serde is very finnicky about how its API should be
+    /// ### Why is this bad?
+    /// Serde is very finnicky about how its API should be
     /// used, but the type system can't be used to enforce it (yet?).
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:** Implementing `Visitor::visit_string` but not
+    /// ### Example
+    /// Implementing `Visitor::visit_string` but not
     /// `Visitor::visit_str`.
     pub SERDE_API_MISUSE,
     correctness,
diff --git a/clippy_lints/src/shadow.rs b/clippy_lints/src/shadow.rs
index ac3f7ebd14b..b28a37cabd4 100644
--- a/clippy_lints/src/shadow.rs
+++ b/clippy_lints/src/shadow.rs
@@ -14,17 +14,20 @@ use rustc_span::source_map::Span;
 use rustc_span::symbol::Symbol;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for bindings that shadow other bindings already in
+    /// ### What it does
+    /// Checks for bindings that shadow other bindings already in
     /// scope, while just changing reference level or mutability.
     ///
-    /// **Why is this bad?** Not much, in fact it's a very common pattern in Rust
+    /// ### Why is this bad?
+    /// Not much, in fact it's a very common pattern in Rust
     /// code. Still, some may opt to avoid it in their code base, they can set this
     /// lint to `Warn`.
     ///
-    /// **Known problems:** This lint, as the other shadowing related lints,
+    /// ### Known problems
+    /// This lint, as the other shadowing related lints,
     /// currently only catches very simple patterns.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// # let x = 1;
     /// // Bad
@@ -39,18 +42,21 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for bindings that shadow other bindings already in
+    /// ### What it does
+    /// Checks for bindings that shadow other bindings already in
     /// scope, while reusing the original value.
     ///
-    /// **Why is this bad?** Not too much, in fact it's a common pattern in Rust
+    /// ### Why is this bad?
+    /// Not too much, in fact it's a common pattern in Rust
     /// code. Still, some argue that name shadowing like this hurts readability,
     /// because a value may be bound to different things depending on position in
     /// the code.
     ///
-    /// **Known problems:** This lint, as the other shadowing related lints,
+    /// ### Known problems
+    /// This lint, as the other shadowing related lints,
     /// currently only catches very simple patterns.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// let x = 2;
     /// let x = x + 1;
@@ -66,21 +72,24 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for bindings that shadow other bindings already in
+    /// ### What it does
+    /// Checks for bindings that shadow other bindings already in
     /// scope, either without a initialization or with one that does not even use
     /// the original value.
     ///
-    /// **Why is this bad?** Name shadowing can hurt readability, especially in
+    /// ### Why is this bad?
+    /// Name shadowing can hurt readability, especially in
     /// large code bases, because it is easy to lose track of the active binding at
     /// any place in the code. This can be alleviated by either giving more specific
     /// names to bindings or introducing more scopes to contain the bindings.
     ///
-    /// **Known problems:** This lint, as the other shadowing related lints,
+    /// ### Known problems
+    /// This lint, as the other shadowing related lints,
     /// currently only catches very simple patterns. Note that
     /// `allow`/`warn`/`deny`/`forbid` attributes only work on the function level
     /// for this lint.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// # let y = 1;
     /// # let z = 2;
diff --git a/clippy_lints/src/single_component_path_imports.rs b/clippy_lints/src/single_component_path_imports.rs
index 1eaad438237..f6487b8c46b 100644
--- a/clippy_lints/src/single_component_path_imports.rs
+++ b/clippy_lints/src/single_component_path_imports.rs
@@ -7,15 +7,14 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::{edition::Edition, symbol::kw, Span, Symbol};
 
 declare_clippy_lint! {
-    /// **What it does:** Checking for imports with single component use path.
+    /// ### What it does
+    /// Checking for imports with single component use path.
     ///
-    /// **Why is this bad?** Import with single component use path such as `use cratename;`
+    /// ### Why is this bad?
+    /// Import with single component use path such as `use cratename;`
     /// is not necessary, and thus should be removed.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust,ignore
     /// use regex;
     ///
diff --git a/clippy_lints/src/size_of_in_element_count.rs b/clippy_lints/src/size_of_in_element_count.rs
index b1965cfd601..3e4e4a8d0c0 100644
--- a/clippy_lints/src/size_of_in_element_count.rs
+++ b/clippy_lints/src/size_of_in_element_count.rs
@@ -11,16 +11,16 @@ use rustc_middle::ty::{self, Ty, TyS, TypeAndMut};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
-    /// **What it does:** Detects expressions where
+    /// ### What it does
+    /// Detects expressions where
     /// `size_of::<T>` or `size_of_val::<T>` is used as a
     /// count of elements of type `T`
     ///
-    /// **Why is this bad?** These functions expect a count
+    /// ### Why is this bad?
+    /// These functions expect a count
     /// of `T` and not a number of bytes
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust,no_run
     /// # use std::ptr::copy_nonoverlapping;
     /// # use std::mem::size_of;
diff --git a/clippy_lints/src/slow_vector_initialization.rs b/clippy_lints/src/slow_vector_initialization.rs
index e5c58d70b60..3d039e13065 100644
--- a/clippy_lints/src/slow_vector_initialization.rs
+++ b/clippy_lints/src/slow_vector_initialization.rs
@@ -13,14 +13,14 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::symbol::sym;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks slow zero-filled vector initialization
+    /// ### What it does
+    /// Checks slow zero-filled vector initialization
     ///
-    /// **Why is this bad?** These structures are non-idiomatic and less efficient than simply using
+    /// ### Why is this bad?
+    /// These structures are non-idiomatic and less efficient than simply using
     /// `vec![0; len]`.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// # use core::iter::repeat;
     /// # let len = 4;
diff --git a/clippy_lints/src/stable_sort_primitive.rs b/clippy_lints/src/stable_sort_primitive.rs
index 65790375c73..4ea1293d504 100644
--- a/clippy_lints/src/stable_sort_primitive.rs
+++ b/clippy_lints/src/stable_sort_primitive.rs
@@ -7,22 +7,18 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
-    /// **What it does:**
+    /// ### What it does
     /// When sorting primitive values (integers, bools, chars, as well
     /// as arrays, slices, and tuples of such items), it is better to
     /// use an unstable sort than a stable sort.
     ///
-    /// **Why is this bad?**
+    /// ### Why is this bad?
     /// Using a stable sort consumes more memory and cpu cycles. Because
     /// values which compare equal are identical, preserving their
     /// relative order (the guarantee that a stable sort provides) means
     /// nothing, while the extra costs still apply.
     ///
-    /// **Known problems:**
-    /// None
-    ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust
     /// let mut vec = vec![2, 1, 3];
     /// vec.sort();
diff --git a/clippy_lints/src/strings.rs b/clippy_lints/src/strings.rs
index 958e462125e..1a78a4968e5 100644
--- a/clippy_lints/src/strings.rs
+++ b/clippy_lints/src/strings.rs
@@ -14,16 +14,15 @@ use rustc_span::source_map::Spanned;
 use rustc_span::sym;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for string appends of the form `x = x + y` (without
+    /// ### What it does
+    /// Checks for string appends of the form `x = x + y` (without
     /// `let`!).
     ///
-    /// **Why is this bad?** It's not really bad, but some people think that the
+    /// ### Why is this bad?
+    /// It's not really bad, but some people think that the
     /// `.push_str(_)` method is more readable.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust
     /// let mut x = "Hello".to_owned();
     /// x = x + ", World";
@@ -38,11 +37,13 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for all instances of `x + _` where `x` is of type
+    /// ### What it does
+    /// Checks for all instances of `x + _` where `x` is of type
     /// `String`, but only if [`string_add_assign`](#string_add_assign) does *not*
     /// match.
     ///
-    /// **Why is this bad?** It's not bad in and of itself. However, this particular
+    /// ### Why is this bad?
+    /// It's not bad in and of itself. However, this particular
     /// `Add` implementation is asymmetric (the other operand need not be `String`,
     /// but `x` does), while addition as mathematically defined is symmetric, also
     /// the `String::push_str(_)` function is a perfectly good replacement.
@@ -52,10 +53,7 @@ declare_clippy_lint! {
     /// in other languages is actually fine, which is why we decided to make this
     /// particular lint `allow` by default.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust
     /// let x = "Hello".to_owned();
     /// x + ", World";
@@ -66,13 +64,15 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for the `as_bytes` method called on string literals
+    /// ### What it does
+    /// Checks for the `as_bytes` method called on string literals
     /// that contain only ASCII characters.
     ///
-    /// **Why is this bad?** Byte string literals (e.g., `b"foo"`) can be used
+    /// ### Why is this bad?
+    /// Byte string literals (e.g., `b"foo"`) can be used
     /// instead. They are shorter but less discoverable than `as_bytes()`.
     ///
-    /// **Known Problems:**
+    /// ### Known problems
     /// `"str".as_bytes()` and the suggested replacement of `b"str"` are not
     /// equivalent because they have different types. The former is `&[u8]`
     /// while the latter is `&[u8; 3]`. That means in general they will have a
@@ -94,7 +94,7 @@ declare_clippy_lint! {
     /// `b"str"` but `&b"str"[..]`, which is a great deal of punctuation and not
     /// more readable than a function call.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// // Bad
     /// let bs = "a byte string".as_bytes();
@@ -177,13 +177,13 @@ fn is_add(cx: &LateContext<'_>, src: &Expr<'_>, target: &Expr<'_>) -> bool {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Check if the string is transformed to byte array and casted back to string.
+    /// ### What it does
+    /// Check if the string is transformed to byte array and casted back to string.
     ///
-    /// **Why is this bad?** It's unnecessary, the string can be used directly.
+    /// ### Why is this bad?
+    /// It's unnecessary, the string can be used directly.
     ///
-    /// **Known problems:** None
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// let _ = std::str::from_utf8(&"Hello World!".as_bytes()[6..11]).unwrap();
     /// ```
@@ -317,16 +317,15 @@ impl<'tcx> LateLintPass<'tcx> for StringLitAsBytes {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** This lint checks for `.to_string()` method calls on values of type `&str`.
+    /// ### What it does
+    /// This lint checks for `.to_string()` method calls on values of type `&str`.
     ///
-    /// **Why is this bad?** The `to_string` method is also used on other types to convert them to a string.
+    /// ### Why is this bad?
+    /// The `to_string` method is also used on other types to convert them to a string.
     /// When called on a `&str` it turns the `&str` into the owned variant `String`, which can be better
     /// expressed with `.to_owned()`.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust
     /// // example code where clippy issues a warning
     /// let _ = "str".to_string();
@@ -366,14 +365,14 @@ impl LateLintPass<'_> for StrToString {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** This lint checks for `.to_string()` method calls on values of type `String`.
+    /// ### What it does
+    /// This lint checks for `.to_string()` method calls on values of type `String`.
     ///
-    /// **Why is this bad?** The `to_string` method is also used on other types to convert them to a string.
+    /// ### Why is this bad?
+    /// The `to_string` method is also used on other types to convert them to a string.
     /// When called on a `String` it only clones the `String`, which can be better expressed with `.clone()`.
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
     ///
+    /// ### Example
     /// ```rust
     /// // example code where clippy issues a warning
     /// let msg = String::from("Hello World");
diff --git a/clippy_lints/src/strlen_on_c_strings.rs b/clippy_lints/src/strlen_on_c_strings.rs
index 2ccf3a3796d..516fa3d95b4 100644
--- a/clippy_lints/src/strlen_on_c_strings.rs
+++ b/clippy_lints/src/strlen_on_c_strings.rs
@@ -11,16 +11,15 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::symbol::{sym, Symbol};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for usage of `libc::strlen` on a `CString` or `CStr` value,
+    /// ### What it does
+    /// Checks for usage of `libc::strlen` on a `CString` or `CStr` value,
     /// and suggest calling `as_bytes().len()` or `to_bytes().len()` respectively instead.
     ///
-    /// **Why is this bad?** This avoids calling an unsafe `libc` function.
+    /// ### Why is this bad?
+    /// This avoids calling an unsafe `libc` function.
     /// Currently, it also avoids calculating the length.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust, ignore
     /// use std::ffi::CString;
     /// let cstring = CString::new("foo").expect("CString::new failed");
diff --git a/clippy_lints/src/suspicious_operation_groupings.rs b/clippy_lints/src/suspicious_operation_groupings.rs
index bb707f78fcc..a8e962d1af3 100644
--- a/clippy_lints/src/suspicious_operation_groupings.rs
+++ b/clippy_lints/src/suspicious_operation_groupings.rs
@@ -13,20 +13,21 @@ use rustc_span::symbol::Ident;
 use rustc_span::Span;
 
 declare_clippy_lint! {
-    /// **What it does:**
+    /// ### What it does
     /// Checks for unlikely usages of binary operators that are almost
     /// certainly typos and/or copy/paste errors, given the other usages
     /// of binary operators nearby.
-    /// **Why is this bad?**
+    ///
+    /// ### Why is this bad?
     /// They are probably bugs and if they aren't then they look like bugs
     /// and you should add a comment explaining why you are doing such an
     /// odd set of operations.
-    /// **Known problems:**
+    ///
+    /// ### Known problems
     /// There may be some false positives if you are trying to do something
     /// unusual that happens to look like a typo.
     ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust
     /// struct Vec3 {
     ///     x: f64,
diff --git a/clippy_lints/src/suspicious_trait_impl.rs b/clippy_lints/src/suspicious_trait_impl.rs
index f2bffd55321..682fad00a13 100644
--- a/clippy_lints/src/suspicious_trait_impl.rs
+++ b/clippy_lints/src/suspicious_trait_impl.rs
@@ -8,14 +8,14 @@ use rustc_middle::hir::map::Map;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
-    /// **What it does:** Lints for suspicious operations in impls of arithmetic operators, e.g.
+    /// ### What it does
+    /// Lints for suspicious operations in impls of arithmetic operators, e.g.
     /// subtracting elements in an Add impl.
     ///
-    /// **Why this is bad?** This is probably a typo or copy-and-paste error and not intended.
+    /// ### Why is this bad?
+    /// This is probably a typo or copy-and-paste error and not intended.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```ignore
     /// impl Add for Foo {
     ///     type Output = Foo;
@@ -31,14 +31,14 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Lints for suspicious operations in impls of OpAssign, e.g.
+    /// ### What it does
+    /// Lints for suspicious operations in impls of OpAssign, e.g.
     /// subtracting elements in an AddAssign impl.
     ///
-    /// **Why this is bad?** This is probably a typo or copy-and-paste error and not intended.
-    ///
-    /// **Known problems:** None.
+    /// ### Why is this bad?
+    /// This is probably a typo or copy-and-paste error and not intended.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```ignore
     /// impl AddAssign for Foo {
     ///     fn add_assign(&mut self, other: Foo) {
diff --git a/clippy_lints/src/swap.rs b/clippy_lints/src/swap.rs
index 19967e2c970..4fa8e77a67b 100644
--- a/clippy_lints/src/swap.rs
+++ b/clippy_lints/src/swap.rs
@@ -12,14 +12,14 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::sym;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for manual swapping.
+    /// ### What it does
+    /// Checks for manual swapping.
     ///
-    /// **Why is this bad?** The `std::mem::swap` function exposes the intent better
+    /// ### Why is this bad?
+    /// The `std::mem::swap` function exposes the intent better
     /// without deinitializing or copying either variable.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// let mut a = 42;
     /// let mut b = 1337;
@@ -40,13 +40,13 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for `foo = bar; bar = foo` sequences.
-    ///
-    /// **Why is this bad?** This looks like a failed attempt to swap.
+    /// ### What it does
+    /// Checks for `foo = bar; bar = foo` sequences.
     ///
-    /// **Known problems:** None.
+    /// ### Why is this bad?
+    /// This looks like a failed attempt to swap.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// # let mut a = 1;
     /// # let mut b = 2;
diff --git a/clippy_lints/src/tabs_in_doc_comments.rs b/clippy_lints/src/tabs_in_doc_comments.rs
index e2c144709f5..6a73b94d87e 100644
--- a/clippy_lints/src/tabs_in_doc_comments.rs
+++ b/clippy_lints/src/tabs_in_doc_comments.rs
@@ -7,16 +7,16 @@ use rustc_span::source_map::{BytePos, Span};
 use std::convert::TryFrom;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks doc comments for usage of tab characters.
+    /// ### What it does
+    /// Checks doc comments for usage of tab characters.
     ///
-    /// **Why is this bad?** The rust style-guide promotes spaces instead of tabs for indentation.
+    /// ### Why is this bad?
+    /// The rust style-guide promotes spaces instead of tabs for indentation.
     /// To keep a consistent view on the source, also doc comments should not have tabs.
     /// Also, explaining ascii-diagrams containing tabs can get displayed incorrectly when the
     /// display settings of the author and reader differ.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// ///
     /// /// Struct to hold two strings:
diff --git a/clippy_lints/src/temporary_assignment.rs b/clippy_lints/src/temporary_assignment.rs
index 8ef25dc816c..a9da690339c 100644
--- a/clippy_lints/src/temporary_assignment.rs
+++ b/clippy_lints/src/temporary_assignment.rs
@@ -5,15 +5,15 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for construction of a structure or tuple just to
+    /// ### What it does
+    /// Checks for construction of a structure or tuple just to
     /// assign a value in it.
     ///
-    /// **Why is this bad?** Readability. If the structure is only created to be
+    /// ### Why is this bad?
+    /// Readability. If the structure is only created to be
     /// updated, why not write the structure you want in the first place?
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// (0, 0).0 = 1
     /// ```
diff --git a/clippy_lints/src/to_digit_is_some.rs b/clippy_lints/src/to_digit_is_some.rs
index c66a596c784..1c14a919995 100644
--- a/clippy_lints/src/to_digit_is_some.rs
+++ b/clippy_lints/src/to_digit_is_some.rs
@@ -9,12 +9,14 @@ use rustc_middle::ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for `.to_digit(..).is_some()` on `char`s.
+    /// ### What it does
+    /// Checks for `.to_digit(..).is_some()` on `char`s.
     ///
-    /// **Why is this bad?** This is a convoluted way of checking if a `char` is a digit. It's
+    /// ### Why is this bad?
+    /// This is a convoluted way of checking if a `char` is a digit. It's
     /// more straight forward to use the dedicated `is_digit` method.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// # let c = 'c';
     /// # let radix = 10;
diff --git a/clippy_lints/src/to_string_in_display.rs b/clippy_lints/src/to_string_in_display.rs
index 4fb297ac6c6..b036ed9a3d2 100644
--- a/clippy_lints/src/to_string_in_display.rs
+++ b/clippy_lints/src/to_string_in_display.rs
@@ -7,15 +7,15 @@ use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::symbol::sym;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for uses of `to_string()` in `Display` traits.
+    /// ### What it does
+    /// Checks for uses of `to_string()` in `Display` traits.
     ///
-    /// **Why is this bad?** Usually `to_string` is implemented indirectly
+    /// ### Why is this bad?
+    /// Usually `to_string` is implemented indirectly
     /// via `Display`. Hence using it while implementing `Display` would
     /// lead to infinite recursion.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     ///
     /// ```rust
     /// use std::fmt;
diff --git a/clippy_lints/src/trait_bounds.rs b/clippy_lints/src/trait_bounds.rs
index 74a94db1800..79367c4230c 100644
--- a/clippy_lints/src/trait_bounds.rs
+++ b/clippy_lints/src/trait_bounds.rs
@@ -11,14 +11,14 @@ use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::Span;
 
 declare_clippy_lint! {
-    /// **What it does:** This lint warns about unnecessary type repetitions in trait bounds
+    /// ### What it does
+    /// This lint warns about unnecessary type repetitions in trait bounds
     ///
-    /// **Why is this bad?** Repeating the type for every bound makes the code
+    /// ### Why is this bad?
+    /// Repeating the type for every bound makes the code
     /// less readable than combining the bounds
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// pub fn foo<T>(t: T) where T: Copy, T: Clone {}
     /// ```
@@ -34,15 +34,15 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for cases where generics are being used and multiple
+    /// ### What it does
+    /// Checks for cases where generics are being used and multiple
     /// syntax specifications for trait bounds are used simultaneously.
     ///
-    /// **Why is this bad?** Duplicate bounds makes the code
+    /// ### Why is this bad?
+    /// Duplicate bounds makes the code
     /// less readable than specifing them only once.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// fn func<T: Clone + Default>(arg: T) where T: Clone + Default {}
     /// ```
diff --git a/clippy_lints/src/transmute/mod.rs b/clippy_lints/src/transmute/mod.rs
index 89fd5faa165..33ec9c331ce 100644
--- a/clippy_lints/src/transmute/mod.rs
+++ b/clippy_lints/src/transmute/mod.rs
@@ -20,15 +20,18 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::symbol::sym;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for transmutes that can't ever be correct on any
+    /// ### What it does
+    /// Checks for transmutes that can't ever be correct on any
     /// architecture.
     ///
-    /// **Why is this bad?** It's basically guaranteed to be undefined behaviour.
+    /// ### Why is this bad?
+    /// It's basically guaranteed to be undefined behaviour.
     ///
-    /// **Known problems:** When accessing C, users might want to store pointer
+    /// ### Known problems
+    /// When accessing C, users might want to store pointer
     /// sized objects in `extradata` arguments to save an allocation.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```ignore
     /// let ptr: *const T = core::intrinsics::transmute('x')
     /// ```
@@ -39,15 +42,15 @@ declare_clippy_lint! {
 
 // FIXME: Move this to `complexity` again, after #5343 is fixed
 declare_clippy_lint! {
-    /// **What it does:** Checks for transmutes to the original type of the object
+    /// ### What it does
+    /// Checks for transmutes to the original type of the object
     /// and transmutes that could be a cast.
     ///
-    /// **Why is this bad?** Readability. The code tricks people into thinking that
+    /// ### Why is this bad?
+    /// Readability. The code tricks people into thinking that
     /// something complex is going on.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust,ignore
     /// core::intrinsics::transmute(t); // where the result type is the same as `t`'s
     /// ```
@@ -58,14 +61,14 @@ declare_clippy_lint! {
 
 // FIXME: Merge this lint with USELESS_TRANSMUTE once that is out of the nursery.
 declare_clippy_lint! {
-    /// **What it does:**Checks for transmutes that could be a pointer cast.
+    /// ### What it does
+    ///Checks for transmutes that could be a pointer cast.
     ///
-    /// **Why is this bad?** Readability. The code tricks people into thinking that
+    /// ### Why is this bad?
+    /// Readability. The code tricks people into thinking that
     /// something complex is going on.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     ///
     /// ```rust
     /// # let p: *const [i32] = &[];
@@ -82,14 +85,14 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for transmutes between a type `T` and `*T`.
+    /// ### What it does
+    /// Checks for transmutes between a type `T` and `*T`.
     ///
-    /// **Why is this bad?** It's easy to mistakenly transmute between a type and a
+    /// ### Why is this bad?
+    /// It's easy to mistakenly transmute between a type and a
     /// pointer to that type.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust,ignore
     /// core::intrinsics::transmute(t) // where the result type is the same as
     ///                                // `*t` or `&t`'s
@@ -100,17 +103,19 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for transmutes from a pointer to a reference.
+    /// ### What it does
+    /// Checks for transmutes from a pointer to a reference.
     ///
-    /// **Why is this bad?** This can always be rewritten with `&` and `*`.
+    /// ### Why is this bad?
+    /// This can always be rewritten with `&` and `*`.
     ///
-    /// **Known problems:**
+    /// ### Known problems
     /// - `mem::transmute` in statics and constants is stable from Rust 1.46.0,
     /// while dereferencing raw pointer is not stable yet.
     /// If you need to do this in those places,
     /// you would have to use `transmute` instead.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust,ignore
     /// unsafe {
     ///     let _: &T = std::mem::transmute(p); // where p: *const T
@@ -125,11 +130,13 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for transmutes from an integer to a `char`.
+    /// ### What it does
+    /// Checks for transmutes from an integer to a `char`.
     ///
-    /// **Why is this bad?** Not every integer is a Unicode scalar value.
+    /// ### Why is this bad?
+    /// Not every integer is a Unicode scalar value.
     ///
-    /// **Known problems:**
+    /// ### Known problems
     /// - [`from_u32`] which this lint suggests using is slower than `transmute`
     /// as it needs to validate the input.
     /// If you are certain that the input is always a valid Unicode scalar value,
@@ -140,7 +147,7 @@ declare_clippy_lint! {
     /// [`from_u32`]: https://doc.rust-lang.org/std/char/fn.from_u32.html
     /// [`from_u32_unchecked`]: https://doc.rust-lang.org/std/char/fn.from_u32_unchecked.html
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// let x = 1_u32;
     /// unsafe {
@@ -156,11 +163,13 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for transmutes from a `&[u8]` to a `&str`.
+    /// ### What it does
+    /// Checks for transmutes from a `&[u8]` to a `&str`.
     ///
-    /// **Why is this bad?** Not every byte slice is a valid UTF-8 string.
+    /// ### Why is this bad?
+    /// Not every byte slice is a valid UTF-8 string.
     ///
-    /// **Known problems:**
+    /// ### Known problems
     /// - [`from_utf8`] which this lint suggests using is slower than `transmute`
     /// as it needs to validate the input.
     /// If you are certain that the input is always a valid UTF-8,
@@ -171,7 +180,7 @@ declare_clippy_lint! {
     /// [`from_utf8`]: https://doc.rust-lang.org/std/str/fn.from_utf8.html
     /// [`from_utf8_unchecked`]: https://doc.rust-lang.org/std/str/fn.from_utf8_unchecked.html
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// let b: &[u8] = &[1_u8, 2_u8];
     /// unsafe {
@@ -187,13 +196,13 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for transmutes from an integer to a `bool`.
-    ///
-    /// **Why is this bad?** This might result in an invalid in-memory representation of a `bool`.
+    /// ### What it does
+    /// Checks for transmutes from an integer to a `bool`.
     ///
-    /// **Known problems:** None.
+    /// ### Why is this bad?
+    /// This might result in an invalid in-memory representation of a `bool`.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// let x = 1_u8;
     /// unsafe {
@@ -209,14 +218,14 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for transmutes from an integer to a float.
+    /// ### What it does
+    /// Checks for transmutes from an integer to a float.
     ///
-    /// **Why is this bad?** Transmutes are dangerous and error-prone, whereas `from_bits` is intuitive
+    /// ### Why is this bad?
+    /// Transmutes are dangerous and error-prone, whereas `from_bits` is intuitive
     /// and safe.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// unsafe {
     ///     let _: f32 = std::mem::transmute(1_u32); // where x: u32
@@ -231,14 +240,14 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for transmutes from a float to an integer.
+    /// ### What it does
+    /// Checks for transmutes from a float to an integer.
     ///
-    /// **Why is this bad?** Transmutes are dangerous and error-prone, whereas `to_bits` is intuitive
+    /// ### Why is this bad?
+    /// Transmutes are dangerous and error-prone, whereas `to_bits` is intuitive
     /// and safe.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// unsafe {
     ///     let _: u32 = std::mem::transmute(1f32);
@@ -253,15 +262,15 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for transmutes from a pointer to a pointer, or
+    /// ### What it does
+    /// Checks for transmutes from a pointer to a pointer, or
     /// from a reference to a reference.
     ///
-    /// **Why is this bad?** Transmutes are dangerous, and these can instead be
+    /// ### Why is this bad?
+    /// Transmutes are dangerous, and these can instead be
     /// written as casts.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// let ptr = &1u32 as *const u32;
     /// unsafe {
@@ -280,15 +289,18 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for transmutes between collections whose
+    /// ### What it does
+    /// Checks for transmutes between collections whose
     /// types have different ABI, size or alignment.
     ///
-    /// **Why is this bad?** This is undefined behavior.
+    /// ### Why is this bad?
+    /// This is undefined behavior.
     ///
-    /// **Known problems:** Currently, we cannot know whether a type is a
+    /// ### Known problems
+    /// Currently, we cannot know whether a type is a
     /// collection, so we just lint the ones that come with `std`.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// // different size, therefore likely out-of-bounds memory access
     /// // You absolutely do not want this in your code!
diff --git a/clippy_lints/src/transmuting_null.rs b/clippy_lints/src/transmuting_null.rs
index 0c39d4d8cf4..a67fa792205 100644
--- a/clippy_lints/src/transmuting_null.rs
+++ b/clippy_lints/src/transmuting_null.rs
@@ -10,15 +10,18 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::symbol::sym;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for transmute calls which would receive a null pointer.
+    /// ### What it does
+    /// Checks for transmute calls which would receive a null pointer.
     ///
-    /// **Why is this bad?** Transmuting a null pointer is undefined behavior.
+    /// ### Why is this bad?
+    /// Transmuting a null pointer is undefined behavior.
     ///
-    /// **Known problems:** Not all cases can be detected at the moment of this writing.
+    /// ### Known problems
+    /// Not all cases can be detected at the moment of this writing.
     /// For example, variables which hold a null pointer and are then fed to a `transmute`
     /// call, aren't detectable yet.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// let null_ref: &u64 = unsafe { std::mem::transmute(0 as *const u64) };
     /// ```
diff --git a/clippy_lints/src/try_err.rs b/clippy_lints/src/try_err.rs
index f2ba2b2ecf6..1196271d5dd 100644
--- a/clippy_lints/src/try_err.rs
+++ b/clippy_lints/src/try_err.rs
@@ -13,16 +13,16 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::sym;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for usages of `Err(x)?`.
+    /// ### What it does
+    /// Checks for usages of `Err(x)?`.
     ///
-    /// **Why is this bad?** The `?` operator is designed to allow calls that
+    /// ### Why is this bad?
+    /// The `?` operator is designed to allow calls that
     /// can fail to be easily chained. For example, `foo()?.bar()` or
     /// `foo(bar()?)`. Because `Err(x)?` can't be used that way (it will
     /// always return), it is more clear to write `return Err(x)`.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// fn foo(fail: bool) -> Result<i32, String> {
     ///     if fail {
diff --git a/clippy_lints/src/types/mod.rs b/clippy_lints/src/types/mod.rs
index 7d629b5455b..ad7409fe3a9 100644
--- a/clippy_lints/src/types/mod.rs
+++ b/clippy_lints/src/types/mod.rs
@@ -20,16 +20,16 @@ use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::Span;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for use of `Box<Vec<_>>` anywhere in the code.
+    /// ### What it does
+    /// Checks for use of `Box<Vec<_>>` anywhere in the code.
     /// Check the [Box documentation](https://doc.rust-lang.org/std/boxed/index.html) for more information.
     ///
-    /// **Why is this bad?** `Vec` already keeps its contents in a separate area on
+    /// ### Why is this bad?
+    /// `Vec` already keeps its contents in a separate area on
     /// the heap. So if you `Box` it, you just add another level of indirection
     /// without any benefit whatsoever.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust,ignore
     /// struct X {
     ///     values: Box<Vec<Foo>>,
@@ -49,16 +49,19 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for use of `Vec<Box<T>>` where T: Sized anywhere in the code.
+    /// ### What it does
+    /// Checks for use of `Vec<Box<T>>` where T: Sized anywhere in the code.
     /// Check the [Box documentation](https://doc.rust-lang.org/std/boxed/index.html) for more information.
     ///
-    /// **Why is this bad?** `Vec` already keeps its contents in a separate area on
+    /// ### Why is this bad?
+    /// `Vec` already keeps its contents in a separate area on
     /// the heap. So if you `Box` its contents, you just add another level of indirection.
     ///
-    /// **Known problems:** Vec<Box<T: Sized>> makes sense if T is a large type (see [#3530](https://github.com/rust-lang/rust-clippy/issues/3530),
+    /// ### Known problems
+    /// Vec<Box<T: Sized>> makes sense if T is a large type (see [#3530](https://github.com/rust-lang/rust-clippy/issues/3530),
     /// 1st comment).
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// struct X {
     ///     values: Vec<Box<i32>>,
@@ -78,19 +81,19 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for use of `Option<Option<_>>` in function signatures and type
+    /// ### What it does
+    /// Checks for use of `Option<Option<_>>` in function signatures and type
     /// definitions
     ///
-    /// **Why is this bad?** `Option<_>` represents an optional value. `Option<Option<_>>`
+    /// ### Why is this bad?
+    /// `Option<_>` represents an optional value. `Option<Option<_>>`
     /// represents an optional optional value which is logically the same thing as an optional
     /// value but has an unneeded extra level of wrapping.
     ///
     /// If you have a case where `Some(Some(_))`, `Some(None)` and `None` are distinct cases,
     /// consider a custom `enum` instead, with clear names for each case.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example**
+    /// ### Example
     /// ```rust
     /// fn get_data() -> Option<Option<u32>> {
     ///     None
@@ -116,10 +119,12 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for usage of any `LinkedList`, suggesting to use a
+    /// ### What it does
+    /// Checks for usage of any `LinkedList`, suggesting to use a
     /// `Vec` or a `VecDeque` (formerly called `RingBuf`).
     ///
-    /// **Why is this bad?** Gankro says:
+    /// ### Why is this bad?
+    /// Gankro says:
     ///
     /// > The TL;DR of `LinkedList` is that it's built on a massive amount of
     /// pointers and indirection.
@@ -138,10 +143,11 @@ declare_clippy_lint! {
     /// can still be better
     /// > because of how expensive it is to seek to the middle of a `LinkedList`.
     ///
-    /// **Known problems:** False positives – the instances where using a
+    /// ### Known problems
+    /// False positives – the instances where using a
     /// `LinkedList` makes sense are few and far between, but they can still happen.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// # use std::collections::LinkedList;
     /// let x: LinkedList<usize> = LinkedList::new();
@@ -152,15 +158,15 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for use of `&Box<T>` anywhere in the code.
+    /// ### What it does
+    /// Checks for use of `&Box<T>` anywhere in the code.
     /// Check the [Box documentation](https://doc.rust-lang.org/std/boxed/index.html) for more information.
     ///
-    /// **Why is this bad?** Any `&Box<T>` can also be a `&T`, which is more
+    /// ### Why is this bad?
+    /// Any `&Box<T>` can also be a `&T`, which is more
     /// general.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust,ignore
     /// fn foo(bar: &Box<T>) { ... }
     /// ```
@@ -176,14 +182,14 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for use of redundant allocations anywhere in the code.
+    /// ### What it does
+    /// Checks for use of redundant allocations anywhere in the code.
     ///
-    /// **Why is this bad?** Expressions such as `Rc<&T>`, `Rc<Rc<T>>`, `Rc<Arc<T>>`, `Rc<Box<T>>`, Arc<&T>`, `Arc<Rc<T>>`,
+    /// ### Why is this bad?
+    /// Expressions such as `Rc<&T>`, `Rc<Rc<T>>`, `Rc<Arc<T>>`, `Rc<Box<T>>`, Arc<&T>`, `Arc<Rc<T>>`,
     /// `Arc<Arc<T>>`, `Arc<Box<T>>`, `Box<&T>`, `Box<Rc<T>>`, `Box<Arc<T>>`, `Box<Box<T>>`, add an unnecessary level of indirection.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// # use std::rc::Rc;
     /// fn foo(bar: Rc<&usize>) {}
@@ -200,9 +206,11 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for `Rc<T>` and `Arc<T>` when `T` is a mutable buffer type such as `String` or `Vec`.
+    /// ### What it does
+    /// Checks for `Rc<T>` and `Arc<T>` when `T` is a mutable buffer type such as `String` or `Vec`.
     ///
-    /// **Why is this bad?** Expressions such as `Rc<String>` usually have no advantage over `Rc<str>`, since
+    /// ### Why is this bad?
+    /// Expressions such as `Rc<String>` usually have no advantage over `Rc<str>`, since
     /// it is larger and involves an extra level of indirection, and doesn't implement `Borrow<str>`.
     ///
     /// While mutating a buffer type would still be possible with `Rc::get_mut()`, it only
@@ -211,10 +219,11 @@ declare_clippy_lint! {
     /// type with an interior mutable container (such as `RefCell` or `Mutex`) would normally
     /// be used.
     ///
-    /// **Known problems:** This pattern can be desirable to avoid the overhead of a `RefCell` or `Mutex` for
+    /// ### Known problems
+    /// This pattern can be desirable to avoid the overhead of a `RefCell` or `Mutex` for
     /// cases where mutation only happens before there are any additional references.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust,ignore
     /// # use std::rc::Rc;
     /// fn foo(interned: Rc<String>) { ... }
@@ -231,15 +240,15 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for types used in structs, parameters and `let`
+    /// ### What it does
+    /// Checks for types used in structs, parameters and `let`
     /// declarations above a certain complexity threshold.
     ///
-    /// **Why is this bad?** Too complex types make the code less readable. Consider
+    /// ### Why is this bad?
+    /// Too complex types make the code less readable. Consider
     /// using a `type` definition to simplify them.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// # use std::rc::Rc;
     /// struct Foo {
@@ -252,16 +261,19 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for `Rc<Mutex<T>>`.
+    /// ### What it does
+    /// Checks for `Rc<Mutex<T>>`.
     ///
-    /// **Why is this bad?** `Rc` is used in single thread and `Mutex` is used in multi thread.
+    /// ### Why is this bad?
+    /// `Rc` is used in single thread and `Mutex` is used in multi thread.
     /// Consider using `Rc<RefCell<T>>` in single thread or `Arc<Mutex<T>>` in multi thread.
     ///
-    /// **Known problems:** Sometimes combining generic types can lead to the requirement that a
+    /// ### Known problems
+    /// Sometimes combining generic types can lead to the requirement that a
     /// type use Rc in conjunction with Mutex. We must consider those cases false positives, but
     /// alas they are quite hard to rule out. Luckily they are also rare.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust,ignore
     /// use std::rc::Rc;
     /// use std::sync::Mutex;
diff --git a/clippy_lints/src/undropped_manually_drops.rs b/clippy_lints/src/undropped_manually_drops.rs
index f4f5e1233e3..47571e608c7 100644
--- a/clippy_lints/src/undropped_manually_drops.rs
+++ b/clippy_lints/src/undropped_manually_drops.rs
@@ -6,15 +6,17 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
-    /// **What it does:** Prevents the safe `std::mem::drop` function from being called on `std::mem::ManuallyDrop`.
+    /// ### What it does
+    /// Prevents the safe `std::mem::drop` function from being called on `std::mem::ManuallyDrop`.
     ///
-    /// **Why is this bad?** The safe `drop` function does not drop the inner value of a `ManuallyDrop`.
+    /// ### Why is this bad?
+    /// The safe `drop` function does not drop the inner value of a `ManuallyDrop`.
     ///
-    /// **Known problems:** Does not catch cases if the user binds `std::mem::drop`
+    /// ### Known problems
+    /// Does not catch cases if the user binds `std::mem::drop`
     /// to a different name and calls it that way.
     ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust
     /// struct S;
     /// drop(std::mem::ManuallyDrop::new(S));
diff --git a/clippy_lints/src/unicode.rs b/clippy_lints/src/unicode.rs
index 2f0a61898ba..f337dec8f2b 100644
--- a/clippy_lints/src/unicode.rs
+++ b/clippy_lints/src/unicode.rs
@@ -10,14 +10,15 @@ use rustc_span::source_map::Span;
 use unicode_normalization::UnicodeNormalization;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for invisible Unicode characters in the code.
+    /// ### What it does
+    /// Checks for invisible Unicode characters in the code.
     ///
-    /// **Why is this bad?** Having an invisible character in the code makes for all
+    /// ### Why is this bad?
+    /// Having an invisible character in the code makes for all
     /// sorts of April fools, but otherwise is very much frowned upon.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:** You don't see it, but there may be a zero-width space or soft hyphen
+    /// ### Example
+    /// You don't see it, but there may be a zero-width space or soft hyphen
     /// some­where in this text.
     pub INVISIBLE_CHARACTERS,
     correctness,
@@ -25,17 +26,17 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for non-ASCII characters in string literals.
+    /// ### What it does
+    /// Checks for non-ASCII characters in string literals.
     ///
-    /// **Why is this bad?** Yeah, we know, the 90's called and wanted their charset
+    /// ### Why is this bad?
+    /// Yeah, we know, the 90's called and wanted their charset
     /// back. Even so, there still are editors and other programs out there that
     /// don't work well with Unicode. So if the code is meant to be used
     /// internationally, on multiple operating systems, or has other portability
     /// requirements, activating this lint could be useful.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// let x = String::from("€");
     /// ```
@@ -49,16 +50,17 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for string literals that contain Unicode in a form
+    /// ### What it does
+    /// Checks for string literals that contain Unicode in a form
     /// that is not equal to its
     /// [NFC-recomposition](http://www.unicode.org/reports/tr15/#Norm_Forms).
     ///
-    /// **Why is this bad?** If such a string is compared to another, the results
+    /// ### Why is this bad?
+    /// If such a string is compared to another, the results
     /// may be surprising.
     ///
-    /// **Known problems** None.
-    ///
-    /// **Example:** You may not see it, but "à"" and "à"" aren't the same string. The
+    /// ### Example
+    /// You may not see it, but "à"" and "à"" aren't the same string. The
     /// former when escaped is actually `"a\u{300}"` while the latter is `"\u{e0}"`.
     pub UNICODE_NOT_NFC,
     pedantic,
diff --git a/clippy_lints/src/unit_return_expecting_ord.rs b/clippy_lints/src/unit_return_expecting_ord.rs
index 1c420a50427..900d4531760 100644
--- a/clippy_lints/src/unit_return_expecting_ord.rs
+++ b/clippy_lints/src/unit_return_expecting_ord.rs
@@ -10,20 +10,22 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::{BytePos, Span};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for functions that expect closures of type
+    /// ### What it does
+    /// Checks for functions that expect closures of type
     /// Fn(...) -> Ord where the implemented closure returns the unit type.
     /// The lint also suggests to remove the semi-colon at the end of the statement if present.
     ///
-    /// **Why is this bad?** Likely, returning the unit type is unintentional, and
+    /// ### Why is this bad?
+    /// Likely, returning the unit type is unintentional, and
     /// could simply be caused by an extra semi-colon. Since () implements Ord
     /// it doesn't cause a compilation error.
     /// This is the same reasoning behind the unit_cmp lint.
     ///
-    /// **Known problems:** If returning unit is intentional, then there is no
+    /// ### Known problems
+    /// If returning unit is intentional, then there is no
     /// way of specifying this without triggering needless_return lint
     ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust
     /// let mut twins = vec!((1, 1), (2, 2));
     /// twins.sort_by_key(|x| { x.1; });
diff --git a/clippy_lints/src/unit_types/mod.rs b/clippy_lints/src/unit_types/mod.rs
index 64420a03933..66b1abbe50b 100644
--- a/clippy_lints/src/unit_types/mod.rs
+++ b/clippy_lints/src/unit_types/mod.rs
@@ -8,14 +8,14 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for binding a unit value.
+    /// ### What it does
+    /// Checks for binding a unit value.
     ///
-    /// **Why is this bad?** A unit value cannot usefully be used anywhere. So
+    /// ### Why is this bad?
+    /// A unit value cannot usefully be used anywhere. So
     /// binding one is kind of pointless.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// let x = {
     ///     1;
@@ -27,16 +27,16 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for comparisons to unit. This includes all binary
+    /// ### What it does
+    /// Checks for comparisons to unit. This includes all binary
     /// comparisons (like `==` and `<`) and asserts.
     ///
-    /// **Why is this bad?** Unit is always equal to itself, and thus is just a
+    /// ### Why is this bad?
+    /// Unit is always equal to itself, and thus is just a
     /// clumsily written constant. Mostly this happens when someone accidentally
     /// adds semicolons at the end of the operands.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// # fn foo() {};
     /// # fn bar() {};
@@ -74,14 +74,14 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for passing a unit value as an argument to a function without using a
+    /// ### What it does
+    /// Checks for passing a unit value as an argument to a function without using a
     /// unit literal (`()`).
     ///
-    /// **Why is this bad?** This is likely the result of an accidental semicolon.
-    ///
-    /// **Known problems:** None.
+    /// ### Why is this bad?
+    /// This is likely the result of an accidental semicolon.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust,ignore
     /// foo({
     ///     let a = bar();
diff --git a/clippy_lints/src/unnamed_address.rs b/clippy_lints/src/unnamed_address.rs
index 9cca05b1f1a..1eafdee0352 100644
--- a/clippy_lints/src/unnamed_address.rs
+++ b/clippy_lints/src/unnamed_address.rs
@@ -7,16 +7,15 @@ use rustc_middle::ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for comparisons with an address of a function item.
+    /// ### What it does
+    /// Checks for comparisons with an address of a function item.
     ///
-    /// **Why is this bad?** Function item address is not guaranteed to be unique and could vary
+    /// ### Why is this bad?
+    /// Function item address is not guaranteed to be unique and could vary
     /// between different code generation units. Furthermore different function items could have
     /// the same address after being merged together.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust
     /// type F = fn();
     /// fn a() {}
@@ -31,17 +30,16 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for comparisons with an address of a trait vtable.
+    /// ### What it does
+    /// Checks for comparisons with an address of a trait vtable.
     ///
-    /// **Why is this bad?** Comparing trait objects pointers compares an vtable addresses which
+    /// ### Why is this bad?
+    /// Comparing trait objects pointers compares an vtable addresses which
     /// are not guaranteed to be unique and could vary between different code generation units.
     /// Furthermore vtables for different types could have the same address after being merged
     /// together.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust,ignore
     /// let a: Rc<dyn Trait> = ...
     /// let b: Rc<dyn Trait> = ...
diff --git a/clippy_lints/src/unnecessary_self_imports.rs b/clippy_lints/src/unnecessary_self_imports.rs
index 48c54d79cf1..4cfd2df551f 100644
--- a/clippy_lints/src/unnecessary_self_imports.rs
+++ b/clippy_lints/src/unnecessary_self_imports.rs
@@ -7,16 +7,18 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::symbol::kw;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for imports ending in `::{self}`.
+    /// ### What it does
+    /// Checks for imports ending in `::{self}`.
     ///
-    /// **Why is this bad?** In most cases, this can be written much more cleanly by omitting `::{self}`.
+    /// ### Why is this bad?
+    /// In most cases, this can be written much more cleanly by omitting `::{self}`.
     ///
-    /// **Known problems:** Removing `::{self}` will cause any non-module items at the same path to also be imported.
+    /// ### Known problems
+    /// Removing `::{self}` will cause any non-module items at the same path to also be imported.
     /// This might cause a naming conflict (https://github.com/rust-lang/rustfmt/issues/3568). This lint makes no attempt
     /// to detect this scenario and that is why it is a restriction lint.
     ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust
     /// use std::io::{self};
     /// ```
diff --git a/clippy_lints/src/unnecessary_sort_by.rs b/clippy_lints/src/unnecessary_sort_by.rs
index 347d858b640..6fc5707a4ee 100644
--- a/clippy_lints/src/unnecessary_sort_by.rs
+++ b/clippy_lints/src/unnecessary_sort_by.rs
@@ -12,21 +12,20 @@ use rustc_span::symbol::Ident;
 use std::iter;
 
 declare_clippy_lint! {
-    /// **What it does:**
+    /// ### What it does
     /// Detects uses of `Vec::sort_by` passing in a closure
     /// which compares the two arguments, either directly or indirectly.
     ///
-    /// **Why is this bad?**
+    /// ### Why is this bad?
     /// It is more clear to use `Vec::sort_by_key` (or `Vec::sort` if
     /// possible) than to use `Vec::sort_by` and a more complicated
     /// closure.
     ///
-    /// **Known problems:**
+    /// ### Known problems
     /// If the suggested `Vec::sort_by_key` uses Reverse and it isn't already
     /// imported by a use statement, then it will need to be added manually.
     ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust
     /// # struct A;
     /// # impl A { fn foo(&self) {} }
diff --git a/clippy_lints/src/unnecessary_wraps.rs b/clippy_lints/src/unnecessary_wraps.rs
index a85ffa6aa95..7a62b21937f 100644
--- a/clippy_lints/src/unnecessary_wraps.rs
+++ b/clippy_lints/src/unnecessary_wraps.rs
@@ -13,15 +13,17 @@ use rustc_span::symbol::sym;
 use rustc_span::Span;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for private functions that only return `Ok` or `Some`.
+    /// ### What it does
+    /// Checks for private functions that only return `Ok` or `Some`.
     ///
-    /// **Why is this bad?** It is not meaningful to wrap values when no `None` or `Err` is returned.
+    /// ### Why is this bad?
+    /// It is not meaningful to wrap values when no `None` or `Err` is returned.
     ///
-    /// **Known problems:** There can be false positives if the function signature is designed to
+    /// ### Known problems
+    /// There can be false positives if the function signature is designed to
     /// fit some external requirement.
     ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust
     /// fn get_cool_number(a: bool, b: bool) -> Option<i32> {
     ///     if a && b {
diff --git a/clippy_lints/src/unnested_or_patterns.rs b/clippy_lints/src/unnested_or_patterns.rs
index 07a4e294049..9acfbc994b3 100644
--- a/clippy_lints/src/unnested_or_patterns.rs
+++ b/clippy_lints/src/unnested_or_patterns.rs
@@ -17,22 +17,17 @@ use std::cell::Cell;
 use std::mem;
 
 declare_clippy_lint! {
-    /// **What it does:**
-    ///
+    /// ### What it does
     /// Checks for unnested or-patterns, e.g., `Some(0) | Some(2)` and
     /// suggests replacing the pattern with a nested one, `Some(0 | 2)`.
     ///
     /// Another way to think of this is that it rewrites patterns in
     /// *disjunctive normal form (DNF)* into *conjunctive normal form (CNF)*.
     ///
-    /// **Why is this bad?**
-    ///
+    /// ### Why is this bad?
     /// In the example above, `Some` is repeated, which unncessarily complicates the pattern.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust
     /// fn main() {
     ///     if let Some(0) | Some(2) = Some(0) {}
diff --git a/clippy_lints/src/unsafe_removed_from_name.rs b/clippy_lints/src/unsafe_removed_from_name.rs
index 16ad9d2dfd3..3c694af2b9d 100644
--- a/clippy_lints/src/unsafe_removed_from_name.rs
+++ b/clippy_lints/src/unsafe_removed_from_name.rs
@@ -6,15 +6,15 @@ use rustc_span::source_map::Span;
 use rustc_span::symbol::Ident;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for imports that remove "unsafe" from an item's
+    /// ### What it does
+    /// Checks for imports that remove "unsafe" from an item's
     /// name.
     ///
-    /// **Why is this bad?** Renaming makes it less clear which traits and
+    /// ### Why is this bad?
+    /// Renaming makes it less clear which traits and
     /// structures are unsafe.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust,ignore
     /// use std::cell::{UnsafeCell as TotallySafeCell};
     ///
diff --git a/clippy_lints/src/unused_async.rs b/clippy_lints/src/unused_async.rs
index 18ee07d3a95..3a6a07c5226 100644
--- a/clippy_lints/src/unused_async.rs
+++ b/clippy_lints/src/unused_async.rs
@@ -7,16 +7,15 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::Span;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for functions that are declared `async` but have no `.await`s inside of them.
+    /// ### What it does
+    /// Checks for functions that are declared `async` but have no `.await`s inside of them.
     ///
-    /// **Why is this bad?** Async functions with no async code create overhead, both mentally and computationally.
+    /// ### Why is this bad?
+    /// Async functions with no async code create overhead, both mentally and computationally.
     /// Callers of async methods either need to be calling from an async function themselves or run it on an executor, both of which
     /// causes runtime overhead and hassle for the caller.
     ///
-    /// **Known problems:** None
-    ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust
     /// // Bad
     /// async fn get_random_number() -> i64 {
diff --git a/clippy_lints/src/unused_io_amount.rs b/clippy_lints/src/unused_io_amount.rs
index ee082d30d93..82bc4a6d153 100644
--- a/clippy_lints/src/unused_io_amount.rs
+++ b/clippy_lints/src/unused_io_amount.rs
@@ -5,9 +5,11 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for unused written/read amount.
+    /// ### What it does
+    /// Checks for unused written/read amount.
     ///
-    /// **Why is this bad?** `io::Write::write(_vectored)` and
+    /// ### Why is this bad?
+    /// `io::Write::write(_vectored)` and
     /// `io::Read::read(_vectored)` are not guaranteed to
     /// process the entire buffer. They return how many bytes were processed, which
     /// might be smaller
@@ -15,9 +17,10 @@ declare_clippy_lint! {
     /// partial-write/read, use
     /// `write_all`/`read_exact` instead.
     ///
-    /// **Known problems:** Detects only common patterns.
+    /// ### Known problems
+    /// Detects only common patterns.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust,ignore
     /// use std::io;
     /// fn foo<W: io::Write>(w: &mut W) -> io::Result<()> {
diff --git a/clippy_lints/src/unused_self.rs b/clippy_lints/src/unused_self.rs
index 15343cf90f2..658ac81f6ea 100644
--- a/clippy_lints/src/unused_self.rs
+++ b/clippy_lints/src/unused_self.rs
@@ -6,14 +6,14 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks methods that contain a `self` argument but don't use it
+    /// ### What it does
+    /// Checks methods that contain a `self` argument but don't use it
     ///
-    /// **Why is this bad?** It may be clearer to define the method as an associated function instead
+    /// ### Why is this bad?
+    /// It may be clearer to define the method as an associated function instead
     /// of an instance method if it doesn't require `self`.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust,ignore
     /// struct A;
     /// impl A {
diff --git a/clippy_lints/src/unused_unit.rs b/clippy_lints/src/unused_unit.rs
index ab0cdf75ffe..9ed5e585f84 100644
--- a/clippy_lints/src/unused_unit.rs
+++ b/clippy_lints/src/unused_unit.rs
@@ -10,15 +10,15 @@ use rustc_span::source_map::Span;
 use rustc_span::BytePos;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for unit (`()`) expressions that can be removed.
+    /// ### What it does
+    /// Checks for unit (`()`) expressions that can be removed.
     ///
-    /// **Why is this bad?** Such expressions add no value, but can make the code
+    /// ### Why is this bad?
+    /// Such expressions add no value, but can make the code
     /// less readable. Depending on formatting they can make a `break` or `return`
     /// statement look like a function call.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// fn return_unit() -> () {
     ///     ()
diff --git a/clippy_lints/src/unwrap.rs b/clippy_lints/src/unwrap.rs
index d4efee56eff..c5b8acb9982 100644
--- a/clippy_lints/src/unwrap.rs
+++ b/clippy_lints/src/unwrap.rs
@@ -13,13 +13,13 @@ use rustc_span::source_map::Span;
 use rustc_span::sym;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for calls of `unwrap[_err]()` that cannot fail.
+    /// ### What it does
+    /// Checks for calls of `unwrap[_err]()` that cannot fail.
     ///
-    /// **Why is this bad?** Using `if let` or `match` is more idiomatic.
+    /// ### Why is this bad?
+    /// Using `if let` or `match` is more idiomatic.
     ///
-    /// **Known problems:** None
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// # let option = Some(0);
     /// # fn do_something_with(_x: usize) {}
@@ -43,14 +43,17 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for calls of `unwrap[_err]()` that will always fail.
+    /// ### What it does
+    /// Checks for calls of `unwrap[_err]()` that will always fail.
     ///
-    /// **Why is this bad?** If panicking is desired, an explicit `panic!()` should be used.
+    /// ### Why is this bad?
+    /// If panicking is desired, an explicit `panic!()` should be used.
     ///
-    /// **Known problems:** This lint only checks `if` conditions not assignments.
+    /// ### Known problems
+    /// This lint only checks `if` conditions not assignments.
     /// So something like `let x: Option<()> = None; x.unwrap();` will not be recognized.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// # let option = Some(0);
     /// # fn do_something_with(_x: usize) {}
diff --git a/clippy_lints/src/unwrap_in_result.rs b/clippy_lints/src/unwrap_in_result.rs
index d17aa6d8424..6eadd1fc1c9 100644
--- a/clippy_lints/src/unwrap_in_result.rs
+++ b/clippy_lints/src/unwrap_in_result.rs
@@ -12,13 +12,16 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::{sym, Span};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for functions of type Result that contain `expect()` or `unwrap()`
+    /// ### What it does
+    /// Checks for functions of type Result that contain `expect()` or `unwrap()`
     ///
-    /// **Why is this bad?** These functions promote recoverable errors to non-recoverable errors which may be undesirable in code bases which wish to avoid panics.
+    /// ### Why is this bad?
+    /// These functions promote recoverable errors to non-recoverable errors which may be undesirable in code bases which wish to avoid panics.
     ///
-    /// **Known problems:** This can cause false positives in functions that handle both recoverable and non recoverable errors.
+    /// ### Known problems
+    /// This can cause false positives in functions that handle both recoverable and non recoverable errors.
     ///
-    /// **Example:**
+    /// ### Example
     /// Before:
     /// ```rust
     /// fn divisible_by_3(i_str: String) -> Result<(), String> {
diff --git a/clippy_lints/src/upper_case_acronyms.rs b/clippy_lints/src/upper_case_acronyms.rs
index 0b58c6c0917..7fa0e23ee73 100644
--- a/clippy_lints/src/upper_case_acronyms.rs
+++ b/clippy_lints/src/upper_case_acronyms.rs
@@ -8,9 +8,11 @@ use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::symbol::Ident;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for fully capitalized names and optionally names containing a capitalized acronym.
+    /// ### What it does
+    /// Checks for fully capitalized names and optionally names containing a capitalized acronym.
     ///
-    /// **Why is this bad?** In CamelCase, acronyms count as one word.
+    /// ### Why is this bad?
+    /// In CamelCase, acronyms count as one word.
     /// See [naming conventions](https://rust-lang.github.io/api-guidelines/naming.html#casing-conforms-to-rfc-430-c-case)
     /// for more.
     ///
@@ -18,12 +20,12 @@ declare_clippy_lint! {
     /// You can use the `upper-case-acronyms-aggressive: true` config option to enable linting
     /// on all camel case names
     ///
-    /// **Known problems:** When two acronyms are contiguous, the lint can't tell where
+    /// ### Known problems
+    /// When two acronyms are contiguous, the lint can't tell where
     /// the first acronym ends and the second starts, so it suggests to lowercase all of
     /// the letters in the second acronym.
     ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust
     /// struct HTTPResponse;
     /// ```
diff --git a/clippy_lints/src/use_self.rs b/clippy_lints/src/use_self.rs
index 71117e967e3..fbd552186df 100644
--- a/clippy_lints/src/use_self.rs
+++ b/clippy_lints/src/use_self.rs
@@ -20,19 +20,20 @@ use rustc_span::Span;
 use rustc_typeck::hir_ty_to_ty;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for unnecessary repetition of structure name when a
+    /// ### What it does
+    /// Checks for unnecessary repetition of structure name when a
     /// replacement with `Self` is applicable.
     ///
-    /// **Why is this bad?** Unnecessary repetition. Mixed use of `Self` and struct
+    /// ### Why is this bad?
+    /// Unnecessary repetition. Mixed use of `Self` and struct
     /// name
     /// feels inconsistent.
     ///
-    /// **Known problems:**
+    /// ### Known problems
     /// - Unaddressed false negative in fn bodies of trait implementations
     /// - False positive with assotiated types in traits (#4140)
     ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust
     /// struct Foo {}
     /// impl Foo {
diff --git a/clippy_lints/src/useless_conversion.rs b/clippy_lints/src/useless_conversion.rs
index 25a959d3e41..2861b432919 100644
--- a/clippy_lints/src/useless_conversion.rs
+++ b/clippy_lints/src/useless_conversion.rs
@@ -12,15 +12,14 @@ use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::sym;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for `Into`, `TryInto`, `From`, `TryFrom`, or `IntoIter` calls
+    /// ### What it does
+    /// Checks for `Into`, `TryInto`, `From`, `TryFrom`, or `IntoIter` calls
     /// which uselessly convert to the same type.
     ///
-    /// **Why is this bad?** Redundant code.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Why is this bad?
+    /// Redundant code.
     ///
+    /// ### Example
     /// ```rust
     /// // Bad
     /// // format!() returns a `String`
diff --git a/clippy_lints/src/utils/author.rs b/clippy_lints/src/utils/author.rs
index c1e7fd7fe95..61fd375a989 100644
--- a/clippy_lints/src/utils/author.rs
+++ b/clippy_lints/src/utils/author.rs
@@ -13,9 +13,10 @@ use rustc_middle::hir::map::Map;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
-    /// **What it does:** Generates clippy code that detects the offending pattern
+    /// ### What it does
+    /// Generates clippy code that detects the offending pattern
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust,ignore
     /// // ./tests/ui/my_lint.rs
     /// fn foo() {
diff --git a/clippy_lints/src/utils/inspector.rs b/clippy_lints/src/utils/inspector.rs
index 4665eeeff7b..f7ddee12dcf 100644
--- a/clippy_lints/src/utils/inspector.rs
+++ b/clippy_lints/src/utils/inspector.rs
@@ -8,10 +8,11 @@ use rustc_session::Session;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
-    /// **What it does:** Dumps every ast/hir node which has the `#[clippy::dump]`
+    /// ### What it does
+    /// Dumps every ast/hir node which has the `#[clippy::dump]`
     /// attribute
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust,ignore
     /// #[clippy::dump]
     /// extern crate foo;
diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs
index 668807f499f..d660008e7d1 100644
--- a/clippy_lints/src/utils/internal_lints.rs
+++ b/clippy_lints/src/utils/internal_lints.rs
@@ -36,29 +36,33 @@ use std::borrow::{Borrow, Cow};
 pub mod metadata_collector;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for various things we like to keep tidy in clippy.
+    /// ### What it does
+    /// Checks for various things we like to keep tidy in clippy.
     ///
-    /// **Why is this bad?** We like to pretend we're an example of tidy code.
+    /// ### Why is this bad?
+    /// We like to pretend we're an example of tidy code.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:** Wrong ordering of the util::paths constants.
+    /// ### Example
+    /// Wrong ordering of the util::paths constants.
     pub CLIPPY_LINTS_INTERNAL,
     internal,
     "various things that will negatively affect your clippy experience"
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Ensures every lint is associated to a `LintPass`.
+    /// ### What it does
+    /// Ensures every lint is associated to a `LintPass`.
     ///
-    /// **Why is this bad?** The compiler only knows lints via a `LintPass`. Without
+    /// ### Why is this bad?
+    /// The compiler only knows lints via a `LintPass`. Without
     /// putting a lint to a `LintPass::get_lints()`'s return, the compiler will not
     /// know the name of the lint.
     ///
-    /// **Known problems:** Only checks for lints associated using the
+    /// ### Known problems
+    /// Only checks for lints associated using the
     /// `declare_lint_pass!`, `impl_lint_pass!`, and `lint_array!` macros.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust,ignore
     /// declare_lint! { pub LINT_1, ... }
     /// declare_lint! { pub LINT_2, ... }
@@ -73,15 +77,15 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for calls to `cx.span_lint*` and suggests to use the `utils::*`
+    /// ### What it does
+    /// Checks for calls to `cx.span_lint*` and suggests to use the `utils::*`
     /// variant of the function.
     ///
-    /// **Why is this bad?** The `utils::*` variants also add a link to the Clippy documentation to the
+    /// ### Why is this bad?
+    /// The `utils::*` variants also add a link to the Clippy documentation to the
     /// warning/error messages.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// Bad:
     /// ```rust,ignore
     /// cx.span_lint(LINT_NAME, "message");
@@ -97,14 +101,14 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for calls to `cx.outer().expn_data()` and suggests to use
+    /// ### What it does
+    /// Checks for calls to `cx.outer().expn_data()` and suggests to use
     /// the `cx.outer_expn_data()`
     ///
-    /// **Why is this bad?** `cx.outer_expn_data()` is faster and more concise.
-    ///
-    /// **Known problems:** None.
+    /// ### Why is this bad?
+    /// `cx.outer_expn_data()` is faster and more concise.
     ///
-    /// **Example:**
+    /// ### Example
     /// Bad:
     /// ```rust,ignore
     /// expr.span.ctxt().outer().expn_data()
@@ -120,14 +124,14 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Not an actual lint. This lint is only meant for testing our customized internal compiler
+    /// ### What it does
+    /// Not an actual lint. This lint is only meant for testing our customized internal compiler
     /// error message by calling `panic`.
     ///
-    /// **Why is this bad?** ICE in large quantities can damage your teeth
+    /// ### Why is this bad?
+    /// ICE in large quantities can damage your teeth
     ///
-    /// **Known problems:** None
-    ///
-    /// **Example:**
+    /// ### Example
     /// Bad:
     /// ```rust,ignore
     /// 🍦🍦🍦🍦🍦
@@ -138,14 +142,14 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for cases of an auto-generated lint without an updated description,
+    /// ### What it does
+    /// Checks for cases of an auto-generated lint without an updated description,
     /// i.e. `default lint description`.
     ///
-    /// **Why is this bad?** Indicates that the lint is not finished.
-    ///
-    /// **Known problems:** None
+    /// ### Why is this bad?
+    /// Indicates that the lint is not finished.
     ///
-    /// **Example:**
+    /// ### Example
     /// Bad:
     /// ```rust,ignore
     /// declare_lint! { pub COOL_LINT, nursery, "default lint description" }
@@ -161,7 +165,8 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Lints `span_lint_and_then` function calls, where the
+    /// ### What it does
+    /// Lints `span_lint_and_then` function calls, where the
     /// closure argument has only one statement and that statement is a method
     /// call to `span_suggestion`, `span_help`, `span_note` (using the same
     /// span), `help` or `note`.
@@ -170,12 +175,11 @@ declare_clippy_lint! {
     /// wrapper functions `span_lint_and_sugg`, span_lint_and_help`, or
     /// `span_lint_and_note`.
     ///
-    /// **Why is this bad?** Using the wrapper `span_lint_and_*` functions, is more
+    /// ### Why is this bad?
+    /// Using the wrapper `span_lint_and_*` functions, is more
     /// convenient, readable and less error prone.
     ///
-    /// **Known problems:** None
-    ///
-    /// *Example:**
+    /// ### Example
     /// Bad:
     /// ```rust,ignore
     /// span_lint_and_then(cx, TEST_LINT, expr.span, lint_msg, |diag| {
@@ -222,14 +226,14 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for calls to `utils::match_type()` on a type diagnostic item
+    /// ### What it does
+    /// Checks for calls to `utils::match_type()` on a type diagnostic item
     /// and suggests to use `utils::is_type_diagnostic_item()` instead.
     ///
-    /// **Why is this bad?** `utils::is_type_diagnostic_item()` does not require hardcoded paths.
-    ///
-    /// **Known problems:** None.
+    /// ### Why is this bad?
+    /// `utils::is_type_diagnostic_item()` does not require hardcoded paths.
     ///
-    /// **Example:**
+    /// ### Example
     /// Bad:
     /// ```rust,ignore
     /// utils::match_type(cx, ty, &paths::VEC)
@@ -245,30 +249,27 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:**
+    /// ### What it does
     /// Checks the paths module for invalid paths.
     ///
-    /// **Why is this bad?**
+    /// ### Why is this bad?
     /// It indicates a bug in the code.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:** None.
+    /// ### Example
+    /// None.
     pub INVALID_PATHS,
     internal,
     "invalid path"
 }
 
 declare_clippy_lint! {
-    /// **What it does:**
+    /// ### What it does
     /// Checks for interning symbols that have already been pre-interned and defined as constants.
     ///
-    /// **Why is this bad?**
+    /// ### Why is this bad?
     /// It's faster and easier to use the symbol constant.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// Bad:
     /// ```rust,ignore
     /// let _ = sym!(f32);
@@ -284,13 +285,13 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for unnecessary conversion from Symbol to a string.
-    ///
-    /// **Why is this bad?** It's faster use symbols directly intead of strings.
+    /// ### What it does
+    /// Checks for unnecessary conversion from Symbol to a string.
     ///
-    /// **Known problems:** None.
+    /// ### Why is this bad?
+    /// It's faster use symbols directly intead of strings.
     ///
-    /// **Example:**
+    /// ### Example
     /// Bad:
     /// ```rust,ignore
     /// symbol.as_str() == "clippy";
diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index 3eccc89cdeb..3244677b301 100644
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -68,7 +68,7 @@ const CLIPPY_LINT_GROUP_PREFIX: &str = "clippy::";
 macro_rules! CONFIGURATION_SECTION_TEMPLATE {
     () => {
         r#"
-**Configuration**
+### Configuration
 This lint has the following configuration variables:
 
 {configurations}
@@ -116,18 +116,21 @@ const DEPRECATED_LINT_TYPE: [&str; 3] = ["clippy_lints", "deprecated_lints", "Cl
 const APPLICABILITY_NAME_INDEX: usize = 2;
 
 declare_clippy_lint! {
-    /// **What it does:** Collects metadata about clippy lints for the website.
+    /// ### What it does
+    /// Collects metadata about clippy lints for the website.
     ///
     /// This lint will be used to report problems of syntax parsing. You should hopefully never
     /// see this but never say never I guess ^^
     ///
-    /// **Why is this bad?** This is not a bad thing but definitely a hacky way to do it. See
+    /// ### Why is this bad?
+    /// This is not a bad thing but definitely a hacky way to do it. See
     /// issue [#4310](https://github.com/rust-lang/rust-clippy/issues/4310) for a discussion
     /// about the implementation.
     ///
-    /// **Known problems:** Hopefully none. It would be pretty uncool to have a problem here :)
+    /// ### Known problems
+    /// Hopefully none. It would be pretty uncool to have a problem here :)
     ///
-    /// **Example output:**
+    /// ### Example output
     /// ```json,ignore
     /// {
     ///     "id": "internal_metadata_collector",
@@ -374,7 +377,8 @@ impl<'hir> LateLintPass<'hir> for MetadataCollector {
     /// Collecting lint declarations like:
     /// ```rust, ignore
     /// declare_clippy_lint! {
-    ///     /// **What it does:** Something IDK.
+    ///     /// ### What it does
+    ///     /// Something IDK.
     ///     pub SOME_LINT,
     ///     internal,
     ///     "Who am I?"
diff --git a/clippy_lints/src/vec.rs b/clippy_lints/src/vec.rs
index 1d5b7c98d31..32fa46f042c 100644
--- a/clippy_lints/src/vec.rs
+++ b/clippy_lints/src/vec.rs
@@ -19,14 +19,14 @@ pub struct UselessVec {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for usage of `&vec![..]` when using `&[..]` would
+    /// ### What it does
+    /// Checks for usage of `&vec![..]` when using `&[..]` would
     /// be possible.
     ///
-    /// **Why is this bad?** This is less efficient.
+    /// ### Why is this bad?
+    /// This is less efficient.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// # fn foo(my_vec: &[u8]) {}
     ///
diff --git a/clippy_lints/src/vec_init_then_push.rs b/clippy_lints/src/vec_init_then_push.rs
index c7190e2f979..0413c02b230 100644
--- a/clippy_lints/src/vec_init_then_push.rs
+++ b/clippy_lints/src/vec_init_then_push.rs
@@ -13,15 +13,14 @@ use rustc_span::{symbol::sym, Span};
 use std::convert::TryInto;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for calls to `push` immediately after creating a new `Vec`.
+    /// ### What it does
+    /// Checks for calls to `push` immediately after creating a new `Vec`.
     ///
-    /// **Why is this bad?** The `vec![]` macro is both more performant and easier to read than
+    /// ### Why is this bad?
+    /// The `vec![]` macro is both more performant and easier to read than
     /// multiple `push` calls.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust
     /// let mut v = Vec::new();
     /// v.push(0);
diff --git a/clippy_lints/src/vec_resize_to_zero.rs b/clippy_lints/src/vec_resize_to_zero.rs
index 5540e87405f..5c0429db6b8 100644
--- a/clippy_lints/src/vec_resize_to_zero.rs
+++ b/clippy_lints/src/vec_resize_to_zero.rs
@@ -10,13 +10,13 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Spanned;
 
 declare_clippy_lint! {
-    /// **What it does:** Finds occurrences of `Vec::resize(0, an_int)`
+    /// ### What it does
+    /// Finds occurrences of `Vec::resize(0, an_int)`
     ///
-    /// **Why is this bad?** This is probably an argument inversion mistake.
+    /// ### Why is this bad?
+    /// This is probably an argument inversion mistake.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// vec!(1, 2, 3, 4, 5).resize(0, 5)
     /// ```
diff --git a/clippy_lints/src/verbose_file_reads.rs b/clippy_lints/src/verbose_file_reads.rs
index 3ab68df2b6d..e07c12f4f16 100644
--- a/clippy_lints/src/verbose_file_reads.rs
+++ b/clippy_lints/src/verbose_file_reads.rs
@@ -7,15 +7,14 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for use of File::read_to_end and File::read_to_string.
+    /// ### What it does
+    /// Checks for use of File::read_to_end and File::read_to_string.
     ///
-    /// **Why is this bad?** `fs::{read, read_to_string}` provide the same functionality when `buf` is empty with fewer imports and no intermediate values.
+    /// ### Why is this bad?
+    /// `fs::{read, read_to_string}` provide the same functionality when `buf` is empty with fewer imports and no intermediate values.
     /// See also: [fs::read docs](https://doc.rust-lang.org/std/fs/fn.read.html), [fs::read_to_string docs](https://doc.rust-lang.org/std/fs/fn.read_to_string.html)
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust,no_run
     /// # use std::io::Read;
     /// # use std::fs::File;
diff --git a/clippy_lints/src/wildcard_dependencies.rs b/clippy_lints/src/wildcard_dependencies.rs
index 1ca1117a41e..fd3872bacbe 100644
--- a/clippy_lints/src/wildcard_dependencies.rs
+++ b/clippy_lints/src/wildcard_dependencies.rs
@@ -7,16 +7,15 @@ use rustc_span::source_map::DUMMY_SP;
 use if_chain::if_chain;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for wildcard dependencies in the `Cargo.toml`.
+    /// ### What it does
+    /// Checks for wildcard dependencies in the `Cargo.toml`.
     ///
-    /// **Why is this bad?** [As the edition guide says](https://rust-lang-nursery.github.io/edition-guide/rust-2018/cargo-and-crates-io/crates-io-disallows-wildcard-dependencies.html),
+    /// ### Why is this bad?
+    /// [As the edition guide says](https://rust-lang-nursery.github.io/edition-guide/rust-2018/cargo-and-crates-io/crates-io-disallows-wildcard-dependencies.html),
     /// it is highly unlikely that you work with any possible version of your dependency,
     /// and wildcard dependencies would cause unnecessary breakage in the ecosystem.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```toml
     /// [dependencies]
     /// regex = "*"
diff --git a/clippy_lints/src/wildcard_imports.rs b/clippy_lints/src/wildcard_imports.rs
index 520586b3a1f..bafb9d3e3b1 100644
--- a/clippy_lints/src/wildcard_imports.rs
+++ b/clippy_lints/src/wildcard_imports.rs
@@ -13,15 +13,18 @@ use rustc_span::symbol::kw;
 use rustc_span::{sym, BytePos};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for `use Enum::*`.
+    /// ### What it does
+    /// Checks for `use Enum::*`.
     ///
-    /// **Why is this bad?** It is usually better style to use the prefixed name of
+    /// ### Why is this bad?
+    /// It is usually better style to use the prefixed name of
     /// an enumeration variant, rather than importing variants.
     ///
-    /// **Known problems:** Old-style enumerations that prefix the variants are
+    /// ### Known problems
+    /// Old-style enumerations that prefix the variants are
     /// still around.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust,ignore
     /// // Bad
     /// use std::cmp::Ordering::*;
@@ -37,9 +40,11 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for wildcard imports `use _::*`.
+    /// ### What it does
+    /// Checks for wildcard imports `use _::*`.
     ///
-    /// **Why is this bad?** wildcard imports can pollute the namespace. This is especially bad if
+    /// ### Why is this bad?
+    /// wildcard imports can pollute the namespace. This is especially bad if
     /// you try to import something through a wildcard, that already has been imported by name from
     /// a different source:
     ///
@@ -52,8 +57,7 @@ declare_clippy_lint! {
     ///
     /// This can lead to confusing error messages at best and to unexpected behavior at worst.
     ///
-    /// **Exceptions:**
-    ///
+    /// ### Exceptions
     /// Wildcard imports are allowed from modules named `prelude`. Many crates (including the standard library)
     /// provide modules named "prelude" specifically designed for wildcard import.
     ///
@@ -61,14 +65,14 @@ declare_clippy_lint! {
     ///
     /// These exceptions can be disabled using the `warn-on-all-wildcard-imports` configuration flag.
     ///
-    /// **Known problems:** If macros are imported through the wildcard, this macro is not included
+    /// ### Known problems
+    /// If macros are imported through the wildcard, this macro is not included
     /// by the suggestion and has to be added by hand.
     ///
     /// Applying the suggestion when explicit imports of the things imported with a glob import
     /// exist, may result in `unused_imports` warnings.
     ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust,ignore
     /// // Bad
     /// use crate1::*;
diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs
index 5229a705865..4553ac704a2 100644
--- a/clippy_lints/src/write.rs
+++ b/clippy_lints/src/write.rs
@@ -16,14 +16,14 @@ use rustc_span::symbol::{kw, Symbol};
 use rustc_span::{sym, BytePos, Span, DUMMY_SP};
 
 declare_clippy_lint! {
-    /// **What it does:** This lint warns when you use `println!("")` to
+    /// ### What it does
+    /// This lint warns when you use `println!("")` to
     /// print a newline.
     ///
-    /// **Why is this bad?** You should use `println!()`, which is simpler.
+    /// ### Why is this bad?
+    /// You should use `println!()`, which is simpler.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// // Bad
     /// println!("");
@@ -37,15 +37,15 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** This lint warns when you use `print!()` with a format
+    /// ### What it does
+    /// This lint warns when you use `print!()` with a format
     /// string that ends in a newline.
     ///
-    /// **Why is this bad?** You should use `println!()` instead, which appends the
+    /// ### Why is this bad?
+    /// You should use `println!()` instead, which appends the
     /// newline.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// # let name = "World";
     /// print!("Hello {}!\n", name);
@@ -61,15 +61,18 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for printing on *stdout*. The purpose of this lint
+    /// ### What it does
+    /// Checks for printing on *stdout*. The purpose of this lint
     /// is to catch debugging remnants.
     ///
-    /// **Why is this bad?** People often print on *stdout* while debugging an
+    /// ### Why is this bad?
+    /// People often print on *stdout* while debugging an
     /// application and might forget to remove those prints afterward.
     ///
-    /// **Known problems:** Only catches `print!` and `println!` calls.
+    /// ### Known problems
+    /// Only catches `print!` and `println!` calls.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// println!("Hello world!");
     /// ```
@@ -79,15 +82,18 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for printing on *stderr*. The purpose of this lint
+    /// ### What it does
+    /// Checks for printing on *stderr*. The purpose of this lint
     /// is to catch debugging remnants.
     ///
-    /// **Why is this bad?** People often print on *stderr* while debugging an
+    /// ### Why is this bad?
+    /// People often print on *stderr* while debugging an
     /// application and might forget to remove those prints afterward.
     ///
-    /// **Known problems:** Only catches `eprint!` and `eprintln!` calls.
+    /// ### Known problems
+    /// Only catches `eprint!` and `eprintln!` calls.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// eprintln!("Hello world!");
     /// ```
@@ -97,13 +103,15 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for use of `Debug` formatting. The purpose of this
+    /// ### What it does
+    /// Checks for use of `Debug` formatting. The purpose of this
     /// lint is to catch debugging remnants.
     ///
-    /// **Why is this bad?** The purpose of the `Debug` trait is to facilitate
+    /// ### Why is this bad?
+    /// The purpose of the `Debug` trait is to facilitate
     /// debugging Rust code. It should not be used in user-facing output.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// # let foo = "bar";
     /// println!("{:?}", foo);
@@ -114,16 +122,19 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** This lint warns about the use of literals as `print!`/`println!` args.
+    /// ### What it does
+    /// This lint warns about the use of literals as `print!`/`println!` args.
     ///
-    /// **Why is this bad?** Using literals as `println!` args is inefficient
+    /// ### Why is this bad?
+    /// Using literals as `println!` args is inefficient
     /// (c.f., https://github.com/matthiaskrgr/rust-str-bench) and unnecessary
     /// (i.e., just put the literal in the format string)
     ///
-    /// **Known problems:** Will also warn with macro calls as arguments that expand to literals
+    /// ### Known problems
+    /// Will also warn with macro calls as arguments that expand to literals
     /// -- e.g., `println!("{}", env!("FOO"))`.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// println!("{}", "foo");
     /// ```
@@ -137,14 +148,14 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** This lint warns when you use `writeln!(buf, "")` to
+    /// ### What it does
+    /// This lint warns when you use `writeln!(buf, "")` to
     /// print a newline.
     ///
-    /// **Why is this bad?** You should use `writeln!(buf)`, which is simpler.
+    /// ### Why is this bad?
+    /// You should use `writeln!(buf)`, which is simpler.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// # use std::fmt::Write;
     /// # let mut buf = String::new();
@@ -160,16 +171,16 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** This lint warns when you use `write!()` with a format
+    /// ### What it does
+    /// This lint warns when you use `write!()` with a format
     /// string that
     /// ends in a newline.
     ///
-    /// **Why is this bad?** You should use `writeln!()` instead, which appends the
+    /// ### Why is this bad?
+    /// You should use `writeln!()` instead, which appends the
     /// newline.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// # use std::fmt::Write;
     /// # let mut buf = String::new();
@@ -186,16 +197,19 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** This lint warns about the use of literals as `write!`/`writeln!` args.
+    /// ### What it does
+    /// This lint warns about the use of literals as `write!`/`writeln!` args.
     ///
-    /// **Why is this bad?** Using literals as `writeln!` args is inefficient
+    /// ### Why is this bad?
+    /// Using literals as `writeln!` args is inefficient
     /// (c.f., https://github.com/matthiaskrgr/rust-str-bench) and unnecessary
     /// (i.e., just put the literal in the format string)
     ///
-    /// **Known problems:** Will also warn with macro calls as arguments that expand to literals
+    /// ### Known problems
+    /// Will also warn with macro calls as arguments that expand to literals
     /// -- e.g., `writeln!(buf, "{}", env!("FOO"))`.
     ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// # use std::fmt::Write;
     /// # let mut buf = String::new();
diff --git a/clippy_lints/src/zero_div_zero.rs b/clippy_lints/src/zero_div_zero.rs
index a1ea743ba80..b29ced28ac4 100644
--- a/clippy_lints/src/zero_div_zero.rs
+++ b/clippy_lints/src/zero_div_zero.rs
@@ -6,13 +6,13 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for `0.0 / 0.0`.
+    /// ### What it does
+    /// Checks for `0.0 / 0.0`.
     ///
-    /// **Why is this bad?** It's less readable than `f32::NAN` or `f64::NAN`.
+    /// ### Why is this bad?
+    /// It's less readable than `f32::NAN` or `f64::NAN`.
     ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Example
     /// ```rust
     /// // Bad
     /// let nan = 0.0f32 / 0.0;
diff --git a/clippy_lints/src/zero_sized_map_values.rs b/clippy_lints/src/zero_sized_map_values.rs
index d6a8112218f..2fbe27f9479 100644
--- a/clippy_lints/src/zero_sized_map_values.rs
+++ b/clippy_lints/src/zero_sized_map_values.rs
@@ -10,18 +10,19 @@ use rustc_target::abi::LayoutOf as _;
 use rustc_typeck::hir_ty_to_ty;
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for maps with zero-sized value types anywhere in the code.
+    /// ### What it does
+    /// Checks for maps with zero-sized value types anywhere in the code.
     ///
-    /// **Why is this bad?** Since there is only a single value for a zero-sized type, a map
+    /// ### Why is this bad?
+    /// Since there is only a single value for a zero-sized type, a map
     /// containing zero sized values is effectively a set. Using a set in that case improves
     /// readability and communicates intent more clearly.
     ///
-    /// **Known problems:**
+    /// ### Known problems
     /// * A zero-sized type cannot be recovered later if it contains private fields.
     /// * This lints the signature of public items
     ///
-    /// **Example:**
-    ///
+    /// ### Example
     /// ```rust
     /// # use std::collections::HashMap;
     /// fn unique_words(text: &str) -> HashMap<&str, ()> {
diff --git a/doc/adding_lints.md b/doc/adding_lints.md
index 5a06afedbf4..f2260c3d1a2 100644
--- a/doc/adding_lints.md
+++ b/doc/adding_lints.md
@@ -11,6 +11,7 @@ because that's clearly a non-descriptive name.
   - [Setup](#setup)
   - [Getting Started](#getting-started)
   - [Testing](#testing)
+    - [Cargo lints](#cargo-lints)
   - [Rustfix tests](#rustfix-tests)
   - [Edition 2018 tests](#edition-2018-tests)
   - [Testing manually](#testing-manually)
@@ -179,14 +180,11 @@ the auto-generated lint declaration to have a real description, something like t
 
 ```rust
 declare_clippy_lint! {
-    /// **What it does:**
+    /// ### What it does
     ///
-    /// **Why is this bad?**
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
+    /// ### Why is this bad?
     ///
+    /// ### Example
     /// ```rust
     /// // example code
     /// ```
@@ -487,13 +485,13 @@ Please document your lint with a doc comment akin to the following:
 
 ```rust
 declare_clippy_lint! {
-    /// **What it does:** Checks for ... (describe what the lint matches).
-    ///
-    /// **Why is this bad?** Supply the reason for linting the code.
+    /// ### What it does
+    /// Checks for ... (describe what the lint matches).
     ///
-    /// **Known problems:** None. (Or describe where it could go wrong.)
+    /// ### Why is this bad?
+    /// Supply the reason for linting the code.
     ///
-    /// **Example:**
+    /// ### Example
     ///
     /// ```rust,ignore
     /// // Bad
-- 
cgit 1.4.1-3-g733a5


From 9bc5803195f75895614feae27607564da01d100a Mon Sep 17 00:00:00 2001
From: flip1995 <philipp.krones@embecosm.com>
Date: Wed, 28 Jul 2021 13:51:16 +0200
Subject: Fix last occurence of **What it does:**

---
 clippy_lints/src/utils/internal_lints/metadata_collector.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index 3244677b301..3f5abf3fb8f 100644
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -139,7 +139,7 @@ declare_clippy_lint! {
     ///         "line": 1
     ///     },
     ///     "group": "clippy::internal",
-    ///     "docs": " **What it does:** Collects metadata about clippy lints for the website. [...] "
+    ///     "docs": " ### What it does\nCollects metadata about clippy lints for the website. [...] "
     /// }
     /// ```
     pub INTERNAL_METADATA_COLLECTOR,
-- 
cgit 1.4.1-3-g733a5


From 322a768c7709005e2e996b65594b579c3966301f Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Wed, 19 May 2021 00:08:31 +0200
Subject: Adapting the lint list to Clippy's new metadata format

Changes included:
    - Minimum adaption to the new `lints.json` format
    - Fixing filtering for the new `lints.json` format; hardcoding the
      lint groups in the index
    - Recreating the original doc styling for the new format
    - Fixed sytax highlighting for rust,ignore code blocks
    - Fixed markdown table extraction in the metadata collector and
      fixed lint level output
    - Adding the additional information row for lints
    - Changed the website title to Clippy's lint list
    - Flexing the website for mobile users
    - Added (?) references for lint levels and groups
    - Making deprecated lints look dead
    - Removed JS code block language extraction in favor of a rust
      implementation `rust-clippy#7352`
    - Added the suspicious lint group to the lint list
    - Remove trailing whitespaces from index.html
    - Fix code highlighting
    - Use default value if the docVersion is empty

Co-authored-by: Philipp Krones <hello@philkrones.com>
---
 .../src/utils/internal_lints/metadata_collector.rs |  36 ++--
 util/gh-pages/index.html                           | 199 +++++++++++++++------
 2 files changed, 172 insertions(+), 63 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index 3eccc89cdeb..c9234a85dd2 100644
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -114,6 +114,8 @@ const DEPRECATED_LINT_TYPE: [&str; 3] = ["clippy_lints", "deprecated_lints", "Cl
 
 /// The index of the applicability name of `paths::APPLICABILITY_VALUES`
 const APPLICABILITY_NAME_INDEX: usize = 2;
+/// This applicability will be set for unresolved applicability values.
+const APPLICABILITY_UNRESOLVED_STR: &str = "Unresolved";
 
 declare_clippy_lint! {
     /// **What it does:** Collects metadata about clippy lints for the website.
@@ -192,7 +194,7 @@ impl Drop for MetadataCollector {
         let mut lints = std::mem::take(&mut self.lints).into_sorted_vec();
         lints
             .iter_mut()
-            .for_each(|x| x.applicability = applicability_info.remove(&x.id));
+            .for_each(|x| x.applicability = Some(applicability_info.remove(&x.id).unwrap_or_default()));
 
         // Outputting
         if Path::new(OUTPUT_FILE).exists() {
@@ -208,7 +210,7 @@ struct LintMetadata {
     id: String,
     id_span: SerializableSpan,
     group: String,
-    level: &'static str,
+    level: String,
     docs: String,
     /// This field is only used in the output and will only be
     /// mapped shortly before the actual output.
@@ -221,7 +223,7 @@ impl LintMetadata {
             id,
             id_span,
             group,
-            level,
+            level: level.to_string(),
             docs,
             applicability: None,
         }
@@ -269,14 +271,16 @@ impl Serialize for ApplicabilityInfo {
     where
         S: Serializer,
     {
-        let index = self.applicability.unwrap_or_default();
-
         let mut s = serializer.serialize_struct("ApplicabilityInfo", 2)?;
         s.serialize_field("is_multi_part_suggestion", &self.is_multi_part_suggestion)?;
-        s.serialize_field(
-            "applicability",
-            &paths::APPLICABILITY_VALUES[index][APPLICABILITY_NAME_INDEX],
-        )?;
+        if let Some(index) = self.applicability {
+            s.serialize_field(
+                "applicability",
+                &paths::APPLICABILITY_VALUES[index][APPLICABILITY_NAME_INDEX],
+            )?;
+        } else {
+            s.serialize_field("applicability", APPLICABILITY_UNRESOLVED_STR)?;
+        }
         s.end()
     }
 }
@@ -486,6 +490,13 @@ fn extract_attr_docs_or_lint(cx: &LateContext<'_>, item: &Item<'_>) -> Option<St
 /// ```
 ///
 /// Would result in `Hello world!\n=^.^=\n`
+///
+/// ---
+///
+/// This function may modify the doc comment to ensure that the string can be displayed using a
+/// markdown viewer in Clippy's lint list. The following modifications could be applied:
+/// * Removal of leading space after a new line. (Important to display tables)
+/// * Ensures that code blocks only contain language information
 fn extract_attr_docs(cx: &LateContext<'_>, item: &Item<'_>) -> Option<String> {
     let attrs = cx.tcx.hir().attrs(item.hir_id());
     let mut lines = attrs.iter().filter_map(ast::Attribute::doc_str);
@@ -510,7 +521,12 @@ fn extract_attr_docs(cx: &LateContext<'_>, item: &Item<'_>) -> Option<String> {
                 continue;
             }
         }
-        docs.push_str(line);
+        // This removes the leading space that the macro translation introduces
+        if let Some(stripped_doc) = line.strip_prefix(' ') {
+            docs.push_str(stripped_doc);
+        } else if !line.is_empty() {
+            docs.push_str(line);
+        }
     }
     Some(docs)
 }
diff --git a/util/gh-pages/index.html b/util/gh-pages/index.html
index 0174d3ffcbc..48421150a54 100644
--- a/util/gh-pages/index.html
+++ b/util/gh-pages/index.html
@@ -1,10 +1,17 @@
 <!DOCTYPE html>
+<!--
+Welcome to a Clippy's lint list, at least the source code of it. If you are
+interested in contributing to this website checkout `util/gh-pages/index.html`
+inside the rust-clippy repository.
+
+Otherwise, have a great day =^.^=
+-->
 <html lang="en">
 <head>
     <meta charset="UTF-8"/>
     <meta name="viewport" content="width=device-width, initial-scale=1"/>
 
-    <title>ALL the Clippy Lints</title>
+    <title>Clippy Lints</title>
 
     <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/3.3.6/css/bootstrap.min.css"/>
     <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.5.0/styles/github.min.css"/>
@@ -22,15 +29,95 @@
 
         .panel-heading { cursor: pointer; }
 
-        .panel-title { display: flex; }
+        .panel-title { display: flex; flex-wrap: wrap;}
         .panel-title .label { display: inline-block; }
 
-        .panel-title-name { flex: 1; }
+        .panel-title-name { flex: 1; min-width: 400px;}
         .panel-title-name span { vertical-align: bottom; }
 
         .panel .panel-title-name .anchor { display: none; }
         .panel:hover .panel-title-name .anchor { display: inline;}
 
+        .label {
+            padding-top: 0.3em;
+            padding-bottom: 0.3em;
+        }
+
+        .label-lint-group {
+            min-width: 8em;
+        }
+        .label-lint-level {
+            min-width: 4em;
+        }
+
+        .label-lint-level-allow {
+            background-color: #5cb85c;
+        }
+        .label-lint-level-warn {
+            background-color: #f0ad4e;
+        }
+        .label-lint-level-deny {
+            background-color: #d9534f;
+        }
+        .label-lint-level-none {
+            background-color: #777777;
+            opacity: 0.5;
+        }
+
+        .label-group-deprecated {
+            opacity: 0.5;
+        }
+
+        .label-doc-folding {
+            color: #000;
+            background-color: #fff;
+            border: 1px solid var(--theme-popup-border);
+        }
+        .label-doc-folding:hover {
+            background-color: #e6e6e6;
+        }
+
+        .lint-doc-md > h3 {
+            border-top: 1px solid var(--theme-popup-border);
+            padding: 10px 15px;
+            margin: 0 -15px;
+            font-size: 18px;
+        }
+        .lint-doc-md > h3:first-child {
+            border-top: none;
+            padding-top: 0px;
+        }
+
+        @media (max-width:749px) {
+            .lint-additional-info-container {
+                display: flex;
+                flex-flow: column;
+            }
+            .lint-additional-info-item + .lint-additional-info-item {
+                border-top: 1px solid var(--theme-popup-border);
+            }
+        }
+        @media (min-width:750px) {
+            .lint-additional-info-container {
+                display: flex;
+                flex-flow: row;
+            }
+            .lint-additional-info-item + .lint-additional-info-item {
+                border-left: 1px solid var(--theme-popup-border);
+            }
+        }
+
+        .lint-additional-info-item {
+            display: inline-flex;
+            min-width: 200px;
+            flex-grow: 1;
+            padding: 9px 5px 5px 15px;
+        }
+
+        .label-applicability {
+            background-color: #777777;
+            margin: auto 5px;
+        }
     </style>
     <style>
         /* Expanding the mdBoom theme*/
@@ -159,7 +246,7 @@
 
     <div class="container" ng-app="clippy" ng-controller="lintList">
         <div class="page-header">
-            <h1>ALL the Clippy Lints</h1>
+            <h1>Clippy Lints</h1>
         </div>
 
         <noscript>
@@ -181,9 +268,12 @@
                 <div class="panel-body row filter-panel">
                     <div class="col-md-6 form-inline">
                         <div class="form-group form-group-lg">
-                            <p class="h4">Lint levels</p>
+                            <p class="h4">
+                                Lint levels
+                                <a href="https://doc.rust-lang.org/rustc/lints/levels.html">(?)</a>
+                            </p>
                             <div class="checkbox" ng-repeat="(level, enabled) in levels">
-                                <label>
+                                <label class="text-capitalize">
                                     <input type="checkbox" ng-model="levels[level]" />
                                     {{level}}
                                 </label>
@@ -192,7 +282,10 @@
                     </div>
                     <div class="col-md-6 form-inline">
                         <div class="form-group form-group-lg">
-                            <p class="h4">Lint groups</p>
+                            <p class="h4">
+                                Lint groups
+                                <a href="https://github.com/rust-lang/rust-clippy/#clippy">(?)</a>
+                            </p>
                             <div class="checkbox" ng-repeat="(group, enabled) in groups">
                                 <label class="text-capitalize">
                                     <input type="checkbox" ng-model="groups[group]" />
@@ -216,9 +309,8 @@
                     </div>
                 </div>
             </div>
-
-            <article class="panel panel-default" id="{{lint.id}}"
-                ng-repeat="lint in data | filter:byLevels | filter:byGroups | filter:bySearch | orderBy:'id' track by lint.id">
+            <!-- The order of the filters should be from most likely to remove a lint to least likely to improve performance. -->
+            <article class="panel panel-default" id="{{lint.id}}" ng-repeat="lint in data | filter:bySearch | filter:byGroups | filter:byLevels">
                 <header class="panel-heading" ng-click="open[lint.id] = !open[lint.id]">
                     <h2 class="panel-title">
                         <div class="panel-title-name">
@@ -227,29 +319,36 @@
                         </div>
 
                         <div class="panel-title-addons">
-                            <span class="label label-default text-capitalize">{{lint.group}}</span>
+                            <span class="label label-lint-group label-default label-group-{{lint.group}}">{{lint.group}}</span>
+
+                            <span class="label label-lint-level label-lint-level-{{lint.level}}">{{lint.level}}</span>
 
-                            <span ng-if="lint.level == 'Allow'" class="label label-success">Allow</span>
-                            <span ng-if="lint.level == 'Warn'" class="label label-warning">Warn</span>
-                            <span ng-if="lint.level == 'Deny'" class="label label-danger">Deny</span>
-                            <span ng-if="lint.level == 'Deprecated'" class="label label-default">Deprecated</span>
 
-                            <button class="btn btn-default btn-xs">
-                                <span ng-show="open[lint.id]">&minus;</span>
-                                <span ng-hide="open[lint.id]">&plus;</span>
-                            </button>
+                            <span class="label label-doc-folding" ng-show="open[lint.id]">&minus;</span>
+                            <span class="label label-doc-folding" ng-hide="open[lint.id]">&plus;</span>
                         </div>
                     </h2>
                 </header>
 
-                <ul class="list-group lint-docs" ng-if="lint.docs" ng-class="{collapse: true, in: open[lint.id]}">
-                    <li class="list-group-item" ng-repeat="(title, text) in lint.docs">
-                        <h4 class="list-group-item-heading">
-                            {{title}}
-                        </h4>
-                        <div class="list-group-item-text" ng-bind-html="text | markdown"></div>
-                        <a ng-if="title == 'Known problems'" href="https://github.com/rust-lang/rust-clippy/issues?q=is%3Aissue+is%3Aopen+{{lint.id}}">Search on GitHub</a>
-                    </li>
+                <ul class="list-group lint-docs" ng-class="{collapse: true, in: open[lint.id]}">
+                    <div class="list-group-item lint-doc-md" ng-bind-html="lint.docs | markdown"></div>
+                    <div class="lint-additional-info-container">
+                        <!-- Applicability -->
+                        <div class="lint-additional-info-item">
+                            <span> Applicability: </span>
+                            <span class="label label-default label-applicability">{{lint.applicability.applicability}}</span>
+                            <a href="https://doc.rust-lang.org/nightly/nightly-rustc/rustc_lint_defs/enum.Applicability.html#variants">(?)</a>
+                        </div>
+                        <!-- TODO xFrednet 2021-05-19: Somehow collect and show the version See rust-clippy#6492 -->
+                        <!-- Open related issues -->
+                        <div class="lint-additional-info-item">
+                            <a href="https://github.com/rust-lang/rust-clippy/issues?q=is%3Aissue+{{lint.id}}">Related Issues</a>
+                        </div>
+                        <!-- Jump to source -->
+                        <div class="lint-additional-info-item">
+                            <a href="https://github.com/rust-lang/rust-clippy/blob/{{docVersion}}/clippy_lints/{{lint.id_span.path}}#L{{lint.id_span.line}}">View Source</a>
+                        </div>
+                    </div>
                 </ul>
             </article>
         </div>
@@ -310,22 +409,6 @@
             }
         }
 
-        function searchLint(lint, term) {
-            for (const field in lint.docs) {
-                // Continue if it's not a property
-                if (!lint.docs.hasOwnProperty(field)) {
-                    continue;
-                }
-
-                // Return if not found
-                if (lint.docs[field].toLowerCase().indexOf(term) !== -1) {
-                    return true;
-                }
-            }
-
-            return false;
-        }
-
         angular.module("clippy", [])
         .filter('markdown', function ($sce) {
             return function (text) {
@@ -350,13 +433,25 @@
         })
         .controller("lintList", function ($scope, $http, $timeout) {
             // Level filter
-            var LEVEL_FILTERS_DEFAULT = {Allow: true, Warn: true, Deny: true, Deprecated: true};
+            var LEVEL_FILTERS_DEFAULT = {allow: true, warn: true, deny: true, none: true};
             $scope.levels = LEVEL_FILTERS_DEFAULT;
             $scope.byLevels = function (lint) {
                 return $scope.levels[lint.level];
             };
 
-            $scope.groups = {};
+            var GROUPS_FILTER_DEFAULT = {
+                cargo: true,
+                complexity: true,
+                correctness: true,
+                deprecated: false,
+                nursery: true,
+                pedantic: true,
+                perf: true,
+                restriction: true,
+                style: true,
+                suspicious: true,
+            };
+            $scope.groups = GROUPS_FILTER_DEFAULT;
             $scope.byGroups = function (lint) {
                 return $scope.groups[lint.group];
             };
@@ -377,12 +472,14 @@
                 // Search the description
                 // The use of `for`-loops instead of `foreach` enables us to return early
                 let terms = searchStr.split(" ");
+                let docsLowerCase = lint.docs.toLowerCase();
                 for (index = 0; index < terms.length; index++) {
-                    if (lint.id.indexOf(terms[index]) !== -1) {
+                    // This is more likely and will therefor be checked first
+                    if (docsLowerCase.indexOf(terms[index]) !== -1) {
                         continue;
                     }
 
-                    if (searchLint(lint, terms[index])) {
+                    if (lint.id.indexOf(terms[index]) !== -1) {
                         continue;
                     }
 
@@ -395,6 +492,8 @@
             // Get data
             $scope.open = {};
             $scope.loading = true;
+            // This will be used to jump into the source code of the version that this documentation is for.
+            $scope.docVersion = window.location.pathname.split('/')[2] || "master";
 
             if (window.location.hash.length > 1) {
                 $scope.search = window.location.hash.slice(1);
@@ -407,12 +506,6 @@
                 $scope.data = data;
                 $scope.loading = false;
 
-                // Initialize lint groups (the same structure is also used to enable filtering)
-                $scope.groups = data.reduce(function (result, val) {
-                    result[val.group] = true;
-                    return result;
-                }, {});
-
                 var selectedGroup = getQueryVariable("sel");
                 if (selectedGroup) {
                     selectGroup($scope, selectedGroup.toLowerCase());
-- 
cgit 1.4.1-3-g733a5


From 54e539121d7911933157519a80e8dd30219dc9e0 Mon Sep 17 00:00:00 2001
From: flip1995 <philipp.krones@embecosm.com>
Date: Thu, 29 Jul 2021 12:10:18 +0200
Subject: Rename two lints to comply with our lint naming convention

self_named_constructor -> self_named_constructors
append_instead_of_extend -> extend_with_drain
---
 CHANGELOG.md                                       |  4 +-
 clippy_lints/src/lib.rs                            | 16 ++--
 .../src/methods/append_instead_of_extend.rs        | 41 ----------
 clippy_lints/src/methods/extend_with_drain.rs      | 41 ++++++++++
 clippy_lints/src/methods/mod.rs                    |  8 +-
 clippy_lints/src/self_named_constructor.rs         | 90 ----------------------
 clippy_lints/src/self_named_constructors.rs        | 90 ++++++++++++++++++++++
 tests/ui/append_instead_of_extend.fixed            | 55 -------------
 tests/ui/append_instead_of_extend.rs               | 55 -------------
 tests/ui/append_instead_of_extend.stderr           | 22 ------
 tests/ui/extend_with_drain.fixed                   | 55 +++++++++++++
 tests/ui/extend_with_drain.rs                      | 55 +++++++++++++
 tests/ui/extend_with_drain.stderr                  | 22 ++++++
 tests/ui/needless_bool/fixable.fixed               |  2 +-
 tests/ui/needless_bool/fixable.rs                  |  2 +-
 tests/ui/self_named_constructor.rs                 | 59 --------------
 tests/ui/self_named_constructor.stderr             | 12 ---
 tests/ui/self_named_constructors.rs                | 59 ++++++++++++++
 tests/ui/self_named_constructors.stderr            | 12 +++
 tests/ui/unit_arg.rs                               |  2 +-
 tests/ui/use_self.fixed                            |  2 +-
 tests/ui/use_self.rs                               |  2 +-
 22 files changed, 353 insertions(+), 353 deletions(-)
 delete mode 100644 clippy_lints/src/methods/append_instead_of_extend.rs
 create mode 100644 clippy_lints/src/methods/extend_with_drain.rs
 delete mode 100644 clippy_lints/src/self_named_constructor.rs
 create mode 100644 clippy_lints/src/self_named_constructors.rs
 delete mode 100644 tests/ui/append_instead_of_extend.fixed
 delete mode 100644 tests/ui/append_instead_of_extend.rs
 delete mode 100644 tests/ui/append_instead_of_extend.stderr
 create mode 100644 tests/ui/extend_with_drain.fixed
 create mode 100644 tests/ui/extend_with_drain.rs
 create mode 100644 tests/ui/extend_with_drain.stderr
 delete mode 100644 tests/ui/self_named_constructor.rs
 delete mode 100644 tests/ui/self_named_constructor.stderr
 create mode 100644 tests/ui/self_named_constructors.rs
 create mode 100644 tests/ui/self_named_constructors.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5e00dec2e77..acbefc8064d 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2423,7 +2423,6 @@ Released 2018-09-13
 <!-- begin autogenerated links to lint list -->
 [`absurd_extreme_comparisons`]: https://rust-lang.github.io/rust-clippy/master/index.html#absurd_extreme_comparisons
 [`almost_swapped`]: https://rust-lang.github.io/rust-clippy/master/index.html#almost_swapped
-[`append_instead_of_extend`]: https://rust-lang.github.io/rust-clippy/master/index.html#append_instead_of_extend
 [`approx_constant`]: https://rust-lang.github.io/rust-clippy/master/index.html#approx_constant
 [`as_conversions`]: https://rust-lang.github.io/rust-clippy/master/index.html#as_conversions
 [`assertions_on_constants`]: https://rust-lang.github.io/rust-clippy/master/index.html#assertions_on_constants
@@ -2522,6 +2521,7 @@ Released 2018-09-13
 [`explicit_iter_loop`]: https://rust-lang.github.io/rust-clippy/master/index.html#explicit_iter_loop
 [`explicit_write`]: https://rust-lang.github.io/rust-clippy/master/index.html#explicit_write
 [`extend_from_slice`]: https://rust-lang.github.io/rust-clippy/master/index.html#extend_from_slice
+[`extend_with_drain`]: https://rust-lang.github.io/rust-clippy/master/index.html#extend_with_drain
 [`extra_unused_lifetimes`]: https://rust-lang.github.io/rust-clippy/master/index.html#extra_unused_lifetimes
 [`fallible_impl_from`]: https://rust-lang.github.io/rust-clippy/master/index.html#fallible_impl_from
 [`field_reassign_with_default`]: https://rust-lang.github.io/rust-clippy/master/index.html#field_reassign_with_default
@@ -2772,7 +2772,7 @@ Released 2018-09-13
 [`same_item_push`]: https://rust-lang.github.io/rust-clippy/master/index.html#same_item_push
 [`search_is_some`]: https://rust-lang.github.io/rust-clippy/master/index.html#search_is_some
 [`self_assignment`]: https://rust-lang.github.io/rust-clippy/master/index.html#self_assignment
-[`self_named_constructor`]: https://rust-lang.github.io/rust-clippy/master/index.html#self_named_constructor
+[`self_named_constructors`]: https://rust-lang.github.io/rust-clippy/master/index.html#self_named_constructors
 [`semicolon_if_nothing_returned`]: https://rust-lang.github.io/rust-clippy/master/index.html#semicolon_if_nothing_returned
 [`serde_api_misuse`]: https://rust-lang.github.io/rust-clippy/master/index.html#serde_api_misuse
 [`shadow_reuse`]: https://rust-lang.github.io/rust-clippy/master/index.html#shadow_reuse
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 3cffb507f70..f49b382c5ea 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -329,7 +329,7 @@ mod regex;
 mod repeat_once;
 mod returns;
 mod self_assignment;
-mod self_named_constructor;
+mod self_named_constructors;
 mod semicolon_if_nothing_returned;
 mod serde_api;
 mod shadow;
@@ -740,7 +740,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         mem_replace::MEM_REPLACE_OPTION_WITH_NONE,
         mem_replace::MEM_REPLACE_WITH_DEFAULT,
         mem_replace::MEM_REPLACE_WITH_UNINIT,
-        methods::APPEND_INSTEAD_OF_EXTEND,
         methods::BIND_INSTEAD_OF_MAP,
         methods::BYTES_NTH,
         methods::CHARS_LAST_CMP,
@@ -751,6 +750,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         methods::CLONE_ON_REF_PTR,
         methods::EXPECT_FUN_CALL,
         methods::EXPECT_USED,
+        methods::EXTEND_WITH_DRAIN,
         methods::FILETYPE_IS_FILE,
         methods::FILTER_MAP_IDENTITY,
         methods::FILTER_MAP_NEXT,
@@ -900,7 +900,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         returns::LET_AND_RETURN,
         returns::NEEDLESS_RETURN,
         self_assignment::SELF_ASSIGNMENT,
-        self_named_constructor::SELF_NAMED_CONSTRUCTOR,
+        self_named_constructors::SELF_NAMED_CONSTRUCTORS,
         semicolon_if_nothing_returned::SEMICOLON_IF_NOTHING_RETURNED,
         serde_api::SERDE_API_MISUSE,
         shadow::SHADOW_REUSE,
@@ -1296,7 +1296,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(mem_replace::MEM_REPLACE_OPTION_WITH_NONE),
         LintId::of(mem_replace::MEM_REPLACE_WITH_DEFAULT),
         LintId::of(mem_replace::MEM_REPLACE_WITH_UNINIT),
-        LintId::of(methods::APPEND_INSTEAD_OF_EXTEND),
         LintId::of(methods::BIND_INSTEAD_OF_MAP),
         LintId::of(methods::BYTES_NTH),
         LintId::of(methods::CHARS_LAST_CMP),
@@ -1304,6 +1303,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(methods::CLONE_DOUBLE_REF),
         LintId::of(methods::CLONE_ON_COPY),
         LintId::of(methods::EXPECT_FUN_CALL),
+        LintId::of(methods::EXTEND_WITH_DRAIN),
         LintId::of(methods::FILTER_MAP_IDENTITY),
         LintId::of(methods::FILTER_NEXT),
         LintId::of(methods::FLAT_MAP_IDENTITY),
@@ -1407,7 +1407,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(returns::LET_AND_RETURN),
         LintId::of(returns::NEEDLESS_RETURN),
         LintId::of(self_assignment::SELF_ASSIGNMENT),
-        LintId::of(self_named_constructor::SELF_NAMED_CONSTRUCTOR),
+        LintId::of(self_named_constructors::SELF_NAMED_CONSTRUCTORS),
         LintId::of(serde_api::SERDE_API_MISUSE),
         LintId::of(single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS),
         LintId::of(size_of_in_element_count::SIZE_OF_IN_ELEMENT_COUNT),
@@ -1561,7 +1561,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(redundant_static_lifetimes::REDUNDANT_STATIC_LIFETIMES),
         LintId::of(returns::LET_AND_RETURN),
         LintId::of(returns::NEEDLESS_RETURN),
-        LintId::of(self_named_constructor::SELF_NAMED_CONSTRUCTOR),
+        LintId::of(self_named_constructors::SELF_NAMED_CONSTRUCTORS),
         LintId::of(single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS),
         LintId::of(tabs_in_doc_comments::TABS_IN_DOC_COMMENTS),
         LintId::of(to_digit_is_some::TO_DIGIT_IS_SOME),
@@ -1762,8 +1762,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(large_enum_variant::LARGE_ENUM_VARIANT),
         LintId::of(loops::MANUAL_MEMCPY),
         LintId::of(loops::NEEDLESS_COLLECT),
-        LintId::of(methods::APPEND_INSTEAD_OF_EXTEND),
         LintId::of(methods::EXPECT_FUN_CALL),
+        LintId::of(methods::EXTEND_WITH_DRAIN),
         LintId::of(methods::ITER_NTH),
         LintId::of(methods::MANUAL_STR_REPEAT),
         LintId::of(methods::OR_FUN_CALL),
@@ -2104,7 +2104,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     let scripts = conf.allowed_scripts.clone();
     store.register_early_pass(move || box disallowed_script_idents::DisallowedScriptIdents::new(&scripts));
     store.register_late_pass(|| box strlen_on_c_strings::StrlenOnCStrings);
-    store.register_late_pass(move || box self_named_constructor::SelfNamedConstructor);
+    store.register_late_pass(move || box self_named_constructors::SelfNamedConstructors);
 }
 
 #[rustfmt::skip]
diff --git a/clippy_lints/src/methods/append_instead_of_extend.rs b/clippy_lints/src/methods/append_instead_of_extend.rs
deleted file mode 100644
index e39a5a1efd1..00000000000
--- a/clippy_lints/src/methods/append_instead_of_extend.rs
+++ /dev/null
@@ -1,41 +0,0 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::ty::{is_type_diagnostic_item, is_type_lang_item};
-use if_chain::if_chain;
-use rustc_errors::Applicability;
-use rustc_hir::{Expr, ExprKind, LangItem};
-use rustc_lint::LateContext;
-use rustc_span::symbol::sym;
-
-use super::APPEND_INSTEAD_OF_EXTEND;
-
-pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'_>, arg: &Expr<'_>) {
-    let ty = cx.typeck_results().expr_ty(recv).peel_refs();
-    if_chain! {
-        if is_type_diagnostic_item(cx, ty, sym::vec_type);
-        //check source object
-        if let ExprKind::MethodCall(src_method, _, [drain_vec, drain_arg], _) = &arg.kind;
-        if src_method.ident.as_str() == "drain";
-        if let src_ty = cx.typeck_results().expr_ty(drain_vec).peel_refs();
-        if is_type_diagnostic_item(cx, src_ty, sym::vec_type);
-        //check drain range
-        if let src_ty_range = cx.typeck_results().expr_ty(drain_arg).peel_refs();
-        if is_type_lang_item(cx, src_ty_range, LangItem::RangeFull);
-        then {
-            let mut applicability = Applicability::MachineApplicable;
-            span_lint_and_sugg(
-                cx,
-                APPEND_INSTEAD_OF_EXTEND,
-                expr.span,
-                "use of `extend` instead of `append` for adding the full range of a second vector",
-                "try this",
-                format!(
-                    "{}.append(&mut {})",
-                    snippet_with_applicability(cx, recv.span, "..", &mut applicability),
-                    snippet_with_applicability(cx, drain_vec.span, "..", &mut applicability)
-                ),
-                applicability,
-            );
-        }
-    }
-}
diff --git a/clippy_lints/src/methods/extend_with_drain.rs b/clippy_lints/src/methods/extend_with_drain.rs
new file mode 100644
index 00000000000..57e10ce42f8
--- /dev/null
+++ b/clippy_lints/src/methods/extend_with_drain.rs
@@ -0,0 +1,41 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::ty::{is_type_diagnostic_item, is_type_lang_item};
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind, LangItem};
+use rustc_lint::LateContext;
+use rustc_span::symbol::sym;
+
+use super::EXTEND_WITH_DRAIN;
+
+pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'_>, arg: &Expr<'_>) {
+    let ty = cx.typeck_results().expr_ty(recv).peel_refs();
+    if_chain! {
+        if is_type_diagnostic_item(cx, ty, sym::vec_type);
+        //check source object
+        if let ExprKind::MethodCall(src_method, _, [drain_vec, drain_arg], _) = &arg.kind;
+        if src_method.ident.as_str() == "drain";
+        if let src_ty = cx.typeck_results().expr_ty(drain_vec).peel_refs();
+        if is_type_diagnostic_item(cx, src_ty, sym::vec_type);
+        //check drain range
+        if let src_ty_range = cx.typeck_results().expr_ty(drain_arg).peel_refs();
+        if is_type_lang_item(cx, src_ty_range, LangItem::RangeFull);
+        then {
+            let mut applicability = Applicability::MachineApplicable;
+            span_lint_and_sugg(
+                cx,
+                EXTEND_WITH_DRAIN,
+                expr.span,
+                "use of `extend` instead of `append` for adding the full range of a second vector",
+                "try this",
+                format!(
+                    "{}.append(&mut {})",
+                    snippet_with_applicability(cx, recv.span, "..", &mut applicability),
+                    snippet_with_applicability(cx, drain_vec.span, "..", &mut applicability)
+                ),
+                applicability,
+            );
+        }
+    }
+}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index d3e12023814..5aa29424349 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1,4 +1,3 @@
-mod append_instead_of_extend;
 mod bind_instead_of_map;
 mod bytes_nth;
 mod chars_cmp;
@@ -12,6 +11,7 @@ mod clone_on_ref_ptr;
 mod cloned_instead_of_copied;
 mod expect_fun_call;
 mod expect_used;
+mod extend_with_drain;
 mod filetype_is_file;
 mod filter_map;
 mod filter_map_identity;
@@ -1068,7 +1068,7 @@ declare_clippy_lint! {
     /// // Good
     /// a.append(&mut b);
     /// ```
-    pub APPEND_INSTEAD_OF_EXTEND,
+    pub EXTEND_WITH_DRAIN,
     perf,
     "using vec.append(&mut vec) to move the full range of a vecor to another"
 }
@@ -1821,7 +1821,7 @@ impl_lint_pass!(Methods => [
     IMPLICIT_CLONE,
     SUSPICIOUS_SPLITN,
     MANUAL_STR_REPEAT,
-    APPEND_INSTEAD_OF_EXTEND
+    EXTEND_WITH_DRAIN
 ]);
 
 /// Extracts a method call name, args, and `Span` of the method name.
@@ -2085,7 +2085,7 @@ fn check_methods<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, msrv: Optio
             },
             ("extend", [arg]) => {
                 string_extend_chars::check(cx, expr, recv, arg);
-                append_instead_of_extend::check(cx, expr, recv, arg);
+                extend_with_drain::check(cx, expr, recv, arg);
             },
             ("filter_map", [arg]) => {
                 unnecessary_filter_map::check(cx, expr, arg);
diff --git a/clippy_lints/src/self_named_constructor.rs b/clippy_lints/src/self_named_constructor.rs
deleted file mode 100644
index 2123a14cc1b..00000000000
--- a/clippy_lints/src/self_named_constructor.rs
+++ /dev/null
@@ -1,90 +0,0 @@
-use clippy_utils::diagnostics::span_lint;
-use clippy_utils::return_ty;
-use clippy_utils::ty::{contains_adt_constructor, contains_ty};
-use rustc_hir::{Impl, ImplItem, ImplItemKind, ItemKind, Node};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Warns when constructors have the same name as their types.
-    ///
-    /// ### Why is this bad?
-    /// Repeating the name of the type is redundant.
-    ///
-    /// ### Example
-    /// ```rust,ignore
-    /// struct Foo {}
-    ///
-    /// impl Foo {
-    ///     pub fn foo() -> Foo {
-    ///         Foo {}
-    ///     }
-    /// }
-    /// ```
-    /// Use instead:
-    /// ```rust,ignore
-    /// struct Foo {}
-    ///
-    /// impl Foo {
-    ///     pub fn new() -> Foo {
-    ///         Foo {}
-    ///     }
-    /// }
-    /// ```
-    pub SELF_NAMED_CONSTRUCTOR,
-    style,
-    "method should not have the same name as the type it is implemented for"
-}
-
-declare_lint_pass!(SelfNamedConstructor => [SELF_NAMED_CONSTRUCTOR]);
-
-impl<'tcx> LateLintPass<'tcx> for SelfNamedConstructor {
-    fn check_impl_item(&mut self, cx: &LateContext<'tcx>, impl_item: &'tcx ImplItem<'_>) {
-        match impl_item.kind {
-            ImplItemKind::Fn(ref sig, _) => {
-                if sig.decl.implicit_self.has_implicit_self() {
-                    return;
-                }
-            },
-            _ => return,
-        }
-
-        let parent = cx.tcx.hir().get_parent_item(impl_item.hir_id());
-        let item = cx.tcx.hir().expect_item(parent);
-        let self_ty = cx.tcx.type_of(item.def_id);
-        let ret_ty = return_ty(cx, impl_item.hir_id());
-
-        // Do not check trait impls
-        if matches!(item.kind, ItemKind::Impl(Impl { of_trait: Some(_), .. })) {
-            return;
-        }
-
-        // Ensure method is constructor-like
-        if let Some(self_adt) = self_ty.ty_adt_def() {
-            if !contains_adt_constructor(ret_ty, self_adt) {
-                return;
-            }
-        } else if !contains_ty(ret_ty, self_ty) {
-            return;
-        }
-
-        if_chain! {
-            if let Some(self_def) = self_ty.ty_adt_def();
-            if let Some(self_local_did) = self_def.did.as_local();
-            let self_id = cx.tcx.hir().local_def_id_to_hir_id(self_local_did);
-            if let Some(Node::Item(x)) = cx.tcx.hir().find(self_id);
-            let type_name = x.ident.name.as_str().to_lowercase();
-            if impl_item.ident.name.as_str() == type_name || impl_item.ident.name.as_str().replace("_", "") == type_name;
-
-            then {
-                span_lint(
-                    cx,
-                    SELF_NAMED_CONSTRUCTOR,
-                    impl_item.span,
-                    &format!("constructor `{}` has the same name as the type", impl_item.ident.name),
-                );
-            }
-        }
-    }
-}
diff --git a/clippy_lints/src/self_named_constructors.rs b/clippy_lints/src/self_named_constructors.rs
new file mode 100644
index 00000000000..4472edecbed
--- /dev/null
+++ b/clippy_lints/src/self_named_constructors.rs
@@ -0,0 +1,90 @@
+use clippy_utils::diagnostics::span_lint;
+use clippy_utils::return_ty;
+use clippy_utils::ty::{contains_adt_constructor, contains_ty};
+use rustc_hir::{Impl, ImplItem, ImplItemKind, ItemKind, Node};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Warns when constructors have the same name as their types.
+    ///
+    /// ### Why is this bad?
+    /// Repeating the name of the type is redundant.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// struct Foo {}
+    ///
+    /// impl Foo {
+    ///     pub fn foo() -> Foo {
+    ///         Foo {}
+    ///     }
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust,ignore
+    /// struct Foo {}
+    ///
+    /// impl Foo {
+    ///     pub fn new() -> Foo {
+    ///         Foo {}
+    ///     }
+    /// }
+    /// ```
+    pub SELF_NAMED_CONSTRUCTORS,
+    style,
+    "method should not have the same name as the type it is implemented for"
+}
+
+declare_lint_pass!(SelfNamedConstructors => [SELF_NAMED_CONSTRUCTORS]);
+
+impl<'tcx> LateLintPass<'tcx> for SelfNamedConstructors {
+    fn check_impl_item(&mut self, cx: &LateContext<'tcx>, impl_item: &'tcx ImplItem<'_>) {
+        match impl_item.kind {
+            ImplItemKind::Fn(ref sig, _) => {
+                if sig.decl.implicit_self.has_implicit_self() {
+                    return;
+                }
+            },
+            _ => return,
+        }
+
+        let parent = cx.tcx.hir().get_parent_item(impl_item.hir_id());
+        let item = cx.tcx.hir().expect_item(parent);
+        let self_ty = cx.tcx.type_of(item.def_id);
+        let ret_ty = return_ty(cx, impl_item.hir_id());
+
+        // Do not check trait impls
+        if matches!(item.kind, ItemKind::Impl(Impl { of_trait: Some(_), .. })) {
+            return;
+        }
+
+        // Ensure method is constructor-like
+        if let Some(self_adt) = self_ty.ty_adt_def() {
+            if !contains_adt_constructor(ret_ty, self_adt) {
+                return;
+            }
+        } else if !contains_ty(ret_ty, self_ty) {
+            return;
+        }
+
+        if_chain! {
+            if let Some(self_def) = self_ty.ty_adt_def();
+            if let Some(self_local_did) = self_def.did.as_local();
+            let self_id = cx.tcx.hir().local_def_id_to_hir_id(self_local_did);
+            if let Some(Node::Item(x)) = cx.tcx.hir().find(self_id);
+            let type_name = x.ident.name.as_str().to_lowercase();
+            if impl_item.ident.name.as_str() == type_name || impl_item.ident.name.as_str().replace("_", "") == type_name;
+
+            then {
+                span_lint(
+                    cx,
+                    SELF_NAMED_CONSTRUCTORS,
+                    impl_item.span,
+                    &format!("constructor `{}` has the same name as the type", impl_item.ident.name),
+                );
+            }
+        }
+    }
+}
diff --git a/tests/ui/append_instead_of_extend.fixed b/tests/ui/append_instead_of_extend.fixed
deleted file mode 100644
index 283358333cd..00000000000
--- a/tests/ui/append_instead_of_extend.fixed
+++ /dev/null
@@ -1,55 +0,0 @@
-// run-rustfix
-#![warn(clippy::append_instead_of_extend)]
-use std::collections::BinaryHeap;
-fn main() {
-    //gets linted
-    let mut vec1 = vec![0u8; 1024];
-    let mut vec2: std::vec::Vec<u8> = Vec::new();
-
-    vec2.append(&mut vec1);
-
-    let mut vec3 = vec![0u8; 1024];
-    let mut vec4: std::vec::Vec<u8> = Vec::new();
-
-    vec4.append(&mut vec3);
-
-    let mut vec11: std::vec::Vec<u8> = Vec::new();
-
-    vec11.append(&mut return_vector());
-
-    //won't get linted it dosen't move the entire content of a vec into another
-    let mut test1 = vec![0u8, 10];
-    let mut test2: std::vec::Vec<u8> = Vec::new();
-
-    test2.extend(test1.drain(4..10));
-
-    let mut vec3 = vec![0u8; 104];
-    let mut vec7: std::vec::Vec<u8> = Vec::new();
-
-    vec3.append(&mut vec7);
-
-    let mut vec5 = vec![0u8; 1024];
-    let mut vec6: std::vec::Vec<u8> = Vec::new();
-
-    vec5.extend(vec6.drain(..4));
-
-    let mut vec9: std::vec::Vec<u8> = Vec::new();
-
-    return_vector().append(&mut vec9);
-
-    //won't get linted because it is not a vec
-
-    let mut heap = BinaryHeap::from(vec![1, 3]);
-    let mut heap2 = BinaryHeap::from(vec![]);
-    heap2.extend(heap.drain())
-}
-
-fn return_vector() -> Vec<u8> {
-    let mut new_vector = vec![];
-
-    for i in 1..10 {
-        new_vector.push(i)
-    }
-
-    new_vector
-}
diff --git a/tests/ui/append_instead_of_extend.rs b/tests/ui/append_instead_of_extend.rs
deleted file mode 100644
index abde5cdac5c..00000000000
--- a/tests/ui/append_instead_of_extend.rs
+++ /dev/null
@@ -1,55 +0,0 @@
-// run-rustfix
-#![warn(clippy::append_instead_of_extend)]
-use std::collections::BinaryHeap;
-fn main() {
-    //gets linted
-    let mut vec1 = vec![0u8; 1024];
-    let mut vec2: std::vec::Vec<u8> = Vec::new();
-
-    vec2.extend(vec1.drain(..));
-
-    let mut vec3 = vec![0u8; 1024];
-    let mut vec4: std::vec::Vec<u8> = Vec::new();
-
-    vec4.extend(vec3.drain(..));
-
-    let mut vec11: std::vec::Vec<u8> = Vec::new();
-
-    vec11.extend(return_vector().drain(..));
-
-    //won't get linted it dosen't move the entire content of a vec into another
-    let mut test1 = vec![0u8, 10];
-    let mut test2: std::vec::Vec<u8> = Vec::new();
-
-    test2.extend(test1.drain(4..10));
-
-    let mut vec3 = vec![0u8; 104];
-    let mut vec7: std::vec::Vec<u8> = Vec::new();
-
-    vec3.append(&mut vec7);
-
-    let mut vec5 = vec![0u8; 1024];
-    let mut vec6: std::vec::Vec<u8> = Vec::new();
-
-    vec5.extend(vec6.drain(..4));
-
-    let mut vec9: std::vec::Vec<u8> = Vec::new();
-
-    return_vector().append(&mut vec9);
-
-    //won't get linted because it is not a vec
-
-    let mut heap = BinaryHeap::from(vec![1, 3]);
-    let mut heap2 = BinaryHeap::from(vec![]);
-    heap2.extend(heap.drain())
-}
-
-fn return_vector() -> Vec<u8> {
-    let mut new_vector = vec![];
-
-    for i in 1..10 {
-        new_vector.push(i)
-    }
-
-    new_vector
-}
diff --git a/tests/ui/append_instead_of_extend.stderr b/tests/ui/append_instead_of_extend.stderr
deleted file mode 100644
index 9d309d981de..00000000000
--- a/tests/ui/append_instead_of_extend.stderr
+++ /dev/null
@@ -1,22 +0,0 @@
-error: use of `extend` instead of `append` for adding the full range of a second vector
-  --> $DIR/append_instead_of_extend.rs:9:5
-   |
-LL |     vec2.extend(vec1.drain(..));
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `vec2.append(&mut vec1)`
-   |
-   = note: `-D clippy::append-instead-of-extend` implied by `-D warnings`
-
-error: use of `extend` instead of `append` for adding the full range of a second vector
-  --> $DIR/append_instead_of_extend.rs:14:5
-   |
-LL |     vec4.extend(vec3.drain(..));
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `vec4.append(&mut vec3)`
-
-error: use of `extend` instead of `append` for adding the full range of a second vector
-  --> $DIR/append_instead_of_extend.rs:18:5
-   |
-LL |     vec11.extend(return_vector().drain(..));
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `vec11.append(&mut return_vector())`
-
-error: aborting due to 3 previous errors
-
diff --git a/tests/ui/extend_with_drain.fixed b/tests/ui/extend_with_drain.fixed
new file mode 100644
index 00000000000..00170e649e2
--- /dev/null
+++ b/tests/ui/extend_with_drain.fixed
@@ -0,0 +1,55 @@
+// run-rustfix
+#![warn(clippy::extend_with_drain)]
+use std::collections::BinaryHeap;
+fn main() {
+    //gets linted
+    let mut vec1 = vec![0u8; 1024];
+    let mut vec2: std::vec::Vec<u8> = Vec::new();
+
+    vec2.append(&mut vec1);
+
+    let mut vec3 = vec![0u8; 1024];
+    let mut vec4: std::vec::Vec<u8> = Vec::new();
+
+    vec4.append(&mut vec3);
+
+    let mut vec11: std::vec::Vec<u8> = Vec::new();
+
+    vec11.append(&mut return_vector());
+
+    //won't get linted it dosen't move the entire content of a vec into another
+    let mut test1 = vec![0u8, 10];
+    let mut test2: std::vec::Vec<u8> = Vec::new();
+
+    test2.extend(test1.drain(4..10));
+
+    let mut vec3 = vec![0u8; 104];
+    let mut vec7: std::vec::Vec<u8> = Vec::new();
+
+    vec3.append(&mut vec7);
+
+    let mut vec5 = vec![0u8; 1024];
+    let mut vec6: std::vec::Vec<u8> = Vec::new();
+
+    vec5.extend(vec6.drain(..4));
+
+    let mut vec9: std::vec::Vec<u8> = Vec::new();
+
+    return_vector().append(&mut vec9);
+
+    //won't get linted because it is not a vec
+
+    let mut heap = BinaryHeap::from(vec![1, 3]);
+    let mut heap2 = BinaryHeap::from(vec![]);
+    heap2.extend(heap.drain())
+}
+
+fn return_vector() -> Vec<u8> {
+    let mut new_vector = vec![];
+
+    for i in 1..10 {
+        new_vector.push(i)
+    }
+
+    new_vector
+}
diff --git a/tests/ui/extend_with_drain.rs b/tests/ui/extend_with_drain.rs
new file mode 100644
index 00000000000..d76458c3289
--- /dev/null
+++ b/tests/ui/extend_with_drain.rs
@@ -0,0 +1,55 @@
+// run-rustfix
+#![warn(clippy::extend_with_drain)]
+use std::collections::BinaryHeap;
+fn main() {
+    //gets linted
+    let mut vec1 = vec![0u8; 1024];
+    let mut vec2: std::vec::Vec<u8> = Vec::new();
+
+    vec2.extend(vec1.drain(..));
+
+    let mut vec3 = vec![0u8; 1024];
+    let mut vec4: std::vec::Vec<u8> = Vec::new();
+
+    vec4.extend(vec3.drain(..));
+
+    let mut vec11: std::vec::Vec<u8> = Vec::new();
+
+    vec11.extend(return_vector().drain(..));
+
+    //won't get linted it dosen't move the entire content of a vec into another
+    let mut test1 = vec![0u8, 10];
+    let mut test2: std::vec::Vec<u8> = Vec::new();
+
+    test2.extend(test1.drain(4..10));
+
+    let mut vec3 = vec![0u8; 104];
+    let mut vec7: std::vec::Vec<u8> = Vec::new();
+
+    vec3.append(&mut vec7);
+
+    let mut vec5 = vec![0u8; 1024];
+    let mut vec6: std::vec::Vec<u8> = Vec::new();
+
+    vec5.extend(vec6.drain(..4));
+
+    let mut vec9: std::vec::Vec<u8> = Vec::new();
+
+    return_vector().append(&mut vec9);
+
+    //won't get linted because it is not a vec
+
+    let mut heap = BinaryHeap::from(vec![1, 3]);
+    let mut heap2 = BinaryHeap::from(vec![]);
+    heap2.extend(heap.drain())
+}
+
+fn return_vector() -> Vec<u8> {
+    let mut new_vector = vec![];
+
+    for i in 1..10 {
+        new_vector.push(i)
+    }
+
+    new_vector
+}
diff --git a/tests/ui/extend_with_drain.stderr b/tests/ui/extend_with_drain.stderr
new file mode 100644
index 00000000000..57f344716a1
--- /dev/null
+++ b/tests/ui/extend_with_drain.stderr
@@ -0,0 +1,22 @@
+error: use of `extend` instead of `append` for adding the full range of a second vector
+  --> $DIR/extend_with_drain.rs:9:5
+   |
+LL |     vec2.extend(vec1.drain(..));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `vec2.append(&mut vec1)`
+   |
+   = note: `-D clippy::extend-with-drain` implied by `-D warnings`
+
+error: use of `extend` instead of `append` for adding the full range of a second vector
+  --> $DIR/extend_with_drain.rs:14:5
+   |
+LL |     vec4.extend(vec3.drain(..));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `vec4.append(&mut vec3)`
+
+error: use of `extend` instead of `append` for adding the full range of a second vector
+  --> $DIR/extend_with_drain.rs:18:5
+   |
+LL |     vec11.extend(return_vector().drain(..));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `vec11.append(&mut return_vector())`
+
+error: aborting due to 3 previous errors
+
diff --git a/tests/ui/needless_bool/fixable.fixed b/tests/ui/needless_bool/fixable.fixed
index 5917ffc3e12..639eac8b8b3 100644
--- a/tests/ui/needless_bool/fixable.fixed
+++ b/tests/ui/needless_bool/fixable.fixed
@@ -7,7 +7,7 @@
     clippy::no_effect,
     clippy::if_same_then_else,
     clippy::needless_return,
-    clippy::self_named_constructor
+    clippy::self_named_constructors
 )]
 
 use std::cell::Cell;
diff --git a/tests/ui/needless_bool/fixable.rs b/tests/ui/needless_bool/fixable.rs
index d26dcb9fcc3..a3ce086a1c9 100644
--- a/tests/ui/needless_bool/fixable.rs
+++ b/tests/ui/needless_bool/fixable.rs
@@ -7,7 +7,7 @@
     clippy::no_effect,
     clippy::if_same_then_else,
     clippy::needless_return,
-    clippy::self_named_constructor
+    clippy::self_named_constructors
 )]
 
 use std::cell::Cell;
diff --git a/tests/ui/self_named_constructor.rs b/tests/ui/self_named_constructor.rs
deleted file mode 100644
index 7658b86a8d6..00000000000
--- a/tests/ui/self_named_constructor.rs
+++ /dev/null
@@ -1,59 +0,0 @@
-#![warn(clippy::self_named_constructor)]
-
-struct ShouldSpawn;
-struct ShouldNotSpawn;
-
-impl ShouldSpawn {
-    pub fn should_spawn() -> ShouldSpawn {
-        ShouldSpawn
-    }
-
-    fn should_not_spawn() -> ShouldNotSpawn {
-        ShouldNotSpawn
-    }
-}
-
-impl ShouldNotSpawn {
-    pub fn new() -> ShouldNotSpawn {
-        ShouldNotSpawn
-    }
-}
-
-struct ShouldNotSpawnWithTrait;
-
-trait ShouldNotSpawnTrait {
-    type Item;
-}
-
-impl ShouldNotSpawnTrait for ShouldNotSpawnWithTrait {
-    type Item = Self;
-}
-
-impl ShouldNotSpawnWithTrait {
-    pub fn should_not_spawn_with_trait() -> impl ShouldNotSpawnTrait<Item = Self> {
-        ShouldNotSpawnWithTrait
-    }
-}
-
-// Same trait name and same type name should not spawn the lint
-#[derive(Default)]
-pub struct Default;
-
-trait TraitSameTypeName {
-    fn should_not_spawn() -> Self;
-}
-impl TraitSameTypeName for ShouldNotSpawn {
-    fn should_not_spawn() -> Self {
-        ShouldNotSpawn
-    }
-}
-
-struct SelfMethodShouldNotSpawn;
-
-impl SelfMethodShouldNotSpawn {
-    fn self_method_should_not_spawn(self) -> Self {
-        SelfMethodShouldNotSpawn
-    }
-}
-
-fn main() {}
diff --git a/tests/ui/self_named_constructor.stderr b/tests/ui/self_named_constructor.stderr
deleted file mode 100644
index 1e2c34ac2f7..00000000000
--- a/tests/ui/self_named_constructor.stderr
+++ /dev/null
@@ -1,12 +0,0 @@
-error: constructor `should_spawn` has the same name as the type
-  --> $DIR/self_named_constructor.rs:7:5
-   |
-LL | /     pub fn should_spawn() -> ShouldSpawn {
-LL | |         ShouldSpawn
-LL | |     }
-   | |_____^
-   |
-   = note: `-D clippy::self-named-constructor` implied by `-D warnings`
-
-error: aborting due to previous error
-
diff --git a/tests/ui/self_named_constructors.rs b/tests/ui/self_named_constructors.rs
new file mode 100644
index 00000000000..356f701c985
--- /dev/null
+++ b/tests/ui/self_named_constructors.rs
@@ -0,0 +1,59 @@
+#![warn(clippy::self_named_constructors)]
+
+struct ShouldSpawn;
+struct ShouldNotSpawn;
+
+impl ShouldSpawn {
+    pub fn should_spawn() -> ShouldSpawn {
+        ShouldSpawn
+    }
+
+    fn should_not_spawn() -> ShouldNotSpawn {
+        ShouldNotSpawn
+    }
+}
+
+impl ShouldNotSpawn {
+    pub fn new() -> ShouldNotSpawn {
+        ShouldNotSpawn
+    }
+}
+
+struct ShouldNotSpawnWithTrait;
+
+trait ShouldNotSpawnTrait {
+    type Item;
+}
+
+impl ShouldNotSpawnTrait for ShouldNotSpawnWithTrait {
+    type Item = Self;
+}
+
+impl ShouldNotSpawnWithTrait {
+    pub fn should_not_spawn_with_trait() -> impl ShouldNotSpawnTrait<Item = Self> {
+        ShouldNotSpawnWithTrait
+    }
+}
+
+// Same trait name and same type name should not spawn the lint
+#[derive(Default)]
+pub struct Default;
+
+trait TraitSameTypeName {
+    fn should_not_spawn() -> Self;
+}
+impl TraitSameTypeName for ShouldNotSpawn {
+    fn should_not_spawn() -> Self {
+        ShouldNotSpawn
+    }
+}
+
+struct SelfMethodShouldNotSpawn;
+
+impl SelfMethodShouldNotSpawn {
+    fn self_method_should_not_spawn(self) -> Self {
+        SelfMethodShouldNotSpawn
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/self_named_constructors.stderr b/tests/ui/self_named_constructors.stderr
new file mode 100644
index 00000000000..ba989f06dc8
--- /dev/null
+++ b/tests/ui/self_named_constructors.stderr
@@ -0,0 +1,12 @@
+error: constructor `should_spawn` has the same name as the type
+  --> $DIR/self_named_constructors.rs:7:5
+   |
+LL | /     pub fn should_spawn() -> ShouldSpawn {
+LL | |         ShouldSpawn
+LL | |     }
+   | |_____^
+   |
+   = note: `-D clippy::self-named-constructors` implied by `-D warnings`
+
+error: aborting due to previous error
+
diff --git a/tests/ui/unit_arg.rs b/tests/ui/unit_arg.rs
index df0fdaccb34..535683729f6 100644
--- a/tests/ui/unit_arg.rs
+++ b/tests/ui/unit_arg.rs
@@ -7,7 +7,7 @@
     clippy::unnecessary_wraps,
     clippy::or_fun_call,
     clippy::needless_question_mark,
-    clippy::self_named_constructor
+    clippy::self_named_constructors
 )]
 
 use std::fmt::Debug;
diff --git a/tests/ui/use_self.fixed b/tests/ui/use_self.fixed
index 23fc7632511..dcf818f8076 100644
--- a/tests/ui/use_self.fixed
+++ b/tests/ui/use_self.fixed
@@ -8,7 +8,7 @@
     clippy::should_implement_trait,
     clippy::upper_case_acronyms,
     clippy::from_over_into,
-    clippy::self_named_constructor
+    clippy::self_named_constructors
 )]
 
 #[macro_use]
diff --git a/tests/ui/use_self.rs b/tests/ui/use_self.rs
index bb46a339923..9da6fef7a38 100644
--- a/tests/ui/use_self.rs
+++ b/tests/ui/use_self.rs
@@ -8,7 +8,7 @@
     clippy::should_implement_trait,
     clippy::upper_case_acronyms,
     clippy::from_over_into,
-    clippy::self_named_constructor
+    clippy::self_named_constructors
 )]
 
 #[macro_use]
-- 
cgit 1.4.1-3-g733a5


From dbb10b87f8e4365298ed33a6ed96bffe66a1951e Mon Sep 17 00:00:00 2001
From: Hrishi Dharam <hdharam@berkeley.edu>
Date: Sun, 2 May 2021 12:42:28 -0400
Subject: add xor-swap lint

---
 CHANGELOG.md             |   1 +
 clippy_lints/src/lib.rs  |   3 ++
 clippy_lints/src/swap.rs | 117 +++++++++++++++++++++++++++++++++++++++++++++--
 tests/ui/swap.fixed      |  42 +++++++++++++++++
 tests/ui/swap.rs         |  48 +++++++++++++++++++
 tests/ui/swap.stderr     |  36 +++++++++++++--
 6 files changed, 239 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index acbefc8064d..601fa83ad89 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2900,6 +2900,7 @@ Released 2018-09-13
 [`wrong_pub_self_convention`]: https://rust-lang.github.io/rust-clippy/master/index.html#wrong_pub_self_convention
 [`wrong_self_convention`]: https://rust-lang.github.io/rust-clippy/master/index.html#wrong_self_convention
 [`wrong_transmute`]: https://rust-lang.github.io/rust-clippy/master/index.html#wrong_transmute
+[`xor_swap`]: https://rust-lang.github.io/rust-clippy/master/index.html#xor_swap
 [`zero_divided_by_zero`]: https://rust-lang.github.io/rust-clippy/master/index.html#zero_divided_by_zero
 [`zero_prefixed_literal`]: https://rust-lang.github.io/rust-clippy/master/index.html#zero_prefixed_literal
 [`zero_ptr`]: https://rust-lang.github.io/rust-clippy/master/index.html#zero_ptr
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index f49b382c5ea..c4197bab82a 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -922,6 +922,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         suspicious_trait_impl::SUSPICIOUS_OP_ASSIGN_IMPL,
         swap::ALMOST_SWAPPED,
         swap::MANUAL_SWAP,
+        swap::XOR_SWAP,
         tabs_in_doc_comments::TABS_IN_DOC_COMMENTS,
         temporary_assignment::TEMPORARY_ASSIGNMENT,
         to_digit_is_some::TO_DIGIT_IS_SOME,
@@ -1419,6 +1420,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(suspicious_trait_impl::SUSPICIOUS_OP_ASSIGN_IMPL),
         LintId::of(swap::ALMOST_SWAPPED),
         LintId::of(swap::MANUAL_SWAP),
+        LintId::of(swap::XOR_SWAP),
         LintId::of(tabs_in_doc_comments::TABS_IN_DOC_COMMENTS),
         LintId::of(temporary_assignment::TEMPORARY_ASSIGNMENT),
         LintId::of(to_digit_is_some::TO_DIGIT_IS_SOME),
@@ -1647,6 +1649,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(strings::STRING_FROM_UTF8_AS_BYTES),
         LintId::of(strlen_on_c_strings::STRLEN_ON_C_STRINGS),
         LintId::of(swap::MANUAL_SWAP),
+        LintId::of(swap::XOR_SWAP),
         LintId::of(temporary_assignment::TEMPORARY_ASSIGNMENT),
         LintId::of(transmute::CROSSPOINTER_TRANSMUTE),
         LintId::of(transmute::TRANSMUTES_EXPRESSIBLE_AS_PTR_CASTS),
diff --git a/clippy_lints/src/swap.rs b/clippy_lints/src/swap.rs
index 4fa8e77a67b..6dceec65574 100644
--- a/clippy_lints/src/swap.rs
+++ b/clippy_lints/src/swap.rs
@@ -1,14 +1,15 @@
-use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::{differing_macro_contexts, eq_expr_value};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
-use rustc_hir::{Block, Expr, ExprKind, PatKind, QPath, StmtKind};
+use rustc_hir::{BinOpKind, Block, Expr, ExprKind, PatKind, QPath, Stmt, StmtKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::source_map::Spanned;
 use rustc_span::sym;
 
 declare_clippy_lint! {
@@ -64,12 +65,43 @@ declare_clippy_lint! {
     "`foo = bar; bar = foo` sequence"
 }
 
-declare_lint_pass!(Swap => [MANUAL_SWAP, ALMOST_SWAPPED]);
+declare_clippy_lint! {
+    /// **What it does:** Checks for uses of xor-based swaps.
+    ///
+    /// **Why is this bad?** The `std::mem::swap` function exposes the intent better
+    /// without deinitializing or copying either variable.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// let mut a = 1;
+    /// let mut b = 2;
+    ///
+    /// a ^= b;
+    /// b ^= a;
+    /// a ^= b;
+    /// ```
+    ///
+    /// Use std::mem::swap() instead:
+    /// ```rust
+    /// let mut a = 1;
+    /// let mut b = 2;
+    /// std::mem::swap(&mut a, &mut b);
+    /// ```
+    pub XOR_SWAP,
+    complexity,
+    "xor-based swap of two variables"
+}
+
+declare_lint_pass!(Swap => [MANUAL_SWAP, ALMOST_SWAPPED, XOR_SWAP]);
 
 impl<'tcx> LateLintPass<'tcx> for Swap {
     fn check_block(&mut self, cx: &LateContext<'tcx>, block: &'tcx Block<'_>) {
         check_manual_swap(cx, block);
         check_suspicious_swap(cx, block);
+        check_xor_swap(cx, block);
     }
 }
 
@@ -262,3 +294,82 @@ fn check_suspicious_swap(cx: &LateContext<'_>, block: &Block<'_>) {
         }
     }
 }
+
+/// Implementation of the `XOR_SWAP` lint.
+fn check_xor_swap(cx: &LateContext<'_>, block: &Block<'_>) {
+    for window in block.stmts.windows(3) {
+        if_chain! {
+            if let Some((lhs0, rhs0)) = extract_sides_of_xor_assign(&window[0]);
+            if let Some((lhs1, rhs1)) = extract_sides_of_xor_assign(&window[1]);
+            if let Some((lhs2, rhs2)) = extract_sides_of_xor_assign(&window[2]);
+            if eq_expr_value(cx, lhs0, rhs1)
+               && eq_expr_value(cx, rhs1, lhs2)
+               && eq_expr_value(cx, rhs0, lhs1)
+               && eq_expr_value(cx, lhs1, rhs2);
+            then {
+                let span = window[0].span.to(window[2].span);
+                let mut applicability = Applicability::MachineApplicable;
+                match check_for_slice(cx, lhs0, rhs0) {
+                    Slice::Swappable(slice, idx0, idx1) => {
+                        if let Some(slice) = Sugg::hir_opt(cx, slice) {
+                            span_lint_and_sugg(
+                                cx,
+                                XOR_SWAP,
+                                span,
+                                &format!(
+                                    "this xor-based swap of the elements of `{}` can be \
+                                    more clearly expressed using `.swap`",
+                                    slice
+                                ),
+                                "try",
+                                format!(
+                                    "{}.swap({}, {})",
+                                    slice.maybe_par(),
+                                    snippet_with_applicability(cx, idx0.span, "..", &mut applicability),
+                                    snippet_with_applicability(cx, idx1.span, "..", &mut applicability)
+                                ),
+                                applicability
+                            )
+                        }
+                    }
+                    Slice::None => {
+                        if let (Some(first), Some(second)) = (Sugg::hir_opt(cx, lhs0), Sugg::hir_opt(cx, rhs0)) {
+                            span_lint_and_sugg(
+                                cx,
+                                XOR_SWAP,
+                                span,
+                                &format!(
+                                    "this xor-based swap of `{}` and `{}` can be \
+                                    more clearly expressed using `std::mem::swap`",
+                                    first, second
+                                ),
+                                "try",
+                                format!("std::mem::swap({}, {})", first.mut_addr(), second.mut_addr()),
+                                applicability,
+                            );
+                        }
+                    }
+                    Slice::NotSwappable => {}
+                }
+            }
+        };
+    }
+}
+
+/// Returns the lhs and rhs of an xor assignment statement.  
+fn extract_sides_of_xor_assign<'a, 'hir>(stmt: &'a Stmt<'hir>) -> Option<(&'a Expr<'hir>, &'a Expr<'hir>)> {
+    if let StmtKind::Semi(expr) = stmt.kind {
+        if let ExprKind::AssignOp(
+            Spanned {
+                node: BinOpKind::BitXor,
+                ..
+            },
+            lhs,
+            rhs,
+        ) = expr.kind
+        {
+            return Some((lhs, rhs));
+        }
+    }
+    None
+}
diff --git a/tests/ui/swap.fixed b/tests/ui/swap.fixed
index 0f8f839a0d5..e0d412b2198 100644
--- a/tests/ui/swap.fixed
+++ b/tests/ui/swap.fixed
@@ -60,6 +60,43 @@ fn vec() {
     foo.swap(0, 1);
 }
 
+fn xor_swap_locals() {
+    // This is an xor-based swap of local variables.
+    let mut a = 0;
+    let mut b = 1;
+    std::mem::swap(&mut a, &mut b)
+}
+
+fn xor_field_swap() {
+    // This is an xor-based swap of fields in a struct.
+    let mut bar = Bar { a: 0, b: 1 };
+    std::mem::swap(&mut bar.a, &mut bar.b)
+}
+
+fn xor_slice_swap() {
+    // This is an xor-based swap of a slice
+    let foo = &mut [1, 2];
+    foo.swap(0, 1)
+}
+
+fn xor_no_swap() {
+    // This is a sequence of xor-assignment statements that doesn't result in a swap.
+    let mut a = 0;
+    let mut b = 1;
+    let mut c = 2;
+    a ^= b;
+    b ^= c;
+    a ^= c;
+    c ^= a;
+}
+
+fn xor_unswappable_slice() {
+    let foo = &mut [vec![1, 2], vec![3, 4]];
+    foo[0][1] ^= foo[1][0];
+    foo[1][0] ^= foo[0][0];
+    foo[0][1] ^= foo[1][0];
+}
+
 #[rustfmt::skip]
 fn main() {
     field();
@@ -67,6 +104,11 @@ fn main() {
     slice();
     unswappable_slice();
     vec();
+    xor_swap_locals();
+    xor_field_swap();
+    xor_slice_swap();
+    xor_no_swap();
+    xor_unswappable_slice();
 
     let mut a = 42;
     let mut b = 1337;
diff --git a/tests/ui/swap.rs b/tests/ui/swap.rs
index 5763d9e82d4..6f8fd6e4c91 100644
--- a/tests/ui/swap.rs
+++ b/tests/ui/swap.rs
@@ -66,6 +66,49 @@ fn vec() {
     foo.swap(0, 1);
 }
 
+fn xor_swap_locals() {
+    // This is an xor-based swap of local variables.
+    let mut a = 0;
+    let mut b = 1;
+    a ^= b;
+    b ^= a;
+    a ^= b;
+}
+
+fn xor_field_swap() {
+    // This is an xor-based swap of fields in a struct.
+    let mut bar = Bar { a: 0, b: 1 };
+    bar.a ^= bar.b;
+    bar.b ^= bar.a;
+    bar.a ^= bar.b;
+}
+
+fn xor_slice_swap() {
+    // This is an xor-based swap of a slice
+    let foo = &mut [1, 2];
+    foo[0] ^= foo[1];
+    foo[1] ^= foo[0];
+    foo[0] ^= foo[1];
+}
+
+fn xor_no_swap() {
+    // This is a sequence of xor-assignment statements that doesn't result in a swap.
+    let mut a = 0;
+    let mut b = 1;
+    let mut c = 2;
+    a ^= b;
+    b ^= c;
+    a ^= c;
+    c ^= a;
+}
+
+fn xor_unswappable_slice() {
+    let foo = &mut [vec![1, 2], vec![3, 4]];
+    foo[0][1] ^= foo[1][0];
+    foo[1][0] ^= foo[0][0];
+    foo[0][1] ^= foo[1][0];
+}
+
 #[rustfmt::skip]
 fn main() {
     field();
@@ -73,6 +116,11 @@ fn main() {
     slice();
     unswappable_slice();
     vec();
+    xor_swap_locals();
+    xor_field_swap();
+    xor_slice_swap();
+    xor_no_swap();
+    xor_unswappable_slice();
 
     let mut a = 42;
     let mut b = 1337;
diff --git a/tests/ui/swap.stderr b/tests/ui/swap.stderr
index f49bcfedf3a..55b470821e2 100644
--- a/tests/ui/swap.stderr
+++ b/tests/ui/swap.stderr
@@ -24,8 +24,34 @@ LL | |     foo[0] = foo[1];
 LL | |     foo[1] = temp;
    | |_________________^ help: try: `foo.swap(0, 1)`
 
+error: this xor-based swap of `a` and `b` can be more clearly expressed using `std::mem::swap`
+  --> $DIR/swap.rs:73:5
+   |
+LL | /     a ^= b;
+LL | |     b ^= a;
+LL | |     a ^= b;
+   | |___________^ help: try: `std::mem::swap(&mut a, &mut b)`
+   |
+   = note: `-D clippy::xor-swap` implied by `-D warnings`
+
+error: this xor-based swap of `bar.a` and `bar.b` can be more clearly expressed using `std::mem::swap`
+  --> $DIR/swap.rs:81:5
+   |
+LL | /     bar.a ^= bar.b;
+LL | |     bar.b ^= bar.a;
+LL | |     bar.a ^= bar.b;
+   | |___________________^ help: try: `std::mem::swap(&mut bar.a, &mut bar.b)`
+
+error: this xor-based swap of the elements of `foo` can be more clearly expressed using `.swap`
+  --> $DIR/swap.rs:89:5
+   |
+LL | /     foo[0] ^= foo[1];
+LL | |     foo[1] ^= foo[0];
+LL | |     foo[0] ^= foo[1];
+   | |_____________________^ help: try: `foo.swap(0, 1)`
+
 error: this looks like you are swapping `a` and `b` manually
-  --> $DIR/swap.rs:83:7
+  --> $DIR/swap.rs:131:7
    |
 LL |       ; let t = a;
    |  _______^
@@ -36,7 +62,7 @@ LL | |     b = t;
    = note: or maybe you should use `std::mem::replace`?
 
 error: this looks like you are swapping `c.0` and `a` manually
-  --> $DIR/swap.rs:92:7
+  --> $DIR/swap.rs:140:7
    |
 LL |       ; let t = c.0;
    |  _______^
@@ -47,7 +73,7 @@ LL | |     a = t;
    = note: or maybe you should use `std::mem::replace`?
 
 error: this looks like you are trying to swap `a` and `b`
-  --> $DIR/swap.rs:80:5
+  --> $DIR/swap.rs:128:5
    |
 LL | /     a = b;
 LL | |     b = a;
@@ -57,7 +83,7 @@ LL | |     b = a;
    = note: or maybe you should use `std::mem::replace`?
 
 error: this looks like you are trying to swap `c.0` and `a`
-  --> $DIR/swap.rs:89:5
+  --> $DIR/swap.rs:137:5
    |
 LL | /     c.0 = a;
 LL | |     a = c.0;
@@ -65,5 +91,5 @@ LL | |     a = c.0;
    |
    = note: or maybe you should use `std::mem::replace`?
 
-error: aborting due to 7 previous errors
+error: aborting due to 10 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From e9004b063f9d6e3b0d789c260b096a8a24a1c935 Mon Sep 17 00:00:00 2001
From: Léo Lanteri Thauvin <leseulartichaut@gmail.com>
Date: Thu, 29 Jul 2021 14:23:12 +0200
Subject: Remove `or_patterns` feature gate in example

---
 clippy_lints/src/unnested_or_patterns.rs | 2 --
 1 file changed, 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unnested_or_patterns.rs b/clippy_lints/src/unnested_or_patterns.rs
index 9acfbc994b3..c8a231341b7 100644
--- a/clippy_lints/src/unnested_or_patterns.rs
+++ b/clippy_lints/src/unnested_or_patterns.rs
@@ -35,8 +35,6 @@ declare_clippy_lint! {
     /// ```
     /// Use instead:
     /// ```rust
-    /// #![feature(or_patterns)]
-    ///
     /// fn main() {
     ///     if let Some(0 | 2) = Some(0) {}
     /// }
-- 
cgit 1.4.1-3-g733a5


From fe75faa6eeafe22eb5e6ffae652c7514792334ab Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Fri, 30 Jul 2021 22:59:20 -0400
Subject: Fix `while_let_on_iterator` Reborrow mutable references rather then
 take a reference to them.

---
 clippy_lints/src/loops/while_let_on_iterator.rs | 13 +++++++++++--
 tests/ui/while_let_on_iterator.fixed            | 23 +++++++++++++++++++++++
 tests/ui/while_let_on_iterator.rs               | 23 +++++++++++++++++++++++
 tests/ui/while_let_on_iterator.stderr           | 16 ++++++++++++++--
 4 files changed, 71 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/while_let_on_iterator.rs b/clippy_lints/src/loops/while_let_on_iterator.rs
index d57588716a5..6655e2e445c 100644
--- a/clippy_lints/src/loops/while_let_on_iterator.rs
+++ b/clippy_lints/src/loops/while_let_on_iterator.rs
@@ -7,7 +7,7 @@ use clippy_utils::{
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_expr, ErasedMap, NestedVisitorMap, Visitor};
-use rustc_hir::{def::Res, Expr, ExprKind, HirId, Local, MatchSource, Node, PatKind, QPath, UnOp};
+use rustc_hir::{def::Res, Expr, ExprKind, HirId, Local, MatchSource, Mutability, Node, PatKind, QPath, UnOp};
 use rustc_lint::LateContext;
 use rustc_span::{symbol::sym, Span, Symbol};
 
@@ -48,7 +48,12 @@ pub(super) fn check(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
     // borrowed mutably. TODO: If the struct can be partially moved from and the struct isn't used
     // afterwards a mutable borrow of a field isn't necessary.
     let ref_mut = if !iter_expr.fields.is_empty() || needs_mutable_borrow(cx, &iter_expr, loop_expr) {
-        "&mut "
+        if cx.typeck_results().node_type(iter_expr.hir_id).ref_mutability() == Some(Mutability::Mut) {
+            // Reborrow for mutable references. It may not be possible to get a mutable reference here.
+            "&mut *"
+        } else {
+            "&mut "
+        }
     } else {
         ""
     };
@@ -69,6 +74,8 @@ pub(super) fn check(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
 struct IterExpr {
     /// The span of the whole expression, not just the path and fields stored here.
     span: Span,
+    /// The HIR id of the whole expression, not just the path and fields stored here.
+    hir_id: HirId,
     /// The fields used, in order of child to parent.
     fields: Vec<Symbol>,
     /// The path being used.
@@ -78,12 +85,14 @@ struct IterExpr {
 /// the expression might have side effects.
 fn try_parse_iter_expr(cx: &LateContext<'_>, mut e: &Expr<'_>) -> Option<IterExpr> {
     let span = e.span;
+    let hir_id = e.hir_id;
     let mut fields = Vec::new();
     loop {
         match e.kind {
             ExprKind::Path(ref path) => {
                 break Some(IterExpr {
                     span,
+                    hir_id,
                     fields,
                     path: cx.qpath_res(path, e.hir_id),
                 });
diff --git a/tests/ui/while_let_on_iterator.fixed b/tests/ui/while_let_on_iterator.fixed
index 52e80ceee83..52c70ced2bd 100644
--- a/tests/ui/while_let_on_iterator.fixed
+++ b/tests/ui/while_let_on_iterator.fixed
@@ -334,6 +334,29 @@ fn issue7249() {
     x();
 }
 
+fn issue7510() {
+    let mut it = 0..10;
+    let it = &mut it;
+    // Needs to reborrow `it` as the binding isn't mutable
+    for x in &mut *it {
+        if x % 2 == 0 {
+            break;
+        }
+    }
+    println!("{}", it.next().unwrap());
+
+    struct S<T>(T);
+    let mut it = 0..10;
+    let it = S(&mut it);
+    // Needs to reborrow `it.0` as the binding isn't mutable
+    for x in &mut *it.0 {
+        if x % 2 == 0 {
+            break;
+        }
+    }
+    println!("{}", it.0.next().unwrap());
+}
+
 fn main() {
     let mut it = 0..20;
     for _ in it {
diff --git a/tests/ui/while_let_on_iterator.rs b/tests/ui/while_let_on_iterator.rs
index 5078a3c9028..8434acaf582 100644
--- a/tests/ui/while_let_on_iterator.rs
+++ b/tests/ui/while_let_on_iterator.rs
@@ -334,6 +334,29 @@ fn issue7249() {
     x();
 }
 
+fn issue7510() {
+    let mut it = 0..10;
+    let it = &mut it;
+    // Needs to reborrow `it` as the binding isn't mutable
+    while let Some(x) = it.next() {
+        if x % 2 == 0 {
+            break;
+        }
+    }
+    println!("{}", it.next().unwrap());
+
+    struct S<T>(T);
+    let mut it = 0..10;
+    let it = S(&mut it);
+    // Needs to reborrow `it.0` as the binding isn't mutable
+    while let Some(x) = it.0.next() {
+        if x % 2 == 0 {
+            break;
+        }
+    }
+    println!("{}", it.0.next().unwrap());
+}
+
 fn main() {
     let mut it = 0..20;
     while let Some(..) = it.next() {
diff --git a/tests/ui/while_let_on_iterator.stderr b/tests/ui/while_let_on_iterator.stderr
index cb0afeae15e..50bcc26cec2 100644
--- a/tests/ui/while_let_on_iterator.stderr
+++ b/tests/ui/while_let_on_iterator.stderr
@@ -111,10 +111,22 @@ LL |         while let Some(x) = it.next() {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for x in &mut it`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:339:5
+  --> $DIR/while_let_on_iterator.rs:341:5
+   |
+LL |     while let Some(x) = it.next() {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for x in &mut *it`
+
+error: this loop could be written as a `for` loop
+  --> $DIR/while_let_on_iterator.rs:352:5
+   |
+LL |     while let Some(x) = it.0.next() {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for x in &mut *it.0`
+
+error: this loop could be written as a `for` loop
+  --> $DIR/while_let_on_iterator.rs:362:5
    |
 LL |     while let Some(..) = it.next() {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for _ in it`
 
-error: aborting due to 19 previous errors
+error: aborting due to 21 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 205aa88921ce63898f7fd3db6e9070c70987be2e Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sat, 31 Jul 2021 09:32:54 -0400
Subject: Fix `while_let_on_iterator` When the iterator is one field within a
 local correctly check for usages of the field

---
 clippy_lints/src/loops/while_let_on_iterator.rs | 2 +-
 tests/ui/while_let_on_iterator.fixed            | 9 +++++++++
 tests/ui/while_let_on_iterator.rs               | 9 +++++++++
 tests/ui/while_let_on_iterator.stderr           | 2 +-
 4 files changed, 20 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/while_let_on_iterator.rs b/clippy_lints/src/loops/while_let_on_iterator.rs
index 6655e2e445c..ef822e0cbe5 100644
--- a/clippy_lints/src/loops/while_let_on_iterator.rs
+++ b/clippy_lints/src/loops/while_let_on_iterator.rs
@@ -146,7 +146,7 @@ fn is_expr_same_child_or_parent_field(cx: &LateContext<'_>, expr: &Expr<'_>, fie
     match expr.kind {
         ExprKind::Field(base, name) => {
             if let Some((head_field, tail_fields)) = fields.split_first() {
-                if name.name == *head_field && is_expr_same_field(cx, base, fields, path_res) {
+                if name.name == *head_field && is_expr_same_field(cx, base, tail_fields, path_res) {
                     return true;
                 }
                 // Check if the expression is a parent field
diff --git a/tests/ui/while_let_on_iterator.fixed b/tests/ui/while_let_on_iterator.fixed
index 52c70ced2bd..cdcdd808c94 100644
--- a/tests/ui/while_let_on_iterator.fixed
+++ b/tests/ui/while_let_on_iterator.fixed
@@ -357,6 +357,15 @@ fn issue7510() {
     println!("{}", it.0.next().unwrap());
 }
 
+fn exact_match_with_single_field() {
+    struct S<T>(T);
+    let mut s = S(0..10);
+    // Don't lint. `s.0` is used inside the loop.
+    while let Some(_) = s.0.next() {
+        let _ = &mut s.0;
+    }
+}
+
 fn main() {
     let mut it = 0..20;
     for _ in it {
diff --git a/tests/ui/while_let_on_iterator.rs b/tests/ui/while_let_on_iterator.rs
index 8434acaf582..72f34257d1f 100644
--- a/tests/ui/while_let_on_iterator.rs
+++ b/tests/ui/while_let_on_iterator.rs
@@ -357,6 +357,15 @@ fn issue7510() {
     println!("{}", it.0.next().unwrap());
 }
 
+fn exact_match_with_single_field() {
+    struct S<T>(T);
+    let mut s = S(0..10);
+    // Don't lint. `s.0` is used inside the loop.
+    while let Some(_) = s.0.next() {
+        let _ = &mut s.0;
+    }
+}
+
 fn main() {
     let mut it = 0..20;
     while let Some(..) = it.next() {
diff --git a/tests/ui/while_let_on_iterator.stderr b/tests/ui/while_let_on_iterator.stderr
index 50bcc26cec2..ff9b08996da 100644
--- a/tests/ui/while_let_on_iterator.stderr
+++ b/tests/ui/while_let_on_iterator.stderr
@@ -123,7 +123,7 @@ LL |     while let Some(x) = it.0.next() {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for x in &mut *it.0`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:362:5
+  --> $DIR/while_let_on_iterator.rs:371:5
    |
 LL |     while let Some(..) = it.next() {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for _ in it`
-- 
cgit 1.4.1-3-g733a5


From 69d439065eccef7f554e7506236fafa0b4af19eb Mon Sep 17 00:00:00 2001
From: Dharma Saputra Wijaya <dswijj@gmail.com>
Date: Sun, 1 Aug 2021 17:47:29 +0800
Subject: Handle `Result` on `map_flatten` lint

Adds a check on `.map(..).flatten()` on `Result` type that follows the
behaviour on `Option` type.
---
 clippy_lints/src/methods/map_flatten.rs | 42 ++++++++++++++++++++++-----------
 tests/ui/map_flatten.fixed              |  4 ++++
 tests/ui/map_flatten.rs                 |  4 ++++
 tests/ui/map_flatten.stderr             | 20 ++++++++++------
 4 files changed, 49 insertions(+), 21 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/map_flatten.rs b/clippy_lints/src/methods/map_flatten.rs
index e8ad16bc0de..08d3a7ce92b 100644
--- a/clippy_lints/src/methods/map_flatten.rs
+++ b/clippy_lints/src/methods/map_flatten.rs
@@ -52,18 +52,32 @@ pub(super) fn check<'tcx>(
         );
     }
 
-    // lint if caller of `.map().flatten()` is an Option
-    if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(recv), sym::option_type) {
-        let func_snippet = snippet(cx, map_arg.span, "..");
-        let hint = format!(".and_then({})", func_snippet);
-        span_lint_and_sugg(
-            cx,
-            MAP_FLATTEN,
-            expr.span.with_lo(recv.span.hi()),
-            "called `map(..).flatten()` on an `Option`",
-            "try using `and_then` instead",
-            hint,
-            Applicability::MachineApplicable,
-        );
-    }
+    // lint if caller of `.map().flatten()` is an Option or Result
+    let caller_type = match cx.typeck_results().expr_ty(recv).kind() {
+        ty::Adt(adt, _) => {
+            if cx.tcx.is_diagnostic_item(sym::option_type, adt.did) {
+                "Option"
+            } else if cx.tcx.is_diagnostic_item(sym::result_type, adt.did) {
+                "Result"
+            } else {
+                return;
+            }
+        },
+        _ => {
+            return;
+        },
+    };
+
+    let func_snippet = snippet(cx, map_arg.span, "..");
+    let hint = format!(".and_then({})", func_snippet);
+    let lint_info = format!("called `map(..).flatten()` on an `{}`", caller_type);
+    span_lint_and_sugg(
+        cx,
+        MAP_FLATTEN,
+        expr.span.with_lo(recv.span.hi()),
+        &lint_info,
+        "try using `and_then` instead",
+        hint,
+        Applicability::MachineApplicable,
+    );
 }
diff --git a/tests/ui/map_flatten.fixed b/tests/ui/map_flatten.fixed
index 773b5914439..18846c898da 100644
--- a/tests/ui/map_flatten.fixed
+++ b/tests/ui/map_flatten.fixed
@@ -5,6 +5,7 @@
 #![allow(clippy::missing_docs_in_private_items)]
 #![allow(clippy::map_identity)]
 #![allow(clippy::unnecessary_wraps)]
+#![feature(result_flattening)]
 
 fn main() {
     // mapping to Option on Iterator
@@ -23,4 +24,7 @@ fn main() {
 
     // mapping to Option on Option
     let _: Option<_> = (Some(Some(1))).and_then(|x| x);
+
+    // mapping to Result on Result
+    let _: Result<_, &str> = (Ok(Ok(1))).and_then(|x| x);
 }
diff --git a/tests/ui/map_flatten.rs b/tests/ui/map_flatten.rs
index 578bd877267..01db27876da 100644
--- a/tests/ui/map_flatten.rs
+++ b/tests/ui/map_flatten.rs
@@ -5,6 +5,7 @@
 #![allow(clippy::missing_docs_in_private_items)]
 #![allow(clippy::map_identity)]
 #![allow(clippy::unnecessary_wraps)]
+#![feature(result_flattening)]
 
 fn main() {
     // mapping to Option on Iterator
@@ -23,4 +24,7 @@ fn main() {
 
     // mapping to Option on Option
     let _: Option<_> = (Some(Some(1))).map(|x| x).flatten();
+
+    // mapping to Result on Result
+    let _: Result<_, &str> = (Ok(Ok(1))).map(|x| x).flatten();
 }
diff --git a/tests/ui/map_flatten.stderr b/tests/ui/map_flatten.stderr
index 756e6e818ad..38457c8ea4d 100644
--- a/tests/ui/map_flatten.stderr
+++ b/tests/ui/map_flatten.stderr
@@ -1,5 +1,5 @@
 error: called `map(..).flatten()` on an `Iterator`
-  --> $DIR/map_flatten.rs:16:46
+  --> $DIR/map_flatten.rs:17:46
    |
 LL |     let _: Vec<_> = vec![5_i8; 6].into_iter().map(option_id).flatten().collect();
    |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try using `filter_map` instead: `.filter_map(option_id)`
@@ -7,34 +7,40 @@ LL |     let _: Vec<_> = vec![5_i8; 6].into_iter().map(option_id).flatten().coll
    = note: `-D clippy::map-flatten` implied by `-D warnings`
 
 error: called `map(..).flatten()` on an `Iterator`
-  --> $DIR/map_flatten.rs:17:46
+  --> $DIR/map_flatten.rs:18:46
    |
 LL |     let _: Vec<_> = vec![5_i8; 6].into_iter().map(option_id_ref).flatten().collect();
    |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try using `filter_map` instead: `.filter_map(option_id_ref)`
 
 error: called `map(..).flatten()` on an `Iterator`
-  --> $DIR/map_flatten.rs:18:46
+  --> $DIR/map_flatten.rs:19:46
    |
 LL |     let _: Vec<_> = vec![5_i8; 6].into_iter().map(option_id_closure).flatten().collect();
    |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try using `filter_map` instead: `.filter_map(option_id_closure)`
 
 error: called `map(..).flatten()` on an `Iterator`
-  --> $DIR/map_flatten.rs:19:46
+  --> $DIR/map_flatten.rs:20:46
    |
 LL |     let _: Vec<_> = vec![5_i8; 6].into_iter().map(|x| x.checked_add(1)).flatten().collect();
    |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try using `filter_map` instead: `.filter_map(|x| x.checked_add(1))`
 
 error: called `map(..).flatten()` on an `Iterator`
-  --> $DIR/map_flatten.rs:22:46
+  --> $DIR/map_flatten.rs:23:46
    |
 LL |     let _: Vec<_> = vec![5_i8; 6].into_iter().map(|x| 0..x).flatten().collect();
    |                                              ^^^^^^^^^^^^^^^^^^^^^^^^ help: try using `flat_map` instead: `.flat_map(|x| 0..x)`
 
 error: called `map(..).flatten()` on an `Option`
-  --> $DIR/map_flatten.rs:25:39
+  --> $DIR/map_flatten.rs:26:39
    |
 LL |     let _: Option<_> = (Some(Some(1))).map(|x| x).flatten();
    |                                       ^^^^^^^^^^^^^^^^^^^^^ help: try using `and_then` instead: `.and_then(|x| x)`
 
-error: aborting due to 6 previous errors
+error: called `map(..).flatten()` on an `Result`
+  --> $DIR/map_flatten.rs:29:41
+   |
+LL |     let _: Result<_, &str> = (Ok(Ok(1))).map(|x| x).flatten();
+   |                                         ^^^^^^^^^^^^^^^^^^^^^ help: try using `and_then` instead: `.and_then(|x| x)`
+
+error: aborting due to 7 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From b7d80e7d65d40eb1901d1e1c342854db91e263be Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Mon, 2 Aug 2021 17:25:58 +0200
Subject: Updated `define_Conf!` to support multi-line doc comments

---
 clippy_lints/src/utils/conf.rs                     | 134 +++++++++++++++------
 .../src/utils/internal_lints/metadata_collector.rs |   9 +-
 2 files changed, 107 insertions(+), 36 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 44d3d456342..a28b1d78f7d 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -36,13 +36,13 @@ impl TryConf {
 /// See (rust-clippy#7172)
 macro_rules! define_Conf {
     ($(
-        #[doc = $doc:literal]
+        $(#[doc = $doc:literal])+
         $(#[conf_deprecated($dep:literal)])?
         ($name:ident: $ty:ty = $default:expr),
     )*) => {
         /// Clippy lint configuration
         pub struct Conf {
-            $(#[doc = $doc] pub $name: $ty,)*
+            $($(#[doc = $doc])+ pub $name: $ty,)*
         }
 
         mod defaults {
@@ -119,7 +119,7 @@ macro_rules! define_Conf {
                                 stringify!($name),
                                 stringify!($ty),
                                 format!("{:?}", super::defaults::$name()),
-                                $doc,
+                                concat!($($doc, '\n',)*),
                                 deprecation_reason,
                             )
                         },
@@ -132,18 +132,30 @@ macro_rules! define_Conf {
 
 // N.B., this macro is parsed by util/lintlib.py
 define_Conf! {
-    /// Lint: ENUM_VARIANT_NAMES, LARGE_TYPES_PASSED_BY_VALUE, TRIVIALLY_COPY_PASS_BY_REF, UNNECESSARY_WRAPS, UPPER_CASE_ACRONYMS, WRONG_SELF_CONVENTION. Suppress lints whenever the suggested change would cause breakage for other crates.
+    /// Lint: ENUM_VARIANT_NAMES, LARGE_TYPES_PASSED_BY_VALUE, TRIVIALLY_COPY_PASS_BY_REF, UNNECESSARY_WRAPS, UPPER_CASE_ACRONYMS, WRONG_SELF_CONVENTION.
+    ///
+    /// Suppress lints whenever the suggested change would cause breakage for other crates.
     (avoid_breaking_exported_api: bool = true),
-    /// Lint: MANUAL_STR_REPEAT, CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR, IF_THEN_SOME_ELSE_NONE. The minimum rust version that the project supports
+    /// Lint: MANUAL_STR_REPEAT, CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR, IF_THEN_SOME_ELSE_NONE.
+    ///
+    /// The minimum rust version that the project supports
     (msrv: Option<String> = None),
-    /// Lint: BLACKLISTED_NAME. The list of blacklisted names to lint about. NB: `bar` is not here since it has legitimate uses
+    /// Lint: BLACKLISTED_NAME.
+    ///
+    /// The list of blacklisted names to lint about. NB: `bar` is not here since it has legitimate uses
     (blacklisted_names: Vec<String> = ["foo", "baz", "quux"].iter().map(ToString::to_string).collect()),
-    /// Lint: COGNITIVE_COMPLEXITY. The maximum cognitive complexity a function can have
+    /// Lint: COGNITIVE_COMPLEXITY.
+    ///
+    /// The maximum cognitive complexity a function can have
     (cognitive_complexity_threshold: u64 = 25),
-    /// DEPRECATED LINT: CYCLOMATIC_COMPLEXITY. Use the Cognitive Complexity lint instead.
+    /// DEPRECATED LINT: CYCLOMATIC_COMPLEXITY.
+    ///
+    /// Use the Cognitive Complexity lint instead.
     #[conf_deprecated("Please use `cognitive-complexity-threshold` instead")]
     (cyclomatic_complexity_threshold: Option<u64> = None),
-    /// Lint: DOC_MARKDOWN. The list of words this lint should not consider as identifiers needing ticks
+    /// Lint: DOC_MARKDOWN.
+    ///
+    /// The list of words this lint should not consider as identifiers needing ticks
     (doc_valid_idents: Vec<String> = [
         "KiB", "MiB", "GiB", "TiB", "PiB", "EiB",
         "DirectX",
@@ -164,55 +176,109 @@ define_Conf! {
         "MinGW",
         "CamelCase",
     ].iter().map(ToString::to_string).collect()),
-    /// Lint: TOO_MANY_ARGUMENTS. The maximum number of argument a function or method can have
+    /// Lint: TOO_MANY_ARGUMENTS.
+    ///
+    /// The maximum number of argument a function or method can have
     (too_many_arguments_threshold: u64 = 7),
-    /// Lint: TYPE_COMPLEXITY. The maximum complexity a type can have
+    /// Lint: TYPE_COMPLEXITY.
+    ///
+    /// The maximum complexity a type can have
     (type_complexity_threshold: u64 = 250),
-    /// Lint: MANY_SINGLE_CHAR_NAMES. The maximum number of single char bindings a scope may have
+    /// Lint: MANY_SINGLE_CHAR_NAMES.
+    ///
+    /// The maximum number of single char bindings a scope may have
     (single_char_binding_names_threshold: u64 = 4),
-    /// Lint: BOXED_LOCAL, USELESS_VEC. The maximum size of objects (in bytes) that will be linted. Larger objects are ok on the heap
+    /// Lint: BOXED_LOCAL, USELESS_VEC.
+    ///
+    /// The maximum size of objects (in bytes) that will be linted. Larger objects are ok on the heap
     (too_large_for_stack: u64 = 200),
-    /// Lint: ENUM_VARIANT_NAMES. The minimum number of enum variants for the lints about variant names to trigger
+    /// Lint: ENUM_VARIANT_NAMES.
+    ///
+    /// The minimum number of enum variants for the lints about variant names to trigger
     (enum_variant_name_threshold: u64 = 3),
-    /// Lint: LARGE_ENUM_VARIANT. The maximum size of a enum's variant to avoid box suggestion
+    /// Lint: LARGE_ENUM_VARIANT.
+    ///
+    /// The maximum size of a enum's variant to avoid box suggestion
     (enum_variant_size_threshold: u64 = 200),
-    /// Lint: VERBOSE_BIT_MASK. The maximum allowed size of a bit mask before suggesting to use 'trailing_zeros'
+    /// Lint: VERBOSE_BIT_MASK.
+    ///
+    /// The maximum allowed size of a bit mask before suggesting to use 'trailing_zeros'
     (verbose_bit_mask_threshold: u64 = 1),
-    /// Lint: DECIMAL_LITERAL_REPRESENTATION. The lower bound for linting decimal literals
+    /// Lint: DECIMAL_LITERAL_REPRESENTATION.
+    ///
+    /// The lower bound for linting decimal literals
     (literal_representation_threshold: u64 = 16384),
-    /// Lint: TRIVIALLY_COPY_PASS_BY_REF. The maximum size (in bytes) to consider a `Copy` type for passing by value instead of by reference.
+    /// Lint: TRIVIALLY_COPY_PASS_BY_REF.
+    ///
+    /// The maximum size (in bytes) to consider a `Copy` type for passing by value instead of by reference.
     (trivial_copy_size_limit: Option<u64> = None),
-    /// Lint: LARGE_TYPE_PASS_BY_MOVE. The minimum size (in bytes) to consider a type for passing by reference instead of by value.
+    /// Lint: LARGE_TYPE_PASS_BY_MOVE.
+    ///
+    /// The minimum size (in bytes) to consider a type for passing by reference instead of by value.
     (pass_by_value_size_limit: u64 = 256),
-    /// Lint: TOO_MANY_LINES. The maximum number of lines a function or method can have
+    /// Lint: TOO_MANY_LINES.
+    ///
+    /// The maximum number of lines a function or method can have
     (too_many_lines_threshold: u64 = 100),
-    /// Lint: LARGE_STACK_ARRAYS, LARGE_CONST_ARRAYS. The maximum allowed size for arrays on the stack
+    /// Lint: LARGE_STACK_ARRAYS, LARGE_CONST_ARRAYS.
+    ///
+    /// The maximum allowed size for arrays on the stack
     (array_size_threshold: u64 = 512_000),
-    /// Lint: VEC_BOX. The size of the boxed type in bytes, where boxing in a `Vec` is allowed
+    /// Lint: VEC_BOX.
+    ///
+    /// The size of the boxed type in bytes, where boxing in a `Vec` is allowed
     (vec_box_size_threshold: u64 = 4096),
-    /// Lint: TYPE_REPETITION_IN_BOUNDS. The maximum number of bounds a trait can have to be linted
+    /// Lint: TYPE_REPETITION_IN_BOUNDS.
+    ///
+    /// The maximum number of bounds a trait can have to be linted
     (max_trait_bounds: u64 = 3),
-    /// Lint: STRUCT_EXCESSIVE_BOOLS. The maximum number of bool fields a struct can have
+    /// Lint: STRUCT_EXCESSIVE_BOOLS.
+    ///
+    /// The maximum number of bool fields a struct can have
     (max_struct_bools: u64 = 3),
-    /// Lint: FN_PARAMS_EXCESSIVE_BOOLS. The maximum number of bool parameters a function can have
+    /// Lint: FN_PARAMS_EXCESSIVE_BOOLS.
+    ///
+    /// The maximum number of bool parameters a function can have
     (max_fn_params_bools: u64 = 3),
-    /// Lint: WILDCARD_IMPORTS. Whether to allow certain wildcard imports (prelude, super in tests).
+    /// Lint: WILDCARD_IMPORTS.
+    ///
+    /// Whether to allow certain wildcard imports (prelude, super in tests).
     (warn_on_all_wildcard_imports: bool = false),
-    /// Lint: DISALLOWED_METHOD. The list of disallowed methods, written as fully qualified paths.
+    /// Lint: DISALLOWED_METHOD.
+    ///
+    /// The list of disallowed methods, written as fully qualified paths.
     (disallowed_methods: Vec<String> = Vec::new()),
-    /// Lint: DISALLOWED_TYPE. The list of disallowed types, written as fully qualified paths.
+    /// Lint: DISALLOWED_TYPE.
+    ///
+    /// The list of disallowed types, written as fully qualified paths.
     (disallowed_types: Vec<String> = Vec::new()),
-    /// Lint: UNREADABLE_LITERAL. Should the fraction of a decimal be linted to include separators.
+    /// Lint: UNREADABLE_LITERAL.
+    ///
+    /// Should the fraction of a decimal be linted to include separators.
     (unreadable_literal_lint_fractions: bool = true),
-    /// Lint: UPPER_CASE_ACRONYMS. Enables verbose mode. Triggers if there is more than one uppercase char next to each other
+    /// Lint: UPPER_CASE_ACRONYMS.
+    ///
+    /// Enables verbose mode. Triggers if there is more than one uppercase char next to each other
     (upper_case_acronyms_aggressive: bool = false),
-    /// Lint: _CARGO_COMMON_METADATA. For internal testing only, ignores the current `publish` settings in the Cargo manifest.
+    /// Lint: _CARGO_COMMON_METADATA.
+    ///
+    /// For internal testing only, ignores the current `publish` settings in the Cargo manifest.
     (cargo_ignore_publish: bool = false),
-    /// Lint: NONSTANDARD_MACRO_BRACES. Enforce the named macros always use the braces specified. <br> A `MacroMatcher` can be added like so `{ name = "macro_name", brace = "(" }`. If the macro is could be used with a full path two `MacroMatcher`s have to be added one with the full path `crate_name::macro_name` and one with just the macro name.
+    /// Lint: NONSTANDARD_MACRO_BRACES.
+    ///
+    /// Enforce the named macros always use the braces specified.
+    ///
+    /// A `MacroMatcher` can be added like so `{ name = "macro_name", brace = "(" }`. If the macro
+    /// is could be used with a full path two `MacroMatcher`s have to be added one with the full path
+    /// `crate_name::macro_name` and one with just the macro name.
     (standard_macro_braces: Vec<crate::nonstandard_macro_braces::MacroMatcher> = Vec::new()),
-    /// Lint: MISSING_ENFORCED_IMPORT_RENAMES. The list of imports to always rename, a fully qualified path followed by the rename.
+    /// Lint: MISSING_ENFORCED_IMPORT_RENAMES.
+    ///
+    /// The list of imports to always rename, a fully qualified path followed by the rename.
     (enforced_import_renames: Vec<crate::utils::conf::Rename> = Vec::new()),
-    /// Lint: RESTRICTED_SCRIPTS. The list of unicode scripts allowed to be used in the scope.
+    /// Lint: RESTRICTED_SCRIPTS.
+    ///
+    /// The list of unicode scripts allowed to be used in the scope.
     (allowed_scripts: Vec<String> = vec!["Latin".to_string()]),
 }
 
diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index 47336459d7d..a48a5385083 100644
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -82,7 +82,7 @@ This lint has the following configuration variables:
 /// `default`
 macro_rules! CONFIGURATION_VALUE_TEMPLATE {
     () => {
-        "* {name}: {ty}: {doc} (defaults to `{default}`)\n"
+        "* {name}: `{ty}`: {doc} (defaults to `{default}`)\n"
     };
 }
 
@@ -344,11 +344,16 @@ fn parse_config_field_doc(doc_comment: &str) -> Option<(Vec<String>, String)> {
         if let Some(split_pos) = doc_comment.find('.');
         then {
             let mut doc_comment = doc_comment.to_string();
-            let documentation = doc_comment.split_off(split_pos);
+            let mut documentation = doc_comment.split_off(split_pos);
 
+            // Extract lints
             doc_comment.make_ascii_lowercase();
             let lints: Vec<String> = doc_comment.split_off(DOC_START.len()).split(", ").map(str::to_string).collect();
 
+            // Format documentation correctly
+            // split off leading `.` from lint name list and indent for correct formatting
+            documentation = documentation.trim_start_matches('.').trim().replace("\n ", "\n    ");
+
             Some((lints, documentation))
         } else {
             None
-- 
cgit 1.4.1-3-g733a5


From bc7fac9526a157cff245c0bbd55e156b37292a0b Mon Sep 17 00:00:00 2001
From: Devin Ragotzy <devin.ragotzy@gmail.com>
Date: Tue, 3 Aug 2021 08:19:13 -0400
Subject: fixup! Lint inside macro when owned by current crate

---
 clippy_lints/src/nonstandard_macro_braces.rs | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/nonstandard_macro_braces.rs b/clippy_lints/src/nonstandard_macro_braces.rs
index 2a318946656..99423b8a840 100644
--- a/clippy_lints/src/nonstandard_macro_braces.rs
+++ b/clippy_lints/src/nonstandard_macro_braces.rs
@@ -7,6 +7,7 @@ use clippy_utils::{diagnostics::span_lint_and_help, in_macro, is_direct_expn_of,
 use if_chain::if_chain;
 use rustc_ast::ast;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
+use rustc_hir::def_id::DefId;
 use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::Span;
@@ -95,9 +96,11 @@ impl EarlyLintPass for MacroBraces {
 fn is_offending_macro<'a>(cx: &EarlyContext<'_>, span: Span, mac_braces: &'a MacroBraces) -> Option<MacroInfo<'a>> {
     let unnested_or_local = || {
         let nested = in_macro(span.ctxt().outer_expn_data().call_site);
-        let in_local_macro = nested
-            && matches!(span.macro_backtrace().last().and_then(|e| e.macro_def_id), Some(defid) if defid.is_local());
-        !nested || in_local_macro
+        !nested
+            || span
+                .macro_backtrace()
+                .last()
+                .map_or(false, |e| e.macro_def_id.map_or(false, DefId::is_local))
     };
     if_chain! {
         // Make sure we are only one level deep otherwise there are to many FP's
-- 
cgit 1.4.1-3-g733a5


From 54c41c049cbfdd159a713ba4ac87056f6b5c7488 Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Wed, 4 Aug 2021 00:21:25 +0200
Subject: needless_borrow: try to make lint example a bit more illustrating

---
 clippy_lints/src/needless_borrow.rs | 4 ++++
 1 file changed, 4 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/needless_borrow.rs b/clippy_lints/src/needless_borrow.rs
index 3f0b23ee4d3..ba8f9446af8 100644
--- a/clippy_lints/src/needless_borrow.rs
+++ b/clippy_lints/src/needless_borrow.rs
@@ -27,11 +27,15 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust
+    /// fn fun(_a: &i32) {}
+    ///
     /// // Bad
     /// let x: &i32 = &&&&&&5;
+    /// fun(&x);
     ///
     /// // Good
     /// let x: &i32 = &5;
+    /// fun(x);
     /// ```
     pub NEEDLESS_BORROW,
     style,
-- 
cgit 1.4.1-3-g733a5


From 4743ec19489702b0c09adf684f7d9d8a9bcfdb10 Mon Sep 17 00:00:00 2001
From: LeSeulArtichaut <leseulartichaut@gmail.com>
Date: Thu, 5 Aug 2021 15:38:57 +0200
Subject: Don't emit `too_many_lines` for closures

---
 clippy_lints/src/functions/mod.rs            |  2 +-
 clippy_lints/src/functions/too_many_lines.rs | 13 +++++++++++--
 tests/ui-toml/functions_maxlines/test.rs     | 16 ++++++++++++++++
 tests/ui-toml/functions_maxlines/test.stderr | 26 +++++++++++++++++++++++---
 4 files changed, 51 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/functions/mod.rs b/clippy_lints/src/functions/mod.rs
index ce23c0ce4a0..04fc5887e8e 100644
--- a/clippy_lints/src/functions/mod.rs
+++ b/clippy_lints/src/functions/mod.rs
@@ -251,7 +251,7 @@ impl<'tcx> LateLintPass<'tcx> for Functions {
         hir_id: hir::HirId,
     ) {
         too_many_arguments::check_fn(cx, kind, decl, span, hir_id, self.too_many_arguments_threshold);
-        too_many_lines::check_fn(cx, span, body, self.too_many_lines_threshold);
+        too_many_lines::check_fn(cx, kind, span, body, self.too_many_lines_threshold);
         not_unsafe_ptr_arg_deref::check_fn(cx, kind, decl, body, hir_id);
     }
 
diff --git a/clippy_lints/src/functions/too_many_lines.rs b/clippy_lints/src/functions/too_many_lines.rs
index a666fee1a4a..008ef661b55 100644
--- a/clippy_lints/src/functions/too_many_lines.rs
+++ b/clippy_lints/src/functions/too_many_lines.rs
@@ -1,4 +1,5 @@
 use rustc_hir as hir;
+use rustc_hir::intravisit::FnKind;
 use rustc_lint::{LateContext, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_span::Span;
@@ -8,8 +9,16 @@ use clippy_utils::source::snippet_opt;
 
 use super::TOO_MANY_LINES;
 
-pub(super) fn check_fn(cx: &LateContext<'_>, span: Span, body: &'tcx hir::Body<'_>, too_many_lines_threshold: u64) {
-    if in_external_macro(cx.sess(), span) {
+pub(super) fn check_fn(
+    cx: &LateContext<'_>,
+    kind: FnKind<'tcx>,
+    span: Span,
+    body: &'tcx hir::Body<'_>,
+    too_many_lines_threshold: u64,
+) {
+    // Closures must be contained in a parent body, which will be checked for `too_many_lines`.
+    // Don't check closures for `too_many_lines` to avoid duplicated lints.
+    if matches!(kind, FnKind::Closure) || in_external_macro(cx.sess(), span) {
         return;
     }
 
diff --git a/tests/ui-toml/functions_maxlines/test.rs b/tests/ui-toml/functions_maxlines/test.rs
index a47677a1f3a..33a3ef75136 100644
--- a/tests/ui-toml/functions_maxlines/test.rs
+++ b/tests/ui-toml/functions_maxlines/test.rs
@@ -1,3 +1,5 @@
+// edition:2018
+
 #![warn(clippy::too_many_lines)]
 
 // This function should be considered one line.
@@ -20,6 +22,20 @@ fn too_many_lines() {
     println!("This is bad.");
 }
 
+// This should only fail once (#7517).
+async fn async_too_many_lines() {
+    println!("This is bad.");
+    println!("This is bad.");
+}
+
+// This should fail only once, without failing on the closure.
+fn closure_too_many_lines() {
+    let _ = {
+        println!("This is bad.");
+        println!("This is bad.");
+    };
+}
+
 // This should be considered one line.
 #[rustfmt::skip]
 fn comment_starts_after_code() {
diff --git a/tests/ui-toml/functions_maxlines/test.stderr b/tests/ui-toml/functions_maxlines/test.stderr
index a27ce945ca5..7551cac9f50 100644
--- a/tests/ui-toml/functions_maxlines/test.stderr
+++ b/tests/ui-toml/functions_maxlines/test.stderr
@@ -1,5 +1,5 @@
 error: this function has too many lines (2/1)
-  --> $DIR/test.rs:18:1
+  --> $DIR/test.rs:20:1
    |
 LL | / fn too_many_lines() {
 LL | |     println!("This is bad.");
@@ -9,8 +9,28 @@ LL | | }
    |
    = note: `-D clippy::too-many-lines` implied by `-D warnings`
 
+error: this function has too many lines (4/1)
+  --> $DIR/test.rs:26:1
+   |
+LL | / async fn async_too_many_lines() {
+LL | |     println!("This is bad.");
+LL | |     println!("This is bad.");
+LL | | }
+   | |_^
+
+error: this function has too many lines (4/1)
+  --> $DIR/test.rs:32:1
+   |
+LL | / fn closure_too_many_lines() {
+LL | |     let _ = {
+LL | |         println!("This is bad.");
+LL | |         println!("This is bad.");
+LL | |     };
+LL | | }
+   | |_^
+
 error: this function has too many lines (2/1)
-  --> $DIR/test.rs:38:1
+  --> $DIR/test.rs:54:1
    |
 LL | / fn comment_before_code() {
 LL | |     let _ = "test";
@@ -19,5 +39,5 @@ LL | |     the code but this line should still count. */ let _ = 5;
 LL | | }
    | |_^
 
-error: aborting due to 2 previous errors
+error: aborting due to 4 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 8a4ffb881d989be8e5bbbfa45cd5aa971a6179f2 Mon Sep 17 00:00:00 2001
From: valentine-mario <valentine13400@gmail.com>
Date: Thu, 5 Aug 2021 16:15:44 +0100
Subject: fixed bug that had to deal with mut and non mut suggestion

---
 clippy_lints/src/methods/extend_with_drain.rs | 8 ++++++--
 tests/ui/extend_with_drain.fixed              | 7 ++++++-
 tests/ui/extend_with_drain.rs                 | 7 ++++++-
 tests/ui/extend_with_drain.stderr             | 8 +++++++-
 4 files changed, 25 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/extend_with_drain.rs b/clippy_lints/src/methods/extend_with_drain.rs
index 57e10ce42f8..8829b8c5f4d 100644
--- a/clippy_lints/src/methods/extend_with_drain.rs
+++ b/clippy_lints/src/methods/extend_with_drain.rs
@@ -16,7 +16,10 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'_>, arg:
         //check source object
         if let ExprKind::MethodCall(src_method, _, [drain_vec, drain_arg], _) = &arg.kind;
         if src_method.ident.as_str() == "drain";
-        if let src_ty = cx.typeck_results().expr_ty(drain_vec).peel_refs();
+        let src_ty = cx.typeck_results().expr_ty(drain_vec);
+        //check if actual src type is mutable for code suggestion
+        let immutable = src_ty.is_mutable_ptr();
+        let src_ty = src_ty.peel_refs();
         if is_type_diagnostic_item(cx, src_ty, sym::vec_type);
         //check drain range
         if let src_ty_range = cx.typeck_results().expr_ty(drain_arg).peel_refs();
@@ -30,8 +33,9 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'_>, arg:
                 "use of `extend` instead of `append` for adding the full range of a second vector",
                 "try this",
                 format!(
-                    "{}.append(&mut {})",
+                    "{}.append({}{})",
                     snippet_with_applicability(cx, recv.span, "..", &mut applicability),
+                    if immutable { "" } else { "&mut " },
                     snippet_with_applicability(cx, drain_vec.span, "..", &mut applicability)
                 ),
                 applicability,
diff --git a/tests/ui/extend_with_drain.fixed b/tests/ui/extend_with_drain.fixed
index 00170e649e2..e863870e7d6 100644
--- a/tests/ui/extend_with_drain.fixed
+++ b/tests/ui/extend_with_drain.fixed
@@ -41,7 +41,12 @@ fn main() {
 
     let mut heap = BinaryHeap::from(vec![1, 3]);
     let mut heap2 = BinaryHeap::from(vec![]);
-    heap2.extend(heap.drain())
+    heap2.extend(heap.drain());
+
+    let mut x = vec![0, 1, 2, 3, 5];
+    let ref_x = &mut x;
+    let mut y = Vec::new();
+    y.append(ref_x);
 }
 
 fn return_vector() -> Vec<u8> {
diff --git a/tests/ui/extend_with_drain.rs b/tests/ui/extend_with_drain.rs
index d76458c3289..dcb36b5951c 100644
--- a/tests/ui/extend_with_drain.rs
+++ b/tests/ui/extend_with_drain.rs
@@ -41,7 +41,12 @@ fn main() {
 
     let mut heap = BinaryHeap::from(vec![1, 3]);
     let mut heap2 = BinaryHeap::from(vec![]);
-    heap2.extend(heap.drain())
+    heap2.extend(heap.drain());
+
+    let mut x = vec![0, 1, 2, 3, 5];
+    let ref_x = &mut x;
+    let mut y = Vec::new();
+    y.extend(ref_x.drain(..));
 }
 
 fn return_vector() -> Vec<u8> {
diff --git a/tests/ui/extend_with_drain.stderr b/tests/ui/extend_with_drain.stderr
index 57f344716a1..da14ddb25b3 100644
--- a/tests/ui/extend_with_drain.stderr
+++ b/tests/ui/extend_with_drain.stderr
@@ -18,5 +18,11 @@ error: use of `extend` instead of `append` for adding the full range of a second
 LL |     vec11.extend(return_vector().drain(..));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `vec11.append(&mut return_vector())`
 
-error: aborting due to 3 previous errors
+error: use of `extend` instead of `append` for adding the full range of a second vector
+  --> $DIR/extend_with_drain.rs:49:5
+   |
+LL |     y.extend(ref_x.drain(..));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `y.append(ref_x)`
+
+error: aborting due to 4 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From ccb5d73dec8b7de2bb5a1bb8be7de59fa1863005 Mon Sep 17 00:00:00 2001
From: LeSeulArtichaut <leseulartichaut@gmail.com>
Date: Thu, 5 Aug 2021 18:11:08 +0200
Subject: Properly handle `Self` type for `trivially_copy_pass_by_ref`

---
 clippy_lints/src/pass_by_ref_or_value.rs   |  4 ++--
 tests/ui/trivially_copy_pass_by_ref.rs     |  2 ++
 tests/ui/trivially_copy_pass_by_ref.stderr | 20 +++++++++++++-------
 3 files changed, 17 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/pass_by_ref_or_value.rs b/clippy_lints/src/pass_by_ref_or_value.rs
index f738ac25417..291e57aabe8 100644
--- a/clippy_lints/src/pass_by_ref_or_value.rs
+++ b/clippy_lints/src/pass_by_ref_or_value.rs
@@ -2,9 +2,9 @@ use std::cmp;
 use std::iter;
 
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::is_self_ty;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::is_copy;
+use clippy_utils::{is_self, is_self_ty};
 use if_chain::if_chain;
 use rustc_ast::attr;
 use rustc_errors::Applicability;
@@ -170,7 +170,7 @@ impl<'tcx> PassByRefOrValue {
                         if size <= self.ref_min_size;
                         if let hir::TyKind::Rptr(_, MutTy { ty: decl_ty, .. }) = input.kind;
                         then {
-                            let value_type = if is_self_ty(decl_ty) {
+                            let value_type = if fn_body.and_then(|body| body.params.get(index)).map_or(false, is_self) {
                                 "self".into()
                             } else {
                                 snippet(cx, decl_ty.span, "_").into()
diff --git a/tests/ui/trivially_copy_pass_by_ref.rs b/tests/ui/trivially_copy_pass_by_ref.rs
index e7e0a31febc..1a0123803a3 100644
--- a/tests/ui/trivially_copy_pass_by_ref.rs
+++ b/tests/ui/trivially_copy_pass_by_ref.rs
@@ -58,6 +58,8 @@ impl Foo {
     fn bad(&self, x: &u32, y: &Foo, z: &Baz) {}
 
     fn bad2(x: &u32, y: &Foo, z: &Baz) {}
+
+    fn bad_issue7518(self, other: &Self) {}
 }
 
 impl AsRef<u32> for Foo {
diff --git a/tests/ui/trivially_copy_pass_by_ref.stderr b/tests/ui/trivially_copy_pass_by_ref.stderr
index 2b0005bbff1..9c4c49ceac4 100644
--- a/tests/ui/trivially_copy_pass_by_ref.stderr
+++ b/tests/ui/trivially_copy_pass_by_ref.stderr
@@ -65,40 +65,46 @@ LL |     fn bad2(x: &u32, y: &Foo, z: &Baz) {}
    |                                  ^^^^ help: consider passing by value instead: `Baz`
 
 error: this argument (N byte) is passed by reference, but would be more efficient if passed by value (limit: N byte)
-  --> $DIR/trivially_copy_pass_by_ref.rs:72:16
+  --> $DIR/trivially_copy_pass_by_ref.rs:62:35
+   |
+LL |     fn bad_issue7518(self, other: &Self) {}
+   |                                   ^^^^^ help: consider passing by value instead: `Self`
+
+error: this argument (N byte) is passed by reference, but would be more efficient if passed by value (limit: N byte)
+  --> $DIR/trivially_copy_pass_by_ref.rs:74:16
    |
 LL |     fn bad2(x: &u32, y: &Foo, z: &Baz) {}
    |                ^^^^ help: consider passing by value instead: `u32`
 
 error: this argument (N byte) is passed by reference, but would be more efficient if passed by value (limit: N byte)
-  --> $DIR/trivially_copy_pass_by_ref.rs:72:25
+  --> $DIR/trivially_copy_pass_by_ref.rs:74:25
    |
 LL |     fn bad2(x: &u32, y: &Foo, z: &Baz) {}
    |                         ^^^^ help: consider passing by value instead: `Foo`
 
 error: this argument (N byte) is passed by reference, but would be more efficient if passed by value (limit: N byte)
-  --> $DIR/trivially_copy_pass_by_ref.rs:72:34
+  --> $DIR/trivially_copy_pass_by_ref.rs:74:34
    |
 LL |     fn bad2(x: &u32, y: &Foo, z: &Baz) {}
    |                                  ^^^^ help: consider passing by value instead: `Baz`
 
 error: this argument (N byte) is passed by reference, but would be more efficient if passed by value (limit: N byte)
-  --> $DIR/trivially_copy_pass_by_ref.rs:76:34
+  --> $DIR/trivially_copy_pass_by_ref.rs:78:34
    |
 LL |     fn trait_method(&self, _foo: &Foo);
    |                                  ^^^^ help: consider passing by value instead: `Foo`
 
 error: this argument (N byte) is passed by reference, but would be more efficient if passed by value (limit: N byte)
-  --> $DIR/trivially_copy_pass_by_ref.rs:108:21
+  --> $DIR/trivially_copy_pass_by_ref.rs:110:21
    |
 LL |     fn foo_never(x: &i32) {
    |                     ^^^^ help: consider passing by value instead: `i32`
 
 error: this argument (N byte) is passed by reference, but would be more efficient if passed by value (limit: N byte)
-  --> $DIR/trivially_copy_pass_by_ref.rs:113:15
+  --> $DIR/trivially_copy_pass_by_ref.rs:115:15
    |
 LL |     fn foo(x: &i32) {
    |               ^^^^ help: consider passing by value instead: `i32`
 
-error: aborting due to 16 previous errors
+error: aborting due to 17 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 15b87088bef9f39c3313939328e1f5fc29473c04 Mon Sep 17 00:00:00 2001
From: LeSeulArtichaut <leseulartichaut@gmail.com>
Date: Thu, 5 Aug 2021 19:06:35 +0200
Subject: Add missing backtick in docs for `redundant_allocation`

---
 clippy_lints/src/types/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types/mod.rs b/clippy_lints/src/types/mod.rs
index ad7409fe3a9..371bb8b445a 100644
--- a/clippy_lints/src/types/mod.rs
+++ b/clippy_lints/src/types/mod.rs
@@ -186,7 +186,7 @@ declare_clippy_lint! {
     /// Checks for use of redundant allocations anywhere in the code.
     ///
     /// ### Why is this bad?
-    /// Expressions such as `Rc<&T>`, `Rc<Rc<T>>`, `Rc<Arc<T>>`, `Rc<Box<T>>`, Arc<&T>`, `Arc<Rc<T>>`,
+    /// Expressions such as `Rc<&T>`, `Rc<Rc<T>>`, `Rc<Arc<T>>`, `Rc<Box<T>>`, `Arc<&T>`, `Arc<Rc<T>>`,
     /// `Arc<Arc<T>>`, `Arc<Box<T>>`, `Box<&T>`, `Box<Rc<T>>`, `Box<Arc<T>>`, `Box<Box<T>>`, add an unnecessary level of indirection.
     ///
     /// ### Example
-- 
cgit 1.4.1-3-g733a5


From 64ff2b05b9d2d346b456a72f1b5d602081a037e2 Mon Sep 17 00:00:00 2001
From: LeSeulArtichaut <leseulartichaut@gmail.com>
Date: Sat, 7 Aug 2021 01:01:27 +0200
Subject: Replace `span_to_snippet` calls with `snippet_opt` from
 `clippy_utils`

---
 .../src/methods/from_iter_instead_of_collect.rs    |  5 +++--
 .../src/misc_early/unneeded_field_pattern.rs       |  5 +++--
 clippy_lints/src/reference.rs                      |  3 ++-
 clippy_lints/src/unused_unit.rs                    | 25 +++++++++++-----------
 4 files changed, 20 insertions(+), 18 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/from_iter_instead_of_collect.rs b/clippy_lints/src/methods/from_iter_instead_of_collect.rs
index b4188d9ed30..99c03844f49 100644
--- a/clippy_lints/src/methods/from_iter_instead_of_collect.rs
+++ b/clippy_lints/src/methods/from_iter_instead_of_collect.rs
@@ -1,10 +1,11 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::implements_trait;
 use clippy_utils::{is_expr_path_def_path, paths, sugg};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
-use rustc_lint::{LateContext, LintContext};
+use rustc_lint::LateContext;
 use rustc_middle::ty::Ty;
 use rustc_span::sym;
 
@@ -43,7 +44,7 @@ fn extract_turbofish(cx: &LateContext<'_>, expr: &hir::Expr<'_>, ty: Ty<'tcx>) -
 
     let call_site = expr.span.source_callsite();
     if_chain! {
-        if let Ok(snippet) = cx.sess().source_map().span_to_snippet(call_site);
+        if let Some(snippet) = snippet_opt(cx, call_site);
         let snippet_split = snippet.split("::").collect::<Vec<_>>();
         if let Some((_, elements)) = snippet_split.split_last();
 
diff --git a/clippy_lints/src/misc_early/unneeded_field_pattern.rs b/clippy_lints/src/misc_early/unneeded_field_pattern.rs
index 2201cf56d52..fff533167ed 100644
--- a/clippy_lints/src/misc_early/unneeded_field_pattern.rs
+++ b/clippy_lints/src/misc_early/unneeded_field_pattern.rs
@@ -1,6 +1,7 @@
 use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
+use clippy_utils::source::snippet_opt;
 use rustc_ast::ast::{Pat, PatKind};
-use rustc_lint::{EarlyContext, LintContext};
+use rustc_lint::EarlyContext;
 
 use super::UNNEEDED_FIELD_PATTERN;
 
@@ -48,7 +49,7 @@ pub(super) fn check(cx: &EarlyContext<'_>, pat: &Pat) {
                             match field.pat.kind {
                                 PatKind::Wild => {},
                                 _ => {
-                                    if let Ok(n) = cx.sess().source_map().span_to_snippet(field.span) {
+                                    if let Some(n) = snippet_opt(cx, field.span) {
                                         normal.push(n);
                                     }
                                 },
diff --git a/clippy_lints/src/reference.rs b/clippy_lints/src/reference.rs
index e0930d69ab9..77b6e60d893 100644
--- a/clippy_lints/src/reference.rs
+++ b/clippy_lints/src/reference.rs
@@ -54,7 +54,8 @@ impl EarlyLintPass for DerefAddrOf {
             then {
                 let mut applicability = Applicability::MachineApplicable;
                 let sugg = if e.span.from_expansion() {
-                    if let Ok(macro_source) = cx.sess.source_map().span_to_snippet(e.span) {
+                    #[allow(clippy::option_if_let_else)]
+                    if let Some(macro_source) = snippet_opt(cx, e.span) {
                         // Remove leading whitespace from the given span
                         // e.g: ` $visitor` turns into `$visitor`
                         let trim_leading_whitespaces = |span| {
diff --git a/clippy_lints/src/unused_unit.rs b/clippy_lints/src/unused_unit.rs
index 9ed5e585f84..1164ac4938f 100644
--- a/clippy_lints/src/unused_unit.rs
+++ b/clippy_lints/src/unused_unit.rs
@@ -1,10 +1,10 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::source::position_before_rarrow;
+use clippy_utils::source::{position_before_rarrow, snippet_opt};
 use if_chain::if_chain;
 use rustc_ast::ast;
 use rustc_ast::visit::FnKind;
 use rustc_errors::Applicability;
-use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
+use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
 use rustc_span::BytePos;
@@ -125,17 +125,16 @@ fn is_unit_expr(expr: &ast::Expr) -> bool {
 }
 
 fn lint_unneeded_unit_return(cx: &EarlyContext<'_>, ty: &ast::Ty, span: Span) {
-    let (ret_span, appl) = if let Ok(fn_source) = cx.sess().source_map().span_to_snippet(span.with_hi(ty.span.hi())) {
-        position_before_rarrow(&fn_source).map_or((ty.span, Applicability::MaybeIncorrect), |rpos| {
-            (
-                #[allow(clippy::cast_possible_truncation)]
-                ty.span.with_lo(BytePos(span.lo().0 + rpos as u32)),
-                Applicability::MachineApplicable,
-            )
-        })
-    } else {
-        (ty.span, Applicability::MaybeIncorrect)
-    };
+    let (ret_span, appl) =
+        snippet_opt(cx, span.with_hi(ty.span.hi())).map_or((ty.span, Applicability::MaybeIncorrect), |fn_source| {
+            position_before_rarrow(&fn_source).map_or((ty.span, Applicability::MaybeIncorrect), |rpos| {
+                (
+                    #[allow(clippy::cast_possible_truncation)]
+                    ty.span.with_lo(BytePos(span.lo().0 + rpos as u32)),
+                    Applicability::MachineApplicable,
+                )
+            })
+        });
     span_lint_and_sugg(
         cx,
         UNUSED_UNIT,
-- 
cgit 1.4.1-3-g733a5


From ae700b42ed56e735ee813b03b53fcd44d1a662e9 Mon Sep 17 00:00:00 2001
From: LeSeulArtichaut <leseulartichaut@gmail.com>
Date: Sat, 7 Aug 2021 01:15:29 +0200
Subject: Use `EarlyContext::sess` instead of `LintContext::sess()`

---
 clippy_lints/src/as_conversions.rs         | 4 ++--
 clippy_lints/src/else_if_without_else.rs   | 4 ++--
 clippy_lints/src/if_not_else.rs            | 4 ++--
 clippy_lints/src/items_after_statements.rs | 6 +++---
 clippy_lints/src/literal_representation.rs | 6 +++---
 clippy_lints/src/misc_early/mod.rs         | 4 ++--
 clippy_lints/src/redundant_closure_call.rs | 4 ++--
 7 files changed, 16 insertions(+), 16 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/as_conversions.rs b/clippy_lints/src/as_conversions.rs
index 7c39a3e2ce3..0be460d67a7 100644
--- a/clippy_lints/src/as_conversions.rs
+++ b/clippy_lints/src/as_conversions.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_help;
 use rustc_ast::ast::{Expr, ExprKind};
-use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
+use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
@@ -47,7 +47,7 @@ declare_lint_pass!(AsConversions => [AS_CONVERSIONS]);
 
 impl EarlyLintPass for AsConversions {
     fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
-        if in_external_macro(cx.sess(), expr.span) {
+        if in_external_macro(cx.sess, expr.span) {
             return;
         }
 
diff --git a/clippy_lints/src/else_if_without_else.rs b/clippy_lints/src/else_if_without_else.rs
index 0541ac5eccc..b64246515f3 100644
--- a/clippy_lints/src/else_if_without_else.rs
+++ b/clippy_lints/src/else_if_without_else.rs
@@ -2,7 +2,7 @@
 
 use clippy_utils::diagnostics::span_lint_and_help;
 use rustc_ast::ast::{Expr, ExprKind};
-use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
+use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
@@ -49,7 +49,7 @@ declare_lint_pass!(ElseIfWithoutElse => [ELSE_IF_WITHOUT_ELSE]);
 
 impl EarlyLintPass for ElseIfWithoutElse {
     fn check_expr(&mut self, cx: &EarlyContext<'_>, mut item: &Expr) {
-        if in_external_macro(cx.sess(), item.span) {
+        if in_external_macro(cx.sess, item.span) {
             return;
         }
 
diff --git a/clippy_lints/src/if_not_else.rs b/clippy_lints/src/if_not_else.rs
index 28db7233d70..3ce91d421ba 100644
--- a/clippy_lints/src/if_not_else.rs
+++ b/clippy_lints/src/if_not_else.rs
@@ -3,7 +3,7 @@
 
 use clippy_utils::diagnostics::span_lint_and_help;
 use rustc_ast::ast::{BinOpKind, Expr, ExprKind, UnOp};
-use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
+use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
@@ -48,7 +48,7 @@ declare_lint_pass!(IfNotElse => [IF_NOT_ELSE]);
 
 impl EarlyLintPass for IfNotElse {
     fn check_expr(&mut self, cx: &EarlyContext<'_>, item: &Expr) {
-        if in_external_macro(cx.sess(), item.span) {
+        if in_external_macro(cx.sess, item.span) {
             return;
         }
         if let ExprKind::If(ref cond, _, Some(ref els)) = item.kind {
diff --git a/clippy_lints/src/items_after_statements.rs b/clippy_lints/src/items_after_statements.rs
index 429c6ed7d2d..3736d237642 100644
--- a/clippy_lints/src/items_after_statements.rs
+++ b/clippy_lints/src/items_after_statements.rs
@@ -2,7 +2,7 @@
 
 use clippy_utils::diagnostics::span_lint;
 use rustc_ast::ast::{Block, ItemKind, StmtKind};
-use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
+use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
@@ -54,7 +54,7 @@ declare_lint_pass!(ItemsAfterStatements => [ITEMS_AFTER_STATEMENTS]);
 
 impl EarlyLintPass for ItemsAfterStatements {
     fn check_block(&mut self, cx: &EarlyContext<'_>, item: &Block) {
-        if in_external_macro(cx.sess(), item.span) {
+        if in_external_macro(cx.sess, item.span) {
             return;
         }
 
@@ -68,7 +68,7 @@ impl EarlyLintPass for ItemsAfterStatements {
         // lint on all further items
         for stmt in stmts {
             if let StmtKind::Item(ref it) = *stmt {
-                if in_external_macro(cx.sess(), it.span) {
+                if in_external_macro(cx.sess, it.span) {
                     return;
                 }
                 if let ItemKind::MacroDef(..) = it.kind {
diff --git a/clippy_lints/src/literal_representation.rs b/clippy_lints/src/literal_representation.rs
index 699ddce0cff..0e5121ca3d7 100644
--- a/clippy_lints/src/literal_representation.rs
+++ b/clippy_lints/src/literal_representation.rs
@@ -10,7 +10,7 @@ use clippy_utils::{
 use if_chain::if_chain;
 use rustc_ast::ast::{Expr, ExprKind, Lit, LitKind};
 use rustc_errors::Applicability;
-use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
+use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use std::iter;
@@ -222,7 +222,7 @@ impl_lint_pass!(LiteralDigitGrouping => [
 
 impl EarlyLintPass for LiteralDigitGrouping {
     fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
-        if in_external_macro(cx.sess(), expr.span) {
+        if in_external_macro(cx.sess, expr.span) {
             return;
         }
 
@@ -415,7 +415,7 @@ impl_lint_pass!(DecimalLiteralRepresentation => [DECIMAL_LITERAL_REPRESENTATION]
 
 impl EarlyLintPass for DecimalLiteralRepresentation {
     fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
-        if in_external_macro(cx.sess(), expr.span) {
+        if in_external_macro(cx.sess, expr.span) {
             return;
         }
 
diff --git a/clippy_lints/src/misc_early/mod.rs b/clippy_lints/src/misc_early/mod.rs
index 06fe967dafc..b32feab4ee3 100644
--- a/clippy_lints/src/misc_early/mod.rs
+++ b/clippy_lints/src/misc_early/mod.rs
@@ -12,7 +12,7 @@ use clippy_utils::source::snippet_opt;
 use rustc_ast::ast::{Expr, Generics, Lit, LitFloatType, LitIntType, LitKind, NodeId, Pat, PatKind};
 use rustc_ast::visit::FnKind;
 use rustc_data_structures::fx::FxHashMap;
-use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
+use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
@@ -307,7 +307,7 @@ impl EarlyLintPass for MiscEarlyLints {
     }
 
     fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
-        if in_external_macro(cx.sess(), expr.span) {
+        if in_external_macro(cx.sess, expr.span) {
             return;
         }
         double_neg::check(cx, expr);
diff --git a/clippy_lints/src/redundant_closure_call.rs b/clippy_lints/src/redundant_closure_call.rs
index a79b2fe76e2..7314bce83e0 100644
--- a/clippy_lints/src/redundant_closure_call.rs
+++ b/clippy_lints/src/redundant_closure_call.rs
@@ -8,7 +8,7 @@ use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_hir::intravisit as hir_visit;
 use rustc_hir::intravisit::Visitor as HirVisitor;
-use rustc_lint::{EarlyContext, EarlyLintPass, LateContext, LateLintPass, LintContext};
+use rustc_lint::{EarlyContext, EarlyLintPass, LateContext, LateLintPass};
 use rustc_middle::hir::map::Map;
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -63,7 +63,7 @@ impl<'ast> ast_visit::Visitor<'ast> for ReturnVisitor {
 
 impl EarlyLintPass for RedundantClosureCall {
     fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &ast::Expr) {
-        if in_external_macro(cx.sess(), expr.span) {
+        if in_external_macro(cx.sess, expr.span) {
             return;
         }
         if_chain! {
-- 
cgit 1.4.1-3-g733a5


From bc9459f9d457c23471852a6f20c9d867385d8429 Mon Sep 17 00:00:00 2001
From: Matthias Geier <Matthias.Geier@gmail.com>
Date: Sat, 7 Aug 2021 18:11:49 +0200
Subject: similar_names: allow "iter" and "item"

---
 clippy_lints/src/non_expressive_names.rs | 1 +
 1 file changed, 1 insertion(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/non_expressive_names.rs b/clippy_lints/src/non_expressive_names.rs
index dc55b103eb6..ac21eb5275f 100644
--- a/clippy_lints/src/non_expressive_names.rs
+++ b/clippy_lints/src/non_expressive_names.rs
@@ -126,6 +126,7 @@ const ALLOWED_TO_BE_SIMILAR: &[&[&str]] = &[
     &["qpath", "path"],
     &["lit", "lint"],
     &["wparam", "lparam"],
+    &["iter", "item"],
 ];
 
 struct SimilarNamesNameVisitor<'a, 'tcx, 'b>(&'b mut SimilarNamesLocalVisitor<'a, 'tcx>);
-- 
cgit 1.4.1-3-g733a5


From 6d36d1a835370a01cbee58aba038ea0bd712c82b Mon Sep 17 00:00:00 2001
From: hamidreza kalbasi <hamidrezakalbasi@protonmail.com>
Date: Thu, 29 Jul 2021 16:38:17 +0430
Subject: merge XOR_SWAP with MANUAL_SWAP

---
 CHANGELOG.md             |   1 -
 clippy_lints/src/lib.rs  |   3 -
 clippy_lints/src/swap.rs | 259 ++++++++++++-----------------------------------
 clippy_utils/src/lib.rs  |  48 +++++++++
 tests/ui/swap.fixed      |  25 +++--
 tests/ui/swap.rs         |  23 +++--
 tests/ui/swap.stderr     |  53 ++++++----
 7 files changed, 175 insertions(+), 237 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 601fa83ad89..acbefc8064d 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2900,7 +2900,6 @@ Released 2018-09-13
 [`wrong_pub_self_convention`]: https://rust-lang.github.io/rust-clippy/master/index.html#wrong_pub_self_convention
 [`wrong_self_convention`]: https://rust-lang.github.io/rust-clippy/master/index.html#wrong_self_convention
 [`wrong_transmute`]: https://rust-lang.github.io/rust-clippy/master/index.html#wrong_transmute
-[`xor_swap`]: https://rust-lang.github.io/rust-clippy/master/index.html#xor_swap
 [`zero_divided_by_zero`]: https://rust-lang.github.io/rust-clippy/master/index.html#zero_divided_by_zero
 [`zero_prefixed_literal`]: https://rust-lang.github.io/rust-clippy/master/index.html#zero_prefixed_literal
 [`zero_ptr`]: https://rust-lang.github.io/rust-clippy/master/index.html#zero_ptr
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index c4197bab82a..f49b382c5ea 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -922,7 +922,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         suspicious_trait_impl::SUSPICIOUS_OP_ASSIGN_IMPL,
         swap::ALMOST_SWAPPED,
         swap::MANUAL_SWAP,
-        swap::XOR_SWAP,
         tabs_in_doc_comments::TABS_IN_DOC_COMMENTS,
         temporary_assignment::TEMPORARY_ASSIGNMENT,
         to_digit_is_some::TO_DIGIT_IS_SOME,
@@ -1420,7 +1419,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(suspicious_trait_impl::SUSPICIOUS_OP_ASSIGN_IMPL),
         LintId::of(swap::ALMOST_SWAPPED),
         LintId::of(swap::MANUAL_SWAP),
-        LintId::of(swap::XOR_SWAP),
         LintId::of(tabs_in_doc_comments::TABS_IN_DOC_COMMENTS),
         LintId::of(temporary_assignment::TEMPORARY_ASSIGNMENT),
         LintId::of(to_digit_is_some::TO_DIGIT_IS_SOME),
@@ -1649,7 +1647,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(strings::STRING_FROM_UTF8_AS_BYTES),
         LintId::of(strlen_on_c_strings::STRLEN_ON_C_STRINGS),
         LintId::of(swap::MANUAL_SWAP),
-        LintId::of(swap::XOR_SWAP),
         LintId::of(temporary_assignment::TEMPORARY_ASSIGNMENT),
         LintId::of(transmute::CROSSPOINTER_TRANSMUTE),
         LintId::of(transmute::TRANSMUTES_EXPRESSIBLE_AS_PTR_CASTS),
diff --git a/clippy_lints/src/swap.rs b/clippy_lints/src/swap.rs
index 6dceec65574..f126908e84b 100644
--- a/clippy_lints/src/swap.rs
+++ b/clippy_lints/src/swap.rs
@@ -2,7 +2,7 @@ use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{differing_macro_contexts, eq_expr_value};
+use clippy_utils::{can_mut_borrow_both, differing_macro_contexts, eq_expr_value};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Block, Expr, ExprKind, PatKind, QPath, Stmt, StmtKind};
@@ -10,7 +10,7 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Spanned;
-use rustc_span::sym;
+use rustc_span::{sym, Span};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -65,37 +65,7 @@ declare_clippy_lint! {
     "`foo = bar; bar = foo` sequence"
 }
 
-declare_clippy_lint! {
-    /// **What it does:** Checks for uses of xor-based swaps.
-    ///
-    /// **Why is this bad?** The `std::mem::swap` function exposes the intent better
-    /// without deinitializing or copying either variable.
-    ///
-    /// **Known problems:** None.
-    ///
-    /// **Example:**
-    ///
-    /// ```rust
-    /// let mut a = 1;
-    /// let mut b = 2;
-    ///
-    /// a ^= b;
-    /// b ^= a;
-    /// a ^= b;
-    /// ```
-    ///
-    /// Use std::mem::swap() instead:
-    /// ```rust
-    /// let mut a = 1;
-    /// let mut b = 2;
-    /// std::mem::swap(&mut a, &mut b);
-    /// ```
-    pub XOR_SWAP,
-    complexity,
-    "xor-based swap of two variables"
-}
-
-declare_lint_pass!(Swap => [MANUAL_SWAP, ALMOST_SWAPPED, XOR_SWAP]);
+declare_lint_pass!(Swap => [MANUAL_SWAP, ALMOST_SWAPPED]);
 
 impl<'tcx> LateLintPass<'tcx> for Swap {
     fn check_block(&mut self, cx: &LateContext<'tcx>, block: &'tcx Block<'_>) {
@@ -105,6 +75,63 @@ impl<'tcx> LateLintPass<'tcx> for Swap {
     }
 }
 
+fn generate_swap_warning(cx: &LateContext<'_>, e1: &Expr<'_>, e2: &Expr<'_>, span: Span, is_xor_based: bool) {
+    let mut applicability = Applicability::MachineApplicable;
+
+    if !can_mut_borrow_both(cx, e1, e2) {
+        if let ExprKind::Index(lhs1, idx1) = e1.kind {
+            if let ExprKind::Index(lhs2, idx2) = e2.kind {
+                if eq_expr_value(cx, lhs1, lhs2) {
+                    let ty = cx.typeck_results().expr_ty(lhs1).peel_refs();
+
+                    if matches!(ty.kind(), ty::Slice(_))
+                        || matches!(ty.kind(), ty::Array(_, _))
+                        || is_type_diagnostic_item(cx, ty, sym::vec_type)
+                        || is_type_diagnostic_item(cx, ty, sym::vecdeque_type)
+                    {
+                        let slice = Sugg::hir_with_applicability(cx, lhs1, "<slice>", &mut applicability);
+                        span_lint_and_sugg(
+                            cx,
+                            MANUAL_SWAP,
+                            span,
+                            &format!("this looks like you are swapping elements of `{}` manually", slice),
+                            "try",
+                            format!(
+                                "{}.swap({}, {})",
+                                slice.maybe_par(),
+                                snippet_with_applicability(cx, idx1.span, "..", &mut applicability),
+                                snippet_with_applicability(cx, idx2.span, "..", &mut applicability),
+                            ),
+                            applicability,
+                        );
+                    }
+                }
+            }
+        }
+        return;
+    }
+
+    let first = Sugg::hir_with_applicability(cx, e1, "..", &mut applicability);
+    let second = Sugg::hir_with_applicability(cx, e2, "..", &mut applicability);
+    span_lint_and_then(
+        cx,
+        MANUAL_SWAP,
+        span,
+        &format!("this looks like you are swapping `{}` and `{}` manually", first, second),
+        |diag| {
+            diag.span_suggestion(
+                span,
+                "try",
+                format!("std::mem::swap({}, {})", first.mut_addr(), second.mut_addr()),
+                applicability,
+            );
+            if !is_xor_based {
+                diag.note("or maybe you should use `std::mem::replace`?");
+            }
+        },
+    );
+}
+
 /// Implementation of the `MANUAL_SWAP` lint.
 fn check_manual_swap(cx: &LateContext<'_>, block: &Block<'_>) {
     for w in block.stmts.windows(3) {
@@ -128,123 +155,13 @@ fn check_manual_swap(cx: &LateContext<'_>, block: &Block<'_>) {
             if eq_expr_value(cx, tmp_init, lhs1);
             if eq_expr_value(cx, rhs1, lhs2);
             then {
-                if let ExprKind::Field(lhs1, _) = lhs1.kind {
-                    if let ExprKind::Field(lhs2, _) = lhs2.kind {
-                        if lhs1.hir_id.owner == lhs2.hir_id.owner {
-                            return;
-                        }
-                    }
-                }
-
-                let mut applicability = Applicability::MachineApplicable;
-
-                let slice = check_for_slice(cx, lhs1, lhs2);
-                let (replace, what, sugg) = if let Slice::NotSwappable = slice {
-                    return;
-                } else if let Slice::Swappable(slice, idx1, idx2) = slice {
-                    if let Some(slice) = Sugg::hir_opt(cx, slice) {
-                        (
-                            false,
-                            format!(" elements of `{}`", slice),
-                            format!(
-                                "{}.swap({}, {})",
-                                slice.maybe_par(),
-                                snippet_with_applicability(cx, idx1.span, "..", &mut applicability),
-                                snippet_with_applicability(cx, idx2.span, "..", &mut applicability),
-                            ),
-                        )
-                    } else {
-                        (false, String::new(), String::new())
-                    }
-                } else if let (Some(first), Some(second)) = (Sugg::hir_opt(cx, lhs1), Sugg::hir_opt(cx, rhs1)) {
-                    (
-                        true,
-                        format!(" `{}` and `{}`", first, second),
-                        format!("std::mem::swap({}, {})", first.mut_addr(), second.mut_addr()),
-                    )
-                } else {
-                    (true, String::new(), String::new())
-                };
-
                 let span = w[0].span.to(second.span);
-
-                span_lint_and_then(
-                    cx,
-                    MANUAL_SWAP,
-                    span,
-                    &format!("this looks like you are swapping{} manually", what),
-                    |diag| {
-                        if !sugg.is_empty() {
-                            diag.span_suggestion(
-                                span,
-                                "try",
-                                sugg,
-                                applicability,
-                            );
-
-                            if replace {
-                                diag.note("or maybe you should use `std::mem::replace`?");
-                            }
-                        }
-                    }
-                );
+                generate_swap_warning(cx, lhs1, lhs2, span, false);
             }
         }
     }
 }
 
-enum Slice<'a> {
-    /// `slice.swap(idx1, idx2)` can be used
-    ///
-    /// ## Example
-    ///
-    /// ```rust
-    /// # let mut a = vec![0, 1];
-    /// let t = a[1];
-    /// a[1] = a[0];
-    /// a[0] = t;
-    /// // can be written as
-    /// a.swap(0, 1);
-    /// ```
-    Swappable(&'a Expr<'a>, &'a Expr<'a>, &'a Expr<'a>),
-    /// The `swap` function cannot be used.
-    ///
-    /// ## Example
-    ///
-    /// ```rust
-    /// # let mut a = [vec![1, 2], vec![3, 4]];
-    /// let t = a[0][1];
-    /// a[0][1] = a[1][0];
-    /// a[1][0] = t;
-    /// ```
-    NotSwappable,
-    /// Not a slice
-    None,
-}
-
-/// Checks if both expressions are index operations into "slice-like" types.
-fn check_for_slice<'a>(cx: &LateContext<'_>, lhs1: &'a Expr<'_>, lhs2: &'a Expr<'_>) -> Slice<'a> {
-    if let ExprKind::Index(lhs1, idx1) = lhs1.kind {
-        if let ExprKind::Index(lhs2, idx2) = lhs2.kind {
-            if eq_expr_value(cx, lhs1, lhs2) {
-                let ty = cx.typeck_results().expr_ty(lhs1).peel_refs();
-
-                if matches!(ty.kind(), ty::Slice(_))
-                    || matches!(ty.kind(), ty::Array(_, _))
-                    || is_type_diagnostic_item(cx, ty, sym::vec_type)
-                    || is_type_diagnostic_item(cx, ty, sym::vecdeque_type)
-                {
-                    return Slice::Swappable(lhs1, idx1, idx2);
-                }
-            } else {
-                return Slice::NotSwappable;
-            }
-        }
-    }
-
-    Slice::None
-}
-
 /// Implementation of the `ALMOST_SWAPPED` lint.
 fn check_suspicious_swap(cx: &LateContext<'_>, block: &Block<'_>) {
     for w in block.stmts.windows(2) {
@@ -295,62 +212,20 @@ fn check_suspicious_swap(cx: &LateContext<'_>, block: &Block<'_>) {
     }
 }
 
-/// Implementation of the `XOR_SWAP` lint.
+/// Implementation of the xor case for `MANUAL_SWAP` lint.
 fn check_xor_swap(cx: &LateContext<'_>, block: &Block<'_>) {
     for window in block.stmts.windows(3) {
         if_chain! {
             if let Some((lhs0, rhs0)) = extract_sides_of_xor_assign(&window[0]);
             if let Some((lhs1, rhs1)) = extract_sides_of_xor_assign(&window[1]);
             if let Some((lhs2, rhs2)) = extract_sides_of_xor_assign(&window[2]);
-            if eq_expr_value(cx, lhs0, rhs1)
-               && eq_expr_value(cx, rhs1, lhs2)
-               && eq_expr_value(cx, rhs0, lhs1)
-               && eq_expr_value(cx, lhs1, rhs2);
+            if eq_expr_value(cx, lhs0, rhs1);
+            if eq_expr_value(cx, lhs2, rhs1);
+            if eq_expr_value(cx, lhs1, rhs0);
+            if eq_expr_value(cx, lhs1, rhs2);
             then {
                 let span = window[0].span.to(window[2].span);
-                let mut applicability = Applicability::MachineApplicable;
-                match check_for_slice(cx, lhs0, rhs0) {
-                    Slice::Swappable(slice, idx0, idx1) => {
-                        if let Some(slice) = Sugg::hir_opt(cx, slice) {
-                            span_lint_and_sugg(
-                                cx,
-                                XOR_SWAP,
-                                span,
-                                &format!(
-                                    "this xor-based swap of the elements of `{}` can be \
-                                    more clearly expressed using `.swap`",
-                                    slice
-                                ),
-                                "try",
-                                format!(
-                                    "{}.swap({}, {})",
-                                    slice.maybe_par(),
-                                    snippet_with_applicability(cx, idx0.span, "..", &mut applicability),
-                                    snippet_with_applicability(cx, idx1.span, "..", &mut applicability)
-                                ),
-                                applicability
-                            )
-                        }
-                    }
-                    Slice::None => {
-                        if let (Some(first), Some(second)) = (Sugg::hir_opt(cx, lhs0), Sugg::hir_opt(cx, rhs0)) {
-                            span_lint_and_sugg(
-                                cx,
-                                XOR_SWAP,
-                                span,
-                                &format!(
-                                    "this xor-based swap of `{}` and `{}` can be \
-                                    more clearly expressed using `std::mem::swap`",
-                                    first, second
-                                ),
-                                "try",
-                                format!("std::mem::swap({}, {})", first.mut_addr(), second.mut_addr()),
-                                applicability,
-                            );
-                        }
-                    }
-                    Slice::NotSwappable => {}
-                }
+                generate_swap_warning(cx, lhs0, rhs0, span, true);
             }
         };
     }
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 59f878f8b20..e930338270c 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -558,6 +558,54 @@ pub fn trait_ref_of_method<'tcx>(cx: &LateContext<'tcx>, hir_id: HirId) -> Optio
     None
 }
 
+/// This method will return tuple of projection stack and root of the expression,
+/// used in `can_mut_borrow_both`.
+///
+/// For example, if `e` represents the `v[0].a.b[x]`
+/// this method will return a tuple, composed of a `Vec`
+/// containing the `Expr`s for `v[0], v[0].a, v[0].a.b, v[0].a.b[x]`
+/// and a `Expr` for root of them, `v`
+fn projection_stack<'a, 'hir>(mut e: &'a Expr<'hir>) -> (Vec<&'a Expr<'hir>>, &'a Expr<'hir>) {
+    let mut result = vec![];
+    let root = loop {
+        match e.kind {
+            ExprKind::Index(ep, _) | ExprKind::Field(ep, _) => {
+                result.push(e);
+                e = ep;
+            },
+            _ => break e,
+        };
+    };
+    result.reverse();
+    (result, root)
+}
+
+/// Checks if two expressions can be mutably borrowed simultaneously
+/// and they aren't dependent on borrowing same thing twice
+pub fn can_mut_borrow_both(cx: &LateContext<'_>, e1: &Expr<'_>, e2: &Expr<'_>) -> bool {
+    let (s1, r1) = projection_stack(e1);
+    let (s2, r2) = projection_stack(e2);
+    if !eq_expr_value(cx, r1, r2) {
+        return true;
+    }
+    for (x1, x2) in s1.iter().zip(s2.iter()) {
+        match (&x1.kind, &x2.kind) {
+            (ExprKind::Field(_, i1), ExprKind::Field(_, i2)) => {
+                if i1 != i2 {
+                    return true;
+                }
+            },
+            (ExprKind::Index(_, i1), ExprKind::Index(_, i2)) => {
+                if !eq_expr_value(cx, i1, i2) {
+                    return false;
+                }
+            },
+            _ => return false,
+        }
+    }
+    false
+}
+
 /// Checks if the top level expression can be moved into a closure as is.
 pub fn can_move_expr_to_closure_no_visit(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, jump_targets: &[HirId]) -> bool {
     match expr.kind {
diff --git a/tests/ui/swap.fixed b/tests/ui/swap.fixed
index e0d412b2198..ef518359ec5 100644
--- a/tests/ui/swap.fixed
+++ b/tests/ui/swap.fixed
@@ -6,6 +6,7 @@
     clippy::no_effect,
     clippy::redundant_clone,
     redundant_semicolons,
+    dead_code,
     unused_assignments
 )]
 
@@ -20,9 +21,7 @@ struct Bar {
 fn field() {
     let mut bar = Bar { a: 1, b: 2 };
 
-    let temp = bar.a;
-    bar.a = bar.b;
-    bar.b = temp;
+    std::mem::swap(&mut bar.a, &mut bar.b);
 
     let mut baz = vec![bar.clone(), bar.clone()];
     let temp = baz[0].a;
@@ -51,6 +50,7 @@ fn unswappable_slice() {
     foo[1][0] = temp;
 
     // swap(foo[0][1], foo[1][0]) would fail
+    // this could use split_at_mut and mem::swap, but that is not much simpler.
 }
 
 fn vec() {
@@ -95,20 +95,19 @@ fn xor_unswappable_slice() {
     foo[0][1] ^= foo[1][0];
     foo[1][0] ^= foo[0][0];
     foo[0][1] ^= foo[1][0];
+
+    // swap(foo[0][1], foo[1][0]) would fail
+    // this could use split_at_mut and mem::swap, but that is not much simpler.
+}
+
+fn distinct_slice() {
+    let foo = &mut [vec![1, 2], vec![3, 4]];
+    let bar = &mut [vec![1, 2], vec![3, 4]];
+    std::mem::swap(&mut foo[0][1], &mut bar[1][0]);
 }
 
 #[rustfmt::skip]
 fn main() {
-    field();
-    array();
-    slice();
-    unswappable_slice();
-    vec();
-    xor_swap_locals();
-    xor_field_swap();
-    xor_slice_swap();
-    xor_no_swap();
-    xor_unswappable_slice();
 
     let mut a = 42;
     let mut b = 1337;
diff --git a/tests/ui/swap.rs b/tests/ui/swap.rs
index 6f8fd6e4c91..8518659ccf3 100644
--- a/tests/ui/swap.rs
+++ b/tests/ui/swap.rs
@@ -6,6 +6,7 @@
     clippy::no_effect,
     clippy::redundant_clone,
     redundant_semicolons,
+    dead_code,
     unused_assignments
 )]
 
@@ -55,6 +56,7 @@ fn unswappable_slice() {
     foo[1][0] = temp;
 
     // swap(foo[0][1], foo[1][0]) would fail
+    // this could use split_at_mut and mem::swap, but that is not much simpler.
 }
 
 fn vec() {
@@ -107,20 +109,21 @@ fn xor_unswappable_slice() {
     foo[0][1] ^= foo[1][0];
     foo[1][0] ^= foo[0][0];
     foo[0][1] ^= foo[1][0];
+
+    // swap(foo[0][1], foo[1][0]) would fail
+    // this could use split_at_mut and mem::swap, but that is not much simpler.
+}
+
+fn distinct_slice() {
+    let foo = &mut [vec![1, 2], vec![3, 4]];
+    let bar = &mut [vec![1, 2], vec![3, 4]];
+    let temp = foo[0][1];
+    foo[0][1] = bar[1][0];
+    bar[1][0] = temp;
 }
 
 #[rustfmt::skip]
 fn main() {
-    field();
-    array();
-    slice();
-    unswappable_slice();
-    vec();
-    xor_swap_locals();
-    xor_field_swap();
-    xor_slice_swap();
-    xor_no_swap();
-    xor_unswappable_slice();
 
     let mut a = 42;
     let mut b = 1337;
diff --git a/tests/ui/swap.stderr b/tests/ui/swap.stderr
index 55b470821e2..614d16ced40 100644
--- a/tests/ui/swap.stderr
+++ b/tests/ui/swap.stderr
@@ -1,15 +1,24 @@
+error: this looks like you are swapping `bar.a` and `bar.b` manually
+  --> $DIR/swap.rs:24:5
+   |
+LL | /     let temp = bar.a;
+LL | |     bar.a = bar.b;
+LL | |     bar.b = temp;
+   | |________________^ help: try: `std::mem::swap(&mut bar.a, &mut bar.b)`
+   |
+   = note: `-D clippy::manual-swap` implied by `-D warnings`
+   = note: or maybe you should use `std::mem::replace`?
+
 error: this looks like you are swapping elements of `foo` manually
-  --> $DIR/swap.rs:35:5
+  --> $DIR/swap.rs:36:5
    |
 LL | /     let temp = foo[0];
 LL | |     foo[0] = foo[1];
 LL | |     foo[1] = temp;
    | |_________________^ help: try: `foo.swap(0, 1)`
-   |
-   = note: `-D clippy::manual-swap` implied by `-D warnings`
 
 error: this looks like you are swapping elements of `foo` manually
-  --> $DIR/swap.rs:44:5
+  --> $DIR/swap.rs:45:5
    |
 LL | /     let temp = foo[0];
 LL | |     foo[0] = foo[1];
@@ -17,41 +26,49 @@ LL | |     foo[1] = temp;
    | |_________________^ help: try: `foo.swap(0, 1)`
 
 error: this looks like you are swapping elements of `foo` manually
-  --> $DIR/swap.rs:62:5
+  --> $DIR/swap.rs:64:5
    |
 LL | /     let temp = foo[0];
 LL | |     foo[0] = foo[1];
 LL | |     foo[1] = temp;
    | |_________________^ help: try: `foo.swap(0, 1)`
 
-error: this xor-based swap of `a` and `b` can be more clearly expressed using `std::mem::swap`
-  --> $DIR/swap.rs:73:5
+error: this looks like you are swapping `a` and `b` manually
+  --> $DIR/swap.rs:75:5
    |
 LL | /     a ^= b;
 LL | |     b ^= a;
 LL | |     a ^= b;
    | |___________^ help: try: `std::mem::swap(&mut a, &mut b)`
-   |
-   = note: `-D clippy::xor-swap` implied by `-D warnings`
 
-error: this xor-based swap of `bar.a` and `bar.b` can be more clearly expressed using `std::mem::swap`
-  --> $DIR/swap.rs:81:5
+error: this looks like you are swapping `bar.a` and `bar.b` manually
+  --> $DIR/swap.rs:83:5
    |
 LL | /     bar.a ^= bar.b;
 LL | |     bar.b ^= bar.a;
 LL | |     bar.a ^= bar.b;
    | |___________________^ help: try: `std::mem::swap(&mut bar.a, &mut bar.b)`
 
-error: this xor-based swap of the elements of `foo` can be more clearly expressed using `.swap`
-  --> $DIR/swap.rs:89:5
+error: this looks like you are swapping elements of `foo` manually
+  --> $DIR/swap.rs:91:5
    |
 LL | /     foo[0] ^= foo[1];
 LL | |     foo[1] ^= foo[0];
 LL | |     foo[0] ^= foo[1];
    | |_____________________^ help: try: `foo.swap(0, 1)`
 
+error: this looks like you are swapping `foo[0][1]` and `bar[1][0]` manually
+  --> $DIR/swap.rs:120:5
+   |
+LL | /     let temp = foo[0][1];
+LL | |     foo[0][1] = bar[1][0];
+LL | |     bar[1][0] = temp;
+   | |____________________^ help: try: `std::mem::swap(&mut foo[0][1], &mut bar[1][0])`
+   |
+   = note: or maybe you should use `std::mem::replace`?
+
 error: this looks like you are swapping `a` and `b` manually
-  --> $DIR/swap.rs:131:7
+  --> $DIR/swap.rs:134:7
    |
 LL |       ; let t = a;
    |  _______^
@@ -62,7 +79,7 @@ LL | |     b = t;
    = note: or maybe you should use `std::mem::replace`?
 
 error: this looks like you are swapping `c.0` and `a` manually
-  --> $DIR/swap.rs:140:7
+  --> $DIR/swap.rs:143:7
    |
 LL |       ; let t = c.0;
    |  _______^
@@ -73,7 +90,7 @@ LL | |     a = t;
    = note: or maybe you should use `std::mem::replace`?
 
 error: this looks like you are trying to swap `a` and `b`
-  --> $DIR/swap.rs:128:5
+  --> $DIR/swap.rs:131:5
    |
 LL | /     a = b;
 LL | |     b = a;
@@ -83,7 +100,7 @@ LL | |     b = a;
    = note: or maybe you should use `std::mem::replace`?
 
 error: this looks like you are trying to swap `c.0` and `a`
-  --> $DIR/swap.rs:137:5
+  --> $DIR/swap.rs:140:5
    |
 LL | /     c.0 = a;
 LL | |     a = c.0;
@@ -91,5 +108,5 @@ LL | |     a = c.0;
    |
    = note: or maybe you should use `std::mem::replace`?
 
-error: aborting due to 10 previous errors
+error: aborting due to 12 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From ede977cf3131caeaac71e36c32390ca3c5b4deda Mon Sep 17 00:00:00 2001
From: F3real <stefan92ff@yandex.com>
Date: Mon, 9 Aug 2021 09:49:55 +0200
Subject: Update suggestion in case of index for unnecessary_operation lint

---
 clippy_lints/src/no_effect.rs         | 69 ++++++++++++++++++++++--------
 tests/ui/unnecessary_operation.fixed  |  4 +-
 tests/ui/unnecessary_operation.stderr | 80 +++++++++++++++++------------------
 3 files changed, 94 insertions(+), 59 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/no_effect.rs b/clippy_lints/src/no_effect.rs
index e07518b2586..c50980e1cf6 100644
--- a/clippy_lints/src/no_effect.rs
+++ b/clippy_lints/src/no_effect.rs
@@ -94,28 +94,63 @@ impl<'tcx> LateLintPass<'tcx> for NoEffect {
             if has_no_effect(cx, expr) {
                 span_lint_hir(cx, NO_EFFECT, expr.hir_id, stmt.span, "statement with no effect");
             } else if let Some(reduced) = reduce_expression(cx, expr) {
-                let mut snippet = String::new();
-                for e in reduced {
+                for e in &reduced {
                     if e.span.from_expansion() {
                         return;
                     }
-                    if let Some(snip) = snippet_opt(cx, e.span) {
-                        snippet.push_str(&snip);
-                        snippet.push(';');
-                    } else {
-                        return;
+                }
+                if let ExprKind::Index(..) = &expr.kind {
+                    let snippet;
+                    if_chain! {
+                        if let Some(arr) = snippet_opt(cx, reduced[0].span);
+                        if let Some(func) = snippet_opt(cx, reduced[1].span);
+                        then {
+                            snippet = format!("assert!({}.len() > {});", &arr, &func);
+                        } else {
+                            return;
+                        }
                     }
+                    span_lint_hir_and_then(
+                        cx,
+                        UNNECESSARY_OPERATION,
+                        expr.hir_id,
+                        stmt.span,
+                        "unnecessary operation",
+                        |diag| {
+                            diag.span_suggestion(
+                                stmt.span,
+                                "statement can be written as",
+                                snippet,
+                                Applicability::MaybeIncorrect,
+                            );
+                        },
+                    );
+                } else {
+                    let mut snippet = String::new();
+                    for e in reduced {
+                        if let Some(snip) = snippet_opt(cx, e.span) {
+                            snippet.push_str(&snip);
+                            snippet.push(';');
+                        } else {
+                            return;
+                        }
+                    }
+                    span_lint_hir_and_then(
+                        cx,
+                        UNNECESSARY_OPERATION,
+                        expr.hir_id,
+                        stmt.span,
+                        "unnecessary operation",
+                        |diag| {
+                            diag.span_suggestion(
+                                stmt.span,
+                                "statement can be reduced to",
+                                snippet,
+                                Applicability::MachineApplicable,
+                            );
+                        },
+                    );
                 }
-                span_lint_hir_and_then(
-                    cx,
-                    UNNECESSARY_OPERATION,
-                    expr.hir_id,
-                    stmt.span,
-                    "statement can be reduced",
-                    |diag| {
-                        diag.span_suggestion(stmt.span, "replace it with", snippet, Applicability::MachineApplicable);
-                    },
-                );
             }
         }
     }
diff --git a/tests/ui/unnecessary_operation.fixed b/tests/ui/unnecessary_operation.fixed
index 2fca96c4cd5..bf0ec8deb34 100644
--- a/tests/ui/unnecessary_operation.fixed
+++ b/tests/ui/unnecessary_operation.fixed
@@ -62,10 +62,10 @@ fn main() {
     get_number();
     5;get_number();
     42;get_number();
-    [42, 55];get_usize();
+    assert!([42, 55].len() > get_usize());
     42;get_number();
     get_number();
-    [42; 55];get_usize();
+    assert!([42; 55].len() > get_usize());
     get_number();
     String::from("blah");
 
diff --git a/tests/ui/unnecessary_operation.stderr b/tests/ui/unnecessary_operation.stderr
index f88c9f9908b..f66d08ecb82 100644
--- a/tests/ui/unnecessary_operation.stderr
+++ b/tests/ui/unnecessary_operation.stderr
@@ -1,128 +1,128 @@
-error: statement can be reduced
+error: unnecessary operation
   --> $DIR/unnecessary_operation.rs:51:5
    |
 LL |     Tuple(get_number());
-   |     ^^^^^^^^^^^^^^^^^^^^ help: replace it with: `get_number();`
+   |     ^^^^^^^^^^^^^^^^^^^^ help: statement can be reduced to: `get_number();`
    |
    = note: `-D clippy::unnecessary-operation` implied by `-D warnings`
 
-error: statement can be reduced
+error: unnecessary operation
   --> $DIR/unnecessary_operation.rs:52:5
    |
 LL |     Struct { field: get_number() };
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `get_number();`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: statement can be reduced to: `get_number();`
 
-error: statement can be reduced
+error: unnecessary operation
   --> $DIR/unnecessary_operation.rs:53:5
    |
 LL |     Struct { ..get_struct() };
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `get_struct();`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: statement can be reduced to: `get_struct();`
 
-error: statement can be reduced
+error: unnecessary operation
   --> $DIR/unnecessary_operation.rs:54:5
    |
 LL |     Enum::Tuple(get_number());
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `get_number();`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: statement can be reduced to: `get_number();`
 
-error: statement can be reduced
+error: unnecessary operation
   --> $DIR/unnecessary_operation.rs:55:5
    |
 LL |     Enum::Struct { field: get_number() };
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `get_number();`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: statement can be reduced to: `get_number();`
 
-error: statement can be reduced
+error: unnecessary operation
   --> $DIR/unnecessary_operation.rs:56:5
    |
 LL |     5 + get_number();
-   |     ^^^^^^^^^^^^^^^^^ help: replace it with: `5;get_number();`
+   |     ^^^^^^^^^^^^^^^^^ help: statement can be reduced to: `5;get_number();`
 
-error: statement can be reduced
+error: unnecessary operation
   --> $DIR/unnecessary_operation.rs:57:5
    |
 LL |     *&get_number();
-   |     ^^^^^^^^^^^^^^^ help: replace it with: `get_number();`
+   |     ^^^^^^^^^^^^^^^ help: statement can be reduced to: `get_number();`
 
-error: statement can be reduced
+error: unnecessary operation
   --> $DIR/unnecessary_operation.rs:58:5
    |
 LL |     &get_number();
-   |     ^^^^^^^^^^^^^^ help: replace it with: `get_number();`
+   |     ^^^^^^^^^^^^^^ help: statement can be reduced to: `get_number();`
 
-error: statement can be reduced
+error: unnecessary operation
   --> $DIR/unnecessary_operation.rs:59:5
    |
 LL |     (5, 6, get_number());
-   |     ^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `5;6;get_number();`
+   |     ^^^^^^^^^^^^^^^^^^^^^ help: statement can be reduced to: `5;6;get_number();`
 
-error: statement can be reduced
+error: unnecessary operation
   --> $DIR/unnecessary_operation.rs:60:5
    |
 LL |     box get_number();
-   |     ^^^^^^^^^^^^^^^^^ help: replace it with: `get_number();`
+   |     ^^^^^^^^^^^^^^^^^ help: statement can be reduced to: `get_number();`
 
-error: statement can be reduced
+error: unnecessary operation
   --> $DIR/unnecessary_operation.rs:61:5
    |
 LL |     get_number()..;
-   |     ^^^^^^^^^^^^^^^ help: replace it with: `get_number();`
+   |     ^^^^^^^^^^^^^^^ help: statement can be reduced to: `get_number();`
 
-error: statement can be reduced
+error: unnecessary operation
   --> $DIR/unnecessary_operation.rs:62:5
    |
 LL |     ..get_number();
-   |     ^^^^^^^^^^^^^^^ help: replace it with: `get_number();`
+   |     ^^^^^^^^^^^^^^^ help: statement can be reduced to: `get_number();`
 
-error: statement can be reduced
+error: unnecessary operation
   --> $DIR/unnecessary_operation.rs:63:5
    |
 LL |     5..get_number();
-   |     ^^^^^^^^^^^^^^^^ help: replace it with: `5;get_number();`
+   |     ^^^^^^^^^^^^^^^^ help: statement can be reduced to: `5;get_number();`
 
-error: statement can be reduced
+error: unnecessary operation
   --> $DIR/unnecessary_operation.rs:64:5
    |
 LL |     [42, get_number()];
-   |     ^^^^^^^^^^^^^^^^^^^ help: replace it with: `42;get_number();`
+   |     ^^^^^^^^^^^^^^^^^^^ help: statement can be reduced to: `42;get_number();`
 
-error: statement can be reduced
+error: unnecessary operation
   --> $DIR/unnecessary_operation.rs:65:5
    |
 LL |     [42, 55][get_usize()];
-   |     ^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `[42, 55];get_usize();`
+   |     ^^^^^^^^^^^^^^^^^^^^^^ help: statement can be written as: `assert!([42, 55].len() > get_usize());`
 
-error: statement can be reduced
+error: unnecessary operation
   --> $DIR/unnecessary_operation.rs:66:5
    |
 LL |     (42, get_number()).1;
-   |     ^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `42;get_number();`
+   |     ^^^^^^^^^^^^^^^^^^^^^ help: statement can be reduced to: `42;get_number();`
 
-error: statement can be reduced
+error: unnecessary operation
   --> $DIR/unnecessary_operation.rs:67:5
    |
 LL |     [get_number(); 55];
-   |     ^^^^^^^^^^^^^^^^^^^ help: replace it with: `get_number();`
+   |     ^^^^^^^^^^^^^^^^^^^ help: statement can be reduced to: `get_number();`
 
-error: statement can be reduced
+error: unnecessary operation
   --> $DIR/unnecessary_operation.rs:68:5
    |
 LL |     [42; 55][get_usize()];
-   |     ^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `[42; 55];get_usize();`
+   |     ^^^^^^^^^^^^^^^^^^^^^^ help: statement can be written as: `assert!([42; 55].len() > get_usize());`
 
-error: statement can be reduced
+error: unnecessary operation
   --> $DIR/unnecessary_operation.rs:69:5
    |
 LL | /     {
 LL | |         get_number()
 LL | |     };
-   | |______^ help: replace it with: `get_number();`
+   | |______^ help: statement can be reduced to: `get_number();`
 
-error: statement can be reduced
+error: unnecessary operation
   --> $DIR/unnecessary_operation.rs:72:5
    |
 LL | /     FooString {
 LL | |         s: String::from("blah"),
 LL | |     };
-   | |______^ help: replace it with: `String::from("blah");`
+   | |______^ help: statement can be reduced to: `String::from("blah");`
 
 error: aborting due to 20 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 11ef04728c90aa6105b20c681e3c12f231ba4f12 Mon Sep 17 00:00:00 2001
From: Jade <software@lfcode.ca>
Date: Thu, 29 Jul 2021 23:56:47 -0700
Subject: Add unwrap_or_else_default lint

This will catch `unwrap_or_else(Default::default)` on Result and Option
and suggest `unwrap_or_default()` instead.
---
 CHANGELOG.md                                       |  1 +
 clippy_lints/src/lib.rs                            |  3 +
 clippy_lints/src/methods/mod.rs                    | 32 +++++++++-
 clippy_lints/src/methods/or_fun_call.rs            | 21 +++++--
 clippy_lints/src/methods/unwrap_or_else_default.rs | 50 +++++++++++++++
 clippy_utils/src/source.rs                         |  2 +-
 clippy_utils/src/ty.rs                             | 18 +++++-
 tests/ui/or_fun_call.fixed                         | 19 ++++++
 tests/ui/or_fun_call.rs                            | 19 ++++++
 tests/ui/or_fun_call.stderr                        | 58 +++++++++++-------
 tests/ui/unwrap_or_else_default.fixed              | 71 ++++++++++++++++++++++
 tests/ui/unwrap_or_else_default.rs                 | 71 ++++++++++++++++++++++
 tests/ui/unwrap_or_else_default.stderr             | 22 +++++++
 13 files changed, 356 insertions(+), 31 deletions(-)
 create mode 100644 clippy_lints/src/methods/unwrap_or_else_default.rs
 create mode 100644 tests/ui/unwrap_or_else_default.fixed
 create mode 100644 tests/ui/unwrap_or_else_default.rs
 create mode 100644 tests/ui/unwrap_or_else_default.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index ac745793dda..2b89170073b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2999,6 +2999,7 @@ Released 2018-09-13
 [`unused_unit`]: https://rust-lang.github.io/rust-clippy/master/index.html#unused_unit
 [`unusual_byte_groupings`]: https://rust-lang.github.io/rust-clippy/master/index.html#unusual_byte_groupings
 [`unwrap_in_result`]: https://rust-lang.github.io/rust-clippy/master/index.html#unwrap_in_result
+[`unwrap_or_else_default`]: https://rust-lang.github.io/rust-clippy/master/index.html#unwrap_or_else_default
 [`unwrap_used`]: https://rust-lang.github.io/rust-clippy/master/index.html#unwrap_used
 [`upper_case_acronyms`]: https://rust-lang.github.io/rust-clippy/master/index.html#upper_case_acronyms
 [`use_debug`]: https://rust-lang.github.io/rust-clippy/master/index.html#use_debug
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index f49b382c5ea..dbdb4251b3b 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -797,6 +797,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         methods::UNNECESSARY_FILTER_MAP,
         methods::UNNECESSARY_FOLD,
         methods::UNNECESSARY_LAZY_EVALUATIONS,
+        methods::UNWRAP_OR_ELSE_DEFAULT,
         methods::UNWRAP_USED,
         methods::USELESS_ASREF,
         methods::WRONG_SELF_CONVENTION,
@@ -1341,6 +1342,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(methods::UNNECESSARY_FILTER_MAP),
         LintId::of(methods::UNNECESSARY_FOLD),
         LintId::of(methods::UNNECESSARY_LAZY_EVALUATIONS),
+        LintId::of(methods::UNWRAP_OR_ELSE_DEFAULT),
         LintId::of(methods::USELESS_ASREF),
         LintId::of(methods::WRONG_SELF_CONVENTION),
         LintId::of(methods::ZST_OFFSET),
@@ -1535,6 +1537,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(methods::STRING_EXTEND_CHARS),
         LintId::of(methods::UNNECESSARY_FOLD),
         LintId::of(methods::UNNECESSARY_LAZY_EVALUATIONS),
+        LintId::of(methods::UNWRAP_OR_ELSE_DEFAULT),
         LintId::of(methods::WRONG_SELF_CONVENTION),
         LintId::of(misc::TOPLEVEL_REF_ARG),
         LintId::of(misc::ZERO_PTR),
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 5aa29424349..12f7987fd3a 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -56,6 +56,7 @@ mod uninit_assumed_init;
 mod unnecessary_filter_map;
 mod unnecessary_fold;
 mod unnecessary_lazy_eval;
+mod unwrap_or_else_default;
 mod unwrap_used;
 mod useless_asref;
 mod utils;
@@ -310,6 +311,31 @@ declare_clippy_lint! {
     "using `ok().expect()`, which gives worse error messages than calling `expect` directly on the Result"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usages of `_.unwrap_or_else(Default::default)` on Option and
+    /// Result values.
+    ///
+    /// ### Why is this bad?
+    /// Readability, these can be written as `option.unwrap_or_default` or
+    /// `result.unwrap_or_default`.
+    ///
+    /// ### Examples
+    /// ```rust
+    /// # let x = Some(1);
+    ///
+    /// // Bad
+    /// x.unwrap_or_else(Default::default);
+    /// x.unwrap_or_else(u32::default);
+    ///
+    /// // Good
+    /// x.unwrap_or_default();
+    /// ```
+    pub UNWRAP_OR_ELSE_DEFAULT,
+    style,
+    "using `.unwrap_or_else(Default::default)`, which is more succinctly expressed as `.unwrap_or_default()`"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for usage of `option.map(_).unwrap_or(_)` or `option.map(_).unwrap_or_else(_)` or
@@ -1766,6 +1792,7 @@ impl_lint_pass!(Methods => [
     SHOULD_IMPLEMENT_TRAIT,
     WRONG_SELF_CONVENTION,
     OK_EXPECT,
+    UNWRAP_OR_ELSE_DEFAULT,
     MAP_UNWRAP_OR,
     RESULT_MAP_OR_INTO_OPTION,
     OPTION_MAP_OR_NONE,
@@ -2172,7 +2199,10 @@ fn check_methods<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, msrv: Optio
             },
             ("unwrap_or_else", [u_arg]) => match method_call!(recv) {
                 Some(("map", [recv, map_arg], _)) if map_unwrap_or::check(cx, expr, recv, map_arg, u_arg, msrv) => {},
-                _ => unnecessary_lazy_eval::check(cx, expr, recv, u_arg, "unwrap_or"),
+                _ => {
+                    unwrap_or_else_default::check(cx, expr, recv, u_arg);
+                    unnecessary_lazy_eval::check(cx, expr, recv, u_arg, "unwrap_or");
+                },
             },
             _ => {},
         }
diff --git a/clippy_lints/src/methods/or_fun_call.rs b/clippy_lints/src/methods/or_fun_call.rs
index ef615b0aa40..378b0724170 100644
--- a/clippy_lints/src/methods/or_fun_call.rs
+++ b/clippy_lints/src/methods/or_fun_call.rs
@@ -1,7 +1,8 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::eager_or_lazy::is_lazyness_candidate;
 use clippy_utils::source::{snippet, snippet_with_applicability, snippet_with_macro_callsite};
-use clippy_utils::ty::{implements_trait, is_type_diagnostic_item, match_type};
+use clippy_utils::ty::{implements_trait, qpath_target_trait};
+use clippy_utils::ty::{is_type_diagnostic_item, match_type};
 use clippy_utils::{contains_return, last_path_segment, paths};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
@@ -34,15 +35,25 @@ pub(super) fn check<'tcx>(
         or_has_args: bool,
         span: Span,
     ) -> bool {
+        let is_default_default = |qpath, default_trait_id| {
+            qpath_target_trait(cx, qpath, fun.hir_id).map_or(false, |target_trait| target_trait == default_trait_id)
+        };
+
+        let implements_default = |arg, default_trait_id| {
+            let arg_ty = cx.typeck_results().expr_ty(arg);
+            implements_trait(cx, arg_ty, default_trait_id, &[])
+        };
+
         if_chain! {
             if !or_has_args;
             if name == "unwrap_or";
             if let hir::ExprKind::Path(ref qpath) = fun.kind;
-            let path = last_path_segment(qpath).ident.name;
-            if matches!(path, kw::Default | sym::new);
-            let arg_ty = cx.typeck_results().expr_ty(arg);
             if let Some(default_trait_id) = cx.tcx.get_diagnostic_item(sym::Default);
-            if implements_trait(cx, arg_ty, default_trait_id, &[]);
+            let path = last_path_segment(qpath).ident.name;
+            // needs to target Default::default in particular or be *::new and have a Default impl
+            // available
+            if (matches!(path, kw::Default) && is_default_default(qpath, default_trait_id))
+                || (matches!(path, sym::new) && implements_default(arg, default_trait_id));
 
             then {
                 let mut applicability = Applicability::MachineApplicable;
diff --git a/clippy_lints/src/methods/unwrap_or_else_default.rs b/clippy_lints/src/methods/unwrap_or_else_default.rs
new file mode 100644
index 00000000000..f99ae6cae93
--- /dev/null
+++ b/clippy_lints/src/methods/unwrap_or_else_default.rs
@@ -0,0 +1,50 @@
+//! Lint for `some_result_or_option.unwrap_or_else(Default::default)`
+
+use super::UNWRAP_OR_ELSE_DEFAULT;
+use clippy_utils::{
+    diagnostics::span_lint_and_sugg,
+    source::snippet_with_applicability,
+    ty::{is_type_diagnostic_item, qpath_target_trait},
+};
+use rustc_errors::Applicability;
+use rustc_hir as hir;
+use rustc_lint::LateContext;
+use rustc_span::sym;
+
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx hir::Expr<'_>,
+    recv: &'tcx hir::Expr<'_>,
+    u_arg: &'tcx hir::Expr<'_>,
+) {
+    // something.unwrap_or_else(Default::default)
+    // ^^^^^^^^^- recv          ^^^^^^^^^^^^^^^^- u_arg
+    // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^- expr
+    let recv_ty = cx.typeck_results().expr_ty(recv);
+    let is_option = is_type_diagnostic_item(cx, recv_ty, sym::option_type);
+    let is_result = is_type_diagnostic_item(cx, recv_ty, sym::result_type);
+
+    if_chain! {
+        if is_option || is_result;
+        if let hir::ExprKind::Path(ref qpath) = u_arg.kind;
+        if let Some(default_trait_id) = cx.tcx.get_diagnostic_item(sym::Default);
+        if let Some(target_trait) = qpath_target_trait(cx, qpath, u_arg.hir_id);
+        if target_trait == default_trait_id;
+        then {
+            let mut applicability = Applicability::MachineApplicable;
+
+            span_lint_and_sugg(
+                cx,
+                UNWRAP_OR_ELSE_DEFAULT,
+                expr.span,
+                "use of `.unwrap_or_else(..)` to construct default value",
+                "try",
+                format!(
+                    "{}.unwrap_or_default()",
+                    snippet_with_applicability(cx, recv.span, "..", &mut applicability)
+                ),
+                applicability,
+            );
+        }
+    }
+}
diff --git a/clippy_utils/src/source.rs b/clippy_utils/src/source.rs
index 4d49b43bde9..789079510c5 100644
--- a/clippy_utils/src/source.rs
+++ b/clippy_utils/src/source.rs
@@ -168,7 +168,7 @@ pub fn snippet<'a, T: LintContext>(cx: &T, span: Span, default: &'a str) -> Cow<
     snippet_opt(cx, span).map_or_else(|| Cow::Borrowed(default), From::from)
 }
 
-/// Same as `snippet`, but it adapts the applicability level by following rules:
+/// Same as [`snippet`], but it adapts the applicability level by following rules:
 ///
 /// - Applicability level `Unspecified` will never be changed.
 /// - If the span is inside a macro, change the applicability level to `MaybeIncorrect`.
diff --git a/clippy_utils/src/ty.rs b/clippy_utils/src/ty.rs
index e914dc1c222..bc31bea8b9f 100644
--- a/clippy_utils/src/ty.rs
+++ b/clippy_utils/src/ty.rs
@@ -2,6 +2,7 @@
 
 #![allow(clippy::module_name_repetitions)]
 
+use hir::{HirId, QPath};
 use rustc_ast::ast::Mutability;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_hir as hir;
@@ -114,7 +115,7 @@ pub fn has_iter_method(cx: &LateContext<'_>, probably_ref_ty: Ty<'_>) -> Option<
 
 /// Checks whether a type implements a trait.
 /// The function returns false in case the type contains an inference variable.
-/// See also `get_trait_def_id`.
+/// See also [`get_trait_def_id`].
 pub fn implements_trait<'tcx>(
     cx: &LateContext<'tcx>,
     ty: Ty<'tcx>,
@@ -136,6 +137,21 @@ pub fn implements_trait<'tcx>(
     })
 }
 
+/// Gets the trait that a path targets. For example `<SomeTy as Trait>::a` would return the
+/// [`DefId`] for `Trait`.
+///
+/// `cx` must be in a body.
+pub fn qpath_target_trait<'tcx>(cx: &LateContext<'tcx>, qpath: &QPath<'_>, expr_id: HirId) -> Option<DefId> {
+    let method_res = cx.typeck_results().qpath_res(qpath, expr_id);
+    let method_id = match method_res {
+        hir::def::Res::Def(_kind, id) => Some(id),
+        _ => None,
+    };
+    let method_id = method_id?;
+
+    cx.tcx.trait_of_item(method_id)
+}
+
 /// Checks whether this type implements `Drop`.
 pub fn has_drop<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
     match ty.ty_adt_def() {
diff --git a/tests/ui/or_fun_call.fixed b/tests/ui/or_fun_call.fixed
index 4390ff7dc30..c2f94d0e857 100644
--- a/tests/ui/or_fun_call.fixed
+++ b/tests/ui/or_fun_call.fixed
@@ -18,6 +18,19 @@ fn or_fun_call() {
         }
     }
 
+    struct FakeDefault;
+    impl FakeDefault {
+        fn default() -> Self {
+            FakeDefault
+        }
+    }
+
+    impl Default for FakeDefault {
+        fn default() -> Self {
+            FakeDefault
+        }
+    }
+
     enum Enum {
         A(i32),
     }
@@ -53,6 +66,12 @@ fn or_fun_call() {
     let with_default_type = Some(1);
     with_default_type.unwrap_or_default();
 
+    let self_default = None::<FakeDefault>;
+    self_default.unwrap_or_else(<FakeDefault>::default);
+
+    let real_default = None::<FakeDefault>;
+    real_default.unwrap_or_default();
+
     let with_vec = Some(vec![1]);
     with_vec.unwrap_or_default();
 
diff --git a/tests/ui/or_fun_call.rs b/tests/ui/or_fun_call.rs
index 75908c974cc..afaf92961b0 100644
--- a/tests/ui/or_fun_call.rs
+++ b/tests/ui/or_fun_call.rs
@@ -18,6 +18,19 @@ fn or_fun_call() {
         }
     }
 
+    struct FakeDefault;
+    impl FakeDefault {
+        fn default() -> Self {
+            FakeDefault
+        }
+    }
+
+    impl Default for FakeDefault {
+        fn default() -> Self {
+            FakeDefault
+        }
+    }
+
     enum Enum {
         A(i32),
     }
@@ -53,6 +66,12 @@ fn or_fun_call() {
     let with_default_type = Some(1);
     with_default_type.unwrap_or(u64::default());
 
+    let self_default = None::<FakeDefault>;
+    self_default.unwrap_or(<FakeDefault>::default());
+
+    let real_default = None::<FakeDefault>;
+    real_default.unwrap_or(<FakeDefault as Default>::default());
+
     let with_vec = Some(vec![1]);
     with_vec.unwrap_or(vec![]);
 
diff --git a/tests/ui/or_fun_call.stderr b/tests/ui/or_fun_call.stderr
index 9905029ce91..b2bcbd38c2d 100644
--- a/tests/ui/or_fun_call.stderr
+++ b/tests/ui/or_fun_call.stderr
@@ -1,5 +1,5 @@
 error: use of `unwrap_or` followed by a function call
-  --> $DIR/or_fun_call.rs:33:19
+  --> $DIR/or_fun_call.rs:46:19
    |
 LL |     with_const_fn.unwrap_or(Duration::from_secs(5));
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|| Duration::from_secs(5))`
@@ -7,130 +7,142 @@ LL |     with_const_fn.unwrap_or(Duration::from_secs(5));
    = note: `-D clippy::or-fun-call` implied by `-D warnings`
 
 error: use of `unwrap_or` followed by a function call
-  --> $DIR/or_fun_call.rs:36:22
+  --> $DIR/or_fun_call.rs:49:22
    |
 LL |     with_constructor.unwrap_or(make());
    |                      ^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(make)`
 
 error: use of `unwrap_or` followed by a call to `new`
-  --> $DIR/or_fun_call.rs:39:5
+  --> $DIR/or_fun_call.rs:52:5
    |
 LL |     with_new.unwrap_or(Vec::new());
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `with_new.unwrap_or_default()`
 
 error: use of `unwrap_or` followed by a function call
-  --> $DIR/or_fun_call.rs:42:21
+  --> $DIR/or_fun_call.rs:55:21
    |
 LL |     with_const_args.unwrap_or(Vec::with_capacity(12));
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|| Vec::with_capacity(12))`
 
 error: use of `unwrap_or` followed by a function call
-  --> $DIR/or_fun_call.rs:45:14
+  --> $DIR/or_fun_call.rs:58:14
    |
 LL |     with_err.unwrap_or(make());
    |              ^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|_| make())`
 
 error: use of `unwrap_or` followed by a function call
-  --> $DIR/or_fun_call.rs:48:19
+  --> $DIR/or_fun_call.rs:61:19
    |
 LL |     with_err_args.unwrap_or(Vec::with_capacity(12));
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|_| Vec::with_capacity(12))`
 
 error: use of `unwrap_or` followed by a call to `default`
-  --> $DIR/or_fun_call.rs:51:5
+  --> $DIR/or_fun_call.rs:64:5
    |
 LL |     with_default_trait.unwrap_or(Default::default());
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `with_default_trait.unwrap_or_default()`
 
 error: use of `unwrap_or` followed by a call to `default`
-  --> $DIR/or_fun_call.rs:54:5
+  --> $DIR/or_fun_call.rs:67:5
    |
 LL |     with_default_type.unwrap_or(u64::default());
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `with_default_type.unwrap_or_default()`
 
+error: use of `unwrap_or` followed by a function call
+  --> $DIR/or_fun_call.rs:70:18
+   |
+LL |     self_default.unwrap_or(<FakeDefault>::default());
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(<FakeDefault>::default)`
+
+error: use of `unwrap_or` followed by a call to `default`
+  --> $DIR/or_fun_call.rs:73:5
+   |
+LL |     real_default.unwrap_or(<FakeDefault as Default>::default());
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `real_default.unwrap_or_default()`
+
 error: use of `unwrap_or` followed by a call to `new`
-  --> $DIR/or_fun_call.rs:57:5
+  --> $DIR/or_fun_call.rs:76:5
    |
 LL |     with_vec.unwrap_or(vec![]);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `with_vec.unwrap_or_default()`
 
 error: use of `unwrap_or` followed by a function call
-  --> $DIR/or_fun_call.rs:60:21
+  --> $DIR/or_fun_call.rs:79:21
    |
 LL |     without_default.unwrap_or(Foo::new());
    |                     ^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(Foo::new)`
 
 error: use of `or_insert` followed by a function call
-  --> $DIR/or_fun_call.rs:63:19
+  --> $DIR/or_fun_call.rs:82:19
    |
 LL |     map.entry(42).or_insert(String::new());
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `or_insert_with(String::new)`
 
 error: use of `or_insert` followed by a function call
-  --> $DIR/or_fun_call.rs:66:23
+  --> $DIR/or_fun_call.rs:85:23
    |
 LL |     map_vec.entry(42).or_insert(vec![]);
    |                       ^^^^^^^^^^^^^^^^^ help: try this: `or_insert_with(Vec::new)`
 
 error: use of `or_insert` followed by a function call
-  --> $DIR/or_fun_call.rs:69:21
+  --> $DIR/or_fun_call.rs:88:21
    |
 LL |     btree.entry(42).or_insert(String::new());
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `or_insert_with(String::new)`
 
 error: use of `or_insert` followed by a function call
-  --> $DIR/or_fun_call.rs:72:25
+  --> $DIR/or_fun_call.rs:91:25
    |
 LL |     btree_vec.entry(42).or_insert(vec![]);
    |                         ^^^^^^^^^^^^^^^^^ help: try this: `or_insert_with(Vec::new)`
 
 error: use of `unwrap_or` followed by a function call
-  --> $DIR/or_fun_call.rs:75:21
+  --> $DIR/or_fun_call.rs:94:21
    |
 LL |     let _ = stringy.unwrap_or("".to_owned());
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|| "".to_owned())`
 
 error: use of `unwrap_or` followed by a function call
-  --> $DIR/or_fun_call.rs:83:21
+  --> $DIR/or_fun_call.rs:102:21
    |
 LL |     let _ = Some(1).unwrap_or(map[&1]);
    |                     ^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|| map[&1])`
 
 error: use of `unwrap_or` followed by a function call
-  --> $DIR/or_fun_call.rs:85:21
+  --> $DIR/or_fun_call.rs:104:21
    |
 LL |     let _ = Some(1).unwrap_or(map[&1]);
    |                     ^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|| map[&1])`
 
 error: use of `or` followed by a function call
-  --> $DIR/or_fun_call.rs:109:35
+  --> $DIR/or_fun_call.rs:128:35
    |
 LL |     let _ = Some("a".to_string()).or(Some("b".to_string()));
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `or_else(|| Some("b".to_string()))`
 
 error: use of `or` followed by a function call
-  --> $DIR/or_fun_call.rs:113:10
+  --> $DIR/or_fun_call.rs:132:10
    |
 LL |         .or(Some(Bar(b, Duration::from_secs(2))));
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `or_else(|| Some(Bar(b, Duration::from_secs(2))))`
 
 error: use of `unwrap_or` followed by a function call
-  --> $DIR/or_fun_call.rs:141:14
+  --> $DIR/or_fun_call.rs:160:14
    |
 LL |         None.unwrap_or(s.as_mut_vec());
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|| s.as_mut_vec())`
 
 error: use of `unwrap_or` followed by a function call
-  --> $DIR/or_fun_call.rs:146:14
+  --> $DIR/or_fun_call.rs:165:14
    |
 LL |         None.unwrap_or(unsafe { s.as_mut_vec() });
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|| unsafe { s.as_mut_vec() })`
 
 error: use of `unwrap_or` followed by a function call
-  --> $DIR/or_fun_call.rs:148:14
+  --> $DIR/or_fun_call.rs:167:14
    |
 LL |         None.unwrap_or( unsafe { s.as_mut_vec() }    );
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|| unsafe { s.as_mut_vec() })`
 
-error: aborting due to 22 previous errors
+error: aborting due to 24 previous errors
 
diff --git a/tests/ui/unwrap_or_else_default.fixed b/tests/ui/unwrap_or_else_default.fixed
new file mode 100644
index 00000000000..7ac3f426c97
--- /dev/null
+++ b/tests/ui/unwrap_or_else_default.fixed
@@ -0,0 +1,71 @@
+// run-rustfix
+
+#![warn(clippy::unwrap_or_else_default)]
+#![allow(dead_code)]
+#![allow(clippy::unnecessary_wraps)]
+
+/// Checks implementation of the `UNWRAP_OR_ELSE_DEFAULT` lint.
+fn unwrap_or_else_default() {
+    struct Foo;
+
+    impl Foo {
+        fn new() -> Foo {
+            Foo
+        }
+
+        // fake default, we should not trigger on this
+        fn default() -> Foo {
+            Foo
+        }
+    }
+
+    struct HasDefaultAndDuplicate;
+
+    impl HasDefaultAndDuplicate {
+        fn default() -> Self {
+            HasDefaultAndDuplicate
+        }
+    }
+
+    impl Default for HasDefaultAndDuplicate {
+        fn default() -> Self {
+            HasDefaultAndDuplicate
+        }
+    }
+
+    enum Enum {
+        A(),
+    }
+
+    fn make<T, V>(_: V) -> T {
+        unimplemented!();
+    }
+
+    let with_enum = Some(Enum::A());
+    with_enum.unwrap_or_else(Enum::A);
+
+    let with_new = Some(vec![1]);
+    with_new.unwrap_or_else(Vec::new);
+
+    let with_err: Result<_, ()> = Ok(vec![1]);
+    with_err.unwrap_or_else(make);
+
+    // should not be changed
+    let with_fake_default = None::<Foo>;
+    with_fake_default.unwrap_or_else(Foo::default);
+
+    // should not be changed
+    let with_fake_default2 = None::<HasDefaultAndDuplicate>;
+    with_fake_default2.unwrap_or_else(<HasDefaultAndDuplicate>::default);
+
+    let with_real_default = None::<HasDefaultAndDuplicate>;
+    with_real_default.unwrap_or_default();
+
+    let with_default_trait = Some(1);
+    with_default_trait.unwrap_or_default();
+
+    let with_default_type = Some(1);
+    with_default_type.unwrap_or_default();
+}
+
+fn main() {}
diff --git a/tests/ui/unwrap_or_else_default.rs b/tests/ui/unwrap_or_else_default.rs
new file mode 100644
index 00000000000..82b727a039e
--- /dev/null
+++ b/tests/ui/unwrap_or_else_default.rs
@@ -0,0 +1,71 @@
+// run-rustfix
+
+#![warn(clippy::unwrap_or_else_default)]
+#![allow(dead_code)]
+#![allow(clippy::unnecessary_wraps)]
+
+/// Checks implementation of the `UNWRAP_OR_ELSE_DEFAULT` lint.
+fn unwrap_or_else_default() {
+    struct Foo;
+
+    impl Foo {
+        fn new() -> Foo {
+            Foo
+        }
+
+        // fake default, we should not trigger on this
+        fn default() -> Foo {
+            Foo
+        }
+    }
+
+    struct HasDefaultAndDuplicate;
+
+    impl HasDefaultAndDuplicate {
+        fn default() -> Self {
+            HasDefaultAndDuplicate
+        }
+    }
+
+    impl Default for HasDefaultAndDuplicate {
+        fn default() -> Self {
+            HasDefaultAndDuplicate
+        }
+    }
+
+    enum Enum {
+        A(),
+    }
+
+    fn make<T, V>(_: V) -> T {
+        unimplemented!();
+    }
+
+    let with_enum = Some(Enum::A());
+    with_enum.unwrap_or_else(Enum::A);
+
+    let with_new = Some(vec![1]);
+    with_new.unwrap_or_else(Vec::new);
+
+    let with_err: Result<_, ()> = Ok(vec![1]);
+    with_err.unwrap_or_else(make);
+
+    // should not be changed
+    let with_fake_default = None::<Foo>;
+    with_fake_default.unwrap_or_else(Foo::default);
+
+    // should not be changed
+    let with_fake_default2 = None::<HasDefaultAndDuplicate>;
+    with_fake_default2.unwrap_or_else(<HasDefaultAndDuplicate>::default);
+
+    let with_real_default = None::<HasDefaultAndDuplicate>;
+    with_real_default.unwrap_or_else(<HasDefaultAndDuplicate as Default>::default);
+
+    let with_default_trait = Some(1);
+    with_default_trait.unwrap_or_else(Default::default);
+
+    let with_default_type = Some(1);
+    with_default_type.unwrap_or_else(u64::default);
+}
+
+fn main() {}
diff --git a/tests/ui/unwrap_or_else_default.stderr b/tests/ui/unwrap_or_else_default.stderr
new file mode 100644
index 00000000000..feb215b09f6
--- /dev/null
+++ b/tests/ui/unwrap_or_else_default.stderr
@@ -0,0 +1,22 @@
+error: use of `.unwrap_or_else(..)` to construct default value
+  --> $DIR/unwrap_or_else_default.rs:62:5
+   |
+LL |     with_real_default.unwrap_or_else(<HasDefaultAndDuplicate as Default>::default);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `with_real_default.unwrap_or_default()`
+   |
+   = note: `-D clippy::unwrap-or-else-default` implied by `-D warnings`
+
+error: use of `.unwrap_or_else(..)` to construct default value
+  --> $DIR/unwrap_or_else_default.rs:65:5
+   |
+LL |     with_default_trait.unwrap_or_else(Default::default);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `with_default_trait.unwrap_or_default()`
+
+error: use of `.unwrap_or_else(..)` to construct default value
+  --> $DIR/unwrap_or_else_default.rs:68:5
+   |
+LL |     with_default_type.unwrap_or_else(u64::default);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `with_default_type.unwrap_or_default()`
+
+error: aborting due to 3 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From c78cc7ac1f1e89cd2e12d29374e1c5e6110d9217 Mon Sep 17 00:00:00 2001
From: Jade <software@lfcode.ca>
Date: Thu, 5 Aug 2021 20:08:52 -0700
Subject: Add is_trait_item, refactor or_fun_call and unwrap_or_else_default

---
 clippy_lints/src/methods/mod.rs                    |  8 ++++----
 clippy_lints/src/methods/or_fun_call.rs            |  9 ++++-----
 clippy_lints/src/methods/unwrap_or_else_default.rs |  9 ++-------
 clippy_utils/src/lib.rs                            | 19 +++++++++++++++++++
 clippy_utils/src/ty.rs                             | 16 ----------------
 5 files changed, 29 insertions(+), 32 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 12f7987fd3a..bf74cad039e 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -313,12 +313,12 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usages of `_.unwrap_or_else(Default::default)` on Option and
-    /// Result values.
+    /// Checks for usages of `_.unwrap_or_else(Default::default)` on `Option` and
+    /// `Result` values.
     ///
     /// ### Why is this bad?
-    /// Readability, these can be written as `option.unwrap_or_default` or
-    /// `result.unwrap_or_default`.
+    /// Readability, these can be written as `_.unwrap_or_default`, which is
+    /// simpler and more concise.
     ///
     /// ### Examples
     /// ```rust
diff --git a/clippy_lints/src/methods/or_fun_call.rs b/clippy_lints/src/methods/or_fun_call.rs
index 378b0724170..c1d22e5d72c 100644
--- a/clippy_lints/src/methods/or_fun_call.rs
+++ b/clippy_lints/src/methods/or_fun_call.rs
@@ -1,7 +1,8 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::eager_or_lazy::is_lazyness_candidate;
+use clippy_utils::is_trait_item;
 use clippy_utils::source::{snippet, snippet_with_applicability, snippet_with_macro_callsite};
-use clippy_utils::ty::{implements_trait, qpath_target_trait};
+use clippy_utils::ty::implements_trait;
 use clippy_utils::ty::{is_type_diagnostic_item, match_type};
 use clippy_utils::{contains_return, last_path_segment, paths};
 use if_chain::if_chain;
@@ -35,9 +36,7 @@ pub(super) fn check<'tcx>(
         or_has_args: bool,
         span: Span,
     ) -> bool {
-        let is_default_default = |qpath, default_trait_id| {
-            qpath_target_trait(cx, qpath, fun.hir_id).map_or(false, |target_trait| target_trait == default_trait_id)
-        };
+        let is_default_default = || is_trait_item(cx, fun, sym::Default);
 
         let implements_default = |arg, default_trait_id| {
             let arg_ty = cx.typeck_results().expr_ty(arg);
@@ -52,7 +51,7 @@ pub(super) fn check<'tcx>(
             let path = last_path_segment(qpath).ident.name;
             // needs to target Default::default in particular or be *::new and have a Default impl
             // available
-            if (matches!(path, kw::Default) && is_default_default(qpath, default_trait_id))
+            if (matches!(path, kw::Default) && is_default_default())
                 || (matches!(path, sym::new) && implements_default(arg, default_trait_id));
 
             then {
diff --git a/clippy_lints/src/methods/unwrap_or_else_default.rs b/clippy_lints/src/methods/unwrap_or_else_default.rs
index f99ae6cae93..677aa80e1b7 100644
--- a/clippy_lints/src/methods/unwrap_or_else_default.rs
+++ b/clippy_lints/src/methods/unwrap_or_else_default.rs
@@ -2,9 +2,7 @@
 
 use super::UNWRAP_OR_ELSE_DEFAULT;
 use clippy_utils::{
-    diagnostics::span_lint_and_sugg,
-    source::snippet_with_applicability,
-    ty::{is_type_diagnostic_item, qpath_target_trait},
+    diagnostics::span_lint_and_sugg, is_trait_item, source::snippet_with_applicability, ty::is_type_diagnostic_item,
 };
 use rustc_errors::Applicability;
 use rustc_hir as hir;
@@ -26,10 +24,7 @@ pub(super) fn check<'tcx>(
 
     if_chain! {
         if is_option || is_result;
-        if let hir::ExprKind::Path(ref qpath) = u_arg.kind;
-        if let Some(default_trait_id) = cx.tcx.get_diagnostic_item(sym::Default);
-        if let Some(target_trait) = qpath_target_trait(cx, qpath, u_arg.hir_id);
-        if target_trait == default_trait_id;
+        if is_trait_item(cx, u_arg, sym::Default);
         then {
             let mut applicability = Applicability::MachineApplicable;
 
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 59f878f8b20..da9560f8ccf 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -326,6 +326,25 @@ pub fn is_trait_method(cx: &LateContext<'_>, expr: &Expr<'_>, diag_item: Symbol)
         .map_or(false, |did| is_diag_trait_item(cx, did, diag_item))
 }
 
+/// Checks if the given expression is a path referring an item on the trait
+/// that is marked with the given diagnostic item.
+///
+/// For checking method call expressions instead of path expressions, use
+/// [`is_trait_method`].
+///
+/// For example, to find if an expression like `u64::default` refers to an item
+/// of the trait `Default`, which is marked `#[rustc_diagnostic_item = "Default"]`,
+/// a `diag_item` of `sym::Default` should be used.
+pub fn is_trait_item(cx: &LateContext<'_>, expr: &Expr<'_>, diag_item: Symbol) -> bool {
+    if let hir::ExprKind::Path(ref qpath) = expr.kind {
+        cx.qpath_res(qpath, expr.hir_id)
+            .opt_def_id()
+            .map_or(false, |def_id| is_diag_trait_item(cx, def_id, diag_item))
+    } else {
+        false
+    }
+}
+
 pub fn last_path_segment<'tcx>(path: &QPath<'tcx>) -> &'tcx PathSegment<'tcx> {
     match *path {
         QPath::Resolved(_, path) => path.segments.last().expect("A path must have at least one segment"),
diff --git a/clippy_utils/src/ty.rs b/clippy_utils/src/ty.rs
index bc31bea8b9f..536d0f006e3 100644
--- a/clippy_utils/src/ty.rs
+++ b/clippy_utils/src/ty.rs
@@ -2,7 +2,6 @@
 
 #![allow(clippy::module_name_repetitions)]
 
-use hir::{HirId, QPath};
 use rustc_ast::ast::Mutability;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_hir as hir;
@@ -137,21 +136,6 @@ pub fn implements_trait<'tcx>(
     })
 }
 
-/// Gets the trait that a path targets. For example `<SomeTy as Trait>::a` would return the
-/// [`DefId`] for `Trait`.
-///
-/// `cx` must be in a body.
-pub fn qpath_target_trait<'tcx>(cx: &LateContext<'tcx>, qpath: &QPath<'_>, expr_id: HirId) -> Option<DefId> {
-    let method_res = cx.typeck_results().qpath_res(qpath, expr_id);
-    let method_id = match method_res {
-        hir::def::Res::Def(_kind, id) => Some(id),
-        _ => None,
-    };
-    let method_id = method_id?;
-
-    cx.tcx.trait_of_item(method_id)
-}
-
 /// Checks whether this type implements `Drop`.
 pub fn has_drop<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
     match ty.ty_adt_def() {
-- 
cgit 1.4.1-3-g733a5


From 23d398b1848571709a0cbb8a08436f6de56d43a8 Mon Sep 17 00:00:00 2001
From: Jade <software@lfcode.ca>
Date: Thu, 5 Aug 2021 19:46:26 -0700
Subject: tree-wide: Fix all the rustdoc warnings

---
 clippy_lints/src/needless_continue.rs | 2 +-
 clippy_lints/src/needless_for_each.rs | 2 +-
 clippy_utils/src/diagnostics.rs       | 6 +++---
 clippy_utils/src/higher.rs            | 6 +++---
 clippy_utils/src/ty.rs                | 2 +-
 5 files changed, 9 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/needless_continue.rs b/clippy_lints/src/needless_continue.rs
index 5088b8bb0d3..5a50cc48d61 100644
--- a/clippy_lints/src/needless_continue.rs
+++ b/clippy_lints/src/needless_continue.rs
@@ -422,7 +422,7 @@ fn check_and_warn<'a>(cx: &EarlyContext<'_>, expr: &'a ast::Expr) {
 ///
 /// is transformed to
 ///
-/// ```ignore
+/// ```text
 ///     {
 ///         let x = 5;
 /// ```
diff --git a/clippy_lints/src/needless_for_each.rs b/clippy_lints/src/needless_for_each.rs
index d9aa42fe8ee..9a6ddc72ce5 100644
--- a/clippy_lints/src/needless_for_each.rs
+++ b/clippy_lints/src/needless_for_each.rs
@@ -122,7 +122,7 @@ impl LateLintPass<'_> for NeedlessForEach {
 /// 2. Detect use of `return` in `Loop` in the closure body.
 ///
 /// NOTE: The functionality of this type is similar to
-/// [`crate::utilts::visitors::find_all_ret_expressions`], but we can't use
+/// [`clippy_utils::visitors::find_all_ret_expressions`], but we can't use
 /// `find_all_ret_expressions` instead of this type. The reasons are:
 /// 1. `find_all_ret_expressions` passes the argument of `ExprKind::Ret` to a callback, but what we
 ///    need here is `ExprKind::Ret` itself.
diff --git a/clippy_utils/src/diagnostics.rs b/clippy_utils/src/diagnostics.rs
index 7c94474cb35..71cfa196fc3 100644
--- a/clippy_utils/src/diagnostics.rs
+++ b/clippy_utils/src/diagnostics.rs
@@ -65,7 +65,7 @@ pub fn span_lint<T: LintContext>(cx: &T, lint: &'static Lint, sp: impl Into<Mult
 ///
 /// # Example
 ///
-/// ```ignore
+/// ```text
 /// error: constant division of 0.0 with 0.0 will always result in NaN
 ///   --> $DIR/zero_div_zero.rs:6:25
 ///    |
@@ -103,7 +103,7 @@ pub fn span_lint_and_help<'a, T: LintContext>(
 ///
 /// # Example
 ///
-/// ```ignore
+/// ```text
 /// error: calls to `std::mem::forget` with a reference instead of an owned value. Forgetting a reference does nothing.
 ///   --> $DIR/drop_forget_ref.rs:10:5
 ///    |
@@ -189,7 +189,7 @@ pub fn span_lint_hir_and_then(
 ///
 /// # Example
 ///
-/// ```ignore
+/// ```text
 /// error: This `.fold` can be more succinctly expressed as `.any`
 /// --> $DIR/methods.rs:390:13
 ///     |
diff --git a/clippy_utils/src/higher.rs b/clippy_utils/src/higher.rs
index f32f1109b08..884180f0586 100644
--- a/clippy_utils/src/higher.rs
+++ b/clippy_utils/src/higher.rs
@@ -195,8 +195,8 @@ pub fn vec_macro<'e>(cx: &LateContext<'_>, expr: &'e hir::Expr<'_>) -> Option<Ve
 /// - `assert!`, `assert_eq!` and `assert_ne!`
 /// - `debug_assert!`, `debug_assert_eq!` and `debug_assert_ne!`
 /// For example:
-/// `assert!(expr)` will return Some([expr])
-/// `debug_assert_eq!(a, b)` will return Some([a, b])
+/// `assert!(expr)` will return `Some([expr])`
+/// `debug_assert_eq!(a, b)` will return `Some([a, b])`
 pub fn extract_assert_macro_args<'tcx>(e: &'tcx Expr<'tcx>) -> Option<Vec<&'tcx Expr<'tcx>>> {
     /// Try to match the AST for a pattern that contains a match, for example when two args are
     /// compared
@@ -283,7 +283,7 @@ pub struct FormatArgsExpn<'tcx> {
 
     /// String literal expressions which represent the format string split by "{}"
     pub format_string_parts: &'tcx [Expr<'tcx>],
-    /// Symbols corresponding to [`format_string_parts`]
+    /// Symbols corresponding to [`Self::format_string_parts`]
     pub format_string_symbols: Vec<Symbol>,
     /// Expressions like `ArgumentV1::new(arg0, Debug::fmt)`
     pub args: &'tcx [Expr<'tcx>],
diff --git a/clippy_utils/src/ty.rs b/clippy_utils/src/ty.rs
index 536d0f006e3..4f9aaf396b8 100644
--- a/clippy_utils/src/ty.rs
+++ b/clippy_utils/src/ty.rs
@@ -114,7 +114,7 @@ pub fn has_iter_method(cx: &LateContext<'_>, probably_ref_ty: Ty<'_>) -> Option<
 
 /// Checks whether a type implements a trait.
 /// The function returns false in case the type contains an inference variable.
-/// See also [`get_trait_def_id`].
+/// See also [`get_trait_def_id`](super::get_trait_def_id).
 pub fn implements_trait<'tcx>(
     cx: &LateContext<'tcx>,
     ty: Ty<'tcx>,
-- 
cgit 1.4.1-3-g733a5


From fc0af8e4d80272b1255a6582a03f846b6f3dc66a Mon Sep 17 00:00:00 2001
From: LeSeulArtichaut <leseulartichaut@gmail.com>
Date: Sat, 7 Aug 2021 00:41:19 +0200
Subject: `never_loop`: suggest using an `if let` instead of a `for` loop

---
 clippy_lints/src/loops/never_loop.rs | 42 ++++++++++++++++++++++++++++++++----
 tests/ui/never_loop.stderr           |  5 +++++
 2 files changed, 43 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/never_loop.rs b/clippy_lints/src/loops/never_loop.rs
index e97b7c94170..6d9f6215ed4 100644
--- a/clippy_lints/src/loops/never_loop.rs
+++ b/clippy_lints/src/loops/never_loop.rs
@@ -1,13 +1,36 @@
+use super::utils::make_iterator_snippet;
 use super::NEVER_LOOP;
-use clippy_utils::diagnostics::span_lint;
-use rustc_hir::{Block, Expr, ExprKind, HirId, InlineAsmOperand, Stmt, StmtKind};
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::higher;
+use clippy_utils::source::snippet;
+use rustc_errors::Applicability;
+use rustc_hir::{Block, Expr, ExprKind, HirId, InlineAsmOperand, LoopSource, Node, Pat, Stmt, StmtKind};
 use rustc_lint::LateContext;
 use std::iter::{once, Iterator};
 
 pub(super) fn check(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-    if let ExprKind::Loop(block, _, _, _) = expr.kind {
+    if let ExprKind::Loop(block, _, source, _) = expr.kind {
         match never_loop_block(block, expr.hir_id) {
-            NeverLoopResult::AlwaysBreak => span_lint(cx, NEVER_LOOP, expr.span, "this loop never actually loops"),
+            NeverLoopResult::AlwaysBreak => {
+                span_lint_and_then(cx, NEVER_LOOP, expr.span, "this loop never actually loops", |diag| {
+                    if_chain! {
+                        if let LoopSource::ForLoop = source;
+                        if let Some((_, Node::Expr(parent_match))) = cx.tcx.hir().parent_iter(expr.hir_id).nth(1);
+                        if let Some((pat, iterator, _, for_span)) = higher::for_loop(parent_match);
+                        then {
+                            // Suggests using an `if let` instead. This is `Unspecified` because the
+                            // loop may (probably) contain `break` statements which would be invalid
+                            // in an `if let`.
+                            diag.span_suggestion_verbose(
+                                for_span.with_hi(iterator.span.hi()),
+                                "if you need the first element of the iterator, try writing",
+                                for_to_if_let_sugg(cx, iterator, pat),
+                                Applicability::Unspecified,
+                            );
+                        }
+                    };
+                });
+            },
             NeverLoopResult::MayContinueMainLoop | NeverLoopResult::Otherwise => (),
         }
     }
@@ -170,3 +193,14 @@ fn never_loop_expr_branch<'a, T: Iterator<Item = &'a Expr<'a>>>(e: &mut T, main_
     e.map(|e| never_loop_expr(e, main_loop_id))
         .fold(NeverLoopResult::AlwaysBreak, combine_branches)
 }
+
+fn for_to_if_let_sugg(cx: &LateContext<'_>, iterator: &Expr<'_>, pat: &Pat<'_>) -> String {
+    let pat_snippet = snippet(cx, pat.span, "_");
+    let iter_snippet = make_iterator_snippet(cx, iterator, &mut Applicability::Unspecified);
+
+    format!(
+        "if let Some({pat}) = {iter}.next()",
+        pat = pat_snippet,
+        iter = iter_snippet
+    )
+}
diff --git a/tests/ui/never_loop.stderr b/tests/ui/never_loop.stderr
index c00b4c78cf2..9fbf3e9ce98 100644
--- a/tests/ui/never_loop.stderr
+++ b/tests/ui/never_loop.stderr
@@ -75,6 +75,11 @@ LL | |             _ => return,
 LL | |         }
 LL | |     }
    | |_____^
+   |
+help: if you need the first element of the iterator, try writing
+   |
+LL |     if let Some(x) = (0..10).next() {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this loop never actually loops
   --> $DIR/never_loop.rs:157:5
-- 
cgit 1.4.1-3-g733a5


From 979ce29086fb6bde6ac88700e1b4072d68739564 Mon Sep 17 00:00:00 2001
From: F3real <stefan92ff@yandex.com>
Date: Wed, 11 Aug 2021 23:46:13 +0200
Subject: Correctly report inclusive range in no_effect lint

---
 clippy_lints/src/no_effect.rs | 16 +++++++++-------
 tests/ui/no_effect.stderr     |  8 +++++++-
 2 files changed, 16 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/no_effect.rs b/clippy_lints/src/no_effect.rs
index e07518b2586..28e9e6f438e 100644
--- a/clippy_lints/src/no_effect.rs
+++ b/clippy_lints/src/no_effect.rs
@@ -3,7 +3,7 @@ use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::has_drop;
 use rustc_errors::Applicability;
 use rustc_hir::def::{DefKind, Res};
-use rustc_hir::{BinOpKind, BlockCheckMode, Expr, ExprKind, Stmt, StmtKind, UnsafeSource};
+use rustc_hir::{is_range_literal, BinOpKind, BlockCheckMode, Expr, ExprKind, Stmt, StmtKind, UnsafeSource};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use std::ops::Deref;
@@ -68,12 +68,14 @@ fn has_no_effect(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
         ExprKind::Call(callee, args) => {
             if let ExprKind::Path(ref qpath) = callee.kind {
                 let res = cx.qpath_res(qpath, callee.hir_id);
-                match res {
-                    Res::Def(DefKind::Struct | DefKind::Variant | DefKind::Ctor(..), ..) => {
-                        !has_drop(cx, cx.typeck_results().expr_ty(expr))
-                            && args.iter().all(|arg| has_no_effect(cx, arg))
-                    },
-                    _ => false,
+                let def_matched = matches!(
+                    res,
+                    Res::Def(DefKind::Struct | DefKind::Variant | DefKind::Ctor(..), ..)
+                );
+                if def_matched || is_range_literal(expr) {
+                    !has_drop(cx, cx.typeck_results().expr_ty(expr)) && args.iter().all(|arg| has_no_effect(cx, arg))
+                } else {
+                    false
                 }
             } else {
                 false
diff --git a/tests/ui/no_effect.stderr b/tests/ui/no_effect.stderr
index 834b9056e31..6b24675ac2d 100644
--- a/tests/ui/no_effect.stderr
+++ b/tests/ui/no_effect.stderr
@@ -108,6 +108,12 @@ error: statement with no effect
 LL |     5..6;
    |     ^^^^^
 
+error: statement with no effect
+  --> $DIR/no_effect.rs:83:5
+   |
+LL |     5..=6;
+   |     ^^^^^^
+
 error: statement with no effect
   --> $DIR/no_effect.rs:84:5
    |
@@ -150,5 +156,5 @@ error: statement with no effect
 LL |     FooString { s: s };
    |     ^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 25 previous errors
+error: aborting due to 26 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 09b7745f34b8d81c1d4517975f2e552274977f45 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Thu, 12 Aug 2021 12:11:26 +0200
Subject: Updated lint message for `rc_mutex`

---
 clippy_lints/src/types/rc_mutex.rs | 11 ++++++-----
 tests/ui/rc_mutex.stderr           | 15 +++++++++++----
 2 files changed, 17 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types/rc_mutex.rs b/clippy_lints/src/types/rc_mutex.rs
index bd7a0ee6408..12db7afb81c 100644
--- a/clippy_lints/src/types/rc_mutex.rs
+++ b/clippy_lints/src/types/rc_mutex.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint;
+use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::is_ty_param_diagnostic_item;
 use if_chain::if_chain;
 use rustc_hir::{self as hir, def_id::DefId, QPath};
@@ -11,13 +11,14 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_
     if_chain! {
         if cx.tcx.is_diagnostic_item(sym::Rc, def_id) ;
         if let Some(_) = is_ty_param_diagnostic_item(cx, qpath, sym!(mutex_type)) ;
-
-        then{
-            span_lint(
+        then {
+            span_lint_and_help(
                 cx,
                 RC_MUTEX,
                 hir_ty.span,
-                "found `Rc<Mutex<_>>`. Consider using `Rc<RefCell<_>>` or `Arc<Mutex<_>>` instead",
+                "usage of `Rc<Mutex<_>>`",
+                None,
+                "consider using `Rc<RefCell<_>>` or `Arc<Mutex<_>>` instead",
             );
             return true;
         }
diff --git a/tests/ui/rc_mutex.stderr b/tests/ui/rc_mutex.stderr
index 8e58e2bc2d0..852e415cf1e 100644
--- a/tests/ui/rc_mutex.stderr
+++ b/tests/ui/rc_mutex.stderr
@@ -1,28 +1,35 @@
-error: found `Rc<Mutex<_>>`. Consider using `Rc<RefCell<_>>` or `Arc<Mutex<_>>` instead
+error: usage of `Rc<Mutex<_>>`
   --> $DIR/rc_mutex.rs:8:10
    |
 LL |     foo: Rc<Mutex<i32>>,
    |          ^^^^^^^^^^^^^^
    |
    = note: `-D clippy::rc-mutex` implied by `-D warnings`
+   = help: consider using `Rc<RefCell<_>>` or `Arc<Mutex<_>>` instead
 
-error: found `Rc<Mutex<_>>`. Consider using `Rc<RefCell<_>>` or `Arc<Mutex<_>>` instead
+error: usage of `Rc<Mutex<_>>`
   --> $DIR/rc_mutex.rs:20:22
    |
 LL | pub fn test1<T>(foo: Rc<Mutex<T>>) {}
    |                      ^^^^^^^^^^^^
+   |
+   = help: consider using `Rc<RefCell<_>>` or `Arc<Mutex<_>>` instead
 
-error: found `Rc<Mutex<_>>`. Consider using `Rc<RefCell<_>>` or `Arc<Mutex<_>>` instead
+error: usage of `Rc<Mutex<_>>`
   --> $DIR/rc_mutex.rs:22:19
    |
 LL | pub fn test2(foo: Rc<Mutex<MyEnum>>) {}
    |                   ^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using `Rc<RefCell<_>>` or `Arc<Mutex<_>>` instead
 
-error: found `Rc<Mutex<_>>`. Consider using `Rc<RefCell<_>>` or `Arc<Mutex<_>>` instead
+error: usage of `Rc<Mutex<_>>`
   --> $DIR/rc_mutex.rs:24:19
    |
 LL | pub fn test3(foo: Rc<Mutex<SubT<usize>>>) {}
    |                   ^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using `Rc<RefCell<_>>` or `Arc<Mutex<_>>` instead
 
 error: aborting due to 4 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 206741bf57361efcd04243b9e2e6275701c15c76 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Thu, 12 Aug 2021 12:05:02 +0200
Subject: Use `avoid_breaking_exported_api` for `types` module lints

Addressed PR reviews regarding code style
---
 clippy_lints/src/lib.rs        |  7 +++-
 clippy_lints/src/types/mod.rs  | 81 +++++++++++++++++++++++++++++++++---------
 clippy_lints/src/utils/conf.rs |  2 +-
 3 files changed, 71 insertions(+), 19 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index dbdb4251b3b..18600498e1c 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1840,7 +1840,12 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box serde_api::SerdeApi);
     let vec_box_size_threshold = conf.vec_box_size_threshold;
     let type_complexity_threshold = conf.type_complexity_threshold;
-    store.register_late_pass(move || box types::Types::new(vec_box_size_threshold, type_complexity_threshold));
+    let avoid_breaking_exported_api = conf.avoid_breaking_exported_api;
+    store.register_late_pass(move || box types::Types::new(
+        vec_box_size_threshold,
+        type_complexity_threshold,
+        avoid_breaking_exported_api,
+    ));
     store.register_late_pass(|| box booleans::NonminimalBool);
     store.register_late_pass(|| box needless_bitwise_bool::NeedlessBitwiseBool);
     store.register_late_pass(|| box eq_op::EqOp);
diff --git a/clippy_lints/src/types/mod.rs b/clippy_lints/src/types/mod.rs
index 371bb8b445a..9588de8459c 100644
--- a/clippy_lints/src/types/mod.rs
+++ b/clippy_lints/src/types/mod.rs
@@ -295,6 +295,7 @@ declare_clippy_lint! {
 pub struct Types {
     vec_box_size_threshold: u64,
     type_complexity_threshold: u64,
+    avoid_breaking_exported_api: bool,
 }
 
 impl_lint_pass!(Types => [BOX_VEC, VEC_BOX, OPTION_OPTION, LINKEDLIST, BORROWED_BOX, REDUNDANT_ALLOCATION, RC_BUFFER, RC_MUTEX, TYPE_COMPLEXITY]);
@@ -308,19 +309,31 @@ impl<'tcx> LateLintPass<'tcx> for Types {
             false
         };
 
+        let is_exported = cx.access_levels.is_exported(cx.tcx.hir().local_def_id(id));
+
         self.check_fn_decl(
             cx,
             decl,
             CheckTyContext {
                 is_in_trait_impl,
+                is_exported,
                 ..CheckTyContext::default()
             },
         );
     }
 
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
+        let is_exported = cx.access_levels.is_exported(item.def_id);
+
         match item.kind {
-            ItemKind::Static(ty, _, _) | ItemKind::Const(ty, _) => self.check_ty(cx, ty, CheckTyContext::default()),
+            ItemKind::Static(ty, _, _) | ItemKind::Const(ty, _) => self.check_ty(
+                cx,
+                ty,
+                CheckTyContext {
+                    is_exported,
+                    ..CheckTyContext::default()
+                },
+            ),
             // functions, enums, structs, impls and traits are covered
             _ => (),
         }
@@ -342,15 +355,31 @@ impl<'tcx> LateLintPass<'tcx> for Types {
     }
 
     fn check_field_def(&mut self, cx: &LateContext<'_>, field: &hir::FieldDef<'_>) {
-        self.check_ty(cx, field.ty, CheckTyContext::default());
+        let is_exported = cx.access_levels.is_exported(cx.tcx.hir().local_def_id(field.hir_id));
+
+        self.check_ty(
+            cx,
+            field.ty,
+            CheckTyContext {
+                is_exported,
+                ..CheckTyContext::default()
+            },
+        );
     }
 
-    fn check_trait_item(&mut self, cx: &LateContext<'_>, item: &TraitItem<'_>) {
+    fn check_trait_item(&mut self, cx: &LateContext<'tcx>, item: &TraitItem<'_>) {
+        let is_exported = cx.access_levels.is_exported(item.def_id);
+
+        let context = CheckTyContext {
+            is_exported,
+            ..CheckTyContext::default()
+        };
+
         match item.kind {
             TraitItemKind::Const(ty, _) | TraitItemKind::Type(_, Some(ty)) => {
-                self.check_ty(cx, ty, CheckTyContext::default());
+                self.check_ty(cx, ty, context);
             },
-            TraitItemKind::Fn(ref sig, _) => self.check_fn_decl(cx, sig.decl, CheckTyContext::default()),
+            TraitItemKind::Fn(ref sig, _) => self.check_fn_decl(cx, sig.decl, context),
             TraitItemKind::Type(..) => (),
         }
     }
@@ -370,10 +399,11 @@ impl<'tcx> LateLintPass<'tcx> for Types {
 }
 
 impl Types {
-    pub fn new(vec_box_size_threshold: u64, type_complexity_threshold: u64) -> Self {
+    pub fn new(vec_box_size_threshold: u64, type_complexity_threshold: u64, avoid_breaking_exported_api: bool) -> Self {
         Self {
             vec_box_size_threshold,
             type_complexity_threshold,
+            avoid_breaking_exported_api,
         }
     }
 
@@ -410,17 +440,24 @@ impl Types {
                 let hir_id = hir_ty.hir_id;
                 let res = cx.qpath_res(qpath, hir_id);
                 if let Some(def_id) = res.opt_def_id() {
-                    let mut triggered = false;
-                    triggered |= box_vec::check(cx, hir_ty, qpath, def_id);
-                    triggered |= redundant_allocation::check(cx, hir_ty, qpath, def_id);
-                    triggered |= rc_buffer::check(cx, hir_ty, qpath, def_id);
-                    triggered |= vec_box::check(cx, hir_ty, qpath, def_id, self.vec_box_size_threshold);
-                    triggered |= option_option::check(cx, hir_ty, qpath, def_id);
-                    triggered |= linked_list::check(cx, hir_ty, def_id);
-                    triggered |= rc_mutex::check(cx, hir_ty, qpath, def_id);
-
-                    if triggered {
-                        return;
+                    if self.is_type_change_allowed(context) {
+                        // All lints that are being checked in this block are guarded by
+                        // the `avoid_breaking_exported_api` configuration. When adding a
+                        // new lint, please also add the name to the configuration documentation
+                        // in `clippy_lints::utils::conf.rs`
+
+                        let mut triggered = false;
+                        triggered |= box_vec::check(cx, hir_ty, qpath, def_id);
+                        triggered |= redundant_allocation::check(cx, hir_ty, qpath, def_id);
+                        triggered |= rc_buffer::check(cx, hir_ty, qpath, def_id);
+                        triggered |= vec_box::check(cx, hir_ty, qpath, def_id, self.vec_box_size_threshold);
+                        triggered |= option_option::check(cx, hir_ty, qpath, def_id);
+                        triggered |= linked_list::check(cx, hir_ty, def_id);
+                        triggered |= rc_mutex::check(cx, hir_ty, qpath, def_id);
+
+                        if triggered {
+                            return;
+                        }
                     }
                 }
                 match *qpath {
@@ -487,11 +524,21 @@ impl Types {
             _ => {},
         }
     }
+
+    /// This function checks if the type is allowed to change in the current context
+    /// based on the `avoid_breaking_exported_api` configuration
+    fn is_type_change_allowed(&self, context: CheckTyContext) -> bool {
+        !(context.is_exported && self.avoid_breaking_exported_api)
+    }
 }
 
+#[allow(clippy::struct_excessive_bools)]
 #[derive(Clone, Copy, Default)]
 struct CheckTyContext {
     is_in_trait_impl: bool,
+    /// `true` for types on local variables.
     is_local: bool,
+    /// `true` for types that are part of the public API.
+    is_exported: bool,
     is_nested_call: bool,
 }
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index a28b1d78f7d..9ee2e302452 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -132,7 +132,7 @@ macro_rules! define_Conf {
 
 // N.B., this macro is parsed by util/lintlib.py
 define_Conf! {
-    /// Lint: ENUM_VARIANT_NAMES, LARGE_TYPES_PASSED_BY_VALUE, TRIVIALLY_COPY_PASS_BY_REF, UNNECESSARY_WRAPS, UPPER_CASE_ACRONYMS, WRONG_SELF_CONVENTION.
+    /// Lint: ENUM_VARIANT_NAMES, LARGE_TYPES_PASSED_BY_VALUE, TRIVIALLY_COPY_PASS_BY_REF, UNNECESSARY_WRAPS, UPPER_CASE_ACRONYMS, WRONG_SELF_CONVENTION, BOX_VEC, REDUNDANT_ALLOCATION, RC_BUFFER, VEC_BOX, OPTION_OPTION, LINKEDLIST, RC_MUTEX.
     ///
     /// Suppress lints whenever the suggested change would cause breakage for other crates.
     (avoid_breaking_exported_api: bool = true),
-- 
cgit 1.4.1-3-g733a5


From 91b598a8e484da328325ece3400e8612b6f854df Mon Sep 17 00:00:00 2001
From: dswij <dswijj@gmail.com>
Date: Fri, 13 Aug 2021 14:36:40 +0800
Subject: Fix false positive on `filter_next`

---
 clippy_lints/src/methods/filter_next.rs | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/filter_next.rs b/clippy_lints/src/methods/filter_next.rs
index 172714f6b01..bcf8d93b602 100644
--- a/clippy_lints/src/methods/filter_next.rs
+++ b/clippy_lints/src/methods/filter_next.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg};
-use clippy_utils::is_trait_method;
 use clippy_utils::source::snippet;
+use clippy_utils::ty::implements_trait;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
@@ -16,7 +16,10 @@ pub(super) fn check<'tcx>(
     filter_arg: &'tcx hir::Expr<'_>,
 ) {
     // lint if caller of `.filter().next()` is an Iterator
-    if is_trait_method(cx, expr, sym::Iterator) {
+    let recv_impls_iterator = cx.tcx.get_diagnostic_item(sym::Iterator).map_or(false, |id| {
+        implements_trait(cx, cx.typeck_results().expr_ty(recv), id, &[])
+    });
+    if recv_impls_iterator {
         let msg = "called `filter(..).next()` on an `Iterator`. This is more succinctly expressed by calling \
                    `.find(..)` instead";
         let filter_snippet = snippet(cx, filter_arg.span, "..");
-- 
cgit 1.4.1-3-g733a5


From 3c8eaa8b2c2d594d39810fc2f2a62098c4107c80 Mon Sep 17 00:00:00 2001
From: David Tolnay <dtolnay@gmail.com>
Date: Sat, 14 Aug 2021 05:47:01 -0700
Subject: Downgrade option_if_let_else to nursery

---
 clippy_lints/src/lib.rs                | 2 +-
 clippy_lints/src/option_if_let_else.rs | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 18600498e1c..8372d681078 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1125,7 +1125,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(needless_for_each::NEEDLESS_FOR_EACH),
         LintId::of(needless_pass_by_value::NEEDLESS_PASS_BY_VALUE),
         LintId::of(non_expressive_names::SIMILAR_NAMES),
-        LintId::of(option_if_let_else::OPTION_IF_LET_ELSE),
         LintId::of(pass_by_ref_or_value::LARGE_TYPES_PASSED_BY_VALUE),
         LintId::of(pass_by_ref_or_value::TRIVIALLY_COPY_PASS_BY_REF),
         LintId::of(ranges::RANGE_MINUS_ONE),
@@ -1802,6 +1801,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(mutable_debug_assertion::DEBUG_ASSERT_WITH_MUT_CALL),
         LintId::of(mutex_atomic::MUTEX_INTEGER),
         LintId::of(nonstandard_macro_braces::NONSTANDARD_MACRO_BRACES),
+        LintId::of(option_if_let_else::OPTION_IF_LET_ELSE),
         LintId::of(path_buf_push_overwrite::PATH_BUF_PUSH_OVERWRITE),
         LintId::of(redundant_pub_crate::REDUNDANT_PUB_CRATE),
         LintId::of(regex::TRIVIAL_REGEX),
diff --git a/clippy_lints/src/option_if_let_else.rs b/clippy_lints/src/option_if_let_else.rs
index 7aef3a5f34c..a7899dc8bc1 100644
--- a/clippy_lints/src/option_if_let_else.rs
+++ b/clippy_lints/src/option_if_let_else.rs
@@ -57,7 +57,7 @@ declare_clippy_lint! {
     /// }, |foo| foo);
     /// ```
     pub OPTION_IF_LET_ELSE,
-    pedantic,
+    nursery,
     "reimplementation of Option::map_or"
 }
 
-- 
cgit 1.4.1-3-g733a5


From 4838c78ba4ef784379ae6ec5617479de2a32d3f6 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sun, 1 Aug 2021 18:39:56 -0400
Subject: Improve `manual_map` and `map_entry` Locals which can be partially
 moved created within the to-be-created closure shouldn't block the use of a
 closure

---
 clippy_lints/src/entry.rs           | 31 +++++++++++++++++++-------
 clippy_utils/src/lib.rs             | 44 +++++++++++++++++++++++++++++--------
 tests/ui/entry.fixed                | 15 ++++++-------
 tests/ui/entry.rs                   |  9 ++++----
 tests/ui/entry.stderr               | 16 ++++++++------
 tests/ui/entry_btree.fixed          | 18 +++++++++++++++
 tests/ui/entry_btree.rs             | 18 +++++++++++++++
 tests/ui/entry_btree.stderr         | 20 +++++++++++++++++
 tests/ui/manual_map_option_2.fixed  | 10 +++++++++
 tests/ui/manual_map_option_2.rs     | 13 +++++++++++
 tests/ui/manual_map_option_2.stderr | 24 ++++++++++++++++++++
 11 files changed, 181 insertions(+), 37 deletions(-)
 create mode 100644 tests/ui/entry_btree.fixed
 create mode 100644 tests/ui/entry_btree.rs
 create mode 100644 tests/ui/entry_btree.stderr
 create mode 100644 tests/ui/manual_map_option_2.fixed
 create mode 100644 tests/ui/manual_map_option_2.rs
 create mode 100644 tests/ui/manual_map_option_2.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/entry.rs b/clippy_lints/src/entry.rs
index e1d0d65edb1..7fb8e427660 100644
--- a/clippy_lints/src/entry.rs
+++ b/clippy_lints/src/entry.rs
@@ -7,8 +7,9 @@ use clippy_utils::{
 };
 use rustc_errors::Applicability;
 use rustc_hir::{
+    hir_id::HirIdSet,
     intravisit::{walk_expr, ErasedMap, NestedVisitorMap, Visitor},
-    Block, Expr, ExprKind, Guard, HirId, Local, Stmt, StmtKind, UnOp,
+    Block, Expr, ExprKind, Guard, HirId, Pat, Stmt, StmtKind, UnOp,
 };
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -336,6 +337,8 @@ struct InsertSearcher<'cx, 'tcx> {
     edits: Vec<Edit<'tcx>>,
     /// A stack of loops the visitor is currently in.
     loops: Vec<HirId>,
+    /// Local variables created in the expression. These don't need to be captured.
+    locals: HirIdSet,
 }
 impl<'tcx> InsertSearcher<'_, 'tcx> {
     /// Visit the expression as a branch in control flow. Multiple insert calls can be used, but
@@ -383,13 +386,16 @@ impl<'tcx> Visitor<'tcx> for InsertSearcher<'_, 'tcx> {
                 }
             },
             StmtKind::Expr(e) => self.visit_expr(e),
-            StmtKind::Local(Local { init: Some(e), .. }) => {
-                self.allow_insert_closure &= !self.in_tail_pos;
-                self.in_tail_pos = false;
-                self.is_single_insert = false;
-                self.visit_expr(e);
+            StmtKind::Local(l) => {
+                self.visit_pat(l.pat);
+                if let Some(e) = l.init {
+                    self.allow_insert_closure &= !self.in_tail_pos;
+                    self.in_tail_pos = false;
+                    self.is_single_insert = false;
+                    self.visit_expr(e);
+                }
             },
-            _ => {
+            StmtKind::Item(_) => {
                 self.allow_insert_closure &= !self.in_tail_pos;
                 self.is_single_insert = false;
             },
@@ -471,6 +477,7 @@ impl<'tcx> Visitor<'tcx> for InsertSearcher<'_, 'tcx> {
                     // Each branch may contain it's own insert expression.
                     let mut is_map_used = self.is_map_used;
                     for arm in arms {
+                        self.visit_pat(arm.pat);
                         if let Some(Guard::If(guard) | Guard::IfLet(_, guard)) = arm.guard {
                             self.visit_non_tail_expr(guard);
                         }
@@ -496,7 +503,8 @@ impl<'tcx> Visitor<'tcx> for InsertSearcher<'_, 'tcx> {
                 },
                 _ => {
                     self.allow_insert_closure &= !self.in_tail_pos;
-                    self.allow_insert_closure &= can_move_expr_to_closure_no_visit(self.cx, expr, &self.loops);
+                    self.allow_insert_closure &=
+                        can_move_expr_to_closure_no_visit(self.cx, expr, &self.loops, &self.locals);
                     // Sub expressions are no longer in the tail position.
                     self.is_single_insert = false;
                     self.in_tail_pos = false;
@@ -505,6 +513,12 @@ impl<'tcx> Visitor<'tcx> for InsertSearcher<'_, 'tcx> {
             },
         }
     }
+
+    fn visit_pat(&mut self, p: &'tcx Pat<'tcx>) {
+        p.each_binding_or_first(&mut |_, id, _, _| {
+            self.locals.insert(id);
+        });
+    }
 }
 
 struct InsertSearchResults<'tcx> {
@@ -630,6 +644,7 @@ fn find_insert_calls(
         in_tail_pos: true,
         is_single_insert: true,
         loops: Vec::new(),
+        locals: HirIdSet::default(),
     };
     s.visit_expr(expr);
     let allow_insert_closure = s.allow_insert_closure;
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 1d59d6bfea1..aee9f791b03 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -67,6 +67,7 @@ use rustc_data_structures::unhash::UnhashMap;
 use rustc_hir as hir;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::def_id::DefId;
+use rustc_hir::hir_id::HirIdSet;
 use rustc_hir::intravisit::{self, walk_expr, ErasedMap, FnKind, NestedVisitorMap, Visitor};
 use rustc_hir::LangItem::{ResultErr, ResultOk};
 use rustc_hir::{
@@ -626,7 +627,12 @@ pub fn can_mut_borrow_both(cx: &LateContext<'_>, e1: &Expr<'_>, e2: &Expr<'_>) -
 }
 
 /// Checks if the top level expression can be moved into a closure as is.
-pub fn can_move_expr_to_closure_no_visit(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, jump_targets: &[HirId]) -> bool {
+pub fn can_move_expr_to_closure_no_visit(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx Expr<'_>,
+    jump_targets: &[HirId],
+    ignore_locals: &HirIdSet,
+) -> bool {
     match expr.kind {
         ExprKind::Break(Destination { target_id: Ok(id), .. }, _)
         | ExprKind::Continue(Destination { target_id: Ok(id), .. })
@@ -642,15 +648,24 @@ pub fn can_move_expr_to_closure_no_visit(cx: &LateContext<'tcx>, expr: &'tcx Exp
         | ExprKind::LlvmInlineAsm(_) => false,
         // Accessing a field of a local value can only be done if the type isn't
         // partially moved.
-        ExprKind::Field(base_expr, _)
-            if matches!(
-                base_expr.kind,
-                ExprKind::Path(QPath::Resolved(_, Path { res: Res::Local(_), .. }))
-            ) && can_partially_move_ty(cx, cx.typeck_results().expr_ty(base_expr)) =>
-        {
+        ExprKind::Field(
+            &Expr {
+                hir_id,
+                kind:
+                    ExprKind::Path(QPath::Resolved(
+                        _,
+                        Path {
+                            res: Res::Local(local_id),
+                            ..
+                        },
+                    )),
+                ..
+            },
+            _,
+        ) if !ignore_locals.contains(local_id) && can_partially_move_ty(cx, cx.typeck_results().node_type(hir_id)) => {
             // TODO: check if the local has been partially moved. Assume it has for now.
             false
-        }
+        },
         _ => true,
     }
 }
@@ -659,7 +674,11 @@ pub fn can_move_expr_to_closure_no_visit(cx: &LateContext<'tcx>, expr: &'tcx Exp
 pub fn can_move_expr_to_closure(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> bool {
     struct V<'cx, 'tcx> {
         cx: &'cx LateContext<'tcx>,
+        // Stack of potential break targets contained in the expression.
         loops: Vec<HirId>,
+        /// Local variables created in the expression. These don't need to be captured.
+        locals: HirIdSet,
+        /// Whether this expression can be turned into a closure.
         allow_closure: bool,
     }
     impl Visitor<'tcx> for V<'_, 'tcx> {
@@ -677,16 +696,23 @@ pub fn can_move_expr_to_closure(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) ->
                 self.visit_block(b);
                 self.loops.pop();
             } else {
-                self.allow_closure &= can_move_expr_to_closure_no_visit(self.cx, e, &self.loops);
+                self.allow_closure &= can_move_expr_to_closure_no_visit(self.cx, e, &self.loops, &self.locals);
                 walk_expr(self, e);
             }
         }
+
+        fn visit_pat(&mut self, p: &'tcx Pat<'tcx>) {
+            p.each_binding_or_first(&mut |_, id, _, _| {
+                self.locals.insert(id);
+            });
+        }
     }
 
     let mut v = V {
         cx,
         allow_closure: true,
         loops: Vec::new(),
+        locals: HirIdSet::default(),
     };
     v.visit_expr(expr);
     v.allow_closure
diff --git a/tests/ui/entry.fixed b/tests/ui/entry.fixed
index cfad3090ba3..8a36ec833d7 100644
--- a/tests/ui/entry.fixed
+++ b/tests/ui/entry.fixed
@@ -4,7 +4,7 @@
 #![warn(clippy::map_entry)]
 #![feature(asm)]
 
-use std::collections::{BTreeMap, HashMap};
+use std::collections::HashMap;
 use std::hash::Hash;
 
 macro_rules! m {
@@ -142,14 +142,13 @@ fn hash_map<K: Eq + Hash + Copy, V: Copy>(m: &mut HashMap<K, V>, m2: &mut HashMa
     if !m.contains_key(&k) {
         insert!(m, k, v);
     }
-}
 
-fn btree_map<K: Eq + Ord + Copy, V: Copy>(m: &mut BTreeMap<K, V>, k: K, v: V, v2: V) {
-    // insert then do something, use if let
-    if let std::collections::btree_map::Entry::Vacant(e) = m.entry(k) {
-        e.insert(v);
-        foo();
-    }
+    // or_insert_with. Partial move of a local declared in the closure is ok.
+    m.entry(k).or_insert_with(|| {
+        let x = (String::new(), String::new());
+        let _ = x.0;
+        v
+    });
 }
 
 fn main() {}
diff --git a/tests/ui/entry.rs b/tests/ui/entry.rs
index fa9280b58de..d972a201ad7 100644
--- a/tests/ui/entry.rs
+++ b/tests/ui/entry.rs
@@ -4,7 +4,7 @@
 #![warn(clippy::map_entry)]
 #![feature(asm)]
 
-use std::collections::{BTreeMap, HashMap};
+use std::collections::HashMap;
 use std::hash::Hash;
 
 macro_rules! m {
@@ -146,13 +146,12 @@ fn hash_map<K: Eq + Hash + Copy, V: Copy>(m: &mut HashMap<K, V>, m2: &mut HashMa
     if !m.contains_key(&k) {
         insert!(m, k, v);
     }
-}
 
-fn btree_map<K: Eq + Ord + Copy, V: Copy>(m: &mut BTreeMap<K, V>, k: K, v: V, v2: V) {
-    // insert then do something, use if let
+    // or_insert_with. Partial move of a local declared in the closure is ok.
     if !m.contains_key(&k) {
+        let x = (String::new(), String::new());
+        let _ = x.0;
         m.insert(k, v);
-        foo();
     }
 }
 
diff --git a/tests/ui/entry.stderr b/tests/ui/entry.stderr
index 8f2e383d675..1076500498d 100644
--- a/tests/ui/entry.stderr
+++ b/tests/ui/entry.stderr
@@ -165,21 +165,23 @@ LL | |         m.insert(m!(k), m!(v));
 LL | |     }
    | |_____^ help: try this: `m.entry(m!(k)).or_insert_with(|| m!(v));`
 
-error: usage of `contains_key` followed by `insert` on a `BTreeMap`
-  --> $DIR/entry.rs:153:5
+error: usage of `contains_key` followed by `insert` on a `HashMap`
+  --> $DIR/entry.rs:151:5
    |
 LL | /     if !m.contains_key(&k) {
+LL | |         let x = (String::new(), String::new());
+LL | |         let _ = x.0;
 LL | |         m.insert(k, v);
-LL | |         foo();
 LL | |     }
    | |_____^
    |
 help: try this
    |
-LL ~     if let std::collections::btree_map::Entry::Vacant(e) = m.entry(k) {
-LL +         e.insert(v);
-LL +         foo();
-LL +     }
+LL ~     m.entry(k).or_insert_with(|| {
+LL +         let x = (String::new(), String::new());
+LL +         let _ = x.0;
+LL +         v
+LL +     });
    |
 
 error: aborting due to 10 previous errors
diff --git a/tests/ui/entry_btree.fixed b/tests/ui/entry_btree.fixed
new file mode 100644
index 00000000000..94979104556
--- /dev/null
+++ b/tests/ui/entry_btree.fixed
@@ -0,0 +1,18 @@
+// run-rustfix
+
+#![warn(clippy::map_entry)]
+#![allow(dead_code)]
+
+use std::collections::BTreeMap;
+
+fn foo() {}
+
+fn btree_map<K: Eq + Ord + Copy, V: Copy>(m: &mut BTreeMap<K, V>, k: K, v: V) {
+    // insert then do something, use if let
+    if let std::collections::btree_map::Entry::Vacant(e) = m.entry(k) {
+        e.insert(v);
+        foo();
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/entry_btree.rs b/tests/ui/entry_btree.rs
new file mode 100644
index 00000000000..080c1d959e8
--- /dev/null
+++ b/tests/ui/entry_btree.rs
@@ -0,0 +1,18 @@
+// run-rustfix
+
+#![warn(clippy::map_entry)]
+#![allow(dead_code)]
+
+use std::collections::BTreeMap;
+
+fn foo() {}
+
+fn btree_map<K: Eq + Ord + Copy, V: Copy>(m: &mut BTreeMap<K, V>, k: K, v: V) {
+    // insert then do something, use if let
+    if !m.contains_key(&k) {
+        m.insert(k, v);
+        foo();
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/entry_btree.stderr b/tests/ui/entry_btree.stderr
new file mode 100644
index 00000000000..5c6fcdf1a28
--- /dev/null
+++ b/tests/ui/entry_btree.stderr
@@ -0,0 +1,20 @@
+error: usage of `contains_key` followed by `insert` on a `BTreeMap`
+  --> $DIR/entry_btree.rs:12:5
+   |
+LL | /     if !m.contains_key(&k) {
+LL | |         m.insert(k, v);
+LL | |         foo();
+LL | |     }
+   | |_____^
+   |
+   = note: `-D clippy::map-entry` implied by `-D warnings`
+help: try this
+   |
+LL ~     if let std::collections::btree_map::Entry::Vacant(e) = m.entry(k) {
+LL +         e.insert(v);
+LL +         foo();
+LL +     }
+   |
+
+error: aborting due to previous error
+
diff --git a/tests/ui/manual_map_option_2.fixed b/tests/ui/manual_map_option_2.fixed
new file mode 100644
index 00000000000..147a0c49e6a
--- /dev/null
+++ b/tests/ui/manual_map_option_2.fixed
@@ -0,0 +1,10 @@
+// run-rustfix
+
+#![warn(clippy::manual_map)]
+
+fn main() {
+    let _ = Some(0).map(|x| {
+            let y = (String::new(), String::new());
+            (x, y.0)
+        });
+}
diff --git a/tests/ui/manual_map_option_2.rs b/tests/ui/manual_map_option_2.rs
new file mode 100644
index 00000000000..cc612dcc601
--- /dev/null
+++ b/tests/ui/manual_map_option_2.rs
@@ -0,0 +1,13 @@
+// run-rustfix
+
+#![warn(clippy::manual_map)]
+
+fn main() {
+    let _ = match Some(0) {
+        Some(x) => Some({
+            let y = (String::new(), String::new());
+            (x, y.0)
+        }),
+        None => None,
+    };
+}
diff --git a/tests/ui/manual_map_option_2.stderr b/tests/ui/manual_map_option_2.stderr
new file mode 100644
index 00000000000..745737079f3
--- /dev/null
+++ b/tests/ui/manual_map_option_2.stderr
@@ -0,0 +1,24 @@
+error: manual implementation of `Option::map`
+  --> $DIR/manual_map_option_2.rs:6:13
+   |
+LL |       let _ = match Some(0) {
+   |  _____________^
+LL | |         Some(x) => Some({
+LL | |             let y = (String::new(), String::new());
+LL | |             (x, y.0)
+LL | |         }),
+LL | |         None => None,
+LL | |     };
+   | |_____^
+   |
+   = note: `-D clippy::manual-map` implied by `-D warnings`
+help: try this
+   |
+LL |     let _ = Some(0).map(|x| {
+LL |             let y = (String::new(), String::new());
+LL |             (x, y.0)
+LL |         });
+   |
+
+error: aborting due to previous error
+
-- 
cgit 1.4.1-3-g733a5


From 251dd30d77c98cbebd1c68840fce029affe9b6a8 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Wed, 4 Aug 2021 13:48:45 -0400
Subject: Improve `manual_map` In some cases check if a borrow made in the
 scrutinee expression would prevent creating the closure used by `map`

---
 clippy_lints/src/manual_map.rs     |  36 ++++++++++--
 clippy_utils/src/lib.rs            | 117 ++++++++++++++++++++++++++++++++-----
 tests/ui/manual_map_option_2.fixed |   6 ++
 tests/ui/manual_map_option_2.rs    |   6 ++
 4 files changed, 145 insertions(+), 20 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_map.rs b/clippy_lints/src/manual_map.rs
index 7dec1595e0d..3ea88f52a1c 100644
--- a/clippy_lints/src/manual_map.rs
+++ b/clippy_lints/src/manual_map.rs
@@ -4,12 +4,14 @@ use clippy_utils::source::{snippet_with_applicability, snippet_with_context};
 use clippy_utils::ty::{is_type_diagnostic_item, peel_mid_ty_refs_is_mutable};
 use clippy_utils::{
     can_move_expr_to_closure, in_constant, is_else_clause, is_lang_ctor, is_lint_allowed, path_to_local_id,
-    peel_hir_expr_refs,
+    peel_hir_expr_refs, peel_hir_expr_while, CaptureKind,
 };
 use rustc_ast::util::parser::PREC_POSTFIX;
 use rustc_errors::Applicability;
 use rustc_hir::LangItem::{OptionNone, OptionSome};
-use rustc_hir::{Arm, BindingAnnotation, Block, Expr, ExprKind, HirId, MatchSource, Mutability, Pat, PatKind};
+use rustc_hir::{
+    def::Res, Arm, BindingAnnotation, Block, Expr, ExprKind, HirId, MatchSource, Mutability, Pat, PatKind, Path, QPath,
+};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -111,10 +113,6 @@ impl LateLintPass<'_> for ManualMap {
                 return;
             }
 
-            if !can_move_expr_to_closure(cx, some_expr) {
-                return;
-            }
-
             // Determine which binding mode to use.
             let explicit_ref = some_pat.contains_explicit_ref_binding();
             let binding_ref = explicit_ref.or_else(|| (ty_ref_count != pat_ref_count).then(|| ty_mutability));
@@ -125,6 +123,32 @@ impl LateLintPass<'_> for ManualMap {
                 None => "",
             };
 
+            match can_move_expr_to_closure(cx, some_expr) {
+                Some(captures) => {
+                    // Check if captures the closure will need conflict with borrows made in the scrutinee.
+                    // TODO: check all the references made in the scrutinee expression. This will require interacting
+                    // with the borrow checker. Currently only `<local>[.<field>]*` is checked for.
+                    if let Some(binding_ref_mutability) = binding_ref {
+                        let e = peel_hir_expr_while(scrutinee, |e| match e.kind {
+                            ExprKind::Field(e, _) | ExprKind::AddrOf(_, _, e) => Some(e),
+                            _ => None,
+                        });
+                        if let ExprKind::Path(QPath::Resolved(None, Path { res: Res::Local(l), .. })) = e.kind {
+                            match captures.get(l) {
+                                Some(CaptureKind::Value | CaptureKind::Ref(Mutability::Mut)) => return,
+                                Some(CaptureKind::Ref(Mutability::Not))
+                                    if binding_ref_mutability == Mutability::Mut =>
+                                {
+                                    return;
+                                }
+                                Some(CaptureKind::Ref(Mutability::Not)) | None => (),
+                            }
+                        }
+                    }
+                },
+                None => return,
+            };
+
             let mut app = Applicability::MachineApplicable;
 
             // Remove address-of expressions from the scrutinee. Either `as_ref` will be called, or
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index aee9f791b03..2655ba6a8e9 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -67,19 +67,20 @@ use rustc_data_structures::unhash::UnhashMap;
 use rustc_hir as hir;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::def_id::DefId;
-use rustc_hir::hir_id::HirIdSet;
+use rustc_hir::hir_id::{HirIdMap, HirIdSet};
 use rustc_hir::intravisit::{self, walk_expr, ErasedMap, FnKind, NestedVisitorMap, Visitor};
 use rustc_hir::LangItem::{ResultErr, ResultOk};
 use rustc_hir::{
     def, Arm, BindingAnnotation, Block, Body, Constness, Destination, Expr, ExprKind, FnDecl, GenericArgs, HirId, Impl,
-    ImplItem, ImplItemKind, IsAsync, Item, ItemKind, LangItem, Local, MatchSource, Node, Param, Pat, PatKind, Path,
-    PathSegment, PrimTy, QPath, Stmt, StmtKind, TraitItem, TraitItemKind, TraitRef, TyKind, UnOp,
+    ImplItem, ImplItemKind, IsAsync, Item, ItemKind, LangItem, Local, MatchSource, Mutability, Node, Param, Pat,
+    PatKind, Path, PathSegment, PrimTy, QPath, Stmt, StmtKind, TraitItem, TraitItemKind, TraitRef, TyKind, UnOp,
 };
 use rustc_lint::{LateContext, Level, Lint, LintContext};
 use rustc_middle::hir::exports::Export;
 use rustc_middle::hir::map::Map;
 use rustc_middle::ty as rustc_ty;
-use rustc_middle::ty::{layout::IntegerExt, DefIdTree, Ty, TyCtxt, TypeFoldable};
+use rustc_middle::ty::adjustment::{Adjust, Adjustment, AutoBorrow};
+use rustc_middle::ty::{layout::IntegerExt, DefIdTree, Ty, TyCtxt, TypeAndMut, TypeFoldable};
 use rustc_semver::RustcVersion;
 use rustc_session::Session;
 use rustc_span::hygiene::{ExpnKind, MacroKind};
@@ -670,8 +671,82 @@ pub fn can_move_expr_to_closure_no_visit(
     }
 }
 
-/// Checks if the expression can be moved into a closure as is.
-pub fn can_move_expr_to_closure(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> bool {
+/// How a local is captured by a closure
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum CaptureKind {
+    Value,
+    Ref(Mutability),
+}
+impl std::ops::BitOr for CaptureKind {
+    type Output = Self;
+    fn bitor(self, rhs: Self) -> Self::Output {
+        match (self, rhs) {
+            (CaptureKind::Value, _) | (_, CaptureKind::Value) => CaptureKind::Value,
+            (CaptureKind::Ref(Mutability::Mut), CaptureKind::Ref(_))
+            | (CaptureKind::Ref(_), CaptureKind::Ref(Mutability::Mut)) => CaptureKind::Ref(Mutability::Mut),
+            (CaptureKind::Ref(Mutability::Not), CaptureKind::Ref(Mutability::Not)) => CaptureKind::Ref(Mutability::Not),
+        }
+    }
+}
+impl std::ops::BitOrAssign for CaptureKind {
+    fn bitor_assign(&mut self, rhs: Self) {
+        *self = *self | rhs;
+    }
+}
+
+/// Given an expression referencing a local, determines how it would be captured in a closure.
+/// Note as this will walk up to parent expressions until the capture can be determined it should
+/// only be used while making a closure somewhere a value is consumed. e.g. a block, match arm, or
+/// function argument (other than a receiver).
+pub fn capture_local_usage(cx: &LateContext<'tcx>, e: &Expr<'_>) -> CaptureKind {
+    debug_assert!(matches!(
+        e.kind,
+        ExprKind::Path(QPath::Resolved(None, Path { res: Res::Local(_), .. }))
+    ));
+
+    let map = cx.tcx.hir();
+    let mut child_id = e.hir_id;
+    let mut capture = CaptureKind::Value;
+
+    for (parent_id, parent) in map.parent_iter(e.hir_id) {
+        if let [Adjustment {
+            kind: Adjust::Deref(_) | Adjust::Borrow(AutoBorrow::Ref(..)),
+            target,
+        }, ref adjust @ ..] = *cx
+            .typeck_results()
+            .adjustments()
+            .get(child_id)
+            .map_or(&[][..], |x| &**x)
+        {
+            if let rustc_ty::RawPtr(TypeAndMut { mutbl: mutability, .. }) | rustc_ty::Ref(_, _, mutability) =
+                *adjust.last().map_or(target, |a| a.target).kind()
+            {
+                return CaptureKind::Ref(mutability);
+            }
+        }
+
+        if let Node::Expr(e) = parent {
+            match e.kind {
+                ExprKind::AddrOf(_, mutability, _) => return CaptureKind::Ref(mutability),
+                ExprKind::Index(..) | ExprKind::Unary(UnOp::Deref, _) => capture = CaptureKind::Ref(Mutability::Not),
+                ExprKind::Assign(lhs, ..) | ExprKind::Assign(_, lhs, _) if lhs.hir_id == child_id => {
+                    return CaptureKind::Ref(Mutability::Mut);
+                },
+                _ => break,
+            }
+        } else {
+            break;
+        }
+
+        child_id = parent_id;
+    }
+
+    capture
+}
+
+/// Checks if the expression can be moved into a closure as is. This will return a list of captures
+/// if so, otherwise, `None`.
+pub fn can_move_expr_to_closure(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<HirIdMap<CaptureKind>> {
     struct V<'cx, 'tcx> {
         cx: &'cx LateContext<'tcx>,
         // Stack of potential break targets contained in the expression.
@@ -680,6 +755,9 @@ pub fn can_move_expr_to_closure(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) ->
         locals: HirIdSet,
         /// Whether this expression can be turned into a closure.
         allow_closure: bool,
+        /// Locals which need to be captured, and whether they need to be by value, reference, or
+        /// mutable reference.
+        captures: HirIdMap<CaptureKind>,
     }
     impl Visitor<'tcx> for V<'_, 'tcx> {
         type Map = ErasedMap<'tcx>;
@@ -691,13 +769,23 @@ pub fn can_move_expr_to_closure(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) ->
             if !self.allow_closure {
                 return;
             }
-            if let ExprKind::Loop(b, ..) = e.kind {
-                self.loops.push(e.hir_id);
-                self.visit_block(b);
-                self.loops.pop();
-            } else {
-                self.allow_closure &= can_move_expr_to_closure_no_visit(self.cx, e, &self.loops, &self.locals);
-                walk_expr(self, e);
+
+            match e.kind {
+                ExprKind::Path(QPath::Resolved(None, &Path { res: Res::Local(l), .. })) => {
+                    if !self.locals.contains(&l) {
+                        let cap = capture_local_usage(self.cx, e);
+                        self.captures.entry(l).and_modify(|e| *e |= cap).or_insert(cap);
+                    }
+                },
+                ExprKind::Loop(b, ..) => {
+                    self.loops.push(e.hir_id);
+                    self.visit_block(b);
+                    self.loops.pop();
+                },
+                _ => {
+                    self.allow_closure &= can_move_expr_to_closure_no_visit(self.cx, e, &self.loops, &self.locals);
+                    walk_expr(self, e);
+                },
             }
         }
 
@@ -713,9 +801,10 @@ pub fn can_move_expr_to_closure(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) ->
         allow_closure: true,
         loops: Vec::new(),
         locals: HirIdSet::default(),
+        captures: HirIdMap::default(),
     };
     v.visit_expr(expr);
-    v.allow_closure
+    v.allow_closure.then(|| v.captures)
 }
 
 /// Returns the method names and argument list of nested method call expressions that make up
diff --git a/tests/ui/manual_map_option_2.fixed b/tests/ui/manual_map_option_2.fixed
index 147a0c49e6a..637f0327954 100644
--- a/tests/ui/manual_map_option_2.fixed
+++ b/tests/ui/manual_map_option_2.fixed
@@ -7,4 +7,10 @@ fn main() {
             let y = (String::new(), String::new());
             (x, y.0)
         });
+
+    let s = Some(String::new());
+    let _ = match &s {
+        Some(x) => Some((x.clone(), s)),
+        None => None,
+    };
 }
diff --git a/tests/ui/manual_map_option_2.rs b/tests/ui/manual_map_option_2.rs
index cc612dcc601..98e00604a1b 100644
--- a/tests/ui/manual_map_option_2.rs
+++ b/tests/ui/manual_map_option_2.rs
@@ -10,4 +10,10 @@ fn main() {
         }),
         None => None,
     };
+
+    let s = Some(String::new());
+    let _ = match &s {
+        Some(x) => Some((x.clone(), s)),
+        None => None,
+    };
 }
-- 
cgit 1.4.1-3-g733a5


From a09bc1b6fe97839b23122ae7e386f75a1bf9c823 Mon Sep 17 00:00:00 2001
From: dswij <dswijj@gmail.com>
Date: Sat, 14 Aug 2021 17:43:28 +0800
Subject: Check `if let` expr usage in `manual_flatten`

`manual_flatten` should not trigger when match expression in `if let` is
going to be used.
---
 clippy_lints/src/loops/manual_flatten.rs | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/manual_flatten.rs b/clippy_lints/src/loops/manual_flatten.rs
index 64ff7574f86..d8153abc965 100644
--- a/clippy_lints/src/loops/manual_flatten.rs
+++ b/clippy_lints/src/loops/manual_flatten.rs
@@ -1,6 +1,7 @@
 use super::utils::make_iterator_snippet;
 use super::MANUAL_FLATTEN;
 use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::visitors::LocalUsedVisitor;
 use clippy_utils::{is_lang_ctor, path_to_local_id};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
@@ -37,16 +38,18 @@ pub(super) fn check<'tcx>(
         if_chain! {
             if let Some(inner_expr) = inner_expr;
             if let ExprKind::Match(
-                match_expr, match_arms, MatchSource::IfLetDesugar{ contains_else_clause: false }
+                match_expr, [true_arm, _else_arm], MatchSource::IfLetDesugar{ contains_else_clause: false }
             ) = inner_expr.kind;
             // Ensure match_expr in `if let` statement is the same as the pat from the for-loop
             if let PatKind::Binding(_, pat_hir_id, _, _) = pat.kind;
             if path_to_local_id(match_expr, pat_hir_id);
             // Ensure the `if let` statement is for the `Some` variant of `Option` or the `Ok` variant of `Result`
-            if let PatKind::TupleStruct(ref qpath, _, _) = match_arms[0].pat.kind;
+            if let PatKind::TupleStruct(ref qpath, _, _) = true_arm.pat.kind;
             let some_ctor = is_lang_ctor(cx, qpath, OptionSome);
             let ok_ctor = is_lang_ctor(cx, qpath, ResultOk);
             if some_ctor || ok_ctor;
+            // Ensure epxr in `if let` is not used afterwards
+            if !LocalUsedVisitor::new(cx, pat_hir_id).check_arm(true_arm);
             then {
                 let if_let_type = if some_ctor { "Some" } else { "Ok" };
                 // Prepare the error message
-- 
cgit 1.4.1-3-g733a5


From 8cf6dae0ca66525fcdf519b588896e6cb5576c71 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sun, 6 Jun 2021 20:01:14 -0400
Subject: Add `for_each_local_usage`. Switch `LocalUsedVisitor` to a function.

---
 clippy_lints/src/bytecount.rs                 |   4 +-
 clippy_lints/src/collapsible_match.rs         |   7 +-
 clippy_lints/src/let_if_seq.rs                |  21 ++---
 clippy_lints/src/loops/for_kv_map.rs          |   6 +-
 clippy_lints/src/loops/manual_flatten.rs      |   4 +-
 clippy_lints/src/loops/needless_range_loop.rs |  25 ++----
 clippy_lints/src/matches.rs                   |   6 +-
 clippy_lints/src/unused_self.rs               |   5 +-
 clippy_utils/src/lib.rs                       |   1 +
 clippy_utils/src/visitors.rs                  | 116 +++++++++++++-------------
 10 files changed, 91 insertions(+), 104 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/bytecount.rs b/clippy_lints/src/bytecount.rs
index c444984bc13..a07cd5e5f4e 100644
--- a/clippy_lints/src/bytecount.rs
+++ b/clippy_lints/src/bytecount.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::match_type;
-use clippy_utils::visitors::LocalUsedVisitor;
+use clippy_utils::visitors::is_local_used;
 use clippy_utils::{path_to_local_id, paths, peel_ref_operators, remove_blocks, strip_pat_refs};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
@@ -65,7 +65,7 @@ impl<'tcx> LateLintPass<'tcx> for ByteCount {
                 return;
             };
             if ty::Uint(UintTy::U8) == *cx.typeck_results().expr_ty(needle).peel_refs().kind();
-            if !LocalUsedVisitor::new(cx, arg_id).check_expr(needle);
+            if !is_local_used(cx, needle, arg_id);
             then {
                 let haystack = if let ExprKind::MethodCall(path, _, args, _) =
                         filter_recv.kind {
diff --git a/clippy_lints/src/collapsible_match.rs b/clippy_lints/src/collapsible_match.rs
index a403a9846ba..bd8f9cc7343 100644
--- a/clippy_lints/src/collapsible_match.rs
+++ b/clippy_lints/src/collapsible_match.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::visitors::LocalUsedVisitor;
+use clippy_utils::visitors::is_local_used;
 use clippy_utils::{is_lang_ctor, path_to_local, peel_ref_operators, SpanlessEq};
 use if_chain::if_chain;
 use rustc_hir::LangItem::OptionNone;
@@ -83,13 +83,12 @@ fn check_arm<'tcx>(arm: &Arm<'tcx>, wild_outer_arm: &Arm<'tcx>, cx: &LateContext
         // the "wild-like" branches must be equal
         if SpanlessEq::new(cx).eq_expr(wild_inner_arm.body, wild_outer_arm.body);
         // the binding must not be used in the if guard
-        let mut used_visitor = LocalUsedVisitor::new(cx, binding_id);
         if match arm.guard {
             None => true,
-            Some(Guard::If(expr) | Guard::IfLet(_, expr)) => !used_visitor.check_expr(expr),
+            Some(Guard::If(expr) | Guard::IfLet(_, expr)) => !is_local_used(cx, expr, binding_id),
         };
         // ...or anywhere in the inner match
-        if !arms_inner.iter().any(|arm| used_visitor.check_arm(arm));
+        if !arms_inner.iter().any(|arm| is_local_used(cx, arm, binding_id));
         then {
             span_lint_and_then(
                 cx,
diff --git a/clippy_lints/src/let_if_seq.rs b/clippy_lints/src/let_if_seq.rs
index 13f0d43cf8d..834440e912d 100644
--- a/clippy_lints/src/let_if_seq.rs
+++ b/clippy_lints/src/let_if_seq.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet;
-use clippy_utils::{path_to_local_id, visitors::LocalUsedVisitor};
+use clippy_utils::{path_to_local_id, visitors::is_local_used};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
@@ -65,11 +65,10 @@ impl<'tcx> LateLintPass<'tcx> for LetIfSeq {
                 if let hir::PatKind::Binding(mode, canonical_id, ident, None) = local.pat.kind;
                 if let hir::StmtKind::Expr(if_) = expr.kind;
                 if let hir::ExprKind::If(cond, then, ref else_) = if_.kind;
-                let mut used_visitor = LocalUsedVisitor::new(cx, canonical_id);
-                if !used_visitor.check_expr(cond);
+                if !is_local_used(cx, cond, canonical_id);
                 if let hir::ExprKind::Block(then, _) = then.kind;
                 if let Some(value) = check_assign(cx, canonical_id, &*then);
-                if !used_visitor.check_expr(value);
+                if !is_local_used(cx, value, canonical_id);
                 then {
                     let span = stmt.span.to(if_.span);
 
@@ -148,15 +147,13 @@ fn check_assign<'tcx>(
         if let hir::ExprKind::Assign(var, value, _) = expr.kind;
         if path_to_local_id(var, decl);
         then {
-            let mut v = LocalUsedVisitor::new(cx, decl);
-
-            if block.stmts.iter().take(block.stmts.len()-1).any(|stmt| v.check_stmt(stmt)) {
-                return None;
+            if block.stmts.iter().take(block.stmts.len()-1).any(|stmt| is_local_used(cx, stmt, decl)) {
+                None
+            } else {
+                Some(value)
             }
-
-            return Some(value);
+        } else {
+            None
         }
     }
-
-    None
 }
diff --git a/clippy_lints/src/loops/for_kv_map.rs b/clippy_lints/src/loops/for_kv_map.rs
index 82bf49f5b49..68bef2f4c8b 100644
--- a/clippy_lints/src/loops/for_kv_map.rs
+++ b/clippy_lints/src/loops/for_kv_map.rs
@@ -3,7 +3,7 @@ use clippy_utils::diagnostics::{multispan_sugg, span_lint_and_then};
 use clippy_utils::source::snippet;
 use clippy_utils::sugg;
 use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::visitors::LocalUsedVisitor;
+use clippy_utils::visitors::is_local_used;
 use rustc_hir::{BorrowKind, Expr, ExprKind, Mutability, Pat, PatKind};
 use rustc_lint::LateContext;
 use rustc_middle::ty;
@@ -66,9 +66,7 @@ pub(super) fn check<'tcx>(
 fn pat_is_wild<'tcx>(cx: &LateContext<'tcx>, pat: &'tcx PatKind<'_>, body: &'tcx Expr<'_>) -> bool {
     match *pat {
         PatKind::Wild => true,
-        PatKind::Binding(_, id, ident, None) if ident.as_str().starts_with('_') => {
-            !LocalUsedVisitor::new(cx, id).check_expr(body)
-        },
+        PatKind::Binding(_, id, ident, None) if ident.as_str().starts_with('_') => !is_local_used(cx, body, id),
         _ => false,
     }
 }
diff --git a/clippy_lints/src/loops/manual_flatten.rs b/clippy_lints/src/loops/manual_flatten.rs
index d8153abc965..2af6cfe35b5 100644
--- a/clippy_lints/src/loops/manual_flatten.rs
+++ b/clippy_lints/src/loops/manual_flatten.rs
@@ -1,7 +1,7 @@
 use super::utils::make_iterator_snippet;
 use super::MANUAL_FLATTEN;
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::visitors::LocalUsedVisitor;
+use clippy_utils::visitors::is_local_used;
 use clippy_utils::{is_lang_ctor, path_to_local_id};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
@@ -49,7 +49,7 @@ pub(super) fn check<'tcx>(
             let ok_ctor = is_lang_ctor(cx, qpath, ResultOk);
             if some_ctor || ok_ctor;
             // Ensure epxr in `if let` is not used afterwards
-            if !LocalUsedVisitor::new(cx, pat_hir_id).check_arm(true_arm);
+            if !is_local_used(cx, true_arm, pat_hir_id);
             then {
                 let if_let_type = if some_ctor { "Some" } else { "Ok" };
                 // Prepare the error message
diff --git a/clippy_lints/src/loops/needless_range_loop.rs b/clippy_lints/src/loops/needless_range_loop.rs
index 3810d0dcc05..fa33d068d3d 100644
--- a/clippy_lints/src/loops/needless_range_loop.rs
+++ b/clippy_lints/src/loops/needless_range_loop.rs
@@ -2,10 +2,8 @@ use super::NEEDLESS_RANGE_LOOP;
 use clippy_utils::diagnostics::{multispan_sugg, span_lint_and_then};
 use clippy_utils::source::snippet;
 use clippy_utils::ty::has_iter_method;
-use clippy_utils::visitors::LocalUsedVisitor;
-use clippy_utils::{
-    contains_name, higher, is_integer_const, match_trait_method, path_to_local_id, paths, sugg, SpanlessEq,
-};
+use clippy_utils::visitors::is_local_used;
+use clippy_utils::{contains_name, higher, is_integer_const, match_trait_method, paths, sugg, SpanlessEq};
 use if_chain::if_chain;
 use rustc_ast::ast;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
@@ -256,43 +254,36 @@ impl<'a, 'tcx> VarVisitor<'a, 'tcx> {
             if let ExprKind::Path(ref seqpath) = seqexpr.kind;
             if let QPath::Resolved(None, seqvar) = *seqpath;
             if seqvar.segments.len() == 1;
-            let index_used_directly = path_to_local_id(idx, self.var);
-            let indexed_indirectly = {
-                let mut used_visitor = LocalUsedVisitor::new(self.cx, self.var);
-                walk_expr(&mut used_visitor, idx);
-                used_visitor.used
-            };
-            if indexed_indirectly || index_used_directly;
+            if is_local_used(self.cx, idx, self.var);
             then {
                 if self.prefer_mutable {
                     self.indexed_mut.insert(seqvar.segments[0].ident.name);
                 }
+                let index_used_directly = matches!(idx.kind, ExprKind::Path(_));
                 let res = self.cx.qpath_res(seqpath, seqexpr.hir_id);
                 match res {
                     Res::Local(hir_id) => {
                         let parent_id = self.cx.tcx.hir().get_parent_item(expr.hir_id);
                         let parent_def_id = self.cx.tcx.hir().local_def_id(parent_id);
                         let extent = self.cx.tcx.region_scope_tree(parent_def_id).var_scope(hir_id.local_id);
-                        if indexed_indirectly {
-                            self.indexed_indirectly.insert(seqvar.segments[0].ident.name, Some(extent));
-                        }
                         if index_used_directly {
                             self.indexed_directly.insert(
                                 seqvar.segments[0].ident.name,
                                 (Some(extent), self.cx.typeck_results().node_type(seqexpr.hir_id)),
                             );
+                        } else {
+                            self.indexed_indirectly.insert(seqvar.segments[0].ident.name, Some(extent));
                         }
                         return false;  // no need to walk further *on the variable*
                     }
                     Res::Def(DefKind::Static | DefKind::Const, ..) => {
-                        if indexed_indirectly {
-                            self.indexed_indirectly.insert(seqvar.segments[0].ident.name, None);
-                        }
                         if index_used_directly {
                             self.indexed_directly.insert(
                                 seqvar.segments[0].ident.name,
                                 (None, self.cx.typeck_results().node_type(seqexpr.hir_id)),
                             );
+                        } else {
+                            self.indexed_indirectly.insert(seqvar.segments[0].ident.name, None);
                         }
                         return false;  // no need to walk further *on the variable*
                     }
diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index 5360c02f905..149c9bee9fb 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -5,7 +5,7 @@ use clippy_utils::diagnostics::{
 use clippy_utils::source::{expr_block, indent_of, snippet, snippet_block, snippet_opt, snippet_with_applicability};
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::{implements_trait, is_type_diagnostic_item, match_type, peel_mid_ty_refs};
-use clippy_utils::visitors::LocalUsedVisitor;
+use clippy_utils::visitors::is_local_used;
 use clippy_utils::{
     get_parent_expr, in_macro, is_expn_of, is_lang_ctor, is_lint_allowed, is_refutable, is_wild, meets_msrv, msrvs,
     path_to_local, path_to_local_id, peel_hir_pat_refs, peel_n_hir_expr_refs, recurse_or_patterns, remove_blocks,
@@ -953,9 +953,7 @@ fn check_wild_err_arm<'tcx>(cx: &LateContext<'tcx>, ex: &Expr<'tcx>, arms: &[Arm
                         // Looking for unused bindings (i.e.: `_e`)
                         for pat in inner.iter() {
                             if let PatKind::Binding(_, id, ident, None) = pat.kind {
-                                if ident.as_str().starts_with('_')
-                                    && !LocalUsedVisitor::new(cx, id).check_expr(arm.body)
-                                {
+                                if ident.as_str().starts_with('_') && !is_local_used(cx, arm.body, id) {
                                     ident_bind_name = (&ident.name.as_str()).to_string();
                                     matching_wild = true;
                                 }
diff --git a/clippy_lints/src/unused_self.rs b/clippy_lints/src/unused_self.rs
index 658ac81f6ea..e7e249c79a2 100644
--- a/clippy_lints/src/unused_self.rs
+++ b/clippy_lints/src/unused_self.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_help;
-use clippy_utils::visitors::LocalUsedVisitor;
+use clippy_utils::visitors::is_local_used;
 use if_chain::if_chain;
 use rustc_hir::{Impl, ImplItem, ImplItemKind, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
@@ -50,8 +50,7 @@ impl<'tcx> LateLintPass<'tcx> for UnusedSelf {
             if let ImplItemKind::Fn(.., body_id) = &impl_item.kind;
             let body = cx.tcx.hir().body(*body_id);
             if let [self_param, ..] = body.params;
-            let self_hir_id = self_param.pat.hir_id;
-            if !LocalUsedVisitor::new(cx, self_hir_id).check_body(body);
+            if !is_local_used(cx, body, self_param.pat.hir_id);
             then {
                 span_lint_and_help(
                     cx,
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index bd229402f41..603e831459d 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -2,6 +2,7 @@
 #![feature(in_band_lifetimes)]
 #![feature(iter_zip)]
 #![feature(rustc_private)]
+#![feature(control_flow_enum)]
 #![recursion_limit = "512"]
 #![cfg_attr(feature = "deny-warnings", deny(warnings))]
 #![allow(clippy::missing_errors_doc, clippy::missing_panics_doc, clippy::must_use_candidate)]
diff --git a/clippy_utils/src/visitors.rs b/clippy_utils/src/visitors.rs
index ce00106dd4d..52f95ff34f5 100644
--- a/clippy_utils/src/visitors.rs
+++ b/clippy_utils/src/visitors.rs
@@ -4,6 +4,7 @@ use rustc_hir::intravisit::{self, walk_expr, ErasedMap, NestedVisitorMap, Visito
 use rustc_hir::{def::Res, Arm, Block, Body, BodyId, Destination, Expr, ExprKind, HirId, Stmt};
 use rustc_lint::LateContext;
 use rustc_middle::hir::map::Map;
+use std::ops::ControlFlow;
 
 /// returns `true` if expr contains match expr desugared from try
 fn contains_try(expr: &hir::Expr<'_>) -> bool {
@@ -133,62 +134,6 @@ where
     }
 }
 
-pub struct LocalUsedVisitor<'hir> {
-    hir: Map<'hir>,
-    pub local_hir_id: HirId,
-    pub used: bool,
-}
-
-impl<'hir> LocalUsedVisitor<'hir> {
-    pub fn new(cx: &LateContext<'hir>, local_hir_id: HirId) -> Self {
-        Self {
-            hir: cx.tcx.hir(),
-            local_hir_id,
-            used: false,
-        }
-    }
-
-    fn check<T>(&mut self, t: T, visit: fn(&mut Self, T)) -> bool {
-        visit(self, t);
-        std::mem::replace(&mut self.used, false)
-    }
-
-    pub fn check_arm(&mut self, arm: &'hir Arm<'_>) -> bool {
-        self.check(arm, Self::visit_arm)
-    }
-
-    pub fn check_body(&mut self, body: &'hir Body<'_>) -> bool {
-        self.check(body, Self::visit_body)
-    }
-
-    pub fn check_expr(&mut self, expr: &'hir Expr<'_>) -> bool {
-        self.check(expr, Self::visit_expr)
-    }
-
-    pub fn check_stmt(&mut self, stmt: &'hir Stmt<'_>) -> bool {
-        self.check(stmt, Self::visit_stmt)
-    }
-}
-
-impl<'v> Visitor<'v> for LocalUsedVisitor<'v> {
-    type Map = Map<'v>;
-
-    fn visit_expr(&mut self, expr: &'v Expr<'v>) {
-        if self.used {
-            return;
-        }
-        if path_to_local_id(expr, self.local_hir_id) {
-            self.used = true;
-        } else {
-            walk_expr(self, expr);
-        }
-    }
-
-    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-        NestedVisitorMap::OnlyBodies(self.hir)
-    }
-}
-
 /// A type which can be visited.
 pub trait Visitable<'tcx> {
     /// Calls the corresponding `visit_*` function on the visitor.
@@ -202,8 +147,22 @@ macro_rules! visitable_ref {
             }
         }
     };
+    ([$t:ident], $f:ident) => {
+        impl Visitable<'tcx> for &'tcx [$t<'tcx>] {
+            fn visit<V: Visitor<'tcx>>(self, visitor: &mut V) {
+                for x in self {
+                    visitor.$f(x);
+                }
+            }
+        }
+    };
 }
+visitable_ref!(Arm, visit_arm);
 visitable_ref!(Block, visit_block);
+visitable_ref!(Body, visit_body);
+visitable_ref!(Expr, visit_expr);
+visitable_ref!(Stmt, visit_stmt);
+visitable_ref!([Stmt], visit_stmt);
 
 /// Calls the given function for each break expression.
 pub fn visit_break_exprs<'tcx>(
@@ -260,3 +219,48 @@ pub fn is_res_used(cx: &LateContext<'_>, res: Res, body: BodyId) -> bool {
     v.visit_expr(&cx.tcx.hir().body(body).value);
     v.found
 }
+
+/// Calls the given function for each usage of the given local.
+pub fn for_each_local_usage<'tcx, B>(
+    cx: &LateContext<'tcx>,
+    visitable: impl Visitable<'tcx>,
+    id: HirId,
+    f: impl FnMut(&'tcx Expr<'tcx>) -> ControlFlow<B>,
+) -> ControlFlow<B> {
+    struct V<'tcx, B, F> {
+        map: Map<'tcx>,
+        id: HirId,
+        f: F,
+        res: ControlFlow<B>,
+    }
+    impl<'tcx, B, F: FnMut(&'tcx Expr<'tcx>) -> ControlFlow<B>> Visitor<'tcx> for V<'tcx, B, F> {
+        type Map = Map<'tcx>;
+        fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+            NestedVisitorMap::OnlyBodies(self.map)
+        }
+
+        fn visit_expr(&mut self, e: &'tcx Expr<'_>) {
+            if self.res.is_continue() {
+                if path_to_local_id(e, self.id) {
+                    self.res = (self.f)(e);
+                } else {
+                    walk_expr(self, e);
+                }
+            }
+        }
+    }
+
+    let mut v = V {
+        map: cx.tcx.hir(),
+        id,
+        f,
+        res: ControlFlow::CONTINUE,
+    };
+    visitable.visit(&mut v);
+    v.res
+}
+
+/// Checks if the given local is used.
+pub fn is_local_used(cx: &LateContext<'tcx>, visitable: impl Visitable<'tcx>, id: HirId) -> bool {
+    for_each_local_usage(cx, visitable, id, |_| ControlFlow::BREAK).is_break()
+}
-- 
cgit 1.4.1-3-g733a5


From a7f376fbd3f30b58ec2bde5538b446eb4c2d615e Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sat, 17 Jul 2021 13:52:03 -0400
Subject: Add lint `manual_split_once`

---
 CHANGELOG.md                                  |   1 +
 clippy_lints/src/lib.rs                       |   3 +
 clippy_lints/src/methods/manual_split_once.rs | 213 ++++++++++++++++++++++++++
 clippy_lints/src/methods/mod.rs               |  44 +++++-
 clippy_lints/src/methods/suspicious_splitn.rs |  14 +-
 clippy_lints/src/utils/conf.rs                |   2 +-
 clippy_utils/src/diagnostics.rs               |   2 +-
 clippy_utils/src/msrvs.rs                     |   1 +
 clippy_utils/src/paths.rs                     |   1 +
 clippy_utils/src/visitors.rs                  |  21 +--
 tests/compile-test.rs                         |   1 +
 tests/ui/manual_split_once.fixed              |  50 ++++++
 tests/ui/manual_split_once.rs                 |  50 ++++++
 tests/ui/manual_split_once.stderr             |  82 ++++++++++
 14 files changed, 459 insertions(+), 26 deletions(-)
 create mode 100644 clippy_lints/src/methods/manual_split_once.rs
 create mode 100644 tests/ui/manual_split_once.fixed
 create mode 100644 tests/ui/manual_split_once.rs
 create mode 100644 tests/ui/manual_split_once.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 2b89170073b..b9e67d361c0 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2754,6 +2754,7 @@ Released 2018-09-13
 [`manual_ok_or`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_ok_or
 [`manual_range_contains`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_range_contains
 [`manual_saturating_arithmetic`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_saturating_arithmetic
+[`manual_split_once`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_split_once
 [`manual_str_repeat`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_str_repeat
 [`manual_strip`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_strip
 [`manual_swap`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_swap
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 8372d681078..1fadaf4770a 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -773,6 +773,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         methods::MANUAL_FILTER_MAP,
         methods::MANUAL_FIND_MAP,
         methods::MANUAL_SATURATING_ARITHMETIC,
+        methods::MANUAL_SPLIT_ONCE,
         methods::MANUAL_STR_REPEAT,
         methods::MAP_COLLECT_RESULT_UNIT,
         methods::MAP_FLATTEN,
@@ -1319,6 +1320,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(methods::MANUAL_FILTER_MAP),
         LintId::of(methods::MANUAL_FIND_MAP),
         LintId::of(methods::MANUAL_SATURATING_ARITHMETIC),
+        LintId::of(methods::MANUAL_SPLIT_ONCE),
         LintId::of(methods::MANUAL_STR_REPEAT),
         LintId::of(methods::MAP_COLLECT_RESULT_UNIT),
         LintId::of(methods::MAP_IDENTITY),
@@ -1617,6 +1619,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(methods::ITER_COUNT),
         LintId::of(methods::MANUAL_FILTER_MAP),
         LintId::of(methods::MANUAL_FIND_MAP),
+        LintId::of(methods::MANUAL_SPLIT_ONCE),
         LintId::of(methods::MAP_IDENTITY),
         LintId::of(methods::OPTION_AS_REF_DEREF),
         LintId::of(methods::OPTION_FILTER_MAP),
diff --git a/clippy_lints/src/methods/manual_split_once.rs b/clippy_lints/src/methods/manual_split_once.rs
new file mode 100644
index 00000000000..e273186d051
--- /dev/null
+++ b/clippy_lints/src/methods/manual_split_once.rs
@@ -0,0 +1,213 @@
+use clippy_utils::consts::{constant, Constant};
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet_with_context;
+use clippy_utils::{is_diag_item_method, match_def_path, paths};
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind, HirId, LangItem, Node, QPath};
+use rustc_lint::LateContext;
+use rustc_middle::ty::{self, adjustment::Adjust};
+use rustc_span::{symbol::sym, Span, SyntaxContext};
+
+use super::MANUAL_SPLIT_ONCE;
+
+pub(super) fn check(cx: &LateContext<'_>, method_name: &str, expr: &Expr<'_>, self_arg: &Expr<'_>, pat_arg: &Expr<'_>) {
+    if !cx.typeck_results().expr_ty_adjusted(self_arg).peel_refs().is_str() {
+        return;
+    }
+
+    let ctxt = expr.span.ctxt();
+    let usage = match parse_iter_usage(cx, ctxt, cx.tcx.hir().parent_iter(expr.hir_id)) {
+        Some(x) => x,
+        None => return,
+    };
+    let (method_name, msg) = if method_name == "splitn" {
+        ("split_once", "manual implementation of `split_once`")
+    } else {
+        ("rsplit_once", "manual implementation of `rsplit_once`")
+    };
+
+    let mut app = Applicability::MachineApplicable;
+    let self_snip = snippet_with_context(cx, self_arg.span, ctxt, "..", &mut app).0;
+    let pat_snip = snippet_with_context(cx, pat_arg.span, ctxt, "..", &mut app).0;
+
+    match usage.kind {
+        IterUsageKind::NextTuple => {
+            span_lint_and_sugg(
+                cx,
+                MANUAL_SPLIT_ONCE,
+                usage.span,
+                msg,
+                "try this",
+                format!("{}.{}({})", self_snip, method_name, pat_snip),
+                app,
+            );
+        },
+        IterUsageKind::Next => {
+            let self_deref = {
+                let adjust = cx.typeck_results().expr_adjustments(self_arg);
+                if adjust.is_empty() {
+                    String::new()
+                } else if cx.typeck_results().expr_ty(self_arg).is_box()
+                    || adjust
+                        .iter()
+                        .any(|a| matches!(a.kind, Adjust::Deref(Some(_))) || a.target.is_box())
+                {
+                    format!("&{}", "*".repeat(adjust.len() - 1))
+                } else {
+                    "*".repeat(adjust.len() - 2)
+                }
+            };
+            let sugg = if usage.unwrap_kind.is_some() {
+                format!(
+                    "{}.{}({}).map_or({}{}, |x| x.0)",
+                    &self_snip, method_name, pat_snip, self_deref, &self_snip
+                )
+            } else {
+                format!(
+                    "Some({}.{}({}).map_or({}{}, |x| x.0))",
+                    &self_snip, method_name, pat_snip, self_deref, &self_snip
+                )
+            };
+
+            span_lint_and_sugg(cx, MANUAL_SPLIT_ONCE, usage.span, msg, "try this", sugg, app);
+        },
+        IterUsageKind::Second => {
+            let access_str = match usage.unwrap_kind {
+                Some(UnwrapKind::Unwrap) => ".unwrap().1",
+                Some(UnwrapKind::QuestionMark) => "?.1",
+                None => ".map(|x| x.1)",
+            };
+            span_lint_and_sugg(
+                cx,
+                MANUAL_SPLIT_ONCE,
+                usage.span,
+                msg,
+                "try this",
+                format!("{}.{}({}){}", self_snip, method_name, pat_snip, access_str),
+                app,
+            );
+        },
+    }
+}
+
+enum IterUsageKind {
+    Next,
+    Second,
+    NextTuple,
+}
+
+enum UnwrapKind {
+    Unwrap,
+    QuestionMark,
+}
+
+struct IterUsage {
+    kind: IterUsageKind,
+    unwrap_kind: Option<UnwrapKind>,
+    span: Span,
+}
+
+fn parse_iter_usage(
+    cx: &LateContext<'tcx>,
+    ctxt: SyntaxContext,
+    mut iter: impl Iterator<Item = (HirId, Node<'tcx>)>,
+) -> Option<IterUsage> {
+    let (kind, span) = match iter.next() {
+        Some((_, Node::Expr(e))) if e.span.ctxt() == ctxt => {
+            let (name, args) = if let ExprKind::MethodCall(name, _, [_, args @ ..], _) = e.kind {
+                (name, args)
+            } else {
+                return None;
+            };
+            let did = cx.typeck_results().type_dependent_def_id(e.hir_id)?;
+            let iter_id = cx.tcx.get_diagnostic_item(sym::Iterator)?;
+
+            match (&*name.ident.as_str(), args) {
+                ("next", []) if cx.tcx.trait_of_item(did) == Some(iter_id) => (IterUsageKind::Next, e.span),
+                ("next_tuple", []) => {
+                    if_chain! {
+                        if match_def_path(cx, did, &paths::ITERTOOLS_NEXT_TUPLE);
+                        if let ty::Adt(adt_def, subs) = cx.typeck_results().expr_ty(e).kind();
+                        if cx.tcx.is_diagnostic_item(sym::option_type, adt_def.did);
+                        if let ty::Tuple(subs) = subs.type_at(0).kind();
+                        if subs.len() == 2;
+                        then {
+                            return Some(IterUsage { kind: IterUsageKind::NextTuple, span: e.span, unwrap_kind: None });
+                        } else {
+                            return None;
+                        }
+                    }
+                },
+                ("nth" | "skip", [idx_expr]) if cx.tcx.trait_of_item(did) == Some(iter_id) => {
+                    if let Some((Constant::Int(idx), _)) = constant(cx, cx.typeck_results(), idx_expr) {
+                        let span = if name.ident.as_str() == "nth" {
+                            e.span
+                        } else {
+                            if_chain! {
+                                if let Some((_, Node::Expr(next_expr))) = iter.next();
+                                if let ExprKind::MethodCall(next_name, _, [_], _) = next_expr.kind;
+                                if next_name.ident.name == sym::next;
+                                if next_expr.span.ctxt() == ctxt;
+                                if let Some(next_id) = cx.typeck_results().type_dependent_def_id(next_expr.hir_id);
+                                if cx.tcx.trait_of_item(next_id) == Some(iter_id);
+                                then {
+                                    next_expr.span
+                                } else {
+                                    return None;
+                                }
+                            }
+                        };
+                        match idx {
+                            0 => (IterUsageKind::Next, span),
+                            1 => (IterUsageKind::Second, span),
+                            _ => return None,
+                        }
+                    } else {
+                        return None;
+                    }
+                },
+                _ => return None,
+            }
+        },
+        _ => return None,
+    };
+
+    let (unwrap_kind, span) = if let Some((_, Node::Expr(e))) = iter.next() {
+        match e.kind {
+            ExprKind::Call(
+                Expr {
+                    kind: ExprKind::Path(QPath::LangItem(LangItem::TryTraitBranch, _)),
+                    ..
+                },
+                _,
+            ) => {
+                let parent_span = e.span.parent().unwrap();
+                if parent_span.ctxt() == ctxt {
+                    (Some(UnwrapKind::QuestionMark), parent_span)
+                } else {
+                    (None, span)
+                }
+            },
+            _ if e.span.ctxt() != ctxt => (None, span),
+            ExprKind::MethodCall(name, _, [_], _)
+                if name.ident.name == sym::unwrap
+                    && cx
+                        .typeck_results()
+                        .type_dependent_def_id(e.hir_id)
+                        .map_or(false, |id| is_diag_item_method(cx, id, sym::option_type)) =>
+            {
+                (Some(UnwrapKind::Unwrap), e.span)
+            },
+            _ => (None, span),
+        }
+    } else {
+        (None, span)
+    };
+
+    Some(IterUsage {
+        kind,
+        unwrap_kind,
+        span,
+    })
+}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 91606ed3b2b..15ad0325006 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -33,6 +33,7 @@ mod iter_nth_zero;
 mod iter_skip_next;
 mod iterator_step_by_zero;
 mod manual_saturating_arithmetic;
+mod manual_split_once;
 mod manual_str_repeat;
 mod map_collect_result_unit;
 mod map_flatten;
@@ -64,6 +65,7 @@ mod wrong_self_convention;
 mod zst_offset;
 
 use bind_instead_of_map::BindInsteadOfMap;
+use clippy_utils::consts::{constant, Constant};
 use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
 use clippy_utils::ty::{contains_adt_constructor, contains_ty, implements_trait, is_copy, is_type_diagnostic_item};
 use clippy_utils::{contains_return, get_trait_def_id, in_macro, iter_input_pats, meets_msrv, msrvs, paths, return_ty};
@@ -1771,6 +1773,31 @@ declare_clippy_lint! {
     "manual implementation of `str::repeat`"
 }
 
+declare_clippy_lint! {
+    /// **What it does:** Checks for usages of `splitn(2, _)`
+    ///
+    /// **Why is this bad?** `split_once` is clearer.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// // Bad
+    /// let some_str = "name=value";
+    /// let mut iter = some_str.splitn(2, '=');
+    /// let name = iter.next().unwrap();
+    /// let value = iter.next().unwrap_or("");
+    ///
+    /// // Good
+    /// let some_str = "name=value";
+    /// let (name, value) = some_str.split_once('=').unwrap_or((some_str, ""));
+    /// ```
+    pub MANUAL_SPLIT_ONCE,
+    complexity,
+    "replace `.splitn(2, pat)` with `.split_once(pat)`"
+}
+
 pub struct Methods {
     avoid_breaking_exported_api: bool,
     msrv: Option<RustcVersion>,
@@ -1848,7 +1875,8 @@ impl_lint_pass!(Methods => [
     IMPLICIT_CLONE,
     SUSPICIOUS_SPLITN,
     MANUAL_STR_REPEAT,
-    EXTEND_WITH_DRAIN
+    EXTEND_WITH_DRAIN,
+    MANUAL_SPLIT_ONCE
 ]);
 
 /// Extracts a method call name, args, and `Span` of the method name.
@@ -2176,8 +2204,18 @@ fn check_methods<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, msrv: Optio
                     unnecessary_lazy_eval::check(cx, expr, recv, arg, "or");
                 }
             },
-            ("splitn" | "splitn_mut" | "rsplitn" | "rsplitn_mut", [count_arg, _]) => {
-                suspicious_splitn::check(cx, name, expr, recv, count_arg);
+            ("splitn" | "rsplitn", [count_arg, pat_arg]) => {
+                if let Some((Constant::Int(count), _)) = constant(cx, cx.typeck_results(), count_arg) {
+                    suspicious_splitn::check(cx, name, expr, recv, count);
+                    if count == 2 && meets_msrv(msrv, &msrvs::STR_SPLIT_ONCE) {
+                        manual_split_once::check(cx, name, expr, recv, pat_arg);
+                    }
+                }
+            },
+            ("splitn_mut" | "rsplitn_mut", [count_arg, _]) => {
+                if let Some((Constant::Int(count), _)) = constant(cx, cx.typeck_results(), count_arg) {
+                    suspicious_splitn::check(cx, name, expr, recv, count);
+                }
             },
             ("step_by", [arg]) => iterator_step_by_zero::check(cx, expr, arg),
             ("to_os_string" | "to_owned" | "to_path_buf" | "to_vec", []) => {
diff --git a/clippy_lints/src/methods/suspicious_splitn.rs b/clippy_lints/src/methods/suspicious_splitn.rs
index a271df60572..1c546a15bf6 100644
--- a/clippy_lints/src/methods/suspicious_splitn.rs
+++ b/clippy_lints/src/methods/suspicious_splitn.rs
@@ -1,4 +1,3 @@
-use clippy_utils::consts::{constant, Constant};
 use clippy_utils::diagnostics::span_lint_and_note;
 use if_chain::if_chain;
 use rustc_ast::LitKind;
@@ -8,15 +7,8 @@ use rustc_span::source_map::Spanned;
 
 use super::SUSPICIOUS_SPLITN;
 
-pub(super) fn check(
-    cx: &LateContext<'_>,
-    method_name: &str,
-    expr: &Expr<'_>,
-    self_arg: &Expr<'_>,
-    count_arg: &Expr<'_>,
-) {
+pub(super) fn check(cx: &LateContext<'_>, method_name: &str, expr: &Expr<'_>, self_arg: &Expr<'_>, count: u128) {
     if_chain! {
-        if let Some((Constant::Int(count), _)) = constant(cx, cx.typeck_results(), count_arg);
         if count <= 1;
         if let Some(call_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
         if let Some(impl_id) = cx.tcx.impl_of_method(call_id);
@@ -24,9 +16,9 @@ pub(super) fn check(
         if lang_items.slice_impl() == Some(impl_id) || lang_items.str_impl() == Some(impl_id);
         then {
             // Ignore empty slice and string literals when used with a literal count.
-            if (matches!(self_arg.kind, ExprKind::Array([]))
+            if matches!(self_arg.kind, ExprKind::Array([]))
                 || matches!(self_arg.kind, ExprKind::Lit(Spanned { node: LitKind::Str(s, _), .. }) if s.is_empty())
-            ) && matches!(count_arg.kind, ExprKind::Lit(_))
+
             {
                 return;
             }
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 9ee2e302452..211ffdeca20 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -136,7 +136,7 @@ define_Conf! {
     ///
     /// Suppress lints whenever the suggested change would cause breakage for other crates.
     (avoid_breaking_exported_api: bool = true),
-    /// Lint: MANUAL_STR_REPEAT, CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR, IF_THEN_SOME_ELSE_NONE.
+    /// Lint: MANUAL_SPLIT_ONCE, MANUAL_STR_REPEAT, CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR, IF_THEN_SOME_ELSE_NONE.
     ///
     /// The minimum rust version that the project supports
     (msrv: Option<String> = None),
diff --git a/clippy_utils/src/diagnostics.rs b/clippy_utils/src/diagnostics.rs
index 71cfa196fc3..9302e5c21fa 100644
--- a/clippy_utils/src/diagnostics.rs
+++ b/clippy_utils/src/diagnostics.rs
@@ -21,7 +21,7 @@ fn docs_link(diag: &mut DiagnosticBuilder<'_>, lint: &'static Lint) {
                 "for further information visit https://rust-lang.github.io/rust-clippy/{}/index.html#{}",
                 &option_env!("RUST_RELEASE_NUM").map_or("master".to_string(), |n| {
                     // extract just major + minor version and ignore patch versions
-                    format!("rust-{}", n.rsplitn(2, '.').nth(1).unwrap())
+                    format!("rust-{}", n.rsplit_once('.').unwrap().1)
                 }),
                 lint
             ));
diff --git a/clippy_utils/src/msrvs.rs b/clippy_utils/src/msrvs.rs
index 4a9c4fd0276..14234d9c9cb 100644
--- a/clippy_utils/src/msrvs.rs
+++ b/clippy_utils/src/msrvs.rs
@@ -13,6 +13,7 @@ macro_rules! msrv_aliases {
 // names may refer to stabilized feature flags or library items
 msrv_aliases! {
     1,53,0 { OR_PATTERNS }
+    1,52,0 { STR_SPLIT_ONCE }
     1,50,0 { BOOL_THEN }
     1,46,0 { CONST_IF_MATCH }
     1,45,0 { STR_STRIP_PREFIX }
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index b0c3fe1e5a7..d7e46c2d3eb 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -68,6 +68,7 @@ pub const IO_WRITE: [&str; 3] = ["std", "io", "Write"];
 pub const IPADDR_V4: [&str; 5] = ["std", "net", "ip", "IpAddr", "V4"];
 pub const IPADDR_V6: [&str; 5] = ["std", "net", "ip", "IpAddr", "V6"];
 pub const ITER_REPEAT: [&str; 5] = ["core", "iter", "sources", "repeat", "repeat"];
+pub const ITERTOOLS_NEXT_TUPLE: [&str; 3] = ["itertools", "Itertools", "next_tuple"];
 #[cfg(feature = "internal-lints")]
 pub const KW_MODULE: [&str; 3] = ["rustc_span", "symbol", "kw"];
 #[cfg(feature = "internal-lints")]
diff --git a/clippy_utils/src/visitors.rs b/clippy_utils/src/visitors.rs
index 52f95ff34f5..503effbdad5 100644
--- a/clippy_utils/src/visitors.rs
+++ b/clippy_utils/src/visitors.rs
@@ -147,22 +147,23 @@ macro_rules! visitable_ref {
             }
         }
     };
-    ([$t:ident], $f:ident) => {
-        impl Visitable<'tcx> for &'tcx [$t<'tcx>] {
-            fn visit<V: Visitor<'tcx>>(self, visitor: &mut V) {
-                for x in self {
-                    visitor.$f(x);
-                }
-            }
-        }
-    };
 }
 visitable_ref!(Arm, visit_arm);
 visitable_ref!(Block, visit_block);
 visitable_ref!(Body, visit_body);
 visitable_ref!(Expr, visit_expr);
 visitable_ref!(Stmt, visit_stmt);
-visitable_ref!([Stmt], visit_stmt);
+
+// impl<'tcx, I: IntoIterator> Visitable<'tcx> for I
+// where
+//     I::Item: Visitable<'tcx>,
+// {
+//     fn visit<V: Visitor<'tcx>>(self, visitor: &mut V) {
+//         for x in self {
+//             x.visit(visitor);
+//         }
+//     }
+// }
 
 /// Calls the given function for each break expression.
 pub fn visit_break_exprs<'tcx>(
diff --git a/tests/compile-test.rs b/tests/compile-test.rs
index 0a82377a10e..6116acffe07 100644
--- a/tests/compile-test.rs
+++ b/tests/compile-test.rs
@@ -39,6 +39,7 @@ fn third_party_crates() -> String {
         "clippy_lints",
         "clippy_utils",
         "if_chain",
+        "itertools",
         "quote",
         "regex",
         "serde",
diff --git a/tests/ui/manual_split_once.fixed b/tests/ui/manual_split_once.fixed
new file mode 100644
index 00000000000..3a0332939d4
--- /dev/null
+++ b/tests/ui/manual_split_once.fixed
@@ -0,0 +1,50 @@
+// run-rustfix
+
+#![feature(custom_inner_attributes)]
+#![warn(clippy::manual_split_once)]
+#![allow(clippy::iter_skip_next, clippy::iter_nth_zero)]
+
+extern crate itertools;
+
+#[allow(unused_imports)]
+use itertools::Itertools;
+
+fn main() {
+    let _ = Some("key=value".split_once('=').map_or("key=value", |x| x.0));
+    let _ = "key=value".splitn(2, '=').nth(2);
+    let _ = "key=value".split_once('=').map_or("key=value", |x| x.0);
+    let _ = "key=value".split_once('=').map_or("key=value", |x| x.0);
+    let _ = "key=value".split_once('=').unwrap().1;
+    let _ = "key=value".split_once('=').unwrap().1;
+    let (_, _) = "key=value".split_once('=').unwrap();
+
+    let s = String::from("key=value");
+    let _ = s.split_once('=').map_or(&*s, |x| x.0);
+
+    let s = Box::<str>::from("key=value");
+    let _ = s.split_once('=').map_or(&*s, |x| x.0);
+
+    let s = &"key=value";
+    let _ = s.split_once('=').map_or(*s, |x| x.0);
+
+    fn _f(s: &str) -> Option<&str> {
+        let _ = s.split_once("key=value").map_or(s, |x| x.0);
+        let _ = s.split_once("key=value")?.1;
+        let _ = s.split_once("key=value")?.1;
+        None
+    }
+
+    // Don't lint, slices don't have `split_once`
+    let _ = [0, 1, 2].splitn(2, |&x| x == 1).nth(1).unwrap();
+}
+
+fn _msrv_1_51() {
+    #![clippy::msrv = "1.51"]
+    // `str::split_once` was stabilized in 1.16. Do not lint this
+    let _ = "key=value".splitn(2, '=').nth(1).unwrap();
+}
+
+fn _msrv_1_52() {
+    #![clippy::msrv = "1.52"]
+    let _ = "key=value".split_once('=').unwrap().1;
+}
diff --git a/tests/ui/manual_split_once.rs b/tests/ui/manual_split_once.rs
new file mode 100644
index 00000000000..e6093b63fe8
--- /dev/null
+++ b/tests/ui/manual_split_once.rs
@@ -0,0 +1,50 @@
+// run-rustfix
+
+#![feature(custom_inner_attributes)]
+#![warn(clippy::manual_split_once)]
+#![allow(clippy::iter_skip_next, clippy::iter_nth_zero)]
+
+extern crate itertools;
+
+#[allow(unused_imports)]
+use itertools::Itertools;
+
+fn main() {
+    let _ = "key=value".splitn(2, '=').next();
+    let _ = "key=value".splitn(2, '=').nth(2);
+    let _ = "key=value".splitn(2, '=').next().unwrap();
+    let _ = "key=value".splitn(2, '=').nth(0).unwrap();
+    let _ = "key=value".splitn(2, '=').nth(1).unwrap();
+    let _ = "key=value".splitn(2, '=').skip(1).next().unwrap();
+    let (_, _) = "key=value".splitn(2, '=').next_tuple().unwrap();
+
+    let s = String::from("key=value");
+    let _ = s.splitn(2, '=').next().unwrap();
+
+    let s = Box::<str>::from("key=value");
+    let _ = s.splitn(2, '=').nth(0).unwrap();
+
+    let s = &"key=value";
+    let _ = s.splitn(2, '=').skip(0).next().unwrap();
+
+    fn _f(s: &str) -> Option<&str> {
+        let _ = s.splitn(2, "key=value").next()?;
+        let _ = s.splitn(2, "key=value").nth(1)?;
+        let _ = s.splitn(2, "key=value").skip(1).next()?;
+        None
+    }
+
+    // Don't lint, slices don't have `split_once`
+    let _ = [0, 1, 2].splitn(2, |&x| x == 1).nth(1).unwrap();
+}
+
+fn _msrv_1_51() {
+    #![clippy::msrv = "1.51"]
+    // `str::split_once` was stabilized in 1.16. Do not lint this
+    let _ = "key=value".splitn(2, '=').nth(1).unwrap();
+}
+
+fn _msrv_1_52() {
+    #![clippy::msrv = "1.52"]
+    let _ = "key=value".splitn(2, '=').nth(1).unwrap();
+}
diff --git a/tests/ui/manual_split_once.stderr b/tests/ui/manual_split_once.stderr
new file mode 100644
index 00000000000..4f15196b469
--- /dev/null
+++ b/tests/ui/manual_split_once.stderr
@@ -0,0 +1,82 @@
+error: manual implementation of `split_once`
+  --> $DIR/manual_split_once.rs:13:13
+   |
+LL |     let _ = "key=value".splitn(2, '=').next();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `Some("key=value".split_once('=').map_or("key=value", |x| x.0))`
+   |
+   = note: `-D clippy::manual-split-once` implied by `-D warnings`
+
+error: manual implementation of `split_once`
+  --> $DIR/manual_split_once.rs:15:13
+   |
+LL |     let _ = "key=value".splitn(2, '=').next().unwrap();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `"key=value".split_once('=').map_or("key=value", |x| x.0)`
+
+error: manual implementation of `split_once`
+  --> $DIR/manual_split_once.rs:16:13
+   |
+LL |     let _ = "key=value".splitn(2, '=').nth(0).unwrap();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `"key=value".split_once('=').map_or("key=value", |x| x.0)`
+
+error: manual implementation of `split_once`
+  --> $DIR/manual_split_once.rs:17:13
+   |
+LL |     let _ = "key=value".splitn(2, '=').nth(1).unwrap();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `"key=value".split_once('=').unwrap().1`
+
+error: manual implementation of `split_once`
+  --> $DIR/manual_split_once.rs:18:13
+   |
+LL |     let _ = "key=value".splitn(2, '=').skip(1).next().unwrap();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `"key=value".split_once('=').unwrap().1`
+
+error: manual implementation of `split_once`
+  --> $DIR/manual_split_once.rs:19:18
+   |
+LL |     let (_, _) = "key=value".splitn(2, '=').next_tuple().unwrap();
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `"key=value".split_once('=')`
+
+error: manual implementation of `split_once`
+  --> $DIR/manual_split_once.rs:22:13
+   |
+LL |     let _ = s.splitn(2, '=').next().unwrap();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `s.split_once('=').map_or(&*s, |x| x.0)`
+
+error: manual implementation of `split_once`
+  --> $DIR/manual_split_once.rs:25:13
+   |
+LL |     let _ = s.splitn(2, '=').nth(0).unwrap();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `s.split_once('=').map_or(&*s, |x| x.0)`
+
+error: manual implementation of `split_once`
+  --> $DIR/manual_split_once.rs:28:13
+   |
+LL |     let _ = s.splitn(2, '=').skip(0).next().unwrap();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `s.split_once('=').map_or(*s, |x| x.0)`
+
+error: manual implementation of `split_once`
+  --> $DIR/manual_split_once.rs:31:17
+   |
+LL |         let _ = s.splitn(2, "key=value").next()?;
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `s.split_once("key=value").map_or(s, |x| x.0)`
+
+error: manual implementation of `split_once`
+  --> $DIR/manual_split_once.rs:32:17
+   |
+LL |         let _ = s.splitn(2, "key=value").nth(1)?;
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `s.split_once("key=value")?.1`
+
+error: manual implementation of `split_once`
+  --> $DIR/manual_split_once.rs:33:17
+   |
+LL |         let _ = s.splitn(2, "key=value").skip(1).next()?;
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `s.split_once("key=value")?.1`
+
+error: manual implementation of `split_once`
+  --> $DIR/manual_split_once.rs:49:13
+   |
+LL |     let _ = "key=value".splitn(2, '=').nth(1).unwrap();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `"key=value".split_once('=').unwrap().1`
+
+error: aborting due to 13 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From aab3267412bd23cae4fd58e860b6b9a36de42448 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sun, 15 Aug 2021 16:27:59 -0400
Subject: Update docs for `manual_split_once`

---
 clippy_lints/src/methods/mod.rs | 16 +++++++---------
 1 file changed, 7 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 15ad0325006..b6438bce874 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1774,24 +1774,22 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for usages of `splitn(2, _)`
+    /// **What it does:** Checks for usages of `str::splitn(2, _)`
     ///
-    /// **Why is this bad?** `split_once` is clearer.
+    /// **Why is this bad?** `split_once` is both clearer in intent and slightly more efficient.
     ///
     /// **Known problems:** None.
     ///
     /// **Example:**
     ///
-    /// ```rust
+    /// ```rust,ignore
     /// // Bad
-    /// let some_str = "name=value";
-    /// let mut iter = some_str.splitn(2, '=');
-    /// let name = iter.next().unwrap();
-    /// let value = iter.next().unwrap_or("");
+    ///  let (key, value) = _.splitn(2, '=').next_tuple()?;
+    ///  let value = _.splitn(2, '=').nth(1)?;
     ///
     /// // Good
-    /// let some_str = "name=value";
-    /// let (name, value) = some_str.split_once('=').unwrap_or((some_str, ""));
+    /// let (key, value) = _.split_once('=')?;
+    /// let value = _.split_once('=')?.1;
     /// ```
     pub MANUAL_SPLIT_ONCE,
     complexity,
-- 
cgit 1.4.1-3-g733a5


From 8b3ca9a315aeb9ece9ca9df27e69f581629c51aa Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Mon, 16 Aug 2021 15:42:52 -0400
Subject: Fix `option_if_let_else` * `break` and `continue` statments local to
 the would-be closure are allowed * don't lint in const contexts * don't lint
 when yield expressions are used * don't lint when the captures made by the
 would-be closure conflict with the other branch * don't lint when a field of
 a local is used when the type could be pontentially moved from * in some
 cases, don't lint when scrutinee expression conflicts with the captures of
 the would-be closure

---
 clippy_lints/src/option_if_let_else.rs | 53 +++++++++++++++++++++++++++-------
 clippy_utils/src/lib.rs                |  5 ++++
 tests/ui/option_if_let_else.fixed      | 42 +++++++++++++++++++++++++++
 tests/ui/option_if_let_else.rs         | 48 ++++++++++++++++++++++++++++++
 tests/ui/option_if_let_else.stderr     | 50 +++++++++++++++++++++++++++++++-
 5 files changed, 186 insertions(+), 12 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/option_if_let_else.rs b/clippy_lints/src/option_if_let_else.rs
index a7899dc8bc1..46f06362ccc 100644
--- a/clippy_lints/src/option_if_let_else.rs
+++ b/clippy_lints/src/option_if_let_else.rs
@@ -1,12 +1,16 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::usage::contains_return_break_continue_macro;
-use clippy_utils::{eager_or_lazy, in_macro, is_else_clause, is_lang_ctor};
+use clippy_utils::{
+    can_move_expr_to_closure, eager_or_lazy, in_constant, in_macro, is_else_clause, is_lang_ctor, peel_hir_expr_while,
+    CaptureKind,
+};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::LangItem::OptionSome;
-use rustc_hir::{Arm, BindingAnnotation, Block, Expr, ExprKind, MatchSource, Mutability, PatKind, UnOp};
+use rustc_hir::{
+    def::Res, Arm, BindingAnnotation, Block, Expr, ExprKind, MatchSource, Mutability, PatKind, Path, QPath, UnOp,
+};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::sym;
@@ -127,21 +131,30 @@ fn detect_option_if_let_else<'tcx>(
 ) -> Option<OptionIfLetElseOccurence> {
     if_chain! {
         if !in_macro(expr.span); // Don't lint macros, because it behaves weirdly
-        if let ExprKind::Match(cond_expr, arms, MatchSource::IfLetDesugar{contains_else_clause: true}) = &expr.kind;
+        if !in_constant(cx, expr.hir_id);
+        if let ExprKind::Match(cond_expr, [some_arm, none_arm], MatchSource::IfLetDesugar{contains_else_clause: true})
+            = &expr.kind;
         if !is_else_clause(cx.tcx, expr);
-        if arms.len() == 2;
         if !is_result_ok(cx, cond_expr); // Don't lint on Result::ok because a different lint does it already
-        if let PatKind::TupleStruct(struct_qpath, [inner_pat], _) = &arms[0].pat.kind;
+        if let PatKind::TupleStruct(struct_qpath, [inner_pat], _) = &some_arm.pat.kind;
         if is_lang_ctor(cx, struct_qpath, OptionSome);
         if let PatKind::Binding(bind_annotation, _, id, _) = &inner_pat.kind;
-        if !contains_return_break_continue_macro(arms[0].body);
-        if !contains_return_break_continue_macro(arms[1].body);
+        if let Some(some_captures) = can_move_expr_to_closure(cx, some_arm.body);
+        if let Some(none_captures) = can_move_expr_to_closure(cx, none_arm.body);
+        if some_captures
+            .iter()
+            .filter_map(|(id, &c)| none_captures.get(id).map(|&c2| (c, c2)))
+            .all(|(x, y)| x.is_imm_ref() && y.is_imm_ref());
 
         then {
             let capture_mut = if bind_annotation == &BindingAnnotation::Mutable { "mut " } else { "" };
-            let some_body = extract_body_from_arm(&arms[0])?;
-            let none_body = extract_body_from_arm(&arms[1])?;
-            let method_sugg = if eager_or_lazy::is_eagerness_candidate(cx, none_body) { "map_or" } else { "map_or_else" };
+            let some_body = extract_body_from_arm(some_arm)?;
+            let none_body = extract_body_from_arm(none_arm)?;
+            let method_sugg = if eager_or_lazy::is_eagerness_candidate(cx, none_body) {
+                "map_or"
+            } else {
+                "map_or_else"
+            };
             let capture_name = id.name.to_ident_string();
             let (as_ref, as_mut) = match &cond_expr.kind {
                 ExprKind::AddrOf(_, Mutability::Not, _) => (true, false),
@@ -153,6 +166,24 @@ fn detect_option_if_let_else<'tcx>(
                 ExprKind::Unary(UnOp::Deref, expr) | ExprKind::AddrOf(_, _, expr) => expr,
                 _ => cond_expr,
             };
+            // Check if captures the closure will need conflict with borrows made in the scrutinee.
+            // TODO: check all the references made in the scrutinee expression. This will require interacting
+            // with the borrow checker. Currently only `<local>[.<field>]*` is checked for.
+            if as_ref || as_mut {
+                let e = peel_hir_expr_while(cond_expr, |e| match e.kind {
+                    ExprKind::Field(e, _) | ExprKind::AddrOf(_, _, e) => Some(e),
+                    _ => None,
+                });
+                if let ExprKind::Path(QPath::Resolved(None, Path { res: Res::Local(l), .. })) = e.kind {
+                    match some_captures.get(l)
+                        .or_else(|| (method_sugg == "map_or_else").then(|| ()).and_then(|_| none_captures.get(l)))
+                    {
+                        Some(CaptureKind::Value | CaptureKind::Ref(Mutability::Mut)) => return None,
+                        Some(CaptureKind::Ref(Mutability::Not)) if as_mut => return None,
+                        Some(CaptureKind::Ref(Mutability::Not)) | None => (),
+                    }
+                }
+            }
             Some(OptionIfLetElseOccurence {
                 option: format_option_in_sugg(cx, cond_expr, as_ref, as_mut),
                 method_sugg: method_sugg.to_string(),
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index bd229402f41..bb7de165360 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -709,6 +709,11 @@ pub enum CaptureKind {
     Value,
     Ref(Mutability),
 }
+impl CaptureKind {
+    pub fn is_imm_ref(self) -> bool {
+        self == Self::Ref(Mutability::Not)
+    }
+}
 impl std::ops::BitOr for CaptureKind {
     type Output = Self;
     fn bitor(self, rhs: Self) -> Self::Output {
diff --git a/tests/ui/option_if_let_else.fixed b/tests/ui/option_if_let_else.fixed
index 769ccc14bc1..56e032cdb57 100644
--- a/tests/ui/option_if_let_else.fixed
+++ b/tests/ui/option_if_let_else.fixed
@@ -86,4 +86,46 @@ fn main() {
     test_map_or_else(None);
     let _ = negative_tests(None);
     let _ = impure_else(None);
+
+    let _ = Some(0).map_or(0, |x| loop {
+            if x == 0 {
+                break x;
+            }
+        });
+
+    // #7576
+    const fn _f(x: Option<u32>) -> u32 {
+        // Don't lint, `map_or` isn't const
+        if let Some(x) = x { x } else { 10 }
+    }
+
+    // #5822
+    let s = String::new();
+    // Don't lint, `Some` branch consumes `s`, but else branch uses `s`
+    let _ = if let Some(x) = Some(0) {
+        let s = s;
+        s.len() + x
+    } else {
+        s.len()
+    };
+
+    let s = String::new();
+    // Lint, both branches immutably borrow `s`.
+    let _ = Some(0).map_or_else(|| s.len(), |x| s.len() + x);
+
+    let s = String::new();
+    // Lint, `Some` branch consumes `s`, but else branch doesn't use `s`.
+    let _ = Some(0).map_or(1, |x| {
+        let s = s;
+        s.len() + x
+    });
+
+    let s = Some(String::new());
+    // Don't lint, `Some` branch borrows `s`, but else branch consumes `s`
+    let _ = if let Some(x) = &s {
+        x.len()
+    } else {
+        let _s = s;
+        10
+    };
 }
diff --git a/tests/ui/option_if_let_else.rs b/tests/ui/option_if_let_else.rs
index e2f8dec3b93..595ed8172cd 100644
--- a/tests/ui/option_if_let_else.rs
+++ b/tests/ui/option_if_let_else.rs
@@ -105,4 +105,52 @@ fn main() {
     test_map_or_else(None);
     let _ = negative_tests(None);
     let _ = impure_else(None);
+
+    let _ = if let Some(x) = Some(0) {
+        loop {
+            if x == 0 {
+                break x;
+            }
+        }
+    } else {
+        0
+    };
+
+    // #7576
+    const fn _f(x: Option<u32>) -> u32 {
+        // Don't lint, `map_or` isn't const
+        if let Some(x) = x { x } else { 10 }
+    }
+
+    // #5822
+    let s = String::new();
+    // Don't lint, `Some` branch consumes `s`, but else branch uses `s`
+    let _ = if let Some(x) = Some(0) {
+        let s = s;
+        s.len() + x
+    } else {
+        s.len()
+    };
+
+    let s = String::new();
+    // Lint, both branches immutably borrow `s`.
+    let _ = if let Some(x) = Some(0) { s.len() + x } else { s.len() };
+
+    let s = String::new();
+    // Lint, `Some` branch consumes `s`, but else branch doesn't use `s`.
+    let _ = if let Some(x) = Some(0) {
+        let s = s;
+        s.len() + x
+    } else {
+        1
+    };
+
+    let s = Some(String::new());
+    // Don't lint, `Some` branch borrows `s`, but else branch consumes `s`
+    let _ = if let Some(x) = &s {
+        x.len()
+    } else {
+        let _s = s;
+        10
+    };
 }
diff --git a/tests/ui/option_if_let_else.stderr b/tests/ui/option_if_let_else.stderr
index 099e49ef8e3..803d941c36d 100644
--- a/tests/ui/option_if_let_else.stderr
+++ b/tests/ui/option_if_let_else.stderr
@@ -148,5 +148,53 @@ error: use Option::map_or instead of an if let/else
 LL |     let _ = if let Some(x) = optional { x + 2 } else { 5 };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `optional.map_or(5, |x| x + 2)`
 
-error: aborting due to 11 previous errors
+error: use Option::map_or instead of an if let/else
+  --> $DIR/option_if_let_else.rs:109:13
+   |
+LL |       let _ = if let Some(x) = Some(0) {
+   |  _____________^
+LL | |         loop {
+LL | |             if x == 0 {
+LL | |                 break x;
+...  |
+LL | |         0
+LL | |     };
+   | |_____^
+   |
+help: try
+   |
+LL ~     let _ = Some(0).map_or(0, |x| loop {
+LL +             if x == 0 {
+LL +                 break x;
+LL +             }
+LL ~         });
+   |
+
+error: use Option::map_or_else instead of an if let/else
+  --> $DIR/option_if_let_else.rs:137:13
+   |
+LL |     let _ = if let Some(x) = Some(0) { s.len() + x } else { s.len() };
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Some(0).map_or_else(|| s.len(), |x| s.len() + x)`
+
+error: use Option::map_or instead of an if let/else
+  --> $DIR/option_if_let_else.rs:141:13
+   |
+LL |       let _ = if let Some(x) = Some(0) {
+   |  _____________^
+LL | |         let s = s;
+LL | |         s.len() + x
+LL | |     } else {
+LL | |         1
+LL | |     };
+   | |_____^
+   |
+help: try
+   |
+LL ~     let _ = Some(0).map_or(1, |x| {
+LL +         let s = s;
+LL +         s.len() + x
+LL ~     });
+   |
+
+error: aborting due to 14 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 3c6c7d5de9cf989b19e82298735486a03eac4b75 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Mon, 16 Aug 2021 19:57:14 -0400
Subject: Update docs for `expl_impl_clone_on_copy`. Bug was fixed in
 879fa5c9721c89c27be6a9db5f51d935a51f549b1~

---
 clippy_lints/src/derive.rs | 3 ---
 1 file changed, 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/derive.rs b/clippy_lints/src/derive.rs
index dcfa5253f83..8416b8440df 100644
--- a/clippy_lints/src/derive.rs
+++ b/clippy_lints/src/derive.rs
@@ -105,9 +105,6 @@ declare_clippy_lint! {
     /// nothing more than copy the object, which is what `#[derive(Copy, Clone)]`
     /// gets you.
     ///
-    /// ### Known problems
-    /// Bounds of generic types are sometimes wrong: https://github.com/rust-lang/rust/issues/26925
-    ///
     /// ### Example
     /// ```rust,ignore
     /// #[derive(Copy)]
-- 
cgit 1.4.1-3-g733a5


From c01aa64591df67b4f4b44c1c946ed56790f83580 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Tue, 17 Aug 2021 14:51:56 +0200
Subject: Small documentation update for the new metadata_collector

---
 clippy_lints/src/utils/conf.rs                              | 4 ----
 clippy_lints/src/utils/internal_lints/metadata_collector.rs | 2 +-
 doc/adding_lints.md                                         | 7 ++++---
 3 files changed, 5 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 9ee2e302452..ad341fbbda9 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -31,9 +31,6 @@ impl TryConf {
     }
 }
 
-/// Note that the configuration parsing currently doesn't support documentation that will
-/// that spans over several lines. This will be possible with the new implementation
-/// See (rust-clippy#7172)
 macro_rules! define_Conf {
     ($(
         $(#[doc = $doc:literal])+
@@ -130,7 +127,6 @@ macro_rules! define_Conf {
     };
 }
 
-// N.B., this macro is parsed by util/lintlib.py
 define_Conf! {
     /// Lint: ENUM_VARIANT_NAMES, LARGE_TYPES_PASSED_BY_VALUE, TRIVIALLY_COPY_PASS_BY_REF, UNNECESSARY_WRAPS, UPPER_CASE_ACRONYMS, WRONG_SELF_CONVENTION, BOX_VEC, REDUNDANT_ALLOCATION, RC_BUFFER, VEC_BOX, OPTION_OPTION, LINKEDLIST, RC_MUTEX.
     ///
diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index a48a5385083..91533695eb3 100644
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -82,7 +82,7 @@ This lint has the following configuration variables:
 /// `default`
 macro_rules! CONFIGURATION_VALUE_TEMPLATE {
     () => {
-        "* {name}: `{ty}`: {doc} (defaults to `{default}`)\n"
+        "* `{name}`: `{ty}`: {doc} (defaults to `{default}`)\n"
     };
 }
 
diff --git a/doc/adding_lints.md b/doc/adding_lints.md
index f2260c3d1a2..392b70ee3a9 100644
--- a/doc/adding_lints.md
+++ b/doc/adding_lints.md
@@ -559,11 +559,12 @@ in the following steps:
 1. Adding a new configuration entry to [clippy_utils::conf](/clippy_utils/src/conf.rs)
     like this:
     ```rust
-    /// Lint: LINT_NAME. <The configuration field doc comment>
+    /// Lint: LINT_NAME.
+    ///
+    /// <The configuration field doc comment>
     (configuration_ident: Type = DefaultValue),
     ```
-    The configuration value and identifier should usually be the same. The doc comment will be
-    automatically added to the lint documentation.
+    The doc comment will be automatically added to the lint documentation.
 2. Adding the configuration value to the lint impl struct:
     1. This first requires the definition of a lint impl struct. Lint impl structs are usually
         generated with the `declare_lint_pass!` macro. This struct needs to be defined manually
-- 
cgit 1.4.1-3-g733a5


From 0a021d5900a9ee55875fb247614a0671b71d3271 Mon Sep 17 00:00:00 2001
From: Labelray <labelray@icloud.com>
Date: Fri, 6 Aug 2021 22:46:20 +0800
Subject: Add new lints `negative_feature_names` and `redundant_feature_names`

---
 CHANGELOG.md                                       |   2 +
 clippy_lints/src/feature_name.rs                   | 164 +++++++++++++++++++++
 clippy_lints/src/lib.rs                            |   6 +
 tests/ui-cargo/feature_name/fail/Cargo.toml        |  21 +++
 tests/ui-cargo/feature_name/fail/src/main.rs       |   7 +
 tests/ui-cargo/feature_name/fail/src/main.stderr   |  44 ++++++
 tests/ui-cargo/feature_name/pass/Cargo.toml        |   9 ++
 tests/ui-cargo/feature_name/pass/src/main.rs       |   7 +
 tests/ui/missing-doc-crate.stderr                  |   0
 tests/ui/missing_const_for_fn/cant_be_const.stderr |   0
 tests/ui/rc_buffer_redefined_string.stderr         |   0
 11 files changed, 260 insertions(+)
 create mode 100644 clippy_lints/src/feature_name.rs
 create mode 100644 tests/ui-cargo/feature_name/fail/Cargo.toml
 create mode 100644 tests/ui-cargo/feature_name/fail/src/main.rs
 create mode 100644 tests/ui-cargo/feature_name/fail/src/main.stderr
 create mode 100644 tests/ui-cargo/feature_name/pass/Cargo.toml
 create mode 100644 tests/ui-cargo/feature_name/pass/src/main.rs
 delete mode 100644 tests/ui/missing-doc-crate.stderr
 delete mode 100644 tests/ui/missing_const_for_fn/cant_be_const.stderr
 delete mode 100644 tests/ui/rc_buffer_redefined_string.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index ac745793dda..1c182c05f50 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2828,6 +2828,7 @@ Released 2018-09-13
 [`needless_update`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_update
 [`neg_cmp_op_on_partial_ord`]: https://rust-lang.github.io/rust-clippy/master/index.html#neg_cmp_op_on_partial_ord
 [`neg_multiply`]: https://rust-lang.github.io/rust-clippy/master/index.html#neg_multiply
+[`negative_feature_names`]: https://rust-lang.github.io/rust-clippy/master/index.html#negative_feature_names
 [`never_loop`]: https://rust-lang.github.io/rust-clippy/master/index.html#never_loop
 [`new_ret_no_self`]: https://rust-lang.github.io/rust-clippy/master/index.html#new_ret_no_self
 [`new_without_default`]: https://rust-lang.github.io/rust-clippy/master/index.html#new_without_default
@@ -2881,6 +2882,7 @@ Released 2018-09-13
 [`redundant_closure_call`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_closure_call
 [`redundant_closure_for_method_calls`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_closure_for_method_calls
 [`redundant_else`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_else
+[`redundant_feature_names`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_feature_names
 [`redundant_field_names`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_field_names
 [`redundant_pattern`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_pattern
 [`redundant_pattern_matching`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_pattern_matching
diff --git a/clippy_lints/src/feature_name.rs b/clippy_lints/src/feature_name.rs
new file mode 100644
index 00000000000..eef1407a80c
--- /dev/null
+++ b/clippy_lints/src/feature_name.rs
@@ -0,0 +1,164 @@
+use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::{diagnostics::span_lint, is_lint_allowed};
+use rustc_hir::{Crate, CRATE_HIR_ID};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::source_map::DUMMY_SP;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for feature names with prefix `use-`, `with-` or suffix `-support`
+    ///
+    /// ### Why is this bad?
+    /// These prefixes and suffixes have no significant meaning.
+    ///
+    /// ### Example
+    /// ```toml
+    /// # The `Cargo.toml` with feature name redundancy
+    /// [features]
+    /// default = ["use-abc", "with-def", "ghi-support"]
+    /// use-abc = []  // redundant
+    /// with-def = []   // redundant
+    /// ghi-support = []   // redundant
+    /// ```
+    ///
+    /// Use instead:
+    /// ```toml
+    /// [features]
+    /// default = ["abc", "def", "ghi"]
+    /// abc = []
+    /// def = []
+    /// ghi = []
+    /// ```
+    ///
+    pub REDUNDANT_FEATURE_NAMES,
+    cargo,
+    "usage of a redundant feature name"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for negative feature names with prefix `no-` or `not-`
+    ///
+    /// ### Why is this bad?
+    /// Features are supposed to be additive, and negatively-named features violate it.
+    ///
+    /// ### Example
+    /// ```toml
+    /// # The `Cargo.toml` with negative feature names
+    /// [features]
+    /// default = []
+    /// no-abc = []
+    /// not-def = []
+    ///
+    /// ```
+    /// Use instead:
+    /// ```toml
+    /// [features]
+    /// default = ["abc", "def"]
+    /// abc = []
+    /// def = []
+    ///
+    /// ```
+    pub NEGATIVE_FEATURE_NAMES,
+    cargo,
+    "usage of a negative feature name"
+}
+
+declare_lint_pass!(FeatureName => [REDUNDANT_FEATURE_NAMES, NEGATIVE_FEATURE_NAMES]);
+
+static PREFIXES: [&str; 8] = ["no-", "no_", "not-", "not_", "use-", "use_", "with-", "with_"];
+static SUFFIXES: [&str; 2] = ["-support", "_support"];
+
+fn is_negative_prefix(s: &str) -> bool {
+    s.starts_with("no")
+}
+
+fn lint(cx: &LateContext<'_>, feature: &str, substring: &str, is_prefix: bool) {
+    let is_negative = is_prefix && is_negative_prefix(substring);
+    span_lint_and_help(
+        cx,
+        if is_negative {
+            NEGATIVE_FEATURE_NAMES
+        } else {
+            REDUNDANT_FEATURE_NAMES
+        },
+        DUMMY_SP,
+        &format!(
+            "the \"{}\" {} in the feature name \"{}\" is {}",
+            substring,
+            if is_prefix { "prefix" } else { "suffix" },
+            feature,
+            if is_negative { "negative" } else { "redundant" }
+        ),
+        None,
+        &format!(
+            "consider renaming the feature to \"{}\"{}",
+            if is_prefix {
+                feature.strip_prefix(substring)
+            } else {
+                feature.strip_suffix(substring)
+            }
+            .unwrap(),
+            if is_negative {
+                ", but make sure the feature adds functionality"
+            } else {
+                ""
+            }
+        ),
+    );
+}
+
+impl LateLintPass<'_> for FeatureName {
+    fn check_crate(&mut self, cx: &LateContext<'_>, _: &Crate<'_>) {
+        if is_lint_allowed(cx, REDUNDANT_FEATURE_NAMES, CRATE_HIR_ID)
+            && is_lint_allowed(cx, NEGATIVE_FEATURE_NAMES, CRATE_HIR_ID)
+        {
+            return;
+        }
+
+        let metadata = unwrap_cargo_metadata!(cx, REDUNDANT_FEATURE_NAMES, false);
+
+        for package in metadata.packages {
+            let mut features: Vec<&String> = package.features.keys().collect();
+            features.sort();
+            for feature in features {
+                let prefix_opt = {
+                    let i = PREFIXES.partition_point(|prefix| prefix < &feature.as_str());
+                    if i > 0 && feature.starts_with(PREFIXES[i - 1]) {
+                        Some(PREFIXES[i - 1])
+                    } else {
+                        None
+                    }
+                };
+                if let Some(prefix) = prefix_opt {
+                    lint(cx, feature, prefix, true);
+                }
+
+                let suffix_opt: Option<&str> = {
+                    let i = SUFFIXES.partition_point(|suffix| {
+                        suffix.bytes().rev().cmp(feature.bytes().rev()) == std::cmp::Ordering::Less
+                    });
+                    if i > 0 && feature.ends_with(SUFFIXES[i - 1]) {
+                        Some(SUFFIXES[i - 1])
+                    } else {
+                        None
+                    }
+                };
+                if let Some(suffix) = suffix_opt {
+                    lint(cx, feature, suffix, false);
+                }
+            }
+        }
+    }
+}
+
+#[test]
+fn test_prefixes_sorted() {
+    let mut sorted_prefixes = PREFIXES;
+    sorted_prefixes.sort_unstable();
+    assert_eq!(PREFIXES, sorted_prefixes);
+    let mut sorted_suffixes = SUFFIXES;
+    sorted_suffixes.sort_by(|a, b| a.bytes().rev().cmp(b.bytes().rev()));
+    assert_eq!(SUFFIXES, sorted_suffixes);
+}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index f49b382c5ea..ce671be069a 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -213,6 +213,7 @@ mod exhaustive_items;
 mod exit;
 mod explicit_write;
 mod fallible_impl_from;
+mod feature_name;
 mod float_equality_without_abs;
 mod float_literal;
 mod floating_point_arithmetic;
@@ -628,6 +629,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         exit::EXIT,
         explicit_write::EXPLICIT_WRITE,
         fallible_impl_from::FALLIBLE_IMPL_FROM,
+        feature_name::NEGATIVE_FEATURE_NAMES,
+        feature_name::REDUNDANT_FEATURE_NAMES,
         float_equality_without_abs::FLOAT_EQUALITY_WITHOUT_ABS,
         float_literal::EXCESSIVE_PRECISION,
         float_literal::LOSSY_FLOAT_LITERAL,
@@ -1781,6 +1784,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
 
     store.register_group(true, "clippy::cargo", Some("clippy_cargo"), vec![
         LintId::of(cargo_common_metadata::CARGO_COMMON_METADATA),
+        LintId::of(feature_name::NEGATIVE_FEATURE_NAMES),
+        LintId::of(feature_name::REDUNDANT_FEATURE_NAMES),
         LintId::of(multiple_crate_versions::MULTIPLE_CRATE_VERSIONS),
         LintId::of(wildcard_dependencies::WILDCARD_DEPENDENCIES),
     ]);
@@ -2105,6 +2110,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_early_pass(move || box disallowed_script_idents::DisallowedScriptIdents::new(&scripts));
     store.register_late_pass(|| box strlen_on_c_strings::StrlenOnCStrings);
     store.register_late_pass(move || box self_named_constructors::SelfNamedConstructors);
+    store.register_late_pass(move || box feature_name::FeatureName);
 }
 
 #[rustfmt::skip]
diff --git a/tests/ui-cargo/feature_name/fail/Cargo.toml b/tests/ui-cargo/feature_name/fail/Cargo.toml
new file mode 100644
index 00000000000..97d51462a94
--- /dev/null
+++ b/tests/ui-cargo/feature_name/fail/Cargo.toml
@@ -0,0 +1,21 @@
+
+# Content that triggers the lint goes here
+
+[package]
+name = "feature_name"
+version = "0.1.0"
+publish = false
+
+[workspace]
+
+[features]
+use-qwq = []
+use_qwq = []
+with-owo = []
+with_owo = []
+qvq-support = []
+qvq_support = []
+no-qaq = []
+no_qaq = []
+not-orz = []
+not_orz = []
diff --git a/tests/ui-cargo/feature_name/fail/src/main.rs b/tests/ui-cargo/feature_name/fail/src/main.rs
new file mode 100644
index 00000000000..64f01a98c90
--- /dev/null
+++ b/tests/ui-cargo/feature_name/fail/src/main.rs
@@ -0,0 +1,7 @@
+// compile-flags: --crate-name=feature_name
+#![warn(clippy::redundant_feature_names)]
+#![warn(clippy::negative_feature_names)]
+
+fn main() {
+    // test code goes here
+}
diff --git a/tests/ui-cargo/feature_name/fail/src/main.stderr b/tests/ui-cargo/feature_name/fail/src/main.stderr
new file mode 100644
index 00000000000..b9e6cb49bc9
--- /dev/null
+++ b/tests/ui-cargo/feature_name/fail/src/main.stderr
@@ -0,0 +1,44 @@
+error: the "no-" prefix in the feature name "no-qaq" is negative
+   |
+   = note: `-D clippy::negative-feature-names` implied by `-D warnings`
+   = help: consider renaming the feature to "qaq", but make sure the feature adds functionality
+
+error: the "no_" prefix in the feature name "no_qaq" is negative
+   |
+   = help: consider renaming the feature to "qaq", but make sure the feature adds functionality
+
+error: the "not-" prefix in the feature name "not-orz" is negative
+   |
+   = help: consider renaming the feature to "orz", but make sure the feature adds functionality
+
+error: the "not_" prefix in the feature name "not_orz" is negative
+   |
+   = help: consider renaming the feature to "orz", but make sure the feature adds functionality
+
+error: the "-support" suffix in the feature name "qvq-support" is redundant
+   |
+   = note: `-D clippy::redundant-feature-names` implied by `-D warnings`
+   = help: consider renaming the feature to "qvq"
+
+error: the "_support" suffix in the feature name "qvq_support" is redundant
+   |
+   = help: consider renaming the feature to "qvq"
+
+error: the "use-" prefix in the feature name "use-qwq" is redundant
+   |
+   = help: consider renaming the feature to "qwq"
+
+error: the "use_" prefix in the feature name "use_qwq" is redundant
+   |
+   = help: consider renaming the feature to "qwq"
+
+error: the "with-" prefix in the feature name "with-owo" is redundant
+   |
+   = help: consider renaming the feature to "owo"
+
+error: the "with_" prefix in the feature name "with_owo" is redundant
+   |
+   = help: consider renaming the feature to "owo"
+
+error: aborting due to 10 previous errors
+
diff --git a/tests/ui-cargo/feature_name/pass/Cargo.toml b/tests/ui-cargo/feature_name/pass/Cargo.toml
new file mode 100644
index 00000000000..cf947312bd4
--- /dev/null
+++ b/tests/ui-cargo/feature_name/pass/Cargo.toml
@@ -0,0 +1,9 @@
+
+# This file should not trigger the lint
+
+[package]
+name = "feature_name"
+version = "0.1.0"
+publish = false
+
+[workspace]
diff --git a/tests/ui-cargo/feature_name/pass/src/main.rs b/tests/ui-cargo/feature_name/pass/src/main.rs
new file mode 100644
index 00000000000..64f01a98c90
--- /dev/null
+++ b/tests/ui-cargo/feature_name/pass/src/main.rs
@@ -0,0 +1,7 @@
+// compile-flags: --crate-name=feature_name
+#![warn(clippy::redundant_feature_names)]
+#![warn(clippy::negative_feature_names)]
+
+fn main() {
+    // test code goes here
+}
diff --git a/tests/ui/missing-doc-crate.stderr b/tests/ui/missing-doc-crate.stderr
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/tests/ui/missing_const_for_fn/cant_be_const.stderr b/tests/ui/missing_const_for_fn/cant_be_const.stderr
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/tests/ui/rc_buffer_redefined_string.stderr b/tests/ui/rc_buffer_redefined_string.stderr
deleted file mode 100644
index e69de29bb2d..00000000000
-- 
cgit 1.4.1-3-g733a5


From 2f73776525cfe7a47e4550ce640b5565ddd9315c Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Mon, 23 Aug 2021 13:39:36 -0500
Subject: Move branches_sharing_code to nursery

---
 clippy_lints/src/copies.rs | 2 +-
 clippy_lints/src/lib.rs    | 3 +--
 2 files changed, 2 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/copies.rs b/clippy_lints/src/copies.rs
index 2dcd5545799..29f3c911a30 100644
--- a/clippy_lints/src/copies.rs
+++ b/clippy_lints/src/copies.rs
@@ -148,7 +148,7 @@ declare_clippy_lint! {
     /// };
     /// ```
     pub BRANCHES_SHARING_CODE,
-    complexity,
+    nursery,
     "`if` statement with shared code in all blocks"
 }
 
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index c98803adbed..30c684dc744 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1200,7 +1200,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(collapsible_if::COLLAPSIBLE_IF),
         LintId::of(collapsible_match::COLLAPSIBLE_MATCH),
         LintId::of(comparison_chain::COMPARISON_CHAIN),
-        LintId::of(copies::BRANCHES_SHARING_CODE),
         LintId::of(copies::IFS_SAME_COND),
         LintId::of(copies::IF_SAME_THEN_ELSE),
         LintId::of(default::FIELD_REASSIGN_WITH_DEFAULT),
@@ -1589,7 +1588,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(booleans::NONMINIMAL_BOOL),
         LintId::of(casts::CHAR_LIT_AS_U8),
         LintId::of(casts::UNNECESSARY_CAST),
-        LintId::of(copies::BRANCHES_SHARING_CODE),
         LintId::of(double_comparison::DOUBLE_COMPARISONS),
         LintId::of(double_parens::DOUBLE_PARENS),
         LintId::of(duration_subsec::DURATION_SUBSEC),
@@ -1798,6 +1796,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_group(true, "clippy::nursery", Some("clippy_nursery"), vec![
         LintId::of(attrs::EMPTY_LINE_AFTER_OUTER_ATTR),
         LintId::of(cognitive_complexity::COGNITIVE_COMPLEXITY),
+        LintId::of(copies::BRANCHES_SHARING_CODE),
         LintId::of(disallowed_method::DISALLOWED_METHOD),
         LintId::of(disallowed_type::DISALLOWED_TYPE),
         LintId::of(fallible_impl_from::FALLIBLE_IMPL_FROM),
-- 
cgit 1.4.1-3-g733a5


From 641be558fcdbddbabc1b6af841c05b61dbdd9d5f Mon Sep 17 00:00:00 2001
From: lengyijun <sjtu5140809011@gmail.com>
Date: Sun, 22 Aug 2021 15:22:28 +0800
Subject: redundant_allocation: fix 7487

---
 clippy_lints/src/types/redundant_allocation.rs |  8 +++++++-
 tests/ui/redundant_allocation.rs               | 20 ++++++++++++++++++++
 tests/ui/redundant_allocation.stderr           | 11 ++++++++++-
 3 files changed, 37 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types/redundant_allocation.rs b/clippy_lints/src/types/redundant_allocation.rs
index 8e83dcbf704..ac7bdd6a1eb 100644
--- a/clippy_lints/src/types/redundant_allocation.rs
+++ b/clippy_lints/src/types/redundant_allocation.rs
@@ -54,7 +54,13 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_
         _ => return false,
     };
     let inner_span = match get_qpath_generic_tys(inner_qpath).next() {
-        Some(ty) => ty.span,
+        Some(ty) => {
+            // Box<Box<dyn T>> is smaller than Box<dyn T> because of wide pointers
+            if matches!(ty.kind, TyKind::TraitObject(..)) {
+                return false;
+            }
+            ty.span
+        },
         None => return false,
     };
     if inner_sym == outer_sym {
diff --git a/tests/ui/redundant_allocation.rs b/tests/ui/redundant_allocation.rs
index 1b4f2a66c70..52fbc91e325 100644
--- a/tests/ui/redundant_allocation.rs
+++ b/tests/ui/redundant_allocation.rs
@@ -77,4 +77,24 @@ mod outer_arc {
     }
 }
 
+// https://github.com/rust-lang/rust-clippy/issues/7487
+mod box_dyn {
+    use std::boxed::Box;
+    use std::rc::Rc;
+    use std::sync::Arc;
+
+    pub trait T {}
+
+    struct S {
+        a: Box<Box<dyn T>>,
+        b: Rc<Box<dyn T>>,
+        c: Arc<Box<dyn T>>,
+    }
+
+    pub fn test_box(_: Box<Box<dyn T>>) {}
+    pub fn test_rc(_: Rc<Box<dyn T>>) {}
+    pub fn test_arc(_: Arc<Box<dyn T>>) {}
+    pub fn test_rc_box(_: Rc<Box<Box<dyn T>>>) {}
+}
+
 fn main() {}
diff --git a/tests/ui/redundant_allocation.stderr b/tests/ui/redundant_allocation.stderr
index fdab74eb538..c3b10e5f5e6 100644
--- a/tests/ui/redundant_allocation.stderr
+++ b/tests/ui/redundant_allocation.stderr
@@ -134,5 +134,14 @@ LL |     pub fn arc_test9<T>(foo: Arc<Rc<T>>) -> Arc<Rc<SubT<T>>> {
    = note: `Rc<SubT<T>>` is already on the heap, `Arc<Rc<SubT<T>>>` makes an extra allocation
    = help: consider using just `Arc<SubT<T>>` or `Rc<SubT<T>>`
 
-error: aborting due to 15 previous errors
+error: usage of `Rc<Box<Box<dyn T>>>`
+  --> $DIR/redundant_allocation.rs:97:27
+   |
+LL |     pub fn test_rc_box(_: Rc<Box<Box<dyn T>>>) {}
+   |                           ^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `Box<Box<dyn T>>` is already on the heap, `Rc<Box<Box<dyn T>>>` makes an extra allocation
+   = help: consider using just `Rc<Box<dyn T>>` or `Box<Box<dyn T>>`
+
+error: aborting due to 16 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 31738b1da3e4033ff7898ffc869e96d7faba1775 Mon Sep 17 00:00:00 2001
From: Devin Ragotzy <devin.ragotzy@gmail.com>
Date: Fri, 30 Jul 2021 17:28:44 -0400
Subject: Add module_style lint to restriction

Add tests for disallowed_mod in ui-cargo test section

Use correct algorithm to determine if mod.rs is missing

Move to two lints and remove config option

Switch lint names so they read "warn on ..."

Emit the same help info for self_named_mod_file warnings

Bail when both lints are Allow

Reword help message for both module_style lints
---
 CHANGELOG.md                                       |   2 +
 clippy_lints/src/lib.rs                            |   6 +
 clippy_lints/src/module_style.rs                   | 178 +++++++++++++++++++++
 tests/ui-cargo/module_style/fail_mod/Cargo.toml    |   8 +
 .../module_style/fail_mod/src/bad/inner.rs         |   1 +
 .../module_style/fail_mod/src/bad/inner/stuff.rs   |   3 +
 .../fail_mod/src/bad/inner/stuff/most.rs           |   1 +
 .../ui-cargo/module_style/fail_mod/src/bad/mod.rs  |   3 +
 tests/ui-cargo/module_style/fail_mod/src/main.rs   |   9 ++
 .../ui-cargo/module_style/fail_mod/src/main.stderr |  19 +++
 tests/ui-cargo/module_style/fail_no_mod/Cargo.toml |   8 +
 .../module_style/fail_no_mod/src/bad/mod.rs        |   1 +
 .../ui-cargo/module_style/fail_no_mod/src/main.rs  |   7 +
 .../module_style/fail_no_mod/src/main.stderr       |  11 ++
 tests/ui-cargo/module_style/pass_mod/Cargo.toml    |   8 +
 .../ui-cargo/module_style/pass_mod/src/bad/mod.rs  |   1 +
 tests/ui-cargo/module_style/pass_mod/src/main.rs   |  10 ++
 .../ui-cargo/module_style/pass_mod/src/more/foo.rs |   1 +
 .../module_style/pass_mod/src/more/inner/mod.rs    |   1 +
 .../ui-cargo/module_style/pass_mod/src/more/mod.rs |   2 +
 tests/ui-cargo/module_style/pass_no_mod/Cargo.toml |   8 +
 .../ui-cargo/module_style/pass_no_mod/src/good.rs  |   1 +
 .../ui-cargo/module_style/pass_no_mod/src/main.rs  |   7 +
 23 files changed, 296 insertions(+)
 create mode 100644 clippy_lints/src/module_style.rs
 create mode 100644 tests/ui-cargo/module_style/fail_mod/Cargo.toml
 create mode 100644 tests/ui-cargo/module_style/fail_mod/src/bad/inner.rs
 create mode 100644 tests/ui-cargo/module_style/fail_mod/src/bad/inner/stuff.rs
 create mode 100644 tests/ui-cargo/module_style/fail_mod/src/bad/inner/stuff/most.rs
 create mode 100644 tests/ui-cargo/module_style/fail_mod/src/bad/mod.rs
 create mode 100644 tests/ui-cargo/module_style/fail_mod/src/main.rs
 create mode 100644 tests/ui-cargo/module_style/fail_mod/src/main.stderr
 create mode 100644 tests/ui-cargo/module_style/fail_no_mod/Cargo.toml
 create mode 100644 tests/ui-cargo/module_style/fail_no_mod/src/bad/mod.rs
 create mode 100644 tests/ui-cargo/module_style/fail_no_mod/src/main.rs
 create mode 100644 tests/ui-cargo/module_style/fail_no_mod/src/main.stderr
 create mode 100644 tests/ui-cargo/module_style/pass_mod/Cargo.toml
 create mode 100644 tests/ui-cargo/module_style/pass_mod/src/bad/mod.rs
 create mode 100644 tests/ui-cargo/module_style/pass_mod/src/main.rs
 create mode 100644 tests/ui-cargo/module_style/pass_mod/src/more/foo.rs
 create mode 100644 tests/ui-cargo/module_style/pass_mod/src/more/inner/mod.rs
 create mode 100644 tests/ui-cargo/module_style/pass_mod/src/more/mod.rs
 create mode 100644 tests/ui-cargo/module_style/pass_no_mod/Cargo.toml
 create mode 100644 tests/ui-cargo/module_style/pass_no_mod/src/good.rs
 create mode 100644 tests/ui-cargo/module_style/pass_no_mod/src/main.rs

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index b9e67d361c0..4bbc1233902 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2796,6 +2796,7 @@ Released 2018-09-13
 [`missing_safety_doc`]: https://rust-lang.github.io/rust-clippy/master/index.html#missing_safety_doc
 [`mistyped_literal_suffixes`]: https://rust-lang.github.io/rust-clippy/master/index.html#mistyped_literal_suffixes
 [`mixed_case_hex_literals`]: https://rust-lang.github.io/rust-clippy/master/index.html#mixed_case_hex_literals
+[`mod_module_files`]: https://rust-lang.github.io/rust-clippy/master/index.html#mod_module_files
 [`module_inception`]: https://rust-lang.github.io/rust-clippy/master/index.html#module_inception
 [`module_name_repetitions`]: https://rust-lang.github.io/rust-clippy/master/index.html#module_name_repetitions
 [`modulo_arithmetic`]: https://rust-lang.github.io/rust-clippy/master/index.html#modulo_arithmetic
@@ -2904,6 +2905,7 @@ Released 2018-09-13
 [`search_is_some`]: https://rust-lang.github.io/rust-clippy/master/index.html#search_is_some
 [`self_assignment`]: https://rust-lang.github.io/rust-clippy/master/index.html#self_assignment
 [`self_named_constructors`]: https://rust-lang.github.io/rust-clippy/master/index.html#self_named_constructors
+[`self_named_module_files`]: https://rust-lang.github.io/rust-clippy/master/index.html#self_named_module_files
 [`semicolon_if_nothing_returned`]: https://rust-lang.github.io/rust-clippy/master/index.html#semicolon_if_nothing_returned
 [`serde_api_misuse`]: https://rust-lang.github.io/rust-clippy/master/index.html#serde_api_misuse
 [`shadow_reuse`]: https://rust-lang.github.io/rust-clippy/master/index.html#shadow_reuse
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 1fadaf4770a..82178701176 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -274,6 +274,7 @@ mod missing_const_for_fn;
 mod missing_doc;
 mod missing_enforced_import_rename;
 mod missing_inline;
+mod module_style;
 mod modulo_arithmetic;
 mod multiple_crate_versions;
 mod mut_key;
@@ -826,6 +827,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         missing_doc::MISSING_DOCS_IN_PRIVATE_ITEMS,
         missing_enforced_import_rename::MISSING_ENFORCED_IMPORT_RENAMES,
         missing_inline::MISSING_INLINE_IN_PUBLIC_ITEMS,
+        module_style::MOD_MODULE_FILES,
+        module_style::SELF_NAMED_MODULE_FILES,
         modulo_arithmetic::MODULO_ARITHMETIC,
         multiple_crate_versions::MULTIPLE_CRATE_VERSIONS,
         mut_key::MUTABLE_KEY_TYPE,
@@ -1035,6 +1038,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(missing_doc::MISSING_DOCS_IN_PRIVATE_ITEMS),
         LintId::of(missing_enforced_import_rename::MISSING_ENFORCED_IMPORT_RENAMES),
         LintId::of(missing_inline::MISSING_INLINE_IN_PUBLIC_ITEMS),
+        LintId::of(module_style::MOD_MODULE_FILES),
+        LintId::of(module_style::SELF_NAMED_MODULE_FILES),
         LintId::of(modulo_arithmetic::MODULO_ARITHMETIC),
         LintId::of(panic_in_result_fn::PANIC_IN_RESULT_FN),
         LintId::of(panic_unimplemented::PANIC),
@@ -2107,6 +2112,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box manual_map::ManualMap);
     store.register_late_pass(move || box if_then_some_else_none::IfThenSomeElseNone::new(msrv));
     store.register_early_pass(|| box bool_assert_comparison::BoolAssertComparison);
+    store.register_early_pass(move || box module_style::ModStyle);
     store.register_late_pass(|| box unused_async::UnusedAsync);
     let disallowed_types = conf.disallowed_types.iter().cloned().collect::<FxHashSet<_>>();
     store.register_late_pass(move || box disallowed_type::DisallowedType::new(&disallowed_types));
diff --git a/clippy_lints/src/module_style.rs b/clippy_lints/src/module_style.rs
new file mode 100644
index 00000000000..73e93cf5a3e
--- /dev/null
+++ b/clippy_lints/src/module_style.rs
@@ -0,0 +1,178 @@
+use std::{
+    ffi::OsString,
+    path::{Component, Path},
+};
+
+use rustc_ast::ast;
+use rustc_data_structures::fx::{FxHashMap, FxHashSet};
+use rustc_lint::{EarlyContext, EarlyLintPass, Level, LintContext};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::{FileName, RealFileName, SourceFile, Span, SyntaxContext};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks that module layout uses only self named module files, bans mod.rs files.
+    ///
+    /// ### Why is this bad?
+    /// Having multiple module layout styles in a project can be confusing.
+    ///
+    /// ### Example
+    /// ```text
+    /// src/
+    ///   stuff/
+    ///     stuff_files.rs
+    ///     mod.rs
+    ///   lib.rs
+    /// ```
+    /// Use instead:
+    /// ```text
+    /// src/
+    ///   stuff/
+    ///     stuff_files.rs
+    ///   stuff.rs
+    ///   lib.rs
+    /// ```
+    pub MOD_MODULE_FILES,
+    restriction,
+    "checks that module layout is consistent"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks that module layout uses only mod.rs files.
+    ///
+    /// ### Why is this bad?
+    /// Having multiple module layout styles in a project can be confusing.
+    ///
+    /// ### Example
+    /// ```text
+    /// src/
+    ///   stuff/
+    ///     stuff_files.rs
+    ///   stuff.rs
+    ///   lib.rs
+    /// ```
+    /// Use instead:
+    /// ```text
+    /// src/
+    ///   stuff/
+    ///     stuff_files.rs
+    ///     mod.rs
+    ///   lib.rs
+    /// ```
+
+    pub SELF_NAMED_MODULE_FILES,
+    restriction,
+    "checks that module layout is consistent"
+}
+
+pub struct ModStyle;
+
+impl_lint_pass!(ModStyle => [MOD_MODULE_FILES, SELF_NAMED_MODULE_FILES]);
+
+impl EarlyLintPass for ModStyle {
+    fn check_crate(&mut self, cx: &EarlyContext<'_>, _: &ast::Crate) {
+        if cx.builder.lint_level(MOD_MODULE_FILES).0 == Level::Allow
+            && cx.builder.lint_level(SELF_NAMED_MODULE_FILES).0 == Level::Allow
+        {
+            return;
+        }
+
+        let files = cx.sess.source_map().files();
+
+        let trim_to_src = if let RealFileName::LocalPath(p) = &cx.sess.working_dir {
+            p.to_string_lossy()
+        } else {
+            return;
+        };
+
+        // `folder_segments` is all unique folder path segments `path/to/foo.rs` gives
+        // `[path, to]` but not foo
+        let mut folder_segments = FxHashSet::default();
+        // `mod_folders` is all the unique folder names that contain a mod.rs file
+        let mut mod_folders = FxHashSet::default();
+        // `file_map` maps file names to the full path including the file name
+        // `{ foo => path/to/foo.rs, .. }
+        let mut file_map = FxHashMap::default();
+        for file in files.iter() {
+            match &file.name {
+                FileName::Real(RealFileName::LocalPath(lp))
+                    if lp.to_string_lossy().starts_with(trim_to_src.as_ref()) =>
+                {
+                    let p = lp.to_string_lossy();
+                    let path = Path::new(p.trim_start_matches(trim_to_src.as_ref()));
+                    if let Some(stem) = path.file_stem() {
+                        file_map.insert(stem.to_os_string(), (file, path.to_owned()));
+                    }
+                    process_paths_for_mod_files(path, &mut folder_segments, &mut mod_folders);
+                    check_self_named_mod_exists(cx, path, file);
+                }
+                _ => {},
+            }
+        }
+
+        for folder in &folder_segments {
+            if !mod_folders.contains(folder) {
+                if let Some((file, path)) = file_map.get(folder) {
+                    let mut correct = path.clone();
+                    correct.pop();
+                    correct.push(folder);
+                    correct.push("mod.rs");
+                    cx.struct_span_lint(
+                        SELF_NAMED_MODULE_FILES,
+                        Span::new(file.start_pos, file.start_pos, SyntaxContext::root()),
+                        |build| {
+                            let mut lint =
+                                build.build(&format!("`mod.rs` files are required, found `{}`", path.display()));
+                            lint.help(&format!("move `{}` to `{}`", path.display(), correct.display(),));
+                            lint.emit();
+                        },
+                    );
+                }
+            }
+        }
+    }
+}
+
+/// For each `path` we add each folder component to `folder_segments` and if the file name
+/// is `mod.rs` we add it's parent folder to `mod_folders`.
+fn process_paths_for_mod_files(
+    path: &Path,
+    folder_segments: &mut FxHashSet<OsString>,
+    mod_folders: &mut FxHashSet<OsString>,
+) {
+    let mut comp = path.components().rev().peekable();
+    let _ = comp.next();
+    if path.ends_with("mod.rs") {
+        mod_folders.insert(comp.peek().map(|c| c.as_os_str().to_owned()).unwrap_or_default());
+    }
+    let folders = comp
+        .filter_map(|c| {
+            if let Component::Normal(s) = c {
+                Some(s.to_os_string())
+            } else {
+                None
+            }
+        })
+        .collect::<Vec<_>>();
+    folder_segments.extend(folders);
+}
+
+/// Checks every path for the presence of `mod.rs` files and emits the lint if found.
+fn check_self_named_mod_exists(cx: &EarlyContext<'_>, path: &Path, file: &SourceFile) {
+    if path.ends_with("mod.rs") {
+        let mut mod_file = path.to_path_buf();
+        mod_file.pop();
+        mod_file.set_extension("rs");
+
+        cx.struct_span_lint(
+            MOD_MODULE_FILES,
+            Span::new(file.start_pos, file.start_pos, SyntaxContext::root()),
+            |build| {
+                let mut lint = build.build(&format!("`mod.rs` files are not allowed, found `{}`", path.display()));
+                lint.help(&format!("move `{}` to `{}`", path.display(), mod_file.display(),));
+                lint.emit();
+            },
+        );
+    }
+}
diff --git a/tests/ui-cargo/module_style/fail_mod/Cargo.toml b/tests/ui-cargo/module_style/fail_mod/Cargo.toml
new file mode 100644
index 00000000000..27b61c09fb4
--- /dev/null
+++ b/tests/ui-cargo/module_style/fail_mod/Cargo.toml
@@ -0,0 +1,8 @@
+[package]
+name = "fail"
+version = "0.1.0"
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
diff --git a/tests/ui-cargo/module_style/fail_mod/src/bad/inner.rs b/tests/ui-cargo/module_style/fail_mod/src/bad/inner.rs
new file mode 100644
index 00000000000..91cd540a28f
--- /dev/null
+++ b/tests/ui-cargo/module_style/fail_mod/src/bad/inner.rs
@@ -0,0 +1 @@
+pub mod stuff;
diff --git a/tests/ui-cargo/module_style/fail_mod/src/bad/inner/stuff.rs b/tests/ui-cargo/module_style/fail_mod/src/bad/inner/stuff.rs
new file mode 100644
index 00000000000..7713fa9d35c
--- /dev/null
+++ b/tests/ui-cargo/module_style/fail_mod/src/bad/inner/stuff.rs
@@ -0,0 +1,3 @@
+pub mod most;
+
+pub struct Inner;
diff --git a/tests/ui-cargo/module_style/fail_mod/src/bad/inner/stuff/most.rs b/tests/ui-cargo/module_style/fail_mod/src/bad/inner/stuff/most.rs
new file mode 100644
index 00000000000..5a5eaf9670f
--- /dev/null
+++ b/tests/ui-cargo/module_style/fail_mod/src/bad/inner/stuff/most.rs
@@ -0,0 +1 @@
+pub struct Snarks;
diff --git a/tests/ui-cargo/module_style/fail_mod/src/bad/mod.rs b/tests/ui-cargo/module_style/fail_mod/src/bad/mod.rs
new file mode 100644
index 00000000000..a12734db7cb
--- /dev/null
+++ b/tests/ui-cargo/module_style/fail_mod/src/bad/mod.rs
@@ -0,0 +1,3 @@
+pub mod inner;
+
+pub struct Thing;
diff --git a/tests/ui-cargo/module_style/fail_mod/src/main.rs b/tests/ui-cargo/module_style/fail_mod/src/main.rs
new file mode 100644
index 00000000000..3e985d4e904
--- /dev/null
+++ b/tests/ui-cargo/module_style/fail_mod/src/main.rs
@@ -0,0 +1,9 @@
+#![warn(clippy::self_named_module_files)]
+
+mod bad;
+
+fn main() {
+    let _ = bad::Thing;
+    let _ = bad::inner::stuff::Inner;
+    let _ = bad::inner::stuff::most::Snarks;
+}
diff --git a/tests/ui-cargo/module_style/fail_mod/src/main.stderr b/tests/ui-cargo/module_style/fail_mod/src/main.stderr
new file mode 100644
index 00000000000..af4c298b310
--- /dev/null
+++ b/tests/ui-cargo/module_style/fail_mod/src/main.stderr
@@ -0,0 +1,19 @@
+error: `mod.rs` files are required, found `/bad/inner.rs`
+  --> $DIR/bad/inner.rs:1:1
+   |
+LL | pub mod stuff;
+   | ^
+   |
+   = note: `-D clippy::self-named-module-files` implied by `-D warnings`
+   = help: move `/bad/inner.rs` to `/bad/inner/mod.rs`
+
+error: `mod.rs` files are required, found `/bad/inner/stuff.rs`
+  --> $DIR/bad/inner/stuff.rs:1:1
+   |
+LL | pub mod most;
+   | ^
+   |
+   = help: move `/bad/inner/stuff.rs` to `/bad/inner/stuff/mod.rs`
+
+error: aborting due to 2 previous errors
+
diff --git a/tests/ui-cargo/module_style/fail_no_mod/Cargo.toml b/tests/ui-cargo/module_style/fail_no_mod/Cargo.toml
new file mode 100644
index 00000000000..27b61c09fb4
--- /dev/null
+++ b/tests/ui-cargo/module_style/fail_no_mod/Cargo.toml
@@ -0,0 +1,8 @@
+[package]
+name = "fail"
+version = "0.1.0"
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
diff --git a/tests/ui-cargo/module_style/fail_no_mod/src/bad/mod.rs b/tests/ui-cargo/module_style/fail_no_mod/src/bad/mod.rs
new file mode 100644
index 00000000000..f19ab10d5fb
--- /dev/null
+++ b/tests/ui-cargo/module_style/fail_no_mod/src/bad/mod.rs
@@ -0,0 +1 @@
+pub struct Thing;
diff --git a/tests/ui-cargo/module_style/fail_no_mod/src/main.rs b/tests/ui-cargo/module_style/fail_no_mod/src/main.rs
new file mode 100644
index 00000000000..c6e9045b8dc
--- /dev/null
+++ b/tests/ui-cargo/module_style/fail_no_mod/src/main.rs
@@ -0,0 +1,7 @@
+#![warn(clippy::mod_module_files)]
+
+mod bad;
+
+fn main() {
+    let _ = bad::Thing;
+}
diff --git a/tests/ui-cargo/module_style/fail_no_mod/src/main.stderr b/tests/ui-cargo/module_style/fail_no_mod/src/main.stderr
new file mode 100644
index 00000000000..11e15db7fb9
--- /dev/null
+++ b/tests/ui-cargo/module_style/fail_no_mod/src/main.stderr
@@ -0,0 +1,11 @@
+error: `mod.rs` files are not allowed, found `/bad/mod.rs`
+  --> $DIR/bad/mod.rs:1:1
+   |
+LL | pub struct Thing;
+   | ^
+   |
+   = note: `-D clippy::mod-module-files` implied by `-D warnings`
+   = help: move `/bad/mod.rs` to `/bad.rs`
+
+error: aborting due to previous error
+
diff --git a/tests/ui-cargo/module_style/pass_mod/Cargo.toml b/tests/ui-cargo/module_style/pass_mod/Cargo.toml
new file mode 100644
index 00000000000..27b61c09fb4
--- /dev/null
+++ b/tests/ui-cargo/module_style/pass_mod/Cargo.toml
@@ -0,0 +1,8 @@
+[package]
+name = "fail"
+version = "0.1.0"
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
diff --git a/tests/ui-cargo/module_style/pass_mod/src/bad/mod.rs b/tests/ui-cargo/module_style/pass_mod/src/bad/mod.rs
new file mode 100644
index 00000000000..f19ab10d5fb
--- /dev/null
+++ b/tests/ui-cargo/module_style/pass_mod/src/bad/mod.rs
@@ -0,0 +1 @@
+pub struct Thing;
diff --git a/tests/ui-cargo/module_style/pass_mod/src/main.rs b/tests/ui-cargo/module_style/pass_mod/src/main.rs
new file mode 100644
index 00000000000..9e08715fc05
--- /dev/null
+++ b/tests/ui-cargo/module_style/pass_mod/src/main.rs
@@ -0,0 +1,10 @@
+#![warn(clippy::self_named_module_files)]
+
+mod bad;
+mod more;
+
+fn main() {
+    let _ = bad::Thing;
+    let _ = more::foo::Foo;
+    let _ = more::inner::Inner;
+}
diff --git a/tests/ui-cargo/module_style/pass_mod/src/more/foo.rs b/tests/ui-cargo/module_style/pass_mod/src/more/foo.rs
new file mode 100644
index 00000000000..4a835673a59
--- /dev/null
+++ b/tests/ui-cargo/module_style/pass_mod/src/more/foo.rs
@@ -0,0 +1 @@
+pub struct Foo;
diff --git a/tests/ui-cargo/module_style/pass_mod/src/more/inner/mod.rs b/tests/ui-cargo/module_style/pass_mod/src/more/inner/mod.rs
new file mode 100644
index 00000000000..aa84f78cc2c
--- /dev/null
+++ b/tests/ui-cargo/module_style/pass_mod/src/more/inner/mod.rs
@@ -0,0 +1 @@
+pub struct Inner;
diff --git a/tests/ui-cargo/module_style/pass_mod/src/more/mod.rs b/tests/ui-cargo/module_style/pass_mod/src/more/mod.rs
new file mode 100644
index 00000000000..d79569f78ff
--- /dev/null
+++ b/tests/ui-cargo/module_style/pass_mod/src/more/mod.rs
@@ -0,0 +1,2 @@
+pub mod foo;
+pub mod inner;
diff --git a/tests/ui-cargo/module_style/pass_no_mod/Cargo.toml b/tests/ui-cargo/module_style/pass_no_mod/Cargo.toml
new file mode 100644
index 00000000000..3c0896dd2cd
--- /dev/null
+++ b/tests/ui-cargo/module_style/pass_no_mod/Cargo.toml
@@ -0,0 +1,8 @@
+[package]
+name = "pass"
+version = "0.1.0"
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
diff --git a/tests/ui-cargo/module_style/pass_no_mod/src/good.rs b/tests/ui-cargo/module_style/pass_no_mod/src/good.rs
new file mode 100644
index 00000000000..f19ab10d5fb
--- /dev/null
+++ b/tests/ui-cargo/module_style/pass_no_mod/src/good.rs
@@ -0,0 +1 @@
+pub struct Thing;
diff --git a/tests/ui-cargo/module_style/pass_no_mod/src/main.rs b/tests/ui-cargo/module_style/pass_no_mod/src/main.rs
new file mode 100644
index 00000000000..50211a340b9
--- /dev/null
+++ b/tests/ui-cargo/module_style/pass_no_mod/src/main.rs
@@ -0,0 +1,7 @@
+#![warn(clippy::mod_module_files)]
+
+mod good;
+
+fn main() {
+    let _ = good::Thing;
+}
-- 
cgit 1.4.1-3-g733a5


From c6e420266a5a416f54124b0db556434330dd0567 Mon Sep 17 00:00:00 2001
From: flip1995 <philipp.krones@embecosm.com>
Date: Thu, 26 Aug 2021 10:01:11 +0100
Subject: Set applicability of needless_collect to MaybeIncorrect

---
 clippy_lints/src/loops/needless_collect.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/needless_collect.rs b/clippy_lints/src/loops/needless_collect.rs
index 51d7def137e..f90ed7397e1 100644
--- a/clippy_lints/src/loops/needless_collect.rs
+++ b/clippy_lints/src/loops/needless_collect.rs
@@ -26,7 +26,7 @@ fn check_needless_collect_direct_usage<'tcx>(expr: &'tcx Expr<'_>, cx: &LateCont
         if chain_method.ident.name == sym!(collect) && is_trait_method(cx, &args[0], sym::Iterator);
         then {
             let ty = cx.typeck_results().expr_ty(&args[0]);
-            let mut applicability = Applicability::MachineApplicable;
+            let mut applicability = Applicability::MaybeIncorrect;
             let is_empty_sugg = "next().is_none()".to_string();
             let method_name = &*method.ident.name.as_str();
             let sugg = if is_type_diagnostic_item(cx, ty, sym::vec_type) ||
@@ -113,7 +113,7 @@ fn check_needless_collect_indirect_usage<'tcx>(expr: &'tcx Expr<'_>, cx: &LateCo
                                     (stmt.span, String::new()),
                                     (iter_call.span, iter_replacement)
                                 ],
-                                Applicability::MachineApplicable,// MaybeIncorrect,
+                                Applicability::MaybeIncorrect,
                             );
                         },
                     );
-- 
cgit 1.4.1-3-g733a5


From 3e5dcba2ee446ac712a4a57b042ca4b7f6a46ecc Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Thu, 26 Aug 2021 11:27:43 -0400
Subject: Small cleanup of `option_if_let_else` and additional tests.

---
 clippy_lints/src/option_if_let_else.rs |  6 +++---
 tests/ui/option_if_let_else.fixed      | 20 ++++++++++++++++++++
 tests/ui/option_if_let_else.rs         | 20 ++++++++++++++++++++
 tests/ui/option_if_let_else.stderr     | 28 ++++++++++++++--------------
 4 files changed, 57 insertions(+), 17 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/option_if_let_else.rs b/clippy_lints/src/option_if_let_else.rs
index 46f06362ccc..0614c14462b 100644
--- a/clippy_lints/src/option_if_let_else.rs
+++ b/clippy_lints/src/option_if_let_else.rs
@@ -174,9 +174,9 @@ fn detect_option_if_let_else<'tcx>(
                     ExprKind::Field(e, _) | ExprKind::AddrOf(_, _, e) => Some(e),
                     _ => None,
                 });
-                if let ExprKind::Path(QPath::Resolved(None, Path { res: Res::Local(l), .. })) = e.kind {
-                    match some_captures.get(l)
-                        .or_else(|| (method_sugg == "map_or_else").then(|| ()).and_then(|_| none_captures.get(l)))
+                if let ExprKind::Path(QPath::Resolved(None, Path { res: Res::Local(local_id), .. })) = e.kind {
+                    match some_captures.get(local_id)
+                        .or_else(|| (method_sugg == "map_or_else").then(|| ()).and_then(|_| none_captures.get(local_id)))
                     {
                         Some(CaptureKind::Value | CaptureKind::Ref(Mutability::Mut)) => return None,
                         Some(CaptureKind::Ref(Mutability::Not)) if as_mut => return None,
diff --git a/tests/ui/option_if_let_else.fixed b/tests/ui/option_if_let_else.fixed
index 56e032cdb57..d1815d0aec3 100644
--- a/tests/ui/option_if_let_else.fixed
+++ b/tests/ui/option_if_let_else.fixed
@@ -1,3 +1,4 @@
+// edition:2018
 // run-rustfix
 #![warn(clippy::option_if_let_else)]
 #![allow(clippy::redundant_closure)]
@@ -128,4 +129,23 @@ fn main() {
         let _s = s;
         10
     };
+
+    let mut s = Some(String::new());
+    // Don't lint, `Some` branch mutably borrows `s`, but else branch also borrows  `s`
+    let _ = if let Some(x) = &mut s {
+        x.push_str("test");
+        x.len()
+    } else {
+        let _s = &s;
+        10
+    };
+
+    async fn _f1(x: u32) -> u32 {
+        x
+    }
+
+    async fn _f2() {
+        // Don't lint. `await` can't be moved into a closure.
+        let _ = if let Some(x) = Some(0) { _f1(x).await } else { 0 };
+    }
 }
diff --git a/tests/ui/option_if_let_else.rs b/tests/ui/option_if_let_else.rs
index 595ed8172cd..a15627338cb 100644
--- a/tests/ui/option_if_let_else.rs
+++ b/tests/ui/option_if_let_else.rs
@@ -1,3 +1,4 @@
+// edition:2018
 // run-rustfix
 #![warn(clippy::option_if_let_else)]
 #![allow(clippy::redundant_closure)]
@@ -153,4 +154,23 @@ fn main() {
         let _s = s;
         10
     };
+
+    let mut s = Some(String::new());
+    // Don't lint, `Some` branch mutably borrows `s`, but else branch also borrows  `s`
+    let _ = if let Some(x) = &mut s {
+        x.push_str("test");
+        x.len()
+    } else {
+        let _s = &s;
+        10
+    };
+
+    async fn _f1(x: u32) -> u32 {
+        x
+    }
+
+    async fn _f2() {
+        // Don't lint. `await` can't be moved into a closure.
+        let _ = if let Some(x) = Some(0) { _f1(x).await } else { 0 };
+    }
 }
diff --git a/tests/ui/option_if_let_else.stderr b/tests/ui/option_if_let_else.stderr
index 803d941c36d..ed748ee8b39 100644
--- a/tests/ui/option_if_let_else.stderr
+++ b/tests/ui/option_if_let_else.stderr
@@ -1,5 +1,5 @@
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:7:5
+  --> $DIR/option_if_let_else.rs:8:5
    |
 LL | /     if let Some(x) = string {
 LL | |         (true, x)
@@ -11,19 +11,19 @@ LL | |     }
    = note: `-D clippy::option-if-let-else` implied by `-D warnings`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:25:13
+  --> $DIR/option_if_let_else.rs:26:13
    |
 LL |     let _ = if let Some(s) = *string { s.len() } else { 0 };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `string.map_or(0, |s| s.len())`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:26:13
+  --> $DIR/option_if_let_else.rs:27:13
    |
 LL |     let _ = if let Some(s) = &num { s } else { &0 };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `num.as_ref().map_or(&0, |s| s)`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:27:13
+  --> $DIR/option_if_let_else.rs:28:13
    |
 LL |       let _ = if let Some(s) = &mut num {
    |  _____________^
@@ -43,13 +43,13 @@ LL ~     });
    |
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:33:13
+  --> $DIR/option_if_let_else.rs:34:13
    |
 LL |     let _ = if let Some(ref s) = num { s } else { &0 };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `num.as_ref().map_or(&0, |s| s)`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:34:13
+  --> $DIR/option_if_let_else.rs:35:13
    |
 LL |       let _ = if let Some(mut s) = num {
    |  _____________^
@@ -69,7 +69,7 @@ LL ~     });
    |
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:40:13
+  --> $DIR/option_if_let_else.rs:41:13
    |
 LL |       let _ = if let Some(ref mut s) = num {
    |  _____________^
@@ -89,7 +89,7 @@ LL ~     });
    |
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:49:5
+  --> $DIR/option_if_let_else.rs:50:5
    |
 LL | /     if let Some(x) = arg {
 LL | |         let y = x * x;
@@ -108,7 +108,7 @@ LL +     })
    |
 
 error: use Option::map_or_else instead of an if let/else
-  --> $DIR/option_if_let_else.rs:62:13
+  --> $DIR/option_if_let_else.rs:63:13
    |
 LL |       let _ = if let Some(x) = arg {
    |  _____________^
@@ -120,7 +120,7 @@ LL | |     };
    | |_____^ help: try: `arg.map_or_else(|| side_effect(), |x| x)`
 
 error: use Option::map_or_else instead of an if let/else
-  --> $DIR/option_if_let_else.rs:71:13
+  --> $DIR/option_if_let_else.rs:72:13
    |
 LL |       let _ = if let Some(x) = arg {
    |  _____________^
@@ -143,13 +143,13 @@ LL ~     }, |x| x * x * x * x);
    |
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:100:13
+  --> $DIR/option_if_let_else.rs:101:13
    |
 LL |     let _ = if let Some(x) = optional { x + 2 } else { 5 };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `optional.map_or(5, |x| x + 2)`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:109:13
+  --> $DIR/option_if_let_else.rs:110:13
    |
 LL |       let _ = if let Some(x) = Some(0) {
    |  _____________^
@@ -171,13 +171,13 @@ LL ~         });
    |
 
 error: use Option::map_or_else instead of an if let/else
-  --> $DIR/option_if_let_else.rs:137:13
+  --> $DIR/option_if_let_else.rs:138:13
    |
 LL |     let _ = if let Some(x) = Some(0) { s.len() + x } else { s.len() };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Some(0).map_or_else(|| s.len(), |x| s.len() + x)`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:141:13
+  --> $DIR/option_if_let_else.rs:142:13
    |
 LL |       let _ = if let Some(x) = Some(0) {
    |  _____________^
-- 
cgit 1.4.1-3-g733a5


From f75d1b2bc5b5794ccc43925f36900d404211eeda Mon Sep 17 00:00:00 2001
From: xordi <jordi.obuades@gmail.com>
Date: Thu, 26 Aug 2021 16:14:37 +0200
Subject: Check for Not trait implementation

---
 clippy_lints/src/bool_assert_comparison.rs | 90 ++++++++++++++++++++----------
 clippy_lints/src/lib.rs                    |  2 +-
 2 files changed, 63 insertions(+), 29 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/bool_assert_comparison.rs b/clippy_lints/src/bool_assert_comparison.rs
index 8d3f68565b2..171d22f9986 100644
--- a/clippy_lints/src/bool_assert_comparison.rs
+++ b/clippy_lints/src/bool_assert_comparison.rs
@@ -1,9 +1,11 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::{ast_utils, is_direct_expn_of};
-use rustc_ast::ast::{Expr, ExprKind, Lit, LitKind};
+use clippy_utils::{diagnostics::span_lint_and_sugg, higher, is_direct_expn_of, ty::implements_trait};
+use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
-use rustc_lint::{EarlyContext, EarlyLintPass};
+use rustc_hir::*;
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::symbol::Ident;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -28,45 +30,77 @@ declare_clippy_lint! {
 
 declare_lint_pass!(BoolAssertComparison => [BOOL_ASSERT_COMPARISON]);
 
-fn is_bool_lit(e: &Expr) -> bool {
+fn is_bool_lit(e: &Expr<'_>) -> bool {
     matches!(
         e.kind,
         ExprKind::Lit(Lit {
-            kind: LitKind::Bool(_),
+            node: LitKind::Bool(_),
             ..
         })
     ) && !e.span.from_expansion()
 }
 
-impl EarlyLintPass for BoolAssertComparison {
-    fn check_expr(&mut self, cx: &EarlyContext<'_>, e: &Expr) {
+fn impl_not_trait_with_bool_out(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> bool {
+    let ty = cx.typeck_results().expr_ty(e);
+
+    cx.tcx
+        .lang_items()
+        .not_trait()
+        .filter(|id| implements_trait(cx, ty, *id, &[]))
+        .and_then(|id| {
+            cx.tcx.associated_items(id).find_by_name_and_kind(
+                cx.tcx,
+                Ident::from_str("Output"),
+                ty::AssocKind::Type,
+                id,
+            )
+        })
+        .map_or(false, |item| {
+            let proj = cx.tcx.mk_projection(item.def_id, cx.tcx.mk_substs_trait(ty, &[]));
+            let nty = cx.tcx.normalize_erasing_regions(cx.param_env, proj);
+
+            nty.is_bool()
+        })
+}
+
+impl<'tcx> LateLintPass<'tcx> for BoolAssertComparison {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         let macros = ["assert_eq", "debug_assert_eq"];
         let inverted_macros = ["assert_ne", "debug_assert_ne"];
 
         for mac in macros.iter().chain(inverted_macros.iter()) {
-            if let Some(span) = is_direct_expn_of(e.span, mac) {
-                if let Some([a, b]) = ast_utils::extract_assert_macro_args(e) {
-                    let nb_bool_args = is_bool_lit(a) as usize + is_bool_lit(b) as usize;
+            if let Some(span) = is_direct_expn_of(expr.span, mac) {
+                if let Some(args) = higher::extract_assert_macro_args(expr) {
+                    if let [a, b, ..] = args[..] {
+                        let nb_bool_args = is_bool_lit(a) as usize + is_bool_lit(b) as usize;
+
+                        if nb_bool_args != 1 {
+                            // If there are two boolean arguments, we definitely don't understand
+                            // what's going on, so better leave things as is...
+                            //
+                            // Or there is simply no boolean and then we can leave things as is!
+                            return;
+                        }
 
-                    if nb_bool_args != 1 {
-                        // If there are two boolean arguments, we definitely don't understand
-                        // what's going on, so better leave things as is...
-                        //
-                        // Or there is simply no boolean and then we can leave things as is!
+                        if !impl_not_trait_with_bool_out(cx, a) || !impl_not_trait_with_bool_out(cx, b) {
+                            // At this point the expression which is not a boolean
+                            // literal does not implement Not trait with a bool output,
+                            // so we cannot suggest to rewrite our code
+                            return;
+                        }
+
+                        let non_eq_mac = &mac[..mac.len() - 3];
+                        span_lint_and_sugg(
+                            cx,
+                            BOOL_ASSERT_COMPARISON,
+                            span,
+                            &format!("used `{}!` with a literal bool", mac),
+                            "replace it with",
+                            format!("{}!(..)", non_eq_mac),
+                            Applicability::MaybeIncorrect,
+                        );
                         return;
                     }
-
-                    let non_eq_mac = &mac[..mac.len() - 3];
-                    span_lint_and_sugg(
-                        cx,
-                        BOOL_ASSERT_COMPARISON,
-                        span,
-                        &format!("used `{}!` with a literal bool", mac),
-                        "replace it with",
-                        format!("{}!(..)", non_eq_mac),
-                        Applicability::MaybeIncorrect,
-                    );
-                    return;
                 }
             }
         }
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index be97776187f..5987f9e5b0c 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -2115,7 +2115,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box from_str_radix_10::FromStrRadix10);
     store.register_late_pass(|| box manual_map::ManualMap);
     store.register_late_pass(move || box if_then_some_else_none::IfThenSomeElseNone::new(msrv));
-    store.register_early_pass(|| box bool_assert_comparison::BoolAssertComparison);
+    store.register_late_pass(|| box bool_assert_comparison::BoolAssertComparison);
     store.register_early_pass(move || box module_style::ModStyle);
     store.register_late_pass(|| box unused_async::UnusedAsync);
     let disallowed_types = conf.disallowed_types.iter().cloned().collect::<FxHashSet<_>>();
-- 
cgit 1.4.1-3-g733a5


From aee4f1fc0cae5ac2c044e4f1b6ff015bbb9405b4 Mon Sep 17 00:00:00 2001
From: xordi <jordi.obuades@gmail.com>
Date: Thu, 26 Aug 2021 18:18:17 +0200
Subject: Fix CI errors

---
 clippy_lints/src/bool_assert_comparison.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/bool_assert_comparison.rs b/clippy_lints/src/bool_assert_comparison.rs
index 171d22f9986..2f8f61f7d33 100644
--- a/clippy_lints/src/bool_assert_comparison.rs
+++ b/clippy_lints/src/bool_assert_comparison.rs
@@ -1,7 +1,7 @@
 use clippy_utils::{diagnostics::span_lint_and_sugg, higher, is_direct_expn_of, ty::implements_trait};
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
-use rustc_hir::*;
+use rustc_hir::{Expr, ExprKind, Lit};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-- 
cgit 1.4.1-3-g733a5


From 83f1454ade1bfa9a797b4bdccd8bd2432c110641 Mon Sep 17 00:00:00 2001
From: xordi <jordi.obuades@gmail.com>
Date: Tue, 31 Aug 2021 09:06:14 +0200
Subject: Fix function and variable names

---
 clippy_lints/src/bool_assert_comparison.rs | 16 ++++++++--------
 tests/ui/bool_assert_comparison.rs         | 24 ++++++++++++------------
 2 files changed, 20 insertions(+), 20 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/bool_assert_comparison.rs b/clippy_lints/src/bool_assert_comparison.rs
index 2f8f61f7d33..cdc192a47e4 100644
--- a/clippy_lints/src/bool_assert_comparison.rs
+++ b/clippy_lints/src/bool_assert_comparison.rs
@@ -40,23 +40,23 @@ fn is_bool_lit(e: &Expr<'_>) -> bool {
     ) && !e.span.from_expansion()
 }
 
-fn impl_not_trait_with_bool_out(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> bool {
+fn is_impl_not_trait_with_bool_out(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> bool {
     let ty = cx.typeck_results().expr_ty(e);
 
     cx.tcx
         .lang_items()
         .not_trait()
-        .filter(|id| implements_trait(cx, ty, *id, &[]))
-        .and_then(|id| {
-            cx.tcx.associated_items(id).find_by_name_and_kind(
+        .filter(|trait_id| implements_trait(cx, ty, *trait_id, &[]))
+        .and_then(|trait_id| {
+            cx.tcx.associated_items(trait_id).find_by_name_and_kind(
                 cx.tcx,
                 Ident::from_str("Output"),
                 ty::AssocKind::Type,
-                id,
+                trait_id,
             )
         })
-        .map_or(false, |item| {
-            let proj = cx.tcx.mk_projection(item.def_id, cx.tcx.mk_substs_trait(ty, &[]));
+        .map_or(false, |assoc_item| {
+            let proj = cx.tcx.mk_projection(assoc_item.def_id, cx.tcx.mk_substs_trait(ty, &[]));
             let nty = cx.tcx.normalize_erasing_regions(cx.param_env, proj);
 
             nty.is_bool()
@@ -82,7 +82,7 @@ impl<'tcx> LateLintPass<'tcx> for BoolAssertComparison {
                             return;
                         }
 
-                        if !impl_not_trait_with_bool_out(cx, a) || !impl_not_trait_with_bool_out(cx, b) {
+                        if !is_impl_not_trait_with_bool_out(cx, a) || !is_impl_not_trait_with_bool_out(cx, b) {
                             // At this point the expression which is not a boolean
                             // literal does not implement Not trait with a bool output,
                             // so we cannot suggest to rewrite our code
diff --git a/tests/ui/bool_assert_comparison.rs b/tests/ui/bool_assert_comparison.rs
index 3961b9432a3..ec4d6f3ff84 100644
--- a/tests/ui/bool_assert_comparison.rs
+++ b/tests/ui/bool_assert_comparison.rs
@@ -16,28 +16,28 @@ macro_rules! b {
 // Implements the Not trait but with an output type
 // that's not bool. Should not suggest a rewrite
 #[derive(Debug)]
-enum A {
+enum ImplNotTraitWithoutBool {
     VariantX(bool),
     VariantY(u32),
 }
 
-impl PartialEq<bool> for A {
+impl PartialEq<bool> for ImplNotTraitWithoutBool {
     fn eq(&self, other: &bool) -> bool {
         match *self {
-            A::VariantX(b) => b == *other,
+            ImplNotTraitWithoutBool::VariantX(b) => b == *other,
             _ => false,
         }
     }
 }
 
-impl Not for A {
+impl Not for ImplNotTraitWithoutBool {
     type Output = Self;
 
     fn not(self) -> Self::Output {
         match self {
-            A::VariantX(b) => A::VariantX(!b),
-            A::VariantY(0) => A::VariantY(1),
-            A::VariantY(_) => A::VariantY(0),
+            ImplNotTraitWithoutBool::VariantX(b) => ImplNotTraitWithoutBool::VariantX(!b),
+            ImplNotTraitWithoutBool::VariantY(0) => ImplNotTraitWithoutBool::VariantY(1),
+            ImplNotTraitWithoutBool::VariantY(_) => ImplNotTraitWithoutBool::VariantY(0),
         }
     }
 }
@@ -45,15 +45,15 @@ impl Not for A {
 // This type implements the Not trait with an Output of
 // type bool. Using assert!(..) must be suggested
 #[derive(Debug)]
-struct B;
+struct ImplNotTraitWithBool;
 
-impl PartialEq<bool> for B {
+impl PartialEq<bool> for ImplNotTraitWithBool {
     fn eq(&self, other: &bool) -> bool {
         false
     }
 }
 
-impl Not for B {
+impl Not for ImplNotTraitWithBool {
     type Output = bool;
 
     fn not(self) -> Self::Output {
@@ -62,8 +62,8 @@ impl Not for B {
 }
 
 fn main() {
-    let a = A::VariantX(true);
-    let b = B {};
+    let a = ImplNotTraitWithoutBool::VariantX(true);
+    let b = ImplNotTraitWithBool;
 
     assert_eq!("a".len(), 1);
     assert_eq!("a".is_empty(), false);
-- 
cgit 1.4.1-3-g733a5


From 5722a7dacdfa84d125adaa872dfe2ec0a34e8200 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Thu, 26 Aug 2021 10:05:33 -0500
Subject: Fix manual_match with let-expressions

---
 clippy_lints/src/collapsible_match.rs |  32 +---
 clippy_lints/src/manual_map.rs        | 334 ++++++++++++++++------------------
 clippy_utils/src/higher.rs            |  29 ++-
 clippy_utils/src/lib.rs               |   7 +
 4 files changed, 191 insertions(+), 211 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/collapsible_match.rs b/clippy_lints/src/collapsible_match.rs
index f5683856889..86226be715d 100644
--- a/clippy_lints/src/collapsible_match.rs
+++ b/clippy_lints/src/collapsible_match.rs
@@ -1,9 +1,10 @@
 use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::higher::IfLetOrMatch;
 use clippy_utils::visitors::is_local_used;
-use clippy_utils::{higher, is_lang_ctor, is_unit_expr, path_to_local, peel_ref_operators, SpanlessEq};
+use clippy_utils::{is_lang_ctor, is_unit_expr, path_to_local, peel_ref_operators, SpanlessEq};
 use if_chain::if_chain;
 use rustc_hir::LangItem::OptionNone;
-use rustc_hir::{Arm, Expr, ExprKind, Guard, HirId, MatchSource, Pat, PatKind, StmtKind};
+use rustc_hir::{Arm, Expr, ExprKind, Guard, HirId, Pat, PatKind, StmtKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::{MultiSpan, Span};
@@ -149,33 +150,6 @@ fn strip_singleton_blocks<'hir>(mut expr: &'hir Expr<'hir>) -> &'hir Expr<'hir>
     expr
 }
 
-enum IfLetOrMatch<'hir> {
-    Match(&'hir Expr<'hir>, &'hir [Arm<'hir>], MatchSource),
-    /// scrutinee, pattern, then block, else block
-    IfLet(
-        &'hir Expr<'hir>,
-        &'hir Pat<'hir>,
-        &'hir Expr<'hir>,
-        Option<&'hir Expr<'hir>>,
-    ),
-}
-
-impl<'hir> IfLetOrMatch<'hir> {
-    fn parse(cx: &LateContext<'_>, expr: &Expr<'hir>) -> Option<Self> {
-        match expr.kind {
-            ExprKind::Match(expr, arms, source) => Some(Self::Match(expr, arms, source)),
-            _ => higher::IfLet::hir(cx, expr).map(
-                |higher::IfLet {
-                     let_expr,
-                     let_pat,
-                     if_then,
-                     if_else,
-                 }| { Self::IfLet(let_expr, let_pat, if_then, if_else) },
-            ),
-        }
-    }
-}
-
 /// A "wild-like" arm has a wild (`_`) or `None` pattern and no guard. Such arms can be "collapsed"
 /// into a single wild arm without any significant loss in semantics or readability.
 fn arm_is_wild_like(cx: &LateContext<'_>, arm: &Arm<'_>) -> bool {
diff --git a/clippy_lints/src/manual_map.rs b/clippy_lints/src/manual_map.rs
index 385a3f546b9..b5f573cb104 100644
--- a/clippy_lints/src/manual_map.rs
+++ b/clippy_lints/src/manual_map.rs
@@ -1,6 +1,6 @@
 use crate::{map_unit_fn::OPTION_MAP_UNIT_FN, matches::MATCH_AS_REF};
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::higher;
+use clippy_utils::higher::IfLetOrMatch;
 use clippy_utils::source::{snippet_with_applicability, snippet_with_context};
 use clippy_utils::ty::{is_type_diagnostic_item, peel_mid_ty_refs_is_mutable};
 use clippy_utils::{
@@ -46,190 +46,169 @@ declare_lint_pass!(ManualMap => [MANUAL_MAP]);
 impl LateLintPass<'_> for ManualMap {
     #[allow(clippy::too_many_lines)]
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if let Some(higher::IfLet {
-            let_pat,
-            let_expr,
-            if_then,
-            if_else: Some(if_else),
-        }) = higher::IfLet::hir(cx, expr)
-        {
-            manage_lint(cx, expr, (&let_pat.kind, if_then), (&PatKind::Wild, if_else), let_expr);
+        let (scrutinee, then_pat, then_body, else_pat, else_body) = match IfLetOrMatch::parse(cx, expr) {
+            Some(IfLetOrMatch::IfLet(scrutinee, pat, body, Some(r#else))) => (scrutinee, pat, body, None, r#else),
+            Some(IfLetOrMatch::Match(
+                scrutinee,
+                [arm1 @ Arm { guard: None, .. }, arm2 @ Arm { guard: None, .. }],
+                _,
+            )) => (scrutinee, arm1.pat, arm1.body, Some(arm2.pat), arm2.body),
+            _ => return,
+        };
+        if in_external_macro(cx.sess(), expr.span) || in_constant(cx, expr.hir_id) {
+            return;
         }
 
-        if let ExprKind::Match(scrutinee, [then @ Arm { guard: None, .. }, r#else @ Arm { guard: None, .. }], _) =
-            expr.kind
+        let (scrutinee_ty, ty_ref_count, ty_mutability) =
+            peel_mid_ty_refs_is_mutable(cx.typeck_results().expr_ty(scrutinee));
+        if !(is_type_diagnostic_item(cx, scrutinee_ty, sym::option_type)
+            && is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(expr), sym::option_type))
         {
-            manage_lint(
-                cx,
-                expr,
-                (&then.pat.kind, then.body),
-                (&r#else.pat.kind, r#else.body),
-                scrutinee,
-            );
+            return;
         }
-    }
-}
-
-fn manage_lint<'tcx>(
-    cx: &LateContext<'tcx>,
-    expr: &'tcx Expr<'_>,
-    then: (&'tcx PatKind<'_>, &'tcx Expr<'_>),
-    r#else: (&'tcx PatKind<'_>, &'tcx Expr<'_>),
-    scrut: &'tcx Expr<'_>,
-) {
-    if in_external_macro(cx.sess(), expr.span) || in_constant(cx, expr.hir_id) {
-        return;
-    }
-
-    let (scrutinee_ty, ty_ref_count, ty_mutability) = peel_mid_ty_refs_is_mutable(cx.typeck_results().expr_ty(scrut));
-    if !(is_type_diagnostic_item(cx, scrutinee_ty, sym::option_type)
-        && is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(expr), sym::option_type))
-    {
-        return;
-    }
-
-    let (then_pat, then_expr) = then;
-    let (else_pat, else_expr) = r#else;
 
-    let expr_ctxt = expr.span.ctxt();
-    let (some_expr, some_pat, pat_ref_count, is_wild_none) = match (
-        try_parse_pattern(cx, then_pat, expr_ctxt),
-        try_parse_pattern(cx, else_pat, expr_ctxt),
-    ) {
-        (Some(OptionPat::Wild), Some(OptionPat::Some { pattern, ref_count })) if is_none_expr(cx, then_expr) => {
-            (else_expr, pattern, ref_count, true)
-        },
-        (Some(OptionPat::None), Some(OptionPat::Some { pattern, ref_count })) if is_none_expr(cx, then_expr) => {
-            (else_expr, pattern, ref_count, false)
-        },
-        (Some(OptionPat::Some { pattern, ref_count }), Some(OptionPat::Wild)) if is_none_expr(cx, else_expr) => {
-            (then_expr, pattern, ref_count, true)
-        },
-        (Some(OptionPat::Some { pattern, ref_count }), Some(OptionPat::None)) if is_none_expr(cx, else_expr) => {
-            (then_expr, pattern, ref_count, false)
-        },
-        _ => return,
-    };
+        let expr_ctxt = expr.span.ctxt();
+        let (some_expr, some_pat, pat_ref_count, is_wild_none) = match (
+            try_parse_pattern(cx, then_pat, expr_ctxt),
+            else_pat.map_or(Some(OptionPat::Wild), |p| try_parse_pattern(cx, p, expr_ctxt)),
+        ) {
+            (Some(OptionPat::Wild), Some(OptionPat::Some { pattern, ref_count })) if is_none_expr(cx, then_body) => {
+                (else_body, pattern, ref_count, true)
+            },
+            (Some(OptionPat::None), Some(OptionPat::Some { pattern, ref_count })) if is_none_expr(cx, then_body) => {
+                (else_body, pattern, ref_count, false)
+            },
+            (Some(OptionPat::Some { pattern, ref_count }), Some(OptionPat::Wild)) if is_none_expr(cx, else_body) => {
+                (then_body, pattern, ref_count, true)
+            },
+            (Some(OptionPat::Some { pattern, ref_count }), Some(OptionPat::None)) if is_none_expr(cx, else_body) => {
+                (then_body, pattern, ref_count, false)
+            },
+            _ => return,
+        };
 
-    // Top level or patterns aren't allowed in closures.
-    if matches!(some_pat.kind, PatKind::Or(_)) {
-        return;
-    }
+        // Top level or patterns aren't allowed in closures.
+        if matches!(some_pat.kind, PatKind::Or(_)) {
+            return;
+        }
 
-    let some_expr = match get_some_expr(cx, some_expr, expr_ctxt) {
-        Some(expr) => expr,
-        None => return,
-    };
+        let some_expr = match get_some_expr(cx, some_expr, expr_ctxt) {
+            Some(expr) => expr,
+            None => return,
+        };
 
-    if cx.typeck_results().expr_ty(some_expr) == cx.tcx.types.unit
-        && !is_lint_allowed(cx, OPTION_MAP_UNIT_FN, expr.hir_id)
-    {
-        return;
-    }
+        // These two lints will go back and forth with each other.
+        if cx.typeck_results().expr_ty(some_expr) == cx.tcx.types.unit
+            && !is_lint_allowed(cx, OPTION_MAP_UNIT_FN, expr.hir_id)
+        {
+            return;
+        }
 
-    // `map` won't perform any adjustments.
-    if !cx.typeck_results().expr_adjustments(some_expr).is_empty() {
-        return;
-    }
+        // `map` won't perform any adjustments.
+        if !cx.typeck_results().expr_adjustments(some_expr).is_empty() {
+            return;
+        }
 
-    // Determine which binding mode to use.
-    let explicit_ref = some_pat.contains_explicit_ref_binding();
-    let binding_ref = explicit_ref.or_else(|| (ty_ref_count != pat_ref_count).then(|| ty_mutability));
+        // Determine which binding mode to use.
+        let explicit_ref = some_pat.contains_explicit_ref_binding();
+        let binding_ref = explicit_ref.or_else(|| (ty_ref_count != pat_ref_count).then(|| ty_mutability));
 
-    let as_ref_str = match binding_ref {
-        Some(Mutability::Mut) => ".as_mut()",
-        Some(Mutability::Not) => ".as_ref()",
-        None => "",
-    };
+        let as_ref_str = match binding_ref {
+            Some(Mutability::Mut) => ".as_mut()",
+            Some(Mutability::Not) => ".as_ref()",
+            None => "",
+        };
 
-    match can_move_expr_to_closure(cx, some_expr) {
-        Some(captures) => {
-            // Check if captures the closure will need conflict with borrows made in the scrutinee.
-            // TODO: check all the references made in the scrutinee expression. This will require interacting
-            // with the borrow checker. Currently only `<local>[.<field>]*` is checked for.
-            if let Some(binding_ref_mutability) = binding_ref {
-                let e = peel_hir_expr_while(scrut, |e| match e.kind {
-                    ExprKind::Field(e, _) | ExprKind::AddrOf(_, _, e) => Some(e),
-                    _ => None,
-                });
-                if let ExprKind::Path(QPath::Resolved(None, Path { res: Res::Local(l), .. })) = e.kind {
-                    match captures.get(l) {
-                        Some(CaptureKind::Value | CaptureKind::Ref(Mutability::Mut)) => return,
-                        Some(CaptureKind::Ref(Mutability::Not)) if binding_ref_mutability == Mutability::Mut => {
-                            return;
-                        },
-                        Some(CaptureKind::Ref(Mutability::Not)) | None => (),
+        match can_move_expr_to_closure(cx, some_expr) {
+            Some(captures) => {
+                // Check if captures the closure will need conflict with borrows made in the scrutinee.
+                // TODO: check all the references made in the scrutinee expression. This will require interacting
+                // with the borrow checker. Currently only `<local>[.<field>]*` is checked for.
+                if let Some(binding_ref_mutability) = binding_ref {
+                    let e = peel_hir_expr_while(scrutinee, |e| match e.kind {
+                        ExprKind::Field(e, _) | ExprKind::AddrOf(_, _, e) => Some(e),
+                        _ => None,
+                    });
+                    if let ExprKind::Path(QPath::Resolved(None, Path { res: Res::Local(l), .. })) = e.kind {
+                        match captures.get(l) {
+                            Some(CaptureKind::Value | CaptureKind::Ref(Mutability::Mut)) => return,
+                            Some(CaptureKind::Ref(Mutability::Not)) if binding_ref_mutability == Mutability::Mut => {
+                                return;
+                            },
+                            Some(CaptureKind::Ref(Mutability::Not)) | None => (),
+                        }
                     }
                 }
-            }
-        },
-        None => return,
-    };
-
-    let mut app = Applicability::MachineApplicable;
+            },
+            None => return,
+        };
 
-    // Remove address-of expressions from the scrutinee. Either `as_ref` will be called, or
-    // it's being passed by value.
-    let scrutinee = peel_hir_expr_refs(scrut).0;
-    let (scrutinee_str, _) = snippet_with_context(cx, scrutinee.span, expr_ctxt, "..", &mut app);
-    let scrutinee_str = if scrutinee.span.ctxt() == expr.span.ctxt() && scrutinee.precedence().order() < PREC_POSTFIX {
-        format!("({})", scrutinee_str)
-    } else {
-        scrutinee_str.into()
-    };
+        let mut app = Applicability::MachineApplicable;
 
-    let body_str = if let PatKind::Binding(annotation, id, some_binding, None) = some_pat.kind {
-        match can_pass_as_func(cx, id, some_expr) {
-            Some(func) if func.span.ctxt() == some_expr.span.ctxt() => {
-                snippet_with_applicability(cx, func.span, "..", &mut app).into_owned()
-            },
-            _ => {
-                if path_to_local_id(some_expr, id)
-                    && !is_lint_allowed(cx, MATCH_AS_REF, expr.hir_id)
-                    && binding_ref.is_some()
-                {
-                    return;
-                }
+        // Remove address-of expressions from the scrutinee. Either `as_ref` will be called, or
+        // it's being passed by value.
+        let scrutinee = peel_hir_expr_refs(scrutinee).0;
+        let (scrutinee_str, _) = snippet_with_context(cx, scrutinee.span, expr_ctxt, "..", &mut app);
+        let scrutinee_str =
+            if scrutinee.span.ctxt() == expr.span.ctxt() && scrutinee.precedence().order() < PREC_POSTFIX {
+                format!("({})", scrutinee_str)
+            } else {
+                scrutinee_str.into()
+            };
 
-                // `ref` and `ref mut` annotations were handled earlier.
-                let annotation = if matches!(annotation, BindingAnnotation::Mutable) {
-                    "mut "
-                } else {
-                    ""
-                };
-                format!(
-                    "|{}{}| {}",
-                    annotation,
-                    some_binding,
-                    snippet_with_context(cx, some_expr.span, expr_ctxt, "..", &mut app).0
-                )
-            },
-        }
-    } else if !is_wild_none && explicit_ref.is_none() {
-        // TODO: handle explicit reference annotations.
-        format!(
-            "|{}| {}",
-            snippet_with_context(cx, some_pat.span, expr_ctxt, "..", &mut app).0,
-            snippet_with_context(cx, some_expr.span, expr_ctxt, "..", &mut app).0
-        )
-    } else {
-        // Refutable bindings and mixed reference annotations can't be handled by `map`.
-        return;
-    };
+        let body_str = if let PatKind::Binding(annotation, id, some_binding, None) = some_pat.kind {
+            match can_pass_as_func(cx, id, some_expr) {
+                Some(func) if func.span.ctxt() == some_expr.span.ctxt() => {
+                    snippet_with_applicability(cx, func.span, "..", &mut app).into_owned()
+                },
+                _ => {
+                    if path_to_local_id(some_expr, id)
+                        && !is_lint_allowed(cx, MATCH_AS_REF, expr.hir_id)
+                        && binding_ref.is_some()
+                    {
+                        return;
+                    }
 
-    span_lint_and_sugg(
-        cx,
-        MANUAL_MAP,
-        expr.span,
-        "manual implementation of `Option::map`",
-        "try this",
-        if is_else_clause(cx.tcx, expr) {
-            format!("{{ {}{}.map({}) }}", scrutinee_str, as_ref_str, body_str)
+                    // `ref` and `ref mut` annotations were handled earlier.
+                    let annotation = if matches!(annotation, BindingAnnotation::Mutable) {
+                        "mut "
+                    } else {
+                        ""
+                    };
+                    format!(
+                        "|{}{}| {}",
+                        annotation,
+                        some_binding,
+                        snippet_with_context(cx, some_expr.span, expr_ctxt, "..", &mut app).0
+                    )
+                },
+            }
+        } else if !is_wild_none && explicit_ref.is_none() {
+            // TODO: handle explicit reference annotations.
+            format!(
+                "|{}| {}",
+                snippet_with_context(cx, some_pat.span, expr_ctxt, "..", &mut app).0,
+                snippet_with_context(cx, some_expr.span, expr_ctxt, "..", &mut app).0
+            )
         } else {
-            format!("{}{}.map({})", scrutinee_str, as_ref_str, body_str)
-        },
-        app,
-    );
+            // Refutable bindings and mixed reference annotations can't be handled by `map`.
+            return;
+        };
+
+        span_lint_and_sugg(
+            cx,
+            MANUAL_MAP,
+            expr.span,
+            "manual implementation of `Option::map`",
+            "try this",
+            if else_pat.is_none() && is_else_clause(cx.tcx, expr) {
+                format!("{{ {}{}.map({}) }}", scrutinee_str, as_ref_str, body_str)
+            } else {
+                format!("{}{}.map({})", scrutinee_str, as_ref_str, body_str)
+            },
+            app,
+        );
+    }
 }
 
 // Checks whether the expression could be passed as a function, or whether a closure is needed.
@@ -259,28 +238,21 @@ enum OptionPat<'a> {
 
 // Try to parse into a recognized `Option` pattern.
 // i.e. `_`, `None`, `Some(..)`, or a reference to any of those.
-fn try_parse_pattern(
-    cx: &LateContext<'tcx>,
-    pat_kind: &'tcx PatKind<'_>,
-    ctxt: SyntaxContext,
-) -> Option<OptionPat<'tcx>> {
-    fn f(
-        cx: &LateContext<'tcx>,
-        pat_kind: &'tcx PatKind<'_>,
-        ref_count: usize,
-        ctxt: SyntaxContext,
-    ) -> Option<OptionPat<'tcx>> {
-        match pat_kind {
+fn try_parse_pattern(cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>, ctxt: SyntaxContext) -> Option<OptionPat<'tcx>> {
+    fn f(cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>, ref_count: usize, ctxt: SyntaxContext) -> Option<OptionPat<'tcx>> {
+        match pat.kind {
             PatKind::Wild => Some(OptionPat::Wild),
-            PatKind::Ref(ref_pat, _) => f(cx, &ref_pat.kind, ref_count + 1, ctxt),
+            PatKind::Ref(pat, _) => f(cx, pat, ref_count + 1, ctxt),
             PatKind::Path(ref qpath) if is_lang_ctor(cx, qpath, OptionNone) => Some(OptionPat::None),
-            PatKind::TupleStruct(ref qpath, [pattern], _) if is_lang_ctor(cx, qpath, OptionSome) => {
+            PatKind::TupleStruct(ref qpath, [pattern], _)
+                if is_lang_ctor(cx, qpath, OptionSome) && pat.span.ctxt() == ctxt =>
+            {
                 Some(OptionPat::Some { pattern, ref_count })
             },
             _ => None,
         }
     }
-    f(cx, pat_kind, 0, ctxt)
+    f(cx, pat, 0, ctxt)
 }
 
 // Checks for an expression wrapped by the `Some` constructor. Returns the contained expression.
diff --git a/clippy_utils/src/higher.rs b/clippy_utils/src/higher.rs
index d20739a9f74..61e672781f8 100644
--- a/clippy_utils/src/higher.rs
+++ b/clippy_utils/src/higher.rs
@@ -6,7 +6,7 @@ use crate::{is_expn_of, match_def_path, paths};
 use if_chain::if_chain;
 use rustc_ast::ast::{self, LitKind};
 use rustc_hir as hir;
-use rustc_hir::{Block, BorrowKind, Expr, ExprKind, LoopSource, Node, Pat, StmtKind, UnOp};
+use rustc_hir::{Arm, Block, BorrowKind, Expr, ExprKind, LoopSource, MatchSource, Node, Pat, StmtKind, UnOp};
 use rustc_lint::LateContext;
 use rustc_span::{sym, ExpnKind, Span, Symbol};
 
@@ -115,6 +115,33 @@ impl<'hir> IfLet<'hir> {
     }
 }
 
+pub enum IfLetOrMatch<'hir> {
+    Match(&'hir Expr<'hir>, &'hir [Arm<'hir>], MatchSource),
+    /// scrutinee, pattern, then block, else block
+    IfLet(
+        &'hir Expr<'hir>,
+        &'hir Pat<'hir>,
+        &'hir Expr<'hir>,
+        Option<&'hir Expr<'hir>>,
+    ),
+}
+
+impl<'hir> IfLetOrMatch<'hir> {
+    pub fn parse(cx: &LateContext<'_>, expr: &Expr<'hir>) -> Option<Self> {
+        match expr.kind {
+            ExprKind::Match(expr, arms, source) => Some(Self::Match(expr, arms, source)),
+            _ => IfLet::hir(cx, expr).map(
+                |IfLet {
+                     let_expr,
+                     let_pat,
+                     if_then,
+                     if_else,
+                 }| { Self::IfLet(let_expr, let_pat, if_then, if_else) },
+            ),
+        }
+    }
+}
+
 pub struct IfOrIfLet<'hir> {
     pub cond: &'hir Expr<'hir>,
     pub r#else: Option<&'hir Expr<'hir>>,
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 7e03cf56e8a..6cecdd6b199 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -808,6 +808,13 @@ pub fn capture_local_usage(cx: &LateContext<'tcx>, e: &Expr<'_>) -> CaptureKind
                         capture_expr_ty = e;
                     }
                 },
+                ExprKind::Let(pat, ..) => {
+                    let mutability = match pat_capture_kind(cx, pat) {
+                        CaptureKind::Value => Mutability::Not,
+                        CaptureKind::Ref(m) => m,
+                    };
+                    return CaptureKind::Ref(mutability);
+                },
                 ExprKind::Match(_, arms, _) => {
                     let mut mutability = Mutability::Not;
                     for capture in arms.iter().map(|arm| pat_capture_kind(cx, arm.pat)) {
-- 
cgit 1.4.1-3-g733a5


From 588367b62ec0e6c30cb8d8783644775742da91fc Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Thu, 26 Aug 2021 10:25:14 -0500
Subject: Fix dogfood

---
 clippy_lints/src/assertions_on_constants.rs   |  2 +-
 clippy_lints/src/floating_point_arithmetic.rs |  2 --
 clippy_lints/src/functions/must_use.rs        |  1 -
 clippy_lints/src/if_let_some_result.rs        |  4 ++--
 clippy_lints/src/loops/mod.rs                 |  2 +-
 clippy_lints/src/loops/while_let_loop.rs      |  6 +++---
 clippy_lints/src/matches.rs                   | 14 +++++++-------
 clippy_lints/src/pattern_type_mismatch.rs     |  2 +-
 clippy_lints/src/question_mark.rs             |  2 +-
 clippy_lints/src/ranges.rs                    |  2 +-
 clippy_lints/src/redundant_closure_call.rs    |  4 +---
 clippy_lints/src/returns.rs                   | 11 ++++-------
 clippy_lints/src/unused_async.rs              |  7 +------
 clippy_lints/src/utils/inspector.rs           |  2 +-
 clippy_lints/src/vec.rs                       |  2 +-
 clippy_utils/src/higher.rs                    | 24 ++++++++++++------------
 clippy_utils/src/hir_utils.rs                 |  6 ++----
 clippy_utils/src/lib.rs                       |  4 ++--
 18 files changed, 41 insertions(+), 56 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/assertions_on_constants.rs b/clippy_lints/src/assertions_on_constants.rs
index 891e865b245..d834a1d317a 100644
--- a/clippy_lints/src/assertions_on_constants.rs
+++ b/clippy_lints/src/assertions_on_constants.rs
@@ -118,7 +118,7 @@ enum AssertKind {
 fn match_assert_with_message<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<AssertKind> {
     if_chain! {
         if let Some(higher::If { cond, then, .. }) = higher::If::hir(expr);
-        if let ExprKind::Unary(UnOp::Not, ref expr) = cond.kind;
+        if let ExprKind::Unary(UnOp::Not, expr) = cond.kind;
         // bind the first argument of the `assert!` macro
         if let Some((Constant::Bool(is_true), _)) = constant(cx, cx.typeck_results(), expr);
         // block
diff --git a/clippy_lints/src/floating_point_arithmetic.rs b/clippy_lints/src/floating_point_arithmetic.rs
index d12482e7b7b..a643b3eb8f1 100644
--- a/clippy_lints/src/floating_point_arithmetic.rs
+++ b/clippy_lints/src/floating_point_arithmetic.rs
@@ -332,8 +332,6 @@ fn check_powi(cx: &LateContext<'_>, expr: &Expr<'_>, args: &[Expr<'_>]) {
                         ),
                         Applicability::MachineApplicable,
                     );
-
-                    return;
                 }
             }
         }
diff --git a/clippy_lints/src/functions/must_use.rs b/clippy_lints/src/functions/must_use.rs
index ea6193acbe8..77d08081c07 100644
--- a/clippy_lints/src/functions/must_use.rs
+++ b/clippy_lints/src/functions/must_use.rs
@@ -26,7 +26,6 @@ pub(super) fn check_item(cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) {
         let fn_header_span = item.span.with_hi(sig.decl.output.span().hi());
         if let Some(attr) = attr {
             check_needless_must_use(cx, sig.decl, item.hir_id(), item.span, fn_header_span, attr);
-            return;
         } else if is_public && !is_proc_macro(cx.sess(), attrs) && !attrs.iter().any(|a| a.has_name(sym::no_mangle)) {
             check_must_use_candidate(
                 cx,
diff --git a/clippy_lints/src/if_let_some_result.rs b/clippy_lints/src/if_let_some_result.rs
index fb5637fcec1..33eba02dae0 100644
--- a/clippy_lints/src/if_let_some_result.rs
+++ b/clippy_lints/src/if_let_some_result.rs
@@ -46,8 +46,8 @@ impl<'tcx> LateLintPass<'tcx> for OkIfLet {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if_chain! { //begin checking variables
             if let Some(higher::IfLet { let_pat, let_expr, .. }) = higher::IfLet::hir(cx, expr);
-            if let ExprKind::MethodCall(_, ok_span, ref result_types, _) = let_expr.kind; //check is expr.ok() has type Result<T,E>.ok(, _)
-            if let PatKind::TupleStruct(QPath::Resolved(_, ref x), ref y, _)  = let_pat.kind; //get operation
+            if let ExprKind::MethodCall(_, ok_span, result_types, _) = let_expr.kind; //check is expr.ok() has type Result<T,E>.ok(, _)
+            if let PatKind::TupleStruct(QPath::Resolved(_, x), y, _)  = let_pat.kind; //get operation
             if method_chain_args(let_expr, &["ok"]).is_some(); //test to see if using ok() methoduse std::marker::Sized;
             if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&result_types[0]), sym::result_type);
             if rustc_hir_pretty::to_string(rustc_hir_pretty::NO_ANN, |s| s.print_path(x, false)) == "Some";
diff --git a/clippy_lints/src/loops/mod.rs b/clippy_lints/src/loops/mod.rs
index bd9de5e08d7..9c224445b15 100644
--- a/clippy_lints/src/loops/mod.rs
+++ b/clippy_lints/src/loops/mod.rs
@@ -580,7 +580,7 @@ impl<'tcx> LateLintPass<'tcx> for Loops {
 
         while_let_on_iterator::check(cx, expr);
 
-        if let Some(higher::While { if_cond, if_then, .. }) = higher::While::hir(&expr) {
+        if let Some(higher::While { if_cond, if_then, .. }) = higher::While::hir(expr) {
             while_immutable_condition::check(cx, if_cond, if_then);
         }
 
diff --git a/clippy_lints/src/loops/while_let_loop.rs b/clippy_lints/src/loops/while_let_loop.rs
index d6d3315e0a8..1848f5b5de2 100644
--- a/clippy_lints/src/loops/while_let_loop.rs
+++ b/clippy_lints/src/loops/while_let_loop.rs
@@ -24,13 +24,13 @@ pub(super) fn check(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, loop_block: &'
             }
         }
 
-        if let ExprKind::Match(ref matchexpr, ref arms, MatchSource::Normal) = inner.kind {
+        if let ExprKind::Match(matchexpr, arms, MatchSource::Normal) = inner.kind {
             if arms.len() == 2
                 && arms[0].guard.is_none()
                 && arms[1].guard.is_none()
-                && is_simple_break_expr(&arms[1].body)
+                && is_simple_break_expr(arms[1].body)
             {
-                could_be_while_let(cx, expr, &arms[0].pat, matchexpr);
+                could_be_while_let(cx, expr, arms[0].pat, matchexpr);
             }
         }
     }
diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index 131ed1d8925..2f1ff567e84 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -631,7 +631,7 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
                 check_match_single_binding(cx, ex, arms, expr);
             }
         }
-        if let ExprKind::Match(ref ex, ref arms, _) = expr.kind {
+        if let ExprKind::Match(ex, arms, _) = expr.kind {
             check_match_ref_pats(cx, ex, arms.iter().map(|el| el.pat), expr);
         }
         if let Some(higher::IfLet { let_pat, let_expr, .. }) = higher::IfLet::hir(cx, expr) {
@@ -1194,7 +1194,7 @@ where
 
     let (first_sugg, msg, title);
     let span = ex.span.source_callsite();
-    if let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Not, ref inner) = ex.kind {
+    if let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Not, inner) = ex.kind {
         first_sugg = once((span, Sugg::hir_with_macro_callsite(cx, inner, "..").to_string()));
         msg = "try";
         title = "you don't need to add `&` to both the expression and the patterns";
@@ -1205,7 +1205,7 @@ where
     }
 
     let remaining_suggs = pats.filter_map(|pat| {
-        if let PatKind::Ref(ref refp, _) = pat.kind {
+        if let PatKind::Ref(refp, _) = pat.kind {
             Some((pat.span, snippet(cx, refp.span, "..").to_string()))
         } else {
             None
@@ -1365,7 +1365,7 @@ where
                 find_bool_lit(&arm.2.kind, is_if_let).map_or(false, |b| b == b0) && arm.3.is_none() && arm.0.is_empty()
             });
         then {
-            if let Some(ref last_pat) = last_pat_opt {
+            if let Some(last_pat) = last_pat_opt {
                 if !is_wild(last_pat) {
                     return false;
                 }
@@ -1827,13 +1827,13 @@ mod redundant_pattern_match {
             ..
         }) = higher::IfLet::hir(cx, expr)
         {
-            find_sugg_for_if_let(cx, expr, let_pat, let_expr, "if", if_else.is_some())
+            find_sugg_for_if_let(cx, expr, let_pat, let_expr, "if", if_else.is_some());
         }
         if let ExprKind::Match(op, arms, MatchSource::Normal) = &expr.kind {
-            find_sugg_for_match(cx, expr, op, arms)
+            find_sugg_for_match(cx, expr, op, arms);
         }
         if let Some(higher::WhileLet { let_pat, let_expr, .. }) = higher::WhileLet::hir(expr) {
-            find_sugg_for_if_let(cx, expr, let_pat, let_expr, "while", false)
+            find_sugg_for_if_let(cx, expr, let_pat, let_expr, "while", false);
         }
     }
 
diff --git a/clippy_lints/src/pattern_type_mismatch.rs b/clippy_lints/src/pattern_type_mismatch.rs
index 35cff4141a9..e7bc2446590 100644
--- a/clippy_lints/src/pattern_type_mismatch.rs
+++ b/clippy_lints/src/pattern_type_mismatch.rs
@@ -118,7 +118,7 @@ impl<'tcx> LateLintPass<'tcx> for PatternTypeMismatch {
             }
         }
         if let ExprKind::Let(let_pat, let_expr, _) = expr.kind {
-            if let Some(ref expr_ty) = cx.typeck_results().node_type_opt(let_expr.hir_id) {
+            if let Some(expr_ty) = cx.typeck_results().node_type_opt(let_expr.hir_id) {
                 if in_external_macro(cx.sess(), let_pat.span) {
                     return;
                 }
diff --git a/clippy_lints/src/question_mark.rs b/clippy_lints/src/question_mark.rs
index 17c9e3e7541..e79cd7ed4ec 100644
--- a/clippy_lints/src/question_mark.rs
+++ b/clippy_lints/src/question_mark.rs
@@ -106,7 +106,7 @@ impl QuestionMark {
             if let PatKind::Binding(annot, bind_id, _, _) = fields[0].kind;
             let by_ref = matches!(annot, BindingAnnotation::Ref | BindingAnnotation::RefMut);
 
-            if let ExprKind::Block(ref block, None) = if_then.kind;
+            if let ExprKind::Block(block, None) = if_then.kind;
             if block.stmts.is_empty();
             if let Some(trailing_expr) = &block.expr;
             if path_to_local_id(trailing_expr, bind_id);
diff --git a/clippy_lints/src/ranges.rs b/clippy_lints/src/ranges.rs
index 4fa361fedaf..87364a88ed0 100644
--- a/clippy_lints/src/ranges.rs
+++ b/clippy_lints/src/ranges.rs
@@ -337,7 +337,7 @@ fn check_range_zip_with_len(cx: &LateContext<'_>, path: &PathSegment<'_>, args:
         // `.iter()` and `.len()` called on same `Path`
         if let ExprKind::Path(QPath::Resolved(_, iter_path)) = iter_args[0].kind;
         if let ExprKind::Path(QPath::Resolved(_, len_path)) = len_args[0].kind;
-        if SpanlessEq::new(cx).eq_path_segments(&iter_path.segments, &len_path.segments);
+        if SpanlessEq::new(cx).eq_path_segments(iter_path.segments, len_path.segments);
         then {
             span_lint(cx,
                 RANGE_ZIP_WITH_LEN,
diff --git a/clippy_lints/src/redundant_closure_call.rs b/clippy_lints/src/redundant_closure_call.rs
index 7314bce83e0..90e3c3f4b3e 100644
--- a/clippy_lints/src/redundant_closure_call.rs
+++ b/clippy_lints/src/redundant_closure_call.rs
@@ -51,9 +51,7 @@ impl ReturnVisitor {
 
 impl<'ast> ast_visit::Visitor<'ast> for ReturnVisitor {
     fn visit_expr(&mut self, ex: &'ast ast::Expr) {
-        if let ast::ExprKind::Ret(_) = ex.kind {
-            self.found_return = true;
-        } else if let ast::ExprKind::Try(_) = ex.kind {
+        if let ast::ExprKind::Ret(_) | ast::ExprKind::Try(_) = ex.kind {
             self.found_return = true;
         }
 
diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
index 681baed8c36..341b5a61631 100644
--- a/clippy_lints/src/returns.rs
+++ b/clippy_lints/src/returns.rs
@@ -206,13 +206,10 @@ fn check_final_expr<'tcx>(
         // an if/if let expr, check both exprs
         // note, if without else is going to be a type checking error anyways
         // (except for unit type functions) so we don't match it
-        ExprKind::Match(_, arms, source) => match source {
-            MatchSource::Normal => {
-                for arm in arms.iter() {
-                    check_final_expr(cx, arm.body, Some(arm.body.span), RetReplacement::Block);
-                }
-            },
-            _ => (),
+        ExprKind::Match(_, arms, MatchSource::Normal) => {
+            for arm in arms.iter() {
+                check_final_expr(cx, arm.body, Some(arm.body.span), RetReplacement::Block);
+            }
         },
         ExprKind::DropTemps(expr) => check_final_expr(cx, expr, None, RetReplacement::Empty),
         _ => (),
diff --git a/clippy_lints/src/unused_async.rs b/clippy_lints/src/unused_async.rs
index 3a6a07c5226..f4808682b69 100644
--- a/clippy_lints/src/unused_async.rs
+++ b/clippy_lints/src/unused_async.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_help;
 use rustc_hir::intravisit::{walk_expr, walk_fn, FnKind, NestedVisitorMap, Visitor};
-use rustc_hir::{Body, Expr, ExprKind, FnDecl, FnHeader, HirId, IsAsync, Item, ItemKind, YieldSource};
+use rustc_hir::{Body, Expr, ExprKind, FnDecl, FnHeader, HirId, IsAsync, YieldSource};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::map::Map;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -57,11 +57,6 @@ impl<'a, 'tcx> Visitor<'tcx> for AsyncFnVisitor<'a, 'tcx> {
 }
 
 impl<'tcx> LateLintPass<'tcx> for UnusedAsync {
-    fn check_item(&mut self, _: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
-        if let ItemKind::Trait(..) = item.kind {
-            return;
-        }
-    }
     fn check_fn(
         &mut self,
         cx: &LateContext<'tcx>,
diff --git a/clippy_lints/src/utils/inspector.rs b/clippy_lints/src/utils/inspector.rs
index e97983a2e14..43590cc7862 100644
--- a/clippy_lints/src/utils/inspector.rs
+++ b/clippy_lints/src/utils/inspector.rs
@@ -142,7 +142,7 @@ fn print_expr(cx: &LateContext<'_>, expr: &hir::Expr<'_>, indent: usize) {
                 print_expr(cx, arg, indent + 1);
             }
         },
-        hir::ExprKind::Let(ref pat, ref expr, _) => {
+        hir::ExprKind::Let(pat, expr, _) => {
             print_pat(cx, pat, indent + 1);
             print_expr(cx, expr, indent + 1);
         },
diff --git a/clippy_lints/src/vec.rs b/clippy_lints/src/vec.rs
index 95a45fa937f..85ff292c53a 100644
--- a/clippy_lints/src/vec.rs
+++ b/clippy_lints/src/vec.rs
@@ -49,7 +49,7 @@ impl<'tcx> LateLintPass<'tcx> for UselessVec {
         if_chain! {
             if let ty::Ref(_, ty, _) = cx.typeck_results().expr_ty_adjusted(expr).kind();
             if let ty::Slice(..) = ty.kind();
-            if let ExprKind::AddrOf(BorrowKind::Ref, mutability, ref addressee) = expr.kind;
+            if let ExprKind::AddrOf(BorrowKind::Ref, mutability, addressee) = expr.kind;
             if let Some(vec_args) = higher::VecArgs::hir(cx, addressee);
             then {
                 self.check_vec_macro(cx, &vec_args, mutability, expr.span);
diff --git a/clippy_utils/src/higher.rs b/clippy_utils/src/higher.rs
index 61e672781f8..4bb31868baf 100644
--- a/clippy_utils/src/higher.rs
+++ b/clippy_utils/src/higher.rs
@@ -23,16 +23,16 @@ impl<'tcx> ForLoop<'tcx> {
     #[inline]
     pub fn hir(expr: &Expr<'tcx>) -> Option<Self> {
         if_chain! {
-            if let hir::ExprKind::Match(ref iterexpr, ref arms, hir::MatchSource::ForLoopDesugar) = expr.kind;
+            if let hir::ExprKind::Match(iterexpr, arms, hir::MatchSource::ForLoopDesugar) = expr.kind;
             if let Some(first_arm) = arms.get(0);
-            if let hir::ExprKind::Call(_, ref iterargs) = iterexpr.kind;
+            if let hir::ExprKind::Call(_, iterargs) = iterexpr.kind;
             if let Some(first_arg) = iterargs.get(0);
             if iterargs.len() == 1 && arms.len() == 1 && first_arm.guard.is_none();
-            if let hir::ExprKind::Loop(ref block, ..) = first_arm.body.kind;
+            if let hir::ExprKind::Loop(block, ..) = first_arm.body.kind;
             if block.expr.is_none();
             if let [ _, _, ref let_stmt, ref body ] = *block.stmts;
-            if let hir::StmtKind::Local(ref local) = let_stmt.kind;
-            if let hir::StmtKind::Expr(ref body_expr) = body.kind;
+            if let hir::StmtKind::Local(local) = let_stmt.kind;
+            if let hir::StmtKind::Expr(body_expr) = body.kind;
             then {
                 return Some(Self {
                     pat: &*local.pat,
@@ -189,7 +189,7 @@ impl<'a> Range<'a> {
         }
 
         match expr.kind {
-            hir::ExprKind::Call(ref path, ref args)
+            hir::ExprKind::Call(path, args)
                 if matches!(
                     path.kind,
                     hir::ExprKind::Path(hir::QPath::LangItem(hir::LangItem::RangeInclusiveNew, _))
@@ -201,7 +201,7 @@ impl<'a> Range<'a> {
                     limits: ast::RangeLimits::Closed,
                 })
             },
-            hir::ExprKind::Struct(ref path, ref fields, None) => match path {
+            hir::ExprKind::Struct(path, fields, None) => match &path {
                 hir::QPath::LangItem(hir::LangItem::RangeFull, _) => Some(Range {
                     start: None,
                     end: None,
@@ -247,7 +247,7 @@ impl<'a> VecArgs<'a> {
     /// from `vec!`.
     pub fn hir(cx: &LateContext<'_>, expr: &'a hir::Expr<'_>) -> Option<VecArgs<'a>> {
         if_chain! {
-            if let hir::ExprKind::Call(ref fun, ref args) = expr.kind;
+            if let hir::ExprKind::Call(fun, args) = expr.kind;
             if let hir::ExprKind::Path(ref qpath) = fun.kind;
             if is_expn_of(fun.span, "vec").is_some();
             if let Some(fun_def_id) = cx.qpath_res(qpath, fun.hir_id).opt_def_id();
@@ -259,10 +259,10 @@ impl<'a> VecArgs<'a> {
                 else if match_def_path(cx, fun_def_id, &paths::SLICE_INTO_VEC) && args.len() == 1 {
                     // `vec![a, b, c]` case
                     if_chain! {
-                        if let hir::ExprKind::Box(ref boxed) = args[0].kind;
-                        if let hir::ExprKind::Array(ref args) = boxed.kind;
+                        if let hir::ExprKind::Box(boxed) = args[0].kind;
+                        if let hir::ExprKind::Array(args) = boxed.kind;
                         then {
-                            return Some(VecArgs::Vec(&*args));
+                            return Some(VecArgs::Vec(args));
                         }
                     }
 
@@ -566,7 +566,7 @@ pub fn is_from_for_desugar(local: &hir::Local<'_>) -> bool {
     // }
     // ```
     if_chain! {
-        if let Some(ref expr) = local.init;
+        if let Some(expr) = local.init;
         if let hir::ExprKind::Match(_, _, hir::MatchSource::ForLoopDesugar) = expr.kind;
         then {
             return true;
diff --git a/clippy_utils/src/hir_utils.rs b/clippy_utils/src/hir_utils.rs
index a44f2df2fd6..6e9a1de21ee 100644
--- a/clippy_utils/src/hir_utils.rs
+++ b/clippy_utils/src/hir_utils.rs
@@ -232,9 +232,7 @@ impl HirEqInterExpr<'_, '_, '_> {
             (&ExprKind::If(lc, lt, ref le), &ExprKind::If(rc, rt, ref re)) => {
                 self.eq_expr(lc, rc) && self.eq_expr(&**lt, &**rt) && both(le, re, |l, r| self.eq_expr(l, r))
             },
-            (&ExprKind::Let(ref lp, ref le, _), &ExprKind::Let(ref rp, ref re, _)) => {
-                self.eq_pat(lp, rp) && self.eq_expr(le, re)
-            },
+            (&ExprKind::Let(lp, le, _), &ExprKind::Let(rp, re, _)) => self.eq_pat(lp, rp) && self.eq_expr(le, re),
             (&ExprKind::Lit(ref l), &ExprKind::Lit(ref r)) => l.node == r.node,
             (&ExprKind::Loop(lb, ref ll, ref lls, _), &ExprKind::Loop(rb, ref rl, ref rls, _)) => {
                 lls == rls && self.eq_block(lb, rb) && both(ll, rl, |l, r| l.ident.name == r.ident.name)
@@ -668,7 +666,7 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> {
                     }
                 }
             },
-            ExprKind::Let(ref pat, ref expr, _) => {
+            ExprKind::Let(pat, expr, _) => {
                 self.hash_expr(expr);
                 self.hash_pat(pat);
             },
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 6cecdd6b199..40d7963a5e5 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -1603,13 +1603,13 @@ pub fn if_sequence<'tcx>(mut expr: &'tcx Expr<'tcx>) -> (Vec<&'tcx Expr<'tcx>>,
 
     while let Some(higher::IfOrIfLet { cond, then, r#else }) = higher::IfOrIfLet::hir(expr) {
         conds.push(&*cond);
-        if let ExprKind::Block(ref block, _) = then.kind {
+        if let ExprKind::Block(block, _) = then.kind {
             blocks.push(block);
         } else {
             panic!("ExprKind::If node is not an ExprKind::Block");
         }
 
-        if let Some(ref else_expr) = r#else {
+        if let Some(else_expr) = r#else {
             expr = else_expr;
         } else {
             break;
-- 
cgit 1.4.1-3-g733a5


From c2bb313e7aeb19c8e7f0eab490adb957ec7aa0cc Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Fri, 27 Aug 2021 08:38:07 -0500
Subject: Add higher docs and remove some unneeded fields

---
 clippy_lints/src/loops/mod.rs                   |   4 +-
 clippy_lints/src/loops/while_let_on_iterator.rs |   7 +-
 clippy_utils/src/higher.rs                      | 103 ++++++++++++++----------
 3 files changed, 65 insertions(+), 49 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/mod.rs b/clippy_lints/src/loops/mod.rs
index 9c224445b15..97cbe2c53dd 100644
--- a/clippy_lints/src/loops/mod.rs
+++ b/clippy_lints/src/loops/mod.rs
@@ -580,8 +580,8 @@ impl<'tcx> LateLintPass<'tcx> for Loops {
 
         while_let_on_iterator::check(cx, expr);
 
-        if let Some(higher::While { if_cond, if_then, .. }) = higher::While::hir(expr) {
-            while_immutable_condition::check(cx, if_cond, if_then);
+        if let Some(higher::While { condition, body }) = higher::While::hir(expr) {
+            while_immutable_condition::check(cx, condition, body);
         }
 
         needless_collect::check(expr, cx);
diff --git a/clippy_lints/src/loops/while_let_on_iterator.rs b/clippy_lints/src/loops/while_let_on_iterator.rs
index 0757d329125..79527e3bfa9 100644
--- a/clippy_lints/src/loops/while_let_on_iterator.rs
+++ b/clippy_lints/src/loops/while_let_on_iterator.rs
@@ -14,12 +14,7 @@ use rustc_span::{symbol::sym, Span, Symbol};
 
 pub(super) fn check(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
     let (scrutinee_expr, iter_expr, some_pat, loop_expr) = if_chain! {
-        if let Some(higher::WhileLet {
-            if_then,
-            let_pat,
-            let_expr,
-            ..
-        }) = higher::WhileLet::hir(expr);
+        if let Some(higher::WhileLet { if_then, let_pat, let_expr }) = higher::WhileLet::hir(expr);
         // check for `Some(..)` pattern
         if let PatKind::TupleStruct(QPath::Resolved(None, pat_path), some_pat, _) = let_pat.kind;
         if let Res::Def(_, pat_did) = pat_path.res;
diff --git a/clippy_utils/src/higher.rs b/clippy_utils/src/higher.rs
index 4bb31868baf..05a4a014319 100644
--- a/clippy_utils/src/higher.rs
+++ b/clippy_utils/src/higher.rs
@@ -13,14 +13,19 @@ use rustc_span::{sym, ExpnKind, Span, Symbol};
 /// The essential nodes of a desugared for loop as well as the entire span:
 /// `for pat in arg { body }` becomes `(pat, arg, body)`. Return `(pat, arg, body, span)`.
 pub struct ForLoop<'tcx> {
+    /// `for` loop item
     pub pat: &'tcx hir::Pat<'tcx>,
+    /// `IntoIterator` argument
     pub arg: &'tcx hir::Expr<'tcx>,
+    /// `for` loop body
     pub body: &'tcx hir::Expr<'tcx>,
+    /// entire `for` loop span
     pub span: Span,
 }
 
 impl<'tcx> ForLoop<'tcx> {
     #[inline]
+    /// Parses a desugared `for` loop
     pub fn hir(expr: &Expr<'tcx>) -> Option<Self> {
         if_chain! {
             if let hir::ExprKind::Match(iterexpr, arms, hir::MatchSource::ForLoopDesugar) = expr.kind;
@@ -46,14 +51,19 @@ impl<'tcx> ForLoop<'tcx> {
     }
 }
 
+/// An `if` expression without `DropTemps`
 pub struct If<'hir> {
+    /// `if` condition
     pub cond: &'hir Expr<'hir>,
-    pub r#else: Option<&'hir Expr<'hir>>,
+    /// `if` then expression
     pub then: &'hir Expr<'hir>,
+    /// `else` expression
+    pub r#else: Option<&'hir Expr<'hir>>,
 }
 
 impl<'hir> If<'hir> {
     #[inline]
+    /// Parses an `if` expression
     pub const fn hir(expr: &Expr<'hir>) -> Option<Self> {
         if let ExprKind::If(
             Expr {
@@ -64,21 +74,27 @@ impl<'hir> If<'hir> {
             r#else,
         ) = expr.kind
         {
-            Some(Self { cond, r#else, then })
+            Some(Self { cond, then, r#else })
         } else {
             None
         }
     }
 }
 
+/// An `if let` expression
 pub struct IfLet<'hir> {
+    /// `if let` pattern
     pub let_pat: &'hir Pat<'hir>,
+    /// `if let` scrutinee
     pub let_expr: &'hir Expr<'hir>,
+    /// `if let` then expression
     pub if_then: &'hir Expr<'hir>,
+    /// `if let` else expression
     pub if_else: Option<&'hir Expr<'hir>>,
 }
 
 impl<'hir> IfLet<'hir> {
+    /// Parses an `if let` expression
     pub fn hir(cx: &LateContext<'_>, expr: &Expr<'hir>) -> Option<Self> {
         if let ExprKind::If(
             Expr {
@@ -115,7 +131,9 @@ impl<'hir> IfLet<'hir> {
     }
 }
 
+/// An `if let` or `match` expression. Useful for lints that trigger on one or the other.
 pub enum IfLetOrMatch<'hir> {
+    /// Any `match` expression
     Match(&'hir Expr<'hir>, &'hir [Arm<'hir>], MatchSource),
     /// scrutinee, pattern, then block, else block
     IfLet(
@@ -127,6 +145,7 @@ pub enum IfLetOrMatch<'hir> {
 }
 
 impl<'hir> IfLetOrMatch<'hir> {
+    /// Parses an `if let` or `match` expression
     pub fn parse(cx: &LateContext<'_>, expr: &Expr<'hir>) -> Option<Self> {
         match expr.kind {
             ExprKind::Match(expr, arms, source) => Some(Self::Match(expr, arms, source)),
@@ -142,14 +161,19 @@ impl<'hir> IfLetOrMatch<'hir> {
     }
 }
 
+/// An `if` or `if let` expression
 pub struct IfOrIfLet<'hir> {
+    /// `if` condition that is maybe a `let` expression
     pub cond: &'hir Expr<'hir>,
-    pub r#else: Option<&'hir Expr<'hir>>,
+    /// `if` then expression
     pub then: &'hir Expr<'hir>,
+    /// `else` expression
+    pub r#else: Option<&'hir Expr<'hir>>,
 }
 
 impl<'hir> IfOrIfLet<'hir> {
     #[inline]
+    /// Parses an `if` or `if let` expression
     pub const fn hir(expr: &Expr<'hir>) -> Option<Self> {
         if let ExprKind::If(cond, then, r#else) = expr.kind {
             if let ExprKind::DropTemps(new_cond) = cond.kind {
@@ -160,7 +184,7 @@ impl<'hir> IfOrIfLet<'hir> {
                 });
             }
             if let ExprKind::Let(..) = cond.kind {
-                return Some(Self { cond, r#else, then });
+                return Some(Self { cond, then, r#else });
             }
         }
         None
@@ -281,14 +305,17 @@ impl<'a> VecArgs<'a> {
     }
 }
 
+/// A desugared `while` loop
 pub struct While<'hir> {
-    pub if_cond: &'hir Expr<'hir>,
-    pub if_then: &'hir Expr<'hir>,
-    pub if_else: Option<&'hir Expr<'hir>>,
+    /// `while` loop condition
+    pub condition: &'hir Expr<'hir>,
+    /// `while` loop body
+    pub body: &'hir Expr<'hir>,
 }
 
 impl<'hir> While<'hir> {
     #[inline]
+    /// Parses a desugared `while` loop
     pub const fn hir(expr: &Expr<'hir>) -> Option<Self> {
         if let ExprKind::Loop(
             Block {
@@ -297,11 +324,11 @@ impl<'hir> While<'hir> {
                         kind:
                             ExprKind::If(
                                 Expr {
-                                    kind: ExprKind::DropTemps(if_cond),
+                                    kind: ExprKind::DropTemps(condition),
                                     ..
                                 },
-                                if_then,
-                                if_else_ref,
+                                body,
+                                _,
                             ),
                         ..
                     }),
@@ -312,59 +339,53 @@ impl<'hir> While<'hir> {
             _,
         ) = expr.kind
         {
-            let if_else = *if_else_ref;
-            return Some(Self {
-                if_cond,
-                if_then,
-                if_else,
-            });
+            return Some(Self { condition, body });
         }
         None
     }
 }
 
+/// A desugared `while let` loop
 pub struct WhileLet<'hir> {
-    pub if_expr: &'hir Expr<'hir>,
+    /// `while let` loop item pattern
     pub let_pat: &'hir Pat<'hir>,
+    /// `while let` loop scrutinee
     pub let_expr: &'hir Expr<'hir>,
+    /// `while let` loop body
     pub if_then: &'hir Expr<'hir>,
-    pub if_else: Option<&'hir Expr<'hir>>,
 }
 
 impl<'hir> WhileLet<'hir> {
     #[inline]
+    /// Parses a desugared `while let` loop
     pub const fn hir(expr: &Expr<'hir>) -> Option<Self> {
         if let ExprKind::Loop(
             Block {
-                expr: Some(if_expr), ..
+                expr:
+                    Some(Expr {
+                        kind:
+                            ExprKind::If(
+                                Expr {
+                                    kind: ExprKind::Let(let_pat, let_expr, _),
+                                    ..
+                                },
+                                if_then,
+                                _,
+                            ),
+                        ..
+                    }),
+                ..
             },
             _,
             LoopSource::While,
             _,
         ) = expr.kind
         {
-            if let Expr {
-                kind:
-                    ExprKind::If(
-                        Expr {
-                            kind: ExprKind::Let(let_pat, let_expr, _),
-                            ..
-                        },
-                        if_then,
-                        if_else_ref,
-                    ),
-                ..
-            } = if_expr
-            {
-                let if_else = *if_else_ref;
-                return Some(Self {
-                    if_expr,
-                    let_pat,
-                    let_expr,
-                    if_then,
-                    if_else,
-                });
-            }
+            return Some(Self {
+                let_pat,
+                let_expr,
+                if_then,
+            });
         }
         None
     }
-- 
cgit 1.4.1-3-g733a5


From 8bf2940abb478139e575cba302a4ea100c4652cb Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Sat, 28 Aug 2021 15:04:28 +0200
Subject: Fix matadata collection configuration formatting

---
 clippy_lints/src/utils/internal_lints/metadata_collector.rs | 2 --
 1 file changed, 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index 91533695eb3..188d0419c39 100644
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -786,8 +786,6 @@ impl<'a, 'hir> intravisit::Visitor<'hir> for ApplicabilityResolver<'a, 'hir> {
             }
         };
 
-        // TODO xFrednet 2021-03-01: support function arguments?
-
         intravisit::walk_expr(self, expr);
     }
 }
-- 
cgit 1.4.1-3-g733a5


From 01b17af1083ffc0630255c7ac172d32812c610fa Mon Sep 17 00:00:00 2001
From: flip1995 <philipp.krones@embecosm.com>
Date: Thu, 2 Sep 2021 12:58:25 +0100
Subject: Fix fallout from re-applying patches

---
 clippy_lints/src/collapsible_match.rs    |  3 ++-
 clippy_lints/src/lib.rs                  |  1 +
 clippy_lints/src/option_if_let_else.rs   |  4 +++-
 clippy_lints/src/utils/internal_lints.rs | 24 ++++++++----------------
 clippy_utils/src/sugg.rs                 |  2 +-
 5 files changed, 15 insertions(+), 19 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/collapsible_match.rs b/clippy_lints/src/collapsible_match.rs
index 86226be715d..a4693fa213b 100644
--- a/clippy_lints/src/collapsible_match.rs
+++ b/clippy_lints/src/collapsible_match.rs
@@ -107,7 +107,8 @@ fn check_arm<'tcx>(
             (Some(a), Some(b)) => SpanlessEq::new(cx).eq_expr(a, b),
         };
         // the binding must not be used in the if guard
-        if outer_guard.map_or(true, |(Guard::If(e) | Guard::IfLet(_, e))| !is_local_used(cx, *e, binding_id));        // ...or anywhere in the inner expression
+        if outer_guard.map_or(true, |(Guard::If(e) | Guard::IfLet(_, e))| !is_local_used(cx, *e, binding_id));
+        // ...or anywhere in the inner expression
         if match inner {
             IfLetOrMatch::IfLet(_, _, body, els) => {
                 !is_local_used(cx, body, binding_id) && els.map_or(true, |e| !is_local_used(cx, e, binding_id))
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 5ce5f809f46..2b76eacb7d6 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -2199,6 +2199,7 @@ pub fn register_renamed(ls: &mut rustc_lint::LintStore) {
     ls.register_renamed("clippy::temporary_cstring_as_ptr", "temporary_cstring_as_ptr");
     ls.register_renamed("clippy::panic_params", "non_fmt_panics");
     ls.register_renamed("clippy::unknown_clippy_lints", "unknown_lints");
+    ls.register_renamed("clippy::invalid_atomic_ordering", "invalid_atomic_ordering");
 }
 
 // only exists to let the dogfood integration test works.
diff --git a/clippy_lints/src/option_if_let_else.rs b/clippy_lints/src/option_if_let_else.rs
index 80b4f544b1a..15f6dcae887 100644
--- a/clippy_lints/src/option_if_let_else.rs
+++ b/clippy_lints/src/option_if_let_else.rs
@@ -3,7 +3,8 @@ use clippy_utils::higher;
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::{
-    can_move_expr_to_closure, eager_or_lazy, in_macro, is_else_clause, is_lang_ctor, peel_hir_expr_while, CaptureKind,
+    can_move_expr_to_closure, eager_or_lazy, in_constant, in_macro, is_else_clause, is_lang_ctor, peel_hir_expr_while,
+    CaptureKind,
 };
 use if_chain::if_chain;
 use rustc_errors::Applicability;
@@ -126,6 +127,7 @@ fn format_option_in_sugg(cx: &LateContext<'_>, cond_expr: &Expr<'_>, as_ref: boo
 fn detect_option_if_let_else<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>) -> Option<OptionIfLetElseOccurence> {
     if_chain! {
         if !in_macro(expr.span); // Don't lint macros, because it behaves weirdly
+        if !in_constant(cx, expr.hir_id);
         if let Some(higher::IfLet { let_pat, let_expr, if_then, if_else: Some(if_else) })
             = higher::IfLet::hir(cx, expr);
         if !is_else_clause(cx.tcx, expr);
diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs
index d660008e7d1..42d51272279 100644
--- a/clippy_lints/src/utils/internal_lints.rs
+++ b/clippy_lints/src/utils/internal_lints.rs
@@ -1,5 +1,6 @@
 use clippy_utils::consts::{constant_simple, Constant};
 use clippy_utils::diagnostics::{span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then};
+use clippy_utils::higher;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::match_type;
 use clippy_utils::{
@@ -17,8 +18,8 @@ use rustc_hir::def_id::DefId;
 use rustc_hir::hir_id::CRATE_HIR_ID;
 use rustc_hir::intravisit::{NestedVisitorMap, Visitor};
 use rustc_hir::{
-    BinOpKind, Block, Crate, Expr, ExprKind, HirId, Item, Local, MatchSource, MutTy, Mutability, Node, Path, Stmt,
-    StmtKind, Ty, TyKind, UnOp,
+    BinOpKind, Block, Crate, Expr, ExprKind, HirId, Item, Local, MutTy, Mutability, Node, Path, Stmt, StmtKind, Ty,
+    TyKind, UnOp,
 };
 use rustc_lint::{EarlyContext, EarlyLintPass, LateContext, LateLintPass, LintContext};
 use rustc_middle::hir::map::Map;
@@ -1106,16 +1107,10 @@ impl<'tcx> LateLintPass<'tcx> for IfChainStyle {
     }
 
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
-        let (cond, then, els) = match expr.kind {
-            ExprKind::If(cond, then, els) => (Some(cond), then, els.is_some()),
-            ExprKind::Match(
-                _,
-                [arm, ..],
-                MatchSource::IfLetDesugar {
-                    contains_else_clause: els,
-                },
-            ) => (None, arm.body, els),
-            _ => return,
+        let (cond, then, els) = if let Some(higher::IfOrIfLet { cond, r#else, then }) = higher::IfOrIfLet::hir(expr) {
+            (cond, then, r#else.is_some())
+        } else {
+            return;
         };
         let then_block = match then.kind {
             ExprKind::Block(block, _) => block,
@@ -1131,7 +1126,6 @@ impl<'tcx> LateLintPass<'tcx> for IfChainStyle {
         };
         // check for `if a && b;`
         if_chain! {
-            if let Some(cond) = cond;
             if let ExprKind::Binary(op, _, _) = cond.kind;
             if op.node == BinOpKind::And;
             if cx.sess().source_map().is_multiline(cond.span);
@@ -1166,9 +1160,7 @@ fn check_nested_if_chains(
         _ => return,
     };
     if_chain! {
-        if matches!(tail.kind,
-            ExprKind::If(_, _, None)
-            | ExprKind::Match(.., MatchSource::IfLetDesugar { contains_else_clause: false }));
+        if let Some(higher::IfOrIfLet { r#else: None, .. }) = higher::IfOrIfLet::hir(tail);
         let sm = cx.sess().source_map();
         if head
             .iter()
diff --git a/clippy_utils/src/sugg.rs b/clippy_utils/src/sugg.rs
index 65d93e8f86e..ab05a0b4238 100644
--- a/clippy_utils/src/sugg.rs
+++ b/clippy_utils/src/sugg.rs
@@ -329,7 +329,7 @@ fn has_enclosing_paren(sugg: impl AsRef<str>) -> bool {
     }
 }
 
-// Copied from the rust standart library, and then edited
+/// Copied from the rust standard library, and then edited
 macro_rules! forward_binop_impls_to_ref {
     (impl $imp:ident, $method:ident for $t:ty, type Output = $o:ty) => {
         impl $imp<$t> for &$t {
-- 
cgit 1.4.1-3-g733a5


From 03d3131cb46ad8139466a58759ac312f9ebaf053 Mon Sep 17 00:00:00 2001
From: Jake Goulding <jake.goulding@gmail.com>
Date: Wed, 18 Aug 2021 09:56:25 -0400
Subject: Extend unnecessary_unwrap to look for expect in addition to unwrap

Closes #7581
---
 clippy_lints/src/unwrap.rs                         |  4 +-
 tests/ui/checked_unwrap/simple_conditionals.rs     |  4 ++
 tests/ui/checked_unwrap/simple_conditionals.stderr | 62 +++++++++++++++++-----
 3 files changed, 55 insertions(+), 15 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unwrap.rs b/clippy_lints/src/unwrap.rs
index bffd9f3612b..42738bc3e1f 100644
--- a/clippy_lints/src/unwrap.rs
+++ b/clippy_lints/src/unwrap.rs
@@ -172,8 +172,8 @@ impl<'a, 'tcx> Visitor<'tcx> for UnwrappableVariablesVisitor<'a, 'tcx> {
             if_chain! {
                 if let ExprKind::MethodCall(method_name, _, args, _) = expr.kind;
                 if let ExprKind::Path(QPath::Resolved(None, path)) = args[0].kind;
-                if [sym::unwrap, sym!(unwrap_err)].contains(&method_name.ident.name);
-                let call_to_unwrap = method_name.ident.name == sym::unwrap;
+                if [sym::unwrap, sym::expect, sym!(unwrap_err)].contains(&method_name.ident.name);
+                let call_to_unwrap = [sym::unwrap, sym::expect].contains(&method_name.ident.name);
                 if let Some(unwrappable) = self.unwrappables.iter()
                     .find(|u| u.ident.res == path.res);
                 // Span contexts should not differ with the conditional branch
diff --git a/tests/ui/checked_unwrap/simple_conditionals.rs b/tests/ui/checked_unwrap/simple_conditionals.rs
index 8f23fb28827..ee3fdfabe9d 100644
--- a/tests/ui/checked_unwrap/simple_conditionals.rs
+++ b/tests/ui/checked_unwrap/simple_conditionals.rs
@@ -37,8 +37,10 @@ fn main() {
     let x = Some(());
     if x.is_some() {
         x.unwrap(); // unnecessary
+        x.expect("an error message"); // unnecessary
     } else {
         x.unwrap(); // will panic
+        x.expect("an error message"); // will panic
     }
     if x.is_none() {
         x.unwrap(); // will panic
@@ -52,9 +54,11 @@ fn main() {
     let mut x: Result<(), ()> = Ok(());
     if x.is_ok() {
         x.unwrap(); // unnecessary
+        x.expect("an error message"); // unnecessary
         x.unwrap_err(); // will panic
     } else {
         x.unwrap(); // will panic
+        x.expect("an error message"); // will panic
         x.unwrap_err(); // unnecessary
     }
     if x.is_err() {
diff --git a/tests/ui/checked_unwrap/simple_conditionals.stderr b/tests/ui/checked_unwrap/simple_conditionals.stderr
index a4bc058fe20..7127ff89b31 100644
--- a/tests/ui/checked_unwrap/simple_conditionals.stderr
+++ b/tests/ui/checked_unwrap/simple_conditionals.stderr
@@ -12,8 +12,17 @@ note: the lint level is defined here
 LL | #![deny(clippy::panicking_unwrap, clippy::unnecessary_unwrap)]
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
+error: you checked before that `expect()` cannot fail, instead of checking and unwrapping, it's better to use `if let` or `match`
+  --> $DIR/simple_conditionals.rs:40:9
+   |
+LL |     if x.is_some() {
+   |        ----------- the check is happening here
+LL |         x.unwrap(); // unnecessary
+LL |         x.expect("an error message"); // unnecessary
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
 error: this call to `unwrap()` will always panic
-  --> $DIR/simple_conditionals.rs:41:9
+  --> $DIR/simple_conditionals.rs:42:9
    |
 LL |     if x.is_some() {
    |        ----------- because of this check
@@ -27,8 +36,17 @@ note: the lint level is defined here
 LL | #![deny(clippy::panicking_unwrap, clippy::unnecessary_unwrap)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^
 
+error: this call to `expect()` will always panic
+  --> $DIR/simple_conditionals.rs:43:9
+   |
+LL |     if x.is_some() {
+   |        ----------- because of this check
+...
+LL |         x.expect("an error message"); // will panic
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
 error: this call to `unwrap()` will always panic
-  --> $DIR/simple_conditionals.rs:44:9
+  --> $DIR/simple_conditionals.rs:46:9
    |
 LL |     if x.is_none() {
    |        ----------- because of this check
@@ -36,7 +54,7 @@ LL |         x.unwrap(); // will panic
    |         ^^^^^^^^^^
 
 error: you checked before that `unwrap()` cannot fail, instead of checking and unwrapping, it's better to use `if let` or `match`
-  --> $DIR/simple_conditionals.rs:46:9
+  --> $DIR/simple_conditionals.rs:48:9
    |
 LL |     if x.is_none() {
    |        ----------- the check is happening here
@@ -58,24 +76,33 @@ LL |     m!(x);
    = note: this error originates in the macro `m` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: you checked before that `unwrap()` cannot fail, instead of checking and unwrapping, it's better to use `if let` or `match`
-  --> $DIR/simple_conditionals.rs:54:9
+  --> $DIR/simple_conditionals.rs:56:9
    |
 LL |     if x.is_ok() {
    |        --------- the check is happening here
 LL |         x.unwrap(); // unnecessary
    |         ^^^^^^^^^^
 
+error: you checked before that `expect()` cannot fail, instead of checking and unwrapping, it's better to use `if let` or `match`
+  --> $DIR/simple_conditionals.rs:57:9
+   |
+LL |     if x.is_ok() {
+   |        --------- the check is happening here
+LL |         x.unwrap(); // unnecessary
+LL |         x.expect("an error message"); // unnecessary
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
 error: this call to `unwrap_err()` will always panic
-  --> $DIR/simple_conditionals.rs:55:9
+  --> $DIR/simple_conditionals.rs:58:9
    |
 LL |     if x.is_ok() {
    |        --------- because of this check
-LL |         x.unwrap(); // unnecessary
+...
 LL |         x.unwrap_err(); // will panic
    |         ^^^^^^^^^^^^^^
 
 error: this call to `unwrap()` will always panic
-  --> $DIR/simple_conditionals.rs:57:9
+  --> $DIR/simple_conditionals.rs:60:9
    |
 LL |     if x.is_ok() {
    |        --------- because of this check
@@ -83,8 +110,17 @@ LL |     if x.is_ok() {
 LL |         x.unwrap(); // will panic
    |         ^^^^^^^^^^
 
+error: this call to `expect()` will always panic
+  --> $DIR/simple_conditionals.rs:61:9
+   |
+LL |     if x.is_ok() {
+   |        --------- because of this check
+...
+LL |         x.expect("an error message"); // will panic
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
 error: you checked before that `unwrap_err()` cannot fail, instead of checking and unwrapping, it's better to use `if let` or `match`
-  --> $DIR/simple_conditionals.rs:58:9
+  --> $DIR/simple_conditionals.rs:62:9
    |
 LL |     if x.is_ok() {
    |        --------- the check is happening here
@@ -93,7 +129,7 @@ LL |         x.unwrap_err(); // unnecessary
    |         ^^^^^^^^^^^^^^
 
 error: this call to `unwrap()` will always panic
-  --> $DIR/simple_conditionals.rs:61:9
+  --> $DIR/simple_conditionals.rs:65:9
    |
 LL |     if x.is_err() {
    |        ---------- because of this check
@@ -101,7 +137,7 @@ LL |         x.unwrap(); // will panic
    |         ^^^^^^^^^^
 
 error: you checked before that `unwrap_err()` cannot fail, instead of checking and unwrapping, it's better to use `if let` or `match`
-  --> $DIR/simple_conditionals.rs:62:9
+  --> $DIR/simple_conditionals.rs:66:9
    |
 LL |     if x.is_err() {
    |        ---------- the check is happening here
@@ -110,7 +146,7 @@ LL |         x.unwrap_err(); // unnecessary
    |         ^^^^^^^^^^^^^^
 
 error: you checked before that `unwrap()` cannot fail, instead of checking and unwrapping, it's better to use `if let` or `match`
-  --> $DIR/simple_conditionals.rs:64:9
+  --> $DIR/simple_conditionals.rs:68:9
    |
 LL |     if x.is_err() {
    |        ---------- the check is happening here
@@ -119,7 +155,7 @@ LL |         x.unwrap(); // unnecessary
    |         ^^^^^^^^^^
 
 error: this call to `unwrap_err()` will always panic
-  --> $DIR/simple_conditionals.rs:65:9
+  --> $DIR/simple_conditionals.rs:69:9
    |
 LL |     if x.is_err() {
    |        ---------- because of this check
@@ -127,5 +163,5 @@ LL |     if x.is_err() {
 LL |         x.unwrap_err(); // will panic
    |         ^^^^^^^^^^^^^^
 
-error: aborting due to 13 previous errors
+error: aborting due to 17 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From b4775435e875e3668ad920d911fabaed58f8860f Mon Sep 17 00:00:00 2001
From: Jake Goulding <jake.goulding@gmail.com>
Date: Wed, 18 Aug 2021 16:33:50 -0400
Subject: Adjust the output of unnecessary_unwrap and provide a suggestion

---
 clippy_lints/src/unwrap.rs                         | 129 +++++++++++++++++----
 clippy_utils/src/usage.rs                          |  11 +-
 .../ui/checked_unwrap/complex_conditionals.stderr  |  39 +++++--
 .../complex_conditionals_nested.stderr             |   4 +-
 tests/ui/checked_unwrap/simple_conditionals.stderr |  36 +++---
 5 files changed, 161 insertions(+), 58 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unwrap.rs b/clippy_lints/src/unwrap.rs
index 42738bc3e1f..b2ab300c2e9 100644
--- a/clippy_lints/src/unwrap.rs
+++ b/clippy_lints/src/unwrap.rs
@@ -1,10 +1,11 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::higher;
 use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{differing_macro_contexts, usage::is_potentially_mutated};
+use clippy_utils::{differing_macro_contexts, path_to_local, usage::is_potentially_mutated};
 use if_chain::if_chain;
+use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_expr, walk_fn, FnKind, NestedVisitorMap, Visitor};
-use rustc_hir::{BinOpKind, Body, Expr, ExprKind, FnDecl, HirId, Path, QPath, UnOp};
+use rustc_hir::{BinOpKind, Body, Expr, ExprKind, FnDecl, HirId, PathSegment, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::map::Map;
 use rustc_middle::lint::in_external_macro;
@@ -74,26 +75,61 @@ struct UnwrappableVariablesVisitor<'a, 'tcx> {
     unwrappables: Vec<UnwrapInfo<'tcx>>,
     cx: &'a LateContext<'tcx>,
 }
+
+/// What kind of unwrappable this is.
+#[derive(Copy, Clone, Debug)]
+enum UnwrappableKind {
+    Option,
+    Result,
+}
+
+impl UnwrappableKind {
+    fn success_variant_pattern(self) -> &'static str {
+        match self {
+            UnwrappableKind::Option => "Some(..)",
+            UnwrappableKind::Result => "Ok(..)",
+        }
+    }
+
+    fn error_variant_pattern(self) -> &'static str {
+        match self {
+            UnwrappableKind::Option => "None",
+            UnwrappableKind::Result => "Err(..)",
+        }
+    }
+}
+
 /// Contains information about whether a variable can be unwrapped.
 #[derive(Copy, Clone, Debug)]
 struct UnwrapInfo<'tcx> {
     /// The variable that is checked
-    ident: &'tcx Path<'tcx>,
+    local_id: HirId,
+    /// The if itself
+    if_expr: &'tcx Expr<'tcx>,
     /// The check, like `x.is_ok()`
     check: &'tcx Expr<'tcx>,
+    /// The check's name, like `is_ok`
+    check_name: &'tcx PathSegment<'tcx>,
     /// The branch where the check takes place, like `if x.is_ok() { .. }`
     branch: &'tcx Expr<'tcx>,
     /// Whether `is_some()` or `is_ok()` was called (as opposed to `is_err()` or `is_none()`).
     safe_to_unwrap: bool,
+    /// What kind of unwrappable this is.
+    kind: UnwrappableKind,
+    /// If the check is the entire condition (`if x.is_ok()`) or only a part of it (`foo() &&
+    /// x.is_ok()`)
+    is_entire_condition: bool,
 }
 
 /// Collects the information about unwrappable variables from an if condition
 /// The `invert` argument tells us whether the condition is negated.
 fn collect_unwrap_info<'tcx>(
     cx: &LateContext<'tcx>,
+    if_expr: &'tcx Expr<'_>,
     expr: &'tcx Expr<'_>,
     branch: &'tcx Expr<'_>,
     invert: bool,
+    is_entire_condition: bool,
 ) -> Vec<UnwrapInfo<'tcx>> {
     fn is_relevant_option_call(cx: &LateContext<'_>, ty: Ty<'_>, method_name: &str) -> bool {
         is_type_diagnostic_item(cx, ty, sym::option_type) && ["is_some", "is_none"].contains(&method_name)
@@ -106,18 +142,18 @@ fn collect_unwrap_info<'tcx>(
     if let ExprKind::Binary(op, left, right) = &expr.kind {
         match (invert, op.node) {
             (false, BinOpKind::And | BinOpKind::BitAnd) | (true, BinOpKind::Or | BinOpKind::BitOr) => {
-                let mut unwrap_info = collect_unwrap_info(cx, left, branch, invert);
-                unwrap_info.append(&mut collect_unwrap_info(cx, right, branch, invert));
+                let mut unwrap_info = collect_unwrap_info(cx, if_expr, left, branch, invert, false);
+                unwrap_info.append(&mut collect_unwrap_info(cx, if_expr, right, branch, invert, false));
                 return unwrap_info;
             },
             _ => (),
         }
     } else if let ExprKind::Unary(UnOp::Not, expr) = &expr.kind {
-        return collect_unwrap_info(cx, expr, branch, !invert);
+        return collect_unwrap_info(cx, if_expr, expr, branch, !invert, false);
     } else {
         if_chain! {
             if let ExprKind::MethodCall(method_name, _, args, _) = &expr.kind;
-            if let ExprKind::Path(QPath::Resolved(None, path)) = &args[0].kind;
+            if let Some(local_id) = path_to_local(&args[0]);
             let ty = cx.typeck_results().expr_ty(&args[0]);
             let name = method_name.ident.as_str();
             if is_relevant_option_call(cx, ty, &name) || is_relevant_result_call(cx, ty, &name);
@@ -129,7 +165,24 @@ fn collect_unwrap_info<'tcx>(
                     _ => unreachable!(),
                 };
                 let safe_to_unwrap = unwrappable != invert;
-                return vec![UnwrapInfo { ident: path, check: expr, branch, safe_to_unwrap }];
+                let kind = if is_type_diagnostic_item(cx, ty, sym::option_type) {
+                    UnwrappableKind::Option
+                } else {
+                    UnwrappableKind::Result
+                };
+
+                return vec![
+                    UnwrapInfo {
+                        local_id,
+                        if_expr,
+                        check: expr,
+                        check_name: method_name,
+                        branch,
+                        safe_to_unwrap,
+                        kind,
+                        is_entire_condition,
+                    }
+                ]
             }
         }
     }
@@ -137,11 +190,17 @@ fn collect_unwrap_info<'tcx>(
 }
 
 impl<'a, 'tcx> UnwrappableVariablesVisitor<'a, 'tcx> {
-    fn visit_branch(&mut self, cond: &'tcx Expr<'_>, branch: &'tcx Expr<'_>, else_branch: bool) {
+    fn visit_branch(
+        &mut self,
+        if_expr: &'tcx Expr<'_>,
+        cond: &'tcx Expr<'_>,
+        branch: &'tcx Expr<'_>,
+        else_branch: bool,
+    ) {
         let prev_len = self.unwrappables.len();
-        for unwrap_info in collect_unwrap_info(self.cx, cond, branch, else_branch) {
-            if is_potentially_mutated(unwrap_info.ident, cond, self.cx)
-                || is_potentially_mutated(unwrap_info.ident, branch, self.cx)
+        for unwrap_info in collect_unwrap_info(self.cx, if_expr, cond, branch, else_branch, true) {
+            if is_potentially_mutated(unwrap_info.local_id, cond, self.cx)
+                || is_potentially_mutated(unwrap_info.local_id, branch, self.cx)
             {
                 // if the variable is mutated, we don't know whether it can be unwrapped:
                 continue;
@@ -163,32 +222,62 @@ impl<'a, 'tcx> Visitor<'tcx> for UnwrappableVariablesVisitor<'a, 'tcx> {
         }
         if let Some(higher::If { cond, then, r#else }) = higher::If::hir(expr) {
             walk_expr(self, cond);
-            self.visit_branch(cond, then, false);
+            self.visit_branch(expr, cond, then, false);
             if let Some(else_inner) = r#else {
-                self.visit_branch(cond, else_inner, true);
+                self.visit_branch(expr, cond, else_inner, true);
             }
         } else {
             // find `unwrap[_err]()` calls:
             if_chain! {
                 if let ExprKind::MethodCall(method_name, _, args, _) = expr.kind;
-                if let ExprKind::Path(QPath::Resolved(None, path)) = args[0].kind;
+                if let Some(id) = path_to_local(&args[0]);
                 if [sym::unwrap, sym::expect, sym!(unwrap_err)].contains(&method_name.ident.name);
                 let call_to_unwrap = [sym::unwrap, sym::expect].contains(&method_name.ident.name);
                 if let Some(unwrappable) = self.unwrappables.iter()
-                    .find(|u| u.ident.res == path.res);
+                    .find(|u| u.local_id == id);
                 // Span contexts should not differ with the conditional branch
                 if !differing_macro_contexts(unwrappable.branch.span, expr.span);
                 if !differing_macro_contexts(unwrappable.branch.span, unwrappable.check.span);
                 then {
                     if call_to_unwrap == unwrappable.safe_to_unwrap {
+                        let is_entire_condition = unwrappable.is_entire_condition;
+                        let unwrappable_variable_name = self.cx.tcx.hir().name(unwrappable.local_id);
+                        let suggested_pattern = if call_to_unwrap {
+                            unwrappable.kind.success_variant_pattern()
+                        } else {
+                            unwrappable.kind.error_variant_pattern()
+                        };
+
                         span_lint_and_then(
                             self.cx,
                             UNNECESSARY_UNWRAP,
                             expr.span,
-                            &format!("you checked before that `{}()` cannot fail, \
-                            instead of checking and unwrapping, it's better to use `if let` or `match`",
-                            method_name.ident.name),
-                            |diag| { diag.span_label(unwrappable.check.span, "the check is happening here"); },
+                            &format!(
+                                "called `{}` on `{}` after checking its variant with `{}`",
+                                method_name.ident.name,
+                                unwrappable_variable_name,
+                                unwrappable.check_name.ident.as_str(),
+                            ),
+                            |diag| {
+                                if is_entire_condition {
+                                    diag.span_suggestion(
+                                        unwrappable.check.span.with_lo(unwrappable.if_expr.span.lo()),
+                                        "try",
+                                        format!(
+                                            "if let {} = {}",
+                                            suggested_pattern,
+                                            unwrappable_variable_name,
+                                        ),
+                                        // We don't track how the unwrapped value is used inside the
+                                        // block or suggest deleting the unwrap, so we can't offer a
+                                        // fixable solution.
+                                        Applicability::Unspecified,
+                                    );
+                                } else {
+                                    diag.span_label(unwrappable.check.span, "the check is happening here");
+                                    diag.help("try using `if let` or `match`");
+                                }
+                            },
                         );
                     } else {
                         span_lint_and_then(
diff --git a/clippy_utils/src/usage.rs b/clippy_utils/src/usage.rs
index ac885e99944..098ec175fe2 100644
--- a/clippy_utils/src/usage.rs
+++ b/clippy_utils/src/usage.rs
@@ -1,10 +1,9 @@
 use crate as utils;
 use rustc_hir as hir;
-use rustc_hir::def::Res;
 use rustc_hir::intravisit;
 use rustc_hir::intravisit::{NestedVisitorMap, Visitor};
 use rustc_hir::HirIdSet;
-use rustc_hir::{Expr, ExprKind, HirId, Path};
+use rustc_hir::{Expr, ExprKind, HirId};
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::LateContext;
 use rustc_middle::hir::map::Map;
@@ -35,12 +34,8 @@ pub fn mutated_variables<'tcx>(expr: &'tcx Expr<'_>, cx: &LateContext<'tcx>) ->
     Some(delegate.used_mutably)
 }
 
-pub fn is_potentially_mutated<'tcx>(variable: &'tcx Path<'_>, expr: &'tcx Expr<'_>, cx: &LateContext<'tcx>) -> bool {
-    if let Res::Local(id) = variable.res {
-        mutated_variables(expr, cx).map_or(true, |mutated| mutated.contains(&id))
-    } else {
-        true
-    }
+pub fn is_potentially_mutated<'tcx>(variable: HirId, expr: &'tcx Expr<'_>, cx: &LateContext<'tcx>) -> bool {
+    mutated_variables(expr, cx).map_or(true, |mutated| mutated.contains(&variable))
 }
 
 struct MutVarsDelegate {
diff --git a/tests/ui/checked_unwrap/complex_conditionals.stderr b/tests/ui/checked_unwrap/complex_conditionals.stderr
index 33bb5136ef8..46c6f69708e 100644
--- a/tests/ui/checked_unwrap/complex_conditionals.stderr
+++ b/tests/ui/checked_unwrap/complex_conditionals.stderr
@@ -1,4 +1,4 @@
-error: you checked before that `unwrap()` cannot fail, instead of checking and unwrapping, it's better to use `if let` or `match`
+error: called `unwrap` on `x` after checking its variant with `is_ok`
   --> $DIR/complex_conditionals.rs:8:9
    |
 LL |     if x.is_ok() && y.is_err() {
@@ -11,6 +11,7 @@ note: the lint level is defined here
    |
 LL | #![deny(clippy::panicking_unwrap, clippy::unnecessary_unwrap)]
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   = help: try using `if let` or `match`
 
 error: this call to `unwrap_err()` will always panic
   --> $DIR/complex_conditionals.rs:9:9
@@ -36,7 +37,7 @@ LL |     if x.is_ok() && y.is_err() {
 LL |         y.unwrap(); // will panic
    |         ^^^^^^^^^^
 
-error: you checked before that `unwrap_err()` cannot fail, instead of checking and unwrapping, it's better to use `if let` or `match`
+error: called `unwrap_err` on `y` after checking its variant with `is_err`
   --> $DIR/complex_conditionals.rs:11:9
    |
 LL |     if x.is_ok() && y.is_err() {
@@ -44,6 +45,8 @@ LL |     if x.is_ok() && y.is_err() {
 ...
 LL |         y.unwrap_err(); // unnecessary
    |         ^^^^^^^^^^^^^^
+   |
+   = help: try using `if let` or `match`
 
 error: this call to `unwrap()` will always panic
   --> $DIR/complex_conditionals.rs:25:9
@@ -54,7 +57,7 @@ LL |     if x.is_ok() || y.is_ok() {
 LL |         x.unwrap(); // will panic
    |         ^^^^^^^^^^
 
-error: you checked before that `unwrap_err()` cannot fail, instead of checking and unwrapping, it's better to use `if let` or `match`
+error: called `unwrap_err` on `x` after checking its variant with `is_ok`
   --> $DIR/complex_conditionals.rs:26:9
    |
 LL |     if x.is_ok() || y.is_ok() {
@@ -62,6 +65,8 @@ LL |     if x.is_ok() || y.is_ok() {
 ...
 LL |         x.unwrap_err(); // unnecessary
    |         ^^^^^^^^^^^^^^
+   |
+   = help: try using `if let` or `match`
 
 error: this call to `unwrap()` will always panic
   --> $DIR/complex_conditionals.rs:27:9
@@ -72,7 +77,7 @@ LL |     if x.is_ok() || y.is_ok() {
 LL |         y.unwrap(); // will panic
    |         ^^^^^^^^^^
 
-error: you checked before that `unwrap_err()` cannot fail, instead of checking and unwrapping, it's better to use `if let` or `match`
+error: called `unwrap_err` on `y` after checking its variant with `is_ok`
   --> $DIR/complex_conditionals.rs:28:9
    |
 LL |     if x.is_ok() || y.is_ok() {
@@ -80,14 +85,18 @@ LL |     if x.is_ok() || y.is_ok() {
 ...
 LL |         y.unwrap_err(); // unnecessary
    |         ^^^^^^^^^^^^^^
+   |
+   = help: try using `if let` or `match`
 
-error: you checked before that `unwrap()` cannot fail, instead of checking and unwrapping, it's better to use `if let` or `match`
+error: called `unwrap` on `x` after checking its variant with `is_ok`
   --> $DIR/complex_conditionals.rs:32:9
    |
 LL |     if x.is_ok() && !(y.is_ok() || z.is_err()) {
    |        --------- the check is happening here
 LL |         x.unwrap(); // unnecessary
    |         ^^^^^^^^^^
+   |
+   = help: try using `if let` or `match`
 
 error: this call to `unwrap_err()` will always panic
   --> $DIR/complex_conditionals.rs:33:9
@@ -107,7 +116,7 @@ LL |     if x.is_ok() && !(y.is_ok() || z.is_err()) {
 LL |         y.unwrap(); // will panic
    |         ^^^^^^^^^^
 
-error: you checked before that `unwrap_err()` cannot fail, instead of checking and unwrapping, it's better to use `if let` or `match`
+error: called `unwrap_err` on `y` after checking its variant with `is_ok`
   --> $DIR/complex_conditionals.rs:35:9
    |
 LL |     if x.is_ok() && !(y.is_ok() || z.is_err()) {
@@ -115,8 +124,10 @@ LL |     if x.is_ok() && !(y.is_ok() || z.is_err()) {
 ...
 LL |         y.unwrap_err(); // unnecessary
    |         ^^^^^^^^^^^^^^
+   |
+   = help: try using `if let` or `match`
 
-error: you checked before that `unwrap()` cannot fail, instead of checking and unwrapping, it's better to use `if let` or `match`
+error: called `unwrap` on `z` after checking its variant with `is_err`
   --> $DIR/complex_conditionals.rs:36:9
    |
 LL |     if x.is_ok() && !(y.is_ok() || z.is_err()) {
@@ -124,6 +135,8 @@ LL |     if x.is_ok() && !(y.is_ok() || z.is_err()) {
 ...
 LL |         z.unwrap(); // unnecessary
    |         ^^^^^^^^^^
+   |
+   = help: try using `if let` or `match`
 
 error: this call to `unwrap_err()` will always panic
   --> $DIR/complex_conditionals.rs:37:9
@@ -143,7 +156,7 @@ LL |     if x.is_ok() || !(y.is_ok() && z.is_err()) {
 LL |         x.unwrap(); // will panic
    |         ^^^^^^^^^^
 
-error: you checked before that `unwrap_err()` cannot fail, instead of checking and unwrapping, it's better to use `if let` or `match`
+error: called `unwrap_err` on `x` after checking its variant with `is_ok`
   --> $DIR/complex_conditionals.rs:46:9
    |
 LL |     if x.is_ok() || !(y.is_ok() && z.is_err()) {
@@ -151,8 +164,10 @@ LL |     if x.is_ok() || !(y.is_ok() && z.is_err()) {
 ...
 LL |         x.unwrap_err(); // unnecessary
    |         ^^^^^^^^^^^^^^
+   |
+   = help: try using `if let` or `match`
 
-error: you checked before that `unwrap()` cannot fail, instead of checking and unwrapping, it's better to use `if let` or `match`
+error: called `unwrap` on `y` after checking its variant with `is_ok`
   --> $DIR/complex_conditionals.rs:47:9
    |
 LL |     if x.is_ok() || !(y.is_ok() && z.is_err()) {
@@ -160,6 +175,8 @@ LL |     if x.is_ok() || !(y.is_ok() && z.is_err()) {
 ...
 LL |         y.unwrap(); // unnecessary
    |         ^^^^^^^^^^
+   |
+   = help: try using `if let` or `match`
 
 error: this call to `unwrap_err()` will always panic
   --> $DIR/complex_conditionals.rs:48:9
@@ -179,7 +196,7 @@ LL |     if x.is_ok() || !(y.is_ok() && z.is_err()) {
 LL |         z.unwrap(); // will panic
    |         ^^^^^^^^^^
 
-error: you checked before that `unwrap_err()` cannot fail, instead of checking and unwrapping, it's better to use `if let` or `match`
+error: called `unwrap_err` on `z` after checking its variant with `is_err`
   --> $DIR/complex_conditionals.rs:50:9
    |
 LL |     if x.is_ok() || !(y.is_ok() && z.is_err()) {
@@ -187,6 +204,8 @@ LL |     if x.is_ok() || !(y.is_ok() && z.is_err()) {
 ...
 LL |         z.unwrap_err(); // unnecessary
    |         ^^^^^^^^^^^^^^
+   |
+   = help: try using `if let` or `match`
 
 error: aborting due to 20 previous errors
 
diff --git a/tests/ui/checked_unwrap/complex_conditionals_nested.stderr b/tests/ui/checked_unwrap/complex_conditionals_nested.stderr
index a01f7f956f6..542ab53300c 100644
--- a/tests/ui/checked_unwrap/complex_conditionals_nested.stderr
+++ b/tests/ui/checked_unwrap/complex_conditionals_nested.stderr
@@ -1,8 +1,8 @@
-error: you checked before that `unwrap()` cannot fail, instead of checking and unwrapping, it's better to use `if let` or `match`
+error: called `unwrap` on `x` after checking its variant with `is_some`
   --> $DIR/complex_conditionals_nested.rs:8:13
    |
 LL |         if x.is_some() {
-   |            ----------- the check is happening here
+   |         -------------- help: try: `if let Some(..) = x`
 LL |             x.unwrap(); // unnecessary
    |             ^^^^^^^^^^
    |
diff --git a/tests/ui/checked_unwrap/simple_conditionals.stderr b/tests/ui/checked_unwrap/simple_conditionals.stderr
index 7127ff89b31..82f26954380 100644
--- a/tests/ui/checked_unwrap/simple_conditionals.stderr
+++ b/tests/ui/checked_unwrap/simple_conditionals.stderr
@@ -1,8 +1,8 @@
-error: you checked before that `unwrap()` cannot fail, instead of checking and unwrapping, it's better to use `if let` or `match`
+error: called `unwrap` on `x` after checking its variant with `is_some`
   --> $DIR/simple_conditionals.rs:39:9
    |
 LL |     if x.is_some() {
-   |        ----------- the check is happening here
+   |     -------------- help: try: `if let Some(..) = x`
 LL |         x.unwrap(); // unnecessary
    |         ^^^^^^^^^^
    |
@@ -12,11 +12,11 @@ note: the lint level is defined here
 LL | #![deny(clippy::panicking_unwrap, clippy::unnecessary_unwrap)]
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: you checked before that `expect()` cannot fail, instead of checking and unwrapping, it's better to use `if let` or `match`
+error: called `expect` on `x` after checking its variant with `is_some`
   --> $DIR/simple_conditionals.rs:40:9
    |
 LL |     if x.is_some() {
-   |        ----------- the check is happening here
+   |     -------------- help: try: `if let Some(..) = x`
 LL |         x.unwrap(); // unnecessary
 LL |         x.expect("an error message"); // unnecessary
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -53,20 +53,20 @@ LL |     if x.is_none() {
 LL |         x.unwrap(); // will panic
    |         ^^^^^^^^^^
 
-error: you checked before that `unwrap()` cannot fail, instead of checking and unwrapping, it's better to use `if let` or `match`
+error: called `unwrap` on `x` after checking its variant with `is_none`
   --> $DIR/simple_conditionals.rs:48:9
    |
 LL |     if x.is_none() {
-   |        ----------- the check is happening here
+   |     -------------- help: try: `if let Some(..) = x`
 ...
 LL |         x.unwrap(); // unnecessary
    |         ^^^^^^^^^^
 
-error: you checked before that `unwrap()` cannot fail, instead of checking and unwrapping, it's better to use `if let` or `match`
+error: called `unwrap` on `x` after checking its variant with `is_some`
   --> $DIR/simple_conditionals.rs:7:13
    |
 LL |         if $a.is_some() {
-   |            ------------ the check is happening here
+   |         --------------- help: try: `if let Some(..) = x`
 LL |             $a.unwrap(); // unnecessary
    |             ^^^^^^^^^^^
 ...
@@ -75,19 +75,19 @@ LL |     m!(x);
    |
    = note: this error originates in the macro `m` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: you checked before that `unwrap()` cannot fail, instead of checking and unwrapping, it's better to use `if let` or `match`
+error: called `unwrap` on `x` after checking its variant with `is_ok`
   --> $DIR/simple_conditionals.rs:56:9
    |
 LL |     if x.is_ok() {
-   |        --------- the check is happening here
+   |     ------------ help: try: `if let Ok(..) = x`
 LL |         x.unwrap(); // unnecessary
    |         ^^^^^^^^^^
 
-error: you checked before that `expect()` cannot fail, instead of checking and unwrapping, it's better to use `if let` or `match`
+error: called `expect` on `x` after checking its variant with `is_ok`
   --> $DIR/simple_conditionals.rs:57:9
    |
 LL |     if x.is_ok() {
-   |        --------- the check is happening here
+   |     ------------ help: try: `if let Ok(..) = x`
 LL |         x.unwrap(); // unnecessary
 LL |         x.expect("an error message"); // unnecessary
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -119,11 +119,11 @@ LL |     if x.is_ok() {
 LL |         x.expect("an error message"); // will panic
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: you checked before that `unwrap_err()` cannot fail, instead of checking and unwrapping, it's better to use `if let` or `match`
+error: called `unwrap_err` on `x` after checking its variant with `is_ok`
   --> $DIR/simple_conditionals.rs:62:9
    |
 LL |     if x.is_ok() {
-   |        --------- the check is happening here
+   |     ------------ help: try: `if let Err(..) = x`
 ...
 LL |         x.unwrap_err(); // unnecessary
    |         ^^^^^^^^^^^^^^
@@ -136,20 +136,20 @@ LL |     if x.is_err() {
 LL |         x.unwrap(); // will panic
    |         ^^^^^^^^^^
 
-error: you checked before that `unwrap_err()` cannot fail, instead of checking and unwrapping, it's better to use `if let` or `match`
+error: called `unwrap_err` on `x` after checking its variant with `is_err`
   --> $DIR/simple_conditionals.rs:66:9
    |
 LL |     if x.is_err() {
-   |        ---------- the check is happening here
+   |     ------------- help: try: `if let Err(..) = x`
 LL |         x.unwrap(); // will panic
 LL |         x.unwrap_err(); // unnecessary
    |         ^^^^^^^^^^^^^^
 
-error: you checked before that `unwrap()` cannot fail, instead of checking and unwrapping, it's better to use `if let` or `match`
+error: called `unwrap` on `x` after checking its variant with `is_err`
   --> $DIR/simple_conditionals.rs:68:9
    |
 LL |     if x.is_err() {
-   |        ---------- the check is happening here
+   |     ------------- help: try: `if let Ok(..) = x`
 ...
 LL |         x.unwrap(); // unnecessary
    |         ^^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From 265b8ec622e0ab9c65109ba6b98646ecf12868c7 Mon Sep 17 00:00:00 2001
From: Michael Wright <mikerite@lavabit.com>
Date: Fri, 3 Sep 2021 06:41:30 +0200
Subject: Reorder approx_consts constant to match rust docs

---
 clippy_lints/src/approx_const.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/approx_const.rs b/clippy_lints/src/approx_const.rs
index 6100f4e435a..b04c50e9d04 100644
--- a/clippy_lints/src/approx_const.rs
+++ b/clippy_lints/src/approx_const.rs
@@ -48,12 +48,12 @@ const KNOWN_CONSTS: [(f64, &str, usize); 18] = [
     (f64::FRAC_PI_4, "FRAC_PI_4", 5),
     (f64::FRAC_PI_6, "FRAC_PI_6", 5),
     (f64::FRAC_PI_8, "FRAC_PI_8", 5),
-    (f64::LN_10, "LN_10", 5),
     (f64::LN_2, "LN_2", 5),
-    (f64::LOG10_E, "LOG10_E", 5),
-    (f64::LOG2_E, "LOG2_E", 5),
+    (f64::LN_10, "LN_10", 5),
     (f64::LOG2_10, "LOG2_10", 5),
+    (f64::LOG2_E, "LOG2_E", 5),
     (f64::LOG10_2, "LOG10_2", 5),
+    (f64::LOG10_E, "LOG10_E", 5),
     (f64::PI, "PI", 3),
     (f64::SQRT_2, "SQRT_2", 5),
 ];
-- 
cgit 1.4.1-3-g733a5


From a23af89447d467c38ed2e5c9358cc81b47dc346d Mon Sep 17 00:00:00 2001
From: Michael Wright <mikerite@lavabit.com>
Date: Fri, 3 Sep 2021 08:34:34 +0200
Subject: Make `approx_const` MSRV aware

Fixes #7623.
---
 clippy_lints/src/approx_const.rs      | 123 +++++++++++++++++++---------------
 clippy_lints/src/lib.rs               |   2 +-
 clippy_utils/src/msrvs.rs             |   1 +
 tests/ui/min_rust_version_attr.rs     |   5 ++
 tests/ui/min_rust_version_attr.stderr |   8 +--
 5 files changed, 81 insertions(+), 58 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/approx_const.rs b/clippy_lints/src/approx_const.rs
index b04c50e9d04..069a10e9b3a 100644
--- a/clippy_lints/src/approx_const.rs
+++ b/clippy_lints/src/approx_const.rs
@@ -1,8 +1,10 @@
 use clippy_utils::diagnostics::span_lint;
+use clippy_utils::{meets_msrv, msrvs};
 use rustc_ast::ast::{FloatTy, LitFloatType, LitKind};
 use rustc_hir::{Expr, ExprKind};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_semver::RustcVersion;
+use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::symbol;
 use std::f64::consts as f64;
 
@@ -36,68 +38,83 @@ declare_clippy_lint! {
     "the approximate of a known float constant (in `std::fXX::consts`)"
 }
 
-// Tuples are of the form (constant, name, min_digits)
-const KNOWN_CONSTS: [(f64, &str, usize); 18] = [
-    (f64::E, "E", 4),
-    (f64::FRAC_1_PI, "FRAC_1_PI", 4),
-    (f64::FRAC_1_SQRT_2, "FRAC_1_SQRT_2", 5),
-    (f64::FRAC_2_PI, "FRAC_2_PI", 5),
-    (f64::FRAC_2_SQRT_PI, "FRAC_2_SQRT_PI", 5),
-    (f64::FRAC_PI_2, "FRAC_PI_2", 5),
-    (f64::FRAC_PI_3, "FRAC_PI_3", 5),
-    (f64::FRAC_PI_4, "FRAC_PI_4", 5),
-    (f64::FRAC_PI_6, "FRAC_PI_6", 5),
-    (f64::FRAC_PI_8, "FRAC_PI_8", 5),
-    (f64::LN_2, "LN_2", 5),
-    (f64::LN_10, "LN_10", 5),
-    (f64::LOG2_10, "LOG2_10", 5),
-    (f64::LOG2_E, "LOG2_E", 5),
-    (f64::LOG10_2, "LOG10_2", 5),
-    (f64::LOG10_E, "LOG10_E", 5),
-    (f64::PI, "PI", 3),
-    (f64::SQRT_2, "SQRT_2", 5),
+// Tuples are of the form (constant, name, min_digits, msrv)
+const KNOWN_CONSTS: [(f64, &str, usize, Option<RustcVersion>); 18] = [
+    (f64::E, "E", 4, None),
+    (f64::FRAC_1_PI, "FRAC_1_PI", 4, None),
+    (f64::FRAC_1_SQRT_2, "FRAC_1_SQRT_2", 5, None),
+    (f64::FRAC_2_PI, "FRAC_2_PI", 5, None),
+    (f64::FRAC_2_SQRT_PI, "FRAC_2_SQRT_PI", 5, None),
+    (f64::FRAC_PI_2, "FRAC_PI_2", 5, None),
+    (f64::FRAC_PI_3, "FRAC_PI_3", 5, None),
+    (f64::FRAC_PI_4, "FRAC_PI_4", 5, None),
+    (f64::FRAC_PI_6, "FRAC_PI_6", 5, None),
+    (f64::FRAC_PI_8, "FRAC_PI_8", 5, None),
+    (f64::LN_2, "LN_2", 5, None),
+    (f64::LN_10, "LN_10", 5, None),
+    (f64::LOG2_10, "LOG2_10", 5, Some(msrvs::LOG2_10)),
+    (f64::LOG2_E, "LOG2_E", 5, None),
+    (f64::LOG10_2, "LOG10_2", 5, Some(msrvs::LOG10_2)),
+    (f64::LOG10_E, "LOG10_E", 5, None),
+    (f64::PI, "PI", 3, None),
+    (f64::SQRT_2, "SQRT_2", 5, None),
 ];
 
-declare_lint_pass!(ApproxConstant => [APPROX_CONSTANT]);
+pub struct ApproxConstant {
+    msrv: Option<RustcVersion>,
+}
 
-impl<'tcx> LateLintPass<'tcx> for ApproxConstant {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
-        if let ExprKind::Lit(lit) = &e.kind {
-            check_lit(cx, &lit.node, e);
+impl ApproxConstant {
+    #[must_use]
+    pub fn new(msrv: Option<RustcVersion>) -> Self {
+        Self { msrv }
+    }
+
+    fn check_lit(&self, cx: &LateContext<'_>, lit: &LitKind, e: &Expr<'_>) {
+        match *lit {
+            LitKind::Float(s, LitFloatType::Suffixed(fty)) => match fty {
+                FloatTy::F32 => self.check_known_consts(cx, e, s, "f32"),
+                FloatTy::F64 => self.check_known_consts(cx, e, s, "f64"),
+            },
+            LitKind::Float(s, LitFloatType::Unsuffixed) => self.check_known_consts(cx, e, s, "f{32, 64}"),
+            _ => (),
         }
     }
-}
 
-fn check_lit(cx: &LateContext<'_>, lit: &LitKind, e: &Expr<'_>) {
-    match *lit {
-        LitKind::Float(s, LitFloatType::Suffixed(fty)) => match fty {
-            FloatTy::F32 => check_known_consts(cx, e, s, "f32"),
-            FloatTy::F64 => check_known_consts(cx, e, s, "f64"),
-        },
-        LitKind::Float(s, LitFloatType::Unsuffixed) => check_known_consts(cx, e, s, "f{32, 64}"),
-        _ => (),
+    fn check_known_consts(&self, cx: &LateContext<'_>, e: &Expr<'_>, s: symbol::Symbol, module: &str) {
+        let s = s.as_str();
+        if s.parse::<f64>().is_ok() {
+            for &(constant, name, min_digits, msrv) in &KNOWN_CONSTS {
+                if is_approx_const(constant, &s, min_digits)
+                    && msrv.as_ref().map_or(true, |msrv| meets_msrv(self.msrv.as_ref(), msrv))
+                {
+                    span_lint(
+                        cx,
+                        APPROX_CONSTANT,
+                        e.span,
+                        &format!(
+                            "approximate value of `{}::consts::{}` found. \
+                             Consider using it directly",
+                            module, &name
+                        ),
+                    );
+                    return;
+                }
+            }
+        }
     }
 }
 
-fn check_known_consts(cx: &LateContext<'_>, e: &Expr<'_>, s: symbol::Symbol, module: &str) {
-    let s = s.as_str();
-    if s.parse::<f64>().is_ok() {
-        for &(constant, name, min_digits) in &KNOWN_CONSTS {
-            if is_approx_const(constant, &s, min_digits) {
-                span_lint(
-                    cx,
-                    APPROX_CONSTANT,
-                    e.span,
-                    &format!(
-                        "approximate value of `{}::consts::{}` found. \
-                         Consider using it directly",
-                        module, &name
-                    ),
-                );
-                return;
-            }
+impl_lint_pass!(ApproxConstant => [APPROX_CONSTANT]);
+
+impl<'tcx> LateLintPass<'tcx> for ApproxConstant {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
+        if let ExprKind::Lit(lit) = &e.kind {
+            self.check_lit(cx, &lit.node, e);
         }
     }
+
+    extract_msrv_attr!(LateContext);
 }
 
 /// Returns `false` if the number of significant figures in `value` are
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 2b76eacb7d6..0d9b81e3d75 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1865,7 +1865,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(needless_bool::NeedlessBool));
     store.register_late_pass(|| Box::new(needless_bool::BoolComparison));
     store.register_late_pass(|| Box::new(needless_for_each::NeedlessForEach));
-    store.register_late_pass(|| Box::new(approx_const::ApproxConstant));
     store.register_late_pass(|| Box::new(misc::MiscLints));
     store.register_late_pass(|| Box::new(eta_reduction::EtaReduction));
     store.register_late_pass(|| Box::new(identity_op::IdentityOp));
@@ -1894,6 +1893,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     });
 
     let avoid_breaking_exported_api = conf.avoid_breaking_exported_api;
+    store.register_late_pass(move || Box::new(approx_const::ApproxConstant::new(msrv)));
     store.register_late_pass(move || Box::new(methods::Methods::new(avoid_breaking_exported_api, msrv)));
     store.register_late_pass(move || Box::new(matches::Matches::new(msrv)));
     store.register_early_pass(move || Box::new(manual_non_exhaustive::ManualNonExhaustive::new(msrv)));
diff --git a/clippy_utils/src/msrvs.rs b/clippy_utils/src/msrvs.rs
index 14234d9c9cb..6fab17f07fe 100644
--- a/clippy_utils/src/msrvs.rs
+++ b/clippy_utils/src/msrvs.rs
@@ -17,6 +17,7 @@ msrv_aliases! {
     1,50,0 { BOOL_THEN }
     1,46,0 { CONST_IF_MATCH }
     1,45,0 { STR_STRIP_PREFIX }
+    1,43,0 { LOG2_10, LOG10_2 }
     1,42,0 { MATCHES_MACRO }
     1,41,0 { RE_REBALANCING_COHERENCE, RESULT_MAP_OR_ELSE }
     1,40,0 { MEM_TAKE, NON_EXHAUSTIVE, OPTION_AS_DEREF }
diff --git a/tests/ui/min_rust_version_attr.rs b/tests/ui/min_rust_version_attr.rs
index 7f9f7ddc535..8d9fc5a864d 100644
--- a/tests/ui/min_rust_version_attr.rs
+++ b/tests/ui/min_rust_version_attr.rs
@@ -4,6 +4,11 @@
 
 use std::ops::{Deref, RangeFrom};
 
+fn approx_const() {
+    let log2_10 = 3.321928094887362;
+    let log10_2 = 0.301029995663981;
+}
+
 fn cloned_instead_of_copied() {
     let _ = [1].iter().cloned();
 }
diff --git a/tests/ui/min_rust_version_attr.stderr b/tests/ui/min_rust_version_attr.stderr
index a2e4e86ed6b..360dcfb230c 100644
--- a/tests/ui/min_rust_version_attr.stderr
+++ b/tests/ui/min_rust_version_attr.stderr
@@ -1,12 +1,12 @@
 error: stripping a prefix manually
-  --> $DIR/min_rust_version_attr.rs:160:24
+  --> $DIR/min_rust_version_attr.rs:165:24
    |
 LL |             assert_eq!(s["hello, ".len()..].to_uppercase(), "WORLD!");
    |                        ^^^^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::manual-strip` implied by `-D warnings`
 note: the prefix was tested here
-  --> $DIR/min_rust_version_attr.rs:159:9
+  --> $DIR/min_rust_version_attr.rs:164:9
    |
 LL |         if s.starts_with("hello, ") {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -17,13 +17,13 @@ LL ~             assert_eq!(<stripped>.to_uppercase(), "WORLD!");
    |
 
 error: stripping a prefix manually
-  --> $DIR/min_rust_version_attr.rs:172:24
+  --> $DIR/min_rust_version_attr.rs:177:24
    |
 LL |             assert_eq!(s["hello, ".len()..].to_uppercase(), "WORLD!");
    |                        ^^^^^^^^^^^^^^^^^^^^
    |
 note: the prefix was tested here
-  --> $DIR/min_rust_version_attr.rs:171:9
+  --> $DIR/min_rust_version_attr.rs:176:9
    |
 LL |         if s.starts_with("hello, ") {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From b2f01ef6f600b249416cf55426716091582a3a76 Mon Sep 17 00:00:00 2001
From: chansuke <moonset20@gmail.com>
Date: Sat, 4 Sep 2021 21:07:25 +0900
Subject: Fix documentation of eval_order_dependence

---
 clippy_lints/src/eval_order_dependence.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/eval_order_dependence.rs b/clippy_lints/src/eval_order_dependence.rs
index f72a1e446d5..8714ce90164 100644
--- a/clippy_lints/src/eval_order_dependence.rs
+++ b/clippy_lints/src/eval_order_dependence.rs
@@ -15,8 +15,8 @@ declare_clippy_lint! {
     /// order of sub-expressions.
     ///
     /// ### Why is this bad?
-    /// It is often confusing to read. In addition, the
-    /// sub-expression evaluation order for Rust is not well documented.
+    /// It is often confusing to read. As described [here](https://doc.rust-lang.org/reference/expressions.html?highlight=subexpression#evaluation-order-of-operands),
+    /// the operands of these expressions are evaluated before applying the effects of the expression.
     ///
     /// ### Known problems
     /// Code which intentionally depends on the evaluation
-- 
cgit 1.4.1-3-g733a5


From 4184cc369a8e08bc74560baf0f47bab14423e26e Mon Sep 17 00:00:00 2001
From: lengyijun <sjtu5140809011@gmail.com>
Date: Tue, 24 Aug 2021 22:06:46 +0800
Subject: needless_option_as_deref

---
 CHANGELOG.md                                 |  1 +
 clippy_lints/src/lib.rs                      |  5 ++
 clippy_lints/src/loops/never_loop.rs         |  4 +-
 clippy_lints/src/needless_option_as_deref.rs | 69 ++++++++++++++++++++++++++++
 tests/ui/needless_option_as_deref.fixed      | 13 ++++++
 tests/ui/needless_option_as_deref.rs         | 13 ++++++
 tests/ui/needless_option_as_deref.stderr     | 16 +++++++
 7 files changed, 119 insertions(+), 2 deletions(-)
 create mode 100644 clippy_lints/src/needless_option_as_deref.rs
 create mode 100644 tests/ui/needless_option_as_deref.fixed
 create mode 100644 tests/ui/needless_option_as_deref.rs
 create mode 100644 tests/ui/needless_option_as_deref.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index d86414a87f4..0e131ed02af 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2822,6 +2822,7 @@ Released 2018-09-13
 [`needless_doctest_main`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_doctest_main
 [`needless_for_each`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_for_each
 [`needless_lifetimes`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_lifetimes
+[`needless_option_as_deref`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_option_as_deref
 [`needless_pass_by_value`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_pass_by_value
 [`needless_question_mark`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_question_mark
 [`needless_range_loop`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_range_loop
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 2b76eacb7d6..64b7ff199be 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -289,6 +289,7 @@ mod needless_borrow;
 mod needless_borrowed_ref;
 mod needless_continue;
 mod needless_for_each;
+mod needless_option_as_deref;
 mod needless_pass_by_value;
 mod needless_question_mark;
 mod needless_update;
@@ -847,6 +848,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         needless_borrowed_ref::NEEDLESS_BORROWED_REFERENCE,
         needless_continue::NEEDLESS_CONTINUE,
         needless_for_each::NEEDLESS_FOR_EACH,
+        needless_option_as_deref::NEEDLESS_OPTION_AS_DEREF,
         needless_pass_by_value::NEEDLESS_PASS_BY_VALUE,
         needless_question_mark::NEEDLESS_QUESTION_MARK,
         needless_update::NEEDLESS_UPDATE,
@@ -1374,6 +1376,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(needless_bool::NEEDLESS_BOOL),
         LintId::of(needless_borrow::NEEDLESS_BORROW),
         LintId::of(needless_borrowed_ref::NEEDLESS_BORROWED_REFERENCE),
+        LintId::of(needless_option_as_deref::NEEDLESS_OPTION_AS_DEREF),
         LintId::of(needless_question_mark::NEEDLESS_QUESTION_MARK),
         LintId::of(needless_update::NEEDLESS_UPDATE),
         LintId::of(neg_cmp_op_on_partial_ord::NEG_CMP_OP_ON_PARTIAL_ORD),
@@ -1636,6 +1639,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(needless_bool::BOOL_COMPARISON),
         LintId::of(needless_bool::NEEDLESS_BOOL),
         LintId::of(needless_borrowed_ref::NEEDLESS_BORROWED_REFERENCE),
+        LintId::of(needless_option_as_deref::NEEDLESS_OPTION_AS_DEREF),
         LintId::of(needless_question_mark::NEEDLESS_QUESTION_MARK),
         LintId::of(needless_update::NEEDLESS_UPDATE),
         LintId::of(neg_cmp_op_on_partial_ord::NEG_CMP_OP_ON_PARTIAL_ORD),
@@ -1863,6 +1867,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(ptr::Ptr));
     store.register_late_pass(|| Box::new(ptr_eq::PtrEq));
     store.register_late_pass(|| Box::new(needless_bool::NeedlessBool));
+    store.register_late_pass(|| Box::new(needless_option_as_deref::OptionNeedlessDeref));
     store.register_late_pass(|| Box::new(needless_bool::BoolComparison));
     store.register_late_pass(|| Box::new(needless_for_each::NeedlessForEach));
     store.register_late_pass(|| Box::new(approx_const::ApproxConstant));
diff --git a/clippy_lints/src/loops/never_loop.rs b/clippy_lints/src/loops/never_loop.rs
index 2c46971d5f7..41956650c9f 100644
--- a/clippy_lints/src/loops/never_loop.rs
+++ b/clippy_lints/src/loops/never_loop.rs
@@ -87,7 +87,7 @@ fn combine_branches(b1: NeverLoopResult, b2: NeverLoopResult) -> NeverLoopResult
 
 fn never_loop_block(block: &Block<'_>, main_loop_id: HirId) -> NeverLoopResult {
     let stmts = block.stmts.iter().map(stmt_to_expr);
-    let expr = once(block.expr.as_deref());
+    let expr = once(block.expr);
     let mut iter = stmts.chain(expr).flatten();
     never_loop_expr_seq(&mut iter, main_loop_id)
 }
@@ -100,7 +100,7 @@ fn never_loop_expr_seq<'a, T: Iterator<Item = &'a Expr<'a>>>(es: &mut T, main_lo
 fn stmt_to_expr<'tcx>(stmt: &Stmt<'tcx>) -> Option<&'tcx Expr<'tcx>> {
     match stmt.kind {
         StmtKind::Semi(e, ..) | StmtKind::Expr(e, ..) => Some(e),
-        StmtKind::Local(local) => local.init.as_deref(),
+        StmtKind::Local(local) => local.init,
         StmtKind::Item(..) => None,
     }
 }
diff --git a/clippy_lints/src/needless_option_as_deref.rs b/clippy_lints/src/needless_option_as_deref.rs
new file mode 100644
index 00000000000..67c697da04f
--- /dev/null
+++ b/clippy_lints/src/needless_option_as_deref.rs
@@ -0,0 +1,69 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::in_macro;
+use clippy_utils::source::snippet_opt;
+use clippy_utils::ty::is_type_diagnostic_item;
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::TyS;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::symbol::sym;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for no-op uses of Option::{as_deref,as_deref_mut},
+    /// for example, `Option<&T>::as_deref()` returns the same type.
+    ///
+    /// ### Why is this bad?
+    /// Redundant code and improving readability.
+    ///
+    /// ### Example
+    /// ```rust
+    /// let a = Some(&1);
+    /// let b = a.as_deref(); // goes from Option<&i32> to Option<&i32>
+    /// ```
+    /// Could be written as:
+    /// ```rust
+    /// let a = Some(&1);
+    /// let b = a;
+    /// ```
+    pub NEEDLESS_OPTION_AS_DEREF,
+    complexity,
+    "no-op use of `deref` or `deref_mut` method to `Option`."
+}
+
+declare_lint_pass!(OptionNeedlessDeref=> [
+    NEEDLESS_OPTION_AS_DEREF,
+]);
+
+impl<'tcx> LateLintPass<'tcx> for OptionNeedlessDeref {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        if expr.span.from_expansion() {
+            return;
+        }
+        if in_macro(expr.span) {
+            return;
+        }
+        let typeck = cx.typeck_results();
+        let outer_ty = typeck.expr_ty(expr);
+
+        if_chain! {
+            if is_type_diagnostic_item(cx,outer_ty,sym::option_type);
+            if let ExprKind::MethodCall(path, _, [sub_expr], _) = expr.kind;
+            let symbol = path.ident.as_str();
+            if symbol=="as_deref" || symbol=="as_deref_mut";
+            if TyS::same_type( outer_ty, typeck.expr_ty(sub_expr) );
+            then{
+                span_lint_and_sugg(
+                    cx,
+                    NEEDLESS_OPTION_AS_DEREF,
+                    expr.span,
+                    "derefed type is same as origin",
+                    "try this",
+                    snippet_opt(cx,sub_expr.span).unwrap(),
+                    Applicability::MachineApplicable
+                );
+            }
+        }
+    }
+}
diff --git a/tests/ui/needless_option_as_deref.fixed b/tests/ui/needless_option_as_deref.fixed
new file mode 100644
index 00000000000..d721452ae88
--- /dev/null
+++ b/tests/ui/needless_option_as_deref.fixed
@@ -0,0 +1,13 @@
+// run-rustfix
+
+#[warn(clippy::needless_option_as_deref)]
+
+fn main() {
+    // should lint
+    let _: Option<&usize> = Some(&1);
+    let _: Option<&mut usize> = Some(&mut 1);
+
+    // should not lint
+    let _ = Some(Box::new(1)).as_deref();
+    let _ = Some(Box::new(1)).as_deref_mut();
+}
diff --git a/tests/ui/needless_option_as_deref.rs b/tests/ui/needless_option_as_deref.rs
new file mode 100644
index 00000000000..bb15512adf6
--- /dev/null
+++ b/tests/ui/needless_option_as_deref.rs
@@ -0,0 +1,13 @@
+// run-rustfix
+
+#[warn(clippy::needless_option_as_deref)]
+
+fn main() {
+    // should lint
+    let _: Option<&usize> = Some(&1).as_deref();
+    let _: Option<&mut usize> = Some(&mut 1).as_deref_mut();
+
+    // should not lint
+    let _ = Some(Box::new(1)).as_deref();
+    let _ = Some(Box::new(1)).as_deref_mut();
+}
diff --git a/tests/ui/needless_option_as_deref.stderr b/tests/ui/needless_option_as_deref.stderr
new file mode 100644
index 00000000000..5dd507b4a71
--- /dev/null
+++ b/tests/ui/needless_option_as_deref.stderr
@@ -0,0 +1,16 @@
+error: derefed type is same as origin
+  --> $DIR/needless_option_as_deref.rs:7:29
+   |
+LL |     let _: Option<&usize> = Some(&1).as_deref();
+   |                             ^^^^^^^^^^^^^^^^^^^ help: try this: `Some(&1)`
+   |
+   = note: `-D clippy::needless-option-as-deref` implied by `-D warnings`
+
+error: derefed type is same as origin
+  --> $DIR/needless_option_as_deref.rs:8:33
+   |
+LL |     let _: Option<&mut usize> = Some(&mut 1).as_deref_mut();
+   |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `Some(&mut 1)`
+
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 8221f9e7950120c940511ca914c9724cc89b56d5 Mon Sep 17 00:00:00 2001
From: hamidreza kalbasi <hamidrezakalbasi@protonmail.com>
Date: Mon, 16 Aug 2021 19:34:41 +0430
Subject: add derivable impls lint

---
 CHANGELOG.md                        |   1 +
 clippy_lints/src/derivable_impls.rs | 108 +++++++++++++++++++++++
 clippy_lints/src/lib.rs             |   5 ++
 clippy_lints/src/mem_replace.rs     |  85 ++++++------------
 clippy_utils/src/lib.rs             |  61 ++++++++++++-
 clippy_utils/src/ty.rs              |   7 ++
 tests/ui/derivable_impls.rs         | 170 ++++++++++++++++++++++++++++++++++++
 tests/ui/derivable_impls.stderr     |  77 ++++++++++++++++
 tests/ui/mem_replace.fixed          |  20 +++++
 tests/ui/mem_replace.rs             |  20 +++++
 tests/ui/mem_replace.stderr         |  20 ++++-
 11 files changed, 516 insertions(+), 58 deletions(-)
 create mode 100644 clippy_lints/src/derivable_impls.rs
 create mode 100644 tests/ui/derivable_impls.rs
 create mode 100644 tests/ui/derivable_impls.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index d86414a87f4..57df49a2723 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2613,6 +2613,7 @@ Released 2018-09-13
 [`deprecated_cfg_attr`]: https://rust-lang.github.io/rust-clippy/master/index.html#deprecated_cfg_attr
 [`deprecated_semver`]: https://rust-lang.github.io/rust-clippy/master/index.html#deprecated_semver
 [`deref_addrof`]: https://rust-lang.github.io/rust-clippy/master/index.html#deref_addrof
+[`derivable_impls`]: https://rust-lang.github.io/rust-clippy/master/index.html#derivable_impls
 [`derive_hash_xor_eq`]: https://rust-lang.github.io/rust-clippy/master/index.html#derive_hash_xor_eq
 [`derive_ord_xor_partial_ord`]: https://rust-lang.github.io/rust-clippy/master/index.html#derive_ord_xor_partial_ord
 [`disallowed_method`]: https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_method
diff --git a/clippy_lints/src/derivable_impls.rs b/clippy_lints/src/derivable_impls.rs
new file mode 100644
index 00000000000..b4c4ca016aa
--- /dev/null
+++ b/clippy_lints/src/derivable_impls.rs
@@ -0,0 +1,108 @@
+use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::{in_macro, is_automatically_derived, is_default_equivalent, remove_blocks};
+use rustc_hir::{
+    def::{DefKind, Res},
+    Body, Expr, ExprKind, Impl, ImplItemKind, Item, ItemKind, Node, QPath,
+};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::TypeFoldable;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::sym;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Detects manual `std::default::Default` implementations that are identical to a derived implementation.
+    ///
+    /// ### Why is this bad?
+    /// It is less concise.
+    ///
+    /// ### Example
+    /// ```rust
+    /// struct Foo {
+    ///     bar: bool
+    /// }
+    ///
+    /// impl std::default::Default for Foo {
+    ///     fn default() -> Self {
+    ///         Self {
+    ///             bar: false
+    ///         }
+    ///     }
+    /// }
+    /// ```
+    ///
+    /// Could be written as:
+    ///
+    /// ```rust
+    /// #[derive(Default)]
+    /// struct Foo {
+    ///     bar: bool
+    /// }
+    /// ```
+    ///
+    /// ### Known problems
+    /// Derive macros [sometimes use incorrect bounds](https://github.com/rust-lang/rust/issues/26925)
+    /// in generic types and the user defined `impl` maybe is more generalized or
+    /// specialized than what derive will produce. This lint can't detect the manual `impl`
+    /// has exactly equal bounds, and therefore this lint is disabled for types with
+    /// generic parameters.
+    ///
+    pub DERIVABLE_IMPLS,
+    complexity,
+    "manual implementation of the `Default` trait which is equal to a derive"
+}
+
+declare_lint_pass!(DerivableImpls => [DERIVABLE_IMPLS]);
+
+fn is_path_self(e: &Expr<'_>) -> bool {
+    if let ExprKind::Path(QPath::Resolved(_, p)) = e.kind {
+        matches!(p.res, Res::SelfCtor(..) | Res::Def(DefKind::Ctor(..), _))
+    } else {
+        false
+    }
+}
+
+impl<'tcx> LateLintPass<'tcx> for DerivableImpls {
+    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
+        if_chain! {
+            if let ItemKind::Impl(Impl {
+                of_trait: Some(ref trait_ref),
+                items: [child],
+                ..
+            }) = item.kind;
+            if let attrs = cx.tcx.hir().attrs(item.hir_id());
+            if !is_automatically_derived(attrs);
+            if !in_macro(item.span);
+            if let Some(def_id) = trait_ref.trait_def_id();
+            if cx.tcx.is_diagnostic_item(sym::Default, def_id);
+            if let impl_item_hir = child.id.hir_id();
+            if let Some(Node::ImplItem(impl_item)) = cx.tcx.hir().find(impl_item_hir);
+            if let ImplItemKind::Fn(_, b) = &impl_item.kind;
+            if let Body { value: func_expr, .. } = cx.tcx.hir().body(*b);
+            if let Some(adt_def) = cx.tcx.type_of(item.def_id).ty_adt_def();
+            then {
+                if cx.tcx.type_of(item.def_id).definitely_has_param_types_or_consts(cx.tcx) {
+                    return;
+                }
+                let should_emit = match remove_blocks(func_expr).kind {
+                    ExprKind::Tup(fields) => fields.iter().all(|e| is_default_equivalent(cx, e)),
+                    ExprKind::Call(callee, args)
+                        if is_path_self(callee) => args.iter().all(|e| is_default_equivalent(cx, e)),
+                    ExprKind::Struct(_, fields, _) => fields.iter().all(|ef| is_default_equivalent(cx, ef.expr)),
+                    _ => false,
+                };
+                if should_emit {
+                    let path_string = cx.tcx.def_path_str(adt_def.did);
+                    span_lint_and_help(
+                        cx,
+                        DERIVABLE_IMPLS,
+                        item.span,
+                        "this `impl` can be derived",
+                        None,
+                        &format!("try annotating `{}` with `#[derive(Default)]`", path_string),
+                    );
+                }
+            }
+        }
+    }
+}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 2b76eacb7d6..88c1ee1ba0e 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -187,6 +187,7 @@ mod dbg_macro;
 mod default;
 mod default_numeric_fallback;
 mod dereference;
+mod derivable_impls;
 mod derive;
 mod disallowed_method;
 mod disallowed_script_idents;
@@ -586,6 +587,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         default::FIELD_REASSIGN_WITH_DEFAULT,
         default_numeric_fallback::DEFAULT_NUMERIC_FALLBACK,
         dereference::EXPLICIT_DEREF_METHODS,
+        derivable_impls::DERIVABLE_IMPLS,
         derive::DERIVE_HASH_XOR_EQ,
         derive::DERIVE_ORD_XOR_PARTIAL_ORD,
         derive::EXPL_IMPL_CLONE_ON_COPY,
@@ -1204,6 +1206,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(copies::IFS_SAME_COND),
         LintId::of(copies::IF_SAME_THEN_ELSE),
         LintId::of(default::FIELD_REASSIGN_WITH_DEFAULT),
+        LintId::of(derivable_impls::DERIVABLE_IMPLS),
         LintId::of(derive::DERIVE_HASH_XOR_EQ),
         LintId::of(derive::DERIVE_ORD_XOR_PARTIAL_ORD),
         LintId::of(doc::MISSING_SAFETY_DOC),
@@ -1589,6 +1592,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(booleans::NONMINIMAL_BOOL),
         LintId::of(casts::CHAR_LIT_AS_U8),
         LintId::of(casts::UNNECESSARY_CAST),
+        LintId::of(derivable_impls::DERIVABLE_IMPLS),
         LintId::of(double_comparison::DOUBLE_COMPARISONS),
         LintId::of(double_parens::DOUBLE_PARENS),
         LintId::of(duration_subsec::DURATION_SUBSEC),
@@ -1937,6 +1941,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(panic_unimplemented::PanicUnimplemented));
     store.register_late_pass(|| Box::new(strings::StringLitAsBytes));
     store.register_late_pass(|| Box::new(derive::Derive));
+    store.register_late_pass(|| Box::new(derivable_impls::DerivableImpls));
     store.register_late_pass(|| Box::new(get_last_with_len::GetLastWithLen));
     store.register_late_pass(|| Box::new(drop_forget_ref::DropForgetRef));
     store.register_late_pass(|| Box::new(empty_enum::EmptyEnum));
diff --git a/clippy_lints/src/mem_replace.rs b/clippy_lints/src/mem_replace.rs
index 3d071c9081b..1e6057a8fe9 100644
--- a/clippy_lints/src/mem_replace.rs
+++ b/clippy_lints/src/mem_replace.rs
@@ -1,9 +1,9 @@
 use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::{snippet, snippet_with_applicability};
-use clippy_utils::{in_macro, is_diag_trait_item, is_lang_ctor, match_def_path, meets_msrv, msrvs, paths};
+use clippy_utils::ty::is_non_aggregate_primitive_type;
+use clippy_utils::{in_macro, is_default_equivalent, is_lang_ctor, match_def_path, meets_msrv, msrvs, paths};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
-use rustc_hir::def_id::DefId;
 use rustc_hir::LangItem::OptionNone;
 use rustc_hir::{BorrowKind, Expr, ExprKind, Mutability, QPath};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
@@ -194,64 +194,37 @@ fn check_replace_with_uninit(cx: &LateContext<'_>, src: &Expr<'_>, dest: &Expr<'
     }
 }
 
-/// Returns true if the `def_id` associated with the `path` is recognized as a "default-equivalent"
-/// constructor from the std library
-fn is_default_equivalent_ctor(cx: &LateContext<'_>, def_id: DefId, path: &QPath<'_>) -> bool {
-    let std_types_symbols = &[
-        sym::string_type,
-        sym::vec_type,
-        sym::vecdeque_type,
-        sym::LinkedList,
-        sym::hashmap_type,
-        sym::BTreeMap,
-        sym::hashset_type,
-        sym::BTreeSet,
-        sym::BinaryHeap,
-    ];
-
-    if let QPath::TypeRelative(_, method) = path {
-        if method.ident.name == sym::new {
-            if let Some(impl_did) = cx.tcx.impl_of_method(def_id) {
-                if let Some(adt) = cx.tcx.type_of(impl_did).ty_adt_def() {
-                    return std_types_symbols
-                        .iter()
-                        .any(|&symbol| cx.tcx.is_diagnostic_item(symbol, adt.did));
-                }
-            }
+fn check_replace_with_default(cx: &LateContext<'_>, src: &Expr<'_>, dest: &Expr<'_>, expr_span: Span) {
+    // disable lint for primitives
+    let expr_type = cx.typeck_results().expr_ty_adjusted(src);
+    if is_non_aggregate_primitive_type(expr_type) {
+        return;
+    }
+    // disable lint for Option since it is covered in another lint
+    if let ExprKind::Path(q) = &src.kind {
+        if is_lang_ctor(cx, q, OptionNone) {
+            return;
         }
     }
-    false
-}
+    if is_default_equivalent(cx, src) && !in_external_macro(cx.tcx.sess, expr_span) {
+        span_lint_and_then(
+            cx,
+            MEM_REPLACE_WITH_DEFAULT,
+            expr_span,
+            "replacing a value of type `T` with `T::default()` is better expressed using `std::mem::take`",
+            |diag| {
+                if !in_macro(expr_span) {
+                    let suggestion = format!("std::mem::take({})", snippet(cx, dest.span, ""));
 
-fn check_replace_with_default(cx: &LateContext<'_>, src: &Expr<'_>, dest: &Expr<'_>, expr_span: Span) {
-    if_chain! {
-        if let ExprKind::Call(repl_func, _) = src.kind;
-        if !in_external_macro(cx.tcx.sess, expr_span);
-        if let ExprKind::Path(ref repl_func_qpath) = repl_func.kind;
-        if let Some(repl_def_id) = cx.qpath_res(repl_func_qpath, repl_func.hir_id).opt_def_id();
-        if is_diag_trait_item(cx, repl_def_id, sym::Default)
-            || is_default_equivalent_ctor(cx, repl_def_id, repl_func_qpath);
-
-        then {
-            span_lint_and_then(
-                cx,
-                MEM_REPLACE_WITH_DEFAULT,
-                expr_span,
-                "replacing a value of type `T` with `T::default()` is better expressed using `std::mem::take`",
-                |diag| {
-                    if !in_macro(expr_span) {
-                        let suggestion = format!("std::mem::take({})", snippet(cx, dest.span, ""));
-
-                        diag.span_suggestion(
-                            expr_span,
-                            "consider using",
-                            suggestion,
-                            Applicability::MachineApplicable
-                        );
-                    }
+                    diag.span_suggestion(
+                        expr_span,
+                        "consider using",
+                        suggestion,
+                        Applicability::MachineApplicable,
+                    );
                 }
-            );
-        }
+            },
+        );
     }
 }
 
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 40d7963a5e5..757485d19d2 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -70,7 +70,7 @@ use rustc_hir::def::{DefKind, Res};
 use rustc_hir::def_id::DefId;
 use rustc_hir::hir_id::{HirIdMap, HirIdSet};
 use rustc_hir::intravisit::{self, walk_expr, ErasedMap, FnKind, NestedVisitorMap, Visitor};
-use rustc_hir::LangItem::{ResultErr, ResultOk};
+use rustc_hir::LangItem::{OptionNone, ResultErr, ResultOk};
 use rustc_hir::{
     def, Arm, BindingAnnotation, Block, Body, Constness, Destination, Expr, ExprKind, FnDecl, GenericArgs, HirId, Impl,
     ImplItem, ImplItemKind, IsAsync, Item, ItemKind, LangItem, Local, MatchSource, Mutability, Node, Param, Pat,
@@ -644,6 +644,65 @@ pub fn can_mut_borrow_both(cx: &LateContext<'_>, e1: &Expr<'_>, e2: &Expr<'_>) -
     false
 }
 
+/// Returns true if the `def_id` associated with the `path` is recognized as a "default-equivalent"
+/// constructor from the std library
+fn is_default_equivalent_ctor(cx: &LateContext<'_>, def_id: DefId, path: &QPath<'_>) -> bool {
+    let std_types_symbols = &[
+        sym::string_type,
+        sym::vec_type,
+        sym::vecdeque_type,
+        sym::LinkedList,
+        sym::hashmap_type,
+        sym::BTreeMap,
+        sym::hashset_type,
+        sym::BTreeSet,
+        sym::BinaryHeap,
+    ];
+
+    if let QPath::TypeRelative(_, method) = path {
+        if method.ident.name == sym::new {
+            if let Some(impl_did) = cx.tcx.impl_of_method(def_id) {
+                if let Some(adt) = cx.tcx.type_of(impl_did).ty_adt_def() {
+                    return std_types_symbols
+                        .iter()
+                        .any(|&symbol| cx.tcx.is_diagnostic_item(symbol, adt.did));
+                }
+            }
+        }
+    }
+    false
+}
+
+/// Returns true if the expr is equal to `Default::default()` of it's type when evaluated.
+/// It doesn't cover all cases, for example indirect function calls (some of std
+/// functions are supported) but it is the best we have.
+pub fn is_default_equivalent(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
+    match &e.kind {
+        ExprKind::Lit(lit) => match lit.node {
+            LitKind::Bool(false) | LitKind::Int(0, _) => true,
+            LitKind::Str(s, _) => s.is_empty(),
+            _ => false,
+        },
+        ExprKind::Tup(items) | ExprKind::Array(items) => items.iter().all(|x| is_default_equivalent(cx, x)),
+        ExprKind::Repeat(x, _) => is_default_equivalent(cx, x),
+        ExprKind::Call(repl_func, _) => if_chain! {
+            if let ExprKind::Path(ref repl_func_qpath) = repl_func.kind;
+            if let Some(repl_def_id) = cx.qpath_res(repl_func_qpath, repl_func.hir_id).opt_def_id();
+            if is_diag_trait_item(cx, repl_def_id, sym::Default)
+                || is_default_equivalent_ctor(cx, repl_def_id, repl_func_qpath);
+            then {
+                true
+            }
+            else {
+                false
+            }
+        },
+        ExprKind::Path(qpath) => is_lang_ctor(cx, qpath, OptionNone),
+        ExprKind::AddrOf(rustc_hir::BorrowKind::Ref, _, expr) => matches!(expr.kind, ExprKind::Array([])),
+        _ => false,
+    }
+}
+
 /// Checks if the top level expression can be moved into a closure as is.
 /// Currently checks for:
 /// * Break/Continue outside the given loop HIR ids.
diff --git a/clippy_utils/src/ty.rs b/clippy_utils/src/ty.rs
index 7f7fbdc9f21..d6f9ebe89bc 100644
--- a/clippy_utils/src/ty.rs
+++ b/clippy_utils/src/ty.rs
@@ -224,6 +224,13 @@ fn is_normalizable_helper<'tcx>(
     result
 }
 
+/// Returns true iff the given type is a non aggregate primitive (a bool or char, any integer or
+/// floating-point number type). For checking aggregation of primitive types (e.g. tuples and slices
+/// of primitive type) see `is_recursively_primitive_type`
+pub fn is_non_aggregate_primitive_type(ty: Ty<'_>) -> bool {
+    matches!(ty.kind(), ty::Bool | ty::Char | ty::Int(_) | ty::Uint(_) | ty::Float(_))
+}
+
 /// Returns true iff the given type is a primitive (a bool or char, any integer or floating-point
 /// number type, a str, or an array, slice, or tuple of those types).
 pub fn is_recursively_primitive_type(ty: Ty<'_>) -> bool {
diff --git a/tests/ui/derivable_impls.rs b/tests/ui/derivable_impls.rs
new file mode 100644
index 00000000000..336a743de72
--- /dev/null
+++ b/tests/ui/derivable_impls.rs
@@ -0,0 +1,170 @@
+use std::collections::HashMap;
+
+struct FooDefault<'a> {
+    a: bool,
+    b: i32,
+    c: u64,
+    d: Vec<i32>,
+    e: FooND1,
+    f: FooND2,
+    g: HashMap<i32, i32>,
+    h: (i32, Vec<i32>),
+    i: [Vec<i32>; 3],
+    j: [i32; 5],
+    k: Option<i32>,
+    l: &'a [i32],
+}
+
+impl std::default::Default for FooDefault<'_> {
+    fn default() -> Self {
+        Self {
+            a: false,
+            b: 0,
+            c: 0u64,
+            d: vec![],
+            e: Default::default(),
+            f: FooND2::default(),
+            g: HashMap::new(),
+            h: (0, vec![]),
+            i: [vec![], vec![], vec![]],
+            j: [0; 5],
+            k: None,
+            l: &[],
+        }
+    }
+}
+
+struct TupleDefault(bool, i32, u64);
+
+impl std::default::Default for TupleDefault {
+    fn default() -> Self {
+        Self(false, 0, 0u64)
+    }
+}
+
+struct FooND1 {
+    a: bool,
+}
+
+impl std::default::Default for FooND1 {
+    fn default() -> Self {
+        Self { a: true }
+    }
+}
+
+struct FooND2 {
+    a: i32,
+}
+
+impl std::default::Default for FooND2 {
+    fn default() -> Self {
+        Self { a: 5 }
+    }
+}
+
+struct FooNDNew {
+    a: bool,
+}
+
+impl FooNDNew {
+    fn new() -> Self {
+        Self { a: true }
+    }
+}
+
+impl Default for FooNDNew {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+struct FooNDVec(Vec<i32>);
+
+impl Default for FooNDVec {
+    fn default() -> Self {
+        Self(vec![5, 12])
+    }
+}
+
+struct StrDefault<'a>(&'a str);
+
+impl Default for StrDefault<'_> {
+    fn default() -> Self {
+        Self("")
+    }
+}
+
+#[derive(Default)]
+struct AlreadyDerived(i32, bool);
+
+macro_rules! mac {
+    () => {
+        0
+    };
+    ($e:expr) => {
+        struct X(u32);
+        impl Default for X {
+            fn default() -> Self {
+                Self($e)
+            }
+        }
+    };
+}
+
+mac!(0);
+
+struct Y(u32);
+impl Default for Y {
+    fn default() -> Self {
+        Self(mac!())
+    }
+}
+
+struct RustIssue26925<T> {
+    a: Option<T>,
+}
+
+// We should watch out for cases where a manual impl is needed because a
+// derive adds different type bounds (https://github.com/rust-lang/rust/issues/26925).
+// For example, a struct with Option<T> does not require T: Default, but a derive adds
+// that type bound anyways. So until #26925 get fixed we should disable lint
+// for the following case
+impl<T> Default for RustIssue26925<T> {
+    fn default() -> Self {
+        Self { a: None }
+    }
+}
+
+struct SpecializedImpl<A, B> {
+    a: A,
+    b: B,
+}
+
+impl<T: Default> Default for SpecializedImpl<T, T> {
+    fn default() -> Self {
+        Self {
+            a: T::default(),
+            b: T::default(),
+        }
+    }
+}
+
+struct WithoutSelfCurly {
+    a: bool,
+}
+
+impl Default for WithoutSelfCurly {
+    fn default() -> Self {
+        WithoutSelfCurly { a: false }
+    }
+}
+
+struct WithoutSelfParan(bool);
+
+impl Default for WithoutSelfParan {
+    fn default() -> Self {
+        WithoutSelfParan(false)
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/derivable_impls.stderr b/tests/ui/derivable_impls.stderr
new file mode 100644
index 00000000000..4ed64fade02
--- /dev/null
+++ b/tests/ui/derivable_impls.stderr
@@ -0,0 +1,77 @@
+error: this `impl` can be derived
+  --> $DIR/derivable_impls.rs:18:1
+   |
+LL | / impl std::default::Default for FooDefault<'_> {
+LL | |     fn default() -> Self {
+LL | |         Self {
+LL | |             a: false,
+...  |
+LL | |     }
+LL | | }
+   | |_^
+   |
+   = note: `-D clippy::derivable-impls` implied by `-D warnings`
+   = help: try annotating `FooDefault` with `#[derive(Default)]`
+
+error: this `impl` can be derived
+  --> $DIR/derivable_impls.rs:39:1
+   |
+LL | / impl std::default::Default for TupleDefault {
+LL | |     fn default() -> Self {
+LL | |         Self(false, 0, 0u64)
+LL | |     }
+LL | | }
+   | |_^
+   |
+   = help: try annotating `TupleDefault` with `#[derive(Default)]`
+
+error: this `impl` can be derived
+  --> $DIR/derivable_impls.rs:91:1
+   |
+LL | / impl Default for StrDefault<'_> {
+LL | |     fn default() -> Self {
+LL | |         Self("")
+LL | |     }
+LL | | }
+   | |_^
+   |
+   = help: try annotating `StrDefault` with `#[derive(Default)]`
+
+error: this `impl` can be derived
+  --> $DIR/derivable_impls.rs:117:1
+   |
+LL | / impl Default for Y {
+LL | |     fn default() -> Self {
+LL | |         Self(mac!())
+LL | |     }
+LL | | }
+   | |_^
+   |
+   = help: try annotating `Y` with `#[derive(Default)]`
+
+error: this `impl` can be derived
+  --> $DIR/derivable_impls.rs:156:1
+   |
+LL | / impl Default for WithoutSelfCurly {
+LL | |     fn default() -> Self {
+LL | |         WithoutSelfCurly { a: false }
+LL | |     }
+LL | | }
+   | |_^
+   |
+   = help: try annotating `WithoutSelfCurly` with `#[derive(Default)]`
+
+error: this `impl` can be derived
+  --> $DIR/derivable_impls.rs:164:1
+   |
+LL | / impl Default for WithoutSelfParan {
+LL | |     fn default() -> Self {
+LL | |         WithoutSelfParan(false)
+LL | |     }
+LL | | }
+   | |_^
+   |
+   = help: try annotating `WithoutSelfParan` with `#[derive(Default)]`
+
+error: aborting due to 6 previous errors
+
diff --git a/tests/ui/mem_replace.fixed b/tests/ui/mem_replace.fixed
index 3b6224254a0..b609ba65946 100644
--- a/tests/ui/mem_replace.fixed
+++ b/tests/ui/mem_replace.fixed
@@ -51,9 +51,29 @@ fn replace_with_default() {
 
     let mut binary_heap: BinaryHeap<i32> = BinaryHeap::new();
     let _ = std::mem::take(&mut binary_heap);
+
+    let mut tuple = (vec![1, 2], BinaryHeap::<i32>::new());
+    let _ = std::mem::take(&mut tuple);
+
+    let mut refstr = "hello";
+    let _ = std::mem::take(&mut refstr);
+
+    let mut slice: &[i32] = &[1, 2, 3];
+    let _ = std::mem::take(&mut slice);
+}
+
+// lint is disabled for primitives because in this case `take`
+// has no clear benefit over `replace` and sometimes is harder to read
+fn dont_lint_primitive() {
+    let mut pbool = true;
+    let _ = std::mem::replace(&mut pbool, false);
+
+    let mut pint = 5;
+    let _ = std::mem::replace(&mut pint, 0);
 }
 
 fn main() {
     replace_option_with_none();
     replace_with_default();
+    dont_lint_primitive();
 }
diff --git a/tests/ui/mem_replace.rs b/tests/ui/mem_replace.rs
index 0a36db9e921..93f6dcdec83 100644
--- a/tests/ui/mem_replace.rs
+++ b/tests/ui/mem_replace.rs
@@ -51,9 +51,29 @@ fn replace_with_default() {
 
     let mut binary_heap: BinaryHeap<i32> = BinaryHeap::new();
     let _ = std::mem::replace(&mut binary_heap, BinaryHeap::new());
+
+    let mut tuple = (vec![1, 2], BinaryHeap::<i32>::new());
+    let _ = std::mem::replace(&mut tuple, (vec![], BinaryHeap::new()));
+
+    let mut refstr = "hello";
+    let _ = std::mem::replace(&mut refstr, "");
+
+    let mut slice: &[i32] = &[1, 2, 3];
+    let _ = std::mem::replace(&mut slice, &[]);
+}
+
+// lint is disabled for primitives because in this case `take`
+// has no clear benefit over `replace` and sometimes is harder to read
+fn dont_lint_primitive() {
+    let mut pbool = true;
+    let _ = std::mem::replace(&mut pbool, false);
+
+    let mut pint = 5;
+    let _ = std::mem::replace(&mut pint, 0);
 }
 
 fn main() {
     replace_option_with_none();
     replace_with_default();
+    dont_lint_primitive();
 }
diff --git a/tests/ui/mem_replace.stderr b/tests/ui/mem_replace.stderr
index f8aa1538bff..90dc6c95f85 100644
--- a/tests/ui/mem_replace.stderr
+++ b/tests/ui/mem_replace.stderr
@@ -98,5 +98,23 @@ error: replacing a value of type `T` with `T::default()` is better expressed usi
 LL |     let _ = std::mem::replace(&mut binary_heap, BinaryHeap::new());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::mem::take(&mut binary_heap)`
 
-error: aborting due to 16 previous errors
+error: replacing a value of type `T` with `T::default()` is better expressed using `std::mem::take`
+  --> $DIR/mem_replace.rs:56:13
+   |
+LL |     let _ = std::mem::replace(&mut tuple, (vec![], BinaryHeap::new()));
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::mem::take(&mut tuple)`
+
+error: replacing a value of type `T` with `T::default()` is better expressed using `std::mem::take`
+  --> $DIR/mem_replace.rs:59:13
+   |
+LL |     let _ = std::mem::replace(&mut refstr, "");
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::mem::take(&mut refstr)`
+
+error: replacing a value of type `T` with `T::default()` is better expressed using `std::mem::take`
+  --> $DIR/mem_replace.rs:62:13
+   |
+LL |     let _ = std::mem::replace(&mut slice, &[]);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::mem::take(&mut slice)`
+
+error: aborting due to 19 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 37af742bbbd20b5fe5a753c0c23e5bab477298f1 Mon Sep 17 00:00:00 2001
From: lyj <sjtu5140809011@gmail.com>
Date: Sun, 5 Sep 2021 08:33:04 +0800
Subject: Update clippy_lints/src/needless_option_as_deref.rs

Co-authored-by: llogiq <bogusandre@gmail.com>
---
 clippy_lints/src/needless_option_as_deref.rs | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/needless_option_as_deref.rs b/clippy_lints/src/needless_option_as_deref.rs
index 67c697da04f..5024a881d2a 100644
--- a/clippy_lints/src/needless_option_as_deref.rs
+++ b/clippy_lints/src/needless_option_as_deref.rs
@@ -38,10 +38,7 @@ declare_lint_pass!(OptionNeedlessDeref=> [
 
 impl<'tcx> LateLintPass<'tcx> for OptionNeedlessDeref {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if expr.span.from_expansion() {
-            return;
-        }
-        if in_macro(expr.span) {
+        if expr.span.from_expansion() || in_macro(expr.span) {
             return;
         }
         let typeck = cx.typeck_results();
-- 
cgit 1.4.1-3-g733a5


From 4ee9ec960ec434e27cf0764a539a3f42a43a896d Mon Sep 17 00:00:00 2001
From: Michael Wright <mikerite@lavabit.com>
Date: Sun, 5 Sep 2021 08:19:30 +0200
Subject: Add MSRV to `approx_constant` documentation

---
 clippy_lints/src/utils/conf.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 881dc321930..8651fa6fcf9 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -132,7 +132,7 @@ define_Conf! {
     ///
     /// Suppress lints whenever the suggested change would cause breakage for other crates.
     (avoid_breaking_exported_api: bool = true),
-    /// Lint: MANUAL_SPLIT_ONCE, MANUAL_STR_REPEAT, CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR, IF_THEN_SOME_ELSE_NONE.
+    /// Lint: MANUAL_SPLIT_ONCE, MANUAL_STR_REPEAT, CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR, IF_THEN_SOME_ELSE_NONE, APPROX_CONSTANT.
     ///
     /// The minimum rust version that the project supports
     (msrv: Option<String> = None),
-- 
cgit 1.4.1-3-g733a5


From 19d8a3e53c77a51f691f61e1d4eb0ae2d0c94267 Mon Sep 17 00:00:00 2001
From: Michael Wright <mikerite@lavabit.com>
Date: Sun, 5 Sep 2021 08:42:00 +0200
Subject: Improve `approx_constant` output

---
 clippy_lints/src/approx_const.rs | 12 +++---
 tests/ui/approx_const.stderr     | 83 ++++++++++++++++++++++++++++++----------
 tests/ui/proc_macro.stderr       |  3 +-
 3 files changed, 69 insertions(+), 29 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/approx_const.rs b/clippy_lints/src/approx_const.rs
index 069a10e9b3a..a57d8b67ed3 100644
--- a/clippy_lints/src/approx_const.rs
+++ b/clippy_lints/src/approx_const.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint;
+use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::{meets_msrv, msrvs};
 use rustc_ast::ast::{FloatTy, LitFloatType, LitKind};
 use rustc_hir::{Expr, ExprKind};
@@ -88,15 +88,13 @@ impl ApproxConstant {
                 if is_approx_const(constant, &s, min_digits)
                     && msrv.as_ref().map_or(true, |msrv| meets_msrv(self.msrv.as_ref(), msrv))
                 {
-                    span_lint(
+                    span_lint_and_help(
                         cx,
                         APPROX_CONSTANT,
                         e.span,
-                        &format!(
-                            "approximate value of `{}::consts::{}` found. \
-                             Consider using it directly",
-                            module, &name
-                        ),
+                        &format!("approximate value of `{}::consts::{}` found", module, &name),
+                        None,
+                        "consider using the constant directly",
                     );
                     return;
                 }
diff --git a/tests/ui/approx_const.stderr b/tests/ui/approx_const.stderr
index 98b85443f0b..a49fd40bf33 100644
--- a/tests/ui/approx_const.stderr
+++ b/tests/ui/approx_const.stderr
@@ -1,130 +1,171 @@
-error: approximate value of `f{32, 64}::consts::E` found. Consider using it directly
+error: approximate value of `f{32, 64}::consts::E` found
   --> $DIR/approx_const.rs:4:16
    |
 LL |     let my_e = 2.7182;
    |                ^^^^^^
    |
    = note: `-D clippy::approx-constant` implied by `-D warnings`
+   = help: consider using the constant directly
 
-error: approximate value of `f{32, 64}::consts::E` found. Consider using it directly
+error: approximate value of `f{32, 64}::consts::E` found
   --> $DIR/approx_const.rs:5:20
    |
 LL |     let almost_e = 2.718;
    |                    ^^^^^
+   |
+   = help: consider using the constant directly
 
-error: approximate value of `f{32, 64}::consts::FRAC_1_PI` found. Consider using it directly
+error: approximate value of `f{32, 64}::consts::FRAC_1_PI` found
   --> $DIR/approx_const.rs:8:24
    |
 LL |     let my_1_frac_pi = 0.3183;
    |                        ^^^^^^
+   |
+   = help: consider using the constant directly
 
-error: approximate value of `f{32, 64}::consts::FRAC_1_SQRT_2` found. Consider using it directly
+error: approximate value of `f{32, 64}::consts::FRAC_1_SQRT_2` found
   --> $DIR/approx_const.rs:11:28
    |
 LL |     let my_frac_1_sqrt_2 = 0.70710678;
    |                            ^^^^^^^^^^
+   |
+   = help: consider using the constant directly
 
-error: approximate value of `f{32, 64}::consts::FRAC_1_SQRT_2` found. Consider using it directly
+error: approximate value of `f{32, 64}::consts::FRAC_1_SQRT_2` found
   --> $DIR/approx_const.rs:12:32
    |
 LL |     let almost_frac_1_sqrt_2 = 0.70711;
    |                                ^^^^^^^
+   |
+   = help: consider using the constant directly
 
-error: approximate value of `f{32, 64}::consts::FRAC_2_PI` found. Consider using it directly
+error: approximate value of `f{32, 64}::consts::FRAC_2_PI` found
   --> $DIR/approx_const.rs:15:24
    |
 LL |     let my_frac_2_pi = 0.63661977;
    |                        ^^^^^^^^^^
+   |
+   = help: consider using the constant directly
 
-error: approximate value of `f{32, 64}::consts::FRAC_2_SQRT_PI` found. Consider using it directly
+error: approximate value of `f{32, 64}::consts::FRAC_2_SQRT_PI` found
   --> $DIR/approx_const.rs:18:27
    |
 LL |     let my_frac_2_sq_pi = 1.128379;
    |                           ^^^^^^^^
+   |
+   = help: consider using the constant directly
 
-error: approximate value of `f{32, 64}::consts::FRAC_PI_2` found. Consider using it directly
+error: approximate value of `f{32, 64}::consts::FRAC_PI_2` found
   --> $DIR/approx_const.rs:21:24
    |
 LL |     let my_frac_pi_2 = 1.57079632679;
    |                        ^^^^^^^^^^^^^
+   |
+   = help: consider using the constant directly
 
-error: approximate value of `f{32, 64}::consts::FRAC_PI_3` found. Consider using it directly
+error: approximate value of `f{32, 64}::consts::FRAC_PI_3` found
   --> $DIR/approx_const.rs:24:24
    |
 LL |     let my_frac_pi_3 = 1.04719755119;
    |                        ^^^^^^^^^^^^^
+   |
+   = help: consider using the constant directly
 
-error: approximate value of `f{32, 64}::consts::FRAC_PI_4` found. Consider using it directly
+error: approximate value of `f{32, 64}::consts::FRAC_PI_4` found
   --> $DIR/approx_const.rs:27:24
    |
 LL |     let my_frac_pi_4 = 0.785398163397;
    |                        ^^^^^^^^^^^^^^
+   |
+   = help: consider using the constant directly
 
-error: approximate value of `f{32, 64}::consts::FRAC_PI_6` found. Consider using it directly
+error: approximate value of `f{32, 64}::consts::FRAC_PI_6` found
   --> $DIR/approx_const.rs:30:24
    |
 LL |     let my_frac_pi_6 = 0.523598775598;
    |                        ^^^^^^^^^^^^^^
+   |
+   = help: consider using the constant directly
 
-error: approximate value of `f{32, 64}::consts::FRAC_PI_8` found. Consider using it directly
+error: approximate value of `f{32, 64}::consts::FRAC_PI_8` found
   --> $DIR/approx_const.rs:33:24
    |
 LL |     let my_frac_pi_8 = 0.3926990816987;
    |                        ^^^^^^^^^^^^^^^
+   |
+   = help: consider using the constant directly
 
-error: approximate value of `f{32, 64}::consts::LN_10` found. Consider using it directly
+error: approximate value of `f{32, 64}::consts::LN_10` found
   --> $DIR/approx_const.rs:36:20
    |
 LL |     let my_ln_10 = 2.302585092994046;
    |                    ^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using the constant directly
 
-error: approximate value of `f{32, 64}::consts::LN_2` found. Consider using it directly
+error: approximate value of `f{32, 64}::consts::LN_2` found
   --> $DIR/approx_const.rs:39:19
    |
 LL |     let my_ln_2 = 0.6931471805599453;
    |                   ^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using the constant directly
 
-error: approximate value of `f{32, 64}::consts::LOG10_E` found. Consider using it directly
+error: approximate value of `f{32, 64}::consts::LOG10_E` found
   --> $DIR/approx_const.rs:42:22
    |
 LL |     let my_log10_e = 0.4342944819032518;
    |                      ^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using the constant directly
 
-error: approximate value of `f{32, 64}::consts::LOG2_E` found. Consider using it directly
+error: approximate value of `f{32, 64}::consts::LOG2_E` found
   --> $DIR/approx_const.rs:45:21
    |
 LL |     let my_log2_e = 1.4426950408889634;
    |                     ^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using the constant directly
 
-error: approximate value of `f{32, 64}::consts::LOG2_10` found. Consider using it directly
+error: approximate value of `f{32, 64}::consts::LOG2_10` found
   --> $DIR/approx_const.rs:48:19
    |
 LL |     let log2_10 = 3.321928094887362;
    |                   ^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using the constant directly
 
-error: approximate value of `f{32, 64}::consts::LOG10_2` found. Consider using it directly
+error: approximate value of `f{32, 64}::consts::LOG10_2` found
   --> $DIR/approx_const.rs:51:19
    |
 LL |     let log10_2 = 0.301029995663981;
    |                   ^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using the constant directly
 
-error: approximate value of `f{32, 64}::consts::PI` found. Consider using it directly
+error: approximate value of `f{32, 64}::consts::PI` found
   --> $DIR/approx_const.rs:54:17
    |
 LL |     let my_pi = 3.1415;
    |                 ^^^^^^
+   |
+   = help: consider using the constant directly
 
-error: approximate value of `f{32, 64}::consts::PI` found. Consider using it directly
+error: approximate value of `f{32, 64}::consts::PI` found
   --> $DIR/approx_const.rs:55:21
    |
 LL |     let almost_pi = 3.14;
    |                     ^^^^
+   |
+   = help: consider using the constant directly
 
-error: approximate value of `f{32, 64}::consts::SQRT_2` found. Consider using it directly
+error: approximate value of `f{32, 64}::consts::SQRT_2` found
   --> $DIR/approx_const.rs:58:18
    |
 LL |     let my_sq2 = 1.4142;
    |                  ^^^^^^
+   |
+   = help: consider using the constant directly
 
 error: aborting due to 21 previous errors
 
diff --git a/tests/ui/proc_macro.stderr b/tests/ui/proc_macro.stderr
index 872cbc66af6..48fd58c9a49 100644
--- a/tests/ui/proc_macro.stderr
+++ b/tests/ui/proc_macro.stderr
@@ -1,10 +1,11 @@
-error: approximate value of `f{32, 64}::consts::PI` found. Consider using it directly
+error: approximate value of `f{32, 64}::consts::PI` found
   --> $DIR/proc_macro.rs:10:14
    |
 LL |     let _x = 3.14;
    |              ^^^^
    |
    = note: `#[deny(clippy::approx_constant)]` on by default
+   = help: consider using the constant directly
 
 error: aborting due to previous error
 
-- 
cgit 1.4.1-3-g733a5


From 62b46125cb66d1f9050711d012cd16c49c99217c Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Sat, 4 Sep 2021 18:21:49 +0200
Subject: Avoid slice indexing in Clippy (down with the ICEs)

---
 clippy_lints/src/blocks_in_if_conditions.rs   |  4 ++--
 clippy_lints/src/casts/cast_ptr_alignment.rs  |  4 ++--
 clippy_lints/src/floating_point_arithmetic.rs | 30 +++++++++++++--------------
 clippy_lints/src/if_let_mutex.rs              |  6 +++---
 clippy_lints/src/if_let_some_result.rs        |  4 ++--
 clippy_lints/src/loops/needless_range_loop.rs |  4 ++--
 clippy_lints/src/mem_forget.rs                |  4 ++--
 clippy_lints/src/methods/or_fun_call.rs       |  4 ++--
 clippy_lints/src/methods/utils.rs             |  6 +++---
 clippy_lints/src/misc.rs                      |  4 ++--
 clippy_lints/src/mut_mutex_lock.rs            |  4 ++--
 clippy_lints/src/open_options.rs              |  6 +++---
 clippy_lints/src/ptr_offset_with_cast.rs      |  8 +++----
 clippy_lints/src/strings.rs                   |  8 +++----
 clippy_lints/src/to_string_in_display.rs      |  4 ++--
 clippy_lints/src/undropped_manually_drops.rs  |  4 ++--
 clippy_lints/src/unused_io_amount.rs          |  8 +++----
 clippy_lints/src/utils/internal_lints.rs      |  4 ++--
 18 files changed, 58 insertions(+), 58 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/blocks_in_if_conditions.rs b/clippy_lints/src/blocks_in_if_conditions.rs
index 51d95cc6f0b..47e5b0d583d 100644
--- a/clippy_lints/src/blocks_in_if_conditions.rs
+++ b/clippy_lints/src/blocks_in_if_conditions.rs
@@ -61,8 +61,8 @@ impl<'a, 'tcx> Visitor<'tcx> for ExVisitor<'a, 'tcx> {
             // do not lint if the closure is called using an iterator (see #1141)
             if_chain! {
                 if let Some(parent) = get_parent_expr(self.cx, expr);
-                if let ExprKind::MethodCall(_, _, args, _) = parent.kind;
-                let caller = self.cx.typeck_results().expr_ty(&args[0]);
+                if let ExprKind::MethodCall(_, _, [self_arg, ..], _) = &parent.kind;
+                let caller = self.cx.typeck_results().expr_ty(self_arg);
                 if let Some(iter_id) = self.cx.tcx.get_diagnostic_item(sym::Iterator);
                 if implements_trait(self.cx, caller, iter_id, &[]);
                 then {
diff --git a/clippy_lints/src/casts/cast_ptr_alignment.rs b/clippy_lints/src/casts/cast_ptr_alignment.rs
index 62a119d662b..5880859e719 100644
--- a/clippy_lints/src/casts/cast_ptr_alignment.rs
+++ b/clippy_lints/src/casts/cast_ptr_alignment.rs
@@ -19,7 +19,7 @@ pub(super) fn check(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
             cx.typeck_results().expr_ty(expr),
         );
         lint_cast_ptr_alignment(cx, expr, cast_from, cast_to);
-    } else if let ExprKind::MethodCall(method_path, _, args, _) = expr.kind {
+    } else if let ExprKind::MethodCall(method_path, _, [self_arg, ..], _) = &expr.kind {
         if_chain! {
             if method_path.ident.name == sym!(cast);
             if let Some(generic_args) = method_path.args;
@@ -28,7 +28,7 @@ pub(super) fn check(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
             if !is_hir_ty_cfg_dependant(cx, cast_to);
             then {
                 let (cast_from, cast_to) =
-                    (cx.typeck_results().expr_ty(&args[0]), cx.typeck_results().expr_ty(expr));
+                    (cx.typeck_results().expr_ty(self_arg), cx.typeck_results().expr_ty(expr));
                 lint_cast_ptr_alignment(cx, expr, cast_from, cast_to);
             }
         }
diff --git a/clippy_lints/src/floating_point_arithmetic.rs b/clippy_lints/src/floating_point_arithmetic.rs
index a643b3eb8f1..eda611117ba 100644
--- a/clippy_lints/src/floating_point_arithmetic.rs
+++ b/clippy_lints/src/floating_point_arithmetic.rs
@@ -362,22 +362,22 @@ fn detect_hypot(cx: &LateContext<'_>, args: &[Expr<'_>]) -> Option<String> {
         if_chain! {
             if let ExprKind::MethodCall(
                 PathSegment { ident: lmethod_name, .. },
-                ref _lspan,
-                largs,
+                _lspan,
+                [largs_0, largs_1, ..],
                 _
-            ) = add_lhs.kind;
+            ) = &add_lhs.kind;
             if let ExprKind::MethodCall(
                 PathSegment { ident: rmethod_name, .. },
-                ref _rspan,
-                rargs,
+                _rspan,
+                [rargs_0, rargs_1, ..],
                 _
-            ) = add_rhs.kind;
+            ) = &add_rhs.kind;
             if lmethod_name.as_str() == "powi" && rmethod_name.as_str() == "powi";
-            if let Some((lvalue, _)) = constant(cx, cx.typeck_results(), &largs[1]);
-            if let Some((rvalue, _)) = constant(cx, cx.typeck_results(), &rargs[1]);
+            if let Some((lvalue, _)) = constant(cx, cx.typeck_results(), largs_1);
+            if let Some((rvalue, _)) = constant(cx, cx.typeck_results(), rargs_1);
             if Int(2) == lvalue && Int(2) == rvalue;
             then {
-                return Some(format!("{}.hypot({})", Sugg::hir(cx, &largs[0], ".."), Sugg::hir(cx, &rargs[0], "..")));
+                return Some(format!("{}.hypot({})", Sugg::hir(cx, largs_0, ".."), Sugg::hir(cx, rargs_0, "..")));
             }
         }
     }
@@ -407,8 +407,8 @@ fn check_expm1(cx: &LateContext<'_>, expr: &Expr<'_>) {
         if cx.typeck_results().expr_ty(lhs).is_floating_point();
         if let Some((value, _)) = constant(cx, cx.typeck_results(), rhs);
         if F32(1.0) == value || F64(1.0) == value;
-        if let ExprKind::MethodCall(path, _, method_args, _) = lhs.kind;
-        if cx.typeck_results().expr_ty(&method_args[0]).is_floating_point();
+        if let ExprKind::MethodCall(path, _, [self_arg, ..], _) = &lhs.kind;
+        if cx.typeck_results().expr_ty(self_arg).is_floating_point();
         if path.ident.name.as_str() == "exp";
         then {
             span_lint_and_sugg(
@@ -419,7 +419,7 @@ fn check_expm1(cx: &LateContext<'_>, expr: &Expr<'_>) {
                 "consider using",
                 format!(
                     "{}.exp_m1()",
-                    Sugg::hir(cx, &method_args[0], "..")
+                    Sugg::hir(cx, self_arg, "..")
                 ),
                 Applicability::MachineApplicable,
             );
@@ -617,8 +617,8 @@ fn check_log_division(cx: &LateContext<'_>, expr: &Expr<'_>) {
             rhs,
         ) = &expr.kind;
         if are_same_base_logs(cx, lhs, rhs);
-        if let ExprKind::MethodCall(_, _, largs, _) = lhs.kind;
-        if let ExprKind::MethodCall(_, _, rargs, _) = rhs.kind;
+        if let ExprKind::MethodCall(_, _, [largs_self, ..], _) = &lhs.kind;
+        if let ExprKind::MethodCall(_, _, [rargs_self, ..], _) = &rhs.kind;
         then {
             span_lint_and_sugg(
                 cx,
@@ -626,7 +626,7 @@ fn check_log_division(cx: &LateContext<'_>, expr: &Expr<'_>) {
                 expr.span,
                 "log base can be expressed more clearly",
                 "consider using",
-                format!("{}.log({})", Sugg::hir(cx, &largs[0], ".."), Sugg::hir(cx, &rargs[0], ".."),),
+                format!("{}.log({})", Sugg::hir(cx, largs_self, ".."), Sugg::hir(cx, rargs_self, ".."),),
                 Applicability::MachineApplicable,
             );
         }
diff --git a/clippy_lints/src/if_let_mutex.rs b/clippy_lints/src/if_let_mutex.rs
index 7dad1c31150..ef72b88b3c7 100644
--- a/clippy_lints/src/if_let_mutex.rs
+++ b/clippy_lints/src/if_let_mutex.rs
@@ -138,12 +138,12 @@ impl<'tcx, 'l> ArmVisitor<'tcx, 'l> {
 
 fn is_mutex_lock_call<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<&'tcx Expr<'tcx>> {
     if_chain! {
-        if let ExprKind::MethodCall(path, _span, args, _) = &expr.kind;
+        if let ExprKind::MethodCall(path, _span, [self_arg, ..], _) = &expr.kind;
         if path.ident.as_str() == "lock";
-        let ty = cx.typeck_results().expr_ty(&args[0]);
+        let ty = cx.typeck_results().expr_ty(self_arg);
         if is_type_diagnostic_item(cx, ty, sym!(mutex_type));
         then {
-            Some(&args[0])
+            Some(self_arg)
         } else {
             None
         }
diff --git a/clippy_lints/src/if_let_some_result.rs b/clippy_lints/src/if_let_some_result.rs
index 33eba02dae0..adcd78ed0d4 100644
--- a/clippy_lints/src/if_let_some_result.rs
+++ b/clippy_lints/src/if_let_some_result.rs
@@ -46,10 +46,10 @@ impl<'tcx> LateLintPass<'tcx> for OkIfLet {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if_chain! { //begin checking variables
             if let Some(higher::IfLet { let_pat, let_expr, .. }) = higher::IfLet::hir(cx, expr);
-            if let ExprKind::MethodCall(_, ok_span, result_types, _) = let_expr.kind; //check is expr.ok() has type Result<T,E>.ok(, _)
+            if let ExprKind::MethodCall(_, ok_span, [ref result_types_0, ..], _) = let_expr.kind; //check is expr.ok() has type Result<T,E>.ok(, _)
             if let PatKind::TupleStruct(QPath::Resolved(_, x), y, _)  = let_pat.kind; //get operation
             if method_chain_args(let_expr, &["ok"]).is_some(); //test to see if using ok() methoduse std::marker::Sized;
-            if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&result_types[0]), sym::result_type);
+            if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(result_types_0), sym::result_type);
             if rustc_hir_pretty::to_string(rustc_hir_pretty::NO_ANN, |s| s.print_path(x, false)) == "Some";
 
             then {
diff --git a/clippy_lints/src/loops/needless_range_loop.rs b/clippy_lints/src/loops/needless_range_loop.rs
index f17e76d9682..e8f3550283a 100644
--- a/clippy_lints/src/loops/needless_range_loop.rs
+++ b/clippy_lints/src/loops/needless_range_loop.rs
@@ -301,10 +301,10 @@ impl<'a, 'tcx> Visitor<'tcx> for VarVisitor<'a, 'tcx> {
     fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
         if_chain! {
             // a range index op
-            if let ExprKind::MethodCall(meth, _, args, _) = expr.kind;
+            if let ExprKind::MethodCall(meth, _, [args_0, args_1, ..], _) = &expr.kind;
             if (meth.ident.name == sym::index && match_trait_method(self.cx, expr, &paths::INDEX))
                 || (meth.ident.name == sym::index_mut && match_trait_method(self.cx, expr, &paths::INDEX_MUT));
-            if !self.check(&args[1], &args[0], expr);
+            if !self.check(args_1, args_0, expr);
             then { return }
         }
 
diff --git a/clippy_lints/src/mem_forget.rs b/clippy_lints/src/mem_forget.rs
index 07202a59c4b..eb437dc47af 100644
--- a/clippy_lints/src/mem_forget.rs
+++ b/clippy_lints/src/mem_forget.rs
@@ -28,11 +28,11 @@ declare_lint_pass!(MemForget => [MEM_FORGET]);
 
 impl<'tcx> LateLintPass<'tcx> for MemForget {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
-        if let ExprKind::Call(path_expr, args) = e.kind {
+        if let ExprKind::Call(path_expr, [ref first_arg, ..]) = e.kind {
             if let ExprKind::Path(ref qpath) = path_expr.kind {
                 if let Some(def_id) = cx.qpath_res(qpath, path_expr.hir_id).opt_def_id() {
                     if match_def_path(cx, def_id, &paths::MEM_FORGET) {
-                        let forgot_ty = cx.typeck_results().expr_ty(&args[0]);
+                        let forgot_ty = cx.typeck_results().expr_ty(first_arg);
 
                         if forgot_ty.ty_adt_def().map_or(false, |def| def.has_dtor(cx.tcx)) {
                             span_lint(cx, MEM_FORGET, e.span, "usage of `mem::forget` on `Drop` type");
diff --git a/clippy_lints/src/methods/or_fun_call.rs b/clippy_lints/src/methods/or_fun_call.rs
index c1d22e5d72c..30ed1d665a9 100644
--- a/clippy_lints/src/methods/or_fun_call.rs
+++ b/clippy_lints/src/methods/or_fun_call.rs
@@ -96,9 +96,9 @@ pub(super) fn check<'tcx>(
             (&paths::RESULT, true, &["or", "unwrap_or"], "else"),
         ];
 
-        if let hir::ExprKind::MethodCall(path, _, args, _) = &arg.kind {
+        if let hir::ExprKind::MethodCall(path, _, [self_arg, ..], _) = &arg.kind {
             if path.ident.name == sym::len {
-                let ty = cx.typeck_results().expr_ty(&args[0]).peel_refs();
+                let ty = cx.typeck_results().expr_ty(self_arg).peel_refs();
 
                 match ty.kind() {
                     ty::Slice(_) | ty::Array(_, _) | ty::Str => return,
diff --git a/clippy_lints/src/methods/utils.rs b/clippy_lints/src/methods/utils.rs
index 0daea47816a..30d6665a920 100644
--- a/clippy_lints/src/methods/utils.rs
+++ b/clippy_lints/src/methods/utils.rs
@@ -24,9 +24,9 @@ pub(super) fn derefs_to_slice<'tcx>(
         }
     }
 
-    if let hir::ExprKind::MethodCall(path, _, args, _) = expr.kind {
-        if path.ident.name == sym::iter && may_slice(cx, cx.typeck_results().expr_ty(&args[0])) {
-            Some(&args[0])
+    if let hir::ExprKind::MethodCall(path, _, [self_arg, ..], _) = &expr.kind {
+        if path.ident.name == sym::iter && may_slice(cx, cx.typeck_results().expr_ty(self_arg)) {
+            Some(self_arg)
         } else {
             None
         }
diff --git a/clippy_lints/src/misc.rs b/clippy_lints/src/misc.rs
index c796abe9815..538fa4e1678 100644
--- a/clippy_lints/src/misc.rs
+++ b/clippy_lints/src/misc.rs
@@ -513,12 +513,12 @@ fn is_signum(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
     }
 
     if_chain! {
-        if let ExprKind::MethodCall(method_name, _, expressions, _) = expr.kind;
+        if let ExprKind::MethodCall(method_name, _, [ref self_arg, ..], _) = expr.kind;
         if sym!(signum) == method_name.ident.name;
         // Check that the receiver of the signum() is a float (expressions[0] is the receiver of
         // the method call)
         then {
-            return is_float(cx, &expressions[0]);
+            return is_float(cx, self_arg);
         }
     }
     false
diff --git a/clippy_lints/src/mut_mutex_lock.rs b/clippy_lints/src/mut_mutex_lock.rs
index 85e870632a5..e9dcc7b227d 100644
--- a/clippy_lints/src/mut_mutex_lock.rs
+++ b/clippy_lints/src/mut_mutex_lock.rs
@@ -47,9 +47,9 @@ declare_lint_pass!(MutMutexLock => [MUT_MUTEX_LOCK]);
 impl<'tcx> LateLintPass<'tcx> for MutMutexLock {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, ex: &'tcx Expr<'tcx>) {
         if_chain! {
-            if let ExprKind::MethodCall(path, method_span, args, _) = &ex.kind;
+            if let ExprKind::MethodCall(path, method_span, [self_arg, ..], _) = &ex.kind;
             if path.ident.name == sym!(lock);
-            let ty = cx.typeck_results().expr_ty(&args[0]);
+            let ty = cx.typeck_results().expr_ty(self_arg);
             if let ty::Ref(_, inner_ty, Mutability::Mut) = ty.kind();
             if is_type_diagnostic_item(cx, inner_ty, sym!(mutex_type));
             then {
diff --git a/clippy_lints/src/open_options.rs b/clippy_lints/src/open_options.rs
index 4064d94da2a..5752342cf62 100644
--- a/clippy_lints/src/open_options.rs
+++ b/clippy_lints/src/open_options.rs
@@ -31,11 +31,11 @@ declare_lint_pass!(OpenOptions => [NONSENSICAL_OPEN_OPTIONS]);
 
 impl<'tcx> LateLintPass<'tcx> for OpenOptions {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
-        if let ExprKind::MethodCall(path, _, arguments, _) = e.kind {
-            let obj_ty = cx.typeck_results().expr_ty(&arguments[0]).peel_refs();
+        if let ExprKind::MethodCall(path, _, [self_arg, ..], _) = &e.kind {
+            let obj_ty = cx.typeck_results().expr_ty(self_arg).peel_refs();
             if path.ident.name == sym!(open) && match_type(cx, obj_ty, &paths::OPEN_OPTIONS) {
                 let mut options = Vec::new();
-                get_open_options(cx, &arguments[0], &mut options);
+                get_open_options(cx, self_arg, &mut options);
                 check_open_options(cx, &options, e.span);
             }
         }
diff --git a/clippy_lints/src/ptr_offset_with_cast.rs b/clippy_lints/src/ptr_offset_with_cast.rs
index f1975056ddc..cfb5287c667 100644
--- a/clippy_lints/src/ptr_offset_with_cast.rs
+++ b/clippy_lints/src/ptr_offset_with_cast.rs
@@ -92,13 +92,13 @@ fn expr_as_ptr_offset_call<'tcx>(
     cx: &LateContext<'tcx>,
     expr: &'tcx Expr<'_>,
 ) -> Option<(&'tcx Expr<'tcx>, &'tcx Expr<'tcx>, Method)> {
-    if let ExprKind::MethodCall(path_segment, _, args, _) = expr.kind {
-        if is_expr_ty_raw_ptr(cx, &args[0]) {
+    if let ExprKind::MethodCall(path_segment, _, [arg_0, arg_1, ..], _) = &expr.kind {
+        if is_expr_ty_raw_ptr(cx, arg_0) {
             if path_segment.ident.name == sym::offset {
-                return Some((&args[0], &args[1], Method::Offset));
+                return Some((arg_0, arg_1, Method::Offset));
             }
             if path_segment.ident.name == sym!(wrapping_offset) {
-                return Some((&args[0], &args[1], Method::WrappingOffset));
+                return Some((arg_0, arg_1, Method::WrappingOffset));
             }
         }
     }
diff --git a/clippy_lints/src/strings.rs b/clippy_lints/src/strings.rs
index 1a78a4968e5..13d8f954c44 100644
--- a/clippy_lints/src/strings.rs
+++ b/clippy_lints/src/strings.rs
@@ -345,9 +345,9 @@ declare_lint_pass!(StrToString => [STR_TO_STRING]);
 impl LateLintPass<'_> for StrToString {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &Expr<'_>) {
         if_chain! {
-            if let ExprKind::MethodCall(path, _, args, _) = &expr.kind;
+            if let ExprKind::MethodCall(path, _, [self_arg, ..], _) = &expr.kind;
             if path.ident.name == sym!(to_string);
-            let ty = cx.typeck_results().expr_ty(&args[0]);
+            let ty = cx.typeck_results().expr_ty(self_arg);
             if let ty::Ref(_, ty, ..) = ty.kind();
             if *ty.kind() == ty::Str;
             then {
@@ -394,9 +394,9 @@ declare_lint_pass!(StringToString => [STRING_TO_STRING]);
 impl LateLintPass<'_> for StringToString {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &Expr<'_>) {
         if_chain! {
-            if let ExprKind::MethodCall(path, _, args, _) = &expr.kind;
+            if let ExprKind::MethodCall(path, _, [self_arg, ..], _) = &expr.kind;
             if path.ident.name == sym!(to_string);
-            let ty = cx.typeck_results().expr_ty(&args[0]);
+            let ty = cx.typeck_results().expr_ty(self_arg);
             if is_type_diagnostic_item(cx, ty, sym::string_type);
             then {
                 span_lint_and_help(
diff --git a/clippy_lints/src/to_string_in_display.rs b/clippy_lints/src/to_string_in_display.rs
index b036ed9a3d2..b7414cec87c 100644
--- a/clippy_lints/src/to_string_in_display.rs
+++ b/clippy_lints/src/to_string_in_display.rs
@@ -92,11 +92,11 @@ impl LateLintPass<'_> for ToStringInDisplay {
         if_chain! {
             if self.in_display_impl;
             if let Some(self_hir_id) = self.self_hir_id;
-            if let ExprKind::MethodCall(path, _, args, _) = expr.kind;
+            if let ExprKind::MethodCall(path, _, [ref self_arg, ..], _) = expr.kind;
             if path.ident.name == sym!(to_string);
             if let Some(expr_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
             if is_diag_trait_item(cx, expr_def_id, sym::ToString);
-            if path_to_local_id(&args[0], self_hir_id);
+            if path_to_local_id(self_arg, self_hir_id);
             then {
                 span_lint(
                     cx,
diff --git a/clippy_lints/src/undropped_manually_drops.rs b/clippy_lints/src/undropped_manually_drops.rs
index 47571e608c7..09570616593 100644
--- a/clippy_lints/src/undropped_manually_drops.rs
+++ b/clippy_lints/src/undropped_manually_drops.rs
@@ -37,8 +37,8 @@ declare_lint_pass!(UndroppedManuallyDrops => [UNDROPPED_MANUALLY_DROPS]);
 
 impl LateLintPass<'tcx> for UndroppedManuallyDrops {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if let Some(args) = match_function_call(cx, expr, &paths::DROP) {
-            let ty = cx.typeck_results().expr_ty(&args[0]);
+        if let Some([arg_0, ..]) = match_function_call(cx, expr, &paths::DROP) {
+            let ty = cx.typeck_results().expr_ty(arg_0);
             if is_type_lang_item(cx, ty, lang_items::LangItem::ManuallyDrop) {
                 span_lint_and_help(
                     cx,
diff --git a/clippy_lints/src/unused_io_amount.rs b/clippy_lints/src/unused_io_amount.rs
index 82bc4a6d153..031b182bd2f 100644
--- a/clippy_lints/src/unused_io_amount.rs
+++ b/clippy_lints/src/unused_io_amount.rs
@@ -45,20 +45,20 @@ impl<'tcx> LateLintPass<'tcx> for UnusedIoAmount {
 
         match expr.kind {
             hir::ExprKind::Match(res, _, _) if is_try(cx, expr).is_some() => {
-                if let hir::ExprKind::Call(func, args) = res.kind {
+                if let hir::ExprKind::Call(func, [ref arg_0, ..]) = res.kind {
                     if matches!(
                         func.kind,
                         hir::ExprKind::Path(hir::QPath::LangItem(hir::LangItem::TryTraitBranch, _))
                     ) {
-                        check_map_error(cx, &args[0], expr);
+                        check_map_error(cx, arg_0, expr);
                     }
                 } else {
                     check_map_error(cx, res, expr);
                 }
             },
-            hir::ExprKind::MethodCall(path, _, args, _) => match &*path.ident.as_str() {
+            hir::ExprKind::MethodCall(path, _, [ref arg_0, ..], _) => match &*path.ident.as_str() {
                 "expect" | "unwrap" | "unwrap_or" | "unwrap_or_else" => {
-                    check_map_error(cx, &args[0], expr);
+                    check_map_error(cx, arg_0, expr);
                 },
                 _ => (),
             },
diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs
index 42d51272279..756c33d70c2 100644
--- a/clippy_lints/src/utils/internal_lints.rs
+++ b/clippy_lints/src/utils/internal_lints.rs
@@ -504,10 +504,10 @@ impl<'tcx> LateLintPass<'tcx> for CompilerLintFunctions {
         }
 
         if_chain! {
-            if let ExprKind::MethodCall(path, _, args, _) = expr.kind;
+            if let ExprKind::MethodCall(path, _, [self_arg, ..], _) = &expr.kind;
             let fn_name = path.ident;
             if let Some(sugg) = self.map.get(&*fn_name.as_str());
-            let ty = cx.typeck_results().expr_ty(&args[0]).peel_refs();
+            let ty = cx.typeck_results().expr_ty(self_arg).peel_refs();
             if match_type(cx, ty, &paths::EARLY_CONTEXT)
                 || match_type(cx, ty, &paths::LATE_CONTEXT);
             then {
-- 
cgit 1.4.1-3-g733a5


From a7a5a5d9b00e6ecc0e518b1e806c1f3e2d216502 Mon Sep 17 00:00:00 2001
From: Michael Wright <mikerite@lavabit.com>
Date: Tue, 7 Sep 2021 05:50:04 +0200
Subject: Add `TAU` to `approx_constant`

---
 clippy_lints/src/approx_const.rs |  3 ++-
 clippy_utils/src/msrvs.rs        |  1 +
 tests/ui/approx_const.rs         |  4 ++++
 tests/ui/approx_const.stderr     | 18 +++++++++++++++++-
 4 files changed, 24 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/approx_const.rs b/clippy_lints/src/approx_const.rs
index a57d8b67ed3..fb54ac1ec51 100644
--- a/clippy_lints/src/approx_const.rs
+++ b/clippy_lints/src/approx_const.rs
@@ -39,7 +39,7 @@ declare_clippy_lint! {
 }
 
 // Tuples are of the form (constant, name, min_digits, msrv)
-const KNOWN_CONSTS: [(f64, &str, usize, Option<RustcVersion>); 18] = [
+const KNOWN_CONSTS: [(f64, &str, usize, Option<RustcVersion>); 19] = [
     (f64::E, "E", 4, None),
     (f64::FRAC_1_PI, "FRAC_1_PI", 4, None),
     (f64::FRAC_1_SQRT_2, "FRAC_1_SQRT_2", 5, None),
@@ -58,6 +58,7 @@ const KNOWN_CONSTS: [(f64, &str, usize, Option<RustcVersion>); 18] = [
     (f64::LOG10_E, "LOG10_E", 5, None),
     (f64::PI, "PI", 3, None),
     (f64::SQRT_2, "SQRT_2", 5, None),
+    (f64::TAU, "TAU", 3, Some(msrvs::TAU)),
 ];
 
 pub struct ApproxConstant {
diff --git a/clippy_utils/src/msrvs.rs b/clippy_utils/src/msrvs.rs
index 6fab17f07fe..fa57dfbb57e 100644
--- a/clippy_utils/src/msrvs.rs
+++ b/clippy_utils/src/msrvs.rs
@@ -15,6 +15,7 @@ msrv_aliases! {
     1,53,0 { OR_PATTERNS }
     1,52,0 { STR_SPLIT_ONCE }
     1,50,0 { BOOL_THEN }
+    1,47,0 { TAU }
     1,46,0 { CONST_IF_MATCH }
     1,45,0 { STR_STRIP_PREFIX }
     1,43,0 { LOG2_10, LOG10_2 }
diff --git a/tests/ui/approx_const.rs b/tests/ui/approx_const.rs
index fb57a0becbb..2ae4d613507 100644
--- a/tests/ui/approx_const.rs
+++ b/tests/ui/approx_const.rs
@@ -57,4 +57,8 @@ fn main() {
 
     let my_sq2 = 1.4142;
     let no_sq2 = 1.414;
+
+    let my_tau = 6.2832;
+    let almost_tau = 6.28;
+    let no_tau = 6.3;
 }
diff --git a/tests/ui/approx_const.stderr b/tests/ui/approx_const.stderr
index a49fd40bf33..4da1b8215ae 100644
--- a/tests/ui/approx_const.stderr
+++ b/tests/ui/approx_const.stderr
@@ -167,5 +167,21 @@ LL |     let my_sq2 = 1.4142;
    |
    = help: consider using the constant directly
 
-error: aborting due to 21 previous errors
+error: approximate value of `f{32, 64}::consts::TAU` found
+  --> $DIR/approx_const.rs:61:18
+   |
+LL |     let my_tau = 6.2832;
+   |                  ^^^^^^
+   |
+   = help: consider using the constant directly
+
+error: approximate value of `f{32, 64}::consts::TAU` found
+  --> $DIR/approx_const.rs:62:22
+   |
+LL |     let almost_tau = 6.28;
+   |                      ^^^^
+   |
+   = help: consider using the constant directly
+
+error: aborting due to 23 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 8fbf75e0f9f7abf0f7820f1a89dfc230d3bc918f Mon Sep 17 00:00:00 2001
From: dswij <dswijj@gmail.com>
Date: Thu, 2 Sep 2021 16:04:46 +0800
Subject: `mut_range_bound` to check for immediate break from loop

---
 clippy_lints/src/loops/mut_range_bound.rs | 98 ++++++++++++++++++++++++-------
 1 file changed, 77 insertions(+), 21 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/mut_range_bound.rs b/clippy_lints/src/loops/mut_range_bound.rs
index 344dc5074d3..358d53e8859 100644
--- a/clippy_lints/src/loops/mut_range_bound.rs
+++ b/clippy_lints/src/loops/mut_range_bound.rs
@@ -1,24 +1,27 @@
 use super::MUT_RANGE_BOUND;
-use clippy_utils::diagnostics::span_lint;
-use clippy_utils::{higher, path_to_local};
+use clippy_utils::diagnostics::span_lint_and_note;
+use clippy_utils::{get_enclosing_block, higher, path_to_local};
 use if_chain::if_chain;
-use rustc_hir::{BindingAnnotation, Expr, HirId, Node, PatKind};
+use rustc_hir::intravisit::{self, NestedVisitorMap, Visitor};
+use rustc_hir::{BindingAnnotation, Expr, ExprKind, HirId, Node, PatKind};
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::LateContext;
+use rustc_middle::hir::map::Map;
 use rustc_middle::{mir::FakeReadCause, ty};
 use rustc_span::source_map::Span;
 use rustc_typeck::expr_use_visitor::{Delegate, ExprUseVisitor, PlaceBase, PlaceWithHirId};
 
 pub(super) fn check(cx: &LateContext<'_>, arg: &Expr<'_>, body: &Expr<'_>) {
-    if let Some(higher::Range {
-        start: Some(start),
-        end: Some(end),
-        ..
-    }) = higher::Range::hir(arg)
-    {
-        let mut_ids = vec![check_for_mutability(cx, start), check_for_mutability(cx, end)];
-        if mut_ids[0].is_some() || mut_ids[1].is_some() {
-            let (span_low, span_high) = check_for_mutation(cx, body, &mut_ids);
+    if_chain! {
+        if let Some(higher::Range {
+            start: Some(start),
+            end: Some(end),
+            ..
+        }) = higher::Range::hir(arg);
+        let (mut_id_start, mut_id_end) = (check_for_mutability(cx, start), check_for_mutability(cx, end));
+        if mut_id_start.is_some() || mut_id_end.is_some();
+        then {
+            let (span_low, span_high) = check_for_mutation(cx, body, mut_id_start, mut_id_end);
             mut_warn_with_span(cx, span_low);
             mut_warn_with_span(cx, span_high);
         }
@@ -27,11 +30,13 @@ pub(super) fn check(cx: &LateContext<'_>, arg: &Expr<'_>, body: &Expr<'_>) {
 
 fn mut_warn_with_span(cx: &LateContext<'_>, span: Option<Span>) {
     if let Some(sp) = span {
-        span_lint(
+        span_lint_and_note(
             cx,
             MUT_RANGE_BOUND,
             sp,
-            "attempt to mutate range bound within loop; note that the range of the loop is unchanged",
+            "attempt to mutate range bound within loop",
+            None,
+            "the range of the loop is unchanged",
         );
     }
 }
@@ -51,12 +56,13 @@ fn check_for_mutability(cx: &LateContext<'_>, bound: &Expr<'_>) -> Option<HirId>
 fn check_for_mutation<'tcx>(
     cx: &LateContext<'tcx>,
     body: &Expr<'_>,
-    bound_ids: &[Option<HirId>],
+    bound_id_start: Option<HirId>,
+    bound_id_end: Option<HirId>,
 ) -> (Option<Span>, Option<Span>) {
     let mut delegate = MutatePairDelegate {
         cx,
-        hir_id_low: bound_ids[0],
-        hir_id_high: bound_ids[1],
+        hir_id_low: bound_id_start,
+        hir_id_high: bound_id_end,
         span_low: None,
         span_high: None,
     };
@@ -70,6 +76,7 @@ fn check_for_mutation<'tcx>(
         )
         .walk_expr(body);
     });
+
     delegate.mutation_span()
 }
 
@@ -87,10 +94,10 @@ impl<'tcx> Delegate<'tcx> for MutatePairDelegate<'_, 'tcx> {
     fn borrow(&mut self, cmt: &PlaceWithHirId<'tcx>, diag_expr_id: HirId, bk: ty::BorrowKind) {
         if let ty::BorrowKind::MutBorrow = bk {
             if let PlaceBase::Local(id) = cmt.place.base {
-                if Some(id) == self.hir_id_low {
+                if Some(id) == self.hir_id_low && !BreakAfterExprVisitor::is_found(self.cx, diag_expr_id) {
                     self.span_low = Some(self.cx.tcx.hir().span(diag_expr_id));
                 }
-                if Some(id) == self.hir_id_high {
+                if Some(id) == self.hir_id_high && !BreakAfterExprVisitor::is_found(self.cx, diag_expr_id) {
                     self.span_high = Some(self.cx.tcx.hir().span(diag_expr_id));
                 }
             }
@@ -99,10 +106,10 @@ impl<'tcx> Delegate<'tcx> for MutatePairDelegate<'_, 'tcx> {
 
     fn mutate(&mut self, cmt: &PlaceWithHirId<'tcx>, diag_expr_id: HirId) {
         if let PlaceBase::Local(id) = cmt.place.base {
-            if Some(id) == self.hir_id_low {
+            if Some(id) == self.hir_id_low && !BreakAfterExprVisitor::is_found(self.cx, diag_expr_id) {
                 self.span_low = Some(self.cx.tcx.hir().span(diag_expr_id));
             }
-            if Some(id) == self.hir_id_high {
+            if Some(id) == self.hir_id_high && !BreakAfterExprVisitor::is_found(self.cx, diag_expr_id) {
                 self.span_high = Some(self.cx.tcx.hir().span(diag_expr_id));
             }
         }
@@ -116,3 +123,52 @@ impl MutatePairDelegate<'_, '_> {
         (self.span_low, self.span_high)
     }
 }
+
+struct BreakAfterExprVisitor {
+    hir_id: HirId,
+    past_expr: bool,
+    past_candidate: bool,
+    break_after_expr: bool,
+}
+
+impl BreakAfterExprVisitor {
+    pub fn is_found(cx: &LateContext<'_>, hir_id: HirId) -> bool {
+        let mut visitor = BreakAfterExprVisitor {
+            hir_id,
+            past_expr: false,
+            past_candidate: false,
+            break_after_expr: false,
+        };
+
+        get_enclosing_block(cx, hir_id).map_or(false, |block| {
+            visitor.visit_block(block);
+            visitor.break_after_expr
+        })
+    }
+}
+
+impl intravisit::Visitor<'tcx> for BreakAfterExprVisitor {
+    type Map = Map<'tcx>;
+
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::None
+    }
+
+    fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) {
+        if self.past_candidate {
+            return;
+        }
+
+        if expr.hir_id == self.hir_id {
+            self.past_expr = true;
+        } else if self.past_expr {
+            if matches!(&expr.kind, ExprKind::Break(..)) {
+                self.break_after_expr = true;
+            }
+
+            self.past_candidate = true;
+        } else {
+            intravisit::walk_expr(self, expr);
+        }
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From dc6f7dc6bf13295d5249c7f2a9aa71024b6555ad Mon Sep 17 00:00:00 2001
From: dswij <dswijj@gmail.com>
Date: Tue, 7 Sep 2021 06:07:50 +0800
Subject: Add known problems to `mut_range_bound` docs

---
 clippy_lints/src/loops/mod.rs | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/mod.rs b/clippy_lints/src/loops/mod.rs
index 97cbe2c53dd..2860cb68f42 100644
--- a/clippy_lints/src/loops/mod.rs
+++ b/clippy_lints/src/loops/mod.rs
@@ -397,6 +397,21 @@ declare_clippy_lint! {
     /// ### Why is this bad?
     /// One might think that modifying the mutable variable changes the loop bounds
     ///
+    /// ### Known problems
+    /// False positive when mutation is followed by a `break`, but the `break` is not immediately
+    /// after the mutation:
+    ///
+    /// ```rust
+    /// let mut x = 5;
+    /// for _ in 0..x {
+    ///     x += 1; // x is a range bound that is mutated
+    ///     ..; // some other expression
+    ///     break; // leaves the loop, so mutation is not an issue
+    /// }
+    /// ```
+    ///
+    /// False positive on nested loops ([#6072](https://github.com/rust-lang/rust-clippy/issues/6072))
+    ///
     /// ### Example
     /// ```rust
     /// let mut foo = 42;
-- 
cgit 1.4.1-3-g733a5


From 293db0d33c06f1642af51df0afcb6f5e0fd0eb10 Mon Sep 17 00:00:00 2001
From: Ariel Davis <ariel.z.davis@icloud.com>
Date: Wed, 8 Sep 2021 21:12:02 -0400
Subject: Allow giving reasons for disallowed_methods

---
 clippy_lints/src/disallowed_method.rs              | 84 ++++++++++++----------
 clippy_lints/src/lib.rs                            |  4 +-
 clippy_lints/src/utils/conf.rs                     | 10 ++-
 tests/ui-toml/toml_disallowed_method/clippy.toml   |  7 +-
 .../conf_disallowed_method.stderr                  |  8 ++-
 5 files changed, 69 insertions(+), 44 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/disallowed_method.rs b/clippy_lints/src/disallowed_method.rs
index 7069cb4198c..1167b26c8f1 100644
--- a/clippy_lints/src/disallowed_method.rs
+++ b/clippy_lints/src/disallowed_method.rs
@@ -1,33 +1,44 @@
-use clippy_utils::diagnostics::span_lint;
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::fn_def_id;
 
-use rustc_data_structures::fx::FxHashSet;
-use rustc_hir::{def::Res, def_id::DefId, Crate, Expr};
+use rustc_hir::{def::Res, def_id::DefIdMap, Crate, Expr};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::Symbol;
+
+use crate::utils::conf;
 
 declare_clippy_lint! {
     /// ### What it does
     /// Denies the configured methods and functions in clippy.toml
     ///
     /// ### Why is this bad?
-    /// Some methods are undesirable in certain contexts,
-    /// and it's beneficial to lint for them as needed.
+    /// Some methods are undesirable in certain contexts, and it's beneficial to
+    /// lint for them as needed.
     ///
     /// ### Example
     /// An example clippy.toml configuration:
     /// ```toml
     /// # clippy.toml
-    /// disallowed-methods = ["std::vec::Vec::leak", "std::time::Instant::now"]
+    /// disallowed-methods = [
+    ///     # Can use a string as the path of the disallowed method.
+    ///     "std::boxed::Box::new",
+    ///     # Can also use an inline table with a `path` key.
+    ///     { path = "std::time::Instant::now" },
+    ///     # When using an inline table, can add a `reason` for why the method
+    ///     # is disallowed.
+    ///     { path = "std::vec::Vec::leak", reason = "no leaking memory" },
+    /// ]
     /// ```
     ///
     /// ```rust,ignore
     /// // Example code where clippy issues a warning
     /// let xs = vec![1, 2, 3, 4];
     /// xs.leak(); // Vec::leak is disallowed in the config.
+    /// // The diagnostic contains the message "no leaking memory".
     ///
     /// let _now = Instant::now(); // Instant::now is disallowed in the config.
+    ///
+    /// let _box = Box::new(3); // Box::new is disallowed in the config.
     /// ```
     ///
     /// Use instead:
@@ -43,18 +54,15 @@ declare_clippy_lint! {
 
 #[derive(Clone, Debug)]
 pub struct DisallowedMethod {
-    disallowed: FxHashSet<Vec<Symbol>>,
-    def_ids: FxHashSet<(DefId, Vec<Symbol>)>,
+    conf_disallowed: Vec<conf::DisallowedMethod>,
+    disallowed: DefIdMap<Option<String>>,
 }
 
 impl DisallowedMethod {
-    pub fn new(disallowed: &FxHashSet<String>) -> Self {
+    pub fn new(conf_disallowed: Vec<conf::DisallowedMethod>) -> Self {
         Self {
-            disallowed: disallowed
-                .iter()
-                .map(|s| s.split("::").map(|seg| Symbol::intern(seg)).collect::<Vec<_>>())
-                .collect(),
-            def_ids: FxHashSet::default(),
+            conf_disallowed,
+            disallowed: DefIdMap::default(),
         }
     }
 }
@@ -63,32 +71,36 @@ impl_lint_pass!(DisallowedMethod => [DISALLOWED_METHOD]);
 
 impl<'tcx> LateLintPass<'tcx> for DisallowedMethod {
     fn check_crate(&mut self, cx: &LateContext<'_>, _: &Crate<'_>) {
-        for path in &self.disallowed {
-            let segs = path.iter().map(ToString::to_string).collect::<Vec<_>>();
-            if let Res::Def(_, id) = clippy_utils::path_to_res(cx, &segs.iter().map(String::as_str).collect::<Vec<_>>())
-            {
-                self.def_ids.insert((id, path.clone()));
+        for conf in &self.conf_disallowed {
+            let (path, reason) = match conf {
+                conf::DisallowedMethod::Simple(path) => (path, None),
+                conf::DisallowedMethod::WithReason { path, reason } => (
+                    path,
+                    reason.as_ref().map(|reason| format!("{} (from clippy.toml)", reason)),
+                ),
+            };
+            let segs: Vec<_> = path.split("::").collect();
+            if let Res::Def(_, id) = clippy_utils::path_to_res(cx, &segs) {
+                self.disallowed.insert(id, reason);
             }
         }
     }
 
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if let Some(def_id) = fn_def_id(cx, expr) {
-            if self.def_ids.iter().any(|(id, _)| def_id == *id) {
-                let func_path = cx.get_def_path(def_id);
-                let func_path_string = func_path
-                    .into_iter()
-                    .map(Symbol::to_ident_string)
-                    .collect::<Vec<_>>()
-                    .join("::");
-
-                span_lint(
-                    cx,
-                    DISALLOWED_METHOD,
-                    expr.span,
-                    &format!("use of a disallowed method `{}`", func_path_string),
-                );
+        let def_id = match fn_def_id(cx, expr) {
+            Some(def_id) => def_id,
+            None => return,
+        };
+        let reason = match self.disallowed.get(&def_id) {
+            Some(reason) => reason,
+            None => return,
+        };
+        let func_path = cx.tcx.def_path_str(def_id);
+        let msg = format!("use of a disallowed method `{}`", func_path);
+        span_lint_and_then(cx, DISALLOWED_METHOD, expr.span, &msg, |diag| {
+            if let Some(reason) = reason {
+                diag.note(reason);
             }
-        }
+        });
     }
 }
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 92a13be81f4..9544309ae4f 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -2105,8 +2105,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(float_equality_without_abs::FloatEqualityWithoutAbs));
     store.register_late_pass(|| Box::new(semicolon_if_nothing_returned::SemicolonIfNothingReturned));
     store.register_late_pass(|| Box::new(async_yields_async::AsyncYieldsAsync));
-    let disallowed_methods = conf.disallowed_methods.iter().cloned().collect::<FxHashSet<_>>();
-    store.register_late_pass(move || Box::new(disallowed_method::DisallowedMethod::new(&disallowed_methods)));
+    let disallowed_methods = conf.disallowed_methods.clone();
+    store.register_late_pass(move || Box::new(disallowed_method::DisallowedMethod::new(disallowed_methods.clone())));
     store.register_early_pass(|| Box::new(asm_syntax::InlineAsmX86AttSyntax));
     store.register_early_pass(|| Box::new(asm_syntax::InlineAsmX86IntelSyntax));
     store.register_late_pass(|| Box::new(undropped_manually_drops::UndroppedManuallyDrops));
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 8651fa6fcf9..8b087507b11 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -15,6 +15,14 @@ pub struct Rename {
     pub rename: String,
 }
 
+/// A single disallowed method, used by the `DISALLOWED_METHOD` lint.
+#[derive(Clone, Debug, Deserialize)]
+#[serde(untagged)]
+pub enum DisallowedMethod {
+    Simple(String),
+    WithReason { path: String, reason: Option<String> },
+}
+
 /// Conf with parse errors
 #[derive(Default)]
 pub struct TryConf {
@@ -243,7 +251,7 @@ define_Conf! {
     /// Lint: DISALLOWED_METHOD.
     ///
     /// The list of disallowed methods, written as fully qualified paths.
-    (disallowed_methods: Vec<String> = Vec::new()),
+    (disallowed_methods: Vec<crate::utils::conf::DisallowedMethod> = Vec::new()),
     /// Lint: DISALLOWED_TYPE.
     ///
     /// The list of disallowed types, written as fully qualified paths.
diff --git a/tests/ui-toml/toml_disallowed_method/clippy.toml b/tests/ui-toml/toml_disallowed_method/clippy.toml
index a3245da6825..f1d4a4619c5 100644
--- a/tests/ui-toml/toml_disallowed_method/clippy.toml
+++ b/tests/ui-toml/toml_disallowed_method/clippy.toml
@@ -1,5 +1,8 @@
 disallowed-methods = [
+    # just a string is shorthand for path only
     "std::iter::Iterator::sum",
-    "regex::Regex::is_match",
-    "regex::Regex::new"
+    # can give path and reason with an inline table
+    { path = "regex::Regex::is_match", reason = "no matching allowed" },
+    # can use an inline table but omit reason
+    { path = "regex::Regex::new" },
 ]
diff --git a/tests/ui-toml/toml_disallowed_method/conf_disallowed_method.stderr b/tests/ui-toml/toml_disallowed_method/conf_disallowed_method.stderr
index 2b628c67fa7..38123220a43 100644
--- a/tests/ui-toml/toml_disallowed_method/conf_disallowed_method.stderr
+++ b/tests/ui-toml/toml_disallowed_method/conf_disallowed_method.stderr
@@ -1,4 +1,4 @@
-error: use of a disallowed method `regex::re_unicode::Regex::new`
+error: use of a disallowed method `regex::Regex::new`
   --> $DIR/conf_disallowed_method.rs:7:14
    |
 LL |     let re = Regex::new(r"ab.*c").unwrap();
@@ -6,13 +6,15 @@ LL |     let re = Regex::new(r"ab.*c").unwrap();
    |
    = note: `-D clippy::disallowed-method` implied by `-D warnings`
 
-error: use of a disallowed method `regex::re_unicode::Regex::is_match`
+error: use of a disallowed method `regex::Regex::is_match`
   --> $DIR/conf_disallowed_method.rs:8:5
    |
 LL |     re.is_match("abc");
    |     ^^^^^^^^^^^^^^^^^^
+   |
+   = note: no matching allowed (from clippy.toml)
 
-error: use of a disallowed method `core::iter::traits::iterator::Iterator::sum`
+error: use of a disallowed method `std::iter::Iterator::sum`
   --> $DIR/conf_disallowed_method.rs:11:5
    |
 LL |     a.iter().sum::<i32>();
-- 
cgit 1.4.1-3-g733a5


From 8f88acdbfa6073eefbfcd773619d460fdfec122a Mon Sep 17 00:00:00 2001
From: Labelray <labelray@icloud.com>
Date: Tue, 7 Sep 2021 09:59:21 +0800
Subject: add new lint `iter_not_returning_iterator`

---
 CHANGELOG.md                                    |  1 +
 clippy_lints/src/iter_not_returning_iterator.rs | 64 +++++++++++++++++++++++++
 clippy_lints/src/lib.rs                         |  4 ++
 tests/ui/iter_not_returning_iterator.rs         | 47 ++++++++++++++++++
 tests/ui/iter_not_returning_iterator.stderr     | 16 +++++++
 5 files changed, 132 insertions(+)
 create mode 100644 clippy_lints/src/iter_not_returning_iterator.rs
 create mode 100644 tests/ui/iter_not_returning_iterator.rs
 create mode 100644 tests/ui/iter_not_returning_iterator.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index f5ac2f7c9f8..71383e8116b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2722,6 +2722,7 @@ Released 2018-09-13
 [`iter_count`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_count
 [`iter_next_loop`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_next_loop
 [`iter_next_slice`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_next_slice
+[`iter_not_returning_iterator`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_not_returning_iterator
 [`iter_nth`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_nth
 [`iter_nth_zero`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_nth_zero
 [`iter_skip_next`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_skip_next
diff --git a/clippy_lints/src/iter_not_returning_iterator.rs b/clippy_lints/src/iter_not_returning_iterator.rs
new file mode 100644
index 00000000000..6c779348ca2
--- /dev/null
+++ b/clippy_lints/src/iter_not_returning_iterator.rs
@@ -0,0 +1,64 @@
+use clippy_utils::{diagnostics::span_lint, return_ty, ty::implements_trait};
+use rustc_hir::{ImplItem, ImplItemKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::symbol::kw;
+use rustc_span::symbol::sym;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Detects methods named `iter` or `iter_mut` that do not have a return type that implements `Iterator`.
+    ///
+    /// ### Why is this bad?
+    /// Methods named `iter` or `iter_mut` conventionally return an `Iterator`.
+    ///
+    /// ### Example
+    /// ```rust
+    /// // `String` does not implement `Iterator`
+    /// struct Data {}
+    /// impl Data {
+    ///     fn iter(&self) -> String {
+    ///         todo!()
+    ///     }
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// use std::str::Chars;
+    /// struct Data {}
+    /// impl Data {
+    ///    fn iter(&self) -> Chars<'static> {
+    ///        todo!()
+    ///    }
+    /// }
+    /// ```
+    pub ITER_NOT_RETURNING_ITERATOR,
+    pedantic,
+    "methods named `iter` or `iter_mut` that do not return an `Iterator`"
+}
+
+declare_lint_pass!(IterNotReturningIterator => [ITER_NOT_RETURNING_ITERATOR]);
+
+impl LateLintPass<'_> for IterNotReturningIterator {
+    fn check_impl_item(&mut self, cx: &LateContext<'tcx>, impl_item: &'tcx ImplItem<'tcx>) {
+        let name: &str = &impl_item.ident.name.as_str();
+        if_chain! {
+            if let ImplItemKind::Fn(fn_sig, _) = &impl_item.kind;
+            let ret_ty = return_ty(cx, impl_item.hir_id());
+            if matches!(name, "iter" | "iter_mut");
+            if let [param] = cx.tcx.fn_arg_names(impl_item.def_id);
+            if param.name == kw::SelfLower;
+            if let Some(iter_trait_id) = cx.tcx.get_diagnostic_item(sym::Iterator);
+            if !implements_trait(cx, ret_ty, iter_trait_id, &[]);
+
+            then {
+                span_lint(
+                    cx,
+                    ITER_NOT_RETURNING_ITERATOR,
+                    fn_sig.span,
+                    &format!("this method is named `{}` but its return type does not implement `Iterator`", name),
+                );
+            }
+        }
+    }
+}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 92a13be81f4..63deb46dc73 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -241,6 +241,7 @@ mod int_plus_one;
 mod integer_division;
 mod invalid_upcast_comparisons;
 mod items_after_statements;
+mod iter_not_returning_iterator;
 mod large_const_arrays;
 mod large_enum_variant;
 mod large_stack_arrays;
@@ -674,6 +675,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         integer_division::INTEGER_DIVISION,
         invalid_upcast_comparisons::INVALID_UPCAST_COMPARISONS,
         items_after_statements::ITEMS_AFTER_STATEMENTS,
+        iter_not_returning_iterator::ITER_NOT_RETURNING_ITERATOR,
         large_const_arrays::LARGE_CONST_ARRAYS,
         large_enum_variant::LARGE_ENUM_VARIANT,
         large_stack_arrays::LARGE_STACK_ARRAYS,
@@ -1104,6 +1106,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(infinite_iter::MAYBE_INFINITE_ITER),
         LintId::of(invalid_upcast_comparisons::INVALID_UPCAST_COMPARISONS),
         LintId::of(items_after_statements::ITEMS_AFTER_STATEMENTS),
+        LintId::of(iter_not_returning_iterator::ITER_NOT_RETURNING_ITERATOR),
         LintId::of(large_stack_arrays::LARGE_STACK_ARRAYS),
         LintId::of(let_underscore::LET_UNDERSCORE_DROP),
         LintId::of(literal_representation::LARGE_DIGIT_GROUPS),
@@ -2131,6 +2134,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(strlen_on_c_strings::StrlenOnCStrings));
     store.register_late_pass(move || Box::new(self_named_constructors::SelfNamedConstructors));
     store.register_late_pass(move || Box::new(feature_name::FeatureName));
+    store.register_late_pass(move || Box::new(iter_not_returning_iterator::IterNotReturningIterator));
 }
 
 #[rustfmt::skip]
diff --git a/tests/ui/iter_not_returning_iterator.rs b/tests/ui/iter_not_returning_iterator.rs
new file mode 100644
index 00000000000..377f760b3c4
--- /dev/null
+++ b/tests/ui/iter_not_returning_iterator.rs
@@ -0,0 +1,47 @@
+#![warn(clippy::iter_not_returning_iterator)]
+
+struct Data {
+    begin: u32,
+}
+
+struct Counter {
+    count: u32,
+}
+
+impl Data {
+    fn iter(&self) -> Counter {
+        todo!()
+    }
+
+    fn iter_mut(&self) -> Counter {
+        todo!()
+    }
+}
+
+struct Data2 {
+    begin: u32,
+}
+
+struct Counter2 {
+    count: u32,
+}
+
+impl Data2 {
+    fn iter(&self) -> Counter2 {
+        todo!()
+    }
+
+    fn iter_mut(&self) -> Counter2 {
+        todo!()
+    }
+}
+
+impl Iterator for Counter {
+    type Item = u32;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        todo!()
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/iter_not_returning_iterator.stderr b/tests/ui/iter_not_returning_iterator.stderr
new file mode 100644
index 00000000000..2273cd0be66
--- /dev/null
+++ b/tests/ui/iter_not_returning_iterator.stderr
@@ -0,0 +1,16 @@
+error: this method is named `iter` but its return type does not implement `Iterator`
+  --> $DIR/iter_not_returning_iterator.rs:30:5
+   |
+LL |     fn iter(&self) -> Counter2 {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::iter-not-returning-iterator` implied by `-D warnings`
+
+error: this method is named `iter_mut` but its return type does not implement `Iterator`
+  --> $DIR/iter_not_returning_iterator.rs:34:5
+   |
+LL |     fn iter_mut(&self) -> Counter2 {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 5782dc0eb992a4975eca370345e1ba455d12faa4 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Thu, 9 Sep 2021 15:35:26 -0500
Subject: Fix redundant closure bugs

---
 clippy_lints/src/eta_reduction.rs             | 240 ++++++++++----------------
 tests/ui/eta.fixed                            |  63 ++++---
 tests/ui/eta.rs                               |  55 +++---
 tests/ui/eta.stderr                           |  66 ++++---
 tests/ui/map_flatten.fixed                    |   1 +
 tests/ui/map_flatten.rs                       |   1 +
 tests/ui/map_flatten.stderr                   |  14 +-
 tests/ui/semicolon_if_nothing_returned.rs     |   5 +-
 tests/ui/semicolon_if_nothing_returned.stderr |  12 +-
 9 files changed, 227 insertions(+), 230 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/eta_reduction.rs b/clippy_lints/src/eta_reduction.rs
index f6a64a8ca60..9df92cc5b64 100644
--- a/clippy_lints/src/eta_reduction.rs
+++ b/clippy_lints/src/eta_reduction.rs
@@ -1,16 +1,16 @@
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::higher::VecArgs;
 use clippy_utils::source::snippet_opt;
-use clippy_utils::ty::{implements_trait, type_is_unsafe_function};
 use clippy_utils::usage::UsedAfterExprVisitor;
-use clippy_utils::{get_enclosing_loop_or_closure, higher};
-use clippy_utils::{is_adjusted, iter_input_pats};
+use clippy_utils::{get_enclosing_loop_or_closure, higher, path_to_local_id};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
-use rustc_hir::{def_id, Expr, ExprKind, Param, PatKind, QPath};
-use rustc_lint::{LateContext, LateLintPass, LintContext};
-use rustc_middle::lint::in_external_macro;
-use rustc_middle::ty::{self, ClosureKind, Ty};
+use rustc_hir::def_id::DefId;
+use rustc_hir::{Expr, ExprKind, Param, PatKind, Unsafety};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::adjustment::{Adjust, Adjustment, AutoBorrow};
+use rustc_middle::ty::subst::Subst;
+use rustc_middle::ty::{self, ClosureKind, Ty, TypeFoldable};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
@@ -52,12 +52,6 @@ declare_clippy_lint! {
     /// ### Why is this bad?
     /// It's unnecessary to create the closure.
     ///
-    /// ### Known problems
-    /// [#3071](https://github.com/rust-lang/rust-clippy/issues/3071),
-    /// [#3942](https://github.com/rust-lang/rust-clippy/issues/3942),
-    /// [#4002](https://github.com/rust-lang/rust-clippy/issues/4002)
-    ///
-    ///
     /// ### Example
     /// ```rust,ignore
     /// Some('a').map(|s| s.to_uppercase());
@@ -75,32 +69,16 @@ declare_lint_pass!(EtaReduction => [REDUNDANT_CLOSURE, REDUNDANT_CLOSURE_FOR_MET
 
 impl<'tcx> LateLintPass<'tcx> for EtaReduction {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if in_external_macro(cx.sess(), expr.span) {
+        if expr.span.from_expansion() {
             return;
         }
-
-        match expr.kind {
-            ExprKind::Call(_, args) | ExprKind::MethodCall(_, _, args, _) => {
-                for arg in args {
-                    // skip `foo(macro!())`
-                    if arg.span.ctxt() == expr.span.ctxt() {
-                        check_closure(cx, arg);
-                    }
-                }
-            },
-            _ => (),
-        }
-    }
-}
-
-fn check_closure<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-    if let ExprKind::Closure(_, decl, eid, _, _) = expr.kind {
-        let body = cx.tcx.hir().body(eid);
-        let ex = &body.value;
-
-        if ex.span.ctxt() != expr.span.ctxt() {
-            if decl.inputs.is_empty() {
-                if let Some(VecArgs::Vec(&[])) = higher::VecArgs::hir(cx, ex) {
+        let body = match expr.kind {
+            ExprKind::Closure(_, _, id, _, _) => cx.tcx.hir().body(id),
+            _ => return,
+        };
+        if body.value.span.from_expansion() {
+            if body.params.is_empty() {
+                if let Some(VecArgs::Vec(&[])) = higher::VecArgs::hir(cx, &body.value) {
                     // replace `|| vec![]` with `Vec::new`
                     span_lint_and_sugg(
                         cx,
@@ -117,33 +95,30 @@ fn check_closure<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
             return;
         }
 
-        if_chain!(
-            if let ExprKind::Call(caller, args) = ex.kind;
-
-            if let ExprKind::Path(_) = caller.kind;
-
-            // Not the same number of arguments, there is no way the closure is the same as the function return;
-            if args.len() == decl.inputs.len();
-
-            // Are the expression or the arguments type-adjusted? Then we need the closure
-            if !(is_adjusted(cx, ex) || args.iter().any(|arg| is_adjusted(cx, arg)));
-
-            let fn_ty = cx.typeck_results().expr_ty(caller);
-
-            if matches!(fn_ty.kind(), ty::FnDef(_, _) | ty::FnPtr(_) | ty::Closure(_, _));
-
-            if !type_is_unsafe_function(cx, fn_ty);
-
-            if compare_inputs(&mut iter_input_pats(decl, body), &mut args.iter());
+        let closure_ty = cx.typeck_results().expr_ty(expr);
 
+        if_chain!(
+            if let ExprKind::Call(callee, args) = body.value.kind;
+            if let ExprKind::Path(_) = callee.kind;
+            if check_inputs(cx, body.params, args);
+            let callee_ty = cx.typeck_results().expr_ty_adjusted(callee);
+            let call_ty = cx.typeck_results().type_dependent_def_id(body.value.hir_id)
+                .map_or(callee_ty, |id| cx.tcx.type_of(id));
+            if check_sig(cx, closure_ty, call_ty);
+            let substs = cx.typeck_results().node_substs(callee.hir_id);
+            // This fixes some false positives that I don't entirely understand
+            if substs.is_empty() || !cx.typeck_results().expr_ty(expr).has_late_bound_regions();
+            // A type param function ref like `T::f` is not 'static, however
+            // it is if cast like `T::f as fn()`. This seems like a rustc bug.
+            if !substs.types().any(|t| matches!(t.kind(), ty::Param(_)));
             then {
                 span_lint_and_then(cx, REDUNDANT_CLOSURE, expr.span, "redundant closure", |diag| {
-                    if let Some(mut snippet) = snippet_opt(cx, caller.span) {
+                    if let Some(mut snippet) = snippet_opt(cx, callee.span) {
                         if_chain! {
-                            if let ty::Closure(_, substs) = fn_ty.kind();
+                            if let ty::Closure(_, substs) = callee_ty.peel_refs().kind();
                             if let ClosureKind::FnMut = substs.as_closure().kind();
-                            if UsedAfterExprVisitor::is_found(cx, caller)
-                                || get_enclosing_loop_or_closure(cx.tcx, expr).is_some();
+                            if get_enclosing_loop_or_closure(cx.tcx, expr).is_some()
+                                || UsedAfterExprVisitor::is_found(cx, callee);
 
                             then {
                                 // Mutable closure is used after current expr; we cannot consume it.
@@ -162,110 +137,79 @@ fn check_closure<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         );
 
         if_chain!(
-            if let ExprKind::MethodCall(path, _, args, _) = ex.kind;
-
-            // Not the same number of arguments, there is no way the closure is the same as the function return;
-            if args.len() == decl.inputs.len();
-
-            // Are the expression or the arguments type-adjusted? Then we need the closure
-            if !(is_adjusted(cx, ex) || args.iter().skip(1).any(|arg| is_adjusted(cx, arg)));
-
-            let method_def_id = cx.typeck_results().type_dependent_def_id(ex.hir_id).unwrap();
-            if !type_is_unsafe_function(cx, cx.tcx.type_of(method_def_id));
-
-            if compare_inputs(&mut iter_input_pats(decl, body), &mut args.iter());
-
-            if let Some(name) = get_ufcs_type_name(cx, method_def_id, &args[0]);
-
+            if let ExprKind::MethodCall(path, _, args, _) = body.value.kind;
+            if check_inputs(cx, body.params, args);
+            let method_def_id = cx.typeck_results().type_dependent_def_id(body.value.hir_id).unwrap();
+            let substs = cx.typeck_results().node_substs(body.value.hir_id);
+            let call_ty = cx.tcx.type_of(method_def_id).subst(cx.tcx, substs);
+            if check_sig(cx, closure_ty, call_ty);
             then {
-                span_lint_and_sugg(
-                    cx,
-                    REDUNDANT_CLOSURE_FOR_METHOD_CALLS,
-                    expr.span,
-                    "redundant closure",
-                    "replace the closure with the method itself",
-                    format!("{}::{}", name, path.ident.name),
-                    Applicability::MachineApplicable,
-                );
+                span_lint_and_then(cx, REDUNDANT_CLOSURE_FOR_METHOD_CALLS, expr.span, "redundant closure", |diag| {
+                    let name = get_ufcs_type_name(cx, method_def_id);
+                    diag.span_suggestion(
+                        expr.span,
+                        "replace the closure with the method itself",
+                        format!("{}::{}", name, path.ident.name),
+                        Applicability::MachineApplicable,
+                    );
+                })
             }
         );
     }
 }
 
-/// Tries to determine the type for universal function call to be used instead of the closure
-fn get_ufcs_type_name(cx: &LateContext<'_>, method_def_id: def_id::DefId, self_arg: &Expr<'_>) -> Option<String> {
-    let expected_type_of_self = &cx.tcx.fn_sig(method_def_id).inputs_and_output().skip_binder()[0];
-    let actual_type_of_self = &cx.typeck_results().node_type(self_arg.hir_id);
-
-    if let Some(trait_id) = cx.tcx.trait_of_item(method_def_id) {
-        if match_borrow_depth(expected_type_of_self, actual_type_of_self)
-            && implements_trait(cx, actual_type_of_self, trait_id, &[])
-        {
-            return Some(cx.tcx.def_path_str(trait_id));
-        }
+fn check_inputs(cx: &LateContext<'_>, params: &[Param<'_>], call_args: &[Expr<'_>]) -> bool {
+    if params.len() != call_args.len() {
+        return false;
     }
-
-    cx.tcx.impl_of_method(method_def_id).and_then(|_| {
-        //a type may implicitly implement other type's methods (e.g. Deref)
-        if match_types(expected_type_of_self, actual_type_of_self) {
-            Some(get_type_name(cx, actual_type_of_self))
-        } else {
-            None
+    std::iter::zip(params, call_args).all(|(param, arg)| {
+        match param.pat.kind {
+            PatKind::Binding(_, id, ..) if path_to_local_id(arg, id) => {},
+            _ => return false,
+        }
+        match *cx.typeck_results().expr_adjustments(arg) {
+            [] => true,
+            [Adjustment {
+                kind: Adjust::Deref(None),
+                ..
+            }, Adjustment {
+                kind: Adjust::Borrow(AutoBorrow::Ref(_, mu2)),
+                ..
+            }] => {
+                // re-borrow with the same mutability is allowed
+                let ty = cx.typeck_results().expr_ty(arg);
+                matches!(*ty.kind(), ty::Ref(.., mu1) if mu1 == mu2.into())
+            },
+            _ => false,
         }
     })
 }
 
-fn match_borrow_depth(lhs: Ty<'_>, rhs: Ty<'_>) -> bool {
-    match (&lhs.kind(), &rhs.kind()) {
-        (ty::Ref(_, t1, mut1), ty::Ref(_, t2, mut2)) => mut1 == mut2 && match_borrow_depth(t1, t2),
-        (l, r) => !matches!((l, r), (ty::Ref(_, _, _), _) | (_, ty::Ref(_, _, _))),
-    }
-}
-
-fn match_types(lhs: Ty<'_>, rhs: Ty<'_>) -> bool {
-    match (&lhs.kind(), &rhs.kind()) {
-        (ty::Bool, ty::Bool)
-        | (ty::Char, ty::Char)
-        | (ty::Int(_), ty::Int(_))
-        | (ty::Uint(_), ty::Uint(_))
-        | (ty::Str, ty::Str) => true,
-        (ty::Ref(_, t1, mut1), ty::Ref(_, t2, mut2)) => mut1 == mut2 && match_types(t1, t2),
-        (ty::Array(t1, _), ty::Array(t2, _)) | (ty::Slice(t1), ty::Slice(t2)) => match_types(t1, t2),
-        (ty::Adt(def1, _), ty::Adt(def2, _)) => def1 == def2,
-        (_, _) => false,
+fn check_sig<'tcx>(cx: &LateContext<'tcx>, closure_ty: Ty<'tcx>, call_ty: Ty<'tcx>) -> bool {
+    let call_sig = call_ty.fn_sig(cx.tcx);
+    if call_sig.unsafety() == Unsafety::Unsafe {
+        return false;
     }
-}
-
-fn get_type_name(cx: &LateContext<'_>, ty: Ty<'_>) -> String {
-    match ty.kind() {
-        ty::Adt(t, _) => cx.tcx.def_path_str(t.did),
-        ty::Ref(_, r, _) => get_type_name(cx, r),
-        _ => ty.to_string(),
+    if !closure_ty.has_late_bound_regions() {
+        return true;
     }
+    let substs = match closure_ty.kind() {
+        ty::Closure(_, substs) => substs,
+        _ => return false,
+    };
+    let closure_sig = cx.tcx.signature_unclosure(substs.as_closure().sig(), Unsafety::Normal);
+    cx.tcx.erase_late_bound_regions(closure_sig) == cx.tcx.erase_late_bound_regions(call_sig)
 }
 
-fn compare_inputs(
-    closure_inputs: &mut dyn Iterator<Item = &Param<'_>>,
-    call_args: &mut dyn Iterator<Item = &Expr<'_>>,
-) -> bool {
-    for (closure_input, function_arg) in closure_inputs.zip(call_args) {
-        if let PatKind::Binding(_, _, ident, _) = closure_input.pat.kind {
-            // XXXManishearth Should I be checking the binding mode here?
-            if let ExprKind::Path(QPath::Resolved(None, p)) = function_arg.kind {
-                if p.segments.len() != 1 {
-                    // If it's a proper path, it can't be a local variable
-                    return false;
-                }
-                if p.segments[0].ident.name != ident.name {
-                    // The two idents should be the same
-                    return false;
-                }
-            } else {
-                return false;
+fn get_ufcs_type_name(cx: &LateContext<'_>, method_def_id: DefId) -> String {
+    match cx.tcx.associated_item(method_def_id).container {
+        ty::TraitContainer(def_id) => cx.tcx.def_path_str(def_id),
+        ty::ImplContainer(def_id) => {
+            let ty = cx.tcx.type_of(def_id);
+            match ty.kind() {
+                ty::Adt(adt, _) => cx.tcx.def_path_str(adt.did),
+                _ => ty.to_string(),
             }
-        } else {
-            return false;
-        }
+        },
     }
-    true
 }
diff --git a/tests/ui/eta.fixed b/tests/ui/eta.fixed
index 91b837f9a85..9d9a1a3e500 100644
--- a/tests/ui/eta.fixed
+++ b/tests/ui/eta.fixed
@@ -14,7 +14,7 @@
     clippy::needless_borrow
 )]
 
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 
 macro_rules! mac {
     () => {
@@ -30,19 +30,18 @@ macro_rules! closure_mac {
 
 fn main() {
     let a = Some(1u8).map(foo);
-    meta(foo);
     let c = Some(1u8).map(|a| {1+2; foo}(a));
     true.then(|| mac!()); // don't lint function in macro expansion
     Some(1).map(closure_mac!()); // don't lint closure in macro expansion
     let _: Option<Vec<u8>> = true.then(std::vec::Vec::new); // special case vec!
-    let d = Some(1u8).map(|a| foo((|b| foo2(b))(a))); //is adjusted?
-    all(&[1, 2, 3], &2, |x, y| below(x, y)); //is adjusted
+    let d = Some(1u8).map(|a| foo(foo2(a))); //is adjusted?
+    all(&[1, 2, 3], &2, below); //is adjusted
     unsafe {
         Some(1u8).map(|a| unsafe_fn(a)); // unsafe fn
     }
 
     // See #815
-    let e = Some(1u8).map(|a| divergent(a));
+    let e = Some(1u8).map(divergent);
     let e = Some(1u8).map(generic);
     let e = Some(1u8).map(generic);
     // See #515
@@ -90,24 +89,17 @@ impl<'a> std::ops::Deref for TestStruct<'a> {
 fn test_redundant_closures_containing_method_calls() {
     let i = 10;
     let e = Some(TestStruct { some_ref: &i }).map(TestStruct::foo);
-    let e = Some(TestStruct { some_ref: &i }).map(TestStruct::foo);
     let e = Some(TestStruct { some_ref: &i }).map(TestTrait::trait_foo);
     let e = Some(TestStruct { some_ref: &i }).map(|a| a.trait_foo_ref());
-    let e = Some(TestStruct { some_ref: &i }).map(TestTrait::trait_foo);
-    let e = Some(&mut vec![1, 2, 3]).map(std::vec::Vec::clear);
     let e = Some(&mut vec![1, 2, 3]).map(std::vec::Vec::clear);
     unsafe {
         let e = Some(TestStruct { some_ref: &i }).map(|a| a.foo_unsafe());
     }
     let e = Some("str").map(std::string::ToString::to_string);
-    let e = Some("str").map(str::to_string);
-    let e = Some('a').map(char::to_uppercase);
     let e = Some('a').map(char::to_uppercase);
     let e: std::vec::Vec<usize> = vec!['a', 'b', 'c'].iter().map(|c| c.len_utf8()).collect();
     let e: std::vec::Vec<char> = vec!['a', 'b', 'c'].iter().map(char::to_ascii_uppercase).collect();
-    let e: std::vec::Vec<char> = vec!['a', 'b', 'c'].iter().map(char::to_ascii_uppercase).collect();
-    let p = Some(PathBuf::new());
-    let e = p.as_ref().and_then(|s| s.to_str());
+    let e = Some(PathBuf::new()).as_ref().and_then(|s| s.to_str());
     let c = Some(TestStruct { some_ref: &i })
         .as_ref()
         .map(|c| c.to_ascii_uppercase());
@@ -119,10 +111,6 @@ fn test_redundant_closures_containing_method_calls() {
         t.iter().filter(|x| x.trait_foo_ref());
         t.iter().map(|x| x.trait_foo_ref());
     }
-
-    let mut some = Some(|x| x * x);
-    let arr = [Ok(1), Err(2)];
-    let _: Vec<_> = arr.iter().map(|x| x.map_err(|e| some.take().unwrap()(e))).collect();
 }
 
 struct Thunk<T>(Box<dyn FnMut() -> T>);
@@ -145,13 +133,6 @@ fn foobar() {
     thunk.unwrap()
 }
 
-fn meta<F>(f: F)
-where
-    F: Fn(u8),
-{
-    f(1u8)
-}
-
 fn foo(_: u8) {}
 
 fn foo2(_: u8) -> u8 {
@@ -180,7 +161,7 @@ fn generic<T>(_: T) -> u8 {
 }
 
 fn passes_fn_mut(mut x: Box<dyn FnMut()>) {
-    requires_fn_once(|| x());
+    requires_fn_once(x);
 }
 fn requires_fn_once<T: FnOnce()>(_: T) {}
 
@@ -236,3 +217,35 @@ fn mutable_closure_in_loop() {
         Some(1).map(&mut closure);
     }
 }
+
+fn late_bound_lifetimes() {
+    fn take_asref_path<P: AsRef<Path>>(path: P) {}
+
+    fn map_str<F>(thunk: F)
+    where
+        F: FnOnce(&str),
+    {
+    }
+
+    fn map_str_to_path<F>(thunk: F)
+    where
+        F: FnOnce(&str) -> &Path,
+    {
+    }
+    map_str(|s| take_asref_path(s));
+    map_str_to_path(std::convert::AsRef::as_ref);
+}
+
+mod type_param_bound {
+    trait Trait {
+        fn fun();
+    }
+
+    fn take<T: 'static>(_: T) {}
+
+    fn test<X: Trait>() {
+        // don't lint, but it's questionable that rust requires a cast
+        take(|| X::fun());
+        take(X::fun as fn());
+    }
+}
diff --git a/tests/ui/eta.rs b/tests/ui/eta.rs
index 1b53700289d..3b53b9b28eb 100644
--- a/tests/ui/eta.rs
+++ b/tests/ui/eta.rs
@@ -14,7 +14,7 @@
     clippy::needless_borrow
 )]
 
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 
 macro_rules! mac {
     () => {
@@ -30,7 +30,6 @@ macro_rules! closure_mac {
 
 fn main() {
     let a = Some(1u8).map(|a| foo(a));
-    meta(|a| foo(a));
     let c = Some(1u8).map(|a| {1+2; foo}(a));
     true.then(|| mac!()); // don't lint function in macro expansion
     Some(1).map(closure_mac!()); // don't lint closure in macro expansion
@@ -90,24 +89,17 @@ impl<'a> std::ops::Deref for TestStruct<'a> {
 fn test_redundant_closures_containing_method_calls() {
     let i = 10;
     let e = Some(TestStruct { some_ref: &i }).map(|a| a.foo());
-    let e = Some(TestStruct { some_ref: &i }).map(TestStruct::foo);
     let e = Some(TestStruct { some_ref: &i }).map(|a| a.trait_foo());
     let e = Some(TestStruct { some_ref: &i }).map(|a| a.trait_foo_ref());
-    let e = Some(TestStruct { some_ref: &i }).map(TestTrait::trait_foo);
     let e = Some(&mut vec![1, 2, 3]).map(|v| v.clear());
-    let e = Some(&mut vec![1, 2, 3]).map(std::vec::Vec::clear);
     unsafe {
         let e = Some(TestStruct { some_ref: &i }).map(|a| a.foo_unsafe());
     }
     let e = Some("str").map(|s| s.to_string());
-    let e = Some("str").map(str::to_string);
     let e = Some('a').map(|s| s.to_uppercase());
-    let e = Some('a').map(char::to_uppercase);
     let e: std::vec::Vec<usize> = vec!['a', 'b', 'c'].iter().map(|c| c.len_utf8()).collect();
     let e: std::vec::Vec<char> = vec!['a', 'b', 'c'].iter().map(|c| c.to_ascii_uppercase()).collect();
-    let e: std::vec::Vec<char> = vec!['a', 'b', 'c'].iter().map(char::to_ascii_uppercase).collect();
-    let p = Some(PathBuf::new());
-    let e = p.as_ref().and_then(|s| s.to_str());
+    let e = Some(PathBuf::new()).as_ref().and_then(|s| s.to_str());
     let c = Some(TestStruct { some_ref: &i })
         .as_ref()
         .map(|c| c.to_ascii_uppercase());
@@ -119,10 +111,6 @@ fn test_redundant_closures_containing_method_calls() {
         t.iter().filter(|x| x.trait_foo_ref());
         t.iter().map(|x| x.trait_foo_ref());
     }
-
-    let mut some = Some(|x| x * x);
-    let arr = [Ok(1), Err(2)];
-    let _: Vec<_> = arr.iter().map(|x| x.map_err(|e| some.take().unwrap()(e))).collect();
 }
 
 struct Thunk<T>(Box<dyn FnMut() -> T>);
@@ -145,13 +133,6 @@ fn foobar() {
     thunk.unwrap()
 }
 
-fn meta<F>(f: F)
-where
-    F: Fn(u8),
-{
-    f(1u8)
-}
-
 fn foo(_: u8) {}
 
 fn foo2(_: u8) -> u8 {
@@ -236,3 +217,35 @@ fn mutable_closure_in_loop() {
         Some(1).map(|n| closure(n));
     }
 }
+
+fn late_bound_lifetimes() {
+    fn take_asref_path<P: AsRef<Path>>(path: P) {}
+
+    fn map_str<F>(thunk: F)
+    where
+        F: FnOnce(&str),
+    {
+    }
+
+    fn map_str_to_path<F>(thunk: F)
+    where
+        F: FnOnce(&str) -> &Path,
+    {
+    }
+    map_str(|s| take_asref_path(s));
+    map_str_to_path(|s| s.as_ref());
+}
+
+mod type_param_bound {
+    trait Trait {
+        fn fun();
+    }
+
+    fn take<T: 'static>(_: T) {}
+
+    fn test<X: Trait>() {
+        // don't lint, but it's questionable that rust requires a cast
+        take(|| X::fun());
+        take(X::fun as fn());
+    }
+}
diff --git a/tests/ui/eta.stderr b/tests/ui/eta.stderr
index 28da8941346..48d7e9e9c96 100644
--- a/tests/ui/eta.stderr
+++ b/tests/ui/eta.stderr
@@ -7,19 +7,19 @@ LL |     let a = Some(1u8).map(|a| foo(a));
    = note: `-D clippy::redundant-closure` implied by `-D warnings`
 
 error: redundant closure
-  --> $DIR/eta.rs:33:10
+  --> $DIR/eta.rs:36:40
    |
-LL |     meta(|a| foo(a));
-   |          ^^^^^^^^^^ help: replace the closure with the function itself: `foo`
+LL |     let _: Option<Vec<u8>> = true.then(|| vec![]); // special case vec!
+   |                                        ^^^^^^^^^ help: replace the closure with `Vec::new`: `std::vec::Vec::new`
 
 error: redundant closure
-  --> $DIR/eta.rs:37:40
+  --> $DIR/eta.rs:37:35
    |
-LL |     let _: Option<Vec<u8>> = true.then(|| vec![]); // special case vec!
-   |                                        ^^^^^^^^^ help: replace the closure with `Vec::new`: `std::vec::Vec::new`
+LL |     let d = Some(1u8).map(|a| foo((|b| foo2(b))(a))); //is adjusted?
+   |                                   ^^^^^^^^^^^^^ help: replace the closure with the function itself: `foo2`
 
 error: this expression borrows a reference (`&u8`) that is immediately dereferenced by the compiler
-  --> $DIR/eta.rs:39:21
+  --> $DIR/eta.rs:38:21
    |
 LL |     all(&[1, 2, 3], &&2, |x, y| below(x, y)); //is adjusted
    |                     ^^^ help: change this to: `&2`
@@ -27,13 +27,25 @@ LL |     all(&[1, 2, 3], &&2, |x, y| below(x, y)); //is adjusted
    = note: `-D clippy::needless-borrow` implied by `-D warnings`
 
 error: redundant closure
-  --> $DIR/eta.rs:46:27
+  --> $DIR/eta.rs:38:26
+   |
+LL |     all(&[1, 2, 3], &&2, |x, y| below(x, y)); //is adjusted
+   |                          ^^^^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `below`
+
+error: redundant closure
+  --> $DIR/eta.rs:44:27
+   |
+LL |     let e = Some(1u8).map(|a| divergent(a));
+   |                           ^^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `divergent`
+
+error: redundant closure
+  --> $DIR/eta.rs:45:27
    |
 LL |     let e = Some(1u8).map(|a| generic(a));
    |                           ^^^^^^^^^^^^^^ help: replace the closure with the function itself: `generic`
 
 error: redundant closure
-  --> $DIR/eta.rs:92:51
+  --> $DIR/eta.rs:91:51
    |
 LL |     let e = Some(TestStruct { some_ref: &i }).map(|a| a.foo());
    |                                                   ^^^^^^^^^^^ help: replace the closure with the method itself: `TestStruct::foo`
@@ -41,70 +53,82 @@ LL |     let e = Some(TestStruct { some_ref: &i }).map(|a| a.foo());
    = note: `-D clippy::redundant-closure-for-method-calls` implied by `-D warnings`
 
 error: redundant closure
-  --> $DIR/eta.rs:94:51
+  --> $DIR/eta.rs:92:51
    |
 LL |     let e = Some(TestStruct { some_ref: &i }).map(|a| a.trait_foo());
    |                                                   ^^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `TestTrait::trait_foo`
 
 error: redundant closure
-  --> $DIR/eta.rs:97:42
+  --> $DIR/eta.rs:94:42
    |
 LL |     let e = Some(&mut vec![1, 2, 3]).map(|v| v.clear());
    |                                          ^^^^^^^^^^^^^ help: replace the closure with the method itself: `std::vec::Vec::clear`
 
 error: redundant closure
-  --> $DIR/eta.rs:102:29
+  --> $DIR/eta.rs:98:29
    |
 LL |     let e = Some("str").map(|s| s.to_string());
    |                             ^^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `std::string::ToString::to_string`
 
 error: redundant closure
-  --> $DIR/eta.rs:104:27
+  --> $DIR/eta.rs:99:27
    |
 LL |     let e = Some('a').map(|s| s.to_uppercase());
    |                           ^^^^^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `char::to_uppercase`
 
 error: redundant closure
-  --> $DIR/eta.rs:107:65
+  --> $DIR/eta.rs:101:65
    |
 LL |     let e: std::vec::Vec<char> = vec!['a', 'b', 'c'].iter().map(|c| c.to_ascii_uppercase()).collect();
    |                                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `char::to_ascii_uppercase`
 
 error: redundant closure
-  --> $DIR/eta.rs:190:27
+  --> $DIR/eta.rs:164:22
+   |
+LL |     requires_fn_once(|| x());
+   |                      ^^^^^^ help: replace the closure with the function itself: `x`
+
+error: redundant closure
+  --> $DIR/eta.rs:171:27
    |
 LL |     let a = Some(1u8).map(|a| foo_ptr(a));
    |                           ^^^^^^^^^^^^^^ help: replace the closure with the function itself: `foo_ptr`
 
 error: redundant closure
-  --> $DIR/eta.rs:195:27
+  --> $DIR/eta.rs:176:27
    |
 LL |     let a = Some(1u8).map(|a| closure(a));
    |                           ^^^^^^^^^^^^^^ help: replace the closure with the function itself: `closure`
 
 error: redundant closure
-  --> $DIR/eta.rs:227:28
+  --> $DIR/eta.rs:208:28
    |
 LL |     x.into_iter().for_each(|x| add_to_res(x));
    |                            ^^^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `&mut add_to_res`
 
 error: redundant closure
-  --> $DIR/eta.rs:228:28
+  --> $DIR/eta.rs:209:28
    |
 LL |     y.into_iter().for_each(|x| add_to_res(x));
    |                            ^^^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `&mut add_to_res`
 
 error: redundant closure
-  --> $DIR/eta.rs:229:28
+  --> $DIR/eta.rs:210:28
    |
 LL |     z.into_iter().for_each(|x| add_to_res(x));
    |                            ^^^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `add_to_res`
 
 error: redundant closure
-  --> $DIR/eta.rs:236:21
+  --> $DIR/eta.rs:217:21
    |
 LL |         Some(1).map(|n| closure(n));
    |                     ^^^^^^^^^^^^^^ help: replace the closure with the function itself: `&mut closure`
 
-error: aborting due to 17 previous errors
+error: redundant closure
+  --> $DIR/eta.rs:236:21
+   |
+LL |     map_str_to_path(|s| s.as_ref());
+   |                     ^^^^^^^^^^^^^^ help: replace the closure with the method itself: `std::convert::AsRef::as_ref`
+
+error: aborting due to 21 previous errors
 
diff --git a/tests/ui/map_flatten.fixed b/tests/ui/map_flatten.fixed
index 18846c898da..fec3a95edd6 100644
--- a/tests/ui/map_flatten.fixed
+++ b/tests/ui/map_flatten.fixed
@@ -4,6 +4,7 @@
 #![allow(clippy::let_underscore_drop)]
 #![allow(clippy::missing_docs_in_private_items)]
 #![allow(clippy::map_identity)]
+#![allow(clippy::redundant_closure)]
 #![allow(clippy::unnecessary_wraps)]
 #![feature(result_flattening)]
 
diff --git a/tests/ui/map_flatten.rs b/tests/ui/map_flatten.rs
index 01db27876da..aa1f76e335a 100644
--- a/tests/ui/map_flatten.rs
+++ b/tests/ui/map_flatten.rs
@@ -4,6 +4,7 @@
 #![allow(clippy::let_underscore_drop)]
 #![allow(clippy::missing_docs_in_private_items)]
 #![allow(clippy::map_identity)]
+#![allow(clippy::redundant_closure)]
 #![allow(clippy::unnecessary_wraps)]
 #![feature(result_flattening)]
 
diff --git a/tests/ui/map_flatten.stderr b/tests/ui/map_flatten.stderr
index 38457c8ea4d..bcd2047e6fa 100644
--- a/tests/ui/map_flatten.stderr
+++ b/tests/ui/map_flatten.stderr
@@ -1,5 +1,5 @@
 error: called `map(..).flatten()` on an `Iterator`
-  --> $DIR/map_flatten.rs:17:46
+  --> $DIR/map_flatten.rs:18:46
    |
 LL |     let _: Vec<_> = vec![5_i8; 6].into_iter().map(option_id).flatten().collect();
    |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try using `filter_map` instead: `.filter_map(option_id)`
@@ -7,37 +7,37 @@ LL |     let _: Vec<_> = vec![5_i8; 6].into_iter().map(option_id).flatten().coll
    = note: `-D clippy::map-flatten` implied by `-D warnings`
 
 error: called `map(..).flatten()` on an `Iterator`
-  --> $DIR/map_flatten.rs:18:46
+  --> $DIR/map_flatten.rs:19:46
    |
 LL |     let _: Vec<_> = vec![5_i8; 6].into_iter().map(option_id_ref).flatten().collect();
    |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try using `filter_map` instead: `.filter_map(option_id_ref)`
 
 error: called `map(..).flatten()` on an `Iterator`
-  --> $DIR/map_flatten.rs:19:46
+  --> $DIR/map_flatten.rs:20:46
    |
 LL |     let _: Vec<_> = vec![5_i8; 6].into_iter().map(option_id_closure).flatten().collect();
    |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try using `filter_map` instead: `.filter_map(option_id_closure)`
 
 error: called `map(..).flatten()` on an `Iterator`
-  --> $DIR/map_flatten.rs:20:46
+  --> $DIR/map_flatten.rs:21:46
    |
 LL |     let _: Vec<_> = vec![5_i8; 6].into_iter().map(|x| x.checked_add(1)).flatten().collect();
    |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try using `filter_map` instead: `.filter_map(|x| x.checked_add(1))`
 
 error: called `map(..).flatten()` on an `Iterator`
-  --> $DIR/map_flatten.rs:23:46
+  --> $DIR/map_flatten.rs:24:46
    |
 LL |     let _: Vec<_> = vec![5_i8; 6].into_iter().map(|x| 0..x).flatten().collect();
    |                                              ^^^^^^^^^^^^^^^^^^^^^^^^ help: try using `flat_map` instead: `.flat_map(|x| 0..x)`
 
 error: called `map(..).flatten()` on an `Option`
-  --> $DIR/map_flatten.rs:26:39
+  --> $DIR/map_flatten.rs:27:39
    |
 LL |     let _: Option<_> = (Some(Some(1))).map(|x| x).flatten();
    |                                       ^^^^^^^^^^^^^^^^^^^^^ help: try using `and_then` instead: `.and_then(|x| x)`
 
 error: called `map(..).flatten()` on an `Result`
-  --> $DIR/map_flatten.rs:29:41
+  --> $DIR/map_flatten.rs:30:41
    |
 LL |     let _: Result<_, &str> = (Ok(Ok(1))).map(|x| x).flatten();
    |                                         ^^^^^^^^^^^^^^^^^^^^^ help: try using `and_then` instead: `.and_then(|x| x)`
diff --git a/tests/ui/semicolon_if_nothing_returned.rs b/tests/ui/semicolon_if_nothing_returned.rs
index 79ba7402f1f..9644a232968 100644
--- a/tests/ui/semicolon_if_nothing_returned.rs
+++ b/tests/ui/semicolon_if_nothing_returned.rs
@@ -1,4 +1,5 @@
 #![warn(clippy::semicolon_if_nothing_returned)]
+#![allow(clippy::redundant_closure)]
 #![feature(label_break_value)]
 
 fn get_unit() {}
@@ -30,8 +31,8 @@ fn unsafe_checks_error() {
     use std::ptr;
 
     let mut s = MaybeUninit::<String>::uninit();
-    let _d = || unsafe { 
-        ptr::drop_in_place(s.as_mut_ptr()) 
+    let _d = || unsafe {
+        ptr::drop_in_place(s.as_mut_ptr())
     };
 }
 
diff --git a/tests/ui/semicolon_if_nothing_returned.stderr b/tests/ui/semicolon_if_nothing_returned.stderr
index e88ebe2ad35..78813e7cc1c 100644
--- a/tests/ui/semicolon_if_nothing_returned.stderr
+++ b/tests/ui/semicolon_if_nothing_returned.stderr
@@ -1,5 +1,5 @@
 error: consider adding a `;` to the last statement for consistent formatting
-  --> $DIR/semicolon_if_nothing_returned.rs:8:5
+  --> $DIR/semicolon_if_nothing_returned.rs:9:5
    |
 LL |     println!("Hello")
    |     ^^^^^^^^^^^^^^^^^ help: add a `;` here: `println!("Hello");`
@@ -7,27 +7,27 @@ LL |     println!("Hello")
    = note: `-D clippy::semicolon-if-nothing-returned` implied by `-D warnings`
 
 error: consider adding a `;` to the last statement for consistent formatting
-  --> $DIR/semicolon_if_nothing_returned.rs:12:5
+  --> $DIR/semicolon_if_nothing_returned.rs:13:5
    |
 LL |     get_unit()
    |     ^^^^^^^^^^ help: add a `;` here: `get_unit();`
 
 error: consider adding a `;` to the last statement for consistent formatting
-  --> $DIR/semicolon_if_nothing_returned.rs:17:5
+  --> $DIR/semicolon_if_nothing_returned.rs:18:5
    |
 LL |     y = x + 1
    |     ^^^^^^^^^ help: add a `;` here: `y = x + 1;`
 
 error: consider adding a `;` to the last statement for consistent formatting
-  --> $DIR/semicolon_if_nothing_returned.rs:23:9
+  --> $DIR/semicolon_if_nothing_returned.rs:24:9
    |
 LL |         hello()
    |         ^^^^^^^ help: add a `;` here: `hello();`
 
 error: consider adding a `;` to the last statement for consistent formatting
-  --> $DIR/semicolon_if_nothing_returned.rs:34:9
+  --> $DIR/semicolon_if_nothing_returned.rs:35:9
    |
-LL |         ptr::drop_in_place(s.as_mut_ptr()) 
+LL |         ptr::drop_in_place(s.as_mut_ptr())
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: add a `;` here: `ptr::drop_in_place(s.as_mut_ptr());`
 
 error: aborting due to 5 previous errors
-- 
cgit 1.4.1-3-g733a5


From ae2a95fadc098b326f2114fc5ee6f55ee0db81a8 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Thu, 9 Sep 2021 15:36:06 -0500
Subject: Eat dogfood

---
 clippy_lints/src/disallowed_type.rs      |  2 +-
 clippy_lints/src/format.rs               |  4 +-
 clippy_lints/src/loops/while_let_loop.rs |  2 +-
 clippy_lints/src/ptr.rs                  |  2 +-
 clippy_utils/src/ast_utils.rs            | 85 ++++++++++++++------------------
 clippy_utils/src/eager_or_lazy.rs        |  7 ++-
 6 files changed, 45 insertions(+), 57 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/disallowed_type.rs b/clippy_lints/src/disallowed_type.rs
index e627168b932..6c861fb33a9 100644
--- a/clippy_lints/src/disallowed_type.rs
+++ b/clippy_lints/src/disallowed_type.rs
@@ -48,7 +48,7 @@ impl DisallowedType {
         Self {
             disallowed: disallowed
                 .iter()
-                .map(|s| s.split("::").map(|seg| Symbol::intern(seg)).collect::<Vec<_>>())
+                .map(|s| s.split("::").map(Symbol::intern).collect::<Vec<_>>())
                 .collect(),
             def_ids: FxHashSet::default(),
             prim_tys: FxHashSet::default(),
diff --git a/clippy_lints/src/format.rs b/clippy_lints/src/format.rs
index 863c606f5a9..508cac33848 100644
--- a/clippy_lints/src/format.rs
+++ b/clippy_lints/src/format.rs
@@ -69,8 +69,8 @@ impl<'tcx> LateLintPass<'tcx> for UselessFormat {
                     ty::Str => true,
                     _ => false,
                 };
-                if format_args.args.iter().all(|e| is_display_arg(e));
-                if format_args.fmt_expr.map_or(true, |e| check_unformatted(e));
+                if format_args.args.iter().all(is_display_arg);
+                if format_args.fmt_expr.map_or(true, check_unformatted);
                 then {
                     let is_new_string = match value.kind {
                         ExprKind::Binary(..) => true,
diff --git a/clippy_lints/src/loops/while_let_loop.rs b/clippy_lints/src/loops/while_let_loop.rs
index 1848f5b5de2..4dcd5c87722 100644
--- a/clippy_lints/src/loops/while_let_loop.rs
+++ b/clippy_lints/src/loops/while_let_loop.rs
@@ -65,7 +65,7 @@ fn extract_first_expr<'tcx>(block: &Block<'tcx>) -> Option<&'tcx Expr<'tcx>> {
 fn is_simple_break_expr(expr: &Expr<'_>) -> bool {
     match expr.kind {
         ExprKind::Break(dest, ref passed_expr) if dest.label.is_none() && passed_expr.is_none() => true,
-        ExprKind::Block(b, _) => extract_first_expr(b).map_or(false, |subexpr| is_simple_break_expr(subexpr)),
+        ExprKind::Block(b, _) => extract_first_expr(b).map_or(false, is_simple_break_expr),
         _ => false,
     }
 }
diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs
index c0d1f1eb6e6..d696e17d656 100644
--- a/clippy_lints/src/ptr.rs
+++ b/clippy_lints/src/ptr.rs
@@ -372,7 +372,7 @@ fn check_fn(cx: &LateContext<'_>, decl: &FnDecl<'_>, fn_id: HirId, opt_body_id:
             for (_, ref mutbl, ref argspan) in decl
                 .inputs
                 .iter()
-                .filter_map(|ty| get_rptr_lm(ty))
+                .filter_map(get_rptr_lm)
                 .filter(|&(lt, _, _)| lt.name == out.name)
             {
                 if *mutbl == Mutability::Mut {
diff --git a/clippy_utils/src/ast_utils.rs b/clippy_utils/src/ast_utils.rs
index 133f6c29f7d..2fa98831c77 100644
--- a/clippy_utils/src/ast_utils.rs
+++ b/clippy_utils/src/ast_utils.rs
@@ -46,15 +46,12 @@ pub fn eq_pat(l: &Pat, r: &Pat) -> bool {
         | (Ref(l, Mutability::Not), Ref(r, Mutability::Not))
         | (Ref(l, Mutability::Mut), Ref(r, Mutability::Mut)) => eq_pat(l, r),
         (Tuple(l), Tuple(r)) | (Slice(l), Slice(r)) => over(l, r, |l, r| eq_pat(l, r)),
-        (Path(lq, lp), Path(rq, rp)) => both(lq, rq, |l, r| eq_qself(l, r)) && eq_path(lp, rp),
+        (Path(lq, lp), Path(rq, rp)) => both(lq, rq, eq_qself) && eq_path(lp, rp),
         (TupleStruct(lqself, lp, lfs), TupleStruct(rqself, rp, rfs)) => {
             eq_maybe_qself(lqself, rqself) && eq_path(lp, rp) && over(lfs, rfs, |l, r| eq_pat(l, r))
         },
         (Struct(lqself, lp, lfs, lr), Struct(rqself, rp, rfs, rr)) => {
-            lr == rr
-                && eq_maybe_qself(lqself, rqself)
-                && eq_path(lp, rp)
-                && unordered_over(lfs, rfs, |lf, rf| eq_field_pat(lf, rf))
+            lr == rr && eq_maybe_qself(lqself, rqself) && eq_path(lp, rp) && unordered_over(lfs, rfs, eq_field_pat)
         },
         (Or(ls), Or(rs)) => unordered_over(ls, rs, |l, r| eq_pat(l, r)),
         (MacCall(l), MacCall(r)) => eq_mac_call(l, r),
@@ -76,7 +73,7 @@ pub fn eq_field_pat(l: &PatField, r: &PatField) -> bool {
     l.is_placeholder == r.is_placeholder
         && eq_id(l.ident, r.ident)
         && eq_pat(&l.pat, &r.pat)
-        && over(&l.attrs, &r.attrs, |l, r| eq_attr(l, r))
+        && over(&l.attrs, &r.attrs, eq_attr)
 }
 
 pub fn eq_qself(l: &QSelf, r: &QSelf) -> bool {
@@ -92,7 +89,7 @@ pub fn eq_maybe_qself(l: &Option<QSelf>, r: &Option<QSelf>) -> bool {
 }
 
 pub fn eq_path(l: &Path, r: &Path) -> bool {
-    over(&l.segments, &r.segments, |l, r| eq_path_seg(l, r))
+    over(&l.segments, &r.segments, eq_path_seg)
 }
 
 pub fn eq_path_seg(l: &PathSegment, r: &PathSegment) -> bool {
@@ -101,9 +98,7 @@ pub fn eq_path_seg(l: &PathSegment, r: &PathSegment) -> bool {
 
 pub fn eq_generic_args(l: &GenericArgs, r: &GenericArgs) -> bool {
     match (l, r) {
-        (GenericArgs::AngleBracketed(l), GenericArgs::AngleBracketed(r)) => {
-            over(&l.args, &r.args, |l, r| eq_angle_arg(l, r))
-        },
+        (GenericArgs::AngleBracketed(l), GenericArgs::AngleBracketed(r)) => over(&l.args, &r.args, eq_angle_arg),
         (GenericArgs::Parenthesized(l), GenericArgs::Parenthesized(r)) => {
             over(&l.inputs, &r.inputs, |l, r| eq_ty(l, r)) && eq_fn_ret_ty(&l.output, &r.output)
         },
@@ -142,7 +137,7 @@ pub fn eq_struct_rest(l: &StructRest, r: &StructRest) -> bool {
 
 pub fn eq_expr(l: &Expr, r: &Expr) -> bool {
     use ExprKind::*;
-    if !over(&l.attrs, &r.attrs, |l, r| eq_attr(l, r)) {
+    if !over(&l.attrs, &r.attrs, eq_attr) {
         return false;
     }
     match (&l.kind, &r.kind) {
@@ -173,20 +168,20 @@ pub fn eq_expr(l: &Expr, r: &Expr) -> bool {
         (Assign(l1, l2, _), Assign(r1, r2, _)) | (Index(l1, l2), Index(r1, r2)) => eq_expr(l1, r1) && eq_expr(l2, r2),
         (AssignOp(lo, lp, lv), AssignOp(ro, rp, rv)) => lo.node == ro.node && eq_expr(lp, rp) && eq_expr(lv, rv),
         (Field(lp, lf), Field(rp, rf)) => eq_id(*lf, *rf) && eq_expr(lp, rp),
-        (Match(ls, la), Match(rs, ra)) => eq_expr(ls, rs) && over(la, ra, |l, r| eq_arm(l, r)),
+        (Match(ls, la), Match(rs, ra)) => eq_expr(ls, rs) && over(la, ra, eq_arm),
         (Closure(lc, la, lm, lf, lb, _), Closure(rc, ra, rm, rf, rb, _)) => {
             lc == rc && la.is_async() == ra.is_async() && lm == rm && eq_fn_decl(lf, rf) && eq_expr(lb, rb)
         },
         (Async(lc, _, lb), Async(rc, _, rb)) => lc == rc && eq_block(lb, rb),
         (Range(lf, lt, ll), Range(rf, rt, rl)) => ll == rl && eq_expr_opt(lf, rf) && eq_expr_opt(lt, rt),
         (AddrOf(lbk, lm, le), AddrOf(rbk, rm, re)) => lbk == rbk && lm == rm && eq_expr(le, re),
-        (Path(lq, lp), Path(rq, rp)) => both(lq, rq, |l, r| eq_qself(l, r)) && eq_path(lp, rp),
+        (Path(lq, lp), Path(rq, rp)) => both(lq, rq, eq_qself) && eq_path(lp, rp),
         (MacCall(l), MacCall(r)) => eq_mac_call(l, r),
         (Struct(lse), Struct(rse)) => {
             eq_maybe_qself(&lse.qself, &rse.qself)
                 && eq_path(&lse.path, &rse.path)
                 && eq_struct_rest(&lse.rest, &rse.rest)
-                && unordered_over(&lse.fields, &rse.fields, |l, r| eq_field(l, r))
+                && unordered_over(&lse.fields, &rse.fields, eq_field)
         },
         _ => false,
     }
@@ -196,7 +191,7 @@ pub fn eq_field(l: &ExprField, r: &ExprField) -> bool {
     l.is_placeholder == r.is_placeholder
         && eq_id(l.ident, r.ident)
         && eq_expr(&l.expr, &r.expr)
-        && over(&l.attrs, &r.attrs, |l, r| eq_attr(l, r))
+        && over(&l.attrs, &r.attrs, eq_attr)
 }
 
 pub fn eq_arm(l: &Arm, r: &Arm) -> bool {
@@ -204,7 +199,7 @@ pub fn eq_arm(l: &Arm, r: &Arm) -> bool {
         && eq_pat(&l.pat, &r.pat)
         && eq_expr(&l.body, &r.body)
         && eq_expr_opt(&l.guard, &r.guard)
-        && over(&l.attrs, &r.attrs, |l, r| eq_attr(l, r))
+        && over(&l.attrs, &r.attrs, eq_attr)
 }
 
 pub fn eq_label(l: &Option<Label>, r: &Option<Label>) -> bool {
@@ -212,7 +207,7 @@ pub fn eq_label(l: &Option<Label>, r: &Option<Label>) -> bool {
 }
 
 pub fn eq_block(l: &Block, r: &Block) -> bool {
-    l.rules == r.rules && over(&l.stmts, &r.stmts, |l, r| eq_stmt(l, r))
+    l.rules == r.rules && over(&l.stmts, &r.stmts, eq_stmt)
 }
 
 pub fn eq_stmt(l: &Stmt, r: &Stmt) -> bool {
@@ -222,13 +217,13 @@ pub fn eq_stmt(l: &Stmt, r: &Stmt) -> bool {
             eq_pat(&l.pat, &r.pat)
                 && both(&l.ty, &r.ty, |l, r| eq_ty(l, r))
                 && eq_local_kind(&l.kind, &r.kind)
-                && over(&l.attrs, &r.attrs, |l, r| eq_attr(l, r))
+                && over(&l.attrs, &r.attrs, eq_attr)
         },
         (Item(l), Item(r)) => eq_item(l, r, eq_item_kind),
         (Expr(l), Expr(r)) | (Semi(l), Semi(r)) => eq_expr(l, r),
         (Empty, Empty) => true,
         (MacCall(l), MacCall(r)) => {
-            l.style == r.style && eq_mac_call(&l.mac, &r.mac) && over(&l.attrs, &r.attrs, |l, r| eq_attr(l, r))
+            l.style == r.style && eq_mac_call(&l.mac, &r.mac) && over(&l.attrs, &r.attrs, eq_attr)
         },
         _ => false,
     }
@@ -245,10 +240,7 @@ pub fn eq_local_kind(l: &LocalKind, r: &LocalKind) -> bool {
 }
 
 pub fn eq_item<K>(l: &Item<K>, r: &Item<K>, mut eq_kind: impl FnMut(&K, &K) -> bool) -> bool {
-    eq_id(l.ident, r.ident)
-        && over(&l.attrs, &r.attrs, |l, r| eq_attr(l, r))
-        && eq_vis(&l.vis, &r.vis)
-        && eq_kind(&l.kind, &r.kind)
+    eq_id(l.ident, r.ident) && over(&l.attrs, &r.attrs, eq_attr) && eq_vis(&l.vis, &r.vis) && eq_kind(&l.kind, &r.kind)
 }
 
 pub fn eq_item_kind(l: &ItemKind, r: &ItemKind) -> bool {
@@ -272,18 +264,15 @@ pub fn eq_item_kind(l: &ItemKind, r: &ItemKind) -> bool {
                 }
         },
         (ForeignMod(l), ForeignMod(r)) => {
-            both(&l.abi, &r.abi, |l, r| eq_str_lit(l, r))
-                && over(&l.items, &r.items, |l, r| eq_item(l, r, eq_foreign_item_kind))
+            both(&l.abi, &r.abi, eq_str_lit) && over(&l.items, &r.items, |l, r| eq_item(l, r, eq_foreign_item_kind))
         },
         (TyAlias(box TyAliasKind(ld, lg, lb, lt)), TyAlias(box TyAliasKind(rd, rg, rb, rt))) => {
             eq_defaultness(*ld, *rd)
                 && eq_generics(lg, rg)
-                && over(lb, rb, |l, r| eq_generic_bound(l, r))
+                && over(lb, rb, eq_generic_bound)
                 && both(lt, rt, |l, r| eq_ty(l, r))
         },
-        (Enum(le, lg), Enum(re, rg)) => {
-            over(&le.variants, &re.variants, |l, r| eq_variant(l, r)) && eq_generics(lg, rg)
-        },
+        (Enum(le, lg), Enum(re, rg)) => over(&le.variants, &re.variants, eq_variant) && eq_generics(lg, rg),
         (Struct(lv, lg), Struct(rv, rg)) | (Union(lv, lg), Union(rv, rg)) => {
             eq_variant_data(lv, rv) && eq_generics(lg, rg)
         },
@@ -291,10 +280,10 @@ pub fn eq_item_kind(l: &ItemKind, r: &ItemKind) -> bool {
             la == ra
                 && matches!(lu, Unsafe::No) == matches!(ru, Unsafe::No)
                 && eq_generics(lg, rg)
-                && over(lb, rb, |l, r| eq_generic_bound(l, r))
+                && over(lb, rb, eq_generic_bound)
                 && over(li, ri, |l, r| eq_item(l, r, eq_assoc_item_kind))
         },
-        (TraitAlias(lg, lb), TraitAlias(rg, rb)) => eq_generics(lg, rg) && over(lb, rb, |l, r| eq_generic_bound(l, r)),
+        (TraitAlias(lg, lb), TraitAlias(rg, rb)) => eq_generics(lg, rg) && over(lb, rb, eq_generic_bound),
         (
             Impl(box ImplKind {
                 unsafety: lu,
@@ -342,7 +331,7 @@ pub fn eq_foreign_item_kind(l: &ForeignItemKind, r: &ForeignItemKind) -> bool {
         (TyAlias(box TyAliasKind(ld, lg, lb, lt)), TyAlias(box TyAliasKind(rd, rg, rb, rt))) => {
             eq_defaultness(*ld, *rd)
                 && eq_generics(lg, rg)
-                && over(lb, rb, |l, r| eq_generic_bound(l, r))
+                && over(lb, rb, eq_generic_bound)
                 && both(lt, rt, |l, r| eq_ty(l, r))
         },
         (MacCall(l), MacCall(r)) => eq_mac_call(l, r),
@@ -360,7 +349,7 @@ pub fn eq_assoc_item_kind(l: &AssocItemKind, r: &AssocItemKind) -> bool {
         (TyAlias(box TyAliasKind(ld, lg, lb, lt)), TyAlias(box TyAliasKind(rd, rg, rb, rt))) => {
             eq_defaultness(*ld, *rd)
                 && eq_generics(lg, rg)
-                && over(lb, rb, |l, r| eq_generic_bound(l, r))
+                && over(lb, rb, eq_generic_bound)
                 && both(lt, rt, |l, r| eq_ty(l, r))
         },
         (MacCall(l), MacCall(r)) => eq_mac_call(l, r),
@@ -370,7 +359,7 @@ pub fn eq_assoc_item_kind(l: &AssocItemKind, r: &AssocItemKind) -> bool {
 
 pub fn eq_variant(l: &Variant, r: &Variant) -> bool {
     l.is_placeholder == r.is_placeholder
-        && over(&l.attrs, &r.attrs, |l, r| eq_attr(l, r))
+        && over(&l.attrs, &r.attrs, eq_attr)
         && eq_vis(&l.vis, &r.vis)
         && eq_id(l.ident, r.ident)
         && eq_variant_data(&l.data, &r.data)
@@ -381,14 +370,14 @@ pub fn eq_variant_data(l: &VariantData, r: &VariantData) -> bool {
     use VariantData::*;
     match (l, r) {
         (Unit(_), Unit(_)) => true,
-        (Struct(l, _), Struct(r, _)) | (Tuple(l, _), Tuple(r, _)) => over(l, r, |l, r| eq_struct_field(l, r)),
+        (Struct(l, _), Struct(r, _)) | (Tuple(l, _), Tuple(r, _)) => over(l, r, eq_struct_field),
         _ => false,
     }
 }
 
 pub fn eq_struct_field(l: &FieldDef, r: &FieldDef) -> bool {
     l.is_placeholder == r.is_placeholder
-        && over(&l.attrs, &r.attrs, |l, r| eq_attr(l, r))
+        && over(&l.attrs, &r.attrs, eq_attr)
         && eq_vis(&l.vis, &r.vis)
         && both(&l.ident, &r.ident, |l, r| eq_id(*l, *r))
         && eq_ty(&l.ty, &r.ty)
@@ -406,7 +395,7 @@ pub fn eq_fn_header(l: &FnHeader, r: &FnHeader) -> bool {
 }
 
 pub fn eq_generics(l: &Generics, r: &Generics) -> bool {
-    over(&l.params, &r.params, |l, r| eq_generic_param(l, r))
+    over(&l.params, &r.params, eq_generic_param)
         && over(&l.where_clause.predicates, &r.where_clause.predicates, |l, r| {
             eq_where_predicate(l, r)
         })
@@ -419,10 +408,10 @@ pub fn eq_where_predicate(l: &WherePredicate, r: &WherePredicate) -> bool {
             over(&l.bound_generic_params, &r.bound_generic_params, |l, r| {
                 eq_generic_param(l, r)
             }) && eq_ty(&l.bounded_ty, &r.bounded_ty)
-                && over(&l.bounds, &r.bounds, |l, r| eq_generic_bound(l, r))
+                && over(&l.bounds, &r.bounds, eq_generic_bound)
         },
         (RegionPredicate(l), RegionPredicate(r)) => {
-            eq_id(l.lifetime.ident, r.lifetime.ident) && over(&l.bounds, &r.bounds, |l, r| eq_generic_bound(l, r))
+            eq_id(l.lifetime.ident, r.lifetime.ident) && over(&l.bounds, &r.bounds, eq_generic_bound)
         },
         (EqPredicate(l), EqPredicate(r)) => eq_ty(&l.lhs_ty, &r.lhs_ty) && eq_ty(&l.rhs_ty, &r.rhs_ty),
         _ => false,
@@ -469,7 +458,7 @@ pub fn eq_fn_decl(l: &FnDecl, r: &FnDecl) -> bool {
             l.is_placeholder == r.is_placeholder
                 && eq_pat(&l.pat, &r.pat)
                 && eq_ty(&l.ty, &r.ty)
-                && over(&l.attrs, &r.attrs, |l, r| eq_attr(l, r))
+                && over(&l.attrs, &r.attrs, eq_attr)
         })
 }
 
@@ -496,13 +485,13 @@ pub fn eq_ty(l: &Ty, r: &Ty) -> bool {
         (BareFn(l), BareFn(r)) => {
             l.unsafety == r.unsafety
                 && eq_ext(&l.ext, &r.ext)
-                && over(&l.generic_params, &r.generic_params, |l, r| eq_generic_param(l, r))
+                && over(&l.generic_params, &r.generic_params, eq_generic_param)
                 && eq_fn_decl(&l.decl, &r.decl)
         },
         (Tup(l), Tup(r)) => over(l, r, |l, r| eq_ty(l, r)),
-        (Path(lq, lp), Path(rq, rp)) => both(lq, rq, |l, r| eq_qself(l, r)) && eq_path(lp, rp),
-        (TraitObject(lg, ls), TraitObject(rg, rs)) => ls == rs && over(lg, rg, |l, r| eq_generic_bound(l, r)),
-        (ImplTrait(_, lg), ImplTrait(_, rg)) => over(lg, rg, |l, r| eq_generic_bound(l, r)),
+        (Path(lq, lp), Path(rq, rp)) => both(lq, rq, eq_qself) && eq_path(lp, rp),
+        (TraitObject(lg, ls), TraitObject(rg, rs)) => ls == rs && over(lg, rg, eq_generic_bound),
+        (ImplTrait(_, lg), ImplTrait(_, rg)) => over(lg, rg, eq_generic_bound),
         (Typeof(l), Typeof(r)) => eq_expr(&l.value, &r.value),
         (MacCall(l), MacCall(r)) => eq_mac_call(l, r),
         _ => false,
@@ -533,7 +522,7 @@ pub fn eq_generic_param(l: &GenericParam, r: &GenericParam) -> bool {
     use GenericParamKind::*;
     l.is_placeholder == r.is_placeholder
         && eq_id(l.ident, r.ident)
-        && over(&l.bounds, &r.bounds, |l, r| eq_generic_bound(l, r))
+        && over(&l.bounds, &r.bounds, eq_generic_bound)
         && match (&l.kind, &r.kind) {
             (Lifetime, Lifetime) => true,
             (Type { default: l }, Type { default: r }) => both(l, r, |l, r| eq_ty(l, r)),
@@ -548,10 +537,10 @@ pub fn eq_generic_param(l: &GenericParam, r: &GenericParam) -> bool {
                     kw_span: _,
                     default: rd,
                 },
-            ) => eq_ty(lt, rt) && both(ld, rd, |ld, rd| eq_anon_const(ld, rd)),
+            ) => eq_ty(lt, rt) && both(ld, rd, eq_anon_const),
             _ => false,
         }
-        && over(&l.attrs, &r.attrs, |l, r| eq_attr(l, r))
+        && over(&l.attrs, &r.attrs, eq_attr)
 }
 
 pub fn eq_generic_bound(l: &GenericBound, r: &GenericBound) -> bool {
@@ -568,7 +557,7 @@ pub fn eq_assoc_constraint(l: &AssocTyConstraint, r: &AssocTyConstraint) -> bool
     eq_id(l.ident, r.ident)
         && match (&l.kind, &r.kind) {
             (Equality { ty: l }, Equality { ty: r }) => eq_ty(l, r),
-            (Bound { bounds: l }, Bound { bounds: r }) => over(l, r, |l, r| eq_generic_bound(l, r)),
+            (Bound { bounds: l }, Bound { bounds: r }) => over(l, r, eq_generic_bound),
             _ => false,
         }
 }
diff --git a/clippy_utils/src/eager_or_lazy.rs b/clippy_utils/src/eager_or_lazy.rs
index 29e2559fc6d..9650294fc7b 100644
--- a/clippy_utils/src/eager_or_lazy.rs
+++ b/clippy_utils/src/eager_or_lazy.rs
@@ -27,10 +27,9 @@ fn identify_some_pure_patterns(expr: &Expr<'_>) -> bool {
     match expr.kind {
         ExprKind::Lit(..) | ExprKind::ConstBlock(..) | ExprKind::Path(..) | ExprKind::Field(..) => true,
         ExprKind::AddrOf(_, _, addr_of_expr) => identify_some_pure_patterns(addr_of_expr),
-        ExprKind::Tup(tup_exprs) => tup_exprs.iter().all(|expr| identify_some_pure_patterns(expr)),
+        ExprKind::Tup(tup_exprs) => tup_exprs.iter().all(identify_some_pure_patterns),
         ExprKind::Struct(_, fields, expr) => {
-            fields.iter().all(|f| identify_some_pure_patterns(f.expr))
-                && expr.map_or(true, |e| identify_some_pure_patterns(e))
+            fields.iter().all(|f| identify_some_pure_patterns(f.expr)) && expr.map_or(true, identify_some_pure_patterns)
         },
         ExprKind::Call(
             &Expr {
@@ -45,7 +44,7 @@ fn identify_some_pure_patterns(expr: &Expr<'_>) -> bool {
                 ..
             },
             args,
-        ) => args.iter().all(|expr| identify_some_pure_patterns(expr)),
+        ) => args.iter().all(identify_some_pure_patterns),
         ExprKind::Block(
             &Block {
                 stmts,
-- 
cgit 1.4.1-3-g733a5


From 5aff720e1adb8efc1903c25c20cdee701c9e4f3a Mon Sep 17 00:00:00 2001
From: hamidreza kalbasi <hamidrezakalbasi@protonmail.com>
Date: Fri, 10 Sep 2021 18:10:55 +0430
Subject: fix derivable impl false positives

---
 clippy_lints/src/derivable_impls.rs | 17 ++++++++++++----
 tests/ui/derivable_impls.rs         | 40 +++++++++++++++++++++++++++++++++++++
 2 files changed, 53 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/derivable_impls.rs b/clippy_lints/src/derivable_impls.rs
index b4c4ca016aa..15252ef96cd 100644
--- a/clippy_lints/src/derivable_impls.rs
+++ b/clippy_lints/src/derivable_impls.rs
@@ -2,10 +2,9 @@ use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::{in_macro, is_automatically_derived, is_default_equivalent, remove_blocks};
 use rustc_hir::{
     def::{DefKind, Res},
-    Body, Expr, ExprKind, Impl, ImplItemKind, Item, ItemKind, Node, QPath,
+    Body, Expr, ExprKind, GenericArg, Impl, ImplItemKind, Item, ItemKind, Node, PathSegment, QPath, TyKind,
 };
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty::TypeFoldable;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::sym;
 
@@ -68,6 +67,7 @@ impl<'tcx> LateLintPass<'tcx> for DerivableImpls {
             if let ItemKind::Impl(Impl {
                 of_trait: Some(ref trait_ref),
                 items: [child],
+                self_ty,
                 ..
             }) = item.kind;
             if let attrs = cx.tcx.hir().attrs(item.hir_id());
@@ -80,9 +80,18 @@ impl<'tcx> LateLintPass<'tcx> for DerivableImpls {
             if let ImplItemKind::Fn(_, b) = &impl_item.kind;
             if let Body { value: func_expr, .. } = cx.tcx.hir().body(*b);
             if let Some(adt_def) = cx.tcx.type_of(item.def_id).ty_adt_def();
+            if !attrs.iter().any(|attr| attr.doc_str().is_some());
+            if let child_attrs = cx.tcx.hir().attrs(impl_item_hir);
+            if !child_attrs.iter().any(|attr| attr.doc_str().is_some());
             then {
-                if cx.tcx.type_of(item.def_id).definitely_has_param_types_or_consts(cx.tcx) {
-                    return;
+                if let TyKind::Path(QPath::Resolved(_, p)) = self_ty.kind {
+                    if let Some(PathSegment { args: Some(a), .. }) = p.segments.last() {
+                        for arg in a.args {
+                            if !matches!(arg, GenericArg::Lifetime(_)) {
+                                return;
+                            }
+                        }
+                    }
                 }
                 let should_emit = match remove_blocks(func_expr).kind {
                     ExprKind::Tup(fields) => fields.iter().all(|e| is_default_equivalent(cx, e)),
diff --git a/tests/ui/derivable_impls.rs b/tests/ui/derivable_impls.rs
index 336a743de72..ebbc0c77e32 100644
--- a/tests/ui/derivable_impls.rs
+++ b/tests/ui/derivable_impls.rs
@@ -167,4 +167,44 @@ impl Default for WithoutSelfParan {
     }
 }
 
+// https://github.com/rust-lang/rust-clippy/issues/7655
+
+pub struct SpecializedImpl2<T> {
+    v: Vec<T>,
+}
+
+impl Default for SpecializedImpl2<String> {
+    fn default() -> Self {
+        Self { v: Vec::new() }
+    }
+}
+
+// https://github.com/rust-lang/rust-clippy/issues/7654
+
+pub struct Color {
+    pub r: u8,
+    pub g: u8,
+    pub b: u8,
+}
+
+/// `#000000`
+impl Default for Color {
+    fn default() -> Self {
+        Color { r: 0, g: 0, b: 0 }
+    }
+}
+
+pub struct Color2 {
+    pub r: u8,
+    pub g: u8,
+    pub b: u8,
+}
+
+impl Default for Color2 {
+    /// `#000000`
+    fn default() -> Self {
+        Self { r: 0, g: 0, b: 0 }
+    }
+}
+
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 4c1b6a28e4c7b932b077c03e7a0f100b791391d7 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Fri, 10 Sep 2021 12:20:39 -0400
Subject: Fix result order for `manual_split_once` when `rsplitn` is used

---
 clippy_lints/src/methods/manual_split_once.rs | 70 +++++++++++++--------------
 tests/ui/manual_split_once.fixed              |  6 +++
 tests/ui/manual_split_once.rs                 |  6 +++
 tests/ui/manual_split_once.stderr             | 28 ++++++++++-
 4 files changed, 72 insertions(+), 38 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/manual_split_once.rs b/clippy_lints/src/methods/manual_split_once.rs
index e273186d051..8440f291859 100644
--- a/clippy_lints/src/methods/manual_split_once.rs
+++ b/clippy_lints/src/methods/manual_split_once.rs
@@ -17,32 +17,25 @@ pub(super) fn check(cx: &LateContext<'_>, method_name: &str, expr: &Expr<'_>, se
     }
 
     let ctxt = expr.span.ctxt();
-    let usage = match parse_iter_usage(cx, ctxt, cx.tcx.hir().parent_iter(expr.hir_id)) {
+    let (method_name, msg, reverse) = if method_name == "splitn" {
+        ("split_once", "manual implementation of `split_once`", false)
+    } else {
+        ("rsplit_once", "manual implementation of `rsplit_once`", true)
+    };
+    let usage = match parse_iter_usage(cx, ctxt, cx.tcx.hir().parent_iter(expr.hir_id), reverse) {
         Some(x) => x,
         None => return,
     };
-    let (method_name, msg) = if method_name == "splitn" {
-        ("split_once", "manual implementation of `split_once`")
-    } else {
-        ("rsplit_once", "manual implementation of `rsplit_once`")
-    };
 
     let mut app = Applicability::MachineApplicable;
     let self_snip = snippet_with_context(cx, self_arg.span, ctxt, "..", &mut app).0;
     let pat_snip = snippet_with_context(cx, pat_arg.span, ctxt, "..", &mut app).0;
 
-    match usage.kind {
+    let sugg = match usage.kind {
         IterUsageKind::NextTuple => {
-            span_lint_and_sugg(
-                cx,
-                MANUAL_SPLIT_ONCE,
-                usage.span,
-                msg,
-                "try this",
-                format!("{}.{}({})", self_snip, method_name, pat_snip),
-                app,
-            );
+            format!("{}.{}({})", self_snip, method_name, pat_snip)
         },
+        IterUsageKind::RNextTuple => format!("{}.{}({}).map(|(x, y)| (y, x))", self_snip, method_name, pat_snip),
         IterUsageKind::Next => {
             let self_deref = {
                 let adjust = cx.typeck_results().expr_adjustments(self_arg);
@@ -58,7 +51,7 @@ pub(super) fn check(cx: &LateContext<'_>, method_name: &str, expr: &Expr<'_>, se
                     "*".repeat(adjust.len() - 2)
                 }
             };
-            let sugg = if usage.unwrap_kind.is_some() {
+            if usage.unwrap_kind.is_some() {
                 format!(
                     "{}.{}({}).map_or({}{}, |x| x.0)",
                     &self_snip, method_name, pat_snip, self_deref, &self_snip
@@ -68,9 +61,7 @@ pub(super) fn check(cx: &LateContext<'_>, method_name: &str, expr: &Expr<'_>, se
                     "Some({}.{}({}).map_or({}{}, |x| x.0))",
                     &self_snip, method_name, pat_snip, self_deref, &self_snip
                 )
-            };
-
-            span_lint_and_sugg(cx, MANUAL_SPLIT_ONCE, usage.span, msg, "try this", sugg, app);
+            }
         },
         IterUsageKind::Second => {
             let access_str = match usage.unwrap_kind {
@@ -78,23 +69,18 @@ pub(super) fn check(cx: &LateContext<'_>, method_name: &str, expr: &Expr<'_>, se
                 Some(UnwrapKind::QuestionMark) => "?.1",
                 None => ".map(|x| x.1)",
             };
-            span_lint_and_sugg(
-                cx,
-                MANUAL_SPLIT_ONCE,
-                usage.span,
-                msg,
-                "try this",
-                format!("{}.{}({}){}", self_snip, method_name, pat_snip, access_str),
-                app,
-            );
+            format!("{}.{}({}){}", self_snip, method_name, pat_snip, access_str)
         },
-    }
+    };
+
+    span_lint_and_sugg(cx, MANUAL_SPLIT_ONCE, usage.span, msg, "try this", sugg, app);
 }
 
 enum IterUsageKind {
     Next,
     Second,
     NextTuple,
+    RNextTuple,
 }
 
 enum UnwrapKind {
@@ -108,10 +94,12 @@ struct IterUsage {
     span: Span,
 }
 
+#[allow(clippy::too_many_lines)]
 fn parse_iter_usage(
     cx: &LateContext<'tcx>,
     ctxt: SyntaxContext,
     mut iter: impl Iterator<Item = (HirId, Node<'tcx>)>,
+    reverse: bool,
 ) -> Option<IterUsage> {
     let (kind, span) = match iter.next() {
         Some((_, Node::Expr(e))) if e.span.ctxt() == ctxt => {
@@ -124,20 +112,30 @@ fn parse_iter_usage(
             let iter_id = cx.tcx.get_diagnostic_item(sym::Iterator)?;
 
             match (&*name.ident.as_str(), args) {
-                ("next", []) if cx.tcx.trait_of_item(did) == Some(iter_id) => (IterUsageKind::Next, e.span),
+                ("next", []) if cx.tcx.trait_of_item(did) == Some(iter_id) => {
+                    if reverse {
+                        (IterUsageKind::Second, e.span)
+                    } else {
+                        (IterUsageKind::Next, e.span)
+                    }
+                },
                 ("next_tuple", []) => {
-                    if_chain! {
+                    return if_chain! {
                         if match_def_path(cx, did, &paths::ITERTOOLS_NEXT_TUPLE);
                         if let ty::Adt(adt_def, subs) = cx.typeck_results().expr_ty(e).kind();
                         if cx.tcx.is_diagnostic_item(sym::option_type, adt_def.did);
                         if let ty::Tuple(subs) = subs.type_at(0).kind();
                         if subs.len() == 2;
                         then {
-                            return Some(IterUsage { kind: IterUsageKind::NextTuple, span: e.span, unwrap_kind: None });
+                            Some(IterUsage {
+                                kind: if reverse { IterUsageKind::RNextTuple } else { IterUsageKind::NextTuple },
+                                span: e.span,
+                                unwrap_kind: None
+                            })
                         } else {
-                            return None;
+                            None
                         }
-                    }
+                    };
                 },
                 ("nth" | "skip", [idx_expr]) if cx.tcx.trait_of_item(did) == Some(iter_id) => {
                     if let Some((Constant::Int(idx), _)) = constant(cx, cx.typeck_results(), idx_expr) {
@@ -158,7 +156,7 @@ fn parse_iter_usage(
                                 }
                             }
                         };
-                        match idx {
+                        match if reverse { idx ^ 1 } else { idx } {
                             0 => (IterUsageKind::Next, span),
                             1 => (IterUsageKind::Second, span),
                             _ => return None,
diff --git a/tests/ui/manual_split_once.fixed b/tests/ui/manual_split_once.fixed
index 3a0332939d4..992baf1f185 100644
--- a/tests/ui/manual_split_once.fixed
+++ b/tests/ui/manual_split_once.fixed
@@ -36,6 +36,12 @@ fn main() {
 
     // Don't lint, slices don't have `split_once`
     let _ = [0, 1, 2].splitn(2, |&x| x == 1).nth(1).unwrap();
+
+    // `rsplitn` gives the results in the reverse order of `rsplit_once`
+    let _ = "key=value".rsplit_once('=').unwrap().1;
+    let _ = "key=value".rsplit_once('=').map_or("key=value", |x| x.0);
+    let _ = "key=value".rsplit_once('=').map(|x| x.1);
+    let (_, _) = "key=value".rsplit_once('=').map(|(x, y)| (y, x)).unwrap();
 }
 
 fn _msrv_1_51() {
diff --git a/tests/ui/manual_split_once.rs b/tests/ui/manual_split_once.rs
index e6093b63fe8..4f92ab6b812 100644
--- a/tests/ui/manual_split_once.rs
+++ b/tests/ui/manual_split_once.rs
@@ -36,6 +36,12 @@ fn main() {
 
     // Don't lint, slices don't have `split_once`
     let _ = [0, 1, 2].splitn(2, |&x| x == 1).nth(1).unwrap();
+
+    // `rsplitn` gives the results in the reverse order of `rsplit_once`
+    let _ = "key=value".rsplitn(2, '=').next().unwrap();
+    let _ = "key=value".rsplitn(2, '=').nth(1).unwrap();
+    let _ = "key=value".rsplitn(2, '=').nth(0);
+    let (_, _) = "key=value".rsplitn(2, '=').next_tuple().unwrap();
 }
 
 fn _msrv_1_51() {
diff --git a/tests/ui/manual_split_once.stderr b/tests/ui/manual_split_once.stderr
index 4f15196b469..7bea2303d92 100644
--- a/tests/ui/manual_split_once.stderr
+++ b/tests/ui/manual_split_once.stderr
@@ -72,11 +72,35 @@ error: manual implementation of `split_once`
 LL |         let _ = s.splitn(2, "key=value").skip(1).next()?;
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `s.split_once("key=value")?.1`
 
+error: manual implementation of `rsplit_once`
+  --> $DIR/manual_split_once.rs:41:13
+   |
+LL |     let _ = "key=value".rsplitn(2, '=').next().unwrap();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `"key=value".rsplit_once('=').unwrap().1`
+
+error: manual implementation of `rsplit_once`
+  --> $DIR/manual_split_once.rs:42:13
+   |
+LL |     let _ = "key=value".rsplitn(2, '=').nth(1).unwrap();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `"key=value".rsplit_once('=').map_or("key=value", |x| x.0)`
+
+error: manual implementation of `rsplit_once`
+  --> $DIR/manual_split_once.rs:43:13
+   |
+LL |     let _ = "key=value".rsplitn(2, '=').nth(0);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `"key=value".rsplit_once('=').map(|x| x.1)`
+
+error: manual implementation of `rsplit_once`
+  --> $DIR/manual_split_once.rs:44:18
+   |
+LL |     let (_, _) = "key=value".rsplitn(2, '=').next_tuple().unwrap();
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `"key=value".rsplit_once('=').map(|(x, y)| (y, x))`
+
 error: manual implementation of `split_once`
-  --> $DIR/manual_split_once.rs:49:13
+  --> $DIR/manual_split_once.rs:55:13
    |
 LL |     let _ = "key=value".splitn(2, '=').nth(1).unwrap();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `"key=value".split_once('=').unwrap().1`
 
-error: aborting due to 13 previous errors
+error: aborting due to 17 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 46c3076784b94b4f56771ee02850d01480d9aca2 Mon Sep 17 00:00:00 2001
From: dswij <dswijj@gmail.com>
Date: Thu, 9 Sep 2021 23:37:18 +0800
Subject: Fix `needless_borrow` not linting mutable reference

---
 clippy_lints/src/needless_borrow.rs | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/needless_borrow.rs b/clippy_lints/src/needless_borrow.rs
index ba8f9446af8..1b2495d764d 100644
--- a/clippy_lints/src/needless_borrow.rs
+++ b/clippy_lints/src/needless_borrow.rs
@@ -104,7 +104,7 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessBorrow {
         if e.span.from_expansion() {
             return;
         }
-        if let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Not, inner) = e.kind {
+        if let ExprKind::AddrOf(BorrowKind::Ref, mutability, inner) = e.kind {
             if let ty::Ref(_, ty, _) = cx.typeck_results().expr_ty(inner).kind() {
                 for adj3 in cx.typeck_results().expr_adjustments(e).windows(3) {
                     if let [Adjustment {
@@ -116,14 +116,20 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessBorrow {
                         ..
                     }] = *adj3
                     {
+                        let help_msg_ty = if matches!(mutability, Mutability::Not) {
+                            format!("&{}", ty)
+                        } else {
+                            format!("&mut {}", ty)
+                        };
+
                         span_lint_and_then(
                             cx,
                             NEEDLESS_BORROW,
                             e.span,
                             &format!(
-                                "this expression borrows a reference (`&{}`) that is immediately dereferenced \
+                                "this expression borrows a reference (`{}`) that is immediately dereferenced \
                              by the compiler",
-                                ty
+                                help_msg_ty
                             ),
                             |diag| {
                                 if let Some(snippet) = snippet_opt(cx, inner.span) {
-- 
cgit 1.4.1-3-g733a5


From e0090735f1d826f78ef8f27e1305038bde2da2de Mon Sep 17 00:00:00 2001
From: Kneasle <kneasle@gmail.com>
Date: Sun, 5 Sep 2021 21:58:47 +0100
Subject: Fix FP when using raw pointers as hashed keys

---
 clippy_lints/src/mut_key.rs | 33 +++++++++++++++++++++++----------
 tests/ui/mut_key.rs         | 14 +++++++++++++-
 tests/ui/mut_key.stderr     |  8 ++++----
 3 files changed, 40 insertions(+), 15 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/mut_key.rs b/clippy_lints/src/mut_key.rs
index 2c7681c45a4..bdb6fc505f7 100644
--- a/clippy_lints/src/mut_key.rs
+++ b/clippy_lints/src/mut_key.rs
@@ -103,26 +103,39 @@ fn check_sig<'tcx>(cx: &LateContext<'tcx>, item_hir_id: hir::HirId, decl: &hir::
 fn check_ty<'tcx>(cx: &LateContext<'tcx>, span: Span, ty: Ty<'tcx>) {
     let ty = ty.peel_refs();
     if let Adt(def, substs) = ty.kind() {
-        if [sym::hashmap_type, sym::BTreeMap, sym::hashset_type, sym::BTreeMap]
+        let is_map_type = [sym::hashmap_type, sym::BTreeMap, sym::hashset_type, sym::BTreeMap]
             .iter()
-            .any(|diag_item| cx.tcx.is_diagnostic_item(*diag_item, def.did))
-            && is_mutable_type(cx, substs.type_at(0), span)
-        {
+            .any(|diag_item| cx.tcx.is_diagnostic_item(*diag_item, def.did));
+        if is_map_type && is_mutable_type(cx, substs.type_at(0), span, true) {
             span_lint(cx, MUTABLE_KEY_TYPE, span, "mutable key type");
         }
     }
 }
 
-fn is_mutable_type<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>, span: Span) -> bool {
+fn is_mutable_type<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>, span: Span, is_top_level_type: bool) -> bool {
     match *ty.kind() {
-        RawPtr(TypeAndMut { ty: inner_ty, mutbl }) | Ref(_, inner_ty, mutbl) => {
-            mutbl == hir::Mutability::Mut || is_mutable_type(cx, inner_ty, span)
+        RawPtr(TypeAndMut { ty: inner_ty, mutbl }) => {
+            if is_top_level_type {
+                // Raw pointers are hashed by the address they point to, not what is pointed to.
+                // Therefore, using a raw pointer to any type as the top-level key type is OK.
+                // Using raw pointers _in_ the key type is not, because the wrapper type could
+                // provide a custom `impl` for `Hash` (which could deref the raw pointer).
+                //
+                // see:
+                // - clippy issue: https://github.com/rust-lang/rust-clippy/issues/6745
+                // - std code: https://github.com/rust-lang/rust/blob/1.54.0/library/core/src/hash/mod.rs#L717-L736
+                false
+            } else {
+                mutbl == hir::Mutability::Mut || is_mutable_type(cx, inner_ty, span, false)
+            }
         },
-        Slice(inner_ty) => is_mutable_type(cx, inner_ty, span),
+        Ref(_, inner_ty, mutbl) => mutbl == hir::Mutability::Mut || is_mutable_type(cx, inner_ty, span, false),
+        Slice(inner_ty) => is_mutable_type(cx, inner_ty, span, false),
         Array(inner_ty, size) => {
-            size.try_eval_usize(cx.tcx, cx.param_env).map_or(true, |u| u != 0) && is_mutable_type(cx, inner_ty, span)
+            size.try_eval_usize(cx.tcx, cx.param_env).map_or(true, |u| u != 0)
+                && is_mutable_type(cx, inner_ty, span, false)
         },
-        Tuple(..) => ty.tuple_fields().any(|ty| is_mutable_type(cx, ty, span)),
+        Tuple(..) => ty.tuple_fields().any(|ty| is_mutable_type(cx, ty, span, false)),
         Adt(..) => {
             !ty.has_escaping_bound_vars()
                 && cx.tcx.layout_of(cx.param_env.and(ty)).is_ok()
diff --git a/tests/ui/mut_key.rs b/tests/ui/mut_key.rs
index 2d227e6654c..75b1618d82a 100644
--- a/tests/ui/mut_key.rs
+++ b/tests/ui/mut_key.rs
@@ -1,3 +1,4 @@
+use std::cell::Cell;
 use std::collections::{HashMap, HashSet};
 use std::hash::{Hash, Hasher};
 use std::sync::atomic::{AtomicUsize, Ordering::Relaxed};
@@ -31,11 +32,19 @@ fn should_not_take_this_arg(m: &mut HashMap<Key, usize>, _n: usize) -> HashSet<K
 
 fn this_is_ok(_m: &mut HashMap<usize, Key>) {}
 
+// Raw pointers are hashed by the address they point to, so it doesn't matter if they point to a
+// type with interior mutability.  See:
+// - clippy issue: https://github.com/rust-lang/rust-clippy/issues/6745
+// - std lib: https://github.com/rust-lang/rust/blob/1.54.0/library/core/src/hash/mod.rs#L717-L736
+// So these are OK:
+fn raw_ptr_is_ok(_m: &mut HashMap<*const Key, ()>) {}
+fn raw_mut_ptr_is_ok(_m: &mut HashMap<*mut Key, ()>) {}
+
 #[allow(unused)]
 trait Trait {
     type AssociatedType;
 
-    fn trait_fn(&self, set: std::collections::HashSet<Self::AssociatedType>);
+    fn trait_fn(&self, set: HashSet<Self::AssociatedType>);
 }
 
 fn generics_are_ok_too<K>(_m: &mut HashSet<K>) {
@@ -52,4 +61,7 @@ fn main() {
     tuples::<Key>(&mut HashMap::new());
     tuples::<()>(&mut HashMap::new());
     tuples_bad::<()>(&mut HashMap::new());
+
+    raw_ptr_is_ok(&mut HashMap::new());
+    raw_mut_ptr_is_ok(&mut HashMap::new());
 }
diff --git a/tests/ui/mut_key.stderr b/tests/ui/mut_key.stderr
index a8460b06ca6..8da1262f0f1 100644
--- a/tests/ui/mut_key.stderr
+++ b/tests/ui/mut_key.stderr
@@ -1,5 +1,5 @@
 error: mutable key type
-  --> $DIR/mut_key.rs:27:32
+  --> $DIR/mut_key.rs:28:32
    |
 LL | fn should_not_take_this_arg(m: &mut HashMap<Key, usize>, _n: usize) -> HashSet<Key> {
    |                                ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -7,19 +7,19 @@ LL | fn should_not_take_this_arg(m: &mut HashMap<Key, usize>, _n: usize) -> Hash
    = note: `-D clippy::mutable-key-type` implied by `-D warnings`
 
 error: mutable key type
-  --> $DIR/mut_key.rs:27:72
+  --> $DIR/mut_key.rs:28:72
    |
 LL | fn should_not_take_this_arg(m: &mut HashMap<Key, usize>, _n: usize) -> HashSet<Key> {
    |                                                                        ^^^^^^^^^^^^
 
 error: mutable key type
-  --> $DIR/mut_key.rs:28:5
+  --> $DIR/mut_key.rs:29:5
    |
 LL |     let _other: HashMap<Key, bool> = HashMap::new();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: mutable key type
-  --> $DIR/mut_key.rs:47:22
+  --> $DIR/mut_key.rs:56:22
    |
 LL | fn tuples_bad<U>(_m: &mut HashMap<(Key, U), bool>) {}
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From e2cdaec98437ea317eead6c90336d3462c779608 Mon Sep 17 00:00:00 2001
From: lengyijun <sjtu5140809011@gmail.com>
Date: Wed, 8 Sep 2021 10:36:51 +0800
Subject: same_name_method

---
 CHANGELOG.md                         |   1 +
 clippy_lints/src/lib.rs              |   4 +
 clippy_lints/src/same_name_method.rs | 160 +++++++++++++++++++++++++++++++++++
 tests/ui/same_name_method.rs         | 111 ++++++++++++++++++++++++
 tests/ui/same_name_method.stderr     |  64 ++++++++++++++
 5 files changed, 340 insertions(+)
 create mode 100644 clippy_lints/src/same_name_method.rs
 create mode 100644 tests/ui/same_name_method.rs
 create mode 100644 tests/ui/same_name_method.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 71383e8116b..72fe6ae3173 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2906,6 +2906,7 @@ Released 2018-09-13
 [`reversed_empty_ranges`]: https://rust-lang.github.io/rust-clippy/master/index.html#reversed_empty_ranges
 [`same_functions_in_if_condition`]: https://rust-lang.github.io/rust-clippy/master/index.html#same_functions_in_if_condition
 [`same_item_push`]: https://rust-lang.github.io/rust-clippy/master/index.html#same_item_push
+[`same_name_method`]: https://rust-lang.github.io/rust-clippy/master/index.html#same_name_method
 [`search_is_some`]: https://rust-lang.github.io/rust-clippy/master/index.html#search_is_some
 [`self_assignment`]: https://rust-lang.github.io/rust-clippy/master/index.html#self_assignment
 [`self_named_constructors`]: https://rust-lang.github.io/rust-clippy/master/index.html#self_named_constructors
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index e3dd43d6982..60e48728dc1 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -331,6 +331,7 @@ mod reference;
 mod regex;
 mod repeat_once;
 mod returns;
+mod same_name_method;
 mod self_assignment;
 mod self_named_constructors;
 mod semicolon_if_nothing_returned;
@@ -910,6 +911,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         repeat_once::REPEAT_ONCE,
         returns::LET_AND_RETURN,
         returns::NEEDLESS_RETURN,
+        same_name_method::SAME_NAME_METHOD,
         self_assignment::SELF_ASSIGNMENT,
         self_named_constructors::SELF_NAMED_CONSTRUCTORS,
         semicolon_if_nothing_returned::SEMICOLON_IF_NOTHING_RETURNED,
@@ -1053,6 +1055,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(panic_unimplemented::UNIMPLEMENTED),
         LintId::of(panic_unimplemented::UNREACHABLE),
         LintId::of(pattern_type_mismatch::PATTERN_TYPE_MISMATCH),
+        LintId::of(same_name_method::SAME_NAME_METHOD),
         LintId::of(shadow::SHADOW_REUSE),
         LintId::of(shadow::SHADOW_SAME),
         LintId::of(strings::STRING_ADD),
@@ -1923,6 +1926,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_early_pass(move || Box::new(unnested_or_patterns::UnnestedOrPatterns::new(msrv)));
 
     store.register_late_pass(|| Box::new(size_of_in_element_count::SizeOfInElementCount));
+    store.register_late_pass(|| Box::new(same_name_method::SameNameMethod));
     store.register_late_pass(|| Box::new(map_clone::MapClone));
     store.register_late_pass(|| Box::new(map_err_ignore::MapErrIgnore));
     store.register_late_pass(|| Box::new(shadow::Shadow));
diff --git a/clippy_lints/src/same_name_method.rs b/clippy_lints/src/same_name_method.rs
new file mode 100644
index 00000000000..014898e6dab
--- /dev/null
+++ b/clippy_lints/src/same_name_method.rs
@@ -0,0 +1,160 @@
+use clippy_utils::diagnostics::span_lint_and_then;
+use rustc_data_structures::fx::FxHashMap;
+use rustc_hir::def::{DefKind, Res};
+use rustc_hir::{Crate, Impl, ItemKind, Node, Path, QPath, TraitRef, TyKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::AssocKind;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::symbol::Symbol;
+use rustc_span::Span;
+use std::collections::{BTreeMap, BTreeSet};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// It lints if a struct has two method with same time:
+    /// one from a trait, another not from trait.
+    ///
+    /// ### Why is this bad?
+    /// Confusing.
+    ///
+    /// ### Example
+    /// ```rust
+    /// trait T {
+    ///     fn foo(&self) {}
+    /// }
+    ///
+    /// struct S;
+    ///
+    /// impl T for S {
+    ///     fn foo(&self) {}
+    /// }
+    ///
+    /// impl S {
+    ///     fn foo(&self) {}
+    /// }
+    /// ```
+    pub SAME_NAME_METHOD,
+    restriction,
+    "two method with same name"
+}
+
+declare_lint_pass!(SameNameMethod => [SAME_NAME_METHOD]);
+
+struct ExistingName {
+    impl_methods: BTreeMap<Symbol, Span>,
+    trait_methods: BTreeMap<Symbol, Vec<Span>>,
+}
+
+impl<'tcx> LateLintPass<'tcx> for SameNameMethod {
+    fn check_crate_post(&mut self, cx: &LateContext<'tcx>, krate: &'tcx Crate<'tcx>) {
+        let mut map = FxHashMap::<Res, ExistingName>::default();
+
+        for item in krate.items() {
+            if let ItemKind::Impl(Impl {
+                items,
+                of_trait,
+                self_ty,
+                ..
+            }) = &item.kind
+            {
+                if let TyKind::Path(QPath::Resolved(_, Path { res, .. })) = self_ty.kind {
+                    if !map.contains_key(res) {
+                        map.insert(
+                            *res,
+                            ExistingName {
+                                impl_methods: BTreeMap::new(),
+                                trait_methods: BTreeMap::new(),
+                            },
+                        );
+                    }
+                    let existing_name = map.get_mut(res).unwrap();
+
+                    match of_trait {
+                        Some(trait_ref) => {
+                            let mut methods_in_trait: BTreeSet<Symbol> = if_chain! {
+                                if let Some(Node::TraitRef(TraitRef { path, .. })) =
+                                    cx.tcx.hir().find(trait_ref.hir_ref_id);
+                                if let Res::Def(DefKind::Trait, did) = path.res;
+                                then{
+                                    // FIXME: if
+                                    // `rustc_middle::ty::assoc::AssocItems::items` is public,
+                                    // we can iterate its keys instead of `in_definition_order`,
+                                    // which's more efficient
+                                    cx.tcx
+                                        .associated_items(did)
+                                        .in_definition_order()
+                                        .filter(|assoc_item| {
+                                            matches!(assoc_item.kind, AssocKind::Fn)
+                                        })
+                                        .map(|assoc_item| assoc_item.ident.name)
+                                        .collect()
+                                }else{
+                                    BTreeSet::new()
+                                }
+                            };
+
+                            let mut check_trait_method = |method_name: Symbol, trait_method_span: Span| {
+                                if let Some(impl_span) = existing_name.impl_methods.get(&method_name) {
+                                    span_lint_and_then(
+                                        cx,
+                                        SAME_NAME_METHOD,
+                                        *impl_span,
+                                        "method's name is same to an existing method in a trait",
+                                        |diag| {
+                                            diag.span_note(
+                                                trait_method_span,
+                                                &format!("existing `{}` defined here", method_name),
+                                            );
+                                        },
+                                    );
+                                }
+                                if let Some(v) = existing_name.trait_methods.get_mut(&method_name) {
+                                    v.push(trait_method_span);
+                                } else {
+                                    existing_name.trait_methods.insert(method_name, vec![trait_method_span]);
+                                }
+                            };
+
+                            for impl_item_ref in (*items).iter().filter(|impl_item_ref| {
+                                matches!(impl_item_ref.kind, rustc_hir::AssocItemKind::Fn { .. })
+                            }) {
+                                let method_name = impl_item_ref.ident.name;
+                                methods_in_trait.remove(&method_name);
+                                check_trait_method(method_name, impl_item_ref.span);
+                            }
+
+                            for method_name in methods_in_trait {
+                                check_trait_method(method_name, item.span);
+                            }
+                        },
+                        None => {
+                            for impl_item_ref in (*items).iter().filter(|impl_item_ref| {
+                                matches!(impl_item_ref.kind, rustc_hir::AssocItemKind::Fn { .. })
+                            }) {
+                                let method_name = impl_item_ref.ident.name;
+                                let impl_span = impl_item_ref.span;
+                                if let Some(trait_spans) = existing_name.trait_methods.get(&method_name) {
+                                    span_lint_and_then(
+                                        cx,
+                                        SAME_NAME_METHOD,
+                                        impl_span,
+                                        "method's name is same to an existing method in a trait",
+                                        |diag| {
+                                            // TODO should we `span_note` on every trait?
+                                            // iterate on trait_spans?
+                                            diag.span_note(
+                                                trait_spans[0],
+                                                &format!("existing `{}` defined here", method_name),
+                                            );
+                                        },
+                                    );
+                                }
+                                existing_name.impl_methods.insert(method_name, impl_span);
+                            }
+                        },
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/tests/ui/same_name_method.rs b/tests/ui/same_name_method.rs
new file mode 100644
index 00000000000..12e10ba6c49
--- /dev/null
+++ b/tests/ui/same_name_method.rs
@@ -0,0 +1,111 @@
+#![warn(clippy::same_name_method)]
+#![allow(dead_code, non_camel_case_types)]
+
+trait T1 {
+    fn foo() {}
+}
+
+trait T2 {
+    fn foo() {}
+}
+
+mod should_lint {
+
+    mod test_basic_case {
+        use crate::T1;
+
+        struct S;
+
+        impl S {
+            fn foo() {}
+        }
+
+        impl T1 for S {
+            fn foo() {}
+        }
+    }
+
+    mod test_derive {
+
+        #[derive(Clone)]
+        struct S;
+
+        impl S {
+            fn clone() {}
+        }
+    }
+
+    mod with_generic {
+        use crate::T1;
+
+        struct S<U>(U);
+
+        impl<U> S<U> {
+            fn foo() {}
+        }
+
+        impl<U: Copy> T1 for S<U> {
+            fn foo() {}
+        }
+    }
+
+    mod default_method {
+        use crate::T1;
+
+        struct S;
+
+        impl S {
+            fn foo() {}
+        }
+
+        impl T1 for S {}
+    }
+
+    mod mulitply_conflicit_trait {
+        use crate::{T1, T2};
+
+        struct S;
+
+        impl S {
+            fn foo() {}
+        }
+
+        impl T1 for S {}
+
+        impl T2 for S {}
+    }
+}
+
+mod should_not_lint {
+
+    mod not_lint_two_trait_method {
+        use crate::{T1, T2};
+
+        struct S;
+
+        impl T1 for S {
+            fn foo() {}
+        }
+
+        impl T2 for S {
+            fn foo() {}
+        }
+    }
+
+    mod only_lint_on_method {
+        trait T3 {
+            type foo;
+        }
+
+        struct S;
+
+        impl S {
+            fn foo() {}
+        }
+        impl T3 for S {
+            type foo = usize;
+        }
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/same_name_method.stderr b/tests/ui/same_name_method.stderr
new file mode 100644
index 00000000000..0f9139b41b9
--- /dev/null
+++ b/tests/ui/same_name_method.stderr
@@ -0,0 +1,64 @@
+error: method's name is same to an existing method in a trait
+  --> $DIR/same_name_method.rs:20:13
+   |
+LL |             fn foo() {}
+   |             ^^^^^^^^^^^
+   |
+   = note: `-D clippy::same-name-method` implied by `-D warnings`
+note: existing `foo` defined here
+  --> $DIR/same_name_method.rs:24:13
+   |
+LL |             fn foo() {}
+   |             ^^^^^^^^^^^
+
+error: method's name is same to an existing method in a trait
+  --> $DIR/same_name_method.rs:44:13
+   |
+LL |             fn foo() {}
+   |             ^^^^^^^^^^^
+   |
+note: existing `foo` defined here
+  --> $DIR/same_name_method.rs:48:13
+   |
+LL |             fn foo() {}
+   |             ^^^^^^^^^^^
+
+error: method's name is same to an existing method in a trait
+  --> $DIR/same_name_method.rs:58:13
+   |
+LL |             fn foo() {}
+   |             ^^^^^^^^^^^
+   |
+note: existing `foo` defined here
+  --> $DIR/same_name_method.rs:61:9
+   |
+LL |         impl T1 for S {}
+   |         ^^^^^^^^^^^^^^^^
+
+error: method's name is same to an existing method in a trait
+  --> $DIR/same_name_method.rs:70:13
+   |
+LL |             fn foo() {}
+   |             ^^^^^^^^^^^
+   |
+note: existing `foo` defined here
+  --> $DIR/same_name_method.rs:73:9
+   |
+LL |         impl T1 for S {}
+   |         ^^^^^^^^^^^^^^^^
+
+error: method's name is same to an existing method in a trait
+  --> $DIR/same_name_method.rs:34:13
+   |
+LL |             fn clone() {}
+   |             ^^^^^^^^^^^^^
+   |
+note: existing `clone` defined here
+  --> $DIR/same_name_method.rs:30:18
+   |
+LL |         #[derive(Clone)]
+   |                  ^^^^^
+   = note: this error originates in the derive macro `Clone` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: aborting due to 5 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From b2ffb28da582d160f0689e6540a212d6d2bfabc5 Mon Sep 17 00:00:00 2001
From: Kneasle <kneasle@gmail.com>
Date: Wed, 8 Sep 2021 22:51:47 +0100
Subject: Fix FN for collections/smart ptrs in `std`

---
 clippy_lints/src/mut_key.rs | 90 +++++++++++++++++++++++++++++----------------
 tests/ui/mut_key.rs         | 20 +++++++++-
 tests/ui/mut_key.stderr     | 88 +++++++++++++++++++++++++++++++++++++++++---
 3 files changed, 161 insertions(+), 37 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/mut_key.rs b/clippy_lints/src/mut_key.rs
index bdb6fc505f7..cb17e4dbfd0 100644
--- a/clippy_lints/src/mut_key.rs
+++ b/clippy_lints/src/mut_key.rs
@@ -3,7 +3,7 @@ use clippy_utils::trait_ref_of_method;
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::TypeFoldable;
-use rustc_middle::ty::{Adt, Array, RawPtr, Ref, Slice, Tuple, Ty, TypeAndMut};
+use rustc_middle::ty::{Adt, Array, Ref, Slice, Tuple, Ty};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
 use rustc_span::symbol::sym;
@@ -19,10 +19,29 @@ declare_clippy_lint! {
     /// so having types with interior mutability is a bad idea.
     ///
     /// ### Known problems
-    /// It's correct to use a struct, that contains interior mutability
-    /// as a key, when its `Hash` implementation doesn't access any of the interior mutable types.
-    /// However, this lint is unable to recognize this, so it causes a false positive in theses cases.
-    /// The `bytes` crate is a great example of this.
+    ///
+    /// #### False Positives
+    /// It's correct to use a struct that contains interior mutability as a key, when its
+    /// implementation of `Hash` or `Ord` doesn't access any of the interior mutable types.
+    /// However, this lint is unable to recognize this, so it will often cause false positives in
+    /// theses cases.  The `bytes` crate is a great example of this.
+    ///
+    /// #### False Negatives
+    /// For custom `struct`s/`enum`s, this lint is unable to check for interior mutability behind
+    /// indirection.  For example, `struct BadKey<'a>(&'a Cell<usize>)` will be seen as immutable
+    /// and cause a false negative if its implementation of `Hash`/`Ord` accesses the `Cell`.
+    ///
+    /// This lint does check a few cases for indirection.  Firstly, using some standard library
+    /// types (`Option`, `Result`, `Box`, `Rc`, `Arc`, `Vec`, `VecDeque`, `BTreeMap` and
+    /// `BTreeSet`) directly as keys (e.g. in `HashMap<Box<Cell<usize>>, ()>`) **will** trigger the
+    /// lint, because the impls of `Hash`/`Ord` for these types directly call `Hash`/`Ord` on their
+    /// contained type.
+    ///
+    /// Secondly, the implementations of `Hash` and `Ord` for raw pointers (`*const T` or `*mut T`)
+    /// apply only to the **address** of the contained value.  Therefore, interior mutability
+    /// behind raw pointers (e.g. in `HashSet<*mut Cell<usize>>`) can't impact the value of `Hash`
+    /// or `Ord`, and therefore will not trigger this link.  For more info, see issue
+    /// [#6745](https://github.com/rust-lang/rust-clippy/issues/6745).
     ///
     /// ### Example
     /// ```rust
@@ -103,43 +122,52 @@ fn check_sig<'tcx>(cx: &LateContext<'tcx>, item_hir_id: hir::HirId, decl: &hir::
 fn check_ty<'tcx>(cx: &LateContext<'tcx>, span: Span, ty: Ty<'tcx>) {
     let ty = ty.peel_refs();
     if let Adt(def, substs) = ty.kind() {
-        let is_map_type = [sym::hashmap_type, sym::BTreeMap, sym::hashset_type, sym::BTreeMap]
+        let is_keyed_type = [sym::hashmap_type, sym::BTreeMap, sym::hashset_type, sym::BTreeSet]
             .iter()
             .any(|diag_item| cx.tcx.is_diagnostic_item(*diag_item, def.did));
-        if is_map_type && is_mutable_type(cx, substs.type_at(0), span, true) {
+        if is_keyed_type && is_interior_mutable_type(cx, substs.type_at(0), span) {
             span_lint(cx, MUTABLE_KEY_TYPE, span, "mutable key type");
         }
     }
 }
 
-fn is_mutable_type<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>, span: Span, is_top_level_type: bool) -> bool {
+/// Determines if a type contains interior mutability which would affect its implementation of
+/// [`Hash`] or [`Ord`].
+fn is_interior_mutable_type<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>, span: Span) -> bool {
     match *ty.kind() {
-        RawPtr(TypeAndMut { ty: inner_ty, mutbl }) => {
-            if is_top_level_type {
-                // Raw pointers are hashed by the address they point to, not what is pointed to.
-                // Therefore, using a raw pointer to any type as the top-level key type is OK.
-                // Using raw pointers _in_ the key type is not, because the wrapper type could
-                // provide a custom `impl` for `Hash` (which could deref the raw pointer).
-                //
-                // see:
-                // - clippy issue: https://github.com/rust-lang/rust-clippy/issues/6745
-                // - std code: https://github.com/rust-lang/rust/blob/1.54.0/library/core/src/hash/mod.rs#L717-L736
-                false
-            } else {
-                mutbl == hir::Mutability::Mut || is_mutable_type(cx, inner_ty, span, false)
-            }
-        },
-        Ref(_, inner_ty, mutbl) => mutbl == hir::Mutability::Mut || is_mutable_type(cx, inner_ty, span, false),
-        Slice(inner_ty) => is_mutable_type(cx, inner_ty, span, false),
+        Ref(_, inner_ty, mutbl) => mutbl == hir::Mutability::Mut || is_interior_mutable_type(cx, inner_ty, span),
+        Slice(inner_ty) => is_interior_mutable_type(cx, inner_ty, span),
         Array(inner_ty, size) => {
             size.try_eval_usize(cx.tcx, cx.param_env).map_or(true, |u| u != 0)
-                && is_mutable_type(cx, inner_ty, span, false)
+                && is_interior_mutable_type(cx, inner_ty, span)
         },
-        Tuple(..) => ty.tuple_fields().any(|ty| is_mutable_type(cx, ty, span, false)),
-        Adt(..) => {
-            !ty.has_escaping_bound_vars()
-                && cx.tcx.layout_of(cx.param_env.and(ty)).is_ok()
-                && !ty.is_freeze(cx.tcx.at(span), cx.param_env)
+        Tuple(..) => ty.tuple_fields().any(|ty| is_interior_mutable_type(cx, ty, span)),
+        Adt(def, substs) => {
+            // Special case for collections in `std` who's impl of `Hash` or `Ord` delegates to
+            // that of their type parameters.  Note: we don't include `HashSet` and `HashMap`
+            // because they have no impl for `Hash` or `Ord`.
+            let is_std_collection = [
+                sym::option_type,
+                sym::result_type,
+                sym::LinkedList,
+                sym::vec_type,
+                sym::vecdeque_type,
+                sym::BTreeMap,
+                sym::BTreeSet,
+                sym::Rc,
+                sym::Arc,
+            ]
+            .iter()
+            .any(|diag_item| cx.tcx.is_diagnostic_item(*diag_item, def.did));
+            let is_box = Some(def.did) == cx.tcx.lang_items().owned_box();
+            if is_std_collection || is_box {
+                // The type is mutable if any of its type parameters are
+                substs.types().any(|ty| is_interior_mutable_type(cx, ty, span))
+            } else {
+                !ty.has_escaping_bound_vars()
+                    && cx.tcx.layout_of(cx.param_env.and(ty)).is_ok()
+                    && !ty.is_freeze(cx.tcx.at(span), cx.param_env)
+            }
         },
         _ => false,
     }
diff --git a/tests/ui/mut_key.rs b/tests/ui/mut_key.rs
index 75b1618d82a..1c0ba664580 100644
--- a/tests/ui/mut_key.rs
+++ b/tests/ui/mut_key.rs
@@ -1,7 +1,9 @@
 use std::cell::Cell;
-use std::collections::{HashMap, HashSet};
+use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
 use std::hash::{Hash, Hasher};
+use std::rc::Rc;
 use std::sync::atomic::{AtomicUsize, Ordering::Relaxed};
+use std::sync::Arc;
 
 struct Key(AtomicUsize);
 
@@ -64,4 +66,20 @@ fn main() {
 
     raw_ptr_is_ok(&mut HashMap::new());
     raw_mut_ptr_is_ok(&mut HashMap::new());
+
+    let _map = HashMap::<Cell<usize>, usize>::new();
+    let _map = HashMap::<&mut Cell<usize>, usize>::new();
+    let _map = HashMap::<&mut usize, usize>::new();
+    // Collection types from `std` who's impl of `Hash` or `Ord` delegate their type parameters
+    let _map = HashMap::<Vec<Cell<usize>>, usize>::new();
+    let _map = HashMap::<BTreeMap<Cell<usize>, ()>, usize>::new();
+    let _map = HashMap::<BTreeMap<(), Cell<usize>>, usize>::new();
+    let _map = HashMap::<BTreeSet<Cell<usize>>, usize>::new();
+    let _map = HashMap::<Option<Cell<usize>>, usize>::new();
+    let _map = HashMap::<Option<Vec<Cell<usize>>>, usize>::new();
+    let _map = HashMap::<Result<&mut usize, ()>, usize>::new();
+    // Smart pointers from `std` who's impl of `Hash` or `Ord` delegate their type parameters
+    let _map = HashMap::<Box<Cell<usize>>, usize>::new();
+    let _map = HashMap::<Rc<Cell<usize>>, usize>::new();
+    let _map = HashMap::<Arc<Cell<usize>>, usize>::new();
 }
diff --git a/tests/ui/mut_key.stderr b/tests/ui/mut_key.stderr
index 8da1262f0f1..25dd029b16e 100644
--- a/tests/ui/mut_key.stderr
+++ b/tests/ui/mut_key.stderr
@@ -1,5 +1,5 @@
 error: mutable key type
-  --> $DIR/mut_key.rs:28:32
+  --> $DIR/mut_key.rs:30:32
    |
 LL | fn should_not_take_this_arg(m: &mut HashMap<Key, usize>, _n: usize) -> HashSet<Key> {
    |                                ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -7,22 +7,100 @@ LL | fn should_not_take_this_arg(m: &mut HashMap<Key, usize>, _n: usize) -> Hash
    = note: `-D clippy::mutable-key-type` implied by `-D warnings`
 
 error: mutable key type
-  --> $DIR/mut_key.rs:28:72
+  --> $DIR/mut_key.rs:30:72
    |
 LL | fn should_not_take_this_arg(m: &mut HashMap<Key, usize>, _n: usize) -> HashSet<Key> {
    |                                                                        ^^^^^^^^^^^^
 
 error: mutable key type
-  --> $DIR/mut_key.rs:29:5
+  --> $DIR/mut_key.rs:31:5
    |
 LL |     let _other: HashMap<Key, bool> = HashMap::new();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: mutable key type
-  --> $DIR/mut_key.rs:56:22
+  --> $DIR/mut_key.rs:58:22
    |
 LL | fn tuples_bad<U>(_m: &mut HashMap<(Key, U), bool>) {}
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 4 previous errors
+error: mutable key type
+  --> $DIR/mut_key.rs:70:5
+   |
+LL |     let _map = HashMap::<Cell<usize>, usize>::new();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: mutable key type
+  --> $DIR/mut_key.rs:71:5
+   |
+LL |     let _map = HashMap::<&mut Cell<usize>, usize>::new();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: mutable key type
+  --> $DIR/mut_key.rs:72:5
+   |
+LL |     let _map = HashMap::<&mut usize, usize>::new();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: mutable key type
+  --> $DIR/mut_key.rs:74:5
+   |
+LL |     let _map = HashMap::<Vec<Cell<usize>>, usize>::new();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: mutable key type
+  --> $DIR/mut_key.rs:75:5
+   |
+LL |     let _map = HashMap::<BTreeMap<Cell<usize>, ()>, usize>::new();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: mutable key type
+  --> $DIR/mut_key.rs:76:5
+   |
+LL |     let _map = HashMap::<BTreeMap<(), Cell<usize>>, usize>::new();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: mutable key type
+  --> $DIR/mut_key.rs:77:5
+   |
+LL |     let _map = HashMap::<BTreeSet<Cell<usize>>, usize>::new();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: mutable key type
+  --> $DIR/mut_key.rs:78:5
+   |
+LL |     let _map = HashMap::<Option<Cell<usize>>, usize>::new();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: mutable key type
+  --> $DIR/mut_key.rs:79:5
+   |
+LL |     let _map = HashMap::<Option<Vec<Cell<usize>>>, usize>::new();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: mutable key type
+  --> $DIR/mut_key.rs:80:5
+   |
+LL |     let _map = HashMap::<Result<&mut usize, ()>, usize>::new();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: mutable key type
+  --> $DIR/mut_key.rs:82:5
+   |
+LL |     let _map = HashMap::<Box<Cell<usize>>, usize>::new();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: mutable key type
+  --> $DIR/mut_key.rs:83:5
+   |
+LL |     let _map = HashMap::<Rc<Cell<usize>>, usize>::new();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: mutable key type
+  --> $DIR/mut_key.rs:84:5
+   |
+LL |     let _map = HashMap::<Arc<Cell<usize>>, usize>::new();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 17 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From c2783c1dcb6a61bb0fd8b6dec209c79136821a30 Mon Sep 17 00:00:00 2001
From: David Tolnay <dtolnay@gmail.com>
Date: Tue, 14 Sep 2021 09:48:30 -0700
Subject: Downgrade many_single_char_names to pedantic

---
 clippy_lints/src/lib.rs                       |  3 +-
 clippy_lints/src/non_expressive_names.rs      |  2 +-
 clippy_utils/src/hir_utils.rs                 |  2 +-
 tests/ui-toml/toml_trivially_copy/test.rs     |  1 -
 tests/ui-toml/toml_trivially_copy/test.stderr |  4 +--
 tests/ui/deref_addrof.fixed                   |  2 +-
 tests/ui/deref_addrof.rs                      |  2 +-
 tests/ui/eq_op.rs                             |  2 +-
 tests/ui/eta.fixed                            |  1 -
 tests/ui/eta.rs                               |  1 -
 tests/ui/eta.stderr                           | 42 +++++++++++-----------
 tests/ui/eval_order_dependence.rs             |  1 -
 tests/ui/eval_order_dependence.stderr         | 16 ++++-----
 tests/ui/explicit_deref_methods.fixed         |  2 +-
 tests/ui/explicit_deref_methods.rs            |  2 +-
 tests/ui/float_cmp.rs                         |  3 +-
 tests/ui/float_cmp.stderr                     | 12 +++----
 tests/ui/for_loop_fixable.fixed               |  2 +-
 tests/ui/for_loop_fixable.rs                  |  2 +-
 tests/ui/infinite_loop.rs                     |  1 -
 tests/ui/infinite_loop.stderr                 | 22 ++++++------
 tests/ui/inherent_to_string.rs                |  1 -
 tests/ui/inherent_to_string.stderr            |  4 +--
 tests/ui/logic_bug.rs                         |  2 +-
 tests/ui/many_single_char_names.rs            |  2 +-
 tests/ui/match_single_binding.fixed           |  2 +-
 tests/ui/match_single_binding.rs              |  2 +-
 tests/ui/needless_pass_by_value.rs            |  1 -
 tests/ui/needless_pass_by_value.stderr        | 52 +++++++++++++--------------
 tests/ui/nonminimal_bool.rs                   |  2 +-
 tests/ui/nonminimal_bool_methods.rs           |  2 +-
 tests/ui/op_ref.rs                            |  1 -
 tests/ui/op_ref.stderr                        |  4 +--
 tests/ui/overflow_check_conditional.rs        |  1 -
 tests/ui/overflow_check_conditional.stderr    | 16 ++++-----
 tests/ui/ptr_arg.rs                           |  2 +-
 tests/ui/repeat_once.fixed                    |  2 +-
 tests/ui/repeat_once.rs                       |  2 +-
 tests/ui/trivially_copy_pass_by_ref.rs        |  6 +---
 tests/ui/trivially_copy_pass_by_ref.stderr    | 34 +++++++++---------
 40 files changed, 124 insertions(+), 139 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index e3dd43d6982..86cc76d45f8 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1137,6 +1137,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(needless_continue::NEEDLESS_CONTINUE),
         LintId::of(needless_for_each::NEEDLESS_FOR_EACH),
         LintId::of(needless_pass_by_value::NEEDLESS_PASS_BY_VALUE),
+        LintId::of(non_expressive_names::MANY_SINGLE_CHAR_NAMES),
         LintId::of(non_expressive_names::SIMILAR_NAMES),
         LintId::of(pass_by_ref_or_value::LARGE_TYPES_PASSED_BY_VALUE),
         LintId::of(pass_by_ref_or_value::TRIVIALLY_COPY_PASS_BY_REF),
@@ -1393,7 +1394,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(non_copy_const::BORROW_INTERIOR_MUTABLE_CONST),
         LintId::of(non_copy_const::DECLARE_INTERIOR_MUTABLE_CONST),
         LintId::of(non_expressive_names::JUST_UNDERSCORES_AND_DIGITS),
-        LintId::of(non_expressive_names::MANY_SINGLE_CHAR_NAMES),
         LintId::of(non_octal_unix_permissions::NON_OCTAL_UNIX_PERMISSIONS),
         LintId::of(open_options::NONSENSICAL_OPEN_OPTIONS),
         LintId::of(option_env_unwrap::OPTION_ENV_UNWRAP),
@@ -1567,7 +1567,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(non_copy_const::BORROW_INTERIOR_MUTABLE_CONST),
         LintId::of(non_copy_const::DECLARE_INTERIOR_MUTABLE_CONST),
         LintId::of(non_expressive_names::JUST_UNDERSCORES_AND_DIGITS),
-        LintId::of(non_expressive_names::MANY_SINGLE_CHAR_NAMES),
         LintId::of(ptr::CMP_NULL),
         LintId::of(ptr::PTR_ARG),
         LintId::of(ptr_eq::PTR_EQ),
diff --git a/clippy_lints/src/non_expressive_names.rs b/clippy_lints/src/non_expressive_names.rs
index 2ffc00b449d..5b254bc8133 100644
--- a/clippy_lints/src/non_expressive_names.rs
+++ b/clippy_lints/src/non_expressive_names.rs
@@ -43,7 +43,7 @@ declare_clippy_lint! {
     /// let (a, b, c, d, e, f, g) = (...);
     /// ```
     pub MANY_SINGLE_CHAR_NAMES,
-    style,
+    pedantic,
     "too many single character bindings"
 }
 
diff --git a/clippy_utils/src/hir_utils.rs b/clippy_utils/src/hir_utils.rs
index 6e9a1de21ee..7438b6eabf9 100644
--- a/clippy_utils/src/hir_utils.rs
+++ b/clippy_utils/src/hir_utils.rs
@@ -540,7 +540,7 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> {
         std::mem::discriminant(&b.rules).hash(&mut self.s);
     }
 
-    #[allow(clippy::many_single_char_names, clippy::too_many_lines)]
+    #[allow(clippy::too_many_lines)]
     pub fn hash_expr(&mut self, e: &Expr<'_>) {
         let simple_const = self
             .maybe_typeck_results
diff --git a/tests/ui-toml/toml_trivially_copy/test.rs b/tests/ui-toml/toml_trivially_copy/test.rs
index 19019a25416..fb0e226f3aa 100644
--- a/tests/ui-toml/toml_trivially_copy/test.rs
+++ b/tests/ui-toml/toml_trivially_copy/test.rs
@@ -2,7 +2,6 @@
 // normalize-stderr-test "\(limit: \d+ byte\)" -> "(limit: N byte)"
 
 #![deny(clippy::trivially_copy_pass_by_ref)]
-#![allow(clippy::many_single_char_names)]
 
 #[derive(Copy, Clone)]
 struct Foo(u8);
diff --git a/tests/ui-toml/toml_trivially_copy/test.stderr b/tests/ui-toml/toml_trivially_copy/test.stderr
index 912761a8f00..b3ef5928e8e 100644
--- a/tests/ui-toml/toml_trivially_copy/test.stderr
+++ b/tests/ui-toml/toml_trivially_copy/test.stderr
@@ -1,5 +1,5 @@
 error: this argument (N byte) is passed by reference, but would be more efficient if passed by value (limit: N byte)
-  --> $DIR/test.rs:15:11
+  --> $DIR/test.rs:14:11
    |
 LL | fn bad(x: &u16, y: &Foo) {}
    |           ^^^^ help: consider passing by value instead: `u16`
@@ -11,7 +11,7 @@ LL | #![deny(clippy::trivially_copy_pass_by_ref)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this argument (N byte) is passed by reference, but would be more efficient if passed by value (limit: N byte)
-  --> $DIR/test.rs:15:20
+  --> $DIR/test.rs:14:20
    |
 LL | fn bad(x: &u16, y: &Foo) {}
    |                    ^^^^ help: consider passing by value instead: `Foo`
diff --git a/tests/ui/deref_addrof.fixed b/tests/ui/deref_addrof.fixed
index 0795900558b..d4832daa689 100644
--- a/tests/ui/deref_addrof.fixed
+++ b/tests/ui/deref_addrof.fixed
@@ -9,7 +9,7 @@ fn get_reference(n: &usize) -> &usize {
     n
 }
 
-#[allow(clippy::many_single_char_names, clippy::double_parens)]
+#[allow(clippy::double_parens)]
 #[allow(unused_variables, unused_parens)]
 fn main() {
     let a = 10;
diff --git a/tests/ui/deref_addrof.rs b/tests/ui/deref_addrof.rs
index 60c4318601b..be7cc669b5b 100644
--- a/tests/ui/deref_addrof.rs
+++ b/tests/ui/deref_addrof.rs
@@ -9,7 +9,7 @@ fn get_reference(n: &usize) -> &usize {
     n
 }
 
-#[allow(clippy::many_single_char_names, clippy::double_parens)]
+#[allow(clippy::double_parens)]
 #[allow(unused_variables, unused_parens)]
 fn main() {
     let a = 10;
diff --git a/tests/ui/eq_op.rs b/tests/ui/eq_op.rs
index 7ab23320db6..707b449f82e 100644
--- a/tests/ui/eq_op.rs
+++ b/tests/ui/eq_op.rs
@@ -2,7 +2,7 @@
 
 #[rustfmt::skip]
 #[warn(clippy::eq_op)]
-#[allow(clippy::identity_op, clippy::double_parens, clippy::many_single_char_names)]
+#[allow(clippy::identity_op, clippy::double_parens)]
 #[allow(clippy::no_effect, unused_variables, clippy::unnecessary_operation, clippy::short_circuit_statement)]
 #[allow(clippy::nonminimal_bool)]
 #[allow(unused)]
diff --git a/tests/ui/eta.fixed b/tests/ui/eta.fixed
index 9d9a1a3e500..1de79667f55 100644
--- a/tests/ui/eta.fixed
+++ b/tests/ui/eta.fixed
@@ -4,7 +4,6 @@
     unused,
     clippy::no_effect,
     clippy::redundant_closure_call,
-    clippy::many_single_char_names,
     clippy::needless_pass_by_value,
     clippy::option_map_unit_fn
 )]
diff --git a/tests/ui/eta.rs b/tests/ui/eta.rs
index 3b53b9b28eb..86abd347baa 100644
--- a/tests/ui/eta.rs
+++ b/tests/ui/eta.rs
@@ -4,7 +4,6 @@
     unused,
     clippy::no_effect,
     clippy::redundant_closure_call,
-    clippy::many_single_char_names,
     clippy::needless_pass_by_value,
     clippy::option_map_unit_fn
 )]
diff --git a/tests/ui/eta.stderr b/tests/ui/eta.stderr
index 48d7e9e9c96..8092f04c3fc 100644
--- a/tests/ui/eta.stderr
+++ b/tests/ui/eta.stderr
@@ -1,5 +1,5 @@
 error: redundant closure
-  --> $DIR/eta.rs:32:27
+  --> $DIR/eta.rs:31:27
    |
 LL |     let a = Some(1u8).map(|a| foo(a));
    |                           ^^^^^^^^^^ help: replace the closure with the function itself: `foo`
@@ -7,19 +7,19 @@ LL |     let a = Some(1u8).map(|a| foo(a));
    = note: `-D clippy::redundant-closure` implied by `-D warnings`
 
 error: redundant closure
-  --> $DIR/eta.rs:36:40
+  --> $DIR/eta.rs:35:40
    |
 LL |     let _: Option<Vec<u8>> = true.then(|| vec![]); // special case vec!
    |                                        ^^^^^^^^^ help: replace the closure with `Vec::new`: `std::vec::Vec::new`
 
 error: redundant closure
-  --> $DIR/eta.rs:37:35
+  --> $DIR/eta.rs:36:35
    |
 LL |     let d = Some(1u8).map(|a| foo((|b| foo2(b))(a))); //is adjusted?
    |                                   ^^^^^^^^^^^^^ help: replace the closure with the function itself: `foo2`
 
 error: this expression borrows a reference (`&u8`) that is immediately dereferenced by the compiler
-  --> $DIR/eta.rs:38:21
+  --> $DIR/eta.rs:37:21
    |
 LL |     all(&[1, 2, 3], &&2, |x, y| below(x, y)); //is adjusted
    |                     ^^^ help: change this to: `&2`
@@ -27,25 +27,25 @@ LL |     all(&[1, 2, 3], &&2, |x, y| below(x, y)); //is adjusted
    = note: `-D clippy::needless-borrow` implied by `-D warnings`
 
 error: redundant closure
-  --> $DIR/eta.rs:38:26
+  --> $DIR/eta.rs:37:26
    |
 LL |     all(&[1, 2, 3], &&2, |x, y| below(x, y)); //is adjusted
    |                          ^^^^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `below`
 
 error: redundant closure
-  --> $DIR/eta.rs:44:27
+  --> $DIR/eta.rs:43:27
    |
 LL |     let e = Some(1u8).map(|a| divergent(a));
    |                           ^^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `divergent`
 
 error: redundant closure
-  --> $DIR/eta.rs:45:27
+  --> $DIR/eta.rs:44:27
    |
 LL |     let e = Some(1u8).map(|a| generic(a));
    |                           ^^^^^^^^^^^^^^ help: replace the closure with the function itself: `generic`
 
 error: redundant closure
-  --> $DIR/eta.rs:91:51
+  --> $DIR/eta.rs:90:51
    |
 LL |     let e = Some(TestStruct { some_ref: &i }).map(|a| a.foo());
    |                                                   ^^^^^^^^^^^ help: replace the closure with the method itself: `TestStruct::foo`
@@ -53,79 +53,79 @@ LL |     let e = Some(TestStruct { some_ref: &i }).map(|a| a.foo());
    = note: `-D clippy::redundant-closure-for-method-calls` implied by `-D warnings`
 
 error: redundant closure
-  --> $DIR/eta.rs:92:51
+  --> $DIR/eta.rs:91:51
    |
 LL |     let e = Some(TestStruct { some_ref: &i }).map(|a| a.trait_foo());
    |                                                   ^^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `TestTrait::trait_foo`
 
 error: redundant closure
-  --> $DIR/eta.rs:94:42
+  --> $DIR/eta.rs:93:42
    |
 LL |     let e = Some(&mut vec![1, 2, 3]).map(|v| v.clear());
    |                                          ^^^^^^^^^^^^^ help: replace the closure with the method itself: `std::vec::Vec::clear`
 
 error: redundant closure
-  --> $DIR/eta.rs:98:29
+  --> $DIR/eta.rs:97:29
    |
 LL |     let e = Some("str").map(|s| s.to_string());
    |                             ^^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `std::string::ToString::to_string`
 
 error: redundant closure
-  --> $DIR/eta.rs:99:27
+  --> $DIR/eta.rs:98:27
    |
 LL |     let e = Some('a').map(|s| s.to_uppercase());
    |                           ^^^^^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `char::to_uppercase`
 
 error: redundant closure
-  --> $DIR/eta.rs:101:65
+  --> $DIR/eta.rs:100:65
    |
 LL |     let e: std::vec::Vec<char> = vec!['a', 'b', 'c'].iter().map(|c| c.to_ascii_uppercase()).collect();
    |                                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `char::to_ascii_uppercase`
 
 error: redundant closure
-  --> $DIR/eta.rs:164:22
+  --> $DIR/eta.rs:163:22
    |
 LL |     requires_fn_once(|| x());
    |                      ^^^^^^ help: replace the closure with the function itself: `x`
 
 error: redundant closure
-  --> $DIR/eta.rs:171:27
+  --> $DIR/eta.rs:170:27
    |
 LL |     let a = Some(1u8).map(|a| foo_ptr(a));
    |                           ^^^^^^^^^^^^^^ help: replace the closure with the function itself: `foo_ptr`
 
 error: redundant closure
-  --> $DIR/eta.rs:176:27
+  --> $DIR/eta.rs:175:27
    |
 LL |     let a = Some(1u8).map(|a| closure(a));
    |                           ^^^^^^^^^^^^^^ help: replace the closure with the function itself: `closure`
 
 error: redundant closure
-  --> $DIR/eta.rs:208:28
+  --> $DIR/eta.rs:207:28
    |
 LL |     x.into_iter().for_each(|x| add_to_res(x));
    |                            ^^^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `&mut add_to_res`
 
 error: redundant closure
-  --> $DIR/eta.rs:209:28
+  --> $DIR/eta.rs:208:28
    |
 LL |     y.into_iter().for_each(|x| add_to_res(x));
    |                            ^^^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `&mut add_to_res`
 
 error: redundant closure
-  --> $DIR/eta.rs:210:28
+  --> $DIR/eta.rs:209:28
    |
 LL |     z.into_iter().for_each(|x| add_to_res(x));
    |                            ^^^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `add_to_res`
 
 error: redundant closure
-  --> $DIR/eta.rs:217:21
+  --> $DIR/eta.rs:216:21
    |
 LL |         Some(1).map(|n| closure(n));
    |                     ^^^^^^^^^^^^^^ help: replace the closure with the function itself: `&mut closure`
 
 error: redundant closure
-  --> $DIR/eta.rs:236:21
+  --> $DIR/eta.rs:235:21
    |
 LL |     map_str_to_path(|s| s.as_ref());
    |                     ^^^^^^^^^^^^^^ help: replace the closure with the method itself: `std::convert::AsRef::as_ref`
diff --git a/tests/ui/eval_order_dependence.rs b/tests/ui/eval_order_dependence.rs
index d742856bc41..8e6a32b7be3 100644
--- a/tests/ui/eval_order_dependence.rs
+++ b/tests/ui/eval_order_dependence.rs
@@ -4,7 +4,6 @@
 #[allow(
     unused_assignments,
     unused_variables,
-    clippy::many_single_char_names,
     clippy::no_effect,
     dead_code,
     clippy::blacklisted_name
diff --git a/tests/ui/eval_order_dependence.stderr b/tests/ui/eval_order_dependence.stderr
index 35eb85e95a3..4f611e308e1 100644
--- a/tests/ui/eval_order_dependence.stderr
+++ b/tests/ui/eval_order_dependence.stderr
@@ -1,48 +1,48 @@
 error: unsequenced read of `x`
-  --> $DIR/eval_order_dependence.rs:17:9
+  --> $DIR/eval_order_dependence.rs:16:9
    |
 LL |     } + x;
    |         ^
    |
    = note: `-D clippy::eval-order-dependence` implied by `-D warnings`
 note: whether read occurs before this write depends on evaluation order
-  --> $DIR/eval_order_dependence.rs:15:9
+  --> $DIR/eval_order_dependence.rs:14:9
    |
 LL |         x = 1;
    |         ^^^^^
 
 error: unsequenced read of `x`
-  --> $DIR/eval_order_dependence.rs:20:5
+  --> $DIR/eval_order_dependence.rs:19:5
    |
 LL |     x += {
    |     ^
    |
 note: whether read occurs before this write depends on evaluation order
-  --> $DIR/eval_order_dependence.rs:21:9
+  --> $DIR/eval_order_dependence.rs:20:9
    |
 LL |         x = 20;
    |         ^^^^^^
 
 error: unsequenced read of `x`
-  --> $DIR/eval_order_dependence.rs:33:12
+  --> $DIR/eval_order_dependence.rs:32:12
    |
 LL |         a: x,
    |            ^
    |
 note: whether read occurs before this write depends on evaluation order
-  --> $DIR/eval_order_dependence.rs:35:13
+  --> $DIR/eval_order_dependence.rs:34:13
    |
 LL |             x = 6;
    |             ^^^^^
 
 error: unsequenced read of `x`
-  --> $DIR/eval_order_dependence.rs:42:9
+  --> $DIR/eval_order_dependence.rs:41:9
    |
 LL |         x += {
    |         ^
    |
 note: whether read occurs before this write depends on evaluation order
-  --> $DIR/eval_order_dependence.rs:43:13
+  --> $DIR/eval_order_dependence.rs:42:13
    |
 LL |             x = 20;
    |             ^^^^^^
diff --git a/tests/ui/explicit_deref_methods.fixed b/tests/ui/explicit_deref_methods.fixed
index 51d0468e47c..48e2aae75d0 100644
--- a/tests/ui/explicit_deref_methods.fixed
+++ b/tests/ui/explicit_deref_methods.fixed
@@ -1,6 +1,6 @@
 // run-rustfix
 
-#![allow(unused_variables, clippy::many_single_char_names, clippy::clone_double_ref)]
+#![allow(unused_variables, clippy::clone_double_ref)]
 #![warn(clippy::explicit_deref_methods)]
 
 use std::ops::{Deref, DerefMut};
diff --git a/tests/ui/explicit_deref_methods.rs b/tests/ui/explicit_deref_methods.rs
index 680664bd4f6..d8c8c0c5ca3 100644
--- a/tests/ui/explicit_deref_methods.rs
+++ b/tests/ui/explicit_deref_methods.rs
@@ -1,6 +1,6 @@
 // run-rustfix
 
-#![allow(unused_variables, clippy::many_single_char_names, clippy::clone_double_ref)]
+#![allow(unused_variables, clippy::clone_double_ref)]
 #![warn(clippy::explicit_deref_methods)]
 
 use std::ops::{Deref, DerefMut};
diff --git a/tests/ui/float_cmp.rs b/tests/ui/float_cmp.rs
index ad5d1a09c03..a34458b9419 100644
--- a/tests/ui/float_cmp.rs
+++ b/tests/ui/float_cmp.rs
@@ -4,8 +4,7 @@
     clippy::no_effect,
     clippy::op_ref,
     clippy::unnecessary_operation,
-    clippy::cast_lossless,
-    clippy::many_single_char_names
+    clippy::cast_lossless
 )]
 
 use std::ops::Add;
diff --git a/tests/ui/float_cmp.stderr b/tests/ui/float_cmp.stderr
index cb5b68b2e95..9cc1f1b75ed 100644
--- a/tests/ui/float_cmp.stderr
+++ b/tests/ui/float_cmp.stderr
@@ -1,5 +1,5 @@
 error: strict comparison of `f32` or `f64`
-  --> $DIR/float_cmp.rs:58:5
+  --> $DIR/float_cmp.rs:57:5
    |
 LL |     ONE as f64 != 2.0;
    |     ^^^^^^^^^^^^^^^^^ help: consider comparing them within some margin of error: `(ONE as f64 - 2.0).abs() > error_margin`
@@ -8,7 +8,7 @@ LL |     ONE as f64 != 2.0;
    = note: `f32::EPSILON` and `f64::EPSILON` are available for the `error_margin`
 
 error: strict comparison of `f32` or `f64`
-  --> $DIR/float_cmp.rs:63:5
+  --> $DIR/float_cmp.rs:62:5
    |
 LL |     x == 1.0;
    |     ^^^^^^^^ help: consider comparing them within some margin of error: `(x - 1.0).abs() < error_margin`
@@ -16,7 +16,7 @@ LL |     x == 1.0;
    = note: `f32::EPSILON` and `f64::EPSILON` are available for the `error_margin`
 
 error: strict comparison of `f32` or `f64`
-  --> $DIR/float_cmp.rs:66:5
+  --> $DIR/float_cmp.rs:65:5
    |
 LL |     twice(x) != twice(ONE as f64);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider comparing them within some margin of error: `(twice(x) - twice(ONE as f64)).abs() > error_margin`
@@ -24,7 +24,7 @@ LL |     twice(x) != twice(ONE as f64);
    = note: `f32::EPSILON` and `f64::EPSILON` are available for the `error_margin`
 
 error: strict comparison of `f32` or `f64`
-  --> $DIR/float_cmp.rs:86:5
+  --> $DIR/float_cmp.rs:85:5
    |
 LL |     NON_ZERO_ARRAY[i] == NON_ZERO_ARRAY[j];
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider comparing them within some margin of error: `(NON_ZERO_ARRAY[i] - NON_ZERO_ARRAY[j]).abs() < error_margin`
@@ -32,7 +32,7 @@ LL |     NON_ZERO_ARRAY[i] == NON_ZERO_ARRAY[j];
    = note: `f32::EPSILON` and `f64::EPSILON` are available for the `error_margin`
 
 error: strict comparison of `f32` or `f64` arrays
-  --> $DIR/float_cmp.rs:91:5
+  --> $DIR/float_cmp.rs:90:5
    |
 LL |     a1 == a2;
    |     ^^^^^^^^
@@ -40,7 +40,7 @@ LL |     a1 == a2;
    = note: `f32::EPSILON` and `f64::EPSILON` are available for the `error_margin`
 
 error: strict comparison of `f32` or `f64`
-  --> $DIR/float_cmp.rs:92:5
+  --> $DIR/float_cmp.rs:91:5
    |
 LL |     a1[0] == a2[0];
    |     ^^^^^^^^^^^^^^ help: consider comparing them within some margin of error: `(a1[0] - a2[0]).abs() < error_margin`
diff --git a/tests/ui/for_loop_fixable.fixed b/tests/ui/for_loop_fixable.fixed
index f44928d4083..f0e4835415f 100644
--- a/tests/ui/for_loop_fixable.fixed
+++ b/tests/ui/for_loop_fixable.fixed
@@ -29,7 +29,7 @@ impl Unrelated {
     clippy::unnecessary_mut_passed,
     clippy::similar_names
 )]
-#[allow(clippy::many_single_char_names, unused_variables)]
+#[allow(unused_variables)]
 fn main() {
     let mut vec = vec![1, 2, 3, 4];
 
diff --git a/tests/ui/for_loop_fixable.rs b/tests/ui/for_loop_fixable.rs
index 5b1eb3ee4dc..1edef175fb9 100644
--- a/tests/ui/for_loop_fixable.rs
+++ b/tests/ui/for_loop_fixable.rs
@@ -29,7 +29,7 @@ impl Unrelated {
     clippy::unnecessary_mut_passed,
     clippy::similar_names
 )]
-#[allow(clippy::many_single_char_names, unused_variables)]
+#[allow(unused_variables)]
 fn main() {
     let mut vec = vec![1, 2, 3, 4];
 
diff --git a/tests/ui/infinite_loop.rs b/tests/ui/infinite_loop.rs
index e518b2677b7..e86bd7bcf4f 100644
--- a/tests/ui/infinite_loop.rs
+++ b/tests/ui/infinite_loop.rs
@@ -16,7 +16,6 @@ fn foob() -> bool {
     unimplemented!()
 }
 
-#[allow(clippy::many_single_char_names)]
 fn immutable_condition() {
     // Should warn when all vars mentioned are immutable
     let y = 0;
diff --git a/tests/ui/infinite_loop.stderr b/tests/ui/infinite_loop.stderr
index 2736753c14b..69309b0da87 100644
--- a/tests/ui/infinite_loop.stderr
+++ b/tests/ui/infinite_loop.stderr
@@ -1,5 +1,5 @@
 error: variables in the condition are not mutated in the loop body
-  --> $DIR/infinite_loop.rs:23:11
+  --> $DIR/infinite_loop.rs:22:11
    |
 LL |     while y < 10 {
    |           ^^^^^^
@@ -8,7 +8,7 @@ LL |     while y < 10 {
    = note: this may lead to an infinite or to a never running loop
 
 error: variables in the condition are not mutated in the loop body
-  --> $DIR/infinite_loop.rs:28:11
+  --> $DIR/infinite_loop.rs:27:11
    |
 LL |     while y < 10 && x < 3 {
    |           ^^^^^^^^^^^^^^^
@@ -16,7 +16,7 @@ LL |     while y < 10 && x < 3 {
    = note: this may lead to an infinite or to a never running loop
 
 error: variables in the condition are not mutated in the loop body
-  --> $DIR/infinite_loop.rs:35:11
+  --> $DIR/infinite_loop.rs:34:11
    |
 LL |     while !cond {
    |           ^^^^^
@@ -24,7 +24,7 @@ LL |     while !cond {
    = note: this may lead to an infinite or to a never running loop
 
 error: variables in the condition are not mutated in the loop body
-  --> $DIR/infinite_loop.rs:79:11
+  --> $DIR/infinite_loop.rs:78:11
    |
 LL |     while i < 3 {
    |           ^^^^^
@@ -32,7 +32,7 @@ LL |     while i < 3 {
    = note: this may lead to an infinite or to a never running loop
 
 error: variables in the condition are not mutated in the loop body
-  --> $DIR/infinite_loop.rs:84:11
+  --> $DIR/infinite_loop.rs:83:11
    |
 LL |     while i < 3 && j > 0 {
    |           ^^^^^^^^^^^^^^
@@ -40,7 +40,7 @@ LL |     while i < 3 && j > 0 {
    = note: this may lead to an infinite or to a never running loop
 
 error: variables in the condition are not mutated in the loop body
-  --> $DIR/infinite_loop.rs:88:11
+  --> $DIR/infinite_loop.rs:87:11
    |
 LL |     while i < 3 {
    |           ^^^^^
@@ -48,7 +48,7 @@ LL |     while i < 3 {
    = note: this may lead to an infinite or to a never running loop
 
 error: variables in the condition are not mutated in the loop body
-  --> $DIR/infinite_loop.rs:103:11
+  --> $DIR/infinite_loop.rs:102:11
    |
 LL |     while i < 3 {
    |           ^^^^^
@@ -56,7 +56,7 @@ LL |     while i < 3 {
    = note: this may lead to an infinite or to a never running loop
 
 error: variables in the condition are not mutated in the loop body
-  --> $DIR/infinite_loop.rs:108:11
+  --> $DIR/infinite_loop.rs:107:11
    |
 LL |     while i < 3 {
    |           ^^^^^
@@ -64,7 +64,7 @@ LL |     while i < 3 {
    = note: this may lead to an infinite or to a never running loop
 
 error: variables in the condition are not mutated in the loop body
-  --> $DIR/infinite_loop.rs:174:15
+  --> $DIR/infinite_loop.rs:173:15
    |
 LL |         while self.count < n {
    |               ^^^^^^^^^^^^^^
@@ -72,7 +72,7 @@ LL |         while self.count < n {
    = note: this may lead to an infinite or to a never running loop
 
 error: variables in the condition are not mutated in the loop body
-  --> $DIR/infinite_loop.rs:182:11
+  --> $DIR/infinite_loop.rs:181:11
    |
 LL |     while y < 10 {
    |           ^^^^^^
@@ -82,7 +82,7 @@ LL |     while y < 10 {
    = help: rewrite it as `if cond { loop { } }`
 
 error: variables in the condition are not mutated in the loop body
-  --> $DIR/infinite_loop.rs:189:11
+  --> $DIR/infinite_loop.rs:188:11
    |
 LL |     while y < 10 {
    |           ^^^^^^
diff --git a/tests/ui/inherent_to_string.rs b/tests/ui/inherent_to_string.rs
index 6e65fdbd04e..aeb0a0c1e2e 100644
--- a/tests/ui/inherent_to_string.rs
+++ b/tests/ui/inherent_to_string.rs
@@ -1,6 +1,5 @@
 #![warn(clippy::inherent_to_string)]
 #![deny(clippy::inherent_to_string_shadow_display)]
-#![allow(clippy::many_single_char_names)]
 
 use std::fmt;
 
diff --git a/tests/ui/inherent_to_string.stderr b/tests/ui/inherent_to_string.stderr
index f5fcc193b4d..4f331f5bec9 100644
--- a/tests/ui/inherent_to_string.stderr
+++ b/tests/ui/inherent_to_string.stderr
@@ -1,5 +1,5 @@
 error: implementation of inherent method `to_string(&self) -> String` for type `A`
-  --> $DIR/inherent_to_string.rs:21:5
+  --> $DIR/inherent_to_string.rs:20:5
    |
 LL | /     fn to_string(&self) -> String {
 LL | |         "A.to_string()".to_string()
@@ -10,7 +10,7 @@ LL | |     }
    = help: implement trait `Display` for type `A` instead
 
 error: type `C` implements inherent method `to_string(&self) -> String` which shadows the implementation of `Display`
-  --> $DIR/inherent_to_string.rs:45:5
+  --> $DIR/inherent_to_string.rs:44:5
    |
 LL | /     fn to_string(&self) -> String {
 LL | |         "C.to_string()".to_string()
diff --git a/tests/ui/logic_bug.rs b/tests/ui/logic_bug.rs
index a01c6ef99db..4eaa2dd98eb 100644
--- a/tests/ui/logic_bug.rs
+++ b/tests/ui/logic_bug.rs
@@ -1,4 +1,4 @@
-#![allow(unused, clippy::many_single_char_names, clippy::diverging_sub_expression)]
+#![allow(unused, clippy::diverging_sub_expression)]
 #![warn(clippy::logic_bug)]
 
 fn main() {
diff --git a/tests/ui/many_single_char_names.rs b/tests/ui/many_single_char_names.rs
index 80800e48724..65769819110 100644
--- a/tests/ui/many_single_char_names.rs
+++ b/tests/ui/many_single_char_names.rs
@@ -1,4 +1,4 @@
-#[warn(clippy::many_single_char_names)]
+#![warn(clippy::many_single_char_names)]
 
 fn bla() {
     let a: i32;
diff --git a/tests/ui/match_single_binding.fixed b/tests/ui/match_single_binding.fixed
index 30bf6402253..b4ec525ada0 100644
--- a/tests/ui/match_single_binding.fixed
+++ b/tests/ui/match_single_binding.fixed
@@ -1,7 +1,7 @@
 // run-rustfix
 
 #![warn(clippy::match_single_binding)]
-#![allow(unused_variables, clippy::many_single_char_names, clippy::toplevel_ref_arg)]
+#![allow(unused_variables, clippy::toplevel_ref_arg)]
 
 struct Point {
     x: i32,
diff --git a/tests/ui/match_single_binding.rs b/tests/ui/match_single_binding.rs
index d8bb80d8b96..e04c4018b98 100644
--- a/tests/ui/match_single_binding.rs
+++ b/tests/ui/match_single_binding.rs
@@ -1,7 +1,7 @@
 // run-rustfix
 
 #![warn(clippy::match_single_binding)]
-#![allow(unused_variables, clippy::many_single_char_names, clippy::toplevel_ref_arg)]
+#![allow(unused_variables, clippy::toplevel_ref_arg)]
 
 struct Point {
     x: i32,
diff --git a/tests/ui/needless_pass_by_value.rs b/tests/ui/needless_pass_by_value.rs
index 7a9ba55590d..5a35b100afe 100644
--- a/tests/ui/needless_pass_by_value.rs
+++ b/tests/ui/needless_pass_by_value.rs
@@ -3,7 +3,6 @@
     dead_code,
     clippy::single_match,
     clippy::redundant_pattern_matching,
-    clippy::many_single_char_names,
     clippy::option_option,
     clippy::redundant_clone
 )]
diff --git a/tests/ui/needless_pass_by_value.stderr b/tests/ui/needless_pass_by_value.stderr
index 2f61ba241c4..d960c86a9f0 100644
--- a/tests/ui/needless_pass_by_value.stderr
+++ b/tests/ui/needless_pass_by_value.stderr
@@ -1,5 +1,5 @@
 error: this argument is passed by value, but not consumed in the function body
-  --> $DIR/needless_pass_by_value.rs:18:23
+  --> $DIR/needless_pass_by_value.rs:17:23
    |
 LL | fn foo<T: Default>(v: Vec<T>, w: Vec<T>, mut x: Vec<T>, y: Vec<T>) -> Vec<T> {
    |                       ^^^^^^ help: consider changing the type to: `&[T]`
@@ -7,55 +7,55 @@ LL | fn foo<T: Default>(v: Vec<T>, w: Vec<T>, mut x: Vec<T>, y: Vec<T>) -> Vec<T
    = note: `-D clippy::needless-pass-by-value` implied by `-D warnings`
 
 error: this argument is passed by value, but not consumed in the function body
-  --> $DIR/needless_pass_by_value.rs:32:11
+  --> $DIR/needless_pass_by_value.rs:31:11
    |
 LL | fn bar(x: String, y: Wrapper) {
    |           ^^^^^^ help: consider changing the type to: `&str`
 
 error: this argument is passed by value, but not consumed in the function body
-  --> $DIR/needless_pass_by_value.rs:32:22
+  --> $DIR/needless_pass_by_value.rs:31:22
    |
 LL | fn bar(x: String, y: Wrapper) {
    |                      ^^^^^^^ help: consider taking a reference instead: `&Wrapper`
 
 error: this argument is passed by value, but not consumed in the function body
-  --> $DIR/needless_pass_by_value.rs:38:71
+  --> $DIR/needless_pass_by_value.rs:37:71
    |
 LL | fn test_borrow_trait<T: Borrow<str>, U: AsRef<str>, V>(t: T, u: U, v: V) {
    |                                                                       ^ help: consider taking a reference instead: `&V`
 
 error: this argument is passed by value, but not consumed in the function body
-  --> $DIR/needless_pass_by_value.rs:50:18
+  --> $DIR/needless_pass_by_value.rs:49:18
    |
 LL | fn test_match(x: Option<Option<String>>, y: Option<Option<String>>) {
    |                  ^^^^^^^^^^^^^^^^^^^^^^ help: consider taking a reference instead: `&Option<Option<String>>`
 
 error: this argument is passed by value, but not consumed in the function body
-  --> $DIR/needless_pass_by_value.rs:63:24
+  --> $DIR/needless_pass_by_value.rs:62:24
    |
 LL | fn test_destructure(x: Wrapper, y: Wrapper, z: Wrapper) {
    |                        ^^^^^^^ help: consider taking a reference instead: `&Wrapper`
 
 error: this argument is passed by value, but not consumed in the function body
-  --> $DIR/needless_pass_by_value.rs:63:36
+  --> $DIR/needless_pass_by_value.rs:62:36
    |
 LL | fn test_destructure(x: Wrapper, y: Wrapper, z: Wrapper) {
    |                                    ^^^^^^^ help: consider taking a reference instead: `&Wrapper`
 
 error: this argument is passed by value, but not consumed in the function body
-  --> $DIR/needless_pass_by_value.rs:79:49
+  --> $DIR/needless_pass_by_value.rs:78:49
    |
 LL | fn test_blanket_ref<T: Foo, S: Serialize>(_foo: T, _serializable: S) {}
    |                                                 ^ help: consider taking a reference instead: `&T`
 
 error: this argument is passed by value, but not consumed in the function body
-  --> $DIR/needless_pass_by_value.rs:81:18
+  --> $DIR/needless_pass_by_value.rs:80:18
    |
 LL | fn issue_2114(s: String, t: String, u: Vec<i32>, v: Vec<i32>) {
    |                  ^^^^^^ help: consider taking a reference instead: `&String`
 
 error: this argument is passed by value, but not consumed in the function body
-  --> $DIR/needless_pass_by_value.rs:81:29
+  --> $DIR/needless_pass_by_value.rs:80:29
    |
 LL | fn issue_2114(s: String, t: String, u: Vec<i32>, v: Vec<i32>) {
    |                             ^^^^^^
@@ -70,13 +70,13 @@ LL |     let _ = t.to_string();
    |             ~~~~~~~~~~~~~
 
 error: this argument is passed by value, but not consumed in the function body
-  --> $DIR/needless_pass_by_value.rs:81:40
+  --> $DIR/needless_pass_by_value.rs:80:40
    |
 LL | fn issue_2114(s: String, t: String, u: Vec<i32>, v: Vec<i32>) {
    |                                        ^^^^^^^^ help: consider taking a reference instead: `&Vec<i32>`
 
 error: this argument is passed by value, but not consumed in the function body
-  --> $DIR/needless_pass_by_value.rs:81:53
+  --> $DIR/needless_pass_by_value.rs:80:53
    |
 LL | fn issue_2114(s: String, t: String, u: Vec<i32>, v: Vec<i32>) {
    |                                                     ^^^^^^^^
@@ -91,85 +91,85 @@ LL |     let _ = v.to_owned();
    |             ~~~~~~~~~~~~
 
 error: this argument is passed by value, but not consumed in the function body
-  --> $DIR/needless_pass_by_value.rs:94:12
+  --> $DIR/needless_pass_by_value.rs:93:12
    |
 LL |         s: String,
    |            ^^^^^^ help: consider changing the type to: `&str`
 
 error: this argument is passed by value, but not consumed in the function body
-  --> $DIR/needless_pass_by_value.rs:95:12
+  --> $DIR/needless_pass_by_value.rs:94:12
    |
 LL |         t: String,
    |            ^^^^^^ help: consider taking a reference instead: `&String`
 
 error: this argument is passed by value, but not consumed in the function body
-  --> $DIR/needless_pass_by_value.rs:104:23
+  --> $DIR/needless_pass_by_value.rs:103:23
    |
 LL |     fn baz(&self, _u: U, _s: Self) {}
    |                       ^ help: consider taking a reference instead: `&U`
 
 error: this argument is passed by value, but not consumed in the function body
-  --> $DIR/needless_pass_by_value.rs:104:30
+  --> $DIR/needless_pass_by_value.rs:103:30
    |
 LL |     fn baz(&self, _u: U, _s: Self) {}
    |                              ^^^^ help: consider taking a reference instead: `&Self`
 
 error: this argument is passed by value, but not consumed in the function body
-  --> $DIR/needless_pass_by_value.rs:126:24
+  --> $DIR/needless_pass_by_value.rs:125:24
    |
 LL | fn bar_copy(x: u32, y: CopyWrapper) {
    |                        ^^^^^^^^^^^ help: consider taking a reference instead: `&CopyWrapper`
    |
 help: consider marking this type as `Copy`
-  --> $DIR/needless_pass_by_value.rs:124:1
+  --> $DIR/needless_pass_by_value.rs:123:1
    |
 LL | struct CopyWrapper(u32);
    | ^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this argument is passed by value, but not consumed in the function body
-  --> $DIR/needless_pass_by_value.rs:132:29
+  --> $DIR/needless_pass_by_value.rs:131:29
    |
 LL | fn test_destructure_copy(x: CopyWrapper, y: CopyWrapper, z: CopyWrapper) {
    |                             ^^^^^^^^^^^ help: consider taking a reference instead: `&CopyWrapper`
    |
 help: consider marking this type as `Copy`
-  --> $DIR/needless_pass_by_value.rs:124:1
+  --> $DIR/needless_pass_by_value.rs:123:1
    |
 LL | struct CopyWrapper(u32);
    | ^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this argument is passed by value, but not consumed in the function body
-  --> $DIR/needless_pass_by_value.rs:132:45
+  --> $DIR/needless_pass_by_value.rs:131:45
    |
 LL | fn test_destructure_copy(x: CopyWrapper, y: CopyWrapper, z: CopyWrapper) {
    |                                             ^^^^^^^^^^^ help: consider taking a reference instead: `&CopyWrapper`
    |
 help: consider marking this type as `Copy`
-  --> $DIR/needless_pass_by_value.rs:124:1
+  --> $DIR/needless_pass_by_value.rs:123:1
    |
 LL | struct CopyWrapper(u32);
    | ^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this argument is passed by value, but not consumed in the function body
-  --> $DIR/needless_pass_by_value.rs:132:61
+  --> $DIR/needless_pass_by_value.rs:131:61
    |
 LL | fn test_destructure_copy(x: CopyWrapper, y: CopyWrapper, z: CopyWrapper) {
    |                                                             ^^^^^^^^^^^ help: consider taking a reference instead: `&CopyWrapper`
    |
 help: consider marking this type as `Copy`
-  --> $DIR/needless_pass_by_value.rs:124:1
+  --> $DIR/needless_pass_by_value.rs:123:1
    |
 LL | struct CopyWrapper(u32);
    | ^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this argument is passed by value, but not consumed in the function body
-  --> $DIR/needless_pass_by_value.rs:144:40
+  --> $DIR/needless_pass_by_value.rs:143:40
    |
 LL | fn some_fun<'b, S: Bar<'b, ()>>(_item: S) {}
    |                                        ^ help: consider taking a reference instead: `&S`
 
 error: this argument is passed by value, but not consumed in the function body
-  --> $DIR/needless_pass_by_value.rs:149:20
+  --> $DIR/needless_pass_by_value.rs:148:20
    |
 LL | fn more_fun(_item: impl Club<'static, i32>) {}
    |                    ^^^^^^^^^^^^^^^^^^^^^^^ help: consider taking a reference instead: `&impl Club<'static, i32>`
diff --git a/tests/ui/nonminimal_bool.rs b/tests/ui/nonminimal_bool.rs
index 971be26278f..fa5743c1155 100644
--- a/tests/ui/nonminimal_bool.rs
+++ b/tests/ui/nonminimal_bool.rs
@@ -1,4 +1,4 @@
-#![allow(unused, clippy::many_single_char_names, clippy::diverging_sub_expression)]
+#![allow(unused, clippy::diverging_sub_expression)]
 #![warn(clippy::nonminimal_bool)]
 
 fn main() {
diff --git a/tests/ui/nonminimal_bool_methods.rs b/tests/ui/nonminimal_bool_methods.rs
index 90758740290..d0a289b7ea4 100644
--- a/tests/ui/nonminimal_bool_methods.rs
+++ b/tests/ui/nonminimal_bool_methods.rs
@@ -1,4 +1,4 @@
-#![allow(unused, clippy::many_single_char_names, clippy::diverging_sub_expression)]
+#![allow(unused, clippy::diverging_sub_expression)]
 #![warn(clippy::nonminimal_bool)]
 
 fn methods_with_negation() {
diff --git a/tests/ui/op_ref.rs b/tests/ui/op_ref.rs
index 6605c967c8e..ab9c4d34c88 100644
--- a/tests/ui/op_ref.rs
+++ b/tests/ui/op_ref.rs
@@ -1,6 +1,5 @@
 #![allow(unused_variables, clippy::blacklisted_name)]
 #![warn(clippy::op_ref)]
-#![allow(clippy::many_single_char_names)]
 use std::collections::HashSet;
 use std::ops::BitAnd;
 
diff --git a/tests/ui/op_ref.stderr b/tests/ui/op_ref.stderr
index 821099d8779..992417084bd 100644
--- a/tests/ui/op_ref.stderr
+++ b/tests/ui/op_ref.stderr
@@ -1,5 +1,5 @@
 error: needlessly taken reference of both operands
-  --> $DIR/op_ref.rs:12:15
+  --> $DIR/op_ref.rs:11:15
    |
 LL |     let foo = &5 - &6;
    |               ^^^^^^^
@@ -11,7 +11,7 @@ LL |     let foo = 5 - 6;
    |               ~   ~
 
 error: taken reference of right operand
-  --> $DIR/op_ref.rs:57:13
+  --> $DIR/op_ref.rs:56:13
    |
 LL |     let z = x & &y;
    |             ^^^^--
diff --git a/tests/ui/overflow_check_conditional.rs b/tests/ui/overflow_check_conditional.rs
index 84332040dba..5db75f5291b 100644
--- a/tests/ui/overflow_check_conditional.rs
+++ b/tests/ui/overflow_check_conditional.rs
@@ -1,4 +1,3 @@
-#![allow(clippy::many_single_char_names)]
 #![warn(clippy::overflow_check_conditional)]
 
 fn main() {
diff --git a/tests/ui/overflow_check_conditional.stderr b/tests/ui/overflow_check_conditional.stderr
index 19e843c2c0a..1b8b146b60a 100644
--- a/tests/ui/overflow_check_conditional.stderr
+++ b/tests/ui/overflow_check_conditional.stderr
@@ -1,5 +1,5 @@
 error: you are trying to use classic C overflow conditions that will fail in Rust
-  --> $DIR/overflow_check_conditional.rs:8:8
+  --> $DIR/overflow_check_conditional.rs:7:8
    |
 LL |     if a + b < a {}
    |        ^^^^^^^^^
@@ -7,43 +7,43 @@ LL |     if a + b < a {}
    = note: `-D clippy::overflow-check-conditional` implied by `-D warnings`
 
 error: you are trying to use classic C overflow conditions that will fail in Rust
-  --> $DIR/overflow_check_conditional.rs:9:8
+  --> $DIR/overflow_check_conditional.rs:8:8
    |
 LL |     if a > a + b {}
    |        ^^^^^^^^^
 
 error: you are trying to use classic C overflow conditions that will fail in Rust
-  --> $DIR/overflow_check_conditional.rs:10:8
+  --> $DIR/overflow_check_conditional.rs:9:8
    |
 LL |     if a + b < b {}
    |        ^^^^^^^^^
 
 error: you are trying to use classic C overflow conditions that will fail in Rust
-  --> $DIR/overflow_check_conditional.rs:11:8
+  --> $DIR/overflow_check_conditional.rs:10:8
    |
 LL |     if b > a + b {}
    |        ^^^^^^^^^
 
 error: you are trying to use classic C underflow conditions that will fail in Rust
-  --> $DIR/overflow_check_conditional.rs:12:8
+  --> $DIR/overflow_check_conditional.rs:11:8
    |
 LL |     if a - b > b {}
    |        ^^^^^^^^^
 
 error: you are trying to use classic C underflow conditions that will fail in Rust
-  --> $DIR/overflow_check_conditional.rs:13:8
+  --> $DIR/overflow_check_conditional.rs:12:8
    |
 LL |     if b < a - b {}
    |        ^^^^^^^^^
 
 error: you are trying to use classic C underflow conditions that will fail in Rust
-  --> $DIR/overflow_check_conditional.rs:14:8
+  --> $DIR/overflow_check_conditional.rs:13:8
    |
 LL |     if a - b > a {}
    |        ^^^^^^^^^
 
 error: you are trying to use classic C underflow conditions that will fail in Rust
-  --> $DIR/overflow_check_conditional.rs:15:8
+  --> $DIR/overflow_check_conditional.rs:14:8
    |
 LL |     if a < a - b {}
    |        ^^^^^^^^^
diff --git a/tests/ui/ptr_arg.rs b/tests/ui/ptr_arg.rs
index 06370dfce65..8656c17f29a 100644
--- a/tests/ui/ptr_arg.rs
+++ b/tests/ui/ptr_arg.rs
@@ -1,4 +1,4 @@
-#![allow(unused, clippy::many_single_char_names, clippy::redundant_clone)]
+#![allow(unused, clippy::redundant_clone)]
 #![warn(clippy::ptr_arg)]
 
 use std::borrow::Cow;
diff --git a/tests/ui/repeat_once.fixed b/tests/ui/repeat_once.fixed
index a637c22fbcd..dc197e50300 100644
--- a/tests/ui/repeat_once.fixed
+++ b/tests/ui/repeat_once.fixed
@@ -1,6 +1,6 @@
 // run-rustfix
 #![warn(clippy::repeat_once)]
-#[allow(unused, clippy::many_single_char_names, clippy::redundant_clone)]
+#[allow(unused, clippy::redundant_clone)]
 fn main() {
     const N: usize = 1;
     let s = "str";
diff --git a/tests/ui/repeat_once.rs b/tests/ui/repeat_once.rs
index d99ca1b5b55..0ec5127117c 100644
--- a/tests/ui/repeat_once.rs
+++ b/tests/ui/repeat_once.rs
@@ -1,6 +1,6 @@
 // run-rustfix
 #![warn(clippy::repeat_once)]
-#[allow(unused, clippy::many_single_char_names, clippy::redundant_clone)]
+#[allow(unused, clippy::redundant_clone)]
 fn main() {
     const N: usize = 1;
     let s = "str";
diff --git a/tests/ui/trivially_copy_pass_by_ref.rs b/tests/ui/trivially_copy_pass_by_ref.rs
index 1a0123803a3..ea3dce17081 100644
--- a/tests/ui/trivially_copy_pass_by_ref.rs
+++ b/tests/ui/trivially_copy_pass_by_ref.rs
@@ -2,11 +2,7 @@
 // normalize-stderr-test "\(limit: \d+ byte\)" -> "(limit: N byte)"
 
 #![deny(clippy::trivially_copy_pass_by_ref)]
-#![allow(
-    clippy::many_single_char_names,
-    clippy::blacklisted_name,
-    clippy::redundant_field_names
-)]
+#![allow(clippy::blacklisted_name, clippy::redundant_field_names)]
 
 #[derive(Copy, Clone)]
 struct Foo(u32);
diff --git a/tests/ui/trivially_copy_pass_by_ref.stderr b/tests/ui/trivially_copy_pass_by_ref.stderr
index 9c4c49ceac4..a88d35f3ea5 100644
--- a/tests/ui/trivially_copy_pass_by_ref.stderr
+++ b/tests/ui/trivially_copy_pass_by_ref.stderr
@@ -1,5 +1,5 @@
 error: this argument (N byte) is passed by reference, but would be more efficient if passed by value (limit: N byte)
-  --> $DIR/trivially_copy_pass_by_ref.rs:51:11
+  --> $DIR/trivially_copy_pass_by_ref.rs:47:11
    |
 LL | fn bad(x: &u32, y: &Foo, z: &Baz) {}
    |           ^^^^ help: consider passing by value instead: `u32`
@@ -11,97 +11,97 @@ LL | #![deny(clippy::trivially_copy_pass_by_ref)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this argument (N byte) is passed by reference, but would be more efficient if passed by value (limit: N byte)
-  --> $DIR/trivially_copy_pass_by_ref.rs:51:20
+  --> $DIR/trivially_copy_pass_by_ref.rs:47:20
    |
 LL | fn bad(x: &u32, y: &Foo, z: &Baz) {}
    |                    ^^^^ help: consider passing by value instead: `Foo`
 
 error: this argument (N byte) is passed by reference, but would be more efficient if passed by value (limit: N byte)
-  --> $DIR/trivially_copy_pass_by_ref.rs:51:29
+  --> $DIR/trivially_copy_pass_by_ref.rs:47:29
    |
 LL | fn bad(x: &u32, y: &Foo, z: &Baz) {}
    |                             ^^^^ help: consider passing by value instead: `Baz`
 
 error: this argument (N byte) is passed by reference, but would be more efficient if passed by value (limit: N byte)
-  --> $DIR/trivially_copy_pass_by_ref.rs:58:12
+  --> $DIR/trivially_copy_pass_by_ref.rs:54:12
    |
 LL |     fn bad(&self, x: &u32, y: &Foo, z: &Baz) {}
    |            ^^^^^ help: consider passing by value instead: `self`
 
 error: this argument (N byte) is passed by reference, but would be more efficient if passed by value (limit: N byte)
-  --> $DIR/trivially_copy_pass_by_ref.rs:58:22
+  --> $DIR/trivially_copy_pass_by_ref.rs:54:22
    |
 LL |     fn bad(&self, x: &u32, y: &Foo, z: &Baz) {}
    |                      ^^^^ help: consider passing by value instead: `u32`
 
 error: this argument (N byte) is passed by reference, but would be more efficient if passed by value (limit: N byte)
-  --> $DIR/trivially_copy_pass_by_ref.rs:58:31
+  --> $DIR/trivially_copy_pass_by_ref.rs:54:31
    |
 LL |     fn bad(&self, x: &u32, y: &Foo, z: &Baz) {}
    |                               ^^^^ help: consider passing by value instead: `Foo`
 
 error: this argument (N byte) is passed by reference, but would be more efficient if passed by value (limit: N byte)
-  --> $DIR/trivially_copy_pass_by_ref.rs:58:40
+  --> $DIR/trivially_copy_pass_by_ref.rs:54:40
    |
 LL |     fn bad(&self, x: &u32, y: &Foo, z: &Baz) {}
    |                                        ^^^^ help: consider passing by value instead: `Baz`
 
 error: this argument (N byte) is passed by reference, but would be more efficient if passed by value (limit: N byte)
-  --> $DIR/trivially_copy_pass_by_ref.rs:60:16
+  --> $DIR/trivially_copy_pass_by_ref.rs:56:16
    |
 LL |     fn bad2(x: &u32, y: &Foo, z: &Baz) {}
    |                ^^^^ help: consider passing by value instead: `u32`
 
 error: this argument (N byte) is passed by reference, but would be more efficient if passed by value (limit: N byte)
-  --> $DIR/trivially_copy_pass_by_ref.rs:60:25
+  --> $DIR/trivially_copy_pass_by_ref.rs:56:25
    |
 LL |     fn bad2(x: &u32, y: &Foo, z: &Baz) {}
    |                         ^^^^ help: consider passing by value instead: `Foo`
 
 error: this argument (N byte) is passed by reference, but would be more efficient if passed by value (limit: N byte)
-  --> $DIR/trivially_copy_pass_by_ref.rs:60:34
+  --> $DIR/trivially_copy_pass_by_ref.rs:56:34
    |
 LL |     fn bad2(x: &u32, y: &Foo, z: &Baz) {}
    |                                  ^^^^ help: consider passing by value instead: `Baz`
 
 error: this argument (N byte) is passed by reference, but would be more efficient if passed by value (limit: N byte)
-  --> $DIR/trivially_copy_pass_by_ref.rs:62:35
+  --> $DIR/trivially_copy_pass_by_ref.rs:58:35
    |
 LL |     fn bad_issue7518(self, other: &Self) {}
    |                                   ^^^^^ help: consider passing by value instead: `Self`
 
 error: this argument (N byte) is passed by reference, but would be more efficient if passed by value (limit: N byte)
-  --> $DIR/trivially_copy_pass_by_ref.rs:74:16
+  --> $DIR/trivially_copy_pass_by_ref.rs:70:16
    |
 LL |     fn bad2(x: &u32, y: &Foo, z: &Baz) {}
    |                ^^^^ help: consider passing by value instead: `u32`
 
 error: this argument (N byte) is passed by reference, but would be more efficient if passed by value (limit: N byte)
-  --> $DIR/trivially_copy_pass_by_ref.rs:74:25
+  --> $DIR/trivially_copy_pass_by_ref.rs:70:25
    |
 LL |     fn bad2(x: &u32, y: &Foo, z: &Baz) {}
    |                         ^^^^ help: consider passing by value instead: `Foo`
 
 error: this argument (N byte) is passed by reference, but would be more efficient if passed by value (limit: N byte)
-  --> $DIR/trivially_copy_pass_by_ref.rs:74:34
+  --> $DIR/trivially_copy_pass_by_ref.rs:70:34
    |
 LL |     fn bad2(x: &u32, y: &Foo, z: &Baz) {}
    |                                  ^^^^ help: consider passing by value instead: `Baz`
 
 error: this argument (N byte) is passed by reference, but would be more efficient if passed by value (limit: N byte)
-  --> $DIR/trivially_copy_pass_by_ref.rs:78:34
+  --> $DIR/trivially_copy_pass_by_ref.rs:74:34
    |
 LL |     fn trait_method(&self, _foo: &Foo);
    |                                  ^^^^ help: consider passing by value instead: `Foo`
 
 error: this argument (N byte) is passed by reference, but would be more efficient if passed by value (limit: N byte)
-  --> $DIR/trivially_copy_pass_by_ref.rs:110:21
+  --> $DIR/trivially_copy_pass_by_ref.rs:106:21
    |
 LL |     fn foo_never(x: &i32) {
    |                     ^^^^ help: consider passing by value instead: `i32`
 
 error: this argument (N byte) is passed by reference, but would be more efficient if passed by value (limit: N byte)
-  --> $DIR/trivially_copy_pass_by_ref.rs:115:15
+  --> $DIR/trivially_copy_pass_by_ref.rs:111:15
    |
 LL |     fn foo(x: &i32) {
    |               ^^^^ help: consider passing by value instead: `i32`
-- 
cgit 1.4.1-3-g733a5


From ee6a6b55c4281d2bdd78bc48eb507db7aa525cf7 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Fri, 17 Sep 2021 21:44:21 -0400
Subject: Change the suggestion for `while_let_on_iterator` when the iterator
 cannot be consumed to `iter.by_ref()`

---
 clippy_lints/src/loops/while_let_on_iterator.rs | 13 ++++---------
 tests/ui/while_let_on_iterator.fixed            | 18 +++++++++---------
 tests/ui/while_let_on_iterator.stderr           | 18 +++++++++---------
 3 files changed, 22 insertions(+), 27 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/while_let_on_iterator.rs b/clippy_lints/src/loops/while_let_on_iterator.rs
index 79527e3bfa9..9a3475c977e 100644
--- a/clippy_lints/src/loops/while_let_on_iterator.rs
+++ b/clippy_lints/src/loops/while_let_on_iterator.rs
@@ -8,7 +8,7 @@ use clippy_utils::{
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_expr, ErasedMap, NestedVisitorMap, Visitor};
-use rustc_hir::{def::Res, Expr, ExprKind, HirId, Local, Mutability, PatKind, QPath, UnOp};
+use rustc_hir::{def::Res, Expr, ExprKind, HirId, Local, PatKind, QPath, UnOp};
 use rustc_lint::LateContext;
 use rustc_span::{symbol::sym, Span, Symbol};
 
@@ -47,13 +47,8 @@ pub(super) fn check(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
     // If the iterator is a field or the iterator is accessed after the loop is complete it needs to be
     // borrowed mutably. TODO: If the struct can be partially moved from and the struct isn't used
     // afterwards a mutable borrow of a field isn't necessary.
-    let ref_mut = if !iter_expr.fields.is_empty() || needs_mutable_borrow(cx, &iter_expr, loop_expr) {
-        if cx.typeck_results().node_type(iter_expr.hir_id).ref_mutability() == Some(Mutability::Mut) {
-            // Reborrow for mutable references. It may not be possible to get a mutable reference here.
-            "&mut *"
-        } else {
-            "&mut "
-        }
+    let by_ref = if !iter_expr.fields.is_empty() || needs_mutable_borrow(cx, &iter_expr, loop_expr) {
+        ".by_ref()"
     } else {
         ""
     };
@@ -65,7 +60,7 @@ pub(super) fn check(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         expr.span.with_hi(scrutinee_expr.span.hi()),
         "this loop could be written as a `for` loop",
         "try",
-        format!("for {} in {}{}", loop_var, ref_mut, iterator),
+        format!("for {} in {}{}", loop_var, iterator, by_ref),
         applicability,
     );
 }
diff --git a/tests/ui/while_let_on_iterator.fixed b/tests/ui/while_let_on_iterator.fixed
index cdcdd808c94..f5a34190902 100644
--- a/tests/ui/while_let_on_iterator.fixed
+++ b/tests/ui/while_let_on_iterator.fixed
@@ -188,7 +188,7 @@ fn issue6491() {
     // Used in outer loop, needs &mut
     let mut it = 1..40;
     while let Some(n) = it.next() {
-        for m in &mut it {
+        for m in it.by_ref() {
             if m % 10 == 0 {
                 break;
             }
@@ -219,7 +219,7 @@ fn issue6491() {
 
         // Used after the loop, needs &mut.
         let mut it = 1..40;
-        for m in &mut it {
+        for m in it.by_ref() {
             if m % 10 == 0 {
                 break;
             }
@@ -236,7 +236,7 @@ fn issue6231() {
     let mut it = 1..40;
     let mut opt = Some(0);
     while let Some(n) = opt.take().or_else(|| it.next()) {
-        for m in &mut it {
+        for m in it.by_ref() {
             if n % 10 == 0 {
                 break;
             }
@@ -251,7 +251,7 @@ fn issue1924() {
     impl<T: Iterator<Item = u32>> S<T> {
         fn f(&mut self) -> Option<u32> {
             // Used as a field.
-            for i in &mut self.0 {
+            for i in self.0.by_ref() {
                 if !(3..=7).contains(&i) {
                     return Some(i);
                 }
@@ -283,7 +283,7 @@ fn issue1924() {
                 }
             }
             // This one is fine, a different field is borrowed
-            for i in &mut self.0.0.0 {
+            for i in self.0.0.0.by_ref() {
                 if i == 1 {
                     return self.0.1.take();
                 } else {
@@ -312,7 +312,7 @@ fn issue1924() {
 
     // Needs &mut, field of the iterator is accessed after the loop
     let mut it = S2(1..40, 0);
-    for n in &mut it {
+    for n in it.by_ref() {
         if n == 0 {
             break;
         }
@@ -324,7 +324,7 @@ fn issue7249() {
     let mut it = 0..10;
     let mut x = || {
         // Needs &mut, the closure can be called multiple times
-        for x in &mut it {
+        for x in it.by_ref() {
             if x % 2 == 0 {
                 break;
             }
@@ -338,7 +338,7 @@ fn issue7510() {
     let mut it = 0..10;
     let it = &mut it;
     // Needs to reborrow `it` as the binding isn't mutable
-    for x in &mut *it {
+    for x in it.by_ref() {
         if x % 2 == 0 {
             break;
         }
@@ -349,7 +349,7 @@ fn issue7510() {
     let mut it = 0..10;
     let it = S(&mut it);
     // Needs to reborrow `it.0` as the binding isn't mutable
-    for x in &mut *it.0 {
+    for x in it.0.by_ref() {
         if x % 2 == 0 {
             break;
         }
diff --git a/tests/ui/while_let_on_iterator.stderr b/tests/ui/while_let_on_iterator.stderr
index ff9b08996da..5e2fce4491a 100644
--- a/tests/ui/while_let_on_iterator.stderr
+++ b/tests/ui/while_let_on_iterator.stderr
@@ -46,7 +46,7 @@ error: this loop could be written as a `for` loop
   --> $DIR/while_let_on_iterator.rs:191:9
    |
 LL |         while let Some(m) = it.next() {
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for m in &mut it`
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for m in it.by_ref()`
 
 error: this loop could be written as a `for` loop
   --> $DIR/while_let_on_iterator.rs:202:5
@@ -70,19 +70,19 @@ error: this loop could be written as a `for` loop
   --> $DIR/while_let_on_iterator.rs:222:9
    |
 LL |         while let Some(m) = it.next() {
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for m in &mut it`
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for m in it.by_ref()`
 
 error: this loop could be written as a `for` loop
   --> $DIR/while_let_on_iterator.rs:239:9
    |
 LL |         while let Some(m) = it.next() {
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for m in &mut it`
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for m in it.by_ref()`
 
 error: this loop could be written as a `for` loop
   --> $DIR/while_let_on_iterator.rs:254:13
    |
 LL |             while let Some(i) = self.0.next() {
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for i in &mut self.0`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for i in self.0.by_ref()`
 
 error: manual `!RangeInclusive::contains` implementation
   --> $DIR/while_let_on_iterator.rs:255:20
@@ -96,31 +96,31 @@ error: this loop could be written as a `for` loop
   --> $DIR/while_let_on_iterator.rs:286:13
    |
 LL |             while let Some(i) = self.0.0.0.next() {
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for i in &mut self.0.0.0`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for i in self.0.0.0.by_ref()`
 
 error: this loop could be written as a `for` loop
   --> $DIR/while_let_on_iterator.rs:315:5
    |
 LL |     while let Some(n) = it.next() {
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for n in &mut it`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for n in it.by_ref()`
 
 error: this loop could be written as a `for` loop
   --> $DIR/while_let_on_iterator.rs:327:9
    |
 LL |         while let Some(x) = it.next() {
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for x in &mut it`
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for x in it.by_ref()`
 
 error: this loop could be written as a `for` loop
   --> $DIR/while_let_on_iterator.rs:341:5
    |
 LL |     while let Some(x) = it.next() {
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for x in &mut *it`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for x in it.by_ref()`
 
 error: this loop could be written as a `for` loop
   --> $DIR/while_let_on_iterator.rs:352:5
    |
 LL |     while let Some(x) = it.0.next() {
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for x in &mut *it.0`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for x in it.0.by_ref()`
 
 error: this loop could be written as a `for` loop
   --> $DIR/while_let_on_iterator.rs:371:5
-- 
cgit 1.4.1-3-g733a5


From b36591217df3d13a67f1bab77c39c2d5bb55ce02 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Sat, 18 Sep 2021 09:40:16 -0500
Subject: Fix needless_return with let-else

---
 clippy_lints/src/returns.rs     |  5 +++-
 tests/ui/needless_return.fixed  | 12 ++++----
 tests/ui/needless_return.rs     | 12 ++++----
 tests/ui/needless_return.stderr | 64 ++++++++++++++++++++---------------------
 4 files changed, 48 insertions(+), 45 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
index 341b5a61631..ae85b7087e7 100644
--- a/clippy_lints/src/returns.rs
+++ b/clippy_lints/src/returns.rs
@@ -11,6 +11,7 @@ use rustc_middle::hir::map::Map;
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::subst::GenericArgKind;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::hygiene::DesugaringKind;
 use rustc_span::source_map::Span;
 use rustc_span::sym;
 
@@ -199,7 +200,9 @@ fn check_final_expr<'tcx>(
                 check_block_return(cx, ifblock);
             }
             if let Some(else_clause) = else_clause_opt {
-                check_final_expr(cx, else_clause, None, RetReplacement::Empty);
+                if expr.span.desugaring_kind() != Some(DesugaringKind::LetElse) {
+                    check_final_expr(cx, else_clause, None, RetReplacement::Empty);
+                }
             }
         },
         // a match expr, check all arms
diff --git a/tests/ui/needless_return.fixed b/tests/ui/needless_return.fixed
index 5c4fd466c04..37efa6274df 100644
--- a/tests/ui/needless_return.fixed
+++ b/tests/ui/needless_return.fixed
@@ -1,13 +1,9 @@
 // run-rustfix
 // edition:2018
 
+#![feature(let_else)]
 #![allow(unused)]
-#![allow(
-    clippy::if_same_then_else,
-    clippy::single_match,
-    clippy::branches_sharing_code,
-    clippy::needless_bool
-)]
+#![allow(clippy::if_same_then_else, clippy::single_match, clippy::needless_bool)]
 #![warn(clippy::needless_return)]
 
 macro_rules! the_answer {
@@ -207,4 +203,8 @@ async fn async_test_return_in_macro() {
     needed_return!(0);
 }
 
+fn let_else() {
+    let Some(1) = Some(1) else { return };
+}
+
 fn main() {}
diff --git a/tests/ui/needless_return.rs b/tests/ui/needless_return.rs
index 34811db7413..cbf384ac9e4 100644
--- a/tests/ui/needless_return.rs
+++ b/tests/ui/needless_return.rs
@@ -1,13 +1,9 @@
 // run-rustfix
 // edition:2018
 
+#![feature(let_else)]
 #![allow(unused)]
-#![allow(
-    clippy::if_same_then_else,
-    clippy::single_match,
-    clippy::branches_sharing_code,
-    clippy::needless_bool
-)]
+#![allow(clippy::if_same_then_else, clippy::single_match, clippy::needless_bool)]
 #![warn(clippy::needless_return)]
 
 macro_rules! the_answer {
@@ -207,4 +203,8 @@ async fn async_test_return_in_macro() {
     needed_return!(0);
 }
 
+fn let_else() {
+    let Some(1) = Some(1) else { return };
+}
+
 fn main() {}
diff --git a/tests/ui/needless_return.stderr b/tests/ui/needless_return.stderr
index 74dda971fda..7ce7028bbae 100644
--- a/tests/ui/needless_return.stderr
+++ b/tests/ui/needless_return.stderr
@@ -1,5 +1,5 @@
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:24:5
+  --> $DIR/needless_return.rs:20:5
    |
 LL |     return true;
    |     ^^^^^^^^^^^^ help: remove `return`: `true`
@@ -7,187 +7,187 @@ LL |     return true;
    = note: `-D clippy::needless-return` implied by `-D warnings`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:28:5
+  --> $DIR/needless_return.rs:24:5
    |
 LL |     return true;
    |     ^^^^^^^^^^^^ help: remove `return`: `true`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:33:9
+  --> $DIR/needless_return.rs:29:9
    |
 LL |         return true;
    |         ^^^^^^^^^^^^ help: remove `return`: `true`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:35:9
+  --> $DIR/needless_return.rs:31:9
    |
 LL |         return false;
    |         ^^^^^^^^^^^^^ help: remove `return`: `false`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:41:17
+  --> $DIR/needless_return.rs:37:17
    |
 LL |         true => return false,
    |                 ^^^^^^^^^^^^ help: remove `return`: `false`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:43:13
+  --> $DIR/needless_return.rs:39:13
    |
 LL |             return true;
    |             ^^^^^^^^^^^^ help: remove `return`: `true`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:50:9
+  --> $DIR/needless_return.rs:46:9
    |
 LL |         return true;
    |         ^^^^^^^^^^^^ help: remove `return`: `true`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:52:16
+  --> $DIR/needless_return.rs:48:16
    |
 LL |     let _ = || return true;
    |                ^^^^^^^^^^^ help: remove `return`: `true`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:60:5
+  --> $DIR/needless_return.rs:56:5
    |
 LL |     return;
    |     ^^^^^^^ help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:65:9
+  --> $DIR/needless_return.rs:61:9
    |
 LL |         return;
    |         ^^^^^^^ help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:67:9
+  --> $DIR/needless_return.rs:63:9
    |
 LL |         return;
    |         ^^^^^^^ help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:74:14
+  --> $DIR/needless_return.rs:70:14
    |
 LL |         _ => return,
    |              ^^^^^^ help: replace `return` with an empty block: `{}`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:89:9
+  --> $DIR/needless_return.rs:85:9
    |
 LL |         return String::from("test");
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove `return`: `String::from("test")`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:91:9
+  --> $DIR/needless_return.rs:87:9
    |
 LL |         return String::new();
    |         ^^^^^^^^^^^^^^^^^^^^^ help: remove `return`: `String::new()`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:112:32
+  --> $DIR/needless_return.rs:108:32
    |
 LL |         bar.unwrap_or_else(|_| return)
    |                                ^^^^^^ help: replace `return` with an empty block: `{}`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:117:13
+  --> $DIR/needless_return.rs:113:13
    |
 LL |             return;
    |             ^^^^^^^ help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:119:20
+  --> $DIR/needless_return.rs:115:20
    |
 LL |         let _ = || return;
    |                    ^^^^^^ help: replace `return` with an empty block: `{}`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:125:32
+  --> $DIR/needless_return.rs:121:32
    |
 LL |         res.unwrap_or_else(|_| return Foo)
    |                                ^^^^^^^^^^ help: remove `return`: `Foo`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:134:5
+  --> $DIR/needless_return.rs:130:5
    |
 LL |     return true;
    |     ^^^^^^^^^^^^ help: remove `return`: `true`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:138:5
+  --> $DIR/needless_return.rs:134:5
    |
 LL |     return true;
    |     ^^^^^^^^^^^^ help: remove `return`: `true`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:143:9
+  --> $DIR/needless_return.rs:139:9
    |
 LL |         return true;
    |         ^^^^^^^^^^^^ help: remove `return`: `true`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:145:9
+  --> $DIR/needless_return.rs:141:9
    |
 LL |         return false;
    |         ^^^^^^^^^^^^^ help: remove `return`: `false`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:151:17
+  --> $DIR/needless_return.rs:147:17
    |
 LL |         true => return false,
    |                 ^^^^^^^^^^^^ help: remove `return`: `false`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:153:13
+  --> $DIR/needless_return.rs:149:13
    |
 LL |             return true;
    |             ^^^^^^^^^^^^ help: remove `return`: `true`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:160:9
+  --> $DIR/needless_return.rs:156:9
    |
 LL |         return true;
    |         ^^^^^^^^^^^^ help: remove `return`: `true`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:162:16
+  --> $DIR/needless_return.rs:158:16
    |
 LL |     let _ = || return true;
    |                ^^^^^^^^^^^ help: remove `return`: `true`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:170:5
+  --> $DIR/needless_return.rs:166:5
    |
 LL |     return;
    |     ^^^^^^^ help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:175:9
+  --> $DIR/needless_return.rs:171:9
    |
 LL |         return;
    |         ^^^^^^^ help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:177:9
+  --> $DIR/needless_return.rs:173:9
    |
 LL |         return;
    |         ^^^^^^^ help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:184:14
+  --> $DIR/needless_return.rs:180:14
    |
 LL |         _ => return,
    |              ^^^^^^ help: replace `return` with an empty block: `{}`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:199:9
+  --> $DIR/needless_return.rs:195:9
    |
 LL |         return String::from("test");
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove `return`: `String::from("test")`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:201:9
+  --> $DIR/needless_return.rs:197:9
    |
 LL |         return String::new();
    |         ^^^^^^^^^^^^^^^^^^^^^ help: remove `return`: `String::new()`
-- 
cgit 1.4.1-3-g733a5


From 63ed2f9eb4a787abdd8c50773f3ef9cc8a5cb724 Mon Sep 17 00:00:00 2001
From: F3real <stefan92ff@yandex.com>
Date: Sat, 18 Sep 2021 00:56:14 +0200
Subject: Expand BOX_VEC to BOX_COLLECTION

---
 CHANGELOG.md                             |  2 +-
 clippy_lints/src/lib.rs                  |  6 ++--
 clippy_lints/src/types/box_collection.rs | 50 ++++++++++++++++++++++++++++++++
 clippy_lints/src/types/box_vec.rs        | 25 ----------------
 clippy_lints/src/types/mod.rs            | 14 ++++-----
 clippy_lints/src/utils/conf.rs           |  2 +-
 tests/ui/box_collection.rs               | 44 ++++++++++++++++++++++++++++
 tests/ui/box_collection.stderr           | 27 +++++++++++++++++
 tests/ui/box_vec.rs                      | 36 -----------------------
 tests/ui/box_vec.stderr                  | 11 -------
 10 files changed, 133 insertions(+), 84 deletions(-)
 create mode 100644 clippy_lints/src/types/box_collection.rs
 delete mode 100644 clippy_lints/src/types/box_vec.rs
 create mode 100644 tests/ui/box_collection.rs
 create mode 100644 tests/ui/box_collection.stderr
 delete mode 100644 tests/ui/box_vec.rs
 delete mode 100644 tests/ui/box_vec.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 72fe6ae3173..eff73d1fae8 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2570,7 +2570,7 @@ Released 2018-09-13
 [`bool_comparison`]: https://rust-lang.github.io/rust-clippy/master/index.html#bool_comparison
 [`borrow_interior_mutable_const`]: https://rust-lang.github.io/rust-clippy/master/index.html#borrow_interior_mutable_const
 [`borrowed_box`]: https://rust-lang.github.io/rust-clippy/master/index.html#borrowed_box
-[`box_vec`]: https://rust-lang.github.io/rust-clippy/master/index.html#box_vec
+[`box_collection`]: https://rust-lang.github.io/rust-clippy/master/index.html#box_collection
 [`boxed_local`]: https://rust-lang.github.io/rust-clippy/master/index.html#boxed_local
 [`branches_sharing_code`]: https://rust-lang.github.io/rust-clippy/master/index.html#branches_sharing_code
 [`builtin_type_shadow`]: https://rust-lang.github.io/rust-clippy/master/index.html#builtin_type_shadow
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 59d87aa96dc..fdbaccef53b 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -956,7 +956,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         transmuting_null::TRANSMUTING_NULL,
         try_err::TRY_ERR,
         types::BORROWED_BOX,
-        types::BOX_VEC,
+        types::BOX_COLLECTION,
         types::LINKEDLIST,
         types::OPTION_OPTION,
         types::RC_BUFFER,
@@ -1454,7 +1454,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(transmuting_null::TRANSMUTING_NULL),
         LintId::of(try_err::TRY_ERR),
         LintId::of(types::BORROWED_BOX),
-        LintId::of(types::BOX_VEC),
+        LintId::of(types::BOX_COLLECTION),
         LintId::of(types::REDUNDANT_ALLOCATION),
         LintId::of(types::TYPE_COMPLEXITY),
         LintId::of(types::VEC_BOX),
@@ -1792,7 +1792,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(redundant_clone::REDUNDANT_CLONE),
         LintId::of(slow_vector_initialization::SLOW_VECTOR_INITIALIZATION),
         LintId::of(stable_sort_primitive::STABLE_SORT_PRIMITIVE),
-        LintId::of(types::BOX_VEC),
+        LintId::of(types::BOX_COLLECTION),
         LintId::of(types::REDUNDANT_ALLOCATION),
         LintId::of(vec::USELESS_VEC),
         LintId::of(vec_init_then_push::VEC_INIT_THEN_PUSH),
diff --git a/clippy_lints/src/types/box_collection.rs b/clippy_lints/src/types/box_collection.rs
new file mode 100644
index 00000000000..718aea471d9
--- /dev/null
+++ b/clippy_lints/src/types/box_collection.rs
@@ -0,0 +1,50 @@
+use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::is_ty_param_diagnostic_item;
+use rustc_hir::{self as hir, def_id::DefId, QPath};
+use rustc_lint::LateContext;
+use rustc_span::symbol::sym;
+
+use super::BOX_COLLECTION;
+
+pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_>, def_id: DefId) -> bool {
+    if_chain! {
+        if Some(def_id) == cx.tcx.lang_items().owned_box();
+        if let Some(item_type) = get_std_collection(cx, qpath);
+        then {
+            let generic = if item_type == "String" {
+                ""
+            } else {
+                "<..>"
+            };
+            span_lint_and_help(
+                cx,
+                BOX_COLLECTION,
+                hir_ty.span,
+                &format!(
+                    "you seem to be trying to use `Box<{outer}{generic}>`. Consider using just `{outer}{generic}`",
+                    outer=item_type,
+                    generic = generic),
+                None,
+                &format!(
+                    "`{outer}{generic}` is already on the heap, `Box<{outer}{generic}>` makes an extra allocation",
+                    outer=item_type,
+                    generic = generic)
+            );
+            true
+        } else {
+            false
+        }
+    }
+}
+
+fn get_std_collection(cx: &LateContext<'_>, qpath: &QPath<'_>) -> Option<String> {
+    if is_ty_param_diagnostic_item(cx, qpath, sym::vec_type).is_some() {
+        Some(String::from("Vec"))
+    } else if is_ty_param_diagnostic_item(cx, qpath, sym::string_type).is_some() {
+        Some(String::from("String"))
+    } else if is_ty_param_diagnostic_item(cx, qpath, sym::hashmap_type).is_some() {
+        Some(String::from("HashMap"))
+    } else {
+        None
+    }
+}
diff --git a/clippy_lints/src/types/box_vec.rs b/clippy_lints/src/types/box_vec.rs
deleted file mode 100644
index d8b1953457c..00000000000
--- a/clippy_lints/src/types/box_vec.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-use clippy_utils::diagnostics::span_lint_and_help;
-use clippy_utils::is_ty_param_diagnostic_item;
-use rustc_hir::{self as hir, def_id::DefId, QPath};
-use rustc_lint::LateContext;
-use rustc_span::symbol::sym;
-
-use super::BOX_VEC;
-
-pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_>, def_id: DefId) -> bool {
-    if Some(def_id) == cx.tcx.lang_items().owned_box()
-        && is_ty_param_diagnostic_item(cx, qpath, sym::vec_type).is_some()
-    {
-        span_lint_and_help(
-            cx,
-            BOX_VEC,
-            hir_ty.span,
-            "you seem to be trying to use `Box<Vec<T>>`. Consider using just `Vec<T>`",
-            None,
-            "`Vec<T>` is already on the heap, `Box<Vec<T>>` makes an extra allocation",
-        );
-        true
-    } else {
-        false
-    }
-}
diff --git a/clippy_lints/src/types/mod.rs b/clippy_lints/src/types/mod.rs
index 9588de8459c..bbe07db5358 100644
--- a/clippy_lints/src/types/mod.rs
+++ b/clippy_lints/src/types/mod.rs
@@ -1,5 +1,5 @@
 mod borrowed_box;
-mod box_vec;
+mod box_collection;
 mod linked_list;
 mod option_option;
 mod rc_buffer;
@@ -21,12 +21,12 @@ use rustc_span::source_map::Span;
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for use of `Box<Vec<_>>` anywhere in the code.
+    /// Checks for use of `Box<T>` where T is a collection such as Vec anywhere in the code.
     /// Check the [Box documentation](https://doc.rust-lang.org/std/boxed/index.html) for more information.
     ///
     /// ### Why is this bad?
-    /// `Vec` already keeps its contents in a separate area on
-    /// the heap. So if you `Box` it, you just add another level of indirection
+    /// Collections already keeps their contents in a separate area on
+    /// the heap. So if you `Box` them, you just add another level of indirection
     /// without any benefit whatsoever.
     ///
     /// ### Example
@@ -43,7 +43,7 @@ declare_clippy_lint! {
     ///     values: Vec<Foo>,
     /// }
     /// ```
-    pub BOX_VEC,
+    pub BOX_COLLECTION,
     perf,
     "usage of `Box<Vec<T>>`, vector elements are already on the heap"
 }
@@ -298,7 +298,7 @@ pub struct Types {
     avoid_breaking_exported_api: bool,
 }
 
-impl_lint_pass!(Types => [BOX_VEC, VEC_BOX, OPTION_OPTION, LINKEDLIST, BORROWED_BOX, REDUNDANT_ALLOCATION, RC_BUFFER, RC_MUTEX, TYPE_COMPLEXITY]);
+impl_lint_pass!(Types => [BOX_COLLECTION, VEC_BOX, OPTION_OPTION, LINKEDLIST, BORROWED_BOX, REDUNDANT_ALLOCATION, RC_BUFFER, RC_MUTEX, TYPE_COMPLEXITY]);
 
 impl<'tcx> LateLintPass<'tcx> for Types {
     fn check_fn(&mut self, cx: &LateContext<'_>, _: FnKind<'_>, decl: &FnDecl<'_>, _: &Body<'_>, _: Span, id: HirId) {
@@ -447,7 +447,7 @@ impl Types {
                         // in `clippy_lints::utils::conf.rs`
 
                         let mut triggered = false;
-                        triggered |= box_vec::check(cx, hir_ty, qpath, def_id);
+                        triggered |= box_collection::check(cx, hir_ty, qpath, def_id);
                         triggered |= redundant_allocation::check(cx, hir_ty, qpath, def_id);
                         triggered |= rc_buffer::check(cx, hir_ty, qpath, def_id);
                         triggered |= vec_box::check(cx, hir_ty, qpath, def_id, self.vec_box_size_threshold);
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 8b087507b11..1e0447239be 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -136,7 +136,7 @@ macro_rules! define_Conf {
 }
 
 define_Conf! {
-    /// Lint: ENUM_VARIANT_NAMES, LARGE_TYPES_PASSED_BY_VALUE, TRIVIALLY_COPY_PASS_BY_REF, UNNECESSARY_WRAPS, UPPER_CASE_ACRONYMS, WRONG_SELF_CONVENTION, BOX_VEC, REDUNDANT_ALLOCATION, RC_BUFFER, VEC_BOX, OPTION_OPTION, LINKEDLIST, RC_MUTEX.
+    /// Lint: ENUM_VARIANT_NAMES, LARGE_TYPES_PASSED_BY_VALUE, TRIVIALLY_COPY_PASS_BY_REF, UNNECESSARY_WRAPS, UPPER_CASE_ACRONYMS, WRONG_SELF_CONVENTION, BOX_COLLECTION, REDUNDANT_ALLOCATION, RC_BUFFER, VEC_BOX, OPTION_OPTION, LINKEDLIST, RC_MUTEX.
     ///
     /// Suppress lints whenever the suggested change would cause breakage for other crates.
     (avoid_breaking_exported_api: bool = true),
diff --git a/tests/ui/box_collection.rs b/tests/ui/box_collection.rs
new file mode 100644
index 00000000000..e00f061f28a
--- /dev/null
+++ b/tests/ui/box_collection.rs
@@ -0,0 +1,44 @@
+#![warn(clippy::all)]
+#![allow(
+    clippy::boxed_local,
+    clippy::needless_pass_by_value,
+    clippy::blacklisted_name,
+    unused
+)]
+
+use std::collections::HashMap;
+
+macro_rules! boxit {
+    ($init:expr, $x:ty) => {
+        let _: Box<$x> = Box::new($init);
+    };
+}
+
+fn test_macro() {
+    boxit!(Vec::new(), Vec<u8>);
+}
+
+fn test(foo: Box<Vec<bool>>) {}
+
+fn test2(foo: Box<dyn Fn(Vec<u32>)>) {
+    // pass if #31 is fixed
+    foo(vec![1, 2, 3])
+}
+
+fn test3(foo: Box<String>) {}
+
+fn test4(foo: Box<HashMap<String, String>>) {}
+
+fn test_local_not_linted() {
+    let _: Box<Vec<bool>>;
+}
+
+// All of these test should be allowed because they are part of the
+// public api and `avoid_breaking_exported_api` is `false` by default.
+pub fn pub_test(foo: Box<Vec<bool>>) {}
+
+pub fn pub_test_ret() -> Box<Vec<bool>> {
+    Box::new(Vec::new())
+}
+
+fn main() {}
diff --git a/tests/ui/box_collection.stderr b/tests/ui/box_collection.stderr
new file mode 100644
index 00000000000..6de85d05a99
--- /dev/null
+++ b/tests/ui/box_collection.stderr
@@ -0,0 +1,27 @@
+error: you seem to be trying to use `Box<Vec<..>>`. Consider using just `Vec<..>`
+  --> $DIR/box_collection.rs:21:14
+   |
+LL | fn test(foo: Box<Vec<bool>>) {}
+   |              ^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::box-collection` implied by `-D warnings`
+   = help: `Vec<..>` is already on the heap, `Box<Vec<..>>` makes an extra allocation
+
+error: you seem to be trying to use `Box<String>`. Consider using just `String`
+  --> $DIR/box_collection.rs:28:15
+   |
+LL | fn test3(foo: Box<String>) {}
+   |               ^^^^^^^^^^^
+   |
+   = help: `String` is already on the heap, `Box<String>` makes an extra allocation
+
+error: you seem to be trying to use `Box<HashMap<..>>`. Consider using just `HashMap<..>`
+  --> $DIR/box_collection.rs:30:15
+   |
+LL | fn test4(foo: Box<HashMap<String, String>>) {}
+   |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: `HashMap<..>` is already on the heap, `Box<HashMap<..>>` makes an extra allocation
+
+error: aborting due to 3 previous errors
+
diff --git a/tests/ui/box_vec.rs b/tests/ui/box_vec.rs
deleted file mode 100644
index 1d6366972da..00000000000
--- a/tests/ui/box_vec.rs
+++ /dev/null
@@ -1,36 +0,0 @@
-#![warn(clippy::all)]
-#![allow(
-    clippy::boxed_local,
-    clippy::needless_pass_by_value,
-    clippy::blacklisted_name,
-    unused
-)]
-
-macro_rules! boxit {
-    ($init:expr, $x:ty) => {
-        let _: Box<$x> = Box::new($init);
-    };
-}
-
-fn test_macro() {
-    boxit!(Vec::new(), Vec<u8>);
-}
-fn test(foo: Box<Vec<bool>>) {}
-
-fn test2(foo: Box<dyn Fn(Vec<u32>)>) {
-    // pass if #31 is fixed
-    foo(vec![1, 2, 3])
-}
-
-fn test_local_not_linted() {
-    let _: Box<Vec<bool>>;
-}
-
-// All of these test should be allowed because they are part of the
-// public api and `avoid_breaking_exported_api` is `false` by default.
-pub fn pub_test(foo: Box<Vec<bool>>) {}
-pub fn pub_test_ret() -> Box<Vec<bool>> {
-    Box::new(Vec::new())
-}
-
-fn main() {}
diff --git a/tests/ui/box_vec.stderr b/tests/ui/box_vec.stderr
deleted file mode 100644
index 58c1f13fb87..00000000000
--- a/tests/ui/box_vec.stderr
+++ /dev/null
@@ -1,11 +0,0 @@
-error: you seem to be trying to use `Box<Vec<T>>`. Consider using just `Vec<T>`
-  --> $DIR/box_vec.rs:18:14
-   |
-LL | fn test(foo: Box<Vec<bool>>) {}
-   |              ^^^^^^^^^^^^^^
-   |
-   = note: `-D clippy::box-vec` implied by `-D warnings`
-   = help: `Vec<T>` is already on the heap, `Box<Vec<T>>` makes an extra allocation
-
-error: aborting due to previous error
-
-- 
cgit 1.4.1-3-g733a5


From 7f96b358b0e5a7c8ed03330b469c716fdd1a89b3 Mon Sep 17 00:00:00 2001
From: F3real <stefan92ff@yandex.com>
Date: Mon, 20 Sep 2021 23:07:17 +0200
Subject: Register lint rename

---
 clippy_lints/src/lib.rs | 1 +
 1 file changed, 1 insertion(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index fdbaccef53b..c7e59cb1683 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -2193,6 +2193,7 @@ pub fn register_renamed(ls: &mut rustc_lint::LintStore) {
     ls.register_renamed("clippy::cyclomatic_complexity", "clippy::cognitive_complexity");
     ls.register_renamed("clippy::const_static_lifetime", "clippy::redundant_static_lifetimes");
     ls.register_renamed("clippy::option_and_then_some", "clippy::bind_instead_of_map");
+    ls.register_renamed("clippy::box_vec", "clippy::box_collection");
     ls.register_renamed("clippy::block_in_if_condition_expr", "clippy::blocks_in_if_conditions");
     ls.register_renamed("clippy::block_in_if_condition_stmt", "clippy::blocks_in_if_conditions");
     ls.register_renamed("clippy::option_map_unwrap_or", "clippy::map_unwrap_or");
-- 
cgit 1.4.1-3-g733a5


From 3ad3c51cee1d36d01fd145d6a45e33cff2bc12a1 Mon Sep 17 00:00:00 2001
From: Jubilee Young <workingjubilee@gmail.com>
Date: Sun, 19 Sep 2021 16:10:29 -0700
Subject: Demote float_cmp to pedantic

---
 clippy_lints/src/lib.rs  | 3 +--
 clippy_lints/src/misc.rs | 2 +-
 2 files changed, 2 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 59d87aa96dc..8a73824ce4c 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1132,6 +1132,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(methods::INEFFICIENT_TO_STRING),
         LintId::of(methods::MAP_FLATTEN),
         LintId::of(methods::MAP_UNWRAP_OR),
+        LintId::of(misc::FLOAT_CMP),
         LintId::of(misc::USED_UNDERSCORE_BINDING),
         LintId::of(misc_early::UNSEPARATED_LITERAL_SUFFIX),
         LintId::of(mut_mut::MUT_MUT),
@@ -1365,7 +1366,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(minmax::MIN_MAX),
         LintId::of(misc::CMP_NAN),
         LintId::of(misc::CMP_OWNED),
-        LintId::of(misc::FLOAT_CMP),
         LintId::of(misc::MODULO_ONE),
         LintId::of(misc::SHORT_CIRCUIT_STATEMENT),
         LintId::of(misc::TOPLEVEL_REF_ARG),
@@ -1729,7 +1729,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(methods::ZST_OFFSET),
         LintId::of(minmax::MIN_MAX),
         LintId::of(misc::CMP_NAN),
-        LintId::of(misc::FLOAT_CMP),
         LintId::of(misc::MODULO_ONE),
         LintId::of(non_octal_unix_permissions::NON_OCTAL_UNIX_PERMISSIONS),
         LintId::of(open_options::NONSENSICAL_OPEN_OPTIONS),
diff --git a/clippy_lints/src/misc.rs b/clippy_lints/src/misc.rs
index 538fa4e1678..0f32cd9164e 100644
--- a/clippy_lints/src/misc.rs
+++ b/clippy_lints/src/misc.rs
@@ -113,7 +113,7 @@ declare_clippy_lint! {
     /// if (y - x).abs() > error_margin { }
     /// ```
     pub FLOAT_CMP,
-    correctness,
+    pedantic,
     "using `==` or `!=` on float values instead of comparing difference with an epsilon"
 }
 
-- 
cgit 1.4.1-3-g733a5


From b68325ecf6dfd87d2dda5c6b3f3d3b0bcc315d3e Mon Sep 17 00:00:00 2001
From: lengyijun <sjtu5140809011@gmail.com>
Date: Fri, 17 Sep 2021 11:48:21 +0800
Subject: add #4546 test

---
 clippy_lints/src/methods/mod.rs    |  2 ++
 tests/ui/wrong_self_convention2.rs | 18 ++++++++++++++++++
 2 files changed, 20 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index e89b2d295b9..486208f0fad 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -264,6 +264,8 @@ declare_clippy_lint! {
     /// The method signature is controlled by the trait and often `&self` is required for all types that implement the trait
     /// (see e.g. the `std::string::ToString` trait).
     ///
+    /// Clippy allows `Pin<&Self>` and `Pin<&mut Self>` if `&self` and `&mut self` is required.
+    ///
     /// Please find more info here:
     /// https://rust-lang.github.io/api-guidelines/naming.html#ad-hoc-conversions-follow-as_-to_-into_-conventions-c-conv
     ///
diff --git a/tests/ui/wrong_self_convention2.rs b/tests/ui/wrong_self_convention2.rs
index dd3e842c925..0d827c1feb3 100644
--- a/tests/ui/wrong_self_convention2.rs
+++ b/tests/ui/wrong_self_convention2.rs
@@ -87,3 +87,21 @@ mod issue3414 {
         }
     }
 }
+
+// don't trigger
+mod issue4546 {
+    use std::pin::Pin;
+
+    struct S;
+    impl S {
+        pub fn as_mut(self: Pin<&mut Self>) {}
+
+        pub fn as_other_thingy(self: Pin<&Self>) {}
+
+        pub fn is_other_thingy(self: Pin<&Self>) {}
+
+        pub fn to_mut(self: Pin<&mut Self>) {}
+
+        pub fn to_other_thingy(self: Pin<&Self>) {}
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 5efd6bc6c3781f28f762fdf781d49e3db7fcc9d3 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Thu, 23 Sep 2021 00:22:27 -0400
Subject: Don't lint `suspicious_else_formatting` inside proc-macros

---
 clippy_lints/src/formatting.rs | 57 +++++++++++++++++++++++-------------------
 1 file changed, 31 insertions(+), 26 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/formatting.rs b/clippy_lints/src/formatting.rs
index 4dd0ffe77ea..b4f186525c5 100644
--- a/clippy_lints/src/formatting.rs
+++ b/clippy_lints/src/formatting.rs
@@ -286,34 +286,39 @@ fn check_array(cx: &EarlyContext<'_>, expr: &Expr) {
 }
 
 fn check_missing_else(cx: &EarlyContext<'_>, first: &Expr, second: &Expr) {
-    if !differing_macro_contexts(first.span, second.span)
-        && !first.span.from_expansion()
-        && is_if(first)
-        && (is_block(second) || is_if(second))
-    {
-        // where the else would be
-        let else_span = first.span.between(second.span);
+    if_chain! {
+        if !differing_macro_contexts(first.span, second.span);
+        if !first.span.from_expansion();
+        if let ExprKind::If(cond_expr, ..) = &first.kind;
+        if is_block(second) || is_if(second);
 
-        if let Some(else_snippet) = snippet_opt(cx, else_span) {
-            if !else_snippet.contains('\n') {
-                let (looks_like, next_thing) = if is_if(second) {
-                    ("an `else if`", "the second `if`")
-                } else {
-                    ("an `else {..}`", "the next block")
-                };
+        // Proc-macros can give weird spans. Make sure this is actually an `if`.
+        if let Some(if_snip) = snippet_opt(cx, first.span.until(cond_expr.span));
+        if if_snip.starts_with("if");
 
-                span_lint_and_note(
-                    cx,
-                    SUSPICIOUS_ELSE_FORMATTING,
-                    else_span,
-                    &format!("this looks like {} but the `else` is missing", looks_like),
-                    None,
-                    &format!(
-                        "to remove this lint, add the missing `else` or add a new line before {}",
-                        next_thing,
-                    ),
-                );
-            }
+        // If there is a line break between the two expressions, don't lint.
+        // If there is a non-whitespace character, this span came from a proc-macro.
+        let else_span = first.span.between(second.span);
+        if let Some(else_snippet) = snippet_opt(cx, else_span);
+        if !else_snippet.chars().any(|c| c == '\n' || !c.is_whitespace());
+        then {
+            let (looks_like, next_thing) = if is_if(second) {
+                ("an `else if`", "the second `if`")
+            } else {
+                ("an `else {..}`", "the next block")
+            };
+
+            span_lint_and_note(
+                cx,
+                SUSPICIOUS_ELSE_FORMATTING,
+                else_span,
+                &format!("this looks like {} but the `else` is missing", looks_like),
+                None,
+                &format!(
+                    "to remove this lint, add the missing `else` or add a new line before {}",
+                    next_thing,
+                ),
+            );
         }
     }
 }
-- 
cgit 1.4.1-3-g733a5


From 7a4a556100dc6c060c9c2f464740c2f3286d30fb Mon Sep 17 00:00:00 2001
From: F3real <stefan92ff@yandex.com>
Date: Fri, 24 Sep 2021 11:02:16 +0200
Subject: Avoid needless heap allocation in box_collection

---
 clippy_lints/src/types/box_collection.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types/box_collection.rs b/clippy_lints/src/types/box_collection.rs
index 718aea471d9..b28da29c91c 100644
--- a/clippy_lints/src/types/box_collection.rs
+++ b/clippy_lints/src/types/box_collection.rs
@@ -37,13 +37,13 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_
     }
 }
 
-fn get_std_collection(cx: &LateContext<'_>, qpath: &QPath<'_>) -> Option<String> {
+fn get_std_collection(cx: &LateContext<'_>, qpath: &QPath<'_>) -> Option<&'static str> {
     if is_ty_param_diagnostic_item(cx, qpath, sym::vec_type).is_some() {
-        Some(String::from("Vec"))
+        Some("Vec")
     } else if is_ty_param_diagnostic_item(cx, qpath, sym::string_type).is_some() {
-        Some(String::from("String"))
+        Some("String")
     } else if is_ty_param_diagnostic_item(cx, qpath, sym::hashmap_type).is_some() {
-        Some(String::from("HashMap"))
+        Some("HashMap")
     } else {
         None
     }
-- 
cgit 1.4.1-3-g733a5


From 543b638dbe4b559e660c76128eb326533f7ea370 Mon Sep 17 00:00:00 2001
From: Labelray <labelray@icloud.com>
Date: Tue, 14 Sep 2021 16:28:09 +0800
Subject: Add new lint `if_then_panic`

---
 CHANGELOG.md                             |  1 +
 clippy_lints/src/if_then_panic.rs        | 97 ++++++++++++++++++++++++++++++++
 clippy_lints/src/lib.rs                  |  5 ++
 clippy_lints/src/utils/internal_lints.rs |  4 +-
 clippy_utils/src/higher.rs               | 30 ++++++++++
 tests/compile-test.rs                    |  8 ++-
 tests/integration.rs                     |  7 ++-
 tests/ui/fallible_impl_from.rs           |  1 +
 tests/ui/fallible_impl_from.stderr       | 16 +++---
 tests/ui/if_then_panic.fixed             | 34 +++++++++++
 tests/ui/if_then_panic.rs                | 38 +++++++++++++
 tests/ui/if_then_panic.stderr            | 20 +++++++
 tests/ui/ptr_arg.rs                      |  7 ++-
 tests/ui/ptr_arg.stderr                  | 24 ++++----
 14 files changed, 263 insertions(+), 29 deletions(-)
 create mode 100644 clippy_lints/src/if_then_panic.rs
 create mode 100644 tests/ui/if_then_panic.fixed
 create mode 100644 tests/ui/if_then_panic.rs
 create mode 100644 tests/ui/if_then_panic.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 59a3dc651bc..040c906a722 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2688,6 +2688,7 @@ Released 2018-09-13
 [`if_let_some_result`]: https://rust-lang.github.io/rust-clippy/master/index.html#if_let_some_result
 [`if_not_else`]: https://rust-lang.github.io/rust-clippy/master/index.html#if_not_else
 [`if_same_then_else`]: https://rust-lang.github.io/rust-clippy/master/index.html#if_same_then_else
+[`if_then_panic`]: https://rust-lang.github.io/rust-clippy/master/index.html#if_then_panic
 [`if_then_some_else_none`]: https://rust-lang.github.io/rust-clippy/master/index.html#if_then_some_else_none
 [`ifs_same_cond`]: https://rust-lang.github.io/rust-clippy/master/index.html#ifs_same_cond
 [`implicit_clone`]: https://rust-lang.github.io/rust-clippy/master/index.html#implicit_clone
diff --git a/clippy_lints/src/if_then_panic.rs b/clippy_lints/src/if_then_panic.rs
new file mode 100644
index 00000000000..ee575c81a8b
--- /dev/null
+++ b/clippy_lints/src/if_then_panic.rs
@@ -0,0 +1,97 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::higher::PanicExpn;
+use clippy_utils::is_expn_of;
+use clippy_utils::source::snippet_with_applicability;
+use rustc_errors::Applicability;
+use rustc_hir::{Block, Expr, ExprKind, StmtKind, UnOp};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Detects `if`-then-`panic!` that can be replaced with `assert!`.
+    ///
+    /// ### Why is this bad?
+    /// `assert!` is simpler than `if`-then-`panic!`.
+    ///
+    /// ### Example
+    /// ```rust
+    /// let sad_people: Vec<&str> = vec![];
+    /// if !sad_people.is_empty() {
+    ///     panic!("there are sad people: {:?}", sad_people);
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// let sad_people: Vec<&str> = vec![];
+    /// assert!(sad_people.is_empty(), "there are sad people: {:?}", sad_people);
+    /// ```
+    pub IF_THEN_PANIC,
+    style,
+    "`panic!` and only a `panic!` in `if`-then statement"
+}
+
+declare_lint_pass!(IfThenPanic => [IF_THEN_PANIC]);
+
+impl LateLintPass<'_> for IfThenPanic {
+    fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
+        if_chain! {
+            if let Expr {
+                kind: ExprKind:: If(cond, Expr {
+                    kind: ExprKind::Block(
+                        Block {
+                            stmts: [stmt],
+                            ..
+                        },
+                        _),
+                    ..
+                }, None),
+                ..
+            } = &expr;
+            if is_expn_of(stmt.span, "panic").is_some();
+            if !matches!(cond.kind, ExprKind::Let(_, _, _));
+            if let StmtKind::Semi(semi) = stmt.kind;
+            if !cx.tcx.sess.source_map().is_multiline(cond.span);
+
+            then {
+                let span = if let Some(panic_expn) = PanicExpn::parse(semi) {
+                    match *panic_expn.format_args.value_args {
+                        [] => panic_expn.format_args.format_string_span,
+                        [.., last] => panic_expn.format_args.format_string_span.to(last.span),
+                    }
+                } else {
+                    if_chain! {
+                        if let ExprKind::Block(block, _) = semi.kind;
+                        if let Some(init) = block.expr;
+                        if let ExprKind::Call(_, [format_args]) = init.kind;
+
+                        then {
+                            format_args.span
+                        } else {
+                            return
+                        }
+                    }
+                };
+                let mut applicability = Applicability::MachineApplicable;
+                let sugg = snippet_with_applicability(cx, span, "..", &mut applicability);
+
+                let cond_sugg =
+                if let ExprKind::DropTemps(Expr{kind: ExprKind::Unary(UnOp::Not, not_expr), ..}) = cond.kind {
+                    snippet_with_applicability(cx, not_expr.span, "..", &mut applicability).to_string()
+                } else {
+                    format!("!{}", snippet_with_applicability(cx, cond.span, "..", &mut applicability))
+                };
+
+                span_lint_and_sugg(
+                    cx,
+                    IF_THEN_PANIC,
+                    expr.span,
+                    "only a `panic!` in `if`-then statement",
+                    "try",
+                    format!("assert!({}, {});", cond_sugg, sugg),
+                    Applicability::MachineApplicable,
+                );
+            }
+        }
+    }
+}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index c7e59cb1683..1a69cf0dc88 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -227,6 +227,7 @@ mod identity_op;
 mod if_let_mutex;
 mod if_let_some_result;
 mod if_not_else;
+mod if_then_panic;
 mod if_then_some_else_none;
 mod implicit_hasher;
 mod implicit_return;
@@ -659,6 +660,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         if_let_mutex::IF_LET_MUTEX,
         if_let_some_result::IF_LET_SOME_RESULT,
         if_not_else::IF_NOT_ELSE,
+        if_then_panic::IF_THEN_PANIC,
         if_then_some_else_none::IF_THEN_SOME_ELSE_NONE,
         implicit_hasher::IMPLICIT_HASHER,
         implicit_return::IMPLICIT_RETURN,
@@ -1257,6 +1259,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(identity_op::IDENTITY_OP),
         LintId::of(if_let_mutex::IF_LET_MUTEX),
         LintId::of(if_let_some_result::IF_LET_SOME_RESULT),
+        LintId::of(if_then_panic::IF_THEN_PANIC),
         LintId::of(indexing_slicing::OUT_OF_BOUNDS_INDEXING),
         LintId::of(infinite_iter::INFINITE_ITER),
         LintId::of(inherent_to_string::INHERENT_TO_STRING),
@@ -1511,6 +1514,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(functions::MUST_USE_UNIT),
         LintId::of(functions::RESULT_UNIT_ERR),
         LintId::of(if_let_some_result::IF_LET_SOME_RESULT),
+        LintId::of(if_then_panic::IF_THEN_PANIC),
         LintId::of(inherent_to_string::INHERENT_TO_STRING),
         LintId::of(len_zero::COMPARISON_TO_EMPTY),
         LintId::of(len_zero::LEN_WITHOUT_IS_EMPTY),
@@ -2138,6 +2142,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(move || Box::new(self_named_constructors::SelfNamedConstructors));
     store.register_late_pass(move || Box::new(feature_name::FeatureName));
     store.register_late_pass(move || Box::new(iter_not_returning_iterator::IterNotReturningIterator));
+    store.register_late_pass(move || Box::new(if_then_panic::IfThenPanic));
 }
 
 #[rustfmt::skip]
diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs
index 756c33d70c2..273684b8e86 100644
--- a/clippy_lints/src/utils/internal_lints.rs
+++ b/clippy_lints/src/utils/internal_lints.rs
@@ -561,9 +561,7 @@ declare_lint_pass!(ProduceIce => [PRODUCE_ICE]);
 
 impl EarlyLintPass for ProduceIce {
     fn check_fn(&mut self, _: &EarlyContext<'_>, fn_kind: FnKind<'_>, _: Span, _: NodeId) {
-        if is_trigger_fn(fn_kind) {
-            panic!("Would you like some help with that?");
-        }
+        assert!(!is_trigger_fn(fn_kind), "Would you like some help with that?");
     }
 }
 
diff --git a/clippy_utils/src/higher.rs b/clippy_utils/src/higher.rs
index 05a4a014319..64bd4223c05 100644
--- a/clippy_utils/src/higher.rs
+++ b/clippy_utils/src/higher.rs
@@ -608,3 +608,33 @@ pub fn is_from_for_desugar(local: &hir::Local<'_>) -> bool {
 
     false
 }
+
+/// A parsed `panic!` expansion
+pub struct PanicExpn<'tcx> {
+    /// Span of `panic!(..)`
+    pub call_site: Span,
+    /// Inner `format_args!` expansion
+    pub format_args: FormatArgsExpn<'tcx>,
+}
+
+impl PanicExpn<'tcx> {
+    /// Parses an expanded `panic!` invocation
+    pub fn parse(expr: &'tcx Expr<'tcx>) -> Option<Self> {
+        if_chain! {
+            if let ExprKind::Block(block, _) = expr.kind;
+            if let Some(init) = block.expr;
+            if let ExprKind::Call(_, [format_args]) = init.kind;
+            let expn_data = expr.span.ctxt().outer_expn_data();
+            if let ExprKind::AddrOf(_, _, format_args) = format_args.kind;
+            if let Some(format_args) = FormatArgsExpn::parse(format_args);
+            then {
+                Some(PanicExpn {
+                    call_site: expn_data.call_site,
+                    format_args,
+                })
+            } else {
+                None
+            }
+        }
+    }
+}
diff --git a/tests/compile-test.rs b/tests/compile-test.rs
index c9d10111595..d7596f6ff0c 100644
--- a/tests/compile-test.rs
+++ b/tests/compile-test.rs
@@ -90,9 +90,11 @@ fn extern_flags() -> String {
         .copied()
         .filter(|n| !crates.contains_key(n))
         .collect();
-    if !not_found.is_empty() {
-        panic!("dependencies not found in depinfo: {:?}", not_found);
-    }
+    assert!(
+        not_found.is_empty(),
+        "dependencies not found in depinfo: {:?}",
+        not_found
+    );
     crates
         .into_iter()
         .map(|(name, path)| format!(" --extern {}={}", name, path))
diff --git a/tests/integration.rs b/tests/integration.rs
index 7e3eff3c732..c64425fa01a 100644
--- a/tests/integration.rs
+++ b/tests/integration.rs
@@ -74,8 +74,11 @@ fn integration_test() {
         panic!("incompatible crate versions");
     } else if stderr.contains("failed to run `rustc` to learn about target-specific information") {
         panic!("couldn't find librustc_driver, consider setting `LD_LIBRARY_PATH`");
-    } else if stderr.contains("toolchain") && stderr.contains("is not installed") {
-        panic!("missing required toolchain");
+    } else {
+        assert!(
+            !stderr.contains("toolchain") || !stderr.contains("is not installed"),
+            "missing required toolchain"
+        );
     }
 
     match output.status.code() {
diff --git a/tests/ui/fallible_impl_from.rs b/tests/ui/fallible_impl_from.rs
index 5d5af4e4632..495cd97e05e 100644
--- a/tests/ui/fallible_impl_from.rs
+++ b/tests/ui/fallible_impl_from.rs
@@ -1,4 +1,5 @@
 #![deny(clippy::fallible_impl_from)]
+#![allow(clippy::if_then_panic)]
 
 // docs example
 struct Foo(i32);
diff --git a/tests/ui/fallible_impl_from.stderr b/tests/ui/fallible_impl_from.stderr
index 64c8ea85727..8b8054586e6 100644
--- a/tests/ui/fallible_impl_from.stderr
+++ b/tests/ui/fallible_impl_from.stderr
@@ -1,5 +1,5 @@
 error: consider implementing `TryFrom` instead
-  --> $DIR/fallible_impl_from.rs:5:1
+  --> $DIR/fallible_impl_from.rs:6:1
    |
 LL | / impl From<String> for Foo {
 LL | |     fn from(s: String) -> Self {
@@ -15,13 +15,13 @@ LL | #![deny(clippy::fallible_impl_from)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
    = help: `From` is intended for infallible conversions only. Use `TryFrom` if there's a possibility for the conversion to fail
 note: potential failure(s)
-  --> $DIR/fallible_impl_from.rs:7:13
+  --> $DIR/fallible_impl_from.rs:8:13
    |
 LL |         Foo(s.parse().unwrap())
    |             ^^^^^^^^^^^^^^^^^^
 
 error: consider implementing `TryFrom` instead
-  --> $DIR/fallible_impl_from.rs:26:1
+  --> $DIR/fallible_impl_from.rs:27:1
    |
 LL | / impl From<usize> for Invalid {
 LL | |     fn from(i: usize) -> Invalid {
@@ -34,14 +34,14 @@ LL | | }
    |
    = help: `From` is intended for infallible conversions only. Use `TryFrom` if there's a possibility for the conversion to fail
 note: potential failure(s)
-  --> $DIR/fallible_impl_from.rs:29:13
+  --> $DIR/fallible_impl_from.rs:30:13
    |
 LL |             panic!();
    |             ^^^^^^^^^
    = note: this error originates in the macro `$crate::panic::panic_2015` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: consider implementing `TryFrom` instead
-  --> $DIR/fallible_impl_from.rs:35:1
+  --> $DIR/fallible_impl_from.rs:36:1
    |
 LL | / impl From<Option<String>> for Invalid {
 LL | |     fn from(s: Option<String>) -> Invalid {
@@ -54,7 +54,7 @@ LL | | }
    |
    = help: `From` is intended for infallible conversions only. Use `TryFrom` if there's a possibility for the conversion to fail
 note: potential failure(s)
-  --> $DIR/fallible_impl_from.rs:37:17
+  --> $DIR/fallible_impl_from.rs:38:17
    |
 LL |         let s = s.unwrap();
    |                 ^^^^^^^^^^
@@ -68,7 +68,7 @@ LL |             panic!("{:?}", s);
    = note: this error originates in the macro `$crate::panic::panic_2015` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: consider implementing `TryFrom` instead
-  --> $DIR/fallible_impl_from.rs:53:1
+  --> $DIR/fallible_impl_from.rs:54:1
    |
 LL | / impl<'a> From<&'a mut <Box<u32> as ProjStrTrait>::ProjString> for Invalid {
 LL | |     fn from(s: &'a mut <Box<u32> as ProjStrTrait>::ProjString) -> Invalid {
@@ -81,7 +81,7 @@ LL | | }
    |
    = help: `From` is intended for infallible conversions only. Use `TryFrom` if there's a possibility for the conversion to fail
 note: potential failure(s)
-  --> $DIR/fallible_impl_from.rs:55:12
+  --> $DIR/fallible_impl_from.rs:56:12
    |
 LL |         if s.parse::<u32>().ok().unwrap() != 42 {
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/if_then_panic.fixed b/tests/ui/if_then_panic.fixed
new file mode 100644
index 00000000000..fc57ae0dfa5
--- /dev/null
+++ b/tests/ui/if_then_panic.fixed
@@ -0,0 +1,34 @@
+// run-rustfix
+#![warn(clippy::if_then_panic)]
+
+fn main() {
+    let a = vec![1, 2, 3];
+    let c = Some(2);
+    if !a.is_empty()
+        && a.len() == 3
+        && c != None
+        && !a.is_empty()
+        && a.len() == 3
+        && !a.is_empty()
+        && a.len() == 3
+        && !a.is_empty()
+        && a.len() == 3
+    {
+        panic!("qaqaq{:?}", a);
+    }
+    assert!(a.is_empty(), "qaqaq{:?}", a);
+    assert!(a.is_empty(), "qwqwq");
+    if a.len() == 3 {
+        println!("qwq");
+        println!("qwq");
+        println!("qwq");
+    }
+    if let Some(b) = c {
+        panic!("orz {}", b);
+    }
+    if a.len() == 3 {
+        panic!("qaqaq");
+    } else {
+        println!("qwq");
+    }
+}
diff --git a/tests/ui/if_then_panic.rs b/tests/ui/if_then_panic.rs
new file mode 100644
index 00000000000..d1ac93d8d41
--- /dev/null
+++ b/tests/ui/if_then_panic.rs
@@ -0,0 +1,38 @@
+// run-rustfix
+#![warn(clippy::if_then_panic)]
+
+fn main() {
+    let a = vec![1, 2, 3];
+    let c = Some(2);
+    if !a.is_empty()
+        && a.len() == 3
+        && c != None
+        && !a.is_empty()
+        && a.len() == 3
+        && !a.is_empty()
+        && a.len() == 3
+        && !a.is_empty()
+        && a.len() == 3
+    {
+        panic!("qaqaq{:?}", a);
+    }
+    if !a.is_empty() {
+        panic!("qaqaq{:?}", a);
+    }
+    if !a.is_empty() {
+        panic!("qwqwq");
+    }
+    if a.len() == 3 {
+        println!("qwq");
+        println!("qwq");
+        println!("qwq");
+    }
+    if let Some(b) = c {
+        panic!("orz {}", b);
+    }
+    if a.len() == 3 {
+        panic!("qaqaq");
+    } else {
+        println!("qwq");
+    }
+}
diff --git a/tests/ui/if_then_panic.stderr b/tests/ui/if_then_panic.stderr
new file mode 100644
index 00000000000..b92c9bdf674
--- /dev/null
+++ b/tests/ui/if_then_panic.stderr
@@ -0,0 +1,20 @@
+error: only a `panic!` in `if`-then statement
+  --> $DIR/if_then_panic.rs:19:5
+   |
+LL | /     if !a.is_empty() {
+LL | |         panic!("qaqaq{:?}", a);
+LL | |     }
+   | |_____^ help: try: `assert!(a.is_empty(), "qaqaq{:?}", a);`
+   |
+   = note: `-D clippy::if-then-panic` implied by `-D warnings`
+
+error: only a `panic!` in `if`-then statement
+  --> $DIR/if_then_panic.rs:22:5
+   |
+LL | /     if !a.is_empty() {
+LL | |         panic!("qwqwq");
+LL | |     }
+   | |_____^ help: try: `assert!(a.is_empty(), "qwqwq");`
+
+error: aborting due to 2 previous errors
+
diff --git a/tests/ui/ptr_arg.rs b/tests/ui/ptr_arg.rs
index 8656c17f29a..99e6d2aad8d 100644
--- a/tests/ui/ptr_arg.rs
+++ b/tests/ui/ptr_arg.rs
@@ -1,4 +1,9 @@
-#![allow(unused, clippy::redundant_clone)]
+#![allow(
+    unused,
+    clippy::many_single_char_names,
+    clippy::redundant_clone,
+    clippy::if_then_panic
+)]
 #![warn(clippy::ptr_arg)]
 
 use std::borrow::Cow;
diff --git a/tests/ui/ptr_arg.stderr b/tests/ui/ptr_arg.stderr
index 64594eb870c..42183447ead 100644
--- a/tests/ui/ptr_arg.stderr
+++ b/tests/ui/ptr_arg.stderr
@@ -1,5 +1,5 @@
 error: writing `&Vec<_>` instead of `&[_]` involves one more reference and cannot be used with non-Vec-based slices
-  --> $DIR/ptr_arg.rs:7:14
+  --> $DIR/ptr_arg.rs:12:14
    |
 LL | fn do_vec(x: &Vec<i64>) {
    |              ^^^^^^^^^ help: change this to: `&[i64]`
@@ -7,25 +7,25 @@ LL | fn do_vec(x: &Vec<i64>) {
    = note: `-D clippy::ptr-arg` implied by `-D warnings`
 
 error: writing `&String` instead of `&str` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:16:14
+  --> $DIR/ptr_arg.rs:21:14
    |
 LL | fn do_str(x: &String) {
    |              ^^^^^^^ help: change this to: `&str`
 
 error: writing `&PathBuf` instead of `&Path` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:25:15
+  --> $DIR/ptr_arg.rs:30:15
    |
 LL | fn do_path(x: &PathBuf) {
    |               ^^^^^^^^ help: change this to: `&Path`
 
 error: writing `&Vec<_>` instead of `&[_]` involves one more reference and cannot be used with non-Vec-based slices
-  --> $DIR/ptr_arg.rs:38:18
+  --> $DIR/ptr_arg.rs:43:18
    |
 LL |     fn do_vec(x: &Vec<i64>);
    |                  ^^^^^^^^^ help: change this to: `&[i64]`
 
 error: writing `&Vec<_>` instead of `&[_]` involves one more reference and cannot be used with non-Vec-based slices
-  --> $DIR/ptr_arg.rs:51:14
+  --> $DIR/ptr_arg.rs:56:14
    |
 LL | fn cloned(x: &Vec<u8>) -> Vec<u8> {
    |              ^^^^^^^^
@@ -44,7 +44,7 @@ LL |     x.to_owned()
    |
 
 error: writing `&String` instead of `&str` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:60:18
+  --> $DIR/ptr_arg.rs:65:18
    |
 LL | fn str_cloned(x: &String) -> String {
    |                  ^^^^^^^
@@ -67,7 +67,7 @@ LL |     x.to_string()
    |
 
 error: writing `&PathBuf` instead of `&Path` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:68:19
+  --> $DIR/ptr_arg.rs:73:19
    |
 LL | fn path_cloned(x: &PathBuf) -> PathBuf {
    |                   ^^^^^^^^
@@ -90,7 +90,7 @@ LL |     x.to_path_buf()
    |
 
 error: writing `&String` instead of `&str` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:76:44
+  --> $DIR/ptr_arg.rs:81:44
    |
 LL | fn false_positive_capacity(x: &Vec<u8>, y: &String) {
    |                                            ^^^^^^^
@@ -109,13 +109,13 @@ LL |     let c = y;
    |             ~
 
 error: using a reference to `Cow` is not recommended
-  --> $DIR/ptr_arg.rs:90:25
+  --> $DIR/ptr_arg.rs:95:25
    |
 LL | fn test_cow_with_ref(c: &Cow<[i32]>) {}
    |                         ^^^^^^^^^^^ help: change this to: `&[i32]`
 
 error: writing `&Vec<_>` instead of `&[_]` involves one more reference and cannot be used with non-Vec-based slices
-  --> $DIR/ptr_arg.rs:143:21
+  --> $DIR/ptr_arg.rs:148:21
    |
 LL |     fn foo_vec(vec: &Vec<u8>) {
    |                     ^^^^^^^^
@@ -134,7 +134,7 @@ LL |         let _ = vec.to_owned().clone();
    |                 ~~~~~~~~~~~~~~
 
 error: writing `&PathBuf` instead of `&Path` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:148:23
+  --> $DIR/ptr_arg.rs:153:23
    |
 LL |     fn foo_path(path: &PathBuf) {
    |                       ^^^^^^^^
@@ -153,7 +153,7 @@ LL |         let _ = path.to_path_buf().clone();
    |                 ~~~~~~~~~~~~~~~~~~
 
 error: writing `&PathBuf` instead of `&Path` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:153:21
+  --> $DIR/ptr_arg.rs:158:21
    |
 LL |     fn foo_str(str: &PathBuf) {
    |                     ^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From d888b4b98cb3fc233cca1c9f3165d5de3d86886a Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Fri, 10 Sep 2021 23:47:51 +0200
Subject: clippy lints: update doctest ranges to inclusive ones

---
 clippy_lints/src/matches.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index 2f1ff567e84..d878fbc35fd 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -183,8 +183,8 @@ declare_clippy_lint! {
     /// ```rust
     /// let x = 5;
     /// match x {
-    ///     1...10 => println!("1 ... 10"),
-    ///     5...15 => println!("5 ... 15"),
+    ///     1..=10 => println!("1 ... 10"),
+    ///     5..=15 => println!("5 ... 15"),
     ///     _ => (),
     /// }
     /// ```
-- 
cgit 1.4.1-3-g733a5


From e63d69244e6f0d1463cea210445cb46f59cd9f83 Mon Sep 17 00:00:00 2001
From: David Tolnay <dtolnay@gmail.com>
Date: Sat, 25 Sep 2021 22:54:08 -0700
Subject: Stop suggesting a float truncation that is not shorter

---
 clippy_lints/src/float_literal.rs   |  2 +-
 tests/ui/excessive_precision.fixed  | 10 +++++-----
 tests/ui/excessive_precision.stderr | 32 +-------------------------------
 3 files changed, 7 insertions(+), 37 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/float_literal.rs b/clippy_lints/src/float_literal.rs
index a3d70f31f00..1e8a5bd7d34 100644
--- a/clippy_lints/src/float_literal.rs
+++ b/clippy_lints/src/float_literal.rs
@@ -111,7 +111,7 @@ impl<'tcx> LateLintPass<'tcx> for FloatLiteral {
                             Applicability::MachineApplicable,
                         );
                     }
-                } else if digits > max as usize && sym_str != float_str {
+                } else if digits > max as usize && float_str.len() < sym_str.len() {
                     span_lint_and_sugg(
                         cx,
                         EXCESSIVE_PRECISION,
diff --git a/tests/ui/excessive_precision.fixed b/tests/ui/excessive_precision.fixed
index bf0325fec79..90376620a9f 100644
--- a/tests/ui/excessive_precision.fixed
+++ b/tests/ui/excessive_precision.fixed
@@ -17,8 +17,8 @@ fn main() {
     const BAD32_3: f32 = 0.1;
     const BAD32_EDGE: f32 = 1.000_001;
 
-    const BAD64_1: f64 = 0.123_456_789_012_345_66_f64;
-    const BAD64_2: f64 = 0.123_456_789_012_345_66;
+    const BAD64_1: f64 = 0.123_456_789_012_345_67f64;
+    const BAD64_2: f64 = 0.123_456_789_012_345_67;
     const BAD64_3: f64 = 0.1;
 
     // Literal as param
@@ -37,9 +37,9 @@ fn main() {
     let bad32_suf: f32 = 1.123_456_8_f32;
     let bad32_inf = 1.123_456_8_f32;
 
-    let bad64: f64 = 0.123_456_789_012_345_66;
-    let bad64_suf: f64 = 0.123_456_789_012_345_66_f64;
-    let bad64_inf = 0.123_456_789_012_345_66;
+    let bad64: f64 = 0.123_456_789_012_345_67;
+    let bad64_suf: f64 = 0.123_456_789_012_345_67f64;
+    let bad64_inf = 0.123_456_789_012_345_67;
 
     // Vectors
     let good_vec32: Vec<f32> = vec![0.123_456];
diff --git a/tests/ui/excessive_precision.stderr b/tests/ui/excessive_precision.stderr
index 599773f2f70..e59c20c30b4 100644
--- a/tests/ui/excessive_precision.stderr
+++ b/tests/ui/excessive_precision.stderr
@@ -24,18 +24,6 @@ error: float has excessive precision
 LL |     const BAD32_EDGE: f32 = 1.000_000_9;
    |                             ^^^^^^^^^^^ help: consider changing the type or truncating it to: `1.000_001`
 
-error: float has excessive precision
-  --> $DIR/excessive_precision.rs:20:26
-   |
-LL |     const BAD64_1: f64 = 0.123_456_789_012_345_67f64;
-   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider changing the type or truncating it to: `0.123_456_789_012_345_66_f64`
-
-error: float has excessive precision
-  --> $DIR/excessive_precision.rs:21:26
-   |
-LL |     const BAD64_2: f64 = 0.123_456_789_012_345_67;
-   |                          ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider changing the type or truncating it to: `0.123_456_789_012_345_66`
-
 error: float has excessive precision
   --> $DIR/excessive_precision.rs:22:26
    |
@@ -66,24 +54,6 @@ error: float has excessive precision
 LL |     let bad32_inf = 1.123_456_789_f32;
    |                     ^^^^^^^^^^^^^^^^^ help: consider changing the type or truncating it to: `1.123_456_8_f32`
 
-error: float has excessive precision
-  --> $DIR/excessive_precision.rs:40:22
-   |
-LL |     let bad64: f64 = 0.123_456_789_012_345_67;
-   |                      ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider changing the type or truncating it to: `0.123_456_789_012_345_66`
-
-error: float has excessive precision
-  --> $DIR/excessive_precision.rs:41:26
-   |
-LL |     let bad64_suf: f64 = 0.123_456_789_012_345_67f64;
-   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider changing the type or truncating it to: `0.123_456_789_012_345_66_f64`
-
-error: float has excessive precision
-  --> $DIR/excessive_precision.rs:42:21
-   |
-LL |     let bad64_inf = 0.123_456_789_012_345_67;
-   |                     ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider changing the type or truncating it to: `0.123_456_789_012_345_66`
-
 error: float has excessive precision
   --> $DIR/excessive_precision.rs:48:36
    |
@@ -108,5 +78,5 @@ error: float has excessive precision
 LL |     let bad_bige32: f32 = 1.123_456_788_888E-10;
    |                           ^^^^^^^^^^^^^^^^^^^^^ help: consider changing the type or truncating it to: `1.123_456_8E-10`
 
-error: aborting due to 18 previous errors
+error: aborting due to 13 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From b7d40bc10394107afc03a126e346b5522beb0703 Mon Sep 17 00:00:00 2001
From: Andrew Pollack <andrewpkq@gmail.com>
Date: Sun, 29 Aug 2021 18:49:09 -0700
Subject: Adding new  linting

---
 CHANGELOG.md                           |   6 +-
 clippy_lints/src/if_let_some_result.rs |  76 -----------------------
 clippy_lints/src/lib.rs                |  10 +--
 clippy_lints/src/match_result_ok.rs    | 110 +++++++++++++++++++++++++++++++++
 tests/ui/if_let_some_result.fixed      |  28 ---------
 tests/ui/if_let_some_result.rs         |  28 ---------
 tests/ui/if_let_some_result.stderr     |  25 --------
 tests/ui/match_result_ok.fixed         |  63 +++++++++++++++++++
 tests/ui/match_result_ok.rs            |  63 +++++++++++++++++++
 tests/ui/match_result_ok.stderr        |  36 +++++++++++
 10 files changed, 282 insertions(+), 163 deletions(-)
 delete mode 100644 clippy_lints/src/if_let_some_result.rs
 create mode 100644 clippy_lints/src/match_result_ok.rs
 delete mode 100644 tests/ui/if_let_some_result.fixed
 delete mode 100644 tests/ui/if_let_some_result.rs
 delete mode 100644 tests/ui/if_let_some_result.stderr
 create mode 100644 tests/ui/match_result_ok.fixed
 create mode 100644 tests/ui/match_result_ok.rs
 create mode 100644 tests/ui/match_result_ok.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 040c906a722..9518c511171 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -8,6 +8,10 @@ document.
 
 [74d1561...master](https://github.com/rust-lang/rust-clippy/compare/74d1561...master)
 
+### New Lints
+
+* Renamed Lint: `if_let_some_result` is now called [`match_result_ok`].
+
 ## Rust 1.55
 
 Current beta, release 2021-09-09
@@ -2685,7 +2689,6 @@ Released 2018-09-13
 [`identity_op`]: https://rust-lang.github.io/rust-clippy/master/index.html#identity_op
 [`if_let_mutex`]: https://rust-lang.github.io/rust-clippy/master/index.html#if_let_mutex
 [`if_let_redundant_pattern_matching`]: https://rust-lang.github.io/rust-clippy/master/index.html#if_let_redundant_pattern_matching
-[`if_let_some_result`]: https://rust-lang.github.io/rust-clippy/master/index.html#if_let_some_result
 [`if_not_else`]: https://rust-lang.github.io/rust-clippy/master/index.html#if_not_else
 [`if_same_then_else`]: https://rust-lang.github.io/rust-clippy/master/index.html#if_same_then_else
 [`if_then_panic`]: https://rust-lang.github.io/rust-clippy/master/index.html#if_then_panic
@@ -2775,6 +2778,7 @@ Released 2018-09-13
 [`match_on_vec_items`]: https://rust-lang.github.io/rust-clippy/master/index.html#match_on_vec_items
 [`match_overlapping_arm`]: https://rust-lang.github.io/rust-clippy/master/index.html#match_overlapping_arm
 [`match_ref_pats`]: https://rust-lang.github.io/rust-clippy/master/index.html#match_ref_pats
+[`match_result_ok`]: https://rust-lang.github.io/rust-clippy/master/index.html#match_result_ok
 [`match_same_arms`]: https://rust-lang.github.io/rust-clippy/master/index.html#match_same_arms
 [`match_single_binding`]: https://rust-lang.github.io/rust-clippy/master/index.html#match_single_binding
 [`match_wild_err_arm`]: https://rust-lang.github.io/rust-clippy/master/index.html#match_wild_err_arm
diff --git a/clippy_lints/src/if_let_some_result.rs b/clippy_lints/src/if_let_some_result.rs
deleted file mode 100644
index adcd78ed0d4..00000000000
--- a/clippy_lints/src/if_let_some_result.rs
+++ /dev/null
@@ -1,76 +0,0 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::higher;
-use clippy_utils::method_chain_args;
-use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::ty::is_type_diagnostic_item;
-use if_chain::if_chain;
-use rustc_errors::Applicability;
-use rustc_hir::{Expr, ExprKind, PatKind, QPath};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::sym;
-
-declare_clippy_lint! {
-    /// ### What it does
-    ///* Checks for unnecessary `ok()` in if let.
-    ///
-    /// ### Why is this bad?
-    /// Calling `ok()` in if let is unnecessary, instead match
-    /// on `Ok(pat)`
-    ///
-    /// ### Example
-    /// ```ignore
-    /// for i in iter {
-    ///     if let Some(value) = i.parse().ok() {
-    ///         vec.push(value)
-    ///     }
-    /// }
-    /// ```
-    /// Could be written:
-    ///
-    /// ```ignore
-    /// for i in iter {
-    ///     if let Ok(value) = i.parse() {
-    ///         vec.push(value)
-    ///     }
-    /// }
-    /// ```
-    pub IF_LET_SOME_RESULT,
-    style,
-    "usage of `ok()` in `if let Some(pat)` statements is unnecessary, match on `Ok(pat)` instead"
-}
-
-declare_lint_pass!(OkIfLet => [IF_LET_SOME_RESULT]);
-
-impl<'tcx> LateLintPass<'tcx> for OkIfLet {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if_chain! { //begin checking variables
-            if let Some(higher::IfLet { let_pat, let_expr, .. }) = higher::IfLet::hir(cx, expr);
-            if let ExprKind::MethodCall(_, ok_span, [ref result_types_0, ..], _) = let_expr.kind; //check is expr.ok() has type Result<T,E>.ok(, _)
-            if let PatKind::TupleStruct(QPath::Resolved(_, x), y, _)  = let_pat.kind; //get operation
-            if method_chain_args(let_expr, &["ok"]).is_some(); //test to see if using ok() methoduse std::marker::Sized;
-            if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(result_types_0), sym::result_type);
-            if rustc_hir_pretty::to_string(rustc_hir_pretty::NO_ANN, |s| s.print_path(x, false)) == "Some";
-
-            then {
-                let mut applicability = Applicability::MachineApplicable;
-                let some_expr_string = snippet_with_applicability(cx, y[0].span, "", &mut applicability);
-                let trimmed_ok = snippet_with_applicability(cx, let_expr.span.until(ok_span), "", &mut applicability);
-                let sugg = format!(
-                    "if let Ok({}) = {}",
-                    some_expr_string,
-                    trimmed_ok.trim().trim_end_matches('.'),
-                );
-                span_lint_and_sugg(
-                    cx,
-                    IF_LET_SOME_RESULT,
-                    expr.span.with_hi(let_expr.span.hi()),
-                    "matching on `Some` with `ok()` is redundant",
-                    &format!("consider matching on `Ok({})` and removing the call to `ok` instead", some_expr_string),
-                    sugg,
-                    applicability,
-                );
-            }
-        }
-    }
-}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 1d24d02511b..879f3ba68f4 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -225,7 +225,6 @@ mod future_not_send;
 mod get_last_with_len;
 mod identity_op;
 mod if_let_mutex;
-mod if_let_some_result;
 mod if_not_else;
 mod if_then_panic;
 mod if_then_some_else_none;
@@ -264,6 +263,7 @@ mod map_clone;
 mod map_err_ignore;
 mod map_unit_fn;
 mod match_on_vec_items;
+mod match_result_ok;
 mod matches;
 mod mem_discriminant;
 mod mem_forget;
@@ -658,7 +658,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         get_last_with_len::GET_LAST_WITH_LEN,
         identity_op::IDENTITY_OP,
         if_let_mutex::IF_LET_MUTEX,
-        if_let_some_result::IF_LET_SOME_RESULT,
         if_not_else::IF_NOT_ELSE,
         if_then_panic::IF_THEN_PANIC,
         if_then_some_else_none::IF_THEN_SOME_ELSE_NONE,
@@ -728,6 +727,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         map_unit_fn::OPTION_MAP_UNIT_FN,
         map_unit_fn::RESULT_MAP_UNIT_FN,
         match_on_vec_items::MATCH_ON_VEC_ITEMS,
+        match_result_ok::MATCH_RESULT_OK,
         matches::INFALLIBLE_DESTRUCTURING_MATCH,
         matches::MATCH_AS_REF,
         matches::MATCH_BOOL,
@@ -1259,7 +1259,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(get_last_with_len::GET_LAST_WITH_LEN),
         LintId::of(identity_op::IDENTITY_OP),
         LintId::of(if_let_mutex::IF_LET_MUTEX),
-        LintId::of(if_let_some_result::IF_LET_SOME_RESULT),
         LintId::of(if_then_panic::IF_THEN_PANIC),
         LintId::of(indexing_slicing::OUT_OF_BOUNDS_INDEXING),
         LintId::of(infinite_iter::INFINITE_ITER),
@@ -1303,6 +1302,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(map_clone::MAP_CLONE),
         LintId::of(map_unit_fn::OPTION_MAP_UNIT_FN),
         LintId::of(map_unit_fn::RESULT_MAP_UNIT_FN),
+        LintId::of(match_result_ok::MATCH_RESULT_OK),
         LintId::of(matches::INFALLIBLE_DESTRUCTURING_MATCH),
         LintId::of(matches::MATCH_AS_REF),
         LintId::of(matches::MATCH_LIKE_MATCHES_MACRO),
@@ -1513,7 +1513,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(functions::DOUBLE_MUST_USE),
         LintId::of(functions::MUST_USE_UNIT),
         LintId::of(functions::RESULT_UNIT_ERR),
-        LintId::of(if_let_some_result::IF_LET_SOME_RESULT),
         LintId::of(if_then_panic::IF_THEN_PANIC),
         LintId::of(inherent_to_string::INHERENT_TO_STRING),
         LintId::of(len_zero::COMPARISON_TO_EMPTY),
@@ -1530,6 +1529,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(manual_map::MANUAL_MAP),
         LintId::of(manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE),
         LintId::of(map_clone::MAP_CLONE),
+        LintId::of(match_result_ok::MATCH_RESULT_OK),
         LintId::of(matches::INFALLIBLE_DESTRUCTURING_MATCH),
         LintId::of(matches::MATCH_LIKE_MATCHES_MACRO),
         LintId::of(matches::MATCH_OVERLAPPING_ARM),
@@ -1985,7 +1985,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(missing_doc::MissingDoc::new()));
     store.register_late_pass(|| Box::new(missing_inline::MissingInline));
     store.register_late_pass(move || Box::new(exhaustive_items::ExhaustiveItems));
-    store.register_late_pass(|| Box::new(if_let_some_result::OkIfLet));
+    store.register_late_pass(|| Box::new(match_result_ok::MatchResultOk));
     store.register_late_pass(|| Box::new(partialeq_ne_impl::PartialEqNeImpl));
     store.register_late_pass(|| Box::new(unused_io_amount::UnusedIoAmount));
     let enum_variant_size_threshold = conf.enum_variant_size_threshold;
diff --git a/clippy_lints/src/match_result_ok.rs b/clippy_lints/src/match_result_ok.rs
new file mode 100644
index 00000000000..02b09a2dec6
--- /dev/null
+++ b/clippy_lints/src/match_result_ok.rs
@@ -0,0 +1,110 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::higher;
+use clippy_utils::method_chain_args;
+use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::ty::is_type_diagnostic_item;
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind, PatKind, QPath};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::sym;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for unnecessary `ok()` in `while let`.
+    ///
+    /// ### Why is this bad?
+    /// Calling `ok()` in `while let` is unnecessary, instead match
+    /// on `Ok(pat)`
+    ///
+    /// ### Example
+    /// ```ignore
+    /// while let Some(value) = iter.next().ok() {
+    ///     vec.push(value)
+    /// }
+    ///
+    /// if let Some(valie) = iter.next().ok() {
+    ///     vec.push(value)
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```ignore
+    /// while let Ok(value) = iter.next() {
+    ///     vec.push(value)
+    /// }
+    ///
+    /// if let Ok(value) = iter.next() {
+    ///        vec.push_value)
+    /// }
+    /// ```
+    pub MATCH_RESULT_OK,
+    style,
+    "usage of `ok()` in `let Some(pat)` statements is unnecessary, match on `Ok(pat)` instead"
+}
+
+declare_lint_pass!(MatchResultOk => [MATCH_RESULT_OK]);
+
+impl<'tcx> LateLintPass<'tcx> for MatchResultOk {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        if_chain! {
+            if let Some(higher::IfLet { let_pat, let_expr, .. }) = higher::IfLet::hir(cx, expr);
+            if let ExprKind::MethodCall(_, ok_span, [ref result_types_0, ..], _) = let_expr.kind; //check is expr.ok() has type Result<T,E>.ok(, _)
+            if let PatKind::TupleStruct(QPath::Resolved(_, x), y, _)  = let_pat.kind; //get operation
+            if method_chain_args(let_expr, &["ok"]).is_some(); //test to see if using ok() methoduse std::marker::Sized;
+            if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(result_types_0), sym::result_type);
+            if rustc_hir_pretty::to_string(rustc_hir_pretty::NO_ANN, |s| s.print_path(x, false)) == "Some";
+
+            then {
+
+                let mut applicability = Applicability::MachineApplicable;
+                let some_expr_string = snippet_with_applicability(cx, y[0].span, "", &mut applicability);
+                let trimmed_ok = snippet_with_applicability(cx, let_expr.span.until(ok_span), "", &mut applicability);
+                let sugg = format!(
+                    "if let Ok({}) = {}",
+                    some_expr_string,
+                    trimmed_ok.trim().trim_end_matches('.'),
+                );
+                span_lint_and_sugg(
+                    cx,
+                    MATCH_RESULT_OK,
+                    expr.span.with_hi(let_expr.span.hi()),
+                    "matching on `Some` with `ok()` is redundant",
+                    &format!("consider matching on `Ok({})` and removing the call to `ok` instead", some_expr_string),
+                    sugg,
+                    applicability,
+                );
+            }
+        }
+
+        if_chain! {
+            if let Some(higher::WhileLet { let_pat, let_expr, .. }) = higher::WhileLet::hir(expr);
+            if let ExprKind::MethodCall(_, ok_span, [ref result_types_0, ..], _) = let_expr.kind; //check is expr.ok() has type Result<T,E>.ok(, _)
+            if let PatKind::TupleStruct(QPath::Resolved(_, x), y, _)  = let_pat.kind; //get operation
+            if method_chain_args(let_expr, &["ok"]).is_some(); //test to see if using ok() methoduse std::marker::Sized;
+            if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(result_types_0), sym::result_type);
+            if rustc_hir_pretty::to_string(rustc_hir_pretty::NO_ANN, |s| s.print_path(x, false)) == "Some";
+
+            then {
+
+                let mut applicability = Applicability::MachineApplicable;
+                let some_expr_string = snippet_with_applicability(cx, y[0].span, "", &mut applicability);
+                let trimmed_ok = snippet_with_applicability(cx, let_expr.span.until(ok_span), "", &mut applicability);
+                let sugg = format!(
+                    "while let Ok({}) = {}",
+                    some_expr_string,
+                    trimmed_ok.trim().trim_end_matches('.'),
+                );
+                span_lint_and_sugg(
+                    cx,
+                    MATCH_RESULT_OK,
+                    expr.span.with_hi(let_expr.span.hi()),
+                    "matching on `Some` with `ok()` is redundant",
+                    &format!("consider matching on `Ok({})` and removing the call to `ok` instead", some_expr_string),
+                    sugg,
+                    applicability,
+                );
+            }
+        }
+    }
+}
diff --git a/tests/ui/if_let_some_result.fixed b/tests/ui/if_let_some_result.fixed
deleted file mode 100644
index 1bddc47721e..00000000000
--- a/tests/ui/if_let_some_result.fixed
+++ /dev/null
@@ -1,28 +0,0 @@
-// run-rustfix
-
-#![warn(clippy::if_let_some_result)]
-#![allow(dead_code)]
-
-fn str_to_int(x: &str) -> i32 {
-    if let Ok(y) = x.parse() { y } else { 0 }
-}
-
-fn str_to_int_ok(x: &str) -> i32 {
-    if let Ok(y) = x.parse() { y } else { 0 }
-}
-
-#[rustfmt::skip]
-fn strange_some_no_else(x: &str) -> i32 {
-    {
-        if let Ok(y) = x   .   parse()       {
-            return y;
-        };
-        0
-    }
-}
-
-fn negative() {
-    while let Some(1) = "".parse().ok() {}
-}
-
-fn main() {}
diff --git a/tests/ui/if_let_some_result.rs b/tests/ui/if_let_some_result.rs
deleted file mode 100644
index d4a52ec9881..00000000000
--- a/tests/ui/if_let_some_result.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-// run-rustfix
-
-#![warn(clippy::if_let_some_result)]
-#![allow(dead_code)]
-
-fn str_to_int(x: &str) -> i32 {
-    if let Some(y) = x.parse().ok() { y } else { 0 }
-}
-
-fn str_to_int_ok(x: &str) -> i32 {
-    if let Ok(y) = x.parse() { y } else { 0 }
-}
-
-#[rustfmt::skip]
-fn strange_some_no_else(x: &str) -> i32 {
-    {
-        if let Some(y) = x   .   parse()   .   ok   ()    {
-            return y;
-        };
-        0
-    }
-}
-
-fn negative() {
-    while let Some(1) = "".parse().ok() {}
-}
-
-fn main() {}
diff --git a/tests/ui/if_let_some_result.stderr b/tests/ui/if_let_some_result.stderr
deleted file mode 100644
index bc3a5e7698d..00000000000
--- a/tests/ui/if_let_some_result.stderr
+++ /dev/null
@@ -1,25 +0,0 @@
-error: matching on `Some` with `ok()` is redundant
-  --> $DIR/if_let_some_result.rs:7:5
-   |
-LL |     if let Some(y) = x.parse().ok() { y } else { 0 }
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: `-D clippy::if-let-some-result` implied by `-D warnings`
-help: consider matching on `Ok(y)` and removing the call to `ok` instead
-   |
-LL |     if let Ok(y) = x.parse() { y } else { 0 }
-   |     ~~~~~~~~~~~~~~~~~~~~~~~~
-
-error: matching on `Some` with `ok()` is redundant
-  --> $DIR/if_let_some_result.rs:17:9
-   |
-LL |         if let Some(y) = x   .   parse()   .   ok   ()    {
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: consider matching on `Ok(y)` and removing the call to `ok` instead
-   |
-LL |         if let Ok(y) = x   .   parse()       {
-   |         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-error: aborting due to 2 previous errors
-
diff --git a/tests/ui/match_result_ok.fixed b/tests/ui/match_result_ok.fixed
new file mode 100644
index 00000000000..d4760a97567
--- /dev/null
+++ b/tests/ui/match_result_ok.fixed
@@ -0,0 +1,63 @@
+// run-rustfix
+
+#![warn(clippy::match_result_ok)]
+#![allow(clippy::boxed_local)]
+#![allow(dead_code)]
+
+// Checking `if` cases
+
+fn str_to_int(x: &str) -> i32 {
+    if let Ok(y) = x.parse() { y } else { 0 }
+}
+
+fn str_to_int_ok(x: &str) -> i32 {
+    if let Ok(y) = x.parse() { y } else { 0 }
+}
+
+#[rustfmt::skip]
+fn strange_some_no_else(x: &str) -> i32 {
+    {
+        if let Ok(y) = x   .   parse()       {
+            return y;
+        };
+        0
+    }
+}
+
+// Checking `while` cases
+
+struct Wat {
+    counter: i32,
+}
+
+impl Wat {
+    fn next(&mut self) -> Result<i32, &str> {
+        self.counter += 1;
+        if self.counter < 5 {
+            Ok(self.counter)
+        } else {
+            Err("Oh no")
+        }
+    }
+}
+
+fn base_1(x: i32) {
+    let mut wat = Wat { counter: x };
+    while let Ok(a) = wat.next() {
+        println!("{}", a);
+    }
+}
+
+fn base_2(x: i32) {
+    let mut wat = Wat { counter: x };
+    while let Ok(a) = wat.next() {
+        println!("{}", a);
+    }
+}
+
+fn base_3(test_func: Box<Result<i32, &str>>) {
+    // Expected to stay as is
+    while let Some(_b) = test_func.ok() {}
+}
+
+fn main() {}
diff --git a/tests/ui/match_result_ok.rs b/tests/ui/match_result_ok.rs
new file mode 100644
index 00000000000..0b818723d98
--- /dev/null
+++ b/tests/ui/match_result_ok.rs
@@ -0,0 +1,63 @@
+// run-rustfix
+
+#![warn(clippy::match_result_ok)]
+#![allow(clippy::boxed_local)]
+#![allow(dead_code)]
+
+// Checking `if` cases
+
+fn str_to_int(x: &str) -> i32 {
+    if let Some(y) = x.parse().ok() { y } else { 0 }
+}
+
+fn str_to_int_ok(x: &str) -> i32 {
+    if let Ok(y) = x.parse() { y } else { 0 }
+}
+
+#[rustfmt::skip]
+fn strange_some_no_else(x: &str) -> i32 {
+    {
+        if let Some(y) = x   .   parse()   .   ok   ()    {
+            return y;
+        };
+        0
+    }
+}
+
+// Checking `while` cases
+
+struct Wat {
+    counter: i32,
+}
+
+impl Wat {
+    fn next(&mut self) -> Result<i32, &str> {
+        self.counter += 1;
+        if self.counter < 5 {
+            Ok(self.counter)
+        } else {
+            Err("Oh no")
+        }
+    }
+}
+
+fn base_1(x: i32) {
+    let mut wat = Wat { counter: x };
+    while let Some(a) = wat.next().ok() {
+        println!("{}", a);
+    }
+}
+
+fn base_2(x: i32) {
+    let mut wat = Wat { counter: x };
+    while let Ok(a) = wat.next() {
+        println!("{}", a);
+    }
+}
+
+fn base_3(test_func: Box<Result<i32, &str>>) {
+    // Expected to stay as is
+    while let Some(_b) = test_func.ok() {}
+}
+
+fn main() {}
diff --git a/tests/ui/match_result_ok.stderr b/tests/ui/match_result_ok.stderr
new file mode 100644
index 00000000000..cc3bc8c76ff
--- /dev/null
+++ b/tests/ui/match_result_ok.stderr
@@ -0,0 +1,36 @@
+error: matching on `Some` with `ok()` is redundant
+  --> $DIR/match_result_ok.rs:10:5
+   |
+LL |     if let Some(y) = x.parse().ok() { y } else { 0 }
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::match-result-ok` implied by `-D warnings`
+help: consider matching on `Ok(y)` and removing the call to `ok` instead
+   |
+LL |     if let Ok(y) = x.parse() { y } else { 0 }
+   |     ~~~~~~~~~~~~~~~~~~~~~~~~
+
+error: matching on `Some` with `ok()` is redundant
+  --> $DIR/match_result_ok.rs:20:9
+   |
+LL |         if let Some(y) = x   .   parse()   .   ok   ()    {
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider matching on `Ok(y)` and removing the call to `ok` instead
+   |
+LL |         if let Ok(y) = x   .   parse()       {
+   |         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+error: matching on `Some` with `ok()` is redundant
+  --> $DIR/match_result_ok.rs:46:5
+   |
+LL |     while let Some(a) = wat.next().ok() {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider matching on `Ok(a)` and removing the call to `ok` instead
+   |
+LL |     while let Ok(a) = wat.next() {
+   |     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+error: aborting due to 3 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From baec67e9de4b3794f07d3024525d2a5fa8e1a1ea Mon Sep 17 00:00:00 2001
From: Manish Goregaokar <manishsmail@gmail.com>
Date: Mon, 27 Sep 2021 22:09:23 -0700
Subject: Use a single if_chain

---
 clippy_lints/src/match_result_ok.rs | 40 +++++++++----------------------------
 1 file changed, 9 insertions(+), 31 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/match_result_ok.rs b/clippy_lints/src/match_result_ok.rs
index 02b09a2dec6..650bb167b73 100644
--- a/clippy_lints/src/match_result_ok.rs
+++ b/clippy_lints/src/match_result_ok.rs
@@ -47,38 +47,15 @@ declare_lint_pass!(MatchResultOk => [MATCH_RESULT_OK]);
 
 impl<'tcx> LateLintPass<'tcx> for MatchResultOk {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if_chain! {
-            if let Some(higher::IfLet { let_pat, let_expr, .. }) = higher::IfLet::hir(cx, expr);
-            if let ExprKind::MethodCall(_, ok_span, [ref result_types_0, ..], _) = let_expr.kind; //check is expr.ok() has type Result<T,E>.ok(, _)
-            if let PatKind::TupleStruct(QPath::Resolved(_, x), y, _)  = let_pat.kind; //get operation
-            if method_chain_args(let_expr, &["ok"]).is_some(); //test to see if using ok() methoduse std::marker::Sized;
-            if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(result_types_0), sym::result_type);
-            if rustc_hir_pretty::to_string(rustc_hir_pretty::NO_ANN, |s| s.print_path(x, false)) == "Some";
-
-            then {
-
-                let mut applicability = Applicability::MachineApplicable;
-                let some_expr_string = snippet_with_applicability(cx, y[0].span, "", &mut applicability);
-                let trimmed_ok = snippet_with_applicability(cx, let_expr.span.until(ok_span), "", &mut applicability);
-                let sugg = format!(
-                    "if let Ok({}) = {}",
-                    some_expr_string,
-                    trimmed_ok.trim().trim_end_matches('.'),
-                );
-                span_lint_and_sugg(
-                    cx,
-                    MATCH_RESULT_OK,
-                    expr.span.with_hi(let_expr.span.hi()),
-                    "matching on `Some` with `ok()` is redundant",
-                    &format!("consider matching on `Ok({})` and removing the call to `ok` instead", some_expr_string),
-                    sugg,
-                    applicability,
-                );
-            }
-        }
+        let (let_pat, let_expr, ifwhile) = if let Some(higher::IfLet { let_pat, let_expr, .. }) = higher::IfLet::hir(cx, expr) {
+            (let_pat, let_expr, "if")
+        } else if let Some(higher::WhileLet { let_pat, let_expr, .. }) = higher::WhileLet::hir(expr) {
+            (let_pat, let_expr, "while")
+        } else {
+            return
+        };
 
         if_chain! {
-            if let Some(higher::WhileLet { let_pat, let_expr, .. }) = higher::WhileLet::hir(expr);
             if let ExprKind::MethodCall(_, ok_span, [ref result_types_0, ..], _) = let_expr.kind; //check is expr.ok() has type Result<T,E>.ok(, _)
             if let PatKind::TupleStruct(QPath::Resolved(_, x), y, _)  = let_pat.kind; //get operation
             if method_chain_args(let_expr, &["ok"]).is_some(); //test to see if using ok() methoduse std::marker::Sized;
@@ -91,7 +68,8 @@ impl<'tcx> LateLintPass<'tcx> for MatchResultOk {
                 let some_expr_string = snippet_with_applicability(cx, y[0].span, "", &mut applicability);
                 let trimmed_ok = snippet_with_applicability(cx, let_expr.span.until(ok_span), "", &mut applicability);
                 let sugg = format!(
-                    "while let Ok({}) = {}",
+                    "{} let Ok({}) = {}",
+                    ifwhile,
                     some_expr_string,
                     trimmed_ok.trim().trim_end_matches('.'),
                 );
-- 
cgit 1.4.1-3-g733a5


From 17155c8dca9386e865fd92a259694246a5120ed8 Mon Sep 17 00:00:00 2001
From: Manish Goregaokar <manishsmail@gmail.com>
Date: Mon, 27 Sep 2021 22:26:14 -0700
Subject: Add renamed lint

---
 clippy_lints/src/lib.rs | 1 +
 1 file changed, 1 insertion(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 879f3ba68f4..92ebebd62bf 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -2212,6 +2212,7 @@ pub fn register_renamed(ls: &mut rustc_lint::LintStore) {
     ls.register_renamed("clippy::identity_conversion", "clippy::useless_conversion");
     ls.register_renamed("clippy::zero_width_space", "clippy::invisible_characters");
     ls.register_renamed("clippy::single_char_push_str", "clippy::single_char_add_str");
+    ls.register_renamed("clippy::if_let_some_result", "clippy::match_result_ok");
 
     // uplifted lints
     ls.register_renamed("clippy::invalid_ref", "invalid_value");
-- 
cgit 1.4.1-3-g733a5


From 13834e6ad2294a95c664aca2acaedb1a9619773f Mon Sep 17 00:00:00 2001
From: Manish Goregaokar <manishsmail@gmail.com>
Date: Mon, 27 Sep 2021 22:33:45 -0700
Subject: fmt

---
 clippy_lints/src/match_result_ok.rs | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/match_result_ok.rs b/clippy_lints/src/match_result_ok.rs
index 650bb167b73..c7de06f0815 100644
--- a/clippy_lints/src/match_result_ok.rs
+++ b/clippy_lints/src/match_result_ok.rs
@@ -47,13 +47,14 @@ declare_lint_pass!(MatchResultOk => [MATCH_RESULT_OK]);
 
 impl<'tcx> LateLintPass<'tcx> for MatchResultOk {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        let (let_pat, let_expr, ifwhile) = if let Some(higher::IfLet { let_pat, let_expr, .. }) = higher::IfLet::hir(cx, expr) {
-            (let_pat, let_expr, "if")
-        } else if let Some(higher::WhileLet { let_pat, let_expr, .. }) = higher::WhileLet::hir(expr) {
-            (let_pat, let_expr, "while")
-        } else {
-            return
-        };
+        let (let_pat, let_expr, ifwhile) =
+            if let Some(higher::IfLet { let_pat, let_expr, .. }) = higher::IfLet::hir(cx, expr) {
+                (let_pat, let_expr, "if")
+            } else if let Some(higher::WhileLet { let_pat, let_expr, .. }) = higher::WhileLet::hir(expr) {
+                (let_pat, let_expr, "while")
+            } else {
+                return;
+            };
 
         if_chain! {
             if let ExprKind::MethodCall(_, ok_span, [ref result_types_0, ..], _) = let_expr.kind; //check is expr.ok() has type Result<T,E>.ok(, _)
-- 
cgit 1.4.1-3-g733a5


From 25850fc264ff71fcdbfd3594e8d5a299d7dbe2c0 Mon Sep 17 00:00:00 2001
From: Manish Goregaokar <manishsmail@gmail.com>
Date: Tue, 28 Sep 2021 08:33:58 -0700
Subject: Make doc_unsafe lint on unsafe traits as well

---
 clippy_lints/src/doc.rs       | 12 +++++++++++-
 tests/ui/def_id_nocore.rs     |  1 +
 tests/ui/def_id_nocore.stderr |  2 +-
 tests/ui/doc_unsafe.rs        | 21 +++++++++++++++++++--
 tests/ui/doc_unsafe.stderr    | 14 +++++++++++---
 5 files changed, 43 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/doc.rs b/clippy_lints/src/doc.rs
index cb2b7f5be70..0a9edfd7334 100644
--- a/clippy_lints/src/doc.rs
+++ b/clippy_lints/src/doc.rs
@@ -236,7 +236,17 @@ impl<'tcx> LateLintPass<'tcx> for DocMarkdown {
             hir::ItemKind::Impl(ref impl_) => {
                 self.in_trait_impl = impl_.of_trait.is_some();
             },
-            _ => {},
+            hir::ItemKind::Trait(_, unsafety, ..) => {
+                if !headers.safety && unsafety == hir::Unsafety::Unsafe {
+                    span_lint(
+                        cx,
+                        MISSING_SAFETY_DOC,
+                        item.span,
+                        "unsafe trait's docs miss `# Safety` section",
+                    );
+                }
+            },
+            _ => (),
         }
     }
 
diff --git a/tests/ui/def_id_nocore.rs b/tests/ui/def_id_nocore.rs
index cba7666c2d8..9ff3b5e5ef5 100644
--- a/tests/ui/def_id_nocore.rs
+++ b/tests/ui/def_id_nocore.rs
@@ -3,6 +3,7 @@
 
 #![feature(no_core, lang_items, start)]
 #![no_core]
+#![allow(clippy::missing_safety_doc)]
 
 #[link(name = "c")]
 extern "C" {}
diff --git a/tests/ui/def_id_nocore.stderr b/tests/ui/def_id_nocore.stderr
index 702684f6b43..6210d7c6cfd 100644
--- a/tests/ui/def_id_nocore.stderr
+++ b/tests/ui/def_id_nocore.stderr
@@ -1,5 +1,5 @@
 error: methods called `as_*` usually take `self` by reference or `self` by mutable reference
-  --> $DIR/def_id_nocore.rs:26:19
+  --> $DIR/def_id_nocore.rs:27:19
    |
 LL |     pub fn as_ref(self) -> &'static str {
    |                   ^^^^
diff --git a/tests/ui/doc_unsafe.rs b/tests/ui/doc_unsafe.rs
index 484aa72d59a..8f823f1672b 100644
--- a/tests/ui/doc_unsafe.rs
+++ b/tests/ui/doc_unsafe.rs
@@ -34,16 +34,25 @@ mod private_mod {
 
 pub use private_mod::republished;
 
-pub trait UnsafeTrait {
+pub trait SafeTraitUnsafeMethods {
     unsafe fn woefully_underdocumented(self);
 
     /// # Safety
     unsafe fn at_least_somewhat_documented(self);
 }
 
+pub unsafe trait UnsafeTrait {
+    fn method();
+}
+
+/// # Safety
+pub unsafe trait DocumentedUnsafeTrait {
+    fn method2();
+}
+
 pub struct Struct;
 
-impl UnsafeTrait for Struct {
+impl SafeTraitUnsafeMethods for Struct {
     unsafe fn woefully_underdocumented(self) {
         // all is well
     }
@@ -53,6 +62,14 @@ impl UnsafeTrait for Struct {
     }
 }
 
+unsafe impl UnsafeTrait for Struct {
+    fn method() {}
+}
+
+unsafe impl DocumentedUnsafeTrait for Struct {
+    fn method2() {}
+}
+
 impl Struct {
     pub unsafe fn more_undocumented_unsafe() -> Self {
         unimplemented!();
diff --git a/tests/ui/doc_unsafe.stderr b/tests/ui/doc_unsafe.stderr
index 73b53f3431e..d540abd1262 100644
--- a/tests/ui/doc_unsafe.stderr
+++ b/tests/ui/doc_unsafe.stderr
@@ -22,8 +22,16 @@ error: unsafe function's docs miss `# Safety` section
 LL |     unsafe fn woefully_underdocumented(self);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
+error: unsafe trait's docs miss `# Safety` section
+  --> $DIR/doc_unsafe.rs:44:1
+   |
+LL | / pub unsafe trait UnsafeTrait {
+LL | |     fn method();
+LL | | }
+   | |_^
+
 error: unsafe function's docs miss `# Safety` section
-  --> $DIR/doc_unsafe.rs:57:5
+  --> $DIR/doc_unsafe.rs:74:5
    |
 LL | /     pub unsafe fn more_undocumented_unsafe() -> Self {
 LL | |         unimplemented!();
@@ -31,7 +39,7 @@ LL | |     }
    | |_____^
 
 error: unsafe function's docs miss `# Safety` section
-  --> $DIR/doc_unsafe.rs:73:9
+  --> $DIR/doc_unsafe.rs:90:9
    |
 LL | /         pub unsafe fn whee() {
 LL | |             unimplemented!()
@@ -43,5 +51,5 @@ LL |   very_unsafe!();
    |
    = note: this error originates in the macro `very_unsafe` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to 5 previous errors
+error: aborting due to 6 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From ec38746b4ab7c69b2bc18f690875afc604e3329a Mon Sep 17 00:00:00 2001
From: flip1995 <philipp.krones@embecosm.com>
Date: Tue, 28 Sep 2021 10:53:11 +0100
Subject: Allow internal lint INVALID_PATHS for itertools path

Since clippy_utils doesn't depend on the itertools crate anymore, the
lint can't find the path.
---
 clippy_lints/src/utils/internal_lints.rs | 2 +-
 clippy_utils/src/paths.rs                | 1 +
 tests/ui-internal/invalid_paths.stderr   | 2 +-
 3 files changed, 3 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs
index b132bf93b5b..a626e4f2a33 100644
--- a/clippy_lints/src/utils/internal_lints.rs
+++ b/clippy_lints/src/utils/internal_lints.rs
@@ -892,7 +892,7 @@ impl<'tcx> LateLintPass<'tcx> for InvalidPaths {
                 }).collect();
             if !check_path(cx, &path[..]);
             then {
-                span_lint(cx, CLIPPY_LINTS_INTERNAL, item.span, "invalid path");
+                span_lint(cx, INVALID_PATHS, item.span, "invalid path");
             }
         }
     }
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index 80be4350c3c..7a8208c12c0 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -68,6 +68,7 @@ pub const IO_WRITE: [&str; 3] = ["std", "io", "Write"];
 pub const IPADDR_V4: [&str; 5] = ["std", "net", "ip", "IpAddr", "V4"];
 pub const IPADDR_V6: [&str; 5] = ["std", "net", "ip", "IpAddr", "V6"];
 pub const ITER_REPEAT: [&str; 5] = ["core", "iter", "sources", "repeat", "repeat"];
+#[allow(clippy::invalid_paths)] // internal lints do not know about all external crates
 pub const ITERTOOLS_NEXT_TUPLE: [&str; 3] = ["itertools", "Itertools", "next_tuple"];
 #[cfg(feature = "internal-lints")]
 pub const KW_MODULE: [&str; 3] = ["rustc_span", "symbol", "kw"];
diff --git a/tests/ui-internal/invalid_paths.stderr b/tests/ui-internal/invalid_paths.stderr
index bd69d661b71..20aa81b98a0 100644
--- a/tests/ui-internal/invalid_paths.stderr
+++ b/tests/ui-internal/invalid_paths.stderr
@@ -4,7 +4,7 @@ error: invalid path
 LL |     pub const BAD_CRATE_PATH: [&str; 2] = ["bad", "path"];
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = note: `-D clippy::clippy-lints-internal` implied by `-D warnings`
+   = note: `-D clippy::invalid-paths` implied by `-D warnings`
 
 error: invalid path
   --> $DIR/invalid_paths.rs:20:5
-- 
cgit 1.4.1-3-g733a5


From 53c534d11b289c8587128929306ad50cd3fe02f9 Mon Sep 17 00:00:00 2001
From: Manish Goregaokar <manishsmail@gmail.com>
Date: Tue, 28 Sep 2021 09:37:11 -0700
Subject: Update clippy_lints/src/doc.rs

Co-authored-by: Cameron Steffen <cam.steffen94@gmail.com>
---
 clippy_lints/src/doc.rs    | 2 +-
 tests/ui/doc_unsafe.stderr | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/doc.rs b/clippy_lints/src/doc.rs
index 0a9edfd7334..ce540c38478 100644
--- a/clippy_lints/src/doc.rs
+++ b/clippy_lints/src/doc.rs
@@ -242,7 +242,7 @@ impl<'tcx> LateLintPass<'tcx> for DocMarkdown {
                         cx,
                         MISSING_SAFETY_DOC,
                         item.span,
-                        "unsafe trait's docs miss `# Safety` section",
+                        "docs for unsafe trait missing `# Safety` section",
                     );
                 }
             },
diff --git a/tests/ui/doc_unsafe.stderr b/tests/ui/doc_unsafe.stderr
index d540abd1262..34ca37a6efd 100644
--- a/tests/ui/doc_unsafe.stderr
+++ b/tests/ui/doc_unsafe.stderr
@@ -22,7 +22,7 @@ error: unsafe function's docs miss `# Safety` section
 LL |     unsafe fn woefully_underdocumented(self);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: unsafe trait's docs miss `# Safety` section
+error: docs for unsafe trait missing `# Safety` section
   --> $DIR/doc_unsafe.rs:44:1
    |
 LL | / pub unsafe trait UnsafeTrait {
-- 
cgit 1.4.1-3-g733a5


From d8f453d0218a384fb34cb82c4cf8de6284a6221c Mon Sep 17 00:00:00 2001
From: flip1995 <philipp.krones@embecosm.com>
Date: Tue, 28 Sep 2021 10:54:04 +0100
Subject: Bump nightly version -> 2021-09-28

---
 clippy_lints/src/lib.rs | 2 +-
 rust-toolchain          | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 792d4c7be53..2b61340769e 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1961,7 +1961,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(empty_enum::EmptyEnum));
     store.register_late_pass(|| Box::new(absurd_extreme_comparisons::AbsurdExtremeComparisons));
     store.register_late_pass(|| Box::new(invalid_upcast_comparisons::InvalidUpcastComparisons));
-    store.register_late_pass(|| Box::new(regex::Regex::default()));
+    store.register_late_pass(|| Box::new(regex::Regex));
     store.register_late_pass(|| Box::new(copies::CopyAndPaste));
     store.register_late_pass(|| Box::new(copy_iterator::CopyIterator));
     store.register_late_pass(|| Box::new(format::UselessFormat));
diff --git a/rust-toolchain b/rust-toolchain
index 92bde3423a2..660401ff28c 100644
--- a/rust-toolchain
+++ b/rust-toolchain
@@ -1,3 +1,3 @@
 [toolchain]
-channel = "nightly-2021-09-08"
+channel = "nightly-2021-09-28"
 components = ["llvm-tools-preview", "rustc-dev", "rust-src"]
-- 
cgit 1.4.1-3-g733a5


From c2b8882cef03ed7813ac4e3162c3c3e22869f618 Mon Sep 17 00:00:00 2001
From: flip1995 <philipp.krones@embecosm.com>
Date: Tue, 28 Sep 2021 17:40:06 +0100
Subject: Cleanup of rustup changes

---
 clippy_lints/src/regex.rs                | 7 ++-----
 clippy_lints/src/utils/internal_lints.rs | 7 ++++++-
 2 files changed, 8 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/regex.rs b/clippy_lints/src/regex.rs
index 947c25ac880..5d08aee1e5f 100644
--- a/clippy_lints/src/regex.rs
+++ b/clippy_lints/src/regex.rs
@@ -5,7 +5,7 @@ use if_chain::if_chain;
 use rustc_ast::ast::{LitKind, StrStyle};
 use rustc_hir::{BorrowKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::{BytePos, Span};
 use std::convert::TryFrom;
 
@@ -51,10 +51,7 @@ declare_clippy_lint! {
     "trivial regular expressions"
 }
 
-#[derive(Clone, Default)]
-pub struct Regex {}
-
-impl_lint_pass!(Regex => [INVALID_REGEX, TRIVIAL_REGEX]);
+declare_lint_pass!(Regex => [INVALID_REGEX, TRIVIAL_REGEX]);
 
 impl<'tcx> LateLintPass<'tcx> for Regex {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs
index a626e4f2a33..3e2a4e9748d 100644
--- a/clippy_lints/src/utils/internal_lints.rs
+++ b/clippy_lints/src/utils/internal_lints.rs
@@ -1222,5 +1222,10 @@ fn if_chain_local_span(cx: &LateContext<'_>, local: &Local<'_>, if_chain_span: S
     let sm = cx.sess().source_map();
     let span = sm.span_extend_to_prev_str(span, "let", false);
     let span = sm.span_extend_to_next_char(span, ';', false);
-    Span::new(span.lo() - BytePos(3), span.hi() + BytePos(1), span.ctxt(), None)
+    Span::new(
+        span.lo() - BytePos(3),
+        span.hi() + BytePos(1),
+        span.ctxt(),
+        span.parent(),
+    )
 }
-- 
cgit 1.4.1-3-g733a5


From 30ea0a5ebb2694dbb70c18dfb1fccfe95b191001 Mon Sep 17 00:00:00 2001
From: vxpm <59714841+vxpm@users.noreply.github.com>
Date: Tue, 28 Sep 2021 17:53:12 -0300
Subject: Fix typo ("asynx" corrected to "async")

---
 clippy_lints/src/await_holding_invalid.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/await_holding_invalid.rs b/clippy_lints/src/await_holding_invalid.rs
index 0cc79c8b6e8..28615b9217c 100644
--- a/clippy_lints/src/await_holding_invalid.rs
+++ b/clippy_lints/src/await_holding_invalid.rs
@@ -16,7 +16,7 @@ declare_clippy_lint! {
     /// The Mutex types found in std::sync and parking_lot
     /// are not designed to operate in an async context across await points.
     ///
-    /// There are two potential solutions. One is to use an asynx-aware Mutex
+    /// There are two potential solutions. One is to use an async-aware Mutex
     /// type. Many asynchronous foundation crates provide such a Mutex type. The
     /// other solution is to ensure the mutex is unlocked before calling await,
     /// either by introducing a scope or an explicit call to Drop::drop.
-- 
cgit 1.4.1-3-g733a5


From 50ea37061937acf9c912e0088ce48783926562a1 Mon Sep 17 00:00:00 2001
From: Michael Wright <mikerite@lavabit.com>
Date: Sat, 18 Sep 2021 06:43:39 +0200
Subject: Move code generated by `update_lints` to includes

---
 clippy_dev/src/lib.rs                        |   68 +-
 clippy_dev/src/update_lints.rs               |  116 +-
 clippy_lints/src/lib.deprecated.rs           |   70 ++
 clippy_lints/src/lib.mods.rs                 |  232 ++++
 clippy_lints/src/lib.register_all.rs         |  304 +++++
 clippy_lints/src/lib.register_cargo.rs       |   11 +
 clippy_lints/src/lib.register_complexity.rs  |   94 ++
 clippy_lints/src/lib.register_correctness.rs |   73 ++
 clippy_lints/src/lib.register_internal.rs    |   18 +
 clippy_lints/src/lib.register_lints.rs       |  508 ++++++++
 clippy_lints/src/lib.register_nursery.rs     |   28 +
 clippy_lints/src/lib.register_pedantic.rs    |  101 ++
 clippy_lints/src/lib.register_perf.rs        |   27 +
 clippy_lints/src/lib.register_restriction.rs |   64 +
 clippy_lints/src/lib.register_style.rs       |  114 ++
 clippy_lints/src/lib.register_suspicious.rs  |   20 +
 clippy_lints/src/lib.rs                      | 1637 +-------------------------
 17 files changed, 1779 insertions(+), 1706 deletions(-)
 create mode 100644 clippy_lints/src/lib.deprecated.rs
 create mode 100644 clippy_lints/src/lib.mods.rs
 create mode 100644 clippy_lints/src/lib.register_all.rs
 create mode 100644 clippy_lints/src/lib.register_cargo.rs
 create mode 100644 clippy_lints/src/lib.register_complexity.rs
 create mode 100644 clippy_lints/src/lib.register_correctness.rs
 create mode 100644 clippy_lints/src/lib.register_internal.rs
 create mode 100644 clippy_lints/src/lib.register_lints.rs
 create mode 100644 clippy_lints/src/lib.register_nursery.rs
 create mode 100644 clippy_lints/src/lib.register_pedantic.rs
 create mode 100644 clippy_lints/src/lib.register_perf.rs
 create mode 100644 clippy_lints/src/lib.register_restriction.rs
 create mode 100644 clippy_lints/src/lib.register_style.rs
 create mode 100644 clippy_lints/src/lib.register_suspicious.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_dev/src/lib.rs b/clippy_dev/src/lib.rs
index e05db7af586..8f0356c028b 100644
--- a/clippy_dev/src/lib.rs
+++ b/clippy_dev/src/lib.rs
@@ -100,11 +100,24 @@ impl Lint {
 
 /// Generates the Vec items for `register_lint_group` calls in `clippy_lints/src/lib.rs`.
 #[must_use]
-pub fn gen_lint_group_list<'a>(lints: impl Iterator<Item = &'a Lint>) -> Vec<String> {
-    lints
-        .map(|l| format!("        LintId::of({}::{}),", l.module, l.name.to_uppercase()))
-        .sorted()
-        .collect::<Vec<String>>()
+pub fn gen_lint_group_list<'a>(group_name: &str, lints: impl Iterator<Item = &'a Lint>) -> Vec<String> {
+    let header = format!(
+        r#"store.register_group(true, "clippy::{0}", Some("clippy_{0}"), vec!["#,
+        group_name
+    );
+    let footer = "])".to_string();
+
+    let mut result = vec![header];
+
+    result.extend(
+        lints
+            .map(|l| format!("LintId::of({}::{}),", l.module, l.name.to_uppercase()))
+            .sorted(),
+    );
+
+    result.push(footer);
+
+    result
 }
 
 /// Generates the `pub mod module_name` list in `clippy_lints/src/lib.rs`.
@@ -130,21 +143,22 @@ pub fn gen_changelog_lint_list<'a>(lints: impl Iterator<Item = &'a Lint>) -> Vec
 /// Generates the `register_removed` code in `./clippy_lints/src/lib.rs`.
 #[must_use]
 pub fn gen_deprecated<'a>(lints: impl Iterator<Item = &'a Lint>) -> Vec<String> {
-    lints
-        .flat_map(|l| {
-            l.deprecation
-                .clone()
-                .map(|depr_text| {
-                    vec![
-                        "    store.register_removed(".to_string(),
-                        format!("        \"clippy::{}\",", l.name),
-                        format!("        \"{}\",", depr_text),
-                        "    );".to_string(),
-                    ]
-                })
-                .expect("only deprecated lints should be passed")
-        })
-        .collect::<Vec<String>>()
+    let mut result = vec!["{".to_string()];
+    result.extend(lints.flat_map(|l| {
+        l.deprecation
+            .clone()
+            .map(|depr_text| {
+                vec![
+                    "    store.register_removed(".to_string(),
+                    format!("        \"clippy::{}\",", l.name),
+                    format!("        \"{}\",", depr_text),
+                    "    );".to_string(),
+                ]
+            })
+            .expect("only deprecated lints should be passed")
+    }));
+    result.push("}".to_string());
+    result
 }
 
 #[must_use]
@@ -153,7 +167,7 @@ pub fn gen_register_lint_list<'a>(
     usable_lints: impl Iterator<Item = &'a Lint>,
 ) -> Vec<String> {
     let header = "    store.register_lints(&[".to_string();
-    let footer = "    ]);".to_string();
+    let footer = "    ])".to_string();
     let internal_lints = internal_lints
         .sorted_by_key(|l| format!("        {}::{},", l.module, l.name.to_uppercase()))
         .map(|l| {
@@ -511,6 +525,7 @@ fn test_gen_deprecated() {
         ),
     ];
     let expected: Vec<String> = vec![
+        "{",
         "    store.register_removed(",
         "        \"clippy::should_assert_eq\",",
         "        \"has been superseded by should_assert_eq2\",",
@@ -519,6 +534,7 @@ fn test_gen_deprecated() {
         "        \"clippy::another_deprecated\",",
         "        \"will be removed\",",
         "    );",
+        "}",
     ]
     .into_iter()
     .map(String::from)
@@ -551,9 +567,11 @@ fn test_gen_lint_group_list() {
         Lint::new("internal", "internal_style", "abc", None, "module_name"),
     ];
     let expected = vec![
-        "        LintId::of(module_name::ABC),".to_string(),
-        "        LintId::of(module_name::INTERNAL),".to_string(),
-        "        LintId::of(module_name::SHOULD_ASSERT_EQ),".to_string(),
+        "store.register_group(true, \"clippy::group1\", Some(\"clippy_group1\"), vec![",
+        "LintId::of(module_name::ABC),",
+        "LintId::of(module_name::INTERNAL),",
+        "LintId::of(module_name::SHOULD_ASSERT_EQ),",
+        "])",
     ];
-    assert_eq!(expected, gen_lint_group_list(lints.iter()));
+    assert_eq!(expected, gen_lint_group_list("group1", lints.iter()));
 }
diff --git a/clippy_dev/src/update_lints.rs b/clippy_dev/src/update_lints.rs
index db467c26f15..ba550d492fc 100644
--- a/clippy_dev/src/update_lints.rs
+++ b/clippy_dev/src/update_lints.rs
@@ -2,6 +2,7 @@ use crate::{
     gather_all, gen_changelog_lint_list, gen_deprecated, gen_lint_group_list, gen_modules_list, gen_register_lint_list,
     replace_region_in_file, Lint, DOCS_LINK,
 };
+use std::fs;
 use std::path::Path;
 
 #[derive(Clone, Copy, PartialEq)]
@@ -10,6 +11,15 @@ pub enum UpdateMode {
     Change,
 }
 
+/// Runs the `update_lints` command.
+///
+/// This updates various generated values from the lint source code.
+///
+/// `update_mode` indicates if the files should be updated or if updates should be checked for.
+///
+/// # Panics
+///
+/// Panics if a file path could not read from or then written to
 #[allow(clippy::too_many_lines)]
 pub fn run(update_mode: UpdateMode) {
     let lint_list: Vec<Lint> = gather_all().collect();
@@ -52,45 +62,18 @@ pub fn run(update_mode: UpdateMode) {
     )
     .changed;
 
-    file_change |= replace_region_in_file(
-        Path::new("clippy_lints/src/lib.rs"),
-        "begin deprecated lints",
-        "end deprecated lints",
-        false,
-        update_mode == UpdateMode::Change,
-        || gen_deprecated(deprecated_lints.iter()),
-    )
-    .changed;
-
-    file_change |= replace_region_in_file(
-        Path::new("clippy_lints/src/lib.rs"),
-        "begin register lints",
-        "end register lints",
-        false,
-        update_mode == UpdateMode::Change,
-        || gen_register_lint_list(internal_lints.iter(), usable_lints.iter()),
-    )
-    .changed;
-
-    file_change |= replace_region_in_file(
-        Path::new("clippy_lints/src/lib.rs"),
-        "begin lints modules",
-        "end lints modules",
-        false,
-        update_mode == UpdateMode::Change,
-        || gen_modules_list(usable_lints.iter()),
-    )
-    .changed;
+    if file_change && update_mode == UpdateMode::Check {
+        exit_with_failure();
+    }
 
-    // Generate lists of lints in the clippy::all lint group
-    file_change |= replace_region_in_file(
-        Path::new("clippy_lints/src/lib.rs"),
-        r#"store.register_group\(true, "clippy::all""#,
-        r#"\]\);"#,
-        false,
-        update_mode == UpdateMode::Change,
-        || {
-            // clippy::all should only include the following lint groups:
+    for (name, lines) in [
+        ("mods", gen_modules_list(usable_lints.iter())),
+        ("deprecated", gen_deprecated(deprecated_lints.iter())),
+        (
+            "register_lints",
+            gen_register_lint_list(internal_lints.iter(), usable_lints.iter()),
+        ),
+        ("register_all", {
             let all_group_lints = usable_lints.iter().filter(|l| {
                 matches!(
                     &*l.group,
@@ -98,30 +81,18 @@ pub fn run(update_mode: UpdateMode) {
                 )
             });
 
-            gen_lint_group_list(all_group_lints)
-        },
-    )
-    .changed;
-
-    // Generate the list of lints for all other lint groups
-    for (lint_group, lints) in Lint::by_lint_group(usable_lints.into_iter().chain(internal_lints)) {
-        file_change |= replace_region_in_file(
-            Path::new("clippy_lints/src/lib.rs"),
-            &format!("store.register_group\\(true, \"clippy::{}\"", lint_group),
-            r#"\]\);"#,
-            false,
-            update_mode == UpdateMode::Change,
-            || gen_lint_group_list(lints.iter()),
-        )
-        .changed;
+            gen_lint_group_list("all", all_group_lints)
+        }),
+    ] {
+        process_file(&format!("clippy_lints/src/lib.{}.rs", name), update_mode, &lines[..]);
     }
 
-    if update_mode == UpdateMode::Check && file_change {
-        println!(
-            "Not all lints defined properly. \
-             Please run `cargo dev update_lints` to make sure all lints are defined properly."
+    for (lint_group, lints) in Lint::by_lint_group(usable_lints.into_iter().chain(internal_lints)) {
+        process_file(
+            &format!("clippy_lints/src/lib.register_{}.rs", lint_group),
+            update_mode,
+            &gen_lint_group_list(&lints.get(0).expect("group non-empty").group, lints.iter())[..],
         );
-        std::process::exit(1);
     }
 }
 
@@ -150,3 +121,30 @@ pub fn print_lints() {
 fn round_to_fifty(count: usize) -> usize {
     count / 50 * 50
 }
+
+fn process_file(path: impl AsRef<Path>, update_mode: UpdateMode, new_lines: &[String]) {
+    let mut new_content = "// This file was generated by `cargo dev update_lints`.\n\
+                       // Use that command to update this file and do not edit by hand.\n\
+                       // Manual edits will be overwritten.\n\n"
+        .to_string();
+    new_content.push_str(&new_lines.join("\n"));
+
+    if update_mode == UpdateMode::Check {
+        let old_content =
+            fs::read_to_string(&path).unwrap_or_else(|e| panic!("Cannot read from {}: {}", path.as_ref().display(), e));
+        if new_content != old_content {
+            exit_with_failure();
+        }
+    } else {
+        fs::write(&path, new_content.as_bytes())
+            .unwrap_or_else(|e| panic!("Cannot write to {}: {}", path.as_ref().display(), e));
+    }
+}
+
+fn exit_with_failure() {
+    println!(
+        "Not all lints defined properly. \
+                 Please run `cargo dev update_lints` to make sure all lints are defined properly."
+    );
+    std::process::exit(1);
+}
diff --git a/clippy_lints/src/lib.deprecated.rs b/clippy_lints/src/lib.deprecated.rs
new file mode 100644
index 00000000000..f5134a0a80a
--- /dev/null
+++ b/clippy_lints/src/lib.deprecated.rs
@@ -0,0 +1,70 @@
+// This file was generated by `cargo dev update_lints`.
+// Use that command to update this file and do not edit by hand.
+// Manual edits will be overwritten.
+
+{
+    store.register_removed(
+        "clippy::should_assert_eq",
+        "`assert!()` will be more flexible with RFC 2011",
+    );
+    store.register_removed(
+        "clippy::extend_from_slice",
+        "`.extend_from_slice(_)` is a faster way to extend a Vec by a slice",
+    );
+    store.register_removed(
+        "clippy::range_step_by_zero",
+        "`iterator.step_by(0)` panics nowadays",
+    );
+    store.register_removed(
+        "clippy::unstable_as_slice",
+        "`Vec::as_slice` has been stabilized in 1.7",
+    );
+    store.register_removed(
+        "clippy::unstable_as_mut_slice",
+        "`Vec::as_mut_slice` has been stabilized in 1.7",
+    );
+    store.register_removed(
+        "clippy::misaligned_transmute",
+        "this lint has been split into cast_ptr_alignment and transmute_ptr_to_ptr",
+    );
+    store.register_removed(
+        "clippy::assign_ops",
+        "using compound assignment operators (e.g., `+=`) is harmless",
+    );
+    store.register_removed(
+        "clippy::if_let_redundant_pattern_matching",
+        "this lint has been changed to redundant_pattern_matching",
+    );
+    store.register_removed(
+        "clippy::unsafe_vector_initialization",
+        "the replacement suggested by this lint had substantially different behavior",
+    );
+    store.register_removed(
+        "clippy::unused_collect",
+        "`collect` has been marked as #[must_use] in rustc and that covers all cases of this lint",
+    );
+    store.register_removed(
+        "clippy::replace_consts",
+        "associated-constants `MIN`/`MAX` of integers are preferred to `{min,max}_value()` and module constants",
+    );
+    store.register_removed(
+        "clippy::regex_macro",
+        "the regex! macro has been removed from the regex crate in 2018",
+    );
+    store.register_removed(
+        "clippy::find_map",
+        "this lint has been replaced by `manual_find_map`, a more specific lint",
+    );
+    store.register_removed(
+        "clippy::filter_map",
+        "this lint has been replaced by `manual_filter_map`, a more specific lint",
+    );
+    store.register_removed(
+        "clippy::pub_enum_variant_names",
+        "set the `avoid-breaking-exported-api` config option to `false` to enable the `enum_variant_names` lint for public items",
+    );
+    store.register_removed(
+        "clippy::wrong_pub_self_convention",
+        "set the `avoid-breaking-exported-api` config option to `false` to enable the `wrong_self_convention` lint for public items",
+    );
+}
\ No newline at end of file
diff --git a/clippy_lints/src/lib.mods.rs b/clippy_lints/src/lib.mods.rs
new file mode 100644
index 00000000000..49f445c3531
--- /dev/null
+++ b/clippy_lints/src/lib.mods.rs
@@ -0,0 +1,232 @@
+// This file was generated by `cargo dev update_lints`.
+// Use that command to update this file and do not edit by hand.
+// Manual edits will be overwritten.
+
+mod absurd_extreme_comparisons;
+mod approx_const;
+mod arithmetic;
+mod as_conversions;
+mod asm_syntax;
+mod assertions_on_constants;
+mod assign_ops;
+mod async_yields_async;
+mod attrs;
+mod await_holding_invalid;
+mod bit_mask;
+mod blacklisted_name;
+mod blocks_in_if_conditions;
+mod bool_assert_comparison;
+mod booleans;
+mod bytecount;
+mod cargo_common_metadata;
+mod case_sensitive_file_extension_comparisons;
+mod casts;
+mod checked_conversions;
+mod cognitive_complexity;
+mod collapsible_if;
+mod collapsible_match;
+mod comparison_chain;
+mod copies;
+mod copy_iterator;
+mod create_dir;
+mod dbg_macro;
+mod default;
+mod default_numeric_fallback;
+mod dereference;
+mod derivable_impls;
+mod derive;
+mod disallowed_method;
+mod disallowed_script_idents;
+mod disallowed_type;
+mod doc;
+mod double_comparison;
+mod double_parens;
+mod drop_forget_ref;
+mod duration_subsec;
+mod else_if_without_else;
+mod empty_enum;
+mod entry;
+mod enum_clike;
+mod enum_variants;
+mod eq_op;
+mod erasing_op;
+mod escape;
+mod eta_reduction;
+mod eval_order_dependence;
+mod excessive_bools;
+mod exhaustive_items;
+mod exit;
+mod explicit_write;
+mod fallible_impl_from;
+mod feature_name;
+mod float_equality_without_abs;
+mod float_literal;
+mod floating_point_arithmetic;
+mod format;
+mod formatting;
+mod from_over_into;
+mod from_str_radix_10;
+mod functions;
+mod future_not_send;
+mod get_last_with_len;
+mod identity_op;
+mod if_let_mutex;
+mod if_not_else;
+mod if_then_panic;
+mod if_then_some_else_none;
+mod implicit_hasher;
+mod implicit_return;
+mod implicit_saturating_sub;
+mod inconsistent_struct_constructor;
+mod indexing_slicing;
+mod infinite_iter;
+mod inherent_impl;
+mod inherent_to_string;
+mod inline_fn_without_body;
+mod int_plus_one;
+mod integer_division;
+mod invalid_upcast_comparisons;
+mod items_after_statements;
+mod iter_not_returning_iterator;
+mod large_const_arrays;
+mod large_enum_variant;
+mod large_stack_arrays;
+mod len_zero;
+mod let_if_seq;
+mod let_underscore;
+mod lifetimes;
+mod literal_representation;
+mod loops;
+mod macro_use;
+mod main_recursion;
+mod manual_async_fn;
+mod manual_map;
+mod manual_non_exhaustive;
+mod manual_ok_or;
+mod manual_strip;
+mod manual_unwrap_or;
+mod map_clone;
+mod map_err_ignore;
+mod map_unit_fn;
+mod match_on_vec_items;
+mod match_result_ok;
+mod matches;
+mod mem_discriminant;
+mod mem_forget;
+mod mem_replace;
+mod methods;
+mod minmax;
+mod misc;
+mod misc_early;
+mod missing_const_for_fn;
+mod missing_doc;
+mod missing_enforced_import_rename;
+mod missing_inline;
+mod module_style;
+mod modulo_arithmetic;
+mod multiple_crate_versions;
+mod mut_key;
+mod mut_mut;
+mod mut_mutex_lock;
+mod mut_reference;
+mod mutable_debug_assertion;
+mod mutex_atomic;
+mod needless_arbitrary_self_type;
+mod needless_bitwise_bool;
+mod needless_bool;
+mod needless_borrow;
+mod needless_borrowed_ref;
+mod needless_continue;
+mod needless_for_each;
+mod needless_option_as_deref;
+mod needless_pass_by_value;
+mod needless_question_mark;
+mod needless_update;
+mod neg_cmp_op_on_partial_ord;
+mod neg_multiply;
+mod new_without_default;
+mod no_effect;
+mod non_copy_const;
+mod non_expressive_names;
+mod non_octal_unix_permissions;
+mod nonstandard_macro_braces;
+mod open_options;
+mod option_env_unwrap;
+mod option_if_let_else;
+mod overflow_check_conditional;
+mod panic_in_result_fn;
+mod panic_unimplemented;
+mod partialeq_ne_impl;
+mod pass_by_ref_or_value;
+mod path_buf_push_overwrite;
+mod pattern_type_mismatch;
+mod precedence;
+mod ptr;
+mod ptr_eq;
+mod ptr_offset_with_cast;
+mod question_mark;
+mod ranges;
+mod redundant_clone;
+mod redundant_closure_call;
+mod redundant_else;
+mod redundant_field_names;
+mod redundant_pub_crate;
+mod redundant_slicing;
+mod redundant_static_lifetimes;
+mod ref_option_ref;
+mod reference;
+mod regex;
+mod repeat_once;
+mod returns;
+mod same_name_method;
+mod self_assignment;
+mod self_named_constructors;
+mod semicolon_if_nothing_returned;
+mod serde_api;
+mod shadow;
+mod single_component_path_imports;
+mod size_of_in_element_count;
+mod slow_vector_initialization;
+mod stable_sort_primitive;
+mod strings;
+mod strlen_on_c_strings;
+mod suspicious_operation_groupings;
+mod suspicious_trait_impl;
+mod swap;
+mod tabs_in_doc_comments;
+mod temporary_assignment;
+mod to_digit_is_some;
+mod to_string_in_display;
+mod trait_bounds;
+mod transmute;
+mod transmuting_null;
+mod try_err;
+mod types;
+mod undropped_manually_drops;
+mod unicode;
+mod unit_return_expecting_ord;
+mod unit_types;
+mod unnamed_address;
+mod unnecessary_self_imports;
+mod unnecessary_sort_by;
+mod unnecessary_wraps;
+mod unnested_or_patterns;
+mod unsafe_removed_from_name;
+mod unused_async;
+mod unused_io_amount;
+mod unused_self;
+mod unused_unit;
+mod unwrap;
+mod unwrap_in_result;
+mod upper_case_acronyms;
+mod use_self;
+mod useless_conversion;
+mod vec;
+mod vec_init_then_push;
+mod vec_resize_to_zero;
+mod verbose_file_reads;
+mod wildcard_dependencies;
+mod wildcard_imports;
+mod write;
+mod zero_div_zero;
+mod zero_sized_map_values;
\ No newline at end of file
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
new file mode 100644
index 00000000000..7a77303b834
--- /dev/null
+++ b/clippy_lints/src/lib.register_all.rs
@@ -0,0 +1,304 @@
+// This file was generated by `cargo dev update_lints`.
+// Use that command to update this file and do not edit by hand.
+// Manual edits will be overwritten.
+
+store.register_group(true, "clippy::all", Some("clippy_all"), vec![
+LintId::of(absurd_extreme_comparisons::ABSURD_EXTREME_COMPARISONS),
+LintId::of(approx_const::APPROX_CONSTANT),
+LintId::of(assertions_on_constants::ASSERTIONS_ON_CONSTANTS),
+LintId::of(assign_ops::ASSIGN_OP_PATTERN),
+LintId::of(assign_ops::MISREFACTORED_ASSIGN_OP),
+LintId::of(async_yields_async::ASYNC_YIELDS_ASYNC),
+LintId::of(attrs::BLANKET_CLIPPY_RESTRICTION_LINTS),
+LintId::of(attrs::DEPRECATED_CFG_ATTR),
+LintId::of(attrs::DEPRECATED_SEMVER),
+LintId::of(attrs::MISMATCHED_TARGET_OS),
+LintId::of(attrs::USELESS_ATTRIBUTE),
+LintId::of(bit_mask::BAD_BIT_MASK),
+LintId::of(bit_mask::INEFFECTIVE_BIT_MASK),
+LintId::of(blacklisted_name::BLACKLISTED_NAME),
+LintId::of(blocks_in_if_conditions::BLOCKS_IN_IF_CONDITIONS),
+LintId::of(bool_assert_comparison::BOOL_ASSERT_COMPARISON),
+LintId::of(booleans::LOGIC_BUG),
+LintId::of(booleans::NONMINIMAL_BOOL),
+LintId::of(casts::CAST_REF_TO_MUT),
+LintId::of(casts::CHAR_LIT_AS_U8),
+LintId::of(casts::FN_TO_NUMERIC_CAST),
+LintId::of(casts::FN_TO_NUMERIC_CAST_WITH_TRUNCATION),
+LintId::of(casts::UNNECESSARY_CAST),
+LintId::of(collapsible_if::COLLAPSIBLE_ELSE_IF),
+LintId::of(collapsible_if::COLLAPSIBLE_IF),
+LintId::of(collapsible_match::COLLAPSIBLE_MATCH),
+LintId::of(comparison_chain::COMPARISON_CHAIN),
+LintId::of(copies::IFS_SAME_COND),
+LintId::of(copies::IF_SAME_THEN_ELSE),
+LintId::of(default::FIELD_REASSIGN_WITH_DEFAULT),
+LintId::of(derivable_impls::DERIVABLE_IMPLS),
+LintId::of(derive::DERIVE_HASH_XOR_EQ),
+LintId::of(derive::DERIVE_ORD_XOR_PARTIAL_ORD),
+LintId::of(doc::MISSING_SAFETY_DOC),
+LintId::of(doc::NEEDLESS_DOCTEST_MAIN),
+LintId::of(double_comparison::DOUBLE_COMPARISONS),
+LintId::of(double_parens::DOUBLE_PARENS),
+LintId::of(drop_forget_ref::DROP_COPY),
+LintId::of(drop_forget_ref::DROP_REF),
+LintId::of(drop_forget_ref::FORGET_COPY),
+LintId::of(drop_forget_ref::FORGET_REF),
+LintId::of(duration_subsec::DURATION_SUBSEC),
+LintId::of(entry::MAP_ENTRY),
+LintId::of(enum_clike::ENUM_CLIKE_UNPORTABLE_VARIANT),
+LintId::of(enum_variants::ENUM_VARIANT_NAMES),
+LintId::of(enum_variants::MODULE_INCEPTION),
+LintId::of(eq_op::EQ_OP),
+LintId::of(eq_op::OP_REF),
+LintId::of(erasing_op::ERASING_OP),
+LintId::of(escape::BOXED_LOCAL),
+LintId::of(eta_reduction::REDUNDANT_CLOSURE),
+LintId::of(eval_order_dependence::DIVERGING_SUB_EXPRESSION),
+LintId::of(eval_order_dependence::EVAL_ORDER_DEPENDENCE),
+LintId::of(explicit_write::EXPLICIT_WRITE),
+LintId::of(float_equality_without_abs::FLOAT_EQUALITY_WITHOUT_ABS),
+LintId::of(float_literal::EXCESSIVE_PRECISION),
+LintId::of(format::USELESS_FORMAT),
+LintId::of(formatting::POSSIBLE_MISSING_COMMA),
+LintId::of(formatting::SUSPICIOUS_ASSIGNMENT_FORMATTING),
+LintId::of(formatting::SUSPICIOUS_ELSE_FORMATTING),
+LintId::of(formatting::SUSPICIOUS_UNARY_OP_FORMATTING),
+LintId::of(from_over_into::FROM_OVER_INTO),
+LintId::of(from_str_radix_10::FROM_STR_RADIX_10),
+LintId::of(functions::DOUBLE_MUST_USE),
+LintId::of(functions::MUST_USE_UNIT),
+LintId::of(functions::NOT_UNSAFE_PTR_ARG_DEREF),
+LintId::of(functions::RESULT_UNIT_ERR),
+LintId::of(functions::TOO_MANY_ARGUMENTS),
+LintId::of(get_last_with_len::GET_LAST_WITH_LEN),
+LintId::of(identity_op::IDENTITY_OP),
+LintId::of(if_let_mutex::IF_LET_MUTEX),
+LintId::of(if_then_panic::IF_THEN_PANIC),
+LintId::of(indexing_slicing::OUT_OF_BOUNDS_INDEXING),
+LintId::of(infinite_iter::INFINITE_ITER),
+LintId::of(inherent_to_string::INHERENT_TO_STRING),
+LintId::of(inherent_to_string::INHERENT_TO_STRING_SHADOW_DISPLAY),
+LintId::of(inline_fn_without_body::INLINE_FN_WITHOUT_BODY),
+LintId::of(int_plus_one::INT_PLUS_ONE),
+LintId::of(large_const_arrays::LARGE_CONST_ARRAYS),
+LintId::of(large_enum_variant::LARGE_ENUM_VARIANT),
+LintId::of(len_zero::COMPARISON_TO_EMPTY),
+LintId::of(len_zero::LEN_WITHOUT_IS_EMPTY),
+LintId::of(len_zero::LEN_ZERO),
+LintId::of(let_underscore::LET_UNDERSCORE_LOCK),
+LintId::of(lifetimes::EXTRA_UNUSED_LIFETIMES),
+LintId::of(lifetimes::NEEDLESS_LIFETIMES),
+LintId::of(literal_representation::INCONSISTENT_DIGIT_GROUPING),
+LintId::of(literal_representation::MISTYPED_LITERAL_SUFFIXES),
+LintId::of(literal_representation::UNUSUAL_BYTE_GROUPINGS),
+LintId::of(loops::EMPTY_LOOP),
+LintId::of(loops::EXPLICIT_COUNTER_LOOP),
+LintId::of(loops::FOR_KV_MAP),
+LintId::of(loops::FOR_LOOPS_OVER_FALLIBLES),
+LintId::of(loops::ITER_NEXT_LOOP),
+LintId::of(loops::MANUAL_FLATTEN),
+LintId::of(loops::MANUAL_MEMCPY),
+LintId::of(loops::MUT_RANGE_BOUND),
+LintId::of(loops::NEEDLESS_COLLECT),
+LintId::of(loops::NEEDLESS_RANGE_LOOP),
+LintId::of(loops::NEVER_LOOP),
+LintId::of(loops::SAME_ITEM_PUSH),
+LintId::of(loops::SINGLE_ELEMENT_LOOP),
+LintId::of(loops::WHILE_IMMUTABLE_CONDITION),
+LintId::of(loops::WHILE_LET_LOOP),
+LintId::of(loops::WHILE_LET_ON_ITERATOR),
+LintId::of(main_recursion::MAIN_RECURSION),
+LintId::of(manual_async_fn::MANUAL_ASYNC_FN),
+LintId::of(manual_map::MANUAL_MAP),
+LintId::of(manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE),
+LintId::of(manual_strip::MANUAL_STRIP),
+LintId::of(manual_unwrap_or::MANUAL_UNWRAP_OR),
+LintId::of(map_clone::MAP_CLONE),
+LintId::of(map_unit_fn::OPTION_MAP_UNIT_FN),
+LintId::of(map_unit_fn::RESULT_MAP_UNIT_FN),
+LintId::of(match_result_ok::MATCH_RESULT_OK),
+LintId::of(matches::INFALLIBLE_DESTRUCTURING_MATCH),
+LintId::of(matches::MATCH_AS_REF),
+LintId::of(matches::MATCH_LIKE_MATCHES_MACRO),
+LintId::of(matches::MATCH_OVERLAPPING_ARM),
+LintId::of(matches::MATCH_REF_PATS),
+LintId::of(matches::MATCH_SINGLE_BINDING),
+LintId::of(matches::REDUNDANT_PATTERN_MATCHING),
+LintId::of(matches::SINGLE_MATCH),
+LintId::of(matches::WILDCARD_IN_OR_PATTERNS),
+LintId::of(mem_discriminant::MEM_DISCRIMINANT_NON_ENUM),
+LintId::of(mem_replace::MEM_REPLACE_OPTION_WITH_NONE),
+LintId::of(mem_replace::MEM_REPLACE_WITH_DEFAULT),
+LintId::of(mem_replace::MEM_REPLACE_WITH_UNINIT),
+LintId::of(methods::BIND_INSTEAD_OF_MAP),
+LintId::of(methods::BYTES_NTH),
+LintId::of(methods::CHARS_LAST_CMP),
+LintId::of(methods::CHARS_NEXT_CMP),
+LintId::of(methods::CLONE_DOUBLE_REF),
+LintId::of(methods::CLONE_ON_COPY),
+LintId::of(methods::EXPECT_FUN_CALL),
+LintId::of(methods::EXTEND_WITH_DRAIN),
+LintId::of(methods::FILTER_MAP_IDENTITY),
+LintId::of(methods::FILTER_NEXT),
+LintId::of(methods::FLAT_MAP_IDENTITY),
+LintId::of(methods::INSPECT_FOR_EACH),
+LintId::of(methods::INTO_ITER_ON_REF),
+LintId::of(methods::ITERATOR_STEP_BY_ZERO),
+LintId::of(methods::ITER_CLONED_COLLECT),
+LintId::of(methods::ITER_COUNT),
+LintId::of(methods::ITER_NEXT_SLICE),
+LintId::of(methods::ITER_NTH),
+LintId::of(methods::ITER_NTH_ZERO),
+LintId::of(methods::ITER_SKIP_NEXT),
+LintId::of(methods::MANUAL_FILTER_MAP),
+LintId::of(methods::MANUAL_FIND_MAP),
+LintId::of(methods::MANUAL_SATURATING_ARITHMETIC),
+LintId::of(methods::MANUAL_SPLIT_ONCE),
+LintId::of(methods::MANUAL_STR_REPEAT),
+LintId::of(methods::MAP_COLLECT_RESULT_UNIT),
+LintId::of(methods::MAP_IDENTITY),
+LintId::of(methods::NEW_RET_NO_SELF),
+LintId::of(methods::OK_EXPECT),
+LintId::of(methods::OPTION_AS_REF_DEREF),
+LintId::of(methods::OPTION_FILTER_MAP),
+LintId::of(methods::OPTION_MAP_OR_NONE),
+LintId::of(methods::OR_FUN_CALL),
+LintId::of(methods::RESULT_MAP_OR_INTO_OPTION),
+LintId::of(methods::SEARCH_IS_SOME),
+LintId::of(methods::SHOULD_IMPLEMENT_TRAIT),
+LintId::of(methods::SINGLE_CHAR_ADD_STR),
+LintId::of(methods::SINGLE_CHAR_PATTERN),
+LintId::of(methods::SKIP_WHILE_NEXT),
+LintId::of(methods::STRING_EXTEND_CHARS),
+LintId::of(methods::SUSPICIOUS_MAP),
+LintId::of(methods::SUSPICIOUS_SPLITN),
+LintId::of(methods::UNINIT_ASSUMED_INIT),
+LintId::of(methods::UNNECESSARY_FILTER_MAP),
+LintId::of(methods::UNNECESSARY_FOLD),
+LintId::of(methods::UNNECESSARY_LAZY_EVALUATIONS),
+LintId::of(methods::UNWRAP_OR_ELSE_DEFAULT),
+LintId::of(methods::USELESS_ASREF),
+LintId::of(methods::WRONG_SELF_CONVENTION),
+LintId::of(methods::ZST_OFFSET),
+LintId::of(minmax::MIN_MAX),
+LintId::of(misc::CMP_NAN),
+LintId::of(misc::CMP_OWNED),
+LintId::of(misc::MODULO_ONE),
+LintId::of(misc::SHORT_CIRCUIT_STATEMENT),
+LintId::of(misc::TOPLEVEL_REF_ARG),
+LintId::of(misc::ZERO_PTR),
+LintId::of(misc_early::BUILTIN_TYPE_SHADOW),
+LintId::of(misc_early::DOUBLE_NEG),
+LintId::of(misc_early::DUPLICATE_UNDERSCORE_ARGUMENT),
+LintId::of(misc_early::MIXED_CASE_HEX_LITERALS),
+LintId::of(misc_early::REDUNDANT_PATTERN),
+LintId::of(misc_early::UNNEEDED_WILDCARD_PATTERN),
+LintId::of(misc_early::ZERO_PREFIXED_LITERAL),
+LintId::of(mut_key::MUTABLE_KEY_TYPE),
+LintId::of(mut_mutex_lock::MUT_MUTEX_LOCK),
+LintId::of(mut_reference::UNNECESSARY_MUT_PASSED),
+LintId::of(mutex_atomic::MUTEX_ATOMIC),
+LintId::of(needless_arbitrary_self_type::NEEDLESS_ARBITRARY_SELF_TYPE),
+LintId::of(needless_bool::BOOL_COMPARISON),
+LintId::of(needless_bool::NEEDLESS_BOOL),
+LintId::of(needless_borrow::NEEDLESS_BORROW),
+LintId::of(needless_borrowed_ref::NEEDLESS_BORROWED_REFERENCE),
+LintId::of(needless_option_as_deref::NEEDLESS_OPTION_AS_DEREF),
+LintId::of(needless_question_mark::NEEDLESS_QUESTION_MARK),
+LintId::of(needless_update::NEEDLESS_UPDATE),
+LintId::of(neg_cmp_op_on_partial_ord::NEG_CMP_OP_ON_PARTIAL_ORD),
+LintId::of(neg_multiply::NEG_MULTIPLY),
+LintId::of(new_without_default::NEW_WITHOUT_DEFAULT),
+LintId::of(no_effect::NO_EFFECT),
+LintId::of(no_effect::UNNECESSARY_OPERATION),
+LintId::of(non_copy_const::BORROW_INTERIOR_MUTABLE_CONST),
+LintId::of(non_copy_const::DECLARE_INTERIOR_MUTABLE_CONST),
+LintId::of(non_expressive_names::JUST_UNDERSCORES_AND_DIGITS),
+LintId::of(non_octal_unix_permissions::NON_OCTAL_UNIX_PERMISSIONS),
+LintId::of(open_options::NONSENSICAL_OPEN_OPTIONS),
+LintId::of(option_env_unwrap::OPTION_ENV_UNWRAP),
+LintId::of(overflow_check_conditional::OVERFLOW_CHECK_CONDITIONAL),
+LintId::of(partialeq_ne_impl::PARTIALEQ_NE_IMPL),
+LintId::of(precedence::PRECEDENCE),
+LintId::of(ptr::CMP_NULL),
+LintId::of(ptr::INVALID_NULL_PTR_USAGE),
+LintId::of(ptr::MUT_FROM_REF),
+LintId::of(ptr::PTR_ARG),
+LintId::of(ptr_eq::PTR_EQ),
+LintId::of(ptr_offset_with_cast::PTR_OFFSET_WITH_CAST),
+LintId::of(question_mark::QUESTION_MARK),
+LintId::of(ranges::MANUAL_RANGE_CONTAINS),
+LintId::of(ranges::RANGE_ZIP_WITH_LEN),
+LintId::of(ranges::REVERSED_EMPTY_RANGES),
+LintId::of(redundant_clone::REDUNDANT_CLONE),
+LintId::of(redundant_closure_call::REDUNDANT_CLOSURE_CALL),
+LintId::of(redundant_field_names::REDUNDANT_FIELD_NAMES),
+LintId::of(redundant_slicing::REDUNDANT_SLICING),
+LintId::of(redundant_static_lifetimes::REDUNDANT_STATIC_LIFETIMES),
+LintId::of(reference::DEREF_ADDROF),
+LintId::of(reference::REF_IN_DEREF),
+LintId::of(regex::INVALID_REGEX),
+LintId::of(repeat_once::REPEAT_ONCE),
+LintId::of(returns::LET_AND_RETURN),
+LintId::of(returns::NEEDLESS_RETURN),
+LintId::of(self_assignment::SELF_ASSIGNMENT),
+LintId::of(self_named_constructors::SELF_NAMED_CONSTRUCTORS),
+LintId::of(serde_api::SERDE_API_MISUSE),
+LintId::of(single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS),
+LintId::of(size_of_in_element_count::SIZE_OF_IN_ELEMENT_COUNT),
+LintId::of(slow_vector_initialization::SLOW_VECTOR_INITIALIZATION),
+LintId::of(stable_sort_primitive::STABLE_SORT_PRIMITIVE),
+LintId::of(strings::STRING_FROM_UTF8_AS_BYTES),
+LintId::of(strlen_on_c_strings::STRLEN_ON_C_STRINGS),
+LintId::of(suspicious_trait_impl::SUSPICIOUS_ARITHMETIC_IMPL),
+LintId::of(suspicious_trait_impl::SUSPICIOUS_OP_ASSIGN_IMPL),
+LintId::of(swap::ALMOST_SWAPPED),
+LintId::of(swap::MANUAL_SWAP),
+LintId::of(tabs_in_doc_comments::TABS_IN_DOC_COMMENTS),
+LintId::of(temporary_assignment::TEMPORARY_ASSIGNMENT),
+LintId::of(to_digit_is_some::TO_DIGIT_IS_SOME),
+LintId::of(to_string_in_display::TO_STRING_IN_DISPLAY),
+LintId::of(transmute::CROSSPOINTER_TRANSMUTE),
+LintId::of(transmute::TRANSMUTES_EXPRESSIBLE_AS_PTR_CASTS),
+LintId::of(transmute::TRANSMUTE_BYTES_TO_STR),
+LintId::of(transmute::TRANSMUTE_FLOAT_TO_INT),
+LintId::of(transmute::TRANSMUTE_INT_TO_BOOL),
+LintId::of(transmute::TRANSMUTE_INT_TO_CHAR),
+LintId::of(transmute::TRANSMUTE_INT_TO_FLOAT),
+LintId::of(transmute::TRANSMUTE_PTR_TO_REF),
+LintId::of(transmute::UNSOUND_COLLECTION_TRANSMUTE),
+LintId::of(transmute::WRONG_TRANSMUTE),
+LintId::of(transmuting_null::TRANSMUTING_NULL),
+LintId::of(try_err::TRY_ERR),
+LintId::of(types::BORROWED_BOX),
+LintId::of(types::BOX_COLLECTION),
+LintId::of(types::REDUNDANT_ALLOCATION),
+LintId::of(types::TYPE_COMPLEXITY),
+LintId::of(types::VEC_BOX),
+LintId::of(undropped_manually_drops::UNDROPPED_MANUALLY_DROPS),
+LintId::of(unicode::INVISIBLE_CHARACTERS),
+LintId::of(unit_return_expecting_ord::UNIT_RETURN_EXPECTING_ORD),
+LintId::of(unit_types::UNIT_ARG),
+LintId::of(unit_types::UNIT_CMP),
+LintId::of(unnamed_address::FN_ADDRESS_COMPARISONS),
+LintId::of(unnamed_address::VTABLE_ADDRESS_COMPARISONS),
+LintId::of(unnecessary_sort_by::UNNECESSARY_SORT_BY),
+LintId::of(unsafe_removed_from_name::UNSAFE_REMOVED_FROM_NAME),
+LintId::of(unused_io_amount::UNUSED_IO_AMOUNT),
+LintId::of(unused_unit::UNUSED_UNIT),
+LintId::of(unwrap::PANICKING_UNWRAP),
+LintId::of(unwrap::UNNECESSARY_UNWRAP),
+LintId::of(upper_case_acronyms::UPPER_CASE_ACRONYMS),
+LintId::of(useless_conversion::USELESS_CONVERSION),
+LintId::of(vec::USELESS_VEC),
+LintId::of(vec_init_then_push::VEC_INIT_THEN_PUSH),
+LintId::of(vec_resize_to_zero::VEC_RESIZE_TO_ZERO),
+LintId::of(write::PRINTLN_EMPTY_STRING),
+LintId::of(write::PRINT_LITERAL),
+LintId::of(write::PRINT_WITH_NEWLINE),
+LintId::of(write::WRITELN_EMPTY_STRING),
+LintId::of(write::WRITE_LITERAL),
+LintId::of(write::WRITE_WITH_NEWLINE),
+LintId::of(zero_div_zero::ZERO_DIVIDED_BY_ZERO),
+])
\ No newline at end of file
diff --git a/clippy_lints/src/lib.register_cargo.rs b/clippy_lints/src/lib.register_cargo.rs
new file mode 100644
index 00000000000..21d070728e4
--- /dev/null
+++ b/clippy_lints/src/lib.register_cargo.rs
@@ -0,0 +1,11 @@
+// This file was generated by `cargo dev update_lints`.
+// Use that command to update this file and do not edit by hand.
+// Manual edits will be overwritten.
+
+store.register_group(true, "clippy::cargo", Some("clippy_cargo"), vec![
+LintId::of(cargo_common_metadata::CARGO_COMMON_METADATA),
+LintId::of(feature_name::NEGATIVE_FEATURE_NAMES),
+LintId::of(feature_name::REDUNDANT_FEATURE_NAMES),
+LintId::of(multiple_crate_versions::MULTIPLE_CRATE_VERSIONS),
+LintId::of(wildcard_dependencies::WILDCARD_DEPENDENCIES),
+])
\ No newline at end of file
diff --git a/clippy_lints/src/lib.register_complexity.rs b/clippy_lints/src/lib.register_complexity.rs
new file mode 100644
index 00000000000..515afe54c86
--- /dev/null
+++ b/clippy_lints/src/lib.register_complexity.rs
@@ -0,0 +1,94 @@
+// This file was generated by `cargo dev update_lints`.
+// Use that command to update this file and do not edit by hand.
+// Manual edits will be overwritten.
+
+store.register_group(true, "clippy::complexity", Some("clippy_complexity"), vec![
+LintId::of(attrs::DEPRECATED_CFG_ATTR),
+LintId::of(booleans::NONMINIMAL_BOOL),
+LintId::of(casts::CHAR_LIT_AS_U8),
+LintId::of(casts::UNNECESSARY_CAST),
+LintId::of(derivable_impls::DERIVABLE_IMPLS),
+LintId::of(double_comparison::DOUBLE_COMPARISONS),
+LintId::of(double_parens::DOUBLE_PARENS),
+LintId::of(duration_subsec::DURATION_SUBSEC),
+LintId::of(eval_order_dependence::DIVERGING_SUB_EXPRESSION),
+LintId::of(explicit_write::EXPLICIT_WRITE),
+LintId::of(format::USELESS_FORMAT),
+LintId::of(functions::TOO_MANY_ARGUMENTS),
+LintId::of(get_last_with_len::GET_LAST_WITH_LEN),
+LintId::of(identity_op::IDENTITY_OP),
+LintId::of(int_plus_one::INT_PLUS_ONE),
+LintId::of(lifetimes::EXTRA_UNUSED_LIFETIMES),
+LintId::of(lifetimes::NEEDLESS_LIFETIMES),
+LintId::of(loops::EXPLICIT_COUNTER_LOOP),
+LintId::of(loops::MANUAL_FLATTEN),
+LintId::of(loops::SINGLE_ELEMENT_LOOP),
+LintId::of(loops::WHILE_LET_LOOP),
+LintId::of(manual_strip::MANUAL_STRIP),
+LintId::of(manual_unwrap_or::MANUAL_UNWRAP_OR),
+LintId::of(map_unit_fn::OPTION_MAP_UNIT_FN),
+LintId::of(map_unit_fn::RESULT_MAP_UNIT_FN),
+LintId::of(matches::MATCH_AS_REF),
+LintId::of(matches::MATCH_SINGLE_BINDING),
+LintId::of(matches::WILDCARD_IN_OR_PATTERNS),
+LintId::of(methods::BIND_INSTEAD_OF_MAP),
+LintId::of(methods::CLONE_ON_COPY),
+LintId::of(methods::FILTER_MAP_IDENTITY),
+LintId::of(methods::FILTER_NEXT),
+LintId::of(methods::FLAT_MAP_IDENTITY),
+LintId::of(methods::INSPECT_FOR_EACH),
+LintId::of(methods::ITER_COUNT),
+LintId::of(methods::MANUAL_FILTER_MAP),
+LintId::of(methods::MANUAL_FIND_MAP),
+LintId::of(methods::MANUAL_SPLIT_ONCE),
+LintId::of(methods::MAP_IDENTITY),
+LintId::of(methods::OPTION_AS_REF_DEREF),
+LintId::of(methods::OPTION_FILTER_MAP),
+LintId::of(methods::SEARCH_IS_SOME),
+LintId::of(methods::SKIP_WHILE_NEXT),
+LintId::of(methods::UNNECESSARY_FILTER_MAP),
+LintId::of(methods::USELESS_ASREF),
+LintId::of(misc::SHORT_CIRCUIT_STATEMENT),
+LintId::of(misc_early::UNNEEDED_WILDCARD_PATTERN),
+LintId::of(misc_early::ZERO_PREFIXED_LITERAL),
+LintId::of(needless_arbitrary_self_type::NEEDLESS_ARBITRARY_SELF_TYPE),
+LintId::of(needless_bool::BOOL_COMPARISON),
+LintId::of(needless_bool::NEEDLESS_BOOL),
+LintId::of(needless_borrowed_ref::NEEDLESS_BORROWED_REFERENCE),
+LintId::of(needless_option_as_deref::NEEDLESS_OPTION_AS_DEREF),
+LintId::of(needless_question_mark::NEEDLESS_QUESTION_MARK),
+LintId::of(needless_update::NEEDLESS_UPDATE),
+LintId::of(neg_cmp_op_on_partial_ord::NEG_CMP_OP_ON_PARTIAL_ORD),
+LintId::of(no_effect::NO_EFFECT),
+LintId::of(no_effect::UNNECESSARY_OPERATION),
+LintId::of(overflow_check_conditional::OVERFLOW_CHECK_CONDITIONAL),
+LintId::of(partialeq_ne_impl::PARTIALEQ_NE_IMPL),
+LintId::of(precedence::PRECEDENCE),
+LintId::of(ptr_offset_with_cast::PTR_OFFSET_WITH_CAST),
+LintId::of(ranges::RANGE_ZIP_WITH_LEN),
+LintId::of(redundant_closure_call::REDUNDANT_CLOSURE_CALL),
+LintId::of(redundant_slicing::REDUNDANT_SLICING),
+LintId::of(reference::DEREF_ADDROF),
+LintId::of(reference::REF_IN_DEREF),
+LintId::of(repeat_once::REPEAT_ONCE),
+LintId::of(strings::STRING_FROM_UTF8_AS_BYTES),
+LintId::of(strlen_on_c_strings::STRLEN_ON_C_STRINGS),
+LintId::of(swap::MANUAL_SWAP),
+LintId::of(temporary_assignment::TEMPORARY_ASSIGNMENT),
+LintId::of(transmute::CROSSPOINTER_TRANSMUTE),
+LintId::of(transmute::TRANSMUTES_EXPRESSIBLE_AS_PTR_CASTS),
+LintId::of(transmute::TRANSMUTE_BYTES_TO_STR),
+LintId::of(transmute::TRANSMUTE_FLOAT_TO_INT),
+LintId::of(transmute::TRANSMUTE_INT_TO_BOOL),
+LintId::of(transmute::TRANSMUTE_INT_TO_CHAR),
+LintId::of(transmute::TRANSMUTE_INT_TO_FLOAT),
+LintId::of(transmute::TRANSMUTE_PTR_TO_REF),
+LintId::of(types::BORROWED_BOX),
+LintId::of(types::TYPE_COMPLEXITY),
+LintId::of(types::VEC_BOX),
+LintId::of(unit_types::UNIT_ARG),
+LintId::of(unnecessary_sort_by::UNNECESSARY_SORT_BY),
+LintId::of(unwrap::UNNECESSARY_UNWRAP),
+LintId::of(useless_conversion::USELESS_CONVERSION),
+LintId::of(zero_div_zero::ZERO_DIVIDED_BY_ZERO),
+])
\ No newline at end of file
diff --git a/clippy_lints/src/lib.register_correctness.rs b/clippy_lints/src/lib.register_correctness.rs
new file mode 100644
index 00000000000..ef42f930a96
--- /dev/null
+++ b/clippy_lints/src/lib.register_correctness.rs
@@ -0,0 +1,73 @@
+// This file was generated by `cargo dev update_lints`.
+// Use that command to update this file and do not edit by hand.
+// Manual edits will be overwritten.
+
+store.register_group(true, "clippy::correctness", Some("clippy_correctness"), vec![
+LintId::of(absurd_extreme_comparisons::ABSURD_EXTREME_COMPARISONS),
+LintId::of(approx_const::APPROX_CONSTANT),
+LintId::of(async_yields_async::ASYNC_YIELDS_ASYNC),
+LintId::of(attrs::DEPRECATED_SEMVER),
+LintId::of(attrs::MISMATCHED_TARGET_OS),
+LintId::of(attrs::USELESS_ATTRIBUTE),
+LintId::of(bit_mask::BAD_BIT_MASK),
+LintId::of(bit_mask::INEFFECTIVE_BIT_MASK),
+LintId::of(booleans::LOGIC_BUG),
+LintId::of(casts::CAST_REF_TO_MUT),
+LintId::of(copies::IFS_SAME_COND),
+LintId::of(copies::IF_SAME_THEN_ELSE),
+LintId::of(derive::DERIVE_HASH_XOR_EQ),
+LintId::of(derive::DERIVE_ORD_XOR_PARTIAL_ORD),
+LintId::of(drop_forget_ref::DROP_COPY),
+LintId::of(drop_forget_ref::DROP_REF),
+LintId::of(drop_forget_ref::FORGET_COPY),
+LintId::of(drop_forget_ref::FORGET_REF),
+LintId::of(enum_clike::ENUM_CLIKE_UNPORTABLE_VARIANT),
+LintId::of(eq_op::EQ_OP),
+LintId::of(erasing_op::ERASING_OP),
+LintId::of(formatting::POSSIBLE_MISSING_COMMA),
+LintId::of(functions::NOT_UNSAFE_PTR_ARG_DEREF),
+LintId::of(if_let_mutex::IF_LET_MUTEX),
+LintId::of(indexing_slicing::OUT_OF_BOUNDS_INDEXING),
+LintId::of(infinite_iter::INFINITE_ITER),
+LintId::of(inherent_to_string::INHERENT_TO_STRING_SHADOW_DISPLAY),
+LintId::of(inline_fn_without_body::INLINE_FN_WITHOUT_BODY),
+LintId::of(let_underscore::LET_UNDERSCORE_LOCK),
+LintId::of(literal_representation::MISTYPED_LITERAL_SUFFIXES),
+LintId::of(loops::ITER_NEXT_LOOP),
+LintId::of(loops::NEVER_LOOP),
+LintId::of(loops::WHILE_IMMUTABLE_CONDITION),
+LintId::of(mem_discriminant::MEM_DISCRIMINANT_NON_ENUM),
+LintId::of(mem_replace::MEM_REPLACE_WITH_UNINIT),
+LintId::of(methods::CLONE_DOUBLE_REF),
+LintId::of(methods::ITERATOR_STEP_BY_ZERO),
+LintId::of(methods::SUSPICIOUS_SPLITN),
+LintId::of(methods::UNINIT_ASSUMED_INIT),
+LintId::of(methods::ZST_OFFSET),
+LintId::of(minmax::MIN_MAX),
+LintId::of(misc::CMP_NAN),
+LintId::of(misc::MODULO_ONE),
+LintId::of(non_octal_unix_permissions::NON_OCTAL_UNIX_PERMISSIONS),
+LintId::of(open_options::NONSENSICAL_OPEN_OPTIONS),
+LintId::of(option_env_unwrap::OPTION_ENV_UNWRAP),
+LintId::of(ptr::INVALID_NULL_PTR_USAGE),
+LintId::of(ptr::MUT_FROM_REF),
+LintId::of(ranges::REVERSED_EMPTY_RANGES),
+LintId::of(regex::INVALID_REGEX),
+LintId::of(self_assignment::SELF_ASSIGNMENT),
+LintId::of(serde_api::SERDE_API_MISUSE),
+LintId::of(size_of_in_element_count::SIZE_OF_IN_ELEMENT_COUNT),
+LintId::of(swap::ALMOST_SWAPPED),
+LintId::of(to_string_in_display::TO_STRING_IN_DISPLAY),
+LintId::of(transmute::UNSOUND_COLLECTION_TRANSMUTE),
+LintId::of(transmute::WRONG_TRANSMUTE),
+LintId::of(transmuting_null::TRANSMUTING_NULL),
+LintId::of(undropped_manually_drops::UNDROPPED_MANUALLY_DROPS),
+LintId::of(unicode::INVISIBLE_CHARACTERS),
+LintId::of(unit_return_expecting_ord::UNIT_RETURN_EXPECTING_ORD),
+LintId::of(unit_types::UNIT_CMP),
+LintId::of(unnamed_address::FN_ADDRESS_COMPARISONS),
+LintId::of(unnamed_address::VTABLE_ADDRESS_COMPARISONS),
+LintId::of(unused_io_amount::UNUSED_IO_AMOUNT),
+LintId::of(unwrap::PANICKING_UNWRAP),
+LintId::of(vec_resize_to_zero::VEC_RESIZE_TO_ZERO),
+])
\ No newline at end of file
diff --git a/clippy_lints/src/lib.register_internal.rs b/clippy_lints/src/lib.register_internal.rs
new file mode 100644
index 00000000000..7d43e2196cd
--- /dev/null
+++ b/clippy_lints/src/lib.register_internal.rs
@@ -0,0 +1,18 @@
+// This file was generated by `cargo dev update_lints`.
+// Use that command to update this file and do not edit by hand.
+// Manual edits will be overwritten.
+
+store.register_group(true, "clippy::internal", Some("clippy_internal"), vec![
+LintId::of(utils::internal_lints::CLIPPY_LINTS_INTERNAL),
+LintId::of(utils::internal_lints::COLLAPSIBLE_SPAN_LINT_CALLS),
+LintId::of(utils::internal_lints::COMPILER_LINT_FUNCTIONS),
+LintId::of(utils::internal_lints::DEFAULT_LINT),
+LintId::of(utils::internal_lints::IF_CHAIN_STYLE),
+LintId::of(utils::internal_lints::INTERNING_DEFINED_SYMBOL),
+LintId::of(utils::internal_lints::INVALID_PATHS),
+LintId::of(utils::internal_lints::LINT_WITHOUT_LINT_PASS),
+LintId::of(utils::internal_lints::MATCH_TYPE_ON_DIAGNOSTIC_ITEM),
+LintId::of(utils::internal_lints::OUTER_EXPN_EXPN_DATA),
+LintId::of(utils::internal_lints::PRODUCE_ICE),
+LintId::of(utils::internal_lints::UNNECESSARY_SYMBOL_STR),
+])
\ No newline at end of file
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
new file mode 100644
index 00000000000..ed0de60c284
--- /dev/null
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -0,0 +1,508 @@
+// This file was generated by `cargo dev update_lints`.
+// Use that command to update this file and do not edit by hand.
+// Manual edits will be overwritten.
+
+    store.register_lints(&[
+        #[cfg(feature = "internal-lints")]
+        utils::internal_lints::CLIPPY_LINTS_INTERNAL,
+        #[cfg(feature = "internal-lints")]
+        utils::internal_lints::COLLAPSIBLE_SPAN_LINT_CALLS,
+        #[cfg(feature = "internal-lints")]
+        utils::internal_lints::COMPILER_LINT_FUNCTIONS,
+        #[cfg(feature = "internal-lints")]
+        utils::internal_lints::DEFAULT_LINT,
+        #[cfg(feature = "internal-lints")]
+        utils::internal_lints::IF_CHAIN_STYLE,
+        #[cfg(feature = "internal-lints")]
+        utils::internal_lints::INTERNING_DEFINED_SYMBOL,
+        #[cfg(feature = "internal-lints")]
+        utils::internal_lints::INVALID_PATHS,
+        #[cfg(feature = "internal-lints")]
+        utils::internal_lints::LINT_WITHOUT_LINT_PASS,
+        #[cfg(feature = "internal-lints")]
+        utils::internal_lints::MATCH_TYPE_ON_DIAGNOSTIC_ITEM,
+        #[cfg(feature = "internal-lints")]
+        utils::internal_lints::OUTER_EXPN_EXPN_DATA,
+        #[cfg(feature = "internal-lints")]
+        utils::internal_lints::PRODUCE_ICE,
+        #[cfg(feature = "internal-lints")]
+        utils::internal_lints::UNNECESSARY_SYMBOL_STR,
+        absurd_extreme_comparisons::ABSURD_EXTREME_COMPARISONS,
+        approx_const::APPROX_CONSTANT,
+        arithmetic::FLOAT_ARITHMETIC,
+        arithmetic::INTEGER_ARITHMETIC,
+        as_conversions::AS_CONVERSIONS,
+        asm_syntax::INLINE_ASM_X86_ATT_SYNTAX,
+        asm_syntax::INLINE_ASM_X86_INTEL_SYNTAX,
+        assertions_on_constants::ASSERTIONS_ON_CONSTANTS,
+        assign_ops::ASSIGN_OP_PATTERN,
+        assign_ops::MISREFACTORED_ASSIGN_OP,
+        async_yields_async::ASYNC_YIELDS_ASYNC,
+        attrs::BLANKET_CLIPPY_RESTRICTION_LINTS,
+        attrs::DEPRECATED_CFG_ATTR,
+        attrs::DEPRECATED_SEMVER,
+        attrs::EMPTY_LINE_AFTER_OUTER_ATTR,
+        attrs::INLINE_ALWAYS,
+        attrs::MISMATCHED_TARGET_OS,
+        attrs::USELESS_ATTRIBUTE,
+        await_holding_invalid::AWAIT_HOLDING_LOCK,
+        await_holding_invalid::AWAIT_HOLDING_REFCELL_REF,
+        bit_mask::BAD_BIT_MASK,
+        bit_mask::INEFFECTIVE_BIT_MASK,
+        bit_mask::VERBOSE_BIT_MASK,
+        blacklisted_name::BLACKLISTED_NAME,
+        blocks_in_if_conditions::BLOCKS_IN_IF_CONDITIONS,
+        bool_assert_comparison::BOOL_ASSERT_COMPARISON,
+        booleans::LOGIC_BUG,
+        booleans::NONMINIMAL_BOOL,
+        bytecount::NAIVE_BYTECOUNT,
+        cargo_common_metadata::CARGO_COMMON_METADATA,
+        case_sensitive_file_extension_comparisons::CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS,
+        casts::CAST_LOSSLESS,
+        casts::CAST_POSSIBLE_TRUNCATION,
+        casts::CAST_POSSIBLE_WRAP,
+        casts::CAST_PRECISION_LOSS,
+        casts::CAST_PTR_ALIGNMENT,
+        casts::CAST_REF_TO_MUT,
+        casts::CAST_SIGN_LOSS,
+        casts::CHAR_LIT_AS_U8,
+        casts::FN_TO_NUMERIC_CAST,
+        casts::FN_TO_NUMERIC_CAST_WITH_TRUNCATION,
+        casts::PTR_AS_PTR,
+        casts::UNNECESSARY_CAST,
+        checked_conversions::CHECKED_CONVERSIONS,
+        cognitive_complexity::COGNITIVE_COMPLEXITY,
+        collapsible_if::COLLAPSIBLE_ELSE_IF,
+        collapsible_if::COLLAPSIBLE_IF,
+        collapsible_match::COLLAPSIBLE_MATCH,
+        comparison_chain::COMPARISON_CHAIN,
+        copies::BRANCHES_SHARING_CODE,
+        copies::IFS_SAME_COND,
+        copies::IF_SAME_THEN_ELSE,
+        copies::SAME_FUNCTIONS_IN_IF_CONDITION,
+        copy_iterator::COPY_ITERATOR,
+        create_dir::CREATE_DIR,
+        dbg_macro::DBG_MACRO,
+        default::DEFAULT_TRAIT_ACCESS,
+        default::FIELD_REASSIGN_WITH_DEFAULT,
+        default_numeric_fallback::DEFAULT_NUMERIC_FALLBACK,
+        dereference::EXPLICIT_DEREF_METHODS,
+        derivable_impls::DERIVABLE_IMPLS,
+        derive::DERIVE_HASH_XOR_EQ,
+        derive::DERIVE_ORD_XOR_PARTIAL_ORD,
+        derive::EXPL_IMPL_CLONE_ON_COPY,
+        derive::UNSAFE_DERIVE_DESERIALIZE,
+        disallowed_method::DISALLOWED_METHOD,
+        disallowed_script_idents::DISALLOWED_SCRIPT_IDENTS,
+        disallowed_type::DISALLOWED_TYPE,
+        doc::DOC_MARKDOWN,
+        doc::MISSING_ERRORS_DOC,
+        doc::MISSING_PANICS_DOC,
+        doc::MISSING_SAFETY_DOC,
+        doc::NEEDLESS_DOCTEST_MAIN,
+        double_comparison::DOUBLE_COMPARISONS,
+        double_parens::DOUBLE_PARENS,
+        drop_forget_ref::DROP_COPY,
+        drop_forget_ref::DROP_REF,
+        drop_forget_ref::FORGET_COPY,
+        drop_forget_ref::FORGET_REF,
+        duration_subsec::DURATION_SUBSEC,
+        else_if_without_else::ELSE_IF_WITHOUT_ELSE,
+        empty_enum::EMPTY_ENUM,
+        entry::MAP_ENTRY,
+        enum_clike::ENUM_CLIKE_UNPORTABLE_VARIANT,
+        enum_variants::ENUM_VARIANT_NAMES,
+        enum_variants::MODULE_INCEPTION,
+        enum_variants::MODULE_NAME_REPETITIONS,
+        eq_op::EQ_OP,
+        eq_op::OP_REF,
+        erasing_op::ERASING_OP,
+        escape::BOXED_LOCAL,
+        eta_reduction::REDUNDANT_CLOSURE,
+        eta_reduction::REDUNDANT_CLOSURE_FOR_METHOD_CALLS,
+        eval_order_dependence::DIVERGING_SUB_EXPRESSION,
+        eval_order_dependence::EVAL_ORDER_DEPENDENCE,
+        excessive_bools::FN_PARAMS_EXCESSIVE_BOOLS,
+        excessive_bools::STRUCT_EXCESSIVE_BOOLS,
+        exhaustive_items::EXHAUSTIVE_ENUMS,
+        exhaustive_items::EXHAUSTIVE_STRUCTS,
+        exit::EXIT,
+        explicit_write::EXPLICIT_WRITE,
+        fallible_impl_from::FALLIBLE_IMPL_FROM,
+        feature_name::NEGATIVE_FEATURE_NAMES,
+        feature_name::REDUNDANT_FEATURE_NAMES,
+        float_equality_without_abs::FLOAT_EQUALITY_WITHOUT_ABS,
+        float_literal::EXCESSIVE_PRECISION,
+        float_literal::LOSSY_FLOAT_LITERAL,
+        floating_point_arithmetic::IMPRECISE_FLOPS,
+        floating_point_arithmetic::SUBOPTIMAL_FLOPS,
+        format::USELESS_FORMAT,
+        formatting::POSSIBLE_MISSING_COMMA,
+        formatting::SUSPICIOUS_ASSIGNMENT_FORMATTING,
+        formatting::SUSPICIOUS_ELSE_FORMATTING,
+        formatting::SUSPICIOUS_UNARY_OP_FORMATTING,
+        from_over_into::FROM_OVER_INTO,
+        from_str_radix_10::FROM_STR_RADIX_10,
+        functions::DOUBLE_MUST_USE,
+        functions::MUST_USE_CANDIDATE,
+        functions::MUST_USE_UNIT,
+        functions::NOT_UNSAFE_PTR_ARG_DEREF,
+        functions::RESULT_UNIT_ERR,
+        functions::TOO_MANY_ARGUMENTS,
+        functions::TOO_MANY_LINES,
+        future_not_send::FUTURE_NOT_SEND,
+        get_last_with_len::GET_LAST_WITH_LEN,
+        identity_op::IDENTITY_OP,
+        if_let_mutex::IF_LET_MUTEX,
+        if_not_else::IF_NOT_ELSE,
+        if_then_panic::IF_THEN_PANIC,
+        if_then_some_else_none::IF_THEN_SOME_ELSE_NONE,
+        implicit_hasher::IMPLICIT_HASHER,
+        implicit_return::IMPLICIT_RETURN,
+        implicit_saturating_sub::IMPLICIT_SATURATING_SUB,
+        inconsistent_struct_constructor::INCONSISTENT_STRUCT_CONSTRUCTOR,
+        indexing_slicing::INDEXING_SLICING,
+        indexing_slicing::OUT_OF_BOUNDS_INDEXING,
+        infinite_iter::INFINITE_ITER,
+        infinite_iter::MAYBE_INFINITE_ITER,
+        inherent_impl::MULTIPLE_INHERENT_IMPL,
+        inherent_to_string::INHERENT_TO_STRING,
+        inherent_to_string::INHERENT_TO_STRING_SHADOW_DISPLAY,
+        inline_fn_without_body::INLINE_FN_WITHOUT_BODY,
+        int_plus_one::INT_PLUS_ONE,
+        integer_division::INTEGER_DIVISION,
+        invalid_upcast_comparisons::INVALID_UPCAST_COMPARISONS,
+        items_after_statements::ITEMS_AFTER_STATEMENTS,
+        iter_not_returning_iterator::ITER_NOT_RETURNING_ITERATOR,
+        large_const_arrays::LARGE_CONST_ARRAYS,
+        large_enum_variant::LARGE_ENUM_VARIANT,
+        large_stack_arrays::LARGE_STACK_ARRAYS,
+        len_zero::COMPARISON_TO_EMPTY,
+        len_zero::LEN_WITHOUT_IS_EMPTY,
+        len_zero::LEN_ZERO,
+        let_if_seq::USELESS_LET_IF_SEQ,
+        let_underscore::LET_UNDERSCORE_DROP,
+        let_underscore::LET_UNDERSCORE_LOCK,
+        let_underscore::LET_UNDERSCORE_MUST_USE,
+        lifetimes::EXTRA_UNUSED_LIFETIMES,
+        lifetimes::NEEDLESS_LIFETIMES,
+        literal_representation::DECIMAL_LITERAL_REPRESENTATION,
+        literal_representation::INCONSISTENT_DIGIT_GROUPING,
+        literal_representation::LARGE_DIGIT_GROUPS,
+        literal_representation::MISTYPED_LITERAL_SUFFIXES,
+        literal_representation::UNREADABLE_LITERAL,
+        literal_representation::UNUSUAL_BYTE_GROUPINGS,
+        loops::EMPTY_LOOP,
+        loops::EXPLICIT_COUNTER_LOOP,
+        loops::EXPLICIT_INTO_ITER_LOOP,
+        loops::EXPLICIT_ITER_LOOP,
+        loops::FOR_KV_MAP,
+        loops::FOR_LOOPS_OVER_FALLIBLES,
+        loops::ITER_NEXT_LOOP,
+        loops::MANUAL_FLATTEN,
+        loops::MANUAL_MEMCPY,
+        loops::MUT_RANGE_BOUND,
+        loops::NEEDLESS_COLLECT,
+        loops::NEEDLESS_RANGE_LOOP,
+        loops::NEVER_LOOP,
+        loops::SAME_ITEM_PUSH,
+        loops::SINGLE_ELEMENT_LOOP,
+        loops::WHILE_IMMUTABLE_CONDITION,
+        loops::WHILE_LET_LOOP,
+        loops::WHILE_LET_ON_ITERATOR,
+        macro_use::MACRO_USE_IMPORTS,
+        main_recursion::MAIN_RECURSION,
+        manual_async_fn::MANUAL_ASYNC_FN,
+        manual_map::MANUAL_MAP,
+        manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE,
+        manual_ok_or::MANUAL_OK_OR,
+        manual_strip::MANUAL_STRIP,
+        manual_unwrap_or::MANUAL_UNWRAP_OR,
+        map_clone::MAP_CLONE,
+        map_err_ignore::MAP_ERR_IGNORE,
+        map_unit_fn::OPTION_MAP_UNIT_FN,
+        map_unit_fn::RESULT_MAP_UNIT_FN,
+        match_on_vec_items::MATCH_ON_VEC_ITEMS,
+        match_result_ok::MATCH_RESULT_OK,
+        matches::INFALLIBLE_DESTRUCTURING_MATCH,
+        matches::MATCH_AS_REF,
+        matches::MATCH_BOOL,
+        matches::MATCH_LIKE_MATCHES_MACRO,
+        matches::MATCH_OVERLAPPING_ARM,
+        matches::MATCH_REF_PATS,
+        matches::MATCH_SAME_ARMS,
+        matches::MATCH_SINGLE_BINDING,
+        matches::MATCH_WILDCARD_FOR_SINGLE_VARIANTS,
+        matches::MATCH_WILD_ERR_ARM,
+        matches::REDUNDANT_PATTERN_MATCHING,
+        matches::REST_PAT_IN_FULLY_BOUND_STRUCTS,
+        matches::SINGLE_MATCH,
+        matches::SINGLE_MATCH_ELSE,
+        matches::WILDCARD_ENUM_MATCH_ARM,
+        matches::WILDCARD_IN_OR_PATTERNS,
+        mem_discriminant::MEM_DISCRIMINANT_NON_ENUM,
+        mem_forget::MEM_FORGET,
+        mem_replace::MEM_REPLACE_OPTION_WITH_NONE,
+        mem_replace::MEM_REPLACE_WITH_DEFAULT,
+        mem_replace::MEM_REPLACE_WITH_UNINIT,
+        methods::BIND_INSTEAD_OF_MAP,
+        methods::BYTES_NTH,
+        methods::CHARS_LAST_CMP,
+        methods::CHARS_NEXT_CMP,
+        methods::CLONED_INSTEAD_OF_COPIED,
+        methods::CLONE_DOUBLE_REF,
+        methods::CLONE_ON_COPY,
+        methods::CLONE_ON_REF_PTR,
+        methods::EXPECT_FUN_CALL,
+        methods::EXPECT_USED,
+        methods::EXTEND_WITH_DRAIN,
+        methods::FILETYPE_IS_FILE,
+        methods::FILTER_MAP_IDENTITY,
+        methods::FILTER_MAP_NEXT,
+        methods::FILTER_NEXT,
+        methods::FLAT_MAP_IDENTITY,
+        methods::FLAT_MAP_OPTION,
+        methods::FROM_ITER_INSTEAD_OF_COLLECT,
+        methods::GET_UNWRAP,
+        methods::IMPLICIT_CLONE,
+        methods::INEFFICIENT_TO_STRING,
+        methods::INSPECT_FOR_EACH,
+        methods::INTO_ITER_ON_REF,
+        methods::ITERATOR_STEP_BY_ZERO,
+        methods::ITER_CLONED_COLLECT,
+        methods::ITER_COUNT,
+        methods::ITER_NEXT_SLICE,
+        methods::ITER_NTH,
+        methods::ITER_NTH_ZERO,
+        methods::ITER_SKIP_NEXT,
+        methods::MANUAL_FILTER_MAP,
+        methods::MANUAL_FIND_MAP,
+        methods::MANUAL_SATURATING_ARITHMETIC,
+        methods::MANUAL_SPLIT_ONCE,
+        methods::MANUAL_STR_REPEAT,
+        methods::MAP_COLLECT_RESULT_UNIT,
+        methods::MAP_FLATTEN,
+        methods::MAP_IDENTITY,
+        methods::MAP_UNWRAP_OR,
+        methods::NEW_RET_NO_SELF,
+        methods::OK_EXPECT,
+        methods::OPTION_AS_REF_DEREF,
+        methods::OPTION_FILTER_MAP,
+        methods::OPTION_MAP_OR_NONE,
+        methods::OR_FUN_CALL,
+        methods::RESULT_MAP_OR_INTO_OPTION,
+        methods::SEARCH_IS_SOME,
+        methods::SHOULD_IMPLEMENT_TRAIT,
+        methods::SINGLE_CHAR_ADD_STR,
+        methods::SINGLE_CHAR_PATTERN,
+        methods::SKIP_WHILE_NEXT,
+        methods::STRING_EXTEND_CHARS,
+        methods::SUSPICIOUS_MAP,
+        methods::SUSPICIOUS_SPLITN,
+        methods::UNINIT_ASSUMED_INIT,
+        methods::UNNECESSARY_FILTER_MAP,
+        methods::UNNECESSARY_FOLD,
+        methods::UNNECESSARY_LAZY_EVALUATIONS,
+        methods::UNWRAP_OR_ELSE_DEFAULT,
+        methods::UNWRAP_USED,
+        methods::USELESS_ASREF,
+        methods::WRONG_SELF_CONVENTION,
+        methods::ZST_OFFSET,
+        minmax::MIN_MAX,
+        misc::CMP_NAN,
+        misc::CMP_OWNED,
+        misc::FLOAT_CMP,
+        misc::FLOAT_CMP_CONST,
+        misc::MODULO_ONE,
+        misc::SHORT_CIRCUIT_STATEMENT,
+        misc::TOPLEVEL_REF_ARG,
+        misc::USED_UNDERSCORE_BINDING,
+        misc::ZERO_PTR,
+        misc_early::BUILTIN_TYPE_SHADOW,
+        misc_early::DOUBLE_NEG,
+        misc_early::DUPLICATE_UNDERSCORE_ARGUMENT,
+        misc_early::MIXED_CASE_HEX_LITERALS,
+        misc_early::REDUNDANT_PATTERN,
+        misc_early::UNNEEDED_FIELD_PATTERN,
+        misc_early::UNNEEDED_WILDCARD_PATTERN,
+        misc_early::UNSEPARATED_LITERAL_SUFFIX,
+        misc_early::ZERO_PREFIXED_LITERAL,
+        missing_const_for_fn::MISSING_CONST_FOR_FN,
+        missing_doc::MISSING_DOCS_IN_PRIVATE_ITEMS,
+        missing_enforced_import_rename::MISSING_ENFORCED_IMPORT_RENAMES,
+        missing_inline::MISSING_INLINE_IN_PUBLIC_ITEMS,
+        module_style::MOD_MODULE_FILES,
+        module_style::SELF_NAMED_MODULE_FILES,
+        modulo_arithmetic::MODULO_ARITHMETIC,
+        multiple_crate_versions::MULTIPLE_CRATE_VERSIONS,
+        mut_key::MUTABLE_KEY_TYPE,
+        mut_mut::MUT_MUT,
+        mut_mutex_lock::MUT_MUTEX_LOCK,
+        mut_reference::UNNECESSARY_MUT_PASSED,
+        mutable_debug_assertion::DEBUG_ASSERT_WITH_MUT_CALL,
+        mutex_atomic::MUTEX_ATOMIC,
+        mutex_atomic::MUTEX_INTEGER,
+        needless_arbitrary_self_type::NEEDLESS_ARBITRARY_SELF_TYPE,
+        needless_bitwise_bool::NEEDLESS_BITWISE_BOOL,
+        needless_bool::BOOL_COMPARISON,
+        needless_bool::NEEDLESS_BOOL,
+        needless_borrow::NEEDLESS_BORROW,
+        needless_borrow::REF_BINDING_TO_REFERENCE,
+        needless_borrowed_ref::NEEDLESS_BORROWED_REFERENCE,
+        needless_continue::NEEDLESS_CONTINUE,
+        needless_for_each::NEEDLESS_FOR_EACH,
+        needless_option_as_deref::NEEDLESS_OPTION_AS_DEREF,
+        needless_pass_by_value::NEEDLESS_PASS_BY_VALUE,
+        needless_question_mark::NEEDLESS_QUESTION_MARK,
+        needless_update::NEEDLESS_UPDATE,
+        neg_cmp_op_on_partial_ord::NEG_CMP_OP_ON_PARTIAL_ORD,
+        neg_multiply::NEG_MULTIPLY,
+        new_without_default::NEW_WITHOUT_DEFAULT,
+        no_effect::NO_EFFECT,
+        no_effect::UNNECESSARY_OPERATION,
+        non_copy_const::BORROW_INTERIOR_MUTABLE_CONST,
+        non_copy_const::DECLARE_INTERIOR_MUTABLE_CONST,
+        non_expressive_names::JUST_UNDERSCORES_AND_DIGITS,
+        non_expressive_names::MANY_SINGLE_CHAR_NAMES,
+        non_expressive_names::SIMILAR_NAMES,
+        non_octal_unix_permissions::NON_OCTAL_UNIX_PERMISSIONS,
+        nonstandard_macro_braces::NONSTANDARD_MACRO_BRACES,
+        open_options::NONSENSICAL_OPEN_OPTIONS,
+        option_env_unwrap::OPTION_ENV_UNWRAP,
+        option_if_let_else::OPTION_IF_LET_ELSE,
+        overflow_check_conditional::OVERFLOW_CHECK_CONDITIONAL,
+        panic_in_result_fn::PANIC_IN_RESULT_FN,
+        panic_unimplemented::PANIC,
+        panic_unimplemented::TODO,
+        panic_unimplemented::UNIMPLEMENTED,
+        panic_unimplemented::UNREACHABLE,
+        partialeq_ne_impl::PARTIALEQ_NE_IMPL,
+        pass_by_ref_or_value::LARGE_TYPES_PASSED_BY_VALUE,
+        pass_by_ref_or_value::TRIVIALLY_COPY_PASS_BY_REF,
+        path_buf_push_overwrite::PATH_BUF_PUSH_OVERWRITE,
+        pattern_type_mismatch::PATTERN_TYPE_MISMATCH,
+        precedence::PRECEDENCE,
+        ptr::CMP_NULL,
+        ptr::INVALID_NULL_PTR_USAGE,
+        ptr::MUT_FROM_REF,
+        ptr::PTR_ARG,
+        ptr_eq::PTR_EQ,
+        ptr_offset_with_cast::PTR_OFFSET_WITH_CAST,
+        question_mark::QUESTION_MARK,
+        ranges::MANUAL_RANGE_CONTAINS,
+        ranges::RANGE_MINUS_ONE,
+        ranges::RANGE_PLUS_ONE,
+        ranges::RANGE_ZIP_WITH_LEN,
+        ranges::REVERSED_EMPTY_RANGES,
+        redundant_clone::REDUNDANT_CLONE,
+        redundant_closure_call::REDUNDANT_CLOSURE_CALL,
+        redundant_else::REDUNDANT_ELSE,
+        redundant_field_names::REDUNDANT_FIELD_NAMES,
+        redundant_pub_crate::REDUNDANT_PUB_CRATE,
+        redundant_slicing::REDUNDANT_SLICING,
+        redundant_static_lifetimes::REDUNDANT_STATIC_LIFETIMES,
+        ref_option_ref::REF_OPTION_REF,
+        reference::DEREF_ADDROF,
+        reference::REF_IN_DEREF,
+        regex::INVALID_REGEX,
+        regex::TRIVIAL_REGEX,
+        repeat_once::REPEAT_ONCE,
+        returns::LET_AND_RETURN,
+        returns::NEEDLESS_RETURN,
+        same_name_method::SAME_NAME_METHOD,
+        self_assignment::SELF_ASSIGNMENT,
+        self_named_constructors::SELF_NAMED_CONSTRUCTORS,
+        semicolon_if_nothing_returned::SEMICOLON_IF_NOTHING_RETURNED,
+        serde_api::SERDE_API_MISUSE,
+        shadow::SHADOW_REUSE,
+        shadow::SHADOW_SAME,
+        shadow::SHADOW_UNRELATED,
+        single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS,
+        size_of_in_element_count::SIZE_OF_IN_ELEMENT_COUNT,
+        slow_vector_initialization::SLOW_VECTOR_INITIALIZATION,
+        stable_sort_primitive::STABLE_SORT_PRIMITIVE,
+        strings::STRING_ADD,
+        strings::STRING_ADD_ASSIGN,
+        strings::STRING_FROM_UTF8_AS_BYTES,
+        strings::STRING_LIT_AS_BYTES,
+        strings::STRING_TO_STRING,
+        strings::STR_TO_STRING,
+        strlen_on_c_strings::STRLEN_ON_C_STRINGS,
+        suspicious_operation_groupings::SUSPICIOUS_OPERATION_GROUPINGS,
+        suspicious_trait_impl::SUSPICIOUS_ARITHMETIC_IMPL,
+        suspicious_trait_impl::SUSPICIOUS_OP_ASSIGN_IMPL,
+        swap::ALMOST_SWAPPED,
+        swap::MANUAL_SWAP,
+        tabs_in_doc_comments::TABS_IN_DOC_COMMENTS,
+        temporary_assignment::TEMPORARY_ASSIGNMENT,
+        to_digit_is_some::TO_DIGIT_IS_SOME,
+        to_string_in_display::TO_STRING_IN_DISPLAY,
+        trait_bounds::TRAIT_DUPLICATION_IN_BOUNDS,
+        trait_bounds::TYPE_REPETITION_IN_BOUNDS,
+        transmute::CROSSPOINTER_TRANSMUTE,
+        transmute::TRANSMUTES_EXPRESSIBLE_AS_PTR_CASTS,
+        transmute::TRANSMUTE_BYTES_TO_STR,
+        transmute::TRANSMUTE_FLOAT_TO_INT,
+        transmute::TRANSMUTE_INT_TO_BOOL,
+        transmute::TRANSMUTE_INT_TO_CHAR,
+        transmute::TRANSMUTE_INT_TO_FLOAT,
+        transmute::TRANSMUTE_PTR_TO_PTR,
+        transmute::TRANSMUTE_PTR_TO_REF,
+        transmute::UNSOUND_COLLECTION_TRANSMUTE,
+        transmute::USELESS_TRANSMUTE,
+        transmute::WRONG_TRANSMUTE,
+        transmuting_null::TRANSMUTING_NULL,
+        try_err::TRY_ERR,
+        types::BORROWED_BOX,
+        types::BOX_COLLECTION,
+        types::LINKEDLIST,
+        types::OPTION_OPTION,
+        types::RC_BUFFER,
+        types::RC_MUTEX,
+        types::REDUNDANT_ALLOCATION,
+        types::TYPE_COMPLEXITY,
+        types::VEC_BOX,
+        undropped_manually_drops::UNDROPPED_MANUALLY_DROPS,
+        unicode::INVISIBLE_CHARACTERS,
+        unicode::NON_ASCII_LITERAL,
+        unicode::UNICODE_NOT_NFC,
+        unit_return_expecting_ord::UNIT_RETURN_EXPECTING_ORD,
+        unit_types::LET_UNIT_VALUE,
+        unit_types::UNIT_ARG,
+        unit_types::UNIT_CMP,
+        unnamed_address::FN_ADDRESS_COMPARISONS,
+        unnamed_address::VTABLE_ADDRESS_COMPARISONS,
+        unnecessary_self_imports::UNNECESSARY_SELF_IMPORTS,
+        unnecessary_sort_by::UNNECESSARY_SORT_BY,
+        unnecessary_wraps::UNNECESSARY_WRAPS,
+        unnested_or_patterns::UNNESTED_OR_PATTERNS,
+        unsafe_removed_from_name::UNSAFE_REMOVED_FROM_NAME,
+        unused_async::UNUSED_ASYNC,
+        unused_io_amount::UNUSED_IO_AMOUNT,
+        unused_self::UNUSED_SELF,
+        unused_unit::UNUSED_UNIT,
+        unwrap::PANICKING_UNWRAP,
+        unwrap::UNNECESSARY_UNWRAP,
+        unwrap_in_result::UNWRAP_IN_RESULT,
+        upper_case_acronyms::UPPER_CASE_ACRONYMS,
+        use_self::USE_SELF,
+        useless_conversion::USELESS_CONVERSION,
+        vec::USELESS_VEC,
+        vec_init_then_push::VEC_INIT_THEN_PUSH,
+        vec_resize_to_zero::VEC_RESIZE_TO_ZERO,
+        verbose_file_reads::VERBOSE_FILE_READS,
+        wildcard_dependencies::WILDCARD_DEPENDENCIES,
+        wildcard_imports::ENUM_GLOB_USE,
+        wildcard_imports::WILDCARD_IMPORTS,
+        write::PRINTLN_EMPTY_STRING,
+        write::PRINT_LITERAL,
+        write::PRINT_STDERR,
+        write::PRINT_STDOUT,
+        write::PRINT_WITH_NEWLINE,
+        write::USE_DEBUG,
+        write::WRITELN_EMPTY_STRING,
+        write::WRITE_LITERAL,
+        write::WRITE_WITH_NEWLINE,
+        zero_div_zero::ZERO_DIVIDED_BY_ZERO,
+        zero_sized_map_values::ZERO_SIZED_MAP_VALUES,
+    ])
\ No newline at end of file
diff --git a/clippy_lints/src/lib.register_nursery.rs b/clippy_lints/src/lib.register_nursery.rs
new file mode 100644
index 00000000000..72a09fcfe25
--- /dev/null
+++ b/clippy_lints/src/lib.register_nursery.rs
@@ -0,0 +1,28 @@
+// This file was generated by `cargo dev update_lints`.
+// Use that command to update this file and do not edit by hand.
+// Manual edits will be overwritten.
+
+store.register_group(true, "clippy::nursery", Some("clippy_nursery"), vec![
+LintId::of(attrs::EMPTY_LINE_AFTER_OUTER_ATTR),
+LintId::of(cognitive_complexity::COGNITIVE_COMPLEXITY),
+LintId::of(copies::BRANCHES_SHARING_CODE),
+LintId::of(disallowed_method::DISALLOWED_METHOD),
+LintId::of(disallowed_type::DISALLOWED_TYPE),
+LintId::of(fallible_impl_from::FALLIBLE_IMPL_FROM),
+LintId::of(floating_point_arithmetic::IMPRECISE_FLOPS),
+LintId::of(floating_point_arithmetic::SUBOPTIMAL_FLOPS),
+LintId::of(future_not_send::FUTURE_NOT_SEND),
+LintId::of(let_if_seq::USELESS_LET_IF_SEQ),
+LintId::of(missing_const_for_fn::MISSING_CONST_FOR_FN),
+LintId::of(mutable_debug_assertion::DEBUG_ASSERT_WITH_MUT_CALL),
+LintId::of(mutex_atomic::MUTEX_INTEGER),
+LintId::of(nonstandard_macro_braces::NONSTANDARD_MACRO_BRACES),
+LintId::of(option_if_let_else::OPTION_IF_LET_ELSE),
+LintId::of(path_buf_push_overwrite::PATH_BUF_PUSH_OVERWRITE),
+LintId::of(redundant_pub_crate::REDUNDANT_PUB_CRATE),
+LintId::of(regex::TRIVIAL_REGEX),
+LintId::of(strings::STRING_LIT_AS_BYTES),
+LintId::of(suspicious_operation_groupings::SUSPICIOUS_OPERATION_GROUPINGS),
+LintId::of(transmute::USELESS_TRANSMUTE),
+LintId::of(use_self::USE_SELF),
+])
\ No newline at end of file
diff --git a/clippy_lints/src/lib.register_pedantic.rs b/clippy_lints/src/lib.register_pedantic.rs
new file mode 100644
index 00000000000..8356198d80d
--- /dev/null
+++ b/clippy_lints/src/lib.register_pedantic.rs
@@ -0,0 +1,101 @@
+// This file was generated by `cargo dev update_lints`.
+// Use that command to update this file and do not edit by hand.
+// Manual edits will be overwritten.
+
+store.register_group(true, "clippy::pedantic", Some("clippy_pedantic"), vec![
+LintId::of(attrs::INLINE_ALWAYS),
+LintId::of(await_holding_invalid::AWAIT_HOLDING_LOCK),
+LintId::of(await_holding_invalid::AWAIT_HOLDING_REFCELL_REF),
+LintId::of(bit_mask::VERBOSE_BIT_MASK),
+LintId::of(bytecount::NAIVE_BYTECOUNT),
+LintId::of(case_sensitive_file_extension_comparisons::CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS),
+LintId::of(casts::CAST_LOSSLESS),
+LintId::of(casts::CAST_POSSIBLE_TRUNCATION),
+LintId::of(casts::CAST_POSSIBLE_WRAP),
+LintId::of(casts::CAST_PRECISION_LOSS),
+LintId::of(casts::CAST_PTR_ALIGNMENT),
+LintId::of(casts::CAST_SIGN_LOSS),
+LintId::of(casts::PTR_AS_PTR),
+LintId::of(checked_conversions::CHECKED_CONVERSIONS),
+LintId::of(copies::SAME_FUNCTIONS_IN_IF_CONDITION),
+LintId::of(copy_iterator::COPY_ITERATOR),
+LintId::of(default::DEFAULT_TRAIT_ACCESS),
+LintId::of(dereference::EXPLICIT_DEREF_METHODS),
+LintId::of(derive::EXPL_IMPL_CLONE_ON_COPY),
+LintId::of(derive::UNSAFE_DERIVE_DESERIALIZE),
+LintId::of(doc::DOC_MARKDOWN),
+LintId::of(doc::MISSING_ERRORS_DOC),
+LintId::of(doc::MISSING_PANICS_DOC),
+LintId::of(empty_enum::EMPTY_ENUM),
+LintId::of(enum_variants::MODULE_NAME_REPETITIONS),
+LintId::of(eta_reduction::REDUNDANT_CLOSURE_FOR_METHOD_CALLS),
+LintId::of(excessive_bools::FN_PARAMS_EXCESSIVE_BOOLS),
+LintId::of(excessive_bools::STRUCT_EXCESSIVE_BOOLS),
+LintId::of(functions::MUST_USE_CANDIDATE),
+LintId::of(functions::TOO_MANY_LINES),
+LintId::of(if_not_else::IF_NOT_ELSE),
+LintId::of(implicit_hasher::IMPLICIT_HASHER),
+LintId::of(implicit_saturating_sub::IMPLICIT_SATURATING_SUB),
+LintId::of(inconsistent_struct_constructor::INCONSISTENT_STRUCT_CONSTRUCTOR),
+LintId::of(infinite_iter::MAYBE_INFINITE_ITER),
+LintId::of(invalid_upcast_comparisons::INVALID_UPCAST_COMPARISONS),
+LintId::of(items_after_statements::ITEMS_AFTER_STATEMENTS),
+LintId::of(iter_not_returning_iterator::ITER_NOT_RETURNING_ITERATOR),
+LintId::of(large_stack_arrays::LARGE_STACK_ARRAYS),
+LintId::of(let_underscore::LET_UNDERSCORE_DROP),
+LintId::of(literal_representation::LARGE_DIGIT_GROUPS),
+LintId::of(literal_representation::UNREADABLE_LITERAL),
+LintId::of(loops::EXPLICIT_INTO_ITER_LOOP),
+LintId::of(loops::EXPLICIT_ITER_LOOP),
+LintId::of(macro_use::MACRO_USE_IMPORTS),
+LintId::of(manual_ok_or::MANUAL_OK_OR),
+LintId::of(match_on_vec_items::MATCH_ON_VEC_ITEMS),
+LintId::of(matches::MATCH_BOOL),
+LintId::of(matches::MATCH_SAME_ARMS),
+LintId::of(matches::MATCH_WILDCARD_FOR_SINGLE_VARIANTS),
+LintId::of(matches::MATCH_WILD_ERR_ARM),
+LintId::of(matches::SINGLE_MATCH_ELSE),
+LintId::of(methods::CLONED_INSTEAD_OF_COPIED),
+LintId::of(methods::FILTER_MAP_NEXT),
+LintId::of(methods::FLAT_MAP_OPTION),
+LintId::of(methods::FROM_ITER_INSTEAD_OF_COLLECT),
+LintId::of(methods::IMPLICIT_CLONE),
+LintId::of(methods::INEFFICIENT_TO_STRING),
+LintId::of(methods::MAP_FLATTEN),
+LintId::of(methods::MAP_UNWRAP_OR),
+LintId::of(misc::FLOAT_CMP),
+LintId::of(misc::USED_UNDERSCORE_BINDING),
+LintId::of(misc_early::UNSEPARATED_LITERAL_SUFFIX),
+LintId::of(mut_mut::MUT_MUT),
+LintId::of(needless_bitwise_bool::NEEDLESS_BITWISE_BOOL),
+LintId::of(needless_borrow::REF_BINDING_TO_REFERENCE),
+LintId::of(needless_continue::NEEDLESS_CONTINUE),
+LintId::of(needless_for_each::NEEDLESS_FOR_EACH),
+LintId::of(needless_pass_by_value::NEEDLESS_PASS_BY_VALUE),
+LintId::of(non_expressive_names::MANY_SINGLE_CHAR_NAMES),
+LintId::of(non_expressive_names::SIMILAR_NAMES),
+LintId::of(pass_by_ref_or_value::LARGE_TYPES_PASSED_BY_VALUE),
+LintId::of(pass_by_ref_or_value::TRIVIALLY_COPY_PASS_BY_REF),
+LintId::of(ranges::RANGE_MINUS_ONE),
+LintId::of(ranges::RANGE_PLUS_ONE),
+LintId::of(redundant_else::REDUNDANT_ELSE),
+LintId::of(ref_option_ref::REF_OPTION_REF),
+LintId::of(semicolon_if_nothing_returned::SEMICOLON_IF_NOTHING_RETURNED),
+LintId::of(shadow::SHADOW_UNRELATED),
+LintId::of(strings::STRING_ADD_ASSIGN),
+LintId::of(trait_bounds::TRAIT_DUPLICATION_IN_BOUNDS),
+LintId::of(trait_bounds::TYPE_REPETITION_IN_BOUNDS),
+LintId::of(transmute::TRANSMUTE_PTR_TO_PTR),
+LintId::of(types::LINKEDLIST),
+LintId::of(types::OPTION_OPTION),
+LintId::of(unicode::NON_ASCII_LITERAL),
+LintId::of(unicode::UNICODE_NOT_NFC),
+LintId::of(unit_types::LET_UNIT_VALUE),
+LintId::of(unnecessary_wraps::UNNECESSARY_WRAPS),
+LintId::of(unnested_or_patterns::UNNESTED_OR_PATTERNS),
+LintId::of(unused_async::UNUSED_ASYNC),
+LintId::of(unused_self::UNUSED_SELF),
+LintId::of(wildcard_imports::ENUM_GLOB_USE),
+LintId::of(wildcard_imports::WILDCARD_IMPORTS),
+LintId::of(zero_sized_map_values::ZERO_SIZED_MAP_VALUES),
+])
\ No newline at end of file
diff --git a/clippy_lints/src/lib.register_perf.rs b/clippy_lints/src/lib.register_perf.rs
new file mode 100644
index 00000000000..610309dd893
--- /dev/null
+++ b/clippy_lints/src/lib.register_perf.rs
@@ -0,0 +1,27 @@
+// This file was generated by `cargo dev update_lints`.
+// Use that command to update this file and do not edit by hand.
+// Manual edits will be overwritten.
+
+store.register_group(true, "clippy::perf", Some("clippy_perf"), vec![
+LintId::of(entry::MAP_ENTRY),
+LintId::of(escape::BOXED_LOCAL),
+LintId::of(large_const_arrays::LARGE_CONST_ARRAYS),
+LintId::of(large_enum_variant::LARGE_ENUM_VARIANT),
+LintId::of(loops::MANUAL_MEMCPY),
+LintId::of(loops::NEEDLESS_COLLECT),
+LintId::of(methods::EXPECT_FUN_CALL),
+LintId::of(methods::EXTEND_WITH_DRAIN),
+LintId::of(methods::ITER_NTH),
+LintId::of(methods::MANUAL_STR_REPEAT),
+LintId::of(methods::OR_FUN_CALL),
+LintId::of(methods::SINGLE_CHAR_PATTERN),
+LintId::of(misc::CMP_OWNED),
+LintId::of(mutex_atomic::MUTEX_ATOMIC),
+LintId::of(redundant_clone::REDUNDANT_CLONE),
+LintId::of(slow_vector_initialization::SLOW_VECTOR_INITIALIZATION),
+LintId::of(stable_sort_primitive::STABLE_SORT_PRIMITIVE),
+LintId::of(types::BOX_COLLECTION),
+LintId::of(types::REDUNDANT_ALLOCATION),
+LintId::of(vec::USELESS_VEC),
+LintId::of(vec_init_then_push::VEC_INIT_THEN_PUSH),
+])
\ No newline at end of file
diff --git a/clippy_lints/src/lib.register_restriction.rs b/clippy_lints/src/lib.register_restriction.rs
new file mode 100644
index 00000000000..8f181fe2e78
--- /dev/null
+++ b/clippy_lints/src/lib.register_restriction.rs
@@ -0,0 +1,64 @@
+// This file was generated by `cargo dev update_lints`.
+// Use that command to update this file and do not edit by hand.
+// Manual edits will be overwritten.
+
+store.register_group(true, "clippy::restriction", Some("clippy_restriction"), vec![
+LintId::of(arithmetic::FLOAT_ARITHMETIC),
+LintId::of(arithmetic::INTEGER_ARITHMETIC),
+LintId::of(as_conversions::AS_CONVERSIONS),
+LintId::of(asm_syntax::INLINE_ASM_X86_ATT_SYNTAX),
+LintId::of(asm_syntax::INLINE_ASM_X86_INTEL_SYNTAX),
+LintId::of(create_dir::CREATE_DIR),
+LintId::of(dbg_macro::DBG_MACRO),
+LintId::of(default_numeric_fallback::DEFAULT_NUMERIC_FALLBACK),
+LintId::of(disallowed_script_idents::DISALLOWED_SCRIPT_IDENTS),
+LintId::of(else_if_without_else::ELSE_IF_WITHOUT_ELSE),
+LintId::of(exhaustive_items::EXHAUSTIVE_ENUMS),
+LintId::of(exhaustive_items::EXHAUSTIVE_STRUCTS),
+LintId::of(exit::EXIT),
+LintId::of(float_literal::LOSSY_FLOAT_LITERAL),
+LintId::of(if_then_some_else_none::IF_THEN_SOME_ELSE_NONE),
+LintId::of(implicit_return::IMPLICIT_RETURN),
+LintId::of(indexing_slicing::INDEXING_SLICING),
+LintId::of(inherent_impl::MULTIPLE_INHERENT_IMPL),
+LintId::of(integer_division::INTEGER_DIVISION),
+LintId::of(let_underscore::LET_UNDERSCORE_MUST_USE),
+LintId::of(literal_representation::DECIMAL_LITERAL_REPRESENTATION),
+LintId::of(map_err_ignore::MAP_ERR_IGNORE),
+LintId::of(matches::REST_PAT_IN_FULLY_BOUND_STRUCTS),
+LintId::of(matches::WILDCARD_ENUM_MATCH_ARM),
+LintId::of(mem_forget::MEM_FORGET),
+LintId::of(methods::CLONE_ON_REF_PTR),
+LintId::of(methods::EXPECT_USED),
+LintId::of(methods::FILETYPE_IS_FILE),
+LintId::of(methods::GET_UNWRAP),
+LintId::of(methods::UNWRAP_USED),
+LintId::of(misc::FLOAT_CMP_CONST),
+LintId::of(misc_early::UNNEEDED_FIELD_PATTERN),
+LintId::of(missing_doc::MISSING_DOCS_IN_PRIVATE_ITEMS),
+LintId::of(missing_enforced_import_rename::MISSING_ENFORCED_IMPORT_RENAMES),
+LintId::of(missing_inline::MISSING_INLINE_IN_PUBLIC_ITEMS),
+LintId::of(module_style::MOD_MODULE_FILES),
+LintId::of(module_style::SELF_NAMED_MODULE_FILES),
+LintId::of(modulo_arithmetic::MODULO_ARITHMETIC),
+LintId::of(panic_in_result_fn::PANIC_IN_RESULT_FN),
+LintId::of(panic_unimplemented::PANIC),
+LintId::of(panic_unimplemented::TODO),
+LintId::of(panic_unimplemented::UNIMPLEMENTED),
+LintId::of(panic_unimplemented::UNREACHABLE),
+LintId::of(pattern_type_mismatch::PATTERN_TYPE_MISMATCH),
+LintId::of(same_name_method::SAME_NAME_METHOD),
+LintId::of(shadow::SHADOW_REUSE),
+LintId::of(shadow::SHADOW_SAME),
+LintId::of(strings::STRING_ADD),
+LintId::of(strings::STRING_TO_STRING),
+LintId::of(strings::STR_TO_STRING),
+LintId::of(types::RC_BUFFER),
+LintId::of(types::RC_MUTEX),
+LintId::of(unnecessary_self_imports::UNNECESSARY_SELF_IMPORTS),
+LintId::of(unwrap_in_result::UNWRAP_IN_RESULT),
+LintId::of(verbose_file_reads::VERBOSE_FILE_READS),
+LintId::of(write::PRINT_STDERR),
+LintId::of(write::PRINT_STDOUT),
+LintId::of(write::USE_DEBUG),
+])
\ No newline at end of file
diff --git a/clippy_lints/src/lib.register_style.rs b/clippy_lints/src/lib.register_style.rs
new file mode 100644
index 00000000000..cd563907b77
--- /dev/null
+++ b/clippy_lints/src/lib.register_style.rs
@@ -0,0 +1,114 @@
+// This file was generated by `cargo dev update_lints`.
+// Use that command to update this file and do not edit by hand.
+// Manual edits will be overwritten.
+
+store.register_group(true, "clippy::style", Some("clippy_style"), vec![
+LintId::of(assertions_on_constants::ASSERTIONS_ON_CONSTANTS),
+LintId::of(assign_ops::ASSIGN_OP_PATTERN),
+LintId::of(blacklisted_name::BLACKLISTED_NAME),
+LintId::of(blocks_in_if_conditions::BLOCKS_IN_IF_CONDITIONS),
+LintId::of(bool_assert_comparison::BOOL_ASSERT_COMPARISON),
+LintId::of(casts::FN_TO_NUMERIC_CAST),
+LintId::of(casts::FN_TO_NUMERIC_CAST_WITH_TRUNCATION),
+LintId::of(collapsible_if::COLLAPSIBLE_ELSE_IF),
+LintId::of(collapsible_if::COLLAPSIBLE_IF),
+LintId::of(collapsible_match::COLLAPSIBLE_MATCH),
+LintId::of(comparison_chain::COMPARISON_CHAIN),
+LintId::of(default::FIELD_REASSIGN_WITH_DEFAULT),
+LintId::of(doc::MISSING_SAFETY_DOC),
+LintId::of(doc::NEEDLESS_DOCTEST_MAIN),
+LintId::of(enum_variants::ENUM_VARIANT_NAMES),
+LintId::of(enum_variants::MODULE_INCEPTION),
+LintId::of(eq_op::OP_REF),
+LintId::of(eta_reduction::REDUNDANT_CLOSURE),
+LintId::of(float_literal::EXCESSIVE_PRECISION),
+LintId::of(from_over_into::FROM_OVER_INTO),
+LintId::of(from_str_radix_10::FROM_STR_RADIX_10),
+LintId::of(functions::DOUBLE_MUST_USE),
+LintId::of(functions::MUST_USE_UNIT),
+LintId::of(functions::RESULT_UNIT_ERR),
+LintId::of(if_then_panic::IF_THEN_PANIC),
+LintId::of(inherent_to_string::INHERENT_TO_STRING),
+LintId::of(len_zero::COMPARISON_TO_EMPTY),
+LintId::of(len_zero::LEN_WITHOUT_IS_EMPTY),
+LintId::of(len_zero::LEN_ZERO),
+LintId::of(literal_representation::INCONSISTENT_DIGIT_GROUPING),
+LintId::of(literal_representation::UNUSUAL_BYTE_GROUPINGS),
+LintId::of(loops::FOR_KV_MAP),
+LintId::of(loops::NEEDLESS_RANGE_LOOP),
+LintId::of(loops::SAME_ITEM_PUSH),
+LintId::of(loops::WHILE_LET_ON_ITERATOR),
+LintId::of(main_recursion::MAIN_RECURSION),
+LintId::of(manual_async_fn::MANUAL_ASYNC_FN),
+LintId::of(manual_map::MANUAL_MAP),
+LintId::of(manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE),
+LintId::of(map_clone::MAP_CLONE),
+LintId::of(match_result_ok::MATCH_RESULT_OK),
+LintId::of(matches::INFALLIBLE_DESTRUCTURING_MATCH),
+LintId::of(matches::MATCH_LIKE_MATCHES_MACRO),
+LintId::of(matches::MATCH_OVERLAPPING_ARM),
+LintId::of(matches::MATCH_REF_PATS),
+LintId::of(matches::REDUNDANT_PATTERN_MATCHING),
+LintId::of(matches::SINGLE_MATCH),
+LintId::of(mem_replace::MEM_REPLACE_OPTION_WITH_NONE),
+LintId::of(mem_replace::MEM_REPLACE_WITH_DEFAULT),
+LintId::of(methods::BYTES_NTH),
+LintId::of(methods::CHARS_LAST_CMP),
+LintId::of(methods::CHARS_NEXT_CMP),
+LintId::of(methods::INTO_ITER_ON_REF),
+LintId::of(methods::ITER_CLONED_COLLECT),
+LintId::of(methods::ITER_NEXT_SLICE),
+LintId::of(methods::ITER_NTH_ZERO),
+LintId::of(methods::ITER_SKIP_NEXT),
+LintId::of(methods::MANUAL_SATURATING_ARITHMETIC),
+LintId::of(methods::MAP_COLLECT_RESULT_UNIT),
+LintId::of(methods::NEW_RET_NO_SELF),
+LintId::of(methods::OK_EXPECT),
+LintId::of(methods::OPTION_MAP_OR_NONE),
+LintId::of(methods::RESULT_MAP_OR_INTO_OPTION),
+LintId::of(methods::SHOULD_IMPLEMENT_TRAIT),
+LintId::of(methods::SINGLE_CHAR_ADD_STR),
+LintId::of(methods::STRING_EXTEND_CHARS),
+LintId::of(methods::UNNECESSARY_FOLD),
+LintId::of(methods::UNNECESSARY_LAZY_EVALUATIONS),
+LintId::of(methods::UNWRAP_OR_ELSE_DEFAULT),
+LintId::of(methods::WRONG_SELF_CONVENTION),
+LintId::of(misc::TOPLEVEL_REF_ARG),
+LintId::of(misc::ZERO_PTR),
+LintId::of(misc_early::BUILTIN_TYPE_SHADOW),
+LintId::of(misc_early::DOUBLE_NEG),
+LintId::of(misc_early::DUPLICATE_UNDERSCORE_ARGUMENT),
+LintId::of(misc_early::MIXED_CASE_HEX_LITERALS),
+LintId::of(misc_early::REDUNDANT_PATTERN),
+LintId::of(mut_mutex_lock::MUT_MUTEX_LOCK),
+LintId::of(mut_reference::UNNECESSARY_MUT_PASSED),
+LintId::of(needless_borrow::NEEDLESS_BORROW),
+LintId::of(neg_multiply::NEG_MULTIPLY),
+LintId::of(new_without_default::NEW_WITHOUT_DEFAULT),
+LintId::of(non_copy_const::BORROW_INTERIOR_MUTABLE_CONST),
+LintId::of(non_copy_const::DECLARE_INTERIOR_MUTABLE_CONST),
+LintId::of(non_expressive_names::JUST_UNDERSCORES_AND_DIGITS),
+LintId::of(ptr::CMP_NULL),
+LintId::of(ptr::PTR_ARG),
+LintId::of(ptr_eq::PTR_EQ),
+LintId::of(question_mark::QUESTION_MARK),
+LintId::of(ranges::MANUAL_RANGE_CONTAINS),
+LintId::of(redundant_field_names::REDUNDANT_FIELD_NAMES),
+LintId::of(redundant_static_lifetimes::REDUNDANT_STATIC_LIFETIMES),
+LintId::of(returns::LET_AND_RETURN),
+LintId::of(returns::NEEDLESS_RETURN),
+LintId::of(self_named_constructors::SELF_NAMED_CONSTRUCTORS),
+LintId::of(single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS),
+LintId::of(tabs_in_doc_comments::TABS_IN_DOC_COMMENTS),
+LintId::of(to_digit_is_some::TO_DIGIT_IS_SOME),
+LintId::of(try_err::TRY_ERR),
+LintId::of(unsafe_removed_from_name::UNSAFE_REMOVED_FROM_NAME),
+LintId::of(unused_unit::UNUSED_UNIT),
+LintId::of(upper_case_acronyms::UPPER_CASE_ACRONYMS),
+LintId::of(write::PRINTLN_EMPTY_STRING),
+LintId::of(write::PRINT_LITERAL),
+LintId::of(write::PRINT_WITH_NEWLINE),
+LintId::of(write::WRITELN_EMPTY_STRING),
+LintId::of(write::WRITE_LITERAL),
+LintId::of(write::WRITE_WITH_NEWLINE),
+])
\ No newline at end of file
diff --git a/clippy_lints/src/lib.register_suspicious.rs b/clippy_lints/src/lib.register_suspicious.rs
new file mode 100644
index 00000000000..c424efe69b3
--- /dev/null
+++ b/clippy_lints/src/lib.register_suspicious.rs
@@ -0,0 +1,20 @@
+// This file was generated by `cargo dev update_lints`.
+// Use that command to update this file and do not edit by hand.
+// Manual edits will be overwritten.
+
+store.register_group(true, "clippy::suspicious", Some("clippy_suspicious"), vec![
+LintId::of(assign_ops::MISREFACTORED_ASSIGN_OP),
+LintId::of(attrs::BLANKET_CLIPPY_RESTRICTION_LINTS),
+LintId::of(eval_order_dependence::EVAL_ORDER_DEPENDENCE),
+LintId::of(float_equality_without_abs::FLOAT_EQUALITY_WITHOUT_ABS),
+LintId::of(formatting::SUSPICIOUS_ASSIGNMENT_FORMATTING),
+LintId::of(formatting::SUSPICIOUS_ELSE_FORMATTING),
+LintId::of(formatting::SUSPICIOUS_UNARY_OP_FORMATTING),
+LintId::of(loops::EMPTY_LOOP),
+LintId::of(loops::FOR_LOOPS_OVER_FALLIBLES),
+LintId::of(loops::MUT_RANGE_BOUND),
+LintId::of(methods::SUSPICIOUS_MAP),
+LintId::of(mut_key::MUTABLE_KEY_TYPE),
+LintId::of(suspicious_trait_impl::SUSPICIOUS_ARITHMETIC_IMPL),
+LintId::of(suspicious_trait_impl::SUSPICIOUS_OP_ASSIGN_IMPL),
+])
\ No newline at end of file
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 89724917482..d43ce4a87c6 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -155,236 +155,7 @@ macro_rules! declare_clippy_lint {
 mod deprecated_lints;
 mod utils;
 
-// begin lints modules, do not remove this comment, it’s used in `update_lints`
-mod absurd_extreme_comparisons;
-mod approx_const;
-mod arithmetic;
-mod as_conversions;
-mod asm_syntax;
-mod assertions_on_constants;
-mod assign_ops;
-mod async_yields_async;
-mod attrs;
-mod await_holding_invalid;
-mod bit_mask;
-mod blacklisted_name;
-mod blocks_in_if_conditions;
-mod bool_assert_comparison;
-mod booleans;
-mod bytecount;
-mod cargo_common_metadata;
-mod case_sensitive_file_extension_comparisons;
-mod casts;
-mod checked_conversions;
-mod cognitive_complexity;
-mod collapsible_if;
-mod collapsible_match;
-mod comparison_chain;
-mod copies;
-mod copy_iterator;
-mod create_dir;
-mod dbg_macro;
-mod default;
-mod default_numeric_fallback;
-mod dereference;
-mod derivable_impls;
-mod derive;
-mod disallowed_method;
-mod disallowed_script_idents;
-mod disallowed_type;
-mod doc;
-mod double_comparison;
-mod double_parens;
-mod drop_forget_ref;
-mod duration_subsec;
-mod else_if_without_else;
-mod empty_enum;
-mod entry;
-mod enum_clike;
-mod enum_variants;
-mod eq_op;
-mod erasing_op;
-mod escape;
-mod eta_reduction;
-mod eval_order_dependence;
-mod excessive_bools;
-mod exhaustive_items;
-mod exit;
-mod explicit_write;
-mod fallible_impl_from;
-mod feature_name;
-mod float_equality_without_abs;
-mod float_literal;
-mod floating_point_arithmetic;
-mod format;
-mod formatting;
-mod from_over_into;
-mod from_str_radix_10;
-mod functions;
-mod future_not_send;
-mod get_last_with_len;
-mod identity_op;
-mod if_let_mutex;
-mod if_not_else;
-mod if_then_panic;
-mod if_then_some_else_none;
-mod implicit_hasher;
-mod implicit_return;
-mod implicit_saturating_sub;
-mod inconsistent_struct_constructor;
-mod indexing_slicing;
-mod infinite_iter;
-mod inherent_impl;
-mod inherent_to_string;
-mod inline_fn_without_body;
-mod int_plus_one;
-mod integer_division;
-mod invalid_upcast_comparisons;
-mod items_after_statements;
-mod iter_not_returning_iterator;
-mod large_const_arrays;
-mod large_enum_variant;
-mod large_stack_arrays;
-mod len_zero;
-mod let_if_seq;
-mod let_underscore;
-mod lifetimes;
-mod literal_representation;
-mod loops;
-mod macro_use;
-mod main_recursion;
-mod manual_async_fn;
-mod manual_map;
-mod manual_non_exhaustive;
-mod manual_ok_or;
-mod manual_strip;
-mod manual_unwrap_or;
-mod map_clone;
-mod map_err_ignore;
-mod map_unit_fn;
-mod match_on_vec_items;
-mod match_result_ok;
-mod matches;
-mod mem_discriminant;
-mod mem_forget;
-mod mem_replace;
-mod methods;
-mod minmax;
-mod misc;
-mod misc_early;
-mod missing_const_for_fn;
-mod missing_doc;
-mod missing_enforced_import_rename;
-mod missing_inline;
-mod module_style;
-mod modulo_arithmetic;
-mod multiple_crate_versions;
-mod mut_key;
-mod mut_mut;
-mod mut_mutex_lock;
-mod mut_reference;
-mod mutable_debug_assertion;
-mod mutex_atomic;
-mod needless_arbitrary_self_type;
-mod needless_bitwise_bool;
-mod needless_bool;
-mod needless_borrow;
-mod needless_borrowed_ref;
-mod needless_continue;
-mod needless_for_each;
-mod needless_option_as_deref;
-mod needless_pass_by_value;
-mod needless_question_mark;
-mod needless_update;
-mod neg_cmp_op_on_partial_ord;
-mod neg_multiply;
-mod new_without_default;
-mod no_effect;
-mod non_copy_const;
-mod non_expressive_names;
-mod non_octal_unix_permissions;
-mod nonstandard_macro_braces;
-mod open_options;
-mod option_env_unwrap;
-mod option_if_let_else;
-mod overflow_check_conditional;
-mod panic_in_result_fn;
-mod panic_unimplemented;
-mod partialeq_ne_impl;
-mod pass_by_ref_or_value;
-mod path_buf_push_overwrite;
-mod pattern_type_mismatch;
-mod precedence;
-mod ptr;
-mod ptr_eq;
-mod ptr_offset_with_cast;
-mod question_mark;
-mod ranges;
-mod redundant_clone;
-mod redundant_closure_call;
-mod redundant_else;
-mod redundant_field_names;
-mod redundant_pub_crate;
-mod redundant_slicing;
-mod redundant_static_lifetimes;
-mod ref_option_ref;
-mod reference;
-mod regex;
-mod repeat_once;
-mod returns;
-mod same_name_method;
-mod self_assignment;
-mod self_named_constructors;
-mod semicolon_if_nothing_returned;
-mod serde_api;
-mod shadow;
-mod single_component_path_imports;
-mod size_of_in_element_count;
-mod slow_vector_initialization;
-mod stable_sort_primitive;
-mod strings;
-mod strlen_on_c_strings;
-mod suspicious_operation_groupings;
-mod suspicious_trait_impl;
-mod swap;
-mod tabs_in_doc_comments;
-mod temporary_assignment;
-mod to_digit_is_some;
-mod to_string_in_display;
-mod trait_bounds;
-mod transmute;
-mod transmuting_null;
-mod try_err;
-mod types;
-mod undropped_manually_drops;
-mod unicode;
-mod unit_return_expecting_ord;
-mod unit_types;
-mod unnamed_address;
-mod unnecessary_self_imports;
-mod unnecessary_sort_by;
-mod unnecessary_wraps;
-mod unnested_or_patterns;
-mod unsafe_removed_from_name;
-mod unused_async;
-mod unused_io_amount;
-mod unused_self;
-mod unused_unit;
-mod unwrap;
-mod unwrap_in_result;
-mod upper_case_acronyms;
-mod use_self;
-mod useless_conversion;
-mod vec;
-mod vec_init_then_push;
-mod vec_resize_to_zero;
-mod verbose_file_reads;
-mod wildcard_dependencies;
-mod wildcard_imports;
-mod write;
-mod zero_div_zero;
-mod zero_sized_map_values;
-// end lints modules, do not remove this comment, it’s used in `update_lints`
+include!("lib.mods.rs");
 
 pub use crate::utils::conf::Conf;
 use crate::utils::conf::TryConf;
@@ -438,1401 +209,23 @@ pub fn read_conf(sess: &Session) -> Conf {
 pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf: &Conf) {
     register_removed_non_tool_lints(store);
 
-    // begin deprecated lints, do not remove this comment, it’s used in `update_lints`
-    store.register_removed(
-        "clippy::should_assert_eq",
-        "`assert!()` will be more flexible with RFC 2011",
-    );
-    store.register_removed(
-        "clippy::extend_from_slice",
-        "`.extend_from_slice(_)` is a faster way to extend a Vec by a slice",
-    );
-    store.register_removed(
-        "clippy::range_step_by_zero",
-        "`iterator.step_by(0)` panics nowadays",
-    );
-    store.register_removed(
-        "clippy::unstable_as_slice",
-        "`Vec::as_slice` has been stabilized in 1.7",
-    );
-    store.register_removed(
-        "clippy::unstable_as_mut_slice",
-        "`Vec::as_mut_slice` has been stabilized in 1.7",
-    );
-    store.register_removed(
-        "clippy::misaligned_transmute",
-        "this lint has been split into cast_ptr_alignment and transmute_ptr_to_ptr",
-    );
-    store.register_removed(
-        "clippy::assign_ops",
-        "using compound assignment operators (e.g., `+=`) is harmless",
-    );
-    store.register_removed(
-        "clippy::if_let_redundant_pattern_matching",
-        "this lint has been changed to redundant_pattern_matching",
-    );
-    store.register_removed(
-        "clippy::unsafe_vector_initialization",
-        "the replacement suggested by this lint had substantially different behavior",
-    );
-    store.register_removed(
-        "clippy::unused_collect",
-        "`collect` has been marked as #[must_use] in rustc and that covers all cases of this lint",
-    );
-    store.register_removed(
-        "clippy::replace_consts",
-        "associated-constants `MIN`/`MAX` of integers are preferred to `{min,max}_value()` and module constants",
-    );
-    store.register_removed(
-        "clippy::regex_macro",
-        "the regex! macro has been removed from the regex crate in 2018",
-    );
-    store.register_removed(
-        "clippy::find_map",
-        "this lint has been replaced by `manual_find_map`, a more specific lint",
-    );
-    store.register_removed(
-        "clippy::filter_map",
-        "this lint has been replaced by `manual_filter_map`, a more specific lint",
-    );
-    store.register_removed(
-        "clippy::pub_enum_variant_names",
-        "set the `avoid-breaking-exported-api` config option to `false` to enable the `enum_variant_names` lint for public items",
-    );
-    store.register_removed(
-        "clippy::wrong_pub_self_convention",
-        "set the `avoid-breaking-exported-api` config option to `false` to enable the `wrong_self_convention` lint for public items",
-    );
-    // end deprecated lints, do not remove this comment, it’s used in `update_lints`
-
-    // begin register lints, do not remove this comment, it’s used in `update_lints`
-    store.register_lints(&[
-        #[cfg(feature = "internal-lints")]
-        utils::internal_lints::CLIPPY_LINTS_INTERNAL,
-        #[cfg(feature = "internal-lints")]
-        utils::internal_lints::COLLAPSIBLE_SPAN_LINT_CALLS,
-        #[cfg(feature = "internal-lints")]
-        utils::internal_lints::COMPILER_LINT_FUNCTIONS,
-        #[cfg(feature = "internal-lints")]
-        utils::internal_lints::DEFAULT_LINT,
-        #[cfg(feature = "internal-lints")]
-        utils::internal_lints::IF_CHAIN_STYLE,
-        #[cfg(feature = "internal-lints")]
-        utils::internal_lints::INTERNING_DEFINED_SYMBOL,
-        #[cfg(feature = "internal-lints")]
-        utils::internal_lints::INVALID_PATHS,
-        #[cfg(feature = "internal-lints")]
-        utils::internal_lints::LINT_WITHOUT_LINT_PASS,
-        #[cfg(feature = "internal-lints")]
-        utils::internal_lints::MATCH_TYPE_ON_DIAGNOSTIC_ITEM,
-        #[cfg(feature = "internal-lints")]
-        utils::internal_lints::OUTER_EXPN_EXPN_DATA,
-        #[cfg(feature = "internal-lints")]
-        utils::internal_lints::PRODUCE_ICE,
-        #[cfg(feature = "internal-lints")]
-        utils::internal_lints::UNNECESSARY_SYMBOL_STR,
-        absurd_extreme_comparisons::ABSURD_EXTREME_COMPARISONS,
-        approx_const::APPROX_CONSTANT,
-        arithmetic::FLOAT_ARITHMETIC,
-        arithmetic::INTEGER_ARITHMETIC,
-        as_conversions::AS_CONVERSIONS,
-        asm_syntax::INLINE_ASM_X86_ATT_SYNTAX,
-        asm_syntax::INLINE_ASM_X86_INTEL_SYNTAX,
-        assertions_on_constants::ASSERTIONS_ON_CONSTANTS,
-        assign_ops::ASSIGN_OP_PATTERN,
-        assign_ops::MISREFACTORED_ASSIGN_OP,
-        async_yields_async::ASYNC_YIELDS_ASYNC,
-        attrs::BLANKET_CLIPPY_RESTRICTION_LINTS,
-        attrs::DEPRECATED_CFG_ATTR,
-        attrs::DEPRECATED_SEMVER,
-        attrs::EMPTY_LINE_AFTER_OUTER_ATTR,
-        attrs::INLINE_ALWAYS,
-        attrs::MISMATCHED_TARGET_OS,
-        attrs::USELESS_ATTRIBUTE,
-        await_holding_invalid::AWAIT_HOLDING_LOCK,
-        await_holding_invalid::AWAIT_HOLDING_REFCELL_REF,
-        bit_mask::BAD_BIT_MASK,
-        bit_mask::INEFFECTIVE_BIT_MASK,
-        bit_mask::VERBOSE_BIT_MASK,
-        blacklisted_name::BLACKLISTED_NAME,
-        blocks_in_if_conditions::BLOCKS_IN_IF_CONDITIONS,
-        bool_assert_comparison::BOOL_ASSERT_COMPARISON,
-        booleans::LOGIC_BUG,
-        booleans::NONMINIMAL_BOOL,
-        bytecount::NAIVE_BYTECOUNT,
-        cargo_common_metadata::CARGO_COMMON_METADATA,
-        case_sensitive_file_extension_comparisons::CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS,
-        casts::CAST_LOSSLESS,
-        casts::CAST_POSSIBLE_TRUNCATION,
-        casts::CAST_POSSIBLE_WRAP,
-        casts::CAST_PRECISION_LOSS,
-        casts::CAST_PTR_ALIGNMENT,
-        casts::CAST_REF_TO_MUT,
-        casts::CAST_SIGN_LOSS,
-        casts::CHAR_LIT_AS_U8,
-        casts::FN_TO_NUMERIC_CAST,
-        casts::FN_TO_NUMERIC_CAST_WITH_TRUNCATION,
-        casts::PTR_AS_PTR,
-        casts::UNNECESSARY_CAST,
-        checked_conversions::CHECKED_CONVERSIONS,
-        cognitive_complexity::COGNITIVE_COMPLEXITY,
-        collapsible_if::COLLAPSIBLE_ELSE_IF,
-        collapsible_if::COLLAPSIBLE_IF,
-        collapsible_match::COLLAPSIBLE_MATCH,
-        comparison_chain::COMPARISON_CHAIN,
-        copies::BRANCHES_SHARING_CODE,
-        copies::IFS_SAME_COND,
-        copies::IF_SAME_THEN_ELSE,
-        copies::SAME_FUNCTIONS_IN_IF_CONDITION,
-        copy_iterator::COPY_ITERATOR,
-        create_dir::CREATE_DIR,
-        dbg_macro::DBG_MACRO,
-        default::DEFAULT_TRAIT_ACCESS,
-        default::FIELD_REASSIGN_WITH_DEFAULT,
-        default_numeric_fallback::DEFAULT_NUMERIC_FALLBACK,
-        dereference::EXPLICIT_DEREF_METHODS,
-        derivable_impls::DERIVABLE_IMPLS,
-        derive::DERIVE_HASH_XOR_EQ,
-        derive::DERIVE_ORD_XOR_PARTIAL_ORD,
-        derive::EXPL_IMPL_CLONE_ON_COPY,
-        derive::UNSAFE_DERIVE_DESERIALIZE,
-        disallowed_method::DISALLOWED_METHOD,
-        disallowed_script_idents::DISALLOWED_SCRIPT_IDENTS,
-        disallowed_type::DISALLOWED_TYPE,
-        doc::DOC_MARKDOWN,
-        doc::MISSING_ERRORS_DOC,
-        doc::MISSING_PANICS_DOC,
-        doc::MISSING_SAFETY_DOC,
-        doc::NEEDLESS_DOCTEST_MAIN,
-        double_comparison::DOUBLE_COMPARISONS,
-        double_parens::DOUBLE_PARENS,
-        drop_forget_ref::DROP_COPY,
-        drop_forget_ref::DROP_REF,
-        drop_forget_ref::FORGET_COPY,
-        drop_forget_ref::FORGET_REF,
-        duration_subsec::DURATION_SUBSEC,
-        else_if_without_else::ELSE_IF_WITHOUT_ELSE,
-        empty_enum::EMPTY_ENUM,
-        entry::MAP_ENTRY,
-        enum_clike::ENUM_CLIKE_UNPORTABLE_VARIANT,
-        enum_variants::ENUM_VARIANT_NAMES,
-        enum_variants::MODULE_INCEPTION,
-        enum_variants::MODULE_NAME_REPETITIONS,
-        eq_op::EQ_OP,
-        eq_op::OP_REF,
-        erasing_op::ERASING_OP,
-        escape::BOXED_LOCAL,
-        eta_reduction::REDUNDANT_CLOSURE,
-        eta_reduction::REDUNDANT_CLOSURE_FOR_METHOD_CALLS,
-        eval_order_dependence::DIVERGING_SUB_EXPRESSION,
-        eval_order_dependence::EVAL_ORDER_DEPENDENCE,
-        excessive_bools::FN_PARAMS_EXCESSIVE_BOOLS,
-        excessive_bools::STRUCT_EXCESSIVE_BOOLS,
-        exhaustive_items::EXHAUSTIVE_ENUMS,
-        exhaustive_items::EXHAUSTIVE_STRUCTS,
-        exit::EXIT,
-        explicit_write::EXPLICIT_WRITE,
-        fallible_impl_from::FALLIBLE_IMPL_FROM,
-        feature_name::NEGATIVE_FEATURE_NAMES,
-        feature_name::REDUNDANT_FEATURE_NAMES,
-        float_equality_without_abs::FLOAT_EQUALITY_WITHOUT_ABS,
-        float_literal::EXCESSIVE_PRECISION,
-        float_literal::LOSSY_FLOAT_LITERAL,
-        floating_point_arithmetic::IMPRECISE_FLOPS,
-        floating_point_arithmetic::SUBOPTIMAL_FLOPS,
-        format::USELESS_FORMAT,
-        formatting::POSSIBLE_MISSING_COMMA,
-        formatting::SUSPICIOUS_ASSIGNMENT_FORMATTING,
-        formatting::SUSPICIOUS_ELSE_FORMATTING,
-        formatting::SUSPICIOUS_UNARY_OP_FORMATTING,
-        from_over_into::FROM_OVER_INTO,
-        from_str_radix_10::FROM_STR_RADIX_10,
-        functions::DOUBLE_MUST_USE,
-        functions::MUST_USE_CANDIDATE,
-        functions::MUST_USE_UNIT,
-        functions::NOT_UNSAFE_PTR_ARG_DEREF,
-        functions::RESULT_UNIT_ERR,
-        functions::TOO_MANY_ARGUMENTS,
-        functions::TOO_MANY_LINES,
-        future_not_send::FUTURE_NOT_SEND,
-        get_last_with_len::GET_LAST_WITH_LEN,
-        identity_op::IDENTITY_OP,
-        if_let_mutex::IF_LET_MUTEX,
-        if_not_else::IF_NOT_ELSE,
-        if_then_panic::IF_THEN_PANIC,
-        if_then_some_else_none::IF_THEN_SOME_ELSE_NONE,
-        implicit_hasher::IMPLICIT_HASHER,
-        implicit_return::IMPLICIT_RETURN,
-        implicit_saturating_sub::IMPLICIT_SATURATING_SUB,
-        inconsistent_struct_constructor::INCONSISTENT_STRUCT_CONSTRUCTOR,
-        indexing_slicing::INDEXING_SLICING,
-        indexing_slicing::OUT_OF_BOUNDS_INDEXING,
-        infinite_iter::INFINITE_ITER,
-        infinite_iter::MAYBE_INFINITE_ITER,
-        inherent_impl::MULTIPLE_INHERENT_IMPL,
-        inherent_to_string::INHERENT_TO_STRING,
-        inherent_to_string::INHERENT_TO_STRING_SHADOW_DISPLAY,
-        inline_fn_without_body::INLINE_FN_WITHOUT_BODY,
-        int_plus_one::INT_PLUS_ONE,
-        integer_division::INTEGER_DIVISION,
-        invalid_upcast_comparisons::INVALID_UPCAST_COMPARISONS,
-        items_after_statements::ITEMS_AFTER_STATEMENTS,
-        iter_not_returning_iterator::ITER_NOT_RETURNING_ITERATOR,
-        large_const_arrays::LARGE_CONST_ARRAYS,
-        large_enum_variant::LARGE_ENUM_VARIANT,
-        large_stack_arrays::LARGE_STACK_ARRAYS,
-        len_zero::COMPARISON_TO_EMPTY,
-        len_zero::LEN_WITHOUT_IS_EMPTY,
-        len_zero::LEN_ZERO,
-        let_if_seq::USELESS_LET_IF_SEQ,
-        let_underscore::LET_UNDERSCORE_DROP,
-        let_underscore::LET_UNDERSCORE_LOCK,
-        let_underscore::LET_UNDERSCORE_MUST_USE,
-        lifetimes::EXTRA_UNUSED_LIFETIMES,
-        lifetimes::NEEDLESS_LIFETIMES,
-        literal_representation::DECIMAL_LITERAL_REPRESENTATION,
-        literal_representation::INCONSISTENT_DIGIT_GROUPING,
-        literal_representation::LARGE_DIGIT_GROUPS,
-        literal_representation::MISTYPED_LITERAL_SUFFIXES,
-        literal_representation::UNREADABLE_LITERAL,
-        literal_representation::UNUSUAL_BYTE_GROUPINGS,
-        loops::EMPTY_LOOP,
-        loops::EXPLICIT_COUNTER_LOOP,
-        loops::EXPLICIT_INTO_ITER_LOOP,
-        loops::EXPLICIT_ITER_LOOP,
-        loops::FOR_KV_MAP,
-        loops::FOR_LOOPS_OVER_FALLIBLES,
-        loops::ITER_NEXT_LOOP,
-        loops::MANUAL_FLATTEN,
-        loops::MANUAL_MEMCPY,
-        loops::MUT_RANGE_BOUND,
-        loops::NEEDLESS_COLLECT,
-        loops::NEEDLESS_RANGE_LOOP,
-        loops::NEVER_LOOP,
-        loops::SAME_ITEM_PUSH,
-        loops::SINGLE_ELEMENT_LOOP,
-        loops::WHILE_IMMUTABLE_CONDITION,
-        loops::WHILE_LET_LOOP,
-        loops::WHILE_LET_ON_ITERATOR,
-        macro_use::MACRO_USE_IMPORTS,
-        main_recursion::MAIN_RECURSION,
-        manual_async_fn::MANUAL_ASYNC_FN,
-        manual_map::MANUAL_MAP,
-        manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE,
-        manual_ok_or::MANUAL_OK_OR,
-        manual_strip::MANUAL_STRIP,
-        manual_unwrap_or::MANUAL_UNWRAP_OR,
-        map_clone::MAP_CLONE,
-        map_err_ignore::MAP_ERR_IGNORE,
-        map_unit_fn::OPTION_MAP_UNIT_FN,
-        map_unit_fn::RESULT_MAP_UNIT_FN,
-        match_on_vec_items::MATCH_ON_VEC_ITEMS,
-        match_result_ok::MATCH_RESULT_OK,
-        matches::INFALLIBLE_DESTRUCTURING_MATCH,
-        matches::MATCH_AS_REF,
-        matches::MATCH_BOOL,
-        matches::MATCH_LIKE_MATCHES_MACRO,
-        matches::MATCH_OVERLAPPING_ARM,
-        matches::MATCH_REF_PATS,
-        matches::MATCH_SAME_ARMS,
-        matches::MATCH_SINGLE_BINDING,
-        matches::MATCH_WILDCARD_FOR_SINGLE_VARIANTS,
-        matches::MATCH_WILD_ERR_ARM,
-        matches::REDUNDANT_PATTERN_MATCHING,
-        matches::REST_PAT_IN_FULLY_BOUND_STRUCTS,
-        matches::SINGLE_MATCH,
-        matches::SINGLE_MATCH_ELSE,
-        matches::WILDCARD_ENUM_MATCH_ARM,
-        matches::WILDCARD_IN_OR_PATTERNS,
-        mem_discriminant::MEM_DISCRIMINANT_NON_ENUM,
-        mem_forget::MEM_FORGET,
-        mem_replace::MEM_REPLACE_OPTION_WITH_NONE,
-        mem_replace::MEM_REPLACE_WITH_DEFAULT,
-        mem_replace::MEM_REPLACE_WITH_UNINIT,
-        methods::BIND_INSTEAD_OF_MAP,
-        methods::BYTES_NTH,
-        methods::CHARS_LAST_CMP,
-        methods::CHARS_NEXT_CMP,
-        methods::CLONED_INSTEAD_OF_COPIED,
-        methods::CLONE_DOUBLE_REF,
-        methods::CLONE_ON_COPY,
-        methods::CLONE_ON_REF_PTR,
-        methods::EXPECT_FUN_CALL,
-        methods::EXPECT_USED,
-        methods::EXTEND_WITH_DRAIN,
-        methods::FILETYPE_IS_FILE,
-        methods::FILTER_MAP_IDENTITY,
-        methods::FILTER_MAP_NEXT,
-        methods::FILTER_NEXT,
-        methods::FLAT_MAP_IDENTITY,
-        methods::FLAT_MAP_OPTION,
-        methods::FROM_ITER_INSTEAD_OF_COLLECT,
-        methods::GET_UNWRAP,
-        methods::IMPLICIT_CLONE,
-        methods::INEFFICIENT_TO_STRING,
-        methods::INSPECT_FOR_EACH,
-        methods::INTO_ITER_ON_REF,
-        methods::ITERATOR_STEP_BY_ZERO,
-        methods::ITER_CLONED_COLLECT,
-        methods::ITER_COUNT,
-        methods::ITER_NEXT_SLICE,
-        methods::ITER_NTH,
-        methods::ITER_NTH_ZERO,
-        methods::ITER_SKIP_NEXT,
-        methods::MANUAL_FILTER_MAP,
-        methods::MANUAL_FIND_MAP,
-        methods::MANUAL_SATURATING_ARITHMETIC,
-        methods::MANUAL_SPLIT_ONCE,
-        methods::MANUAL_STR_REPEAT,
-        methods::MAP_COLLECT_RESULT_UNIT,
-        methods::MAP_FLATTEN,
-        methods::MAP_IDENTITY,
-        methods::MAP_UNWRAP_OR,
-        methods::NEW_RET_NO_SELF,
-        methods::OK_EXPECT,
-        methods::OPTION_AS_REF_DEREF,
-        methods::OPTION_FILTER_MAP,
-        methods::OPTION_MAP_OR_NONE,
-        methods::OR_FUN_CALL,
-        methods::RESULT_MAP_OR_INTO_OPTION,
-        methods::SEARCH_IS_SOME,
-        methods::SHOULD_IMPLEMENT_TRAIT,
-        methods::SINGLE_CHAR_ADD_STR,
-        methods::SINGLE_CHAR_PATTERN,
-        methods::SKIP_WHILE_NEXT,
-        methods::STRING_EXTEND_CHARS,
-        methods::SUSPICIOUS_MAP,
-        methods::SUSPICIOUS_SPLITN,
-        methods::UNINIT_ASSUMED_INIT,
-        methods::UNNECESSARY_FILTER_MAP,
-        methods::UNNECESSARY_FOLD,
-        methods::UNNECESSARY_LAZY_EVALUATIONS,
-        methods::UNWRAP_OR_ELSE_DEFAULT,
-        methods::UNWRAP_USED,
-        methods::USELESS_ASREF,
-        methods::WRONG_SELF_CONVENTION,
-        methods::ZST_OFFSET,
-        minmax::MIN_MAX,
-        misc::CMP_NAN,
-        misc::CMP_OWNED,
-        misc::FLOAT_CMP,
-        misc::FLOAT_CMP_CONST,
-        misc::MODULO_ONE,
-        misc::SHORT_CIRCUIT_STATEMENT,
-        misc::TOPLEVEL_REF_ARG,
-        misc::USED_UNDERSCORE_BINDING,
-        misc::ZERO_PTR,
-        misc_early::BUILTIN_TYPE_SHADOW,
-        misc_early::DOUBLE_NEG,
-        misc_early::DUPLICATE_UNDERSCORE_ARGUMENT,
-        misc_early::MIXED_CASE_HEX_LITERALS,
-        misc_early::REDUNDANT_PATTERN,
-        misc_early::UNNEEDED_FIELD_PATTERN,
-        misc_early::UNNEEDED_WILDCARD_PATTERN,
-        misc_early::UNSEPARATED_LITERAL_SUFFIX,
-        misc_early::ZERO_PREFIXED_LITERAL,
-        missing_const_for_fn::MISSING_CONST_FOR_FN,
-        missing_doc::MISSING_DOCS_IN_PRIVATE_ITEMS,
-        missing_enforced_import_rename::MISSING_ENFORCED_IMPORT_RENAMES,
-        missing_inline::MISSING_INLINE_IN_PUBLIC_ITEMS,
-        module_style::MOD_MODULE_FILES,
-        module_style::SELF_NAMED_MODULE_FILES,
-        modulo_arithmetic::MODULO_ARITHMETIC,
-        multiple_crate_versions::MULTIPLE_CRATE_VERSIONS,
-        mut_key::MUTABLE_KEY_TYPE,
-        mut_mut::MUT_MUT,
-        mut_mutex_lock::MUT_MUTEX_LOCK,
-        mut_reference::UNNECESSARY_MUT_PASSED,
-        mutable_debug_assertion::DEBUG_ASSERT_WITH_MUT_CALL,
-        mutex_atomic::MUTEX_ATOMIC,
-        mutex_atomic::MUTEX_INTEGER,
-        needless_arbitrary_self_type::NEEDLESS_ARBITRARY_SELF_TYPE,
-        needless_bitwise_bool::NEEDLESS_BITWISE_BOOL,
-        needless_bool::BOOL_COMPARISON,
-        needless_bool::NEEDLESS_BOOL,
-        needless_borrow::NEEDLESS_BORROW,
-        needless_borrow::REF_BINDING_TO_REFERENCE,
-        needless_borrowed_ref::NEEDLESS_BORROWED_REFERENCE,
-        needless_continue::NEEDLESS_CONTINUE,
-        needless_for_each::NEEDLESS_FOR_EACH,
-        needless_option_as_deref::NEEDLESS_OPTION_AS_DEREF,
-        needless_pass_by_value::NEEDLESS_PASS_BY_VALUE,
-        needless_question_mark::NEEDLESS_QUESTION_MARK,
-        needless_update::NEEDLESS_UPDATE,
-        neg_cmp_op_on_partial_ord::NEG_CMP_OP_ON_PARTIAL_ORD,
-        neg_multiply::NEG_MULTIPLY,
-        new_without_default::NEW_WITHOUT_DEFAULT,
-        no_effect::NO_EFFECT,
-        no_effect::UNNECESSARY_OPERATION,
-        non_copy_const::BORROW_INTERIOR_MUTABLE_CONST,
-        non_copy_const::DECLARE_INTERIOR_MUTABLE_CONST,
-        non_expressive_names::JUST_UNDERSCORES_AND_DIGITS,
-        non_expressive_names::MANY_SINGLE_CHAR_NAMES,
-        non_expressive_names::SIMILAR_NAMES,
-        non_octal_unix_permissions::NON_OCTAL_UNIX_PERMISSIONS,
-        nonstandard_macro_braces::NONSTANDARD_MACRO_BRACES,
-        open_options::NONSENSICAL_OPEN_OPTIONS,
-        option_env_unwrap::OPTION_ENV_UNWRAP,
-        option_if_let_else::OPTION_IF_LET_ELSE,
-        overflow_check_conditional::OVERFLOW_CHECK_CONDITIONAL,
-        panic_in_result_fn::PANIC_IN_RESULT_FN,
-        panic_unimplemented::PANIC,
-        panic_unimplemented::TODO,
-        panic_unimplemented::UNIMPLEMENTED,
-        panic_unimplemented::UNREACHABLE,
-        partialeq_ne_impl::PARTIALEQ_NE_IMPL,
-        pass_by_ref_or_value::LARGE_TYPES_PASSED_BY_VALUE,
-        pass_by_ref_or_value::TRIVIALLY_COPY_PASS_BY_REF,
-        path_buf_push_overwrite::PATH_BUF_PUSH_OVERWRITE,
-        pattern_type_mismatch::PATTERN_TYPE_MISMATCH,
-        precedence::PRECEDENCE,
-        ptr::CMP_NULL,
-        ptr::INVALID_NULL_PTR_USAGE,
-        ptr::MUT_FROM_REF,
-        ptr::PTR_ARG,
-        ptr_eq::PTR_EQ,
-        ptr_offset_with_cast::PTR_OFFSET_WITH_CAST,
-        question_mark::QUESTION_MARK,
-        ranges::MANUAL_RANGE_CONTAINS,
-        ranges::RANGE_MINUS_ONE,
-        ranges::RANGE_PLUS_ONE,
-        ranges::RANGE_ZIP_WITH_LEN,
-        ranges::REVERSED_EMPTY_RANGES,
-        redundant_clone::REDUNDANT_CLONE,
-        redundant_closure_call::REDUNDANT_CLOSURE_CALL,
-        redundant_else::REDUNDANT_ELSE,
-        redundant_field_names::REDUNDANT_FIELD_NAMES,
-        redundant_pub_crate::REDUNDANT_PUB_CRATE,
-        redundant_slicing::REDUNDANT_SLICING,
-        redundant_static_lifetimes::REDUNDANT_STATIC_LIFETIMES,
-        ref_option_ref::REF_OPTION_REF,
-        reference::DEREF_ADDROF,
-        reference::REF_IN_DEREF,
-        regex::INVALID_REGEX,
-        regex::TRIVIAL_REGEX,
-        repeat_once::REPEAT_ONCE,
-        returns::LET_AND_RETURN,
-        returns::NEEDLESS_RETURN,
-        same_name_method::SAME_NAME_METHOD,
-        self_assignment::SELF_ASSIGNMENT,
-        self_named_constructors::SELF_NAMED_CONSTRUCTORS,
-        semicolon_if_nothing_returned::SEMICOLON_IF_NOTHING_RETURNED,
-        serde_api::SERDE_API_MISUSE,
-        shadow::SHADOW_REUSE,
-        shadow::SHADOW_SAME,
-        shadow::SHADOW_UNRELATED,
-        single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS,
-        size_of_in_element_count::SIZE_OF_IN_ELEMENT_COUNT,
-        slow_vector_initialization::SLOW_VECTOR_INITIALIZATION,
-        stable_sort_primitive::STABLE_SORT_PRIMITIVE,
-        strings::STRING_ADD,
-        strings::STRING_ADD_ASSIGN,
-        strings::STRING_FROM_UTF8_AS_BYTES,
-        strings::STRING_LIT_AS_BYTES,
-        strings::STRING_TO_STRING,
-        strings::STR_TO_STRING,
-        strlen_on_c_strings::STRLEN_ON_C_STRINGS,
-        suspicious_operation_groupings::SUSPICIOUS_OPERATION_GROUPINGS,
-        suspicious_trait_impl::SUSPICIOUS_ARITHMETIC_IMPL,
-        suspicious_trait_impl::SUSPICIOUS_OP_ASSIGN_IMPL,
-        swap::ALMOST_SWAPPED,
-        swap::MANUAL_SWAP,
-        tabs_in_doc_comments::TABS_IN_DOC_COMMENTS,
-        temporary_assignment::TEMPORARY_ASSIGNMENT,
-        to_digit_is_some::TO_DIGIT_IS_SOME,
-        to_string_in_display::TO_STRING_IN_DISPLAY,
-        trait_bounds::TRAIT_DUPLICATION_IN_BOUNDS,
-        trait_bounds::TYPE_REPETITION_IN_BOUNDS,
-        transmute::CROSSPOINTER_TRANSMUTE,
-        transmute::TRANSMUTES_EXPRESSIBLE_AS_PTR_CASTS,
-        transmute::TRANSMUTE_BYTES_TO_STR,
-        transmute::TRANSMUTE_FLOAT_TO_INT,
-        transmute::TRANSMUTE_INT_TO_BOOL,
-        transmute::TRANSMUTE_INT_TO_CHAR,
-        transmute::TRANSMUTE_INT_TO_FLOAT,
-        transmute::TRANSMUTE_PTR_TO_PTR,
-        transmute::TRANSMUTE_PTR_TO_REF,
-        transmute::UNSOUND_COLLECTION_TRANSMUTE,
-        transmute::USELESS_TRANSMUTE,
-        transmute::WRONG_TRANSMUTE,
-        transmuting_null::TRANSMUTING_NULL,
-        try_err::TRY_ERR,
-        types::BORROWED_BOX,
-        types::BOX_COLLECTION,
-        types::LINKEDLIST,
-        types::OPTION_OPTION,
-        types::RC_BUFFER,
-        types::RC_MUTEX,
-        types::REDUNDANT_ALLOCATION,
-        types::TYPE_COMPLEXITY,
-        types::VEC_BOX,
-        undropped_manually_drops::UNDROPPED_MANUALLY_DROPS,
-        unicode::INVISIBLE_CHARACTERS,
-        unicode::NON_ASCII_LITERAL,
-        unicode::UNICODE_NOT_NFC,
-        unit_return_expecting_ord::UNIT_RETURN_EXPECTING_ORD,
-        unit_types::LET_UNIT_VALUE,
-        unit_types::UNIT_ARG,
-        unit_types::UNIT_CMP,
-        unnamed_address::FN_ADDRESS_COMPARISONS,
-        unnamed_address::VTABLE_ADDRESS_COMPARISONS,
-        unnecessary_self_imports::UNNECESSARY_SELF_IMPORTS,
-        unnecessary_sort_by::UNNECESSARY_SORT_BY,
-        unnecessary_wraps::UNNECESSARY_WRAPS,
-        unnested_or_patterns::UNNESTED_OR_PATTERNS,
-        unsafe_removed_from_name::UNSAFE_REMOVED_FROM_NAME,
-        unused_async::UNUSED_ASYNC,
-        unused_io_amount::UNUSED_IO_AMOUNT,
-        unused_self::UNUSED_SELF,
-        unused_unit::UNUSED_UNIT,
-        unwrap::PANICKING_UNWRAP,
-        unwrap::UNNECESSARY_UNWRAP,
-        unwrap_in_result::UNWRAP_IN_RESULT,
-        upper_case_acronyms::UPPER_CASE_ACRONYMS,
-        use_self::USE_SELF,
-        useless_conversion::USELESS_CONVERSION,
-        vec::USELESS_VEC,
-        vec_init_then_push::VEC_INIT_THEN_PUSH,
-        vec_resize_to_zero::VEC_RESIZE_TO_ZERO,
-        verbose_file_reads::VERBOSE_FILE_READS,
-        wildcard_dependencies::WILDCARD_DEPENDENCIES,
-        wildcard_imports::ENUM_GLOB_USE,
-        wildcard_imports::WILDCARD_IMPORTS,
-        write::PRINTLN_EMPTY_STRING,
-        write::PRINT_LITERAL,
-        write::PRINT_STDERR,
-        write::PRINT_STDOUT,
-        write::PRINT_WITH_NEWLINE,
-        write::USE_DEBUG,
-        write::WRITELN_EMPTY_STRING,
-        write::WRITE_LITERAL,
-        write::WRITE_WITH_NEWLINE,
-        zero_div_zero::ZERO_DIVIDED_BY_ZERO,
-        zero_sized_map_values::ZERO_SIZED_MAP_VALUES,
-    ]);
-    // end register lints, do not remove this comment, it’s used in `update_lints`
+    include!("lib.deprecated.rs");
 
-    store.register_group(true, "clippy::restriction", Some("clippy_restriction"), vec![
-        LintId::of(arithmetic::FLOAT_ARITHMETIC),
-        LintId::of(arithmetic::INTEGER_ARITHMETIC),
-        LintId::of(as_conversions::AS_CONVERSIONS),
-        LintId::of(asm_syntax::INLINE_ASM_X86_ATT_SYNTAX),
-        LintId::of(asm_syntax::INLINE_ASM_X86_INTEL_SYNTAX),
-        LintId::of(create_dir::CREATE_DIR),
-        LintId::of(dbg_macro::DBG_MACRO),
-        LintId::of(default_numeric_fallback::DEFAULT_NUMERIC_FALLBACK),
-        LintId::of(disallowed_script_idents::DISALLOWED_SCRIPT_IDENTS),
-        LintId::of(else_if_without_else::ELSE_IF_WITHOUT_ELSE),
-        LintId::of(exhaustive_items::EXHAUSTIVE_ENUMS),
-        LintId::of(exhaustive_items::EXHAUSTIVE_STRUCTS),
-        LintId::of(exit::EXIT),
-        LintId::of(float_literal::LOSSY_FLOAT_LITERAL),
-        LintId::of(if_then_some_else_none::IF_THEN_SOME_ELSE_NONE),
-        LintId::of(implicit_return::IMPLICIT_RETURN),
-        LintId::of(indexing_slicing::INDEXING_SLICING),
-        LintId::of(inherent_impl::MULTIPLE_INHERENT_IMPL),
-        LintId::of(integer_division::INTEGER_DIVISION),
-        LintId::of(let_underscore::LET_UNDERSCORE_MUST_USE),
-        LintId::of(literal_representation::DECIMAL_LITERAL_REPRESENTATION),
-        LintId::of(map_err_ignore::MAP_ERR_IGNORE),
-        LintId::of(matches::REST_PAT_IN_FULLY_BOUND_STRUCTS),
-        LintId::of(matches::WILDCARD_ENUM_MATCH_ARM),
-        LintId::of(mem_forget::MEM_FORGET),
-        LintId::of(methods::CLONE_ON_REF_PTR),
-        LintId::of(methods::EXPECT_USED),
-        LintId::of(methods::FILETYPE_IS_FILE),
-        LintId::of(methods::GET_UNWRAP),
-        LintId::of(methods::UNWRAP_USED),
-        LintId::of(misc::FLOAT_CMP_CONST),
-        LintId::of(misc_early::UNNEEDED_FIELD_PATTERN),
-        LintId::of(missing_doc::MISSING_DOCS_IN_PRIVATE_ITEMS),
-        LintId::of(missing_enforced_import_rename::MISSING_ENFORCED_IMPORT_RENAMES),
-        LintId::of(missing_inline::MISSING_INLINE_IN_PUBLIC_ITEMS),
-        LintId::of(module_style::MOD_MODULE_FILES),
-        LintId::of(module_style::SELF_NAMED_MODULE_FILES),
-        LintId::of(modulo_arithmetic::MODULO_ARITHMETIC),
-        LintId::of(panic_in_result_fn::PANIC_IN_RESULT_FN),
-        LintId::of(panic_unimplemented::PANIC),
-        LintId::of(panic_unimplemented::TODO),
-        LintId::of(panic_unimplemented::UNIMPLEMENTED),
-        LintId::of(panic_unimplemented::UNREACHABLE),
-        LintId::of(pattern_type_mismatch::PATTERN_TYPE_MISMATCH),
-        LintId::of(same_name_method::SAME_NAME_METHOD),
-        LintId::of(shadow::SHADOW_REUSE),
-        LintId::of(shadow::SHADOW_SAME),
-        LintId::of(strings::STRING_ADD),
-        LintId::of(strings::STRING_TO_STRING),
-        LintId::of(strings::STR_TO_STRING),
-        LintId::of(types::RC_BUFFER),
-        LintId::of(types::RC_MUTEX),
-        LintId::of(unnecessary_self_imports::UNNECESSARY_SELF_IMPORTS),
-        LintId::of(unwrap_in_result::UNWRAP_IN_RESULT),
-        LintId::of(verbose_file_reads::VERBOSE_FILE_READS),
-        LintId::of(write::PRINT_STDERR),
-        LintId::of(write::PRINT_STDOUT),
-        LintId::of(write::USE_DEBUG),
-    ]);
-
-    store.register_group(true, "clippy::pedantic", Some("clippy_pedantic"), vec![
-        LintId::of(attrs::INLINE_ALWAYS),
-        LintId::of(await_holding_invalid::AWAIT_HOLDING_LOCK),
-        LintId::of(await_holding_invalid::AWAIT_HOLDING_REFCELL_REF),
-        LintId::of(bit_mask::VERBOSE_BIT_MASK),
-        LintId::of(bytecount::NAIVE_BYTECOUNT),
-        LintId::of(case_sensitive_file_extension_comparisons::CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS),
-        LintId::of(casts::CAST_LOSSLESS),
-        LintId::of(casts::CAST_POSSIBLE_TRUNCATION),
-        LintId::of(casts::CAST_POSSIBLE_WRAP),
-        LintId::of(casts::CAST_PRECISION_LOSS),
-        LintId::of(casts::CAST_PTR_ALIGNMENT),
-        LintId::of(casts::CAST_SIGN_LOSS),
-        LintId::of(casts::PTR_AS_PTR),
-        LintId::of(checked_conversions::CHECKED_CONVERSIONS),
-        LintId::of(copies::SAME_FUNCTIONS_IN_IF_CONDITION),
-        LintId::of(copy_iterator::COPY_ITERATOR),
-        LintId::of(default::DEFAULT_TRAIT_ACCESS),
-        LintId::of(dereference::EXPLICIT_DEREF_METHODS),
-        LintId::of(derive::EXPL_IMPL_CLONE_ON_COPY),
-        LintId::of(derive::UNSAFE_DERIVE_DESERIALIZE),
-        LintId::of(doc::DOC_MARKDOWN),
-        LintId::of(doc::MISSING_ERRORS_DOC),
-        LintId::of(doc::MISSING_PANICS_DOC),
-        LintId::of(empty_enum::EMPTY_ENUM),
-        LintId::of(enum_variants::MODULE_NAME_REPETITIONS),
-        LintId::of(eta_reduction::REDUNDANT_CLOSURE_FOR_METHOD_CALLS),
-        LintId::of(excessive_bools::FN_PARAMS_EXCESSIVE_BOOLS),
-        LintId::of(excessive_bools::STRUCT_EXCESSIVE_BOOLS),
-        LintId::of(functions::MUST_USE_CANDIDATE),
-        LintId::of(functions::TOO_MANY_LINES),
-        LintId::of(if_not_else::IF_NOT_ELSE),
-        LintId::of(implicit_hasher::IMPLICIT_HASHER),
-        LintId::of(implicit_saturating_sub::IMPLICIT_SATURATING_SUB),
-        LintId::of(inconsistent_struct_constructor::INCONSISTENT_STRUCT_CONSTRUCTOR),
-        LintId::of(infinite_iter::MAYBE_INFINITE_ITER),
-        LintId::of(invalid_upcast_comparisons::INVALID_UPCAST_COMPARISONS),
-        LintId::of(items_after_statements::ITEMS_AFTER_STATEMENTS),
-        LintId::of(iter_not_returning_iterator::ITER_NOT_RETURNING_ITERATOR),
-        LintId::of(large_stack_arrays::LARGE_STACK_ARRAYS),
-        LintId::of(let_underscore::LET_UNDERSCORE_DROP),
-        LintId::of(literal_representation::LARGE_DIGIT_GROUPS),
-        LintId::of(literal_representation::UNREADABLE_LITERAL),
-        LintId::of(loops::EXPLICIT_INTO_ITER_LOOP),
-        LintId::of(loops::EXPLICIT_ITER_LOOP),
-        LintId::of(macro_use::MACRO_USE_IMPORTS),
-        LintId::of(manual_ok_or::MANUAL_OK_OR),
-        LintId::of(match_on_vec_items::MATCH_ON_VEC_ITEMS),
-        LintId::of(matches::MATCH_BOOL),
-        LintId::of(matches::MATCH_SAME_ARMS),
-        LintId::of(matches::MATCH_WILDCARD_FOR_SINGLE_VARIANTS),
-        LintId::of(matches::MATCH_WILD_ERR_ARM),
-        LintId::of(matches::SINGLE_MATCH_ELSE),
-        LintId::of(methods::CLONED_INSTEAD_OF_COPIED),
-        LintId::of(methods::FILTER_MAP_NEXT),
-        LintId::of(methods::FLAT_MAP_OPTION),
-        LintId::of(methods::FROM_ITER_INSTEAD_OF_COLLECT),
-        LintId::of(methods::IMPLICIT_CLONE),
-        LintId::of(methods::INEFFICIENT_TO_STRING),
-        LintId::of(methods::MAP_FLATTEN),
-        LintId::of(methods::MAP_UNWRAP_OR),
-        LintId::of(misc::FLOAT_CMP),
-        LintId::of(misc::USED_UNDERSCORE_BINDING),
-        LintId::of(misc_early::UNSEPARATED_LITERAL_SUFFIX),
-        LintId::of(mut_mut::MUT_MUT),
-        LintId::of(needless_bitwise_bool::NEEDLESS_BITWISE_BOOL),
-        LintId::of(needless_borrow::REF_BINDING_TO_REFERENCE),
-        LintId::of(needless_continue::NEEDLESS_CONTINUE),
-        LintId::of(needless_for_each::NEEDLESS_FOR_EACH),
-        LintId::of(needless_pass_by_value::NEEDLESS_PASS_BY_VALUE),
-        LintId::of(non_expressive_names::MANY_SINGLE_CHAR_NAMES),
-        LintId::of(non_expressive_names::SIMILAR_NAMES),
-        LintId::of(pass_by_ref_or_value::LARGE_TYPES_PASSED_BY_VALUE),
-        LintId::of(pass_by_ref_or_value::TRIVIALLY_COPY_PASS_BY_REF),
-        LintId::of(ranges::RANGE_MINUS_ONE),
-        LintId::of(ranges::RANGE_PLUS_ONE),
-        LintId::of(redundant_else::REDUNDANT_ELSE),
-        LintId::of(ref_option_ref::REF_OPTION_REF),
-        LintId::of(semicolon_if_nothing_returned::SEMICOLON_IF_NOTHING_RETURNED),
-        LintId::of(shadow::SHADOW_UNRELATED),
-        LintId::of(strings::STRING_ADD_ASSIGN),
-        LintId::of(trait_bounds::TRAIT_DUPLICATION_IN_BOUNDS),
-        LintId::of(trait_bounds::TYPE_REPETITION_IN_BOUNDS),
-        LintId::of(transmute::TRANSMUTE_PTR_TO_PTR),
-        LintId::of(types::LINKEDLIST),
-        LintId::of(types::OPTION_OPTION),
-        LintId::of(unicode::NON_ASCII_LITERAL),
-        LintId::of(unicode::UNICODE_NOT_NFC),
-        LintId::of(unit_types::LET_UNIT_VALUE),
-        LintId::of(unnecessary_wraps::UNNECESSARY_WRAPS),
-        LintId::of(unnested_or_patterns::UNNESTED_OR_PATTERNS),
-        LintId::of(unused_async::UNUSED_ASYNC),
-        LintId::of(unused_self::UNUSED_SELF),
-        LintId::of(wildcard_imports::ENUM_GLOB_USE),
-        LintId::of(wildcard_imports::WILDCARD_IMPORTS),
-        LintId::of(zero_sized_map_values::ZERO_SIZED_MAP_VALUES),
-    ]);
+    include!("lib.register_lints.rs");
+    include!("lib.register_restriction.rs");
+    include!("lib.register_pedantic.rs");
 
     #[cfg(feature = "internal-lints")]
-    store.register_group(true, "clippy::internal", Some("clippy_internal"), vec![
-        LintId::of(utils::internal_lints::CLIPPY_LINTS_INTERNAL),
-        LintId::of(utils::internal_lints::COLLAPSIBLE_SPAN_LINT_CALLS),
-        LintId::of(utils::internal_lints::COMPILER_LINT_FUNCTIONS),
-        LintId::of(utils::internal_lints::DEFAULT_LINT),
-        LintId::of(utils::internal_lints::IF_CHAIN_STYLE),
-        LintId::of(utils::internal_lints::INTERNING_DEFINED_SYMBOL),
-        LintId::of(utils::internal_lints::INVALID_PATHS),
-        LintId::of(utils::internal_lints::LINT_WITHOUT_LINT_PASS),
-        LintId::of(utils::internal_lints::MATCH_TYPE_ON_DIAGNOSTIC_ITEM),
-        LintId::of(utils::internal_lints::OUTER_EXPN_EXPN_DATA),
-        LintId::of(utils::internal_lints::PRODUCE_ICE),
-        LintId::of(utils::internal_lints::UNNECESSARY_SYMBOL_STR),
-    ]);
-
-    store.register_group(true, "clippy::all", Some("clippy"), vec![
-        LintId::of(absurd_extreme_comparisons::ABSURD_EXTREME_COMPARISONS),
-        LintId::of(approx_const::APPROX_CONSTANT),
-        LintId::of(assertions_on_constants::ASSERTIONS_ON_CONSTANTS),
-        LintId::of(assign_ops::ASSIGN_OP_PATTERN),
-        LintId::of(assign_ops::MISREFACTORED_ASSIGN_OP),
-        LintId::of(async_yields_async::ASYNC_YIELDS_ASYNC),
-        LintId::of(attrs::BLANKET_CLIPPY_RESTRICTION_LINTS),
-        LintId::of(attrs::DEPRECATED_CFG_ATTR),
-        LintId::of(attrs::DEPRECATED_SEMVER),
-        LintId::of(attrs::MISMATCHED_TARGET_OS),
-        LintId::of(attrs::USELESS_ATTRIBUTE),
-        LintId::of(bit_mask::BAD_BIT_MASK),
-        LintId::of(bit_mask::INEFFECTIVE_BIT_MASK),
-        LintId::of(blacklisted_name::BLACKLISTED_NAME),
-        LintId::of(blocks_in_if_conditions::BLOCKS_IN_IF_CONDITIONS),
-        LintId::of(bool_assert_comparison::BOOL_ASSERT_COMPARISON),
-        LintId::of(booleans::LOGIC_BUG),
-        LintId::of(booleans::NONMINIMAL_BOOL),
-        LintId::of(casts::CAST_REF_TO_MUT),
-        LintId::of(casts::CHAR_LIT_AS_U8),
-        LintId::of(casts::FN_TO_NUMERIC_CAST),
-        LintId::of(casts::FN_TO_NUMERIC_CAST_WITH_TRUNCATION),
-        LintId::of(casts::UNNECESSARY_CAST),
-        LintId::of(collapsible_if::COLLAPSIBLE_ELSE_IF),
-        LintId::of(collapsible_if::COLLAPSIBLE_IF),
-        LintId::of(collapsible_match::COLLAPSIBLE_MATCH),
-        LintId::of(comparison_chain::COMPARISON_CHAIN),
-        LintId::of(copies::IFS_SAME_COND),
-        LintId::of(copies::IF_SAME_THEN_ELSE),
-        LintId::of(default::FIELD_REASSIGN_WITH_DEFAULT),
-        LintId::of(derivable_impls::DERIVABLE_IMPLS),
-        LintId::of(derive::DERIVE_HASH_XOR_EQ),
-        LintId::of(derive::DERIVE_ORD_XOR_PARTIAL_ORD),
-        LintId::of(doc::MISSING_SAFETY_DOC),
-        LintId::of(doc::NEEDLESS_DOCTEST_MAIN),
-        LintId::of(double_comparison::DOUBLE_COMPARISONS),
-        LintId::of(double_parens::DOUBLE_PARENS),
-        LintId::of(drop_forget_ref::DROP_COPY),
-        LintId::of(drop_forget_ref::DROP_REF),
-        LintId::of(drop_forget_ref::FORGET_COPY),
-        LintId::of(drop_forget_ref::FORGET_REF),
-        LintId::of(duration_subsec::DURATION_SUBSEC),
-        LintId::of(entry::MAP_ENTRY),
-        LintId::of(enum_clike::ENUM_CLIKE_UNPORTABLE_VARIANT),
-        LintId::of(enum_variants::ENUM_VARIANT_NAMES),
-        LintId::of(enum_variants::MODULE_INCEPTION),
-        LintId::of(eq_op::EQ_OP),
-        LintId::of(eq_op::OP_REF),
-        LintId::of(erasing_op::ERASING_OP),
-        LintId::of(escape::BOXED_LOCAL),
-        LintId::of(eta_reduction::REDUNDANT_CLOSURE),
-        LintId::of(eval_order_dependence::DIVERGING_SUB_EXPRESSION),
-        LintId::of(eval_order_dependence::EVAL_ORDER_DEPENDENCE),
-        LintId::of(explicit_write::EXPLICIT_WRITE),
-        LintId::of(float_equality_without_abs::FLOAT_EQUALITY_WITHOUT_ABS),
-        LintId::of(float_literal::EXCESSIVE_PRECISION),
-        LintId::of(format::USELESS_FORMAT),
-        LintId::of(formatting::POSSIBLE_MISSING_COMMA),
-        LintId::of(formatting::SUSPICIOUS_ASSIGNMENT_FORMATTING),
-        LintId::of(formatting::SUSPICIOUS_ELSE_FORMATTING),
-        LintId::of(formatting::SUSPICIOUS_UNARY_OP_FORMATTING),
-        LintId::of(from_over_into::FROM_OVER_INTO),
-        LintId::of(from_str_radix_10::FROM_STR_RADIX_10),
-        LintId::of(functions::DOUBLE_MUST_USE),
-        LintId::of(functions::MUST_USE_UNIT),
-        LintId::of(functions::NOT_UNSAFE_PTR_ARG_DEREF),
-        LintId::of(functions::RESULT_UNIT_ERR),
-        LintId::of(functions::TOO_MANY_ARGUMENTS),
-        LintId::of(get_last_with_len::GET_LAST_WITH_LEN),
-        LintId::of(identity_op::IDENTITY_OP),
-        LintId::of(if_let_mutex::IF_LET_MUTEX),
-        LintId::of(if_then_panic::IF_THEN_PANIC),
-        LintId::of(indexing_slicing::OUT_OF_BOUNDS_INDEXING),
-        LintId::of(infinite_iter::INFINITE_ITER),
-        LintId::of(inherent_to_string::INHERENT_TO_STRING),
-        LintId::of(inherent_to_string::INHERENT_TO_STRING_SHADOW_DISPLAY),
-        LintId::of(inline_fn_without_body::INLINE_FN_WITHOUT_BODY),
-        LintId::of(int_plus_one::INT_PLUS_ONE),
-        LintId::of(large_const_arrays::LARGE_CONST_ARRAYS),
-        LintId::of(large_enum_variant::LARGE_ENUM_VARIANT),
-        LintId::of(len_zero::COMPARISON_TO_EMPTY),
-        LintId::of(len_zero::LEN_WITHOUT_IS_EMPTY),
-        LintId::of(len_zero::LEN_ZERO),
-        LintId::of(let_underscore::LET_UNDERSCORE_LOCK),
-        LintId::of(lifetimes::EXTRA_UNUSED_LIFETIMES),
-        LintId::of(lifetimes::NEEDLESS_LIFETIMES),
-        LintId::of(literal_representation::INCONSISTENT_DIGIT_GROUPING),
-        LintId::of(literal_representation::MISTYPED_LITERAL_SUFFIXES),
-        LintId::of(literal_representation::UNUSUAL_BYTE_GROUPINGS),
-        LintId::of(loops::EMPTY_LOOP),
-        LintId::of(loops::EXPLICIT_COUNTER_LOOP),
-        LintId::of(loops::FOR_KV_MAP),
-        LintId::of(loops::FOR_LOOPS_OVER_FALLIBLES),
-        LintId::of(loops::ITER_NEXT_LOOP),
-        LintId::of(loops::MANUAL_FLATTEN),
-        LintId::of(loops::MANUAL_MEMCPY),
-        LintId::of(loops::MUT_RANGE_BOUND),
-        LintId::of(loops::NEEDLESS_COLLECT),
-        LintId::of(loops::NEEDLESS_RANGE_LOOP),
-        LintId::of(loops::NEVER_LOOP),
-        LintId::of(loops::SAME_ITEM_PUSH),
-        LintId::of(loops::SINGLE_ELEMENT_LOOP),
-        LintId::of(loops::WHILE_IMMUTABLE_CONDITION),
-        LintId::of(loops::WHILE_LET_LOOP),
-        LintId::of(loops::WHILE_LET_ON_ITERATOR),
-        LintId::of(main_recursion::MAIN_RECURSION),
-        LintId::of(manual_async_fn::MANUAL_ASYNC_FN),
-        LintId::of(manual_map::MANUAL_MAP),
-        LintId::of(manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE),
-        LintId::of(manual_strip::MANUAL_STRIP),
-        LintId::of(manual_unwrap_or::MANUAL_UNWRAP_OR),
-        LintId::of(map_clone::MAP_CLONE),
-        LintId::of(map_unit_fn::OPTION_MAP_UNIT_FN),
-        LintId::of(map_unit_fn::RESULT_MAP_UNIT_FN),
-        LintId::of(match_result_ok::MATCH_RESULT_OK),
-        LintId::of(matches::INFALLIBLE_DESTRUCTURING_MATCH),
-        LintId::of(matches::MATCH_AS_REF),
-        LintId::of(matches::MATCH_LIKE_MATCHES_MACRO),
-        LintId::of(matches::MATCH_OVERLAPPING_ARM),
-        LintId::of(matches::MATCH_REF_PATS),
-        LintId::of(matches::MATCH_SINGLE_BINDING),
-        LintId::of(matches::REDUNDANT_PATTERN_MATCHING),
-        LintId::of(matches::SINGLE_MATCH),
-        LintId::of(matches::WILDCARD_IN_OR_PATTERNS),
-        LintId::of(mem_discriminant::MEM_DISCRIMINANT_NON_ENUM),
-        LintId::of(mem_replace::MEM_REPLACE_OPTION_WITH_NONE),
-        LintId::of(mem_replace::MEM_REPLACE_WITH_DEFAULT),
-        LintId::of(mem_replace::MEM_REPLACE_WITH_UNINIT),
-        LintId::of(methods::BIND_INSTEAD_OF_MAP),
-        LintId::of(methods::BYTES_NTH),
-        LintId::of(methods::CHARS_LAST_CMP),
-        LintId::of(methods::CHARS_NEXT_CMP),
-        LintId::of(methods::CLONE_DOUBLE_REF),
-        LintId::of(methods::CLONE_ON_COPY),
-        LintId::of(methods::EXPECT_FUN_CALL),
-        LintId::of(methods::EXTEND_WITH_DRAIN),
-        LintId::of(methods::FILTER_MAP_IDENTITY),
-        LintId::of(methods::FILTER_NEXT),
-        LintId::of(methods::FLAT_MAP_IDENTITY),
-        LintId::of(methods::INSPECT_FOR_EACH),
-        LintId::of(methods::INTO_ITER_ON_REF),
-        LintId::of(methods::ITERATOR_STEP_BY_ZERO),
-        LintId::of(methods::ITER_CLONED_COLLECT),
-        LintId::of(methods::ITER_COUNT),
-        LintId::of(methods::ITER_NEXT_SLICE),
-        LintId::of(methods::ITER_NTH),
-        LintId::of(methods::ITER_NTH_ZERO),
-        LintId::of(methods::ITER_SKIP_NEXT),
-        LintId::of(methods::MANUAL_FILTER_MAP),
-        LintId::of(methods::MANUAL_FIND_MAP),
-        LintId::of(methods::MANUAL_SATURATING_ARITHMETIC),
-        LintId::of(methods::MANUAL_SPLIT_ONCE),
-        LintId::of(methods::MANUAL_STR_REPEAT),
-        LintId::of(methods::MAP_COLLECT_RESULT_UNIT),
-        LintId::of(methods::MAP_IDENTITY),
-        LintId::of(methods::NEW_RET_NO_SELF),
-        LintId::of(methods::OK_EXPECT),
-        LintId::of(methods::OPTION_AS_REF_DEREF),
-        LintId::of(methods::OPTION_FILTER_MAP),
-        LintId::of(methods::OPTION_MAP_OR_NONE),
-        LintId::of(methods::OR_FUN_CALL),
-        LintId::of(methods::RESULT_MAP_OR_INTO_OPTION),
-        LintId::of(methods::SEARCH_IS_SOME),
-        LintId::of(methods::SHOULD_IMPLEMENT_TRAIT),
-        LintId::of(methods::SINGLE_CHAR_ADD_STR),
-        LintId::of(methods::SINGLE_CHAR_PATTERN),
-        LintId::of(methods::SKIP_WHILE_NEXT),
-        LintId::of(methods::STRING_EXTEND_CHARS),
-        LintId::of(methods::SUSPICIOUS_MAP),
-        LintId::of(methods::SUSPICIOUS_SPLITN),
-        LintId::of(methods::UNINIT_ASSUMED_INIT),
-        LintId::of(methods::UNNECESSARY_FILTER_MAP),
-        LintId::of(methods::UNNECESSARY_FOLD),
-        LintId::of(methods::UNNECESSARY_LAZY_EVALUATIONS),
-        LintId::of(methods::UNWRAP_OR_ELSE_DEFAULT),
-        LintId::of(methods::USELESS_ASREF),
-        LintId::of(methods::WRONG_SELF_CONVENTION),
-        LintId::of(methods::ZST_OFFSET),
-        LintId::of(minmax::MIN_MAX),
-        LintId::of(misc::CMP_NAN),
-        LintId::of(misc::CMP_OWNED),
-        LintId::of(misc::MODULO_ONE),
-        LintId::of(misc::SHORT_CIRCUIT_STATEMENT),
-        LintId::of(misc::TOPLEVEL_REF_ARG),
-        LintId::of(misc::ZERO_PTR),
-        LintId::of(misc_early::BUILTIN_TYPE_SHADOW),
-        LintId::of(misc_early::DOUBLE_NEG),
-        LintId::of(misc_early::DUPLICATE_UNDERSCORE_ARGUMENT),
-        LintId::of(misc_early::MIXED_CASE_HEX_LITERALS),
-        LintId::of(misc_early::REDUNDANT_PATTERN),
-        LintId::of(misc_early::UNNEEDED_WILDCARD_PATTERN),
-        LintId::of(misc_early::ZERO_PREFIXED_LITERAL),
-        LintId::of(mut_key::MUTABLE_KEY_TYPE),
-        LintId::of(mut_mutex_lock::MUT_MUTEX_LOCK),
-        LintId::of(mut_reference::UNNECESSARY_MUT_PASSED),
-        LintId::of(mutex_atomic::MUTEX_ATOMIC),
-        LintId::of(needless_arbitrary_self_type::NEEDLESS_ARBITRARY_SELF_TYPE),
-        LintId::of(needless_bool::BOOL_COMPARISON),
-        LintId::of(needless_bool::NEEDLESS_BOOL),
-        LintId::of(needless_borrow::NEEDLESS_BORROW),
-        LintId::of(needless_borrowed_ref::NEEDLESS_BORROWED_REFERENCE),
-        LintId::of(needless_option_as_deref::NEEDLESS_OPTION_AS_DEREF),
-        LintId::of(needless_question_mark::NEEDLESS_QUESTION_MARK),
-        LintId::of(needless_update::NEEDLESS_UPDATE),
-        LintId::of(neg_cmp_op_on_partial_ord::NEG_CMP_OP_ON_PARTIAL_ORD),
-        LintId::of(neg_multiply::NEG_MULTIPLY),
-        LintId::of(new_without_default::NEW_WITHOUT_DEFAULT),
-        LintId::of(no_effect::NO_EFFECT),
-        LintId::of(no_effect::UNNECESSARY_OPERATION),
-        LintId::of(non_copy_const::BORROW_INTERIOR_MUTABLE_CONST),
-        LintId::of(non_copy_const::DECLARE_INTERIOR_MUTABLE_CONST),
-        LintId::of(non_expressive_names::JUST_UNDERSCORES_AND_DIGITS),
-        LintId::of(non_octal_unix_permissions::NON_OCTAL_UNIX_PERMISSIONS),
-        LintId::of(open_options::NONSENSICAL_OPEN_OPTIONS),
-        LintId::of(option_env_unwrap::OPTION_ENV_UNWRAP),
-        LintId::of(overflow_check_conditional::OVERFLOW_CHECK_CONDITIONAL),
-        LintId::of(partialeq_ne_impl::PARTIALEQ_NE_IMPL),
-        LintId::of(precedence::PRECEDENCE),
-        LintId::of(ptr::CMP_NULL),
-        LintId::of(ptr::INVALID_NULL_PTR_USAGE),
-        LintId::of(ptr::MUT_FROM_REF),
-        LintId::of(ptr::PTR_ARG),
-        LintId::of(ptr_eq::PTR_EQ),
-        LintId::of(ptr_offset_with_cast::PTR_OFFSET_WITH_CAST),
-        LintId::of(question_mark::QUESTION_MARK),
-        LintId::of(ranges::MANUAL_RANGE_CONTAINS),
-        LintId::of(ranges::RANGE_ZIP_WITH_LEN),
-        LintId::of(ranges::REVERSED_EMPTY_RANGES),
-        LintId::of(redundant_clone::REDUNDANT_CLONE),
-        LintId::of(redundant_closure_call::REDUNDANT_CLOSURE_CALL),
-        LintId::of(redundant_field_names::REDUNDANT_FIELD_NAMES),
-        LintId::of(redundant_slicing::REDUNDANT_SLICING),
-        LintId::of(redundant_static_lifetimes::REDUNDANT_STATIC_LIFETIMES),
-        LintId::of(reference::DEREF_ADDROF),
-        LintId::of(reference::REF_IN_DEREF),
-        LintId::of(regex::INVALID_REGEX),
-        LintId::of(repeat_once::REPEAT_ONCE),
-        LintId::of(returns::LET_AND_RETURN),
-        LintId::of(returns::NEEDLESS_RETURN),
-        LintId::of(self_assignment::SELF_ASSIGNMENT),
-        LintId::of(self_named_constructors::SELF_NAMED_CONSTRUCTORS),
-        LintId::of(serde_api::SERDE_API_MISUSE),
-        LintId::of(single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS),
-        LintId::of(size_of_in_element_count::SIZE_OF_IN_ELEMENT_COUNT),
-        LintId::of(slow_vector_initialization::SLOW_VECTOR_INITIALIZATION),
-        LintId::of(stable_sort_primitive::STABLE_SORT_PRIMITIVE),
-        LintId::of(strings::STRING_FROM_UTF8_AS_BYTES),
-        LintId::of(strlen_on_c_strings::STRLEN_ON_C_STRINGS),
-        LintId::of(suspicious_trait_impl::SUSPICIOUS_ARITHMETIC_IMPL),
-        LintId::of(suspicious_trait_impl::SUSPICIOUS_OP_ASSIGN_IMPL),
-        LintId::of(swap::ALMOST_SWAPPED),
-        LintId::of(swap::MANUAL_SWAP),
-        LintId::of(tabs_in_doc_comments::TABS_IN_DOC_COMMENTS),
-        LintId::of(temporary_assignment::TEMPORARY_ASSIGNMENT),
-        LintId::of(to_digit_is_some::TO_DIGIT_IS_SOME),
-        LintId::of(to_string_in_display::TO_STRING_IN_DISPLAY),
-        LintId::of(transmute::CROSSPOINTER_TRANSMUTE),
-        LintId::of(transmute::TRANSMUTES_EXPRESSIBLE_AS_PTR_CASTS),
-        LintId::of(transmute::TRANSMUTE_BYTES_TO_STR),
-        LintId::of(transmute::TRANSMUTE_FLOAT_TO_INT),
-        LintId::of(transmute::TRANSMUTE_INT_TO_BOOL),
-        LintId::of(transmute::TRANSMUTE_INT_TO_CHAR),
-        LintId::of(transmute::TRANSMUTE_INT_TO_FLOAT),
-        LintId::of(transmute::TRANSMUTE_PTR_TO_REF),
-        LintId::of(transmute::UNSOUND_COLLECTION_TRANSMUTE),
-        LintId::of(transmute::WRONG_TRANSMUTE),
-        LintId::of(transmuting_null::TRANSMUTING_NULL),
-        LintId::of(try_err::TRY_ERR),
-        LintId::of(types::BORROWED_BOX),
-        LintId::of(types::BOX_COLLECTION),
-        LintId::of(types::REDUNDANT_ALLOCATION),
-        LintId::of(types::TYPE_COMPLEXITY),
-        LintId::of(types::VEC_BOX),
-        LintId::of(undropped_manually_drops::UNDROPPED_MANUALLY_DROPS),
-        LintId::of(unicode::INVISIBLE_CHARACTERS),
-        LintId::of(unit_return_expecting_ord::UNIT_RETURN_EXPECTING_ORD),
-        LintId::of(unit_types::UNIT_ARG),
-        LintId::of(unit_types::UNIT_CMP),
-        LintId::of(unnamed_address::FN_ADDRESS_COMPARISONS),
-        LintId::of(unnamed_address::VTABLE_ADDRESS_COMPARISONS),
-        LintId::of(unnecessary_sort_by::UNNECESSARY_SORT_BY),
-        LintId::of(unsafe_removed_from_name::UNSAFE_REMOVED_FROM_NAME),
-        LintId::of(unused_io_amount::UNUSED_IO_AMOUNT),
-        LintId::of(unused_unit::UNUSED_UNIT),
-        LintId::of(unwrap::PANICKING_UNWRAP),
-        LintId::of(unwrap::UNNECESSARY_UNWRAP),
-        LintId::of(upper_case_acronyms::UPPER_CASE_ACRONYMS),
-        LintId::of(useless_conversion::USELESS_CONVERSION),
-        LintId::of(vec::USELESS_VEC),
-        LintId::of(vec_init_then_push::VEC_INIT_THEN_PUSH),
-        LintId::of(vec_resize_to_zero::VEC_RESIZE_TO_ZERO),
-        LintId::of(write::PRINTLN_EMPTY_STRING),
-        LintId::of(write::PRINT_LITERAL),
-        LintId::of(write::PRINT_WITH_NEWLINE),
-        LintId::of(write::WRITELN_EMPTY_STRING),
-        LintId::of(write::WRITE_LITERAL),
-        LintId::of(write::WRITE_WITH_NEWLINE),
-        LintId::of(zero_div_zero::ZERO_DIVIDED_BY_ZERO),
-    ]);
-
-    store.register_group(true, "clippy::style", Some("clippy_style"), vec![
-        LintId::of(assertions_on_constants::ASSERTIONS_ON_CONSTANTS),
-        LintId::of(assign_ops::ASSIGN_OP_PATTERN),
-        LintId::of(blacklisted_name::BLACKLISTED_NAME),
-        LintId::of(blocks_in_if_conditions::BLOCKS_IN_IF_CONDITIONS),
-        LintId::of(bool_assert_comparison::BOOL_ASSERT_COMPARISON),
-        LintId::of(casts::FN_TO_NUMERIC_CAST),
-        LintId::of(casts::FN_TO_NUMERIC_CAST_WITH_TRUNCATION),
-        LintId::of(collapsible_if::COLLAPSIBLE_ELSE_IF),
-        LintId::of(collapsible_if::COLLAPSIBLE_IF),
-        LintId::of(collapsible_match::COLLAPSIBLE_MATCH),
-        LintId::of(comparison_chain::COMPARISON_CHAIN),
-        LintId::of(default::FIELD_REASSIGN_WITH_DEFAULT),
-        LintId::of(doc::MISSING_SAFETY_DOC),
-        LintId::of(doc::NEEDLESS_DOCTEST_MAIN),
-        LintId::of(enum_variants::ENUM_VARIANT_NAMES),
-        LintId::of(enum_variants::MODULE_INCEPTION),
-        LintId::of(eq_op::OP_REF),
-        LintId::of(eta_reduction::REDUNDANT_CLOSURE),
-        LintId::of(float_literal::EXCESSIVE_PRECISION),
-        LintId::of(from_over_into::FROM_OVER_INTO),
-        LintId::of(from_str_radix_10::FROM_STR_RADIX_10),
-        LintId::of(functions::DOUBLE_MUST_USE),
-        LintId::of(functions::MUST_USE_UNIT),
-        LintId::of(functions::RESULT_UNIT_ERR),
-        LintId::of(if_then_panic::IF_THEN_PANIC),
-        LintId::of(inherent_to_string::INHERENT_TO_STRING),
-        LintId::of(len_zero::COMPARISON_TO_EMPTY),
-        LintId::of(len_zero::LEN_WITHOUT_IS_EMPTY),
-        LintId::of(len_zero::LEN_ZERO),
-        LintId::of(literal_representation::INCONSISTENT_DIGIT_GROUPING),
-        LintId::of(literal_representation::UNUSUAL_BYTE_GROUPINGS),
-        LintId::of(loops::FOR_KV_MAP),
-        LintId::of(loops::NEEDLESS_RANGE_LOOP),
-        LintId::of(loops::SAME_ITEM_PUSH),
-        LintId::of(loops::WHILE_LET_ON_ITERATOR),
-        LintId::of(main_recursion::MAIN_RECURSION),
-        LintId::of(manual_async_fn::MANUAL_ASYNC_FN),
-        LintId::of(manual_map::MANUAL_MAP),
-        LintId::of(manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE),
-        LintId::of(map_clone::MAP_CLONE),
-        LintId::of(match_result_ok::MATCH_RESULT_OK),
-        LintId::of(matches::INFALLIBLE_DESTRUCTURING_MATCH),
-        LintId::of(matches::MATCH_LIKE_MATCHES_MACRO),
-        LintId::of(matches::MATCH_OVERLAPPING_ARM),
-        LintId::of(matches::MATCH_REF_PATS),
-        LintId::of(matches::REDUNDANT_PATTERN_MATCHING),
-        LintId::of(matches::SINGLE_MATCH),
-        LintId::of(mem_replace::MEM_REPLACE_OPTION_WITH_NONE),
-        LintId::of(mem_replace::MEM_REPLACE_WITH_DEFAULT),
-        LintId::of(methods::BYTES_NTH),
-        LintId::of(methods::CHARS_LAST_CMP),
-        LintId::of(methods::CHARS_NEXT_CMP),
-        LintId::of(methods::INTO_ITER_ON_REF),
-        LintId::of(methods::ITER_CLONED_COLLECT),
-        LintId::of(methods::ITER_NEXT_SLICE),
-        LintId::of(methods::ITER_NTH_ZERO),
-        LintId::of(methods::ITER_SKIP_NEXT),
-        LintId::of(methods::MANUAL_SATURATING_ARITHMETIC),
-        LintId::of(methods::MAP_COLLECT_RESULT_UNIT),
-        LintId::of(methods::NEW_RET_NO_SELF),
-        LintId::of(methods::OK_EXPECT),
-        LintId::of(methods::OPTION_MAP_OR_NONE),
-        LintId::of(methods::RESULT_MAP_OR_INTO_OPTION),
-        LintId::of(methods::SHOULD_IMPLEMENT_TRAIT),
-        LintId::of(methods::SINGLE_CHAR_ADD_STR),
-        LintId::of(methods::STRING_EXTEND_CHARS),
-        LintId::of(methods::UNNECESSARY_FOLD),
-        LintId::of(methods::UNNECESSARY_LAZY_EVALUATIONS),
-        LintId::of(methods::UNWRAP_OR_ELSE_DEFAULT),
-        LintId::of(methods::WRONG_SELF_CONVENTION),
-        LintId::of(misc::TOPLEVEL_REF_ARG),
-        LintId::of(misc::ZERO_PTR),
-        LintId::of(misc_early::BUILTIN_TYPE_SHADOW),
-        LintId::of(misc_early::DOUBLE_NEG),
-        LintId::of(misc_early::DUPLICATE_UNDERSCORE_ARGUMENT),
-        LintId::of(misc_early::MIXED_CASE_HEX_LITERALS),
-        LintId::of(misc_early::REDUNDANT_PATTERN),
-        LintId::of(mut_mutex_lock::MUT_MUTEX_LOCK),
-        LintId::of(mut_reference::UNNECESSARY_MUT_PASSED),
-        LintId::of(needless_borrow::NEEDLESS_BORROW),
-        LintId::of(neg_multiply::NEG_MULTIPLY),
-        LintId::of(new_without_default::NEW_WITHOUT_DEFAULT),
-        LintId::of(non_copy_const::BORROW_INTERIOR_MUTABLE_CONST),
-        LintId::of(non_copy_const::DECLARE_INTERIOR_MUTABLE_CONST),
-        LintId::of(non_expressive_names::JUST_UNDERSCORES_AND_DIGITS),
-        LintId::of(ptr::CMP_NULL),
-        LintId::of(ptr::PTR_ARG),
-        LintId::of(ptr_eq::PTR_EQ),
-        LintId::of(question_mark::QUESTION_MARK),
-        LintId::of(ranges::MANUAL_RANGE_CONTAINS),
-        LintId::of(redundant_field_names::REDUNDANT_FIELD_NAMES),
-        LintId::of(redundant_static_lifetimes::REDUNDANT_STATIC_LIFETIMES),
-        LintId::of(returns::LET_AND_RETURN),
-        LintId::of(returns::NEEDLESS_RETURN),
-        LintId::of(self_named_constructors::SELF_NAMED_CONSTRUCTORS),
-        LintId::of(single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS),
-        LintId::of(tabs_in_doc_comments::TABS_IN_DOC_COMMENTS),
-        LintId::of(to_digit_is_some::TO_DIGIT_IS_SOME),
-        LintId::of(try_err::TRY_ERR),
-        LintId::of(unsafe_removed_from_name::UNSAFE_REMOVED_FROM_NAME),
-        LintId::of(unused_unit::UNUSED_UNIT),
-        LintId::of(upper_case_acronyms::UPPER_CASE_ACRONYMS),
-        LintId::of(write::PRINTLN_EMPTY_STRING),
-        LintId::of(write::PRINT_LITERAL),
-        LintId::of(write::PRINT_WITH_NEWLINE),
-        LintId::of(write::WRITELN_EMPTY_STRING),
-        LintId::of(write::WRITE_LITERAL),
-        LintId::of(write::WRITE_WITH_NEWLINE),
-    ]);
-
-    store.register_group(true, "clippy::complexity", Some("clippy_complexity"), vec![
-        LintId::of(attrs::DEPRECATED_CFG_ATTR),
-        LintId::of(booleans::NONMINIMAL_BOOL),
-        LintId::of(casts::CHAR_LIT_AS_U8),
-        LintId::of(casts::UNNECESSARY_CAST),
-        LintId::of(derivable_impls::DERIVABLE_IMPLS),
-        LintId::of(double_comparison::DOUBLE_COMPARISONS),
-        LintId::of(double_parens::DOUBLE_PARENS),
-        LintId::of(duration_subsec::DURATION_SUBSEC),
-        LintId::of(eval_order_dependence::DIVERGING_SUB_EXPRESSION),
-        LintId::of(explicit_write::EXPLICIT_WRITE),
-        LintId::of(format::USELESS_FORMAT),
-        LintId::of(functions::TOO_MANY_ARGUMENTS),
-        LintId::of(get_last_with_len::GET_LAST_WITH_LEN),
-        LintId::of(identity_op::IDENTITY_OP),
-        LintId::of(int_plus_one::INT_PLUS_ONE),
-        LintId::of(lifetimes::EXTRA_UNUSED_LIFETIMES),
-        LintId::of(lifetimes::NEEDLESS_LIFETIMES),
-        LintId::of(loops::EXPLICIT_COUNTER_LOOP),
-        LintId::of(loops::MANUAL_FLATTEN),
-        LintId::of(loops::SINGLE_ELEMENT_LOOP),
-        LintId::of(loops::WHILE_LET_LOOP),
-        LintId::of(manual_strip::MANUAL_STRIP),
-        LintId::of(manual_unwrap_or::MANUAL_UNWRAP_OR),
-        LintId::of(map_unit_fn::OPTION_MAP_UNIT_FN),
-        LintId::of(map_unit_fn::RESULT_MAP_UNIT_FN),
-        LintId::of(matches::MATCH_AS_REF),
-        LintId::of(matches::MATCH_SINGLE_BINDING),
-        LintId::of(matches::WILDCARD_IN_OR_PATTERNS),
-        LintId::of(methods::BIND_INSTEAD_OF_MAP),
-        LintId::of(methods::CLONE_ON_COPY),
-        LintId::of(methods::FILTER_MAP_IDENTITY),
-        LintId::of(methods::FILTER_NEXT),
-        LintId::of(methods::FLAT_MAP_IDENTITY),
-        LintId::of(methods::INSPECT_FOR_EACH),
-        LintId::of(methods::ITER_COUNT),
-        LintId::of(methods::MANUAL_FILTER_MAP),
-        LintId::of(methods::MANUAL_FIND_MAP),
-        LintId::of(methods::MANUAL_SPLIT_ONCE),
-        LintId::of(methods::MAP_IDENTITY),
-        LintId::of(methods::OPTION_AS_REF_DEREF),
-        LintId::of(methods::OPTION_FILTER_MAP),
-        LintId::of(methods::SEARCH_IS_SOME),
-        LintId::of(methods::SKIP_WHILE_NEXT),
-        LintId::of(methods::UNNECESSARY_FILTER_MAP),
-        LintId::of(methods::USELESS_ASREF),
-        LintId::of(misc::SHORT_CIRCUIT_STATEMENT),
-        LintId::of(misc_early::UNNEEDED_WILDCARD_PATTERN),
-        LintId::of(misc_early::ZERO_PREFIXED_LITERAL),
-        LintId::of(needless_arbitrary_self_type::NEEDLESS_ARBITRARY_SELF_TYPE),
-        LintId::of(needless_bool::BOOL_COMPARISON),
-        LintId::of(needless_bool::NEEDLESS_BOOL),
-        LintId::of(needless_borrowed_ref::NEEDLESS_BORROWED_REFERENCE),
-        LintId::of(needless_option_as_deref::NEEDLESS_OPTION_AS_DEREF),
-        LintId::of(needless_question_mark::NEEDLESS_QUESTION_MARK),
-        LintId::of(needless_update::NEEDLESS_UPDATE),
-        LintId::of(neg_cmp_op_on_partial_ord::NEG_CMP_OP_ON_PARTIAL_ORD),
-        LintId::of(no_effect::NO_EFFECT),
-        LintId::of(no_effect::UNNECESSARY_OPERATION),
-        LintId::of(overflow_check_conditional::OVERFLOW_CHECK_CONDITIONAL),
-        LintId::of(partialeq_ne_impl::PARTIALEQ_NE_IMPL),
-        LintId::of(precedence::PRECEDENCE),
-        LintId::of(ptr_offset_with_cast::PTR_OFFSET_WITH_CAST),
-        LintId::of(ranges::RANGE_ZIP_WITH_LEN),
-        LintId::of(redundant_closure_call::REDUNDANT_CLOSURE_CALL),
-        LintId::of(redundant_slicing::REDUNDANT_SLICING),
-        LintId::of(reference::DEREF_ADDROF),
-        LintId::of(reference::REF_IN_DEREF),
-        LintId::of(repeat_once::REPEAT_ONCE),
-        LintId::of(strings::STRING_FROM_UTF8_AS_BYTES),
-        LintId::of(strlen_on_c_strings::STRLEN_ON_C_STRINGS),
-        LintId::of(swap::MANUAL_SWAP),
-        LintId::of(temporary_assignment::TEMPORARY_ASSIGNMENT),
-        LintId::of(transmute::CROSSPOINTER_TRANSMUTE),
-        LintId::of(transmute::TRANSMUTES_EXPRESSIBLE_AS_PTR_CASTS),
-        LintId::of(transmute::TRANSMUTE_BYTES_TO_STR),
-        LintId::of(transmute::TRANSMUTE_FLOAT_TO_INT),
-        LintId::of(transmute::TRANSMUTE_INT_TO_BOOL),
-        LintId::of(transmute::TRANSMUTE_INT_TO_CHAR),
-        LintId::of(transmute::TRANSMUTE_INT_TO_FLOAT),
-        LintId::of(transmute::TRANSMUTE_PTR_TO_REF),
-        LintId::of(types::BORROWED_BOX),
-        LintId::of(types::TYPE_COMPLEXITY),
-        LintId::of(types::VEC_BOX),
-        LintId::of(unit_types::UNIT_ARG),
-        LintId::of(unnecessary_sort_by::UNNECESSARY_SORT_BY),
-        LintId::of(unwrap::UNNECESSARY_UNWRAP),
-        LintId::of(useless_conversion::USELESS_CONVERSION),
-        LintId::of(zero_div_zero::ZERO_DIVIDED_BY_ZERO),
-    ]);
-
-    store.register_group(true, "clippy::correctness", Some("clippy_correctness"), vec![
-        LintId::of(absurd_extreme_comparisons::ABSURD_EXTREME_COMPARISONS),
-        LintId::of(approx_const::APPROX_CONSTANT),
-        LintId::of(async_yields_async::ASYNC_YIELDS_ASYNC),
-        LintId::of(attrs::DEPRECATED_SEMVER),
-        LintId::of(attrs::MISMATCHED_TARGET_OS),
-        LintId::of(attrs::USELESS_ATTRIBUTE),
-        LintId::of(bit_mask::BAD_BIT_MASK),
-        LintId::of(bit_mask::INEFFECTIVE_BIT_MASK),
-        LintId::of(booleans::LOGIC_BUG),
-        LintId::of(casts::CAST_REF_TO_MUT),
-        LintId::of(copies::IFS_SAME_COND),
-        LintId::of(copies::IF_SAME_THEN_ELSE),
-        LintId::of(derive::DERIVE_HASH_XOR_EQ),
-        LintId::of(derive::DERIVE_ORD_XOR_PARTIAL_ORD),
-        LintId::of(drop_forget_ref::DROP_COPY),
-        LintId::of(drop_forget_ref::DROP_REF),
-        LintId::of(drop_forget_ref::FORGET_COPY),
-        LintId::of(drop_forget_ref::FORGET_REF),
-        LintId::of(enum_clike::ENUM_CLIKE_UNPORTABLE_VARIANT),
-        LintId::of(eq_op::EQ_OP),
-        LintId::of(erasing_op::ERASING_OP),
-        LintId::of(formatting::POSSIBLE_MISSING_COMMA),
-        LintId::of(functions::NOT_UNSAFE_PTR_ARG_DEREF),
-        LintId::of(if_let_mutex::IF_LET_MUTEX),
-        LintId::of(indexing_slicing::OUT_OF_BOUNDS_INDEXING),
-        LintId::of(infinite_iter::INFINITE_ITER),
-        LintId::of(inherent_to_string::INHERENT_TO_STRING_SHADOW_DISPLAY),
-        LintId::of(inline_fn_without_body::INLINE_FN_WITHOUT_BODY),
-        LintId::of(let_underscore::LET_UNDERSCORE_LOCK),
-        LintId::of(literal_representation::MISTYPED_LITERAL_SUFFIXES),
-        LintId::of(loops::ITER_NEXT_LOOP),
-        LintId::of(loops::NEVER_LOOP),
-        LintId::of(loops::WHILE_IMMUTABLE_CONDITION),
-        LintId::of(mem_discriminant::MEM_DISCRIMINANT_NON_ENUM),
-        LintId::of(mem_replace::MEM_REPLACE_WITH_UNINIT),
-        LintId::of(methods::CLONE_DOUBLE_REF),
-        LintId::of(methods::ITERATOR_STEP_BY_ZERO),
-        LintId::of(methods::SUSPICIOUS_SPLITN),
-        LintId::of(methods::UNINIT_ASSUMED_INIT),
-        LintId::of(methods::ZST_OFFSET),
-        LintId::of(minmax::MIN_MAX),
-        LintId::of(misc::CMP_NAN),
-        LintId::of(misc::MODULO_ONE),
-        LintId::of(non_octal_unix_permissions::NON_OCTAL_UNIX_PERMISSIONS),
-        LintId::of(open_options::NONSENSICAL_OPEN_OPTIONS),
-        LintId::of(option_env_unwrap::OPTION_ENV_UNWRAP),
-        LintId::of(ptr::INVALID_NULL_PTR_USAGE),
-        LintId::of(ptr::MUT_FROM_REF),
-        LintId::of(ranges::REVERSED_EMPTY_RANGES),
-        LintId::of(regex::INVALID_REGEX),
-        LintId::of(self_assignment::SELF_ASSIGNMENT),
-        LintId::of(serde_api::SERDE_API_MISUSE),
-        LintId::of(size_of_in_element_count::SIZE_OF_IN_ELEMENT_COUNT),
-        LintId::of(swap::ALMOST_SWAPPED),
-        LintId::of(to_string_in_display::TO_STRING_IN_DISPLAY),
-        LintId::of(transmute::UNSOUND_COLLECTION_TRANSMUTE),
-        LintId::of(transmute::WRONG_TRANSMUTE),
-        LintId::of(transmuting_null::TRANSMUTING_NULL),
-        LintId::of(undropped_manually_drops::UNDROPPED_MANUALLY_DROPS),
-        LintId::of(unicode::INVISIBLE_CHARACTERS),
-        LintId::of(unit_return_expecting_ord::UNIT_RETURN_EXPECTING_ORD),
-        LintId::of(unit_types::UNIT_CMP),
-        LintId::of(unnamed_address::FN_ADDRESS_COMPARISONS),
-        LintId::of(unnamed_address::VTABLE_ADDRESS_COMPARISONS),
-        LintId::of(unused_io_amount::UNUSED_IO_AMOUNT),
-        LintId::of(unwrap::PANICKING_UNWRAP),
-        LintId::of(vec_resize_to_zero::VEC_RESIZE_TO_ZERO),
-    ]);
-
-    store.register_group(true, "clippy::suspicious", None, vec![
-        LintId::of(assign_ops::MISREFACTORED_ASSIGN_OP),
-        LintId::of(attrs::BLANKET_CLIPPY_RESTRICTION_LINTS),
-        LintId::of(eval_order_dependence::EVAL_ORDER_DEPENDENCE),
-        LintId::of(float_equality_without_abs::FLOAT_EQUALITY_WITHOUT_ABS),
-        LintId::of(formatting::SUSPICIOUS_ASSIGNMENT_FORMATTING),
-        LintId::of(formatting::SUSPICIOUS_ELSE_FORMATTING),
-        LintId::of(formatting::SUSPICIOUS_UNARY_OP_FORMATTING),
-        LintId::of(loops::EMPTY_LOOP),
-        LintId::of(loops::FOR_LOOPS_OVER_FALLIBLES),
-        LintId::of(loops::MUT_RANGE_BOUND),
-        LintId::of(methods::SUSPICIOUS_MAP),
-        LintId::of(mut_key::MUTABLE_KEY_TYPE),
-        LintId::of(suspicious_trait_impl::SUSPICIOUS_ARITHMETIC_IMPL),
-        LintId::of(suspicious_trait_impl::SUSPICIOUS_OP_ASSIGN_IMPL),
-    ]);
-
-    store.register_group(true, "clippy::perf", Some("clippy_perf"), vec![
-        LintId::of(entry::MAP_ENTRY),
-        LintId::of(escape::BOXED_LOCAL),
-        LintId::of(large_const_arrays::LARGE_CONST_ARRAYS),
-        LintId::of(large_enum_variant::LARGE_ENUM_VARIANT),
-        LintId::of(loops::MANUAL_MEMCPY),
-        LintId::of(loops::NEEDLESS_COLLECT),
-        LintId::of(methods::EXPECT_FUN_CALL),
-        LintId::of(methods::EXTEND_WITH_DRAIN),
-        LintId::of(methods::ITER_NTH),
-        LintId::of(methods::MANUAL_STR_REPEAT),
-        LintId::of(methods::OR_FUN_CALL),
-        LintId::of(methods::SINGLE_CHAR_PATTERN),
-        LintId::of(misc::CMP_OWNED),
-        LintId::of(mutex_atomic::MUTEX_ATOMIC),
-        LintId::of(redundant_clone::REDUNDANT_CLONE),
-        LintId::of(slow_vector_initialization::SLOW_VECTOR_INITIALIZATION),
-        LintId::of(stable_sort_primitive::STABLE_SORT_PRIMITIVE),
-        LintId::of(types::BOX_COLLECTION),
-        LintId::of(types::REDUNDANT_ALLOCATION),
-        LintId::of(vec::USELESS_VEC),
-        LintId::of(vec_init_then_push::VEC_INIT_THEN_PUSH),
-    ]);
-
-    store.register_group(true, "clippy::cargo", Some("clippy_cargo"), vec![
-        LintId::of(cargo_common_metadata::CARGO_COMMON_METADATA),
-        LintId::of(feature_name::NEGATIVE_FEATURE_NAMES),
-        LintId::of(feature_name::REDUNDANT_FEATURE_NAMES),
-        LintId::of(multiple_crate_versions::MULTIPLE_CRATE_VERSIONS),
-        LintId::of(wildcard_dependencies::WILDCARD_DEPENDENCIES),
-    ]);
-
-    store.register_group(true, "clippy::nursery", Some("clippy_nursery"), vec![
-        LintId::of(attrs::EMPTY_LINE_AFTER_OUTER_ATTR),
-        LintId::of(cognitive_complexity::COGNITIVE_COMPLEXITY),
-        LintId::of(copies::BRANCHES_SHARING_CODE),
-        LintId::of(disallowed_method::DISALLOWED_METHOD),
-        LintId::of(disallowed_type::DISALLOWED_TYPE),
-        LintId::of(fallible_impl_from::FALLIBLE_IMPL_FROM),
-        LintId::of(floating_point_arithmetic::IMPRECISE_FLOPS),
-        LintId::of(floating_point_arithmetic::SUBOPTIMAL_FLOPS),
-        LintId::of(future_not_send::FUTURE_NOT_SEND),
-        LintId::of(let_if_seq::USELESS_LET_IF_SEQ),
-        LintId::of(missing_const_for_fn::MISSING_CONST_FOR_FN),
-        LintId::of(mutable_debug_assertion::DEBUG_ASSERT_WITH_MUT_CALL),
-        LintId::of(mutex_atomic::MUTEX_INTEGER),
-        LintId::of(nonstandard_macro_braces::NONSTANDARD_MACRO_BRACES),
-        LintId::of(option_if_let_else::OPTION_IF_LET_ELSE),
-        LintId::of(path_buf_push_overwrite::PATH_BUF_PUSH_OVERWRITE),
-        LintId::of(redundant_pub_crate::REDUNDANT_PUB_CRATE),
-        LintId::of(regex::TRIVIAL_REGEX),
-        LintId::of(strings::STRING_LIT_AS_BYTES),
-        LintId::of(suspicious_operation_groupings::SUSPICIOUS_OPERATION_GROUPINGS),
-        LintId::of(transmute::USELESS_TRANSMUTE),
-        LintId::of(use_self::USE_SELF),
-    ]);
+    include!("lib.register_internal.rs");
+
+    include!("lib.register_all.rs");
+    include!("lib.register_style.rs");
+    include!("lib.register_complexity.rs");
+    include!("lib.register_correctness.rs");
+    include!("lib.register_suspicious.rs");
+    include!("lib.register_perf.rs");
+    include!("lib.register_cargo.rs");
+    include!("lib.register_nursery.rs");
 
     #[cfg(feature = "metadata-collector-lint")]
     {
-- 
cgit 1.4.1-3-g733a5


From e6747df5cd4232d26747a556c263d0a5d9c72414 Mon Sep 17 00:00:00 2001
From: Michael Wright <mikerite@lavabit.com>
Date: Sat, 18 Sep 2021 06:43:39 +0200
Subject: Fix lint register code format

Also change the generation functions to return `String` instead of
`Vec<String>`. This makes sense now as the updates aren't line oriented
anymore.
---
 clippy_dev/src/lib.rs                        |  188 ++---
 clippy_dev/src/update_lints.rs               |   59 +-
 clippy_lints/src/lib.deprecated.rs           |    2 +-
 clippy_lints/src/lib.mods.rs                 |    2 +-
 clippy_lints/src/lib.register_all.rs         |  598 +++++++--------
 clippy_lints/src/lib.register_cargo.rs       |   12 +-
 clippy_lints/src/lib.register_complexity.rs  |  178 ++---
 clippy_lints/src/lib.register_correctness.rs |  136 ++--
 clippy_lints/src/lib.register_internal.rs    |   26 +-
 clippy_lints/src/lib.register_lints.rs       | 1008 +++++++++++++-------------
 clippy_lints/src/lib.register_nursery.rs     |   46 +-
 clippy_lints/src/lib.register_pedantic.rs    |  192 ++---
 clippy_lints/src/lib.register_perf.rs        |   44 +-
 clippy_lints/src/lib.register_restriction.rs |  118 +--
 clippy_lints/src/lib.register_style.rs       |  218 +++---
 clippy_lints/src/lib.register_suspicious.rs  |   30 +-
 16 files changed, 1433 insertions(+), 1424 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_dev/src/lib.rs b/clippy_dev/src/lib.rs
index 8f0356c028b..7dba808b418 100644
--- a/clippy_dev/src/lib.rs
+++ b/clippy_dev/src/lib.rs
@@ -5,7 +5,7 @@
 
 use itertools::Itertools;
 use regex::Regex;
-use std::collections::HashMap;
+use std::collections::{BTreeSet, HashMap};
 use std::ffi::OsStr;
 use std::fs;
 use std::lazy::SyncLazy;
@@ -19,6 +19,10 @@ pub mod serve;
 pub mod setup;
 pub mod update_lints;
 
+const GENERATED_FILE_COMMENT: &str = "// This file was generated by `cargo dev update_lints`.\n\
+     // Use that command to update this file and do not edit by hand.\n\
+     // Manual edits will be overwritten.\n\n";
+
 static DEC_CLIPPY_LINT_RE: SyncLazy<Regex> = SyncLazy::new(|| {
     Regex::new(
         r#"(?x)
@@ -98,37 +102,35 @@ impl Lint {
     }
 }
 
-/// Generates the Vec items for `register_lint_group` calls in `clippy_lints/src/lib.rs`.
-#[must_use]
-pub fn gen_lint_group_list<'a>(group_name: &str, lints: impl Iterator<Item = &'a Lint>) -> Vec<String> {
-    let header = format!(
-        r#"store.register_group(true, "clippy::{0}", Some("clippy_{0}"), vec!["#,
-        group_name
-    );
-    let footer = "])".to_string();
-
-    let mut result = vec![header];
+/// Generates the code for registering a group
+pub fn gen_lint_group_list<'a>(group_name: &str, lints: impl Iterator<Item = &'a Lint>) -> String {
+    let mut details: Vec<_> = lints.map(|l| (&l.module, l.name.to_uppercase())).collect();
+    details.sort_unstable();
 
-    result.extend(
-        lints
-            .map(|l| format!("LintId::of({}::{}),", l.module, l.name.to_uppercase()))
-            .sorted(),
-    );
+    let mut output = GENERATED_FILE_COMMENT.to_string();
 
-    result.push(footer);
+    output.push_str(&format!(
+        "store.register_group(true, \"clippy::{0}\", Some(\"clippy_{0}\"), vec![\n",
+        group_name
+    ));
+    for (module, name) in details {
+        output.push_str(&format!("    LintId::of({}::{}),\n", module, name));
+    }
+    output.push_str("])\n");
 
-    result
+    output
 }
 
-/// Generates the `pub mod module_name` list in `clippy_lints/src/lib.rs`.
+/// Generates the module declarations for `lints`
 #[must_use]
-pub fn gen_modules_list<'a>(lints: impl Iterator<Item = &'a Lint>) -> Vec<String> {
-    lints
-        .map(|l| &l.module)
-        .unique()
-        .map(|module| format!("mod {};", module))
-        .sorted()
-        .collect::<Vec<String>>()
+pub fn gen_modules_list<'a>(lints: impl Iterator<Item = &'a Lint>) -> String {
+    let module_names: BTreeSet<_> = lints.map(|l| &l.module).collect();
+
+    let mut output = GENERATED_FILE_COMMENT.to_string();
+    for name in module_names {
+        output.push_str(&format!("mod {};\n", name));
+    }
+    output
 }
 
 /// Generates the list of lint links at the bottom of the README
@@ -140,52 +142,52 @@ pub fn gen_changelog_lint_list<'a>(lints: impl Iterator<Item = &'a Lint>) -> Vec
         .collect()
 }
 
-/// Generates the `register_removed` code in `./clippy_lints/src/lib.rs`.
+/// Generates the `register_removed` code
 #[must_use]
-pub fn gen_deprecated<'a>(lints: impl Iterator<Item = &'a Lint>) -> Vec<String> {
-    let mut result = vec!["{".to_string()];
-    result.extend(lints.flat_map(|l| {
-        l.deprecation
-            .clone()
-            .map(|depr_text| {
-                vec![
-                    "    store.register_removed(".to_string(),
-                    format!("        \"clippy::{}\",", l.name),
-                    format!("        \"{}\",", depr_text),
-                    "    );".to_string(),
-                ]
-            })
-            .expect("only deprecated lints should be passed")
-    }));
-    result.push("}".to_string());
-    result
+pub fn gen_deprecated<'a>(lints: impl Iterator<Item = &'a Lint>) -> String {
+    let mut output = GENERATED_FILE_COMMENT.to_string();
+    output.push_str("{\n");
+    for Lint { name, deprecation, .. } in lints {
+        output.push_str(&format!(
+            concat!(
+                "    store.register_removed(\n",
+                "        \"clippy::{}\",\n",
+                "        \"{}\",\n",
+                "    );\n"
+            ),
+            name,
+            deprecation.as_ref().expect("`lints` are deprecated")
+        ));
+    }
+    output.push_str("}\n");
+
+    output
 }
 
+/// Generates the code for registering lints
 #[must_use]
 pub fn gen_register_lint_list<'a>(
     internal_lints: impl Iterator<Item = &'a Lint>,
     usable_lints: impl Iterator<Item = &'a Lint>,
-) -> Vec<String> {
-    let header = "    store.register_lints(&[".to_string();
-    let footer = "    ])".to_string();
-    let internal_lints = internal_lints
-        .sorted_by_key(|l| format!("        {}::{},", l.module, l.name.to_uppercase()))
-        .map(|l| {
-            format!(
-                "        #[cfg(feature = \"internal-lints\")]\n        {}::{},",
-                l.module,
-                l.name.to_uppercase()
-            )
-        });
-    let other_lints = usable_lints
-        .sorted_by_key(|l| format!("        {}::{},", l.module, l.name.to_uppercase()))
-        .map(|l| format!("        {}::{},", l.module, l.name.to_uppercase()))
-        .sorted();
-    let mut lint_list = vec![header];
-    lint_list.extend(internal_lints);
-    lint_list.extend(other_lints);
-    lint_list.push(footer);
-    lint_list
+) -> String {
+    let mut details: Vec<_> = internal_lints
+        .map(|l| (false, &l.module, l.name.to_uppercase()))
+        .chain(usable_lints.map(|l| (true, &l.module, l.name.to_uppercase())))
+        .collect();
+    details.sort_unstable();
+
+    let mut output = GENERATED_FILE_COMMENT.to_string();
+    output.push_str("store.register_lints(&[\n");
+
+    for (is_public, module_name, lint_name) in details {
+        if !is_public {
+            output.push_str("    #[cfg(feature = \"internal-lints\")]\n");
+        }
+        output.push_str(&format!("    {}::{},\n", module_name, lint_name));
+    }
+    output.push_str("])\n");
+
+    output
 }
 
 /// Gathers all files in `src/clippy_lints` and gathers all lints inside
@@ -524,21 +526,23 @@ fn test_gen_deprecated() {
             "module_name",
         ),
     ];
-    let expected: Vec<String> = vec![
-        "{",
-        "    store.register_removed(",
-        "        \"clippy::should_assert_eq\",",
-        "        \"has been superseded by should_assert_eq2\",",
-        "    );",
-        "    store.register_removed(",
-        "        \"clippy::another_deprecated\",",
-        "        \"will be removed\",",
-        "    );",
-        "}",
-    ]
-    .into_iter()
-    .map(String::from)
-    .collect();
+
+    let expected = GENERATED_FILE_COMMENT.to_string()
+        + &[
+            "{",
+            "    store.register_removed(",
+            "        \"clippy::should_assert_eq\",",
+            "        \"has been superseded by should_assert_eq2\",",
+            "    );",
+            "    store.register_removed(",
+            "        \"clippy::another_deprecated\",",
+            "        \"will be removed\",",
+            "    );",
+            "}",
+        ]
+        .join("\n")
+        + "\n";
+
     assert_eq!(expected, gen_deprecated(lints.iter()));
 }
 
@@ -555,7 +559,7 @@ fn test_gen_modules_list() {
         Lint::new("should_assert_eq", "group1", "abc", None, "module_name"),
         Lint::new("incorrect_stuff", "group3", "abc", None, "another_module"),
     ];
-    let expected = vec!["mod another_module;".to_string(), "mod module_name;".to_string()];
+    let expected = GENERATED_FILE_COMMENT.to_string() + &["mod another_module;", "mod module_name;"].join("\n") + "\n";
     assert_eq!(expected, gen_modules_list(lints.iter()));
 }
 
@@ -566,12 +570,18 @@ fn test_gen_lint_group_list() {
         Lint::new("should_assert_eq", "group1", "abc", None, "module_name"),
         Lint::new("internal", "internal_style", "abc", None, "module_name"),
     ];
-    let expected = vec![
-        "store.register_group(true, \"clippy::group1\", Some(\"clippy_group1\"), vec![",
-        "LintId::of(module_name::ABC),",
-        "LintId::of(module_name::INTERNAL),",
-        "LintId::of(module_name::SHOULD_ASSERT_EQ),",
-        "])",
-    ];
-    assert_eq!(expected, gen_lint_group_list("group1", lints.iter()));
+    let expected = GENERATED_FILE_COMMENT.to_string()
+        + &[
+            "store.register_group(true, \"clippy::group1\", Some(\"clippy_group1\"), vec![",
+            "    LintId::of(module_name::ABC),",
+            "    LintId::of(module_name::INTERNAL),",
+            "    LintId::of(module_name::SHOULD_ASSERT_EQ),",
+            "])",
+        ]
+        .join("\n")
+        + "\n";
+
+    let result = gen_lint_group_list("group1", lints.iter());
+
+    assert_eq!(expected, result);
 }
diff --git a/clippy_dev/src/update_lints.rs b/clippy_dev/src/update_lints.rs
index ba550d492fc..f393a8d1de1 100644
--- a/clippy_dev/src/update_lints.rs
+++ b/clippy_dev/src/update_lints.rs
@@ -66,32 +66,37 @@ pub fn run(update_mode: UpdateMode) {
         exit_with_failure();
     }
 
-    for (name, lines) in [
-        ("mods", gen_modules_list(usable_lints.iter())),
-        ("deprecated", gen_deprecated(deprecated_lints.iter())),
-        (
-            "register_lints",
-            gen_register_lint_list(internal_lints.iter(), usable_lints.iter()),
-        ),
-        ("register_all", {
-            let all_group_lints = usable_lints.iter().filter(|l| {
-                matches!(
-                    &*l.group,
-                    "correctness" | "suspicious" | "style" | "complexity" | "perf"
-                )
-            });
-
-            gen_lint_group_list("all", all_group_lints)
-        }),
-    ] {
-        process_file(&format!("clippy_lints/src/lib.{}.rs", name), update_mode, &lines[..]);
-    }
+    process_file(
+        "clippy_lints/src/lib.register_lints.rs",
+        update_mode,
+        &gen_register_lint_list(internal_lints.iter(), usable_lints.iter()),
+    );
+    process_file(
+        "clippy_lints/src/lib.deprecated.rs",
+        update_mode,
+        &gen_deprecated(deprecated_lints.iter()),
+    );
+    process_file(
+        "clippy_lints/src/lib.mods.rs",
+        update_mode,
+        &gen_modules_list(usable_lints.iter()),
+    );
+
+    let all_group_lints = usable_lints.iter().filter(|l| {
+        matches!(
+            &*l.group,
+            "correctness" | "suspicious" | "style" | "complexity" | "perf"
+        )
+    });
+    let content = gen_lint_group_list("all", all_group_lints);
+    process_file("clippy_lints/src/lib.register_all.rs", update_mode, &content);
 
     for (lint_group, lints) in Lint::by_lint_group(usable_lints.into_iter().chain(internal_lints)) {
+        let content = gen_lint_group_list(&lint_group, lints.iter());
         process_file(
             &format!("clippy_lints/src/lib.register_{}.rs", lint_group),
             update_mode,
-            &gen_lint_group_list(&lints.get(0).expect("group non-empty").group, lints.iter())[..],
+            &content,
         );
     }
 }
@@ -122,21 +127,15 @@ fn round_to_fifty(count: usize) -> usize {
     count / 50 * 50
 }
 
-fn process_file(path: impl AsRef<Path>, update_mode: UpdateMode, new_lines: &[String]) {
-    let mut new_content = "// This file was generated by `cargo dev update_lints`.\n\
-                       // Use that command to update this file and do not edit by hand.\n\
-                       // Manual edits will be overwritten.\n\n"
-        .to_string();
-    new_content.push_str(&new_lines.join("\n"));
-
+fn process_file(path: impl AsRef<Path>, update_mode: UpdateMode, content: &str) {
     if update_mode == UpdateMode::Check {
         let old_content =
             fs::read_to_string(&path).unwrap_or_else(|e| panic!("Cannot read from {}: {}", path.as_ref().display(), e));
-        if new_content != old_content {
+        if content != old_content {
             exit_with_failure();
         }
     } else {
-        fs::write(&path, new_content.as_bytes())
+        fs::write(&path, content.as_bytes())
             .unwrap_or_else(|e| panic!("Cannot write to {}: {}", path.as_ref().display(), e));
     }
 }
diff --git a/clippy_lints/src/lib.deprecated.rs b/clippy_lints/src/lib.deprecated.rs
index f5134a0a80a..80bde1b1138 100644
--- a/clippy_lints/src/lib.deprecated.rs
+++ b/clippy_lints/src/lib.deprecated.rs
@@ -67,4 +67,4 @@
         "clippy::wrong_pub_self_convention",
         "set the `avoid-breaking-exported-api` config option to `false` to enable the `wrong_self_convention` lint for public items",
     );
-}
\ No newline at end of file
+}
diff --git a/clippy_lints/src/lib.mods.rs b/clippy_lints/src/lib.mods.rs
index 49f445c3531..2718604f905 100644
--- a/clippy_lints/src/lib.mods.rs
+++ b/clippy_lints/src/lib.mods.rs
@@ -229,4 +229,4 @@ mod wildcard_dependencies;
 mod wildcard_imports;
 mod write;
 mod zero_div_zero;
-mod zero_sized_map_values;
\ No newline at end of file
+mod zero_sized_map_values;
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 7a77303b834..3e6e0244754 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -3,302 +3,302 @@
 // Manual edits will be overwritten.
 
 store.register_group(true, "clippy::all", Some("clippy_all"), vec![
-LintId::of(absurd_extreme_comparisons::ABSURD_EXTREME_COMPARISONS),
-LintId::of(approx_const::APPROX_CONSTANT),
-LintId::of(assertions_on_constants::ASSERTIONS_ON_CONSTANTS),
-LintId::of(assign_ops::ASSIGN_OP_PATTERN),
-LintId::of(assign_ops::MISREFACTORED_ASSIGN_OP),
-LintId::of(async_yields_async::ASYNC_YIELDS_ASYNC),
-LintId::of(attrs::BLANKET_CLIPPY_RESTRICTION_LINTS),
-LintId::of(attrs::DEPRECATED_CFG_ATTR),
-LintId::of(attrs::DEPRECATED_SEMVER),
-LintId::of(attrs::MISMATCHED_TARGET_OS),
-LintId::of(attrs::USELESS_ATTRIBUTE),
-LintId::of(bit_mask::BAD_BIT_MASK),
-LintId::of(bit_mask::INEFFECTIVE_BIT_MASK),
-LintId::of(blacklisted_name::BLACKLISTED_NAME),
-LintId::of(blocks_in_if_conditions::BLOCKS_IN_IF_CONDITIONS),
-LintId::of(bool_assert_comparison::BOOL_ASSERT_COMPARISON),
-LintId::of(booleans::LOGIC_BUG),
-LintId::of(booleans::NONMINIMAL_BOOL),
-LintId::of(casts::CAST_REF_TO_MUT),
-LintId::of(casts::CHAR_LIT_AS_U8),
-LintId::of(casts::FN_TO_NUMERIC_CAST),
-LintId::of(casts::FN_TO_NUMERIC_CAST_WITH_TRUNCATION),
-LintId::of(casts::UNNECESSARY_CAST),
-LintId::of(collapsible_if::COLLAPSIBLE_ELSE_IF),
-LintId::of(collapsible_if::COLLAPSIBLE_IF),
-LintId::of(collapsible_match::COLLAPSIBLE_MATCH),
-LintId::of(comparison_chain::COMPARISON_CHAIN),
-LintId::of(copies::IFS_SAME_COND),
-LintId::of(copies::IF_SAME_THEN_ELSE),
-LintId::of(default::FIELD_REASSIGN_WITH_DEFAULT),
-LintId::of(derivable_impls::DERIVABLE_IMPLS),
-LintId::of(derive::DERIVE_HASH_XOR_EQ),
-LintId::of(derive::DERIVE_ORD_XOR_PARTIAL_ORD),
-LintId::of(doc::MISSING_SAFETY_DOC),
-LintId::of(doc::NEEDLESS_DOCTEST_MAIN),
-LintId::of(double_comparison::DOUBLE_COMPARISONS),
-LintId::of(double_parens::DOUBLE_PARENS),
-LintId::of(drop_forget_ref::DROP_COPY),
-LintId::of(drop_forget_ref::DROP_REF),
-LintId::of(drop_forget_ref::FORGET_COPY),
-LintId::of(drop_forget_ref::FORGET_REF),
-LintId::of(duration_subsec::DURATION_SUBSEC),
-LintId::of(entry::MAP_ENTRY),
-LintId::of(enum_clike::ENUM_CLIKE_UNPORTABLE_VARIANT),
-LintId::of(enum_variants::ENUM_VARIANT_NAMES),
-LintId::of(enum_variants::MODULE_INCEPTION),
-LintId::of(eq_op::EQ_OP),
-LintId::of(eq_op::OP_REF),
-LintId::of(erasing_op::ERASING_OP),
-LintId::of(escape::BOXED_LOCAL),
-LintId::of(eta_reduction::REDUNDANT_CLOSURE),
-LintId::of(eval_order_dependence::DIVERGING_SUB_EXPRESSION),
-LintId::of(eval_order_dependence::EVAL_ORDER_DEPENDENCE),
-LintId::of(explicit_write::EXPLICIT_WRITE),
-LintId::of(float_equality_without_abs::FLOAT_EQUALITY_WITHOUT_ABS),
-LintId::of(float_literal::EXCESSIVE_PRECISION),
-LintId::of(format::USELESS_FORMAT),
-LintId::of(formatting::POSSIBLE_MISSING_COMMA),
-LintId::of(formatting::SUSPICIOUS_ASSIGNMENT_FORMATTING),
-LintId::of(formatting::SUSPICIOUS_ELSE_FORMATTING),
-LintId::of(formatting::SUSPICIOUS_UNARY_OP_FORMATTING),
-LintId::of(from_over_into::FROM_OVER_INTO),
-LintId::of(from_str_radix_10::FROM_STR_RADIX_10),
-LintId::of(functions::DOUBLE_MUST_USE),
-LintId::of(functions::MUST_USE_UNIT),
-LintId::of(functions::NOT_UNSAFE_PTR_ARG_DEREF),
-LintId::of(functions::RESULT_UNIT_ERR),
-LintId::of(functions::TOO_MANY_ARGUMENTS),
-LintId::of(get_last_with_len::GET_LAST_WITH_LEN),
-LintId::of(identity_op::IDENTITY_OP),
-LintId::of(if_let_mutex::IF_LET_MUTEX),
-LintId::of(if_then_panic::IF_THEN_PANIC),
-LintId::of(indexing_slicing::OUT_OF_BOUNDS_INDEXING),
-LintId::of(infinite_iter::INFINITE_ITER),
-LintId::of(inherent_to_string::INHERENT_TO_STRING),
-LintId::of(inherent_to_string::INHERENT_TO_STRING_SHADOW_DISPLAY),
-LintId::of(inline_fn_without_body::INLINE_FN_WITHOUT_BODY),
-LintId::of(int_plus_one::INT_PLUS_ONE),
-LintId::of(large_const_arrays::LARGE_CONST_ARRAYS),
-LintId::of(large_enum_variant::LARGE_ENUM_VARIANT),
-LintId::of(len_zero::COMPARISON_TO_EMPTY),
-LintId::of(len_zero::LEN_WITHOUT_IS_EMPTY),
-LintId::of(len_zero::LEN_ZERO),
-LintId::of(let_underscore::LET_UNDERSCORE_LOCK),
-LintId::of(lifetimes::EXTRA_UNUSED_LIFETIMES),
-LintId::of(lifetimes::NEEDLESS_LIFETIMES),
-LintId::of(literal_representation::INCONSISTENT_DIGIT_GROUPING),
-LintId::of(literal_representation::MISTYPED_LITERAL_SUFFIXES),
-LintId::of(literal_representation::UNUSUAL_BYTE_GROUPINGS),
-LintId::of(loops::EMPTY_LOOP),
-LintId::of(loops::EXPLICIT_COUNTER_LOOP),
-LintId::of(loops::FOR_KV_MAP),
-LintId::of(loops::FOR_LOOPS_OVER_FALLIBLES),
-LintId::of(loops::ITER_NEXT_LOOP),
-LintId::of(loops::MANUAL_FLATTEN),
-LintId::of(loops::MANUAL_MEMCPY),
-LintId::of(loops::MUT_RANGE_BOUND),
-LintId::of(loops::NEEDLESS_COLLECT),
-LintId::of(loops::NEEDLESS_RANGE_LOOP),
-LintId::of(loops::NEVER_LOOP),
-LintId::of(loops::SAME_ITEM_PUSH),
-LintId::of(loops::SINGLE_ELEMENT_LOOP),
-LintId::of(loops::WHILE_IMMUTABLE_CONDITION),
-LintId::of(loops::WHILE_LET_LOOP),
-LintId::of(loops::WHILE_LET_ON_ITERATOR),
-LintId::of(main_recursion::MAIN_RECURSION),
-LintId::of(manual_async_fn::MANUAL_ASYNC_FN),
-LintId::of(manual_map::MANUAL_MAP),
-LintId::of(manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE),
-LintId::of(manual_strip::MANUAL_STRIP),
-LintId::of(manual_unwrap_or::MANUAL_UNWRAP_OR),
-LintId::of(map_clone::MAP_CLONE),
-LintId::of(map_unit_fn::OPTION_MAP_UNIT_FN),
-LintId::of(map_unit_fn::RESULT_MAP_UNIT_FN),
-LintId::of(match_result_ok::MATCH_RESULT_OK),
-LintId::of(matches::INFALLIBLE_DESTRUCTURING_MATCH),
-LintId::of(matches::MATCH_AS_REF),
-LintId::of(matches::MATCH_LIKE_MATCHES_MACRO),
-LintId::of(matches::MATCH_OVERLAPPING_ARM),
-LintId::of(matches::MATCH_REF_PATS),
-LintId::of(matches::MATCH_SINGLE_BINDING),
-LintId::of(matches::REDUNDANT_PATTERN_MATCHING),
-LintId::of(matches::SINGLE_MATCH),
-LintId::of(matches::WILDCARD_IN_OR_PATTERNS),
-LintId::of(mem_discriminant::MEM_DISCRIMINANT_NON_ENUM),
-LintId::of(mem_replace::MEM_REPLACE_OPTION_WITH_NONE),
-LintId::of(mem_replace::MEM_REPLACE_WITH_DEFAULT),
-LintId::of(mem_replace::MEM_REPLACE_WITH_UNINIT),
-LintId::of(methods::BIND_INSTEAD_OF_MAP),
-LintId::of(methods::BYTES_NTH),
-LintId::of(methods::CHARS_LAST_CMP),
-LintId::of(methods::CHARS_NEXT_CMP),
-LintId::of(methods::CLONE_DOUBLE_REF),
-LintId::of(methods::CLONE_ON_COPY),
-LintId::of(methods::EXPECT_FUN_CALL),
-LintId::of(methods::EXTEND_WITH_DRAIN),
-LintId::of(methods::FILTER_MAP_IDENTITY),
-LintId::of(methods::FILTER_NEXT),
-LintId::of(methods::FLAT_MAP_IDENTITY),
-LintId::of(methods::INSPECT_FOR_EACH),
-LintId::of(methods::INTO_ITER_ON_REF),
-LintId::of(methods::ITERATOR_STEP_BY_ZERO),
-LintId::of(methods::ITER_CLONED_COLLECT),
-LintId::of(methods::ITER_COUNT),
-LintId::of(methods::ITER_NEXT_SLICE),
-LintId::of(methods::ITER_NTH),
-LintId::of(methods::ITER_NTH_ZERO),
-LintId::of(methods::ITER_SKIP_NEXT),
-LintId::of(methods::MANUAL_FILTER_MAP),
-LintId::of(methods::MANUAL_FIND_MAP),
-LintId::of(methods::MANUAL_SATURATING_ARITHMETIC),
-LintId::of(methods::MANUAL_SPLIT_ONCE),
-LintId::of(methods::MANUAL_STR_REPEAT),
-LintId::of(methods::MAP_COLLECT_RESULT_UNIT),
-LintId::of(methods::MAP_IDENTITY),
-LintId::of(methods::NEW_RET_NO_SELF),
-LintId::of(methods::OK_EXPECT),
-LintId::of(methods::OPTION_AS_REF_DEREF),
-LintId::of(methods::OPTION_FILTER_MAP),
-LintId::of(methods::OPTION_MAP_OR_NONE),
-LintId::of(methods::OR_FUN_CALL),
-LintId::of(methods::RESULT_MAP_OR_INTO_OPTION),
-LintId::of(methods::SEARCH_IS_SOME),
-LintId::of(methods::SHOULD_IMPLEMENT_TRAIT),
-LintId::of(methods::SINGLE_CHAR_ADD_STR),
-LintId::of(methods::SINGLE_CHAR_PATTERN),
-LintId::of(methods::SKIP_WHILE_NEXT),
-LintId::of(methods::STRING_EXTEND_CHARS),
-LintId::of(methods::SUSPICIOUS_MAP),
-LintId::of(methods::SUSPICIOUS_SPLITN),
-LintId::of(methods::UNINIT_ASSUMED_INIT),
-LintId::of(methods::UNNECESSARY_FILTER_MAP),
-LintId::of(methods::UNNECESSARY_FOLD),
-LintId::of(methods::UNNECESSARY_LAZY_EVALUATIONS),
-LintId::of(methods::UNWRAP_OR_ELSE_DEFAULT),
-LintId::of(methods::USELESS_ASREF),
-LintId::of(methods::WRONG_SELF_CONVENTION),
-LintId::of(methods::ZST_OFFSET),
-LintId::of(minmax::MIN_MAX),
-LintId::of(misc::CMP_NAN),
-LintId::of(misc::CMP_OWNED),
-LintId::of(misc::MODULO_ONE),
-LintId::of(misc::SHORT_CIRCUIT_STATEMENT),
-LintId::of(misc::TOPLEVEL_REF_ARG),
-LintId::of(misc::ZERO_PTR),
-LintId::of(misc_early::BUILTIN_TYPE_SHADOW),
-LintId::of(misc_early::DOUBLE_NEG),
-LintId::of(misc_early::DUPLICATE_UNDERSCORE_ARGUMENT),
-LintId::of(misc_early::MIXED_CASE_HEX_LITERALS),
-LintId::of(misc_early::REDUNDANT_PATTERN),
-LintId::of(misc_early::UNNEEDED_WILDCARD_PATTERN),
-LintId::of(misc_early::ZERO_PREFIXED_LITERAL),
-LintId::of(mut_key::MUTABLE_KEY_TYPE),
-LintId::of(mut_mutex_lock::MUT_MUTEX_LOCK),
-LintId::of(mut_reference::UNNECESSARY_MUT_PASSED),
-LintId::of(mutex_atomic::MUTEX_ATOMIC),
-LintId::of(needless_arbitrary_self_type::NEEDLESS_ARBITRARY_SELF_TYPE),
-LintId::of(needless_bool::BOOL_COMPARISON),
-LintId::of(needless_bool::NEEDLESS_BOOL),
-LintId::of(needless_borrow::NEEDLESS_BORROW),
-LintId::of(needless_borrowed_ref::NEEDLESS_BORROWED_REFERENCE),
-LintId::of(needless_option_as_deref::NEEDLESS_OPTION_AS_DEREF),
-LintId::of(needless_question_mark::NEEDLESS_QUESTION_MARK),
-LintId::of(needless_update::NEEDLESS_UPDATE),
-LintId::of(neg_cmp_op_on_partial_ord::NEG_CMP_OP_ON_PARTIAL_ORD),
-LintId::of(neg_multiply::NEG_MULTIPLY),
-LintId::of(new_without_default::NEW_WITHOUT_DEFAULT),
-LintId::of(no_effect::NO_EFFECT),
-LintId::of(no_effect::UNNECESSARY_OPERATION),
-LintId::of(non_copy_const::BORROW_INTERIOR_MUTABLE_CONST),
-LintId::of(non_copy_const::DECLARE_INTERIOR_MUTABLE_CONST),
-LintId::of(non_expressive_names::JUST_UNDERSCORES_AND_DIGITS),
-LintId::of(non_octal_unix_permissions::NON_OCTAL_UNIX_PERMISSIONS),
-LintId::of(open_options::NONSENSICAL_OPEN_OPTIONS),
-LintId::of(option_env_unwrap::OPTION_ENV_UNWRAP),
-LintId::of(overflow_check_conditional::OVERFLOW_CHECK_CONDITIONAL),
-LintId::of(partialeq_ne_impl::PARTIALEQ_NE_IMPL),
-LintId::of(precedence::PRECEDENCE),
-LintId::of(ptr::CMP_NULL),
-LintId::of(ptr::INVALID_NULL_PTR_USAGE),
-LintId::of(ptr::MUT_FROM_REF),
-LintId::of(ptr::PTR_ARG),
-LintId::of(ptr_eq::PTR_EQ),
-LintId::of(ptr_offset_with_cast::PTR_OFFSET_WITH_CAST),
-LintId::of(question_mark::QUESTION_MARK),
-LintId::of(ranges::MANUAL_RANGE_CONTAINS),
-LintId::of(ranges::RANGE_ZIP_WITH_LEN),
-LintId::of(ranges::REVERSED_EMPTY_RANGES),
-LintId::of(redundant_clone::REDUNDANT_CLONE),
-LintId::of(redundant_closure_call::REDUNDANT_CLOSURE_CALL),
-LintId::of(redundant_field_names::REDUNDANT_FIELD_NAMES),
-LintId::of(redundant_slicing::REDUNDANT_SLICING),
-LintId::of(redundant_static_lifetimes::REDUNDANT_STATIC_LIFETIMES),
-LintId::of(reference::DEREF_ADDROF),
-LintId::of(reference::REF_IN_DEREF),
-LintId::of(regex::INVALID_REGEX),
-LintId::of(repeat_once::REPEAT_ONCE),
-LintId::of(returns::LET_AND_RETURN),
-LintId::of(returns::NEEDLESS_RETURN),
-LintId::of(self_assignment::SELF_ASSIGNMENT),
-LintId::of(self_named_constructors::SELF_NAMED_CONSTRUCTORS),
-LintId::of(serde_api::SERDE_API_MISUSE),
-LintId::of(single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS),
-LintId::of(size_of_in_element_count::SIZE_OF_IN_ELEMENT_COUNT),
-LintId::of(slow_vector_initialization::SLOW_VECTOR_INITIALIZATION),
-LintId::of(stable_sort_primitive::STABLE_SORT_PRIMITIVE),
-LintId::of(strings::STRING_FROM_UTF8_AS_BYTES),
-LintId::of(strlen_on_c_strings::STRLEN_ON_C_STRINGS),
-LintId::of(suspicious_trait_impl::SUSPICIOUS_ARITHMETIC_IMPL),
-LintId::of(suspicious_trait_impl::SUSPICIOUS_OP_ASSIGN_IMPL),
-LintId::of(swap::ALMOST_SWAPPED),
-LintId::of(swap::MANUAL_SWAP),
-LintId::of(tabs_in_doc_comments::TABS_IN_DOC_COMMENTS),
-LintId::of(temporary_assignment::TEMPORARY_ASSIGNMENT),
-LintId::of(to_digit_is_some::TO_DIGIT_IS_SOME),
-LintId::of(to_string_in_display::TO_STRING_IN_DISPLAY),
-LintId::of(transmute::CROSSPOINTER_TRANSMUTE),
-LintId::of(transmute::TRANSMUTES_EXPRESSIBLE_AS_PTR_CASTS),
-LintId::of(transmute::TRANSMUTE_BYTES_TO_STR),
-LintId::of(transmute::TRANSMUTE_FLOAT_TO_INT),
-LintId::of(transmute::TRANSMUTE_INT_TO_BOOL),
-LintId::of(transmute::TRANSMUTE_INT_TO_CHAR),
-LintId::of(transmute::TRANSMUTE_INT_TO_FLOAT),
-LintId::of(transmute::TRANSMUTE_PTR_TO_REF),
-LintId::of(transmute::UNSOUND_COLLECTION_TRANSMUTE),
-LintId::of(transmute::WRONG_TRANSMUTE),
-LintId::of(transmuting_null::TRANSMUTING_NULL),
-LintId::of(try_err::TRY_ERR),
-LintId::of(types::BORROWED_BOX),
-LintId::of(types::BOX_COLLECTION),
-LintId::of(types::REDUNDANT_ALLOCATION),
-LintId::of(types::TYPE_COMPLEXITY),
-LintId::of(types::VEC_BOX),
-LintId::of(undropped_manually_drops::UNDROPPED_MANUALLY_DROPS),
-LintId::of(unicode::INVISIBLE_CHARACTERS),
-LintId::of(unit_return_expecting_ord::UNIT_RETURN_EXPECTING_ORD),
-LintId::of(unit_types::UNIT_ARG),
-LintId::of(unit_types::UNIT_CMP),
-LintId::of(unnamed_address::FN_ADDRESS_COMPARISONS),
-LintId::of(unnamed_address::VTABLE_ADDRESS_COMPARISONS),
-LintId::of(unnecessary_sort_by::UNNECESSARY_SORT_BY),
-LintId::of(unsafe_removed_from_name::UNSAFE_REMOVED_FROM_NAME),
-LintId::of(unused_io_amount::UNUSED_IO_AMOUNT),
-LintId::of(unused_unit::UNUSED_UNIT),
-LintId::of(unwrap::PANICKING_UNWRAP),
-LintId::of(unwrap::UNNECESSARY_UNWRAP),
-LintId::of(upper_case_acronyms::UPPER_CASE_ACRONYMS),
-LintId::of(useless_conversion::USELESS_CONVERSION),
-LintId::of(vec::USELESS_VEC),
-LintId::of(vec_init_then_push::VEC_INIT_THEN_PUSH),
-LintId::of(vec_resize_to_zero::VEC_RESIZE_TO_ZERO),
-LintId::of(write::PRINTLN_EMPTY_STRING),
-LintId::of(write::PRINT_LITERAL),
-LintId::of(write::PRINT_WITH_NEWLINE),
-LintId::of(write::WRITELN_EMPTY_STRING),
-LintId::of(write::WRITE_LITERAL),
-LintId::of(write::WRITE_WITH_NEWLINE),
-LintId::of(zero_div_zero::ZERO_DIVIDED_BY_ZERO),
-])
\ No newline at end of file
+    LintId::of(absurd_extreme_comparisons::ABSURD_EXTREME_COMPARISONS),
+    LintId::of(approx_const::APPROX_CONSTANT),
+    LintId::of(assertions_on_constants::ASSERTIONS_ON_CONSTANTS),
+    LintId::of(assign_ops::ASSIGN_OP_PATTERN),
+    LintId::of(assign_ops::MISREFACTORED_ASSIGN_OP),
+    LintId::of(async_yields_async::ASYNC_YIELDS_ASYNC),
+    LintId::of(attrs::BLANKET_CLIPPY_RESTRICTION_LINTS),
+    LintId::of(attrs::DEPRECATED_CFG_ATTR),
+    LintId::of(attrs::DEPRECATED_SEMVER),
+    LintId::of(attrs::MISMATCHED_TARGET_OS),
+    LintId::of(attrs::USELESS_ATTRIBUTE),
+    LintId::of(bit_mask::BAD_BIT_MASK),
+    LintId::of(bit_mask::INEFFECTIVE_BIT_MASK),
+    LintId::of(blacklisted_name::BLACKLISTED_NAME),
+    LintId::of(blocks_in_if_conditions::BLOCKS_IN_IF_CONDITIONS),
+    LintId::of(bool_assert_comparison::BOOL_ASSERT_COMPARISON),
+    LintId::of(booleans::LOGIC_BUG),
+    LintId::of(booleans::NONMINIMAL_BOOL),
+    LintId::of(casts::CAST_REF_TO_MUT),
+    LintId::of(casts::CHAR_LIT_AS_U8),
+    LintId::of(casts::FN_TO_NUMERIC_CAST),
+    LintId::of(casts::FN_TO_NUMERIC_CAST_WITH_TRUNCATION),
+    LintId::of(casts::UNNECESSARY_CAST),
+    LintId::of(collapsible_if::COLLAPSIBLE_ELSE_IF),
+    LintId::of(collapsible_if::COLLAPSIBLE_IF),
+    LintId::of(collapsible_match::COLLAPSIBLE_MATCH),
+    LintId::of(comparison_chain::COMPARISON_CHAIN),
+    LintId::of(copies::IFS_SAME_COND),
+    LintId::of(copies::IF_SAME_THEN_ELSE),
+    LintId::of(default::FIELD_REASSIGN_WITH_DEFAULT),
+    LintId::of(derivable_impls::DERIVABLE_IMPLS),
+    LintId::of(derive::DERIVE_HASH_XOR_EQ),
+    LintId::of(derive::DERIVE_ORD_XOR_PARTIAL_ORD),
+    LintId::of(doc::MISSING_SAFETY_DOC),
+    LintId::of(doc::NEEDLESS_DOCTEST_MAIN),
+    LintId::of(double_comparison::DOUBLE_COMPARISONS),
+    LintId::of(double_parens::DOUBLE_PARENS),
+    LintId::of(drop_forget_ref::DROP_COPY),
+    LintId::of(drop_forget_ref::DROP_REF),
+    LintId::of(drop_forget_ref::FORGET_COPY),
+    LintId::of(drop_forget_ref::FORGET_REF),
+    LintId::of(duration_subsec::DURATION_SUBSEC),
+    LintId::of(entry::MAP_ENTRY),
+    LintId::of(enum_clike::ENUM_CLIKE_UNPORTABLE_VARIANT),
+    LintId::of(enum_variants::ENUM_VARIANT_NAMES),
+    LintId::of(enum_variants::MODULE_INCEPTION),
+    LintId::of(eq_op::EQ_OP),
+    LintId::of(eq_op::OP_REF),
+    LintId::of(erasing_op::ERASING_OP),
+    LintId::of(escape::BOXED_LOCAL),
+    LintId::of(eta_reduction::REDUNDANT_CLOSURE),
+    LintId::of(eval_order_dependence::DIVERGING_SUB_EXPRESSION),
+    LintId::of(eval_order_dependence::EVAL_ORDER_DEPENDENCE),
+    LintId::of(explicit_write::EXPLICIT_WRITE),
+    LintId::of(float_equality_without_abs::FLOAT_EQUALITY_WITHOUT_ABS),
+    LintId::of(float_literal::EXCESSIVE_PRECISION),
+    LintId::of(format::USELESS_FORMAT),
+    LintId::of(formatting::POSSIBLE_MISSING_COMMA),
+    LintId::of(formatting::SUSPICIOUS_ASSIGNMENT_FORMATTING),
+    LintId::of(formatting::SUSPICIOUS_ELSE_FORMATTING),
+    LintId::of(formatting::SUSPICIOUS_UNARY_OP_FORMATTING),
+    LintId::of(from_over_into::FROM_OVER_INTO),
+    LintId::of(from_str_radix_10::FROM_STR_RADIX_10),
+    LintId::of(functions::DOUBLE_MUST_USE),
+    LintId::of(functions::MUST_USE_UNIT),
+    LintId::of(functions::NOT_UNSAFE_PTR_ARG_DEREF),
+    LintId::of(functions::RESULT_UNIT_ERR),
+    LintId::of(functions::TOO_MANY_ARGUMENTS),
+    LintId::of(get_last_with_len::GET_LAST_WITH_LEN),
+    LintId::of(identity_op::IDENTITY_OP),
+    LintId::of(if_let_mutex::IF_LET_MUTEX),
+    LintId::of(if_then_panic::IF_THEN_PANIC),
+    LintId::of(indexing_slicing::OUT_OF_BOUNDS_INDEXING),
+    LintId::of(infinite_iter::INFINITE_ITER),
+    LintId::of(inherent_to_string::INHERENT_TO_STRING),
+    LintId::of(inherent_to_string::INHERENT_TO_STRING_SHADOW_DISPLAY),
+    LintId::of(inline_fn_without_body::INLINE_FN_WITHOUT_BODY),
+    LintId::of(int_plus_one::INT_PLUS_ONE),
+    LintId::of(large_const_arrays::LARGE_CONST_ARRAYS),
+    LintId::of(large_enum_variant::LARGE_ENUM_VARIANT),
+    LintId::of(len_zero::COMPARISON_TO_EMPTY),
+    LintId::of(len_zero::LEN_WITHOUT_IS_EMPTY),
+    LintId::of(len_zero::LEN_ZERO),
+    LintId::of(let_underscore::LET_UNDERSCORE_LOCK),
+    LintId::of(lifetimes::EXTRA_UNUSED_LIFETIMES),
+    LintId::of(lifetimes::NEEDLESS_LIFETIMES),
+    LintId::of(literal_representation::INCONSISTENT_DIGIT_GROUPING),
+    LintId::of(literal_representation::MISTYPED_LITERAL_SUFFIXES),
+    LintId::of(literal_representation::UNUSUAL_BYTE_GROUPINGS),
+    LintId::of(loops::EMPTY_LOOP),
+    LintId::of(loops::EXPLICIT_COUNTER_LOOP),
+    LintId::of(loops::FOR_KV_MAP),
+    LintId::of(loops::FOR_LOOPS_OVER_FALLIBLES),
+    LintId::of(loops::ITER_NEXT_LOOP),
+    LintId::of(loops::MANUAL_FLATTEN),
+    LintId::of(loops::MANUAL_MEMCPY),
+    LintId::of(loops::MUT_RANGE_BOUND),
+    LintId::of(loops::NEEDLESS_COLLECT),
+    LintId::of(loops::NEEDLESS_RANGE_LOOP),
+    LintId::of(loops::NEVER_LOOP),
+    LintId::of(loops::SAME_ITEM_PUSH),
+    LintId::of(loops::SINGLE_ELEMENT_LOOP),
+    LintId::of(loops::WHILE_IMMUTABLE_CONDITION),
+    LintId::of(loops::WHILE_LET_LOOP),
+    LintId::of(loops::WHILE_LET_ON_ITERATOR),
+    LintId::of(main_recursion::MAIN_RECURSION),
+    LintId::of(manual_async_fn::MANUAL_ASYNC_FN),
+    LintId::of(manual_map::MANUAL_MAP),
+    LintId::of(manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE),
+    LintId::of(manual_strip::MANUAL_STRIP),
+    LintId::of(manual_unwrap_or::MANUAL_UNWRAP_OR),
+    LintId::of(map_clone::MAP_CLONE),
+    LintId::of(map_unit_fn::OPTION_MAP_UNIT_FN),
+    LintId::of(map_unit_fn::RESULT_MAP_UNIT_FN),
+    LintId::of(match_result_ok::MATCH_RESULT_OK),
+    LintId::of(matches::INFALLIBLE_DESTRUCTURING_MATCH),
+    LintId::of(matches::MATCH_AS_REF),
+    LintId::of(matches::MATCH_LIKE_MATCHES_MACRO),
+    LintId::of(matches::MATCH_OVERLAPPING_ARM),
+    LintId::of(matches::MATCH_REF_PATS),
+    LintId::of(matches::MATCH_SINGLE_BINDING),
+    LintId::of(matches::REDUNDANT_PATTERN_MATCHING),
+    LintId::of(matches::SINGLE_MATCH),
+    LintId::of(matches::WILDCARD_IN_OR_PATTERNS),
+    LintId::of(mem_discriminant::MEM_DISCRIMINANT_NON_ENUM),
+    LintId::of(mem_replace::MEM_REPLACE_OPTION_WITH_NONE),
+    LintId::of(mem_replace::MEM_REPLACE_WITH_DEFAULT),
+    LintId::of(mem_replace::MEM_REPLACE_WITH_UNINIT),
+    LintId::of(methods::BIND_INSTEAD_OF_MAP),
+    LintId::of(methods::BYTES_NTH),
+    LintId::of(methods::CHARS_LAST_CMP),
+    LintId::of(methods::CHARS_NEXT_CMP),
+    LintId::of(methods::CLONE_DOUBLE_REF),
+    LintId::of(methods::CLONE_ON_COPY),
+    LintId::of(methods::EXPECT_FUN_CALL),
+    LintId::of(methods::EXTEND_WITH_DRAIN),
+    LintId::of(methods::FILTER_MAP_IDENTITY),
+    LintId::of(methods::FILTER_NEXT),
+    LintId::of(methods::FLAT_MAP_IDENTITY),
+    LintId::of(methods::INSPECT_FOR_EACH),
+    LintId::of(methods::INTO_ITER_ON_REF),
+    LintId::of(methods::ITERATOR_STEP_BY_ZERO),
+    LintId::of(methods::ITER_CLONED_COLLECT),
+    LintId::of(methods::ITER_COUNT),
+    LintId::of(methods::ITER_NEXT_SLICE),
+    LintId::of(methods::ITER_NTH),
+    LintId::of(methods::ITER_NTH_ZERO),
+    LintId::of(methods::ITER_SKIP_NEXT),
+    LintId::of(methods::MANUAL_FILTER_MAP),
+    LintId::of(methods::MANUAL_FIND_MAP),
+    LintId::of(methods::MANUAL_SATURATING_ARITHMETIC),
+    LintId::of(methods::MANUAL_SPLIT_ONCE),
+    LintId::of(methods::MANUAL_STR_REPEAT),
+    LintId::of(methods::MAP_COLLECT_RESULT_UNIT),
+    LintId::of(methods::MAP_IDENTITY),
+    LintId::of(methods::NEW_RET_NO_SELF),
+    LintId::of(methods::OK_EXPECT),
+    LintId::of(methods::OPTION_AS_REF_DEREF),
+    LintId::of(methods::OPTION_FILTER_MAP),
+    LintId::of(methods::OPTION_MAP_OR_NONE),
+    LintId::of(methods::OR_FUN_CALL),
+    LintId::of(methods::RESULT_MAP_OR_INTO_OPTION),
+    LintId::of(methods::SEARCH_IS_SOME),
+    LintId::of(methods::SHOULD_IMPLEMENT_TRAIT),
+    LintId::of(methods::SINGLE_CHAR_ADD_STR),
+    LintId::of(methods::SINGLE_CHAR_PATTERN),
+    LintId::of(methods::SKIP_WHILE_NEXT),
+    LintId::of(methods::STRING_EXTEND_CHARS),
+    LintId::of(methods::SUSPICIOUS_MAP),
+    LintId::of(methods::SUSPICIOUS_SPLITN),
+    LintId::of(methods::UNINIT_ASSUMED_INIT),
+    LintId::of(methods::UNNECESSARY_FILTER_MAP),
+    LintId::of(methods::UNNECESSARY_FOLD),
+    LintId::of(methods::UNNECESSARY_LAZY_EVALUATIONS),
+    LintId::of(methods::UNWRAP_OR_ELSE_DEFAULT),
+    LintId::of(methods::USELESS_ASREF),
+    LintId::of(methods::WRONG_SELF_CONVENTION),
+    LintId::of(methods::ZST_OFFSET),
+    LintId::of(minmax::MIN_MAX),
+    LintId::of(misc::CMP_NAN),
+    LintId::of(misc::CMP_OWNED),
+    LintId::of(misc::MODULO_ONE),
+    LintId::of(misc::SHORT_CIRCUIT_STATEMENT),
+    LintId::of(misc::TOPLEVEL_REF_ARG),
+    LintId::of(misc::ZERO_PTR),
+    LintId::of(misc_early::BUILTIN_TYPE_SHADOW),
+    LintId::of(misc_early::DOUBLE_NEG),
+    LintId::of(misc_early::DUPLICATE_UNDERSCORE_ARGUMENT),
+    LintId::of(misc_early::MIXED_CASE_HEX_LITERALS),
+    LintId::of(misc_early::REDUNDANT_PATTERN),
+    LintId::of(misc_early::UNNEEDED_WILDCARD_PATTERN),
+    LintId::of(misc_early::ZERO_PREFIXED_LITERAL),
+    LintId::of(mut_key::MUTABLE_KEY_TYPE),
+    LintId::of(mut_mutex_lock::MUT_MUTEX_LOCK),
+    LintId::of(mut_reference::UNNECESSARY_MUT_PASSED),
+    LintId::of(mutex_atomic::MUTEX_ATOMIC),
+    LintId::of(needless_arbitrary_self_type::NEEDLESS_ARBITRARY_SELF_TYPE),
+    LintId::of(needless_bool::BOOL_COMPARISON),
+    LintId::of(needless_bool::NEEDLESS_BOOL),
+    LintId::of(needless_borrow::NEEDLESS_BORROW),
+    LintId::of(needless_borrowed_ref::NEEDLESS_BORROWED_REFERENCE),
+    LintId::of(needless_option_as_deref::NEEDLESS_OPTION_AS_DEREF),
+    LintId::of(needless_question_mark::NEEDLESS_QUESTION_MARK),
+    LintId::of(needless_update::NEEDLESS_UPDATE),
+    LintId::of(neg_cmp_op_on_partial_ord::NEG_CMP_OP_ON_PARTIAL_ORD),
+    LintId::of(neg_multiply::NEG_MULTIPLY),
+    LintId::of(new_without_default::NEW_WITHOUT_DEFAULT),
+    LintId::of(no_effect::NO_EFFECT),
+    LintId::of(no_effect::UNNECESSARY_OPERATION),
+    LintId::of(non_copy_const::BORROW_INTERIOR_MUTABLE_CONST),
+    LintId::of(non_copy_const::DECLARE_INTERIOR_MUTABLE_CONST),
+    LintId::of(non_expressive_names::JUST_UNDERSCORES_AND_DIGITS),
+    LintId::of(non_octal_unix_permissions::NON_OCTAL_UNIX_PERMISSIONS),
+    LintId::of(open_options::NONSENSICAL_OPEN_OPTIONS),
+    LintId::of(option_env_unwrap::OPTION_ENV_UNWRAP),
+    LintId::of(overflow_check_conditional::OVERFLOW_CHECK_CONDITIONAL),
+    LintId::of(partialeq_ne_impl::PARTIALEQ_NE_IMPL),
+    LintId::of(precedence::PRECEDENCE),
+    LintId::of(ptr::CMP_NULL),
+    LintId::of(ptr::INVALID_NULL_PTR_USAGE),
+    LintId::of(ptr::MUT_FROM_REF),
+    LintId::of(ptr::PTR_ARG),
+    LintId::of(ptr_eq::PTR_EQ),
+    LintId::of(ptr_offset_with_cast::PTR_OFFSET_WITH_CAST),
+    LintId::of(question_mark::QUESTION_MARK),
+    LintId::of(ranges::MANUAL_RANGE_CONTAINS),
+    LintId::of(ranges::RANGE_ZIP_WITH_LEN),
+    LintId::of(ranges::REVERSED_EMPTY_RANGES),
+    LintId::of(redundant_clone::REDUNDANT_CLONE),
+    LintId::of(redundant_closure_call::REDUNDANT_CLOSURE_CALL),
+    LintId::of(redundant_field_names::REDUNDANT_FIELD_NAMES),
+    LintId::of(redundant_slicing::REDUNDANT_SLICING),
+    LintId::of(redundant_static_lifetimes::REDUNDANT_STATIC_LIFETIMES),
+    LintId::of(reference::DEREF_ADDROF),
+    LintId::of(reference::REF_IN_DEREF),
+    LintId::of(regex::INVALID_REGEX),
+    LintId::of(repeat_once::REPEAT_ONCE),
+    LintId::of(returns::LET_AND_RETURN),
+    LintId::of(returns::NEEDLESS_RETURN),
+    LintId::of(self_assignment::SELF_ASSIGNMENT),
+    LintId::of(self_named_constructors::SELF_NAMED_CONSTRUCTORS),
+    LintId::of(serde_api::SERDE_API_MISUSE),
+    LintId::of(single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS),
+    LintId::of(size_of_in_element_count::SIZE_OF_IN_ELEMENT_COUNT),
+    LintId::of(slow_vector_initialization::SLOW_VECTOR_INITIALIZATION),
+    LintId::of(stable_sort_primitive::STABLE_SORT_PRIMITIVE),
+    LintId::of(strings::STRING_FROM_UTF8_AS_BYTES),
+    LintId::of(strlen_on_c_strings::STRLEN_ON_C_STRINGS),
+    LintId::of(suspicious_trait_impl::SUSPICIOUS_ARITHMETIC_IMPL),
+    LintId::of(suspicious_trait_impl::SUSPICIOUS_OP_ASSIGN_IMPL),
+    LintId::of(swap::ALMOST_SWAPPED),
+    LintId::of(swap::MANUAL_SWAP),
+    LintId::of(tabs_in_doc_comments::TABS_IN_DOC_COMMENTS),
+    LintId::of(temporary_assignment::TEMPORARY_ASSIGNMENT),
+    LintId::of(to_digit_is_some::TO_DIGIT_IS_SOME),
+    LintId::of(to_string_in_display::TO_STRING_IN_DISPLAY),
+    LintId::of(transmute::CROSSPOINTER_TRANSMUTE),
+    LintId::of(transmute::TRANSMUTES_EXPRESSIBLE_AS_PTR_CASTS),
+    LintId::of(transmute::TRANSMUTE_BYTES_TO_STR),
+    LintId::of(transmute::TRANSMUTE_FLOAT_TO_INT),
+    LintId::of(transmute::TRANSMUTE_INT_TO_BOOL),
+    LintId::of(transmute::TRANSMUTE_INT_TO_CHAR),
+    LintId::of(transmute::TRANSMUTE_INT_TO_FLOAT),
+    LintId::of(transmute::TRANSMUTE_PTR_TO_REF),
+    LintId::of(transmute::UNSOUND_COLLECTION_TRANSMUTE),
+    LintId::of(transmute::WRONG_TRANSMUTE),
+    LintId::of(transmuting_null::TRANSMUTING_NULL),
+    LintId::of(try_err::TRY_ERR),
+    LintId::of(types::BORROWED_BOX),
+    LintId::of(types::BOX_COLLECTION),
+    LintId::of(types::REDUNDANT_ALLOCATION),
+    LintId::of(types::TYPE_COMPLEXITY),
+    LintId::of(types::VEC_BOX),
+    LintId::of(undropped_manually_drops::UNDROPPED_MANUALLY_DROPS),
+    LintId::of(unicode::INVISIBLE_CHARACTERS),
+    LintId::of(unit_return_expecting_ord::UNIT_RETURN_EXPECTING_ORD),
+    LintId::of(unit_types::UNIT_ARG),
+    LintId::of(unit_types::UNIT_CMP),
+    LintId::of(unnamed_address::FN_ADDRESS_COMPARISONS),
+    LintId::of(unnamed_address::VTABLE_ADDRESS_COMPARISONS),
+    LintId::of(unnecessary_sort_by::UNNECESSARY_SORT_BY),
+    LintId::of(unsafe_removed_from_name::UNSAFE_REMOVED_FROM_NAME),
+    LintId::of(unused_io_amount::UNUSED_IO_AMOUNT),
+    LintId::of(unused_unit::UNUSED_UNIT),
+    LintId::of(unwrap::PANICKING_UNWRAP),
+    LintId::of(unwrap::UNNECESSARY_UNWRAP),
+    LintId::of(upper_case_acronyms::UPPER_CASE_ACRONYMS),
+    LintId::of(useless_conversion::USELESS_CONVERSION),
+    LintId::of(vec::USELESS_VEC),
+    LintId::of(vec_init_then_push::VEC_INIT_THEN_PUSH),
+    LintId::of(vec_resize_to_zero::VEC_RESIZE_TO_ZERO),
+    LintId::of(write::PRINTLN_EMPTY_STRING),
+    LintId::of(write::PRINT_LITERAL),
+    LintId::of(write::PRINT_WITH_NEWLINE),
+    LintId::of(write::WRITELN_EMPTY_STRING),
+    LintId::of(write::WRITE_LITERAL),
+    LintId::of(write::WRITE_WITH_NEWLINE),
+    LintId::of(zero_div_zero::ZERO_DIVIDED_BY_ZERO),
+])
diff --git a/clippy_lints/src/lib.register_cargo.rs b/clippy_lints/src/lib.register_cargo.rs
index 21d070728e4..1809f2cc7d4 100644
--- a/clippy_lints/src/lib.register_cargo.rs
+++ b/clippy_lints/src/lib.register_cargo.rs
@@ -3,9 +3,9 @@
 // Manual edits will be overwritten.
 
 store.register_group(true, "clippy::cargo", Some("clippy_cargo"), vec![
-LintId::of(cargo_common_metadata::CARGO_COMMON_METADATA),
-LintId::of(feature_name::NEGATIVE_FEATURE_NAMES),
-LintId::of(feature_name::REDUNDANT_FEATURE_NAMES),
-LintId::of(multiple_crate_versions::MULTIPLE_CRATE_VERSIONS),
-LintId::of(wildcard_dependencies::WILDCARD_DEPENDENCIES),
-])
\ No newline at end of file
+    LintId::of(cargo_common_metadata::CARGO_COMMON_METADATA),
+    LintId::of(feature_name::NEGATIVE_FEATURE_NAMES),
+    LintId::of(feature_name::REDUNDANT_FEATURE_NAMES),
+    LintId::of(multiple_crate_versions::MULTIPLE_CRATE_VERSIONS),
+    LintId::of(wildcard_dependencies::WILDCARD_DEPENDENCIES),
+])
diff --git a/clippy_lints/src/lib.register_complexity.rs b/clippy_lints/src/lib.register_complexity.rs
index 515afe54c86..64b82fc0faa 100644
--- a/clippy_lints/src/lib.register_complexity.rs
+++ b/clippy_lints/src/lib.register_complexity.rs
@@ -3,92 +3,92 @@
 // Manual edits will be overwritten.
 
 store.register_group(true, "clippy::complexity", Some("clippy_complexity"), vec![
-LintId::of(attrs::DEPRECATED_CFG_ATTR),
-LintId::of(booleans::NONMINIMAL_BOOL),
-LintId::of(casts::CHAR_LIT_AS_U8),
-LintId::of(casts::UNNECESSARY_CAST),
-LintId::of(derivable_impls::DERIVABLE_IMPLS),
-LintId::of(double_comparison::DOUBLE_COMPARISONS),
-LintId::of(double_parens::DOUBLE_PARENS),
-LintId::of(duration_subsec::DURATION_SUBSEC),
-LintId::of(eval_order_dependence::DIVERGING_SUB_EXPRESSION),
-LintId::of(explicit_write::EXPLICIT_WRITE),
-LintId::of(format::USELESS_FORMAT),
-LintId::of(functions::TOO_MANY_ARGUMENTS),
-LintId::of(get_last_with_len::GET_LAST_WITH_LEN),
-LintId::of(identity_op::IDENTITY_OP),
-LintId::of(int_plus_one::INT_PLUS_ONE),
-LintId::of(lifetimes::EXTRA_UNUSED_LIFETIMES),
-LintId::of(lifetimes::NEEDLESS_LIFETIMES),
-LintId::of(loops::EXPLICIT_COUNTER_LOOP),
-LintId::of(loops::MANUAL_FLATTEN),
-LintId::of(loops::SINGLE_ELEMENT_LOOP),
-LintId::of(loops::WHILE_LET_LOOP),
-LintId::of(manual_strip::MANUAL_STRIP),
-LintId::of(manual_unwrap_or::MANUAL_UNWRAP_OR),
-LintId::of(map_unit_fn::OPTION_MAP_UNIT_FN),
-LintId::of(map_unit_fn::RESULT_MAP_UNIT_FN),
-LintId::of(matches::MATCH_AS_REF),
-LintId::of(matches::MATCH_SINGLE_BINDING),
-LintId::of(matches::WILDCARD_IN_OR_PATTERNS),
-LintId::of(methods::BIND_INSTEAD_OF_MAP),
-LintId::of(methods::CLONE_ON_COPY),
-LintId::of(methods::FILTER_MAP_IDENTITY),
-LintId::of(methods::FILTER_NEXT),
-LintId::of(methods::FLAT_MAP_IDENTITY),
-LintId::of(methods::INSPECT_FOR_EACH),
-LintId::of(methods::ITER_COUNT),
-LintId::of(methods::MANUAL_FILTER_MAP),
-LintId::of(methods::MANUAL_FIND_MAP),
-LintId::of(methods::MANUAL_SPLIT_ONCE),
-LintId::of(methods::MAP_IDENTITY),
-LintId::of(methods::OPTION_AS_REF_DEREF),
-LintId::of(methods::OPTION_FILTER_MAP),
-LintId::of(methods::SEARCH_IS_SOME),
-LintId::of(methods::SKIP_WHILE_NEXT),
-LintId::of(methods::UNNECESSARY_FILTER_MAP),
-LintId::of(methods::USELESS_ASREF),
-LintId::of(misc::SHORT_CIRCUIT_STATEMENT),
-LintId::of(misc_early::UNNEEDED_WILDCARD_PATTERN),
-LintId::of(misc_early::ZERO_PREFIXED_LITERAL),
-LintId::of(needless_arbitrary_self_type::NEEDLESS_ARBITRARY_SELF_TYPE),
-LintId::of(needless_bool::BOOL_COMPARISON),
-LintId::of(needless_bool::NEEDLESS_BOOL),
-LintId::of(needless_borrowed_ref::NEEDLESS_BORROWED_REFERENCE),
-LintId::of(needless_option_as_deref::NEEDLESS_OPTION_AS_DEREF),
-LintId::of(needless_question_mark::NEEDLESS_QUESTION_MARK),
-LintId::of(needless_update::NEEDLESS_UPDATE),
-LintId::of(neg_cmp_op_on_partial_ord::NEG_CMP_OP_ON_PARTIAL_ORD),
-LintId::of(no_effect::NO_EFFECT),
-LintId::of(no_effect::UNNECESSARY_OPERATION),
-LintId::of(overflow_check_conditional::OVERFLOW_CHECK_CONDITIONAL),
-LintId::of(partialeq_ne_impl::PARTIALEQ_NE_IMPL),
-LintId::of(precedence::PRECEDENCE),
-LintId::of(ptr_offset_with_cast::PTR_OFFSET_WITH_CAST),
-LintId::of(ranges::RANGE_ZIP_WITH_LEN),
-LintId::of(redundant_closure_call::REDUNDANT_CLOSURE_CALL),
-LintId::of(redundant_slicing::REDUNDANT_SLICING),
-LintId::of(reference::DEREF_ADDROF),
-LintId::of(reference::REF_IN_DEREF),
-LintId::of(repeat_once::REPEAT_ONCE),
-LintId::of(strings::STRING_FROM_UTF8_AS_BYTES),
-LintId::of(strlen_on_c_strings::STRLEN_ON_C_STRINGS),
-LintId::of(swap::MANUAL_SWAP),
-LintId::of(temporary_assignment::TEMPORARY_ASSIGNMENT),
-LintId::of(transmute::CROSSPOINTER_TRANSMUTE),
-LintId::of(transmute::TRANSMUTES_EXPRESSIBLE_AS_PTR_CASTS),
-LintId::of(transmute::TRANSMUTE_BYTES_TO_STR),
-LintId::of(transmute::TRANSMUTE_FLOAT_TO_INT),
-LintId::of(transmute::TRANSMUTE_INT_TO_BOOL),
-LintId::of(transmute::TRANSMUTE_INT_TO_CHAR),
-LintId::of(transmute::TRANSMUTE_INT_TO_FLOAT),
-LintId::of(transmute::TRANSMUTE_PTR_TO_REF),
-LintId::of(types::BORROWED_BOX),
-LintId::of(types::TYPE_COMPLEXITY),
-LintId::of(types::VEC_BOX),
-LintId::of(unit_types::UNIT_ARG),
-LintId::of(unnecessary_sort_by::UNNECESSARY_SORT_BY),
-LintId::of(unwrap::UNNECESSARY_UNWRAP),
-LintId::of(useless_conversion::USELESS_CONVERSION),
-LintId::of(zero_div_zero::ZERO_DIVIDED_BY_ZERO),
-])
\ No newline at end of file
+    LintId::of(attrs::DEPRECATED_CFG_ATTR),
+    LintId::of(booleans::NONMINIMAL_BOOL),
+    LintId::of(casts::CHAR_LIT_AS_U8),
+    LintId::of(casts::UNNECESSARY_CAST),
+    LintId::of(derivable_impls::DERIVABLE_IMPLS),
+    LintId::of(double_comparison::DOUBLE_COMPARISONS),
+    LintId::of(double_parens::DOUBLE_PARENS),
+    LintId::of(duration_subsec::DURATION_SUBSEC),
+    LintId::of(eval_order_dependence::DIVERGING_SUB_EXPRESSION),
+    LintId::of(explicit_write::EXPLICIT_WRITE),
+    LintId::of(format::USELESS_FORMAT),
+    LintId::of(functions::TOO_MANY_ARGUMENTS),
+    LintId::of(get_last_with_len::GET_LAST_WITH_LEN),
+    LintId::of(identity_op::IDENTITY_OP),
+    LintId::of(int_plus_one::INT_PLUS_ONE),
+    LintId::of(lifetimes::EXTRA_UNUSED_LIFETIMES),
+    LintId::of(lifetimes::NEEDLESS_LIFETIMES),
+    LintId::of(loops::EXPLICIT_COUNTER_LOOP),
+    LintId::of(loops::MANUAL_FLATTEN),
+    LintId::of(loops::SINGLE_ELEMENT_LOOP),
+    LintId::of(loops::WHILE_LET_LOOP),
+    LintId::of(manual_strip::MANUAL_STRIP),
+    LintId::of(manual_unwrap_or::MANUAL_UNWRAP_OR),
+    LintId::of(map_unit_fn::OPTION_MAP_UNIT_FN),
+    LintId::of(map_unit_fn::RESULT_MAP_UNIT_FN),
+    LintId::of(matches::MATCH_AS_REF),
+    LintId::of(matches::MATCH_SINGLE_BINDING),
+    LintId::of(matches::WILDCARD_IN_OR_PATTERNS),
+    LintId::of(methods::BIND_INSTEAD_OF_MAP),
+    LintId::of(methods::CLONE_ON_COPY),
+    LintId::of(methods::FILTER_MAP_IDENTITY),
+    LintId::of(methods::FILTER_NEXT),
+    LintId::of(methods::FLAT_MAP_IDENTITY),
+    LintId::of(methods::INSPECT_FOR_EACH),
+    LintId::of(methods::ITER_COUNT),
+    LintId::of(methods::MANUAL_FILTER_MAP),
+    LintId::of(methods::MANUAL_FIND_MAP),
+    LintId::of(methods::MANUAL_SPLIT_ONCE),
+    LintId::of(methods::MAP_IDENTITY),
+    LintId::of(methods::OPTION_AS_REF_DEREF),
+    LintId::of(methods::OPTION_FILTER_MAP),
+    LintId::of(methods::SEARCH_IS_SOME),
+    LintId::of(methods::SKIP_WHILE_NEXT),
+    LintId::of(methods::UNNECESSARY_FILTER_MAP),
+    LintId::of(methods::USELESS_ASREF),
+    LintId::of(misc::SHORT_CIRCUIT_STATEMENT),
+    LintId::of(misc_early::UNNEEDED_WILDCARD_PATTERN),
+    LintId::of(misc_early::ZERO_PREFIXED_LITERAL),
+    LintId::of(needless_arbitrary_self_type::NEEDLESS_ARBITRARY_SELF_TYPE),
+    LintId::of(needless_bool::BOOL_COMPARISON),
+    LintId::of(needless_bool::NEEDLESS_BOOL),
+    LintId::of(needless_borrowed_ref::NEEDLESS_BORROWED_REFERENCE),
+    LintId::of(needless_option_as_deref::NEEDLESS_OPTION_AS_DEREF),
+    LintId::of(needless_question_mark::NEEDLESS_QUESTION_MARK),
+    LintId::of(needless_update::NEEDLESS_UPDATE),
+    LintId::of(neg_cmp_op_on_partial_ord::NEG_CMP_OP_ON_PARTIAL_ORD),
+    LintId::of(no_effect::NO_EFFECT),
+    LintId::of(no_effect::UNNECESSARY_OPERATION),
+    LintId::of(overflow_check_conditional::OVERFLOW_CHECK_CONDITIONAL),
+    LintId::of(partialeq_ne_impl::PARTIALEQ_NE_IMPL),
+    LintId::of(precedence::PRECEDENCE),
+    LintId::of(ptr_offset_with_cast::PTR_OFFSET_WITH_CAST),
+    LintId::of(ranges::RANGE_ZIP_WITH_LEN),
+    LintId::of(redundant_closure_call::REDUNDANT_CLOSURE_CALL),
+    LintId::of(redundant_slicing::REDUNDANT_SLICING),
+    LintId::of(reference::DEREF_ADDROF),
+    LintId::of(reference::REF_IN_DEREF),
+    LintId::of(repeat_once::REPEAT_ONCE),
+    LintId::of(strings::STRING_FROM_UTF8_AS_BYTES),
+    LintId::of(strlen_on_c_strings::STRLEN_ON_C_STRINGS),
+    LintId::of(swap::MANUAL_SWAP),
+    LintId::of(temporary_assignment::TEMPORARY_ASSIGNMENT),
+    LintId::of(transmute::CROSSPOINTER_TRANSMUTE),
+    LintId::of(transmute::TRANSMUTES_EXPRESSIBLE_AS_PTR_CASTS),
+    LintId::of(transmute::TRANSMUTE_BYTES_TO_STR),
+    LintId::of(transmute::TRANSMUTE_FLOAT_TO_INT),
+    LintId::of(transmute::TRANSMUTE_INT_TO_BOOL),
+    LintId::of(transmute::TRANSMUTE_INT_TO_CHAR),
+    LintId::of(transmute::TRANSMUTE_INT_TO_FLOAT),
+    LintId::of(transmute::TRANSMUTE_PTR_TO_REF),
+    LintId::of(types::BORROWED_BOX),
+    LintId::of(types::TYPE_COMPLEXITY),
+    LintId::of(types::VEC_BOX),
+    LintId::of(unit_types::UNIT_ARG),
+    LintId::of(unnecessary_sort_by::UNNECESSARY_SORT_BY),
+    LintId::of(unwrap::UNNECESSARY_UNWRAP),
+    LintId::of(useless_conversion::USELESS_CONVERSION),
+    LintId::of(zero_div_zero::ZERO_DIVIDED_BY_ZERO),
+])
diff --git a/clippy_lints/src/lib.register_correctness.rs b/clippy_lints/src/lib.register_correctness.rs
index ef42f930a96..e0ef7b3b8af 100644
--- a/clippy_lints/src/lib.register_correctness.rs
+++ b/clippy_lints/src/lib.register_correctness.rs
@@ -3,71 +3,71 @@
 // Manual edits will be overwritten.
 
 store.register_group(true, "clippy::correctness", Some("clippy_correctness"), vec![
-LintId::of(absurd_extreme_comparisons::ABSURD_EXTREME_COMPARISONS),
-LintId::of(approx_const::APPROX_CONSTANT),
-LintId::of(async_yields_async::ASYNC_YIELDS_ASYNC),
-LintId::of(attrs::DEPRECATED_SEMVER),
-LintId::of(attrs::MISMATCHED_TARGET_OS),
-LintId::of(attrs::USELESS_ATTRIBUTE),
-LintId::of(bit_mask::BAD_BIT_MASK),
-LintId::of(bit_mask::INEFFECTIVE_BIT_MASK),
-LintId::of(booleans::LOGIC_BUG),
-LintId::of(casts::CAST_REF_TO_MUT),
-LintId::of(copies::IFS_SAME_COND),
-LintId::of(copies::IF_SAME_THEN_ELSE),
-LintId::of(derive::DERIVE_HASH_XOR_EQ),
-LintId::of(derive::DERIVE_ORD_XOR_PARTIAL_ORD),
-LintId::of(drop_forget_ref::DROP_COPY),
-LintId::of(drop_forget_ref::DROP_REF),
-LintId::of(drop_forget_ref::FORGET_COPY),
-LintId::of(drop_forget_ref::FORGET_REF),
-LintId::of(enum_clike::ENUM_CLIKE_UNPORTABLE_VARIANT),
-LintId::of(eq_op::EQ_OP),
-LintId::of(erasing_op::ERASING_OP),
-LintId::of(formatting::POSSIBLE_MISSING_COMMA),
-LintId::of(functions::NOT_UNSAFE_PTR_ARG_DEREF),
-LintId::of(if_let_mutex::IF_LET_MUTEX),
-LintId::of(indexing_slicing::OUT_OF_BOUNDS_INDEXING),
-LintId::of(infinite_iter::INFINITE_ITER),
-LintId::of(inherent_to_string::INHERENT_TO_STRING_SHADOW_DISPLAY),
-LintId::of(inline_fn_without_body::INLINE_FN_WITHOUT_BODY),
-LintId::of(let_underscore::LET_UNDERSCORE_LOCK),
-LintId::of(literal_representation::MISTYPED_LITERAL_SUFFIXES),
-LintId::of(loops::ITER_NEXT_LOOP),
-LintId::of(loops::NEVER_LOOP),
-LintId::of(loops::WHILE_IMMUTABLE_CONDITION),
-LintId::of(mem_discriminant::MEM_DISCRIMINANT_NON_ENUM),
-LintId::of(mem_replace::MEM_REPLACE_WITH_UNINIT),
-LintId::of(methods::CLONE_DOUBLE_REF),
-LintId::of(methods::ITERATOR_STEP_BY_ZERO),
-LintId::of(methods::SUSPICIOUS_SPLITN),
-LintId::of(methods::UNINIT_ASSUMED_INIT),
-LintId::of(methods::ZST_OFFSET),
-LintId::of(minmax::MIN_MAX),
-LintId::of(misc::CMP_NAN),
-LintId::of(misc::MODULO_ONE),
-LintId::of(non_octal_unix_permissions::NON_OCTAL_UNIX_PERMISSIONS),
-LintId::of(open_options::NONSENSICAL_OPEN_OPTIONS),
-LintId::of(option_env_unwrap::OPTION_ENV_UNWRAP),
-LintId::of(ptr::INVALID_NULL_PTR_USAGE),
-LintId::of(ptr::MUT_FROM_REF),
-LintId::of(ranges::REVERSED_EMPTY_RANGES),
-LintId::of(regex::INVALID_REGEX),
-LintId::of(self_assignment::SELF_ASSIGNMENT),
-LintId::of(serde_api::SERDE_API_MISUSE),
-LintId::of(size_of_in_element_count::SIZE_OF_IN_ELEMENT_COUNT),
-LintId::of(swap::ALMOST_SWAPPED),
-LintId::of(to_string_in_display::TO_STRING_IN_DISPLAY),
-LintId::of(transmute::UNSOUND_COLLECTION_TRANSMUTE),
-LintId::of(transmute::WRONG_TRANSMUTE),
-LintId::of(transmuting_null::TRANSMUTING_NULL),
-LintId::of(undropped_manually_drops::UNDROPPED_MANUALLY_DROPS),
-LintId::of(unicode::INVISIBLE_CHARACTERS),
-LintId::of(unit_return_expecting_ord::UNIT_RETURN_EXPECTING_ORD),
-LintId::of(unit_types::UNIT_CMP),
-LintId::of(unnamed_address::FN_ADDRESS_COMPARISONS),
-LintId::of(unnamed_address::VTABLE_ADDRESS_COMPARISONS),
-LintId::of(unused_io_amount::UNUSED_IO_AMOUNT),
-LintId::of(unwrap::PANICKING_UNWRAP),
-LintId::of(vec_resize_to_zero::VEC_RESIZE_TO_ZERO),
-])
\ No newline at end of file
+    LintId::of(absurd_extreme_comparisons::ABSURD_EXTREME_COMPARISONS),
+    LintId::of(approx_const::APPROX_CONSTANT),
+    LintId::of(async_yields_async::ASYNC_YIELDS_ASYNC),
+    LintId::of(attrs::DEPRECATED_SEMVER),
+    LintId::of(attrs::MISMATCHED_TARGET_OS),
+    LintId::of(attrs::USELESS_ATTRIBUTE),
+    LintId::of(bit_mask::BAD_BIT_MASK),
+    LintId::of(bit_mask::INEFFECTIVE_BIT_MASK),
+    LintId::of(booleans::LOGIC_BUG),
+    LintId::of(casts::CAST_REF_TO_MUT),
+    LintId::of(copies::IFS_SAME_COND),
+    LintId::of(copies::IF_SAME_THEN_ELSE),
+    LintId::of(derive::DERIVE_HASH_XOR_EQ),
+    LintId::of(derive::DERIVE_ORD_XOR_PARTIAL_ORD),
+    LintId::of(drop_forget_ref::DROP_COPY),
+    LintId::of(drop_forget_ref::DROP_REF),
+    LintId::of(drop_forget_ref::FORGET_COPY),
+    LintId::of(drop_forget_ref::FORGET_REF),
+    LintId::of(enum_clike::ENUM_CLIKE_UNPORTABLE_VARIANT),
+    LintId::of(eq_op::EQ_OP),
+    LintId::of(erasing_op::ERASING_OP),
+    LintId::of(formatting::POSSIBLE_MISSING_COMMA),
+    LintId::of(functions::NOT_UNSAFE_PTR_ARG_DEREF),
+    LintId::of(if_let_mutex::IF_LET_MUTEX),
+    LintId::of(indexing_slicing::OUT_OF_BOUNDS_INDEXING),
+    LintId::of(infinite_iter::INFINITE_ITER),
+    LintId::of(inherent_to_string::INHERENT_TO_STRING_SHADOW_DISPLAY),
+    LintId::of(inline_fn_without_body::INLINE_FN_WITHOUT_BODY),
+    LintId::of(let_underscore::LET_UNDERSCORE_LOCK),
+    LintId::of(literal_representation::MISTYPED_LITERAL_SUFFIXES),
+    LintId::of(loops::ITER_NEXT_LOOP),
+    LintId::of(loops::NEVER_LOOP),
+    LintId::of(loops::WHILE_IMMUTABLE_CONDITION),
+    LintId::of(mem_discriminant::MEM_DISCRIMINANT_NON_ENUM),
+    LintId::of(mem_replace::MEM_REPLACE_WITH_UNINIT),
+    LintId::of(methods::CLONE_DOUBLE_REF),
+    LintId::of(methods::ITERATOR_STEP_BY_ZERO),
+    LintId::of(methods::SUSPICIOUS_SPLITN),
+    LintId::of(methods::UNINIT_ASSUMED_INIT),
+    LintId::of(methods::ZST_OFFSET),
+    LintId::of(minmax::MIN_MAX),
+    LintId::of(misc::CMP_NAN),
+    LintId::of(misc::MODULO_ONE),
+    LintId::of(non_octal_unix_permissions::NON_OCTAL_UNIX_PERMISSIONS),
+    LintId::of(open_options::NONSENSICAL_OPEN_OPTIONS),
+    LintId::of(option_env_unwrap::OPTION_ENV_UNWRAP),
+    LintId::of(ptr::INVALID_NULL_PTR_USAGE),
+    LintId::of(ptr::MUT_FROM_REF),
+    LintId::of(ranges::REVERSED_EMPTY_RANGES),
+    LintId::of(regex::INVALID_REGEX),
+    LintId::of(self_assignment::SELF_ASSIGNMENT),
+    LintId::of(serde_api::SERDE_API_MISUSE),
+    LintId::of(size_of_in_element_count::SIZE_OF_IN_ELEMENT_COUNT),
+    LintId::of(swap::ALMOST_SWAPPED),
+    LintId::of(to_string_in_display::TO_STRING_IN_DISPLAY),
+    LintId::of(transmute::UNSOUND_COLLECTION_TRANSMUTE),
+    LintId::of(transmute::WRONG_TRANSMUTE),
+    LintId::of(transmuting_null::TRANSMUTING_NULL),
+    LintId::of(undropped_manually_drops::UNDROPPED_MANUALLY_DROPS),
+    LintId::of(unicode::INVISIBLE_CHARACTERS),
+    LintId::of(unit_return_expecting_ord::UNIT_RETURN_EXPECTING_ORD),
+    LintId::of(unit_types::UNIT_CMP),
+    LintId::of(unnamed_address::FN_ADDRESS_COMPARISONS),
+    LintId::of(unnamed_address::VTABLE_ADDRESS_COMPARISONS),
+    LintId::of(unused_io_amount::UNUSED_IO_AMOUNT),
+    LintId::of(unwrap::PANICKING_UNWRAP),
+    LintId::of(vec_resize_to_zero::VEC_RESIZE_TO_ZERO),
+])
diff --git a/clippy_lints/src/lib.register_internal.rs b/clippy_lints/src/lib.register_internal.rs
index 7d43e2196cd..c8c1e0262ab 100644
--- a/clippy_lints/src/lib.register_internal.rs
+++ b/clippy_lints/src/lib.register_internal.rs
@@ -3,16 +3,16 @@
 // Manual edits will be overwritten.
 
 store.register_group(true, "clippy::internal", Some("clippy_internal"), vec![
-LintId::of(utils::internal_lints::CLIPPY_LINTS_INTERNAL),
-LintId::of(utils::internal_lints::COLLAPSIBLE_SPAN_LINT_CALLS),
-LintId::of(utils::internal_lints::COMPILER_LINT_FUNCTIONS),
-LintId::of(utils::internal_lints::DEFAULT_LINT),
-LintId::of(utils::internal_lints::IF_CHAIN_STYLE),
-LintId::of(utils::internal_lints::INTERNING_DEFINED_SYMBOL),
-LintId::of(utils::internal_lints::INVALID_PATHS),
-LintId::of(utils::internal_lints::LINT_WITHOUT_LINT_PASS),
-LintId::of(utils::internal_lints::MATCH_TYPE_ON_DIAGNOSTIC_ITEM),
-LintId::of(utils::internal_lints::OUTER_EXPN_EXPN_DATA),
-LintId::of(utils::internal_lints::PRODUCE_ICE),
-LintId::of(utils::internal_lints::UNNECESSARY_SYMBOL_STR),
-])
\ No newline at end of file
+    LintId::of(utils::internal_lints::CLIPPY_LINTS_INTERNAL),
+    LintId::of(utils::internal_lints::COLLAPSIBLE_SPAN_LINT_CALLS),
+    LintId::of(utils::internal_lints::COMPILER_LINT_FUNCTIONS),
+    LintId::of(utils::internal_lints::DEFAULT_LINT),
+    LintId::of(utils::internal_lints::IF_CHAIN_STYLE),
+    LintId::of(utils::internal_lints::INTERNING_DEFINED_SYMBOL),
+    LintId::of(utils::internal_lints::INVALID_PATHS),
+    LintId::of(utils::internal_lints::LINT_WITHOUT_LINT_PASS),
+    LintId::of(utils::internal_lints::MATCH_TYPE_ON_DIAGNOSTIC_ITEM),
+    LintId::of(utils::internal_lints::OUTER_EXPN_EXPN_DATA),
+    LintId::of(utils::internal_lints::PRODUCE_ICE),
+    LintId::of(utils::internal_lints::UNNECESSARY_SYMBOL_STR),
+])
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index ed0de60c284..1ad27870b1a 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -2,507 +2,507 @@
 // Use that command to update this file and do not edit by hand.
 // Manual edits will be overwritten.
 
-    store.register_lints(&[
-        #[cfg(feature = "internal-lints")]
-        utils::internal_lints::CLIPPY_LINTS_INTERNAL,
-        #[cfg(feature = "internal-lints")]
-        utils::internal_lints::COLLAPSIBLE_SPAN_LINT_CALLS,
-        #[cfg(feature = "internal-lints")]
-        utils::internal_lints::COMPILER_LINT_FUNCTIONS,
-        #[cfg(feature = "internal-lints")]
-        utils::internal_lints::DEFAULT_LINT,
-        #[cfg(feature = "internal-lints")]
-        utils::internal_lints::IF_CHAIN_STYLE,
-        #[cfg(feature = "internal-lints")]
-        utils::internal_lints::INTERNING_DEFINED_SYMBOL,
-        #[cfg(feature = "internal-lints")]
-        utils::internal_lints::INVALID_PATHS,
-        #[cfg(feature = "internal-lints")]
-        utils::internal_lints::LINT_WITHOUT_LINT_PASS,
-        #[cfg(feature = "internal-lints")]
-        utils::internal_lints::MATCH_TYPE_ON_DIAGNOSTIC_ITEM,
-        #[cfg(feature = "internal-lints")]
-        utils::internal_lints::OUTER_EXPN_EXPN_DATA,
-        #[cfg(feature = "internal-lints")]
-        utils::internal_lints::PRODUCE_ICE,
-        #[cfg(feature = "internal-lints")]
-        utils::internal_lints::UNNECESSARY_SYMBOL_STR,
-        absurd_extreme_comparisons::ABSURD_EXTREME_COMPARISONS,
-        approx_const::APPROX_CONSTANT,
-        arithmetic::FLOAT_ARITHMETIC,
-        arithmetic::INTEGER_ARITHMETIC,
-        as_conversions::AS_CONVERSIONS,
-        asm_syntax::INLINE_ASM_X86_ATT_SYNTAX,
-        asm_syntax::INLINE_ASM_X86_INTEL_SYNTAX,
-        assertions_on_constants::ASSERTIONS_ON_CONSTANTS,
-        assign_ops::ASSIGN_OP_PATTERN,
-        assign_ops::MISREFACTORED_ASSIGN_OP,
-        async_yields_async::ASYNC_YIELDS_ASYNC,
-        attrs::BLANKET_CLIPPY_RESTRICTION_LINTS,
-        attrs::DEPRECATED_CFG_ATTR,
-        attrs::DEPRECATED_SEMVER,
-        attrs::EMPTY_LINE_AFTER_OUTER_ATTR,
-        attrs::INLINE_ALWAYS,
-        attrs::MISMATCHED_TARGET_OS,
-        attrs::USELESS_ATTRIBUTE,
-        await_holding_invalid::AWAIT_HOLDING_LOCK,
-        await_holding_invalid::AWAIT_HOLDING_REFCELL_REF,
-        bit_mask::BAD_BIT_MASK,
-        bit_mask::INEFFECTIVE_BIT_MASK,
-        bit_mask::VERBOSE_BIT_MASK,
-        blacklisted_name::BLACKLISTED_NAME,
-        blocks_in_if_conditions::BLOCKS_IN_IF_CONDITIONS,
-        bool_assert_comparison::BOOL_ASSERT_COMPARISON,
-        booleans::LOGIC_BUG,
-        booleans::NONMINIMAL_BOOL,
-        bytecount::NAIVE_BYTECOUNT,
-        cargo_common_metadata::CARGO_COMMON_METADATA,
-        case_sensitive_file_extension_comparisons::CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS,
-        casts::CAST_LOSSLESS,
-        casts::CAST_POSSIBLE_TRUNCATION,
-        casts::CAST_POSSIBLE_WRAP,
-        casts::CAST_PRECISION_LOSS,
-        casts::CAST_PTR_ALIGNMENT,
-        casts::CAST_REF_TO_MUT,
-        casts::CAST_SIGN_LOSS,
-        casts::CHAR_LIT_AS_U8,
-        casts::FN_TO_NUMERIC_CAST,
-        casts::FN_TO_NUMERIC_CAST_WITH_TRUNCATION,
-        casts::PTR_AS_PTR,
-        casts::UNNECESSARY_CAST,
-        checked_conversions::CHECKED_CONVERSIONS,
-        cognitive_complexity::COGNITIVE_COMPLEXITY,
-        collapsible_if::COLLAPSIBLE_ELSE_IF,
-        collapsible_if::COLLAPSIBLE_IF,
-        collapsible_match::COLLAPSIBLE_MATCH,
-        comparison_chain::COMPARISON_CHAIN,
-        copies::BRANCHES_SHARING_CODE,
-        copies::IFS_SAME_COND,
-        copies::IF_SAME_THEN_ELSE,
-        copies::SAME_FUNCTIONS_IN_IF_CONDITION,
-        copy_iterator::COPY_ITERATOR,
-        create_dir::CREATE_DIR,
-        dbg_macro::DBG_MACRO,
-        default::DEFAULT_TRAIT_ACCESS,
-        default::FIELD_REASSIGN_WITH_DEFAULT,
-        default_numeric_fallback::DEFAULT_NUMERIC_FALLBACK,
-        dereference::EXPLICIT_DEREF_METHODS,
-        derivable_impls::DERIVABLE_IMPLS,
-        derive::DERIVE_HASH_XOR_EQ,
-        derive::DERIVE_ORD_XOR_PARTIAL_ORD,
-        derive::EXPL_IMPL_CLONE_ON_COPY,
-        derive::UNSAFE_DERIVE_DESERIALIZE,
-        disallowed_method::DISALLOWED_METHOD,
-        disallowed_script_idents::DISALLOWED_SCRIPT_IDENTS,
-        disallowed_type::DISALLOWED_TYPE,
-        doc::DOC_MARKDOWN,
-        doc::MISSING_ERRORS_DOC,
-        doc::MISSING_PANICS_DOC,
-        doc::MISSING_SAFETY_DOC,
-        doc::NEEDLESS_DOCTEST_MAIN,
-        double_comparison::DOUBLE_COMPARISONS,
-        double_parens::DOUBLE_PARENS,
-        drop_forget_ref::DROP_COPY,
-        drop_forget_ref::DROP_REF,
-        drop_forget_ref::FORGET_COPY,
-        drop_forget_ref::FORGET_REF,
-        duration_subsec::DURATION_SUBSEC,
-        else_if_without_else::ELSE_IF_WITHOUT_ELSE,
-        empty_enum::EMPTY_ENUM,
-        entry::MAP_ENTRY,
-        enum_clike::ENUM_CLIKE_UNPORTABLE_VARIANT,
-        enum_variants::ENUM_VARIANT_NAMES,
-        enum_variants::MODULE_INCEPTION,
-        enum_variants::MODULE_NAME_REPETITIONS,
-        eq_op::EQ_OP,
-        eq_op::OP_REF,
-        erasing_op::ERASING_OP,
-        escape::BOXED_LOCAL,
-        eta_reduction::REDUNDANT_CLOSURE,
-        eta_reduction::REDUNDANT_CLOSURE_FOR_METHOD_CALLS,
-        eval_order_dependence::DIVERGING_SUB_EXPRESSION,
-        eval_order_dependence::EVAL_ORDER_DEPENDENCE,
-        excessive_bools::FN_PARAMS_EXCESSIVE_BOOLS,
-        excessive_bools::STRUCT_EXCESSIVE_BOOLS,
-        exhaustive_items::EXHAUSTIVE_ENUMS,
-        exhaustive_items::EXHAUSTIVE_STRUCTS,
-        exit::EXIT,
-        explicit_write::EXPLICIT_WRITE,
-        fallible_impl_from::FALLIBLE_IMPL_FROM,
-        feature_name::NEGATIVE_FEATURE_NAMES,
-        feature_name::REDUNDANT_FEATURE_NAMES,
-        float_equality_without_abs::FLOAT_EQUALITY_WITHOUT_ABS,
-        float_literal::EXCESSIVE_PRECISION,
-        float_literal::LOSSY_FLOAT_LITERAL,
-        floating_point_arithmetic::IMPRECISE_FLOPS,
-        floating_point_arithmetic::SUBOPTIMAL_FLOPS,
-        format::USELESS_FORMAT,
-        formatting::POSSIBLE_MISSING_COMMA,
-        formatting::SUSPICIOUS_ASSIGNMENT_FORMATTING,
-        formatting::SUSPICIOUS_ELSE_FORMATTING,
-        formatting::SUSPICIOUS_UNARY_OP_FORMATTING,
-        from_over_into::FROM_OVER_INTO,
-        from_str_radix_10::FROM_STR_RADIX_10,
-        functions::DOUBLE_MUST_USE,
-        functions::MUST_USE_CANDIDATE,
-        functions::MUST_USE_UNIT,
-        functions::NOT_UNSAFE_PTR_ARG_DEREF,
-        functions::RESULT_UNIT_ERR,
-        functions::TOO_MANY_ARGUMENTS,
-        functions::TOO_MANY_LINES,
-        future_not_send::FUTURE_NOT_SEND,
-        get_last_with_len::GET_LAST_WITH_LEN,
-        identity_op::IDENTITY_OP,
-        if_let_mutex::IF_LET_MUTEX,
-        if_not_else::IF_NOT_ELSE,
-        if_then_panic::IF_THEN_PANIC,
-        if_then_some_else_none::IF_THEN_SOME_ELSE_NONE,
-        implicit_hasher::IMPLICIT_HASHER,
-        implicit_return::IMPLICIT_RETURN,
-        implicit_saturating_sub::IMPLICIT_SATURATING_SUB,
-        inconsistent_struct_constructor::INCONSISTENT_STRUCT_CONSTRUCTOR,
-        indexing_slicing::INDEXING_SLICING,
-        indexing_slicing::OUT_OF_BOUNDS_INDEXING,
-        infinite_iter::INFINITE_ITER,
-        infinite_iter::MAYBE_INFINITE_ITER,
-        inherent_impl::MULTIPLE_INHERENT_IMPL,
-        inherent_to_string::INHERENT_TO_STRING,
-        inherent_to_string::INHERENT_TO_STRING_SHADOW_DISPLAY,
-        inline_fn_without_body::INLINE_FN_WITHOUT_BODY,
-        int_plus_one::INT_PLUS_ONE,
-        integer_division::INTEGER_DIVISION,
-        invalid_upcast_comparisons::INVALID_UPCAST_COMPARISONS,
-        items_after_statements::ITEMS_AFTER_STATEMENTS,
-        iter_not_returning_iterator::ITER_NOT_RETURNING_ITERATOR,
-        large_const_arrays::LARGE_CONST_ARRAYS,
-        large_enum_variant::LARGE_ENUM_VARIANT,
-        large_stack_arrays::LARGE_STACK_ARRAYS,
-        len_zero::COMPARISON_TO_EMPTY,
-        len_zero::LEN_WITHOUT_IS_EMPTY,
-        len_zero::LEN_ZERO,
-        let_if_seq::USELESS_LET_IF_SEQ,
-        let_underscore::LET_UNDERSCORE_DROP,
-        let_underscore::LET_UNDERSCORE_LOCK,
-        let_underscore::LET_UNDERSCORE_MUST_USE,
-        lifetimes::EXTRA_UNUSED_LIFETIMES,
-        lifetimes::NEEDLESS_LIFETIMES,
-        literal_representation::DECIMAL_LITERAL_REPRESENTATION,
-        literal_representation::INCONSISTENT_DIGIT_GROUPING,
-        literal_representation::LARGE_DIGIT_GROUPS,
-        literal_representation::MISTYPED_LITERAL_SUFFIXES,
-        literal_representation::UNREADABLE_LITERAL,
-        literal_representation::UNUSUAL_BYTE_GROUPINGS,
-        loops::EMPTY_LOOP,
-        loops::EXPLICIT_COUNTER_LOOP,
-        loops::EXPLICIT_INTO_ITER_LOOP,
-        loops::EXPLICIT_ITER_LOOP,
-        loops::FOR_KV_MAP,
-        loops::FOR_LOOPS_OVER_FALLIBLES,
-        loops::ITER_NEXT_LOOP,
-        loops::MANUAL_FLATTEN,
-        loops::MANUAL_MEMCPY,
-        loops::MUT_RANGE_BOUND,
-        loops::NEEDLESS_COLLECT,
-        loops::NEEDLESS_RANGE_LOOP,
-        loops::NEVER_LOOP,
-        loops::SAME_ITEM_PUSH,
-        loops::SINGLE_ELEMENT_LOOP,
-        loops::WHILE_IMMUTABLE_CONDITION,
-        loops::WHILE_LET_LOOP,
-        loops::WHILE_LET_ON_ITERATOR,
-        macro_use::MACRO_USE_IMPORTS,
-        main_recursion::MAIN_RECURSION,
-        manual_async_fn::MANUAL_ASYNC_FN,
-        manual_map::MANUAL_MAP,
-        manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE,
-        manual_ok_or::MANUAL_OK_OR,
-        manual_strip::MANUAL_STRIP,
-        manual_unwrap_or::MANUAL_UNWRAP_OR,
-        map_clone::MAP_CLONE,
-        map_err_ignore::MAP_ERR_IGNORE,
-        map_unit_fn::OPTION_MAP_UNIT_FN,
-        map_unit_fn::RESULT_MAP_UNIT_FN,
-        match_on_vec_items::MATCH_ON_VEC_ITEMS,
-        match_result_ok::MATCH_RESULT_OK,
-        matches::INFALLIBLE_DESTRUCTURING_MATCH,
-        matches::MATCH_AS_REF,
-        matches::MATCH_BOOL,
-        matches::MATCH_LIKE_MATCHES_MACRO,
-        matches::MATCH_OVERLAPPING_ARM,
-        matches::MATCH_REF_PATS,
-        matches::MATCH_SAME_ARMS,
-        matches::MATCH_SINGLE_BINDING,
-        matches::MATCH_WILDCARD_FOR_SINGLE_VARIANTS,
-        matches::MATCH_WILD_ERR_ARM,
-        matches::REDUNDANT_PATTERN_MATCHING,
-        matches::REST_PAT_IN_FULLY_BOUND_STRUCTS,
-        matches::SINGLE_MATCH,
-        matches::SINGLE_MATCH_ELSE,
-        matches::WILDCARD_ENUM_MATCH_ARM,
-        matches::WILDCARD_IN_OR_PATTERNS,
-        mem_discriminant::MEM_DISCRIMINANT_NON_ENUM,
-        mem_forget::MEM_FORGET,
-        mem_replace::MEM_REPLACE_OPTION_WITH_NONE,
-        mem_replace::MEM_REPLACE_WITH_DEFAULT,
-        mem_replace::MEM_REPLACE_WITH_UNINIT,
-        methods::BIND_INSTEAD_OF_MAP,
-        methods::BYTES_NTH,
-        methods::CHARS_LAST_CMP,
-        methods::CHARS_NEXT_CMP,
-        methods::CLONED_INSTEAD_OF_COPIED,
-        methods::CLONE_DOUBLE_REF,
-        methods::CLONE_ON_COPY,
-        methods::CLONE_ON_REF_PTR,
-        methods::EXPECT_FUN_CALL,
-        methods::EXPECT_USED,
-        methods::EXTEND_WITH_DRAIN,
-        methods::FILETYPE_IS_FILE,
-        methods::FILTER_MAP_IDENTITY,
-        methods::FILTER_MAP_NEXT,
-        methods::FILTER_NEXT,
-        methods::FLAT_MAP_IDENTITY,
-        methods::FLAT_MAP_OPTION,
-        methods::FROM_ITER_INSTEAD_OF_COLLECT,
-        methods::GET_UNWRAP,
-        methods::IMPLICIT_CLONE,
-        methods::INEFFICIENT_TO_STRING,
-        methods::INSPECT_FOR_EACH,
-        methods::INTO_ITER_ON_REF,
-        methods::ITERATOR_STEP_BY_ZERO,
-        methods::ITER_CLONED_COLLECT,
-        methods::ITER_COUNT,
-        methods::ITER_NEXT_SLICE,
-        methods::ITER_NTH,
-        methods::ITER_NTH_ZERO,
-        methods::ITER_SKIP_NEXT,
-        methods::MANUAL_FILTER_MAP,
-        methods::MANUAL_FIND_MAP,
-        methods::MANUAL_SATURATING_ARITHMETIC,
-        methods::MANUAL_SPLIT_ONCE,
-        methods::MANUAL_STR_REPEAT,
-        methods::MAP_COLLECT_RESULT_UNIT,
-        methods::MAP_FLATTEN,
-        methods::MAP_IDENTITY,
-        methods::MAP_UNWRAP_OR,
-        methods::NEW_RET_NO_SELF,
-        methods::OK_EXPECT,
-        methods::OPTION_AS_REF_DEREF,
-        methods::OPTION_FILTER_MAP,
-        methods::OPTION_MAP_OR_NONE,
-        methods::OR_FUN_CALL,
-        methods::RESULT_MAP_OR_INTO_OPTION,
-        methods::SEARCH_IS_SOME,
-        methods::SHOULD_IMPLEMENT_TRAIT,
-        methods::SINGLE_CHAR_ADD_STR,
-        methods::SINGLE_CHAR_PATTERN,
-        methods::SKIP_WHILE_NEXT,
-        methods::STRING_EXTEND_CHARS,
-        methods::SUSPICIOUS_MAP,
-        methods::SUSPICIOUS_SPLITN,
-        methods::UNINIT_ASSUMED_INIT,
-        methods::UNNECESSARY_FILTER_MAP,
-        methods::UNNECESSARY_FOLD,
-        methods::UNNECESSARY_LAZY_EVALUATIONS,
-        methods::UNWRAP_OR_ELSE_DEFAULT,
-        methods::UNWRAP_USED,
-        methods::USELESS_ASREF,
-        methods::WRONG_SELF_CONVENTION,
-        methods::ZST_OFFSET,
-        minmax::MIN_MAX,
-        misc::CMP_NAN,
-        misc::CMP_OWNED,
-        misc::FLOAT_CMP,
-        misc::FLOAT_CMP_CONST,
-        misc::MODULO_ONE,
-        misc::SHORT_CIRCUIT_STATEMENT,
-        misc::TOPLEVEL_REF_ARG,
-        misc::USED_UNDERSCORE_BINDING,
-        misc::ZERO_PTR,
-        misc_early::BUILTIN_TYPE_SHADOW,
-        misc_early::DOUBLE_NEG,
-        misc_early::DUPLICATE_UNDERSCORE_ARGUMENT,
-        misc_early::MIXED_CASE_HEX_LITERALS,
-        misc_early::REDUNDANT_PATTERN,
-        misc_early::UNNEEDED_FIELD_PATTERN,
-        misc_early::UNNEEDED_WILDCARD_PATTERN,
-        misc_early::UNSEPARATED_LITERAL_SUFFIX,
-        misc_early::ZERO_PREFIXED_LITERAL,
-        missing_const_for_fn::MISSING_CONST_FOR_FN,
-        missing_doc::MISSING_DOCS_IN_PRIVATE_ITEMS,
-        missing_enforced_import_rename::MISSING_ENFORCED_IMPORT_RENAMES,
-        missing_inline::MISSING_INLINE_IN_PUBLIC_ITEMS,
-        module_style::MOD_MODULE_FILES,
-        module_style::SELF_NAMED_MODULE_FILES,
-        modulo_arithmetic::MODULO_ARITHMETIC,
-        multiple_crate_versions::MULTIPLE_CRATE_VERSIONS,
-        mut_key::MUTABLE_KEY_TYPE,
-        mut_mut::MUT_MUT,
-        mut_mutex_lock::MUT_MUTEX_LOCK,
-        mut_reference::UNNECESSARY_MUT_PASSED,
-        mutable_debug_assertion::DEBUG_ASSERT_WITH_MUT_CALL,
-        mutex_atomic::MUTEX_ATOMIC,
-        mutex_atomic::MUTEX_INTEGER,
-        needless_arbitrary_self_type::NEEDLESS_ARBITRARY_SELF_TYPE,
-        needless_bitwise_bool::NEEDLESS_BITWISE_BOOL,
-        needless_bool::BOOL_COMPARISON,
-        needless_bool::NEEDLESS_BOOL,
-        needless_borrow::NEEDLESS_BORROW,
-        needless_borrow::REF_BINDING_TO_REFERENCE,
-        needless_borrowed_ref::NEEDLESS_BORROWED_REFERENCE,
-        needless_continue::NEEDLESS_CONTINUE,
-        needless_for_each::NEEDLESS_FOR_EACH,
-        needless_option_as_deref::NEEDLESS_OPTION_AS_DEREF,
-        needless_pass_by_value::NEEDLESS_PASS_BY_VALUE,
-        needless_question_mark::NEEDLESS_QUESTION_MARK,
-        needless_update::NEEDLESS_UPDATE,
-        neg_cmp_op_on_partial_ord::NEG_CMP_OP_ON_PARTIAL_ORD,
-        neg_multiply::NEG_MULTIPLY,
-        new_without_default::NEW_WITHOUT_DEFAULT,
-        no_effect::NO_EFFECT,
-        no_effect::UNNECESSARY_OPERATION,
-        non_copy_const::BORROW_INTERIOR_MUTABLE_CONST,
-        non_copy_const::DECLARE_INTERIOR_MUTABLE_CONST,
-        non_expressive_names::JUST_UNDERSCORES_AND_DIGITS,
-        non_expressive_names::MANY_SINGLE_CHAR_NAMES,
-        non_expressive_names::SIMILAR_NAMES,
-        non_octal_unix_permissions::NON_OCTAL_UNIX_PERMISSIONS,
-        nonstandard_macro_braces::NONSTANDARD_MACRO_BRACES,
-        open_options::NONSENSICAL_OPEN_OPTIONS,
-        option_env_unwrap::OPTION_ENV_UNWRAP,
-        option_if_let_else::OPTION_IF_LET_ELSE,
-        overflow_check_conditional::OVERFLOW_CHECK_CONDITIONAL,
-        panic_in_result_fn::PANIC_IN_RESULT_FN,
-        panic_unimplemented::PANIC,
-        panic_unimplemented::TODO,
-        panic_unimplemented::UNIMPLEMENTED,
-        panic_unimplemented::UNREACHABLE,
-        partialeq_ne_impl::PARTIALEQ_NE_IMPL,
-        pass_by_ref_or_value::LARGE_TYPES_PASSED_BY_VALUE,
-        pass_by_ref_or_value::TRIVIALLY_COPY_PASS_BY_REF,
-        path_buf_push_overwrite::PATH_BUF_PUSH_OVERWRITE,
-        pattern_type_mismatch::PATTERN_TYPE_MISMATCH,
-        precedence::PRECEDENCE,
-        ptr::CMP_NULL,
-        ptr::INVALID_NULL_PTR_USAGE,
-        ptr::MUT_FROM_REF,
-        ptr::PTR_ARG,
-        ptr_eq::PTR_EQ,
-        ptr_offset_with_cast::PTR_OFFSET_WITH_CAST,
-        question_mark::QUESTION_MARK,
-        ranges::MANUAL_RANGE_CONTAINS,
-        ranges::RANGE_MINUS_ONE,
-        ranges::RANGE_PLUS_ONE,
-        ranges::RANGE_ZIP_WITH_LEN,
-        ranges::REVERSED_EMPTY_RANGES,
-        redundant_clone::REDUNDANT_CLONE,
-        redundant_closure_call::REDUNDANT_CLOSURE_CALL,
-        redundant_else::REDUNDANT_ELSE,
-        redundant_field_names::REDUNDANT_FIELD_NAMES,
-        redundant_pub_crate::REDUNDANT_PUB_CRATE,
-        redundant_slicing::REDUNDANT_SLICING,
-        redundant_static_lifetimes::REDUNDANT_STATIC_LIFETIMES,
-        ref_option_ref::REF_OPTION_REF,
-        reference::DEREF_ADDROF,
-        reference::REF_IN_DEREF,
-        regex::INVALID_REGEX,
-        regex::TRIVIAL_REGEX,
-        repeat_once::REPEAT_ONCE,
-        returns::LET_AND_RETURN,
-        returns::NEEDLESS_RETURN,
-        same_name_method::SAME_NAME_METHOD,
-        self_assignment::SELF_ASSIGNMENT,
-        self_named_constructors::SELF_NAMED_CONSTRUCTORS,
-        semicolon_if_nothing_returned::SEMICOLON_IF_NOTHING_RETURNED,
-        serde_api::SERDE_API_MISUSE,
-        shadow::SHADOW_REUSE,
-        shadow::SHADOW_SAME,
-        shadow::SHADOW_UNRELATED,
-        single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS,
-        size_of_in_element_count::SIZE_OF_IN_ELEMENT_COUNT,
-        slow_vector_initialization::SLOW_VECTOR_INITIALIZATION,
-        stable_sort_primitive::STABLE_SORT_PRIMITIVE,
-        strings::STRING_ADD,
-        strings::STRING_ADD_ASSIGN,
-        strings::STRING_FROM_UTF8_AS_BYTES,
-        strings::STRING_LIT_AS_BYTES,
-        strings::STRING_TO_STRING,
-        strings::STR_TO_STRING,
-        strlen_on_c_strings::STRLEN_ON_C_STRINGS,
-        suspicious_operation_groupings::SUSPICIOUS_OPERATION_GROUPINGS,
-        suspicious_trait_impl::SUSPICIOUS_ARITHMETIC_IMPL,
-        suspicious_trait_impl::SUSPICIOUS_OP_ASSIGN_IMPL,
-        swap::ALMOST_SWAPPED,
-        swap::MANUAL_SWAP,
-        tabs_in_doc_comments::TABS_IN_DOC_COMMENTS,
-        temporary_assignment::TEMPORARY_ASSIGNMENT,
-        to_digit_is_some::TO_DIGIT_IS_SOME,
-        to_string_in_display::TO_STRING_IN_DISPLAY,
-        trait_bounds::TRAIT_DUPLICATION_IN_BOUNDS,
-        trait_bounds::TYPE_REPETITION_IN_BOUNDS,
-        transmute::CROSSPOINTER_TRANSMUTE,
-        transmute::TRANSMUTES_EXPRESSIBLE_AS_PTR_CASTS,
-        transmute::TRANSMUTE_BYTES_TO_STR,
-        transmute::TRANSMUTE_FLOAT_TO_INT,
-        transmute::TRANSMUTE_INT_TO_BOOL,
-        transmute::TRANSMUTE_INT_TO_CHAR,
-        transmute::TRANSMUTE_INT_TO_FLOAT,
-        transmute::TRANSMUTE_PTR_TO_PTR,
-        transmute::TRANSMUTE_PTR_TO_REF,
-        transmute::UNSOUND_COLLECTION_TRANSMUTE,
-        transmute::USELESS_TRANSMUTE,
-        transmute::WRONG_TRANSMUTE,
-        transmuting_null::TRANSMUTING_NULL,
-        try_err::TRY_ERR,
-        types::BORROWED_BOX,
-        types::BOX_COLLECTION,
-        types::LINKEDLIST,
-        types::OPTION_OPTION,
-        types::RC_BUFFER,
-        types::RC_MUTEX,
-        types::REDUNDANT_ALLOCATION,
-        types::TYPE_COMPLEXITY,
-        types::VEC_BOX,
-        undropped_manually_drops::UNDROPPED_MANUALLY_DROPS,
-        unicode::INVISIBLE_CHARACTERS,
-        unicode::NON_ASCII_LITERAL,
-        unicode::UNICODE_NOT_NFC,
-        unit_return_expecting_ord::UNIT_RETURN_EXPECTING_ORD,
-        unit_types::LET_UNIT_VALUE,
-        unit_types::UNIT_ARG,
-        unit_types::UNIT_CMP,
-        unnamed_address::FN_ADDRESS_COMPARISONS,
-        unnamed_address::VTABLE_ADDRESS_COMPARISONS,
-        unnecessary_self_imports::UNNECESSARY_SELF_IMPORTS,
-        unnecessary_sort_by::UNNECESSARY_SORT_BY,
-        unnecessary_wraps::UNNECESSARY_WRAPS,
-        unnested_or_patterns::UNNESTED_OR_PATTERNS,
-        unsafe_removed_from_name::UNSAFE_REMOVED_FROM_NAME,
-        unused_async::UNUSED_ASYNC,
-        unused_io_amount::UNUSED_IO_AMOUNT,
-        unused_self::UNUSED_SELF,
-        unused_unit::UNUSED_UNIT,
-        unwrap::PANICKING_UNWRAP,
-        unwrap::UNNECESSARY_UNWRAP,
-        unwrap_in_result::UNWRAP_IN_RESULT,
-        upper_case_acronyms::UPPER_CASE_ACRONYMS,
-        use_self::USE_SELF,
-        useless_conversion::USELESS_CONVERSION,
-        vec::USELESS_VEC,
-        vec_init_then_push::VEC_INIT_THEN_PUSH,
-        vec_resize_to_zero::VEC_RESIZE_TO_ZERO,
-        verbose_file_reads::VERBOSE_FILE_READS,
-        wildcard_dependencies::WILDCARD_DEPENDENCIES,
-        wildcard_imports::ENUM_GLOB_USE,
-        wildcard_imports::WILDCARD_IMPORTS,
-        write::PRINTLN_EMPTY_STRING,
-        write::PRINT_LITERAL,
-        write::PRINT_STDERR,
-        write::PRINT_STDOUT,
-        write::PRINT_WITH_NEWLINE,
-        write::USE_DEBUG,
-        write::WRITELN_EMPTY_STRING,
-        write::WRITE_LITERAL,
-        write::WRITE_WITH_NEWLINE,
-        zero_div_zero::ZERO_DIVIDED_BY_ZERO,
-        zero_sized_map_values::ZERO_SIZED_MAP_VALUES,
-    ])
\ No newline at end of file
+store.register_lints(&[
+    #[cfg(feature = "internal-lints")]
+    utils::internal_lints::CLIPPY_LINTS_INTERNAL,
+    #[cfg(feature = "internal-lints")]
+    utils::internal_lints::COLLAPSIBLE_SPAN_LINT_CALLS,
+    #[cfg(feature = "internal-lints")]
+    utils::internal_lints::COMPILER_LINT_FUNCTIONS,
+    #[cfg(feature = "internal-lints")]
+    utils::internal_lints::DEFAULT_LINT,
+    #[cfg(feature = "internal-lints")]
+    utils::internal_lints::IF_CHAIN_STYLE,
+    #[cfg(feature = "internal-lints")]
+    utils::internal_lints::INTERNING_DEFINED_SYMBOL,
+    #[cfg(feature = "internal-lints")]
+    utils::internal_lints::INVALID_PATHS,
+    #[cfg(feature = "internal-lints")]
+    utils::internal_lints::LINT_WITHOUT_LINT_PASS,
+    #[cfg(feature = "internal-lints")]
+    utils::internal_lints::MATCH_TYPE_ON_DIAGNOSTIC_ITEM,
+    #[cfg(feature = "internal-lints")]
+    utils::internal_lints::OUTER_EXPN_EXPN_DATA,
+    #[cfg(feature = "internal-lints")]
+    utils::internal_lints::PRODUCE_ICE,
+    #[cfg(feature = "internal-lints")]
+    utils::internal_lints::UNNECESSARY_SYMBOL_STR,
+    absurd_extreme_comparisons::ABSURD_EXTREME_COMPARISONS,
+    approx_const::APPROX_CONSTANT,
+    arithmetic::FLOAT_ARITHMETIC,
+    arithmetic::INTEGER_ARITHMETIC,
+    as_conversions::AS_CONVERSIONS,
+    asm_syntax::INLINE_ASM_X86_ATT_SYNTAX,
+    asm_syntax::INLINE_ASM_X86_INTEL_SYNTAX,
+    assertions_on_constants::ASSERTIONS_ON_CONSTANTS,
+    assign_ops::ASSIGN_OP_PATTERN,
+    assign_ops::MISREFACTORED_ASSIGN_OP,
+    async_yields_async::ASYNC_YIELDS_ASYNC,
+    attrs::BLANKET_CLIPPY_RESTRICTION_LINTS,
+    attrs::DEPRECATED_CFG_ATTR,
+    attrs::DEPRECATED_SEMVER,
+    attrs::EMPTY_LINE_AFTER_OUTER_ATTR,
+    attrs::INLINE_ALWAYS,
+    attrs::MISMATCHED_TARGET_OS,
+    attrs::USELESS_ATTRIBUTE,
+    await_holding_invalid::AWAIT_HOLDING_LOCK,
+    await_holding_invalid::AWAIT_HOLDING_REFCELL_REF,
+    bit_mask::BAD_BIT_MASK,
+    bit_mask::INEFFECTIVE_BIT_MASK,
+    bit_mask::VERBOSE_BIT_MASK,
+    blacklisted_name::BLACKLISTED_NAME,
+    blocks_in_if_conditions::BLOCKS_IN_IF_CONDITIONS,
+    bool_assert_comparison::BOOL_ASSERT_COMPARISON,
+    booleans::LOGIC_BUG,
+    booleans::NONMINIMAL_BOOL,
+    bytecount::NAIVE_BYTECOUNT,
+    cargo_common_metadata::CARGO_COMMON_METADATA,
+    case_sensitive_file_extension_comparisons::CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS,
+    casts::CAST_LOSSLESS,
+    casts::CAST_POSSIBLE_TRUNCATION,
+    casts::CAST_POSSIBLE_WRAP,
+    casts::CAST_PRECISION_LOSS,
+    casts::CAST_PTR_ALIGNMENT,
+    casts::CAST_REF_TO_MUT,
+    casts::CAST_SIGN_LOSS,
+    casts::CHAR_LIT_AS_U8,
+    casts::FN_TO_NUMERIC_CAST,
+    casts::FN_TO_NUMERIC_CAST_WITH_TRUNCATION,
+    casts::PTR_AS_PTR,
+    casts::UNNECESSARY_CAST,
+    checked_conversions::CHECKED_CONVERSIONS,
+    cognitive_complexity::COGNITIVE_COMPLEXITY,
+    collapsible_if::COLLAPSIBLE_ELSE_IF,
+    collapsible_if::COLLAPSIBLE_IF,
+    collapsible_match::COLLAPSIBLE_MATCH,
+    comparison_chain::COMPARISON_CHAIN,
+    copies::BRANCHES_SHARING_CODE,
+    copies::IFS_SAME_COND,
+    copies::IF_SAME_THEN_ELSE,
+    copies::SAME_FUNCTIONS_IN_IF_CONDITION,
+    copy_iterator::COPY_ITERATOR,
+    create_dir::CREATE_DIR,
+    dbg_macro::DBG_MACRO,
+    default::DEFAULT_TRAIT_ACCESS,
+    default::FIELD_REASSIGN_WITH_DEFAULT,
+    default_numeric_fallback::DEFAULT_NUMERIC_FALLBACK,
+    dereference::EXPLICIT_DEREF_METHODS,
+    derivable_impls::DERIVABLE_IMPLS,
+    derive::DERIVE_HASH_XOR_EQ,
+    derive::DERIVE_ORD_XOR_PARTIAL_ORD,
+    derive::EXPL_IMPL_CLONE_ON_COPY,
+    derive::UNSAFE_DERIVE_DESERIALIZE,
+    disallowed_method::DISALLOWED_METHOD,
+    disallowed_script_idents::DISALLOWED_SCRIPT_IDENTS,
+    disallowed_type::DISALLOWED_TYPE,
+    doc::DOC_MARKDOWN,
+    doc::MISSING_ERRORS_DOC,
+    doc::MISSING_PANICS_DOC,
+    doc::MISSING_SAFETY_DOC,
+    doc::NEEDLESS_DOCTEST_MAIN,
+    double_comparison::DOUBLE_COMPARISONS,
+    double_parens::DOUBLE_PARENS,
+    drop_forget_ref::DROP_COPY,
+    drop_forget_ref::DROP_REF,
+    drop_forget_ref::FORGET_COPY,
+    drop_forget_ref::FORGET_REF,
+    duration_subsec::DURATION_SUBSEC,
+    else_if_without_else::ELSE_IF_WITHOUT_ELSE,
+    empty_enum::EMPTY_ENUM,
+    entry::MAP_ENTRY,
+    enum_clike::ENUM_CLIKE_UNPORTABLE_VARIANT,
+    enum_variants::ENUM_VARIANT_NAMES,
+    enum_variants::MODULE_INCEPTION,
+    enum_variants::MODULE_NAME_REPETITIONS,
+    eq_op::EQ_OP,
+    eq_op::OP_REF,
+    erasing_op::ERASING_OP,
+    escape::BOXED_LOCAL,
+    eta_reduction::REDUNDANT_CLOSURE,
+    eta_reduction::REDUNDANT_CLOSURE_FOR_METHOD_CALLS,
+    eval_order_dependence::DIVERGING_SUB_EXPRESSION,
+    eval_order_dependence::EVAL_ORDER_DEPENDENCE,
+    excessive_bools::FN_PARAMS_EXCESSIVE_BOOLS,
+    excessive_bools::STRUCT_EXCESSIVE_BOOLS,
+    exhaustive_items::EXHAUSTIVE_ENUMS,
+    exhaustive_items::EXHAUSTIVE_STRUCTS,
+    exit::EXIT,
+    explicit_write::EXPLICIT_WRITE,
+    fallible_impl_from::FALLIBLE_IMPL_FROM,
+    feature_name::NEGATIVE_FEATURE_NAMES,
+    feature_name::REDUNDANT_FEATURE_NAMES,
+    float_equality_without_abs::FLOAT_EQUALITY_WITHOUT_ABS,
+    float_literal::EXCESSIVE_PRECISION,
+    float_literal::LOSSY_FLOAT_LITERAL,
+    floating_point_arithmetic::IMPRECISE_FLOPS,
+    floating_point_arithmetic::SUBOPTIMAL_FLOPS,
+    format::USELESS_FORMAT,
+    formatting::POSSIBLE_MISSING_COMMA,
+    formatting::SUSPICIOUS_ASSIGNMENT_FORMATTING,
+    formatting::SUSPICIOUS_ELSE_FORMATTING,
+    formatting::SUSPICIOUS_UNARY_OP_FORMATTING,
+    from_over_into::FROM_OVER_INTO,
+    from_str_radix_10::FROM_STR_RADIX_10,
+    functions::DOUBLE_MUST_USE,
+    functions::MUST_USE_CANDIDATE,
+    functions::MUST_USE_UNIT,
+    functions::NOT_UNSAFE_PTR_ARG_DEREF,
+    functions::RESULT_UNIT_ERR,
+    functions::TOO_MANY_ARGUMENTS,
+    functions::TOO_MANY_LINES,
+    future_not_send::FUTURE_NOT_SEND,
+    get_last_with_len::GET_LAST_WITH_LEN,
+    identity_op::IDENTITY_OP,
+    if_let_mutex::IF_LET_MUTEX,
+    if_not_else::IF_NOT_ELSE,
+    if_then_panic::IF_THEN_PANIC,
+    if_then_some_else_none::IF_THEN_SOME_ELSE_NONE,
+    implicit_hasher::IMPLICIT_HASHER,
+    implicit_return::IMPLICIT_RETURN,
+    implicit_saturating_sub::IMPLICIT_SATURATING_SUB,
+    inconsistent_struct_constructor::INCONSISTENT_STRUCT_CONSTRUCTOR,
+    indexing_slicing::INDEXING_SLICING,
+    indexing_slicing::OUT_OF_BOUNDS_INDEXING,
+    infinite_iter::INFINITE_ITER,
+    infinite_iter::MAYBE_INFINITE_ITER,
+    inherent_impl::MULTIPLE_INHERENT_IMPL,
+    inherent_to_string::INHERENT_TO_STRING,
+    inherent_to_string::INHERENT_TO_STRING_SHADOW_DISPLAY,
+    inline_fn_without_body::INLINE_FN_WITHOUT_BODY,
+    int_plus_one::INT_PLUS_ONE,
+    integer_division::INTEGER_DIVISION,
+    invalid_upcast_comparisons::INVALID_UPCAST_COMPARISONS,
+    items_after_statements::ITEMS_AFTER_STATEMENTS,
+    iter_not_returning_iterator::ITER_NOT_RETURNING_ITERATOR,
+    large_const_arrays::LARGE_CONST_ARRAYS,
+    large_enum_variant::LARGE_ENUM_VARIANT,
+    large_stack_arrays::LARGE_STACK_ARRAYS,
+    len_zero::COMPARISON_TO_EMPTY,
+    len_zero::LEN_WITHOUT_IS_EMPTY,
+    len_zero::LEN_ZERO,
+    let_if_seq::USELESS_LET_IF_SEQ,
+    let_underscore::LET_UNDERSCORE_DROP,
+    let_underscore::LET_UNDERSCORE_LOCK,
+    let_underscore::LET_UNDERSCORE_MUST_USE,
+    lifetimes::EXTRA_UNUSED_LIFETIMES,
+    lifetimes::NEEDLESS_LIFETIMES,
+    literal_representation::DECIMAL_LITERAL_REPRESENTATION,
+    literal_representation::INCONSISTENT_DIGIT_GROUPING,
+    literal_representation::LARGE_DIGIT_GROUPS,
+    literal_representation::MISTYPED_LITERAL_SUFFIXES,
+    literal_representation::UNREADABLE_LITERAL,
+    literal_representation::UNUSUAL_BYTE_GROUPINGS,
+    loops::EMPTY_LOOP,
+    loops::EXPLICIT_COUNTER_LOOP,
+    loops::EXPLICIT_INTO_ITER_LOOP,
+    loops::EXPLICIT_ITER_LOOP,
+    loops::FOR_KV_MAP,
+    loops::FOR_LOOPS_OVER_FALLIBLES,
+    loops::ITER_NEXT_LOOP,
+    loops::MANUAL_FLATTEN,
+    loops::MANUAL_MEMCPY,
+    loops::MUT_RANGE_BOUND,
+    loops::NEEDLESS_COLLECT,
+    loops::NEEDLESS_RANGE_LOOP,
+    loops::NEVER_LOOP,
+    loops::SAME_ITEM_PUSH,
+    loops::SINGLE_ELEMENT_LOOP,
+    loops::WHILE_IMMUTABLE_CONDITION,
+    loops::WHILE_LET_LOOP,
+    loops::WHILE_LET_ON_ITERATOR,
+    macro_use::MACRO_USE_IMPORTS,
+    main_recursion::MAIN_RECURSION,
+    manual_async_fn::MANUAL_ASYNC_FN,
+    manual_map::MANUAL_MAP,
+    manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE,
+    manual_ok_or::MANUAL_OK_OR,
+    manual_strip::MANUAL_STRIP,
+    manual_unwrap_or::MANUAL_UNWRAP_OR,
+    map_clone::MAP_CLONE,
+    map_err_ignore::MAP_ERR_IGNORE,
+    map_unit_fn::OPTION_MAP_UNIT_FN,
+    map_unit_fn::RESULT_MAP_UNIT_FN,
+    match_on_vec_items::MATCH_ON_VEC_ITEMS,
+    match_result_ok::MATCH_RESULT_OK,
+    matches::INFALLIBLE_DESTRUCTURING_MATCH,
+    matches::MATCH_AS_REF,
+    matches::MATCH_BOOL,
+    matches::MATCH_LIKE_MATCHES_MACRO,
+    matches::MATCH_OVERLAPPING_ARM,
+    matches::MATCH_REF_PATS,
+    matches::MATCH_SAME_ARMS,
+    matches::MATCH_SINGLE_BINDING,
+    matches::MATCH_WILDCARD_FOR_SINGLE_VARIANTS,
+    matches::MATCH_WILD_ERR_ARM,
+    matches::REDUNDANT_PATTERN_MATCHING,
+    matches::REST_PAT_IN_FULLY_BOUND_STRUCTS,
+    matches::SINGLE_MATCH,
+    matches::SINGLE_MATCH_ELSE,
+    matches::WILDCARD_ENUM_MATCH_ARM,
+    matches::WILDCARD_IN_OR_PATTERNS,
+    mem_discriminant::MEM_DISCRIMINANT_NON_ENUM,
+    mem_forget::MEM_FORGET,
+    mem_replace::MEM_REPLACE_OPTION_WITH_NONE,
+    mem_replace::MEM_REPLACE_WITH_DEFAULT,
+    mem_replace::MEM_REPLACE_WITH_UNINIT,
+    methods::BIND_INSTEAD_OF_MAP,
+    methods::BYTES_NTH,
+    methods::CHARS_LAST_CMP,
+    methods::CHARS_NEXT_CMP,
+    methods::CLONED_INSTEAD_OF_COPIED,
+    methods::CLONE_DOUBLE_REF,
+    methods::CLONE_ON_COPY,
+    methods::CLONE_ON_REF_PTR,
+    methods::EXPECT_FUN_CALL,
+    methods::EXPECT_USED,
+    methods::EXTEND_WITH_DRAIN,
+    methods::FILETYPE_IS_FILE,
+    methods::FILTER_MAP_IDENTITY,
+    methods::FILTER_MAP_NEXT,
+    methods::FILTER_NEXT,
+    methods::FLAT_MAP_IDENTITY,
+    methods::FLAT_MAP_OPTION,
+    methods::FROM_ITER_INSTEAD_OF_COLLECT,
+    methods::GET_UNWRAP,
+    methods::IMPLICIT_CLONE,
+    methods::INEFFICIENT_TO_STRING,
+    methods::INSPECT_FOR_EACH,
+    methods::INTO_ITER_ON_REF,
+    methods::ITERATOR_STEP_BY_ZERO,
+    methods::ITER_CLONED_COLLECT,
+    methods::ITER_COUNT,
+    methods::ITER_NEXT_SLICE,
+    methods::ITER_NTH,
+    methods::ITER_NTH_ZERO,
+    methods::ITER_SKIP_NEXT,
+    methods::MANUAL_FILTER_MAP,
+    methods::MANUAL_FIND_MAP,
+    methods::MANUAL_SATURATING_ARITHMETIC,
+    methods::MANUAL_SPLIT_ONCE,
+    methods::MANUAL_STR_REPEAT,
+    methods::MAP_COLLECT_RESULT_UNIT,
+    methods::MAP_FLATTEN,
+    methods::MAP_IDENTITY,
+    methods::MAP_UNWRAP_OR,
+    methods::NEW_RET_NO_SELF,
+    methods::OK_EXPECT,
+    methods::OPTION_AS_REF_DEREF,
+    methods::OPTION_FILTER_MAP,
+    methods::OPTION_MAP_OR_NONE,
+    methods::OR_FUN_CALL,
+    methods::RESULT_MAP_OR_INTO_OPTION,
+    methods::SEARCH_IS_SOME,
+    methods::SHOULD_IMPLEMENT_TRAIT,
+    methods::SINGLE_CHAR_ADD_STR,
+    methods::SINGLE_CHAR_PATTERN,
+    methods::SKIP_WHILE_NEXT,
+    methods::STRING_EXTEND_CHARS,
+    methods::SUSPICIOUS_MAP,
+    methods::SUSPICIOUS_SPLITN,
+    methods::UNINIT_ASSUMED_INIT,
+    methods::UNNECESSARY_FILTER_MAP,
+    methods::UNNECESSARY_FOLD,
+    methods::UNNECESSARY_LAZY_EVALUATIONS,
+    methods::UNWRAP_OR_ELSE_DEFAULT,
+    methods::UNWRAP_USED,
+    methods::USELESS_ASREF,
+    methods::WRONG_SELF_CONVENTION,
+    methods::ZST_OFFSET,
+    minmax::MIN_MAX,
+    misc::CMP_NAN,
+    misc::CMP_OWNED,
+    misc::FLOAT_CMP,
+    misc::FLOAT_CMP_CONST,
+    misc::MODULO_ONE,
+    misc::SHORT_CIRCUIT_STATEMENT,
+    misc::TOPLEVEL_REF_ARG,
+    misc::USED_UNDERSCORE_BINDING,
+    misc::ZERO_PTR,
+    misc_early::BUILTIN_TYPE_SHADOW,
+    misc_early::DOUBLE_NEG,
+    misc_early::DUPLICATE_UNDERSCORE_ARGUMENT,
+    misc_early::MIXED_CASE_HEX_LITERALS,
+    misc_early::REDUNDANT_PATTERN,
+    misc_early::UNNEEDED_FIELD_PATTERN,
+    misc_early::UNNEEDED_WILDCARD_PATTERN,
+    misc_early::UNSEPARATED_LITERAL_SUFFIX,
+    misc_early::ZERO_PREFIXED_LITERAL,
+    missing_const_for_fn::MISSING_CONST_FOR_FN,
+    missing_doc::MISSING_DOCS_IN_PRIVATE_ITEMS,
+    missing_enforced_import_rename::MISSING_ENFORCED_IMPORT_RENAMES,
+    missing_inline::MISSING_INLINE_IN_PUBLIC_ITEMS,
+    module_style::MOD_MODULE_FILES,
+    module_style::SELF_NAMED_MODULE_FILES,
+    modulo_arithmetic::MODULO_ARITHMETIC,
+    multiple_crate_versions::MULTIPLE_CRATE_VERSIONS,
+    mut_key::MUTABLE_KEY_TYPE,
+    mut_mut::MUT_MUT,
+    mut_mutex_lock::MUT_MUTEX_LOCK,
+    mut_reference::UNNECESSARY_MUT_PASSED,
+    mutable_debug_assertion::DEBUG_ASSERT_WITH_MUT_CALL,
+    mutex_atomic::MUTEX_ATOMIC,
+    mutex_atomic::MUTEX_INTEGER,
+    needless_arbitrary_self_type::NEEDLESS_ARBITRARY_SELF_TYPE,
+    needless_bitwise_bool::NEEDLESS_BITWISE_BOOL,
+    needless_bool::BOOL_COMPARISON,
+    needless_bool::NEEDLESS_BOOL,
+    needless_borrow::NEEDLESS_BORROW,
+    needless_borrow::REF_BINDING_TO_REFERENCE,
+    needless_borrowed_ref::NEEDLESS_BORROWED_REFERENCE,
+    needless_continue::NEEDLESS_CONTINUE,
+    needless_for_each::NEEDLESS_FOR_EACH,
+    needless_option_as_deref::NEEDLESS_OPTION_AS_DEREF,
+    needless_pass_by_value::NEEDLESS_PASS_BY_VALUE,
+    needless_question_mark::NEEDLESS_QUESTION_MARK,
+    needless_update::NEEDLESS_UPDATE,
+    neg_cmp_op_on_partial_ord::NEG_CMP_OP_ON_PARTIAL_ORD,
+    neg_multiply::NEG_MULTIPLY,
+    new_without_default::NEW_WITHOUT_DEFAULT,
+    no_effect::NO_EFFECT,
+    no_effect::UNNECESSARY_OPERATION,
+    non_copy_const::BORROW_INTERIOR_MUTABLE_CONST,
+    non_copy_const::DECLARE_INTERIOR_MUTABLE_CONST,
+    non_expressive_names::JUST_UNDERSCORES_AND_DIGITS,
+    non_expressive_names::MANY_SINGLE_CHAR_NAMES,
+    non_expressive_names::SIMILAR_NAMES,
+    non_octal_unix_permissions::NON_OCTAL_UNIX_PERMISSIONS,
+    nonstandard_macro_braces::NONSTANDARD_MACRO_BRACES,
+    open_options::NONSENSICAL_OPEN_OPTIONS,
+    option_env_unwrap::OPTION_ENV_UNWRAP,
+    option_if_let_else::OPTION_IF_LET_ELSE,
+    overflow_check_conditional::OVERFLOW_CHECK_CONDITIONAL,
+    panic_in_result_fn::PANIC_IN_RESULT_FN,
+    panic_unimplemented::PANIC,
+    panic_unimplemented::TODO,
+    panic_unimplemented::UNIMPLEMENTED,
+    panic_unimplemented::UNREACHABLE,
+    partialeq_ne_impl::PARTIALEQ_NE_IMPL,
+    pass_by_ref_or_value::LARGE_TYPES_PASSED_BY_VALUE,
+    pass_by_ref_or_value::TRIVIALLY_COPY_PASS_BY_REF,
+    path_buf_push_overwrite::PATH_BUF_PUSH_OVERWRITE,
+    pattern_type_mismatch::PATTERN_TYPE_MISMATCH,
+    precedence::PRECEDENCE,
+    ptr::CMP_NULL,
+    ptr::INVALID_NULL_PTR_USAGE,
+    ptr::MUT_FROM_REF,
+    ptr::PTR_ARG,
+    ptr_eq::PTR_EQ,
+    ptr_offset_with_cast::PTR_OFFSET_WITH_CAST,
+    question_mark::QUESTION_MARK,
+    ranges::MANUAL_RANGE_CONTAINS,
+    ranges::RANGE_MINUS_ONE,
+    ranges::RANGE_PLUS_ONE,
+    ranges::RANGE_ZIP_WITH_LEN,
+    ranges::REVERSED_EMPTY_RANGES,
+    redundant_clone::REDUNDANT_CLONE,
+    redundant_closure_call::REDUNDANT_CLOSURE_CALL,
+    redundant_else::REDUNDANT_ELSE,
+    redundant_field_names::REDUNDANT_FIELD_NAMES,
+    redundant_pub_crate::REDUNDANT_PUB_CRATE,
+    redundant_slicing::REDUNDANT_SLICING,
+    redundant_static_lifetimes::REDUNDANT_STATIC_LIFETIMES,
+    ref_option_ref::REF_OPTION_REF,
+    reference::DEREF_ADDROF,
+    reference::REF_IN_DEREF,
+    regex::INVALID_REGEX,
+    regex::TRIVIAL_REGEX,
+    repeat_once::REPEAT_ONCE,
+    returns::LET_AND_RETURN,
+    returns::NEEDLESS_RETURN,
+    same_name_method::SAME_NAME_METHOD,
+    self_assignment::SELF_ASSIGNMENT,
+    self_named_constructors::SELF_NAMED_CONSTRUCTORS,
+    semicolon_if_nothing_returned::SEMICOLON_IF_NOTHING_RETURNED,
+    serde_api::SERDE_API_MISUSE,
+    shadow::SHADOW_REUSE,
+    shadow::SHADOW_SAME,
+    shadow::SHADOW_UNRELATED,
+    single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS,
+    size_of_in_element_count::SIZE_OF_IN_ELEMENT_COUNT,
+    slow_vector_initialization::SLOW_VECTOR_INITIALIZATION,
+    stable_sort_primitive::STABLE_SORT_PRIMITIVE,
+    strings::STRING_ADD,
+    strings::STRING_ADD_ASSIGN,
+    strings::STRING_FROM_UTF8_AS_BYTES,
+    strings::STRING_LIT_AS_BYTES,
+    strings::STRING_TO_STRING,
+    strings::STR_TO_STRING,
+    strlen_on_c_strings::STRLEN_ON_C_STRINGS,
+    suspicious_operation_groupings::SUSPICIOUS_OPERATION_GROUPINGS,
+    suspicious_trait_impl::SUSPICIOUS_ARITHMETIC_IMPL,
+    suspicious_trait_impl::SUSPICIOUS_OP_ASSIGN_IMPL,
+    swap::ALMOST_SWAPPED,
+    swap::MANUAL_SWAP,
+    tabs_in_doc_comments::TABS_IN_DOC_COMMENTS,
+    temporary_assignment::TEMPORARY_ASSIGNMENT,
+    to_digit_is_some::TO_DIGIT_IS_SOME,
+    to_string_in_display::TO_STRING_IN_DISPLAY,
+    trait_bounds::TRAIT_DUPLICATION_IN_BOUNDS,
+    trait_bounds::TYPE_REPETITION_IN_BOUNDS,
+    transmute::CROSSPOINTER_TRANSMUTE,
+    transmute::TRANSMUTES_EXPRESSIBLE_AS_PTR_CASTS,
+    transmute::TRANSMUTE_BYTES_TO_STR,
+    transmute::TRANSMUTE_FLOAT_TO_INT,
+    transmute::TRANSMUTE_INT_TO_BOOL,
+    transmute::TRANSMUTE_INT_TO_CHAR,
+    transmute::TRANSMUTE_INT_TO_FLOAT,
+    transmute::TRANSMUTE_PTR_TO_PTR,
+    transmute::TRANSMUTE_PTR_TO_REF,
+    transmute::UNSOUND_COLLECTION_TRANSMUTE,
+    transmute::USELESS_TRANSMUTE,
+    transmute::WRONG_TRANSMUTE,
+    transmuting_null::TRANSMUTING_NULL,
+    try_err::TRY_ERR,
+    types::BORROWED_BOX,
+    types::BOX_COLLECTION,
+    types::LINKEDLIST,
+    types::OPTION_OPTION,
+    types::RC_BUFFER,
+    types::RC_MUTEX,
+    types::REDUNDANT_ALLOCATION,
+    types::TYPE_COMPLEXITY,
+    types::VEC_BOX,
+    undropped_manually_drops::UNDROPPED_MANUALLY_DROPS,
+    unicode::INVISIBLE_CHARACTERS,
+    unicode::NON_ASCII_LITERAL,
+    unicode::UNICODE_NOT_NFC,
+    unit_return_expecting_ord::UNIT_RETURN_EXPECTING_ORD,
+    unit_types::LET_UNIT_VALUE,
+    unit_types::UNIT_ARG,
+    unit_types::UNIT_CMP,
+    unnamed_address::FN_ADDRESS_COMPARISONS,
+    unnamed_address::VTABLE_ADDRESS_COMPARISONS,
+    unnecessary_self_imports::UNNECESSARY_SELF_IMPORTS,
+    unnecessary_sort_by::UNNECESSARY_SORT_BY,
+    unnecessary_wraps::UNNECESSARY_WRAPS,
+    unnested_or_patterns::UNNESTED_OR_PATTERNS,
+    unsafe_removed_from_name::UNSAFE_REMOVED_FROM_NAME,
+    unused_async::UNUSED_ASYNC,
+    unused_io_amount::UNUSED_IO_AMOUNT,
+    unused_self::UNUSED_SELF,
+    unused_unit::UNUSED_UNIT,
+    unwrap::PANICKING_UNWRAP,
+    unwrap::UNNECESSARY_UNWRAP,
+    unwrap_in_result::UNWRAP_IN_RESULT,
+    upper_case_acronyms::UPPER_CASE_ACRONYMS,
+    use_self::USE_SELF,
+    useless_conversion::USELESS_CONVERSION,
+    vec::USELESS_VEC,
+    vec_init_then_push::VEC_INIT_THEN_PUSH,
+    vec_resize_to_zero::VEC_RESIZE_TO_ZERO,
+    verbose_file_reads::VERBOSE_FILE_READS,
+    wildcard_dependencies::WILDCARD_DEPENDENCIES,
+    wildcard_imports::ENUM_GLOB_USE,
+    wildcard_imports::WILDCARD_IMPORTS,
+    write::PRINTLN_EMPTY_STRING,
+    write::PRINT_LITERAL,
+    write::PRINT_STDERR,
+    write::PRINT_STDOUT,
+    write::PRINT_WITH_NEWLINE,
+    write::USE_DEBUG,
+    write::WRITELN_EMPTY_STRING,
+    write::WRITE_LITERAL,
+    write::WRITE_WITH_NEWLINE,
+    zero_div_zero::ZERO_DIVIDED_BY_ZERO,
+    zero_sized_map_values::ZERO_SIZED_MAP_VALUES,
+])
diff --git a/clippy_lints/src/lib.register_nursery.rs b/clippy_lints/src/lib.register_nursery.rs
index 72a09fcfe25..b082f577a52 100644
--- a/clippy_lints/src/lib.register_nursery.rs
+++ b/clippy_lints/src/lib.register_nursery.rs
@@ -3,26 +3,26 @@
 // Manual edits will be overwritten.
 
 store.register_group(true, "clippy::nursery", Some("clippy_nursery"), vec![
-LintId::of(attrs::EMPTY_LINE_AFTER_OUTER_ATTR),
-LintId::of(cognitive_complexity::COGNITIVE_COMPLEXITY),
-LintId::of(copies::BRANCHES_SHARING_CODE),
-LintId::of(disallowed_method::DISALLOWED_METHOD),
-LintId::of(disallowed_type::DISALLOWED_TYPE),
-LintId::of(fallible_impl_from::FALLIBLE_IMPL_FROM),
-LintId::of(floating_point_arithmetic::IMPRECISE_FLOPS),
-LintId::of(floating_point_arithmetic::SUBOPTIMAL_FLOPS),
-LintId::of(future_not_send::FUTURE_NOT_SEND),
-LintId::of(let_if_seq::USELESS_LET_IF_SEQ),
-LintId::of(missing_const_for_fn::MISSING_CONST_FOR_FN),
-LintId::of(mutable_debug_assertion::DEBUG_ASSERT_WITH_MUT_CALL),
-LintId::of(mutex_atomic::MUTEX_INTEGER),
-LintId::of(nonstandard_macro_braces::NONSTANDARD_MACRO_BRACES),
-LintId::of(option_if_let_else::OPTION_IF_LET_ELSE),
-LintId::of(path_buf_push_overwrite::PATH_BUF_PUSH_OVERWRITE),
-LintId::of(redundant_pub_crate::REDUNDANT_PUB_CRATE),
-LintId::of(regex::TRIVIAL_REGEX),
-LintId::of(strings::STRING_LIT_AS_BYTES),
-LintId::of(suspicious_operation_groupings::SUSPICIOUS_OPERATION_GROUPINGS),
-LintId::of(transmute::USELESS_TRANSMUTE),
-LintId::of(use_self::USE_SELF),
-])
\ No newline at end of file
+    LintId::of(attrs::EMPTY_LINE_AFTER_OUTER_ATTR),
+    LintId::of(cognitive_complexity::COGNITIVE_COMPLEXITY),
+    LintId::of(copies::BRANCHES_SHARING_CODE),
+    LintId::of(disallowed_method::DISALLOWED_METHOD),
+    LintId::of(disallowed_type::DISALLOWED_TYPE),
+    LintId::of(fallible_impl_from::FALLIBLE_IMPL_FROM),
+    LintId::of(floating_point_arithmetic::IMPRECISE_FLOPS),
+    LintId::of(floating_point_arithmetic::SUBOPTIMAL_FLOPS),
+    LintId::of(future_not_send::FUTURE_NOT_SEND),
+    LintId::of(let_if_seq::USELESS_LET_IF_SEQ),
+    LintId::of(missing_const_for_fn::MISSING_CONST_FOR_FN),
+    LintId::of(mutable_debug_assertion::DEBUG_ASSERT_WITH_MUT_CALL),
+    LintId::of(mutex_atomic::MUTEX_INTEGER),
+    LintId::of(nonstandard_macro_braces::NONSTANDARD_MACRO_BRACES),
+    LintId::of(option_if_let_else::OPTION_IF_LET_ELSE),
+    LintId::of(path_buf_push_overwrite::PATH_BUF_PUSH_OVERWRITE),
+    LintId::of(redundant_pub_crate::REDUNDANT_PUB_CRATE),
+    LintId::of(regex::TRIVIAL_REGEX),
+    LintId::of(strings::STRING_LIT_AS_BYTES),
+    LintId::of(suspicious_operation_groupings::SUSPICIOUS_OPERATION_GROUPINGS),
+    LintId::of(transmute::USELESS_TRANSMUTE),
+    LintId::of(use_self::USE_SELF),
+])
diff --git a/clippy_lints/src/lib.register_pedantic.rs b/clippy_lints/src/lib.register_pedantic.rs
index 8356198d80d..334e058c4ae 100644
--- a/clippy_lints/src/lib.register_pedantic.rs
+++ b/clippy_lints/src/lib.register_pedantic.rs
@@ -3,99 +3,99 @@
 // Manual edits will be overwritten.
 
 store.register_group(true, "clippy::pedantic", Some("clippy_pedantic"), vec![
-LintId::of(attrs::INLINE_ALWAYS),
-LintId::of(await_holding_invalid::AWAIT_HOLDING_LOCK),
-LintId::of(await_holding_invalid::AWAIT_HOLDING_REFCELL_REF),
-LintId::of(bit_mask::VERBOSE_BIT_MASK),
-LintId::of(bytecount::NAIVE_BYTECOUNT),
-LintId::of(case_sensitive_file_extension_comparisons::CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS),
-LintId::of(casts::CAST_LOSSLESS),
-LintId::of(casts::CAST_POSSIBLE_TRUNCATION),
-LintId::of(casts::CAST_POSSIBLE_WRAP),
-LintId::of(casts::CAST_PRECISION_LOSS),
-LintId::of(casts::CAST_PTR_ALIGNMENT),
-LintId::of(casts::CAST_SIGN_LOSS),
-LintId::of(casts::PTR_AS_PTR),
-LintId::of(checked_conversions::CHECKED_CONVERSIONS),
-LintId::of(copies::SAME_FUNCTIONS_IN_IF_CONDITION),
-LintId::of(copy_iterator::COPY_ITERATOR),
-LintId::of(default::DEFAULT_TRAIT_ACCESS),
-LintId::of(dereference::EXPLICIT_DEREF_METHODS),
-LintId::of(derive::EXPL_IMPL_CLONE_ON_COPY),
-LintId::of(derive::UNSAFE_DERIVE_DESERIALIZE),
-LintId::of(doc::DOC_MARKDOWN),
-LintId::of(doc::MISSING_ERRORS_DOC),
-LintId::of(doc::MISSING_PANICS_DOC),
-LintId::of(empty_enum::EMPTY_ENUM),
-LintId::of(enum_variants::MODULE_NAME_REPETITIONS),
-LintId::of(eta_reduction::REDUNDANT_CLOSURE_FOR_METHOD_CALLS),
-LintId::of(excessive_bools::FN_PARAMS_EXCESSIVE_BOOLS),
-LintId::of(excessive_bools::STRUCT_EXCESSIVE_BOOLS),
-LintId::of(functions::MUST_USE_CANDIDATE),
-LintId::of(functions::TOO_MANY_LINES),
-LintId::of(if_not_else::IF_NOT_ELSE),
-LintId::of(implicit_hasher::IMPLICIT_HASHER),
-LintId::of(implicit_saturating_sub::IMPLICIT_SATURATING_SUB),
-LintId::of(inconsistent_struct_constructor::INCONSISTENT_STRUCT_CONSTRUCTOR),
-LintId::of(infinite_iter::MAYBE_INFINITE_ITER),
-LintId::of(invalid_upcast_comparisons::INVALID_UPCAST_COMPARISONS),
-LintId::of(items_after_statements::ITEMS_AFTER_STATEMENTS),
-LintId::of(iter_not_returning_iterator::ITER_NOT_RETURNING_ITERATOR),
-LintId::of(large_stack_arrays::LARGE_STACK_ARRAYS),
-LintId::of(let_underscore::LET_UNDERSCORE_DROP),
-LintId::of(literal_representation::LARGE_DIGIT_GROUPS),
-LintId::of(literal_representation::UNREADABLE_LITERAL),
-LintId::of(loops::EXPLICIT_INTO_ITER_LOOP),
-LintId::of(loops::EXPLICIT_ITER_LOOP),
-LintId::of(macro_use::MACRO_USE_IMPORTS),
-LintId::of(manual_ok_or::MANUAL_OK_OR),
-LintId::of(match_on_vec_items::MATCH_ON_VEC_ITEMS),
-LintId::of(matches::MATCH_BOOL),
-LintId::of(matches::MATCH_SAME_ARMS),
-LintId::of(matches::MATCH_WILDCARD_FOR_SINGLE_VARIANTS),
-LintId::of(matches::MATCH_WILD_ERR_ARM),
-LintId::of(matches::SINGLE_MATCH_ELSE),
-LintId::of(methods::CLONED_INSTEAD_OF_COPIED),
-LintId::of(methods::FILTER_MAP_NEXT),
-LintId::of(methods::FLAT_MAP_OPTION),
-LintId::of(methods::FROM_ITER_INSTEAD_OF_COLLECT),
-LintId::of(methods::IMPLICIT_CLONE),
-LintId::of(methods::INEFFICIENT_TO_STRING),
-LintId::of(methods::MAP_FLATTEN),
-LintId::of(methods::MAP_UNWRAP_OR),
-LintId::of(misc::FLOAT_CMP),
-LintId::of(misc::USED_UNDERSCORE_BINDING),
-LintId::of(misc_early::UNSEPARATED_LITERAL_SUFFIX),
-LintId::of(mut_mut::MUT_MUT),
-LintId::of(needless_bitwise_bool::NEEDLESS_BITWISE_BOOL),
-LintId::of(needless_borrow::REF_BINDING_TO_REFERENCE),
-LintId::of(needless_continue::NEEDLESS_CONTINUE),
-LintId::of(needless_for_each::NEEDLESS_FOR_EACH),
-LintId::of(needless_pass_by_value::NEEDLESS_PASS_BY_VALUE),
-LintId::of(non_expressive_names::MANY_SINGLE_CHAR_NAMES),
-LintId::of(non_expressive_names::SIMILAR_NAMES),
-LintId::of(pass_by_ref_or_value::LARGE_TYPES_PASSED_BY_VALUE),
-LintId::of(pass_by_ref_or_value::TRIVIALLY_COPY_PASS_BY_REF),
-LintId::of(ranges::RANGE_MINUS_ONE),
-LintId::of(ranges::RANGE_PLUS_ONE),
-LintId::of(redundant_else::REDUNDANT_ELSE),
-LintId::of(ref_option_ref::REF_OPTION_REF),
-LintId::of(semicolon_if_nothing_returned::SEMICOLON_IF_NOTHING_RETURNED),
-LintId::of(shadow::SHADOW_UNRELATED),
-LintId::of(strings::STRING_ADD_ASSIGN),
-LintId::of(trait_bounds::TRAIT_DUPLICATION_IN_BOUNDS),
-LintId::of(trait_bounds::TYPE_REPETITION_IN_BOUNDS),
-LintId::of(transmute::TRANSMUTE_PTR_TO_PTR),
-LintId::of(types::LINKEDLIST),
-LintId::of(types::OPTION_OPTION),
-LintId::of(unicode::NON_ASCII_LITERAL),
-LintId::of(unicode::UNICODE_NOT_NFC),
-LintId::of(unit_types::LET_UNIT_VALUE),
-LintId::of(unnecessary_wraps::UNNECESSARY_WRAPS),
-LintId::of(unnested_or_patterns::UNNESTED_OR_PATTERNS),
-LintId::of(unused_async::UNUSED_ASYNC),
-LintId::of(unused_self::UNUSED_SELF),
-LintId::of(wildcard_imports::ENUM_GLOB_USE),
-LintId::of(wildcard_imports::WILDCARD_IMPORTS),
-LintId::of(zero_sized_map_values::ZERO_SIZED_MAP_VALUES),
-])
\ No newline at end of file
+    LintId::of(attrs::INLINE_ALWAYS),
+    LintId::of(await_holding_invalid::AWAIT_HOLDING_LOCK),
+    LintId::of(await_holding_invalid::AWAIT_HOLDING_REFCELL_REF),
+    LintId::of(bit_mask::VERBOSE_BIT_MASK),
+    LintId::of(bytecount::NAIVE_BYTECOUNT),
+    LintId::of(case_sensitive_file_extension_comparisons::CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS),
+    LintId::of(casts::CAST_LOSSLESS),
+    LintId::of(casts::CAST_POSSIBLE_TRUNCATION),
+    LintId::of(casts::CAST_POSSIBLE_WRAP),
+    LintId::of(casts::CAST_PRECISION_LOSS),
+    LintId::of(casts::CAST_PTR_ALIGNMENT),
+    LintId::of(casts::CAST_SIGN_LOSS),
+    LintId::of(casts::PTR_AS_PTR),
+    LintId::of(checked_conversions::CHECKED_CONVERSIONS),
+    LintId::of(copies::SAME_FUNCTIONS_IN_IF_CONDITION),
+    LintId::of(copy_iterator::COPY_ITERATOR),
+    LintId::of(default::DEFAULT_TRAIT_ACCESS),
+    LintId::of(dereference::EXPLICIT_DEREF_METHODS),
+    LintId::of(derive::EXPL_IMPL_CLONE_ON_COPY),
+    LintId::of(derive::UNSAFE_DERIVE_DESERIALIZE),
+    LintId::of(doc::DOC_MARKDOWN),
+    LintId::of(doc::MISSING_ERRORS_DOC),
+    LintId::of(doc::MISSING_PANICS_DOC),
+    LintId::of(empty_enum::EMPTY_ENUM),
+    LintId::of(enum_variants::MODULE_NAME_REPETITIONS),
+    LintId::of(eta_reduction::REDUNDANT_CLOSURE_FOR_METHOD_CALLS),
+    LintId::of(excessive_bools::FN_PARAMS_EXCESSIVE_BOOLS),
+    LintId::of(excessive_bools::STRUCT_EXCESSIVE_BOOLS),
+    LintId::of(functions::MUST_USE_CANDIDATE),
+    LintId::of(functions::TOO_MANY_LINES),
+    LintId::of(if_not_else::IF_NOT_ELSE),
+    LintId::of(implicit_hasher::IMPLICIT_HASHER),
+    LintId::of(implicit_saturating_sub::IMPLICIT_SATURATING_SUB),
+    LintId::of(inconsistent_struct_constructor::INCONSISTENT_STRUCT_CONSTRUCTOR),
+    LintId::of(infinite_iter::MAYBE_INFINITE_ITER),
+    LintId::of(invalid_upcast_comparisons::INVALID_UPCAST_COMPARISONS),
+    LintId::of(items_after_statements::ITEMS_AFTER_STATEMENTS),
+    LintId::of(iter_not_returning_iterator::ITER_NOT_RETURNING_ITERATOR),
+    LintId::of(large_stack_arrays::LARGE_STACK_ARRAYS),
+    LintId::of(let_underscore::LET_UNDERSCORE_DROP),
+    LintId::of(literal_representation::LARGE_DIGIT_GROUPS),
+    LintId::of(literal_representation::UNREADABLE_LITERAL),
+    LintId::of(loops::EXPLICIT_INTO_ITER_LOOP),
+    LintId::of(loops::EXPLICIT_ITER_LOOP),
+    LintId::of(macro_use::MACRO_USE_IMPORTS),
+    LintId::of(manual_ok_or::MANUAL_OK_OR),
+    LintId::of(match_on_vec_items::MATCH_ON_VEC_ITEMS),
+    LintId::of(matches::MATCH_BOOL),
+    LintId::of(matches::MATCH_SAME_ARMS),
+    LintId::of(matches::MATCH_WILDCARD_FOR_SINGLE_VARIANTS),
+    LintId::of(matches::MATCH_WILD_ERR_ARM),
+    LintId::of(matches::SINGLE_MATCH_ELSE),
+    LintId::of(methods::CLONED_INSTEAD_OF_COPIED),
+    LintId::of(methods::FILTER_MAP_NEXT),
+    LintId::of(methods::FLAT_MAP_OPTION),
+    LintId::of(methods::FROM_ITER_INSTEAD_OF_COLLECT),
+    LintId::of(methods::IMPLICIT_CLONE),
+    LintId::of(methods::INEFFICIENT_TO_STRING),
+    LintId::of(methods::MAP_FLATTEN),
+    LintId::of(methods::MAP_UNWRAP_OR),
+    LintId::of(misc::FLOAT_CMP),
+    LintId::of(misc::USED_UNDERSCORE_BINDING),
+    LintId::of(misc_early::UNSEPARATED_LITERAL_SUFFIX),
+    LintId::of(mut_mut::MUT_MUT),
+    LintId::of(needless_bitwise_bool::NEEDLESS_BITWISE_BOOL),
+    LintId::of(needless_borrow::REF_BINDING_TO_REFERENCE),
+    LintId::of(needless_continue::NEEDLESS_CONTINUE),
+    LintId::of(needless_for_each::NEEDLESS_FOR_EACH),
+    LintId::of(needless_pass_by_value::NEEDLESS_PASS_BY_VALUE),
+    LintId::of(non_expressive_names::MANY_SINGLE_CHAR_NAMES),
+    LintId::of(non_expressive_names::SIMILAR_NAMES),
+    LintId::of(pass_by_ref_or_value::LARGE_TYPES_PASSED_BY_VALUE),
+    LintId::of(pass_by_ref_or_value::TRIVIALLY_COPY_PASS_BY_REF),
+    LintId::of(ranges::RANGE_MINUS_ONE),
+    LintId::of(ranges::RANGE_PLUS_ONE),
+    LintId::of(redundant_else::REDUNDANT_ELSE),
+    LintId::of(ref_option_ref::REF_OPTION_REF),
+    LintId::of(semicolon_if_nothing_returned::SEMICOLON_IF_NOTHING_RETURNED),
+    LintId::of(shadow::SHADOW_UNRELATED),
+    LintId::of(strings::STRING_ADD_ASSIGN),
+    LintId::of(trait_bounds::TRAIT_DUPLICATION_IN_BOUNDS),
+    LintId::of(trait_bounds::TYPE_REPETITION_IN_BOUNDS),
+    LintId::of(transmute::TRANSMUTE_PTR_TO_PTR),
+    LintId::of(types::LINKEDLIST),
+    LintId::of(types::OPTION_OPTION),
+    LintId::of(unicode::NON_ASCII_LITERAL),
+    LintId::of(unicode::UNICODE_NOT_NFC),
+    LintId::of(unit_types::LET_UNIT_VALUE),
+    LintId::of(unnecessary_wraps::UNNECESSARY_WRAPS),
+    LintId::of(unnested_or_patterns::UNNESTED_OR_PATTERNS),
+    LintId::of(unused_async::UNUSED_ASYNC),
+    LintId::of(unused_self::UNUSED_SELF),
+    LintId::of(wildcard_imports::ENUM_GLOB_USE),
+    LintId::of(wildcard_imports::WILDCARD_IMPORTS),
+    LintId::of(zero_sized_map_values::ZERO_SIZED_MAP_VALUES),
+])
diff --git a/clippy_lints/src/lib.register_perf.rs b/clippy_lints/src/lib.register_perf.rs
index 610309dd893..5432345760b 100644
--- a/clippy_lints/src/lib.register_perf.rs
+++ b/clippy_lints/src/lib.register_perf.rs
@@ -3,25 +3,25 @@
 // Manual edits will be overwritten.
 
 store.register_group(true, "clippy::perf", Some("clippy_perf"), vec![
-LintId::of(entry::MAP_ENTRY),
-LintId::of(escape::BOXED_LOCAL),
-LintId::of(large_const_arrays::LARGE_CONST_ARRAYS),
-LintId::of(large_enum_variant::LARGE_ENUM_VARIANT),
-LintId::of(loops::MANUAL_MEMCPY),
-LintId::of(loops::NEEDLESS_COLLECT),
-LintId::of(methods::EXPECT_FUN_CALL),
-LintId::of(methods::EXTEND_WITH_DRAIN),
-LintId::of(methods::ITER_NTH),
-LintId::of(methods::MANUAL_STR_REPEAT),
-LintId::of(methods::OR_FUN_CALL),
-LintId::of(methods::SINGLE_CHAR_PATTERN),
-LintId::of(misc::CMP_OWNED),
-LintId::of(mutex_atomic::MUTEX_ATOMIC),
-LintId::of(redundant_clone::REDUNDANT_CLONE),
-LintId::of(slow_vector_initialization::SLOW_VECTOR_INITIALIZATION),
-LintId::of(stable_sort_primitive::STABLE_SORT_PRIMITIVE),
-LintId::of(types::BOX_COLLECTION),
-LintId::of(types::REDUNDANT_ALLOCATION),
-LintId::of(vec::USELESS_VEC),
-LintId::of(vec_init_then_push::VEC_INIT_THEN_PUSH),
-])
\ No newline at end of file
+    LintId::of(entry::MAP_ENTRY),
+    LintId::of(escape::BOXED_LOCAL),
+    LintId::of(large_const_arrays::LARGE_CONST_ARRAYS),
+    LintId::of(large_enum_variant::LARGE_ENUM_VARIANT),
+    LintId::of(loops::MANUAL_MEMCPY),
+    LintId::of(loops::NEEDLESS_COLLECT),
+    LintId::of(methods::EXPECT_FUN_CALL),
+    LintId::of(methods::EXTEND_WITH_DRAIN),
+    LintId::of(methods::ITER_NTH),
+    LintId::of(methods::MANUAL_STR_REPEAT),
+    LintId::of(methods::OR_FUN_CALL),
+    LintId::of(methods::SINGLE_CHAR_PATTERN),
+    LintId::of(misc::CMP_OWNED),
+    LintId::of(mutex_atomic::MUTEX_ATOMIC),
+    LintId::of(redundant_clone::REDUNDANT_CLONE),
+    LintId::of(slow_vector_initialization::SLOW_VECTOR_INITIALIZATION),
+    LintId::of(stable_sort_primitive::STABLE_SORT_PRIMITIVE),
+    LintId::of(types::BOX_COLLECTION),
+    LintId::of(types::REDUNDANT_ALLOCATION),
+    LintId::of(vec::USELESS_VEC),
+    LintId::of(vec_init_then_push::VEC_INIT_THEN_PUSH),
+])
diff --git a/clippy_lints/src/lib.register_restriction.rs b/clippy_lints/src/lib.register_restriction.rs
index 8f181fe2e78..530662dfc0c 100644
--- a/clippy_lints/src/lib.register_restriction.rs
+++ b/clippy_lints/src/lib.register_restriction.rs
@@ -3,62 +3,62 @@
 // Manual edits will be overwritten.
 
 store.register_group(true, "clippy::restriction", Some("clippy_restriction"), vec![
-LintId::of(arithmetic::FLOAT_ARITHMETIC),
-LintId::of(arithmetic::INTEGER_ARITHMETIC),
-LintId::of(as_conversions::AS_CONVERSIONS),
-LintId::of(asm_syntax::INLINE_ASM_X86_ATT_SYNTAX),
-LintId::of(asm_syntax::INLINE_ASM_X86_INTEL_SYNTAX),
-LintId::of(create_dir::CREATE_DIR),
-LintId::of(dbg_macro::DBG_MACRO),
-LintId::of(default_numeric_fallback::DEFAULT_NUMERIC_FALLBACK),
-LintId::of(disallowed_script_idents::DISALLOWED_SCRIPT_IDENTS),
-LintId::of(else_if_without_else::ELSE_IF_WITHOUT_ELSE),
-LintId::of(exhaustive_items::EXHAUSTIVE_ENUMS),
-LintId::of(exhaustive_items::EXHAUSTIVE_STRUCTS),
-LintId::of(exit::EXIT),
-LintId::of(float_literal::LOSSY_FLOAT_LITERAL),
-LintId::of(if_then_some_else_none::IF_THEN_SOME_ELSE_NONE),
-LintId::of(implicit_return::IMPLICIT_RETURN),
-LintId::of(indexing_slicing::INDEXING_SLICING),
-LintId::of(inherent_impl::MULTIPLE_INHERENT_IMPL),
-LintId::of(integer_division::INTEGER_DIVISION),
-LintId::of(let_underscore::LET_UNDERSCORE_MUST_USE),
-LintId::of(literal_representation::DECIMAL_LITERAL_REPRESENTATION),
-LintId::of(map_err_ignore::MAP_ERR_IGNORE),
-LintId::of(matches::REST_PAT_IN_FULLY_BOUND_STRUCTS),
-LintId::of(matches::WILDCARD_ENUM_MATCH_ARM),
-LintId::of(mem_forget::MEM_FORGET),
-LintId::of(methods::CLONE_ON_REF_PTR),
-LintId::of(methods::EXPECT_USED),
-LintId::of(methods::FILETYPE_IS_FILE),
-LintId::of(methods::GET_UNWRAP),
-LintId::of(methods::UNWRAP_USED),
-LintId::of(misc::FLOAT_CMP_CONST),
-LintId::of(misc_early::UNNEEDED_FIELD_PATTERN),
-LintId::of(missing_doc::MISSING_DOCS_IN_PRIVATE_ITEMS),
-LintId::of(missing_enforced_import_rename::MISSING_ENFORCED_IMPORT_RENAMES),
-LintId::of(missing_inline::MISSING_INLINE_IN_PUBLIC_ITEMS),
-LintId::of(module_style::MOD_MODULE_FILES),
-LintId::of(module_style::SELF_NAMED_MODULE_FILES),
-LintId::of(modulo_arithmetic::MODULO_ARITHMETIC),
-LintId::of(panic_in_result_fn::PANIC_IN_RESULT_FN),
-LintId::of(panic_unimplemented::PANIC),
-LintId::of(panic_unimplemented::TODO),
-LintId::of(panic_unimplemented::UNIMPLEMENTED),
-LintId::of(panic_unimplemented::UNREACHABLE),
-LintId::of(pattern_type_mismatch::PATTERN_TYPE_MISMATCH),
-LintId::of(same_name_method::SAME_NAME_METHOD),
-LintId::of(shadow::SHADOW_REUSE),
-LintId::of(shadow::SHADOW_SAME),
-LintId::of(strings::STRING_ADD),
-LintId::of(strings::STRING_TO_STRING),
-LintId::of(strings::STR_TO_STRING),
-LintId::of(types::RC_BUFFER),
-LintId::of(types::RC_MUTEX),
-LintId::of(unnecessary_self_imports::UNNECESSARY_SELF_IMPORTS),
-LintId::of(unwrap_in_result::UNWRAP_IN_RESULT),
-LintId::of(verbose_file_reads::VERBOSE_FILE_READS),
-LintId::of(write::PRINT_STDERR),
-LintId::of(write::PRINT_STDOUT),
-LintId::of(write::USE_DEBUG),
-])
\ No newline at end of file
+    LintId::of(arithmetic::FLOAT_ARITHMETIC),
+    LintId::of(arithmetic::INTEGER_ARITHMETIC),
+    LintId::of(as_conversions::AS_CONVERSIONS),
+    LintId::of(asm_syntax::INLINE_ASM_X86_ATT_SYNTAX),
+    LintId::of(asm_syntax::INLINE_ASM_X86_INTEL_SYNTAX),
+    LintId::of(create_dir::CREATE_DIR),
+    LintId::of(dbg_macro::DBG_MACRO),
+    LintId::of(default_numeric_fallback::DEFAULT_NUMERIC_FALLBACK),
+    LintId::of(disallowed_script_idents::DISALLOWED_SCRIPT_IDENTS),
+    LintId::of(else_if_without_else::ELSE_IF_WITHOUT_ELSE),
+    LintId::of(exhaustive_items::EXHAUSTIVE_ENUMS),
+    LintId::of(exhaustive_items::EXHAUSTIVE_STRUCTS),
+    LintId::of(exit::EXIT),
+    LintId::of(float_literal::LOSSY_FLOAT_LITERAL),
+    LintId::of(if_then_some_else_none::IF_THEN_SOME_ELSE_NONE),
+    LintId::of(implicit_return::IMPLICIT_RETURN),
+    LintId::of(indexing_slicing::INDEXING_SLICING),
+    LintId::of(inherent_impl::MULTIPLE_INHERENT_IMPL),
+    LintId::of(integer_division::INTEGER_DIVISION),
+    LintId::of(let_underscore::LET_UNDERSCORE_MUST_USE),
+    LintId::of(literal_representation::DECIMAL_LITERAL_REPRESENTATION),
+    LintId::of(map_err_ignore::MAP_ERR_IGNORE),
+    LintId::of(matches::REST_PAT_IN_FULLY_BOUND_STRUCTS),
+    LintId::of(matches::WILDCARD_ENUM_MATCH_ARM),
+    LintId::of(mem_forget::MEM_FORGET),
+    LintId::of(methods::CLONE_ON_REF_PTR),
+    LintId::of(methods::EXPECT_USED),
+    LintId::of(methods::FILETYPE_IS_FILE),
+    LintId::of(methods::GET_UNWRAP),
+    LintId::of(methods::UNWRAP_USED),
+    LintId::of(misc::FLOAT_CMP_CONST),
+    LintId::of(misc_early::UNNEEDED_FIELD_PATTERN),
+    LintId::of(missing_doc::MISSING_DOCS_IN_PRIVATE_ITEMS),
+    LintId::of(missing_enforced_import_rename::MISSING_ENFORCED_IMPORT_RENAMES),
+    LintId::of(missing_inline::MISSING_INLINE_IN_PUBLIC_ITEMS),
+    LintId::of(module_style::MOD_MODULE_FILES),
+    LintId::of(module_style::SELF_NAMED_MODULE_FILES),
+    LintId::of(modulo_arithmetic::MODULO_ARITHMETIC),
+    LintId::of(panic_in_result_fn::PANIC_IN_RESULT_FN),
+    LintId::of(panic_unimplemented::PANIC),
+    LintId::of(panic_unimplemented::TODO),
+    LintId::of(panic_unimplemented::UNIMPLEMENTED),
+    LintId::of(panic_unimplemented::UNREACHABLE),
+    LintId::of(pattern_type_mismatch::PATTERN_TYPE_MISMATCH),
+    LintId::of(same_name_method::SAME_NAME_METHOD),
+    LintId::of(shadow::SHADOW_REUSE),
+    LintId::of(shadow::SHADOW_SAME),
+    LintId::of(strings::STRING_ADD),
+    LintId::of(strings::STRING_TO_STRING),
+    LintId::of(strings::STR_TO_STRING),
+    LintId::of(types::RC_BUFFER),
+    LintId::of(types::RC_MUTEX),
+    LintId::of(unnecessary_self_imports::UNNECESSARY_SELF_IMPORTS),
+    LintId::of(unwrap_in_result::UNWRAP_IN_RESULT),
+    LintId::of(verbose_file_reads::VERBOSE_FILE_READS),
+    LintId::of(write::PRINT_STDERR),
+    LintId::of(write::PRINT_STDOUT),
+    LintId::of(write::USE_DEBUG),
+])
diff --git a/clippy_lints/src/lib.register_style.rs b/clippy_lints/src/lib.register_style.rs
index cd563907b77..a39c111c574 100644
--- a/clippy_lints/src/lib.register_style.rs
+++ b/clippy_lints/src/lib.register_style.rs
@@ -3,112 +3,112 @@
 // Manual edits will be overwritten.
 
 store.register_group(true, "clippy::style", Some("clippy_style"), vec![
-LintId::of(assertions_on_constants::ASSERTIONS_ON_CONSTANTS),
-LintId::of(assign_ops::ASSIGN_OP_PATTERN),
-LintId::of(blacklisted_name::BLACKLISTED_NAME),
-LintId::of(blocks_in_if_conditions::BLOCKS_IN_IF_CONDITIONS),
-LintId::of(bool_assert_comparison::BOOL_ASSERT_COMPARISON),
-LintId::of(casts::FN_TO_NUMERIC_CAST),
-LintId::of(casts::FN_TO_NUMERIC_CAST_WITH_TRUNCATION),
-LintId::of(collapsible_if::COLLAPSIBLE_ELSE_IF),
-LintId::of(collapsible_if::COLLAPSIBLE_IF),
-LintId::of(collapsible_match::COLLAPSIBLE_MATCH),
-LintId::of(comparison_chain::COMPARISON_CHAIN),
-LintId::of(default::FIELD_REASSIGN_WITH_DEFAULT),
-LintId::of(doc::MISSING_SAFETY_DOC),
-LintId::of(doc::NEEDLESS_DOCTEST_MAIN),
-LintId::of(enum_variants::ENUM_VARIANT_NAMES),
-LintId::of(enum_variants::MODULE_INCEPTION),
-LintId::of(eq_op::OP_REF),
-LintId::of(eta_reduction::REDUNDANT_CLOSURE),
-LintId::of(float_literal::EXCESSIVE_PRECISION),
-LintId::of(from_over_into::FROM_OVER_INTO),
-LintId::of(from_str_radix_10::FROM_STR_RADIX_10),
-LintId::of(functions::DOUBLE_MUST_USE),
-LintId::of(functions::MUST_USE_UNIT),
-LintId::of(functions::RESULT_UNIT_ERR),
-LintId::of(if_then_panic::IF_THEN_PANIC),
-LintId::of(inherent_to_string::INHERENT_TO_STRING),
-LintId::of(len_zero::COMPARISON_TO_EMPTY),
-LintId::of(len_zero::LEN_WITHOUT_IS_EMPTY),
-LintId::of(len_zero::LEN_ZERO),
-LintId::of(literal_representation::INCONSISTENT_DIGIT_GROUPING),
-LintId::of(literal_representation::UNUSUAL_BYTE_GROUPINGS),
-LintId::of(loops::FOR_KV_MAP),
-LintId::of(loops::NEEDLESS_RANGE_LOOP),
-LintId::of(loops::SAME_ITEM_PUSH),
-LintId::of(loops::WHILE_LET_ON_ITERATOR),
-LintId::of(main_recursion::MAIN_RECURSION),
-LintId::of(manual_async_fn::MANUAL_ASYNC_FN),
-LintId::of(manual_map::MANUAL_MAP),
-LintId::of(manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE),
-LintId::of(map_clone::MAP_CLONE),
-LintId::of(match_result_ok::MATCH_RESULT_OK),
-LintId::of(matches::INFALLIBLE_DESTRUCTURING_MATCH),
-LintId::of(matches::MATCH_LIKE_MATCHES_MACRO),
-LintId::of(matches::MATCH_OVERLAPPING_ARM),
-LintId::of(matches::MATCH_REF_PATS),
-LintId::of(matches::REDUNDANT_PATTERN_MATCHING),
-LintId::of(matches::SINGLE_MATCH),
-LintId::of(mem_replace::MEM_REPLACE_OPTION_WITH_NONE),
-LintId::of(mem_replace::MEM_REPLACE_WITH_DEFAULT),
-LintId::of(methods::BYTES_NTH),
-LintId::of(methods::CHARS_LAST_CMP),
-LintId::of(methods::CHARS_NEXT_CMP),
-LintId::of(methods::INTO_ITER_ON_REF),
-LintId::of(methods::ITER_CLONED_COLLECT),
-LintId::of(methods::ITER_NEXT_SLICE),
-LintId::of(methods::ITER_NTH_ZERO),
-LintId::of(methods::ITER_SKIP_NEXT),
-LintId::of(methods::MANUAL_SATURATING_ARITHMETIC),
-LintId::of(methods::MAP_COLLECT_RESULT_UNIT),
-LintId::of(methods::NEW_RET_NO_SELF),
-LintId::of(methods::OK_EXPECT),
-LintId::of(methods::OPTION_MAP_OR_NONE),
-LintId::of(methods::RESULT_MAP_OR_INTO_OPTION),
-LintId::of(methods::SHOULD_IMPLEMENT_TRAIT),
-LintId::of(methods::SINGLE_CHAR_ADD_STR),
-LintId::of(methods::STRING_EXTEND_CHARS),
-LintId::of(methods::UNNECESSARY_FOLD),
-LintId::of(methods::UNNECESSARY_LAZY_EVALUATIONS),
-LintId::of(methods::UNWRAP_OR_ELSE_DEFAULT),
-LintId::of(methods::WRONG_SELF_CONVENTION),
-LintId::of(misc::TOPLEVEL_REF_ARG),
-LintId::of(misc::ZERO_PTR),
-LintId::of(misc_early::BUILTIN_TYPE_SHADOW),
-LintId::of(misc_early::DOUBLE_NEG),
-LintId::of(misc_early::DUPLICATE_UNDERSCORE_ARGUMENT),
-LintId::of(misc_early::MIXED_CASE_HEX_LITERALS),
-LintId::of(misc_early::REDUNDANT_PATTERN),
-LintId::of(mut_mutex_lock::MUT_MUTEX_LOCK),
-LintId::of(mut_reference::UNNECESSARY_MUT_PASSED),
-LintId::of(needless_borrow::NEEDLESS_BORROW),
-LintId::of(neg_multiply::NEG_MULTIPLY),
-LintId::of(new_without_default::NEW_WITHOUT_DEFAULT),
-LintId::of(non_copy_const::BORROW_INTERIOR_MUTABLE_CONST),
-LintId::of(non_copy_const::DECLARE_INTERIOR_MUTABLE_CONST),
-LintId::of(non_expressive_names::JUST_UNDERSCORES_AND_DIGITS),
-LintId::of(ptr::CMP_NULL),
-LintId::of(ptr::PTR_ARG),
-LintId::of(ptr_eq::PTR_EQ),
-LintId::of(question_mark::QUESTION_MARK),
-LintId::of(ranges::MANUAL_RANGE_CONTAINS),
-LintId::of(redundant_field_names::REDUNDANT_FIELD_NAMES),
-LintId::of(redundant_static_lifetimes::REDUNDANT_STATIC_LIFETIMES),
-LintId::of(returns::LET_AND_RETURN),
-LintId::of(returns::NEEDLESS_RETURN),
-LintId::of(self_named_constructors::SELF_NAMED_CONSTRUCTORS),
-LintId::of(single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS),
-LintId::of(tabs_in_doc_comments::TABS_IN_DOC_COMMENTS),
-LintId::of(to_digit_is_some::TO_DIGIT_IS_SOME),
-LintId::of(try_err::TRY_ERR),
-LintId::of(unsafe_removed_from_name::UNSAFE_REMOVED_FROM_NAME),
-LintId::of(unused_unit::UNUSED_UNIT),
-LintId::of(upper_case_acronyms::UPPER_CASE_ACRONYMS),
-LintId::of(write::PRINTLN_EMPTY_STRING),
-LintId::of(write::PRINT_LITERAL),
-LintId::of(write::PRINT_WITH_NEWLINE),
-LintId::of(write::WRITELN_EMPTY_STRING),
-LintId::of(write::WRITE_LITERAL),
-LintId::of(write::WRITE_WITH_NEWLINE),
-])
\ No newline at end of file
+    LintId::of(assertions_on_constants::ASSERTIONS_ON_CONSTANTS),
+    LintId::of(assign_ops::ASSIGN_OP_PATTERN),
+    LintId::of(blacklisted_name::BLACKLISTED_NAME),
+    LintId::of(blocks_in_if_conditions::BLOCKS_IN_IF_CONDITIONS),
+    LintId::of(bool_assert_comparison::BOOL_ASSERT_COMPARISON),
+    LintId::of(casts::FN_TO_NUMERIC_CAST),
+    LintId::of(casts::FN_TO_NUMERIC_CAST_WITH_TRUNCATION),
+    LintId::of(collapsible_if::COLLAPSIBLE_ELSE_IF),
+    LintId::of(collapsible_if::COLLAPSIBLE_IF),
+    LintId::of(collapsible_match::COLLAPSIBLE_MATCH),
+    LintId::of(comparison_chain::COMPARISON_CHAIN),
+    LintId::of(default::FIELD_REASSIGN_WITH_DEFAULT),
+    LintId::of(doc::MISSING_SAFETY_DOC),
+    LintId::of(doc::NEEDLESS_DOCTEST_MAIN),
+    LintId::of(enum_variants::ENUM_VARIANT_NAMES),
+    LintId::of(enum_variants::MODULE_INCEPTION),
+    LintId::of(eq_op::OP_REF),
+    LintId::of(eta_reduction::REDUNDANT_CLOSURE),
+    LintId::of(float_literal::EXCESSIVE_PRECISION),
+    LintId::of(from_over_into::FROM_OVER_INTO),
+    LintId::of(from_str_radix_10::FROM_STR_RADIX_10),
+    LintId::of(functions::DOUBLE_MUST_USE),
+    LintId::of(functions::MUST_USE_UNIT),
+    LintId::of(functions::RESULT_UNIT_ERR),
+    LintId::of(if_then_panic::IF_THEN_PANIC),
+    LintId::of(inherent_to_string::INHERENT_TO_STRING),
+    LintId::of(len_zero::COMPARISON_TO_EMPTY),
+    LintId::of(len_zero::LEN_WITHOUT_IS_EMPTY),
+    LintId::of(len_zero::LEN_ZERO),
+    LintId::of(literal_representation::INCONSISTENT_DIGIT_GROUPING),
+    LintId::of(literal_representation::UNUSUAL_BYTE_GROUPINGS),
+    LintId::of(loops::FOR_KV_MAP),
+    LintId::of(loops::NEEDLESS_RANGE_LOOP),
+    LintId::of(loops::SAME_ITEM_PUSH),
+    LintId::of(loops::WHILE_LET_ON_ITERATOR),
+    LintId::of(main_recursion::MAIN_RECURSION),
+    LintId::of(manual_async_fn::MANUAL_ASYNC_FN),
+    LintId::of(manual_map::MANUAL_MAP),
+    LintId::of(manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE),
+    LintId::of(map_clone::MAP_CLONE),
+    LintId::of(match_result_ok::MATCH_RESULT_OK),
+    LintId::of(matches::INFALLIBLE_DESTRUCTURING_MATCH),
+    LintId::of(matches::MATCH_LIKE_MATCHES_MACRO),
+    LintId::of(matches::MATCH_OVERLAPPING_ARM),
+    LintId::of(matches::MATCH_REF_PATS),
+    LintId::of(matches::REDUNDANT_PATTERN_MATCHING),
+    LintId::of(matches::SINGLE_MATCH),
+    LintId::of(mem_replace::MEM_REPLACE_OPTION_WITH_NONE),
+    LintId::of(mem_replace::MEM_REPLACE_WITH_DEFAULT),
+    LintId::of(methods::BYTES_NTH),
+    LintId::of(methods::CHARS_LAST_CMP),
+    LintId::of(methods::CHARS_NEXT_CMP),
+    LintId::of(methods::INTO_ITER_ON_REF),
+    LintId::of(methods::ITER_CLONED_COLLECT),
+    LintId::of(methods::ITER_NEXT_SLICE),
+    LintId::of(methods::ITER_NTH_ZERO),
+    LintId::of(methods::ITER_SKIP_NEXT),
+    LintId::of(methods::MANUAL_SATURATING_ARITHMETIC),
+    LintId::of(methods::MAP_COLLECT_RESULT_UNIT),
+    LintId::of(methods::NEW_RET_NO_SELF),
+    LintId::of(methods::OK_EXPECT),
+    LintId::of(methods::OPTION_MAP_OR_NONE),
+    LintId::of(methods::RESULT_MAP_OR_INTO_OPTION),
+    LintId::of(methods::SHOULD_IMPLEMENT_TRAIT),
+    LintId::of(methods::SINGLE_CHAR_ADD_STR),
+    LintId::of(methods::STRING_EXTEND_CHARS),
+    LintId::of(methods::UNNECESSARY_FOLD),
+    LintId::of(methods::UNNECESSARY_LAZY_EVALUATIONS),
+    LintId::of(methods::UNWRAP_OR_ELSE_DEFAULT),
+    LintId::of(methods::WRONG_SELF_CONVENTION),
+    LintId::of(misc::TOPLEVEL_REF_ARG),
+    LintId::of(misc::ZERO_PTR),
+    LintId::of(misc_early::BUILTIN_TYPE_SHADOW),
+    LintId::of(misc_early::DOUBLE_NEG),
+    LintId::of(misc_early::DUPLICATE_UNDERSCORE_ARGUMENT),
+    LintId::of(misc_early::MIXED_CASE_HEX_LITERALS),
+    LintId::of(misc_early::REDUNDANT_PATTERN),
+    LintId::of(mut_mutex_lock::MUT_MUTEX_LOCK),
+    LintId::of(mut_reference::UNNECESSARY_MUT_PASSED),
+    LintId::of(needless_borrow::NEEDLESS_BORROW),
+    LintId::of(neg_multiply::NEG_MULTIPLY),
+    LintId::of(new_without_default::NEW_WITHOUT_DEFAULT),
+    LintId::of(non_copy_const::BORROW_INTERIOR_MUTABLE_CONST),
+    LintId::of(non_copy_const::DECLARE_INTERIOR_MUTABLE_CONST),
+    LintId::of(non_expressive_names::JUST_UNDERSCORES_AND_DIGITS),
+    LintId::of(ptr::CMP_NULL),
+    LintId::of(ptr::PTR_ARG),
+    LintId::of(ptr_eq::PTR_EQ),
+    LintId::of(question_mark::QUESTION_MARK),
+    LintId::of(ranges::MANUAL_RANGE_CONTAINS),
+    LintId::of(redundant_field_names::REDUNDANT_FIELD_NAMES),
+    LintId::of(redundant_static_lifetimes::REDUNDANT_STATIC_LIFETIMES),
+    LintId::of(returns::LET_AND_RETURN),
+    LintId::of(returns::NEEDLESS_RETURN),
+    LintId::of(self_named_constructors::SELF_NAMED_CONSTRUCTORS),
+    LintId::of(single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS),
+    LintId::of(tabs_in_doc_comments::TABS_IN_DOC_COMMENTS),
+    LintId::of(to_digit_is_some::TO_DIGIT_IS_SOME),
+    LintId::of(try_err::TRY_ERR),
+    LintId::of(unsafe_removed_from_name::UNSAFE_REMOVED_FROM_NAME),
+    LintId::of(unused_unit::UNUSED_UNIT),
+    LintId::of(upper_case_acronyms::UPPER_CASE_ACRONYMS),
+    LintId::of(write::PRINTLN_EMPTY_STRING),
+    LintId::of(write::PRINT_LITERAL),
+    LintId::of(write::PRINT_WITH_NEWLINE),
+    LintId::of(write::WRITELN_EMPTY_STRING),
+    LintId::of(write::WRITE_LITERAL),
+    LintId::of(write::WRITE_WITH_NEWLINE),
+])
diff --git a/clippy_lints/src/lib.register_suspicious.rs b/clippy_lints/src/lib.register_suspicious.rs
index c424efe69b3..8859787fbc8 100644
--- a/clippy_lints/src/lib.register_suspicious.rs
+++ b/clippy_lints/src/lib.register_suspicious.rs
@@ -3,18 +3,18 @@
 // Manual edits will be overwritten.
 
 store.register_group(true, "clippy::suspicious", Some("clippy_suspicious"), vec![
-LintId::of(assign_ops::MISREFACTORED_ASSIGN_OP),
-LintId::of(attrs::BLANKET_CLIPPY_RESTRICTION_LINTS),
-LintId::of(eval_order_dependence::EVAL_ORDER_DEPENDENCE),
-LintId::of(float_equality_without_abs::FLOAT_EQUALITY_WITHOUT_ABS),
-LintId::of(formatting::SUSPICIOUS_ASSIGNMENT_FORMATTING),
-LintId::of(formatting::SUSPICIOUS_ELSE_FORMATTING),
-LintId::of(formatting::SUSPICIOUS_UNARY_OP_FORMATTING),
-LintId::of(loops::EMPTY_LOOP),
-LintId::of(loops::FOR_LOOPS_OVER_FALLIBLES),
-LintId::of(loops::MUT_RANGE_BOUND),
-LintId::of(methods::SUSPICIOUS_MAP),
-LintId::of(mut_key::MUTABLE_KEY_TYPE),
-LintId::of(suspicious_trait_impl::SUSPICIOUS_ARITHMETIC_IMPL),
-LintId::of(suspicious_trait_impl::SUSPICIOUS_OP_ASSIGN_IMPL),
-])
\ No newline at end of file
+    LintId::of(assign_ops::MISREFACTORED_ASSIGN_OP),
+    LintId::of(attrs::BLANKET_CLIPPY_RESTRICTION_LINTS),
+    LintId::of(eval_order_dependence::EVAL_ORDER_DEPENDENCE),
+    LintId::of(float_equality_without_abs::FLOAT_EQUALITY_WITHOUT_ABS),
+    LintId::of(formatting::SUSPICIOUS_ASSIGNMENT_FORMATTING),
+    LintId::of(formatting::SUSPICIOUS_ELSE_FORMATTING),
+    LintId::of(formatting::SUSPICIOUS_UNARY_OP_FORMATTING),
+    LintId::of(loops::EMPTY_LOOP),
+    LintId::of(loops::FOR_LOOPS_OVER_FALLIBLES),
+    LintId::of(loops::MUT_RANGE_BOUND),
+    LintId::of(methods::SUSPICIOUS_MAP),
+    LintId::of(mut_key::MUTABLE_KEY_TYPE),
+    LintId::of(suspicious_trait_impl::SUSPICIOUS_ARITHMETIC_IMPL),
+    LintId::of(suspicious_trait_impl::SUSPICIOUS_OP_ASSIGN_IMPL),
+])
-- 
cgit 1.4.1-3-g733a5


From 56f0c9afdd4d85859e814e5dee503fd76cc3b2a2 Mon Sep 17 00:00:00 2001
From: surechen <chenshuo17@huawei.com>
Date: Thu, 16 Sep 2021 16:42:36 +0800
Subject: fix bug for large_enum_variants

---
 clippy_lints/src/large_enum_variant.rs | 161 ++++++++++++++++++++-------------
 tests/ui/large_enum_variant.rs         |  18 ++++
 tests/ui/large_enum_variant.stderr     |  63 +++++++++++--
 3 files changed, 171 insertions(+), 71 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/large_enum_variant.rs b/clippy_lints/src/large_enum_variant.rs
index e4b8e754628..392166237be 100644
--- a/clippy_lints/src/large_enum_variant.rs
+++ b/clippy_lints/src/large_enum_variant.rs
@@ -1,13 +1,14 @@
 //! lint when there is a large size difference between variants on an enum
 
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::source::snippet_opt;
+use clippy_utils::source::snippet_with_applicability;
 use rustc_errors::Applicability;
-use rustc_hir::{Item, ItemKind, VariantData};
+use rustc_hir::{Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::layout::LayoutOf;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::source_map::Span;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -58,6 +59,17 @@ impl LargeEnumVariant {
     }
 }
 
+struct FieldInfo {
+    ind: usize,
+    size: u64,
+}
+
+struct VariantInfo {
+    ind: usize,
+    size: u64,
+    fields_size: Vec<FieldInfo>,
+}
+
 impl_lint_pass!(LargeEnumVariant => [LARGE_ENUM_VARIANT]);
 
 impl<'tcx> LateLintPass<'tcx> for LargeEnumVariant {
@@ -68,72 +80,95 @@ impl<'tcx> LateLintPass<'tcx> for LargeEnumVariant {
         if let ItemKind::Enum(ref def, _) = item.kind {
             let ty = cx.tcx.type_of(item.def_id);
             let adt = ty.ty_adt_def().expect("already checked whether this is an enum");
-
-            let mut largest_variant: Option<(_, _)> = None;
-            let mut second_variant: Option<(_, _)> = None;
-
-            for (i, variant) in adt.variants.iter().enumerate() {
-                let size: u64 = variant
-                    .fields
-                    .iter()
-                    .filter_map(|f| {
-                        let ty = cx.tcx.type_of(f.did);
-                        // don't count generics by filtering out everything
-                        // that does not have a layout
-                        cx.layout_of(ty).ok().map(|l| l.size.bytes())
-                    })
-                    .sum();
-
-                let grouped = (size, (i, variant));
-
-                if grouped.0 >= largest_variant.map_or(0, |x| x.0) {
-                    second_variant = largest_variant;
-                    largest_variant = Some(grouped);
-                }
+            if adt.variants.len() <= 1 {
+                return;
             }
+            let mut variants_size: Vec<VariantInfo> = adt
+                .variants
+                .iter()
+                .enumerate()
+                .map(|(i, variant)| {
+                    let mut fields_size = Vec::new();
+                    let size: u64 = variant
+                        .fields
+                        .iter()
+                        .enumerate()
+                        .filter_map(|(i, f)| {
+                            let ty = cx.tcx.type_of(f.did);
+                            // don't count generics by filtering out everything
+                            // that does not have a layout
+                            cx.layout_of(ty).ok().map(|l| {
+                                let size = l.size.bytes();
+                                fields_size.push(FieldInfo { ind: i, size });
+                                size
+                            })
+                        })
+                        .sum();
+                    VariantInfo {
+                        ind: i,
+                        size,
+                        fields_size,
+                    }
+                })
+                .collect();
 
-            if let (Some(largest), Some(second)) = (largest_variant, second_variant) {
-                let difference = largest.0 - second.0;
+            variants_size.sort_by(|a, b| (b.size.cmp(&a.size)));
 
-                if difference > self.maximum_size_difference_allowed {
-                    let (i, variant) = largest.1;
+            let mut difference = variants_size[0].size - variants_size[1].size;
+            if difference > self.maximum_size_difference_allowed {
+                let help_text = "consider boxing the large fields to reduce the total size of the enum";
+                span_lint_and_then(
+                    cx,
+                    LARGE_ENUM_VARIANT,
+                    def.variants[variants_size[0].ind].span,
+                    "large size difference between variants",
+                    |diag| {
+                        diag.span_label(
+                            def.variants[variants_size[0].ind].span,
+                            &format!("this variant is {} bytes", variants_size[0].size),
+                        );
+                        diag.span_note(
+                            def.variants[variants_size[1].ind].span,
+                            &format!("and the second-largest variant is {} bytes:", variants_size[1].size),
+                        );
 
-                    let help_text = "consider boxing the large fields to reduce the total size of the enum";
-                    span_lint_and_then(
-                        cx,
-                        LARGE_ENUM_VARIANT,
-                        def.variants[i].span,
-                        "large size difference between variants",
-                        |diag| {
-                            diag.span_label(
-                                def.variants[(largest.1).0].span,
-                                &format!("this variant is {} bytes", largest.0),
-                            );
-                            diag.span_note(
-                                def.variants[(second.1).0].span,
-                                &format!("and the second-largest variant is {} bytes:", second.0),
-                            );
-                            if variant.fields.len() == 1 {
-                                let span = match def.variants[i].data {
-                                    VariantData::Struct(fields, ..) | VariantData::Tuple(fields, ..) => {
-                                        fields[0].ty.span
-                                    },
-                                    VariantData::Unit(..) => unreachable!(),
-                                };
-                                if let Some(snip) = snippet_opt(cx, span) {
-                                    diag.span_suggestion(
-                                        span,
-                                        help_text,
-                                        format!("Box<{}>", snip),
-                                        Applicability::MaybeIncorrect,
-                                    );
-                                    return;
+                        let fields = def.variants[variants_size[0].ind].data.fields();
+                        variants_size[0].fields_size.sort_by(|a, b| (a.size.cmp(&b.size)));
+                        let mut applicability = Applicability::MaybeIncorrect;
+                        let sugg: Vec<(Span, String)> = variants_size[0]
+                            .fields_size
+                            .iter()
+                            .rev()
+                            .map_while(|val| {
+                                if difference > self.maximum_size_difference_allowed {
+                                    difference = difference.saturating_sub(val.size);
+                                    Some((
+                                        fields[val.ind].ty.span,
+                                        format!(
+                                            "Box<{}>",
+                                            snippet_with_applicability(
+                                                cx,
+                                                fields[val.ind].ty.span,
+                                                "..",
+                                                &mut applicability
+                                            )
+                                            .into_owned()
+                                        ),
+                                    ))
+                                } else {
+                                    None
                                 }
-                            }
-                            diag.span_help(def.variants[i].span, help_text);
-                        },
-                    );
-                }
+                            })
+                            .collect();
+
+                        if !sugg.is_empty() {
+                            diag.multipart_suggestion(help_text, sugg, Applicability::MaybeIncorrect);
+                            return;
+                        }
+
+                        diag.span_help(def.variants[variants_size[0].ind].span, help_text);
+                    },
+                );
             }
         }
     }
diff --git a/tests/ui/large_enum_variant.rs b/tests/ui/large_enum_variant.rs
index d22fee3f27b..b45cc849eae 100644
--- a/tests/ui/large_enum_variant.rs
+++ b/tests/ui/large_enum_variant.rs
@@ -35,6 +35,7 @@ enum LargeEnum2 {
     VariantOk(i32, u32),
     ContainingLargeEnum(LargeEnum),
 }
+
 enum LargeEnum3 {
     ContainingMoreThanOneField(i32, [i32; 8000], [i32; 9500]),
     VoidVariant,
@@ -56,6 +57,23 @@ enum LargeEnumOk {
     LargeB([i32; 8001]),
 }
 
+enum LargeEnum6 {
+    A,
+    B([u8; 255]),
+    C([u8; 200]),
+}
+
+enum LargeEnum7 {
+    A,
+    B([u8; 1255]),
+    C([u8; 200]),
+}
+
+enum LargeEnum8 {
+    VariantOk(i32, u32),
+    ContainingMoreThanOneField([i32; 8000], [i32; 2], [i32; 9500], [i32; 30]),
+}
+
 fn main() {
     large_enum_variant!();
 }
diff --git a/tests/ui/large_enum_variant.stderr b/tests/ui/large_enum_variant.stderr
index 0eac28fbd35..899f97ce2e1 100644
--- a/tests/ui/large_enum_variant.stderr
+++ b/tests/ui/large_enum_variant.stderr
@@ -32,30 +32,45 @@ LL |     ContainingLargeEnum(Box<LargeEnum>),
    |                         ~~~~~~~~~~~~~~
 
 error: large size difference between variants
-  --> $DIR/large_enum_variant.rs:46:5
+  --> $DIR/large_enum_variant.rs:40:5
+   |
+LL |     ContainingMoreThanOneField(i32, [i32; 8000], [i32; 9500]),
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this variant is 70004 bytes
+   |
+note: and the second-largest variant is 8 bytes:
+  --> $DIR/large_enum_variant.rs:42:5
+   |
+LL |     StructLikeLittle { x: i32, y: i32 },
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+help: consider boxing the large fields to reduce the total size of the enum
+   |
+LL |     ContainingMoreThanOneField(i32, Box<[i32; 8000]>, Box<[i32; 9500]>),
+   |                                     ~~~~~~~~~~~~~~~~  ~~~~~~~~~~~~~~~~
+
+error: large size difference between variants
+  --> $DIR/large_enum_variant.rs:47:5
    |
 LL |     StructLikeLarge { x: [i32; 8000], y: i32 },
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this variant is 32004 bytes
    |
 note: and the second-largest variant is 8 bytes:
-  --> $DIR/large_enum_variant.rs:45:5
+  --> $DIR/large_enum_variant.rs:46:5
    |
 LL |     VariantOk(i32, u32),
    |     ^^^^^^^^^^^^^^^^^^^
 help: consider boxing the large fields to reduce the total size of the enum
-  --> $DIR/large_enum_variant.rs:46:5
    |
-LL |     StructLikeLarge { x: [i32; 8000], y: i32 },
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |     StructLikeLarge { x: Box<[i32; 8000]>, y: i32 },
+   |                          ~~~~~~~~~~~~~~~~
 
 error: large size difference between variants
-  --> $DIR/large_enum_variant.rs:51:5
+  --> $DIR/large_enum_variant.rs:52:5
    |
 LL |     StructLikeLarge2 { x: [i32; 8000] },
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this variant is 32000 bytes
    |
 note: and the second-largest variant is 8 bytes:
-  --> $DIR/large_enum_variant.rs:50:5
+  --> $DIR/large_enum_variant.rs:51:5
    |
 LL |     VariantOk(i32, u32),
    |     ^^^^^^^^^^^^^^^^^^^
@@ -64,5 +79,37 @@ help: consider boxing the large fields to reduce the total size of the enum
 LL |     StructLikeLarge2 { x: Box<[i32; 8000]> },
    |                           ~~~~~~~~~~~~~~~~
 
-error: aborting due to 4 previous errors
+error: large size difference between variants
+  --> $DIR/large_enum_variant.rs:68:5
+   |
+LL |     B([u8; 1255]),
+   |     ^^^^^^^^^^^^^ this variant is 1255 bytes
+   |
+note: and the second-largest variant is 200 bytes:
+  --> $DIR/large_enum_variant.rs:69:5
+   |
+LL |     C([u8; 200]),
+   |     ^^^^^^^^^^^^
+help: consider boxing the large fields to reduce the total size of the enum
+   |
+LL |     B(Box<[u8; 1255]>),
+   |       ~~~~~~~~~~~~~~~
+
+error: large size difference between variants
+  --> $DIR/large_enum_variant.rs:74:5
+   |
+LL |     ContainingMoreThanOneField([i32; 8000], [i32; 2], [i32; 9500], [i32; 30]),
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this variant is 70128 bytes
+   |
+note: and the second-largest variant is 8 bytes:
+  --> $DIR/large_enum_variant.rs:73:5
+   |
+LL |     VariantOk(i32, u32),
+   |     ^^^^^^^^^^^^^^^^^^^
+help: consider boxing the large fields to reduce the total size of the enum
+   |
+LL |     ContainingMoreThanOneField(Box<[i32; 8000]>, [i32; 2], Box<[i32; 9500]>, [i32; 30]),
+   |                                ~~~~~~~~~~~~~~~~            ~~~~~~~~~~~~~~~~
+
+error: aborting due to 7 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 4babfae9cba0409d2eed2c5caa623fae0445a50e Mon Sep 17 00:00:00 2001
From: surechen <chenshuo17@huawei.com>
Date: Thu, 30 Sep 2021 19:06:42 +0800
Subject: fix issue #7731

Make if_then_else handle situation of cond.kind = ExprKind::DropTemps(ExprKind::Binary(BinOpKind::And || BinOpKind::Or, left, right), ..) =
---
 clippy_lints/src/if_then_panic.rs | 38 ++++++++++++++++++++++++++++++-----
 tests/ui/if_then_panic.fixed      |  6 ++++++
 tests/ui/if_then_panic.rs         | 16 +++++++++++++++
 tests/ui/if_then_panic.stderr     | 42 ++++++++++++++++++++++++++++++++++++++-
 4 files changed, 96 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/if_then_panic.rs b/clippy_lints/src/if_then_panic.rs
index ee575c81a8b..31e416bd4d6 100644
--- a/clippy_lints/src/if_then_panic.rs
+++ b/clippy_lints/src/if_then_panic.rs
@@ -3,7 +3,7 @@ use clippy_utils::higher::PanicExpn;
 use clippy_utils::is_expn_of;
 use clippy_utils::source::snippet_with_applicability;
 use rustc_errors::Applicability;
-use rustc_hir::{Block, Expr, ExprKind, StmtKind, UnOp};
+use rustc_hir::{BinOpKind, Block, Expr, ExprKind, StmtKind, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
@@ -74,10 +74,38 @@ impl LateLintPass<'_> for IfThenPanic {
                 };
                 let mut applicability = Applicability::MachineApplicable;
                 let sugg = snippet_with_applicability(cx, span, "..", &mut applicability);
-
-                let cond_sugg =
-                if let ExprKind::DropTemps(Expr{kind: ExprKind::Unary(UnOp::Not, not_expr), ..}) = cond.kind {
-                    snippet_with_applicability(cx, not_expr.span, "..", &mut applicability).to_string()
+                //let mut cond_sugg = format!("!{}", snippet_with_applicability(cx, cond.span, "..", &mut applicability));
+                let cond_sugg = if let ExprKind::DropTemps(e, ..) = cond.kind {
+                    if let Expr{kind: ExprKind::Unary(UnOp::Not, not_expr), ..} = e {
+                        snippet_with_applicability(cx, not_expr.span, "..", &mut applicability).to_string()
+                    } else if let Expr{kind: ExprKind::Binary(op, left, right), ..} = e {//BinOp{BinOpKind::And, ..}
+                        match op.node {
+                            BinOpKind::And | BinOpKind::Or => {
+                                let left_span =  {
+                                    if let Expr{kind: ExprKind::Unary(UnOp::Not, not_expr), ..} = left {
+                                        snippet_with_applicability(cx, not_expr.span, "..", &mut applicability).to_string()
+                                    } else {
+                                        format!("!{}", snippet_with_applicability(cx, left.span, "..", &mut applicability))
+                                    }
+                                };
+                                let right_span = {
+                                    if let Expr{kind: ExprKind::Unary(UnOp::Not, not_expr), ..} = right {
+                                        snippet_with_applicability(cx, not_expr.span, "..", &mut applicability).to_string()
+                                    } else {
+                                        format!("!{}", snippet_with_applicability(cx, right.span, "..", &mut applicability))
+                                    }
+                                };
+                                if op.node == BinOpKind::And {
+                                  format!("{} || {}", left_span, right_span)
+                                } else  {
+                                  format!("{} && {}", left_span, right_span)
+                                }
+                            }
+                            _ => format!("!({})", snippet_with_applicability(cx, cond.span, "..", &mut applicability))
+                        }
+                    } else {
+                        format!("!{}", snippet_with_applicability(cx, cond.span, "..", &mut applicability))
+                    }
                 } else {
                     format!("!{}", snippet_with_applicability(cx, cond.span, "..", &mut applicability))
                 };
diff --git a/tests/ui/if_then_panic.fixed b/tests/ui/if_then_panic.fixed
index fc57ae0dfa5..f72bc6f5979 100644
--- a/tests/ui/if_then_panic.fixed
+++ b/tests/ui/if_then_panic.fixed
@@ -31,4 +31,10 @@ fn main() {
     } else {
         println!("qwq");
     }
+    let b = vec![1, 2, 3];
+    assert!(!b.is_empty(), "panic1");
+    assert!(!b.is_empty() || !a.is_empty(), "panic2");
+    assert!(!a.is_empty() || b.is_empty(), "panic3");
+    assert!(!b.is_empty() && !a.is_empty(), "panic4");
+    assert!(!a.is_empty() && b.is_empty(), "panic5");
 }
diff --git a/tests/ui/if_then_panic.rs b/tests/ui/if_then_panic.rs
index d1ac93d8d41..10433c8d54f 100644
--- a/tests/ui/if_then_panic.rs
+++ b/tests/ui/if_then_panic.rs
@@ -35,4 +35,20 @@ fn main() {
     } else {
         println!("qwq");
     }
+    let b = vec![1, 2, 3];
+    if b.is_empty() {
+        panic!("panic1");
+    }
+    if b.is_empty() && a.is_empty() {
+        panic!("panic2");
+    }
+    if a.is_empty() && !b.is_empty() {
+        panic!("panic3");
+    }
+    if b.is_empty() || a.is_empty() {
+        panic!("panic4");
+    }
+    if a.is_empty() || !b.is_empty() {
+        panic!("panic5");
+    }
 }
diff --git a/tests/ui/if_then_panic.stderr b/tests/ui/if_then_panic.stderr
index b92c9bdf674..502ba10b8f4 100644
--- a/tests/ui/if_then_panic.stderr
+++ b/tests/ui/if_then_panic.stderr
@@ -16,5 +16,45 @@ LL | |         panic!("qwqwq");
 LL | |     }
    | |_____^ help: try: `assert!(a.is_empty(), "qwqwq");`
 
-error: aborting due to 2 previous errors
+error: only a `panic!` in `if`-then statement
+  --> $DIR/if_then_panic.rs:39:5
+   |
+LL | /     if b.is_empty() {
+LL | |         panic!("panic1");
+LL | |     }
+   | |_____^ help: try: `assert!(!b.is_empty(), "panic1");`
+
+error: only a `panic!` in `if`-then statement
+  --> $DIR/if_then_panic.rs:42:5
+   |
+LL | /     if b.is_empty() && a.is_empty() {
+LL | |         panic!("panic2");
+LL | |     }
+   | |_____^ help: try: `assert!(!b.is_empty() || !a.is_empty(), "panic2");`
+
+error: only a `panic!` in `if`-then statement
+  --> $DIR/if_then_panic.rs:45:5
+   |
+LL | /     if a.is_empty() && !b.is_empty() {
+LL | |         panic!("panic3");
+LL | |     }
+   | |_____^ help: try: `assert!(!a.is_empty() || b.is_empty(), "panic3");`
+
+error: only a `panic!` in `if`-then statement
+  --> $DIR/if_then_panic.rs:48:5
+   |
+LL | /     if b.is_empty() || a.is_empty() {
+LL | |         panic!("panic4");
+LL | |     }
+   | |_____^ help: try: `assert!(!b.is_empty() && !a.is_empty(), "panic4");`
+
+error: only a `panic!` in `if`-then statement
+  --> $DIR/if_then_panic.rs:51:5
+   |
+LL | /     if a.is_empty() || !b.is_empty() {
+LL | |         panic!("panic5");
+LL | |     }
+   | |_____^ help: try: `assert!(!a.is_empty() && b.is_empty(), "panic5");`
+
+error: aborting due to 7 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 89f77f351245d207068e48b260f154d9c5dc349b Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Sat, 25 Sep 2021 17:14:34 -0500
Subject: Move shadow_unrelated to restriction

---
 clippy_lints/src/lib.register_pedantic.rs    | 1 -
 clippy_lints/src/lib.register_restriction.rs | 1 +
 clippy_lints/src/shadow.rs                   | 2 +-
 3 files changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.register_pedantic.rs b/clippy_lints/src/lib.register_pedantic.rs
index 334e058c4ae..6533b94e82b 100644
--- a/clippy_lints/src/lib.register_pedantic.rs
+++ b/clippy_lints/src/lib.register_pedantic.rs
@@ -81,7 +81,6 @@ store.register_group(true, "clippy::pedantic", Some("clippy_pedantic"), vec![
     LintId::of(redundant_else::REDUNDANT_ELSE),
     LintId::of(ref_option_ref::REF_OPTION_REF),
     LintId::of(semicolon_if_nothing_returned::SEMICOLON_IF_NOTHING_RETURNED),
-    LintId::of(shadow::SHADOW_UNRELATED),
     LintId::of(strings::STRING_ADD_ASSIGN),
     LintId::of(trait_bounds::TRAIT_DUPLICATION_IN_BOUNDS),
     LintId::of(trait_bounds::TYPE_REPETITION_IN_BOUNDS),
diff --git a/clippy_lints/src/lib.register_restriction.rs b/clippy_lints/src/lib.register_restriction.rs
index 530662dfc0c..4463dea5fcb 100644
--- a/clippy_lints/src/lib.register_restriction.rs
+++ b/clippy_lints/src/lib.register_restriction.rs
@@ -50,6 +50,7 @@ store.register_group(true, "clippy::restriction", Some("clippy_restriction"), ve
     LintId::of(same_name_method::SAME_NAME_METHOD),
     LintId::of(shadow::SHADOW_REUSE),
     LintId::of(shadow::SHADOW_SAME),
+    LintId::of(shadow::SHADOW_UNRELATED),
     LintId::of(strings::STRING_ADD),
     LintId::of(strings::STRING_TO_STRING),
     LintId::of(strings::STR_TO_STRING),
diff --git a/clippy_lints/src/shadow.rs b/clippy_lints/src/shadow.rs
index b9e317a3cfd..9f48331c678 100644
--- a/clippy_lints/src/shadow.rs
+++ b/clippy_lints/src/shadow.rs
@@ -102,7 +102,7 @@ declare_clippy_lint! {
     /// let w = z; // use different variable name
     /// ```
     pub SHADOW_UNRELATED,
-    pedantic,
+    restriction,
     "rebinding a name without even using the original value"
 }
 
-- 
cgit 1.4.1-3-g733a5


From 99861c0e88493e6f8fa1363d7040866bfef912ac Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Mon, 11 Jan 2021 09:10:24 -0600
Subject: Remove initialization note from shadow lint

---
 clippy_lints/src/shadow.rs |  2 --
 tests/ui/shadow.stderr     | 25 -------------------------
 2 files changed, 27 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/shadow.rs b/clippy_lints/src/shadow.rs
index 9f48331c678..c17acfc8be7 100644
--- a/clippy_lints/src/shadow.rs
+++ b/clippy_lints/src/shadow.rs
@@ -298,7 +298,6 @@ fn lint_shadow<'tcx>(
                     snippet(cx, expr.span, "..")
                 ),
                 |diag| {
-                    diag.span_note(expr.span, "initialization happens here");
                     diag.span_note(prev_span, "previous binding is here");
                 },
             );
@@ -309,7 +308,6 @@ fn lint_shadow<'tcx>(
                 pattern_span,
                 &format!("`{}` is being shadowed", snippet(cx, pattern_span, "_")),
                 |diag| {
-                    diag.span_note(expr.span, "initialization happens here");
                     diag.span_note(prev_span, "previous binding is here");
                 },
             );
diff --git a/tests/ui/shadow.stderr b/tests/ui/shadow.stderr
index 7c1ad2949e9..23839749018 100644
--- a/tests/ui/shadow.stderr
+++ b/tests/ui/shadow.stderr
@@ -42,11 +42,6 @@ LL |     let x = { *x + 1 };
    |         ^
    |
    = note: `-D clippy::shadow-reuse` implied by `-D warnings`
-note: initialization happens here
-  --> $DIR/shadow.rs:30:13
-   |
-LL |     let x = { *x + 1 };
-   |             ^^^^^^^^^^
 note: previous binding is here
   --> $DIR/shadow.rs:29:9
    |
@@ -59,11 +54,6 @@ error: `x` is shadowed by `id(x)` which reuses the original value
 LL |     let x = id(x);
    |         ^
    |
-note: initialization happens here
-  --> $DIR/shadow.rs:31:13
-   |
-LL |     let x = id(x);
-   |             ^^^^^
 note: previous binding is here
   --> $DIR/shadow.rs:30:9
    |
@@ -76,11 +66,6 @@ error: `x` is shadowed by `(1, x)` which reuses the original value
 LL |     let x = (1, x);
    |         ^
    |
-note: initialization happens here
-  --> $DIR/shadow.rs:32:13
-   |
-LL |     let x = (1, x);
-   |             ^^^^^^
 note: previous binding is here
   --> $DIR/shadow.rs:31:9
    |
@@ -93,11 +78,6 @@ error: `x` is shadowed by `first(x)` which reuses the original value
 LL |     let x = first(x);
    |         ^
    |
-note: initialization happens here
-  --> $DIR/shadow.rs:33:13
-   |
-LL |     let x = first(x);
-   |             ^^^^^^^^
 note: previous binding is here
   --> $DIR/shadow.rs:32:9
    |
@@ -111,11 +91,6 @@ LL |     let x = y;
    |         ^
    |
    = note: `-D clippy::shadow-unrelated` implied by `-D warnings`
-note: initialization happens here
-  --> $DIR/shadow.rs:35:13
-   |
-LL |     let x = y;
-   |             ^
 note: previous binding is here
   --> $DIR/shadow.rs:33:9
    |
-- 
cgit 1.4.1-3-g733a5


From 8c0e4d5ccf8be995273f8b1e0e217906ec4b1dc4 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Sun, 10 Jan 2021 17:51:43 -0600
Subject: Rewrite shadow lint

---
 clippy_lints/src/lib.rs    |   2 +-
 clippy_lints/src/shadow.rs | 423 ++++++++++++++-------------------------------
 tests/ui/map_clone.fixed   |  14 +-
 tests/ui/map_clone.rs      |  14 +-
 tests/ui/shadow.rs         | 113 +++++++-----
 tests/ui/shadow.stderr     | 220 +++++++++++++++++------
 6 files changed, 379 insertions(+), 407 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index d43ce4a87c6..4e21b03217d 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -324,7 +324,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(same_name_method::SameNameMethod));
     store.register_late_pass(|| Box::new(map_clone::MapClone));
     store.register_late_pass(|| Box::new(map_err_ignore::MapErrIgnore));
-    store.register_late_pass(|| Box::new(shadow::Shadow));
+    store.register_late_pass(|| Box::new(shadow::Shadow::default()));
     store.register_late_pass(|| Box::new(unit_types::UnitTypes));
     store.register_late_pass(|| Box::new(loops::Loops));
     store.register_late_pass(|| Box::new(main_recursion::MainRecursion::default()));
diff --git a/clippy_lints/src/shadow.rs b/clippy_lints/src/shadow.rs
index c17acfc8be7..2ca7c18800e 100644
--- a/clippy_lints/src/shadow.rs
+++ b/clippy_lints/src/shadow.rs
@@ -1,17 +1,14 @@
-use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::diagnostics::span_lint_and_note;
 use clippy_utils::source::snippet;
-use clippy_utils::{contains_name, higher, iter_input_pats};
-use rustc_hir::intravisit::FnKind;
-use rustc_hir::{
-    Block, Body, Expr, ExprKind, FnDecl, Guard, HirId, Local, MutTy, Pat, PatKind, Path, QPath, StmtKind, Ty, TyKind,
-    UnOp,
-};
-use rustc_lint::{LateContext, LateLintPass, LintContext};
-use rustc_middle::lint::in_external_macro;
-use rustc_middle::ty;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::source_map::Span;
-use rustc_span::symbol::Symbol;
+use clippy_utils::visitors::is_local_used;
+use rustc_data_structures::fx::FxHashMap;
+use rustc_hir::def::Res;
+use rustc_hir::def_id::LocalDefId;
+use rustc_hir::hir_id::ItemLocalId;
+use rustc_hir::{Block, Body, BodyOwnerKind, Expr, ExprKind, HirId, Node, Pat, PatKind, QPath, UnOp};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::{Span, Symbol};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -23,10 +20,6 @@ declare_clippy_lint! {
     /// code. Still, some may opt to avoid it in their code base, they can set this
     /// lint to `Warn`.
     ///
-    /// ### Known problems
-    /// This lint, as the other shadowing related lints,
-    /// currently only catches very simple patterns.
-    ///
     /// ### Example
     /// ```rust
     /// # let x = 1;
@@ -52,10 +45,6 @@ declare_clippy_lint! {
     /// because a value may be bound to different things depending on position in
     /// the code.
     ///
-    /// ### Known problems
-    /// This lint, as the other shadowing related lints,
-    /// currently only catches very simple patterns.
-    ///
     /// ### Example
     /// ```rust
     /// let x = 2;
@@ -83,12 +72,6 @@ declare_clippy_lint! {
     /// any place in the code. This can be alleviated by either giving more specific
     /// names to bindings or introducing more scopes to contain the bindings.
     ///
-    /// ### Known problems
-    /// This lint, as the other shadowing related lints,
-    /// currently only catches very simple patterns. Note that
-    /// `allow`/`warn`/`deny`/`forbid` attributes only work on the function level
-    /// for this lint.
-    ///
     /// ### Example
     /// ```rust
     /// # let y = 1;
@@ -106,301 +89,147 @@ declare_clippy_lint! {
     "rebinding a name without even using the original value"
 }
 
-declare_lint_pass!(Shadow => [SHADOW_SAME, SHADOW_REUSE, SHADOW_UNRELATED]);
+#[derive(Default)]
+pub(crate) struct Shadow {
+    bindings: Vec<FxHashMap<Symbol, Vec<ItemLocalId>>>,
+}
+
+impl_lint_pass!(Shadow => [SHADOW_SAME, SHADOW_REUSE, SHADOW_UNRELATED]);
 
 impl<'tcx> LateLintPass<'tcx> for Shadow {
-    fn check_fn(
-        &mut self,
-        cx: &LateContext<'tcx>,
-        _: FnKind<'tcx>,
-        decl: &'tcx FnDecl<'_>,
-        body: &'tcx Body<'_>,
-        _: Span,
-        _: HirId,
-    ) {
-        if in_external_macro(cx.sess(), body.value.span) {
+    fn check_pat(&mut self, cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>) {
+        let (id, ident) = match pat.kind {
+            PatKind::Binding(_, hir_id, ident, _) => (hir_id, ident),
+            _ => return,
+        };
+        if ident.span.from_expansion() || ident.span.is_dummy() {
             return;
         }
-        check_fn(cx, decl, body);
-    }
-}
+        let HirId { owner, local_id } = id;
+
+        // get (or insert) the list of items for this owner and symbol
+        let data = self.bindings.last_mut().unwrap();
+        let items_with_name = data.entry(ident.name).or_default();
 
-fn check_fn<'tcx>(cx: &LateContext<'tcx>, decl: &'tcx FnDecl<'_>, body: &'tcx Body<'_>) {
-    let mut bindings = Vec::with_capacity(decl.inputs.len());
-    for arg in iter_input_pats(decl, body) {
-        if let PatKind::Binding(.., ident, _) = arg.pat.kind {
-            bindings.push((ident.name, ident.span));
+        // check other bindings with the same name, most recently seen first
+        for &prev in items_with_name.iter().rev() {
+            if prev == local_id {
+                // repeated binding in an `Or` pattern
+                return;
+            }
+
+            if is_shadow(cx, owner, prev, local_id) {
+                let prev_hir_id = HirId { owner, local_id: prev };
+                lint_shadow(cx, pat, prev_hir_id, ident.span);
+                // only lint against the "nearest" shadowed binding
+                break;
+            }
         }
+        // store the binding
+        items_with_name.push(local_id);
     }
-    check_expr(cx, &body.value, &mut bindings);
-}
 
-fn check_block<'tcx>(cx: &LateContext<'tcx>, block: &'tcx Block<'_>, bindings: &mut Vec<(Symbol, Span)>) {
-    let len = bindings.len();
-    for stmt in block.stmts {
-        match stmt.kind {
-            StmtKind::Local(local) => check_local(cx, local, bindings),
-            StmtKind::Expr(e) | StmtKind::Semi(e) => check_expr(cx, e, bindings),
-            StmtKind::Item(..) => {},
+    fn check_body(&mut self, cx: &LateContext<'_>, body: &Body<'_>) {
+        let hir = cx.tcx.hir();
+        if !matches!(hir.body_owner_kind(hir.body_owner(body.id())), BodyOwnerKind::Closure) {
+            self.bindings.push(FxHashMap::default());
         }
     }
-    if let Some(o) = block.expr {
-        check_expr(cx, o, bindings);
-    }
-    bindings.truncate(len);
-}
 
-fn check_local<'tcx>(cx: &LateContext<'tcx>, local: &'tcx Local<'_>, bindings: &mut Vec<(Symbol, Span)>) {
-    if in_external_macro(cx.sess(), local.span) {
-        return;
-    }
-    if higher::is_from_for_desugar(local) {
-        return;
-    }
-    let Local {
-        pat,
-        ref ty,
-        ref init,
-        span,
-        ..
-    } = *local;
-    if let Some(t) = *ty {
-        check_ty(cx, t, bindings);
-    }
-    if let Some(o) = *init {
-        check_expr(cx, o, bindings);
-        check_pat(cx, pat, Some(o), span, bindings);
-    } else {
-        check_pat(cx, pat, None, span, bindings);
+    fn check_body_post(&mut self, cx: &LateContext<'_>, body: &Body<'_>) {
+        let hir = cx.tcx.hir();
+        if !matches!(hir.body_owner_kind(hir.body_owner(body.id())), BodyOwnerKind::Closure) {
+            self.bindings.pop();
+        }
     }
 }
 
-fn is_binding(cx: &LateContext<'_>, pat_id: HirId) -> bool {
-    let var_ty = cx.typeck_results().node_type_opt(pat_id);
-    var_ty.map_or(false, |var_ty| !matches!(var_ty.kind(), ty::Adt(..)))
+fn is_shadow(cx: &LateContext<'_>, owner: LocalDefId, first: ItemLocalId, second: ItemLocalId) -> bool {
+    let scope_tree = cx.tcx.region_scope_tree(owner.to_def_id());
+    let first_scope = scope_tree.var_scope(first);
+    let second_scope = scope_tree.var_scope(second);
+    scope_tree.is_subscope_of(second_scope, first_scope)
 }
 
-fn check_pat<'tcx>(
-    cx: &LateContext<'tcx>,
-    pat: &'tcx Pat<'_>,
-    init: Option<&'tcx Expr<'_>>,
-    span: Span,
-    bindings: &mut Vec<(Symbol, Span)>,
-) {
-    // TODO: match more stuff / destructuring
-    match pat.kind {
-        PatKind::Binding(.., ident, ref inner) => {
-            let name = ident.name;
-            if is_binding(cx, pat.hir_id) {
-                let mut new_binding = true;
-                for tup in bindings.iter_mut() {
-                    if tup.0 == name {
-                        lint_shadow(cx, name, span, pat.span, init, tup.1);
-                        tup.1 = ident.span;
-                        new_binding = false;
-                        break;
-                    }
-                }
-                if new_binding {
-                    bindings.push((name, ident.span));
-                }
-            }
-            if let Some(p) = *inner {
-                check_pat(cx, p, init, span, bindings);
-            }
-        },
-        PatKind::Struct(_, pfields, _) => {
-            if let Some(init_struct) = init {
-                if let ExprKind::Struct(_, efields, _) = init_struct.kind {
-                    for field in pfields {
-                        let name = field.ident.name;
-                        let efield = efields
-                            .iter()
-                            .find_map(|f| if f.ident.name == name { Some(&*f.expr) } else { None });
-                        check_pat(cx, field.pat, efield, span, bindings);
-                    }
-                } else {
-                    for field in pfields {
-                        check_pat(cx, field.pat, init, span, bindings);
-                    }
-                }
-            } else {
-                for field in pfields {
-                    check_pat(cx, field.pat, None, span, bindings);
-                }
-            }
+fn lint_shadow(cx: &LateContext<'_>, pat: &Pat<'_>, shadowed: HirId, span: Span) {
+    let (lint, msg) = match find_init(cx, pat.hir_id) {
+        Some(expr) if is_self_shadow(cx, pat, expr, shadowed) => {
+            let msg = format!(
+                "`{}` is shadowed by itself in `{}`",
+                snippet(cx, pat.span, "_"),
+                snippet(cx, expr.span, "..")
+            );
+            (SHADOW_SAME, msg)
         },
-        PatKind::Tuple(inner, _) => {
-            if let Some(init_tup) = init {
-                if let ExprKind::Tup(tup) = init_tup.kind {
-                    for (i, p) in inner.iter().enumerate() {
-                        check_pat(cx, p, Some(&tup[i]), p.span, bindings);
-                    }
-                } else {
-                    for p in inner {
-                        check_pat(cx, p, init, span, bindings);
-                    }
-                }
-            } else {
-                for p in inner {
-                    check_pat(cx, p, None, span, bindings);
-                }
-            }
+        Some(expr) if is_local_used(cx, expr, shadowed) => {
+            let msg = format!(
+                "`{}` is shadowed by `{}` which reuses the original value",
+                snippet(cx, pat.span, "_"),
+                snippet(cx, expr.span, "..")
+            );
+            (SHADOW_REUSE, msg)
         },
-        PatKind::Box(inner) => {
-            if let Some(initp) = init {
-                if let ExprKind::Box(inner_init) = initp.kind {
-                    check_pat(cx, inner, Some(inner_init), span, bindings);
-                } else {
-                    check_pat(cx, inner, init, span, bindings);
-                }
-            } else {
-                check_pat(cx, inner, init, span, bindings);
-            }
+        _ => {
+            let msg = format!("`{}` shadows a previous, unrelated binding", snippet(cx, pat.span, "_"));
+            (SHADOW_UNRELATED, msg)
         },
-        PatKind::Ref(inner, _) => check_pat(cx, inner, init, span, bindings),
-        // PatVec(Vec<P<Pat>>, Option<P<Pat>>, Vec<P<Pat>>),
-        _ => (),
-    }
+    };
+    span_lint_and_note(
+        cx,
+        lint,
+        span,
+        &msg,
+        Some(cx.tcx.hir().span(shadowed)),
+        "previous binding is here",
+    );
 }
 
-fn lint_shadow<'tcx>(
-    cx: &LateContext<'tcx>,
-    name: Symbol,
-    span: Span,
-    pattern_span: Span,
-    init: Option<&'tcx Expr<'_>>,
-    prev_span: Span,
-) {
-    if let Some(expr) = init {
-        if is_self_shadow(name, expr) {
-            span_lint_and_then(
-                cx,
-                SHADOW_SAME,
-                span,
-                &format!(
-                    "`{}` is shadowed by itself in `{}`",
-                    snippet(cx, pattern_span, "_"),
-                    snippet(cx, expr.span, "..")
-                ),
-                |diag| {
-                    diag.span_note(prev_span, "previous binding is here");
-                },
-            );
-        } else if contains_name(name, expr) {
-            span_lint_and_then(
-                cx,
-                SHADOW_REUSE,
-                pattern_span,
-                &format!(
-                    "`{}` is shadowed by `{}` which reuses the original value",
-                    snippet(cx, pattern_span, "_"),
-                    snippet(cx, expr.span, "..")
-                ),
-                |diag| {
-                    diag.span_note(prev_span, "previous binding is here");
-                },
-            );
-        } else {
-            span_lint_and_then(
-                cx,
-                SHADOW_UNRELATED,
-                pattern_span,
-                &format!("`{}` is being shadowed", snippet(cx, pattern_span, "_")),
-                |diag| {
-                    diag.span_note(prev_span, "previous binding is here");
+/// Returns true if the expression is a simple transformation of a local binding such as `&x`
+fn is_self_shadow(cx: &LateContext<'_>, pat: &Pat<'_>, mut expr: &Expr<'_>, hir_id: HirId) -> bool {
+    let hir = cx.tcx.hir();
+    let is_direct_binding = hir
+        .parent_iter(pat.hir_id)
+        .map_while(|(_id, node)| match node {
+            Node::Pat(pat) => Some(pat),
+            _ => None,
+        })
+        .all(|pat| matches!(pat.kind, PatKind::Ref(..) | PatKind::Or(_)));
+    if !is_direct_binding {
+        return false;
+    }
+    loop {
+        expr = match expr.kind {
+            ExprKind::Box(e)
+            | ExprKind::AddrOf(_, _, e)
+            | ExprKind::Block(
+                &Block {
+                    stmts: [],
+                    expr: Some(e),
+                    ..
                 },
-            );
+                _,
+            )
+            | ExprKind::Unary(UnOp::Deref, e) => e,
+            ExprKind::Path(QPath::Resolved(None, path)) => break path.res == Res::Local(hir_id),
+            _ => break false,
         }
-    } else {
-        span_lint_and_then(
-            cx,
-            SHADOW_UNRELATED,
-            span,
-            &format!("`{}` shadows a previous declaration", snippet(cx, pattern_span, "_")),
-            |diag| {
-                diag.span_note(prev_span, "previous binding is here");
-            },
-        );
-    }
-}
-
-fn check_expr<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, bindings: &mut Vec<(Symbol, Span)>) {
-    if in_external_macro(cx.sess(), expr.span) {
-        return;
-    }
-    match expr.kind {
-        ExprKind::Unary(_, e) | ExprKind::Field(e, _) | ExprKind::AddrOf(_, _, e) | ExprKind::Box(e) => {
-            check_expr(cx, e, bindings);
-        },
-        ExprKind::Block(block, _) | ExprKind::Loop(block, ..) => check_block(cx, block, bindings),
-        // ExprKind::Call
-        // ExprKind::MethodCall
-        ExprKind::Array(v) | ExprKind::Tup(v) => {
-            for e in v {
-                check_expr(cx, e, bindings);
-            }
-        },
-        ExprKind::If(cond, then, ref otherwise) => {
-            check_expr(cx, cond, bindings);
-            check_expr(cx, then, bindings);
-            if let Some(o) = *otherwise {
-                check_expr(cx, o, bindings);
-            }
-        },
-        ExprKind::Match(init, arms, _) => {
-            check_expr(cx, init, bindings);
-            let len = bindings.len();
-            for arm in arms {
-                check_pat(cx, arm.pat, Some(init), arm.pat.span, bindings);
-                // This is ugly, but needed to get the right type
-                if let Some(ref guard) = arm.guard {
-                    match guard {
-                        Guard::If(if_expr) => check_expr(cx, if_expr, bindings),
-                        Guard::IfLet(guard_pat, guard_expr) => {
-                            check_pat(cx, guard_pat, Some(*guard_expr), guard_pat.span, bindings);
-                            check_expr(cx, guard_expr, bindings);
-                        },
-                    }
-                }
-                check_expr(cx, arm.body, bindings);
-                bindings.truncate(len);
-            }
-        },
-        _ => (),
-    }
-}
-
-fn check_ty<'tcx>(cx: &LateContext<'tcx>, ty: &'tcx Ty<'_>, bindings: &mut Vec<(Symbol, Span)>) {
-    match ty.kind {
-        TyKind::Slice(sty) => check_ty(cx, sty, bindings),
-        TyKind::Array(fty, ref anon_const) => {
-            check_ty(cx, fty, bindings);
-            check_expr(cx, &cx.tcx.hir().body(anon_const.body).value, bindings);
-        },
-        TyKind::Ptr(MutTy { ty: mty, .. }) | TyKind::Rptr(_, MutTy { ty: mty, .. }) => check_ty(cx, mty, bindings),
-        TyKind::Tup(tup) => {
-            for t in tup {
-                check_ty(cx, t, bindings);
-            }
-        },
-        TyKind::Typeof(ref anon_const) => check_expr(cx, &cx.tcx.hir().body(anon_const.body).value, bindings),
-        _ => (),
     }
 }
 
-fn is_self_shadow(name: Symbol, expr: &Expr<'_>) -> bool {
-    match expr.kind {
-        ExprKind::Box(inner) | ExprKind::AddrOf(_, _, inner) => is_self_shadow(name, inner),
-        ExprKind::Block(block, _) => {
-            block.stmts.is_empty() && block.expr.as_ref().map_or(false, |e| is_self_shadow(name, e))
-        },
-        ExprKind::Unary(op, inner) => (UnOp::Deref == op) && is_self_shadow(name, inner),
-        ExprKind::Path(QPath::Resolved(_, path)) => path_eq_name(name, path),
-        _ => false,
+/// Finds the "init" expression for a pattern: `let <pat> = <init>;` or
+/// `match <init> { .., <pat> => .., .. }`
+fn find_init<'tcx>(cx: &LateContext<'tcx>, hir_id: HirId) -> Option<&'tcx Expr<'tcx>> {
+    for (_, node) in cx.tcx.hir().parent_iter(hir_id) {
+        let init = match node {
+            Node::Arm(_) | Node::Pat(_) => continue,
+            Node::Expr(expr) => match expr.kind {
+                ExprKind::Match(e, _, _) => Some(e),
+                _ => None,
+            },
+            Node::Local(local) => local.init,
+            _ => None,
+        };
+        return init;
     }
-}
-
-fn path_eq_name(name: Symbol, path: &Path<'_>) -> bool {
-    !path.is_global() && path.segments.len() == 1 && path.segments[0].ident.name == name
+    None
 }
diff --git a/tests/ui/map_clone.fixed b/tests/ui/map_clone.fixed
index 178d8705c2f..0860dcf8e0d 100644
--- a/tests/ui/map_clone.fixed
+++ b/tests/ui/map_clone.fixed
@@ -1,11 +1,11 @@
 // run-rustfix
-#![warn(clippy::all, clippy::pedantic)]
-#![allow(clippy::iter_cloned_collect)]
-#![allow(clippy::clone_on_copy, clippy::redundant_clone)]
-#![allow(clippy::let_underscore_drop)]
-#![allow(clippy::missing_docs_in_private_items)]
-#![allow(clippy::redundant_closure_for_method_calls)]
-#![allow(clippy::many_single_char_names)]
+#![warn(clippy::map_clone)]
+#![allow(
+    clippy::clone_on_copy,
+    clippy::iter_cloned_collect,
+    clippy::many_single_char_names,
+    clippy::redundant_clone
+)]
 
 fn main() {
     let _: Vec<i8> = vec![5_i8; 6].iter().copied().collect();
diff --git a/tests/ui/map_clone.rs b/tests/ui/map_clone.rs
index c73d81713b8..b6987336834 100644
--- a/tests/ui/map_clone.rs
+++ b/tests/ui/map_clone.rs
@@ -1,11 +1,11 @@
 // run-rustfix
-#![warn(clippy::all, clippy::pedantic)]
-#![allow(clippy::iter_cloned_collect)]
-#![allow(clippy::clone_on_copy, clippy::redundant_clone)]
-#![allow(clippy::let_underscore_drop)]
-#![allow(clippy::missing_docs_in_private_items)]
-#![allow(clippy::redundant_closure_for_method_calls)]
-#![allow(clippy::many_single_char_names)]
+#![warn(clippy::map_clone)]
+#![allow(
+    clippy::clone_on_copy,
+    clippy::iter_cloned_collect,
+    clippy::many_single_char_names,
+    clippy::redundant_clone
+)]
 
 fn main() {
     let _: Vec<i8> = vec![5_i8; 6].iter().map(|x| *x).collect();
diff --git a/tests/ui/shadow.rs b/tests/ui/shadow.rs
index e366c75335c..02e838456d0 100644
--- a/tests/ui/shadow.rs
+++ b/tests/ui/shadow.rs
@@ -1,54 +1,77 @@
-#![warn(
-    clippy::all,
-    clippy::pedantic,
-    clippy::shadow_same,
-    clippy::shadow_reuse,
-    clippy::shadow_unrelated
-)]
-#![allow(
-    unused_parens,
-    unused_variables,
-    clippy::manual_unwrap_or,
-    clippy::missing_docs_in_private_items,
-    clippy::single_match
-)]
-
-fn id<T>(x: T) -> T {
-    x
+#![warn(clippy::shadow_same, clippy::shadow_reuse, clippy::shadow_unrelated)]
+
+fn shadow_same() {
+    let x = 1;
+    let x = x;
+    let mut x = &x;
+    let x = &mut x;
+    let x = *x;
 }
 
-#[must_use]
-fn first(x: (isize, isize)) -> isize {
-    x.0
+fn shadow_reuse() -> Option<()> {
+    let x = ([[0]], ());
+    let x = x.0;
+    let x = x[0];
+    let [x] = x;
+    let x = Some(x);
+    let x = foo(x);
+    let x = || x;
+    let x = Some(1).map(|_| x)?;
+    None
 }
 
-fn main() {
-    let mut x = 1;
-    let x = &mut x;
-    let x = { x };
-    let x = (&*x);
-    let x = { *x + 1 };
-    let x = id(x);
-    let x = (1, x);
-    let x = first(x);
-    let y = 1;
-    let x = y;
-
-    let x;
-    x = 42;
-
-    let o = Some(1_u8);
-
-    if let Some(p) = o {
-        assert_eq!(1, p);
+fn shadow_unrelated() {
+    let x = 1;
+    let x = 2;
+}
+
+fn syntax() {
+    fn f(x: u32) {
+        let x = 1;
+    }
+    let x = 1;
+    match Some(1) {
+        Some(1) => {},
+        Some(x) => {
+            let x = 1;
+        },
+        _ => {},
     }
-    match o {
-        Some(p) => p, // no error, because the p above is in its own scope
-        None => 0,
+    if let Some(x) = Some(1) {}
+    while let Some(x) = Some(1) {}
+    let _ = |[x]: [u32; 1]| {
+        let x = 1;
     };
+}
 
-    match (x, o) {
-        (1, Some(a)) | (a, Some(1)) => (), // no error though `a` appears twice
-        _ => (),
+fn negative() {
+    match Some(1) {
+        Some(x) if x == 1 => {},
+        Some(x) => {},
+        None => {},
     }
+    match [None, Some(1)] {
+        [Some(x), None] | [None, Some(x)] => {},
+        _ => {},
+    }
+    if let Some(x) = Some(1) {
+        let y = 1;
+    } else {
+        let x = 1;
+        let y = 1;
+    }
+    let x = 1;
+    #[allow(clippy::shadow_unrelated)]
+    let x = 1;
+}
+
+fn foo<T>(_: T) {}
+
+fn question_mark() -> Option<()> {
+    let val = 1;
+    // `?` expands with a `val` binding
+    None?;
+    None
 }
+
+fn main() {}
diff --git a/tests/ui/shadow.stderr b/tests/ui/shadow.stderr
index 23839749018..8b60e072c93 100644
--- a/tests/ui/shadow.stderr
+++ b/tests/ui/shadow.stderr
@@ -1,113 +1,233 @@
-error: `x` is shadowed by itself in `&mut x`
-  --> $DIR/shadow.rs:27:5
+error: `x` is shadowed by itself in `x`
+  --> $DIR/shadow.rs:5:9
    |
-LL |     let x = &mut x;
-   |     ^^^^^^^^^^^^^^^
+LL |     let x = x;
+   |         ^
    |
    = note: `-D clippy::shadow-same` implied by `-D warnings`
 note: previous binding is here
-  --> $DIR/shadow.rs:26:13
+  --> $DIR/shadow.rs:4:9
    |
-LL |     let mut x = 1;
-   |             ^
+LL |     let x = 1;
+   |         ^
 
-error: `x` is shadowed by itself in `{ x }`
-  --> $DIR/shadow.rs:28:5
+error: `mut x` is shadowed by itself in `&x`
+  --> $DIR/shadow.rs:6:13
    |
-LL |     let x = { x };
-   |     ^^^^^^^^^^^^^^
+LL |     let mut x = &x;
+   |             ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:27:9
+  --> $DIR/shadow.rs:5:9
+   |
+LL |     let x = x;
+   |         ^
+
+error: `x` is shadowed by itself in `&mut x`
+  --> $DIR/shadow.rs:7:9
    |
 LL |     let x = &mut x;
    |         ^
+   |
+note: previous binding is here
+  --> $DIR/shadow.rs:6:9
+   |
+LL |     let mut x = &x;
+   |         ^^^^^
 
-error: `x` is shadowed by itself in `(&*x)`
-  --> $DIR/shadow.rs:29:5
+error: `x` is shadowed by itself in `*x`
+  --> $DIR/shadow.rs:8:9
    |
-LL |     let x = (&*x);
-   |     ^^^^^^^^^^^^^^
+LL |     let x = *x;
+   |         ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:28:9
+  --> $DIR/shadow.rs:7:9
    |
-LL |     let x = { x };
+LL |     let x = &mut x;
    |         ^
 
-error: `x` is shadowed by `{ *x + 1 }` which reuses the original value
-  --> $DIR/shadow.rs:30:9
+error: `x` is shadowed by `x.0` which reuses the original value
+  --> $DIR/shadow.rs:13:9
    |
-LL |     let x = { *x + 1 };
+LL |     let x = x.0;
    |         ^
    |
    = note: `-D clippy::shadow-reuse` implied by `-D warnings`
 note: previous binding is here
-  --> $DIR/shadow.rs:29:9
+  --> $DIR/shadow.rs:12:9
    |
-LL |     let x = (&*x);
+LL |     let x = ([[0]], ());
    |         ^
 
-error: `x` is shadowed by `id(x)` which reuses the original value
-  --> $DIR/shadow.rs:31:9
+error: `x` is shadowed by `x[0]` which reuses the original value
+  --> $DIR/shadow.rs:14:9
    |
-LL |     let x = id(x);
+LL |     let x = x[0];
    |         ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:30:9
+  --> $DIR/shadow.rs:13:9
    |
-LL |     let x = { *x + 1 };
+LL |     let x = x.0;
    |         ^
 
-error: `x` is shadowed by `(1, x)` which reuses the original value
-  --> $DIR/shadow.rs:32:9
+error: `x` is shadowed by `x` which reuses the original value
+  --> $DIR/shadow.rs:15:10
+   |
+LL |     let [x] = x;
+   |          ^
+   |
+note: previous binding is here
+  --> $DIR/shadow.rs:14:9
    |
-LL |     let x = (1, x);
+LL |     let x = x[0];
+   |         ^
+
+error: `x` is shadowed by `Some(x)` which reuses the original value
+  --> $DIR/shadow.rs:16:9
+   |
+LL |     let x = Some(x);
+   |         ^
+   |
+note: previous binding is here
+  --> $DIR/shadow.rs:15:10
+   |
+LL |     let [x] = x;
+   |          ^
+
+error: `x` is shadowed by `foo(x)` which reuses the original value
+  --> $DIR/shadow.rs:17:9
+   |
+LL |     let x = foo(x);
    |         ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:31:9
+  --> $DIR/shadow.rs:16:9
    |
-LL |     let x = id(x);
+LL |     let x = Some(x);
    |         ^
 
-error: `x` is shadowed by `first(x)` which reuses the original value
-  --> $DIR/shadow.rs:33:9
+error: `x` is shadowed by `|| x` which reuses the original value
+  --> $DIR/shadow.rs:18:9
    |
-LL |     let x = first(x);
+LL |     let x = || x;
    |         ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:32:9
+  --> $DIR/shadow.rs:17:9
    |
-LL |     let x = (1, x);
+LL |     let x = foo(x);
    |         ^
 
-error: `x` is being shadowed
-  --> $DIR/shadow.rs:35:9
+error: `x` is shadowed by `Some(1).map(|_| x)?` which reuses the original value
+  --> $DIR/shadow.rs:19:9
    |
-LL |     let x = y;
+LL |     let x = Some(1).map(|_| x)?;
+   |         ^
+   |
+note: previous binding is here
+  --> $DIR/shadow.rs:18:9
+   |
+LL |     let x = || x;
+   |         ^
+
+error: `x` shadows a previous, unrelated binding
+  --> $DIR/shadow.rs:25:9
+   |
+LL |     let x = 2;
    |         ^
    |
    = note: `-D clippy::shadow-unrelated` implied by `-D warnings`
 note: previous binding is here
-  --> $DIR/shadow.rs:33:9
+  --> $DIR/shadow.rs:24:9
    |
-LL |     let x = first(x);
+LL |     let x = 1;
    |         ^
 
-error: `x` shadows a previous declaration
-  --> $DIR/shadow.rs:37:5
+error: `x` shadows a previous, unrelated binding
+  --> $DIR/shadow.rs:30:13
    |
-LL |     let x;
-   |     ^^^^^^
+LL |         let x = 1;
+   |             ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:35:9
+  --> $DIR/shadow.rs:29:10
    |
-LL |     let x = y;
+LL |     fn f(x: u32) {
+   |          ^
+
+error: `x` shadows a previous, unrelated binding
+  --> $DIR/shadow.rs:35:14
+   |
+LL |         Some(x) => {
+   |              ^
+   |
+note: previous binding is here
+  --> $DIR/shadow.rs:32:9
+   |
+LL |     let x = 1;
    |         ^
 
-error: aborting due to 9 previous errors
+error: `x` shadows a previous, unrelated binding
+  --> $DIR/shadow.rs:36:17
+   |
+LL |             let x = 1;
+   |                 ^
+   |
+note: previous binding is here
+  --> $DIR/shadow.rs:35:14
+   |
+LL |         Some(x) => {
+   |              ^
+
+error: `x` shadows a previous, unrelated binding
+  --> $DIR/shadow.rs:40:17
+   |
+LL |     if let Some(x) = Some(1) {}
+   |                 ^
+   |
+note: previous binding is here
+  --> $DIR/shadow.rs:32:9
+   |
+LL |     let x = 1;
+   |         ^
+
+error: `x` shadows a previous, unrelated binding
+  --> $DIR/shadow.rs:41:20
+   |
+LL |     while let Some(x) = Some(1) {}
+   |                    ^
+   |
+note: previous binding is here
+  --> $DIR/shadow.rs:32:9
+   |
+LL |     let x = 1;
+   |         ^
+
+error: `x` shadows a previous, unrelated binding
+  --> $DIR/shadow.rs:42:15
+   |
+LL |     let _ = |[x]: [u32; 1]| {
+   |               ^
+   |
+note: previous binding is here
+  --> $DIR/shadow.rs:32:9
+   |
+LL |     let x = 1;
+   |         ^
+
+error: `x` shadows a previous, unrelated binding
+  --> $DIR/shadow.rs:43:13
+   |
+LL |         let x = 1;
+   |             ^
+   |
+note: previous binding is here
+  --> $DIR/shadow.rs:42:15
+   |
+LL |     let _ = |[x]: [u32; 1]| {
+   |               ^
+
+error: aborting due to 19 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 41e2c68a6e3e6d06c6e3549ae4e79f145fb4ba1b Mon Sep 17 00:00:00 2001
From: surechen <chenshuo17@huawei.com>
Date: Fri, 1 Oct 2021 13:13:09 +0800
Subject: use sugg::Sugg::maybe_par

---
 clippy_lints/src/if_then_panic.rs | 36 +++++-------------------------------
 tests/ui/if_then_panic.fixed      |  8 ++++----
 tests/ui/if_then_panic.stderr     |  8 ++++----
 3 files changed, 13 insertions(+), 39 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/if_then_panic.rs b/clippy_lints/src/if_then_panic.rs
index 31e416bd4d6..10bca59e6d0 100644
--- a/clippy_lints/src/if_then_panic.rs
+++ b/clippy_lints/src/if_then_panic.rs
@@ -1,9 +1,9 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::higher::PanicExpn;
-use clippy_utils::is_expn_of;
 use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::{is_expn_of, sugg};
 use rustc_errors::Applicability;
-use rustc_hir::{BinOpKind, Block, Expr, ExprKind, StmtKind, UnOp};
+use rustc_hir::{Block, Expr, ExprKind, StmtKind, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
@@ -74,40 +74,14 @@ impl LateLintPass<'_> for IfThenPanic {
                 };
                 let mut applicability = Applicability::MachineApplicable;
                 let sugg = snippet_with_applicability(cx, span, "..", &mut applicability);
-                //let mut cond_sugg = format!("!{}", snippet_with_applicability(cx, cond.span, "..", &mut applicability));
                 let cond_sugg = if let ExprKind::DropTemps(e, ..) = cond.kind {
                     if let Expr{kind: ExprKind::Unary(UnOp::Not, not_expr), ..} = e {
-                        snippet_with_applicability(cx, not_expr.span, "..", &mut applicability).to_string()
-                    } else if let Expr{kind: ExprKind::Binary(op, left, right), ..} = e {//BinOp{BinOpKind::And, ..}
-                        match op.node {
-                            BinOpKind::And | BinOpKind::Or => {
-                                let left_span =  {
-                                    if let Expr{kind: ExprKind::Unary(UnOp::Not, not_expr), ..} = left {
-                                        snippet_with_applicability(cx, not_expr.span, "..", &mut applicability).to_string()
-                                    } else {
-                                        format!("!{}", snippet_with_applicability(cx, left.span, "..", &mut applicability))
-                                    }
-                                };
-                                let right_span = {
-                                    if let Expr{kind: ExprKind::Unary(UnOp::Not, not_expr), ..} = right {
-                                        snippet_with_applicability(cx, not_expr.span, "..", &mut applicability).to_string()
-                                    } else {
-                                        format!("!{}", snippet_with_applicability(cx, right.span, "..", &mut applicability))
-                                    }
-                                };
-                                if op.node == BinOpKind::And {
-                                  format!("{} || {}", left_span, right_span)
-                                } else  {
-                                  format!("{} && {}", left_span, right_span)
-                                }
-                            }
-                            _ => format!("!({})", snippet_with_applicability(cx, cond.span, "..", &mut applicability))
-                        }
+                         sugg::Sugg::hir_with_applicability(cx, not_expr, "..", &mut applicability).maybe_par().to_string()
                     } else {
-                        format!("!{}", snippet_with_applicability(cx, cond.span, "..", &mut applicability))
+                       format!("!{}", sugg::Sugg::hir_with_applicability(cx, e, "..", &mut applicability).maybe_par().to_string())
                     }
                 } else {
-                    format!("!{}", snippet_with_applicability(cx, cond.span, "..", &mut applicability))
+                   format!("!{}", sugg::Sugg::hir_with_applicability(cx, cond, "..", &mut applicability).maybe_par().to_string())
                 };
 
                 span_lint_and_sugg(
diff --git a/tests/ui/if_then_panic.fixed b/tests/ui/if_then_panic.fixed
index f72bc6f5979..0998f8ffa9d 100644
--- a/tests/ui/if_then_panic.fixed
+++ b/tests/ui/if_then_panic.fixed
@@ -33,8 +33,8 @@ fn main() {
     }
     let b = vec![1, 2, 3];
     assert!(!b.is_empty(), "panic1");
-    assert!(!b.is_empty() || !a.is_empty(), "panic2");
-    assert!(!a.is_empty() || b.is_empty(), "panic3");
-    assert!(!b.is_empty() && !a.is_empty(), "panic4");
-    assert!(!a.is_empty() && b.is_empty(), "panic5");
+    assert!(!(b.is_empty() && a.is_empty()), "panic2");
+    assert!(!(a.is_empty() && !b.is_empty()), "panic3");
+    assert!(!(b.is_empty() || a.is_empty()), "panic4");
+    assert!(!(a.is_empty() || !b.is_empty()), "panic5");
 }
diff --git a/tests/ui/if_then_panic.stderr b/tests/ui/if_then_panic.stderr
index 502ba10b8f4..5bb62f87566 100644
--- a/tests/ui/if_then_panic.stderr
+++ b/tests/ui/if_then_panic.stderr
@@ -30,7 +30,7 @@ error: only a `panic!` in `if`-then statement
 LL | /     if b.is_empty() && a.is_empty() {
 LL | |         panic!("panic2");
 LL | |     }
-   | |_____^ help: try: `assert!(!b.is_empty() || !a.is_empty(), "panic2");`
+   | |_____^ help: try: `assert!(!(b.is_empty() && a.is_empty()), "panic2");`
 
 error: only a `panic!` in `if`-then statement
   --> $DIR/if_then_panic.rs:45:5
@@ -38,7 +38,7 @@ error: only a `panic!` in `if`-then statement
 LL | /     if a.is_empty() && !b.is_empty() {
 LL | |         panic!("panic3");
 LL | |     }
-   | |_____^ help: try: `assert!(!a.is_empty() || b.is_empty(), "panic3");`
+   | |_____^ help: try: `assert!(!(a.is_empty() && !b.is_empty()), "panic3");`
 
 error: only a `panic!` in `if`-then statement
   --> $DIR/if_then_panic.rs:48:5
@@ -46,7 +46,7 @@ error: only a `panic!` in `if`-then statement
 LL | /     if b.is_empty() || a.is_empty() {
 LL | |         panic!("panic4");
 LL | |     }
-   | |_____^ help: try: `assert!(!b.is_empty() && !a.is_empty(), "panic4");`
+   | |_____^ help: try: `assert!(!(b.is_empty() || a.is_empty()), "panic4");`
 
 error: only a `panic!` in `if`-then statement
   --> $DIR/if_then_panic.rs:51:5
@@ -54,7 +54,7 @@ error: only a `panic!` in `if`-then statement
 LL | /     if a.is_empty() || !b.is_empty() {
 LL | |         panic!("panic5");
 LL | |     }
-   | |_____^ help: try: `assert!(!a.is_empty() && b.is_empty(), "panic5");`
+   | |_____^ help: try: `assert!(!(a.is_empty() || !b.is_empty()), "panic5");`
 
 error: aborting due to 7 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From e4c3000e5bf254ab19895b7a62413ff0d346d337 Mon Sep 17 00:00:00 2001
From: Yechan Bae <yechan@gatech.edu>
Date: Thu, 23 Sep 2021 03:51:10 -0400
Subject: Initial implementation

---
 CHANGELOG.md                                  |   1 +
 clippy_lints/src/lib.mods.rs                  |   1 +
 clippy_lints/src/lib.register_lints.rs        |   1 +
 clippy_lints/src/lib.register_nursery.rs      |   1 +
 clippy_lints/src/lib.rs                       |   1 +
 clippy_lints/src/non_send_field_in_send_ty.rs | 126 ++++++++++++++++++++++++++
 tests/ui/non_send_field_in_send_ty.rs         |  94 +++++++++++++++++++
 7 files changed, 225 insertions(+)
 create mode 100644 clippy_lints/src/non_send_field_in_send_ty.rs
 create mode 100644 tests/ui/non_send_field_in_send_ty.rs

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 58ea0f9ab9d..df3fa2866c2 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2898,6 +2898,7 @@ Released 2018-09-13
 [`no_effect`]: https://rust-lang.github.io/rust-clippy/master/index.html#no_effect
 [`non_ascii_literal`]: https://rust-lang.github.io/rust-clippy/master/index.html#non_ascii_literal
 [`non_octal_unix_permissions`]: https://rust-lang.github.io/rust-clippy/master/index.html#non_octal_unix_permissions
+[`non_send_field_in_send_ty`]: https://rust-lang.github.io/rust-clippy/master/index.html#non_send_field_in_send_ty
 [`nonminimal_bool`]: https://rust-lang.github.io/rust-clippy/master/index.html#nonminimal_bool
 [`nonsensical_open_options`]: https://rust-lang.github.io/rust-clippy/master/index.html#nonsensical_open_options
 [`nonstandard_macro_braces`]: https://rust-lang.github.io/rust-clippy/master/index.html#nonstandard_macro_braces
diff --git a/clippy_lints/src/lib.mods.rs b/clippy_lints/src/lib.mods.rs
index 2718604f905..1d9d2be3443 100644
--- a/clippy_lints/src/lib.mods.rs
+++ b/clippy_lints/src/lib.mods.rs
@@ -149,6 +149,7 @@ mod no_effect;
 mod non_copy_const;
 mod non_expressive_names;
 mod non_octal_unix_permissions;
+mod non_send_field_in_send_ty;
 mod nonstandard_macro_braces;
 mod open_options;
 mod option_env_unwrap;
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 1ad27870b1a..b1cd5aafe4c 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -366,6 +366,7 @@ store.register_lints(&[
     non_expressive_names::MANY_SINGLE_CHAR_NAMES,
     non_expressive_names::SIMILAR_NAMES,
     non_octal_unix_permissions::NON_OCTAL_UNIX_PERMISSIONS,
+    non_send_field_in_send_ty::NON_SEND_FIELD_IN_SEND_TY,
     nonstandard_macro_braces::NONSTANDARD_MACRO_BRACES,
     open_options::NONSENSICAL_OPEN_OPTIONS,
     option_env_unwrap::OPTION_ENV_UNWRAP,
diff --git a/clippy_lints/src/lib.register_nursery.rs b/clippy_lints/src/lib.register_nursery.rs
index b082f577a52..56b4f9d2391 100644
--- a/clippy_lints/src/lib.register_nursery.rs
+++ b/clippy_lints/src/lib.register_nursery.rs
@@ -16,6 +16,7 @@ store.register_group(true, "clippy::nursery", Some("clippy_nursery"), vec![
     LintId::of(missing_const_for_fn::MISSING_CONST_FOR_FN),
     LintId::of(mutable_debug_assertion::DEBUG_ASSERT_WITH_MUT_CALL),
     LintId::of(mutex_atomic::MUTEX_INTEGER),
+    LintId::of(non_send_field_in_send_ty::NON_SEND_FIELD_IN_SEND_TY),
     LintId::of(nonstandard_macro_braces::NONSTANDARD_MACRO_BRACES),
     LintId::of(option_if_let_else::OPTION_IF_LET_ELSE),
     LintId::of(path_buf_push_overwrite::PATH_BUF_PUSH_OVERWRITE),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 4e21b03217d..93b93bcba48 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -535,6 +535,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(move || Box::new(feature_name::FeatureName));
     store.register_late_pass(move || Box::new(iter_not_returning_iterator::IterNotReturningIterator));
     store.register_late_pass(move || Box::new(if_then_panic::IfThenPanic));
+    store.register_late_pass(|| Box::new(non_send_field_in_send_ty::NonSendFieldInSendTy));
 }
 
 #[rustfmt::skip]
diff --git a/clippy_lints/src/non_send_field_in_send_ty.rs b/clippy_lints/src/non_send_field_in_send_ty.rs
new file mode 100644
index 00000000000..5d6501196cd
--- /dev/null
+++ b/clippy_lints/src/non_send_field_in_send_ty.rs
@@ -0,0 +1,126 @@
+use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_note};
+use clippy_utils::ty::{implements_trait, is_copy};
+use rustc_ast::ImplPolarity;
+use rustc_hir::{Item, ItemKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::{self, subst::GenericArgKind, Ty};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::sym;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Warns about a field in a `Send` struct that is neither `Send` nor `Copy`.
+    ///
+    /// ### Why is this bad?
+    /// Sending the struct to another thread and drops it there will also drop
+    /// the field in the new thread. This effectively changes the ownership of
+    /// the field type to the new thread and creates a soundness issue by
+    /// breaking breaks the non-`Send` invariant.
+    ///
+    /// ### Known Problems
+    /// Data structures that contain raw pointers may cause false positives.
+    /// They are sometimes safe to be sent across threads but do not implement
+    /// the `Send` trait. This lint has a heuristic to filter out basic cases
+    /// such as `Vec<*const T>`, but it's not perfect.
+    ///
+    /// ### Example
+    /// ```rust
+    /// use std::sync::Arc;
+    ///
+    /// // There is no `RC: Send` bound here
+    /// unsafe impl<RC, T: Send> Send for ArcGuard<RC, T> {}
+    ///
+    /// #[derive(Debug, Clone)]
+    /// pub struct ArcGuard<RC, T> {
+    ///     inner: T,
+    ///     // Possibly drops `Arc<RC>` (and in turn `RC`) on a wrong thread
+    ///     head: Arc<RC>
+    /// }
+    /// ```
+    pub NON_SEND_FIELD_IN_SEND_TY,
+    nursery,
+    "a field in a `Send` struct does not implement `Send`"
+}
+
+declare_lint_pass!(NonSendFieldInSendTy => [NON_SEND_FIELD_IN_SEND_TY]);
+
+impl<'tcx> LateLintPass<'tcx> for NonSendFieldInSendTy {
+    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
+        let send_trait = cx.tcx.get_diagnostic_item(sym::send_trait).unwrap();
+
+        // Check if we are in `Send` impl item
+        if_chain! {
+            if let ItemKind::Impl(hir_impl) = &item.kind;
+            if let Some(trait_ref) = &hir_impl.of_trait;
+            if let Some(trait_id) = trait_ref.trait_def_id();
+            if send_trait == trait_id;
+            if let ImplPolarity::Positive = hir_impl.polarity;
+            if let Some(ty_trait_ref) = cx.tcx.impl_trait_ref(item.def_id);
+            if let self_ty = ty_trait_ref.self_ty();
+            if let ty::Adt(adt_def, impl_trait_substs) = self_ty.kind();
+            then {
+                for variant in &adt_def.variants {
+                    for field in &variant.fields {
+                        let field_ty = field.ty(cx.tcx, impl_trait_substs);
+
+                        // TODO: substs rebase_onto
+
+                        if raw_pointer_in_ty_def(cx, field_ty)
+                            || implements_trait(cx, field_ty, send_trait, &[])
+                            || is_copy(cx, field_ty)
+                        {
+                            continue;
+                        }
+
+                        if let Some(field_span) = cx.tcx.hir().span_if_local(field.did) {
+                            if is_ty_param(field_ty) {
+                                span_lint_and_help(
+                                    cx,
+                                    NON_SEND_FIELD_IN_SEND_TY,
+                                    field_span,
+                                    "a field in a `Send` struct does not implement `Send`",
+                                    Some(item.span),
+                                    &format!("add `{}: Send` in `Send` impl for `{}`", field_ty, self_ty),
+                                )
+                            } else {
+                                span_lint_and_note(
+                                    cx,
+                                    NON_SEND_FIELD_IN_SEND_TY,
+                                    field_span,
+                                    "a field in a `Send` struct does not implement `Send`",
+                                    Some(item.span),
+                                    &format!(
+                                        "type `{}` doesn't implement `Send` when `{}` is `Send`",
+                                        field_ty, self_ty
+                                    ),
+                                )
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+/// Returns `true` if the type itself is a raw pointer or has a raw pointer as a
+/// generic parameter, e.g., `Vec<*const u8>`.
+/// Note that it does not look into enum variants or struct fields.
+fn raw_pointer_in_ty_def<'tcx>(cx: &LateContext<'tcx>, target_ty: Ty<'tcx>) -> bool {
+    for ty_node in target_ty.walk(cx.tcx) {
+        if_chain! {
+            if let GenericArgKind::Type(inner_ty) = ty_node.unpack();
+            if let ty::RawPtr(_) = inner_ty.kind();
+            then {
+                return true;
+            }
+        }
+    }
+
+    false
+}
+
+/// Returns `true` if the type is a type parameter such as `T`.
+fn is_ty_param<'tcx>(target_ty: Ty<'tcx>) -> bool {
+    matches!(target_ty.kind(), ty::Param(_))
+}
diff --git a/tests/ui/non_send_field_in_send_ty.rs b/tests/ui/non_send_field_in_send_ty.rs
new file mode 100644
index 00000000000..a0c574f8e59
--- /dev/null
+++ b/tests/ui/non_send_field_in_send_ty.rs
@@ -0,0 +1,94 @@
+#![warn(clippy::non_send_field_in_send_ty)]
+#![feature(extern_types)]
+
+use std::cell::UnsafeCell;
+use std::ptr::NonNull;
+use std::sync::{Arc, Mutex};
+
+// disrustor / RUSTSEC-2020-0150
+pub struct RingBuffer<T> {
+    data: Vec<UnsafeCell<T>>,
+    capacity: usize,
+    mask: usize,
+}
+
+unsafe impl<T> Send for RingBuffer<T> {}
+
+// noise_search / RUSTSEC-2020-0141
+pub struct MvccRwLock<T> {
+    raw: *const T,
+    lock: Mutex<Box<T>>,
+}
+
+unsafe impl<T> Send for MvccRwLock<T> {}
+
+// async-coap / RUSTSEC-2020-0124
+pub struct ArcGuard<RC, T> {
+    inner: T,
+    head: Arc<RC>,
+}
+
+unsafe impl<RC, T: Send> Send for ArcGuard<RC, T> {}
+
+// rusb / RUSTSEC-2020-0098
+extern "C" {
+    type libusb_device_handle;
+}
+
+pub trait UsbContext {
+    // some user trait that does not guarantee `Send`
+}
+
+pub struct DeviceHandle<T: UsbContext> {
+    context: T,
+    handle: NonNull<libusb_device_handle>,
+}
+
+unsafe impl<T: UsbContext> Send for DeviceHandle<T> {}
+
+// Raw pointers are allowed
+extern "C" {
+    type SomeFfiType;
+}
+
+pub struct FpTest {
+    vec: Vec<*const SomeFfiType>,
+}
+
+unsafe impl Send for FpTest {}
+
+// Check raw pointer false positive
+#[allow(clippy::non_send_field_in_send_ty)]
+pub struct AttrTest1<T>(T);
+
+pub struct AttrTest2<T> {
+    #[allow(clippy::non_send_field_in_send_ty)]
+    field: T,
+}
+
+pub enum AttrTest3<T> {
+    #[allow(clippy::non_send_field_in_send_ty)]
+    Enum1(T),
+    Enum2(T),
+}
+
+unsafe impl<T> Send for AttrTest1<T> {}
+unsafe impl<T> Send for AttrTest2<T> {}
+unsafe impl<T> Send for AttrTest3<T> {}
+
+pub struct MultiField<T> {
+    field1: T,
+    field2: T,
+    field3: T,
+}
+
+unsafe impl<T> Send for MultiField<T> {}
+
+pub enum MyOption<T> {
+    MySome(T),
+    MyNone,
+}
+
+unsafe impl<T> Send for MyOption<T> {}
+
+fn main() {}
-- 
cgit 1.4.1-3-g733a5


From d7a9ec2c5080dc69219e43ba8f221b4e61e47ce4 Mon Sep 17 00:00:00 2001
From: Yechan Bae <yechan@gatech.edu>
Date: Thu, 23 Sep 2021 06:45:24 -0400
Subject: Fix attribute handling

---
 clippy_lints/src/non_send_field_in_send_ty.rs |  57 ++++++-----
 tests/ui/non_send_field_in_send_ty.rs         |  38 ++++---
 tests/ui/non_send_field_in_send_ty.stderr     | 142 ++++++++++++++++++++++++++
 3 files changed, 197 insertions(+), 40 deletions(-)
 create mode 100644 tests/ui/non_send_field_in_send_ty.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/non_send_field_in_send_ty.rs b/clippy_lints/src/non_send_field_in_send_ty.rs
index 5d6501196cd..07b50cb8274 100644
--- a/clippy_lints/src/non_send_field_in_send_ty.rs
+++ b/clippy_lints/src/non_send_field_in_send_ty.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_note};
+use clippy_utils::diagnostics::span_lint_hir_and_then;
 use clippy_utils::ty::{implements_trait, is_copy};
 use rustc_ast::ImplPolarity;
 use rustc_hir::{Item, ItemKind};
@@ -39,17 +39,19 @@ declare_clippy_lint! {
     /// ```
     pub NON_SEND_FIELD_IN_SEND_TY,
     nursery,
-    "a field in a `Send` struct does not implement `Send`"
+    "there is field that does not implement `Send` in a `Send` struct"
 }
 
 declare_lint_pass!(NonSendFieldInSendTy => [NON_SEND_FIELD_IN_SEND_TY]);
 
 impl<'tcx> LateLintPass<'tcx> for NonSendFieldInSendTy {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
-        let send_trait = cx.tcx.get_diagnostic_item(sym::send_trait).unwrap();
-
-        // Check if we are in `Send` impl item
+        // Checks if we are in `Send` impl item.
+        // We start from `Send` impl instead of `check_field_def()` because
+        // single `AdtDef` may have multiple `Send` impls due to generic
+        // parameters, and the lint is much easier to implement in this way.
         if_chain! {
+            if let Some(send_trait) = cx.tcx.get_diagnostic_item(sym::send_trait);
             if let ItemKind::Impl(hir_impl) = &item.kind;
             if let Some(trait_ref) = &hir_impl.of_trait;
             if let Some(trait_id) = trait_ref.trait_def_id();
@@ -63,8 +65,6 @@ impl<'tcx> LateLintPass<'tcx> for NonSendFieldInSendTy {
                     for field in &variant.fields {
                         let field_ty = field.ty(cx.tcx, impl_trait_substs);
 
-                        // TODO: substs rebase_onto
-
                         if raw_pointer_in_ty_def(cx, field_ty)
                             || implements_trait(cx, field_ty, send_trait, &[])
                             || is_copy(cx, field_ty)
@@ -72,28 +72,31 @@ impl<'tcx> LateLintPass<'tcx> for NonSendFieldInSendTy {
                             continue;
                         }
 
-                        if let Some(field_span) = cx.tcx.hir().span_if_local(field.did) {
-                            if is_ty_param(field_ty) {
-                                span_lint_and_help(
-                                    cx,
-                                    NON_SEND_FIELD_IN_SEND_TY,
-                                    field_span,
-                                    "a field in a `Send` struct does not implement `Send`",
-                                    Some(item.span),
-                                    &format!("add `{}: Send` in `Send` impl for `{}`", field_ty, self_ty),
-                                )
-                            } else {
-                                span_lint_and_note(
+                        if let Some(field_hir_id) = field
+                            .did
+                            .as_local()
+                            .map(|local_def_id| cx.tcx.hir().local_def_id_to_hir_id(local_def_id))
+                        {
+                            if let Some(field_span) = cx.tcx.hir().span_if_local(field.did) {
+                                span_lint_hir_and_then(
                                     cx,
                                     NON_SEND_FIELD_IN_SEND_TY,
+                                    field_hir_id,
                                     field_span,
-                                    "a field in a `Send` struct does not implement `Send`",
-                                    Some(item.span),
-                                    &format!(
-                                        "type `{}` doesn't implement `Send` when `{}` is `Send`",
-                                        field_ty, self_ty
-                                    ),
-                                )
+                                    "non-`Send` field found in a `Send` struct",
+                                    |diag| {
+                                        diag.span_note(
+                                            item.span,
+                                            &format!(
+                                                "type `{}` doesn't implement `Send` when `{}` is `Send`",
+                                                field_ty, self_ty
+                                            ),
+                                        );
+                                        if is_ty_param(field_ty) {
+                                            diag.help(&format!("add `{}: Send` bound", field_ty));
+                                        }
+                                    },
+                                );
                             }
                         }
                     }
@@ -121,6 +124,6 @@ fn raw_pointer_in_ty_def<'tcx>(cx: &LateContext<'tcx>, target_ty: Ty<'tcx>) -> b
 }
 
 /// Returns `true` if the type is a type parameter such as `T`.
-fn is_ty_param<'tcx>(target_ty: Ty<'tcx>) -> bool {
+fn is_ty_param(target_ty: Ty<'_>) -> bool {
     matches!(target_ty.kind(), ty::Param(_))
 }
diff --git a/tests/ui/non_send_field_in_send_ty.rs b/tests/ui/non_send_field_in_send_ty.rs
index a0c574f8e59..b97501aa457 100644
--- a/tests/ui/non_send_field_in_send_ty.rs
+++ b/tests/ui/non_send_field_in_send_ty.rs
@@ -3,7 +3,7 @@
 
 use std::cell::UnsafeCell;
 use std::ptr::NonNull;
-use std::sync::{Arc, Mutex};
+use std::sync::{Arc, Mutex, MutexGuard};
 
 // disrustor / RUSTSEC-2020-0150
 pub struct RingBuffer<T> {
@@ -46,6 +46,22 @@ pub struct DeviceHandle<T: UsbContext> {
 
 unsafe impl<T: UsbContext> Send for DeviceHandle<T> {}
 
+// Other basic tests
+pub struct MultiField<T> {
+    field1: T,
+    field2: T,
+    field3: T,
+}
+
+unsafe impl<T> Send for MultiField<T> {}
+
+pub enum MyOption<T> {
+    MySome(T),
+    MyNone,
+}
+
+unsafe impl<T> Send for MyOption<T> {}
+
 // Raw pointers are allowed
 extern "C" {
     type SomeFfiType;
@@ -57,7 +73,7 @@ pub struct FpTest {
 
 unsafe impl Send for FpTest {}
 
-// Check raw pointer false positive
+// Test attributes
 #[allow(clippy::non_send_field_in_send_ty)]
 pub struct AttrTest1<T>(T);
 
@@ -76,19 +92,15 @@ unsafe impl<T> Send for AttrTest1<T> {}
 unsafe impl<T> Send for AttrTest2<T> {}
 unsafe impl<T> Send for AttrTest3<T> {}
 
-pub struct MultiField<T> {
-    field1: T,
-    field2: T,
-    field3: T,
+// Multiple non-overlapping `Send` for a single type
+pub struct Complex<A, B> {
+    field1: A,
+    field2: B,
 }
 
-unsafe impl<T> Send for MultiField<T> {}
+unsafe impl<P> Send for Complex<P, u32> {}
 
-pub enum MyOption<T> {
-    MySome(T),
-    MyNone,
-}
-
-unsafe impl<T> Send for MyOption<T> {}
+// `MutexGuard` is non-Send
+unsafe impl<Q: Send> Send for Complex<Q, MutexGuard<'static, bool>> {}
 
 fn main() {}
diff --git a/tests/ui/non_send_field_in_send_ty.stderr b/tests/ui/non_send_field_in_send_ty.stderr
new file mode 100644
index 00000000000..3a82828e0fe
--- /dev/null
+++ b/tests/ui/non_send_field_in_send_ty.stderr
@@ -0,0 +1,142 @@
+error: non-`Send` field found in a `Send` struct
+  --> $DIR/non_send_field_in_send_ty.rs:10:5
+   |
+LL |     data: Vec<UnsafeCell<T>>,
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::non-send-field-in-send-ty` implied by `-D warnings`
+note: type `std::vec::Vec<std::cell::UnsafeCell<T>>` doesn't implement `Send` when `RingBuffer<T>` is `Send`
+  --> $DIR/non_send_field_in_send_ty.rs:15:1
+   |
+LL | unsafe impl<T> Send for RingBuffer<T> {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: non-`Send` field found in a `Send` struct
+  --> $DIR/non_send_field_in_send_ty.rs:20:5
+   |
+LL |     lock: Mutex<Box<T>>,
+   |     ^^^^^^^^^^^^^^^^^^^
+   |
+note: type `std::sync::Mutex<std::boxed::Box<T>>` doesn't implement `Send` when `MvccRwLock<T>` is `Send`
+  --> $DIR/non_send_field_in_send_ty.rs:23:1
+   |
+LL | unsafe impl<T> Send for MvccRwLock<T> {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: non-`Send` field found in a `Send` struct
+  --> $DIR/non_send_field_in_send_ty.rs:28:5
+   |
+LL |     head: Arc<RC>,
+   |     ^^^^^^^^^^^^^
+   |
+note: type `std::sync::Arc<RC>` doesn't implement `Send` when `ArcGuard<RC, T>` is `Send`
+  --> $DIR/non_send_field_in_send_ty.rs:31:1
+   |
+LL | unsafe impl<RC, T: Send> Send for ArcGuard<RC, T> {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: non-`Send` field found in a `Send` struct
+  --> $DIR/non_send_field_in_send_ty.rs:43:5
+   |
+LL |     context: T,
+   |     ^^^^^^^^^^
+   |
+note: type `T` doesn't implement `Send` when `DeviceHandle<T>` is `Send`
+  --> $DIR/non_send_field_in_send_ty.rs:47:1
+   |
+LL | unsafe impl<T: UsbContext> Send for DeviceHandle<T> {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   = help: add `T: Send` bound
+
+error: non-`Send` field found in a `Send` struct
+  --> $DIR/non_send_field_in_send_ty.rs:51:5
+   |
+LL |     field1: T,
+   |     ^^^^^^^^^
+   |
+note: type `T` doesn't implement `Send` when `MultiField<T>` is `Send`
+  --> $DIR/non_send_field_in_send_ty.rs:56:1
+   |
+LL | unsafe impl<T> Send for MultiField<T> {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   = help: add `T: Send` bound
+
+error: non-`Send` field found in a `Send` struct
+  --> $DIR/non_send_field_in_send_ty.rs:52:5
+   |
+LL |     field2: T,
+   |     ^^^^^^^^^
+   |
+note: type `T` doesn't implement `Send` when `MultiField<T>` is `Send`
+  --> $DIR/non_send_field_in_send_ty.rs:56:1
+   |
+LL | unsafe impl<T> Send for MultiField<T> {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   = help: add `T: Send` bound
+
+error: non-`Send` field found in a `Send` struct
+  --> $DIR/non_send_field_in_send_ty.rs:53:5
+   |
+LL |     field3: T,
+   |     ^^^^^^^^^
+   |
+note: type `T` doesn't implement `Send` when `MultiField<T>` is `Send`
+  --> $DIR/non_send_field_in_send_ty.rs:56:1
+   |
+LL | unsafe impl<T> Send for MultiField<T> {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   = help: add `T: Send` bound
+
+error: non-`Send` field found in a `Send` struct
+  --> $DIR/non_send_field_in_send_ty.rs:59:12
+   |
+LL |     MySome(T),
+   |            ^
+   |
+note: type `T` doesn't implement `Send` when `MyOption<T>` is `Send`
+  --> $DIR/non_send_field_in_send_ty.rs:63:1
+   |
+LL | unsafe impl<T> Send for MyOption<T> {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   = help: add `T: Send` bound
+
+error: non-`Send` field found in a `Send` struct
+  --> $DIR/non_send_field_in_send_ty.rs:88:11
+   |
+LL |     Enum2(T),
+   |           ^
+   |
+note: type `T` doesn't implement `Send` when `AttrTest3<T>` is `Send`
+  --> $DIR/non_send_field_in_send_ty.rs:93:1
+   |
+LL | unsafe impl<T> Send for AttrTest3<T> {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   = help: add `T: Send` bound
+
+error: non-`Send` field found in a `Send` struct
+  --> $DIR/non_send_field_in_send_ty.rs:97:5
+   |
+LL |     field1: A,
+   |     ^^^^^^^^^
+   |
+note: type `P` doesn't implement `Send` when `Complex<P, u32>` is `Send`
+  --> $DIR/non_send_field_in_send_ty.rs:101:1
+   |
+LL | unsafe impl<P> Send for Complex<P, u32> {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   = help: add `P: Send` bound
+
+error: non-`Send` field found in a `Send` struct
+  --> $DIR/non_send_field_in_send_ty.rs:98:5
+   |
+LL |     field2: B,
+   |     ^^^^^^^^^
+   |
+note: type `std::sync::MutexGuard<'static, bool>` doesn't implement `Send` when `Complex<Q, std::sync::MutexGuard<'static, bool>>` is `Send`
+  --> $DIR/non_send_field_in_send_ty.rs:104:1
+   |
+LL | unsafe impl<Q: Send> Send for Complex<Q, MutexGuard<'static, bool>> {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 11 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 6458630e1aad3ef325b5839f5c3af665d837fa84 Mon Sep 17 00:00:00 2001
From: Yechan Bae <yechan@gatech.edu>
Date: Thu, 23 Sep 2021 06:49:23 -0400
Subject: typo

---
 clippy_lints/src/non_send_field_in_send_ty.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/non_send_field_in_send_ty.rs b/clippy_lints/src/non_send_field_in_send_ty.rs
index 07b50cb8274..7b81119448f 100644
--- a/clippy_lints/src/non_send_field_in_send_ty.rs
+++ b/clippy_lints/src/non_send_field_in_send_ty.rs
@@ -15,7 +15,7 @@ declare_clippy_lint! {
     /// Sending the struct to another thread and drops it there will also drop
     /// the field in the new thread. This effectively changes the ownership of
     /// the field type to the new thread and creates a soundness issue by
-    /// breaking breaks the non-`Send` invariant.
+    /// breaking the non-`Send` invariant.
     ///
     /// ### Known Problems
     /// Data structures that contain raw pointers may cause false positives.
-- 
cgit 1.4.1-3-g733a5


From a81a5ad1a87b0fd92d9d0310ae44ac582c814387 Mon Sep 17 00:00:00 2001
From: Yechan Bae <yechan@gatech.edu>
Date: Tue, 28 Sep 2021 13:46:13 -0400
Subject: Update documentation

---
 clippy_lints/src/non_send_field_in_send_ty.rs | 35 +++++++++++++++------------
 1 file changed, 19 insertions(+), 16 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/non_send_field_in_send_ty.rs b/clippy_lints/src/non_send_field_in_send_ty.rs
index 7b81119448f..d141cd2199f 100644
--- a/clippy_lints/src/non_send_field_in_send_ty.rs
+++ b/clippy_lints/src/non_send_field_in_send_ty.rs
@@ -12,31 +12,34 @@ declare_clippy_lint! {
     /// Warns about a field in a `Send` struct that is neither `Send` nor `Copy`.
     ///
     /// ### Why is this bad?
-    /// Sending the struct to another thread and drops it there will also drop
-    /// the field in the new thread. This effectively changes the ownership of
-    /// the field type to the new thread and creates a soundness issue by
-    /// breaking the non-`Send` invariant.
+    /// Sending the struct to another thread will transfer the ownership to
+    /// the new thread by dropping in the current thread during the transfer.
+    /// This causes soundness issues for non-`Send` fields, as they are also
+    /// dropped and might not be set up to handle this.
+    ///
+    /// See:
+    /// * [*The Rustonomicon* about *Send and Sync*](https://doc.rust-lang.org/nomicon/send-and-sync.html)
+    /// * [The documentation of `Send`](https://doc.rust-lang.org/std/marker/trait.Send.html)
     ///
     /// ### Known Problems
     /// Data structures that contain raw pointers may cause false positives.
     /// They are sometimes safe to be sent across threads but do not implement
     /// the `Send` trait. This lint has a heuristic to filter out basic cases
-    /// such as `Vec<*const T>`, but it's not perfect.
+    /// such as `Vec<*const T>`, but it's not perfect. Feel free to create an
+    /// issue if you have a suggestion on how this heuristic can be improved.
     ///
     /// ### Example
-    /// ```rust
-    /// use std::sync::Arc;
-    ///
-    /// // There is no `RC: Send` bound here
-    /// unsafe impl<RC, T: Send> Send for ArcGuard<RC, T> {}
-    ///
-    /// #[derive(Debug, Clone)]
-    /// pub struct ArcGuard<RC, T> {
-    ///     inner: T,
-    ///     // Possibly drops `Arc<RC>` (and in turn `RC`) on a wrong thread
-    ///     head: Arc<RC>
+    /// ```rust,ignore
+    /// struct ExampleStruct<T> {
+    ///     rc_is_not_send: Rc<String>,
+    ///     unbounded_generic_field: T,
     /// }
+    ///
+    /// // This impl is unsound because it allows sending `!Send` types through `ExampleStruct`
+    /// unsafe impl<T> Send for ExampleStruct<T> {}
     /// ```
+    /// Use thread-safe types like [`std::sync::Arc`](https://doc.rust-lang.org/std/sync/struct.Arc.html)
+    /// and specify correct bounds on generic type parameters (`T: Send`).
     pub NON_SEND_FIELD_IN_SEND_TY,
     nursery,
     "there is field that does not implement `Send` in a `Send` struct"
-- 
cgit 1.4.1-3-g733a5


From ee74574876e74a00eeae9c36f662d20fd6c61c0a Mon Sep 17 00:00:00 2001
From: Yechan Bae <yechan@gatech.edu>
Date: Tue, 28 Sep 2021 15:23:39 -0400
Subject: Emit one report for all fields in the same ADT

---
 clippy_lints/src/non_send_field_in_send_ty.rs | 120 +++++++++++-----
 tests/ui/non_send_field_in_send_ty.rs         |  14 ++
 tests/ui/non_send_field_in_send_ty.stderr     | 192 ++++++++++++++------------
 3 files changed, 203 insertions(+), 123 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/non_send_field_in_send_ty.rs b/clippy_lints/src/non_send_field_in_send_ty.rs
index d141cd2199f..0fa994cacb1 100644
--- a/clippy_lints/src/non_send_field_in_send_ty.rs
+++ b/clippy_lints/src/non_send_field_in_send_ty.rs
@@ -1,11 +1,14 @@
-use clippy_utils::diagnostics::span_lint_hir_and_then;
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::is_lint_allowed;
 use clippy_utils::ty::{implements_trait, is_copy};
 use rustc_ast::ImplPolarity;
+use rustc_hir::def_id::DefId;
 use rustc_hir::{Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{self, subst::GenericArgKind, Ty};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::sym;
+use rustc_span::symbol::Symbol;
+use rustc_span::{sym, Span};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -64,51 +67,98 @@ impl<'tcx> LateLintPass<'tcx> for NonSendFieldInSendTy {
             if let self_ty = ty_trait_ref.self_ty();
             if let ty::Adt(adt_def, impl_trait_substs) = self_ty.kind();
             then {
+                let mut non_send_fields = Vec::new();
+
+                let hir_map = cx.tcx.hir();
                 for variant in &adt_def.variants {
                     for field in &variant.fields {
-                        let field_ty = field.ty(cx.tcx, impl_trait_substs);
-
-                        if raw_pointer_in_ty_def(cx, field_ty)
-                            || implements_trait(cx, field_ty, send_trait, &[])
-                            || is_copy(cx, field_ty)
-                        {
-                            continue;
+                        if_chain! {
+                            if let Some(field_hir_id) = field
+                                .did
+                                .as_local()
+                                .map(|local_def_id| hir_map.local_def_id_to_hir_id(local_def_id));
+                            if !is_lint_allowed(cx, NON_SEND_FIELD_IN_SEND_TY, field_hir_id);
+                            if let field_ty = field.ty(cx.tcx, impl_trait_substs);
+                            if !ty_allowed_in_send(cx, field_ty, send_trait);
+                            if let Some(field_span) = hir_map.span_if_local(field.did);
+                            then {
+                                non_send_fields.push(NonSendField {
+                                    name: hir_map.name(field_hir_id),
+                                    span: field_span,
+                                    ty: field_ty,
+                                    generic_params: collect_generic_params(cx, field_ty),
+                                })
+                            }
                         }
+                    }
+                }
 
-                        if let Some(field_hir_id) = field
-                            .did
-                            .as_local()
-                            .map(|local_def_id| cx.tcx.hir().local_def_id_to_hir_id(local_def_id))
-                        {
-                            if let Some(field_span) = cx.tcx.hir().span_if_local(field.did) {
-                                span_lint_hir_and_then(
-                                    cx,
-                                    NON_SEND_FIELD_IN_SEND_TY,
-                                    field_hir_id,
-                                    field_span,
-                                    "non-`Send` field found in a `Send` struct",
-                                    |diag| {
-                                        diag.span_note(
-                                            item.span,
-                                            &format!(
-                                                "type `{}` doesn't implement `Send` when `{}` is `Send`",
-                                                field_ty, self_ty
-                                            ),
-                                        );
-                                        if is_ty_param(field_ty) {
-                                            diag.help(&format!("add `{}: Send` bound", field_ty));
-                                        }
-                                    },
+                if !non_send_fields.is_empty() {
+                    span_lint_and_then(
+                        cx,
+                        NON_SEND_FIELD_IN_SEND_TY,
+                        item.span,
+                        &format!(
+                            "this implementation is unsound, as some fields in `{}` are `!Send`",
+                            self_ty
+                        ),
+                        |diag| {
+                            for field in non_send_fields {
+                                diag.span_note(
+                                    field.span,
+                                    &format!("the field `{}` has type `{}` which is not `Send`", field.name, field.ty),
                                 );
+
+                                match field.generic_params.len() {
+                                    0 => diag.help("use a thread-safe type that implements `Send`"),
+                                    1 if is_ty_param(field.ty) => diag.help(&format!("add `{}: Send` bound in `Send` impl", field.ty)),
+                                    _ => diag.help(&format!(
+                                        "add bounds on type parameter{} `{}` that satisfy `{}: Send`",
+                                        if field.generic_params.len() > 1 { "s" } else { "" },
+                                        field.generic_params_string(),
+                                        field.ty
+                                    )),
+                                };
                             }
-                        }
-                    }
+                        },
+                    )
                 }
             }
         }
     }
 }
 
+struct NonSendField<'tcx> {
+    name: Symbol,
+    span: Span,
+    ty: Ty<'tcx>,
+    generic_params: Vec<Ty<'tcx>>,
+}
+
+impl<'tcx> NonSendField<'tcx> {
+    fn generic_params_string(&self) -> String {
+        self.generic_params
+            .iter()
+            .map(ToString::to_string)
+            .collect::<Vec<_>>()
+            .join(", ")
+    }
+}
+
+fn collect_generic_params<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Vec<Ty<'tcx>> {
+    ty.walk(cx.tcx)
+        .filter_map(|inner| match inner.unpack() {
+            GenericArgKind::Type(inner_ty) => Some(inner_ty),
+            _ => None,
+        })
+        .filter(|&inner_ty| is_ty_param(inner_ty))
+        .collect()
+}
+
+fn ty_allowed_in_send<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>, send_trait: DefId) -> bool {
+    raw_pointer_in_ty_def(cx, ty) || implements_trait(cx, ty, send_trait, &[]) || is_copy(cx, ty)
+}
+
 /// Returns `true` if the type itself is a raw pointer or has a raw pointer as a
 /// generic parameter, e.g., `Vec<*const u8>`.
 /// Note that it does not look into enum variants or struct fields.
diff --git a/tests/ui/non_send_field_in_send_ty.rs b/tests/ui/non_send_field_in_send_ty.rs
index b97501aa457..cf4fc1fd9b8 100644
--- a/tests/ui/non_send_field_in_send_ty.rs
+++ b/tests/ui/non_send_field_in_send_ty.rs
@@ -3,6 +3,7 @@
 
 use std::cell::UnsafeCell;
 use std::ptr::NonNull;
+use std::rc::Rc;
 use std::sync::{Arc, Mutex, MutexGuard};
 
 // disrustor / RUSTSEC-2020-0150
@@ -47,6 +48,12 @@ pub struct DeviceHandle<T: UsbContext> {
 unsafe impl<T: UsbContext> Send for DeviceHandle<T> {}
 
 // Other basic tests
+pub struct NoGeneric {
+    rc_is_not_send: Rc<String>,
+}
+
+unsafe impl Send for NoGeneric {}
+
 pub struct MultiField<T> {
     field1: T,
     field2: T,
@@ -62,6 +69,13 @@ pub enum MyOption<T> {
 
 unsafe impl<T> Send for MyOption<T> {}
 
+// Multiple type parameters
+pub struct MultiParam<A, B> {
+    vec: Vec<(A, B)>,
+}
+
+unsafe impl<A, B> Send for MultiParam<A, B> {}
+
 // Raw pointers are allowed
 extern "C" {
     type SomeFfiType;
diff --git a/tests/ui/non_send_field_in_send_ty.stderr b/tests/ui/non_send_field_in_send_ty.stderr
index 3a82828e0fe..52cc038b658 100644
--- a/tests/ui/non_send_field_in_send_ty.stderr
+++ b/tests/ui/non_send_field_in_send_ty.stderr
@@ -1,142 +1,158 @@
-error: non-`Send` field found in a `Send` struct
-  --> $DIR/non_send_field_in_send_ty.rs:10:5
-   |
-LL |     data: Vec<UnsafeCell<T>>,
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: `-D clippy::non-send-field-in-send-ty` implied by `-D warnings`
-note: type `std::vec::Vec<std::cell::UnsafeCell<T>>` doesn't implement `Send` when `RingBuffer<T>` is `Send`
-  --> $DIR/non_send_field_in_send_ty.rs:15:1
+error: this implementation is unsound, as some fields in `RingBuffer<T>` are `!Send`
+  --> $DIR/non_send_field_in_send_ty.rs:16:1
    |
 LL | unsafe impl<T> Send for RingBuffer<T> {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: non-`Send` field found in a `Send` struct
-  --> $DIR/non_send_field_in_send_ty.rs:20:5
    |
-LL |     lock: Mutex<Box<T>>,
-   |     ^^^^^^^^^^^^^^^^^^^
+   = note: `-D clippy::non-send-field-in-send-ty` implied by `-D warnings`
+note: the field `data` has type `std::vec::Vec<std::cell::UnsafeCell<T>>` which is not `Send`
+  --> $DIR/non_send_field_in_send_ty.rs:11:5
    |
-note: type `std::sync::Mutex<std::boxed::Box<T>>` doesn't implement `Send` when `MvccRwLock<T>` is `Send`
-  --> $DIR/non_send_field_in_send_ty.rs:23:1
+LL |     data: Vec<UnsafeCell<T>>,
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^
+   = help: add bounds on type parameter `T` that satisfy `std::vec::Vec<std::cell::UnsafeCell<T>>: Send`
+
+error: this implementation is unsound, as some fields in `MvccRwLock<T>` are `!Send`
+  --> $DIR/non_send_field_in_send_ty.rs:24:1
    |
 LL | unsafe impl<T> Send for MvccRwLock<T> {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: non-`Send` field found in a `Send` struct
-  --> $DIR/non_send_field_in_send_ty.rs:28:5
    |
-LL |     head: Arc<RC>,
-   |     ^^^^^^^^^^^^^
+note: the field `lock` has type `std::sync::Mutex<std::boxed::Box<T>>` which is not `Send`
+  --> $DIR/non_send_field_in_send_ty.rs:21:5
    |
-note: type `std::sync::Arc<RC>` doesn't implement `Send` when `ArcGuard<RC, T>` is `Send`
-  --> $DIR/non_send_field_in_send_ty.rs:31:1
+LL |     lock: Mutex<Box<T>>,
+   |     ^^^^^^^^^^^^^^^^^^^
+   = help: add bounds on type parameter `T` that satisfy `std::sync::Mutex<std::boxed::Box<T>>: Send`
+
+error: this implementation is unsound, as some fields in `ArcGuard<RC, T>` are `!Send`
+  --> $DIR/non_send_field_in_send_ty.rs:32:1
    |
 LL | unsafe impl<RC, T: Send> Send for ArcGuard<RC, T> {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: non-`Send` field found in a `Send` struct
-  --> $DIR/non_send_field_in_send_ty.rs:43:5
    |
-LL |     context: T,
-   |     ^^^^^^^^^^
+note: the field `head` has type `std::sync::Arc<RC>` which is not `Send`
+  --> $DIR/non_send_field_in_send_ty.rs:29:5
    |
-note: type `T` doesn't implement `Send` when `DeviceHandle<T>` is `Send`
-  --> $DIR/non_send_field_in_send_ty.rs:47:1
+LL |     head: Arc<RC>,
+   |     ^^^^^^^^^^^^^
+   = help: add bounds on type parameter `RC` that satisfy `std::sync::Arc<RC>: Send`
+
+error: this implementation is unsound, as some fields in `DeviceHandle<T>` are `!Send`
+  --> $DIR/non_send_field_in_send_ty.rs:48:1
    |
 LL | unsafe impl<T: UsbContext> Send for DeviceHandle<T> {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   = help: add `T: Send` bound
+   |
+note: the field `context` has type `T` which is not `Send`
+  --> $DIR/non_send_field_in_send_ty.rs:44:5
+   |
+LL |     context: T,
+   |     ^^^^^^^^^^
+   = help: add `T: Send` bound in `Send` impl
 
-error: non-`Send` field found in a `Send` struct
-  --> $DIR/non_send_field_in_send_ty.rs:51:5
+error: this implementation is unsound, as some fields in `NoGeneric` are `!Send`
+  --> $DIR/non_send_field_in_send_ty.rs:55:1
    |
-LL |     field1: T,
-   |     ^^^^^^^^^
+LL | unsafe impl Send for NoGeneric {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: the field `rc_is_not_send` has type `std::rc::Rc<std::string::String>` which is not `Send`
+  --> $DIR/non_send_field_in_send_ty.rs:52:5
    |
-note: type `T` doesn't implement `Send` when `MultiField<T>` is `Send`
-  --> $DIR/non_send_field_in_send_ty.rs:56:1
+LL |     rc_is_not_send: Rc<String>,
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   = help: use a thread-safe type that implements `Send`
+
+error: this implementation is unsound, as some fields in `MultiField<T>` are `!Send`
+  --> $DIR/non_send_field_in_send_ty.rs:63:1
    |
 LL | unsafe impl<T> Send for MultiField<T> {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   = help: add `T: Send` bound
-
-error: non-`Send` field found in a `Send` struct
-  --> $DIR/non_send_field_in_send_ty.rs:52:5
    |
-LL |     field2: T,
-   |     ^^^^^^^^^
+note: the field `field1` has type `T` which is not `Send`
+  --> $DIR/non_send_field_in_send_ty.rs:58:5
    |
-note: type `T` doesn't implement `Send` when `MultiField<T>` is `Send`
-  --> $DIR/non_send_field_in_send_ty.rs:56:1
+LL |     field1: T,
+   |     ^^^^^^^^^
+   = help: add `T: Send` bound in `Send` impl
+note: the field `field2` has type `T` which is not `Send`
+  --> $DIR/non_send_field_in_send_ty.rs:59:5
    |
-LL | unsafe impl<T> Send for MultiField<T> {}
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   = help: add `T: Send` bound
-
-error: non-`Send` field found in a `Send` struct
-  --> $DIR/non_send_field_in_send_ty.rs:53:5
+LL |     field2: T,
+   |     ^^^^^^^^^
+   = help: add `T: Send` bound in `Send` impl
+note: the field `field3` has type `T` which is not `Send`
+  --> $DIR/non_send_field_in_send_ty.rs:60:5
    |
 LL |     field3: T,
    |     ^^^^^^^^^
+   = help: add `T: Send` bound in `Send` impl
+
+error: this implementation is unsound, as some fields in `MyOption<T>` are `!Send`
+  --> $DIR/non_send_field_in_send_ty.rs:70:1
    |
-note: type `T` doesn't implement `Send` when `MultiField<T>` is `Send`
-  --> $DIR/non_send_field_in_send_ty.rs:56:1
+LL | unsafe impl<T> Send for MyOption<T> {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-LL | unsafe impl<T> Send for MultiField<T> {}
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   = help: add `T: Send` bound
-
-error: non-`Send` field found in a `Send` struct
-  --> $DIR/non_send_field_in_send_ty.rs:59:12
+note: the field `0` has type `T` which is not `Send`
+  --> $DIR/non_send_field_in_send_ty.rs:66:12
    |
 LL |     MySome(T),
    |            ^
-   |
-note: type `T` doesn't implement `Send` when `MyOption<T>` is `Send`
-  --> $DIR/non_send_field_in_send_ty.rs:63:1
-   |
-LL | unsafe impl<T> Send for MyOption<T> {}
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   = help: add `T: Send` bound
+   = help: add `T: Send` bound in `Send` impl
 
-error: non-`Send` field found in a `Send` struct
-  --> $DIR/non_send_field_in_send_ty.rs:88:11
+error: this implementation is unsound, as some fields in `MultiParam<A, B>` are `!Send`
+  --> $DIR/non_send_field_in_send_ty.rs:77:1
    |
-LL |     Enum2(T),
-   |           ^
+LL | unsafe impl<A, B> Send for MultiParam<A, B> {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: the field `vec` has type `std::vec::Vec<(A, B)>` which is not `Send`
+  --> $DIR/non_send_field_in_send_ty.rs:74:5
    |
-note: type `T` doesn't implement `Send` when `AttrTest3<T>` is `Send`
-  --> $DIR/non_send_field_in_send_ty.rs:93:1
+LL |     vec: Vec<(A, B)>,
+   |     ^^^^^^^^^^^^^^^^
+   = help: add bounds on type parameters `A, B` that satisfy `std::vec::Vec<(A, B)>: Send`
+
+error: this implementation is unsound, as some fields in `AttrTest3<T>` are `!Send`
+  --> $DIR/non_send_field_in_send_ty.rs:107:1
    |
 LL | unsafe impl<T> Send for AttrTest3<T> {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   = help: add `T: Send` bound
-
-error: non-`Send` field found in a `Send` struct
-  --> $DIR/non_send_field_in_send_ty.rs:97:5
    |
-LL |     field1: A,
-   |     ^^^^^^^^^
+note: the field `0` has type `T` which is not `Send`
+  --> $DIR/non_send_field_in_send_ty.rs:102:11
    |
-note: type `P` doesn't implement `Send` when `Complex<P, u32>` is `Send`
-  --> $DIR/non_send_field_in_send_ty.rs:101:1
+LL |     Enum2(T),
+   |           ^
+   = help: add `T: Send` bound in `Send` impl
+
+error: this implementation is unsound, as some fields in `Complex<P, u32>` are `!Send`
+  --> $DIR/non_send_field_in_send_ty.rs:115:1
    |
 LL | unsafe impl<P> Send for Complex<P, u32> {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   = help: add `P: Send` bound
-
-error: non-`Send` field found in a `Send` struct
-  --> $DIR/non_send_field_in_send_ty.rs:98:5
    |
-LL |     field2: B,
-   |     ^^^^^^^^^
+note: the field `field1` has type `P` which is not `Send`
+  --> $DIR/non_send_field_in_send_ty.rs:111:5
    |
-note: type `std::sync::MutexGuard<'static, bool>` doesn't implement `Send` when `Complex<Q, std::sync::MutexGuard<'static, bool>>` is `Send`
-  --> $DIR/non_send_field_in_send_ty.rs:104:1
+LL |     field1: A,
+   |     ^^^^^^^^^
+   = help: add `P: Send` bound in `Send` impl
+
+error: this implementation is unsound, as some fields in `Complex<Q, std::sync::MutexGuard<'static, bool>>` are `!Send`
+  --> $DIR/non_send_field_in_send_ty.rs:118:1
    |
 LL | unsafe impl<Q: Send> Send for Complex<Q, MutexGuard<'static, bool>> {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: the field `field2` has type `std::sync::MutexGuard<'static, bool>` which is not `Send`
+  --> $DIR/non_send_field_in_send_ty.rs:112:5
+   |
+LL |     field2: B,
+   |     ^^^^^^^^^
+   = help: use a thread-safe type that implements `Send`
 
 error: aborting due to 11 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From d413e157a5410b40eaa42decad6bf9d85a577a2d Mon Sep 17 00:00:00 2001
From: Yechan Bae <yechan@gatech.edu>
Date: Tue, 28 Sep 2021 16:42:27 -0400
Subject: Look into tuple, array, ADT args in raw pointer heuristic

---
 clippy_lints/src/non_send_field_in_send_ty.rs | 49 +++++++++++++++++++++++----
 tests/ui/non_send_field_in_send_ty.rs         | 17 +++++++---
 tests/ui/non_send_field_in_send_ty.stderr     | 27 +++++++++++----
 3 files changed, 74 insertions(+), 19 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/non_send_field_in_send_ty.rs b/clippy_lints/src/non_send_field_in_send_ty.rs
index 0fa994cacb1..f800d3ff7e1 100644
--- a/clippy_lints/src/non_send_field_in_send_ty.rs
+++ b/clippy_lints/src/non_send_field_in_send_ty.rs
@@ -121,7 +121,7 @@ impl<'tcx> LateLintPass<'tcx> for NonSendFieldInSendTy {
                                 };
                             }
                         },
-                    )
+                    );
                 }
             }
         }
@@ -145,6 +145,8 @@ impl<'tcx> NonSendField<'tcx> {
     }
 }
 
+/// Given a type, collect all of its generic parameters.
+/// Example: MyStruct<P, Box<Q, R>> => vec![P, Q, R]
 fn collect_generic_params<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Vec<Ty<'tcx>> {
     ty.walk(cx.tcx)
         .filter_map(|inner| match inner.unpack() {
@@ -155,14 +157,47 @@ fn collect_generic_params<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Vec<Ty<
         .collect()
 }
 
-fn ty_allowed_in_send<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>, send_trait: DefId) -> bool {
-    raw_pointer_in_ty_def(cx, ty) || implements_trait(cx, ty, send_trait, &[]) || is_copy(cx, ty)
+/// Determine if the given type is allowed in an ADT that implements `Send`
+fn ty_allowed_in_send(cx: &LateContext<'tcx>, ty: Ty<'tcx>, send_trait: DefId) -> bool {
+    // TODO: check configuration and call `ty_implements_send_or_copy()` or
+    // `ty_allowed_with_raw_pointer_heuristic()`
+    ty_allowed_with_raw_pointer_heuristic(cx, ty, send_trait)
 }
 
-/// Returns `true` if the type itself is a raw pointer or has a raw pointer as a
-/// generic parameter, e.g., `Vec<*const u8>`.
-/// Note that it does not look into enum variants or struct fields.
-fn raw_pointer_in_ty_def<'tcx>(cx: &LateContext<'tcx>, target_ty: Ty<'tcx>) -> bool {
+/// Determine if the given type is `Send` or `Copy`
+fn ty_implements_send_or_copy(cx: &LateContext<'tcx>, ty: Ty<'tcx>, send_trait: DefId) -> bool {
+    implements_trait(cx, ty, send_trait, &[]) || is_copy(cx, ty)
+}
+
+/// Heuristic to allow cases like `Vec<*const u8>`
+fn ty_allowed_with_raw_pointer_heuristic<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>, send_trait: DefId) -> bool {
+    if ty_implements_send_or_copy(cx, ty, send_trait) {
+        true
+    } else {
+        // The type is known to be `!Send` and `!Copy`
+        match ty.kind() {
+            ty::Tuple(_) => ty
+                .tuple_fields()
+                .all(|ty| ty_allowed_with_raw_pointer_heuristic(cx, ty, send_trait)),
+            ty::Array(ty, _) | ty::Slice(ty) => ty_allowed_with_raw_pointer_heuristic(cx, ty, send_trait),
+            ty::Adt(_, substs) => {
+                if contains_raw_pointer(cx, ty) {
+                    // descends only if ADT contains any raw pointers
+                    substs.iter().all(|generic_arg| match generic_arg.unpack() {
+                        GenericArgKind::Type(ty) => ty_allowed_with_raw_pointer_heuristic(cx, ty, send_trait),
+                        GenericArgKind::Lifetime(_) | GenericArgKind::Const(_) => true,
+                    })
+                } else {
+                    false
+                }
+            },
+            ty::RawPtr(_) => true,
+            _ => false,
+        }
+    }
+}
+
+fn contains_raw_pointer<'tcx>(cx: &LateContext<'tcx>, target_ty: Ty<'tcx>) -> bool {
     for ty_node in target_ty.walk(cx.tcx) {
         if_chain! {
             if let GenericArgKind::Type(inner_ty) = ty_node.unpack();
diff --git a/tests/ui/non_send_field_in_send_ty.rs b/tests/ui/non_send_field_in_send_ty.rs
index cf4fc1fd9b8..f5e7abdecd1 100644
--- a/tests/ui/non_send_field_in_send_ty.rs
+++ b/tests/ui/non_send_field_in_send_ty.rs
@@ -76,16 +76,23 @@ pub struct MultiParam<A, B> {
 
 unsafe impl<A, B> Send for MultiParam<A, B> {}
 
-// Raw pointers are allowed
+// Tests for raw pointer heuristic
 extern "C" {
-    type SomeFfiType;
+    type NonSend;
 }
 
-pub struct FpTest {
-    vec: Vec<*const SomeFfiType>,
+pub struct HeuristicTest {
+    // raw pointers are allowed
+    field1: Vec<*const NonSend>,
+    field2: [*const NonSend; 3],
+    field3: (*const NonSend, *const NonSend, *const NonSend),
+    // not allowed when it contains concrete `!Send` field
+    field4: (*const NonSend, Rc<u8>),
+    // nested raw pointer is also allowed
+    field5: Vec<Vec<*const NonSend>>,
 }
 
-unsafe impl Send for FpTest {}
+unsafe impl Send for HeuristicTest {}
 
 // Test attributes
 #[allow(clippy::non_send_field_in_send_ty)]
diff --git a/tests/ui/non_send_field_in_send_ty.stderr b/tests/ui/non_send_field_in_send_ty.stderr
index 52cc038b658..327ef9fc2d6 100644
--- a/tests/ui/non_send_field_in_send_ty.stderr
+++ b/tests/ui/non_send_field_in_send_ty.stderr
@@ -115,44 +115,57 @@ LL |     vec: Vec<(A, B)>,
    |     ^^^^^^^^^^^^^^^^
    = help: add bounds on type parameters `A, B` that satisfy `std::vec::Vec<(A, B)>: Send`
 
+error: this implementation is unsound, as some fields in `HeuristicTest` are `!Send`
+  --> $DIR/non_send_field_in_send_ty.rs:95:1
+   |
+LL | unsafe impl Send for HeuristicTest {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: the field `field4` has type `(*const NonSend, std::rc::Rc<u8>)` which is not `Send`
+  --> $DIR/non_send_field_in_send_ty.rs:90:5
+   |
+LL |     field4: (*const NonSend, Rc<u8>),
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   = help: use a thread-safe type that implements `Send`
+
 error: this implementation is unsound, as some fields in `AttrTest3<T>` are `!Send`
-  --> $DIR/non_send_field_in_send_ty.rs:107:1
+  --> $DIR/non_send_field_in_send_ty.rs:114:1
    |
 LL | unsafe impl<T> Send for AttrTest3<T> {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: the field `0` has type `T` which is not `Send`
-  --> $DIR/non_send_field_in_send_ty.rs:102:11
+  --> $DIR/non_send_field_in_send_ty.rs:109:11
    |
 LL |     Enum2(T),
    |           ^
    = help: add `T: Send` bound in `Send` impl
 
 error: this implementation is unsound, as some fields in `Complex<P, u32>` are `!Send`
-  --> $DIR/non_send_field_in_send_ty.rs:115:1
+  --> $DIR/non_send_field_in_send_ty.rs:122:1
    |
 LL | unsafe impl<P> Send for Complex<P, u32> {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: the field `field1` has type `P` which is not `Send`
-  --> $DIR/non_send_field_in_send_ty.rs:111:5
+  --> $DIR/non_send_field_in_send_ty.rs:118:5
    |
 LL |     field1: A,
    |     ^^^^^^^^^
    = help: add `P: Send` bound in `Send` impl
 
 error: this implementation is unsound, as some fields in `Complex<Q, std::sync::MutexGuard<'static, bool>>` are `!Send`
-  --> $DIR/non_send_field_in_send_ty.rs:118:1
+  --> $DIR/non_send_field_in_send_ty.rs:125:1
    |
 LL | unsafe impl<Q: Send> Send for Complex<Q, MutexGuard<'static, bool>> {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: the field `field2` has type `std::sync::MutexGuard<'static, bool>` which is not `Send`
-  --> $DIR/non_send_field_in_send_ty.rs:112:5
+  --> $DIR/non_send_field_in_send_ty.rs:119:5
    |
 LL |     field2: B,
    |     ^^^^^^^^^
    = help: use a thread-safe type that implements `Send`
 
-error: aborting due to 11 previous errors
+error: aborting due to 12 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 427a09ba7bb91cc692cd3101d3c8d84a21a64d1c Mon Sep 17 00:00:00 2001
From: Yechan Bae <yechan@gatech.edu>
Date: Tue, 28 Sep 2021 16:55:36 -0400
Subject: Add configuration for raw pointer heuristic

---
 clippy_lints/src/lib.rs                            |  3 ++-
 clippy_lints/src/non_send_field_in_send_ty.rs      | 30 +++++++++++++++-------
 clippy_lints/src/utils/conf.rs                     |  4 +++
 .../toml_unknown_key/conf_unknown_key.stderr       |  2 +-
 4 files changed, 28 insertions(+), 11 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 93b93bcba48..f9d660972cb 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -535,7 +535,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(move || Box::new(feature_name::FeatureName));
     store.register_late_pass(move || Box::new(iter_not_returning_iterator::IterNotReturningIterator));
     store.register_late_pass(move || Box::new(if_then_panic::IfThenPanic));
-    store.register_late_pass(|| Box::new(non_send_field_in_send_ty::NonSendFieldInSendTy));
+    let enable_raw_pointer_heuristic = conf.enable_raw_pointer_heuristic;
+    store.register_late_pass(move || Box::new(non_send_field_in_send_ty::NonSendFieldInSendTy::new(enable_raw_pointer_heuristic)));
 }
 
 #[rustfmt::skip]
diff --git a/clippy_lints/src/non_send_field_in_send_ty.rs b/clippy_lints/src/non_send_field_in_send_ty.rs
index f800d3ff7e1..706214cb3d5 100644
--- a/clippy_lints/src/non_send_field_in_send_ty.rs
+++ b/clippy_lints/src/non_send_field_in_send_ty.rs
@@ -6,7 +6,7 @@ use rustc_hir::def_id::DefId;
 use rustc_hir::{Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{self, subst::GenericArgKind, Ty};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::symbol::Symbol;
 use rustc_span::{sym, Span};
 
@@ -48,10 +48,29 @@ declare_clippy_lint! {
     "there is field that does not implement `Send` in a `Send` struct"
 }
 
-declare_lint_pass!(NonSendFieldInSendTy => [NON_SEND_FIELD_IN_SEND_TY]);
+#[derive(Copy, Clone)]
+pub struct NonSendFieldInSendTy {
+    enable_raw_pointer_heuristic: bool,
+}
+
+impl NonSendFieldInSendTy {
+    pub fn new(enable_raw_pointer_heuristic: bool) -> Self {
+        Self {
+            enable_raw_pointer_heuristic,
+        }
+    }
+}
+
+impl_lint_pass!(NonSendFieldInSendTy => [NON_SEND_FIELD_IN_SEND_TY]);
 
 impl<'tcx> LateLintPass<'tcx> for NonSendFieldInSendTy {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
+        let ty_allowed_in_send = if self.enable_raw_pointer_heuristic {
+            ty_allowed_with_raw_pointer_heuristic
+        } else {
+            ty_implements_send_or_copy
+        };
+
         // Checks if we are in `Send` impl item.
         // We start from `Send` impl instead of `check_field_def()` because
         // single `AdtDef` may have multiple `Send` impls due to generic
@@ -157,13 +176,6 @@ fn collect_generic_params<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Vec<Ty<
         .collect()
 }
 
-/// Determine if the given type is allowed in an ADT that implements `Send`
-fn ty_allowed_in_send(cx: &LateContext<'tcx>, ty: Ty<'tcx>, send_trait: DefId) -> bool {
-    // TODO: check configuration and call `ty_implements_send_or_copy()` or
-    // `ty_allowed_with_raw_pointer_heuristic()`
-    ty_allowed_with_raw_pointer_heuristic(cx, ty, send_trait)
-}
-
 /// Determine if the given type is `Send` or `Copy`
 fn ty_implements_send_or_copy(cx: &LateContext<'tcx>, ty: Ty<'tcx>, send_trait: DefId) -> bool {
     implements_trait(cx, ty, send_trait, &[]) || is_copy(cx, ty)
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 1e0447239be..177c0fd375c 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -284,6 +284,10 @@ define_Conf! {
     ///
     /// The list of unicode scripts allowed to be used in the scope.
     (allowed_scripts: Vec<String> = vec!["Latin".to_string()]),
+    /// Lint: NON_SEND_FIELD_IN_SEND_TY.
+    ///
+    /// Whether to apply the raw pointer heuristic in `non_send_field_in_send_ty` lint.
+    (enable_raw_pointer_heuristic: bool = true),
 }
 
 /// Search for the configuration file.
diff --git a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
index e0029ebeb27..0eff2be7960 100644
--- a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
+++ b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
@@ -1,4 +1,4 @@
-error: error reading Clippy's configuration file `$DIR/clippy.toml`: unknown field `foobar`, expected one of `avoid-breaking-exported-api`, `msrv`, `blacklisted-names`, `cognitive-complexity-threshold`, `cyclomatic-complexity-threshold`, `doc-valid-idents`, `too-many-arguments-threshold`, `type-complexity-threshold`, `single-char-binding-names-threshold`, `too-large-for-stack`, `enum-variant-name-threshold`, `enum-variant-size-threshold`, `verbose-bit-mask-threshold`, `literal-representation-threshold`, `trivial-copy-size-limit`, `pass-by-value-size-limit`, `too-many-lines-threshold`, `array-size-threshold`, `vec-box-size-threshold`, `max-trait-bounds`, `max-struct-bools`, `max-fn-params-bools`, `warn-on-all-wildcard-imports`, `disallowed-methods`, `disallowed-types`, `unreadable-literal-lint-fractions`, `upper-case-acronyms-aggressive`, `cargo-ignore-publish`, `standard-macro-braces`, `enforced-import-renames`, `allowed-scripts`, `third-party` at line 5 column 1
+error: error reading Clippy's configuration file `$DIR/clippy.toml`: unknown field `foobar`, expected one of `avoid-breaking-exported-api`, `msrv`, `blacklisted-names`, `cognitive-complexity-threshold`, `cyclomatic-complexity-threshold`, `doc-valid-idents`, `too-many-arguments-threshold`, `type-complexity-threshold`, `single-char-binding-names-threshold`, `too-large-for-stack`, `enum-variant-name-threshold`, `enum-variant-size-threshold`, `verbose-bit-mask-threshold`, `literal-representation-threshold`, `trivial-copy-size-limit`, `pass-by-value-size-limit`, `too-many-lines-threshold`, `array-size-threshold`, `vec-box-size-threshold`, `max-trait-bounds`, `max-struct-bools`, `max-fn-params-bools`, `warn-on-all-wildcard-imports`, `disallowed-methods`, `disallowed-types`, `unreadable-literal-lint-fractions`, `upper-case-acronyms-aggressive`, `cargo-ignore-publish`, `standard-macro-braces`, `enforced-import-renames`, `allowed-scripts`, `enable-raw-pointer-heuristic`, `third-party` at line 5 column 1
 
 error: aborting due to previous error
 
-- 
cgit 1.4.1-3-g733a5


From 08f0aecffd4e8522bf51a7b9d74386a36834d4a9 Mon Sep 17 00:00:00 2001
From: Yechan Bae <yechan@gatech.edu>
Date: Fri, 1 Oct 2021 12:47:54 -0400
Subject: Minor changes from PR feedback

---
 clippy_lints/src/lib.rs                       |  4 +-
 clippy_lints/src/non_send_field_in_send_ty.rs | 53 ++++++++++++++-------------
 clippy_lints/src/utils/conf.rs                |  2 +-
 tests/ui/non_send_field_in_send_ty.stderr     | 28 +++++++-------
 4 files changed, 45 insertions(+), 42 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index f9d660972cb..50b55e5f79a 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -535,8 +535,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(move || Box::new(feature_name::FeatureName));
     store.register_late_pass(move || Box::new(iter_not_returning_iterator::IterNotReturningIterator));
     store.register_late_pass(move || Box::new(if_then_panic::IfThenPanic));
-    let enable_raw_pointer_heuristic = conf.enable_raw_pointer_heuristic;
-    store.register_late_pass(move || Box::new(non_send_field_in_send_ty::NonSendFieldInSendTy::new(enable_raw_pointer_heuristic)));
+    let enable_raw_pointer_heuristic_for_send = conf.enable_raw_pointer_heuristic_for_send;
+    store.register_late_pass(move || Box::new(non_send_field_in_send_ty::NonSendFieldInSendTy::new(enable_raw_pointer_heuristic_for_send)));
 }
 
 #[rustfmt::skip]
diff --git a/clippy_lints/src/non_send_field_in_send_ty.rs b/clippy_lints/src/non_send_field_in_send_ty.rs
index 706214cb3d5..83f6f786d26 100644
--- a/clippy_lints/src/non_send_field_in_send_ty.rs
+++ b/clippy_lints/src/non_send_field_in_send_ty.rs
@@ -42,7 +42,7 @@ declare_clippy_lint! {
     /// unsafe impl<T> Send for ExampleStruct<T> {}
     /// ```
     /// Use thread-safe types like [`std::sync::Arc`](https://doc.rust-lang.org/std/sync/struct.Arc.html)
-    /// and specify correct bounds on generic type parameters (`T: Send`).
+    /// or specify correct bounds on generic type parameters (`T: Send`).
     pub NON_SEND_FIELD_IN_SEND_TY,
     nursery,
     "there is field that does not implement `Send` in a `Send` struct"
@@ -125,7 +125,7 @@ impl<'tcx> LateLintPass<'tcx> for NonSendFieldInSendTy {
                             for field in non_send_fields {
                                 diag.span_note(
                                     field.span,
-                                    &format!("the field `{}` has type `{}` which is not `Send`", field.name, field.ty),
+                                    &format!("the field `{}` has type `{}` which is `!Send`", field.name, field.ty),
                                 );
 
                                 match field.generic_params.len() {
@@ -165,7 +165,7 @@ impl<'tcx> NonSendField<'tcx> {
 }
 
 /// Given a type, collect all of its generic parameters.
-/// Example: MyStruct<P, Box<Q, R>> => vec![P, Q, R]
+/// Example: `MyStruct<P, Box<Q, R>>` => `vec![P, Q, R]`
 fn collect_generic_params<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Vec<Ty<'tcx>> {
     ty.walk(cx.tcx)
         .filter_map(|inner| match inner.unpack() {
@@ -184,31 +184,34 @@ fn ty_implements_send_or_copy(cx: &LateContext<'tcx>, ty: Ty<'tcx>, send_trait:
 /// Heuristic to allow cases like `Vec<*const u8>`
 fn ty_allowed_with_raw_pointer_heuristic<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>, send_trait: DefId) -> bool {
     if ty_implements_send_or_copy(cx, ty, send_trait) {
-        true
-    } else {
-        // The type is known to be `!Send` and `!Copy`
-        match ty.kind() {
-            ty::Tuple(_) => ty
-                .tuple_fields()
-                .all(|ty| ty_allowed_with_raw_pointer_heuristic(cx, ty, send_trait)),
-            ty::Array(ty, _) | ty::Slice(ty) => ty_allowed_with_raw_pointer_heuristic(cx, ty, send_trait),
-            ty::Adt(_, substs) => {
-                if contains_raw_pointer(cx, ty) {
-                    // descends only if ADT contains any raw pointers
-                    substs.iter().all(|generic_arg| match generic_arg.unpack() {
-                        GenericArgKind::Type(ty) => ty_allowed_with_raw_pointer_heuristic(cx, ty, send_trait),
-                        GenericArgKind::Lifetime(_) | GenericArgKind::Const(_) => true,
-                    })
-                } else {
-                    false
-                }
-            },
-            ty::RawPtr(_) => true,
-            _ => false,
-        }
+        return true;
+    }
+
+    // The type is known to be `!Send` and `!Copy`
+    match ty.kind() {
+        ty::Tuple(_) => ty
+            .tuple_fields()
+            .all(|ty| ty_allowed_with_raw_pointer_heuristic(cx, ty, send_trait)),
+        ty::Array(ty, _) | ty::Slice(ty) => ty_allowed_with_raw_pointer_heuristic(cx, ty, send_trait),
+        ty::Adt(_, substs) => {
+            if contains_raw_pointer(cx, ty) {
+                // descends only if ADT contains any raw pointers
+                substs.iter().all(|generic_arg| match generic_arg.unpack() {
+                    GenericArgKind::Type(ty) => ty_allowed_with_raw_pointer_heuristic(cx, ty, send_trait),
+                    // Lifetimes and const generics are not solid part of ADT and ignored
+                    GenericArgKind::Lifetime(_) | GenericArgKind::Const(_) => true,
+                })
+            } else {
+                false
+            }
+        },
+        // Raw pointers are `!Send` but allowed by the heuristic
+        ty::RawPtr(_) => true,
+        _ => false,
     }
 }
 
+/// Checks if the type contains any raw pointers in substs (including nested ones).
 fn contains_raw_pointer<'tcx>(cx: &LateContext<'tcx>, target_ty: Ty<'tcx>) -> bool {
     for ty_node in target_ty.walk(cx.tcx) {
         if_chain! {
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 177c0fd375c..e6233f73a57 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -287,7 +287,7 @@ define_Conf! {
     /// Lint: NON_SEND_FIELD_IN_SEND_TY.
     ///
     /// Whether to apply the raw pointer heuristic in `non_send_field_in_send_ty` lint.
-    (enable_raw_pointer_heuristic: bool = true),
+    (enable_raw_pointer_heuristic_for_send: bool = true),
 }
 
 /// Search for the configuration file.
diff --git a/tests/ui/non_send_field_in_send_ty.stderr b/tests/ui/non_send_field_in_send_ty.stderr
index 327ef9fc2d6..6c7312d0152 100644
--- a/tests/ui/non_send_field_in_send_ty.stderr
+++ b/tests/ui/non_send_field_in_send_ty.stderr
@@ -5,7 +5,7 @@ LL | unsafe impl<T> Send for RingBuffer<T> {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::non-send-field-in-send-ty` implied by `-D warnings`
-note: the field `data` has type `std::vec::Vec<std::cell::UnsafeCell<T>>` which is not `Send`
+note: the field `data` has type `std::vec::Vec<std::cell::UnsafeCell<T>>` which is `!Send`
   --> $DIR/non_send_field_in_send_ty.rs:11:5
    |
 LL |     data: Vec<UnsafeCell<T>>,
@@ -18,7 +18,7 @@ error: this implementation is unsound, as some fields in `MvccRwLock<T>` are `!S
 LL | unsafe impl<T> Send for MvccRwLock<T> {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-note: the field `lock` has type `std::sync::Mutex<std::boxed::Box<T>>` which is not `Send`
+note: the field `lock` has type `std::sync::Mutex<std::boxed::Box<T>>` which is `!Send`
   --> $DIR/non_send_field_in_send_ty.rs:21:5
    |
 LL |     lock: Mutex<Box<T>>,
@@ -31,7 +31,7 @@ error: this implementation is unsound, as some fields in `ArcGuard<RC, T>` are `
 LL | unsafe impl<RC, T: Send> Send for ArcGuard<RC, T> {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-note: the field `head` has type `std::sync::Arc<RC>` which is not `Send`
+note: the field `head` has type `std::sync::Arc<RC>` which is `!Send`
   --> $DIR/non_send_field_in_send_ty.rs:29:5
    |
 LL |     head: Arc<RC>,
@@ -44,7 +44,7 @@ error: this implementation is unsound, as some fields in `DeviceHandle<T>` are `
 LL | unsafe impl<T: UsbContext> Send for DeviceHandle<T> {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-note: the field `context` has type `T` which is not `Send`
+note: the field `context` has type `T` which is `!Send`
   --> $DIR/non_send_field_in_send_ty.rs:44:5
    |
 LL |     context: T,
@@ -57,7 +57,7 @@ error: this implementation is unsound, as some fields in `NoGeneric` are `!Send`
 LL | unsafe impl Send for NoGeneric {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-note: the field `rc_is_not_send` has type `std::rc::Rc<std::string::String>` which is not `Send`
+note: the field `rc_is_not_send` has type `std::rc::Rc<std::string::String>` which is `!Send`
   --> $DIR/non_send_field_in_send_ty.rs:52:5
    |
 LL |     rc_is_not_send: Rc<String>,
@@ -70,19 +70,19 @@ error: this implementation is unsound, as some fields in `MultiField<T>` are `!S
 LL | unsafe impl<T> Send for MultiField<T> {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-note: the field `field1` has type `T` which is not `Send`
+note: the field `field1` has type `T` which is `!Send`
   --> $DIR/non_send_field_in_send_ty.rs:58:5
    |
 LL |     field1: T,
    |     ^^^^^^^^^
    = help: add `T: Send` bound in `Send` impl
-note: the field `field2` has type `T` which is not `Send`
+note: the field `field2` has type `T` which is `!Send`
   --> $DIR/non_send_field_in_send_ty.rs:59:5
    |
 LL |     field2: T,
    |     ^^^^^^^^^
    = help: add `T: Send` bound in `Send` impl
-note: the field `field3` has type `T` which is not `Send`
+note: the field `field3` has type `T` which is `!Send`
   --> $DIR/non_send_field_in_send_ty.rs:60:5
    |
 LL |     field3: T,
@@ -95,7 +95,7 @@ error: this implementation is unsound, as some fields in `MyOption<T>` are `!Sen
 LL | unsafe impl<T> Send for MyOption<T> {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-note: the field `0` has type `T` which is not `Send`
+note: the field `0` has type `T` which is `!Send`
   --> $DIR/non_send_field_in_send_ty.rs:66:12
    |
 LL |     MySome(T),
@@ -108,7 +108,7 @@ error: this implementation is unsound, as some fields in `MultiParam<A, B>` are
 LL | unsafe impl<A, B> Send for MultiParam<A, B> {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-note: the field `vec` has type `std::vec::Vec<(A, B)>` which is not `Send`
+note: the field `vec` has type `std::vec::Vec<(A, B)>` which is `!Send`
   --> $DIR/non_send_field_in_send_ty.rs:74:5
    |
 LL |     vec: Vec<(A, B)>,
@@ -121,7 +121,7 @@ error: this implementation is unsound, as some fields in `HeuristicTest` are `!S
 LL | unsafe impl Send for HeuristicTest {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-note: the field `field4` has type `(*const NonSend, std::rc::Rc<u8>)` which is not `Send`
+note: the field `field4` has type `(*const NonSend, std::rc::Rc<u8>)` which is `!Send`
   --> $DIR/non_send_field_in_send_ty.rs:90:5
    |
 LL |     field4: (*const NonSend, Rc<u8>),
@@ -134,7 +134,7 @@ error: this implementation is unsound, as some fields in `AttrTest3<T>` are `!Se
 LL | unsafe impl<T> Send for AttrTest3<T> {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-note: the field `0` has type `T` which is not `Send`
+note: the field `0` has type `T` which is `!Send`
   --> $DIR/non_send_field_in_send_ty.rs:109:11
    |
 LL |     Enum2(T),
@@ -147,7 +147,7 @@ error: this implementation is unsound, as some fields in `Complex<P, u32>` are `
 LL | unsafe impl<P> Send for Complex<P, u32> {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-note: the field `field1` has type `P` which is not `Send`
+note: the field `field1` has type `P` which is `!Send`
   --> $DIR/non_send_field_in_send_ty.rs:118:5
    |
 LL |     field1: A,
@@ -160,7 +160,7 @@ error: this implementation is unsound, as some fields in `Complex<Q, std::sync::
 LL | unsafe impl<Q: Send> Send for Complex<Q, MutexGuard<'static, bool>> {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-note: the field `field2` has type `std::sync::MutexGuard<'static, bool>` which is not `Send`
+note: the field `field2` has type `std::sync::MutexGuard<'static, bool>` which is `!Send`
   --> $DIR/non_send_field_in_send_ty.rs:119:5
    |
 LL |     field2: B,
-- 
cgit 1.4.1-3-g733a5


From 4f01656a7d5d206488f9f3de879d43a637f943a1 Mon Sep 17 00:00:00 2001
From: Yechan Bae <yechan@gatech.edu>
Date: Fri, 1 Oct 2021 13:07:25 -0400
Subject: Add ui-test for enable-raw-pointer-heuristic-for-send config

---
 clippy_lints/src/non_send_field_in_send_ty.rs      | 18 +++--
 .../strict_non_send_field_in_send_ty/clippy.toml   |  1 +
 .../strict_non_send_field_in_send_ty/test.rs       | 43 ++++++++++
 .../strict_non_send_field_in_send_ty/test.stderr   | 91 ++++++++++++++++++++++
 .../toml_unknown_key/conf_unknown_key.stderr       |  2 +-
 5 files changed, 149 insertions(+), 6 deletions(-)
 create mode 100644 tests/ui-toml/strict_non_send_field_in_send_ty/clippy.toml
 create mode 100644 tests/ui-toml/strict_non_send_field_in_send_ty/test.rs
 create mode 100644 tests/ui-toml/strict_non_send_field_in_send_ty/test.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/non_send_field_in_send_ty.rs b/clippy_lints/src/non_send_field_in_send_ty.rs
index 83f6f786d26..b43fb02d329 100644
--- a/clippy_lints/src/non_send_field_in_send_ty.rs
+++ b/clippy_lints/src/non_send_field_in_send_ty.rs
@@ -68,7 +68,7 @@ impl<'tcx> LateLintPass<'tcx> for NonSendFieldInSendTy {
         let ty_allowed_in_send = if self.enable_raw_pointer_heuristic {
             ty_allowed_with_raw_pointer_heuristic
         } else {
-            ty_implements_send_or_copy
+            ty_allowed_without_raw_pointer_heuristic
         };
 
         // Checks if we are in `Send` impl item.
@@ -176,14 +176,22 @@ fn collect_generic_params<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Vec<Ty<
         .collect()
 }
 
-/// Determine if the given type is `Send` or `Copy`
-fn ty_implements_send_or_copy(cx: &LateContext<'tcx>, ty: Ty<'tcx>, send_trait: DefId) -> bool {
-    implements_trait(cx, ty, send_trait, &[]) || is_copy(cx, ty)
+/// Be more strict when the heuristic is disabled
+fn ty_allowed_without_raw_pointer_heuristic<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>, send_trait: DefId) -> bool {
+    if implements_trait(cx, ty, send_trait, &[]) {
+        return true;
+    }
+
+    if is_copy(cx, ty) && !contains_raw_pointer(cx, ty) {
+        return true;
+    }
+
+    false
 }
 
 /// Heuristic to allow cases like `Vec<*const u8>`
 fn ty_allowed_with_raw_pointer_heuristic<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>, send_trait: DefId) -> bool {
-    if ty_implements_send_or_copy(cx, ty, send_trait) {
+    if implements_trait(cx, ty, send_trait, &[]) || is_copy(cx, ty) {
         return true;
     }
 
diff --git a/tests/ui-toml/strict_non_send_field_in_send_ty/clippy.toml b/tests/ui-toml/strict_non_send_field_in_send_ty/clippy.toml
new file mode 100644
index 00000000000..a942709d14a
--- /dev/null
+++ b/tests/ui-toml/strict_non_send_field_in_send_ty/clippy.toml
@@ -0,0 +1 @@
+enable-raw-pointer-heuristic-for-send = false
diff --git a/tests/ui-toml/strict_non_send_field_in_send_ty/test.rs b/tests/ui-toml/strict_non_send_field_in_send_ty/test.rs
new file mode 100644
index 00000000000..6306c9c9f6d
--- /dev/null
+++ b/tests/ui-toml/strict_non_send_field_in_send_ty/test.rs
@@ -0,0 +1,43 @@
+#![warn(clippy::non_send_field_in_send_ty)]
+#![feature(extern_types)]
+
+use std::rc::Rc;
+
+// Basic tests should not be affected
+pub struct NoGeneric {
+    rc_is_not_send: Rc<String>,
+}
+
+unsafe impl Send for NoGeneric {}
+
+pub struct MultiField<T> {
+    field1: T,
+    field2: T,
+    field3: T,
+}
+
+unsafe impl<T> Send for MultiField<T> {}
+
+pub enum MyOption<T> {
+    MySome(T),
+    MyNone,
+}
+
+unsafe impl<T> Send for MyOption<T> {}
+
+// All fields are disallowed when raw pointer heuristic is off
+extern "C" {
+    type NonSend;
+}
+
+pub struct HeuristicTest {
+    field1: Vec<*const NonSend>,
+    field2: [*const NonSend; 3],
+    field3: (*const NonSend, *const NonSend, *const NonSend),
+    field4: (*const NonSend, Rc<u8>),
+    field5: Vec<Vec<*const NonSend>>,
+}
+
+unsafe impl Send for HeuristicTest {}
+
+fn main() {}
diff --git a/tests/ui-toml/strict_non_send_field_in_send_ty/test.stderr b/tests/ui-toml/strict_non_send_field_in_send_ty/test.stderr
new file mode 100644
index 00000000000..093c9320945
--- /dev/null
+++ b/tests/ui-toml/strict_non_send_field_in_send_ty/test.stderr
@@ -0,0 +1,91 @@
+error: this implementation is unsound, as some fields in `NoGeneric` are `!Send`
+  --> $DIR/test.rs:11:1
+   |
+LL | unsafe impl Send for NoGeneric {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::non-send-field-in-send-ty` implied by `-D warnings`
+note: the field `rc_is_not_send` has type `std::rc::Rc<std::string::String>` which is `!Send`
+  --> $DIR/test.rs:8:5
+   |
+LL |     rc_is_not_send: Rc<String>,
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   = help: use a thread-safe type that implements `Send`
+
+error: this implementation is unsound, as some fields in `MultiField<T>` are `!Send`
+  --> $DIR/test.rs:19:1
+   |
+LL | unsafe impl<T> Send for MultiField<T> {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: the field `field1` has type `T` which is `!Send`
+  --> $DIR/test.rs:14:5
+   |
+LL |     field1: T,
+   |     ^^^^^^^^^
+   = help: add `T: Send` bound in `Send` impl
+note: the field `field2` has type `T` which is `!Send`
+  --> $DIR/test.rs:15:5
+   |
+LL |     field2: T,
+   |     ^^^^^^^^^
+   = help: add `T: Send` bound in `Send` impl
+note: the field `field3` has type `T` which is `!Send`
+  --> $DIR/test.rs:16:5
+   |
+LL |     field3: T,
+   |     ^^^^^^^^^
+   = help: add `T: Send` bound in `Send` impl
+
+error: this implementation is unsound, as some fields in `MyOption<T>` are `!Send`
+  --> $DIR/test.rs:26:1
+   |
+LL | unsafe impl<T> Send for MyOption<T> {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: the field `0` has type `T` which is `!Send`
+  --> $DIR/test.rs:22:12
+   |
+LL |     MySome(T),
+   |            ^
+   = help: add `T: Send` bound in `Send` impl
+
+error: this implementation is unsound, as some fields in `HeuristicTest` are `!Send`
+  --> $DIR/test.rs:41:1
+   |
+LL | unsafe impl Send for HeuristicTest {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: the field `field1` has type `std::vec::Vec<*const NonSend>` which is `!Send`
+  --> $DIR/test.rs:34:5
+   |
+LL |     field1: Vec<*const NonSend>,
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   = help: use a thread-safe type that implements `Send`
+note: the field `field2` has type `[*const NonSend; 3]` which is `!Send`
+  --> $DIR/test.rs:35:5
+   |
+LL |     field2: [*const NonSend; 3],
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   = help: use a thread-safe type that implements `Send`
+note: the field `field3` has type `(*const NonSend, *const NonSend, *const NonSend)` which is `!Send`
+  --> $DIR/test.rs:36:5
+   |
+LL |     field3: (*const NonSend, *const NonSend, *const NonSend),
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   = help: use a thread-safe type that implements `Send`
+note: the field `field4` has type `(*const NonSend, std::rc::Rc<u8>)` which is `!Send`
+  --> $DIR/test.rs:37:5
+   |
+LL |     field4: (*const NonSend, Rc<u8>),
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   = help: use a thread-safe type that implements `Send`
+note: the field `field5` has type `std::vec::Vec<std::vec::Vec<*const NonSend>>` which is `!Send`
+  --> $DIR/test.rs:38:5
+   |
+LL |     field5: Vec<Vec<*const NonSend>>,
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   = help: use a thread-safe type that implements `Send`
+
+error: aborting due to 4 previous errors
+
diff --git a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
index 0eff2be7960..97bab1308aa 100644
--- a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
+++ b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
@@ -1,4 +1,4 @@
-error: error reading Clippy's configuration file `$DIR/clippy.toml`: unknown field `foobar`, expected one of `avoid-breaking-exported-api`, `msrv`, `blacklisted-names`, `cognitive-complexity-threshold`, `cyclomatic-complexity-threshold`, `doc-valid-idents`, `too-many-arguments-threshold`, `type-complexity-threshold`, `single-char-binding-names-threshold`, `too-large-for-stack`, `enum-variant-name-threshold`, `enum-variant-size-threshold`, `verbose-bit-mask-threshold`, `literal-representation-threshold`, `trivial-copy-size-limit`, `pass-by-value-size-limit`, `too-many-lines-threshold`, `array-size-threshold`, `vec-box-size-threshold`, `max-trait-bounds`, `max-struct-bools`, `max-fn-params-bools`, `warn-on-all-wildcard-imports`, `disallowed-methods`, `disallowed-types`, `unreadable-literal-lint-fractions`, `upper-case-acronyms-aggressive`, `cargo-ignore-publish`, `standard-macro-braces`, `enforced-import-renames`, `allowed-scripts`, `enable-raw-pointer-heuristic`, `third-party` at line 5 column 1
+error: error reading Clippy's configuration file `$DIR/clippy.toml`: unknown field `foobar`, expected one of `avoid-breaking-exported-api`, `msrv`, `blacklisted-names`, `cognitive-complexity-threshold`, `cyclomatic-complexity-threshold`, `doc-valid-idents`, `too-many-arguments-threshold`, `type-complexity-threshold`, `single-char-binding-names-threshold`, `too-large-for-stack`, `enum-variant-name-threshold`, `enum-variant-size-threshold`, `verbose-bit-mask-threshold`, `literal-representation-threshold`, `trivial-copy-size-limit`, `pass-by-value-size-limit`, `too-many-lines-threshold`, `array-size-threshold`, `vec-box-size-threshold`, `max-trait-bounds`, `max-struct-bools`, `max-fn-params-bools`, `warn-on-all-wildcard-imports`, `disallowed-methods`, `disallowed-types`, `unreadable-literal-lint-fractions`, `upper-case-acronyms-aggressive`, `cargo-ignore-publish`, `standard-macro-braces`, `enforced-import-renames`, `allowed-scripts`, `enable-raw-pointer-heuristic-for-send`, `third-party` at line 5 column 1
 
 error: aborting due to previous error
 
-- 
cgit 1.4.1-3-g733a5


From dfed2e31d5caa0ff7e53b442e8bd3585e78aba09 Mon Sep 17 00:00:00 2001
From: Yechan Bae <yechan@gatech.edu>
Date: Fri, 1 Oct 2021 14:00:50 -0400
Subject: Do not use full type path in help message

---
 clippy_lints/src/non_send_field_in_send_ty.rs | 22 +++++++---------
 tests/ui/non_send_field_in_send_ty.stderr     | 38 +++++++++++++--------------
 2 files changed, 29 insertions(+), 31 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/non_send_field_in_send_ty.rs b/clippy_lints/src/non_send_field_in_send_ty.rs
index b43fb02d329..399b1a929e2 100644
--- a/clippy_lints/src/non_send_field_in_send_ty.rs
+++ b/clippy_lints/src/non_send_field_in_send_ty.rs
@@ -1,14 +1,14 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::is_lint_allowed;
+use clippy_utils::source::snippet;
 use clippy_utils::ty::{implements_trait, is_copy};
 use rustc_ast::ImplPolarity;
 use rustc_hir::def_id::DefId;
-use rustc_hir::{Item, ItemKind};
+use rustc_hir::{FieldDef, Item, ItemKind, Node};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{self, subst::GenericArgKind, Ty};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::symbol::Symbol;
-use rustc_span::{sym, Span};
+use rustc_span::sym;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -99,11 +99,10 @@ impl<'tcx> LateLintPass<'tcx> for NonSendFieldInSendTy {
                             if !is_lint_allowed(cx, NON_SEND_FIELD_IN_SEND_TY, field_hir_id);
                             if let field_ty = field.ty(cx.tcx, impl_trait_substs);
                             if !ty_allowed_in_send(cx, field_ty, send_trait);
-                            if let Some(field_span) = hir_map.span_if_local(field.did);
+                            if let Node::Field(field_def) = hir_map.get(field_hir_id);
                             then {
                                 non_send_fields.push(NonSendField {
-                                    name: hir_map.name(field_hir_id),
-                                    span: field_span,
+                                    def: field_def,
                                     ty: field_ty,
                                     generic_params: collect_generic_params(cx, field_ty),
                                 })
@@ -119,13 +118,13 @@ impl<'tcx> LateLintPass<'tcx> for NonSendFieldInSendTy {
                         item.span,
                         &format!(
                             "this implementation is unsound, as some fields in `{}` are `!Send`",
-                            self_ty
+                            snippet(cx, hir_impl.self_ty.span, "Unknown")
                         ),
                         |diag| {
                             for field in non_send_fields {
                                 diag.span_note(
-                                    field.span,
-                                    &format!("the field `{}` has type `{}` which is `!Send`", field.name, field.ty),
+                                    field.def.span,
+                                    &format!("the type of field `{}` is `!Send`", field.def.ident.name),
                                 );
 
                                 match field.generic_params.len() {
@@ -135,7 +134,7 @@ impl<'tcx> LateLintPass<'tcx> for NonSendFieldInSendTy {
                                         "add bounds on type parameter{} `{}` that satisfy `{}: Send`",
                                         if field.generic_params.len() > 1 { "s" } else { "" },
                                         field.generic_params_string(),
-                                        field.ty
+                                        snippet(cx, field.def.ty.span, "Unknown"),
                                     )),
                                 };
                             }
@@ -148,8 +147,7 @@ impl<'tcx> LateLintPass<'tcx> for NonSendFieldInSendTy {
 }
 
 struct NonSendField<'tcx> {
-    name: Symbol,
-    span: Span,
+    def: &'tcx FieldDef<'tcx>,
     ty: Ty<'tcx>,
     generic_params: Vec<Ty<'tcx>>,
 }
diff --git a/tests/ui/non_send_field_in_send_ty.stderr b/tests/ui/non_send_field_in_send_ty.stderr
index 6c7312d0152..f49a7355b53 100644
--- a/tests/ui/non_send_field_in_send_ty.stderr
+++ b/tests/ui/non_send_field_in_send_ty.stderr
@@ -5,12 +5,12 @@ LL | unsafe impl<T> Send for RingBuffer<T> {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::non-send-field-in-send-ty` implied by `-D warnings`
-note: the field `data` has type `std::vec::Vec<std::cell::UnsafeCell<T>>` which is `!Send`
+note: the type of field `data` is `!Send`
   --> $DIR/non_send_field_in_send_ty.rs:11:5
    |
 LL |     data: Vec<UnsafeCell<T>>,
    |     ^^^^^^^^^^^^^^^^^^^^^^^^
-   = help: add bounds on type parameter `T` that satisfy `std::vec::Vec<std::cell::UnsafeCell<T>>: Send`
+   = help: add bounds on type parameter `T` that satisfy `Vec<UnsafeCell<T>>: Send`
 
 error: this implementation is unsound, as some fields in `MvccRwLock<T>` are `!Send`
   --> $DIR/non_send_field_in_send_ty.rs:24:1
@@ -18,12 +18,12 @@ error: this implementation is unsound, as some fields in `MvccRwLock<T>` are `!S
 LL | unsafe impl<T> Send for MvccRwLock<T> {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-note: the field `lock` has type `std::sync::Mutex<std::boxed::Box<T>>` which is `!Send`
+note: the type of field `lock` is `!Send`
   --> $DIR/non_send_field_in_send_ty.rs:21:5
    |
 LL |     lock: Mutex<Box<T>>,
    |     ^^^^^^^^^^^^^^^^^^^
-   = help: add bounds on type parameter `T` that satisfy `std::sync::Mutex<std::boxed::Box<T>>: Send`
+   = help: add bounds on type parameter `T` that satisfy `Mutex<Box<T>>: Send`
 
 error: this implementation is unsound, as some fields in `ArcGuard<RC, T>` are `!Send`
   --> $DIR/non_send_field_in_send_ty.rs:32:1
@@ -31,12 +31,12 @@ error: this implementation is unsound, as some fields in `ArcGuard<RC, T>` are `
 LL | unsafe impl<RC, T: Send> Send for ArcGuard<RC, T> {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-note: the field `head` has type `std::sync::Arc<RC>` which is `!Send`
+note: the type of field `head` is `!Send`
   --> $DIR/non_send_field_in_send_ty.rs:29:5
    |
 LL |     head: Arc<RC>,
    |     ^^^^^^^^^^^^^
-   = help: add bounds on type parameter `RC` that satisfy `std::sync::Arc<RC>: Send`
+   = help: add bounds on type parameter `RC` that satisfy `Arc<RC>: Send`
 
 error: this implementation is unsound, as some fields in `DeviceHandle<T>` are `!Send`
   --> $DIR/non_send_field_in_send_ty.rs:48:1
@@ -44,7 +44,7 @@ error: this implementation is unsound, as some fields in `DeviceHandle<T>` are `
 LL | unsafe impl<T: UsbContext> Send for DeviceHandle<T> {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-note: the field `context` has type `T` which is `!Send`
+note: the type of field `context` is `!Send`
   --> $DIR/non_send_field_in_send_ty.rs:44:5
    |
 LL |     context: T,
@@ -57,7 +57,7 @@ error: this implementation is unsound, as some fields in `NoGeneric` are `!Send`
 LL | unsafe impl Send for NoGeneric {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-note: the field `rc_is_not_send` has type `std::rc::Rc<std::string::String>` which is `!Send`
+note: the type of field `rc_is_not_send` is `!Send`
   --> $DIR/non_send_field_in_send_ty.rs:52:5
    |
 LL |     rc_is_not_send: Rc<String>,
@@ -70,19 +70,19 @@ error: this implementation is unsound, as some fields in `MultiField<T>` are `!S
 LL | unsafe impl<T> Send for MultiField<T> {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-note: the field `field1` has type `T` which is `!Send`
+note: the type of field `field1` is `!Send`
   --> $DIR/non_send_field_in_send_ty.rs:58:5
    |
 LL |     field1: T,
    |     ^^^^^^^^^
    = help: add `T: Send` bound in `Send` impl
-note: the field `field2` has type `T` which is `!Send`
+note: the type of field `field2` is `!Send`
   --> $DIR/non_send_field_in_send_ty.rs:59:5
    |
 LL |     field2: T,
    |     ^^^^^^^^^
    = help: add `T: Send` bound in `Send` impl
-note: the field `field3` has type `T` which is `!Send`
+note: the type of field `field3` is `!Send`
   --> $DIR/non_send_field_in_send_ty.rs:60:5
    |
 LL |     field3: T,
@@ -95,7 +95,7 @@ error: this implementation is unsound, as some fields in `MyOption<T>` are `!Sen
 LL | unsafe impl<T> Send for MyOption<T> {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-note: the field `0` has type `T` which is `!Send`
+note: the type of field `0` is `!Send`
   --> $DIR/non_send_field_in_send_ty.rs:66:12
    |
 LL |     MySome(T),
@@ -108,12 +108,12 @@ error: this implementation is unsound, as some fields in `MultiParam<A, B>` are
 LL | unsafe impl<A, B> Send for MultiParam<A, B> {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-note: the field `vec` has type `std::vec::Vec<(A, B)>` which is `!Send`
+note: the type of field `vec` is `!Send`
   --> $DIR/non_send_field_in_send_ty.rs:74:5
    |
 LL |     vec: Vec<(A, B)>,
    |     ^^^^^^^^^^^^^^^^
-   = help: add bounds on type parameters `A, B` that satisfy `std::vec::Vec<(A, B)>: Send`
+   = help: add bounds on type parameters `A, B` that satisfy `Vec<(A, B)>: Send`
 
 error: this implementation is unsound, as some fields in `HeuristicTest` are `!Send`
   --> $DIR/non_send_field_in_send_ty.rs:95:1
@@ -121,7 +121,7 @@ error: this implementation is unsound, as some fields in `HeuristicTest` are `!S
 LL | unsafe impl Send for HeuristicTest {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-note: the field `field4` has type `(*const NonSend, std::rc::Rc<u8>)` which is `!Send`
+note: the type of field `field4` is `!Send`
   --> $DIR/non_send_field_in_send_ty.rs:90:5
    |
 LL |     field4: (*const NonSend, Rc<u8>),
@@ -134,7 +134,7 @@ error: this implementation is unsound, as some fields in `AttrTest3<T>` are `!Se
 LL | unsafe impl<T> Send for AttrTest3<T> {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-note: the field `0` has type `T` which is `!Send`
+note: the type of field `0` is `!Send`
   --> $DIR/non_send_field_in_send_ty.rs:109:11
    |
 LL |     Enum2(T),
@@ -147,20 +147,20 @@ error: this implementation is unsound, as some fields in `Complex<P, u32>` are `
 LL | unsafe impl<P> Send for Complex<P, u32> {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-note: the field `field1` has type `P` which is `!Send`
+note: the type of field `field1` is `!Send`
   --> $DIR/non_send_field_in_send_ty.rs:118:5
    |
 LL |     field1: A,
    |     ^^^^^^^^^
    = help: add `P: Send` bound in `Send` impl
 
-error: this implementation is unsound, as some fields in `Complex<Q, std::sync::MutexGuard<'static, bool>>` are `!Send`
+error: this implementation is unsound, as some fields in `Complex<Q, MutexGuard<'static, bool>>` are `!Send`
   --> $DIR/non_send_field_in_send_ty.rs:125:1
    |
 LL | unsafe impl<Q: Send> Send for Complex<Q, MutexGuard<'static, bool>> {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-note: the field `field2` has type `std::sync::MutexGuard<'static, bool>` which is `!Send`
+note: the type of field `field2` is `!Send`
   --> $DIR/non_send_field_in_send_ty.rs:119:5
    |
 LL |     field2: B,
-- 
cgit 1.4.1-3-g733a5


From fb0353b28d746108932ffb0a9ce8535c115c0acf Mon Sep 17 00:00:00 2001
From: Yechan Bae <yechan@gatech.edu>
Date: Sat, 2 Oct 2021 19:22:37 -0400
Subject: Update documentation and name for non_send_fields_in_send_ty lint

---
 CHANGELOG.md                                       |   2 +-
 clippy_lints/src/lib.mods.rs                       |   2 +-
 clippy_lints/src/lib.register_lints.rs             |   2 +-
 clippy_lints/src/lib.register_nursery.rs           |   2 +-
 clippy_lints/src/lib.rs                            |   2 +-
 clippy_lints/src/non_send_field_in_send_ty.rs      | 238 ---------------------
 clippy_lints/src/non_send_fields_in_send_ty.rs     | 238 +++++++++++++++++++++
 clippy_lints/src/utils/conf.rs                     |   4 +-
 .../strict_non_send_field_in_send_ty/clippy.toml   |   1 -
 .../strict_non_send_field_in_send_ty/test.rs       |  43 ----
 .../strict_non_send_field_in_send_ty/test.stderr   |  91 --------
 .../strict_non_send_fields_in_send_ty/clippy.toml  |   1 +
 .../strict_non_send_fields_in_send_ty/test.rs      |  43 ++++
 .../strict_non_send_fields_in_send_ty/test.stderr  |  91 ++++++++
 tests/ui/non_send_field_in_send_ty.rs              | 127 -----------
 tests/ui/non_send_field_in_send_ty.stderr          | 171 ---------------
 tests/ui/non_send_fields_in_send_ty.rs             | 127 +++++++++++
 tests/ui/non_send_fields_in_send_ty.stderr         | 171 +++++++++++++++
 18 files changed, 678 insertions(+), 678 deletions(-)
 delete mode 100644 clippy_lints/src/non_send_field_in_send_ty.rs
 create mode 100644 clippy_lints/src/non_send_fields_in_send_ty.rs
 delete mode 100644 tests/ui-toml/strict_non_send_field_in_send_ty/clippy.toml
 delete mode 100644 tests/ui-toml/strict_non_send_field_in_send_ty/test.rs
 delete mode 100644 tests/ui-toml/strict_non_send_field_in_send_ty/test.stderr
 create mode 100644 tests/ui-toml/strict_non_send_fields_in_send_ty/clippy.toml
 create mode 100644 tests/ui-toml/strict_non_send_fields_in_send_ty/test.rs
 create mode 100644 tests/ui-toml/strict_non_send_fields_in_send_ty/test.stderr
 delete mode 100644 tests/ui/non_send_field_in_send_ty.rs
 delete mode 100644 tests/ui/non_send_field_in_send_ty.stderr
 create mode 100644 tests/ui/non_send_fields_in_send_ty.rs
 create mode 100644 tests/ui/non_send_fields_in_send_ty.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index df3fa2866c2..9a4424f5061 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2898,7 +2898,7 @@ Released 2018-09-13
 [`no_effect`]: https://rust-lang.github.io/rust-clippy/master/index.html#no_effect
 [`non_ascii_literal`]: https://rust-lang.github.io/rust-clippy/master/index.html#non_ascii_literal
 [`non_octal_unix_permissions`]: https://rust-lang.github.io/rust-clippy/master/index.html#non_octal_unix_permissions
-[`non_send_field_in_send_ty`]: https://rust-lang.github.io/rust-clippy/master/index.html#non_send_field_in_send_ty
+[`non_send_fields_in_send_ty`]: https://rust-lang.github.io/rust-clippy/master/index.html#non_send_fields_in_send_ty
 [`nonminimal_bool`]: https://rust-lang.github.io/rust-clippy/master/index.html#nonminimal_bool
 [`nonsensical_open_options`]: https://rust-lang.github.io/rust-clippy/master/index.html#nonsensical_open_options
 [`nonstandard_macro_braces`]: https://rust-lang.github.io/rust-clippy/master/index.html#nonstandard_macro_braces
diff --git a/clippy_lints/src/lib.mods.rs b/clippy_lints/src/lib.mods.rs
index 1d9d2be3443..7fd84783c22 100644
--- a/clippy_lints/src/lib.mods.rs
+++ b/clippy_lints/src/lib.mods.rs
@@ -149,7 +149,7 @@ mod no_effect;
 mod non_copy_const;
 mod non_expressive_names;
 mod non_octal_unix_permissions;
-mod non_send_field_in_send_ty;
+mod non_send_fields_in_send_ty;
 mod nonstandard_macro_braces;
 mod open_options;
 mod option_env_unwrap;
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index b1cd5aafe4c..28d54246fbb 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -366,7 +366,7 @@ store.register_lints(&[
     non_expressive_names::MANY_SINGLE_CHAR_NAMES,
     non_expressive_names::SIMILAR_NAMES,
     non_octal_unix_permissions::NON_OCTAL_UNIX_PERMISSIONS,
-    non_send_field_in_send_ty::NON_SEND_FIELD_IN_SEND_TY,
+    non_send_fields_in_send_ty::NON_SEND_FIELDS_IN_SEND_TY,
     nonstandard_macro_braces::NONSTANDARD_MACRO_BRACES,
     open_options::NONSENSICAL_OPEN_OPTIONS,
     option_env_unwrap::OPTION_ENV_UNWRAP,
diff --git a/clippy_lints/src/lib.register_nursery.rs b/clippy_lints/src/lib.register_nursery.rs
index 56b4f9d2391..32606e570d8 100644
--- a/clippy_lints/src/lib.register_nursery.rs
+++ b/clippy_lints/src/lib.register_nursery.rs
@@ -16,7 +16,7 @@ store.register_group(true, "clippy::nursery", Some("clippy_nursery"), vec![
     LintId::of(missing_const_for_fn::MISSING_CONST_FOR_FN),
     LintId::of(mutable_debug_assertion::DEBUG_ASSERT_WITH_MUT_CALL),
     LintId::of(mutex_atomic::MUTEX_INTEGER),
-    LintId::of(non_send_field_in_send_ty::NON_SEND_FIELD_IN_SEND_TY),
+    LintId::of(non_send_fields_in_send_ty::NON_SEND_FIELDS_IN_SEND_TY),
     LintId::of(nonstandard_macro_braces::NONSTANDARD_MACRO_BRACES),
     LintId::of(option_if_let_else::OPTION_IF_LET_ELSE),
     LintId::of(path_buf_push_overwrite::PATH_BUF_PUSH_OVERWRITE),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 50b55e5f79a..c3be6db6ffa 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -536,7 +536,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(move || Box::new(iter_not_returning_iterator::IterNotReturningIterator));
     store.register_late_pass(move || Box::new(if_then_panic::IfThenPanic));
     let enable_raw_pointer_heuristic_for_send = conf.enable_raw_pointer_heuristic_for_send;
-    store.register_late_pass(move || Box::new(non_send_field_in_send_ty::NonSendFieldInSendTy::new(enable_raw_pointer_heuristic_for_send)));
+    store.register_late_pass(move || Box::new(non_send_fields_in_send_ty::NonSendFieldInSendTy::new(enable_raw_pointer_heuristic_for_send)));
 }
 
 #[rustfmt::skip]
diff --git a/clippy_lints/src/non_send_field_in_send_ty.rs b/clippy_lints/src/non_send_field_in_send_ty.rs
deleted file mode 100644
index 399b1a929e2..00000000000
--- a/clippy_lints/src/non_send_field_in_send_ty.rs
+++ /dev/null
@@ -1,238 +0,0 @@
-use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::is_lint_allowed;
-use clippy_utils::source::snippet;
-use clippy_utils::ty::{implements_trait, is_copy};
-use rustc_ast::ImplPolarity;
-use rustc_hir::def_id::DefId;
-use rustc_hir::{FieldDef, Item, ItemKind, Node};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty::{self, subst::GenericArgKind, Ty};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::sym;
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Warns about a field in a `Send` struct that is neither `Send` nor `Copy`.
-    ///
-    /// ### Why is this bad?
-    /// Sending the struct to another thread will transfer the ownership to
-    /// the new thread by dropping in the current thread during the transfer.
-    /// This causes soundness issues for non-`Send` fields, as they are also
-    /// dropped and might not be set up to handle this.
-    ///
-    /// See:
-    /// * [*The Rustonomicon* about *Send and Sync*](https://doc.rust-lang.org/nomicon/send-and-sync.html)
-    /// * [The documentation of `Send`](https://doc.rust-lang.org/std/marker/trait.Send.html)
-    ///
-    /// ### Known Problems
-    /// Data structures that contain raw pointers may cause false positives.
-    /// They are sometimes safe to be sent across threads but do not implement
-    /// the `Send` trait. This lint has a heuristic to filter out basic cases
-    /// such as `Vec<*const T>`, but it's not perfect. Feel free to create an
-    /// issue if you have a suggestion on how this heuristic can be improved.
-    ///
-    /// ### Example
-    /// ```rust,ignore
-    /// struct ExampleStruct<T> {
-    ///     rc_is_not_send: Rc<String>,
-    ///     unbounded_generic_field: T,
-    /// }
-    ///
-    /// // This impl is unsound because it allows sending `!Send` types through `ExampleStruct`
-    /// unsafe impl<T> Send for ExampleStruct<T> {}
-    /// ```
-    /// Use thread-safe types like [`std::sync::Arc`](https://doc.rust-lang.org/std/sync/struct.Arc.html)
-    /// or specify correct bounds on generic type parameters (`T: Send`).
-    pub NON_SEND_FIELD_IN_SEND_TY,
-    nursery,
-    "there is field that does not implement `Send` in a `Send` struct"
-}
-
-#[derive(Copy, Clone)]
-pub struct NonSendFieldInSendTy {
-    enable_raw_pointer_heuristic: bool,
-}
-
-impl NonSendFieldInSendTy {
-    pub fn new(enable_raw_pointer_heuristic: bool) -> Self {
-        Self {
-            enable_raw_pointer_heuristic,
-        }
-    }
-}
-
-impl_lint_pass!(NonSendFieldInSendTy => [NON_SEND_FIELD_IN_SEND_TY]);
-
-impl<'tcx> LateLintPass<'tcx> for NonSendFieldInSendTy {
-    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
-        let ty_allowed_in_send = if self.enable_raw_pointer_heuristic {
-            ty_allowed_with_raw_pointer_heuristic
-        } else {
-            ty_allowed_without_raw_pointer_heuristic
-        };
-
-        // Checks if we are in `Send` impl item.
-        // We start from `Send` impl instead of `check_field_def()` because
-        // single `AdtDef` may have multiple `Send` impls due to generic
-        // parameters, and the lint is much easier to implement in this way.
-        if_chain! {
-            if let Some(send_trait) = cx.tcx.get_diagnostic_item(sym::send_trait);
-            if let ItemKind::Impl(hir_impl) = &item.kind;
-            if let Some(trait_ref) = &hir_impl.of_trait;
-            if let Some(trait_id) = trait_ref.trait_def_id();
-            if send_trait == trait_id;
-            if let ImplPolarity::Positive = hir_impl.polarity;
-            if let Some(ty_trait_ref) = cx.tcx.impl_trait_ref(item.def_id);
-            if let self_ty = ty_trait_ref.self_ty();
-            if let ty::Adt(adt_def, impl_trait_substs) = self_ty.kind();
-            then {
-                let mut non_send_fields = Vec::new();
-
-                let hir_map = cx.tcx.hir();
-                for variant in &adt_def.variants {
-                    for field in &variant.fields {
-                        if_chain! {
-                            if let Some(field_hir_id) = field
-                                .did
-                                .as_local()
-                                .map(|local_def_id| hir_map.local_def_id_to_hir_id(local_def_id));
-                            if !is_lint_allowed(cx, NON_SEND_FIELD_IN_SEND_TY, field_hir_id);
-                            if let field_ty = field.ty(cx.tcx, impl_trait_substs);
-                            if !ty_allowed_in_send(cx, field_ty, send_trait);
-                            if let Node::Field(field_def) = hir_map.get(field_hir_id);
-                            then {
-                                non_send_fields.push(NonSendField {
-                                    def: field_def,
-                                    ty: field_ty,
-                                    generic_params: collect_generic_params(cx, field_ty),
-                                })
-                            }
-                        }
-                    }
-                }
-
-                if !non_send_fields.is_empty() {
-                    span_lint_and_then(
-                        cx,
-                        NON_SEND_FIELD_IN_SEND_TY,
-                        item.span,
-                        &format!(
-                            "this implementation is unsound, as some fields in `{}` are `!Send`",
-                            snippet(cx, hir_impl.self_ty.span, "Unknown")
-                        ),
-                        |diag| {
-                            for field in non_send_fields {
-                                diag.span_note(
-                                    field.def.span,
-                                    &format!("the type of field `{}` is `!Send`", field.def.ident.name),
-                                );
-
-                                match field.generic_params.len() {
-                                    0 => diag.help("use a thread-safe type that implements `Send`"),
-                                    1 if is_ty_param(field.ty) => diag.help(&format!("add `{}: Send` bound in `Send` impl", field.ty)),
-                                    _ => diag.help(&format!(
-                                        "add bounds on type parameter{} `{}` that satisfy `{}: Send`",
-                                        if field.generic_params.len() > 1 { "s" } else { "" },
-                                        field.generic_params_string(),
-                                        snippet(cx, field.def.ty.span, "Unknown"),
-                                    )),
-                                };
-                            }
-                        },
-                    );
-                }
-            }
-        }
-    }
-}
-
-struct NonSendField<'tcx> {
-    def: &'tcx FieldDef<'tcx>,
-    ty: Ty<'tcx>,
-    generic_params: Vec<Ty<'tcx>>,
-}
-
-impl<'tcx> NonSendField<'tcx> {
-    fn generic_params_string(&self) -> String {
-        self.generic_params
-            .iter()
-            .map(ToString::to_string)
-            .collect::<Vec<_>>()
-            .join(", ")
-    }
-}
-
-/// Given a type, collect all of its generic parameters.
-/// Example: `MyStruct<P, Box<Q, R>>` => `vec![P, Q, R]`
-fn collect_generic_params<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Vec<Ty<'tcx>> {
-    ty.walk(cx.tcx)
-        .filter_map(|inner| match inner.unpack() {
-            GenericArgKind::Type(inner_ty) => Some(inner_ty),
-            _ => None,
-        })
-        .filter(|&inner_ty| is_ty_param(inner_ty))
-        .collect()
-}
-
-/// Be more strict when the heuristic is disabled
-fn ty_allowed_without_raw_pointer_heuristic<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>, send_trait: DefId) -> bool {
-    if implements_trait(cx, ty, send_trait, &[]) {
-        return true;
-    }
-
-    if is_copy(cx, ty) && !contains_raw_pointer(cx, ty) {
-        return true;
-    }
-
-    false
-}
-
-/// Heuristic to allow cases like `Vec<*const u8>`
-fn ty_allowed_with_raw_pointer_heuristic<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>, send_trait: DefId) -> bool {
-    if implements_trait(cx, ty, send_trait, &[]) || is_copy(cx, ty) {
-        return true;
-    }
-
-    // The type is known to be `!Send` and `!Copy`
-    match ty.kind() {
-        ty::Tuple(_) => ty
-            .tuple_fields()
-            .all(|ty| ty_allowed_with_raw_pointer_heuristic(cx, ty, send_trait)),
-        ty::Array(ty, _) | ty::Slice(ty) => ty_allowed_with_raw_pointer_heuristic(cx, ty, send_trait),
-        ty::Adt(_, substs) => {
-            if contains_raw_pointer(cx, ty) {
-                // descends only if ADT contains any raw pointers
-                substs.iter().all(|generic_arg| match generic_arg.unpack() {
-                    GenericArgKind::Type(ty) => ty_allowed_with_raw_pointer_heuristic(cx, ty, send_trait),
-                    // Lifetimes and const generics are not solid part of ADT and ignored
-                    GenericArgKind::Lifetime(_) | GenericArgKind::Const(_) => true,
-                })
-            } else {
-                false
-            }
-        },
-        // Raw pointers are `!Send` but allowed by the heuristic
-        ty::RawPtr(_) => true,
-        _ => false,
-    }
-}
-
-/// Checks if the type contains any raw pointers in substs (including nested ones).
-fn contains_raw_pointer<'tcx>(cx: &LateContext<'tcx>, target_ty: Ty<'tcx>) -> bool {
-    for ty_node in target_ty.walk(cx.tcx) {
-        if_chain! {
-            if let GenericArgKind::Type(inner_ty) = ty_node.unpack();
-            if let ty::RawPtr(_) = inner_ty.kind();
-            then {
-                return true;
-            }
-        }
-    }
-
-    false
-}
-
-/// Returns `true` if the type is a type parameter such as `T`.
-fn is_ty_param(target_ty: Ty<'_>) -> bool {
-    matches!(target_ty.kind(), ty::Param(_))
-}
diff --git a/clippy_lints/src/non_send_fields_in_send_ty.rs b/clippy_lints/src/non_send_fields_in_send_ty.rs
new file mode 100644
index 00000000000..0dbf296c714
--- /dev/null
+++ b/clippy_lints/src/non_send_fields_in_send_ty.rs
@@ -0,0 +1,238 @@
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::is_lint_allowed;
+use clippy_utils::source::snippet;
+use clippy_utils::ty::{implements_trait, is_copy};
+use rustc_ast::ImplPolarity;
+use rustc_hir::def_id::DefId;
+use rustc_hir::{FieldDef, Item, ItemKind, Node};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::{self, subst::GenericArgKind, Ty};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::sym;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Warns about fields in struct implementing `Send` that are neither `Send` nor `Copy`.
+    ///
+    /// ### Why is this bad?
+    /// Sending the struct to another thread will transfer the ownership to
+    /// the new thread by dropping in the current thread during the transfer.
+    /// This causes soundness issues for non-`Send` fields, as they are also
+    /// dropped and might not be set up to handle this.
+    ///
+    /// See:
+    /// * [*The Rustonomicon* about *Send and Sync*](https://doc.rust-lang.org/nomicon/send-and-sync.html)
+    /// * [The documentation of `Send`](https://doc.rust-lang.org/std/marker/trait.Send.html)
+    ///
+    /// ### Known Problems
+    /// Data structures that contain raw pointers may cause false positives.
+    /// They are sometimes safe to be sent across threads but do not implement
+    /// the `Send` trait. This lint has a heuristic to filter out basic cases
+    /// such as `Vec<*const T>`, but it's not perfect. Feel free to create an
+    /// issue if you have a suggestion on how this heuristic can be improved.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// struct ExampleStruct<T> {
+    ///     rc_is_not_send: Rc<String>,
+    ///     unbounded_generic_field: T,
+    /// }
+    ///
+    /// // This impl is unsound because it allows sending `!Send` types through `ExampleStruct`
+    /// unsafe impl<T> Send for ExampleStruct<T> {}
+    /// ```
+    /// Use thread-safe types like [`std::sync::Arc`](https://doc.rust-lang.org/std/sync/struct.Arc.html)
+    /// or specify correct bounds on generic type parameters (`T: Send`).
+    pub NON_SEND_FIELDS_IN_SEND_TY,
+    nursery,
+    "there is field that does not implement `Send` in a `Send` struct"
+}
+
+#[derive(Copy, Clone)]
+pub struct NonSendFieldInSendTy {
+    enable_raw_pointer_heuristic: bool,
+}
+
+impl NonSendFieldInSendTy {
+    pub fn new(enable_raw_pointer_heuristic: bool) -> Self {
+        Self {
+            enable_raw_pointer_heuristic,
+        }
+    }
+}
+
+impl_lint_pass!(NonSendFieldInSendTy => [NON_SEND_FIELDS_IN_SEND_TY]);
+
+impl<'tcx> LateLintPass<'tcx> for NonSendFieldInSendTy {
+    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
+        let ty_allowed_in_send = if self.enable_raw_pointer_heuristic {
+            ty_allowed_with_raw_pointer_heuristic
+        } else {
+            ty_allowed_without_raw_pointer_heuristic
+        };
+
+        // Checks if we are in `Send` impl item.
+        // We start from `Send` impl instead of `check_field_def()` because
+        // single `AdtDef` may have multiple `Send` impls due to generic
+        // parameters, and the lint is much easier to implement in this way.
+        if_chain! {
+            if let Some(send_trait) = cx.tcx.get_diagnostic_item(sym::send_trait);
+            if let ItemKind::Impl(hir_impl) = &item.kind;
+            if let Some(trait_ref) = &hir_impl.of_trait;
+            if let Some(trait_id) = trait_ref.trait_def_id();
+            if send_trait == trait_id;
+            if let ImplPolarity::Positive = hir_impl.polarity;
+            if let Some(ty_trait_ref) = cx.tcx.impl_trait_ref(item.def_id);
+            if let self_ty = ty_trait_ref.self_ty();
+            if let ty::Adt(adt_def, impl_trait_substs) = self_ty.kind();
+            then {
+                let mut non_send_fields = Vec::new();
+
+                let hir_map = cx.tcx.hir();
+                for variant in &adt_def.variants {
+                    for field in &variant.fields {
+                        if_chain! {
+                            if let Some(field_hir_id) = field
+                                .did
+                                .as_local()
+                                .map(|local_def_id| hir_map.local_def_id_to_hir_id(local_def_id));
+                            if !is_lint_allowed(cx, NON_SEND_FIELDS_IN_SEND_TY, field_hir_id);
+                            if let field_ty = field.ty(cx.tcx, impl_trait_substs);
+                            if !ty_allowed_in_send(cx, field_ty, send_trait);
+                            if let Node::Field(field_def) = hir_map.get(field_hir_id);
+                            then {
+                                non_send_fields.push(NonSendField {
+                                    def: field_def,
+                                    ty: field_ty,
+                                    generic_params: collect_generic_params(cx, field_ty),
+                                })
+                            }
+                        }
+                    }
+                }
+
+                if !non_send_fields.is_empty() {
+                    span_lint_and_then(
+                        cx,
+                        NON_SEND_FIELDS_IN_SEND_TY,
+                        item.span,
+                        &format!(
+                            "this implementation is unsound, as some fields in `{}` are `!Send`",
+                            snippet(cx, hir_impl.self_ty.span, "Unknown")
+                        ),
+                        |diag| {
+                            for field in non_send_fields {
+                                diag.span_note(
+                                    field.def.span,
+                                    &format!("the type of field `{}` is `!Send`", field.def.ident.name),
+                                );
+
+                                match field.generic_params.len() {
+                                    0 => diag.help("use a thread-safe type that implements `Send`"),
+                                    1 if is_ty_param(field.ty) => diag.help(&format!("add `{}: Send` bound in `Send` impl", field.ty)),
+                                    _ => diag.help(&format!(
+                                        "add bounds on type parameter{} `{}` that satisfy `{}: Send`",
+                                        if field.generic_params.len() > 1 { "s" } else { "" },
+                                        field.generic_params_string(),
+                                        snippet(cx, field.def.ty.span, "Unknown"),
+                                    )),
+                                };
+                            }
+                        },
+                    );
+                }
+            }
+        }
+    }
+}
+
+struct NonSendField<'tcx> {
+    def: &'tcx FieldDef<'tcx>,
+    ty: Ty<'tcx>,
+    generic_params: Vec<Ty<'tcx>>,
+}
+
+impl<'tcx> NonSendField<'tcx> {
+    fn generic_params_string(&self) -> String {
+        self.generic_params
+            .iter()
+            .map(ToString::to_string)
+            .collect::<Vec<_>>()
+            .join(", ")
+    }
+}
+
+/// Given a type, collect all of its generic parameters.
+/// Example: `MyStruct<P, Box<Q, R>>` => `vec![P, Q, R]`
+fn collect_generic_params<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Vec<Ty<'tcx>> {
+    ty.walk(cx.tcx)
+        .filter_map(|inner| match inner.unpack() {
+            GenericArgKind::Type(inner_ty) => Some(inner_ty),
+            _ => None,
+        })
+        .filter(|&inner_ty| is_ty_param(inner_ty))
+        .collect()
+}
+
+/// Be more strict when the heuristic is disabled
+fn ty_allowed_without_raw_pointer_heuristic<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>, send_trait: DefId) -> bool {
+    if implements_trait(cx, ty, send_trait, &[]) {
+        return true;
+    }
+
+    if is_copy(cx, ty) && !contains_raw_pointer(cx, ty) {
+        return true;
+    }
+
+    false
+}
+
+/// Heuristic to allow cases like `Vec<*const u8>`
+fn ty_allowed_with_raw_pointer_heuristic<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>, send_trait: DefId) -> bool {
+    if implements_trait(cx, ty, send_trait, &[]) || is_copy(cx, ty) {
+        return true;
+    }
+
+    // The type is known to be `!Send` and `!Copy`
+    match ty.kind() {
+        ty::Tuple(_) => ty
+            .tuple_fields()
+            .all(|ty| ty_allowed_with_raw_pointer_heuristic(cx, ty, send_trait)),
+        ty::Array(ty, _) | ty::Slice(ty) => ty_allowed_with_raw_pointer_heuristic(cx, ty, send_trait),
+        ty::Adt(_, substs) => {
+            if contains_raw_pointer(cx, ty) {
+                // descends only if ADT contains any raw pointers
+                substs.iter().all(|generic_arg| match generic_arg.unpack() {
+                    GenericArgKind::Type(ty) => ty_allowed_with_raw_pointer_heuristic(cx, ty, send_trait),
+                    // Lifetimes and const generics are not solid part of ADT and ignored
+                    GenericArgKind::Lifetime(_) | GenericArgKind::Const(_) => true,
+                })
+            } else {
+                false
+            }
+        },
+        // Raw pointers are `!Send` but allowed by the heuristic
+        ty::RawPtr(_) => true,
+        _ => false,
+    }
+}
+
+/// Checks if the type contains any raw pointers in substs (including nested ones).
+fn contains_raw_pointer<'tcx>(cx: &LateContext<'tcx>, target_ty: Ty<'tcx>) -> bool {
+    for ty_node in target_ty.walk(cx.tcx) {
+        if_chain! {
+            if let GenericArgKind::Type(inner_ty) = ty_node.unpack();
+            if let ty::RawPtr(_) = inner_ty.kind();
+            then {
+                return true;
+            }
+        }
+    }
+
+    false
+}
+
+/// Returns `true` if the type is a type parameter such as `T`.
+fn is_ty_param(target_ty: Ty<'_>) -> bool {
+    matches!(target_ty.kind(), ty::Param(_))
+}
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index e6233f73a57..6cbada4c150 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -284,9 +284,9 @@ define_Conf! {
     ///
     /// The list of unicode scripts allowed to be used in the scope.
     (allowed_scripts: Vec<String> = vec!["Latin".to_string()]),
-    /// Lint: NON_SEND_FIELD_IN_SEND_TY.
+    /// Lint: NON_SEND_FIELDS_IN_SEND_TY.
     ///
-    /// Whether to apply the raw pointer heuristic in `non_send_field_in_send_ty` lint.
+    /// Whether to apply the raw pointer heuristic to determine if a type is `Send`.
     (enable_raw_pointer_heuristic_for_send: bool = true),
 }
 
diff --git a/tests/ui-toml/strict_non_send_field_in_send_ty/clippy.toml b/tests/ui-toml/strict_non_send_field_in_send_ty/clippy.toml
deleted file mode 100644
index a942709d14a..00000000000
--- a/tests/ui-toml/strict_non_send_field_in_send_ty/clippy.toml
+++ /dev/null
@@ -1 +0,0 @@
-enable-raw-pointer-heuristic-for-send = false
diff --git a/tests/ui-toml/strict_non_send_field_in_send_ty/test.rs b/tests/ui-toml/strict_non_send_field_in_send_ty/test.rs
deleted file mode 100644
index 6306c9c9f6d..00000000000
--- a/tests/ui-toml/strict_non_send_field_in_send_ty/test.rs
+++ /dev/null
@@ -1,43 +0,0 @@
-#![warn(clippy::non_send_field_in_send_ty)]
-#![feature(extern_types)]
-
-use std::rc::Rc;
-
-// Basic tests should not be affected
-pub struct NoGeneric {
-    rc_is_not_send: Rc<String>,
-}
-
-unsafe impl Send for NoGeneric {}
-
-pub struct MultiField<T> {
-    field1: T,
-    field2: T,
-    field3: T,
-}
-
-unsafe impl<T> Send for MultiField<T> {}
-
-pub enum MyOption<T> {
-    MySome(T),
-    MyNone,
-}
-
-unsafe impl<T> Send for MyOption<T> {}
-
-// All fields are disallowed when raw pointer heuristic is off
-extern "C" {
-    type NonSend;
-}
-
-pub struct HeuristicTest {
-    field1: Vec<*const NonSend>,
-    field2: [*const NonSend; 3],
-    field3: (*const NonSend, *const NonSend, *const NonSend),
-    field4: (*const NonSend, Rc<u8>),
-    field5: Vec<Vec<*const NonSend>>,
-}
-
-unsafe impl Send for HeuristicTest {}
-
-fn main() {}
diff --git a/tests/ui-toml/strict_non_send_field_in_send_ty/test.stderr b/tests/ui-toml/strict_non_send_field_in_send_ty/test.stderr
deleted file mode 100644
index 74ec93cfa55..00000000000
--- a/tests/ui-toml/strict_non_send_field_in_send_ty/test.stderr
+++ /dev/null
@@ -1,91 +0,0 @@
-error: this implementation is unsound, as some fields in `NoGeneric` are `!Send`
-  --> $DIR/test.rs:11:1
-   |
-LL | unsafe impl Send for NoGeneric {}
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: `-D clippy::non-send-field-in-send-ty` implied by `-D warnings`
-note: the type of field `rc_is_not_send` is `!Send`
-  --> $DIR/test.rs:8:5
-   |
-LL |     rc_is_not_send: Rc<String>,
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
-   = help: use a thread-safe type that implements `Send`
-
-error: this implementation is unsound, as some fields in `MultiField<T>` are `!Send`
-  --> $DIR/test.rs:19:1
-   |
-LL | unsafe impl<T> Send for MultiField<T> {}
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-note: the type of field `field1` is `!Send`
-  --> $DIR/test.rs:14:5
-   |
-LL |     field1: T,
-   |     ^^^^^^^^^
-   = help: add `T: Send` bound in `Send` impl
-note: the type of field `field2` is `!Send`
-  --> $DIR/test.rs:15:5
-   |
-LL |     field2: T,
-   |     ^^^^^^^^^
-   = help: add `T: Send` bound in `Send` impl
-note: the type of field `field3` is `!Send`
-  --> $DIR/test.rs:16:5
-   |
-LL |     field3: T,
-   |     ^^^^^^^^^
-   = help: add `T: Send` bound in `Send` impl
-
-error: this implementation is unsound, as some fields in `MyOption<T>` are `!Send`
-  --> $DIR/test.rs:26:1
-   |
-LL | unsafe impl<T> Send for MyOption<T> {}
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-note: the type of field `0` is `!Send`
-  --> $DIR/test.rs:22:12
-   |
-LL |     MySome(T),
-   |            ^
-   = help: add `T: Send` bound in `Send` impl
-
-error: this implementation is unsound, as some fields in `HeuristicTest` are `!Send`
-  --> $DIR/test.rs:41:1
-   |
-LL | unsafe impl Send for HeuristicTest {}
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-note: the type of field `field1` is `!Send`
-  --> $DIR/test.rs:34:5
-   |
-LL |     field1: Vec<*const NonSend>,
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   = help: use a thread-safe type that implements `Send`
-note: the type of field `field2` is `!Send`
-  --> $DIR/test.rs:35:5
-   |
-LL |     field2: [*const NonSend; 3],
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   = help: use a thread-safe type that implements `Send`
-note: the type of field `field3` is `!Send`
-  --> $DIR/test.rs:36:5
-   |
-LL |     field3: (*const NonSend, *const NonSend, *const NonSend),
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   = help: use a thread-safe type that implements `Send`
-note: the type of field `field4` is `!Send`
-  --> $DIR/test.rs:37:5
-   |
-LL |     field4: (*const NonSend, Rc<u8>),
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   = help: use a thread-safe type that implements `Send`
-note: the type of field `field5` is `!Send`
-  --> $DIR/test.rs:38:5
-   |
-LL |     field5: Vec<Vec<*const NonSend>>,
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   = help: use a thread-safe type that implements `Send`
-
-error: aborting due to 4 previous errors
-
diff --git a/tests/ui-toml/strict_non_send_fields_in_send_ty/clippy.toml b/tests/ui-toml/strict_non_send_fields_in_send_ty/clippy.toml
new file mode 100644
index 00000000000..a942709d14a
--- /dev/null
+++ b/tests/ui-toml/strict_non_send_fields_in_send_ty/clippy.toml
@@ -0,0 +1 @@
+enable-raw-pointer-heuristic-for-send = false
diff --git a/tests/ui-toml/strict_non_send_fields_in_send_ty/test.rs b/tests/ui-toml/strict_non_send_fields_in_send_ty/test.rs
new file mode 100644
index 00000000000..90c2439dc34
--- /dev/null
+++ b/tests/ui-toml/strict_non_send_fields_in_send_ty/test.rs
@@ -0,0 +1,43 @@
+#![warn(clippy::non_send_fields_in_send_ty)]
+#![feature(extern_types)]
+
+use std::rc::Rc;
+
+// Basic tests should not be affected
+pub struct NoGeneric {
+    rc_is_not_send: Rc<String>,
+}
+
+unsafe impl Send for NoGeneric {}
+
+pub struct MultiField<T> {
+    field1: T,
+    field2: T,
+    field3: T,
+}
+
+unsafe impl<T> Send for MultiField<T> {}
+
+pub enum MyOption<T> {
+    MySome(T),
+    MyNone,
+}
+
+unsafe impl<T> Send for MyOption<T> {}
+
+// All fields are disallowed when raw pointer heuristic is off
+extern "C" {
+    type NonSend;
+}
+
+pub struct HeuristicTest {
+    field1: Vec<*const NonSend>,
+    field2: [*const NonSend; 3],
+    field3: (*const NonSend, *const NonSend, *const NonSend),
+    field4: (*const NonSend, Rc<u8>),
+    field5: Vec<Vec<*const NonSend>>,
+}
+
+unsafe impl Send for HeuristicTest {}
+
+fn main() {}
diff --git a/tests/ui-toml/strict_non_send_fields_in_send_ty/test.stderr b/tests/ui-toml/strict_non_send_fields_in_send_ty/test.stderr
new file mode 100644
index 00000000000..b07f9dd3df3
--- /dev/null
+++ b/tests/ui-toml/strict_non_send_fields_in_send_ty/test.stderr
@@ -0,0 +1,91 @@
+error: this implementation is unsound, as some fields in `NoGeneric` are `!Send`
+  --> $DIR/test.rs:11:1
+   |
+LL | unsafe impl Send for NoGeneric {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::non-send-fields-in-send-ty` implied by `-D warnings`
+note: the type of field `rc_is_not_send` is `!Send`
+  --> $DIR/test.rs:8:5
+   |
+LL |     rc_is_not_send: Rc<String>,
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   = help: use a thread-safe type that implements `Send`
+
+error: this implementation is unsound, as some fields in `MultiField<T>` are `!Send`
+  --> $DIR/test.rs:19:1
+   |
+LL | unsafe impl<T> Send for MultiField<T> {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: the type of field `field1` is `!Send`
+  --> $DIR/test.rs:14:5
+   |
+LL |     field1: T,
+   |     ^^^^^^^^^
+   = help: add `T: Send` bound in `Send` impl
+note: the type of field `field2` is `!Send`
+  --> $DIR/test.rs:15:5
+   |
+LL |     field2: T,
+   |     ^^^^^^^^^
+   = help: add `T: Send` bound in `Send` impl
+note: the type of field `field3` is `!Send`
+  --> $DIR/test.rs:16:5
+   |
+LL |     field3: T,
+   |     ^^^^^^^^^
+   = help: add `T: Send` bound in `Send` impl
+
+error: this implementation is unsound, as some fields in `MyOption<T>` are `!Send`
+  --> $DIR/test.rs:26:1
+   |
+LL | unsafe impl<T> Send for MyOption<T> {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: the type of field `0` is `!Send`
+  --> $DIR/test.rs:22:12
+   |
+LL |     MySome(T),
+   |            ^
+   = help: add `T: Send` bound in `Send` impl
+
+error: this implementation is unsound, as some fields in `HeuristicTest` are `!Send`
+  --> $DIR/test.rs:41:1
+   |
+LL | unsafe impl Send for HeuristicTest {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: the type of field `field1` is `!Send`
+  --> $DIR/test.rs:34:5
+   |
+LL |     field1: Vec<*const NonSend>,
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   = help: use a thread-safe type that implements `Send`
+note: the type of field `field2` is `!Send`
+  --> $DIR/test.rs:35:5
+   |
+LL |     field2: [*const NonSend; 3],
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   = help: use a thread-safe type that implements `Send`
+note: the type of field `field3` is `!Send`
+  --> $DIR/test.rs:36:5
+   |
+LL |     field3: (*const NonSend, *const NonSend, *const NonSend),
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   = help: use a thread-safe type that implements `Send`
+note: the type of field `field4` is `!Send`
+  --> $DIR/test.rs:37:5
+   |
+LL |     field4: (*const NonSend, Rc<u8>),
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   = help: use a thread-safe type that implements `Send`
+note: the type of field `field5` is `!Send`
+  --> $DIR/test.rs:38:5
+   |
+LL |     field5: Vec<Vec<*const NonSend>>,
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   = help: use a thread-safe type that implements `Send`
+
+error: aborting due to 4 previous errors
+
diff --git a/tests/ui/non_send_field_in_send_ty.rs b/tests/ui/non_send_field_in_send_ty.rs
deleted file mode 100644
index f5e7abdecd1..00000000000
--- a/tests/ui/non_send_field_in_send_ty.rs
+++ /dev/null
@@ -1,127 +0,0 @@
-#![warn(clippy::non_send_field_in_send_ty)]
-#![feature(extern_types)]
-
-use std::cell::UnsafeCell;
-use std::ptr::NonNull;
-use std::rc::Rc;
-use std::sync::{Arc, Mutex, MutexGuard};
-
-// disrustor / RUSTSEC-2020-0150
-pub struct RingBuffer<T> {
-    data: Vec<UnsafeCell<T>>,
-    capacity: usize,
-    mask: usize,
-}
-
-unsafe impl<T> Send for RingBuffer<T> {}
-
-// noise_search / RUSTSEC-2020-0141
-pub struct MvccRwLock<T> {
-    raw: *const T,
-    lock: Mutex<Box<T>>,
-}
-
-unsafe impl<T> Send for MvccRwLock<T> {}
-
-// async-coap / RUSTSEC-2020-0124
-pub struct ArcGuard<RC, T> {
-    inner: T,
-    head: Arc<RC>,
-}
-
-unsafe impl<RC, T: Send> Send for ArcGuard<RC, T> {}
-
-// rusb / RUSTSEC-2020-0098
-extern "C" {
-    type libusb_device_handle;
-}
-
-pub trait UsbContext {
-    // some user trait that does not guarantee `Send`
-}
-
-pub struct DeviceHandle<T: UsbContext> {
-    context: T,
-    handle: NonNull<libusb_device_handle>,
-}
-
-unsafe impl<T: UsbContext> Send for DeviceHandle<T> {}
-
-// Other basic tests
-pub struct NoGeneric {
-    rc_is_not_send: Rc<String>,
-}
-
-unsafe impl Send for NoGeneric {}
-
-pub struct MultiField<T> {
-    field1: T,
-    field2: T,
-    field3: T,
-}
-
-unsafe impl<T> Send for MultiField<T> {}
-
-pub enum MyOption<T> {
-    MySome(T),
-    MyNone,
-}
-
-unsafe impl<T> Send for MyOption<T> {}
-
-// Multiple type parameters
-pub struct MultiParam<A, B> {
-    vec: Vec<(A, B)>,
-}
-
-unsafe impl<A, B> Send for MultiParam<A, B> {}
-
-// Tests for raw pointer heuristic
-extern "C" {
-    type NonSend;
-}
-
-pub struct HeuristicTest {
-    // raw pointers are allowed
-    field1: Vec<*const NonSend>,
-    field2: [*const NonSend; 3],
-    field3: (*const NonSend, *const NonSend, *const NonSend),
-    // not allowed when it contains concrete `!Send` field
-    field4: (*const NonSend, Rc<u8>),
-    // nested raw pointer is also allowed
-    field5: Vec<Vec<*const NonSend>>,
-}
-
-unsafe impl Send for HeuristicTest {}
-
-// Test attributes
-#[allow(clippy::non_send_field_in_send_ty)]
-pub struct AttrTest1<T>(T);
-
-pub struct AttrTest2<T> {
-    #[allow(clippy::non_send_field_in_send_ty)]
-    field: T,
-}
-
-pub enum AttrTest3<T> {
-    #[allow(clippy::non_send_field_in_send_ty)]
-    Enum1(T),
-    Enum2(T),
-}
-
-unsafe impl<T> Send for AttrTest1<T> {}
-unsafe impl<T> Send for AttrTest2<T> {}
-unsafe impl<T> Send for AttrTest3<T> {}
-
-// Multiple non-overlapping `Send` for a single type
-pub struct Complex<A, B> {
-    field1: A,
-    field2: B,
-}
-
-unsafe impl<P> Send for Complex<P, u32> {}
-
-// `MutexGuard` is non-Send
-unsafe impl<Q: Send> Send for Complex<Q, MutexGuard<'static, bool>> {}
-
-fn main() {}
diff --git a/tests/ui/non_send_field_in_send_ty.stderr b/tests/ui/non_send_field_in_send_ty.stderr
deleted file mode 100644
index f49a7355b53..00000000000
--- a/tests/ui/non_send_field_in_send_ty.stderr
+++ /dev/null
@@ -1,171 +0,0 @@
-error: this implementation is unsound, as some fields in `RingBuffer<T>` are `!Send`
-  --> $DIR/non_send_field_in_send_ty.rs:16:1
-   |
-LL | unsafe impl<T> Send for RingBuffer<T> {}
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: `-D clippy::non-send-field-in-send-ty` implied by `-D warnings`
-note: the type of field `data` is `!Send`
-  --> $DIR/non_send_field_in_send_ty.rs:11:5
-   |
-LL |     data: Vec<UnsafeCell<T>>,
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^
-   = help: add bounds on type parameter `T` that satisfy `Vec<UnsafeCell<T>>: Send`
-
-error: this implementation is unsound, as some fields in `MvccRwLock<T>` are `!Send`
-  --> $DIR/non_send_field_in_send_ty.rs:24:1
-   |
-LL | unsafe impl<T> Send for MvccRwLock<T> {}
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-note: the type of field `lock` is `!Send`
-  --> $DIR/non_send_field_in_send_ty.rs:21:5
-   |
-LL |     lock: Mutex<Box<T>>,
-   |     ^^^^^^^^^^^^^^^^^^^
-   = help: add bounds on type parameter `T` that satisfy `Mutex<Box<T>>: Send`
-
-error: this implementation is unsound, as some fields in `ArcGuard<RC, T>` are `!Send`
-  --> $DIR/non_send_field_in_send_ty.rs:32:1
-   |
-LL | unsafe impl<RC, T: Send> Send for ArcGuard<RC, T> {}
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-note: the type of field `head` is `!Send`
-  --> $DIR/non_send_field_in_send_ty.rs:29:5
-   |
-LL |     head: Arc<RC>,
-   |     ^^^^^^^^^^^^^
-   = help: add bounds on type parameter `RC` that satisfy `Arc<RC>: Send`
-
-error: this implementation is unsound, as some fields in `DeviceHandle<T>` are `!Send`
-  --> $DIR/non_send_field_in_send_ty.rs:48:1
-   |
-LL | unsafe impl<T: UsbContext> Send for DeviceHandle<T> {}
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-note: the type of field `context` is `!Send`
-  --> $DIR/non_send_field_in_send_ty.rs:44:5
-   |
-LL |     context: T,
-   |     ^^^^^^^^^^
-   = help: add `T: Send` bound in `Send` impl
-
-error: this implementation is unsound, as some fields in `NoGeneric` are `!Send`
-  --> $DIR/non_send_field_in_send_ty.rs:55:1
-   |
-LL | unsafe impl Send for NoGeneric {}
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-note: the type of field `rc_is_not_send` is `!Send`
-  --> $DIR/non_send_field_in_send_ty.rs:52:5
-   |
-LL |     rc_is_not_send: Rc<String>,
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
-   = help: use a thread-safe type that implements `Send`
-
-error: this implementation is unsound, as some fields in `MultiField<T>` are `!Send`
-  --> $DIR/non_send_field_in_send_ty.rs:63:1
-   |
-LL | unsafe impl<T> Send for MultiField<T> {}
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-note: the type of field `field1` is `!Send`
-  --> $DIR/non_send_field_in_send_ty.rs:58:5
-   |
-LL |     field1: T,
-   |     ^^^^^^^^^
-   = help: add `T: Send` bound in `Send` impl
-note: the type of field `field2` is `!Send`
-  --> $DIR/non_send_field_in_send_ty.rs:59:5
-   |
-LL |     field2: T,
-   |     ^^^^^^^^^
-   = help: add `T: Send` bound in `Send` impl
-note: the type of field `field3` is `!Send`
-  --> $DIR/non_send_field_in_send_ty.rs:60:5
-   |
-LL |     field3: T,
-   |     ^^^^^^^^^
-   = help: add `T: Send` bound in `Send` impl
-
-error: this implementation is unsound, as some fields in `MyOption<T>` are `!Send`
-  --> $DIR/non_send_field_in_send_ty.rs:70:1
-   |
-LL | unsafe impl<T> Send for MyOption<T> {}
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-note: the type of field `0` is `!Send`
-  --> $DIR/non_send_field_in_send_ty.rs:66:12
-   |
-LL |     MySome(T),
-   |            ^
-   = help: add `T: Send` bound in `Send` impl
-
-error: this implementation is unsound, as some fields in `MultiParam<A, B>` are `!Send`
-  --> $DIR/non_send_field_in_send_ty.rs:77:1
-   |
-LL | unsafe impl<A, B> Send for MultiParam<A, B> {}
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-note: the type of field `vec` is `!Send`
-  --> $DIR/non_send_field_in_send_ty.rs:74:5
-   |
-LL |     vec: Vec<(A, B)>,
-   |     ^^^^^^^^^^^^^^^^
-   = help: add bounds on type parameters `A, B` that satisfy `Vec<(A, B)>: Send`
-
-error: this implementation is unsound, as some fields in `HeuristicTest` are `!Send`
-  --> $DIR/non_send_field_in_send_ty.rs:95:1
-   |
-LL | unsafe impl Send for HeuristicTest {}
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-note: the type of field `field4` is `!Send`
-  --> $DIR/non_send_field_in_send_ty.rs:90:5
-   |
-LL |     field4: (*const NonSend, Rc<u8>),
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   = help: use a thread-safe type that implements `Send`
-
-error: this implementation is unsound, as some fields in `AttrTest3<T>` are `!Send`
-  --> $DIR/non_send_field_in_send_ty.rs:114:1
-   |
-LL | unsafe impl<T> Send for AttrTest3<T> {}
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-note: the type of field `0` is `!Send`
-  --> $DIR/non_send_field_in_send_ty.rs:109:11
-   |
-LL |     Enum2(T),
-   |           ^
-   = help: add `T: Send` bound in `Send` impl
-
-error: this implementation is unsound, as some fields in `Complex<P, u32>` are `!Send`
-  --> $DIR/non_send_field_in_send_ty.rs:122:1
-   |
-LL | unsafe impl<P> Send for Complex<P, u32> {}
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-note: the type of field `field1` is `!Send`
-  --> $DIR/non_send_field_in_send_ty.rs:118:5
-   |
-LL |     field1: A,
-   |     ^^^^^^^^^
-   = help: add `P: Send` bound in `Send` impl
-
-error: this implementation is unsound, as some fields in `Complex<Q, MutexGuard<'static, bool>>` are `!Send`
-  --> $DIR/non_send_field_in_send_ty.rs:125:1
-   |
-LL | unsafe impl<Q: Send> Send for Complex<Q, MutexGuard<'static, bool>> {}
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-note: the type of field `field2` is `!Send`
-  --> $DIR/non_send_field_in_send_ty.rs:119:5
-   |
-LL |     field2: B,
-   |     ^^^^^^^^^
-   = help: use a thread-safe type that implements `Send`
-
-error: aborting due to 12 previous errors
-
diff --git a/tests/ui/non_send_fields_in_send_ty.rs b/tests/ui/non_send_fields_in_send_ty.rs
new file mode 100644
index 00000000000..eca7f5e5655
--- /dev/null
+++ b/tests/ui/non_send_fields_in_send_ty.rs
@@ -0,0 +1,127 @@
+#![warn(clippy::non_send_fields_in_send_ty)]
+#![feature(extern_types)]
+
+use std::cell::UnsafeCell;
+use std::ptr::NonNull;
+use std::rc::Rc;
+use std::sync::{Arc, Mutex, MutexGuard};
+
+// disrustor / RUSTSEC-2020-0150
+pub struct RingBuffer<T> {
+    data: Vec<UnsafeCell<T>>,
+    capacity: usize,
+    mask: usize,
+}
+
+unsafe impl<T> Send for RingBuffer<T> {}
+
+// noise_search / RUSTSEC-2020-0141
+pub struct MvccRwLock<T> {
+    raw: *const T,
+    lock: Mutex<Box<T>>,
+}
+
+unsafe impl<T> Send for MvccRwLock<T> {}
+
+// async-coap / RUSTSEC-2020-0124
+pub struct ArcGuard<RC, T> {
+    inner: T,
+    head: Arc<RC>,
+}
+
+unsafe impl<RC, T: Send> Send for ArcGuard<RC, T> {}
+
+// rusb / RUSTSEC-2020-0098
+extern "C" {
+    type libusb_device_handle;
+}
+
+pub trait UsbContext {
+    // some user trait that does not guarantee `Send`
+}
+
+pub struct DeviceHandle<T: UsbContext> {
+    context: T,
+    handle: NonNull<libusb_device_handle>,
+}
+
+unsafe impl<T: UsbContext> Send for DeviceHandle<T> {}
+
+// Other basic tests
+pub struct NoGeneric {
+    rc_is_not_send: Rc<String>,
+}
+
+unsafe impl Send for NoGeneric {}
+
+pub struct MultiField<T> {
+    field1: T,
+    field2: T,
+    field3: T,
+}
+
+unsafe impl<T> Send for MultiField<T> {}
+
+pub enum MyOption<T> {
+    MySome(T),
+    MyNone,
+}
+
+unsafe impl<T> Send for MyOption<T> {}
+
+// Multiple type parameters
+pub struct MultiParam<A, B> {
+    vec: Vec<(A, B)>,
+}
+
+unsafe impl<A, B> Send for MultiParam<A, B> {}
+
+// Tests for raw pointer heuristic
+extern "C" {
+    type NonSend;
+}
+
+pub struct HeuristicTest {
+    // raw pointers are allowed
+    field1: Vec<*const NonSend>,
+    field2: [*const NonSend; 3],
+    field3: (*const NonSend, *const NonSend, *const NonSend),
+    // not allowed when it contains concrete `!Send` field
+    field4: (*const NonSend, Rc<u8>),
+    // nested raw pointer is also allowed
+    field5: Vec<Vec<*const NonSend>>,
+}
+
+unsafe impl Send for HeuristicTest {}
+
+// Test attributes
+#[allow(clippy::non_send_fields_in_send_ty)]
+pub struct AttrTest1<T>(T);
+
+pub struct AttrTest2<T> {
+    #[allow(clippy::non_send_fields_in_send_ty)]
+    field: T,
+}
+
+pub enum AttrTest3<T> {
+    #[allow(clippy::non_send_fields_in_send_ty)]
+    Enum1(T),
+    Enum2(T),
+}
+
+unsafe impl<T> Send for AttrTest1<T> {}
+unsafe impl<T> Send for AttrTest2<T> {}
+unsafe impl<T> Send for AttrTest3<T> {}
+
+// Multiple non-overlapping `Send` for a single type
+pub struct Complex<A, B> {
+    field1: A,
+    field2: B,
+}
+
+unsafe impl<P> Send for Complex<P, u32> {}
+
+// `MutexGuard` is non-Send
+unsafe impl<Q: Send> Send for Complex<Q, MutexGuard<'static, bool>> {}
+
+fn main() {}
diff --git a/tests/ui/non_send_fields_in_send_ty.stderr b/tests/ui/non_send_fields_in_send_ty.stderr
new file mode 100644
index 00000000000..8b8a1d16d9b
--- /dev/null
+++ b/tests/ui/non_send_fields_in_send_ty.stderr
@@ -0,0 +1,171 @@
+error: this implementation is unsound, as some fields in `RingBuffer<T>` are `!Send`
+  --> $DIR/non_send_fields_in_send_ty.rs:16:1
+   |
+LL | unsafe impl<T> Send for RingBuffer<T> {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::non-send-fields-in-send-ty` implied by `-D warnings`
+note: the type of field `data` is `!Send`
+  --> $DIR/non_send_fields_in_send_ty.rs:11:5
+   |
+LL |     data: Vec<UnsafeCell<T>>,
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^
+   = help: add bounds on type parameter `T` that satisfy `Vec<UnsafeCell<T>>: Send`
+
+error: this implementation is unsound, as some fields in `MvccRwLock<T>` are `!Send`
+  --> $DIR/non_send_fields_in_send_ty.rs:24:1
+   |
+LL | unsafe impl<T> Send for MvccRwLock<T> {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: the type of field `lock` is `!Send`
+  --> $DIR/non_send_fields_in_send_ty.rs:21:5
+   |
+LL |     lock: Mutex<Box<T>>,
+   |     ^^^^^^^^^^^^^^^^^^^
+   = help: add bounds on type parameter `T` that satisfy `Mutex<Box<T>>: Send`
+
+error: this implementation is unsound, as some fields in `ArcGuard<RC, T>` are `!Send`
+  --> $DIR/non_send_fields_in_send_ty.rs:32:1
+   |
+LL | unsafe impl<RC, T: Send> Send for ArcGuard<RC, T> {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: the type of field `head` is `!Send`
+  --> $DIR/non_send_fields_in_send_ty.rs:29:5
+   |
+LL |     head: Arc<RC>,
+   |     ^^^^^^^^^^^^^
+   = help: add bounds on type parameter `RC` that satisfy `Arc<RC>: Send`
+
+error: this implementation is unsound, as some fields in `DeviceHandle<T>` are `!Send`
+  --> $DIR/non_send_fields_in_send_ty.rs:48:1
+   |
+LL | unsafe impl<T: UsbContext> Send for DeviceHandle<T> {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: the type of field `context` is `!Send`
+  --> $DIR/non_send_fields_in_send_ty.rs:44:5
+   |
+LL |     context: T,
+   |     ^^^^^^^^^^
+   = help: add `T: Send` bound in `Send` impl
+
+error: this implementation is unsound, as some fields in `NoGeneric` are `!Send`
+  --> $DIR/non_send_fields_in_send_ty.rs:55:1
+   |
+LL | unsafe impl Send for NoGeneric {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: the type of field `rc_is_not_send` is `!Send`
+  --> $DIR/non_send_fields_in_send_ty.rs:52:5
+   |
+LL |     rc_is_not_send: Rc<String>,
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   = help: use a thread-safe type that implements `Send`
+
+error: this implementation is unsound, as some fields in `MultiField<T>` are `!Send`
+  --> $DIR/non_send_fields_in_send_ty.rs:63:1
+   |
+LL | unsafe impl<T> Send for MultiField<T> {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: the type of field `field1` is `!Send`
+  --> $DIR/non_send_fields_in_send_ty.rs:58:5
+   |
+LL |     field1: T,
+   |     ^^^^^^^^^
+   = help: add `T: Send` bound in `Send` impl
+note: the type of field `field2` is `!Send`
+  --> $DIR/non_send_fields_in_send_ty.rs:59:5
+   |
+LL |     field2: T,
+   |     ^^^^^^^^^
+   = help: add `T: Send` bound in `Send` impl
+note: the type of field `field3` is `!Send`
+  --> $DIR/non_send_fields_in_send_ty.rs:60:5
+   |
+LL |     field3: T,
+   |     ^^^^^^^^^
+   = help: add `T: Send` bound in `Send` impl
+
+error: this implementation is unsound, as some fields in `MyOption<T>` are `!Send`
+  --> $DIR/non_send_fields_in_send_ty.rs:70:1
+   |
+LL | unsafe impl<T> Send for MyOption<T> {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: the type of field `0` is `!Send`
+  --> $DIR/non_send_fields_in_send_ty.rs:66:12
+   |
+LL |     MySome(T),
+   |            ^
+   = help: add `T: Send` bound in `Send` impl
+
+error: this implementation is unsound, as some fields in `MultiParam<A, B>` are `!Send`
+  --> $DIR/non_send_fields_in_send_ty.rs:77:1
+   |
+LL | unsafe impl<A, B> Send for MultiParam<A, B> {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: the type of field `vec` is `!Send`
+  --> $DIR/non_send_fields_in_send_ty.rs:74:5
+   |
+LL |     vec: Vec<(A, B)>,
+   |     ^^^^^^^^^^^^^^^^
+   = help: add bounds on type parameters `A, B` that satisfy `Vec<(A, B)>: Send`
+
+error: this implementation is unsound, as some fields in `HeuristicTest` are `!Send`
+  --> $DIR/non_send_fields_in_send_ty.rs:95:1
+   |
+LL | unsafe impl Send for HeuristicTest {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: the type of field `field4` is `!Send`
+  --> $DIR/non_send_fields_in_send_ty.rs:90:5
+   |
+LL |     field4: (*const NonSend, Rc<u8>),
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   = help: use a thread-safe type that implements `Send`
+
+error: this implementation is unsound, as some fields in `AttrTest3<T>` are `!Send`
+  --> $DIR/non_send_fields_in_send_ty.rs:114:1
+   |
+LL | unsafe impl<T> Send for AttrTest3<T> {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: the type of field `0` is `!Send`
+  --> $DIR/non_send_fields_in_send_ty.rs:109:11
+   |
+LL |     Enum2(T),
+   |           ^
+   = help: add `T: Send` bound in `Send` impl
+
+error: this implementation is unsound, as some fields in `Complex<P, u32>` are `!Send`
+  --> $DIR/non_send_fields_in_send_ty.rs:122:1
+   |
+LL | unsafe impl<P> Send for Complex<P, u32> {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: the type of field `field1` is `!Send`
+  --> $DIR/non_send_fields_in_send_ty.rs:118:5
+   |
+LL |     field1: A,
+   |     ^^^^^^^^^
+   = help: add `P: Send` bound in `Send` impl
+
+error: this implementation is unsound, as some fields in `Complex<Q, MutexGuard<'static, bool>>` are `!Send`
+  --> $DIR/non_send_fields_in_send_ty.rs:125:1
+   |
+LL | unsafe impl<Q: Send> Send for Complex<Q, MutexGuard<'static, bool>> {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: the type of field `field2` is `!Send`
+  --> $DIR/non_send_fields_in_send_ty.rs:119:5
+   |
+LL |     field2: B,
+   |     ^^^^^^^^^
+   = help: use a thread-safe type that implements `Send`
+
+error: aborting due to 12 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From ea8e65f0da3f1148cea03d5996c99cd7a505c02c Mon Sep 17 00:00:00 2001
From: hkalbasi <hamidrezakalbasi@protonmail.com>
Date: Sun, 3 Oct 2021 11:58:27 +0330
Subject: exclude enum from derivable impls

---
 clippy_lints/src/derivable_impls.rs |  1 +
 tests/ui/derivable_impls.rs         | 13 +++++++++++++
 2 files changed, 14 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/derivable_impls.rs b/clippy_lints/src/derivable_impls.rs
index 15252ef96cd..63422f7ec21 100644
--- a/clippy_lints/src/derivable_impls.rs
+++ b/clippy_lints/src/derivable_impls.rs
@@ -83,6 +83,7 @@ impl<'tcx> LateLintPass<'tcx> for DerivableImpls {
             if !attrs.iter().any(|attr| attr.doc_str().is_some());
             if let child_attrs = cx.tcx.hir().attrs(impl_item_hir);
             if !child_attrs.iter().any(|attr| attr.doc_str().is_some());
+            if !adt_def.is_enum();
             then {
                 if let TyKind::Path(QPath::Resolved(_, p)) = self_ty.kind {
                     if let Some(PathSegment { args: Some(a), .. }) = p.segments.last() {
diff --git a/tests/ui/derivable_impls.rs b/tests/ui/derivable_impls.rs
index 3eeebc117f3..a6412004726 100644
--- a/tests/ui/derivable_impls.rs
+++ b/tests/ui/derivable_impls.rs
@@ -227,4 +227,17 @@ impl Default for RepeatDefault2 {
     }
 }
 
+// https://github.com/rust-lang/rust-clippy/issues/7753
+
+pub enum IntOrString {
+    Int(i32),
+    String(String),
+}
+
+impl Default for IntOrString {
+    fn default() -> Self {
+        IntOrString::Int(0)
+    }
+}
+
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 0ebc656a9add6a08dac7d8be3e7f1983998bef34 Mon Sep 17 00:00:00 2001
From: HKalbasi <45197576+HKalbasi@users.noreply.github.com>
Date: Sun, 3 Oct 2021 13:01:57 +0330
Subject: Change not enum to is struct

---
 clippy_lints/src/derivable_impls.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/derivable_impls.rs b/clippy_lints/src/derivable_impls.rs
index 63422f7ec21..fdef0abe970 100644
--- a/clippy_lints/src/derivable_impls.rs
+++ b/clippy_lints/src/derivable_impls.rs
@@ -83,7 +83,7 @@ impl<'tcx> LateLintPass<'tcx> for DerivableImpls {
             if !attrs.iter().any(|attr| attr.doc_str().is_some());
             if let child_attrs = cx.tcx.hir().attrs(impl_item_hir);
             if !child_attrs.iter().any(|attr| attr.doc_str().is_some());
-            if !adt_def.is_enum();
+            if adt_def.is_struct();
             then {
                 if let TyKind::Path(QPath::Resolved(_, p)) = self_ty.kind {
                     if let Some(PathSegment { args: Some(a), .. }) = p.segments.last() {
-- 
cgit 1.4.1-3-g733a5


From e6e6e7d211d74e54dba121165bfb92116da85c33 Mon Sep 17 00:00:00 2001
From: dswij <dswijj@gmail.com>
Date: Mon, 27 Sep 2021 14:26:29 +0800
Subject: Change `unseparated_literal_suffix` type to restriction

---
 clippy_lints/src/lib.register_pedantic.rs    | 1 -
 clippy_lints/src/lib.register_restriction.rs | 1 +
 clippy_lints/src/misc_early/mod.rs           | 2 +-
 3 files changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.register_pedantic.rs b/clippy_lints/src/lib.register_pedantic.rs
index 6533b94e82b..c249fb39938 100644
--- a/clippy_lints/src/lib.register_pedantic.rs
+++ b/clippy_lints/src/lib.register_pedantic.rs
@@ -65,7 +65,6 @@ store.register_group(true, "clippy::pedantic", Some("clippy_pedantic"), vec![
     LintId::of(methods::MAP_UNWRAP_OR),
     LintId::of(misc::FLOAT_CMP),
     LintId::of(misc::USED_UNDERSCORE_BINDING),
-    LintId::of(misc_early::UNSEPARATED_LITERAL_SUFFIX),
     LintId::of(mut_mut::MUT_MUT),
     LintId::of(needless_bitwise_bool::NEEDLESS_BITWISE_BOOL),
     LintId::of(needless_borrow::REF_BINDING_TO_REFERENCE),
diff --git a/clippy_lints/src/lib.register_restriction.rs b/clippy_lints/src/lib.register_restriction.rs
index 4463dea5fcb..419a40b1bb8 100644
--- a/clippy_lints/src/lib.register_restriction.rs
+++ b/clippy_lints/src/lib.register_restriction.rs
@@ -35,6 +35,7 @@ store.register_group(true, "clippy::restriction", Some("clippy_restriction"), ve
     LintId::of(methods::UNWRAP_USED),
     LintId::of(misc::FLOAT_CMP_CONST),
     LintId::of(misc_early::UNNEEDED_FIELD_PATTERN),
+    LintId::of(misc_early::UNSEPARATED_LITERAL_SUFFIX),
     LintId::of(missing_doc::MISSING_DOCS_IN_PRIVATE_ITEMS),
     LintId::of(missing_enforced_import_rename::MISSING_ENFORCED_IMPORT_RENAMES),
     LintId::of(missing_inline::MISSING_INLINE_IN_PUBLIC_ITEMS),
diff --git a/clippy_lints/src/misc_early/mod.rs b/clippy_lints/src/misc_early/mod.rs
index b32feab4ee3..5aad08cdd46 100644
--- a/clippy_lints/src/misc_early/mod.rs
+++ b/clippy_lints/src/misc_early/mod.rs
@@ -128,7 +128,7 @@ declare_clippy_lint! {
     /// let y = 123832_i32;
     /// ```
     pub UNSEPARATED_LITERAL_SUFFIX,
-    pedantic,
+    restriction,
     "literals whose suffix is not separated by an underscore"
 }
 
-- 
cgit 1.4.1-3-g733a5


From 72f0180f7bcf033604822a6ab6e65cc9ccf7540f Mon Sep 17 00:00:00 2001
From: Takayuki Nakata <f.seasons017@gmail.com>
Date: Mon, 4 Oct 2021 23:31:40 +0900
Subject: Fix ICE in `implicit_hasher`

---
 clippy_lints/src/implicit_hasher.rs | 20 ++++++++++++++------
 tests/ui/implicit_hasher.rs         |  4 ++++
 tests/ui/implicit_hasher.stderr     | 35 +++++++++++++++++++++++------------
 3 files changed, 41 insertions(+), 18 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/implicit_hasher.rs b/clippy_lints/src/implicit_hasher.rs
index 2fe32fcf665..77318e74ca8 100644
--- a/clippy_lints/src/implicit_hasher.rs
+++ b/clippy_lints/src/implicit_hasher.rs
@@ -167,12 +167,20 @@ impl<'tcx> LateLintPass<'tcx> for ImplicitHasher {
                             continue;
                         }
                         let generics_suggestion_span = generics.span.substitute_dummy({
-                            let pos = snippet_opt(cx, item.span.until(body.params[0].pat.span))
-                                .and_then(|snip| {
-                                    let i = snip.find("fn")?;
-                                    Some(item.span.lo() + BytePos((i + (&snip[i..]).find('(')?) as u32))
-                                })
-                                .expect("failed to create span for type parameters");
+                            let pos = snippet_opt(
+                                cx,
+                                Span::new(
+                                    item.span.lo(),
+                                    body.params[0].pat.span.lo(),
+                                    item.span.ctxt(),
+                                    item.span.parent(),
+                                ),
+                            )
+                            .and_then(|snip| {
+                                let i = snip.find("fn")?;
+                                Some(item.span.lo() + BytePos((i + (&snip[i..]).find('(')?) as u32))
+                            })
+                            .expect("failed to create span for type parameters");
                             Span::new(pos, pos, item.span.ctxt(), item.span.parent())
                         });
 
diff --git a/tests/ui/implicit_hasher.rs b/tests/ui/implicit_hasher.rs
index 97c26bc83ad..aa69b097410 100644
--- a/tests/ui/implicit_hasher.rs
+++ b/tests/ui/implicit_hasher.rs
@@ -1,3 +1,4 @@
+// edition:2018
 // aux-build:implicit_hasher_macros.rs
 #![deny(clippy::implicit_hasher)]
 #![allow(unused)]
@@ -96,4 +97,7 @@ __implicit_hasher_test_macro!(impl<K, V> for HashMap<K, V> where V: test_macro::
 // #4260
 implicit_hasher_fn!();
 
+// #7712
+pub async fn election_vote(_data: HashMap<i32, i32>) {}
+
 fn main() {}
diff --git a/tests/ui/implicit_hasher.stderr b/tests/ui/implicit_hasher.stderr
index 2e62dd30f9f..dad5ab71f15 100644
--- a/tests/ui/implicit_hasher.stderr
+++ b/tests/ui/implicit_hasher.stderr
@@ -1,11 +1,11 @@
 error: impl for `HashMap` should be generalized over different hashers
-  --> $DIR/implicit_hasher.rs:16:35
+  --> $DIR/implicit_hasher.rs:17:35
    |
 LL | impl<K: Hash + Eq, V> Foo<i8> for HashMap<K, V> {
    |                                   ^^^^^^^^^^^^^
    |
 note: the lint level is defined here
-  --> $DIR/implicit_hasher.rs:2:9
+  --> $DIR/implicit_hasher.rs:3:9
    |
 LL | #![deny(clippy::implicit_hasher)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^
@@ -19,7 +19,7 @@ LL |         (HashMap::default(), HashMap::with_capacity_and_hasher(10, Default:
    |          ~~~~~~~~~~~~~~~~~~  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 error: impl for `HashMap` should be generalized over different hashers
-  --> $DIR/implicit_hasher.rs:25:36
+  --> $DIR/implicit_hasher.rs:26:36
    |
 LL | impl<K: Hash + Eq, V> Foo<i8> for (HashMap<K, V>,) {
    |                                    ^^^^^^^^^^^^^
@@ -34,7 +34,7 @@ LL |         ((HashMap::default(),), (HashMap::with_capacity_and_hasher(10, Defa
    |           ~~~~~~~~~~~~~~~~~~     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 error: impl for `HashMap` should be generalized over different hashers
-  --> $DIR/implicit_hasher.rs:30:19
+  --> $DIR/implicit_hasher.rs:31:19
    |
 LL | impl Foo<i16> for HashMap<String, String> {
    |                   ^^^^^^^^^^^^^^^^^^^^^^^
@@ -49,7 +49,7 @@ LL |         (HashMap::default(), HashMap::with_capacity_and_hasher(10, Default:
    |          ~~~~~~~~~~~~~~~~~~  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 error: impl for `HashSet` should be generalized over different hashers
-  --> $DIR/implicit_hasher.rs:47:32
+  --> $DIR/implicit_hasher.rs:48:32
    |
 LL | impl<T: Hash + Eq> Foo<i8> for HashSet<T> {
    |                                ^^^^^^^^^^
@@ -64,7 +64,7 @@ LL |         (HashSet::default(), HashSet::with_capacity_and_hasher(10, Default:
    |          ~~~~~~~~~~~~~~~~~~  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 error: impl for `HashSet` should be generalized over different hashers
-  --> $DIR/implicit_hasher.rs:52:19
+  --> $DIR/implicit_hasher.rs:53:19
    |
 LL | impl Foo<i16> for HashSet<String> {
    |                   ^^^^^^^^^^^^^^^
@@ -79,7 +79,7 @@ LL |         (HashSet::default(), HashSet::with_capacity_and_hasher(10, Default:
    |          ~~~~~~~~~~~~~~~~~~  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 error: parameter of type `HashMap` should be generalized over different hashers
-  --> $DIR/implicit_hasher.rs:69:23
+  --> $DIR/implicit_hasher.rs:70:23
    |
 LL | pub fn foo(_map: &mut HashMap<i32, i32>, _set: &mut HashSet<i32>) {}
    |                       ^^^^^^^^^^^^^^^^^
@@ -90,7 +90,7 @@ LL | pub fn foo<S: ::std::hash::BuildHasher>(_map: &mut HashMap<i32, i32, S>, _s
    |           +++++++++++++++++++++++++++++            ~~~~~~~~~~~~~~~~~~~~
 
 error: parameter of type `HashSet` should be generalized over different hashers
-  --> $DIR/implicit_hasher.rs:69:53
+  --> $DIR/implicit_hasher.rs:70:53
    |
 LL | pub fn foo(_map: &mut HashMap<i32, i32>, _set: &mut HashSet<i32>) {}
    |                                                     ^^^^^^^^^^^^
@@ -101,7 +101,7 @@ LL | pub fn foo<S: ::std::hash::BuildHasher>(_map: &mut HashMap<i32, i32>, _set:
    |           +++++++++++++++++++++++++++++                                          ~~~~~~~~~~~~~~~
 
 error: impl for `HashMap` should be generalized over different hashers
-  --> $DIR/implicit_hasher.rs:73:43
+  --> $DIR/implicit_hasher.rs:74:43
    |
 LL |         impl<K: Hash + Eq, V> Foo<u8> for HashMap<K, V> {
    |                                           ^^^^^^^^^^^^^
@@ -120,7 +120,7 @@ LL |                 (HashMap::default(), HashMap::with_capacity_and_hasher(10,
    |                  ~~~~~~~~~~~~~~~~~~  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 error: parameter of type `HashMap` should be generalized over different hashers
-  --> $DIR/implicit_hasher.rs:81:33
+  --> $DIR/implicit_hasher.rs:82:33
    |
 LL |         pub fn $name(_map: &mut HashMap<i32, i32>, _set: &mut HashSet<i32>) {}
    |                                 ^^^^^^^^^^^^^^^^^
@@ -135,7 +135,7 @@ LL |         pub fn $name<S: ::std::hash::BuildHasher>(_map: &mut HashMap<i32, i
    |                     +++++++++++++++++++++++++++++            ~~~~~~~~~~~~~~~~~~~~
 
 error: parameter of type `HashSet` should be generalized over different hashers
-  --> $DIR/implicit_hasher.rs:81:63
+  --> $DIR/implicit_hasher.rs:82:63
    |
 LL |         pub fn $name(_map: &mut HashMap<i32, i32>, _set: &mut HashSet<i32>) {}
    |                                                               ^^^^^^^^^^^^
@@ -149,5 +149,16 @@ help: consider adding a type parameter
 LL |         pub fn $name<S: ::std::hash::BuildHasher>(_map: &mut HashMap<i32, i32>, _set: &mut HashSet<i32, S>) {}
    |                     +++++++++++++++++++++++++++++                                          ~~~~~~~~~~~~~~~
 
-error: aborting due to 10 previous errors
+error: parameter of type `HashMap` should be generalized over different hashers
+  --> $DIR/implicit_hasher.rs:101:35
+   |
+LL | pub async fn election_vote(_data: HashMap<i32, i32>) {}
+   |                                   ^^^^^^^^^^^^^^^^^
+   |
+help: consider adding a type parameter
+   |
+LL | pub async fn election_vote<S: ::std::hash::BuildHasher>(_data: HashMap<i32, i32, S>) {}
+   |                           +++++++++++++++++++++++++++++        ~~~~~~~~~~~~~~~~~~~~
+
+error: aborting due to 11 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 388a3d098358edd1f7b83f1f47f1e1e157bad067 Mon Sep 17 00:00:00 2001
From: hkalbasi <hamidrezakalbasi@protonmail.com>
Date: Mon, 4 Oct 2021 10:03:40 +0330
Subject: Implement equatable if let lint

---
 CHANGELOG.md                                       |   1 +
 clippy_lints/src/attrs.rs                          |   2 +-
 clippy_lints/src/casts/cast_precision_loss.rs      |   2 +-
 clippy_lints/src/derive.rs                         |   4 +-
 clippy_lints/src/equatable_if_let.rs               | 100 +++++++++++++++++++++
 clippy_lints/src/erasing_op.rs                     |   2 +-
 clippy_lints/src/escape.rs                         |   2 +-
 clippy_lints/src/eta_reduction.rs                  |   2 +-
 clippy_lints/src/eval_order_dependence.rs          |   2 +-
 clippy_lints/src/identity_op.rs                    |  14 +--
 clippy_lints/src/integer_division.rs               |   2 +-
 clippy_lints/src/len_zero.rs                       |  12 +--
 clippy_lints/src/lib.mods.rs                       |   1 +
 clippy_lints/src/lib.register_lints.rs             |   1 +
 clippy_lints/src/lib.register_nursery.rs           |   1 +
 clippy_lints/src/lib.rs                            |   1 +
 clippy_lints/src/loops/mut_range_bound.rs          |   2 +-
 clippy_lints/src/loops/needless_range_loop.rs      |   2 +-
 clippy_lints/src/loops/never_loop.rs               |   2 +-
 clippy_lints/src/manual_async_fn.rs                |   4 +-
 clippy_lints/src/methods/or_fun_call.rs            |  14 +--
 clippy_lints/src/modulo_arithmetic.rs              |   2 +-
 clippy_lints/src/needless_bool.rs                  |   2 +-
 clippy_lints/src/neg_multiply.rs                   |   2 +-
 clippy_lints/src/new_without_default.rs            |   2 +-
 clippy_lints/src/non_send_fields_in_send_ty.rs     |   2 +-
 clippy_lints/src/overflow_check_conditional.rs     |  31 +++----
 clippy_lints/src/redundant_pub_crate.rs            |  36 ++++----
 clippy_lints/src/repeat_once.rs                    |   2 +-
 clippy_lints/src/transmuting_null.rs               |   4 +-
 clippy_lints/src/zero_div_zero.rs                  |   2 +-
 clippy_utils/src/lib.rs                            |   2 +-
 clippy_utils/src/numeric_literal.rs                |   4 +-
 clippy_utils/src/sugg.rs                           |   2 +-
 clippy_utils/src/usage.rs                          |   2 +-
 tests/ui/branches_sharing_code/shared_at_bottom.rs |   2 +-
 tests/ui/collapsible_else_if.fixed                 |   2 +-
 tests/ui/collapsible_else_if.rs                    |   2 +-
 tests/ui/collapsible_if.fixed                      |   2 +-
 tests/ui/collapsible_if.rs                         |   2 +-
 tests/ui/collapsible_match.rs                      |   7 +-
 tests/ui/collapsible_match.stderr                  |  40 ++++-----
 tests/ui/crashes/ice-3462.rs                       |   2 +-
 tests/ui/equatable_if_let.fixed                    |  69 ++++++++++++++
 tests/ui/equatable_if_let.rs                       |  69 ++++++++++++++
 tests/ui/equatable_if_let.stderr                   |  64 +++++++++++++
 tests/ui/if_same_then_else2.rs                     |   1 +
 tests/ui/if_same_then_else2.stderr                 |  24 ++---
 tests/ui/match_expr_like_matches_macro.fixed       |   2 +-
 tests/ui/match_expr_like_matches_macro.rs          |   2 +-
 tests/ui/match_overlapping_arm.rs                  |   2 +-
 tests/ui/match_ref_pats.rs                         |   1 +
 tests/ui/match_ref_pats.stderr                     |  16 ++--
 tests/ui/needless_bool/fixable.fixed               |   1 +
 tests/ui/needless_bool/fixable.rs                  |   1 +
 tests/ui/needless_bool/fixable.stderr              |  24 ++---
 tests/ui/needless_return.fixed                     |   7 +-
 tests/ui/needless_return.rs                        |   7 +-
 tests/ui/needless_return.stderr                    |  64 ++++++-------
 tests/ui/option_if_let_else.fixed                  |   2 +-
 tests/ui/option_if_let_else.rs                     |   2 +-
 .../ui/redundant_pattern_matching_drop_order.fixed |   2 +-
 tests/ui/redundant_pattern_matching_drop_order.rs  |   2 +-
 tests/ui/redundant_pattern_matching_option.fixed   |   1 +
 tests/ui/redundant_pattern_matching_option.rs      |   1 +
 tests/ui/redundant_pattern_matching_option.stderr  |  38 ++++----
 tests/ui/redundant_pattern_matching_poll.fixed     |   1 +
 tests/ui/redundant_pattern_matching_poll.rs        |   1 +
 tests/ui/redundant_pattern_matching_poll.stderr    |  36 ++++----
 tests/ui/while_let_on_iterator.fixed               |   8 +-
 tests/ui/while_let_on_iterator.rs                  |   8 +-
 tests/ui/while_let_on_iterator.stderr              |  42 ++++-----
 72 files changed, 572 insertions(+), 253 deletions(-)
 create mode 100644 clippy_lints/src/equatable_if_let.rs
 create mode 100644 tests/ui/equatable_if_let.fixed
 create mode 100644 tests/ui/equatable_if_let.rs
 create mode 100644 tests/ui/equatable_if_let.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9a4424f5061..7fdb300c977 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2695,6 +2695,7 @@ Released 2018-09-13
 [`enum_glob_use`]: https://rust-lang.github.io/rust-clippy/master/index.html#enum_glob_use
 [`enum_variant_names`]: https://rust-lang.github.io/rust-clippy/master/index.html#enum_variant_names
 [`eq_op`]: https://rust-lang.github.io/rust-clippy/master/index.html#eq_op
+[`equatable_if_let`]: https://rust-lang.github.io/rust-clippy/master/index.html#equatable_if_let
 [`erasing_op`]: https://rust-lang.github.io/rust-clippy/master/index.html#erasing_op
 [`eval_order_dependence`]: https://rust-lang.github.io/rust-clippy/master/index.html#eval_order_dependence
 [`excessive_precision`]: https://rust-lang.github.io/rust-clippy/master/index.html#excessive_precision
diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs
index 2ef7dcc1775..6f8b645dd70 100644
--- a/clippy_lints/src/attrs.rs
+++ b/clippy_lints/src/attrs.rs
@@ -563,7 +563,7 @@ fn check_deprecated_cfg_attr(cx: &EarlyContext<'_>, attr: &Attribute) {
             skip_item.path.segments.last().expect("empty path in attribute").ident.name == sym::skip;
         // Only lint outer attributes, because custom inner attributes are unstable
         // Tracking issue: https://github.com/rust-lang/rust/issues/54726
-        if let AttrStyle::Outer = attr.style;
+        if attr.style == AttrStyle::Outer;
         then {
             span_lint_and_sugg(
                 cx,
diff --git a/clippy_lints/src/casts/cast_precision_loss.rs b/clippy_lints/src/casts/cast_precision_loss.rs
index 63ac8fd2dd2..334e1646cd4 100644
--- a/clippy_lints/src/casts/cast_precision_loss.rs
+++ b/clippy_lints/src/casts/cast_precision_loss.rs
@@ -12,7 +12,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_from: Ty<'_>, ca
     }
 
     let from_nbits = utils::int_ty_to_nbits(cast_from, cx.tcx);
-    let to_nbits = if let ty::Float(FloatTy::F32) = cast_to.kind() {
+    let to_nbits = if cast_to.kind() == &ty::Float(FloatTy::F32) {
         32
     } else {
         64
diff --git a/clippy_lints/src/derive.rs b/clippy_lints/src/derive.rs
index 8416b8440df..24ac5917dcb 100644
--- a/clippy_lints/src/derive.rs
+++ b/clippy_lints/src/derive.rs
@@ -393,7 +393,7 @@ impl<'tcx> Visitor<'tcx> for UnsafeVisitor<'_, 'tcx> {
 
         if_chain! {
             if let Some(header) = kind.header();
-            if let Unsafety::Unsafe = header.unsafety;
+            if header.unsafety == Unsafety::Unsafe;
             then {
                 self.has_unsafe = true;
             }
@@ -408,7 +408,7 @@ impl<'tcx> Visitor<'tcx> for UnsafeVisitor<'_, 'tcx> {
         }
 
         if let ExprKind::Block(block, _) = expr.kind {
-            if let BlockCheckMode::UnsafeBlock(UnsafeSource::UserProvided) = block.rules {
+            if block.rules == BlockCheckMode::UnsafeBlock(UnsafeSource::UserProvided) {
                 self.has_unsafe = true;
             }
         }
diff --git a/clippy_lints/src/equatable_if_let.rs b/clippy_lints/src/equatable_if_let.rs
new file mode 100644
index 00000000000..0c6ba91c943
--- /dev/null
+++ b/clippy_lints/src/equatable_if_let.rs
@@ -0,0 +1,100 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::ty::implements_trait;
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind, Pat, PatKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::Ty;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for pattern matchings that can be expressed using equality.
+    ///
+    /// ### Why is this bad?
+    ///
+    /// * It reads better and has less cognitive load because equality won't cause binding.
+    /// * It is a [Yoda condition](https://en.wikipedia.org/wiki/Yoda_conditions). Yoda conditions are widely
+    /// criticized for increasing the cognitive load of reading the code.
+    /// * Equality is a simple bool expression and can be merged with `&&` and `||` and
+    /// reuse if blocks
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// if let Some(2) = x {
+    ///     do_thing();
+    /// }
+    /// ```
+    /// Should be written
+    /// ```rust,ignore
+    /// if x == Some(2) {
+    ///     do_thing();
+    /// }
+    /// ```
+    pub EQUATABLE_IF_LET,
+    nursery,
+    "using pattern matching instead of equality"
+}
+
+declare_lint_pass!(PatternEquality => [EQUATABLE_IF_LET]);
+
+/// detects if pattern matches just one thing
+fn unary_pattern(pat: &Pat<'_>) -> bool {
+    fn array_rec(pats: &[Pat<'_>]) -> bool {
+        pats.iter().all(unary_pattern)
+    }
+    match &pat.kind {
+        PatKind::Slice(_, _, _) | PatKind::Range(_, _, _) | PatKind::Binding(..) | PatKind::Wild | PatKind::Or(_) => {
+            false
+        },
+        PatKind::Struct(_, a, etc) => !etc && a.iter().all(|x| unary_pattern(x.pat)),
+        PatKind::Tuple(a, etc) | PatKind::TupleStruct(_, a, etc) => !etc.is_some() && array_rec(a),
+        PatKind::Ref(x, _) | PatKind::Box(x) => unary_pattern(x),
+        PatKind::Path(_) | PatKind::Lit(_) => true,
+    }
+}
+
+fn is_structural_partial_eq(cx: &LateContext<'tcx>, ty: Ty<'tcx>, other: Ty<'tcx>) -> bool {
+    if let Some(def_id) = cx.tcx.lang_items().eq_trait() {
+        implements_trait(cx, ty, def_id, &[other.into()])
+    } else {
+        false
+    }
+}
+
+impl<'tcx> LateLintPass<'tcx> for PatternEquality {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
+        if_chain! {
+            if let ExprKind::Let(pat, exp, _) = expr.kind;
+            if unary_pattern(pat);
+            let exp_ty = cx.typeck_results().expr_ty(exp);
+            let pat_ty = cx.typeck_results().pat_ty(pat);
+            if is_structural_partial_eq(cx, exp_ty, pat_ty);
+            then {
+
+                let mut applicability = Applicability::MachineApplicable;
+                let pat_str = match pat.kind {
+                    PatKind::Struct(..) => format!(
+                        "({})",
+                        snippet_with_applicability(cx, pat.span, "..", &mut applicability),
+                    ),
+                    _ => snippet_with_applicability(cx, pat.span, "..", &mut applicability).to_string(),
+                };
+                span_lint_and_sugg(
+                    cx,
+                    EQUATABLE_IF_LET,
+                    expr.span,
+                    "this pattern matching can be expressed using equality",
+                    "try",
+                    format!(
+                        "{} == {}",
+                        snippet_with_applicability(cx, exp.span, "..", &mut applicability),
+                        pat_str,
+                    ),
+                    applicability,
+                );
+            }
+        }
+    }
+}
diff --git a/clippy_lints/src/erasing_op.rs b/clippy_lints/src/erasing_op.rs
index 026d14d0ea2..d0944c37cf5 100644
--- a/clippy_lints/src/erasing_op.rs
+++ b/clippy_lints/src/erasing_op.rs
@@ -47,7 +47,7 @@ impl<'tcx> LateLintPass<'tcx> for ErasingOp {
 }
 
 fn check(cx: &LateContext<'_>, e: &Expr<'_>, span: Span) {
-    if let Some(Constant::Int(0)) = constant_simple(cx, cx.typeck_results(), e) {
+    if constant_simple(cx, cx.typeck_results(), e) == Some(Constant::Int(0)) {
         span_lint(
             cx,
             ERASING_OP,
diff --git a/clippy_lints/src/escape.rs b/clippy_lints/src/escape.rs
index 090be73af3b..75b1c882c23 100644
--- a/clippy_lints/src/escape.rs
+++ b/clippy_lints/src/escape.rs
@@ -90,7 +90,7 @@ impl<'tcx> LateLintPass<'tcx> for BoxedLocal {
                 for trait_item in items {
                     if trait_item.id.hir_id() == hir_id {
                         // be sure we have `self` parameter in this function
-                        if let AssocItemKind::Fn { has_self: true } = trait_item.kind {
+                        if trait_item.kind == (AssocItemKind::Fn { has_self: true }) {
                             trait_self_ty = Some(
                                 TraitRef::identity(cx.tcx, trait_item.id.def_id.to_def_id())
                                     .self_ty()
diff --git a/clippy_lints/src/eta_reduction.rs b/clippy_lints/src/eta_reduction.rs
index 9df92cc5b64..765a6c7585a 100644
--- a/clippy_lints/src/eta_reduction.rs
+++ b/clippy_lints/src/eta_reduction.rs
@@ -116,7 +116,7 @@ impl<'tcx> LateLintPass<'tcx> for EtaReduction {
                     if let Some(mut snippet) = snippet_opt(cx, callee.span) {
                         if_chain! {
                             if let ty::Closure(_, substs) = callee_ty.peel_refs().kind();
-                            if let ClosureKind::FnMut = substs.as_closure().kind();
+                            if substs.as_closure().kind() == ClosureKind::FnMut;
                             if get_enclosing_loop_or_closure(cx.tcx, expr).is_some()
                                 || UsedAfterExprVisitor::is_found(cx, callee);
 
diff --git a/clippy_lints/src/eval_order_dependence.rs b/clippy_lints/src/eval_order_dependence.rs
index 8714ce90164..1b56dd4b081 100644
--- a/clippy_lints/src/eval_order_dependence.rs
+++ b/clippy_lints/src/eval_order_dependence.rs
@@ -141,7 +141,7 @@ impl<'a, 'tcx> Visitor<'tcx> for DivergenceVisitor<'a, 'tcx> {
                 match typ.kind() {
                     ty::FnDef(..) | ty::FnPtr(_) => {
                         let sig = typ.fn_sig(self.cx.tcx);
-                        if let ty::Never = self.cx.tcx.erase_late_bound_regions(sig).output().kind() {
+                        if self.cx.tcx.erase_late_bound_regions(sig).output().kind() == &ty::Never {
                             self.report_diverging_sub_expr(e);
                         }
                     },
diff --git a/clippy_lints/src/identity_op.rs b/clippy_lints/src/identity_op.rs
index 5feb0ce8dec..73bdd67ff5d 100644
--- a/clippy_lints/src/identity_op.rs
+++ b/clippy_lints/src/identity_op.rs
@@ -1,5 +1,4 @@
 use clippy_utils::source::snippet;
-use if_chain::if_chain;
 use rustc_hir::{BinOp, BinOpKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
@@ -62,16 +61,9 @@ impl<'tcx> LateLintPass<'tcx> for IdentityOp {
 
 fn is_allowed(cx: &LateContext<'_>, cmp: BinOp, left: &Expr<'_>, right: &Expr<'_>) -> bool {
     // `1 << 0` is a common pattern in bit manipulation code
-    if_chain! {
-        if let BinOpKind::Shl = cmp.node;
-        if let Some(Constant::Int(0)) = constant_simple(cx, cx.typeck_results(), right);
-        if let Some(Constant::Int(1)) = constant_simple(cx, cx.typeck_results(), left);
-        then {
-            return true;
-        }
-    }
-
-    false
+    cmp.node == BinOpKind::Shl
+        && constant_simple(cx, cx.typeck_results(), right) == Some(Constant::Int(0))
+        && constant_simple(cx, cx.typeck_results(), left) == Some(Constant::Int(1))
 }
 
 #[allow(clippy::cast_possible_wrap)]
diff --git a/clippy_lints/src/integer_division.rs b/clippy_lints/src/integer_division.rs
index a0e6f12b812..c962e814fa5 100644
--- a/clippy_lints/src/integer_division.rs
+++ b/clippy_lints/src/integer_division.rs
@@ -48,7 +48,7 @@ impl<'tcx> LateLintPass<'tcx> for IntegerDivision {
 fn is_integer_division<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) -> bool {
     if_chain! {
         if let hir::ExprKind::Binary(binop, left, right) = &expr.kind;
-        if let hir::BinOpKind::Div = &binop.node;
+        if binop.node == hir::BinOpKind::Div;
         then {
             let (left_ty, right_ty) = (cx.typeck_results().expr_ty(left), cx.typeck_results().expr_ty(right));
             return left_ty.is_integral() && right_ty.is_integral();
diff --git a/clippy_lints/src/len_zero.rs b/clippy_lints/src/len_zero.rs
index a519ad90df5..1811f739421 100644
--- a/clippy_lints/src/len_zero.rs
+++ b/clippy_lints/src/len_zero.rs
@@ -455,14 +455,10 @@ fn is_empty_array(expr: &Expr<'_>) -> bool {
 fn has_is_empty(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
     /// Gets an `AssocItem` and return true if it matches `is_empty(self)`.
     fn is_is_empty(cx: &LateContext<'_>, item: &ty::AssocItem) -> bool {
-        if let ty::AssocKind::Fn = item.kind {
-            if item.ident.name.as_str() == "is_empty" {
-                let sig = cx.tcx.fn_sig(item.def_id);
-                let ty = sig.skip_binder();
-                ty.inputs().len() == 1
-            } else {
-                false
-            }
+        if item.kind == ty::AssocKind::Fn && item.ident.name.as_str() == "is_empty" {
+            let sig = cx.tcx.fn_sig(item.def_id);
+            let ty = sig.skip_binder();
+            ty.inputs().len() == 1
         } else {
             false
         }
diff --git a/clippy_lints/src/lib.mods.rs b/clippy_lints/src/lib.mods.rs
index 7fd84783c22..8e899553e69 100644
--- a/clippy_lints/src/lib.mods.rs
+++ b/clippy_lints/src/lib.mods.rs
@@ -49,6 +49,7 @@ mod entry;
 mod enum_clike;
 mod enum_variants;
 mod eq_op;
+mod equatable_if_let;
 mod erasing_op;
 mod escape;
 mod eta_reduction;
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 28d54246fbb..2ba2b3da55c 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -116,6 +116,7 @@ store.register_lints(&[
     enum_variants::MODULE_NAME_REPETITIONS,
     eq_op::EQ_OP,
     eq_op::OP_REF,
+    equatable_if_let::EQUATABLE_IF_LET,
     erasing_op::ERASING_OP,
     escape::BOXED_LOCAL,
     eta_reduction::REDUNDANT_CLOSURE,
diff --git a/clippy_lints/src/lib.register_nursery.rs b/clippy_lints/src/lib.register_nursery.rs
index 32606e570d8..96e0b421094 100644
--- a/clippy_lints/src/lib.register_nursery.rs
+++ b/clippy_lints/src/lib.register_nursery.rs
@@ -8,6 +8,7 @@ store.register_group(true, "clippy::nursery", Some("clippy_nursery"), vec![
     LintId::of(copies::BRANCHES_SHARING_CODE),
     LintId::of(disallowed_method::DISALLOWED_METHOD),
     LintId::of(disallowed_type::DISALLOWED_TYPE),
+    LintId::of(equatable_if_let::EQUATABLE_IF_LET),
     LintId::of(fallible_impl_from::FALLIBLE_IMPL_FROM),
     LintId::of(floating_point_arithmetic::IMPRECISE_FLOPS),
     LintId::of(floating_point_arithmetic::SUBOPTIMAL_FLOPS),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index c3be6db6ffa..04128c8a0cc 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -485,6 +485,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(option_if_let_else::OptionIfLetElse));
     store.register_late_pass(|| Box::new(future_not_send::FutureNotSend));
     store.register_late_pass(|| Box::new(if_let_mutex::IfLetMutex));
+    store.register_late_pass(|| Box::new(equatable_if_let::PatternEquality));
     store.register_late_pass(|| Box::new(mut_mutex_lock::MutMutexLock));
     store.register_late_pass(|| Box::new(match_on_vec_items::MatchOnVecItems));
     store.register_late_pass(|| Box::new(manual_async_fn::ManualAsyncFn));
diff --git a/clippy_lints/src/loops/mut_range_bound.rs b/clippy_lints/src/loops/mut_range_bound.rs
index 358d53e8859..aedf0844937 100644
--- a/clippy_lints/src/loops/mut_range_bound.rs
+++ b/clippy_lints/src/loops/mut_range_bound.rs
@@ -92,7 +92,7 @@ impl<'tcx> Delegate<'tcx> for MutatePairDelegate<'_, 'tcx> {
     fn consume(&mut self, _: &PlaceWithHirId<'tcx>, _: HirId) {}
 
     fn borrow(&mut self, cmt: &PlaceWithHirId<'tcx>, diag_expr_id: HirId, bk: ty::BorrowKind) {
-        if let ty::BorrowKind::MutBorrow = bk {
+        if bk == ty::BorrowKind::MutBorrow {
             if let PlaceBase::Local(id) = cmt.place.base {
                 if Some(id) == self.hir_id_low && !BreakAfterExprVisitor::is_found(self.cx, diag_expr_id) {
                     self.span_low = Some(self.cx.tcx.hir().span(diag_expr_id));
diff --git a/clippy_lints/src/loops/needless_range_loop.rs b/clippy_lints/src/loops/needless_range_loop.rs
index 7157b801185..172d9fc39a2 100644
--- a/clippy_lints/src/loops/needless_range_loop.rs
+++ b/clippy_lints/src/loops/needless_range_loop.rs
@@ -95,7 +95,7 @@ pub(super) fn check<'tcx>(
                     let mut take_expr = end;
 
                     if let ExprKind::Binary(ref op, left, right) = end.kind {
-                        if let BinOpKind::Add = op.node {
+                        if op.node == BinOpKind::Add {
                             let start_equal_left = SpanlessEq::new(cx).eq_expr(start, left);
                             let start_equal_right = SpanlessEq::new(cx).eq_expr(start, right);
 
diff --git a/clippy_lints/src/loops/never_loop.rs b/clippy_lints/src/loops/never_loop.rs
index 41956650c9f..c0fde5e5166 100644
--- a/clippy_lints/src/loops/never_loop.rs
+++ b/clippy_lints/src/loops/never_loop.rs
@@ -14,7 +14,7 @@ pub(super) fn check(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
             NeverLoopResult::AlwaysBreak => {
                 span_lint_and_then(cx, NEVER_LOOP, expr.span, "this loop never actually loops", |diag| {
                     if_chain! {
-                        if let LoopSource::ForLoop = source;
+                        if source == LoopSource::ForLoop;
                         if let Some((_, Node::Expr(parent_match))) = cx.tcx.hir().parent_iter(expr.hir_id).nth(1);
                         if let Some(ForLoop { arg: iterator, pat, span: for_span, .. }) = ForLoop::hir(parent_match);
                         then {
diff --git a/clippy_lints/src/manual_async_fn.rs b/clippy_lints/src/manual_async_fn.rs
index 8e1385fb83a..b632af455f8 100644
--- a/clippy_lints/src/manual_async_fn.rs
+++ b/clippy_lints/src/manual_async_fn.rs
@@ -49,7 +49,7 @@ impl<'tcx> LateLintPass<'tcx> for ManualAsyncFn {
     ) {
         if_chain! {
             if let Some(header) = kind.header();
-            if let IsAsync::NotAsync = header.asyncness;
+            if header.asyncness == IsAsync::NotAsync;
             // Check that this function returns `impl Future`
             if let FnRetTy::Return(ret_ty) = decl.output;
             if let Some((trait_ref, output_lifetimes)) = future_trait_ref(cx, ret_ty);
@@ -178,7 +178,7 @@ fn desugared_async_block<'tcx>(cx: &LateContext<'tcx>, block: &'tcx Block<'tcx>)
         if args.len() == 1;
         if let Expr{kind: ExprKind::Closure(_, _, body_id, ..), ..} = args[0];
         let closure_body = cx.tcx.hir().body(body_id);
-        if let Some(GeneratorKind::Async(AsyncGeneratorKind::Block)) = closure_body.generator_kind;
+        if closure_body.generator_kind == Some(GeneratorKind::Async(AsyncGeneratorKind::Block));
         then {
             return Some(closure_body);
         }
diff --git a/clippy_lints/src/methods/or_fun_call.rs b/clippy_lints/src/methods/or_fun_call.rs
index 30ed1d665a9..a4d3f0bfb6c 100644
--- a/clippy_lints/src/methods/or_fun_call.rs
+++ b/clippy_lints/src/methods/or_fun_call.rs
@@ -178,15 +178,15 @@ pub(super) fn check<'tcx>(
             hir::ExprKind::Index(..) | hir::ExprKind::MethodCall(..) => {
                 check_general_case(cx, name, method_span, &args[0], &args[1], expr.span, None);
             },
-            hir::ExprKind::Block(block, _) => {
-                if let BlockCheckMode::UnsafeBlock(UnsafeSource::UserProvided) = block.rules {
-                    if let Some(block_expr) = block.expr {
-                        if let hir::ExprKind::MethodCall(..) = block_expr.kind {
-                            check_general_case(cx, name, method_span, &args[0], &args[1], expr.span, None);
-                        }
+            hir::ExprKind::Block(block, _)
+                if block.rules == BlockCheckMode::UnsafeBlock(UnsafeSource::UserProvided) =>
+            {
+                if let Some(block_expr) = block.expr {
+                    if let hir::ExprKind::MethodCall(..) = block_expr.kind {
+                        check_general_case(cx, name, method_span, &args[0], &args[1], expr.span, None);
                     }
                 }
-            },
+            }
             _ => (),
         }
     }
diff --git a/clippy_lints/src/modulo_arithmetic.rs b/clippy_lints/src/modulo_arithmetic.rs
index 2d14943b56c..f45e68233a1 100644
--- a/clippy_lints/src/modulo_arithmetic.rs
+++ b/clippy_lints/src/modulo_arithmetic.rs
@@ -128,7 +128,7 @@ impl<'tcx> LateLintPass<'tcx> for ModuloArithmetic {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         match &expr.kind {
             ExprKind::Binary(op, lhs, rhs) | ExprKind::AssignOp(op, lhs, rhs) => {
-                if let BinOpKind::Rem = op.node {
+                if op.node == BinOpKind::Rem {
                     let lhs_operand = analyze_operand(lhs, cx, expr);
                     let rhs_operand = analyze_operand(rhs, cx, expr);
                     if_chain! {
diff --git a/clippy_lints/src/needless_bool.rs b/clippy_lints/src/needless_bool.rs
index c9dd94400ef..91944653500 100644
--- a/clippy_lints/src/needless_bool.rs
+++ b/clippy_lints/src/needless_bool.rs
@@ -248,7 +248,7 @@ fn check_comparison<'a, 'tcx>(
         if l_ty.is_bool() && r_ty.is_bool() {
             let mut applicability = Applicability::MachineApplicable;
 
-            if let BinOpKind::Eq = op.node {
+            if op.node == BinOpKind::Eq {
                 let expression_info = one_side_is_unary_not(left_side, right_side);
                 if expression_info.one_side_is_unary_not {
                     span_lint_and_sugg(
diff --git a/clippy_lints/src/neg_multiply.rs b/clippy_lints/src/neg_multiply.rs
index fa36d8fb1b3..1b15d29439f 100644
--- a/clippy_lints/src/neg_multiply.rs
+++ b/clippy_lints/src/neg_multiply.rs
@@ -46,7 +46,7 @@ impl<'tcx> LateLintPass<'tcx> for NegMultiply {
 fn check_mul(cx: &LateContext<'_>, span: Span, lit: &Expr<'_>, exp: &Expr<'_>) {
     if_chain! {
         if let ExprKind::Lit(ref l) = lit.kind;
-        if let Constant::Int(1) = consts::lit_to_constant(&l.node, cx.typeck_results().expr_ty_opt(lit));
+        if consts::lit_to_constant(&l.node, cx.typeck_results().expr_ty_opt(lit)) == Constant::Int(1);
         if cx.typeck_results().expr_ty(exp).is_integral();
         then {
             span_lint(cx, NEG_MULTIPLY, span, "negation by multiplying with `-1`");
diff --git a/clippy_lints/src/new_without_default.rs b/clippy_lints/src/new_without_default.rs
index 0ad616a39d2..0ac27f1cba2 100644
--- a/clippy_lints/src/new_without_default.rs
+++ b/clippy_lints/src/new_without_default.rs
@@ -69,7 +69,7 @@ impl<'tcx> LateLintPass<'tcx> for NewWithoutDefault {
         }) = item.kind
         {
             for assoc_item in items {
-                if let hir::AssocItemKind::Fn { has_self: false } = assoc_item.kind {
+                if assoc_item.kind == (hir::AssocItemKind::Fn { has_self: false }) {
                     let impl_item = cx.tcx.hir().impl_item(assoc_item.id);
                     if in_external_macro(cx.sess(), impl_item.span) {
                         return;
diff --git a/clippy_lints/src/non_send_fields_in_send_ty.rs b/clippy_lints/src/non_send_fields_in_send_ty.rs
index 0dbf296c714..0973e3a1768 100644
--- a/clippy_lints/src/non_send_fields_in_send_ty.rs
+++ b/clippy_lints/src/non_send_fields_in_send_ty.rs
@@ -81,7 +81,7 @@ impl<'tcx> LateLintPass<'tcx> for NonSendFieldInSendTy {
             if let Some(trait_ref) = &hir_impl.of_trait;
             if let Some(trait_id) = trait_ref.trait_def_id();
             if send_trait == trait_id;
-            if let ImplPolarity::Positive = hir_impl.polarity;
+            if hir_impl.polarity == ImplPolarity::Positive;
             if let Some(ty_trait_ref) = cx.tcx.impl_trait_ref(item.def_id);
             if let self_ty = ty_trait_ref.self_ty();
             if let ty::Adt(adt_def, impl_trait_substs) = self_ty.kind();
diff --git a/clippy_lints/src/overflow_check_conditional.rs b/clippy_lints/src/overflow_check_conditional.rs
index 34755afdb72..0f9e5ada3a8 100644
--- a/clippy_lints/src/overflow_check_conditional.rs
+++ b/clippy_lints/src/overflow_check_conditional.rs
@@ -26,6 +26,9 @@ declare_clippy_lint! {
 
 declare_lint_pass!(OverflowCheckConditional => [OVERFLOW_CHECK_CONDITIONAL]);
 
+const OVERFLOW_MSG: &str = "you are trying to use classic C overflow conditions that will fail in Rust";
+const UNDERFLOW_MSG: &str = "you are trying to use classic C underflow conditions that will fail in Rust";
+
 impl<'tcx> LateLintPass<'tcx> for OverflowCheckConditional {
     // a + b < a, a > a + b, a < a - b, a - b > a
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
@@ -40,17 +43,11 @@ impl<'tcx> LateLintPass<'tcx> for OverflowCheckConditional {
             if cx.typeck_results().expr_ty(ident1).is_integral();
             if cx.typeck_results().expr_ty(ident2).is_integral();
             then {
-                if let BinOpKind::Lt = op.node {
-                    if let BinOpKind::Add = op2.node {
-                        span_lint(cx, OVERFLOW_CHECK_CONDITIONAL, expr.span,
-                            "you are trying to use classic C overflow conditions that will fail in Rust");
-                    }
+                if op.node == BinOpKind::Lt && op2.node == BinOpKind::Add {
+                    span_lint(cx, OVERFLOW_CHECK_CONDITIONAL, expr.span, OVERFLOW_MSG);
                 }
-                if let BinOpKind::Gt = op.node {
-                    if let BinOpKind::Sub = op2.node {
-                        span_lint(cx, OVERFLOW_CHECK_CONDITIONAL, expr.span,
-                            "you are trying to use classic C underflow conditions that will fail in Rust");
-                    }
+                if op.node == BinOpKind::Gt && op2.node == BinOpKind::Sub {
+                    span_lint(cx, OVERFLOW_CHECK_CONDITIONAL, expr.span, UNDERFLOW_MSG);
                 }
             }
         }
@@ -65,17 +62,11 @@ impl<'tcx> LateLintPass<'tcx> for OverflowCheckConditional {
             if cx.typeck_results().expr_ty(ident1).is_integral();
             if cx.typeck_results().expr_ty(ident2).is_integral();
             then {
-                if let BinOpKind::Gt = op.node {
-                    if let BinOpKind::Add = op2.node {
-                        span_lint(cx, OVERFLOW_CHECK_CONDITIONAL, expr.span,
-                            "you are trying to use classic C overflow conditions that will fail in Rust");
-                    }
+                if op.node == BinOpKind::Gt && op2.node == BinOpKind::Add {
+                    span_lint(cx, OVERFLOW_CHECK_CONDITIONAL, expr.span, OVERFLOW_MSG);
                 }
-                if let BinOpKind::Lt = op.node {
-                    if let BinOpKind::Sub = op2.node {
-                        span_lint(cx, OVERFLOW_CHECK_CONDITIONAL, expr.span,
-                            "you are trying to use classic C underflow conditions that will fail in Rust");
-                    }
+                if op.node == BinOpKind::Lt && op2.node == BinOpKind::Sub {
+                    span_lint(cx, OVERFLOW_CHECK_CONDITIONAL, expr.span, UNDERFLOW_MSG);
                 }
             }
         }
diff --git a/clippy_lints/src/redundant_pub_crate.rs b/clippy_lints/src/redundant_pub_crate.rs
index ed2e1f90fa5..919d4e11e5a 100644
--- a/clippy_lints/src/redundant_pub_crate.rs
+++ b/clippy_lints/src/redundant_pub_crate.rs
@@ -41,25 +41,23 @@ impl_lint_pass!(RedundantPubCrate => [REDUNDANT_PUB_CRATE]);
 impl<'tcx> LateLintPass<'tcx> for RedundantPubCrate {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
         if let VisibilityKind::Crate { .. } = item.vis.node {
-            if !cx.access_levels.is_exported(item.def_id) {
-                if let Some(false) = self.is_exported.last() {
-                    let span = item.span.with_hi(item.ident.span.hi());
-                    let descr = cx.tcx.def_kind(item.def_id).descr(item.def_id.to_def_id());
-                    span_lint_and_then(
-                        cx,
-                        REDUNDANT_PUB_CRATE,
-                        span,
-                        &format!("pub(crate) {} inside private module", descr),
-                        |diag| {
-                            diag.span_suggestion(
-                                item.vis.span,
-                                "consider using",
-                                "pub".to_string(),
-                                Applicability::MachineApplicable,
-                            );
-                        },
-                    );
-                }
+            if !cx.access_levels.is_exported(item.def_id) && self.is_exported.last() == Some(&false) {
+                let span = item.span.with_hi(item.ident.span.hi());
+                let descr = cx.tcx.def_kind(item.def_id).descr(item.def_id.to_def_id());
+                span_lint_and_then(
+                    cx,
+                    REDUNDANT_PUB_CRATE,
+                    span,
+                    &format!("pub(crate) {} inside private module", descr),
+                    |diag| {
+                        diag.span_suggestion(
+                            item.vis.span,
+                            "consider using",
+                            "pub".to_string(),
+                            Applicability::MachineApplicable,
+                        );
+                    },
+                );
             }
         }
 
diff --git a/clippy_lints/src/repeat_once.rs b/clippy_lints/src/repeat_once.rs
index 54b9c8b3275..710de773e9c 100644
--- a/clippy_lints/src/repeat_once.rs
+++ b/clippy_lints/src/repeat_once.rs
@@ -48,7 +48,7 @@ impl<'tcx> LateLintPass<'tcx> for RepeatOnce {
         if_chain! {
             if let ExprKind::MethodCall(path, _, [receiver, count], _) = &expr.kind;
             if path.ident.name == sym!(repeat);
-            if let Some(Constant::Int(1)) = constant_context(cx, cx.typeck_results()).expr(count);
+            if constant_context(cx, cx.typeck_results()).expr(count) == Some(Constant::Int(1));
             if !in_macro(receiver.span);
             then {
                 let ty = cx.typeck_results().expr_ty(receiver).peel_refs();
diff --git a/clippy_lints/src/transmuting_null.rs b/clippy_lints/src/transmuting_null.rs
index a67fa792205..ef80663d1da 100644
--- a/clippy_lints/src/transmuting_null.rs
+++ b/clippy_lints/src/transmuting_null.rs
@@ -49,8 +49,8 @@ impl<'tcx> LateLintPass<'tcx> for TransmutingNull {
                 let mut const_eval_context = constant_context(cx, cx.typeck_results());
                 if_chain! {
                     if let ExprKind::Path(ref _qpath) = arg.kind;
-                    let x = const_eval_context.expr(arg);
-                    if let Some(Constant::RawPtr(0)) = x;
+                    if let Some(Constant::RawPtr(x)) = const_eval_context.expr(arg);
+                    if x == 0;
                     then {
                         span_lint(cx, TRANSMUTING_NULL, expr.span, LINT_MSG)
                     }
diff --git a/clippy_lints/src/zero_div_zero.rs b/clippy_lints/src/zero_div_zero.rs
index b29ced28ac4..e0746ce4d81 100644
--- a/clippy_lints/src/zero_div_zero.rs
+++ b/clippy_lints/src/zero_div_zero.rs
@@ -32,7 +32,7 @@ impl<'tcx> LateLintPass<'tcx> for ZeroDiv {
         // check for instances of 0.0/0.0
         if_chain! {
             if let ExprKind::Binary(ref op, left, right) = expr.kind;
-            if let BinOpKind::Div = op.node;
+            if op.node == BinOpKind::Div;
             // TODO - constant_simple does not fold many operations involving floats.
             // That's probably fine for this lint - it's pretty unlikely that someone would
             // do something like 0.0/(2.0 - 2.0), but it would be nice to warn on that case too.
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 231b5b80d18..00cf8a4d077 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -1508,7 +1508,7 @@ pub fn is_try<'tcx>(cx: &LateContext<'_>, expr: &'tcx Expr<'tcx>) -> Option<&'tc
 
     if let ExprKind::Match(_, arms, ref source) = expr.kind {
         // desugared from a `?` operator
-        if let MatchSource::TryDesugar = *source {
+        if *source == MatchSource::TryDesugar {
             return Some(expr);
         }
 
diff --git a/clippy_utils/src/numeric_literal.rs b/clippy_utils/src/numeric_literal.rs
index 98f65039b7d..7ad21044d7d 100644
--- a/clippy_utils/src/numeric_literal.rs
+++ b/clippy_utils/src/numeric_literal.rs
@@ -74,7 +74,7 @@ impl<'a> NumericLiteral<'a> {
         };
 
         // Grab part of the literal after prefix, if present.
-        let (prefix, mut sans_prefix) = if let Radix::Decimal = radix {
+        let (prefix, mut sans_prefix) = if radix == Radix::Decimal {
             (None, lit)
         } else {
             let (p, s) = lit.split_at(2);
@@ -179,7 +179,7 @@ impl<'a> NumericLiteral<'a> {
 
         // The exponent may have a sign, output it early, otherwise it will be
         // treated as a digit
-        if let Some('-') = digits.clone().next() {
+        if digits.clone().next() == Some('-') {
             let _ = digits.next();
             output.push('-');
         }
diff --git a/clippy_utils/src/sugg.rs b/clippy_utils/src/sugg.rs
index ab05a0b4238..5b0efb1fd71 100644
--- a/clippy_utils/src/sugg.rs
+++ b/clippy_utils/src/sugg.rs
@@ -311,7 +311,7 @@ impl<'a> Sugg<'a> {
 /// Return `true` if `sugg` is enclosed in parenthesis.
 fn has_enclosing_paren(sugg: impl AsRef<str>) -> bool {
     let mut chars = sugg.as_ref().chars();
-    if let Some('(') = chars.next() {
+    if chars.next() == Some('(') {
         let mut depth = 1;
         for c in &mut chars {
             if c == '(' {
diff --git a/clippy_utils/src/usage.rs b/clippy_utils/src/usage.rs
index 098ec175fe2..34206b5ae2b 100644
--- a/clippy_utils/src/usage.rs
+++ b/clippy_utils/src/usage.rs
@@ -65,7 +65,7 @@ impl<'tcx> Delegate<'tcx> for MutVarsDelegate {
     fn consume(&mut self, _: &PlaceWithHirId<'tcx>, _: HirId) {}
 
     fn borrow(&mut self, cmt: &PlaceWithHirId<'tcx>, _: HirId, bk: ty::BorrowKind) {
-        if let ty::BorrowKind::MutBorrow = bk {
+        if bk == ty::BorrowKind::MutBorrow {
             self.update(cmt);
         }
     }
diff --git a/tests/ui/branches_sharing_code/shared_at_bottom.rs b/tests/ui/branches_sharing_code/shared_at_bottom.rs
index ce2040bdeb8..12f550d9c9a 100644
--- a/tests/ui/branches_sharing_code/shared_at_bottom.rs
+++ b/tests/ui/branches_sharing_code/shared_at_bottom.rs
@@ -1,4 +1,4 @@
-#![allow(dead_code)]
+#![allow(dead_code, clippy::equatable_if_let)]
 #![deny(clippy::if_same_then_else, clippy::branches_sharing_code)]
 
 // This tests the branches_sharing_code lint at the end of blocks
diff --git a/tests/ui/collapsible_else_if.fixed b/tests/ui/collapsible_else_if.fixed
index c69a46f0a77..bb6c4c0703d 100644
--- a/tests/ui/collapsible_else_if.fixed
+++ b/tests/ui/collapsible_else_if.fixed
@@ -1,5 +1,5 @@
 // run-rustfix
-#![allow(clippy::assertions_on_constants)]
+#![allow(clippy::assertions_on_constants, clippy::equatable_if_let)]
 
 #[rustfmt::skip]
 #[warn(clippy::collapsible_if)]
diff --git a/tests/ui/collapsible_else_if.rs b/tests/ui/collapsible_else_if.rs
index 1359c7eb627..6d4f688db8c 100644
--- a/tests/ui/collapsible_else_if.rs
+++ b/tests/ui/collapsible_else_if.rs
@@ -1,5 +1,5 @@
 // run-rustfix
-#![allow(clippy::assertions_on_constants)]
+#![allow(clippy::assertions_on_constants, clippy::equatable_if_let)]
 
 #[rustfmt::skip]
 #[warn(clippy::collapsible_if)]
diff --git a/tests/ui/collapsible_if.fixed b/tests/ui/collapsible_if.fixed
index e4c088bf6f0..5b0e4a473c4 100644
--- a/tests/ui/collapsible_if.fixed
+++ b/tests/ui/collapsible_if.fixed
@@ -1,5 +1,5 @@
 // run-rustfix
-#![allow(clippy::assertions_on_constants)]
+#![allow(clippy::assertions_on_constants, clippy::equatable_if_let)]
 
 #[rustfmt::skip]
 #[warn(clippy::collapsible_if)]
diff --git a/tests/ui/collapsible_if.rs b/tests/ui/collapsible_if.rs
index d6cf01c8319..cd231a5d7ab 100644
--- a/tests/ui/collapsible_if.rs
+++ b/tests/ui/collapsible_if.rs
@@ -1,5 +1,5 @@
 // run-rustfix
-#![allow(clippy::assertions_on_constants)]
+#![allow(clippy::assertions_on_constants, clippy::equatable_if_let)]
 
 #[rustfmt::skip]
 #[warn(clippy::collapsible_if)]
diff --git a/tests/ui/collapsible_match.rs b/tests/ui/collapsible_match.rs
index 4ce365cc764..603ae7dc9eb 100644
--- a/tests/ui/collapsible_match.rs
+++ b/tests/ui/collapsible_match.rs
@@ -1,5 +1,10 @@
 #![warn(clippy::collapsible_match)]
-#![allow(clippy::needless_return, clippy::no_effect, clippy::single_match)]
+#![allow(
+    clippy::needless_return,
+    clippy::no_effect,
+    clippy::single_match,
+    clippy::equatable_if_let
+)]
 
 fn lint_cases(opt_opt: Option<Option<u32>>, res_opt: Result<Option<u32>, String>) {
     // match without block
diff --git a/tests/ui/collapsible_match.stderr b/tests/ui/collapsible_match.stderr
index c119570e8ab..5f18b693502 100644
--- a/tests/ui/collapsible_match.stderr
+++ b/tests/ui/collapsible_match.stderr
@@ -1,5 +1,5 @@
 error: this `match` can be collapsed into the outer `match`
-  --> $DIR/collapsible_match.rs:7:20
+  --> $DIR/collapsible_match.rs:12:20
    |
 LL |           Ok(val) => match val {
    |  ____________________^
@@ -10,7 +10,7 @@ LL | |         },
    |
    = note: `-D clippy::collapsible-match` implied by `-D warnings`
 help: the outer pattern can be modified to include the inner pattern
-  --> $DIR/collapsible_match.rs:7:12
+  --> $DIR/collapsible_match.rs:12:12
    |
 LL |         Ok(val) => match val {
    |            ^^^ replace this binding
@@ -18,7 +18,7 @@ LL |             Some(n) => foo(n),
    |             ^^^^^^^ with this pattern
 
 error: this `match` can be collapsed into the outer `match`
-  --> $DIR/collapsible_match.rs:16:20
+  --> $DIR/collapsible_match.rs:21:20
    |
 LL |           Ok(val) => match val {
    |  ____________________^
@@ -28,7 +28,7 @@ LL | |         },
    | |_________^
    |
 help: the outer pattern can be modified to include the inner pattern
-  --> $DIR/collapsible_match.rs:16:12
+  --> $DIR/collapsible_match.rs:21:12
    |
 LL |         Ok(val) => match val {
    |            ^^^ replace this binding
@@ -36,7 +36,7 @@ LL |             Some(n) => foo(n),
    |             ^^^^^^^ with this pattern
 
 error: this `if let` can be collapsed into the outer `if let`
-  --> $DIR/collapsible_match.rs:25:9
+  --> $DIR/collapsible_match.rs:30:9
    |
 LL | /         if let Some(n) = val {
 LL | |             take(n);
@@ -44,7 +44,7 @@ LL | |         }
    | |_________^
    |
 help: the outer pattern can be modified to include the inner pattern
-  --> $DIR/collapsible_match.rs:24:15
+  --> $DIR/collapsible_match.rs:29:15
    |
 LL |     if let Ok(val) = res_opt {
    |               ^^^ replace this binding
@@ -52,7 +52,7 @@ LL |         if let Some(n) = val {
    |                ^^^^^^^ with this pattern
 
 error: this `if let` can be collapsed into the outer `if let`
-  --> $DIR/collapsible_match.rs:32:9
+  --> $DIR/collapsible_match.rs:37:9
    |
 LL | /         if let Some(n) = val {
 LL | |             take(n);
@@ -62,7 +62,7 @@ LL | |         }
    | |_________^
    |
 help: the outer pattern can be modified to include the inner pattern
-  --> $DIR/collapsible_match.rs:31:15
+  --> $DIR/collapsible_match.rs:36:15
    |
 LL |     if let Ok(val) = res_opt {
    |               ^^^ replace this binding
@@ -70,7 +70,7 @@ LL |         if let Some(n) = val {
    |                ^^^^^^^ with this pattern
 
 error: this `match` can be collapsed into the outer `if let`
-  --> $DIR/collapsible_match.rs:43:9
+  --> $DIR/collapsible_match.rs:48:9
    |
 LL | /         match val {
 LL | |             Some(n) => foo(n),
@@ -79,7 +79,7 @@ LL | |         }
    | |_________^
    |
 help: the outer pattern can be modified to include the inner pattern
-  --> $DIR/collapsible_match.rs:42:15
+  --> $DIR/collapsible_match.rs:47:15
    |
 LL |     if let Ok(val) = res_opt {
    |               ^^^ replace this binding
@@ -88,7 +88,7 @@ LL |             Some(n) => foo(n),
    |             ^^^^^^^ with this pattern
 
 error: this `if let` can be collapsed into the outer `match`
-  --> $DIR/collapsible_match.rs:52:13
+  --> $DIR/collapsible_match.rs:57:13
    |
 LL | /             if let Some(n) = val {
 LL | |                 take(n);
@@ -96,7 +96,7 @@ LL | |             }
    | |_____________^
    |
 help: the outer pattern can be modified to include the inner pattern
-  --> $DIR/collapsible_match.rs:51:12
+  --> $DIR/collapsible_match.rs:56:12
    |
 LL |         Ok(val) => {
    |            ^^^ replace this binding
@@ -104,7 +104,7 @@ LL |             if let Some(n) = val {
    |                    ^^^^^^^ with this pattern
 
 error: this `match` can be collapsed into the outer `if let`
-  --> $DIR/collapsible_match.rs:61:9
+  --> $DIR/collapsible_match.rs:66:9
    |
 LL | /         match val {
 LL | |             Some(n) => foo(n),
@@ -113,7 +113,7 @@ LL | |         }
    | |_________^
    |
 help: the outer pattern can be modified to include the inner pattern
-  --> $DIR/collapsible_match.rs:60:15
+  --> $DIR/collapsible_match.rs:65:15
    |
 LL |     if let Ok(val) = res_opt {
    |               ^^^ replace this binding
@@ -122,7 +122,7 @@ LL |             Some(n) => foo(n),
    |             ^^^^^^^ with this pattern
 
 error: this `if let` can be collapsed into the outer `match`
-  --> $DIR/collapsible_match.rs:72:13
+  --> $DIR/collapsible_match.rs:77:13
    |
 LL | /             if let Some(n) = val {
 LL | |                 take(n);
@@ -132,7 +132,7 @@ LL | |             }
    | |_____________^
    |
 help: the outer pattern can be modified to include the inner pattern
-  --> $DIR/collapsible_match.rs:71:12
+  --> $DIR/collapsible_match.rs:76:12
    |
 LL |         Ok(val) => {
    |            ^^^ replace this binding
@@ -140,7 +140,7 @@ LL |             if let Some(n) = val {
    |                    ^^^^^^^ with this pattern
 
 error: this `match` can be collapsed into the outer `match`
-  --> $DIR/collapsible_match.rs:83:20
+  --> $DIR/collapsible_match.rs:88:20
    |
 LL |           Ok(val) => match val {
    |  ____________________^
@@ -150,7 +150,7 @@ LL | |         },
    | |_________^
    |
 help: the outer pattern can be modified to include the inner pattern
-  --> $DIR/collapsible_match.rs:83:12
+  --> $DIR/collapsible_match.rs:88:12
    |
 LL |         Ok(val) => match val {
    |            ^^^ replace this binding
@@ -158,7 +158,7 @@ LL |             Some(n) => foo(n),
    |             ^^^^^^^ with this pattern
 
 error: this `match` can be collapsed into the outer `match`
-  --> $DIR/collapsible_match.rs:92:22
+  --> $DIR/collapsible_match.rs:97:22
    |
 LL |           Some(val) => match val {
    |  ______________________^
@@ -168,7 +168,7 @@ LL | |         },
    | |_________^
    |
 help: the outer pattern can be modified to include the inner pattern
-  --> $DIR/collapsible_match.rs:92:14
+  --> $DIR/collapsible_match.rs:97:14
    |
 LL |         Some(val) => match val {
    |              ^^^ replace this binding
diff --git a/tests/ui/crashes/ice-3462.rs b/tests/ui/crashes/ice-3462.rs
index 7d62e315da2..02c49aa0d7c 100644
--- a/tests/ui/crashes/ice-3462.rs
+++ b/tests/ui/crashes/ice-3462.rs
@@ -1,5 +1,5 @@
 #![warn(clippy::all)]
-#![allow(clippy::blacklisted_name)]
+#![allow(clippy::blacklisted_name, clippy::equatable_if_let)]
 #![allow(unused)]
 
 /// Test for https://github.com/rust-lang/rust-clippy/issues/3462
diff --git a/tests/ui/equatable_if_let.fixed b/tests/ui/equatable_if_let.fixed
new file mode 100644
index 00000000000..ba72cc237b4
--- /dev/null
+++ b/tests/ui/equatable_if_let.fixed
@@ -0,0 +1,69 @@
+// run-rustfix
+
+#![allow(unused_variables, dead_code)]
+#![warn(clippy::equatable_if_let)]
+
+use std::cmp::Ordering;
+
+#[derive(PartialEq)]
+enum Enum {
+    TupleVariant(i32, u64),
+    RecordVariant { a: i64, b: u32 },
+    UnitVariant,
+    Recursive(Struct),
+}
+
+#[derive(PartialEq)]
+struct Struct {
+    a: i32,
+    b: bool,
+}
+
+enum NotPartialEq {
+    A,
+    B,
+}
+
+enum NotStructuralEq {
+    A,
+    B,
+}
+
+impl PartialEq for NotStructuralEq {
+    fn eq(&self, _: &NotStructuralEq) -> bool {
+        false
+    }
+}
+
+fn main() {
+    let a = 2;
+    let b = 3;
+    let c = Some(2);
+    let d = Struct { a: 2, b: false };
+    let e = Enum::UnitVariant;
+    let f = NotPartialEq::A;
+    let g = NotStructuralEq::A;
+
+    // true
+
+    if a == 2 {}
+    if a.cmp(&b) == Ordering::Greater {}
+    if c == Some(2) {}
+    if d == (Struct { a: 2, b: false }) {}
+    if e == Enum::TupleVariant(32, 64) {}
+    if e == (Enum::RecordVariant { a: 64, b: 32 }) {}
+    if e == Enum::UnitVariant {}
+    if (e, &d) == (Enum::UnitVariant, &Struct { a: 2, b: false }) {}
+
+    // false
+
+    if let 2 | 3 = a {}
+    if let x @ 2 = a {}
+    if let Some(3 | 4) = c {}
+    if let Struct { a, b: false } = d {}
+    if let Struct { a: 2, b: x } = d {}
+    if let NotPartialEq::A = f {}
+    if g == NotStructuralEq::A {}
+    if let Some(NotPartialEq::A) = Some(f) {}
+    if Some(g) == Some(NotStructuralEq::A) {}
+}
diff --git a/tests/ui/equatable_if_let.rs b/tests/ui/equatable_if_let.rs
new file mode 100644
index 00000000000..12526ca193d
--- /dev/null
+++ b/tests/ui/equatable_if_let.rs
@@ -0,0 +1,69 @@
+// run-rustfix
+
+#![allow(unused_variables, dead_code)]
+#![warn(clippy::equatable_if_let)]
+
+use std::cmp::Ordering;
+
+#[derive(PartialEq)]
+enum Enum {
+    TupleVariant(i32, u64),
+    RecordVariant { a: i64, b: u32 },
+    UnitVariant,
+    Recursive(Struct),
+}
+
+#[derive(PartialEq)]
+struct Struct {
+    a: i32,
+    b: bool,
+}
+
+enum NotPartialEq {
+    A,
+    B,
+}
+
+enum NotStructuralEq {
+    A,
+    B,
+}
+
+impl PartialEq for NotStructuralEq {
+    fn eq(&self, _: &NotStructuralEq) -> bool {
+        false
+    }
+}
+
+fn main() {
+    let a = 2;
+    let b = 3;
+    let c = Some(2);
+    let d = Struct { a: 2, b: false };
+    let e = Enum::UnitVariant;
+    let f = NotPartialEq::A;
+    let g = NotStructuralEq::A;
+
+    // true
+
+    if let 2 = a {}
+    if let Ordering::Greater = a.cmp(&b) {}
+    if let Some(2) = c {}
+    if let Struct { a: 2, b: false } = d {}
+    if let Enum::TupleVariant(32, 64) = e {}
+    if let Enum::RecordVariant { a: 64, b: 32 } = e {}
+    if let Enum::UnitVariant = e {}
+    if let (Enum::UnitVariant, &Struct { a: 2, b: false }) = (e, &d) {}
+
+    // false
+
+    if let 2 | 3 = a {}
+    if let x @ 2 = a {}
+    if let Some(3 | 4) = c {}
+    if let Struct { a, b: false } = d {}
+    if let Struct { a: 2, b: x } = d {}
+    if let NotPartialEq::A = f {}
+    if let NotStructuralEq::A = g {}
+    if let Some(NotPartialEq::A) = Some(f) {}
+    if let Some(NotStructuralEq::A) = Some(g) {}
+}
diff --git a/tests/ui/equatable_if_let.stderr b/tests/ui/equatable_if_let.stderr
new file mode 100644
index 00000000000..79ef919384d
--- /dev/null
+++ b/tests/ui/equatable_if_let.stderr
@@ -0,0 +1,64 @@
+error: this pattern matching can be expressed using equality
+  --> $DIR/equatable_if_let.rs:49:8
+   |
+LL |     if let 2 = a {}
+   |        ^^^^^^^^^ help: try: `a == 2`
+   |
+   = note: `-D clippy::equatable-if-let` implied by `-D warnings`
+
+error: this pattern matching can be expressed using equality
+  --> $DIR/equatable_if_let.rs:50:8
+   |
+LL |     if let Ordering::Greater = a.cmp(&b) {}
+   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `a.cmp(&b) == Ordering::Greater`
+
+error: this pattern matching can be expressed using equality
+  --> $DIR/equatable_if_let.rs:51:8
+   |
+LL |     if let Some(2) = c {}
+   |        ^^^^^^^^^^^^^^^ help: try: `c == Some(2)`
+
+error: this pattern matching can be expressed using equality
+  --> $DIR/equatable_if_let.rs:52:8
+   |
+LL |     if let Struct { a: 2, b: false } = d {}
+   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `d == (Struct { a: 2, b: false })`
+
+error: this pattern matching can be expressed using equality
+  --> $DIR/equatable_if_let.rs:53:8
+   |
+LL |     if let Enum::TupleVariant(32, 64) = e {}
+   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `e == Enum::TupleVariant(32, 64)`
+
+error: this pattern matching can be expressed using equality
+  --> $DIR/equatable_if_let.rs:54:8
+   |
+LL |     if let Enum::RecordVariant { a: 64, b: 32 } = e {}
+   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `e == (Enum::RecordVariant { a: 64, b: 32 })`
+
+error: this pattern matching can be expressed using equality
+  --> $DIR/equatable_if_let.rs:55:8
+   |
+LL |     if let Enum::UnitVariant = e {}
+   |        ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `e == Enum::UnitVariant`
+
+error: this pattern matching can be expressed using equality
+  --> $DIR/equatable_if_let.rs:56:8
+   |
+LL |     if let (Enum::UnitVariant, &Struct { a: 2, b: false }) = (e, &d) {}
+   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `(e, &d) == (Enum::UnitVariant, &Struct { a: 2, b: false })`
+
+error: this pattern matching can be expressed using equality
+  --> $DIR/equatable_if_let.rs:66:8
+   |
+LL |     if let NotStructuralEq::A = g {}
+   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `g == NotStructuralEq::A`
+
+error: this pattern matching can be expressed using equality
+  --> $DIR/equatable_if_let.rs:68:8
+   |
+LL |     if let Some(NotStructuralEq::A) = Some(g) {}
+   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Some(g) == Some(NotStructuralEq::A)`
+
+error: aborting due to 10 previous errors
+
diff --git a/tests/ui/if_same_then_else2.rs b/tests/ui/if_same_then_else2.rs
index e4dc5b647df..69189d9e0c0 100644
--- a/tests/ui/if_same_then_else2.rs
+++ b/tests/ui/if_same_then_else2.rs
@@ -2,6 +2,7 @@
 #![allow(
     clippy::blacklisted_name,
     clippy::collapsible_else_if,
+    clippy::equatable_if_let,
     clippy::collapsible_if,
     clippy::ifs_same_cond,
     clippy::needless_return,
diff --git a/tests/ui/if_same_then_else2.stderr b/tests/ui/if_same_then_else2.stderr
index 6524be0af85..cac788f859d 100644
--- a/tests/ui/if_same_then_else2.stderr
+++ b/tests/ui/if_same_then_else2.stderr
@@ -1,5 +1,5 @@
 error: this `if` has identical blocks
-  --> $DIR/if_same_then_else2.rs:13:13
+  --> $DIR/if_same_then_else2.rs:14:13
    |
 LL |       if true {
    |  _____________^
@@ -13,7 +13,7 @@ LL | |     } else {
    |
    = note: `-D clippy::if-same-then-else` implied by `-D warnings`
 note: same as this
-  --> $DIR/if_same_then_else2.rs:22:12
+  --> $DIR/if_same_then_else2.rs:23:12
    |
 LL |       } else {
    |  ____________^
@@ -26,7 +26,7 @@ LL | |     }
    | |_____^
 
 error: this `if` has identical blocks
-  --> $DIR/if_same_then_else2.rs:34:13
+  --> $DIR/if_same_then_else2.rs:35:13
    |
 LL |       if true {
    |  _____________^
@@ -35,7 +35,7 @@ LL | |     } else {
    | |_____^
    |
 note: same as this
-  --> $DIR/if_same_then_else2.rs:36:12
+  --> $DIR/if_same_then_else2.rs:37:12
    |
 LL |       } else {
    |  ____________^
@@ -45,7 +45,7 @@ LL | |     }
    | |_____^
 
 error: this `if` has identical blocks
-  --> $DIR/if_same_then_else2.rs:41:13
+  --> $DIR/if_same_then_else2.rs:42:13
    |
 LL |       if true {
    |  _____________^
@@ -54,7 +54,7 @@ LL | |     } else {
    | |_____^
    |
 note: same as this
-  --> $DIR/if_same_then_else2.rs:43:12
+  --> $DIR/if_same_then_else2.rs:44:12
    |
 LL |       } else {
    |  ____________^
@@ -64,7 +64,7 @@ LL | |     }
    | |_____^
 
 error: this `if` has identical blocks
-  --> $DIR/if_same_then_else2.rs:91:21
+  --> $DIR/if_same_then_else2.rs:92:21
    |
 LL |       let _ = if true {
    |  _____________________^
@@ -73,7 +73,7 @@ LL | |     } else {
    | |_____^
    |
 note: same as this
-  --> $DIR/if_same_then_else2.rs:93:12
+  --> $DIR/if_same_then_else2.rs:94:12
    |
 LL |       } else {
    |  ____________^
@@ -83,7 +83,7 @@ LL | |     };
    | |_____^
 
 error: this `if` has identical blocks
-  --> $DIR/if_same_then_else2.rs:98:13
+  --> $DIR/if_same_then_else2.rs:99:13
    |
 LL |       if true {
    |  _____________^
@@ -92,7 +92,7 @@ LL | |     } else {
    | |_____^
    |
 note: same as this
-  --> $DIR/if_same_then_else2.rs:100:12
+  --> $DIR/if_same_then_else2.rs:101:12
    |
 LL |       } else {
    |  ____________^
@@ -102,7 +102,7 @@ LL | |     }
    | |_____^
 
 error: this `if` has identical blocks
-  --> $DIR/if_same_then_else2.rs:122:20
+  --> $DIR/if_same_then_else2.rs:123:20
    |
 LL |       } else if true {
    |  ____________________^
@@ -112,7 +112,7 @@ LL | |     } else {
    | |_____^
    |
 note: same as this
-  --> $DIR/if_same_then_else2.rs:125:12
+  --> $DIR/if_same_then_else2.rs:126:12
    |
 LL |       } else {
    |  ____________^
diff --git a/tests/ui/match_expr_like_matches_macro.fixed b/tests/ui/match_expr_like_matches_macro.fixed
index 319299862a7..c611f76bf96 100644
--- a/tests/ui/match_expr_like_matches_macro.fixed
+++ b/tests/ui/match_expr_like_matches_macro.fixed
@@ -1,7 +1,7 @@
 // run-rustfix
 
 #![warn(clippy::match_like_matches_macro)]
-#![allow(unreachable_patterns, dead_code)]
+#![allow(unreachable_patterns, dead_code, clippy::equatable_if_let)]
 
 fn main() {
     let x = Some(5);
diff --git a/tests/ui/match_expr_like_matches_macro.rs b/tests/ui/match_expr_like_matches_macro.rs
index 2ef6cf42387..2deeb84e741 100644
--- a/tests/ui/match_expr_like_matches_macro.rs
+++ b/tests/ui/match_expr_like_matches_macro.rs
@@ -1,7 +1,7 @@
 // run-rustfix
 
 #![warn(clippy::match_like_matches_macro)]
-#![allow(unreachable_patterns, dead_code)]
+#![allow(unreachable_patterns, dead_code, clippy::equatable_if_let)]
 
 fn main() {
     let x = Some(5);
diff --git a/tests/ui/match_overlapping_arm.rs b/tests/ui/match_overlapping_arm.rs
index c84e31ea482..846d665d1d8 100644
--- a/tests/ui/match_overlapping_arm.rs
+++ b/tests/ui/match_overlapping_arm.rs
@@ -2,7 +2,7 @@
 #![feature(half_open_range_patterns)]
 #![warn(clippy::match_overlapping_arm)]
 #![allow(clippy::redundant_pattern_matching)]
-#![allow(clippy::if_same_then_else)]
+#![allow(clippy::if_same_then_else, clippy::equatable_if_let)]
 
 /// Tests for match_overlapping_arm
 
diff --git a/tests/ui/match_ref_pats.rs b/tests/ui/match_ref_pats.rs
index 5de43733ad3..6cbb4d32b0d 100644
--- a/tests/ui/match_ref_pats.rs
+++ b/tests/ui/match_ref_pats.rs
@@ -1,4 +1,5 @@
 #![warn(clippy::match_ref_pats)]
+#![allow(clippy::equatable_if_let)]
 
 fn ref_pats() {
     {
diff --git a/tests/ui/match_ref_pats.stderr b/tests/ui/match_ref_pats.stderr
index a57a338b276..072aff445e9 100644
--- a/tests/ui/match_ref_pats.stderr
+++ b/tests/ui/match_ref_pats.stderr
@@ -1,5 +1,5 @@
 error: you don't need to add `&` to all patterns
-  --> $DIR/match_ref_pats.rs:6:9
+  --> $DIR/match_ref_pats.rs:7:9
    |
 LL | /         match v {
 LL | |             &Some(v) => println!("{:?}", v),
@@ -16,7 +16,7 @@ LL ~             None => println!("none"),
    |
 
 error: you don't need to add `&` to all patterns
-  --> $DIR/match_ref_pats.rs:17:5
+  --> $DIR/match_ref_pats.rs:18:5
    |
 LL | /     match tup {
 LL | |         &(v, 1) => println!("{}", v),
@@ -31,7 +31,7 @@ LL ~         (v, 1) => println!("{}", v),
    |
 
 error: you don't need to add `&` to both the expression and the patterns
-  --> $DIR/match_ref_pats.rs:23:5
+  --> $DIR/match_ref_pats.rs:24:5
    |
 LL | /     match &w {
 LL | |         &Some(v) => println!("{:?}", v),
@@ -47,7 +47,7 @@ LL ~         None => println!("none"),
    |
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/match_ref_pats.rs:35:12
+  --> $DIR/match_ref_pats.rs:36:12
    |
 LL |     if let &None = a {
    |     -------^^^^^---- help: try this: `if a.is_none()`
@@ -55,7 +55,7 @@ LL |     if let &None = a {
    = note: `-D clippy::redundant-pattern-matching` implied by `-D warnings`
 
 error: you don't need to add `&` to all patterns
-  --> $DIR/match_ref_pats.rs:35:5
+  --> $DIR/match_ref_pats.rs:36:5
    |
 LL | /     if let &None = a {
 LL | |         println!("none");
@@ -68,13 +68,13 @@ LL |     if let None = *a {
    |            ~~~~   ~~
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/match_ref_pats.rs:40:12
+  --> $DIR/match_ref_pats.rs:41:12
    |
 LL |     if let &None = &b {
    |     -------^^^^^----- help: try this: `if b.is_none()`
 
 error: you don't need to add `&` to both the expression and the patterns
-  --> $DIR/match_ref_pats.rs:40:5
+  --> $DIR/match_ref_pats.rs:41:5
    |
 LL | /     if let &None = &b {
 LL | |         println!("none");
@@ -87,7 +87,7 @@ LL |     if let None = b {
    |            ~~~~   ~
 
 error: you don't need to add `&` to all patterns
-  --> $DIR/match_ref_pats.rs:67:9
+  --> $DIR/match_ref_pats.rs:68:9
    |
 LL | /         match foo_variant!(0) {
 LL | |             &Foo::A => println!("A"),
diff --git a/tests/ui/needless_bool/fixable.fixed b/tests/ui/needless_bool/fixable.fixed
index 639eac8b8b3..a2e3988daff 100644
--- a/tests/ui/needless_bool/fixable.fixed
+++ b/tests/ui/needless_bool/fixable.fixed
@@ -6,6 +6,7 @@
     dead_code,
     clippy::no_effect,
     clippy::if_same_then_else,
+    clippy::equatable_if_let,
     clippy::needless_return,
     clippy::self_named_constructors
 )]
diff --git a/tests/ui/needless_bool/fixable.rs b/tests/ui/needless_bool/fixable.rs
index a3ce086a1c9..75805e85789 100644
--- a/tests/ui/needless_bool/fixable.rs
+++ b/tests/ui/needless_bool/fixable.rs
@@ -6,6 +6,7 @@
     dead_code,
     clippy::no_effect,
     clippy::if_same_then_else,
+    clippy::equatable_if_let,
     clippy::needless_return,
     clippy::self_named_constructors
 )]
diff --git a/tests/ui/needless_bool/fixable.stderr b/tests/ui/needless_bool/fixable.stderr
index 8026d643c44..1fa12add167 100644
--- a/tests/ui/needless_bool/fixable.stderr
+++ b/tests/ui/needless_bool/fixable.stderr
@@ -1,5 +1,5 @@
 error: this if-then-else expression returns a bool literal
-  --> $DIR/fixable.rs:40:5
+  --> $DIR/fixable.rs:41:5
    |
 LL | /     if x {
 LL | |         true
@@ -11,7 +11,7 @@ LL | |     };
    = note: `-D clippy::needless-bool` implied by `-D warnings`
 
 error: this if-then-else expression returns a bool literal
-  --> $DIR/fixable.rs:45:5
+  --> $DIR/fixable.rs:46:5
    |
 LL | /     if x {
 LL | |         false
@@ -21,7 +21,7 @@ LL | |     };
    | |_____^ help: you can reduce it to: `!x`
 
 error: this if-then-else expression returns a bool literal
-  --> $DIR/fixable.rs:50:5
+  --> $DIR/fixable.rs:51:5
    |
 LL | /     if x && y {
 LL | |         false
@@ -31,7 +31,7 @@ LL | |     };
    | |_____^ help: you can reduce it to: `!(x && y)`
 
 error: this if-then-else expression returns a bool literal
-  --> $DIR/fixable.rs:70:5
+  --> $DIR/fixable.rs:71:5
    |
 LL | /     if x {
 LL | |         return true;
@@ -41,7 +41,7 @@ LL | |     };
    | |_____^ help: you can reduce it to: `return x`
 
 error: this if-then-else expression returns a bool literal
-  --> $DIR/fixable.rs:78:5
+  --> $DIR/fixable.rs:79:5
    |
 LL | /     if x {
 LL | |         return false;
@@ -51,7 +51,7 @@ LL | |     };
    | |_____^ help: you can reduce it to: `return !x`
 
 error: this if-then-else expression returns a bool literal
-  --> $DIR/fixable.rs:86:5
+  --> $DIR/fixable.rs:87:5
    |
 LL | /     if x && y {
 LL | |         return true;
@@ -61,7 +61,7 @@ LL | |     };
    | |_____^ help: you can reduce it to: `return x && y`
 
 error: this if-then-else expression returns a bool literal
-  --> $DIR/fixable.rs:94:5
+  --> $DIR/fixable.rs:95:5
    |
 LL | /     if x && y {
 LL | |         return false;
@@ -71,7 +71,7 @@ LL | |     };
    | |_____^ help: you can reduce it to: `return !(x && y)`
 
 error: equality checks against true are unnecessary
-  --> $DIR/fixable.rs:102:8
+  --> $DIR/fixable.rs:103:8
    |
 LL |     if x == true {};
    |        ^^^^^^^^^ help: try simplifying it as shown: `x`
@@ -79,25 +79,25 @@ LL |     if x == true {};
    = note: `-D clippy::bool-comparison` implied by `-D warnings`
 
 error: equality checks against false can be replaced by a negation
-  --> $DIR/fixable.rs:106:8
+  --> $DIR/fixable.rs:107:8
    |
 LL |     if x == false {};
    |        ^^^^^^^^^^ help: try simplifying it as shown: `!x`
 
 error: equality checks against true are unnecessary
-  --> $DIR/fixable.rs:116:8
+  --> $DIR/fixable.rs:117:8
    |
 LL |     if x == true {};
    |        ^^^^^^^^^ help: try simplifying it as shown: `x`
 
 error: equality checks against false can be replaced by a negation
-  --> $DIR/fixable.rs:117:8
+  --> $DIR/fixable.rs:118:8
    |
 LL |     if x == false {};
    |        ^^^^^^^^^^ help: try simplifying it as shown: `!x`
 
 error: this if-then-else expression returns a bool literal
-  --> $DIR/fixable.rs:126:12
+  --> $DIR/fixable.rs:127:12
    |
 LL |       } else if returns_bool() {
    |  ____________^
diff --git a/tests/ui/needless_return.fixed b/tests/ui/needless_return.fixed
index 37efa6274df..9c999e12b4c 100644
--- a/tests/ui/needless_return.fixed
+++ b/tests/ui/needless_return.fixed
@@ -3,7 +3,12 @@
 
 #![feature(let_else)]
 #![allow(unused)]
-#![allow(clippy::if_same_then_else, clippy::single_match, clippy::needless_bool)]
+#![allow(
+    clippy::if_same_then_else,
+    clippy::single_match,
+    clippy::needless_bool,
+    clippy::equatable_if_let
+)]
 #![warn(clippy::needless_return)]
 
 macro_rules! the_answer {
diff --git a/tests/ui/needless_return.rs b/tests/ui/needless_return.rs
index cbf384ac9e4..da7dcf4f0a9 100644
--- a/tests/ui/needless_return.rs
+++ b/tests/ui/needless_return.rs
@@ -3,7 +3,12 @@
 
 #![feature(let_else)]
 #![allow(unused)]
-#![allow(clippy::if_same_then_else, clippy::single_match, clippy::needless_bool)]
+#![allow(
+    clippy::if_same_then_else,
+    clippy::single_match,
+    clippy::needless_bool,
+    clippy::equatable_if_let
+)]
 #![warn(clippy::needless_return)]
 
 macro_rules! the_answer {
diff --git a/tests/ui/needless_return.stderr b/tests/ui/needless_return.stderr
index 7ce7028bbae..2e802cff1e6 100644
--- a/tests/ui/needless_return.stderr
+++ b/tests/ui/needless_return.stderr
@@ -1,5 +1,5 @@
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:20:5
+  --> $DIR/needless_return.rs:25:5
    |
 LL |     return true;
    |     ^^^^^^^^^^^^ help: remove `return`: `true`
@@ -7,187 +7,187 @@ LL |     return true;
    = note: `-D clippy::needless-return` implied by `-D warnings`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:24:5
+  --> $DIR/needless_return.rs:29:5
    |
 LL |     return true;
    |     ^^^^^^^^^^^^ help: remove `return`: `true`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:29:9
+  --> $DIR/needless_return.rs:34:9
    |
 LL |         return true;
    |         ^^^^^^^^^^^^ help: remove `return`: `true`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:31:9
+  --> $DIR/needless_return.rs:36:9
    |
 LL |         return false;
    |         ^^^^^^^^^^^^^ help: remove `return`: `false`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:37:17
+  --> $DIR/needless_return.rs:42:17
    |
 LL |         true => return false,
    |                 ^^^^^^^^^^^^ help: remove `return`: `false`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:39:13
+  --> $DIR/needless_return.rs:44:13
    |
 LL |             return true;
    |             ^^^^^^^^^^^^ help: remove `return`: `true`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:46:9
+  --> $DIR/needless_return.rs:51:9
    |
 LL |         return true;
    |         ^^^^^^^^^^^^ help: remove `return`: `true`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:48:16
+  --> $DIR/needless_return.rs:53:16
    |
 LL |     let _ = || return true;
    |                ^^^^^^^^^^^ help: remove `return`: `true`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:56:5
+  --> $DIR/needless_return.rs:61:5
    |
 LL |     return;
    |     ^^^^^^^ help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:61:9
+  --> $DIR/needless_return.rs:66:9
    |
 LL |         return;
    |         ^^^^^^^ help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:63:9
+  --> $DIR/needless_return.rs:68:9
    |
 LL |         return;
    |         ^^^^^^^ help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:70:14
+  --> $DIR/needless_return.rs:75:14
    |
 LL |         _ => return,
    |              ^^^^^^ help: replace `return` with an empty block: `{}`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:85:9
+  --> $DIR/needless_return.rs:90:9
    |
 LL |         return String::from("test");
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove `return`: `String::from("test")`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:87:9
+  --> $DIR/needless_return.rs:92:9
    |
 LL |         return String::new();
    |         ^^^^^^^^^^^^^^^^^^^^^ help: remove `return`: `String::new()`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:108:32
+  --> $DIR/needless_return.rs:113:32
    |
 LL |         bar.unwrap_or_else(|_| return)
    |                                ^^^^^^ help: replace `return` with an empty block: `{}`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:113:13
+  --> $DIR/needless_return.rs:118:13
    |
 LL |             return;
    |             ^^^^^^^ help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:115:20
+  --> $DIR/needless_return.rs:120:20
    |
 LL |         let _ = || return;
    |                    ^^^^^^ help: replace `return` with an empty block: `{}`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:121:32
+  --> $DIR/needless_return.rs:126:32
    |
 LL |         res.unwrap_or_else(|_| return Foo)
    |                                ^^^^^^^^^^ help: remove `return`: `Foo`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:130:5
+  --> $DIR/needless_return.rs:135:5
    |
 LL |     return true;
    |     ^^^^^^^^^^^^ help: remove `return`: `true`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:134:5
+  --> $DIR/needless_return.rs:139:5
    |
 LL |     return true;
    |     ^^^^^^^^^^^^ help: remove `return`: `true`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:139:9
+  --> $DIR/needless_return.rs:144:9
    |
 LL |         return true;
    |         ^^^^^^^^^^^^ help: remove `return`: `true`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:141:9
+  --> $DIR/needless_return.rs:146:9
    |
 LL |         return false;
    |         ^^^^^^^^^^^^^ help: remove `return`: `false`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:147:17
+  --> $DIR/needless_return.rs:152:17
    |
 LL |         true => return false,
    |                 ^^^^^^^^^^^^ help: remove `return`: `false`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:149:13
+  --> $DIR/needless_return.rs:154:13
    |
 LL |             return true;
    |             ^^^^^^^^^^^^ help: remove `return`: `true`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:156:9
+  --> $DIR/needless_return.rs:161:9
    |
 LL |         return true;
    |         ^^^^^^^^^^^^ help: remove `return`: `true`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:158:16
+  --> $DIR/needless_return.rs:163:16
    |
 LL |     let _ = || return true;
    |                ^^^^^^^^^^^ help: remove `return`: `true`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:166:5
+  --> $DIR/needless_return.rs:171:5
    |
 LL |     return;
    |     ^^^^^^^ help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:171:9
+  --> $DIR/needless_return.rs:176:9
    |
 LL |         return;
    |         ^^^^^^^ help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:173:9
+  --> $DIR/needless_return.rs:178:9
    |
 LL |         return;
    |         ^^^^^^^ help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:180:14
+  --> $DIR/needless_return.rs:185:14
    |
 LL |         _ => return,
    |              ^^^^^^ help: replace `return` with an empty block: `{}`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:195:9
+  --> $DIR/needless_return.rs:200:9
    |
 LL |         return String::from("test");
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove `return`: `String::from("test")`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:197:9
+  --> $DIR/needless_return.rs:202:9
    |
 LL |         return String::new();
    |         ^^^^^^^^^^^^^^^^^^^^^ help: remove `return`: `String::new()`
diff --git a/tests/ui/option_if_let_else.fixed b/tests/ui/option_if_let_else.fixed
index d1815d0aec3..a3ebe5d0703 100644
--- a/tests/ui/option_if_let_else.fixed
+++ b/tests/ui/option_if_let_else.fixed
@@ -2,7 +2,7 @@
 // run-rustfix
 #![warn(clippy::option_if_let_else)]
 #![allow(clippy::redundant_closure)]
-#![allow(clippy::ref_option_ref)]
+#![allow(clippy::ref_option_ref, clippy::equatable_if_let)]
 
 fn bad1(string: Option<&str>) -> (bool, &str) {
     string.map_or((false, "hello"), |x| (true, x))
diff --git a/tests/ui/option_if_let_else.rs b/tests/ui/option_if_let_else.rs
index a15627338cb..b11df3db60f 100644
--- a/tests/ui/option_if_let_else.rs
+++ b/tests/ui/option_if_let_else.rs
@@ -2,7 +2,7 @@
 // run-rustfix
 #![warn(clippy::option_if_let_else)]
 #![allow(clippy::redundant_closure)]
-#![allow(clippy::ref_option_ref)]
+#![allow(clippy::ref_option_ref, clippy::equatable_if_let)]
 
 fn bad1(string: Option<&str>) -> (bool, &str) {
     if let Some(x) = string {
diff --git a/tests/ui/redundant_pattern_matching_drop_order.fixed b/tests/ui/redundant_pattern_matching_drop_order.fixed
index 794ed542435..ce3229f1759 100644
--- a/tests/ui/redundant_pattern_matching_drop_order.fixed
+++ b/tests/ui/redundant_pattern_matching_drop_order.fixed
@@ -2,7 +2,7 @@
 
 // Issue #5746
 #![warn(clippy::redundant_pattern_matching)]
-#![allow(clippy::if_same_then_else)]
+#![allow(clippy::if_same_then_else, clippy::equatable_if_let)]
 use std::task::Poll::{Pending, Ready};
 
 fn main() {
diff --git a/tests/ui/redundant_pattern_matching_drop_order.rs b/tests/ui/redundant_pattern_matching_drop_order.rs
index b9c82d86f61..29b8543cf47 100644
--- a/tests/ui/redundant_pattern_matching_drop_order.rs
+++ b/tests/ui/redundant_pattern_matching_drop_order.rs
@@ -2,7 +2,7 @@
 
 // Issue #5746
 #![warn(clippy::redundant_pattern_matching)]
-#![allow(clippy::if_same_then_else)]
+#![allow(clippy::if_same_then_else, clippy::equatable_if_let)]
 use std::task::Poll::{Pending, Ready};
 
 fn main() {
diff --git a/tests/ui/redundant_pattern_matching_option.fixed b/tests/ui/redundant_pattern_matching_option.fixed
index 99714477266..813e268a60c 100644
--- a/tests/ui/redundant_pattern_matching_option.fixed
+++ b/tests/ui/redundant_pattern_matching_option.fixed
@@ -6,6 +6,7 @@
     unused_must_use,
     clippy::needless_bool,
     clippy::match_like_matches_macro,
+    clippy::equatable_if_let,
     clippy::if_same_then_else
 )]
 
diff --git a/tests/ui/redundant_pattern_matching_option.rs b/tests/ui/redundant_pattern_matching_option.rs
index 8309847e181..82a98468943 100644
--- a/tests/ui/redundant_pattern_matching_option.rs
+++ b/tests/ui/redundant_pattern_matching_option.rs
@@ -6,6 +6,7 @@
     unused_must_use,
     clippy::needless_bool,
     clippy::match_like_matches_macro,
+    clippy::equatable_if_let,
     clippy::if_same_then_else
 )]
 
diff --git a/tests/ui/redundant_pattern_matching_option.stderr b/tests/ui/redundant_pattern_matching_option.stderr
index 613a30d4a48..3a58e5ad7be 100644
--- a/tests/ui/redundant_pattern_matching_option.stderr
+++ b/tests/ui/redundant_pattern_matching_option.stderr
@@ -1,5 +1,5 @@
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:13:12
+  --> $DIR/redundant_pattern_matching_option.rs:14:12
    |
 LL |     if let None = None::<()> {}
    |     -------^^^^------------- help: try this: `if None::<()>.is_none()`
@@ -7,43 +7,43 @@ LL |     if let None = 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:15:12
+  --> $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:17:12
+  --> $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:23:15
+  --> $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:25:15
+  --> $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:27:15
+  --> $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:30:15
+  --> $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:38:5
+  --> $DIR/redundant_pattern_matching_option.rs:39:5
    |
 LL | /     match Some(42) {
 LL | |         Some(_) => true,
@@ -52,7 +52,7 @@ LL | |     };
    | |_____^ help: try this: `Some(42).is_some()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:43:5
+  --> $DIR/redundant_pattern_matching_option.rs:44:5
    |
 LL | /     match None::<()> {
 LL | |         Some(_) => false,
@@ -61,7 +61,7 @@ LL | |     };
    | |_____^ help: try this: `None::<()>.is_none()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:48:13
+  --> $DIR/redundant_pattern_matching_option.rs:49:13
    |
 LL |       let _ = match None::<()> {
    |  _____________^
@@ -71,49 +71,49 @@ LL | |     };
    | |_____^ help: try this: `None::<()>.is_none()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/redundant_pattern_matching_option.rs:54:20
+  --> $DIR/redundant_pattern_matching_option.rs:55:20
    |
 LL |     let _ = 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:58:20
+  --> $DIR/redundant_pattern_matching_option.rs:59: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:60:19
+  --> $DIR/redundant_pattern_matching_option.rs:61: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:79:12
+  --> $DIR/redundant_pattern_matching_option.rs:80: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:81:12
+  --> $DIR/redundant_pattern_matching_option.rs:82: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:83:15
+  --> $DIR/redundant_pattern_matching_option.rs:84: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:85:15
+  --> $DIR/redundant_pattern_matching_option.rs:86: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:87:5
+  --> $DIR/redundant_pattern_matching_option.rs:88:5
    |
 LL | /     match Some(42) {
 LL | |         Some(_) => true,
@@ -122,7 +122,7 @@ LL | |     };
    | |_____^ help: try this: `Some(42).is_some()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:92:5
+  --> $DIR/redundant_pattern_matching_option.rs:93:5
    |
 LL | /     match None::<()> {
 LL | |         Some(_) => false,
diff --git a/tests/ui/redundant_pattern_matching_poll.fixed b/tests/ui/redundant_pattern_matching_poll.fixed
index c2977453804..3645f2c4bfd 100644
--- a/tests/ui/redundant_pattern_matching_poll.fixed
+++ b/tests/ui/redundant_pattern_matching_poll.fixed
@@ -6,6 +6,7 @@
     unused_must_use,
     clippy::needless_bool,
     clippy::match_like_matches_macro,
+    clippy::equatable_if_let,
     clippy::if_same_then_else
 )]
 
diff --git a/tests/ui/redundant_pattern_matching_poll.rs b/tests/ui/redundant_pattern_matching_poll.rs
index 665c8c41750..866c71b7cfa 100644
--- a/tests/ui/redundant_pattern_matching_poll.rs
+++ b/tests/ui/redundant_pattern_matching_poll.rs
@@ -6,6 +6,7 @@
     unused_must_use,
     clippy::needless_bool,
     clippy::match_like_matches_macro,
+    clippy::equatable_if_let,
     clippy::if_same_then_else
 )]
 
diff --git a/tests/ui/redundant_pattern_matching_poll.stderr b/tests/ui/redundant_pattern_matching_poll.stderr
index 5ecf024a733..1b480f3157f 100644
--- a/tests/ui/redundant_pattern_matching_poll.stderr
+++ b/tests/ui/redundant_pattern_matching_poll.stderr
@@ -1,5 +1,5 @@
 error: redundant pattern matching, consider using `is_pending()`
-  --> $DIR/redundant_pattern_matching_poll.rs:15:12
+  --> $DIR/redundant_pattern_matching_poll.rs:16:12
    |
 LL |     if let Pending = Pending::<()> {}
    |     -------^^^^^^^---------------- help: try this: `if Pending::<()>.is_pending()`
@@ -7,37 +7,37 @@ LL |     if let Pending = Pending::<()> {}
    = note: `-D clippy::redundant-pattern-matching` implied by `-D warnings`
 
 error: redundant pattern matching, consider using `is_ready()`
-  --> $DIR/redundant_pattern_matching_poll.rs:17:12
+  --> $DIR/redundant_pattern_matching_poll.rs:18:12
    |
 LL |     if let Ready(_) = Ready(42) {}
    |     -------^^^^^^^^------------ help: try this: `if Ready(42).is_ready()`
 
 error: redundant pattern matching, consider using `is_ready()`
-  --> $DIR/redundant_pattern_matching_poll.rs:19:12
+  --> $DIR/redundant_pattern_matching_poll.rs:20:12
    |
 LL |     if let Ready(_) = Ready(42) {
    |     -------^^^^^^^^------------ help: try this: `if Ready(42).is_ready()`
 
 error: redundant pattern matching, consider using `is_ready()`
-  --> $DIR/redundant_pattern_matching_poll.rs:25:15
+  --> $DIR/redundant_pattern_matching_poll.rs:26:15
    |
 LL |     while let Ready(_) = Ready(42) {}
    |     ----------^^^^^^^^------------ help: try this: `while Ready(42).is_ready()`
 
 error: redundant pattern matching, consider using `is_pending()`
-  --> $DIR/redundant_pattern_matching_poll.rs:27:15
+  --> $DIR/redundant_pattern_matching_poll.rs:28:15
    |
 LL |     while let Pending = Ready(42) {}
    |     ----------^^^^^^^------------ help: try this: `while Ready(42).is_pending()`
 
 error: redundant pattern matching, consider using `is_pending()`
-  --> $DIR/redundant_pattern_matching_poll.rs:29:15
+  --> $DIR/redundant_pattern_matching_poll.rs:30:15
    |
 LL |     while let Pending = Pending::<()> {}
    |     ----------^^^^^^^---------------- help: try this: `while Pending::<()>.is_pending()`
 
 error: redundant pattern matching, consider using `is_ready()`
-  --> $DIR/redundant_pattern_matching_poll.rs:35:5
+  --> $DIR/redundant_pattern_matching_poll.rs:36:5
    |
 LL | /     match Ready(42) {
 LL | |         Ready(_) => true,
@@ -46,7 +46,7 @@ LL | |     };
    | |_____^ help: try this: `Ready(42).is_ready()`
 
 error: redundant pattern matching, consider using `is_pending()`
-  --> $DIR/redundant_pattern_matching_poll.rs:40:5
+  --> $DIR/redundant_pattern_matching_poll.rs:41:5
    |
 LL | /     match Pending::<()> {
 LL | |         Ready(_) => false,
@@ -55,7 +55,7 @@ LL | |     };
    | |_____^ help: try this: `Pending::<()>.is_pending()`
 
 error: redundant pattern matching, consider using `is_pending()`
-  --> $DIR/redundant_pattern_matching_poll.rs:45:13
+  --> $DIR/redundant_pattern_matching_poll.rs:46:13
    |
 LL |       let _ = match Pending::<()> {
    |  _____________^
@@ -65,49 +65,49 @@ LL | |     };
    | |_____^ help: try this: `Pending::<()>.is_pending()`
 
 error: redundant pattern matching, consider using `is_ready()`
-  --> $DIR/redundant_pattern_matching_poll.rs:51:20
+  --> $DIR/redundant_pattern_matching_poll.rs:52:20
    |
 LL |     let _ = if let Ready(_) = poll { true } else { false };
    |             -------^^^^^^^^------- help: try this: `if poll.is_ready()`
 
 error: redundant pattern matching, consider using `is_ready()`
-  --> $DIR/redundant_pattern_matching_poll.rs:55:20
+  --> $DIR/redundant_pattern_matching_poll.rs:56:20
    |
 LL |     let _ = if let Ready(_) = gen_poll() {
    |             -------^^^^^^^^------------- help: try this: `if gen_poll().is_ready()`
 
 error: redundant pattern matching, consider using `is_pending()`
-  --> $DIR/redundant_pattern_matching_poll.rs:57:19
+  --> $DIR/redundant_pattern_matching_poll.rs:58:19
    |
 LL |     } else if let Pending = gen_poll() {
    |            -------^^^^^^^------------- help: try this: `if gen_poll().is_pending()`
 
 error: redundant pattern matching, consider using `is_ready()`
-  --> $DIR/redundant_pattern_matching_poll.rs:73:12
+  --> $DIR/redundant_pattern_matching_poll.rs:74:12
    |
 LL |     if let Ready(_) = Ready(42) {}
    |     -------^^^^^^^^------------ help: try this: `if Ready(42).is_ready()`
 
 error: redundant pattern matching, consider using `is_pending()`
-  --> $DIR/redundant_pattern_matching_poll.rs:75:12
+  --> $DIR/redundant_pattern_matching_poll.rs:76:12
    |
 LL |     if let Pending = Pending::<()> {}
    |     -------^^^^^^^---------------- help: try this: `if Pending::<()>.is_pending()`
 
 error: redundant pattern matching, consider using `is_ready()`
-  --> $DIR/redundant_pattern_matching_poll.rs:77:15
+  --> $DIR/redundant_pattern_matching_poll.rs:78:15
    |
 LL |     while let Ready(_) = Ready(42) {}
    |     ----------^^^^^^^^------------ help: try this: `while Ready(42).is_ready()`
 
 error: redundant pattern matching, consider using `is_pending()`
-  --> $DIR/redundant_pattern_matching_poll.rs:79:15
+  --> $DIR/redundant_pattern_matching_poll.rs:80:15
    |
 LL |     while let Pending = Pending::<()> {}
    |     ----------^^^^^^^---------------- help: try this: `while Pending::<()>.is_pending()`
 
 error: redundant pattern matching, consider using `is_ready()`
-  --> $DIR/redundant_pattern_matching_poll.rs:81:5
+  --> $DIR/redundant_pattern_matching_poll.rs:82:5
    |
 LL | /     match Ready(42) {
 LL | |         Ready(_) => true,
@@ -116,7 +116,7 @@ LL | |     };
    | |_____^ help: try this: `Ready(42).is_ready()`
 
 error: redundant pattern matching, consider using `is_pending()`
-  --> $DIR/redundant_pattern_matching_poll.rs:86:5
+  --> $DIR/redundant_pattern_matching_poll.rs:87:5
    |
 LL | /     match Pending::<()> {
 LL | |         Ready(_) => false,
diff --git a/tests/ui/while_let_on_iterator.fixed b/tests/ui/while_let_on_iterator.fixed
index f5a34190902..1e74ad2de65 100644
--- a/tests/ui/while_let_on_iterator.fixed
+++ b/tests/ui/while_let_on_iterator.fixed
@@ -1,7 +1,13 @@
 // run-rustfix
 
 #![warn(clippy::while_let_on_iterator)]
-#![allow(clippy::never_loop, unreachable_code, unused_mut, dead_code)]
+#![allow(
+    clippy::never_loop,
+    unreachable_code,
+    unused_mut,
+    dead_code,
+    clippy::equatable_if_let
+)]
 
 fn base() {
     let mut iter = 1..20;
diff --git a/tests/ui/while_let_on_iterator.rs b/tests/ui/while_let_on_iterator.rs
index 72f34257d1f..69cb636cee8 100644
--- a/tests/ui/while_let_on_iterator.rs
+++ b/tests/ui/while_let_on_iterator.rs
@@ -1,7 +1,13 @@
 // run-rustfix
 
 #![warn(clippy::while_let_on_iterator)]
-#![allow(clippy::never_loop, unreachable_code, unused_mut, dead_code)]
+#![allow(
+    clippy::never_loop,
+    unreachable_code,
+    unused_mut,
+    dead_code,
+    clippy::equatable_if_let
+)]
 
 fn base() {
     let mut iter = 1..20;
diff --git a/tests/ui/while_let_on_iterator.stderr b/tests/ui/while_let_on_iterator.stderr
index 5e2fce4491a..1a11ba26eef 100644
--- a/tests/ui/while_let_on_iterator.stderr
+++ b/tests/ui/while_let_on_iterator.stderr
@@ -1,5 +1,5 @@
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:8:5
+  --> $DIR/while_let_on_iterator.rs:14:5
    |
 LL |     while let Option::Some(x) = iter.next() {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for x in iter`
@@ -7,85 +7,85 @@ LL |     while let Option::Some(x) = iter.next() {
    = note: `-D clippy::while-let-on-iterator` implied by `-D warnings`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:13:5
+  --> $DIR/while_let_on_iterator.rs:19:5
    |
 LL |     while let Some(x) = iter.next() {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for x in iter`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:18:5
+  --> $DIR/while_let_on_iterator.rs:24:5
    |
 LL |     while let Some(_) = iter.next() {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for _ in iter`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:94:9
+  --> $DIR/while_let_on_iterator.rs:100:9
    |
 LL |         while let Some([..]) = it.next() {}
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for [..] in it`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:101:9
+  --> $DIR/while_let_on_iterator.rs:107:9
    |
 LL |         while let Some([_x]) = it.next() {}
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for [_x] in it`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:114:9
+  --> $DIR/while_let_on_iterator.rs:120:9
    |
 LL |         while let Some(x @ [_]) = it.next() {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for x @ [_] in it`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:134:9
+  --> $DIR/while_let_on_iterator.rs:140:9
    |
 LL |         while let Some(_) = y.next() {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for _ in y`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:191:9
+  --> $DIR/while_let_on_iterator.rs:197:9
    |
 LL |         while let Some(m) = it.next() {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for m in it.by_ref()`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:202:5
+  --> $DIR/while_let_on_iterator.rs:208:5
    |
 LL |     while let Some(n) = it.next() {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for n in it`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:204:9
+  --> $DIR/while_let_on_iterator.rs:210:9
    |
 LL |         while let Some(m) = it.next() {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for m in it`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:213:9
+  --> $DIR/while_let_on_iterator.rs:219:9
    |
 LL |         while let Some(m) = it.next() {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for m in it`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:222:9
+  --> $DIR/while_let_on_iterator.rs:228:9
    |
 LL |         while let Some(m) = it.next() {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for m in it.by_ref()`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:239:9
+  --> $DIR/while_let_on_iterator.rs:245:9
    |
 LL |         while let Some(m) = it.next() {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for m in it.by_ref()`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:254:13
+  --> $DIR/while_let_on_iterator.rs:260:13
    |
 LL |             while let Some(i) = self.0.next() {
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for i in self.0.by_ref()`
 
 error: manual `!RangeInclusive::contains` implementation
-  --> $DIR/while_let_on_iterator.rs:255:20
+  --> $DIR/while_let_on_iterator.rs:261:20
    |
 LL |                 if i < 3 || i > 7 {
    |                    ^^^^^^^^^^^^^^ help: use: `!(3..=7).contains(&i)`
@@ -93,37 +93,37 @@ LL |                 if i < 3 || i > 7 {
    = note: `-D clippy::manual-range-contains` implied by `-D warnings`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:286:13
+  --> $DIR/while_let_on_iterator.rs:292:13
    |
 LL |             while let Some(i) = self.0.0.0.next() {
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for i in self.0.0.0.by_ref()`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:315:5
+  --> $DIR/while_let_on_iterator.rs:321:5
    |
 LL |     while let Some(n) = it.next() {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for n in it.by_ref()`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:327:9
+  --> $DIR/while_let_on_iterator.rs:333:9
    |
 LL |         while let Some(x) = it.next() {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for x in it.by_ref()`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:341:5
+  --> $DIR/while_let_on_iterator.rs:347:5
    |
 LL |     while let Some(x) = it.next() {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for x in it.by_ref()`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:352:5
+  --> $DIR/while_let_on_iterator.rs:358:5
    |
 LL |     while let Some(x) = it.0.next() {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for x in it.0.by_ref()`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:371:5
+  --> $DIR/while_let_on_iterator.rs:377:5
    |
 LL |     while let Some(..) = it.next() {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for _ in it`
-- 
cgit 1.4.1-3-g733a5


From 7c82e78f308b35b40f424527b6d7961a81280529 Mon Sep 17 00:00:00 2001
From: Matthias Kaak <m.kaak@protonmail.ch>
Date: Tue, 5 Oct 2021 19:03:13 +0000
Subject: improved help message for `suspicious_map`

---
 clippy_lints/src/methods/suspicious_map.rs | 2 +-
 tests/ui/suspicious_map.stderr             | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/suspicious_map.rs b/clippy_lints/src/methods/suspicious_map.rs
index 0fd0668c734..18ded291915 100644
--- a/clippy_lints/src/methods/suspicious_map.rs
+++ b/clippy_lints/src/methods/suspicious_map.rs
@@ -28,7 +28,7 @@ pub fn check<'tcx>(cx: &LateContext<'tcx>, expr: &hir::Expr<'_>, count_recv: &hi
                 expr.span,
                 "this call to `map()` won't have an effect on the call to `count()`",
                 None,
-                "make sure you did not confuse `map` with `filter` or `for_each`",
+                "make sure you did not confuse `map` with `filter`, `for_each` or `inspect`",
             );
         }
     }
diff --git a/tests/ui/suspicious_map.stderr b/tests/ui/suspicious_map.stderr
index 8c3f36584a5..3ffcd1a9031 100644
--- a/tests/ui/suspicious_map.stderr
+++ b/tests/ui/suspicious_map.stderr
@@ -5,7 +5,7 @@ LL |     let _ = (0..3).map(|x| x + 2).count();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::suspicious-map` implied by `-D warnings`
-   = help: make sure you did not confuse `map` with `filter` or `for_each`
+   = help: make sure you did not confuse `map` with `filter`, `for_each` or `inspect`
 
 error: this call to `map()` won't have an effect on the call to `count()`
   --> $DIR/suspicious_map.rs:7:13
@@ -13,7 +13,7 @@ error: this call to `map()` won't have an effect on the call to `count()`
 LL |     let _ = (0..3).map(f).count();
    |             ^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: make sure you did not confuse `map` with `filter` or `for_each`
+   = help: make sure you did not confuse `map` with `filter`, `for_each` or `inspect`
 
 error: aborting due to 2 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 320ecb1f0b4e41427ef7af049ce44c815bdd7664 Mon Sep 17 00:00:00 2001
From: Matthias Kaak <m.kaak@protonmail.ch>
Date: Tue, 5 Oct 2021 19:40:15 +0000
Subject: Mentioned `inspect` in lint description of `suspicious_map`

---
 clippy_lints/src/methods/mod.rs | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 2025056ac94..b26d11c0d6b 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1284,8 +1284,9 @@ declare_clippy_lint! {
     ///
     /// ### Why is this bad?
     /// It looks suspicious. Maybe `map` was confused with `filter`.
-    /// If the `map` call is intentional, this should be rewritten. Or, if you intend to
-    /// drive the iterator to completion, you can just use `for_each` instead.
+    /// If the `map` call is intentional, this should be rewritten
+    /// using `inspect`. Or, if you intend to drive the iterator to
+    /// completion, you can just use `for_each` instead.
     ///
     /// ### Example
     /// ```rust
-- 
cgit 1.4.1-3-g733a5


From d9488c50ce64d09c6f598e4a3c7a5566faff3b11 Mon Sep 17 00:00:00 2001
From: Manish Goregaokar <manishsmail@gmail.com>
Date: Wed, 6 Oct 2021 00:12:58 -0700
Subject: Regen update_lints

---
 clippy_lints/src/lib.mods.rs | 234 ------------------------------------------
 clippy_lints/src/lib.rs      | 238 ++++++++++++++++++++++++++++++++++++++++++-
 2 files changed, 237 insertions(+), 235 deletions(-)
 delete mode 100644 clippy_lints/src/lib.mods.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.mods.rs b/clippy_lints/src/lib.mods.rs
deleted file mode 100644
index 8e899553e69..00000000000
--- a/clippy_lints/src/lib.mods.rs
+++ /dev/null
@@ -1,234 +0,0 @@
-// This file was generated by `cargo dev update_lints`.
-// Use that command to update this file and do not edit by hand.
-// Manual edits will be overwritten.
-
-mod absurd_extreme_comparisons;
-mod approx_const;
-mod arithmetic;
-mod as_conversions;
-mod asm_syntax;
-mod assertions_on_constants;
-mod assign_ops;
-mod async_yields_async;
-mod attrs;
-mod await_holding_invalid;
-mod bit_mask;
-mod blacklisted_name;
-mod blocks_in_if_conditions;
-mod bool_assert_comparison;
-mod booleans;
-mod bytecount;
-mod cargo_common_metadata;
-mod case_sensitive_file_extension_comparisons;
-mod casts;
-mod checked_conversions;
-mod cognitive_complexity;
-mod collapsible_if;
-mod collapsible_match;
-mod comparison_chain;
-mod copies;
-mod copy_iterator;
-mod create_dir;
-mod dbg_macro;
-mod default;
-mod default_numeric_fallback;
-mod dereference;
-mod derivable_impls;
-mod derive;
-mod disallowed_method;
-mod disallowed_script_idents;
-mod disallowed_type;
-mod doc;
-mod double_comparison;
-mod double_parens;
-mod drop_forget_ref;
-mod duration_subsec;
-mod else_if_without_else;
-mod empty_enum;
-mod entry;
-mod enum_clike;
-mod enum_variants;
-mod eq_op;
-mod equatable_if_let;
-mod erasing_op;
-mod escape;
-mod eta_reduction;
-mod eval_order_dependence;
-mod excessive_bools;
-mod exhaustive_items;
-mod exit;
-mod explicit_write;
-mod fallible_impl_from;
-mod feature_name;
-mod float_equality_without_abs;
-mod float_literal;
-mod floating_point_arithmetic;
-mod format;
-mod formatting;
-mod from_over_into;
-mod from_str_radix_10;
-mod functions;
-mod future_not_send;
-mod get_last_with_len;
-mod identity_op;
-mod if_let_mutex;
-mod if_not_else;
-mod if_then_panic;
-mod if_then_some_else_none;
-mod implicit_hasher;
-mod implicit_return;
-mod implicit_saturating_sub;
-mod inconsistent_struct_constructor;
-mod indexing_slicing;
-mod infinite_iter;
-mod inherent_impl;
-mod inherent_to_string;
-mod inline_fn_without_body;
-mod int_plus_one;
-mod integer_division;
-mod invalid_upcast_comparisons;
-mod items_after_statements;
-mod iter_not_returning_iterator;
-mod large_const_arrays;
-mod large_enum_variant;
-mod large_stack_arrays;
-mod len_zero;
-mod let_if_seq;
-mod let_underscore;
-mod lifetimes;
-mod literal_representation;
-mod loops;
-mod macro_use;
-mod main_recursion;
-mod manual_async_fn;
-mod manual_map;
-mod manual_non_exhaustive;
-mod manual_ok_or;
-mod manual_strip;
-mod manual_unwrap_or;
-mod map_clone;
-mod map_err_ignore;
-mod map_unit_fn;
-mod match_on_vec_items;
-mod match_result_ok;
-mod matches;
-mod mem_discriminant;
-mod mem_forget;
-mod mem_replace;
-mod methods;
-mod minmax;
-mod misc;
-mod misc_early;
-mod missing_const_for_fn;
-mod missing_doc;
-mod missing_enforced_import_rename;
-mod missing_inline;
-mod module_style;
-mod modulo_arithmetic;
-mod multiple_crate_versions;
-mod mut_key;
-mod mut_mut;
-mod mut_mutex_lock;
-mod mut_reference;
-mod mutable_debug_assertion;
-mod mutex_atomic;
-mod needless_arbitrary_self_type;
-mod needless_bitwise_bool;
-mod needless_bool;
-mod needless_borrow;
-mod needless_borrowed_ref;
-mod needless_continue;
-mod needless_for_each;
-mod needless_option_as_deref;
-mod needless_pass_by_value;
-mod needless_question_mark;
-mod needless_update;
-mod neg_cmp_op_on_partial_ord;
-mod neg_multiply;
-mod new_without_default;
-mod no_effect;
-mod non_copy_const;
-mod non_expressive_names;
-mod non_octal_unix_permissions;
-mod non_send_fields_in_send_ty;
-mod nonstandard_macro_braces;
-mod open_options;
-mod option_env_unwrap;
-mod option_if_let_else;
-mod overflow_check_conditional;
-mod panic_in_result_fn;
-mod panic_unimplemented;
-mod partialeq_ne_impl;
-mod pass_by_ref_or_value;
-mod path_buf_push_overwrite;
-mod pattern_type_mismatch;
-mod precedence;
-mod ptr;
-mod ptr_eq;
-mod ptr_offset_with_cast;
-mod question_mark;
-mod ranges;
-mod redundant_clone;
-mod redundant_closure_call;
-mod redundant_else;
-mod redundant_field_names;
-mod redundant_pub_crate;
-mod redundant_slicing;
-mod redundant_static_lifetimes;
-mod ref_option_ref;
-mod reference;
-mod regex;
-mod repeat_once;
-mod returns;
-mod same_name_method;
-mod self_assignment;
-mod self_named_constructors;
-mod semicolon_if_nothing_returned;
-mod serde_api;
-mod shadow;
-mod single_component_path_imports;
-mod size_of_in_element_count;
-mod slow_vector_initialization;
-mod stable_sort_primitive;
-mod strings;
-mod strlen_on_c_strings;
-mod suspicious_operation_groupings;
-mod suspicious_trait_impl;
-mod swap;
-mod tabs_in_doc_comments;
-mod temporary_assignment;
-mod to_digit_is_some;
-mod to_string_in_display;
-mod trait_bounds;
-mod transmute;
-mod transmuting_null;
-mod try_err;
-mod types;
-mod undropped_manually_drops;
-mod unicode;
-mod unit_return_expecting_ord;
-mod unit_types;
-mod unnamed_address;
-mod unnecessary_self_imports;
-mod unnecessary_sort_by;
-mod unnecessary_wraps;
-mod unnested_or_patterns;
-mod unsafe_removed_from_name;
-mod unused_async;
-mod unused_io_amount;
-mod unused_self;
-mod unused_unit;
-mod unwrap;
-mod unwrap_in_result;
-mod upper_case_acronyms;
-mod use_self;
-mod useless_conversion;
-mod vec;
-mod vec_init_then_push;
-mod vec_resize_to_zero;
-mod verbose_file_reads;
-mod wildcard_dependencies;
-mod wildcard_imports;
-mod write;
-mod zero_div_zero;
-mod zero_sized_map_values;
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 04128c8a0cc..c2376575cb8 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -155,7 +155,243 @@ macro_rules! declare_clippy_lint {
 mod deprecated_lints;
 mod utils;
 
-include!("lib.mods.rs");
+// begin lints modules, do not remove this comment, it’s used in `update_lints`
+// This file was generated by `cargo dev update_lints`.
+// Use that command to update this file and do not edit by hand.
+// Manual edits will be overwritten.
+
+mod absurd_extreme_comparisons;
+mod approx_const;
+mod arithmetic;
+mod as_conversions;
+mod asm_syntax;
+mod assertions_on_constants;
+mod assign_ops;
+mod async_yields_async;
+mod attrs;
+mod await_holding_invalid;
+mod bit_mask;
+mod blacklisted_name;
+mod blocks_in_if_conditions;
+mod bool_assert_comparison;
+mod booleans;
+mod bytecount;
+mod cargo_common_metadata;
+mod case_sensitive_file_extension_comparisons;
+mod casts;
+mod checked_conversions;
+mod cognitive_complexity;
+mod collapsible_if;
+mod collapsible_match;
+mod comparison_chain;
+mod copies;
+mod copy_iterator;
+mod create_dir;
+mod dbg_macro;
+mod default;
+mod default_numeric_fallback;
+mod dereference;
+mod derivable_impls;
+mod derive;
+mod disallowed_method;
+mod disallowed_script_idents;
+mod disallowed_type;
+mod doc;
+mod double_comparison;
+mod double_parens;
+mod drop_forget_ref;
+mod duration_subsec;
+mod else_if_without_else;
+mod empty_enum;
+mod entry;
+mod enum_clike;
+mod enum_variants;
+mod eq_op;
+mod equatable_if_let;
+mod erasing_op;
+mod escape;
+mod eta_reduction;
+mod eval_order_dependence;
+mod excessive_bools;
+mod exhaustive_items;
+mod exit;
+mod explicit_write;
+mod fallible_impl_from;
+mod feature_name;
+mod float_equality_without_abs;
+mod float_literal;
+mod floating_point_arithmetic;
+mod format;
+mod formatting;
+mod from_over_into;
+mod from_str_radix_10;
+mod functions;
+mod future_not_send;
+mod get_last_with_len;
+mod identity_op;
+mod if_let_mutex;
+mod if_not_else;
+mod if_then_panic;
+mod if_then_some_else_none;
+mod implicit_hasher;
+mod implicit_return;
+mod implicit_saturating_sub;
+mod inconsistent_struct_constructor;
+mod indexing_slicing;
+mod infinite_iter;
+mod inherent_impl;
+mod inherent_to_string;
+mod inline_fn_without_body;
+mod int_plus_one;
+mod integer_division;
+mod invalid_upcast_comparisons;
+mod items_after_statements;
+mod iter_not_returning_iterator;
+mod large_const_arrays;
+mod large_enum_variant;
+mod large_stack_arrays;
+mod len_zero;
+mod let_if_seq;
+mod let_underscore;
+mod lifetimes;
+mod literal_representation;
+mod loops;
+mod macro_use;
+mod main_recursion;
+mod manual_async_fn;
+mod manual_map;
+mod manual_non_exhaustive;
+mod manual_ok_or;
+mod manual_strip;
+mod manual_unwrap_or;
+mod map_clone;
+mod map_err_ignore;
+mod map_unit_fn;
+mod match_on_vec_items;
+mod match_result_ok;
+mod matches;
+mod mem_discriminant;
+mod mem_forget;
+mod mem_replace;
+mod methods;
+mod minmax;
+mod misc;
+mod misc_early;
+mod missing_const_for_fn;
+mod missing_doc;
+mod missing_enforced_import_rename;
+mod missing_inline;
+mod module_style;
+mod modulo_arithmetic;
+mod multiple_crate_versions;
+mod mut_key;
+mod mut_mut;
+mod mut_mutex_lock;
+mod mut_reference;
+mod mutable_debug_assertion;
+mod mutex_atomic;
+mod needless_arbitrary_self_type;
+mod needless_bitwise_bool;
+mod needless_bool;
+mod needless_borrow;
+mod needless_borrowed_ref;
+mod needless_continue;
+mod needless_for_each;
+mod needless_option_as_deref;
+mod needless_pass_by_value;
+mod needless_question_mark;
+mod needless_update;
+mod neg_cmp_op_on_partial_ord;
+mod neg_multiply;
+mod new_without_default;
+mod no_effect;
+mod non_copy_const;
+mod non_expressive_names;
+mod non_octal_unix_permissions;
+mod non_send_fields_in_send_ty;
+mod nonstandard_macro_braces;
+mod open_options;
+mod option_env_unwrap;
+mod option_if_let_else;
+mod overflow_check_conditional;
+mod panic_in_result_fn;
+mod panic_unimplemented;
+mod partialeq_ne_impl;
+mod pass_by_ref_or_value;
+mod path_buf_push_overwrite;
+mod pattern_type_mismatch;
+mod precedence;
+mod ptr;
+mod ptr_eq;
+mod ptr_offset_with_cast;
+mod question_mark;
+mod ranges;
+mod redundant_clone;
+mod redundant_closure_call;
+mod redundant_else;
+mod redundant_field_names;
+mod redundant_pub_crate;
+mod redundant_slicing;
+mod redundant_static_lifetimes;
+mod ref_option_ref;
+mod reference;
+mod regex;
+mod repeat_once;
+mod returns;
+mod same_name_method;
+mod self_assignment;
+mod self_named_constructors;
+mod semicolon_if_nothing_returned;
+mod serde_api;
+mod shadow;
+mod single_component_path_imports;
+mod size_of_in_element_count;
+mod slow_vector_initialization;
+mod stable_sort_primitive;
+mod strings;
+mod strlen_on_c_strings;
+mod suspicious_operation_groupings;
+mod suspicious_trait_impl;
+mod swap;
+mod tabs_in_doc_comments;
+mod temporary_assignment;
+mod to_digit_is_some;
+mod to_string_in_display;
+mod trait_bounds;
+mod transmute;
+mod transmuting_null;
+mod try_err;
+mod types;
+mod undropped_manually_drops;
+mod unicode;
+mod unit_return_expecting_ord;
+mod unit_types;
+mod unnamed_address;
+mod unnecessary_self_imports;
+mod unnecessary_sort_by;
+mod unnecessary_wraps;
+mod unnested_or_patterns;
+mod unsafe_removed_from_name;
+mod unused_async;
+mod unused_io_amount;
+mod unused_self;
+mod unused_unit;
+mod unwrap;
+mod unwrap_in_result;
+mod upper_case_acronyms;
+mod use_self;
+mod useless_conversion;
+mod vec;
+mod vec_init_then_push;
+mod vec_resize_to_zero;
+mod verbose_file_reads;
+mod wildcard_dependencies;
+mod wildcard_imports;
+mod write;
+mod zero_div_zero;
+mod zero_sized_map_values;
+
+// end lints modules, do not remove this comment, it’s used in `update_lints`
 
 pub use crate::utils::conf::Conf;
 use crate::utils::conf::TryConf;
-- 
cgit 1.4.1-3-g733a5


From 2a8d7bd0dd69ab1fe2a2af0f2984959f62b5631c Mon Sep 17 00:00:00 2001
From: Manish Goregaokar <manishsmail@gmail.com>
Date: Wed, 6 Oct 2021 00:01:40 -0700
Subject: Handle intra-doc links in doc_markdown

---
 clippy_lints/src/doc.rs | 14 +++++++++++++-
 tests/ui/doc/doc.stderr |  8 +-------
 2 files changed, 14 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/doc.rs b/clippy_lints/src/doc.rs
index 55d2265125e..75873fd7c1c 100644
--- a/clippy_lints/src/doc.rs
+++ b/clippy_lints/src/doc.rs
@@ -406,6 +406,15 @@ struct DocHeaders {
 }
 
 fn check_attrs<'a>(cx: &LateContext<'_>, valid_idents: &FxHashSet<String>, attrs: &'a [Attribute]) -> DocHeaders {
+    use pulldown_cmark::{BrokenLink, CowStr, Options};
+    /// We don't want the parser to choke on intra doc links. Since we don't
+    /// actually care about rendering them, just pretend that all broken links are
+    /// point to a fake address.
+    #[allow(clippy::unnecessary_wraps)] // we're following a type signature
+    fn fake_broken_link_callback<'a>(_: BrokenLink<'_>) -> Option<(CowStr<'a>, CowStr<'a>)> {
+        Some(("fake".into(), "fake".into()))
+    }
+
     let mut doc = String::new();
     let mut spans = vec![];
 
@@ -440,7 +449,10 @@ fn check_attrs<'a>(cx: &LateContext<'_>, valid_idents: &FxHashSet<String>, attrs
         };
     }
 
-    let parser = pulldown_cmark::Parser::new(&doc).into_offset_iter();
+    let mut cb = fake_broken_link_callback;
+
+    let parser =
+        pulldown_cmark::Parser::new_with_broken_link_callback(&doc, Options::empty(), Some(&mut cb)).into_offset_iter();
     // Iterate over all `Events` and combine consecutive events into one
     let events = parser.coalesce(|previous, current| {
         use pulldown_cmark::Event::Text;
diff --git a/tests/ui/doc/doc.stderr b/tests/ui/doc/doc.stderr
index 161407a6a72..7eab8a85f09 100644
--- a/tests/ui/doc/doc.stderr
+++ b/tests/ui/doc/doc.stderr
@@ -186,11 +186,5 @@ error: you should put `mycrate::Collection` between ticks in the documentation
 LL | /// An iterator over mycrate::Collection's values.
    |                      ^^^^^^^^^^^^^^^^^^^
 
-error: you should put `text][path::to::item` between ticks in the documentation
-  --> $DIR/doc.rs:208:12
-   |
-LL | /// [plain text][path::to::item]
-   |            ^^^^^^^^^^^^^^^^^^^^
-
-error: aborting due to 32 previous errors
+error: aborting due to 31 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 8f075ec961bea50074f96d48be851eccd94a065f Mon Sep 17 00:00:00 2001
From: Michael Wright <mikerite@lavabit.com>
Date: Thu, 7 Oct 2021 06:37:56 +0200
Subject: Revert `update_lints` module list generating code

This commit reverts the module list generation code to what it was
before the change to `include!` it and generates better output.
---
 clippy_dev/src/update_lints.rs | 22 ++++++++++------------
 clippy_lints/src/lib.rs        |  5 -----
 2 files changed, 10 insertions(+), 17 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_dev/src/update_lints.rs b/clippy_dev/src/update_lints.rs
index 6ec812909f2..10d859988f6 100644
--- a/clippy_dev/src/update_lints.rs
+++ b/clippy_dev/src/update_lints.rs
@@ -1,6 +1,6 @@
 use itertools::Itertools;
 use regex::Regex;
-use std::collections::{BTreeSet, HashMap};
+use std::collections::HashMap;
 use std::ffi::OsStr;
 use std::fs;
 use std::lazy::SyncLazy;
@@ -105,7 +105,7 @@ pub fn run(update_mode: UpdateMode) {
         "end lints modules",
         false,
         update_mode == UpdateMode::Change,
-        || vec![gen_modules_list(usable_lints.iter())],
+        || gen_modules_list(usable_lints.iter()),
     )
     .changed;
 
@@ -262,14 +262,13 @@ fn gen_lint_group_list<'a>(group_name: &str, lints: impl Iterator<Item = &'a Lin
 
 /// Generates the module declarations for `lints`
 #[must_use]
-fn gen_modules_list<'a>(lints: impl Iterator<Item = &'a Lint>) -> String {
-    let module_names: BTreeSet<_> = lints.map(|l| &l.module).collect();
-
-    let mut output = GENERATED_FILE_COMMENT.to_string();
-    for name in module_names {
-        output.push_str(&format!("mod {};\n", name));
-    }
-    output
+fn gen_modules_list<'a>(lints: impl Iterator<Item = &'a Lint>) -> Vec<String> {
+    lints
+        .map(|l| &l.module)
+        .unique()
+        .map(|module| format!("mod {};", module))
+        .sorted()
+        .collect::<Vec<String>>()
 }
 
 /// Generates the list of lint links at the bottom of the CHANGELOG
@@ -677,8 +676,7 @@ mod tests {
             Lint::new("should_assert_eq", "group1", "abc", None, "module_name"),
             Lint::new("incorrect_stuff", "group3", "abc", None, "another_module"),
         ];
-        let expected =
-            GENERATED_FILE_COMMENT.to_string() + &["mod another_module;", "mod module_name;"].join("\n") + "\n";
+        let expected = vec!["mod another_module;".to_string(), "mod module_name;".to_string()];
         assert_eq!(expected, gen_modules_list(lints.iter()));
     }
 
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index c2376575cb8..9fc6a9e0ccc 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -156,10 +156,6 @@ mod deprecated_lints;
 mod utils;
 
 // begin lints modules, do not remove this comment, it’s used in `update_lints`
-// This file was generated by `cargo dev update_lints`.
-// Use that command to update this file and do not edit by hand.
-// Manual edits will be overwritten.
-
 mod absurd_extreme_comparisons;
 mod approx_const;
 mod arithmetic;
@@ -390,7 +386,6 @@ mod wildcard_imports;
 mod write;
 mod zero_div_zero;
 mod zero_sized_map_values;
-
 // end lints modules, do not remove this comment, it’s used in `update_lints`
 
 pub use crate::utils::conf::Conf;
-- 
cgit 1.4.1-3-g733a5


From 64f8b9d0eac0b3c25c74462bfbe5086feb4264e8 Mon Sep 17 00:00:00 2001
From: dswij <dswijj@gmail.com>
Date: Thu, 7 Oct 2021 16:39:13 +0800
Subject: Make `shadow_reuse` suggestion less verbose

---
 clippy_lints/src/shadow.rs |  6 +----
 tests/ui/shadow.rs         |  5 ++++
 tests/ui/shadow.stderr     | 60 +++++++++++++++++++++++++++-------------------
 3 files changed, 42 insertions(+), 29 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/shadow.rs b/clippy_lints/src/shadow.rs
index 2ca7c18800e..64841f33cc3 100644
--- a/clippy_lints/src/shadow.rs
+++ b/clippy_lints/src/shadow.rs
@@ -162,11 +162,7 @@ fn lint_shadow(cx: &LateContext<'_>, pat: &Pat<'_>, shadowed: HirId, span: Span)
             (SHADOW_SAME, msg)
         },
         Some(expr) if is_local_used(cx, expr, shadowed) => {
-            let msg = format!(
-                "`{}` is shadowed by `{}` which reuses the original value",
-                snippet(cx, pat.span, "_"),
-                snippet(cx, expr.span, "..")
-            );
+            let msg = format!("`{}` is shadowed", snippet(cx, pat.span, "_"));
             (SHADOW_REUSE, msg)
         },
         _ => {
diff --git a/tests/ui/shadow.rs b/tests/ui/shadow.rs
index 02e838456d0..55caef59f7f 100644
--- a/tests/ui/shadow.rs
+++ b/tests/ui/shadow.rs
@@ -17,6 +17,11 @@ fn shadow_reuse() -> Option<()> {
     let x = foo(x);
     let x = || x;
     let x = Some(1).map(|_| x)?;
+    let y = 1;
+    let y = match y {
+        1 => 2,
+        _ => 3,
+    };
     None
 }
 
diff --git a/tests/ui/shadow.stderr b/tests/ui/shadow.stderr
index 8b60e072c93..feed6e1ba8b 100644
--- a/tests/ui/shadow.stderr
+++ b/tests/ui/shadow.stderr
@@ -47,7 +47,7 @@ note: previous binding is here
 LL |     let x = &mut x;
    |         ^
 
-error: `x` is shadowed by `x.0` which reuses the original value
+error: `x` is shadowed
   --> $DIR/shadow.rs:13:9
    |
 LL |     let x = x.0;
@@ -60,7 +60,7 @@ note: previous binding is here
 LL |     let x = ([[0]], ());
    |         ^
 
-error: `x` is shadowed by `x[0]` which reuses the original value
+error: `x` is shadowed
   --> $DIR/shadow.rs:14:9
    |
 LL |     let x = x[0];
@@ -72,7 +72,7 @@ note: previous binding is here
 LL |     let x = x.0;
    |         ^
 
-error: `x` is shadowed by `x` which reuses the original value
+error: `x` is shadowed
   --> $DIR/shadow.rs:15:10
    |
 LL |     let [x] = x;
@@ -84,7 +84,7 @@ note: previous binding is here
 LL |     let x = x[0];
    |         ^
 
-error: `x` is shadowed by `Some(x)` which reuses the original value
+error: `x` is shadowed
   --> $DIR/shadow.rs:16:9
    |
 LL |     let x = Some(x);
@@ -96,7 +96,7 @@ note: previous binding is here
 LL |     let [x] = x;
    |          ^
 
-error: `x` is shadowed by `foo(x)` which reuses the original value
+error: `x` is shadowed
   --> $DIR/shadow.rs:17:9
    |
 LL |     let x = foo(x);
@@ -108,7 +108,7 @@ note: previous binding is here
 LL |     let x = Some(x);
    |         ^
 
-error: `x` is shadowed by `|| x` which reuses the original value
+error: `x` is shadowed
   --> $DIR/shadow.rs:18:9
    |
 LL |     let x = || x;
@@ -120,7 +120,7 @@ note: previous binding is here
 LL |     let x = foo(x);
    |         ^
 
-error: `x` is shadowed by `Some(1).map(|_| x)?` which reuses the original value
+error: `x` is shadowed
   --> $DIR/shadow.rs:19:9
    |
 LL |     let x = Some(1).map(|_| x)?;
@@ -132,102 +132,114 @@ note: previous binding is here
 LL |     let x = || x;
    |         ^
 
+error: `y` is shadowed
+  --> $DIR/shadow.rs:21:9
+   |
+LL |     let y = match y {
+   |         ^
+   |
+note: previous binding is here
+  --> $DIR/shadow.rs:20:9
+   |
+LL |     let y = 1;
+   |         ^
+
 error: `x` shadows a previous, unrelated binding
-  --> $DIR/shadow.rs:25:9
+  --> $DIR/shadow.rs:30:9
    |
 LL |     let x = 2;
    |         ^
    |
    = note: `-D clippy::shadow-unrelated` implied by `-D warnings`
 note: previous binding is here
-  --> $DIR/shadow.rs:24:9
+  --> $DIR/shadow.rs:29:9
    |
 LL |     let x = 1;
    |         ^
 
 error: `x` shadows a previous, unrelated binding
-  --> $DIR/shadow.rs:30:13
+  --> $DIR/shadow.rs:35:13
    |
 LL |         let x = 1;
    |             ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:29:10
+  --> $DIR/shadow.rs:34:10
    |
 LL |     fn f(x: u32) {
    |          ^
 
 error: `x` shadows a previous, unrelated binding
-  --> $DIR/shadow.rs:35:14
+  --> $DIR/shadow.rs:40:14
    |
 LL |         Some(x) => {
    |              ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:32:9
+  --> $DIR/shadow.rs:37:9
    |
 LL |     let x = 1;
    |         ^
 
 error: `x` shadows a previous, unrelated binding
-  --> $DIR/shadow.rs:36:17
+  --> $DIR/shadow.rs:41:17
    |
 LL |             let x = 1;
    |                 ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:35:14
+  --> $DIR/shadow.rs:40:14
    |
 LL |         Some(x) => {
    |              ^
 
 error: `x` shadows a previous, unrelated binding
-  --> $DIR/shadow.rs:40:17
+  --> $DIR/shadow.rs:45:17
    |
 LL |     if let Some(x) = Some(1) {}
    |                 ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:32:9
+  --> $DIR/shadow.rs:37:9
    |
 LL |     let x = 1;
    |         ^
 
 error: `x` shadows a previous, unrelated binding
-  --> $DIR/shadow.rs:41:20
+  --> $DIR/shadow.rs:46:20
    |
 LL |     while let Some(x) = Some(1) {}
    |                    ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:32:9
+  --> $DIR/shadow.rs:37:9
    |
 LL |     let x = 1;
    |         ^
 
 error: `x` shadows a previous, unrelated binding
-  --> $DIR/shadow.rs:42:15
+  --> $DIR/shadow.rs:47:15
    |
 LL |     let _ = |[x]: [u32; 1]| {
    |               ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:32:9
+  --> $DIR/shadow.rs:37:9
    |
 LL |     let x = 1;
    |         ^
 
 error: `x` shadows a previous, unrelated binding
-  --> $DIR/shadow.rs:43:13
+  --> $DIR/shadow.rs:48:13
    |
 LL |         let x = 1;
    |             ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:42:15
+  --> $DIR/shadow.rs:47:15
    |
 LL |     let _ = |[x]: [u32; 1]| {
    |               ^
 
-error: aborting due to 19 previous errors
+error: aborting due to 20 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From fbd0fb9aedbee06d0eefeecd62bc710832e0c457 Mon Sep 17 00:00:00 2001
From: Michael Sproul <michael@sigmaprime.io>
Date: Thu, 7 Oct 2021 11:50:14 +1100
Subject: Restriction lint for function pointer casts

---
 CHANGELOG.md                                     |   1 +
 clippy_lints/src/casts/fn_to_numeric_cast_any.rs |  34 ++++++++
 clippy_lints/src/casts/mod.rs                    |  39 +++++++++
 clippy_lints/src/lib.register_lints.rs           |   1 +
 clippy_lints/src/lib.register_restriction.rs     |   1 +
 tests/ui/fn_to_numeric_cast_any.rs               |  76 ++++++++++++++++
 tests/ui/fn_to_numeric_cast_any.stderr           | 106 +++++++++++++++++++++++
 7 files changed, 258 insertions(+)
 create mode 100644 clippy_lints/src/casts/fn_to_numeric_cast_any.rs
 create mode 100644 tests/ui/fn_to_numeric_cast_any.rs
 create mode 100644 tests/ui/fn_to_numeric_cast_any.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 7fdb300c977..b13a5d76002 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2730,6 +2730,7 @@ Released 2018-09-13
 [`fn_address_comparisons`]: https://rust-lang.github.io/rust-clippy/master/index.html#fn_address_comparisons
 [`fn_params_excessive_bools`]: https://rust-lang.github.io/rust-clippy/master/index.html#fn_params_excessive_bools
 [`fn_to_numeric_cast`]: https://rust-lang.github.io/rust-clippy/master/index.html#fn_to_numeric_cast
+[`fn_to_numeric_cast_any`]: https://rust-lang.github.io/rust-clippy/master/index.html#fn_to_numeric_cast_any
 [`fn_to_numeric_cast_with_truncation`]: https://rust-lang.github.io/rust-clippy/master/index.html#fn_to_numeric_cast_with_truncation
 [`for_kv_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#for_kv_map
 [`for_loops_over_fallibles`]: https://rust-lang.github.io/rust-clippy/master/index.html#for_loops_over_fallibles
diff --git a/clippy_lints/src/casts/fn_to_numeric_cast_any.rs b/clippy_lints/src/casts/fn_to_numeric_cast_any.rs
new file mode 100644
index 00000000000..03621887a34
--- /dev/null
+++ b/clippy_lints/src/casts/fn_to_numeric_cast_any.rs
@@ -0,0 +1,34 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet_with_applicability;
+use rustc_errors::Applicability;
+use rustc_hir::Expr;
+use rustc_lint::LateContext;
+use rustc_middle::ty::{self, Ty};
+
+use super::FN_TO_NUMERIC_CAST_ANY;
+
+pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_expr: &Expr<'_>, cast_from: Ty<'_>, cast_to: Ty<'_>) {
+    // We allow casts from any function type to any function type.
+    match cast_to.kind() {
+        ty::FnDef(..) | ty::FnPtr(..) => return,
+        _ => { /* continue to checks */ },
+    }
+
+    match cast_from.kind() {
+        ty::FnDef(..) | ty::FnPtr(_) => {
+            let mut applicability = Applicability::MaybeIncorrect;
+            let from_snippet = snippet_with_applicability(cx, cast_expr.span, "..", &mut applicability);
+
+            span_lint_and_sugg(
+                cx,
+                FN_TO_NUMERIC_CAST_ANY,
+                expr.span,
+                &format!("casting function pointer `{}` to `{}`", from_snippet, cast_to),
+                "did you mean to invoke the function?",
+                format!("{}() as {}", from_snippet, cast_to),
+                applicability,
+            );
+        },
+        _ => {},
+    }
+}
diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index 27e1bea7993..f0800c6a6f1 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -7,6 +7,7 @@ mod cast_ref_to_mut;
 mod cast_sign_loss;
 mod char_lit_as_u8;
 mod fn_to_numeric_cast;
+mod fn_to_numeric_cast_any;
 mod fn_to_numeric_cast_with_truncation;
 mod ptr_as_ptr;
 mod unnecessary_cast;
@@ -251,6 +252,42 @@ declare_clippy_lint! {
     "casting a function pointer to a numeric type not wide enough to store the address"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for casts of a function pointer to any integer type.
+    ///
+    /// ### Why is this bad?
+    /// Casting a function pointer to an integer can have surprising results and can occur
+    /// accidentally if parantheses are omitted from a function call. If you aren't doing anything
+    /// low-level with function pointers then you can opt-out of casting functions to integers in
+    /// order to avoid mistakes. Alternatively, you can use this lint to audit all uses of function
+    /// pointer casts in your code.
+    ///
+    /// ### Example
+    /// ```rust
+    /// // Bad: fn1 is cast as `usize`
+    /// fn fn1() -> u16 {
+    ///     1
+    /// };
+    /// let _ = fn1 as usize;
+    ///
+    /// // Good: maybe you intended to call the function?
+    /// fn fn2() -> u16 {
+    ///     1
+    /// };
+    /// let _ = fn2() as usize;
+    ///
+    /// // Good: maybe you intended to cast it to a function type?
+    /// fn fn3() -> u16 {
+    ///     1
+    /// }
+    /// let _ = fn3 as fn() -> u16;
+    /// ```
+    pub FN_TO_NUMERIC_CAST_ANY,
+    restriction,
+    "casting a function pointer to any integer type"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for casts of `&T` to `&mut T` anywhere in the code.
@@ -360,6 +397,7 @@ impl_lint_pass!(Casts => [
     CAST_REF_TO_MUT,
     CAST_PTR_ALIGNMENT,
     UNNECESSARY_CAST,
+    FN_TO_NUMERIC_CAST_ANY,
     FN_TO_NUMERIC_CAST,
     FN_TO_NUMERIC_CAST_WITH_TRUNCATION,
     CHAR_LIT_AS_U8,
@@ -385,6 +423,7 @@ impl<'tcx> LateLintPass<'tcx> for Casts {
                 return;
             }
 
+            fn_to_numeric_cast_any::check(cx, expr, cast_expr, cast_from, cast_to);
             fn_to_numeric_cast::check(cx, expr, cast_expr, cast_from, cast_to);
             fn_to_numeric_cast_with_truncation::check(cx, expr, cast_expr, cast_from, cast_to);
             if cast_from.is_numeric() && cast_to.is_numeric() && !in_external_macro(cx.sess(), expr.span) {
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 2ba2b3da55c..3c6d8103b6d 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -67,6 +67,7 @@ store.register_lints(&[
     casts::CAST_SIGN_LOSS,
     casts::CHAR_LIT_AS_U8,
     casts::FN_TO_NUMERIC_CAST,
+    casts::FN_TO_NUMERIC_CAST_ANY,
     casts::FN_TO_NUMERIC_CAST_WITH_TRUNCATION,
     casts::PTR_AS_PTR,
     casts::UNNECESSARY_CAST,
diff --git a/clippy_lints/src/lib.register_restriction.rs b/clippy_lints/src/lib.register_restriction.rs
index 4463dea5fcb..503f4f64a0e 100644
--- a/clippy_lints/src/lib.register_restriction.rs
+++ b/clippy_lints/src/lib.register_restriction.rs
@@ -8,6 +8,7 @@ store.register_group(true, "clippy::restriction", Some("clippy_restriction"), ve
     LintId::of(as_conversions::AS_CONVERSIONS),
     LintId::of(asm_syntax::INLINE_ASM_X86_ATT_SYNTAX),
     LintId::of(asm_syntax::INLINE_ASM_X86_INTEL_SYNTAX),
+    LintId::of(casts::FN_TO_NUMERIC_CAST_ANY),
     LintId::of(create_dir::CREATE_DIR),
     LintId::of(dbg_macro::DBG_MACRO),
     LintId::of(default_numeric_fallback::DEFAULT_NUMERIC_FALLBACK),
diff --git a/tests/ui/fn_to_numeric_cast_any.rs b/tests/ui/fn_to_numeric_cast_any.rs
new file mode 100644
index 00000000000..46704683926
--- /dev/null
+++ b/tests/ui/fn_to_numeric_cast_any.rs
@@ -0,0 +1,76 @@
+#![warn(clippy::fn_to_numeric_cast_any)]
+#![allow(clippy::fn_to_numeric_cast, clippy::fn_to_numeric_cast_with_truncation)]
+
+fn foo() -> u8 {
+    0
+}
+
+fn generic_foo<T>(x: T) -> T {
+    x
+}
+
+trait Trait {
+    fn static_method() -> u32 {
+        2
+    }
+}
+
+struct Struct;
+
+impl Trait for Struct {}
+
+fn fn_pointer_to_integer() {
+    let _ = foo as i8;
+    let _ = foo as i16;
+    let _ = foo as i32;
+    let _ = foo as i64;
+    let _ = foo as i128;
+    let _ = foo as isize;
+
+    let _ = foo as u8;
+    let _ = foo as u16;
+    let _ = foo as u32;
+    let _ = foo as u64;
+    let _ = foo as u128;
+    let _ = foo as usize;
+}
+
+fn static_method_to_integer() {
+    let _ = Struct::static_method as usize;
+}
+
+fn fn_with_fn_arg(f: fn(i32) -> u32) -> usize {
+    f as usize
+}
+
+fn fn_with_generic_static_trait_method<T: Trait>() -> usize {
+    T::static_method as usize
+}
+
+fn closure_to_fn_to_integer() {
+    let clos = |x| x * 2_u32;
+
+    let _ = (clos as fn(u32) -> u32) as usize;
+}
+
+fn fn_to_raw_ptr() {
+    let _ = foo as *const ();
+}
+
+fn cast_fn_to_self() {
+    // Casting to the same function pointer type should be permitted.
+    let _ = foo as fn() -> u8;
+}
+
+fn cast_generic_to_concrete() {
+    // Casting to a more concrete function pointer type should be permitted.
+    let _ = generic_foo as fn(usize) -> usize;
+}
+
+fn cast_closure_to_fn() {
+    // Casting a closure to a function pointer should be permitted.
+    let id = |x| x;
+    let _ = id as fn(usize) -> usize;
+}
+
+fn main() {}
diff --git a/tests/ui/fn_to_numeric_cast_any.stderr b/tests/ui/fn_to_numeric_cast_any.stderr
new file mode 100644
index 00000000000..a6c4a77672f
--- /dev/null
+++ b/tests/ui/fn_to_numeric_cast_any.stderr
@@ -0,0 +1,106 @@
+error: casting function pointer `foo` to `i8`
+  --> $DIR/fn_to_numeric_cast_any.rs:23:13
+   |
+LL |     let _ = foo as i8;
+   |             ^^^^^^^^^ help: did you mean to invoke the function?: `foo() as i8`
+   |
+   = note: `-D clippy::fn-to-numeric-cast-any` implied by `-D warnings`
+
+error: casting function pointer `foo` to `i16`
+  --> $DIR/fn_to_numeric_cast_any.rs:24:13
+   |
+LL |     let _ = foo as i16;
+   |             ^^^^^^^^^^ help: did you mean to invoke the function?: `foo() as i16`
+
+error: casting function pointer `foo` to `i32`
+  --> $DIR/fn_to_numeric_cast_any.rs:25:13
+   |
+LL |     let _ = foo as i32;
+   |             ^^^^^^^^^^ help: did you mean to invoke the function?: `foo() as i32`
+
+error: casting function pointer `foo` to `i64`
+  --> $DIR/fn_to_numeric_cast_any.rs:26:13
+   |
+LL |     let _ = foo as i64;
+   |             ^^^^^^^^^^ help: did you mean to invoke the function?: `foo() as i64`
+
+error: casting function pointer `foo` to `i128`
+  --> $DIR/fn_to_numeric_cast_any.rs:27:13
+   |
+LL |     let _ = foo as i128;
+   |             ^^^^^^^^^^^ help: did you mean to invoke the function?: `foo() as i128`
+
+error: casting function pointer `foo` to `isize`
+  --> $DIR/fn_to_numeric_cast_any.rs:28:13
+   |
+LL |     let _ = foo as isize;
+   |             ^^^^^^^^^^^^ help: did you mean to invoke the function?: `foo() as isize`
+
+error: casting function pointer `foo` to `u8`
+  --> $DIR/fn_to_numeric_cast_any.rs:30:13
+   |
+LL |     let _ = foo as u8;
+   |             ^^^^^^^^^ help: did you mean to invoke the function?: `foo() as u8`
+
+error: casting function pointer `foo` to `u16`
+  --> $DIR/fn_to_numeric_cast_any.rs:31:13
+   |
+LL |     let _ = foo as u16;
+   |             ^^^^^^^^^^ help: did you mean to invoke the function?: `foo() as u16`
+
+error: casting function pointer `foo` to `u32`
+  --> $DIR/fn_to_numeric_cast_any.rs:32:13
+   |
+LL |     let _ = foo as u32;
+   |             ^^^^^^^^^^ help: did you mean to invoke the function?: `foo() as u32`
+
+error: casting function pointer `foo` to `u64`
+  --> $DIR/fn_to_numeric_cast_any.rs:33:13
+   |
+LL |     let _ = foo as u64;
+   |             ^^^^^^^^^^ help: did you mean to invoke the function?: `foo() as u64`
+
+error: casting function pointer `foo` to `u128`
+  --> $DIR/fn_to_numeric_cast_any.rs:34:13
+   |
+LL |     let _ = foo as u128;
+   |             ^^^^^^^^^^^ help: did you mean to invoke the function?: `foo() as u128`
+
+error: casting function pointer `foo` to `usize`
+  --> $DIR/fn_to_numeric_cast_any.rs:35:13
+   |
+LL |     let _ = foo as usize;
+   |             ^^^^^^^^^^^^ help: did you mean to invoke the function?: `foo() as usize`
+
+error: casting function pointer `Struct::static_method` to `usize`
+  --> $DIR/fn_to_numeric_cast_any.rs:39:13
+   |
+LL |     let _ = Struct::static_method as usize;
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: did you mean to invoke the function?: `Struct::static_method() as usize`
+
+error: casting function pointer `f` to `usize`
+  --> $DIR/fn_to_numeric_cast_any.rs:43:5
+   |
+LL |     f as usize
+   |     ^^^^^^^^^^ help: did you mean to invoke the function?: `f() as usize`
+
+error: casting function pointer `T::static_method` to `usize`
+  --> $DIR/fn_to_numeric_cast_any.rs:47:5
+   |
+LL |     T::static_method as usize
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^ help: did you mean to invoke the function?: `T::static_method() as usize`
+
+error: casting function pointer `(clos as fn(u32) -> u32)` to `usize`
+  --> $DIR/fn_to_numeric_cast_any.rs:53:13
+   |
+LL |     let _ = (clos as fn(u32) -> u32) as usize;
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: did you mean to invoke the function?: `(clos as fn(u32) -> u32)() as usize`
+
+error: casting function pointer `foo` to `*const ()`
+  --> $DIR/fn_to_numeric_cast_any.rs:57:13
+   |
+LL |     let _ = foo as *const ();
+   |             ^^^^^^^^^^^^^^^^ help: did you mean to invoke the function?: `foo() as *const ()`
+
+error: aborting due to 17 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 412b862fba9df1219ab4fb5bd5a096bfbdaa37d2 Mon Sep 17 00:00:00 2001
From: Serial <69764315+Serial-ATA@users.noreply.github.com>
Date: Fri, 1 Oct 2021 23:25:48 -0400
Subject: Add undocumented_unsafe_blocks lint

---
 CHANGELOG.md                                   |   1 +
 clippy_lints/src/lib.register_lints.rs         |   1 +
 clippy_lints/src/lib.register_restriction.rs   |   1 +
 clippy_lints/src/lib.rs                        |   2 +
 clippy_lints/src/undocumented_unsafe_blocks.rs | 225 +++++++++++++++++++
 tests/ui/undocumented_unsafe_blocks.rs         | 287 +++++++++++++++++++++++++
 tests/ui/undocumented_unsafe_blocks.stderr     | 159 ++++++++++++++
 7 files changed, 676 insertions(+)
 create mode 100644 clippy_lints/src/undocumented_unsafe_blocks.rs
 create mode 100644 tests/ui/undocumented_unsafe_blocks.rs
 create mode 100644 tests/ui/undocumented_unsafe_blocks.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index b13a5d76002..13067e4e92a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3033,6 +3033,7 @@ Released 2018-09-13
 [`try_err`]: https://rust-lang.github.io/rust-clippy/master/index.html#try_err
 [`type_complexity`]: https://rust-lang.github.io/rust-clippy/master/index.html#type_complexity
 [`type_repetition_in_bounds`]: https://rust-lang.github.io/rust-clippy/master/index.html#type_repetition_in_bounds
+[`undocumented_unsafe_blocks`]: https://rust-lang.github.io/rust-clippy/master/index.html#undocumented_unsafe_blocks
 [`undropped_manually_drops`]: https://rust-lang.github.io/rust-clippy/master/index.html#undropped_manually_drops
 [`unicode_not_nfc`]: https://rust-lang.github.io/rust-clippy/master/index.html#unicode_not_nfc
 [`unimplemented`]: https://rust-lang.github.io/rust-clippy/master/index.html#unimplemented
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 3c6d8103b6d..3c4b720671a 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -465,6 +465,7 @@ store.register_lints(&[
     types::REDUNDANT_ALLOCATION,
     types::TYPE_COMPLEXITY,
     types::VEC_BOX,
+    undocumented_unsafe_blocks::UNDOCUMENTED_UNSAFE_BLOCKS,
     undropped_manually_drops::UNDROPPED_MANUALLY_DROPS,
     unicode::INVISIBLE_CHARACTERS,
     unicode::NON_ASCII_LITERAL,
diff --git a/clippy_lints/src/lib.register_restriction.rs b/clippy_lints/src/lib.register_restriction.rs
index 503f4f64a0e..3d68a6e9009 100644
--- a/clippy_lints/src/lib.register_restriction.rs
+++ b/clippy_lints/src/lib.register_restriction.rs
@@ -57,6 +57,7 @@ store.register_group(true, "clippy::restriction", Some("clippy_restriction"), ve
     LintId::of(strings::STR_TO_STRING),
     LintId::of(types::RC_BUFFER),
     LintId::of(types::RC_MUTEX),
+    LintId::of(undocumented_unsafe_blocks::UNDOCUMENTED_UNSAFE_BLOCKS),
     LintId::of(unnecessary_self_imports::UNNECESSARY_SELF_IMPORTS),
     LintId::of(unwrap_in_result::UNWRAP_IN_RESULT),
     LintId::of(verbose_file_reads::VERBOSE_FILE_READS),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 9fc6a9e0ccc..7e1bcbbd0ed 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -358,6 +358,7 @@ mod transmute;
 mod transmuting_null;
 mod try_err;
 mod types;
+mod undocumented_unsafe_blocks;
 mod undropped_manually_drops;
 mod unicode;
 mod unit_return_expecting_ord;
@@ -769,6 +770,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(move || Box::new(if_then_panic::IfThenPanic));
     let enable_raw_pointer_heuristic_for_send = conf.enable_raw_pointer_heuristic_for_send;
     store.register_late_pass(move || Box::new(non_send_fields_in_send_ty::NonSendFieldInSendTy::new(enable_raw_pointer_heuristic_for_send)));
+    store.register_late_pass(move || Box::new(undocumented_unsafe_blocks::UndocumentedUnsafeBlocks::default()));
 }
 
 #[rustfmt::skip]
diff --git a/clippy_lints/src/undocumented_unsafe_blocks.rs b/clippy_lints/src/undocumented_unsafe_blocks.rs
new file mode 100644
index 00000000000..e08e4d03c7e
--- /dev/null
+++ b/clippy_lints/src/undocumented_unsafe_blocks.rs
@@ -0,0 +1,225 @@
+use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg};
+use clippy_utils::source::{indent_of, reindent_multiline, snippet};
+use clippy_utils::{in_macro, is_lint_allowed};
+use rustc_errors::Applicability;
+use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
+use rustc_hir::{Block, BlockCheckMode, Expr, ExprKind, HirId, Local, UnsafeSource};
+use rustc_lexer::TokenKind;
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::hir::map::Map;
+use rustc_middle::lint::in_external_macro;
+use rustc_middle::ty::TyCtxt;
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::{BytePos, Span};
+use std::borrow::Cow;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `unsafe` blocks without a `// Safety: ` comment
+    /// explaining why the unsafe operations performed inside
+    /// the block are safe.
+    ///
+    /// ### Why is this bad?
+    /// Undocumented unsafe blocks can make it difficult to
+    /// read and maintain code, as well as uncover unsoundness
+    /// and bugs.
+    ///
+    /// ### Example
+    /// ```rust
+    /// use std::ptr::NonNull;
+    /// let a = &mut 42;
+    ///
+    /// let ptr = unsafe { NonNull::new_unchecked(a) };
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// use std::ptr::NonNull;
+    /// let a = &mut 42;
+    ///
+    /// // Safety: references are guaranteed to be non-null.
+    /// let ptr = unsafe { NonNull::new_unchecked(a) };
+    /// ```
+    pub UNDOCUMENTED_UNSAFE_BLOCKS,
+    restriction,
+    "creating an unsafe block without explaining why it is safe"
+}
+
+impl_lint_pass!(UndocumentedUnsafeBlocks => [UNDOCUMENTED_UNSAFE_BLOCKS]);
+
+#[derive(Default)]
+pub struct UndocumentedUnsafeBlocks {
+    pub local_level: u32,
+    pub local_span: Option<Span>,
+    // The local was already checked for an overall safety comment
+    // There is no need to continue checking the blocks in the local
+    pub local_checked: bool,
+    // Since we can only check the blocks from expanded macros
+    // We have to omit the suggestion due to the actual definition
+    // Not being available to us
+    pub macro_expansion: bool,
+}
+
+impl LateLintPass<'_> for UndocumentedUnsafeBlocks {
+    fn check_block(&mut self, cx: &LateContext<'_>, block: &'_ Block<'_>) {
+        if_chain! {
+            if !self.local_checked;
+            if !is_lint_allowed(cx, UNDOCUMENTED_UNSAFE_BLOCKS, block.hir_id);
+            if !in_external_macro(cx.tcx.sess, block.span);
+            if let BlockCheckMode::UnsafeBlock(UnsafeSource::UserProvided) = block.rules;
+            if let Some(enclosing_scope_hir_id) = cx.tcx.hir().get_enclosing_scope(block.hir_id);
+            if self.block_has_safety_comment(cx.tcx, enclosing_scope_hir_id, block.span) == Some(false);
+            then {
+                let mut span = block.span;
+
+                if let Some(local_span) = self.local_span {
+                    span = local_span;
+
+                    let result = self.block_has_safety_comment(cx.tcx, enclosing_scope_hir_id, span);
+
+                    if result.unwrap_or(true) {
+                        self.local_checked = true;
+                        return;
+                    }
+                }
+
+                self.lint(cx, span);
+            }
+        }
+    }
+
+    fn check_local(&mut self, cx: &LateContext<'_>, local: &'_ Local<'_>) {
+        if_chain! {
+            if !is_lint_allowed(cx, UNDOCUMENTED_UNSAFE_BLOCKS, local.hir_id);
+            if !in_external_macro(cx.tcx.sess, local.span);
+            if let Some(init) = local.init;
+            then {
+                self.visit_expr(init);
+
+                if self.local_level > 0 {
+                    self.local_span = Some(local.span);
+                }
+            }
+        }
+    }
+
+    fn check_block_post(&mut self, _: &LateContext<'_>, _: &'_ Block<'_>) {
+        self.local_level = self.local_level.saturating_sub(1);
+
+        if self.local_level == 0 {
+            self.local_checked = false;
+            self.local_span = None;
+        }
+    }
+}
+
+impl<'hir> Visitor<'hir> for UndocumentedUnsafeBlocks {
+    type Map = Map<'hir>;
+
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::None
+    }
+
+    fn visit_expr(&mut self, ex: &'v Expr<'v>) {
+        match ex.kind {
+            ExprKind::Block(_, _) => self.local_level = self.local_level.saturating_add(1),
+            _ => walk_expr(self, ex),
+        }
+    }
+}
+
+impl UndocumentedUnsafeBlocks {
+    fn block_has_safety_comment(&mut self, tcx: TyCtxt<'_>, enclosing_hir_id: HirId, block_span: Span) -> Option<bool> {
+        let map = tcx.hir();
+        let source_map = tcx.sess.source_map();
+
+        let enclosing_scope_span = map.opt_span(enclosing_hir_id)?;
+
+        let between_span = if in_macro(block_span) {
+            self.macro_expansion = true;
+            enclosing_scope_span.with_hi(block_span.hi())
+        } else {
+            self.macro_expansion = false;
+            enclosing_scope_span.to(block_span)
+        };
+
+        let file_name = source_map.span_to_filename(between_span);
+        let source_file = source_map.get_source_file(&file_name)?;
+
+        let lex_start = (between_span.lo().0 + 1) as usize;
+        let src_str = source_file.src.as_ref()?[lex_start..between_span.hi().0 as usize].to_string();
+
+        let mut pos = 0;
+        let mut comment = false;
+
+        for token in rustc_lexer::tokenize(&src_str) {
+            match token.kind {
+                TokenKind::LineComment { doc_style: None }
+                | TokenKind::BlockComment {
+                    doc_style: None,
+                    terminated: true,
+                } => {
+                    let comment_str = src_str[pos + 2..pos + token.len].to_ascii_uppercase();
+
+                    if comment_str.contains("SAFETY:") {
+                        comment = true;
+                    }
+                },
+                // We need to add all whitespace to `pos` before checking the comment's line number
+                TokenKind::Whitespace => {},
+                _ => {
+                    if comment {
+                        // Get the line number of the "comment" (really wherever the trailing whitespace ended)
+                        let comment_line_num = source_file
+                            .lookup_file_pos_with_col_display(BytePos((lex_start + pos).try_into().unwrap()))
+                            .0;
+                        // Find the block/local's line number
+                        let block_line_num = tcx.sess.source_map().lookup_char_pos(block_span.lo()).line;
+
+                        // Check the comment is immediately followed by the block/local
+                        if block_line_num == comment_line_num + 1 || block_line_num == comment_line_num {
+                            return Some(true);
+                        }
+
+                        comment = false;
+                    }
+                },
+            }
+
+            pos += token.len;
+        }
+
+        Some(false)
+    }
+
+    fn lint(&self, cx: &LateContext<'_>, mut span: Span) {
+        let source_map = cx.tcx.sess.source_map();
+
+        if source_map.is_multiline(span) {
+            span = source_map.span_until_char(span, '\n');
+        }
+
+        if self.macro_expansion {
+            span_lint_and_help(
+                cx,
+                UNDOCUMENTED_UNSAFE_BLOCKS,
+                span,
+                "unsafe block in macro expansion missing a safety comment",
+                None,
+                "consider adding a safety comment in the macro definition",
+            );
+        } else {
+            let block_indent = indent_of(cx, span);
+            let suggestion = format!("// Safety: ...\n{}", snippet(cx, span, ".."));
+
+            span_lint_and_sugg(
+                cx,
+                UNDOCUMENTED_UNSAFE_BLOCKS,
+                span,
+                "unsafe block missing a safety comment",
+                "consider adding a safety comment",
+                reindent_multiline(Cow::Borrowed(&suggestion), true, block_indent).to_string(),
+                Applicability::HasPlaceholders,
+            );
+        }
+    }
+}
diff --git a/tests/ui/undocumented_unsafe_blocks.rs b/tests/ui/undocumented_unsafe_blocks.rs
new file mode 100644
index 00000000000..52577323a58
--- /dev/null
+++ b/tests/ui/undocumented_unsafe_blocks.rs
@@ -0,0 +1,287 @@
+#![warn(clippy::undocumented_unsafe_blocks)]
+
+// Valid comments
+
+fn nested_local() {
+    let _ = {
+        let _ = {
+            // Safety:
+            let _ = unsafe {};
+        };
+    };
+}
+
+fn deep_nest() {
+    let _ = {
+        let _ = {
+            // Safety:
+            let _ = unsafe {};
+
+            // Safety:
+            unsafe {};
+
+            let _ = {
+                let _ = {
+                    let _ = {
+                        let _ = {
+                            let _ = {
+                                // Safety:
+                                let _ = unsafe {};
+
+                                // Safety:
+                                unsafe {};
+                            };
+                        };
+                    };
+
+                    // Safety:
+                    unsafe {};
+                };
+            };
+        };
+
+        // Safety:
+        unsafe {};
+    };
+
+    // Safety:
+    unsafe {};
+}
+
+fn local_tuple_expression() {
+    // Safety:
+    let _ = (42, unsafe {});
+}
+
+fn line_comment() {
+    // Safety:
+    unsafe {}
+}
+
+fn line_comment_newlines() {
+    // Safety:
+
+    unsafe {}
+}
+
+fn line_comment_empty() {
+    // Safety:
+    //
+    //
+    //
+    unsafe {}
+}
+
+fn line_comment_with_extras() {
+    // This is a description
+    // Safety:
+    unsafe {}
+}
+
+fn block_comment() {
+    /* Safety: */
+    unsafe {}
+}
+
+fn block_comment_newlines() {
+    /* Safety: */
+
+    unsafe {}
+}
+
+#[rustfmt::skip]
+fn inline_block_comment() {
+    /* Safety: */unsafe {}
+}
+
+fn block_comment_with_extras() {
+    /* This is a description
+     * Safety:
+     */
+    unsafe {}
+}
+
+fn block_comment_terminator_same_line() {
+    /* This is a description
+     * Safety: */
+    unsafe {}
+}
+
+fn buried_safety() {
+    // Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor
+    // incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation
+    // ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in
+    // reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint
+    // occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est
+    // laborum. Safety:
+    // Tellus elementum sagittis vitae et leo duis ut diam quam. Sit amet nulla facilisi
+    // morbi tempus iaculis urna. Amet luctus venenatis lectus magna. At quis risus sed vulputate odio
+    // ut. Luctus venenatis lectus magna fringilla urna. Tortor id aliquet lectus proin nibh nisl
+    // condimentum id venenatis. Vulputate dignissim suspendisse in est ante in nibh mauris cursus.
+    unsafe {}
+}
+
+fn safety_with_prepended_text() {
+    // This is a test. Safety:
+    unsafe {}
+}
+
+fn local_line_comment() {
+    // Safety:
+    let _ = unsafe {};
+}
+
+fn local_block_comment() {
+    /* Safety: */
+    let _ = unsafe {};
+}
+
+fn comment_array() {
+    // Safety:
+    let _ = [unsafe { 14 }, unsafe { 15 }, 42, unsafe { 16 }];
+}
+
+fn comment_tuple() {
+    // Safety:
+    let _ = (42, unsafe {}, "test", unsafe {});
+}
+
+fn comment_unary() {
+    // Safety:
+    let _ = *unsafe { &42 };
+}
+
+#[allow(clippy::match_single_binding)]
+fn comment_match() {
+    // Safety:
+    let _ = match unsafe {} {
+        _ => {},
+    };
+}
+
+fn comment_addr_of() {
+    // Safety:
+    let _ = &unsafe {};
+}
+
+fn comment_repeat() {
+    // Safety:
+    let _ = [unsafe {}; 5];
+}
+
+fn comment_macro_call() {
+    macro_rules! t {
+        ($b:expr) => {
+            $b
+        };
+    }
+
+    t!(
+        // Safety:
+        unsafe {}
+    );
+}
+
+fn comment_macro_def() {
+    macro_rules! t {
+        () => {
+            // Safety:
+            unsafe {}
+        };
+    }
+
+    t!();
+}
+
+fn non_ascii_comment() {
+    // ॐ᧻໒ Safety: ௵∰
+    unsafe {};
+}
+
+fn local_commented_block() {
+    let _ =
+        // Safety:
+        unsafe {};
+}
+
+fn local_nest() {
+    // Safety:
+    let _ = [(42, unsafe {}, unsafe {}), (52, unsafe {}, unsafe {})];
+}
+
+// Invalid comments
+
+fn no_comment() {
+    unsafe {}
+}
+
+fn no_comment_array() {
+    let _ = [unsafe { 14 }, unsafe { 15 }, 42, unsafe { 16 }];
+}
+
+fn no_comment_tuple() {
+    let _ = (42, unsafe {}, "test", unsafe {});
+}
+
+fn no_comment_unary() {
+    let _ = *unsafe { &42 };
+}
+
+#[allow(clippy::match_single_binding)]
+fn no_comment_match() {
+    let _ = match unsafe {} {
+        _ => {},
+    };
+}
+
+fn no_comment_addr_of() {
+    let _ = &unsafe {};
+}
+
+fn no_comment_repeat() {
+    let _ = [unsafe {}; 5];
+}
+
+fn local_no_comment() {
+    let _ = unsafe {};
+}
+
+fn no_comment_macro_call() {
+    macro_rules! t {
+        ($b:expr) => {
+            $b
+        };
+    }
+
+    t!(unsafe {});
+}
+
+fn no_comment_macro_def() {
+    macro_rules! t {
+        () => {
+            unsafe {}
+        };
+    }
+
+    t!();
+}
+
+fn trailing_comment() {
+    unsafe {} // Safety:
+}
+
+fn internal_comment() {
+    unsafe {
+        // Safety:
+    }
+}
+
+fn interference() {
+    // Safety
+
+    let _ = 42;
+
+    unsafe {};
+}
+
+fn main() {}
diff --git a/tests/ui/undocumented_unsafe_blocks.stderr b/tests/ui/undocumented_unsafe_blocks.stderr
new file mode 100644
index 00000000000..b32069a334c
--- /dev/null
+++ b/tests/ui/undocumented_unsafe_blocks.stderr
@@ -0,0 +1,159 @@
+error: unsafe block missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:215:5
+   |
+LL |     unsafe {}
+   |     ^^^^^^^^^
+   |
+   = note: `-D clippy::undocumented-unsafe-blocks` implied by `-D warnings`
+help: consider adding a safety comment
+   |
+LL ~     // Safety: ...
+LL +     unsafe {}
+   |
+
+error: unsafe block missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:219:5
+   |
+LL |     let _ = [unsafe { 14 }, unsafe { 15 }, 42, unsafe { 16 }];
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider adding a safety comment
+   |
+LL ~     // Safety: ...
+LL +     let _ = [unsafe { 14 }, unsafe { 15 }, 42, unsafe { 16 }];
+   |
+
+error: unsafe block missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:223:5
+   |
+LL |     let _ = (42, unsafe {}, "test", unsafe {});
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider adding a safety comment
+   |
+LL ~     // Safety: ...
+LL +     let _ = (42, unsafe {}, "test", unsafe {});
+   |
+
+error: unsafe block missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:227:5
+   |
+LL |     let _ = *unsafe { &42 };
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider adding a safety comment
+   |
+LL ~     // Safety: ...
+LL +     let _ = *unsafe { &42 };
+   |
+
+error: unsafe block missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:232:5
+   |
+LL |     let _ = match unsafe {} {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider adding a safety comment
+   |
+LL ~     // Safety: ...
+LL +     let _ = match unsafe {} {
+   |
+
+error: unsafe block missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:238:5
+   |
+LL |     let _ = &unsafe {};
+   |     ^^^^^^^^^^^^^^^^^^^
+   |
+help: consider adding a safety comment
+   |
+LL ~     // Safety: ...
+LL +     let _ = &unsafe {};
+   |
+
+error: unsafe block missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:242:5
+   |
+LL |     let _ = [unsafe {}; 5];
+   |     ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider adding a safety comment
+   |
+LL ~     // Safety: ...
+LL +     let _ = [unsafe {}; 5];
+   |
+
+error: unsafe block missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:246:5
+   |
+LL |     let _ = unsafe {};
+   |     ^^^^^^^^^^^^^^^^^^
+   |
+help: consider adding a safety comment
+   |
+LL ~     // Safety: ...
+LL +     let _ = unsafe {};
+   |
+
+error: unsafe block missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:256:8
+   |
+LL |     t!(unsafe {});
+   |        ^^^^^^^^^
+   |
+help: consider adding a safety comment
+   |
+LL ~     t!(// Safety: ...
+LL ~     unsafe {});
+   |
+
+error: unsafe block in macro expansion missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:262:13
+   |
+LL |             unsafe {}
+   |             ^^^^^^^^^
+...
+LL |     t!();
+   |     ----- in this macro invocation
+   |
+   = help: consider adding a safety comment in the macro definition
+   = note: this error originates in the macro `t` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: unsafe block missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:270:5
+   |
+LL |     unsafe {} // Safety:
+   |     ^^^^^^^^^
+   |
+help: consider adding a safety comment
+   |
+LL ~     // Safety: ...
+LL ~     unsafe {} // Safety:
+   |
+
+error: unsafe block missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:274:5
+   |
+LL |     unsafe {
+   |     ^^^^^^^^
+   |
+help: consider adding a safety comment
+   |
+LL ~     // Safety: ...
+LL +     unsafe {
+   |
+
+error: unsafe block missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:284:5
+   |
+LL |     unsafe {};
+   |     ^^^^^^^^^
+   |
+help: consider adding a safety comment
+   |
+LL ~     // Safety: ...
+LL ~     unsafe {};
+   |
+
+error: aborting due to 13 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 28fb591b6e681493b6ba3917146fbfe410dd45d0 Mon Sep 17 00:00:00 2001
From: flip1995 <philipp.krones@embecosm.com>
Date: Fri, 8 Oct 2021 15:26:10 +0200
Subject: Do not expand macros in equatable_if_let suggestion

---
 clippy_lints/src/equatable_if_let.rs | 8 ++++----
 tests/ui/equatable_if_let.fixed      | 9 +++++++++
 tests/ui/equatable_if_let.rs         | 9 +++++++++
 tests/ui/equatable_if_let.stderr     | 8 +++++++-
 4 files changed, 29 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/equatable_if_let.rs b/clippy_lints/src/equatable_if_let.rs
index 0c6ba91c943..e8b1d6f6eda 100644
--- a/clippy_lints/src/equatable_if_let.rs
+++ b/clippy_lints/src/equatable_if_let.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::source::snippet_with_context;
 use clippy_utils::ty::implements_trait;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
@@ -77,9 +77,9 @@ impl<'tcx> LateLintPass<'tcx> for PatternEquality {
                 let pat_str = match pat.kind {
                     PatKind::Struct(..) => format!(
                         "({})",
-                        snippet_with_applicability(cx, pat.span, "..", &mut applicability),
+                        snippet_with_context(cx, pat.span, expr.span.ctxt(), "..", &mut applicability).0,
                     ),
-                    _ => snippet_with_applicability(cx, pat.span, "..", &mut applicability).to_string(),
+                    _ => snippet_with_context(cx, pat.span, expr.span.ctxt(), "..", &mut applicability).0.to_string(),
                 };
                 span_lint_and_sugg(
                     cx,
@@ -89,7 +89,7 @@ impl<'tcx> LateLintPass<'tcx> for PatternEquality {
                     "try",
                     format!(
                         "{} == {}",
-                        snippet_with_applicability(cx, exp.span, "..", &mut applicability),
+                        snippet_with_context(cx, exp.span, expr.span.ctxt(), "..", &mut applicability).0,
                         pat_str,
                     ),
                     applicability,
diff --git a/tests/ui/equatable_if_let.fixed b/tests/ui/equatable_if_let.fixed
index ba72cc237b4..88918d9671e 100644
--- a/tests/ui/equatable_if_let.fixed
+++ b/tests/ui/equatable_if_let.fixed
@@ -66,4 +66,13 @@ fn main() {
     if g == NotStructuralEq::A {}
     if let Some(NotPartialEq::A) = Some(f) {}
     if Some(g) == Some(NotStructuralEq::A) {}
+
+    macro_rules! m1 {
+        (x) => {
+            "abc"
+        };
+    }
+    if "abc" == m1!(x) {
+        println!("OK");
+    }
 }
diff --git a/tests/ui/equatable_if_let.rs b/tests/ui/equatable_if_let.rs
index 12526ca193d..9a7ab75ef45 100644
--- a/tests/ui/equatable_if_let.rs
+++ b/tests/ui/equatable_if_let.rs
@@ -66,4 +66,13 @@ fn main() {
     if let NotStructuralEq::A = g {}
     if let Some(NotPartialEq::A) = Some(f) {}
     if let Some(NotStructuralEq::A) = Some(g) {}
+
+    macro_rules! m1 {
+        (x) => {
+            "abc"
+        };
+    }
+    if let m1!(x) = "abc" {
+        println!("OK");
+    }
 }
diff --git a/tests/ui/equatable_if_let.stderr b/tests/ui/equatable_if_let.stderr
index 79ef919384d..760ff88f448 100644
--- a/tests/ui/equatable_if_let.stderr
+++ b/tests/ui/equatable_if_let.stderr
@@ -60,5 +60,11 @@ error: this pattern matching can be expressed using equality
 LL |     if let Some(NotStructuralEq::A) = Some(g) {}
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Some(g) == Some(NotStructuralEq::A)`
 
-error: aborting due to 10 previous errors
+error: this pattern matching can be expressed using equality
+  --> $DIR/equatable_if_let.rs:75:8
+   |
+LL |     if let m1!(x) = "abc" {
+   |        ^^^^^^^^^^^^^^^^^^ help: try: `"abc" == m1!(x)`
+
+error: aborting due to 11 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From b423b85ca99c2a085797e228ec405038bbd3308f Mon Sep 17 00:00:00 2001
From: flip1995 <philipp.krones@embecosm.com>
Date: Fri, 8 Oct 2021 16:16:56 +0200
Subject: Don't trigger semicolon_if_nothing_returned in expanded code

Before this lint didn't trigger on macros. With rust-lang/rust#88175
this isn't enough anymore. In this PR a `WhileLoop` desugaring kind was
introduced. This overrides the span of expanded expressions when
lowering the while loop. So if a while loop is in a macro, the
expressions that it expands to are no longer marked with
`ExpnKind::Macro`, but with `ExpnKind::Desugaring`. In general, this is
the correct behavior and the same that is done for `ForLoop`s. It just
tripped up this lint.
---
 clippy_lints/src/semicolon_if_nothing_returned.rs |  4 ++--
 tests/ui/semicolon_if_nothing_returned.rs         | 12 ++++++++++++
 2 files changed, 14 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/semicolon_if_nothing_returned.rs b/clippy_lints/src/semicolon_if_nothing_returned.rs
index 6966230156c..c0e4914efe0 100644
--- a/clippy_lints/src/semicolon_if_nothing_returned.rs
+++ b/clippy_lints/src/semicolon_if_nothing_returned.rs
@@ -1,7 +1,7 @@
 use crate::rustc_lint::LintContext;
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_macro_callsite;
-use clippy_utils::{in_macro, sugg};
+use clippy_utils::sugg;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Block, ExprKind};
@@ -39,7 +39,7 @@ declare_lint_pass!(SemicolonIfNothingReturned => [SEMICOLON_IF_NOTHING_RETURNED]
 impl LateLintPass<'_> for SemicolonIfNothingReturned {
     fn check_block(&mut self, cx: &LateContext<'tcx>, block: &'tcx Block<'tcx>) {
         if_chain! {
-            if !in_macro(block.span);
+            if !block.span.from_expansion();
             if let Some(expr) = block.expr;
             let t_expr = cx.typeck_results().expr_ty(expr);
             if t_expr.is_unit();
diff --git a/tests/ui/semicolon_if_nothing_returned.rs b/tests/ui/semicolon_if_nothing_returned.rs
index 9644a232968..7a45f1b18d4 100644
--- a/tests/ui/semicolon_if_nothing_returned.rs
+++ b/tests/ui/semicolon_if_nothing_returned.rs
@@ -98,3 +98,15 @@ fn unsafe_checks() {
     let mut s = MaybeUninit::<String>::uninit();
     let _d = || unsafe { ptr::drop_in_place(s.as_mut_ptr()) };
 }
+
+// Issue #7768
+#[rustfmt::skip]
+fn macro_with_semicolon() {
+    macro_rules! repro {
+        () => {
+            while false {
+            }
+        };
+    }
+    repro!();
+}
-- 
cgit 1.4.1-3-g733a5


From 72078faf9122e99f496f3f868d5e4ff59cfa0b00 Mon Sep 17 00:00:00 2001
From: James Hinshelwood <jameshinshelwood1@gmail.com>
Date: Fri, 8 Oct 2021 20:45:44 +0100
Subject: Allow giving reasons for `disallowed_types`

Co-authored-by: James Hinshelwood <james.hinshelwood@bigpayme.com>
---
 clippy_lints/src/disallowed_type.rs                | 59 +++++++++++++---------
 clippy_lints/src/lib.rs                            |  4 +-
 clippy_lints/src/utils/conf.rs                     | 10 +++-
 tests/ui-toml/toml_disallowed_type/clippy.toml     |  6 ++-
 .../toml_disallowed_type/conf_disallowed_type.rs   |  4 ++
 .../conf_disallowed_type.stderr                    | 34 +++++++++----
 6 files changed, 79 insertions(+), 38 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/disallowed_type.rs b/clippy_lints/src/disallowed_type.rs
index 87124f093a8..261e9af11c8 100644
--- a/clippy_lints/src/disallowed_type.rs
+++ b/clippy_lints/src/disallowed_type.rs
@@ -1,12 +1,14 @@
-use clippy_utils::diagnostics::span_lint;
+use clippy_utils::diagnostics::span_lint_and_then;
 
-use rustc_data_structures::fx::FxHashSet;
+use rustc_data_structures::fx::FxHashMap;
 use rustc_hir::{
     def::Res, def_id::DefId, Item, ItemKind, PolyTraitRef, PrimTy, TraitBoundModifier, Ty, TyKind, UseKind,
 };
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::{Span, Symbol};
+use rustc_span::Span;
+
+use crate::utils::conf;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -38,33 +40,30 @@ declare_clippy_lint! {
 }
 #[derive(Clone, Debug)]
 pub struct DisallowedType {
-    disallowed: FxHashSet<Vec<Symbol>>,
-    def_ids: FxHashSet<DefId>,
-    prim_tys: FxHashSet<PrimTy>,
+    disallowed: Vec<conf::DisallowedType>,
+    def_ids: FxHashMap<DefId, Option<String>>,
+    prim_tys: FxHashMap<PrimTy, Option<String>>,
 }
 
 impl DisallowedType {
-    pub fn new(disallowed: &FxHashSet<String>) -> Self {
+    pub fn new(disallowed: Vec<conf::DisallowedType>) -> Self {
         Self {
-            disallowed: disallowed
-                .iter()
-                .map(|s| s.split("::").map(Symbol::intern).collect::<Vec<_>>())
-                .collect(),
-            def_ids: FxHashSet::default(),
-            prim_tys: FxHashSet::default(),
+            disallowed,
+            def_ids: FxHashMap::default(),
+            prim_tys: FxHashMap::default(),
         }
     }
 
     fn check_res_emit(&self, cx: &LateContext<'_>, res: &Res, span: Span) {
         match res {
             Res::Def(_, did) => {
-                if self.def_ids.contains(did) {
-                    emit(cx, &cx.tcx.def_path_str(*did), span);
+                if let Some(reason) = self.def_ids.get(did) {
+                    emit(cx, &cx.tcx.def_path_str(*did), span, reason.as_deref());
                 }
             },
             Res::PrimTy(prim) => {
-                if self.prim_tys.contains(prim) {
-                    emit(cx, prim.name_str(), span);
+                if let Some(reason) = self.prim_tys.get(prim) {
+                    emit(cx, prim.name_str(), span, reason.as_deref());
                 }
             },
             _ => {},
@@ -76,14 +75,21 @@ impl_lint_pass!(DisallowedType => [DISALLOWED_TYPE]);
 
 impl<'tcx> LateLintPass<'tcx> for DisallowedType {
     fn check_crate(&mut self, cx: &LateContext<'_>) {
-        for path in &self.disallowed {
-            let segs = path.iter().map(ToString::to_string).collect::<Vec<_>>();
-            match clippy_utils::path_to_res(cx, &segs.iter().map(String::as_str).collect::<Vec<_>>()) {
+        for conf in &self.disallowed {
+            let (path, reason) = match conf {
+                conf::DisallowedType::Simple(path) => (path, None),
+                conf::DisallowedType::WithReason { path, reason } => (
+                    path,
+                    reason.as_ref().map(|reason| format!("{} (from clippy.toml)", reason)),
+                ),
+            };
+            let segs: Vec<_> = path.split("::").collect();
+            match clippy_utils::path_to_res(cx, &segs) {
                 Res::Def(_, id) => {
-                    self.def_ids.insert(id);
+                    self.def_ids.insert(id, reason);
                 },
                 Res::PrimTy(ty) => {
-                    self.prim_tys.insert(ty);
+                    self.prim_tys.insert(ty, reason);
                 },
                 _ => {},
             }
@@ -107,11 +113,16 @@ impl<'tcx> LateLintPass<'tcx> for DisallowedType {
     }
 }
 
-fn emit(cx: &LateContext<'_>, name: &str, span: Span) {
-    span_lint(
+fn emit(cx: &LateContext<'_>, name: &str, span: Span, reason: Option<&str>) {
+    span_lint_and_then(
         cx,
         DISALLOWED_TYPE,
         span,
         &format!("`{}` is not allowed according to config", name),
+        |diag| {
+            if let Some(reason) = reason {
+                diag.note(reason);
+            }
+        },
     );
 }
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 7e1bcbbd0ed..8af76cbed6e 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -757,8 +757,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(bool_assert_comparison::BoolAssertComparison));
     store.register_early_pass(move || Box::new(module_style::ModStyle));
     store.register_late_pass(|| Box::new(unused_async::UnusedAsync));
-    let disallowed_types = conf.disallowed_types.iter().cloned().collect::<FxHashSet<_>>();
-    store.register_late_pass(move || Box::new(disallowed_type::DisallowedType::new(&disallowed_types)));
+    let disallowed_types = conf.disallowed_types.clone();
+    store.register_late_pass(move || Box::new(disallowed_type::DisallowedType::new(disallowed_types.clone())));
     let import_renames = conf.enforced_import_renames.clone();
     store.register_late_pass(move || Box::new(missing_enforced_import_rename::ImportRename::new(import_renames.clone())));
     let scripts = conf.allowed_scripts.clone();
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 6cbada4c150..d05c52122d5 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -23,6 +23,14 @@ pub enum DisallowedMethod {
     WithReason { path: String, reason: Option<String> },
 }
 
+/// A single disallowed type, used by the `DISALLOWED_TYPE` lint.
+#[derive(Clone, Debug, Deserialize)]
+#[serde(untagged)]
+pub enum DisallowedType {
+    Simple(String),
+    WithReason { path: String, reason: Option<String> },
+}
+
 /// Conf with parse errors
 #[derive(Default)]
 pub struct TryConf {
@@ -255,7 +263,7 @@ define_Conf! {
     /// Lint: DISALLOWED_TYPE.
     ///
     /// The list of disallowed types, written as fully qualified paths.
-    (disallowed_types: Vec<String> = Vec::new()),
+    (disallowed_types: Vec<crate::utils::conf::DisallowedType> = Vec::new()),
     /// Lint: UNREADABLE_LITERAL.
     ///
     /// Should the fraction of a decimal be linted to include separators.
diff --git a/tests/ui-toml/toml_disallowed_type/clippy.toml b/tests/ui-toml/toml_disallowed_type/clippy.toml
index dac4446703b..6cb9e2ef954 100644
--- a/tests/ui-toml/toml_disallowed_type/clippy.toml
+++ b/tests/ui-toml/toml_disallowed_type/clippy.toml
@@ -7,5 +7,9 @@ disallowed-types = [
     "std::time::Instant",
     "std::io::Read",
     "std::primitive::usize",
-    "bool"
+    "bool",
+    # can give path and reason with an inline table
+    { path = "std::net::Ipv4Addr", reason = "no IPv4 allowed" },
+    # can use an inline table but omit reason
+    { path = "std::net::TcpListener" },
 ]
diff --git a/tests/ui-toml/toml_disallowed_type/conf_disallowed_type.rs b/tests/ui-toml/toml_disallowed_type/conf_disallowed_type.rs
index 0871a3073ab..410f0765055 100644
--- a/tests/ui-toml/toml_disallowed_type/conf_disallowed_type.rs
+++ b/tests/ui-toml/toml_disallowed_type/conf_disallowed_type.rs
@@ -25,6 +25,10 @@ struct GenArg<const U: usize>([u8; U]);
 
 static BAD: foo::atomic::AtomicPtr<()> = foo::atomic::AtomicPtr::new(std::ptr::null_mut());
 
+fn ip(_: std::net::Ipv4Addr) {}
+
+fn listener(_: std::net::TcpListener) {}
+
 #[allow(clippy::diverging_sub_expression)]
 fn main() {
     let _: std::collections::HashMap<(), ()> = std::collections::HashMap::new();
diff --git a/tests/ui-toml/toml_disallowed_type/conf_disallowed_type.stderr b/tests/ui-toml/toml_disallowed_type/conf_disallowed_type.stderr
index 90ce7db2cc4..08a400a8367 100644
--- a/tests/ui-toml/toml_disallowed_type/conf_disallowed_type.stderr
+++ b/tests/ui-toml/toml_disallowed_type/conf_disallowed_type.stderr
@@ -60,59 +60,73 @@ error: `usize` is not allowed according to config
 LL | struct GenArg<const U: usize>([u8; U]);
    |                        ^^^^^
 
+error: `std::net::Ipv4Addr` is not allowed according to config
+  --> $DIR/conf_disallowed_type.rs:28:10
+   |
+LL | fn ip(_: std::net::Ipv4Addr) {}
+   |          ^^^^^^^^^^^^^^^^^^
+   |
+   = note: no IPv4 allowed (from clippy.toml)
+
+error: `std::net::TcpListener` is not allowed according to config
+  --> $DIR/conf_disallowed_type.rs:30:16
+   |
+LL | fn listener(_: std::net::TcpListener) {}
+   |                ^^^^^^^^^^^^^^^^^^^^^
+
 error: `std::collections::HashMap` is not allowed according to config
-  --> $DIR/conf_disallowed_type.rs:30:48
+  --> $DIR/conf_disallowed_type.rs:34:48
    |
 LL |     let _: std::collections::HashMap<(), ()> = std::collections::HashMap::new();
    |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: `std::collections::HashMap` is not allowed according to config
-  --> $DIR/conf_disallowed_type.rs:30:12
+  --> $DIR/conf_disallowed_type.rs:34:12
    |
 LL |     let _: std::collections::HashMap<(), ()> = std::collections::HashMap::new();
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: `std::time::Instant` is not allowed according to config
-  --> $DIR/conf_disallowed_type.rs:31:13
+  --> $DIR/conf_disallowed_type.rs:35:13
    |
 LL |     let _ = Sneaky::now();
    |             ^^^^^^
 
 error: `std::sync::atomic::AtomicU32` is not allowed according to config
-  --> $DIR/conf_disallowed_type.rs:32:13
+  --> $DIR/conf_disallowed_type.rs:36:13
    |
 LL |     let _ = foo::atomic::AtomicU32::new(0);
    |             ^^^^^^^^^^^^^^^^^^^^^^
 
 error: `std::sync::atomic::AtomicU32` is not allowed according to config
-  --> $DIR/conf_disallowed_type.rs:33:17
+  --> $DIR/conf_disallowed_type.rs:37:17
    |
 LL |     static FOO: std::sync::atomic::AtomicU32 = foo::atomic::AtomicU32::new(1);
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: `std::sync::atomic::AtomicU32` is not allowed according to config
-  --> $DIR/conf_disallowed_type.rs:33:48
+  --> $DIR/conf_disallowed_type.rs:37:48
    |
 LL |     static FOO: std::sync::atomic::AtomicU32 = foo::atomic::AtomicU32::new(1);
    |                                                ^^^^^^^^^^^^^^^^^^^^^^
 
 error: `syn::TypePath` is not allowed according to config
-  --> $DIR/conf_disallowed_type.rs:34:43
+  --> $DIR/conf_disallowed_type.rs:38:43
    |
 LL |     let _: std::collections::BTreeMap<(), syn::TypePath> = Default::default();
    |                                           ^^^^^^^^^^^^^
 
 error: `syn::Ident` is not allowed according to config
-  --> $DIR/conf_disallowed_type.rs:35:13
+  --> $DIR/conf_disallowed_type.rs:39:13
    |
 LL |     let _ = syn::Ident::new("", todo!());
    |             ^^^^^^^^^^
 
 error: `usize` is not allowed according to config
-  --> $DIR/conf_disallowed_type.rs:37:12
+  --> $DIR/conf_disallowed_type.rs:41:12
    |
 LL |     let _: usize = 64_usize;
    |            ^^^^^
 
-error: aborting due to 19 previous errors
+error: aborting due to 21 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 452181c69d2a106d9d5a1262b69e68a765c4b3e3 Mon Sep 17 00:00:00 2001
From: Yechan Bae <yechan@gatech.edu>
Date: Fri, 17 Sep 2021 02:55:26 -0400
Subject: Implement uninit_vec lint

---
 CHANGELOG.md                                    |   1 +
 clippy_lints/src/lib.register_all.rs            |   1 +
 clippy_lints/src/lib.register_correctness.rs    |   1 +
 clippy_lints/src/lib.register_lints.rs          |   1 +
 clippy_lints/src/lib.rs                         |   2 +
 clippy_lints/src/methods/uninit_assumed_init.rs |  14 +-
 clippy_lints/src/uninit_vec.rs                  | 174 ++++++++++++++++++++++++
 clippy_utils/src/lib.rs                         |  10 ++
 clippy_utils/src/paths.rs                       |   3 +
 tests/ui/uninit_vec.rs                          |  32 +++++
 tests/ui/uninit_vec.stderr                      |  51 +++++++
 11 files changed, 278 insertions(+), 12 deletions(-)
 create mode 100644 clippy_lints/src/uninit_vec.rs
 create mode 100644 tests/ui/uninit_vec.rs
 create mode 100644 tests/ui/uninit_vec.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 13067e4e92a..2c69432f31c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3038,6 +3038,7 @@ Released 2018-09-13
 [`unicode_not_nfc`]: https://rust-lang.github.io/rust-clippy/master/index.html#unicode_not_nfc
 [`unimplemented`]: https://rust-lang.github.io/rust-clippy/master/index.html#unimplemented
 [`uninit_assumed_init`]: https://rust-lang.github.io/rust-clippy/master/index.html#uninit_assumed_init
+[`uninit_vec`]: https://rust-lang.github.io/rust-clippy/master/index.html#uninit_vec
 [`unit_arg`]: https://rust-lang.github.io/rust-clippy/master/index.html#unit_arg
 [`unit_cmp`]: https://rust-lang.github.io/rust-clippy/master/index.html#unit_cmp
 [`unit_return_expecting_ord`]: https://rust-lang.github.io/rust-clippy/master/index.html#unit_return_expecting_ord
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 3e6e0244754..f0ef0befea0 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -278,6 +278,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(types::VEC_BOX),
     LintId::of(undropped_manually_drops::UNDROPPED_MANUALLY_DROPS),
     LintId::of(unicode::INVISIBLE_CHARACTERS),
+    LintId::of(uninit_vec::UNINIT_VEC),
     LintId::of(unit_return_expecting_ord::UNIT_RETURN_EXPECTING_ORD),
     LintId::of(unit_types::UNIT_ARG),
     LintId::of(unit_types::UNIT_CMP),
diff --git a/clippy_lints/src/lib.register_correctness.rs b/clippy_lints/src/lib.register_correctness.rs
index e0ef7b3b8af..8eb662195e2 100644
--- a/clippy_lints/src/lib.register_correctness.rs
+++ b/clippy_lints/src/lib.register_correctness.rs
@@ -63,6 +63,7 @@ store.register_group(true, "clippy::correctness", Some("clippy_correctness"), ve
     LintId::of(transmuting_null::TRANSMUTING_NULL),
     LintId::of(undropped_manually_drops::UNDROPPED_MANUALLY_DROPS),
     LintId::of(unicode::INVISIBLE_CHARACTERS),
+    LintId::of(uninit_vec::UNINIT_VEC),
     LintId::of(unit_return_expecting_ord::UNIT_RETURN_EXPECTING_ORD),
     LintId::of(unit_types::UNIT_CMP),
     LintId::of(unnamed_address::FN_ADDRESS_COMPARISONS),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 3c4b720671a..401c5b78b38 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -470,6 +470,7 @@ store.register_lints(&[
     unicode::INVISIBLE_CHARACTERS,
     unicode::NON_ASCII_LITERAL,
     unicode::UNICODE_NOT_NFC,
+    uninit_vec::UNINIT_VEC,
     unit_return_expecting_ord::UNIT_RETURN_EXPECTING_ORD,
     unit_types::LET_UNIT_VALUE,
     unit_types::UNIT_ARG,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 7e1bcbbd0ed..829d5acdfde 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -361,6 +361,7 @@ mod types;
 mod undocumented_unsafe_blocks;
 mod undropped_manually_drops;
 mod unicode;
+mod uninit_vec;
 mod unit_return_expecting_ord;
 mod unit_types;
 mod unnamed_address;
@@ -518,6 +519,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(blocks_in_if_conditions::BlocksInIfConditions));
     store.register_late_pass(|| Box::new(collapsible_match::CollapsibleMatch));
     store.register_late_pass(|| Box::new(unicode::Unicode));
+    store.register_late_pass(|| Box::new(uninit_vec::UninitVec));
     store.register_late_pass(|| Box::new(unit_return_expecting_ord::UnitReturnExpectingOrd));
     store.register_late_pass(|| Box::new(strings::StringAdd));
     store.register_late_pass(|| Box::new(implicit_return::ImplicitReturn));
diff --git a/clippy_lints/src/methods/uninit_assumed_init.rs b/clippy_lints/src/methods/uninit_assumed_init.rs
index 1a5894e48d1..dbd91fb6d9d 100644
--- a/clippy_lints/src/methods/uninit_assumed_init.rs
+++ b/clippy_lints/src/methods/uninit_assumed_init.rs
@@ -1,9 +1,8 @@
 use clippy_utils::diagnostics::span_lint;
-use clippy_utils::{is_expr_path_def_path, match_def_path, paths};
+use clippy_utils::{is_expr_path_def_path, is_uninit_ty_valid, paths};
 use if_chain::if_chain;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
-use rustc_middle::ty::{self, Ty};
 
 use super::UNINIT_ASSUMED_INIT;
 
@@ -13,7 +12,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr
         if let hir::ExprKind::Call(callee, args) = recv.kind;
         if args.is_empty();
         if is_expr_path_def_path(cx, callee, &paths::MEM_MAYBEUNINIT_UNINIT);
-        if !is_maybe_uninit_ty_valid(cx, cx.typeck_results().expr_ty_adjusted(expr));
+        if !is_uninit_ty_valid(cx, cx.typeck_results().expr_ty_adjusted(expr));
         then {
             span_lint(
                 cx,
@@ -24,12 +23,3 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr
         }
     }
 }
-
-fn is_maybe_uninit_ty_valid(cx: &LateContext<'_>, ty: Ty<'_>) -> bool {
-    match ty.kind() {
-        ty::Array(component, _) => is_maybe_uninit_ty_valid(cx, component),
-        ty::Tuple(types) => types.types().all(|ty| is_maybe_uninit_ty_valid(cx, ty)),
-        ty::Adt(adt, _) => match_def_path(cx, adt.did, &paths::MEM_MAYBEUNINIT),
-        _ => false,
-    }
-}
diff --git a/clippy_lints/src/uninit_vec.rs b/clippy_lints/src/uninit_vec.rs
new file mode 100644
index 00000000000..ff302289a1f
--- /dev/null
+++ b/clippy_lints/src/uninit_vec.rs
@@ -0,0 +1,174 @@
+use clippy_utils::diagnostics::span_lint_and_note;
+use clippy_utils::{is_uninit_ty_valid, match_def_path, path_to_local_id, paths, peel_hir_expr_while, SpanlessEq};
+use rustc_hir::def::Res;
+use rustc_hir::{Block, Expr, ExprKind, HirId, PatKind, Stmt, StmtKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::Span;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for the creation of uninitialized `Vec<T>` by calling `set_len()`
+    /// immediately after `with_capacity()` or `reserve()`.
+    ///
+    /// ### Why is this bad?
+    /// It creates `Vec<T>` that contains uninitialized data, which leads to an
+    /// undefined behavior with most safe operations.
+    /// Notably, using uninitialized `Vec<u8>` with generic `Read` is unsound.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// let mut vec: Vec<u8> = Vec::with_capacity(1000);
+    /// unsafe { vec.set_len(1000); }
+    /// reader.read(&mut vec); // undefined behavior!
+    /// ```
+    /// Use an initialized buffer:
+    /// ```rust,ignore
+    /// let mut vec: Vec<u8> = vec![0; 1000];
+    /// reader.read(&mut vec);
+    /// ```
+    /// Or, wrap the content in `MaybeUninit`:
+    /// ```rust,ignore
+    /// let mut vec: Vec<MaybeUninit<T>> = Vec::with_capacity(1000);
+    /// unsafe { vec.set_len(1000); }
+    /// ```
+    pub UNINIT_VEC,
+    correctness,
+    "Vec with uninitialized data"
+}
+
+declare_lint_pass!(UninitVec => [UNINIT_VEC]);
+
+impl<'tcx> LateLintPass<'tcx> for UninitVec {
+    fn check_block(&mut self, cx: &LateContext<'tcx>, block: &'tcx Block<'_>) {
+        for w in block.stmts.windows(2) {
+            if let StmtKind::Expr(expr) | StmtKind::Semi(expr) = w[1].kind {
+                handle_pair(cx, &w[0], expr);
+            }
+        }
+
+        if let (Some(stmt), Some(expr)) = (block.stmts.last(), block.expr) {
+            handle_pair(cx, stmt, expr);
+        }
+    }
+}
+
+fn handle_pair(cx: &LateContext<'tcx>, first: &'tcx Stmt<'tcx>, second: &'tcx Expr<'tcx>) {
+    if_chain! {
+        if let Some(vec) = extract_with_capacity_or_reserve_target(cx, first);
+        if let Some((set_len_self, call_span)) = extract_set_len_self(cx, second);
+        if vec.eq_expr(cx, set_len_self);
+        if let ty::Ref(_, vec_ty, _) = cx.typeck_results().expr_ty_adjusted(set_len_self).kind();
+        if let ty::Adt(_, substs) = vec_ty.kind();
+        // Check T of Vec<T>
+        if !is_uninit_ty_valid(cx, substs.type_at(0));
+        then {
+            span_lint_and_note(
+                cx,
+                UNINIT_VEC,
+                call_span,
+                "calling `set_len()` immediately after reserving a buffer creates uninitialized values",
+                Some(first.span),
+                "the buffer is reserved here"
+            );
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug)]
+enum LocalOrExpr<'tcx> {
+    Local(HirId),
+    Expr(&'tcx Expr<'tcx>),
+}
+
+impl<'tcx> LocalOrExpr<'tcx> {
+    fn eq_expr(self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
+        match self {
+            LocalOrExpr::Local(hir_id) => path_to_local_id(expr, hir_id),
+            LocalOrExpr::Expr(self_expr) => SpanlessEq::new(cx).eq_expr(self_expr, expr),
+        }
+    }
+}
+
+/// Returns the target vec of Vec::with_capacity() or Vec::reserve()
+fn extract_with_capacity_or_reserve_target(cx: &LateContext<'_>, stmt: &'tcx Stmt<'_>) -> Option<LocalOrExpr<'tcx>> {
+    match stmt.kind {
+        StmtKind::Local(local) => {
+            // let mut x = Vec::with_capacity()
+            if_chain! {
+                if let Some(init_expr) = local.init;
+                if let PatKind::Binding(_, hir_id, _, None) = local.pat.kind;
+                if is_with_capacity(cx, init_expr);
+                then {
+                    Some(LocalOrExpr::Local(hir_id))
+                } else {
+                    None
+                }
+            }
+        },
+        StmtKind::Expr(expr) | StmtKind::Semi(expr) => {
+            match expr.kind {
+                ExprKind::Assign(lhs, rhs, _span) if is_with_capacity(cx, rhs) => {
+                    // self.vec = Vec::with_capacity()
+                    Some(LocalOrExpr::Expr(lhs))
+                },
+                ExprKind::MethodCall(_, _, [vec_expr, _], _) => {
+                    // self.vec.reserve()
+                    if_chain! {
+                        if let Some(id) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
+                        if match_def_path(cx, id, &paths::VEC_RESERVE);
+                        then {
+                            Some(LocalOrExpr::Expr(vec_expr))
+                        } else {
+                            None
+                        }
+                    }
+                },
+                _ => None,
+            }
+        },
+        _ => None,
+    }
+}
+
+fn is_with_capacity(cx: &LateContext<'_>, expr: &'tcx Expr<'_>) -> bool {
+    if_chain! {
+        if let ExprKind::Call(path_expr, _) = &expr.kind;
+        if let ExprKind::Path(qpath) = &path_expr.kind;
+        if let Res::Def(_, def_id) = cx.qpath_res(qpath, path_expr.hir_id);
+        then {
+            match_def_path(cx, def_id, &paths::VEC_WITH_CAPACITY)
+        } else {
+            false
+        }
+    }
+}
+
+/// Returns self if the expression is Vec::set_len()
+fn extract_set_len_self(cx: &LateContext<'_>, expr: &'tcx Expr<'_>) -> Option<(&'tcx Expr<'tcx>, Span)> {
+    // peel unsafe blocks in `unsafe { vec.set_len() }`
+    let expr = peel_hir_expr_while(expr, |e| {
+        if let ExprKind::Block(block, _) = e.kind {
+            match (block.stmts.get(0).map(|stmt| &stmt.kind), block.expr) {
+                (None, Some(expr)) => Some(expr),
+                (Some(StmtKind::Expr(expr) | StmtKind::Semi(expr)), None) => Some(expr),
+                _ => None,
+            }
+        } else {
+            None
+        }
+    });
+    match expr.kind {
+        ExprKind::MethodCall(_, _, [vec_expr, _], _) => {
+            cx.typeck_results().type_dependent_def_id(expr.hir_id).and_then(|id| {
+                if match_def_path(cx, id, &paths::VEC_SET_LEN) {
+                    Some((vec_expr, expr.span))
+                } else {
+                    None
+                }
+            })
+        },
+        _ => None,
+    }
+}
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 09eee78f0d1..00d2098a021 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -1470,6 +1470,16 @@ pub fn is_self_ty(slf: &hir::Ty<'_>) -> bool {
     false
 }
 
+/// Checks if a given type looks safe to be uninitialized.
+pub fn is_uninit_ty_valid(cx: &LateContext<'_>, ty: Ty<'_>) -> bool {
+    match ty.kind() {
+        rustc_ty::Array(component, _) => is_uninit_ty_valid(cx, component),
+        rustc_ty::Tuple(types) => types.types().all(|ty| is_uninit_ty_valid(cx, ty)),
+        rustc_ty::Adt(adt, _) => match_def_path(cx, adt.did, &paths::MEM_MAYBEUNINIT),
+        _ => false,
+    }
+}
+
 pub fn iter_input_pats<'tcx>(decl: &FnDecl<'_>, body: &'tcx Body<'_>) -> impl Iterator<Item = &'tcx Param<'tcx>> {
     (0..decl.inputs.len()).map(move |i| &body.params[i])
 }
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index e43c5756021..dffe30910dd 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -183,5 +183,8 @@ pub const VEC_AS_SLICE: [&str; 4] = ["alloc", "vec", "Vec", "as_slice"];
 pub const VEC_FROM_ELEM: [&str; 3] = ["alloc", "vec", "from_elem"];
 pub const VEC_NEW: [&str; 4] = ["alloc", "vec", "Vec", "new"];
 pub const VEC_RESIZE: [&str; 4] = ["alloc", "vec", "Vec", "resize"];
+pub const VEC_RESERVE: [&str; 4] = ["alloc", "vec", "Vec", "reserve"];
+pub const VEC_WITH_CAPACITY: [&str; 4] = ["alloc", "vec", "Vec", "with_capacity"];
+pub const VEC_SET_LEN: [&str; 4] = ["alloc", "vec", "Vec", "set_len"];
 pub const WEAK_ARC: [&str; 3] = ["alloc", "sync", "Weak"];
 pub const WEAK_RC: [&str; 3] = ["alloc", "rc", "Weak"];
diff --git a/tests/ui/uninit_vec.rs b/tests/ui/uninit_vec.rs
new file mode 100644
index 00000000000..5e67288405a
--- /dev/null
+++ b/tests/ui/uninit_vec.rs
@@ -0,0 +1,32 @@
+#![warn(clippy::uninit_vec)]
+
+use std::mem::MaybeUninit;
+
+fn main() {
+    // with_capacity() -> set_len() should be detected
+    let mut vec: Vec<u8> = Vec::with_capacity(1000);
+    unsafe {
+        vec.set_len(200);
+    }
+
+    // reserve() -> set_len() should be detected
+    vec.reserve(1000);
+    unsafe {
+        vec.set_len(200);
+    }
+
+    // test when both calls are enclosed in the same unsafe block
+    unsafe {
+        let mut vec: Vec<u8> = Vec::with_capacity(1000);
+        vec.set_len(200);
+
+        vec.reserve(1000);
+        vec.set_len(200);
+    }
+
+    // MaybeUninit-wrapped types should not be detected
+    let mut vec: Vec<MaybeUninit<u8>> = Vec::with_capacity(1000);
+    unsafe {
+        vec.set_len(200);
+    }
+}
diff --git a/tests/ui/uninit_vec.stderr b/tests/ui/uninit_vec.stderr
new file mode 100644
index 00000000000..1d7807fcf7d
--- /dev/null
+++ b/tests/ui/uninit_vec.stderr
@@ -0,0 +1,51 @@
+error: calling `set_len()` immediately after reserving a buffer creates uninitialized values
+  --> $DIR/uninit_vec.rs:9:9
+   |
+LL |         vec.set_len(200);
+   |         ^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::uninit-vec` implied by `-D warnings`
+note: the buffer is reserved here
+  --> $DIR/uninit_vec.rs:7:5
+   |
+LL |     let mut vec: Vec<u8> = Vec::with_capacity(1000);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: calling `set_len()` immediately after reserving a buffer creates uninitialized values
+  --> $DIR/uninit_vec.rs:15:9
+   |
+LL |         vec.set_len(200);
+   |         ^^^^^^^^^^^^^^^^
+   |
+note: the buffer is reserved here
+  --> $DIR/uninit_vec.rs:13:5
+   |
+LL |     vec.reserve(1000);
+   |     ^^^^^^^^^^^^^^^^^^
+
+error: calling `set_len()` immediately after reserving a buffer creates uninitialized values
+  --> $DIR/uninit_vec.rs:21:9
+   |
+LL |         vec.set_len(200);
+   |         ^^^^^^^^^^^^^^^^
+   |
+note: the buffer is reserved here
+  --> $DIR/uninit_vec.rs:20:9
+   |
+LL |         let mut vec: Vec<u8> = Vec::with_capacity(1000);
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: calling `set_len()` immediately after reserving a buffer creates uninitialized values
+  --> $DIR/uninit_vec.rs:24:9
+   |
+LL |         vec.set_len(200);
+   |         ^^^^^^^^^^^^^^^^
+   |
+note: the buffer is reserved here
+  --> $DIR/uninit_vec.rs:23:9
+   |
+LL |         vec.reserve(1000);
+   |         ^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 4 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From b8ba7269cd10843e4aebf855c4f72e980a9c0ed6 Mon Sep 17 00:00:00 2001
From: Yechan Bae <yechan@gatech.edu>
Date: Fri, 17 Sep 2021 03:27:31 -0400
Subject: Fix clippy lints

---
 clippy_lints/src/uninit_vec.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/uninit_vec.rs b/clippy_lints/src/uninit_vec.rs
index ff302289a1f..8b1254b60f9 100644
--- a/clippy_lints/src/uninit_vec.rs
+++ b/clippy_lints/src/uninit_vec.rs
@@ -91,7 +91,7 @@ impl<'tcx> LocalOrExpr<'tcx> {
     }
 }
 
-/// Returns the target vec of Vec::with_capacity() or Vec::reserve()
+/// Returns the target vec of `Vec::with_capacity()` or `Vec::reserve()`
 fn extract_with_capacity_or_reserve_target(cx: &LateContext<'_>, stmt: &'tcx Stmt<'_>) -> Option<LocalOrExpr<'tcx>> {
     match stmt.kind {
         StmtKind::Local(local) => {
@@ -128,7 +128,7 @@ fn extract_with_capacity_or_reserve_target(cx: &LateContext<'_>, stmt: &'tcx Stm
                 _ => None,
             }
         },
-        _ => None,
+        StmtKind::Item(_) => None,
     }
 }
 
@@ -145,7 +145,7 @@ fn is_with_capacity(cx: &LateContext<'_>, expr: &'tcx Expr<'_>) -> bool {
     }
 }
 
-/// Returns self if the expression is Vec::set_len()
+/// Returns self if the expression is `Vec::set_len()`
 fn extract_set_len_self(cx: &LateContext<'_>, expr: &'tcx Expr<'_>) -> Option<(&'tcx Expr<'tcx>, Span)> {
     // peel unsafe blocks in `unsafe { vec.set_len() }`
     let expr = peel_hir_expr_while(expr, |e| {
-- 
cgit 1.4.1-3-g733a5


From 759200b6991b5dac5fdb12bc6c366b16850add00 Mon Sep 17 00:00:00 2001
From: Yechan Bae <yechan@gatech.edu>
Date: Fri, 17 Sep 2021 14:42:32 -0400
Subject: Handle PR feedbacks first round

---
 clippy_lints/src/methods/uninit_assumed_init.rs |  4 +--
 clippy_lints/src/uninit_vec.rs                  | 41 ++++++++++++++-----------
 clippy_utils/src/lib.rs                         | 10 ------
 clippy_utils/src/paths.rs                       |  1 -
 clippy_utils/src/ty.rs                          | 10 ++++++
 tests/ui/uninit_vec.rs                          |  8 ++++-
 6 files changed, 42 insertions(+), 32 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/uninit_assumed_init.rs b/clippy_lints/src/methods/uninit_assumed_init.rs
index dbd91fb6d9d..ce89189bce9 100644
--- a/clippy_lints/src/methods/uninit_assumed_init.rs
+++ b/clippy_lints/src/methods/uninit_assumed_init.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint;
-use clippy_utils::{is_expr_path_def_path, is_uninit_ty_valid, paths};
+use clippy_utils::{is_expr_path_def_path, paths, ty::is_uninit_value_valid_for_ty};
 use if_chain::if_chain;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
@@ -12,7 +12,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr
         if let hir::ExprKind::Call(callee, args) = recv.kind;
         if args.is_empty();
         if is_expr_path_def_path(cx, callee, &paths::MEM_MAYBEUNINIT_UNINIT);
-        if !is_uninit_ty_valid(cx, cx.typeck_results().expr_ty_adjusted(expr));
+        if !is_uninit_value_valid_for_ty(cx, cx.typeck_results().expr_ty_adjusted(expr));
         then {
             span_lint(
                 cx,
diff --git a/clippy_lints/src/uninit_vec.rs b/clippy_lints/src/uninit_vec.rs
index 8b1254b60f9..37084f57043 100644
--- a/clippy_lints/src/uninit_vec.rs
+++ b/clippy_lints/src/uninit_vec.rs
@@ -1,11 +1,14 @@
 use clippy_utils::diagnostics::span_lint_and_note;
-use clippy_utils::{is_uninit_ty_valid, match_def_path, path_to_local_id, paths, peel_hir_expr_while, SpanlessEq};
+use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::{
+    match_def_path, path_to_local_id, paths, peel_hir_expr_while, ty::is_uninit_value_valid_for_ty, SpanlessEq,
+};
 use rustc_hir::def::Res;
 use rustc_hir::{Block, Expr, ExprKind, HirId, PatKind, Stmt, StmtKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::Span;
+use rustc_span::{sym, Span};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -44,32 +47,36 @@ impl<'tcx> LateLintPass<'tcx> for UninitVec {
     fn check_block(&mut self, cx: &LateContext<'tcx>, block: &'tcx Block<'_>) {
         for w in block.stmts.windows(2) {
             if let StmtKind::Expr(expr) | StmtKind::Semi(expr) = w[1].kind {
-                handle_pair(cx, &w[0], expr);
+                handle_uninit_vec_pair(cx, &w[0], expr);
             }
         }
 
         if let (Some(stmt), Some(expr)) = (block.stmts.last(), block.expr) {
-            handle_pair(cx, stmt, expr);
+            handle_uninit_vec_pair(cx, stmt, expr);
         }
     }
 }
 
-fn handle_pair(cx: &LateContext<'tcx>, first: &'tcx Stmt<'tcx>, second: &'tcx Expr<'tcx>) {
+fn handle_uninit_vec_pair(
+    cx: &LateContext<'tcx>,
+    maybe_with_capacity_or_reserve: &'tcx Stmt<'tcx>,
+    maybe_set_len: &'tcx Expr<'tcx>,
+) {
     if_chain! {
-        if let Some(vec) = extract_with_capacity_or_reserve_target(cx, first);
-        if let Some((set_len_self, call_span)) = extract_set_len_self(cx, second);
+        if let Some(vec) = extract_with_capacity_or_reserve_target(cx, maybe_with_capacity_or_reserve);
+        if let Some((set_len_self, call_span)) = extract_set_len_self(cx, maybe_set_len);
         if vec.eq_expr(cx, set_len_self);
         if let ty::Ref(_, vec_ty, _) = cx.typeck_results().expr_ty_adjusted(set_len_self).kind();
         if let ty::Adt(_, substs) = vec_ty.kind();
         // Check T of Vec<T>
-        if !is_uninit_ty_valid(cx, substs.type_at(0));
+        if !is_uninit_value_valid_for_ty(cx, substs.type_at(0));
         then {
             span_lint_and_note(
                 cx,
                 UNINIT_VEC,
                 call_span,
                 "calling `set_len()` immediately after reserving a buffer creates uninitialized values",
-                Some(first.span),
+                Some(maybe_with_capacity_or_reserve.span),
                 "the buffer is reserved here"
             );
         }
@@ -113,16 +120,14 @@ fn extract_with_capacity_or_reserve_target(cx: &LateContext<'_>, stmt: &'tcx Stm
                     // self.vec = Vec::with_capacity()
                     Some(LocalOrExpr::Expr(lhs))
                 },
-                ExprKind::MethodCall(_, _, [vec_expr, _], _) => {
+                ExprKind::MethodCall(path, _, [self_expr, _], _) => {
                     // self.vec.reserve()
-                    if_chain! {
-                        if let Some(id) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
-                        if match_def_path(cx, id, &paths::VEC_RESERVE);
-                        then {
-                            Some(LocalOrExpr::Expr(vec_expr))
-                        } else {
-                            None
-                        }
+                    if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(self_expr).peel_refs(), sym::vec_type)
+                        && path.ident.name.as_str() == "reserve"
+                    {
+                        Some(LocalOrExpr::Expr(self_expr))
+                    } else {
+                        None
                     }
                 },
                 _ => None,
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 00d2098a021..09eee78f0d1 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -1470,16 +1470,6 @@ pub fn is_self_ty(slf: &hir::Ty<'_>) -> bool {
     false
 }
 
-/// Checks if a given type looks safe to be uninitialized.
-pub fn is_uninit_ty_valid(cx: &LateContext<'_>, ty: Ty<'_>) -> bool {
-    match ty.kind() {
-        rustc_ty::Array(component, _) => is_uninit_ty_valid(cx, component),
-        rustc_ty::Tuple(types) => types.types().all(|ty| is_uninit_ty_valid(cx, ty)),
-        rustc_ty::Adt(adt, _) => match_def_path(cx, adt.did, &paths::MEM_MAYBEUNINIT),
-        _ => false,
-    }
-}
-
 pub fn iter_input_pats<'tcx>(decl: &FnDecl<'_>, body: &'tcx Body<'_>) -> impl Iterator<Item = &'tcx Param<'tcx>> {
     (0..decl.inputs.len()).map(move |i| &body.params[i])
 }
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index dffe30910dd..63ec10a3178 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -183,7 +183,6 @@ pub const VEC_AS_SLICE: [&str; 4] = ["alloc", "vec", "Vec", "as_slice"];
 pub const VEC_FROM_ELEM: [&str; 3] = ["alloc", "vec", "from_elem"];
 pub const VEC_NEW: [&str; 4] = ["alloc", "vec", "Vec", "new"];
 pub const VEC_RESIZE: [&str; 4] = ["alloc", "vec", "Vec", "resize"];
-pub const VEC_RESERVE: [&str; 4] = ["alloc", "vec", "Vec", "reserve"];
 pub const VEC_WITH_CAPACITY: [&str; 4] = ["alloc", "vec", "Vec", "with_capacity"];
 pub const VEC_SET_LEN: [&str; 4] = ["alloc", "vec", "Vec", "set_len"];
 pub const WEAK_ARC: [&str; 3] = ["alloc", "sync", "Weak"];
diff --git a/clippy_utils/src/ty.rs b/clippy_utils/src/ty.rs
index 6ebe1a0028a..ca64ac7de3e 100644
--- a/clippy_utils/src/ty.rs
+++ b/clippy_utils/src/ty.rs
@@ -367,3 +367,13 @@ pub fn same_type_and_consts(a: Ty<'tcx>, b: Ty<'tcx>) -> bool {
         _ => a == b,
     }
 }
+
+/// Checks if a given type looks safe to be uninitialized.
+pub fn is_uninit_value_valid_for_ty(cx: &LateContext<'_>, ty: Ty<'_>) -> bool {
+    match ty.kind() {
+        ty::Array(component, _) => is_uninit_value_valid_for_ty(cx, component),
+        ty::Tuple(types) => types.types().all(|ty| is_uninit_value_valid_for_ty(cx, ty)),
+        ty::Adt(adt, _) => cx.tcx.lang_items().maybe_uninit() == Some(adt.did),
+        _ => false,
+    }
+}
diff --git a/tests/ui/uninit_vec.rs b/tests/ui/uninit_vec.rs
index 5e67288405a..34b9e07ef1d 100644
--- a/tests/ui/uninit_vec.rs
+++ b/tests/ui/uninit_vec.rs
@@ -25,8 +25,14 @@ fn main() {
     }
 
     // MaybeUninit-wrapped types should not be detected
-    let mut vec: Vec<MaybeUninit<u8>> = Vec::with_capacity(1000);
     unsafe {
+        let mut vec: Vec<MaybeUninit<u8>> = Vec::with_capacity(1000);
+        vec.set_len(200);
+
+        let mut vec: Vec<(MaybeUninit<u8>, MaybeUninit<bool>)> = Vec::with_capacity(1000);
+        vec.set_len(200);
+
+        let mut vec: Vec<(MaybeUninit<u8>, [MaybeUninit<bool>; 2])> = Vec::with_capacity(1000);
         vec.set_len(200);
     }
 }
-- 
cgit 1.4.1-3-g733a5


From fdc06d9b2b3e858878b6fd8f6bd815d947e9950a Mon Sep 17 00:00:00 2001
From: Yechan Bae <yechan@gatech.edu>
Date: Mon, 20 Sep 2021 15:32:53 -0400
Subject: Improve error messages

---
 clippy_lints/src/uninit_vec.rs | 14 +++++----
 tests/ui/uninit_vec.rs         | 32 ++++++++++++++++++++
 tests/ui/uninit_vec.stderr     | 69 +++++++++++++++++++++++++++++-------------
 3 files changed, 88 insertions(+), 27 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/uninit_vec.rs b/clippy_lints/src/uninit_vec.rs
index 37084f57043..b9b575a452b 100644
--- a/clippy_lints/src/uninit_vec.rs
+++ b/clippy_lints/src/uninit_vec.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_note;
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::{
     match_def_path, path_to_local_id, paths, peel_hir_expr_while, ty::is_uninit_value_valid_for_ty, SpanlessEq,
@@ -71,13 +71,14 @@ fn handle_uninit_vec_pair(
         // Check T of Vec<T>
         if !is_uninit_value_valid_for_ty(cx, substs.type_at(0));
         then {
-            span_lint_and_note(
+            span_lint_and_then(
                 cx,
                 UNINIT_VEC,
-                call_span,
+                vec![call_span, maybe_with_capacity_or_reserve.span],
                 "calling `set_len()` immediately after reserving a buffer creates uninitialized values",
-                Some(maybe_with_capacity_or_reserve.span),
-                "the buffer is reserved here"
+                |diag| {
+                    diag.help("initialize the buffer or wrap the content in `MaybeUninit`");
+                },
             );
         }
     }
@@ -155,9 +156,10 @@ fn extract_set_len_self(cx: &LateContext<'_>, expr: &'tcx Expr<'_>) -> Option<(&
     // peel unsafe blocks in `unsafe { vec.set_len() }`
     let expr = peel_hir_expr_while(expr, |e| {
         if let ExprKind::Block(block, _) = e.kind {
+            // Extract the first statement/expression
             match (block.stmts.get(0).map(|stmt| &stmt.kind), block.expr) {
                 (None, Some(expr)) => Some(expr),
-                (Some(StmtKind::Expr(expr) | StmtKind::Semi(expr)), None) => Some(expr),
+                (Some(StmtKind::Expr(expr) | StmtKind::Semi(expr)), _) => Some(expr),
                 _ => None,
             }
         } else {
diff --git a/tests/ui/uninit_vec.rs b/tests/ui/uninit_vec.rs
index 34b9e07ef1d..e60b73a1e30 100644
--- a/tests/ui/uninit_vec.rs
+++ b/tests/ui/uninit_vec.rs
@@ -2,6 +2,11 @@
 
 use std::mem::MaybeUninit;
 
+#[derive(Default)]
+struct MyVec {
+    vec: Vec<u8>,
+}
+
 fn main() {
     // with_capacity() -> set_len() should be detected
     let mut vec: Vec<u8> = Vec::with_capacity(1000);
@@ -24,6 +29,25 @@ fn main() {
         vec.set_len(200);
     }
 
+    let mut vec: Vec<u8> = Vec::with_capacity(1000);
+    unsafe {
+        // test the case where there are other statements in the following unsafe block
+        vec.set_len(200);
+        assert!(vec.len() == 200);
+    }
+
+    // handle vec stored in the field of a struct
+    let mut my_vec = MyVec::default();
+    my_vec.vec.reserve(1000);
+    unsafe {
+        my_vec.vec.set_len(200);
+    }
+
+    my_vec.vec = Vec::with_capacity(1000);
+    unsafe {
+        my_vec.vec.set_len(200);
+    }
+
     // MaybeUninit-wrapped types should not be detected
     unsafe {
         let mut vec: Vec<MaybeUninit<u8>> = Vec::with_capacity(1000);
@@ -35,4 +59,12 @@ fn main() {
         let mut vec: Vec<(MaybeUninit<u8>, [MaybeUninit<bool>; 2])> = Vec::with_capacity(1000);
         vec.set_len(200);
     }
+
+    // known false negative
+    let mut vec1: Vec<u8> = Vec::with_capacity(1000);
+    let mut vec2: Vec<u8> = Vec::with_capacity(1000);
+    unsafe {
+        vec1.reserve(200);
+        vec2.reserve(200);
+    }
 }
diff --git a/tests/ui/uninit_vec.stderr b/tests/ui/uninit_vec.stderr
index 1d7807fcf7d..31f8ae40350 100644
--- a/tests/ui/uninit_vec.stderr
+++ b/tests/ui/uninit_vec.stderr
@@ -1,51 +1,78 @@
 error: calling `set_len()` immediately after reserving a buffer creates uninitialized values
-  --> $DIR/uninit_vec.rs:9:9
+  --> $DIR/uninit_vec.rs:12:5
    |
+LL |     let mut vec: Vec<u8> = Vec::with_capacity(1000);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |     unsafe {
 LL |         vec.set_len(200);
    |         ^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::uninit-vec` implied by `-D warnings`
-note: the buffer is reserved here
-  --> $DIR/uninit_vec.rs:7:5
-   |
-LL |     let mut vec: Vec<u8> = Vec::with_capacity(1000);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   = help: initialize the buffer or wrap the content in `MaybeUninit`
 
 error: calling `set_len()` immediately after reserving a buffer creates uninitialized values
-  --> $DIR/uninit_vec.rs:15:9
+  --> $DIR/uninit_vec.rs:18:5
    |
+LL |     vec.reserve(1000);
+   |     ^^^^^^^^^^^^^^^^^^
+LL |     unsafe {
 LL |         vec.set_len(200);
    |         ^^^^^^^^^^^^^^^^
    |
-note: the buffer is reserved here
-  --> $DIR/uninit_vec.rs:13:5
-   |
-LL |     vec.reserve(1000);
-   |     ^^^^^^^^^^^^^^^^^^
+   = help: initialize the buffer or wrap the content in `MaybeUninit`
 
 error: calling `set_len()` immediately after reserving a buffer creates uninitialized values
-  --> $DIR/uninit_vec.rs:21:9
+  --> $DIR/uninit_vec.rs:32:5
    |
+LL |     let mut vec: Vec<u8> = Vec::with_capacity(1000);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+...
 LL |         vec.set_len(200);
    |         ^^^^^^^^^^^^^^^^
    |
-note: the buffer is reserved here
-  --> $DIR/uninit_vec.rs:20:9
+   = help: initialize the buffer or wrap the content in `MaybeUninit`
+
+error: calling `set_len()` immediately after reserving a buffer creates uninitialized values
+  --> $DIR/uninit_vec.rs:41:5
+   |
+LL |     my_vec.vec.reserve(1000);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |     unsafe {
+LL |         my_vec.vec.set_len(200);
+   |         ^^^^^^^^^^^^^^^^^^^^^^^
    |
-LL |         let mut vec: Vec<u8> = Vec::with_capacity(1000);
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   = help: initialize the buffer or wrap the content in `MaybeUninit`
+
+error: calling `set_len()` immediately after reserving a buffer creates uninitialized values
+  --> $DIR/uninit_vec.rs:46:5
+   |
+LL |     my_vec.vec = Vec::with_capacity(1000);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |     unsafe {
+LL |         my_vec.vec.set_len(200);
+   |         ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: initialize the buffer or wrap the content in `MaybeUninit`
 
 error: calling `set_len()` immediately after reserving a buffer creates uninitialized values
-  --> $DIR/uninit_vec.rs:24:9
+  --> $DIR/uninit_vec.rs:25:9
    |
+LL |         let mut vec: Vec<u8> = Vec::with_capacity(1000);
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 LL |         vec.set_len(200);
    |         ^^^^^^^^^^^^^^^^
    |
-note: the buffer is reserved here
-  --> $DIR/uninit_vec.rs:23:9
+   = help: initialize the buffer or wrap the content in `MaybeUninit`
+
+error: calling `set_len()` immediately after reserving a buffer creates uninitialized values
+  --> $DIR/uninit_vec.rs:28:9
    |
 LL |         vec.reserve(1000);
    |         ^^^^^^^^^^^^^^^^^^
+LL |         vec.set_len(200);
+   |         ^^^^^^^^^^^^^^^^
+   |
+   = help: initialize the buffer or wrap the content in `MaybeUninit`
 
-error: aborting due to 4 previous errors
+error: aborting due to 7 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From fec20bf61799764fab2b0d00d4666f4a9a9632c2 Mon Sep 17 00:00:00 2001
From: Yechan Bae <yechan@gatech.edu>
Date: Tue, 21 Sep 2021 09:56:56 -0400
Subject: Add #allow attribute to suppress FP #7698

---
 clippy_lints/src/uninit_vec.rs | 2 ++
 1 file changed, 2 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/uninit_vec.rs b/clippy_lints/src/uninit_vec.rs
index b9b575a452b..4d556d62c9b 100644
--- a/clippy_lints/src/uninit_vec.rs
+++ b/clippy_lints/src/uninit_vec.rs
@@ -71,6 +71,8 @@ fn handle_uninit_vec_pair(
         // Check T of Vec<T>
         if !is_uninit_value_valid_for_ty(cx, substs.type_at(0));
         then {
+            // FIXME: false positive #7698
+            #[allow(clippy::collapsible_span_lint_calls)]
             span_lint_and_then(
                 cx,
                 UNINIT_VEC,
-- 
cgit 1.4.1-3-g733a5


From dd9c8d32f2d7984545816ee07e1e7213b36013f0 Mon Sep 17 00:00:00 2001
From: Yechan Bae <yechan@gatech.edu>
Date: Sun, 3 Oct 2021 00:23:57 -0400
Subject: Extract get_vec_init_kind and share it

---
 clippy_lints/src/uninit_vec.rs         | 116 +++++++++++++++------------------
 clippy_lints/src/vec_init_then_push.rs |  51 ++-------------
 clippy_utils/src/lib.rs                |  49 +++++++++++++-
 clippy_utils/src/paths.rs              |   1 -
 4 files changed, 105 insertions(+), 112 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/uninit_vec.rs b/clippy_lints/src/uninit_vec.rs
index 4d556d62c9b..833c95f4940 100644
--- a/clippy_lints/src/uninit_vec.rs
+++ b/clippy_lints/src/uninit_vec.rs
@@ -1,24 +1,24 @@
 use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::get_vec_init_kind;
 use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{
-    match_def_path, path_to_local_id, paths, peel_hir_expr_while, ty::is_uninit_value_valid_for_ty, SpanlessEq,
-};
-use rustc_hir::def::Res;
-use rustc_hir::{Block, Expr, ExprKind, HirId, PatKind, Stmt, StmtKind};
+use clippy_utils::{path_to_local_id, peel_hir_expr_while, ty::is_uninit_value_valid_for_ty, SpanlessEq};
+use rustc_hir::{Block, Expr, ExprKind, HirId, PatKind, PathSegment, Stmt, StmtKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::{sym, Span};
 
+// TODO: add `ReadBuf` (RFC 2930) in "How to fix" once it is available in std
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for the creation of uninitialized `Vec<T>` by calling `set_len()`
-    /// immediately after `with_capacity()` or `reserve()`.
+    /// Checks for `set_len()` call that creates `Vec` with uninitialized elements.
+    /// This is commonly caused by calling `set_len()` right after after calling
+    /// `with_capacity()` or `reserve()`.
     ///
     /// ### Why is this bad?
-    /// It creates `Vec<T>` that contains uninitialized data, which leads to an
+    /// It creates a `Vec` with uninitialized data, which leads to an
     /// undefined behavior with most safe operations.
-    /// Notably, using uninitialized `Vec<u8>` with generic `Read` is unsound.
+    /// Notably, uninitialized `Vec<u8>` must not be used with generic `Read`.
     ///
     /// ### Example
     /// ```rust,ignore
@@ -26,16 +26,25 @@ declare_clippy_lint! {
     /// unsafe { vec.set_len(1000); }
     /// reader.read(&mut vec); // undefined behavior!
     /// ```
-    /// Use an initialized buffer:
-    /// ```rust,ignore
-    /// let mut vec: Vec<u8> = vec![0; 1000];
-    /// reader.read(&mut vec);
-    /// ```
-    /// Or, wrap the content in `MaybeUninit`:
-    /// ```rust,ignore
-    /// let mut vec: Vec<MaybeUninit<T>> = Vec::with_capacity(1000);
-    /// unsafe { vec.set_len(1000); }
-    /// ```
+    ///
+    /// ### How to fix?
+    /// 1. Use an initialized buffer:
+    ///    ```rust,ignore
+    ///    let mut vec: Vec<u8> = vec![0; 1000];
+    ///    reader.read(&mut vec);
+    ///    ```
+    /// 2. Wrap the content in `MaybeUninit`:
+    ///    ```rust,ignore
+    ///    let mut vec: Vec<MaybeUninit<T>> = Vec::with_capacity(1000);
+    ///    vec.set_len(1000);  // `MaybeUninit` can be uninitialized
+    ///    ```
+    /// 3. If you are on nightly, `Vec::spare_capacity_mut()` is available:
+    ///    ```rust,ignore
+    ///    let mut vec: Vec<u8> = Vec::with_capacity(1000);
+    ///    let remaining = vec.spare_capacity_mut();  // `&mut [MaybeUninit<u8>]`
+    ///    // perform initialization with `remaining`
+    ///    vec.set_len(...);  // Safe to call `set_len()` on initialized part
+    ///    ```
     pub UNINIT_VEC,
     correctness,
     "Vec with uninitialized data"
@@ -59,11 +68,11 @@ impl<'tcx> LateLintPass<'tcx> for UninitVec {
 
 fn handle_uninit_vec_pair(
     cx: &LateContext<'tcx>,
-    maybe_with_capacity_or_reserve: &'tcx Stmt<'tcx>,
+    maybe_init_or_reserve: &'tcx Stmt<'tcx>,
     maybe_set_len: &'tcx Expr<'tcx>,
 ) {
     if_chain! {
-        if let Some(vec) = extract_with_capacity_or_reserve_target(cx, maybe_with_capacity_or_reserve);
+        if let Some(vec) = extract_init_or_reserve_target(cx, maybe_init_or_reserve);
         if let Some((set_len_self, call_span)) = extract_set_len_self(cx, maybe_set_len);
         if vec.eq_expr(cx, set_len_self);
         if let ty::Ref(_, vec_ty, _) = cx.typeck_results().expr_ty_adjusted(set_len_self).kind();
@@ -71,12 +80,12 @@ fn handle_uninit_vec_pair(
         // Check T of Vec<T>
         if !is_uninit_value_valid_for_ty(cx, substs.type_at(0));
         then {
-            // FIXME: false positive #7698
+            // FIXME: #7698, false positive of the internal lints
             #[allow(clippy::collapsible_span_lint_calls)]
             span_lint_and_then(
                 cx,
                 UNINIT_VEC,
-                vec![call_span, maybe_with_capacity_or_reserve.span],
+                vec![call_span, maybe_init_or_reserve.span],
                 "calling `set_len()` immediately after reserving a buffer creates uninitialized values",
                 |diag| {
                     diag.help("initialize the buffer or wrap the content in `MaybeUninit`");
@@ -101,15 +110,15 @@ impl<'tcx> LocalOrExpr<'tcx> {
     }
 }
 
-/// Returns the target vec of `Vec::with_capacity()` or `Vec::reserve()`
-fn extract_with_capacity_or_reserve_target(cx: &LateContext<'_>, stmt: &'tcx Stmt<'_>) -> Option<LocalOrExpr<'tcx>> {
+/// Finds the target location where the result of `Vec` initialization is stored
+/// or `self` expression for `Vec::reserve()`.
+fn extract_init_or_reserve_target<'tcx>(cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'tcx>) -> Option<LocalOrExpr<'tcx>> {
     match stmt.kind {
         StmtKind::Local(local) => {
-            // let mut x = Vec::with_capacity()
             if_chain! {
                 if let Some(init_expr) = local.init;
                 if let PatKind::Binding(_, hir_id, _, None) = local.pat.kind;
-                if is_with_capacity(cx, init_expr);
+                if get_vec_init_kind(cx, init_expr).is_some();
                 then {
                     Some(LocalOrExpr::Local(hir_id))
                 } else {
@@ -117,40 +126,20 @@ fn extract_with_capacity_or_reserve_target(cx: &LateContext<'_>, stmt: &'tcx Stm
                 }
             }
         },
-        StmtKind::Expr(expr) | StmtKind::Semi(expr) => {
-            match expr.kind {
-                ExprKind::Assign(lhs, rhs, _span) if is_with_capacity(cx, rhs) => {
-                    // self.vec = Vec::with_capacity()
-                    Some(LocalOrExpr::Expr(lhs))
-                },
-                ExprKind::MethodCall(path, _, [self_expr, _], _) => {
-                    // self.vec.reserve()
-                    if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(self_expr).peel_refs(), sym::vec_type)
-                        && path.ident.name.as_str() == "reserve"
-                    {
-                        Some(LocalOrExpr::Expr(self_expr))
-                    } else {
-                        None
-                    }
-                },
-                _ => None,
-            }
+        StmtKind::Expr(expr) | StmtKind::Semi(expr) => match expr.kind {
+            ExprKind::Assign(lhs, rhs, _span) if get_vec_init_kind(cx, rhs).is_some() => Some(LocalOrExpr::Expr(lhs)),
+            ExprKind::MethodCall(path, _, [self_expr, _], _) if is_reserve(cx, path, self_expr) => {
+                Some(LocalOrExpr::Expr(self_expr))
+            },
+            _ => None,
         },
         StmtKind::Item(_) => None,
     }
 }
 
-fn is_with_capacity(cx: &LateContext<'_>, expr: &'tcx Expr<'_>) -> bool {
-    if_chain! {
-        if let ExprKind::Call(path_expr, _) = &expr.kind;
-        if let ExprKind::Path(qpath) = &path_expr.kind;
-        if let Res::Def(_, def_id) = cx.qpath_res(qpath, path_expr.hir_id);
-        then {
-            match_def_path(cx, def_id, &paths::VEC_WITH_CAPACITY)
-        } else {
-            false
-        }
-    }
+fn is_reserve(cx: &LateContext<'_>, path: &PathSegment<'_>, self_expr: &Expr<'_>) -> bool {
+    is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(self_expr).peel_refs(), sym::Vec)
+        && path.ident.name.as_str() == "reserve"
 }
 
 /// Returns self if the expression is `Vec::set_len()`
@@ -169,14 +158,13 @@ fn extract_set_len_self(cx: &LateContext<'_>, expr: &'tcx Expr<'_>) -> Option<(&
         }
     });
     match expr.kind {
-        ExprKind::MethodCall(_, _, [vec_expr, _], _) => {
-            cx.typeck_results().type_dependent_def_id(expr.hir_id).and_then(|id| {
-                if match_def_path(cx, id, &paths::VEC_SET_LEN) {
-                    Some((vec_expr, expr.span))
-                } else {
-                    None
-                }
-            })
+        ExprKind::MethodCall(path, _, [self_expr, _], _) => {
+            let self_type = cx.typeck_results().expr_ty(self_expr).peel_refs();
+            if is_type_diagnostic_item(cx, self_type, sym::Vec) && path.ident.name.as_str() == "set_len" {
+                Some((self_expr, expr.span))
+            } else {
+                None
+            }
         },
         _ => None,
     }
diff --git a/clippy_lints/src/vec_init_then_push.rs b/clippy_lints/src/vec_init_then_push.rs
index d8e241d72af..478314c0836 100644
--- a/clippy_lints/src/vec_init_then_push.rs
+++ b/clippy_lints/src/vec_init_then_push.rs
@@ -1,16 +1,13 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet;
-use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{match_def_path, path_to_local, path_to_local_id, paths};
+use clippy_utils::{get_vec_init_kind, path_to_local, path_to_local_id, VecInitKind};
 use if_chain::if_chain;
-use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
-use rustc_hir::{BindingAnnotation, Block, Expr, ExprKind, HirId, Local, PatKind, QPath, Stmt, StmtKind};
+use rustc_hir::{BindingAnnotation, Block, Expr, ExprKind, HirId, Local, PatKind, Stmt, StmtKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::{symbol::sym, Span};
-use std::convert::TryInto;
+use rustc_span::Span;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -41,11 +38,6 @@ pub struct VecInitThenPush {
     searcher: Option<VecPushSearcher>,
 }
 
-#[derive(Clone, Copy)]
-enum VecInitKind {
-    New,
-    WithCapacity(u64),
-}
 struct VecPushSearcher {
     local_id: HirId,
     init: VecInitKind,
@@ -58,7 +50,8 @@ impl VecPushSearcher {
     fn display_err(&self, cx: &LateContext<'_>) {
         match self.init {
             _ if self.found == 0 => return,
-            VecInitKind::WithCapacity(x) if x > self.found => return,
+            VecInitKind::WithLiteralCapacity(x) if x > self.found => return,
+            VecInitKind::WithExprCapacity(_) => return,
             _ => (),
         };
 
@@ -152,37 +145,3 @@ impl LateLintPass<'_> for VecInitThenPush {
         }
     }
 }
-
-fn get_vec_init_kind<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> Option<VecInitKind> {
-    if let ExprKind::Call(func, args) = expr.kind {
-        match func.kind {
-            ExprKind::Path(QPath::TypeRelative(ty, name))
-                if is_type_diagnostic_item(cx, cx.typeck_results().node_type(ty.hir_id), sym::Vec) =>
-            {
-                if name.ident.name == sym::new {
-                    return Some(VecInitKind::New);
-                } else if name.ident.name.as_str() == "with_capacity" {
-                    return args.get(0).and_then(|arg| {
-                        if_chain! {
-                            if let ExprKind::Lit(lit) = &arg.kind;
-                            if let LitKind::Int(num, _) = lit.node;
-                            then {
-                                Some(VecInitKind::WithCapacity(num.try_into().ok()?))
-                            } else {
-                                None
-                            }
-                        }
-                    });
-                }
-            }
-            ExprKind::Path(QPath::Resolved(_, path))
-                if match_def_path(cx, path.res.opt_def_id()?, &paths::DEFAULT_TRAIT_METHOD)
-                    && is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(expr), sym::Vec) =>
-            {
-                return Some(VecInitKind::New);
-            }
-            _ => (),
-        }
-    }
-    None
-}
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 09eee78f0d1..b450059e18a 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -93,7 +93,7 @@ use rustc_span::{Span, DUMMY_SP};
 use rustc_target::abi::Integer;
 
 use crate::consts::{constant, Constant};
-use crate::ty::{can_partially_move_ty, is_copy, is_recursively_primitive_type};
+use crate::ty::{can_partially_move_ty, is_copy, is_recursively_primitive_type, is_type_diagnostic_item};
 
 pub fn parse_msrv(msrv: &str, sess: Option<&Session>, span: Option<Span>) -> Option<RustcVersion> {
     if let Ok(version) = RustcVersion::parse(msrv) {
@@ -1789,6 +1789,53 @@ pub fn is_expr_identity_function(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool
     }
 }
 
+#[derive(Clone, Copy)]
+pub enum VecInitKind {
+    /// `Vec::new()`
+    New,
+    /// `Vec::default()` or `Default::default()`
+    Default,
+    /// `Vec::with_capacity(123)`
+    WithLiteralCapacity(u64),
+    /// `Vec::with_capacity(slice.len())`
+    WithExprCapacity(HirId),
+}
+
+/// Checks if given expression is an initialization of `Vec` and returns its kind.
+pub fn get_vec_init_kind<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> Option<VecInitKind> {
+    if let ExprKind::Call(func, args) = expr.kind {
+        match func.kind {
+            ExprKind::Path(QPath::TypeRelative(ty, name))
+                if is_type_diagnostic_item(cx, cx.typeck_results().node_type(ty.hir_id), sym::Vec) =>
+            {
+                if name.ident.name == sym::new {
+                    return Some(VecInitKind::New);
+                } else if name.ident.name.as_str() == "with_capacity" {
+                    return args.get(0).and_then(|arg| {
+                        if_chain! {
+                            if let ExprKind::Lit(lit) = &arg.kind;
+                            if let LitKind::Int(num, _) = lit.node;
+                            then {
+                                Some(VecInitKind::WithLiteralCapacity(num.try_into().ok()?))
+                            } else {
+                                Some(VecInitKind::WithExprCapacity(arg.hir_id))
+                            }
+                        }
+                    });
+                }
+            }
+            ExprKind::Path(QPath::Resolved(_, path))
+                if match_def_path(cx, path.res.opt_def_id()?, &paths::DEFAULT_TRAIT_METHOD)
+                    && is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(expr), sym::Vec) =>
+            {
+                return Some(VecInitKind::Default);
+            }
+            _ => (),
+        }
+    }
+    None
+}
+
 /// Gets the node where an expression is either used, or it's type is unified with another branch.
 pub fn get_expr_use_or_unification_node(tcx: TyCtxt<'tcx>, expr: &Expr<'_>) -> Option<Node<'tcx>> {
     let mut child_id = expr.hir_id;
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index 63ec10a3178..a39c0fc0b10 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -183,7 +183,6 @@ pub const VEC_AS_SLICE: [&str; 4] = ["alloc", "vec", "Vec", "as_slice"];
 pub const VEC_FROM_ELEM: [&str; 3] = ["alloc", "vec", "from_elem"];
 pub const VEC_NEW: [&str; 4] = ["alloc", "vec", "Vec", "new"];
 pub const VEC_RESIZE: [&str; 4] = ["alloc", "vec", "Vec", "resize"];
-pub const VEC_WITH_CAPACITY: [&str; 4] = ["alloc", "vec", "Vec", "with_capacity"];
 pub const VEC_SET_LEN: [&str; 4] = ["alloc", "vec", "Vec", "set_len"];
 pub const WEAK_ARC: [&str; 3] = ["alloc", "sync", "Weak"];
 pub const WEAK_RC: [&str; 3] = ["alloc", "rc", "Weak"];
-- 
cgit 1.4.1-3-g733a5


From b1aa3064b6d86c5ae90a67e420d88d826bafe8be Mon Sep 17 00:00:00 2001
From: Yechan Bae <yechan@gatech.edu>
Date: Tue, 5 Oct 2021 11:43:44 -0400
Subject: Address PR comments

---
 clippy_lints/src/uninit_vec.rs         | 31 +++++++++++++-------
 clippy_lints/src/vec_init_then_push.rs |  3 +-
 clippy_utils/src/higher.rs             | 53 +++++++++++++++++++++++++++++++++-
 clippy_utils/src/lib.rs                | 49 +------------------------------
 clippy_utils/src/paths.rs              |  1 -
 tests/ui/uninit_vec.rs                 | 11 +++++--
 6 files changed, 85 insertions(+), 63 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/uninit_vec.rs b/clippy_lints/src/uninit_vec.rs
index 833c95f4940..5d6409874d8 100644
--- a/clippy_lints/src/uninit_vec.rs
+++ b/clippy_lints/src/uninit_vec.rs
@@ -1,9 +1,10 @@
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::get_vec_init_kind;
-use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{path_to_local_id, peel_hir_expr_while, ty::is_uninit_value_valid_for_ty, SpanlessEq};
+use clippy_utils::higher::get_vec_init_kind;
+use clippy_utils::ty::{is_type_diagnostic_item, is_uninit_value_valid_for_ty};
+use clippy_utils::{is_lint_allowed, path_to_local_id, peel_hir_expr_while, SpanlessEq};
 use rustc_hir::{Block, Expr, ExprKind, HirId, PatKind, PathSegment, Stmt, StmtKind};
 use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::{sym, Span};
@@ -16,10 +17,14 @@ declare_clippy_lint! {
     /// `with_capacity()` or `reserve()`.
     ///
     /// ### Why is this bad?
-    /// It creates a `Vec` with uninitialized data, which leads to an
+    /// It creates a `Vec` with uninitialized data, which leads to
     /// undefined behavior with most safe operations.
+    ///
     /// Notably, uninitialized `Vec<u8>` must not be used with generic `Read`.
     ///
+    /// ### Known Problems
+    /// This lint only checks directly adjacent statements.
+    ///
     /// ### Example
     /// ```rust,ignore
     /// let mut vec: Vec<u8> = Vec::with_capacity(1000);
@@ -52,16 +57,20 @@ declare_clippy_lint! {
 
 declare_lint_pass!(UninitVec => [UNINIT_VEC]);
 
+// FIXME: update to a visitor-based implementation.
+// Threads: https://github.com/rust-lang/rust-clippy/pull/7682#discussion_r710998368
 impl<'tcx> LateLintPass<'tcx> for UninitVec {
     fn check_block(&mut self, cx: &LateContext<'tcx>, block: &'tcx Block<'_>) {
-        for w in block.stmts.windows(2) {
-            if let StmtKind::Expr(expr) | StmtKind::Semi(expr) = w[1].kind {
-                handle_uninit_vec_pair(cx, &w[0], expr);
+        if !in_external_macro(cx.tcx.sess, block.span) {
+            for w in block.stmts.windows(2) {
+                if let StmtKind::Expr(expr) | StmtKind::Semi(expr) = w[1].kind {
+                    handle_uninit_vec_pair(cx, &w[0], expr);
+                }
             }
-        }
 
-        if let (Some(stmt), Some(expr)) = (block.stmts.last(), block.expr) {
-            handle_uninit_vec_pair(cx, stmt, expr);
+            if let (Some(stmt), Some(expr)) = (block.stmts.last(), block.expr) {
+                handle_uninit_vec_pair(cx, stmt, expr);
+            }
         }
     }
 }
@@ -79,6 +88,8 @@ fn handle_uninit_vec_pair(
         if let ty::Adt(_, substs) = vec_ty.kind();
         // Check T of Vec<T>
         if !is_uninit_value_valid_for_ty(cx, substs.type_at(0));
+        // `#[allow(...)]` attribute can be set on enclosing unsafe block of `set_len()`
+        if !is_lint_allowed(cx, UNINIT_VEC, maybe_set_len.hir_id);
         then {
             // FIXME: #7698, false positive of the internal lints
             #[allow(clippy::collapsible_span_lint_calls)]
diff --git a/clippy_lints/src/vec_init_then_push.rs b/clippy_lints/src/vec_init_then_push.rs
index 478314c0836..b92b6ca4f43 100644
--- a/clippy_lints/src/vec_init_then_push.rs
+++ b/clippy_lints/src/vec_init_then_push.rs
@@ -1,6 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::higher::{get_vec_init_kind, VecInitKind};
 use clippy_utils::source::snippet;
-use clippy_utils::{get_vec_init_kind, path_to_local, path_to_local_id, VecInitKind};
+use clippy_utils::{path_to_local, path_to_local_id};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{BindingAnnotation, Block, Expr, ExprKind, HirId, Local, PatKind, Stmt, StmtKind};
diff --git a/clippy_utils/src/higher.rs b/clippy_utils/src/higher.rs
index ba4d50bf744..d60ddbd3c56 100644
--- a/clippy_utils/src/higher.rs
+++ b/clippy_utils/src/higher.rs
@@ -2,11 +2,14 @@
 
 #![deny(clippy::missing_docs_in_private_items)]
 
+use crate::ty::is_type_diagnostic_item;
 use crate::{is_expn_of, match_def_path, paths};
 use if_chain::if_chain;
 use rustc_ast::ast::{self, LitKind};
 use rustc_hir as hir;
-use rustc_hir::{Arm, Block, BorrowKind, Expr, ExprKind, LoopSource, MatchSource, Node, Pat, StmtKind, UnOp};
+use rustc_hir::{
+    Arm, Block, BorrowKind, Expr, ExprKind, HirId, LoopSource, MatchSource, Node, Pat, QPath, StmtKind, UnOp,
+};
 use rustc_lint::LateContext;
 use rustc_span::{sym, ExpnKind, Span, Symbol};
 
@@ -632,3 +635,51 @@ impl PanicExpn<'tcx> {
         }
     }
 }
+
+/// A parsed `Vec` initialization expression
+#[derive(Clone, Copy)]
+pub enum VecInitKind {
+    /// `Vec::new()`
+    New,
+    /// `Vec::default()` or `Default::default()`
+    Default,
+    /// `Vec::with_capacity(123)`
+    WithLiteralCapacity(u64),
+    /// `Vec::with_capacity(slice.len())`
+    WithExprCapacity(HirId),
+}
+
+/// Checks if given expression is an initialization of `Vec` and returns its kind.
+pub fn get_vec_init_kind<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> Option<VecInitKind> {
+    if let ExprKind::Call(func, args) = expr.kind {
+        match func.kind {
+            ExprKind::Path(QPath::TypeRelative(ty, name))
+                if is_type_diagnostic_item(cx, cx.typeck_results().node_type(ty.hir_id), sym::Vec) =>
+            {
+                if name.ident.name == sym::new {
+                    return Some(VecInitKind::New);
+                } else if name.ident.name.as_str() == "with_capacity" {
+                    return args.get(0).and_then(|arg| {
+                        if_chain! {
+                            if let ExprKind::Lit(lit) = &arg.kind;
+                            if let LitKind::Int(num, _) = lit.node;
+                            then {
+                                Some(VecInitKind::WithLiteralCapacity(num.try_into().ok()?))
+                            } else {
+                                Some(VecInitKind::WithExprCapacity(arg.hir_id))
+                            }
+                        }
+                    });
+                }
+            }
+            ExprKind::Path(QPath::Resolved(_, path))
+                if match_def_path(cx, path.res.opt_def_id()?, &paths::DEFAULT_TRAIT_METHOD)
+                    && is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(expr), sym::Vec) =>
+            {
+                return Some(VecInitKind::Default);
+            }
+            _ => (),
+        }
+    }
+    None
+}
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index b450059e18a..09eee78f0d1 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -93,7 +93,7 @@ use rustc_span::{Span, DUMMY_SP};
 use rustc_target::abi::Integer;
 
 use crate::consts::{constant, Constant};
-use crate::ty::{can_partially_move_ty, is_copy, is_recursively_primitive_type, is_type_diagnostic_item};
+use crate::ty::{can_partially_move_ty, is_copy, is_recursively_primitive_type};
 
 pub fn parse_msrv(msrv: &str, sess: Option<&Session>, span: Option<Span>) -> Option<RustcVersion> {
     if let Ok(version) = RustcVersion::parse(msrv) {
@@ -1789,53 +1789,6 @@ pub fn is_expr_identity_function(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool
     }
 }
 
-#[derive(Clone, Copy)]
-pub enum VecInitKind {
-    /// `Vec::new()`
-    New,
-    /// `Vec::default()` or `Default::default()`
-    Default,
-    /// `Vec::with_capacity(123)`
-    WithLiteralCapacity(u64),
-    /// `Vec::with_capacity(slice.len())`
-    WithExprCapacity(HirId),
-}
-
-/// Checks if given expression is an initialization of `Vec` and returns its kind.
-pub fn get_vec_init_kind<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> Option<VecInitKind> {
-    if let ExprKind::Call(func, args) = expr.kind {
-        match func.kind {
-            ExprKind::Path(QPath::TypeRelative(ty, name))
-                if is_type_diagnostic_item(cx, cx.typeck_results().node_type(ty.hir_id), sym::Vec) =>
-            {
-                if name.ident.name == sym::new {
-                    return Some(VecInitKind::New);
-                } else if name.ident.name.as_str() == "with_capacity" {
-                    return args.get(0).and_then(|arg| {
-                        if_chain! {
-                            if let ExprKind::Lit(lit) = &arg.kind;
-                            if let LitKind::Int(num, _) = lit.node;
-                            then {
-                                Some(VecInitKind::WithLiteralCapacity(num.try_into().ok()?))
-                            } else {
-                                Some(VecInitKind::WithExprCapacity(arg.hir_id))
-                            }
-                        }
-                    });
-                }
-            }
-            ExprKind::Path(QPath::Resolved(_, path))
-                if match_def_path(cx, path.res.opt_def_id()?, &paths::DEFAULT_TRAIT_METHOD)
-                    && is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(expr), sym::Vec) =>
-            {
-                return Some(VecInitKind::Default);
-            }
-            _ => (),
-        }
-    }
-    None
-}
-
 /// Gets the node where an expression is either used, or it's type is unified with another branch.
 pub fn get_expr_use_or_unification_node(tcx: TyCtxt<'tcx>, expr: &Expr<'_>) -> Option<Node<'tcx>> {
     let mut child_id = expr.hir_id;
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index a39c0fc0b10..e43c5756021 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -183,6 +183,5 @@ pub const VEC_AS_SLICE: [&str; 4] = ["alloc", "vec", "Vec", "as_slice"];
 pub const VEC_FROM_ELEM: [&str; 3] = ["alloc", "vec", "from_elem"];
 pub const VEC_NEW: [&str; 4] = ["alloc", "vec", "Vec", "new"];
 pub const VEC_RESIZE: [&str; 4] = ["alloc", "vec", "Vec", "resize"];
-pub const VEC_SET_LEN: [&str; 4] = ["alloc", "vec", "Vec", "set_len"];
 pub const WEAK_ARC: [&str; 3] = ["alloc", "sync", "Weak"];
 pub const WEAK_RC: [&str; 3] = ["alloc", "rc", "Weak"];
diff --git a/tests/ui/uninit_vec.rs b/tests/ui/uninit_vec.rs
index e60b73a1e30..c8f9067e549 100644
--- a/tests/ui/uninit_vec.rs
+++ b/tests/ui/uninit_vec.rs
@@ -48,6 +48,13 @@ fn main() {
         my_vec.vec.set_len(200);
     }
 
+    // Test `#[allow(...)]` attributes on inner unsafe block (shouldn't trigger)
+    let mut vec: Vec<u8> = Vec::with_capacity(1000);
+    #[allow(clippy::uninit_vec)]
+    unsafe {
+        vec.set_len(200);
+    }
+
     // MaybeUninit-wrapped types should not be detected
     unsafe {
         let mut vec: Vec<MaybeUninit<u8>> = Vec::with_capacity(1000);
@@ -64,7 +71,7 @@ fn main() {
     let mut vec1: Vec<u8> = Vec::with_capacity(1000);
     let mut vec2: Vec<u8> = Vec::with_capacity(1000);
     unsafe {
-        vec1.reserve(200);
-        vec2.reserve(200);
+        vec1.set_len(200);
+        vec2.set_len(200);
     }
 }
-- 
cgit 1.4.1-3-g733a5


From 2181387c3ab4d7dc4d6e2c46c8158201a1b1045e Mon Sep 17 00:00:00 2001
From: Yechan Bae <yechan@gatech.edu>
Date: Thu, 7 Oct 2021 11:53:08 -0400
Subject: Improved error message for set_len() on empty Vec

---
 clippy_lints/src/uninit_vec.rs | 101 ++++++++++++++++++++++++++++-------------
 tests/ui/uninit_vec.stderr     |  12 ++---
 2 files changed, 73 insertions(+), 40 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/uninit_vec.rs b/clippy_lints/src/uninit_vec.rs
index 5d6409874d8..15c79da6fa9 100644
--- a/clippy_lints/src/uninit_vec.rs
+++ b/clippy_lints/src/uninit_vec.rs
@@ -1,5 +1,5 @@
-use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::higher::get_vec_init_kind;
+use clippy_utils::diagnostics::{span_lint, span_lint_and_then};
+use clippy_utils::higher::{get_vec_init_kind, VecInitKind};
 use clippy_utils::ty::{is_type_diagnostic_item, is_uninit_value_valid_for_ty};
 use clippy_utils::{is_lint_allowed, path_to_local_id, peel_hir_expr_while, SpanlessEq};
 use rustc_hir::{Block, Expr, ExprKind, HirId, PatKind, PathSegment, Stmt, StmtKind};
@@ -83,69 +83,108 @@ fn handle_uninit_vec_pair(
     if_chain! {
         if let Some(vec) = extract_init_or_reserve_target(cx, maybe_init_or_reserve);
         if let Some((set_len_self, call_span)) = extract_set_len_self(cx, maybe_set_len);
-        if vec.eq_expr(cx, set_len_self);
+        if vec.location.eq_expr(cx, set_len_self);
         if let ty::Ref(_, vec_ty, _) = cx.typeck_results().expr_ty_adjusted(set_len_self).kind();
         if let ty::Adt(_, substs) = vec_ty.kind();
-        // Check T of Vec<T>
-        if !is_uninit_value_valid_for_ty(cx, substs.type_at(0));
         // `#[allow(...)]` attribute can be set on enclosing unsafe block of `set_len()`
         if !is_lint_allowed(cx, UNINIT_VEC, maybe_set_len.hir_id);
         then {
-            // FIXME: #7698, false positive of the internal lints
-            #[allow(clippy::collapsible_span_lint_calls)]
-            span_lint_and_then(
-                cx,
-                UNINIT_VEC,
-                vec![call_span, maybe_init_or_reserve.span],
-                "calling `set_len()` immediately after reserving a buffer creates uninitialized values",
-                |diag| {
-                    diag.help("initialize the buffer or wrap the content in `MaybeUninit`");
-                },
-            );
+            if vec.has_capacity() {
+                // with_capacity / reserve -> set_len
+
+                // Check T of Vec<T>
+                if !is_uninit_value_valid_for_ty(cx, substs.type_at(0)) {
+                    // FIXME: #7698, false positive of the internal lints
+                    #[allow(clippy::collapsible_span_lint_calls)]
+                    span_lint_and_then(
+                        cx,
+                        UNINIT_VEC,
+                        vec![call_span, maybe_init_or_reserve.span],
+                        "calling `set_len()` immediately after reserving a buffer creates uninitialized values",
+                        |diag| {
+                            diag.help("initialize the buffer or wrap the content in `MaybeUninit`");
+                        },
+                    );
+                }
+            } else {
+                // new / default -> set_len
+                span_lint(
+                    cx,
+                    UNINIT_VEC,
+                    vec![call_span, maybe_init_or_reserve.span],
+                    "calling `set_len()` on empty `Vec` creates out-of-bound values",
+                )
+            }
         }
     }
 }
 
-#[derive(Clone, Copy, Debug)]
-enum LocalOrExpr<'tcx> {
+/// The target `Vec` that is initialized or reserved
+#[derive(Clone, Copy)]
+struct TargetVec<'tcx> {
+    location: VecLocation<'tcx>,
+    /// `None` if `reserve()`
+    init_kind: Option<VecInitKind>,
+}
+
+impl TargetVec<'_> {
+    pub fn has_capacity(self) -> bool {
+        !matches!(self.init_kind, Some(VecInitKind::New | VecInitKind::Default))
+    }
+}
+
+#[derive(Clone, Copy)]
+enum VecLocation<'tcx> {
     Local(HirId),
     Expr(&'tcx Expr<'tcx>),
 }
 
-impl<'tcx> LocalOrExpr<'tcx> {
-    fn eq_expr(self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
+impl<'tcx> VecLocation<'tcx> {
+    pub fn eq_expr(self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
         match self {
-            LocalOrExpr::Local(hir_id) => path_to_local_id(expr, hir_id),
-            LocalOrExpr::Expr(self_expr) => SpanlessEq::new(cx).eq_expr(self_expr, expr),
+            VecLocation::Local(hir_id) => path_to_local_id(expr, hir_id),
+            VecLocation::Expr(self_expr) => SpanlessEq::new(cx).eq_expr(self_expr, expr),
         }
     }
 }
 
 /// Finds the target location where the result of `Vec` initialization is stored
 /// or `self` expression for `Vec::reserve()`.
-fn extract_init_or_reserve_target<'tcx>(cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'tcx>) -> Option<LocalOrExpr<'tcx>> {
+fn extract_init_or_reserve_target<'tcx>(cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'tcx>) -> Option<TargetVec<'tcx>> {
     match stmt.kind {
         StmtKind::Local(local) => {
             if_chain! {
                 if let Some(init_expr) = local.init;
                 if let PatKind::Binding(_, hir_id, _, None) = local.pat.kind;
-                if get_vec_init_kind(cx, init_expr).is_some();
+                if let Some(init_kind) = get_vec_init_kind(cx, init_expr);
                 then {
-                    Some(LocalOrExpr::Local(hir_id))
-                } else {
-                    None
+                    return Some(TargetVec {
+                        location: VecLocation::Local(hir_id),
+                        init_kind: Some(init_kind),
+                    })
                 }
             }
         },
         StmtKind::Expr(expr) | StmtKind::Semi(expr) => match expr.kind {
-            ExprKind::Assign(lhs, rhs, _span) if get_vec_init_kind(cx, rhs).is_some() => Some(LocalOrExpr::Expr(lhs)),
+            ExprKind::Assign(lhs, rhs, _span) => {
+                if let Some(init_kind) = get_vec_init_kind(cx, rhs) {
+                    return Some(TargetVec {
+                        location: VecLocation::Expr(lhs),
+                        init_kind: Some(init_kind),
+                    });
+                }
+            },
             ExprKind::MethodCall(path, _, [self_expr, _], _) if is_reserve(cx, path, self_expr) => {
-                Some(LocalOrExpr::Expr(self_expr))
+                return Some(TargetVec {
+                    location: VecLocation::Expr(self_expr),
+                    init_kind: None,
+                });
             },
-            _ => None,
+            _ => (),
         },
-        StmtKind::Item(_) => None,
+        StmtKind::Item(_) => (),
     }
+    None
 }
 
 fn is_reserve(cx: &LateContext<'_>, path: &PathSegment<'_>, self_expr: &Expr<'_>) -> bool {
diff --git a/tests/ui/uninit_vec.stderr b/tests/ui/uninit_vec.stderr
index 81b91cef92a..520bfb26b62 100644
--- a/tests/ui/uninit_vec.stderr
+++ b/tests/ui/uninit_vec.stderr
@@ -21,7 +21,7 @@ LL |         vec.set_len(200);
    |
    = help: initialize the buffer or wrap the content in `MaybeUninit`
 
-error: calling `set_len()` immediately after reserving a buffer creates uninitialized values
+error: calling `set_len()` on empty `Vec` creates out-of-bound values
   --> $DIR/uninit_vec.rs:24:5
    |
 LL |     let mut vec: Vec<u8> = Vec::new();
@@ -29,10 +29,8 @@ LL |     let mut vec: Vec<u8> = Vec::new();
 LL |     unsafe {
 LL |         vec.set_len(200);
    |         ^^^^^^^^^^^^^^^^
-   |
-   = help: initialize the buffer or wrap the content in `MaybeUninit`
 
-error: calling `set_len()` immediately after reserving a buffer creates uninitialized values
+error: calling `set_len()` on empty `Vec` creates out-of-bound values
   --> $DIR/uninit_vec.rs:30:5
    |
 LL |     let mut vec: Vec<u8> = Default::default();
@@ -40,10 +38,8 @@ LL |     let mut vec: Vec<u8> = Default::default();
 LL |     unsafe {
 LL |         vec.set_len(200);
    |         ^^^^^^^^^^^^^^^^
-   |
-   = help: initialize the buffer or wrap the content in `MaybeUninit`
 
-error: calling `set_len()` immediately after reserving a buffer creates uninitialized values
+error: calling `set_len()` on empty `Vec` creates out-of-bound values
   --> $DIR/uninit_vec.rs:35:5
    |
 LL |     let mut vec: Vec<u8> = Vec::default();
@@ -51,8 +47,6 @@ LL |     let mut vec: Vec<u8> = Vec::default();
 LL |     unsafe {
 LL |         vec.set_len(200);
    |         ^^^^^^^^^^^^^^^^
-   |
-   = help: initialize the buffer or wrap the content in `MaybeUninit`
 
 error: calling `set_len()` immediately after reserving a buffer creates uninitialized values
   --> $DIR/uninit_vec.rs:49:5
-- 
cgit 1.4.1-3-g733a5


From 03fed75c89880e5ed919eec1ba93dbe769d463a2 Mon Sep 17 00:00:00 2001
From: Yechan Bae <yechan@gatech.edu>
Date: Sat, 9 Oct 2021 05:59:53 -0400
Subject: Address internal lints

---
 clippy_lints/src/uninit_vec.rs | 2 +-
 clippy_utils/src/higher.rs     | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/uninit_vec.rs b/clippy_lints/src/uninit_vec.rs
index 15c79da6fa9..2573209d1b6 100644
--- a/clippy_lints/src/uninit_vec.rs
+++ b/clippy_lints/src/uninit_vec.rs
@@ -113,7 +113,7 @@ fn handle_uninit_vec_pair(
                     UNINIT_VEC,
                     vec![call_span, maybe_init_or_reserve.span],
                     "calling `set_len()` on empty `Vec` creates out-of-bound values",
-                )
+                );
             }
         }
     }
diff --git a/clippy_utils/src/higher.rs b/clippy_utils/src/higher.rs
index 30f6831dcf4..1ff282de950 100644
--- a/clippy_utils/src/higher.rs
+++ b/clippy_utils/src/higher.rs
@@ -11,7 +11,7 @@ use rustc_hir::{
     Arm, Block, BorrowKind, Expr, ExprKind, HirId, LoopSource, MatchSource, Node, Pat, QPath, StmtKind, UnOp,
 };
 use rustc_lint::LateContext;
-use rustc_span::{sym, ExpnKind, Span, Symbol};
+use rustc_span::{sym, symbol, ExpnKind, Span, Symbol};
 
 /// The essential nodes of a desugared for loop as well as the entire span:
 /// `for pat in arg { body }` becomes `(pat, arg, body)`. Return `(pat, arg, body, span)`.
@@ -658,7 +658,7 @@ pub fn get_vec_init_kind<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -
             {
                 if name.ident.name == sym::new {
                     return Some(VecInitKind::New);
-                } else if name.ident.name.as_str() == "default" {
+                } else if name.ident.name == symbol::kw::Default {
                     return Some(VecInitKind::Default);
                 } else if name.ident.name.as_str() == "with_capacity" {
                     let arg = args.get(0)?;
-- 
cgit 1.4.1-3-g733a5


From 7aaed02b8c4cad724506a44a53b5205132ff4d20 Mon Sep 17 00:00:00 2001
From: ThibsG <thibsg@pm.me>
Date: Sat, 9 Oct 2021 14:56:33 +0200
Subject: Fix false positive when `Drop` and `Copy` involved

---
 clippy_lints/src/default.rs                 |  8 ++++
 tests/ui/field_reassign_with_default.rs     | 64 +++++++++++++++++++++++++++++
 tests/ui/field_reassign_with_default.stderr | 26 +++++++++++-
 3 files changed, 97 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/default.rs b/clippy_lints/src/default.rs
index db8f2171348..cde27d3ad2a 100644
--- a/clippy_lints/src/default.rs
+++ b/clippy_lints/src/default.rs
@@ -1,5 +1,6 @@
 use clippy_utils::diagnostics::{span_lint_and_note, span_lint_and_sugg};
 use clippy_utils::source::snippet_with_macro_callsite;
+use clippy_utils::ty::{has_drop, is_copy};
 use clippy_utils::{any_parent_is_automatically_derived, contains_name, in_macro, match_def_path, paths};
 use if_chain::if_chain;
 use rustc_data_structures::fx::FxHashSet;
@@ -139,6 +140,13 @@ impl LateLintPass<'_> for Default {
                     .fields
                     .iter()
                     .all(|field| field.vis.is_accessible_from(module_did, cx.tcx));
+                let all_fields_are_copy = variant
+                    .fields
+                    .iter()
+                    .all(|field| {
+                        is_copy(cx, cx.tcx.type_of(field.did))
+                    });
+                if !has_drop(cx, binding_type) || all_fields_are_copy;
                 then {
                     (local, variant, ident.name, binding_type, expr.span)
                 } else {
diff --git a/tests/ui/field_reassign_with_default.rs b/tests/ui/field_reassign_with_default.rs
index 787053fb000..7367910eaa1 100644
--- a/tests/ui/field_reassign_with_default.rs
+++ b/tests/ui/field_reassign_with_default.rs
@@ -183,3 +183,67 @@ struct WrapperMulti<T, U> {
     i: T,
     j: U,
 }
+
+mod issue6312 {
+    use std::sync::atomic::AtomicBool;
+    use std::sync::Arc;
+
+    // do not lint: type implements `Drop` but not all fields are `Copy`
+    #[derive(Clone, Default)]
+    pub struct ImplDropNotAllCopy {
+        name: String,
+        delay_data_sync: Arc<AtomicBool>,
+    }
+
+    impl Drop for ImplDropNotAllCopy {
+        fn drop(&mut self) {
+            self.close()
+        }
+    }
+
+    impl ImplDropNotAllCopy {
+        fn new(name: &str) -> Self {
+            let mut f = ImplDropNotAllCopy::default();
+            f.name = name.to_owned();
+            f
+        }
+        fn close(&self) {}
+    }
+
+    // lint: type implements `Drop` and all fields are `Copy`
+    #[derive(Clone, Default)]
+    pub struct ImplDropAllCopy {
+        name: usize,
+        delay_data_sync: bool,
+    }
+
+    impl Drop for ImplDropAllCopy {
+        fn drop(&mut self) {
+            self.close()
+        }
+    }
+
+    impl ImplDropAllCopy {
+        fn new(name: &str) -> Self {
+            let mut f = ImplDropAllCopy::default();
+            f.name = name.len();
+            f
+        }
+        fn close(&self) {}
+    }
+
+    // lint: type does not implement `Drop` though all fields are `Copy`
+    #[derive(Clone, Default)]
+    pub struct NoDropAllCopy {
+        name: usize,
+        delay_data_sync: bool,
+    }
+
+    impl NoDropAllCopy {
+        fn new(name: &str) -> Self {
+            let mut f = NoDropAllCopy::default();
+            f.name = name.len();
+            f
+        }
+    }
+}
diff --git a/tests/ui/field_reassign_with_default.stderr b/tests/ui/field_reassign_with_default.stderr
index b56db08ec8a..3ce4b91a548 100644
--- a/tests/ui/field_reassign_with_default.stderr
+++ b/tests/ui/field_reassign_with_default.stderr
@@ -107,5 +107,29 @@ note: consider initializing the variable with `WrapperMulti::<i32, i64> { i: 42,
 LL |     let mut a: WrapperMulti<i32, i64> = Default::default();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 9 previous errors
+error: field assignment outside of initializer for an instance created with Default::default()
+  --> $DIR/field_reassign_with_default.rs:229:13
+   |
+LL |             f.name = name.len();
+   |             ^^^^^^^^^^^^^^^^^^^^
+   |
+note: consider initializing the variable with `issue6312::ImplDropAllCopy { name: name.len(), ..Default::default() }` and removing relevant reassignments
+  --> $DIR/field_reassign_with_default.rs:228:13
+   |
+LL |             let mut f = ImplDropAllCopy::default();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: field assignment outside of initializer for an instance created with Default::default()
+  --> $DIR/field_reassign_with_default.rs:245:13
+   |
+LL |             f.name = name.len();
+   |             ^^^^^^^^^^^^^^^^^^^^
+   |
+note: consider initializing the variable with `issue6312::NoDropAllCopy { name: name.len(), ..Default::default() }` and removing relevant reassignments
+  --> $DIR/field_reassign_with_default.rs:244:13
+   |
+LL |             let mut f = NoDropAllCopy::default();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 11 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 1e18b8a269f58b15da39a1ffa9f4c29b2a55bae8 Mon Sep 17 00:00:00 2001
From: ThibsG <thibsg@pm.me>
Date: Sat, 9 Oct 2021 15:54:16 +0200
Subject: Fix FP in external macros for `mut_mut` lint

---
 clippy_lints/src/mut_mut.rs       |  4 ++++
 tests/ui/auxiliary/macro_rules.rs |  7 +++++++
 tests/ui/mut_mut.rs               | 10 ++++++++++
 tests/ui/mut_mut.stderr           | 18 +++++++++---------
 4 files changed, 30 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/mut_mut.rs b/clippy_lints/src/mut_mut.rs
index 610152a217f..7c4cac29ba8 100644
--- a/clippy_lints/src/mut_mut.rs
+++ b/clippy_lints/src/mut_mut.rs
@@ -82,6 +82,10 @@ impl<'a, 'tcx> intravisit::Visitor<'tcx> for MutVisitor<'a, 'tcx> {
     }
 
     fn visit_ty(&mut self, ty: &'tcx hir::Ty<'_>) {
+        if in_external_macro(self.cx.sess(), ty.span) {
+            return;
+        }
+
         if let hir::TyKind::Rptr(
             _,
             hir::MutTy {
diff --git a/tests/ui/auxiliary/macro_rules.rs b/tests/ui/auxiliary/macro_rules.rs
index 170955e726c..0251fada9e8 100644
--- a/tests/ui/auxiliary/macro_rules.rs
+++ b/tests/ui/auxiliary/macro_rules.rs
@@ -113,3 +113,10 @@ macro_rules! default_numeric_fallback {
         let x = 22;
     };
 }
+
+#[macro_export]
+macro_rules! mut_mut {
+    () => {
+        let mut_mut_ty: &mut &mut u32 = &mut &mut 1u32;
+    };
+}
diff --git a/tests/ui/mut_mut.rs b/tests/ui/mut_mut.rs
index 8965cef66de..be854d94183 100644
--- a/tests/ui/mut_mut.rs
+++ b/tests/ui/mut_mut.rs
@@ -1,6 +1,11 @@
+// aux-build:macro_rules.rs
+
 #![allow(unused, clippy::no_effect, clippy::unnecessary_operation)]
 #![warn(clippy::mut_mut)]
 
+#[macro_use]
+extern crate macro_rules;
+
 fn fun(x: &mut &mut u32) -> bool {
     **x > 0
 }
@@ -47,3 +52,8 @@ fn issue939() {
         println!(":{}", arg);
     }
 }
+
+fn issue6922() {
+    // do not lint from an external macro
+    mut_mut!();
+}
diff --git a/tests/ui/mut_mut.stderr b/tests/ui/mut_mut.stderr
index 0fed6953cb8..6820a85aa54 100644
--- a/tests/ui/mut_mut.stderr
+++ b/tests/ui/mut_mut.stderr
@@ -1,5 +1,5 @@
 error: generally you want to avoid `&mut &mut _` if possible
-  --> $DIR/mut_mut.rs:4:11
+  --> $DIR/mut_mut.rs:9:11
    |
 LL | fn fun(x: &mut &mut u32) -> bool {
    |           ^^^^^^^^^^^^^
@@ -7,13 +7,13 @@ LL | fn fun(x: &mut &mut u32) -> bool {
    = note: `-D clippy::mut-mut` implied by `-D warnings`
 
 error: generally you want to avoid `&mut &mut _` if possible
-  --> $DIR/mut_mut.rs:20:17
+  --> $DIR/mut_mut.rs:25:17
    |
 LL |     let mut x = &mut &mut 1u32;
    |                 ^^^^^^^^^^^^^^
 
 error: generally you want to avoid `&mut &mut _` if possible
-  --> $DIR/mut_mut.rs:14:9
+  --> $DIR/mut_mut.rs:19:9
    |
 LL |         &mut $p
    |         ^^^^^^^
@@ -24,37 +24,37 @@ LL |     let mut z = mut_ptr!(&mut 3u32);
    = note: this error originates in the macro `mut_ptr` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: this expression mutably borrows a mutable reference. Consider reborrowing
-  --> $DIR/mut_mut.rs:22:21
+  --> $DIR/mut_mut.rs:27:21
    |
 LL |         let mut y = &mut x;
    |                     ^^^^^^
 
 error: generally you want to avoid `&mut &mut _` if possible
-  --> $DIR/mut_mut.rs:26:32
+  --> $DIR/mut_mut.rs:31:32
    |
 LL |         let y: &mut &mut u32 = &mut &mut 2;
    |                                ^^^^^^^^^^^
 
 error: generally you want to avoid `&mut &mut _` if possible
-  --> $DIR/mut_mut.rs:26:16
+  --> $DIR/mut_mut.rs:31:16
    |
 LL |         let y: &mut &mut u32 = &mut &mut 2;
    |                ^^^^^^^^^^^^^
 
 error: generally you want to avoid `&mut &mut _` if possible
-  --> $DIR/mut_mut.rs:31:37
+  --> $DIR/mut_mut.rs:36:37
    |
 LL |         let y: &mut &mut &mut u32 = &mut &mut &mut 2;
    |                                     ^^^^^^^^^^^^^^^^
 
 error: generally you want to avoid `&mut &mut _` if possible
-  --> $DIR/mut_mut.rs:31:16
+  --> $DIR/mut_mut.rs:36:16
    |
 LL |         let y: &mut &mut &mut u32 = &mut &mut &mut 2;
    |                ^^^^^^^^^^^^^^^^^^
 
 error: generally you want to avoid `&mut &mut _` if possible
-  --> $DIR/mut_mut.rs:31:21
+  --> $DIR/mut_mut.rs:36:21
    |
 LL |         let y: &mut &mut &mut u32 = &mut &mut &mut 2;
    |                     ^^^^^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From fc324255215066afd4f4dfff6f39e76e2c80fc4b Mon Sep 17 00:00:00 2001
From: 1nF0rmed <prkinformed@gmail.com>
Date: Sat, 9 Oct 2021 22:30:12 +0530
Subject: Refactor to check for multiple reference patterns

---
 clippy_lints/src/matches.rs                   | 10 ++---
 tests/ui/match_expr_like_matches_macro.stderr | 35 +---------------
 tests/ui/match_ref_pats.stderr                | 58 +--------------------------
 3 files changed, 7 insertions(+), 96 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index 56d4163a6b3..b643fba5d32 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -1187,7 +1187,7 @@ where
     'b: 'a,
     I: Clone + Iterator<Item = &'a Pat<'b>>,
 {
-    if !has_only_ref_pats(pats.clone()) {
+    if !has_multiple_ref_pats(pats.clone()) {
         return;
     }
 
@@ -1693,12 +1693,12 @@ fn is_ref_some_arm(cx: &LateContext<'_>, arm: &Arm<'_>) -> Option<BindingAnnotat
     None
 }
 
-fn has_only_ref_pats<'a, 'b, I>(pats: I) -> bool
+fn has_multiple_ref_pats<'a, 'b, I>(pats: I) -> bool
 where
     'b: 'a,
     I: Iterator<Item = &'a Pat<'b>>,
 {
-    let mut at_least_one_is_true = false;
+    let mut ref_count = 0;
     for opt in pats.map(|pat| match pat.kind {
         PatKind::Ref(..) => Some(true), // &-patterns
         PatKind::Wild => Some(false),   // an "anything" wildcard is also fine
@@ -1706,13 +1706,13 @@ where
     }) {
         if let Some(inner) = opt {
             if inner {
-                at_least_one_is_true = true;
+                ref_count += 1;
             }
         } else {
             return false;
         }
     }
-    at_least_one_is_true
+    ref_count > 1
 }
 
 pub fn overlapping<T>(ranges: &[SpannedRange<T>]) -> Option<(&SpannedRange<T>, &SpannedRange<T>)>
diff --git a/tests/ui/match_expr_like_matches_macro.stderr b/tests/ui/match_expr_like_matches_macro.stderr
index 366ef36c367..d7cedf9f9f1 100644
--- a/tests/ui/match_expr_like_matches_macro.stderr
+++ b/tests/ui/match_expr_like_matches_macro.stderr
@@ -110,23 +110,6 @@ LL | |             _ => false,
 LL | |         };
    | |_________^ help: try this: `matches!(&val, &Some(ref _a))`
 
-error: you don't need to add `&` to both the expression and the patterns
-  --> $DIR/match_expr_like_matches_macro.rs:166:20
-   |
-LL |           let _res = match &val {
-   |  ____________________^
-LL | |             &Some(ref _a) => true,
-LL | |             _ => false,
-LL | |         };
-   | |_________^
-   |
-   = note: `-D clippy::match-ref-pats` implied by `-D warnings`
-help: try
-   |
-LL ~         let _res = match val {
-LL ~             Some(ref _a) => true,
-   |
-
 error: match expression looks like `matches!` macro
   --> $DIR/match_expr_like_matches_macro.rs:178:20
    |
@@ -137,21 +120,5 @@ LL | |             _ => false,
 LL | |         };
    | |_________^ help: try this: `matches!(&val, &Some(ref _a))`
 
-error: you don't need to add `&` to both the expression and the patterns
-  --> $DIR/match_expr_like_matches_macro.rs:178:20
-   |
-LL |           let _res = match &val {
-   |  ____________________^
-LL | |             &Some(ref _a) => true,
-LL | |             _ => false,
-LL | |         };
-   | |_________^
-   |
-help: try
-   |
-LL ~         let _res = match val {
-LL ~             Some(ref _a) => true,
-   |
-
-error: aborting due to 14 previous errors
+error: aborting due to 12 previous errors
 
diff --git a/tests/ui/match_ref_pats.stderr b/tests/ui/match_ref_pats.stderr
index 072aff445e9..e4e13c32d74 100644
--- a/tests/ui/match_ref_pats.stderr
+++ b/tests/ui/match_ref_pats.stderr
@@ -15,21 +15,6 @@ LL ~             Some(v) => println!("{:?}", v),
 LL ~             None => println!("none"),
    |
 
-error: you don't need to add `&` to all patterns
-  --> $DIR/match_ref_pats.rs:18:5
-   |
-LL | /     match tup {
-LL | |         &(v, 1) => println!("{}", v),
-LL | |         _ => println!("none"),
-LL | |     }
-   | |_____^
-   |
-help: instead of prefixing all patterns with `&`, you can dereference the expression
-   |
-LL ~     match *tup {
-LL ~         (v, 1) => println!("{}", v),
-   |
-
 error: you don't need to add `&` to both the expression and the patterns
   --> $DIR/match_ref_pats.rs:24:5
    |
@@ -54,52 +39,11 @@ LL |     if let &None = a {
    |
    = note: `-D clippy::redundant-pattern-matching` implied by `-D warnings`
 
-error: you don't need to add `&` to all patterns
-  --> $DIR/match_ref_pats.rs:36:5
-   |
-LL | /     if let &None = a {
-LL | |         println!("none");
-LL | |     }
-   | |_____^
-   |
-help: instead of prefixing all patterns with `&`, you can dereference the expression
-   |
-LL |     if let None = *a {
-   |            ~~~~   ~~
-
 error: redundant pattern matching, consider using `is_none()`
   --> $DIR/match_ref_pats.rs:41:12
    |
 LL |     if let &None = &b {
    |     -------^^^^^----- help: try this: `if b.is_none()`
 
-error: you don't need to add `&` to both the expression and the patterns
-  --> $DIR/match_ref_pats.rs:41:5
-   |
-LL | /     if let &None = &b {
-LL | |         println!("none");
-LL | |     }
-   | |_____^
-   |
-help: try
-   |
-LL |     if let None = b {
-   |            ~~~~   ~
-
-error: you don't need to add `&` to all patterns
-  --> $DIR/match_ref_pats.rs:68:9
-   |
-LL | /         match foo_variant!(0) {
-LL | |             &Foo::A => println!("A"),
-LL | |             _ => println!("Wild"),
-LL | |         }
-   | |_________^
-   |
-help: instead of prefixing all patterns with `&`, you can dereference the expression
-   |
-LL ~         match *foo_variant!(0) {
-LL ~             Foo::A => println!("A"),
-   |
-
-error: aborting due to 8 previous errors
+error: aborting due to 4 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 857a4073b8b76bd29ff9504b5f015e5021b5d9b2 Mon Sep 17 00:00:00 2001
From: James Hinshelwood <jameshinshelwood1@gmail.com>
Date: Mon, 11 Oct 2021 08:25:30 +0100
Subject: Add reason config example for disallowed_type

Co-authored-by: James Hinshelwood <james.hinshelwood@bigpayme.com>
---
 clippy_lints/src/disallowed_type.rs | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/disallowed_type.rs b/clippy_lints/src/disallowed_type.rs
index 261e9af11c8..8113c388018 100644
--- a/clippy_lints/src/disallowed_type.rs
+++ b/clippy_lints/src/disallowed_type.rs
@@ -21,7 +21,15 @@ declare_clippy_lint! {
     /// An example clippy.toml configuration:
     /// ```toml
     /// # clippy.toml
-    /// disallowed-types = ["std::collections::BTreeMap"]
+    /// disallowed-types = [
+    ///     # Can use a string as the path of the disallowed type.
+    ///     "std::collections::BTreeMap",
+    ///     # Can also use an inline table with a `path` key.
+    ///     { path = "std::net::TcpListener" },
+    ///     # When using an inline table, can add a `reason` for why the type
+    ///     # is disallowed.
+    ///     { path = "std::net::Ipv4Addr", reason = "no IPv4 allowed" },
+    /// ]
     /// ```
     ///
     /// ```rust,ignore
-- 
cgit 1.4.1-3-g733a5


From 886cbb18821bdd9a5548dedbe6caa0ccb2dafb3f Mon Sep 17 00:00:00 2001
From: James Hinshelwood <jameshinshelwood1@gmail.com>
Date: Mon, 11 Oct 2021 08:28:32 +0100
Subject: Rename `disallowed` to `conf_disallowed`

Co-authored-by: James Hinshelwood <james.hinshelwood@bigpayme.com>
---
 clippy_lints/src/disallowed_type.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/disallowed_type.rs b/clippy_lints/src/disallowed_type.rs
index 8113c388018..48f781516f4 100644
--- a/clippy_lints/src/disallowed_type.rs
+++ b/clippy_lints/src/disallowed_type.rs
@@ -48,15 +48,15 @@ declare_clippy_lint! {
 }
 #[derive(Clone, Debug)]
 pub struct DisallowedType {
-    disallowed: Vec<conf::DisallowedType>,
+    conf_disallowed: Vec<conf::DisallowedType>,
     def_ids: FxHashMap<DefId, Option<String>>,
     prim_tys: FxHashMap<PrimTy, Option<String>>,
 }
 
 impl DisallowedType {
-    pub fn new(disallowed: Vec<conf::DisallowedType>) -> Self {
+    pub fn new(conf_disallowed: Vec<conf::DisallowedType>) -> Self {
         Self {
-            disallowed,
+            conf_disallowed,
             def_ids: FxHashMap::default(),
             prim_tys: FxHashMap::default(),
         }
@@ -83,7 +83,7 @@ impl_lint_pass!(DisallowedType => [DISALLOWED_TYPE]);
 
 impl<'tcx> LateLintPass<'tcx> for DisallowedType {
     fn check_crate(&mut self, cx: &LateContext<'_>) {
-        for conf in &self.disallowed {
+        for conf in &self.conf_disallowed {
             let (path, reason) = match conf {
                 conf::DisallowedType::Simple(path) => (path, None),
                 conf::DisallowedType::WithReason { path, reason } => (
-- 
cgit 1.4.1-3-g733a5


From 9e0ce14700070a5cf61ebdb542cefd70a1dd9b0c Mon Sep 17 00:00:00 2001
From: Serial <69764315+Serial-ATA@users.noreply.github.com>
Date: Mon, 11 Oct 2021 20:19:34 -0400
Subject: Add match_str_case_mismatch lint

---
 CHANGELOG.md                                 |   1 +
 clippy_lints/src/lib.register_all.rs         |   1 +
 clippy_lints/src/lib.register_correctness.rs |   1 +
 clippy_lints/src/lib.register_lints.rs       |   1 +
 clippy_lints/src/lib.rs                      |   2 +
 clippy_lints/src/match_str_case_mismatch.rs  | 166 +++++++++++++++++++++++++++
 tests/ui/match_str_case_mismatch.rs          |  98 ++++++++++++++++
 tests/ui/match_str_case_mismatch.stderr      |  53 +++++++++
 8 files changed, 323 insertions(+)
 create mode 100644 clippy_lints/src/match_str_case_mismatch.rs
 create mode 100644 tests/ui/match_str_case_mismatch.rs
 create mode 100644 tests/ui/match_str_case_mismatch.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 13067e4e92a..1f79d9e73db 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2837,6 +2837,7 @@ Released 2018-09-13
 [`match_result_ok`]: https://rust-lang.github.io/rust-clippy/master/index.html#match_result_ok
 [`match_same_arms`]: https://rust-lang.github.io/rust-clippy/master/index.html#match_same_arms
 [`match_single_binding`]: https://rust-lang.github.io/rust-clippy/master/index.html#match_single_binding
+[`match_str_case_mismatch`]: https://rust-lang.github.io/rust-clippy/master/index.html#match_str_case_mismatch
 [`match_wild_err_arm`]: https://rust-lang.github.io/rust-clippy/master/index.html#match_wild_err_arm
 [`match_wildcard_for_single_variants`]: https://rust-lang.github.io/rust-clippy/master/index.html#match_wildcard_for_single_variants
 [`maybe_infinite_iter`]: https://rust-lang.github.io/rust-clippy/master/index.html#maybe_infinite_iter
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 3e6e0244754..e544c6607e8 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -118,6 +118,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(map_unit_fn::OPTION_MAP_UNIT_FN),
     LintId::of(map_unit_fn::RESULT_MAP_UNIT_FN),
     LintId::of(match_result_ok::MATCH_RESULT_OK),
+    LintId::of(match_str_case_mismatch::MATCH_STR_CASE_MISMATCH),
     LintId::of(matches::INFALLIBLE_DESTRUCTURING_MATCH),
     LintId::of(matches::MATCH_AS_REF),
     LintId::of(matches::MATCH_LIKE_MATCHES_MACRO),
diff --git a/clippy_lints/src/lib.register_correctness.rs b/clippy_lints/src/lib.register_correctness.rs
index e0ef7b3b8af..1c2441d1af2 100644
--- a/clippy_lints/src/lib.register_correctness.rs
+++ b/clippy_lints/src/lib.register_correctness.rs
@@ -36,6 +36,7 @@ store.register_group(true, "clippy::correctness", Some("clippy_correctness"), ve
     LintId::of(loops::ITER_NEXT_LOOP),
     LintId::of(loops::NEVER_LOOP),
     LintId::of(loops::WHILE_IMMUTABLE_CONDITION),
+    LintId::of(match_str_case_mismatch::MATCH_STR_CASE_MISMATCH),
     LintId::of(mem_discriminant::MEM_DISCRIMINANT_NON_ENUM),
     LintId::of(mem_replace::MEM_REPLACE_WITH_UNINIT),
     LintId::of(methods::CLONE_DOUBLE_REF),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 3c4b720671a..d5673ad2c7c 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -226,6 +226,7 @@ store.register_lints(&[
     map_unit_fn::RESULT_MAP_UNIT_FN,
     match_on_vec_items::MATCH_ON_VEC_ITEMS,
     match_result_ok::MATCH_RESULT_OK,
+    match_str_case_mismatch::MATCH_STR_CASE_MISMATCH,
     matches::INFALLIBLE_DESTRUCTURING_MATCH,
     matches::MATCH_AS_REF,
     matches::MATCH_BOOL,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 7e1bcbbd0ed..73d21eb5b52 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -265,6 +265,7 @@ mod map_err_ignore;
 mod map_unit_fn;
 mod match_on_vec_items;
 mod match_result_ok;
+mod match_str_case_mismatch;
 mod matches;
 mod mem_discriminant;
 mod mem_forget;
@@ -771,6 +772,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     let enable_raw_pointer_heuristic_for_send = conf.enable_raw_pointer_heuristic_for_send;
     store.register_late_pass(move || Box::new(non_send_fields_in_send_ty::NonSendFieldInSendTy::new(enable_raw_pointer_heuristic_for_send)));
     store.register_late_pass(move || Box::new(undocumented_unsafe_blocks::UndocumentedUnsafeBlocks::default()));
+    store.register_late_pass(|| Box::new(match_str_case_mismatch::MatchStrCaseMismatch));
 }
 
 #[rustfmt::skip]
diff --git a/clippy_lints/src/match_str_case_mismatch.rs b/clippy_lints/src/match_str_case_mismatch.rs
new file mode 100644
index 00000000000..dd8b5cb4a21
--- /dev/null
+++ b/clippy_lints/src/match_str_case_mismatch.rs
@@ -0,0 +1,166 @@
+use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::ty::is_type_diagnostic_item;
+use rustc_ast::ast::LitKind;
+use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
+use rustc_hir::{Arm, Expr, ExprKind, MatchSource, PatKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::hir::map::Map;
+use rustc_middle::lint::in_external_macro;
+use rustc_middle::ty;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::{sym, Span};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `match` expressions modifying the case of a string with non-compliant arms
+    ///
+    /// ### Why is this bad?
+    /// The arm is unreachable, which is likely a mistake
+    ///
+    /// ### Example
+    /// ```rust
+    /// match &*text.to_ascii_lowercase() {
+    ///     "foo" => {},
+    ///     "Bar" => {},
+    ///     _ => {},
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// match &*text.to_ascii_lowercase() {
+    ///     "foo" => {},
+    ///     "bar" => {},
+    ///     _ => {},
+    /// }
+    /// ```
+    pub MATCH_STR_CASE_MISMATCH,
+    correctness,
+    "creation of a case altering match expression with non-compliant arms"
+}
+
+declare_lint_pass!(MatchStrCaseMismatch => [MATCH_STR_CASE_MISMATCH]);
+
+#[derive(Debug)]
+enum CaseMethod {
+    LowerCase,
+    AsciiLowerCase,
+    UpperCase,
+    AsciiUppercase,
+}
+
+impl LateLintPass<'_> for MatchStrCaseMismatch {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        if_chain! {
+            if !in_external_macro(cx.tcx.sess, expr.span);
+            if let ExprKind::Match(match_expr, arms, MatchSource::Normal) = expr.kind;
+            if let ty::Ref(_, ty, _) = cx.typeck_results().expr_ty(match_expr).kind();
+            if let ty::Str = ty.kind();
+            then {
+                let mut visitor = MatchExprVisitor {
+                    cx,
+                    case_method: None,
+                };
+
+                visitor.visit_expr(match_expr);
+
+                if let Some(case_method) = visitor.case_method {
+                    if let Some(bad_case) = verify_case(&case_method, arms) {
+                        lint(cx, expr.span, &case_method, bad_case);
+                    }
+                }
+            }
+        }
+    }
+}
+
+struct MatchExprVisitor<'a, 'tcx> {
+    cx: &'a LateContext<'tcx>,
+    case_method: Option<CaseMethod>,
+}
+
+impl<'a, 'tcx> Visitor<'tcx> for MatchExprVisitor<'a, 'tcx> {
+    type Map = Map<'tcx>;
+
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::None
+    }
+
+    fn visit_expr(&mut self, ex: &'tcx Expr<'_>) {
+        match ex.kind {
+            ExprKind::MethodCall(segment, _, [receiver], _)
+                if self.case_altered(&*segment.ident.as_str(), receiver) => {},
+            _ => walk_expr(self, ex),
+        }
+    }
+}
+
+impl<'a, 'tcx> MatchExprVisitor<'a, 'tcx> {
+    fn case_altered(&mut self, segment_ident: &str, receiver: &Expr<'_>) -> bool {
+        if let Some(case_method) = get_case_method(segment_ident) {
+            let ty = self.cx.typeck_results().expr_ty(receiver).peel_refs();
+
+            if is_type_diagnostic_item(self.cx, ty, sym::String) || ty.kind() == &ty::Str {
+                self.case_method = Some(case_method);
+                return true;
+            }
+        }
+
+        false
+    }
+}
+
+fn get_case_method(segment_ident_str: &str) -> Option<CaseMethod> {
+    match segment_ident_str {
+        "to_lowercase" => Some(CaseMethod::LowerCase),
+        "to_ascii_lowercase" => Some(CaseMethod::AsciiLowerCase),
+        "to_uppercase" => Some(CaseMethod::UpperCase),
+        "to_ascii_uppercase" => Some(CaseMethod::AsciiUppercase),
+        _ => None,
+    }
+}
+
+fn verify_case(case_method: &CaseMethod, arms: &'_ [Arm<'_>]) -> Option<Span> {
+    let mut bad_case = None;
+
+    let case_check = match case_method {
+        CaseMethod::LowerCase => |input: &str| -> bool { input.chars().all(char::is_lowercase) },
+        CaseMethod::AsciiLowerCase => |input: &str| -> bool { input.chars().all(|c| matches!(c, 'a'..='z')) },
+        CaseMethod::UpperCase => |input: &str| -> bool { input.chars().all(char::is_uppercase) },
+        CaseMethod::AsciiUppercase => |input: &str| -> bool { input.chars().all(|c| matches!(c, 'A'..='Z')) },
+    };
+
+    for arm in arms {
+        if_chain! {
+            if let PatKind::Lit(Expr {
+                                kind: ExprKind::Lit(lit),
+                                ..
+                            }) = arm.pat.kind;
+            if let LitKind::Str(symbol, _) = lit.node;
+            if !case_check(&symbol.as_str());
+            then {
+                bad_case = Some(lit.span);
+                break;
+            }
+        }
+    }
+
+    bad_case
+}
+
+fn lint(cx: &LateContext<'_>, expr_span: Span, case_method: &CaseMethod, bad_case_span: Span) {
+    let method_str = match case_method {
+        CaseMethod::LowerCase => "to_lower_case",
+        CaseMethod::AsciiLowerCase => "to_ascii_lowercase",
+        CaseMethod::UpperCase => "to_uppercase",
+        CaseMethod::AsciiUppercase => "to_ascii_uppercase",
+    };
+
+    span_lint_and_help(
+        cx,
+        MATCH_STR_CASE_MISMATCH,
+        expr_span,
+        "this `match` expression alters case, but has non-compliant arms",
+        Some(bad_case_span),
+        &*format!("consider changing the case of this arm to respect `{}`", method_str),
+    );
+}
diff --git a/tests/ui/match_str_case_mismatch.rs b/tests/ui/match_str_case_mismatch.rs
new file mode 100644
index 00000000000..208a4bba3d2
--- /dev/null
+++ b/tests/ui/match_str_case_mismatch.rs
@@ -0,0 +1,98 @@
+#![warn(clippy::match_str_case_mismatch)]
+
+// Valid
+
+fn as_str_match() {
+    let var = "BAR";
+
+    match var.to_ascii_lowercase().as_str() {
+        "foo" => {},
+        "bar" => {},
+        _ => {},
+    }
+}
+
+fn addrof_unary_match() {
+    let var = "BAR";
+
+    match &*var.to_ascii_lowercase() {
+        "foo" => {},
+        "bar" => {},
+        _ => {},
+    }
+}
+
+fn alternating_chain() {
+    let var = "BAR";
+
+    match &*var
+        .to_ascii_lowercase()
+        .to_uppercase()
+        .to_lowercase()
+        .to_ascii_uppercase()
+    {
+        "FOO" => {},
+        "BAR" => {},
+        _ => {},
+    }
+}
+
+fn unrelated_method() {
+    struct Item {
+        a: String,
+    }
+
+    impl Item {
+        #[allow(clippy::wrong_self_convention)]
+        fn to_lowercase(self) -> String {
+            self.a
+        }
+    }
+
+    let item = Item { a: String::from("BAR") };
+
+    match &*item.to_lowercase() {
+        "FOO" => {},
+        "BAR" => {},
+        _ => {},
+    }
+}
+
+// Invalid
+
+fn as_str_match_mismatch() {
+    let var = "BAR";
+
+    match var.to_ascii_lowercase().as_str() {
+        "foo" => {},
+        "Bar" => {},
+        _ => {},
+    }
+}
+
+fn addrof_unary_match_mismatch() {
+    let var = "BAR";
+
+    match &*var.to_ascii_lowercase() {
+        "foo" => {},
+        "Bar" => {},
+        _ => {},
+    }
+}
+
+fn alternating_chain_mismatch() {
+    let var = "BAR";
+
+    match &*var
+        .to_ascii_lowercase()
+        .to_uppercase()
+        .to_lowercase()
+        .to_ascii_uppercase()
+    {
+        "FOO" => {},
+        "bAR" => {},
+        _ => {},
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/match_str_case_mismatch.stderr b/tests/ui/match_str_case_mismatch.stderr
new file mode 100644
index 00000000000..a5eab1f72f3
--- /dev/null
+++ b/tests/ui/match_str_case_mismatch.stderr
@@ -0,0 +1,53 @@
+error: this `match` expression alters case, but has non-compliant arms
+  --> $DIR/match_str_case_mismatch.rs:66:5
+   |
+LL | /     match var.to_ascii_lowercase().as_str() {
+LL | |         "foo" => {},
+LL | |         "Bar" => {},
+LL | |         _ => {},
+LL | |     }
+   | |_____^
+   |
+   = note: `-D clippy::match-str-case-mismatch` implied by `-D warnings`
+help: consider changing the case of this arm to respect `to_ascii_lowercase`
+  --> $DIR/match_str_case_mismatch.rs:68:9
+   |
+LL |         "Bar" => {},
+   |         ^^^^^
+
+error: this `match` expression alters case, but has non-compliant arms
+  --> $DIR/match_str_case_mismatch.rs:76:5
+   |
+LL | /     match &*var.to_ascii_lowercase() {
+LL | |         "foo" => {},
+LL | |         "Bar" => {},
+LL | |         _ => {},
+LL | |     }
+   | |_____^
+   |
+help: consider changing the case of this arm to respect `to_ascii_lowercase`
+  --> $DIR/match_str_case_mismatch.rs:78:9
+   |
+LL |         "Bar" => {},
+   |         ^^^^^
+
+error: this `match` expression alters case, but has non-compliant arms
+  --> $DIR/match_str_case_mismatch.rs:86:5
+   |
+LL | /     match &*var
+LL | |         .to_ascii_lowercase()
+LL | |         .to_uppercase()
+LL | |         .to_lowercase()
+...  |
+LL | |         _ => {},
+LL | |     }
+   | |_____^
+   |
+help: consider changing the case of this arm to respect `to_ascii_uppercase`
+  --> $DIR/match_str_case_mismatch.rs:93:9
+   |
+LL |         "bAR" => {},
+   |         ^^^^^
+
+error: aborting due to 3 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 99bfee720119240d8eb64c2fd395aeaecc683b9a Mon Sep 17 00:00:00 2001
From: Serial <69764315+Serial-ATA@users.noreply.github.com>
Date: Mon, 11 Oct 2021 20:40:13 -0400
Subject: Don't run examples

---
 clippy_lints/src/match_str_case_mismatch.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/match_str_case_mismatch.rs b/clippy_lints/src/match_str_case_mismatch.rs
index dd8b5cb4a21..ae6d2b6c79d 100644
--- a/clippy_lints/src/match_str_case_mismatch.rs
+++ b/clippy_lints/src/match_str_case_mismatch.rs
@@ -18,7 +18,7 @@ declare_clippy_lint! {
     /// The arm is unreachable, which is likely a mistake
     ///
     /// ### Example
-    /// ```rust
+    /// ```rust,no_run
     /// match &*text.to_ascii_lowercase() {
     ///     "foo" => {},
     ///     "Bar" => {},
@@ -26,7 +26,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```rust,no_run
     /// match &*text.to_ascii_lowercase() {
     ///     "foo" => {},
     ///     "bar" => {},
-- 
cgit 1.4.1-3-g733a5


From 5adf17cb43d62e7e02c13f32def548b724bf2148 Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukastw97@gmail.com>
Date: Tue, 12 Oct 2021 09:42:42 +0200
Subject: Bring `manual_split_once` docs in line with other lint docs

---
 clippy_lints/src/methods/mod.rs | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index b26d11c0d6b..26c29fbb289 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1777,14 +1777,13 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for usages of `str::splitn(2, _)`
-    ///
-    /// **Why is this bad?** `split_once` is both clearer in intent and slightly more efficient.
-    ///
-    /// **Known problems:** None.
+    /// ### What it does
+    /// Checks for usages of `str::splitn(2, _)`
     ///
-    /// **Example:**
+    /// ### Why is this bad?
+    /// `split_once` is both clearer in intent and slightly more efficient.
     ///
+    /// ### Example
     /// ```rust,ignore
     /// // Bad
     ///  let (key, value) = _.splitn(2, '=').next_tuple()?;
-- 
cgit 1.4.1-3-g733a5


From 0c99de0ab2a83740c921e4b4bfc67177c787ff36 Mon Sep 17 00:00:00 2001
From: Serial <69764315+Serial-ATA@users.noreply.github.com>
Date: Tue, 12 Oct 2021 07:13:19 -0400
Subject: Add a suggestion

---
 clippy_lints/src/match_str_case_mismatch.rs | 49 ++++++++++++++------------
 tests/ui/match_str_case_mismatch.stderr     | 53 ++++++++++-------------------
 2 files changed, 45 insertions(+), 57 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/match_str_case_mismatch.rs b/clippy_lints/src/match_str_case_mismatch.rs
index ae6d2b6c79d..a83f38e3d51 100644
--- a/clippy_lints/src/match_str_case_mismatch.rs
+++ b/clippy_lints/src/match_str_case_mismatch.rs
@@ -1,6 +1,7 @@
-use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_ast::ast::LitKind;
+use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
 use rustc_hir::{Arm, Expr, ExprKind, MatchSource, PatKind};
 use rustc_lint::{LateContext, LateLintPass};
@@ -8,6 +9,7 @@ use rustc_middle::hir::map::Map;
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::symbol::SymbolStr;
 use rustc_span::{sym, Span};
 
 declare_clippy_lint! {
@@ -18,7 +20,9 @@ declare_clippy_lint! {
     /// The arm is unreachable, which is likely a mistake
     ///
     /// ### Example
-    /// ```rust,no_run
+    /// ```rust
+    /// # let text = "Foo";
+    ///
     /// match &*text.to_ascii_lowercase() {
     ///     "foo" => {},
     ///     "Bar" => {},
@@ -26,7 +30,9 @@ declare_clippy_lint! {
     /// }
     /// ```
     /// Use instead:
-    /// ```rust,no_run
+    /// ```rust
+    /// # let text = "Foo";
+    ///
     /// match &*text.to_ascii_lowercase() {
     ///     "foo" => {},
     ///     "bar" => {},
@@ -64,8 +70,8 @@ impl LateLintPass<'_> for MatchStrCaseMismatch {
                 visitor.visit_expr(match_expr);
 
                 if let Some(case_method) = visitor.case_method {
-                    if let Some(bad_case) = verify_case(&case_method, arms) {
-                        lint(cx, expr.span, &case_method, bad_case);
+                    if let Some((bad_case_span, bad_case_str)) = verify_case(&case_method, arms) {
+                        lint(cx, &case_method, bad_case_span, &bad_case_str);
                     }
                 }
             }
@@ -119,9 +125,7 @@ fn get_case_method(segment_ident_str: &str) -> Option<CaseMethod> {
     }
 }
 
-fn verify_case(case_method: &CaseMethod, arms: &'_ [Arm<'_>]) -> Option<Span> {
-    let mut bad_case = None;
-
+fn verify_case<'a>(case_method: &'a CaseMethod, arms: &'a [Arm<'_>]) -> Option<(Span, SymbolStr)> {
     let case_check = match case_method {
         CaseMethod::LowerCase => |input: &str| -> bool { input.chars().all(char::is_lowercase) },
         CaseMethod::AsciiLowerCase => |input: &str| -> bool { input.chars().all(|c| matches!(c, 'a'..='z')) },
@@ -136,31 +140,32 @@ fn verify_case(case_method: &CaseMethod, arms: &'_ [Arm<'_>]) -> Option<Span> {
                                 ..
                             }) = arm.pat.kind;
             if let LitKind::Str(symbol, _) = lit.node;
-            if !case_check(&symbol.as_str());
+            let input = symbol.as_str();
+            if !case_check(&input);
             then {
-                bad_case = Some(lit.span);
-                break;
+                return Some((lit.span, input));
             }
         }
     }
 
-    bad_case
+    None
 }
 
-fn lint(cx: &LateContext<'_>, expr_span: Span, case_method: &CaseMethod, bad_case_span: Span) {
-    let method_str = match case_method {
-        CaseMethod::LowerCase => "to_lower_case",
-        CaseMethod::AsciiLowerCase => "to_ascii_lowercase",
-        CaseMethod::UpperCase => "to_uppercase",
-        CaseMethod::AsciiUppercase => "to_ascii_uppercase",
+fn lint(cx: &LateContext<'_>, case_method: &CaseMethod, bad_case_span: Span, bad_case_str: &str) {
+    let (method_str, suggestion) = match case_method {
+        CaseMethod::LowerCase => ("to_lower_case", bad_case_str.to_lowercase()),
+        CaseMethod::AsciiLowerCase => ("to_ascii_lowercase", bad_case_str.to_ascii_lowercase()),
+        CaseMethod::UpperCase => ("to_uppercase", bad_case_str.to_uppercase()),
+        CaseMethod::AsciiUppercase => ("to_ascii_uppercase", bad_case_str.to_ascii_uppercase()),
     };
 
-    span_lint_and_help(
+    span_lint_and_sugg(
         cx,
         MATCH_STR_CASE_MISMATCH,
-        expr_span,
-        "this `match` expression alters case, but has non-compliant arms",
-        Some(bad_case_span),
+        bad_case_span,
+        "this `match` arm has a differing case than its expression",
         &*format!("consider changing the case of this arm to respect `{}`", method_str),
+        format!("\"{}\"", suggestion),
+        Applicability::MachineApplicable,
     );
 }
diff --git a/tests/ui/match_str_case_mismatch.stderr b/tests/ui/match_str_case_mismatch.stderr
index a5eab1f72f3..fa023477a9c 100644
--- a/tests/ui/match_str_case_mismatch.stderr
+++ b/tests/ui/match_str_case_mismatch.stderr
@@ -1,53 +1,36 @@
-error: this `match` expression alters case, but has non-compliant arms
-  --> $DIR/match_str_case_mismatch.rs:66:5
-   |
-LL | /     match var.to_ascii_lowercase().as_str() {
-LL | |         "foo" => {},
-LL | |         "Bar" => {},
-LL | |         _ => {},
-LL | |     }
-   | |_____^
-   |
-   = note: `-D clippy::match-str-case-mismatch` implied by `-D warnings`
-help: consider changing the case of this arm to respect `to_ascii_lowercase`
+error: this `match` arm has a differing case than its expression
   --> $DIR/match_str_case_mismatch.rs:68:9
    |
 LL |         "Bar" => {},
    |         ^^^^^
-
-error: this `match` expression alters case, but has non-compliant arms
-  --> $DIR/match_str_case_mismatch.rs:76:5
-   |
-LL | /     match &*var.to_ascii_lowercase() {
-LL | |         "foo" => {},
-LL | |         "Bar" => {},
-LL | |         _ => {},
-LL | |     }
-   | |_____^
    |
+   = note: `-D clippy::match-str-case-mismatch` implied by `-D warnings`
 help: consider changing the case of this arm to respect `to_ascii_lowercase`
+   |
+LL |         "bar" => {},
+   |         ~~~~~
+
+error: this `match` arm has a differing case than its expression
   --> $DIR/match_str_case_mismatch.rs:78:9
    |
 LL |         "Bar" => {},
    |         ^^^^^
-
-error: this `match` expression alters case, but has non-compliant arms
-  --> $DIR/match_str_case_mismatch.rs:86:5
-   |
-LL | /     match &*var
-LL | |         .to_ascii_lowercase()
-LL | |         .to_uppercase()
-LL | |         .to_lowercase()
-...  |
-LL | |         _ => {},
-LL | |     }
-   | |_____^
    |
-help: consider changing the case of this arm to respect `to_ascii_uppercase`
+help: consider changing the case of this arm to respect `to_ascii_lowercase`
+   |
+LL |         "bar" => {},
+   |         ~~~~~
+
+error: this `match` arm has a differing case than its expression
   --> $DIR/match_str_case_mismatch.rs:93:9
    |
 LL |         "bAR" => {},
    |         ^^^^^
+   |
+help: consider changing the case of this arm to respect `to_ascii_uppercase`
+   |
+LL |         "BAR" => {},
+   |         ~~~~~
 
 error: aborting due to 3 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 4ed3a4fe2f681660cac9a4fad6385c6d92a89de1 Mon Sep 17 00:00:00 2001
From: Yechan Bae <yechan@gatech.edu>
Date: Tue, 12 Oct 2021 16:01:58 -0400
Subject: Update lint description for new() and default()

---
 clippy_lints/src/uninit_vec.rs | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/uninit_vec.rs b/clippy_lints/src/uninit_vec.rs
index 2573209d1b6..f3e8b688105 100644
--- a/clippy_lints/src/uninit_vec.rs
+++ b/clippy_lints/src/uninit_vec.rs
@@ -13,14 +13,16 @@ use rustc_span::{sym, Span};
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for `set_len()` call that creates `Vec` with uninitialized elements.
-    /// This is commonly caused by calling `set_len()` right after after calling
-    /// `with_capacity()` or `reserve()`.
+    /// This is commonly caused by calling `set_len()` right after allocating or
+    /// reserving a buffer with `new()`, `default()`, `with_capacity()`, or `reserve()`.
     ///
     /// ### Why is this bad?
     /// It creates a `Vec` with uninitialized data, which leads to
-    /// undefined behavior with most safe operations.
+    /// undefined behavior with most safe operations. Notably, uninitialized
+    /// `Vec<u8>` must not be used with generic `Read`.
     ///
-    /// Notably, uninitialized `Vec<u8>` must not be used with generic `Read`.
+    /// Moreover, calling `set_len()` on a `Vec` created with `new()` or `default()`
+    /// creates out-of-bound values that lead to heap memory corruption when used.
     ///
     /// ### Known Problems
     /// This lint only checks directly adjacent statements.
-- 
cgit 1.4.1-3-g733a5


From 58969807ab7a79caecf33ad8a03df8a9793a23ad Mon Sep 17 00:00:00 2001
From: Nixon Enraght-Moony <nixon.emoony@gmail.com>
Date: Mon, 11 Oct 2021 23:46:49 +0100
Subject: Add lint transmute_num_to_bytes

Closes #7803

changelog: [`transmute_num_to_bytes`] new lint
---
 CHANGELOG.md                                       |  1 +
 clippy_lints/src/lib.register_all.rs               |  1 +
 clippy_lints/src/lib.register_complexity.rs        |  1 +
 clippy_lints/src/lib.register_lints.rs             |  1 +
 clippy_lints/src/transmute/mod.rs                  | 25 ++++++
 .../src/transmute/transmute_num_to_bytes.rs        | 49 ++++++++++++
 tests/ui/transmute.rs                              | 27 +++++++
 tests/ui/transmute.stderr                          | 92 +++++++++++++++++++++-
 8 files changed, 194 insertions(+), 3 deletions(-)
 create mode 100644 clippy_lints/src/transmute/transmute_num_to_bytes.rs

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 13067e4e92a..4c0b1991fd4 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3024,6 +3024,7 @@ Released 2018-09-13
 [`transmute_int_to_bool`]: https://rust-lang.github.io/rust-clippy/master/index.html#transmute_int_to_bool
 [`transmute_int_to_char`]: https://rust-lang.github.io/rust-clippy/master/index.html#transmute_int_to_char
 [`transmute_int_to_float`]: https://rust-lang.github.io/rust-clippy/master/index.html#transmute_int_to_float
+[`transmute_num_to_bytes`]: https://rust-lang.github.io/rust-clippy/master/index.html#transmute_num_to_bytes
 [`transmute_ptr_to_ptr`]: https://rust-lang.github.io/rust-clippy/master/index.html#transmute_ptr_to_ptr
 [`transmute_ptr_to_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#transmute_ptr_to_ref
 [`transmutes_expressible_as_ptr_casts`]: https://rust-lang.github.io/rust-clippy/master/index.html#transmutes_expressible_as_ptr_casts
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 3e6e0244754..8d0a3e7423b 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -266,6 +266,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(transmute::TRANSMUTE_INT_TO_BOOL),
     LintId::of(transmute::TRANSMUTE_INT_TO_CHAR),
     LintId::of(transmute::TRANSMUTE_INT_TO_FLOAT),
+    LintId::of(transmute::TRANSMUTE_NUM_TO_BYTES),
     LintId::of(transmute::TRANSMUTE_PTR_TO_REF),
     LintId::of(transmute::UNSOUND_COLLECTION_TRANSMUTE),
     LintId::of(transmute::WRONG_TRANSMUTE),
diff --git a/clippy_lints/src/lib.register_complexity.rs b/clippy_lints/src/lib.register_complexity.rs
index 64b82fc0faa..c51341bdf0c 100644
--- a/clippy_lints/src/lib.register_complexity.rs
+++ b/clippy_lints/src/lib.register_complexity.rs
@@ -82,6 +82,7 @@ store.register_group(true, "clippy::complexity", Some("clippy_complexity"), vec!
     LintId::of(transmute::TRANSMUTE_INT_TO_BOOL),
     LintId::of(transmute::TRANSMUTE_INT_TO_CHAR),
     LintId::of(transmute::TRANSMUTE_INT_TO_FLOAT),
+    LintId::of(transmute::TRANSMUTE_NUM_TO_BYTES),
     LintId::of(transmute::TRANSMUTE_PTR_TO_REF),
     LintId::of(types::BORROWED_BOX),
     LintId::of(types::TYPE_COMPLEXITY),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 3c4b720671a..8d17317c38e 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -449,6 +449,7 @@ store.register_lints(&[
     transmute::TRANSMUTE_INT_TO_BOOL,
     transmute::TRANSMUTE_INT_TO_CHAR,
     transmute::TRANSMUTE_INT_TO_FLOAT,
+    transmute::TRANSMUTE_NUM_TO_BYTES,
     transmute::TRANSMUTE_PTR_TO_PTR,
     transmute::TRANSMUTE_PTR_TO_REF,
     transmute::UNSOUND_COLLECTION_TRANSMUTE,
diff --git a/clippy_lints/src/transmute/mod.rs b/clippy_lints/src/transmute/mod.rs
index 33ec9c331ce..374999473a4 100644
--- a/clippy_lints/src/transmute/mod.rs
+++ b/clippy_lints/src/transmute/mod.rs
@@ -3,6 +3,7 @@ mod transmute_float_to_int;
 mod transmute_int_to_bool;
 mod transmute_int_to_char;
 mod transmute_int_to_float;
+mod transmute_num_to_bytes;
 mod transmute_ptr_to_ptr;
 mod transmute_ptr_to_ref;
 mod transmute_ref_to_ref;
@@ -261,6 +262,28 @@ declare_clippy_lint! {
     "transmutes from a float to an integer"
 }
 
+declare_clippy_lint! {
+    /// # What it does
+    /// Checks for transmutes from a number to an array of `u8`
+    ///
+    /// ### Why this is bad?
+    /// Transmutes are dangerous and error-prone, whereas `to_ne_bytes`
+    /// is intuitive and safe.
+    ///
+    /// ### Example
+    /// ```rust
+    /// unsafe {
+    ///     let x: [u8; 8] = std::mem::transmute(1i64);
+    /// }
+    ///
+    /// // should be
+    /// let x: [u8; 8] = 0i64.to_ne_bytes();
+    /// ```
+    pub TRANSMUTE_NUM_TO_BYTES,
+    complexity,
+    "transmutes from a number to an array of `u8`"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for transmutes from a pointer to a pointer, or
@@ -330,6 +353,7 @@ declare_lint_pass!(Transmute => [
     TRANSMUTE_INT_TO_BOOL,
     TRANSMUTE_INT_TO_FLOAT,
     TRANSMUTE_FLOAT_TO_INT,
+    TRANSMUTE_NUM_TO_BYTES,
     UNSOUND_COLLECTION_TRANSMUTE,
     TRANSMUTES_EXPRESSIBLE_AS_PTR_CASTS,
 ]);
@@ -365,6 +389,7 @@ impl<'tcx> LateLintPass<'tcx> for Transmute {
                 linted |= transmute_int_to_bool::check(cx, e, from_ty, to_ty, args);
                 linted |= transmute_int_to_float::check(cx, e, from_ty, to_ty, args, const_context);
                 linted |= transmute_float_to_int::check(cx, e, from_ty, to_ty, args, const_context);
+                linted |= transmute_num_to_bytes::check(cx, e, from_ty, to_ty, args, const_context);
                 linted |= unsound_collection_transmute::check(cx, e, from_ty, to_ty);
 
                 if !linted {
diff --git a/clippy_lints/src/transmute/transmute_num_to_bytes.rs b/clippy_lints/src/transmute/transmute_num_to_bytes.rs
new file mode 100644
index 00000000000..dd5ded1c91a
--- /dev/null
+++ b/clippy_lints/src/transmute/transmute_num_to_bytes.rs
@@ -0,0 +1,49 @@
+use super::TRANSMUTE_NUM_TO_BYTES;
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::sugg;
+use rustc_errors::Applicability;
+use rustc_hir::Expr;
+use rustc_lint::LateContext;
+use rustc_middle::ty::{self, Ty, UintTy};
+
+/// Checks for `transmute_int_to_float` lint.
+/// Returns `true` if it's triggered, otherwise returns `false`.
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    e: &'tcx Expr<'_>,
+    from_ty: Ty<'tcx>,
+    to_ty: Ty<'tcx>,
+    args: &'tcx [Expr<'_>],
+    const_context: bool,
+) -> bool {
+    match (&from_ty.kind(), &to_ty.kind()) {
+        (ty::Int(_) | ty::Uint(_) | ty::Float(_), ty::Array(arr_ty, _)) => {
+            if !matches!(arr_ty.kind(), ty::Uint(UintTy::U8)) {
+                return false;
+            }
+            if matches!(from_ty.kind(), ty::Float(_)) && const_context {
+                // TODO: Remove when const_float_bits_conv is stabilized
+                // rust#72447
+                return false;
+            }
+
+            span_lint_and_then(
+                cx,
+                TRANSMUTE_NUM_TO_BYTES,
+                e.span,
+                &format!("transmute from a `{}` to a `{}`", from_ty, to_ty),
+                |diag| {
+                    let arg = sugg::Sugg::hir(cx, &args[0], "..");
+                    diag.span_suggestion(
+                        e.span,
+                        "consider using `to_ne_bytes()`",
+                        format!("{}.to_ne_bytes()", arg.to_string()),
+                        Applicability::Unspecified,
+                    );
+                },
+            );
+            true
+        },
+        _ => false,
+    }
+}
diff --git a/tests/ui/transmute.rs b/tests/ui/transmute.rs
index bce4c81b78a..6a7037d8f38 100644
--- a/tests/ui/transmute.rs
+++ b/tests/ui/transmute.rs
@@ -103,6 +103,33 @@ mod int_to_float {
     }
 }
 
+mod num_to_bytes {
+    fn test() {
+        unsafe {
+            let _: [u8; 1] = std::mem::transmute(0u8);
+            let _: [u8; 4] = std::mem::transmute(0u32);
+            let _: [u8; 16] = std::mem::transmute(0u128);
+            let _: [u8; 1] = std::mem::transmute(0i8);
+            let _: [u8; 4] = std::mem::transmute(0i32);
+            let _: [u8; 16] = std::mem::transmute(0i128);
+            let _: [u8; 4] = std::mem::transmute(0.0f32);
+            let _: [u8; 8] = std::mem::transmute(0.0f64);
+        }
+    }
+    const fn test_const() {
+        unsafe {
+            let _: [u8; 1] = std::mem::transmute(0u8);
+            let _: [u8; 4] = std::mem::transmute(0u32);
+            let _: [u8; 16] = std::mem::transmute(0u128);
+            let _: [u8; 1] = std::mem::transmute(0i8);
+            let _: [u8; 4] = std::mem::transmute(0i32);
+            let _: [u8; 16] = std::mem::transmute(0i128);
+            let _: [u8; 4] = std::mem::transmute(0.0f32);
+            let _: [u8; 8] = std::mem::transmute(0.0f64);
+        }
+    }
+}
+
 fn bytes_to_str(b: &[u8], mb: &mut [u8]) {
     let _: &str = unsafe { std::mem::transmute(b) };
     let _: &mut str = unsafe { std::mem::transmute(mb) };
diff --git a/tests/ui/transmute.stderr b/tests/ui/transmute.stderr
index e31accb982a..86537153e32 100644
--- a/tests/ui/transmute.stderr
+++ b/tests/ui/transmute.stderr
@@ -140,8 +140,94 @@ error: transmute from a `i64` to a `f64`
 LL |         let _: f64 = unsafe { std::mem::transmute(0_i64) };
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `f64::from_bits(0_i64 as u64)`
 
+error: transmute from a `u8` to a `[u8; 1]`
+  --> $DIR/transmute.rs:109:30
+   |
+LL |             let _: [u8; 1] = std::mem::transmute(0u8);
+   |                              ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0u8.to_ne_bytes()`
+   |
+   = note: `-D clippy::transmute-num-to-bytes` implied by `-D warnings`
+
+error: transmute from a `u32` to a `[u8; 4]`
+  --> $DIR/transmute.rs:110:30
+   |
+LL |             let _: [u8; 4] = std::mem::transmute(0u32);
+   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0u32.to_ne_bytes()`
+
+error: transmute from a `u128` to a `[u8; 16]`
+  --> $DIR/transmute.rs:111:31
+   |
+LL |             let _: [u8; 16] = std::mem::transmute(0u128);
+   |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0u128.to_ne_bytes()`
+
+error: transmute from a `i8` to a `[u8; 1]`
+  --> $DIR/transmute.rs:112:30
+   |
+LL |             let _: [u8; 1] = std::mem::transmute(0i8);
+   |                              ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0i8.to_ne_bytes()`
+
+error: transmute from a `i32` to a `[u8; 4]`
+  --> $DIR/transmute.rs:113:30
+   |
+LL |             let _: [u8; 4] = std::mem::transmute(0i32);
+   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0i32.to_ne_bytes()`
+
+error: transmute from a `i128` to a `[u8; 16]`
+  --> $DIR/transmute.rs:114:31
+   |
+LL |             let _: [u8; 16] = std::mem::transmute(0i128);
+   |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0i128.to_ne_bytes()`
+
+error: transmute from a `f32` to a `[u8; 4]`
+  --> $DIR/transmute.rs:115:30
+   |
+LL |             let _: [u8; 4] = std::mem::transmute(0.0f32);
+   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0.0f32.to_ne_bytes()`
+
+error: transmute from a `f64` to a `[u8; 8]`
+  --> $DIR/transmute.rs:116:30
+   |
+LL |             let _: [u8; 8] = std::mem::transmute(0.0f64);
+   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0.0f64.to_ne_bytes()`
+
+error: transmute from a `u8` to a `[u8; 1]`
+  --> $DIR/transmute.rs:121:30
+   |
+LL |             let _: [u8; 1] = std::mem::transmute(0u8);
+   |                              ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0u8.to_ne_bytes()`
+
+error: transmute from a `u32` to a `[u8; 4]`
+  --> $DIR/transmute.rs:122:30
+   |
+LL |             let _: [u8; 4] = std::mem::transmute(0u32);
+   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0u32.to_ne_bytes()`
+
+error: transmute from a `u128` to a `[u8; 16]`
+  --> $DIR/transmute.rs:123:31
+   |
+LL |             let _: [u8; 16] = std::mem::transmute(0u128);
+   |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0u128.to_ne_bytes()`
+
+error: transmute from a `i8` to a `[u8; 1]`
+  --> $DIR/transmute.rs:124:30
+   |
+LL |             let _: [u8; 1] = std::mem::transmute(0i8);
+   |                              ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0i8.to_ne_bytes()`
+
+error: transmute from a `i32` to a `[u8; 4]`
+  --> $DIR/transmute.rs:125:30
+   |
+LL |             let _: [u8; 4] = std::mem::transmute(0i32);
+   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0i32.to_ne_bytes()`
+
+error: transmute from a `i128` to a `[u8; 16]`
+  --> $DIR/transmute.rs:126:31
+   |
+LL |             let _: [u8; 16] = std::mem::transmute(0i128);
+   |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0i128.to_ne_bytes()`
+
 error: transmute from a `&[u8]` to a `&str`
-  --> $DIR/transmute.rs:107:28
+  --> $DIR/transmute.rs:134:28
    |
 LL |     let _: &str = unsafe { std::mem::transmute(b) };
    |                            ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::str::from_utf8(b).unwrap()`
@@ -149,10 +235,10 @@ LL |     let _: &str = unsafe { std::mem::transmute(b) };
    = note: `-D clippy::transmute-bytes-to-str` implied by `-D warnings`
 
 error: transmute from a `&mut [u8]` to a `&mut str`
-  --> $DIR/transmute.rs:108:32
+  --> $DIR/transmute.rs:135:32
    |
 LL |     let _: &mut str = unsafe { std::mem::transmute(mb) };
    |                                ^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::str::from_utf8_mut(mb).unwrap()`
 
-error: aborting due to 24 previous errors
+error: aborting due to 38 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 09aa4ad6dca75be43ef782884fab36176cb785f0 Mon Sep 17 00:00:00 2001
From: nhamovitz <18648574+nhamovitz@users.noreply.github.com>
Date: Wed, 13 Oct 2021 12:12:46 -0700
Subject: Fix typo in example for `match_result_ok`

---
 clippy_lints/src/match_result_ok.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/match_result_ok.rs b/clippy_lints/src/match_result_ok.rs
index 3db1f0421ea..ecf6ad316a4 100644
--- a/clippy_lints/src/match_result_ok.rs
+++ b/clippy_lints/src/match_result_ok.rs
@@ -35,7 +35,7 @@ declare_clippy_lint! {
     /// }
     ///
     /// if let Ok(value) = iter.next() {
-    ///        vec.push_value)
+    ///        vec.push(value)
     /// }
     /// ```
     pub MATCH_RESULT_OK,
-- 
cgit 1.4.1-3-g733a5


From ec5071931eb68a981d14eefd7f6c39bb16c59596 Mon Sep 17 00:00:00 2001
From: dswij <dswijj@gmail.com>
Date: Fri, 15 Oct 2021 18:00:02 +0800
Subject: `unnecessary_sort_by` only warns if argument impl `Ord` trait

---
 clippy_lints/src/unnecessary_sort_by.rs | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unnecessary_sort_by.rs b/clippy_lints/src/unnecessary_sort_by.rs
index dd74bf367f3..26b56e0f2f3 100644
--- a/clippy_lints/src/unnecessary_sort_by.rs
+++ b/clippy_lints/src/unnecessary_sort_by.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::sugg::Sugg;
-use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::ty::{implements_trait, is_type_diagnostic_item};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, Mutability, Param, Pat, PatKind, Path, PathSegment, QPath};
@@ -193,10 +193,15 @@ fn detect_lint(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<LintTrigger> {
             let vec_name = Sugg::hir(cx, &args[0], "..").to_string();
             let unstable = name == "sort_unstable_by";
 
+            if_chain! {
             if let ExprKind::Path(QPath::Resolved(_, Path {
                 segments: [PathSegment { ident: left_name, .. }], ..
-            })) = &left_expr.kind {
-                if left_name == left_ident {
+            })) = &left_expr.kind;
+            if left_name == left_ident;
+            if cx.tcx.get_diagnostic_item(sym::Ord).map_or(false, |id| {
+                implements_trait(cx, cx.typeck_results().expr_ty(left_expr), id, &[])
+            });
+                then {
                     return Some(LintTrigger::Sort(SortDetection { vec_name, unstable }));
                 }
             }
-- 
cgit 1.4.1-3-g733a5


From c9599d79a3b741b7c42353dc45eab6f1c461891f Mon Sep 17 00:00:00 2001
From: "Samuel E. Moelius III" <sam@moeli.us>
Date: Thu, 30 Sep 2021 07:45:03 -0400
Subject: Add `format_in_format_args` and `to_string_in_format_args` lints

Fixes #7667 and #7729
---
 CHANGELOG.md                           |   2 +
 clippy_lints/src/format.rs             |  51 +-------
 clippy_lints/src/format_args.rs        | 223 +++++++++++++++++++++++++++++++++
 clippy_lints/src/lib.register_all.rs   |   2 +
 clippy_lints/src/lib.register_lints.rs |   2 +
 clippy_lints/src/lib.register_perf.rs  |   2 +
 clippy_lints/src/lib.rs                |   2 +
 clippy_utils/src/higher.rs             | 102 ++++++++++++++-
 clippy_utils/src/paths.rs              |  20 +++
 tests/ui/format_args.fixed             | 105 ++++++++++++++++
 tests/ui/format_args.rs                | 105 ++++++++++++++++
 tests/ui/format_args.stderr            | 106 ++++++++++++++++
 tests/ui/format_args_unfixable.rs      |  60 +++++++++
 tests/ui/format_args_unfixable.stderr  | 175 ++++++++++++++++++++++++++
 14 files changed, 908 insertions(+), 49 deletions(-)
 create mode 100644 clippy_lints/src/format_args.rs
 create mode 100644 tests/ui/format_args.fixed
 create mode 100644 tests/ui/format_args.rs
 create mode 100644 tests/ui/format_args.stderr
 create mode 100644 tests/ui/format_args_unfixable.rs
 create mode 100644 tests/ui/format_args_unfixable.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index b1e837d363a..f6a883311c9 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2736,6 +2736,7 @@ Released 2018-09-13
 [`for_loops_over_fallibles`]: https://rust-lang.github.io/rust-clippy/master/index.html#for_loops_over_fallibles
 [`forget_copy`]: https://rust-lang.github.io/rust-clippy/master/index.html#forget_copy
 [`forget_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#forget_ref
+[`format_in_format_args`]: https://rust-lang.github.io/rust-clippy/master/index.html#format_in_format_args
 [`from_iter_instead_of_collect`]: https://rust-lang.github.io/rust-clippy/master/index.html#from_iter_instead_of_collect
 [`from_over_into`]: https://rust-lang.github.io/rust-clippy/master/index.html#from_over_into
 [`from_str_radix_10`]: https://rust-lang.github.io/rust-clippy/master/index.html#from_str_radix_10
@@ -3015,6 +3016,7 @@ Released 2018-09-13
 [`temporary_assignment`]: https://rust-lang.github.io/rust-clippy/master/index.html#temporary_assignment
 [`to_digit_is_some`]: https://rust-lang.github.io/rust-clippy/master/index.html#to_digit_is_some
 [`to_string_in_display`]: https://rust-lang.github.io/rust-clippy/master/index.html#to_string_in_display
+[`to_string_in_format_args`]: https://rust-lang.github.io/rust-clippy/master/index.html#to_string_in_format_args
 [`todo`]: https://rust-lang.github.io/rust-clippy/master/index.html#todo
 [`too_many_arguments`]: https://rust-lang.github.io/rust-clippy/master/index.html#too_many_arguments
 [`too_many_lines`]: https://rust-lang.github.io/rust-clippy/master/index.html#too_many_lines
diff --git a/clippy_lints/src/format.rs b/clippy_lints/src/format.rs
index 8df7f91ce59..472db6f5731 100644
--- a/clippy_lints/src/format.rs
+++ b/clippy_lints/src/format.rs
@@ -1,11 +1,10 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::higher::FormatExpn;
-use clippy_utils::last_path_segment;
 use clippy_utils::source::{snippet_opt, snippet_with_applicability};
 use clippy_utils::sugg::Sugg;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
-use rustc_hir::{BorrowKind, Expr, ExprKind, QPath};
+use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -69,8 +68,8 @@ impl<'tcx> LateLintPass<'tcx> for UselessFormat {
                     ty::Str => true,
                     _ => false,
                 };
-                if format_args.args.iter().all(is_display_arg);
-                if format_args.fmt_expr.map_or(true, check_unformatted);
+                if let Some(args) = format_args.args();
+                if args.iter().all(|arg| arg.is_display() && !arg.has_string_formatting());
                 then {
                     let is_new_string = match value.kind {
                         ExprKind::Binary(..) => true,
@@ -106,47 +105,3 @@ fn span_useless_format(cx: &LateContext<'_>, span: Span, mut sugg: String, mut a
         applicability,
     );
 }
-
-fn is_display_arg(expr: &Expr<'_>) -> bool {
-    if_chain! {
-        if let ExprKind::Call(_, [_, fmt]) = expr.kind;
-        if let ExprKind::Path(QPath::Resolved(_, path)) = fmt.kind;
-        if let [.., t, _] = path.segments;
-        if t.ident.name == sym::Display;
-        then { true } else { false }
-    }
-}
-
-/// Checks if the expression matches
-/// ```rust,ignore
-/// &[_ {
-///    format: _ {
-///         width: _::Implied,
-///         precision: _::Implied,
-///         ...
-///    },
-///    ...,
-/// }]
-/// ```
-fn check_unformatted(expr: &Expr<'_>) -> bool {
-    if_chain! {
-        if let ExprKind::AddrOf(BorrowKind::Ref, _, expr) = expr.kind;
-        if let ExprKind::Array([expr]) = expr.kind;
-        // struct `core::fmt::rt::v1::Argument`
-        if let ExprKind::Struct(_, fields, _) = expr.kind;
-        if let Some(format_field) = fields.iter().find(|f| f.ident.name == sym::format);
-        // struct `core::fmt::rt::v1::FormatSpec`
-        if let ExprKind::Struct(_, fields, _) = format_field.expr.kind;
-        if let Some(precision_field) = fields.iter().find(|f| f.ident.name == sym::precision);
-        if let ExprKind::Path(ref precision_path) = precision_field.expr.kind;
-        if last_path_segment(precision_path).ident.name == sym::Implied;
-        if let Some(width_field) = fields.iter().find(|f| f.ident.name == sym::width);
-        if let ExprKind::Path(ref width_qpath) = width_field.expr.kind;
-        if last_path_segment(width_qpath).ident.name == sym::Implied;
-        then {
-            return true;
-        }
-    }
-
-    false
-}
diff --git a/clippy_lints/src/format_args.rs b/clippy_lints/src/format_args.rs
new file mode 100644
index 00000000000..8b27442aa94
--- /dev/null
+++ b/clippy_lints/src/format_args.rs
@@ -0,0 +1,223 @@
+use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
+use clippy_utils::higher::{FormatArgsArg, FormatArgsExpn, FormatExpn};
+use clippy_utils::source::snippet_opt;
+use clippy_utils::ty::implements_trait;
+use clippy_utils::{is_diag_trait_item, match_def_path, paths};
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::adjustment::{Adjust, Adjustment};
+use rustc_middle::ty::Ty;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::{sym, BytePos, ExpnData, ExpnKind, Span, Symbol};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Detects `format!` within the arguments of another macro that does
+    /// formatting such as `format!` itself, `write!` or `println!`. Suggests
+    /// inlining the `format!` call.
+    ///
+    /// ### Why is this bad?
+    /// The recommended code is both shorter and avoids a temporary allocation.
+    ///
+    /// ### Example
+    /// ```rust
+    /// # use std::panic::Location;
+    /// println!("error: {}", format!("something failed at {}", Location::caller()));
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// # use std::panic::Location;
+    /// println!("error: something failed at {}", Location::caller());
+    /// ```
+    pub FORMAT_IN_FORMAT_ARGS,
+    perf,
+    "`format!` used in a macro that does formatting"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for [`ToString::to_string`](https://doc.rust-lang.org/std/string/trait.ToString.html#tymethod.to_string)
+    /// applied to a type that implements [`Display`](https://doc.rust-lang.org/std/fmt/trait.Display.html)
+    /// in a macro that does formatting.
+    ///
+    /// ### Why is this bad?
+    /// Since the type implements `Display`, the use of `to_string` is
+    /// unnecessary.
+    ///
+    /// ### Example
+    /// ```rust
+    /// # use std::panic::Location;
+    /// println!("error: something failed at {}", Location::caller().to_string());
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// # use std::panic::Location;
+    /// println!("error: something failed at {}", Location::caller());
+    /// ```
+    pub TO_STRING_IN_FORMAT_ARGS,
+    perf,
+    "`to_string` applied to a type that implements `Display` in format args"
+}
+
+declare_lint_pass!(FormatArgs => [FORMAT_IN_FORMAT_ARGS, TO_STRING_IN_FORMAT_ARGS]);
+
+const FORMAT_MACRO_PATHS: &[&[&str]] = &[
+    &paths::FORMAT_ARGS_MACRO,
+    &paths::ASSERT_EQ_MACRO,
+    &paths::ASSERT_MACRO,
+    &paths::ASSERT_NE_MACRO,
+    &paths::EPRINT_MACRO,
+    &paths::EPRINTLN_MACRO,
+    &paths::PRINT_MACRO,
+    &paths::PRINTLN_MACRO,
+    &paths::WRITE_MACRO,
+    &paths::WRITELN_MACRO,
+];
+
+const FORMAT_MACRO_DIAG_ITEMS: &[Symbol] = &[sym::format_macro, sym::std_panic_macro];
+
+impl<'tcx> LateLintPass<'tcx> for FormatArgs {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
+        if_chain! {
+            if let Some(format_args) = FormatArgsExpn::parse(expr);
+            let expr_expn_data = expr.span.ctxt().outer_expn_data();
+            let outermost_expn_data = outermost_expn_data(expr_expn_data);
+            if let Some(macro_def_id) = outermost_expn_data.macro_def_id;
+            if FORMAT_MACRO_PATHS
+                .iter()
+                .any(|path| match_def_path(cx, macro_def_id, path))
+                || FORMAT_MACRO_DIAG_ITEMS
+                    .iter()
+                    .any(|diag_item| cx.tcx.is_diagnostic_item(*diag_item, macro_def_id));
+            if let ExpnKind::Macro(_, name) = outermost_expn_data.kind;
+            if let Some(args) = format_args.args();
+            then {
+                for (i, arg) in args.iter().enumerate() {
+                    if !arg.is_display() {
+                        continue;
+                    }
+                    if arg.has_string_formatting() {
+                        continue;
+                    }
+                    if is_aliased(&args, i) {
+                        continue;
+                    }
+                    check_format_in_format_args(cx, outermost_expn_data.call_site, name, arg);
+                    check_to_string_in_format_args(cx, name, arg);
+                }
+            }
+        }
+    }
+}
+
+fn outermost_expn_data(expn_data: ExpnData) -> ExpnData {
+    if expn_data.call_site.from_expansion() {
+        outermost_expn_data(expn_data.call_site.ctxt().outer_expn_data())
+    } else {
+        expn_data
+    }
+}
+
+fn check_format_in_format_args(cx: &LateContext<'_>, call_site: Span, name: Symbol, arg: &FormatArgsArg<'_>) {
+    if_chain! {
+        if FormatExpn::parse(arg.value).is_some();
+        if !arg.value.span.ctxt().outer_expn_data().call_site.from_expansion();
+        then {
+            span_lint_and_then(
+                cx,
+                FORMAT_IN_FORMAT_ARGS,
+                trim_semicolon(cx, call_site),
+                &format!("`format!` in `{}!` args", name),
+                |diag| {
+                    diag.help(&format!(
+                        "combine the `format!(..)` arguments with the outer `{}!(..)` call",
+                        name
+                    ));
+                    diag.help("or consider changing `format!` to `format_args!`");
+                },
+            );
+        }
+    }
+}
+
+fn check_to_string_in_format_args<'tcx>(cx: &LateContext<'tcx>, name: Symbol, arg: &FormatArgsArg<'tcx>) {
+    let value = arg.value;
+    if_chain! {
+        if !value.span.from_expansion();
+        if let ExprKind::MethodCall(_, _, [receiver], _) = value.kind;
+        if let Some(method_def_id) = cx.typeck_results().type_dependent_def_id(value.hir_id);
+        if is_diag_trait_item(cx, method_def_id, sym::ToString);
+        let receiver_ty = cx.typeck_results().expr_ty(receiver);
+        if let Some(display_trait_id) = cx.tcx.get_diagnostic_item(sym::Display);
+        if let Some(receiver_snippet) = snippet_opt(cx, receiver.span);
+        then {
+            let (n_needed_derefs, target) = count_needed_derefs(
+                receiver_ty,
+                cx.typeck_results().expr_adjustments(receiver).iter(),
+            );
+            if implements_trait(cx, target, display_trait_id, &[]) {
+                if n_needed_derefs == 0 {
+                    span_lint_and_sugg(
+                        cx,
+                        TO_STRING_IN_FORMAT_ARGS,
+                        value.span.with_lo(receiver.span.hi()),
+                        &format!("`to_string` applied to a type that implements `Display` in `{}!` args", name),
+                        "remove this",
+                        String::new(),
+                        Applicability::MachineApplicable,
+                    );
+                } else {
+                    span_lint_and_sugg(
+                        cx,
+                        TO_STRING_IN_FORMAT_ARGS,
+                        value.span,
+                        &format!("`to_string` applied to a type that implements `Display` in `{}!` args", name),
+                        "use this",
+                        format!("{:*>width$}{}", "", receiver_snippet, width = n_needed_derefs),
+                        Applicability::MachineApplicable,
+                    );
+                }
+            }
+        }
+    }
+}
+
+// Returns true if `args[i]` "refers to" or "is referred to by" another argument.
+fn is_aliased(args: &[FormatArgsArg<'_>], i: usize) -> bool {
+    let value = args[i].value;
+    args.iter()
+        .enumerate()
+        .any(|(j, arg)| i != j && std::ptr::eq(value, arg.value))
+}
+
+fn trim_semicolon(cx: &LateContext<'_>, span: Span) -> Span {
+    snippet_opt(cx, span).map_or(span, |snippet| {
+        let snippet = snippet.trim_end_matches(';');
+        span.with_hi(span.lo() + BytePos(u32::try_from(snippet.len()).unwrap()))
+    })
+}
+
+fn count_needed_derefs<'tcx, I>(mut ty: Ty<'tcx>, mut iter: I) -> (usize, Ty<'tcx>)
+where
+    I: Iterator<Item = &'tcx Adjustment<'tcx>>,
+{
+    let mut n_total = 0;
+    let mut n_needed = 0;
+    loop {
+        if let Some(Adjustment {
+            kind: Adjust::Deref(overloaded_deref),
+            target,
+        }) = iter.next()
+        {
+            n_total += 1;
+            if overloaded_deref.is_some() {
+                n_needed = n_total;
+            }
+            ty = target;
+        } else {
+            return (n_needed, ty);
+        }
+    }
+}
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 7c8733f9022..4c2dfbd1d84 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -60,6 +60,8 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(float_equality_without_abs::FLOAT_EQUALITY_WITHOUT_ABS),
     LintId::of(float_literal::EXCESSIVE_PRECISION),
     LintId::of(format::USELESS_FORMAT),
+    LintId::of(format_args::FORMAT_IN_FORMAT_ARGS),
+    LintId::of(format_args::TO_STRING_IN_FORMAT_ARGS),
     LintId::of(formatting::POSSIBLE_MISSING_COMMA),
     LintId::of(formatting::SUSPICIOUS_ASSIGNMENT_FORMATTING),
     LintId::of(formatting::SUSPICIOUS_ELSE_FORMATTING),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 7d81fafe4c9..f334f723f6b 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -139,6 +139,8 @@ store.register_lints(&[
     floating_point_arithmetic::IMPRECISE_FLOPS,
     floating_point_arithmetic::SUBOPTIMAL_FLOPS,
     format::USELESS_FORMAT,
+    format_args::FORMAT_IN_FORMAT_ARGS,
+    format_args::TO_STRING_IN_FORMAT_ARGS,
     formatting::POSSIBLE_MISSING_COMMA,
     formatting::SUSPICIOUS_ASSIGNMENT_FORMATTING,
     formatting::SUSPICIOUS_ELSE_FORMATTING,
diff --git a/clippy_lints/src/lib.register_perf.rs b/clippy_lints/src/lib.register_perf.rs
index 5432345760b..a0d5cf9418e 100644
--- a/clippy_lints/src/lib.register_perf.rs
+++ b/clippy_lints/src/lib.register_perf.rs
@@ -5,6 +5,8 @@
 store.register_group(true, "clippy::perf", Some("clippy_perf"), vec![
     LintId::of(entry::MAP_ENTRY),
     LintId::of(escape::BOXED_LOCAL),
+    LintId::of(format_args::FORMAT_IN_FORMAT_ARGS),
+    LintId::of(format_args::TO_STRING_IN_FORMAT_ARGS),
     LintId::of(large_const_arrays::LARGE_CONST_ARRAYS),
     LintId::of(large_enum_variant::LARGE_ENUM_VARIANT),
     LintId::of(loops::MANUAL_MEMCPY),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 6ab59b1b12f..9794d74e198 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -218,6 +218,7 @@ mod float_equality_without_abs;
 mod float_literal;
 mod floating_point_arithmetic;
 mod format;
+mod format_args;
 mod formatting;
 mod from_over_into;
 mod from_str_radix_10;
@@ -775,6 +776,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(move || Box::new(non_send_fields_in_send_ty::NonSendFieldInSendTy::new(enable_raw_pointer_heuristic_for_send)));
     store.register_late_pass(move || Box::new(undocumented_unsafe_blocks::UndocumentedUnsafeBlocks::default()));
     store.register_late_pass(|| Box::new(match_str_case_mismatch::MatchStrCaseMismatch));
+    store.register_late_pass(move || Box::new(format_args::FormatArgs));
 }
 
 #[rustfmt::skip]
diff --git a/clippy_utils/src/higher.rs b/clippy_utils/src/higher.rs
index 1ff282de950..fb4d53e2845 100644
--- a/clippy_utils/src/higher.rs
+++ b/clippy_utils/src/higher.rs
@@ -3,7 +3,7 @@
 #![deny(clippy::missing_docs_in_private_items)]
 
 use crate::ty::is_type_diagnostic_item;
-use crate::{is_expn_of, match_def_path, paths};
+use crate::{is_expn_of, last_path_segment, match_def_path, paths};
 use if_chain::if_chain;
 use rustc_ast::ast::{self, LitKind};
 use rustc_hir as hir;
@@ -572,6 +572,106 @@ impl FormatArgsExpn<'tcx> {
             }
         }
     }
+
+    /// Returns a vector of `FormatArgsArg`.
+    pub fn args(&self) -> Option<Vec<FormatArgsArg<'tcx>>> {
+        if let Some(expr) = self.fmt_expr {
+            if_chain! {
+                if let ExprKind::AddrOf(BorrowKind::Ref, _, expr) = expr.kind;
+                if let ExprKind::Array(exprs) = expr.kind;
+                then {
+                    exprs.iter().map(|fmt| {
+                        if_chain! {
+                            // struct `core::fmt::rt::v1::Argument`
+                            if let ExprKind::Struct(_, fields, _) = fmt.kind;
+                            if let Some(position_field) = fields.iter().find(|f| f.ident.name == sym::position);
+                            if let ExprKind::Lit(lit) = &position_field.expr.kind;
+                            if let LitKind::Int(position, _) = lit.node;
+                            then {
+                                let i = usize::try_from(position).unwrap();
+                                Some(FormatArgsArg { value: self.value_args[i], arg: &self.args[i], fmt: Some(fmt) })
+                            } else {
+                                None
+                            }
+                        }
+                    }).collect()
+                } else {
+                    None
+                }
+            }
+        } else {
+            Some(
+                self.value_args
+                    .iter()
+                    .zip(self.args.iter())
+                    .map(|(value, arg)| FormatArgsArg { value, arg, fmt: None })
+                    .collect(),
+            )
+        }
+    }
+}
+
+/// Type representing a `FormatArgsExpn`'s format arguments
+pub struct FormatArgsArg<'tcx> {
+    /// An element of `value_args` according to `position`
+    pub value: &'tcx Expr<'tcx>,
+    /// An element of `args` according to `position`
+    pub arg: &'tcx Expr<'tcx>,
+    /// An element of `fmt_expn`
+    pub fmt: Option<&'tcx Expr<'tcx>>,
+}
+
+impl<'tcx> FormatArgsArg<'tcx> {
+    /// Returns true if any formatting parameters are used that would have an effect on strings,
+    /// like `{:+2}` instead of just `{}`.
+    pub fn has_string_formatting(&self) -> bool {
+        self.fmt.map_or(false, |fmt| {
+            // `!` because these conditions check that `self` is unformatted.
+            !if_chain! {
+                // struct `core::fmt::rt::v1::Argument`
+                if let ExprKind::Struct(_, fields, _) = fmt.kind;
+                if let Some(format_field) = fields.iter().find(|f| f.ident.name == sym::format);
+                // struct `core::fmt::rt::v1::FormatSpec`
+                if let ExprKind::Struct(_, subfields, _) = format_field.expr.kind;
+                let mut precision_found = false;
+                let mut width_found = false;
+                if subfields.iter().all(|field| {
+                    match field.ident.name {
+                        sym::precision => {
+                            precision_found = true;
+                            if let ExprKind::Path(ref precision_path) = field.expr.kind {
+                                last_path_segment(precision_path).ident.name == sym::Implied
+                            } else {
+                                false
+                            }
+                        }
+                        sym::width => {
+                            width_found = true;
+                            if let ExprKind::Path(ref width_qpath) = field.expr.kind {
+                                last_path_segment(width_qpath).ident.name == sym::Implied
+                            } else {
+                                false
+                            }
+                        }
+                        _ => true,
+                    }
+                });
+                if precision_found && width_found;
+                then { true } else { false }
+            }
+        })
+    }
+
+    /// Returns true if the argument is formatted using `Display::fmt`.
+    pub fn is_display(&self) -> bool {
+        if_chain! {
+            if let ExprKind::Call(_, [_, format_field]) = self.arg.kind;
+            if let ExprKind::Path(QPath::Resolved(_, path)) = format_field.kind;
+            if let [.., t, _] = path.segments;
+            if t.ident.name == sym::Display;
+            then { true } else { false }
+        }
+    }
 }
 
 /// Checks if a `let` statement is from a `for` loop desugaring.
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index e43c5756021..7c61288f661 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -17,6 +17,12 @@ pub const APPLICABILITY_VALUES: [[&str; 3]; 4] = [
 #[cfg(feature = "metadata-collector-lint")]
 pub const DIAGNOSTIC_BUILDER: [&str; 3] = ["rustc_errors", "diagnostic_builder", "DiagnosticBuilder"];
 pub const ARC_PTR_EQ: [&str; 4] = ["alloc", "sync", "Arc", "ptr_eq"];
+#[allow(clippy::invalid_paths)] // `check_path` does not seem to work for macros
+pub const ASSERT_EQ_MACRO: [&str; 3] = ["core", "macros", "assert_eq"];
+#[allow(clippy::invalid_paths)] // `check_path` does not seem to work for macros
+pub const ASSERT_MACRO: [&str; 4] = ["core", "macros", "builtin", "assert"];
+#[allow(clippy::invalid_paths)] // `check_path` does not seem to work for macros
+pub const ASSERT_NE_MACRO: [&str; 3] = ["core", "macros", "assert_ne"];
 pub const ASMUT_TRAIT: [&str; 3] = ["core", "convert", "AsMut"];
 pub const ASREF_TRAIT: [&str; 3] = ["core", "convert", "AsRef"];
 pub(super) const BEGIN_PANIC: [&str; 3] = ["std", "panicking", "begin_panic"];
@@ -42,11 +48,17 @@ pub const DROP: [&str; 3] = ["core", "mem", "drop"];
 pub const DURATION: [&str; 3] = ["core", "time", "Duration"];
 #[cfg(feature = "internal-lints")]
 pub const EARLY_CONTEXT: [&str; 2] = ["rustc_lint", "EarlyContext"];
+#[allow(clippy::invalid_paths)] // `check_path` does not seem to work for macros
+pub const EPRINT_MACRO: [&str; 3] = ["std", "macros", "eprint"];
+#[allow(clippy::invalid_paths)] // `check_path` does not seem to work for macros
+pub const EPRINTLN_MACRO: [&str; 3] = ["std", "macros", "eprintln"];
 pub const EXIT: [&str; 3] = ["std", "process", "exit"];
 pub const F32_EPSILON: [&str; 4] = ["core", "f32", "<impl f32>", "EPSILON"];
 pub const F64_EPSILON: [&str; 4] = ["core", "f64", "<impl f64>", "EPSILON"];
 pub const FILE: [&str; 3] = ["std", "fs", "File"];
 pub const FILE_TYPE: [&str; 3] = ["std", "fs", "FileType"];
+#[allow(clippy::invalid_paths)] // `check_path` does not seem to work for macros
+pub const FORMAT_ARGS_MACRO: [&str; 4] = ["core", "macros", "builtin", "format_args"];
 pub const FROM_FROM: [&str; 4] = ["core", "convert", "From", "from"];
 pub const FROM_ITERATOR: [&str; 5] = ["core", "iter", "traits", "collect", "FromIterator"];
 pub const FROM_ITERATOR_METHOD: [&str; 6] = ["core", "iter", "traits", "collect", "FromIterator", "from_iter"];
@@ -109,6 +121,10 @@ pub const PERMISSIONS_FROM_MODE: [&str; 6] = ["std", "os", "unix", "fs", "Permis
 pub const POLL: [&str; 4] = ["core", "task", "poll", "Poll"];
 pub const POLL_PENDING: [&str; 5] = ["core", "task", "poll", "Poll", "Pending"];
 pub const POLL_READY: [&str; 5] = ["core", "task", "poll", "Poll", "Ready"];
+#[allow(clippy::invalid_paths)] // `check_path` does not seem to work for macros
+pub const PRINT_MACRO: [&str; 3] = ["std", "macros", "print"];
+#[allow(clippy::invalid_paths)] // `check_path` does not seem to work for macros
+pub const PRINTLN_MACRO: [&str; 3] = ["std", "macros", "println"];
 pub const PTR_COPY: [&str; 3] = ["core", "intrinsics", "copy"];
 pub const PTR_COPY_NONOVERLAPPING: [&str; 3] = ["core", "intrinsics", "copy_nonoverlapping"];
 pub const PTR_EQ: [&str; 3] = ["core", "ptr", "eq"];
@@ -185,3 +201,7 @@ pub const VEC_NEW: [&str; 4] = ["alloc", "vec", "Vec", "new"];
 pub const VEC_RESIZE: [&str; 4] = ["alloc", "vec", "Vec", "resize"];
 pub const WEAK_ARC: [&str; 3] = ["alloc", "sync", "Weak"];
 pub const WEAK_RC: [&str; 3] = ["alloc", "rc", "Weak"];
+#[allow(clippy::invalid_paths)] // `check_path` does not seem to work for macros
+pub const WRITE_MACRO: [&str; 3] = ["core", "macros", "write"];
+#[allow(clippy::invalid_paths)] // `check_path` does not seem to work for macros
+pub const WRITELN_MACRO: [&str; 3] = ["core", "macros", "writeln"];
diff --git a/tests/ui/format_args.fixed b/tests/ui/format_args.fixed
new file mode 100644
index 00000000000..8376566c4d6
--- /dev/null
+++ b/tests/ui/format_args.fixed
@@ -0,0 +1,105 @@
+// run-rustfix
+
+#![allow(unreachable_code)]
+#![allow(unused_macros)]
+#![allow(unused_variables)]
+#![allow(clippy::assertions_on_constants)]
+#![allow(clippy::eq_op)]
+#![warn(clippy::to_string_in_format_args)]
+
+use std::io::{stdout, Write};
+use std::ops::Deref;
+use std::panic::Location;
+
+struct Somewhere;
+
+impl ToString for Somewhere {
+    fn to_string(&self) -> String {
+        String::from("somewhere")
+    }
+}
+
+struct X(u32);
+
+impl Deref for X {
+    type Target = u32;
+
+    fn deref(&self) -> &u32 {
+        &self.0
+    }
+}
+
+struct Y<'a>(&'a X);
+
+impl<'a> Deref for Y<'a> {
+    type Target = &'a X;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+struct Z(u32);
+
+impl Deref for Z {
+    type Target = u32;
+
+    fn deref(&self) -> &u32 {
+        &self.0
+    }
+}
+
+impl std::fmt::Display for Z {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "Z")
+    }
+}
+
+macro_rules! my_macro {
+    () => {
+        // here be dragons, do not enter (or lint)
+        println!("error: something failed at {}", Location::caller().to_string());
+    };
+}
+
+macro_rules! my_other_macro {
+    () => {
+        Location::caller().to_string()
+    };
+}
+
+fn main() {
+    let x = &X(1);
+    let x_ref = &x;
+
+    let _ = format!("error: something failed at {}", Location::caller());
+    let _ = write!(
+        stdout(),
+        "error: something failed at {}",
+        Location::caller()
+    );
+    let _ = writeln!(
+        stdout(),
+        "error: something failed at {}",
+        Location::caller()
+    );
+    print!("error: something failed at {}", Location::caller());
+    println!("error: something failed at {}", Location::caller());
+    eprint!("error: something failed at {}", Location::caller());
+    eprintln!("error: something failed at {}", Location::caller());
+    let _ = format_args!("error: something failed at {}", Location::caller());
+    assert!(true, "error: something failed at {}", Location::caller());
+    assert_eq!(0, 0, "error: something failed at {}", Location::caller());
+    assert_ne!(0, 0, "error: something failed at {}", Location::caller());
+    panic!("error: something failed at {}", Location::caller());
+    println!("{}", *X(1));
+    println!("{}", ***Y(&X(1)));
+    println!("{}", Z(1));
+    println!("{}", **x);
+    println!("{}", ***x_ref);
+
+    println!("error: something failed at {}", Somewhere.to_string());
+    println!("{} and again {0}", x.to_string());
+    my_macro!();
+    println!("error: something failed at {}", my_other_macro!());
+}
diff --git a/tests/ui/format_args.rs b/tests/ui/format_args.rs
new file mode 100644
index 00000000000..164cc07066d
--- /dev/null
+++ b/tests/ui/format_args.rs
@@ -0,0 +1,105 @@
+// run-rustfix
+
+#![allow(unreachable_code)]
+#![allow(unused_macros)]
+#![allow(unused_variables)]
+#![allow(clippy::assertions_on_constants)]
+#![allow(clippy::eq_op)]
+#![warn(clippy::to_string_in_format_args)]
+
+use std::io::{stdout, Write};
+use std::ops::Deref;
+use std::panic::Location;
+
+struct Somewhere;
+
+impl ToString for Somewhere {
+    fn to_string(&self) -> String {
+        String::from("somewhere")
+    }
+}
+
+struct X(u32);
+
+impl Deref for X {
+    type Target = u32;
+
+    fn deref(&self) -> &u32 {
+        &self.0
+    }
+}
+
+struct Y<'a>(&'a X);
+
+impl<'a> Deref for Y<'a> {
+    type Target = &'a X;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+struct Z(u32);
+
+impl Deref for Z {
+    type Target = u32;
+
+    fn deref(&self) -> &u32 {
+        &self.0
+    }
+}
+
+impl std::fmt::Display for Z {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "Z")
+    }
+}
+
+macro_rules! my_macro {
+    () => {
+        // here be dragons, do not enter (or lint)
+        println!("error: something failed at {}", Location::caller().to_string());
+    };
+}
+
+macro_rules! my_other_macro {
+    () => {
+        Location::caller().to_string()
+    };
+}
+
+fn main() {
+    let x = &X(1);
+    let x_ref = &x;
+
+    let _ = format!("error: something failed at {}", Location::caller().to_string());
+    let _ = write!(
+        stdout(),
+        "error: something failed at {}",
+        Location::caller().to_string()
+    );
+    let _ = writeln!(
+        stdout(),
+        "error: something failed at {}",
+        Location::caller().to_string()
+    );
+    print!("error: something failed at {}", Location::caller().to_string());
+    println!("error: something failed at {}", Location::caller().to_string());
+    eprint!("error: something failed at {}", Location::caller().to_string());
+    eprintln!("error: something failed at {}", Location::caller().to_string());
+    let _ = format_args!("error: something failed at {}", Location::caller().to_string());
+    assert!(true, "error: something failed at {}", Location::caller().to_string());
+    assert_eq!(0, 0, "error: something failed at {}", Location::caller().to_string());
+    assert_ne!(0, 0, "error: something failed at {}", Location::caller().to_string());
+    panic!("error: something failed at {}", Location::caller().to_string());
+    println!("{}", X(1).to_string());
+    println!("{}", Y(&X(1)).to_string());
+    println!("{}", Z(1).to_string());
+    println!("{}", x.to_string());
+    println!("{}", x_ref.to_string());
+
+    println!("error: something failed at {}", Somewhere.to_string());
+    println!("{} and again {0}", x.to_string());
+    my_macro!();
+    println!("error: something failed at {}", my_other_macro!());
+}
diff --git a/tests/ui/format_args.stderr b/tests/ui/format_args.stderr
new file mode 100644
index 00000000000..9cfc97edeaf
--- /dev/null
+++ b/tests/ui/format_args.stderr
@@ -0,0 +1,106 @@
+error: `to_string` applied to a type that implements `Display` in `format!` args
+  --> $DIR/format_args.rs:75:72
+   |
+LL |     let _ = format!("error: something failed at {}", Location::caller().to_string());
+   |                                                                        ^^^^^^^^^^^^ help: remove this
+   |
+   = note: `-D clippy::to-string-in-format-args` implied by `-D warnings`
+
+error: `to_string` applied to a type that implements `Display` in `write!` args
+  --> $DIR/format_args.rs:79:27
+   |
+LL |         Location::caller().to_string()
+   |                           ^^^^^^^^^^^^ help: remove this
+
+error: `to_string` applied to a type that implements `Display` in `writeln!` args
+  --> $DIR/format_args.rs:84:27
+   |
+LL |         Location::caller().to_string()
+   |                           ^^^^^^^^^^^^ help: remove this
+
+error: `to_string` applied to a type that implements `Display` in `print!` args
+  --> $DIR/format_args.rs:86:63
+   |
+LL |     print!("error: something failed at {}", Location::caller().to_string());
+   |                                                               ^^^^^^^^^^^^ help: remove this
+
+error: `to_string` applied to a type that implements `Display` in `println!` args
+  --> $DIR/format_args.rs:87:65
+   |
+LL |     println!("error: something failed at {}", Location::caller().to_string());
+   |                                                                 ^^^^^^^^^^^^ help: remove this
+
+error: `to_string` applied to a type that implements `Display` in `eprint!` args
+  --> $DIR/format_args.rs:88:64
+   |
+LL |     eprint!("error: something failed at {}", Location::caller().to_string());
+   |                                                                ^^^^^^^^^^^^ help: remove this
+
+error: `to_string` applied to a type that implements `Display` in `eprintln!` args
+  --> $DIR/format_args.rs:89:66
+   |
+LL |     eprintln!("error: something failed at {}", Location::caller().to_string());
+   |                                                                  ^^^^^^^^^^^^ help: remove this
+
+error: `to_string` applied to a type that implements `Display` in `format_args!` args
+  --> $DIR/format_args.rs:90:77
+   |
+LL |     let _ = format_args!("error: something failed at {}", Location::caller().to_string());
+   |                                                                             ^^^^^^^^^^^^ help: remove this
+
+error: `to_string` applied to a type that implements `Display` in `assert!` args
+  --> $DIR/format_args.rs:91:70
+   |
+LL |     assert!(true, "error: something failed at {}", Location::caller().to_string());
+   |                                                                      ^^^^^^^^^^^^ help: remove this
+
+error: `to_string` applied to a type that implements `Display` in `assert_eq!` args
+  --> $DIR/format_args.rs:92:73
+   |
+LL |     assert_eq!(0, 0, "error: something failed at {}", Location::caller().to_string());
+   |                                                                         ^^^^^^^^^^^^ help: remove this
+
+error: `to_string` applied to a type that implements `Display` in `assert_ne!` args
+  --> $DIR/format_args.rs:93:73
+   |
+LL |     assert_ne!(0, 0, "error: something failed at {}", Location::caller().to_string());
+   |                                                                         ^^^^^^^^^^^^ help: remove this
+
+error: `to_string` applied to a type that implements `Display` in `panic!` args
+  --> $DIR/format_args.rs:94:63
+   |
+LL |     panic!("error: something failed at {}", Location::caller().to_string());
+   |                                                               ^^^^^^^^^^^^ help: remove this
+
+error: `to_string` applied to a type that implements `Display` in `println!` args
+  --> $DIR/format_args.rs:95:20
+   |
+LL |     println!("{}", X(1).to_string());
+   |                    ^^^^^^^^^^^^^^^^ help: use this: `*X(1)`
+
+error: `to_string` applied to a type that implements `Display` in `println!` args
+  --> $DIR/format_args.rs:96:20
+   |
+LL |     println!("{}", Y(&X(1)).to_string());
+   |                    ^^^^^^^^^^^^^^^^^^^^ help: use this: `***Y(&X(1))`
+
+error: `to_string` applied to a type that implements `Display` in `println!` args
+  --> $DIR/format_args.rs:97:24
+   |
+LL |     println!("{}", Z(1).to_string());
+   |                        ^^^^^^^^^^^^ help: remove this
+
+error: `to_string` applied to a type that implements `Display` in `println!` args
+  --> $DIR/format_args.rs:98:20
+   |
+LL |     println!("{}", x.to_string());
+   |                    ^^^^^^^^^^^^^ help: use this: `**x`
+
+error: `to_string` applied to a type that implements `Display` in `println!` args
+  --> $DIR/format_args.rs:99:20
+   |
+LL |     println!("{}", x_ref.to_string());
+   |                    ^^^^^^^^^^^^^^^^^ help: use this: `***x_ref`
+
+error: aborting due to 17 previous errors
+
diff --git a/tests/ui/format_args_unfixable.rs b/tests/ui/format_args_unfixable.rs
new file mode 100644
index 00000000000..a8c06c2bde6
--- /dev/null
+++ b/tests/ui/format_args_unfixable.rs
@@ -0,0 +1,60 @@
+#![allow(clippy::assertions_on_constants)]
+#![allow(clippy::eq_op)]
+#![warn(clippy::format_in_format_args)]
+#![warn(clippy::to_string_in_format_args)]
+
+use std::io::{stdout, Error, ErrorKind, Write};
+use std::ops::Deref;
+use std::panic::Location;
+
+macro_rules! my_macro {
+    () => {
+        // here be dragons, do not enter (or lint)
+        println!("error: {}", format!("something failed at {}", Location::caller()));
+    };
+}
+
+macro_rules! my_other_macro {
+    () => {
+        format!("something failed at {}", Location::caller())
+    };
+}
+
+fn main() {
+    let error = Error::new(ErrorKind::Other, "bad thing");
+    let x = 'x';
+
+    println!("error: {}", format!("something failed at {}", Location::caller()));
+    println!("{}: {}", error, format!("something failed at {}", Location::caller()));
+    println!("{:?}: {}", error, format!("something failed at {}", Location::caller()));
+    println!("{{}}: {}", format!("something failed at {}", Location::caller()));
+    println!(r#"error: "{}""#, format!("something failed at {}", Location::caller()));
+    println!("error: {}", format!(r#"something failed at "{}""#, Location::caller()));
+    println!("error: {}", format!("something failed at {} {0}", Location::caller()));
+    let _ = format!("error: {}", format!("something failed at {}", Location::caller()));
+    let _ = write!(
+        stdout(),
+        "error: {}",
+        format!("something failed at {}", Location::caller())
+    );
+    let _ = writeln!(
+        stdout(),
+        "error: {}",
+        format!("something failed at {}", Location::caller())
+    );
+    print!("error: {}", format!("something failed at {}", Location::caller()));
+    eprint!("error: {}", format!("something failed at {}", Location::caller()));
+    eprintln!("error: {}", format!("something failed at {}", Location::caller()));
+    let _ = format_args!("error: {}", format!("something failed at {}", Location::caller()));
+    assert!(true, "error: {}", format!("something failed at {}", Location::caller()));
+    assert_eq!(0, 0, "error: {}", format!("something failed at {}", Location::caller()));
+    assert_ne!(0, 0, "error: {}", format!("something failed at {}", Location::caller()));
+    panic!("error: {}", format!("something failed at {}", Location::caller()));
+
+    println!("error: {}", format_args!("something failed at {}", Location::caller()));
+    println!("error: {:>70}", format!("something failed at {}", Location::caller()));
+    println!("error: {} {0}", format!("something failed at {}", Location::caller()));
+    println!("{} and again {0}", format!("hi {}", x));
+    my_macro!();
+    println!("error: {}", my_other_macro!());
+}
diff --git a/tests/ui/format_args_unfixable.stderr b/tests/ui/format_args_unfixable.stderr
new file mode 100644
index 00000000000..4476218ad58
--- /dev/null
+++ b/tests/ui/format_args_unfixable.stderr
@@ -0,0 +1,175 @@
+error: `format!` in `println!` args
+  --> $DIR/format_args_unfixable.rs:27:5
+   |
+LL |     println!("error: {}", format!("something failed at {}", Location::caller()));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::format-in-format-args` implied by `-D warnings`
+   = help: combine the `format!(..)` arguments with the outer `println!(..)` call
+   = help: or consider changing `format!` to `format_args!`
+
+error: `format!` in `println!` args
+  --> $DIR/format_args_unfixable.rs:28:5
+   |
+LL |     println!("{}: {}", error, format!("something failed at {}", Location::caller()));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: combine the `format!(..)` arguments with the outer `println!(..)` call
+   = help: or consider changing `format!` to `format_args!`
+
+error: `format!` in `println!` args
+  --> $DIR/format_args_unfixable.rs:29:5
+   |
+LL |     println!("{:?}: {}", error, format!("something failed at {}", Location::caller()));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: combine the `format!(..)` arguments with the outer `println!(..)` call
+   = help: or consider changing `format!` to `format_args!`
+
+error: `format!` in `println!` args
+  --> $DIR/format_args_unfixable.rs:30:5
+   |
+LL |     println!("{{}}: {}", format!("something failed at {}", Location::caller()));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: combine the `format!(..)` arguments with the outer `println!(..)` call
+   = help: or consider changing `format!` to `format_args!`
+
+error: `format!` in `println!` args
+  --> $DIR/format_args_unfixable.rs:31:5
+   |
+LL |     println!(r#"error: "{}""#, format!("something failed at {}", Location::caller()));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: combine the `format!(..)` arguments with the outer `println!(..)` call
+   = help: or consider changing `format!` to `format_args!`
+
+error: `format!` in `println!` args
+  --> $DIR/format_args_unfixable.rs:32:5
+   |
+LL |     println!("error: {}", format!(r#"something failed at "{}""#, Location::caller()));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: combine the `format!(..)` arguments with the outer `println!(..)` call
+   = help: or consider changing `format!` to `format_args!`
+
+error: `format!` in `println!` args
+  --> $DIR/format_args_unfixable.rs:33:5
+   |
+LL |     println!("error: {}", format!("something failed at {} {0}", Location::caller()));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: combine the `format!(..)` arguments with the outer `println!(..)` call
+   = help: or consider changing `format!` to `format_args!`
+
+error: `format!` in `format!` args
+  --> $DIR/format_args_unfixable.rs:34:13
+   |
+LL |     let _ = format!("error: {}", format!("something failed at {}", Location::caller()));
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: combine the `format!(..)` arguments with the outer `format!(..)` call
+   = help: or consider changing `format!` to `format_args!`
+
+error: `format!` in `write!` args
+  --> $DIR/format_args_unfixable.rs:35:13
+   |
+LL |       let _ = write!(
+   |  _____________^
+LL | |         stdout(),
+LL | |         "error: {}",
+LL | |         format!("something failed at {}", Location::caller())
+LL | |     );
+   | |_____^
+   |
+   = help: combine the `format!(..)` arguments with the outer `write!(..)` call
+   = help: or consider changing `format!` to `format_args!`
+
+error: `format!` in `writeln!` args
+  --> $DIR/format_args_unfixable.rs:40:13
+   |
+LL |       let _ = writeln!(
+   |  _____________^
+LL | |         stdout(),
+LL | |         "error: {}",
+LL | |         format!("something failed at {}", Location::caller())
+LL | |     );
+   | |_____^
+   |
+   = help: combine the `format!(..)` arguments with the outer `writeln!(..)` call
+   = help: or consider changing `format!` to `format_args!`
+
+error: `format!` in `print!` args
+  --> $DIR/format_args_unfixable.rs:45:5
+   |
+LL |     print!("error: {}", format!("something failed at {}", Location::caller()));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: combine the `format!(..)` arguments with the outer `print!(..)` call
+   = help: or consider changing `format!` to `format_args!`
+
+error: `format!` in `eprint!` args
+  --> $DIR/format_args_unfixable.rs:46:5
+   |
+LL |     eprint!("error: {}", format!("something failed at {}", Location::caller()));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: combine the `format!(..)` arguments with the outer `eprint!(..)` call
+   = help: or consider changing `format!` to `format_args!`
+
+error: `format!` in `eprintln!` args
+  --> $DIR/format_args_unfixable.rs:47:5
+   |
+LL |     eprintln!("error: {}", format!("something failed at {}", Location::caller()));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: combine the `format!(..)` arguments with the outer `eprintln!(..)` call
+   = help: or consider changing `format!` to `format_args!`
+
+error: `format!` in `format_args!` args
+  --> $DIR/format_args_unfixable.rs:48:13
+   |
+LL |     let _ = format_args!("error: {}", format!("something failed at {}", Location::caller()));
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: combine the `format!(..)` arguments with the outer `format_args!(..)` call
+   = help: or consider changing `format!` to `format_args!`
+
+error: `format!` in `assert!` args
+  --> $DIR/format_args_unfixable.rs:49:5
+   |
+LL |     assert!(true, "error: {}", format!("something failed at {}", Location::caller()));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: combine the `format!(..)` arguments with the outer `assert!(..)` call
+   = help: or consider changing `format!` to `format_args!`
+
+error: `format!` in `assert_eq!` args
+  --> $DIR/format_args_unfixable.rs:50:5
+   |
+LL |     assert_eq!(0, 0, "error: {}", format!("something failed at {}", Location::caller()));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: combine the `format!(..)` arguments with the outer `assert_eq!(..)` call
+   = help: or consider changing `format!` to `format_args!`
+
+error: `format!` in `assert_ne!` args
+  --> $DIR/format_args_unfixable.rs:51:5
+   |
+LL |     assert_ne!(0, 0, "error: {}", format!("something failed at {}", Location::caller()));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: combine the `format!(..)` arguments with the outer `assert_ne!(..)` call
+   = help: or consider changing `format!` to `format_args!`
+
+error: `format!` in `panic!` args
+  --> $DIR/format_args_unfixable.rs:52:5
+   |
+LL |     panic!("error: {}", format!("something failed at {}", Location::caller()));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: combine the `format!(..)` arguments with the outer `panic!(..)` call
+   = help: or consider changing `format!` to `format_args!`
+
+error: aborting due to 18 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 75e9f8cbd6d8c704ec89d12e3ddc382402a13119 Mon Sep 17 00:00:00 2001
From: "Samuel E. Moelius III" <sam@moeli.us>
Date: Thu, 30 Sep 2021 07:38:03 -0400
Subject: Remove redundant `to_string`s

---
 clippy_dev/src/update_lints.rs                       | 4 ++--
 clippy_lints/src/if_then_panic.rs                    | 4 ++--
 clippy_lints/src/inherent_to_string.rs               | 8 ++++----
 clippy_lints/src/suspicious_operation_groupings.rs   | 2 +-
 clippy_lints/src/transmute/transmute_int_to_char.rs  | 2 +-
 clippy_lints/src/transmute/transmute_int_to_float.rs | 2 +-
 clippy_lints/src/transmute/transmute_num_to_bytes.rs | 2 +-
 7 files changed, 12 insertions(+), 12 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_dev/src/update_lints.rs b/clippy_dev/src/update_lints.rs
index 10d859988f6..23f58bc4915 100644
--- a/clippy_dev/src/update_lints.rs
+++ b/clippy_dev/src/update_lints.rs
@@ -619,8 +619,8 @@ mod tests {
             Lint::new("should_assert_eq2", "group2", "abc", None, "module_name"),
         ];
         let expected = vec![
-            format!("[`should_assert_eq`]: {}#should_assert_eq", DOCS_LINK.to_string()),
-            format!("[`should_assert_eq2`]: {}#should_assert_eq2", DOCS_LINK.to_string()),
+            format!("[`should_assert_eq`]: {}#should_assert_eq", DOCS_LINK),
+            format!("[`should_assert_eq2`]: {}#should_assert_eq2", DOCS_LINK),
         ];
         assert_eq!(expected, gen_changelog_lint_list(lints.iter()));
     }
diff --git a/clippy_lints/src/if_then_panic.rs b/clippy_lints/src/if_then_panic.rs
index 10bca59e6d0..e8cea5529e8 100644
--- a/clippy_lints/src/if_then_panic.rs
+++ b/clippy_lints/src/if_then_panic.rs
@@ -78,10 +78,10 @@ impl LateLintPass<'_> for IfThenPanic {
                     if let Expr{kind: ExprKind::Unary(UnOp::Not, not_expr), ..} = e {
                          sugg::Sugg::hir_with_applicability(cx, not_expr, "..", &mut applicability).maybe_par().to_string()
                     } else {
-                       format!("!{}", sugg::Sugg::hir_with_applicability(cx, e, "..", &mut applicability).maybe_par().to_string())
+                       format!("!{}", sugg::Sugg::hir_with_applicability(cx, e, "..", &mut applicability).maybe_par())
                     }
                 } else {
-                   format!("!{}", sugg::Sugg::hir_with_applicability(cx, cond, "..", &mut applicability).maybe_par().to_string())
+                   format!("!{}", sugg::Sugg::hir_with_applicability(cx, cond, "..", &mut applicability).maybe_par())
                 };
 
                 span_lint_and_sugg(
diff --git a/clippy_lints/src/inherent_to_string.rs b/clippy_lints/src/inherent_to_string.rs
index 3c40ca50a09..61dd0eb4af7 100644
--- a/clippy_lints/src/inherent_to_string.rs
+++ b/clippy_lints/src/inherent_to_string.rs
@@ -138,10 +138,10 @@ fn show_lint(cx: &LateContext<'_>, item: &ImplItem<'_>) {
             item.span,
             &format!(
                 "type `{}` implements inherent method `to_string(&self) -> String` which shadows the implementation of `Display`",
-                self_type.to_string()
+                self_type
             ),
             None,
-            &format!("remove the inherent method from type `{}`", self_type.to_string()),
+            &format!("remove the inherent method from type `{}`", self_type),
         );
     } else {
         span_lint_and_help(
@@ -150,10 +150,10 @@ fn show_lint(cx: &LateContext<'_>, item: &ImplItem<'_>) {
             item.span,
             &format!(
                 "implementation of inherent method `to_string(&self) -> String` for type `{}`",
-                self_type.to_string()
+                self_type
             ),
             None,
-            &format!("implement trait `Display` for type `{}` instead", self_type.to_string()),
+            &format!("implement trait `Display` for type `{}` instead", self_type),
         );
     }
 }
diff --git a/clippy_lints/src/suspicious_operation_groupings.rs b/clippy_lints/src/suspicious_operation_groupings.rs
index 44d5ff0b63a..201aa067824 100644
--- a/clippy_lints/src/suspicious_operation_groupings.rs
+++ b/clippy_lints/src/suspicious_operation_groupings.rs
@@ -678,7 +678,7 @@ fn suggestion_with_swapped_ident(
         Some(format!(
             "{}{}{}",
             snippet_with_applicability(cx, expr.span.with_hi(current_ident.span.lo()), "..", applicability),
-            new_ident.to_string(),
+            new_ident,
             snippet_with_applicability(cx, expr.span.with_lo(current_ident.span.hi()), "..", applicability),
         ))
     })
diff --git a/clippy_lints/src/transmute/transmute_int_to_char.rs b/clippy_lints/src/transmute/transmute_int_to_char.rs
index 8f884e6a4a1..e83d2e06b9a 100644
--- a/clippy_lints/src/transmute/transmute_int_to_char.rs
+++ b/clippy_lints/src/transmute/transmute_int_to_char.rs
@@ -33,7 +33,7 @@ pub(super) fn check<'tcx>(
                     diag.span_suggestion(
                         e.span,
                         "consider using",
-                        format!("std::char::from_u32({}).unwrap()", arg.to_string()),
+                        format!("std::char::from_u32({}).unwrap()", arg),
                         Applicability::Unspecified,
                     );
                 },
diff --git a/clippy_lints/src/transmute/transmute_int_to_float.rs b/clippy_lints/src/transmute/transmute_int_to_float.rs
index 2b6a4cff81e..05eee380d6f 100644
--- a/clippy_lints/src/transmute/transmute_int_to_float.rs
+++ b/clippy_lints/src/transmute/transmute_int_to_float.rs
@@ -36,7 +36,7 @@ pub(super) fn check<'tcx>(
                     diag.span_suggestion(
                         e.span,
                         "consider using",
-                        format!("{}::from_bits({})", to_ty, arg.to_string()),
+                        format!("{}::from_bits({})", to_ty, arg),
                         Applicability::Unspecified,
                     );
                 },
diff --git a/clippy_lints/src/transmute/transmute_num_to_bytes.rs b/clippy_lints/src/transmute/transmute_num_to_bytes.rs
index dd5ded1c91a..5ba58a76494 100644
--- a/clippy_lints/src/transmute/transmute_num_to_bytes.rs
+++ b/clippy_lints/src/transmute/transmute_num_to_bytes.rs
@@ -37,7 +37,7 @@ pub(super) fn check<'tcx>(
                     diag.span_suggestion(
                         e.span,
                         "consider using `to_ne_bytes()`",
-                        format!("{}.to_ne_bytes()", arg.to_string()),
+                        format!("{}.to_ne_bytes()", arg),
                         Applicability::Unspecified,
                     );
                 },
-- 
cgit 1.4.1-3-g733a5


From 25ff7ce1283c45a330793ce74cfa5190c4ab68f8 Mon Sep 17 00:00:00 2001
From: Matthias Kaak <m.kaak@protonmail.ch>
Date: Sat, 16 Oct 2021 15:23:34 +0000
Subject: Fixed naive doc formatting for `#[must_use]` lints

---
 clippy_lints/src/functions/mod.rs  | 12 +++---------
 clippy_lints/src/let_underscore.rs |  7 +++----
 2 files changed, 6 insertions(+), 13 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/functions/mod.rs b/clippy_lints/src/functions/mod.rs
index 04fc5887e8e..d7c5ec9ba35 100644
--- a/clippy_lints/src/functions/mod.rs
+++ b/clippy_lints/src/functions/mod.rs
@@ -91,11 +91,9 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for a [`#[must_use]`] attribute on
+    /// Checks for a `#[must_use]` attribute on
     /// unit-returning functions and methods.
     ///
-    /// [`#[must_use]`]: https://doc.rust-lang.org/reference/attributes/diagnostics.html#the-must_use-attribute
-    ///
     /// ### Why is this bad?
     /// Unit values are useless. The attribute is likely
     /// a remnant of a refactoring that removed the return type.
@@ -112,12 +110,10 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for a [`#[must_use]`] attribute without
+    /// Checks for a `#[must_use]` attribute without
     /// further information on functions and methods that return a type already
     /// marked as `#[must_use]`.
     ///
-    /// [`#[must_use]`]: https://doc.rust-lang.org/reference/attributes/diagnostics.html#the-must_use-attribute
-    ///
     /// ### Why is this bad?
     /// The attribute isn't needed. Not using the result
     /// will already be reported. Alternatively, one can add some text to the
@@ -138,11 +134,9 @@ declare_clippy_lint! {
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for public functions that have no
-    /// [`#[must_use]`] attribute, but return something not already marked
+    /// `#[must_use]` attribute, but return something not already marked
     /// must-use, have no mutable arg and mutate no statics.
     ///
-    /// [`#[must_use]`]: https://doc.rust-lang.org/reference/attributes/diagnostics.html#the-must_use-attribute
-    ///
     /// ### Why is this bad?
     /// Not bad at all, this lint just shows places where
     /// you could add the attribute.
diff --git a/clippy_lints/src/let_underscore.rs b/clippy_lints/src/let_underscore.rs
index 89146b4dd2c..9efd7aba7e8 100644
--- a/clippy_lints/src/let_underscore.rs
+++ b/clippy_lints/src/let_underscore.rs
@@ -10,12 +10,11 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for `let _ = <expr>`
-    /// where expr is #[must_use]
+    /// Checks for `let _ = <expr>` where expr is `#[must_use]`
     ///
     /// ### Why is this bad?
-    /// It's better to explicitly
-    /// handle the value of a #[must_use] expr
+    /// It's better to explicitly handle the value of a `#[must_use]`
+    /// expr
     ///
     /// ### Example
     /// ```rust
-- 
cgit 1.4.1-3-g733a5


From a550133b8fa9e3bae23c26eadae1a75f86b240a6 Mon Sep 17 00:00:00 2001
From: Paul Gey <narpfel@gmx.de>
Date: Sun, 17 Oct 2021 15:56:59 +0200
Subject: Fix false positive of `implicit_saturating_sub` with `else` clause

Fixes #7831
---
 clippy_lints/src/implicit_saturating_sub.rs | 2 +-
 tests/ui/implicit_saturating_sub.fixed      | 8 ++++++++
 tests/ui/implicit_saturating_sub.rs         | 8 ++++++++
 3 files changed, 17 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/implicit_saturating_sub.rs b/clippy_lints/src/implicit_saturating_sub.rs
index 79d4d7ddcbc..a4f60ded3a6 100644
--- a/clippy_lints/src/implicit_saturating_sub.rs
+++ b/clippy_lints/src/implicit_saturating_sub.rs
@@ -43,7 +43,7 @@ impl<'tcx> LateLintPass<'tcx> for ImplicitSaturatingSub {
             return;
         }
         if_chain! {
-            if let Some(higher::If { cond, then, .. }) = higher::If::hir(expr);
+            if let Some(higher::If { cond, then, r#else: None }) = higher::If::hir(expr);
 
             // Check if the conditional expression is a binary operation
             if let ExprKind::Binary(ref cond_op, cond_left, cond_right) = cond.kind;
diff --git a/tests/ui/implicit_saturating_sub.fixed b/tests/ui/implicit_saturating_sub.fixed
index 859765d08a7..e6f57e9267e 100644
--- a/tests/ui/implicit_saturating_sub.fixed
+++ b/tests/ui/implicit_saturating_sub.fixed
@@ -157,4 +157,12 @@ fn main() {
     if i_64 != 0 {
         i_64 -= 1;
     }
+
+    // issue #7831
+    // No Lint
+    if u_32 > 0 {
+        u_32 -= 1;
+    } else {
+        println!("side effect");
+    }
 }
diff --git a/tests/ui/implicit_saturating_sub.rs b/tests/ui/implicit_saturating_sub.rs
index 2f32a7b1578..8bb28d149c6 100644
--- a/tests/ui/implicit_saturating_sub.rs
+++ b/tests/ui/implicit_saturating_sub.rs
@@ -203,4 +203,12 @@ fn main() {
     if i_64 != 0 {
         i_64 -= 1;
     }
+
+    // issue #7831
+    // No Lint
+    if u_32 > 0 {
+        u_32 -= 1;
+    } else {
+        println!("side effect");
+    }
 }
-- 
cgit 1.4.1-3-g733a5


From 63d715209eaf241114f87db247b435df5272e8e4 Mon Sep 17 00:00:00 2001
From: Michael Wright <mikerite@lavabit.com>
Date: Mon, 18 Oct 2021 08:46:11 +0200
Subject: Remove unneeded allow

---
 clippy_lints/src/identity_op.rs | 1 -
 1 file changed, 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/identity_op.rs b/clippy_lints/src/identity_op.rs
index 73bdd67ff5d..414f465c494 100644
--- a/clippy_lints/src/identity_op.rs
+++ b/clippy_lints/src/identity_op.rs
@@ -66,7 +66,6 @@ fn is_allowed(cx: &LateContext<'_>, cmp: BinOp, left: &Expr<'_>, right: &Expr<'_
         && constant_simple(cx, cx.typeck_results(), left) == Some(Constant::Int(1))
 }
 
-#[allow(clippy::cast_possible_wrap)]
 fn check(cx: &LateContext<'_>, e: &Expr<'_>, m: i8, span: Span, arg: Span) {
     if let Some(Constant::Int(v)) = constant_simple(cx, cx.typeck_results(), e) {
         let check = match *cx.typeck_results().expr_ty(e).kind() {
-- 
cgit 1.4.1-3-g733a5


From 797507c58390662098f0d20a9ee89d200f93f11c Mon Sep 17 00:00:00 2001
From: Nathaniel Hamovitz <18648574+nhamovitz@users.noreply.github.com>
Date: Thu, 14 Oct 2021 20:08:38 -0700
Subject: Add boilerplate and basic tests

---
 CHANGELOG.md                                       |  1 +
 clippy_lints/src/lib.register_lints.rs             |  1 +
 clippy_lints/src/lib.register_nursery.rs           |  1 +
 clippy_lints/src/lib.rs                            |  1 +
 .../trailing_zero_sized_array_without_repr_c.rs    | 58 ++++++++++++++++++++++
 .../ui/trailing_zero_sized_array_without_repr_c.rs | 23 +++++++++
 6 files changed, 85 insertions(+)
 create mode 100644 clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs
 create mode 100644 tests/ui/trailing_zero_sized_array_without_repr_c.rs

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index f6a883311c9..a124bebe924 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3021,6 +3021,7 @@ Released 2018-09-13
 [`too_many_arguments`]: https://rust-lang.github.io/rust-clippy/master/index.html#too_many_arguments
 [`too_many_lines`]: https://rust-lang.github.io/rust-clippy/master/index.html#too_many_lines
 [`toplevel_ref_arg`]: https://rust-lang.github.io/rust-clippy/master/index.html#toplevel_ref_arg
+[`trailing_zero_sized_array_without_repr_c`]: https://rust-lang.github.io/rust-clippy/master/index.html#trailing_zero_sized_array_without_repr_c
 [`trait_duplication_in_bounds`]: https://rust-lang.github.io/rust-clippy/master/index.html#trait_duplication_in_bounds
 [`transmute_bytes_to_str`]: https://rust-lang.github.io/rust-clippy/master/index.html#transmute_bytes_to_str
 [`transmute_float_to_int`]: https://rust-lang.github.io/rust-clippy/master/index.html#transmute_float_to_int
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index f334f723f6b..34b87002fa3 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -443,6 +443,7 @@ store.register_lints(&[
     temporary_assignment::TEMPORARY_ASSIGNMENT,
     to_digit_is_some::TO_DIGIT_IS_SOME,
     to_string_in_display::TO_STRING_IN_DISPLAY,
+    trailing_zero_sized_array_without_repr_c::TRAILING_ZERO_SIZED_ARRAY_WITHOUT_REPR_C,
     trait_bounds::TRAIT_DUPLICATION_IN_BOUNDS,
     trait_bounds::TYPE_REPETITION_IN_BOUNDS,
     transmute::CROSSPOINTER_TRANSMUTE,
diff --git a/clippy_lints/src/lib.register_nursery.rs b/clippy_lints/src/lib.register_nursery.rs
index 96e0b421094..325706746db 100644
--- a/clippy_lints/src/lib.register_nursery.rs
+++ b/clippy_lints/src/lib.register_nursery.rs
@@ -25,6 +25,7 @@ store.register_group(true, "clippy::nursery", Some("clippy_nursery"), vec![
     LintId::of(regex::TRIVIAL_REGEX),
     LintId::of(strings::STRING_LIT_AS_BYTES),
     LintId::of(suspicious_operation_groupings::SUSPICIOUS_OPERATION_GROUPINGS),
+    LintId::of(trailing_zero_sized_array_without_repr_c::TRAILING_ZERO_SIZED_ARRAY_WITHOUT_REPR_C),
     LintId::of(transmute::USELESS_TRANSMUTE),
     LintId::of(use_self::USE_SELF),
 ])
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 9794d74e198..17bffc08309 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -355,6 +355,7 @@ mod tabs_in_doc_comments;
 mod temporary_assignment;
 mod to_digit_is_some;
 mod to_string_in_display;
+mod trailing_zero_sized_array_without_repr_c;
 mod trait_bounds;
 mod transmute;
 mod transmuting_null;
diff --git a/clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs b/clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs
new file mode 100644
index 00000000000..9aea22af274
--- /dev/null
+++ b/clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs
@@ -0,0 +1,58 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use rustc_hir::*;
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Displays a warning when a struct with a trailing zero-sized array is declared without the `repr(C)` attribute.
+    ///
+    /// ### Why is this bad?
+    /// Zero-sized arrays aren't very useful in Rust itself, so such a struct is likely being created to pass to C code (or in conjuction with manual allocation to make it easy to compute the offset of the array). Either way, `#[repr(C)]` is needed.
+    ///
+    /// ### Example
+    /// ```rust
+    /// struct RarelyUseful {
+    ///     some_field: usize,
+    ///     last: [SomeType; 0],
+    /// }
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust
+    /// #[repr(C)]
+    /// struct MakesSense {
+    ///     some_field: usize,
+    ///     last: [SomeType; 0],
+    /// }
+    /// ```
+    pub TRAILING_ZERO_SIZED_ARRAY_WITHOUT_REPR_C,
+    nursery,
+    "struct with a trailing zero-sized array but without `repr(C)`"
+}
+declare_lint_pass!(TrailingZeroSizedArrayWithoutReprC => [TRAILING_ZERO_SIZED_ARRAY_WITHOUT_REPR_C]);
+
+impl LateLintPass<'_> for TrailingZeroSizedArrayWithoutReprC {
+    fn check_struct_def(&mut self, _: &LateContext<'tcx>, _: &'tcx rustc_hir::VariantData<'tcx>) {}
+
+    fn check_struct_def_post(&mut self, _: &LateContext<'tcx>, _: &'tcx rustc_hir::VariantData<'tcx>) {}
+    // https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/sty/enum.TyKind.html#variant.Array in latepass
+    // or https://doc.rust-lang.org/nightly/nightly-rustc/rustc_ast/ast/enum.TyKind.html#variant.Array in early pass
+
+    fn check_field_def(&mut self, _: &LateContext<'tcx>, _: &'tcx rustc_hir::FieldDef<'tcx>) {}
+
+    fn check_attribute(&mut self, _: &LateContext<'tcx>, _: &'tcx rustc_ast::Attribute) {}
+
+    fn enter_lint_attrs(&mut self, _: &LateContext<'tcx>, _: &'tcx [rustc_ast::Attribute]) {}
+
+    fn exit_lint_attrs(&mut self, _: &LateContext<'tcx>, _: &'tcx [rustc_ast::Attribute]) {}
+}
+//
+// TODO: Register the lint pass in `clippy_lints/src/lib.rs`,
+//       e.g. store.register_late_pass(||
+// Box::new(trailing_zero_sized_array_without_repr_c::TrailingZeroSizedArrayWithoutReprC));
+
+
+fn temp_alert() {
+    span_lint_and_sugg(cx, lint, sp, msg, help, sugg, applicability)
+}
\ No newline at end of file
diff --git a/tests/ui/trailing_zero_sized_array_without_repr_c.rs b/tests/ui/trailing_zero_sized_array_without_repr_c.rs
new file mode 100644
index 00000000000..2a0f432bc2d
--- /dev/null
+++ b/tests/ui/trailing_zero_sized_array_without_repr_c.rs
@@ -0,0 +1,23 @@
+#![warn(clippy::trailing_zero_sized_array_without_repr_c)]
+
+struct RarelyUseful {
+    field: i32,
+    last: [SomeType; 0],
+}
+
+#[repr(C)]
+struct GoodReason {
+    field: i32,
+    last: [SomeType; 0],
+}
+
+struct OnlyFieldIsZeroSizeArray {
+    first_and_last: [SomeType; 0],
+}
+
+struct GenericArrayType<T> {
+    field: i32,
+    last: [T; 0],
+}
+
+fn main() {}
-- 
cgit 1.4.1-3-g733a5


From c69387a0d530dccb56ef11d4cd148f9c38904893 Mon Sep 17 00:00:00 2001
From: Nathaniel Hamovitz <18648574+nhamovitz@users.noreply.github.com>
Date: Fri, 15 Oct 2021 00:13:42 -0700
Subject: Well it builds

---
 .../trailing_zero_sized_array_without_repr_c.rs    | 47 +++++++++++++++++-----
 .../ui/trailing_zero_sized_array_without_repr_c.rs |  6 +--
 2 files changed, 41 insertions(+), 12 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs b/clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs
index 9aea22af274..507d9b40412 100644
--- a/clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs
+++ b/clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs
@@ -1,5 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use rustc_hir::*;
+use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
@@ -33,26 +34,54 @@ declare_clippy_lint! {
 declare_lint_pass!(TrailingZeroSizedArrayWithoutReprC => [TRAILING_ZERO_SIZED_ARRAY_WITHOUT_REPR_C]);
 
 impl LateLintPass<'_> for TrailingZeroSizedArrayWithoutReprC {
-    fn check_struct_def(&mut self, _: &LateContext<'tcx>, _: &'tcx rustc_hir::VariantData<'tcx>) {}
+    fn check_struct_def(&mut self, cx: &LateContext<'tcx>, data: &'tcx rustc_hir::VariantData<'tcx>) {
+        dbg!("in check_struct_def");
+        if_chain! {
+            if let Some(def) = data.fields().last();
+            if let rustc_hir::TyKind::Array(ty, acost) = def.ty.kind;
+            then {
+                // is the AnonConst `0`
+            }
+        }
 
-    fn check_struct_def_post(&mut self, _: &LateContext<'tcx>, _: &'tcx rustc_hir::VariantData<'tcx>) {}
+        // span_lint_and_sugg(
+        //     cx,
+        //     todo!(),
+        //     todo!(),
+        //     todo!(),
+        //     todo!(),
+        //     todo!(),
+        //     rustc_errors::Applicability::MaybeIncorrect,
+        // )
+    }
     // https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/sty/enum.TyKind.html#variant.Array in latepass
     // or https://doc.rust-lang.org/nightly/nightly-rustc/rustc_ast/ast/enum.TyKind.html#variant.Array in early pass
 
-    fn check_field_def(&mut self, _: &LateContext<'tcx>, _: &'tcx rustc_hir::FieldDef<'tcx>) {}
+    // fn check_struct_def_post(&mut self, _: &LateContext<'tcx>, _: &'tcx rustc_hir::VariantData<'tcx>)
+    // {}
 
-    fn check_attribute(&mut self, _: &LateContext<'tcx>, _: &'tcx rustc_ast::Attribute) {}
+    // fn check_field_def(&mut self, _: &LateContext<'tcx>, _: &'tcx rustc_hir::FieldDef<'tcx>) {}
 
-    fn enter_lint_attrs(&mut self, _: &LateContext<'tcx>, _: &'tcx [rustc_ast::Attribute]) {}
+    // fn check_attribute(&mut self, _: &LateContext<'tcx>, _: &'tcx rustc_ast::Attribute) {}
 
-    fn exit_lint_attrs(&mut self, _: &LateContext<'tcx>, _: &'tcx [rustc_ast::Attribute]) {}
+    // fn enter_lint_attrs(&mut self, _: &LateContext<'tcx>, _: &'tcx [rustc_ast::Attribute]) {}
+
+    // fn exit_lint_attrs(&mut self, _: &LateContext<'tcx>, _: &'tcx [rustc_ast::Attribute]) {}
 }
 //
 // TODO: Register the lint pass in `clippy_lints/src/lib.rs`,
 //       e.g. store.register_late_pass(||
 // Box::new(trailing_zero_sized_array_without_repr_c::TrailingZeroSizedArrayWithoutReprC));
 
+// fn temp_alert() {}
 
-fn temp_alert() {
-    span_lint_and_sugg(cx, lint, sp, msg, help, sugg, applicability)
-}
\ No newline at end of file
+impl EarlyLintPass for TrailingZeroSizedArrayWithoutReprC {
+    fn check_struct_def(&mut self, cx: &EarlyContext<'_>, data: &rustc_ast::VariantData) {
+        if_chain! {
+            if let rustc_ast::ast::VariantData::Struct(field_defs, some_bool_huh) = data;
+            if let Some(last_field) = field_defs.last();
+            if let rustc_ast::ast::TyKind::Array(_, aconst) = &last_field.ty.kind;            
+            then {dbg!(aconst); return ();}
+        }
+    }
+}
diff --git a/tests/ui/trailing_zero_sized_array_without_repr_c.rs b/tests/ui/trailing_zero_sized_array_without_repr_c.rs
index 2a0f432bc2d..771622178e7 100644
--- a/tests/ui/trailing_zero_sized_array_without_repr_c.rs
+++ b/tests/ui/trailing_zero_sized_array_without_repr_c.rs
@@ -2,17 +2,17 @@
 
 struct RarelyUseful {
     field: i32,
-    last: [SomeType; 0],
+    last: [usize; 0],
 }
 
 #[repr(C)]
 struct GoodReason {
     field: i32,
-    last: [SomeType; 0],
+    last: [usize; 0],
 }
 
 struct OnlyFieldIsZeroSizeArray {
-    first_and_last: [SomeType; 0],
+    first_and_last: [usize; 0],
 }
 
 struct GenericArrayType<T> {
-- 
cgit 1.4.1-3-g733a5


From 92d3b775bd05c363b69b91ed66c20904c7fbfbe7 Mon Sep 17 00:00:00 2001
From: Nathaniel Hamovitz <18648574+nhamovitz@users.noreply.github.com>
Date: Fri, 15 Oct 2021 01:31:26 -0700
Subject: ayy it compiles! ship it, right? 😎 /s
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

why was `rustc_lint_defs` not already externed in `lib.rs`?
and how was r-a able to find it but cargo wasn't? 🤔
---
 clippy_lints/src/lib.rs                            |  2 +
 .../trailing_zero_sized_array_without_repr_c.rs    | 76 +++++++++-------------
 2 files changed, 33 insertions(+), 45 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 17bffc08309..6624ee93101 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -30,6 +30,7 @@ extern crate rustc_index;
 extern crate rustc_infer;
 extern crate rustc_lexer;
 extern crate rustc_lint;
+extern crate rustc_lint_defs;
 extern crate rustc_middle;
 extern crate rustc_mir_dataflow;
 extern crate rustc_parse;
@@ -487,6 +488,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         store.register_late_pass(|| Box::new(utils::internal_lints::OuterExpnDataPass));
     }
 
+    store.register_early_pass(||        Box::new(trailing_zero_sized_array_without_repr_c::TrailingZeroSizedArrayWithoutReprC));
     store.register_late_pass(|| Box::new(utils::author::Author));
     store.register_late_pass(|| Box::new(await_holding_invalid::AwaitHolding));
     store.register_late_pass(|| Box::new(serde_api::SerdeApi));
diff --git a/clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs b/clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs
index 507d9b40412..a96b8792295 100644
--- a/clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs
+++ b/clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs
@@ -1,7 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use rustc_hir::*;
 use rustc_lint::{EarlyContext, EarlyLintPass};
-use rustc_lint::{LateContext, LateLintPass};
+use rustc_lint_defs::Applicability;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
@@ -33,55 +32,42 @@ declare_clippy_lint! {
 }
 declare_lint_pass!(TrailingZeroSizedArrayWithoutReprC => [TRAILING_ZERO_SIZED_ARRAY_WITHOUT_REPR_C]);
 
-impl LateLintPass<'_> for TrailingZeroSizedArrayWithoutReprC {
-    fn check_struct_def(&mut self, cx: &LateContext<'tcx>, data: &'tcx rustc_hir::VariantData<'tcx>) {
-        dbg!("in check_struct_def");
-        if_chain! {
-            if let Some(def) = data.fields().last();
-            if let rustc_hir::TyKind::Array(ty, acost) = def.ty.kind;
-            then {
-                // is the AnonConst `0`
-            }
-        }
-
-        // span_lint_and_sugg(
-        //     cx,
-        //     todo!(),
-        //     todo!(),
-        //     todo!(),
-        //     todo!(),
-        //     todo!(),
-        //     rustc_errors::Applicability::MaybeIncorrect,
-        // )
-    }
-    // https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/sty/enum.TyKind.html#variant.Array in latepass
-    // or https://doc.rust-lang.org/nightly/nightly-rustc/rustc_ast/ast/enum.TyKind.html#variant.Array in early pass
-
-    // fn check_struct_def_post(&mut self, _: &LateContext<'tcx>, _: &'tcx rustc_hir::VariantData<'tcx>)
-    // {}
-
-    // fn check_field_def(&mut self, _: &LateContext<'tcx>, _: &'tcx rustc_hir::FieldDef<'tcx>) {}
-
-    // fn check_attribute(&mut self, _: &LateContext<'tcx>, _: &'tcx rustc_ast::Attribute) {}
-
-    // fn enter_lint_attrs(&mut self, _: &LateContext<'tcx>, _: &'tcx [rustc_ast::Attribute]) {}
-
-    // fn exit_lint_attrs(&mut self, _: &LateContext<'tcx>, _: &'tcx [rustc_ast::Attribute]) {}
-}
 //
 // TODO: Register the lint pass in `clippy_lints/src/lib.rs`,
-//       e.g. store.register_late_pass(||
+//       e.g. store.register_early_pass(||
 // Box::new(trailing_zero_sized_array_without_repr_c::TrailingZeroSizedArrayWithoutReprC));
 
-// fn temp_alert() {}
-
 impl EarlyLintPass for TrailingZeroSizedArrayWithoutReprC {
     fn check_struct_def(&mut self, cx: &EarlyContext<'_>, data: &rustc_ast::VariantData) {
-        if_chain! {
-            if let rustc_ast::ast::VariantData::Struct(field_defs, some_bool_huh) = data;
-            if let Some(last_field) = field_defs.last();
-            if let rustc_ast::ast::TyKind::Array(_, aconst) = &last_field.ty.kind;            
-            then {dbg!(aconst); return ();}
+        if is_struct_with_trailing_zero_sized_array(cx, data) && !has_repr_c(cx, data) {
+            span_lint_and_sugg(
+                cx,
+                todo!(),
+                todo!(),
+                todo!(),
+                "try",
+                "`#[repr(C)]`".to_string(),
+                Applicability::MachineApplicable,
+            )
+        }
+    }
+}
+
+fn is_struct_with_trailing_zero_sized_array(cx: &EarlyContext<'_>, data: &rustc_ast::VariantData) -> bool {
+    if_chain! {
+        if let rustc_ast::ast::VariantData::Struct(field_defs, some_bool_huh) = data;
+        if let Some(last_field) = field_defs.last();
+        if let rustc_ast::ast::TyKind::Array(_, aconst) = &last_field.ty.kind;
+        // TODO: if array is zero-sized;
+        then {
+            dbg!(aconst);
+            true
+        } else {
+            false
         }
     }
 }
+
+fn has_repr_c(cx: &EarlyContext<'_>, data: &rustc_ast::VariantData) -> bool {
+    todo!()
+}
-- 
cgit 1.4.1-3-g733a5


From 7ee8e7a9b846686148b8797ecc5ae724a6c5a1a9 Mon Sep 17 00:00:00 2001
From: Nathaniel Hamovitz <18648574+nhamovitz@users.noreply.github.com>
Date: Fri, 15 Oct 2021 16:16:27 -0700
Subject: Implement detecting trailing zero-sized array

---
 clippy_lints/src/lib.rs                            |  4 +-
 .../trailing_zero_sized_array_without_repr_c.rs    | 62 ++++++++++++++--------
 .../ui/trailing_zero_sized_array_without_repr_c.rs | 26 +++++++++
 3 files changed, 69 insertions(+), 23 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 6624ee93101..d494892c3b4 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -30,7 +30,6 @@ extern crate rustc_index;
 extern crate rustc_infer;
 extern crate rustc_lexer;
 extern crate rustc_lint;
-extern crate rustc_lint_defs;
 extern crate rustc_middle;
 extern crate rustc_mir_dataflow;
 extern crate rustc_parse;
@@ -488,7 +487,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         store.register_late_pass(|| Box::new(utils::internal_lints::OuterExpnDataPass));
     }
 
-    store.register_early_pass(||        Box::new(trailing_zero_sized_array_without_repr_c::TrailingZeroSizedArrayWithoutReprC));
     store.register_late_pass(|| Box::new(utils::author::Author));
     store.register_late_pass(|| Box::new(await_holding_invalid::AwaitHolding));
     store.register_late_pass(|| Box::new(serde_api::SerdeApi));
@@ -780,6 +778,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(move || Box::new(undocumented_unsafe_blocks::UndocumentedUnsafeBlocks::default()));
     store.register_late_pass(|| Box::new(match_str_case_mismatch::MatchStrCaseMismatch));
     store.register_late_pass(move || Box::new(format_args::FormatArgs));
+    store.register_late_pass(|| Box::new(trailing_zero_sized_array_without_repr_c::TrailingZeroSizedArrayWithoutReprC));
+
 }
 
 #[rustfmt::skip]
diff --git a/clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs b/clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs
index a96b8792295..6ca382d1679 100644
--- a/clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs
+++ b/clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs
@@ -1,6 +1,9 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use rustc_lint::{EarlyContext, EarlyLintPass};
-use rustc_lint_defs::Applicability;
+// use clippy_utils::is_integer_const;
+use clippy_utils::consts::{miri_to_const, Constant};
+use rustc_errors::Applicability;
+use rustc_hir::{Item, ItemKind, TyKind, VariantData};
+use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
@@ -36,38 +39,55 @@ declare_lint_pass!(TrailingZeroSizedArrayWithoutReprC => [TRAILING_ZERO_SIZED_AR
 // TODO: Register the lint pass in `clippy_lints/src/lib.rs`,
 //       e.g. store.register_early_pass(||
 // Box::new(trailing_zero_sized_array_without_repr_c::TrailingZeroSizedArrayWithoutReprC));
+// DONE!
 
-impl EarlyLintPass for TrailingZeroSizedArrayWithoutReprC {
-    fn check_struct_def(&mut self, cx: &EarlyContext<'_>, data: &rustc_ast::VariantData) {
-        if is_struct_with_trailing_zero_sized_array(cx, data) && !has_repr_c(cx, data) {
-            span_lint_and_sugg(
-                cx,
-                todo!(),
-                todo!(),
-                todo!(),
-                "try",
-                "`#[repr(C)]`".to_string(),
-                Applicability::MachineApplicable,
-            )
+impl<'tcx> LateLintPass<'tcx> for TrailingZeroSizedArrayWithoutReprC {
+    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
+        if is_struct_with_trailing_zero_sized_array(cx, item)
+        /* && !has_repr_c(cx, item) */
+        {
+            // span_lint_and_sugg(
+            //     cx,
+            //     todo!(),
+            //     todo!(),
+            //     todo!(),
+            //     "try",
+            //     "`#[repr(C)]`".to_string(),
+            //     Applicability::MachineApplicable,
+            // );
+            // println!("consider yourself linted 😎");
         }
     }
 }
 
-fn is_struct_with_trailing_zero_sized_array(cx: &EarlyContext<'_>, data: &rustc_ast::VariantData) -> bool {
+fn is_struct_with_trailing_zero_sized_array(cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) -> bool {
+    dbg!(item.ident);
     if_chain! {
-        if let rustc_ast::ast::VariantData::Struct(field_defs, some_bool_huh) = data;
+        if let ItemKind::Struct(data, _generics) = &item.kind;
+        if let VariantData::Struct(field_defs, _) = data;
         if let Some(last_field) = field_defs.last();
-        if let rustc_ast::ast::TyKind::Array(_, aconst) = &last_field.ty.kind;
-        // TODO: if array is zero-sized;
+        if let TyKind::Array(_, aconst) = last_field.ty.kind;
+        let aconst_def_id = cx.tcx.hir().body_owner_def_id(aconst.body).to_def_id();
+        let ty = cx.tcx.type_of(aconst_def_id);
+        let constant = cx
+            .tcx
+            .const_eval_poly(aconst_def_id) // NOTE: maybe const_eval_resolve? seems especially cursed to be using a const expr which resolves to 0 to create a zero-sized array, tho
+            .ok()
+            .map(|val| rustc_middle::ty::Const::from_value(cx.tcx, val, ty));
+        if let Some(Constant::Int(val)) = constant.and_then(miri_to_const);
+        if val == 0;
         then {
-            dbg!(aconst);
+            eprintln!("true");
             true
         } else {
+            // dbg!(aconst);
+            eprintln!("false");
             false
         }
     }
 }
 
-fn has_repr_c(cx: &EarlyContext<'_>, data: &rustc_ast::VariantData) -> bool {
-    todo!()
+fn has_repr_c(cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) -> bool {
+    // todo!()
+    true
 }
diff --git a/tests/ui/trailing_zero_sized_array_without_repr_c.rs b/tests/ui/trailing_zero_sized_array_without_repr_c.rs
index 771622178e7..5f844f16ba1 100644
--- a/tests/ui/trailing_zero_sized_array_without_repr_c.rs
+++ b/tests/ui/trailing_zero_sized_array_without_repr_c.rs
@@ -20,4 +20,30 @@ struct GenericArrayType<T> {
     last: [T; 0],
 }
 
+struct SizedArray {
+    field: i32,
+    last: [usize; 1],
+}
+
+const ZERO: usize = 0;
+struct ZeroSizedFromExternalConst {
+    field: i32,
+    last: [usize; ZERO],
+}
+
+const ONE: usize = 1;
+struct NonZeroSizedFromExternalConst {
+    field: i32,
+    last: [usize; ONE],
+}
+
+#[allow(clippy::eq_op)] // lmao im impressed
+const fn compute_zero() -> usize {
+    (4 + 6) - (2 * 5)
+}
+struct UsingFunction {
+    field: i32,
+    last: [usize; compute_zero()],
+}
+
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 523b0131618d8e4437a788eb1e3ddca743b3789f Mon Sep 17 00:00:00 2001
From: Nathaniel Hamovitz <18648574+nhamovitz@users.noreply.github.com>
Date: Fri, 15 Oct 2021 23:44:39 -0700
Subject: Implement getting an array of attributes!

---
 .../trailing_zero_sized_array_without_repr_c.rs    | 73 ++++++++++++++--------
 1 file changed, 46 insertions(+), 27 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs b/clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs
index 6ca382d1679..063dfb874cf 100644
--- a/clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs
+++ b/clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs
@@ -5,6 +5,7 @@ use rustc_errors::Applicability;
 use rustc_hir::{Item, ItemKind, TyKind, VariantData};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::sym;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -43,9 +44,8 @@ declare_lint_pass!(TrailingZeroSizedArrayWithoutReprC => [TRAILING_ZERO_SIZED_AR
 
 impl<'tcx> LateLintPass<'tcx> for TrailingZeroSizedArrayWithoutReprC {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
-        if is_struct_with_trailing_zero_sized_array(cx, item)
-        /* && !has_repr_c(cx, item) */
-        {
+        dbg!(item.ident);
+        if is_struct_with_trailing_zero_sized_array(cx, item) && !has_repr_c(cx, item) {
             // span_lint_and_sugg(
             //     cx,
             //     todo!(),
@@ -61,33 +61,52 @@ impl<'tcx> LateLintPass<'tcx> for TrailingZeroSizedArrayWithoutReprC {
 }
 
 fn is_struct_with_trailing_zero_sized_array(cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) -> bool {
-    dbg!(item.ident);
-    if_chain! {
-        if let ItemKind::Struct(data, _generics) = &item.kind;
-        if let VariantData::Struct(field_defs, _) = data;
-        if let Some(last_field) = field_defs.last();
-        if let TyKind::Array(_, aconst) = last_field.ty.kind;
-        let aconst_def_id = cx.tcx.hir().body_owner_def_id(aconst.body).to_def_id();
-        let ty = cx.tcx.type_of(aconst_def_id);
-        let constant = cx
-            .tcx
-            .const_eval_poly(aconst_def_id) // NOTE: maybe const_eval_resolve? seems especially cursed to be using a const expr which resolves to 0 to create a zero-sized array, tho
-            .ok()
-            .map(|val| rustc_middle::ty::Const::from_value(cx.tcx, val, ty));
-        if let Some(Constant::Int(val)) = constant.and_then(miri_to_const);
-        if val == 0;
-        then {
-            eprintln!("true");
-            true
-        } else {
-            // dbg!(aconst);
-            eprintln!("false");
-            false
+    if let ItemKind::Struct(data, _generics) = &item.kind {
+        if let VariantData::Struct(field_defs, _) = data {
+            if let Some(last_field) = field_defs.last() {
+                if let TyKind::Array(_, aconst) = last_field.ty.kind {
+                    let aconst_def_id = cx.tcx.hir().body_owner_def_id(aconst.body).to_def_id();
+                    let ty = cx.tcx.type_of(aconst_def_id);
+                    let constant = cx
+                        .tcx
+                        // NOTE: maybe const_eval_resolve? seems especially cursed to be using a const expr which
+                        // resolves to 0 to create a zero-sized array, tho
+                        .const_eval_poly(aconst_def_id)
+                        .ok()
+                        .map(|val| rustc_middle::ty::Const::from_value(cx.tcx, val, ty));
+                    if let Some(Constant::Int(val)) = constant.and_then(miri_to_const) {
+                        if val == 0 {
+                            eprintln!("trailing: true");
+                            return true;
+                        }
+                    }
+                }
+            }
         }
     }
+    // dbg!(aconst);
+    eprintln!("trailing: false");
+    false
 }
 
 fn has_repr_c(cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) -> bool {
-    // todo!()
-    true
+    // let hir_id2 = if let Some(body) = cx.enclosing_body {
+    //     body.hir_id
+    // } else {
+    //     todo!();
+    // };
+
+    let hir_id = cx.tcx.hir().local_def_id_to_hir_id(item.def_id);
+    let attrs = cx.tcx.hir().attrs(hir_id);
+    // NOTE: Can there ever be more than one `repr` attribute?
+    // other `repr` syms: repr, repr128, repr_align, repr_align_enum, repr_no_niche, repr_packed,
+    // repr_simd, repr_transparent
+
+    if let Some(repr_attr) = attrs.iter().find(|attr| attr.has_name(sym::repr)) {
+        eprintln!("repr: true");
+        true
+    } else {
+        eprintln!("repr: false");
+        false
+    }
 }
-- 
cgit 1.4.1-3-g733a5


From e53a4da4a142d3e90f8eb658a19466eca54901ea Mon Sep 17 00:00:00 2001
From: Nathaniel Hamovitz <18648574+nhamovitz@users.noreply.github.com>
Date: Sat, 16 Oct 2021 00:51:09 -0700
Subject: it works i think (incl some `dbg`s)

---
 .../trailing_zero_sized_array_without_repr_c.rs    | 53 ++++++++-------
 .../ui/trailing_zero_sized_array_without_repr_c.rs | 79 +++++++++++++++-------
 2 files changed, 82 insertions(+), 50 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs b/clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs
index 063dfb874cf..62f8ecdc216 100644
--- a/clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs
+++ b/clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs
@@ -2,7 +2,7 @@ use clippy_utils::diagnostics::span_lint_and_sugg;
 // use clippy_utils::is_integer_const;
 use clippy_utils::consts::{miri_to_const, Constant};
 use rustc_errors::Applicability;
-use rustc_hir::{Item, ItemKind, TyKind, VariantData};
+use rustc_hir::{HirId, Item, ItemKind, TyKind, VariantData};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::sym;
@@ -45,17 +45,29 @@ declare_lint_pass!(TrailingZeroSizedArrayWithoutReprC => [TRAILING_ZERO_SIZED_AR
 impl<'tcx> LateLintPass<'tcx> for TrailingZeroSizedArrayWithoutReprC {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
         dbg!(item.ident);
-        if is_struct_with_trailing_zero_sized_array(cx, item) && !has_repr_c(cx, item) {
-            // span_lint_and_sugg(
-            //     cx,
-            //     todo!(),
-            //     todo!(),
-            //     todo!(),
-            //     "try",
-            //     "`#[repr(C)]`".to_string(),
-            //     Applicability::MachineApplicable,
-            // );
-            // println!("consider yourself linted 😎");
+
+        let hir_id = cx.tcx.hir().local_def_id_to_hir_id(item.def_id);
+        let hir_id2 = item.hir_id();
+        dbg!(hir_id);
+        dbg!(hir_id2);
+        dbg!(hir_id == hir_id2);
+
+        let span1 = cx.tcx.hir().span(hir_id);
+        let span2 = item.span;
+        dbg!(span1);
+        dbg!(span2);
+        dbg!(span1 == span2);
+
+        if is_struct_with_trailing_zero_sized_array(cx, item) && !has_repr_c(cx, hir_id) {
+            span_lint_and_sugg(
+                cx,
+                TRAILING_ZERO_SIZED_ARRAY_WITHOUT_REPR_C,
+                span2,
+                "trailing zero-sized array in a struct which isn't marked `#[repr(C)]`",
+                "try",
+                "#[repr(C)]".to_string(),
+                Applicability::MaybeIncorrect,
+            );
         }
     }
 }
@@ -76,7 +88,7 @@ fn is_struct_with_trailing_zero_sized_array(cx: &LateContext<'tcx>, item: &'tcx
                         .map(|val| rustc_middle::ty::Const::from_value(cx.tcx, val, ty));
                     if let Some(Constant::Int(val)) = constant.and_then(miri_to_const) {
                         if val == 0 {
-                            eprintln!("trailing: true");
+                            // eprintln!("trailing: true");
                             return true;
                         }
                     }
@@ -85,28 +97,21 @@ fn is_struct_with_trailing_zero_sized_array(cx: &LateContext<'tcx>, item: &'tcx
         }
     }
     // dbg!(aconst);
-    eprintln!("trailing: false");
+    // eprintln!("trailing: false");
     false
 }
 
-fn has_repr_c(cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) -> bool {
-    // let hir_id2 = if let Some(body) = cx.enclosing_body {
-    //     body.hir_id
-    // } else {
-    //     todo!();
-    // };
-
-    let hir_id = cx.tcx.hir().local_def_id_to_hir_id(item.def_id);
+fn has_repr_c(cx: &LateContext<'tcx>, hir_id: HirId) -> bool {
     let attrs = cx.tcx.hir().attrs(hir_id);
     // NOTE: Can there ever be more than one `repr` attribute?
     // other `repr` syms: repr, repr128, repr_align, repr_align_enum, repr_no_niche, repr_packed,
     // repr_simd, repr_transparent
 
     if let Some(repr_attr) = attrs.iter().find(|attr| attr.has_name(sym::repr)) {
-        eprintln!("repr: true");
+        // eprintln!("repr: true");
         true
     } else {
-        eprintln!("repr: false");
+        // eprintln!("repr: false");
         false
     }
 }
diff --git a/tests/ui/trailing_zero_sized_array_without_repr_c.rs b/tests/ui/trailing_zero_sized_array_without_repr_c.rs
index 5f844f16ba1..1e3683b2c25 100644
--- a/tests/ui/trailing_zero_sized_array_without_repr_c.rs
+++ b/tests/ui/trailing_zero_sized_array_without_repr_c.rs
@@ -15,35 +15,62 @@ struct OnlyFieldIsZeroSizeArray {
     first_and_last: [usize; 0],
 }
 
-struct GenericArrayType<T> {
-    field: i32,
-    last: [T; 0],
-}
+// struct GenericArrayType<T> {
+//     field: i32,
+//     last: [T; 0],
+// }
 
-struct SizedArray {
-    field: i32,
-    last: [usize; 1],
-}
+// struct SizedArray {
+//     field: i32,
+//     last: [usize; 1],
+// }
 
-const ZERO: usize = 0;
-struct ZeroSizedFromExternalConst {
-    field: i32,
-    last: [usize; ZERO],
-}
+// const ZERO: usize = 0;
+// struct ZeroSizedFromExternalConst {
+//     field: i32,
+//     last: [usize; ZERO],
+// }
 
-const ONE: usize = 1;
-struct NonZeroSizedFromExternalConst {
-    field: i32,
-    last: [usize; ONE],
-}
+// const ONE: usize = 1;
+// struct NonZeroSizedFromExternalConst {
+//     field: i32,
+//     last: [usize; ONE],
+// }
 
-#[allow(clippy::eq_op)] // lmao im impressed
-const fn compute_zero() -> usize {
-    (4 + 6) - (2 * 5)
-}
-struct UsingFunction {
-    field: i32,
-    last: [usize; compute_zero()],
-}
+// #[allow(clippy::eq_op)] // lmao im impressed
+// const fn compute_zero() -> usize {
+//     (4 + 6) - (2 * 5)
+// }
+// struct UsingFunction {
+//     field: i32,
+//     last: [usize; compute_zero()],
+// }
+
+// // TODO: same
+// #[repr(packed)]
+// struct ReprPacked {
+//     small: u8,
+//     medium: i32,
+//     weird: [u64; 0],
+// }
+
+// // TODO: actually, uh,, 
+// #[repr(align(64))]
+// struct ReprAlign {
+//     field: i32,
+//     last: [usize; 0],
+// }
+// #[repr(C, align(64))]
+// struct ReprCAlign {
+//     field: i32,
+//     last: [usize; 0],
+// }
+
+// #[repr(C)]
+// enum DontLintAnonymousStructsFromDesuraging {
+//     A(u32),
+//     B(f32, [u64; 0]),
+//     C { x: u32, y: [u64; 0] },
+// }
 
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 4b4db597722ff561515812e2e0cab255a678a41c Mon Sep 17 00:00:00 2001
From: Nathaniel Hamovitz <18648574+nhamovitz@users.noreply.github.com>
Date: Sat, 16 Oct 2021 02:01:17 -0700
Subject: output looks fantastic

---
 .../trailing_zero_sized_array_without_repr_c.rs    |  34 ++----
 .../ui/trailing_zero_sized_array_without_repr_c.rs | 131 +++++++++++++--------
 2 files changed, 96 insertions(+), 69 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs b/clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs
index 62f8ecdc216..7eeb2914c40 100644
--- a/clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs
+++ b/clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs
@@ -1,8 +1,9 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
-// use clippy_utils::is_integer_const;
 use clippy_utils::consts::{miri_to_const, Constant};
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet;
 use rustc_errors::Applicability;
-use rustc_hir::{HirId, Item, ItemKind, TyKind, VariantData};
+use rustc_hir::def_id::LocalDefId;
+use rustc_hir::{Item, ItemKind, TyKind, VariantData};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::sym;
@@ -46,26 +47,14 @@ impl<'tcx> LateLintPass<'tcx> for TrailingZeroSizedArrayWithoutReprC {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
         dbg!(item.ident);
 
-        let hir_id = cx.tcx.hir().local_def_id_to_hir_id(item.def_id);
-        let hir_id2 = item.hir_id();
-        dbg!(hir_id);
-        dbg!(hir_id2);
-        dbg!(hir_id == hir_id2);
-
-        let span1 = cx.tcx.hir().span(hir_id);
-        let span2 = item.span;
-        dbg!(span1);
-        dbg!(span2);
-        dbg!(span1 == span2);
-
-        if is_struct_with_trailing_zero_sized_array(cx, item) && !has_repr_c(cx, hir_id) {
+        if is_struct_with_trailing_zero_sized_array(cx, item) && !has_repr_c(cx, item.def_id) {
             span_lint_and_sugg(
                 cx,
                 TRAILING_ZERO_SIZED_ARRAY_WITHOUT_REPR_C,
-                span2,
-                "trailing zero-sized array in a struct which isn't marked `#[repr(C)]`",
+                item.span,
+                "trailing zero-sized array in a struct which is not marked `#[repr(C)]`",
                 "try",
-                "#[repr(C)]".to_string(),
+                format!("#[repr(C)]\n{}", snippet(cx, item.span, "..")),
                 Applicability::MaybeIncorrect,
             );
         }
@@ -101,13 +90,14 @@ fn is_struct_with_trailing_zero_sized_array(cx: &LateContext<'tcx>, item: &'tcx
     false
 }
 
-fn has_repr_c(cx: &LateContext<'tcx>, hir_id: HirId) -> bool {
+fn has_repr_c(cx: &LateContext<'tcx>, def_id: LocalDefId) -> bool {
+    let hir_id = cx.tcx.hir().local_def_id_to_hir_id(def_id);
     let attrs = cx.tcx.hir().attrs(hir_id);
+
     // NOTE: Can there ever be more than one `repr` attribute?
     // other `repr` syms: repr, repr128, repr_align, repr_align_enum, repr_no_niche, repr_packed,
     // repr_simd, repr_transparent
-
-    if let Some(repr_attr) = attrs.iter().find(|attr| attr.has_name(sym::repr)) {
+    if let Some(_repr_attr) = attrs.iter().find(|attr| attr.has_name(sym::repr)) {
         // eprintln!("repr: true");
         true
     } else {
diff --git a/tests/ui/trailing_zero_sized_array_without_repr_c.rs b/tests/ui/trailing_zero_sized_array_without_repr_c.rs
index 1e3683b2c25..311193fb4a1 100644
--- a/tests/ui/trailing_zero_sized_array_without_repr_c.rs
+++ b/tests/ui/trailing_zero_sized_array_without_repr_c.rs
@@ -1,5 +1,7 @@
 #![warn(clippy::trailing_zero_sized_array_without_repr_c)]
 
+// #![feature(const_generics_defaults)]
+
 struct RarelyUseful {
     field: i32,
     last: [usize; 0],
@@ -15,62 +17,97 @@ struct OnlyFieldIsZeroSizeArray {
     first_and_last: [usize; 0],
 }
 
-// struct GenericArrayType<T> {
-//     field: i32,
-//     last: [T; 0],
-// }
+struct GenericArrayType<T> {
+    field: i32,
+    last: [T; 0],
+}
 
-// struct SizedArray {
-//     field: i32,
-//     last: [usize; 1],
-// }
+struct SizedArray {
+    field: i32,
+    last: [usize; 1],
+}
 
-// const ZERO: usize = 0;
-// struct ZeroSizedFromExternalConst {
-//     field: i32,
-//     last: [usize; ZERO],
-// }
+const ZERO: usize = 0;
+struct ZeroSizedFromExternalConst {
+    field: i32,
+    last: [usize; ZERO],
+}
+
+const ONE: usize = 1;
+struct NonZeroSizedFromExternalConst {
+    field: i32,
+    last: [usize; ONE],
+}
 
-// const ONE: usize = 1;
-// struct NonZeroSizedFromExternalConst {
+#[allow(clippy::eq_op)] // lmao im impressed
+const fn compute_zero() -> usize {
+    (4 + 6) - (2 * 5)
+}
+struct UsingFunction {
+    field: i32,
+    last: [usize; compute_zero()],
+}
+
+// #[repr(C)]
+// struct ConstParamOk<const N: usize = 0> {
 //     field: i32,
-//     last: [usize; ONE],
+//     last: [usize; N]
 // }
 
-// #[allow(clippy::eq_op)] // lmao im impressed
-// const fn compute_zero() -> usize {
-//     (4 + 6) - (2 * 5)
-// }
-// struct UsingFunction {
+// struct ConstParamLint<const N: usize = 0> {
 //     field: i32,
-//     last: [usize; compute_zero()],
+//     last: [usize; N]
 // }
 
-// // TODO: same
-// #[repr(packed)]
-// struct ReprPacked {
-//     small: u8,
-//     medium: i32,
-//     weird: [u64; 0],
-// }
 
-// // TODO: actually, uh,, 
-// #[repr(align(64))]
-// struct ReprAlign {
-//     field: i32,
-//     last: [usize; 0],
-// }
-// #[repr(C, align(64))]
-// struct ReprCAlign {
-//     field: i32,
-//     last: [usize; 0],
-// }
+// TODO: actually, uh,,
+#[repr(packed)]
+struct ReprPacked {
+    small: u8,
+    medium: i32,
+    weird: [u64; 0],
+}
 
-// #[repr(C)]
-// enum DontLintAnonymousStructsFromDesuraging {
-//     A(u32),
-//     B(f32, [u64; 0]),
-//     C { x: u32, y: [u64; 0] },
-// }
+// same
+#[repr(align(64))]
+struct ReprAlign {
+    field: i32,
+    last: [usize; 0],
+}
 
-fn main() {}
+// same
+#[repr(C, align(64))]
+struct ReprCAlign {
+    field: i32,
+    last: [usize; 0],
+}
+
+#[repr(C)]
+enum DontLintAnonymousStructsFromDesuraging {
+    A(u32),
+    B(f32, [u64; 0]),
+    C { x: u32, y: [u64; 0] },
+}
+
+struct LotsOfFields {
+    f1: u32,
+    f2: u32,
+    f3: u32,
+    f4: u32,
+    f5: u32,
+    f6: u32,
+    f7: u32,
+    f8: u32,
+    f9: u32,
+    f10: u32,
+    f11: u32,
+    f12: u32,
+    f13: u32,
+    f14: u32,
+    f15: u32,
+    f16: u32,
+    last: [usize; 0],
+}
+
+fn main() {
+}
-- 
cgit 1.4.1-3-g733a5


From b9948c4be6741ae916b838df29e9777467d4c84c Mon Sep 17 00:00:00 2001
From: Nathaniel Hamovitz <18648574+nhamovitz@users.noreply.github.com>
Date: Sat, 16 Oct 2021 02:26:08 -0700
Subject: Ran `dev bless`!

---
 .../trailing_zero_sized_array_without_repr_c.rs    |  58 +++++------
 .../ui/trailing_zero_sized_array_without_repr_c.rs |  17 ++--
 ...trailing_zero_sized_array_without_repr_c.stderr | 113 +++++++++++++++++++++
 3 files changed, 147 insertions(+), 41 deletions(-)
 create mode 100644 tests/ui/trailing_zero_sized_array_without_repr_c.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs b/clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs
index 7eeb2914c40..7f579835512 100644
--- a/clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs
+++ b/clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs
@@ -26,7 +26,7 @@ declare_clippy_lint! {
     /// Use instead:
     /// ```rust
     /// #[repr(C)]
-    /// struct MakesSense {
+    /// struct MoreOftenUseful {
     ///     some_field: usize,
     ///     last: [SomeType; 0],
     /// }
@@ -45,15 +45,13 @@ declare_lint_pass!(TrailingZeroSizedArrayWithoutReprC => [TRAILING_ZERO_SIZED_AR
 
 impl<'tcx> LateLintPass<'tcx> for TrailingZeroSizedArrayWithoutReprC {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
-        dbg!(item.ident);
-
         if is_struct_with_trailing_zero_sized_array(cx, item) && !has_repr_c(cx, item.def_id) {
             span_lint_and_sugg(
                 cx,
                 TRAILING_ZERO_SIZED_ARRAY_WITHOUT_REPR_C,
                 item.span,
                 "trailing zero-sized array in a struct which is not marked `#[repr(C)]`",
-                "try",
+                "try annotating the struct definition with `#[repr(C)]` (or another `repr` attribute):",
                 format!("#[repr(C)]\n{}", snippet(cx, item.span, "..")),
                 Applicability::MaybeIncorrect,
             );
@@ -62,46 +60,40 @@ impl<'tcx> LateLintPass<'tcx> for TrailingZeroSizedArrayWithoutReprC {
 }
 
 fn is_struct_with_trailing_zero_sized_array(cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) -> bool {
-    if let ItemKind::Struct(data, _generics) = &item.kind {
-        if let VariantData::Struct(field_defs, _) = data {
-            if let Some(last_field) = field_defs.last() {
-                if let TyKind::Array(_, aconst) = last_field.ty.kind {
-                    let aconst_def_id = cx.tcx.hir().body_owner_def_id(aconst.body).to_def_id();
-                    let ty = cx.tcx.type_of(aconst_def_id);
-                    let constant = cx
-                        .tcx
-                        // NOTE: maybe const_eval_resolve? seems especially cursed to be using a const expr which
-                        // resolves to 0 to create a zero-sized array, tho
-                        .const_eval_poly(aconst_def_id)
-                        .ok()
-                        .map(|val| rustc_middle::ty::Const::from_value(cx.tcx, val, ty));
-                    if let Some(Constant::Int(val)) = constant.and_then(miri_to_const) {
-                        if val == 0 {
-                            // eprintln!("trailing: true");
-                            return true;
-                        }
-                    }
-                }
-            }
+    if_chain! {
+        if let ItemKind::Struct(data, _generics) = &item.kind;
+        if let VariantData::Struct(field_defs, _) = data;
+        if let Some(last_field) = field_defs.last();
+        if let TyKind::Array(_, aconst) = last_field.ty.kind;
+        let aconst_def_id = cx.tcx.hir().body_owner_def_id(aconst.body).to_def_id();
+        let ty = cx.tcx.type_of(aconst_def_id);
+        let constant = cx
+            .tcx
+            // NOTE: maybe const_eval_resolve?
+            .const_eval_poly(aconst_def_id)
+            .ok()
+            .map(|val| rustc_middle::ty::Const::from_value(cx.tcx, val, ty));
+        if let Some(Constant::Int(val)) = constant.and_then(miri_to_const);
+        if val == 0;
+        then {
+            true
+        } else {
+            false
         }
     }
-    // dbg!(aconst);
-    // eprintln!("trailing: false");
-    false
 }
 
 fn has_repr_c(cx: &LateContext<'tcx>, def_id: LocalDefId) -> bool {
-    let hir_id = cx.tcx.hir().local_def_id_to_hir_id(def_id);
-    let attrs = cx.tcx.hir().attrs(hir_id);
+    let hir_map = cx.tcx.hir();
+    let hir_id = hir_map.local_def_id_to_hir_id(def_id);
+    let attrs = hir_map.attrs(hir_id);
 
     // NOTE: Can there ever be more than one `repr` attribute?
     // other `repr` syms: repr, repr128, repr_align, repr_align_enum, repr_no_niche, repr_packed,
     // repr_simd, repr_transparent
-    if let Some(_repr_attr) = attrs.iter().find(|attr| attr.has_name(sym::repr)) {
-        // eprintln!("repr: true");
+    if let Some(_attr) = attrs.iter().find(|attr| attr.has_name(sym::repr)) {
         true
     } else {
-        // eprintln!("repr: false");
         false
     }
 }
diff --git a/tests/ui/trailing_zero_sized_array_without_repr_c.rs b/tests/ui/trailing_zero_sized_array_without_repr_c.rs
index 311193fb4a1..62fe94d7abf 100644
--- a/tests/ui/trailing_zero_sized_array_without_repr_c.rs
+++ b/tests/ui/trailing_zero_sized_array_without_repr_c.rs
@@ -1,6 +1,5 @@
 #![warn(clippy::trailing_zero_sized_array_without_repr_c)]
-
-// #![feature(const_generics_defaults)]
+// #![feature(const_generics_defaults)] // see below
 
 struct RarelyUseful {
     field: i32,
@@ -48,6 +47,9 @@ struct UsingFunction {
     last: [usize; compute_zero()],
 }
 
+// NOTE: including these (along with the required feature) triggers an ICE. Should make sure the
+// const generics people are aware of that if they weren't already.
+
 // #[repr(C)]
 // struct ConstParamOk<const N: usize = 0> {
 //     field: i32,
@@ -59,8 +61,7 @@ struct UsingFunction {
 //     last: [usize; N]
 // }
 
-
-// TODO: actually, uh,,
+// TODO: actually, uh,, no idea what behavior here would be
 #[repr(packed)]
 struct ReprPacked {
     small: u8,
@@ -68,20 +69,21 @@ struct ReprPacked {
     weird: [u64; 0],
 }
 
-// same
+// TODO: clarify expected behavior
 #[repr(align(64))]
 struct ReprAlign {
     field: i32,
     last: [usize; 0],
 }
 
-// same
+// TODO: clarify expected behavior
 #[repr(C, align(64))]
 struct ReprCAlign {
     field: i32,
     last: [usize; 0],
 }
 
+// NOTE: because of https://doc.rust-lang.org/stable/reference/type-layout.html#primitive-representation-of-enums-with-fields and I'm not sure when in the compilation pipeline that would happen
 #[repr(C)]
 enum DontLintAnonymousStructsFromDesuraging {
     A(u32),
@@ -109,5 +111,4 @@ struct LotsOfFields {
     last: [usize; 0],
 }
 
-fn main() {
-}
+fn main() {}
diff --git a/tests/ui/trailing_zero_sized_array_without_repr_c.stderr b/tests/ui/trailing_zero_sized_array_without_repr_c.stderr
new file mode 100644
index 00000000000..84606ed6185
--- /dev/null
+++ b/tests/ui/trailing_zero_sized_array_without_repr_c.stderr
@@ -0,0 +1,113 @@
+error: trailing zero-sized array in a struct which is not marked `#[repr(C)]`
+  --> $DIR/trailing_zero_sized_array_without_repr_c.rs:4:1
+   |
+LL | / struct RarelyUseful {
+LL | |     field: i32,
+LL | |     last: [usize; 0],
+LL | | }
+   | |_^
+   |
+   = note: `-D clippy::trailing-zero-sized-array-without-repr-c` implied by `-D warnings`
+help: try annotating the struct definition with `#[repr(C)]` (or another `repr` attribute):
+   |
+LL + #[repr(C)]
+LL + struct RarelyUseful {
+LL +     field: i32,
+LL +     last: [usize; 0],
+LL + }
+   |
+
+error: trailing zero-sized array in a struct which is not marked `#[repr(C)]`
+  --> $DIR/trailing_zero_sized_array_without_repr_c.rs:15:1
+   |
+LL | / struct OnlyFieldIsZeroSizeArray {
+LL | |     first_and_last: [usize; 0],
+LL | | }
+   | |_^
+   |
+help: try annotating the struct definition with `#[repr(C)]` (or another `repr` attribute):
+   |
+LL + #[repr(C)]
+LL + struct OnlyFieldIsZeroSizeArray {
+LL +     first_and_last: [usize; 0],
+LL + }
+   |
+
+error: trailing zero-sized array in a struct which is not marked `#[repr(C)]`
+  --> $DIR/trailing_zero_sized_array_without_repr_c.rs:19:1
+   |
+LL | / struct GenericArrayType<T> {
+LL | |     field: i32,
+LL | |     last: [T; 0],
+LL | | }
+   | |_^
+   |
+help: try annotating the struct definition with `#[repr(C)]` (or another `repr` attribute):
+   |
+LL + #[repr(C)]
+LL + struct GenericArrayType<T> {
+LL +     field: i32,
+LL +     last: [T; 0],
+LL + }
+   |
+
+error: trailing zero-sized array in a struct which is not marked `#[repr(C)]`
+  --> $DIR/trailing_zero_sized_array_without_repr_c.rs:30:1
+   |
+LL | / struct ZeroSizedFromExternalConst {
+LL | |     field: i32,
+LL | |     last: [usize; ZERO],
+LL | | }
+   | |_^
+   |
+help: try annotating the struct definition with `#[repr(C)]` (or another `repr` attribute):
+   |
+LL + #[repr(C)]
+LL + struct ZeroSizedFromExternalConst {
+LL +     field: i32,
+LL +     last: [usize; ZERO],
+LL + }
+   |
+
+error: trailing zero-sized array in a struct which is not marked `#[repr(C)]`
+  --> $DIR/trailing_zero_sized_array_without_repr_c.rs:45:1
+   |
+LL | / struct UsingFunction {
+LL | |     field: i32,
+LL | |     last: [usize; compute_zero()],
+LL | | }
+   | |_^
+   |
+help: try annotating the struct definition with `#[repr(C)]` (or another `repr` attribute):
+   |
+LL + #[repr(C)]
+LL + struct UsingFunction {
+LL +     field: i32,
+LL +     last: [usize; compute_zero()],
+LL + }
+   |
+
+error: trailing zero-sized array in a struct which is not marked `#[repr(C)]`
+  --> $DIR/trailing_zero_sized_array_without_repr_c.rs:94:1
+   |
+LL | / struct LotsOfFields {
+LL | |     f1: u32,
+LL | |     f2: u32,
+LL | |     f3: u32,
+...  |
+LL | |     last: [usize; 0],
+LL | | }
+   | |_^
+   |
+help: try annotating the struct definition with `#[repr(C)]` (or another `repr` attribute):
+   |
+LL + #[repr(C)]
+LL + struct LotsOfFields {
+LL +     f1: u32,
+LL +     f2: u32,
+LL +     f3: u32,
+LL +     f4: u32,
+ ...
+
+error: aborting due to 6 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 003972f4281ab83fb56ce9a898efd93b6ca3740e Mon Sep 17 00:00:00 2001
From: Nathaniel Hamovitz <18648574+nhamovitz@users.noreply.github.com>
Date: Sat, 16 Oct 2021 15:26:10 -0700
Subject: add multiple `get_attrs` and `includes_repr` and they all work!

---
 clippy_lints/src/lib.rs                            |   1 +
 .../trailing_zero_sized_array_without_repr_c.rs    |  66 ++++++++---
 .../ui/trailing_zero_sized_array_without_repr_c.rs | 125 ++++++++++++---------
 3 files changed, 123 insertions(+), 69 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index d494892c3b4..72636146d7c 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -21,6 +21,7 @@
 // (Currently there is no way to opt into sysroot crates without `extern crate`.)
 extern crate rustc_ast;
 extern crate rustc_ast_pretty;
+extern crate rustc_attr;
 extern crate rustc_data_structures;
 extern crate rustc_driver;
 extern crate rustc_errors;
diff --git a/clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs b/clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs
index 7f579835512..4c3c5191d28 100644
--- a/clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs
+++ b/clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs
@@ -1,10 +1,14 @@
 use clippy_utils::consts::{miri_to_const, Constant};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet;
+use rustc_ast::Attribute;
 use rustc_errors::Applicability;
 use rustc_hir::def_id::LocalDefId;
-use rustc_hir::{Item, ItemKind, TyKind, VariantData};
+use rustc_hir::{Item, ItemKind, VariantData};
 use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::dep_graph::DepContext;
+use rustc_middle::ty as ty_mod;
+use rustc_middle::ty::ReprFlags;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::sym;
 
@@ -33,19 +37,16 @@ declare_clippy_lint! {
     /// ```
     pub TRAILING_ZERO_SIZED_ARRAY_WITHOUT_REPR_C,
     nursery,
-    "struct with a trailing zero-sized array but without `repr(C)`"
+    "struct with a trailing zero-sized array but without `repr(C)` or another `repr` attribute"
 }
 declare_lint_pass!(TrailingZeroSizedArrayWithoutReprC => [TRAILING_ZERO_SIZED_ARRAY_WITHOUT_REPR_C]);
 
-//
-// TODO: Register the lint pass in `clippy_lints/src/lib.rs`,
-//       e.g. store.register_early_pass(||
-// Box::new(trailing_zero_sized_array_without_repr_c::TrailingZeroSizedArrayWithoutReprC));
-// DONE!
+// TESTNAME=trailing_zero_sized_array_without_repr_c cargo uitest
 
 impl<'tcx> LateLintPass<'tcx> for TrailingZeroSizedArrayWithoutReprC {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
-        if is_struct_with_trailing_zero_sized_array(cx, item) && !has_repr_c(cx, item.def_id) {
+        dbg!(item.ident);
+        if is_struct_with_trailing_zero_sized_array(cx, item) && !has_repr_attr(cx, item.def_id) {
             span_lint_and_sugg(
                 cx,
                 TRAILING_ZERO_SIZED_ARRAY_WITHOUT_REPR_C,
@@ -64,7 +65,7 @@ fn is_struct_with_trailing_zero_sized_array(cx: &LateContext<'tcx>, item: &'tcx
         if let ItemKind::Struct(data, _generics) = &item.kind;
         if let VariantData::Struct(field_defs, _) = data;
         if let Some(last_field) = field_defs.last();
-        if let TyKind::Array(_, aconst) = last_field.ty.kind;
+        if let rustc_hir::TyKind::Array(_, aconst) = last_field.ty.kind;
         let aconst_def_id = cx.tcx.hir().body_owner_def_id(aconst.body).to_def_id();
         let ty = cx.tcx.type_of(aconst_def_id);
         let constant = cx
@@ -83,17 +84,50 @@ fn is_struct_with_trailing_zero_sized_array(cx: &LateContext<'tcx>, item: &'tcx
     }
 }
 
-fn has_repr_c(cx: &LateContext<'tcx>, def_id: LocalDefId) -> bool {
+fn has_repr_attr(cx: &LateContext<'tcx>, def_id: LocalDefId) -> bool {
+    let attrs_get_attrs = get_attrs_get_attrs(cx, def_id);
+    let attrs_hir_map = get_attrs_hir_map(cx, def_id);
+    let b11 = dbg!(includes_repr_attr_using_sym(attrs_get_attrs));
+    let b12 = dbg!(includes_repr_attr_using_sym(attrs_hir_map));
+    let b21 = dbg!(includes_repr_attr_using_helper(cx, attrs_get_attrs));
+    let b22 = dbg!(includes_repr_attr_using_helper(cx, attrs_hir_map));
+    let b3 = dbg!(has_repr_attr_using_adt(cx, def_id));
+    let all_same = b11 && b12 && b21 && b22 && b3;
+    dbg!(all_same);
+
+    b11
+}
+
+fn get_attrs_get_attrs(cx: &LateContext<'tcx>, def_id: LocalDefId) -> &'tcx [Attribute] {
+    cx.tcx.get_attrs(def_id.to_def_id())
+}
+
+fn get_attrs_hir_map(cx: &LateContext<'tcx>, def_id: LocalDefId) -> &'tcx [Attribute] {
     let hir_map = cx.tcx.hir();
     let hir_id = hir_map.local_def_id_to_hir_id(def_id);
-    let attrs = hir_map.attrs(hir_id);
+    hir_map.attrs(hir_id)
+}
 
-    // NOTE: Can there ever be more than one `repr` attribute?
-    // other `repr` syms: repr, repr128, repr_align, repr_align_enum, repr_no_niche, repr_packed,
-    // repr_simd, repr_transparent
-    if let Some(_attr) = attrs.iter().find(|attr| attr.has_name(sym::repr)) {
-        true
+// Don't like this because it's so dependent on the current list of `repr` flags and it would have to be manually updated if that ever expanded. idk if there's any mechanism in `bitflag!` or elsewhere for requiring that sort of exhaustiveness
+fn has_repr_attr_using_adt(cx: &LateContext<'tcx>, def_id: LocalDefId) -> bool {
+    let ty = cx.tcx.type_of(def_id.to_def_id());
+    if let ty_mod::Adt(adt, _) = ty.kind() {
+        if adt.is_struct() {
+            let repr = adt.repr;
+            let repr_attr = ReprFlags::IS_C | ReprFlags::IS_TRANSPARENT | ReprFlags::IS_SIMD | ReprFlags::IS_LINEAR;
+            repr.int.is_some() || repr.align.is_some() || repr.pack.is_some() || repr.flags.intersects(repr_attr)
+        } else {
+            false
+        }
     } else {
         false
     }
 }
+
+fn includes_repr_attr_using_sym(attrs: &'tcx [Attribute]) -> bool {
+    attrs.iter().any(|attr| attr.has_name(sym::repr))
+}
+
+fn includes_repr_attr_using_helper(cx: &LateContext<'tcx>, attrs: &'tcx [Attribute]) -> bool {
+    attrs.iter().any(|attr| !rustc_attr::find_repr_attrs(cx.tcx.sess(), attr).is_empty())
+}
diff --git a/tests/ui/trailing_zero_sized_array_without_repr_c.rs b/tests/ui/trailing_zero_sized_array_without_repr_c.rs
index 62fe94d7abf..8e8c84fe9c5 100644
--- a/tests/ui/trailing_zero_sized_array_without_repr_c.rs
+++ b/tests/ui/trailing_zero_sized_array_without_repr_c.rs
@@ -1,13 +1,9 @@
 #![warn(clippy::trailing_zero_sized_array_without_repr_c)]
 // #![feature(const_generics_defaults)] // see below
 
-struct RarelyUseful {
-    field: i32,
-    last: [usize; 0],
-}
+// Do lint:
 
-#[repr(C)]
-struct GoodReason {
+struct RarelyUseful {
     field: i32,
     last: [usize; 0],
 }
@@ -21,24 +17,25 @@ struct GenericArrayType<T> {
     last: [T; 0],
 }
 
-struct SizedArray {
+#[derive(Debug)]
+struct PlayNiceWithOtherAttributesDerive {
     field: i32,
-    last: [usize; 1],
+    last: [usize; 0]
 }
 
-const ZERO: usize = 0;
-struct ZeroSizedFromExternalConst {
+#[must_use]
+struct PlayNiceWithOtherAttributesMustUse {
     field: i32,
-    last: [usize; ZERO],
+    last: [usize; 0]
 }
 
-const ONE: usize = 1;
-struct NonZeroSizedFromExternalConst {
+const ZERO: usize = 0;
+struct ZeroSizedFromExternalConst {
     field: i32,
-    last: [usize; ONE],
+    last: [usize; ZERO],
 }
 
-#[allow(clippy::eq_op)] // lmao im impressed
+#[allow(clippy::eq_op)]
 const fn compute_zero() -> usize {
     (4 + 6) - (2 * 5)
 }
@@ -47,36 +44,62 @@ struct UsingFunction {
     last: [usize; compute_zero()],
 }
 
-// NOTE: including these (along with the required feature) triggers an ICE. Should make sure the
-// const generics people are aware of that if they weren't already.
+struct LotsOfFields {
+    f1: u32,
+    f2: u32,
+    f3: u32,
+    f4: u32,
+    f5: u32,
+    f6: u32,
+    f7: u32,
+    f8: u32,
+    f9: u32,
+    f10: u32,
+    f11: u32,
+    f12: u32,
+    f13: u32,
+    f14: u32,
+    f15: u32,
+    f16: u32,
+    last: [usize; 0],
+}
 
-// #[repr(C)]
-// struct ConstParamOk<const N: usize = 0> {
-//     field: i32,
-//     last: [usize; N]
-// }
+// Don't lint
 
-// struct ConstParamLint<const N: usize = 0> {
-//     field: i32,
-//     last: [usize; N]
-// }
+#[repr(C)]
+struct GoodReason {
+    field: i32,
+    last: [usize; 0],
+}
+
+struct SizedArray {
+    field: i32,
+    last: [usize; 1],
+}
+
+const ONE: usize = 1;
+struct NonZeroSizedFromExternalConst {
+    field: i32,
+    last: [usize; ONE],
+}
 
-// TODO: actually, uh,, no idea what behavior here would be
 #[repr(packed)]
 struct ReprPacked {
-    small: u8,
-    medium: i32,
-    weird: [u64; 0],
+    field: i32,
+    last: [usize; 0],
+}
+
+#[repr(C, packed)]
+struct ReprCPacked {
+    field: i32,
+    last: [usize; 0],
 }
 
-// TODO: clarify expected behavior
 #[repr(align(64))]
 struct ReprAlign {
     field: i32,
     last: [usize; 0],
 }
-
-// TODO: clarify expected behavior
 #[repr(C, align(64))]
 struct ReprCAlign {
     field: i32,
@@ -91,24 +114,20 @@ enum DontLintAnonymousStructsFromDesuraging {
     C { x: u32, y: [u64; 0] },
 }
 
-struct LotsOfFields {
-    f1: u32,
-    f2: u32,
-    f3: u32,
-    f4: u32,
-    f5: u32,
-    f6: u32,
-    f7: u32,
-    f8: u32,
-    f9: u32,
-    f10: u32,
-    f11: u32,
-    f12: u32,
-    f13: u32,
-    f14: u32,
-    f15: u32,
-    f16: u32,
-    last: [usize; 0],
-}
+// NOTE: including these (along with the required feature) triggers an ICE. Should make sure the
+// const generics people are aware of that if they weren't already.
+
+// #[repr(C)]
+// struct ConstParamOk<const N: usize = 0> {
+//     field: i32,
+//     last: [usize; N]
+// }
 
-fn main() {}
+// struct ConstParamLint<const N: usize = 0> {
+//     field: i32,
+//     last: [usize; N]
+// }
+
+fn main() {
+    let _ = PlayNiceWithOtherAttributesMustUse {field: 0, last: []};
+}
-- 
cgit 1.4.1-3-g733a5


From 5fdf93415bfd59a7cd61ebec20f0a4e4fec78164 Mon Sep 17 00:00:00 2001
From: Nathaniel Hamovitz <18648574+nhamovitz@users.noreply.github.com>
Date: Sat, 16 Oct 2021 16:13:14 -0700
Subject: intermediate step

---
 .../trailing_zero_sized_array_without_repr_c.rs    | 45 ++++++++++++----------
 .../ui/trailing_zero_sized_array_without_repr_c.rs | 14 +++----
 2 files changed, 31 insertions(+), 28 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs b/clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs
index 4c3c5191d28..a9c6e24918e 100644
--- a/clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs
+++ b/clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs
@@ -1,8 +1,6 @@
 use clippy_utils::consts::{miri_to_const, Constant};
-use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::source::snippet;
+use clippy_utils::diagnostics::span_lint_and_help;
 use rustc_ast::Attribute;
-use rustc_errors::Applicability;
 use rustc_hir::def_id::LocalDefId;
 use rustc_hir::{Item, ItemKind, VariantData};
 use rustc_lint::{LateContext, LateLintPass};
@@ -47,15 +45,15 @@ impl<'tcx> LateLintPass<'tcx> for TrailingZeroSizedArrayWithoutReprC {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
         dbg!(item.ident);
         if is_struct_with_trailing_zero_sized_array(cx, item) && !has_repr_attr(cx, item.def_id) {
-            span_lint_and_sugg(
-                cx,
-                TRAILING_ZERO_SIZED_ARRAY_WITHOUT_REPR_C,
-                item.span,
-                "trailing zero-sized array in a struct which is not marked `#[repr(C)]`",
-                "try annotating the struct definition with `#[repr(C)]` (or another `repr` attribute):",
-                format!("#[repr(C)]\n{}", snippet(cx, item.span, "..")),
-                Applicability::MaybeIncorrect,
-            );
+            // span_lint_and_help(
+            //     cx,
+            //     TRAILING_ZERO_SIZED_ARRAY_WITHOUT_REPR_C,
+            //     item.span,
+            //     "trailing zero-sized array in a struct which is not marked `#[repr(C)]`",
+            //     None,
+            //     "consider annotating the struct definition with `#[repr(C)]` (or another `repr` attribute)",
+            // );
+            eprintln!("— consider yourself linted — 🦀")
         }
     }
 }
@@ -87,15 +85,16 @@ fn is_struct_with_trailing_zero_sized_array(cx: &LateContext<'tcx>, item: &'tcx
 fn has_repr_attr(cx: &LateContext<'tcx>, def_id: LocalDefId) -> bool {
     let attrs_get_attrs = get_attrs_get_attrs(cx, def_id);
     let attrs_hir_map = get_attrs_hir_map(cx, def_id);
-    let b11 = dbg!(includes_repr_attr_using_sym(attrs_get_attrs));
-    let b12 = dbg!(includes_repr_attr_using_sym(attrs_hir_map));
-    let b21 = dbg!(includes_repr_attr_using_helper(cx, attrs_get_attrs));
-    let b22 = dbg!(includes_repr_attr_using_helper(cx, attrs_hir_map));
-    let b3 = dbg!(has_repr_attr_using_adt(cx, def_id));
-    let all_same = b11 && b12 && b21 && b22 && b3;
+
+    let b11 = includes_repr_attr_using_sym(attrs_get_attrs);
+    let b12 = includes_repr_attr_using_sym(attrs_hir_map);
+    let b21 = includes_repr_attr_using_helper(cx, attrs_get_attrs);
+    let b22 = includes_repr_attr_using_helper(cx, attrs_hir_map);
+    let b3 =  has_repr_attr_using_adt(cx, def_id);
+    let all_same = (b11 && b12 && b21 && b22 && b3) || (!b11 && !b12 && !b21 && !b22 && !b3);
     dbg!(all_same);
 
-    b11
+    b21
 }
 
 fn get_attrs_get_attrs(cx: &LateContext<'tcx>, def_id: LocalDefId) -> &'tcx [Attribute] {
@@ -108,7 +107,9 @@ fn get_attrs_hir_map(cx: &LateContext<'tcx>, def_id: LocalDefId) -> &'tcx [Attri
     hir_map.attrs(hir_id)
 }
 
-// Don't like this because it's so dependent on the current list of `repr` flags and it would have to be manually updated if that ever expanded. idk if there's any mechanism in `bitflag!` or elsewhere for requiring that sort of exhaustiveness
+// Don't like this because it's so dependent on the current list of `repr` flags and it would have
+// to be manually updated if that ever expanded. idk if there's any mechanism in `bitflag!` or
+// elsewhere for requiring that sort of exhaustiveness
 fn has_repr_attr_using_adt(cx: &LateContext<'tcx>, def_id: LocalDefId) -> bool {
     let ty = cx.tcx.type_of(def_id.to_def_id());
     if let ty_mod::Adt(adt, _) = ty.kind() {
@@ -129,5 +130,7 @@ fn includes_repr_attr_using_sym(attrs: &'tcx [Attribute]) -> bool {
 }
 
 fn includes_repr_attr_using_helper(cx: &LateContext<'tcx>, attrs: &'tcx [Attribute]) -> bool {
-    attrs.iter().any(|attr| !rustc_attr::find_repr_attrs(cx.tcx.sess(), attr).is_empty())
+    attrs
+        .iter()
+        .any(|attr| !rustc_attr::find_repr_attrs(cx.tcx.sess(), attr).is_empty())
 }
diff --git a/tests/ui/trailing_zero_sized_array_without_repr_c.rs b/tests/ui/trailing_zero_sized_array_without_repr_c.rs
index 8e8c84fe9c5..07cba5774a5 100644
--- a/tests/ui/trailing_zero_sized_array_without_repr_c.rs
+++ b/tests/ui/trailing_zero_sized_array_without_repr_c.rs
@@ -1,5 +1,5 @@
 #![warn(clippy::trailing_zero_sized_array_without_repr_c)]
-// #![feature(const_generics_defaults)] // see below
+#![feature(const_generics_defaults)] // see below
 
 // Do lint:
 
@@ -20,13 +20,13 @@ struct GenericArrayType<T> {
 #[derive(Debug)]
 struct PlayNiceWithOtherAttributesDerive {
     field: i32,
-    last: [usize; 0]
+    last: [usize; 0],
 }
 
 #[must_use]
 struct PlayNiceWithOtherAttributesMustUse {
     field: i32,
-    last: [usize; 0]
+    last: [usize; 0],
 }
 
 const ZERO: usize = 0;
@@ -72,7 +72,7 @@ struct GoodReason {
     last: [usize; 0],
 }
 
-struct SizedArray {
+struct NonZeroSizedArray {
     field: i32,
     last: [usize; 1],
 }
@@ -114,8 +114,8 @@ enum DontLintAnonymousStructsFromDesuraging {
     C { x: u32, y: [u64; 0] },
 }
 
-// NOTE: including these (along with the required feature) triggers an ICE. Should make sure the
-// const generics people are aware of that if they weren't already.
+// NOTE: including these (along with the required feature) triggers an ICE. Not sure why. Should
+// make sure the const generics people are aware of that if they weren't already.
 
 // #[repr(C)]
 // struct ConstParamOk<const N: usize = 0> {
@@ -129,5 +129,5 @@ enum DontLintAnonymousStructsFromDesuraging {
 // }
 
 fn main() {
-    let _ = PlayNiceWithOtherAttributesMustUse {field: 0, last: []};
+    let _ = PlayNiceWithOtherAttributesMustUse { field: 0, last: [] };
 }
-- 
cgit 1.4.1-3-g733a5


From 9b3f55ee61e781ef3360ddfaa436746bb7e40df5 Mon Sep 17 00:00:00 2001
From: Nathaniel Hamovitz <18648574+nhamovitz@users.noreply.github.com>
Date: Sat, 16 Oct 2021 17:49:13 -0700
Subject: tried to simplify but it doesn't work :/

---
 .../trailing_zero_sized_array_without_repr_c.rs    | 109 +++++++--------------
 .../ui/trailing_zero_sized_array_without_repr_c.rs |  34 +++++--
 2 files changed, 61 insertions(+), 82 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs b/clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs
index a9c6e24918e..913812126a9 100644
--- a/clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs
+++ b/clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs
@@ -1,14 +1,11 @@
 use clippy_utils::consts::{miri_to_const, Constant};
 use clippy_utils::diagnostics::span_lint_and_help;
 use rustc_ast::Attribute;
-use rustc_hir::def_id::LocalDefId;
 use rustc_hir::{Item, ItemKind, VariantData};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::dep_graph::DepContext;
-use rustc_middle::ty as ty_mod;
-use rustc_middle::ty::ReprFlags;
+use rustc_middle::ty::Const;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::sym;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -43,93 +40,55 @@ declare_lint_pass!(TrailingZeroSizedArrayWithoutReprC => [TRAILING_ZERO_SIZED_AR
 
 impl<'tcx> LateLintPass<'tcx> for TrailingZeroSizedArrayWithoutReprC {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
-        dbg!(item.ident);
-        if is_struct_with_trailing_zero_sized_array(cx, item) && !has_repr_attr(cx, item.def_id) {
-            // span_lint_and_help(
-            //     cx,
-            //     TRAILING_ZERO_SIZED_ARRAY_WITHOUT_REPR_C,
-            //     item.span,
-            //     "trailing zero-sized array in a struct which is not marked `#[repr(C)]`",
-            //     None,
-            //     "consider annotating the struct definition with `#[repr(C)]` (or another `repr` attribute)",
-            // );
-            eprintln!("— consider yourself linted — 🦀")
+        if is_struct_with_trailing_zero_sized_array(cx, item) {
+            let attrs = cx.tcx.get_attrs(item.def_id.to_def_id());
+            let first_attr = attrs.first(); // Actually, I've no idea if this is guaranteed to be the first one in the source code.
+
+            let lint_span = if let Some(first_attr) = first_attr {
+                first_attr.span.until(item.span)
+            } else {
+                item.span
+            };
+
+            if !has_repr_attr(cx, attrs) {
+                span_lint_and_help(
+                    cx,
+                    TRAILING_ZERO_SIZED_ARRAY_WITHOUT_REPR_C,
+                    lint_span,
+                    "trailing zero-sized array in a struct which is not marked `#[repr(C)]`",
+                    None,
+                    "consider annotating the struct definition with `#[repr(C)]` (or another `repr` attribute)",
+                );
+            }
         }
     }
 }
 
 fn is_struct_with_trailing_zero_sized_array(cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) -> bool {
     if_chain! {
-        if let ItemKind::Struct(data, _generics) = &item.kind;
+        // Check if last field is an array
+        if let ItemKind::Struct(data, _) = &item.kind;
         if let VariantData::Struct(field_defs, _) = data;
         if let Some(last_field) = field_defs.last();
-        if let rustc_hir::TyKind::Array(_, aconst) = last_field.ty.kind;
-        let aconst_def_id = cx.tcx.hir().body_owner_def_id(aconst.body).to_def_id();
-        let ty = cx.tcx.type_of(aconst_def_id);
-        let constant = cx
-            .tcx
-            // NOTE: maybe const_eval_resolve?
-            .const_eval_poly(aconst_def_id)
-            .ok()
-            .map(|val| rustc_middle::ty::Const::from_value(cx.tcx, val, ty));
-        if let Some(Constant::Int(val)) = constant.and_then(miri_to_const);
-        if val == 0;
-        then {
-            true
-        } else {
-            false
-        }
-    }
-}
-
-fn has_repr_attr(cx: &LateContext<'tcx>, def_id: LocalDefId) -> bool {
-    let attrs_get_attrs = get_attrs_get_attrs(cx, def_id);
-    let attrs_hir_map = get_attrs_hir_map(cx, def_id);
+        if let rustc_hir::TyKind::Array(_, length) = last_field.ty.kind;
 
-    let b11 = includes_repr_attr_using_sym(attrs_get_attrs);
-    let b12 = includes_repr_attr_using_sym(attrs_hir_map);
-    let b21 = includes_repr_attr_using_helper(cx, attrs_get_attrs);
-    let b22 = includes_repr_attr_using_helper(cx, attrs_hir_map);
-    let b3 =  has_repr_attr_using_adt(cx, def_id);
-    let all_same = (b11 && b12 && b21 && b22 && b3) || (!b11 && !b12 && !b21 && !b22 && !b3);
-    dbg!(all_same);
+        // Check if that that array zero-sized.
+        let length_ldid = cx.tcx.hir().local_def_id(length.hir_id);
+        let length = Const::from_anon_const(cx.tcx, length_ldid);
+        if let Some(Constant::Int(length)) = miri_to_const(length);
+        if length == 0;
 
-    b21
-}
-
-fn get_attrs_get_attrs(cx: &LateContext<'tcx>, def_id: LocalDefId) -> &'tcx [Attribute] {
-    cx.tcx.get_attrs(def_id.to_def_id())
-}
-
-fn get_attrs_hir_map(cx: &LateContext<'tcx>, def_id: LocalDefId) -> &'tcx [Attribute] {
-    let hir_map = cx.tcx.hir();
-    let hir_id = hir_map.local_def_id_to_hir_id(def_id);
-    hir_map.attrs(hir_id)
-}
-
-// Don't like this because it's so dependent on the current list of `repr` flags and it would have
-// to be manually updated if that ever expanded. idk if there's any mechanism in `bitflag!` or
-// elsewhere for requiring that sort of exhaustiveness
-fn has_repr_attr_using_adt(cx: &LateContext<'tcx>, def_id: LocalDefId) -> bool {
-    let ty = cx.tcx.type_of(def_id.to_def_id());
-    if let ty_mod::Adt(adt, _) = ty.kind() {
-        if adt.is_struct() {
-            let repr = adt.repr;
-            let repr_attr = ReprFlags::IS_C | ReprFlags::IS_TRANSPARENT | ReprFlags::IS_SIMD | ReprFlags::IS_LINEAR;
-            repr.int.is_some() || repr.align.is_some() || repr.pack.is_some() || repr.flags.intersects(repr_attr)
+        then {
+            true
         } else {
             false
         }
-    } else {
-        false
     }
 }
 
-fn includes_repr_attr_using_sym(attrs: &'tcx [Attribute]) -> bool {
-    attrs.iter().any(|attr| attr.has_name(sym::repr))
-}
-
-fn includes_repr_attr_using_helper(cx: &LateContext<'tcx>, attrs: &'tcx [Attribute]) -> bool {
+fn has_repr_attr(cx: &LateContext<'tcx>, attrs: &[Attribute]) -> bool {
+    // NOTE: there's at least four other ways to do this but I liked this one the best. (All five agreed
+    // on all testcases.) Happy to use another; they're in the commit history.
     attrs
         .iter()
         .any(|attr| !rustc_attr::find_repr_attrs(cx.tcx.sess(), attr).is_empty())
diff --git a/tests/ui/trailing_zero_sized_array_without_repr_c.rs b/tests/ui/trailing_zero_sized_array_without_repr_c.rs
index 07cba5774a5..6ab96c2ebf6 100644
--- a/tests/ui/trailing_zero_sized_array_without_repr_c.rs
+++ b/tests/ui/trailing_zero_sized_array_without_repr_c.rs
@@ -8,7 +8,7 @@ struct RarelyUseful {
     last: [usize; 0],
 }
 
-struct OnlyFieldIsZeroSizeArray {
+struct OnlyField {
     first_and_last: [usize; 0],
 }
 
@@ -18,19 +18,19 @@ struct GenericArrayType<T> {
 }
 
 #[derive(Debug)]
-struct PlayNiceWithOtherAttributesDerive {
+struct OnlyAnotherAttributeDerive {
     field: i32,
     last: [usize; 0],
 }
 
 #[must_use]
-struct PlayNiceWithOtherAttributesMustUse {
+struct OnlyAnotherAttributeMustUse {
     field: i32,
     last: [usize; 0],
 }
 
 const ZERO: usize = 0;
-struct ZeroSizedFromExternalConst {
+struct ZeroSizedWithConst {
     field: i32,
     last: [usize; ZERO],
 }
@@ -39,7 +39,7 @@ struct ZeroSizedFromExternalConst {
 const fn compute_zero() -> usize {
     (4 + 6) - (2 * 5)
 }
-struct UsingFunction {
+struct ZeroSizedWithConstFunction {
     field: i32,
     last: [usize; compute_zero()],
 }
@@ -72,17 +72,36 @@ struct GoodReason {
     last: [usize; 0],
 }
 
+#[repr(C)]
+struct OnlyFieldWithReprC {
+    first_and_last: [usize; 0],
+}
+
 struct NonZeroSizedArray {
     field: i32,
     last: [usize; 1],
 }
 
 const ONE: usize = 1;
-struct NonZeroSizedFromExternalConst {
+struct NonZeroSizedWithConst {
     field: i32,
     last: [usize; ONE],
 }
 
+#[derive(Debug)]
+#[repr(C)]
+struct OtherAttributesDerive {
+    field: i32,
+    last: [usize; 0],
+}
+
+#[must_use]
+#[repr(C)]
+struct OtherAttributesMustUse {
+    field: i32,
+    last: [usize; 0],
+}
+
 #[repr(packed)]
 struct ReprPacked {
     field: i32,
@@ -129,5 +148,6 @@ enum DontLintAnonymousStructsFromDesuraging {
 // }
 
 fn main() {
-    let _ = PlayNiceWithOtherAttributesMustUse { field: 0, last: [] };
+    let _ = OnlyAnotherAttributeMustUse { field: 0, last: [] };
+    let _ = OtherAttributesMustUse { field: 0, last: [] };
 }
-- 
cgit 1.4.1-3-g733a5


From a3420f70043c19165a4e44639ef4e6f3c156a174 Mon Sep 17 00:00:00 2001
From: Nathaniel Hamovitz <18648574+nhamovitz@users.noreply.github.com>
Date: Sat, 16 Oct 2021 22:03:08 -0700
Subject: Tidy comments + tests; revert 'size-is-zero' detection

---
 .../trailing_zero_sized_array_without_repr_c.rs    | 35 ++++++---
 .../ui/trailing_zero_sized_array_without_repr_c.rs | 36 ++++-----
 ...trailing_zero_sized_array_without_repr_c.stderr | 91 +++++++++-------------
 3 files changed, 72 insertions(+), 90 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs b/clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs
index 913812126a9..bc055307d5e 100644
--- a/clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs
+++ b/clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs
@@ -36,16 +36,15 @@ declare_clippy_lint! {
 }
 declare_lint_pass!(TrailingZeroSizedArrayWithoutReprC => [TRAILING_ZERO_SIZED_ARRAY_WITHOUT_REPR_C]);
 
-// TESTNAME=trailing_zero_sized_array_without_repr_c cargo uitest
-
 impl<'tcx> LateLintPass<'tcx> for TrailingZeroSizedArrayWithoutReprC {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
         if is_struct_with_trailing_zero_sized_array(cx, item) {
+            // NOTE: This is to include attributes on the definition when we print the lint. If the convention
+            // is to not do that with struct definitions (I'm not sure), then this isn't necessary.
             let attrs = cx.tcx.get_attrs(item.def_id.to_def_id());
-            let first_attr = attrs.first(); // Actually, I've no idea if this is guaranteed to be the first one in the source code.
-
+            let first_attr = attrs.iter().min_by_key(|attr| attr.span.lo());
             let lint_span = if let Some(first_attr) = first_attr {
-                first_attr.span.until(item.span)
+                first_attr.span.to(item.span)
             } else {
                 item.span
             };
@@ -66,18 +65,29 @@ impl<'tcx> LateLintPass<'tcx> for TrailingZeroSizedArrayWithoutReprC {
 
 fn is_struct_with_trailing_zero_sized_array(cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) -> bool {
     if_chain! {
-        // Check if last field is an array
+        // First check if last field is an array
         if let ItemKind::Struct(data, _) = &item.kind;
         if let VariantData::Struct(field_defs, _) = data;
         if let Some(last_field) = field_defs.last();
         if let rustc_hir::TyKind::Array(_, length) = last_field.ty.kind;
 
-        // Check if that that array zero-sized.
-        let length_ldid = cx.tcx.hir().local_def_id(length.hir_id);
-        let length = Const::from_anon_const(cx.tcx, length_ldid);
-        if let Some(Constant::Int(length)) = miri_to_const(length);
-        if length == 0;
+        // Then check if that that array zero-sized
 
+        // This is pretty much copied from `enum_clike.rs` and I don't fully understand it, so let me know
+        // if there's a better way. I tried `Const::from_anon_const` but it didn't fold in the values
+        // on the `ZeroSizedWithConst` and `ZeroSizedWithConstFunction` tests.
+
+        // This line in particular seems convoluted.
+        let length_did = cx.tcx.hir().body_owner_def_id(length.body).to_def_id();
+        let length_ty = cx.tcx.type_of(length_did);
+        let length = cx
+            .tcx
+            .const_eval_poly(length_did)
+            .ok()
+            .map(|val| Const::from_value(cx.tcx, val, length_ty))
+            .and_then(miri_to_const);
+        if let Some(Constant::Int(length)) = length;
+        if length == 0;
         then {
             true
         } else {
@@ -88,7 +98,8 @@ fn is_struct_with_trailing_zero_sized_array(cx: &LateContext<'tcx>, item: &'tcx
 
 fn has_repr_attr(cx: &LateContext<'tcx>, attrs: &[Attribute]) -> bool {
     // NOTE: there's at least four other ways to do this but I liked this one the best. (All five agreed
-    // on all testcases.) Happy to use another; they're in the commit history.
+    // on all testcases.) Happy to use another; they're in the commit history if you want to look (or I
+    // can go find them).
     attrs
         .iter()
         .any(|attr| !rustc_attr::find_repr_attrs(cx.tcx.sess(), attr).is_empty())
diff --git a/tests/ui/trailing_zero_sized_array_without_repr_c.rs b/tests/ui/trailing_zero_sized_array_without_repr_c.rs
index 6ab96c2ebf6..77b2c29b275 100644
--- a/tests/ui/trailing_zero_sized_array_without_repr_c.rs
+++ b/tests/ui/trailing_zero_sized_array_without_repr_c.rs
@@ -1,5 +1,4 @@
 #![warn(clippy::trailing_zero_sized_array_without_repr_c)]
-#![feature(const_generics_defaults)] // see below
 
 // Do lint:
 
@@ -17,14 +16,16 @@ struct GenericArrayType<T> {
     last: [T; 0],
 }
 
-#[derive(Debug)]
-struct OnlyAnotherAttributeDerive {
+#[must_use]
+struct OnlyAnotherAttributeMustUse {
     field: i32,
     last: [usize; 0],
 }
 
-#[must_use]
-struct OnlyAnotherAttributeMustUse {
+// NOTE: Unfortunately the attribute isn't included in the lint output. I'm not sure how to make it
+// show up.
+#[derive(Debug)]
+struct OnlyAnotherAttributeDerive {
     field: i32,
     last: [usize; 0],
 }
@@ -82,6 +83,12 @@ struct NonZeroSizedArray {
     last: [usize; 1],
 }
 
+struct NotLastField {
+    f1: u32,
+    zero_sized: [usize; 0],
+    last: i32,
+}
+
 const ONE: usize = 1;
 struct NonZeroSizedWithConst {
     field: i32,
@@ -133,21 +140,4 @@ enum DontLintAnonymousStructsFromDesuraging {
     C { x: u32, y: [u64; 0] },
 }
 
-// NOTE: including these (along with the required feature) triggers an ICE. Not sure why. Should
-// make sure the const generics people are aware of that if they weren't already.
-
-// #[repr(C)]
-// struct ConstParamOk<const N: usize = 0> {
-//     field: i32,
-//     last: [usize; N]
-// }
-
-// struct ConstParamLint<const N: usize = 0> {
-//     field: i32,
-//     last: [usize; N]
-// }
-
-fn main() {
-    let _ = OnlyAnotherAttributeMustUse { field: 0, last: [] };
-    let _ = OtherAttributesMustUse { field: 0, last: [] };
-}
+fn main() {}
diff --git a/tests/ui/trailing_zero_sized_array_without_repr_c.stderr b/tests/ui/trailing_zero_sized_array_without_repr_c.stderr
index 84606ed6185..ee8182cdc38 100644
--- a/tests/ui/trailing_zero_sized_array_without_repr_c.stderr
+++ b/tests/ui/trailing_zero_sized_array_without_repr_c.stderr
@@ -1,5 +1,5 @@
 error: trailing zero-sized array in a struct which is not marked `#[repr(C)]`
-  --> $DIR/trailing_zero_sized_array_without_repr_c.rs:4:1
+  --> $DIR/trailing_zero_sized_array_without_repr_c.rs:5:1
    |
 LL | / struct RarelyUseful {
 LL | |     field: i32,
@@ -8,33 +8,20 @@ LL | | }
    | |_^
    |
    = note: `-D clippy::trailing-zero-sized-array-without-repr-c` implied by `-D warnings`
-help: try annotating the struct definition with `#[repr(C)]` (or another `repr` attribute):
-   |
-LL + #[repr(C)]
-LL + struct RarelyUseful {
-LL +     field: i32,
-LL +     last: [usize; 0],
-LL + }
-   |
+   = help: consider annotating the struct definition with `#[repr(C)]` (or another `repr` attribute)
 
 error: trailing zero-sized array in a struct which is not marked `#[repr(C)]`
-  --> $DIR/trailing_zero_sized_array_without_repr_c.rs:15:1
+  --> $DIR/trailing_zero_sized_array_without_repr_c.rs:10:1
    |
-LL | / struct OnlyFieldIsZeroSizeArray {
+LL | / struct OnlyField {
 LL | |     first_and_last: [usize; 0],
 LL | | }
    | |_^
    |
-help: try annotating the struct definition with `#[repr(C)]` (or another `repr` attribute):
-   |
-LL + #[repr(C)]
-LL + struct OnlyFieldIsZeroSizeArray {
-LL +     first_and_last: [usize; 0],
-LL + }
-   |
+   = help: consider annotating the struct definition with `#[repr(C)]` (or another `repr` attribute)
 
 error: trailing zero-sized array in a struct which is not marked `#[repr(C)]`
-  --> $DIR/trailing_zero_sized_array_without_repr_c.rs:19:1
+  --> $DIR/trailing_zero_sized_array_without_repr_c.rs:14:1
    |
 LL | / struct GenericArrayType<T> {
 LL | |     field: i32,
@@ -42,53 +29,55 @@ LL | |     last: [T; 0],
 LL | | }
    | |_^
    |
-help: try annotating the struct definition with `#[repr(C)]` (or another `repr` attribute):
+   = help: consider annotating the struct definition with `#[repr(C)]` (or another `repr` attribute)
+
+error: trailing zero-sized array in a struct which is not marked `#[repr(C)]`
+  --> $DIR/trailing_zero_sized_array_without_repr_c.rs:19:1
    |
-LL + #[repr(C)]
-LL + struct GenericArrayType<T> {
-LL +     field: i32,
-LL +     last: [T; 0],
-LL + }
+LL | / #[must_use]
+LL | | struct OnlyAnotherAttributeMustUse {
+LL | |     field: i32,
+LL | |     last: [usize; 0],
+LL | | }
+   | |_^
    |
+   = help: consider annotating the struct definition with `#[repr(C)]` (or another `repr` attribute)
 
 error: trailing zero-sized array in a struct which is not marked `#[repr(C)]`
-  --> $DIR/trailing_zero_sized_array_without_repr_c.rs:30:1
+  --> $DIR/trailing_zero_sized_array_without_repr_c.rs:28:1
    |
-LL | / struct ZeroSizedFromExternalConst {
+LL | / struct OnlyAnotherAttributeDerive {
 LL | |     field: i32,
-LL | |     last: [usize; ZERO],
+LL | |     last: [usize; 0],
 LL | | }
    | |_^
    |
-help: try annotating the struct definition with `#[repr(C)]` (or another `repr` attribute):
+   = help: consider annotating the struct definition with `#[repr(C)]` (or another `repr` attribute)
+
+error: trailing zero-sized array in a struct which is not marked `#[repr(C)]`
+  --> $DIR/trailing_zero_sized_array_without_repr_c.rs:34:1
    |
-LL + #[repr(C)]
-LL + struct ZeroSizedFromExternalConst {
-LL +     field: i32,
-LL +     last: [usize; ZERO],
-LL + }
+LL | / struct ZeroSizedWithConst {
+LL | |     field: i32,
+LL | |     last: [usize; ZERO],
+LL | | }
+   | |_^
    |
+   = help: consider annotating the struct definition with `#[repr(C)]` (or another `repr` attribute)
 
 error: trailing zero-sized array in a struct which is not marked `#[repr(C)]`
-  --> $DIR/trailing_zero_sized_array_without_repr_c.rs:45:1
+  --> $DIR/trailing_zero_sized_array_without_repr_c.rs:43:1
    |
-LL | / struct UsingFunction {
+LL | / struct ZeroSizedWithConstFunction {
 LL | |     field: i32,
 LL | |     last: [usize; compute_zero()],
 LL | | }
    | |_^
    |
-help: try annotating the struct definition with `#[repr(C)]` (or another `repr` attribute):
-   |
-LL + #[repr(C)]
-LL + struct UsingFunction {
-LL +     field: i32,
-LL +     last: [usize; compute_zero()],
-LL + }
-   |
+   = help: consider annotating the struct definition with `#[repr(C)]` (or another `repr` attribute)
 
 error: trailing zero-sized array in a struct which is not marked `#[repr(C)]`
-  --> $DIR/trailing_zero_sized_array_without_repr_c.rs:94:1
+  --> $DIR/trailing_zero_sized_array_without_repr_c.rs:48:1
    |
 LL | / struct LotsOfFields {
 LL | |     f1: u32,
@@ -99,15 +88,7 @@ LL | |     last: [usize; 0],
 LL | | }
    | |_^
    |
-help: try annotating the struct definition with `#[repr(C)]` (or another `repr` attribute):
-   |
-LL + #[repr(C)]
-LL + struct LotsOfFields {
-LL +     f1: u32,
-LL +     f2: u32,
-LL +     f3: u32,
-LL +     f4: u32,
- ...
+   = help: consider annotating the struct definition with `#[repr(C)]` (or another `repr` attribute)
 
-error: aborting due to 6 previous errors
+error: aborting due to 8 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From c5d3167a23e7f1f6515a28ff15a6698b6712ae54 Mon Sep 17 00:00:00 2001
From: Nathaniel Hamovitz <18648574+nhamovitz@users.noreply.github.com>
Date: Sun, 17 Oct 2021 17:28:45 -0700
Subject: update testsuite and expand `if_chain`

---
 .../trailing_zero_sized_array_without_repr_c.rs    | 55 ++++++++++++----------
 .../ui/trailing_zero_sized_array_without_repr_c.rs | 32 +++++++++++++
 2 files changed, 63 insertions(+), 24 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs b/clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs
index bc055307d5e..de2513244da 100644
--- a/clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs
+++ b/clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs
@@ -64,35 +64,42 @@ impl<'tcx> LateLintPass<'tcx> for TrailingZeroSizedArrayWithoutReprC {
 }
 
 fn is_struct_with_trailing_zero_sized_array(cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) -> bool {
-    if_chain! {
-        // First check if last field is an array
-        if let ItemKind::Struct(data, _) = &item.kind;
-        if let VariantData::Struct(field_defs, _) = data;
-        if let Some(last_field) = field_defs.last();
-        if let rustc_hir::TyKind::Array(_, length) = last_field.ty.kind;
+    // First check if last field is an array
+    if let ItemKind::Struct(data, _) = &item.kind {
+        if let VariantData::Struct(field_defs, _) = data {
+            if let Some(last_field) = field_defs.last() {
+                if let rustc_hir::TyKind::Array(_, length) = last_field.ty.kind {
+                    // Then check if that that array zero-sized
 
-        // Then check if that that array zero-sized
+                    // This is pretty much copied from `enum_clike.rs` and I don't fully understand it, so let me know
+                    // if there's a better way. I tried `Const::from_anon_const` but it didn't fold in the values
+                    // on the `ZeroSizedWithConst` and `ZeroSizedWithConstFunction` tests.
 
-        // This is pretty much copied from `enum_clike.rs` and I don't fully understand it, so let me know
-        // if there's a better way. I tried `Const::from_anon_const` but it didn't fold in the values
-        // on the `ZeroSizedWithConst` and `ZeroSizedWithConstFunction` tests.
-
-        // This line in particular seems convoluted.
-        let length_did = cx.tcx.hir().body_owner_def_id(length.body).to_def_id();
-        let length_ty = cx.tcx.type_of(length_did);
-        let length = cx
-            .tcx
-            .const_eval_poly(length_did)
-            .ok()
-            .map(|val| Const::from_value(cx.tcx, val, length_ty))
-            .and_then(miri_to_const);
-        if let Some(Constant::Int(length)) = length;
-        if length == 0;
-        then {
-            true
+                    // This line in particular seems convoluted.
+                    let length_did = cx.tcx.hir().body_owner_def_id(length.body).to_def_id();
+                    let length_ty = cx.tcx.type_of(length_did);
+                    let length = cx
+                        .tcx
+                        .const_eval_poly(length_did)
+                        .ok()
+                        .map(|val| Const::from_value(cx.tcx, val, length_ty))
+                        .and_then(miri_to_const);
+                    if let Some(Constant::Int(length)) = length {
+                        length == 0
+                    } else {
+                        false
+                    }
+                } else {
+                    false
+                }
+            } else {
+                false
+            }
         } else {
             false
         }
+    } else {
+        false
     }
 }
 
diff --git a/tests/ui/trailing_zero_sized_array_without_repr_c.rs b/tests/ui/trailing_zero_sized_array_without_repr_c.rs
index 77b2c29b275..c6ee36e9685 100644
--- a/tests/ui/trailing_zero_sized_array_without_repr_c.rs
+++ b/tests/ui/trailing_zero_sized_array_without_repr_c.rs
@@ -1,4 +1,5 @@
 #![warn(clippy::trailing_zero_sized_array_without_repr_c)]
+#![feature(const_generics_defaults)]
 
 // Do lint:
 
@@ -45,6 +46,10 @@ struct ZeroSizedWithConstFunction {
     last: [usize; compute_zero()],
 }
 
+struct ZeroSizedArrayWrapper([usize; 0]);
+
+struct TupleStruct(i32, [usize; 0]);
+
 struct LotsOfFields {
     f1: u32,
     f2: u32,
@@ -140,4 +145,31 @@ enum DontLintAnonymousStructsFromDesuraging {
     C { x: u32, y: [u64; 0] },
 }
 
+#[repr(C)]
+struct TupleStructReprC(i32, [usize; 0]);
+
+type NamedTuple = (i32, [usize; 0]);
+
+#[rustfmt::skip] // [rustfmt#4995](https://github.com/rust-lang/rustfmt/issues/4995)
+struct ConstParamZeroDefault<const N: usize = 0> {
+    field: i32,
+    last: [usize; N],
+}
+
+struct ConstParamNoDefault<const N: usize> {
+    field: i32,
+    last: [usize; N],
+}
+
+#[rustfmt::skip] 
+struct ConstParamNonZeroDefault<const N: usize = 1> {
+    field: i32,
+    last: [usize; N],
+}
+
+type A = ConstParamZeroDefault;
+type B = ConstParamZeroDefault<0>;
+type C = ConstParamNoDefault<0>;
+type D = ConstParamNonZeroDefault<0>;
+
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 2a5a4f07cf34895cf6d3c6f8843169e3d6d9c46d Mon Sep 17 00:00:00 2001
From: Nathaniel Hamovitz <18648574+nhamovitz@users.noreply.github.com>
Date: Mon, 18 Oct 2021 00:51:30 -0700
Subject: Refactor ZS array detection again and this one seems great 👍
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../trailing_zero_sized_array_without_repr_c.rs    | 26 ++++++++--------------
 1 file changed, 9 insertions(+), 17 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs b/clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs
index de2513244da..d68ad901704 100644
--- a/clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs
+++ b/clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs
@@ -1,4 +1,4 @@
-use clippy_utils::consts::{miri_to_const, Constant};
+use clippy_utils::consts::{constant, miri_to_const, ConstEvalLateContext, Constant};
 use clippy_utils::diagnostics::span_lint_and_help;
 use rustc_ast::Attribute;
 use rustc_hir::{Item, ItemKind, VariantData};
@@ -38,9 +38,11 @@ declare_lint_pass!(TrailingZeroSizedArrayWithoutReprC => [TRAILING_ZERO_SIZED_AR
 
 impl<'tcx> LateLintPass<'tcx> for TrailingZeroSizedArrayWithoutReprC {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
+        dbg!(item.ident);
         if is_struct_with_trailing_zero_sized_array(cx, item) {
             // NOTE: This is to include attributes on the definition when we print the lint. If the convention
-            // is to not do that with struct definitions (I'm not sure), then this isn't necessary.
+            // is to not do that with struct definitions (I'm not sure), then this isn't necessary. (note: if
+            // you don't get rid of this, change `has_repr_attr` to `includes_repr_attr`).
             let attrs = cx.tcx.get_attrs(item.def_id.to_def_id());
             let first_attr = attrs.iter().min_by_key(|attr| attr.span.lo());
             let lint_span = if let Some(first_attr) = first_attr {
@@ -70,21 +72,11 @@ fn is_struct_with_trailing_zero_sized_array(cx: &LateContext<'tcx>, item: &'tcx
             if let Some(last_field) = field_defs.last() {
                 if let rustc_hir::TyKind::Array(_, length) = last_field.ty.kind {
                     // Then check if that that array zero-sized
-
-                    // This is pretty much copied from `enum_clike.rs` and I don't fully understand it, so let me know
-                    // if there's a better way. I tried `Const::from_anon_const` but it didn't fold in the values
-                    // on the `ZeroSizedWithConst` and `ZeroSizedWithConstFunction` tests.
-
-                    // This line in particular seems convoluted.
-                    let length_did = cx.tcx.hir().body_owner_def_id(length.body).to_def_id();
-                    let length_ty = cx.tcx.type_of(length_did);
-                    let length = cx
-                        .tcx
-                        .const_eval_poly(length_did)
-                        .ok()
-                        .map(|val| Const::from_value(cx.tcx, val, length_ty))
-                        .and_then(miri_to_const);
-                    if let Some(Constant::Int(length)) = length {
+                    let length_ldid = cx.tcx.hir().local_def_id(length.hir_id);
+                    let length = Const::from_anon_const(cx.tcx, length_ldid);
+                    let length = length.try_eval_usize(cx.tcx, cx.param_env);
+                    // if let Some((Constant::Int(length), _)) = length {
+                    if let Some(length) = length {
                         length == 0
                     } else {
                         false
-- 
cgit 1.4.1-3-g733a5


From 9f402b370c43f8cbad15d477d29aa96ff9746de5 Mon Sep 17 00:00:00 2001
From: Nathaniel Hamovitz <18648574+nhamovitz@users.noreply.github.com>
Date: Mon, 18 Oct 2021 03:03:48 -0700
Subject: Check for tuple structs

---
 .../trailing_zero_sized_array_without_repr_c.rs    | 27 ++++++++--------------
 1 file changed, 10 insertions(+), 17 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs b/clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs
index d68ad901704..9373551db15 100644
--- a/clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs
+++ b/clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs
@@ -38,7 +38,6 @@ declare_lint_pass!(TrailingZeroSizedArrayWithoutReprC => [TRAILING_ZERO_SIZED_AR
 
 impl<'tcx> LateLintPass<'tcx> for TrailingZeroSizedArrayWithoutReprC {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
-        dbg!(item.ident);
         if is_struct_with_trailing_zero_sized_array(cx, item) {
             // NOTE: This is to include attributes on the definition when we print the lint. If the convention
             // is to not do that with struct definitions (I'm not sure), then this isn't necessary. (note: if
@@ -66,24 +65,18 @@ impl<'tcx> LateLintPass<'tcx> for TrailingZeroSizedArrayWithoutReprC {
 }
 
 fn is_struct_with_trailing_zero_sized_array(cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) -> bool {
+    // TODO: when finalized, replace with an `if_chain`. I have it like this because my rust-analyzer doesn't work when it's an `if_chain`
     // First check if last field is an array
     if let ItemKind::Struct(data, _) = &item.kind {
-        if let VariantData::Struct(field_defs, _) = data {
-            if let Some(last_field) = field_defs.last() {
-                if let rustc_hir::TyKind::Array(_, length) = last_field.ty.kind {
-                    // Then check if that that array zero-sized
-                    let length_ldid = cx.tcx.hir().local_def_id(length.hir_id);
-                    let length = Const::from_anon_const(cx.tcx, length_ldid);
-                    let length = length.try_eval_usize(cx.tcx, cx.param_env);
-                    // if let Some((Constant::Int(length), _)) = length {
-                    if let Some(length) = length {
-                        length == 0
-                    } else {
-                        false
-                    }
-                } else {
-                    false
-                }
+        let field_defs = data.fields();
+        if let Some(last_field) = field_defs.last() {
+            if let rustc_hir::TyKind::Array(_, length) = last_field.ty.kind {
+                // Then check if that that array zero-sized
+                let length_ldid = cx.tcx.hir().local_def_id(length.hir_id);
+                let length = Const::from_anon_const(cx.tcx, length_ldid);
+                let length = length.try_eval_usize(cx.tcx, cx.param_env);
+                // if let Some((Constant::Int(length), _)) = length {
+                if let Some(length) = length { length == 0 } else { false }
             } else {
                 false
             }
-- 
cgit 1.4.1-3-g733a5


From cd6862283ee603432f509510c53f35bda12e3a5a Mon Sep 17 00:00:00 2001
From: Nathaniel Hamovitz <18648574+nhamovitz@users.noreply.github.com>
Date: Mon, 18 Oct 2021 03:04:50 -0700
Subject: Tidy imports

---
 clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs b/clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs
index 9373551db15..a759fff9cfc 100644
--- a/clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs
+++ b/clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs
@@ -1,7 +1,7 @@
-use clippy_utils::consts::{constant, miri_to_const, ConstEvalLateContext, Constant};
 use clippy_utils::diagnostics::span_lint_and_help;
 use rustc_ast::Attribute;
-use rustc_hir::{Item, ItemKind, VariantData};
+use rustc_hir::VariantData;
+use rustc_hir::{Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::dep_graph::DepContext;
 use rustc_middle::ty::Const;
@@ -65,8 +65,8 @@ impl<'tcx> LateLintPass<'tcx> for TrailingZeroSizedArrayWithoutReprC {
 }
 
 fn is_struct_with_trailing_zero_sized_array(cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) -> bool {
-    // TODO: when finalized, replace with an `if_chain`. I have it like this because my rust-analyzer doesn't work when it's an `if_chain`
-    // First check if last field is an array
+    // TODO: when finalized, replace with an `if_chain`. I have it like this because my rust-analyzer
+    // doesn't work when it's an `if_chain` First check if last field is an array
     if let ItemKind::Struct(data, _) = &item.kind {
         let field_defs = data.fields();
         if let Some(last_field) = field_defs.last() {
-- 
cgit 1.4.1-3-g733a5


From 6377fb2fe71a8bde91a20fbadc93242e19fd0dee Mon Sep 17 00:00:00 2001
From: Nathaniel Hamovitz <18648574+nhamovitz@users.noreply.github.com>
Date: Mon, 18 Oct 2021 03:13:48 -0700
Subject: Tidy import + update expected stderr

---
 .../trailing_zero_sized_array_without_repr_c.rs    |  3 +-
 ...trailing_zero_sized_array_without_repr_c.stderr | 34 ++++++++++++++++------
 2 files changed, 26 insertions(+), 11 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs b/clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs
index a759fff9cfc..aea2fb208df 100644
--- a/clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs
+++ b/clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs
@@ -1,6 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_help;
 use rustc_ast::Attribute;
-use rustc_hir::VariantData;
 use rustc_hir::{Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::dep_graph::DepContext;
@@ -90,7 +89,7 @@ fn is_struct_with_trailing_zero_sized_array(cx: &LateContext<'tcx>, item: &'tcx
 
 fn has_repr_attr(cx: &LateContext<'tcx>, attrs: &[Attribute]) -> bool {
     // NOTE: there's at least four other ways to do this but I liked this one the best. (All five agreed
-    // on all testcases.) Happy to use another; they're in the commit history if you want to look (or I
+    // on all testcases (when i wrote this comment. I added a few since then).) Happy to use another; they're in the commit history if you want to look (or I
     // can go find them).
     attrs
         .iter()
diff --git a/tests/ui/trailing_zero_sized_array_without_repr_c.stderr b/tests/ui/trailing_zero_sized_array_without_repr_c.stderr
index ee8182cdc38..5ed91e937d5 100644
--- a/tests/ui/trailing_zero_sized_array_without_repr_c.stderr
+++ b/tests/ui/trailing_zero_sized_array_without_repr_c.stderr
@@ -1,5 +1,5 @@
 error: trailing zero-sized array in a struct which is not marked `#[repr(C)]`
-  --> $DIR/trailing_zero_sized_array_without_repr_c.rs:5:1
+  --> $DIR/trailing_zero_sized_array_without_repr_c.rs:6:1
    |
 LL | / struct RarelyUseful {
 LL | |     field: i32,
@@ -11,7 +11,7 @@ LL | | }
    = help: consider annotating the struct definition with `#[repr(C)]` (or another `repr` attribute)
 
 error: trailing zero-sized array in a struct which is not marked `#[repr(C)]`
-  --> $DIR/trailing_zero_sized_array_without_repr_c.rs:10:1
+  --> $DIR/trailing_zero_sized_array_without_repr_c.rs:11:1
    |
 LL | / struct OnlyField {
 LL | |     first_and_last: [usize; 0],
@@ -21,7 +21,7 @@ LL | | }
    = help: consider annotating the struct definition with `#[repr(C)]` (or another `repr` attribute)
 
 error: trailing zero-sized array in a struct which is not marked `#[repr(C)]`
-  --> $DIR/trailing_zero_sized_array_without_repr_c.rs:14:1
+  --> $DIR/trailing_zero_sized_array_without_repr_c.rs:15:1
    |
 LL | / struct GenericArrayType<T> {
 LL | |     field: i32,
@@ -32,7 +32,7 @@ LL | | }
    = help: consider annotating the struct definition with `#[repr(C)]` (or another `repr` attribute)
 
 error: trailing zero-sized array in a struct which is not marked `#[repr(C)]`
-  --> $DIR/trailing_zero_sized_array_without_repr_c.rs:19:1
+  --> $DIR/trailing_zero_sized_array_without_repr_c.rs:20:1
    |
 LL | / #[must_use]
 LL | | struct OnlyAnotherAttributeMustUse {
@@ -44,7 +44,7 @@ LL | | }
    = help: consider annotating the struct definition with `#[repr(C)]` (or another `repr` attribute)
 
 error: trailing zero-sized array in a struct which is not marked `#[repr(C)]`
-  --> $DIR/trailing_zero_sized_array_without_repr_c.rs:28:1
+  --> $DIR/trailing_zero_sized_array_without_repr_c.rs:29:1
    |
 LL | / struct OnlyAnotherAttributeDerive {
 LL | |     field: i32,
@@ -55,7 +55,7 @@ LL | | }
    = help: consider annotating the struct definition with `#[repr(C)]` (or another `repr` attribute)
 
 error: trailing zero-sized array in a struct which is not marked `#[repr(C)]`
-  --> $DIR/trailing_zero_sized_array_without_repr_c.rs:34:1
+  --> $DIR/trailing_zero_sized_array_without_repr_c.rs:35:1
    |
 LL | / struct ZeroSizedWithConst {
 LL | |     field: i32,
@@ -66,7 +66,7 @@ LL | | }
    = help: consider annotating the struct definition with `#[repr(C)]` (or another `repr` attribute)
 
 error: trailing zero-sized array in a struct which is not marked `#[repr(C)]`
-  --> $DIR/trailing_zero_sized_array_without_repr_c.rs:43:1
+  --> $DIR/trailing_zero_sized_array_without_repr_c.rs:44:1
    |
 LL | / struct ZeroSizedWithConstFunction {
 LL | |     field: i32,
@@ -77,7 +77,23 @@ LL | | }
    = help: consider annotating the struct definition with `#[repr(C)]` (or another `repr` attribute)
 
 error: trailing zero-sized array in a struct which is not marked `#[repr(C)]`
-  --> $DIR/trailing_zero_sized_array_without_repr_c.rs:48:1
+  --> $DIR/trailing_zero_sized_array_without_repr_c.rs:49:1
+   |
+LL | struct ZeroSizedArrayWrapper([usize; 0]);
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider annotating the struct definition with `#[repr(C)]` (or another `repr` attribute)
+
+error: trailing zero-sized array in a struct which is not marked `#[repr(C)]`
+  --> $DIR/trailing_zero_sized_array_without_repr_c.rs:51:1
+   |
+LL | struct TupleStruct(i32, [usize; 0]);
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider annotating the struct definition with `#[repr(C)]` (or another `repr` attribute)
+
+error: trailing zero-sized array in a struct which is not marked `#[repr(C)]`
+  --> $DIR/trailing_zero_sized_array_without_repr_c.rs:53:1
    |
 LL | / struct LotsOfFields {
 LL | |     f1: u32,
@@ -90,5 +106,5 @@ LL | | }
    |
    = help: consider annotating the struct definition with `#[repr(C)]` (or another `repr` attribute)
 
-error: aborting due to 8 previous errors
+error: aborting due to 10 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 149b3728732169cbd6684dfb5e17242924a506a7 Mon Sep 17 00:00:00 2001
From: Nathaniel Hamovitz <18648574+nhamovitz@users.noreply.github.com>
Date: Mon, 18 Oct 2021 03:16:10 -0700
Subject: run rustfmt

---
 clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs b/clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs
index aea2fb208df..6cba18146b1 100644
--- a/clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs
+++ b/clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs
@@ -89,8 +89,8 @@ fn is_struct_with_trailing_zero_sized_array(cx: &LateContext<'tcx>, item: &'tcx
 
 fn has_repr_attr(cx: &LateContext<'tcx>, attrs: &[Attribute]) -> bool {
     // NOTE: there's at least four other ways to do this but I liked this one the best. (All five agreed
-    // on all testcases (when i wrote this comment. I added a few since then).) Happy to use another; they're in the commit history if you want to look (or I
-    // can go find them).
+    // on all testcases (when i wrote this comment. I added a few since then).) Happy to use another;
+    // they're in the commit history if you want to look (or I can go find them).
     attrs
         .iter()
         .any(|attr| !rustc_attr::find_repr_attrs(cx.tcx.sess(), attr).is_empty())
-- 
cgit 1.4.1-3-g733a5


From 7f84e3d791846fb462eb39d05bbec029b68d97af Mon Sep 17 00:00:00 2001
From: Nathaniel Hamovitz <18648574+nhamovitz@users.noreply.github.com>
Date: Mon, 18 Oct 2021 03:45:08 -0700
Subject: Rename lint

---
 CHANGELOG.md                                       |   2 +-
 clippy_lints/src/lib.register_lints.rs             |   2 +-
 clippy_lints/src/lib.register_nursery.rs           |   2 +-
 clippy_lints/src/lib.rs                            |   4 +-
 .../src/trailing_zero_sized_array_without_repr.rs  |  97 ++++++++++++
 .../trailing_zero_sized_array_without_repr_c.rs    |  97 ------------
 tests/ui/trailing_zero_sized_array_without_repr.rs | 175 +++++++++++++++++++++
 .../ui/trailing_zero_sized_array_without_repr_c.rs | 175 ---------------------
 8 files changed, 277 insertions(+), 277 deletions(-)
 create mode 100644 clippy_lints/src/trailing_zero_sized_array_without_repr.rs
 delete mode 100644 clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs
 create mode 100644 tests/ui/trailing_zero_sized_array_without_repr.rs
 delete mode 100644 tests/ui/trailing_zero_sized_array_without_repr_c.rs

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index a124bebe924..0cf19a6f0f1 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3021,7 +3021,7 @@ Released 2018-09-13
 [`too_many_arguments`]: https://rust-lang.github.io/rust-clippy/master/index.html#too_many_arguments
 [`too_many_lines`]: https://rust-lang.github.io/rust-clippy/master/index.html#too_many_lines
 [`toplevel_ref_arg`]: https://rust-lang.github.io/rust-clippy/master/index.html#toplevel_ref_arg
-[`trailing_zero_sized_array_without_repr_c`]: https://rust-lang.github.io/rust-clippy/master/index.html#trailing_zero_sized_array_without_repr_c
+[`trailing_zero_sized_array_without_repr`]: https://rust-lang.github.io/rust-clippy/master/index.html#trailing_zero_sized_array_without_repr
 [`trait_duplication_in_bounds`]: https://rust-lang.github.io/rust-clippy/master/index.html#trait_duplication_in_bounds
 [`transmute_bytes_to_str`]: https://rust-lang.github.io/rust-clippy/master/index.html#transmute_bytes_to_str
 [`transmute_float_to_int`]: https://rust-lang.github.io/rust-clippy/master/index.html#transmute_float_to_int
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 34b87002fa3..af0629beb36 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -443,7 +443,7 @@ store.register_lints(&[
     temporary_assignment::TEMPORARY_ASSIGNMENT,
     to_digit_is_some::TO_DIGIT_IS_SOME,
     to_string_in_display::TO_STRING_IN_DISPLAY,
-    trailing_zero_sized_array_without_repr_c::TRAILING_ZERO_SIZED_ARRAY_WITHOUT_REPR_C,
+    trailing_zero_sized_array_without_repr::TRAILING_ZERO_SIZED_ARRAY_WITHOUT_REPR,
     trait_bounds::TRAIT_DUPLICATION_IN_BOUNDS,
     trait_bounds::TYPE_REPETITION_IN_BOUNDS,
     transmute::CROSSPOINTER_TRANSMUTE,
diff --git a/clippy_lints/src/lib.register_nursery.rs b/clippy_lints/src/lib.register_nursery.rs
index 325706746db..eab0e5b90f1 100644
--- a/clippy_lints/src/lib.register_nursery.rs
+++ b/clippy_lints/src/lib.register_nursery.rs
@@ -25,7 +25,7 @@ store.register_group(true, "clippy::nursery", Some("clippy_nursery"), vec![
     LintId::of(regex::TRIVIAL_REGEX),
     LintId::of(strings::STRING_LIT_AS_BYTES),
     LintId::of(suspicious_operation_groupings::SUSPICIOUS_OPERATION_GROUPINGS),
-    LintId::of(trailing_zero_sized_array_without_repr_c::TRAILING_ZERO_SIZED_ARRAY_WITHOUT_REPR_C),
+    LintId::of(trailing_zero_sized_array_without_repr::TRAILING_ZERO_SIZED_ARRAY_WITHOUT_REPR),
     LintId::of(transmute::USELESS_TRANSMUTE),
     LintId::of(use_self::USE_SELF),
 ])
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 72636146d7c..1473a2f3095 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -356,7 +356,7 @@ mod tabs_in_doc_comments;
 mod temporary_assignment;
 mod to_digit_is_some;
 mod to_string_in_display;
-mod trailing_zero_sized_array_without_repr_c;
+mod trailing_zero_sized_array_without_repr;
 mod trait_bounds;
 mod transmute;
 mod transmuting_null;
@@ -779,7 +779,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(move || Box::new(undocumented_unsafe_blocks::UndocumentedUnsafeBlocks::default()));
     store.register_late_pass(|| Box::new(match_str_case_mismatch::MatchStrCaseMismatch));
     store.register_late_pass(move || Box::new(format_args::FormatArgs));
-    store.register_late_pass(|| Box::new(trailing_zero_sized_array_without_repr_c::TrailingZeroSizedArrayWithoutReprC));
+    store.register_late_pass(|| Box::new(trailing_zero_sized_array_without_repr::TrailingZeroSizedArrayWithoutRepr));
 
 }
 
diff --git a/clippy_lints/src/trailing_zero_sized_array_without_repr.rs b/clippy_lints/src/trailing_zero_sized_array_without_repr.rs
new file mode 100644
index 00000000000..0267f7bdf0e
--- /dev/null
+++ b/clippy_lints/src/trailing_zero_sized_array_without_repr.rs
@@ -0,0 +1,97 @@
+use clippy_utils::diagnostics::span_lint_and_help;
+use rustc_ast::Attribute;
+use rustc_hir::{Item, ItemKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::dep_graph::DepContext;
+use rustc_middle::ty::Const;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Displays a warning when a struct with a trailing zero-sized array is declared without a `repr` attribute.
+    ///
+    /// ### Why is this bad?
+    /// Zero-sized arrays aren't very useful in Rust itself, so such a struct is likely being created to pass to C code or in some other situation where control over memory layout matters (for example, in conjuction with manual allocation to make it easy to compute the offset of the array). Either way, `#[repr(C)]` (or another `repr` attribute) is needed.
+    ///
+    /// ### Example
+    /// ```rust
+    /// struct RarelyUseful {
+    ///     some_field: usize,
+    ///     last: [SomeType; 0],
+    /// }
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust
+    /// #[repr(C)]
+    /// struct MoreOftenUseful {
+    ///     some_field: usize,
+    ///     last: [SomeType; 0],
+    /// }
+    /// ```
+    pub TRAILING_ZERO_SIZED_ARRAY_WITHOUT_REPR,
+    nursery,
+    "struct with a trailing zero-sized array but without `repr(C)` or another `repr` attribute"
+}
+declare_lint_pass!(TrailingZeroSizedArrayWithoutRepr => [TRAILING_ZERO_SIZED_ARRAY_WITHOUT_REPR]);
+
+impl<'tcx> LateLintPass<'tcx> for TrailingZeroSizedArrayWithoutRepr {
+    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
+        if is_struct_with_trailing_zero_sized_array(cx, item) {
+            // NOTE: This is to include attributes on the definition when we print the lint. If the convention
+            // is to not do that with struct definitions (I'm not sure), then this isn't necessary. (note: if
+            // you don't get rid of this, change `has_repr_attr` to `includes_repr_attr`).
+            let attrs = cx.tcx.get_attrs(item.def_id.to_def_id());
+            let first_attr = attrs.iter().min_by_key(|attr| attr.span.lo());
+            let lint_span = if let Some(first_attr) = first_attr {
+                first_attr.span.to(item.span)
+            } else {
+                item.span
+            };
+
+            if !has_repr_attr(cx, attrs) {
+                span_lint_and_help(
+                    cx,
+                    TRAILING_ZERO_SIZED_ARRAY_WITHOUT_REPR,
+                    lint_span,
+                    "trailing zero-sized array in a struct which is not marked `#[repr(C)]`",
+                    None,
+                    "consider annotating the struct definition with `#[repr(C)]` (or another `repr` attribute)",
+                );
+            }
+        }
+    }
+}
+
+fn is_struct_with_trailing_zero_sized_array(cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) -> bool {
+    // TODO: when finalized, replace with an `if_chain`. I have it like this because my rust-analyzer
+    // doesn't work when it's an `if_chain`.
+
+    // First check if last field is an array
+    if let ItemKind::Struct(data, _) = &item.kind {
+        if let Some(last_field) = data.fields().last() {
+            if let rustc_hir::TyKind::Array(_, length) = last_field.ty.kind {
+                // Then check if that that array zero-sized
+                let length_ldid = cx.tcx.hir().local_def_id(length.hir_id);
+                let length = Const::from_anon_const(cx.tcx, length_ldid);
+                let length = length.try_eval_usize(cx.tcx, cx.param_env);
+                length == Some(0)
+            } else {
+                false
+            }
+        } else {
+            false
+        }
+    } else {
+        false
+    }
+}
+
+fn has_repr_attr(cx: &LateContext<'tcx>, attrs: &[Attribute]) -> bool {
+    // NOTE: there's at least four other ways to do this but I liked this one the best. (All five agreed
+    // on all testcases (when i wrote this comment. I added a few since then).) Happy to use another;
+    // they're in the commit history if you want to look (or I can go find them).
+    attrs
+        .iter()
+        .any(|attr| !rustc_attr::find_repr_attrs(cx.tcx.sess(), attr).is_empty())
+}
diff --git a/clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs b/clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs
deleted file mode 100644
index 6cba18146b1..00000000000
--- a/clippy_lints/src/trailing_zero_sized_array_without_repr_c.rs
+++ /dev/null
@@ -1,97 +0,0 @@
-use clippy_utils::diagnostics::span_lint_and_help;
-use rustc_ast::Attribute;
-use rustc_hir::{Item, ItemKind};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::dep_graph::DepContext;
-use rustc_middle::ty::Const;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Displays a warning when a struct with a trailing zero-sized array is declared without the `repr(C)` attribute.
-    ///
-    /// ### Why is this bad?
-    /// Zero-sized arrays aren't very useful in Rust itself, so such a struct is likely being created to pass to C code (or in conjuction with manual allocation to make it easy to compute the offset of the array). Either way, `#[repr(C)]` is needed.
-    ///
-    /// ### Example
-    /// ```rust
-    /// struct RarelyUseful {
-    ///     some_field: usize,
-    ///     last: [SomeType; 0],
-    /// }
-    /// ```
-    ///
-    /// Use instead:
-    /// ```rust
-    /// #[repr(C)]
-    /// struct MoreOftenUseful {
-    ///     some_field: usize,
-    ///     last: [SomeType; 0],
-    /// }
-    /// ```
-    pub TRAILING_ZERO_SIZED_ARRAY_WITHOUT_REPR_C,
-    nursery,
-    "struct with a trailing zero-sized array but without `repr(C)` or another `repr` attribute"
-}
-declare_lint_pass!(TrailingZeroSizedArrayWithoutReprC => [TRAILING_ZERO_SIZED_ARRAY_WITHOUT_REPR_C]);
-
-impl<'tcx> LateLintPass<'tcx> for TrailingZeroSizedArrayWithoutReprC {
-    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
-        if is_struct_with_trailing_zero_sized_array(cx, item) {
-            // NOTE: This is to include attributes on the definition when we print the lint. If the convention
-            // is to not do that with struct definitions (I'm not sure), then this isn't necessary. (note: if
-            // you don't get rid of this, change `has_repr_attr` to `includes_repr_attr`).
-            let attrs = cx.tcx.get_attrs(item.def_id.to_def_id());
-            let first_attr = attrs.iter().min_by_key(|attr| attr.span.lo());
-            let lint_span = if let Some(first_attr) = first_attr {
-                first_attr.span.to(item.span)
-            } else {
-                item.span
-            };
-
-            if !has_repr_attr(cx, attrs) {
-                span_lint_and_help(
-                    cx,
-                    TRAILING_ZERO_SIZED_ARRAY_WITHOUT_REPR_C,
-                    lint_span,
-                    "trailing zero-sized array in a struct which is not marked `#[repr(C)]`",
-                    None,
-                    "consider annotating the struct definition with `#[repr(C)]` (or another `repr` attribute)",
-                );
-            }
-        }
-    }
-}
-
-fn is_struct_with_trailing_zero_sized_array(cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) -> bool {
-    // TODO: when finalized, replace with an `if_chain`. I have it like this because my rust-analyzer
-    // doesn't work when it's an `if_chain` First check if last field is an array
-    if let ItemKind::Struct(data, _) = &item.kind {
-        let field_defs = data.fields();
-        if let Some(last_field) = field_defs.last() {
-            if let rustc_hir::TyKind::Array(_, length) = last_field.ty.kind {
-                // Then check if that that array zero-sized
-                let length_ldid = cx.tcx.hir().local_def_id(length.hir_id);
-                let length = Const::from_anon_const(cx.tcx, length_ldid);
-                let length = length.try_eval_usize(cx.tcx, cx.param_env);
-                // if let Some((Constant::Int(length), _)) = length {
-                if let Some(length) = length { length == 0 } else { false }
-            } else {
-                false
-            }
-        } else {
-            false
-        }
-    } else {
-        false
-    }
-}
-
-fn has_repr_attr(cx: &LateContext<'tcx>, attrs: &[Attribute]) -> bool {
-    // NOTE: there's at least four other ways to do this but I liked this one the best. (All five agreed
-    // on all testcases (when i wrote this comment. I added a few since then).) Happy to use another;
-    // they're in the commit history if you want to look (or I can go find them).
-    attrs
-        .iter()
-        .any(|attr| !rustc_attr::find_repr_attrs(cx.tcx.sess(), attr).is_empty())
-}
diff --git a/tests/ui/trailing_zero_sized_array_without_repr.rs b/tests/ui/trailing_zero_sized_array_without_repr.rs
new file mode 100644
index 00000000000..6ac124c8b34
--- /dev/null
+++ b/tests/ui/trailing_zero_sized_array_without_repr.rs
@@ -0,0 +1,175 @@
+#![warn(clippy::trailing_zero_sized_array_without_repr)]
+#![feature(const_generics_defaults)]
+
+// Do lint:
+
+struct RarelyUseful {
+    field: i32,
+    last: [usize; 0],
+}
+
+struct OnlyField {
+    first_and_last: [usize; 0],
+}
+
+struct GenericArrayType<T> {
+    field: i32,
+    last: [T; 0],
+}
+
+#[must_use]
+struct OnlyAnotherAttributeMustUse {
+    field: i32,
+    last: [usize; 0],
+}
+
+// NOTE: Unfortunately the attribute isn't included in the lint output. I'm not sure how to make it
+// show up.
+#[derive(Debug)]
+struct OnlyAnotherAttributeDerive {
+    field: i32,
+    last: [usize; 0],
+}
+
+const ZERO: usize = 0;
+struct ZeroSizedWithConst {
+    field: i32,
+    last: [usize; ZERO],
+}
+
+#[allow(clippy::eq_op)]
+const fn compute_zero() -> usize {
+    (4 + 6) - (2 * 5)
+}
+struct ZeroSizedWithConstFunction {
+    field: i32,
+    last: [usize; compute_zero()],
+}
+
+struct ZeroSizedArrayWrapper([usize; 0]);
+
+struct TupleStruct(i32, [usize; 0]);
+
+struct LotsOfFields {
+    f1: u32,
+    f2: u32,
+    f3: u32,
+    f4: u32,
+    f5: u32,
+    f6: u32,
+    f7: u32,
+    f8: u32,
+    f9: u32,
+    f10: u32,
+    f11: u32,
+    f12: u32,
+    f13: u32,
+    f14: u32,
+    f15: u32,
+    f16: u32,
+    last: [usize; 0],
+}
+
+// Don't lint
+
+#[repr(C)]
+struct GoodReason {
+    field: i32,
+    last: [usize; 0],
+}
+
+#[repr(C)]
+struct OnlyFieldWithReprC {
+    first_and_last: [usize; 0],
+}
+
+struct NonZeroSizedArray {
+    field: i32,
+    last: [usize; 1],
+}
+
+struct NotLastField {
+    f1: u32,
+    zero_sized: [usize; 0],
+    last: i32,
+}
+
+const ONE: usize = 1;
+struct NonZeroSizedWithConst {
+    field: i32,
+    last: [usize; ONE],
+}
+
+#[derive(Debug)]
+#[repr(C)]
+struct OtherAttributesDerive {
+    field: i32,
+    last: [usize; 0],
+}
+
+#[must_use]
+#[repr(C)]
+struct OtherAttributesMustUse {
+    field: i32,
+    last: [usize; 0],
+}
+
+#[repr(packed)]
+struct ReprPacked {
+    field: i32,
+    last: [usize; 0],
+}
+
+#[repr(C, packed)]
+struct ReprCPacked {
+    field: i32,
+    last: [usize; 0],
+}
+
+#[repr(align(64))]
+struct ReprAlign {
+    field: i32,
+    last: [usize; 0],
+}
+#[repr(C, align(64))]
+struct ReprCAlign {
+    field: i32,
+    last: [usize; 0],
+}
+
+// NOTE: because of https://doc.rust-lang.org/stable/reference/type-layout.html#primitive-representation-of-enums-with-fields and I'm not sure when in the compilation pipeline that would happen
+#[repr(C)]
+enum DontLintAnonymousStructsFromDesuraging {
+    A(u32),
+    B(f32, [u64; 0]),
+    C { x: u32, y: [u64; 0] },
+}
+
+#[repr(C)]
+struct TupleStructReprC(i32, [usize; 0]);
+
+type NamedTuple = (i32, [usize; 0]);
+
+#[rustfmt::skip] // [rustfmt#4995](https://github.com/rust-lang/rustfmt/issues/4995)
+struct ConstParamZeroDefault<const N: usize = 0> {
+    field: i32,
+    last: [usize; N],
+}
+
+struct ConstParamNoDefault<const N: usize> {
+    field: i32,
+    last: [usize; N],
+}
+
+#[rustfmt::skip] 
+struct ConstParamNonZeroDefault<const N: usize = 1> {
+    field: i32,
+    last: [usize; N],
+}
+
+type A = ConstParamZeroDefault;
+type B = ConstParamZeroDefault<0>;
+type C = ConstParamNoDefault<0>;
+type D = ConstParamNonZeroDefault<0>;
+
+fn main() {}
diff --git a/tests/ui/trailing_zero_sized_array_without_repr_c.rs b/tests/ui/trailing_zero_sized_array_without_repr_c.rs
deleted file mode 100644
index c6ee36e9685..00000000000
--- a/tests/ui/trailing_zero_sized_array_without_repr_c.rs
+++ /dev/null
@@ -1,175 +0,0 @@
-#![warn(clippy::trailing_zero_sized_array_without_repr_c)]
-#![feature(const_generics_defaults)]
-
-// Do lint:
-
-struct RarelyUseful {
-    field: i32,
-    last: [usize; 0],
-}
-
-struct OnlyField {
-    first_and_last: [usize; 0],
-}
-
-struct GenericArrayType<T> {
-    field: i32,
-    last: [T; 0],
-}
-
-#[must_use]
-struct OnlyAnotherAttributeMustUse {
-    field: i32,
-    last: [usize; 0],
-}
-
-// NOTE: Unfortunately the attribute isn't included in the lint output. I'm not sure how to make it
-// show up.
-#[derive(Debug)]
-struct OnlyAnotherAttributeDerive {
-    field: i32,
-    last: [usize; 0],
-}
-
-const ZERO: usize = 0;
-struct ZeroSizedWithConst {
-    field: i32,
-    last: [usize; ZERO],
-}
-
-#[allow(clippy::eq_op)]
-const fn compute_zero() -> usize {
-    (4 + 6) - (2 * 5)
-}
-struct ZeroSizedWithConstFunction {
-    field: i32,
-    last: [usize; compute_zero()],
-}
-
-struct ZeroSizedArrayWrapper([usize; 0]);
-
-struct TupleStruct(i32, [usize; 0]);
-
-struct LotsOfFields {
-    f1: u32,
-    f2: u32,
-    f3: u32,
-    f4: u32,
-    f5: u32,
-    f6: u32,
-    f7: u32,
-    f8: u32,
-    f9: u32,
-    f10: u32,
-    f11: u32,
-    f12: u32,
-    f13: u32,
-    f14: u32,
-    f15: u32,
-    f16: u32,
-    last: [usize; 0],
-}
-
-// Don't lint
-
-#[repr(C)]
-struct GoodReason {
-    field: i32,
-    last: [usize; 0],
-}
-
-#[repr(C)]
-struct OnlyFieldWithReprC {
-    first_and_last: [usize; 0],
-}
-
-struct NonZeroSizedArray {
-    field: i32,
-    last: [usize; 1],
-}
-
-struct NotLastField {
-    f1: u32,
-    zero_sized: [usize; 0],
-    last: i32,
-}
-
-const ONE: usize = 1;
-struct NonZeroSizedWithConst {
-    field: i32,
-    last: [usize; ONE],
-}
-
-#[derive(Debug)]
-#[repr(C)]
-struct OtherAttributesDerive {
-    field: i32,
-    last: [usize; 0],
-}
-
-#[must_use]
-#[repr(C)]
-struct OtherAttributesMustUse {
-    field: i32,
-    last: [usize; 0],
-}
-
-#[repr(packed)]
-struct ReprPacked {
-    field: i32,
-    last: [usize; 0],
-}
-
-#[repr(C, packed)]
-struct ReprCPacked {
-    field: i32,
-    last: [usize; 0],
-}
-
-#[repr(align(64))]
-struct ReprAlign {
-    field: i32,
-    last: [usize; 0],
-}
-#[repr(C, align(64))]
-struct ReprCAlign {
-    field: i32,
-    last: [usize; 0],
-}
-
-// NOTE: because of https://doc.rust-lang.org/stable/reference/type-layout.html#primitive-representation-of-enums-with-fields and I'm not sure when in the compilation pipeline that would happen
-#[repr(C)]
-enum DontLintAnonymousStructsFromDesuraging {
-    A(u32),
-    B(f32, [u64; 0]),
-    C { x: u32, y: [u64; 0] },
-}
-
-#[repr(C)]
-struct TupleStructReprC(i32, [usize; 0]);
-
-type NamedTuple = (i32, [usize; 0]);
-
-#[rustfmt::skip] // [rustfmt#4995](https://github.com/rust-lang/rustfmt/issues/4995)
-struct ConstParamZeroDefault<const N: usize = 0> {
-    field: i32,
-    last: [usize; N],
-}
-
-struct ConstParamNoDefault<const N: usize> {
-    field: i32,
-    last: [usize; N],
-}
-
-#[rustfmt::skip] 
-struct ConstParamNonZeroDefault<const N: usize = 1> {
-    field: i32,
-    last: [usize; N],
-}
-
-type A = ConstParamZeroDefault;
-type B = ConstParamZeroDefault<0>;
-type C = ConstParamNoDefault<0>;
-type D = ConstParamNonZeroDefault<0>;
-
-fn main() {}
-- 
cgit 1.4.1-3-g733a5


From a54dbf6445f923b6b315a4c9b08f3e45eaac0081 Mon Sep 17 00:00:00 2001
From: Nathaniel Hamovitz <18648574+nhamovitz@users.noreply.github.com>
Date: Mon, 18 Oct 2021 03:52:57 -0700
Subject: Improve doc and span messages

---
 clippy_lints/src/trailing_zero_sized_array_without_repr.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/trailing_zero_sized_array_without_repr.rs b/clippy_lints/src/trailing_zero_sized_array_without_repr.rs
index 0267f7bdf0e..98f5073681d 100644
--- a/clippy_lints/src/trailing_zero_sized_array_without_repr.rs
+++ b/clippy_lints/src/trailing_zero_sized_array_without_repr.rs
@@ -31,7 +31,7 @@ declare_clippy_lint! {
     /// ```
     pub TRAILING_ZERO_SIZED_ARRAY_WITHOUT_REPR,
     nursery,
-    "struct with a trailing zero-sized array but without `repr(C)` or another `repr` attribute"
+    "struct with a trailing zero-sized array but without `#[repr(C)]` or another `repr` attribute"
 }
 declare_lint_pass!(TrailingZeroSizedArrayWithoutRepr => [TRAILING_ZERO_SIZED_ARRAY_WITHOUT_REPR]);
 
@@ -54,9 +54,9 @@ impl<'tcx> LateLintPass<'tcx> for TrailingZeroSizedArrayWithoutRepr {
                     cx,
                     TRAILING_ZERO_SIZED_ARRAY_WITHOUT_REPR,
                     lint_span,
-                    "trailing zero-sized array in a struct which is not marked `#[repr(C)]`",
+                    "trailing zero-sized array in a struct which is not marked with a `repr` attribute",
                     None,
-                    "consider annotating the struct definition with `#[repr(C)]` (or another `repr` attribute)",
+                    "consider annotating the struct definition with `#[repr(C)]` or another `repr` attribute",
                 );
             }
         }
-- 
cgit 1.4.1-3-g733a5


From 3a41f226c5c89806f23ef67502ea29bedf7d9ce8 Mon Sep 17 00:00:00 2001
From: Nathaniel Hamovitz <18648574+nhamovitz@users.noreply.github.com>
Date: Mon, 18 Oct 2021 07:02:00 -0700
Subject: Exploring emitting other sorts of `span`s

---
 .../src/trailing_zero_sized_array_without_repr.rs  | 42 ++++++++++++++++------
 1 file changed, 32 insertions(+), 10 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/trailing_zero_sized_array_without_repr.rs b/clippy_lints/src/trailing_zero_sized_array_without_repr.rs
index 98f5073681d..48feb365ed8 100644
--- a/clippy_lints/src/trailing_zero_sized_array_without_repr.rs
+++ b/clippy_lints/src/trailing_zero_sized_array_without_repr.rs
@@ -1,5 +1,6 @@
-use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::{diagnostics::{span_lint_and_help, span_lint_and_then, span_lint_and_sugg}, source::{indent_of, snippet}};
 use rustc_ast::Attribute;
+use rustc_errors::Applicability;
 use rustc_hir::{Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::dep_graph::DepContext;
@@ -50,14 +51,34 @@ impl<'tcx> LateLintPass<'tcx> for TrailingZeroSizedArrayWithoutRepr {
             };
 
             if !has_repr_attr(cx, attrs) {
-                span_lint_and_help(
-                    cx,
-                    TRAILING_ZERO_SIZED_ARRAY_WITHOUT_REPR,
-                    lint_span,
-                    "trailing zero-sized array in a struct which is not marked with a `repr` attribute",
-                    None,
-                    "consider annotating the struct definition with `#[repr(C)]` or another `repr` attribute",
-                );
+                let suggestion_span = item.span.shrink_to_lo();
+                let indent = " ".repeat(indent_of(cx, item.span).unwrap_or(0));
+
+                span_lint_and_sugg(cx, TRAILING_ZERO_SIZED_ARRAY_WITHOUT_REPR, item.span, "trailing zero-sized array in a struct which is not marked with a `repr` attribute", "consider adding `#[repr(C)]` or another `repr` attribute", format!("#[repr(C)]\n{}", snippet(cx, item.span.shrink_to_lo().to(item.ident.span), "..")), Applicability::MaybeIncorrect);
+
+                // span_lint_and_then(
+                //     cx,
+                //     TRAILING_ZERO_SIZED_ARRAY_WITHOUT_REPR,
+                //     item.span,
+                //     "trailing zero-sized array in a struct which is not marked with a `repr` attribute",
+                //     |diag| {
+                //         let sugg = format!("#[repr(C)]\n{}", indent);
+                //         let sugg2 = format!("#[repr(C)]\n{}", item.ident.span);
+                //         diag.span_suggestion(item.span,
+                //                               "consider adding `#[repr(C)]` or another `repr` attribute",
+                //                               sugg2,
+                //                               Applicability::MaybeIncorrect);
+                //     }
+                // );
+              
+                // span_lint_and_help(
+                //     cx,
+                //     TRAILING_ZERO_SIZED_ARRAY_WITHOUT_REPR,
+                //     lint_span,
+                //     "trailing zero-sized array in a struct which is not marked with a `repr` attribute",
+                //     None,
+                //     "consider annotating the struct definition with `#[repr(C)]` or another `repr` attribute",
+                // );
             }
         }
     }
@@ -91,7 +112,8 @@ fn has_repr_attr(cx: &LateContext<'tcx>, attrs: &[Attribute]) -> bool {
     // NOTE: there's at least four other ways to do this but I liked this one the best. (All five agreed
     // on all testcases (when i wrote this comment. I added a few since then).) Happy to use another;
     // they're in the commit history if you want to look (or I can go find them).
+    let sess = cx.tcx.sess(); // are captured values in closures evaluated once or every time?
     attrs
         .iter()
-        .any(|attr| !rustc_attr::find_repr_attrs(cx.tcx.sess(), attr).is_empty())
+        .any(|attr| !rustc_attr::find_repr_attrs(sess, attr).is_empty())
 }
-- 
cgit 1.4.1-3-g733a5


From d8bacf078a0c0d1dd3f15e6554338805f2d7256b Mon Sep 17 00:00:00 2001
From: Nathaniel Hamovitz <18648574+nhamovitz@users.noreply.github.com>
Date: Mon, 18 Oct 2021 15:33:11 -0700
Subject: All five `has_repr_attr` agree + are correct

---
 .../src/trailing_zero_sized_array_without_repr.rs  | 115 ++++++++++++---------
 1 file changed, 65 insertions(+), 50 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/trailing_zero_sized_array_without_repr.rs b/clippy_lints/src/trailing_zero_sized_array_without_repr.rs
index 48feb365ed8..10088ea55a9 100644
--- a/clippy_lints/src/trailing_zero_sized_array_without_repr.rs
+++ b/clippy_lints/src/trailing_zero_sized_array_without_repr.rs
@@ -1,11 +1,15 @@
-use clippy_utils::{diagnostics::{span_lint_and_help, span_lint_and_then, span_lint_and_sugg}, source::{indent_of, snippet}};
+use clippy_utils::{
+    diagnostics::{span_lint_and_help, span_lint_and_sugg, span_lint_and_then},
+    source::{indent_of, snippet},
+};
 use rustc_ast::Attribute;
 use rustc_errors::Applicability;
-use rustc_hir::{Item, ItemKind};
+use rustc_hir::{HirId, Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::dep_graph::DepContext;
-use rustc_middle::ty::Const;
+use rustc_middle::ty::{self as ty_mod, Const, ReprFlags};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::sym;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -38,48 +42,19 @@ declare_lint_pass!(TrailingZeroSizedArrayWithoutRepr => [TRAILING_ZERO_SIZED_ARR
 
 impl<'tcx> LateLintPass<'tcx> for TrailingZeroSizedArrayWithoutRepr {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
-        if is_struct_with_trailing_zero_sized_array(cx, item) {
-            // NOTE: This is to include attributes on the definition when we print the lint. If the convention
-            // is to not do that with struct definitions (I'm not sure), then this isn't necessary. (note: if
-            // you don't get rid of this, change `has_repr_attr` to `includes_repr_attr`).
-            let attrs = cx.tcx.get_attrs(item.def_id.to_def_id());
-            let first_attr = attrs.iter().min_by_key(|attr| attr.span.lo());
-            let lint_span = if let Some(first_attr) = first_attr {
-                first_attr.span.to(item.span)
-            } else {
-                item.span
-            };
-
-            if !has_repr_attr(cx, attrs) {
-                let suggestion_span = item.span.shrink_to_lo();
-                let indent = " ".repeat(indent_of(cx, item.span).unwrap_or(0));
-
-                span_lint_and_sugg(cx, TRAILING_ZERO_SIZED_ARRAY_WITHOUT_REPR, item.span, "trailing zero-sized array in a struct which is not marked with a `repr` attribute", "consider adding `#[repr(C)]` or another `repr` attribute", format!("#[repr(C)]\n{}", snippet(cx, item.span.shrink_to_lo().to(item.ident.span), "..")), Applicability::MaybeIncorrect);
-
-                // span_lint_and_then(
-                //     cx,
-                //     TRAILING_ZERO_SIZED_ARRAY_WITHOUT_REPR,
-                //     item.span,
-                //     "trailing zero-sized array in a struct which is not marked with a `repr` attribute",
-                //     |diag| {
-                //         let sugg = format!("#[repr(C)]\n{}", indent);
-                //         let sugg2 = format!("#[repr(C)]\n{}", item.ident.span);
-                //         diag.span_suggestion(item.span,
-                //                               "consider adding `#[repr(C)]` or another `repr` attribute",
-                //                               sugg2,
-                //                               Applicability::MaybeIncorrect);
-                //     }
-                // );
-              
-                // span_lint_and_help(
-                //     cx,
-                //     TRAILING_ZERO_SIZED_ARRAY_WITHOUT_REPR,
-                //     lint_span,
-                //     "trailing zero-sized array in a struct which is not marked with a `repr` attribute",
-                //     None,
-                //     "consider annotating the struct definition with `#[repr(C)]` or another `repr` attribute",
-                // );
-            }
+        dbg!(item.ident);
+        if is_struct_with_trailing_zero_sized_array(cx, item) && !has_repr_attr(cx, item) {
+            eprintln!("consider yourself linted 😎");
+            // span_lint_and_help(
+            //     cx,
+            //     TRAILING_ZERO_SIZED_ARRAY_WITHOUT_REPR,
+            //     item.span,
+            //     "trailing zero-sized array in a struct which is not marked with a `repr`
+            //     attribute",
+            //     None,
+            //     "consider annotating the struct definition with `#[repr(C)]` or another
+            //     `repr` attribute",
+            // );
         }
     }
 }
@@ -108,12 +83,52 @@ fn is_struct_with_trailing_zero_sized_array(cx: &LateContext<'tcx>, item: &'tcx
     }
 }
 
-fn has_repr_attr(cx: &LateContext<'tcx>, attrs: &[Attribute]) -> bool {
+fn has_repr_attr(cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) -> bool {
     // NOTE: there's at least four other ways to do this but I liked this one the best. (All five agreed
     // on all testcases (when i wrote this comment. I added a few since then).) Happy to use another;
     // they're in the commit history if you want to look (or I can go find them).
-    let sess = cx.tcx.sess(); // are captured values in closures evaluated once or every time?
-    attrs
-        .iter()
-        .any(|attr| !rustc_attr::find_repr_attrs(sess, attr).is_empty())
+
+    let attrs1 = cx.tcx.hir().attrs(item.hir_id());
+    let attrs2 = cx.tcx.get_attrs(item.def_id.to_def_id());
+
+    let res11 = {
+        let sess = cx.tcx.sess(); // are captured values in closures evaluated once or every time?
+        attrs1
+            .iter()
+            .any(|attr| !rustc_attr::find_repr_attrs(sess, attr).is_empty())
+    };
+    let res12 = { attrs1.iter().any(|attr| attr.has_name(sym::repr)) };
+
+    let res21 = {
+        let sess = cx.tcx.sess(); // are captured values in closures evaluated once or every time?
+        attrs2
+            .iter()
+            .any(|attr| !rustc_attr::find_repr_attrs(sess, attr).is_empty())
+    };
+    let res22 = { attrs2.iter().any(|attr| attr.has_name(sym::repr)) };
+
+    let res_adt = {
+        let ty = cx.tcx.type_of(item.def_id.to_def_id());
+        if let ty_mod::Adt(adt, _) = ty.kind() {
+            if adt.is_struct() {
+                let repr = adt.repr;
+                let repr_attr = ReprFlags::IS_C | ReprFlags::IS_TRANSPARENT | ReprFlags::IS_SIMD | ReprFlags::IS_LINEAR;
+                repr.int.is_some() || repr.align.is_some() || repr.pack.is_some() || repr.flags.intersects(repr_attr)
+            } else {
+                false
+            }
+        } else {
+            false
+        }
+    };
+
+    let all_same = (res11 && res12 && res21 && res22 && res_adt) || (!res11 && !res12 && !res21 && !res22 && !res_adt);
+
+    
+    dbg!((
+        (res11, res12, res21, res22, res_adt),
+        all_same,
+    ));
+
+    res12
 }
-- 
cgit 1.4.1-3-g733a5


From 18c863dd0ef490d8f069dba6263d7d5d6f8b3e13 Mon Sep 17 00:00:00 2001
From: Nathaniel Hamovitz <18648574+nhamovitz@users.noreply.github.com>
Date: Mon, 18 Oct 2021 16:53:05 -0700
Subject: Improve help message

---
 .../src/trailing_zero_sized_array_without_repr.rs  | 87 +++++++---------------
 1 file changed, 26 insertions(+), 61 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/trailing_zero_sized_array_without_repr.rs b/clippy_lints/src/trailing_zero_sized_array_without_repr.rs
index 10088ea55a9..0c9066fda82 100644
--- a/clippy_lints/src/trailing_zero_sized_array_without_repr.rs
+++ b/clippy_lints/src/trailing_zero_sized_array_without_repr.rs
@@ -2,12 +2,10 @@ use clippy_utils::{
     diagnostics::{span_lint_and_help, span_lint_and_sugg, span_lint_and_then},
     source::{indent_of, snippet},
 };
-use rustc_ast::Attribute;
 use rustc_errors::Applicability;
 use rustc_hir::{HirId, Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::dep_graph::DepContext;
-use rustc_middle::ty::{self as ty_mod, Const, ReprFlags};
+use rustc_middle::ty::{Const, TyS};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::sym;
 
@@ -43,18 +41,28 @@ declare_lint_pass!(TrailingZeroSizedArrayWithoutRepr => [TRAILING_ZERO_SIZED_ARR
 impl<'tcx> LateLintPass<'tcx> for TrailingZeroSizedArrayWithoutRepr {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
         dbg!(item.ident);
-        if is_struct_with_trailing_zero_sized_array(cx, item) && !has_repr_attr(cx, item) {
-            eprintln!("consider yourself linted 😎");
-            // span_lint_and_help(
-            //     cx,
-            //     TRAILING_ZERO_SIZED_ARRAY_WITHOUT_REPR,
-            //     item.span,
-            //     "trailing zero-sized array in a struct which is not marked with a `repr`
-            //     attribute",
-            //     None,
-            //     "consider annotating the struct definition with `#[repr(C)]` or another
-            //     `repr` attribute",
-            // );
+        if is_struct_with_trailing_zero_sized_array(cx, item) && !has_repr_attr(cx, item.hir_id()) {
+            let help_msg = format!(
+                "consider annotating {} with `#[repr(C)]` or another `repr` attribute",
+                cx.tcx
+                    .type_of(item.def_id)
+                    .ty_adt_def()
+                    .map(|adt_def| cx.tcx.def_path_str(adt_def.did))
+                    .unwrap_or_else(
+                        // I don't think this will ever be the case, since we made it through
+                        // `is_struct_with_trailing_zero_sized_array`, but I don't feel comfortable putting an `unwrap`
+                        || "the struct definition".to_string()
+                    )
+            );
+
+            span_lint_and_help(
+                cx,
+                TRAILING_ZERO_SIZED_ARRAY_WITHOUT_REPR,
+                item.span,
+                "trailing zero-sized array in a struct which is not marked with a `repr` attribute",
+                None,
+                &help_msg,
+            );
         }
     }
 }
@@ -83,52 +91,9 @@ fn is_struct_with_trailing_zero_sized_array(cx: &LateContext<'tcx>, item: &'tcx
     }
 }
 
-fn has_repr_attr(cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) -> bool {
+fn has_repr_attr(cx: &LateContext<'tcx>, hir_id: HirId) -> bool {
     // NOTE: there's at least four other ways to do this but I liked this one the best. (All five agreed
-    // on all testcases (when i wrote this comment. I added a few since then).) Happy to use another;
+    // on all testcases.) Happy to use another;
     // they're in the commit history if you want to look (or I can go find them).
-
-    let attrs1 = cx.tcx.hir().attrs(item.hir_id());
-    let attrs2 = cx.tcx.get_attrs(item.def_id.to_def_id());
-
-    let res11 = {
-        let sess = cx.tcx.sess(); // are captured values in closures evaluated once or every time?
-        attrs1
-            .iter()
-            .any(|attr| !rustc_attr::find_repr_attrs(sess, attr).is_empty())
-    };
-    let res12 = { attrs1.iter().any(|attr| attr.has_name(sym::repr)) };
-
-    let res21 = {
-        let sess = cx.tcx.sess(); // are captured values in closures evaluated once or every time?
-        attrs2
-            .iter()
-            .any(|attr| !rustc_attr::find_repr_attrs(sess, attr).is_empty())
-    };
-    let res22 = { attrs2.iter().any(|attr| attr.has_name(sym::repr)) };
-
-    let res_adt = {
-        let ty = cx.tcx.type_of(item.def_id.to_def_id());
-        if let ty_mod::Adt(adt, _) = ty.kind() {
-            if adt.is_struct() {
-                let repr = adt.repr;
-                let repr_attr = ReprFlags::IS_C | ReprFlags::IS_TRANSPARENT | ReprFlags::IS_SIMD | ReprFlags::IS_LINEAR;
-                repr.int.is_some() || repr.align.is_some() || repr.pack.is_some() || repr.flags.intersects(repr_attr)
-            } else {
-                false
-            }
-        } else {
-            false
-        }
-    };
-
-    let all_same = (res11 && res12 && res21 && res22 && res_adt) || (!res11 && !res12 && !res21 && !res22 && !res_adt);
-
-    
-    dbg!((
-        (res11, res12, res21, res22, res_adt),
-        all_same,
-    ));
-
-    res12
+    cx.tcx.hir().attrs(hir_id).iter().any(|attr| attr.has_name(sym::repr))
 }
-- 
cgit 1.4.1-3-g733a5


From 48cf9c284ac858545cdd22ef2efec9096e6c6b06 Mon Sep 17 00:00:00 2001
From: Nathaniel Hamovitz <18648574+nhamovitz@users.noreply.github.com>
Date: Mon, 18 Oct 2021 16:53:17 -0700
Subject: Don't need `rustc_attr` anymore

---
 clippy_lints/src/lib.rs | 1 -
 1 file changed, 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 1473a2f3095..de2ebcab667 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -21,7 +21,6 @@
 // (Currently there is no way to opt into sysroot crates without `extern crate`.)
 extern crate rustc_ast;
 extern crate rustc_ast_pretty;
-extern crate rustc_attr;
 extern crate rustc_data_structures;
 extern crate rustc_driver;
 extern crate rustc_errors;
-- 
cgit 1.4.1-3-g733a5


From d85f903c91d909534003ee2ff0e16316b20687dc Mon Sep 17 00:00:00 2001
From: Nathaniel Hamovitz <18648574+nhamovitz@users.noreply.github.com>
Date: Mon, 18 Oct 2021 17:07:51 -0700
Subject: !: this is the commit that demonstrates the ICE

---
 .../src/trailing_zero_sized_array_without_repr.rs  | 55 +++++++++-------------
 tests/ui/trailing_zero_sized_array_without_repr.rs |  8 +++-
 2 files changed, 29 insertions(+), 34 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/trailing_zero_sized_array_without_repr.rs b/clippy_lints/src/trailing_zero_sized_array_without_repr.rs
index 0c9066fda82..ac4bbded127 100644
--- a/clippy_lints/src/trailing_zero_sized_array_without_repr.rs
+++ b/clippy_lints/src/trailing_zero_sized_array_without_repr.rs
@@ -1,11 +1,6 @@
-use clippy_utils::{
-    diagnostics::{span_lint_and_help, span_lint_and_sugg, span_lint_and_then},
-    source::{indent_of, snippet},
-};
-use rustc_errors::Applicability;
+use clippy_utils::{consts::miri_to_const, consts::Constant, diagnostics::span_lint_and_help};
 use rustc_hir::{HirId, Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty::{Const, TyS};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::sym;
 
@@ -42,27 +37,15 @@ impl<'tcx> LateLintPass<'tcx> for TrailingZeroSizedArrayWithoutRepr {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
         dbg!(item.ident);
         if is_struct_with_trailing_zero_sized_array(cx, item) && !has_repr_attr(cx, item.hir_id()) {
-            let help_msg = format!(
-                "consider annotating {} with `#[repr(C)]` or another `repr` attribute",
-                cx.tcx
-                    .type_of(item.def_id)
-                    .ty_adt_def()
-                    .map(|adt_def| cx.tcx.def_path_str(adt_def.did))
-                    .unwrap_or_else(
-                        // I don't think this will ever be the case, since we made it through
-                        // `is_struct_with_trailing_zero_sized_array`, but I don't feel comfortable putting an `unwrap`
-                        || "the struct definition".to_string()
-                    )
-            );
-
-            span_lint_and_help(
-                cx,
-                TRAILING_ZERO_SIZED_ARRAY_WITHOUT_REPR,
-                item.span,
-                "trailing zero-sized array in a struct which is not marked with a `repr` attribute",
-                None,
-                &help_msg,
-            );
+            // span_lint_and_help(
+            //     cx,
+            //     TRAILING_ZERO_SIZED_ARRAY_WITHOUT_REPR,
+            //     item.span,
+            //     "trailing zero-sized array in a struct which is not marked with a `repr` attribute",
+            //     None,
+            //     "",
+            // );
+            eprintln!("consider yourself linted 😎");
         }
     }
 }
@@ -75,11 +58,19 @@ fn is_struct_with_trailing_zero_sized_array(cx: &LateContext<'tcx>, item: &'tcx
     if let ItemKind::Struct(data, _) = &item.kind {
         if let Some(last_field) = data.fields().last() {
             if let rustc_hir::TyKind::Array(_, length) = last_field.ty.kind {
-                // Then check if that that array zero-sized
-                let length_ldid = cx.tcx.hir().local_def_id(length.hir_id);
-                let length = Const::from_anon_const(cx.tcx, length_ldid);
-                let length = length.try_eval_usize(cx.tcx, cx.param_env);
-                length == Some(0)
+                let length_did = cx.tcx.hir().body_owner_def_id(length.body).to_def_id();
+                let ty = cx.tcx.type_of(length_did);
+                let length = cx
+                    .tcx
+                    // ICE happens in `const_eval_poly` according to my backtrace
+                    .const_eval_poly(length_did)
+                    .ok()
+                    .map(|val| rustc_middle::ty::Const::from_value(cx.tcx, val, ty));
+                if let Some(Constant::Int(length)) = length.and_then(miri_to_const){
+                    length == 0
+                } else {
+                    false
+                }
             } else {
                 false
             }
diff --git a/tests/ui/trailing_zero_sized_array_without_repr.rs b/tests/ui/trailing_zero_sized_array_without_repr.rs
index 52966c64db7..c00a772d2fe 100644
--- a/tests/ui/trailing_zero_sized_array_without_repr.rs
+++ b/tests/ui/trailing_zero_sized_array_without_repr.rs
@@ -1,6 +1,8 @@
 #![warn(clippy::trailing_zero_sized_array_without_repr)]
 #![feature(const_generics_defaults)]
 
+// ICE note: All of these are fine
+
 // Do lint:
 
 struct RarelyUseful {
@@ -23,8 +25,6 @@ struct OnlyAnotherAttribute {
     last: [usize; 0],
 }
 
-// NOTE: Unfortunately the attribute isn't included in the lint output. I'm not sure how to make it
-// show up.
 #[derive(Debug)]
 struct OnlyADeriveAttribute {
     field: i32,
@@ -150,12 +150,16 @@ struct TupleStructReprC(i32, [usize; 0]);
 
 type NamedTuple = (i32, [usize; 0]);
 
+// ICE note: and then this one crashes
+
 #[rustfmt::skip] // [rustfmt#4995](https://github.com/rust-lang/rustfmt/issues/4995)
 struct ConstParamZeroDefault<const N: usize = 0> {
     field: i32,
     last: [usize; N],
 }
 
+// ICE notes: presumably these as well but I'm not sure
+
 struct ConstParamNoDefault<const N: usize> {
     field: i32,
     last: [usize; N],
-- 
cgit 1.4.1-3-g733a5


From 6303d2d075131641ef325344124c71052d2bd3eb Mon Sep 17 00:00:00 2001
From: Nathaniel Hamovitz <18648574+nhamovitz@users.noreply.github.com>
Date: Mon, 18 Oct 2021 17:18:07 -0700
Subject: Revert "!: this is the commit that demonstrates the ICE"

This reverts commit d85f903c91d909534003ee2ff0e16316b20687dc.
---
 .../src/trailing_zero_sized_array_without_repr.rs  | 55 +++++++++++++---------
 tests/ui/trailing_zero_sized_array_without_repr.rs |  8 +---
 2 files changed, 34 insertions(+), 29 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/trailing_zero_sized_array_without_repr.rs b/clippy_lints/src/trailing_zero_sized_array_without_repr.rs
index ac4bbded127..0c9066fda82 100644
--- a/clippy_lints/src/trailing_zero_sized_array_without_repr.rs
+++ b/clippy_lints/src/trailing_zero_sized_array_without_repr.rs
@@ -1,6 +1,11 @@
-use clippy_utils::{consts::miri_to_const, consts::Constant, diagnostics::span_lint_and_help};
+use clippy_utils::{
+    diagnostics::{span_lint_and_help, span_lint_and_sugg, span_lint_and_then},
+    source::{indent_of, snippet},
+};
+use rustc_errors::Applicability;
 use rustc_hir::{HirId, Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::{Const, TyS};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::sym;
 
@@ -37,15 +42,27 @@ impl<'tcx> LateLintPass<'tcx> for TrailingZeroSizedArrayWithoutRepr {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
         dbg!(item.ident);
         if is_struct_with_trailing_zero_sized_array(cx, item) && !has_repr_attr(cx, item.hir_id()) {
-            // span_lint_and_help(
-            //     cx,
-            //     TRAILING_ZERO_SIZED_ARRAY_WITHOUT_REPR,
-            //     item.span,
-            //     "trailing zero-sized array in a struct which is not marked with a `repr` attribute",
-            //     None,
-            //     "",
-            // );
-            eprintln!("consider yourself linted 😎");
+            let help_msg = format!(
+                "consider annotating {} with `#[repr(C)]` or another `repr` attribute",
+                cx.tcx
+                    .type_of(item.def_id)
+                    .ty_adt_def()
+                    .map(|adt_def| cx.tcx.def_path_str(adt_def.did))
+                    .unwrap_or_else(
+                        // I don't think this will ever be the case, since we made it through
+                        // `is_struct_with_trailing_zero_sized_array`, but I don't feel comfortable putting an `unwrap`
+                        || "the struct definition".to_string()
+                    )
+            );
+
+            span_lint_and_help(
+                cx,
+                TRAILING_ZERO_SIZED_ARRAY_WITHOUT_REPR,
+                item.span,
+                "trailing zero-sized array in a struct which is not marked with a `repr` attribute",
+                None,
+                &help_msg,
+            );
         }
     }
 }
@@ -58,19 +75,11 @@ fn is_struct_with_trailing_zero_sized_array(cx: &LateContext<'tcx>, item: &'tcx
     if let ItemKind::Struct(data, _) = &item.kind {
         if let Some(last_field) = data.fields().last() {
             if let rustc_hir::TyKind::Array(_, length) = last_field.ty.kind {
-                let length_did = cx.tcx.hir().body_owner_def_id(length.body).to_def_id();
-                let ty = cx.tcx.type_of(length_did);
-                let length = cx
-                    .tcx
-                    // ICE happens in `const_eval_poly` according to my backtrace
-                    .const_eval_poly(length_did)
-                    .ok()
-                    .map(|val| rustc_middle::ty::Const::from_value(cx.tcx, val, ty));
-                if let Some(Constant::Int(length)) = length.and_then(miri_to_const){
-                    length == 0
-                } else {
-                    false
-                }
+                // Then check if that that array zero-sized
+                let length_ldid = cx.tcx.hir().local_def_id(length.hir_id);
+                let length = Const::from_anon_const(cx.tcx, length_ldid);
+                let length = length.try_eval_usize(cx.tcx, cx.param_env);
+                length == Some(0)
             } else {
                 false
             }
diff --git a/tests/ui/trailing_zero_sized_array_without_repr.rs b/tests/ui/trailing_zero_sized_array_without_repr.rs
index c00a772d2fe..52966c64db7 100644
--- a/tests/ui/trailing_zero_sized_array_without_repr.rs
+++ b/tests/ui/trailing_zero_sized_array_without_repr.rs
@@ -1,8 +1,6 @@
 #![warn(clippy::trailing_zero_sized_array_without_repr)]
 #![feature(const_generics_defaults)]
 
-// ICE note: All of these are fine
-
 // Do lint:
 
 struct RarelyUseful {
@@ -25,6 +23,8 @@ struct OnlyAnotherAttribute {
     last: [usize; 0],
 }
 
+// NOTE: Unfortunately the attribute isn't included in the lint output. I'm not sure how to make it
+// show up.
 #[derive(Debug)]
 struct OnlyADeriveAttribute {
     field: i32,
@@ -150,16 +150,12 @@ struct TupleStructReprC(i32, [usize; 0]);
 
 type NamedTuple = (i32, [usize; 0]);
 
-// ICE note: and then this one crashes
-
 #[rustfmt::skip] // [rustfmt#4995](https://github.com/rust-lang/rustfmt/issues/4995)
 struct ConstParamZeroDefault<const N: usize = 0> {
     field: i32,
     last: [usize; N],
 }
 
-// ICE notes: presumably these as well but I'm not sure
-
 struct ConstParamNoDefault<const N: usize> {
     field: i32,
     last: [usize; N],
-- 
cgit 1.4.1-3-g733a5


From c654cc56da81e9bebc37dd6c476b40c07d297cbe Mon Sep 17 00:00:00 2001
From: Nathaniel Hamovitz <18648574+nhamovitz@users.noreply.github.com>
Date: Mon, 18 Oct 2021 17:41:27 -0700
Subject: One more test + final tidying

---
 .../src/trailing_zero_sized_array_without_repr.rs  | 55 +++++++---------------
 tests/ui/trailing_zero_sized_array_without_repr.rs |  8 ++++
 .../trailing_zero_sized_array_without_repr.stderr  | 44 ++++++++++-------
 3 files changed, 53 insertions(+), 54 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/trailing_zero_sized_array_without_repr.rs b/clippy_lints/src/trailing_zero_sized_array_without_repr.rs
index 0c9066fda82..88ec471184c 100644
--- a/clippy_lints/src/trailing_zero_sized_array_without_repr.rs
+++ b/clippy_lints/src/trailing_zero_sized_array_without_repr.rs
@@ -1,11 +1,7 @@
-use clippy_utils::{
-    diagnostics::{span_lint_and_help, span_lint_and_sugg, span_lint_and_then},
-    source::{indent_of, snippet},
-};
-use rustc_errors::Applicability;
+use clippy_utils::diagnostics::span_lint_and_help;
 use rustc_hir::{HirId, Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty::{Const, TyS};
+use rustc_middle::ty::Const;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::sym;
 
@@ -40,54 +36,39 @@ declare_lint_pass!(TrailingZeroSizedArrayWithoutRepr => [TRAILING_ZERO_SIZED_ARR
 
 impl<'tcx> LateLintPass<'tcx> for TrailingZeroSizedArrayWithoutRepr {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
-        dbg!(item.ident);
         if is_struct_with_trailing_zero_sized_array(cx, item) && !has_repr_attr(cx, item.hir_id()) {
-            let help_msg = format!(
-                "consider annotating {} with `#[repr(C)]` or another `repr` attribute",
-                cx.tcx
-                    .type_of(item.def_id)
-                    .ty_adt_def()
-                    .map(|adt_def| cx.tcx.def_path_str(adt_def.did))
-                    .unwrap_or_else(
-                        // I don't think this will ever be the case, since we made it through
-                        // `is_struct_with_trailing_zero_sized_array`, but I don't feel comfortable putting an `unwrap`
-                        || "the struct definition".to_string()
-                    )
-            );
-
             span_lint_and_help(
                 cx,
                 TRAILING_ZERO_SIZED_ARRAY_WITHOUT_REPR,
                 item.span,
                 "trailing zero-sized array in a struct which is not marked with a `repr` attribute",
                 None,
-                &help_msg,
+                &format!(
+                    "consider annotating `{}` with `#[repr(C)]` or another `repr` attribute",
+                    cx.tcx.def_path_str(item.def_id.to_def_id())
+                ),
             );
         }
     }
 }
 
 fn is_struct_with_trailing_zero_sized_array(cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) -> bool {
-    // TODO: when finalized, replace with an `if_chain`. I have it like this because my rust-analyzer
-    // doesn't work when it's an `if_chain`.
+    if_chain! {
+        // First check if last field is an array
+        if let ItemKind::Struct(data, _) = &item.kind;
+        if let Some(last_field) = data.fields().last();
+        if let rustc_hir::TyKind::Array(_, length) = last_field.ty.kind;
 
-    // First check if last field is an array
-    if let ItemKind::Struct(data, _) = &item.kind {
-        if let Some(last_field) = data.fields().last() {
-            if let rustc_hir::TyKind::Array(_, length) = last_field.ty.kind {
-                // Then check if that that array zero-sized
-                let length_ldid = cx.tcx.hir().local_def_id(length.hir_id);
-                let length = Const::from_anon_const(cx.tcx, length_ldid);
-                let length = length.try_eval_usize(cx.tcx, cx.param_env);
-                length == Some(0)
-            } else {
-                false
-            }
+        // Then check if that that array zero-sized
+        let length_ldid = cx.tcx.hir().local_def_id(length.hir_id);
+        let length = Const::from_anon_const(cx.tcx, length_ldid);
+        let length = length.try_eval_usize(cx.tcx, cx.param_env);
+        if let Some(length) = length;
+        then {
+            length == 0
         } else {
             false
         }
-    } else {
-        false
     }
 }
 
diff --git a/tests/ui/trailing_zero_sized_array_without_repr.rs b/tests/ui/trailing_zero_sized_array_without_repr.rs
index 52966c64db7..dee7f811540 100644
--- a/tests/ui/trailing_zero_sized_array_without_repr.rs
+++ b/tests/ui/trailing_zero_sized_array_without_repr.rs
@@ -46,6 +46,14 @@ struct ZeroSizedWithConstFunction {
     last: [usize; compute_zero()],
 }
 
+const fn compute_zero_from_arg(x: usize) -> usize {
+    x - 1
+}
+struct ZeroSizedWithConstFunction2 {
+    field: i32,
+    last: [usize; compute_zero_from_arg(1)],
+}
+
 struct ZeroSizedArrayWrapper([usize; 0]);
 
 struct TupleStruct(i32, [usize; 0]);
diff --git a/tests/ui/trailing_zero_sized_array_without_repr.stderr b/tests/ui/trailing_zero_sized_array_without_repr.stderr
index e5714386c8b..93c607bbf38 100644
--- a/tests/ui/trailing_zero_sized_array_without_repr.stderr
+++ b/tests/ui/trailing_zero_sized_array_without_repr.stderr
@@ -8,7 +8,7 @@ LL | | }
    | |_^
    |
    = note: `-D clippy::trailing-zero-sized-array-without-repr` implied by `-D warnings`
-   = help: consider annotating the struct definition with `#[repr(C)]` or another `repr` attribute
+   = help: consider annotating `RarelyUseful` with `#[repr(C)]` or another `repr` attribute
 
 error: trailing zero-sized array in a struct which is not marked with a `repr` attribute
   --> $DIR/trailing_zero_sized_array_without_repr.rs:11:1
@@ -18,7 +18,7 @@ LL | |     first_and_last: [usize; 0],
 LL | | }
    | |_^
    |
-   = help: consider annotating the struct definition with `#[repr(C)]` or another `repr` attribute
+   = help: consider annotating `OnlyField` with `#[repr(C)]` or another `repr` attribute
 
 error: trailing zero-sized array in a struct which is not marked with a `repr` attribute
   --> $DIR/trailing_zero_sized_array_without_repr.rs:15:1
@@ -29,19 +29,18 @@ LL | |     last: [T; 0],
 LL | | }
    | |_^
    |
-   = help: consider annotating the struct definition with `#[repr(C)]` or another `repr` attribute
+   = help: consider annotating `GenericArrayType` with `#[repr(C)]` or another `repr` attribute
 
 error: trailing zero-sized array in a struct which is not marked with a `repr` attribute
-  --> $DIR/trailing_zero_sized_array_without_repr.rs:20:1
+  --> $DIR/trailing_zero_sized_array_without_repr.rs:21:1
    |
-LL | / #[must_use]
-LL | | struct OnlyAnotherAttribute {
+LL | / struct OnlyAnotherAttribute {
 LL | |     field: i32,
 LL | |     last: [usize; 0],
 LL | | }
    | |_^
    |
-   = help: consider annotating the struct definition with `#[repr(C)]` or another `repr` attribute
+   = help: consider annotating `OnlyAnotherAttribute` with `#[repr(C)]` or another `repr` attribute
 
 error: trailing zero-sized array in a struct which is not marked with a `repr` attribute
   --> $DIR/trailing_zero_sized_array_without_repr.rs:29:1
@@ -52,7 +51,7 @@ LL | |     last: [usize; 0],
 LL | | }
    | |_^
    |
-   = help: consider annotating the struct definition with `#[repr(C)]` or another `repr` attribute
+   = help: consider annotating `OnlyADeriveAttribute` with `#[repr(C)]` or another `repr` attribute
 
 error: trailing zero-sized array in a struct which is not marked with a `repr` attribute
   --> $DIR/trailing_zero_sized_array_without_repr.rs:35:1
@@ -63,7 +62,7 @@ LL | |     last: [usize; ZERO],
 LL | | }
    | |_^
    |
-   = help: consider annotating the struct definition with `#[repr(C)]` or another `repr` attribute
+   = help: consider annotating `ZeroSizedWithConst` with `#[repr(C)]` or another `repr` attribute
 
 error: trailing zero-sized array in a struct which is not marked with a `repr` attribute
   --> $DIR/trailing_zero_sized_array_without_repr.rs:44:1
@@ -74,26 +73,37 @@ LL | |     last: [usize; compute_zero()],
 LL | | }
    | |_^
    |
-   = help: consider annotating the struct definition with `#[repr(C)]` or another `repr` attribute
+   = help: consider annotating `ZeroSizedWithConstFunction` with `#[repr(C)]` or another `repr` attribute
 
 error: trailing zero-sized array in a struct which is not marked with a `repr` attribute
-  --> $DIR/trailing_zero_sized_array_without_repr.rs:49:1
+  --> $DIR/trailing_zero_sized_array_without_repr.rs:52:1
+   |
+LL | / struct ZeroSizedWithConstFunction2 {
+LL | |     field: i32,
+LL | |     last: [usize; compute_zero_from_arg(1)],
+LL | | }
+   | |_^
+   |
+   = help: consider annotating `ZeroSizedWithConstFunction2` with `#[repr(C)]` or another `repr` attribute
+
+error: trailing zero-sized array in a struct which is not marked with a `repr` attribute
+  --> $DIR/trailing_zero_sized_array_without_repr.rs:57:1
    |
 LL | struct ZeroSizedArrayWrapper([usize; 0]);
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: consider annotating the struct definition with `#[repr(C)]` or another `repr` attribute
+   = help: consider annotating `ZeroSizedArrayWrapper` with `#[repr(C)]` or another `repr` attribute
 
 error: trailing zero-sized array in a struct which is not marked with a `repr` attribute
-  --> $DIR/trailing_zero_sized_array_without_repr.rs:51:1
+  --> $DIR/trailing_zero_sized_array_without_repr.rs:59:1
    |
 LL | struct TupleStruct(i32, [usize; 0]);
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: consider annotating the struct definition with `#[repr(C)]` or another `repr` attribute
+   = help: consider annotating `TupleStruct` with `#[repr(C)]` or another `repr` attribute
 
 error: trailing zero-sized array in a struct which is not marked with a `repr` attribute
-  --> $DIR/trailing_zero_sized_array_without_repr.rs:53:1
+  --> $DIR/trailing_zero_sized_array_without_repr.rs:61:1
    |
 LL | / struct LotsOfFields {
 LL | |     f1: u32,
@@ -104,7 +114,7 @@ LL | |     last: [usize; 0],
 LL | | }
    | |_^
    |
-   = help: consider annotating the struct definition with `#[repr(C)]` or another `repr` attribute
+   = help: consider annotating `LotsOfFields` with `#[repr(C)]` or another `repr` attribute
 
-error: aborting due to 10 previous errors
+error: aborting due to 11 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From bc32be0fecd9a99c981323699bbd5a8e485220f0 Mon Sep 17 00:00:00 2001
From: Nathaniel Hamovitz <18648574+nhamovitz@users.noreply.github.com>
Date: Mon, 18 Oct 2021 18:03:00 -0700
Subject: Remove comment

---
 clippy_lints/src/trailing_zero_sized_array_without_repr.rs | 3 ---
 1 file changed, 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/trailing_zero_sized_array_without_repr.rs b/clippy_lints/src/trailing_zero_sized_array_without_repr.rs
index 88ec471184c..cc1671af82d 100644
--- a/clippy_lints/src/trailing_zero_sized_array_without_repr.rs
+++ b/clippy_lints/src/trailing_zero_sized_array_without_repr.rs
@@ -73,8 +73,5 @@ fn is_struct_with_trailing_zero_sized_array(cx: &LateContext<'tcx>, item: &'tcx
 }
 
 fn has_repr_attr(cx: &LateContext<'tcx>, hir_id: HirId) -> bool {
-    // NOTE: there's at least four other ways to do this but I liked this one the best. (All five agreed
-    // on all testcases.) Happy to use another;
-    // they're in the commit history if you want to look (or I can go find them).
     cx.tcx.hir().attrs(hir_id).iter().any(|attr| attr.has_name(sym::repr))
 }
-- 
cgit 1.4.1-3-g733a5


From 02b1f266d6a98cd9dc430554b80971705c5de09b Mon Sep 17 00:00:00 2001
From: Nathaniel Hamovitz <18648574+nhamovitz@users.noreply.github.com>
Date: Mon, 18 Oct 2021 18:20:35 -0700
Subject: Remove explicit lifetime

---
 clippy_lints/src/trailing_zero_sized_array_without_repr.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/trailing_zero_sized_array_without_repr.rs b/clippy_lints/src/trailing_zero_sized_array_without_repr.rs
index cc1671af82d..5fa13605ae3 100644
--- a/clippy_lints/src/trailing_zero_sized_array_without_repr.rs
+++ b/clippy_lints/src/trailing_zero_sized_array_without_repr.rs
@@ -72,6 +72,6 @@ fn is_struct_with_trailing_zero_sized_array(cx: &LateContext<'tcx>, item: &'tcx
     }
 }
 
-fn has_repr_attr(cx: &LateContext<'tcx>, hir_id: HirId) -> bool {
+fn has_repr_attr(cx: &LateContext<'_>, hir_id: HirId) -> bool {
     cx.tcx.hir().attrs(hir_id).iter().any(|attr| attr.has_name(sym::repr))
 }
-- 
cgit 1.4.1-3-g733a5


From 4c8e8169720d54db905142a18502ab2a2dad63a0 Mon Sep 17 00:00:00 2001
From: Nathaniel Hamovitz <18648574+nhamovitz@users.noreply.github.com>
Date: Mon, 18 Oct 2021 18:32:00 -0700
Subject: Use real type in doc examples

---
 clippy_lints/src/trailing_zero_sized_array_without_repr.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/trailing_zero_sized_array_without_repr.rs b/clippy_lints/src/trailing_zero_sized_array_without_repr.rs
index 5fa13605ae3..bfe0049dfae 100644
--- a/clippy_lints/src/trailing_zero_sized_array_without_repr.rs
+++ b/clippy_lints/src/trailing_zero_sized_array_without_repr.rs
@@ -15,17 +15,17 @@ declare_clippy_lint! {
     /// ### Example
     /// ```rust
     /// struct RarelyUseful {
-    ///     some_field: usize,
-    ///     last: [SomeType; 0],
+    ///     some_field: u32,
+    ///     last: [u32; 0],
     /// }
     /// ```
     ///
-    /// Use instead:
+    /// Use instead:    
     /// ```rust
     /// #[repr(C)]
     /// struct MoreOftenUseful {
     ///     some_field: usize,
-    ///     last: [SomeType; 0],
+    ///     last: [u32; 0],
     /// }
     /// ```
     pub TRAILING_ZERO_SIZED_ARRAY_WITHOUT_REPR,
-- 
cgit 1.4.1-3-g733a5


From 5283d24b38631941790082b41ae3c99c698fc346 Mon Sep 17 00:00:00 2001
From: Nathaniel Hamovitz <18648574+nhamovitz@users.noreply.github.com>
Date: Mon, 18 Oct 2021 18:42:01 -0700
Subject: formatting 🙃
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 clippy_lints/src/trailing_zero_sized_array_without_repr.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/trailing_zero_sized_array_without_repr.rs b/clippy_lints/src/trailing_zero_sized_array_without_repr.rs
index bfe0049dfae..2e579aecab0 100644
--- a/clippy_lints/src/trailing_zero_sized_array_without_repr.rs
+++ b/clippy_lints/src/trailing_zero_sized_array_without_repr.rs
@@ -20,7 +20,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     ///
-    /// Use instead:    
+    /// Use instead:
     /// ```rust
     /// #[repr(C)]
     /// struct MoreOftenUseful {
-- 
cgit 1.4.1-3-g733a5


From 687f3925da6481d938be0d787808328f8a93fdee Mon Sep 17 00:00:00 2001
From: dswij <dswijj@gmail.com>
Date: Tue, 19 Oct 2021 18:26:50 +0800
Subject: Cover `Result` for `question_mark`

---
 clippy_lints/src/question_mark.rs | 76 ++++++++++++++++++++++++++++-----------
 1 file changed, 55 insertions(+), 21 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/question_mark.rs b/clippy_lints/src/question_mark.rs
index aa6d254e7a5..c1ee20c370a 100644
--- a/clippy_lints/src/question_mark.rs
+++ b/clippy_lints/src/question_mark.rs
@@ -4,10 +4,10 @@ use clippy_utils::is_lang_ctor;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{eq_expr_value, path_to_local_id};
+use clippy_utils::{eq_expr_value, path_to_local, path_to_local_id};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
-use rustc_hir::LangItem::{OptionNone, OptionSome};
+use rustc_hir::LangItem::{OptionNone, OptionSome, ResultOk};
 use rustc_hir::{BindingAnnotation, Block, Expr, ExprKind, PatKind, StmtKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -48,16 +48,25 @@ impl QuestionMark {
     /// }
     /// ```
     ///
+    /// ```ignore
+    /// if result.is_err() {
+    ///     return result;
+    /// }
+    /// ```
+    ///
     /// If it matches, it will suggest to use the question mark operator instead
-    fn check_is_none_and_early_return_none(cx: &LateContext<'_>, expr: &Expr<'_>) {
+    fn check_is_none_or_err_and_early_return(cx: &LateContext<'_>, expr: &Expr<'_>) {
         if_chain! {
             if let Some(higher::If { cond, then, r#else }) = higher::If::hir(expr);
             if let ExprKind::MethodCall(segment, _, args, _) = &cond.kind;
-            if segment.ident.name == sym!(is_none);
-            if Self::expression_returns_none(cx, then);
             if let Some(subject) = args.get(0);
-            if Self::is_option(cx, subject);
-
+            if (Self::is_option(cx, subject)
+                && Self::expression_returns_none(cx, then)
+                && segment.ident.name == sym!(is_none))
+                ||
+                (Self::is_result(cx, subject)
+                && Self::expression_returns_unmodified_err(cx, then, subject)
+                && segment.ident.name == sym!(is_err));
             then {
                 let mut applicability = Applicability::MachineApplicable;
                 let receiver_str = &Sugg::hir_with_applicability(cx, subject, "..", &mut applicability);
@@ -95,31 +104,29 @@ impl QuestionMark {
         }
     }
 
-    fn check_if_let_some_and_early_return_none(cx: &LateContext<'_>, expr: &Expr<'_>) {
+    fn check_if_let_some_or_err_and_early_return(cx: &LateContext<'_>, expr: &Expr<'_>) {
         if_chain! {
             if let Some(higher::IfLet { let_pat, let_expr, if_then, if_else: Some(if_else) })
                 = higher::IfLet::hir(cx, expr);
-            if Self::is_option(cx, let_expr);
-
             if let PatKind::TupleStruct(ref path1, fields, None) = let_pat.kind;
-            if is_lang_ctor(cx, path1, OptionSome);
+            if (Self::is_option(cx, let_expr)
+                && Self::expression_returns_none(cx, if_else)
+                && is_lang_ctor(cx, path1, OptionSome))
+                ||
+                (Self::is_result(cx, let_expr)
+                 && Self::expression_returns_unmodified_err(cx, if_else, let_expr)
+                 && is_lang_ctor(cx, path1, ResultOk));
+
             if let PatKind::Binding(annot, bind_id, _, _) = fields[0].kind;
             let by_ref = matches!(annot, BindingAnnotation::Ref | BindingAnnotation::RefMut);
-
             if let ExprKind::Block(block, None) = if_then.kind;
             if block.stmts.is_empty();
             if let Some(trailing_expr) = &block.expr;
             if path_to_local_id(trailing_expr, bind_id);
-
-            if Self::expression_returns_none(cx, if_else);
             then {
                 let mut applicability = Applicability::MachineApplicable;
                 let receiver_str = snippet_with_applicability(cx, let_expr.span, "..", &mut applicability);
-                let replacement = format!(
-                    "{}{}?",
-                    receiver_str,
-                    if by_ref { ".as_ref()" } else { "" },
-                );
+                let replacement = format!("{}{}?", receiver_str, if by_ref { ".as_ref()" } else { "" },);
 
                 span_lint_and_sugg(
                     cx,
@@ -146,6 +153,12 @@ impl QuestionMark {
         is_type_diagnostic_item(cx, expr_ty, sym::Option)
     }
 
+    fn is_result(cx: &LateContext<'_>, expression: &Expr<'_>) -> bool {
+        let expr_ty = cx.typeck_results().expr_ty(expression);
+
+        is_type_diagnostic_item(cx, expr_ty, sym::Result)
+    }
+
     fn expression_returns_none(cx: &LateContext<'_>, expression: &Expr<'_>) -> bool {
         match expression.kind {
             ExprKind::Block(block, _) => {
@@ -161,6 +174,27 @@ impl QuestionMark {
         }
     }
 
+    fn expression_returns_unmodified_err(
+        cx: &LateContext<'_>,
+        expression: &Expr<'_>,
+        origin_hir_id: &Expr<'_>,
+    ) -> bool {
+        match expression.kind {
+            ExprKind::Block(block, _) => {
+                if let Some(return_expression) = Self::return_expression(block) {
+                    return Self::expression_returns_unmodified_err(cx, return_expression, origin_hir_id);
+                }
+
+                false
+            },
+            ExprKind::Ret(Some(expr)) | ExprKind::Call(expr, _) => {
+                Self::expression_returns_unmodified_err(cx, expr, origin_hir_id)
+            },
+            ExprKind::Path(_) => path_to_local(expression) == path_to_local(origin_hir_id),
+            _ => false,
+        }
+    }
+
     fn return_expression<'tcx>(block: &Block<'tcx>) -> Option<&'tcx Expr<'tcx>> {
         // Check if last expression is a return statement. Then, return the expression
         if_chain! {
@@ -189,7 +223,7 @@ impl QuestionMark {
 
 impl<'tcx> LateLintPass<'tcx> for QuestionMark {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        Self::check_is_none_and_early_return_none(cx, expr);
-        Self::check_if_let_some_and_early_return_none(cx, expr);
+        Self::check_is_none_or_err_and_early_return(cx, expr);
+        Self::check_if_let_some_or_err_and_early_return(cx, expr);
     }
 }
-- 
cgit 1.4.1-3-g733a5


From e88c956e1e18a99af55af00c8917f8e975d534c5 Mon Sep 17 00:00:00 2001
From: Andre Bogus <bogusandre@gmail.com>
Date: Tue, 12 Oct 2021 19:18:22 +0200
Subject: avoid `eq_op` in test code

---
 clippy_lints/src/eq_op.rs | 11 +++++--
 clippy_utils/src/lib.rs   | 78 +++++++++++++++++++++++++++++++++++++++++------
 tests/compile-test.rs     | 14 +++++++++
 tests/ui_test/eq_op.rs    | 15 +++++++++
 4 files changed, 105 insertions(+), 13 deletions(-)
 create mode 100644 tests/ui_test/eq_op.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/eq_op.rs b/clippy_lints/src/eq_op.rs
index 51d5094e8c9..655560afd42 100644
--- a/clippy_lints/src/eq_op.rs
+++ b/clippy_lints/src/eq_op.rs
@@ -1,7 +1,9 @@
 use clippy_utils::diagnostics::{multispan_sugg, span_lint, span_lint_and_then};
 use clippy_utils::source::snippet;
 use clippy_utils::ty::{implements_trait, is_copy};
-use clippy_utils::{ast_utils::is_useless_with_eq_exprs, eq_expr_value, higher, in_macro, is_expn_of};
+use clippy_utils::{
+    ast_utils::is_useless_with_eq_exprs, eq_expr_value, higher, in_macro, is_expn_of, is_in_test_function,
+};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, BorrowKind, Expr, ExprKind, StmtKind};
@@ -81,7 +83,7 @@ impl<'tcx> LateLintPass<'tcx> for EqOp {
                         if macro_args.len() == 2;
                         let (lhs, rhs) = (macro_args[0], macro_args[1]);
                         if eq_expr_value(cx, lhs, rhs);
-
+                        if !is_in_test_function(cx.tcx, e.hir_id);
                         then {
                             span_lint(
                                 cx,
@@ -108,7 +110,10 @@ impl<'tcx> LateLintPass<'tcx> for EqOp {
             if macro_with_not_op(&left.kind) || macro_with_not_op(&right.kind) {
                 return;
             }
-            if is_useless_with_eq_exprs(op.node.into()) && eq_expr_value(cx, left, right) {
+            if is_useless_with_eq_exprs(op.node.into())
+                && eq_expr_value(cx, left, right)
+                && !is_in_test_function(cx.tcx, e.hir_id)
+            {
                 span_lint(
                     cx,
                     EQ_OP,
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 09eee78f0d1..c540e1ebc9c 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -69,11 +69,13 @@ use rustc_hir::def::{DefKind, Res};
 use rustc_hir::def_id::DefId;
 use rustc_hir::hir_id::{HirIdMap, HirIdSet};
 use rustc_hir::intravisit::{self, walk_expr, ErasedMap, FnKind, NestedVisitorMap, Visitor};
+use rustc_hir::itemlikevisit::ItemLikeVisitor;
 use rustc_hir::LangItem::{OptionNone, ResultErr, ResultOk};
 use rustc_hir::{
-    def, Arm, BindingAnnotation, Block, Body, Constness, Destination, Expr, ExprKind, FnDecl, GenericArgs, HirId, Impl,
-    ImplItem, ImplItemKind, IsAsync, Item, ItemKind, LangItem, Local, MatchSource, Mutability, Node, Param, Pat,
-    PatKind, Path, PathSegment, PrimTy, QPath, Stmt, StmtKind, TraitItem, TraitItemKind, TraitRef, TyKind, UnOp,
+    def, Arm, BindingAnnotation, Block, Body, Constness, Destination, Expr, ExprKind, FnDecl, ForeignItem, GenericArgs,
+    HirId, Impl, ImplItem, ImplItemKind, IsAsync, Item, ItemKind, LangItem, Local, MatchSource, Mutability, Node,
+    Param, Pat, PatKind, Path, PathSegment, PrimTy, QPath, Stmt, StmtKind, TraitItem, TraitItemKind, TraitRef, TyKind,
+    UnOp,
 };
 use rustc_lint::{LateContext, Level, Lint, LintContext};
 use rustc_middle::hir::exports::Export;
@@ -2064,16 +2066,72 @@ pub fn is_hir_ty_cfg_dependant(cx: &LateContext<'_>, ty: &hir::Ty<'_>) -> bool {
     false
 }
 
-/// Checks whether item either has `test` attribute applied, or
-/// is a module with `test` in its name.
-pub fn is_test_module_or_function(tcx: TyCtxt<'_>, item: &Item<'_>) -> bool {
-    if let Some(def_id) = tcx.hir().opt_local_def_id(item.hir_id()) {
-        if tcx.has_attr(def_id.to_def_id(), sym::test) {
-            return true;
+struct VisitConstTestStruct<'tcx> {
+    tcx: TyCtxt<'tcx>,
+    names: Vec<Symbol>,
+    found: bool,
+}
+impl<'hir> ItemLikeVisitor<'hir> for VisitConstTestStruct<'hir> {
+    fn visit_item(&mut self, item: &Item<'_>) {
+        if let ItemKind::Const(ty, _body) = item.kind {
+            if let TyKind::Path(QPath::Resolved(_, path)) = ty.kind {
+                // We could also check for the type name `test::TestDescAndFn`
+                // and the `#[rustc_test_marker]` attribute?
+                if let Res::Def(DefKind::Struct, _) = path.res {
+                    let has_test_marker = self
+                        .tcx
+                        .hir()
+                        .attrs(item.hir_id())
+                        .iter()
+                        .any(|a| a.has_name(sym::rustc_test_marker));
+                    if has_test_marker && self.names.contains(&item.ident.name) {
+                        self.found = true;
+                    }
+                }
+            }
         }
     }
+    fn visit_trait_item(&mut self, _: &TraitItem<'_>) {}
+    fn visit_impl_item(&mut self, _: &ImplItem<'_>) {}
+    fn visit_foreign_item(&mut self, _: &ForeignItem<'_>) {}
+}
 
-    matches!(item.kind, ItemKind::Mod(..)) && item.ident.name.as_str().split('_').any(|a| a == "test" || a == "tests")
+/// Checks if the function containing the given `HirId` is a `#[test]` function
+///
+/// Note: If you use this function, please add a `#[test]` case in `tests/ui_test`.
+pub fn is_in_test_function(tcx: TyCtxt<'_>, id: hir::HirId) -> bool {
+    let names: Vec<_> = tcx
+        .hir()
+        .parent_iter(id)
+        // Since you can nest functions we need to collect all until we leave
+        // function scope
+        .filter_map(|(_id, node)| {
+            if let Node::Item(item) = node {
+                if let ItemKind::Fn(_, _, _) = item.kind {
+                    return Some(item.ident.name);
+                }
+            }
+            None
+        })
+        .collect();
+    let parent_mod = tcx.parent_module(id);
+    let mut vis = VisitConstTestStruct {
+        tcx,
+        names,
+        found: false,
+    };
+    tcx.hir().visit_item_likes_in_module(parent_mod, &mut vis);
+    vis.found
+}
+
+/// Checks whether item either has `test` attribute appelied, or
+/// is a module with `test` in its name.
+///
+/// Note: If you use this function, please add a `#[test]` case in `tests/ui_test`.
+pub fn is_test_module_or_function(tcx: TyCtxt<'_>, item: &Item<'_>) -> bool {
+    is_in_test_function(tcx, item.hir_id())
+        || matches!(item.kind, ItemKind::Mod(..))
+            && item.ident.name.as_str().split('_').any(|a| a == "test" || a == "tests")
 }
 
 macro_rules! op_utils {
diff --git a/tests/compile-test.rs b/tests/compile-test.rs
index e8b1640c869..c15835ef299 100644
--- a/tests/compile-test.rs
+++ b/tests/compile-test.rs
@@ -149,6 +149,19 @@ fn run_ui(cfg: &mut compiletest::Config) {
     compiletest::run_tests(cfg);
 }
 
+fn run_ui_test(cfg: &mut compiletest::Config) {
+    cfg.mode = TestMode::Ui;
+    cfg.src_base = Path::new("tests").join("ui_test");
+    let _g = VarGuard::set("CARGO_MANIFEST_DIR", std::fs::canonicalize("tests").unwrap());
+    let rustcflags = cfg.target_rustcflags.get_or_insert_with(Default::default);
+    let len = rustcflags.len();
+    rustcflags.push_str(" --test");
+    compiletest::run_tests(cfg);
+    if let Some(ref mut flags) = &mut cfg.target_rustcflags {
+        flags.truncate(len);
+    }
+}
+
 fn run_internal_tests(cfg: &mut compiletest::Config) {
     // only run internal tests with the internal-tests feature
     if !RUN_INTERNAL_TESTS {
@@ -312,6 +325,7 @@ fn compile_test() {
     prepare_env();
     let mut config = default_config();
     run_ui(&mut config);
+    run_ui_test(&mut config);
     run_ui_toml(&mut config);
     run_ui_cargo(&mut config);
     run_internal_tests(&mut config);
diff --git a/tests/ui_test/eq_op.rs b/tests/ui_test/eq_op.rs
new file mode 100644
index 00000000000..f2f5f1e588e
--- /dev/null
+++ b/tests/ui_test/eq_op.rs
@@ -0,0 +1,15 @@
+#[warn(clippy::eq_op)]
+#[test]
+fn eq_op_shouldnt_trigger_in_tests() {
+    let a = 1;
+    let result = a + 1 == 1 + a;
+    assert!(result);
+}
+
+#[test]
+fn eq_op_macros_shouldnt_trigger_in_tests() {
+    let a = 1;
+    let b = 2;
+    assert_eq!(a, a);
+    assert_eq!(a + b, b + a);
+}
-- 
cgit 1.4.1-3-g733a5


From 0f9f591e30074bf5e31e4ca279280425685f33ff Mon Sep 17 00:00:00 2001
From: Nathaniel Hamovitz <18648574+nhamovitz@users.noreply.github.com>
Date: Tue, 19 Oct 2021 14:33:43 -0700
Subject: Rename lint

---
 CHANGELOG.md                                       |   2 +-
 clippy_lints/src/lib.register_lints.rs             |   2 +-
 clippy_lints/src/lib.register_nursery.rs           |   2 +-
 clippy_lints/src/lib.rs                            |   4 +-
 clippy_lints/src/trailing_empty_array.rs           |  77 +++++++++
 .../src/trailing_zero_sized_array_without_repr.rs  |  77 ---------
 tests/ui/trailing_empty_array.rs                   | 186 +++++++++++++++++++++
 tests/ui/trailing_empty_array.stderr               | 120 +++++++++++++
 tests/ui/trailing_zero_sized_array_without_repr.rs | 186 ---------------------
 .../trailing_zero_sized_array_without_repr.stderr  | 120 -------------
 10 files changed, 388 insertions(+), 388 deletions(-)
 create mode 100644 clippy_lints/src/trailing_empty_array.rs
 delete mode 100644 clippy_lints/src/trailing_zero_sized_array_without_repr.rs
 create mode 100644 tests/ui/trailing_empty_array.rs
 create mode 100644 tests/ui/trailing_empty_array.stderr
 delete mode 100644 tests/ui/trailing_zero_sized_array_without_repr.rs
 delete mode 100644 tests/ui/trailing_zero_sized_array_without_repr.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 0cf19a6f0f1..49499324ea0 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3021,7 +3021,7 @@ Released 2018-09-13
 [`too_many_arguments`]: https://rust-lang.github.io/rust-clippy/master/index.html#too_many_arguments
 [`too_many_lines`]: https://rust-lang.github.io/rust-clippy/master/index.html#too_many_lines
 [`toplevel_ref_arg`]: https://rust-lang.github.io/rust-clippy/master/index.html#toplevel_ref_arg
-[`trailing_zero_sized_array_without_repr`]: https://rust-lang.github.io/rust-clippy/master/index.html#trailing_zero_sized_array_without_repr
+[`trailing_empty_array`]: https://rust-lang.github.io/rust-clippy/master/index.html#trailing_empty_array
 [`trait_duplication_in_bounds`]: https://rust-lang.github.io/rust-clippy/master/index.html#trait_duplication_in_bounds
 [`transmute_bytes_to_str`]: https://rust-lang.github.io/rust-clippy/master/index.html#transmute_bytes_to_str
 [`transmute_float_to_int`]: https://rust-lang.github.io/rust-clippy/master/index.html#transmute_float_to_int
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index af0629beb36..37d8d7f422f 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -443,7 +443,7 @@ store.register_lints(&[
     temporary_assignment::TEMPORARY_ASSIGNMENT,
     to_digit_is_some::TO_DIGIT_IS_SOME,
     to_string_in_display::TO_STRING_IN_DISPLAY,
-    trailing_zero_sized_array_without_repr::TRAILING_ZERO_SIZED_ARRAY_WITHOUT_REPR,
+    trailing_empty_array::TRAILING_EMPTY_ARRAY,
     trait_bounds::TRAIT_DUPLICATION_IN_BOUNDS,
     trait_bounds::TYPE_REPETITION_IN_BOUNDS,
     transmute::CROSSPOINTER_TRANSMUTE,
diff --git a/clippy_lints/src/lib.register_nursery.rs b/clippy_lints/src/lib.register_nursery.rs
index eab0e5b90f1..1e54482a8da 100644
--- a/clippy_lints/src/lib.register_nursery.rs
+++ b/clippy_lints/src/lib.register_nursery.rs
@@ -25,7 +25,7 @@ store.register_group(true, "clippy::nursery", Some("clippy_nursery"), vec![
     LintId::of(regex::TRIVIAL_REGEX),
     LintId::of(strings::STRING_LIT_AS_BYTES),
     LintId::of(suspicious_operation_groupings::SUSPICIOUS_OPERATION_GROUPINGS),
-    LintId::of(trailing_zero_sized_array_without_repr::TRAILING_ZERO_SIZED_ARRAY_WITHOUT_REPR),
+    LintId::of(trailing_empty_array::TRAILING_EMPTY_ARRAY),
     LintId::of(transmute::USELESS_TRANSMUTE),
     LintId::of(use_self::USE_SELF),
 ])
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index de2ebcab667..58e4c061892 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -355,7 +355,7 @@ mod tabs_in_doc_comments;
 mod temporary_assignment;
 mod to_digit_is_some;
 mod to_string_in_display;
-mod trailing_zero_sized_array_without_repr;
+mod trailing_empty_array;
 mod trait_bounds;
 mod transmute;
 mod transmuting_null;
@@ -778,7 +778,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(move || Box::new(undocumented_unsafe_blocks::UndocumentedUnsafeBlocks::default()));
     store.register_late_pass(|| Box::new(match_str_case_mismatch::MatchStrCaseMismatch));
     store.register_late_pass(move || Box::new(format_args::FormatArgs));
-    store.register_late_pass(|| Box::new(trailing_zero_sized_array_without_repr::TrailingZeroSizedArrayWithoutRepr));
+    store.register_late_pass(|| Box::new(trailing_empty_array::TrailingEmptyArray));
 
 }
 
diff --git a/clippy_lints/src/trailing_empty_array.rs b/clippy_lints/src/trailing_empty_array.rs
new file mode 100644
index 00000000000..c216a1f81ea
--- /dev/null
+++ b/clippy_lints/src/trailing_empty_array.rs
@@ -0,0 +1,77 @@
+use clippy_utils::diagnostics::span_lint_and_help;
+use rustc_hir::{HirId, Item, ItemKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::Const;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::sym;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Displays a warning when a struct with a trailing zero-sized array is declared without a `repr` attribute.
+    ///
+    /// ### Why is this bad?
+    /// Zero-sized arrays aren't very useful in Rust itself, so such a struct is likely being created to pass to C code or in some other situation where control over memory layout matters (for example, in conjuction with manual allocation to make it easy to compute the offset of the array). Either way, `#[repr(C)]` (or another `repr` attribute) is needed.
+    ///
+    /// ### Example
+    /// ```rust
+    /// struct RarelyUseful {
+    ///     some_field: u32,
+    ///     last: [u32; 0],
+    /// }
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust
+    /// #[repr(C)]
+    /// struct MoreOftenUseful {
+    ///     some_field: usize,
+    ///     last: [u32; 0],
+    /// }
+    /// ```
+    pub TRAILING_EMPTY_ARRAY,
+    nursery,
+    "struct with a trailing zero-sized array but without `#[repr(C)]` or another `repr` attribute"
+}
+declare_lint_pass!(TrailingEmptyArray => [TRAILING_EMPTY_ARRAY]);
+
+impl<'tcx> LateLintPass<'tcx> for TrailingEmptyArray {
+    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
+        if is_struct_with_trailing_zero_sized_array(cx, item) && !has_repr_attr(cx, item.hir_id()) {
+            span_lint_and_help(
+                cx,
+                TRAILING_EMPTY_ARRAY,
+                item.span,
+                "trailing zero-sized array in a struct which is not marked with a `repr` attribute",
+                None,
+                &format!(
+                    "consider annotating `{}` with `#[repr(C)]` or another `repr` attribute",
+                    cx.tcx.def_path_str(item.def_id.to_def_id())
+                ),
+            );
+        }
+    }
+}
+
+fn is_struct_with_trailing_zero_sized_array(cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) -> bool {
+    if_chain! {
+        // First check if last field is an array
+        if let ItemKind::Struct(data, _) = &item.kind;
+        if let Some(last_field) = data.fields().last();
+        if let rustc_hir::TyKind::Array(_, length) = last_field.ty.kind;
+
+        // Then check if that that array zero-sized
+        let length_ldid = cx.tcx.hir().local_def_id(length.hir_id);
+        let length = Const::from_anon_const(cx.tcx, length_ldid);
+        let length = length.try_eval_usize(cx.tcx, cx.param_env);
+        if let Some(length) = length;
+        then {
+            length == 0
+        } else {
+            false
+        }
+    }
+}
+
+fn has_repr_attr(cx: &LateContext<'_>, hir_id: HirId) -> bool {
+    cx.tcx.hir().attrs(hir_id).iter().any(|attr| attr.has_name(sym::repr))
+}
diff --git a/clippy_lints/src/trailing_zero_sized_array_without_repr.rs b/clippy_lints/src/trailing_zero_sized_array_without_repr.rs
deleted file mode 100644
index 2e579aecab0..00000000000
--- a/clippy_lints/src/trailing_zero_sized_array_without_repr.rs
+++ /dev/null
@@ -1,77 +0,0 @@
-use clippy_utils::diagnostics::span_lint_and_help;
-use rustc_hir::{HirId, Item, ItemKind};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty::Const;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::sym;
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Displays a warning when a struct with a trailing zero-sized array is declared without a `repr` attribute.
-    ///
-    /// ### Why is this bad?
-    /// Zero-sized arrays aren't very useful in Rust itself, so such a struct is likely being created to pass to C code or in some other situation where control over memory layout matters (for example, in conjuction with manual allocation to make it easy to compute the offset of the array). Either way, `#[repr(C)]` (or another `repr` attribute) is needed.
-    ///
-    /// ### Example
-    /// ```rust
-    /// struct RarelyUseful {
-    ///     some_field: u32,
-    ///     last: [u32; 0],
-    /// }
-    /// ```
-    ///
-    /// Use instead:
-    /// ```rust
-    /// #[repr(C)]
-    /// struct MoreOftenUseful {
-    ///     some_field: usize,
-    ///     last: [u32; 0],
-    /// }
-    /// ```
-    pub TRAILING_ZERO_SIZED_ARRAY_WITHOUT_REPR,
-    nursery,
-    "struct with a trailing zero-sized array but without `#[repr(C)]` or another `repr` attribute"
-}
-declare_lint_pass!(TrailingZeroSizedArrayWithoutRepr => [TRAILING_ZERO_SIZED_ARRAY_WITHOUT_REPR]);
-
-impl<'tcx> LateLintPass<'tcx> for TrailingZeroSizedArrayWithoutRepr {
-    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
-        if is_struct_with_trailing_zero_sized_array(cx, item) && !has_repr_attr(cx, item.hir_id()) {
-            span_lint_and_help(
-                cx,
-                TRAILING_ZERO_SIZED_ARRAY_WITHOUT_REPR,
-                item.span,
-                "trailing zero-sized array in a struct which is not marked with a `repr` attribute",
-                None,
-                &format!(
-                    "consider annotating `{}` with `#[repr(C)]` or another `repr` attribute",
-                    cx.tcx.def_path_str(item.def_id.to_def_id())
-                ),
-            );
-        }
-    }
-}
-
-fn is_struct_with_trailing_zero_sized_array(cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) -> bool {
-    if_chain! {
-        // First check if last field is an array
-        if let ItemKind::Struct(data, _) = &item.kind;
-        if let Some(last_field) = data.fields().last();
-        if let rustc_hir::TyKind::Array(_, length) = last_field.ty.kind;
-
-        // Then check if that that array zero-sized
-        let length_ldid = cx.tcx.hir().local_def_id(length.hir_id);
-        let length = Const::from_anon_const(cx.tcx, length_ldid);
-        let length = length.try_eval_usize(cx.tcx, cx.param_env);
-        if let Some(length) = length;
-        then {
-            length == 0
-        } else {
-            false
-        }
-    }
-}
-
-fn has_repr_attr(cx: &LateContext<'_>, hir_id: HirId) -> bool {
-    cx.tcx.hir().attrs(hir_id).iter().any(|attr| attr.has_name(sym::repr))
-}
diff --git a/tests/ui/trailing_empty_array.rs b/tests/ui/trailing_empty_array.rs
new file mode 100644
index 00000000000..501c9eb7651
--- /dev/null
+++ b/tests/ui/trailing_empty_array.rs
@@ -0,0 +1,186 @@
+#![warn(clippy::trailing_empty_array)]
+#![feature(const_generics_defaults)]
+
+// Do lint:
+
+struct RarelyUseful {
+    field: i32,
+    last: [usize; 0],
+}
+
+struct OnlyField {
+    first_and_last: [usize; 0],
+}
+
+struct GenericArrayType<T> {
+    field: i32,
+    last: [T; 0],
+}
+
+#[must_use]
+struct OnlyAnotherAttribute {
+    field: i32,
+    last: [usize; 0],
+}
+
+#[derive(Debug)]
+struct OnlyADeriveAttribute {
+    field: i32,
+    last: [usize; 0],
+}
+
+const ZERO: usize = 0;
+struct ZeroSizedWithConst {
+    field: i32,
+    last: [usize; ZERO],
+}
+
+#[allow(clippy::eq_op)]
+const fn compute_zero() -> usize {
+    (4 + 6) - (2 * 5)
+}
+struct ZeroSizedWithConstFunction {
+    field: i32,
+    last: [usize; compute_zero()],
+}
+
+const fn compute_zero_from_arg(x: usize) -> usize {
+    x - 1
+}
+struct ZeroSizedWithConstFunction2 {
+    field: i32,
+    last: [usize; compute_zero_from_arg(1)],
+}
+
+struct ZeroSizedArrayWrapper([usize; 0]);
+
+struct TupleStruct(i32, [usize; 0]);
+
+struct LotsOfFields {
+    f1: u32,
+    f2: u32,
+    f3: u32,
+    f4: u32,
+    f5: u32,
+    f6: u32,
+    f7: u32,
+    f8: u32,
+    f9: u32,
+    f10: u32,
+    f11: u32,
+    f12: u32,
+    f13: u32,
+    f14: u32,
+    f15: u32,
+    f16: u32,
+    last: [usize; 0],
+}
+
+// Don't lint
+
+#[repr(C)]
+struct GoodReason {
+    field: i32,
+    last: [usize; 0],
+}
+
+#[repr(C)]
+struct OnlyFieldWithReprC {
+    first_and_last: [usize; 0],
+}
+
+struct NonZeroSizedArray {
+    field: i32,
+    last: [usize; 1],
+}
+
+struct NotLastField {
+    f1: u32,
+    zero_sized: [usize; 0],
+    last: i32,
+}
+
+const ONE: usize = 1;
+struct NonZeroSizedWithConst {
+    field: i32,
+    last: [usize; ONE],
+}
+
+#[derive(Debug)]
+#[repr(C)]
+struct AlsoADeriveAttribute {
+    field: i32,
+    last: [usize; 0],
+}
+
+#[must_use]
+#[repr(C)]
+struct AlsoAnotherAttribute {
+    field: i32,
+    last: [usize; 0],
+}
+
+#[repr(packed)]
+struct ReprPacked {
+    field: i32,
+    last: [usize; 0],
+}
+
+#[repr(C, packed)]
+struct ReprCPacked {
+    field: i32,
+    last: [usize; 0],
+}
+
+#[repr(align(64))]
+struct ReprAlign {
+    field: i32,
+    last: [usize; 0],
+}
+#[repr(C, align(64))]
+struct ReprCAlign {
+    field: i32,
+    last: [usize; 0],
+}
+
+// NOTE: because of https://doc.rust-lang.org/stable/reference/type-layout.html#primitive-representation-of-enums-with-fields and I'm not sure when in the compilation pipeline that would happen
+#[repr(C)]
+enum DontLintAnonymousStructsFromDesuraging {
+    A(u32),
+    B(f32, [u64; 0]),
+    C { x: u32, y: [u64; 0] },
+}
+
+#[repr(C)]
+struct TupleStructReprC(i32, [usize; 0]);
+
+type NamedTuple = (i32, [usize; 0]);
+
+#[rustfmt::skip] // [rustfmt#4995](https://github.com/rust-lang/rustfmt/issues/4995)
+struct ConstParamZeroDefault<const N: usize = 0> {
+    field: i32,
+    last: [usize; N],
+}
+
+struct ConstParamNoDefault<const N: usize> {
+    field: i32,
+    last: [usize; N],
+}
+
+#[rustfmt::skip] 
+struct ConstParamNonZeroDefault<const N: usize = 1> {
+    field: i32,
+    last: [usize; N],
+}
+
+struct TwoGenericParams<T, const N: usize> {
+    field: i32,
+    last: [T; N],
+}
+
+type A = ConstParamZeroDefault;
+type B = ConstParamZeroDefault<0>;
+type C = ConstParamNoDefault<0>;
+type D = ConstParamNonZeroDefault<0>;
+
+fn main() {}
diff --git a/tests/ui/trailing_empty_array.stderr b/tests/ui/trailing_empty_array.stderr
new file mode 100644
index 00000000000..d88aa0504b5
--- /dev/null
+++ b/tests/ui/trailing_empty_array.stderr
@@ -0,0 +1,120 @@
+error: trailing zero-sized array in a struct which is not marked with a `repr` attribute
+  --> $DIR/trailing_empty_array.rs:6:1
+   |
+LL | / struct RarelyUseful {
+LL | |     field: i32,
+LL | |     last: [usize; 0],
+LL | | }
+   | |_^
+   |
+   = note: `-D clippy::trailing-empty-array` implied by `-D warnings`
+   = help: consider annotating `RarelyUseful` with `#[repr(C)]` or another `repr` attribute
+
+error: trailing zero-sized array in a struct which is not marked with a `repr` attribute
+  --> $DIR/trailing_empty_array.rs:11:1
+   |
+LL | / struct OnlyField {
+LL | |     first_and_last: [usize; 0],
+LL | | }
+   | |_^
+   |
+   = help: consider annotating `OnlyField` with `#[repr(C)]` or another `repr` attribute
+
+error: trailing zero-sized array in a struct which is not marked with a `repr` attribute
+  --> $DIR/trailing_empty_array.rs:15:1
+   |
+LL | / struct GenericArrayType<T> {
+LL | |     field: i32,
+LL | |     last: [T; 0],
+LL | | }
+   | |_^
+   |
+   = help: consider annotating `GenericArrayType` with `#[repr(C)]` or another `repr` attribute
+
+error: trailing zero-sized array in a struct which is not marked with a `repr` attribute
+  --> $DIR/trailing_empty_array.rs:21:1
+   |
+LL | / struct OnlyAnotherAttribute {
+LL | |     field: i32,
+LL | |     last: [usize; 0],
+LL | | }
+   | |_^
+   |
+   = help: consider annotating `OnlyAnotherAttribute` with `#[repr(C)]` or another `repr` attribute
+
+error: trailing zero-sized array in a struct which is not marked with a `repr` attribute
+  --> $DIR/trailing_empty_array.rs:27:1
+   |
+LL | / struct OnlyADeriveAttribute {
+LL | |     field: i32,
+LL | |     last: [usize; 0],
+LL | | }
+   | |_^
+   |
+   = help: consider annotating `OnlyADeriveAttribute` with `#[repr(C)]` or another `repr` attribute
+
+error: trailing zero-sized array in a struct which is not marked with a `repr` attribute
+  --> $DIR/trailing_empty_array.rs:33:1
+   |
+LL | / struct ZeroSizedWithConst {
+LL | |     field: i32,
+LL | |     last: [usize; ZERO],
+LL | | }
+   | |_^
+   |
+   = help: consider annotating `ZeroSizedWithConst` with `#[repr(C)]` or another `repr` attribute
+
+error: trailing zero-sized array in a struct which is not marked with a `repr` attribute
+  --> $DIR/trailing_empty_array.rs:42:1
+   |
+LL | / struct ZeroSizedWithConstFunction {
+LL | |     field: i32,
+LL | |     last: [usize; compute_zero()],
+LL | | }
+   | |_^
+   |
+   = help: consider annotating `ZeroSizedWithConstFunction` with `#[repr(C)]` or another `repr` attribute
+
+error: trailing zero-sized array in a struct which is not marked with a `repr` attribute
+  --> $DIR/trailing_empty_array.rs:50:1
+   |
+LL | / struct ZeroSizedWithConstFunction2 {
+LL | |     field: i32,
+LL | |     last: [usize; compute_zero_from_arg(1)],
+LL | | }
+   | |_^
+   |
+   = help: consider annotating `ZeroSizedWithConstFunction2` with `#[repr(C)]` or another `repr` attribute
+
+error: trailing zero-sized array in a struct which is not marked with a `repr` attribute
+  --> $DIR/trailing_empty_array.rs:55:1
+   |
+LL | struct ZeroSizedArrayWrapper([usize; 0]);
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider annotating `ZeroSizedArrayWrapper` with `#[repr(C)]` or another `repr` attribute
+
+error: trailing zero-sized array in a struct which is not marked with a `repr` attribute
+  --> $DIR/trailing_empty_array.rs:57:1
+   |
+LL | struct TupleStruct(i32, [usize; 0]);
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider annotating `TupleStruct` with `#[repr(C)]` or another `repr` attribute
+
+error: trailing zero-sized array in a struct which is not marked with a `repr` attribute
+  --> $DIR/trailing_empty_array.rs:59:1
+   |
+LL | / struct LotsOfFields {
+LL | |     f1: u32,
+LL | |     f2: u32,
+LL | |     f3: u32,
+...  |
+LL | |     last: [usize; 0],
+LL | | }
+   | |_^
+   |
+   = help: consider annotating `LotsOfFields` with `#[repr(C)]` or another `repr` attribute
+
+error: aborting due to 11 previous errors
+
diff --git a/tests/ui/trailing_zero_sized_array_without_repr.rs b/tests/ui/trailing_zero_sized_array_without_repr.rs
deleted file mode 100644
index bfa3af0bbc3..00000000000
--- a/tests/ui/trailing_zero_sized_array_without_repr.rs
+++ /dev/null
@@ -1,186 +0,0 @@
-#![warn(clippy::trailing_zero_sized_array_without_repr)]
-#![feature(const_generics_defaults)]
-
-// Do lint:
-
-struct RarelyUseful {
-    field: i32,
-    last: [usize; 0],
-}
-
-struct OnlyField {
-    first_and_last: [usize; 0],
-}
-
-struct GenericArrayType<T> {
-    field: i32,
-    last: [T; 0],
-}
-
-#[must_use]
-struct OnlyAnotherAttribute {
-    field: i32,
-    last: [usize; 0],
-}
-
-#[derive(Debug)]
-struct OnlyADeriveAttribute {
-    field: i32,
-    last: [usize; 0],
-}
-
-const ZERO: usize = 0;
-struct ZeroSizedWithConst {
-    field: i32,
-    last: [usize; ZERO],
-}
-
-#[allow(clippy::eq_op)]
-const fn compute_zero() -> usize {
-    (4 + 6) - (2 * 5)
-}
-struct ZeroSizedWithConstFunction {
-    field: i32,
-    last: [usize; compute_zero()],
-}
-
-const fn compute_zero_from_arg(x: usize) -> usize {
-    x - 1
-}
-struct ZeroSizedWithConstFunction2 {
-    field: i32,
-    last: [usize; compute_zero_from_arg(1)],
-}
-
-struct ZeroSizedArrayWrapper([usize; 0]);
-
-struct TupleStruct(i32, [usize; 0]);
-
-struct LotsOfFields {
-    f1: u32,
-    f2: u32,
-    f3: u32,
-    f4: u32,
-    f5: u32,
-    f6: u32,
-    f7: u32,
-    f8: u32,
-    f9: u32,
-    f10: u32,
-    f11: u32,
-    f12: u32,
-    f13: u32,
-    f14: u32,
-    f15: u32,
-    f16: u32,
-    last: [usize; 0],
-}
-
-// Don't lint
-
-#[repr(C)]
-struct GoodReason {
-    field: i32,
-    last: [usize; 0],
-}
-
-#[repr(C)]
-struct OnlyFieldWithReprC {
-    first_and_last: [usize; 0],
-}
-
-struct NonZeroSizedArray {
-    field: i32,
-    last: [usize; 1],
-}
-
-struct NotLastField {
-    f1: u32,
-    zero_sized: [usize; 0],
-    last: i32,
-}
-
-const ONE: usize = 1;
-struct NonZeroSizedWithConst {
-    field: i32,
-    last: [usize; ONE],
-}
-
-#[derive(Debug)]
-#[repr(C)]
-struct AlsoADeriveAttribute {
-    field: i32,
-    last: [usize; 0],
-}
-
-#[must_use]
-#[repr(C)]
-struct AlsoAnotherAttribute {
-    field: i32,
-    last: [usize; 0],
-}
-
-#[repr(packed)]
-struct ReprPacked {
-    field: i32,
-    last: [usize; 0],
-}
-
-#[repr(C, packed)]
-struct ReprCPacked {
-    field: i32,
-    last: [usize; 0],
-}
-
-#[repr(align(64))]
-struct ReprAlign {
-    field: i32,
-    last: [usize; 0],
-}
-#[repr(C, align(64))]
-struct ReprCAlign {
-    field: i32,
-    last: [usize; 0],
-}
-
-// NOTE: because of https://doc.rust-lang.org/stable/reference/type-layout.html#primitive-representation-of-enums-with-fields and I'm not sure when in the compilation pipeline that would happen
-#[repr(C)]
-enum DontLintAnonymousStructsFromDesuraging {
-    A(u32),
-    B(f32, [u64; 0]),
-    C { x: u32, y: [u64; 0] },
-}
-
-#[repr(C)]
-struct TupleStructReprC(i32, [usize; 0]);
-
-type NamedTuple = (i32, [usize; 0]);
-
-#[rustfmt::skip] // [rustfmt#4995](https://github.com/rust-lang/rustfmt/issues/4995)
-struct ConstParamZeroDefault<const N: usize = 0> {
-    field: i32,
-    last: [usize; N],
-}
-
-struct ConstParamNoDefault<const N: usize> {
-    field: i32,
-    last: [usize; N],
-}
-
-#[rustfmt::skip] 
-struct ConstParamNonZeroDefault<const N: usize = 1> {
-    field: i32,
-    last: [usize; N],
-}
-
-struct TwoGenericParams<T, const N: usize> {
-    field: i32,
-    last: [T; N],
-}
-
-type A = ConstParamZeroDefault;
-type B = ConstParamZeroDefault<0>;
-type C = ConstParamNoDefault<0>;
-type D = ConstParamNonZeroDefault<0>;
-
-fn main() {}
diff --git a/tests/ui/trailing_zero_sized_array_without_repr.stderr b/tests/ui/trailing_zero_sized_array_without_repr.stderr
deleted file mode 100644
index 93c607bbf38..00000000000
--- a/tests/ui/trailing_zero_sized_array_without_repr.stderr
+++ /dev/null
@@ -1,120 +0,0 @@
-error: trailing zero-sized array in a struct which is not marked with a `repr` attribute
-  --> $DIR/trailing_zero_sized_array_without_repr.rs:6:1
-   |
-LL | / struct RarelyUseful {
-LL | |     field: i32,
-LL | |     last: [usize; 0],
-LL | | }
-   | |_^
-   |
-   = note: `-D clippy::trailing-zero-sized-array-without-repr` implied by `-D warnings`
-   = help: consider annotating `RarelyUseful` with `#[repr(C)]` or another `repr` attribute
-
-error: trailing zero-sized array in a struct which is not marked with a `repr` attribute
-  --> $DIR/trailing_zero_sized_array_without_repr.rs:11:1
-   |
-LL | / struct OnlyField {
-LL | |     first_and_last: [usize; 0],
-LL | | }
-   | |_^
-   |
-   = help: consider annotating `OnlyField` with `#[repr(C)]` or another `repr` attribute
-
-error: trailing zero-sized array in a struct which is not marked with a `repr` attribute
-  --> $DIR/trailing_zero_sized_array_without_repr.rs:15:1
-   |
-LL | / struct GenericArrayType<T> {
-LL | |     field: i32,
-LL | |     last: [T; 0],
-LL | | }
-   | |_^
-   |
-   = help: consider annotating `GenericArrayType` with `#[repr(C)]` or another `repr` attribute
-
-error: trailing zero-sized array in a struct which is not marked with a `repr` attribute
-  --> $DIR/trailing_zero_sized_array_without_repr.rs:21:1
-   |
-LL | / struct OnlyAnotherAttribute {
-LL | |     field: i32,
-LL | |     last: [usize; 0],
-LL | | }
-   | |_^
-   |
-   = help: consider annotating `OnlyAnotherAttribute` with `#[repr(C)]` or another `repr` attribute
-
-error: trailing zero-sized array in a struct which is not marked with a `repr` attribute
-  --> $DIR/trailing_zero_sized_array_without_repr.rs:29:1
-   |
-LL | / struct OnlyADeriveAttribute {
-LL | |     field: i32,
-LL | |     last: [usize; 0],
-LL | | }
-   | |_^
-   |
-   = help: consider annotating `OnlyADeriveAttribute` with `#[repr(C)]` or another `repr` attribute
-
-error: trailing zero-sized array in a struct which is not marked with a `repr` attribute
-  --> $DIR/trailing_zero_sized_array_without_repr.rs:35:1
-   |
-LL | / struct ZeroSizedWithConst {
-LL | |     field: i32,
-LL | |     last: [usize; ZERO],
-LL | | }
-   | |_^
-   |
-   = help: consider annotating `ZeroSizedWithConst` with `#[repr(C)]` or another `repr` attribute
-
-error: trailing zero-sized array in a struct which is not marked with a `repr` attribute
-  --> $DIR/trailing_zero_sized_array_without_repr.rs:44:1
-   |
-LL | / struct ZeroSizedWithConstFunction {
-LL | |     field: i32,
-LL | |     last: [usize; compute_zero()],
-LL | | }
-   | |_^
-   |
-   = help: consider annotating `ZeroSizedWithConstFunction` with `#[repr(C)]` or another `repr` attribute
-
-error: trailing zero-sized array in a struct which is not marked with a `repr` attribute
-  --> $DIR/trailing_zero_sized_array_without_repr.rs:52:1
-   |
-LL | / struct ZeroSizedWithConstFunction2 {
-LL | |     field: i32,
-LL | |     last: [usize; compute_zero_from_arg(1)],
-LL | | }
-   | |_^
-   |
-   = help: consider annotating `ZeroSizedWithConstFunction2` with `#[repr(C)]` or another `repr` attribute
-
-error: trailing zero-sized array in a struct which is not marked with a `repr` attribute
-  --> $DIR/trailing_zero_sized_array_without_repr.rs:57:1
-   |
-LL | struct ZeroSizedArrayWrapper([usize; 0]);
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: consider annotating `ZeroSizedArrayWrapper` with `#[repr(C)]` or another `repr` attribute
-
-error: trailing zero-sized array in a struct which is not marked with a `repr` attribute
-  --> $DIR/trailing_zero_sized_array_without_repr.rs:59:1
-   |
-LL | struct TupleStruct(i32, [usize; 0]);
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: consider annotating `TupleStruct` with `#[repr(C)]` or another `repr` attribute
-
-error: trailing zero-sized array in a struct which is not marked with a `repr` attribute
-  --> $DIR/trailing_zero_sized_array_without_repr.rs:61:1
-   |
-LL | / struct LotsOfFields {
-LL | |     f1: u32,
-LL | |     f2: u32,
-LL | |     f3: u32,
-...  |
-LL | |     last: [usize; 0],
-LL | | }
-   | |_^
-   |
-   = help: consider annotating `LotsOfFields` with `#[repr(C)]` or another `repr` attribute
-
-error: aborting due to 11 previous errors
-
-- 
cgit 1.4.1-3-g733a5


From 6b22bba902e873a9cceb3f5649d10a195699267d Mon Sep 17 00:00:00 2001
From: F3real <stefan92ff@yandex.com>
Date: Mon, 4 Oct 2021 23:49:53 +0200
Subject: Lint on underscore variable assignment

Fix tests after no_effect update

Add a drop testcase

Don't lint _ variables in macro expansion

Address review comments and update tests

Don't shadow unnecessary operation lint if no_effect is allowed

Revert shadowing change and remove no_effect allows

Update clippy_lints/src/no_effect.rs

Co-authored-by: Takayuki Nakata <f.seasons017@gmail.com>

Update clippy_lints/src/no_effect.rs

Co-authored-by: Takayuki Nakata <f.seasons017@gmail.com>

Address review comments
---
 CHANGELOG.md                              |   1 +
 clippy_lints/src/lib.register_lints.rs    |   1 +
 clippy_lints/src/lib.register_pedantic.rs |   1 +
 clippy_lints/src/no_effect.rs             | 179 +++++++++++++++++++-----------
 tests/ui/cfg_attr_rustfmt.fixed           |   2 +-
 tests/ui/cfg_attr_rustfmt.rs              |   2 +-
 tests/ui/no_effect.rs                     |   8 +-
 tests/ui/no_effect.stderr                 |  28 ++++-
 tests/ui/option_if_let_else.fixed         |   3 +-
 tests/ui/option_if_let_else.rs            |   3 +-
 tests/ui/option_if_let_else.stderr        |  28 ++---
 11 files changed, 170 insertions(+), 86 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index b1e837d363a..b7a7a421532 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2899,6 +2899,7 @@ Released 2018-09-13
 [`new_ret_no_self`]: https://rust-lang.github.io/rust-clippy/master/index.html#new_ret_no_self
 [`new_without_default`]: https://rust-lang.github.io/rust-clippy/master/index.html#new_without_default
 [`no_effect`]: https://rust-lang.github.io/rust-clippy/master/index.html#no_effect
+[`no_effect_underscore_binding`]: https://rust-lang.github.io/rust-clippy/master/index.html#no_effect_underscore_binding
 [`non_ascii_literal`]: https://rust-lang.github.io/rust-clippy/master/index.html#non_ascii_literal
 [`non_octal_unix_permissions`]: https://rust-lang.github.io/rust-clippy/master/index.html#non_octal_unix_permissions
 [`non_send_fields_in_send_ty`]: https://rust-lang.github.io/rust-clippy/master/index.html#non_send_fields_in_send_ty
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 7d81fafe4c9..e5fe22ad394 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -362,6 +362,7 @@ store.register_lints(&[
     neg_multiply::NEG_MULTIPLY,
     new_without_default::NEW_WITHOUT_DEFAULT,
     no_effect::NO_EFFECT,
+    no_effect::NO_EFFECT_UNDERSCORE_BINDING,
     no_effect::UNNECESSARY_OPERATION,
     non_copy_const::BORROW_INTERIOR_MUTABLE_CONST,
     non_copy_const::DECLARE_INTERIOR_MUTABLE_CONST,
diff --git a/clippy_lints/src/lib.register_pedantic.rs b/clippy_lints/src/lib.register_pedantic.rs
index 6533b94e82b..268349d2848 100644
--- a/clippy_lints/src/lib.register_pedantic.rs
+++ b/clippy_lints/src/lib.register_pedantic.rs
@@ -72,6 +72,7 @@ store.register_group(true, "clippy::pedantic", Some("clippy_pedantic"), vec![
     LintId::of(needless_continue::NEEDLESS_CONTINUE),
     LintId::of(needless_for_each::NEEDLESS_FOR_EACH),
     LintId::of(needless_pass_by_value::NEEDLESS_PASS_BY_VALUE),
+    LintId::of(no_effect::NO_EFFECT_UNDERSCORE_BINDING),
     LintId::of(non_expressive_names::MANY_SINGLE_CHAR_NAMES),
     LintId::of(non_expressive_names::SIMILAR_NAMES),
     LintId::of(pass_by_ref_or_value::LARGE_TYPES_PASSED_BY_VALUE),
diff --git a/clippy_lints/src/no_effect.rs b/clippy_lints/src/no_effect.rs
index c5a5cde4b11..6dae8f32043 100644
--- a/clippy_lints/src/no_effect.rs
+++ b/clippy_lints/src/no_effect.rs
@@ -1,9 +1,10 @@
 use clippy_utils::diagnostics::{span_lint_hir, span_lint_hir_and_then};
+use clippy_utils::is_lint_allowed;
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::has_drop;
 use rustc_errors::Applicability;
 use rustc_hir::def::{DefKind, Res};
-use rustc_hir::{is_range_literal, BinOpKind, BlockCheckMode, Expr, ExprKind, Stmt, StmtKind, UnsafeSource};
+use rustc_hir::{is_range_literal, BinOpKind, BlockCheckMode, Expr, ExprKind, PatKind, Stmt, StmtKind, UnsafeSource};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use std::ops::Deref;
@@ -13,7 +14,7 @@ declare_clippy_lint! {
     /// Checks for statements which have no effect.
     ///
     /// ### Why is this bad?
-    /// Similar to dead code, these statements are actually
+    /// Unlike dead code, these statements are actually
     /// executed. However, as they have no effect, all they do is make the code less
     /// readable.
     ///
@@ -26,6 +27,28 @@ declare_clippy_lint! {
     "statements with no effect"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for binding to underscore prefixed variable without side-effects.
+    ///
+    /// ### Why is this bad?
+    /// Unlike dead code, these bindings are actually
+    /// executed. However, as they have no effect and shouldn't be used further on, all they
+    /// do is make the code less readable.
+    ///
+    /// ### Known problems
+    /// Further usage of this variable is not checked, which can lead to false positives if it is
+    /// used later in the code.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// let _i_serve_no_purpose = 1;
+    /// ```
+    pub NO_EFFECT_UNDERSCORE_BINDING,
+    pedantic,
+    "binding to `_` prefixed variable with no side-effect"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for expression statements that can be reduced to a
@@ -44,6 +67,46 @@ declare_clippy_lint! {
     "outer expressions with no effect"
 }
 
+declare_lint_pass!(NoEffect => [NO_EFFECT, UNNECESSARY_OPERATION, NO_EFFECT_UNDERSCORE_BINDING]);
+
+impl<'tcx> LateLintPass<'tcx> for NoEffect {
+    fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) {
+        if check_no_effect(cx, stmt) {
+            return;
+        }
+        check_unnecessary_operation(cx, stmt);
+    }
+}
+
+fn check_no_effect(cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) -> bool {
+    if let StmtKind::Semi(expr) = stmt.kind {
+        if has_no_effect(cx, expr) {
+            span_lint_hir(cx, NO_EFFECT, expr.hir_id, stmt.span, "statement with no effect");
+            return true;
+        }
+    } else if let StmtKind::Local(local) = stmt.kind {
+        if_chain! {
+            if !is_lint_allowed(cx, NO_EFFECT_UNDERSCORE_BINDING, local.hir_id);
+            if let Some(init) = local.init;
+            if !local.pat.span.from_expansion();
+            if has_no_effect(cx, init);
+            if let PatKind::Binding(_, _, ident, _) = local.pat.kind;
+            if ident.name.to_ident_string().starts_with('_');
+            then {
+                span_lint_hir(
+                    cx,
+                    NO_EFFECT_UNDERSCORE_BINDING,
+                    init.hir_id,
+                    stmt.span,
+                    "binding to `_` prefixed variable with no side-effect"
+                );
+                return true;
+            }
+        }
+    }
+    false
+}
+
 fn has_no_effect(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
     if expr.span.from_expansion() {
         return false;
@@ -88,71 +151,59 @@ fn has_no_effect(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
     }
 }
 
-declare_lint_pass!(NoEffect => [NO_EFFECT, UNNECESSARY_OPERATION]);
-
-impl<'tcx> LateLintPass<'tcx> for NoEffect {
-    fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) {
-        if let StmtKind::Semi(expr) = stmt.kind {
-            if has_no_effect(cx, expr) {
-                span_lint_hir(cx, NO_EFFECT, expr.hir_id, stmt.span, "statement with no effect");
-            } else if let Some(reduced) = reduce_expression(cx, expr) {
-                for e in &reduced {
-                    if e.span.from_expansion() {
-                        return;
-                    }
-                }
-                if let ExprKind::Index(..) = &expr.kind {
-                    let snippet;
-                    if_chain! {
-                        if let Some(arr) = snippet_opt(cx, reduced[0].span);
-                        if let Some(func) = snippet_opt(cx, reduced[1].span);
-                        then {
-                            snippet = format!("assert!({}.len() > {});", &arr, &func);
-                        } else {
-                            return;
-                        }
-                    }
-                    span_lint_hir_and_then(
-                        cx,
-                        UNNECESSARY_OPERATION,
-                        expr.hir_id,
-                        stmt.span,
-                        "unnecessary operation",
-                        |diag| {
-                            diag.span_suggestion(
-                                stmt.span,
-                                "statement can be written as",
-                                snippet,
-                                Applicability::MaybeIncorrect,
-                            );
-                        },
-                    );
+fn check_unnecessary_operation(cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) {
+    if_chain! {
+        if let StmtKind::Semi(expr) = stmt.kind;
+        if let Some(reduced) = reduce_expression(cx, expr);
+        if !&reduced.iter().any(|e| e.span.from_expansion());
+        then {
+            if let ExprKind::Index(..) = &expr.kind {
+                let snippet;
+                if let (Some(arr), Some(func)) = (snippet_opt(cx, reduced[0].span), snippet_opt(cx, reduced[1].span)) {
+                    snippet = format!("assert!({}.len() > {});", &arr, &func);
                 } else {
-                    let mut snippet = String::new();
-                    for e in reduced {
-                        if let Some(snip) = snippet_opt(cx, e.span) {
-                            snippet.push_str(&snip);
-                            snippet.push(';');
-                        } else {
-                            return;
-                        }
+                    return;
+                }
+                span_lint_hir_and_then(
+                    cx,
+                    UNNECESSARY_OPERATION,
+                    expr.hir_id,
+                    stmt.span,
+                    "unnecessary operation",
+                    |diag| {
+                        diag.span_suggestion(
+                            stmt.span,
+                            "statement can be written as",
+                            snippet,
+                            Applicability::MaybeIncorrect,
+                        );
+                    },
+                );
+            } else {
+                let mut snippet = String::new();
+                for e in reduced {
+                    if let Some(snip) = snippet_opt(cx, e.span) {
+                        snippet.push_str(&snip);
+                        snippet.push(';');
+                    } else {
+                        return;
                     }
-                    span_lint_hir_and_then(
-                        cx,
-                        UNNECESSARY_OPERATION,
-                        expr.hir_id,
-                        stmt.span,
-                        "unnecessary operation",
-                        |diag| {
-                            diag.span_suggestion(
-                                stmt.span,
-                                "statement can be reduced to",
-                                snippet,
-                                Applicability::MachineApplicable,
-                            );
-                        },
-                    );
                 }
+                span_lint_hir_and_then(
+                    cx,
+                    UNNECESSARY_OPERATION,
+                    expr.hir_id,
+                    stmt.span,
+                    "unnecessary operation",
+                    |diag| {
+                        diag.span_suggestion(
+                            stmt.span,
+                            "statement can be reduced to",
+                            snippet,
+                            Applicability::MachineApplicable,
+                        );
+                    },
+                );
             }
         }
     }
diff --git a/tests/ui/cfg_attr_rustfmt.fixed b/tests/ui/cfg_attr_rustfmt.fixed
index 4e583a25b94..061a4ab9b2e 100644
--- a/tests/ui/cfg_attr_rustfmt.fixed
+++ b/tests/ui/cfg_attr_rustfmt.fixed
@@ -1,7 +1,7 @@
 // run-rustfix
 #![feature(stmt_expr_attributes)]
 
-#![allow(unused, clippy::no_effect)]
+#![allow(unused, clippy::no_effect, clippy::unnecessary_operation)]
 #![warn(clippy::deprecated_cfg_attr)]
 
 // This doesn't get linted, see known problems
diff --git a/tests/ui/cfg_attr_rustfmt.rs b/tests/ui/cfg_attr_rustfmt.rs
index 9c0fcf6fb45..035169fab85 100644
--- a/tests/ui/cfg_attr_rustfmt.rs
+++ b/tests/ui/cfg_attr_rustfmt.rs
@@ -1,7 +1,7 @@
 // run-rustfix
 #![feature(stmt_expr_attributes)]
 
-#![allow(unused, clippy::no_effect)]
+#![allow(unused, clippy::no_effect, clippy::unnecessary_operation)]
 #![warn(clippy::deprecated_cfg_attr)]
 
 // This doesn't get linted, see known problems
diff --git a/tests/ui/no_effect.rs b/tests/ui/no_effect.rs
index 7ec845adfaa..7bcc4cad0d3 100644
--- a/tests/ui/no_effect.rs
+++ b/tests/ui/no_effect.rs
@@ -1,5 +1,5 @@
 #![feature(box_syntax)]
-#![warn(clippy::no_effect)]
+#![warn(clippy::no_effect_underscore_binding)]
 #![allow(dead_code)]
 #![allow(path_statements)]
 #![allow(clippy::deref_addrof)]
@@ -90,6 +90,10 @@ fn main() {
     || x += 5;
     let s: String = "foo".into();
     FooString { s: s };
+    let _unused = 1;
+    let _penguin = || println!("Some helpful closure");
+    let _duck = Struct { field: 0 };
+    let _cat = [2, 4, 6, 8][2];
 
     #[allow(clippy::no_effect)]
     0;
@@ -97,6 +101,8 @@ fn main() {
     // Do not warn
     get_number();
     unsafe { unsafe_fn() };
+    let _used = get_struct();
+    let _x = vec![1];
     DropUnit;
     DropStruct { field: 0 };
     DropTuple(0);
diff --git a/tests/ui/no_effect.stderr b/tests/ui/no_effect.stderr
index 6b24675ac2d..a5dbc9fef45 100644
--- a/tests/ui/no_effect.stderr
+++ b/tests/ui/no_effect.stderr
@@ -156,5 +156,31 @@ error: statement with no effect
 LL |     FooString { s: s };
    |     ^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 26 previous errors
+error: binding to `_` prefixed variable with no side-effect
+  --> $DIR/no_effect.rs:93:5
+   |
+LL |     let _unused = 1;
+   |     ^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::no-effect-underscore-binding` implied by `-D warnings`
+
+error: binding to `_` prefixed variable with no side-effect
+  --> $DIR/no_effect.rs:94:5
+   |
+LL |     let _penguin = || println!("Some helpful closure");
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: binding to `_` prefixed variable with no side-effect
+  --> $DIR/no_effect.rs:95:5
+   |
+LL |     let _duck = Struct { field: 0 };
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: binding to `_` prefixed variable with no side-effect
+  --> $DIR/no_effect.rs:96:5
+   |
+LL |     let _cat = [2, 4, 6, 8][2];
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 30 previous errors
 
diff --git a/tests/ui/option_if_let_else.fixed b/tests/ui/option_if_let_else.fixed
index a3ebe5d0703..4077f1920a3 100644
--- a/tests/ui/option_if_let_else.fixed
+++ b/tests/ui/option_if_let_else.fixed
@@ -1,8 +1,7 @@
 // edition:2018
 // run-rustfix
 #![warn(clippy::option_if_let_else)]
-#![allow(clippy::redundant_closure)]
-#![allow(clippy::ref_option_ref, clippy::equatable_if_let)]
+#![allow(clippy::redundant_closure, clippy::ref_option_ref, clippy::equatable_if_let)]
 
 fn bad1(string: Option<&str>) -> (bool, &str) {
     string.map_or((false, "hello"), |x| (true, x))
diff --git a/tests/ui/option_if_let_else.rs b/tests/ui/option_if_let_else.rs
index b11df3db60f..2f414e129d5 100644
--- a/tests/ui/option_if_let_else.rs
+++ b/tests/ui/option_if_let_else.rs
@@ -1,8 +1,7 @@
 // edition:2018
 // run-rustfix
 #![warn(clippy::option_if_let_else)]
-#![allow(clippy::redundant_closure)]
-#![allow(clippy::ref_option_ref, clippy::equatable_if_let)]
+#![allow(clippy::redundant_closure, clippy::ref_option_ref, clippy::equatable_if_let)]
 
 fn bad1(string: Option<&str>) -> (bool, &str) {
     if let Some(x) = string {
diff --git a/tests/ui/option_if_let_else.stderr b/tests/ui/option_if_let_else.stderr
index ed748ee8b39..803d941c36d 100644
--- a/tests/ui/option_if_let_else.stderr
+++ b/tests/ui/option_if_let_else.stderr
@@ -1,5 +1,5 @@
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:8:5
+  --> $DIR/option_if_let_else.rs:7:5
    |
 LL | /     if let Some(x) = string {
 LL | |         (true, x)
@@ -11,19 +11,19 @@ LL | |     }
    = note: `-D clippy::option-if-let-else` implied by `-D warnings`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:26:13
+  --> $DIR/option_if_let_else.rs:25:13
    |
 LL |     let _ = if let Some(s) = *string { s.len() } else { 0 };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `string.map_or(0, |s| s.len())`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:27:13
+  --> $DIR/option_if_let_else.rs:26:13
    |
 LL |     let _ = if let Some(s) = &num { s } else { &0 };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `num.as_ref().map_or(&0, |s| s)`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:28:13
+  --> $DIR/option_if_let_else.rs:27:13
    |
 LL |       let _ = if let Some(s) = &mut num {
    |  _____________^
@@ -43,13 +43,13 @@ LL ~     });
    |
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:34:13
+  --> $DIR/option_if_let_else.rs:33:13
    |
 LL |     let _ = if let Some(ref s) = num { s } else { &0 };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `num.as_ref().map_or(&0, |s| s)`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:35:13
+  --> $DIR/option_if_let_else.rs:34:13
    |
 LL |       let _ = if let Some(mut s) = num {
    |  _____________^
@@ -69,7 +69,7 @@ LL ~     });
    |
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:41:13
+  --> $DIR/option_if_let_else.rs:40:13
    |
 LL |       let _ = if let Some(ref mut s) = num {
    |  _____________^
@@ -89,7 +89,7 @@ LL ~     });
    |
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:50:5
+  --> $DIR/option_if_let_else.rs:49:5
    |
 LL | /     if let Some(x) = arg {
 LL | |         let y = x * x;
@@ -108,7 +108,7 @@ LL +     })
    |
 
 error: use Option::map_or_else instead of an if let/else
-  --> $DIR/option_if_let_else.rs:63:13
+  --> $DIR/option_if_let_else.rs:62:13
    |
 LL |       let _ = if let Some(x) = arg {
    |  _____________^
@@ -120,7 +120,7 @@ LL | |     };
    | |_____^ help: try: `arg.map_or_else(|| side_effect(), |x| x)`
 
 error: use Option::map_or_else instead of an if let/else
-  --> $DIR/option_if_let_else.rs:72:13
+  --> $DIR/option_if_let_else.rs:71:13
    |
 LL |       let _ = if let Some(x) = arg {
    |  _____________^
@@ -143,13 +143,13 @@ LL ~     }, |x| x * x * x * x);
    |
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:101:13
+  --> $DIR/option_if_let_else.rs:100:13
    |
 LL |     let _ = if let Some(x) = optional { x + 2 } else { 5 };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `optional.map_or(5, |x| x + 2)`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:110:13
+  --> $DIR/option_if_let_else.rs:109:13
    |
 LL |       let _ = if let Some(x) = Some(0) {
    |  _____________^
@@ -171,13 +171,13 @@ LL ~         });
    |
 
 error: use Option::map_or_else instead of an if let/else
-  --> $DIR/option_if_let_else.rs:138:13
+  --> $DIR/option_if_let_else.rs:137:13
    |
 LL |     let _ = if let Some(x) = Some(0) { s.len() + x } else { s.len() };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Some(0).map_or_else(|| s.len(), |x| s.len() + x)`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:142:13
+  --> $DIR/option_if_let_else.rs:141:13
    |
 LL |       let _ = if let Some(x) = Some(0) {
    |  _____________^
-- 
cgit 1.4.1-3-g733a5


From 4679eb3a0d09219b4bd815c636eb55e5b05c5a5e Mon Sep 17 00:00:00 2001
From: Michael Wright <mikerite@lavabit.com>
Date: Wed, 20 Oct 2021 06:13:42 +0200
Subject: Move const int value code to utils

---
 clippy_lints/src/invalid_upcast_comparisons.rs | 68 ++------------------------
 clippy_utils/src/consts.rs                     | 68 ++++++++++++++++++++++++++
 2 files changed, 71 insertions(+), 65 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/invalid_upcast_comparisons.rs b/clippy_lints/src/invalid_upcast_comparisons.rs
index b1f70b30c12..82438d85c7a 100644
--- a/clippy_lints/src/invalid_upcast_comparisons.rs
+++ b/clippy_lints/src/invalid_upcast_comparisons.rs
@@ -1,5 +1,3 @@
-use std::cmp::Ordering;
-
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::layout::LayoutOf;
@@ -7,11 +5,11 @@ use rustc_middle::ty::{self, IntTy, UintTy};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::Span;
 
+use clippy_utils::comparisons;
 use clippy_utils::comparisons::Rel;
-use clippy_utils::consts::{constant, Constant};
+use clippy_utils::consts::{constant_full_int, FullInt};
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::source::snippet;
-use clippy_utils::{comparisons, sext};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -39,53 +37,6 @@ declare_clippy_lint! {
 
 declare_lint_pass!(InvalidUpcastComparisons => [INVALID_UPCAST_COMPARISONS]);
 
-#[derive(Copy, Clone, Debug, Eq)]
-enum FullInt {
-    S(i128),
-    U(u128),
-}
-
-impl FullInt {
-    #[allow(clippy::cast_sign_loss)]
-    #[must_use]
-    fn cmp_s_u(s: i128, u: u128) -> Ordering {
-        if s < 0 {
-            Ordering::Less
-        } else if u > (i128::MAX as u128) {
-            Ordering::Greater
-        } else {
-            (s as u128).cmp(&u)
-        }
-    }
-}
-
-impl PartialEq for FullInt {
-    #[must_use]
-    fn eq(&self, other: &Self) -> bool {
-        self.partial_cmp(other).expect("`partial_cmp` only returns `Some(_)`") == Ordering::Equal
-    }
-}
-
-impl PartialOrd for FullInt {
-    #[must_use]
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        Some(match (self, other) {
-            (&Self::S(s), &Self::S(o)) => s.cmp(&o),
-            (&Self::U(s), &Self::U(o)) => s.cmp(&o),
-            (&Self::S(s), &Self::U(o)) => Self::cmp_s_u(s, o),
-            (&Self::U(s), &Self::S(o)) => Self::cmp_s_u(o, s).reverse(),
-        })
-    }
-}
-
-impl Ord for FullInt {
-    #[must_use]
-    fn cmp(&self, other: &Self) -> Ordering {
-        self.partial_cmp(other)
-            .expect("`partial_cmp` for FullInt can never return `None`")
-    }
-}
-
 fn numeric_cast_precast_bounds<'a>(cx: &LateContext<'_>, expr: &'a Expr<'_>) -> Option<(FullInt, FullInt)> {
     if let ExprKind::Cast(cast_exp, _) = expr.kind {
         let pre_cast_ty = cx.typeck_results().expr_ty(cast_exp);
@@ -118,19 +69,6 @@ fn numeric_cast_precast_bounds<'a>(cx: &LateContext<'_>, expr: &'a Expr<'_>) ->
     }
 }
 
-fn node_as_const_fullint<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<FullInt> {
-    let val = constant(cx, cx.typeck_results(), expr)?.0;
-    if let Constant::Int(const_int) = val {
-        match *cx.typeck_results().expr_ty(expr).kind() {
-            ty::Int(ity) => Some(FullInt::S(sext(cx.tcx, const_int, ity))),
-            ty::Uint(_) => Some(FullInt::U(const_int)),
-            _ => None,
-        }
-    } else {
-        None
-    }
-}
-
 fn err_upcast_comparison(cx: &LateContext<'_>, span: Span, expr: &Expr<'_>, always: bool) {
     if let ExprKind::Cast(cast_val, _) = expr.kind {
         span_lint(
@@ -156,7 +94,7 @@ fn upcast_comparison_bounds_err<'tcx>(
     invert: bool,
 ) {
     if let Some((lb, ub)) = lhs_bounds {
-        if let Some(norm_rhs_val) = node_as_const_fullint(cx, rhs) {
+        if let Some(norm_rhs_val) = constant_full_int(cx, cx.typeck_results(), rhs) {
             if rel == Rel::Eq || rel == Rel::Ne {
                 if norm_rhs_val < lb || norm_rhs_val > ub {
                     err_upcast_comparison(cx, span, lhs, rel == Rel::Ne);
diff --git a/clippy_utils/src/consts.rs b/clippy_utils/src/consts.rs
index 8bf31807d55..3e5d74a66f4 100644
--- a/clippy_utils/src/consts.rs
+++ b/clippy_utils/src/consts.rs
@@ -155,6 +155,19 @@ impl Constant {
             _ => None,
         }
     }
+
+    /// Returns the integer value or `None` if `self` or `val_type` is not integer type.
+    pub fn int_value(&self, cx: &LateContext<'_>, val_type: Ty<'_>) -> Option<FullInt> {
+        if let Constant::Int(const_int) = *self {
+            match *val_type.kind() {
+                ty::Int(ity) => Some(FullInt::S(sext(cx.tcx, const_int, ity))),
+                ty::Uint(_) => Some(FullInt::U(const_int)),
+                _ => None,
+            }
+        } else {
+            None
+        }
+    }
 }
 
 /// Parses a `LitKind` to a `Constant`.
@@ -202,6 +215,61 @@ pub fn constant_simple<'tcx>(
     constant(lcx, typeck_results, e).and_then(|(cst, res)| if res { None } else { Some(cst) })
 }
 
+pub fn constant_full_int(
+    lcx: &LateContext<'tcx>,
+    typeck_results: &ty::TypeckResults<'tcx>,
+    e: &Expr<'_>,
+) -> Option<FullInt> {
+    constant_simple(lcx, typeck_results, e)?.int_value(lcx, typeck_results.expr_ty(e))
+}
+
+#[derive(Copy, Clone, Debug, Eq)]
+pub enum FullInt {
+    S(i128),
+    U(u128),
+}
+
+impl FullInt {
+    #[allow(clippy::cast_sign_loss)]
+    #[must_use]
+    fn cmp_s_u(s: i128, u: u128) -> Ordering {
+        if s < 0 {
+            Ordering::Less
+        } else if u > (i128::MAX as u128) {
+            Ordering::Greater
+        } else {
+            (s as u128).cmp(&u)
+        }
+    }
+}
+
+impl PartialEq for FullInt {
+    #[must_use]
+    fn eq(&self, other: &Self) -> bool {
+        self.partial_cmp(other).expect("`partial_cmp` only returns `Some(_)`") == Ordering::Equal
+    }
+}
+
+impl PartialOrd for FullInt {
+    #[must_use]
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(match (self, other) {
+            (&Self::S(s), &Self::S(o)) => s.cmp(&o),
+            (&Self::U(s), &Self::U(o)) => s.cmp(&o),
+            (&Self::S(s), &Self::U(o)) => Self::cmp_s_u(s, o),
+            (&Self::U(s), &Self::S(o)) => Self::cmp_s_u(o, s).reverse(),
+        })
+    }
+}
+
+impl Ord for FullInt {
+    #[must_use]
+    fn cmp(&self, other: &Self) -> Ordering {
+        self.partial_cmp(other)
+            .expect("`partial_cmp` for FullInt can never return `None`")
+    }
+}
+
 /// Creates a `ConstEvalLateContext` from the given `LateContext` and `TypeckResults`.
 pub fn constant_context<'a, 'tcx>(
     lcx: &'a LateContext<'tcx>,
-- 
cgit 1.4.1-3-g733a5


From 1ede540b2135ce56546cb5f28fbf5c000646363f Mon Sep 17 00:00:00 2001
From: Michael Wright <mikerite@lavabit.com>
Date: Wed, 20 Oct 2021 06:13:42 +0200
Subject: Fix false positive in `match_overlapping_arm`

The bug was dues to the constant bytes being compared instead of their
values. This meant that negative values were being treated as larger
than some positive values.

Fixes #7829
---
 clippy_lints/src/matches.rs | 51 +++++++++++++--------------------------------
 1 file changed, 14 insertions(+), 37 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index b643fba5d32..f1289a36e77 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -1,4 +1,4 @@
-use clippy_utils::consts::{constant, miri_to_const, Constant};
+use clippy_utils::consts::{constant, constant_full_int, miri_to_const, FullInt};
 use clippy_utils::diagnostics::{
     multispan_sugg, span_lint_and_help, span_lint_and_note, span_lint_and_sugg, span_lint_and_then,
 };
@@ -930,9 +930,8 @@ fn check_match_bool(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>], expr:
 fn check_overlapping_arms<'tcx>(cx: &LateContext<'tcx>, ex: &'tcx Expr<'_>, arms: &'tcx [Arm<'_>]) {
     if arms.len() >= 2 && cx.typeck_results().expr_ty(ex).is_integral() {
         let ranges = all_ranges(cx, arms, cx.typeck_results().expr_ty(ex));
-        let type_ranges = type_ranges(&ranges);
-        if !type_ranges.is_empty() {
-            if let Some((start, end)) = overlapping(&type_ranges) {
+        if !ranges.is_empty() {
+            if let Some((start, end)) = overlapping(&ranges) {
                 span_lint_and_note(
                     cx,
                     MATCH_OVERLAPPING_ARM,
@@ -1601,7 +1600,7 @@ fn opt_parent_let<'a>(cx: &LateContext<'a>, ex: &Expr<'a>) -> Option<&'a Local<'
 }
 
 /// Gets all arms that are unbounded `PatRange`s.
-fn all_ranges<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>], ty: Ty<'tcx>) -> Vec<SpannedRange<Constant>> {
+fn all_ranges<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>], ty: Ty<'tcx>) -> Vec<SpannedRange<FullInt>> {
     arms.iter()
         .filter_map(|arm| {
             if let Arm { pat, guard: None, .. } = *arm {
@@ -1614,21 +1613,25 @@ fn all_ranges<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>], ty: Ty<'tcx>)
                         Some(rhs) => constant(cx, cx.typeck_results(), rhs)?.0,
                         None => miri_to_const(ty.numeric_max_val(cx.tcx)?)?,
                     };
-                    let rhs = match range_end {
-                        RangeEnd::Included => Bound::Included(rhs),
-                        RangeEnd::Excluded => Bound::Excluded(rhs),
+
+                    let lhs_val = lhs.int_value(cx, ty)?;
+                    let rhs_val = rhs.int_value(cx, ty)?;
+
+                    let rhs_bound = match range_end {
+                        RangeEnd::Included => Bound::Included(rhs_val),
+                        RangeEnd::Excluded => Bound::Excluded(rhs_val),
                     };
                     return Some(SpannedRange {
                         span: pat.span,
-                        node: (lhs, rhs),
+                        node: (lhs_val, rhs_bound),
                     });
                 }
 
                 if let PatKind::Lit(value) = pat.kind {
-                    let value = constant(cx, cx.typeck_results(), value)?.0;
+                    let value = constant_full_int(cx, cx.typeck_results(), value)?;
                     return Some(SpannedRange {
                         span: pat.span,
-                        node: (value.clone(), Bound::Included(value)),
+                        node: (value, Bound::Included(value)),
                     });
                 }
             }
@@ -1643,32 +1646,6 @@ pub struct SpannedRange<T> {
     pub node: (T, Bound<T>),
 }
 
-type TypedRanges = Vec<SpannedRange<u128>>;
-
-/// Gets all `Int` ranges or all `Uint` ranges. Mixed types are an error anyway
-/// and other types than
-/// `Uint` and `Int` probably don't make sense.
-fn type_ranges(ranges: &[SpannedRange<Constant>]) -> TypedRanges {
-    ranges
-        .iter()
-        .filter_map(|range| match range.node {
-            (Constant::Int(start), Bound::Included(Constant::Int(end))) => Some(SpannedRange {
-                span: range.span,
-                node: (start, Bound::Included(end)),
-            }),
-            (Constant::Int(start), Bound::Excluded(Constant::Int(end))) => Some(SpannedRange {
-                span: range.span,
-                node: (start, Bound::Excluded(end)),
-            }),
-            (Constant::Int(start), Bound::Unbounded) => Some(SpannedRange {
-                span: range.span,
-                node: (start, Bound::Unbounded),
-            }),
-            _ => None,
-        })
-        .collect()
-}
-
 // Checks if arm has the form `None => None`
 fn is_none_arm(cx: &LateContext<'_>, arm: &Arm<'_>) -> bool {
     matches!(arm.pat.kind, PatKind::Path(ref qpath) if is_lang_ctor(cx, qpath, OptionNone))
-- 
cgit 1.4.1-3-g733a5


From 083a4546f6a93be70da2538bf9bd73a0b88c8236 Mon Sep 17 00:00:00 2001
From: dswij <dswijj@gmail.com>
Date: Wed, 20 Oct 2021 13:41:44 +0800
Subject: Small refactor on `question_mark` condition checks

---
 clippy_lints/src/question_mark.rs | 26 ++++++++++++--------------
 1 file changed, 12 insertions(+), 14 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/question_mark.rs b/clippy_lints/src/question_mark.rs
index c1ee20c370a..4d616e26bfc 100644
--- a/clippy_lints/src/question_mark.rs
+++ b/clippy_lints/src/question_mark.rs
@@ -60,13 +60,8 @@ impl QuestionMark {
             if let Some(higher::If { cond, then, r#else }) = higher::If::hir(expr);
             if let ExprKind::MethodCall(segment, _, args, _) = &cond.kind;
             if let Some(subject) = args.get(0);
-            if (Self::is_option(cx, subject)
-                && Self::expression_returns_none(cx, then)
-                && segment.ident.name == sym!(is_none))
-                ||
-                (Self::is_result(cx, subject)
-                && Self::expression_returns_unmodified_err(cx, then, subject)
-                && segment.ident.name == sym!(is_err));
+            if (Self::option_check_and_early_return(cx, subject, then) && segment.ident.name == sym!(is_none)) ||
+                (Self::result_check_and_early_return(cx, subject, then) && segment.ident.name == sym!(is_err));
             then {
                 let mut applicability = Applicability::MachineApplicable;
                 let receiver_str = &Sugg::hir_with_applicability(cx, subject, "..", &mut applicability);
@@ -109,13 +104,8 @@ impl QuestionMark {
             if let Some(higher::IfLet { let_pat, let_expr, if_then, if_else: Some(if_else) })
                 = higher::IfLet::hir(cx, expr);
             if let PatKind::TupleStruct(ref path1, fields, None) = let_pat.kind;
-            if (Self::is_option(cx, let_expr)
-                && Self::expression_returns_none(cx, if_else)
-                && is_lang_ctor(cx, path1, OptionSome))
-                ||
-                (Self::is_result(cx, let_expr)
-                 && Self::expression_returns_unmodified_err(cx, if_else, let_expr)
-                 && is_lang_ctor(cx, path1, ResultOk));
+            if (Self::option_check_and_early_return(cx, let_expr, if_else) && is_lang_ctor(cx, path1, OptionSome)) ||
+                (Self::result_check_and_early_return(cx, let_expr, if_else) && is_lang_ctor(cx, path1, ResultOk));
 
             if let PatKind::Binding(annot, bind_id, _, _) = fields[0].kind;
             let by_ref = matches!(annot, BindingAnnotation::Ref | BindingAnnotation::RefMut);
@@ -141,6 +131,14 @@ impl QuestionMark {
         }
     }
 
+    fn result_check_and_early_return(cx: &LateContext<'_>, expr: &Expr<'_>, nested_expr: &Expr<'_>) -> bool {
+        Self::is_result(cx, expr) && Self::expression_returns_unmodified_err(cx, nested_expr, expr)
+    }
+
+    fn option_check_and_early_return(cx: &LateContext<'_>, expr: &Expr<'_>, nested_expr: &Expr<'_>) -> bool {
+        Self::is_option(cx, expr) && Self::expression_returns_none(cx, nested_expr)
+    }
+
     fn moves_by_default(cx: &LateContext<'_>, expression: &Expr<'_>) -> bool {
         let expr_ty = cx.typeck_results().expr_ty(expression);
 
-- 
cgit 1.4.1-3-g733a5


From 9cf68e40fe37106e22859b67fb204145467162d5 Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukastw97@gmail.com>
Date: Wed, 20 Oct 2021 13:46:12 +0200
Subject: Fix doc heading of TRANSMUTE_NUM_TO_BYTES

---
 clippy_lints/src/transmute/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/transmute/mod.rs b/clippy_lints/src/transmute/mod.rs
index 374999473a4..e6acf1a94c9 100644
--- a/clippy_lints/src/transmute/mod.rs
+++ b/clippy_lints/src/transmute/mod.rs
@@ -263,7 +263,7 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// # What it does
+    /// ### What it does
     /// Checks for transmutes from a number to an array of `u8`
     ///
     /// ### Why this is bad?
-- 
cgit 1.4.1-3-g733a5


From 3630afb57f5c98c83210adde07a92f6ebdce7fc7 Mon Sep 17 00:00:00 2001
From: ThibsG <thibsg@pm.me>
Date: Thu, 14 Oct 2021 12:16:35 +0200
Subject: Do not lint if any parent has hidden attribute

---
 clippy_lints/src/doc.rs | 12 ++++++++++++
 tests/ui/doc_unsafe.rs  | 10 ++++++++++
 2 files changed, 22 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/doc.rs b/clippy_lints/src/doc.rs
index 9840affbf6f..5511c3ea9b6 100644
--- a/clippy_lints/src/doc.rs
+++ b/clippy_lints/src/doc.rs
@@ -1,3 +1,4 @@
+use clippy_utils::attrs::is_doc_hidden;
 use clippy_utils::diagnostics::{span_lint, span_lint_and_help, span_lint_and_note};
 use clippy_utils::source::first_line_of_span;
 use clippy_utils::ty::{implements_trait, is_type_diagnostic_item};
@@ -297,6 +298,17 @@ fn lint_for_missing_headers<'tcx>(
     if !cx.access_levels.is_exported(def_id) {
         return; // Private functions do not require doc comments
     }
+
+    // do not lint if any parent has `#[doc(hidden)]` attribute (#7347)
+    if cx
+        .tcx
+        .hir()
+        .parent_iter(cx.tcx.hir().local_def_id_to_hir_id(def_id))
+        .any(|(id, _node)| is_doc_hidden(cx.tcx.hir().attrs(id)))
+    {
+        return;
+    }
+
     if !headers.safety && sig.header.unsafety == hir::Unsafety::Unsafe {
         span_lint(
             cx,
diff --git a/tests/ui/doc_unsafe.rs b/tests/ui/doc_unsafe.rs
index 8f823f1672b..03bb30f9083 100644
--- a/tests/ui/doc_unsafe.rs
+++ b/tests/ui/doc_unsafe.rs
@@ -115,3 +115,13 @@ fn main() {
         drive();
     }
 }
+
+// do not lint if any parent has `#[doc(hidden)]` attribute
+// see #7347
+#[doc(hidden)]
+pub mod __macro {
+    pub struct T;
+    impl T {
+        pub unsafe fn f() {}
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From abb7ae9a79cdeeb6a892f19120a87ed4dba77b17 Mon Sep 17 00:00:00 2001
From: surechen <chenshuo17@huawei.com>
Date: Thu, 21 Oct 2021 14:33:43 +0800
Subject: Fix typo for INVALID_NULL_PTR_USAGE and
 MISSING_INLINE_IN_PUBLIC_ITEMS.

---
 clippy_lints/src/missing_inline.rs | 2 +-
 clippy_lints/src/ptr.rs            | 1 +
 2 files changed, 2 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/missing_inline.rs b/clippy_lints/src/missing_inline.rs
index 667cdd83025..b593c747498 100644
--- a/clippy_lints/src/missing_inline.rs
+++ b/clippy_lints/src/missing_inline.rs
@@ -8,7 +8,7 @@ use rustc_span::sym;
 
 declare_clippy_lint! {
     /// ### What it does
-    /// it lints if an exported function, method, trait method with default impl,
+    /// It lints if an exported function, method, trait method with default impl,
     /// or trait method impl is not `#[inline]`.
     ///
     /// ### Why is this bad?
diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs
index d180d6f9227..92a4801a846 100644
--- a/clippy_lints/src/ptr.rs
+++ b/clippy_lints/src/ptr.rs
@@ -139,6 +139,7 @@ declare_clippy_lint! {
     /// unsafe { std::slice::from_raw_parts(ptr::null(), 0); }
     /// ```
     ///
+    /// ```ignore
     /// // Good
     /// unsafe { std::slice::from_raw_parts(NonNull::dangling().as_ptr(), 0); }
     /// ```
-- 
cgit 1.4.1-3-g733a5


From 1e8d9fb18c5bba7577cea524282dd5cbbc7ec702 Mon Sep 17 00:00:00 2001
From: Manish Goregaokar <manishsmail@gmail.com>
Date: Thu, 21 Oct 2021 08:50:50 -0700
Subject: Handle 'implementation safety' headers as well

---
 clippy_lints/src/doc.rs | 2 ++
 tests/ui/doc_unsafe.rs  | 5 +++++
 2 files changed, 7 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/doc.rs b/clippy_lints/src/doc.rs
index 5511c3ea9b6..c14a3604c2f 100644
--- a/clippy_lints/src/doc.rs
+++ b/clippy_lints/src/doc.rs
@@ -579,6 +579,8 @@ fn check_doc<'a, Events: Iterator<Item = (pulldown_cmark::Event<'a>, Range<usize
                     continue;
                 }
                 headers.safety |= in_heading && text.trim() == "Safety";
+                headers.safety |= in_heading && text.trim() == "Implementation safety";
+                headers.safety |= in_heading && text.trim() == "Implementation Safety";
                 headers.errors |= in_heading && text.trim() == "Errors";
                 headers.panics |= in_heading && text.trim() == "Panics";
                 if in_code {
diff --git a/tests/ui/doc_unsafe.rs b/tests/ui/doc_unsafe.rs
index 03bb30f9083..4464a21b3b6 100644
--- a/tests/ui/doc_unsafe.rs
+++ b/tests/ui/doc_unsafe.rs
@@ -125,3 +125,8 @@ pub mod __macro {
         pub unsafe fn f() {}
     }
 }
+
+/// # Implementation safety
+pub unsafe trait DocumentedUnsafeTraitWithImplementationHeader {
+    fn method();
+}
-- 
cgit 1.4.1-3-g733a5


From 566244a8bcd4f94a0c8c2491c2abde552ee46558 Mon Sep 17 00:00:00 2001
From: ThibsG <thibsg@pm.me>
Date: Wed, 20 Oct 2021 21:44:05 +0200
Subject: Do not lint when cast is coming from `signum` method call

---
 clippy_lints/src/casts/cast_possible_truncation.rs | 12 ++++++++++--
 clippy_lints/src/casts/mod.rs                      |  2 +-
 tests/ui/cast.rs                                   |  8 ++++++++
 3 files changed, 19 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/cast_possible_truncation.rs b/clippy_lints/src/casts/cast_possible_truncation.rs
index 833ad122e0d..2ae7d16e00b 100644
--- a/clippy_lints/src/casts/cast_possible_truncation.rs
+++ b/clippy_lints/src/casts/cast_possible_truncation.rs
@@ -1,12 +1,20 @@
 use clippy_utils::diagnostics::span_lint;
+use clippy_utils::expr_or_init;
 use clippy_utils::ty::is_isize_or_usize;
-use rustc_hir::Expr;
+use rustc_hir::{Expr, ExprKind};
 use rustc_lint::LateContext;
 use rustc_middle::ty::{self, FloatTy, Ty};
 
 use super::{utils, CAST_POSSIBLE_TRUNCATION};
 
-pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_from: Ty<'_>, cast_to: Ty<'_>) {
+pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_expr: &Expr<'_>, cast_from: Ty<'_>, cast_to: Ty<'_>) {
+    // do not lint if cast comes from a `signum` function
+    if let ExprKind::MethodCall(path, ..) = expr_or_init(cx, cast_expr).kind {
+        if path.ident.name.as_str() == "signum" {
+            return;
+        }
+    }
+
     let msg = match (cast_from.is_integral(), cast_to.is_integral()) {
         (true, true) => {
             let from_nbits = utils::int_ty_to_nbits(cast_from, cx.tcx);
diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index f0800c6a6f1..233abd17894 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -427,7 +427,7 @@ impl<'tcx> LateLintPass<'tcx> for Casts {
             fn_to_numeric_cast::check(cx, expr, cast_expr, cast_from, cast_to);
             fn_to_numeric_cast_with_truncation::check(cx, expr, cast_expr, cast_from, cast_to);
             if cast_from.is_numeric() && cast_to.is_numeric() && !in_external_macro(cx.sess(), expr.span) {
-                cast_possible_truncation::check(cx, expr, cast_from, cast_to);
+                cast_possible_truncation::check(cx, expr, cast_expr, cast_from, cast_to);
                 cast_possible_wrap::check(cx, expr, cast_from, cast_to);
                 cast_precision_loss::check(cx, expr, cast_from, cast_to);
                 cast_lossless::check(cx, expr, cast_expr, cast_from, cast_to);
diff --git a/tests/ui/cast.rs b/tests/ui/cast.rs
index 8ee0969b0f0..adc95e63ae5 100644
--- a/tests/ui/cast.rs
+++ b/tests/ui/cast.rs
@@ -92,4 +92,12 @@ fn main() {
     (1i64).checked_rem_euclid(-1i64).unwrap() as u64;
     (1i64).checked_rem_euclid(-1i64).unwrap() as u128;
     (1isize).checked_rem_euclid(-1isize).unwrap() as usize;
+
+    // no lint for `cast_possible_truncation`
+    // with `signum` method call (see issue #5395)
+    let x: i64 = 5;
+    let _ = x.signum() as i32;
+
+    let s = x.signum();
+    let _ = s as i32;
 }
-- 
cgit 1.4.1-3-g733a5


From 081d0f82f490b886753cf2cf32da8076050a5a6c Mon Sep 17 00:00:00 2001
From: Nixon Enraght-Moony <nixon.emoony@gmail.com>
Date: Mon, 11 Oct 2021 01:03:11 +0100
Subject: Make useless_format recognize format!("")

Closes #7796
---
 clippy_lints/src/format.rs | 34 +++++++++++++++++++++++++---------
 tests/ui/format.fixed      |  2 ++
 tests/ui/format.rs         |  2 ++
 tests/ui/format.stderr     | 28 +++++++++++++++++-----------
 4 files changed, 46 insertions(+), 20 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/format.rs b/clippy_lints/src/format.rs
index c22f9d0e170..7169ac9ad6c 100644
--- a/clippy_lints/src/format.rs
+++ b/clippy_lints/src/format.rs
@@ -49,15 +49,19 @@ impl<'tcx> LateLintPass<'tcx> for UselessFormat {
 
         let mut applicability = Applicability::MachineApplicable;
         if format_args.value_args.is_empty() {
-            if_chain! {
-                if let [e] = &*format_args.format_string_parts;
-                if let ExprKind::Lit(lit) = &e.kind;
-                if let Some(s_src) = snippet_opt(cx, lit.span);
-                then {
-                    // Simulate macro expansion, converting {{ and }} to { and }.
-                    let s_expand = s_src.replace("{{", "{").replace("}}", "}");
-                    let sugg = format!("{}.to_string()", s_expand);
-                    span_useless_format(cx, call_site, sugg, applicability);
+            if format_args.format_string_parts.is_empty() {
+                span_useless_format_empty(cx, call_site, "String::new()".to_owned(), applicability);
+            } else {
+                if_chain! {
+                    if let [e] = &*format_args.format_string_parts;
+                    if let ExprKind::Lit(lit) = &e.kind;
+                    if let Some(s_src) = snippet_opt(cx, lit.span);
+                    then {
+                        // Simulate macro expansion, converting {{ and }} to { and }.
+                        let s_expand = s_src.replace("{{", "{").replace("}}", "}");
+                        let sugg = format!("{}.to_string()", s_expand);
+                        span_useless_format(cx, call_site, sugg, applicability);
+                    }
                 }
             }
         } else if let [value] = *format_args.value_args {
@@ -89,6 +93,18 @@ impl<'tcx> LateLintPass<'tcx> for UselessFormat {
     }
 }
 
+fn span_useless_format_empty(cx: &LateContext<'_>, span: Span, sugg: String, applicability: Applicability) {
+    span_lint_and_sugg(
+        cx,
+        USELESS_FORMAT,
+        span,
+        "useless use of `format!`",
+        "consider using `String::new()`",
+        sugg,
+        applicability,
+    );
+}
+
 fn span_useless_format(cx: &LateContext<'_>, span: Span, sugg: String, applicability: Applicability) {
     span_lint_and_sugg(
         cx,
diff --git a/tests/ui/format.fixed b/tests/ui/format.fixed
index 73fc750511c..64cb7b1cfb8 100644
--- a/tests/ui/format.fixed
+++ b/tests/ui/format.fixed
@@ -16,6 +16,8 @@ fn main() {
     r##"foo {}
 " bar"##.to_string();
 
+    let _ = String::new();
+
     "foo".to_string();
     format!("{:?}", "foo"); // Don't warn about `Debug`.
     format!("{:8}", "foo");
diff --git a/tests/ui/format.rs b/tests/ui/format.rs
index 2f4595650cb..a065b1b5683 100644
--- a/tests/ui/format.rs
+++ b/tests/ui/format.rs
@@ -18,6 +18,8 @@ fn main() {
 " bar"##
     );
 
+    let _ = format!("");
+
     format!("{}", "foo");
     format!("{:?}", "foo"); // Don't warn about `Debug`.
     format!("{:8}", "foo");
diff --git a/tests/ui/format.stderr b/tests/ui/format.stderr
index 701399b32d6..58ad7499bb2 100644
--- a/tests/ui/format.stderr
+++ b/tests/ui/format.stderr
@@ -34,64 +34,70 @@ LL ~ " bar"##.to_string();
    |
 
 error: useless use of `format!`
-  --> $DIR/format.rs:21:5
+  --> $DIR/format.rs:21:13
+   |
+LL |     let _ = format!("");
+   |             ^^^^^^^^^^^ help: consider using `String::new()`: `String::new()`
+
+error: useless use of `format!`
+  --> $DIR/format.rs:23:5
    |
 LL |     format!("{}", "foo");
    |     ^^^^^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `"foo".to_string()`
 
 error: useless use of `format!`
-  --> $DIR/format.rs:25:5
+  --> $DIR/format.rs:27:5
    |
 LL |     format!("{:+}", "foo"); // Warn when the format makes no difference.
    |     ^^^^^^^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `"foo".to_string()`
 
 error: useless use of `format!`
-  --> $DIR/format.rs:26:5
+  --> $DIR/format.rs:28:5
    |
 LL |     format!("{:<}", "foo"); // Warn when the format makes no difference.
    |     ^^^^^^^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `"foo".to_string()`
 
 error: useless use of `format!`
-  --> $DIR/format.rs:31:5
+  --> $DIR/format.rs:33:5
    |
 LL |     format!("{}", arg);
    |     ^^^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `arg.to_string()`
 
 error: useless use of `format!`
-  --> $DIR/format.rs:35:5
+  --> $DIR/format.rs:37:5
    |
 LL |     format!("{:+}", arg); // Warn when the format makes no difference.
    |     ^^^^^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `arg.to_string()`
 
 error: useless use of `format!`
-  --> $DIR/format.rs:36:5
+  --> $DIR/format.rs:38:5
    |
 LL |     format!("{:<}", arg); // Warn when the format makes no difference.
    |     ^^^^^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `arg.to_string()`
 
 error: useless use of `format!`
-  --> $DIR/format.rs:63:5
+  --> $DIR/format.rs:65:5
    |
 LL |     format!("{}", 42.to_string());
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `42.to_string()`
 
 error: useless use of `format!`
-  --> $DIR/format.rs:65:5
+  --> $DIR/format.rs:67:5
    |
 LL |     format!("{}", x.display().to_string());
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `x.display().to_string()`
 
 error: useless use of `format!`
-  --> $DIR/format.rs:69:18
+  --> $DIR/format.rs:71:18
    |
 LL |     let _ = Some(format!("{}", a + "bar"));
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `a + "bar"`
 
 error: useless use of `format!`
-  --> $DIR/format.rs:73:22
+  --> $DIR/format.rs:75:22
    |
 LL |     let _s: String = format!("{}", &*v.join("/n"));
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `(&*v.join("/n")).to_string()`
 
-error: aborting due to 14 previous errors
+error: aborting due to 15 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 9def82d382220970760baa9d6480663bec3ebf97 Mon Sep 17 00:00:00 2001
From: Manish Goregaokar <manishsmail@gmail.com>
Date: Thu, 21 Oct 2021 14:40:33 -0700
Subject: use a variable

---
 clippy_lints/src/doc.rs | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/doc.rs b/clippy_lints/src/doc.rs
index c14a3604c2f..ec67adf3f87 100644
--- a/clippy_lints/src/doc.rs
+++ b/clippy_lints/src/doc.rs
@@ -578,11 +578,12 @@ fn check_doc<'a, Events: Iterator<Item = (pulldown_cmark::Event<'a>, Range<usize
                     // text "http://example.com" by pulldown-cmark
                     continue;
                 }
-                headers.safety |= in_heading && text.trim() == "Safety";
-                headers.safety |= in_heading && text.trim() == "Implementation safety";
-                headers.safety |= in_heading && text.trim() == "Implementation Safety";
-                headers.errors |= in_heading && text.trim() == "Errors";
-                headers.panics |= in_heading && text.trim() == "Panics";
+                let trimmed_text = text.trim();
+                headers.safety |= in_heading && trimmed_text == "Safety";
+                headers.safety |= in_heading && trimmed_text == "Implementation safety";
+                headers.safety |= in_heading && trimmed_text == "Implementation Safety";
+                headers.errors |= in_heading && trimmed_text == "Errors";
+                headers.panics |= in_heading && trimmed_text == "Panics";
                 if in_code {
                     if is_rust {
                         let edition = edition.unwrap_or_else(|| cx.tcx.sess.edition());
-- 
cgit 1.4.1-3-g733a5


From e953dff5360ad718511dff79ca7c3ae5cb8118d4 Mon Sep 17 00:00:00 2001
From: Mike Welsh <mwelsh@gmail.com>
Date: Fri, 22 Oct 2021 23:47:38 -0700
Subject: Fix `match_str_case_mismatch` false positives

Properly consider uncased and titlecased characters.
Fixes #7863.
---
 clippy_lints/src/match_str_case_mismatch.rs | 10 ++--
 tests/ui/match_str_case_mismatch.rs         | 86 +++++++++++++++++++++++++++++
 tests/ui/match_str_case_mismatch.stderr     | 52 +++++++++++++++--
 3 files changed, 139 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/match_str_case_mismatch.rs b/clippy_lints/src/match_str_case_mismatch.rs
index a83f38e3d51..f501593c518 100644
--- a/clippy_lints/src/match_str_case_mismatch.rs
+++ b/clippy_lints/src/match_str_case_mismatch.rs
@@ -127,10 +127,10 @@ fn get_case_method(segment_ident_str: &str) -> Option<CaseMethod> {
 
 fn verify_case<'a>(case_method: &'a CaseMethod, arms: &'a [Arm<'_>]) -> Option<(Span, SymbolStr)> {
     let case_check = match case_method {
-        CaseMethod::LowerCase => |input: &str| -> bool { input.chars().all(char::is_lowercase) },
-        CaseMethod::AsciiLowerCase => |input: &str| -> bool { input.chars().all(|c| matches!(c, 'a'..='z')) },
-        CaseMethod::UpperCase => |input: &str| -> bool { input.chars().all(char::is_uppercase) },
-        CaseMethod::AsciiUppercase => |input: &str| -> bool { input.chars().all(|c| matches!(c, 'A'..='Z')) },
+        CaseMethod::LowerCase => |input: &str| -> bool { input.chars().all(|c| c.to_lowercase().next() == Some(c)) },
+        CaseMethod::AsciiLowerCase => |input: &str| -> bool { !input.chars().any(|c| c.is_ascii_uppercase()) },
+        CaseMethod::UpperCase => |input: &str| -> bool { input.chars().all(|c| c.to_uppercase().next() == Some(c)) },
+        CaseMethod::AsciiUppercase => |input: &str| -> bool { !input.chars().any(|c| c.is_ascii_lowercase()) },
     };
 
     for arm in arms {
@@ -153,7 +153,7 @@ fn verify_case<'a>(case_method: &'a CaseMethod, arms: &'a [Arm<'_>]) -> Option<(
 
 fn lint(cx: &LateContext<'_>, case_method: &CaseMethod, bad_case_span: Span, bad_case_str: &str) {
     let (method_str, suggestion) = match case_method {
-        CaseMethod::LowerCase => ("to_lower_case", bad_case_str.to_lowercase()),
+        CaseMethod::LowerCase => ("to_lowercase", bad_case_str.to_lowercase()),
         CaseMethod::AsciiLowerCase => ("to_ascii_lowercase", bad_case_str.to_ascii_lowercase()),
         CaseMethod::UpperCase => ("to_uppercase", bad_case_str.to_uppercase()),
         CaseMethod::AsciiUppercase => ("to_ascii_uppercase", bad_case_str.to_ascii_uppercase()),
diff --git a/tests/ui/match_str_case_mismatch.rs b/tests/ui/match_str_case_mismatch.rs
index 208a4bba3d2..ac555c87d83 100644
--- a/tests/ui/match_str_case_mismatch.rs
+++ b/tests/ui/match_str_case_mismatch.rs
@@ -12,6 +12,49 @@ fn as_str_match() {
     }
 }
 
+fn non_alphabetic() {
+    let var = "~!@#$%^&*()-_=+FOO";
+
+    match var.to_ascii_lowercase().as_str() {
+        "1234567890" => {},
+        "~!@#$%^&*()-_=+foo" => {},
+        "\n\r\t\x7F" => {},
+        _ => {},
+    }
+}
+
+fn unicode_cased() {
+    let var = "ВОДЫ";
+
+    match var.to_lowercase().as_str() {
+        "水" => {},
+        "νερό" => {},
+        "воды" => {},
+        "물" => {},
+        _ => {},
+    }
+}
+
+fn titlecase() {
+    let var = "BarDz";
+
+    match var.to_lowercase().as_str() {
+        "foolj" => {},
+        "bardz" => {},
+        _ => {},
+    }
+}
+
+fn no_case_equivalent() {
+    let var = "barʁ";
+
+    match var.to_uppercase().as_str() {
+        "FOOɕ" => {},
+        "BARʁ" => {},
+        _ => {},
+    }
+}
+
 fn addrof_unary_match() {
     let var = "BAR";
 
@@ -70,6 +113,49 @@ fn as_str_match_mismatch() {
     }
 }
 
+fn non_alphabetic_mismatch() {
+    let var = "~!@#$%^&*()-_=+FOO";
+
+    match var.to_ascii_lowercase().as_str() {
+        "1234567890" => {},
+        "~!@#$%^&*()-_=+Foo" => {},
+        "\n\r\t\x7F" => {},
+        _ => {},
+    }
+}
+
+fn unicode_cased_mismatch() {
+    let var = "ВОДЫ";
+
+    match var.to_lowercase().as_str() {
+        "水" => {},
+        "νερό" => {},
+        "Воды" => {},
+        "물" => {},
+        _ => {},
+    }
+}
+
+fn titlecase_mismatch() {
+    let var = "BarDz";
+
+    match var.to_lowercase().as_str() {
+        "foolj" => {},
+        "barDz" => {},
+        _ => {},
+    }
+}
+
+fn no_case_equivalent_mismatch() {
+    let var = "barʁ";
+
+    match var.to_uppercase().as_str() {
+        "FOOɕ" => {},
+        "bARʁ" => {},
+        _ => {},
+    }
+}
+
 fn addrof_unary_match_mismatch() {
     let var = "BAR";
 
diff --git a/tests/ui/match_str_case_mismatch.stderr b/tests/ui/match_str_case_mismatch.stderr
index fa023477a9c..92baa40ef28 100644
--- a/tests/ui/match_str_case_mismatch.stderr
+++ b/tests/ui/match_str_case_mismatch.stderr
@@ -1,5 +1,5 @@
 error: this `match` arm has a differing case than its expression
-  --> $DIR/match_str_case_mismatch.rs:68:9
+  --> $DIR/match_str_case_mismatch.rs:111:9
    |
 LL |         "Bar" => {},
    |         ^^^^^
@@ -11,7 +11,51 @@ LL |         "bar" => {},
    |         ~~~~~
 
 error: this `match` arm has a differing case than its expression
-  --> $DIR/match_str_case_mismatch.rs:78:9
+  --> $DIR/match_str_case_mismatch.rs:121:9
+   |
+LL |         "~!@#$%^&*()-_=+Foo" => {},
+   |         ^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider changing the case of this arm to respect `to_ascii_lowercase`
+   |
+LL |         "~!@#$%^&*()-_=+foo" => {},
+   |         ~~~~~~~~~~~~~~~~~~~~
+
+error: this `match` arm has a differing case than its expression
+  --> $DIR/match_str_case_mismatch.rs:133:9
+   |
+LL |         "Воды" => {},
+   |         ^^^^^^
+   |
+help: consider changing the case of this arm to respect `to_lowercase`
+   |
+LL |         "воды" => {},
+   |         ~~~~~~
+
+error: this `match` arm has a differing case than its expression
+  --> $DIR/match_str_case_mismatch.rs:144:9
+   |
+LL |         "barDz" => {},
+   |         ^^^^^^
+   |
+help: consider changing the case of this arm to respect `to_lowercase`
+   |
+LL |         "bardz" => {},
+   |         ~~~~~~
+
+error: this `match` arm has a differing case than its expression
+  --> $DIR/match_str_case_mismatch.rs:154:9
+   |
+LL |         "bARʁ" => {},
+   |         ^^^^^^
+   |
+help: consider changing the case of this arm to respect `to_uppercase`
+   |
+LL |         "BARʁ" => {},
+   |         ~~~~~~
+
+error: this `match` arm has a differing case than its expression
+  --> $DIR/match_str_case_mismatch.rs:164:9
    |
 LL |         "Bar" => {},
    |         ^^^^^
@@ -22,7 +66,7 @@ LL |         "bar" => {},
    |         ~~~~~
 
 error: this `match` arm has a differing case than its expression
-  --> $DIR/match_str_case_mismatch.rs:93:9
+  --> $DIR/match_str_case_mismatch.rs:179:9
    |
 LL |         "bAR" => {},
    |         ^^^^^
@@ -32,5 +76,5 @@ help: consider changing the case of this arm to respect `to_ascii_uppercase`
 LL |         "BAR" => {},
    |         ~~~~~
 
-error: aborting due to 3 previous errors
+error: aborting due to 7 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 1b91d986ea38ad121d760ab8c1320dd2fc5580f2 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Sun, 24 Oct 2021 17:42:13 +0200
Subject: Rename `clippy_utils::camal_case` to `clippy_utils::str_utils`

---
 clippy_lints/src/enum_variants.rs |  12 ++--
 clippy_utils/src/camel_case.rs    | 117 --------------------------------------
 clippy_utils/src/lib.rs           |   2 +-
 clippy_utils/src/str_utils.rs     | 117 ++++++++++++++++++++++++++++++++++++++
 4 files changed, 124 insertions(+), 124 deletions(-)
 delete mode 100644 clippy_utils/src/camel_case.rs
 create mode 100644 clippy_utils/src/str_utils.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/enum_variants.rs b/clippy_lints/src/enum_variants.rs
index 174260fabd2..8d6f7d6fdf1 100644
--- a/clippy_lints/src/enum_variants.rs
+++ b/clippy_lints/src/enum_variants.rs
@@ -1,6 +1,6 @@
 //! lint on enum variants that are prefixed or suffixed by the same characters
 
-use clippy_utils::camel_case;
+use clippy_utils::str_utils;
 use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
 use clippy_utils::source::is_present_in_source;
 use rustc_hir::{EnumDef, Item, ItemKind};
@@ -171,14 +171,14 @@ fn check_variant(
         }
     }
     let first = &def.variants[0].ident.name.as_str();
-    let mut pre = &first[..camel_case::until(&*first)];
-    let mut post = &first[camel_case::from(&*first)..];
+    let mut pre = &first[..str_utils::until(&*first)];
+    let mut post = &first[str_utils::from(&*first)..];
     for var in def.variants {
         let name = var.ident.name.as_str();
 
         let pre_match = partial_match(pre, &name);
         pre = &pre[..pre_match];
-        let pre_camel = camel_case::until(pre);
+        let pre_camel = str_utils::until(pre);
         pre = &pre[..pre_camel];
         while let Some((next, last)) = name[pre.len()..].chars().zip(pre.chars().rev()).next() {
             if next.is_numeric() {
@@ -186,7 +186,7 @@ fn check_variant(
             }
             if next.is_lowercase() {
                 let last = pre.len() - last.len_utf8();
-                let last_camel = camel_case::until(&pre[..last]);
+                let last_camel = str_utils::until(&pre[..last]);
                 pre = &pre[..last_camel];
             } else {
                 break;
@@ -196,7 +196,7 @@ fn check_variant(
         let post_match = partial_rmatch(post, &name);
         let post_end = post.len() - post_match;
         post = &post[post_end..];
-        let post_camel = camel_case::from(post);
+        let post_camel = str_utils::from(post);
         post = &post[post_camel..];
     }
     let (what, value) = match (pre.is_empty(), post.is_empty()) {
diff --git a/clippy_utils/src/camel_case.rs b/clippy_utils/src/camel_case.rs
deleted file mode 100644
index a6636e39137..00000000000
--- a/clippy_utils/src/camel_case.rs
+++ /dev/null
@@ -1,117 +0,0 @@
-/// Returns the index of the character after the first camel-case component of `s`.
-#[must_use]
-pub fn until(s: &str) -> usize {
-    let mut iter = s.char_indices();
-    if let Some((_, first)) = iter.next() {
-        if !first.is_uppercase() {
-            return 0;
-        }
-    } else {
-        return 0;
-    }
-    let mut up = true;
-    let mut last_i = 0;
-    for (i, c) in iter {
-        if up {
-            if c.is_lowercase() {
-                up = false;
-            } else {
-                return last_i;
-            }
-        } else if c.is_uppercase() {
-            up = true;
-            last_i = i;
-        } else if !c.is_lowercase() {
-            return i;
-        }
-    }
-    if up { last_i } else { s.len() }
-}
-
-/// Returns index of the last camel-case component of `s`.
-#[must_use]
-pub fn from(s: &str) -> usize {
-    let mut iter = s.char_indices().rev();
-    if let Some((_, first)) = iter.next() {
-        if !first.is_lowercase() {
-            return s.len();
-        }
-    } else {
-        return s.len();
-    }
-    let mut down = true;
-    let mut last_i = s.len();
-    for (i, c) in iter {
-        if down {
-            if c.is_uppercase() {
-                down = false;
-                last_i = i;
-            } else if !c.is_lowercase() {
-                return last_i;
-            }
-        } else if c.is_lowercase() {
-            down = true;
-        } else if c.is_uppercase() {
-            last_i = i;
-        } else {
-            return last_i;
-        }
-    }
-    last_i
-}
-
-#[cfg(test)]
-mod test {
-    use super::{from, until};
-
-    #[test]
-    fn from_full() {
-        assert_eq!(from("AbcDef"), 0);
-        assert_eq!(from("Abc"), 0);
-        assert_eq!(from("ABcd"), 0);
-        assert_eq!(from("ABcdEf"), 0);
-        assert_eq!(from("AabABcd"), 0);
-    }
-
-    #[test]
-    fn from_partial() {
-        assert_eq!(from("abcDef"), 3);
-        assert_eq!(from("aDbc"), 1);
-        assert_eq!(from("aabABcd"), 3);
-    }
-
-    #[test]
-    fn from_not() {
-        assert_eq!(from("AbcDef_"), 7);
-        assert_eq!(from("AbcDD"), 5);
-    }
-
-    #[test]
-    fn from_caps() {
-        assert_eq!(from("ABCD"), 4);
-    }
-
-    #[test]
-    fn until_full() {
-        assert_eq!(until("AbcDef"), 6);
-        assert_eq!(until("Abc"), 3);
-    }
-
-    #[test]
-    fn until_not() {
-        assert_eq!(until("abcDef"), 0);
-        assert_eq!(until("aDbc"), 0);
-    }
-
-    #[test]
-    fn until_partial() {
-        assert_eq!(until("AbcDef_"), 6);
-        assert_eq!(until("CallTypeC"), 8);
-        assert_eq!(until("AbcDD"), 3);
-    }
-
-    #[test]
-    fn until_caps() {
-        assert_eq!(until("ABCD"), 0);
-    }
-}
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index aeb8c12ae8b..1c5186dba1b 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -37,7 +37,7 @@ pub mod sym_helper;
 #[allow(clippy::module_name_repetitions)]
 pub mod ast_utils;
 pub mod attrs;
-pub mod camel_case;
+pub mod str_utils;
 pub mod comparisons;
 pub mod consts;
 pub mod diagnostics;
diff --git a/clippy_utils/src/str_utils.rs b/clippy_utils/src/str_utils.rs
new file mode 100644
index 00000000000..a6636e39137
--- /dev/null
+++ b/clippy_utils/src/str_utils.rs
@@ -0,0 +1,117 @@
+/// Returns the index of the character after the first camel-case component of `s`.
+#[must_use]
+pub fn until(s: &str) -> usize {
+    let mut iter = s.char_indices();
+    if let Some((_, first)) = iter.next() {
+        if !first.is_uppercase() {
+            return 0;
+        }
+    } else {
+        return 0;
+    }
+    let mut up = true;
+    let mut last_i = 0;
+    for (i, c) in iter {
+        if up {
+            if c.is_lowercase() {
+                up = false;
+            } else {
+                return last_i;
+            }
+        } else if c.is_uppercase() {
+            up = true;
+            last_i = i;
+        } else if !c.is_lowercase() {
+            return i;
+        }
+    }
+    if up { last_i } else { s.len() }
+}
+
+/// Returns index of the last camel-case component of `s`.
+#[must_use]
+pub fn from(s: &str) -> usize {
+    let mut iter = s.char_indices().rev();
+    if let Some((_, first)) = iter.next() {
+        if !first.is_lowercase() {
+            return s.len();
+        }
+    } else {
+        return s.len();
+    }
+    let mut down = true;
+    let mut last_i = s.len();
+    for (i, c) in iter {
+        if down {
+            if c.is_uppercase() {
+                down = false;
+                last_i = i;
+            } else if !c.is_lowercase() {
+                return last_i;
+            }
+        } else if c.is_lowercase() {
+            down = true;
+        } else if c.is_uppercase() {
+            last_i = i;
+        } else {
+            return last_i;
+        }
+    }
+    last_i
+}
+
+#[cfg(test)]
+mod test {
+    use super::{from, until};
+
+    #[test]
+    fn from_full() {
+        assert_eq!(from("AbcDef"), 0);
+        assert_eq!(from("Abc"), 0);
+        assert_eq!(from("ABcd"), 0);
+        assert_eq!(from("ABcdEf"), 0);
+        assert_eq!(from("AabABcd"), 0);
+    }
+
+    #[test]
+    fn from_partial() {
+        assert_eq!(from("abcDef"), 3);
+        assert_eq!(from("aDbc"), 1);
+        assert_eq!(from("aabABcd"), 3);
+    }
+
+    #[test]
+    fn from_not() {
+        assert_eq!(from("AbcDef_"), 7);
+        assert_eq!(from("AbcDD"), 5);
+    }
+
+    #[test]
+    fn from_caps() {
+        assert_eq!(from("ABCD"), 4);
+    }
+
+    #[test]
+    fn until_full() {
+        assert_eq!(until("AbcDef"), 6);
+        assert_eq!(until("Abc"), 3);
+    }
+
+    #[test]
+    fn until_not() {
+        assert_eq!(until("abcDef"), 0);
+        assert_eq!(until("aDbc"), 0);
+    }
+
+    #[test]
+    fn until_partial() {
+        assert_eq!(until("AbcDef_"), 6);
+        assert_eq!(until("CallTypeC"), 8);
+        assert_eq!(until("AbcDD"), 3);
+    }
+
+    #[test]
+    fn until_caps() {
+        assert_eq!(until("ABCD"), 0);
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 20fb7f291604267447ef95ee437f9bc8699879d1 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Sun, 24 Oct 2021 12:52:38 -0500
Subject: Update rustfmt

---
 clippy_lints/src/dereference.rs           |  2 +-
 clippy_lints/src/entry.rs                 | 13 ++++++++-----
 clippy_lints/src/eta_reduction.rs         | 17 ++++++++++-------
 clippy_lints/src/int_plus_one.rs          |  4 ++--
 clippy_lints/src/loops/utils.rs           |  2 +-
 clippy_lints/src/methods/clone_on_copy.rs |  4 ++--
 clippy_lints/src/methods/or_fun_call.rs   |  2 +-
 clippy_lints/src/module_style.rs          |  2 +-
 clippy_lints/src/needless_borrow.rs       | 20 ++++++++++++--------
 clippy_utils/src/higher.rs                |  4 ++--
 clippy_utils/src/lib.rs                   | 25 ++++++++++++++-----------
 11 files changed, 54 insertions(+), 41 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index 7825e5f6ed5..ce59311c4aa 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -126,7 +126,7 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing {
                                 target_mut,
                             },
                         ));
-                    }
+                    },
                     _ => (),
                 }
             },
diff --git a/clippy_lints/src/entry.rs b/clippy_lints/src/entry.rs
index ac6824672f6..57fd24bd4f0 100644
--- a/clippy_lints/src/entry.rs
+++ b/clippy_lints/src/entry.rs
@@ -245,11 +245,14 @@ fn try_parse_contains(cx: &LateContext<'_>, expr: &'tcx Expr<'_>) -> Option<(Map
         ExprKind::MethodCall(
             _,
             _,
-            [map, Expr {
-                kind: ExprKind::AddrOf(_, _, key),
-                span: key_span,
-                ..
-            }],
+            [
+                map,
+                Expr {
+                    kind: ExprKind::AddrOf(_, _, key),
+                    span: key_span,
+                    ..
+                },
+            ],
             _,
         ) if key_span.ctxt() == expr.span.ctxt() => {
             let id = cx.typeck_results().type_dependent_def_id(expr.hir_id)?;
diff --git a/clippy_lints/src/eta_reduction.rs b/clippy_lints/src/eta_reduction.rs
index 765a6c7585a..9247343b52a 100644
--- a/clippy_lints/src/eta_reduction.rs
+++ b/clippy_lints/src/eta_reduction.rs
@@ -169,13 +169,16 @@ fn check_inputs(cx: &LateContext<'_>, params: &[Param<'_>], call_args: &[Expr<'_
         }
         match *cx.typeck_results().expr_adjustments(arg) {
             [] => true,
-            [Adjustment {
-                kind: Adjust::Deref(None),
-                ..
-            }, Adjustment {
-                kind: Adjust::Borrow(AutoBorrow::Ref(_, mu2)),
-                ..
-            }] => {
+            [
+                Adjustment {
+                    kind: Adjust::Deref(None),
+                    ..
+                },
+                Adjustment {
+                    kind: Adjust::Borrow(AutoBorrow::Ref(_, mu2)),
+                    ..
+                },
+            ] => {
                 // re-borrow with the same mutability is allowed
                 let ty = cx.typeck_results().expr_ty(arg);
                 matches!(*ty.kind(), ty::Ref(.., mu1) if mu1 == mu2.into())
diff --git a/clippy_lints/src/int_plus_one.rs b/clippy_lints/src/int_plus_one.rs
index 49b69dd072a..6850e0c3476 100644
--- a/clippy_lints/src/int_plus_one.rs
+++ b/clippy_lints/src/int_plus_one.rs
@@ -89,7 +89,7 @@ impl IntPlusOne {
                     },
                     _ => None,
                 }
-            }
+            },
             // case where `x + 1 <= ...` or `1 + x <= ...`
             (BinOpKind::Le, &ExprKind::Binary(ref lhskind, ref lhslhs, ref lhsrhs), _)
                 if lhskind.node == BinOpKind::Add =>
@@ -104,7 +104,7 @@ impl IntPlusOne {
                     },
                     _ => None,
                 }
-            }
+            },
             // case where `... >= y - 1` or `... >= -1 + y`
             (BinOpKind::Le, _, &ExprKind::Binary(ref rhskind, ref rhslhs, ref rhsrhs)) => {
                 match (rhskind.node, &rhslhs.kind, &rhsrhs.kind) {
diff --git a/clippy_lints/src/loops/utils.rs b/clippy_lints/src/loops/utils.rs
index 2f7360210ba..f9f515cc40a 100644
--- a/clippy_lints/src/loops/utils.rs
+++ b/clippy_lints/src/loops/utils.rs
@@ -338,7 +338,7 @@ pub(super) fn make_iterator_snippet(cx: &LateContext<'_>, arg: &Expr<'_>, applic
                     sugg::Sugg::hir_with_applicability(cx, arg_inner, "_", applic_ref).maybe_par(),
                     meth_name,
                 )
-            }
+            },
             _ => format!(
                 "{}.into_iter()",
                 sugg::Sugg::hir_with_applicability(cx, arg, "_", applic_ref).maybe_par()
diff --git a/clippy_lints/src/methods/clone_on_copy.rs b/clippy_lints/src/methods/clone_on_copy.rs
index 1a32af5dc7a..b4dacb2580c 100644
--- a/clippy_lints/src/methods/clone_on_copy.rs
+++ b/clippy_lints/src/methods/clone_on_copy.rs
@@ -85,7 +85,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, method_name: Symbol,
                     if expr.hir_id == self_arg.hir_id && ty != cx.typeck_results().expr_ty_adjusted(expr) =>
                 {
                     return;
-                }
+                },
                 ExprKind::MethodCall(_, _, [self_arg, ..], _) if expr.hir_id == self_arg.hir_id => true,
                 ExprKind::Match(_, _, MatchSource::TryDesugar | MatchSource::AwaitDesugar)
                 | ExprKind::Field(..)
@@ -100,7 +100,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, method_name: Symbol,
                 ) =>
             {
                 return;
-            }
+            },
             _ => false,
         };
 
diff --git a/clippy_lints/src/methods/or_fun_call.rs b/clippy_lints/src/methods/or_fun_call.rs
index b5bbbb09092..fe9ffde0d33 100644
--- a/clippy_lints/src/methods/or_fun_call.rs
+++ b/clippy_lints/src/methods/or_fun_call.rs
@@ -186,7 +186,7 @@ pub(super) fn check<'tcx>(
                         check_general_case(cx, name, method_span, &args[0], &args[1], expr.span, None);
                     }
                 }
-            }
+            },
             _ => (),
         }
     }
diff --git a/clippy_lints/src/module_style.rs b/clippy_lints/src/module_style.rs
index f351d0098b7..d41b5474564 100644
--- a/clippy_lints/src/module_style.rs
+++ b/clippy_lints/src/module_style.rs
@@ -106,7 +106,7 @@ impl EarlyLintPass for ModStyle {
                     }
                     process_paths_for_mod_files(path, &mut folder_segments, &mut mod_folders);
                     check_self_named_mod_exists(cx, path, file);
-                }
+                },
                 _ => {},
             }
         }
diff --git a/clippy_lints/src/needless_borrow.rs b/clippy_lints/src/needless_borrow.rs
index 1b2495d764d..f1be90c44f9 100644
--- a/clippy_lints/src/needless_borrow.rs
+++ b/clippy_lints/src/needless_borrow.rs
@@ -107,14 +107,18 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessBorrow {
         if let ExprKind::AddrOf(BorrowKind::Ref, mutability, inner) = e.kind {
             if let ty::Ref(_, ty, _) = cx.typeck_results().expr_ty(inner).kind() {
                 for adj3 in cx.typeck_results().expr_adjustments(e).windows(3) {
-                    if let [Adjustment {
-                        kind: Adjust::Deref(_), ..
-                    }, Adjustment {
-                        kind: Adjust::Deref(_), ..
-                    }, Adjustment {
-                        kind: Adjust::Borrow(_),
-                        ..
-                    }] = *adj3
+                    if let [
+                        Adjustment {
+                            kind: Adjust::Deref(_), ..
+                        },
+                        Adjustment {
+                            kind: Adjust::Deref(_), ..
+                        },
+                        Adjustment {
+                            kind: Adjust::Borrow(_),
+                            ..
+                        },
+                    ] = *adj3
                     {
                         let help_msg_ty = if matches!(mutability, Mutability::Not) {
                             format!("&{}", ty)
diff --git a/clippy_utils/src/higher.rs b/clippy_utils/src/higher.rs
index 60c4cb361aa..7cbd43e6266 100644
--- a/clippy_utils/src/higher.rs
+++ b/clippy_utils/src/higher.rs
@@ -770,13 +770,13 @@ pub fn get_vec_init_kind<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -
                     }
                     return Some(VecInitKind::WithExprCapacity(arg.hir_id));
                 }
-            }
+            },
             ExprKind::Path(QPath::Resolved(_, path))
                 if match_def_path(cx, path.res.opt_def_id()?, &paths::DEFAULT_TRAIT_METHOD)
                     && is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(expr), sym::Vec) =>
             {
                 return Some(VecInitKind::Default);
-            }
+            },
             _ => (),
         }
     }
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index aeb8c12ae8b..bcc38c72256 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -844,10 +844,13 @@ pub fn capture_local_usage(cx: &LateContext<'tcx>, e: &Expr<'_>) -> CaptureKind
     let mut capture_expr_ty = e;
 
     for (parent_id, parent) in cx.tcx.hir().parent_iter(e.hir_id) {
-        if let [Adjustment {
-            kind: Adjust::Deref(_) | Adjust::Borrow(AutoBorrow::Ref(..)),
-            target,
-        }, ref adjust @ ..] = *cx
+        if let [
+            Adjustment {
+                kind: Adjust::Deref(_) | Adjust::Borrow(AutoBorrow::Ref(..)),
+                target,
+            },
+            ref adjust @ ..,
+        ] = *cx
             .typeck_results()
             .adjustments()
             .get(child_id)
@@ -1232,9 +1235,7 @@ pub fn get_enclosing_loop_or_closure(tcx: TyCtxt<'tcx>, expr: &Expr<'_>) -> Opti
     for (_, node) in tcx.hir().parent_iter(expr.hir_id) {
         match node {
             Node::Expr(
-                e
-                @
-                Expr {
+                e @ Expr {
                     kind: ExprKind::Loop(..) | ExprKind::Closure(..),
                     ..
                 },
@@ -1692,10 +1693,12 @@ pub fn is_async_fn(kind: FnKind<'_>) -> bool {
 pub fn get_async_fn_body(tcx: TyCtxt<'tcx>, body: &Body<'_>) -> Option<&'tcx Expr<'tcx>> {
     if let ExprKind::Call(
         _,
-        &[Expr {
-            kind: ExprKind::Closure(_, _, body, _, _),
-            ..
-        }],
+        &[
+            Expr {
+                kind: ExprKind::Closure(_, _, body, _, _),
+                ..
+            },
+        ],
     ) = body.value.kind
     {
         if let ExprKind::Block(
-- 
cgit 1.4.1-3-g733a5


From d38fddd89908cae6767ad599388421f99f71840b Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Sun, 24 Oct 2021 21:06:17 +0200
Subject: Refactor `camel_case` util functions for new `StrIndex`

---
 clippy_lints/src/enum_variants.rs |  16 ++---
 clippy_utils/src/lib.rs           |   2 +-
 clippy_utils/src/str_utils.rs     | 144 +++++++++++++++++++++++++-------------
 3 files changed, 103 insertions(+), 59 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/enum_variants.rs b/clippy_lints/src/enum_variants.rs
index 8d6f7d6fdf1..19f1781d0b0 100644
--- a/clippy_lints/src/enum_variants.rs
+++ b/clippy_lints/src/enum_variants.rs
@@ -1,8 +1,8 @@
 //! lint on enum variants that are prefixed or suffixed by the same characters
 
-use clippy_utils::str_utils;
 use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
 use clippy_utils::source::is_present_in_source;
+use clippy_utils::str_utils;
 use rustc_hir::{EnumDef, Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
@@ -171,14 +171,14 @@ fn check_variant(
         }
     }
     let first = &def.variants[0].ident.name.as_str();
-    let mut pre = &first[..str_utils::until(&*first)];
-    let mut post = &first[str_utils::from(&*first)..];
+    let mut pre = &first[..str_utils::camel_case_until(&*first).byte_index];
+    let mut post = &first[str_utils::camel_case_start(&*first).byte_index..];
     for var in def.variants {
         let name = var.ident.name.as_str();
 
         let pre_match = partial_match(pre, &name);
         pre = &pre[..pre_match];
-        let pre_camel = str_utils::until(pre);
+        let pre_camel = str_utils::camel_case_until(pre).byte_index;
         pre = &pre[..pre_camel];
         while let Some((next, last)) = name[pre.len()..].chars().zip(pre.chars().rev()).next() {
             if next.is_numeric() {
@@ -186,8 +186,8 @@ fn check_variant(
             }
             if next.is_lowercase() {
                 let last = pre.len() - last.len_utf8();
-                let last_camel = str_utils::until(&pre[..last]);
-                pre = &pre[..last_camel];
+                let last_camel = str_utils::camel_case_until(&pre[..last]);
+                pre = &pre[..last_camel.byte_index];
             } else {
                 break;
             }
@@ -196,8 +196,8 @@ fn check_variant(
         let post_match = partial_rmatch(post, &name);
         let post_end = post.len() - post_match;
         post = &post[post_end..];
-        let post_camel = str_utils::from(post);
-        post = &post[post_camel..];
+        let post_camel = str_utils::camel_case_start(post);
+        post = &post[post_camel.byte_index..];
     }
     let (what, value) = match (pre.is_empty(), post.is_empty()) {
         (true, true) => return,
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 1c5186dba1b..0637ae3e97b 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -37,7 +37,6 @@ pub mod sym_helper;
 #[allow(clippy::module_name_repetitions)]
 pub mod ast_utils;
 pub mod attrs;
-pub mod str_utils;
 pub mod comparisons;
 pub mod consts;
 pub mod diagnostics;
@@ -50,6 +49,7 @@ pub mod paths;
 pub mod ptr;
 pub mod qualify_min_const_fn;
 pub mod source;
+pub mod str_utils;
 pub mod sugg;
 pub mod ty;
 pub mod usage;
diff --git a/clippy_utils/src/str_utils.rs b/clippy_utils/src/str_utils.rs
index a6636e39137..f3de1250d5d 100644
--- a/clippy_utils/src/str_utils.rs
+++ b/clippy_utils/src/str_utils.rs
@@ -1,117 +1,161 @@
+/// Dealing with sting indices can be hard, this struct ensures that both the
+/// character and byte index are provided for correct indexing.
+#[derive(Debug, Default, PartialEq, Eq)]
+pub struct StrIndex {
+    pub char_index: usize,
+    pub byte_index: usize,
+}
+
+impl StrIndex {
+    pub fn new(char_index: usize, byte_index: usize) -> Self {
+        Self { char_index, byte_index }
+    }
+}
+
 /// Returns the index of the character after the first camel-case component of `s`.
+///
+/// ```
+/// assert_eq!(camel_case_until("AbcDef"), StrIndex::new(6, 6));
+/// assert_eq!(camel_case_until("ABCD"), StrIndex::new(0, 0));
+/// assert_eq!(camel_case_until("AbcDD"), StrIndex::new(3, 3));
+/// assert_eq!(camel_case_until("Abc\u{f6}\u{f6}DD"), StrIndex::new(5, 7));
+/// ```
 #[must_use]
-pub fn until(s: &str) -> usize {
-    let mut iter = s.char_indices();
-    if let Some((_, first)) = iter.next() {
+pub fn camel_case_until(s: &str) -> StrIndex {
+    let mut iter = s.char_indices().enumerate();
+    if let Some((_char_index, (_, first))) = iter.next() {
         if !first.is_uppercase() {
-            return 0;
+            return StrIndex::new(0, 0);
         }
     } else {
-        return 0;
+        return StrIndex::new(0, 0);
     }
     let mut up = true;
-    let mut last_i = 0;
-    for (i, c) in iter {
+    let mut last_index = StrIndex::new(0, 0);
+    for (char_index, (byte_index, c)) in iter {
         if up {
             if c.is_lowercase() {
                 up = false;
             } else {
-                return last_i;
+                return last_index;
             }
         } else if c.is_uppercase() {
             up = true;
-            last_i = i;
+            last_index.byte_index = byte_index;
+            last_index.char_index = char_index;
         } else if !c.is_lowercase() {
-            return i;
+            return StrIndex::new(char_index, byte_index);
         }
     }
-    if up { last_i } else { s.len() }
+
+    if up {
+        last_index
+    } else {
+        StrIndex::new(s.chars().count(), s.len())
+    }
 }
 
 /// Returns index of the last camel-case component of `s`.
+///
+/// ```
+/// assert_eq!(camel_case_start("AbcDef"), StrIndex::new(0, 0));
+/// assert_eq!(camel_case_start("abcDef"), StrIndex::new(3, 3));
+/// assert_eq!(camel_case_start("ABCD"), StrIndex::new(4, 4));
+/// assert_eq!(camel_case_start("abcd"), StrIndex::new(4, 4));
+/// assert_eq!(camel_case_start("\u{f6}\u{f6}cd"), StrIndex::new(4, 6));
+/// ```
 #[must_use]
-pub fn from(s: &str) -> usize {
-    let mut iter = s.char_indices().rev();
-    if let Some((_, first)) = iter.next() {
+pub fn camel_case_start(s: &str) -> StrIndex {
+    let char_count = s.chars().count();
+    let range = 0..char_count;
+    let mut iter = range.rev().zip(s.char_indices().rev());
+    if let Some((char_index, (_, first))) = iter.next() {
         if !first.is_lowercase() {
-            return s.len();
+            return StrIndex::new(char_index, s.len());
         }
     } else {
-        return s.len();
+        return StrIndex::new(char_count, s.len());
     }
     let mut down = true;
-    let mut last_i = s.len();
-    for (i, c) in iter {
+    let mut last_index = StrIndex::new(char_count, s.len());
+    for (char_index, (byte_index, c)) in iter {
         if down {
             if c.is_uppercase() {
                 down = false;
-                last_i = i;
+                last_index.byte_index = byte_index;
+                last_index.char_index = char_index;
             } else if !c.is_lowercase() {
-                return last_i;
+                return last_index;
             }
         } else if c.is_lowercase() {
             down = true;
         } else if c.is_uppercase() {
-            last_i = i;
+            last_index.byte_index = byte_index;
+            last_index.char_index = char_index;
         } else {
-            return last_i;
+            return last_index;
         }
     }
-    last_i
+    last_index
 }
 
 #[cfg(test)]
 mod test {
-    use super::{from, until};
+    use super::*;
 
     #[test]
-    fn from_full() {
-        assert_eq!(from("AbcDef"), 0);
-        assert_eq!(from("Abc"), 0);
-        assert_eq!(from("ABcd"), 0);
-        assert_eq!(from("ABcdEf"), 0);
-        assert_eq!(from("AabABcd"), 0);
+    fn camel_case_start_full() {
+        assert_eq!(camel_case_start("AbcDef"), StrIndex::new(0, 0));
+        assert_eq!(camel_case_start("Abc"), StrIndex::new(0, 0));
+        assert_eq!(camel_case_start("ABcd"), StrIndex::new(0, 0));
+        assert_eq!(camel_case_start("ABcdEf"), StrIndex::new(0, 0));
+        assert_eq!(camel_case_start("AabABcd"), StrIndex::new(0, 0));
     }
 
     #[test]
-    fn from_partial() {
-        assert_eq!(from("abcDef"), 3);
-        assert_eq!(from("aDbc"), 1);
-        assert_eq!(from("aabABcd"), 3);
+    fn camel_case_start_partial() {
+        assert_eq!(camel_case_start("abcDef"), StrIndex::new(3, 3));
+        assert_eq!(camel_case_start("aDbc"), StrIndex::new(1, 1));
+        assert_eq!(camel_case_start("aabABcd"), StrIndex::new(3, 3));
+        assert_eq!(camel_case_start("\u{f6}\u{f6}AabABcd"), StrIndex::new(2, 4));
     }
 
     #[test]
-    fn from_not() {
-        assert_eq!(from("AbcDef_"), 7);
-        assert_eq!(from("AbcDD"), 5);
+    fn camel_case_start_not() {
+        assert_eq!(camel_case_start("AbcDef_"), StrIndex::new(7, 7));
+        assert_eq!(camel_case_start("AbcDD"), StrIndex::new(5, 5));
+        assert_eq!(camel_case_start("all_small"), StrIndex::new(9, 9));
+        assert_eq!(camel_case_start("\u{f6}_all_small"), StrIndex::new(11, 12));
     }
 
     #[test]
-    fn from_caps() {
-        assert_eq!(from("ABCD"), 4);
+    fn camel_case_start_caps() {
+        assert_eq!(camel_case_start("ABCD"), StrIndex::new(4, 4));
     }
 
     #[test]
-    fn until_full() {
-        assert_eq!(until("AbcDef"), 6);
-        assert_eq!(until("Abc"), 3);
+    fn camel_case_until_full() {
+        assert_eq!(camel_case_until("AbcDef"), StrIndex::new(6, 6));
+        assert_eq!(camel_case_until("Abc"), StrIndex::new(3, 3));
+        assert_eq!(camel_case_until("Abc\u{f6}\u{f6}\u{f6}"), StrIndex::new(6, 9));
     }
 
     #[test]
-    fn until_not() {
-        assert_eq!(until("abcDef"), 0);
-        assert_eq!(until("aDbc"), 0);
+    fn camel_case_until_not() {
+        assert_eq!(camel_case_until("abcDef"), StrIndex::new(0, 0));
+        assert_eq!(camel_case_until("aDbc"), StrIndex::new(0, 0));
     }
 
     #[test]
-    fn until_partial() {
-        assert_eq!(until("AbcDef_"), 6);
-        assert_eq!(until("CallTypeC"), 8);
-        assert_eq!(until("AbcDD"), 3);
+    fn camel_case_until_partial() {
+        assert_eq!(camel_case_until("AbcDef_"), StrIndex::new(6, 6));
+        assert_eq!(camel_case_until("CallTypeC"), StrIndex::new(8, 8));
+        assert_eq!(camel_case_until("AbcDD"), StrIndex::new(3, 3));
+        assert_eq!(camel_case_until("Abc\u{f6}\u{f6}DD"), StrIndex::new(5, 7));
     }
 
     #[test]
     fn until_caps() {
-        assert_eq!(until("ABCD"), 0);
+        assert_eq!(camel_case_until("ABCD"), StrIndex::new(0, 0));
     }
 }
-- 
cgit 1.4.1-3-g733a5


From 7517ae2fb3bc29e91f0f7c2daaac8cd8c8887bb2 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Sun, 24 Oct 2021 22:47:39 +0200
Subject: Refactored some string handling to prevent ICEs and FNs

---
 clippy_lints/src/enum_variants.rs | 44 ++++++++-----------------
 clippy_utils/src/str_utils.rs     | 69 +++++++++++++++++++++++++++++++++++++++
 tests/ui/crashes/ice-7869.rs      |  7 ++++
 tests/ui/crashes/ice-7869.stderr  | 15 +++++++++
 tests/ui/enum_variants.stderr     |  2 +-
 tests/ui/match_ref_pats.rs        |  2 +-
 6 files changed, 106 insertions(+), 33 deletions(-)
 create mode 100644 tests/ui/crashes/ice-7869.rs
 create mode 100644 tests/ui/crashes/ice-7869.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/enum_variants.rs b/clippy_lints/src/enum_variants.rs
index 19f1781d0b0..404b67c8f29 100644
--- a/clippy_lints/src/enum_variants.rs
+++ b/clippy_lints/src/enum_variants.rs
@@ -2,7 +2,7 @@
 
 use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
 use clippy_utils::source::is_present_in_source;
-use clippy_utils::str_utils;
+use clippy_utils::str_utils::{self, count_match_end, count_match_start};
 use rustc_hir::{EnumDef, Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
@@ -117,26 +117,6 @@ impl_lint_pass!(EnumVariantNames => [
     MODULE_INCEPTION
 ]);
 
-/// Returns the number of chars that match from the start
-#[must_use]
-fn partial_match(pre: &str, name: &str) -> usize {
-    let mut name_iter = name.chars();
-    let _ = name_iter.next_back(); // make sure the name is never fully matched
-    pre.chars().zip(name_iter).take_while(|&(l, r)| l == r).count()
-}
-
-/// Returns the number of chars that match from the end
-#[must_use]
-fn partial_rmatch(post: &str, name: &str) -> usize {
-    let mut name_iter = name.chars();
-    let _ = name_iter.next(); // make sure the name is never fully matched
-    post.chars()
-        .rev()
-        .zip(name_iter.rev())
-        .take_while(|&(l, r)| l == r)
-        .count()
-}
-
 fn check_variant(
     cx: &LateContext<'_>,
     threshold: u64,
@@ -150,7 +130,7 @@ fn check_variant(
     }
     for var in def.variants {
         let name = var.ident.name.as_str();
-        if partial_match(item_name, &name) == item_name_chars
+        if count_match_start(item_name, &name).char_count == item_name_chars
             && name.chars().nth(item_name_chars).map_or(false, |c| !c.is_lowercase())
             && name.chars().nth(item_name_chars + 1).map_or(false, |c| !c.is_numeric())
         {
@@ -161,7 +141,7 @@ fn check_variant(
                 "variant name starts with the enum's name",
             );
         }
-        if partial_rmatch(item_name, &name) == item_name_chars {
+        if count_match_end(item_name, &name).char_count == item_name_chars {
             span_lint(
                 cx,
                 ENUM_VARIANT_NAMES,
@@ -176,7 +156,7 @@ fn check_variant(
     for var in def.variants {
         let name = var.ident.name.as_str();
 
-        let pre_match = partial_match(pre, &name);
+        let pre_match = count_match_start(pre, &name).byte_count;
         pre = &pre[..pre_match];
         let pre_camel = str_utils::camel_case_until(pre).byte_index;
         pre = &pre[..pre_camel];
@@ -193,8 +173,8 @@ fn check_variant(
             }
         }
 
-        let post_match = partial_rmatch(post, &name);
-        let post_end = post.len() - post_match;
+        let post_match = count_match_end(post, &name);
+        let post_end = post.len() - post_match.byte_count;
         post = &post[post_end..];
         let post_camel = str_utils::camel_case_start(post);
         post = &post[post_camel.byte_index..];
@@ -266,14 +246,16 @@ impl LateLintPass<'_> for EnumVariantNames {
                             );
                         }
                     }
-                    if item.vis.node.is_pub() {
-                        let matching = partial_match(mod_camel, &item_camel);
-                        let rmatching = partial_rmatch(mod_camel, &item_camel);
+                    // The `module_name_repetitions` lint should only trigger if the item has the module in its
+                    // name. Having the same name is accepted.
+                    if item.vis.node.is_pub() && item_camel.len() > mod_camel.len() {
+                        let matching = count_match_start(mod_camel, &item_camel);
+                        let rmatching = count_match_end(mod_camel, &item_camel);
                         let nchars = mod_camel.chars().count();
 
                         let is_word_beginning = |c: char| c == '_' || c.is_uppercase() || c.is_numeric();
 
-                        if matching == nchars {
+                        if matching.char_count == nchars {
                             match item_camel.chars().nth(nchars) {
                                 Some(c) if is_word_beginning(c) => span_lint(
                                     cx,
@@ -284,7 +266,7 @@ impl LateLintPass<'_> for EnumVariantNames {
                                 _ => (),
                             }
                         }
-                        if rmatching == nchars {
+                        if rmatching.char_count == nchars {
                             span_lint(
                                 cx,
                                 MODULE_NAME_REPETITIONS,
diff --git a/clippy_utils/src/str_utils.rs b/clippy_utils/src/str_utils.rs
index f3de1250d5d..cba96e05a24 100644
--- a/clippy_utils/src/str_utils.rs
+++ b/clippy_utils/src/str_utils.rs
@@ -99,6 +99,75 @@ pub fn camel_case_start(s: &str) -> StrIndex {
     last_index
 }
 
+/// Dealing with sting comparison can be complicated, this struct ensures that both the
+/// character and byte count are provided for correct indexing.
+#[derive(Debug, Default, PartialEq, Eq)]
+pub struct StrCount {
+    pub char_count: usize,
+    pub byte_count: usize,
+}
+
+impl StrCount {
+    pub fn new(char_count: usize, byte_count: usize) -> Self {
+        Self { char_count, byte_count }
+    }
+}
+
+/// Returns the number of chars that match from the start
+///
+/// ```
+/// assert_eq!(count_match_start("hello_mouse", "hello_penguin"), StrCount::new(6, 6));
+/// assert_eq!(count_match_start("hello_clippy", "bye_bugs"), StrCount::new(0, 0));
+/// assert_eq!(count_match_start("hello_world", "hello_world"), StrCount::new(11, 11));
+/// assert_eq!(count_match_start("T\u{f6}ffT\u{f6}ff", "T\u{f6}ff"), StrCount::new(4, 5));
+/// ```
+#[must_use]
+pub fn count_match_start(str1: &str, str2: &str) -> StrCount {
+    // (char_index, char1)
+    let char_count = str1.chars().count();
+    let iter1 = (0..=char_count).zip(str1.chars());
+    // (byte_index, char2)
+    let iter2 = str2.char_indices();
+
+    iter1
+        .zip(iter2)
+        .take_while(|((_, c1), (_, c2))| c1 == c2)
+        .last()
+        .map_or_else(StrCount::default, |((char_index, _), (byte_index, character))| {
+            StrCount::new(char_index + 1, byte_index + character.len_utf8())
+        })
+}
+
+/// Returns the number of chars and bytes that match from the end
+///
+/// ```
+/// assert_eq!(count_match_end("hello_cat", "bye_cat"), StrCount::new(4, 4));
+/// assert_eq!(count_match_end("if_item_thing", "enum_value"), StrCount::new(0, 0));
+/// assert_eq!(count_match_end("Clippy", "Clippy"), StrCount::new(6, 6));
+/// assert_eq!(count_match_end("MyT\u{f6}ff", "YourT\u{f6}ff"), StrCount::new(4, 5));
+/// ```
+#[must_use]
+pub fn count_match_end(str1: &str, str2: &str) -> StrCount {
+    let char_count = str1.chars().count();
+    if char_count == 0 {
+        return StrCount::default();
+    }
+
+    // (char_index, char1)
+    let iter1 = (0..char_count).rev().zip(str1.chars().rev());
+    // (byte_index, char2)
+    let byte_count = str2.len();
+    let iter2 = str2.char_indices().rev();
+
+    iter1
+        .zip(iter2)
+        .take_while(|((_, c1), (_, c2))| c1 == c2)
+        .last()
+        .map_or_else(StrCount::default, |((char_index, _), (byte_index, _))| {
+            StrCount::new(char_count - char_index, byte_count - byte_index)
+        })
+}
+
 #[cfg(test)]
 mod test {
     use super::*;
diff --git a/tests/ui/crashes/ice-7869.rs b/tests/ui/crashes/ice-7869.rs
new file mode 100644
index 00000000000..8f97a063a9a
--- /dev/null
+++ b/tests/ui/crashes/ice-7869.rs
@@ -0,0 +1,7 @@
+enum Tila {
+    TyöAlkoi,
+    TyöKeskeytyi,
+    TyöValmis,
+}
+
+fn main() {}
diff --git a/tests/ui/crashes/ice-7869.stderr b/tests/ui/crashes/ice-7869.stderr
new file mode 100644
index 00000000000..4fa9fb27e76
--- /dev/null
+++ b/tests/ui/crashes/ice-7869.stderr
@@ -0,0 +1,15 @@
+error: all variants have the same prefix: `Työ`
+  --> $DIR/ice-7869.rs:1:1
+   |
+LL | / enum Tila {
+LL | |     TyöAlkoi,
+LL | |     TyöKeskeytyi,
+LL | |     TyöValmis,
+LL | | }
+   | |_^
+   |
+   = note: `-D clippy::enum-variant-names` implied by `-D warnings`
+   = help: remove the prefixes and use full paths to the variants instead of glob imports
+
+error: aborting due to previous error
+
diff --git a/tests/ui/enum_variants.stderr b/tests/ui/enum_variants.stderr
index 447fbb9e1bf..add8a91e26b 100644
--- a/tests/ui/enum_variants.stderr
+++ b/tests/ui/enum_variants.stderr
@@ -60,7 +60,7 @@ LL | | }
    |
    = help: remove the prefixes and use full paths to the variants instead of glob imports
 
-error: all variants have the same prefix: `With`
+error: all variants have the same prefix: `WithOut`
   --> $DIR/enum_variants.rs:81:1
    |
 LL | / enum Seallll {
diff --git a/tests/ui/match_ref_pats.rs b/tests/ui/match_ref_pats.rs
index 50246486bb6..7e3674ab8c9 100644
--- a/tests/ui/match_ref_pats.rs
+++ b/tests/ui/match_ref_pats.rs
@@ -1,5 +1,5 @@
 #![warn(clippy::match_ref_pats)]
-#![allow(clippy::equatable_if_let)]
+#![allow(clippy::equatable_if_let, clippy::enum_variant_names)]
 
 fn ref_pats() {
     {
-- 
cgit 1.4.1-3-g733a5


From 1ad04f4054db6af3e64f95449a86753f2259fc5e Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Sun, 24 Oct 2021 23:01:44 +0200
Subject: Move `non_send_fields_in_send_ty` to `suspicious`

Also updated one configuration for nicer formatting
---
 clippy_lints/src/lib.register_all.rs           | 1 +
 clippy_lints/src/lib.register_nursery.rs       | 1 -
 clippy_lints/src/lib.register_suspicious.rs    | 1 +
 clippy_lints/src/non_send_fields_in_send_ty.rs | 2 +-
 clippy_lints/src/utils/conf.rs                 | 4 ++--
 doc/adding_lints.md                            | 3 ++-
 6 files changed, 7 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index c949ee23ecc..e08bfeec7ca 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -218,6 +218,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(non_copy_const::DECLARE_INTERIOR_MUTABLE_CONST),
     LintId::of(non_expressive_names::JUST_UNDERSCORES_AND_DIGITS),
     LintId::of(non_octal_unix_permissions::NON_OCTAL_UNIX_PERMISSIONS),
+    LintId::of(non_send_fields_in_send_ty::NON_SEND_FIELDS_IN_SEND_TY),
     LintId::of(open_options::NONSENSICAL_OPEN_OPTIONS),
     LintId::of(option_env_unwrap::OPTION_ENV_UNWRAP),
     LintId::of(overflow_check_conditional::OVERFLOW_CHECK_CONDITIONAL),
diff --git a/clippy_lints/src/lib.register_nursery.rs b/clippy_lints/src/lib.register_nursery.rs
index 1e54482a8da..44c75a11eec 100644
--- a/clippy_lints/src/lib.register_nursery.rs
+++ b/clippy_lints/src/lib.register_nursery.rs
@@ -17,7 +17,6 @@ store.register_group(true, "clippy::nursery", Some("clippy_nursery"), vec![
     LintId::of(missing_const_for_fn::MISSING_CONST_FOR_FN),
     LintId::of(mutable_debug_assertion::DEBUG_ASSERT_WITH_MUT_CALL),
     LintId::of(mutex_atomic::MUTEX_INTEGER),
-    LintId::of(non_send_fields_in_send_ty::NON_SEND_FIELDS_IN_SEND_TY),
     LintId::of(nonstandard_macro_braces::NONSTANDARD_MACRO_BRACES),
     LintId::of(option_if_let_else::OPTION_IF_LET_ELSE),
     LintId::of(path_buf_push_overwrite::PATH_BUF_PUSH_OVERWRITE),
diff --git a/clippy_lints/src/lib.register_suspicious.rs b/clippy_lints/src/lib.register_suspicious.rs
index 8859787fbc8..a3f964d1580 100644
--- a/clippy_lints/src/lib.register_suspicious.rs
+++ b/clippy_lints/src/lib.register_suspicious.rs
@@ -15,6 +15,7 @@ store.register_group(true, "clippy::suspicious", Some("clippy_suspicious"), vec!
     LintId::of(loops::MUT_RANGE_BOUND),
     LintId::of(methods::SUSPICIOUS_MAP),
     LintId::of(mut_key::MUTABLE_KEY_TYPE),
+    LintId::of(non_send_fields_in_send_ty::NON_SEND_FIELDS_IN_SEND_TY),
     LintId::of(suspicious_trait_impl::SUSPICIOUS_ARITHMETIC_IMPL),
     LintId::of(suspicious_trait_impl::SUSPICIOUS_OP_ASSIGN_IMPL),
 ])
diff --git a/clippy_lints/src/non_send_fields_in_send_ty.rs b/clippy_lints/src/non_send_fields_in_send_ty.rs
index 374b7bd5964..7ebf84d400f 100644
--- a/clippy_lints/src/non_send_fields_in_send_ty.rs
+++ b/clippy_lints/src/non_send_fields_in_send_ty.rs
@@ -44,7 +44,7 @@ declare_clippy_lint! {
     /// Use thread-safe types like [`std::sync::Arc`](https://doc.rust-lang.org/std/sync/struct.Arc.html)
     /// or specify correct bounds on generic type parameters (`T: Send`).
     pub NON_SEND_FIELDS_IN_SEND_TY,
-    nursery,
+    suspicious,
     "there is field that does not implement `Send` in a `Send` struct"
 }
 
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index d05c52122d5..122a5ce3fc8 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -288,10 +288,10 @@ define_Conf! {
     ///
     /// The list of imports to always rename, a fully qualified path followed by the rename.
     (enforced_import_renames: Vec<crate::utils::conf::Rename> = Vec::new()),
-    /// Lint: RESTRICTED_SCRIPTS.
+    /// Lint: DISALLOWED_SCRIPT_IDENTS.
     ///
     /// The list of unicode scripts allowed to be used in the scope.
-    (allowed_scripts: Vec<String> = vec!["Latin".to_string()]),
+    (allowed_scripts: Vec<String> = ["Latin"].iter().map(ToString::to_string).collect()),
     /// Lint: NON_SEND_FIELDS_IN_SEND_TY.
     ///
     /// Whether to apply the raw pointer heuristic to determine if a type is `Send`.
diff --git a/doc/adding_lints.md b/doc/adding_lints.md
index 004eb28b446..e0a9b27777a 100644
--- a/doc/adding_lints.md
+++ b/doc/adding_lints.md
@@ -564,7 +564,8 @@ in the following steps:
     /// <The configuration field doc comment>
     (configuration_ident: Type = DefaultValue),
     ```
-    The doc comment will be automatically added to the lint documentation.
+    The doc comment is automatically added to the documentation of the listed lints. The default
+    value will be formatted using the `Debug` implementation of the type.
 2. Adding the configuration value to the lint impl struct:
     1. This first requires the definition of a lint impl struct. Lint impl structs are usually
         generated with the `declare_lint_pass!` macro. This struct needs to be defined manually
-- 
cgit 1.4.1-3-g733a5


From 999b3004c499e96e62d677d79fab47c5c514636a Mon Sep 17 00:00:00 2001
From: Andre Bogus <bogusandre@gmail.com>
Date: Mon, 25 Oct 2021 09:46:47 +0200
Subject: new lint: string-slice

---
 CHANGELOG.md                                 |   1 +
 clippy_lints/src/lib.register_lints.rs       |   1 +
 clippy_lints/src/lib.register_restriction.rs |   1 +
 clippy_lints/src/strings.rs                  | 106 ++++++++++++++++++---------
 tests/ui/string_slice.rs                     |  10 +++
 tests/ui/string_slice.stderr                 |  22 ++++++
 6 files changed, 106 insertions(+), 35 deletions(-)
 create mode 100644 tests/ui/string_slice.rs
 create mode 100644 tests/ui/string_slice.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 3b4c687209e..fe4c3bf6261 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3000,6 +3000,7 @@ Released 2018-09-13
 [`string_extend_chars`]: https://rust-lang.github.io/rust-clippy/master/index.html#string_extend_chars
 [`string_from_utf8_as_bytes`]: https://rust-lang.github.io/rust-clippy/master/index.html#string_from_utf8_as_bytes
 [`string_lit_as_bytes`]: https://rust-lang.github.io/rust-clippy/master/index.html#string_lit_as_bytes
+[`string_slice`]: https://rust-lang.github.io/rust-clippy/master/index.html#string_slice
 [`string_to_string`]: https://rust-lang.github.io/rust-clippy/master/index.html#string_to_string
 [`strlen_on_c_strings`]: https://rust-lang.github.io/rust-clippy/master/index.html#strlen_on_c_strings
 [`struct_excessive_bools`]: https://rust-lang.github.io/rust-clippy/master/index.html#struct_excessive_bools
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index e8dd3708c8e..ff0a0f97397 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -431,6 +431,7 @@ store.register_lints(&[
     strings::STRING_ADD_ASSIGN,
     strings::STRING_FROM_UTF8_AS_BYTES,
     strings::STRING_LIT_AS_BYTES,
+    strings::STRING_SLICE,
     strings::STRING_TO_STRING,
     strings::STR_TO_STRING,
     strlen_on_c_strings::STRLEN_ON_C_STRINGS,
diff --git a/clippy_lints/src/lib.register_restriction.rs b/clippy_lints/src/lib.register_restriction.rs
index 3d68a6e9009..4929bbecde0 100644
--- a/clippy_lints/src/lib.register_restriction.rs
+++ b/clippy_lints/src/lib.register_restriction.rs
@@ -53,6 +53,7 @@ store.register_group(true, "clippy::restriction", Some("clippy_restriction"), ve
     LintId::of(shadow::SHADOW_SAME),
     LintId::of(shadow::SHADOW_UNRELATED),
     LintId::of(strings::STRING_ADD),
+    LintId::of(strings::STRING_SLICE),
     LintId::of(strings::STRING_TO_STRING),
     LintId::of(strings::STR_TO_STRING),
     LintId::of(types::RC_BUFFER),
diff --git a/clippy_lints/src/strings.rs b/clippy_lints/src/strings.rs
index 35b6bde5696..6435107b8b4 100644
--- a/clippy_lints/src/strings.rs
+++ b/clippy_lints/src/strings.rs
@@ -107,51 +107,87 @@ declare_clippy_lint! {
     "calling `as_bytes` on a string literal instead of using a byte string literal"
 }
 
-declare_lint_pass!(StringAdd => [STRING_ADD, STRING_ADD_ASSIGN]);
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for slice operations on strings
+    ///
+    /// ### Why is this bad?
+    /// UTF-8 characters span multiple bytes, and it is easy to inadvertently confuse character
+    /// counts and string indices. This may lead to panics, and should warrant some test cases
+    /// containing wide UTF-8 characters. This lint is most useful in code that should avoid
+    /// panics at all costs.
+    ///
+    /// ### Known problems
+    /// Probably lots of false positives. If an index comes from a known valid position (e.g.
+    /// obtained via `char_indices` over the same string), it is totally OK.
+    ///
+    /// # Example
+    /// ```rust,should_panic
+    /// &"Ölkanne"[1..];
+    /// ```
+    pub STRING_SLICE,
+    restriction,
+    "slicing a string"
+}
+
+declare_lint_pass!(StringAdd => [STRING_ADD, STRING_ADD_ASSIGN, STRING_SLICE]);
 
 impl<'tcx> LateLintPass<'tcx> for StringAdd {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
         if in_external_macro(cx.sess(), e.span) {
             return;
         }
-
-        if let ExprKind::Binary(
-            Spanned {
-                node: BinOpKind::Add, ..
-            },
-            left,
-            _,
-        ) = e.kind
-        {
-            if is_string(cx, left) {
-                if !is_lint_allowed(cx, STRING_ADD_ASSIGN, e.hir_id) {
-                    let parent = get_parent_expr(cx, e);
-                    if let Some(p) = parent {
-                        if let ExprKind::Assign(target, _, _) = p.kind {
-                            // avoid duplicate matches
-                            if SpanlessEq::new(cx).eq_expr(target, left) {
-                                return;
+        match e.kind {
+            ExprKind::Binary(
+                Spanned {
+                    node: BinOpKind::Add, ..
+                },
+                left,
+                _,
+            ) => {
+                if is_string(cx, left) {
+                    if !is_lint_allowed(cx, STRING_ADD_ASSIGN, e.hir_id) {
+                        let parent = get_parent_expr(cx, e);
+                        if let Some(p) = parent {
+                            if let ExprKind::Assign(target, _, _) = p.kind {
+                                // avoid duplicate matches
+                                if SpanlessEq::new(cx).eq_expr(target, left) {
+                                    return;
+                                }
                             }
                         }
                     }
+                    span_lint(
+                        cx,
+                        STRING_ADD,
+                        e.span,
+                        "you added something to a string. Consider using `String::push_str()` instead",
+                    );
                 }
-                span_lint(
-                    cx,
-                    STRING_ADD,
-                    e.span,
-                    "you added something to a string. Consider using `String::push_str()` instead",
-                );
-            }
-        } else if let ExprKind::Assign(target, src, _) = e.kind {
-            if is_string(cx, target) && is_add(cx, src, target) {
-                span_lint(
-                    cx,
-                    STRING_ADD_ASSIGN,
-                    e.span,
-                    "you assigned the result of adding something to this string. Consider using \
-                     `String::push_str()` instead",
-                );
-            }
+            },
+            ExprKind::Assign(target, src, _) => {
+                if is_string(cx, target) && is_add(cx, src, target) {
+                    span_lint(
+                        cx,
+                        STRING_ADD_ASSIGN,
+                        e.span,
+                        "you assigned the result of adding something to this string. Consider using \
+                         `String::push_str()` instead",
+                    );
+                }
+            },
+            ExprKind::Index(target, _idx) => {
+                let e_ty = cx.typeck_results().expr_ty(target).peel_refs();
+                if matches!(e_ty.kind(), ty::Str) || is_type_diagnostic_item(cx, e_ty, sym::String) {
+                    span_lint(
+                        cx,
+                        STRING_SLICE,
+                        e.span,
+                        "indexing into a string may panic if the index is within a UTF-8 character",
+                    );
+                }
+            },
+            _ => {},
         }
     }
 }
diff --git a/tests/ui/string_slice.rs b/tests/ui/string_slice.rs
new file mode 100644
index 00000000000..be4dfc8816c
--- /dev/null
+++ b/tests/ui/string_slice.rs
@@ -0,0 +1,10 @@
+#[warn(clippy::string_slice)]
+#[allow(clippy::no_effect)]
+
+fn main() {
+    &"Ölkanne"[1..];
+    let m = "Mötörhead";
+    &m[2..5];
+    let s = String::from(m);
+    &s[0..2];
+}
diff --git a/tests/ui/string_slice.stderr b/tests/ui/string_slice.stderr
new file mode 100644
index 00000000000..55040bf5df2
--- /dev/null
+++ b/tests/ui/string_slice.stderr
@@ -0,0 +1,22 @@
+error: indexing into a string may panic if the index is within a UTF-8 character
+  --> $DIR/string_slice.rs:5:6
+   |
+LL |     &"Ölkanne"[1..];
+   |      ^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::string-slice` implied by `-D warnings`
+
+error: indexing into a string may panic if the index is within a UTF-8 character
+  --> $DIR/string_slice.rs:7:6
+   |
+LL |     &m[2..5];
+   |      ^^^^^^^
+
+error: indexing into a string may panic if the index is within a UTF-8 character
+  --> $DIR/string_slice.rs:9:6
+   |
+LL |     &s[0..2];
+   |      ^^^^^^^
+
+error: aborting due to 3 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From d0c04b4d78504e5ebab17faa1692d8220b5aff92 Mon Sep 17 00:00:00 2001
From: Devon Hollowood <devonhollowood@google.com>
Date: Tue, 26 Oct 2021 00:53:53 -0700
Subject: Clean up tests/ui/rename.rs

---
 clippy_lints/src/lib.rs |   1 +
 tests/ui/rename.fixed   |  48 +++++++++++++
 tests/ui/rename.rs      |  48 +++++++++++++
 tests/ui/rename.stderr  | 178 ++++++++++++++++++++++++++++++++++++++++++++++--
 4 files changed, 268 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index ed7e8277023..533159eca70 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -828,6 +828,7 @@ fn register_removed_non_tool_lints(store: &mut rustc_lint::LintStore) {
 ///
 /// Used in `./src/driver.rs`.
 pub fn register_renamed(ls: &mut rustc_lint::LintStore) {
+    // NOTE: when renaming a lint, add a corresponding test to tests/ui/rename.rs
     ls.register_renamed("clippy::stutter", "clippy::module_name_repetitions");
     ls.register_renamed("clippy::new_without_default_derive", "clippy::new_without_default");
     ls.register_renamed("clippy::cyclomatic_complexity", "clippy::cognitive_complexity");
diff --git a/tests/ui/rename.fixed b/tests/ui/rename.fixed
index a66c2e587c8..dba18d4e784 100644
--- a/tests/ui/rename.fixed
+++ b/tests/ui/rename.fixed
@@ -6,9 +6,57 @@
 #![allow(clippy::module_name_repetitions)]
 #![allow(clippy::new_without_default)]
 #![allow(clippy::redundant_static_lifetimes)]
+#![allow(clippy::bind_instead_of_map)]
+#![allow(clippy::blocks_in_if_conditions)]
+#![allow(clippy::blocks_in_if_conditions)]
+#![allow(clippy::box_collection)]
+#![allow(clippy::blocks_in_if_conditions)]
+#![allow(clippy::map_unwrap_or)]
+#![allow(clippy::unwrap_used)]
+#![allow(clippy::expect_used)]
+#![allow(clippy::for_loops_over_fallibles)]
+#![allow(clippy::useless_conversion)]
+#![allow(clippy::invisible_characters)]
+#![allow(clippy::single_char_add_str)]
+#![allow(clippy::match_result_ok)]
+// uplifted lints
+#![allow(invalid_value)]
+#![allow(array_into_iter)]
+#![allow(unused_labels)]
+#![allow(drop_bounds)]
+#![allow(temporary_cstring_as_ptr)]
+#![allow(non_fmt_panics)]
+#![allow(unknown_lints)]
+#![allow(invalid_atomic_ordering)]
+#![allow(enum_intrinsics_non_enums)]
 // warn for the old lint name here, to test if the renaming worked
 #![warn(clippy::cognitive_complexity)]
 #![warn(enum_intrinsics_non_enums)]
+#![warn(clippy::bind_instead_of_map)]
+#![warn(clippy::box_collection)]
+#![warn(clippy::map_unwrap_or)]
+#![warn(clippy::map_unwrap_or)]
+#![warn(clippy::map_unwrap_or)]
+#![warn(clippy::unwrap_used)]
+#![warn(clippy::unwrap_used)]
+#![warn(clippy::expect_used)]
+#![warn(clippy::expect_used)]
+#![warn(clippy::for_loops_over_fallibles)]
+#![warn(clippy::for_loops_over_fallibles)]
+#![warn(clippy::useless_conversion)]
+#![warn(clippy::invisible_characters)]
+#![warn(clippy::single_char_add_str)]
+#![warn(clippy::match_result_ok)]
+// uplifted lints
+#![warn(invalid_value)]
+#![warn(array_into_iter)]
+#![warn(unused_labels)]
+#![warn(drop_bounds)]
+#![warn(temporary_cstring_as_ptr)]
+#![warn(non_fmt_panics)]
+#![warn(unknown_lints)]
+#![warn(invalid_atomic_ordering)]
+#![warn(enum_intrinsics_non_enums)]
 
 #[warn(clippy::module_name_repetitions)]
 fn main() {}
diff --git a/tests/ui/rename.rs b/tests/ui/rename.rs
index fa81201a2da..a4f0997133c 100644
--- a/tests/ui/rename.rs
+++ b/tests/ui/rename.rs
@@ -6,9 +6,57 @@
 #![allow(clippy::module_name_repetitions)]
 #![allow(clippy::new_without_default)]
 #![allow(clippy::redundant_static_lifetimes)]
+#![allow(clippy::bind_instead_of_map)]
+#![allow(clippy::block_in_if_condition_expr)]
+#![allow(clippy::block_in_if_condition_stmt)]
+#![allow(clippy::box_collection)]
+#![allow(clippy::blocks_in_if_conditions)]
+#![allow(clippy::map_unwrap_or)]
+#![allow(clippy::unwrap_used)]
+#![allow(clippy::expect_used)]
+#![allow(clippy::for_loop_over_fallibles)]
+#![allow(clippy::useless_conversion)]
+#![allow(clippy::invisible_characters)]
+#![allow(clippy::single_char_add_str)]
+#![allow(clippy::match_result_ok)]
+// uplifted lints
+#![allow(invalid_value)]
+#![allow(array_into_iter)]
+#![allow(unused_labels)]
+#![allow(drop_bounds)]
+#![allow(temporary_cstring_as_ptr)]
+#![allow(non_fmt_panics)]
+#![allow(unknown_lints)]
+#![allow(invalid_atomic_ordering)]
+#![allow(enum_intrinsics_non_enums)]
 // warn for the old lint name here, to test if the renaming worked
 #![warn(clippy::cyclomatic_complexity)]
 #![warn(clippy::mem_discriminant_non_enum)]
+#![warn(clippy::option_and_then_some)]
+#![warn(clippy::box_vec)]
+#![warn(clippy::option_map_unwrap_or)]
+#![warn(clippy::option_map_unwrap_or_else)]
+#![warn(clippy::result_map_unwrap_or_else)]
+#![warn(clippy::option_unwrap_used)]
+#![warn(clippy::result_unwrap_used)]
+#![warn(clippy::option_expect_used)]
+#![warn(clippy::result_expect_used)]
+#![warn(clippy::for_loop_over_option)]
+#![warn(clippy::for_loop_over_result)]
+#![warn(clippy::identity_conversion)]
+#![warn(clippy::zero_width_space)]
+#![warn(clippy::single_char_push_str)]
+#![warn(clippy::if_let_some_result)]
+// uplifted lints
+#![warn(clippy::invalid_ref)]
+#![warn(clippy::into_iter_on_array)]
+#![warn(clippy::unused_label)]
+#![warn(clippy::drop_bounds)]
+#![warn(clippy::temporary_cstring_as_ptr)]
+#![warn(clippy::panic_params)]
+#![warn(clippy::unknown_clippy_lints)]
+#![warn(clippy::invalid_atomic_ordering)]
+#![warn(clippy::mem_discriminant_non_enum)]
 
 #[warn(clippy::stutter)]
 fn main() {}
diff --git a/tests/ui/rename.stderr b/tests/ui/rename.stderr
index 05c7854074c..af4ef2762c9 100644
--- a/tests/ui/rename.stderr
+++ b/tests/ui/rename.stderr
@@ -1,34 +1,198 @@
+error: lint `clippy::block_in_if_condition_expr` has been renamed to `clippy::blocks_in_if_conditions`
+  --> $DIR/rename.rs:10:10
+   |
+LL | #![allow(clippy::block_in_if_condition_expr)]
+   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::blocks_in_if_conditions`
+   |
+   = note: `-D renamed-and-removed-lints` implied by `-D warnings`
+
+error: lint `clippy::block_in_if_condition_stmt` has been renamed to `clippy::blocks_in_if_conditions`
+  --> $DIR/rename.rs:11:10
+   |
+LL | #![allow(clippy::block_in_if_condition_stmt)]
+   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::blocks_in_if_conditions`
+
+error: unknown lint: `clippy::for_loop_over_fallibles`
+  --> $DIR/rename.rs:17:10
+   |
+LL | #![allow(clippy::for_loop_over_fallibles)]
+   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: did you mean: `clippy::for_loops_over_fallibles`
+   |
+   = note: `-D unknown-lints` implied by `-D warnings`
+
 error: lint `clippy::cyclomatic_complexity` has been renamed to `clippy::cognitive_complexity`
-  --> $DIR/rename.rs:10:9
+  --> $DIR/rename.rs:33:9
    |
 LL | #![warn(clippy::cyclomatic_complexity)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::cognitive_complexity`
+
+error: lint `clippy::mem_discriminant_non_enum` has been renamed to `enum_intrinsics_non_enums`
+  --> $DIR/rename.rs:34:9
    |
-   = note: `-D renamed-and-removed-lints` implied by `-D warnings`
+LL | #![warn(clippy::mem_discriminant_non_enum)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `enum_intrinsics_non_enums`
+
+error: lint `clippy::option_and_then_some` has been renamed to `clippy::bind_instead_of_map`
+  --> $DIR/rename.rs:35:9
+   |
+LL | #![warn(clippy::option_and_then_some)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::bind_instead_of_map`
+
+error: lint `clippy::box_vec` has been renamed to `clippy::box_collection`
+  --> $DIR/rename.rs:36:9
+   |
+LL | #![warn(clippy::box_vec)]
+   |         ^^^^^^^^^^^^^^^ help: use the new name: `clippy::box_collection`
+
+error: lint `clippy::option_map_unwrap_or` has been renamed to `clippy::map_unwrap_or`
+  --> $DIR/rename.rs:37:9
+   |
+LL | #![warn(clippy::option_map_unwrap_or)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::map_unwrap_or`
+
+error: lint `clippy::option_map_unwrap_or_else` has been renamed to `clippy::map_unwrap_or`
+  --> $DIR/rename.rs:38:9
+   |
+LL | #![warn(clippy::option_map_unwrap_or_else)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::map_unwrap_or`
+
+error: lint `clippy::result_map_unwrap_or_else` has been renamed to `clippy::map_unwrap_or`
+  --> $DIR/rename.rs:39:9
+   |
+LL | #![warn(clippy::result_map_unwrap_or_else)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::map_unwrap_or`
+
+error: lint `clippy::option_unwrap_used` has been renamed to `clippy::unwrap_used`
+  --> $DIR/rename.rs:40:9
+   |
+LL | #![warn(clippy::option_unwrap_used)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::unwrap_used`
+
+error: lint `clippy::result_unwrap_used` has been renamed to `clippy::unwrap_used`
+  --> $DIR/rename.rs:41:9
+   |
+LL | #![warn(clippy::result_unwrap_used)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::unwrap_used`
+
+error: lint `clippy::option_expect_used` has been renamed to `clippy::expect_used`
+  --> $DIR/rename.rs:42:9
+   |
+LL | #![warn(clippy::option_expect_used)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::expect_used`
+
+error: lint `clippy::result_expect_used` has been renamed to `clippy::expect_used`
+  --> $DIR/rename.rs:43:9
+   |
+LL | #![warn(clippy::result_expect_used)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::expect_used`
+
+error: lint `clippy::for_loop_over_option` has been renamed to `clippy::for_loops_over_fallibles`
+  --> $DIR/rename.rs:44:9
+   |
+LL | #![warn(clippy::for_loop_over_option)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::for_loops_over_fallibles`
+
+error: lint `clippy::for_loop_over_result` has been renamed to `clippy::for_loops_over_fallibles`
+  --> $DIR/rename.rs:45:9
+   |
+LL | #![warn(clippy::for_loop_over_result)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::for_loops_over_fallibles`
+
+error: lint `clippy::identity_conversion` has been renamed to `clippy::useless_conversion`
+  --> $DIR/rename.rs:46:9
+   |
+LL | #![warn(clippy::identity_conversion)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::useless_conversion`
+
+error: lint `clippy::zero_width_space` has been renamed to `clippy::invisible_characters`
+  --> $DIR/rename.rs:47:9
+   |
+LL | #![warn(clippy::zero_width_space)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::invisible_characters`
+
+error: lint `clippy::single_char_push_str` has been renamed to `clippy::single_char_add_str`
+  --> $DIR/rename.rs:48:9
+   |
+LL | #![warn(clippy::single_char_push_str)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::single_char_add_str`
+
+error: lint `clippy::if_let_some_result` has been renamed to `clippy::match_result_ok`
+  --> $DIR/rename.rs:49:9
+   |
+LL | #![warn(clippy::if_let_some_result)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::match_result_ok`
+
+error: lint `clippy::invalid_ref` has been renamed to `invalid_value`
+  --> $DIR/rename.rs:51:9
+   |
+LL | #![warn(clippy::invalid_ref)]
+   |         ^^^^^^^^^^^^^^^^^^^ help: use the new name: `invalid_value`
+
+error: lint `clippy::into_iter_on_array` has been renamed to `array_into_iter`
+  --> $DIR/rename.rs:52:9
+   |
+LL | #![warn(clippy::into_iter_on_array)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `array_into_iter`
+
+error: lint `clippy::unused_label` has been renamed to `unused_labels`
+  --> $DIR/rename.rs:53:9
+   |
+LL | #![warn(clippy::unused_label)]
+   |         ^^^^^^^^^^^^^^^^^^^^ help: use the new name: `unused_labels`
+
+error: lint `clippy::drop_bounds` has been renamed to `drop_bounds`
+  --> $DIR/rename.rs:54:9
+   |
+LL | #![warn(clippy::drop_bounds)]
+   |         ^^^^^^^^^^^^^^^^^^^ help: use the new name: `drop_bounds`
+
+error: lint `clippy::temporary_cstring_as_ptr` has been renamed to `temporary_cstring_as_ptr`
+  --> $DIR/rename.rs:55:9
+   |
+LL | #![warn(clippy::temporary_cstring_as_ptr)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `temporary_cstring_as_ptr`
+
+error: lint `clippy::panic_params` has been renamed to `non_fmt_panics`
+  --> $DIR/rename.rs:56:9
+   |
+LL | #![warn(clippy::panic_params)]
+   |         ^^^^^^^^^^^^^^^^^^^^ help: use the new name: `non_fmt_panics`
+
+error: lint `clippy::unknown_clippy_lints` has been renamed to `unknown_lints`
+  --> $DIR/rename.rs:57:9
+   |
+LL | #![warn(clippy::unknown_clippy_lints)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `unknown_lints`
+
+error: lint `clippy::invalid_atomic_ordering` has been renamed to `invalid_atomic_ordering`
+  --> $DIR/rename.rs:58:9
+   |
+LL | #![warn(clippy::invalid_atomic_ordering)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `invalid_atomic_ordering`
 
 error: lint `clippy::mem_discriminant_non_enum` has been renamed to `enum_intrinsics_non_enums`
-  --> $DIR/rename.rs:11:9
+  --> $DIR/rename.rs:59:9
    |
 LL | #![warn(clippy::mem_discriminant_non_enum)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `enum_intrinsics_non_enums`
 
 error: lint `clippy::stutter` has been renamed to `clippy::module_name_repetitions`
-  --> $DIR/rename.rs:13:8
+  --> $DIR/rename.rs:61:8
    |
 LL | #[warn(clippy::stutter)]
    |        ^^^^^^^^^^^^^^^ help: use the new name: `clippy::module_name_repetitions`
 
 error: lint `clippy::new_without_default_derive` has been renamed to `clippy::new_without_default`
-  --> $DIR/rename.rs:16:8
+  --> $DIR/rename.rs:64:8
    |
 LL | #[warn(clippy::new_without_default_derive)]
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::new_without_default`
 
 error: lint `clippy::const_static_lifetime` has been renamed to `clippy::redundant_static_lifetimes`
-  --> $DIR/rename.rs:19:8
+  --> $DIR/rename.rs:67:8
    |
 LL | #[warn(clippy::const_static_lifetime)]
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::redundant_static_lifetimes`
 
-error: aborting due to 5 previous errors
+error: aborting due to 32 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From a1a399d16830ac84c1ce18c2a0e8a77a13edf265 Mon Sep 17 00:00:00 2001
From: dswij <dswijj@gmail.com>
Date: Fri, 22 Oct 2021 13:41:46 +0800
Subject: Fix `question_mark` FP on calls

---
 clippy_lints/src/question_mark.rs | 14 ++++----------
 1 file changed, 4 insertions(+), 10 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/question_mark.rs b/clippy_lints/src/question_mark.rs
index 4d616e26bfc..01fa523300a 100644
--- a/clippy_lints/src/question_mark.rs
+++ b/clippy_lints/src/question_mark.rs
@@ -172,23 +172,17 @@ impl QuestionMark {
         }
     }
 
-    fn expression_returns_unmodified_err(
-        cx: &LateContext<'_>,
-        expression: &Expr<'_>,
-        origin_hir_id: &Expr<'_>,
-    ) -> bool {
+    fn expression_returns_unmodified_err(cx: &LateContext<'_>, expression: &Expr<'_>, cond_expr: &Expr<'_>) -> bool {
         match expression.kind {
             ExprKind::Block(block, _) => {
                 if let Some(return_expression) = Self::return_expression(block) {
-                    return Self::expression_returns_unmodified_err(cx, return_expression, origin_hir_id);
+                    return Self::expression_returns_unmodified_err(cx, return_expression, cond_expr);
                 }
 
                 false
             },
-            ExprKind::Ret(Some(expr)) | ExprKind::Call(expr, _) => {
-                Self::expression_returns_unmodified_err(cx, expr, origin_hir_id)
-            },
-            ExprKind::Path(_) => path_to_local(expression) == path_to_local(origin_hir_id),
+            ExprKind::Ret(Some(expr)) => Self::expression_returns_unmodified_err(cx, expr, cond_expr),
+            ExprKind::Path(_) => path_to_local(expression) == path_to_local(cond_expr),
             _ => false,
         }
     }
-- 
cgit 1.4.1-3-g733a5


From fb0fbad5caa97da949cb2c6dbc56a1185bb53af9 Mon Sep 17 00:00:00 2001
From: Dharma Saputra Wijaya <dswijj@gmail.com>
Date: Tue, 26 Oct 2021 21:22:22 +0800
Subject: Rename variable name in `question_mark`

---
 clippy_lints/src/question_mark.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/question_mark.rs b/clippy_lints/src/question_mark.rs
index 01fa523300a..f63ef163bcb 100644
--- a/clippy_lints/src/question_mark.rs
+++ b/clippy_lints/src/question_mark.rs
@@ -172,8 +172,8 @@ impl QuestionMark {
         }
     }
 
-    fn expression_returns_unmodified_err(cx: &LateContext<'_>, expression: &Expr<'_>, cond_expr: &Expr<'_>) -> bool {
-        match expression.kind {
+    fn expression_returns_unmodified_err(cx: &LateContext<'_>, expr: &Expr<'_>, cond_expr: &Expr<'_>) -> bool {
+        match expr.kind {
             ExprKind::Block(block, _) => {
                 if let Some(return_expression) = Self::return_expression(block) {
                     return Self::expression_returns_unmodified_err(cx, return_expression, cond_expr);
@@ -181,8 +181,8 @@ impl QuestionMark {
 
                 false
             },
-            ExprKind::Ret(Some(expr)) => Self::expression_returns_unmodified_err(cx, expr, cond_expr),
-            ExprKind::Path(_) => path_to_local(expression) == path_to_local(cond_expr),
+            ExprKind::Ret(Some(ret_expr)) => Self::expression_returns_unmodified_err(cx, ret_expr, cond_expr),
+            ExprKind::Path(_) => path_to_local(expr) == path_to_local(cond_expr),
             _ => false,
         }
     }
-- 
cgit 1.4.1-3-g733a5


From e48ab448f9b3c23e583256f2028731639bb168cd Mon Sep 17 00:00:00 2001
From: Devon Hollowood <devonhollowood@google.com>
Date: Tue, 26 Oct 2021 10:52:35 -0700
Subject: Clean up `tests/ui/deprecated.rs`

This also removes the uplifted lints from this test suite -- these are now
tested in `tests/ui/rename.rs`
---
 clippy_lints/src/deprecated_lints.rs |   3 +
 tests/ui/deprecated.rs               |  33 +++++----
 tests/ui/deprecated.stderr           | 128 +++++++++++++++++------------------
 3 files changed, 80 insertions(+), 84 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/deprecated_lints.rs b/clippy_lints/src/deprecated_lints.rs
index c604516742c..9d8524ec91c 100644
--- a/clippy_lints/src/deprecated_lints.rs
+++ b/clippy_lints/src/deprecated_lints.rs
@@ -1,3 +1,6 @@
+// NOTE: if you add a deprecated lint in this file, please add a corresponding test in
+// tests/ui/deprecated.rs
+
 /// This struct fakes the `Lint` declaration that is usually created by `declare_lint!`. This
 /// enables the simple extraction of the metadata without changing the current deprecation
 /// declaration.
diff --git a/tests/ui/deprecated.rs b/tests/ui/deprecated.rs
index 1943d0092e6..39a2601fee9 100644
--- a/tests/ui/deprecated.rs
+++ b/tests/ui/deprecated.rs
@@ -1,19 +1,18 @@
-#[warn(clippy::unstable_as_slice)]
-#[warn(clippy::unstable_as_mut_slice)]
-#[warn(clippy::misaligned_transmute)]
-#[warn(clippy::unused_collect)]
-#[warn(clippy::invalid_ref)]
-#[warn(clippy::into_iter_on_array)]
-#[warn(clippy::unused_label)]
-#[warn(clippy::regex_macro)]
-#[warn(clippy::drop_bounds)]
-#[warn(clippy::temporary_cstring_as_ptr)]
-#[warn(clippy::panic_params)]
-#[warn(clippy::unknown_clippy_lints)]
-#[warn(clippy::find_map)]
-#[warn(clippy::filter_map)]
-#[warn(clippy::pub_enum_variant_names)]
-#[warn(clippy::wrong_pub_self_convention)]
-#[warn(clippy::invalid_atomic_ordering)]
+#![warn(clippy::should_assert_eq)]
+#![warn(clippy::extend_from_slice)]
+#![warn(clippy::range_step_by_zero)]
+#![warn(clippy::unstable_as_slice)]
+#![warn(clippy::unstable_as_mut_slice)]
+#![warn(clippy::misaligned_transmute)]
+#![warn(clippy::assign_ops)]
+#![warn(clippy::if_let_redundant_pattern_matching)]
+#![warn(clippy::unsafe_vector_initialization)]
+#![warn(clippy::unused_collect)]
+#![warn(clippy::replace_consts)]
+#![warn(clippy::regex_macro)]
+#![warn(clippy::find_map)]
+#![warn(clippy::filter_map)]
+#![warn(clippy::pub_enum_variant_names)]
+#![warn(clippy::wrong_pub_self_convention)]
 
 fn main() {}
diff --git a/tests/ui/deprecated.stderr b/tests/ui/deprecated.stderr
index 51048e45c06..6095f134d55 100644
--- a/tests/ui/deprecated.stderr
+++ b/tests/ui/deprecated.stderr
@@ -1,106 +1,100 @@
-error: lint `clippy::unstable_as_slice` has been removed: `Vec::as_slice` has been stabilized in 1.7
-  --> $DIR/deprecated.rs:1:8
+error: lint `clippy::should_assert_eq` has been removed: `assert!()` will be more flexible with RFC 2011
+  --> $DIR/deprecated.rs:1:9
    |
-LL | #[warn(clippy::unstable_as_slice)]
-   |        ^^^^^^^^^^^^^^^^^^^^^^^^^
+LL | #![warn(clippy::should_assert_eq)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: `-D renamed-and-removed-lints` implied by `-D warnings`
 
-error: lint `clippy::unstable_as_mut_slice` has been removed: `Vec::as_mut_slice` has been stabilized in 1.7
-  --> $DIR/deprecated.rs:2:8
+error: lint `clippy::extend_from_slice` has been removed: `.extend_from_slice(_)` is a faster way to extend a Vec by a slice
+  --> $DIR/deprecated.rs:2:9
    |
-LL | #[warn(clippy::unstable_as_mut_slice)]
-   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL | #![warn(clippy::extend_from_slice)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: lint `clippy::misaligned_transmute` has been removed: this lint has been split into cast_ptr_alignment and transmute_ptr_to_ptr
-  --> $DIR/deprecated.rs:3:8
+error: lint `clippy::range_step_by_zero` has been removed: `iterator.step_by(0)` panics nowadays
+  --> $DIR/deprecated.rs:3:9
    |
-LL | #[warn(clippy::misaligned_transmute)]
-   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL | #![warn(clippy::range_step_by_zero)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: lint `clippy::unused_collect` has been removed: `collect` has been marked as #[must_use] in rustc and that covers all cases of this lint
-  --> $DIR/deprecated.rs:4:8
+error: lint `clippy::unstable_as_slice` has been removed: `Vec::as_slice` has been stabilized in 1.7
+  --> $DIR/deprecated.rs:4:9
    |
-LL | #[warn(clippy::unused_collect)]
-   |        ^^^^^^^^^^^^^^^^^^^^^^
+LL | #![warn(clippy::unstable_as_slice)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: lint `clippy::invalid_ref` has been renamed to `invalid_value`
-  --> $DIR/deprecated.rs:5:8
+error: lint `clippy::unstable_as_mut_slice` has been removed: `Vec::as_mut_slice` has been stabilized in 1.7
+  --> $DIR/deprecated.rs:5:9
    |
-LL | #[warn(clippy::invalid_ref)]
-   |        ^^^^^^^^^^^^^^^^^^^ help: use the new name: `invalid_value`
+LL | #![warn(clippy::unstable_as_mut_slice)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: lint `clippy::into_iter_on_array` has been renamed to `array_into_iter`
-  --> $DIR/deprecated.rs:6:8
+error: lint `clippy::misaligned_transmute` has been removed: this lint has been split into cast_ptr_alignment and transmute_ptr_to_ptr
+  --> $DIR/deprecated.rs:6:9
    |
-LL | #[warn(clippy::into_iter_on_array)]
-   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `array_into_iter`
+LL | #![warn(clippy::misaligned_transmute)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: lint `clippy::unused_label` has been renamed to `unused_labels`
-  --> $DIR/deprecated.rs:7:8
+error: lint `clippy::assign_ops` has been removed: using compound assignment operators (e.g., `+=`) is harmless
+  --> $DIR/deprecated.rs:7:9
    |
-LL | #[warn(clippy::unused_label)]
-   |        ^^^^^^^^^^^^^^^^^^^^ help: use the new name: `unused_labels`
+LL | #![warn(clippy::assign_ops)]
+   |         ^^^^^^^^^^^^^^^^^^
 
-error: lint `clippy::regex_macro` has been removed: the regex! macro has been removed from the regex crate in 2018
-  --> $DIR/deprecated.rs:8:8
+error: lint `clippy::if_let_redundant_pattern_matching` has been removed: this lint has been changed to redundant_pattern_matching
+  --> $DIR/deprecated.rs:8:9
    |
-LL | #[warn(clippy::regex_macro)]
-   |        ^^^^^^^^^^^^^^^^^^^
+LL | #![warn(clippy::if_let_redundant_pattern_matching)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: lint `clippy::drop_bounds` has been renamed to `drop_bounds`
-  --> $DIR/deprecated.rs:9:8
+error: lint `clippy::unsafe_vector_initialization` has been removed: the replacement suggested by this lint had substantially different behavior
+  --> $DIR/deprecated.rs:9:9
    |
-LL | #[warn(clippy::drop_bounds)]
-   |        ^^^^^^^^^^^^^^^^^^^ help: use the new name: `drop_bounds`
+LL | #![warn(clippy::unsafe_vector_initialization)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: lint `clippy::temporary_cstring_as_ptr` has been renamed to `temporary_cstring_as_ptr`
-  --> $DIR/deprecated.rs:10:8
+error: lint `clippy::unused_collect` has been removed: `collect` has been marked as #[must_use] in rustc and that covers all cases of this lint
+  --> $DIR/deprecated.rs:10:9
    |
-LL | #[warn(clippy::temporary_cstring_as_ptr)]
-   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `temporary_cstring_as_ptr`
+LL | #![warn(clippy::unused_collect)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^
 
-error: lint `clippy::panic_params` has been renamed to `non_fmt_panics`
-  --> $DIR/deprecated.rs:11:8
+error: lint `clippy::replace_consts` has been removed: associated-constants `MIN`/`MAX` of integers are preferred to `{min,max}_value()` and module constants
+  --> $DIR/deprecated.rs:11:9
    |
-LL | #[warn(clippy::panic_params)]
-   |        ^^^^^^^^^^^^^^^^^^^^ help: use the new name: `non_fmt_panics`
+LL | #![warn(clippy::replace_consts)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^
 
-error: lint `clippy::unknown_clippy_lints` has been renamed to `unknown_lints`
-  --> $DIR/deprecated.rs:12:8
+error: lint `clippy::regex_macro` has been removed: the regex! macro has been removed from the regex crate in 2018
+  --> $DIR/deprecated.rs:12:9
    |
-LL | #[warn(clippy::unknown_clippy_lints)]
-   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `unknown_lints`
+LL | #![warn(clippy::regex_macro)]
+   |         ^^^^^^^^^^^^^^^^^^^
 
 error: lint `clippy::find_map` has been removed: this lint has been replaced by `manual_find_map`, a more specific lint
-  --> $DIR/deprecated.rs:13:8
+  --> $DIR/deprecated.rs:13:9
    |
-LL | #[warn(clippy::find_map)]
-   |        ^^^^^^^^^^^^^^^^
+LL | #![warn(clippy::find_map)]
+   |         ^^^^^^^^^^^^^^^^
 
 error: lint `clippy::filter_map` has been removed: this lint has been replaced by `manual_filter_map`, a more specific lint
-  --> $DIR/deprecated.rs:14:8
+  --> $DIR/deprecated.rs:14:9
    |
-LL | #[warn(clippy::filter_map)]
-   |        ^^^^^^^^^^^^^^^^^^
+LL | #![warn(clippy::filter_map)]
+   |         ^^^^^^^^^^^^^^^^^^
 
 error: lint `clippy::pub_enum_variant_names` has been removed: set the `avoid-breaking-exported-api` config option to `false` to enable the `enum_variant_names` lint for public items
-  --> $DIR/deprecated.rs:15:8
+  --> $DIR/deprecated.rs:15:9
    |
-LL | #[warn(clippy::pub_enum_variant_names)]
-   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL | #![warn(clippy::pub_enum_variant_names)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: lint `clippy::wrong_pub_self_convention` has been removed: set the `avoid-breaking-exported-api` config option to `false` to enable the `wrong_self_convention` lint for public items
-  --> $DIR/deprecated.rs:16:8
-   |
-LL | #[warn(clippy::wrong_pub_self_convention)]
-   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: lint `clippy::invalid_atomic_ordering` has been renamed to `invalid_atomic_ordering`
-  --> $DIR/deprecated.rs:17:8
+  --> $DIR/deprecated.rs:16:9
    |
-LL | #[warn(clippy::invalid_atomic_ordering)]
-   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `invalid_atomic_ordering`
+LL | #![warn(clippy::wrong_pub_self_convention)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 17 previous errors
+error: aborting due to 16 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From bd778e216d3c58049fe0259ce5c8e8fd45cfcbd6 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Mon, 25 Oct 2021 18:14:54 +0100
Subject: Register the generated lints from `cargo dev new_lint`

---
 clippy_dev/src/new_lint.rs | 40 +++++++++++++++++++++++++++++-----------
 clippy_lints/src/lib.rs    |  2 +-
 doc/adding_lints.md        | 45 ++++++++++++++++++++++++---------------------
 3 files changed, 54 insertions(+), 33 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_dev/src/new_lint.rs b/clippy_dev/src/new_lint.rs
index 25320907bb4..43a478ee77d 100644
--- a/clippy_dev/src/new_lint.rs
+++ b/clippy_dev/src/new_lint.rs
@@ -42,7 +42,8 @@ pub fn create(pass: Option<&str>, lint_name: Option<&str>, category: Option<&str
     };
 
     create_lint(&lint, msrv).context("Unable to create lint implementation")?;
-    create_test(&lint).context("Unable to create a test for the new lint")
+    create_test(&lint).context("Unable to create a test for the new lint")?;
+    add_lint(&lint, msrv).context("Unable to add lint to clippy_lints/src/lib.rs")
 }
 
 fn create_lint(lint: &LintData<'_>, enable_msrv: bool) -> io::Result<()> {
@@ -80,6 +81,33 @@ fn create_test(lint: &LintData<'_>) -> io::Result<()> {
     }
 }
 
+fn add_lint(lint: &LintData<'_>, enable_msrv: bool) -> io::Result<()> {
+    let path = "clippy_lints/src/lib.rs";
+    let mut lib_rs = fs::read_to_string(path).context("reading")?;
+
+    let comment_start = lib_rs.find("// add lints here,").expect("Couldn't find comment");
+
+    let new_lint = if enable_msrv {
+        format!(
+            "store.register_{lint_pass}_pass(move || Box::new({module_name}::{camel_name}::new(msrv)));\n    ",
+            lint_pass = lint.pass,
+            module_name = lint.name,
+            camel_name = to_camel_case(lint.name),
+        )
+    } else {
+        format!(
+            "store.register_{lint_pass}_pass(|| Box::new({module_name}::{camel_name}));\n    ",
+            lint_pass = lint.pass,
+            module_name = lint.name,
+            camel_name = to_camel_case(lint.name),
+        )
+    };
+
+    lib_rs.insert_str(comment_start, &new_lint);
+
+    fs::write(path, lib_rs).context("writing")
+}
+
 fn write_file<P: AsRef<Path>, C: AsRef<[u8]>>(path: P, contents: C) -> io::Result<()> {
     fn inner(path: &Path, contents: &[u8]) -> io::Result<()> {
         OpenOptions::new()
@@ -151,7 +179,6 @@ fn get_lint_file_contents(lint: &LintData<'_>, enable_msrv: bool) -> String {
     };
 
     let lint_name = lint.name;
-    let pass_name = lint.pass;
     let category = lint.category;
     let name_camel = to_camel_case(lint.name);
     let name_upper = lint_name.to_uppercase();
@@ -228,18 +255,14 @@ fn get_lint_file_contents(lint: &LintData<'_>, enable_msrv: bool) -> String {
                     extract_msrv_attr!({context_import});
                 }}
 
-                // TODO: Register the lint pass in `clippy_lints/src/lib.rs`,
-                //       e.g. store.register_{pass_name}_pass(move || Box::new({module_name}::{name_camel}::new(msrv)));
                 // TODO: Add MSRV level to `clippy_utils/src/msrvs.rs` if needed.
                 // TODO: Add MSRV test to `tests/ui/min_rust_version_attr.rs`.
                 // TODO: Update msrv config comment in `clippy_lints/src/utils/conf.rs`
             "},
             pass_type = pass_type,
             pass_lifetimes = pass_lifetimes,
-            pass_name = pass_name,
             name_upper = name_upper,
             name_camel = name_camel,
-            module_name = lint_name,
             context_import = context_import,
         )
     } else {
@@ -248,16 +271,11 @@ fn get_lint_file_contents(lint: &LintData<'_>, enable_msrv: bool) -> String {
                 declare_lint_pass!({name_camel} => [{name_upper}]);
 
                 impl {pass_type}{pass_lifetimes} for {name_camel} {{}}
-                //
-                // TODO: Register the lint pass in `clippy_lints/src/lib.rs`,
-                //       e.g. store.register_{pass_name}_pass(|| Box::new({module_name}::{name_camel}));
             "},
             pass_type = pass_type,
             pass_lifetimes = pass_lifetimes,
-            pass_name = pass_name,
             name_upper = name_upper,
             name_camel = name_camel,
-            module_name = lint_name,
         )
     });
 
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index ed7e8277023..86f9d75c06f 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -777,7 +777,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(match_str_case_mismatch::MatchStrCaseMismatch));
     store.register_late_pass(move || Box::new(format_args::FormatArgs));
     store.register_late_pass(|| Box::new(trailing_empty_array::TrailingEmptyArray));
-
+    // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
 #[rustfmt::skip]
diff --git a/doc/adding_lints.md b/doc/adding_lints.md
index 004eb28b446..0e112e37cbc 100644
--- a/doc/adding_lints.md
+++ b/doc/adding_lints.md
@@ -16,6 +16,7 @@ because that's clearly a non-descriptive name.
   - [Edition 2018 tests](#edition-2018-tests)
   - [Testing manually](#testing-manually)
   - [Lint declaration](#lint-declaration)
+  - [Lint registration](#lint-registration)
   - [Lint passes](#lint-passes)
   - [Emitting a lint](#emitting-a-lint)
   - [Adding the lint logic](#adding-the-lint-logic)
@@ -43,9 +44,9 @@ take a look at our [lint naming guidelines][lint_naming]. To get started on this
 lint you can run `cargo dev new_lint --name=foo_functions --pass=early
 --category=pedantic` (category will default to nursery if not provided). This
 command will create two files: `tests/ui/foo_functions.rs` and
-`clippy_lints/src/foo_functions.rs`, as well as run `cargo dev update_lints` to
-register the new lint. For cargo lints, two project hierarchies (fail/pass) will
-be created by default under `tests/ui-cargo`.
+`clippy_lints/src/foo_functions.rs`, as well as
+[registering the lint](#lint-registration). For cargo lints, two project
+hierarchies (fail/pass) will be created by default under `tests/ui-cargo`.
 
 Next, we'll open up these files and add our lint!
 
@@ -220,32 +221,34 @@ declare_lint_pass!(FooFunctions => [FOO_FUNCTIONS]);
 impl EarlyLintPass for FooFunctions {}
 ```
 
-Normally after declaring the lint, we have to run `cargo dev update_lints`,
-which updates some files, so Clippy knows about the new lint. Since we used
-`cargo dev new_lint ...` to generate the lint declaration, this was done
-automatically. While `update_lints` automates most of the things, it doesn't
-automate everything. We will have to register our lint pass manually in the
-`register_plugins` function in `clippy_lints/src/lib.rs`:
+[declare_clippy_lint]: https://github.com/rust-lang/rust-clippy/blob/557f6848bd5b7183f55c1e1522a326e9e1df6030/clippy_lints/src/lib.rs#L60
+[example_lint_page]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_closure
+[lint_naming]: https://rust-lang.github.io/rfcs/0344-conventions-galore.html#lints
+[category_level_mapping]: https://github.com/rust-lang/rust-clippy/blob/557f6848bd5b7183f55c1e1522a326e9e1df6030/clippy_lints/src/lib.rs#L110
+
+## Lint registration
+
+When using `cargo dev new_lint`, the lint is automatically registered and
+nothing more has to be done.
+
+When declaring a new lint by hand and `cargo dev update_lints` is used, the lint
+pass may have to be registered manually in the `register_plugins` function in
+`clippy_lints/src/lib.rs`:
 
 ```rust
-store.register_early_pass(|| box foo_functions::FooFunctions);
+store.register_early_pass(|| Box::new(foo_functions::FooFunctions));
 ```
 
 As one may expect, there is a corresponding `register_late_pass` method
 available as well. Without a call to one of `register_early_pass` or
 `register_late_pass`, the lint pass in question will not be run.
 
-One reason that `cargo dev` does not automate this step is that multiple lints
-can use the same lint pass, so registering the lint pass may already be done
-when adding a new lint. Another reason that this step is not automated is that
-the order that the passes are registered determines the order the passes
-actually run, which in turn affects the order that any emitted lints are output
-in.
-
-[declare_clippy_lint]: https://github.com/rust-lang/rust-clippy/blob/557f6848bd5b7183f55c1e1522a326e9e1df6030/clippy_lints/src/lib.rs#L60
-[example_lint_page]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_closure
-[lint_naming]: https://rust-lang.github.io/rfcs/0344-conventions-galore.html#lints
-[category_level_mapping]: https://github.com/rust-lang/rust-clippy/blob/557f6848bd5b7183f55c1e1522a326e9e1df6030/clippy_lints/src/lib.rs#L110
+One reason that `cargo dev update_lints` does not automate this step is that
+multiple lints can use the same lint pass, so registering the lint pass may
+already be done when adding a new lint. Another reason that this step is not
+automated is that the order that the passes are registered determines the order
+the passes actually run, which in turn affects the order that any emitted lints
+are output in.
 
 ## Lint passes
 
-- 
cgit 1.4.1-3-g733a5


From dea940259e34a7a78f5006562bea5d74201c88b8 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Tue, 26 Oct 2021 21:39:32 +0200
Subject: Remove hidden code lines in Clippy's lint list

---
 clippy_lints/src/utils/internal_lints/metadata_collector.rs | 13 ++++++++++++-
 1 file changed, 12 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index 0d27874b7af..99cf4c1ed40 100644
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -512,12 +512,21 @@ fn extract_attr_docs(cx: &LateContext<'_>, item: &Item<'_>) -> Option<String> {
     let mut lines = attrs.iter().filter_map(ast::Attribute::doc_str);
     let mut docs = String::from(&*lines.next()?.as_str());
     let mut in_code_block = false;
+    let mut is_code_block_rust = false;
     for line in lines {
-        docs.push('\n');
         let line = line.as_str();
         let line = &*line;
+
+        // Rustdoc hides code lines starting with `# ` and this removes them from Clippy's lint list :)
+        if is_code_block_rust && line.trim_start().starts_with("# ") {
+            continue;
+        }
+
+        // The line should be represented in the lint list, even if it's just an empty line
+        docs.push('\n');
         if let Some(info) = line.trim_start().strip_prefix("```") {
             in_code_block = !in_code_block;
+            is_code_block_rust = false;
             if in_code_block {
                 let lang = info
                     .trim()
@@ -528,6 +537,8 @@ fn extract_attr_docs(cx: &LateContext<'_>, item: &Item<'_>) -> Option<String> {
                     .unwrap_or("rust");
                 docs.push_str("```");
                 docs.push_str(lang);
+
+                is_code_block_rust = lang == "rust";
                 continue;
             }
         }
-- 
cgit 1.4.1-3-g733a5


From 36d4a4ea82b235e65d5ec32bf8f7a81438cf0e10 Mon Sep 17 00:00:00 2001
From: Matt Stavola <matt@stavola.xyz>
Date: Sun, 24 Oct 2021 21:14:20 -0700
Subject: Add unit-hash lint

---
 CHANGELOG.md                                 |  1 +
 clippy_lints/src/lib.register_all.rs         |  1 +
 clippy_lints/src/lib.register_correctness.rs |  1 +
 clippy_lints/src/lib.register_lints.rs       |  1 +
 clippy_lints/src/lib.rs                      |  2 +
 clippy_lints/src/unit_hash.rs                | 77 ++++++++++++++++++++++++++++
 tests/ui/unit_hash.rs                        | 27 ++++++++++
 tests/ui/unit_hash.stderr                    | 27 ++++++++++
 8 files changed, 137 insertions(+)
 create mode 100644 clippy_lints/src/unit_hash.rs
 create mode 100644 tests/ui/unit_hash.rs
 create mode 100644 tests/ui/unit_hash.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 3b4c687209e..c1dba75a4c5 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3046,6 +3046,7 @@ Released 2018-09-13
 [`uninit_vec`]: https://rust-lang.github.io/rust-clippy/master/index.html#uninit_vec
 [`unit_arg`]: https://rust-lang.github.io/rust-clippy/master/index.html#unit_arg
 [`unit_cmp`]: https://rust-lang.github.io/rust-clippy/master/index.html#unit_cmp
+[`unit_hash`]: https://rust-lang.github.io/rust-clippy/master/index.html#unit_hash
 [`unit_return_expecting_ord`]: https://rust-lang.github.io/rust-clippy/master/index.html#unit_return_expecting_ord
 [`unnecessary_cast`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_cast
 [`unnecessary_filter_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_filter_map
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index c949ee23ecc..1dd70ce7c15 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -282,6 +282,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(undropped_manually_drops::UNDROPPED_MANUALLY_DROPS),
     LintId::of(unicode::INVISIBLE_CHARACTERS),
     LintId::of(uninit_vec::UNINIT_VEC),
+    LintId::of(unit_hash::UNIT_HASH),
     LintId::of(unit_return_expecting_ord::UNIT_RETURN_EXPECTING_ORD),
     LintId::of(unit_types::UNIT_ARG),
     LintId::of(unit_types::UNIT_CMP),
diff --git a/clippy_lints/src/lib.register_correctness.rs b/clippy_lints/src/lib.register_correctness.rs
index ff56a6081fb..4217fd3a3ea 100644
--- a/clippy_lints/src/lib.register_correctness.rs
+++ b/clippy_lints/src/lib.register_correctness.rs
@@ -64,6 +64,7 @@ store.register_group(true, "clippy::correctness", Some("clippy_correctness"), ve
     LintId::of(undropped_manually_drops::UNDROPPED_MANUALLY_DROPS),
     LintId::of(unicode::INVISIBLE_CHARACTERS),
     LintId::of(uninit_vec::UNINIT_VEC),
+    LintId::of(unit_hash::UNIT_HASH),
     LintId::of(unit_return_expecting_ord::UNIT_RETURN_EXPECTING_ORD),
     LintId::of(unit_types::UNIT_CMP),
     LintId::of(unnamed_address::FN_ADDRESS_COMPARISONS),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index e8dd3708c8e..d293bb6dfc2 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -476,6 +476,7 @@ store.register_lints(&[
     unicode::NON_ASCII_LITERAL,
     unicode::UNICODE_NOT_NFC,
     uninit_vec::UNINIT_VEC,
+    unit_hash::UNIT_HASH,
     unit_return_expecting_ord::UNIT_RETURN_EXPECTING_ORD,
     unit_types::LET_UNIT_VALUE,
     unit_types::UNIT_ARG,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index ed7e8277023..a167c65263b 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -364,6 +364,7 @@ mod undocumented_unsafe_blocks;
 mod undropped_manually_drops;
 mod unicode;
 mod uninit_vec;
+mod unit_hash;
 mod unit_return_expecting_ord;
 mod unit_types;
 mod unnamed_address;
@@ -522,6 +523,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(collapsible_match::CollapsibleMatch));
     store.register_late_pass(|| Box::new(unicode::Unicode));
     store.register_late_pass(|| Box::new(uninit_vec::UninitVec));
+    store.register_late_pass(|| Box::new(unit_hash::UnitHash));
     store.register_late_pass(|| Box::new(unit_return_expecting_ord::UnitReturnExpectingOrd));
     store.register_late_pass(|| Box::new(strings::StringAdd));
     store.register_late_pass(|| Box::new(implicit_return::ImplicitReturn));
diff --git a/clippy_lints/src/unit_hash.rs b/clippy_lints/src/unit_hash.rs
new file mode 100644
index 00000000000..a3a3f2d41c7
--- /dev/null
+++ b/clippy_lints/src/unit_hash.rs
@@ -0,0 +1,77 @@
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::source::snippet;
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::sym;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Detects `().hash(_)`.
+    ///
+    /// ### Why is this bad?
+    /// Hashing a unit value doesn't do anything as the implementation of `Hash` for `()` is a no-op.
+    ///
+    /// ### Example
+    /// ```rust
+    /// # use std::hash::Hash;
+    /// # use std::collections::hash_map::DefaultHasher;
+    /// # enum Foo { Empty, WithValue(u8) }
+    /// # use Foo::*;
+    /// # let mut state = DefaultHasher::new();
+    /// # let my_enum = Foo::Empty;
+    /// match my_enum {
+    /// 	Empty => ().hash(&mut state),
+    /// 	WithValue(x) => x.hash(&mut state),
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// # use std::hash::Hash;
+    /// # use std::collections::hash_map::DefaultHasher;
+    /// # enum Foo { Empty, WithValue(u8) }
+    /// # use Foo::*;
+    /// # let mut state = DefaultHasher::new();
+    /// # let my_enum = Foo::Empty;
+    /// match my_enum {
+    /// 	Empty => 0_u8.hash(&mut state),
+    /// 	WithValue(x) => x.hash(&mut state),
+    /// }
+    /// ```
+    pub UNIT_HASH,
+    correctness,
+    "hashing a unit value, which does nothing"
+}
+declare_lint_pass!(UnitHash => [UNIT_HASH]);
+
+impl LateLintPass<'tcx> for UnitHash {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
+        if_chain! {
+            if let ExprKind::MethodCall(name_ident, _, args, _) = &expr.kind;
+            if name_ident.ident.name == sym::hash;
+            if let [recv, state_param] = args;
+            if cx.typeck_results().expr_ty(recv).is_unit();
+            then {
+                span_lint_and_then(
+                    cx,
+                    UNIT_HASH,
+                    expr.span,
+                    "this call to `hash` on the unit type will do nothing",
+                    |diag| {
+                        diag.span_suggestion(
+                            expr.span,
+                            "remove the call to `hash` or consider using",
+                            format!(
+                                "0_u8.hash({})",
+                                snippet(cx, state_param.span, ".."),
+                            ),
+                            Applicability::MaybeIncorrect,
+                        );
+                        diag.note("the implementation of `Hash` for `()` is a no-op");
+                    }
+                );
+            }
+        }
+    }
+}
diff --git a/tests/ui/unit_hash.rs b/tests/ui/unit_hash.rs
new file mode 100644
index 00000000000..989916c239b
--- /dev/null
+++ b/tests/ui/unit_hash.rs
@@ -0,0 +1,27 @@
+#![warn(clippy::unit_hash)]
+
+use std::collections::hash_map::DefaultHasher;
+use std::hash::Hash;
+
+enum Foo {
+    Empty,
+    WithValue(u8),
+}
+
+fn do_nothing() {}
+
+fn main() {
+    let mut state = DefaultHasher::new();
+    let my_enum = Foo::Empty;
+
+    match my_enum {
+        Foo::Empty => ().hash(&mut state),
+        Foo::WithValue(x) => x.hash(&mut state),
+    }
+
+    let res = ();
+    res.hash(&mut state);
+
+    #[allow(clippy::unit_arg)]
+    do_nothing().hash(&mut state);
+}
diff --git a/tests/ui/unit_hash.stderr b/tests/ui/unit_hash.stderr
new file mode 100644
index 00000000000..da276296e02
--- /dev/null
+++ b/tests/ui/unit_hash.stderr
@@ -0,0 +1,27 @@
+error: this call to `hash` on the unit type will do nothing
+  --> $DIR/unit_hash.rs:18:23
+   |
+LL |         Foo::Empty => ().hash(&mut state),
+   |                       ^^^^^^^^^^^^^^^^^^^ help: remove the call to `hash` or consider using: `0_u8.hash(&mut state)`
+   |
+   = note: `-D clippy::unit-hash` implied by `-D warnings`
+   = note: the implementation of `Hash` for `()` is a no-op
+
+error: this call to `hash` on the unit type will do nothing
+  --> $DIR/unit_hash.rs:23:5
+   |
+LL |     res.hash(&mut state);
+   |     ^^^^^^^^^^^^^^^^^^^^ help: remove the call to `hash` or consider using: `0_u8.hash(&mut state)`
+   |
+   = note: the implementation of `Hash` for `()` is a no-op
+
+error: this call to `hash` on the unit type will do nothing
+  --> $DIR/unit_hash.rs:26:5
+   |
+LL |     do_nothing().hash(&mut state);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove the call to `hash` or consider using: `0_u8.hash(&mut state)`
+   |
+   = note: the implementation of `Hash` for `()` is a no-op
+
+error: aborting due to 3 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From e2c30f05c11bd06d2ba11584407e6671e7d5d1b8 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Wed, 27 Oct 2021 16:24:00 +0100
Subject: Ignore references to type aliases in ptr_arg

Works using the fact that the hir path will point to a TyAlias, rather
than being resolved to the underlying type
---
 clippy_lints/src/ptr.rs | 53 +++++++++++++++++++++++++++++--------------------
 tests/ui/ptr_arg.rs     |  4 ++++
 2 files changed, 36 insertions(+), 21 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs
index 92a4801a846..8a36e20fc97 100644
--- a/clippy_lints/src/ptr.rs
+++ b/clippy_lints/src/ptr.rs
@@ -3,16 +3,16 @@
 use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::ptr::get_spans;
 use clippy_utils::source::snippet_opt;
-use clippy_utils::ty::{is_type_diagnostic_item, match_type, walk_ptrs_hir_ty};
+use clippy_utils::ty::walk_ptrs_hir_ty;
 use clippy_utils::{expr_path_res, is_lint_allowed, match_any_diagnostic_items, paths};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
+use rustc_hir::def::Res;
 use rustc_hir::{
-    BinOpKind, BodyId, Expr, ExprKind, FnDecl, FnRetTy, GenericArg, HirId, Impl, ImplItem, ImplItemKind, Item,
-    ItemKind, Lifetime, MutTy, Mutability, Node, PathSegment, QPath, TraitFn, TraitItem, TraitItemKind, Ty, TyKind,
+    BinOpKind, BodyId, Expr, ExprKind, FnDecl, FnRetTy, GenericArg, Impl, ImplItem, ImplItemKind, Item, ItemKind,
+    Lifetime, MutTy, Mutability, Node, PathSegment, QPath, TraitFn, TraitItem, TraitItemKind, Ty, TyKind,
 };
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
 use rustc_span::symbol::Symbol;
@@ -153,7 +153,7 @@ declare_lint_pass!(Ptr => [PTR_ARG, CMP_NULL, MUT_FROM_REF, INVALID_NULL_PTR_USA
 impl<'tcx> LateLintPass<'tcx> for Ptr {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
         if let ItemKind::Fn(ref sig, _, body_id) = item.kind {
-            check_fn(cx, sig.decl, item.hir_id(), Some(body_id));
+            check_fn(cx, sig.decl, Some(body_id));
         }
     }
 
@@ -165,7 +165,7 @@ impl<'tcx> LateLintPass<'tcx> for Ptr {
                     return; // ignore trait impls
                 }
             }
-            check_fn(cx, sig.decl, item.hir_id(), Some(body_id));
+            check_fn(cx, sig.decl, Some(body_id));
         }
     }
 
@@ -176,7 +176,7 @@ impl<'tcx> LateLintPass<'tcx> for Ptr {
             } else {
                 None
             };
-            check_fn(cx, sig.decl, item.hir_id(), body_id);
+            check_fn(cx, sig.decl, body_id);
         }
     }
 
@@ -244,13 +244,10 @@ fn check_invalid_ptr_usage<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
 }
 
 #[allow(clippy::too_many_lines)]
-fn check_fn(cx: &LateContext<'_>, decl: &FnDecl<'_>, fn_id: HirId, opt_body_id: Option<BodyId>) {
-    let fn_def_id = cx.tcx.hir().local_def_id(fn_id);
-    let sig = cx.tcx.fn_sig(fn_def_id);
-    let fn_ty = sig.skip_binder();
+fn check_fn(cx: &LateContext<'_>, decl: &FnDecl<'_>, opt_body_id: Option<BodyId>) {
     let body = opt_body_id.map(|id| cx.tcx.hir().body(id));
 
-    for (idx, (arg, ty)) in decl.inputs.iter().zip(fn_ty.inputs()).enumerate() {
+    for (idx, arg) in decl.inputs.iter().enumerate() {
         // Honor the allow attribute on parameters. See issue 5644.
         if let Some(body) = &body {
             if is_lint_allowed(cx, PTR_ARG, body.params[idx].hir_id) {
@@ -258,8 +255,20 @@ fn check_fn(cx: &LateContext<'_>, decl: &FnDecl<'_>, fn_id: HirId, opt_body_id:
             }
         }
 
-        if let ty::Ref(_, ty, Mutability::Not) = ty.kind() {
-            if is_type_diagnostic_item(cx, ty, sym::Vec) {
+        let (item_name, path) = if_chain! {
+            if let TyKind::Rptr(_, MutTy { ty, mutbl: Mutability::Not }) = arg.kind;
+            if let TyKind::Path(QPath::Resolved(_, path)) = ty.kind;
+            if let Res::Def(_, did) = path.res;
+            if let Some(item_name) = cx.tcx.get_diagnostic_name(did);
+            then {
+                (item_name, path)
+            } else {
+                continue
+            }
+        };
+
+        match item_name {
+            sym::Vec => {
                 if let Some(spans) = get_spans(cx, opt_body_id, idx, &[("clone", ".to_owned()")]) {
                     span_lint_and_then(
                         cx,
@@ -289,7 +298,8 @@ fn check_fn(cx: &LateContext<'_>, decl: &FnDecl<'_>, fn_id: HirId, opt_body_id:
                         },
                     );
                 }
-            } else if is_type_diagnostic_item(cx, ty, sym::String) {
+            },
+            sym::String => {
                 if let Some(spans) = get_spans(cx, opt_body_id, idx, &[("clone", ".to_string()"), ("as_str", "")]) {
                     span_lint_and_then(
                         cx,
@@ -311,7 +321,8 @@ fn check_fn(cx: &LateContext<'_>, decl: &FnDecl<'_>, fn_id: HirId, opt_body_id:
                         },
                     );
                 }
-            } else if is_type_diagnostic_item(cx, ty, sym::PathBuf) {
+            },
+            sym::PathBuf => {
                 if let Some(spans) = get_spans(cx, opt_body_id, idx, &[("clone", ".to_path_buf()"), ("as_path", "")]) {
                     span_lint_and_then(
                         cx,
@@ -338,11 +349,10 @@ fn check_fn(cx: &LateContext<'_>, decl: &FnDecl<'_>, fn_id: HirId, opt_body_id:
                         },
                     );
                 }
-            } else if match_type(cx, ty, &paths::COW) {
+            },
+            sym::Cow => {
                 if_chain! {
-                    if let TyKind::Rptr(_, MutTy { ty, ..} ) = arg.kind;
-                    if let TyKind::Path(QPath::Resolved(None, pp)) = ty.kind;
-                    if let [ref bx] = *pp.segments;
+                    if let [ref bx] = *path.segments;
                     if let Some(params) = bx.args;
                     if !params.parenthesized;
                     if let Some(inner) = params.args.iter().find_map(|arg| match arg {
@@ -363,7 +373,8 @@ fn check_fn(cx: &LateContext<'_>, decl: &FnDecl<'_>, fn_id: HirId, opt_body_id:
                         );
                     }
                 }
-            }
+            },
+            _ => {},
         }
     }
 
diff --git a/tests/ui/ptr_arg.rs b/tests/ui/ptr_arg.rs
index 99e6d2aad8d..b29b26583b7 100644
--- a/tests/ui/ptr_arg.rs
+++ b/tests/ui/ptr_arg.rs
@@ -160,3 +160,7 @@ mod issue6509 {
         let _ = str.clone().clone();
     }
 }
+
+// No error for types behind an alias (#7699)
+type A = Vec<u8>;
+fn aliased(a: &A) {}
-- 
cgit 1.4.1-3-g733a5


From 35bf041c21eeb5e4ce9d892c01741a179811c811 Mon Sep 17 00:00:00 2001
From: Takayuki Nakata <f.seasons017@gmail.com>
Date: Thu, 28 Oct 2021 22:10:59 +0900
Subject: Fix ICE in `undocumented_unsafe_blocks`

---
 clippy_lints/src/undocumented_unsafe_blocks.rs |  5 +++--
 tests/ui/crashes/ice-7868.rs                   |  1 +
 tests/ui/crashes/ice-7868.stderr               | 15 +++++++++++++++
 3 files changed, 19 insertions(+), 2 deletions(-)
 create mode 100644 tests/ui/crashes/ice-7868.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/undocumented_unsafe_blocks.rs b/clippy_lints/src/undocumented_unsafe_blocks.rs
index e08e4d03c7e..11aef50991b 100644
--- a/clippy_lints/src/undocumented_unsafe_blocks.rs
+++ b/clippy_lints/src/undocumented_unsafe_blocks.rs
@@ -145,8 +145,9 @@ impl UndocumentedUnsafeBlocks {
         let file_name = source_map.span_to_filename(between_span);
         let source_file = source_map.get_source_file(&file_name)?;
 
-        let lex_start = (between_span.lo().0 + 1) as usize;
-        let src_str = source_file.src.as_ref()?[lex_start..between_span.hi().0 as usize].to_string();
+        let lex_start = (between_span.lo().0 - source_file.start_pos.0 + 1) as usize;
+        let lex_end = (between_span.hi().0 - source_file.start_pos.0) as usize;
+        let src_str = source_file.src.as_ref()?[lex_start..lex_end].to_string();
 
         let mut pos = 0;
         let mut comment = false;
diff --git a/tests/ui/crashes/ice-7868.rs b/tests/ui/crashes/ice-7868.rs
index cfe4e552948..c6932164e3b 100644
--- a/tests/ui/crashes/ice-7868.rs
+++ b/tests/ui/crashes/ice-7868.rs
@@ -1,4 +1,5 @@
 #![warn(clippy::undocumented_unsafe_blocks)]
+#![allow(clippy::no_effect)]
 
 #[path = "auxiliary/ice-7868-aux.rs"]
 mod zero;
diff --git a/tests/ui/crashes/ice-7868.stderr b/tests/ui/crashes/ice-7868.stderr
new file mode 100644
index 00000000000..d7b49eb89a2
--- /dev/null
+++ b/tests/ui/crashes/ice-7868.stderr
@@ -0,0 +1,15 @@
+error: unsafe block missing a safety comment
+  --> $DIR/auxiliary/ice-7868-aux.rs:2:5
+   |
+LL |     unsafe { 0 };
+   |     ^^^^^^^^^^^^
+   |
+   = note: `-D clippy::undocumented-unsafe-blocks` implied by `-D warnings`
+help: consider adding a safety comment
+   |
+LL ~     // Safety: ...
+LL ~     unsafe { 0 };
+   |
+
+error: aborting due to previous error
+
-- 
cgit 1.4.1-3-g733a5


From d8fcfd7d64f102402819aba3ac91954a7a6888cc Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Tue, 12 Oct 2021 09:09:54 -0500
Subject: Move if_then_panic to pedantic

---
 clippy_lints/src/if_then_panic.rs         |  2 +-
 clippy_lints/src/lib.register_all.rs      |  1 -
 clippy_lints/src/lib.register_pedantic.rs |  1 +
 clippy_lints/src/lib.register_style.rs    |  1 -
 tests/ui/fallible_impl_from.rs            |  1 -
 tests/ui/fallible_impl_from.stderr        | 16 ++++++++--------
 tests/ui/ptr_arg.rs                       |  7 +------
 tests/ui/ptr_arg.stderr                   | 24 ++++++++++++------------
 8 files changed, 23 insertions(+), 30 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/if_then_panic.rs b/clippy_lints/src/if_then_panic.rs
index e8cea5529e8..7946c93c6ec 100644
--- a/clippy_lints/src/if_then_panic.rs
+++ b/clippy_lints/src/if_then_panic.rs
@@ -27,7 +27,7 @@ declare_clippy_lint! {
     /// assert!(sad_people.is_empty(), "there are sad people: {:?}", sad_people);
     /// ```
     pub IF_THEN_PANIC,
-    style,
+    pedantic,
     "`panic!` and only a `panic!` in `if`-then statement"
 }
 
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 4e123f27ec0..15edb79d36c 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -76,7 +76,6 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(get_last_with_len::GET_LAST_WITH_LEN),
     LintId::of(identity_op::IDENTITY_OP),
     LintId::of(if_let_mutex::IF_LET_MUTEX),
-    LintId::of(if_then_panic::IF_THEN_PANIC),
     LintId::of(indexing_slicing::OUT_OF_BOUNDS_INDEXING),
     LintId::of(infinite_iter::INFINITE_ITER),
     LintId::of(inherent_to_string::INHERENT_TO_STRING),
diff --git a/clippy_lints/src/lib.register_pedantic.rs b/clippy_lints/src/lib.register_pedantic.rs
index 268349d2848..d22b3b31f6d 100644
--- a/clippy_lints/src/lib.register_pedantic.rs
+++ b/clippy_lints/src/lib.register_pedantic.rs
@@ -34,6 +34,7 @@ store.register_group(true, "clippy::pedantic", Some("clippy_pedantic"), vec![
     LintId::of(functions::MUST_USE_CANDIDATE),
     LintId::of(functions::TOO_MANY_LINES),
     LintId::of(if_not_else::IF_NOT_ELSE),
+    LintId::of(if_then_panic::IF_THEN_PANIC),
     LintId::of(implicit_hasher::IMPLICIT_HASHER),
     LintId::of(implicit_saturating_sub::IMPLICIT_SATURATING_SUB),
     LintId::of(inconsistent_struct_constructor::INCONSISTENT_STRUCT_CONSTRUCTOR),
diff --git a/clippy_lints/src/lib.register_style.rs b/clippy_lints/src/lib.register_style.rs
index a39c111c574..744880bda3e 100644
--- a/clippy_lints/src/lib.register_style.rs
+++ b/clippy_lints/src/lib.register_style.rs
@@ -27,7 +27,6 @@ store.register_group(true, "clippy::style", Some("clippy_style"), vec![
     LintId::of(functions::DOUBLE_MUST_USE),
     LintId::of(functions::MUST_USE_UNIT),
     LintId::of(functions::RESULT_UNIT_ERR),
-    LintId::of(if_then_panic::IF_THEN_PANIC),
     LintId::of(inherent_to_string::INHERENT_TO_STRING),
     LintId::of(len_zero::COMPARISON_TO_EMPTY),
     LintId::of(len_zero::LEN_WITHOUT_IS_EMPTY),
diff --git a/tests/ui/fallible_impl_from.rs b/tests/ui/fallible_impl_from.rs
index 495cd97e05e..5d5af4e4632 100644
--- a/tests/ui/fallible_impl_from.rs
+++ b/tests/ui/fallible_impl_from.rs
@@ -1,5 +1,4 @@
 #![deny(clippy::fallible_impl_from)]
-#![allow(clippy::if_then_panic)]
 
 // docs example
 struct Foo(i32);
diff --git a/tests/ui/fallible_impl_from.stderr b/tests/ui/fallible_impl_from.stderr
index f5d0b98c108..5772ff05508 100644
--- a/tests/ui/fallible_impl_from.stderr
+++ b/tests/ui/fallible_impl_from.stderr
@@ -1,5 +1,5 @@
 error: consider implementing `TryFrom` instead
-  --> $DIR/fallible_impl_from.rs:6:1
+  --> $DIR/fallible_impl_from.rs:5:1
    |
 LL | / impl From<String> for Foo {
 LL | |     fn from(s: String) -> Self {
@@ -15,13 +15,13 @@ LL | #![deny(clippy::fallible_impl_from)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
    = help: `From` is intended for infallible conversions only. Use `TryFrom` if there's a possibility for the conversion to fail
 note: potential failure(s)
-  --> $DIR/fallible_impl_from.rs:8:13
+  --> $DIR/fallible_impl_from.rs:7:13
    |
 LL |         Foo(s.parse().unwrap())
    |             ^^^^^^^^^^^^^^^^^^
 
 error: consider implementing `TryFrom` instead
-  --> $DIR/fallible_impl_from.rs:27:1
+  --> $DIR/fallible_impl_from.rs:26:1
    |
 LL | / impl From<usize> for Invalid {
 LL | |     fn from(i: usize) -> Invalid {
@@ -34,14 +34,14 @@ LL | | }
    |
    = help: `From` is intended for infallible conversions only. Use `TryFrom` if there's a possibility for the conversion to fail
 note: potential failure(s)
-  --> $DIR/fallible_impl_from.rs:30:13
+  --> $DIR/fallible_impl_from.rs:29:13
    |
 LL |             panic!();
    |             ^^^^^^^^
    = note: this error originates in the macro `$crate::panic::panic_2015` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: consider implementing `TryFrom` instead
-  --> $DIR/fallible_impl_from.rs:36:1
+  --> $DIR/fallible_impl_from.rs:35:1
    |
 LL | / impl From<Option<String>> for Invalid {
 LL | |     fn from(s: Option<String>) -> Invalid {
@@ -54,7 +54,7 @@ LL | | }
    |
    = help: `From` is intended for infallible conversions only. Use `TryFrom` if there's a possibility for the conversion to fail
 note: potential failure(s)
-  --> $DIR/fallible_impl_from.rs:38:17
+  --> $DIR/fallible_impl_from.rs:37:17
    |
 LL |         let s = s.unwrap();
    |                 ^^^^^^^^^^
@@ -68,7 +68,7 @@ LL |             panic!("{:?}", s);
    = note: this error originates in the macro `$crate::panic::panic_2015` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: consider implementing `TryFrom` instead
-  --> $DIR/fallible_impl_from.rs:54:1
+  --> $DIR/fallible_impl_from.rs:53:1
    |
 LL | / impl<'a> From<&'a mut <Box<u32> as ProjStrTrait>::ProjString> for Invalid {
 LL | |     fn from(s: &'a mut <Box<u32> as ProjStrTrait>::ProjString) -> Invalid {
@@ -81,7 +81,7 @@ LL | | }
    |
    = help: `From` is intended for infallible conversions only. Use `TryFrom` if there's a possibility for the conversion to fail
 note: potential failure(s)
-  --> $DIR/fallible_impl_from.rs:56:12
+  --> $DIR/fallible_impl_from.rs:55:12
    |
 LL |         if s.parse::<u32>().ok().unwrap() != 42 {
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/ptr_arg.rs b/tests/ui/ptr_arg.rs
index 99e6d2aad8d..06370dfce65 100644
--- a/tests/ui/ptr_arg.rs
+++ b/tests/ui/ptr_arg.rs
@@ -1,9 +1,4 @@
-#![allow(
-    unused,
-    clippy::many_single_char_names,
-    clippy::redundant_clone,
-    clippy::if_then_panic
-)]
+#![allow(unused, clippy::many_single_char_names, clippy::redundant_clone)]
 #![warn(clippy::ptr_arg)]
 
 use std::borrow::Cow;
diff --git a/tests/ui/ptr_arg.stderr b/tests/ui/ptr_arg.stderr
index 42183447ead..64594eb870c 100644
--- a/tests/ui/ptr_arg.stderr
+++ b/tests/ui/ptr_arg.stderr
@@ -1,5 +1,5 @@
 error: writing `&Vec<_>` instead of `&[_]` involves one more reference and cannot be used with non-Vec-based slices
-  --> $DIR/ptr_arg.rs:12:14
+  --> $DIR/ptr_arg.rs:7:14
    |
 LL | fn do_vec(x: &Vec<i64>) {
    |              ^^^^^^^^^ help: change this to: `&[i64]`
@@ -7,25 +7,25 @@ LL | fn do_vec(x: &Vec<i64>) {
    = note: `-D clippy::ptr-arg` implied by `-D warnings`
 
 error: writing `&String` instead of `&str` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:21:14
+  --> $DIR/ptr_arg.rs:16:14
    |
 LL | fn do_str(x: &String) {
    |              ^^^^^^^ help: change this to: `&str`
 
 error: writing `&PathBuf` instead of `&Path` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:30:15
+  --> $DIR/ptr_arg.rs:25:15
    |
 LL | fn do_path(x: &PathBuf) {
    |               ^^^^^^^^ help: change this to: `&Path`
 
 error: writing `&Vec<_>` instead of `&[_]` involves one more reference and cannot be used with non-Vec-based slices
-  --> $DIR/ptr_arg.rs:43:18
+  --> $DIR/ptr_arg.rs:38:18
    |
 LL |     fn do_vec(x: &Vec<i64>);
    |                  ^^^^^^^^^ help: change this to: `&[i64]`
 
 error: writing `&Vec<_>` instead of `&[_]` involves one more reference and cannot be used with non-Vec-based slices
-  --> $DIR/ptr_arg.rs:56:14
+  --> $DIR/ptr_arg.rs:51:14
    |
 LL | fn cloned(x: &Vec<u8>) -> Vec<u8> {
    |              ^^^^^^^^
@@ -44,7 +44,7 @@ LL |     x.to_owned()
    |
 
 error: writing `&String` instead of `&str` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:65:18
+  --> $DIR/ptr_arg.rs:60:18
    |
 LL | fn str_cloned(x: &String) -> String {
    |                  ^^^^^^^
@@ -67,7 +67,7 @@ LL |     x.to_string()
    |
 
 error: writing `&PathBuf` instead of `&Path` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:73:19
+  --> $DIR/ptr_arg.rs:68:19
    |
 LL | fn path_cloned(x: &PathBuf) -> PathBuf {
    |                   ^^^^^^^^
@@ -90,7 +90,7 @@ LL |     x.to_path_buf()
    |
 
 error: writing `&String` instead of `&str` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:81:44
+  --> $DIR/ptr_arg.rs:76:44
    |
 LL | fn false_positive_capacity(x: &Vec<u8>, y: &String) {
    |                                            ^^^^^^^
@@ -109,13 +109,13 @@ LL |     let c = y;
    |             ~
 
 error: using a reference to `Cow` is not recommended
-  --> $DIR/ptr_arg.rs:95:25
+  --> $DIR/ptr_arg.rs:90:25
    |
 LL | fn test_cow_with_ref(c: &Cow<[i32]>) {}
    |                         ^^^^^^^^^^^ help: change this to: `&[i32]`
 
 error: writing `&Vec<_>` instead of `&[_]` involves one more reference and cannot be used with non-Vec-based slices
-  --> $DIR/ptr_arg.rs:148:21
+  --> $DIR/ptr_arg.rs:143:21
    |
 LL |     fn foo_vec(vec: &Vec<u8>) {
    |                     ^^^^^^^^
@@ -134,7 +134,7 @@ LL |         let _ = vec.to_owned().clone();
    |                 ~~~~~~~~~~~~~~
 
 error: writing `&PathBuf` instead of `&Path` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:153:23
+  --> $DIR/ptr_arg.rs:148:23
    |
 LL |     fn foo_path(path: &PathBuf) {
    |                       ^^^^^^^^
@@ -153,7 +153,7 @@ LL |         let _ = path.to_path_buf().clone();
    |                 ~~~~~~~~~~~~~~~~~~
 
 error: writing `&PathBuf` instead of `&Path` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:158:21
+  --> $DIR/ptr_arg.rs:153:21
    |
 LL |     fn foo_str(str: &PathBuf) {
    |                     ^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From 022146d2c3c4e1baa65f19c45205152af1a8b997 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Tue, 12 Oct 2021 09:23:05 -0500
Subject: Rename if_then_panic to manual_assert

---
 CHANGELOG.md                              |  6 +-
 clippy_lints/src/if_then_panic.rs         | 99 -------------------------------
 clippy_lints/src/lib.register_lints.rs    |  2 +-
 clippy_lints/src/lib.register_pedantic.rs |  2 +-
 clippy_lints/src/lib.rs                   |  4 +-
 clippy_lints/src/manual_assert.rs         | 99 +++++++++++++++++++++++++++++++
 tests/ui/if_then_panic.fixed              | 40 -------------
 tests/ui/if_then_panic.rs                 | 54 -----------------
 tests/ui/if_then_panic.stderr             | 60 -------------------
 tests/ui/manual_assert.fixed              | 40 +++++++++++++
 tests/ui/manual_assert.rs                 | 54 +++++++++++++++++
 tests/ui/manual_assert.stderr             | 60 +++++++++++++++++++
 12 files changed, 260 insertions(+), 260 deletions(-)
 delete mode 100644 clippy_lints/src/if_then_panic.rs
 create mode 100644 clippy_lints/src/manual_assert.rs
 delete mode 100644 tests/ui/if_then_panic.fixed
 delete mode 100644 tests/ui/if_then_panic.rs
 delete mode 100644 tests/ui/if_then_panic.stderr
 create mode 100644 tests/ui/manual_assert.fixed
 create mode 100644 tests/ui/manual_assert.rs
 create mode 100644 tests/ui/manual_assert.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 267bc07d8fa..c78aa5908de 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -34,7 +34,7 @@ Current beta, release 2021-12-02
   [#7610](https://github.com/rust-lang/rust-clippy/pull/7610)
 * [`same_name_method`]
   [#7653](https://github.com/rust-lang/rust-clippy/pull/7653)
-* [`if_then_panic`] [#7669](https://github.com/rust-lang/rust-clippy/pull/7669)
+* [`manual_assert`] [#7669](https://github.com/rust-lang/rust-clippy/pull/7669)
 * [`non_send_fields_in_send_ty`]
   [#7709](https://github.com/rust-lang/rust-clippy/pull/7709)
 * [`equatable_if_let`]
@@ -139,7 +139,7 @@ Current beta, release 2021-12-02
   `rsplitn` is used [#7663](https://github.com/rust-lang/rust-clippy/pull/7663)
 * [`while_let_on_iterator`]: Produce correct suggestion when using `&mut`
   [#7690](https://github.com/rust-lang/rust-clippy/pull/7690)
-* [`if_then_panic`]: No better handles complex conditions
+* [`manual_assert`]: No better handles complex conditions
   [#7741](https://github.com/rust-lang/rust-clippy/pull/7741)
 * Correctly handle signs in exponents in numeric literals lints
   [#7747](https://github.com/rust-lang/rust-clippy/pull/7747)
@@ -2895,7 +2895,6 @@ Released 2018-09-13
 [`if_let_redundant_pattern_matching`]: https://rust-lang.github.io/rust-clippy/master/index.html#if_let_redundant_pattern_matching
 [`if_not_else`]: https://rust-lang.github.io/rust-clippy/master/index.html#if_not_else
 [`if_same_then_else`]: https://rust-lang.github.io/rust-clippy/master/index.html#if_same_then_else
-[`if_then_panic`]: https://rust-lang.github.io/rust-clippy/master/index.html#if_then_panic
 [`if_then_some_else_none`]: https://rust-lang.github.io/rust-clippy/master/index.html#if_then_some_else_none
 [`ifs_same_cond`]: https://rust-lang.github.io/rust-clippy/master/index.html#ifs_same_cond
 [`implicit_clone`]: https://rust-lang.github.io/rust-clippy/master/index.html#implicit_clone
@@ -2953,6 +2952,7 @@ Released 2018-09-13
 [`lossy_float_literal`]: https://rust-lang.github.io/rust-clippy/master/index.html#lossy_float_literal
 [`macro_use_imports`]: https://rust-lang.github.io/rust-clippy/master/index.html#macro_use_imports
 [`main_recursion`]: https://rust-lang.github.io/rust-clippy/master/index.html#main_recursion
+[`manual_assert`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_assert
 [`manual_async_fn`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_async_fn
 [`manual_filter_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_filter_map
 [`manual_find_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_find_map
diff --git a/clippy_lints/src/if_then_panic.rs b/clippy_lints/src/if_then_panic.rs
deleted file mode 100644
index 7946c93c6ec..00000000000
--- a/clippy_lints/src/if_then_panic.rs
+++ /dev/null
@@ -1,99 +0,0 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::higher::PanicExpn;
-use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::{is_expn_of, sugg};
-use rustc_errors::Applicability;
-use rustc_hir::{Block, Expr, ExprKind, StmtKind, UnOp};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Detects `if`-then-`panic!` that can be replaced with `assert!`.
-    ///
-    /// ### Why is this bad?
-    /// `assert!` is simpler than `if`-then-`panic!`.
-    ///
-    /// ### Example
-    /// ```rust
-    /// let sad_people: Vec<&str> = vec![];
-    /// if !sad_people.is_empty() {
-    ///     panic!("there are sad people: {:?}", sad_people);
-    /// }
-    /// ```
-    /// Use instead:
-    /// ```rust
-    /// let sad_people: Vec<&str> = vec![];
-    /// assert!(sad_people.is_empty(), "there are sad people: {:?}", sad_people);
-    /// ```
-    pub IF_THEN_PANIC,
-    pedantic,
-    "`panic!` and only a `panic!` in `if`-then statement"
-}
-
-declare_lint_pass!(IfThenPanic => [IF_THEN_PANIC]);
-
-impl LateLintPass<'_> for IfThenPanic {
-    fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
-        if_chain! {
-            if let Expr {
-                kind: ExprKind:: If(cond, Expr {
-                    kind: ExprKind::Block(
-                        Block {
-                            stmts: [stmt],
-                            ..
-                        },
-                        _),
-                    ..
-                }, None),
-                ..
-            } = &expr;
-            if is_expn_of(stmt.span, "panic").is_some();
-            if !matches!(cond.kind, ExprKind::Let(_, _, _));
-            if let StmtKind::Semi(semi) = stmt.kind;
-            if !cx.tcx.sess.source_map().is_multiline(cond.span);
-
-            then {
-                let span = if let Some(panic_expn) = PanicExpn::parse(semi) {
-                    match *panic_expn.format_args.value_args {
-                        [] => panic_expn.format_args.format_string_span,
-                        [.., last] => panic_expn.format_args.format_string_span.to(last.span),
-                    }
-                } else {
-                    if_chain! {
-                        if let ExprKind::Block(block, _) = semi.kind;
-                        if let Some(init) = block.expr;
-                        if let ExprKind::Call(_, [format_args]) = init.kind;
-
-                        then {
-                            format_args.span
-                        } else {
-                            return
-                        }
-                    }
-                };
-                let mut applicability = Applicability::MachineApplicable;
-                let sugg = snippet_with_applicability(cx, span, "..", &mut applicability);
-                let cond_sugg = if let ExprKind::DropTemps(e, ..) = cond.kind {
-                    if let Expr{kind: ExprKind::Unary(UnOp::Not, not_expr), ..} = e {
-                         sugg::Sugg::hir_with_applicability(cx, not_expr, "..", &mut applicability).maybe_par().to_string()
-                    } else {
-                       format!("!{}", sugg::Sugg::hir_with_applicability(cx, e, "..", &mut applicability).maybe_par())
-                    }
-                } else {
-                   format!("!{}", sugg::Sugg::hir_with_applicability(cx, cond, "..", &mut applicability).maybe_par())
-                };
-
-                span_lint_and_sugg(
-                    cx,
-                    IF_THEN_PANIC,
-                    expr.span,
-                    "only a `panic!` in `if`-then statement",
-                    "try",
-                    format!("assert!({}, {});", cond_sugg, sugg),
-                    Applicability::MachineApplicable,
-                );
-            }
-        }
-    }
-}
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 249bf77a8f2..9b210791574 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -159,7 +159,6 @@ store.register_lints(&[
     identity_op::IDENTITY_OP,
     if_let_mutex::IF_LET_MUTEX,
     if_not_else::IF_NOT_ELSE,
-    if_then_panic::IF_THEN_PANIC,
     if_then_some_else_none::IF_THEN_SOME_ELSE_NONE,
     implicit_hasher::IMPLICIT_HASHER,
     implicit_return::IMPLICIT_RETURN,
@@ -216,6 +215,7 @@ store.register_lints(&[
     loops::WHILE_LET_ON_ITERATOR,
     macro_use::MACRO_USE_IMPORTS,
     main_recursion::MAIN_RECURSION,
+    manual_assert::MANUAL_ASSERT,
     manual_async_fn::MANUAL_ASYNC_FN,
     manual_map::MANUAL_MAP,
     manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE,
diff --git a/clippy_lints/src/lib.register_pedantic.rs b/clippy_lints/src/lib.register_pedantic.rs
index d22b3b31f6d..63ab7f1ca6f 100644
--- a/clippy_lints/src/lib.register_pedantic.rs
+++ b/clippy_lints/src/lib.register_pedantic.rs
@@ -34,7 +34,6 @@ store.register_group(true, "clippy::pedantic", Some("clippy_pedantic"), vec![
     LintId::of(functions::MUST_USE_CANDIDATE),
     LintId::of(functions::TOO_MANY_LINES),
     LintId::of(if_not_else::IF_NOT_ELSE),
-    LintId::of(if_then_panic::IF_THEN_PANIC),
     LintId::of(implicit_hasher::IMPLICIT_HASHER),
     LintId::of(implicit_saturating_sub::IMPLICIT_SATURATING_SUB),
     LintId::of(inconsistent_struct_constructor::INCONSISTENT_STRUCT_CONSTRUCTOR),
@@ -49,6 +48,7 @@ store.register_group(true, "clippy::pedantic", Some("clippy_pedantic"), vec![
     LintId::of(loops::EXPLICIT_INTO_ITER_LOOP),
     LintId::of(loops::EXPLICIT_ITER_LOOP),
     LintId::of(macro_use::MACRO_USE_IMPORTS),
+    LintId::of(manual_assert::MANUAL_ASSERT),
     LintId::of(manual_ok_or::MANUAL_OK_OR),
     LintId::of(match_on_vec_items::MATCH_ON_VEC_ITEMS),
     LintId::of(matches::MATCH_BOOL),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index fc15c591623..fd5f164e7a1 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -228,7 +228,6 @@ mod get_last_with_len;
 mod identity_op;
 mod if_let_mutex;
 mod if_not_else;
-mod if_then_panic;
 mod if_then_some_else_none;
 mod implicit_hasher;
 mod implicit_return;
@@ -255,6 +254,7 @@ mod literal_representation;
 mod loops;
 mod macro_use;
 mod main_recursion;
+mod manual_assert;
 mod manual_async_fn;
 mod manual_map;
 mod manual_non_exhaustive;
@@ -772,7 +772,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(move || Box::new(self_named_constructors::SelfNamedConstructors));
     store.register_late_pass(move || Box::new(feature_name::FeatureName));
     store.register_late_pass(move || Box::new(iter_not_returning_iterator::IterNotReturningIterator));
-    store.register_late_pass(move || Box::new(if_then_panic::IfThenPanic));
+    store.register_late_pass(move || Box::new(manual_assert::ManualAssert));
     let enable_raw_pointer_heuristic_for_send = conf.enable_raw_pointer_heuristic_for_send;
     store.register_late_pass(move || Box::new(non_send_fields_in_send_ty::NonSendFieldInSendTy::new(enable_raw_pointer_heuristic_for_send)));
     store.register_late_pass(move || Box::new(undocumented_unsafe_blocks::UndocumentedUnsafeBlocks::default()));
diff --git a/clippy_lints/src/manual_assert.rs b/clippy_lints/src/manual_assert.rs
new file mode 100644
index 00000000000..c639be1bccb
--- /dev/null
+++ b/clippy_lints/src/manual_assert.rs
@@ -0,0 +1,99 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::higher::PanicExpn;
+use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::{is_expn_of, sugg};
+use rustc_errors::Applicability;
+use rustc_hir::{Block, Expr, ExprKind, StmtKind, UnOp};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Detects `if`-then-`panic!` that can be replaced with `assert!`.
+    ///
+    /// ### Why is this bad?
+    /// `assert!` is simpler than `if`-then-`panic!`.
+    ///
+    /// ### Example
+    /// ```rust
+    /// let sad_people: Vec<&str> = vec![];
+    /// if !sad_people.is_empty() {
+    ///     panic!("there are sad people: {:?}", sad_people);
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// let sad_people: Vec<&str> = vec![];
+    /// assert!(sad_people.is_empty(), "there are sad people: {:?}", sad_people);
+    /// ```
+    pub MANUAL_ASSERT,
+    pedantic,
+    "`panic!` and only a `panic!` in `if`-then statement"
+}
+
+declare_lint_pass!(ManualAssert => [MANUAL_ASSERT]);
+
+impl LateLintPass<'_> for ManualAssert {
+    fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
+        if_chain! {
+            if let Expr {
+                kind: ExprKind:: If(cond, Expr {
+                    kind: ExprKind::Block(
+                        Block {
+                            stmts: [stmt],
+                            ..
+                        },
+                        _),
+                    ..
+                }, None),
+                ..
+            } = &expr;
+            if is_expn_of(stmt.span, "panic").is_some();
+            if !matches!(cond.kind, ExprKind::Let(_, _, _));
+            if let StmtKind::Semi(semi) = stmt.kind;
+            if !cx.tcx.sess.source_map().is_multiline(cond.span);
+
+            then {
+                let span = if let Some(panic_expn) = PanicExpn::parse(semi) {
+                    match *panic_expn.format_args.value_args {
+                        [] => panic_expn.format_args.format_string_span,
+                        [.., last] => panic_expn.format_args.format_string_span.to(last.span),
+                    }
+                } else {
+                    if_chain! {
+                        if let ExprKind::Block(block, _) = semi.kind;
+                        if let Some(init) = block.expr;
+                        if let ExprKind::Call(_, [format_args]) = init.kind;
+
+                        then {
+                            format_args.span
+                        } else {
+                            return
+                        }
+                    }
+                };
+                let mut applicability = Applicability::MachineApplicable;
+                let sugg = snippet_with_applicability(cx, span, "..", &mut applicability);
+                let cond_sugg = if let ExprKind::DropTemps(e, ..) = cond.kind {
+                    if let Expr{kind: ExprKind::Unary(UnOp::Not, not_expr), ..} = e {
+                         sugg::Sugg::hir_with_applicability(cx, not_expr, "..", &mut applicability).maybe_par().to_string()
+                    } else {
+                       format!("!{}", sugg::Sugg::hir_with_applicability(cx, e, "..", &mut applicability).maybe_par())
+                    }
+                } else {
+                   format!("!{}", sugg::Sugg::hir_with_applicability(cx, cond, "..", &mut applicability).maybe_par())
+                };
+
+                span_lint_and_sugg(
+                    cx,
+                    MANUAL_ASSERT,
+                    expr.span,
+                    "only a `panic!` in `if`-then statement",
+                    "try",
+                    format!("assert!({}, {});", cond_sugg, sugg),
+                    Applicability::MachineApplicable,
+                );
+            }
+        }
+    }
+}
diff --git a/tests/ui/if_then_panic.fixed b/tests/ui/if_then_panic.fixed
deleted file mode 100644
index 0998f8ffa9d..00000000000
--- a/tests/ui/if_then_panic.fixed
+++ /dev/null
@@ -1,40 +0,0 @@
-// run-rustfix
-#![warn(clippy::if_then_panic)]
-
-fn main() {
-    let a = vec![1, 2, 3];
-    let c = Some(2);
-    if !a.is_empty()
-        && a.len() == 3
-        && c != None
-        && !a.is_empty()
-        && a.len() == 3
-        && !a.is_empty()
-        && a.len() == 3
-        && !a.is_empty()
-        && a.len() == 3
-    {
-        panic!("qaqaq{:?}", a);
-    }
-    assert!(a.is_empty(), "qaqaq{:?}", a);
-    assert!(a.is_empty(), "qwqwq");
-    if a.len() == 3 {
-        println!("qwq");
-        println!("qwq");
-        println!("qwq");
-    }
-    if let Some(b) = c {
-        panic!("orz {}", b);
-    }
-    if a.len() == 3 {
-        panic!("qaqaq");
-    } else {
-        println!("qwq");
-    }
-    let b = vec![1, 2, 3];
-    assert!(!b.is_empty(), "panic1");
-    assert!(!(b.is_empty() && a.is_empty()), "panic2");
-    assert!(!(a.is_empty() && !b.is_empty()), "panic3");
-    assert!(!(b.is_empty() || a.is_empty()), "panic4");
-    assert!(!(a.is_empty() || !b.is_empty()), "panic5");
-}
diff --git a/tests/ui/if_then_panic.rs b/tests/ui/if_then_panic.rs
deleted file mode 100644
index 10433c8d54f..00000000000
--- a/tests/ui/if_then_panic.rs
+++ /dev/null
@@ -1,54 +0,0 @@
-// run-rustfix
-#![warn(clippy::if_then_panic)]
-
-fn main() {
-    let a = vec![1, 2, 3];
-    let c = Some(2);
-    if !a.is_empty()
-        && a.len() == 3
-        && c != None
-        && !a.is_empty()
-        && a.len() == 3
-        && !a.is_empty()
-        && a.len() == 3
-        && !a.is_empty()
-        && a.len() == 3
-    {
-        panic!("qaqaq{:?}", a);
-    }
-    if !a.is_empty() {
-        panic!("qaqaq{:?}", a);
-    }
-    if !a.is_empty() {
-        panic!("qwqwq");
-    }
-    if a.len() == 3 {
-        println!("qwq");
-        println!("qwq");
-        println!("qwq");
-    }
-    if let Some(b) = c {
-        panic!("orz {}", b);
-    }
-    if a.len() == 3 {
-        panic!("qaqaq");
-    } else {
-        println!("qwq");
-    }
-    let b = vec![1, 2, 3];
-    if b.is_empty() {
-        panic!("panic1");
-    }
-    if b.is_empty() && a.is_empty() {
-        panic!("panic2");
-    }
-    if a.is_empty() && !b.is_empty() {
-        panic!("panic3");
-    }
-    if b.is_empty() || a.is_empty() {
-        panic!("panic4");
-    }
-    if a.is_empty() || !b.is_empty() {
-        panic!("panic5");
-    }
-}
diff --git a/tests/ui/if_then_panic.stderr b/tests/ui/if_then_panic.stderr
deleted file mode 100644
index 5bb62f87566..00000000000
--- a/tests/ui/if_then_panic.stderr
+++ /dev/null
@@ -1,60 +0,0 @@
-error: only a `panic!` in `if`-then statement
-  --> $DIR/if_then_panic.rs:19:5
-   |
-LL | /     if !a.is_empty() {
-LL | |         panic!("qaqaq{:?}", a);
-LL | |     }
-   | |_____^ help: try: `assert!(a.is_empty(), "qaqaq{:?}", a);`
-   |
-   = note: `-D clippy::if-then-panic` implied by `-D warnings`
-
-error: only a `panic!` in `if`-then statement
-  --> $DIR/if_then_panic.rs:22:5
-   |
-LL | /     if !a.is_empty() {
-LL | |         panic!("qwqwq");
-LL | |     }
-   | |_____^ help: try: `assert!(a.is_empty(), "qwqwq");`
-
-error: only a `panic!` in `if`-then statement
-  --> $DIR/if_then_panic.rs:39:5
-   |
-LL | /     if b.is_empty() {
-LL | |         panic!("panic1");
-LL | |     }
-   | |_____^ help: try: `assert!(!b.is_empty(), "panic1");`
-
-error: only a `panic!` in `if`-then statement
-  --> $DIR/if_then_panic.rs:42:5
-   |
-LL | /     if b.is_empty() && a.is_empty() {
-LL | |         panic!("panic2");
-LL | |     }
-   | |_____^ help: try: `assert!(!(b.is_empty() && a.is_empty()), "panic2");`
-
-error: only a `panic!` in `if`-then statement
-  --> $DIR/if_then_panic.rs:45:5
-   |
-LL | /     if a.is_empty() && !b.is_empty() {
-LL | |         panic!("panic3");
-LL | |     }
-   | |_____^ help: try: `assert!(!(a.is_empty() && !b.is_empty()), "panic3");`
-
-error: only a `panic!` in `if`-then statement
-  --> $DIR/if_then_panic.rs:48:5
-   |
-LL | /     if b.is_empty() || a.is_empty() {
-LL | |         panic!("panic4");
-LL | |     }
-   | |_____^ help: try: `assert!(!(b.is_empty() || a.is_empty()), "panic4");`
-
-error: only a `panic!` in `if`-then statement
-  --> $DIR/if_then_panic.rs:51:5
-   |
-LL | /     if a.is_empty() || !b.is_empty() {
-LL | |         panic!("panic5");
-LL | |     }
-   | |_____^ help: try: `assert!(!(a.is_empty() || !b.is_empty()), "panic5");`
-
-error: aborting due to 7 previous errors
-
diff --git a/tests/ui/manual_assert.fixed b/tests/ui/manual_assert.fixed
new file mode 100644
index 00000000000..9d461cff68d
--- /dev/null
+++ b/tests/ui/manual_assert.fixed
@@ -0,0 +1,40 @@
+// run-rustfix
+#![warn(clippy::manual_assert)]
+
+fn main() {
+    let a = vec![1, 2, 3];
+    let c = Some(2);
+    if !a.is_empty()
+        && a.len() == 3
+        && c != None
+        && !a.is_empty()
+        && a.len() == 3
+        && !a.is_empty()
+        && a.len() == 3
+        && !a.is_empty()
+        && a.len() == 3
+    {
+        panic!("qaqaq{:?}", a);
+    }
+    assert!(a.is_empty(), "qaqaq{:?}", a);
+    assert!(a.is_empty(), "qwqwq");
+    if a.len() == 3 {
+        println!("qwq");
+        println!("qwq");
+        println!("qwq");
+    }
+    if let Some(b) = c {
+        panic!("orz {}", b);
+    }
+    if a.len() == 3 {
+        panic!("qaqaq");
+    } else {
+        println!("qwq");
+    }
+    let b = vec![1, 2, 3];
+    assert!(!b.is_empty(), "panic1");
+    assert!(!(b.is_empty() && a.is_empty()), "panic2");
+    assert!(!(a.is_empty() && !b.is_empty()), "panic3");
+    assert!(!(b.is_empty() || a.is_empty()), "panic4");
+    assert!(!(a.is_empty() || !b.is_empty()), "panic5");
+}
diff --git a/tests/ui/manual_assert.rs b/tests/ui/manual_assert.rs
new file mode 100644
index 00000000000..6aadff887ca
--- /dev/null
+++ b/tests/ui/manual_assert.rs
@@ -0,0 +1,54 @@
+// run-rustfix
+#![warn(clippy::manual_assert)]
+
+fn main() {
+    let a = vec![1, 2, 3];
+    let c = Some(2);
+    if !a.is_empty()
+        && a.len() == 3
+        && c != None
+        && !a.is_empty()
+        && a.len() == 3
+        && !a.is_empty()
+        && a.len() == 3
+        && !a.is_empty()
+        && a.len() == 3
+    {
+        panic!("qaqaq{:?}", a);
+    }
+    if !a.is_empty() {
+        panic!("qaqaq{:?}", a);
+    }
+    if !a.is_empty() {
+        panic!("qwqwq");
+    }
+    if a.len() == 3 {
+        println!("qwq");
+        println!("qwq");
+        println!("qwq");
+    }
+    if let Some(b) = c {
+        panic!("orz {}", b);
+    }
+    if a.len() == 3 {
+        panic!("qaqaq");
+    } else {
+        println!("qwq");
+    }
+    let b = vec![1, 2, 3];
+    if b.is_empty() {
+        panic!("panic1");
+    }
+    if b.is_empty() && a.is_empty() {
+        panic!("panic2");
+    }
+    if a.is_empty() && !b.is_empty() {
+        panic!("panic3");
+    }
+    if b.is_empty() || a.is_empty() {
+        panic!("panic4");
+    }
+    if a.is_empty() || !b.is_empty() {
+        panic!("panic5");
+    }
+}
diff --git a/tests/ui/manual_assert.stderr b/tests/ui/manual_assert.stderr
new file mode 100644
index 00000000000..ab2786247b1
--- /dev/null
+++ b/tests/ui/manual_assert.stderr
@@ -0,0 +1,60 @@
+error: only a `panic!` in `if`-then statement
+  --> $DIR/manual_assert.rs:19:5
+   |
+LL | /     if !a.is_empty() {
+LL | |         panic!("qaqaq{:?}", a);
+LL | |     }
+   | |_____^ help: try: `assert!(a.is_empty(), "qaqaq{:?}", a);`
+   |
+   = note: `-D clippy::manual-assert` implied by `-D warnings`
+
+error: only a `panic!` in `if`-then statement
+  --> $DIR/manual_assert.rs:22:5
+   |
+LL | /     if !a.is_empty() {
+LL | |         panic!("qwqwq");
+LL | |     }
+   | |_____^ help: try: `assert!(a.is_empty(), "qwqwq");`
+
+error: only a `panic!` in `if`-then statement
+  --> $DIR/manual_assert.rs:39:5
+   |
+LL | /     if b.is_empty() {
+LL | |         panic!("panic1");
+LL | |     }
+   | |_____^ help: try: `assert!(!b.is_empty(), "panic1");`
+
+error: only a `panic!` in `if`-then statement
+  --> $DIR/manual_assert.rs:42:5
+   |
+LL | /     if b.is_empty() && a.is_empty() {
+LL | |         panic!("panic2");
+LL | |     }
+   | |_____^ help: try: `assert!(!(b.is_empty() && a.is_empty()), "panic2");`
+
+error: only a `panic!` in `if`-then statement
+  --> $DIR/manual_assert.rs:45:5
+   |
+LL | /     if a.is_empty() && !b.is_empty() {
+LL | |         panic!("panic3");
+LL | |     }
+   | |_____^ help: try: `assert!(!(a.is_empty() && !b.is_empty()), "panic3");`
+
+error: only a `panic!` in `if`-then statement
+  --> $DIR/manual_assert.rs:48:5
+   |
+LL | /     if b.is_empty() || a.is_empty() {
+LL | |         panic!("panic4");
+LL | |     }
+   | |_____^ help: try: `assert!(!(b.is_empty() || a.is_empty()), "panic4");`
+
+error: only a `panic!` in `if`-then statement
+  --> $DIR/manual_assert.rs:51:5
+   |
+LL | /     if a.is_empty() || !b.is_empty() {
+LL | |         panic!("panic5");
+LL | |     }
+   | |_____^ help: try: `assert!(!(a.is_empty() || !b.is_empty()), "panic5");`
+
+error: aborting due to 7 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 00ea73e1627841fe3da7ba3699bbe99705063df1 Mon Sep 17 00:00:00 2001
From: Andre Bogus <bogusandre@gmail.com>
Date: Wed, 13 Oct 2021 13:45:53 +0200
Subject: avoid linting `possible_truncation` on bit-reducing operations

---
 clippy_lints/src/casts/cast_possible_truncation.rs | 81 +++++++++++++++++++---
 tests/ui/cast.rs                                   | 15 ++++
 tests/ui/cast.stderr                               | 14 +++-
 3 files changed, 101 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/cast_possible_truncation.rs b/clippy_lints/src/casts/cast_possible_truncation.rs
index 2ae7d16e00b..4af412ccaf3 100644
--- a/clippy_lints/src/casts/cast_possible_truncation.rs
+++ b/clippy_lints/src/casts/cast_possible_truncation.rs
@@ -1,23 +1,88 @@
+use clippy_utils::consts::{constant, Constant};
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::expr_or_init;
 use clippy_utils::ty::is_isize_or_usize;
-use rustc_hir::{Expr, ExprKind};
+use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::LateContext;
 use rustc_middle::ty::{self, FloatTy, Ty};
 
 use super::{utils, CAST_POSSIBLE_TRUNCATION};
 
-pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_expr: &Expr<'_>, cast_from: Ty<'_>, cast_to: Ty<'_>) {
-    // do not lint if cast comes from a `signum` function
-    if let ExprKind::MethodCall(path, ..) = expr_or_init(cx, cast_expr).kind {
-        if path.ident.name.as_str() == "signum" {
-            return;
-        }
+fn constant_int(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<u128> {
+    if let Some((Constant::Int(c), _)) = constant(cx, cx.typeck_results(), expr) {
+        Some(c)
+    } else {
+        None
     }
+}
 
+fn get_constant_bits(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<u64> {
+    constant_int(cx, expr).map(|c| u64::from(128 - c.leading_zeros()))
+}
+
+fn apply_reductions(cx: &LateContext<'_>, nbits: u64, expr: &Expr<'_>, signed: bool) -> u64 {
+    match expr_or_init(cx, expr).kind {
+        ExprKind::Cast(inner, _) => apply_reductions(cx, nbits, inner, signed),
+        ExprKind::Block(block, _) => block.expr.map_or(nbits, |e| apply_reductions(cx, nbits, e, signed)),
+        ExprKind::Binary(op, left, right) => match op.node {
+            BinOpKind::Div => {
+                apply_reductions(cx, nbits, left, signed)
+                    - (if signed {
+                        0 // let's be conservative here
+                    } else {
+                        // by dividing by 1, we remove 0 bits, etc.
+                        get_constant_bits(cx, right).map_or(0, |b| b.saturating_sub(1))
+                    })
+            },
+            BinOpKind::Rem | BinOpKind::BitAnd => get_constant_bits(cx, right)
+                .unwrap_or(u64::max_value())
+                .min(apply_reductions(cx, nbits, left, signed)),
+            BinOpKind::Shr => {
+                apply_reductions(cx, nbits, left, signed)
+                    - constant_int(cx, right).map_or(0, |s| u64::try_from(s).expect("shift too high"))
+            },
+            _ => nbits,
+        },
+        ExprKind::MethodCall(method, _, [left, right], _) => {
+            if signed {
+                return nbits;
+            }
+            let max_bits = if method.ident.as_str() == "min" {
+                get_constant_bits(cx, right)
+            } else {
+                None
+            };
+            apply_reductions(cx, nbits, left, signed).min(max_bits.unwrap_or(u64::max_value()))
+        },
+        ExprKind::MethodCall(method, _, [_, lo, hi], _) => {
+            if method.ident.as_str() == "clamp" {
+                //FIXME: make this a diagnostic item
+                if let (Some(lo_bits), Some(hi_bits)) = (get_constant_bits(cx, lo), get_constant_bits(cx, hi)) {
+                    return lo_bits.max(hi_bits);
+                }
+            }
+            nbits
+        },
+        ExprKind::MethodCall(method, _, [_value], _) => {
+            if method.ident.name.as_str() == "signum" {
+                0 // do not lint if cast comes from a `signum` function
+            } else {
+                nbits
+            }
+        },
+        _ => nbits,
+    }
+}
+
+pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_expr: &Expr<'_>, cast_from: Ty<'_>, cast_to: Ty<'_>) {
     let msg = match (cast_from.is_integral(), cast_to.is_integral()) {
         (true, true) => {
-            let from_nbits = utils::int_ty_to_nbits(cast_from, cx.tcx);
+            let from_nbits = apply_reductions(
+                cx,
+                utils::int_ty_to_nbits(cast_from, cx.tcx),
+                cast_expr,
+                cast_from.is_signed(),
+            );
             let to_nbits = utils::int_ty_to_nbits(cast_to, cx.tcx);
 
             let (should_lint, suffix) = match (is_isize_or_usize(cast_from), is_isize_or_usize(cast_to)) {
diff --git a/tests/ui/cast.rs b/tests/ui/cast.rs
index adc95e63ae5..ebc1ed5587f 100644
--- a/tests/ui/cast.rs
+++ b/tests/ui/cast.rs
@@ -100,4 +100,19 @@ fn main() {
 
     let s = x.signum();
     let _ = s as i32;
+
+    // Test for signed min
+    (-99999999999i64).min(1) as i8; // should be linted because signed
+
+    // Test for various operations that remove enough bits for the result to fit
+    (999999u64 & 1) as u8;
+    (999999u64 % 15) as u8;
+    (999999u64 / 0x1_0000_0000_0000) as u16;
+    ({ 999999u64 >> 56 }) as u8;
+    ({
+        let x = 999999u64;
+        x.min(1)
+    }) as u8;
+    999999u64.clamp(0, 255) as u8;
+    999999u64.clamp(0, 256) as u8; // should still be linted
 }
diff --git a/tests/ui/cast.stderr b/tests/ui/cast.stderr
index 4c66d736494..edf8790cf33 100644
--- a/tests/ui/cast.stderr
+++ b/tests/ui/cast.stderr
@@ -138,5 +138,17 @@ error: casting `isize` to `usize` may lose the sign of the value
 LL |     -1isize as usize;
    |     ^^^^^^^^^^^^^^^^
 
-error: aborting due to 22 previous errors
+error: casting `i64` to `i8` may truncate the value
+  --> $DIR/cast.rs:105:5
+   |
+LL |     (-99999999999i64).min(1) as i8; // should be linted because signed
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: casting `u64` to `u8` may truncate the value
+  --> $DIR/cast.rs:117:5
+   |
+LL |     999999u64.clamp(0, 256) as u8; // should still be linted
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 24 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 2f327aaba594b86ca15a9b81aebc0d8e5667b30f Mon Sep 17 00:00:00 2001
From: Ahmed Karaman <20889958+ahmedkrmn@users.noreply.github.com>
Date: Fri, 29 Oct 2021 04:11:43 +0200
Subject: Disable "if_not_else" lints firing on else-ifs

1. Convert IfNotElse to LateLintPass and use clippy_utils::is_else_clause for checking.
2. Handle the case where the span comes from desugaring.
3. Update tests.
---
 clippy_lints/src/if_not_else.rs | 23 +++++++++++++++--------
 clippy_lints/src/lib.rs         |  2 +-
 tests/ui/if_not_else.rs         | 10 ++++++++++
 tests/ui/if_not_else.stderr     |  4 ++--
 4 files changed, 28 insertions(+), 11 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/if_not_else.rs b/clippy_lints/src/if_not_else.rs
index 3ce91d421ba..ac938156237 100644
--- a/clippy_lints/src/if_not_else.rs
+++ b/clippy_lints/src/if_not_else.rs
@@ -2,9 +2,9 @@
 //! on the condition
 
 use clippy_utils::diagnostics::span_lint_and_help;
-use rustc_ast::ast::{BinOpKind, Expr, ExprKind, UnOp};
-use rustc_lint::{EarlyContext, EarlyLintPass};
-use rustc_middle::lint::in_external_macro;
+use clippy_utils::is_else_clause;
+use rustc_hir::{BinOpKind, Expr, ExprKind, UnOp};
+use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
@@ -46,14 +46,21 @@ declare_clippy_lint! {
 
 declare_lint_pass!(IfNotElse => [IF_NOT_ELSE]);
 
-impl EarlyLintPass for IfNotElse {
-    fn check_expr(&mut self, cx: &EarlyContext<'_>, item: &Expr) {
-        if in_external_macro(cx.sess, item.span) {
+impl LateLintPass<'_> for IfNotElse {
+    fn check_expr(&mut self, cx: &LateContext<'_>, item: &Expr<'_>) {
+        // While loops will be desugared to ExprKind::If. This will cause the lint to fire.
+        // To fix this, return early if this span comes from a macro or desugaring.
+        if item.span.from_expansion() {
             return;
         }
-        if let ExprKind::If(ref cond, _, Some(ref els)) = item.kind {
+        if let ExprKind::If(cond, _, Some(els)) = item.kind {
             if let ExprKind::Block(..) = els.kind {
-                match cond.kind {
+                // Disable firing the lint in "else if" expressions.
+                if is_else_clause(cx.tcx, item) {
+                    return;
+                }
+
+                match cond.peel_drop_temps().kind {
                     ExprKind::Unary(UnOp::Not, _) => {
                         span_lint_and_help(
                             cx,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index fd5f164e7a1..7174d0a082e 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -668,7 +668,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_early_pass(|| Box::new(double_parens::DoubleParens));
     store.register_late_pass(|| Box::new(to_string_in_display::ToStringInDisplay::new()));
     store.register_early_pass(|| Box::new(unsafe_removed_from_name::UnsafeNameRemoval));
-    store.register_early_pass(|| Box::new(if_not_else::IfNotElse));
     store.register_early_pass(|| Box::new(else_if_without_else::ElseIfWithoutElse));
     store.register_early_pass(|| Box::new(int_plus_one::IntPlusOne));
     store.register_early_pass(|| Box::new(formatting::Formatting));
@@ -722,6 +721,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(option_if_let_else::OptionIfLetElse));
     store.register_late_pass(|| Box::new(future_not_send::FutureNotSend));
     store.register_late_pass(|| Box::new(if_let_mutex::IfLetMutex));
+    store.register_late_pass(|| Box::new(if_not_else::IfNotElse));
     store.register_late_pass(|| Box::new(equatable_if_let::PatternEquality));
     store.register_late_pass(|| Box::new(mut_mutex_lock::MutMutexLock));
     store.register_late_pass(|| Box::new(match_on_vec_items::MatchOnVecItems));
diff --git a/tests/ui/if_not_else.rs b/tests/ui/if_not_else.rs
index dc3fb1ceac9..b7012b43d29 100644
--- a/tests/ui/if_not_else.rs
+++ b/tests/ui/if_not_else.rs
@@ -1,6 +1,9 @@
 #![warn(clippy::all)]
 #![warn(clippy::if_not_else)]
 
+fn foo() -> bool {
+    unimplemented!()
+}
 fn bla() -> bool {
     unimplemented!()
 }
@@ -16,4 +19,11 @@ fn main() {
     } else {
         println!("Bunny");
     }
+    if !foo() {
+        println!("Foo");
+    } else if !bla() {
+        println!("Bugs");
+    } else {
+        println!("Bunny");
+    }
 }
diff --git a/tests/ui/if_not_else.stderr b/tests/ui/if_not_else.stderr
index 53d1b86d02a..8c8cc44bb03 100644
--- a/tests/ui/if_not_else.stderr
+++ b/tests/ui/if_not_else.stderr
@@ -1,5 +1,5 @@
 error: unnecessary boolean `not` operation
-  --> $DIR/if_not_else.rs:9:5
+  --> $DIR/if_not_else.rs:12:5
    |
 LL | /     if !bla() {
 LL | |         println!("Bugs");
@@ -12,7 +12,7 @@ LL | |     }
    = help: remove the `!` and swap the blocks of the `if`/`else`
 
 error: unnecessary `!=` operation
-  --> $DIR/if_not_else.rs:14:5
+  --> $DIR/if_not_else.rs:17:5
    |
 LL | /     if 4 != 5 {
 LL | |         println!("Bugs");
-- 
cgit 1.4.1-3-g733a5


From 28c225f7758f68b25205953919b74c1c7fe03e2a Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Sun, 31 Oct 2021 12:25:53 +0000
Subject: Move non_ascii_literal to restriction

---
 clippy_lints/src/lib.register_pedantic.rs    | 1 -
 clippy_lints/src/lib.register_restriction.rs | 1 +
 clippy_lints/src/unicode.rs                  | 2 +-
 3 files changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.register_pedantic.rs b/clippy_lints/src/lib.register_pedantic.rs
index 63ab7f1ca6f..6893bfd473d 100644
--- a/clippy_lints/src/lib.register_pedantic.rs
+++ b/clippy_lints/src/lib.register_pedantic.rs
@@ -89,7 +89,6 @@ store.register_group(true, "clippy::pedantic", Some("clippy_pedantic"), vec![
     LintId::of(transmute::TRANSMUTE_PTR_TO_PTR),
     LintId::of(types::LINKEDLIST),
     LintId::of(types::OPTION_OPTION),
-    LintId::of(unicode::NON_ASCII_LITERAL),
     LintId::of(unicode::UNICODE_NOT_NFC),
     LintId::of(unit_types::LET_UNIT_VALUE),
     LintId::of(unnecessary_wraps::UNNECESSARY_WRAPS),
diff --git a/clippy_lints/src/lib.register_restriction.rs b/clippy_lints/src/lib.register_restriction.rs
index 4929bbecde0..6b4c1b7db51 100644
--- a/clippy_lints/src/lib.register_restriction.rs
+++ b/clippy_lints/src/lib.register_restriction.rs
@@ -59,6 +59,7 @@ store.register_group(true, "clippy::restriction", Some("clippy_restriction"), ve
     LintId::of(types::RC_BUFFER),
     LintId::of(types::RC_MUTEX),
     LintId::of(undocumented_unsafe_blocks::UNDOCUMENTED_UNSAFE_BLOCKS),
+    LintId::of(unicode::NON_ASCII_LITERAL),
     LintId::of(unnecessary_self_imports::UNNECESSARY_SELF_IMPORTS),
     LintId::of(unwrap_in_result::UNWRAP_IN_RESULT),
     LintId::of(verbose_file_reads::VERBOSE_FILE_READS),
diff --git a/clippy_lints/src/unicode.rs b/clippy_lints/src/unicode.rs
index f337dec8f2b..f49ce696a04 100644
--- a/clippy_lints/src/unicode.rs
+++ b/clippy_lints/src/unicode.rs
@@ -45,7 +45,7 @@ declare_clippy_lint! {
     /// let x = String::from("\u{20ac}");
     /// ```
     pub NON_ASCII_LITERAL,
-    pedantic,
+    restriction,
     "using any literal non-ASCII chars in a string literal instead of using the `\\u` escape"
 }
 
-- 
cgit 1.4.1-3-g733a5


From c3d45775c438c57450317ccc859d3af10ce08972 Mon Sep 17 00:00:00 2001
From: Michael Wright <mikerite@lavabit.com>
Date: Mon, 1 Nov 2021 06:12:43 +0200
Subject: Fix `match_overlapping_arm` false negative

Fixes #7816
---
 clippy_lints/src/matches.rs           | 46 +++++++++++++++++------------------
 tests/ui/match_overlapping_arm.rs     |  9 +++++++
 tests/ui/match_overlapping_arm.stderr | 14 ++++++++++-
 3 files changed, 44 insertions(+), 25 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index f1289a36e77..3511defc59c 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -34,7 +34,6 @@ use rustc_span::source_map::{Span, Spanned};
 use rustc_span::sym;
 use std::cmp::Ordering;
 use std::collections::hash_map::Entry;
-use std::iter;
 use std::ops::Bound;
 
 declare_clippy_lint! {
@@ -1703,12 +1702,6 @@ where
     }
 
     impl<'a, T: Copy> Kind<'a, T> {
-        fn range(&self) -> &'a SpannedRange<T> {
-            match *self {
-                Kind::Start(_, r) | Kind::End(_, r) => r,
-            }
-        }
-
         fn value(self) -> Bound<T> {
             match self {
                 Kind::Start(t, _) => Bound::Included(t),
@@ -1726,7 +1719,19 @@ where
     impl<'a, T: Copy + Ord> Ord for Kind<'a, T> {
         fn cmp(&self, other: &Self) -> Ordering {
             match (self.value(), other.value()) {
-                (Bound::Included(a), Bound::Included(b)) | (Bound::Excluded(a), Bound::Excluded(b)) => a.cmp(&b),
+                (Bound::Included(a), Bound::Included(b)) | (Bound::Excluded(a), Bound::Excluded(b)) => {
+                    let value_cmp = a.cmp(&b);
+                    // In the case of ties, starts come before ends
+                    if value_cmp == Ordering::Equal {
+                        match (self, other) {
+                            (Kind::Start(..), Kind::End(..)) => Ordering::Less,
+                            (Kind::End(..), Kind::Start(..)) => Ordering::Greater,
+                            _ => Ordering::Equal,
+                        }
+                    } else {
+                        value_cmp
+                    }
+                },
                 // Range patterns cannot be unbounded (yet)
                 (Bound::Unbounded, _) | (_, Bound::Unbounded) => unimplemented!(),
                 (Bound::Included(a), Bound::Excluded(b)) => match a.cmp(&b) {
@@ -1750,24 +1755,17 @@ where
 
     values.sort();
 
-    for (a, b) in iter::zip(&values, values.iter().skip(1)) {
-        match (a, b) {
-            (&Kind::Start(_, ra), &Kind::End(_, rb)) => {
-                if ra.node != rb.node {
-                    return Some((ra, rb));
-                }
-            },
-            (&Kind::End(a, _), &Kind::Start(b, _)) if a != Bound::Included(b) => (),
-            _ => {
-                // skip if the range `a` is completely included into the range `b`
-                if let Ordering::Equal | Ordering::Less = a.cmp(b) {
-                    let kind_a = Kind::End(a.range().node.1, a.range());
-                    let kind_b = Kind::End(b.range().node.1, b.range());
-                    if let Ordering::Equal | Ordering::Greater = kind_a.cmp(&kind_b) {
-                        return None;
+    let mut started = vec![];
+
+    for value in values {
+        match value {
+            Kind::Start(_, r) => started.push(r),
+            Kind::End(_, er) => {
+                if let Some(sr) = started.pop() {
+                    if sr != er {
+                        return Some((er, sr));
                     }
                 }
-                return Some((a.range(), b.range()));
             },
         }
     }
diff --git a/tests/ui/match_overlapping_arm.rs b/tests/ui/match_overlapping_arm.rs
index 845986a4ead..c25f59c62a5 100644
--- a/tests/ui/match_overlapping_arm.rs
+++ b/tests/ui/match_overlapping_arm.rs
@@ -100,6 +100,15 @@ fn overlapping() {
         _ => (),
     }
 
+    // Issue #7816 - overlap after included range
+    match 42 {
+        5..=10 => (),
+        0..=20 => (),
+        21..=30 => (),
+        21..=40 => (),
+        _ => (),
+    }
+
     // Issue #7829
     match 0 {
         -1..=1 => (),
diff --git a/tests/ui/match_overlapping_arm.stderr b/tests/ui/match_overlapping_arm.stderr
index c2b3f173c2b..69f794edb6a 100644
--- a/tests/ui/match_overlapping_arm.stderr
+++ b/tests/ui/match_overlapping_arm.stderr
@@ -71,5 +71,17 @@ note: overlaps with this
 LL |         ..26 => println!("..26"),
    |         ^^^^
 
-error: aborting due to 6 previous errors
+error: some ranges overlap
+  --> $DIR/match_overlapping_arm.rs:107:9
+   |
+LL |         21..=30 => (),
+   |         ^^^^^^^
+   |
+note: overlaps with this
+  --> $DIR/match_overlapping_arm.rs:108:9
+   |
+LL |         21..=40 => (),
+   |         ^^^^^^^
+
+error: aborting due to 7 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 693df63c7d51aca2bb405a0574717a5d02fd8158 Mon Sep 17 00:00:00 2001
From: Michael Wright <mikerite@lavabit.com>
Date: Mon, 1 Nov 2021 06:12:43 +0200
Subject: Ensure `match_overlapping_arms` warns on first

---
 clippy_lints/src/matches.rs           | 13 ++++++++++---
 tests/ui/match_overlapping_arm.rs     |  9 +++++++++
 tests/ui/match_overlapping_arm.stderr | 14 +++++++++++++-
 3 files changed, 32 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index 3511defc59c..b552e3fc7af 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -1761,10 +1761,17 @@ where
         match value {
             Kind::Start(_, r) => started.push(r),
             Kind::End(_, er) => {
-                if let Some(sr) = started.pop() {
-                    if sr != er {
-                        return Some((er, sr));
+                let mut overlap = None;
+
+                while let Some(sr) = started.pop() {
+                    if sr == er {
+                        break;
                     }
+                    overlap = Some(sr);
+                }
+
+                if let Some(sr) = overlap {
+                    return Some((er, sr));
                 }
             },
         }
diff --git a/tests/ui/match_overlapping_arm.rs b/tests/ui/match_overlapping_arm.rs
index c25f59c62a5..2f85e635713 100644
--- a/tests/ui/match_overlapping_arm.rs
+++ b/tests/ui/match_overlapping_arm.rs
@@ -116,6 +116,15 @@ fn overlapping() {
         _ => (),
     }
 
+    // Only warn about the first if there are multiple overlaps
+    match 42u128 {
+        0..=0x0000_0000_0000_00ff => (),
+        0..=0x0000_0000_0000_ffff => (),
+        0..=0x0000_0000_ffff_ffff => (),
+        0..=0xffff_ffff_ffff_ffff => (),
+        _ => (),
+    }
+
     if let None = Some(42) {
         // nothing
     } else if let None = Some(42) {
diff --git a/tests/ui/match_overlapping_arm.stderr b/tests/ui/match_overlapping_arm.stderr
index 69f794edb6a..b81bb1ecfae 100644
--- a/tests/ui/match_overlapping_arm.stderr
+++ b/tests/ui/match_overlapping_arm.stderr
@@ -83,5 +83,17 @@ note: overlaps with this
 LL |         21..=40 => (),
    |         ^^^^^^^
 
-error: aborting due to 7 previous errors
+error: some ranges overlap
+  --> $DIR/match_overlapping_arm.rs:121:9
+   |
+LL |         0..=0x0000_0000_0000_00ff => (),
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: overlaps with this
+  --> $DIR/match_overlapping_arm.rs:122:9
+   |
+LL |         0..=0x0000_0000_0000_ffff => (),
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 8 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 1085df58ac898fdaea416e592c8667bef162ea87 Mon Sep 17 00:00:00 2001
From: Dharma Saputra Wijaya <dswijj@gmail.com>
Date: Wed, 22 Sep 2021 22:13:54 +0800
Subject: Add `separated_literal_suffix` as an alternative for
 `unseparated_literal_suffix`

This commit adds a configuration `literal-suffix-style` to enforce a
specific style for unseparated_literal_suffix. The configuration accepts
two values:
- "separated"
    enforce all literals to be written separately (e.g. `123_i32`)
- "unseparated"
    enforce all literals to be written as unseparated (e.g. `123i32`)

Not specifying a value means that there is no preference on style and
any style should not be warned.
---
 clippy_lints/src/lib.register_lints.rs             |  1 +
 clippy_lints/src/lib.register_restriction.rs       |  1 +
 clippy_lints/src/misc_early/double_neg.rs          | 23 +++----
 clippy_lints/src/misc_early/literal_suffix.rs      | 38 +++++++++++
 clippy_lints/src/misc_early/mod.rs                 | 39 ++++++++++--
 .../src/misc_early/unseparated_literal_suffix.rs   | 26 --------
 tests/ui/literals.rs                               |  3 +-
 tests/ui/literals.stderr                           | 74 ++++++++++++++++++----
 8 files changed, 148 insertions(+), 57 deletions(-)
 create mode 100644 clippy_lints/src/misc_early/literal_suffix.rs
 delete mode 100644 clippy_lints/src/misc_early/unseparated_literal_suffix.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 28d54246fbb..48ceecde7c9 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -323,6 +323,7 @@ store.register_lints(&[
     misc_early::DUPLICATE_UNDERSCORE_ARGUMENT,
     misc_early::MIXED_CASE_HEX_LITERALS,
     misc_early::REDUNDANT_PATTERN,
+    misc_early::SEPARATED_LITERAL_SUFFIX,
     misc_early::UNNEEDED_FIELD_PATTERN,
     misc_early::UNNEEDED_WILDCARD_PATTERN,
     misc_early::UNSEPARATED_LITERAL_SUFFIX,
diff --git a/clippy_lints/src/lib.register_restriction.rs b/clippy_lints/src/lib.register_restriction.rs
index 419a40b1bb8..bc71602f67e 100644
--- a/clippy_lints/src/lib.register_restriction.rs
+++ b/clippy_lints/src/lib.register_restriction.rs
@@ -34,6 +34,7 @@ store.register_group(true, "clippy::restriction", Some("clippy_restriction"), ve
     LintId::of(methods::GET_UNWRAP),
     LintId::of(methods::UNWRAP_USED),
     LintId::of(misc::FLOAT_CMP_CONST),
+    LintId::of(misc_early::SEPARATED_LITERAL_SUFFIX),
     LintId::of(misc_early::UNNEEDED_FIELD_PATTERN),
     LintId::of(misc_early::UNSEPARATED_LITERAL_SUFFIX),
     LintId::of(missing_doc::MISSING_DOCS_IN_PRIVATE_ITEMS),
diff --git a/clippy_lints/src/misc_early/double_neg.rs b/clippy_lints/src/misc_early/double_neg.rs
index 6f65778e119..06ba968fa4e 100644
--- a/clippy_lints/src/misc_early/double_neg.rs
+++ b/clippy_lints/src/misc_early/double_neg.rs
@@ -1,4 +1,3 @@
-use super::MiscEarlyLints;
 use clippy_utils::diagnostics::span_lint;
 use rustc_ast::ast::{Expr, ExprKind, UnOp};
 use rustc_lint::EarlyContext;
@@ -6,18 +5,14 @@ use rustc_lint::EarlyContext;
 use super::DOUBLE_NEG;
 
 pub(super) fn check(cx: &EarlyContext<'_>, expr: &Expr) {
-    match expr.kind {
-        ExprKind::Unary(UnOp::Neg, ref inner) => {
-            if let ExprKind::Unary(UnOp::Neg, _) = inner.kind {
-                span_lint(
-                    cx,
-                    DOUBLE_NEG,
-                    expr.span,
-                    "`--x` could be misinterpreted as pre-decrement by C programmers, is usually a no-op",
-                );
-            }
-        },
-        ExprKind::Lit(ref lit) => MiscEarlyLints::check_lit(cx, lit),
-        _ => (),
+    if let ExprKind::Unary(UnOp::Neg, ref inner) = expr.kind {
+        if let ExprKind::Unary(UnOp::Neg, _) = inner.kind {
+            span_lint(
+                cx,
+                DOUBLE_NEG,
+                expr.span,
+                "`--x` could be misinterpreted as pre-decrement by C programmers, is usually a no-op",
+            );
+        }
     }
 }
diff --git a/clippy_lints/src/misc_early/literal_suffix.rs b/clippy_lints/src/misc_early/literal_suffix.rs
new file mode 100644
index 00000000000..1165c19a0cf
--- /dev/null
+++ b/clippy_lints/src/misc_early/literal_suffix.rs
@@ -0,0 +1,38 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use rustc_ast::ast::Lit;
+use rustc_errors::Applicability;
+use rustc_lint::EarlyContext;
+
+use super::{SEPARATED_LITERAL_SUFFIX, UNSEPARATED_LITERAL_SUFFIX};
+
+pub(super) fn check(cx: &EarlyContext<'_>, lit: &Lit, lit_snip: &str, suffix: &str, sugg_type: &str) {
+    let maybe_last_sep_idx = if let Some(val) = lit_snip.len().checked_sub(suffix.len() + 1) {
+        val
+    } else {
+        return; // It's useless so shouldn't lint.
+    };
+    // Do not lint when literal is unsuffixed.
+    if !suffix.is_empty() {
+        if lit_snip.as_bytes()[maybe_last_sep_idx] == b'_' {
+            span_lint_and_sugg(
+                cx,
+                SEPARATED_LITERAL_SUFFIX,
+                lit.span,
+                &format!("{} type suffix should not be separated by an underscore", sugg_type),
+                "remove the underscore",
+                format!("{}{}", &lit_snip[..maybe_last_sep_idx], suffix),
+                Applicability::MachineApplicable,
+            );
+        } else {
+            span_lint_and_sugg(
+                cx,
+                UNSEPARATED_LITERAL_SUFFIX,
+                lit.span,
+                &format!("{} type suffix should be separated by an underscore", sugg_type),
+                "add an underscore",
+                format!("{}_{}", &lit_snip[..=maybe_last_sep_idx], suffix),
+                Applicability::MachineApplicable,
+            );
+        }
+    }
+}
diff --git a/clippy_lints/src/misc_early/mod.rs b/clippy_lints/src/misc_early/mod.rs
index 5aad08cdd46..7c3f5f22ade 100644
--- a/clippy_lints/src/misc_early/mod.rs
+++ b/clippy_lints/src/misc_early/mod.rs
@@ -1,15 +1,15 @@
 mod builtin_type_shadow;
 mod double_neg;
+mod literal_suffix;
 mod mixed_case_hex_literals;
 mod redundant_pattern;
 mod unneeded_field_pattern;
 mod unneeded_wildcard_pattern;
-mod unseparated_literal_suffix;
 mod zero_prefixed_literal;
 
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::source::snippet_opt;
-use rustc_ast::ast::{Expr, Generics, Lit, LitFloatType, LitIntType, LitKind, NodeId, Pat, PatKind};
+use rustc_ast::ast::{Expr, ExprKind, Generics, Lit, LitFloatType, LitIntType, LitKind, NodeId, Pat, PatKind};
 use rustc_ast::visit::FnKind;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_lint::{EarlyContext, EarlyLintPass};
@@ -115,9 +115,11 @@ declare_clippy_lint! {
     /// ### What it does
     /// Warns if literal suffixes are not separated by an
     /// underscore.
+    /// To enforce unseparated literal suffix style,
+    /// see the `separated_literal_suffix` lint.
     ///
     /// ### Why is this bad?
-    /// It is much less readable.
+    /// Suffix style should be consistent.
     ///
     /// ### Example
     /// ```rust
@@ -132,6 +134,28 @@ declare_clippy_lint! {
     "literals whose suffix is not separated by an underscore"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Warns if literal suffixes are separated by an underscore.
+    /// To enforce separated literal suffix style,
+    /// see the `unseparated_literal_suffix` lint.
+    ///
+    /// ### Why is this bad?
+    /// Suffix style should be consistent.
+    ///
+    /// ### Example
+    /// ```rust
+    /// // Bad
+    /// let y = 123832_i32;
+    ///
+    /// // Good
+    /// let y = 123832i32;
+    /// ```
+    pub SEPARATED_LITERAL_SUFFIX,
+    restriction,
+    "literals whose suffix is separated by an underscore"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Warns if an integral constant literal starts with `0`.
@@ -260,6 +284,7 @@ declare_lint_pass!(MiscEarlyLints => [
     DOUBLE_NEG,
     MIXED_CASE_HEX_LITERALS,
     UNSEPARATED_LITERAL_SUFFIX,
+    SEPARATED_LITERAL_SUFFIX,
     ZERO_PREFIXED_LITERAL,
     BUILTIN_TYPE_SHADOW,
     REDUNDANT_PATTERN,
@@ -310,6 +335,10 @@ impl EarlyLintPass for MiscEarlyLints {
         if in_external_macro(cx.sess, expr.span) {
             return;
         }
+
+        if let ExprKind::Lit(ref lit) = expr.kind {
+            MiscEarlyLints::check_lit(cx, lit);
+        }
         double_neg::check(cx, expr);
     }
 }
@@ -332,7 +361,7 @@ impl MiscEarlyLints {
                 LitIntType::Unsigned(ty) => ty.name_str(),
                 LitIntType::Unsuffixed => "",
             };
-            unseparated_literal_suffix::check(cx, lit, &lit_snip, suffix, "integer");
+            literal_suffix::check(cx, lit, &lit_snip, suffix, "integer");
             if lit_snip.starts_with("0x") {
                 mixed_case_hex_literals::check(cx, lit, suffix, &lit_snip);
             } else if lit_snip.starts_with("0b") || lit_snip.starts_with("0o") {
@@ -342,7 +371,7 @@ impl MiscEarlyLints {
             }
         } else if let LitKind::Float(_, LitFloatType::Suffixed(float_ty)) = lit.kind {
             let suffix = float_ty.name_str();
-            unseparated_literal_suffix::check(cx, lit, &lit_snip, suffix, "float");
+            literal_suffix::check(cx, lit, &lit_snip, suffix, "float");
         }
     }
 }
diff --git a/clippy_lints/src/misc_early/unseparated_literal_suffix.rs b/clippy_lints/src/misc_early/unseparated_literal_suffix.rs
deleted file mode 100644
index 2018aa6184a..00000000000
--- a/clippy_lints/src/misc_early/unseparated_literal_suffix.rs
+++ /dev/null
@@ -1,26 +0,0 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
-use rustc_ast::ast::Lit;
-use rustc_errors::Applicability;
-use rustc_lint::EarlyContext;
-
-use super::UNSEPARATED_LITERAL_SUFFIX;
-
-pub(super) fn check(cx: &EarlyContext<'_>, lit: &Lit, lit_snip: &str, suffix: &str, sugg_type: &str) {
-    let maybe_last_sep_idx = if let Some(val) = lit_snip.len().checked_sub(suffix.len() + 1) {
-        val
-    } else {
-        return; // It's useless so shouldn't lint.
-    };
-    // Do not lint when literal is unsuffixed.
-    if !suffix.is_empty() && lit_snip.as_bytes()[maybe_last_sep_idx] != b'_' {
-        span_lint_and_sugg(
-            cx,
-            UNSEPARATED_LITERAL_SUFFIX,
-            lit.span,
-            &format!("{} type suffix should be separated by an underscore", sugg_type),
-            "add an underscore",
-            format!("{}_{}", &lit_snip[..=maybe_last_sep_idx], suffix),
-            Applicability::MachineApplicable,
-        );
-    }
-}
diff --git a/tests/ui/literals.rs b/tests/ui/literals.rs
index a72a74b9131..e60ce8492fc 100644
--- a/tests/ui/literals.rs
+++ b/tests/ui/literals.rs
@@ -2,7 +2,8 @@
 
 #![warn(clippy::mixed_case_hex_literals)]
 #![warn(clippy::zero_prefixed_literal)]
-#![allow(clippy::unseparated_literal_suffix)]
+#![warn(clippy::unseparated_literal_suffix)]
+#![warn(clippy::separated_literal_suffix)]
 #![allow(dead_code)]
 
 fn main() {
diff --git a/tests/ui/literals.stderr b/tests/ui/literals.stderr
index 99542e20f78..365b2407473 100644
--- a/tests/ui/literals.stderr
+++ b/tests/ui/literals.stderr
@@ -1,25 +1,65 @@
+error: integer type suffix should not be separated by an underscore
+  --> $DIR/literals.rs:12:15
+   |
+LL |     let ok4 = 0xab_cd_i32;
+   |               ^^^^^^^^^^^ help: remove the underscore: `0xab_cdi32`
+   |
+   = note: `-D clippy::separated-literal-suffix` implied by `-D warnings`
+
+error: integer type suffix should not be separated by an underscore
+  --> $DIR/literals.rs:13:15
+   |
+LL |     let ok5 = 0xAB_CD_u32;
+   |               ^^^^^^^^^^^ help: remove the underscore: `0xAB_CDu32`
+
+error: integer type suffix should not be separated by an underscore
+  --> $DIR/literals.rs:14:15
+   |
+LL |     let ok5 = 0xAB_CD_isize;
+   |               ^^^^^^^^^^^^^ help: remove the underscore: `0xAB_CDisize`
+
 error: inconsistent casing in hexadecimal literal
-  --> $DIR/literals.rs:14:17
+  --> $DIR/literals.rs:15:17
    |
 LL |     let fail1 = 0xabCD;
    |                 ^^^^^^
    |
    = note: `-D clippy::mixed-case-hex-literals` implied by `-D warnings`
 
+error: integer type suffix should not be separated by an underscore
+  --> $DIR/literals.rs:16:17
+   |
+LL |     let fail2 = 0xabCD_u32;
+   |                 ^^^^^^^^^^ help: remove the underscore: `0xabCDu32`
+
 error: inconsistent casing in hexadecimal literal
-  --> $DIR/literals.rs:15:17
+  --> $DIR/literals.rs:16:17
    |
 LL |     let fail2 = 0xabCD_u32;
    |                 ^^^^^^^^^^
 
+error: integer type suffix should not be separated by an underscore
+  --> $DIR/literals.rs:17:17
+   |
+LL |     let fail2 = 0xabCD_isize;
+   |                 ^^^^^^^^^^^^ help: remove the underscore: `0xabCDisize`
+
 error: inconsistent casing in hexadecimal literal
-  --> $DIR/literals.rs:16:17
+  --> $DIR/literals.rs:17:17
    |
 LL |     let fail2 = 0xabCD_isize;
    |                 ^^^^^^^^^^^^
 
+error: integer type suffix should be separated by an underscore
+  --> $DIR/literals.rs:18:27
+   |
+LL |     let fail_multi_zero = 000_123usize;
+   |                           ^^^^^^^^^^^^ help: add an underscore: `000_123_usize`
+   |
+   = note: `-D clippy::unseparated-literal-suffix` implied by `-D warnings`
+
 error: this is a decimal constant
-  --> $DIR/literals.rs:17:27
+  --> $DIR/literals.rs:18:27
    |
 LL |     let fail_multi_zero = 000_123usize;
    |                           ^^^^^^^^^^^^
@@ -34,8 +74,14 @@ help: if you mean to use an octal constant, use `0o`
 LL |     let fail_multi_zero = 0o123usize;
    |                           ~~~~~~~~~~
 
+error: integer type suffix should not be separated by an underscore
+  --> $DIR/literals.rs:21:16
+   |
+LL |     let ok10 = 0_i64;
+   |                ^^^^^ help: remove the underscore: `0i64`
+
 error: this is a decimal constant
-  --> $DIR/literals.rs:21:17
+  --> $DIR/literals.rs:22:17
    |
 LL |     let fail8 = 0123;
    |                 ^^^^
@@ -49,8 +95,14 @@ help: if you mean to use an octal constant, use `0o`
 LL |     let fail8 = 0o123;
    |                 ~~~~~
 
+error: integer type suffix should not be separated by an underscore
+  --> $DIR/literals.rs:31:16
+   |
+LL |     let ok17 = 0x123_4567_8901_usize;
+   |                ^^^^^^^^^^^^^^^^^^^^^ help: remove the underscore: `0x123_4567_8901usize`
+
 error: digits grouped inconsistently by underscores
-  --> $DIR/literals.rs:33:18
+  --> $DIR/literals.rs:34:18
    |
 LL |     let fail19 = 12_3456_21;
    |                  ^^^^^^^^^^ help: consider: `12_345_621`
@@ -58,19 +110,19 @@ LL |     let fail19 = 12_3456_21;
    = note: `-D clippy::inconsistent-digit-grouping` implied by `-D warnings`
 
 error: digits grouped inconsistently by underscores
-  --> $DIR/literals.rs:34:18
+  --> $DIR/literals.rs:35:18
    |
 LL |     let fail22 = 3__4___23;
    |                  ^^^^^^^^^ help: consider: `3_423`
 
 error: digits grouped inconsistently by underscores
-  --> $DIR/literals.rs:35:18
+  --> $DIR/literals.rs:36:18
    |
 LL |     let fail23 = 3__16___23;
    |                  ^^^^^^^^^^ help: consider: `31_623`
 
 error: digits of hex or binary literal not grouped by four
-  --> $DIR/literals.rs:37:18
+  --> $DIR/literals.rs:38:18
    |
 LL |     let fail24 = 0xAB_ABC_AB;
    |                  ^^^^^^^^^^^ help: consider: `0x0ABA_BCAB`
@@ -78,10 +130,10 @@ LL |     let fail24 = 0xAB_ABC_AB;
    = note: `-D clippy::unusual-byte-groupings` implied by `-D warnings`
 
 error: digits of hex or binary literal not grouped by four
-  --> $DIR/literals.rs:38:18
+  --> $DIR/literals.rs:39:18
    |
 LL |     let fail25 = 0b01_100_101;
    |                  ^^^^^^^^^^^^ help: consider: `0b0110_0101`
 
-error: aborting due to 10 previous errors
+error: aborting due to 18 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 7e5f99ab58afc53f208f31db2e1d664efe679ce2 Mon Sep 17 00:00:00 2001
From: Gary Guo <gary@garyguo.net>
Date: Thu, 21 Oct 2021 00:08:18 +0100
Subject: Fix manual_assert for `#![no_std]` and Rust 2021

---
 clippy_lints/src/manual_assert.rs              | 25 +++++------
 clippy_lints/src/matches.rs                    | 24 ++++++-----
 clippy_utils/src/higher.rs                     |  4 +-
 tests/ui/manual_assert.edition2018.fixed       | 43 ++++++++++++++++++
 tests/ui/manual_assert.edition2018.stderr      | 60 ++++++++++++++++++++++++++
 tests/ui/manual_assert.edition2021.fixed       | 43 ++++++++++++++++++
 tests/ui/manual_assert.edition2021.stderr      | 60 ++++++++++++++++++++++++++
 tests/ui/manual_assert.fixed                   |  5 ++-
 tests/ui/manual_assert.rs                      |  5 ++-
 tests/ui/manual_assert.stderr                  | 60 --------------------------
 tests/ui/match_wild_err_arm.edition2018.stderr | 35 +++++++++++++++
 tests/ui/match_wild_err_arm.edition2021.stderr | 35 +++++++++++++++
 tests/ui/match_wild_err_arm.rs                 |  7 +--
 tests/ui/match_wild_err_arm.stderr             | 35 ---------------
 14 files changed, 314 insertions(+), 127 deletions(-)
 create mode 100644 tests/ui/manual_assert.edition2018.fixed
 create mode 100644 tests/ui/manual_assert.edition2018.stderr
 create mode 100644 tests/ui/manual_assert.edition2021.fixed
 create mode 100644 tests/ui/manual_assert.edition2021.stderr
 delete mode 100644 tests/ui/manual_assert.stderr
 create mode 100644 tests/ui/match_wild_err_arm.edition2018.stderr
 create mode 100644 tests/ui/match_wild_err_arm.edition2021.stderr
 delete mode 100644 tests/ui/match_wild_err_arm.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_assert.rs b/clippy_lints/src/manual_assert.rs
index c639be1bccb..e55aa3f1850 100644
--- a/clippy_lints/src/manual_assert.rs
+++ b/clippy_lints/src/manual_assert.rs
@@ -54,23 +54,24 @@ impl LateLintPass<'_> for ManualAssert {
             if !cx.tcx.sess.source_map().is_multiline(cond.span);
 
             then {
-                let span = if let Some(panic_expn) = PanicExpn::parse(semi) {
+                let call = if_chain! {
+                    if let ExprKind::Block(block, _) = semi.kind;
+                    if let Some(init) = block.expr;
+                    then {
+                        init
+                    } else {
+                        semi
+                    }
+                };
+                let span = if let Some(panic_expn) = PanicExpn::parse(call) {
                     match *panic_expn.format_args.value_args {
                         [] => panic_expn.format_args.format_string_span,
                         [.., last] => panic_expn.format_args.format_string_span.to(last.span),
                     }
+                } else if let ExprKind::Call(_, [format_args]) = call.kind {
+                    format_args.span
                 } else {
-                    if_chain! {
-                        if let ExprKind::Block(block, _) = semi.kind;
-                        if let Some(init) = block.expr;
-                        if let ExprKind::Call(_, [format_args]) = init.kind;
-
-                        then {
-                            format_args.span
-                        } else {
-                            return
-                        }
-                    }
+                    return
                 };
                 let mut applicability = Applicability::MachineApplicable;
                 let sugg = snippet_with_applicability(cx, span, "..", &mut applicability);
diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index f1289a36e77..eb311983b29 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -967,8 +967,7 @@ fn check_wild_err_arm<'tcx>(cx: &LateContext<'tcx>, ex: &Expr<'tcx>, arms: &[Arm
                     }
                     if_chain! {
                         if matching_wild;
-                        if let ExprKind::Block(block, _) = arm.body.kind;
-                        if is_panic_block(block);
+                        if is_panic_call(arm.body);
                         then {
                             // `Err(_)` or `Err(_e)` arm with `panic!` found
                             span_lint_and_note(cx,
@@ -1171,14 +1170,19 @@ fn check_wild_enum_match(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>])
 }
 
 // If the block contains only a `panic!` macro (as expression or statement)
-fn is_panic_block(block: &Block<'_>) -> bool {
-    match (&block.expr, block.stmts.len(), block.stmts.first()) {
-        (&Some(exp), 0, _) => is_expn_of(exp.span, "panic").is_some() && is_expn_of(exp.span, "unreachable").is_none(),
-        (&None, 1, Some(stmt)) => {
-            is_expn_of(stmt.span, "panic").is_some() && is_expn_of(stmt.span, "unreachable").is_none()
-        },
-        _ => false,
-    }
+fn is_panic_call(expr: &Expr<'_>) -> bool {
+    // Unwrap any wrapping blocks
+    let span = if let ExprKind::Block(block, _) = expr.kind {
+        match (&block.expr, block.stmts.len(), block.stmts.first()) {
+            (&Some(exp), 0, _) => exp.span,
+            (&None, 1, Some(stmt)) => stmt.span,
+            _ => return false,
+        }
+    } else {
+        expr.span
+    };
+
+    is_expn_of(span, "panic").is_some() && is_expn_of(span, "unreachable").is_none()
 }
 
 fn check_match_ref_pats<'a, 'b, I>(cx: &LateContext<'_>, ex: &Expr<'_>, pats: I, expr: &Expr<'_>)
diff --git a/clippy_utils/src/higher.rs b/clippy_utils/src/higher.rs
index 7cbd43e6266..c1a763def3d 100644
--- a/clippy_utils/src/higher.rs
+++ b/clippy_utils/src/higher.rs
@@ -718,9 +718,7 @@ impl PanicExpn<'tcx> {
     /// Parses an expanded `panic!` invocation
     pub fn parse(expr: &'tcx Expr<'tcx>) -> Option<Self> {
         if_chain! {
-            if let ExprKind::Block(block, _) = expr.kind;
-            if let Some(init) = block.expr;
-            if let ExprKind::Call(_, [format_args]) = init.kind;
+            if let ExprKind::Call(_, [format_args]) = expr.kind;
             let expn_data = expr.span.ctxt().outer_expn_data();
             if let Some(format_args) = FormatArgsExpn::parse(format_args);
             then {
diff --git a/tests/ui/manual_assert.edition2018.fixed b/tests/ui/manual_assert.edition2018.fixed
new file mode 100644
index 00000000000..11fe06c5724
--- /dev/null
+++ b/tests/ui/manual_assert.edition2018.fixed
@@ -0,0 +1,43 @@
+// revisions: edition2018 edition2021
+// [edition2018] edition:2018
+// [edition2021] edition:2021
+// run-rustfix
+#![warn(clippy::manual_assert)]
+
+fn main() {
+    let a = vec![1, 2, 3];
+    let c = Some(2);
+    if !a.is_empty()
+        && a.len() == 3
+        && c != None
+        && !a.is_empty()
+        && a.len() == 3
+        && !a.is_empty()
+        && a.len() == 3
+        && !a.is_empty()
+        && a.len() == 3
+    {
+        panic!("qaqaq{:?}", a);
+    }
+    assert!(a.is_empty(), "qaqaq{:?}", a);
+    assert!(a.is_empty(), "qwqwq");
+    if a.len() == 3 {
+        println!("qwq");
+        println!("qwq");
+        println!("qwq");
+    }
+    if let Some(b) = c {
+        panic!("orz {}", b);
+    }
+    if a.len() == 3 {
+        panic!("qaqaq");
+    } else {
+        println!("qwq");
+    }
+    let b = vec![1, 2, 3];
+    assert!(!b.is_empty(), "panic1");
+    assert!(!(b.is_empty() && a.is_empty()), "panic2");
+    assert!(!(a.is_empty() && !b.is_empty()), "panic3");
+    assert!(!(b.is_empty() || a.is_empty()), "panic4");
+    assert!(!(a.is_empty() || !b.is_empty()), "panic5");
+}
diff --git a/tests/ui/manual_assert.edition2018.stderr b/tests/ui/manual_assert.edition2018.stderr
new file mode 100644
index 00000000000..03c03472f90
--- /dev/null
+++ b/tests/ui/manual_assert.edition2018.stderr
@@ -0,0 +1,60 @@
+error: only a `panic!` in `if`-then statement
+  --> $DIR/manual_assert.rs:22:5
+   |
+LL | /     if !a.is_empty() {
+LL | |         panic!("qaqaq{:?}", a);
+LL | |     }
+   | |_____^ help: try: `assert!(a.is_empty(), "qaqaq{:?}", a);`
+   |
+   = note: `-D clippy::manual-assert` implied by `-D warnings`
+
+error: only a `panic!` in `if`-then statement
+  --> $DIR/manual_assert.rs:25:5
+   |
+LL | /     if !a.is_empty() {
+LL | |         panic!("qwqwq");
+LL | |     }
+   | |_____^ help: try: `assert!(a.is_empty(), "qwqwq");`
+
+error: only a `panic!` in `if`-then statement
+  --> $DIR/manual_assert.rs:42:5
+   |
+LL | /     if b.is_empty() {
+LL | |         panic!("panic1");
+LL | |     }
+   | |_____^ help: try: `assert!(!b.is_empty(), "panic1");`
+
+error: only a `panic!` in `if`-then statement
+  --> $DIR/manual_assert.rs:45:5
+   |
+LL | /     if b.is_empty() && a.is_empty() {
+LL | |         panic!("panic2");
+LL | |     }
+   | |_____^ help: try: `assert!(!(b.is_empty() && a.is_empty()), "panic2");`
+
+error: only a `panic!` in `if`-then statement
+  --> $DIR/manual_assert.rs:48:5
+   |
+LL | /     if a.is_empty() && !b.is_empty() {
+LL | |         panic!("panic3");
+LL | |     }
+   | |_____^ help: try: `assert!(!(a.is_empty() && !b.is_empty()), "panic3");`
+
+error: only a `panic!` in `if`-then statement
+  --> $DIR/manual_assert.rs:51:5
+   |
+LL | /     if b.is_empty() || a.is_empty() {
+LL | |         panic!("panic4");
+LL | |     }
+   | |_____^ help: try: `assert!(!(b.is_empty() || a.is_empty()), "panic4");`
+
+error: only a `panic!` in `if`-then statement
+  --> $DIR/manual_assert.rs:54:5
+   |
+LL | /     if a.is_empty() || !b.is_empty() {
+LL | |         panic!("panic5");
+LL | |     }
+   | |_____^ help: try: `assert!(!(a.is_empty() || !b.is_empty()), "panic5");`
+
+error: aborting due to 7 previous errors
+
diff --git a/tests/ui/manual_assert.edition2021.fixed b/tests/ui/manual_assert.edition2021.fixed
new file mode 100644
index 00000000000..11fe06c5724
--- /dev/null
+++ b/tests/ui/manual_assert.edition2021.fixed
@@ -0,0 +1,43 @@
+// revisions: edition2018 edition2021
+// [edition2018] edition:2018
+// [edition2021] edition:2021
+// run-rustfix
+#![warn(clippy::manual_assert)]
+
+fn main() {
+    let a = vec![1, 2, 3];
+    let c = Some(2);
+    if !a.is_empty()
+        && a.len() == 3
+        && c != None
+        && !a.is_empty()
+        && a.len() == 3
+        && !a.is_empty()
+        && a.len() == 3
+        && !a.is_empty()
+        && a.len() == 3
+    {
+        panic!("qaqaq{:?}", a);
+    }
+    assert!(a.is_empty(), "qaqaq{:?}", a);
+    assert!(a.is_empty(), "qwqwq");
+    if a.len() == 3 {
+        println!("qwq");
+        println!("qwq");
+        println!("qwq");
+    }
+    if let Some(b) = c {
+        panic!("orz {}", b);
+    }
+    if a.len() == 3 {
+        panic!("qaqaq");
+    } else {
+        println!("qwq");
+    }
+    let b = vec![1, 2, 3];
+    assert!(!b.is_empty(), "panic1");
+    assert!(!(b.is_empty() && a.is_empty()), "panic2");
+    assert!(!(a.is_empty() && !b.is_empty()), "panic3");
+    assert!(!(b.is_empty() || a.is_empty()), "panic4");
+    assert!(!(a.is_empty() || !b.is_empty()), "panic5");
+}
diff --git a/tests/ui/manual_assert.edition2021.stderr b/tests/ui/manual_assert.edition2021.stderr
new file mode 100644
index 00000000000..03c03472f90
--- /dev/null
+++ b/tests/ui/manual_assert.edition2021.stderr
@@ -0,0 +1,60 @@
+error: only a `panic!` in `if`-then statement
+  --> $DIR/manual_assert.rs:22:5
+   |
+LL | /     if !a.is_empty() {
+LL | |         panic!("qaqaq{:?}", a);
+LL | |     }
+   | |_____^ help: try: `assert!(a.is_empty(), "qaqaq{:?}", a);`
+   |
+   = note: `-D clippy::manual-assert` implied by `-D warnings`
+
+error: only a `panic!` in `if`-then statement
+  --> $DIR/manual_assert.rs:25:5
+   |
+LL | /     if !a.is_empty() {
+LL | |         panic!("qwqwq");
+LL | |     }
+   | |_____^ help: try: `assert!(a.is_empty(), "qwqwq");`
+
+error: only a `panic!` in `if`-then statement
+  --> $DIR/manual_assert.rs:42:5
+   |
+LL | /     if b.is_empty() {
+LL | |         panic!("panic1");
+LL | |     }
+   | |_____^ help: try: `assert!(!b.is_empty(), "panic1");`
+
+error: only a `panic!` in `if`-then statement
+  --> $DIR/manual_assert.rs:45:5
+   |
+LL | /     if b.is_empty() && a.is_empty() {
+LL | |         panic!("panic2");
+LL | |     }
+   | |_____^ help: try: `assert!(!(b.is_empty() && a.is_empty()), "panic2");`
+
+error: only a `panic!` in `if`-then statement
+  --> $DIR/manual_assert.rs:48:5
+   |
+LL | /     if a.is_empty() && !b.is_empty() {
+LL | |         panic!("panic3");
+LL | |     }
+   | |_____^ help: try: `assert!(!(a.is_empty() && !b.is_empty()), "panic3");`
+
+error: only a `panic!` in `if`-then statement
+  --> $DIR/manual_assert.rs:51:5
+   |
+LL | /     if b.is_empty() || a.is_empty() {
+LL | |         panic!("panic4");
+LL | |     }
+   | |_____^ help: try: `assert!(!(b.is_empty() || a.is_empty()), "panic4");`
+
+error: only a `panic!` in `if`-then statement
+  --> $DIR/manual_assert.rs:54:5
+   |
+LL | /     if a.is_empty() || !b.is_empty() {
+LL | |         panic!("panic5");
+LL | |     }
+   | |_____^ help: try: `assert!(!(a.is_empty() || !b.is_empty()), "panic5");`
+
+error: aborting due to 7 previous errors
+
diff --git a/tests/ui/manual_assert.fixed b/tests/ui/manual_assert.fixed
index 8943bc80897..11fe06c5724 100644
--- a/tests/ui/manual_assert.fixed
+++ b/tests/ui/manual_assert.fixed
@@ -1,6 +1,7 @@
-// edition:2018
+// revisions: edition2018 edition2021
+// [edition2018] edition:2018
+// [edition2021] edition:2021
 // run-rustfix
-//FIXME: This does not correctly match in edition 2021, see #7843
 #![warn(clippy::manual_assert)]
 
 fn main() {
diff --git a/tests/ui/manual_assert.rs b/tests/ui/manual_assert.rs
index 4c474777e8d..8713426fc88 100644
--- a/tests/ui/manual_assert.rs
+++ b/tests/ui/manual_assert.rs
@@ -1,6 +1,7 @@
-// edition:2018
+// revisions: edition2018 edition2021
+// [edition2018] edition:2018
+// [edition2021] edition:2021
 // run-rustfix
-//FIXME: This does not correctly match in edition 2021, see #7843
 #![warn(clippy::manual_assert)]
 
 fn main() {
diff --git a/tests/ui/manual_assert.stderr b/tests/ui/manual_assert.stderr
deleted file mode 100644
index a8e907d25db..00000000000
--- a/tests/ui/manual_assert.stderr
+++ /dev/null
@@ -1,60 +0,0 @@
-error: only a `panic!` in `if`-then statement
-  --> $DIR/manual_assert.rs:21:5
-   |
-LL | /     if !a.is_empty() {
-LL | |         panic!("qaqaq{:?}", a);
-LL | |     }
-   | |_____^ help: try: `assert!(a.is_empty(), "qaqaq{:?}", a);`
-   |
-   = note: `-D clippy::manual-assert` implied by `-D warnings`
-
-error: only a `panic!` in `if`-then statement
-  --> $DIR/manual_assert.rs:24:5
-   |
-LL | /     if !a.is_empty() {
-LL | |         panic!("qwqwq");
-LL | |     }
-   | |_____^ help: try: `assert!(a.is_empty(), "qwqwq");`
-
-error: only a `panic!` in `if`-then statement
-  --> $DIR/manual_assert.rs:41:5
-   |
-LL | /     if b.is_empty() {
-LL | |         panic!("panic1");
-LL | |     }
-   | |_____^ help: try: `assert!(!b.is_empty(), "panic1");`
-
-error: only a `panic!` in `if`-then statement
-  --> $DIR/manual_assert.rs:44:5
-   |
-LL | /     if b.is_empty() && a.is_empty() {
-LL | |         panic!("panic2");
-LL | |     }
-   | |_____^ help: try: `assert!(!(b.is_empty() && a.is_empty()), "panic2");`
-
-error: only a `panic!` in `if`-then statement
-  --> $DIR/manual_assert.rs:47:5
-   |
-LL | /     if a.is_empty() && !b.is_empty() {
-LL | |         panic!("panic3");
-LL | |     }
-   | |_____^ help: try: `assert!(!(a.is_empty() && !b.is_empty()), "panic3");`
-
-error: only a `panic!` in `if`-then statement
-  --> $DIR/manual_assert.rs:50:5
-   |
-LL | /     if b.is_empty() || a.is_empty() {
-LL | |         panic!("panic4");
-LL | |     }
-   | |_____^ help: try: `assert!(!(b.is_empty() || a.is_empty()), "panic4");`
-
-error: only a `panic!` in `if`-then statement
-  --> $DIR/manual_assert.rs:53:5
-   |
-LL | /     if a.is_empty() || !b.is_empty() {
-LL | |         panic!("panic5");
-LL | |     }
-   | |_____^ help: try: `assert!(!(a.is_empty() || !b.is_empty()), "panic5");`
-
-error: aborting due to 7 previous errors
-
diff --git a/tests/ui/match_wild_err_arm.edition2018.stderr b/tests/ui/match_wild_err_arm.edition2018.stderr
new file mode 100644
index 00000000000..2a4012039ba
--- /dev/null
+++ b/tests/ui/match_wild_err_arm.edition2018.stderr
@@ -0,0 +1,35 @@
+error: `Err(_)` matches all errors
+  --> $DIR/match_wild_err_arm.rs:14:9
+   |
+LL |         Err(_) => panic!("err"),
+   |         ^^^^^^
+   |
+   = note: `-D clippy::match-wild-err-arm` implied by `-D warnings`
+   = note: match each error separately or use the error output, or use `.except(msg)` if the error case is unreachable
+
+error: `Err(_)` matches all errors
+  --> $DIR/match_wild_err_arm.rs:20:9
+   |
+LL |         Err(_) => panic!(),
+   |         ^^^^^^
+   |
+   = note: match each error separately or use the error output, or use `.except(msg)` if the error case is unreachable
+
+error: `Err(_)` matches all errors
+  --> $DIR/match_wild_err_arm.rs:26:9
+   |
+LL |         Err(_) => {
+   |         ^^^^^^
+   |
+   = note: match each error separately or use the error output, or use `.except(msg)` if the error case is unreachable
+
+error: `Err(_e)` matches all errors
+  --> $DIR/match_wild_err_arm.rs:34:9
+   |
+LL |         Err(_e) => panic!(),
+   |         ^^^^^^^
+   |
+   = note: match each error separately or use the error output, or use `.except(msg)` if the error case is unreachable
+
+error: aborting due to 4 previous errors
+
diff --git a/tests/ui/match_wild_err_arm.edition2021.stderr b/tests/ui/match_wild_err_arm.edition2021.stderr
new file mode 100644
index 00000000000..2a4012039ba
--- /dev/null
+++ b/tests/ui/match_wild_err_arm.edition2021.stderr
@@ -0,0 +1,35 @@
+error: `Err(_)` matches all errors
+  --> $DIR/match_wild_err_arm.rs:14:9
+   |
+LL |         Err(_) => panic!("err"),
+   |         ^^^^^^
+   |
+   = note: `-D clippy::match-wild-err-arm` implied by `-D warnings`
+   = note: match each error separately or use the error output, or use `.except(msg)` if the error case is unreachable
+
+error: `Err(_)` matches all errors
+  --> $DIR/match_wild_err_arm.rs:20:9
+   |
+LL |         Err(_) => panic!(),
+   |         ^^^^^^
+   |
+   = note: match each error separately or use the error output, or use `.except(msg)` if the error case is unreachable
+
+error: `Err(_)` matches all errors
+  --> $DIR/match_wild_err_arm.rs:26:9
+   |
+LL |         Err(_) => {
+   |         ^^^^^^
+   |
+   = note: match each error separately or use the error output, or use `.except(msg)` if the error case is unreachable
+
+error: `Err(_e)` matches all errors
+  --> $DIR/match_wild_err_arm.rs:34:9
+   |
+LL |         Err(_e) => panic!(),
+   |         ^^^^^^^
+   |
+   = note: match each error separately or use the error output, or use `.except(msg)` if the error case is unreachable
+
+error: aborting due to 4 previous errors
+
diff --git a/tests/ui/match_wild_err_arm.rs b/tests/ui/match_wild_err_arm.rs
index 010cb7e0301..0a86144b95d 100644
--- a/tests/ui/match_wild_err_arm.rs
+++ b/tests/ui/match_wild_err_arm.rs
@@ -1,12 +1,13 @@
-//edition:2015
-//FIXME: The lint only triggers once on edition 2021, so I'm leaving this at 2015 for now.
-
+// revisions: edition2018 edition2021
+// [edition2018] edition:2018
+// [edition2021] edition:2021
 #![feature(exclusive_range_pattern)]
 #![allow(clippy::match_same_arms)]
 #![warn(clippy::match_wild_err_arm)]
 
 fn match_wild_err_arm() {
     let x: Result<i32, &str> = Ok(3);
+
     match x {
         Ok(3) => println!("ok"),
         Ok(_) => println!("ok"),
diff --git a/tests/ui/match_wild_err_arm.stderr b/tests/ui/match_wild_err_arm.stderr
deleted file mode 100644
index d5ec722d569..00000000000
--- a/tests/ui/match_wild_err_arm.stderr
+++ /dev/null
@@ -1,35 +0,0 @@
-error: `Err(_)` matches all errors
-  --> $DIR/match_wild_err_arm.rs:13:9
-   |
-LL |         Err(_) => panic!("err"),
-   |         ^^^^^^
-   |
-   = note: `-D clippy::match-wild-err-arm` implied by `-D warnings`
-   = note: match each error separately or use the error output, or use `.except(msg)` if the error case is unreachable
-
-error: `Err(_)` matches all errors
-  --> $DIR/match_wild_err_arm.rs:19:9
-   |
-LL |         Err(_) => panic!(),
-   |         ^^^^^^
-   |
-   = note: match each error separately or use the error output, or use `.except(msg)` if the error case is unreachable
-
-error: `Err(_)` matches all errors
-  --> $DIR/match_wild_err_arm.rs:25:9
-   |
-LL |         Err(_) => {
-   |         ^^^^^^
-   |
-   = note: match each error separately or use the error output, or use `.except(msg)` if the error case is unreachable
-
-error: `Err(_e)` matches all errors
-  --> $DIR/match_wild_err_arm.rs:33:9
-   |
-LL |         Err(_e) => panic!(),
-   |         ^^^^^^^
-   |
-   = note: match each error separately or use the error output, or use `.except(msg)` if the error case is unreachable
-
-error: aborting due to 4 previous errors
-
-- 
cgit 1.4.1-3-g733a5


From ec456de2a32dcfd6b891548a0adfd93c6c46c790 Mon Sep 17 00:00:00 2001
From: Takayuki Nakata <f.seasons017@gmail.com>
Date: Tue, 2 Nov 2021 09:09:22 +0900
Subject: Small fixes for missing backticks in doc

---
 clippy_lints/src/option_if_let_else.rs | 2 +-
 clippy_lints/src/unwrap_in_result.rs   | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/option_if_let_else.rs b/clippy_lints/src/option_if_let_else.rs
index a62eb069989..cbe1c5d44d5 100644
--- a/clippy_lints/src/option_if_let_else.rs
+++ b/clippy_lints/src/option_if_let_else.rs
@@ -22,7 +22,7 @@ declare_clippy_lint! {
     /// expression).
     ///
     /// ### Why is this bad?
-    /// Using the dedicated functions of the Option type is clearer and
+    /// Using the dedicated functions of the `Option` type is clearer and
     /// more concise than an `if let` expression.
     ///
     /// ### Known problems
diff --git a/clippy_lints/src/unwrap_in_result.rs b/clippy_lints/src/unwrap_in_result.rs
index a4680ae137b..6447e3fa2ca 100644
--- a/clippy_lints/src/unwrap_in_result.rs
+++ b/clippy_lints/src/unwrap_in_result.rs
@@ -13,7 +13,7 @@ use rustc_span::{sym, Span};
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for functions of type Result that contain `expect()` or `unwrap()`
+    /// Checks for functions of type `Result` that contain `expect()` or `unwrap()`
     ///
     /// ### Why is this bad?
     /// These functions promote recoverable errors to non-recoverable errors which may be undesirable in code bases which wish to avoid panics.
-- 
cgit 1.4.1-3-g733a5


From 3f84010688290e60465aa5eb936f45ffab454431 Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Sat, 30 Oct 2021 12:02:20 +0200
Subject: Examine lifetimes in `OpaqueDef` bounds as well

Fix #7893.
---
 clippy_lints/src/lifetimes.rs | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lifetimes.rs b/clippy_lints/src/lifetimes.rs
index e5e6f8d25cc..cb0b96e0652 100644
--- a/clippy_lints/src/lifetimes.rs
+++ b/clippy_lints/src/lifetimes.rs
@@ -378,11 +378,15 @@ impl<'a, 'tcx> Visitor<'tcx> for RefVisitor<'a, 'tcx> {
 
     fn visit_ty(&mut self, ty: &'tcx Ty<'_>) {
         match ty.kind {
-            TyKind::OpaqueDef(item, _) => {
+            TyKind::OpaqueDef(item, bounds) => {
                 let map = self.cx.tcx.hir();
                 let item = map.item(item);
                 walk_item(self, item);
                 walk_ty(self, ty);
+                self.lts.extend(bounds.iter().filter_map(|bound| match bound {
+                    GenericArg::Lifetime(l) => Some(RefLt::Named(l.name.ident().name)),
+                    _ => None,
+                }));
             },
             TyKind::BareFn(&BareFnTy { decl, .. }) => {
                 let mut sub_visitor = RefVisitor::new(self.cx);
-- 
cgit 1.4.1-3-g733a5


From 7f8198acad74c5a1596b28e51a08c2f5413840a3 Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Tue, 2 Nov 2021 14:44:21 +0100
Subject: Advise to put a :: prefix inside the ticks

---
 clippy_lints/src/doc.rs | 14 +++++++--
 tests/ui/doc/doc.rs     |  4 ++-
 tests/ui/doc/doc.stderr | 82 ++++++++++++++++++++++++++++++-------------------
 3 files changed, 64 insertions(+), 36 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/doc.rs b/clippy_lints/src/doc.rs
index ec67adf3f87..44f7ee3b89a 100644
--- a/clippy_lints/src/doc.rs
+++ b/clippy_lints/src/doc.rs
@@ -689,10 +689,18 @@ fn check_text(cx: &LateContext<'_>, valid_idents: &FxHashSet<String>, text: &str
     for word in text.split(|c: char| c.is_whitespace() || c == '\'') {
         // Trim punctuation as in `some comment (see foo::bar).`
         //                                                   ^^
-        // Or even as in `_foo bar_` which is emphasized.
-        let word = word.trim_matches(|c: char| !c.is_alphanumeric());
+        // Or even as in `_foo bar_` which is emphasized. Also preserve `::` as a prefix/suffix.
+        let mut word = word.trim_matches(|c: char| !c.is_alphanumeric() && c != ':');
 
-        if valid_idents.contains(word) {
+        // Remove leading or trailing single `:` which may be part of a sentence.
+        if word.starts_with(':') && !word.starts_with("::") {
+            word = word.trim_start_matches(':');
+        }
+        if word.ends_with(':') && !word.ends_with("::") {
+            word = word.trim_end_matches(':');
+        }
+
+        if valid_idents.contains(word) || word.chars().all(|c| c == ':') {
             continue;
         }
 
diff --git a/tests/ui/doc/doc.rs b/tests/ui/doc/doc.rs
index 342208e52b8..e40bb42bee2 100644
--- a/tests/ui/doc/doc.rs
+++ b/tests/ui/doc/doc.rs
@@ -8,7 +8,9 @@
 /// The foo_bar function does _nothing_. See also foo::bar. (note the dot there)
 /// Markdown is _weird_. I mean _really weird_. This \_ is ok. So is `_`. But not Foo::some_fun
 /// which should be reported only once despite being __doubly bad__.
-/// Here be ::a::global:path.
+/// Here be ::a::global:path, and _::another::global::path_.  :: is not a path though.
+/// Import an item from ::awesome::global::blob:: (Intended postfix)
+/// These are the options for ::Cat: (Intended trailing single colon, shouldn't be linted)
 /// That's not code ~NotInCodeBlock~.
 /// be_sure_we_got_to_the_end_of_it
 fn foo_bar() {
diff --git a/tests/ui/doc/doc.stderr b/tests/ui/doc/doc.stderr
index 7eab8a85f09..3022e0bfc75 100644
--- a/tests/ui/doc/doc.stderr
+++ b/tests/ui/doc/doc.stderr
@@ -18,173 +18,191 @@ error: you should put `Foo::some_fun` between ticks in the documentation
 LL | /// Markdown is _weird_. I mean _really weird_. This /_ is ok. So is `_`. But not Foo::some_fun
    |                                                                                   ^^^^^^^^^^^^^
 
-error: you should put `a::global:path` between ticks in the documentation
-  --> $DIR/doc.rs:11:15
+error: you should put `::a::global:path` between ticks in the documentation
+  --> $DIR/doc.rs:11:13
    |
-LL | /// Here be ::a::global:path.
-   |               ^^^^^^^^^^^^^^
+LL | /// Here be ::a::global:path, and _::another::global::path_.  :: is not a path though.
+   |             ^^^^^^^^^^^^^^^^
+
+error: you should put `::another::global::path` between ticks in the documentation
+  --> $DIR/doc.rs:11:36
+   |
+LL | /// Here be ::a::global:path, and _::another::global::path_.  :: is not a path though.
+   |                                    ^^^^^^^^^^^^^^^^^^^^^^^
+
+error: you should put `::awesome::global::blob::` between ticks in the documentation
+  --> $DIR/doc.rs:12:25
+   |
+LL | /// Import an item from ::awesome::global::blob:: (Intended postfix)
+   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: you should put `::Cat` between ticks in the documentation
+  --> $DIR/doc.rs:13:31
+   |
+LL | /// These are the options for ::Cat: (Intended trailing single colon, shouldn't be linted)
+   |                               ^^^^^
 
 error: you should put `NotInCodeBlock` between ticks in the documentation
-  --> $DIR/doc.rs:12:22
+  --> $DIR/doc.rs:14:22
    |
 LL | /// That's not code ~NotInCodeBlock~.
    |                      ^^^^^^^^^^^^^^
 
 error: you should put `be_sure_we_got_to_the_end_of_it` between ticks in the documentation
-  --> $DIR/doc.rs:13:5
+  --> $DIR/doc.rs:15:5
    |
 LL | /// be_sure_we_got_to_the_end_of_it
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: you should put `be_sure_we_got_to_the_end_of_it` between ticks in the documentation
-  --> $DIR/doc.rs:27:5
+  --> $DIR/doc.rs:29:5
    |
 LL | /// be_sure_we_got_to_the_end_of_it
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: you should put `be_sure_we_got_to_the_end_of_it` between ticks in the documentation
-  --> $DIR/doc.rs:34:5
+  --> $DIR/doc.rs:36:5
    |
 LL | /// be_sure_we_got_to_the_end_of_it
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: you should put `be_sure_we_got_to_the_end_of_it` between ticks in the documentation
-  --> $DIR/doc.rs:48:5
+  --> $DIR/doc.rs:50:5
    |
 LL | /// be_sure_we_got_to_the_end_of_it
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: you should put `be_sure_we_got_to_the_end_of_it` between ticks in the documentation
-  --> $DIR/doc.rs:71:5
+  --> $DIR/doc.rs:73:5
    |
 LL | /// be_sure_we_got_to_the_end_of_it
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: you should put `link_with_underscores` between ticks in the documentation
-  --> $DIR/doc.rs:75:22
+  --> $DIR/doc.rs:77:22
    |
 LL | /// This test has [a link_with_underscores][chunked-example] inside it. See #823.
    |                      ^^^^^^^^^^^^^^^^^^^^^
 
 error: you should put `inline_link2` between ticks in the documentation
-  --> $DIR/doc.rs:78:21
+  --> $DIR/doc.rs:80:21
    |
 LL | /// It can also be [inline_link2].
    |                     ^^^^^^^^^^^^
 
 error: you should put `be_sure_we_got_to_the_end_of_it` between ticks in the documentation
-  --> $DIR/doc.rs:88:5
+  --> $DIR/doc.rs:90:5
    |
 LL | /// be_sure_we_got_to_the_end_of_it
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: you should put `CamelCaseThing` between ticks in the documentation
-  --> $DIR/doc.rs:96:8
+  --> $DIR/doc.rs:98:8
    |
 LL | /// ## CamelCaseThing
    |        ^^^^^^^^^^^^^^
 
 error: you should put `CamelCaseThing` between ticks in the documentation
-  --> $DIR/doc.rs:99:7
+  --> $DIR/doc.rs:101:7
    |
 LL | /// # CamelCaseThing
    |       ^^^^^^^^^^^^^^
 
 error: you should put `CamelCaseThing` between ticks in the documentation
-  --> $DIR/doc.rs:101:22
+  --> $DIR/doc.rs:103:22
    |
 LL | /// Not a title #897 CamelCaseThing
    |                      ^^^^^^^^^^^^^^
 
 error: you should put `be_sure_we_got_to_the_end_of_it` between ticks in the documentation
-  --> $DIR/doc.rs:102:5
+  --> $DIR/doc.rs:104:5
    |
 LL | /// be_sure_we_got_to_the_end_of_it
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: you should put `be_sure_we_got_to_the_end_of_it` between ticks in the documentation
-  --> $DIR/doc.rs:109:5
+  --> $DIR/doc.rs:111:5
    |
 LL | /// be_sure_we_got_to_the_end_of_it
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: you should put `be_sure_we_got_to_the_end_of_it` between ticks in the documentation
-  --> $DIR/doc.rs:122:5
+  --> $DIR/doc.rs:124:5
    |
 LL | /// be_sure_we_got_to_the_end_of_it
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: you should put `FooBar` between ticks in the documentation
-  --> $DIR/doc.rs:133:43
+  --> $DIR/doc.rs:135:43
    |
 LL | /** E.g., serialization of an empty list: FooBar
    |                                           ^^^^^^
 
 error: you should put `BarQuz` between ticks in the documentation
-  --> $DIR/doc.rs:138:5
+  --> $DIR/doc.rs:140:5
    |
 LL | And BarQuz too.
    |     ^^^^^^
 
 error: you should put `be_sure_we_got_to_the_end_of_it` between ticks in the documentation
-  --> $DIR/doc.rs:139:1
+  --> $DIR/doc.rs:141:1
    |
 LL | be_sure_we_got_to_the_end_of_it
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: you should put `FooBar` between ticks in the documentation
-  --> $DIR/doc.rs:144:43
+  --> $DIR/doc.rs:146:43
    |
 LL | /** E.g., serialization of an empty list: FooBar
    |                                           ^^^^^^
 
 error: you should put `BarQuz` between ticks in the documentation
-  --> $DIR/doc.rs:149:5
+  --> $DIR/doc.rs:151:5
    |
 LL | And BarQuz too.
    |     ^^^^^^
 
 error: you should put `be_sure_we_got_to_the_end_of_it` between ticks in the documentation
-  --> $DIR/doc.rs:150:1
+  --> $DIR/doc.rs:152:1
    |
 LL | be_sure_we_got_to_the_end_of_it
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: you should put `be_sure_we_got_to_the_end_of_it` between ticks in the documentation
-  --> $DIR/doc.rs:161:5
+  --> $DIR/doc.rs:163:5
    |
 LL | /// be_sure_we_got_to_the_end_of_it
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: you should put bare URLs between `<`/`>` or make a proper Markdown link
-  --> $DIR/doc.rs:188:13
+  --> $DIR/doc.rs:190:13
    |
 LL | /// Not ok: http://www.unicode.org
    |             ^^^^^^^^^^^^^^^^^^^^^^
 
 error: you should put bare URLs between `<`/`>` or make a proper Markdown link
-  --> $DIR/doc.rs:189:13
+  --> $DIR/doc.rs:191:13
    |
 LL | /// Not ok: https://www.unicode.org
    |             ^^^^^^^^^^^^^^^^^^^^^^^
 
 error: you should put bare URLs between `<`/`>` or make a proper Markdown link
-  --> $DIR/doc.rs:190:13
+  --> $DIR/doc.rs:192:13
    |
 LL | /// Not ok: http://www.unicode.org/
    |             ^^^^^^^^^^^^^^^^^^^^^^
 
 error: you should put bare URLs between `<`/`>` or make a proper Markdown link
-  --> $DIR/doc.rs:191:13
+  --> $DIR/doc.rs:193:13
    |
 LL | /// Not ok: http://www.unicode.org/reports/tr9/#Reordering_Resolved_Levels
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: you should put `mycrate::Collection` between ticks in the documentation
-  --> $DIR/doc.rs:194:22
+  --> $DIR/doc.rs:196:22
    |
 LL | /// An iterator over mycrate::Collection's values.
    |                      ^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 31 previous errors
+error: aborting due to 34 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 0db8c52291ee515b086d8826ac9beec3668aeb68 Mon Sep 17 00:00:00 2001
From: Serial <69764315+Serial-ATA@users.noreply.github.com>
Date: Sat, 30 Oct 2021 20:11:06 -0400
Subject: Add suggestion to missing backticks error

---
 clippy_lints/src/doc.rs              |  25 ++--
 tests/ui/doc/doc.fixed               | 215 +++++++++++++++++++++++++++++++++++
 tests/ui/doc/doc.rs                  |  15 +--
 tests/ui/doc/doc.stderr              | 206 +++++++++++++++------------------
 tests/ui/doc/issue_1832.rs           |   9 ++
 tests/ui/doc/issue_902.rs            |   7 ++
 tests/ui/doc/unbalanced_ticks.stderr |  12 +-
 7 files changed, 344 insertions(+), 145 deletions(-)
 create mode 100644 tests/ui/doc/doc.fixed
 create mode 100644 tests/ui/doc/issue_1832.rs
 create mode 100644 tests/ui/doc/issue_902.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/doc.rs b/clippy_lints/src/doc.rs
index 44f7ee3b89a..87ad5178ff0 100644
--- a/clippy_lints/src/doc.rs
+++ b/clippy_lints/src/doc.rs
@@ -1,6 +1,6 @@
 use clippy_utils::attrs::is_doc_hidden;
-use clippy_utils::diagnostics::{span_lint, span_lint_and_help, span_lint_and_note};
-use clippy_utils::source::first_line_of_span;
+use clippy_utils::diagnostics::{span_lint, span_lint_and_help, span_lint_and_note, span_lint_and_sugg};
+use clippy_utils::source::{first_line_of_span, snippet_with_applicability};
 use clippy_utils::ty::{implements_trait, is_type_diagnostic_item};
 use clippy_utils::{is_entrypoint_fn, is_expn_of, match_panic_def_id, method_chain_args, return_ty};
 use if_chain::if_chain;
@@ -10,7 +10,7 @@ use rustc_ast::token::CommentKind;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_data_structures::sync::Lrc;
 use rustc_errors::emitter::EmitterWriter;
-use rustc_errors::Handler;
+use rustc_errors::{Applicability, Handler};
 use rustc_hir as hir;
 use rustc_hir::intravisit::{self, NestedVisitorMap, Visitor};
 use rustc_hir::{AnonConst, Expr, ExprKind, QPath};
@@ -48,7 +48,7 @@ declare_clippy_lint! {
     /// content are not linted.
     ///
     /// In addition, when writing documentation comments, including `[]` brackets
-    /// inside a link text would trip the parser. Therfore, documenting link with
+    /// inside a link text would trip the parser. Therefore, documenting link with
     /// `[`SmallVec<[T; INLINE_CAPACITY]>`]` and then [`SmallVec<[T; INLINE_CAPACITY]>`]: SmallVec
     /// would fail.
     ///
@@ -755,17 +755,22 @@ fn check_word(cx: &LateContext<'_>, word: &str, span: Span) {
         }
     }
 
-    // We assume that mixed-case words are not meant to be put inside bacticks. (Issue #2343)
+    // We assume that mixed-case words are not meant to be put inside backticks. (Issue #2343)
     if has_underscore(word) && has_hyphen(word) {
         return;
     }
 
     if has_underscore(word) || word.contains("::") || is_camel_case(word) {
-        span_lint(
+        let mut applicability = Applicability::MachineApplicable;
+
+        span_lint_and_sugg(
             cx,
             DOC_MARKDOWN,
             span,
-            &format!("you should put `{}` between ticks in the documentation", word),
+            "item in documentation is missing backticks",
+            "try",
+            format!("`{}`", snippet_with_applicability(cx, span, "..", &mut applicability)),
+            applicability,
         );
     }
 }
@@ -804,9 +809,9 @@ impl<'a, 'tcx> Visitor<'tcx> for FindPanicUnwrap<'a, 'tcx> {
 
         // check for `unwrap`
         if let Some(arglists) = method_chain_args(expr, &["unwrap"]) {
-            let reciever_ty = self.typeck_results.expr_ty(&arglists[0][0]).peel_refs();
-            if is_type_diagnostic_item(self.cx, reciever_ty, sym::Option)
-                || is_type_diagnostic_item(self.cx, reciever_ty, sym::Result)
+            let receiver_ty = self.typeck_results.expr_ty(&arglists[0][0]).peel_refs();
+            if is_type_diagnostic_item(self.cx, receiver_ty, sym::Option)
+                || is_type_diagnostic_item(self.cx, receiver_ty, sym::Result)
             {
                 self.panic_span = Some(expr.span);
             }
diff --git a/tests/ui/doc/doc.fixed b/tests/ui/doc/doc.fixed
new file mode 100644
index 00000000000..747801b40ee
--- /dev/null
+++ b/tests/ui/doc/doc.fixed
@@ -0,0 +1,215 @@
+// run-rustfix
+//! This file tests for the `DOC_MARKDOWN` lint.
+
+#![allow(dead_code, incomplete_features)]
+#![warn(clippy::doc_markdown)]
+#![feature(custom_inner_attributes, generic_const_exprs, const_option)]
+#![rustfmt::skip]
+
+/// The `foo_bar` function does _nothing_. See also `foo::bar`. (note the dot there)
+/// Markdown is _weird_. I mean _really weird_. This \_ is ok. So is `_`. But not `Foo::some_fun`
+/// which should be reported only once despite being __doubly bad__.
+/// Here be `::a::global:path`, and _`::another::global::path`_.  :: is not a path though.
+/// Import an item from `::awesome::global::blob::` (Intended postfix)
+/// These are the options for `::Cat`: (Intended trailing single colon, shouldn't be linted)
+/// That's not code ~`NotInCodeBlock`~.
+/// `be_sure_we_got_to_the_end_of_it`
+fn foo_bar() {
+}
+
+/// That one tests multiline ticks.
+/// ```rust
+/// foo_bar FOO_BAR
+/// _foo bar_
+/// ```
+///
+/// ~~~rust
+/// foo_bar FOO_BAR
+/// _foo bar_
+/// ~~~
+/// `be_sure_we_got_to_the_end_of_it`
+fn multiline_codeblock() {
+}
+
+/// This _is a test for
+/// multiline
+/// emphasis_.
+/// `be_sure_we_got_to_the_end_of_it`
+fn test_emphasis() {
+}
+
+/// This tests units. See also #835.
+/// kiB MiB GiB TiB PiB EiB
+/// kib Mib Gib Tib Pib Eib
+/// kB MB GB TB PB EB
+/// kb Mb Gb Tb Pb Eb
+/// 32kiB 32MiB 32GiB 32TiB 32PiB 32EiB
+/// 32kib 32Mib 32Gib 32Tib 32Pib 32Eib
+/// 32kB 32MB 32GB 32TB 32PB 32EB
+/// 32kb 32Mb 32Gb 32Tb 32Pb 32Eb
+/// NaN
+/// `be_sure_we_got_to_the_end_of_it`
+fn test_units() {
+}
+
+/// This tests allowed identifiers.
+/// KiB MiB GiB TiB PiB EiB
+/// DirectX
+/// ECMAScript
+/// GPLv2 GPLv3
+/// GitHub GitLab
+/// IPv4 IPv6
+/// ClojureScript CoffeeScript JavaScript PureScript TypeScript
+/// NaN NaNs
+/// OAuth GraphQL
+/// OCaml
+/// OpenGL OpenMP OpenSSH OpenSSL OpenStreetMap OpenDNS
+/// WebGL
+/// TensorFlow
+/// TrueType
+/// iOS macOS FreeBSD
+/// TeX LaTeX BibTeX BibLaTeX
+/// MinGW
+/// CamelCase (see also #2395)
+/// `be_sure_we_got_to_the_end_of_it`
+fn test_allowed() {
+}
+
+/// This test has [a `link_with_underscores`][chunked-example] inside it. See #823.
+/// See also [the issue tracker](https://github.com/rust-lang/rust-clippy/search?q=clippy::doc_markdown&type=Issues)
+/// on GitHub (which is a camel-cased word, but is OK). And here is another [inline link][inline_link].
+/// It can also be [`inline_link2`].
+///
+/// [chunked-example]: https://en.wikipedia.org/wiki/Chunked_transfer_encoding#Example
+/// [inline_link]: https://foobar
+/// [inline_link2]: https://foobar
+/// The `main` function is the entry point of the program. Here it only calls the `foo_bar` and
+/// `multiline_ticks` functions.
+///
+/// expression of the type  `_ <bit_op> m <cmp_op> c` (where `<bit_op>`
+/// is one of {`&`, '|'} and `<cmp_op>` is one of {`!=`, `>=`, `>` ,
+/// `be_sure_we_got_to_the_end_of_it`
+fn main() {
+    foo_bar();
+    multiline_codeblock();
+    test_emphasis();
+    test_units();
+}
+
+/// ## `CamelCaseThing`
+/// Talks about `CamelCaseThing`. Titles should be ignored; see issue #897.
+///
+/// # `CamelCaseThing`
+///
+/// Not a title #897 `CamelCaseThing`
+/// `be_sure_we_got_to_the_end_of_it`
+fn issue897() {
+}
+
+/// I am confused by brackets? (`x_y`)
+/// I am confused by brackets? (foo `x_y`)
+/// I am confused by brackets? (`x_y` foo)
+/// `be_sure_we_got_to_the_end_of_it`
+fn issue900() {
+}
+
+/// Diesel queries also have a similar problem to [Iterator][iterator], where
+/// /// More talking
+/// returning them from a function requires exposing the implementation of that
+/// function. The [`helper_types`][helper_types] module exists to help with this,
+/// but you might want to hide the return type or have it conditionally change.
+/// Boxing can achieve both.
+///
+/// [iterator]: https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html
+/// [helper_types]: ../helper_types/index.html
+/// `be_sure_we_got_to_the_end_of_it`
+fn issue883() {
+}
+
+/// `foo_bar
+/// baz_quz`
+/// [foo
+/// bar](https://doc.rust-lang.org/stable/std/iter/trait.IteratorFooBar.html)
+fn multiline() {
+}
+
+/** E.g., serialization of an empty list: `FooBar`
+```
+That's in a code block: `PackedNode`
+```
+
+And `BarQuz` too.
+`be_sure_we_got_to_the_end_of_it`
+*/
+fn issue1073() {
+}
+
+/** E.g., serialization of an empty list: `FooBar`
+```
+That's in a code block: PackedNode
+```
+
+And `BarQuz` too.
+`be_sure_we_got_to_the_end_of_it`
+*/
+fn issue1073_alt() {
+}
+
+/// Tests more than three quotes:
+/// ````
+/// DoNotWarn
+/// ```
+/// StillDont
+/// ````
+/// `be_sure_we_got_to_the_end_of_it`
+fn four_quotes() {
+}
+
+#[cfg_attr(feature = "a", doc = " ```")]
+#[cfg_attr(not(feature = "a"), doc = " ```ignore")]
+/// fn main() {
+///     let s = "localhost:10000".to_string();
+///     println!("{}", s);
+/// }
+/// ```
+fn issue_1469() {}
+
+/**
+ * This is a doc comment that should not be a list
+ *This would also be an error under a strict common mark interpretation
+ */
+fn issue_1920() {}
+
+/// An iterator over `mycrate::Collection`'s values.
+/// It should not lint a `'static` lifetime in ticks.
+fn issue_2210() {}
+
+/// This should not cause the lint to trigger:
+/// #REQ-data-family.lint_partof_exists
+fn issue_2343() {}
+
+/// This should not cause an ICE:
+/// __|_ _|__||_|
+fn pulldown_cmark_crash() {}
+
+/// This should not lint
+/// (regression test for #7758)
+/// [plain text][path::to::item]
+fn intra_doc_link() {}
+
+// issue #7033 - generic_const_exprs ICE
+struct S<T, const N: usize>
+where [(); N.checked_next_power_of_two().unwrap()]: {
+    arr: [T; N.checked_next_power_of_two().unwrap()],
+    n: usize,
+}
+
+impl<T: Copy + Default, const N: usize> S<T, N>
+where [(); N.checked_next_power_of_two().unwrap()]: {
+    fn new() -> Self {
+        Self {
+            arr: [T::default(); N.checked_next_power_of_two().unwrap()],
+            n: 0,
+        }
+    }
+}
diff --git a/tests/ui/doc/doc.rs b/tests/ui/doc/doc.rs
index e40bb42bee2..f3cf966157a 100644
--- a/tests/ui/doc/doc.rs
+++ b/tests/ui/doc/doc.rs
@@ -1,3 +1,4 @@
+// run-rustfix
 //! This file tests for the `DOC_MARKDOWN` lint.
 
 #![allow(dead_code, incomplete_features)]
@@ -164,12 +165,6 @@ fn issue1073_alt() {
 fn four_quotes() {
 }
 
-/// See [NIST SP 800-56A, revision 2].
-///
-/// [NIST SP 800-56A, revision 2]:
-///     https://github.com/rust-lang/rust-clippy/issues/902#issuecomment-261919419
-fn issue_902_comment() {}
-
 #[cfg_attr(feature = "a", doc = " ```")]
 #[cfg_attr(not(feature = "a"), doc = " ```ignore")]
 /// fn main() {
@@ -185,14 +180,6 @@ fn issue_1469() {}
  */
 fn issue_1920() {}
 
-/// Ok: <http://www.unicode.org/reports/tr9/#Reordering_Resolved_Levels>
-///
-/// Not ok: http://www.unicode.org
-/// Not ok: https://www.unicode.org
-/// Not ok: http://www.unicode.org/
-/// Not ok: http://www.unicode.org/reports/tr9/#Reordering_Resolved_Levels
-fn issue_1832() {}
-
 /// An iterator over mycrate::Collection's values.
 /// It should not lint a `'static` lifetime in ticks.
 fn issue_2210() {}
diff --git a/tests/ui/doc/doc.stderr b/tests/ui/doc/doc.stderr
index 3022e0bfc75..8a9e1d70a16 100644
--- a/tests/ui/doc/doc.stderr
+++ b/tests/ui/doc/doc.stderr
@@ -1,208 +1,184 @@
-error: you should put `foo_bar` between ticks in the documentation
-  --> $DIR/doc.rs:8:9
+error: item in documentation is missing backticks
+  --> $DIR/doc.rs:9:9
    |
 LL | /// The foo_bar function does _nothing_. See also foo::bar. (note the dot there)
-   |         ^^^^^^^
+   |         ^^^^^^^ help: try: ``foo_bar``
    |
    = note: `-D clippy::doc-markdown` implied by `-D warnings`
 
-error: you should put `foo::bar` between ticks in the documentation
-  --> $DIR/doc.rs:8:51
+error: item in documentation is missing backticks
+  --> $DIR/doc.rs:9:51
    |
 LL | /// The foo_bar function does _nothing_. See also foo::bar. (note the dot there)
-   |                                                   ^^^^^^^^
+   |                                                   ^^^^^^^^ help: try: ``foo::bar``
 
-error: you should put `Foo::some_fun` between ticks in the documentation
-  --> $DIR/doc.rs:9:83
+error: item in documentation is missing backticks
+  --> $DIR/doc.rs:10:83
    |
 LL | /// Markdown is _weird_. I mean _really weird_. This /_ is ok. So is `_`. But not Foo::some_fun
-   |                                                                                   ^^^^^^^^^^^^^
+   |                                                                                   ^^^^^^^^^^^^^ help: try: ``Foo::some_fun``
 
-error: you should put `::a::global:path` between ticks in the documentation
-  --> $DIR/doc.rs:11:13
+error: item in documentation is missing backticks
+  --> $DIR/doc.rs:12:13
    |
 LL | /// Here be ::a::global:path, and _::another::global::path_.  :: is not a path though.
-   |             ^^^^^^^^^^^^^^^^
+   |             ^^^^^^^^^^^^^^^^ help: try: ``::a::global:path``
 
-error: you should put `::another::global::path` between ticks in the documentation
-  --> $DIR/doc.rs:11:36
+error: item in documentation is missing backticks
+  --> $DIR/doc.rs:12:36
    |
 LL | /// Here be ::a::global:path, and _::another::global::path_.  :: is not a path though.
-   |                                    ^^^^^^^^^^^^^^^^^^^^^^^
+   |                                    ^^^^^^^^^^^^^^^^^^^^^^^ help: try: ``::another::global::path``
 
-error: you should put `::awesome::global::blob::` between ticks in the documentation
-  --> $DIR/doc.rs:12:25
+error: item in documentation is missing backticks
+  --> $DIR/doc.rs:13:25
    |
 LL | /// Import an item from ::awesome::global::blob:: (Intended postfix)
-   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: ``::awesome::global::blob::``
 
-error: you should put `::Cat` between ticks in the documentation
-  --> $DIR/doc.rs:13:31
+error: item in documentation is missing backticks
+  --> $DIR/doc.rs:14:31
    |
 LL | /// These are the options for ::Cat: (Intended trailing single colon, shouldn't be linted)
-   |                               ^^^^^
+   |                               ^^^^^ help: try: ``::Cat``
 
-error: you should put `NotInCodeBlock` between ticks in the documentation
-  --> $DIR/doc.rs:14:22
+error: item in documentation is missing backticks
+  --> $DIR/doc.rs:15:22
    |
 LL | /// That's not code ~NotInCodeBlock~.
-   |                      ^^^^^^^^^^^^^^
+   |                      ^^^^^^^^^^^^^^ help: try: ``NotInCodeBlock``
 
-error: you should put `be_sure_we_got_to_the_end_of_it` between ticks in the documentation
-  --> $DIR/doc.rs:15:5
+error: item in documentation is missing backticks
+  --> $DIR/doc.rs:16:5
    |
 LL | /// be_sure_we_got_to_the_end_of_it
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: ``be_sure_we_got_to_the_end_of_it``
 
-error: you should put `be_sure_we_got_to_the_end_of_it` between ticks in the documentation
-  --> $DIR/doc.rs:29:5
+error: item in documentation is missing backticks
+  --> $DIR/doc.rs:30:5
    |
 LL | /// be_sure_we_got_to_the_end_of_it
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: ``be_sure_we_got_to_the_end_of_it``
 
-error: you should put `be_sure_we_got_to_the_end_of_it` between ticks in the documentation
-  --> $DIR/doc.rs:36:5
+error: item in documentation is missing backticks
+  --> $DIR/doc.rs:37:5
    |
 LL | /// be_sure_we_got_to_the_end_of_it
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: ``be_sure_we_got_to_the_end_of_it``
 
-error: you should put `be_sure_we_got_to_the_end_of_it` between ticks in the documentation
-  --> $DIR/doc.rs:50:5
+error: item in documentation is missing backticks
+  --> $DIR/doc.rs:51:5
    |
 LL | /// be_sure_we_got_to_the_end_of_it
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: ``be_sure_we_got_to_the_end_of_it``
 
-error: you should put `be_sure_we_got_to_the_end_of_it` between ticks in the documentation
-  --> $DIR/doc.rs:73:5
+error: item in documentation is missing backticks
+  --> $DIR/doc.rs:74:5
    |
 LL | /// be_sure_we_got_to_the_end_of_it
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: ``be_sure_we_got_to_the_end_of_it``
 
-error: you should put `link_with_underscores` between ticks in the documentation
-  --> $DIR/doc.rs:77:22
+error: item in documentation is missing backticks
+  --> $DIR/doc.rs:78:22
    |
 LL | /// This test has [a link_with_underscores][chunked-example] inside it. See #823.
-   |                      ^^^^^^^^^^^^^^^^^^^^^
+   |                      ^^^^^^^^^^^^^^^^^^^^^ help: try: ``link_with_underscores``
 
-error: you should put `inline_link2` between ticks in the documentation
-  --> $DIR/doc.rs:80:21
+error: item in documentation is missing backticks
+  --> $DIR/doc.rs:81:21
    |
 LL | /// It can also be [inline_link2].
-   |                     ^^^^^^^^^^^^
+   |                     ^^^^^^^^^^^^ help: try: ``inline_link2``
 
-error: you should put `be_sure_we_got_to_the_end_of_it` between ticks in the documentation
-  --> $DIR/doc.rs:90:5
+error: item in documentation is missing backticks
+  --> $DIR/doc.rs:91:5
    |
 LL | /// be_sure_we_got_to_the_end_of_it
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: ``be_sure_we_got_to_the_end_of_it``
 
-error: you should put `CamelCaseThing` between ticks in the documentation
-  --> $DIR/doc.rs:98:8
+error: item in documentation is missing backticks
+  --> $DIR/doc.rs:99:8
    |
 LL | /// ## CamelCaseThing
-   |        ^^^^^^^^^^^^^^
+   |        ^^^^^^^^^^^^^^ help: try: ``CamelCaseThing``
 
-error: you should put `CamelCaseThing` between ticks in the documentation
-  --> $DIR/doc.rs:101:7
+error: item in documentation is missing backticks
+  --> $DIR/doc.rs:102:7
    |
 LL | /// # CamelCaseThing
-   |       ^^^^^^^^^^^^^^
+   |       ^^^^^^^^^^^^^^ help: try: ``CamelCaseThing``
 
-error: you should put `CamelCaseThing` between ticks in the documentation
-  --> $DIR/doc.rs:103:22
+error: item in documentation is missing backticks
+  --> $DIR/doc.rs:104:22
    |
 LL | /// Not a title #897 CamelCaseThing
-   |                      ^^^^^^^^^^^^^^
+   |                      ^^^^^^^^^^^^^^ help: try: ``CamelCaseThing``
 
-error: you should put `be_sure_we_got_to_the_end_of_it` between ticks in the documentation
-  --> $DIR/doc.rs:104:5
+error: item in documentation is missing backticks
+  --> $DIR/doc.rs:105:5
    |
 LL | /// be_sure_we_got_to_the_end_of_it
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: ``be_sure_we_got_to_the_end_of_it``
 
-error: you should put `be_sure_we_got_to_the_end_of_it` between ticks in the documentation
-  --> $DIR/doc.rs:111:5
+error: item in documentation is missing backticks
+  --> $DIR/doc.rs:112:5
    |
 LL | /// be_sure_we_got_to_the_end_of_it
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: ``be_sure_we_got_to_the_end_of_it``
 
-error: you should put `be_sure_we_got_to_the_end_of_it` between ticks in the documentation
-  --> $DIR/doc.rs:124:5
+error: item in documentation is missing backticks
+  --> $DIR/doc.rs:125:5
    |
 LL | /// be_sure_we_got_to_the_end_of_it
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: ``be_sure_we_got_to_the_end_of_it``
 
-error: you should put `FooBar` between ticks in the documentation
-  --> $DIR/doc.rs:135:43
+error: item in documentation is missing backticks
+  --> $DIR/doc.rs:136:43
    |
 LL | /** E.g., serialization of an empty list: FooBar
-   |                                           ^^^^^^
+   |                                           ^^^^^^ help: try: ``FooBar``
 
-error: you should put `BarQuz` between ticks in the documentation
-  --> $DIR/doc.rs:140:5
+error: item in documentation is missing backticks
+  --> $DIR/doc.rs:141:5
    |
 LL | And BarQuz too.
-   |     ^^^^^^
+   |     ^^^^^^ help: try: ``BarQuz``
 
-error: you should put `be_sure_we_got_to_the_end_of_it` between ticks in the documentation
-  --> $DIR/doc.rs:141:1
+error: item in documentation is missing backticks
+  --> $DIR/doc.rs:142:1
    |
 LL | be_sure_we_got_to_the_end_of_it
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: ``be_sure_we_got_to_the_end_of_it``
 
-error: you should put `FooBar` between ticks in the documentation
-  --> $DIR/doc.rs:146:43
+error: item in documentation is missing backticks
+  --> $DIR/doc.rs:147:43
    |
 LL | /** E.g., serialization of an empty list: FooBar
-   |                                           ^^^^^^
+   |                                           ^^^^^^ help: try: ``FooBar``
 
-error: you should put `BarQuz` between ticks in the documentation
-  --> $DIR/doc.rs:151:5
+error: item in documentation is missing backticks
+  --> $DIR/doc.rs:152:5
    |
 LL | And BarQuz too.
-   |     ^^^^^^
+   |     ^^^^^^ help: try: ``BarQuz``
 
-error: you should put `be_sure_we_got_to_the_end_of_it` between ticks in the documentation
-  --> $DIR/doc.rs:152:1
+error: item in documentation is missing backticks
+  --> $DIR/doc.rs:153:1
    |
 LL | be_sure_we_got_to_the_end_of_it
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: ``be_sure_we_got_to_the_end_of_it``
 
-error: you should put `be_sure_we_got_to_the_end_of_it` between ticks in the documentation
-  --> $DIR/doc.rs:163:5
+error: item in documentation is missing backticks
+  --> $DIR/doc.rs:164:5
    |
 LL | /// be_sure_we_got_to_the_end_of_it
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: ``be_sure_we_got_to_the_end_of_it``
 
-error: you should put bare URLs between `<`/`>` or make a proper Markdown link
-  --> $DIR/doc.rs:190:13
-   |
-LL | /// Not ok: http://www.unicode.org
-   |             ^^^^^^^^^^^^^^^^^^^^^^
-
-error: you should put bare URLs between `<`/`>` or make a proper Markdown link
-  --> $DIR/doc.rs:191:13
-   |
-LL | /// Not ok: https://www.unicode.org
-   |             ^^^^^^^^^^^^^^^^^^^^^^^
-
-error: you should put bare URLs between `<`/`>` or make a proper Markdown link
-  --> $DIR/doc.rs:192:13
-   |
-LL | /// Not ok: http://www.unicode.org/
-   |             ^^^^^^^^^^^^^^^^^^^^^^
-
-error: you should put bare URLs between `<`/`>` or make a proper Markdown link
-  --> $DIR/doc.rs:193:13
-   |
-LL | /// Not ok: http://www.unicode.org/reports/tr9/#Reordering_Resolved_Levels
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: you should put `mycrate::Collection` between ticks in the documentation
-  --> $DIR/doc.rs:196:22
+error: item in documentation is missing backticks
+  --> $DIR/doc.rs:183:22
    |
 LL | /// An iterator over mycrate::Collection's values.
-   |                      ^^^^^^^^^^^^^^^^^^^
+   |                      ^^^^^^^^^^^^^^^^^^^ help: try: ``mycrate::Collection``
 
-error: aborting due to 34 previous errors
+error: aborting due to 30 previous errors
 
diff --git a/tests/ui/doc/issue_1832.rs b/tests/ui/doc/issue_1832.rs
new file mode 100644
index 00000000000..10586f16d46
--- /dev/null
+++ b/tests/ui/doc/issue_1832.rs
@@ -0,0 +1,9 @@
+/// Ok: <http://www.unicode.org/reports/tr9/#Reordering_Resolved_Levels>
+///
+/// Not ok: http://www.unicode.org
+/// Not ok: https://www.unicode.org
+/// Not ok: http://www.unicode.org/
+/// Not ok: http://www.unicode.org/reports/tr9/#Reordering_Resolved_Levels
+fn issue_1832() {}
+
+fn main() {}
diff --git a/tests/ui/doc/issue_902.rs b/tests/ui/doc/issue_902.rs
new file mode 100644
index 00000000000..4b0c835dd3f
--- /dev/null
+++ b/tests/ui/doc/issue_902.rs
@@ -0,0 +1,7 @@
+/// See [NIST SP 800-56A, revision 2].
+///
+/// [NIST SP 800-56A, revision 2]:
+///     https://github.com/rust-lang/rust-clippy/issues/902#issuecomment-261919419
+fn issue_902_comment() {}
+
+fn main() {}
diff --git a/tests/ui/doc/unbalanced_ticks.stderr b/tests/ui/doc/unbalanced_ticks.stderr
index 45ca34e2a8c..9670e5c24fb 100644
--- a/tests/ui/doc/unbalanced_ticks.stderr
+++ b/tests/ui/doc/unbalanced_ticks.stderr
@@ -18,11 +18,11 @@ LL | /// This paragraph has `unbalanced_tick marks and should stop_linting.
    |
    = help: a backtick may be missing a pair
 
-error: you should put `should_be` between ticks in the documentation
+error: item in documentation is missing backticks
   --> $DIR/unbalanced_ticks.rs:15:32
    |
 LL | /// This paragraph is fine and should_be linted normally.
-   |                                ^^^^^^^^^
+   |                                ^^^^^^^^^ help: try: ``should_be``
 
 error: backticks are unbalanced
   --> $DIR/unbalanced_ticks.rs:17:1
@@ -32,11 +32,11 @@ LL | /// Double unbalanced backtick from ``here to here` should lint.
    |
    = help: a backtick may be missing a pair
 
-error: you should put `not_fine` between ticks in the documentation
+error: item in documentation is missing backticks
   --> $DIR/unbalanced_ticks.rs:30:8
    |
 LL | /// ## not_fine
-   |        ^^^^^^^^
+   |        ^^^^^^^^ help: try: ``not_fine``
 
 error: backticks are unbalanced
   --> $DIR/unbalanced_ticks.rs:32:1
@@ -54,11 +54,11 @@ LL | /// - This `item has unbalanced tick marks
    |
    = help: a backtick may be missing a pair
 
-error: you should put `backticks_here` between ticks in the documentation
+error: item in documentation is missing backticks
   --> $DIR/unbalanced_ticks.rs:35:23
    |
 LL | /// - This item needs backticks_here
-   |                       ^^^^^^^^^^^^^^
+   |                       ^^^^^^^^^^^^^^ help: try: ``backticks_here``
 
 error: aborting due to 8 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 93ffc9d233f24894c7372b8097a3295dd7b7afee Mon Sep 17 00:00:00 2001
From: flip1995 <philipp.krones@embecosm.com>
Date: Fri, 5 Nov 2021 10:54:37 +0000
Subject: Remove rustfmt::skip attribute from register_plugins function

---
 clippy_lints/src/lib.rs | 92 +++++++++++++++++++++++++++++++++++++------------
 1 file changed, 70 insertions(+), 22 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 7174d0a082e..bc302046b2d 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -441,7 +441,6 @@ pub fn read_conf(sess: &Session) -> Conf {
 ///
 /// Used in `./src/driver.rs`.
 #[allow(clippy::too_many_lines)]
-#[rustfmt::skip]
 pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf: &Conf) {
     register_removed_non_tool_lints(store);
 
@@ -493,11 +492,13 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     let vec_box_size_threshold = conf.vec_box_size_threshold;
     let type_complexity_threshold = conf.type_complexity_threshold;
     let avoid_breaking_exported_api = conf.avoid_breaking_exported_api;
-    store.register_late_pass(move || Box::new(types::Types::new(
-        vec_box_size_threshold,
-        type_complexity_threshold,
-        avoid_breaking_exported_api,
-    )));
+    store.register_late_pass(move || {
+        Box::new(types::Types::new(
+            vec_box_size_threshold,
+            type_complexity_threshold,
+            avoid_breaking_exported_api,
+        ))
+    });
     store.register_late_pass(|| Box::new(booleans::NonminimalBool));
     store.register_late_pass(|| Box::new(needless_bitwise_bool::NeedlessBitwiseBool));
     store.register_late_pass(|| Box::new(eq_op::EqOp));
@@ -535,7 +536,10 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
 
     let msrv = conf.msrv.as_ref().and_then(|s| {
         parse_msrv(s, None, None).or_else(|| {
-            sess.err(&format!("error reading Clippy's configuration file. `{}` is not a valid Rust version", s));
+            sess.err(&format!(
+                "error reading Clippy's configuration file. `{}` is not a valid Rust version",
+                s
+            ));
             None
         })
     });
@@ -579,10 +583,14 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(temporary_assignment::TemporaryAssignment));
     store.register_late_pass(|| Box::new(transmute::Transmute));
     let cognitive_complexity_threshold = conf.cognitive_complexity_threshold;
-    store.register_late_pass(move || Box::new(cognitive_complexity::CognitiveComplexity::new(cognitive_complexity_threshold)));
+    store.register_late_pass(move || {
+        Box::new(cognitive_complexity::CognitiveComplexity::new(
+            cognitive_complexity_threshold,
+        ))
+    });
     let too_large_for_stack = conf.too_large_for_stack;
-    store.register_late_pass(move || Box::new(escape::BoxedLocal{too_large_for_stack}));
-    store.register_late_pass(move || Box::new(vec::UselessVec{too_large_for_stack}));
+    store.register_late_pass(move || Box::new(escape::BoxedLocal { too_large_for_stack }));
+    store.register_late_pass(move || Box::new(vec::UselessVec { too_large_for_stack }));
     store.register_late_pass(|| Box::new(panic_unimplemented::PanicUnimplemented));
     store.register_late_pass(|| Box::new(strings::StringLitAsBytes));
     store.register_late_pass(|| Box::new(derive::Derive));
@@ -603,7 +611,12 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(move || Box::new(blacklisted_name::BlacklistedName::new(blacklisted_names.clone())));
     let too_many_arguments_threshold = conf.too_many_arguments_threshold;
     let too_many_lines_threshold = conf.too_many_lines_threshold;
-    store.register_late_pass(move || Box::new(functions::Functions::new(too_many_arguments_threshold, too_many_lines_threshold)));
+    store.register_late_pass(move || {
+        Box::new(functions::Functions::new(
+            too_many_arguments_threshold,
+            too_many_lines_threshold,
+        ))
+    });
     let doc_valid_idents = conf.doc_valid_idents.iter().cloned().collect::<FxHashSet<_>>();
     store.register_late_pass(move || Box::new(doc::DocMarkdown::new(doc_valid_idents.clone())));
     store.register_late_pass(|| Box::new(neg_multiply::NegMultiply));
@@ -688,14 +701,32 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(multiple_crate_versions::MultipleCrateVersions));
     store.register_late_pass(|| Box::new(wildcard_dependencies::WildcardDependencies));
     let literal_representation_lint_fraction_readability = conf.unreadable_literal_lint_fractions;
-    store.register_early_pass(move || Box::new(literal_representation::LiteralDigitGrouping::new(literal_representation_lint_fraction_readability)));
+    store.register_early_pass(move || {
+        Box::new(literal_representation::LiteralDigitGrouping::new(
+            literal_representation_lint_fraction_readability,
+        ))
+    });
     let literal_representation_threshold = conf.literal_representation_threshold;
-    store.register_early_pass(move || Box::new(literal_representation::DecimalLiteralRepresentation::new(literal_representation_threshold)));
+    store.register_early_pass(move || {
+        Box::new(literal_representation::DecimalLiteralRepresentation::new(
+            literal_representation_threshold,
+        ))
+    });
     let enum_variant_name_threshold = conf.enum_variant_name_threshold;
-    store.register_late_pass(move || Box::new(enum_variants::EnumVariantNames::new(enum_variant_name_threshold, avoid_breaking_exported_api)));
+    store.register_late_pass(move || {
+        Box::new(enum_variants::EnumVariantNames::new(
+            enum_variant_name_threshold,
+            avoid_breaking_exported_api,
+        ))
+    });
     store.register_early_pass(|| Box::new(tabs_in_doc_comments::TabsInDocComments));
     let upper_case_acronyms_aggressive = conf.upper_case_acronyms_aggressive;
-    store.register_late_pass(move || Box::new(upper_case_acronyms::UpperCaseAcronyms::new(avoid_breaking_exported_api, upper_case_acronyms_aggressive)));
+    store.register_late_pass(move || {
+        Box::new(upper_case_acronyms::UpperCaseAcronyms::new(
+            avoid_breaking_exported_api,
+            upper_case_acronyms_aggressive,
+        ))
+    });
     store.register_late_pass(|| Box::new(default::Default::default()));
     store.register_late_pass(|| Box::new(unused_self::UnusedSelf));
     store.register_late_pass(|| Box::new(mutable_debug_assertion::DebugAssertWithMutCall));
@@ -710,7 +741,12 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_early_pass(|| Box::new(single_component_path_imports::SingleComponentPathImports));
     let max_fn_params_bools = conf.max_fn_params_bools;
     let max_struct_bools = conf.max_struct_bools;
-    store.register_early_pass(move || Box::new(excessive_bools::ExcessiveBools::new(max_struct_bools, max_fn_params_bools)));
+    store.register_early_pass(move || {
+        Box::new(excessive_bools::ExcessiveBools::new(
+            max_struct_bools,
+            max_fn_params_bools,
+        ))
+    });
     store.register_early_pass(|| Box::new(option_env_unwrap::OptionEnvUnwrap));
     let warn_on_all_wildcard_imports = conf.warn_on_all_wildcard_imports;
     store.register_late_pass(move || Box::new(wildcard_imports::WildcardImports::new(warn_on_all_wildcard_imports)));
@@ -729,9 +765,11 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(vec_resize_to_zero::VecResizeToZero));
     store.register_late_pass(|| Box::new(panic_in_result_fn::PanicInResultFn));
     let single_char_binding_names_threshold = conf.single_char_binding_names_threshold;
-    store.register_early_pass(move || Box::new(non_expressive_names::NonExpressiveNames {
-        single_char_binding_names_threshold,
-    }));
+    store.register_early_pass(move || {
+        Box::new(non_expressive_names::NonExpressiveNames {
+            single_char_binding_names_threshold,
+        })
+    });
     let macro_matcher = conf.standard_macro_braces.iter().cloned().collect::<FxHashSet<_>>();
     store.register_early_pass(move || Box::new(nonstandard_macro_braces::MacroBraces::new(&macro_matcher)));
     store.register_late_pass(|| Box::new(macro_use::MacroUseImports::default()));
@@ -754,7 +792,9 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(strings::StringToString));
     store.register_late_pass(|| Box::new(zero_sized_map_values::ZeroSizedMapValues));
     store.register_late_pass(|| Box::new(vec_init_then_push::VecInitThenPush::default()));
-    store.register_late_pass(|| Box::new(case_sensitive_file_extension_comparisons::CaseSensitiveFileExtensionComparisons));
+    store.register_late_pass(|| {
+        Box::new(case_sensitive_file_extension_comparisons::CaseSensitiveFileExtensionComparisons)
+    });
     store.register_late_pass(|| Box::new(redundant_slicing::RedundantSlicing));
     store.register_late_pass(|| Box::new(from_str_radix_10::FromStrRadix10));
     store.register_late_pass(|| Box::new(manual_map::ManualMap));
@@ -765,7 +805,11 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     let disallowed_types = conf.disallowed_types.clone();
     store.register_late_pass(move || Box::new(disallowed_type::DisallowedType::new(disallowed_types.clone())));
     let import_renames = conf.enforced_import_renames.clone();
-    store.register_late_pass(move || Box::new(missing_enforced_import_rename::ImportRename::new(import_renames.clone())));
+    store.register_late_pass(move || {
+        Box::new(missing_enforced_import_rename::ImportRename::new(
+            import_renames.clone(),
+        ))
+    });
     let scripts = conf.allowed_scripts.clone();
     store.register_early_pass(move || Box::new(disallowed_script_idents::DisallowedScriptIdents::new(&scripts)));
     store.register_late_pass(|| Box::new(strlen_on_c_strings::StrlenOnCStrings));
@@ -774,7 +818,11 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(move || Box::new(iter_not_returning_iterator::IterNotReturningIterator));
     store.register_late_pass(move || Box::new(manual_assert::ManualAssert));
     let enable_raw_pointer_heuristic_for_send = conf.enable_raw_pointer_heuristic_for_send;
-    store.register_late_pass(move || Box::new(non_send_fields_in_send_ty::NonSendFieldInSendTy::new(enable_raw_pointer_heuristic_for_send)));
+    store.register_late_pass(move || {
+        Box::new(non_send_fields_in_send_ty::NonSendFieldInSendTy::new(
+            enable_raw_pointer_heuristic_for_send,
+        ))
+    });
     store.register_late_pass(move || Box::new(undocumented_unsafe_blocks::UndocumentedUnsafeBlocks::default()));
     store.register_late_pass(|| Box::new(match_str_case_mismatch::MatchStrCaseMismatch));
     store.register_late_pass(move || Box::new(format_args::FormatArgs));
-- 
cgit 1.4.1-3-g733a5


From 14d54f0f6eb3b03cb5d719949a25404a8fe563d9 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Fri, 29 Oct 2021 11:14:22 -0500
Subject: Use Span::from_expansion instead of in_macro

---
 clippy_lints/src/booleans.rs                       | 28 ++++++++++----------
 clippy_lints/src/copies.rs                         |  6 ++---
 clippy_lints/src/default.rs                        |  6 ++---
 clippy_lints/src/dereference.rs                    |  4 +--
 clippy_lints/src/derivable_impls.rs                |  4 +--
 clippy_lints/src/eq_op.rs                          |  6 ++---
 clippy_lints/src/excessive_bools.rs                |  3 +--
 clippy_lints/src/implicit_saturating_sub.rs        |  4 +--
 .../src/inconsistent_struct_constructor.rs         |  3 +--
 clippy_lints/src/inherent_impl.rs                  |  8 +++---
 clippy_lints/src/lifetimes.rs                      |  4 +--
 clippy_lints/src/literal_representation.rs         |  7 ++---
 clippy_lints/src/macro_use.rs                      |  6 ++++-
 clippy_lints/src/matches.rs                        | 19 ++++++--------
 clippy_lints/src/mem_replace.rs                    |  4 +--
 clippy_lints/src/methods/bind_instead_of_map.rs    |  4 +--
 clippy_lints/src/methods/mod.rs                    |  4 +--
 clippy_lints/src/needless_arbitrary_self_type.rs   |  7 +++--
 clippy_lints/src/needless_bitwise_bool.rs          |  3 +--
 clippy_lints/src/needless_borrow.rs                | 12 ++++-----
 clippy_lints/src/needless_option_as_deref.rs       |  3 +--
 clippy_lints/src/nonstandard_macro_braces.rs       | 30 ++++++++--------------
 clippy_lints/src/option_if_let_else.rs             |  4 +--
 clippy_lints/src/ptr_eq.rs                         |  3 +--
 clippy_lints/src/redundant_slicing.rs              |  4 +--
 clippy_lints/src/reference.rs                      |  3 +--
 clippy_lints/src/repeat_once.rs                    |  3 +--
 clippy_lints/src/returns.rs                        |  5 ++--
 clippy_lints/src/single_component_path_imports.rs  |  3 +--
 clippy_lints/src/strlen_on_c_strings.rs            |  3 +--
 clippy_lints/src/trait_bounds.rs                   | 10 ++++----
 clippy_lints/src/try_err.rs                        | 20 +++++----------
 clippy_lints/src/undocumented_unsafe_blocks.rs     |  4 +--
 clippy_lints/src/unnecessary_wraps.rs              |  4 +--
 clippy_lints/src/use_self.rs                       | 10 ++++----
 clippy_lints/src/wildcard_imports.rs               |  4 +--
 clippy_utils/src/lib.rs                            |  6 -----
 clippy_utils/src/usage.rs                          |  2 +-
 tests/ui-internal/if_chain_style.rs                |  2 +-
 tests/ui/manual_assert.edition2018.fixed           |  2 ++
 tests/ui/manual_assert.edition2018.stderr          | 14 +++++-----
 tests/ui/manual_assert.edition2021.fixed           |  2 ++
 tests/ui/manual_assert.edition2021.stderr          | 14 +++++-----
 tests/ui/manual_assert.fixed                       |  2 ++
 tests/ui/manual_assert.rs                          |  2 ++
 45 files changed, 137 insertions(+), 164 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/booleans.rs b/clippy_lints/src/booleans.rs
index 8282800c819..a1e6b7224ff 100644
--- a/clippy_lints/src/booleans.rs
+++ b/clippy_lints/src/booleans.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::{implements_trait, is_type_diagnostic_item};
-use clippy_utils::{eq_expr_value, get_trait_def_id, in_macro, paths};
+use clippy_utils::{eq_expr_value, get_trait_def_id, paths};
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
@@ -453,22 +453,20 @@ impl<'a, 'tcx> Visitor<'tcx> for NonminimalBoolVisitor<'a, 'tcx> {
     type Map = Map<'tcx>;
 
     fn visit_expr(&mut self, e: &'tcx Expr<'_>) {
-        if in_macro(e.span) {
-            return;
-        }
-        match &e.kind {
-            ExprKind::Binary(binop, _, _) if binop.node == BinOpKind::Or || binop.node == BinOpKind::And => {
-                self.bool_expr(e);
-            },
-            ExprKind::Unary(UnOp::Not, inner) => {
-                if self.cx.typeck_results().node_types()[inner.hir_id].is_bool() {
+        if !e.span.from_expansion() {
+            match &e.kind {
+                ExprKind::Binary(binop, _, _) if binop.node == BinOpKind::Or || binop.node == BinOpKind::And => {
                     self.bool_expr(e);
-                } else {
-                    walk_expr(self, e);
-                }
-            },
-            _ => walk_expr(self, e),
+                },
+                ExprKind::Unary(UnOp::Not, inner) => {
+                    if self.cx.typeck_results().node_types()[inner.hir_id].is_bool() {
+                        self.bool_expr(e);
+                    }
+                },
+                _ => {},
+            }
         }
+        walk_expr(self, e);
     }
     fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
         NestedVisitorMap::None
diff --git a/clippy_lints/src/copies.rs b/clippy_lints/src/copies.rs
index 8abf10c0d1c..f57da62da5f 100644
--- a/clippy_lints/src/copies.rs
+++ b/clippy_lints/src/copies.rs
@@ -1,8 +1,8 @@
 use clippy_utils::diagnostics::{span_lint_and_note, span_lint_and_then};
 use clippy_utils::source::{first_line_of_span, indent_of, reindent_multiline, snippet, snippet_opt};
 use clippy_utils::{
-    both, count_eq, eq_expr_value, get_enclosing_block, get_parent_expr, if_sequence, in_macro, is_else_clause,
-    is_lint_allowed, search_same, ContainsName, SpanlessEq, SpanlessHash,
+    both, count_eq, eq_expr_value, get_enclosing_block, get_parent_expr, if_sequence, is_else_clause, is_lint_allowed,
+    search_same, ContainsName, SpanlessEq, SpanlessHash,
 };
 use if_chain::if_chain;
 use rustc_data_structures::fx::FxHashSet;
@@ -623,7 +623,7 @@ fn lint_same_fns_in_if_cond(cx: &LateContext<'_>, conds: &[&Expr<'_>]) {
 
     let eq: &dyn Fn(&&Expr<'_>, &&Expr<'_>) -> bool = &|&lhs, &rhs| -> bool {
         // Do not lint if any expr originates from a macro
-        if in_macro(lhs.span) || in_macro(rhs.span) {
+        if lhs.span.from_expansion() || rhs.span.from_expansion() {
             return false;
         }
         // Do not spawn warning if `IFS_SAME_COND` already produced it.
diff --git a/clippy_lints/src/default.rs b/clippy_lints/src/default.rs
index cde27d3ad2a..54647ba823e 100644
--- a/clippy_lints/src/default.rs
+++ b/clippy_lints/src/default.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::{span_lint_and_note, span_lint_and_sugg};
 use clippy_utils::source::snippet_with_macro_callsite;
 use clippy_utils::ty::{has_drop, is_copy};
-use clippy_utils::{any_parent_is_automatically_derived, contains_name, in_macro, match_def_path, paths};
+use clippy_utils::{any_parent_is_automatically_derived, contains_name, match_def_path, paths};
 use if_chain::if_chain;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Applicability;
@@ -78,7 +78,7 @@ impl_lint_pass!(Default => [DEFAULT_TRAIT_ACCESS, FIELD_REASSIGN_WITH_DEFAULT]);
 impl LateLintPass<'_> for Default {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if_chain! {
-            if !in_macro(expr.span);
+            if !expr.span.from_expansion();
             // Avoid cases already linted by `field_reassign_with_default`
             if !self.reassigned_linted.contains(&expr.span);
             if let ExprKind::Call(path, ..) = expr.kind;
@@ -125,7 +125,7 @@ impl LateLintPass<'_> for Default {
                 if let StmtKind::Local(local) = stmt.kind;
                 if let Some(expr) = local.init;
                 if !any_parent_is_automatically_derived(cx.tcx, expr.hir_id);
-                if !in_macro(expr.span);
+                if !expr.span.from_expansion();
                 // only take bindings to identifiers
                 if let PatKind::Binding(_, binding_id, ident, _) = local.pat.kind;
                 // only when assigning `... = Default::default()`
diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index ce59311c4aa..975353add08 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_context;
 use clippy_utils::ty::peel_mid_ty_refs;
-use clippy_utils::{get_parent_node, in_macro, is_lint_allowed};
+use clippy_utils::{get_parent_node, is_lint_allowed};
 use rustc_ast::util::parser::PREC_PREFIX;
 use rustc_errors::Applicability;
 use rustc_hir::{BorrowKind, Expr, ExprKind, HirId, MatchSource, Mutability, Node, UnOp};
@@ -84,7 +84,7 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing {
         }
 
         // Stop processing sub expressions when a macro call is seen
-        if in_macro(expr.span) {
+        if expr.span.from_expansion() {
             if let Some((state, data)) = self.state.take() {
                 report(cx, expr, state, data);
             }
diff --git a/clippy_lints/src/derivable_impls.rs b/clippy_lints/src/derivable_impls.rs
index fdef0abe970..01ec306e5e1 100644
--- a/clippy_lints/src/derivable_impls.rs
+++ b/clippy_lints/src/derivable_impls.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_help;
-use clippy_utils::{in_macro, is_automatically_derived, is_default_equivalent, remove_blocks};
+use clippy_utils::{is_automatically_derived, is_default_equivalent, remove_blocks};
 use rustc_hir::{
     def::{DefKind, Res},
     Body, Expr, ExprKind, GenericArg, Impl, ImplItemKind, Item, ItemKind, Node, PathSegment, QPath, TyKind,
@@ -72,7 +72,7 @@ impl<'tcx> LateLintPass<'tcx> for DerivableImpls {
             }) = item.kind;
             if let attrs = cx.tcx.hir().attrs(item.hir_id());
             if !is_automatically_derived(attrs);
-            if !in_macro(item.span);
+            if !item.span.from_expansion();
             if let Some(def_id) = trait_ref.trait_def_id();
             if cx.tcx.is_diagnostic_item(sym::Default, def_id);
             if let impl_item_hir = child.id.hir_id();
diff --git a/clippy_lints/src/eq_op.rs b/clippy_lints/src/eq_op.rs
index 655560afd42..c034c849b55 100644
--- a/clippy_lints/src/eq_op.rs
+++ b/clippy_lints/src/eq_op.rs
@@ -1,9 +1,7 @@
 use clippy_utils::diagnostics::{multispan_sugg, span_lint, span_lint_and_then};
 use clippy_utils::source::snippet;
 use clippy_utils::ty::{implements_trait, is_copy};
-use clippy_utils::{
-    ast_utils::is_useless_with_eq_exprs, eq_expr_value, higher, in_macro, is_expn_of, is_in_test_function,
-};
+use clippy_utils::{ast_utils::is_useless_with_eq_exprs, eq_expr_value, higher, is_expn_of, is_in_test_function};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, BorrowKind, Expr, ExprKind, StmtKind};
@@ -102,7 +100,7 @@ impl<'tcx> LateLintPass<'tcx> for EqOp {
             }
             let macro_with_not_op = |expr_kind: &ExprKind<'_>| {
                 if let ExprKind::Unary(_, expr) = *expr_kind {
-                    in_macro(expr.span)
+                    expr.span.from_expansion()
                 } else {
                     false
                 }
diff --git a/clippy_lints/src/excessive_bools.rs b/clippy_lints/src/excessive_bools.rs
index 476e6d23f12..06171702f75 100644
--- a/clippy_lints/src/excessive_bools.rs
+++ b/clippy_lints/src/excessive_bools.rs
@@ -1,5 +1,4 @@
 use clippy_utils::diagnostics::span_lint_and_help;
-use clippy_utils::in_macro;
 use rustc_ast::ast::{AssocItemKind, Extern, FnKind, FnSig, ImplKind, Item, ItemKind, TraitKind, Ty, TyKind};
 use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
@@ -135,7 +134,7 @@ fn is_bool_ty(ty: &Ty) -> bool {
 
 impl EarlyLintPass for ExcessiveBools {
     fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {
-        if in_macro(item.span) {
+        if item.span.from_expansion() {
             return;
         }
         match &item.kind {
diff --git a/clippy_lints/src/implicit_saturating_sub.rs b/clippy_lints/src/implicit_saturating_sub.rs
index a4f60ded3a6..ecbbbc5bc64 100644
--- a/clippy_lints/src/implicit_saturating_sub.rs
+++ b/clippy_lints/src/implicit_saturating_sub.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::higher;
-use clippy_utils::{in_macro, SpanlessEq};
+use clippy_utils::SpanlessEq;
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
@@ -39,7 +39,7 @@ declare_lint_pass!(ImplicitSaturatingSub => [IMPLICIT_SATURATING_SUB]);
 
 impl<'tcx> LateLintPass<'tcx> for ImplicitSaturatingSub {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
-        if in_macro(expr.span) {
+        if expr.span.from_expansion() {
             return;
         }
         if_chain! {
diff --git a/clippy_lints/src/inconsistent_struct_constructor.rs b/clippy_lints/src/inconsistent_struct_constructor.rs
index 1f8240a1f63..52c92b3b122 100644
--- a/clippy_lints/src/inconsistent_struct_constructor.rs
+++ b/clippy_lints/src/inconsistent_struct_constructor.rs
@@ -1,5 +1,4 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::in_macro;
 use clippy_utils::source::snippet;
 use if_chain::if_chain;
 use rustc_data_structures::fx::FxHashMap;
@@ -66,7 +65,7 @@ declare_lint_pass!(InconsistentStructConstructor => [INCONSISTENT_STRUCT_CONSTRU
 impl LateLintPass<'_> for InconsistentStructConstructor {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
         if_chain! {
-            if !in_macro(expr.span);
+            if !expr.span.from_expansion();
             if let ExprKind::Struct(qpath, fields, base) = expr.kind;
             let ty = cx.typeck_results().expr_ty(expr);
             if let Some(adt_def) = ty.ty_adt_def();
diff --git a/clippy_lints/src/inherent_impl.rs b/clippy_lints/src/inherent_impl.rs
index 0d23bec27a3..bd0b2964309 100644
--- a/clippy_lints/src/inherent_impl.rs
+++ b/clippy_lints/src/inherent_impl.rs
@@ -1,7 +1,7 @@
 //! lint on inherent implementations
 
 use clippy_utils::diagnostics::span_lint_and_note;
-use clippy_utils::{in_macro, is_lint_allowed};
+use clippy_utils::is_lint_allowed;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_hir::{def_id::LocalDefId, Item, ItemKind, Node};
 use rustc_lint::{LateContext, LateLintPass};
@@ -123,8 +123,10 @@ fn get_impl_span(cx: &LateContext<'_>, id: LocalDefId) -> Option<Span> {
         ..
     }) = cx.tcx.hir().get(id)
     {
-        (!in_macro(span) && impl_item.generics.params.is_empty() && !is_lint_allowed(cx, MULTIPLE_INHERENT_IMPL, id))
-            .then(|| span)
+        (!span.from_expansion()
+            && impl_item.generics.params.is_empty()
+            && !is_lint_allowed(cx, MULTIPLE_INHERENT_IMPL, id))
+        .then(|| span)
     } else {
         None
     }
diff --git a/clippy_lints/src/lifetimes.rs b/clippy_lints/src/lifetimes.rs
index cb0b96e0652..6565d5a6d70 100644
--- a/clippy_lints/src/lifetimes.rs
+++ b/clippy_lints/src/lifetimes.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint;
-use clippy_utils::{in_macro, trait_ref_of_method};
+use clippy_utils::trait_ref_of_method;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_hir::intravisit::{
     walk_fn_decl, walk_generic_param, walk_generics, walk_item, walk_param_bound, walk_poly_trait_ref, walk_ty,
@@ -128,7 +128,7 @@ fn check_fn_inner<'tcx>(
     span: Span,
     report_extra_lifetimes: bool,
 ) {
-    if in_macro(span) || has_where_lifetimes(cx, &generics.where_clause) {
+    if span.from_expansion() || has_where_lifetimes(cx, &generics.where_clause) {
         return;
     }
 
diff --git a/clippy_lints/src/literal_representation.rs b/clippy_lints/src/literal_representation.rs
index 0e5121ca3d7..0e36ab085a3 100644
--- a/clippy_lints/src/literal_representation.rs
+++ b/clippy_lints/src/literal_representation.rs
@@ -2,11 +2,8 @@
 //! floating-point literal expressions.
 
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::numeric_literal::{NumericLiteral, Radix};
 use clippy_utils::source::snippet_opt;
-use clippy_utils::{
-    in_macro,
-    numeric_literal::{NumericLiteral, Radix},
-};
 use if_chain::if_chain;
 use rustc_ast::ast::{Expr, ExprKind, Lit, LitKind};
 use rustc_errors::Applicability;
@@ -283,7 +280,7 @@ impl LiteralDigitGrouping {
                         | WarningType::InconsistentDigitGrouping
                         | WarningType::UnusualByteGroupings
                         | WarningType::LargeDigitGroups => {
-                            !in_macro(lit.span)
+                            !lit.span.from_expansion()
                         }
                         WarningType::DecimalRepresentation | WarningType::MistypedLiteralSuffix => {
                             true
diff --git a/clippy_lints/src/macro_use.rs b/clippy_lints/src/macro_use.rs
index 99ac4680720..bccdc3be5e9 100644
--- a/clippy_lints/src/macro_use.rs
+++ b/clippy_lints/src/macro_use.rs
@@ -1,5 +1,4 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::in_macro;
 use clippy_utils::source::snippet;
 use hir::def::{DefKind, Res};
 use if_chain::if_chain;
@@ -9,6 +8,7 @@ use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::hygiene::ExpnKind;
 use rustc_span::{edition::Edition, sym, Span};
 
 declare_clippy_lint! {
@@ -213,3 +213,7 @@ impl<'tcx> LateLintPass<'tcx> for MacroUseImports {
         }
     }
 }
+
+fn in_macro(span: Span) -> bool {
+    span.from_expansion() && !matches!(span.ctxt().outer_expn_data().kind, ExpnKind::Desugaring(..))
+}
diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index eb311983b29..f9030564588 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -8,9 +8,9 @@ use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::{implements_trait, is_type_diagnostic_item, match_type, peel_mid_ty_refs};
 use clippy_utils::visitors::is_local_used;
 use clippy_utils::{
-    get_parent_expr, in_macro, is_expn_of, is_lang_ctor, is_lint_allowed, is_refutable, is_unit_expr, is_wild,
-    meets_msrv, msrvs, path_to_local, path_to_local_id, peel_hir_pat_refs, peel_n_hir_expr_refs, recurse_or_patterns,
-    remove_blocks, strip_pat_refs,
+    get_parent_expr, is_expn_of, is_lang_ctor, is_lint_allowed, is_refutable, is_unit_expr, is_wild, meets_msrv, msrvs,
+    path_to_local, path_to_local_id, peel_hir_pat_refs, peel_n_hir_expr_refs, recurse_or_patterns, remove_blocks,
+    strip_pat_refs,
 };
 use clippy_utils::{paths, search_same, SpanlessEq, SpanlessHash};
 use core::array;
@@ -26,7 +26,6 @@ use rustc_hir::{
 };
 use rustc_hir::{HirIdMap, HirIdSet};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
-use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::{self, Ty, TyS, VariantDef};
 use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
@@ -602,7 +601,7 @@ impl_lint_pass!(Matches => [
 
 impl<'tcx> LateLintPass<'tcx> for Matches {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if in_external_macro(cx.sess(), expr.span) || in_macro(expr.span) {
+        if expr.span.from_expansion() {
             return;
         }
 
@@ -641,8 +640,7 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
 
     fn check_local(&mut self, cx: &LateContext<'tcx>, local: &'tcx Local<'_>) {
         if_chain! {
-            if !in_external_macro(cx.sess(), local.span);
-            if !in_macro(local.span);
+            if !local.span.from_expansion();
             if let Some(expr) = local.init;
             if let ExprKind::Match(target, arms, MatchSource::Normal) = expr.kind;
             if arms.len() == 1 && arms[0].guard.is_none();
@@ -677,8 +675,7 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
 
     fn check_pat(&mut self, cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>) {
         if_chain! {
-            if !in_external_macro(cx.sess(), pat.span);
-            if !in_macro(pat.span);
+            if !pat.span.from_expansion();
             if let PatKind::Struct(QPath::Resolved(_, path), fields, true) = pat.kind;
             if let Some(def_id) = path.res.opt_def_id();
             let ty = cx.tcx.type_of(def_id);
@@ -705,7 +702,7 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
 #[rustfmt::skip]
 fn check_single_match(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>], expr: &Expr<'_>) {
     if arms.len() == 2 && arms[0].guard.is_none() && arms[1].guard.is_none() {
-        if in_macro(expr.span) {
+        if expr.span.from_expansion() {
             // Don't lint match expressions present in
             // macro_rules! block
             return;
@@ -1448,7 +1445,7 @@ fn find_bool_lit(ex: &ExprKind<'_>, is_if_let: bool) -> Option<bool> {
 
 #[allow(clippy::too_many_lines)]
 fn check_match_single_binding<'a>(cx: &LateContext<'a>, ex: &Expr<'a>, arms: &[Arm<'_>], expr: &Expr<'_>) {
-    if in_macro(expr.span) || arms.len() != 1 || is_refutable(cx, arms[0].pat) {
+    if expr.span.from_expansion() || arms.len() != 1 || is_refutable(cx, arms[0].pat) {
         return;
     }
 
diff --git a/clippy_lints/src/mem_replace.rs b/clippy_lints/src/mem_replace.rs
index 1e6057a8fe9..cf721fc65db 100644
--- a/clippy_lints/src/mem_replace.rs
+++ b/clippy_lints/src/mem_replace.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::{snippet, snippet_with_applicability};
 use clippy_utils::ty::is_non_aggregate_primitive_type;
-use clippy_utils::{in_macro, is_default_equivalent, is_lang_ctor, match_def_path, meets_msrv, msrvs, paths};
+use clippy_utils::{is_default_equivalent, is_lang_ctor, match_def_path, meets_msrv, msrvs, paths};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::LangItem::OptionNone;
@@ -213,7 +213,7 @@ fn check_replace_with_default(cx: &LateContext<'_>, src: &Expr<'_>, dest: &Expr<
             expr_span,
             "replacing a value of type `T` with `T::default()` is better expressed using `std::mem::take`",
             |diag| {
-                if !in_macro(expr_span) {
+                if !expr_span.from_expansion() {
                     let suggestion = format!("std::mem::take({})", snippet(cx, dest.span, ""));
 
                     diag.span_suggestion(
diff --git a/clippy_lints/src/methods/bind_instead_of_map.rs b/clippy_lints/src/methods/bind_instead_of_map.rs
index da428a7b487..b7690cf9222 100644
--- a/clippy_lints/src/methods/bind_instead_of_map.rs
+++ b/clippy_lints/src/methods/bind_instead_of_map.rs
@@ -1,7 +1,7 @@
 use super::{contains_return, BIND_INSTEAD_OF_MAP};
 use clippy_utils::diagnostics::{multispan_sugg_with_applicability, span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::{snippet, snippet_with_macro_callsite};
-use clippy_utils::{in_macro, remove_blocks, visitors::find_all_ret_expressions};
+use clippy_utils::{remove_blocks, visitors::find_all_ret_expressions};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
@@ -106,7 +106,7 @@ pub(crate) trait BindInsteadOfMap {
         let mut suggs = Vec::new();
         let can_sugg: bool = find_all_ret_expressions(cx, closure_expr, |ret_expr| {
             if_chain! {
-                if !in_macro(ret_expr.span);
+                if !ret_expr.span.from_expansion();
                 if let hir::ExprKind::Call(func_path, [arg]) = ret_expr.kind;
                 if let hir::ExprKind::Path(QPath::Resolved(_, path)) = func_path.kind;
                 if Self::is_variant(cx, path.res);
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 26c29fbb289..6c4272f9e65 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -68,7 +68,7 @@ use bind_instead_of_map::BindInsteadOfMap;
 use clippy_utils::consts::{constant, Constant};
 use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
 use clippy_utils::ty::{contains_adt_constructor, contains_ty, implements_trait, is_copy, is_type_diagnostic_item};
-use clippy_utils::{contains_return, get_trait_def_id, in_macro, iter_input_pats, meets_msrv, msrvs, paths, return_ty};
+use clippy_utils::{contains_return, get_trait_def_id, iter_input_pats, meets_msrv, msrvs, paths, return_ty};
 use if_chain::if_chain;
 use rustc_hir as hir;
 use rustc_hir::def::Res;
@@ -1900,7 +1900,7 @@ macro_rules! method_call {
 
 impl<'tcx> LateLintPass<'tcx> for Methods {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
-        if in_macro(expr.span) {
+        if expr.span.from_expansion() {
             return;
         }
 
diff --git a/clippy_lints/src/needless_arbitrary_self_type.rs b/clippy_lints/src/needless_arbitrary_self_type.rs
index 9a3d9383cd9..c8a8750c2ff 100644
--- a/clippy_lints/src/needless_arbitrary_self_type.rs
+++ b/clippy_lints/src/needless_arbitrary_self_type.rs
@@ -1,5 +1,4 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::in_macro;
 use if_chain::if_chain;
 use rustc_ast::ast::{BindingMode, Lifetime, Mutability, Param, PatKind, Path, TyKind};
 use rustc_errors::Applicability;
@@ -78,7 +77,7 @@ fn check_param_inner(cx: &EarlyContext<'_>, path: &Path, span: Span, binding_mod
             let self_param = match (binding_mode, mutbl) {
                 (Mode::Ref(None), Mutability::Mut) => "&mut self".to_string(),
                 (Mode::Ref(Some(lifetime)), Mutability::Mut) => {
-                    if in_macro(lifetime.ident.span) {
+                    if lifetime.ident.span.from_expansion() {
                         applicability = Applicability::HasPlaceholders;
                         "&'_ mut self".to_string()
                     } else {
@@ -87,7 +86,7 @@ fn check_param_inner(cx: &EarlyContext<'_>, path: &Path, span: Span, binding_mod
                 },
                 (Mode::Ref(None), Mutability::Not) => "&self".to_string(),
                 (Mode::Ref(Some(lifetime)), Mutability::Not) => {
-                    if in_macro(lifetime.ident.span) {
+                    if lifetime.ident.span.from_expansion() {
                         applicability = Applicability::HasPlaceholders;
                         "&'_ self".to_string()
                     } else {
@@ -114,7 +113,7 @@ fn check_param_inner(cx: &EarlyContext<'_>, path: &Path, span: Span, binding_mod
 impl EarlyLintPass for NeedlessArbitrarySelfType {
     fn check_param(&mut self, cx: &EarlyContext<'_>, p: &Param) {
         // Bail out if the parameter it's not a receiver or was not written by the user
-        if !p.is_self() || in_macro(p.span) {
+        if !p.is_self() || p.span.from_expansion() {
             return;
         }
 
diff --git a/clippy_lints/src/needless_bitwise_bool.rs b/clippy_lints/src/needless_bitwise_bool.rs
index 203da29cb91..ad981599473 100644
--- a/clippy_lints/src/needless_bitwise_bool.rs
+++ b/clippy_lints/src/needless_bitwise_bool.rs
@@ -1,5 +1,4 @@
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::in_macro;
 use clippy_utils::source::snippet_opt;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
@@ -41,7 +40,7 @@ declare_lint_pass!(NeedlessBitwiseBool => [NEEDLESS_BITWISE_BOOL]);
 fn is_bitwise_operation(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
     let ty = cx.typeck_results().expr_ty(expr);
     if_chain! {
-        if !in_macro(expr.span);
+        if !expr.span.from_expansion();
         if let (&ExprKind::Binary(ref op, _, right), &ty::Bool) = (&expr.kind, &ty.kind());
         if op.node == BinOpKind::BitAnd || op.node == BinOpKind::BitOr;
         if let ExprKind::Call(..) | ExprKind::MethodCall(..) | ExprKind::Binary(..) | ExprKind::Unary(..) = right.kind;
diff --git a/clippy_lints/src/needless_borrow.rs b/clippy_lints/src/needless_borrow.rs
index f1be90c44f9..085be6650cc 100644
--- a/clippy_lints/src/needless_borrow.rs
+++ b/clippy_lints/src/needless_borrow.rs
@@ -4,7 +4,7 @@
 
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::{snippet_opt, snippet_with_applicability, snippet_with_context};
-use clippy_utils::{get_parent_expr, in_macro, path_to_local};
+use clippy_utils::{get_parent_expr, path_to_local};
 use if_chain::if_chain;
 use rustc_ast::util::parser::PREC_POSTFIX;
 use rustc_data_structures::fx::FxIndexMap;
@@ -157,7 +157,7 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessBorrow {
             if let Some(opt_prev_pat) = self.ref_locals.get_mut(&id) {
                 // This binding id has been seen before. Add this pattern to the list of changes.
                 if let Some(prev_pat) = opt_prev_pat {
-                    if in_macro(pat.span) {
+                    if pat.span.from_expansion() {
                         // Doesn't match the context of the previous pattern. Can't lint here.
                         *opt_prev_pat = None;
                     } else {
@@ -174,7 +174,7 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessBorrow {
             }
 
             if_chain! {
-                if !in_macro(pat.span);
+                if !pat.span.from_expansion();
                 if let ty::Ref(_, tam, _) = *cx.typeck_results().pat_ty(pat).kind();
                 // only lint immutable refs, because borrowed `&mut T` cannot be moved out
                 if let ty::Ref(_, _, Mutability::Not) = *tam.kind();
@@ -248,12 +248,12 @@ impl NeedlessBorrow {
                             span,
                             kind: ExprKind::Unary(UnOp::Deref, _),
                             ..
-                        }) if !in_macro(span) => {
+                        }) if !span.from_expansion() => {
                             // Remove explicit deref.
                             let snip = snippet_with_context(cx, e.span, span.ctxt(), "..", &mut pat.app).0;
                             pat.replacements.push((span, snip.into()));
                         },
-                        Some(parent) if !in_macro(parent.span) => {
+                        Some(parent) if !parent.span.from_expansion() => {
                             // Double reference might be needed at this point.
                             if parent.precedence().order() == PREC_POSTFIX {
                                 // Parentheses would be needed here, don't lint.
@@ -264,7 +264,7 @@ impl NeedlessBorrow {
                                 pat.replacements.push((e.span, format!("&{}", snip)));
                             }
                         },
-                        _ if !in_macro(e.span) => {
+                        _ if !e.span.from_expansion() => {
                             // Double reference might be needed at this point.
                             pat.always_deref = false;
                             let snip = snippet_with_applicability(cx, e.span, "..", &mut pat.app);
diff --git a/clippy_lints/src/needless_option_as_deref.rs b/clippy_lints/src/needless_option_as_deref.rs
index fbdaaf51f74..e88e98e6081 100644
--- a/clippy_lints/src/needless_option_as_deref.rs
+++ b/clippy_lints/src/needless_option_as_deref.rs
@@ -1,5 +1,4 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::in_macro;
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_errors::Applicability;
@@ -38,7 +37,7 @@ declare_lint_pass!(OptionNeedlessDeref=> [
 
 impl<'tcx> LateLintPass<'tcx> for OptionNeedlessDeref {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if expr.span.from_expansion() || in_macro(expr.span) {
+        if expr.span.from_expansion() {
             return;
         }
         let typeck = cx.typeck_results();
diff --git a/clippy_lints/src/nonstandard_macro_braces.rs b/clippy_lints/src/nonstandard_macro_braces.rs
index ca660a9250d..bab15217d52 100644
--- a/clippy_lints/src/nonstandard_macro_braces.rs
+++ b/clippy_lints/src/nonstandard_macro_braces.rs
@@ -3,14 +3,16 @@ use std::{
     hash::{Hash, Hasher},
 };
 
-use clippy_utils::{diagnostics::span_lint_and_help, in_macro, is_direct_expn_of, source::snippet_opt};
+use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::source::snippet_opt;
 use if_chain::if_chain;
 use rustc_ast::ast;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_hir::def_id::DefId;
 use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::Span;
+use rustc_span::hygiene::{ExpnKind, MacroKind};
+use rustc_span::{Span, Symbol};
 use serde::{de, Deserialize};
 
 declare_clippy_lint! {
@@ -37,7 +39,7 @@ declare_clippy_lint! {
 const BRACES: &[(&str, &str)] = &[("(", ")"), ("{", "}"), ("[", "]")];
 
 /// The (name, (open brace, close brace), source snippet)
-type MacroInfo<'a> = (&'a str, &'a (String, String), String);
+type MacroInfo<'a> = (Symbol, &'a (String, String), String);
 
 #[derive(Clone, Debug, Default)]
 pub struct MacroBraces {
@@ -93,17 +95,16 @@ impl EarlyLintPass for MacroBraces {
 
 fn is_offending_macro<'a>(cx: &EarlyContext<'_>, span: Span, mac_braces: &'a MacroBraces) -> Option<MacroInfo<'a>> {
     let unnested_or_local = || {
-        let nested = in_macro(span.ctxt().outer_expn_data().call_site);
-        !nested
+        !span.ctxt().outer_expn_data().call_site.from_expansion()
             || span
                 .macro_backtrace()
                 .last()
                 .map_or(false, |e| e.macro_def_id.map_or(false, DefId::is_local))
     };
     if_chain! {
-        // Make sure we are only one level deep otherwise there are to many FP's
-        if in_macro(span);
-        if let Some((name, braces)) = find_matching_macro(span, &mac_braces.macro_braces);
+        if let ExpnKind::Macro(MacroKind::Bang, mac_name) = span.ctxt().outer_expn_data().kind;
+        let name = &*mac_name.as_str();
+        if let Some(braces) = mac_braces.macro_braces.get(name);
         if let Some(snip) = snippet_opt(cx, span.ctxt().outer_expn_data().call_site);
         // we must check only invocation sites
         // https://github.com/rust-lang/rust-clippy/issues/7422
@@ -114,14 +115,14 @@ fn is_offending_macro<'a>(cx: &EarlyContext<'_>, span: Span, mac_braces: &'a Mac
         if !c.starts_with(&format!("{}!{}", name, braces.0));
         if !mac_braces.done.contains(&span.ctxt().outer_expn_data().call_site);
         then {
-            Some((name, braces, snip))
+            Some((mac_name, braces, snip))
         } else {
             None
         }
     }
 }
 
-fn emit_help(cx: &EarlyContext<'_>, snip: String, braces: &(String, String), name: &str, span: Span) {
+fn emit_help(cx: &EarlyContext<'_>, snip: String, braces: &(String, String), name: Symbol, span: Span) {
     let with_space = &format!("! {}", braces.0);
     let without_space = &format!("!{}", braces.0);
     let mut help = snip;
@@ -144,15 +145,6 @@ fn emit_help(cx: &EarlyContext<'_>, snip: String, braces: &(String, String), nam
     );
 }
 
-fn find_matching_macro(
-    span: Span,
-    braces: &FxHashMap<String, (String, String)>,
-) -> Option<(&String, &(String, String))> {
-    braces
-        .iter()
-        .find(|(macro_name, _)| is_direct_expn_of(span, macro_name).is_some())
-}
-
 fn macro_braces(conf: FxHashSet<MacroMatcher>) -> FxHashMap<String, (String, String)> {
     let mut braces = vec![
         macro_matcher!(
diff --git a/clippy_lints/src/option_if_let_else.rs b/clippy_lints/src/option_if_let_else.rs
index cbe1c5d44d5..ed5583799fe 100644
--- a/clippy_lints/src/option_if_let_else.rs
+++ b/clippy_lints/src/option_if_let_else.rs
@@ -3,7 +3,7 @@ use clippy_utils::higher;
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::{
-    can_move_expr_to_closure, eager_or_lazy, in_constant, in_macro, is_else_clause, is_lang_ctor, peel_hir_expr_while,
+    can_move_expr_to_closure, eager_or_lazy, in_constant, is_else_clause, is_lang_ctor, peel_hir_expr_while,
     CaptureKind,
 };
 use if_chain::if_chain;
@@ -126,7 +126,7 @@ fn format_option_in_sugg(cx: &LateContext<'_>, cond_expr: &Expr<'_>, as_ref: boo
 /// this construct is found, or None if this construct is not found.
 fn detect_option_if_let_else<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>) -> Option<OptionIfLetElseOccurence> {
     if_chain! {
-        if !in_macro(expr.span); // Don't lint macros, because it behaves weirdly
+        if !expr.span.from_expansion(); // Don't lint macros, because it behaves weirdly
         if !in_constant(cx, expr.hir_id);
         if let Some(higher::IfLet { let_pat, let_expr, if_then, if_else: Some(if_else) })
             = higher::IfLet::hir(cx, expr);
diff --git a/clippy_lints/src/ptr_eq.rs b/clippy_lints/src/ptr_eq.rs
index 3258c9fb3fe..2df34d6d9b9 100644
--- a/clippy_lints/src/ptr_eq.rs
+++ b/clippy_lints/src/ptr_eq.rs
@@ -1,5 +1,4 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::in_macro;
 use clippy_utils::source::snippet_opt;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
@@ -41,7 +40,7 @@ static LINT_MSG: &str = "use `std::ptr::eq` when comparing raw pointers";
 
 impl LateLintPass<'_> for PtrEq {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if in_macro(expr.span) {
+        if expr.span.from_expansion() {
             return;
         }
 
diff --git a/clippy_lints/src/redundant_slicing.rs b/clippy_lints/src/redundant_slicing.rs
index 290348c4509..0c460150087 100644
--- a/clippy_lints/src/redundant_slicing.rs
+++ b/clippy_lints/src/redundant_slicing.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::get_parent_expr;
 use clippy_utils::source::snippet_with_context;
 use clippy_utils::ty::is_type_lang_item;
-use clippy_utils::{get_parent_expr, in_macro};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{BorrowKind, Expr, ExprKind, LangItem, Mutability};
@@ -43,7 +43,7 @@ declare_lint_pass!(RedundantSlicing => [REDUNDANT_SLICING]);
 
 impl LateLintPass<'_> for RedundantSlicing {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if in_macro(expr.span) {
+        if expr.span.from_expansion() {
             return;
         }
 
diff --git a/clippy_lints/src/reference.rs b/clippy_lints/src/reference.rs
index 77b6e60d893..70dff5ad313 100644
--- a/clippy_lints/src/reference.rs
+++ b/clippy_lints/src/reference.rs
@@ -1,5 +1,4 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::in_macro;
 use clippy_utils::source::{snippet_opt, snippet_with_applicability};
 use clippy_utils::sugg::Sugg;
 use if_chain::if_chain;
@@ -50,7 +49,7 @@ impl EarlyLintPass for DerefAddrOf {
         if_chain! {
             if let ExprKind::Unary(UnOp::Deref, ref deref_target) = e.kind;
             if let ExprKind::AddrOf(_, ref mutability, ref addrof_target) = without_parens(deref_target).kind;
-            if !in_macro(addrof_target.span);
+            if !addrof_target.span.from_expansion();
             then {
                 let mut applicability = Applicability::MachineApplicable;
                 let sugg = if e.span.from_expansion() {
diff --git a/clippy_lints/src/repeat_once.rs b/clippy_lints/src/repeat_once.rs
index cf94c0e97d9..e5e55ee7505 100644
--- a/clippy_lints/src/repeat_once.rs
+++ b/clippy_lints/src/repeat_once.rs
@@ -1,6 +1,5 @@
 use clippy_utils::consts::{constant_context, Constant};
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::in_macro;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
@@ -49,7 +48,7 @@ impl<'tcx> LateLintPass<'tcx> for RepeatOnce {
             if let ExprKind::MethodCall(path, _, [receiver, count], _) = &expr.kind;
             if path.ident.name == sym!(repeat);
             if constant_context(cx, cx.typeck_results()).expr(count) == Some(Constant::Int(1));
-            if !in_macro(receiver.span);
+            if !receiver.span.from_expansion();
             then {
                 let ty = cx.typeck_results().expr_ty(receiver).peel_refs();
                 if ty.is_str() {
diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
index ae85b7087e7..e2b1a33746e 100644
--- a/clippy_lints/src/returns.rs
+++ b/clippy_lints/src/returns.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::snippet_opt;
-use clippy_utils::{fn_def_id, in_macro, path_to_local_id};
+use clippy_utils::{fn_def_id, path_to_local_id};
 use if_chain::if_chain;
 use rustc_ast::ast::Attribute;
 use rustc_errors::Applicability;
@@ -90,8 +90,7 @@ impl<'tcx> LateLintPass<'tcx> for Return {
             if !last_statement_borrows(cx, initexpr);
             if !in_external_macro(cx.sess(), initexpr.span);
             if !in_external_macro(cx.sess(), retexpr.span);
-            if !in_external_macro(cx.sess(), local.span);
-            if !in_macro(local.span);
+            if !local.span.from_expansion();
             then {
                 span_lint_and_then(
                     cx,
diff --git a/clippy_lints/src/single_component_path_imports.rs b/clippy_lints/src/single_component_path_imports.rs
index f6487b8c46b..87aa02b6585 100644
--- a/clippy_lints/src/single_component_path_imports.rs
+++ b/clippy_lints/src/single_component_path_imports.rs
@@ -1,5 +1,4 @@
 use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg};
-use clippy_utils::in_macro;
 use rustc_ast::{ptr::P, Crate, Item, ItemKind, MacroDef, ModKind, UseTreeKind, VisibilityKind};
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass};
@@ -110,7 +109,7 @@ fn track_uses(
     single_use_usages: &mut Vec<(Symbol, Span, bool)>,
     macros: &mut Vec<Symbol>,
 ) {
-    if in_macro(item.span) || item.vis.kind.is_pub() {
+    if item.span.from_expansion() || item.vis.kind.is_pub() {
         return;
     }
 
diff --git a/clippy_lints/src/strlen_on_c_strings.rs b/clippy_lints/src/strlen_on_c_strings.rs
index 516fa3d95b4..8bf40ec5312 100644
--- a/clippy_lints/src/strlen_on_c_strings.rs
+++ b/clippy_lints/src/strlen_on_c_strings.rs
@@ -1,5 +1,4 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::in_macro;
 use clippy_utils::paths;
 use clippy_utils::source::snippet_with_macro_callsite;
 use clippy_utils::ty::{is_type_diagnostic_item, is_type_ref_to_diagnostic_item};
@@ -40,7 +39,7 @@ declare_lint_pass!(StrlenOnCStrings => [STRLEN_ON_C_STRINGS]);
 
 impl LateLintPass<'tcx> for StrlenOnCStrings {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
-        if in_macro(expr.span) {
+        if expr.span.from_expansion() {
             return;
         }
 
diff --git a/clippy_lints/src/trait_bounds.rs b/clippy_lints/src/trait_bounds.rs
index 79367c4230c..73bdcae9e39 100644
--- a/clippy_lints/src/trait_bounds.rs
+++ b/clippy_lints/src/trait_bounds.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::source::{snippet, snippet_with_applicability};
-use clippy_utils::{in_macro, SpanlessHash};
+use clippy_utils::SpanlessHash;
 use if_chain::if_chain;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_data_structures::unhash::UnhashMap;
@@ -93,7 +93,7 @@ fn get_trait_res_span_from_bound(bound: &GenericBound<'_>) -> Option<(Res, Span)
 
 impl TraitBounds {
     fn check_type_repetition(self, cx: &LateContext<'_>, gen: &'_ Generics<'_>) {
-        if in_macro(gen.span) {
+        if gen.span.from_expansion() {
             return;
         }
         let hash = |ty| -> u64 {
@@ -107,7 +107,7 @@ impl TraitBounds {
             if_chain! {
                 if let WherePredicate::BoundPredicate(ref p) = bound;
                 if p.bounds.len() as u64 <= self.max_trait_bounds;
-                if !in_macro(p.span);
+                if !p.span.from_expansion();
                 let h = hash(p.bounded_ty);
                 if let Some(ref v) = map.insert(h, p.bounds.iter().collect::<Vec<_>>());
 
@@ -151,7 +151,7 @@ impl TraitBounds {
 }
 
 fn check_trait_bound_duplication(cx: &LateContext<'_>, gen: &'_ Generics<'_>) {
-    if in_macro(gen.span) || gen.params.is_empty() || gen.where_clause.predicates.is_empty() {
+    if gen.span.from_expansion() || gen.params.is_empty() || gen.where_clause.predicates.is_empty() {
         return;
     }
 
@@ -170,7 +170,7 @@ fn check_trait_bound_duplication(cx: &LateContext<'_>, gen: &'_ Generics<'_>) {
     for predicate in gen.where_clause.predicates {
         if_chain! {
             if let WherePredicate::BoundPredicate(ref bound_predicate) = predicate;
-            if !in_macro(bound_predicate.span);
+            if !bound_predicate.span.from_expansion();
             if let TyKind::Path(QPath::Resolved(_, Path { segments, .. })) = bound_predicate.bounded_ty.kind;
             if let Some(segment) = segments.first();
             if let Some(trait_resolutions_direct) = map.get(&segment.ident);
diff --git a/clippy_lints/src/try_err.rs b/clippy_lints/src/try_err.rs
index e9ec120a7f9..cc450b1e599 100644
--- a/clippy_lints/src/try_err.rs
+++ b/clippy_lints/src/try_err.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::source::{snippet, snippet_with_macro_callsite};
+use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{differing_macro_contexts, get_parent_expr, in_macro, is_lang_ctor, match_def_path, paths};
+use clippy_utils::{get_parent_expr, is_lang_ctor, match_def_path, paths};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::LangItem::ResultErr;
@@ -10,7 +10,7 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::{self, Ty};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::sym;
+use rustc_span::{hygiene, sym};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -93,15 +93,9 @@ impl<'tcx> LateLintPass<'tcx> for TryErr {
                 };
 
                 let expr_err_ty = cx.typeck_results().expr_ty(err_arg);
-                let differing_contexts = differing_macro_contexts(expr.span, err_arg.span);
-
-                let origin_snippet = if in_macro(expr.span) && in_macro(err_arg.span) && differing_contexts {
-                    snippet(cx, err_arg.span.ctxt().outer_expn_data().call_site, "_")
-                } else if err_arg.span.from_expansion() && !in_macro(expr.span) {
-                    snippet_with_macro_callsite(cx, err_arg.span, "_")
-                } else {
-                    snippet(cx, err_arg.span, "_")
-                };
+                let span = hygiene::walk_chain(err_arg.span, try_arg.span.ctxt());
+                let mut applicability = Applicability::MachineApplicable;
+                let origin_snippet = snippet_with_applicability(cx, span, "_", &mut applicability);
                 let ret_prefix = if get_parent_expr(cx, expr).map_or(false, |e| matches!(e.kind, ExprKind::Ret(_))) {
                     "" // already returns
                 } else {
@@ -120,7 +114,7 @@ impl<'tcx> LateLintPass<'tcx> for TryErr {
                     "returning an `Err(_)` with the `?` operator",
                     "try this",
                     suggestion,
-                    Applicability::MachineApplicable
+                    applicability,
                 );
             }
         }
diff --git a/clippy_lints/src/undocumented_unsafe_blocks.rs b/clippy_lints/src/undocumented_unsafe_blocks.rs
index 11aef50991b..99b33e5433f 100644
--- a/clippy_lints/src/undocumented_unsafe_blocks.rs
+++ b/clippy_lints/src/undocumented_unsafe_blocks.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg};
+use clippy_utils::is_lint_allowed;
 use clippy_utils::source::{indent_of, reindent_multiline, snippet};
-use clippy_utils::{in_macro, is_lint_allowed};
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
 use rustc_hir::{Block, BlockCheckMode, Expr, ExprKind, HirId, Local, UnsafeSource};
@@ -134,7 +134,7 @@ impl UndocumentedUnsafeBlocks {
 
         let enclosing_scope_span = map.opt_span(enclosing_hir_id)?;
 
-        let between_span = if in_macro(block_span) {
+        let between_span = if block_span.from_expansion() {
             self.macro_expansion = true;
             enclosing_scope_span.with_hi(block_span.hi())
         } else {
diff --git a/clippy_lints/src/unnecessary_wraps.rs b/clippy_lints/src/unnecessary_wraps.rs
index c940cf077d1..fcfa8403177 100644
--- a/clippy_lints/src/unnecessary_wraps.rs
+++ b/clippy_lints/src/unnecessary_wraps.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet;
-use clippy_utils::{contains_return, in_macro, is_lang_ctor, return_ty, visitors::find_all_ret_expressions};
+use clippy_utils::{contains_return, is_lang_ctor, return_ty, visitors::find_all_ret_expressions};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::FnKind;
@@ -116,7 +116,7 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryWraps {
         let mut suggs = Vec::new();
         let can_sugg = find_all_ret_expressions(cx, &body.value, |ret_expr| {
             if_chain! {
-                if !in_macro(ret_expr.span);
+                if !ret_expr.span.from_expansion();
                 // Check if a function call.
                 if let ExprKind::Call(func, [arg]) = ret_expr.kind;
                 // Check if OPTION_SOME or RESULT_OK, depending on return type.
diff --git a/clippy_lints/src/use_self.rs b/clippy_lints/src/use_self.rs
index 9ae50e47ca4..09aad296f03 100644
--- a/clippy_lints/src/use_self.rs
+++ b/clippy_lints/src/use_self.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::ty::same_type_and_consts;
-use clippy_utils::{in_macro, meets_msrv, msrvs};
+use clippy_utils::{meets_msrv, msrvs};
 use if_chain::if_chain;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Applicability;
@@ -197,7 +197,7 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
 
     fn check_ty(&mut self, cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>) {
         if_chain! {
-            if !in_macro(hir_ty.span);
+            if !hir_ty.span.from_expansion();
             if meets_msrv(self.msrv.as_ref(), &msrvs::TYPE_ALIAS_ENUM_VARIANTS);
             if let Some(&StackItem::Check {
                 impl_id,
@@ -214,8 +214,8 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
             };
             if same_type_and_consts(ty, cx.tcx.type_of(impl_id));
             let hir = cx.tcx.hir();
-            let id = hir.get_parent_node(hir_ty.hir_id);
-            if !hir.opt_span(id).map_or(false, in_macro);
+            // prevents false positive on `#[derive(serde::Deserialize)]`
+            if !hir.span(hir.get_parent_node(hir_ty.hir_id)).in_derive_expansion();
             then {
                 span_lint(cx, hir_ty.span);
             }
@@ -224,7 +224,7 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
 
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
         if_chain! {
-            if !in_macro(expr.span);
+            if !expr.span.from_expansion();
             if meets_msrv(self.msrv.as_ref(), &msrvs::TYPE_ALIAS_ENUM_VARIANTS);
             if let Some(&StackItem::Check { impl_id, .. }) = self.stack.last();
             if cx.typeck_results().expr_ty(expr) == cx.tcx.type_of(impl_id);
diff --git a/clippy_lints/src/wildcard_imports.rs b/clippy_lints/src/wildcard_imports.rs
index bafb9d3e3b1..2f3e525fdcf 100644
--- a/clippy_lints/src/wildcard_imports.rs
+++ b/clippy_lints/src/wildcard_imports.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::is_test_module_or_function;
 use clippy_utils::source::{snippet, snippet_with_applicability};
-use clippy_utils::{in_macro, is_test_module_or_function};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{
@@ -196,7 +196,7 @@ impl LateLintPass<'_> for WildcardImports {
 
 impl WildcardImports {
     fn check_exceptions(&self, item: &Item<'_>, segments: &[PathSegment<'_>]) -> bool {
-        in_macro(item.span)
+        item.span.from_expansion()
             || is_prelude_import(segments)
             || (is_super_only_import(segments) && self.test_modules_deep > 0)
     }
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 086fbc9d3dd..7799fd527cc 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -250,12 +250,6 @@ pub fn is_lang_ctor(cx: &LateContext<'_>, qpath: &QPath<'_>, lang_item: LangItem
     false
 }
 
-/// Returns `true` if this `span` was expanded by any macro.
-#[must_use]
-pub fn in_macro(span: Span) -> bool {
-    span.from_expansion() && !matches!(span.ctxt().outer_expn_data().kind, ExpnKind::Desugaring(..))
-}
-
 pub fn is_unit_expr(expr: &Expr<'_>) -> bool {
     matches!(
         expr.kind,
diff --git a/clippy_utils/src/usage.rs b/clippy_utils/src/usage.rs
index 34206b5ae2b..07883fdc454 100644
--- a/clippy_utils/src/usage.rs
+++ b/clippy_utils/src/usage.rs
@@ -179,7 +179,7 @@ impl<'tcx> Visitor<'tcx> for ReturnBreakContinueMacroVisitor {
             // desugaring, as this will detect a break if there's a while loop
             // or a for loop inside the expression.
             _ => {
-                if utils::in_macro(ex.span) {
+                if ex.span.from_expansion() {
                     self.seen_return_break_continue = true;
                 } else {
                     rustc_hir::intravisit::walk_expr(self, ex);
diff --git a/tests/ui-internal/if_chain_style.rs b/tests/ui-internal/if_chain_style.rs
index 8e871707aa8..e064fd188c8 100644
--- a/tests/ui-internal/if_chain_style.rs
+++ b/tests/ui-internal/if_chain_style.rs
@@ -1,5 +1,5 @@
 #![warn(clippy::if_chain_style)]
-#![allow(clippy::no_effect)]
+#![allow(clippy::no_effect, clippy::nonminimal_bool)]
 
 extern crate if_chain;
 
diff --git a/tests/ui/manual_assert.edition2018.fixed b/tests/ui/manual_assert.edition2018.fixed
index 11fe06c5724..6c2a25c37d8 100644
--- a/tests/ui/manual_assert.edition2018.fixed
+++ b/tests/ui/manual_assert.edition2018.fixed
@@ -2,7 +2,9 @@
 // [edition2018] edition:2018
 // [edition2021] edition:2021
 // run-rustfix
+
 #![warn(clippy::manual_assert)]
+#![allow(clippy::nonminimal_bool)]
 
 fn main() {
     let a = vec![1, 2, 3];
diff --git a/tests/ui/manual_assert.edition2018.stderr b/tests/ui/manual_assert.edition2018.stderr
index 03c03472f90..77511631e44 100644
--- a/tests/ui/manual_assert.edition2018.stderr
+++ b/tests/ui/manual_assert.edition2018.stderr
@@ -1,5 +1,5 @@
 error: only a `panic!` in `if`-then statement
-  --> $DIR/manual_assert.rs:22:5
+  --> $DIR/manual_assert.rs:24:5
    |
 LL | /     if !a.is_empty() {
 LL | |         panic!("qaqaq{:?}", a);
@@ -9,7 +9,7 @@ LL | |     }
    = note: `-D clippy::manual-assert` implied by `-D warnings`
 
 error: only a `panic!` in `if`-then statement
-  --> $DIR/manual_assert.rs:25:5
+  --> $DIR/manual_assert.rs:27:5
    |
 LL | /     if !a.is_empty() {
 LL | |         panic!("qwqwq");
@@ -17,7 +17,7 @@ LL | |     }
    | |_____^ help: try: `assert!(a.is_empty(), "qwqwq");`
 
 error: only a `panic!` in `if`-then statement
-  --> $DIR/manual_assert.rs:42:5
+  --> $DIR/manual_assert.rs:44:5
    |
 LL | /     if b.is_empty() {
 LL | |         panic!("panic1");
@@ -25,7 +25,7 @@ LL | |     }
    | |_____^ help: try: `assert!(!b.is_empty(), "panic1");`
 
 error: only a `panic!` in `if`-then statement
-  --> $DIR/manual_assert.rs:45:5
+  --> $DIR/manual_assert.rs:47:5
    |
 LL | /     if b.is_empty() && a.is_empty() {
 LL | |         panic!("panic2");
@@ -33,7 +33,7 @@ LL | |     }
    | |_____^ help: try: `assert!(!(b.is_empty() && a.is_empty()), "panic2");`
 
 error: only a `panic!` in `if`-then statement
-  --> $DIR/manual_assert.rs:48:5
+  --> $DIR/manual_assert.rs:50:5
    |
 LL | /     if a.is_empty() && !b.is_empty() {
 LL | |         panic!("panic3");
@@ -41,7 +41,7 @@ LL | |     }
    | |_____^ help: try: `assert!(!(a.is_empty() && !b.is_empty()), "panic3");`
 
 error: only a `panic!` in `if`-then statement
-  --> $DIR/manual_assert.rs:51:5
+  --> $DIR/manual_assert.rs:53:5
    |
 LL | /     if b.is_empty() || a.is_empty() {
 LL | |         panic!("panic4");
@@ -49,7 +49,7 @@ LL | |     }
    | |_____^ help: try: `assert!(!(b.is_empty() || a.is_empty()), "panic4");`
 
 error: only a `panic!` in `if`-then statement
-  --> $DIR/manual_assert.rs:54:5
+  --> $DIR/manual_assert.rs:56:5
    |
 LL | /     if a.is_empty() || !b.is_empty() {
 LL | |         panic!("panic5");
diff --git a/tests/ui/manual_assert.edition2021.fixed b/tests/ui/manual_assert.edition2021.fixed
index 11fe06c5724..6c2a25c37d8 100644
--- a/tests/ui/manual_assert.edition2021.fixed
+++ b/tests/ui/manual_assert.edition2021.fixed
@@ -2,7 +2,9 @@
 // [edition2018] edition:2018
 // [edition2021] edition:2021
 // run-rustfix
+
 #![warn(clippy::manual_assert)]
+#![allow(clippy::nonminimal_bool)]
 
 fn main() {
     let a = vec![1, 2, 3];
diff --git a/tests/ui/manual_assert.edition2021.stderr b/tests/ui/manual_assert.edition2021.stderr
index 03c03472f90..77511631e44 100644
--- a/tests/ui/manual_assert.edition2021.stderr
+++ b/tests/ui/manual_assert.edition2021.stderr
@@ -1,5 +1,5 @@
 error: only a `panic!` in `if`-then statement
-  --> $DIR/manual_assert.rs:22:5
+  --> $DIR/manual_assert.rs:24:5
    |
 LL | /     if !a.is_empty() {
 LL | |         panic!("qaqaq{:?}", a);
@@ -9,7 +9,7 @@ LL | |     }
    = note: `-D clippy::manual-assert` implied by `-D warnings`
 
 error: only a `panic!` in `if`-then statement
-  --> $DIR/manual_assert.rs:25:5
+  --> $DIR/manual_assert.rs:27:5
    |
 LL | /     if !a.is_empty() {
 LL | |         panic!("qwqwq");
@@ -17,7 +17,7 @@ LL | |     }
    | |_____^ help: try: `assert!(a.is_empty(), "qwqwq");`
 
 error: only a `panic!` in `if`-then statement
-  --> $DIR/manual_assert.rs:42:5
+  --> $DIR/manual_assert.rs:44:5
    |
 LL | /     if b.is_empty() {
 LL | |         panic!("panic1");
@@ -25,7 +25,7 @@ LL | |     }
    | |_____^ help: try: `assert!(!b.is_empty(), "panic1");`
 
 error: only a `panic!` in `if`-then statement
-  --> $DIR/manual_assert.rs:45:5
+  --> $DIR/manual_assert.rs:47:5
    |
 LL | /     if b.is_empty() && a.is_empty() {
 LL | |         panic!("panic2");
@@ -33,7 +33,7 @@ LL | |     }
    | |_____^ help: try: `assert!(!(b.is_empty() && a.is_empty()), "panic2");`
 
 error: only a `panic!` in `if`-then statement
-  --> $DIR/manual_assert.rs:48:5
+  --> $DIR/manual_assert.rs:50:5
    |
 LL | /     if a.is_empty() && !b.is_empty() {
 LL | |         panic!("panic3");
@@ -41,7 +41,7 @@ LL | |     }
    | |_____^ help: try: `assert!(!(a.is_empty() && !b.is_empty()), "panic3");`
 
 error: only a `panic!` in `if`-then statement
-  --> $DIR/manual_assert.rs:51:5
+  --> $DIR/manual_assert.rs:53:5
    |
 LL | /     if b.is_empty() || a.is_empty() {
 LL | |         panic!("panic4");
@@ -49,7 +49,7 @@ LL | |     }
    | |_____^ help: try: `assert!(!(b.is_empty() || a.is_empty()), "panic4");`
 
 error: only a `panic!` in `if`-then statement
-  --> $DIR/manual_assert.rs:54:5
+  --> $DIR/manual_assert.rs:56:5
    |
 LL | /     if a.is_empty() || !b.is_empty() {
 LL | |         panic!("panic5");
diff --git a/tests/ui/manual_assert.fixed b/tests/ui/manual_assert.fixed
index 11fe06c5724..6c2a25c37d8 100644
--- a/tests/ui/manual_assert.fixed
+++ b/tests/ui/manual_assert.fixed
@@ -2,7 +2,9 @@
 // [edition2018] edition:2018
 // [edition2021] edition:2021
 // run-rustfix
+
 #![warn(clippy::manual_assert)]
+#![allow(clippy::nonminimal_bool)]
 
 fn main() {
     let a = vec![1, 2, 3];
diff --git a/tests/ui/manual_assert.rs b/tests/ui/manual_assert.rs
index 8713426fc88..d3e0897488f 100644
--- a/tests/ui/manual_assert.rs
+++ b/tests/ui/manual_assert.rs
@@ -2,7 +2,9 @@
 // [edition2018] edition:2018
 // [edition2021] edition:2021
 // run-rustfix
+
 #![warn(clippy::manual_assert)]
+#![allow(clippy::nonminimal_bool)]
 
 fn main() {
     let a = vec![1, 2, 3];
-- 
cgit 1.4.1-3-g733a5


From 1c4dd8d3eb2204510599e090e3bef65f553d066f Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Tue, 2 Nov 2021 16:08:09 -0500
Subject: Remove trim_semicolon

---
 clippy_lints/src/format_args.rs | 11 ++---------
 1 file changed, 2 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/format_args.rs b/clippy_lints/src/format_args.rs
index 8b27442aa94..bb30accf145 100644
--- a/clippy_lints/src/format_args.rs
+++ b/clippy_lints/src/format_args.rs
@@ -10,7 +10,7 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::adjustment::{Adjust, Adjustment};
 use rustc_middle::ty::Ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::{sym, BytePos, ExpnData, ExpnKind, Span, Symbol};
+use rustc_span::{sym, ExpnData, ExpnKind, Span, Symbol};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -128,7 +128,7 @@ fn check_format_in_format_args(cx: &LateContext<'_>, call_site: Span, name: Symb
             span_lint_and_then(
                 cx,
                 FORMAT_IN_FORMAT_ARGS,
-                trim_semicolon(cx, call_site),
+                call_site,
                 &format!("`format!` in `{}!` args", name),
                 |diag| {
                     diag.help(&format!(
@@ -192,13 +192,6 @@ fn is_aliased(args: &[FormatArgsArg<'_>], i: usize) -> bool {
         .any(|(j, arg)| i != j && std::ptr::eq(value, arg.value))
 }
 
-fn trim_semicolon(cx: &LateContext<'_>, span: Span) -> Span {
-    snippet_opt(cx, span).map_or(span, |snippet| {
-        let snippet = snippet.trim_end_matches(';');
-        span.with_hi(span.lo() + BytePos(u32::try_from(snippet.len()).unwrap()))
-    })
-}
-
 fn count_needed_derefs<'tcx, I>(mut ty: Ty<'tcx>, mut iter: I) -> (usize, Ty<'tcx>)
 where
     I: Iterator<Item = &'tcx Adjustment<'tcx>>,
-- 
cgit 1.4.1-3-g733a5


From 5239a90f70c7e03660c2d9f4eb395de7dc7be37b Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Fri, 5 Nov 2021 13:41:31 -0500
Subject: Factor in some expr_visitor usages

---
 clippy_lints/src/eta_reduction.rs   |   6 +-
 clippy_lints/src/implicit_return.rs |  30 ++++----
 clippy_utils/src/lib.rs             |  71 +++++------------
 clippy_utils/src/ptr.rs             |  58 +++++---------
 clippy_utils/src/usage.rs           | 109 ++++++++------------------
 clippy_utils/src/visitors.rs        | 149 ++++++++----------------------------
 6 files changed, 120 insertions(+), 303 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/eta_reduction.rs b/clippy_lints/src/eta_reduction.rs
index 9247343b52a..8def6529b3b 100644
--- a/clippy_lints/src/eta_reduction.rs
+++ b/clippy_lints/src/eta_reduction.rs
@@ -1,8 +1,8 @@
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::higher::VecArgs;
 use clippy_utils::source::snippet_opt;
-use clippy_utils::usage::UsedAfterExprVisitor;
-use clippy_utils::{get_enclosing_loop_or_closure, higher, path_to_local_id};
+use clippy_utils::usage::local_used_after_expr;
+use clippy_utils::{get_enclosing_loop_or_closure, higher, path_to_local, path_to_local_id};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::def_id::DefId;
@@ -118,7 +118,7 @@ impl<'tcx> LateLintPass<'tcx> for EtaReduction {
                             if let ty::Closure(_, substs) = callee_ty.peel_refs().kind();
                             if substs.as_closure().kind() == ClosureKind::FnMut;
                             if get_enclosing_loop_or_closure(cx.tcx, expr).is_some()
-                                || UsedAfterExprVisitor::is_found(cx, callee);
+                                || path_to_local(callee).map_or(false, |l| local_used_after_expr(cx, l, callee));
 
                             then {
                                 // Mutable closure is used after current expr; we cannot consume it.
diff --git a/clippy_lints/src/implicit_return.rs b/clippy_lints/src/implicit_return.rs
index fa7b5302cb1..6d7c71d4082 100644
--- a/clippy_lints/src/implicit_return.rs
+++ b/clippy_lints/src/implicit_return.rs
@@ -2,10 +2,10 @@ use clippy_utils::{
     diagnostics::span_lint_and_sugg,
     get_async_fn_body, is_async_fn,
     source::{snippet_with_applicability, snippet_with_context, walk_span_to_context},
-    visitors::visit_break_exprs,
+    visitors::expr_visitor_no_bodies,
 };
 use rustc_errors::Applicability;
-use rustc_hir::intravisit::FnKind;
+use rustc_hir::intravisit::{FnKind, Visitor};
 use rustc_hir::{Block, Body, Expr, ExprKind, FnDecl, FnRetTy, HirId};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
@@ -144,20 +144,24 @@ fn lint_implicit_returns(
 
         ExprKind::Loop(block, ..) => {
             let mut add_return = false;
-            visit_break_exprs(block, |break_expr, dest, sub_expr| {
-                if dest.target_id.ok() == Some(expr.hir_id) {
-                    if call_site_span.is_none() && break_expr.span.ctxt() == ctxt {
-                        // At this point sub_expr can be `None` in async functions which either diverge, or return the
-                        // unit type.
-                        if let Some(sub_expr) = sub_expr {
-                            lint_break(cx, break_expr.span, sub_expr.span);
+            expr_visitor_no_bodies(|e| {
+                if let ExprKind::Break(dest, sub_expr) = e.kind {
+                    if dest.target_id.ok() == Some(expr.hir_id) {
+                        if call_site_span.is_none() && e.span.ctxt() == ctxt {
+                            // At this point sub_expr can be `None` in async functions which either diverge, or return
+                            // the unit type.
+                            if let Some(sub_expr) = sub_expr {
+                                lint_break(cx, e.span, sub_expr.span);
+                            }
+                        } else {
+                            // the break expression is from a macro call, add a return to the loop
+                            add_return = true;
                         }
-                    } else {
-                        // the break expression is from a macro call, add a return to the loop
-                        add_return = true;
                     }
                 }
-            });
+                true
+            })
+            .visit_block(block);
             if add_return {
                 #[allow(clippy::option_if_let_else)]
                 if let Some(span) = call_site_span {
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 7799fd527cc..e4e6c5ddbb2 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -1,6 +1,7 @@
 #![feature(box_patterns)]
 #![feature(in_band_lifetimes)]
 #![feature(iter_zip)]
+#![feature(let_else)]
 #![feature(rustc_private)]
 #![feature(control_flow_enum)]
 #![recursion_limit = "512"]
@@ -68,7 +69,7 @@ use rustc_hir as hir;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::def_id::DefId;
 use rustc_hir::hir_id::{HirIdMap, HirIdSet};
-use rustc_hir::intravisit::{self, walk_expr, ErasedMap, FnKind, NestedVisitorMap, Visitor};
+use rustc_hir::intravisit::{walk_expr, ErasedMap, FnKind, NestedVisitorMap, Visitor};
 use rustc_hir::itemlikevisit::ItemLikeVisitor;
 use rustc_hir::LangItem::{OptionNone, ResultErr, ResultOk};
 use rustc_hir::{
@@ -96,6 +97,7 @@ use rustc_target::abi::Integer;
 
 use crate::consts::{constant, Constant};
 use crate::ty::{can_partially_move_ty, is_copy, is_recursively_primitive_type};
+use crate::visitors::expr_visitor_no_bodies;
 
 pub fn parse_msrv(msrv: &str, sess: Option<&Session>, span: Option<Span>) -> Option<RustcVersion> {
     if let Ok(version) = RustcVersion::parse(msrv) {
@@ -1107,63 +1109,30 @@ pub fn contains_name(name: Symbol, expr: &Expr<'_>) -> bool {
 
 /// Returns `true` if `expr` contains a return expression
 pub fn contains_return(expr: &hir::Expr<'_>) -> bool {
-    struct RetCallFinder {
-        found: bool,
-    }
-
-    impl<'tcx> hir::intravisit::Visitor<'tcx> for RetCallFinder {
-        type Map = Map<'tcx>;
-
-        fn visit_expr(&mut self, expr: &'tcx hir::Expr<'_>) {
-            if self.found {
-                return;
-            }
+    let mut found = false;
+    expr_visitor_no_bodies(|expr| {
+        if !found {
             if let hir::ExprKind::Ret(..) = &expr.kind {
-                self.found = true;
-            } else {
-                hir::intravisit::walk_expr(self, expr);
+                found = true;
             }
         }
-
-        fn nested_visit_map(&mut self) -> hir::intravisit::NestedVisitorMap<Self::Map> {
-            hir::intravisit::NestedVisitorMap::None
-        }
-    }
-
-    let mut visitor = RetCallFinder { found: false };
-    visitor.visit_expr(expr);
-    visitor.found
-}
-
-struct FindMacroCalls<'a, 'b> {
-    names: &'a [&'b str],
-    result: Vec<Span>,
-}
-
-impl<'a, 'b, 'tcx> Visitor<'tcx> for FindMacroCalls<'a, 'b> {
-    type Map = Map<'tcx>;
-
-    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
-        if self.names.iter().any(|fun| is_expn_of(expr.span, fun).is_some()) {
-            self.result.push(expr.span);
-        }
-        // and check sub-expressions
-        intravisit::walk_expr(self, expr);
-    }
-
-    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-        NestedVisitorMap::None
-    }
+        !found
+    })
+    .visit_expr(expr);
+    found
 }
 
 /// Finds calls of the specified macros in a function body.
 pub fn find_macro_calls(names: &[&str], body: &Body<'_>) -> Vec<Span> {
-    let mut fmc = FindMacroCalls {
-        names,
-        result: Vec::new(),
-    };
-    fmc.visit_expr(&body.value);
-    fmc.result
+    let mut result = Vec::new();
+    expr_visitor_no_bodies(|expr| {
+        if names.iter().any(|fun| is_expn_of(expr.span, fun).is_some()) {
+            result.push(expr.span);
+        }
+        true
+    })
+    .visit_expr(&body.value);
+    result
 }
 
 /// Extends the span to the beginning of the spans line, incl. whitespaces.
diff --git a/clippy_utils/src/ptr.rs b/clippy_utils/src/ptr.rs
index 8adb6915952..17d9a505bc9 100644
--- a/clippy_utils/src/ptr.rs
+++ b/clippy_utils/src/ptr.rs
@@ -1,9 +1,9 @@
 use crate::source::snippet;
+use crate::visitors::expr_visitor_no_bodies;
 use crate::{path_to_local_id, strip_pat_refs};
-use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
-use rustc_hir::{Body, BodyId, Expr, ExprKind, HirId, PatKind};
+use rustc_hir::intravisit::Visitor;
+use rustc_hir::{Body, BodyId, ExprKind, HirId, PatKind};
 use rustc_lint::LateContext;
-use rustc_middle::hir::map::Map;
 use rustc_span::Span;
 use std::borrow::Cow;
 
@@ -30,50 +30,28 @@ fn extract_clone_suggestions<'tcx>(
     replace: &[(&'static str, &'static str)],
     body: &'tcx Body<'_>,
 ) -> Option<Vec<(Span, Cow<'static, str>)>> {
-    let mut visitor = PtrCloneVisitor {
-        cx,
-        id,
-        replace,
-        spans: vec![],
-        abort: false,
-    };
-    visitor.visit_body(body);
-    if visitor.abort { None } else { Some(visitor.spans) }
-}
-
-struct PtrCloneVisitor<'a, 'tcx> {
-    cx: &'a LateContext<'tcx>,
-    id: HirId,
-    replace: &'a [(&'static str, &'static str)],
-    spans: Vec<(Span, Cow<'static, str>)>,
-    abort: bool,
-}
-
-impl<'a, 'tcx> Visitor<'tcx> for PtrCloneVisitor<'a, 'tcx> {
-    type Map = Map<'tcx>;
-
-    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
-        if self.abort {
-            return;
+    let mut abort = false;
+    let mut spans = Vec::new();
+    expr_visitor_no_bodies(|expr| {
+        if abort {
+            return false;
         }
         if let ExprKind::MethodCall(seg, _, [recv], _) = expr.kind {
-            if path_to_local_id(recv, self.id) {
+            if path_to_local_id(recv, id) {
                 if seg.ident.name.as_str() == "capacity" {
-                    self.abort = true;
-                    return;
+                    abort = true;
+                    return false;
                 }
-                for &(fn_name, suffix) in self.replace {
+                for &(fn_name, suffix) in replace {
                     if seg.ident.name.as_str() == fn_name {
-                        self.spans.push((expr.span, snippet(self.cx, recv.span, "_") + suffix));
-                        return;
+                        spans.push((expr.span, snippet(cx, recv.span, "_") + suffix));
+                        return false;
                     }
                 }
             }
         }
-        walk_expr(self, expr);
-    }
-
-    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-        NestedVisitorMap::None
-    }
+        !abort
+    })
+    .visit_body(body);
+    if abort { None } else { Some(spans) }
 }
diff --git a/clippy_utils/src/usage.rs b/clippy_utils/src/usage.rs
index 07883fdc454..dfe8a66c2a1 100644
--- a/clippy_utils/src/usage.rs
+++ b/clippy_utils/src/usage.rs
@@ -1,7 +1,7 @@
 use crate as utils;
+use crate::visitors::{expr_visitor, expr_visitor_no_bodies};
 use rustc_hir as hir;
-use rustc_hir::intravisit;
-use rustc_hir::intravisit::{NestedVisitorMap, Visitor};
+use rustc_hir::intravisit::{self, Visitor};
 use rustc_hir::HirIdSet;
 use rustc_hir::{Expr, ExprKind, HirId};
 use rustc_infer::infer::TyCtxtInferExt;
@@ -148,96 +148,47 @@ impl<'a, 'tcx> intravisit::Visitor<'tcx> for BindingUsageFinder<'a, 'tcx> {
     }
 }
 
-struct ReturnBreakContinueMacroVisitor {
-    seen_return_break_continue: bool,
-}
-
-impl ReturnBreakContinueMacroVisitor {
-    fn new() -> ReturnBreakContinueMacroVisitor {
-        ReturnBreakContinueMacroVisitor {
-            seen_return_break_continue: false,
-        }
-    }
-}
-
-impl<'tcx> Visitor<'tcx> for ReturnBreakContinueMacroVisitor {
-    type Map = Map<'tcx>;
-    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-        NestedVisitorMap::None
-    }
-
-    fn visit_expr(&mut self, ex: &'tcx Expr<'tcx>) {
-        if self.seen_return_break_continue {
-            // No need to look farther if we've already seen one of them
-            return;
+pub fn contains_return_break_continue_macro(expression: &Expr<'_>) -> bool {
+    let mut seen_return_break_continue = false;
+    expr_visitor_no_bodies(|ex| {
+        if seen_return_break_continue {
+            return false;
         }
         match &ex.kind {
             ExprKind::Ret(..) | ExprKind::Break(..) | ExprKind::Continue(..) => {
-                self.seen_return_break_continue = true;
+                seen_return_break_continue = true;
             },
             // Something special could be done here to handle while or for loop
             // desugaring, as this will detect a break if there's a while loop
             // or a for loop inside the expression.
             _ => {
                 if ex.span.from_expansion() {
-                    self.seen_return_break_continue = true;
-                } else {
-                    rustc_hir::intravisit::walk_expr(self, ex);
+                    seen_return_break_continue = true;
                 }
             },
         }
-    }
-}
-
-pub fn contains_return_break_continue_macro(expression: &Expr<'_>) -> bool {
-    let mut recursive_visitor = ReturnBreakContinueMacroVisitor::new();
-    recursive_visitor.visit_expr(expression);
-    recursive_visitor.seen_return_break_continue
-}
-
-pub struct UsedAfterExprVisitor<'a, 'tcx> {
-    cx: &'a LateContext<'tcx>,
-    expr: &'tcx Expr<'tcx>,
-    definition: HirId,
-    past_expr: bool,
-    used_after_expr: bool,
-}
-impl<'a, 'tcx> UsedAfterExprVisitor<'a, 'tcx> {
-    pub fn is_found(cx: &'a LateContext<'tcx>, expr: &'tcx Expr<'_>) -> bool {
-        utils::path_to_local(expr).map_or(false, |definition| {
-            let mut visitor = UsedAfterExprVisitor {
-                cx,
-                expr,
-                definition,
-                past_expr: false,
-                used_after_expr: false,
-            };
-            utils::get_enclosing_block(cx, definition).map_or(false, |block| {
-                visitor.visit_block(block);
-                visitor.used_after_expr
-            })
-        })
-    }
-}
-
-impl<'a, 'tcx> intravisit::Visitor<'tcx> for UsedAfterExprVisitor<'a, 'tcx> {
-    type Map = Map<'tcx>;
-
-    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-        NestedVisitorMap::OnlyBodies(self.cx.tcx.hir())
-    }
-
-    fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) {
-        if self.used_after_expr {
-            return;
+        !seen_return_break_continue
+    })
+    .visit_expr(expression);
+    seen_return_break_continue
+}
+
+pub fn local_used_after_expr(cx: &LateContext<'_>, local_id: HirId, after: &Expr<'_>) -> bool {
+    let Some(block) = utils::get_enclosing_block(cx, local_id) else { return false };
+    let mut used_after_expr = false;
+    let mut past_expr = false;
+    expr_visitor(cx, |expr| {
+        if used_after_expr {
+            return false;
         }
 
-        if expr.hir_id == self.expr.hir_id {
-            self.past_expr = true;
-        } else if self.past_expr && utils::path_to_local_id(expr, self.definition) {
-            self.used_after_expr = true;
-        } else {
-            intravisit::walk_expr(self, expr);
+        if expr.hir_id == after.hir_id {
+            past_expr = true;
+        } else if past_expr && utils::path_to_local_id(expr, local_id) {
+            used_after_expr = true;
         }
-    }
+        !used_after_expr
+    })
+    .visit_block(block);
+    used_after_expr
 }
diff --git a/clippy_utils/src/visitors.rs b/clippy_utils/src/visitors.rs
index 4a3181dd027..988f6cf1d51 100644
--- a/clippy_utils/src/visitors.rs
+++ b/clippy_utils/src/visitors.rs
@@ -1,10 +1,9 @@
 use crate::path_to_local_id;
 use rustc_hir as hir;
-use rustc_hir::intravisit::{self, walk_expr, ErasedMap, NestedVisitorMap, Visitor};
-use rustc_hir::{def::Res, Arm, Block, Body, BodyId, Destination, Expr, ExprKind, HirId, Stmt};
+use rustc_hir::intravisit::{self, walk_expr, NestedVisitorMap, Visitor};
+use rustc_hir::{def::Res, Arm, Block, Body, BodyId, Expr, ExprKind, HirId, Stmt};
 use rustc_lint::LateContext;
 use rustc_middle::hir::map::Map;
-use std::ops::ControlFlow;
 
 /// Convenience method for creating a `Visitor` with just `visit_expr` overridden and nested
 /// bodies (i.e. closures) are visited.
@@ -53,31 +52,15 @@ pub fn expr_visitor_no_bodies<'tcx>(f: impl FnMut(&'tcx Expr<'tcx>) -> bool) ->
 
 /// returns `true` if expr contains match expr desugared from try
 fn contains_try(expr: &hir::Expr<'_>) -> bool {
-    struct TryFinder {
-        found: bool,
-    }
-
-    impl<'hir> intravisit::Visitor<'hir> for TryFinder {
-        type Map = Map<'hir>;
-
-        fn nested_visit_map(&mut self) -> intravisit::NestedVisitorMap<Self::Map> {
-            intravisit::NestedVisitorMap::None
-        }
-
-        fn visit_expr(&mut self, expr: &'hir hir::Expr<'hir>) {
-            if self.found {
-                return;
-            }
-            match expr.kind {
-                hir::ExprKind::Match(_, _, hir::MatchSource::TryDesugar) => self.found = true,
-                _ => intravisit::walk_expr(self, expr),
-            }
-        }
-    }
-
-    let mut visitor = TryFinder { found: false };
-    visitor.visit_expr(expr);
-    visitor.found
+    let mut found = false;
+    expr_visitor_no_bodies(|e| {
+        if !found {
+            found = matches!(e.kind, hir::ExprKind::Match(_, _, hir::MatchSource::TryDesugar));
+        }
+        !found
+    })
+    .visit_expr(expr);
+    found
 }
 
 pub fn find_all_ret_expressions<'hir, F>(_cx: &LateContext<'_>, expr: &'hir hir::Expr<'hir>, callback: F) -> bool
@@ -210,103 +193,35 @@ visitable_ref!(Stmt, visit_stmt);
 //     }
 // }
 
-/// Calls the given function for each break expression.
-pub fn visit_break_exprs<'tcx>(
-    node: impl Visitable<'tcx>,
-    f: impl FnMut(&'tcx Expr<'tcx>, Destination, Option<&'tcx Expr<'tcx>>),
-) {
-    struct V<F>(F);
-    impl<'tcx, F: FnMut(&'tcx Expr<'tcx>, Destination, Option<&'tcx Expr<'tcx>>)> Visitor<'tcx> for V<F> {
-        type Map = ErasedMap<'tcx>;
-        fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-            NestedVisitorMap::None
-        }
-
-        fn visit_expr(&mut self, e: &'tcx Expr<'_>) {
-            if let ExprKind::Break(dest, sub_expr) = e.kind {
-                self.0(e, dest, sub_expr);
-            }
-            walk_expr(self, e);
-        }
-    }
-
-    node.visit(&mut V(f));
-}
-
 /// Checks if the given resolved path is used in the given body.
 pub fn is_res_used(cx: &LateContext<'_>, res: Res, body: BodyId) -> bool {
-    struct V<'a, 'tcx> {
-        cx: &'a LateContext<'tcx>,
-        res: Res,
-        found: bool,
-    }
-    impl Visitor<'tcx> for V<'_, 'tcx> {
-        type Map = Map<'tcx>;
-        fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-            NestedVisitorMap::OnlyBodies(self.cx.tcx.hir())
-        }
-
-        fn visit_expr(&mut self, e: &'tcx Expr<'_>) {
-            if self.found {
-                return;
-            }
-
-            if let ExprKind::Path(p) = &e.kind {
-                if self.cx.qpath_res(p, e.hir_id) == self.res {
-                    self.found = true;
-                }
-            } else {
-                walk_expr(self, e);
-            }
-        }
-    }
-
-    let mut v = V { cx, res, found: false };
-    v.visit_expr(&cx.tcx.hir().body(body).value);
-    v.found
-}
-
-/// Calls the given function for each usage of the given local.
-pub fn for_each_local_usage<'tcx, B>(
-    cx: &LateContext<'tcx>,
-    visitable: impl Visitable<'tcx>,
-    id: HirId,
-    f: impl FnMut(&'tcx Expr<'tcx>) -> ControlFlow<B>,
-) -> ControlFlow<B> {
-    struct V<'tcx, B, F> {
-        map: Map<'tcx>,
-        id: HirId,
-        f: F,
-        res: ControlFlow<B>,
-    }
-    impl<'tcx, B, F: FnMut(&'tcx Expr<'tcx>) -> ControlFlow<B>> Visitor<'tcx> for V<'tcx, B, F> {
-        type Map = Map<'tcx>;
-        fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-            NestedVisitorMap::OnlyBodies(self.map)
+    let mut found = false;
+    expr_visitor(cx, |e| {
+        if found {
+            return false;
         }
 
-        fn visit_expr(&mut self, e: &'tcx Expr<'_>) {
-            if self.res.is_continue() {
-                if path_to_local_id(e, self.id) {
-                    self.res = (self.f)(e);
-                } else {
-                    walk_expr(self, e);
-                }
+        if let ExprKind::Path(p) = &e.kind {
+            if cx.qpath_res(p, e.hir_id) == res {
+                found = true;
             }
         }
-    }
-
-    let mut v = V {
-        map: cx.tcx.hir(),
-        id,
-        f,
-        res: ControlFlow::CONTINUE,
-    };
-    visitable.visit(&mut v);
-    v.res
+        !found
+    })
+    .visit_expr(&cx.tcx.hir().body(body).value);
+    found
 }
 
 /// Checks if the given local is used.
 pub fn is_local_used(cx: &LateContext<'tcx>, visitable: impl Visitable<'tcx>, id: HirId) -> bool {
-    for_each_local_usage(cx, visitable, id, |_| ControlFlow::BREAK).is_break()
+    let mut is_used = false;
+    let mut visitor = expr_visitor(cx, |expr| {
+        if !is_used {
+            is_used = path_to_local_id(expr, id);
+        }
+        !is_used
+    });
+    visitable.visit(&mut visitor);
+    drop(visitor);
+    is_used
 }
-- 
cgit 1.4.1-3-g733a5


From 2c7b7e8c56849d272dc7acbd5f0ad0ec02c06e52 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Fri, 5 Nov 2021 14:50:22 -0500
Subject: Remove if let check for match_ref_pats

---
 clippy_lints/src/matches.rs | 3 ---
 1 file changed, 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index 08b652f4f3f..88b1685f52f 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -632,9 +632,6 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
         if let ExprKind::Match(ex, arms, _) = expr.kind {
             check_match_ref_pats(cx, ex, arms.iter().map(|el| el.pat), expr);
         }
-        if let Some(higher::IfLet { let_pat, let_expr, .. }) = higher::IfLet::hir(cx, expr) {
-            check_match_ref_pats(cx, let_expr, once(let_pat), expr);
-        }
     }
 
     fn check_local(&mut self, cx: &LateContext<'tcx>, local: &'tcx Local<'_>) {
-- 
cgit 1.4.1-3-g733a5


From c96cd359f532bb37865ef91d0935655a0af7e7f4 Mon Sep 17 00:00:00 2001
From: Serial <69764315+Serial-ATA@users.noreply.github.com>
Date: Thu, 28 Oct 2021 21:39:41 -0400
Subject: Extend author lint

---
 clippy_lints/src/utils/author.rs | 611 ++++++++++++++++++++++++++++++---------
 tests/ui/author.stdout           |   2 +-
 tests/ui/author/blocks.rs        |   9 +
 tests/ui/author/blocks.stdout    |  34 ++-
 tests/ui/author/call.stdout      |   4 +-
 tests/ui/author/for_loop.rs      |   8 -
 tests/ui/author/for_loop.stdout  |  64 ----
 tests/ui/author/if.rs            |   7 +
 tests/ui/author/if.stdout        |  40 ++-
 tests/ui/author/loop.rs          |  36 +++
 tests/ui/author/loop.stdout      | 112 +++++++
 tests/ui/author/matches.stdout   |  14 +-
 tests/ui/author/repeat.rs        |   5 +
 tests/ui/author/repeat.stdout    |  10 +
 tests/ui/author/struct.rs        |  40 +++
 tests/ui/author/struct.stdout    |  61 ++++
 16 files changed, 827 insertions(+), 230 deletions(-)
 delete mode 100644 tests/ui/author/for_loop.rs
 delete mode 100644 tests/ui/author/for_loop.stdout
 create mode 100644 tests/ui/author/loop.rs
 create mode 100644 tests/ui/author/loop.stdout
 create mode 100644 tests/ui/author/repeat.rs
 create mode 100644 tests/ui/author/repeat.stdout
 create mode 100644 tests/ui/author/struct.rs
 create mode 100644 tests/ui/author/struct.stdout

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/author.rs b/clippy_lints/src/utils/author.rs
index f93d7782e25..38157cc16ef 100644
--- a/clippy_lints/src/utils/author.rs
+++ b/clippy_lints/src/utils/author.rs
@@ -1,13 +1,13 @@
 //! A group of attributes that can be attached to Rust code in order
 //! to generate a clippy lint detecting said code automatically.
 
-use clippy_utils::get_attr;
+use clippy_utils::{get_attr, higher};
 use rustc_ast::ast::{LitFloatType, LitKind};
-use rustc_ast::walk_list;
+use rustc_ast::{walk_list, Label, LitIntType};
 use rustc_data_structures::fx::FxHashMap;
 use rustc_hir as hir;
 use rustc_hir::intravisit::{NestedVisitorMap, Visitor};
-use rustc_hir::{Block, Expr, ExprKind, Pat, PatKind, QPath, Stmt, StmtKind, TyKind};
+use rustc_hir::{Arm, Block, Expr, ExprKind, FnRetTy, Lit, MatchSource, Pat, PatKind, QPath, Stmt, StmtKind, TyKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::hir::map::Map;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -70,7 +70,7 @@ impl<'tcx> LateLintPass<'tcx> for Author {
             return;
         }
         prelude();
-        PrintVisitor::new("item").visit_item(item);
+        PrintVisitor::new("item", cx).visit_item(item);
         done();
     }
 
@@ -79,7 +79,7 @@ impl<'tcx> LateLintPass<'tcx> for Author {
             return;
         }
         prelude();
-        PrintVisitor::new("item").visit_impl_item(item);
+        PrintVisitor::new("item", cx).visit_impl_item(item);
         done();
     }
 
@@ -88,7 +88,7 @@ impl<'tcx> LateLintPass<'tcx> for Author {
             return;
         }
         prelude();
-        PrintVisitor::new("item").visit_trait_item(item);
+        PrintVisitor::new("item", cx).visit_trait_item(item);
         done();
     }
 
@@ -98,7 +98,7 @@ impl<'tcx> LateLintPass<'tcx> for Author {
         }
         prelude();
         let parent_hir_id = cx.tcx.hir().get_parent_node(var.id);
-        PrintVisitor::new("var").visit_variant(var, &hir::Generics::empty(), parent_hir_id);
+        PrintVisitor::new("var", cx).visit_variant(var, &hir::Generics::empty(), parent_hir_id);
         done();
     }
 
@@ -107,7 +107,7 @@ impl<'tcx> LateLintPass<'tcx> for Author {
             return;
         }
         prelude();
-        PrintVisitor::new("field").visit_field_def(field);
+        PrintVisitor::new("field", cx).visit_field_def(field);
         done();
     }
 
@@ -116,7 +116,7 @@ impl<'tcx> LateLintPass<'tcx> for Author {
             return;
         }
         prelude();
-        PrintVisitor::new("expr").visit_expr(expr);
+        PrintVisitor::new("expr", cx).visit_expr(expr);
         done();
     }
 
@@ -125,7 +125,7 @@ impl<'tcx> LateLintPass<'tcx> for Author {
             return;
         }
         prelude();
-        PrintVisitor::new("arm").visit_arm(arm);
+        PrintVisitor::new("arm", cx).visit_arm(arm);
         done();
     }
 
@@ -138,7 +138,7 @@ impl<'tcx> LateLintPass<'tcx> for Author {
             _ => {},
         }
         prelude();
-        PrintVisitor::new("stmt").visit_stmt(stmt);
+        PrintVisitor::new("stmt", cx).visit_stmt(stmt);
         done();
     }
 
@@ -147,17 +147,18 @@ impl<'tcx> LateLintPass<'tcx> for Author {
             return;
         }
         prelude();
-        PrintVisitor::new("item").visit_foreign_item(item);
+        PrintVisitor::new("item", cx).visit_foreign_item(item);
         done();
     }
 }
 
-impl PrintVisitor {
+impl<'a, 'tcx> PrintVisitor<'a, 'tcx> {
     #[must_use]
-    fn new(s: &'static str) -> Self {
+    fn new(s: &'static str, cx: &'a LateContext<'tcx>) -> Self {
         Self {
             ids: FxHashMap::default(),
             current: s.to_owned(),
+            cx,
         }
     }
 
@@ -190,43 +191,299 @@ impl PrintVisitor {
             println!("]);");
         }
     }
+
+    fn print_label(&mut self, label: Option<Label>) {
+        if let Some(label) = label {
+            let label_bind = self.next("label");
+
+            println!("    if let Some(ref {}) = {}", label_bind, self.current);
+
+            let label_name_bind = self.next("label_name");
+            let label_name = label.ident.name;
+
+            println!(
+                "    if {}.ident.name.as_str() == {:?};",
+                label_name_bind,
+                label_name.as_str()
+            );
+        }
+    }
+
+    fn print_lit_expr(&mut self, lit: &Lit, current: &str) {
+        let lit_pat = self.next("lit");
+
+        println!("Lit(ref {}) = {};", lit_pat, current);
+
+        match lit.node {
+            LitKind::Bool(val) => println!("    if let LitKind::Bool({:?}) = {}.node;", val, lit_pat),
+            LitKind::Char(c) => println!("    if let LitKind::Char({:?}) = {}.node;", c, lit_pat),
+            LitKind::Err(val) => println!("    if let LitKind::Err({}) = {}.node;", val, lit_pat),
+            LitKind::Byte(b) => println!("    if let LitKind::Byte({}) = {}.node;", b, lit_pat),
+            LitKind::Int(i, suffix) => {
+                let int_ty = match suffix {
+                    LitIntType::Signed(int_ty) => format!("LitIntType::Signed(IntTy::{:?})", int_ty),
+                    LitIntType::Unsigned(uint_ty) => format!("LitIntType::Unsigned(UintTy::{:?})", uint_ty),
+                    LitIntType::Unsuffixed => String::from("LitIntType::Unsuffixed"),
+                };
+
+                println!("    if let LitKind::Int({}, {}) = {}.node;", i, int_ty, lit_pat);
+            },
+            LitKind::Float(_, suffix) => {
+                let float_ty = match suffix {
+                    LitFloatType::Suffixed(suffix_ty) => format!("LitFloatType::Suffixed(FloatTy::{:?})", suffix_ty),
+                    LitFloatType::Unsuffixed => String::from("LitFloatType::Unsuffixed"),
+                };
+
+                println!("    if let LitKind::Float(_, {}) = {}.node;", float_ty, lit_pat);
+            },
+            LitKind::ByteStr(ref vec) => {
+                let vec_pat = self.next("vec");
+
+                println!("    if let LitKind::ByteStr(ref {}) = {}.node;", vec_pat, lit_pat);
+                println!("    if let [{:?}] = **{};", vec, vec_pat);
+            },
+            LitKind::Str(ref text, _) => {
+                let str_pat = self.next("s");
+
+                println!("    if let LitKind::Str(ref {}, _) = {}.node;", str_pat, lit_pat);
+                println!("    if {}.as_str() == {:?}", str_pat, &*text.as_str());
+            },
+        }
+    }
+
+    fn print_match_expr(&mut self, expr: &Expr<'_>, arms: &[Arm<'_>], des: MatchSource, current: &str) {
+        let expr_pat = self.next("expr");
+        let arms_pat = self.next("arms");
+
+        println!(
+            "Match(ref {}, ref {}, MatchSource::{:?}) = {};",
+            expr_pat, arms_pat, des, current
+        );
+
+        self.current = expr_pat;
+        self.visit_expr(expr);
+
+        println!("    if {}.len() == {};", arms_pat, arms.len());
+
+        for (i, arm) in arms.iter().enumerate() {
+            self.current = format!("{}[{}].body", arms_pat, i);
+            self.visit_expr(arm.body);
+
+            if let Some(ref guard) = arm.guard {
+                let guard_pat = self.next("guard");
+
+                println!("    if let Some(ref {}) = {}[{}].guard;", guard_pat, arms_pat, i);
+
+                match guard {
+                    hir::Guard::If(if_expr) => {
+                        let if_expr_pat = self.next("expr");
+
+                        println!("    if let Guard::If(ref {}) = {};", if_expr_pat, guard_pat);
+
+                        self.current = if_expr_pat;
+                        self.visit_expr(if_expr);
+                    },
+                    hir::Guard::IfLet(if_let_pat, if_let_expr) => {
+                        let if_let_pat_pat = self.next("pat");
+                        let if_let_expr_pat = self.next("expr");
+
+                        println!(
+                            "    if let Guard::IfLet(ref {}, ref {}) = {};",
+                            if_let_pat_pat, if_let_expr_pat, guard_pat
+                        );
+
+                        self.current = if_let_expr_pat;
+                        self.visit_expr(if_let_expr);
+
+                        self.current = if_let_pat_pat;
+                        self.visit_pat(if_let_pat);
+                    },
+                }
+            }
+            self.current = format!("{}[{}].pat", arms_pat, i);
+            self.visit_pat(arm.pat);
+        }
+    }
+
+    fn check_higher(&mut self, expr: &Expr<'_>) -> bool {
+        if let Some(higher::While { condition, body }) = higher::While::hir(expr) {
+            let condition_pat = self.next("condition");
+            let body_pat = self.next("body");
+
+            println!(
+                "    if let Some(higher::While {{ condition: {}, body: {} }}) = higher::While::hir({})",
+                condition_pat, body_pat, self.current
+            );
+
+            self.current = condition_pat;
+            self.visit_expr(condition);
+
+            self.current = body_pat;
+            self.visit_expr(body);
+
+            return true;
+        }
+
+        if let Some(higher::WhileLet {
+            let_pat,
+            let_expr,
+            if_then,
+        }) = higher::WhileLet::hir(expr)
+        {
+            let let_pat_ = self.next("let_pat");
+            let let_expr_pat = self.next("let_expr");
+            let if_then_pat = self.next("if_then");
+
+            println!(
+                "    if let Some(higher::WhileLet {{ let_pat: {}, let_expr: {}, if_then: {} }}) = higher::WhileLet::hir({})",
+                let_pat_, let_expr_pat, if_then_pat, self.current
+            );
+
+            self.current = let_pat_;
+            self.visit_pat(let_pat);
+
+            self.current = let_expr_pat;
+            self.visit_expr(let_expr);
+
+            self.current = if_then_pat;
+            self.visit_expr(if_then);
+
+            return true;
+        }
+
+        if let Some(higher::IfLet {
+            let_pat,
+            let_expr,
+            if_then,
+            if_else,
+        }) = higher::IfLet::hir(self.cx, expr)
+        {
+            let let_pat_ = self.next("let_pat");
+            let let_expr_pat = self.next("let_expr");
+            let if_then_pat = self.next("if_then");
+            let else_pat = self.next("else_expr");
+
+            println!(
+                "    if let Some(higher::IfLet {{ let_pat: {}, let_expr: {}, if_then: {}, if_else: {}}}) = higher::IfLet::hir({})",
+                let_pat_, let_expr_pat, if_then_pat, else_pat, self.current
+            );
+
+            self.current = let_pat_;
+            self.visit_pat(let_pat);
+
+            self.current = let_expr_pat;
+            self.visit_expr(let_expr);
+
+            self.current = if_then_pat;
+            self.visit_expr(if_then);
+
+            if let Some(else_expr) = if_else {
+                self.current = else_pat;
+                self.visit_expr(else_expr);
+            }
+
+            return true;
+        }
+
+        if let Some(higher::If { cond, then, r#else }) = higher::If::hir(expr) {
+            let cond_pat = self.next("cond");
+            let then_pat = self.next("then");
+            let else_pat = self.next("else_expr");
+
+            println!(
+                "    if let Some(higher::If {{ cond: {}, then: {}, r#else: {}}}) = higher::If::hir({})",
+                cond_pat, then_pat, else_pat, self.current
+            );
+
+            self.current = cond_pat;
+            self.visit_expr(cond);
+
+            self.current = then_pat;
+            self.visit_expr(then);
+
+            if let Some(else_expr) = r#else {
+                self.current = else_pat;
+                self.visit_expr(else_expr);
+            }
+
+            return true;
+        }
+
+        if let Some(higher::ForLoop { pat, arg, body, .. }) = higher::ForLoop::hir(expr) {
+            let pat_ = self.next("pat");
+            let arg_pat = self.next("arg");
+            let body_pat = self.next("body");
+
+            println!(
+                "    if let Some(higher::ForLoop {{ pat: {}, arg: {}, body: {}, ..}}) = higher::ForLoop::hir({})",
+                pat_, arg_pat, body_pat, self.current
+            );
+
+            self.current = pat_;
+            self.visit_pat(pat);
+
+            self.current = arg_pat;
+            self.visit_expr(arg);
+
+            self.current = body_pat;
+            self.visit_expr(body);
+
+            return true;
+        }
+
+        false
+    }
 }
 
-struct PrintVisitor {
+struct PrintVisitor<'a, 'tcx> {
     /// Fields are the current index that needs to be appended to pattern
     /// binding names
     ids: FxHashMap<&'static str, usize>,
     /// the name that needs to be destructured
     current: String,
+    cx: &'a LateContext<'tcx>,
 }
 
-impl<'tcx> Visitor<'tcx> for PrintVisitor {
+impl<'a, 'tcx> Visitor<'tcx> for PrintVisitor<'a, '_> {
     type Map = Map<'tcx>;
 
     #[allow(clippy::too_many_lines)]
     fn visit_expr(&mut self, expr: &Expr<'_>) {
+        if self.check_higher(expr) {
+            return;
+        }
+
         print!("    if let ExprKind::");
         let current = format!("{}.kind", self.current);
+
         match expr.kind {
             ExprKind::Let(pat, expr, _) => {
                 let let_pat = self.next("pat");
                 let let_expr = self.next("expr");
-                println!("    Let(ref {}, ref {}, _) = {};", let_pat, let_expr, current);
+
+                println!("Let(ref {}, ref {}, _) = {};", let_pat, let_expr, current);
+
                 self.current = let_expr;
                 self.visit_expr(expr);
+
                 self.current = let_pat;
                 self.visit_pat(pat);
             },
             ExprKind::Box(inner) => {
                 let inner_pat = self.next("inner");
+
                 println!("Box(ref {}) = {};", inner_pat, current);
+
                 self.current = inner_pat;
                 self.visit_expr(inner);
             },
             ExprKind::Array(elements) => {
                 let elements_pat = self.next("elements");
+
                 println!("Array(ref {}) = {};", elements_pat, current);
+
                 println!("    if {}.len() == {};", elements_pat, elements.len());
+
                 for (i, element) in elements.iter().enumerate() {
                     self.current = format!("{}[{}]", elements_pat, i);
                     self.visit_expr(element);
@@ -235,26 +492,48 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor {
             ExprKind::Call(func, args) => {
                 let func_pat = self.next("func");
                 let args_pat = self.next("args");
+
                 println!("Call(ref {}, ref {}) = {};", func_pat, args_pat, current);
+
                 self.current = func_pat;
                 self.visit_expr(func);
+
                 println!("    if {}.len() == {};", args_pat, args.len());
+
                 for (i, arg) in args.iter().enumerate() {
                     self.current = format!("{}[{}]", args_pat, i);
                     self.visit_expr(arg);
                 }
             },
-            ExprKind::MethodCall(_method_name, ref _generics, _args, ref _fn_span) => {
+            ExprKind::MethodCall(method_name, _, args, _) => {
+                let method_name_pat = self.next("method_name");
+                let args_pat = self.next("args");
+
                 println!(
-                    "MethodCall(ref method_name, ref generics, ref args, ref fn_span) = {};",
-                    current
+                    "MethodCall(ref {}, ref {}, _) = {};",
+                    method_name_pat, args_pat, current
                 );
-                println!("    // unimplemented: `ExprKind::MethodCall` is not further destructured at the moment");
+
+                println!(
+                    "    if {}.ident.name.as_str() == {};",
+                    method_name_pat,
+                    method_name.ident.name.as_str()
+                );
+
+                println!("    if {}.len() == {};", args_pat, args.len());
+
+                for (i, arg) in args.iter().enumerate() {
+                    self.current = format!("{}[{}]", args_pat, i);
+                    self.visit_expr(arg);
+                }
             },
             ExprKind::Tup(elements) => {
                 let elements_pat = self.next("elements");
+
                 println!("Tup(ref {}) = {};", elements_pat, current);
+
                 println!("    if {}.len() == {};", elements_pat, elements.len());
+
                 for (i, element) in elements.iter().enumerate() {
                     self.current = format!("{}[{}]", elements_pat, i);
                     self.visit_expr(element);
@@ -264,167 +543,136 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor {
                 let op_pat = self.next("op");
                 let left_pat = self.next("left");
                 let right_pat = self.next("right");
+
                 println!(
                     "Binary(ref {}, ref {}, ref {}) = {};",
                     op_pat, left_pat, right_pat, current
                 );
+
                 println!("    if BinOpKind::{:?} == {}.node;", op.node, op_pat);
+
                 self.current = left_pat;
                 self.visit_expr(left);
+
                 self.current = right_pat;
                 self.visit_expr(right);
             },
             ExprKind::Unary(ref op, inner) => {
                 let inner_pat = self.next("inner");
+
                 println!("Unary(UnOp::{:?}, ref {}) = {};", op, inner_pat, current);
+
                 self.current = inner_pat;
                 self.visit_expr(inner);
             },
-            ExprKind::Lit(ref lit) => {
-                let lit_pat = self.next("lit");
-                println!("Lit(ref {}) = {};", lit_pat, current);
-                match lit.node {
-                    LitKind::Bool(val) => println!("    if let LitKind::Bool({:?}) = {}.node;", val, lit_pat),
-                    LitKind::Char(c) => println!("    if let LitKind::Char({:?}) = {}.node;", c, lit_pat),
-                    LitKind::Err(val) => println!("    if let LitKind::Err({}) = {}.node;", val, lit_pat),
-                    LitKind::Byte(b) => println!("    if let LitKind::Byte({}) = {}.node;", b, lit_pat),
-                    // FIXME: also check int type
-                    LitKind::Int(i, _) => println!("    if let LitKind::Int({}, _) = {}.node;", i, lit_pat),
-                    LitKind::Float(_, LitFloatType::Suffixed(_)) => println!(
-                        "    if let LitKind::Float(_, LitFloatType::Suffixed(_)) = {}.node;",
-                        lit_pat
-                    ),
-                    LitKind::Float(_, LitFloatType::Unsuffixed) => println!(
-                        "    if let LitKind::Float(_, LitFloatType::Unsuffixed) = {}.node;",
-                        lit_pat
-                    ),
-                    LitKind::ByteStr(ref vec) => {
-                        let vec_pat = self.next("vec");
-                        println!("    if let LitKind::ByteStr(ref {}) = {}.node;", vec_pat, lit_pat);
-                        println!("    if let [{:?}] = **{};", vec, vec_pat);
-                    },
-                    LitKind::Str(ref text, _) => {
-                        let str_pat = self.next("s");
-                        println!("    if let LitKind::Str(ref {}, _) = {}.node;", str_pat, lit_pat);
-                        println!("    if {}.as_str() == {:?}", str_pat, &*text.as_str());
-                    },
-                }
-            },
+            ExprKind::Lit(ref lit) => self.print_lit_expr(lit, &current),
             ExprKind::Cast(expr, ty) => {
                 let cast_pat = self.next("expr");
                 let cast_ty = self.next("cast_ty");
                 let qp_label = self.next("qp");
 
                 println!("Cast(ref {}, ref {}) = {};", cast_pat, cast_ty, current);
+
                 if let TyKind::Path(ref qp) = ty.kind {
                     println!("    if let TyKind::Path(ref {}) = {}.kind;", qp_label, cast_ty);
+
                     self.current = qp_label;
                     self.print_qpath(qp);
                 }
+
                 self.current = cast_pat;
                 self.visit_expr(expr);
             },
             ExprKind::Type(expr, _ty) => {
                 let cast_pat = self.next("expr");
+
                 println!("Type(ref {}, _) = {};", cast_pat, current);
+
                 self.current = cast_pat;
                 self.visit_expr(expr);
             },
-            ExprKind::Loop(body, _, des, _) => {
+            ExprKind::Loop(body, label, des, _) => {
                 let body_pat = self.next("body");
                 let label_pat = self.next("label");
+
                 println!(
                     "Loop(ref {}, ref {}, LoopSource::{:?}) = {};",
                     body_pat, label_pat, des, current
                 );
+
                 self.current = body_pat;
                 self.visit_block(body);
+
+                self.current = label_pat;
+                self.print_label(label);
             },
-            ExprKind::If(cond, then, ref opt_else) => {
-                let cond_pat = self.next("cond");
-                let then_pat = self.next("then");
-                if let Some(else_) = *opt_else {
-                    let else_pat = self.next("else_");
-                    println!(
-                        "If(ref {}, ref {}, Some(ref {})) = {};",
-                        cond_pat, then_pat, else_pat, current
-                    );
-                    self.current = else_pat;
-                    self.visit_expr(else_);
+            ExprKind::If(_, _, _) => {}, // Covered by check_higher
+            ExprKind::Match(match_expr, arms, des) => self.print_match_expr(match_expr, arms, des, &current),
+            ExprKind::Closure(capture_clause, fn_decl, body_id, _, movability) => {
+                let capture_by = format!("CaptureBy::{:?}", capture_clause);
+
+                let movability = if let Some(movability) = movability {
+                    format!("Some(Movability::{:?})", movability)
                 } else {
-                    println!("If(ref {}, ref {}, None) = {};", cond_pat, then_pat, current);
-                }
-                self.current = cond_pat;
-                self.visit_expr(cond);
-                self.current = then_pat;
-                self.visit_expr(then);
-            },
-            ExprKind::Match(expr, arms, des) => {
-                let expr_pat = self.next("expr");
-                let arms_pat = self.next("arms");
+                    String::from("None")
+                };
+
+                let ret_ty = match fn_decl.output {
+                    FnRetTy::DefaultReturn(_) => "FnRetTy::DefaultReturn(_)",
+                    FnRetTy::Return(_) => "FnRetTy::Return(_ty)",
+                };
+
+                let fn_decl_pat = self.next("fn_decl");
+                let body_id_pat = self.next("body_id");
+
                 println!(
-                    "Match(ref {}, ref {}, MatchSource::{:?}) = {};",
-                    expr_pat, arms_pat, des, current
+                    "Closure({}, ref {}, ref {}, _, {}) = {}",
+                    capture_by, fn_decl_pat, body_id_pat, movability, current
                 );
-                self.current = expr_pat;
-                self.visit_expr(expr);
-                println!("    if {}.len() == {};", arms_pat, arms.len());
-                for (i, arm) in arms.iter().enumerate() {
-                    self.current = format!("{}[{}].body", arms_pat, i);
-                    self.visit_expr(arm.body);
-                    if let Some(ref guard) = arm.guard {
-                        let guard_pat = self.next("guard");
-                        println!("    if let Some(ref {}) = {}[{}].guard;", guard_pat, arms_pat, i);
-                        match guard {
-                            hir::Guard::If(if_expr) => {
-                                let if_expr_pat = self.next("expr");
-                                println!("    if let Guard::If(ref {}) = {};", if_expr_pat, guard_pat);
-                                self.current = if_expr_pat;
-                                self.visit_expr(if_expr);
-                            },
-                            hir::Guard::IfLet(if_let_pat, if_let_expr) => {
-                                let if_let_pat_pat = self.next("pat");
-                                let if_let_expr_pat = self.next("expr");
-                                println!(
-                                    "    if let Guard::IfLet(ref {}, ref {}) = {};",
-                                    if_let_pat_pat, if_let_expr_pat, guard_pat
-                                );
-                                self.current = if_let_expr_pat;
-                                self.visit_expr(if_let_expr);
-                                self.current = if_let_pat_pat;
-                                self.visit_pat(if_let_pat);
-                            },
-                        }
-                    }
-                    self.current = format!("{}[{}].pat", arms_pat, i);
-                    self.visit_pat(arm.pat);
-                }
-            },
-            ExprKind::Closure(ref _capture_clause, _func, _, _, _) => {
-                println!("Closure(ref capture_clause, ref func, _, _, _) = {};", current);
-                println!("    // unimplemented: `ExprKind::Closure` is not further destructured at the moment");
+                println!("    if let {} = {}.output", ret_ty, fn_decl_pat);
+
+                let hir = self.cx.tcx.hir();
+                let body = hir.body(body_id);
+
+                let body_pat = self.next("body");
+
+                println!("    let {} = cx.tcx.hir().body({});", body_pat, body_id_pat);
+
+                self.current = format!("{}.value", body_pat);
+                self.visit_expr(&body.value);
             },
-            ExprKind::Yield(sub, _) => {
+            ExprKind::Yield(sub, source) => {
                 let sub_pat = self.next("sub");
-                println!("Yield(ref sub) = {};", current);
+
+                println!("Yield(ref sub, YieldSource::{:?}) = {};", source, current);
+
                 self.current = sub_pat;
                 self.visit_expr(sub);
             },
-            ExprKind::Block(block, _) => {
+            ExprKind::Block(block, label) => {
                 let block_pat = self.next("block");
-                println!("Block(ref {}) = {};", block_pat, current);
+                let label_pat = self.next("label");
+
+                println!("Block(ref {}, ref {}) = {};", block_pat, label_pat, current);
+
                 self.current = block_pat;
                 self.visit_block(block);
+
+                self.current = label_pat;
+                self.print_label(label);
             },
             ExprKind::Assign(target, value, _) => {
                 let target_pat = self.next("target");
                 let value_pat = self.next("value");
+
                 println!(
                     "Assign(ref {}, ref {}, ref _span) = {};",
                     target_pat, value_pat, current
                 );
+
                 self.current = target_pat;
                 self.visit_expr(target);
+
                 self.current = value_pat;
                 self.visit_expr(value);
             },
@@ -432,69 +680,91 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor {
                 let op_pat = self.next("op");
                 let target_pat = self.next("target");
                 let value_pat = self.next("value");
+
                 println!(
                     "AssignOp(ref {}, ref {}, ref {}) = {};",
                     op_pat, target_pat, value_pat, current
                 );
+
                 println!("    if BinOpKind::{:?} == {}.node;", op.node, op_pat);
+
                 self.current = target_pat;
                 self.visit_expr(target);
+
                 self.current = value_pat;
                 self.visit_expr(value);
             },
             ExprKind::Field(object, ref field_ident) => {
                 let obj_pat = self.next("object");
                 let field_name_pat = self.next("field_name");
+
                 println!("Field(ref {}, ref {}) = {};", obj_pat, field_name_pat, current);
                 println!("    if {}.as_str() == {:?}", field_name_pat, field_ident.as_str());
+
                 self.current = obj_pat;
                 self.visit_expr(object);
             },
             ExprKind::Index(object, index) => {
                 let object_pat = self.next("object");
                 let index_pat = self.next("index");
+
                 println!("Index(ref {}, ref {}) = {};", object_pat, index_pat, current);
+
                 self.current = object_pat;
                 self.visit_expr(object);
+
                 self.current = index_pat;
                 self.visit_expr(index);
             },
             ExprKind::Path(ref path) => {
                 let path_pat = self.next("path");
+
                 println!("Path(ref {}) = {};", path_pat, current);
+
                 self.current = path_pat;
                 self.print_qpath(path);
             },
             ExprKind::AddrOf(kind, mutability, inner) => {
                 let inner_pat = self.next("inner");
+
                 println!(
                     "AddrOf(BorrowKind::{:?}, Mutability::{:?}, ref {}) = {};",
                     kind, mutability, inner_pat, current
                 );
+
                 self.current = inner_pat;
                 self.visit_expr(inner);
             },
-            ExprKind::Break(ref _destination, ref opt_value) => {
+            ExprKind::Break(ref destination, ref opt_value) => {
                 let destination_pat = self.next("destination");
+
                 if let Some(value) = *opt_value {
                     let value_pat = self.next("value");
+
                     println!("Break(ref {}, Some(ref {})) = {};", destination_pat, value_pat, current);
+
                     self.current = value_pat;
                     self.visit_expr(value);
                 } else {
                     println!("Break(ref {}, None) = {};", destination_pat, current);
                 }
-                // FIXME: implement label printing
+
+                self.current = format!("{}.label", destination_pat);
+                self.print_label(destination.label);
             },
-            ExprKind::Continue(ref _destination) => {
+            ExprKind::Continue(ref destination) => {
                 let destination_pat = self.next("destination");
-                println!("Again(ref {}) = {};", destination_pat, current);
-                // FIXME: implement label printing
+                println!("Continue(ref {}) = {};", destination_pat, current);
+
+                self.current = format!("{}.label", destination_pat);
+                self.print_label(destination.label);
             },
             ExprKind::Ret(ref opt_value) => {
                 if let Some(value) = *opt_value {
                     let value_pat = self.next("value");
+
                     println!("Ret(Some(ref {})) = {};", value_pat, current);
+
                     self.current = value_pat;
                     self.visit_expr(value);
                 } else {
@@ -512,41 +782,66 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor {
             ExprKind::Struct(path, fields, ref opt_base) => {
                 let path_pat = self.next("path");
                 let fields_pat = self.next("fields");
+
                 if let Some(base) = *opt_base {
                     let base_pat = self.next("base");
+
                     println!(
                         "Struct(ref {}, ref {}, Some(ref {})) = {};",
                         path_pat, fields_pat, base_pat, current
                     );
+
                     self.current = base_pat;
                     self.visit_expr(base);
                 } else {
                     println!("Struct(ref {}, ref {}, None) = {};", path_pat, fields_pat, current);
                 }
+
                 self.current = path_pat;
                 self.print_qpath(path);
+
                 println!("    if {}.len() == {};", fields_pat, fields.len());
-                println!("    // unimplemented: field checks");
+
+                for (i, field) in fields.iter().enumerate() {
+                    println!(
+                        "    if {}[{}].ident.name.as_str() == {:?}",
+                        fields_pat,
+                        i,
+                        &*field.ident.name.as_str()
+                    );
+
+                    self.current = format!("{}[{}]", fields_pat, i);
+                    self.visit_expr(field.expr);
+                }
             },
             ExprKind::ConstBlock(_) => {
                 let value_pat = self.next("value");
-                println!("Const({})", value_pat);
+                println!("Const({}) = {}", value_pat, current);
                 self.current = value_pat;
             },
-            // FIXME: compute length (needs type info)
-            ExprKind::Repeat(value, _) => {
+            ExprKind::Repeat(value, length) => {
                 let value_pat = self.next("value");
-                println!("Repeat(ref {}, _) = {};", value_pat, current);
-                println!("// unimplemented: repeat count check");
+                let length_pat = self.next("length");
+
+                println!("Repeat(ref {}, ref {}) = {};", value_pat, length_pat, current);
+
                 self.current = value_pat;
                 self.visit_expr(value);
+
+                let hir = self.cx.tcx.hir();
+                let body = hir.body(length.body);
+
+                self.current = format!("{}.value", length_pat);
+                self.visit_expr(&body.value);
             },
             ExprKind::Err => {
                 println!("Err = {}", current);
             },
             ExprKind::DropTemps(expr) => {
                 let expr_pat = self.next("expr");
+
                 println!("DropTemps(ref {}) = {};", expr_pat, current);
+
                 self.current = expr_pat;
                 self.visit_expr(expr);
             },
@@ -555,11 +850,14 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor {
 
     fn visit_block(&mut self, block: &Block<'_>) {
         println!("    if {}.stmts.len() == {};", self.current, block.stmts.len());
+
         let block_name = self.current.clone();
+
         for (i, stmt) in block.stmts.iter().enumerate() {
             self.current = format!("{}.stmts[{}]", block_name, i);
             self.visit_stmt(stmt);
         }
+
         if let Some(expr) = block.expr {
             self.current = self.next("trailing_expr");
             println!("    if let Some({}) = &{}.expr;", self.current, block_name);
@@ -573,22 +871,27 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor {
     fn visit_pat(&mut self, pat: &Pat<'_>) {
         print!("    if let PatKind::");
         let current = format!("{}.kind", self.current);
+
         match pat.kind {
             PatKind::Wild => println!("Wild = {};", current),
             PatKind::Binding(anno, .., ident, ref sub) => {
                 let anno_pat = &format!("BindingAnnotation::{:?}", anno);
                 let name_pat = self.next("name");
+
                 if let Some(sub) = *sub {
                     let sub_pat = self.next("sub");
+
                     println!(
                         "Binding({}, _, {}, Some(ref {})) = {};",
                         anno_pat, name_pat, sub_pat, current
                     );
+
                     self.current = sub_pat;
                     self.visit_pat(sub);
                 } else {
                     println!("Binding({}, _, {}, None) = {};", anno_pat, name_pat, current);
                 }
+
                 println!("    if {}.as_str() == \"{}\";", name_pat, ident.as_str());
             },
             PatKind::Struct(ref path, fields, ignore) => {
@@ -598,32 +901,57 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor {
                     "Struct(ref {}, ref {}, {}) = {};",
                     path_pat, fields_pat, ignore, current
                 );
+
                 self.current = path_pat;
                 self.print_qpath(path);
+
                 println!("    if {}.len() == {};", fields_pat, fields.len());
-                println!("    // unimplemented: field checks");
+
+                for (i, field) in fields.iter().enumerate() {
+                    println!(
+                        "    if {}[{}].ident.name.as_str() == {:?}",
+                        fields_pat,
+                        i,
+                        &*field.ident.name.as_str()
+                    );
+
+                    self.current = format!("{}[{}]", fields_pat, i);
+                    self.visit_pat(field.pat);
+                }
             },
             PatKind::Or(fields) => {
                 let fields_pat = self.next("fields");
                 println!("Or(ref {}) = {};", fields_pat, current);
                 println!("    if {}.len() == {};", fields_pat, fields.len());
-                println!("    // unimplemented: field checks");
+
+                for (i, field) in fields.iter().enumerate() {
+                    self.current = format!("{}[{}]", fields_pat, i);
+                    self.visit_pat(field);
+                }
             },
             PatKind::TupleStruct(ref path, fields, skip_pos) => {
                 let path_pat = self.next("path");
                 let fields_pat = self.next("fields");
+
                 println!(
                     "TupleStruct(ref {}, ref {}, {:?}) = {};",
                     path_pat, fields_pat, skip_pos, current
                 );
+
                 self.current = path_pat;
                 self.print_qpath(path);
+
                 println!("    if {}.len() == {};", fields_pat, fields.len());
-                println!("    // unimplemented: field checks");
+
+                for (i, field) in fields.iter().enumerate() {
+                    self.current = format!("{}[{}]", fields_pat, i);
+                    self.visit_pat(field);
+                }
             },
             PatKind::Path(ref path) => {
                 let path_pat = self.next("path");
                 println!("Path(ref {}) = {};", path_pat, current);
+
                 self.current = path_pat;
                 self.print_qpath(path);
             },
@@ -631,41 +959,52 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor {
                 let fields_pat = self.next("fields");
                 println!("Tuple(ref {}, {:?}) = {};", fields_pat, skip_pos, current);
                 println!("    if {}.len() == {};", fields_pat, fields.len());
-                println!("    // unimplemented: field checks");
+
+                for (i, field) in fields.iter().enumerate() {
+                    self.current = format!("{}[{}]", fields_pat, i);
+                    self.visit_pat(field);
+                }
             },
             PatKind::Box(pat) => {
                 let pat_pat = self.next("pat");
                 println!("Box(ref {}) = {};", pat_pat, current);
+
                 self.current = pat_pat;
                 self.visit_pat(pat);
             },
             PatKind::Ref(pat, muta) => {
                 let pat_pat = self.next("pat");
                 println!("Ref(ref {}, Mutability::{:?}) = {};", pat_pat, muta, current);
+
                 self.current = pat_pat;
                 self.visit_pat(pat);
             },
             PatKind::Lit(lit_expr) => {
                 let lit_expr_pat = self.next("lit_expr");
                 println!("Lit(ref {}) = {}", lit_expr_pat, current);
+
                 self.current = lit_expr_pat;
                 self.visit_expr(lit_expr);
             },
             PatKind::Range(ref start, ref end, end_kind) => {
                 let start_pat = self.next("start");
                 let end_pat = self.next("end");
+
                 println!(
                     "Range(ref {}, ref {}, RangeEnd::{:?}) = {};",
                     start_pat, end_pat, end_kind, current
                 );
+
                 self.current = start_pat;
                 walk_list!(self, visit_expr, start);
+
                 self.current = end_pat;
                 walk_list!(self, visit_expr, end);
             },
             PatKind::Slice(start, ref middle, end) => {
                 let start_pat = self.next("start");
                 let end_pat = self.next("end");
+
                 if let Some(middle) = middle {
                     let middle_pat = self.next("middle");
                     println!(
@@ -677,12 +1016,16 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor {
                 } else {
                     println!("Slice(ref {}, None, ref {}) = {};", start_pat, end_pat, current);
                 }
+
                 println!("    if {}.len() == {};", start_pat, start.len());
+
                 for (i, pat) in start.iter().enumerate() {
                     self.current = format!("{}[{}]", start_pat, i);
                     self.visit_pat(pat);
                 }
+
                 println!("    if {}.len() == {};", end_pat, end.len());
+
                 for (i, pat) in end.iter().enumerate() {
                     self.current = format!("{}[{}]", end_pat, i);
                     self.visit_pat(pat);
@@ -694,17 +1037,21 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor {
     fn visit_stmt(&mut self, s: &Stmt<'_>) {
         print!("    if let StmtKind::");
         let current = format!("{}.kind", self.current);
+
         match s.kind {
             // A local (let) binding:
             StmtKind::Local(local) => {
                 let local_pat = self.next("local");
                 println!("Local(ref {}) = {};", local_pat, current);
+
                 if let Some(init) = local.init {
                     let init_pat = self.next("init");
                     println!("    if let Some(ref {}) = {}.init;", init_pat, local_pat);
+
                     self.current = init_pat;
                     self.visit_expr(init);
                 }
+
                 self.current = format!("{}.pat", local_pat);
                 self.visit_pat(local.pat);
             },
@@ -717,6 +1064,7 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor {
             StmtKind::Expr(e) => {
                 let e_pat = self.next("e");
                 println!("Expr(ref {}, _) = {}", e_pat, current);
+
                 self.current = e_pat;
                 self.visit_expr(e);
             },
@@ -725,6 +1073,7 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor {
             StmtKind::Semi(e) => {
                 let e_pat = self.next("e");
                 println!("Semi(ref {}, _) = {}", e_pat, current);
+
                 self.current = e_pat;
                 self.visit_expr(e);
             },
diff --git a/tests/ui/author.stdout b/tests/ui/author.stdout
index 211d11c7c1a..313597bf534 100644
--- a/tests/ui/author.stdout
+++ b/tests/ui/author.stdout
@@ -5,7 +5,7 @@ if_chain! {
     if let TyKind::Path(ref qp) = cast_ty.kind;
     if match_qpath(qp, &["char"]);
     if let ExprKind::Lit(ref lit) = expr.kind;
-    if let LitKind::Int(69, _) = lit.node;
+    if let LitKind::Int(69, LitIntType::Unsuffixed) = lit.node;
     if let PatKind::Binding(BindingAnnotation::Unannotated, _, name, None) = local.pat.kind;
     if name.as_str() == "x";
     then {
diff --git a/tests/ui/author/blocks.rs b/tests/ui/author/blocks.rs
index c8465cd59aa..a7335c01baa 100644
--- a/tests/ui/author/blocks.rs
+++ b/tests/ui/author/blocks.rs
@@ -1,10 +1,16 @@
+// edition:2018
+
 #![allow(redundant_semicolons, clippy::no_effect)]
+#![feature(stmt_expr_attributes)]
+#![feature(async_closure)]
 
 #[rustfmt::skip]
 fn main() {
     #[clippy::author]
     {
         let x = 42i32;
+        let _t = 1f32;
+
         -x;
     };
     #[clippy::author]
@@ -12,4 +18,7 @@ fn main() {
         let expr = String::new();
         drop(expr)
     };
+
+    #[clippy::author]
+    async move || {};
 }
diff --git a/tests/ui/author/blocks.stdout b/tests/ui/author/blocks.stdout
index 854bc28083a..31c7fced7f7 100644
--- a/tests/ui/author/blocks.stdout
+++ b/tests/ui/author/blocks.stdout
@@ -1,13 +1,19 @@
 if_chain! {
-    if let ExprKind::Block(ref block) = expr.kind;
-    if block.stmts.len() == 2;
+    if let ExprKind::Block(ref block, ref label) = expr.kind;
+    if block.stmts.len() == 3;
     if let StmtKind::Local(ref local) = block.stmts[0].kind;
     if let Some(ref init) = local.init;
     if let ExprKind::Lit(ref lit) = init.kind;
-    if let LitKind::Int(42, _) = lit.node;
+    if let LitKind::Int(42, LitIntType::Signed(IntTy::I32)) = lit.node;
     if let PatKind::Binding(BindingAnnotation::Unannotated, _, name, None) = local.pat.kind;
     if name.as_str() == "x";
-    if let StmtKind::Semi(ref e, _) = block.stmts[1].kind
+    if let StmtKind::Local(ref local1) = block.stmts[1].kind;
+    if let Some(ref init1) = local1.init;
+    if let ExprKind::Lit(ref lit1) = init1.kind;
+    if let LitKind::Float(_, LitFloatType::Suffixed(FloatTy::F32)) = lit1.node;
+    if let PatKind::Binding(BindingAnnotation::Unannotated, _, name1, None) = local1.pat.kind;
+    if name1.as_str() == "_t";
+    if let StmtKind::Semi(ref e, _) = block.stmts[2].kind
     if let ExprKind::Unary(UnOp::Neg, ref inner) = e.kind;
     if let ExprKind::Path(ref path) = inner.kind;
     if match_qpath(path, &["x"]);
@@ -17,7 +23,7 @@ if_chain! {
     }
 }
 if_chain! {
-    if let ExprKind::Block(ref block) = expr.kind;
+    if let ExprKind::Block(ref block, ref label) = expr.kind;
     if block.stmts.len() == 1;
     if let StmtKind::Local(ref local) = block.stmts[0].kind;
     if let Some(ref init) = local.init;
@@ -38,3 +44,21 @@ if_chain! {
         // report your lint here
     }
 }
+if_chain! {
+    if let ExprKind::Closure(CaptureBy::Value, ref fn_decl, ref body_id, _, None) = expr.kind
+    if let FnRetTy::DefaultReturn(_) = fn_decl.output
+    let body = cx.tcx.hir().body(body_id);
+    if let ExprKind::Call(ref func, ref args) = body.value.kind;
+    if let ExprKind::Path(ref path) = func.kind;
+    if matches!(path, QPath::LangItem(LangItem::FromGenerator, _));
+    if args.len() == 1;
+    if let ExprKind::Closure(CaptureBy::Value, ref fn_decl1, ref body_id1, _, Some(Movability::Static)) = args[0].kind
+    if let FnRetTy::DefaultReturn(_) = fn_decl1.output
+    let body1 = cx.tcx.hir().body(body_id1);
+    if let ExprKind::Block(ref block, ref label) = body1.value.kind;
+    if block.stmts.len() == 0;
+    if block.expr.is_none();
+    then {
+        // report your lint here
+    }
+}
diff --git a/tests/ui/author/call.stdout b/tests/ui/author/call.stdout
index 4dccf666631..07958dbc356 100644
--- a/tests/ui/author/call.stdout
+++ b/tests/ui/author/call.stdout
@@ -6,9 +6,9 @@ if_chain! {
     if match_qpath(path, &["{{root}}", "std", "cmp", "min"]);
     if args.len() == 2;
     if let ExprKind::Lit(ref lit) = args[0].kind;
-    if let LitKind::Int(3, _) = lit.node;
+    if let LitKind::Int(3, LitIntType::Unsuffixed) = lit.node;
     if let ExprKind::Lit(ref lit1) = args[1].kind;
-    if let LitKind::Int(4, _) = lit1.node;
+    if let LitKind::Int(4, LitIntType::Unsuffixed) = lit1.node;
     if let PatKind::Wild = local.pat.kind;
     then {
         // report your lint here
diff --git a/tests/ui/author/for_loop.rs b/tests/ui/author/for_loop.rs
deleted file mode 100644
index b3dec876535..00000000000
--- a/tests/ui/author/for_loop.rs
+++ /dev/null
@@ -1,8 +0,0 @@
-#![feature(stmt_expr_attributes)]
-
-fn main() {
-    #[clippy::author]
-    for y in 0..10 {
-        let z = y;
-    }
-}
diff --git a/tests/ui/author/for_loop.stdout b/tests/ui/author/for_loop.stdout
deleted file mode 100644
index f1b4d4e096e..00000000000
--- a/tests/ui/author/for_loop.stdout
+++ /dev/null
@@ -1,64 +0,0 @@
-if_chain! {
-    if let ExprKind::DropTemps(ref expr) = expr.kind;
-    if let ExprKind::Match(ref expr1, ref arms, MatchSource::ForLoopDesugar) = expr.kind;
-    if let ExprKind::Call(ref func, ref args) = expr1.kind;
-    if let ExprKind::Path(ref path) = func.kind;
-    if matches!(path, QPath::LangItem(LangItem::IntoIterIntoIter, _));
-    if args.len() == 1;
-    if let ExprKind::Struct(ref path1, ref fields, None) = args[0].kind;
-    if matches!(path1, QPath::LangItem(LangItem::Range, _));
-    if fields.len() == 2;
-    // unimplemented: field checks
-    if arms.len() == 1;
-    if let ExprKind::Loop(ref body, ref label, LoopSource::ForLoop) = arms[0].body.kind;
-    if body.stmts.len() == 4;
-    if let StmtKind::Local(ref local) = body.stmts[0].kind;
-    if let PatKind::Binding(BindingAnnotation::Mutable, _, name, None) = local.pat.kind;
-    if name.as_str() == "__next";
-    if let StmtKind::Expr(ref e, _) = body.stmts[1].kind
-    if let ExprKind::Match(ref expr2, ref arms1, MatchSource::ForLoopDesugar) = e.kind;
-    if let ExprKind::Call(ref func1, ref args1) = expr2.kind;
-    if let ExprKind::Path(ref path2) = func1.kind;
-    if matches!(path2, QPath::LangItem(LangItem::IteratorNext, _));
-    if args1.len() == 1;
-    if let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Mut, ref inner) = args1[0].kind;
-    if let ExprKind::Path(ref path3) = inner.kind;
-    if match_qpath(path3, &["iter"]);
-    if arms1.len() == 2;
-    if let ExprKind::Assign(ref target, ref value, ref _span) = arms1[0].body.kind;
-    if let ExprKind::Path(ref path4) = target.kind;
-    if match_qpath(path4, &["__next"]);
-    if let ExprKind::Path(ref path5) = value.kind;
-    if match_qpath(path5, &["val"]);
-    if let PatKind::Struct(ref path6, ref fields1, false) = arms1[0].pat.kind;
-    if matches!(path6, QPath::LangItem(LangItem::OptionSome, _));
-    if fields1.len() == 1;
-    // unimplemented: field checks
-    if let ExprKind::Break(ref destination, None) = arms1[1].body.kind;
-    if let PatKind::Struct(ref path7, ref fields2, false) = arms1[1].pat.kind;
-    if matches!(path7, QPath::LangItem(LangItem::OptionNone, _));
-    if fields2.len() == 0;
-    // unimplemented: field checks
-    if let StmtKind::Local(ref local1) = body.stmts[2].kind;
-    if let Some(ref init) = local1.init;
-    if let ExprKind::Path(ref path8) = init.kind;
-    if match_qpath(path8, &["__next"]);
-    if let PatKind::Binding(BindingAnnotation::Unannotated, _, name1, None) = local1.pat.kind;
-    if name1.as_str() == "y";
-    if let StmtKind::Expr(ref e1, _) = body.stmts[3].kind
-    if let ExprKind::Block(ref block) = e1.kind;
-    if block.stmts.len() == 1;
-    if let StmtKind::Local(ref local2) = block.stmts[0].kind;
-    if let Some(ref init1) = local2.init;
-    if let ExprKind::Path(ref path9) = init1.kind;
-    if match_qpath(path9, &["y"]);
-    if let PatKind::Binding(BindingAnnotation::Unannotated, _, name2, None) = local2.pat.kind;
-    if name2.as_str() == "z";
-    if block.expr.is_none();
-    if body.expr.is_none();
-    if let PatKind::Binding(BindingAnnotation::Mutable, _, name3, None) = arms[0].pat.kind;
-    if name3.as_str() == "iter";
-    then {
-        // report your lint here
-    }
-}
diff --git a/tests/ui/author/if.rs b/tests/ui/author/if.rs
index 2e9cb1466d0..946088ab346 100644
--- a/tests/ui/author/if.rs
+++ b/tests/ui/author/if.rs
@@ -7,4 +7,11 @@ fn main() {
     } else {
         2 == 2;
     };
+
+    let a = true;
+
+    #[clippy::author]
+    if let true = a {
+    } else {
+    };
 }
diff --git a/tests/ui/author/if.stdout b/tests/ui/author/if.stdout
index 1653de9a6f2..7e72a548011 100644
--- a/tests/ui/author/if.stdout
+++ b/tests/ui/author/if.stdout
@@ -1,32 +1,48 @@
 if_chain! {
     if let StmtKind::Local(ref local) = stmt.kind;
     if let Some(ref init) = local.init;
-    if let ExprKind::If(ref cond, ref then, Some(ref else_)) = init.kind;
-    if let ExprKind::Block(ref block) = else_.kind;
+    if let Some(higher::If { cond: cond, then: then, r#else: else_expr}) = higher::If::hir(init)
+    if let ExprKind::Lit(ref lit) = cond.kind;
+    if let LitKind::Bool(true) = lit.node;
+    if let ExprKind::Block(ref block, ref label) = then.kind;
     if block.stmts.len() == 1;
     if let StmtKind::Semi(ref e, _) = block.stmts[0].kind
     if let ExprKind::Binary(ref op, ref left, ref right) = e.kind;
     if BinOpKind::Eq == op.node;
-    if let ExprKind::Lit(ref lit) = left.kind;
-    if let LitKind::Int(2, _) = lit.node;
-    if let ExprKind::Lit(ref lit1) = right.kind;
-    if let LitKind::Int(2, _) = lit1.node;
+    if let ExprKind::Lit(ref lit1) = left.kind;
+    if let LitKind::Int(1, LitIntType::Unsuffixed) = lit1.node;
+    if let ExprKind::Lit(ref lit2) = right.kind;
+    if let LitKind::Int(1, LitIntType::Unsuffixed) = lit2.node;
     if block.expr.is_none();
-    if let ExprKind::DropTemps(ref expr) = cond.kind;
-    if let ExprKind::Lit(ref lit2) = expr.kind;
-    if let LitKind::Bool(true) = lit2.node;
-    if let ExprKind::Block(ref block1) = then.kind;
+    if let ExprKind::Block(ref block1, ref label1) = else_expr.kind;
     if block1.stmts.len() == 1;
     if let StmtKind::Semi(ref e1, _) = block1.stmts[0].kind
     if let ExprKind::Binary(ref op1, ref left1, ref right1) = e1.kind;
     if BinOpKind::Eq == op1.node;
     if let ExprKind::Lit(ref lit3) = left1.kind;
-    if let LitKind::Int(1, _) = lit3.node;
+    if let LitKind::Int(2, LitIntType::Unsuffixed) = lit3.node;
     if let ExprKind::Lit(ref lit4) = right1.kind;
-    if let LitKind::Int(1, _) = lit4.node;
+    if let LitKind::Int(2, LitIntType::Unsuffixed) = lit4.node;
     if block1.expr.is_none();
     if let PatKind::Wild = local.pat.kind;
     then {
         // report your lint here
     }
 }
+if_chain! {
+    if let Some(higher::IfLet { let_pat: let_pat, let_expr: let_expr, if_then: if_then, if_else: else_expr}) = higher::IfLet::hir(expr)
+    if let PatKind::Lit(ref lit_expr) = let_pat.kind
+    if let ExprKind::Lit(ref lit) = lit_expr.kind;
+    if let LitKind::Bool(true) = lit.node;
+    if let ExprKind::Path(ref path) = let_expr.kind;
+    if match_qpath(path, &["a"]);
+    if let ExprKind::Block(ref block, ref label) = if_then.kind;
+    if block.stmts.len() == 0;
+    if block.expr.is_none();
+    if let ExprKind::Block(ref block1, ref label1) = else_expr.kind;
+    if block1.stmts.len() == 0;
+    if block1.expr.is_none();
+    then {
+        // report your lint here
+    }
+}
diff --git a/tests/ui/author/loop.rs b/tests/ui/author/loop.rs
new file mode 100644
index 00000000000..d6de21631e2
--- /dev/null
+++ b/tests/ui/author/loop.rs
@@ -0,0 +1,36 @@
+#![feature(stmt_expr_attributes)]
+#![allow(clippy::never_loop, clippy::while_immutable_condition)]
+
+fn main() {
+    #[clippy::author]
+    for y in 0..10 {
+        let z = y;
+    }
+
+    #[clippy::author]
+    for _ in 0..10 {
+        break;
+    }
+
+    #[clippy::author]
+    'label: for _ in 0..10 {
+        break 'label;
+    }
+
+    let a = true;
+
+    #[clippy::author]
+    while a {
+        break;
+    }
+
+    #[clippy::author]
+    while let true = a {
+        break;
+    }
+
+    #[clippy::author]
+    loop {
+        break;
+    }
+}
diff --git a/tests/ui/author/loop.stdout b/tests/ui/author/loop.stdout
new file mode 100644
index 00000000000..fa146f03495
--- /dev/null
+++ b/tests/ui/author/loop.stdout
@@ -0,0 +1,112 @@
+if_chain! {
+    if let ExprKind::DropTemps(ref expr) = expr.kind;
+    if let Some(higher::ForLoop { pat: pat, arg: arg, body: body, ..}) = higher::ForLoop::hir(expr)
+    if let PatKind::Binding(BindingAnnotation::Unannotated, _, name, None) = pat.kind;
+    if name.as_str() == "y";
+    if let ExprKind::Struct(ref path, ref fields, None) = arg.kind;
+    if matches!(path, QPath::LangItem(LangItem::Range, _));
+    if fields.len() == 2;
+    if fields[0].ident.name.as_str() == "start"
+    if let ExprKind::Lit(ref lit) = fields[0].kind;
+    if let LitKind::Int(0, LitIntType::Unsuffixed) = lit.node;
+    if fields[1].ident.name.as_str() == "end"
+    if let ExprKind::Lit(ref lit1) = fields[1].kind;
+    if let LitKind::Int(10, LitIntType::Unsuffixed) = lit1.node;
+    if let ExprKind::Block(ref block, ref label) = body.kind;
+    if block.stmts.len() == 1;
+    if let StmtKind::Local(ref local) = block.stmts[0].kind;
+    if let Some(ref init) = local.init;
+    if let ExprKind::Path(ref path1) = init.kind;
+    if match_qpath(path1, &["y"]);
+    if let PatKind::Binding(BindingAnnotation::Unannotated, _, name1, None) = local.pat.kind;
+    if name1.as_str() == "z";
+    if block.expr.is_none();
+    then {
+        // report your lint here
+    }
+}
+if_chain! {
+    if let ExprKind::DropTemps(ref expr) = expr.kind;
+    if let Some(higher::ForLoop { pat: pat, arg: arg, body: body, ..}) = higher::ForLoop::hir(expr)
+    if let PatKind::Wild = pat.kind;
+    if let ExprKind::Struct(ref path, ref fields, None) = arg.kind;
+    if matches!(path, QPath::LangItem(LangItem::Range, _));
+    if fields.len() == 2;
+    if fields[0].ident.name.as_str() == "start"
+    if let ExprKind::Lit(ref lit) = fields[0].kind;
+    if let LitKind::Int(0, LitIntType::Unsuffixed) = lit.node;
+    if fields[1].ident.name.as_str() == "end"
+    if let ExprKind::Lit(ref lit1) = fields[1].kind;
+    if let LitKind::Int(10, LitIntType::Unsuffixed) = lit1.node;
+    if let ExprKind::Block(ref block, ref label) = body.kind;
+    if block.stmts.len() == 1;
+    if let StmtKind::Semi(ref e, _) = block.stmts[0].kind
+    if let ExprKind::Break(ref destination, None) = e.kind;
+    if block.expr.is_none();
+    then {
+        // report your lint here
+    }
+}
+if_chain! {
+    if let ExprKind::DropTemps(ref expr) = expr.kind;
+    if let Some(higher::ForLoop { pat: pat, arg: arg, body: body, ..}) = higher::ForLoop::hir(expr)
+    if let PatKind::Wild = pat.kind;
+    if let ExprKind::Struct(ref path, ref fields, None) = arg.kind;
+    if matches!(path, QPath::LangItem(LangItem::Range, _));
+    if fields.len() == 2;
+    if fields[0].ident.name.as_str() == "start"
+    if let ExprKind::Lit(ref lit) = fields[0].kind;
+    if let LitKind::Int(0, LitIntType::Unsuffixed) = lit.node;
+    if fields[1].ident.name.as_str() == "end"
+    if let ExprKind::Lit(ref lit1) = fields[1].kind;
+    if let LitKind::Int(10, LitIntType::Unsuffixed) = lit1.node;
+    if let ExprKind::Block(ref block, ref label) = body.kind;
+    if block.stmts.len() == 1;
+    if let StmtKind::Semi(ref e, _) = block.stmts[0].kind
+    if let ExprKind::Break(ref destination, None) = e.kind;
+    if let Some(ref label1) = destination.label
+    if label_name.ident.name.as_str() == "'label";
+    if block.expr.is_none();
+    then {
+        // report your lint here
+    }
+}
+if_chain! {
+    if let Some(higher::While { condition: condition, body: body }) = higher::While::hir(expr)
+    if let ExprKind::Path(ref path) = condition.kind;
+    if match_qpath(path, &["a"]);
+    if let ExprKind::Block(ref block, ref label) = body.kind;
+    if block.stmts.len() == 1;
+    if let StmtKind::Semi(ref e, _) = block.stmts[0].kind
+    if let ExprKind::Break(ref destination, None) = e.kind;
+    if block.expr.is_none();
+    then {
+        // report your lint here
+    }
+}
+if_chain! {
+    if let Some(higher::WhileLet { let_pat: let_pat, let_expr: let_expr, if_then: if_then }) = higher::WhileLet::hir(expr)
+    if let PatKind::Lit(ref lit_expr) = let_pat.kind
+    if let ExprKind::Lit(ref lit) = lit_expr.kind;
+    if let LitKind::Bool(true) = lit.node;
+    if let ExprKind::Path(ref path) = let_expr.kind;
+    if match_qpath(path, &["a"]);
+    if let ExprKind::Block(ref block, ref label) = if_then.kind;
+    if block.stmts.len() == 1;
+    if let StmtKind::Semi(ref e, _) = block.stmts[0].kind
+    if let ExprKind::Break(ref destination, None) = e.kind;
+    if block.expr.is_none();
+    then {
+        // report your lint here
+    }
+}
+if_chain! {
+    if let ExprKind::Loop(ref body, ref label, LoopSource::Loop) = expr.kind;
+    if body.stmts.len() == 1;
+    if let StmtKind::Semi(ref e, _) = body.stmts[0].kind
+    if let ExprKind::Break(ref destination, None) = e.kind;
+    if body.expr.is_none();
+    then {
+        // report your lint here
+    }
+}
diff --git a/tests/ui/author/matches.stdout b/tests/ui/author/matches.stdout
index 68cc2b214eb..3be61fe3772 100644
--- a/tests/ui/author/matches.stdout
+++ b/tests/ui/author/matches.stdout
@@ -3,19 +3,19 @@ if_chain! {
     if let Some(ref init) = local.init;
     if let ExprKind::Match(ref expr, ref arms, MatchSource::Normal) = init.kind;
     if let ExprKind::Lit(ref lit) = expr.kind;
-    if let LitKind::Int(42, _) = lit.node;
+    if let LitKind::Int(42, LitIntType::Unsuffixed) = lit.node;
     if arms.len() == 3;
     if let ExprKind::Lit(ref lit1) = arms[0].body.kind;
-    if let LitKind::Int(5, _) = lit1.node;
+    if let LitKind::Int(5, LitIntType::Unsuffixed) = lit1.node;
     if let PatKind::Lit(ref lit_expr) = arms[0].pat.kind
     if let ExprKind::Lit(ref lit2) = lit_expr.kind;
-    if let LitKind::Int(16, _) = lit2.node;
-    if let ExprKind::Block(ref block) = arms[1].body.kind;
+    if let LitKind::Int(16, LitIntType::Unsuffixed) = lit2.node;
+    if let ExprKind::Block(ref block, ref label) = arms[1].body.kind;
     if block.stmts.len() == 1;
     if let StmtKind::Local(ref local1) = block.stmts[0].kind;
     if let Some(ref init1) = local1.init;
     if let ExprKind::Lit(ref lit3) = init1.kind;
-    if let LitKind::Int(3, _) = lit3.node;
+    if let LitKind::Int(3, LitIntType::Unsuffixed) = lit3.node;
     if let PatKind::Binding(BindingAnnotation::Unannotated, _, name, None) = local1.pat.kind;
     if name.as_str() == "x";
     if let Some(trailing_expr) = &block.expr;
@@ -23,9 +23,9 @@ if_chain! {
     if match_qpath(path, &["x"]);
     if let PatKind::Lit(ref lit_expr1) = arms[1].pat.kind
     if let ExprKind::Lit(ref lit4) = lit_expr1.kind;
-    if let LitKind::Int(17, _) = lit4.node;
+    if let LitKind::Int(17, LitIntType::Unsuffixed) = lit4.node;
     if let ExprKind::Lit(ref lit5) = arms[2].body.kind;
-    if let LitKind::Int(1, _) = lit5.node;
+    if let LitKind::Int(1, LitIntType::Unsuffixed) = lit5.node;
     if let PatKind::Wild = arms[2].pat.kind;
     if let PatKind::Binding(BindingAnnotation::Unannotated, _, name1, None) = local.pat.kind;
     if name1.as_str() == "a";
diff --git a/tests/ui/author/repeat.rs b/tests/ui/author/repeat.rs
new file mode 100644
index 00000000000..d8e9d589e68
--- /dev/null
+++ b/tests/ui/author/repeat.rs
@@ -0,0 +1,5 @@
+#[allow(clippy::no_effect)]
+fn main() {
+    #[clippy::author]
+    [1_u8; 5];
+}
diff --git a/tests/ui/author/repeat.stdout b/tests/ui/author/repeat.stdout
new file mode 100644
index 00000000000..9ff376373e6
--- /dev/null
+++ b/tests/ui/author/repeat.stdout
@@ -0,0 +1,10 @@
+if_chain! {
+    if let ExprKind::Repeat(ref value, ref length) = expr.kind;
+    if let ExprKind::Lit(ref lit) = value.kind;
+    if let LitKind::Int(1, LitIntType::Unsigned(UintTy::U8)) = lit.node;
+    if let ExprKind::Lit(ref lit1) = length.value.kind;
+    if let LitKind::Int(5, LitIntType::Unsuffixed) = lit1.node;
+    then {
+        // report your lint here
+    }
+}
diff --git a/tests/ui/author/struct.rs b/tests/ui/author/struct.rs
new file mode 100644
index 00000000000..5fdf3433a37
--- /dev/null
+++ b/tests/ui/author/struct.rs
@@ -0,0 +1,40 @@
+#[allow(clippy::unnecessary_operation, clippy::single_match)]
+fn main() {
+    struct Test {
+        field: u32,
+    }
+
+    #[clippy::author]
+    Test {
+        field: if true { 1 } else { 0 },
+    };
+
+    let test = Test { field: 1 };
+
+    match test {
+        #[clippy::author]
+        Test { field: 1 } => {},
+        _ => {},
+    }
+
+    struct TestTuple(u32);
+
+    let test_tuple = TestTuple(1);
+
+    match test_tuple {
+        #[clippy::author]
+        TestTuple(1) => {},
+        _ => {},
+    }
+
+    struct TestMethodCall(u32);
+
+    impl TestMethodCall {
+        fn test(&self) {}
+    }
+
+    let test_method_call = TestMethodCall(1);
+
+    #[clippy::author]
+    test_method_call.test();
+}
diff --git a/tests/ui/author/struct.stdout b/tests/ui/author/struct.stdout
new file mode 100644
index 00000000000..98055d73779
--- /dev/null
+++ b/tests/ui/author/struct.stdout
@@ -0,0 +1,61 @@
+if_chain! {
+    if let ExprKind::Struct(ref path, ref fields, None) = expr.kind;
+    if match_qpath(path, &["Test"]);
+    if fields.len() == 1;
+    if fields[0].ident.name.as_str() == "field"
+    if let Some(higher::If { cond: cond, then: then, r#else: else_expr}) = higher::If::hir(fields[0])
+    if let ExprKind::Lit(ref lit) = cond.kind;
+    if let LitKind::Bool(true) = lit.node;
+    if let ExprKind::Block(ref block, ref label) = then.kind;
+    if block.stmts.len() == 0;
+    if let Some(trailing_expr) = &block.expr;
+    if let ExprKind::Lit(ref lit1) = trailing_expr.kind;
+    if let LitKind::Int(1, LitIntType::Unsuffixed) = lit1.node;
+    if let ExprKind::Block(ref block1, ref label1) = else_expr.kind;
+    if block1.stmts.len() == 0;
+    if let Some(trailing_expr1) = &block1.expr;
+    if let ExprKind::Lit(ref lit2) = trailing_expr1.kind;
+    if let LitKind::Int(0, LitIntType::Unsuffixed) = lit2.node;
+    then {
+        // report your lint here
+    }
+}
+if_chain! {
+    if let PatKind::Struct(ref path, ref fields, false) = arm.kind;
+    if match_qpath(path, &["Test"]);
+    if fields.len() == 1;
+    if fields[0].ident.name.as_str() == "field"
+    if let PatKind::Lit(ref lit_expr) = fields[0].kind
+    if let ExprKind::Lit(ref lit) = lit_expr.kind;
+    if let LitKind::Int(1, LitIntType::Unsuffixed) = lit.node;
+    if let ExprKind::Block(ref block, ref label) = lit_expr.kind;
+    if block.stmts.len() == 0;
+    if block.expr.is_none();
+    then {
+        // report your lint here
+    }
+}
+if_chain! {
+    if let PatKind::TupleStruct(ref path, ref fields, None) = arm.kind;
+    if match_qpath(path, &["TestTuple"]);
+    if fields.len() == 1;
+    if let PatKind::Lit(ref lit_expr) = fields[0].kind
+    if let ExprKind::Lit(ref lit) = lit_expr.kind;
+    if let LitKind::Int(1, LitIntType::Unsuffixed) = lit.node;
+    if let ExprKind::Block(ref block, ref label) = lit_expr.kind;
+    if block.stmts.len() == 0;
+    if block.expr.is_none();
+    then {
+        // report your lint here
+    }
+}
+if_chain! {
+    if let ExprKind::MethodCall(ref method_name, ref args, _) = expr.kind;
+    if method_name.ident.name.as_str() == test;
+    if args.len() == 1;
+    if let ExprKind::Path(ref path) = args[0].kind;
+    if match_qpath(path, &["test_method_call"]);
+    then {
+        // report your lint here
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 2c6f03d48bd25294187eca27c5357620f612c656 Mon Sep 17 00:00:00 2001
From: Serial <69764315+Serial-ATA@users.noreply.github.com>
Date: Sun, 7 Nov 2021 14:28:30 -0500
Subject: Fix ICE in undocumented_unsafe_blocks

---
 clippy_lints/src/undocumented_unsafe_blocks.rs | 4 +++-
 tests/ui/crashes/auxiliary/ice-7934-aux.rs     | 4 ++++
 tests/ui/crashes/ice-7934.rs                   | 7 +++++++
 3 files changed, 14 insertions(+), 1 deletion(-)
 create mode 100644 tests/ui/crashes/auxiliary/ice-7934-aux.rs
 create mode 100644 tests/ui/crashes/ice-7934.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/undocumented_unsafe_blocks.rs b/clippy_lints/src/undocumented_unsafe_blocks.rs
index 99b33e5433f..fbf66712261 100644
--- a/clippy_lints/src/undocumented_unsafe_blocks.rs
+++ b/clippy_lints/src/undocumented_unsafe_blocks.rs
@@ -149,6 +149,8 @@ impl UndocumentedUnsafeBlocks {
         let lex_end = (between_span.hi().0 - source_file.start_pos.0) as usize;
         let src_str = source_file.src.as_ref()?[lex_start..lex_end].to_string();
 
+        let source_start_pos = source_file.start_pos.0 as usize + lex_start;
+
         let mut pos = 0;
         let mut comment = false;
 
@@ -171,7 +173,7 @@ impl UndocumentedUnsafeBlocks {
                     if comment {
                         // Get the line number of the "comment" (really wherever the trailing whitespace ended)
                         let comment_line_num = source_file
-                            .lookup_file_pos_with_col_display(BytePos((lex_start + pos).try_into().unwrap()))
+                            .lookup_file_pos(BytePos((source_start_pos + pos).try_into().unwrap()))
                             .0;
                         // Find the block/local's line number
                         let block_line_num = tcx.sess.source_map().lookup_char_pos(block_span.lo()).line;
diff --git a/tests/ui/crashes/auxiliary/ice-7934-aux.rs b/tests/ui/crashes/auxiliary/ice-7934-aux.rs
new file mode 100644
index 00000000000..4afbf027b61
--- /dev/null
+++ b/tests/ui/crashes/auxiliary/ice-7934-aux.rs
@@ -0,0 +1,4 @@
+fn zero() {
+    // SAFETY:
+    unsafe { 0 };
+}
diff --git a/tests/ui/crashes/ice-7934.rs b/tests/ui/crashes/ice-7934.rs
new file mode 100644
index 00000000000..a4691c4131b
--- /dev/null
+++ b/tests/ui/crashes/ice-7934.rs
@@ -0,0 +1,7 @@
+#![warn(clippy::undocumented_unsafe_blocks)]
+#![allow(clippy::no_effect)]
+
+#[path = "auxiliary/ice-7934-aux.rs"]
+mod zero;
+
+fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 413d255916a314ab8377a308e6b8f98a55301a55 Mon Sep 17 00:00:00 2001
From: Serial <69764315+Serial-ATA@users.noreply.github.com>
Date: Sun, 7 Nov 2021 13:52:34 -0500
Subject: Add MSRV to deprecated_cfg_attr

---
 clippy_lints/src/attrs.rs             | 19 ++++++++++++++-----
 clippy_lints/src/lib.rs               | 15 +++++++++++++--
 clippy_lints/src/utils/conf.rs        |  2 +-
 clippy_utils/src/msrvs.rs             |  2 +-
 src/driver.rs                         |  2 +-
 tests/ui/min_rust_version_attr.rs     | 13 ++++++++-----
 tests/ui/min_rust_version_attr.stderr |  8 ++++----
 7 files changed, 42 insertions(+), 19 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs
index 6f8b645dd70..9c5db18336f 100644
--- a/clippy_lints/src/attrs.rs
+++ b/clippy_lints/src/attrs.rs
@@ -1,8 +1,9 @@
 //! checks for attributes
 
 use clippy_utils::diagnostics::{span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then};
-use clippy_utils::match_panic_def_id;
+use clippy_utils::msrvs;
 use clippy_utils::source::{first_line_of_span, is_present_in_source, snippet_opt, without_block_comments};
+use clippy_utils::{extract_msrv_attr, match_panic_def_id, meets_msrv};
 use if_chain::if_chain;
 use rustc_ast::{AttrKind, AttrStyle, Attribute, Lit, LitKind, MetaItemKind, NestedMetaItem};
 use rustc_errors::Applicability;
@@ -12,7 +13,8 @@ use rustc_hir::{
 use rustc_lint::{EarlyContext, EarlyLintPass, LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_semver::RustcVersion;
+use rustc_session::{declare_lint_pass, declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::Span;
 use rustc_span::sym;
 use rustc_span::symbol::{Symbol, SymbolStr};
@@ -497,7 +499,11 @@ fn is_word(nmi: &NestedMetaItem, expected: Symbol) -> bool {
     }
 }
 
-declare_lint_pass!(EarlyAttributes => [
+pub struct EarlyAttributes {
+    pub msrv: Option<RustcVersion>,
+}
+
+impl_lint_pass!(EarlyAttributes => [
     DEPRECATED_CFG_ATTR,
     MISMATCHED_TARGET_OS,
     EMPTY_LINE_AFTER_OUTER_ATTR,
@@ -509,9 +515,11 @@ impl EarlyLintPass for EarlyAttributes {
     }
 
     fn check_attribute(&mut self, cx: &EarlyContext<'_>, attr: &Attribute) {
-        check_deprecated_cfg_attr(cx, attr);
+        check_deprecated_cfg_attr(cx, attr, self.msrv);
         check_mismatched_target_os(cx, attr);
     }
+
+    extract_msrv_attr!(EarlyContext);
 }
 
 fn check_empty_line_after_outer_attr(cx: &EarlyContext<'_>, item: &rustc_ast::Item) {
@@ -548,8 +556,9 @@ fn check_empty_line_after_outer_attr(cx: &EarlyContext<'_>, item: &rustc_ast::It
     }
 }
 
-fn check_deprecated_cfg_attr(cx: &EarlyContext<'_>, attr: &Attribute) {
+fn check_deprecated_cfg_attr(cx: &EarlyContext<'_>, attr: &Attribute, msrv: Option<RustcVersion>) {
     if_chain! {
+        if meets_msrv(msrv.as_ref(), &msrvs::TOOL_ATTRIBUTES);
         // check cfg_attr
         if attr.has_name(sym::cfg_attr);
         if let Some(items) = attr.meta_item_list();
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index bc302046b2d..d91b2e1f448 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -404,10 +404,21 @@ use crate::utils::conf::TryConf;
 /// level (i.e `#![cfg_attr(...)]`) will still be expanded even when using a pre-expansion pass.
 ///
 /// Used in `./src/driver.rs`.
-pub fn register_pre_expansion_lints(store: &mut rustc_lint::LintStore) {
+pub fn register_pre_expansion_lints(store: &mut rustc_lint::LintStore, sess: &Session, conf: &Conf) {
     // NOTE: Do not add any more pre-expansion passes. These should be removed eventually.
+
+    let msrv = conf.msrv.as_ref().and_then(|s| {
+        parse_msrv(s, None, None).or_else(|| {
+            sess.err(&format!(
+                "error reading Clippy's configuration file. `{}` is not a valid Rust version",
+                s
+            ));
+            None
+        })
+    });
+
     store.register_pre_expansion_pass(|| Box::new(write::Write::default()));
-    store.register_pre_expansion_pass(|| Box::new(attrs::EarlyAttributes));
+    store.register_pre_expansion_pass(move || Box::new(attrs::EarlyAttributes { msrv }));
     store.register_pre_expansion_pass(|| Box::new(dbg_macro::DbgMacro));
 }
 
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 122a5ce3fc8..3c4f114fe59 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -148,7 +148,7 @@ define_Conf! {
     ///
     /// Suppress lints whenever the suggested change would cause breakage for other crates.
     (avoid_breaking_exported_api: bool = true),
-    /// Lint: MANUAL_SPLIT_ONCE, MANUAL_STR_REPEAT, CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR, IF_THEN_SOME_ELSE_NONE, APPROX_CONSTANT.
+    /// Lint: MANUAL_SPLIT_ONCE, MANUAL_STR_REPEAT, CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR, IF_THEN_SOME_ELSE_NONE, APPROX_CONSTANT, DEPRECATED_CFG_ATTR.
     ///
     /// The minimum rust version that the project supports
     (msrv: Option<String> = None),
diff --git a/clippy_utils/src/msrvs.rs b/clippy_utils/src/msrvs.rs
index fa57dfbb57e..f3913203f4b 100644
--- a/clippy_utils/src/msrvs.rs
+++ b/clippy_utils/src/msrvs.rs
@@ -27,7 +27,7 @@ msrv_aliases! {
     1,36,0 { ITERATOR_COPIED }
     1,35,0 { OPTION_COPIED, RANGE_CONTAINS }
     1,34,0 { TRY_FROM }
-    1,30,0 { ITERATOR_FIND_MAP }
+    1,30,0 { ITERATOR_FIND_MAP, TOOL_ATTRIBUTES }
     1,17,0 { FIELD_INIT_SHORTHAND, STATIC_IN_CONST }
     1,16,0 { STR_REPEAT }
 }
diff --git a/src/driver.rs b/src/driver.rs
index 0c82f37d6a2..a8aa3a76abc 100644
--- a/src/driver.rs
+++ b/src/driver.rs
@@ -108,7 +108,7 @@ impl rustc_driver::Callbacks for ClippyCallbacks {
 
             let conf = clippy_lints::read_conf(sess);
             clippy_lints::register_plugins(lint_store, sess, &conf);
-            clippy_lints::register_pre_expansion_lints(lint_store);
+            clippy_lints::register_pre_expansion_lints(lint_store, sess, &conf);
             clippy_lints::register_renamed(lint_store);
         }));
 
diff --git a/tests/ui/min_rust_version_attr.rs b/tests/ui/min_rust_version_attr.rs
index 8d9fc5a864d..57ed453da10 100644
--- a/tests/ui/min_rust_version_attr.rs
+++ b/tests/ui/min_rust_version_attr.rs
@@ -137,6 +137,9 @@ fn unnest_or_patterns() {
     if let TS(0, x) | TS(1, x) = TS(0, 0) {}
 }
 
+#[cfg_attr(rustfmt, rustfmt_skip)]
+fn deprecated_cfg_attr() {}
+
 fn main() {
     filter_map_next();
     checked_conversion();
@@ -155,9 +158,9 @@ fn main() {
     unnest_or_patterns();
 }
 
-mod meets_msrv {
+mod just_under_msrv {
     #![feature(custom_inner_attributes)]
-    #![clippy::msrv = "1.45.0"]
+    #![clippy::msrv = "1.44.0"]
 
     fn main() {
         let s = "hello, world!";
@@ -167,9 +170,9 @@ mod meets_msrv {
     }
 }
 
-mod just_under_msrv {
+mod meets_msrv {
     #![feature(custom_inner_attributes)]
-    #![clippy::msrv = "1.46.0"]
+    #![clippy::msrv = "1.45.0"]
 
     fn main() {
         let s = "hello, world!";
@@ -181,7 +184,7 @@ mod just_under_msrv {
 
 mod just_above_msrv {
     #![feature(custom_inner_attributes)]
-    #![clippy::msrv = "1.44.0"]
+    #![clippy::msrv = "1.46.0"]
 
     fn main() {
         let s = "hello, world!";
diff --git a/tests/ui/min_rust_version_attr.stderr b/tests/ui/min_rust_version_attr.stderr
index 360dcfb230c..4388b78f832 100644
--- a/tests/ui/min_rust_version_attr.stderr
+++ b/tests/ui/min_rust_version_attr.stderr
@@ -1,12 +1,12 @@
 error: stripping a prefix manually
-  --> $DIR/min_rust_version_attr.rs:165:24
+  --> $DIR/min_rust_version_attr.rs:180:24
    |
 LL |             assert_eq!(s["hello, ".len()..].to_uppercase(), "WORLD!");
    |                        ^^^^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::manual-strip` implied by `-D warnings`
 note: the prefix was tested here
-  --> $DIR/min_rust_version_attr.rs:164:9
+  --> $DIR/min_rust_version_attr.rs:179:9
    |
 LL |         if s.starts_with("hello, ") {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -17,13 +17,13 @@ LL ~             assert_eq!(<stripped>.to_uppercase(), "WORLD!");
    |
 
 error: stripping a prefix manually
-  --> $DIR/min_rust_version_attr.rs:177:24
+  --> $DIR/min_rust_version_attr.rs:192:24
    |
 LL |             assert_eq!(s["hello, ".len()..].to_uppercase(), "WORLD!");
    |                        ^^^^^^^^^^^^^^^^^^^^
    |
 note: the prefix was tested here
-  --> $DIR/min_rust_version_attr.rs:176:9
+  --> $DIR/min_rust_version_attr.rs:191:9
    |
 LL |         if s.starts_with("hello, ") {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From 680923491a85044c79a66e1727116ad474ccb8cb Mon Sep 17 00:00:00 2001
From: Serial <69764315+Serial-ATA@users.noreply.github.com>
Date: Mon, 8 Nov 2021 22:09:26 -0500
Subject: Fix explicit_counter_loop suggestion for non-usize types

---
 clippy_lints/src/loops/explicit_counter_loop.rs | 58 +++++++++++++++----
 clippy_lints/src/loops/manual_memcpy.rs         |  2 +-
 clippy_lints/src/loops/utils.rs                 | 74 +++++++++++++++++--------
 tests/ui/explicit_counter_loop.rs               | 30 ++++++++++
 tests/ui/explicit_counter_loop.stderr           | 16 +++++-
 5 files changed, 145 insertions(+), 35 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/explicit_counter_loop.rs b/clippy_lints/src/loops/explicit_counter_loop.rs
index 98e60f7ed85..bf9326b2901 100644
--- a/clippy_lints/src/loops/explicit_counter_loop.rs
+++ b/clippy_lints/src/loops/explicit_counter_loop.rs
@@ -1,7 +1,7 @@
 use super::{
     get_span_of_entire_for_loop, make_iterator_snippet, IncrementVisitor, InitializeVisitor, EXPLICIT_COUNTER_LOOP,
 };
-use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::{get_enclosing_block, is_integer_const};
 use if_chain::if_chain;
@@ -9,6 +9,7 @@ use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_block, walk_expr};
 use rustc_hir::{Expr, Pat};
 use rustc_lint::LateContext;
+use rustc_middle::ty::{self, UintTy};
 
 // To trigger the EXPLICIT_COUNTER_LOOP lint, a variable must be
 // incremented exactly once in the loop body, and initialized to zero
@@ -32,26 +33,61 @@ pub(super) fn check<'tcx>(
             walk_block(&mut initialize_visitor, block);
 
             if_chain! {
-                if let Some((name, initializer)) = initialize_visitor.get_result();
+                if let Some((name, ty, initializer)) = initialize_visitor.get_result();
                 if is_integer_const(cx, initializer, 0);
                 then {
                     let mut applicability = Applicability::MachineApplicable;
 
                     let for_span = get_span_of_entire_for_loop(expr);
 
-                    span_lint_and_sugg(
+                    let int_name = match ty.map(ty::TyS::kind) {
+                        // usize or inferred
+                        Some(ty::Uint(UintTy::Usize)) | None => {
+                            span_lint_and_sugg(
+                                cx,
+                                EXPLICIT_COUNTER_LOOP,
+                                for_span.with_hi(arg.span.hi()),
+                                &format!("the variable `{}` is used as a loop counter", name),
+                                "consider using",
+                                format!(
+                                    "for ({}, {}) in {}.enumerate()",
+                                    name,
+                                    snippet_with_applicability(cx, pat.span, "item", &mut applicability),
+                                    make_iterator_snippet(cx, arg, &mut applicability),
+                                ),
+                                applicability,
+                            );
+                            return;
+                        }
+                        Some(ty::Int(int_ty)) => int_ty.name_str(),
+                        Some(ty::Uint(uint_ty)) => uint_ty.name_str(),
+                        _ => return,
+                    };
+
+                    span_lint_and_then(
                         cx,
                         EXPLICIT_COUNTER_LOOP,
                         for_span.with_hi(arg.span.hi()),
                         &format!("the variable `{}` is used as a loop counter", name),
-                        "consider using",
-                        format!(
-                            "for ({}, {}) in {}.enumerate()",
-                            name,
-                            snippet_with_applicability(cx, pat.span, "item", &mut applicability),
-                            make_iterator_snippet(cx, arg, &mut applicability),
-                        ),
-                        applicability,
+                        |diag| {
+                            diag.span_suggestion(
+                                for_span.with_hi(arg.span.hi()),
+                                "consider using",
+                                format!(
+                                    "for ({}, {}) in (0_{}..).zip({})",
+                                    name,
+                                    snippet_with_applicability(cx, pat.span, "item", &mut applicability),
+                                    int_name,
+                                    make_iterator_snippet(cx, arg, &mut applicability),
+                                ),
+                                applicability,
+                            );
+
+                            diag.note(&format!(
+                                "`{}` is of type `{}`, making it ineligible for `Iterator::enumerate`",
+                                name, int_name
+                            ));
+                        },
                     );
                 }
             }
diff --git a/clippy_lints/src/loops/manual_memcpy.rs b/clippy_lints/src/loops/manual_memcpy.rs
index 6bdc560efd7..f6a673f7135 100644
--- a/clippy_lints/src/loops/manual_memcpy.rs
+++ b/clippy_lints/src/loops/manual_memcpy.rs
@@ -442,7 +442,7 @@ fn get_loop_counters<'a, 'tcx>(
                 let mut initialize_visitor = InitializeVisitor::new(cx, expr, var_id);
                 walk_block(&mut initialize_visitor, block);
 
-                initialize_visitor.get_result().map(|(_, initializer)| Start {
+                initialize_visitor.get_result().map(|(_, _, initializer)| Start {
                     id: var_id,
                     kind: StartKind::Counter { initializer },
                 })
diff --git a/clippy_lints/src/loops/utils.rs b/clippy_lints/src/loops/utils.rs
index f9f515cc40a..c1e367b344a 100644
--- a/clippy_lints/src/loops/utils.rs
+++ b/clippy_lints/src/loops/utils.rs
@@ -1,14 +1,17 @@
 use clippy_utils::ty::{has_iter_method, implements_trait};
 use clippy_utils::{get_parent_expr, is_integer_const, path_to_local, path_to_local_id, sugg};
 use if_chain::if_chain;
+use rustc_ast::ast::{LitIntType, LitKind};
 use rustc_errors::Applicability;
-use rustc_hir::intravisit::{walk_expr, walk_pat, walk_stmt, NestedVisitorMap, Visitor};
-use rustc_hir::HirIdMap;
-use rustc_hir::{BinOpKind, BorrowKind, Expr, ExprKind, HirId, Mutability, Pat, PatKind, Stmt, StmtKind};
+use rustc_hir::intravisit::{walk_expr, walk_local, walk_pat, walk_stmt, NestedVisitorMap, Visitor};
+use rustc_hir::{BinOpKind, BorrowKind, Expr, ExprKind, HirId, HirIdMap, Local, Mutability, Pat, PatKind, Stmt};
 use rustc_lint::LateContext;
 use rustc_middle::hir::map::Map;
+use rustc_middle::ty::Ty;
 use rustc_span::source_map::Span;
+use rustc_span::source_map::Spanned;
 use rustc_span::symbol::{sym, Symbol};
+use rustc_typeck::hir_ty_to_ty;
 use std::iter::Iterator;
 
 #[derive(Debug, PartialEq)]
@@ -106,10 +109,11 @@ impl<'a, 'tcx> Visitor<'tcx> for IncrementVisitor<'a, 'tcx> {
 }
 
 enum InitializeVisitorState<'hir> {
-    Initial,          // Not examined yet
-    Declared(Symbol), // Declared but not (yet) initialized
+    Initial,                            // Not examined yet
+    Declared(Symbol, Option<Ty<'hir>>), // Declared but not (yet) initialized
     Initialized {
         name: Symbol,
+        ty: Option<Ty<'hir>>,
         initializer: &'hir Expr<'hir>,
     },
     DontWarn,
@@ -138,9 +142,9 @@ impl<'a, 'tcx> InitializeVisitor<'a, 'tcx> {
         }
     }
 
-    pub(super) fn get_result(&self) -> Option<(Symbol, &'tcx Expr<'tcx>)> {
-        if let InitializeVisitorState::Initialized { name, initializer } = self.state {
-            Some((name, initializer))
+    pub(super) fn get_result(&self) -> Option<(Symbol, Option<Ty<'tcx>>, &'tcx Expr<'tcx>)> {
+        if let InitializeVisitorState::Initialized { name, ty, initializer } = self.state {
+            Some((name, ty, initializer))
         } else {
             None
         }
@@ -150,22 +154,25 @@ impl<'a, 'tcx> InitializeVisitor<'a, 'tcx> {
 impl<'a, 'tcx> Visitor<'tcx> for InitializeVisitor<'a, 'tcx> {
     type Map = Map<'tcx>;
 
-    fn visit_stmt(&mut self, stmt: &'tcx Stmt<'_>) {
+    fn visit_local(&mut self, l: &'tcx Local<'_>) {
         // Look for declarations of the variable
         if_chain! {
-            if let StmtKind::Local(local) = stmt.kind;
-            if local.pat.hir_id == self.var_id;
-            if let PatKind::Binding(.., ident, _) = local.pat.kind;
+            if l.pat.hir_id == self.var_id;
+            if let PatKind::Binding(.., ident, _) = l.pat.kind;
             then {
-                self.state = local.init.map_or(InitializeVisitorState::Declared(ident.name), |init| {
+                let ty = l.ty.map(|ty| hir_ty_to_ty(self.cx.tcx, ty));
+
+                self.state = l.init.map_or(InitializeVisitorState::Declared(ident.name, ty), |init| {
                     InitializeVisitorState::Initialized {
                         initializer: init,
+                        ty,
                         name: ident.name,
                     }
                 })
             }
         }
-        walk_stmt(self, stmt);
+
+        walk_local(self, l);
     }
 
     fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
@@ -195,15 +202,38 @@ impl<'a, 'tcx> Visitor<'tcx> for InitializeVisitor<'a, 'tcx> {
                         self.state = InitializeVisitorState::DontWarn;
                     },
                     ExprKind::Assign(lhs, rhs, _) if lhs.hir_id == expr.hir_id => {
-                        self.state = if_chain! {
-                            if self.depth == 0;
-                            if let InitializeVisitorState::Declared(name)
-                                | InitializeVisitorState::Initialized { name, ..} = self.state;
-                            then {
-                                InitializeVisitorState::Initialized { initializer: rhs, name }
-                            } else {
-                                InitializeVisitorState::DontWarn
+                        self.state = if self.depth == 0 {
+                            match self.state {
+                                InitializeVisitorState::Declared(name, mut ty) => {
+                                    if ty.is_none() {
+                                        if let ExprKind::Lit(Spanned {
+                                            node: LitKind::Int(_, LitIntType::Unsuffixed),
+                                            ..
+                                        }) = rhs.kind
+                                        {
+                                            ty = None;
+                                        } else {
+                                            ty = self.cx.typeck_results().expr_ty_opt(rhs);
+                                        }
+                                    }
+
+                                    InitializeVisitorState::Initialized {
+                                        initializer: rhs,
+                                        ty,
+                                        name,
+                                    }
+                                },
+                                InitializeVisitorState::Initialized { ty, name, .. } => {
+                                    InitializeVisitorState::Initialized {
+                                        initializer: rhs,
+                                        ty,
+                                        name,
+                                    }
+                                },
+                                _ => InitializeVisitorState::DontWarn,
                             }
+                        } else {
+                            InitializeVisitorState::DontWarn
                         }
                     },
                     ExprKind::AddrOf(BorrowKind::Ref, mutability, _) if mutability == Mutability::Mut => {
diff --git a/tests/ui/explicit_counter_loop.rs b/tests/ui/explicit_counter_loop.rs
index 81d8221bd13..aa966761feb 100644
--- a/tests/ui/explicit_counter_loop.rs
+++ b/tests/ui/explicit_counter_loop.rs
@@ -158,3 +158,33 @@ mod issue_4677 {
         }
     }
 }
+
+mod issue_7920 {
+    pub fn test() {
+        let slice = &[1, 2, 3];
+
+        let index_usize: usize = 0;
+        let mut idx_usize: usize = 0;
+
+        // should suggest `enumerate`
+        for _item in slice {
+            if idx_usize == index_usize {
+                break;
+            }
+
+            idx_usize += 1;
+        }
+
+        let index_u32: u32 = 0;
+        let mut idx_u32: u32 = 0;
+
+        // should suggest `zip`
+        for _item in slice {
+            if idx_u32 == index_u32 {
+                break;
+            }
+
+            idx_u32 += 1;
+        }
+    }
+}
diff --git a/tests/ui/explicit_counter_loop.stderr b/tests/ui/explicit_counter_loop.stderr
index 4cbacffe87b..9edddea651c 100644
--- a/tests/ui/explicit_counter_loop.stderr
+++ b/tests/ui/explicit_counter_loop.stderr
@@ -42,5 +42,19 @@ error: the variable `count` is used as a loop counter
 LL |         for _i in 3..10 {
    |         ^^^^^^^^^^^^^^^ help: consider using: `for (count, _i) in (3..10).enumerate()`
 
-error: aborting due to 7 previous errors
+error: the variable `idx_usize` is used as a loop counter
+  --> $DIR/explicit_counter_loop.rs:170:9
+   |
+LL |         for _item in slice {
+   |         ^^^^^^^^^^^^^^^^^^ help: consider using: `for (idx_usize, _item) in slice.into_iter().enumerate()`
+
+error: the variable `idx_u32` is used as a loop counter
+  --> $DIR/explicit_counter_loop.rs:182:9
+   |
+LL |         for _item in slice {
+   |         ^^^^^^^^^^^^^^^^^^ help: consider using: `for (idx_u32, _item) in (0_u32..).zip(slice.into_iter())`
+   |
+   = note: `idx_u32` is of type `u32`, making it ineligible for `Iterator::enumerate`
+
+error: aborting due to 9 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 98416d7f6ca4cc803d423e0897ccdf1deb08fe31 Mon Sep 17 00:00:00 2001
From: Michael Wright <mikerite@lavabit.com>
Date: Tue, 9 Nov 2021 05:44:02 +0200
Subject: Remove `unimplemented!()` case in matches code

This unbounded case never actually happens because `all_ranges(..)` uses
the scrutinee type bounds for open ranges. Switch to our own `Bound`
enum so that we don't have this case.
---
 clippy_lints/src/matches.rs | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index 88b1685f52f..6973a3743c7 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -33,7 +33,6 @@ use rustc_span::source_map::{Span, Spanned};
 use rustc_span::sym;
 use std::cmp::Ordering;
 use std::collections::hash_map::Entry;
-use std::ops::Bound;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -1596,7 +1595,7 @@ fn opt_parent_let<'a>(cx: &LateContext<'a>, ex: &Expr<'a>) -> Option<&'a Local<'
     None
 }
 
-/// Gets all arms that are unbounded `PatRange`s.
+/// Gets the ranges for each range pattern arm. Applies `ty` bounds for open ranges.
 fn all_ranges<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>], ty: Ty<'tcx>) -> Vec<SpannedRange<FullInt>> {
     arms.iter()
         .filter_map(|arm| {
@@ -1637,6 +1636,12 @@ fn all_ranges<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>], ty: Ty<'tcx>)
         .collect()
 }
 
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub enum Bound<T> {
+    Included(T),
+    Excluded(T),
+}
+
 #[derive(Debug, Eq, PartialEq)]
 pub struct SpannedRange<T> {
     pub span: Span,
@@ -1730,8 +1735,6 @@ where
                         value_cmp
                     }
                 },
-                // Range patterns cannot be unbounded (yet)
-                (Bound::Unbounded, _) | (_, Bound::Unbounded) => unimplemented!(),
                 (Bound::Included(a), Bound::Excluded(b)) => match a.cmp(&b) {
                     Ordering::Equal => Ordering::Greater,
                     other => other,
-- 
cgit 1.4.1-3-g733a5


From 949b25981cdaf2c7708ee257651f1cb9dc951332 Mon Sep 17 00:00:00 2001
From: Michael Wright <mikerite@lavabit.com>
Date: Tue, 9 Nov 2021 05:44:02 +0200
Subject: Change `Bound` to `EndBound`

Only the end bounds of ranges can actually be included or excluded. This
commit changes the SpannedRange type to reflect that. Update `Kind::value`
to and `Kind::cmp` for this change. `Kind::cmp` gets flipped to check value
first and then the bound details and is much shorter.
---
 clippy_lints/src/matches.rs | 78 +++++++++++++++++++++------------------------
 1 file changed, 36 insertions(+), 42 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index 6973a3743c7..7a528cb0b38 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -1614,8 +1614,8 @@ fn all_ranges<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>], ty: Ty<'tcx>)
                     let rhs_val = rhs.int_value(cx, ty)?;
 
                     let rhs_bound = match range_end {
-                        RangeEnd::Included => Bound::Included(rhs_val),
-                        RangeEnd::Excluded => Bound::Excluded(rhs_val),
+                        RangeEnd::Included => EndBound::Included(rhs_val),
+                        RangeEnd::Excluded => EndBound::Excluded(rhs_val),
                     };
                     return Some(SpannedRange {
                         span: pat.span,
@@ -1627,7 +1627,7 @@ fn all_ranges<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>], ty: Ty<'tcx>)
                     let value = constant_full_int(cx, cx.typeck_results(), value)?;
                     return Some(SpannedRange {
                         span: pat.span,
-                        node: (value, Bound::Included(value)),
+                        node: (value, EndBound::Included(value)),
                     });
                 }
             }
@@ -1636,8 +1636,8 @@ fn all_ranges<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>], ty: Ty<'tcx>)
         .collect()
 }
 
-#[derive(Copy, Clone, Debug, Eq, PartialEq)]
-pub enum Bound<T> {
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum EndBound<T> {
     Included(T),
     Excluded(T),
 }
@@ -1645,7 +1645,7 @@ pub enum Bound<T> {
 #[derive(Debug, Eq, PartialEq)]
 pub struct SpannedRange<T> {
     pub span: Span,
-    pub node: (T, Bound<T>),
+    pub node: (T, EndBound<T>),
 }
 
 // Checks if arm has the form `None => None`
@@ -1701,14 +1701,13 @@ where
     #[derive(Copy, Clone, Debug, Eq, PartialEq)]
     enum Kind<'a, T> {
         Start(T, &'a SpannedRange<T>),
-        End(Bound<T>, &'a SpannedRange<T>),
+        End(EndBound<T>, &'a SpannedRange<T>),
     }
 
     impl<'a, T: Copy> Kind<'a, T> {
-        fn value(self) -> Bound<T> {
+        fn value(self) -> T {
             match self {
-                Kind::Start(t, _) => Bound::Included(t),
-                Kind::End(t, _) => t,
+                Kind::Start(t, _) | Kind::End(EndBound::Included(t) | EndBound::Excluded(t), _) => t,
             }
         }
     }
@@ -1721,28 +1720,23 @@ where
 
     impl<'a, T: Copy + Ord> Ord for Kind<'a, T> {
         fn cmp(&self, other: &Self) -> Ordering {
-            match (self.value(), other.value()) {
-                (Bound::Included(a), Bound::Included(b)) | (Bound::Excluded(a), Bound::Excluded(b)) => {
-                    let value_cmp = a.cmp(&b);
-                    // In the case of ties, starts come before ends
-                    if value_cmp == Ordering::Equal {
-                        match (self, other) {
-                            (Kind::Start(..), Kind::End(..)) => Ordering::Less,
-                            (Kind::End(..), Kind::Start(..)) => Ordering::Greater,
-                            _ => Ordering::Equal,
-                        }
-                    } else {
-                        value_cmp
-                    }
-                },
-                (Bound::Included(a), Bound::Excluded(b)) => match a.cmp(&b) {
-                    Ordering::Equal => Ordering::Greater,
-                    other => other,
-                },
-                (Bound::Excluded(a), Bound::Included(b)) => match a.cmp(&b) {
-                    Ordering::Equal => Ordering::Less,
-                    other => other,
+            match self.value().cmp(&other.value()) {
+                Ordering::Equal => match (self, other) {
+                    // End excluded before start and end included
+                    (Kind::End(EndBound::Excluded(_), _), Kind::Start(..) | Kind::End(EndBound::Included(_), _)) => {
+                        Ordering::Less
+                    },
+                    (Kind::Start(..) | Kind::End(EndBound::Included(_), _), Kind::End(EndBound::Excluded(_), _)) => {
+                        Ordering::Greater
+                    },
+
+                    // Start before end included
+                    (Kind::Start(..), Kind::End(EndBound::Included(_), _)) => Ordering::Less,
+                    (Kind::End(EndBound::Included(_), _), Kind::Start(..)) => Ordering::Greater,
+
+                    _ => Ordering::Equal,
                 },
+                other => other,
             }
         }
     }
@@ -2224,29 +2218,29 @@ fn test_overlapping() {
     };
 
     assert_eq!(None, overlapping::<u8>(&[]));
-    assert_eq!(None, overlapping(&[sp(1, Bound::Included(4))]));
+    assert_eq!(None, overlapping(&[sp(1, EndBound::Included(4))]));
     assert_eq!(
         None,
-        overlapping(&[sp(1, Bound::Included(4)), sp(5, Bound::Included(6))])
+        overlapping(&[sp(1, EndBound::Included(4)), sp(5, EndBound::Included(6))])
     );
     assert_eq!(
         None,
         overlapping(&[
-            sp(1, Bound::Included(4)),
-            sp(5, Bound::Included(6)),
-            sp(10, Bound::Included(11))
+            sp(1, EndBound::Included(4)),
+            sp(5, EndBound::Included(6)),
+            sp(10, EndBound::Included(11))
         ],)
     );
     assert_eq!(
-        Some((&sp(1, Bound::Included(4)), &sp(3, Bound::Included(6)))),
-        overlapping(&[sp(1, Bound::Included(4)), sp(3, Bound::Included(6))])
+        Some((&sp(1, EndBound::Included(4)), &sp(3, EndBound::Included(6)))),
+        overlapping(&[sp(1, EndBound::Included(4)), sp(3, EndBound::Included(6))])
     );
     assert_eq!(
-        Some((&sp(5, Bound::Included(6)), &sp(6, Bound::Included(11)))),
+        Some((&sp(5, EndBound::Included(6)), &sp(6, EndBound::Included(11)))),
         overlapping(&[
-            sp(1, Bound::Included(4)),
-            sp(5, Bound::Included(6)),
-            sp(6, Bound::Included(11))
+            sp(1, EndBound::Included(4)),
+            sp(5, EndBound::Included(6)),
+            sp(6, EndBound::Included(11))
         ],)
     );
 }
-- 
cgit 1.4.1-3-g733a5


From f829523340a84624b07a929b5092a5b996f090a6 Mon Sep 17 00:00:00 2001
From: Michael Wright <mikerite@lavabit.com>
Date: Tue, 9 Nov 2021 05:44:02 +0200
Subject: Simplify range comparison code

Reword the `Kind` type so that the `cmp` function is simpler.
---
 clippy_lints/src/matches.rs | 65 +++++++++++++++++----------------------------
 1 file changed, 24 insertions(+), 41 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index 7a528cb0b38..cedf0777ac4 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -1698,75 +1698,58 @@ pub fn overlapping<T>(ranges: &[SpannedRange<T>]) -> Option<(&SpannedRange<T>, &
 where
     T: Copy + Ord,
 {
-    #[derive(Copy, Clone, Debug, Eq, PartialEq)]
-    enum Kind<'a, T> {
-        Start(T, &'a SpannedRange<T>),
-        End(EndBound<T>, &'a SpannedRange<T>),
+    #[derive(Copy, Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
+    enum BoundKind {
+        EndExcluded,
+        Start,
+        EndIncluded,
     }
 
-    impl<'a, T: Copy> Kind<'a, T> {
-        fn value(self) -> T {
-            match self {
-                Kind::Start(t, _) | Kind::End(EndBound::Included(t) | EndBound::Excluded(t), _) => t,
-            }
-        }
-    }
+    #[derive(Copy, Clone, Debug, Eq, PartialEq)]
+    struct RangeBound<'a, T>(T, BoundKind, &'a SpannedRange<T>);
 
-    impl<'a, T: Copy + Ord> PartialOrd for Kind<'a, T> {
+    impl<'a, T: Copy + Ord> PartialOrd for RangeBound<'a, T> {
         fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
             Some(self.cmp(other))
         }
     }
 
-    impl<'a, T: Copy + Ord> Ord for Kind<'a, T> {
-        fn cmp(&self, other: &Self) -> Ordering {
-            match self.value().cmp(&other.value()) {
-                Ordering::Equal => match (self, other) {
-                    // End excluded before start and end included
-                    (Kind::End(EndBound::Excluded(_), _), Kind::Start(..) | Kind::End(EndBound::Included(_), _)) => {
-                        Ordering::Less
-                    },
-                    (Kind::Start(..) | Kind::End(EndBound::Included(_), _), Kind::End(EndBound::Excluded(_), _)) => {
-                        Ordering::Greater
-                    },
-
-                    // Start before end included
-                    (Kind::Start(..), Kind::End(EndBound::Included(_), _)) => Ordering::Less,
-                    (Kind::End(EndBound::Included(_), _), Kind::Start(..)) => Ordering::Greater,
-
-                    _ => Ordering::Equal,
-                },
-                other => other,
-            }
+    impl<'a, T: Copy + Ord> Ord for RangeBound<'a, T> {
+        fn cmp(&self, RangeBound(other_value, other_kind, _): &Self) -> Ordering {
+            let RangeBound(self_value, self_kind, _) = *self;
+            (self_value, self_kind).cmp(&(*other_value, *other_kind))
         }
     }
 
     let mut values = Vec::with_capacity(2 * ranges.len());
 
-    for r in ranges {
-        values.push(Kind::Start(r.node.0, r));
-        values.push(Kind::End(r.node.1, r));
+    for r @ SpannedRange { node: (start, end), .. } in ranges {
+        values.push(RangeBound(*start, BoundKind::Start, r));
+        values.push(match end {
+            EndBound::Excluded(val) => RangeBound(*val, BoundKind::EndExcluded, r),
+            EndBound::Included(val) => RangeBound(*val, BoundKind::EndIncluded, r),
+        });
     }
 
     values.sort();
 
     let mut started = vec![];
 
-    for value in values {
-        match value {
-            Kind::Start(_, r) => started.push(r),
-            Kind::End(_, er) => {
+    for RangeBound(_, kind, r) in values {
+        match kind {
+            BoundKind::Start => started.push(r),
+            BoundKind::EndExcluded | BoundKind::EndIncluded => {
                 let mut overlap = None;
 
                 while let Some(sr) = started.pop() {
-                    if sr == er {
+                    if sr == r {
                         break;
                     }
                     overlap = Some(sr);
                 }
 
                 if let Some(sr) = overlap {
-                    return Some((er, sr));
+                    return Some((r, sr));
                 }
             },
         }
-- 
cgit 1.4.1-3-g733a5


From c8f909ee54f74b5fefa0d16afe92188368c9ccac Mon Sep 17 00:00:00 2001
From: Michael Wright <mikerite@lavabit.com>
Date: Tue, 9 Nov 2021 05:44:02 +0200
Subject: Improve variable naming

---
 clippy_lints/src/matches.rs | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index cedf0777ac4..206cf8928be 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -1735,21 +1735,21 @@ where
 
     let mut started = vec![];
 
-    for RangeBound(_, kind, r) in values {
+    for RangeBound(_, kind, range) in values {
         match kind {
-            BoundKind::Start => started.push(r),
+            BoundKind::Start => started.push(range),
             BoundKind::EndExcluded | BoundKind::EndIncluded => {
                 let mut overlap = None;
 
-                while let Some(sr) = started.pop() {
-                    if sr == r {
+                while let Some(last_started) = started.pop() {
+                    if last_started == range {
                         break;
                     }
-                    overlap = Some(sr);
+                    overlap = Some(last_started);
                 }
 
-                if let Some(sr) = overlap {
-                    return Some((r, sr));
+                if let Some(first_overlapping) = overlap {
+                    return Some((range, first_overlapping));
                 }
             },
         }
-- 
cgit 1.4.1-3-g733a5


From 81fa75835652040f2773c44b34830a1107c07550 Mon Sep 17 00:00:00 2001
From: Michael Wright <mikerite@lavabit.com>
Date: Tue, 9 Nov 2021 05:44:02 +0200
Subject: Improve variable naming 2

---
 clippy_lints/src/matches.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index 206cf8928be..97a19d55ccf 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -1601,17 +1601,17 @@ fn all_ranges<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>], ty: Ty<'tcx>)
         .filter_map(|arm| {
             if let Arm { pat, guard: None, .. } = *arm {
                 if let PatKind::Range(ref lhs, ref rhs, range_end) = pat.kind {
-                    let lhs = match lhs {
+                    let lhs_const = match lhs {
                         Some(lhs) => constant(cx, cx.typeck_results(), lhs)?.0,
                         None => miri_to_const(ty.numeric_min_val(cx.tcx)?)?,
                     };
-                    let rhs = match rhs {
+                    let rhs_const = match rhs {
                         Some(rhs) => constant(cx, cx.typeck_results(), rhs)?.0,
                         None => miri_to_const(ty.numeric_max_val(cx.tcx)?)?,
                     };
 
-                    let lhs_val = lhs.int_value(cx, ty)?;
-                    let rhs_val = rhs.int_value(cx, ty)?;
+                    let lhs_val = lhs_const.int_value(cx, ty)?;
+                    let rhs_val = rhs_const.int_value(cx, ty)?;
 
                     let rhs_bound = match range_end {
                         RangeEnd::Included => EndBound::Included(rhs_val),
-- 
cgit 1.4.1-3-g733a5


From 8b7691551acb5f27fe54a6b609f12c88eba78631 Mon Sep 17 00:00:00 2001
From: Michael Wright <mikerite@lavabit.com>
Date: Tue, 9 Nov 2021 05:44:02 +0200
Subject: matches: remove `pub` from some items

There is no reason for these to be `pub`. They aren't used anywhere
else.
---
 clippy_lints/src/matches.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index 97a19d55ccf..8e170f86cbe 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -1643,7 +1643,7 @@ pub enum EndBound<T> {
 }
 
 #[derive(Debug, Eq, PartialEq)]
-pub struct SpannedRange<T> {
+struct SpannedRange<T> {
     pub span: Span,
     pub node: (T, EndBound<T>),
 }
@@ -1694,7 +1694,7 @@ where
     ref_count > 1
 }
 
-pub fn overlapping<T>(ranges: &[SpannedRange<T>]) -> Option<(&SpannedRange<T>, &SpannedRange<T>)>
+fn overlapping<T>(ranges: &[SpannedRange<T>]) -> Option<(&SpannedRange<T>, &SpannedRange<T>)>
 where
     T: Copy + Ord,
 {
-- 
cgit 1.4.1-3-g733a5


From e54c341d05265e3293649d65481eacb06994bef5 Mon Sep 17 00:00:00 2001
From: Serial <69764315+Serial-ATA@users.noreply.github.com>
Date: Mon, 8 Nov 2021 18:31:18 -0500
Subject: Fix suggestion for deref expressions in redundant_pattern_matching

---
 clippy_lints/src/matches.rs                       | 14 ++++++++++----
 tests/ui/redundant_pattern_matching_option.fixed  |  6 ++++++
 tests/ui/redundant_pattern_matching_option.rs     |  6 ++++++
 tests/ui/redundant_pattern_matching_option.stderr | 14 +++++++++++++-
 tests/ui/redundant_pattern_matching_result.fixed  |  4 ++--
 tests/ui/redundant_pattern_matching_result.stderr |  4 ++--
 6 files changed, 39 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index 08b652f4f3f..0f7c7dcc7a9 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -1785,7 +1785,8 @@ mod redundant_pattern_match {
     use super::REDUNDANT_PATTERN_MATCHING;
     use clippy_utils::diagnostics::span_lint_and_then;
     use clippy_utils::higher;
-    use clippy_utils::source::{snippet, snippet_with_applicability};
+    use clippy_utils::source::snippet;
+    use clippy_utils::sugg::Sugg;
     use clippy_utils::ty::{implements_trait, is_type_diagnostic_item, is_type_lang_item, match_type};
     use clippy_utils::{is_lang_ctor, is_qpath_def_path, is_trait_method, paths};
     use if_chain::if_chain;
@@ -1795,7 +1796,7 @@ mod redundant_pattern_match {
     use rustc_hir::LangItem::{OptionNone, OptionSome, PollPending, PollReady, ResultErr, ResultOk};
     use rustc_hir::{
         intravisit::{walk_expr, ErasedMap, NestedVisitorMap, Visitor},
-        Arm, Block, Expr, ExprKind, LangItem, MatchSource, Node, Pat, PatKind, QPath,
+        Arm, Block, Expr, ExprKind, LangItem, MatchSource, Node, Pat, PatKind, QPath, UnOp,
     };
     use rustc_lint::LateContext;
     use rustc_middle::ty::{self, subst::GenericArgKind, Ty};
@@ -2049,8 +2050,10 @@ mod redundant_pattern_match {
 
         let result_expr = match &let_expr.kind {
             ExprKind::AddrOf(_, _, borrowed) => borrowed,
+            ExprKind::Unary(UnOp::Deref, deref) => deref,
             _ => let_expr,
         };
+
         span_lint_and_then(
             cx,
             REDUNDANT_PATTERN_MATCHING,
@@ -2069,12 +2072,15 @@ mod redundant_pattern_match {
                 // ^^^^^^^^^^^^^^^^^^^
                 let span = expr_span.until(op_span.shrink_to_hi());
 
-                let mut app = if needs_drop {
+                let app = if needs_drop {
                     Applicability::MaybeIncorrect
                 } else {
                     Applicability::MachineApplicable
                 };
-                let sugg = snippet_with_applicability(cx, op_span, "_", &mut app);
+
+                let sugg = Sugg::hir_with_macro_callsite(cx, result_expr, "_")
+                    .maybe_par()
+                    .to_string();
 
                 diag.span_suggestion(span, "try this", format!("{} {}.{}", keyword, sugg, good_method), app);
 
diff --git a/tests/ui/redundant_pattern_matching_option.fixed b/tests/ui/redundant_pattern_matching_option.fixed
index 813e268a60c..cc93859269c 100644
--- a/tests/ui/redundant_pattern_matching_option.fixed
+++ b/tests/ui/redundant_pattern_matching_option.fixed
@@ -80,3 +80,9 @@ const fn issue6067() {
 
     None::<()>.is_none();
 }
+
+#[allow(clippy::deref_addrof, dead_code)]
+fn issue7921() {
+    if (&None::<()>).is_none() {}
+    if (&None::<()>).is_none() {}
+}
diff --git a/tests/ui/redundant_pattern_matching_option.rs b/tests/ui/redundant_pattern_matching_option.rs
index 82a98468943..280dca40c01 100644
--- a/tests/ui/redundant_pattern_matching_option.rs
+++ b/tests/ui/redundant_pattern_matching_option.rs
@@ -95,3 +95,9 @@ const fn issue6067() {
         None => true,
     };
 }
+
+#[allow(clippy::deref_addrof, dead_code)]
+fn issue7921() {
+    if let None = *(&None::<()>) {}
+    if let None = *&None::<()> {}
+}
diff --git a/tests/ui/redundant_pattern_matching_option.stderr b/tests/ui/redundant_pattern_matching_option.stderr
index 3a58e5ad7be..27ff812ba45 100644
--- a/tests/ui/redundant_pattern_matching_option.stderr
+++ b/tests/ui/redundant_pattern_matching_option.stderr
@@ -130,5 +130,17 @@ LL | |         None => true,
 LL | |     };
    | |_____^ help: try this: `None::<()>.is_none()`
 
-error: aborting due to 19 previous errors
+error: redundant pattern matching, consider using `is_none()`
+  --> $DIR/redundant_pattern_matching_option.rs:101:12
+   |
+LL |     if let None = *(&None::<()>) {}
+   |     -------^^^^----------------- help: try this: `if (&None::<()>).is_none()`
+
+error: redundant pattern matching, consider using `is_none()`
+  --> $DIR/redundant_pattern_matching_option.rs:102:12
+   |
+LL |     if let None = *&None::<()> {}
+   |     -------^^^^--------------- help: try this: `if (&None::<()>).is_none()`
+
+error: aborting due to 21 previous errors
 
diff --git a/tests/ui/redundant_pattern_matching_result.fixed b/tests/ui/redundant_pattern_matching_result.fixed
index d7af5d762ae..83c783385ef 100644
--- a/tests/ui/redundant_pattern_matching_result.fixed
+++ b/tests/ui/redundant_pattern_matching_result.fixed
@@ -70,8 +70,8 @@ fn issue5504() {
     }
 
     fn try_result_opt() -> Result<i32, i32> {
-        while r#try!(result_opt()).is_some() {}
-        if r#try!(result_opt()).is_some() {}
+        while (r#try!(result_opt())).is_some() {}
+        if (r#try!(result_opt())).is_some() {}
         Ok(42)
     }
 
diff --git a/tests/ui/redundant_pattern_matching_result.stderr b/tests/ui/redundant_pattern_matching_result.stderr
index e06f095da20..d674d061e4d 100644
--- a/tests/ui/redundant_pattern_matching_result.stderr
+++ b/tests/ui/redundant_pattern_matching_result.stderr
@@ -88,13 +88,13 @@ error: redundant pattern matching, consider using `is_some()`
   --> $DIR/redundant_pattern_matching_result.rs:85:19
    |
 LL |         while let Some(_) = r#try!(result_opt()) {}
-   |         ----------^^^^^^^----------------------- help: try this: `while r#try!(result_opt()).is_some()`
+   |         ----------^^^^^^^----------------------- help: try this: `while (r#try!(result_opt())).is_some()`
 
 error: redundant pattern matching, consider using `is_some()`
   --> $DIR/redundant_pattern_matching_result.rs:86:16
    |
 LL |         if let Some(_) = r#try!(result_opt()) {}
-   |         -------^^^^^^^----------------------- help: try this: `if r#try!(result_opt()).is_some()`
+   |         -------^^^^^^^----------------------- help: try this: `if (r#try!(result_opt())).is_some()`
 
 error: redundant pattern matching, consider using `is_some()`
   --> $DIR/redundant_pattern_matching_result.rs:92:12
-- 
cgit 1.4.1-3-g733a5


From 33822012ec905a589ef16041a051095154b995ca Mon Sep 17 00:00:00 2001
From: 5225225 <5225225@mailbox.org>
Date: Mon, 8 Nov 2021 20:44:50 +0000
Subject: Lint for bool to integer casts in `cast_lossless`

---
 clippy_lints/src/bool_assert_comparison.rs |  2 +-
 clippy_lints/src/casts/cast_lossless.rs    |  2 +-
 clippy_lints/src/casts/mod.rs              | 14 +++--
 tests/ui/cast_lossless_bool.fixed          | 42 +++++++++++++++
 tests/ui/cast_lossless_bool.rs             | 42 +++++++++++++++
 tests/ui/cast_lossless_bool.stderr         | 82 ++++++++++++++++++++++++++++++
 6 files changed, 177 insertions(+), 7 deletions(-)
 create mode 100644 tests/ui/cast_lossless_bool.fixed
 create mode 100644 tests/ui/cast_lossless_bool.rs
 create mode 100644 tests/ui/cast_lossless_bool.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/bool_assert_comparison.rs b/clippy_lints/src/bool_assert_comparison.rs
index cdc192a47e4..2e061267ff5 100644
--- a/clippy_lints/src/bool_assert_comparison.rs
+++ b/clippy_lints/src/bool_assert_comparison.rs
@@ -72,7 +72,7 @@ impl<'tcx> LateLintPass<'tcx> for BoolAssertComparison {
             if let Some(span) = is_direct_expn_of(expr.span, mac) {
                 if let Some(args) = higher::extract_assert_macro_args(expr) {
                     if let [a, b, ..] = args[..] {
-                        let nb_bool_args = is_bool_lit(a) as usize + is_bool_lit(b) as usize;
+                        let nb_bool_args = usize::from(is_bool_lit(a)) + usize::from(is_bool_lit(b));
 
                         if nb_bool_args != 1 {
                             // If there are two boolean arguments, we definitely don't understand
diff --git a/clippy_lints/src/casts/cast_lossless.rs b/clippy_lints/src/casts/cast_lossless.rs
index 869deecfbd5..75dc9098033 100644
--- a/clippy_lints/src/casts/cast_lossless.rs
+++ b/clippy_lints/src/casts/cast_lossless.rs
@@ -72,7 +72,7 @@ fn should_lint(cx: &LateContext<'_>, expr: &Expr<'_>, cast_from: Ty<'_>, cast_to
             };
             from_nbits < to_nbits
         },
-
+        (false, true) if matches!(cast_from.kind(), ty::Bool) => true,
         (_, _) => {
             matches!(cast_from.kind(), ty::Float(FloatTy::F32)) && matches!(cast_to.kind(), ty::Float(FloatTy::F64))
         },
diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index 233abd17894..108f6fbc924 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -426,12 +426,16 @@ impl<'tcx> LateLintPass<'tcx> for Casts {
             fn_to_numeric_cast_any::check(cx, expr, cast_expr, cast_from, cast_to);
             fn_to_numeric_cast::check(cx, expr, cast_expr, cast_from, cast_to);
             fn_to_numeric_cast_with_truncation::check(cx, expr, cast_expr, cast_from, cast_to);
-            if cast_from.is_numeric() && cast_to.is_numeric() && !in_external_macro(cx.sess(), expr.span) {
-                cast_possible_truncation::check(cx, expr, cast_expr, cast_from, cast_to);
-                cast_possible_wrap::check(cx, expr, cast_from, cast_to);
-                cast_precision_loss::check(cx, expr, cast_from, cast_to);
+
+            if cast_to.is_numeric() && !in_external_macro(cx.sess(), expr.span) {
+                if cast_from.is_numeric() {
+                    cast_possible_truncation::check(cx, expr, cast_expr, cast_from, cast_to);
+                    cast_possible_wrap::check(cx, expr, cast_from, cast_to);
+                    cast_precision_loss::check(cx, expr, cast_from, cast_to);
+                    cast_sign_loss::check(cx, expr, cast_expr, cast_from, cast_to);
+                }
+
                 cast_lossless::check(cx, expr, cast_expr, cast_from, cast_to);
-                cast_sign_loss::check(cx, expr, cast_expr, cast_from, cast_to);
             }
         }
 
diff --git a/tests/ui/cast_lossless_bool.fixed b/tests/ui/cast_lossless_bool.fixed
new file mode 100644
index 00000000000..9e2da45c378
--- /dev/null
+++ b/tests/ui/cast_lossless_bool.fixed
@@ -0,0 +1,42 @@
+// run-rustfix
+
+#![allow(dead_code)]
+#![warn(clippy::cast_lossless)]
+
+fn main() {
+    // Test clippy::cast_lossless with casts to integer types
+    let _ = u8::from(true);
+    let _ = u16::from(true);
+    let _ = u32::from(true);
+    let _ = u64::from(true);
+    let _ = u128::from(true);
+    let _ = usize::from(true);
+
+    let _ = i8::from(true);
+    let _ = i16::from(true);
+    let _ = i32::from(true);
+    let _ = i64::from(true);
+    let _ = i128::from(true);
+    let _ = isize::from(true);
+
+    // Test with an expression wrapped in parens
+    let _ = u16::from(true | false);
+}
+
+// The lint would suggest using `u32::from(input)` here but the `XX::from` function is not const,
+// so we skip the lint if the expression is in a const fn.
+// See #3656
+const fn abc(input: bool) -> u32 {
+    input as u32
+}
+
+// Same as the above issue. We can't suggest `::from` in const fns in impls
+mod cast_lossless_in_impl {
+    struct A;
+
+    impl A {
+        pub const fn convert(x: bool) -> u64 {
+            x as u64
+        }
+    }
+}
diff --git a/tests/ui/cast_lossless_bool.rs b/tests/ui/cast_lossless_bool.rs
new file mode 100644
index 00000000000..b6f6c59a01f
--- /dev/null
+++ b/tests/ui/cast_lossless_bool.rs
@@ -0,0 +1,42 @@
+// run-rustfix
+
+#![allow(dead_code)]
+#![warn(clippy::cast_lossless)]
+
+fn main() {
+    // Test clippy::cast_lossless with casts to integer types
+    let _ = true as u8;
+    let _ = true as u16;
+    let _ = true as u32;
+    let _ = true as u64;
+    let _ = true as u128;
+    let _ = true as usize;
+
+    let _ = true as i8;
+    let _ = true as i16;
+    let _ = true as i32;
+    let _ = true as i64;
+    let _ = true as i128;
+    let _ = true as isize;
+
+    // Test with an expression wrapped in parens
+    let _ = (true | false) as u16;
+}
+
+// The lint would suggest using `u32::from(input)` here but the `XX::from` function is not const,
+// so we skip the lint if the expression is in a const fn.
+// See #3656
+const fn abc(input: bool) -> u32 {
+    input as u32
+}
+
+// Same as the above issue. We can't suggest `::from` in const fns in impls
+mod cast_lossless_in_impl {
+    struct A;
+
+    impl A {
+        pub const fn convert(x: bool) -> u64 {
+            x as u64
+        }
+    }
+}
diff --git a/tests/ui/cast_lossless_bool.stderr b/tests/ui/cast_lossless_bool.stderr
new file mode 100644
index 00000000000..a0d11f08acf
--- /dev/null
+++ b/tests/ui/cast_lossless_bool.stderr
@@ -0,0 +1,82 @@
+error: casting `bool` to `u8` may become silently lossy if you later change the type
+  --> $DIR/cast_lossless_bool.rs:8:13
+   |
+LL |     let _ = true as u8;
+   |             ^^^^^^^^^^ help: try: `u8::from(true)`
+   |
+   = note: `-D clippy::cast-lossless` implied by `-D warnings`
+
+error: casting `bool` to `u16` may become silently lossy if you later change the type
+  --> $DIR/cast_lossless_bool.rs:9:13
+   |
+LL |     let _ = true as u16;
+   |             ^^^^^^^^^^^ help: try: `u16::from(true)`
+
+error: casting `bool` to `u32` may become silently lossy if you later change the type
+  --> $DIR/cast_lossless_bool.rs:10:13
+   |
+LL |     let _ = true as u32;
+   |             ^^^^^^^^^^^ help: try: `u32::from(true)`
+
+error: casting `bool` to `u64` may become silently lossy if you later change the type
+  --> $DIR/cast_lossless_bool.rs:11:13
+   |
+LL |     let _ = true as u64;
+   |             ^^^^^^^^^^^ help: try: `u64::from(true)`
+
+error: casting `bool` to `u128` may become silently lossy if you later change the type
+  --> $DIR/cast_lossless_bool.rs:12:13
+   |
+LL |     let _ = true as u128;
+   |             ^^^^^^^^^^^^ help: try: `u128::from(true)`
+
+error: casting `bool` to `usize` may become silently lossy if you later change the type
+  --> $DIR/cast_lossless_bool.rs:13:13
+   |
+LL |     let _ = true as usize;
+   |             ^^^^^^^^^^^^^ help: try: `usize::from(true)`
+
+error: casting `bool` to `i8` may become silently lossy if you later change the type
+  --> $DIR/cast_lossless_bool.rs:15:13
+   |
+LL |     let _ = true as i8;
+   |             ^^^^^^^^^^ help: try: `i8::from(true)`
+
+error: casting `bool` to `i16` may become silently lossy if you later change the type
+  --> $DIR/cast_lossless_bool.rs:16:13
+   |
+LL |     let _ = true as i16;
+   |             ^^^^^^^^^^^ help: try: `i16::from(true)`
+
+error: casting `bool` to `i32` may become silently lossy if you later change the type
+  --> $DIR/cast_lossless_bool.rs:17:13
+   |
+LL |     let _ = true as i32;
+   |             ^^^^^^^^^^^ help: try: `i32::from(true)`
+
+error: casting `bool` to `i64` may become silently lossy if you later change the type
+  --> $DIR/cast_lossless_bool.rs:18:13
+   |
+LL |     let _ = true as i64;
+   |             ^^^^^^^^^^^ help: try: `i64::from(true)`
+
+error: casting `bool` to `i128` may become silently lossy if you later change the type
+  --> $DIR/cast_lossless_bool.rs:19:13
+   |
+LL |     let _ = true as i128;
+   |             ^^^^^^^^^^^^ help: try: `i128::from(true)`
+
+error: casting `bool` to `isize` may become silently lossy if you later change the type
+  --> $DIR/cast_lossless_bool.rs:20:13
+   |
+LL |     let _ = true as isize;
+   |             ^^^^^^^^^^^^^ help: try: `isize::from(true)`
+
+error: casting `bool` to `u16` may become silently lossy if you later change the type
+  --> $DIR/cast_lossless_bool.rs:23:13
+   |
+LL |     let _ = (true | false) as u16;
+   |             ^^^^^^^^^^^^^^^^^^^^^ help: try: `u16::from(true | false)`
+
+error: aborting due to 13 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 6e84f00045e20cbd9f9d2695f67e9fc0852134d4 Mon Sep 17 00:00:00 2001
From: 5225225 <5225225@mailbox.org>
Date: Tue, 9 Nov 2021 17:35:35 +0000
Subject: Check MSRV for bool to int from impl

---
 clippy_lints/src/casts/cast_lossless.rs | 24 +++++++++++++++++++-----
 clippy_lints/src/casts/mod.rs           |  2 +-
 clippy_utils/src/msrvs.rs               |  1 +
 tests/ui/min_rust_version_attr.rs       |  6 ++++++
 tests/ui/min_rust_version_attr.stderr   |  8 ++++----
 5 files changed, 31 insertions(+), 10 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/cast_lossless.rs b/clippy_lints/src/casts/cast_lossless.rs
index 75dc9098033..cc360fc9c76 100644
--- a/clippy_lints/src/casts/cast_lossless.rs
+++ b/clippy_lints/src/casts/cast_lossless.rs
@@ -1,16 +1,24 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::in_constant;
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::is_isize_or_usize;
+use clippy_utils::{in_constant, meets_msrv, msrvs};
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::LateContext;
 use rustc_middle::ty::{self, FloatTy, Ty};
+use rustc_semver::RustcVersion;
 
 use super::{utils, CAST_LOSSLESS};
 
-pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_op: &Expr<'_>, cast_from: Ty<'_>, cast_to: Ty<'_>) {
-    if !should_lint(cx, expr, cast_from, cast_to) {
+pub(super) fn check(
+    cx: &LateContext<'_>,
+    expr: &Expr<'_>,
+    cast_op: &Expr<'_>,
+    cast_from: Ty<'_>,
+    cast_to: Ty<'_>,
+    msrv: &Option<RustcVersion>,
+) {
+    if !should_lint(cx, expr, cast_from, cast_to, msrv) {
         return;
     }
 
@@ -46,7 +54,13 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_op: &Expr<'_>, c
     );
 }
 
-fn should_lint(cx: &LateContext<'_>, expr: &Expr<'_>, cast_from: Ty<'_>, cast_to: Ty<'_>) -> bool {
+fn should_lint(
+    cx: &LateContext<'_>,
+    expr: &Expr<'_>,
+    cast_from: Ty<'_>,
+    cast_to: Ty<'_>,
+    msrv: &Option<RustcVersion>,
+) -> bool {
     // Do not suggest using From in consts/statics until it is valid to do so (see #2267).
     if in_constant(cx, expr.hir_id) {
         return false;
@@ -72,7 +86,7 @@ fn should_lint(cx: &LateContext<'_>, expr: &Expr<'_>, cast_from: Ty<'_>, cast_to
             };
             from_nbits < to_nbits
         },
-        (false, true) if matches!(cast_from.kind(), ty::Bool) => true,
+        (false, true) if matches!(cast_from.kind(), ty::Bool) && meets_msrv(msrv.as_ref(), &msrvs::FROM_BOOL) => true,
         (_, _) => {
             matches!(cast_from.kind(), ty::Float(FloatTy::F32)) && matches!(cast_to.kind(), ty::Float(FloatTy::F64))
         },
diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index 108f6fbc924..822ac4c242e 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -435,7 +435,7 @@ impl<'tcx> LateLintPass<'tcx> for Casts {
                     cast_sign_loss::check(cx, expr, cast_expr, cast_from, cast_to);
                 }
 
-                cast_lossless::check(cx, expr, cast_expr, cast_from, cast_to);
+                cast_lossless::check(cx, expr, cast_expr, cast_from, cast_to, &self.msrv);
             }
         }
 
diff --git a/clippy_utils/src/msrvs.rs b/clippy_utils/src/msrvs.rs
index f3913203f4b..fb11928dad6 100644
--- a/clippy_utils/src/msrvs.rs
+++ b/clippy_utils/src/msrvs.rs
@@ -28,6 +28,7 @@ msrv_aliases! {
     1,35,0 { OPTION_COPIED, RANGE_CONTAINS }
     1,34,0 { TRY_FROM }
     1,30,0 { ITERATOR_FIND_MAP, TOOL_ATTRIBUTES }
+    1,28,0 { FROM_BOOL }
     1,17,0 { FIELD_INIT_SHORTHAND, STATIC_IN_CONST }
     1,16,0 { STR_REPEAT }
 }
diff --git a/tests/ui/min_rust_version_attr.rs b/tests/ui/min_rust_version_attr.rs
index 57ed453da10..c5f221220ec 100644
--- a/tests/ui/min_rust_version_attr.rs
+++ b/tests/ui/min_rust_version_attr.rs
@@ -140,6 +140,11 @@ fn unnest_or_patterns() {
 #[cfg_attr(rustfmt, rustfmt_skip)]
 fn deprecated_cfg_attr() {}
 
+#[warn(clippy::cast_lossless)]
+fn int_from_bool() -> u8 {
+    true as u8
+}
+
 fn main() {
     filter_map_next();
     checked_conversion();
@@ -156,6 +161,7 @@ fn main() {
     map_unwrap_or();
     missing_const_for_fn();
     unnest_or_patterns();
+    int_from_bool();
 }
 
 mod just_under_msrv {
diff --git a/tests/ui/min_rust_version_attr.stderr b/tests/ui/min_rust_version_attr.stderr
index 4388b78f832..6b3fdb0844b 100644
--- a/tests/ui/min_rust_version_attr.stderr
+++ b/tests/ui/min_rust_version_attr.stderr
@@ -1,12 +1,12 @@
 error: stripping a prefix manually
-  --> $DIR/min_rust_version_attr.rs:180:24
+  --> $DIR/min_rust_version_attr.rs:186:24
    |
 LL |             assert_eq!(s["hello, ".len()..].to_uppercase(), "WORLD!");
    |                        ^^^^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::manual-strip` implied by `-D warnings`
 note: the prefix was tested here
-  --> $DIR/min_rust_version_attr.rs:179:9
+  --> $DIR/min_rust_version_attr.rs:185:9
    |
 LL |         if s.starts_with("hello, ") {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -17,13 +17,13 @@ LL ~             assert_eq!(<stripped>.to_uppercase(), "WORLD!");
    |
 
 error: stripping a prefix manually
-  --> $DIR/min_rust_version_attr.rs:192:24
+  --> $DIR/min_rust_version_attr.rs:198:24
    |
 LL |             assert_eq!(s["hello, ".len()..].to_uppercase(), "WORLD!");
    |                        ^^^^^^^^^^^^^^^^^^^^
    |
 note: the prefix was tested here
-  --> $DIR/min_rust_version_attr.rs:191:9
+  --> $DIR/min_rust_version_attr.rs:197:9
    |
 LL |         if s.starts_with("hello, ") {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From a003ca6853772ccde7f4af6d3178126120093cc4 Mon Sep 17 00:00:00 2001
From: dswij <dswijj@gmail.com>
Date: Wed, 10 Nov 2021 14:46:00 +0800
Subject: `semicolon_if_nothing_returned` now checks if the stmt ends with
 semicolon

---
 clippy_lints/src/semicolon_if_nothing_returned.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/semicolon_if_nothing_returned.rs b/clippy_lints/src/semicolon_if_nothing_returned.rs
index c0e4914efe0..d3b4929a189 100644
--- a/clippy_lints/src/semicolon_if_nothing_returned.rs
+++ b/clippy_lints/src/semicolon_if_nothing_returned.rs
@@ -44,7 +44,7 @@ impl LateLintPass<'_> for SemicolonIfNothingReturned {
             let t_expr = cx.typeck_results().expr_ty(expr);
             if t_expr.is_unit();
             if let snippet = snippet_with_macro_callsite(cx, expr.span, "}");
-            if !snippet.ends_with('}');
+            if !snippet.ends_with('}') && !snippet.ends_with(';');
             if cx.sess().source_map().is_multiline(block.span);
             then {
                 // filter out the desugared `for` loop
-- 
cgit 1.4.1-3-g733a5


From 7c1e62d9628365530de69aeef86e30bd0b8a9604 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Tue, 12 Oct 2021 22:51:44 +0200
Subject: Added `clippy::version` attribute as lint metadata

---
 .../src/utils/internal_lints/metadata_collector.rs | 42 ++++++++++++++++++++--
 clippy_utils/src/attrs.rs                          | 15 ++++----
 2 files changed, 47 insertions(+), 10 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index 99cf4c1ed40..d7a023fada2 100644
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -116,6 +116,8 @@ const DEPRECATED_LINT_TYPE: [&str; 3] = ["clippy_lints", "deprecated_lints", "Cl
 const APPLICABILITY_NAME_INDEX: usize = 2;
 /// This applicability will be set for unresolved applicability values.
 const APPLICABILITY_UNRESOLVED_STR: &str = "Unresolved";
+/// The version that will be displayed if none has been defined
+const VERION_DEFAULT_STR: &str = "Unknown";
 
 declare_clippy_lint! {
     /// ### What it does
@@ -144,6 +146,7 @@ declare_clippy_lint! {
     ///     "docs": " ### What it does\nCollects metadata about clippy lints for the website. [...] "
     /// }
     /// ```
+    #[clippy::version = "0.1.56"]
     pub INTERNAL_METADATA_COLLECTOR,
     internal_warn,
     "A busy bee collection metadata about lints"
@@ -215,18 +218,27 @@ struct LintMetadata {
     group: String,
     level: String,
     docs: String,
+    version: String,
     /// This field is only used in the output and will only be
     /// mapped shortly before the actual output.
     applicability: Option<ApplicabilityInfo>,
 }
 
 impl LintMetadata {
-    fn new(id: String, id_span: SerializableSpan, group: String, level: &'static str, docs: String) -> Self {
+    fn new(
+        id: String,
+        id_span: SerializableSpan,
+        group: String,
+        level: &'static str,
+        version: String,
+        docs: String,
+    ) -> Self {
         Self {
             id,
             id_span,
             group,
             level: level.to_string(),
+            version,
             docs,
             applicability: None,
         }
@@ -410,12 +422,14 @@ impl<'hir> LateLintPass<'hir> for MetadataCollector {
                     if let Some(configuration_section) = self.get_lint_configs(&lint_name) {
                         docs.push_str(&configuration_section);
                     }
+                    let version = get_lint_version(cx, item);
 
                     self.lints.push(LintMetadata::new(
                         lint_name,
                         SerializableSpan::from_item(cx, item),
                         group,
                         level,
+                        version,
                         docs,
                     ));
                 }
@@ -429,11 +443,14 @@ impl<'hir> LateLintPass<'hir> for MetadataCollector {
                 // Metadata the little we can get from a deprecated lint
                 if let Some(docs) = extract_attr_docs_or_lint(cx, item);
                 then {
+                    let version = get_lint_version(cx, item);
+
                     self.lints.push(LintMetadata::new(
                         lint_name,
                         SerializableSpan::from_item(cx, item),
                         DEPRECATED_LINT_GROUP_STR.to_string(),
                         DEPRECATED_LINT_LEVEL,
+                        version,
                         docs,
                     ));
                 }
@@ -552,6 +569,28 @@ fn extract_attr_docs(cx: &LateContext<'_>, item: &Item<'_>) -> Option<String> {
     Some(docs)
 }
 
+fn get_lint_version(cx: &LateContext<'_>, item: &Item<'_>) -> String {
+    let attrs = cx.tcx.hir().attrs(item.hir_id());
+    attrs
+        .iter()
+        .find_map(|attr| {
+            if_chain! {
+                // Identify attribute
+                if let ast::AttrKind::Normal(ref attr_kind, _) = &attr.kind;
+                if let [tool_name, attr_name] = &attr_kind.path.segments[..];
+                if tool_name.ident.name == sym::clippy;
+                if attr_name.ident.name == sym::version;
+                if let Some(version) = attr.value_str();
+                then {
+                    Some(version.as_str().to_string())
+                } else {
+                    None
+                }
+            }
+        })
+        .unwrap_or_else(|| VERION_DEFAULT_STR.to_string())
+}
+
 fn get_lint_group_and_level_or_lint(
     cx: &LateContext<'_>,
     lint_name: &str,
@@ -663,7 +702,6 @@ fn extract_emission_info<'hir>(
             applicability = resolve_applicability(cx, arg);
         } else if arg_ty.is_closure() {
             multi_part |= check_is_multi_part(cx, arg);
-            // TODO xFrednet 2021-03-01: don't use or_else but rather a comparison
             applicability = applicability.or_else(|| resolve_applicability(cx, arg));
         }
     }
diff --git a/clippy_utils/src/attrs.rs b/clippy_utils/src/attrs.rs
index c19b558cd8c..7ae9615d560 100644
--- a/clippy_utils/src/attrs.rs
+++ b/clippy_utils/src/attrs.rs
@@ -14,15 +14,14 @@ pub enum DeprecationStatus {
     None,
 }
 
+#[rustfmt::skip]
 pub const BUILTIN_ATTRIBUTES: &[(&str, DeprecationStatus)] = &[
-    ("author", DeprecationStatus::None),
-    ("cognitive_complexity", DeprecationStatus::None),
-    (
-        "cyclomatic_complexity",
-        DeprecationStatus::Replaced("cognitive_complexity"),
-    ),
-    ("dump", DeprecationStatus::None),
-    ("msrv", DeprecationStatus::None),
+    ("author",                DeprecationStatus::None),
+    ("version",               DeprecationStatus::None),
+    ("cognitive_complexity",  DeprecationStatus::None),
+    ("cyclomatic_complexity", DeprecationStatus::Replaced("cognitive_complexity")),
+    ("dump",                  DeprecationStatus::None),
+    ("msrv",                  DeprecationStatus::None),
 ];
 
 pub struct LimitStack {
-- 
cgit 1.4.1-3-g733a5


From 8565fc468e97d7ab4d350532474c36127960f8ee Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Tue, 12 Oct 2021 23:01:44 +0200
Subject: Add clippy version to Clippy's lint list

---
 clippy_dev/src/update_lints.rs                              | 1 +
 clippy_lints/src/utils/internal_lints/metadata_collector.rs | 2 +-
 util/gh-pages/index.html                                    | 5 ++++-
 3 files changed, 6 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_dev/src/update_lints.rs b/clippy_dev/src/update_lints.rs
index 23f58bc4915..f615f74e6de 100644
--- a/clippy_dev/src/update_lints.rs
+++ b/clippy_dev/src/update_lints.rs
@@ -18,6 +18,7 @@ static DEC_CLIPPY_LINT_RE: SyncLazy<Regex> = SyncLazy::new(|| {
         r#"(?x)
     declare_clippy_lint!\s*[\{(]
     (?:\s+///.*)*
+    (?:\s*\#\[clippy::version\s*=\s*"[^"]*"\])?
     \s+pub\s+(?P<name>[A-Z_][A-Z_0-9]*)\s*,\s*
     (?P<cat>[a-z_]+)\s*,\s*
     "(?P<desc>(?:[^"\\]+|\\(?s).(?-s))*)"\s*[})]
diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index d7a023fada2..70c3169c78e 100644
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -146,7 +146,7 @@ declare_clippy_lint! {
     ///     "docs": " ### What it does\nCollects metadata about clippy lints for the website. [...] "
     /// }
     /// ```
-    #[clippy::version = "0.1.56"]
+    #[clippy::version = "1.56.0"]
     pub INTERNAL_METADATA_COLLECTOR,
     internal_warn,
     "A busy bee collection metadata about lints"
diff --git a/util/gh-pages/index.html b/util/gh-pages/index.html
index 48421150a54..cf8828a6bf4 100644
--- a/util/gh-pages/index.html
+++ b/util/gh-pages/index.html
@@ -339,7 +339,10 @@ Otherwise, have a great day =^.^=
                             <span class="label label-default label-applicability">{{lint.applicability.applicability}}</span>
                             <a href="https://doc.rust-lang.org/nightly/nightly-rustc/rustc_lint_defs/enum.Applicability.html#variants">(?)</a>
                         </div>
-                        <!-- TODO xFrednet 2021-05-19: Somehow collect and show the version See rust-clippy#6492 -->
+                        <!-- Clippy version -->
+                        <div class="lint-additional-info-item">
+                            Rust version: <span class="label label-default label-applicability">{{lint.version}}</span>
+                        </div>
                         <!-- Open related issues -->
                         <div class="lint-additional-info-item">
                             <a href="https://github.com/rust-lang/rust-clippy/issues?q=is%3Aissue+{{lint.id}}">Related Issues</a>
-- 
cgit 1.4.1-3-g733a5


From 63cb41098bf1d9f1948492dd4c53e33ba2db828a Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Sun, 17 Oct 2021 16:57:13 +0200
Subject: Manually add `clippy::version` attribute to deprecated lints

---
 clippy_dev/src/update_lints.rs       |  3 ++-
 clippy_lints/src/deprecated_lints.rs | 16 ++++++++++++++++
 2 files changed, 18 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_dev/src/update_lints.rs b/clippy_dev/src/update_lints.rs
index 21b2b3b66f4..8dd073ef405 100644
--- a/clippy_dev/src/update_lints.rs
+++ b/clippy_dev/src/update_lints.rs
@@ -18,7 +18,7 @@ static DEC_CLIPPY_LINT_RE: SyncLazy<Regex> = SyncLazy::new(|| {
         r#"(?x)
     declare_clippy_lint!\s*[\{(]
     (?:\s+///.*)*
-    (?:\s*\#\[clippy::version\s*=\s*"[^"]*"\])
+    (?:\s*\#\[clippy::version\s*=\s*"[^"]*"\])?
     \s+pub\s+(?P<name>[A-Z_][A-Z_0-9]*)\s*,\s*
     (?P<cat>[a-z_]+)\s*,\s*
     "(?P<desc>(?:[^"\\]+|\\(?s).(?-s))*)"\s*[})]
@@ -32,6 +32,7 @@ static DEC_DEPRECATED_LINT_RE: SyncLazy<Regex> = SyncLazy::new(|| {
         r#"(?x)
     declare_deprecated_lint!\s*[{(]\s*
     (?:\s+///.*)*
+    (?:\s*\#\[clippy::version\s*=\s*"[^"]*"\])?
     \s+pub\s+(?P<name>[A-Z_][A-Z_0-9]*)\s*,\s*
     "(?P<desc>(?:[^"\\]+|\\(?s).(?-s))*)"\s*[})]
 "#,
diff --git a/clippy_lints/src/deprecated_lints.rs b/clippy_lints/src/deprecated_lints.rs
index 9d8524ec91c..bba27576c89 100644
--- a/clippy_lints/src/deprecated_lints.rs
+++ b/clippy_lints/src/deprecated_lints.rs
@@ -21,6 +21,7 @@ declare_deprecated_lint! {
     /// ### Deprecation reason
     /// This used to check for `assert!(a == b)` and recommend
     /// replacement with `assert_eq!(a, b)`, but this is no longer needed after RFC 2011.
+    #[clippy::version = "pre 1.29.0"]
     pub SHOULD_ASSERT_EQ,
     "`assert!()` will be more flexible with RFC 2011"
 }
@@ -32,6 +33,7 @@ declare_deprecated_lint! {
     /// ### Deprecation reason
     /// This used to check for `Vec::extend`, which was slower than
     /// `Vec::extend_from_slice`. Thanks to specialization, this is no longer true.
+    #[clippy::version = "pre 1.29.0"]
     pub EXTEND_FROM_SLICE,
     "`.extend_from_slice(_)` is a faster way to extend a Vec by a slice"
 }
@@ -45,6 +47,7 @@ declare_deprecated_lint! {
     /// an infinite iterator, which is better expressed by `iter::repeat`,
     /// but the method has been removed for `Iterator::step_by` which panics
     /// if given a zero
+    #[clippy::version = "pre 1.29.0"]
     pub RANGE_STEP_BY_ZERO,
     "`iterator.step_by(0)` panics nowadays"
 }
@@ -56,6 +59,7 @@ declare_deprecated_lint! {
     /// ### Deprecation reason
     /// This used to check for `Vec::as_slice`, which was unstable with good
     /// stable alternatives. `Vec::as_slice` has now been stabilized.
+    #[clippy::version = "pre 1.29.0"]
     pub UNSTABLE_AS_SLICE,
     "`Vec::as_slice` has been stabilized in 1.7"
 }
@@ -67,6 +71,7 @@ declare_deprecated_lint! {
     /// ### Deprecation reason
     /// This used to check for `Vec::as_mut_slice`, which was unstable with good
     /// stable alternatives. `Vec::as_mut_slice` has now been stabilized.
+    #[clippy::version = "pre 1.29.0"]
     pub UNSTABLE_AS_MUT_SLICE,
     "`Vec::as_mut_slice` has been stabilized in 1.7"
 }
@@ -80,6 +85,7 @@ declare_deprecated_lint! {
     /// between non-pointer types of differing alignment is well-defined behavior (it's semantically
     /// equivalent to a memcpy). This lint has thus been refactored into two separate lints:
     /// cast_ptr_alignment and transmute_ptr_to_ptr.
+    #[clippy::version = "pre 1.29.0"]
     pub MISALIGNED_TRANSMUTE,
     "this lint has been split into cast_ptr_alignment and transmute_ptr_to_ptr"
 }
@@ -92,6 +98,7 @@ declare_deprecated_lint! {
     /// This lint is too subjective, not having a good reason for being in clippy.
     /// Additionally, compound assignment operators may be overloaded separately from their non-assigning
     /// counterparts, so this lint may suggest a change in behavior or the code may not compile.
+    #[clippy::version = "1.30.0"]
     pub ASSIGN_OPS,
     "using compound assignment operators (e.g., `+=`) is harmless"
 }
@@ -104,6 +111,7 @@ declare_deprecated_lint! {
     /// The original rule will only lint for `if let`. After
     /// making it support to lint `match`, naming as `if let` is not suitable for it.
     /// So, this lint is deprecated.
+    #[clippy::version = "pre 1.29.0"]
     pub IF_LET_REDUNDANT_PATTERN_MATCHING,
     "this lint has been changed to redundant_pattern_matching"
 }
@@ -117,6 +125,7 @@ declare_deprecated_lint! {
     /// Vec::with_capacity(n); vec.set_len(n);` with `let vec = vec![0; n];`. The
     /// replacement has very different performance characteristics so the lint is
     /// deprecated.
+    #[clippy::version = "pre 1.29.0"]
     pub UNSAFE_VECTOR_INITIALIZATION,
     "the replacement suggested by this lint had substantially different behavior"
 }
@@ -127,6 +136,7 @@ declare_deprecated_lint! {
     ///
     /// ### Deprecation reason
     /// This lint has been superseded by #[must_use] in rustc.
+    #[clippy::version = "1.39.0"]
     pub UNUSED_COLLECT,
     "`collect` has been marked as #[must_use] in rustc and that covers all cases of this lint"
 }
@@ -137,6 +147,7 @@ declare_deprecated_lint! {
     ///
     /// ### Deprecation reason
     /// Associated-constants are now preferred.
+    #[clippy::version = "1.44.0"]
     pub REPLACE_CONSTS,
     "associated-constants `MIN`/`MAX` of integers are preferred to `{min,max}_value()` and module constants"
 }
@@ -147,6 +158,7 @@ declare_deprecated_lint! {
     ///
     /// ### Deprecation reason
     /// The regex! macro does not exist anymore.
+    #[clippy::version = "1.47.0"]
     pub REGEX_MACRO,
     "the regex! macro has been removed from the regex crate in 2018"
 }
@@ -158,6 +170,7 @@ declare_deprecated_lint! {
     /// ### Deprecation reason
     /// This lint has been replaced by `manual_find_map`, a
     /// more specific lint.
+    #[clippy::version = "1.51.0"]
     pub FIND_MAP,
     "this lint has been replaced by `manual_find_map`, a more specific lint"
 }
@@ -169,6 +182,7 @@ declare_deprecated_lint! {
     /// ### Deprecation reason
     /// This lint has been replaced by `manual_filter_map`, a
     /// more specific lint.
+    #[clippy::version = "1.53.0"]
     pub FILTER_MAP,
     "this lint has been replaced by `manual_filter_map`, a more specific lint"
 }
@@ -181,6 +195,7 @@ declare_deprecated_lint! {
     /// The `avoid_breaking_exported_api` config option was added, which
     /// enables the `enum_variant_names` lint for public items.
     /// ```
+    #[clippy::version = "1.54.0"]
     pub PUB_ENUM_VARIANT_NAMES,
     "set the `avoid-breaking-exported-api` config option to `false` to enable the `enum_variant_names` lint for public items"
 }
@@ -192,6 +207,7 @@ declare_deprecated_lint! {
     /// ### Deprecation reason
     /// The `avoid_breaking_exported_api` config option was added, which
     /// enables the `wrong_self_conversion` lint for public items.
+    #[clippy::version = "1.54.0"]
     pub WRONG_PUB_SELF_CONVENTION,
     "set the `avoid-breaking-exported-api` config option to `false` to enable the `wrong_self_convention` lint for public items"
 }
-- 
cgit 1.4.1-3-g733a5


From d647696c1f167802c9bb9ffe2c98459b152d563c Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Thu, 21 Oct 2021 21:06:26 +0200
Subject: Added `clippy::version` attribute to all normal lints

So, some context for this, well, more a story. I'm not used to scripting, I've never really scripted anything, even if it's a valuable skill. I just never really needed it. Now, `@flip1995` correctly suggested using a script for this in `rust-clippy#7813`...

And I decided to write a script using nushell because why not? This was a mistake... I spend way more time on this than I would like to admit. It has definitely been more than 4 hours. It shouldn't take that long, but me being new to scripting and nushell just wasn't a good mixture... Anyway, here is the script that creates another script which adds the versions. Fun...

Just execute this on the `gh-pages` branch and the resulting `replacer.sh` in `clippy_lints` and it should all work.

```nu
mv v0.0.212 rust-1.00.0;
mv beta rust-1.57.0;
mv master rust-1.58.0;

let paths = (open ./rust-1.58.0/lints.json | select id id_span | flatten | select id path);
let versions = (
    ls | where name =~ "rust-" | select name | format {name}/lints.json |
    each { open $it | select id | insert version $it | str substring "5,11" version} |
    group-by id | rotate counter-clockwise id version |
    update version {get version | first 1} | flatten | select id version);
$paths | each { |row|
    let version = ($versions | where id == ($row.id) | format {version})
    let idu = ($row.id | str upcase)
    $"sed -i '0,/($idu),/{s/pub ($idu),/#[clippy::version = "($version)"]\n    pub ($idu),/}' ($row.path)"
} | str collect ";" | str find-replace --all '1.00.0' 'pre 1.29.0' | save "replacer.sh";
```

And this still has some problems, but at this point I just want to be done -.-
---
 clippy_lints/src/absurd_extreme_comparisons.rs     |  1 +
 clippy_lints/src/approx_const.rs                   |  1 +
 clippy_lints/src/arithmetic.rs                     |  2 +
 clippy_lints/src/as_conversions.rs                 |  1 +
 clippy_lints/src/asm_syntax.rs                     |  2 +
 clippy_lints/src/assertions_on_constants.rs        |  1 +
 clippy_lints/src/assign_ops.rs                     |  2 +
 clippy_lints/src/async_yields_async.rs             |  1 +
 clippy_lints/src/attrs.rs                          |  7 +++
 clippy_lints/src/await_holding_invalid.rs          |  2 +
 clippy_lints/src/bit_mask.rs                       |  3 ++
 clippy_lints/src/blacklisted_name.rs               |  1 +
 clippy_lints/src/blocks_in_if_conditions.rs        |  1 +
 clippy_lints/src/bool_assert_comparison.rs         |  1 +
 clippy_lints/src/booleans.rs                       |  2 +
 clippy_lints/src/bytecount.rs                      |  1 +
 clippy_lints/src/cargo_common_metadata.rs          |  1 +
 .../case_sensitive_file_extension_comparisons.rs   |  1 +
 clippy_lints/src/casts/mod.rs                      | 13 +++++
 clippy_lints/src/checked_conversions.rs            |  1 +
 clippy_lints/src/cognitive_complexity.rs           |  1 +
 clippy_lints/src/collapsible_if.rs                 |  2 +
 clippy_lints/src/collapsible_match.rs              |  1 +
 clippy_lints/src/comparison_chain.rs               |  1 +
 clippy_lints/src/copies.rs                         |  4 ++
 clippy_lints/src/copy_iterator.rs                  |  1 +
 clippy_lints/src/create_dir.rs                     |  1 +
 clippy_lints/src/dbg_macro.rs                      |  1 +
 clippy_lints/src/default.rs                        |  2 +
 clippy_lints/src/default_numeric_fallback.rs       |  1 +
 clippy_lints/src/dereference.rs                    |  1 +
 clippy_lints/src/derivable_impls.rs                |  1 +
 clippy_lints/src/derive.rs                         |  4 ++
 clippy_lints/src/disallowed_method.rs              |  1 +
 clippy_lints/src/disallowed_script_idents.rs       |  1 +
 clippy_lints/src/disallowed_type.rs                |  1 +
 clippy_lints/src/doc.rs                            |  5 ++
 clippy_lints/src/double_comparison.rs              |  1 +
 clippy_lints/src/double_parens.rs                  |  1 +
 clippy_lints/src/drop_forget_ref.rs                |  4 ++
 clippy_lints/src/duration_subsec.rs                |  1 +
 clippy_lints/src/else_if_without_else.rs           |  1 +
 clippy_lints/src/empty_enum.rs                     |  1 +
 clippy_lints/src/entry.rs                          |  1 +
 clippy_lints/src/enum_clike.rs                     |  1 +
 clippy_lints/src/enum_variants.rs                  |  3 ++
 clippy_lints/src/eq_op.rs                          |  2 +
 clippy_lints/src/equatable_if_let.rs               |  1 +
 clippy_lints/src/erasing_op.rs                     |  1 +
 clippy_lints/src/escape.rs                         |  1 +
 clippy_lints/src/eta_reduction.rs                  |  2 +
 clippy_lints/src/eval_order_dependence.rs          |  2 +
 clippy_lints/src/excessive_bools.rs                |  2 +
 clippy_lints/src/exhaustive_items.rs               |  2 +
 clippy_lints/src/exit.rs                           |  1 +
 clippy_lints/src/explicit_write.rs                 |  1 +
 clippy_lints/src/fallible_impl_from.rs             |  1 +
 clippy_lints/src/feature_name.rs                   |  2 +
 clippy_lints/src/float_equality_without_abs.rs     |  1 +
 clippy_lints/src/float_literal.rs                  |  2 +
 clippy_lints/src/floating_point_arithmetic.rs      |  2 +
 clippy_lints/src/format.rs                         |  1 +
 clippy_lints/src/format_args.rs                    |  2 +
 clippy_lints/src/formatting.rs                     |  4 ++
 clippy_lints/src/from_over_into.rs                 |  1 +
 clippy_lints/src/from_str_radix_10.rs              |  1 +
 clippy_lints/src/functions/mod.rs                  |  7 +++
 clippy_lints/src/future_not_send.rs                |  1 +
 clippy_lints/src/get_last_with_len.rs              |  1 +
 clippy_lints/src/identity_op.rs                    |  1 +
 clippy_lints/src/if_let_mutex.rs                   |  1 +
 clippy_lints/src/if_not_else.rs                    |  1 +
 clippy_lints/src/if_then_some_else_none.rs         |  1 +
 clippy_lints/src/implicit_hasher.rs                |  1 +
 clippy_lints/src/implicit_return.rs                |  1 +
 clippy_lints/src/implicit_saturating_sub.rs        |  1 +
 .../src/inconsistent_struct_constructor.rs         |  1 +
 clippy_lints/src/indexing_slicing.rs               |  2 +
 clippy_lints/src/infinite_iter.rs                  |  2 +
 clippy_lints/src/inherent_impl.rs                  |  1 +
 clippy_lints/src/inherent_to_string.rs             |  2 +
 clippy_lints/src/inline_fn_without_body.rs         |  1 +
 clippy_lints/src/int_plus_one.rs                   |  1 +
 clippy_lints/src/integer_division.rs               |  1 +
 clippy_lints/src/invalid_upcast_comparisons.rs     |  1 +
 clippy_lints/src/items_after_statements.rs         |  1 +
 clippy_lints/src/iter_not_returning_iterator.rs    |  1 +
 clippy_lints/src/large_const_arrays.rs             |  1 +
 clippy_lints/src/large_enum_variant.rs             |  1 +
 clippy_lints/src/large_stack_arrays.rs             |  1 +
 clippy_lints/src/len_zero.rs                       |  3 ++
 clippy_lints/src/let_if_seq.rs                     |  1 +
 clippy_lints/src/let_underscore.rs                 |  3 ++
 clippy_lints/src/lifetimes.rs                      |  2 +
 clippy_lints/src/literal_representation.rs         |  6 +++
 clippy_lints/src/loops/mod.rs                      | 18 +++++++
 clippy_lints/src/macro_use.rs                      |  1 +
 clippy_lints/src/main_recursion.rs                 |  1 +
 clippy_lints/src/manual_assert.rs                  |  1 +
 clippy_lints/src/manual_async_fn.rs                |  1 +
 clippy_lints/src/manual_map.rs                     |  1 +
 clippy_lints/src/manual_non_exhaustive.rs          |  1 +
 clippy_lints/src/manual_ok_or.rs                   |  1 +
 clippy_lints/src/manual_strip.rs                   |  1 +
 clippy_lints/src/manual_unwrap_or.rs               |  1 +
 clippy_lints/src/map_clone.rs                      |  1 +
 clippy_lints/src/map_err_ignore.rs                 |  1 +
 clippy_lints/src/map_unit_fn.rs                    |  2 +
 clippy_lints/src/match_on_vec_items.rs             |  1 +
 clippy_lints/src/match_result_ok.rs                |  1 +
 clippy_lints/src/match_str_case_mismatch.rs        |  1 +
 clippy_lints/src/matches.rs                        | 16 ++++++
 clippy_lints/src/mem_forget.rs                     |  1 +
 clippy_lints/src/mem_replace.rs                    |  3 ++
 clippy_lints/src/methods/mod.rs                    | 63 ++++++++++++++++++++++
 clippy_lints/src/minmax.rs                         |  1 +
 clippy_lints/src/misc.rs                           |  9 ++++
 clippy_lints/src/misc_early/mod.rs                 |  9 ++++
 clippy_lints/src/missing_const_for_fn.rs           |  1 +
 clippy_lints/src/missing_doc.rs                    |  1 +
 clippy_lints/src/missing_enforced_import_rename.rs |  1 +
 clippy_lints/src/missing_inline.rs                 |  1 +
 clippy_lints/src/module_style.rs                   |  2 +
 clippy_lints/src/modulo_arithmetic.rs              |  1 +
 clippy_lints/src/multiple_crate_versions.rs        |  1 +
 clippy_lints/src/mut_key.rs                        |  1 +
 clippy_lints/src/mut_mut.rs                        |  1 +
 clippy_lints/src/mut_mutex_lock.rs                 |  1 +
 clippy_lints/src/mut_reference.rs                  |  1 +
 clippy_lints/src/mutable_debug_assertion.rs        |  1 +
 clippy_lints/src/mutex_atomic.rs                   |  2 +
 clippy_lints/src/needless_arbitrary_self_type.rs   |  1 +
 clippy_lints/src/needless_bitwise_bool.rs          |  1 +
 clippy_lints/src/needless_bool.rs                  |  2 +
 clippy_lints/src/needless_borrow.rs                |  2 +
 clippy_lints/src/needless_borrowed_ref.rs          |  1 +
 clippy_lints/src/needless_continue.rs              |  1 +
 clippy_lints/src/needless_for_each.rs              |  1 +
 clippy_lints/src/needless_option_as_deref.rs       |  1 +
 clippy_lints/src/needless_pass_by_value.rs         |  1 +
 clippy_lints/src/needless_question_mark.rs         |  1 +
 clippy_lints/src/needless_update.rs                |  1 +
 clippy_lints/src/neg_cmp_op_on_partial_ord.rs      |  1 +
 clippy_lints/src/neg_multiply.rs                   |  1 +
 clippy_lints/src/new_without_default.rs            |  1 +
 clippy_lints/src/no_effect.rs                      |  3 ++
 clippy_lints/src/non_copy_const.rs                 |  2 +
 clippy_lints/src/non_expressive_names.rs           |  3 ++
 clippy_lints/src/non_octal_unix_permissions.rs     |  1 +
 clippy_lints/src/non_send_fields_in_send_ty.rs     |  1 +
 clippy_lints/src/nonstandard_macro_braces.rs       |  1 +
 clippy_lints/src/open_options.rs                   |  1 +
 clippy_lints/src/option_env_unwrap.rs              |  1 +
 clippy_lints/src/option_if_let_else.rs             |  1 +
 clippy_lints/src/overflow_check_conditional.rs     |  1 +
 clippy_lints/src/panic_in_result_fn.rs             |  1 +
 clippy_lints/src/panic_unimplemented.rs            |  4 ++
 clippy_lints/src/partialeq_ne_impl.rs              |  1 +
 clippy_lints/src/pass_by_ref_or_value.rs           |  2 +
 clippy_lints/src/path_buf_push_overwrite.rs        |  1 +
 clippy_lints/src/pattern_type_mismatch.rs          |  1 +
 clippy_lints/src/precedence.rs                     |  1 +
 clippy_lints/src/ptr.rs                            |  4 ++
 clippy_lints/src/ptr_eq.rs                         |  1 +
 clippy_lints/src/ptr_offset_with_cast.rs           |  1 +
 clippy_lints/src/question_mark.rs                  |  1 +
 clippy_lints/src/ranges.rs                         |  5 ++
 clippy_lints/src/redundant_clone.rs                |  1 +
 clippy_lints/src/redundant_closure_call.rs         |  1 +
 clippy_lints/src/redundant_else.rs                 |  1 +
 clippy_lints/src/redundant_field_names.rs          |  1 +
 clippy_lints/src/redundant_pub_crate.rs            |  1 +
 clippy_lints/src/redundant_slicing.rs              |  1 +
 clippy_lints/src/redundant_static_lifetimes.rs     |  1 +
 clippy_lints/src/ref_option_ref.rs                 |  1 +
 clippy_lints/src/reference.rs                      |  2 +
 clippy_lints/src/regex.rs                          |  2 +
 clippy_lints/src/repeat_once.rs                    |  1 +
 clippy_lints/src/returns.rs                        |  2 +
 clippy_lints/src/same_name_method.rs               |  1 +
 clippy_lints/src/self_assignment.rs                |  1 +
 clippy_lints/src/self_named_constructors.rs        |  1 +
 clippy_lints/src/semicolon_if_nothing_returned.rs  |  1 +
 clippy_lints/src/serde_api.rs                      |  1 +
 clippy_lints/src/shadow.rs                         |  3 ++
 clippy_lints/src/single_component_path_imports.rs  |  1 +
 clippy_lints/src/size_of_in_element_count.rs       |  1 +
 clippy_lints/src/slow_vector_initialization.rs     |  1 +
 clippy_lints/src/stable_sort_primitive.rs          |  1 +
 clippy_lints/src/strings.rs                        |  7 +++
 clippy_lints/src/strlen_on_c_strings.rs            |  1 +
 clippy_lints/src/suspicious_operation_groupings.rs |  1 +
 clippy_lints/src/suspicious_trait_impl.rs          |  2 +
 clippy_lints/src/swap.rs                           |  2 +
 clippy_lints/src/tabs_in_doc_comments.rs           |  1 +
 clippy_lints/src/temporary_assignment.rs           |  1 +
 clippy_lints/src/to_digit_is_some.rs               |  1 +
 clippy_lints/src/to_string_in_display.rs           |  1 +
 clippy_lints/src/trailing_empty_array.rs           |  1 +
 clippy_lints/src/trait_bounds.rs                   |  2 +
 clippy_lints/src/transmute/mod.rs                  | 13 +++++
 clippy_lints/src/transmuting_null.rs               |  1 +
 clippy_lints/src/try_err.rs                        |  1 +
 clippy_lints/src/types/mod.rs                      |  9 ++++
 clippy_lints/src/undocumented_unsafe_blocks.rs     |  1 +
 clippy_lints/src/undropped_manually_drops.rs       |  1 +
 clippy_lints/src/unicode.rs                        |  3 ++
 clippy_lints/src/uninit_vec.rs                     |  1 +
 clippy_lints/src/unit_hash.rs                      |  1 +
 clippy_lints/src/unit_return_expecting_ord.rs      |  1 +
 clippy_lints/src/unit_types/mod.rs                 |  3 ++
 clippy_lints/src/unnamed_address.rs                |  2 +
 clippy_lints/src/unnecessary_self_imports.rs       |  1 +
 clippy_lints/src/unnecessary_sort_by.rs            |  1 +
 clippy_lints/src/unnecessary_wraps.rs              |  1 +
 clippy_lints/src/unnested_or_patterns.rs           |  1 +
 clippy_lints/src/unsafe_removed_from_name.rs       |  1 +
 clippy_lints/src/unused_async.rs                   |  1 +
 clippy_lints/src/unused_io_amount.rs               |  1 +
 clippy_lints/src/unused_self.rs                    |  1 +
 clippy_lints/src/unused_unit.rs                    |  1 +
 clippy_lints/src/unwrap.rs                         |  2 +
 clippy_lints/src/unwrap_in_result.rs               |  1 +
 clippy_lints/src/upper_case_acronyms.rs            |  1 +
 clippy_lints/src/use_self.rs                       |  1 +
 clippy_lints/src/useless_conversion.rs             |  1 +
 clippy_lints/src/vec.rs                            |  1 +
 clippy_lints/src/vec_init_then_push.rs             |  1 +
 clippy_lints/src/vec_resize_to_zero.rs             |  1 +
 clippy_lints/src/verbose_file_reads.rs             |  1 +
 clippy_lints/src/wildcard_dependencies.rs          |  1 +
 clippy_lints/src/wildcard_imports.rs               |  2 +
 clippy_lints/src/write.rs                          |  9 ++++
 clippy_lints/src/zero_div_zero.rs                  |  1 +
 clippy_lints/src/zero_sized_map_values.rs          |  1 +
 235 files changed, 490 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/absurd_extreme_comparisons.rs b/clippy_lints/src/absurd_extreme_comparisons.rs
index 1483f3f9185..7665aa8380b 100644
--- a/clippy_lints/src/absurd_extreme_comparisons.rs
+++ b/clippy_lints/src/absurd_extreme_comparisons.rs
@@ -36,6 +36,7 @@ declare_clippy_lint! {
     /// if vec.len() <= 0 {}
     /// if 100 > i32::MAX {}
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub ABSURD_EXTREME_COMPARISONS,
     correctness,
     "a comparison with a maximum or minimum value that is always true or false"
diff --git a/clippy_lints/src/approx_const.rs b/clippy_lints/src/approx_const.rs
index fb54ac1ec51..12435eefbc4 100644
--- a/clippy_lints/src/approx_const.rs
+++ b/clippy_lints/src/approx_const.rs
@@ -33,6 +33,7 @@ declare_clippy_lint! {
     /// let x = std::f32::consts::PI;
     /// let y = std::f64::consts::FRAC_1_PI;
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub APPROX_CONSTANT,
     correctness,
     "the approximate of a known float constant (in `std::fXX::consts`)"
diff --git a/clippy_lints/src/arithmetic.rs b/clippy_lints/src/arithmetic.rs
index 36fe7b7a867..e0c1d6ab6e1 100644
--- a/clippy_lints/src/arithmetic.rs
+++ b/clippy_lints/src/arithmetic.rs
@@ -25,6 +25,7 @@ declare_clippy_lint! {
     /// # let a = 0;
     /// a + 1;
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub INTEGER_ARITHMETIC,
     restriction,
     "any integer arithmetic expression which could overflow or panic"
@@ -43,6 +44,7 @@ declare_clippy_lint! {
     /// # let a = 0.0;
     /// a + 1.0;
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub FLOAT_ARITHMETIC,
     restriction,
     "any floating-point arithmetic statement"
diff --git a/clippy_lints/src/as_conversions.rs b/clippy_lints/src/as_conversions.rs
index 0be460d67a7..53704da1046 100644
--- a/clippy_lints/src/as_conversions.rs
+++ b/clippy_lints/src/as_conversions.rs
@@ -38,6 +38,7 @@ declare_clippy_lint! {
     /// f(a.try_into().expect("Unexpected u16 overflow in f"));
     /// ```
     ///
+    #[clippy::version = "1.41.0"]
     pub AS_CONVERSIONS,
     restriction,
     "using a potentially dangerous silent `as` conversion"
diff --git a/clippy_lints/src/asm_syntax.rs b/clippy_lints/src/asm_syntax.rs
index 825832eb79d..0322698f029 100644
--- a/clippy_lints/src/asm_syntax.rs
+++ b/clippy_lints/src/asm_syntax.rs
@@ -75,6 +75,7 @@ declare_clippy_lint! {
     /// asm!("lea ({}), {}", in(reg) ptr, lateout(reg) _, options(att_syntax));
     /// # }
     /// ```
+    #[clippy::version = "1.49.0"]
     pub INLINE_ASM_X86_INTEL_SYNTAX,
     restriction,
     "prefer AT&T x86 assembly syntax"
@@ -111,6 +112,7 @@ declare_clippy_lint! {
     /// asm!("lea {}, [{}]", lateout(reg) _, in(reg) ptr);
     /// # }
     /// ```
+    #[clippy::version = "1.49.0"]
     pub INLINE_ASM_X86_ATT_SYNTAX,
     restriction,
     "prefer Intel x86 assembly syntax"
diff --git a/clippy_lints/src/assertions_on_constants.rs b/clippy_lints/src/assertions_on_constants.rs
index d834a1d317a..521fc84ee9c 100644
--- a/clippy_lints/src/assertions_on_constants.rs
+++ b/clippy_lints/src/assertions_on_constants.rs
@@ -26,6 +26,7 @@ declare_clippy_lint! {
     /// const B: bool = false;
     /// assert!(B)
     /// ```
+    #[clippy::version = "1.34.0"]
     pub ASSERTIONS_ON_CONSTANTS,
     style,
     "`assert!(true)` / `assert!(false)` will be optimized out by the compiler, and should probably be replaced by a `panic!()` or `unreachable!()`"
diff --git a/clippy_lints/src/assign_ops.rs b/clippy_lints/src/assign_ops.rs
index 2097a1feff9..e16f4369da9 100644
--- a/clippy_lints/src/assign_ops.rs
+++ b/clippy_lints/src/assign_ops.rs
@@ -34,6 +34,7 @@ declare_clippy_lint! {
     /// // Good
     /// a += b;
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub ASSIGN_OP_PATTERN,
     style,
     "assigning the result of an operation on a variable to that same variable"
@@ -60,6 +61,7 @@ declare_clippy_lint! {
     /// // ...
     /// a += a + b;
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub MISREFACTORED_ASSIGN_OP,
     suspicious,
     "having a variable on both sides of an assign op"
diff --git a/clippy_lints/src/async_yields_async.rs b/clippy_lints/src/async_yields_async.rs
index 182736a5a20..0619490e73c 100644
--- a/clippy_lints/src/async_yields_async.rs
+++ b/clippy_lints/src/async_yields_async.rs
@@ -34,6 +34,7 @@ declare_clippy_lint! {
     ///   };
     /// }
     /// ```
+    #[clippy::version = "1.48.0"]
     pub ASYNC_YIELDS_ASYNC,
     correctness,
     "async blocks that return a type that can be awaited"
diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs
index 9c5db18336f..1edb7c950e7 100644
--- a/clippy_lints/src/attrs.rs
+++ b/clippy_lints/src/attrs.rs
@@ -66,6 +66,7 @@ declare_clippy_lint! {
     /// #[inline(always)]
     /// fn not_quite_hot_code(..) { ... }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub INLINE_ALWAYS,
     pedantic,
     "use of `#[inline(always)]`"
@@ -100,6 +101,7 @@ declare_clippy_lint! {
     /// #[macro_use]
     /// extern crate baz;
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub USELESS_ATTRIBUTE,
     correctness,
     "use of lint attributes on `extern crate` items"
@@ -119,6 +121,7 @@ declare_clippy_lint! {
     /// #[deprecated(since = "forever")]
     /// fn something_else() { /* ... */ }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub DEPRECATED_SEMVER,
     correctness,
     "use of `#[deprecated(since = \"x\")]` where x is not semver"
@@ -156,6 +159,7 @@ declare_clippy_lint! {
     /// #[allow(dead_code)]
     /// fn this_is_fine_too() { }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub EMPTY_LINE_AFTER_OUTER_ATTR,
     nursery,
     "empty line after outer attribute"
@@ -179,6 +183,7 @@ declare_clippy_lint! {
     /// ```rust
     /// #![deny(clippy::as_conversions)]
     /// ```
+    #[clippy::version = "1.47.0"]
     pub BLANKET_CLIPPY_RESTRICTION_LINTS,
     suspicious,
     "enabling the complete restriction group"
@@ -210,6 +215,7 @@ declare_clippy_lint! {
     /// #[rustfmt::skip]
     /// fn main() { }
     /// ```
+    #[clippy::version = "1.32.0"]
     pub DEPRECATED_CFG_ATTR,
     complexity,
     "usage of `cfg_attr(rustfmt)` instead of tool attributes"
@@ -242,6 +248,7 @@ declare_clippy_lint! {
     /// fn conditional() { }
     /// ```
     /// Check the [Rust Reference](https://doc.rust-lang.org/reference/conditional-compilation.html#target_os) for more details.
+    #[clippy::version = "1.45.0"]
     pub MISMATCHED_TARGET_OS,
     correctness,
     "usage of `cfg(operating_system)` instead of `cfg(target_os = \"operating_system\")`"
diff --git a/clippy_lints/src/await_holding_invalid.rs b/clippy_lints/src/await_holding_invalid.rs
index 28615b9217c..1cc3418d474 100644
--- a/clippy_lints/src/await_holding_invalid.rs
+++ b/clippy_lints/src/await_holding_invalid.rs
@@ -47,6 +47,7 @@ declare_clippy_lint! {
     ///   bar.await;
     /// }
     /// ```
+    #[clippy::version = "1.45.0"]
     pub AWAIT_HOLDING_LOCK,
     pedantic,
     "Inside an async function, holding a MutexGuard while calling await"
@@ -88,6 +89,7 @@ declare_clippy_lint! {
     ///   bar.await;
     /// }
     /// ```
+    #[clippy::version = "1.49.0"]
     pub AWAIT_HOLDING_REFCELL_REF,
     pedantic,
     "Inside an async function, holding a RefCell ref while calling await"
diff --git a/clippy_lints/src/bit_mask.rs b/clippy_lints/src/bit_mask.rs
index 11346e7c96a..0977cf22b2c 100644
--- a/clippy_lints/src/bit_mask.rs
+++ b/clippy_lints/src/bit_mask.rs
@@ -41,6 +41,7 @@ declare_clippy_lint! {
     /// # let x = 1;
     /// if (x & 1 == 2) { }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub BAD_BIT_MASK,
     correctness,
     "expressions of the form `_ & mask == select` that will only ever return `true` or `false`"
@@ -73,6 +74,7 @@ declare_clippy_lint! {
     /// # let x = 1;
     /// if (x | 1 > 3) {  }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub INEFFECTIVE_BIT_MASK,
     correctness,
     "expressions where a bit mask will be rendered useless by a comparison, e.g., `(x | 1) > 2`"
@@ -95,6 +97,7 @@ declare_clippy_lint! {
     /// # let x = 1;
     /// if x & 0b1111 == 0 { }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub VERBOSE_BIT_MASK,
     pedantic,
     "expressions where a bit mask is less readable than the corresponding method call"
diff --git a/clippy_lints/src/blacklisted_name.rs b/clippy_lints/src/blacklisted_name.rs
index 916c78c982a..1600fb25d89 100644
--- a/clippy_lints/src/blacklisted_name.rs
+++ b/clippy_lints/src/blacklisted_name.rs
@@ -17,6 +17,7 @@ declare_clippy_lint! {
     /// ```rust
     /// let foo = 3.14;
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub BLACKLISTED_NAME,
     style,
     "usage of a blacklisted/placeholder name"
diff --git a/clippy_lints/src/blocks_in_if_conditions.rs b/clippy_lints/src/blocks_in_if_conditions.rs
index 47e5b0d583d..b59f49357df 100644
--- a/clippy_lints/src/blocks_in_if_conditions.rs
+++ b/clippy_lints/src/blocks_in_if_conditions.rs
@@ -41,6 +41,7 @@ declare_clippy_lint! {
     /// let res = { let x = somefunc(); x };
     /// if res { /* ... */ }
     /// ```
+    #[clippy::version = "1.45.0"]
     pub BLOCKS_IN_IF_CONDITIONS,
     style,
     "useless or complex blocks that can be eliminated in conditions"
diff --git a/clippy_lints/src/bool_assert_comparison.rs b/clippy_lints/src/bool_assert_comparison.rs
index cdc192a47e4..a59abc66306 100644
--- a/clippy_lints/src/bool_assert_comparison.rs
+++ b/clippy_lints/src/bool_assert_comparison.rs
@@ -23,6 +23,7 @@ declare_clippy_lint! {
     /// // Good
     /// assert!(!"a".is_empty());
     /// ```
+    #[clippy::version = "1.53.0"]
     pub BOOL_ASSERT_COMPARISON,
     style,
     "Using a boolean as comparison value in an assert_* macro when there is no need"
diff --git a/clippy_lints/src/booleans.rs b/clippy_lints/src/booleans.rs
index a1e6b7224ff..51835ee7488 100644
--- a/clippy_lints/src/booleans.rs
+++ b/clippy_lints/src/booleans.rs
@@ -31,6 +31,7 @@ declare_clippy_lint! {
     /// if a && true  // should be: if a
     /// if !(a == b)  // should be: if a != b
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub NONMINIMAL_BOOL,
     complexity,
     "boolean expressions that can be written more concisely"
@@ -52,6 +53,7 @@ declare_clippy_lint! {
     /// if a && b || a { ... }
     /// ```
     /// The `b` is unnecessary, the expression is equivalent to `if a`.
+    #[clippy::version = "pre 1.29.0"]
     pub LOGIC_BUG,
     correctness,
     "boolean expressions that contain terminals which can be eliminated"
diff --git a/clippy_lints/src/bytecount.rs b/clippy_lints/src/bytecount.rs
index a07cd5e5f4e..a938ada9d2a 100644
--- a/clippy_lints/src/bytecount.rs
+++ b/clippy_lints/src/bytecount.rs
@@ -30,6 +30,7 @@ declare_clippy_lint! {
     /// # let vec = vec![1_u8];
     /// &vec.iter().filter(|x| **x == 0u8).count(); // use bytecount::count instead
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub NAIVE_BYTECOUNT,
     pedantic,
     "use of naive `<slice>.filter(|&x| x == y).count()` to count byte values"
diff --git a/clippy_lints/src/cargo_common_metadata.rs b/clippy_lints/src/cargo_common_metadata.rs
index ff619c59b6e..23f79fdc682 100644
--- a/clippy_lints/src/cargo_common_metadata.rs
+++ b/clippy_lints/src/cargo_common_metadata.rs
@@ -42,6 +42,7 @@ declare_clippy_lint! {
     /// keywords = ["clippy", "lint", "plugin"]
     /// categories = ["development-tools", "development-tools::cargo-plugins"]
     /// ```
+    #[clippy::version = "1.32.0"]
     pub CARGO_COMMON_METADATA,
     cargo,
     "common metadata is defined in `Cargo.toml`"
diff --git a/clippy_lints/src/case_sensitive_file_extension_comparisons.rs b/clippy_lints/src/case_sensitive_file_extension_comparisons.rs
index c876553c165..3f286dd9e2f 100644
--- a/clippy_lints/src/case_sensitive_file_extension_comparisons.rs
+++ b/clippy_lints/src/case_sensitive_file_extension_comparisons.rs
@@ -27,6 +27,7 @@ declare_clippy_lint! {
     ///     filename.rsplit('.').next().map(|ext| ext.eq_ignore_ascii_case("rs")) == Some(true)
     /// }
     /// ```
+    #[clippy::version = "1.51.0"]
     pub CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS,
     pedantic,
     "Checks for calls to ends_with with case-sensitive file extensions"
diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index 233abd17894..c674327486c 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -40,6 +40,7 @@ declare_clippy_lint! {
     /// let x = u64::MAX;
     /// x as f64;
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub CAST_PRECISION_LOSS,
     pedantic,
     "casts that cause loss of precision, e.g., `x as f32` where `x: u64`"
@@ -61,6 +62,7 @@ declare_clippy_lint! {
     /// let y: i8 = -1;
     /// y as u128; // will return 18446744073709551615
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub CAST_SIGN_LOSS,
     pedantic,
     "casts from signed types to unsigned types, e.g., `x as u32` where `x: i32`"
@@ -83,6 +85,7 @@ declare_clippy_lint! {
     ///     x as u8
     /// }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub CAST_POSSIBLE_TRUNCATION,
     pedantic,
     "casts that may cause truncation of the value, e.g., `x as u8` where `x: u32`, or `x as i32` where `x: f32`"
@@ -106,6 +109,7 @@ declare_clippy_lint! {
     /// ```rust
     /// u32::MAX as i32; // will yield a value of `-1`
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub CAST_POSSIBLE_WRAP,
     pedantic,
     "casts that may cause wrapping around the value, e.g., `x as i32` where `x: u32` and `x > i32::MAX`"
@@ -138,6 +142,7 @@ declare_clippy_lint! {
     ///     u64::from(x)
     /// }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub CAST_LOSSLESS,
     pedantic,
     "casts using `as` that are known to be lossless, e.g., `x as u64` where `x: u8`"
@@ -163,6 +168,7 @@ declare_clippy_lint! {
     /// let _ = 2_i32;
     /// let _ = 0.5_f32;
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub UNNECESSARY_CAST,
     complexity,
     "cast to the same type, e.g., `x as i32` where `x: i32`"
@@ -190,6 +196,7 @@ declare_clippy_lint! {
     /// (&1u8 as *const u8).cast::<u16>();
     /// (&mut 1u8 as *mut u8).cast::<u16>();
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub CAST_PTR_ALIGNMENT,
     pedantic,
     "cast from a pointer to a more-strictly-aligned pointer"
@@ -217,6 +224,7 @@ declare_clippy_lint! {
     /// fn fun2() -> i32 { 1 }
     /// let a = fun2 as usize;
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub FN_TO_NUMERIC_CAST,
     style,
     "casting a function pointer to a numeric type other than usize"
@@ -247,6 +255,7 @@ declare_clippy_lint! {
     /// let fn_ptr = fn2 as usize;
     /// let fn_ptr_truncated = fn_ptr as i32;
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub FN_TO_NUMERIC_CAST_WITH_TRUNCATION,
     style,
     "casting a function pointer to a numeric type not wide enough to store the address"
@@ -283,6 +292,7 @@ declare_clippy_lint! {
     /// }
     /// let _ = fn3 as fn() -> u16;
     /// ```
+    #[clippy::version = "1.58.0"]
     pub FN_TO_NUMERIC_CAST_ANY,
     restriction,
     "casting a function pointer to any integer type"
@@ -317,6 +327,7 @@ declare_clippy_lint! {
     ///     }
     /// }
     /// ```
+    #[clippy::version = "1.33.0"]
     pub CAST_REF_TO_MUT,
     correctness,
     "a cast of reference to a mutable pointer"
@@ -344,6 +355,7 @@ declare_clippy_lint! {
     /// ```rust,ignore
     /// b'x'
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub CHAR_LIT_AS_U8,
     complexity,
     "casting a character literal to `u8` truncates"
@@ -372,6 +384,7 @@ declare_clippy_lint! {
     /// let _ = ptr.cast::<i32>();
     /// let _ = mut_ptr.cast::<i32>();
     /// ```
+    #[clippy::version = "1.51.0"]
     pub PTR_AS_PTR,
     pedantic,
     "casting using `as` from and to raw pointers that doesn't change its mutability, where `pointer::cast` could take the place of `as`"
diff --git a/clippy_lints/src/checked_conversions.rs b/clippy_lints/src/checked_conversions.rs
index 842bbf006cc..ffe6340bd77 100644
--- a/clippy_lints/src/checked_conversions.rs
+++ b/clippy_lints/src/checked_conversions.rs
@@ -36,6 +36,7 @@ declare_clippy_lint! {
     /// i32::try_from(foo).is_ok()
     /// # ;
     /// ```
+    #[clippy::version = "1.37.0"]
     pub CHECKED_CONVERSIONS,
     pedantic,
     "`try_from` could replace manual bounds checking when casting"
diff --git a/clippy_lints/src/cognitive_complexity.rs b/clippy_lints/src/cognitive_complexity.rs
index 1ccb8c5d880..84a2373efe1 100644
--- a/clippy_lints/src/cognitive_complexity.rs
+++ b/clippy_lints/src/cognitive_complexity.rs
@@ -27,6 +27,7 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// No. You'll see it when you get the warning.
+    #[clippy::version = "1.35.0"]
     pub COGNITIVE_COMPLEXITY,
     nursery,
     "functions that should be split up into multiple functions"
diff --git a/clippy_lints/src/collapsible_if.rs b/clippy_lints/src/collapsible_if.rs
index 4aa87980715..f03f34e5a4b 100644
--- a/clippy_lints/src/collapsible_if.rs
+++ b/clippy_lints/src/collapsible_if.rs
@@ -47,6 +47,7 @@ declare_clippy_lint! {
     ///     …
     /// }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub COLLAPSIBLE_IF,
     style,
     "nested `if`s that can be collapsed (e.g., `if x { if y { ... } }`"
@@ -82,6 +83,7 @@ declare_clippy_lint! {
     ///     …
     /// }
     /// ```
+    #[clippy::version = "1.51.0"]
     pub COLLAPSIBLE_ELSE_IF,
     style,
     "nested `else`-`if` expressions that can be collapsed (e.g., `else { if x { ... } }`)"
diff --git a/clippy_lints/src/collapsible_match.rs b/clippy_lints/src/collapsible_match.rs
index a4693fa213b..626f9971f01 100644
--- a/clippy_lints/src/collapsible_match.rs
+++ b/clippy_lints/src/collapsible_match.rs
@@ -41,6 +41,7 @@ declare_clippy_lint! {
     ///     };
     /// }
     /// ```
+    #[clippy::version = "1.50.0"]
     pub COLLAPSIBLE_MATCH,
     style,
     "Nested `match` or `if let` expressions where the patterns may be \"collapsed\" together."
diff --git a/clippy_lints/src/comparison_chain.rs b/clippy_lints/src/comparison_chain.rs
index 597a3c67024..399d11472b0 100644
--- a/clippy_lints/src/comparison_chain.rs
+++ b/clippy_lints/src/comparison_chain.rs
@@ -49,6 +49,7 @@ declare_clippy_lint! {
     ///      }
     /// }
     /// ```
+    #[clippy::version = "1.40.0"]
     pub COMPARISON_CHAIN,
     style,
     "`if`s that can be rewritten with `match` and `cmp`"
diff --git a/clippy_lints/src/copies.rs b/clippy_lints/src/copies.rs
index f57da62da5f..d07bc23235b 100644
--- a/clippy_lints/src/copies.rs
+++ b/clippy_lints/src/copies.rs
@@ -41,6 +41,7 @@ declare_clippy_lint! {
     ///     …
     /// }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub IFS_SAME_COND,
     correctness,
     "consecutive `if`s with the same condition"
@@ -88,6 +89,7 @@ declare_clippy_lint! {
     ///     }
     /// }
     /// ```
+    #[clippy::version = "1.41.0"]
     pub SAME_FUNCTIONS_IN_IF_CONDITION,
     pedantic,
     "consecutive `if`s with the same function call"
@@ -109,6 +111,7 @@ declare_clippy_lint! {
     ///     42
     /// };
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub IF_SAME_THEN_ELSE,
     correctness,
     "`if` with the same `then` and `else` blocks"
@@ -147,6 +150,7 @@ declare_clippy_lint! {
     ///     42
     /// };
     /// ```
+    #[clippy::version = "1.53.0"]
     pub BRANCHES_SHARING_CODE,
     nursery,
     "`if` statement with shared code in all blocks"
diff --git a/clippy_lints/src/copy_iterator.rs b/clippy_lints/src/copy_iterator.rs
index c2e9e8b3ab7..026683f6006 100644
--- a/clippy_lints/src/copy_iterator.rs
+++ b/clippy_lints/src/copy_iterator.rs
@@ -28,6 +28,7 @@ declare_clippy_lint! {
     /// let a: Vec<_> = my_iterator.take(1).collect();
     /// let b: Vec<_> = my_iterator.collect();
     /// ```
+    #[clippy::version = "1.30.0"]
     pub COPY_ITERATOR,
     pedantic,
     "implementing `Iterator` on a `Copy` type"
diff --git a/clippy_lints/src/create_dir.rs b/clippy_lints/src/create_dir.rs
index e4ee2772483..6bc4054a5ab 100644
--- a/clippy_lints/src/create_dir.rs
+++ b/clippy_lints/src/create_dir.rs
@@ -23,6 +23,7 @@ declare_clippy_lint! {
     /// ```rust
     /// std::fs::create_dir_all("foo");
     /// ```
+    #[clippy::version = "1.48.0"]
     pub CREATE_DIR,
     restriction,
     "calling `std::fs::create_dir` instead of `std::fs::create_dir_all`"
diff --git a/clippy_lints/src/dbg_macro.rs b/clippy_lints/src/dbg_macro.rs
index bab4a696f83..1aae4c81c73 100644
--- a/clippy_lints/src/dbg_macro.rs
+++ b/clippy_lints/src/dbg_macro.rs
@@ -23,6 +23,7 @@ declare_clippy_lint! {
     /// // Good
     /// true
     /// ```
+    #[clippy::version = "1.34.0"]
     pub DBG_MACRO,
     restriction,
     "`dbg!` macro is intended as a debugging tool"
diff --git a/clippy_lints/src/default.rs b/clippy_lints/src/default.rs
index 54647ba823e..a0b137efe22 100644
--- a/clippy_lints/src/default.rs
+++ b/clippy_lints/src/default.rs
@@ -29,6 +29,7 @@ declare_clippy_lint! {
     /// // Good
     /// let s = String::default();
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub DEFAULT_TRAIT_ACCESS,
     pedantic,
     "checks for literal calls to `Default::default()`"
@@ -62,6 +63,7 @@ declare_clippy_lint! {
     ///     .. Default::default()
     /// };
     /// ```
+    #[clippy::version = "1.49.0"]
     pub FIELD_REASSIGN_WITH_DEFAULT,
     style,
     "binding initialized with Default should have its fields set in the initializer"
diff --git a/clippy_lints/src/default_numeric_fallback.rs b/clippy_lints/src/default_numeric_fallback.rs
index 3f1b7ea6214..3573ea5f026 100644
--- a/clippy_lints/src/default_numeric_fallback.rs
+++ b/clippy_lints/src/default_numeric_fallback.rs
@@ -46,6 +46,7 @@ declare_clippy_lint! {
     /// let i = 10i32;
     /// let f = 1.23f64;
     /// ```
+    #[clippy::version = "1.52.0"]
     pub DEFAULT_NUMERIC_FALLBACK,
     restriction,
     "usage of unconstrained numeric literals which may cause default numeric fallback."
diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index 975353add08..bbaae94d3dd 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -34,6 +34,7 @@ declare_clippy_lint! {
     /// ```rust,ignore
     /// let _ = d.unwrap().deref();
     /// ```
+    #[clippy::version = "1.44.0"]
     pub EXPLICIT_DEREF_METHODS,
     pedantic,
     "Explicit use of deref or deref_mut method while not in a method chain."
diff --git a/clippy_lints/src/derivable_impls.rs b/clippy_lints/src/derivable_impls.rs
index 01ec306e5e1..d0fab2b48fb 100644
--- a/clippy_lints/src/derivable_impls.rs
+++ b/clippy_lints/src/derivable_impls.rs
@@ -46,6 +46,7 @@ declare_clippy_lint! {
     /// has exactly equal bounds, and therefore this lint is disabled for types with
     /// generic parameters.
     ///
+    #[clippy::version = "1.57.0"]
     pub DERIVABLE_IMPLS,
     complexity,
     "manual implementation of the `Default` trait which is equal to a derive"
diff --git a/clippy_lints/src/derive.rs b/clippy_lints/src/derive.rs
index 24ac5917dcb..4b232a26e5d 100644
--- a/clippy_lints/src/derive.rs
+++ b/clippy_lints/src/derive.rs
@@ -38,6 +38,7 @@ declare_clippy_lint! {
     ///     ...
     /// }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub DERIVE_HASH_XOR_EQ,
     correctness,
     "deriving `Hash` but implementing `PartialEq` explicitly"
@@ -88,6 +89,7 @@ declare_clippy_lint! {
     /// #[derive(Ord, PartialOrd, PartialEq, Eq)]
     /// struct Foo;
     /// ```
+    #[clippy::version = "1.47.0"]
     pub DERIVE_ORD_XOR_PARTIAL_ORD,
     correctness,
     "deriving `Ord` but implementing `PartialOrd` explicitly"
@@ -114,6 +116,7 @@ declare_clippy_lint! {
     ///     // ..
     /// }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub EXPL_IMPL_CLONE_ON_COPY,
     pedantic,
     "implementing `Clone` explicitly on `Copy` types"
@@ -147,6 +150,7 @@ declare_clippy_lint! {
     ///     }
     /// }
     /// ```
+    #[clippy::version = "1.45.0"]
     pub UNSAFE_DERIVE_DESERIALIZE,
     pedantic,
     "deriving `serde::Deserialize` on a type that has methods using `unsafe`"
diff --git a/clippy_lints/src/disallowed_method.rs b/clippy_lints/src/disallowed_method.rs
index 22d726cdcb7..c2217353b32 100644
--- a/clippy_lints/src/disallowed_method.rs
+++ b/clippy_lints/src/disallowed_method.rs
@@ -47,6 +47,7 @@ declare_clippy_lint! {
     /// let mut xs = Vec::new(); // Vec::new is _not_ disallowed in the config.
     /// xs.push(123); // Vec::push is _not_ disallowed in the config.
     /// ```
+    #[clippy::version = "1.49.0"]
     pub DISALLOWED_METHOD,
     nursery,
     "use of a disallowed method call"
diff --git a/clippy_lints/src/disallowed_script_idents.rs b/clippy_lints/src/disallowed_script_idents.rs
index 6d38d30cd0b..3c3f3631849 100644
--- a/clippy_lints/src/disallowed_script_idents.rs
+++ b/clippy_lints/src/disallowed_script_idents.rs
@@ -38,6 +38,7 @@ declare_clippy_lint! {
     /// let zähler = 10; // OK, it's still latin.
     /// let カウンタ = 10; // Will spawn the lint.
     /// ```
+    #[clippy::version = "1.55.0"]
     pub DISALLOWED_SCRIPT_IDENTS,
     restriction,
     "usage of non-allowed Unicode scripts"
diff --git a/clippy_lints/src/disallowed_type.rs b/clippy_lints/src/disallowed_type.rs
index 48f781516f4..7e784ca2244 100644
--- a/clippy_lints/src/disallowed_type.rs
+++ b/clippy_lints/src/disallowed_type.rs
@@ -42,6 +42,7 @@ declare_clippy_lint! {
     /// // A similar type that is allowed by the config
     /// use std::collections::HashMap;
     /// ```
+    #[clippy::version = "1.55.0"]
     pub DISALLOWED_TYPE,
     nursery,
     "use of a disallowed type"
diff --git a/clippy_lints/src/doc.rs b/clippy_lints/src/doc.rs
index 87ad5178ff0..249cf260309 100644
--- a/clippy_lints/src/doc.rs
+++ b/clippy_lints/src/doc.rs
@@ -67,6 +67,7 @@ declare_clippy_lint! {
     /// /// [SmallVec]: SmallVec
     /// fn main() {}
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub DOC_MARKDOWN,
     pedantic,
     "presence of `_`, `::` or camel-case outside backticks in documentation"
@@ -101,6 +102,7 @@ declare_clippy_lint! {
     ///     unimplemented!();
     /// }
     /// ```
+    #[clippy::version = "1.39.0"]
     pub MISSING_SAFETY_DOC,
     style,
     "`pub unsafe fn` without `# Safety` docs"
@@ -129,6 +131,7 @@ declare_clippy_lint! {
     ///     unimplemented!();
     /// }
     /// ```
+    #[clippy::version = "1.41.0"]
     pub MISSING_ERRORS_DOC,
     pedantic,
     "`pub fn` returns `Result` without `# Errors` in doc comment"
@@ -159,6 +162,7 @@ declare_clippy_lint! {
     ///     }
     /// }
     /// ```
+    #[clippy::version = "1.52.0"]
     pub MISSING_PANICS_DOC,
     pedantic,
     "`pub fn` may panic without `# Panics` in doc comment"
@@ -187,6 +191,7 @@ declare_clippy_lint! {
     ///     unimplemented!();
     /// }
     /// ``````
+    #[clippy::version = "1.40.0"]
     pub NEEDLESS_DOCTEST_MAIN,
     style,
     "presence of `fn main() {` in code examples"
diff --git a/clippy_lints/src/double_comparison.rs b/clippy_lints/src/double_comparison.rs
index 6520bb91faf..176092e5b28 100644
--- a/clippy_lints/src/double_comparison.rs
+++ b/clippy_lints/src/double_comparison.rs
@@ -31,6 +31,7 @@ declare_clippy_lint! {
     /// # let y = 2;
     /// if x <= y {}
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub DOUBLE_COMPARISONS,
     complexity,
     "unnecessary double comparisons that can be simplified"
diff --git a/clippy_lints/src/double_parens.rs b/clippy_lints/src/double_parens.rs
index d0d87b6df9a..e10f740d24a 100644
--- a/clippy_lints/src/double_parens.rs
+++ b/clippy_lints/src/double_parens.rs
@@ -32,6 +32,7 @@ declare_clippy_lint! {
     /// // Good
     /// foo(0);
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub DOUBLE_PARENS,
     complexity,
     "Warn on unnecessary double parentheses"
diff --git a/clippy_lints/src/drop_forget_ref.rs b/clippy_lints/src/drop_forget_ref.rs
index 0f3dc866afb..a8f8e3d8a42 100644
--- a/clippy_lints/src/drop_forget_ref.rs
+++ b/clippy_lints/src/drop_forget_ref.rs
@@ -25,6 +25,7 @@ declare_clippy_lint! {
     /// // still locked
     /// operation_that_requires_mutex_to_be_unlocked();
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub DROP_REF,
     correctness,
     "calls to `std::mem::drop` with a reference instead of an owned value"
@@ -46,6 +47,7 @@ declare_clippy_lint! {
     /// let x = Box::new(1);
     /// std::mem::forget(&x) // Should have been forget(x), x will still be dropped
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub FORGET_REF,
     correctness,
     "calls to `std::mem::forget` with a reference instead of an owned value"
@@ -67,6 +69,7 @@ declare_clippy_lint! {
     /// std::mem::drop(x) // A copy of x is passed to the function, leaving the
     ///                   // original unaffected
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub DROP_COPY,
     correctness,
     "calls to `std::mem::drop` with a value that implements Copy"
@@ -94,6 +97,7 @@ declare_clippy_lint! {
     /// std::mem::forget(x) // A copy of x is passed to the function, leaving the
     ///                     // original unaffected
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub FORGET_COPY,
     correctness,
     "calls to `std::mem::forget` with a value that implements Copy"
diff --git a/clippy_lints/src/duration_subsec.rs b/clippy_lints/src/duration_subsec.rs
index 3774de62521..3070d105014 100644
--- a/clippy_lints/src/duration_subsec.rs
+++ b/clippy_lints/src/duration_subsec.rs
@@ -33,6 +33,7 @@ declare_clippy_lint! {
     /// let _micros = dur.subsec_micros();
     /// let _millis = dur.subsec_millis();
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub DURATION_SUBSEC,
     complexity,
     "checks for calculation of subsecond microseconds or milliseconds"
diff --git a/clippy_lints/src/else_if_without_else.rs b/clippy_lints/src/else_if_without_else.rs
index b64246515f3..92c56c762aa 100644
--- a/clippy_lints/src/else_if_without_else.rs
+++ b/clippy_lints/src/else_if_without_else.rs
@@ -40,6 +40,7 @@ declare_clippy_lint! {
     ///     // We don't care about zero.
     /// }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub ELSE_IF_WITHOUT_ELSE,
     restriction,
     "`if` expression with an `else if`, but without a final `else` branch"
diff --git a/clippy_lints/src/empty_enum.rs b/clippy_lints/src/empty_enum.rs
index 3453c2da278..af9e65e6361 100644
--- a/clippy_lints/src/empty_enum.rs
+++ b/clippy_lints/src/empty_enum.rs
@@ -34,6 +34,7 @@ declare_clippy_lint! {
     ///
     /// struct Test(!);
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub EMPTY_ENUM,
     pedantic,
     "enum with no variants"
diff --git a/clippy_lints/src/entry.rs b/clippy_lints/src/entry.rs
index 57fd24bd4f0..3d92eb16870 100644
--- a/clippy_lints/src/entry.rs
+++ b/clippy_lints/src/entry.rs
@@ -54,6 +54,7 @@ declare_clippy_lint! {
     /// # let v = 1;
     /// map.entry(k).or_insert(v);
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub MAP_ENTRY,
     perf,
     "use of `contains_key` followed by `insert` on a `HashMap` or `BTreeMap`"
diff --git a/clippy_lints/src/enum_clike.rs b/clippy_lints/src/enum_clike.rs
index a2c3c7a7b49..3b6661c817b 100644
--- a/clippy_lints/src/enum_clike.rs
+++ b/clippy_lints/src/enum_clike.rs
@@ -28,6 +28,7 @@ declare_clippy_lint! {
     ///     Y = 0,
     /// }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub ENUM_CLIKE_UNPORTABLE_VARIANT,
     correctness,
     "C-like enums that are `repr(isize/usize)` and have values that don't fit into an `i32`"
diff --git a/clippy_lints/src/enum_variants.rs b/clippy_lints/src/enum_variants.rs
index 404b67c8f29..fc3a35efaf8 100644
--- a/clippy_lints/src/enum_variants.rs
+++ b/clippy_lints/src/enum_variants.rs
@@ -34,6 +34,7 @@ declare_clippy_lint! {
     ///     Battenberg,
     /// }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub ENUM_VARIANT_NAMES,
     style,
     "enums where all variants share a prefix/postfix"
@@ -59,6 +60,7 @@ declare_clippy_lint! {
     ///     struct BlackForest;
     /// }
     /// ```
+    #[clippy::version = "1.33.0"]
     pub MODULE_NAME_REPETITIONS,
     pedantic,
     "type names prefixed/postfixed with their containing module's name"
@@ -89,6 +91,7 @@ declare_clippy_lint! {
     ///     ...
     /// }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub MODULE_INCEPTION,
     style,
     "modules that have the same name as their parent module"
diff --git a/clippy_lints/src/eq_op.rs b/clippy_lints/src/eq_op.rs
index c034c849b55..10123460527 100644
--- a/clippy_lints/src/eq_op.rs
+++ b/clippy_lints/src/eq_op.rs
@@ -34,6 +34,7 @@ declare_clippy_lint! {
     /// # let b = 4;
     /// assert_eq!(a, a);
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub EQ_OP,
     correctness,
     "equal operands on both sides of a comparison or bitwise combination (e.g., `x == x`)"
@@ -59,6 +60,7 @@ declare_clippy_lint! {
     /// // Good
     /// x == *y
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub OP_REF,
     style,
     "taking a reference to satisfy the type constraints on `==`"
diff --git a/clippy_lints/src/equatable_if_let.rs b/clippy_lints/src/equatable_if_let.rs
index e8b1d6f6eda..8905cc0de45 100644
--- a/clippy_lints/src/equatable_if_let.rs
+++ b/clippy_lints/src/equatable_if_let.rs
@@ -32,6 +32,7 @@ declare_clippy_lint! {
     ///     do_thing();
     /// }
     /// ```
+    #[clippy::version = "1.57.0"]
     pub EQUATABLE_IF_LET,
     nursery,
     "using pattern matching instead of equality"
diff --git a/clippy_lints/src/erasing_op.rs b/clippy_lints/src/erasing_op.rs
index d0944c37cf5..d49cec26be5 100644
--- a/clippy_lints/src/erasing_op.rs
+++ b/clippy_lints/src/erasing_op.rs
@@ -21,6 +21,7 @@ declare_clippy_lint! {
     /// 0 * x;
     /// x & 0;
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub ERASING_OP,
     correctness,
     "using erasing operations, e.g., `x * 0` or `y & 0`"
diff --git a/clippy_lints/src/escape.rs b/clippy_lints/src/escape.rs
index 75b1c882c23..bc5d2f6278d 100644
--- a/clippy_lints/src/escape.rs
+++ b/clippy_lints/src/escape.rs
@@ -41,6 +41,7 @@ declare_clippy_lint! {
     /// foo(x);
     /// println!("{}", x);
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub BOXED_LOCAL,
     perf,
     "using `Box<T>` where unnecessary"
diff --git a/clippy_lints/src/eta_reduction.rs b/clippy_lints/src/eta_reduction.rs
index 8def6529b3b..5a4b4247104 100644
--- a/clippy_lints/src/eta_reduction.rs
+++ b/clippy_lints/src/eta_reduction.rs
@@ -39,6 +39,7 @@ declare_clippy_lint! {
     /// ```
     /// where `foo(_)` is a plain function that takes the exact argument type of
     /// `x`.
+    #[clippy::version = "pre 1.29.0"]
     pub REDUNDANT_CLOSURE,
     style,
     "redundant closures, i.e., `|a| foo(a)` (which can be written as just `foo`)"
@@ -60,6 +61,7 @@ declare_clippy_lint! {
     /// ```rust,ignore
     /// Some('a').map(char::to_uppercase);
     /// ```
+    #[clippy::version = "1.35.0"]
     pub REDUNDANT_CLOSURE_FOR_METHOD_CALLS,
     pedantic,
     "redundant closures for method calls"
diff --git a/clippy_lints/src/eval_order_dependence.rs b/clippy_lints/src/eval_order_dependence.rs
index 1b56dd4b081..cdac9f3e6e1 100644
--- a/clippy_lints/src/eval_order_dependence.rs
+++ b/clippy_lints/src/eval_order_dependence.rs
@@ -40,6 +40,7 @@ declare_clippy_lint! {
     /// };
     /// let a = tmp + x;
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub EVAL_ORDER_DEPENDENCE,
     suspicious,
     "whether a variable read occurs before a write depends on sub-expression evaluation order"
@@ -67,6 +68,7 @@ declare_clippy_lint! {
     /// let x = (a, b, c, panic!());
     /// // can simply be replaced by `panic!()`
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub DIVERGING_SUB_EXPRESSION,
     complexity,
     "whether an expression contains a diverging sub expression"
diff --git a/clippy_lints/src/excessive_bools.rs b/clippy_lints/src/excessive_bools.rs
index 06171702f75..5435e15de7b 100644
--- a/clippy_lints/src/excessive_bools.rs
+++ b/clippy_lints/src/excessive_bools.rs
@@ -37,6 +37,7 @@ declare_clippy_lint! {
     ///     Finished,
     /// }
     /// ```
+    #[clippy::version = "1.43.0"]
     pub STRUCT_EXCESSIVE_BOOLS,
     pedantic,
     "using too many bools in a struct"
@@ -75,6 +76,7 @@ declare_clippy_lint! {
     ///
     /// fn f(shape: Shape, temperature: Temperature) { ... }
     /// ```
+    #[clippy::version = "1.43.0"]
     pub FN_PARAMS_EXCESSIVE_BOOLS,
     pedantic,
     "using too many bools in function parameters"
diff --git a/clippy_lints/src/exhaustive_items.rs b/clippy_lints/src/exhaustive_items.rs
index bb4684ce38b..b0f50b5c144 100644
--- a/clippy_lints/src/exhaustive_items.rs
+++ b/clippy_lints/src/exhaustive_items.rs
@@ -31,6 +31,7 @@ declare_clippy_lint! {
     ///     Baz
     /// }
     /// ```
+    #[clippy::version = "1.51.0"]
     pub EXHAUSTIVE_ENUMS,
     restriction,
     "detects exported enums that have not been marked #[non_exhaustive]"
@@ -60,6 +61,7 @@ declare_clippy_lint! {
     ///     baz: String,
     /// }
     /// ```
+    #[clippy::version = "1.51.0"]
     pub EXHAUSTIVE_STRUCTS,
     restriction,
     "detects exported structs that have not been marked #[non_exhaustive]"
diff --git a/clippy_lints/src/exit.rs b/clippy_lints/src/exit.rs
index 9cd5b2d9f44..d64cc61916c 100644
--- a/clippy_lints/src/exit.rs
+++ b/clippy_lints/src/exit.rs
@@ -18,6 +18,7 @@ declare_clippy_lint! {
     /// ```ignore
     /// std::process::exit(0)
     /// ```
+    #[clippy::version = "1.41.0"]
     pub EXIT,
     restriction,
     "`std::process::exit` is called, terminating the program"
diff --git a/clippy_lints/src/explicit_write.rs b/clippy_lints/src/explicit_write.rs
index 4f46ef906f4..6b327b9ce17 100644
--- a/clippy_lints/src/explicit_write.rs
+++ b/clippy_lints/src/explicit_write.rs
@@ -23,6 +23,7 @@ declare_clippy_lint! {
     /// // this would be clearer as `eprintln!("foo: {:?}", bar);`
     /// writeln!(&mut std::io::stderr(), "foo: {:?}", bar).unwrap();
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub EXPLICIT_WRITE,
     complexity,
     "using the `write!()` family of functions instead of the `print!()` family of functions, when using the latter would work"
diff --git a/clippy_lints/src/fallible_impl_from.rs b/clippy_lints/src/fallible_impl_from.rs
index 70337f5bbeb..05d300058cf 100644
--- a/clippy_lints/src/fallible_impl_from.rs
+++ b/clippy_lints/src/fallible_impl_from.rs
@@ -44,6 +44,7 @@ declare_clippy_lint! {
     ///     }
     /// }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub FALLIBLE_IMPL_FROM,
     nursery,
     "Warn on impls of `From<..>` that contain `panic!()` or `unwrap()`"
diff --git a/clippy_lints/src/feature_name.rs b/clippy_lints/src/feature_name.rs
index f534327f7a0..dc6bef52ddd 100644
--- a/clippy_lints/src/feature_name.rs
+++ b/clippy_lints/src/feature_name.rs
@@ -31,6 +31,7 @@ declare_clippy_lint! {
     /// ghi = []
     /// ```
     ///
+    #[clippy::version = "1.57.0"]
     pub REDUNDANT_FEATURE_NAMES,
     cargo,
     "usage of a redundant feature name"
@@ -60,6 +61,7 @@ declare_clippy_lint! {
     /// def = []
     ///
     /// ```
+    #[clippy::version = "1.57.0"]
     pub NEGATIVE_FEATURE_NAMES,
     cargo,
     "usage of a negative feature name"
diff --git a/clippy_lints/src/float_equality_without_abs.rs b/clippy_lints/src/float_equality_without_abs.rs
index c33d80b8e8e..ca8886228de 100644
--- a/clippy_lints/src/float_equality_without_abs.rs
+++ b/clippy_lints/src/float_equality_without_abs.rs
@@ -37,6 +37,7 @@ declare_clippy_lint! {
     ///     (a - b).abs() < f32::EPSILON
     /// }
     /// ```
+    #[clippy::version = "1.48.0"]
     pub FLOAT_EQUALITY_WITHOUT_ABS,
     suspicious,
     "float equality check without `.abs()`"
diff --git a/clippy_lints/src/float_literal.rs b/clippy_lints/src/float_literal.rs
index 1e8a5bd7d34..d30dede833c 100644
--- a/clippy_lints/src/float_literal.rs
+++ b/clippy_lints/src/float_literal.rs
@@ -27,6 +27,7 @@ declare_clippy_lint! {
     /// let v: f64 = 0.123_456_789_9;
     /// println!("{}", v); //  0.123_456_789_9
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub EXCESSIVE_PRECISION,
     style,
     "excessive precision for float literal"
@@ -50,6 +51,7 @@ declare_clippy_lint! {
     /// let _: f32 = 16_777_216.0;
     /// let _: f64 = 16_777_217.0;
     /// ```
+    #[clippy::version = "1.43.0"]
     pub LOSSY_FLOAT_LITERAL,
     restriction,
     "lossy whole number float literals"
diff --git a/clippy_lints/src/floating_point_arithmetic.rs b/clippy_lints/src/floating_point_arithmetic.rs
index eda611117ba..914723a4802 100644
--- a/clippy_lints/src/floating_point_arithmetic.rs
+++ b/clippy_lints/src/floating_point_arithmetic.rs
@@ -43,6 +43,7 @@ declare_clippy_lint! {
     /// let _ = a.ln_1p();
     /// let _ = a.exp_m1();
     /// ```
+    #[clippy::version = "1.43.0"]
     pub IMPRECISE_FLOPS,
     nursery,
     "usage of imprecise floating point operations"
@@ -99,6 +100,7 @@ declare_clippy_lint! {
     /// let _ = a.abs();
     /// let _ = -a.abs();
     /// ```
+    #[clippy::version = "1.43.0"]
     pub SUBOPTIMAL_FLOPS,
     nursery,
     "usage of sub-optimal floating point operations"
diff --git a/clippy_lints/src/format.rs b/clippy_lints/src/format.rs
index 7169ac9ad6c..3f043e5f2f1 100644
--- a/clippy_lints/src/format.rs
+++ b/clippy_lints/src/format.rs
@@ -33,6 +33,7 @@ declare_clippy_lint! {
     /// // Good
     /// foo.to_owned();
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub USELESS_FORMAT,
     complexity,
     "useless use of `format!`"
diff --git a/clippy_lints/src/format_args.rs b/clippy_lints/src/format_args.rs
index bb30accf145..f0e1a67dcdd 100644
--- a/clippy_lints/src/format_args.rs
+++ b/clippy_lints/src/format_args.rs
@@ -31,6 +31,7 @@ declare_clippy_lint! {
     /// # use std::panic::Location;
     /// println!("error: something failed at {}", Location::caller());
     /// ```
+    #[clippy::version = "1.58.0"]
     pub FORMAT_IN_FORMAT_ARGS,
     perf,
     "`format!` used in a macro that does formatting"
@@ -56,6 +57,7 @@ declare_clippy_lint! {
     /// # use std::panic::Location;
     /// println!("error: something failed at {}", Location::caller());
     /// ```
+    #[clippy::version = "1.58.0"]
     pub TO_STRING_IN_FORMAT_ARGS,
     perf,
     "`to_string` applied to a type that implements `Display` in format args"
diff --git a/clippy_lints/src/formatting.rs b/clippy_lints/src/formatting.rs
index b4f186525c5..3e85c8a9c80 100644
--- a/clippy_lints/src/formatting.rs
+++ b/clippy_lints/src/formatting.rs
@@ -21,6 +21,7 @@ declare_clippy_lint! {
     /// ```rust,ignore
     /// a =- 42; // confusing, should it be `a -= 42` or `a = -42`?
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub SUSPICIOUS_ASSIGNMENT_FORMATTING,
     suspicious,
     "suspicious formatting of `*=`, `-=` or `!=`"
@@ -43,6 +44,7 @@ declare_clippy_lint! {
     /// if foo &&! bar { // this should be `foo && !bar` but looks like a different operator
     /// }
     /// ```
+    #[clippy::version = "1.40.0"]
     pub SUSPICIOUS_UNARY_OP_FORMATTING,
     suspicious,
     "suspicious formatting of unary `-` or `!` on the RHS of a BinOp"
@@ -79,6 +81,7 @@ declare_clippy_lint! {
     /// if bar { // this is the `else` block of the previous `if`, but should it be?
     /// }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub SUSPICIOUS_ELSE_FORMATTING,
     suspicious,
     "suspicious formatting of `else`"
@@ -99,6 +102,7 @@ declare_clippy_lint! {
     ///     -4, -5, -6
     /// ];
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub POSSIBLE_MISSING_COMMA,
     correctness,
     "possible missing comma in array"
diff --git a/clippy_lints/src/from_over_into.rs b/clippy_lints/src/from_over_into.rs
index 347c6eb12cb..866ff216f84 100644
--- a/clippy_lints/src/from_over_into.rs
+++ b/clippy_lints/src/from_over_into.rs
@@ -34,6 +34,7 @@ declare_clippy_lint! {
     ///     }
     /// }
     /// ```
+    #[clippy::version = "1.51.0"]
     pub FROM_OVER_INTO,
     style,
     "Warns on implementations of `Into<..>` to use `From<..>`"
diff --git a/clippy_lints/src/from_str_radix_10.rs b/clippy_lints/src/from_str_radix_10.rs
index 98ce3db025c..73e800073b0 100644
--- a/clippy_lints/src/from_str_radix_10.rs
+++ b/clippy_lints/src/from_str_radix_10.rs
@@ -35,6 +35,7 @@ declare_clippy_lint! {
     /// let input: &str = get_input();
     /// let num: u16 = input.parse()?;
     /// ```
+    #[clippy::version = "1.52.0"]
     pub FROM_STR_RADIX_10,
     style,
     "from_str_radix with radix 10"
diff --git a/clippy_lints/src/functions/mod.rs b/clippy_lints/src/functions/mod.rs
index d7c5ec9ba35..ad031cbc09d 100644
--- a/clippy_lints/src/functions/mod.rs
+++ b/clippy_lints/src/functions/mod.rs
@@ -26,6 +26,7 @@ declare_clippy_lint! {
     ///     // ..
     /// }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub TOO_MANY_ARGUMENTS,
     complexity,
     "functions with too many arguments"
@@ -49,6 +50,7 @@ declare_clippy_lint! {
     ///     println!("");
     /// }
     /// ```
+    #[clippy::version = "1.34.0"]
     pub TOO_MANY_LINES,
     pedantic,
     "functions with too many lines"
@@ -84,6 +86,7 @@ declare_clippy_lint! {
     ///     println!("{}", unsafe { *x });
     /// }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub NOT_UNSAFE_PTR_ARG_DEREF,
     correctness,
     "public functions dereferencing raw pointer arguments but not marked `unsafe`"
@@ -103,6 +106,7 @@ declare_clippy_lint! {
     /// #[must_use]
     /// fn useless() { }
     /// ```
+    #[clippy::version = "1.40.0"]
     pub MUST_USE_UNIT,
     style,
     "`#[must_use]` attribute on a unit-returning function / method"
@@ -126,6 +130,7 @@ declare_clippy_lint! {
     ///     unimplemented!();
     /// }
     /// ```
+    #[clippy::version = "1.40.0"]
     pub DOUBLE_MUST_USE,
     style,
     "`#[must_use]` attribute on a `#[must_use]`-returning function / method"
@@ -155,6 +160,7 @@ declare_clippy_lint! {
     /// // this could be annotated with `#[must_use]`.
     /// fn id<T>(t: T) -> T { t }
     /// ```
+    #[clippy::version = "1.40.0"]
     pub MUST_USE_CANDIDATE,
     pedantic,
     "function or method that could take a `#[must_use]` attribute"
@@ -204,6 +210,7 @@ declare_clippy_lint! {
     ///
     /// Note that there are crates that simplify creating the error type, e.g.
     /// [`thiserror`](https://docs.rs/thiserror).
+    #[clippy::version = "1.49.0"]
     pub RESULT_UNIT_ERR,
     style,
     "public function returning `Result` with an `Err` type of `()`"
diff --git a/clippy_lints/src/future_not_send.rs b/clippy_lints/src/future_not_send.rs
index e18442515b8..03af498eae3 100644
--- a/clippy_lints/src/future_not_send.rs
+++ b/clippy_lints/src/future_not_send.rs
@@ -41,6 +41,7 @@ declare_clippy_lint! {
     /// ```rust
     /// async fn is_send(bytes: std::sync::Arc<[u8]>) {}
     /// ```
+    #[clippy::version = "1.44.0"]
     pub FUTURE_NOT_SEND,
     nursery,
     "public Futures must be Send"
diff --git a/clippy_lints/src/get_last_with_len.rs b/clippy_lints/src/get_last_with_len.rs
index f3929b0f1e6..edca701869e 100644
--- a/clippy_lints/src/get_last_with_len.rs
+++ b/clippy_lints/src/get_last_with_len.rs
@@ -39,6 +39,7 @@ declare_clippy_lint! {
     /// let x = vec![2, 3, 5];
     /// let last_element = x.last();
     /// ```
+    #[clippy::version = "1.37.0"]
     pub GET_LAST_WITH_LEN,
     complexity,
     "Using `x.get(x.len() - 1)` when `x.last()` is correct and simpler"
diff --git a/clippy_lints/src/identity_op.rs b/clippy_lints/src/identity_op.rs
index 414f465c494..b4e7bbc7671 100644
--- a/clippy_lints/src/identity_op.rs
+++ b/clippy_lints/src/identity_op.rs
@@ -22,6 +22,7 @@ declare_clippy_lint! {
     /// # let x = 1;
     /// x / 1 + 0 * 1 - 0 | 0;
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub IDENTITY_OP,
     complexity,
     "using identity operations, e.g., `x + 0` or `y / 1`"
diff --git a/clippy_lints/src/if_let_mutex.rs b/clippy_lints/src/if_let_mutex.rs
index a4118bf54b6..e20741d2407 100644
--- a/clippy_lints/src/if_let_mutex.rs
+++ b/clippy_lints/src/if_let_mutex.rs
@@ -36,6 +36,7 @@ declare_clippy_lint! {
     ///     use_locked(locked);
     /// }
     /// ```
+    #[clippy::version = "1.45.0"]
     pub IF_LET_MUTEX,
     correctness,
     "locking a `Mutex` in an `if let` block can cause deadlocks"
diff --git a/clippy_lints/src/if_not_else.rs b/clippy_lints/src/if_not_else.rs
index ac938156237..3d59b783337 100644
--- a/clippy_lints/src/if_not_else.rs
+++ b/clippy_lints/src/if_not_else.rs
@@ -39,6 +39,7 @@ declare_clippy_lint! {
     ///     a()
     /// }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub IF_NOT_ELSE,
     pedantic,
     "`if` branches that could be swapped so no negation operation is necessary on the condition"
diff --git a/clippy_lints/src/if_then_some_else_none.rs b/clippy_lints/src/if_then_some_else_none.rs
index a2dac57454f..d95f5d41071 100644
--- a/clippy_lints/src/if_then_some_else_none.rs
+++ b/clippy_lints/src/if_then_some_else_none.rs
@@ -36,6 +36,7 @@ declare_clippy_lint! {
     ///     42
     /// });
     /// ```
+    #[clippy::version = "1.53.0"]
     pub IF_THEN_SOME_ELSE_NONE,
     restriction,
     "Finds if-else that could be written using `bool::then`"
diff --git a/clippy_lints/src/implicit_hasher.rs b/clippy_lints/src/implicit_hasher.rs
index 81eb51e6f7c..6358228dd47 100644
--- a/clippy_lints/src/implicit_hasher.rs
+++ b/clippy_lints/src/implicit_hasher.rs
@@ -54,6 +54,7 @@ declare_clippy_lint! {
     ///
     /// pub fn foo<S: BuildHasher>(map: &mut HashMap<i32, i32, S>) { }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub IMPLICIT_HASHER,
     pedantic,
     "missing generalization over different hashers"
diff --git a/clippy_lints/src/implicit_return.rs b/clippy_lints/src/implicit_return.rs
index 6d7c71d4082..07caeada80d 100644
--- a/clippy_lints/src/implicit_return.rs
+++ b/clippy_lints/src/implicit_return.rs
@@ -35,6 +35,7 @@ declare_clippy_lint! {
     ///     return x;
     /// }
     /// ```
+    #[clippy::version = "1.33.0"]
     pub IMPLICIT_RETURN,
     restriction,
     "use a return statement like `return expr` instead of an expression"
diff --git a/clippy_lints/src/implicit_saturating_sub.rs b/clippy_lints/src/implicit_saturating_sub.rs
index ecbbbc5bc64..4088c54623d 100644
--- a/clippy_lints/src/implicit_saturating_sub.rs
+++ b/clippy_lints/src/implicit_saturating_sub.rs
@@ -30,6 +30,7 @@ declare_clippy_lint! {
     /// // Good
     /// i = i.saturating_sub(1);
     /// ```
+    #[clippy::version = "1.44.0"]
     pub IMPLICIT_SATURATING_SUB,
     pedantic,
     "Perform saturating subtraction instead of implicitly checking lower bound of data type"
diff --git a/clippy_lints/src/inconsistent_struct_constructor.rs b/clippy_lints/src/inconsistent_struct_constructor.rs
index 52c92b3b122..1debdef9d86 100644
--- a/clippy_lints/src/inconsistent_struct_constructor.rs
+++ b/clippy_lints/src/inconsistent_struct_constructor.rs
@@ -55,6 +55,7 @@ declare_clippy_lint! {
     /// # let y = 2;
     /// Foo { x, y };
     /// ```
+    #[clippy::version = "1.52.0"]
     pub INCONSISTENT_STRUCT_CONSTRUCTOR,
     pedantic,
     "the order of the field init shorthand is inconsistent with the order in the struct definition"
diff --git a/clippy_lints/src/indexing_slicing.rs b/clippy_lints/src/indexing_slicing.rs
index f52f090d387..9ead4bb27a5 100644
--- a/clippy_lints/src/indexing_slicing.rs
+++ b/clippy_lints/src/indexing_slicing.rs
@@ -33,6 +33,7 @@ declare_clippy_lint! {
     /// x[0];
     /// x[3];
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub OUT_OF_BOUNDS_INDEXING,
     correctness,
     "out of bounds constant indexing"
@@ -85,6 +86,7 @@ declare_clippy_lint! {
     /// y.get(10..);
     /// y.get(..100);
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub INDEXING_SLICING,
     restriction,
     "indexing/slicing usage"
diff --git a/clippy_lints/src/infinite_iter.rs b/clippy_lints/src/infinite_iter.rs
index 68c1fa35fcc..c7db47a552b 100644
--- a/clippy_lints/src/infinite_iter.rs
+++ b/clippy_lints/src/infinite_iter.rs
@@ -20,6 +20,7 @@ declare_clippy_lint! {
     ///
     /// iter::repeat(1_u8).collect::<Vec<_>>();
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub INFINITE_ITER,
     correctness,
     "infinite iteration"
@@ -42,6 +43,7 @@ declare_clippy_lint! {
     /// let infinite_iter = 0..;
     /// [0..].iter().zip(infinite_iter.take_while(|x| *x > 5));
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub MAYBE_INFINITE_ITER,
     pedantic,
     "possible infinite iteration"
diff --git a/clippy_lints/src/inherent_impl.rs b/clippy_lints/src/inherent_impl.rs
index bd0b2964309..254d3f8a4d0 100644
--- a/clippy_lints/src/inherent_impl.rs
+++ b/clippy_lints/src/inherent_impl.rs
@@ -36,6 +36,7 @@ declare_clippy_lint! {
     ///     fn other() {}
     /// }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub MULTIPLE_INHERENT_IMPL,
     restriction,
     "Multiple inherent impl that could be grouped"
diff --git a/clippy_lints/src/inherent_to_string.rs b/clippy_lints/src/inherent_to_string.rs
index 61dd0eb4af7..60d234cd6f0 100644
--- a/clippy_lints/src/inherent_to_string.rs
+++ b/clippy_lints/src/inherent_to_string.rs
@@ -41,6 +41,7 @@ declare_clippy_lint! {
     ///     }
     /// }
     /// ```
+    #[clippy::version = "1.38.0"]
     pub INHERENT_TO_STRING,
     style,
     "type implements inherent method `to_string()`, but should instead implement the `Display` trait"
@@ -88,6 +89,7 @@ declare_clippy_lint! {
     ///     }
     /// }
     /// ```
+    #[clippy::version = "1.38.0"]
     pub INHERENT_TO_STRING_SHADOW_DISPLAY,
     correctness,
     "type implements inherent method `to_string()`, which gets shadowed by the implementation of the `Display` trait"
diff --git a/clippy_lints/src/inline_fn_without_body.rs b/clippy_lints/src/inline_fn_without_body.rs
index 3e3df903f17..df69d3dcc51 100644
--- a/clippy_lints/src/inline_fn_without_body.rs
+++ b/clippy_lints/src/inline_fn_without_body.rs
@@ -24,6 +24,7 @@ declare_clippy_lint! {
     ///     fn name(&self) -> &'static str;
     /// }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub INLINE_FN_WITHOUT_BODY,
     correctness,
     "use of `#[inline]` on trait methods without bodies"
diff --git a/clippy_lints/src/int_plus_one.rs b/clippy_lints/src/int_plus_one.rs
index 6850e0c3476..3716d36ad88 100644
--- a/clippy_lints/src/int_plus_one.rs
+++ b/clippy_lints/src/int_plus_one.rs
@@ -28,6 +28,7 @@ declare_clippy_lint! {
     /// # let y = 1;
     /// if x > y {}
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub INT_PLUS_ONE,
     complexity,
     "instead of using `x >= y + 1`, use `x > y`"
diff --git a/clippy_lints/src/integer_division.rs b/clippy_lints/src/integer_division.rs
index c962e814fa5..fa786205678 100644
--- a/clippy_lints/src/integer_division.rs
+++ b/clippy_lints/src/integer_division.rs
@@ -23,6 +23,7 @@ declare_clippy_lint! {
     /// let x = 3f32 / 2f32;
     /// println!("{}", x);
     /// ```
+    #[clippy::version = "1.37.0"]
     pub INTEGER_DIVISION,
     restriction,
     "integer division may cause loss of precision"
diff --git a/clippy_lints/src/invalid_upcast_comparisons.rs b/clippy_lints/src/invalid_upcast_comparisons.rs
index 82438d85c7a..36e03e50a8e 100644
--- a/clippy_lints/src/invalid_upcast_comparisons.rs
+++ b/clippy_lints/src/invalid_upcast_comparisons.rs
@@ -30,6 +30,7 @@ declare_clippy_lint! {
     /// let x: u8 = 1;
     /// (x as u32) > 300;
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub INVALID_UPCAST_COMPARISONS,
     pedantic,
     "a comparison involving an upcast which is always true or false"
diff --git a/clippy_lints/src/items_after_statements.rs b/clippy_lints/src/items_after_statements.rs
index 3736d237642..b118d3c8b87 100644
--- a/clippy_lints/src/items_after_statements.rs
+++ b/clippy_lints/src/items_after_statements.rs
@@ -45,6 +45,7 @@ declare_clippy_lint! {
     ///     foo(); // prints "foo"
     /// }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub ITEMS_AFTER_STATEMENTS,
     pedantic,
     "blocks where an item comes after a statement"
diff --git a/clippy_lints/src/iter_not_returning_iterator.rs b/clippy_lints/src/iter_not_returning_iterator.rs
index 6c779348ca2..968bbc524b2 100644
--- a/clippy_lints/src/iter_not_returning_iterator.rs
+++ b/clippy_lints/src/iter_not_returning_iterator.rs
@@ -32,6 +32,7 @@ declare_clippy_lint! {
     ///    }
     /// }
     /// ```
+    #[clippy::version = "1.57.0"]
     pub ITER_NOT_RETURNING_ITERATOR,
     pedantic,
     "methods named `iter` or `iter_mut` that do not return an `Iterator`"
diff --git a/clippy_lints/src/large_const_arrays.rs b/clippy_lints/src/large_const_arrays.rs
index fe6814e35d0..80260e4cd83 100644
--- a/clippy_lints/src/large_const_arrays.rs
+++ b/clippy_lints/src/large_const_arrays.rs
@@ -27,6 +27,7 @@ declare_clippy_lint! {
     /// // Good
     /// pub static a = [0u32; 1_000_000];
     /// ```
+    #[clippy::version = "1.44.0"]
     pub LARGE_CONST_ARRAYS,
     perf,
     "large non-scalar const array may cause performance overhead"
diff --git a/clippy_lints/src/large_enum_variant.rs b/clippy_lints/src/large_enum_variant.rs
index 392166237be..0191713f60d 100644
--- a/clippy_lints/src/large_enum_variant.rs
+++ b/clippy_lints/src/large_enum_variant.rs
@@ -40,6 +40,7 @@ declare_clippy_lint! {
     ///     B(Box<[i32; 8000]>),
     /// }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub LARGE_ENUM_VARIANT,
     perf,
     "large size difference between variants on an enum"
diff --git a/clippy_lints/src/large_stack_arrays.rs b/clippy_lints/src/large_stack_arrays.rs
index bbb6c1f902c..1cc2c28c04a 100644
--- a/clippy_lints/src/large_stack_arrays.rs
+++ b/clippy_lints/src/large_stack_arrays.rs
@@ -19,6 +19,7 @@ declare_clippy_lint! {
     /// ```rust,ignore
     /// let a = [0u32; 1_000_000];
     /// ```
+    #[clippy::version = "1.41.0"]
     pub LARGE_STACK_ARRAYS,
     pedantic,
     "allocating large arrays on stack may cause stack overflow"
diff --git a/clippy_lints/src/len_zero.rs b/clippy_lints/src/len_zero.rs
index f336fb9d42f..09cd0d22d8b 100644
--- a/clippy_lints/src/len_zero.rs
+++ b/clippy_lints/src/len_zero.rs
@@ -46,6 +46,7 @@ declare_clippy_lint! {
     ///     ..
     /// }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub LEN_ZERO,
     style,
     "checking `.len() == 0` or `.len() > 0` (or similar) when `.is_empty()` could be used instead"
@@ -71,6 +72,7 @@ declare_clippy_lint! {
     ///     }
     /// }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub LEN_WITHOUT_IS_EMPTY,
     style,
     "traits or impls with a public `len` method but no corresponding `is_empty` method"
@@ -108,6 +110,7 @@ declare_clippy_lint! {
     ///     ..
     /// }
     /// ```
+    #[clippy::version = "1.49.0"]
     pub COMPARISON_TO_EMPTY,
     style,
     "checking `x == \"\"` or `x == []` (or similar) when `.is_empty()` could be used instead"
diff --git a/clippy_lints/src/let_if_seq.rs b/clippy_lints/src/let_if_seq.rs
index 7f2c7b707f0..db09d00d730 100644
--- a/clippy_lints/src/let_if_seq.rs
+++ b/clippy_lints/src/let_if_seq.rs
@@ -48,6 +48,7 @@ declare_clippy_lint! {
     ///     None
     /// };
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub USELESS_LET_IF_SEQ,
     nursery,
     "unidiomatic `let mut` declaration followed by initialization in `if`"
diff --git a/clippy_lints/src/let_underscore.rs b/clippy_lints/src/let_underscore.rs
index 9efd7aba7e8..557051fb8d2 100644
--- a/clippy_lints/src/let_underscore.rs
+++ b/clippy_lints/src/let_underscore.rs
@@ -26,6 +26,7 @@ declare_clippy_lint! {
     /// // is_ok() is marked #[must_use]
     /// let _ = f().is_ok();
     /// ```
+    #[clippy::version = "1.42.0"]
     pub LET_UNDERSCORE_MUST_USE,
     restriction,
     "non-binding let on a `#[must_use]` expression"
@@ -53,6 +54,7 @@ declare_clippy_lint! {
     /// ```rust,ignore
     /// let _lock = mutex.lock();
     /// ```
+    #[clippy::version = "1.43.0"]
     pub LET_UNDERSCORE_LOCK,
     correctness,
     "non-binding let on a synchronization lock"
@@ -94,6 +96,7 @@ declare_clippy_lint! {
     ///     // dropped at end of scope
     /// }
     /// ```
+    #[clippy::version = "1.50.0"]
     pub LET_UNDERSCORE_DROP,
     pedantic,
     "non-binding let on a type that implements `Drop`"
diff --git a/clippy_lints/src/lifetimes.rs b/clippy_lints/src/lifetimes.rs
index 6565d5a6d70..fad3343d128 100644
--- a/clippy_lints/src/lifetimes.rs
+++ b/clippy_lints/src/lifetimes.rs
@@ -45,6 +45,7 @@ declare_clippy_lint! {
     ///     x
     /// }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub NEEDLESS_LIFETIMES,
     complexity,
     "using explicit lifetimes for references in function arguments when elision rules \
@@ -73,6 +74,7 @@ declare_clippy_lint! {
     ///     // ...
     /// }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub EXTRA_UNUSED_LIFETIMES,
     complexity,
     "unused lifetimes in function definitions"
diff --git a/clippy_lints/src/literal_representation.rs b/clippy_lints/src/literal_representation.rs
index 0e36ab085a3..130543bbbee 100644
--- a/clippy_lints/src/literal_representation.rs
+++ b/clippy_lints/src/literal_representation.rs
@@ -28,6 +28,7 @@ declare_clippy_lint! {
     /// // Good
     /// let x: u64 = 61_864_918_973_511;
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub UNREADABLE_LITERAL,
     pedantic,
     "long literal without underscores"
@@ -53,6 +54,7 @@ declare_clippy_lint! {
     /// // Good
     /// 2_i32;
     /// ```
+    #[clippy::version = "1.30.0"]
     pub MISTYPED_LITERAL_SUFFIXES,
     correctness,
     "mistyped literal suffix"
@@ -75,6 +77,7 @@ declare_clippy_lint! {
     /// // Good
     /// let x: u64 = 61_864_918_973_511;
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub INCONSISTENT_DIGIT_GROUPING,
     style,
     "integer literals with digits grouped inconsistently"
@@ -93,6 +96,7 @@ declare_clippy_lint! {
     /// let x: u32 = 0xFFF_FFF;
     /// let y: u8 = 0b01_011_101;
     /// ```
+    #[clippy::version = "1.49.0"]
     pub UNUSUAL_BYTE_GROUPINGS,
     style,
     "binary or hex literals that aren't grouped by four"
@@ -111,6 +115,7 @@ declare_clippy_lint! {
     /// ```rust
     /// let x: u64 = 6186491_8973511;
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub LARGE_DIGIT_GROUPS,
     pedantic,
     "grouping digits into groups that are too large"
@@ -128,6 +133,7 @@ declare_clippy_lint! {
     /// `255` => `0xFF`
     /// `65_535` => `0xFFFF`
     /// `4_042_322_160` => `0xF0F0_F0F0`
+    #[clippy::version = "pre 1.29.0"]
     pub DECIMAL_LITERAL_REPRESENTATION,
     restriction,
     "using decimal representation when hexadecimal would be better"
diff --git a/clippy_lints/src/loops/mod.rs b/clippy_lints/src/loops/mod.rs
index 5df1b796401..ccec648fa78 100644
--- a/clippy_lints/src/loops/mod.rs
+++ b/clippy_lints/src/loops/mod.rs
@@ -47,6 +47,7 @@ declare_clippy_lint! {
     /// # let mut dst = vec![0; 65];
     /// dst[64..(src.len() + 64)].clone_from_slice(&src[..]);
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub MANUAL_MEMCPY,
     perf,
     "manually copying items between slices"
@@ -75,6 +76,7 @@ declare_clippy_lint! {
     ///     println!("{}", i);
     /// }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub NEEDLESS_RANGE_LOOP,
     style,
     "for-looping over a range of indices where an iterator over items would do"
@@ -107,6 +109,7 @@ declare_clippy_lint! {
     ///     // ..
     /// }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub EXPLICIT_ITER_LOOP,
     pedantic,
     "for-looping over `_.iter()` or `_.iter_mut()` when `&_` or `&mut _` would do"
@@ -135,6 +138,7 @@ declare_clippy_lint! {
     ///     // ..
     /// }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub EXPLICIT_INTO_ITER_LOOP,
     pedantic,
     "for-looping over `_.into_iter()` when `_` would do"
@@ -158,6 +162,7 @@ declare_clippy_lint! {
     ///     ..
     /// }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub ITER_NEXT_LOOP,
     correctness,
     "for-looping over `_.next()` which is probably not intended"
@@ -201,6 +206,7 @@ declare_clippy_lint! {
     ///     // ..
     /// }
     /// ```
+    #[clippy::version = "1.45.0"]
     pub FOR_LOOPS_OVER_FALLIBLES,
     suspicious,
     "for-looping over an `Option` or a `Result`, which is more clearly expressed as an `if let`"
@@ -233,6 +239,7 @@ declare_clippy_lint! {
     ///     // .. do something with x
     /// };
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub WHILE_LET_LOOP,
     complexity,
     "`loop { if let { ... } else break }`, which can be written as a `while let` loop"
@@ -254,6 +261,7 @@ declare_clippy_lint! {
     /// // should be
     /// let len = iterator.count();
     /// ```
+    #[clippy::version = "1.30.0"]
     pub NEEDLESS_COLLECT,
     perf,
     "collecting an iterator when collect is not needed"
@@ -284,6 +292,7 @@ declare_clippy_lint! {
     /// # fn bar(bar: usize, baz: usize) {}
     /// for (i, item) in v.iter().enumerate() { bar(i, *item); }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub EXPLICIT_COUNTER_LOOP,
     complexity,
     "for-looping with an explicit counter when `_.enumerate()` would do"
@@ -317,6 +326,7 @@ declare_clippy_lint! {
     /// ```no_run
     /// loop {}
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub EMPTY_LOOP,
     suspicious,
     "empty `loop {}`, which should block or sleep"
@@ -336,6 +346,7 @@ declare_clippy_lint! {
     ///     ..
     /// }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub WHILE_LET_ON_ITERATOR,
     style,
     "using a `while let` loop instead of a for loop on an iterator"
@@ -364,6 +375,7 @@ declare_clippy_lint! {
     ///     ..
     /// }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub FOR_KV_MAP,
     style,
     "looping on a map using `iter` when `keys` or `values` would do"
@@ -385,6 +397,7 @@ declare_clippy_lint! {
     ///     break;
     /// }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub NEVER_LOOP,
     correctness,
     "any loop that will always `break` or `return`"
@@ -420,6 +433,7 @@ declare_clippy_lint! {
     ///     println!("{}", i); // prints numbers from 0 to 42, not 0 to 21
     /// }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub MUT_RANGE_BOUND,
     suspicious,
     "for loop over a range where one of the bounds is a mutable variable"
@@ -446,6 +460,7 @@ declare_clippy_lint! {
     ///     println!("let me loop forever!");
     /// }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub WHILE_IMMUTABLE_CONDITION,
     correctness,
     "variables used within while expression are not mutated in the body"
@@ -480,6 +495,7 @@ declare_clippy_lint! {
     /// let mut vec: Vec<u8> = vec![item1; 20];
     /// vec.resize(20 + 30, item2);
     /// ```
+    #[clippy::version = "1.47.0"]
     pub SAME_ITEM_PUSH,
     style,
     "the same item is pushed inside of a for loop"
@@ -506,6 +522,7 @@ declare_clippy_lint! {
     /// let item = &item1;
     /// println!("{}", item);
     /// ```
+    #[clippy::version = "1.49.0"]
     pub SINGLE_ELEMENT_LOOP,
     complexity,
     "there is no reason to have a single element loop"
@@ -537,6 +554,7 @@ declare_clippy_lint! {
     ///     println!("{}", n);
     /// }
     /// ```
+    #[clippy::version = "1.52.0"]
     pub MANUAL_FLATTEN,
     complexity,
     "for loops over `Option`s or `Result`s with a single expression can be simplified"
diff --git a/clippy_lints/src/macro_use.rs b/clippy_lints/src/macro_use.rs
index bccdc3be5e9..262a26951c6 100644
--- a/clippy_lints/src/macro_use.rs
+++ b/clippy_lints/src/macro_use.rs
@@ -24,6 +24,7 @@ declare_clippy_lint! {
     /// #[macro_use]
     /// use some_macro;
     /// ```
+    #[clippy::version = "1.44.0"]
     pub MACRO_USE_IMPORTS,
     pedantic,
     "#[macro_use] is no longer needed"
diff --git a/clippy_lints/src/main_recursion.rs b/clippy_lints/src/main_recursion.rs
index 23b3ba2296e..fad8fa467d4 100644
--- a/clippy_lints/src/main_recursion.rs
+++ b/clippy_lints/src/main_recursion.rs
@@ -20,6 +20,7 @@ declare_clippy_lint! {
     ///     main();
     /// }
     /// ```
+    #[clippy::version = "1.38.0"]
     pub MAIN_RECURSION,
     style,
     "recursion using the entrypoint"
diff --git a/clippy_lints/src/manual_assert.rs b/clippy_lints/src/manual_assert.rs
index e55aa3f1850..ed3166086f7 100644
--- a/clippy_lints/src/manual_assert.rs
+++ b/clippy_lints/src/manual_assert.rs
@@ -26,6 +26,7 @@ declare_clippy_lint! {
     /// let sad_people: Vec<&str> = vec![];
     /// assert!(sad_people.is_empty(), "there are sad people: {:?}", sad_people);
     /// ```
+    #[clippy::version = "1.57.0"]
     pub MANUAL_ASSERT,
     pedantic,
     "`panic!` and only a `panic!` in `if`-then statement"
diff --git a/clippy_lints/src/manual_async_fn.rs b/clippy_lints/src/manual_async_fn.rs
index b632af455f8..86819752f90 100644
--- a/clippy_lints/src/manual_async_fn.rs
+++ b/clippy_lints/src/manual_async_fn.rs
@@ -30,6 +30,7 @@ declare_clippy_lint! {
     /// ```rust
     /// async fn foo() -> i32 { 42 }
     /// ```
+    #[clippy::version = "1.45.0"]
     pub MANUAL_ASYNC_FN,
     style,
     "manual implementations of `async` functions can be simplified using the dedicated syntax"
diff --git a/clippy_lints/src/manual_map.rs b/clippy_lints/src/manual_map.rs
index 96df3d0a490..cf5dabd9462 100644
--- a/clippy_lints/src/manual_map.rs
+++ b/clippy_lints/src/manual_map.rs
@@ -36,6 +36,7 @@ declare_clippy_lint! {
     /// ```rust
     /// Some(0).map(|x| x + 1);
     /// ```
+    #[clippy::version = "1.52.0"]
     pub MANUAL_MAP,
     style,
     "reimplementation of `map`"
diff --git a/clippy_lints/src/manual_non_exhaustive.rs b/clippy_lints/src/manual_non_exhaustive.rs
index 335ea001ee4..63a72d4fdde 100644
--- a/clippy_lints/src/manual_non_exhaustive.rs
+++ b/clippy_lints/src/manual_non_exhaustive.rs
@@ -52,6 +52,7 @@ declare_clippy_lint! {
     /// #[non_exhaustive]
     /// struct T(pub i32, pub i32);
     /// ```
+    #[clippy::version = "1.45.0"]
     pub MANUAL_NON_EXHAUSTIVE,
     style,
     "manual implementations of the non-exhaustive pattern can be simplified using #[non_exhaustive]"
diff --git a/clippy_lints/src/manual_ok_or.rs b/clippy_lints/src/manual_ok_or.rs
index cf641d0ce86..b60e2dc366b 100644
--- a/clippy_lints/src/manual_ok_or.rs
+++ b/clippy_lints/src/manual_ok_or.rs
@@ -32,6 +32,7 @@ declare_clippy_lint! {
     /// let foo: Option<i32> = None;
     /// foo.ok_or("error");
     /// ```
+    #[clippy::version = "1.49.0"]
     pub MANUAL_OK_OR,
     pedantic,
     "finds patterns that can be encoded more concisely with `Option::ok_or`"
diff --git a/clippy_lints/src/manual_strip.rs b/clippy_lints/src/manual_strip.rs
index 4e040508b6b..f8e28f1671f 100644
--- a/clippy_lints/src/manual_strip.rs
+++ b/clippy_lints/src/manual_strip.rs
@@ -42,6 +42,7 @@ declare_clippy_lint! {
     ///     assert_eq!(end.to_uppercase(), "WORLD!");
     /// }
     /// ```
+    #[clippy::version = "1.48.0"]
     pub MANUAL_STRIP,
     complexity,
     "suggests using `strip_{prefix,suffix}` over `str::{starts,ends}_with` and slicing"
diff --git a/clippy_lints/src/manual_unwrap_or.rs b/clippy_lints/src/manual_unwrap_or.rs
index 42478e3416e..aac3c6e0de2 100644
--- a/clippy_lints/src/manual_unwrap_or.rs
+++ b/clippy_lints/src/manual_unwrap_or.rs
@@ -35,6 +35,7 @@ declare_clippy_lint! {
     /// let foo: Option<i32> = None;
     /// foo.unwrap_or(1);
     /// ```
+    #[clippy::version = "1.49.0"]
     pub MANUAL_UNWRAP_OR,
     complexity,
     "finds patterns that can be encoded more concisely with `Option::unwrap_or` or `Result::unwrap_or`"
diff --git a/clippy_lints/src/map_clone.rs b/clippy_lints/src/map_clone.rs
index 7db5c7e52ea..c2b78e21861 100644
--- a/clippy_lints/src/map_clone.rs
+++ b/clippy_lints/src/map_clone.rs
@@ -37,6 +37,7 @@ declare_clippy_lint! {
     /// let y = x.iter();
     /// let z = y.cloned();
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub MAP_CLONE,
     style,
     "using `iterator.map(|x| x.clone())`, or dereferencing closures for `Copy` types"
diff --git a/clippy_lints/src/map_err_ignore.rs b/clippy_lints/src/map_err_ignore.rs
index 82d3732326e..61f21d532c5 100644
--- a/clippy_lints/src/map_err_ignore.rs
+++ b/clippy_lints/src/map_err_ignore.rs
@@ -97,6 +97,7 @@ declare_clippy_lint! {
     ///         })
     /// }
     /// ```
+    #[clippy::version = "1.48.0"]
     pub MAP_ERR_IGNORE,
     restriction,
     "`map_err` should not ignore the original error"
diff --git a/clippy_lints/src/map_unit_fn.rs b/clippy_lints/src/map_unit_fn.rs
index 40de9ffcd4e..a84de3e079b 100644
--- a/clippy_lints/src/map_unit_fn.rs
+++ b/clippy_lints/src/map_unit_fn.rs
@@ -47,6 +47,7 @@ declare_clippy_lint! {
     ///     log_err_msg(format_msg(msg));
     /// }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub OPTION_MAP_UNIT_FN,
     complexity,
     "using `option.map(f)`, where `f` is a function or closure that returns `()`"
@@ -87,6 +88,7 @@ declare_clippy_lint! {
     ///     log_err_msg(format_msg(msg));
     /// };
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub RESULT_MAP_UNIT_FN,
     complexity,
     "using `result.map(f)`, where `f` is a function or closure that returns `()`"
diff --git a/clippy_lints/src/match_on_vec_items.rs b/clippy_lints/src/match_on_vec_items.rs
index 552c9a58897..583b577ffe2 100644
--- a/clippy_lints/src/match_on_vec_items.rs
+++ b/clippy_lints/src/match_on_vec_items.rs
@@ -40,6 +40,7 @@ declare_clippy_lint! {
     ///     _ => {},
     /// }
     /// ```
+    #[clippy::version = "1.45.0"]
     pub MATCH_ON_VEC_ITEMS,
     pedantic,
     "matching on vector elements can panic"
diff --git a/clippy_lints/src/match_result_ok.rs b/clippy_lints/src/match_result_ok.rs
index ecf6ad316a4..b1839f00aae 100644
--- a/clippy_lints/src/match_result_ok.rs
+++ b/clippy_lints/src/match_result_ok.rs
@@ -38,6 +38,7 @@ declare_clippy_lint! {
     ///        vec.push(value)
     /// }
     /// ```
+    #[clippy::version = "1.57.0"]
     pub MATCH_RESULT_OK,
     style,
     "usage of `ok()` in `let Some(pat)` statements is unnecessary, match on `Ok(pat)` instead"
diff --git a/clippy_lints/src/match_str_case_mismatch.rs b/clippy_lints/src/match_str_case_mismatch.rs
index f501593c518..3316ebf4051 100644
--- a/clippy_lints/src/match_str_case_mismatch.rs
+++ b/clippy_lints/src/match_str_case_mismatch.rs
@@ -39,6 +39,7 @@ declare_clippy_lint! {
     ///     _ => {},
     /// }
     /// ```
+    #[clippy::version = "1.58.0"]
     pub MATCH_STR_CASE_MISMATCH,
     correctness,
     "creation of a case altering match expression with non-compliant arms"
diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index e4e533fa71a..74765a1a1de 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -57,6 +57,7 @@ declare_clippy_lint! {
     ///     bar(foo);
     /// }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub SINGLE_MATCH,
     style,
     "a `match` statement with a single nontrivial arm (i.e., where the other arm is `_ => {}`) instead of `if let`"
@@ -98,6 +99,7 @@ declare_clippy_lint! {
     ///     bar(&other_ref);
     /// }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub SINGLE_MATCH_ELSE,
     pedantic,
     "a `match` statement with two arms where the second arm's pattern is a placeholder instead of a specific match pattern"
@@ -129,6 +131,7 @@ declare_clippy_lint! {
     ///     _ => frob(x),
     /// }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub MATCH_REF_PATS,
     style,
     "a `match` or `if let` with all arms prefixed with `&` instead of deref-ing the match expression"
@@ -163,6 +166,7 @@ declare_clippy_lint! {
     ///     bar();
     /// }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub MATCH_BOOL,
     pedantic,
     "a `match` on a boolean expression instead of an `if..else` block"
@@ -185,6 +189,7 @@ declare_clippy_lint! {
     ///     _ => (),
     /// }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub MATCH_OVERLAPPING_ARM,
     style,
     "a `match` with overlapping arms"
@@ -207,6 +212,7 @@ declare_clippy_lint! {
     ///     Err(_) => panic!("err"),
     /// }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub MATCH_WILD_ERR_ARM,
     pedantic,
     "a `match` with `Err(_)` arm and take drastic actions"
@@ -233,6 +239,7 @@ declare_clippy_lint! {
     /// // Good
     /// let r: Option<&()> = x.as_ref();
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub MATCH_AS_REF,
     complexity,
     "a `match` on an Option value instead of using `as_ref()` or `as_mut`"
@@ -265,6 +272,7 @@ declare_clippy_lint! {
     ///     Foo::B(_) => {},
     /// }
     /// ```
+    #[clippy::version = "1.34.0"]
     pub WILDCARD_ENUM_MATCH_ARM,
     restriction,
     "a wildcard enum match arm using `_`"
@@ -299,6 +307,7 @@ declare_clippy_lint! {
     ///     Foo::C => {},
     /// }
     /// ```
+    #[clippy::version = "1.45.0"]
     pub MATCH_WILDCARD_FOR_SINGLE_VARIANTS,
     pedantic,
     "a wildcard enum match for a single variant"
@@ -326,6 +335,7 @@ declare_clippy_lint! {
     ///     _ => {},
     /// }
     /// ```
+    #[clippy::version = "1.42.0"]
     pub WILDCARD_IN_OR_PATTERNS,
     complexity,
     "a wildcard pattern used with others patterns in same match arm"
@@ -361,6 +371,7 @@ declare_clippy_lint! {
     /// let wrapper = Wrapper::Data(42);
     /// let Wrapper::Data(data) = wrapper;
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub INFALLIBLE_DESTRUCTURING_MATCH,
     style,
     "a `match` statement with a single infallible arm instead of a `let`"
@@ -392,6 +403,7 @@ declare_clippy_lint! {
     /// // Good
     /// let (c, d) = (a, b);
     /// ```
+    #[clippy::version = "1.43.0"]
     pub MATCH_SINGLE_BINDING,
     complexity,
     "a match with a single binding instead of using `let` statement"
@@ -422,6 +434,7 @@ declare_clippy_lint! {
     ///     _ => {},
     /// }
     /// ```
+    #[clippy::version = "1.43.0"]
     pub REST_PAT_IN_FULLY_BOUND_STRUCTS,
     restriction,
     "a match on a struct that binds all fields but still uses the wildcard pattern"
@@ -477,6 +490,7 @@ declare_clippy_lint! {
     /// if IpAddr::V6(Ipv6Addr::LOCALHOST).is_ipv6() {}
     /// Ok::<i32, i32>(42).is_ok();
     /// ```
+    #[clippy::version = "1.31.0"]
     pub REDUNDANT_PATTERN_MATCHING,
     style,
     "use the proper utility function avoiding an `if let`"
@@ -513,6 +527,7 @@ declare_clippy_lint! {
     /// // Good
     /// let a = matches!(x, Some(0));
     /// ```
+    #[clippy::version = "1.47.0"]
     pub MATCH_LIKE_MATCHES_MACRO,
     style,
     "a match that could be written with the matches! macro"
@@ -557,6 +572,7 @@ declare_clippy_lint! {
     ///     Quz => quz(),
     /// }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub MATCH_SAME_ARMS,
     pedantic,
     "`match` with identical arm bodies"
diff --git a/clippy_lints/src/mem_forget.rs b/clippy_lints/src/mem_forget.rs
index eb437dc47af..5ffcfd4d264 100644
--- a/clippy_lints/src/mem_forget.rs
+++ b/clippy_lints/src/mem_forget.rs
@@ -19,6 +19,7 @@ declare_clippy_lint! {
     /// # use std::rc::Rc;
     /// mem::forget(Rc::new(55))
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub MEM_FORGET,
     restriction,
     "`mem::forget` usage on `Drop` types, likely to cause memory leaks"
diff --git a/clippy_lints/src/mem_replace.rs b/clippy_lints/src/mem_replace.rs
index cf721fc65db..7fc39f17232 100644
--- a/clippy_lints/src/mem_replace.rs
+++ b/clippy_lints/src/mem_replace.rs
@@ -35,6 +35,7 @@ declare_clippy_lint! {
     /// let mut an_option = Some(0);
     /// let taken = an_option.take();
     /// ```
+    #[clippy::version = "1.31.0"]
     pub MEM_REPLACE_OPTION_WITH_NONE,
     style,
     "replacing an `Option` with `None` instead of `take()`"
@@ -66,6 +67,7 @@ declare_clippy_lint! {
     /// The [take_mut](https://docs.rs/take_mut) crate offers a sound solution,
     /// at the cost of either lazily creating a replacement value or aborting
     /// on panic, to ensure that the uninitialized value cannot be observed.
+    #[clippy::version = "1.39.0"]
     pub MEM_REPLACE_WITH_UNINIT,
     correctness,
     "`mem::replace(&mut _, mem::uninitialized())` or `mem::replace(&mut _, mem::zeroed())`"
@@ -90,6 +92,7 @@ declare_clippy_lint! {
     /// let mut text = String::from("foo");
     /// let taken = std::mem::take(&mut text);
     /// ```
+    #[clippy::version = "1.42.0"]
     pub MEM_REPLACE_WITH_DEFAULT,
     style,
     "replacing a value of type `T` with `T::default()` instead of using `std::mem::take`"
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 6c4272f9e65..5cb849a56bc 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -99,6 +99,7 @@ declare_clippy_lint! {
     /// ```rust
     /// [1, 2, 3].iter().copied();
     /// ```
+    #[clippy::version = "1.53.0"]
     pub CLONED_INSTEAD_OF_COPIED,
     pedantic,
     "used `cloned` where `copied` could be used instead"
@@ -121,6 +122,7 @@ declare_clippy_lint! {
     /// ```rust
     /// let nums: Vec<i32> = ["1", "2", "whee!"].iter().filter_map(|x| x.parse().ok()).collect();
     /// ```
+    #[clippy::version = "1.53.0"]
     pub FLAT_MAP_OPTION,
     pedantic,
     "used `flat_map` where `filter_map` could be used instead"
@@ -166,6 +168,7 @@ declare_clippy_lint! {
     /// // Good
     /// res.expect("more helpful message");
     /// ```
+    #[clippy::version = "1.45.0"]
     pub UNWRAP_USED,
     restriction,
     "using `.unwrap()` on `Result` or `Option`, which should at least get a better message using `expect()`"
@@ -208,6 +211,7 @@ declare_clippy_lint! {
     /// res?;
     /// # Ok::<(), ()>(())
     /// ```
+    #[clippy::version = "1.45.0"]
     pub EXPECT_USED,
     restriction,
     "using `.expect()` on `Result` or `Option`, which might be better handled"
@@ -237,6 +241,7 @@ declare_clippy_lint! {
     ///     }
     /// }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub SHOULD_IMPLEMENT_TRAIT,
     style,
     "defining a method that should be implementing a std trait"
@@ -284,6 +289,7 @@ declare_clippy_lint! {
     ///     }
     /// }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub WRONG_SELF_CONVENTION,
     style,
     "defining a method named with an established prefix (like \"into_\") that takes `self` with the wrong convention"
@@ -310,6 +316,7 @@ declare_clippy_lint! {
     /// // Good
     /// x.expect("why did I do this again?");
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub OK_EXPECT,
     style,
     "using `ok().expect()`, which gives worse error messages than calling `expect` directly on the Result"
@@ -335,6 +342,7 @@ declare_clippy_lint! {
     /// // Good
     /// x.unwrap_or_default();
     /// ```
+    #[clippy::version = "1.56.0"]
     pub UNWRAP_OR_ELSE_DEFAULT,
     style,
     "using `.unwrap_or_else(Default::default)`, which is more succinctly expressed as `.unwrap_or_default()`"
@@ -375,6 +383,7 @@ declare_clippy_lint! {
     /// // Good
     /// x.map_or_else(some_function, |a| a + 1);
     /// ```
+    #[clippy::version = "1.45.0"]
     pub MAP_UNWRAP_OR,
     pedantic,
     "using `.map(f).unwrap_or(a)` or `.map(f).unwrap_or_else(func)`, which are more succinctly expressed as `map_or(a, f)` or `map_or_else(a, f)`"
@@ -401,6 +410,7 @@ declare_clippy_lint! {
     /// // Good
     /// opt.and_then(|a| Some(a + 1));
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub OPTION_MAP_OR_NONE,
     style,
     "using `Option.map_or(None, f)`, which is more succinctly expressed as `and_then(f)`"
@@ -426,6 +436,7 @@ declare_clippy_lint! {
     /// # let r: Result<u32, &str> = Ok(1);
     /// assert_eq!(Some(1), r.ok());
     /// ```
+    #[clippy::version = "1.44.0"]
     pub RESULT_MAP_OR_INTO_OPTION,
     style,
     "using `Result.map_or(None, Some)`, which is more succinctly expressed as `ok()`"
@@ -458,6 +469,7 @@ declare_clippy_lint! {
     /// let _ = res().map(|s| if s.len() == 42 { 10 } else { 20 });
     /// let _ = res().map_err(|s| if s.len() == 42 { 10 } else { 20 });
     /// ```
+    #[clippy::version = "1.45.0"]
     pub BIND_INSTEAD_OF_MAP,
     complexity,
     "using `Option.and_then(|x| Some(y))`, which is more succinctly expressed as `map(|x| y)`"
@@ -481,6 +493,7 @@ declare_clippy_lint! {
     /// # let vec = vec![1];
     /// vec.iter().find(|x| **x == 0);
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub FILTER_NEXT,
     complexity,
     "using `filter(p).next()`, which is more succinctly expressed as `.find(p)`"
@@ -504,6 +517,7 @@ declare_clippy_lint! {
     /// # let vec = vec![1];
     /// vec.iter().find(|x| **x != 0);
     /// ```
+    #[clippy::version = "1.42.0"]
     pub SKIP_WHILE_NEXT,
     complexity,
     "using `skip_while(p).next()`, which is more succinctly expressed as `.find(!p)`"
@@ -527,6 +541,7 @@ declare_clippy_lint! {
     /// // Good
     /// vec.iter().flat_map(|x| x.iter());
     /// ```
+    #[clippy::version = "1.31.0"]
     pub MAP_FLATTEN,
     pedantic,
     "using combinations of `flatten` and `map` which can usually be written as a single method call"
@@ -553,6 +568,7 @@ declare_clippy_lint! {
     /// ```rust
     /// (0_i32..10).filter_map(|n| n.checked_add(1));
     /// ```
+    #[clippy::version = "1.51.0"]
     pub MANUAL_FILTER_MAP,
     complexity,
     "using `_.filter(_).map(_)` in a way that can be written more simply as `filter_map(_)`"
@@ -579,6 +595,7 @@ declare_clippy_lint! {
     /// ```rust
     /// (0_i32..10).find_map(|n| n.checked_add(1));
     /// ```
+    #[clippy::version = "1.51.0"]
     pub MANUAL_FIND_MAP,
     complexity,
     "using `_.find(_).map(_)` in a way that can be written more simply as `find_map(_)`"
@@ -601,6 +618,7 @@ declare_clippy_lint! {
     /// ```rust
     ///  (0..3).find_map(|x| if x == 2 { Some(x) } else { None });
     /// ```
+    #[clippy::version = "1.36.0"]
     pub FILTER_MAP_NEXT,
     pedantic,
     "using combination of `filter_map` and `next` which can usually be written as a single method call"
@@ -623,6 +641,7 @@ declare_clippy_lint! {
     /// # let iter = vec![vec![0]].into_iter();
     /// iter.flatten();
     /// ```
+    #[clippy::version = "1.39.0"]
     pub FLAT_MAP_IDENTITY,
     complexity,
     "call to `flat_map` where `flatten` is sufficient"
@@ -652,6 +671,7 @@ declare_clippy_lint! {
     ///
     /// let _ = !"hello world".contains("world");
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub SEARCH_IS_SOME,
     complexity,
     "using an iterator or string search followed by `is_some()` or `is_none()`, which is more succinctly expressed as a call to `any()` or `contains()` (with negation in case of `is_none()`)"
@@ -676,6 +696,7 @@ declare_clippy_lint! {
     /// let name = "foo";
     /// if name.starts_with('_') {};
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub CHARS_NEXT_CMP,
     style,
     "using `.chars().next()` to check if a string starts with a char"
@@ -710,6 +731,7 @@ declare_clippy_lint! {
     /// # let foo = Some(String::new());
     /// foo.unwrap_or_default();
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub OR_FUN_CALL,
     perf,
     "using any `*or` method with a function call, which suggests `*or_else`"
@@ -748,6 +770,7 @@ declare_clippy_lint! {
     /// # let err_msg = "I'm a teapot";
     /// foo.unwrap_or_else(|| panic!("Err {}: {}", err_code, err_msg));
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub EXPECT_FUN_CALL,
     perf,
     "using any `expect` method with a function call"
@@ -765,6 +788,7 @@ declare_clippy_lint! {
     /// ```rust
     /// 42u64.clone();
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub CLONE_ON_COPY,
     complexity,
     "using `clone` on a `Copy` type"
@@ -792,6 +816,7 @@ declare_clippy_lint! {
     /// // Good
     /// Rc::clone(&x);
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub CLONE_ON_REF_PTR,
     restriction,
     "using 'clone' on a ref-counted pointer"
@@ -814,6 +839,7 @@ declare_clippy_lint! {
     ///     println!("{:p} {:p}", *y, z); // prints out the same pointer
     /// }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub CLONE_DOUBLE_REF,
     correctness,
     "using `clone` on `&&T`"
@@ -837,6 +863,7 @@ declare_clippy_lint! {
     /// // OK, the specialized impl is used
     /// ["foo", "bar"].iter().map(|&s| s.to_string());
     /// ```
+    #[clippy::version = "1.40.0"]
     pub INEFFICIENT_TO_STRING,
     pedantic,
     "using `to_string` on `&&T` where `T: ToString`"
@@ -898,6 +925,7 @@ declare_clippy_lint! {
     ///     fn new() -> Self;
     /// }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub NEW_RET_NO_SELF,
     style,
     "not returning type containing `Self` in a `new` method"
@@ -922,6 +950,7 @@ declare_clippy_lint! {
     ///
     /// // Good
     /// _.split('x');
+    #[clippy::version = "pre 1.29.0"]
     pub SINGLE_CHAR_PATTERN,
     perf,
     "using a single-character str where a char could be used, e.g., `_.split(\"x\")`"
@@ -941,6 +970,7 @@ declare_clippy_lint! {
     ///     //..
     /// }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub ITERATOR_STEP_BY_ZERO,
     correctness,
     "using `Iterator::step_by(0)`, which will panic at runtime"
@@ -962,6 +992,7 @@ declare_clippy_lint! {
     /// ```rust
     /// let _ = std::iter::empty::<Option<i32>>().flatten();
     /// ```
+    #[clippy::version = "1.53.0"]
     pub OPTION_FILTER_MAP,
     complexity,
     "filtering `Option` for `Some` then force-unwrapping, which can be one type-safe operation"
@@ -989,6 +1020,7 @@ declare_clippy_lint! {
     /// # s.insert(1);
     /// let x = s.iter().next();
     /// ```
+    #[clippy::version = "1.42.0"]
     pub ITER_NTH_ZERO,
     style,
     "replace `iter.nth(0)` with `iter.next()`"
@@ -1015,6 +1047,7 @@ declare_clippy_lint! {
     /// let bad_vec = some_vec.get(3);
     /// let bad_slice = &some_vec[..].get(3);
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub ITER_NTH,
     perf,
     "using `.iter().nth()` on a standard library type with O(1) element access"
@@ -1039,6 +1072,7 @@ declare_clippy_lint! {
     /// let bad_vec = some_vec.iter().nth(3);
     /// let bad_slice = &some_vec[..].iter().nth(3);
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub ITER_SKIP_NEXT,
     style,
     "using `.skip(x).next()` on an iterator"
@@ -1075,6 +1109,7 @@ declare_clippy_lint! {
     /// let last = some_vec[3];
     /// some_vec[0] = 1;
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub GET_UNWRAP,
     restriction,
     "using `.get().unwrap()` or `.get_mut().unwrap()` when using `[]` would work instead"
@@ -1098,6 +1133,7 @@ declare_clippy_lint! {
     /// // Good
     /// a.append(&mut b);
     /// ```
+    #[clippy::version = "1.55.0"]
     pub EXTEND_WITH_DRAIN,
     perf,
     "using vec.append(&mut vec) to move the full range of a vecor to another"
@@ -1127,6 +1163,7 @@ declare_clippy_lint! {
     /// s.push_str(abc);
     /// s.push_str(&def);
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub STRING_EXTEND_CHARS,
     style,
     "using `x.extend(s.chars())` where s is a `&str` or `String`"
@@ -1150,6 +1187,7 @@ declare_clippy_lint! {
     /// let s = [1, 2, 3, 4, 5];
     /// let s2: Vec<isize> = s.to_vec();
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub ITER_CLONED_COLLECT,
     style,
     "using `.cloned().collect()` on slice to create a `Vec`"
@@ -1174,6 +1212,7 @@ declare_clippy_lint! {
     /// // Good
     /// name.ends_with('_') || name.ends_with('-');
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub CHARS_LAST_CMP,
     style,
     "using `.chars().last()` or `.chars().next_back()` to check if a string ends with a char"
@@ -1199,6 +1238,7 @@ declare_clippy_lint! {
     /// let x: &[i32] = &[1, 2, 3, 4, 5];
     /// do_stuff(x);
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub USELESS_ASREF,
     complexity,
     "using `as_ref` where the types before and after the call are the same"
@@ -1221,6 +1261,7 @@ declare_clippy_lint! {
     /// ```rust
     /// let _ = (0..3).any(|x| x > 2);
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub UNNECESSARY_FOLD,
     style,
     "using `fold` when a more succinct alternative exists"
@@ -1250,6 +1291,7 @@ declare_clippy_lint! {
     /// // As there is no conditional check on the argument this could be written as:
     /// let _ = (0..4).map(|x| x + 1);
     /// ```
+    #[clippy::version = "1.31.0"]
     pub UNNECESSARY_FILTER_MAP,
     complexity,
     "using `filter_map` when a more succinct alternative exists"
@@ -1273,6 +1315,7 @@ declare_clippy_lint! {
     /// // Good
     /// let _ = (&vec![3, 4, 5]).iter();
     /// ```
+    #[clippy::version = "1.32.0"]
     pub INTO_ITER_ON_REF,
     style,
     "using `.into_iter()` on a reference"
@@ -1292,6 +1335,7 @@ declare_clippy_lint! {
     /// ```rust
     /// let _ = (0..3).map(|x| x + 2).count();
     /// ```
+    #[clippy::version = "1.39.0"]
     pub SUSPICIOUS_MAP,
     suspicious,
     "suspicious usage of map"
@@ -1326,6 +1370,7 @@ declare_clippy_lint! {
     ///     MaybeUninit::uninit().assume_init()
     /// };
     /// ```
+    #[clippy::version = "1.39.0"]
     pub UNINIT_ASSUMED_INIT,
     correctness,
     "`MaybeUninit::uninit().assume_init()`"
@@ -1354,6 +1399,7 @@ declare_clippy_lint! {
     /// let add = x.saturating_add(y);
     /// let sub = x.saturating_sub(y);
     /// ```
+    #[clippy::version = "1.39.0"]
     pub MANUAL_SATURATING_ARITHMETIC,
     style,
     "`.chcked_add/sub(x).unwrap_or(MAX/MIN)`"
@@ -1371,6 +1417,7 @@ declare_clippy_lint! {
     /// ```rust
     /// unsafe { (&() as *const ()).offset(1) };
     /// ```
+    #[clippy::version = "1.41.0"]
     pub ZST_OFFSET,
     correctness,
     "Check for offset calculations on raw pointers to zero-sized types"
@@ -1412,6 +1459,7 @@ declare_clippy_lint! {
     /// # Ok::<_, std::io::Error>(())
     /// # };
     /// ```
+    #[clippy::version = "1.42.0"]
     pub FILETYPE_IS_FILE,
     restriction,
     "`FileType::is_file` is not recommended to test for readable file type"
@@ -1437,6 +1485,7 @@ declare_clippy_lint! {
     /// opt.as_deref()
     /// # ;
     /// ```
+    #[clippy::version = "1.42.0"]
     pub OPTION_AS_REF_DEREF,
     complexity,
     "using `as_ref().map(Deref::deref)`, which is more succinctly expressed as `as_deref()`"
@@ -1463,6 +1512,7 @@ declare_clippy_lint! {
     /// a.get(2);
     /// b.get(0);
     /// ```
+    #[clippy::version = "1.46.0"]
     pub ITER_NEXT_SLICE,
     style,
     "using `.iter().next()` on a sliced array, which can be shortened to just `.get()`"
@@ -1488,6 +1538,7 @@ declare_clippy_lint! {
     /// string.insert(0, 'R');
     /// string.push('R');
     /// ```
+    #[clippy::version = "1.49.0"]
     pub SINGLE_CHAR_ADD_STR,
     style,
     "`push_str()` or `insert_str()` used with a single-character string literal as parameter"
@@ -1526,6 +1577,7 @@ declare_clippy_lint! {
     ///
     /// opt.unwrap_or(42);
     /// ```
+    #[clippy::version = "1.48.0"]
     pub UNNECESSARY_LAZY_EVALUATIONS,
     style,
     "using unnecessary lazy evaluation, which can be replaced with simpler eager evaluation"
@@ -1546,6 +1598,7 @@ declare_clippy_lint! {
     /// ```rust
     /// (0..3).try_for_each(|t| Err(t));
     /// ```
+    #[clippy::version = "1.49.0"]
     pub MAP_COLLECT_RESULT_UNIT,
     style,
     "using `.map(_).collect::<Result<(),_>()`, which can be replaced with `try_for_each`"
@@ -1578,6 +1631,7 @@ declare_clippy_lint! {
     ///
     /// assert_eq!(v, vec![5, 5, 5, 5, 5]);
     /// ```
+    #[clippy::version = "1.49.0"]
     pub FROM_ITER_INSTEAD_OF_COLLECT,
     pedantic,
     "use `.collect()` instead of `::from_iter()`"
@@ -1607,6 +1661,7 @@ declare_clippy_lint! {
     ///     assert!(x >= 0);
     /// });
     /// ```
+    #[clippy::version = "1.51.0"]
     pub INSPECT_FOR_EACH,
     complexity,
     "using `.inspect().for_each()`, which can be replaced with `.for_each()`"
@@ -1629,6 +1684,7 @@ declare_clippy_lint! {
     /// # let iter = vec![Some(1)].into_iter();
     /// iter.flatten();
     /// ```
+    #[clippy::version = "1.52.0"]
     pub FILTER_MAP_IDENTITY,
     complexity,
     "call to `filter_map` where `flatten` is sufficient"
@@ -1651,6 +1707,7 @@ declare_clippy_lint! {
     /// let x = [1, 2, 3];
     /// let y: Vec<_> = x.iter().map(|x| 2*x).collect();
     /// ```
+    #[clippy::version = "1.52.0"]
     pub MAP_IDENTITY,
     complexity,
     "using iterator.map(|x| x)"
@@ -1672,6 +1729,7 @@ declare_clippy_lint! {
     /// // Good
     /// let _ = "Hello".as_bytes().get(3);
     /// ```
+    #[clippy::version = "1.52.0"]
     pub BYTES_NTH,
     style,
     "replace `.bytes().nth()` with `.as_bytes().get()`"
@@ -1697,6 +1755,7 @@ declare_clippy_lint! {
     /// let b = a.clone();
     /// let c = a.clone();
     /// ```
+    #[clippy::version = "1.52.0"]
     pub IMPLICIT_CLONE,
     pedantic,
     "implicitly cloning a value by invoking a function on its dereferenced type"
@@ -1722,6 +1781,7 @@ declare_clippy_lint! {
     /// let _ = some_vec.len();
     /// let _ = &some_vec[..].len();
     /// ```
+    #[clippy::version = "1.52.0"]
     pub ITER_COUNT,
     complexity,
     "replace `.iter().count()` with `.len()`"
@@ -1751,6 +1811,7 @@ declare_clippy_lint! {
     ///     // use x
     /// }
     /// ```
+    #[clippy::version = "1.54.0"]
     pub SUSPICIOUS_SPLITN,
     correctness,
     "checks for `.splitn(0, ..)` and `.splitn(1, ..)`"
@@ -1771,6 +1832,7 @@ declare_clippy_lint! {
     /// // Good
     /// let x: String = "x".repeat(10);
     /// ```
+    #[clippy::version = "1.54.0"]
     pub MANUAL_STR_REPEAT,
     perf,
     "manual implementation of `str::repeat`"
@@ -1793,6 +1855,7 @@ declare_clippy_lint! {
     /// let (key, value) = _.split_once('=')?;
     /// let value = _.split_once('=')?.1;
     /// ```
+    #[clippy::version = "1.57.0"]
     pub MANUAL_SPLIT_ONCE,
     complexity,
     "replace `.splitn(2, pat)` with `.split_once(pat)`"
diff --git a/clippy_lints/src/minmax.rs b/clippy_lints/src/minmax.rs
index dc2dd45e4ed..a6450aec4f7 100644
--- a/clippy_lints/src/minmax.rs
+++ b/clippy_lints/src/minmax.rs
@@ -26,6 +26,7 @@ declare_clippy_lint! {
     /// ```
     /// It will always be equal to `0`. Probably the author meant to clamp the value
     /// between 0 and 100, but has erroneously swapped `min` and `max`.
+    #[clippy::version = "pre 1.29.0"]
     pub MIN_MAX,
     correctness,
     "`min(_, max(_, _))` (or vice versa) with bounds clamping the result to a constant"
diff --git a/clippy_lints/src/misc.rs b/clippy_lints/src/misc.rs
index 0f32cd9164e..a93537104bf 100644
--- a/clippy_lints/src/misc.rs
+++ b/clippy_lints/src/misc.rs
@@ -56,6 +56,7 @@ declare_clippy_lint! {
     ///     true
     /// }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub TOPLEVEL_REF_ARG,
     style,
     "an entire binding declared as `ref`, in a function argument or a `let` statement"
@@ -79,6 +80,7 @@ declare_clippy_lint! {
     /// // Good
     /// if x.is_nan() { }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub CMP_NAN,
     correctness,
     "comparisons to `NAN`, which will always return false, probably not intended"
@@ -112,6 +114,7 @@ declare_clippy_lint! {
     /// if (y - 1.23f64).abs() < error_margin { }
     /// if (y - x).abs() > error_margin { }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub FLOAT_CMP,
     pedantic,
     "using `==` or `!=` on float values instead of comparing difference with an epsilon"
@@ -139,6 +142,7 @@ declare_clippy_lint! {
     /// # let y = String::from("foo");
     /// if x == y {}
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub CMP_OWNED,
     perf,
     "creating owned instances for comparing with others, e.g., `x == \"foo\".to_string()`"
@@ -162,6 +166,7 @@ declare_clippy_lint! {
     /// let a = x % 1;
     /// let a = x % -1;
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub MODULO_ONE,
     correctness,
     "taking a number modulo +/-1, which can either panic/overflow or always returns 0"
@@ -187,6 +192,7 @@ declare_clippy_lint! {
     /// let y = _x + 1; // Here we are using `_x`, even though it has a leading
     ///                 // underscore. We should rename `_x` to `x`
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub USED_UNDERSCORE_BINDING,
     pedantic,
     "using a binding which is prefixed with an underscore"
@@ -207,6 +213,7 @@ declare_clippy_lint! {
     /// ```rust,ignore
     /// f() && g(); // We should write `if f() { g(); }`.
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub SHORT_CIRCUIT_STATEMENT,
     complexity,
     "using a short circuit boolean condition as a statement"
@@ -228,6 +235,7 @@ declare_clippy_lint! {
     /// // Good
     /// let a = std::ptr::null::<u32>();
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub ZERO_PTR,
     style,
     "using `0 as *{const, mut} T`"
@@ -259,6 +267,7 @@ declare_clippy_lint! {
     /// // let error_margin = std::f64::EPSILON;
     /// if (x - ONE).abs() < error_margin { }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub FLOAT_CMP_CONST,
     restriction,
     "using `==` or `!=` on float constants instead of comparing difference with an epsilon"
diff --git a/clippy_lints/src/misc_early/mod.rs b/clippy_lints/src/misc_early/mod.rs
index 7c3f5f22ade..4b56eaebaea 100644
--- a/clippy_lints/src/misc_early/mod.rs
+++ b/clippy_lints/src/misc_early/mod.rs
@@ -46,6 +46,7 @@ declare_clippy_lint! {
     ///     Foo { .. } => {},
     /// }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub UNNEEDED_FIELD_PATTERN,
     restriction,
     "struct fields bound to a wildcard instead of using `..`"
@@ -67,6 +68,7 @@ declare_clippy_lint! {
     /// // Good
     /// fn bar(a: i32, _b: i32) {}
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub DUPLICATE_UNDERSCORE_ARGUMENT,
     style,
     "function arguments having names which only differ by an underscore"
@@ -85,6 +87,7 @@ declare_clippy_lint! {
     /// let mut x = 3;
     /// --x;
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub DOUBLE_NEG,
     style,
     "`--x`, which is a double negation of `x` and not a pre-decrement as in C/C++"
@@ -106,6 +109,7 @@ declare_clippy_lint! {
     /// // Good
     /// let y = 0x1A9BACD;
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub MIXED_CASE_HEX_LITERALS,
     style,
     "hex literals whose letter digits are not consistently upper- or lowercased"
@@ -129,6 +133,7 @@ declare_clippy_lint! {
     /// // Good
     /// let y = 123832_i32;
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub UNSEPARATED_LITERAL_SUFFIX,
     restriction,
     "literals whose suffix is not separated by an underscore"
@@ -189,6 +194,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// prints `83` (as `83 == 0o123` while `123 == 0o173`).
+    #[clippy::version = "pre 1.29.0"]
     pub ZERO_PREFIXED_LITERAL,
     complexity,
     "integer literals starting with `0`"
@@ -210,6 +216,7 @@ declare_clippy_lint! {
     ///     }
     /// }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub BUILTIN_TYPE_SHADOW,
     style,
     "shadowing a builtin type"
@@ -239,6 +246,7 @@ declare_clippy_lint! {
     ///     y => (),
     /// }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub REDUNDANT_PATTERN,
     style,
     "using `name @ _` in a pattern"
@@ -273,6 +281,7 @@ declare_clippy_lint! {
     ///     _ => (),
     /// }
     /// ```
+    #[clippy::version = "1.40.0"]
     pub UNNEEDED_WILDCARD_PATTERN,
     complexity,
     "tuple patterns with a wildcard pattern (`_`) is next to a rest pattern (`..`)"
diff --git a/clippy_lints/src/missing_const_for_fn.rs b/clippy_lints/src/missing_const_for_fn.rs
index 5b2584d43a1..a8d41050856 100644
--- a/clippy_lints/src/missing_const_for_fn.rs
+++ b/clippy_lints/src/missing_const_for_fn.rs
@@ -63,6 +63,7 @@ declare_clippy_lint! {
     /// }
     /// # }
     /// ```
+    #[clippy::version = "1.34.0"]
     pub MISSING_CONST_FOR_FN,
     nursery,
     "Lint functions definitions that could be made `const fn`"
diff --git a/clippy_lints/src/missing_doc.rs b/clippy_lints/src/missing_doc.rs
index 6920b4f72ea..db6aab0671b 100644
--- a/clippy_lints/src/missing_doc.rs
+++ b/clippy_lints/src/missing_doc.rs
@@ -27,6 +27,7 @@ declare_clippy_lint! {
     /// allowed-by-default lint for
     /// public members, but has no way to enforce documentation of private items.
     /// This lint fixes that.
+    #[clippy::version = "pre 1.29.0"]
     pub MISSING_DOCS_IN_PRIVATE_ITEMS,
     restriction,
     "detects missing documentation for public and private members"
diff --git a/clippy_lints/src/missing_enforced_import_rename.rs b/clippy_lints/src/missing_enforced_import_rename.rs
index 448bfc2fdd6..68d49e0f150 100644
--- a/clippy_lints/src/missing_enforced_import_rename.rs
+++ b/clippy_lints/src/missing_enforced_import_rename.rs
@@ -33,6 +33,7 @@ declare_clippy_lint! {
     /// ```rust,ignore
     /// use serde_json::Value as JsonValue;
     /// ```
+    #[clippy::version = "1.55.0"]
     pub MISSING_ENFORCED_IMPORT_RENAMES,
     restriction,
     "enforce import renames"
diff --git a/clippy_lints/src/missing_inline.rs b/clippy_lints/src/missing_inline.rs
index b593c747498..ac2f16b49e3 100644
--- a/clippy_lints/src/missing_inline.rs
+++ b/clippy_lints/src/missing_inline.rs
@@ -52,6 +52,7 @@ declare_clippy_lint! {
     ///    fn def_bar() {} // missing #[inline]
     /// }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub MISSING_INLINE_IN_PUBLIC_ITEMS,
     restriction,
     "detects missing `#[inline]` attribute for public callables (functions, trait methods, methods...)"
diff --git a/clippy_lints/src/module_style.rs b/clippy_lints/src/module_style.rs
index d41b5474564..3b65f80cba2 100644
--- a/clippy_lints/src/module_style.rs
+++ b/clippy_lints/src/module_style.rs
@@ -32,6 +32,7 @@ declare_clippy_lint! {
     ///   stuff.rs
     ///   lib.rs
     /// ```
+    #[clippy::version = "1.57.0"]
     pub MOD_MODULE_FILES,
     restriction,
     "checks that module layout is consistent"
@@ -61,6 +62,7 @@ declare_clippy_lint! {
     ///   lib.rs
     /// ```
 
+    #[clippy::version = "1.57.0"]
     pub SELF_NAMED_MODULE_FILES,
     restriction,
     "checks that module layout is consistent"
diff --git a/clippy_lints/src/modulo_arithmetic.rs b/clippy_lints/src/modulo_arithmetic.rs
index f45e68233a1..d182a7d5249 100644
--- a/clippy_lints/src/modulo_arithmetic.rs
+++ b/clippy_lints/src/modulo_arithmetic.rs
@@ -24,6 +24,7 @@ declare_clippy_lint! {
     /// ```rust
     /// let x = -17 % 3;
     /// ```
+    #[clippy::version = "1.42.0"]
     pub MODULO_ARITHMETIC,
     restriction,
     "any modulo arithmetic statement"
diff --git a/clippy_lints/src/multiple_crate_versions.rs b/clippy_lints/src/multiple_crate_versions.rs
index 816b2f275fb..e45cc86d417 100644
--- a/clippy_lints/src/multiple_crate_versions.rs
+++ b/clippy_lints/src/multiple_crate_versions.rs
@@ -33,6 +33,7 @@ declare_clippy_lint! {
     /// ctrlc = "=3.1.0"
     /// ansi_term = "=0.11.0"
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub MULTIPLE_CRATE_VERSIONS,
     cargo,
     "multiple versions of the same crate being used"
diff --git a/clippy_lints/src/mut_key.rs b/clippy_lints/src/mut_key.rs
index 8476257f086..5fe887a4573 100644
--- a/clippy_lints/src/mut_key.rs
+++ b/clippy_lints/src/mut_key.rs
@@ -72,6 +72,7 @@ declare_clippy_lint! {
     ///     let _: HashSet<Bad> = HashSet::new();
     /// }
     /// ```
+    #[clippy::version = "1.42.0"]
     pub MUTABLE_KEY_TYPE,
     suspicious,
     "Check for mutable `Map`/`Set` key type"
diff --git a/clippy_lints/src/mut_mut.rs b/clippy_lints/src/mut_mut.rs
index 7c4cac29ba8..bcbea8f1e66 100644
--- a/clippy_lints/src/mut_mut.rs
+++ b/clippy_lints/src/mut_mut.rs
@@ -22,6 +22,7 @@ declare_clippy_lint! {
     /// # let mut y = 1;
     /// let x = &mut &mut y;
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub MUT_MUT,
     pedantic,
     "usage of double-mut refs, e.g., `&mut &mut ...`"
diff --git a/clippy_lints/src/mut_mutex_lock.rs b/clippy_lints/src/mut_mutex_lock.rs
index b96fa4774cb..b1e6308d2e1 100644
--- a/clippy_lints/src/mut_mutex_lock.rs
+++ b/clippy_lints/src/mut_mutex_lock.rs
@@ -38,6 +38,7 @@ declare_clippy_lint! {
     /// let value = value_mutex.get_mut().unwrap();
     /// *value += 1;
     /// ```
+    #[clippy::version = "1.49.0"]
     pub MUT_MUTEX_LOCK,
     style,
     "`&mut Mutex::lock` does unnecessary locking"
diff --git a/clippy_lints/src/mut_reference.rs b/clippy_lints/src/mut_reference.rs
index 8d5d7951fc5..63a1cf7b7d5 100644
--- a/clippy_lints/src/mut_reference.rs
+++ b/clippy_lints/src/mut_reference.rs
@@ -23,6 +23,7 @@ declare_clippy_lint! {
     /// // Good
     /// my_vec.push(&value)
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub UNNECESSARY_MUT_PASSED,
     style,
     "an argument passed as a mutable reference although the callee only demands an immutable reference"
diff --git a/clippy_lints/src/mutable_debug_assertion.rs b/clippy_lints/src/mutable_debug_assertion.rs
index ee50891cc31..fa7274990db 100644
--- a/clippy_lints/src/mutable_debug_assertion.rs
+++ b/clippy_lints/src/mutable_debug_assertion.rs
@@ -26,6 +26,7 @@ declare_clippy_lint! {
     /// fn take_a_mut_parameter(_: &mut u32) -> bool { unimplemented!() }
     /// debug_assert!(take_a_mut_parameter(&mut 5));
     /// ```
+    #[clippy::version = "1.40.0"]
     pub DEBUG_ASSERT_WITH_MUT_CALL,
     nursery,
     "mutable arguments in `debug_assert{,_ne,_eq}!`"
diff --git a/clippy_lints/src/mutex_atomic.rs b/clippy_lints/src/mutex_atomic.rs
index 5feddcbfc61..816377fe65e 100644
--- a/clippy_lints/src/mutex_atomic.rs
+++ b/clippy_lints/src/mutex_atomic.rs
@@ -36,6 +36,7 @@ declare_clippy_lint! {
     /// # use std::sync::atomic::AtomicBool;
     /// let x = AtomicBool::new(y);
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub MUTEX_ATOMIC,
     perf,
     "using a mutex where an atomic value could be used instead"
@@ -64,6 +65,7 @@ declare_clippy_lint! {
     /// # use std::sync::atomic::AtomicUsize;
     /// let x = AtomicUsize::new(0usize);
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub MUTEX_INTEGER,
     nursery,
     "using a mutex for an integer type"
diff --git a/clippy_lints/src/needless_arbitrary_self_type.rs b/clippy_lints/src/needless_arbitrary_self_type.rs
index c8a8750c2ff..9838d3cad9f 100644
--- a/clippy_lints/src/needless_arbitrary_self_type.rs
+++ b/clippy_lints/src/needless_arbitrary_self_type.rs
@@ -52,6 +52,7 @@ declare_clippy_lint! {
     ///     }
     /// }
     /// ```
+    #[clippy::version = "1.47.0"]
     pub NEEDLESS_ARBITRARY_SELF_TYPE,
     complexity,
     "type of `self` parameter is already by default `Self`"
diff --git a/clippy_lints/src/needless_bitwise_bool.rs b/clippy_lints/src/needless_bitwise_bool.rs
index ad981599473..a8a8d174a82 100644
--- a/clippy_lints/src/needless_bitwise_bool.rs
+++ b/clippy_lints/src/needless_bitwise_bool.rs
@@ -30,6 +30,7 @@ declare_clippy_lint! {
     /// let (x,y) = (true, false);
     /// if x && !y {}
     /// ```
+    #[clippy::version = "1.54.0"]
     pub NEEDLESS_BITWISE_BOOL,
     pedantic,
     "Boolean expressions that use bitwise rather than lazy operators"
diff --git a/clippy_lints/src/needless_bool.rs b/clippy_lints/src/needless_bool.rs
index 91944653500..3709f3948c2 100644
--- a/clippy_lints/src/needless_bool.rs
+++ b/clippy_lints/src/needless_bool.rs
@@ -41,6 +41,7 @@ declare_clippy_lint! {
     /// ```rust,ignore
     /// !x
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub NEEDLESS_BOOL,
     complexity,
     "if-statements with plain booleans in the then- and else-clause, e.g., `if p { true } else { false }`"
@@ -65,6 +66,7 @@ declare_clippy_lint! {
     /// if x {}
     /// if !y {}
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub BOOL_COMPARISON,
     complexity,
     "comparing a variable to a boolean, e.g., `if x == true` or `if x != true`"
diff --git a/clippy_lints/src/needless_borrow.rs b/clippy_lints/src/needless_borrow.rs
index 085be6650cc..6709fed91bd 100644
--- a/clippy_lints/src/needless_borrow.rs
+++ b/clippy_lints/src/needless_borrow.rs
@@ -37,6 +37,7 @@ declare_clippy_lint! {
     /// let x: &i32 = &5;
     /// fun(x);
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub NEEDLESS_BORROW,
     style,
     "taking a reference that is going to be automatically dereferenced"
@@ -63,6 +64,7 @@ declare_clippy_lint! {
     ///     // use `&x` here
     /// }
     /// ```
+    #[clippy::version = "1.54.0"]
     pub REF_BINDING_TO_REFERENCE,
     pedantic,
     "`ref` binding to a reference"
diff --git a/clippy_lints/src/needless_borrowed_ref.rs b/clippy_lints/src/needless_borrowed_ref.rs
index 36879eda7c0..0fcc419e722 100644
--- a/clippy_lints/src/needless_borrowed_ref.rs
+++ b/clippy_lints/src/needless_borrowed_ref.rs
@@ -38,6 +38,7 @@ declare_clippy_lint! {
     /// let mut v = Vec::<String>::new();
     /// let _ = v.iter_mut().filter(|a| a.is_empty());
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub NEEDLESS_BORROWED_REFERENCE,
     complexity,
     "destructuring a reference and borrowing the inner value"
diff --git a/clippy_lints/src/needless_continue.rs b/clippy_lints/src/needless_continue.rs
index 7aa93ed7839..98a3bce1ff3 100644
--- a/clippy_lints/src/needless_continue.rs
+++ b/clippy_lints/src/needless_continue.rs
@@ -110,6 +110,7 @@ declare_clippy_lint! {
     ///     # break;
     /// }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub NEEDLESS_CONTINUE,
     pedantic,
     "`continue` statements that can be replaced by a rearrangement of code"
diff --git a/clippy_lints/src/needless_for_each.rs b/clippy_lints/src/needless_for_each.rs
index 9a6ddc72ce5..0c1da035173 100644
--- a/clippy_lints/src/needless_for_each.rs
+++ b/clippy_lints/src/needless_for_each.rs
@@ -40,6 +40,7 @@ declare_clippy_lint! {
     ///     println!("{}", elem);
     /// }
     /// ```
+    #[clippy::version = "1.53.0"]
     pub NEEDLESS_FOR_EACH,
     pedantic,
     "using `for_each` where a `for` loop would be simpler"
diff --git a/clippy_lints/src/needless_option_as_deref.rs b/clippy_lints/src/needless_option_as_deref.rs
index e88e98e6081..a28b08c33ec 100644
--- a/clippy_lints/src/needless_option_as_deref.rs
+++ b/clippy_lints/src/needless_option_as_deref.rs
@@ -26,6 +26,7 @@ declare_clippy_lint! {
     /// let a = Some(&1);
     /// let b = a;
     /// ```
+    #[clippy::version = "1.57.0"]
     pub NEEDLESS_OPTION_AS_DEREF,
     complexity,
     "no-op use of `deref` or `deref_mut` method to `Option`."
diff --git a/clippy_lints/src/needless_pass_by_value.rs b/clippy_lints/src/needless_pass_by_value.rs
index 352dc6f8bec..35877d51c0c 100644
--- a/clippy_lints/src/needless_pass_by_value.rs
+++ b/clippy_lints/src/needless_pass_by_value.rs
@@ -51,6 +51,7 @@ declare_clippy_lint! {
     ///     assert_eq!(v.len(), 42);
     /// }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub NEEDLESS_PASS_BY_VALUE,
     pedantic,
     "functions taking arguments by value, but not consuming them in its body"
diff --git a/clippy_lints/src/needless_question_mark.rs b/clippy_lints/src/needless_question_mark.rs
index 42e48336e15..3ca933ea8fb 100644
--- a/clippy_lints/src/needless_question_mark.rs
+++ b/clippy_lints/src/needless_question_mark.rs
@@ -53,6 +53,7 @@ declare_clippy_lint! {
     ///     tr.and_then(|t| t.magic)
     /// }
     /// ```
+    #[clippy::version = "1.51.0"]
     pub NEEDLESS_QUESTION_MARK,
     complexity,
     "Suggest `value.inner_option` instead of `Some(value.inner_option?)`. The same goes for `Result<T, E>`."
diff --git a/clippy_lints/src/needless_update.rs b/clippy_lints/src/needless_update.rs
index 2a33b7392ca..ed315efaa2f 100644
--- a/clippy_lints/src/needless_update.rs
+++ b/clippy_lints/src/needless_update.rs
@@ -40,6 +40,7 @@ declare_clippy_lint! {
     ///     ..zero_point
     /// };
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub NEEDLESS_UPDATE,
     complexity,
     "using `Foo { ..base }` when there are no missing fields"
diff --git a/clippy_lints/src/neg_cmp_op_on_partial_ord.rs b/clippy_lints/src/neg_cmp_op_on_partial_ord.rs
index 6ad49b70605..efe31a15441 100644
--- a/clippy_lints/src/neg_cmp_op_on_partial_ord.rs
+++ b/clippy_lints/src/neg_cmp_op_on_partial_ord.rs
@@ -36,6 +36,7 @@ declare_clippy_lint! {
     ///     _ => false,
     /// };
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub NEG_CMP_OP_ON_PARTIAL_ORD,
     complexity,
     "The use of negated comparison operators on partially ordered types may produce confusing code."
diff --git a/clippy_lints/src/neg_multiply.rs b/clippy_lints/src/neg_multiply.rs
index 1b15d29439f..cb67fab1740 100644
--- a/clippy_lints/src/neg_multiply.rs
+++ b/clippy_lints/src/neg_multiply.rs
@@ -20,6 +20,7 @@ declare_clippy_lint! {
     /// ```ignore
     /// x * -1
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub NEG_MULTIPLY,
     style,
     "multiplying integers with `-1`"
diff --git a/clippy_lints/src/new_without_default.rs b/clippy_lints/src/new_without_default.rs
index 0ac27f1cba2..f0c0c89ca8f 100644
--- a/clippy_lints/src/new_without_default.rs
+++ b/clippy_lints/src/new_without_default.rs
@@ -45,6 +45,7 @@ declare_clippy_lint! {
     ///     }
     /// }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub NEW_WITHOUT_DEFAULT,
     style,
     "`fn new() -> Self` method without `Default` implementation"
diff --git a/clippy_lints/src/no_effect.rs b/clippy_lints/src/no_effect.rs
index 6dae8f32043..31134743d02 100644
--- a/clippy_lints/src/no_effect.rs
+++ b/clippy_lints/src/no_effect.rs
@@ -22,6 +22,7 @@ declare_clippy_lint! {
     /// ```rust
     /// 0;
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub NO_EFFECT,
     complexity,
     "statements with no effect"
@@ -44,6 +45,7 @@ declare_clippy_lint! {
     /// ```rust,ignore
     /// let _i_serve_no_purpose = 1;
     /// ```
+    #[clippy::version = "1.58.0"]
     pub NO_EFFECT_UNDERSCORE_BINDING,
     pedantic,
     "binding to `_` prefixed variable with no side-effect"
@@ -62,6 +64,7 @@ declare_clippy_lint! {
     /// ```rust,ignore
     /// compute_array()[0];
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub UNNECESSARY_OPERATION,
     complexity,
     "outer expressions with no effect"
diff --git a/clippy_lints/src/non_copy_const.rs b/clippy_lints/src/non_copy_const.rs
index 2a85a67fa09..df82775d507 100644
--- a/clippy_lints/src/non_copy_const.rs
+++ b/clippy_lints/src/non_copy_const.rs
@@ -69,6 +69,7 @@ declare_clippy_lint! {
     /// STATIC_ATOM.store(9, SeqCst);
     /// assert_eq!(STATIC_ATOM.load(SeqCst), 9); // use a `static` item to refer to the same instance
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub DECLARE_INTERIOR_MUTABLE_CONST,
     style,
     "declaring `const` with interior mutability"
@@ -113,6 +114,7 @@ declare_clippy_lint! {
     /// STATIC_ATOM.store(9, SeqCst);
     /// assert_eq!(STATIC_ATOM.load(SeqCst), 9); // use a `static` item to refer to the same instance
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub BORROW_INTERIOR_MUTABLE_CONST,
     style,
     "referencing `const` with interior mutability"
diff --git a/clippy_lints/src/non_expressive_names.rs b/clippy_lints/src/non_expressive_names.rs
index 5b254bc8133..1a124e2d3cb 100644
--- a/clippy_lints/src/non_expressive_names.rs
+++ b/clippy_lints/src/non_expressive_names.rs
@@ -24,6 +24,7 @@ declare_clippy_lint! {
     /// let checked_exp = something;
     /// let checked_expr = something_else;
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub SIMILAR_NAMES,
     pedantic,
     "similarly named items and bindings"
@@ -42,6 +43,7 @@ declare_clippy_lint! {
     /// ```ignore
     /// let (a, b, c, d, e, f, g) = (...);
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub MANY_SINGLE_CHAR_NAMES,
     pedantic,
     "too many single character bindings"
@@ -62,6 +64,7 @@ declare_clippy_lint! {
     /// let ___1 = 1;
     /// let __1___2 = 11;
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub JUST_UNDERSCORES_AND_DIGITS,
     style,
     "unclear name"
diff --git a/clippy_lints/src/non_octal_unix_permissions.rs b/clippy_lints/src/non_octal_unix_permissions.rs
index 3b74f69d375..4b57dbc4c41 100644
--- a/clippy_lints/src/non_octal_unix_permissions.rs
+++ b/clippy_lints/src/non_octal_unix_permissions.rs
@@ -32,6 +32,7 @@ declare_clippy_lint! {
     /// let mut options = OpenOptions::new();
     /// options.mode(0o644);
     /// ```
+    #[clippy::version = "1.53.0"]
     pub NON_OCTAL_UNIX_PERMISSIONS,
     correctness,
     "use of non-octal value to set unix file permissions, which will be translated into octal"
diff --git a/clippy_lints/src/non_send_fields_in_send_ty.rs b/clippy_lints/src/non_send_fields_in_send_ty.rs
index 7ebf84d400f..9c07488bfe6 100644
--- a/clippy_lints/src/non_send_fields_in_send_ty.rs
+++ b/clippy_lints/src/non_send_fields_in_send_ty.rs
@@ -43,6 +43,7 @@ declare_clippy_lint! {
     /// ```
     /// Use thread-safe types like [`std::sync::Arc`](https://doc.rust-lang.org/std/sync/struct.Arc.html)
     /// or specify correct bounds on generic type parameters (`T: Send`).
+    #[clippy::version = "1.57.0"]
     pub NON_SEND_FIELDS_IN_SEND_TY,
     suspicious,
     "there is field that does not implement `Send` in a `Send` struct"
diff --git a/clippy_lints/src/nonstandard_macro_braces.rs b/clippy_lints/src/nonstandard_macro_braces.rs
index bab15217d52..3dcc9e26c9e 100644
--- a/clippy_lints/src/nonstandard_macro_braces.rs
+++ b/clippy_lints/src/nonstandard_macro_braces.rs
@@ -31,6 +31,7 @@ declare_clippy_lint! {
     /// ```rust
     /// vec![1, 2, 3];
     /// ```
+    #[clippy::version = "1.55.0"]
     pub NONSTANDARD_MACRO_BRACES,
     nursery,
     "check consistent use of braces in macro"
diff --git a/clippy_lints/src/open_options.rs b/clippy_lints/src/open_options.rs
index 5752342cf62..2c77100bdcf 100644
--- a/clippy_lints/src/open_options.rs
+++ b/clippy_lints/src/open_options.rs
@@ -22,6 +22,7 @@ declare_clippy_lint! {
     ///
     /// OpenOptions::new().read(true).truncate(true);
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub NONSENSICAL_OPEN_OPTIONS,
     correctness,
     "nonsensical combination of options for opening a file"
diff --git a/clippy_lints/src/option_env_unwrap.rs b/clippy_lints/src/option_env_unwrap.rs
index d7306628030..3f5286ba097 100644
--- a/clippy_lints/src/option_env_unwrap.rs
+++ b/clippy_lints/src/option_env_unwrap.rs
@@ -26,6 +26,7 @@ declare_clippy_lint! {
     /// ```rust,no_run
     /// let _ = env!("HOME");
     /// ```
+    #[clippy::version = "1.43.0"]
     pub OPTION_ENV_UNWRAP,
     correctness,
     "using `option_env!(...).unwrap()` to get environment variable"
diff --git a/clippy_lints/src/option_if_let_else.rs b/clippy_lints/src/option_if_let_else.rs
index ed5583799fe..df72f4b0eb2 100644
--- a/clippy_lints/src/option_if_let_else.rs
+++ b/clippy_lints/src/option_if_let_else.rs
@@ -59,6 +59,7 @@ declare_clippy_lint! {
     ///     y*y
     /// }, |foo| foo);
     /// ```
+    #[clippy::version = "1.47.0"]
     pub OPTION_IF_LET_ELSE,
     nursery,
     "reimplementation of Option::map_or"
diff --git a/clippy_lints/src/overflow_check_conditional.rs b/clippy_lints/src/overflow_check_conditional.rs
index 0f9e5ada3a8..6dabbd48031 100644
--- a/clippy_lints/src/overflow_check_conditional.rs
+++ b/clippy_lints/src/overflow_check_conditional.rs
@@ -19,6 +19,7 @@ declare_clippy_lint! {
     /// # let b = 2;
     /// a + b < a;
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub OVERFLOW_CHECK_CONDITIONAL,
     complexity,
     "overflow checks inspired by C which are likely to panic"
diff --git a/clippy_lints/src/panic_in_result_fn.rs b/clippy_lints/src/panic_in_result_fn.rs
index 583c42b6563..8769c045214 100644
--- a/clippy_lints/src/panic_in_result_fn.rs
+++ b/clippy_lints/src/panic_in_result_fn.rs
@@ -30,6 +30,7 @@ declare_clippy_lint! {
     ///     Err(String::from("error"))
     /// }
     /// ```
+    #[clippy::version = "1.48.0"]
     pub PANIC_IN_RESULT_FN,
     restriction,
     "functions of type `Result<..>` that contain `panic!()`, `todo!()`, `unreachable()`, `unimplemented()` or assertion"
diff --git a/clippy_lints/src/panic_unimplemented.rs b/clippy_lints/src/panic_unimplemented.rs
index d8d9081d6f1..edfac824ded 100644
--- a/clippy_lints/src/panic_unimplemented.rs
+++ b/clippy_lints/src/panic_unimplemented.rs
@@ -17,6 +17,7 @@ declare_clippy_lint! {
     /// ```no_run
     /// panic!("even with a good reason");
     /// ```
+    #[clippy::version = "1.40.0"]
     pub PANIC,
     restriction,
     "usage of the `panic!` macro"
@@ -33,6 +34,7 @@ declare_clippy_lint! {
     /// ```no_run
     /// unimplemented!();
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub UNIMPLEMENTED,
     restriction,
     "`unimplemented!` should not be present in production code"
@@ -49,6 +51,7 @@ declare_clippy_lint! {
     /// ```no_run
     /// todo!();
     /// ```
+    #[clippy::version = "1.40.0"]
     pub TODO,
     restriction,
     "`todo!` should not be present in production code"
@@ -65,6 +68,7 @@ declare_clippy_lint! {
     /// ```no_run
     /// unreachable!();
     /// ```
+    #[clippy::version = "1.40.0"]
     pub UNREACHABLE,
     restriction,
     "usage of the `unreachable!` macro"
diff --git a/clippy_lints/src/partialeq_ne_impl.rs b/clippy_lints/src/partialeq_ne_impl.rs
index 4ec493e5f45..e827cdaae87 100644
--- a/clippy_lints/src/partialeq_ne_impl.rs
+++ b/clippy_lints/src/partialeq_ne_impl.rs
@@ -25,6 +25,7 @@ declare_clippy_lint! {
     ///    fn ne(&self, other: &Foo) -> bool { !(self == other) }
     /// }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub PARTIALEQ_NE_IMPL,
     complexity,
     "re-implementing `PartialEq::ne`"
diff --git a/clippy_lints/src/pass_by_ref_or_value.rs b/clippy_lints/src/pass_by_ref_or_value.rs
index 6229b9608b3..3092ab8392a 100644
--- a/clippy_lints/src/pass_by_ref_or_value.rs
+++ b/clippy_lints/src/pass_by_ref_or_value.rs
@@ -65,6 +65,7 @@ declare_clippy_lint! {
     /// // Better
     /// fn foo(v: u32) {}
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub TRIVIALLY_COPY_PASS_BY_REF,
     pedantic,
     "functions taking small copyable arguments by reference"
@@ -98,6 +99,7 @@ declare_clippy_lint! {
     /// // Good
     /// fn foo(v: &TooLarge) {}
     /// ```
+    #[clippy::version = "1.49.0"]
     pub LARGE_TYPES_PASSED_BY_VALUE,
     pedantic,
     "functions taking large arguments by value"
diff --git a/clippy_lints/src/path_buf_push_overwrite.rs b/clippy_lints/src/path_buf_push_overwrite.rs
index 3df7a72d295..8ebee9bd04d 100644
--- a/clippy_lints/src/path_buf_push_overwrite.rs
+++ b/clippy_lints/src/path_buf_push_overwrite.rs
@@ -35,6 +35,7 @@ declare_clippy_lint! {
     /// x.push("bar");
     /// assert_eq!(x, PathBuf::from("/foo/bar"));
     /// ```
+    #[clippy::version = "1.36.0"]
     pub PATH_BUF_PUSH_OVERWRITE,
     nursery,
     "calling `push` with file system root on `PathBuf` can overwrite it"
diff --git a/clippy_lints/src/pattern_type_mismatch.rs b/clippy_lints/src/pattern_type_mismatch.rs
index e7bc2446590..3e7eef4edac 100644
--- a/clippy_lints/src/pattern_type_mismatch.rs
+++ b/clippy_lints/src/pattern_type_mismatch.rs
@@ -77,6 +77,7 @@ declare_clippy_lint! {
     ///     *a += b;
     /// }
     /// ```
+    #[clippy::version = "1.47.0"]
     pub PATTERN_TYPE_MISMATCH,
     restriction,
     "type of pattern does not match the expression type"
diff --git a/clippy_lints/src/precedence.rs b/clippy_lints/src/precedence.rs
index 1a8da00d9d6..cc0533c9f5d 100644
--- a/clippy_lints/src/precedence.rs
+++ b/clippy_lints/src/precedence.rs
@@ -42,6 +42,7 @@ declare_clippy_lint! {
     /// ### Example
     /// * `1 << 2 + 3` equals 32, while `(1 << 2) + 3` equals 7
     /// * `-1i32.abs()` equals -1, while `(-1i32).abs()` equals 1
+    #[clippy::version = "pre 1.29.0"]
     pub PRECEDENCE,
     complexity,
     "operations where precedence may be unclear"
diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs
index 8a36e20fc97..c08a19d520b 100644
--- a/clippy_lints/src/ptr.rs
+++ b/clippy_lints/src/ptr.rs
@@ -70,6 +70,7 @@ declare_clippy_lint! {
     /// // Good
     /// fn foo(&[u32]) { .. }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub PTR_ARG,
     style,
     "fn arguments of the type `&Vec<...>` or `&String`, suggesting to use `&[...]` or `&str` instead, respectively"
@@ -96,6 +97,7 @@ declare_clippy_lint! {
     ///     ..
     /// }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub CMP_NULL,
     style,
     "comparing a pointer to a null pointer, suggesting to use `.is_null()` instead"
@@ -121,6 +123,7 @@ declare_clippy_lint! {
     /// ```ignore
     /// fn foo(&Foo) -> &mut Bar { .. }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub MUT_FROM_REF,
     correctness,
     "fns that create mutable refs from immutable ref args"
@@ -143,6 +146,7 @@ declare_clippy_lint! {
     /// // Good
     /// unsafe { std::slice::from_raw_parts(NonNull::dangling().as_ptr(), 0); }
     /// ```
+    #[clippy::version = "1.53.0"]
     pub INVALID_NULL_PTR_USAGE,
     correctness,
     "invalid usage of a null pointer, suggesting `NonNull::dangling()` instead"
diff --git a/clippy_lints/src/ptr_eq.rs b/clippy_lints/src/ptr_eq.rs
index 2df34d6d9b9..3c126fc1ca6 100644
--- a/clippy_lints/src/ptr_eq.rs
+++ b/clippy_lints/src/ptr_eq.rs
@@ -29,6 +29,7 @@ declare_clippy_lint! {
     ///
     /// assert!(std::ptr::eq(a, b));
     /// ```
+    #[clippy::version = "1.49.0"]
     pub PTR_EQ,
     style,
     "use `std::ptr::eq` when comparing raw pointers"
diff --git a/clippy_lints/src/ptr_offset_with_cast.rs b/clippy_lints/src/ptr_offset_with_cast.rs
index cfb5287c667..964564b5794 100644
--- a/clippy_lints/src/ptr_offset_with_cast.rs
+++ b/clippy_lints/src/ptr_offset_with_cast.rs
@@ -38,6 +38,7 @@ declare_clippy_lint! {
     ///     ptr.add(offset);
     /// }
     /// ```
+    #[clippy::version = "1.30.0"]
     pub PTR_OFFSET_WITH_CAST,
     complexity,
     "unneeded pointer offset cast"
diff --git a/clippy_lints/src/question_mark.rs b/clippy_lints/src/question_mark.rs
index f63ef163bcb..a5531993ee6 100644
--- a/clippy_lints/src/question_mark.rs
+++ b/clippy_lints/src/question_mark.rs
@@ -32,6 +32,7 @@ declare_clippy_lint! {
     /// ```ignore
     /// option?;
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub QUESTION_MARK,
     style,
     "checks for expressions that could be replaced by the question mark operator"
diff --git a/clippy_lints/src/ranges.rs b/clippy_lints/src/ranges.rs
index 87364a88ed0..09c64485bbb 100644
--- a/clippy_lints/src/ranges.rs
+++ b/clippy_lints/src/ranges.rs
@@ -35,6 +35,7 @@ declare_clippy_lint! {
     /// # let x = vec![1];
     /// x.iter().enumerate();
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub RANGE_ZIP_WITH_LEN,
     complexity,
     "zipping iterator with a range when `enumerate()` would do"
@@ -72,6 +73,7 @@ declare_clippy_lint! {
     /// ```rust,ignore
     /// for x..=y { .. }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub RANGE_PLUS_ONE,
     pedantic,
     "`x..(y+1)` reads better as `x..=y`"
@@ -100,6 +102,7 @@ declare_clippy_lint! {
     /// ```rust,ignore
     /// for x..y { .. }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub RANGE_MINUS_ONE,
     pedantic,
     "`x..=(y-1)` reads better as `x..y`"
@@ -132,6 +135,7 @@ declare_clippy_lint! {
     ///     let sub = &arr[1..3];
     /// }
     /// ```
+    #[clippy::version = "1.45.0"]
     pub REVERSED_EMPTY_RANGES,
     correctness,
     "reversing the limits of range expressions, resulting in empty ranges"
@@ -158,6 +162,7 @@ declare_clippy_lint! {
     ///# let x = 6;
     /// assert!((3..8).contains(&x));
     /// ```
+    #[clippy::version = "1.49.0"]
     pub MANUAL_RANGE_CONTAINS,
     style,
     "manually reimplementing {`Range`, `RangeInclusive`}`::contains`"
diff --git a/clippy_lints/src/redundant_clone.rs b/clippy_lints/src/redundant_clone.rs
index f7711b6fe94..1a2c86a7686 100644
--- a/clippy_lints/src/redundant_clone.rs
+++ b/clippy_lints/src/redundant_clone.rs
@@ -62,6 +62,7 @@ declare_clippy_lint! {
     ///
     /// Path::new("/a/b").join("c").to_path_buf();
     /// ```
+    #[clippy::version = "1.32.0"]
     pub REDUNDANT_CLONE,
     perf,
     "`clone()` of an owned value that is going to be dropped immediately"
diff --git a/clippy_lints/src/redundant_closure_call.rs b/clippy_lints/src/redundant_closure_call.rs
index 90e3c3f4b3e..0de282542fc 100644
--- a/clippy_lints/src/redundant_closure_call.rs
+++ b/clippy_lints/src/redundant_closure_call.rs
@@ -30,6 +30,7 @@ declare_clippy_lint! {
     /// // Good
     /// let a = 42
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub REDUNDANT_CLOSURE_CALL,
     complexity,
     "throwaway closures called in the expression they are defined"
diff --git a/clippy_lints/src/redundant_else.rs b/clippy_lints/src/redundant_else.rs
index 68b256d2944..93dbe936d58 100644
--- a/clippy_lints/src/redundant_else.rs
+++ b/clippy_lints/src/redundant_else.rs
@@ -36,6 +36,7 @@ declare_clippy_lint! {
     ///     print!("Moving on...");
     /// }
     /// ```
+    #[clippy::version = "1.50.0"]
     pub REDUNDANT_ELSE,
     pedantic,
     "`else` branch that can be removed without changing semantics"
diff --git a/clippy_lints/src/redundant_field_names.rs b/clippy_lints/src/redundant_field_names.rs
index 47df4917510..0dea4a784b2 100644
--- a/clippy_lints/src/redundant_field_names.rs
+++ b/clippy_lints/src/redundant_field_names.rs
@@ -30,6 +30,7 @@ declare_clippy_lint! {
     /// ```ignore
     /// let foo = Foo { bar };
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub REDUNDANT_FIELD_NAMES,
     style,
     "checks for fields in struct literals where shorthands could be used"
diff --git a/clippy_lints/src/redundant_pub_crate.rs b/clippy_lints/src/redundant_pub_crate.rs
index 919d4e11e5a..2cee3c14d7f 100644
--- a/clippy_lints/src/redundant_pub_crate.rs
+++ b/clippy_lints/src/redundant_pub_crate.rs
@@ -26,6 +26,7 @@ declare_clippy_lint! {
     ///     pub fn internal_fn() { }
     /// }
     /// ```
+    #[clippy::version = "1.44.0"]
     pub REDUNDANT_PUB_CRATE,
     nursery,
     "Using `pub(crate)` visibility on items that are not crate visible due to the visibility of the module that contains them."
diff --git a/clippy_lints/src/redundant_slicing.rs b/clippy_lints/src/redundant_slicing.rs
index 0c460150087..b2bd0103d11 100644
--- a/clippy_lints/src/redundant_slicing.rs
+++ b/clippy_lints/src/redundant_slicing.rs
@@ -34,6 +34,7 @@ declare_clippy_lint! {
     ///     x
     /// }
     /// ```
+    #[clippy::version = "1.51.0"]
     pub REDUNDANT_SLICING,
     complexity,
     "redundant slicing of the whole range of a type"
diff --git a/clippy_lints/src/redundant_static_lifetimes.rs b/clippy_lints/src/redundant_static_lifetimes.rs
index d5a1a61da6b..ea5064217ab 100644
--- a/clippy_lints/src/redundant_static_lifetimes.rs
+++ b/clippy_lints/src/redundant_static_lifetimes.rs
@@ -27,6 +27,7 @@ declare_clippy_lint! {
     ///  const FOO: &[(&str, &str, fn(&Bar) -> bool)] = &[...]
     ///  static FOO: &[(&str, &str, fn(&Bar) -> bool)] = &[...]
     /// ```
+    #[clippy::version = "1.37.0"]
     pub REDUNDANT_STATIC_LIFETIMES,
     style,
     "Using explicit `'static` lifetime for constants or statics when elision rules would allow omitting them."
diff --git a/clippy_lints/src/ref_option_ref.rs b/clippy_lints/src/ref_option_ref.rs
index d543832e314..909d6971a54 100644
--- a/clippy_lints/src/ref_option_ref.rs
+++ b/clippy_lints/src/ref_option_ref.rs
@@ -28,6 +28,7 @@ declare_clippy_lint! {
     /// ```rust,ignore
     /// let x: Option<&u32> = Some(&0u32);
     /// ```
+    #[clippy::version = "1.49.0"]
     pub REF_OPTION_REF,
     pedantic,
     "use `Option<&T>` instead of `&Option<&T>`"
diff --git a/clippy_lints/src/reference.rs b/clippy_lints/src/reference.rs
index 70dff5ad313..22ae7a291d0 100644
--- a/clippy_lints/src/reference.rs
+++ b/clippy_lints/src/reference.rs
@@ -30,6 +30,7 @@ declare_clippy_lint! {
     /// let a = f(b);
     /// let c = d;
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub DEREF_ADDROF,
     complexity,
     "use of `*&` or `*&mut` in an expression"
@@ -124,6 +125,7 @@ declare_clippy_lint! {
     /// # let point = Point(30, 20);
     /// let x = point.0;
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub REF_IN_DEREF,
     complexity,
     "Use of reference in auto dereference expression."
diff --git a/clippy_lints/src/regex.rs b/clippy_lints/src/regex.rs
index 5d08aee1e5f..8e5983b4773 100644
--- a/clippy_lints/src/regex.rs
+++ b/clippy_lints/src/regex.rs
@@ -22,6 +22,7 @@ declare_clippy_lint! {
     /// ```ignore
     /// Regex::new("|")
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub INVALID_REGEX,
     correctness,
     "invalid regular expressions"
@@ -46,6 +47,7 @@ declare_clippy_lint! {
     /// ```ignore
     /// Regex::new("^foobar")
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub TRIVIAL_REGEX,
     nursery,
     "trivial regular expressions"
diff --git a/clippy_lints/src/repeat_once.rs b/clippy_lints/src/repeat_once.rs
index e5e55ee7505..b5dd2de6337 100644
--- a/clippy_lints/src/repeat_once.rs
+++ b/clippy_lints/src/repeat_once.rs
@@ -35,6 +35,7 @@ declare_clippy_lint! {
     ///     let x = String::from("hello world").clone();
     /// }
     /// ```
+    #[clippy::version = "1.47.0"]
     pub REPEAT_ONCE,
     complexity,
     "using `.repeat(1)` instead of `String.clone()`, `str.to_string()` or `slice.to_vec()` "
diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
index e2b1a33746e..494bc7dda18 100644
--- a/clippy_lints/src/returns.rs
+++ b/clippy_lints/src/returns.rs
@@ -37,6 +37,7 @@ declare_clippy_lint! {
     ///     String::new()
     /// }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub LET_AND_RETURN,
     style,
     "creating a let-binding and then immediately returning it like `let x = expr; x` at the end of a block"
@@ -62,6 +63,7 @@ declare_clippy_lint! {
     ///     x
     /// }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub NEEDLESS_RETURN,
     style,
     "using a return statement like `return expr;` where an expression would suffice"
diff --git a/clippy_lints/src/same_name_method.rs b/clippy_lints/src/same_name_method.rs
index 737ff634e44..3f38d12fb55 100644
--- a/clippy_lints/src/same_name_method.rs
+++ b/clippy_lints/src/same_name_method.rs
@@ -33,6 +33,7 @@ declare_clippy_lint! {
     ///     fn foo(&self) {}
     /// }
     /// ```
+    #[clippy::version = "1.57.0"]
     pub SAME_NAME_METHOD,
     restriction,
     "two method with same name"
diff --git a/clippy_lints/src/self_assignment.rs b/clippy_lints/src/self_assignment.rs
index fbd65fef7d1..b14f0518bdb 100644
--- a/clippy_lints/src/self_assignment.rs
+++ b/clippy_lints/src/self_assignment.rs
@@ -30,6 +30,7 @@ declare_clippy_lint! {
     ///     a.y = a.y;
     /// }
     /// ```
+    #[clippy::version = "1.48.0"]
     pub SELF_ASSIGNMENT,
     correctness,
     "explicit self-assignment"
diff --git a/clippy_lints/src/self_named_constructors.rs b/clippy_lints/src/self_named_constructors.rs
index 4ba5e1a0f53..dd73dbfe09e 100644
--- a/clippy_lints/src/self_named_constructors.rs
+++ b/clippy_lints/src/self_named_constructors.rs
@@ -32,6 +32,7 @@ declare_clippy_lint! {
     ///     }
     /// }
     /// ```
+    #[clippy::version = "1.55.0"]
     pub SELF_NAMED_CONSTRUCTORS,
     style,
     "method should not have the same name as the type it is implemented for"
diff --git a/clippy_lints/src/semicolon_if_nothing_returned.rs b/clippy_lints/src/semicolon_if_nothing_returned.rs
index d3b4929a189..0b3bbbc8155 100644
--- a/clippy_lints/src/semicolon_if_nothing_returned.rs
+++ b/clippy_lints/src/semicolon_if_nothing_returned.rs
@@ -29,6 +29,7 @@ declare_clippy_lint! {
     ///     println!("Hello world");
     /// }
     /// ```
+    #[clippy::version = "1.52.0"]
     pub SEMICOLON_IF_NOTHING_RETURNED,
     pedantic,
     "add a semicolon if nothing is returned"
diff --git a/clippy_lints/src/serde_api.rs b/clippy_lints/src/serde_api.rs
index 2cd0f85999c..a38b3c4ab69 100644
--- a/clippy_lints/src/serde_api.rs
+++ b/clippy_lints/src/serde_api.rs
@@ -15,6 +15,7 @@ declare_clippy_lint! {
     /// ### Example
     /// Implementing `Visitor::visit_string` but not
     /// `Visitor::visit_str`.
+    #[clippy::version = "pre 1.29.0"]
     pub SERDE_API_MISUSE,
     correctness,
     "various things that will negatively affect your serde experience"
diff --git a/clippy_lints/src/shadow.rs b/clippy_lints/src/shadow.rs
index 64841f33cc3..5f82aed872c 100644
--- a/clippy_lints/src/shadow.rs
+++ b/clippy_lints/src/shadow.rs
@@ -29,6 +29,7 @@ declare_clippy_lint! {
     /// // Good
     /// let y = &x; // use different variable name
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub SHADOW_SAME,
     restriction,
     "rebinding a name to itself, e.g., `let mut x = &mut x`"
@@ -55,6 +56,7 @@ declare_clippy_lint! {
     /// let x = 2;
     /// let y = x + 1;
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub SHADOW_REUSE,
     restriction,
     "rebinding a name to an expression that re-uses the original value, e.g., `let x = x + 1`"
@@ -84,6 +86,7 @@ declare_clippy_lint! {
     /// // Good
     /// let w = z; // use different variable name
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub SHADOW_UNRELATED,
     restriction,
     "rebinding a name without even using the original value"
diff --git a/clippy_lints/src/single_component_path_imports.rs b/clippy_lints/src/single_component_path_imports.rs
index 87aa02b6585..28d32203da9 100644
--- a/clippy_lints/src/single_component_path_imports.rs
+++ b/clippy_lints/src/single_component_path_imports.rs
@@ -27,6 +27,7 @@ declare_clippy_lint! {
     ///     regex::Regex::new(r"^\d{4}-\d{2}-\d{2}$").unwrap();
     /// }
     /// ```
+    #[clippy::version = "1.43.0"]
     pub SINGLE_COMPONENT_PATH_IMPORTS,
     style,
     "imports with single component path are redundant"
diff --git a/clippy_lints/src/size_of_in_element_count.rs b/clippy_lints/src/size_of_in_element_count.rs
index 3e4e4a8d0c0..df1e85afdd7 100644
--- a/clippy_lints/src/size_of_in_element_count.rs
+++ b/clippy_lints/src/size_of_in_element_count.rs
@@ -29,6 +29,7 @@ declare_clippy_lint! {
     /// let mut y = [2u8; SIZE];
     /// unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), size_of::<u8>() * SIZE) };
     /// ```
+    #[clippy::version = "1.50.0"]
     pub SIZE_OF_IN_ELEMENT_COUNT,
     correctness,
     "using `size_of::<T>` or `size_of_val::<T>` where a count of elements of `T` is expected"
diff --git a/clippy_lints/src/slow_vector_initialization.rs b/clippy_lints/src/slow_vector_initialization.rs
index 3608fe1472d..1ae772ef70b 100644
--- a/clippy_lints/src/slow_vector_initialization.rs
+++ b/clippy_lints/src/slow_vector_initialization.rs
@@ -36,6 +36,7 @@ declare_clippy_lint! {
     /// let mut vec1 = vec![0; len];
     /// let mut vec2 = vec![0; len];
     /// ```
+    #[clippy::version = "1.32.0"]
     pub SLOW_VECTOR_INITIALIZATION,
     perf,
     "slow vector initialization"
diff --git a/clippy_lints/src/stable_sort_primitive.rs b/clippy_lints/src/stable_sort_primitive.rs
index 4ea1293d504..953d21e07a3 100644
--- a/clippy_lints/src/stable_sort_primitive.rs
+++ b/clippy_lints/src/stable_sort_primitive.rs
@@ -28,6 +28,7 @@ declare_clippy_lint! {
     /// let mut vec = vec![2, 1, 3];
     /// vec.sort_unstable();
     /// ```
+    #[clippy::version = "1.47.0"]
     pub STABLE_SORT_PRIMITIVE,
     perf,
     "use of sort() when sort_unstable() is equivalent"
diff --git a/clippy_lints/src/strings.rs b/clippy_lints/src/strings.rs
index 6435107b8b4..368274440d5 100644
--- a/clippy_lints/src/strings.rs
+++ b/clippy_lints/src/strings.rs
@@ -31,6 +31,7 @@ declare_clippy_lint! {
     /// x += ", World";
     /// x.push_str(", World");
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub STRING_ADD_ASSIGN,
     pedantic,
     "using `x = x + ..` where x is a `String` instead of `push_str()`"
@@ -58,6 +59,7 @@ declare_clippy_lint! {
     /// let x = "Hello".to_owned();
     /// x + ", World";
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub STRING_ADD,
     restriction,
     "using `x + ..` where x is a `String` instead of `push_str()`"
@@ -102,6 +104,7 @@ declare_clippy_lint! {
     /// // Good
     /// let bs = b"a byte string";
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub STRING_LIT_AS_BYTES,
     nursery,
     "calling `as_bytes` on a string literal instead of using a byte string literal"
@@ -125,6 +128,7 @@ declare_clippy_lint! {
     /// ```rust,should_panic
     /// &"Ölkanne"[1..];
     /// ```
+    #[clippy::version = "1.58.0"]
     pub STRING_SLICE,
     restriction,
     "slicing a string"
@@ -227,6 +231,7 @@ declare_clippy_lint! {
     /// ```rust
     /// let _ = &"Hello World!"[6..11];
     /// ```
+    #[clippy::version = "1.50.0"]
     pub STRING_FROM_UTF8_AS_BYTES,
     complexity,
     "casting string slices to byte slices and back"
@@ -371,6 +376,7 @@ declare_clippy_lint! {
     /// // example code which does not raise clippy warning
     /// let _ = "str".to_owned();
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub STR_TO_STRING,
     restriction,
     "using `to_string()` on a `&str`, which should be `to_owned()`"
@@ -420,6 +426,7 @@ declare_clippy_lint! {
     /// let msg = String::from("Hello World");
     /// let _ = msg.clone();
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub STRING_TO_STRING,
     restriction,
     "using `to_string()` on a `String`, which should be `clone()`"
diff --git a/clippy_lints/src/strlen_on_c_strings.rs b/clippy_lints/src/strlen_on_c_strings.rs
index 8bf40ec5312..be7431f11aa 100644
--- a/clippy_lints/src/strlen_on_c_strings.rs
+++ b/clippy_lints/src/strlen_on_c_strings.rs
@@ -30,6 +30,7 @@ declare_clippy_lint! {
     /// let cstring = CString::new("foo").expect("CString::new failed");
     /// let len = cstring.as_bytes().len();
     /// ```
+    #[clippy::version = "1.55.0"]
     pub STRLEN_ON_C_STRINGS,
     complexity,
     "using `libc::strlen` on a `CString` or `CStr` value, while `as_bytes().len()` or `to_bytes().len()` respectively can be used instead"
diff --git a/clippy_lints/src/suspicious_operation_groupings.rs b/clippy_lints/src/suspicious_operation_groupings.rs
index 201aa067824..faf43fd9fc1 100644
--- a/clippy_lints/src/suspicious_operation_groupings.rs
+++ b/clippy_lints/src/suspicious_operation_groupings.rs
@@ -59,6 +59,7 @@ declare_clippy_lint! {
     ///     }
     /// }
     /// ```
+    #[clippy::version = "1.50.0"]
     pub SUSPICIOUS_OPERATION_GROUPINGS,
     nursery,
     "groupings of binary operations that look suspiciously like typos"
diff --git a/clippy_lints/src/suspicious_trait_impl.rs b/clippy_lints/src/suspicious_trait_impl.rs
index 682fad00a13..a3195de81d1 100644
--- a/clippy_lints/src/suspicious_trait_impl.rs
+++ b/clippy_lints/src/suspicious_trait_impl.rs
@@ -25,6 +25,7 @@ declare_clippy_lint! {
     ///     }
     /// }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub SUSPICIOUS_ARITHMETIC_IMPL,
     suspicious,
     "suspicious use of operators in impl of arithmetic trait"
@@ -46,6 +47,7 @@ declare_clippy_lint! {
     ///     }
     /// }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub SUSPICIOUS_OP_ASSIGN_IMPL,
     suspicious,
     "suspicious use of operators in impl of OpAssign trait"
diff --git a/clippy_lints/src/swap.rs b/clippy_lints/src/swap.rs
index ef26de5b6b9..a8c7ca4c916 100644
--- a/clippy_lints/src/swap.rs
+++ b/clippy_lints/src/swap.rs
@@ -35,6 +35,7 @@ declare_clippy_lint! {
     /// let mut b = 2;
     /// std::mem::swap(&mut a, &mut b);
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub MANUAL_SWAP,
     complexity,
     "manual swap of two variables"
@@ -60,6 +61,7 @@ declare_clippy_lint! {
     /// # let mut b = 2;
     /// std::mem::swap(&mut a, &mut b);
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub ALMOST_SWAPPED,
     correctness,
     "`foo = bar; bar = foo` sequence"
diff --git a/clippy_lints/src/tabs_in_doc_comments.rs b/clippy_lints/src/tabs_in_doc_comments.rs
index 4a67cabf323..c9b4b245f4c 100644
--- a/clippy_lints/src/tabs_in_doc_comments.rs
+++ b/clippy_lints/src/tabs_in_doc_comments.rs
@@ -51,6 +51,7 @@ declare_clippy_lint! {
     ///    second_string: String,
     ///}
     /// ```
+    #[clippy::version = "1.41.0"]
     pub TABS_IN_DOC_COMMENTS,
     style,
     "using tabs in doc comments is not recommended"
diff --git a/clippy_lints/src/temporary_assignment.rs b/clippy_lints/src/temporary_assignment.rs
index a9da690339c..3766b8f8ed1 100644
--- a/clippy_lints/src/temporary_assignment.rs
+++ b/clippy_lints/src/temporary_assignment.rs
@@ -17,6 +17,7 @@ declare_clippy_lint! {
     /// ```rust
     /// (0, 0).0 = 1
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub TEMPORARY_ASSIGNMENT,
     complexity,
     "assignments to temporaries"
diff --git a/clippy_lints/src/to_digit_is_some.rs b/clippy_lints/src/to_digit_is_some.rs
index 1c14a919995..5eb58b47838 100644
--- a/clippy_lints/src/to_digit_is_some.rs
+++ b/clippy_lints/src/to_digit_is_some.rs
@@ -28,6 +28,7 @@ declare_clippy_lint! {
     /// # let radix = 10;
     /// let is_digit = c.is_digit(radix);
     /// ```
+    #[clippy::version = "1.41.0"]
     pub TO_DIGIT_IS_SOME,
     style,
     "`char.is_digit()` is clearer"
diff --git a/clippy_lints/src/to_string_in_display.rs b/clippy_lints/src/to_string_in_display.rs
index b7414cec87c..f8b6bdcd3e1 100644
--- a/clippy_lints/src/to_string_in_display.rs
+++ b/clippy_lints/src/to_string_in_display.rs
@@ -39,6 +39,7 @@ declare_clippy_lint! {
     ///     }
     /// }
     /// ```
+    #[clippy::version = "1.48.0"]
     pub TO_STRING_IN_DISPLAY,
     correctness,
     "`to_string` method used while implementing `Display` trait"
diff --git a/clippy_lints/src/trailing_empty_array.rs b/clippy_lints/src/trailing_empty_array.rs
index c216a1f81ea..47c0a84cd46 100644
--- a/clippy_lints/src/trailing_empty_array.rs
+++ b/clippy_lints/src/trailing_empty_array.rs
@@ -28,6 +28,7 @@ declare_clippy_lint! {
     ///     last: [u32; 0],
     /// }
     /// ```
+    #[clippy::version = "1.58.0"]
     pub TRAILING_EMPTY_ARRAY,
     nursery,
     "struct with a trailing zero-sized array but without `#[repr(C)]` or another `repr` attribute"
diff --git a/clippy_lints/src/trait_bounds.rs b/clippy_lints/src/trait_bounds.rs
index 73bdcae9e39..fb4abceac25 100644
--- a/clippy_lints/src/trait_bounds.rs
+++ b/clippy_lints/src/trait_bounds.rs
@@ -28,6 +28,7 @@ declare_clippy_lint! {
     /// ```rust
     /// pub fn foo<T>(t: T) where T: Copy + Clone {}
     /// ```
+    #[clippy::version = "1.38.0"]
     pub TYPE_REPETITION_IN_BOUNDS,
     pedantic,
     "Types are repeated unnecessary in trait bounds use `+` instead of using `T: _, T: _`"
@@ -57,6 +58,7 @@ declare_clippy_lint! {
     /// ```rust
     /// fn func<T>(arg: T) where T: Clone + Default {}
     /// ```
+    #[clippy::version = "1.47.0"]
     pub TRAIT_DUPLICATION_IN_BOUNDS,
     pedantic,
     "Check if the same trait bounds are specified twice during a function declaration"
diff --git a/clippy_lints/src/transmute/mod.rs b/clippy_lints/src/transmute/mod.rs
index e6acf1a94c9..3ad4ec74bf5 100644
--- a/clippy_lints/src/transmute/mod.rs
+++ b/clippy_lints/src/transmute/mod.rs
@@ -36,6 +36,7 @@ declare_clippy_lint! {
     /// ```ignore
     /// let ptr: *const T = core::intrinsics::transmute('x')
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub WRONG_TRANSMUTE,
     correctness,
     "transmutes that are confusing at best, undefined behaviour at worst and always useless"
@@ -55,6 +56,7 @@ declare_clippy_lint! {
     /// ```rust,ignore
     /// core::intrinsics::transmute(t); // where the result type is the same as `t`'s
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub USELESS_TRANSMUTE,
     nursery,
     "transmutes that have the same to and from types or could be a cast/coercion"
@@ -80,6 +82,7 @@ declare_clippy_lint! {
     /// # let p: *const [i32] = &[];
     /// p as *const [u16];
     /// ```
+    #[clippy::version = "1.47.0"]
     pub TRANSMUTES_EXPRESSIBLE_AS_PTR_CASTS,
     complexity,
     "transmutes that could be a pointer cast"
@@ -98,6 +101,7 @@ declare_clippy_lint! {
     /// core::intrinsics::transmute(t) // where the result type is the same as
     ///                                // `*t` or `&t`'s
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub CROSSPOINTER_TRANSMUTE,
     complexity,
     "transmutes that have to or from types that are a pointer to the other"
@@ -125,6 +129,7 @@ declare_clippy_lint! {
     /// // can be written:
     /// let _: &T = &*p;
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub TRANSMUTE_PTR_TO_REF,
     complexity,
     "transmutes from a pointer to a reference type"
@@ -158,6 +163,7 @@ declare_clippy_lint! {
     /// // should be:
     /// let _ = std::char::from_u32(x).unwrap();
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub TRANSMUTE_INT_TO_CHAR,
     complexity,
     "transmutes from an integer to a `char`"
@@ -191,6 +197,7 @@ declare_clippy_lint! {
     /// // should be:
     /// let _ = std::str::from_utf8(b).unwrap();
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub TRANSMUTE_BYTES_TO_STR,
     complexity,
     "transmutes from a `&[u8]` to a `&str`"
@@ -213,6 +220,7 @@ declare_clippy_lint! {
     /// // should be:
     /// let _: bool = x != 0;
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub TRANSMUTE_INT_TO_BOOL,
     complexity,
     "transmutes from an integer to a `bool`"
@@ -235,6 +243,7 @@ declare_clippy_lint! {
     /// // should be:
     /// let _: f32 = f32::from_bits(1_u32);
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub TRANSMUTE_INT_TO_FLOAT,
     complexity,
     "transmutes from an integer to a float"
@@ -257,6 +266,7 @@ declare_clippy_lint! {
     /// // should be:
     /// let _: u32 = 1f32.to_bits();
     /// ```
+    #[clippy::version = "1.41.0"]
     pub TRANSMUTE_FLOAT_TO_INT,
     complexity,
     "transmutes from a float to an integer"
@@ -279,6 +289,7 @@ declare_clippy_lint! {
     /// // should be
     /// let x: [u8; 8] = 0i64.to_ne_bytes();
     /// ```
+    #[clippy::version = "1.58.0"]
     pub TRANSMUTE_NUM_TO_BYTES,
     complexity,
     "transmutes from a number to an array of `u8`"
@@ -306,6 +317,7 @@ declare_clippy_lint! {
     /// let _ = ptr as *const f32;
     /// let _ = unsafe{ &*(&1u32 as *const u32 as *const f32) };
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub TRANSMUTE_PTR_TO_PTR,
     pedantic,
     "transmutes from a pointer to a pointer / a reference to a reference"
@@ -337,6 +349,7 @@ declare_clippy_lint! {
     /// ```rust
     /// vec![2_u16].into_iter().map(u32::from).collect::<Vec<_>>();
     /// ```
+    #[clippy::version = "1.40.0"]
     pub UNSOUND_COLLECTION_TRANSMUTE,
     correctness,
     "transmute between collections of layout-incompatible types"
diff --git a/clippy_lints/src/transmuting_null.rs b/clippy_lints/src/transmuting_null.rs
index ef80663d1da..7939dfedc3a 100644
--- a/clippy_lints/src/transmuting_null.rs
+++ b/clippy_lints/src/transmuting_null.rs
@@ -25,6 +25,7 @@ declare_clippy_lint! {
     /// ```rust
     /// let null_ref: &u64 = unsafe { std::mem::transmute(0 as *const u64) };
     /// ```
+    #[clippy::version = "1.35.0"]
     pub TRANSMUTING_NULL,
     correctness,
     "transmutes from a null pointer to a reference, which is undefined behavior"
diff --git a/clippy_lints/src/try_err.rs b/clippy_lints/src/try_err.rs
index cc450b1e599..e0e7ec9a452 100644
--- a/clippy_lints/src/try_err.rs
+++ b/clippy_lints/src/try_err.rs
@@ -41,6 +41,7 @@ declare_clippy_lint! {
     ///     Ok(0)
     /// }
     /// ```
+    #[clippy::version = "1.38.0"]
     pub TRY_ERR,
     style,
     "return errors explicitly rather than hiding them behind a `?`"
diff --git a/clippy_lints/src/types/mod.rs b/clippy_lints/src/types/mod.rs
index bbe07db5358..5a7ef760a30 100644
--- a/clippy_lints/src/types/mod.rs
+++ b/clippy_lints/src/types/mod.rs
@@ -43,6 +43,7 @@ declare_clippy_lint! {
     ///     values: Vec<Foo>,
     /// }
     /// ```
+    #[clippy::version = "1.57.0"]
     pub BOX_COLLECTION,
     perf,
     "usage of `Box<Vec<T>>`, vector elements are already on the heap"
@@ -75,6 +76,7 @@ declare_clippy_lint! {
     ///     values: Vec<i32>,
     /// }
     /// ```
+    #[clippy::version = "1.33.0"]
     pub VEC_BOX,
     complexity,
     "usage of `Vec<Box<T>>` where T: Sized, vector elements are already on the heap"
@@ -113,6 +115,7 @@ declare_clippy_lint! {
     ///     Contents::None
     /// }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub OPTION_OPTION,
     pedantic,
     "usage of `Option<Option<T>>`"
@@ -152,6 +155,7 @@ declare_clippy_lint! {
     /// # use std::collections::LinkedList;
     /// let x: LinkedList<usize> = LinkedList::new();
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub LINKEDLIST,
     pedantic,
     "usage of LinkedList, usually a vector is faster, or a more specialized data structure like a `VecDeque`"
@@ -176,6 +180,7 @@ declare_clippy_lint! {
     /// ```rust,ignore
     /// fn foo(bar: &T) { ... }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub BORROWED_BOX,
     complexity,
     "a borrow of a boxed type"
@@ -200,6 +205,7 @@ declare_clippy_lint! {
     /// ```rust
     /// fn foo(bar: &usize) {}
     /// ```
+    #[clippy::version = "1.44.0"]
     pub REDUNDANT_ALLOCATION,
     perf,
     "redundant allocation"
@@ -234,6 +240,7 @@ declare_clippy_lint! {
     /// ```rust,ignore
     /// fn foo(interned: Rc<str>) { ... }
     /// ```
+    #[clippy::version = "1.48.0"]
     pub RC_BUFFER,
     restriction,
     "shared ownership of a buffer type"
@@ -255,6 +262,7 @@ declare_clippy_lint! {
     ///     inner: Rc<Vec<Vec<Box<(u32, u32, u32, u32)>>>>,
     /// }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub TYPE_COMPLEXITY,
     complexity,
     "usage of very complex types that might be better factored into `type` definitions"
@@ -287,6 +295,7 @@ declare_clippy_lint! {
     /// use std::cell::RefCell
     /// fn foo(interned: Rc<RefCell<i32>>) { ... }
     /// ```
+    #[clippy::version = "1.55.0"]
     pub RC_MUTEX,
     restriction,
     "usage of `Rc<Mutex<T>>`"
diff --git a/clippy_lints/src/undocumented_unsafe_blocks.rs b/clippy_lints/src/undocumented_unsafe_blocks.rs
index fbf66712261..c886faf5d28 100644
--- a/clippy_lints/src/undocumented_unsafe_blocks.rs
+++ b/clippy_lints/src/undocumented_unsafe_blocks.rs
@@ -39,6 +39,7 @@ declare_clippy_lint! {
     /// // Safety: references are guaranteed to be non-null.
     /// let ptr = unsafe { NonNull::new_unchecked(a) };
     /// ```
+    #[clippy::version = "1.58.0"]
     pub UNDOCUMENTED_UNSAFE_BLOCKS,
     restriction,
     "creating an unsafe block without explaining why it is safe"
diff --git a/clippy_lints/src/undropped_manually_drops.rs b/clippy_lints/src/undropped_manually_drops.rs
index 09570616593..c58fa67a023 100644
--- a/clippy_lints/src/undropped_manually_drops.rs
+++ b/clippy_lints/src/undropped_manually_drops.rs
@@ -28,6 +28,7 @@ declare_clippy_lint! {
     ///     std::mem::ManuallyDrop::drop(&mut std::mem::ManuallyDrop::new(S));
     /// }
     /// ```
+    #[clippy::version = "1.49.0"]
     pub UNDROPPED_MANUALLY_DROPS,
     correctness,
     "use of safe `std::mem::drop` function to drop a std::mem::ManuallyDrop, which will not drop the inner value"
diff --git a/clippy_lints/src/unicode.rs b/clippy_lints/src/unicode.rs
index f49ce696a04..a514e8c44e2 100644
--- a/clippy_lints/src/unicode.rs
+++ b/clippy_lints/src/unicode.rs
@@ -20,6 +20,7 @@ declare_clippy_lint! {
     /// ### Example
     /// You don't see it, but there may be a zero-width space or soft hyphen
     /// some­where in this text.
+    #[clippy::version = "1.49.0"]
     pub INVISIBLE_CHARACTERS,
     correctness,
     "using an invisible character in a string literal, which is confusing"
@@ -44,6 +45,7 @@ declare_clippy_lint! {
     /// ```rust
     /// let x = String::from("\u{20ac}");
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub NON_ASCII_LITERAL,
     restriction,
     "using any literal non-ASCII chars in a string literal instead of using the `\\u` escape"
@@ -62,6 +64,7 @@ declare_clippy_lint! {
     /// ### Example
     /// You may not see it, but "à"" and "à"" aren't the same string. The
     /// former when escaped is actually `"a\u{300}"` while the latter is `"\u{e0}"`.
+    #[clippy::version = "pre 1.29.0"]
     pub UNICODE_NOT_NFC,
     pedantic,
     "using a Unicode literal not in NFC normal form (see [Unicode tr15](http://www.unicode.org/reports/tr15/) for further information)"
diff --git a/clippy_lints/src/uninit_vec.rs b/clippy_lints/src/uninit_vec.rs
index f3e8b688105..46cc76b150e 100644
--- a/clippy_lints/src/uninit_vec.rs
+++ b/clippy_lints/src/uninit_vec.rs
@@ -52,6 +52,7 @@ declare_clippy_lint! {
     ///    // perform initialization with `remaining`
     ///    vec.set_len(...);  // Safe to call `set_len()` on initialized part
     ///    ```
+    #[clippy::version = "1.58.0"]
     pub UNINIT_VEC,
     correctness,
     "Vec with uninitialized data"
diff --git a/clippy_lints/src/unit_hash.rs b/clippy_lints/src/unit_hash.rs
index a3a3f2d41c7..26b4e0f58a8 100644
--- a/clippy_lints/src/unit_hash.rs
+++ b/clippy_lints/src/unit_hash.rs
@@ -39,6 +39,7 @@ declare_clippy_lint! {
     /// 	WithValue(x) => x.hash(&mut state),
     /// }
     /// ```
+    #[clippy::version = "1.58.0"]
     pub UNIT_HASH,
     correctness,
     "hashing a unit value, which does nothing"
diff --git a/clippy_lints/src/unit_return_expecting_ord.rs b/clippy_lints/src/unit_return_expecting_ord.rs
index db0f412f2a1..9fb8f236899 100644
--- a/clippy_lints/src/unit_return_expecting_ord.rs
+++ b/clippy_lints/src/unit_return_expecting_ord.rs
@@ -30,6 +30,7 @@ declare_clippy_lint! {
     /// let mut twins = vec!((1, 1), (2, 2));
     /// twins.sort_by_key(|x| { x.1; });
     /// ```
+    #[clippy::version = "1.47.0"]
     pub UNIT_RETURN_EXPECTING_ORD,
     correctness,
     "fn arguments of type Fn(...) -> Ord returning the unit type ()."
diff --git a/clippy_lints/src/unit_types/mod.rs b/clippy_lints/src/unit_types/mod.rs
index 66b1abbe50b..d9f5b53b413 100644
--- a/clippy_lints/src/unit_types/mod.rs
+++ b/clippy_lints/src/unit_types/mod.rs
@@ -21,6 +21,7 @@ declare_clippy_lint! {
     ///     1;
     /// };
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub LET_UNIT_VALUE,
     pedantic,
     "creating a `let` binding to a value of unit type, which usually can't be used afterwards"
@@ -68,6 +69,7 @@ declare_clippy_lint! {
     /// assert_eq!({ foo(); }, { bar(); });
     /// ```
     /// will always succeed
+    #[clippy::version = "pre 1.29.0"]
     pub UNIT_CMP,
     correctness,
     "comparing unit values"
@@ -88,6 +90,7 @@ declare_clippy_lint! {
     ///     baz(a);
     /// })
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub UNIT_ARG,
     complexity,
     "passing unit to a function"
diff --git a/clippy_lints/src/unnamed_address.rs b/clippy_lints/src/unnamed_address.rs
index 1eafdee0352..0bcafde658a 100644
--- a/clippy_lints/src/unnamed_address.rs
+++ b/clippy_lints/src/unnamed_address.rs
@@ -24,6 +24,7 @@ declare_clippy_lint! {
     ///     // ...
     /// }
     /// ```
+    #[clippy::version = "1.44.0"]
     pub FN_ADDRESS_COMPARISONS,
     correctness,
     "comparison with an address of a function item"
@@ -47,6 +48,7 @@ declare_clippy_lint! {
     ///     ...
     /// }
     /// ```
+    #[clippy::version = "1.44.0"]
     pub VTABLE_ADDRESS_COMPARISONS,
     correctness,
     "comparison with an address of a trait vtable"
diff --git a/clippy_lints/src/unnecessary_self_imports.rs b/clippy_lints/src/unnecessary_self_imports.rs
index 4cfd2df551f..839a4bdab09 100644
--- a/clippy_lints/src/unnecessary_self_imports.rs
+++ b/clippy_lints/src/unnecessary_self_imports.rs
@@ -26,6 +26,7 @@ declare_clippy_lint! {
     /// ```rust
     /// use std::io;
     /// ```
+    #[clippy::version = "1.53.0"]
     pub UNNECESSARY_SELF_IMPORTS,
     restriction,
     "imports ending in `::{self}`, which can be omitted"
diff --git a/clippy_lints/src/unnecessary_sort_by.rs b/clippy_lints/src/unnecessary_sort_by.rs
index 26b56e0f2f3..d024577f485 100644
--- a/clippy_lints/src/unnecessary_sort_by.rs
+++ b/clippy_lints/src/unnecessary_sort_by.rs
@@ -39,6 +39,7 @@ declare_clippy_lint! {
     /// # let mut vec: Vec<A> = Vec::new();
     /// vec.sort_by_key(|a| a.foo());
     /// ```
+    #[clippy::version = "1.46.0"]
     pub UNNECESSARY_SORT_BY,
     complexity,
     "Use of `Vec::sort_by` when `Vec::sort_by_key` or `Vec::sort` would be clearer"
diff --git a/clippy_lints/src/unnecessary_wraps.rs b/clippy_lints/src/unnecessary_wraps.rs
index fcfa8403177..1728533f18b 100644
--- a/clippy_lints/src/unnecessary_wraps.rs
+++ b/clippy_lints/src/unnecessary_wraps.rs
@@ -49,6 +49,7 @@ declare_clippy_lint! {
     ///     }
     /// }
     /// ```
+    #[clippy::version = "1.50.0"]
     pub UNNECESSARY_WRAPS,
     pedantic,
     "functions that only return `Ok` or `Some`"
diff --git a/clippy_lints/src/unnested_or_patterns.rs b/clippy_lints/src/unnested_or_patterns.rs
index d6cf7190abb..0bd151fed91 100644
--- a/clippy_lints/src/unnested_or_patterns.rs
+++ b/clippy_lints/src/unnested_or_patterns.rs
@@ -39,6 +39,7 @@ declare_clippy_lint! {
     ///     if let Some(0 | 2) = Some(0) {}
     /// }
     /// ```
+    #[clippy::version = "1.46.0"]
     pub UNNESTED_OR_PATTERNS,
     pedantic,
     "unnested or-patterns, e.g., `Foo(Bar) | Foo(Baz) instead of `Foo(Bar | Baz)`"
diff --git a/clippy_lints/src/unsafe_removed_from_name.rs b/clippy_lints/src/unsafe_removed_from_name.rs
index 3c694af2b9d..44b1989dbc6 100644
--- a/clippy_lints/src/unsafe_removed_from_name.rs
+++ b/clippy_lints/src/unsafe_removed_from_name.rs
@@ -21,6 +21,7 @@ declare_clippy_lint! {
     /// extern crate crossbeam;
     /// use crossbeam::{spawn_unsafe as spawn};
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub UNSAFE_REMOVED_FROM_NAME,
     style,
     "`unsafe` removed from API names on import"
diff --git a/clippy_lints/src/unused_async.rs b/clippy_lints/src/unused_async.rs
index f4808682b69..1ccb78425c2 100644
--- a/clippy_lints/src/unused_async.rs
+++ b/clippy_lints/src/unused_async.rs
@@ -29,6 +29,7 @@ declare_clippy_lint! {
     /// }
     /// let number_future = async { get_random_number_improved() };
     /// ```
+    #[clippy::version = "1.54.0"]
     pub UNUSED_ASYNC,
     pedantic,
     "finds async functions with no await statements"
diff --git a/clippy_lints/src/unused_io_amount.rs b/clippy_lints/src/unused_io_amount.rs
index 031b182bd2f..d4b5c9770a2 100644
--- a/clippy_lints/src/unused_io_amount.rs
+++ b/clippy_lints/src/unused_io_amount.rs
@@ -29,6 +29,7 @@ declare_clippy_lint! {
     ///     Ok(())
     /// }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub UNUSED_IO_AMOUNT,
     correctness,
     "unused written/read amount"
diff --git a/clippy_lints/src/unused_self.rs b/clippy_lints/src/unused_self.rs
index e7e249c79a2..fd9d5b52e50 100644
--- a/clippy_lints/src/unused_self.rs
+++ b/clippy_lints/src/unused_self.rs
@@ -29,6 +29,7 @@ declare_clippy_lint! {
     ///     fn method() {}
     /// }
     /// ```
+    #[clippy::version = "1.40.0"]
     pub UNUSED_SELF,
     pedantic,
     "methods that contain a `self` argument but don't use it"
diff --git a/clippy_lints/src/unused_unit.rs b/clippy_lints/src/unused_unit.rs
index 1164ac4938f..48c17fa2a40 100644
--- a/clippy_lints/src/unused_unit.rs
+++ b/clippy_lints/src/unused_unit.rs
@@ -28,6 +28,7 @@ declare_clippy_lint! {
     /// ```rust
     /// fn return_unit() {}
     /// ```
+    #[clippy::version = "1.31.0"]
     pub UNUSED_UNIT,
     style,
     "needless unit expression"
diff --git a/clippy_lints/src/unwrap.rs b/clippy_lints/src/unwrap.rs
index ebaa9dcbbf8..9e83cae79bc 100644
--- a/clippy_lints/src/unwrap.rs
+++ b/clippy_lints/src/unwrap.rs
@@ -39,6 +39,7 @@ declare_clippy_lint! {
     ///     do_something_with(value)
     /// }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub UNNECESSARY_UNWRAP,
     complexity,
     "checks for calls of `unwrap[_err]()` that cannot fail"
@@ -65,6 +66,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// This code will always panic. The if condition should probably be inverted.
+    #[clippy::version = "pre 1.29.0"]
     pub PANICKING_UNWRAP,
     correctness,
     "checks for calls of `unwrap[_err]()` that will always fail"
diff --git a/clippy_lints/src/unwrap_in_result.rs b/clippy_lints/src/unwrap_in_result.rs
index 6447e3fa2ca..994df85cb8a 100644
--- a/clippy_lints/src/unwrap_in_result.rs
+++ b/clippy_lints/src/unwrap_in_result.rs
@@ -51,6 +51,7 @@ declare_clippy_lint! {
     ///     Ok(())
     /// }
     /// ```
+    #[clippy::version = "1.48.0"]
     pub UNWRAP_IN_RESULT,
     restriction,
     "functions of type `Result<..>` or `Option`<...> that contain `expect()` or `unwrap()`"
diff --git a/clippy_lints/src/upper_case_acronyms.rs b/clippy_lints/src/upper_case_acronyms.rs
index dbf335a70c8..4773e350760 100644
--- a/clippy_lints/src/upper_case_acronyms.rs
+++ b/clippy_lints/src/upper_case_acronyms.rs
@@ -33,6 +33,7 @@ declare_clippy_lint! {
     /// ```rust
     /// struct HttpResponse;
     /// ```
+    #[clippy::version = "1.51.0"]
     pub UPPER_CASE_ACRONYMS,
     style,
     "capitalized acronyms are against the naming convention"
diff --git a/clippy_lints/src/use_self.rs b/clippy_lints/src/use_self.rs
index 09aad296f03..059f7f647f8 100644
--- a/clippy_lints/src/use_self.rs
+++ b/clippy_lints/src/use_self.rs
@@ -51,6 +51,7 @@ declare_clippy_lint! {
     ///     }
     /// }
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub USE_SELF,
     nursery,
     "unnecessary structure name repetition whereas `Self` is applicable"
diff --git a/clippy_lints/src/useless_conversion.rs b/clippy_lints/src/useless_conversion.rs
index 88f11542072..0e4b32541c9 100644
--- a/clippy_lints/src/useless_conversion.rs
+++ b/clippy_lints/src/useless_conversion.rs
@@ -28,6 +28,7 @@ declare_clippy_lint! {
     /// // Good
     /// let s: String = format!("hello");
     /// ```
+    #[clippy::version = "1.45.0"]
     pub USELESS_CONVERSION,
     complexity,
     "calls to `Into`, `TryInto`, `From`, `TryFrom`, or `IntoIter` which perform useless conversions to the same type"
diff --git a/clippy_lints/src/vec.rs b/clippy_lints/src/vec.rs
index d3234b5758a..79e7410c3a8 100644
--- a/clippy_lints/src/vec.rs
+++ b/clippy_lints/src/vec.rs
@@ -36,6 +36,7 @@ declare_clippy_lint! {
     /// // Good
     /// foo(&[1, 2]);
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub USELESS_VEC,
     perf,
     "useless `vec!`"
diff --git a/clippy_lints/src/vec_init_then_push.rs b/clippy_lints/src/vec_init_then_push.rs
index b92b6ca4f43..1bc0eb6303c 100644
--- a/clippy_lints/src/vec_init_then_push.rs
+++ b/clippy_lints/src/vec_init_then_push.rs
@@ -27,6 +27,7 @@ declare_clippy_lint! {
     /// ```rust
     /// let v = vec![0];
     /// ```
+    #[clippy::version = "1.51.0"]
     pub VEC_INIT_THEN_PUSH,
     perf,
     "`push` immediately after `Vec` creation"
diff --git a/clippy_lints/src/vec_resize_to_zero.rs b/clippy_lints/src/vec_resize_to_zero.rs
index 5c0429db6b8..3441d9ccdfa 100644
--- a/clippy_lints/src/vec_resize_to_zero.rs
+++ b/clippy_lints/src/vec_resize_to_zero.rs
@@ -20,6 +20,7 @@ declare_clippy_lint! {
     /// ```rust
     /// vec!(1, 2, 3, 4, 5).resize(0, 5)
     /// ```
+    #[clippy::version = "1.46.0"]
     pub VEC_RESIZE_TO_ZERO,
     correctness,
     "emptying a vector with `resize(0, an_int)` instead of `clear()` is probably an argument inversion mistake"
diff --git a/clippy_lints/src/verbose_file_reads.rs b/clippy_lints/src/verbose_file_reads.rs
index e07c12f4f16..ebdaff1e676 100644
--- a/clippy_lints/src/verbose_file_reads.rs
+++ b/clippy_lints/src/verbose_file_reads.rs
@@ -27,6 +27,7 @@ declare_clippy_lint! {
     /// # use std::fs;
     /// let mut bytes = fs::read("foo.txt").unwrap();
     /// ```
+    #[clippy::version = "1.44.0"]
     pub VERBOSE_FILE_READS,
     restriction,
     "use of `File::read_to_end` or `File::read_to_string`"
diff --git a/clippy_lints/src/wildcard_dependencies.rs b/clippy_lints/src/wildcard_dependencies.rs
index d0c98b6bd79..80d7b8a1b6d 100644
--- a/clippy_lints/src/wildcard_dependencies.rs
+++ b/clippy_lints/src/wildcard_dependencies.rs
@@ -20,6 +20,7 @@ declare_clippy_lint! {
     /// [dependencies]
     /// regex = "*"
     /// ```
+    #[clippy::version = "1.32.0"]
     pub WILDCARD_DEPENDENCIES,
     cargo,
     "wildcard dependencies being used"
diff --git a/clippy_lints/src/wildcard_imports.rs b/clippy_lints/src/wildcard_imports.rs
index 2f3e525fdcf..832da66a536 100644
--- a/clippy_lints/src/wildcard_imports.rs
+++ b/clippy_lints/src/wildcard_imports.rs
@@ -34,6 +34,7 @@ declare_clippy_lint! {
     /// use std::cmp::Ordering;
     /// foo(Ordering::Less)
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub ENUM_GLOB_USE,
     pedantic,
     "use items that import all variants of an enum"
@@ -86,6 +87,7 @@ declare_clippy_lint! {
     ///
     /// foo();
     /// ```
+    #[clippy::version = "1.43.0"]
     pub WILDCARD_IMPORTS,
     pedantic,
     "lint `use _::*` statements"
diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs
index 85d1f65c51f..1b3c15fdf23 100644
--- a/clippy_lints/src/write.rs
+++ b/clippy_lints/src/write.rs
@@ -31,6 +31,7 @@ declare_clippy_lint! {
     /// // Good
     /// println!();
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub PRINTLN_EMPTY_STRING,
     style,
     "using `println!(\"\")` with an empty string"
@@ -55,6 +56,7 @@ declare_clippy_lint! {
     /// # let name = "World";
     /// println!("Hello {}!", name);
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub PRINT_WITH_NEWLINE,
     style,
     "using `print!()` with a format string that ends in a single newline"
@@ -76,6 +78,7 @@ declare_clippy_lint! {
     /// ```rust
     /// println!("Hello world!");
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub PRINT_STDOUT,
     restriction,
     "printing on stdout"
@@ -97,6 +100,7 @@ declare_clippy_lint! {
     /// ```rust
     /// eprintln!("Hello world!");
     /// ```
+    #[clippy::version = "1.50.0"]
     pub PRINT_STDERR,
     restriction,
     "printing on stderr"
@@ -116,6 +120,7 @@ declare_clippy_lint! {
     /// # let foo = "bar";
     /// println!("{:?}", foo);
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub USE_DEBUG,
     restriction,
     "use of `Debug`-based formatting"
@@ -142,6 +147,7 @@ declare_clippy_lint! {
     /// ```rust
     /// println!("foo");
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub PRINT_LITERAL,
     style,
     "printing a literal with a format string"
@@ -165,6 +171,7 @@ declare_clippy_lint! {
     /// // Good
     /// writeln!(buf);
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub WRITELN_EMPTY_STRING,
     style,
     "using `writeln!(buf, \"\")` with an empty string"
@@ -191,6 +198,7 @@ declare_clippy_lint! {
     /// // Good
     /// writeln!(buf, "Hello {}!", name);
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub WRITE_WITH_NEWLINE,
     style,
     "using `write!()` with a format string that ends in a single newline"
@@ -219,6 +227,7 @@ declare_clippy_lint! {
     /// // Good
     /// writeln!(buf, "foo");
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub WRITE_LITERAL,
     style,
     "writing a literal with a format string"
diff --git a/clippy_lints/src/zero_div_zero.rs b/clippy_lints/src/zero_div_zero.rs
index e0746ce4d81..641681185a2 100644
--- a/clippy_lints/src/zero_div_zero.rs
+++ b/clippy_lints/src/zero_div_zero.rs
@@ -20,6 +20,7 @@ declare_clippy_lint! {
     /// // Good
     /// let nan = f32::NAN;
     /// ```
+    #[clippy::version = "pre 1.29.0"]
     pub ZERO_DIVIDED_BY_ZERO,
     complexity,
     "usage of `0.0 / 0.0` to obtain NaN instead of `f32::NAN` or `f64::NAN`"
diff --git a/clippy_lints/src/zero_sized_map_values.rs b/clippy_lints/src/zero_sized_map_values.rs
index aa6b2614bbc..eb8436a501d 100644
--- a/clippy_lints/src/zero_sized_map_values.rs
+++ b/clippy_lints/src/zero_sized_map_values.rs
@@ -36,6 +36,7 @@ declare_clippy_lint! {
     ///     todo!();
     /// }
     /// ```
+    #[clippy::version = "1.50.0"]
     pub ZERO_SIZED_MAP_VALUES,
     pedantic,
     "usage of map with zero-sized value type"
-- 
cgit 1.4.1-3-g733a5


From 9d9d06d5572b815ca934f0ad1c6a69e4791a85fd Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Thu, 21 Oct 2021 23:00:31 +0200
Subject: Add lint to check for invalid `clippy:version` attributes

---
 clippy_lints/src/lib.register_internal.rs          |  1 +
 clippy_lints/src/lib.register_lints.rs             |  2 +
 clippy_lints/src/misc_early/mod.rs                 |  1 +
 clippy_lints/src/utils/internal_lints.rs           | 70 +++++++++++++++++++++-
 .../src/utils/internal_lints/metadata_collector.rs | 25 ++------
 .../ui-internal/check_clippy_version_attribute.rs  | 69 +++++++++++++++++++++
 .../check_clippy_version_attribute.stderr          | 38 ++++++++++++
 7 files changed, 184 insertions(+), 22 deletions(-)
 create mode 100644 tests/ui-internal/check_clippy_version_attribute.rs
 create mode 100644 tests/ui-internal/check_clippy_version_attribute.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.register_internal.rs b/clippy_lints/src/lib.register_internal.rs
index c8c1e0262ab..d8f5db65c09 100644
--- a/clippy_lints/src/lib.register_internal.rs
+++ b/clippy_lints/src/lib.register_internal.rs
@@ -9,6 +9,7 @@ store.register_group(true, "clippy::internal", Some("clippy_internal"), vec![
     LintId::of(utils::internal_lints::DEFAULT_LINT),
     LintId::of(utils::internal_lints::IF_CHAIN_STYLE),
     LintId::of(utils::internal_lints::INTERNING_DEFINED_SYMBOL),
+    LintId::of(utils::internal_lints::INVALID_CLIPPY_VERSION_ATTRIBUTE),
     LintId::of(utils::internal_lints::INVALID_PATHS),
     LintId::of(utils::internal_lints::LINT_WITHOUT_LINT_PASS),
     LintId::of(utils::internal_lints::MATCH_TYPE_ON_DIAGNOSTIC_ITEM),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 2cb86418e3c..588debd26c6 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -16,6 +16,8 @@ store.register_lints(&[
     #[cfg(feature = "internal-lints")]
     utils::internal_lints::INTERNING_DEFINED_SYMBOL,
     #[cfg(feature = "internal-lints")]
+    utils::internal_lints::INVALID_CLIPPY_VERSION_ATTRIBUTE,
+    #[cfg(feature = "internal-lints")]
     utils::internal_lints::INVALID_PATHS,
     #[cfg(feature = "internal-lints")]
     utils::internal_lints::LINT_WITHOUT_LINT_PASS,
diff --git a/clippy_lints/src/misc_early/mod.rs b/clippy_lints/src/misc_early/mod.rs
index 4b56eaebaea..6e09e25109f 100644
--- a/clippy_lints/src/misc_early/mod.rs
+++ b/clippy_lints/src/misc_early/mod.rs
@@ -156,6 +156,7 @@ declare_clippy_lint! {
     /// // Good
     /// let y = 123832i32;
     /// ```
+    #[clippy::version = "1.58.0"]
     pub SEPARATED_LITERAL_SUFFIX,
     restriction,
     "literals whose suffix is separated by an underscore"
diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs
index 824ec53ab9c..aa722758859 100644
--- a/clippy_lints/src/utils/internal_lints.rs
+++ b/clippy_lints/src/utils/internal_lints.rs
@@ -8,6 +8,7 @@ use clippy_utils::{
     paths, SpanlessEq,
 };
 use if_chain::if_chain;
+use rustc_ast as ast;
 use rustc_ast::ast::{Crate, ItemKind, LitKind, ModKind, NodeId};
 use rustc_ast::visit::FnKind;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
@@ -25,10 +26,11 @@ use rustc_lint::{EarlyContext, EarlyLintPass, LateContext, LateLintPass, LintCon
 use rustc_middle::hir::map::Map;
 use rustc_middle::mir::interpret::ConstValue;
 use rustc_middle::ty;
+use rustc_semver::RustcVersion;
 use rustc_session::{declare_lint_pass, declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::Spanned;
 use rustc_span::symbol::{Symbol, SymbolStr};
-use rustc_span::{BytePos, Span};
+use rustc_span::{sym, BytePos, Span};
 use rustc_typeck::hir_ty_to_ty;
 
 use std::borrow::{Borrow, Cow};
@@ -314,6 +316,26 @@ declare_clippy_lint! {
     "non-idiomatic `if_chain!` usage"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for invalid `clippy::version` attributes
+    ///
+    /// ```txt
+    /// +-------------------------------+
+    /// | Valid values are:             |
+    /// |  * "pre 1.29.0"               |
+    /// |  * any valid semantic version |
+    /// +-------------------------------+
+    ///                  \
+    ///                   \  (^v^)
+    ///                     <(   )>
+    ///                       w w
+    /// ```
+    pub INVALID_CLIPPY_VERSION_ATTRIBUTE,
+    internal,
+    "found an invalid `clippy::version` attribute"
+}
+
 declare_lint_pass!(ClippyLintsInternal => [CLIPPY_LINTS_INTERNAL]);
 
 impl EarlyLintPass for ClippyLintsInternal {
@@ -351,7 +373,7 @@ pub struct LintWithoutLintPass {
     registered_lints: FxHashSet<Symbol>,
 }
 
-impl_lint_pass!(LintWithoutLintPass => [DEFAULT_LINT, LINT_WITHOUT_LINT_PASS]);
+impl_lint_pass!(LintWithoutLintPass => [DEFAULT_LINT, LINT_WITHOUT_LINT_PASS, INVALID_CLIPPY_VERSION_ATTRIBUTE]);
 
 impl<'tcx> LateLintPass<'tcx> for LintWithoutLintPass {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
@@ -361,6 +383,8 @@ impl<'tcx> LateLintPass<'tcx> for LintWithoutLintPass {
 
         if let hir::ItemKind::Static(ty, Mutability::Not, body_id) = item.kind {
             if is_lint_ref_type(cx, ty) {
+                check_invalid_clippy_version_attribute(cx, item);
+
                 let expr = &cx.tcx.hir().body(body_id).value;
                 if_chain! {
                     if let ExprKind::AddrOf(_, _, inner_exp) = expr.kind;
@@ -458,6 +482,48 @@ fn is_lint_ref_type<'tcx>(cx: &LateContext<'tcx>, ty: &Ty<'_>) -> bool {
     false
 }
 
+fn check_invalid_clippy_version_attribute(cx: &LateContext<'_>, item: &'_ Item<'_>) {
+    if let Some(value) = extract_clippy_version_value(cx, item) {
+        // The `sym!` macro doesn't work as it only expects a single token. I think
+        // It's better to keep it this way and have a direct `Symbol::intern` call here :)
+        if value == Symbol::intern("pre 1.29.0") {
+            return;
+        }
+
+        if RustcVersion::parse(&*value.as_str()).is_err() {
+            span_lint_and_help(
+                cx,
+                INVALID_CLIPPY_VERSION_ATTRIBUTE,
+                item.span,
+                "this item has an invalid `clippy::version` attribute",
+                None,
+                "please use a valid sematic version, see `doc/adding_lints.md`",
+            );
+        }
+    }
+}
+
+/// This function extracts the version value of a `clippy::version` attribute if the given value has
+/// one
+fn extract_clippy_version_value(cx: &LateContext<'_>, item: &'_ Item<'_>) -> Option<Symbol> {
+    let attrs = cx.tcx.hir().attrs(item.hir_id());
+    attrs.iter().find_map(|attr| {
+        if_chain! {
+            // Identify attribute
+            if let ast::AttrKind::Normal(ref attr_kind, _) = &attr.kind;
+            if let [tool_name, attr_name] = &attr_kind.path.segments[..];
+            if tool_name.ident.name == sym::clippy;
+            if attr_name.ident.name == sym::version;
+            if let Some(version) = attr.value_str();
+            then {
+                Some(version)
+            } else {
+                None
+            }
+        }
+    })
+}
+
 struct LintCollector<'a, 'tcx> {
     output: &'a mut FxHashSet<Symbol>,
     cx: &'a LateContext<'tcx>,
diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index 70c3169c78e..8051c58bad7 100644
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -25,7 +25,7 @@ use std::fs::{self, OpenOptions};
 use std::io::prelude::*;
 use std::path::Path;
 
-use crate::utils::internal_lints::is_lint_ref_type;
+use crate::utils::internal_lints::{extract_clippy_version_value, is_lint_ref_type};
 use clippy_utils::{
     diagnostics::span_lint, last_path_segment, match_def_path, match_function_call, match_path, paths, ty::match_type,
     ty::walk_ptrs_ty_depth,
@@ -570,25 +570,10 @@ fn extract_attr_docs(cx: &LateContext<'_>, item: &Item<'_>) -> Option<String> {
 }
 
 fn get_lint_version(cx: &LateContext<'_>, item: &Item<'_>) -> String {
-    let attrs = cx.tcx.hir().attrs(item.hir_id());
-    attrs
-        .iter()
-        .find_map(|attr| {
-            if_chain! {
-                // Identify attribute
-                if let ast::AttrKind::Normal(ref attr_kind, _) = &attr.kind;
-                if let [tool_name, attr_name] = &attr_kind.path.segments[..];
-                if tool_name.ident.name == sym::clippy;
-                if attr_name.ident.name == sym::version;
-                if let Some(version) = attr.value_str();
-                then {
-                    Some(version.as_str().to_string())
-                } else {
-                    None
-                }
-            }
-        })
-        .unwrap_or_else(|| VERION_DEFAULT_STR.to_string())
+    extract_clippy_version_value(cx, item).map_or_else(
+        || VERION_DEFAULT_STR.to_string(),
+        |version| version.as_str().to_string(),
+    )
 }
 
 fn get_lint_group_and_level_or_lint(
diff --git a/tests/ui-internal/check_clippy_version_attribute.rs b/tests/ui-internal/check_clippy_version_attribute.rs
new file mode 100644
index 00000000000..e1b37d42174
--- /dev/null
+++ b/tests/ui-internal/check_clippy_version_attribute.rs
@@ -0,0 +1,69 @@
+#![deny(clippy::internal)]
+#![feature(rustc_private)]
+
+#[macro_use]
+extern crate rustc_middle;
+#[macro_use]
+extern crate rustc_session;
+extern crate rustc_lint;
+
+///////////////////////
+// Valid descriptions
+///////////////////////
+declare_tool_lint! {
+    #[clippy::version = "pre 1.29.0"]
+    pub clippy::VALID_ONE,
+    Warn,
+    "One",
+    report_in_external_macro: true
+}
+
+declare_tool_lint! {
+    #[clippy::version = "1.29.0"]
+    pub clippy::VALID_TWO,
+    Warn,
+    "Two",
+    report_in_external_macro: true
+}
+
+declare_tool_lint! {
+    #[clippy::version = "1.59.0"]
+    pub clippy::VALID_THREE,
+    Warn,
+    "Three",
+    report_in_external_macro: true
+}
+
+///////////////////////
+// Invalid attributes
+///////////////////////
+declare_tool_lint! {
+    #[clippy::version = "1.2.3.4.5.6"]
+    pub clippy::INVALID_ONE,
+    Warn,
+    "One",
+    report_in_external_macro: true
+}
+
+declare_tool_lint! {
+    #[clippy::version = "I'm a string"]
+    pub clippy::INVALID_TWO,
+    Warn,
+    "Two",
+    report_in_external_macro: true
+}
+
+///////////////////////
+// Ignored attributes
+///////////////////////
+declare_tool_lint! {
+    #[clippy::version]
+    pub clippy::IGNORED_ONE,
+    Warn,
+    "ONE",
+    report_in_external_macro: true
+}
+
+declare_lint_pass!(Pass2 => [VALID_ONE, VALID_TWO, VALID_THREE, INVALID_ONE, INVALID_TWO, IGNORED_ONE]);
+
+fn main() {}
diff --git a/tests/ui-internal/check_clippy_version_attribute.stderr b/tests/ui-internal/check_clippy_version_attribute.stderr
new file mode 100644
index 00000000000..fa697ab7425
--- /dev/null
+++ b/tests/ui-internal/check_clippy_version_attribute.stderr
@@ -0,0 +1,38 @@
+error: this item has an invalid `clippy::version` attribute
+  --> $DIR/check_clippy_version_attribute.rs:40:1
+   |
+LL | / declare_tool_lint! {
+LL | |     #[clippy::version = "1.2.3.4.5.6"]
+LL | |     pub clippy::INVALID_ONE,
+LL | |     Warn,
+LL | |     "One",
+LL | |     report_in_external_macro: true
+LL | | }
+   | |_^
+   |
+note: the lint level is defined here
+  --> $DIR/check_clippy_version_attribute.rs:1:9
+   |
+LL | #![deny(clippy::internal)]
+   |         ^^^^^^^^^^^^^^^^
+   = note: `#[deny(clippy::invalid_clippy_version_attribute)]` implied by `#[deny(clippy::internal)]`
+   = help: please use a valid sematic version, see `doc/adding_lints.md`
+   = note: this error originates in the macro `$crate::declare_tool_lint` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: this item has an invalid `clippy::version` attribute
+  --> $DIR/check_clippy_version_attribute.rs:48:1
+   |
+LL | / declare_tool_lint! {
+LL | |     #[clippy::version = "I'm a string"]
+LL | |     pub clippy::INVALID_TWO,
+LL | |     Warn,
+LL | |     "Two",
+LL | |     report_in_external_macro: true
+LL | | }
+   | |_^
+   |
+   = help: please use a valid sematic version, see `doc/adding_lints.md`
+   = note: this error originates in the macro `$crate::declare_tool_lint` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 94bc0a1c78f306186c830f716903e021c8ab7088 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Wed, 10 Nov 2021 20:08:38 +0100
Subject: Address review feedback

---
 clippy_dev/Cargo.toml                    |  2 +-
 clippy_dev/src/new_lint.rs               |  2 +-
 clippy_lints/src/utils/internal_lints.rs | 20 ++++++--------------
 3 files changed, 8 insertions(+), 16 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_dev/Cargo.toml b/clippy_dev/Cargo.toml
index 08cf756c77c..d350d9a0018 100644
--- a/clippy_dev/Cargo.toml
+++ b/clippy_dev/Cargo.toml
@@ -12,7 +12,7 @@ opener = "0.5"
 regex = "1.5"
 shell-escape = "0.1"
 walkdir = "2.3"
-cargo_metadata = "0.12"
+cargo_metadata = "0.14"
 
 [features]
 deny-warnings = []
diff --git a/clippy_dev/src/new_lint.rs b/clippy_dev/src/new_lint.rs
index a14dc360138..59658b42c79 100644
--- a/clippy_dev/src/new_lint.rs
+++ b/clippy_dev/src/new_lint.rs
@@ -141,7 +141,7 @@ fn get_stabilisation_version() -> String {
         }
     }
 
-    String::from("<TODO set version(see doc/adding_lints.md)")
+    String::from("<TODO set version(see doc/adding_lints.md)>")
 }
 
 fn get_test_file_contents(lint_name: &str, header_commands: Option<&str>) -> String {
diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs
index aa722758859..c20bd4ca38f 100644
--- a/clippy_lints/src/utils/internal_lints.rs
+++ b/clippy_lints/src/utils/internal_lints.rs
@@ -318,19 +318,11 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for invalid `clippy::version` attributes
+    /// Checks for invalid `clippy::version` attributes.
     ///
-    /// ```txt
-    /// +-------------------------------+
-    /// | Valid values are:             |
-    /// |  * "pre 1.29.0"               |
-    /// |  * any valid semantic version |
-    /// +-------------------------------+
-    ///                  \
-    ///                   \  (^v^)
-    ///                     <(   )>
-    ///                       w w
-    /// ```
+    /// Valid values are:
+    /// * "pre 1.29.0"
+    /// * any valid semantic version
     pub INVALID_CLIPPY_VERSION_ATTRIBUTE,
     internal,
     "found an invalid `clippy::version` attribute"
@@ -484,8 +476,8 @@ fn is_lint_ref_type<'tcx>(cx: &LateContext<'tcx>, ty: &Ty<'_>) -> bool {
 
 fn check_invalid_clippy_version_attribute(cx: &LateContext<'_>, item: &'_ Item<'_>) {
     if let Some(value) = extract_clippy_version_value(cx, item) {
-        // The `sym!` macro doesn't work as it only expects a single token. I think
-        // It's better to keep it this way and have a direct `Symbol::intern` call here :)
+        // The `sym!` macro doesn't work as it only expects a single token.
+        // It's better to keep it this way and have a direct `Symbol::intern` call here.
         if value == Symbol::intern("pre 1.29.0") {
             return;
         }
-- 
cgit 1.4.1-3-g733a5


From ce01346ac1168272c2ec2d4c272fbc1f27f39aae Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Mon, 8 Nov 2021 17:05:37 -0600
Subject: author: name qpath consistently

---
 clippy_lints/src/utils/author.rs  | 12 ++++++------
 tests/ui/author.stdout            |  4 ++--
 tests/ui/author/blocks.stdout     | 20 ++++++++++----------
 tests/ui/author/call.stdout       |  4 ++--
 tests/ui/author/if.stdout         |  4 ++--
 tests/ui/author/issue_3849.stdout |  8 ++++----
 tests/ui/author/loop.stdout       | 24 ++++++++++++------------
 tests/ui/author/matches.stdout    |  4 ++--
 tests/ui/author/struct.stdout     | 16 ++++++++--------
 9 files changed, 48 insertions(+), 48 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/author.rs b/clippy_lints/src/utils/author.rs
index 38157cc16ef..26b2a89d2ce 100644
--- a/clippy_lints/src/utils/author.rs
+++ b/clippy_lints/src/utils/author.rs
@@ -569,7 +569,7 @@ impl<'a, 'tcx> Visitor<'tcx> for PrintVisitor<'a, '_> {
             ExprKind::Cast(expr, ty) => {
                 let cast_pat = self.next("expr");
                 let cast_ty = self.next("cast_ty");
-                let qp_label = self.next("qp");
+                let qp_label = self.next("qpath");
 
                 println!("Cast(ref {}, ref {}) = {};", cast_pat, cast_ty, current);
 
@@ -717,7 +717,7 @@ impl<'a, 'tcx> Visitor<'tcx> for PrintVisitor<'a, '_> {
                 self.visit_expr(index);
             },
             ExprKind::Path(ref path) => {
-                let path_pat = self.next("path");
+                let path_pat = self.next("qpath");
 
                 println!("Path(ref {}) = {};", path_pat, current);
 
@@ -780,7 +780,7 @@ impl<'a, 'tcx> Visitor<'tcx> for PrintVisitor<'a, '_> {
                 println!("    // unimplemented: `ExprKind::LlvmInlineAsm` is not further destructured at the moment");
             },
             ExprKind::Struct(path, fields, ref opt_base) => {
-                let path_pat = self.next("path");
+                let path_pat = self.next("qpath");
                 let fields_pat = self.next("fields");
 
                 if let Some(base) = *opt_base {
@@ -895,7 +895,7 @@ impl<'a, 'tcx> Visitor<'tcx> for PrintVisitor<'a, '_> {
                 println!("    if {}.as_str() == \"{}\";", name_pat, ident.as_str());
             },
             PatKind::Struct(ref path, fields, ignore) => {
-                let path_pat = self.next("path");
+                let path_pat = self.next("qpath");
                 let fields_pat = self.next("fields");
                 println!(
                     "Struct(ref {}, ref {}, {}) = {};",
@@ -930,7 +930,7 @@ impl<'a, 'tcx> Visitor<'tcx> for PrintVisitor<'a, '_> {
                 }
             },
             PatKind::TupleStruct(ref path, fields, skip_pos) => {
-                let path_pat = self.next("path");
+                let path_pat = self.next("qpath");
                 let fields_pat = self.next("fields");
 
                 println!(
@@ -949,7 +949,7 @@ impl<'a, 'tcx> Visitor<'tcx> for PrintVisitor<'a, '_> {
                 }
             },
             PatKind::Path(ref path) => {
-                let path_pat = self.next("path");
+                let path_pat = self.next("qpath");
                 println!("Path(ref {}) = {};", path_pat, current);
 
                 self.current = path_pat;
diff --git a/tests/ui/author.stdout b/tests/ui/author.stdout
index 313597bf534..4931270bea8 100644
--- a/tests/ui/author.stdout
+++ b/tests/ui/author.stdout
@@ -2,8 +2,8 @@ if_chain! {
     if let StmtKind::Local(ref local) = stmt.kind;
     if let Some(ref init) = local.init;
     if let ExprKind::Cast(ref expr, ref cast_ty) = init.kind;
-    if let TyKind::Path(ref qp) = cast_ty.kind;
-    if match_qpath(qp, &["char"]);
+    if let TyKind::Path(ref qpath) = cast_ty.kind;
+    if match_qpath(qpath, &["char"]);
     if let ExprKind::Lit(ref lit) = expr.kind;
     if let LitKind::Int(69, LitIntType::Unsuffixed) = lit.node;
     if let PatKind::Binding(BindingAnnotation::Unannotated, _, name, None) = local.pat.kind;
diff --git a/tests/ui/author/blocks.stdout b/tests/ui/author/blocks.stdout
index 31c7fced7f7..3454d2bd69c 100644
--- a/tests/ui/author/blocks.stdout
+++ b/tests/ui/author/blocks.stdout
@@ -15,8 +15,8 @@ if_chain! {
     if name1.as_str() == "_t";
     if let StmtKind::Semi(ref e, _) = block.stmts[2].kind
     if let ExprKind::Unary(UnOp::Neg, ref inner) = e.kind;
-    if let ExprKind::Path(ref path) = inner.kind;
-    if match_qpath(path, &["x"]);
+    if let ExprKind::Path(ref qpath) = inner.kind;
+    if match_qpath(qpath, &["x"]);
     if block.expr.is_none();
     then {
         // report your lint here
@@ -28,18 +28,18 @@ if_chain! {
     if let StmtKind::Local(ref local) = block.stmts[0].kind;
     if let Some(ref init) = local.init;
     if let ExprKind::Call(ref func, ref args) = init.kind;
-    if let ExprKind::Path(ref path) = func.kind;
-    if match_qpath(path, &["String", "new"]);
+    if let ExprKind::Path(ref qpath) = func.kind;
+    if match_qpath(qpath, &["String", "new"]);
     if args.len() == 0;
     if let PatKind::Binding(BindingAnnotation::Unannotated, _, name, None) = local.pat.kind;
     if name.as_str() == "expr";
     if let Some(trailing_expr) = &block.expr;
     if let ExprKind::Call(ref func1, ref args1) = trailing_expr.kind;
-    if let ExprKind::Path(ref path1) = func1.kind;
-    if match_qpath(path1, &["drop"]);
+    if let ExprKind::Path(ref qpath1) = func1.kind;
+    if match_qpath(qpath1, &["drop"]);
     if args1.len() == 1;
-    if let ExprKind::Path(ref path2) = args1[0].kind;
-    if match_qpath(path2, &["expr"]);
+    if let ExprKind::Path(ref qpath2) = args1[0].kind;
+    if match_qpath(qpath2, &["expr"]);
     then {
         // report your lint here
     }
@@ -49,8 +49,8 @@ if_chain! {
     if let FnRetTy::DefaultReturn(_) = fn_decl.output
     let body = cx.tcx.hir().body(body_id);
     if let ExprKind::Call(ref func, ref args) = body.value.kind;
-    if let ExprKind::Path(ref path) = func.kind;
-    if matches!(path, QPath::LangItem(LangItem::FromGenerator, _));
+    if let ExprKind::Path(ref qpath) = func.kind;
+    if matches!(qpath, QPath::LangItem(LangItem::FromGenerator, _));
     if args.len() == 1;
     if let ExprKind::Closure(CaptureBy::Value, ref fn_decl1, ref body_id1, _, Some(Movability::Static)) = args[0].kind
     if let FnRetTy::DefaultReturn(_) = fn_decl1.output
diff --git a/tests/ui/author/call.stdout b/tests/ui/author/call.stdout
index 07958dbc356..7bce2bb84f2 100644
--- a/tests/ui/author/call.stdout
+++ b/tests/ui/author/call.stdout
@@ -2,8 +2,8 @@ if_chain! {
     if let StmtKind::Local(ref local) = stmt.kind;
     if let Some(ref init) = local.init;
     if let ExprKind::Call(ref func, ref args) = init.kind;
-    if let ExprKind::Path(ref path) = func.kind;
-    if match_qpath(path, &["{{root}}", "std", "cmp", "min"]);
+    if let ExprKind::Path(ref qpath) = func.kind;
+    if match_qpath(qpath, &["{{root}}", "std", "cmp", "min"]);
     if args.len() == 2;
     if let ExprKind::Lit(ref lit) = args[0].kind;
     if let LitKind::Int(3, LitIntType::Unsuffixed) = lit.node;
diff --git a/tests/ui/author/if.stdout b/tests/ui/author/if.stdout
index 7e72a548011..6acdbee176a 100644
--- a/tests/ui/author/if.stdout
+++ b/tests/ui/author/if.stdout
@@ -34,8 +34,8 @@ if_chain! {
     if let PatKind::Lit(ref lit_expr) = let_pat.kind
     if let ExprKind::Lit(ref lit) = lit_expr.kind;
     if let LitKind::Bool(true) = lit.node;
-    if let ExprKind::Path(ref path) = let_expr.kind;
-    if match_qpath(path, &["a"]);
+    if let ExprKind::Path(ref qpath) = let_expr.kind;
+    if match_qpath(qpath, &["a"]);
     if let ExprKind::Block(ref block, ref label) = if_then.kind;
     if block.stmts.len() == 0;
     if block.expr.is_none();
diff --git a/tests/ui/author/issue_3849.stdout b/tests/ui/author/issue_3849.stdout
index 65f93f3cdc0..769384d79c0 100644
--- a/tests/ui/author/issue_3849.stdout
+++ b/tests/ui/author/issue_3849.stdout
@@ -2,11 +2,11 @@ if_chain! {
     if let StmtKind::Local(ref local) = stmt.kind;
     if let Some(ref init) = local.init;
     if let ExprKind::Call(ref func, ref args) = init.kind;
-    if let ExprKind::Path(ref path) = func.kind;
-    if match_qpath(path, &["std", "mem", "transmute"]);
+    if let ExprKind::Path(ref qpath) = func.kind;
+    if match_qpath(qpath, &["std", "mem", "transmute"]);
     if args.len() == 1;
-    if let ExprKind::Path(ref path1) = args[0].kind;
-    if match_qpath(path1, &["ZPTR"]);
+    if let ExprKind::Path(ref qpath1) = args[0].kind;
+    if match_qpath(qpath1, &["ZPTR"]);
     if let PatKind::Wild = local.pat.kind;
     then {
         // report your lint here
diff --git a/tests/ui/author/loop.stdout b/tests/ui/author/loop.stdout
index fa146f03495..ce1720551c5 100644
--- a/tests/ui/author/loop.stdout
+++ b/tests/ui/author/loop.stdout
@@ -3,8 +3,8 @@ if_chain! {
     if let Some(higher::ForLoop { pat: pat, arg: arg, body: body, ..}) = higher::ForLoop::hir(expr)
     if let PatKind::Binding(BindingAnnotation::Unannotated, _, name, None) = pat.kind;
     if name.as_str() == "y";
-    if let ExprKind::Struct(ref path, ref fields, None) = arg.kind;
-    if matches!(path, QPath::LangItem(LangItem::Range, _));
+    if let ExprKind::Struct(ref qpath, ref fields, None) = arg.kind;
+    if matches!(qpath, QPath::LangItem(LangItem::Range, _));
     if fields.len() == 2;
     if fields[0].ident.name.as_str() == "start"
     if let ExprKind::Lit(ref lit) = fields[0].kind;
@@ -16,8 +16,8 @@ if_chain! {
     if block.stmts.len() == 1;
     if let StmtKind::Local(ref local) = block.stmts[0].kind;
     if let Some(ref init) = local.init;
-    if let ExprKind::Path(ref path1) = init.kind;
-    if match_qpath(path1, &["y"]);
+    if let ExprKind::Path(ref qpath1) = init.kind;
+    if match_qpath(qpath1, &["y"]);
     if let PatKind::Binding(BindingAnnotation::Unannotated, _, name1, None) = local.pat.kind;
     if name1.as_str() == "z";
     if block.expr.is_none();
@@ -29,8 +29,8 @@ if_chain! {
     if let ExprKind::DropTemps(ref expr) = expr.kind;
     if let Some(higher::ForLoop { pat: pat, arg: arg, body: body, ..}) = higher::ForLoop::hir(expr)
     if let PatKind::Wild = pat.kind;
-    if let ExprKind::Struct(ref path, ref fields, None) = arg.kind;
-    if matches!(path, QPath::LangItem(LangItem::Range, _));
+    if let ExprKind::Struct(ref qpath, ref fields, None) = arg.kind;
+    if matches!(qpath, QPath::LangItem(LangItem::Range, _));
     if fields.len() == 2;
     if fields[0].ident.name.as_str() == "start"
     if let ExprKind::Lit(ref lit) = fields[0].kind;
@@ -51,8 +51,8 @@ if_chain! {
     if let ExprKind::DropTemps(ref expr) = expr.kind;
     if let Some(higher::ForLoop { pat: pat, arg: arg, body: body, ..}) = higher::ForLoop::hir(expr)
     if let PatKind::Wild = pat.kind;
-    if let ExprKind::Struct(ref path, ref fields, None) = arg.kind;
-    if matches!(path, QPath::LangItem(LangItem::Range, _));
+    if let ExprKind::Struct(ref qpath, ref fields, None) = arg.kind;
+    if matches!(qpath, QPath::LangItem(LangItem::Range, _));
     if fields.len() == 2;
     if fields[0].ident.name.as_str() == "start"
     if let ExprKind::Lit(ref lit) = fields[0].kind;
@@ -73,8 +73,8 @@ if_chain! {
 }
 if_chain! {
     if let Some(higher::While { condition: condition, body: body }) = higher::While::hir(expr)
-    if let ExprKind::Path(ref path) = condition.kind;
-    if match_qpath(path, &["a"]);
+    if let ExprKind::Path(ref qpath) = condition.kind;
+    if match_qpath(qpath, &["a"]);
     if let ExprKind::Block(ref block, ref label) = body.kind;
     if block.stmts.len() == 1;
     if let StmtKind::Semi(ref e, _) = block.stmts[0].kind
@@ -89,8 +89,8 @@ if_chain! {
     if let PatKind::Lit(ref lit_expr) = let_pat.kind
     if let ExprKind::Lit(ref lit) = lit_expr.kind;
     if let LitKind::Bool(true) = lit.node;
-    if let ExprKind::Path(ref path) = let_expr.kind;
-    if match_qpath(path, &["a"]);
+    if let ExprKind::Path(ref qpath) = let_expr.kind;
+    if match_qpath(qpath, &["a"]);
     if let ExprKind::Block(ref block, ref label) = if_then.kind;
     if block.stmts.len() == 1;
     if let StmtKind::Semi(ref e, _) = block.stmts[0].kind
diff --git a/tests/ui/author/matches.stdout b/tests/ui/author/matches.stdout
index 3be61fe3772..b802b6bff86 100644
--- a/tests/ui/author/matches.stdout
+++ b/tests/ui/author/matches.stdout
@@ -19,8 +19,8 @@ if_chain! {
     if let PatKind::Binding(BindingAnnotation::Unannotated, _, name, None) = local1.pat.kind;
     if name.as_str() == "x";
     if let Some(trailing_expr) = &block.expr;
-    if let ExprKind::Path(ref path) = trailing_expr.kind;
-    if match_qpath(path, &["x"]);
+    if let ExprKind::Path(ref qpath) = trailing_expr.kind;
+    if match_qpath(qpath, &["x"]);
     if let PatKind::Lit(ref lit_expr1) = arms[1].pat.kind
     if let ExprKind::Lit(ref lit4) = lit_expr1.kind;
     if let LitKind::Int(17, LitIntType::Unsuffixed) = lit4.node;
diff --git a/tests/ui/author/struct.stdout b/tests/ui/author/struct.stdout
index 98055d73779..52c708dc8fa 100644
--- a/tests/ui/author/struct.stdout
+++ b/tests/ui/author/struct.stdout
@@ -1,6 +1,6 @@
 if_chain! {
-    if let ExprKind::Struct(ref path, ref fields, None) = expr.kind;
-    if match_qpath(path, &["Test"]);
+    if let ExprKind::Struct(ref qpath, ref fields, None) = expr.kind;
+    if match_qpath(qpath, &["Test"]);
     if fields.len() == 1;
     if fields[0].ident.name.as_str() == "field"
     if let Some(higher::If { cond: cond, then: then, r#else: else_expr}) = higher::If::hir(fields[0])
@@ -21,8 +21,8 @@ if_chain! {
     }
 }
 if_chain! {
-    if let PatKind::Struct(ref path, ref fields, false) = arm.kind;
-    if match_qpath(path, &["Test"]);
+    if let PatKind::Struct(ref qpath, ref fields, false) = arm.kind;
+    if match_qpath(qpath, &["Test"]);
     if fields.len() == 1;
     if fields[0].ident.name.as_str() == "field"
     if let PatKind::Lit(ref lit_expr) = fields[0].kind
@@ -36,8 +36,8 @@ if_chain! {
     }
 }
 if_chain! {
-    if let PatKind::TupleStruct(ref path, ref fields, None) = arm.kind;
-    if match_qpath(path, &["TestTuple"]);
+    if let PatKind::TupleStruct(ref qpath, ref fields, None) = arm.kind;
+    if match_qpath(qpath, &["TestTuple"]);
     if fields.len() == 1;
     if let PatKind::Lit(ref lit_expr) = fields[0].kind
     if let ExprKind::Lit(ref lit) = lit_expr.kind;
@@ -53,8 +53,8 @@ if_chain! {
     if let ExprKind::MethodCall(ref method_name, ref args, _) = expr.kind;
     if method_name.ident.name.as_str() == test;
     if args.len() == 1;
-    if let ExprKind::Path(ref path) = args[0].kind;
-    if match_qpath(path, &["test_method_call"]);
+    if let ExprKind::Path(ref qpath) = args[0].kind;
+    if match_qpath(qpath, &["test_method_call"]);
     then {
         // report your lint here
     }
-- 
cgit 1.4.1-3-g733a5


From d0cc201204644a2ccc0d9c9f5ff5ec44870cadc5 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Wed, 10 Nov 2021 15:42:49 -0600
Subject: author: fix some bugs

---
 clippy_lints/src/utils/author.rs | 34 +++++++++++++--------------
 tests/ui/author/blocks.stdout    | 10 ++++----
 tests/ui/author/if.stdout        | 10 ++++----
 tests/ui/author/loop.stdout      | 50 ++++++++++++++++++++--------------------
 tests/ui/author/matches.stdout   |  4 ++--
 tests/ui/author/struct.stdout    | 10 ++++----
 6 files changed, 59 insertions(+), 59 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/author.rs b/clippy_lints/src/utils/author.rs
index 26b2a89d2ce..3af90c5b1f4 100644
--- a/clippy_lints/src/utils/author.rs
+++ b/clippy_lints/src/utils/author.rs
@@ -196,7 +196,7 @@ impl<'a, 'tcx> PrintVisitor<'a, 'tcx> {
         if let Some(label) = label {
             let label_bind = self.next("label");
 
-            println!("    if let Some(ref {}) = {}", label_bind, self.current);
+            println!("    if let Some(ref {}) = {};", label_bind, self.current);
 
             let label_name_bind = self.next("label_name");
             let label_name = label.ident.name;
@@ -246,7 +246,7 @@ impl<'a, 'tcx> PrintVisitor<'a, 'tcx> {
                 let str_pat = self.next("s");
 
                 println!("    if let LitKind::Str(ref {}, _) = {}.node;", str_pat, lit_pat);
-                println!("    if {}.as_str() == {:?}", str_pat, &*text.as_str());
+                println!("    if {}.as_str() == {:?};", str_pat, &*text.as_str());
             },
         }
     }
@@ -311,7 +311,7 @@ impl<'a, 'tcx> PrintVisitor<'a, 'tcx> {
             let body_pat = self.next("body");
 
             println!(
-                "    if let Some(higher::While {{ condition: {}, body: {} }}) = higher::While::hir({})",
+                "    if let Some(higher::While {{ condition: {}, body: {} }}) = higher::While::hir({});",
                 condition_pat, body_pat, self.current
             );
 
@@ -335,7 +335,7 @@ impl<'a, 'tcx> PrintVisitor<'a, 'tcx> {
             let if_then_pat = self.next("if_then");
 
             println!(
-                "    if let Some(higher::WhileLet {{ let_pat: {}, let_expr: {}, if_then: {} }}) = higher::WhileLet::hir({})",
+                "    if let Some(higher::WhileLet {{ let_pat: {}, let_expr: {}, if_then: {} }}) = higher::WhileLet::hir({});",
                 let_pat_, let_expr_pat, if_then_pat, self.current
             );
 
@@ -364,7 +364,7 @@ impl<'a, 'tcx> PrintVisitor<'a, 'tcx> {
             let else_pat = self.next("else_expr");
 
             println!(
-                "    if let Some(higher::IfLet {{ let_pat: {}, let_expr: {}, if_then: {}, if_else: {}}}) = higher::IfLet::hir({})",
+                "    if let Some(higher::IfLet {{ let_pat: {}, let_expr: {}, if_then: {}, if_else: {}}}) = higher::IfLet::hir({});",
                 let_pat_, let_expr_pat, if_then_pat, else_pat, self.current
             );
 
@@ -391,7 +391,7 @@ impl<'a, 'tcx> PrintVisitor<'a, 'tcx> {
             let else_pat = self.next("else_expr");
 
             println!(
-                "    if let Some(higher::If {{ cond: {}, then: {}, r#else: {}}}) = higher::If::hir({})",
+                "    if let Some(higher::If {{ cond: {}, then: {}, r#else: {}}}) = higher::If::hir({});",
                 cond_pat, then_pat, else_pat, self.current
             );
 
@@ -415,7 +415,7 @@ impl<'a, 'tcx> PrintVisitor<'a, 'tcx> {
             let body_pat = self.next("body");
 
             println!(
-                "    if let Some(higher::ForLoop {{ pat: {}, arg: {}, body: {}, ..}}) = higher::ForLoop::hir({})",
+                "    if let Some(higher::ForLoop {{ pat: {}, arg: {}, body: {}, ..}}) = higher::ForLoop::hir({});",
                 pat_, arg_pat, body_pat, self.current
             );
 
@@ -596,7 +596,7 @@ impl<'a, 'tcx> Visitor<'tcx> for PrintVisitor<'a, '_> {
                 let label_pat = self.next("label");
 
                 println!(
-                    "Loop(ref {}, ref {}, LoopSource::{:?}) = {};",
+                    "Loop(ref {}, ref {}, LoopSource::{:?}, _) = {};",
                     body_pat, label_pat, des, current
                 );
 
@@ -626,10 +626,10 @@ impl<'a, 'tcx> Visitor<'tcx> for PrintVisitor<'a, '_> {
                 let body_id_pat = self.next("body_id");
 
                 println!(
-                    "Closure({}, ref {}, ref {}, _, {}) = {}",
+                    "Closure({}, ref {}, ref {}, _, {}) = {};",
                     capture_by, fn_decl_pat, body_id_pat, movability, current
                 );
-                println!("    if let {} = {}.output", ret_ty, fn_decl_pat);
+                println!("    if let {} = {}.output;", ret_ty, fn_decl_pat);
 
                 let hir = self.cx.tcx.hir();
                 let body = hir.body(body_id);
@@ -699,7 +699,7 @@ impl<'a, 'tcx> Visitor<'tcx> for PrintVisitor<'a, '_> {
                 let field_name_pat = self.next("field_name");
 
                 println!("Field(ref {}, ref {}) = {};", obj_pat, field_name_pat, current);
-                println!("    if {}.as_str() == {:?}", field_name_pat, field_ident.as_str());
+                println!("    if {}.as_str() == {:?};", field_name_pat, field_ident.as_str());
 
                 self.current = obj_pat;
                 self.visit_expr(object);
@@ -804,13 +804,13 @@ impl<'a, 'tcx> Visitor<'tcx> for PrintVisitor<'a, '_> {
 
                 for (i, field) in fields.iter().enumerate() {
                     println!(
-                        "    if {}[{}].ident.name.as_str() == {:?}",
+                        "    if {}[{}].ident.name.as_str() == {:?};",
                         fields_pat,
                         i,
                         &*field.ident.name.as_str()
                     );
 
-                    self.current = format!("{}[{}]", fields_pat, i);
+                    self.current = format!("{}[{}].expr", fields_pat, i);
                     self.visit_expr(field.expr);
                 }
             },
@@ -909,7 +909,7 @@ impl<'a, 'tcx> Visitor<'tcx> for PrintVisitor<'a, '_> {
 
                 for (i, field) in fields.iter().enumerate() {
                     println!(
-                        "    if {}[{}].ident.name.as_str() == {:?}",
+                        "    if {}[{}].ident.name.as_str() == {:?};",
                         fields_pat,
                         i,
                         &*field.ident.name.as_str()
@@ -981,7 +981,7 @@ impl<'a, 'tcx> Visitor<'tcx> for PrintVisitor<'a, '_> {
             },
             PatKind::Lit(lit_expr) => {
                 let lit_expr_pat = self.next("lit_expr");
-                println!("Lit(ref {}) = {}", lit_expr_pat, current);
+                println!("Lit(ref {}) = {};", lit_expr_pat, current);
 
                 self.current = lit_expr_pat;
                 self.visit_expr(lit_expr);
@@ -1063,7 +1063,7 @@ impl<'a, 'tcx> Visitor<'tcx> for PrintVisitor<'a, '_> {
             // Expr without trailing semi-colon (must have unit type):
             StmtKind::Expr(e) => {
                 let e_pat = self.next("e");
-                println!("Expr(ref {}, _) = {}", e_pat, current);
+                println!("Expr(ref {}, _) = {};", e_pat, current);
 
                 self.current = e_pat;
                 self.visit_expr(e);
@@ -1072,7 +1072,7 @@ impl<'a, 'tcx> Visitor<'tcx> for PrintVisitor<'a, '_> {
             // Expr with trailing semi-colon (may have any type):
             StmtKind::Semi(e) => {
                 let e_pat = self.next("e");
-                println!("Semi(ref {}, _) = {}", e_pat, current);
+                println!("Semi(ref {}) = {};", e_pat, current);
 
                 self.current = e_pat;
                 self.visit_expr(e);
diff --git a/tests/ui/author/blocks.stdout b/tests/ui/author/blocks.stdout
index 3454d2bd69c..d9bd738ae92 100644
--- a/tests/ui/author/blocks.stdout
+++ b/tests/ui/author/blocks.stdout
@@ -13,7 +13,7 @@ if_chain! {
     if let LitKind::Float(_, LitFloatType::Suffixed(FloatTy::F32)) = lit1.node;
     if let PatKind::Binding(BindingAnnotation::Unannotated, _, name1, None) = local1.pat.kind;
     if name1.as_str() == "_t";
-    if let StmtKind::Semi(ref e, _) = block.stmts[2].kind
+    if let StmtKind::Semi(ref e) = block.stmts[2].kind;
     if let ExprKind::Unary(UnOp::Neg, ref inner) = e.kind;
     if let ExprKind::Path(ref qpath) = inner.kind;
     if match_qpath(qpath, &["x"]);
@@ -45,15 +45,15 @@ if_chain! {
     }
 }
 if_chain! {
-    if let ExprKind::Closure(CaptureBy::Value, ref fn_decl, ref body_id, _, None) = expr.kind
-    if let FnRetTy::DefaultReturn(_) = fn_decl.output
+    if let ExprKind::Closure(CaptureBy::Value, ref fn_decl, ref body_id, _, None) = expr.kind;
+    if let FnRetTy::DefaultReturn(_) = fn_decl.output;
     let body = cx.tcx.hir().body(body_id);
     if let ExprKind::Call(ref func, ref args) = body.value.kind;
     if let ExprKind::Path(ref qpath) = func.kind;
     if matches!(qpath, QPath::LangItem(LangItem::FromGenerator, _));
     if args.len() == 1;
-    if let ExprKind::Closure(CaptureBy::Value, ref fn_decl1, ref body_id1, _, Some(Movability::Static)) = args[0].kind
-    if let FnRetTy::DefaultReturn(_) = fn_decl1.output
+    if let ExprKind::Closure(CaptureBy::Value, ref fn_decl1, ref body_id1, _, Some(Movability::Static)) = args[0].kind;
+    if let FnRetTy::DefaultReturn(_) = fn_decl1.output;
     let body1 = cx.tcx.hir().body(body_id1);
     if let ExprKind::Block(ref block, ref label) = body1.value.kind;
     if block.stmts.len() == 0;
diff --git a/tests/ui/author/if.stdout b/tests/ui/author/if.stdout
index 6acdbee176a..889d3e595ba 100644
--- a/tests/ui/author/if.stdout
+++ b/tests/ui/author/if.stdout
@@ -1,12 +1,12 @@
 if_chain! {
     if let StmtKind::Local(ref local) = stmt.kind;
     if let Some(ref init) = local.init;
-    if let Some(higher::If { cond: cond, then: then, r#else: else_expr}) = higher::If::hir(init)
+    if let Some(higher::If { cond: cond, then: then, r#else: else_expr}) = higher::If::hir(init);
     if let ExprKind::Lit(ref lit) = cond.kind;
     if let LitKind::Bool(true) = lit.node;
     if let ExprKind::Block(ref block, ref label) = then.kind;
     if block.stmts.len() == 1;
-    if let StmtKind::Semi(ref e, _) = block.stmts[0].kind
+    if let StmtKind::Semi(ref e) = block.stmts[0].kind;
     if let ExprKind::Binary(ref op, ref left, ref right) = e.kind;
     if BinOpKind::Eq == op.node;
     if let ExprKind::Lit(ref lit1) = left.kind;
@@ -16,7 +16,7 @@ if_chain! {
     if block.expr.is_none();
     if let ExprKind::Block(ref block1, ref label1) = else_expr.kind;
     if block1.stmts.len() == 1;
-    if let StmtKind::Semi(ref e1, _) = block1.stmts[0].kind
+    if let StmtKind::Semi(ref e1) = block1.stmts[0].kind;
     if let ExprKind::Binary(ref op1, ref left1, ref right1) = e1.kind;
     if BinOpKind::Eq == op1.node;
     if let ExprKind::Lit(ref lit3) = left1.kind;
@@ -30,8 +30,8 @@ if_chain! {
     }
 }
 if_chain! {
-    if let Some(higher::IfLet { let_pat: let_pat, let_expr: let_expr, if_then: if_then, if_else: else_expr}) = higher::IfLet::hir(expr)
-    if let PatKind::Lit(ref lit_expr) = let_pat.kind
+    if let Some(higher::IfLet { let_pat: let_pat, let_expr: let_expr, if_then: if_then, if_else: else_expr}) = higher::IfLet::hir(expr);
+    if let PatKind::Lit(ref lit_expr) = let_pat.kind;
     if let ExprKind::Lit(ref lit) = lit_expr.kind;
     if let LitKind::Bool(true) = lit.node;
     if let ExprKind::Path(ref qpath) = let_expr.kind;
diff --git a/tests/ui/author/loop.stdout b/tests/ui/author/loop.stdout
index ce1720551c5..9e7300335c5 100644
--- a/tests/ui/author/loop.stdout
+++ b/tests/ui/author/loop.stdout
@@ -1,16 +1,16 @@
 if_chain! {
     if let ExprKind::DropTemps(ref expr) = expr.kind;
-    if let Some(higher::ForLoop { pat: pat, arg: arg, body: body, ..}) = higher::ForLoop::hir(expr)
+    if let Some(higher::ForLoop { pat: pat, arg: arg, body: body, ..}) = higher::ForLoop::hir(expr);
     if let PatKind::Binding(BindingAnnotation::Unannotated, _, name, None) = pat.kind;
     if name.as_str() == "y";
     if let ExprKind::Struct(ref qpath, ref fields, None) = arg.kind;
     if matches!(qpath, QPath::LangItem(LangItem::Range, _));
     if fields.len() == 2;
-    if fields[0].ident.name.as_str() == "start"
-    if let ExprKind::Lit(ref lit) = fields[0].kind;
+    if fields[0].ident.name.as_str() == "start";
+    if let ExprKind::Lit(ref lit) = fields[0].expr.kind;
     if let LitKind::Int(0, LitIntType::Unsuffixed) = lit.node;
-    if fields[1].ident.name.as_str() == "end"
-    if let ExprKind::Lit(ref lit1) = fields[1].kind;
+    if fields[1].ident.name.as_str() == "end";
+    if let ExprKind::Lit(ref lit1) = fields[1].expr.kind;
     if let LitKind::Int(10, LitIntType::Unsuffixed) = lit1.node;
     if let ExprKind::Block(ref block, ref label) = body.kind;
     if block.stmts.len() == 1;
@@ -27,20 +27,20 @@ if_chain! {
 }
 if_chain! {
     if let ExprKind::DropTemps(ref expr) = expr.kind;
-    if let Some(higher::ForLoop { pat: pat, arg: arg, body: body, ..}) = higher::ForLoop::hir(expr)
+    if let Some(higher::ForLoop { pat: pat, arg: arg, body: body, ..}) = higher::ForLoop::hir(expr);
     if let PatKind::Wild = pat.kind;
     if let ExprKind::Struct(ref qpath, ref fields, None) = arg.kind;
     if matches!(qpath, QPath::LangItem(LangItem::Range, _));
     if fields.len() == 2;
-    if fields[0].ident.name.as_str() == "start"
-    if let ExprKind::Lit(ref lit) = fields[0].kind;
+    if fields[0].ident.name.as_str() == "start";
+    if let ExprKind::Lit(ref lit) = fields[0].expr.kind;
     if let LitKind::Int(0, LitIntType::Unsuffixed) = lit.node;
-    if fields[1].ident.name.as_str() == "end"
-    if let ExprKind::Lit(ref lit1) = fields[1].kind;
+    if fields[1].ident.name.as_str() == "end";
+    if let ExprKind::Lit(ref lit1) = fields[1].expr.kind;
     if let LitKind::Int(10, LitIntType::Unsuffixed) = lit1.node;
     if let ExprKind::Block(ref block, ref label) = body.kind;
     if block.stmts.len() == 1;
-    if let StmtKind::Semi(ref e, _) = block.stmts[0].kind
+    if let StmtKind::Semi(ref e) = block.stmts[0].kind;
     if let ExprKind::Break(ref destination, None) = e.kind;
     if block.expr.is_none();
     then {
@@ -49,22 +49,22 @@ if_chain! {
 }
 if_chain! {
     if let ExprKind::DropTemps(ref expr) = expr.kind;
-    if let Some(higher::ForLoop { pat: pat, arg: arg, body: body, ..}) = higher::ForLoop::hir(expr)
+    if let Some(higher::ForLoop { pat: pat, arg: arg, body: body, ..}) = higher::ForLoop::hir(expr);
     if let PatKind::Wild = pat.kind;
     if let ExprKind::Struct(ref qpath, ref fields, None) = arg.kind;
     if matches!(qpath, QPath::LangItem(LangItem::Range, _));
     if fields.len() == 2;
-    if fields[0].ident.name.as_str() == "start"
-    if let ExprKind::Lit(ref lit) = fields[0].kind;
+    if fields[0].ident.name.as_str() == "start";
+    if let ExprKind::Lit(ref lit) = fields[0].expr.kind;
     if let LitKind::Int(0, LitIntType::Unsuffixed) = lit.node;
-    if fields[1].ident.name.as_str() == "end"
-    if let ExprKind::Lit(ref lit1) = fields[1].kind;
+    if fields[1].ident.name.as_str() == "end";
+    if let ExprKind::Lit(ref lit1) = fields[1].expr.kind;
     if let LitKind::Int(10, LitIntType::Unsuffixed) = lit1.node;
     if let ExprKind::Block(ref block, ref label) = body.kind;
     if block.stmts.len() == 1;
-    if let StmtKind::Semi(ref e, _) = block.stmts[0].kind
+    if let StmtKind::Semi(ref e) = block.stmts[0].kind;
     if let ExprKind::Break(ref destination, None) = e.kind;
-    if let Some(ref label1) = destination.label
+    if let Some(ref label1) = destination.label;
     if label_name.ident.name.as_str() == "'label";
     if block.expr.is_none();
     then {
@@ -72,12 +72,12 @@ if_chain! {
     }
 }
 if_chain! {
-    if let Some(higher::While { condition: condition, body: body }) = higher::While::hir(expr)
+    if let Some(higher::While { condition: condition, body: body }) = higher::While::hir(expr);
     if let ExprKind::Path(ref qpath) = condition.kind;
     if match_qpath(qpath, &["a"]);
     if let ExprKind::Block(ref block, ref label) = body.kind;
     if block.stmts.len() == 1;
-    if let StmtKind::Semi(ref e, _) = block.stmts[0].kind
+    if let StmtKind::Semi(ref e) = block.stmts[0].kind;
     if let ExprKind::Break(ref destination, None) = e.kind;
     if block.expr.is_none();
     then {
@@ -85,15 +85,15 @@ if_chain! {
     }
 }
 if_chain! {
-    if let Some(higher::WhileLet { let_pat: let_pat, let_expr: let_expr, if_then: if_then }) = higher::WhileLet::hir(expr)
-    if let PatKind::Lit(ref lit_expr) = let_pat.kind
+    if let Some(higher::WhileLet { let_pat: let_pat, let_expr: let_expr, if_then: if_then }) = higher::WhileLet::hir(expr);
+    if let PatKind::Lit(ref lit_expr) = let_pat.kind;
     if let ExprKind::Lit(ref lit) = lit_expr.kind;
     if let LitKind::Bool(true) = lit.node;
     if let ExprKind::Path(ref qpath) = let_expr.kind;
     if match_qpath(qpath, &["a"]);
     if let ExprKind::Block(ref block, ref label) = if_then.kind;
     if block.stmts.len() == 1;
-    if let StmtKind::Semi(ref e, _) = block.stmts[0].kind
+    if let StmtKind::Semi(ref e) = block.stmts[0].kind;
     if let ExprKind::Break(ref destination, None) = e.kind;
     if block.expr.is_none();
     then {
@@ -101,9 +101,9 @@ if_chain! {
     }
 }
 if_chain! {
-    if let ExprKind::Loop(ref body, ref label, LoopSource::Loop) = expr.kind;
+    if let ExprKind::Loop(ref body, ref label, LoopSource::Loop, _) = expr.kind;
     if body.stmts.len() == 1;
-    if let StmtKind::Semi(ref e, _) = body.stmts[0].kind
+    if let StmtKind::Semi(ref e) = body.stmts[0].kind;
     if let ExprKind::Break(ref destination, None) = e.kind;
     if body.expr.is_none();
     then {
diff --git a/tests/ui/author/matches.stdout b/tests/ui/author/matches.stdout
index b802b6bff86..07d744a7723 100644
--- a/tests/ui/author/matches.stdout
+++ b/tests/ui/author/matches.stdout
@@ -7,7 +7,7 @@ if_chain! {
     if arms.len() == 3;
     if let ExprKind::Lit(ref lit1) = arms[0].body.kind;
     if let LitKind::Int(5, LitIntType::Unsuffixed) = lit1.node;
-    if let PatKind::Lit(ref lit_expr) = arms[0].pat.kind
+    if let PatKind::Lit(ref lit_expr) = arms[0].pat.kind;
     if let ExprKind::Lit(ref lit2) = lit_expr.kind;
     if let LitKind::Int(16, LitIntType::Unsuffixed) = lit2.node;
     if let ExprKind::Block(ref block, ref label) = arms[1].body.kind;
@@ -21,7 +21,7 @@ if_chain! {
     if let Some(trailing_expr) = &block.expr;
     if let ExprKind::Path(ref qpath) = trailing_expr.kind;
     if match_qpath(qpath, &["x"]);
-    if let PatKind::Lit(ref lit_expr1) = arms[1].pat.kind
+    if let PatKind::Lit(ref lit_expr1) = arms[1].pat.kind;
     if let ExprKind::Lit(ref lit4) = lit_expr1.kind;
     if let LitKind::Int(17, LitIntType::Unsuffixed) = lit4.node;
     if let ExprKind::Lit(ref lit5) = arms[2].body.kind;
diff --git a/tests/ui/author/struct.stdout b/tests/ui/author/struct.stdout
index 52c708dc8fa..66e6df195d2 100644
--- a/tests/ui/author/struct.stdout
+++ b/tests/ui/author/struct.stdout
@@ -2,8 +2,8 @@ if_chain! {
     if let ExprKind::Struct(ref qpath, ref fields, None) = expr.kind;
     if match_qpath(qpath, &["Test"]);
     if fields.len() == 1;
-    if fields[0].ident.name.as_str() == "field"
-    if let Some(higher::If { cond: cond, then: then, r#else: else_expr}) = higher::If::hir(fields[0])
+    if fields[0].ident.name.as_str() == "field";
+    if let Some(higher::If { cond: cond, then: then, r#else: else_expr}) = higher::If::hir(fields[0].expr);
     if let ExprKind::Lit(ref lit) = cond.kind;
     if let LitKind::Bool(true) = lit.node;
     if let ExprKind::Block(ref block, ref label) = then.kind;
@@ -24,8 +24,8 @@ if_chain! {
     if let PatKind::Struct(ref qpath, ref fields, false) = arm.kind;
     if match_qpath(qpath, &["Test"]);
     if fields.len() == 1;
-    if fields[0].ident.name.as_str() == "field"
-    if let PatKind::Lit(ref lit_expr) = fields[0].kind
+    if fields[0].ident.name.as_str() == "field";
+    if let PatKind::Lit(ref lit_expr) = fields[0].kind;
     if let ExprKind::Lit(ref lit) = lit_expr.kind;
     if let LitKind::Int(1, LitIntType::Unsuffixed) = lit.node;
     if let ExprKind::Block(ref block, ref label) = lit_expr.kind;
@@ -39,7 +39,7 @@ if_chain! {
     if let PatKind::TupleStruct(ref qpath, ref fields, None) = arm.kind;
     if match_qpath(qpath, &["TestTuple"]);
     if fields.len() == 1;
-    if let PatKind::Lit(ref lit_expr) = fields[0].kind
+    if let PatKind::Lit(ref lit_expr) = fields[0].kind;
     if let ExprKind::Lit(ref lit) = lit_expr.kind;
     if let LitKind::Int(1, LitIntType::Unsuffixed) = lit.node;
     if let ExprKind::Block(ref block, ref label) = lit_expr.kind;
-- 
cgit 1.4.1-3-g733a5


From a806ce79b63c74ad5f4225a1c27a03d418a85af4 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Mon, 8 Nov 2021 17:47:33 -0600
Subject: author: reorder match arm

---
 clippy_lints/src/utils/author.rs | 10 +++++-----
 tests/ui/author/matches.stdout   | 24 ++++++++++++------------
 2 files changed, 17 insertions(+), 17 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/author.rs b/clippy_lints/src/utils/author.rs
index 3af90c5b1f4..e0e3a3cf6bb 100644
--- a/clippy_lints/src/utils/author.rs
+++ b/clippy_lints/src/utils/author.rs
@@ -252,7 +252,7 @@ impl<'a, 'tcx> PrintVisitor<'a, 'tcx> {
     }
 
     fn print_match_expr(&mut self, expr: &Expr<'_>, arms: &[Arm<'_>], des: MatchSource, current: &str) {
-        let expr_pat = self.next("expr");
+        let expr_pat = self.next("scrutinee");
         let arms_pat = self.next("arms");
 
         println!(
@@ -266,8 +266,8 @@ impl<'a, 'tcx> PrintVisitor<'a, 'tcx> {
         println!("    if {}.len() == {};", arms_pat, arms.len());
 
         for (i, arm) in arms.iter().enumerate() {
-            self.current = format!("{}[{}].body", arms_pat, i);
-            self.visit_expr(arm.body);
+            self.current = format!("{}[{}].pat", arms_pat, i);
+            self.visit_pat(arm.pat);
 
             if let Some(ref guard) = arm.guard {
                 let guard_pat = self.next("guard");
@@ -300,8 +300,8 @@ impl<'a, 'tcx> PrintVisitor<'a, 'tcx> {
                     },
                 }
             }
-            self.current = format!("{}[{}].pat", arms_pat, i);
-            self.visit_pat(arm.pat);
+            self.current = format!("{}[{}].body", arms_pat, i);
+            self.visit_expr(arm.body);
         }
     }
 
diff --git a/tests/ui/author/matches.stdout b/tests/ui/author/matches.stdout
index 07d744a7723..56a955571dd 100644
--- a/tests/ui/author/matches.stdout
+++ b/tests/ui/author/matches.stdout
@@ -1,32 +1,32 @@
 if_chain! {
     if let StmtKind::Local(ref local) = stmt.kind;
     if let Some(ref init) = local.init;
-    if let ExprKind::Match(ref expr, ref arms, MatchSource::Normal) = init.kind;
-    if let ExprKind::Lit(ref lit) = expr.kind;
+    if let ExprKind::Match(ref scrutinee, ref arms, MatchSource::Normal) = init.kind;
+    if let ExprKind::Lit(ref lit) = scrutinee.kind;
     if let LitKind::Int(42, LitIntType::Unsuffixed) = lit.node;
     if arms.len() == 3;
-    if let ExprKind::Lit(ref lit1) = arms[0].body.kind;
-    if let LitKind::Int(5, LitIntType::Unsuffixed) = lit1.node;
     if let PatKind::Lit(ref lit_expr) = arms[0].pat.kind;
-    if let ExprKind::Lit(ref lit2) = lit_expr.kind;
-    if let LitKind::Int(16, LitIntType::Unsuffixed) = lit2.node;
+    if let ExprKind::Lit(ref lit1) = lit_expr.kind;
+    if let LitKind::Int(16, LitIntType::Unsuffixed) = lit1.node;
+    if let ExprKind::Lit(ref lit2) = arms[0].body.kind;
+    if let LitKind::Int(5, LitIntType::Unsuffixed) = lit2.node;
+    if let PatKind::Lit(ref lit_expr1) = arms[1].pat.kind;
+    if let ExprKind::Lit(ref lit3) = lit_expr1.kind;
+    if let LitKind::Int(17, LitIntType::Unsuffixed) = lit3.node;
     if let ExprKind::Block(ref block, ref label) = arms[1].body.kind;
     if block.stmts.len() == 1;
     if let StmtKind::Local(ref local1) = block.stmts[0].kind;
     if let Some(ref init1) = local1.init;
-    if let ExprKind::Lit(ref lit3) = init1.kind;
-    if let LitKind::Int(3, LitIntType::Unsuffixed) = lit3.node;
+    if let ExprKind::Lit(ref lit4) = init1.kind;
+    if let LitKind::Int(3, LitIntType::Unsuffixed) = lit4.node;
     if let PatKind::Binding(BindingAnnotation::Unannotated, _, name, None) = local1.pat.kind;
     if name.as_str() == "x";
     if let Some(trailing_expr) = &block.expr;
     if let ExprKind::Path(ref qpath) = trailing_expr.kind;
     if match_qpath(qpath, &["x"]);
-    if let PatKind::Lit(ref lit_expr1) = arms[1].pat.kind;
-    if let ExprKind::Lit(ref lit4) = lit_expr1.kind;
-    if let LitKind::Int(17, LitIntType::Unsuffixed) = lit4.node;
+    if let PatKind::Wild = arms[2].pat.kind;
     if let ExprKind::Lit(ref lit5) = arms[2].body.kind;
     if let LitKind::Int(1, LitIntType::Unsuffixed) = lit5.node;
-    if let PatKind::Wild = arms[2].pat.kind;
     if let PatKind::Binding(BindingAnnotation::Unannotated, _, name1, None) = local.pat.kind;
     if name1.as_str() == "a";
     then {
-- 
cgit 1.4.1-3-g733a5


From 72d7b9c097f5c9299a83ed7ec7ea97093400f92e Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Wed, 10 Nov 2021 15:59:49 -0600
Subject: author: Remove needless `ref`s

---
 clippy_lints/src/utils/author.rs  | 150 +++++++++++++++++---------------------
 tests/ui/author.stdout            |   6 +-
 tests/ui/author/blocks.stdout     |  34 ++++-----
 tests/ui/author/call.stdout       |   6 +-
 tests/ui/author/if.stdout         |  22 +++---
 tests/ui/author/issue_3849.stdout |   6 +-
 tests/ui/author/loop.stdout       |  52 ++++++-------
 tests/ui/author/matches.stdout    |  18 ++---
 tests/ui/author/repeat.stdout     |   2 +-
 tests/ui/author/struct.stdout     |  24 +++---
 10 files changed, 151 insertions(+), 169 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/author.rs b/clippy_lints/src/utils/author.rs
index e0e3a3cf6bb..79186fbe035 100644
--- a/clippy_lints/src/utils/author.rs
+++ b/clippy_lints/src/utils/author.rs
@@ -196,7 +196,7 @@ impl<'a, 'tcx> PrintVisitor<'a, 'tcx> {
         if let Some(label) = label {
             let label_bind = self.next("label");
 
-            println!("    if let Some(ref {}) = {};", label_bind, self.current);
+            println!("    if let Some({}) = {};", label_bind, self.current);
 
             let label_name_bind = self.next("label_name");
             let label_name = label.ident.name;
@@ -242,10 +242,10 @@ impl<'a, 'tcx> PrintVisitor<'a, 'tcx> {
                 println!("    if let LitKind::ByteStr(ref {}) = {}.node;", vec_pat, lit_pat);
                 println!("    if let [{:?}] = **{};", vec, vec_pat);
             },
-            LitKind::Str(ref text, _) => {
+            LitKind::Str(text, _) => {
                 let str_pat = self.next("s");
 
-                println!("    if let LitKind::Str(ref {}, _) = {}.node;", str_pat, lit_pat);
+                println!("    if let LitKind::Str({}, _) = {}.node;", str_pat, lit_pat);
                 println!("    if {}.as_str() == {:?};", str_pat, &*text.as_str());
             },
         }
@@ -256,7 +256,7 @@ impl<'a, 'tcx> PrintVisitor<'a, 'tcx> {
         let arms_pat = self.next("arms");
 
         println!(
-            "Match(ref {}, ref {}, MatchSource::{:?}) = {};",
+            "Match({}, {}, MatchSource::{:?}) = {};",
             expr_pat, arms_pat, des, current
         );
 
@@ -269,16 +269,16 @@ impl<'a, 'tcx> PrintVisitor<'a, 'tcx> {
             self.current = format!("{}[{}].pat", arms_pat, i);
             self.visit_pat(arm.pat);
 
-            if let Some(ref guard) = arm.guard {
+            if let Some(guard) = &arm.guard {
                 let guard_pat = self.next("guard");
 
-                println!("    if let Some(ref {}) = {}[{}].guard;", guard_pat, arms_pat, i);
+                println!("    if let Some({}) = &{}[{}].guard;", guard_pat, arms_pat, i);
 
                 match guard {
                     hir::Guard::If(if_expr) => {
                         let if_expr_pat = self.next("expr");
 
-                        println!("    if let Guard::If(ref {}) = {};", if_expr_pat, guard_pat);
+                        println!("    if let Guard::If({}) = {};", if_expr_pat, guard_pat);
 
                         self.current = if_expr_pat;
                         self.visit_expr(if_expr);
@@ -288,7 +288,7 @@ impl<'a, 'tcx> PrintVisitor<'a, 'tcx> {
                         let if_let_expr_pat = self.next("expr");
 
                         println!(
-                            "    if let Guard::IfLet(ref {}, ref {}) = {};",
+                            "    if let Guard::IfLet({}, {}) = {};",
                             if_let_pat_pat, if_let_expr_pat, guard_pat
                         );
 
@@ -461,7 +461,7 @@ impl<'a, 'tcx> Visitor<'tcx> for PrintVisitor<'a, '_> {
                 let let_pat = self.next("pat");
                 let let_expr = self.next("expr");
 
-                println!("Let(ref {}, ref {}, _) = {};", let_pat, let_expr, current);
+                println!("Let({}, {}, _) = {};", let_pat, let_expr, current);
 
                 self.current = let_expr;
                 self.visit_expr(expr);
@@ -472,7 +472,7 @@ impl<'a, 'tcx> Visitor<'tcx> for PrintVisitor<'a, '_> {
             ExprKind::Box(inner) => {
                 let inner_pat = self.next("inner");
 
-                println!("Box(ref {}) = {};", inner_pat, current);
+                println!("Box({}) = {};", inner_pat, current);
 
                 self.current = inner_pat;
                 self.visit_expr(inner);
@@ -480,7 +480,7 @@ impl<'a, 'tcx> Visitor<'tcx> for PrintVisitor<'a, '_> {
             ExprKind::Array(elements) => {
                 let elements_pat = self.next("elements");
 
-                println!("Array(ref {}) = {};", elements_pat, current);
+                println!("Array({}) = {};", elements_pat, current);
 
                 println!("    if {}.len() == {};", elements_pat, elements.len());
 
@@ -493,7 +493,7 @@ impl<'a, 'tcx> Visitor<'tcx> for PrintVisitor<'a, '_> {
                 let func_pat = self.next("func");
                 let args_pat = self.next("args");
 
-                println!("Call(ref {}, ref {}) = {};", func_pat, args_pat, current);
+                println!("Call({}, {}) = {};", func_pat, args_pat, current);
 
                 self.current = func_pat;
                 self.visit_expr(func);
@@ -509,10 +509,7 @@ impl<'a, 'tcx> Visitor<'tcx> for PrintVisitor<'a, '_> {
                 let method_name_pat = self.next("method_name");
                 let args_pat = self.next("args");
 
-                println!(
-                    "MethodCall(ref {}, ref {}, _) = {};",
-                    method_name_pat, args_pat, current
-                );
+                println!("MethodCall({}, _, {}, _) = {};", method_name_pat, args_pat, current);
 
                 println!(
                     "    if {}.ident.name.as_str() == {};",
@@ -530,7 +527,7 @@ impl<'a, 'tcx> Visitor<'tcx> for PrintVisitor<'a, '_> {
             ExprKind::Tup(elements) => {
                 let elements_pat = self.next("elements");
 
-                println!("Tup(ref {}) = {};", elements_pat, current);
+                println!("Tup({}) = {};", elements_pat, current);
 
                 println!("    if {}.len() == {};", elements_pat, elements.len());
 
@@ -539,15 +536,12 @@ impl<'a, 'tcx> Visitor<'tcx> for PrintVisitor<'a, '_> {
                     self.visit_expr(element);
                 }
             },
-            ExprKind::Binary(ref op, left, right) => {
+            ExprKind::Binary(op, left, right) => {
                 let op_pat = self.next("op");
                 let left_pat = self.next("left");
                 let right_pat = self.next("right");
 
-                println!(
-                    "Binary(ref {}, ref {}, ref {}) = {};",
-                    op_pat, left_pat, right_pat, current
-                );
+                println!("Binary({}, {}, {}) = {};", op_pat, left_pat, right_pat, current);
 
                 println!("    if BinOpKind::{:?} == {}.node;", op.node, op_pat);
 
@@ -557,10 +551,10 @@ impl<'a, 'tcx> Visitor<'tcx> for PrintVisitor<'a, '_> {
                 self.current = right_pat;
                 self.visit_expr(right);
             },
-            ExprKind::Unary(ref op, inner) => {
+            ExprKind::Unary(op, inner) => {
                 let inner_pat = self.next("inner");
 
-                println!("Unary(UnOp::{:?}, ref {}) = {};", op, inner_pat, current);
+                println!("Unary(UnOp::{:?}, {}) = {};", op, inner_pat, current);
 
                 self.current = inner_pat;
                 self.visit_expr(inner);
@@ -571,7 +565,7 @@ impl<'a, 'tcx> Visitor<'tcx> for PrintVisitor<'a, '_> {
                 let cast_ty = self.next("cast_ty");
                 let qp_label = self.next("qpath");
 
-                println!("Cast(ref {}, ref {}) = {};", cast_pat, cast_ty, current);
+                println!("Cast({}, {}) = {};", cast_pat, cast_ty, current);
 
                 if let TyKind::Path(ref qp) = ty.kind {
                     println!("    if let TyKind::Path(ref {}) = {}.kind;", qp_label, cast_ty);
@@ -586,7 +580,7 @@ impl<'a, 'tcx> Visitor<'tcx> for PrintVisitor<'a, '_> {
             ExprKind::Type(expr, _ty) => {
                 let cast_pat = self.next("expr");
 
-                println!("Type(ref {}, _) = {};", cast_pat, current);
+                println!("Type({}, _) = {};", cast_pat, current);
 
                 self.current = cast_pat;
                 self.visit_expr(expr);
@@ -596,7 +590,7 @@ impl<'a, 'tcx> Visitor<'tcx> for PrintVisitor<'a, '_> {
                 let label_pat = self.next("label");
 
                 println!(
-                    "Loop(ref {}, ref {}, LoopSource::{:?}, _) = {};",
+                    "Loop({}, {}, LoopSource::{:?}, _) = {};",
                     body_pat, label_pat, des, current
                 );
 
@@ -626,7 +620,7 @@ impl<'a, 'tcx> Visitor<'tcx> for PrintVisitor<'a, '_> {
                 let body_id_pat = self.next("body_id");
 
                 println!(
-                    "Closure({}, ref {}, ref {}, _, {}) = {};",
+                    "Closure({}, {}, {}, _, {}) = {};",
                     capture_by, fn_decl_pat, body_id_pat, movability, current
                 );
                 println!("    if let {} = {}.output;", ret_ty, fn_decl_pat);
@@ -644,7 +638,7 @@ impl<'a, 'tcx> Visitor<'tcx> for PrintVisitor<'a, '_> {
             ExprKind::Yield(sub, source) => {
                 let sub_pat = self.next("sub");
 
-                println!("Yield(ref sub, YieldSource::{:?}) = {};", source, current);
+                println!("Yield(sub, YieldSource::{:?}) = {};", source, current);
 
                 self.current = sub_pat;
                 self.visit_expr(sub);
@@ -653,7 +647,7 @@ impl<'a, 'tcx> Visitor<'tcx> for PrintVisitor<'a, '_> {
                 let block_pat = self.next("block");
                 let label_pat = self.next("label");
 
-                println!("Block(ref {}, ref {}) = {};", block_pat, label_pat, current);
+                println!("Block({}, {}) = {};", block_pat, label_pat, current);
 
                 self.current = block_pat;
                 self.visit_block(block);
@@ -665,10 +659,7 @@ impl<'a, 'tcx> Visitor<'tcx> for PrintVisitor<'a, '_> {
                 let target_pat = self.next("target");
                 let value_pat = self.next("value");
 
-                println!(
-                    "Assign(ref {}, ref {}, ref _span) = {};",
-                    target_pat, value_pat, current
-                );
+                println!("Assign({}, {}, _span) = {};", target_pat, value_pat, current);
 
                 self.current = target_pat;
                 self.visit_expr(target);
@@ -676,15 +667,12 @@ impl<'a, 'tcx> Visitor<'tcx> for PrintVisitor<'a, '_> {
                 self.current = value_pat;
                 self.visit_expr(value);
             },
-            ExprKind::AssignOp(ref op, target, value) => {
+            ExprKind::AssignOp(op, target, value) => {
                 let op_pat = self.next("op");
                 let target_pat = self.next("target");
                 let value_pat = self.next("value");
 
-                println!(
-                    "AssignOp(ref {}, ref {}, ref {}) = {};",
-                    op_pat, target_pat, value_pat, current
-                );
+                println!("AssignOp({}, {}, {}) = {};", op_pat, target_pat, value_pat, current);
 
                 println!("    if BinOpKind::{:?} == {}.node;", op.node, op_pat);
 
@@ -694,11 +682,11 @@ impl<'a, 'tcx> Visitor<'tcx> for PrintVisitor<'a, '_> {
                 self.current = value_pat;
                 self.visit_expr(value);
             },
-            ExprKind::Field(object, ref field_ident) => {
+            ExprKind::Field(object, field_ident) => {
                 let obj_pat = self.next("object");
                 let field_name_pat = self.next("field_name");
 
-                println!("Field(ref {}, ref {}) = {};", obj_pat, field_name_pat, current);
+                println!("Field({}, {}) = {};", obj_pat, field_name_pat, current);
                 println!("    if {}.as_str() == {:?};", field_name_pat, field_ident.as_str());
 
                 self.current = obj_pat;
@@ -708,7 +696,7 @@ impl<'a, 'tcx> Visitor<'tcx> for PrintVisitor<'a, '_> {
                 let object_pat = self.next("object");
                 let index_pat = self.next("index");
 
-                println!("Index(ref {}, ref {}) = {};", object_pat, index_pat, current);
+                println!("Index({}, {}) = {};", object_pat, index_pat, current);
 
                 self.current = object_pat;
                 self.visit_expr(object);
@@ -728,42 +716,42 @@ impl<'a, 'tcx> Visitor<'tcx> for PrintVisitor<'a, '_> {
                 let inner_pat = self.next("inner");
 
                 println!(
-                    "AddrOf(BorrowKind::{:?}, Mutability::{:?}, ref {}) = {};",
+                    "AddrOf(BorrowKind::{:?}, Mutability::{:?}, {}) = {};",
                     kind, mutability, inner_pat, current
                 );
 
                 self.current = inner_pat;
                 self.visit_expr(inner);
             },
-            ExprKind::Break(ref destination, ref opt_value) => {
+            ExprKind::Break(destination, opt_value) => {
                 let destination_pat = self.next("destination");
 
-                if let Some(value) = *opt_value {
+                if let Some(value) = opt_value {
                     let value_pat = self.next("value");
 
-                    println!("Break(ref {}, Some(ref {})) = {};", destination_pat, value_pat, current);
+                    println!("Break({}, Some({})) = {};", destination_pat, value_pat, current);
 
                     self.current = value_pat;
                     self.visit_expr(value);
                 } else {
-                    println!("Break(ref {}, None) = {};", destination_pat, current);
+                    println!("Break({}, None) = {};", destination_pat, current);
                 }
 
                 self.current = format!("{}.label", destination_pat);
                 self.print_label(destination.label);
             },
-            ExprKind::Continue(ref destination) => {
+            ExprKind::Continue(destination) => {
                 let destination_pat = self.next("destination");
-                println!("Continue(ref {}) = {};", destination_pat, current);
+                println!("Continue({}) = {};", destination_pat, current);
 
                 self.current = format!("{}.label", destination_pat);
                 self.print_label(destination.label);
             },
-            ExprKind::Ret(ref opt_value) => {
-                if let Some(value) = *opt_value {
+            ExprKind::Ret(opt_value) => {
+                if let Some(value) = opt_value {
                     let value_pat = self.next("value");
 
-                    println!("Ret(Some(ref {})) = {};", value_pat, current);
+                    println!("Ret(Some({})) = {};", value_pat, current);
 
                     self.current = value_pat;
                     self.visit_expr(value);
@@ -779,22 +767,22 @@ impl<'a, 'tcx> Visitor<'tcx> for PrintVisitor<'a, '_> {
                 println!("LlvmInlineAsm(_) = {};", current);
                 println!("    // unimplemented: `ExprKind::LlvmInlineAsm` is not further destructured at the moment");
             },
-            ExprKind::Struct(path, fields, ref opt_base) => {
+            ExprKind::Struct(path, fields, opt_base) => {
                 let path_pat = self.next("qpath");
                 let fields_pat = self.next("fields");
 
-                if let Some(base) = *opt_base {
+                if let Some(base) = opt_base {
                     let base_pat = self.next("base");
 
                     println!(
-                        "Struct(ref {}, ref {}, Some(ref {})) = {};",
+                        "Struct({}, {}, Some({})) = {};",
                         path_pat, fields_pat, base_pat, current
                     );
 
                     self.current = base_pat;
                     self.visit_expr(base);
                 } else {
-                    println!("Struct(ref {}, ref {}, None) = {};", path_pat, fields_pat, current);
+                    println!("Struct({}, {}, None) = {};", path_pat, fields_pat, current);
                 }
 
                 self.current = path_pat;
@@ -823,7 +811,7 @@ impl<'a, 'tcx> Visitor<'tcx> for PrintVisitor<'a, '_> {
                 let value_pat = self.next("value");
                 let length_pat = self.next("length");
 
-                println!("Repeat(ref {}, ref {}) = {};", value_pat, length_pat, current);
+                println!("Repeat({}, {}) = {};", value_pat, length_pat, current);
 
                 self.current = value_pat;
                 self.visit_expr(value);
@@ -840,7 +828,7 @@ impl<'a, 'tcx> Visitor<'tcx> for PrintVisitor<'a, '_> {
             ExprKind::DropTemps(expr) => {
                 let expr_pat = self.next("expr");
 
-                println!("DropTemps(ref {}) = {};", expr_pat, current);
+                println!("DropTemps({}) = {};", expr_pat, current);
 
                 self.current = expr_pat;
                 self.visit_expr(expr);
@@ -860,7 +848,7 @@ impl<'a, 'tcx> Visitor<'tcx> for PrintVisitor<'a, '_> {
 
         if let Some(expr) = block.expr {
             self.current = self.next("trailing_expr");
-            println!("    if let Some({}) = &{}.expr;", self.current, block_name);
+            println!("    if let Some({}) = {}.expr;", self.current, block_name);
             self.visit_expr(expr);
         } else {
             println!("    if {}.expr.is_none();", block_name);
@@ -874,15 +862,15 @@ impl<'a, 'tcx> Visitor<'tcx> for PrintVisitor<'a, '_> {
 
         match pat.kind {
             PatKind::Wild => println!("Wild = {};", current),
-            PatKind::Binding(anno, .., ident, ref sub) => {
+            PatKind::Binding(anno, .., ident, sub) => {
                 let anno_pat = &format!("BindingAnnotation::{:?}", anno);
                 let name_pat = self.next("name");
 
-                if let Some(sub) = *sub {
+                if let Some(sub) = sub {
                     let sub_pat = self.next("sub");
 
                     println!(
-                        "Binding({}, _, {}, Some(ref {})) = {};",
+                        "Binding({}, _, {}, Some({})) = {};",
                         anno_pat, name_pat, sub_pat, current
                     );
 
@@ -897,10 +885,7 @@ impl<'a, 'tcx> Visitor<'tcx> for PrintVisitor<'a, '_> {
             PatKind::Struct(ref path, fields, ignore) => {
                 let path_pat = self.next("qpath");
                 let fields_pat = self.next("fields");
-                println!(
-                    "Struct(ref {}, ref {}, {}) = {};",
-                    path_pat, fields_pat, ignore, current
-                );
+                println!("Struct(ref {}, {}, {}) = {};", path_pat, fields_pat, ignore, current);
 
                 self.current = path_pat;
                 self.print_qpath(path);
@@ -921,7 +906,7 @@ impl<'a, 'tcx> Visitor<'tcx> for PrintVisitor<'a, '_> {
             },
             PatKind::Or(fields) => {
                 let fields_pat = self.next("fields");
-                println!("Or(ref {}) = {};", fields_pat, current);
+                println!("Or({}) = {};", fields_pat, current);
                 println!("    if {}.len() == {};", fields_pat, fields.len());
 
                 for (i, field) in fields.iter().enumerate() {
@@ -934,7 +919,7 @@ impl<'a, 'tcx> Visitor<'tcx> for PrintVisitor<'a, '_> {
                 let fields_pat = self.next("fields");
 
                 println!(
-                    "TupleStruct(ref {}, ref {}, {:?}) = {};",
+                    "TupleStruct(ref {}, {}, {:?}) = {};",
                     path_pat, fields_pat, skip_pos, current
                 );
 
@@ -957,7 +942,7 @@ impl<'a, 'tcx> Visitor<'tcx> for PrintVisitor<'a, '_> {
             },
             PatKind::Tuple(fields, skip_pos) => {
                 let fields_pat = self.next("fields");
-                println!("Tuple(ref {}, {:?}) = {};", fields_pat, skip_pos, current);
+                println!("Tuple({}, {:?}) = {};", fields_pat, skip_pos, current);
                 println!("    if {}.len() == {};", fields_pat, fields.len());
 
                 for (i, field) in fields.iter().enumerate() {
@@ -967,31 +952,31 @@ impl<'a, 'tcx> Visitor<'tcx> for PrintVisitor<'a, '_> {
             },
             PatKind::Box(pat) => {
                 let pat_pat = self.next("pat");
-                println!("Box(ref {}) = {};", pat_pat, current);
+                println!("Box({}) = {};", pat_pat, current);
 
                 self.current = pat_pat;
                 self.visit_pat(pat);
             },
             PatKind::Ref(pat, muta) => {
                 let pat_pat = self.next("pat");
-                println!("Ref(ref {}, Mutability::{:?}) = {};", pat_pat, muta, current);
+                println!("Ref({}, Mutability::{:?}) = {};", pat_pat, muta, current);
 
                 self.current = pat_pat;
                 self.visit_pat(pat);
             },
             PatKind::Lit(lit_expr) => {
                 let lit_expr_pat = self.next("lit_expr");
-                println!("Lit(ref {}) = {};", lit_expr_pat, current);
+                println!("Lit({}) = {};", lit_expr_pat, current);
 
                 self.current = lit_expr_pat;
                 self.visit_expr(lit_expr);
             },
-            PatKind::Range(ref start, ref end, end_kind) => {
+            PatKind::Range(start, end, end_kind) => {
                 let start_pat = self.next("start");
                 let end_pat = self.next("end");
 
                 println!(
-                    "Range(ref {}, ref {}, RangeEnd::{:?}) = {};",
+                    "Range({}, {}, RangeEnd::{:?}) = {};",
                     start_pat, end_pat, end_kind, current
                 );
 
@@ -1001,20 +986,17 @@ impl<'a, 'tcx> Visitor<'tcx> for PrintVisitor<'a, '_> {
                 self.current = end_pat;
                 walk_list!(self, visit_expr, end);
             },
-            PatKind::Slice(start, ref middle, end) => {
+            PatKind::Slice(start, middle, end) => {
                 let start_pat = self.next("start");
                 let end_pat = self.next("end");
 
                 if let Some(middle) = middle {
                     let middle_pat = self.next("middle");
-                    println!(
-                        "Slice(ref {}, Some(ref {}), ref {}) = {};",
-                        start_pat, middle_pat, end_pat, current
-                    );
+                    println!("Slice({}, Some({}), {}) = {};", start_pat, middle_pat, end_pat, current);
                     self.current = middle_pat;
                     self.visit_pat(middle);
                 } else {
-                    println!("Slice(ref {}, None, ref {}) = {};", start_pat, end_pat, current);
+                    println!("Slice({}, None, {}) = {};", start_pat, end_pat, current);
                 }
 
                 println!("    if {}.len() == {};", start_pat, start.len());
@@ -1042,11 +1024,11 @@ impl<'a, 'tcx> Visitor<'tcx> for PrintVisitor<'a, '_> {
             // A local (let) binding:
             StmtKind::Local(local) => {
                 let local_pat = self.next("local");
-                println!("Local(ref {}) = {};", local_pat, current);
+                println!("Local({}) = {};", local_pat, current);
 
                 if let Some(init) = local.init {
                     let init_pat = self.next("init");
-                    println!("    if let Some(ref {}) = {}.init;", init_pat, local_pat);
+                    println!("    if let Some({}) = {}.init;", init_pat, local_pat);
 
                     self.current = init_pat;
                     self.visit_expr(init);
@@ -1063,7 +1045,7 @@ impl<'a, 'tcx> Visitor<'tcx> for PrintVisitor<'a, '_> {
             // Expr without trailing semi-colon (must have unit type):
             StmtKind::Expr(e) => {
                 let e_pat = self.next("e");
-                println!("Expr(ref {}, _) = {};", e_pat, current);
+                println!("Expr({}, _) = {};", e_pat, current);
 
                 self.current = e_pat;
                 self.visit_expr(e);
@@ -1072,7 +1054,7 @@ impl<'a, 'tcx> Visitor<'tcx> for PrintVisitor<'a, '_> {
             // Expr with trailing semi-colon (may have any type):
             StmtKind::Semi(e) => {
                 let e_pat = self.next("e");
-                println!("Semi(ref {}) = {};", e_pat, current);
+                println!("Semi({}) = {};", e_pat, current);
 
                 self.current = e_pat;
                 self.visit_expr(e);
diff --git a/tests/ui/author.stdout b/tests/ui/author.stdout
index 4931270bea8..3125863036b 100644
--- a/tests/ui/author.stdout
+++ b/tests/ui/author.stdout
@@ -1,7 +1,7 @@
 if_chain! {
-    if let StmtKind::Local(ref local) = stmt.kind;
-    if let Some(ref init) = local.init;
-    if let ExprKind::Cast(ref expr, ref cast_ty) = init.kind;
+    if let StmtKind::Local(local) = stmt.kind;
+    if let Some(init) = local.init;
+    if let ExprKind::Cast(expr, cast_ty) = init.kind;
     if let TyKind::Path(ref qpath) = cast_ty.kind;
     if match_qpath(qpath, &["char"]);
     if let ExprKind::Lit(ref lit) = expr.kind;
diff --git a/tests/ui/author/blocks.stdout b/tests/ui/author/blocks.stdout
index d9bd738ae92..b1b38736725 100644
--- a/tests/ui/author/blocks.stdout
+++ b/tests/ui/author/blocks.stdout
@@ -1,20 +1,20 @@
 if_chain! {
-    if let ExprKind::Block(ref block, ref label) = expr.kind;
+    if let ExprKind::Block(block, label) = expr.kind;
     if block.stmts.len() == 3;
-    if let StmtKind::Local(ref local) = block.stmts[0].kind;
-    if let Some(ref init) = local.init;
+    if let StmtKind::Local(local) = block.stmts[0].kind;
+    if let Some(init) = local.init;
     if let ExprKind::Lit(ref lit) = init.kind;
     if let LitKind::Int(42, LitIntType::Signed(IntTy::I32)) = lit.node;
     if let PatKind::Binding(BindingAnnotation::Unannotated, _, name, None) = local.pat.kind;
     if name.as_str() == "x";
-    if let StmtKind::Local(ref local1) = block.stmts[1].kind;
-    if let Some(ref init1) = local1.init;
+    if let StmtKind::Local(local1) = block.stmts[1].kind;
+    if let Some(init1) = local1.init;
     if let ExprKind::Lit(ref lit1) = init1.kind;
     if let LitKind::Float(_, LitFloatType::Suffixed(FloatTy::F32)) = lit1.node;
     if let PatKind::Binding(BindingAnnotation::Unannotated, _, name1, None) = local1.pat.kind;
     if name1.as_str() == "_t";
-    if let StmtKind::Semi(ref e) = block.stmts[2].kind;
-    if let ExprKind::Unary(UnOp::Neg, ref inner) = e.kind;
+    if let StmtKind::Semi(e) = block.stmts[2].kind;
+    if let ExprKind::Unary(UnOp::Neg, inner) = e.kind;
     if let ExprKind::Path(ref qpath) = inner.kind;
     if match_qpath(qpath, &["x"]);
     if block.expr.is_none();
@@ -23,18 +23,18 @@ if_chain! {
     }
 }
 if_chain! {
-    if let ExprKind::Block(ref block, ref label) = expr.kind;
+    if let ExprKind::Block(block, label) = expr.kind;
     if block.stmts.len() == 1;
-    if let StmtKind::Local(ref local) = block.stmts[0].kind;
-    if let Some(ref init) = local.init;
-    if let ExprKind::Call(ref func, ref args) = init.kind;
+    if let StmtKind::Local(local) = block.stmts[0].kind;
+    if let Some(init) = local.init;
+    if let ExprKind::Call(func, args) = init.kind;
     if let ExprKind::Path(ref qpath) = func.kind;
     if match_qpath(qpath, &["String", "new"]);
     if args.len() == 0;
     if let PatKind::Binding(BindingAnnotation::Unannotated, _, name, None) = local.pat.kind;
     if name.as_str() == "expr";
-    if let Some(trailing_expr) = &block.expr;
-    if let ExprKind::Call(ref func1, ref args1) = trailing_expr.kind;
+    if let Some(trailing_expr) = block.expr;
+    if let ExprKind::Call(func1, args1) = trailing_expr.kind;
     if let ExprKind::Path(ref qpath1) = func1.kind;
     if match_qpath(qpath1, &["drop"]);
     if args1.len() == 1;
@@ -45,17 +45,17 @@ if_chain! {
     }
 }
 if_chain! {
-    if let ExprKind::Closure(CaptureBy::Value, ref fn_decl, ref body_id, _, None) = expr.kind;
+    if let ExprKind::Closure(CaptureBy::Value, fn_decl, body_id, _, None) = expr.kind;
     if let FnRetTy::DefaultReturn(_) = fn_decl.output;
     let body = cx.tcx.hir().body(body_id);
-    if let ExprKind::Call(ref func, ref args) = body.value.kind;
+    if let ExprKind::Call(func, args) = body.value.kind;
     if let ExprKind::Path(ref qpath) = func.kind;
     if matches!(qpath, QPath::LangItem(LangItem::FromGenerator, _));
     if args.len() == 1;
-    if let ExprKind::Closure(CaptureBy::Value, ref fn_decl1, ref body_id1, _, Some(Movability::Static)) = args[0].kind;
+    if let ExprKind::Closure(CaptureBy::Value, fn_decl1, body_id1, _, Some(Movability::Static)) = args[0].kind;
     if let FnRetTy::DefaultReturn(_) = fn_decl1.output;
     let body1 = cx.tcx.hir().body(body_id1);
-    if let ExprKind::Block(ref block, ref label) = body1.value.kind;
+    if let ExprKind::Block(block, label) = body1.value.kind;
     if block.stmts.len() == 0;
     if block.expr.is_none();
     then {
diff --git a/tests/ui/author/call.stdout b/tests/ui/author/call.stdout
index 7bce2bb84f2..266312d63e5 100644
--- a/tests/ui/author/call.stdout
+++ b/tests/ui/author/call.stdout
@@ -1,7 +1,7 @@
 if_chain! {
-    if let StmtKind::Local(ref local) = stmt.kind;
-    if let Some(ref init) = local.init;
-    if let ExprKind::Call(ref func, ref args) = init.kind;
+    if let StmtKind::Local(local) = stmt.kind;
+    if let Some(init) = local.init;
+    if let ExprKind::Call(func, args) = init.kind;
     if let ExprKind::Path(ref qpath) = func.kind;
     if match_qpath(qpath, &["{{root}}", "std", "cmp", "min"]);
     if args.len() == 2;
diff --git a/tests/ui/author/if.stdout b/tests/ui/author/if.stdout
index 889d3e595ba..504f2c38fbb 100644
--- a/tests/ui/author/if.stdout
+++ b/tests/ui/author/if.stdout
@@ -1,23 +1,23 @@
 if_chain! {
-    if let StmtKind::Local(ref local) = stmt.kind;
-    if let Some(ref init) = local.init;
+    if let StmtKind::Local(local) = stmt.kind;
+    if let Some(init) = local.init;
     if let Some(higher::If { cond: cond, then: then, r#else: else_expr}) = higher::If::hir(init);
     if let ExprKind::Lit(ref lit) = cond.kind;
     if let LitKind::Bool(true) = lit.node;
-    if let ExprKind::Block(ref block, ref label) = then.kind;
+    if let ExprKind::Block(block, label) = then.kind;
     if block.stmts.len() == 1;
-    if let StmtKind::Semi(ref e) = block.stmts[0].kind;
-    if let ExprKind::Binary(ref op, ref left, ref right) = e.kind;
+    if let StmtKind::Semi(e) = block.stmts[0].kind;
+    if let ExprKind::Binary(op, left, right) = e.kind;
     if BinOpKind::Eq == op.node;
     if let ExprKind::Lit(ref lit1) = left.kind;
     if let LitKind::Int(1, LitIntType::Unsuffixed) = lit1.node;
     if let ExprKind::Lit(ref lit2) = right.kind;
     if let LitKind::Int(1, LitIntType::Unsuffixed) = lit2.node;
     if block.expr.is_none();
-    if let ExprKind::Block(ref block1, ref label1) = else_expr.kind;
+    if let ExprKind::Block(block1, label1) = else_expr.kind;
     if block1.stmts.len() == 1;
-    if let StmtKind::Semi(ref e1) = block1.stmts[0].kind;
-    if let ExprKind::Binary(ref op1, ref left1, ref right1) = e1.kind;
+    if let StmtKind::Semi(e1) = block1.stmts[0].kind;
+    if let ExprKind::Binary(op1, left1, right1) = e1.kind;
     if BinOpKind::Eq == op1.node;
     if let ExprKind::Lit(ref lit3) = left1.kind;
     if let LitKind::Int(2, LitIntType::Unsuffixed) = lit3.node;
@@ -31,15 +31,15 @@ if_chain! {
 }
 if_chain! {
     if let Some(higher::IfLet { let_pat: let_pat, let_expr: let_expr, if_then: if_then, if_else: else_expr}) = higher::IfLet::hir(expr);
-    if let PatKind::Lit(ref lit_expr) = let_pat.kind;
+    if let PatKind::Lit(lit_expr) = let_pat.kind;
     if let ExprKind::Lit(ref lit) = lit_expr.kind;
     if let LitKind::Bool(true) = lit.node;
     if let ExprKind::Path(ref qpath) = let_expr.kind;
     if match_qpath(qpath, &["a"]);
-    if let ExprKind::Block(ref block, ref label) = if_then.kind;
+    if let ExprKind::Block(block, label) = if_then.kind;
     if block.stmts.len() == 0;
     if block.expr.is_none();
-    if let ExprKind::Block(ref block1, ref label1) = else_expr.kind;
+    if let ExprKind::Block(block1, label1) = else_expr.kind;
     if block1.stmts.len() == 0;
     if block1.expr.is_none();
     then {
diff --git a/tests/ui/author/issue_3849.stdout b/tests/ui/author/issue_3849.stdout
index 769384d79c0..bce4bc70273 100644
--- a/tests/ui/author/issue_3849.stdout
+++ b/tests/ui/author/issue_3849.stdout
@@ -1,7 +1,7 @@
 if_chain! {
-    if let StmtKind::Local(ref local) = stmt.kind;
-    if let Some(ref init) = local.init;
-    if let ExprKind::Call(ref func, ref args) = init.kind;
+    if let StmtKind::Local(local) = stmt.kind;
+    if let Some(init) = local.init;
+    if let ExprKind::Call(func, args) = init.kind;
     if let ExprKind::Path(ref qpath) = func.kind;
     if match_qpath(qpath, &["std", "mem", "transmute"]);
     if args.len() == 1;
diff --git a/tests/ui/author/loop.stdout b/tests/ui/author/loop.stdout
index 9e7300335c5..57c932ee6c0 100644
--- a/tests/ui/author/loop.stdout
+++ b/tests/ui/author/loop.stdout
@@ -1,9 +1,9 @@
 if_chain! {
-    if let ExprKind::DropTemps(ref expr) = expr.kind;
+    if let ExprKind::DropTemps(expr) = expr.kind;
     if let Some(higher::ForLoop { pat: pat, arg: arg, body: body, ..}) = higher::ForLoop::hir(expr);
     if let PatKind::Binding(BindingAnnotation::Unannotated, _, name, None) = pat.kind;
     if name.as_str() == "y";
-    if let ExprKind::Struct(ref qpath, ref fields, None) = arg.kind;
+    if let ExprKind::Struct(qpath, fields, None) = arg.kind;
     if matches!(qpath, QPath::LangItem(LangItem::Range, _));
     if fields.len() == 2;
     if fields[0].ident.name.as_str() == "start";
@@ -12,10 +12,10 @@ if_chain! {
     if fields[1].ident.name.as_str() == "end";
     if let ExprKind::Lit(ref lit1) = fields[1].expr.kind;
     if let LitKind::Int(10, LitIntType::Unsuffixed) = lit1.node;
-    if let ExprKind::Block(ref block, ref label) = body.kind;
+    if let ExprKind::Block(block, label) = body.kind;
     if block.stmts.len() == 1;
-    if let StmtKind::Local(ref local) = block.stmts[0].kind;
-    if let Some(ref init) = local.init;
+    if let StmtKind::Local(local) = block.stmts[0].kind;
+    if let Some(init) = local.init;
     if let ExprKind::Path(ref qpath1) = init.kind;
     if match_qpath(qpath1, &["y"]);
     if let PatKind::Binding(BindingAnnotation::Unannotated, _, name1, None) = local.pat.kind;
@@ -26,10 +26,10 @@ if_chain! {
     }
 }
 if_chain! {
-    if let ExprKind::DropTemps(ref expr) = expr.kind;
+    if let ExprKind::DropTemps(expr) = expr.kind;
     if let Some(higher::ForLoop { pat: pat, arg: arg, body: body, ..}) = higher::ForLoop::hir(expr);
     if let PatKind::Wild = pat.kind;
-    if let ExprKind::Struct(ref qpath, ref fields, None) = arg.kind;
+    if let ExprKind::Struct(qpath, fields, None) = arg.kind;
     if matches!(qpath, QPath::LangItem(LangItem::Range, _));
     if fields.len() == 2;
     if fields[0].ident.name.as_str() == "start";
@@ -38,20 +38,20 @@ if_chain! {
     if fields[1].ident.name.as_str() == "end";
     if let ExprKind::Lit(ref lit1) = fields[1].expr.kind;
     if let LitKind::Int(10, LitIntType::Unsuffixed) = lit1.node;
-    if let ExprKind::Block(ref block, ref label) = body.kind;
+    if let ExprKind::Block(block, label) = body.kind;
     if block.stmts.len() == 1;
-    if let StmtKind::Semi(ref e) = block.stmts[0].kind;
-    if let ExprKind::Break(ref destination, None) = e.kind;
+    if let StmtKind::Semi(e) = block.stmts[0].kind;
+    if let ExprKind::Break(destination, None) = e.kind;
     if block.expr.is_none();
     then {
         // report your lint here
     }
 }
 if_chain! {
-    if let ExprKind::DropTemps(ref expr) = expr.kind;
+    if let ExprKind::DropTemps(expr) = expr.kind;
     if let Some(higher::ForLoop { pat: pat, arg: arg, body: body, ..}) = higher::ForLoop::hir(expr);
     if let PatKind::Wild = pat.kind;
-    if let ExprKind::Struct(ref qpath, ref fields, None) = arg.kind;
+    if let ExprKind::Struct(qpath, fields, None) = arg.kind;
     if matches!(qpath, QPath::LangItem(LangItem::Range, _));
     if fields.len() == 2;
     if fields[0].ident.name.as_str() == "start";
@@ -60,11 +60,11 @@ if_chain! {
     if fields[1].ident.name.as_str() == "end";
     if let ExprKind::Lit(ref lit1) = fields[1].expr.kind;
     if let LitKind::Int(10, LitIntType::Unsuffixed) = lit1.node;
-    if let ExprKind::Block(ref block, ref label) = body.kind;
+    if let ExprKind::Block(block, label) = body.kind;
     if block.stmts.len() == 1;
-    if let StmtKind::Semi(ref e) = block.stmts[0].kind;
-    if let ExprKind::Break(ref destination, None) = e.kind;
-    if let Some(ref label1) = destination.label;
+    if let StmtKind::Semi(e) = block.stmts[0].kind;
+    if let ExprKind::Break(destination, None) = e.kind;
+    if let Some(label1) = destination.label;
     if label_name.ident.name.as_str() == "'label";
     if block.expr.is_none();
     then {
@@ -75,10 +75,10 @@ if_chain! {
     if let Some(higher::While { condition: condition, body: body }) = higher::While::hir(expr);
     if let ExprKind::Path(ref qpath) = condition.kind;
     if match_qpath(qpath, &["a"]);
-    if let ExprKind::Block(ref block, ref label) = body.kind;
+    if let ExprKind::Block(block, label) = body.kind;
     if block.stmts.len() == 1;
-    if let StmtKind::Semi(ref e) = block.stmts[0].kind;
-    if let ExprKind::Break(ref destination, None) = e.kind;
+    if let StmtKind::Semi(e) = block.stmts[0].kind;
+    if let ExprKind::Break(destination, None) = e.kind;
     if block.expr.is_none();
     then {
         // report your lint here
@@ -86,25 +86,25 @@ if_chain! {
 }
 if_chain! {
     if let Some(higher::WhileLet { let_pat: let_pat, let_expr: let_expr, if_then: if_then }) = higher::WhileLet::hir(expr);
-    if let PatKind::Lit(ref lit_expr) = let_pat.kind;
+    if let PatKind::Lit(lit_expr) = let_pat.kind;
     if let ExprKind::Lit(ref lit) = lit_expr.kind;
     if let LitKind::Bool(true) = lit.node;
     if let ExprKind::Path(ref qpath) = let_expr.kind;
     if match_qpath(qpath, &["a"]);
-    if let ExprKind::Block(ref block, ref label) = if_then.kind;
+    if let ExprKind::Block(block, label) = if_then.kind;
     if block.stmts.len() == 1;
-    if let StmtKind::Semi(ref e) = block.stmts[0].kind;
-    if let ExprKind::Break(ref destination, None) = e.kind;
+    if let StmtKind::Semi(e) = block.stmts[0].kind;
+    if let ExprKind::Break(destination, None) = e.kind;
     if block.expr.is_none();
     then {
         // report your lint here
     }
 }
 if_chain! {
-    if let ExprKind::Loop(ref body, ref label, LoopSource::Loop, _) = expr.kind;
+    if let ExprKind::Loop(body, label, LoopSource::Loop, _) = expr.kind;
     if body.stmts.len() == 1;
-    if let StmtKind::Semi(ref e) = body.stmts[0].kind;
-    if let ExprKind::Break(ref destination, None) = e.kind;
+    if let StmtKind::Semi(e) = body.stmts[0].kind;
+    if let ExprKind::Break(destination, None) = e.kind;
     if body.expr.is_none();
     then {
         // report your lint here
diff --git a/tests/ui/author/matches.stdout b/tests/ui/author/matches.stdout
index 56a955571dd..397be11659b 100644
--- a/tests/ui/author/matches.stdout
+++ b/tests/ui/author/matches.stdout
@@ -1,27 +1,27 @@
 if_chain! {
-    if let StmtKind::Local(ref local) = stmt.kind;
-    if let Some(ref init) = local.init;
-    if let ExprKind::Match(ref scrutinee, ref arms, MatchSource::Normal) = init.kind;
+    if let StmtKind::Local(local) = stmt.kind;
+    if let Some(init) = local.init;
+    if let ExprKind::Match(scrutinee, arms, MatchSource::Normal) = init.kind;
     if let ExprKind::Lit(ref lit) = scrutinee.kind;
     if let LitKind::Int(42, LitIntType::Unsuffixed) = lit.node;
     if arms.len() == 3;
-    if let PatKind::Lit(ref lit_expr) = arms[0].pat.kind;
+    if let PatKind::Lit(lit_expr) = arms[0].pat.kind;
     if let ExprKind::Lit(ref lit1) = lit_expr.kind;
     if let LitKind::Int(16, LitIntType::Unsuffixed) = lit1.node;
     if let ExprKind::Lit(ref lit2) = arms[0].body.kind;
     if let LitKind::Int(5, LitIntType::Unsuffixed) = lit2.node;
-    if let PatKind::Lit(ref lit_expr1) = arms[1].pat.kind;
+    if let PatKind::Lit(lit_expr1) = arms[1].pat.kind;
     if let ExprKind::Lit(ref lit3) = lit_expr1.kind;
     if let LitKind::Int(17, LitIntType::Unsuffixed) = lit3.node;
-    if let ExprKind::Block(ref block, ref label) = arms[1].body.kind;
+    if let ExprKind::Block(block, label) = arms[1].body.kind;
     if block.stmts.len() == 1;
-    if let StmtKind::Local(ref local1) = block.stmts[0].kind;
-    if let Some(ref init1) = local1.init;
+    if let StmtKind::Local(local1) = block.stmts[0].kind;
+    if let Some(init1) = local1.init;
     if let ExprKind::Lit(ref lit4) = init1.kind;
     if let LitKind::Int(3, LitIntType::Unsuffixed) = lit4.node;
     if let PatKind::Binding(BindingAnnotation::Unannotated, _, name, None) = local1.pat.kind;
     if name.as_str() == "x";
-    if let Some(trailing_expr) = &block.expr;
+    if let Some(trailing_expr) = block.expr;
     if let ExprKind::Path(ref qpath) = trailing_expr.kind;
     if match_qpath(qpath, &["x"]);
     if let PatKind::Wild = arms[2].pat.kind;
diff --git a/tests/ui/author/repeat.stdout b/tests/ui/author/repeat.stdout
index 9ff376373e6..af66bb48022 100644
--- a/tests/ui/author/repeat.stdout
+++ b/tests/ui/author/repeat.stdout
@@ -1,5 +1,5 @@
 if_chain! {
-    if let ExprKind::Repeat(ref value, ref length) = expr.kind;
+    if let ExprKind::Repeat(value, length) = expr.kind;
     if let ExprKind::Lit(ref lit) = value.kind;
     if let LitKind::Int(1, LitIntType::Unsigned(UintTy::U8)) = lit.node;
     if let ExprKind::Lit(ref lit1) = length.value.kind;
diff --git a/tests/ui/author/struct.stdout b/tests/ui/author/struct.stdout
index 66e6df195d2..ffedd87625d 100644
--- a/tests/ui/author/struct.stdout
+++ b/tests/ui/author/struct.stdout
@@ -1,19 +1,19 @@
 if_chain! {
-    if let ExprKind::Struct(ref qpath, ref fields, None) = expr.kind;
+    if let ExprKind::Struct(qpath, fields, None) = expr.kind;
     if match_qpath(qpath, &["Test"]);
     if fields.len() == 1;
     if fields[0].ident.name.as_str() == "field";
     if let Some(higher::If { cond: cond, then: then, r#else: else_expr}) = higher::If::hir(fields[0].expr);
     if let ExprKind::Lit(ref lit) = cond.kind;
     if let LitKind::Bool(true) = lit.node;
-    if let ExprKind::Block(ref block, ref label) = then.kind;
+    if let ExprKind::Block(block, label) = then.kind;
     if block.stmts.len() == 0;
-    if let Some(trailing_expr) = &block.expr;
+    if let Some(trailing_expr) = block.expr;
     if let ExprKind::Lit(ref lit1) = trailing_expr.kind;
     if let LitKind::Int(1, LitIntType::Unsuffixed) = lit1.node;
-    if let ExprKind::Block(ref block1, ref label1) = else_expr.kind;
+    if let ExprKind::Block(block1, label1) = else_expr.kind;
     if block1.stmts.len() == 0;
-    if let Some(trailing_expr1) = &block1.expr;
+    if let Some(trailing_expr1) = block1.expr;
     if let ExprKind::Lit(ref lit2) = trailing_expr1.kind;
     if let LitKind::Int(0, LitIntType::Unsuffixed) = lit2.node;
     then {
@@ -21,14 +21,14 @@ if_chain! {
     }
 }
 if_chain! {
-    if let PatKind::Struct(ref qpath, ref fields, false) = arm.kind;
+    if let PatKind::Struct(ref qpath, fields, false) = arm.kind;
     if match_qpath(qpath, &["Test"]);
     if fields.len() == 1;
     if fields[0].ident.name.as_str() == "field";
-    if let PatKind::Lit(ref lit_expr) = fields[0].kind;
+    if let PatKind::Lit(lit_expr) = fields[0].kind;
     if let ExprKind::Lit(ref lit) = lit_expr.kind;
     if let LitKind::Int(1, LitIntType::Unsuffixed) = lit.node;
-    if let ExprKind::Block(ref block, ref label) = lit_expr.kind;
+    if let ExprKind::Block(block, label) = lit_expr.kind;
     if block.stmts.len() == 0;
     if block.expr.is_none();
     then {
@@ -36,13 +36,13 @@ if_chain! {
     }
 }
 if_chain! {
-    if let PatKind::TupleStruct(ref qpath, ref fields, None) = arm.kind;
+    if let PatKind::TupleStruct(ref qpath, fields, None) = arm.kind;
     if match_qpath(qpath, &["TestTuple"]);
     if fields.len() == 1;
-    if let PatKind::Lit(ref lit_expr) = fields[0].kind;
+    if let PatKind::Lit(lit_expr) = fields[0].kind;
     if let ExprKind::Lit(ref lit) = lit_expr.kind;
     if let LitKind::Int(1, LitIntType::Unsuffixed) = lit.node;
-    if let ExprKind::Block(ref block, ref label) = lit_expr.kind;
+    if let ExprKind::Block(block, label) = lit_expr.kind;
     if block.stmts.len() == 0;
     if block.expr.is_none();
     then {
@@ -50,7 +50,7 @@ if_chain! {
     }
 }
 if_chain! {
-    if let ExprKind::MethodCall(ref method_name, ref args, _) = expr.kind;
+    if let ExprKind::MethodCall(method_name, _, args, _) = expr.kind;
     if method_name.ident.name.as_str() == test;
     if args.len() == 1;
     if let ExprKind::Path(ref qpath) = args[0].kind;
-- 
cgit 1.4.1-3-g733a5


From 2d037aa4a66edb601fb65fb3efdc573771cba3e2 Mon Sep 17 00:00:00 2001
From: dswij <dswijj@gmail.com>
Date: Mon, 25 Oct 2021 12:29:05 +0800
Subject: Check for no_std and no_core attribute in `swap` lint

This commit adds a `no_std` and `no_core` check on `swap` lint and additionally suggest `core::mem::swap` whenever possible.
Remove warning if both `std` and `core` is not present.
---
 clippy_lints/src/lib.rs  |  1 +
 clippy_lints/src/swap.rs | 48 +++++++++++++++++++++++++++---------------------
 clippy_utils/src/lib.rs  | 20 ++++++++++++++++++++
 3 files changed, 48 insertions(+), 21 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index d91b2e1f448..02fb6b79dc4 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -8,6 +8,7 @@
 #![feature(rustc_private)]
 #![feature(stmt_expr_attributes)]
 #![feature(control_flow_enum)]
+#![feature(let_else)]
 #![recursion_limit = "512"]
 #![cfg_attr(feature = "deny-warnings", deny(warnings))]
 #![allow(clippy::missing_docs_in_private_items, clippy::must_use_candidate)]
diff --git a/clippy_lints/src/swap.rs b/clippy_lints/src/swap.rs
index ef26de5b6b9..bd779124dee 100644
--- a/clippy_lints/src/swap.rs
+++ b/clippy_lints/src/swap.rs
@@ -2,7 +2,7 @@ use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{can_mut_borrow_both, differing_macro_contexts, eq_expr_value};
+use clippy_utils::{can_mut_borrow_both, differing_macro_contexts, eq_expr_value, std_or_core};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Block, Expr, ExprKind, PatKind, QPath, Stmt, StmtKind};
@@ -113,6 +113,8 @@ fn generate_swap_warning(cx: &LateContext<'_>, e1: &Expr<'_>, e2: &Expr<'_>, spa
 
     let first = Sugg::hir_with_applicability(cx, e1, "..", &mut applicability);
     let second = Sugg::hir_with_applicability(cx, e2, "..", &mut applicability);
+    let Some(sugg) = std_or_core(cx) else { return };
+
     span_lint_and_then(
         cx,
         MANUAL_SWAP,
@@ -122,11 +124,11 @@ fn generate_swap_warning(cx: &LateContext<'_>, e1: &Expr<'_>, e2: &Expr<'_>, spa
             diag.span_suggestion(
                 span,
                 "try",
-                format!("std::mem::swap({}, {})", first.mut_addr(), second.mut_addr()),
+                format!("{}::mem::swap({}, {})", sugg, first.mut_addr(), second.mut_addr()),
                 applicability,
             );
             if !is_xor_based {
-                diag.note("or maybe you should use `std::mem::replace`?");
+                diag.note(&format!("or maybe you should use `{}::mem::replace`?", sugg));
             }
         },
     );
@@ -187,26 +189,30 @@ fn check_suspicious_swap(cx: &LateContext<'_>, block: &Block<'_>) {
                 };
 
                 let span = first.span.to(second.span);
+                let Some(sugg) = std_or_core(cx) else { return };
 
                 span_lint_and_then(cx,
-                                   ALMOST_SWAPPED,
-                                   span,
-                                   &format!("this looks like you are trying to swap{}", what),
-                                   |diag| {
-                                       if !what.is_empty() {
-                                           diag.span_suggestion(
-                                               span,
-                                               "try",
-                                               format!(
-                                                   "std::mem::swap({}, {})",
-                                                   lhs,
-                                                   rhs,
-                                               ),
-                                               Applicability::MaybeIncorrect,
-                                           );
-                                           diag.note("or maybe you should use `std::mem::replace`?");
-                                       }
-                                   });
+                    ALMOST_SWAPPED,
+                    span,
+                    &format!("this looks like you are trying to swap{}", what),
+                    |diag| {
+                        if !what.is_empty() {
+                            diag.span_suggestion(
+                                span,
+                                "try",
+                                format!(
+                                    "{}::mem::swap({}, {})",
+                                    sugg,
+                                    lhs,
+                                    rhs,
+                                ),
+                                Applicability::MaybeIncorrect,
+                            );
+                            diag.note(
+                                &format!("or maybe you should use `{}::mem::replace`?", sugg)
+                            );
+                        }
+                    });
             }
         }
     }
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 95642adeff6..3fdea55aaa1 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -1809,6 +1809,16 @@ pub fn is_expr_final_block_expr(tcx: TyCtxt<'_>, expr: &Expr<'_>) -> bool {
     matches!(get_parent_node(tcx, expr.hir_id), Some(Node::Block(..)))
 }
 
+pub fn std_or_core(cx: &LateContext<'_>) -> Option<&'static str> {
+    if !is_no_std_crate(cx) {
+        Some("std")
+    } else if !is_no_core_crate(cx) {
+        Some("core")
+    } else {
+        None
+    }
+}
+
 pub fn is_no_std_crate(cx: &LateContext<'_>) -> bool {
     cx.tcx.hir().attrs(hir::CRATE_HIR_ID).iter().any(|attr| {
         if let ast::AttrKind::Normal(ref attr, _) = attr.kind {
@@ -1819,6 +1829,16 @@ pub fn is_no_std_crate(cx: &LateContext<'_>) -> bool {
     })
 }
 
+pub fn is_no_core_crate(cx: &LateContext<'_>) -> bool {
+    cx.tcx.hir().attrs(hir::CRATE_HIR_ID).iter().any(|attr| {
+        if let ast::AttrKind::Normal(ref attr, _) = attr.kind {
+            attr.path == sym::no_core
+        } else {
+            false
+        }
+    })
+}
+
 /// Check if parent of a hir node is a trait implementation block.
 /// For example, `f` in
 /// ```rust,ignore
-- 
cgit 1.4.1-3-g733a5


From 8c45fd88d0ca43775b215e1b94b2175e8f4c05d2 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Thu, 11 Nov 2021 12:54:53 +0100
Subject: New internal lint to make  `clippy::version` attribute mandatory

---
 clippy_lints/src/lib.register_internal.rs          |  1 +
 clippy_lints/src/lib.register_lints.rs             |  2 ++
 clippy_lints/src/lib.rs                            |  4 +++
 clippy_lints/src/utils/internal_lints.rs           | 20 +++++++++++-
 .../ui-internal/check_clippy_version_attribute.rs  | 26 ++++++++++++---
 .../check_clippy_version_attribute.stderr          | 37 +++++++++++++++++++++-
 .../ui-internal/collapsible_span_lint_calls.fixed  |  1 +
 tests/ui-internal/collapsible_span_lint_calls.rs   |  1 +
 .../ui-internal/collapsible_span_lint_calls.stderr | 10 +++---
 tests/ui-internal/custom_ice_message.rs            |  1 +
 tests/ui-internal/default_lint.rs                  |  1 +
 tests/ui-internal/default_lint.stderr              |  2 +-
 tests/ui-internal/if_chain_style.rs                |  2 +-
 tests/ui-internal/interning_defined_symbol.fixed   |  1 +
 tests/ui-internal/interning_defined_symbol.rs      |  1 +
 tests/ui-internal/interning_defined_symbol.stderr  |  8 ++---
 tests/ui-internal/invalid_paths.rs                 |  1 +
 tests/ui-internal/invalid_paths.stderr             |  4 +--
 tests/ui-internal/lint_without_lint_pass.rs        |  1 +
 tests/ui-internal/lint_without_lint_pass.stderr    |  2 +-
 tests/ui-internal/match_type_on_diag_item.rs       |  1 +
 tests/ui-internal/match_type_on_diag_item.stderr   |  6 ++--
 tests/ui-internal/outer_expn_data.fixed            |  1 +
 tests/ui-internal/outer_expn_data.rs               |  1 +
 tests/ui-internal/outer_expn_data.stderr           |  2 +-
 tests/ui-internal/unnecessary_symbol_str.fixed     |  6 +++-
 tests/ui-internal/unnecessary_symbol_str.rs        |  6 +++-
 tests/ui-internal/unnecessary_symbol_str.stderr    | 10 +++---
 util/gh-pages/index.html                           |  3 +-
 29 files changed, 130 insertions(+), 32 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.register_internal.rs b/clippy_lints/src/lib.register_internal.rs
index d8f5db65c09..7d4c7d2adb5 100644
--- a/clippy_lints/src/lib.register_internal.rs
+++ b/clippy_lints/src/lib.register_internal.rs
@@ -13,6 +13,7 @@ store.register_group(true, "clippy::internal", Some("clippy_internal"), vec![
     LintId::of(utils::internal_lints::INVALID_PATHS),
     LintId::of(utils::internal_lints::LINT_WITHOUT_LINT_PASS),
     LintId::of(utils::internal_lints::MATCH_TYPE_ON_DIAGNOSTIC_ITEM),
+    LintId::of(utils::internal_lints::MISSING_CLIPPY_VERSION_ATTRIBUTE),
     LintId::of(utils::internal_lints::OUTER_EXPN_EXPN_DATA),
     LintId::of(utils::internal_lints::PRODUCE_ICE),
     LintId::of(utils::internal_lints::UNNECESSARY_SYMBOL_STR),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 588debd26c6..b32c9b060ae 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -24,6 +24,8 @@ store.register_lints(&[
     #[cfg(feature = "internal-lints")]
     utils::internal_lints::MATCH_TYPE_ON_DIAGNOSTIC_ITEM,
     #[cfg(feature = "internal-lints")]
+    utils::internal_lints::MISSING_CLIPPY_VERSION_ATTRIBUTE,
+    #[cfg(feature = "internal-lints")]
     utils::internal_lints::OUTER_EXPN_EXPN_DATA,
     #[cfg(feature = "internal-lints")]
     utils::internal_lints::PRODUCE_ICE,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index d91b2e1f448..5c436e1b9eb 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -153,6 +153,10 @@ macro_rules! declare_clippy_lint {
 
 #[cfg(feature = "metadata-collector-lint")]
 mod deprecated_lints;
+#[cfg_attr(
+    any(feature = "internal-lints", feature = "metadata-collector-lint"),
+    allow(clippy::missing_clippy_version_attribute)
+)]
 mod utils;
 
 // begin lints modules, do not remove this comment, it’s used in `update_lints`
diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs
index c20bd4ca38f..1f97c8ba7e6 100644
--- a/clippy_lints/src/utils/internal_lints.rs
+++ b/clippy_lints/src/utils/internal_lints.rs
@@ -328,6 +328,15 @@ declare_clippy_lint! {
     "found an invalid `clippy::version` attribute"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for declared clippy lints without the `clippy::version` attribute.
+    ///
+    pub MISSING_CLIPPY_VERSION_ATTRIBUTE,
+    internal,
+    "found clippy lint without `clippy::version` attribute"
+}
+
 declare_lint_pass!(ClippyLintsInternal => [CLIPPY_LINTS_INTERNAL]);
 
 impl EarlyLintPass for ClippyLintsInternal {
@@ -365,7 +374,7 @@ pub struct LintWithoutLintPass {
     registered_lints: FxHashSet<Symbol>,
 }
 
-impl_lint_pass!(LintWithoutLintPass => [DEFAULT_LINT, LINT_WITHOUT_LINT_PASS, INVALID_CLIPPY_VERSION_ATTRIBUTE]);
+impl_lint_pass!(LintWithoutLintPass => [DEFAULT_LINT, LINT_WITHOUT_LINT_PASS, INVALID_CLIPPY_VERSION_ATTRIBUTE, MISSING_CLIPPY_VERSION_ATTRIBUTE]);
 
 impl<'tcx> LateLintPass<'tcx> for LintWithoutLintPass {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
@@ -492,6 +501,15 @@ fn check_invalid_clippy_version_attribute(cx: &LateContext<'_>, item: &'_ Item<'
                 "please use a valid sematic version, see `doc/adding_lints.md`",
             );
         }
+    } else {
+        span_lint_and_help(
+            cx,
+            MISSING_CLIPPY_VERSION_ATTRIBUTE,
+            item.span,
+            "this lint is missing the `clippy::version` attribute or version value",
+            None,
+            "please use a `clippy::version` attribute, see `doc/adding_lints.md`",
+        );
     }
 }
 
diff --git a/tests/ui-internal/check_clippy_version_attribute.rs b/tests/ui-internal/check_clippy_version_attribute.rs
index e1b37d42174..31acac89cc6 100644
--- a/tests/ui-internal/check_clippy_version_attribute.rs
+++ b/tests/ui-internal/check_clippy_version_attribute.rs
@@ -54,16 +54,34 @@ declare_tool_lint! {
 }
 
 ///////////////////////
-// Ignored attributes
+// Missing attribute test
 ///////////////////////
 declare_tool_lint! {
     #[clippy::version]
-    pub clippy::IGNORED_ONE,
+    pub clippy::MISSING_ATTRIBUTE_ONE,
     Warn,
-    "ONE",
+    "Two",
     report_in_external_macro: true
 }
 
-declare_lint_pass!(Pass2 => [VALID_ONE, VALID_TWO, VALID_THREE, INVALID_ONE, INVALID_TWO, IGNORED_ONE]);
+declare_tool_lint! {
+    pub clippy::MISSING_ATTRIBUTE_TWO,
+    Warn,
+    "Two",
+    report_in_external_macro: true
+}
+
+#[allow(clippy::missing_clippy_version_attribute)]
+mod internal_clippy_lints {
+    declare_tool_lint! {
+        pub clippy::ALLOW_MISSING_ATTRIBUTE_ONE,
+        Warn,
+        "Two",
+        report_in_external_macro: true
+    }
+}
+
+use crate::internal_clippy_lints::ALLOW_MISSING_ATTRIBUTE_ONE;
+declare_lint_pass!(Pass2 => [VALID_ONE, VALID_TWO, VALID_THREE, INVALID_ONE, INVALID_TWO, MISSING_ATTRIBUTE_ONE, MISSING_ATTRIBUTE_TWO, ALLOW_MISSING_ATTRIBUTE_ONE]);
 
 fn main() {}
diff --git a/tests/ui-internal/check_clippy_version_attribute.stderr b/tests/ui-internal/check_clippy_version_attribute.stderr
index fa697ab7425..9302e02ccb9 100644
--- a/tests/ui-internal/check_clippy_version_attribute.stderr
+++ b/tests/ui-internal/check_clippy_version_attribute.stderr
@@ -34,5 +34,40 @@ LL | | }
    = help: please use a valid sematic version, see `doc/adding_lints.md`
    = note: this error originates in the macro `$crate::declare_tool_lint` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to 2 previous errors
+error: this lint is missing the `clippy::version` attribute or version value
+  --> $DIR/check_clippy_version_attribute.rs:59:1
+   |
+LL | / declare_tool_lint! {
+LL | |     #[clippy::version]
+LL | |     pub clippy::MISSING_ATTRIBUTE_ONE,
+LL | |     Warn,
+LL | |     "Two",
+LL | |     report_in_external_macro: true
+LL | | }
+   | |_^
+   |
+note: the lint level is defined here
+  --> $DIR/check_clippy_version_attribute.rs:1:9
+   |
+LL | #![deny(clippy::internal)]
+   |         ^^^^^^^^^^^^^^^^
+   = note: `#[deny(clippy::missing_clippy_version_attribute)]` implied by `#[deny(clippy::internal)]`
+   = help: please use a `clippy::version` attribute, see `doc/adding_lints.md`
+   = note: this error originates in the macro `$crate::declare_tool_lint` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: this lint is missing the `clippy::version` attribute or version value
+  --> $DIR/check_clippy_version_attribute.rs:67:1
+   |
+LL | / declare_tool_lint! {
+LL | |     pub clippy::MISSING_ATTRIBUTE_TWO,
+LL | |     Warn,
+LL | |     "Two",
+LL | |     report_in_external_macro: true
+LL | | }
+   | |_^
+   |
+   = help: please use a `clippy::version` attribute, see `doc/adding_lints.md`
+   = note: this error originates in the macro `$crate::declare_tool_lint` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: aborting due to 4 previous errors
 
diff --git a/tests/ui-internal/collapsible_span_lint_calls.fixed b/tests/ui-internal/collapsible_span_lint_calls.fixed
index 7764cc8da78..a5a6f20ddd5 100644
--- a/tests/ui-internal/collapsible_span_lint_calls.fixed
+++ b/tests/ui-internal/collapsible_span_lint_calls.fixed
@@ -1,5 +1,6 @@
 // run-rustfix
 #![deny(clippy::internal)]
+#![allow(clippy::missing_clippy_version_attribute)]
 #![feature(rustc_private)]
 
 extern crate clippy_utils;
diff --git a/tests/ui-internal/collapsible_span_lint_calls.rs b/tests/ui-internal/collapsible_span_lint_calls.rs
index bdd296db832..6d783aa0786 100644
--- a/tests/ui-internal/collapsible_span_lint_calls.rs
+++ b/tests/ui-internal/collapsible_span_lint_calls.rs
@@ -1,5 +1,6 @@
 // run-rustfix
 #![deny(clippy::internal)]
+#![allow(clippy::missing_clippy_version_attribute)]
 #![feature(rustc_private)]
 
 extern crate clippy_utils;
diff --git a/tests/ui-internal/collapsible_span_lint_calls.stderr b/tests/ui-internal/collapsible_span_lint_calls.stderr
index 0632b038577..558d1299160 100644
--- a/tests/ui-internal/collapsible_span_lint_calls.stderr
+++ b/tests/ui-internal/collapsible_span_lint_calls.stderr
@@ -1,5 +1,5 @@
 error: this call is collapsible
-  --> $DIR/collapsible_span_lint_calls.rs:35:9
+  --> $DIR/collapsible_span_lint_calls.rs:36:9
    |
 LL | /         span_lint_and_then(cx, TEST_LINT, expr.span, lint_msg, |db| {
 LL | |             db.span_suggestion(expr.span, help_msg, sugg.to_string(), Applicability::MachineApplicable);
@@ -14,7 +14,7 @@ LL | #![deny(clippy::internal)]
    = note: `#[deny(clippy::collapsible_span_lint_calls)]` implied by `#[deny(clippy::internal)]`
 
 error: this call is collapsible
-  --> $DIR/collapsible_span_lint_calls.rs:38:9
+  --> $DIR/collapsible_span_lint_calls.rs:39:9
    |
 LL | /         span_lint_and_then(cx, TEST_LINT, expr.span, lint_msg, |db| {
 LL | |             db.span_help(expr.span, help_msg);
@@ -22,7 +22,7 @@ LL | |         });
    | |__________^ help: collapse into: `span_lint_and_help(cx, TEST_LINT, expr.span, lint_msg, Some(expr.span), help_msg)`
 
 error: this call is collapsible
-  --> $DIR/collapsible_span_lint_calls.rs:41:9
+  --> $DIR/collapsible_span_lint_calls.rs:42:9
    |
 LL | /         span_lint_and_then(cx, TEST_LINT, expr.span, lint_msg, |db| {
 LL | |             db.help(help_msg);
@@ -30,7 +30,7 @@ LL | |         });
    | |__________^ help: collapse into: `span_lint_and_help(cx, TEST_LINT, expr.span, lint_msg, None, help_msg)`
 
 error: this call is collspible
-  --> $DIR/collapsible_span_lint_calls.rs:44:9
+  --> $DIR/collapsible_span_lint_calls.rs:45:9
    |
 LL | /         span_lint_and_then(cx, TEST_LINT, expr.span, lint_msg, |db| {
 LL | |             db.span_note(expr.span, note_msg);
@@ -38,7 +38,7 @@ LL | |         });
    | |__________^ help: collapse into: `span_lint_and_note(cx, TEST_LINT, expr.span, lint_msg, Some(expr.span), note_msg)`
 
 error: this call is collspible
-  --> $DIR/collapsible_span_lint_calls.rs:47:9
+  --> $DIR/collapsible_span_lint_calls.rs:48:9
    |
 LL | /         span_lint_and_then(cx, TEST_LINT, expr.span, lint_msg, |db| {
 LL | |             db.note(note_msg);
diff --git a/tests/ui-internal/custom_ice_message.rs b/tests/ui-internal/custom_ice_message.rs
index 5b30c9d5721..5057a018300 100644
--- a/tests/ui-internal/custom_ice_message.rs
+++ b/tests/ui-internal/custom_ice_message.rs
@@ -4,6 +4,7 @@
 // normalize-stderr-test: "', .*clippy_lints" -> "', clippy_lints"
 
 #![deny(clippy::internal)]
+#![allow(clippy::missing_clippy_version_attribute)]
 
 fn it_looks_like_you_are_trying_to_kill_clippy() {}
 
diff --git a/tests/ui-internal/default_lint.rs b/tests/ui-internal/default_lint.rs
index 053faae02ce..da29aedb2a3 100644
--- a/tests/ui-internal/default_lint.rs
+++ b/tests/ui-internal/default_lint.rs
@@ -1,4 +1,5 @@
 #![deny(clippy::internal)]
+#![allow(clippy::missing_clippy_version_attribute)]
 #![feature(rustc_private)]
 
 #[macro_use]
diff --git a/tests/ui-internal/default_lint.stderr b/tests/ui-internal/default_lint.stderr
index 4735573a47d..af6735f4e4d 100644
--- a/tests/ui-internal/default_lint.stderr
+++ b/tests/ui-internal/default_lint.stderr
@@ -1,5 +1,5 @@
 error: the lint `TEST_LINT_DEFAULT` has the default lint description
-  --> $DIR/default_lint.rs:17:1
+  --> $DIR/default_lint.rs:18:1
    |
 LL | / declare_tool_lint! {
 LL | |     pub clippy::TEST_LINT_DEFAULT,
diff --git a/tests/ui-internal/if_chain_style.rs b/tests/ui-internal/if_chain_style.rs
index e064fd188c8..b0d89e038aa 100644
--- a/tests/ui-internal/if_chain_style.rs
+++ b/tests/ui-internal/if_chain_style.rs
@@ -1,5 +1,5 @@
 #![warn(clippy::if_chain_style)]
-#![allow(clippy::no_effect, clippy::nonminimal_bool)]
+#![allow(clippy::no_effect, clippy::nonminimal_bool, clippy::missing_clippy_version_attribute)]
 
 extern crate if_chain;
 
diff --git a/tests/ui-internal/interning_defined_symbol.fixed b/tests/ui-internal/interning_defined_symbol.fixed
index 9ab845a573a..6b7fd6efe39 100644
--- a/tests/ui-internal/interning_defined_symbol.fixed
+++ b/tests/ui-internal/interning_defined_symbol.fixed
@@ -1,5 +1,6 @@
 // run-rustfix
 #![deny(clippy::internal)]
+#![allow(clippy::missing_clippy_version_attribute)]
 #![feature(rustc_private)]
 
 extern crate rustc_span;
diff --git a/tests/ui-internal/interning_defined_symbol.rs b/tests/ui-internal/interning_defined_symbol.rs
index a58e182971d..98d7d7adad1 100644
--- a/tests/ui-internal/interning_defined_symbol.rs
+++ b/tests/ui-internal/interning_defined_symbol.rs
@@ -1,5 +1,6 @@
 // run-rustfix
 #![deny(clippy::internal)]
+#![allow(clippy::missing_clippy_version_attribute)]
 #![feature(rustc_private)]
 
 extern crate rustc_span;
diff --git a/tests/ui-internal/interning_defined_symbol.stderr b/tests/ui-internal/interning_defined_symbol.stderr
index 50c1c268eb1..4e99636e683 100644
--- a/tests/ui-internal/interning_defined_symbol.stderr
+++ b/tests/ui-internal/interning_defined_symbol.stderr
@@ -1,5 +1,5 @@
 error: interning a defined symbol
-  --> $DIR/interning_defined_symbol.rs:17:13
+  --> $DIR/interning_defined_symbol.rs:18:13
    |
 LL |     let _ = Symbol::intern("f32");
    |             ^^^^^^^^^^^^^^^^^^^^^ help: try: `rustc_span::sym::f32`
@@ -12,19 +12,19 @@ LL | #![deny(clippy::internal)]
    = note: `#[deny(clippy::interning_defined_symbol)]` implied by `#[deny(clippy::internal)]`
 
 error: interning a defined symbol
-  --> $DIR/interning_defined_symbol.rs:20:13
+  --> $DIR/interning_defined_symbol.rs:21:13
    |
 LL |     let _ = sym!(f32);
    |             ^^^^^^^^^ help: try: `rustc_span::sym::f32`
 
 error: interning a defined symbol
-  --> $DIR/interning_defined_symbol.rs:23:13
+  --> $DIR/interning_defined_symbol.rs:24:13
    |
 LL |     let _ = Symbol::intern("proc-macro");
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `rustc_span::sym::proc_dash_macro`
 
 error: interning a defined symbol
-  --> $DIR/interning_defined_symbol.rs:26:13
+  --> $DIR/interning_defined_symbol.rs:27:13
    |
 LL |     let _ = Symbol::intern("self");
    |             ^^^^^^^^^^^^^^^^^^^^^^ help: try: `rustc_span::symbol::kw::SelfLower`
diff --git a/tests/ui-internal/invalid_paths.rs b/tests/ui-internal/invalid_paths.rs
index a3b19c2e394..b823ff7fe37 100644
--- a/tests/ui-internal/invalid_paths.rs
+++ b/tests/ui-internal/invalid_paths.rs
@@ -1,4 +1,5 @@
 #![warn(clippy::internal)]
+#![allow(clippy::missing_clippy_version_attribute)]
 
 mod paths {
     // Good path
diff --git a/tests/ui-internal/invalid_paths.stderr b/tests/ui-internal/invalid_paths.stderr
index 20aa81b98a0..0a8e5427978 100644
--- a/tests/ui-internal/invalid_paths.stderr
+++ b/tests/ui-internal/invalid_paths.stderr
@@ -1,5 +1,5 @@
 error: invalid path
-  --> $DIR/invalid_paths.rs:17:5
+  --> $DIR/invalid_paths.rs:18:5
    |
 LL |     pub const BAD_CRATE_PATH: [&str; 2] = ["bad", "path"];
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -7,7 +7,7 @@ LL |     pub const BAD_CRATE_PATH: [&str; 2] = ["bad", "path"];
    = note: `-D clippy::invalid-paths` implied by `-D warnings`
 
 error: invalid path
-  --> $DIR/invalid_paths.rs:20:5
+  --> $DIR/invalid_paths.rs:21:5
    |
 LL |     pub const BAD_MOD_PATH: [&str; 2] = ["std", "xxx"];
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui-internal/lint_without_lint_pass.rs b/tests/ui-internal/lint_without_lint_pass.rs
index beaef79a340..1fd03cfe36d 100644
--- a/tests/ui-internal/lint_without_lint_pass.rs
+++ b/tests/ui-internal/lint_without_lint_pass.rs
@@ -1,4 +1,5 @@
 #![deny(clippy::internal)]
+#![allow(clippy::missing_clippy_version_attribute)]
 #![feature(rustc_private)]
 
 #[macro_use]
diff --git a/tests/ui-internal/lint_without_lint_pass.stderr b/tests/ui-internal/lint_without_lint_pass.stderr
index e308e13da13..de04920b8e6 100644
--- a/tests/ui-internal/lint_without_lint_pass.stderr
+++ b/tests/ui-internal/lint_without_lint_pass.stderr
@@ -1,5 +1,5 @@
 error: the lint `TEST_LINT` is not added to any `LintPass`
-  --> $DIR/lint_without_lint_pass.rs:11:1
+  --> $DIR/lint_without_lint_pass.rs:12:1
    |
 LL | / declare_tool_lint! {
 LL | |     pub clippy::TEST_LINT,
diff --git a/tests/ui-internal/match_type_on_diag_item.rs b/tests/ui-internal/match_type_on_diag_item.rs
index be7b7a9af19..4b41ff15e80 100644
--- a/tests/ui-internal/match_type_on_diag_item.rs
+++ b/tests/ui-internal/match_type_on_diag_item.rs
@@ -1,4 +1,5 @@
 #![deny(clippy::internal)]
+#![allow(clippy::missing_clippy_version_attribute)]
 #![feature(rustc_private)]
 
 extern crate clippy_utils;
diff --git a/tests/ui-internal/match_type_on_diag_item.stderr b/tests/ui-internal/match_type_on_diag_item.stderr
index bf1d67e6054..e3cb6b6c22e 100644
--- a/tests/ui-internal/match_type_on_diag_item.stderr
+++ b/tests/ui-internal/match_type_on_diag_item.stderr
@@ -1,5 +1,5 @@
 error: usage of `clippy_utils::ty::match_type()` on a type diagnostic item
-  --> $DIR/match_type_on_diag_item.rs:30:17
+  --> $DIR/match_type_on_diag_item.rs:31:17
    |
 LL |         let _ = match_type(cx, ty, &OPTION);
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `clippy_utils::ty::is_type_diagnostic_item(cx, ty, sym::Option)`
@@ -12,13 +12,13 @@ LL | #![deny(clippy::internal)]
    = note: `#[deny(clippy::match_type_on_diagnostic_item)]` implied by `#[deny(clippy::internal)]`
 
 error: usage of `clippy_utils::ty::match_type()` on a type diagnostic item
-  --> $DIR/match_type_on_diag_item.rs:31:17
+  --> $DIR/match_type_on_diag_item.rs:32:17
    |
 LL |         let _ = match_type(cx, ty, &["core", "result", "Result"]);
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `clippy_utils::ty::is_type_diagnostic_item(cx, ty, sym::Result)`
 
 error: usage of `clippy_utils::ty::match_type()` on a type diagnostic item
-  --> $DIR/match_type_on_diag_item.rs:34:17
+  --> $DIR/match_type_on_diag_item.rs:35:17
    |
 LL |         let _ = clippy_utils::ty::match_type(cx, ty, rc_path);
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `clippy_utils::ty::is_type_diagnostic_item(cx, ty, sym::Rc)`
diff --git a/tests/ui-internal/outer_expn_data.fixed b/tests/ui-internal/outer_expn_data.fixed
index b0b3498f057..bb82faf0c90 100644
--- a/tests/ui-internal/outer_expn_data.fixed
+++ b/tests/ui-internal/outer_expn_data.fixed
@@ -1,6 +1,7 @@
 // run-rustfix
 
 #![deny(clippy::internal)]
+#![allow(clippy::missing_clippy_version_attribute)]
 #![feature(rustc_private)]
 
 extern crate rustc_hir;
diff --git a/tests/ui-internal/outer_expn_data.rs b/tests/ui-internal/outer_expn_data.rs
index 55a3fed00d0..187d468b392 100644
--- a/tests/ui-internal/outer_expn_data.rs
+++ b/tests/ui-internal/outer_expn_data.rs
@@ -1,6 +1,7 @@
 // run-rustfix
 
 #![deny(clippy::internal)]
+#![allow(clippy::missing_clippy_version_attribute)]
 #![feature(rustc_private)]
 
 extern crate rustc_hir;
diff --git a/tests/ui-internal/outer_expn_data.stderr b/tests/ui-internal/outer_expn_data.stderr
index 56b6ce1f78e..afef696785e 100644
--- a/tests/ui-internal/outer_expn_data.stderr
+++ b/tests/ui-internal/outer_expn_data.stderr
@@ -1,5 +1,5 @@
 error: usage of `outer_expn().expn_data()`
-  --> $DIR/outer_expn_data.rs:24:34
+  --> $DIR/outer_expn_data.rs:25:34
    |
 LL |         let _ = expr.span.ctxt().outer_expn().expn_data();
    |                                  ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `outer_expn_data()`
diff --git a/tests/ui-internal/unnecessary_symbol_str.fixed b/tests/ui-internal/unnecessary_symbol_str.fixed
index 95b8c6dfe89..4f5336663a8 100644
--- a/tests/ui-internal/unnecessary_symbol_str.fixed
+++ b/tests/ui-internal/unnecessary_symbol_str.fixed
@@ -1,7 +1,11 @@
 // run-rustfix
 #![feature(rustc_private)]
 #![deny(clippy::internal)]
-#![allow(clippy::unnecessary_operation, unused_must_use)]
+#![allow(
+    clippy::unnecessary_operation,
+    unused_must_use,
+    clippy::missing_clippy_version_attribute
+)]
 
 extern crate rustc_span;
 
diff --git a/tests/ui-internal/unnecessary_symbol_str.rs b/tests/ui-internal/unnecessary_symbol_str.rs
index ad6937cf60a..894aa1d3bc6 100644
--- a/tests/ui-internal/unnecessary_symbol_str.rs
+++ b/tests/ui-internal/unnecessary_symbol_str.rs
@@ -1,7 +1,11 @@
 // run-rustfix
 #![feature(rustc_private)]
 #![deny(clippy::internal)]
-#![allow(clippy::unnecessary_operation, unused_must_use)]
+#![allow(
+    clippy::unnecessary_operation,
+    unused_must_use,
+    clippy::missing_clippy_version_attribute
+)]
 
 extern crate rustc_span;
 
diff --git a/tests/ui-internal/unnecessary_symbol_str.stderr b/tests/ui-internal/unnecessary_symbol_str.stderr
index 12e05eaa7a0..75367bf4bc5 100644
--- a/tests/ui-internal/unnecessary_symbol_str.stderr
+++ b/tests/ui-internal/unnecessary_symbol_str.stderr
@@ -1,5 +1,5 @@
 error: unnecessary `Symbol` to string conversion
-  --> $DIR/unnecessary_symbol_str.rs:11:5
+  --> $DIR/unnecessary_symbol_str.rs:15:5
    |
 LL |     Symbol::intern("foo").as_str() == "clippy";
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Symbol::intern("foo") == rustc_span::sym::clippy`
@@ -12,25 +12,25 @@ LL | #![deny(clippy::internal)]
    = note: `#[deny(clippy::unnecessary_symbol_str)]` implied by `#[deny(clippy::internal)]`
 
 error: unnecessary `Symbol` to string conversion
-  --> $DIR/unnecessary_symbol_str.rs:12:5
+  --> $DIR/unnecessary_symbol_str.rs:16:5
    |
 LL |     Symbol::intern("foo").to_string() == "self";
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Symbol::intern("foo") == rustc_span::symbol::kw::SelfLower`
 
 error: unnecessary `Symbol` to string conversion
-  --> $DIR/unnecessary_symbol_str.rs:13:5
+  --> $DIR/unnecessary_symbol_str.rs:17:5
    |
 LL |     Symbol::intern("foo").to_ident_string() != "Self";
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Symbol::intern("foo") != rustc_span::symbol::kw::SelfUpper`
 
 error: unnecessary `Symbol` to string conversion
-  --> $DIR/unnecessary_symbol_str.rs:14:5
+  --> $DIR/unnecessary_symbol_str.rs:18:5
    |
 LL |     &*Ident::empty().as_str() == "clippy";
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Ident::empty().name == rustc_span::sym::clippy`
 
 error: unnecessary `Symbol` to string conversion
-  --> $DIR/unnecessary_symbol_str.rs:15:5
+  --> $DIR/unnecessary_symbol_str.rs:19:5
    |
 LL |     "clippy" == Ident::empty().to_string();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `rustc_span::sym::clippy == Ident::empty().name`
diff --git a/util/gh-pages/index.html b/util/gh-pages/index.html
index c1df8ed9fc8..58e8b4f4829 100644
--- a/util/gh-pages/index.html
+++ b/util/gh-pages/index.html
@@ -347,7 +347,8 @@ Otherwise, have a great day =^.^=
                         </div>
                         <!-- Clippy version -->
                         <div class="lint-additional-info-item">
-                            Added in: <span class="label label-default label-version">{{lint.version}}</span>
+                            <span>{{lint.group == "deprecated" ? "Deprecated" : "Added"}} in: </span>
+                            <span class="label label-default label-version">{{lint.version}}</span>
                         </div>
                         <!-- Open related issues -->
                         <div class="lint-additional-info-item">
-- 
cgit 1.4.1-3-g733a5


From 27a1763eac38123bc206c77cb8b1431671afa81a Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Fri, 5 Nov 2021 17:05:04 -0500
Subject: Make author DRYer

---
 clippy_lints/src/lib.rs          |    1 +
 clippy_lints/src/utils/author.rs | 1340 ++++++++++++++------------------------
 tests/ui/author/blocks.stdout    |   16 +-
 tests/ui/author/if.stdout        |   24 +-
 tests/ui/author/loop.stdout      |   44 +-
 tests/ui/author/matches.stdout   |    5 +-
 tests/ui/author/repeat.stdout    |    3 +-
 tests/ui/author/struct.stdout    |   35 +-
 8 files changed, 553 insertions(+), 915 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index bc302046b2d..ced879b6b2c 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -2,6 +2,7 @@
 
 #![feature(box_patterns)]
 #![feature(drain_filter)]
+#![feature(format_args_capture)]
 #![feature(in_band_lifetimes)]
 #![feature(iter_zip)]
 #![feature(once_cell)]
diff --git a/clippy_lints/src/utils/author.rs b/clippy_lints/src/utils/author.rs
index 79186fbe035..d20bf341318 100644
--- a/clippy_lints/src/utils/author.rs
+++ b/clippy_lints/src/utils/author.rs
@@ -3,14 +3,14 @@
 
 use clippy_utils::{get_attr, higher};
 use rustc_ast::ast::{LitFloatType, LitKind};
-use rustc_ast::{walk_list, Label, LitIntType};
+use rustc_ast::LitIntType;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_hir as hir;
-use rustc_hir::intravisit::{NestedVisitorMap, Visitor};
-use rustc_hir::{Arm, Block, Expr, ExprKind, FnRetTy, Lit, MatchSource, Pat, PatKind, QPath, Stmt, StmtKind, TyKind};
+use rustc_hir::{ExprKind, FnRetTy, HirId, Lit, PatKind, QPath, StmtKind, TyKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
-use rustc_middle::hir::map::Map;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::symbol::{Ident, Symbol};
+use std::fmt::{Display, Formatter, Write as _};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -53,6 +53,42 @@ declare_clippy_lint! {
 
 declare_lint_pass!(Author => [LINT_AUTHOR]);
 
+/// Writes a line of output with indentation added
+macro_rules! out {
+    ($($t:tt)*) => {
+        println!("    {}", format_args!($($t)*))
+    };
+}
+
+/// The variables passed in are replaced with `&Binding`s where the `value` field is set
+/// to the original value of the variable. The `name` field is set to the name of the variable
+/// (using `stringify!`) and is adjusted to avoid duplicate names.
+/// Note that the `Binding` may be printed directly to output the `name`.
+macro_rules! bind {
+    ($self:ident $(, $name:ident)+) => {
+        $(let $name = & $self.bind(stringify!($name), $name);)+
+    };
+}
+
+/// Transforms the given `Option<T>` varibles into `OptionPat<Binding<T>>`.
+/// This displays as `Some($name)` or `None` when printed. The name of the inner binding
+/// is set to the name of the variable passed to the macro.
+macro_rules! opt_bind {
+    ($self:ident $(, $name:ident)+) => {
+        $(let $name = OptionPat::new($name.map(|o| $self.bind(stringify!($name), o)));)+
+    };
+}
+
+/// Creates a `Binding` that accesses the field of an existing `Binding`
+macro_rules! field {
+    ($binding:ident.$field:ident) => {
+        &Binding {
+            name: $binding.name.to_string() + stringify!(.$field),
+            value: $binding.value.$field,
+        }
+    };
+}
+
 fn prelude() {
     println!("if_chain! {{");
 }
@@ -66,1005 +102,594 @@ fn done() {
 
 impl<'tcx> LateLintPass<'tcx> for Author {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) {
-        if !has_attr(cx, item.hir_id()) {
-            return;
-        }
-        prelude();
-        PrintVisitor::new("item", cx).visit_item(item);
-        done();
+        check_item(cx, item.hir_id());
     }
 
     fn check_impl_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::ImplItem<'_>) {
-        if !has_attr(cx, item.hir_id()) {
-            return;
-        }
-        prelude();
-        PrintVisitor::new("item", cx).visit_impl_item(item);
-        done();
+        check_item(cx, item.hir_id());
     }
 
     fn check_trait_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::TraitItem<'_>) {
-        if !has_attr(cx, item.hir_id()) {
-            return;
-        }
-        prelude();
-        PrintVisitor::new("item", cx).visit_trait_item(item);
-        done();
-    }
-
-    fn check_variant(&mut self, cx: &LateContext<'tcx>, var: &'tcx hir::Variant<'_>) {
-        if !has_attr(cx, var.id) {
-            return;
-        }
-        prelude();
-        let parent_hir_id = cx.tcx.hir().get_parent_node(var.id);
-        PrintVisitor::new("var", cx).visit_variant(var, &hir::Generics::empty(), parent_hir_id);
-        done();
+        check_item(cx, item.hir_id());
     }
 
-    fn check_field_def(&mut self, cx: &LateContext<'tcx>, field: &'tcx hir::FieldDef<'_>) {
-        if !has_attr(cx, field.hir_id) {
-            return;
-        }
-        prelude();
-        PrintVisitor::new("field", cx).visit_field_def(field);
-        done();
+    fn check_arm(&mut self, cx: &LateContext<'tcx>, arm: &'tcx hir::Arm<'_>) {
+        check_node(cx, arm.hir_id, |v| {
+            v.arm(&v.bind("arm", arm));
+        });
     }
 
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
-        if !has_attr(cx, expr.hir_id) {
-            return;
-        }
-        prelude();
-        PrintVisitor::new("expr", cx).visit_expr(expr);
-        done();
-    }
-
-    fn check_arm(&mut self, cx: &LateContext<'tcx>, arm: &'tcx hir::Arm<'_>) {
-        if !has_attr(cx, arm.hir_id) {
-            return;
-        }
-        prelude();
-        PrintVisitor::new("arm", cx).visit_arm(arm);
-        done();
+        check_node(cx, expr.hir_id, |v| {
+            v.expr(&v.bind("expr", expr));
+        });
     }
 
     fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx hir::Stmt<'_>) {
-        if !has_attr(cx, stmt.hir_id) {
-            return;
-        }
         match stmt.kind {
             StmtKind::Expr(e) | StmtKind::Semi(e) if has_attr(cx, e.hir_id) => return,
             _ => {},
         }
+        check_node(cx, stmt.hir_id, |v| {
+            v.stmt(&v.bind("stmt", stmt));
+        });
+    }
+}
+
+fn check_item(cx: &LateContext<'_>, hir_id: HirId) {
+    let hir = cx.tcx.hir();
+    if let Some(body_id) = hir.maybe_body_owned_by(hir_id) {
+        check_node(cx, hir_id, |v| {
+            v.expr(&v.bind("expr", &hir.body(body_id).value));
+        });
+    }
+}
+
+fn check_node(cx: &LateContext<'_>, hir_id: HirId, f: impl Fn(&PrintVisitor<'_, '_>)) {
+    if has_attr(cx, hir_id) {
         prelude();
-        PrintVisitor::new("stmt", cx).visit_stmt(stmt);
+        f(&PrintVisitor::new(cx));
         done();
     }
+}
 
-    fn check_foreign_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::ForeignItem<'_>) {
-        if !has_attr(cx, item.hir_id()) {
-            return;
+struct Binding<T> {
+    name: String,
+    value: T,
+}
+
+impl<T> Display for Binding<T> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.write_str(&self.name)
+    }
+}
+
+struct OptionPat<T> {
+    pub opt: Option<T>,
+}
+
+impl<T> OptionPat<T> {
+    fn new(opt: Option<T>) -> Self {
+        Self { opt }
+    }
+
+    fn if_some(&self, f: impl Fn(&T)) {
+        if let Some(t) = &self.opt {
+            f(t);
+        }
+    }
+}
+
+impl<T: Display> Display for OptionPat<T> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match &self.opt {
+            None => f.write_str("None"),
+            Some(node) => write!(f, "Some({node})"),
         }
-        prelude();
-        PrintVisitor::new("item", cx).visit_foreign_item(item);
-        done();
     }
 }
 
+struct PrintVisitor<'a, 'tcx> {
+    cx: &'a LateContext<'tcx>,
+    /// Fields are the current index that needs to be appended to pattern
+    /// binding names
+    ids: std::cell::Cell<FxHashMap<&'static str, u32>>,
+}
+
+#[allow(clippy::unused_self)]
 impl<'a, 'tcx> PrintVisitor<'a, 'tcx> {
-    #[must_use]
-    fn new(s: &'static str, cx: &'a LateContext<'tcx>) -> Self {
+    fn new(cx: &'a LateContext<'tcx>) -> Self {
         Self {
-            ids: FxHashMap::default(),
-            current: s.to_owned(),
             cx,
+            ids: std::cell::Cell::default(),
         }
     }
 
-    fn next(&mut self, s: &'static str) -> String {
-        use std::collections::hash_map::Entry::{Occupied, Vacant};
-        match self.ids.entry(s) {
-            // already there: start numbering from `1`
-            Occupied(mut occ) => {
-                let val = occ.get_mut();
-                *val += 1;
-                format!("{}{}", s, *val)
-            },
-            // not there: insert and return name as given
-            Vacant(vac) => {
-                vac.insert(0);
-                s.to_owned()
+    fn next(&self, s: &'static str) -> String {
+        let mut ids = self.ids.take();
+        let out = match *ids.entry(s).and_modify(|n| *n += 1).or_default() {
+            // first usage of the name, use it as is
+            0 => s.to_string(),
+            // append a number starting with 1
+            n => format!("{s}{n}"),
+        };
+        self.ids.set(ids);
+        out
+    }
+
+    fn bind<T>(&self, name: &'static str, value: T) -> Binding<T> {
+        let name = self.next(name);
+        Binding { name, value }
+    }
+
+    fn option<T: Copy>(&self, option: &Binding<Option<T>>, name: &'static str, f: impl Fn(&Binding<T>)) {
+        match option.value {
+            None => out!("if {option}.is_none();"),
+            Some(value) => {
+                let value = &self.bind(name, value);
+                out!("if let Some({value}) = {option};");
+                f(value);
             },
         }
     }
 
-    fn print_qpath(&mut self, path: &QPath<'_>) {
-        if let QPath::LangItem(lang_item, _) = *path {
-            println!(
-                "    if matches!({}, QPath::LangItem(LangItem::{:?}, _));",
-                self.current, lang_item,
-            );
+    fn slice<T>(&self, slice: &Binding<&[T]>, f: impl Fn(&Binding<&T>)) {
+        if slice.value.is_empty() {
+            out!("if {slice}.is_empty();");
         } else {
-            print!("    if match_qpath({}, &[", self.current);
-            print_path(path, &mut true);
-            println!("]);");
+            out!("if {slice}.len() == {};", slice.value.len());
+            for (i, value) in slice.value.iter().enumerate() {
+                let name = format!("{slice}[{i}]");
+                f(&Binding { name, value });
+            }
         }
     }
 
-    fn print_label(&mut self, label: Option<Label>) {
-        if let Some(label) = label {
-            let label_bind = self.next("label");
+    fn destination(&self, destination: &Binding<hir::Destination>) {
+        self.option(field!(destination.label), "label", |label| {
+            self.ident(field!(label.ident));
+        });
+    }
 
-            println!("    if let Some({}) = {};", label_bind, self.current);
+    fn ident(&self, ident: &Binding<Ident>) {
+        out!("if {ident}.as_str() == {:?};", ident.value.as_str());
+    }
 
-            let label_name_bind = self.next("label_name");
-            let label_name = label.ident.name;
+    fn symbol(&self, symbol: &Binding<Symbol>) {
+        out!("if {symbol}.as_str() == {:?};", symbol.value.as_str());
+    }
 
-            println!(
-                "    if {}.ident.name.as_str() == {:?};",
-                label_name_bind,
-                label_name.as_str()
-            );
+    fn qpath(&self, qpath: &Binding<&QPath<'_>>) {
+        if let QPath::LangItem(lang_item, _) = *qpath.value {
+            out!("if matches!({qpath}, QPath::LangItem(LangItem::{lang_item:?}, _));");
+        } else {
+            out!("if match_qpath({qpath}, &[{}]);", path_to_string(qpath.value));
         }
     }
 
-    fn print_lit_expr(&mut self, lit: &Lit, current: &str) {
-        let lit_pat = self.next("lit");
-
-        println!("Lit(ref {}) = {};", lit_pat, current);
+    fn lit(&self, lit: &Binding<&Lit>) {
+        let kind = |kind| out!("if let LitKind::{kind} = {lit}.node;");
+        macro_rules! kind {
+            ($($t:tt)*) => (kind(format_args!($($t)*)));
+        }
 
-        match lit.node {
-            LitKind::Bool(val) => println!("    if let LitKind::Bool({:?}) = {}.node;", val, lit_pat),
-            LitKind::Char(c) => println!("    if let LitKind::Char({:?}) = {}.node;", c, lit_pat),
-            LitKind::Err(val) => println!("    if let LitKind::Err({}) = {}.node;", val, lit_pat),
-            LitKind::Byte(b) => println!("    if let LitKind::Byte({}) = {}.node;", b, lit_pat),
+        match lit.value.node {
+            LitKind::Bool(val) => kind!("Bool({val:?})"),
+            LitKind::Char(c) => kind!("Char({c:?})"),
+            LitKind::Err(val) => kind!("Err({val})"),
+            LitKind::Byte(b) => kind!("Byte({b})"),
             LitKind::Int(i, suffix) => {
                 let int_ty = match suffix {
-                    LitIntType::Signed(int_ty) => format!("LitIntType::Signed(IntTy::{:?})", int_ty),
-                    LitIntType::Unsigned(uint_ty) => format!("LitIntType::Unsigned(UintTy::{:?})", uint_ty),
+                    LitIntType::Signed(int_ty) => format!("LitIntType::Signed(IntTy::{int_ty:?})"),
+                    LitIntType::Unsigned(uint_ty) => format!("LitIntType::Unsigned(UintTy::{uint_ty:?})"),
                     LitIntType::Unsuffixed => String::from("LitIntType::Unsuffixed"),
                 };
-
-                println!("    if let LitKind::Int({}, {}) = {}.node;", i, int_ty, lit_pat);
+                kind!("Int({i}, {int_ty})");
             },
             LitKind::Float(_, suffix) => {
                 let float_ty = match suffix {
-                    LitFloatType::Suffixed(suffix_ty) => format!("LitFloatType::Suffixed(FloatTy::{:?})", suffix_ty),
+                    LitFloatType::Suffixed(suffix_ty) => format!("LitFloatType::Suffixed(FloatTy::{suffix_ty:?})"),
                     LitFloatType::Unsuffixed => String::from("LitFloatType::Unsuffixed"),
                 };
-
-                println!("    if let LitKind::Float(_, {}) = {}.node;", float_ty, lit_pat);
+                kind!("Float(_, {float_ty})");
             },
             LitKind::ByteStr(ref vec) => {
-                let vec_pat = self.next("vec");
-
-                println!("    if let LitKind::ByteStr(ref {}) = {}.node;", vec_pat, lit_pat);
-                println!("    if let [{:?}] = **{};", vec, vec_pat);
+                bind!(self, vec);
+                kind!("ByteStr(ref {vec})");
+                out!("if let [{:?}] = **{vec};", vec.value);
             },
-            LitKind::Str(text, _) => {
-                let str_pat = self.next("s");
-
-                println!("    if let LitKind::Str({}, _) = {}.node;", str_pat, lit_pat);
-                println!("    if {}.as_str() == {:?};", str_pat, &*text.as_str());
+            LitKind::Str(s, _) => {
+                bind!(self, s);
+                kind!("Str({s}, _)");
+                self.symbol(s);
             },
         }
     }
 
-    fn print_match_expr(&mut self, expr: &Expr<'_>, arms: &[Arm<'_>], des: MatchSource, current: &str) {
-        let expr_pat = self.next("scrutinee");
-        let arms_pat = self.next("arms");
-
-        println!(
-            "Match({}, {}, MatchSource::{:?}) = {};",
-            expr_pat, arms_pat, des, current
-        );
-
-        self.current = expr_pat;
-        self.visit_expr(expr);
-
-        println!("    if {}.len() == {};", arms_pat, arms.len());
-
-        for (i, arm) in arms.iter().enumerate() {
-            self.current = format!("{}[{}].pat", arms_pat, i);
-            self.visit_pat(arm.pat);
-
-            if let Some(guard) = &arm.guard {
-                let guard_pat = self.next("guard");
-
-                println!("    if let Some({}) = &{}[{}].guard;", guard_pat, arms_pat, i);
-
-                match guard {
-                    hir::Guard::If(if_expr) => {
-                        let if_expr_pat = self.next("expr");
-
-                        println!("    if let Guard::If({}) = {};", if_expr_pat, guard_pat);
-
-                        self.current = if_expr_pat;
-                        self.visit_expr(if_expr);
-                    },
-                    hir::Guard::IfLet(if_let_pat, if_let_expr) => {
-                        let if_let_pat_pat = self.next("pat");
-                        let if_let_expr_pat = self.next("expr");
-
-                        println!(
-                            "    if let Guard::IfLet({}, {}) = {};",
-                            if_let_pat_pat, if_let_expr_pat, guard_pat
-                        );
-
-                        self.current = if_let_expr_pat;
-                        self.visit_expr(if_let_expr);
-
-                        self.current = if_let_pat_pat;
-                        self.visit_pat(if_let_pat);
-                    },
-                }
-            }
-            self.current = format!("{}[{}].body", arms_pat, i);
-            self.visit_expr(arm.body);
+    fn arm(&self, arm: &Binding<&hir::Arm<'_>>) {
+        self.pat(field!(arm.pat));
+        match arm.value.guard {
+            None => out!("if {arm}.guard.is_none();"),
+            Some(hir::Guard::If(expr)) => {
+                bind!(self, expr);
+                out!("if let Some(Guard::If({expr})) = {arm}.guard;");
+                self.expr(expr);
+            },
+            Some(hir::Guard::IfLet(pat, expr)) => {
+                bind!(self, pat, expr);
+                out!("if let Some(Guard::IfLet({pat}, {expr}) = {arm}.guard;");
+                self.pat(pat);
+                self.expr(expr);
+            },
         }
+        self.expr(field!(arm.body));
     }
 
-    fn check_higher(&mut self, expr: &Expr<'_>) -> bool {
-        if let Some(higher::While { condition, body }) = higher::While::hir(expr) {
-            let condition_pat = self.next("condition");
-            let body_pat = self.next("body");
-
-            println!(
-                "    if let Some(higher::While {{ condition: {}, body: {} }}) = higher::While::hir({});",
-                condition_pat, body_pat, self.current
+    #[allow(clippy::too_many_lines)]
+    fn expr(&self, expr: &Binding<&hir::Expr<'_>>) {
+        if let Some(higher::While { condition, body }) = higher::While::hir(expr.value) {
+            bind!(self, condition, body);
+            out!(
+                "if let Some(higher::While {{ condition: {condition}, body: {body} }}) \
+                = higher::While::hir({expr});"
             );
-
-            self.current = condition_pat;
-            self.visit_expr(condition);
-
-            self.current = body_pat;
-            self.visit_expr(body);
-
-            return true;
+            self.expr(condition);
+            self.expr(body);
+            return;
         }
 
         if let Some(higher::WhileLet {
             let_pat,
             let_expr,
             if_then,
-        }) = higher::WhileLet::hir(expr)
+        }) = higher::WhileLet::hir(expr.value)
         {
-            let let_pat_ = self.next("let_pat");
-            let let_expr_pat = self.next("let_expr");
-            let if_then_pat = self.next("if_then");
-
-            println!(
-                "    if let Some(higher::WhileLet {{ let_pat: {}, let_expr: {}, if_then: {} }}) = higher::WhileLet::hir({});",
-                let_pat_, let_expr_pat, if_then_pat, self.current
+            bind!(self, let_pat, let_expr, if_then);
+            out!(
+                "if let Some(higher::WhileLet {{ let_pat: {let_pat}, let_expr: {let_expr}, if_then: {if_then} }}) \
+                = higher::WhileLet::hir({expr});"
             );
-
-            self.current = let_pat_;
-            self.visit_pat(let_pat);
-
-            self.current = let_expr_pat;
-            self.visit_expr(let_expr);
-
-            self.current = if_then_pat;
-            self.visit_expr(if_then);
-
-            return true;
-        }
-
-        if let Some(higher::IfLet {
-            let_pat,
-            let_expr,
-            if_then,
-            if_else,
-        }) = higher::IfLet::hir(self.cx, expr)
-        {
-            let let_pat_ = self.next("let_pat");
-            let let_expr_pat = self.next("let_expr");
-            let if_then_pat = self.next("if_then");
-            let else_pat = self.next("else_expr");
-
-            println!(
-                "    if let Some(higher::IfLet {{ let_pat: {}, let_expr: {}, if_then: {}, if_else: {}}}) = higher::IfLet::hir({});",
-                let_pat_, let_expr_pat, if_then_pat, else_pat, self.current
-            );
-
-            self.current = let_pat_;
-            self.visit_pat(let_pat);
-
-            self.current = let_expr_pat;
-            self.visit_expr(let_expr);
-
-            self.current = if_then_pat;
-            self.visit_expr(if_then);
-
-            if let Some(else_expr) = if_else {
-                self.current = else_pat;
-                self.visit_expr(else_expr);
-            }
-
-            return true;
-        }
-
-        if let Some(higher::If { cond, then, r#else }) = higher::If::hir(expr) {
-            let cond_pat = self.next("cond");
-            let then_pat = self.next("then");
-            let else_pat = self.next("else_expr");
-
-            println!(
-                "    if let Some(higher::If {{ cond: {}, then: {}, r#else: {}}}) = higher::If::hir({});",
-                cond_pat, then_pat, else_pat, self.current
-            );
-
-            self.current = cond_pat;
-            self.visit_expr(cond);
-
-            self.current = then_pat;
-            self.visit_expr(then);
-
-            if let Some(else_expr) = r#else {
-                self.current = else_pat;
-                self.visit_expr(else_expr);
-            }
-
-            return true;
+            self.pat(let_pat);
+            self.expr(let_expr);
+            self.expr(if_then);
+            return;
         }
 
-        if let Some(higher::ForLoop { pat, arg, body, .. }) = higher::ForLoop::hir(expr) {
-            let pat_ = self.next("pat");
-            let arg_pat = self.next("arg");
-            let body_pat = self.next("body");
-
-            println!(
-                "    if let Some(higher::ForLoop {{ pat: {}, arg: {}, body: {}, ..}}) = higher::ForLoop::hir({});",
-                pat_, arg_pat, body_pat, self.current
+        if let Some(higher::ForLoop { pat, arg, body, .. }) = higher::ForLoop::hir(expr.value) {
+            bind!(self, pat, arg, body);
+            out!(
+                "if let Some(higher::ForLoop {{ pat: {pat}, arg: {arg}, body: {body}, .. }}) \
+                = higher::ForLoop::hir({expr});"
             );
-
-            self.current = pat_;
-            self.visit_pat(pat);
-
-            self.current = arg_pat;
-            self.visit_expr(arg);
-
-            self.current = body_pat;
-            self.visit_expr(body);
-
-            return true;
-        }
-
-        false
-    }
-}
-
-struct PrintVisitor<'a, 'tcx> {
-    /// Fields are the current index that needs to be appended to pattern
-    /// binding names
-    ids: FxHashMap<&'static str, usize>,
-    /// the name that needs to be destructured
-    current: String,
-    cx: &'a LateContext<'tcx>,
-}
-
-impl<'a, 'tcx> Visitor<'tcx> for PrintVisitor<'a, '_> {
-    type Map = Map<'tcx>;
-
-    #[allow(clippy::too_many_lines)]
-    fn visit_expr(&mut self, expr: &Expr<'_>) {
-        if self.check_higher(expr) {
+            self.pat(pat);
+            self.expr(arg);
+            self.expr(body);
             return;
         }
 
-        print!("    if let ExprKind::");
-        let current = format!("{}.kind", self.current);
+        let kind = |kind| out!("if let ExprKind::{kind} = {expr}.kind;");
+        macro_rules! kind {
+            ($($t:tt)*) => (kind(format_args!($($t)*)));
+        }
 
-        match expr.kind {
+        match expr.value.kind {
             ExprKind::Let(pat, expr, _) => {
-                let let_pat = self.next("pat");
-                let let_expr = self.next("expr");
-
-                println!("Let({}, {}, _) = {};", let_pat, let_expr, current);
-
-                self.current = let_expr;
-                self.visit_expr(expr);
-
-                self.current = let_pat;
-                self.visit_pat(pat);
+                bind!(self, pat, expr);
+                kind!("Let({pat}, {expr}, _)");
+                self.pat(pat);
+                self.expr(expr);
             },
             ExprKind::Box(inner) => {
-                let inner_pat = self.next("inner");
-
-                println!("Box({}) = {};", inner_pat, current);
-
-                self.current = inner_pat;
-                self.visit_expr(inner);
+                bind!(self, inner);
+                kind!("Box({inner})");
+                self.expr(inner);
             },
             ExprKind::Array(elements) => {
-                let elements_pat = self.next("elements");
-
-                println!("Array({}) = {};", elements_pat, current);
-
-                println!("    if {}.len() == {};", elements_pat, elements.len());
-
-                for (i, element) in elements.iter().enumerate() {
-                    self.current = format!("{}[{}]", elements_pat, i);
-                    self.visit_expr(element);
-                }
+                bind!(self, elements);
+                kind!("Array({elements})");
+                self.slice(elements, |e| self.expr(e));
             },
             ExprKind::Call(func, args) => {
-                let func_pat = self.next("func");
-                let args_pat = self.next("args");
-
-                println!("Call({}, {}) = {};", func_pat, args_pat, current);
-
-                self.current = func_pat;
-                self.visit_expr(func);
-
-                println!("    if {}.len() == {};", args_pat, args.len());
-
-                for (i, arg) in args.iter().enumerate() {
-                    self.current = format!("{}[{}]", args_pat, i);
-                    self.visit_expr(arg);
-                }
+                bind!(self, func, args);
+                kind!("Call({func}, {args})");
+                self.expr(func);
+                self.slice(args, |e| self.expr(e));
             },
             ExprKind::MethodCall(method_name, _, args, _) => {
-                let method_name_pat = self.next("method_name");
-                let args_pat = self.next("args");
-
-                println!("MethodCall({}, _, {}, _) = {};", method_name_pat, args_pat, current);
-
-                println!(
-                    "    if {}.ident.name.as_str() == {};",
-                    method_name_pat,
-                    method_name.ident.name.as_str()
-                );
-
-                println!("    if {}.len() == {};", args_pat, args.len());
-
-                for (i, arg) in args.iter().enumerate() {
-                    self.current = format!("{}[{}]", args_pat, i);
-                    self.visit_expr(arg);
-                }
+                bind!(self, method_name, args);
+                kind!("MethodCall({method_name}, _, {args}, _)");
+                self.ident(field!(method_name.ident));
+                self.slice(args, |e| self.expr(e));
             },
             ExprKind::Tup(elements) => {
-                let elements_pat = self.next("elements");
-
-                println!("Tup({}) = {};", elements_pat, current);
-
-                println!("    if {}.len() == {};", elements_pat, elements.len());
-
-                for (i, element) in elements.iter().enumerate() {
-                    self.current = format!("{}[{}]", elements_pat, i);
-                    self.visit_expr(element);
-                }
+                bind!(self, elements);
+                kind!("Tup({elements})");
+                self.slice(elements, |e| self.expr(e));
             },
             ExprKind::Binary(op, left, right) => {
-                let op_pat = self.next("op");
-                let left_pat = self.next("left");
-                let right_pat = self.next("right");
-
-                println!("Binary({}, {}, {}) = {};", op_pat, left_pat, right_pat, current);
-
-                println!("    if BinOpKind::{:?} == {}.node;", op.node, op_pat);
-
-                self.current = left_pat;
-                self.visit_expr(left);
-
-                self.current = right_pat;
-                self.visit_expr(right);
+                bind!(self, op, left, right);
+                kind!("Binary({op}, {left}, {right})");
+                out!("if BinOpKind::{:?} == {op}.node;", op.value.node);
+                self.expr(left);
+                self.expr(right);
             },
             ExprKind::Unary(op, inner) => {
-                let inner_pat = self.next("inner");
-
-                println!("Unary(UnOp::{:?}, {}) = {};", op, inner_pat, current);
-
-                self.current = inner_pat;
-                self.visit_expr(inner);
-            },
-            ExprKind::Lit(ref lit) => self.print_lit_expr(lit, &current),
-            ExprKind::Cast(expr, ty) => {
-                let cast_pat = self.next("expr");
-                let cast_ty = self.next("cast_ty");
-                let qp_label = self.next("qpath");
-
-                println!("Cast({}, {}) = {};", cast_pat, cast_ty, current);
-
-                if let TyKind::Path(ref qp) = ty.kind {
-                    println!("    if let TyKind::Path(ref {}) = {}.kind;", qp_label, cast_ty);
-
-                    self.current = qp_label;
-                    self.print_qpath(qp);
+                bind!(self, inner);
+                kind!("Unary(UnOp::{op:?}, {inner})");
+                self.expr(inner);
+            },
+            ExprKind::Lit(ref lit) => {
+                bind!(self, lit);
+                kind!("Lit(ref {lit})");
+                self.lit(lit);
+            },
+            ExprKind::Cast(expr, cast_ty) => {
+                bind!(self, expr, cast_ty);
+                kind!("Cast({expr}, {cast_ty})");
+                if let TyKind::Path(ref qpath) = cast_ty.value.kind {
+                    bind!(self, qpath);
+                    out!("if let TyKind::Path(ref {qpath}) = {cast_ty}.kind;");
+                    self.qpath(qpath);
                 }
-
-                self.current = cast_pat;
-                self.visit_expr(expr);
+                self.expr(expr);
             },
             ExprKind::Type(expr, _ty) => {
-                let cast_pat = self.next("expr");
-
-                println!("Type({}, _) = {};", cast_pat, current);
-
-                self.current = cast_pat;
-                self.visit_expr(expr);
+                bind!(self, expr);
+                kind!("Type({expr}, _)");
+                self.expr(expr);
             },
             ExprKind::Loop(body, label, des, _) => {
-                let body_pat = self.next("body");
-                let label_pat = self.next("label");
-
-                println!(
-                    "Loop({}, {}, LoopSource::{:?}, _) = {};",
-                    body_pat, label_pat, des, current
-                );
-
-                self.current = body_pat;
-                self.visit_block(body);
-
-                self.current = label_pat;
-                self.print_label(label);
-            },
-            ExprKind::If(_, _, _) => {}, // Covered by check_higher
-            ExprKind::Match(match_expr, arms, des) => self.print_match_expr(match_expr, arms, des, &current),
-            ExprKind::Closure(capture_clause, fn_decl, body_id, _, movability) => {
-                let capture_by = format!("CaptureBy::{:?}", capture_clause);
-
-                let movability = if let Some(movability) = movability {
-                    format!("Some(Movability::{:?})", movability)
-                } else {
-                    String::from("None")
-                };
+                bind!(self, body);
+                opt_bind!(self, label);
+                kind!("Loop({body}, {label}, LoopSource::{des:?}, _)");
+                self.block(body);
+                label.if_some(|l| self.ident(field!(l.ident)));
+            },
+            ExprKind::If(cond, then, else_expr) => {
+                bind!(self, cond, then);
+                opt_bind!(self, else_expr);
+                kind!("If({cond}, {then}, {else_expr})");
+                self.expr(cond);
+                self.expr(then);
+                else_expr.if_some(|e| self.expr(e));
+            },
+            ExprKind::Match(scrutinee, arms, des) => {
+                bind!(self, scrutinee, arms);
+                kind!("Match({scrutinee}, {arms}, MatchSource::{des:?})");
+                self.expr(scrutinee);
+                self.slice(arms, |arm| self.arm(arm));
+            },
+            ExprKind::Closure(capture_by, fn_decl, body_id, _, movability) => {
+                let movability = OptionPat::new(movability.map(|m| format!("Movability::{m:?}")));
 
                 let ret_ty = match fn_decl.output {
                     FnRetTy::DefaultReturn(_) => "FnRetTy::DefaultReturn(_)",
                     FnRetTy::Return(_) => "FnRetTy::Return(_ty)",
                 };
 
-                let fn_decl_pat = self.next("fn_decl");
-                let body_id_pat = self.next("body_id");
-
-                println!(
-                    "Closure({}, {}, {}, _, {}) = {};",
-                    capture_by, fn_decl_pat, body_id_pat, movability, current
-                );
-                println!("    if let {} = {}.output;", ret_ty, fn_decl_pat);
-
-                let hir = self.cx.tcx.hir();
-                let body = hir.body(body_id);
-
-                let body_pat = self.next("body");
-
-                println!("    let {} = cx.tcx.hir().body({});", body_pat, body_id_pat);
-
-                self.current = format!("{}.value", body_pat);
-                self.visit_expr(&body.value);
+                bind!(self, fn_decl, body_id);
+                kind!("Closure(CaptureBy::{capture_by:?}, {fn_decl}, {body_id}, _, {movability})");
+                out!("if let {ret_ty} = {fn_decl}.output;");
+                self.body(body_id);
             },
             ExprKind::Yield(sub, source) => {
-                let sub_pat = self.next("sub");
-
-                println!("Yield(sub, YieldSource::{:?}) = {};", source, current);
-
-                self.current = sub_pat;
-                self.visit_expr(sub);
+                bind!(self, sub);
+                kind!("Yield(sub, YieldSource::{source:?})");
+                self.expr(sub);
             },
             ExprKind::Block(block, label) => {
-                let block_pat = self.next("block");
-                let label_pat = self.next("label");
-
-                println!("Block({}, {}) = {};", block_pat, label_pat, current);
-
-                self.current = block_pat;
-                self.visit_block(block);
-
-                self.current = label_pat;
-                self.print_label(label);
+                bind!(self, block);
+                opt_bind!(self, label);
+                kind!("Block({block}, {label})");
+                self.block(block);
+                label.if_some(|l| self.ident(field!(l.ident)));
             },
             ExprKind::Assign(target, value, _) => {
-                let target_pat = self.next("target");
-                let value_pat = self.next("value");
-
-                println!("Assign({}, {}, _span) = {};", target_pat, value_pat, current);
-
-                self.current = target_pat;
-                self.visit_expr(target);
-
-                self.current = value_pat;
-                self.visit_expr(value);
+                bind!(self, target, value);
+                kind!("Assign({target}, {value}, _span)");
+                self.expr(target);
+                self.expr(value);
             },
             ExprKind::AssignOp(op, target, value) => {
-                let op_pat = self.next("op");
-                let target_pat = self.next("target");
-                let value_pat = self.next("value");
-
-                println!("AssignOp({}, {}, {}) = {};", op_pat, target_pat, value_pat, current);
-
-                println!("    if BinOpKind::{:?} == {}.node;", op.node, op_pat);
-
-                self.current = target_pat;
-                self.visit_expr(target);
-
-                self.current = value_pat;
-                self.visit_expr(value);
-            },
-            ExprKind::Field(object, field_ident) => {
-                let obj_pat = self.next("object");
-                let field_name_pat = self.next("field_name");
-
-                println!("Field({}, {}) = {};", obj_pat, field_name_pat, current);
-                println!("    if {}.as_str() == {:?};", field_name_pat, field_ident.as_str());
-
-                self.current = obj_pat;
-                self.visit_expr(object);
+                bind!(self, op, target, value);
+                kind!("AssignOp({op}, {target}, {value})");
+                out!("if BinOpKind::{:?} == {op}.node;", op.value.node);
+                self.expr(target);
+                self.expr(value);
+            },
+            ExprKind::Field(object, field_name) => {
+                bind!(self, object, field_name);
+                kind!("Field({object}, {field_name})");
+                self.ident(field_name);
+                self.expr(object);
             },
             ExprKind::Index(object, index) => {
-                let object_pat = self.next("object");
-                let index_pat = self.next("index");
-
-                println!("Index({}, {}) = {};", object_pat, index_pat, current);
-
-                self.current = object_pat;
-                self.visit_expr(object);
-
-                self.current = index_pat;
-                self.visit_expr(index);
+                bind!(self, object, index);
+                kind!("Index({object}, {index})");
+                self.expr(object);
+                self.expr(index);
             },
-            ExprKind::Path(ref path) => {
-                let path_pat = self.next("qpath");
-
-                println!("Path(ref {}) = {};", path_pat, current);
-
-                self.current = path_pat;
-                self.print_qpath(path);
+            ExprKind::Path(ref qpath) => {
+                bind!(self, qpath);
+                kind!("Path(ref {qpath})");
+                self.qpath(qpath);
             },
             ExprKind::AddrOf(kind, mutability, inner) => {
-                let inner_pat = self.next("inner");
-
-                println!(
-                    "AddrOf(BorrowKind::{:?}, Mutability::{:?}, {}) = {};",
-                    kind, mutability, inner_pat, current
-                );
-
-                self.current = inner_pat;
-                self.visit_expr(inner);
+                bind!(self, inner);
+                kind!("AddrOf(BorrowKind::{kind:?}, Mutability::{mutability:?}, {inner})");
+                self.expr(inner);
             },
-            ExprKind::Break(destination, opt_value) => {
-                let destination_pat = self.next("destination");
-
-                if let Some(value) = opt_value {
-                    let value_pat = self.next("value");
-
-                    println!("Break({}, Some({})) = {};", destination_pat, value_pat, current);
-
-                    self.current = value_pat;
-                    self.visit_expr(value);
-                } else {
-                    println!("Break({}, None) = {};", destination_pat, current);
-                }
-
-                self.current = format!("{}.label", destination_pat);
-                self.print_label(destination.label);
+            ExprKind::Break(destination, value) => {
+                bind!(self, destination);
+                opt_bind!(self, value);
+                kind!("Break({destination}, {value})");
+                self.destination(destination);
+                value.if_some(|e| self.expr(e));
             },
             ExprKind::Continue(destination) => {
-                let destination_pat = self.next("destination");
-                println!("Continue({}) = {};", destination_pat, current);
-
-                self.current = format!("{}.label", destination_pat);
-                self.print_label(destination.label);
+                bind!(self, destination);
+                kind!("Continue({destination})");
+                self.destination(destination);
             },
-            ExprKind::Ret(opt_value) => {
-                if let Some(value) = opt_value {
-                    let value_pat = self.next("value");
-
-                    println!("Ret(Some({})) = {};", value_pat, current);
-
-                    self.current = value_pat;
-                    self.visit_expr(value);
-                } else {
-                    println!("Ret(None) = {};", current);
-                }
+            ExprKind::Ret(value) => {
+                opt_bind!(self, value);
+                kind!("Ret({value})");
+                value.if_some(|e| self.expr(e));
             },
             ExprKind::InlineAsm(_) => {
-                println!("InlineAsm(_) = {};", current);
-                println!("    // unimplemented: `ExprKind::InlineAsm` is not further destructured at the moment");
+                kind!("InlineAsm(_)");
+                out!("// unimplemented: `ExprKind::InlineAsm` is not further destructured at the moment");
             },
             ExprKind::LlvmInlineAsm(_) => {
-                println!("LlvmInlineAsm(_) = {};", current);
-                println!("    // unimplemented: `ExprKind::LlvmInlineAsm` is not further destructured at the moment");
-            },
-            ExprKind::Struct(path, fields, opt_base) => {
-                let path_pat = self.next("qpath");
-                let fields_pat = self.next("fields");
-
-                if let Some(base) = opt_base {
-                    let base_pat = self.next("base");
-
-                    println!(
-                        "Struct({}, {}, Some({})) = {};",
-                        path_pat, fields_pat, base_pat, current
-                    );
-
-                    self.current = base_pat;
-                    self.visit_expr(base);
-                } else {
-                    println!("Struct({}, {}, None) = {};", path_pat, fields_pat, current);
-                }
-
-                self.current = path_pat;
-                self.print_qpath(path);
-
-                println!("    if {}.len() == {};", fields_pat, fields.len());
-
-                for (i, field) in fields.iter().enumerate() {
-                    println!(
-                        "    if {}[{}].ident.name.as_str() == {:?};",
-                        fields_pat,
-                        i,
-                        &*field.ident.name.as_str()
-                    );
-
-                    self.current = format!("{}[{}].expr", fields_pat, i);
-                    self.visit_expr(field.expr);
-                }
-            },
-            ExprKind::ConstBlock(_) => {
-                let value_pat = self.next("value");
-                println!("Const({}) = {}", value_pat, current);
-                self.current = value_pat;
-            },
+                kind!("LlvmInlineAsm(_)");
+                out!("// unimplemented: `ExprKind::LlvmInlineAsm` is not further destructured at the moment");
+            },
+            ExprKind::Struct(qpath, fields, base) => {
+                bind!(self, qpath, fields);
+                opt_bind!(self, base);
+                kind!("Struct({qpath}, {fields}, {base})");
+                self.qpath(qpath);
+                self.slice(fields, |field| {
+                    self.ident(field!(field.ident));
+                    self.expr(field!(field.expr));
+                });
+                base.if_some(|e| self.expr(e));
+            },
+            ExprKind::ConstBlock(_) => kind!("ConstBlock(_)"),
             ExprKind::Repeat(value, length) => {
-                let value_pat = self.next("value");
-                let length_pat = self.next("length");
-
-                println!("Repeat({}, {}) = {};", value_pat, length_pat, current);
-
-                self.current = value_pat;
-                self.visit_expr(value);
-
-                let hir = self.cx.tcx.hir();
-                let body = hir.body(length.body);
-
-                self.current = format!("{}.value", length_pat);
-                self.visit_expr(&body.value);
-            },
-            ExprKind::Err => {
-                println!("Err = {}", current);
+                bind!(self, value, length);
+                kind!("Repeat({value}, {length})");
+                self.expr(value);
+                self.body(field!(length.body));
             },
+            ExprKind::Err => kind!("Err"),
             ExprKind::DropTemps(expr) => {
-                let expr_pat = self.next("expr");
-
-                println!("DropTemps({}) = {};", expr_pat, current);
-
-                self.current = expr_pat;
-                self.visit_expr(expr);
+                bind!(self, expr);
+                kind!("DropTemps({expr})");
+                self.expr(expr);
             },
         }
     }
 
-    fn visit_block(&mut self, block: &Block<'_>) {
-        println!("    if {}.stmts.len() == {};", self.current, block.stmts.len());
-
-        let block_name = self.current.clone();
-
-        for (i, stmt) in block.stmts.iter().enumerate() {
-            self.current = format!("{}.stmts[{}]", block_name, i);
-            self.visit_stmt(stmt);
-        }
-
-        if let Some(expr) = block.expr {
-            self.current = self.next("trailing_expr");
-            println!("    if let Some({}) = {}.expr;", self.current, block_name);
-            self.visit_expr(expr);
-        } else {
-            println!("    if {}.expr.is_none();", block_name);
-        }
+    fn block(&self, block: &Binding<&hir::Block<'_>>) {
+        self.slice(field!(block.stmts), |stmt| self.stmt(stmt));
+        self.option(field!(block.expr), "trailing_expr", |expr| {
+            self.expr(expr);
+        });
     }
 
-    #[allow(clippy::too_many_lines)]
-    fn visit_pat(&mut self, pat: &Pat<'_>) {
-        print!("    if let PatKind::");
-        let current = format!("{}.kind", self.current);
-
-        match pat.kind {
-            PatKind::Wild => println!("Wild = {};", current),
-            PatKind::Binding(anno, .., ident, sub) => {
-                let anno_pat = &format!("BindingAnnotation::{:?}", anno);
-                let name_pat = self.next("name");
-
-                if let Some(sub) = sub {
-                    let sub_pat = self.next("sub");
-
-                    println!(
-                        "Binding({}, _, {}, Some({})) = {};",
-                        anno_pat, name_pat, sub_pat, current
-                    );
-
-                    self.current = sub_pat;
-                    self.visit_pat(sub);
-                } else {
-                    println!("Binding({}, _, {}, None) = {};", anno_pat, name_pat, current);
-                }
-
-                println!("    if {}.as_str() == \"{}\";", name_pat, ident.as_str());
-            },
-            PatKind::Struct(ref path, fields, ignore) => {
-                let path_pat = self.next("qpath");
-                let fields_pat = self.next("fields");
-                println!("Struct(ref {}, {}, {}) = {};", path_pat, fields_pat, ignore, current);
-
-                self.current = path_pat;
-                self.print_qpath(path);
-
-                println!("    if {}.len() == {};", fields_pat, fields.len());
+    fn body(&self, body_id: &Binding<hir::BodyId>) {
+        let expr = &self.cx.tcx.hir().body(body_id.value).value;
+        bind!(self, expr);
+        out!("let {expr} = &cx.tcx.hir().body({body_id}).value;");
+        self.expr(expr);
+    }
 
-                for (i, field) in fields.iter().enumerate() {
-                    println!(
-                        "    if {}[{}].ident.name.as_str() == {:?};",
-                        fields_pat,
-                        i,
-                        &*field.ident.name.as_str()
-                    );
+    fn pat(&self, pat: &Binding<&hir::Pat<'_>>) {
+        let kind = |kind| out!("if let PatKind::{kind} = {pat}.kind;");
+        macro_rules! kind {
+            ($($t:tt)*) => (kind(format_args!($($t)*)));
+        }
 
-                    self.current = format!("{}[{}]", fields_pat, i);
-                    self.visit_pat(field.pat);
-                }
+        match pat.value.kind {
+            PatKind::Wild => kind!("Wild"),
+            PatKind::Binding(anno, .., name, sub) => {
+                bind!(self, name);
+                opt_bind!(self, sub);
+                kind!("Binding(BindingAnnotation::{anno:?}, _, {name}, {sub})");
+                self.ident(name);
+                sub.if_some(|p| self.pat(p));
+            },
+            PatKind::Struct(ref qpath, fields, ignore) => {
+                bind!(self, qpath, fields);
+                kind!("Struct(ref {qpath}, {fields}, {ignore})");
+                self.qpath(qpath);
+                self.slice(fields, |field| {
+                    self.ident(field!(field.ident));
+                    self.pat(field!(field.pat));
+                });
             },
             PatKind::Or(fields) => {
-                let fields_pat = self.next("fields");
-                println!("Or({}) = {};", fields_pat, current);
-                println!("    if {}.len() == {};", fields_pat, fields.len());
-
-                for (i, field) in fields.iter().enumerate() {
-                    self.current = format!("{}[{}]", fields_pat, i);
-                    self.visit_pat(field);
-                }
+                bind!(self, fields);
+                kind!("Or({fields})");
+                self.slice(fields, |pat| self.pat(pat));
             },
-            PatKind::TupleStruct(ref path, fields, skip_pos) => {
-                let path_pat = self.next("qpath");
-                let fields_pat = self.next("fields");
-
-                println!(
-                    "TupleStruct(ref {}, {}, {:?}) = {};",
-                    path_pat, fields_pat, skip_pos, current
-                );
-
-                self.current = path_pat;
-                self.print_qpath(path);
-
-                println!("    if {}.len() == {};", fields_pat, fields.len());
-
-                for (i, field) in fields.iter().enumerate() {
-                    self.current = format!("{}[{}]", fields_pat, i);
-                    self.visit_pat(field);
-                }
+            PatKind::TupleStruct(ref qpath, fields, skip_pos) => {
+                bind!(self, qpath, fields);
+                kind!("TupleStruct(ref {qpath}, {fields}, {skip_pos:?})");
+                self.qpath(qpath);
+                self.slice(fields, |pat| self.pat(pat));
             },
-            PatKind::Path(ref path) => {
-                let path_pat = self.next("qpath");
-                println!("Path(ref {}) = {};", path_pat, current);
-
-                self.current = path_pat;
-                self.print_qpath(path);
+            PatKind::Path(ref qpath) => {
+                bind!(self, qpath);
+                kind!("Path(ref {qpath})");
+                self.qpath(qpath);
             },
             PatKind::Tuple(fields, skip_pos) => {
-                let fields_pat = self.next("fields");
-                println!("Tuple({}, {:?}) = {};", fields_pat, skip_pos, current);
-                println!("    if {}.len() == {};", fields_pat, fields.len());
-
-                for (i, field) in fields.iter().enumerate() {
-                    self.current = format!("{}[{}]", fields_pat, i);
-                    self.visit_pat(field);
-                }
+                bind!(self, fields);
+                kind!("Tuple({fields}, {skip_pos:?})");
+                self.slice(fields, |field| self.pat(field));
             },
             PatKind::Box(pat) => {
-                let pat_pat = self.next("pat");
-                println!("Box({}) = {};", pat_pat, current);
-
-                self.current = pat_pat;
-                self.visit_pat(pat);
+                bind!(self, pat);
+                kind!("Box({pat})");
+                self.pat(pat);
             },
             PatKind::Ref(pat, muta) => {
-                let pat_pat = self.next("pat");
-                println!("Ref({}, Mutability::{:?}) = {};", pat_pat, muta, current);
-
-                self.current = pat_pat;
-                self.visit_pat(pat);
+                bind!(self, pat);
+                kind!("Ref({pat}, Mutability::{muta:?})");
+                self.pat(pat);
             },
             PatKind::Lit(lit_expr) => {
-                let lit_expr_pat = self.next("lit_expr");
-                println!("Lit({}) = {};", lit_expr_pat, current);
-
-                self.current = lit_expr_pat;
-                self.visit_expr(lit_expr);
+                bind!(self, lit_expr);
+                kind!("Lit({lit_expr})");
+                self.expr(lit_expr);
             },
             PatKind::Range(start, end, end_kind) => {
-                let start_pat = self.next("start");
-                let end_pat = self.next("end");
-
-                println!(
-                    "Range({}, {}, RangeEnd::{:?}) = {};",
-                    start_pat, end_pat, end_kind, current
-                );
-
-                self.current = start_pat;
-                walk_list!(self, visit_expr, start);
-
-                self.current = end_pat;
-                walk_list!(self, visit_expr, end);
+                opt_bind!(self, start, end);
+                kind!("Range({start}, {end}, RangeEnd::{end_kind:?})");
+                start.if_some(|e| self.expr(e));
+                end.if_some(|e| self.expr(e));
             },
             PatKind::Slice(start, middle, end) => {
-                let start_pat = self.next("start");
-                let end_pat = self.next("end");
-
-                if let Some(middle) = middle {
-                    let middle_pat = self.next("middle");
-                    println!("Slice({}, Some({}), {}) = {};", start_pat, middle_pat, end_pat, current);
-                    self.current = middle_pat;
-                    self.visit_pat(middle);
-                } else {
-                    println!("Slice({}, None, {}) = {};", start_pat, end_pat, current);
-                }
-
-                println!("    if {}.len() == {};", start_pat, start.len());
-
-                for (i, pat) in start.iter().enumerate() {
-                    self.current = format!("{}[{}]", start_pat, i);
-                    self.visit_pat(pat);
-                }
-
-                println!("    if {}.len() == {};", end_pat, end.len());
-
-                for (i, pat) in end.iter().enumerate() {
-                    self.current = format!("{}[{}]", end_pat, i);
-                    self.visit_pat(pat);
-                }
+                bind!(self, start, end);
+                opt_bind!(self, middle);
+                kind!("Slice({start}, {middle}, {end})");
+                middle.if_some(|p| self.pat(p));
+                self.slice(start, |pat| self.pat(pat));
+                self.slice(end, |pat| self.pat(pat));
             },
         }
     }
 
-    fn visit_stmt(&mut self, s: &Stmt<'_>) {
-        print!("    if let StmtKind::");
-        let current = format!("{}.kind", self.current);
+    fn stmt(&self, stmt: &Binding<&hir::Stmt<'_>>) {
+        let kind = |kind| out!("if let StmtKind::{kind} = {stmt}.kind;");
+        macro_rules! kind {
+            ($($t:tt)*) => (kind(format_args!($($t)*)));
+        }
 
-        match s.kind {
-            // A local (let) binding:
+        match stmt.value.kind {
             StmtKind::Local(local) => {
-                let local_pat = self.next("local");
-                println!("Local({}) = {};", local_pat, current);
-
-                if let Some(init) = local.init {
-                    let init_pat = self.next("init");
-                    println!("    if let Some({}) = {}.init;", init_pat, local_pat);
-
-                    self.current = init_pat;
-                    self.visit_expr(init);
-                }
-
-                self.current = format!("{}.pat", local_pat);
-                self.visit_pat(local.pat);
-            },
-            // An item binding:
-            StmtKind::Item(_) => {
-                println!("Item(item_id) = {};", current);
-            },
-
-            // Expr without trailing semi-colon (must have unit type):
+                bind!(self, local);
+                kind!("Local({local})");
+                self.option(field!(local.init), "init", |init| {
+                    self.expr(init);
+                });
+                self.pat(field!(local.pat));
+            },
+            StmtKind::Item(_) => kind!("Item(item_id)"),
             StmtKind::Expr(e) => {
-                let e_pat = self.next("e");
-                println!("Expr({}, _) = {};", e_pat, current);
-
-                self.current = e_pat;
-                self.visit_expr(e);
+                bind!(self, e);
+                kind!("Expr({e})");
+                self.expr(e);
             },
-
-            // Expr with trailing semi-colon (may have any type):
             StmtKind::Semi(e) => {
-                let e_pat = self.next("e");
-                println!("Semi({}) = {};", e_pat, current);
-
-                self.current = e_pat;
-                self.visit_expr(e);
+                bind!(self, e);
+                kind!("Semi({e})");
+                self.expr(e);
             },
         }
     }
-
-    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
-        NestedVisitorMap::None
-    }
 }
 
 fn has_attr(cx: &LateContext<'_>, hir_id: hir::HirId) -> bool {
@@ -1072,30 +697,29 @@ fn has_attr(cx: &LateContext<'_>, hir_id: hir::HirId) -> bool {
     get_attr(cx.sess(), attrs, "author").count() > 0
 }
 
-fn print_path(path: &QPath<'_>, first: &mut bool) {
-    match *path {
-        QPath::Resolved(_, path) => {
-            for segment in path.segments {
-                if *first {
-                    *first = false;
-                } else {
-                    print!(", ");
+fn path_to_string(path: &QPath<'_>) -> String {
+    fn inner(s: &mut String, path: &QPath<'_>) {
+        match *path {
+            QPath::Resolved(_, path) => {
+                for (i, segment) in path.segments.iter().enumerate() {
+                    if i > 0 {
+                        *s += ", ";
+                    }
+                    write!(s, "{:?}", segment.ident.as_str()).unwrap();
                 }
-                print!("{:?}", segment.ident.as_str());
-            }
-        },
-        QPath::TypeRelative(ty, segment) => match ty.kind {
-            hir::TyKind::Path(ref inner_path) => {
-                print_path(inner_path, first);
-                if *first {
-                    *first = false;
-                } else {
-                    print!(", ");
-                }
-                print!("{:?}", segment.ident.as_str());
             },
-            ref other => print!("/* unimplemented: {:?}*/", other),
-        },
-        QPath::LangItem(..) => panic!("print_path: called for lang item qpath"),
+            QPath::TypeRelative(ty, segment) => match &ty.kind {
+                hir::TyKind::Path(inner_path) => {
+                    inner(s, inner_path);
+                    *s += ", ";
+                    write!(s, "{:?}", segment.ident.as_str()).unwrap();
+                },
+                other => write!(s, "/* unimplemented: {:?}*/", other).unwrap(),
+            },
+            QPath::LangItem(..) => panic!("path_to_string: called for lang item qpath"),
+        }
     }
+    let mut s = String::new();
+    inner(&mut s, path);
+    s
 }
diff --git a/tests/ui/author/blocks.stdout b/tests/ui/author/blocks.stdout
index b1b38736725..2fc4a7d1f7f 100644
--- a/tests/ui/author/blocks.stdout
+++ b/tests/ui/author/blocks.stdout
@@ -1,5 +1,5 @@
 if_chain! {
-    if let ExprKind::Block(block, label) = expr.kind;
+    if let ExprKind::Block(block, None) = expr.kind;
     if block.stmts.len() == 3;
     if let StmtKind::Local(local) = block.stmts[0].kind;
     if let Some(init) = local.init;
@@ -23,14 +23,14 @@ if_chain! {
     }
 }
 if_chain! {
-    if let ExprKind::Block(block, label) = expr.kind;
+    if let ExprKind::Block(block, None) = expr.kind;
     if block.stmts.len() == 1;
     if let StmtKind::Local(local) = block.stmts[0].kind;
     if let Some(init) = local.init;
     if let ExprKind::Call(func, args) = init.kind;
     if let ExprKind::Path(ref qpath) = func.kind;
     if match_qpath(qpath, &["String", "new"]);
-    if args.len() == 0;
+    if args.is_empty();
     if let PatKind::Binding(BindingAnnotation::Unannotated, _, name, None) = local.pat.kind;
     if name.as_str() == "expr";
     if let Some(trailing_expr) = block.expr;
@@ -47,16 +47,16 @@ if_chain! {
 if_chain! {
     if let ExprKind::Closure(CaptureBy::Value, fn_decl, body_id, _, None) = expr.kind;
     if let FnRetTy::DefaultReturn(_) = fn_decl.output;
-    let body = cx.tcx.hir().body(body_id);
-    if let ExprKind::Call(func, args) = body.value.kind;
+    let expr1 = &cx.tcx.hir().body(body_id).value;
+    if let ExprKind::Call(func, args) = expr1.kind;
     if let ExprKind::Path(ref qpath) = func.kind;
     if matches!(qpath, QPath::LangItem(LangItem::FromGenerator, _));
     if args.len() == 1;
     if let ExprKind::Closure(CaptureBy::Value, fn_decl1, body_id1, _, Some(Movability::Static)) = args[0].kind;
     if let FnRetTy::DefaultReturn(_) = fn_decl1.output;
-    let body1 = cx.tcx.hir().body(body_id1);
-    if let ExprKind::Block(block, label) = body1.value.kind;
-    if block.stmts.len() == 0;
+    let expr2 = &cx.tcx.hir().body(body_id1).value;
+    if let ExprKind::Block(block, None) = expr2.kind;
+    if block.stmts.is_empty();
     if block.expr.is_none();
     then {
         // report your lint here
diff --git a/tests/ui/author/if.stdout b/tests/ui/author/if.stdout
index 504f2c38fbb..75ff3faf29a 100644
--- a/tests/ui/author/if.stdout
+++ b/tests/ui/author/if.stdout
@@ -1,10 +1,11 @@
 if_chain! {
     if let StmtKind::Local(local) = stmt.kind;
     if let Some(init) = local.init;
-    if let Some(higher::If { cond: cond, then: then, r#else: else_expr}) = higher::If::hir(init);
-    if let ExprKind::Lit(ref lit) = cond.kind;
+    if let ExprKind::If(cond, then, Some(else_expr)) = init.kind;
+    if let ExprKind::DropTemps(expr) = cond.kind;
+    if let ExprKind::Lit(ref lit) = expr.kind;
     if let LitKind::Bool(true) = lit.node;
-    if let ExprKind::Block(block, label) = then.kind;
+    if let ExprKind::Block(block, None) = then.kind;
     if block.stmts.len() == 1;
     if let StmtKind::Semi(e) = block.stmts[0].kind;
     if let ExprKind::Binary(op, left, right) = e.kind;
@@ -14,7 +15,7 @@ if_chain! {
     if let ExprKind::Lit(ref lit2) = right.kind;
     if let LitKind::Int(1, LitIntType::Unsuffixed) = lit2.node;
     if block.expr.is_none();
-    if let ExprKind::Block(block1, label1) = else_expr.kind;
+    if let ExprKind::Block(block1, None) = else_expr.kind;
     if block1.stmts.len() == 1;
     if let StmtKind::Semi(e1) = block1.stmts[0].kind;
     if let ExprKind::Binary(op1, left1, right1) = e1.kind;
@@ -30,17 +31,18 @@ if_chain! {
     }
 }
 if_chain! {
-    if let Some(higher::IfLet { let_pat: let_pat, let_expr: let_expr, if_then: if_then, if_else: else_expr}) = higher::IfLet::hir(expr);
-    if let PatKind::Lit(lit_expr) = let_pat.kind;
+    if let ExprKind::If(cond, then, Some(else_expr)) = expr.kind;
+    if let ExprKind::Let(pat, expr1, _) = cond.kind;
+    if let PatKind::Lit(lit_expr) = pat.kind;
     if let ExprKind::Lit(ref lit) = lit_expr.kind;
     if let LitKind::Bool(true) = lit.node;
-    if let ExprKind::Path(ref qpath) = let_expr.kind;
+    if let ExprKind::Path(ref qpath) = expr1.kind;
     if match_qpath(qpath, &["a"]);
-    if let ExprKind::Block(block, label) = if_then.kind;
-    if block.stmts.len() == 0;
+    if let ExprKind::Block(block, None) = then.kind;
+    if block.stmts.is_empty();
     if block.expr.is_none();
-    if let ExprKind::Block(block1, label1) = else_expr.kind;
-    if block1.stmts.len() == 0;
+    if let ExprKind::Block(block1, None) = else_expr.kind;
+    if block1.stmts.is_empty();
     if block1.expr.is_none();
     then {
         // report your lint here
diff --git a/tests/ui/author/loop.stdout b/tests/ui/author/loop.stdout
index 57c932ee6c0..5a1f731ac4a 100644
--- a/tests/ui/author/loop.stdout
+++ b/tests/ui/author/loop.stdout
@@ -1,18 +1,18 @@
 if_chain! {
-    if let ExprKind::DropTemps(expr) = expr.kind;
-    if let Some(higher::ForLoop { pat: pat, arg: arg, body: body, ..}) = higher::ForLoop::hir(expr);
+    if let ExprKind::DropTemps(expr1) = expr.kind;
+    if let Some(higher::ForLoop { pat: pat, arg: arg, body: body, .. }) = higher::ForLoop::hir(expr1);
     if let PatKind::Binding(BindingAnnotation::Unannotated, _, name, None) = pat.kind;
     if name.as_str() == "y";
     if let ExprKind::Struct(qpath, fields, None) = arg.kind;
     if matches!(qpath, QPath::LangItem(LangItem::Range, _));
     if fields.len() == 2;
-    if fields[0].ident.name.as_str() == "start";
+    if fields[0].ident.as_str() == "start";
     if let ExprKind::Lit(ref lit) = fields[0].expr.kind;
     if let LitKind::Int(0, LitIntType::Unsuffixed) = lit.node;
-    if fields[1].ident.name.as_str() == "end";
+    if fields[1].ident.as_str() == "end";
     if let ExprKind::Lit(ref lit1) = fields[1].expr.kind;
     if let LitKind::Int(10, LitIntType::Unsuffixed) = lit1.node;
-    if let ExprKind::Block(block, label) = body.kind;
+    if let ExprKind::Block(block, None) = body.kind;
     if block.stmts.len() == 1;
     if let StmtKind::Local(local) = block.stmts[0].kind;
     if let Some(init) = local.init;
@@ -26,46 +26,47 @@ if_chain! {
     }
 }
 if_chain! {
-    if let ExprKind::DropTemps(expr) = expr.kind;
-    if let Some(higher::ForLoop { pat: pat, arg: arg, body: body, ..}) = higher::ForLoop::hir(expr);
+    if let ExprKind::DropTemps(expr1) = expr.kind;
+    if let Some(higher::ForLoop { pat: pat, arg: arg, body: body, .. }) = higher::ForLoop::hir(expr1);
     if let PatKind::Wild = pat.kind;
     if let ExprKind::Struct(qpath, fields, None) = arg.kind;
     if matches!(qpath, QPath::LangItem(LangItem::Range, _));
     if fields.len() == 2;
-    if fields[0].ident.name.as_str() == "start";
+    if fields[0].ident.as_str() == "start";
     if let ExprKind::Lit(ref lit) = fields[0].expr.kind;
     if let LitKind::Int(0, LitIntType::Unsuffixed) = lit.node;
-    if fields[1].ident.name.as_str() == "end";
+    if fields[1].ident.as_str() == "end";
     if let ExprKind::Lit(ref lit1) = fields[1].expr.kind;
     if let LitKind::Int(10, LitIntType::Unsuffixed) = lit1.node;
-    if let ExprKind::Block(block, label) = body.kind;
+    if let ExprKind::Block(block, None) = body.kind;
     if block.stmts.len() == 1;
     if let StmtKind::Semi(e) = block.stmts[0].kind;
     if let ExprKind::Break(destination, None) = e.kind;
+    if destination.label.is_none();
     if block.expr.is_none();
     then {
         // report your lint here
     }
 }
 if_chain! {
-    if let ExprKind::DropTemps(expr) = expr.kind;
-    if let Some(higher::ForLoop { pat: pat, arg: arg, body: body, ..}) = higher::ForLoop::hir(expr);
+    if let ExprKind::DropTemps(expr1) = expr.kind;
+    if let Some(higher::ForLoop { pat: pat, arg: arg, body: body, .. }) = higher::ForLoop::hir(expr1);
     if let PatKind::Wild = pat.kind;
     if let ExprKind::Struct(qpath, fields, None) = arg.kind;
     if matches!(qpath, QPath::LangItem(LangItem::Range, _));
     if fields.len() == 2;
-    if fields[0].ident.name.as_str() == "start";
+    if fields[0].ident.as_str() == "start";
     if let ExprKind::Lit(ref lit) = fields[0].expr.kind;
     if let LitKind::Int(0, LitIntType::Unsuffixed) = lit.node;
-    if fields[1].ident.name.as_str() == "end";
+    if fields[1].ident.as_str() == "end";
     if let ExprKind::Lit(ref lit1) = fields[1].expr.kind;
     if let LitKind::Int(10, LitIntType::Unsuffixed) = lit1.node;
-    if let ExprKind::Block(block, label) = body.kind;
+    if let ExprKind::Block(block, None) = body.kind;
     if block.stmts.len() == 1;
     if let StmtKind::Semi(e) = block.stmts[0].kind;
     if let ExprKind::Break(destination, None) = e.kind;
-    if let Some(label1) = destination.label;
-    if label_name.ident.name.as_str() == "'label";
+    if let Some(label) = destination.label;
+    if label.ident.as_str() == "'label";
     if block.expr.is_none();
     then {
         // report your lint here
@@ -75,10 +76,11 @@ if_chain! {
     if let Some(higher::While { condition: condition, body: body }) = higher::While::hir(expr);
     if let ExprKind::Path(ref qpath) = condition.kind;
     if match_qpath(qpath, &["a"]);
-    if let ExprKind::Block(block, label) = body.kind;
+    if let ExprKind::Block(block, None) = body.kind;
     if block.stmts.len() == 1;
     if let StmtKind::Semi(e) = block.stmts[0].kind;
     if let ExprKind::Break(destination, None) = e.kind;
+    if destination.label.is_none();
     if block.expr.is_none();
     then {
         // report your lint here
@@ -91,20 +93,22 @@ if_chain! {
     if let LitKind::Bool(true) = lit.node;
     if let ExprKind::Path(ref qpath) = let_expr.kind;
     if match_qpath(qpath, &["a"]);
-    if let ExprKind::Block(block, label) = if_then.kind;
+    if let ExprKind::Block(block, None) = if_then.kind;
     if block.stmts.len() == 1;
     if let StmtKind::Semi(e) = block.stmts[0].kind;
     if let ExprKind::Break(destination, None) = e.kind;
+    if destination.label.is_none();
     if block.expr.is_none();
     then {
         // report your lint here
     }
 }
 if_chain! {
-    if let ExprKind::Loop(body, label, LoopSource::Loop, _) = expr.kind;
+    if let ExprKind::Loop(body, None, LoopSource::Loop, _) = expr.kind;
     if body.stmts.len() == 1;
     if let StmtKind::Semi(e) = body.stmts[0].kind;
     if let ExprKind::Break(destination, None) = e.kind;
+    if destination.label.is_none();
     if body.expr.is_none();
     then {
         // report your lint here
diff --git a/tests/ui/author/matches.stdout b/tests/ui/author/matches.stdout
index 397be11659b..38444a0094c 100644
--- a/tests/ui/author/matches.stdout
+++ b/tests/ui/author/matches.stdout
@@ -8,12 +8,14 @@ if_chain! {
     if let PatKind::Lit(lit_expr) = arms[0].pat.kind;
     if let ExprKind::Lit(ref lit1) = lit_expr.kind;
     if let LitKind::Int(16, LitIntType::Unsuffixed) = lit1.node;
+    if arms[0].guard.is_none();
     if let ExprKind::Lit(ref lit2) = arms[0].body.kind;
     if let LitKind::Int(5, LitIntType::Unsuffixed) = lit2.node;
     if let PatKind::Lit(lit_expr1) = arms[1].pat.kind;
     if let ExprKind::Lit(ref lit3) = lit_expr1.kind;
     if let LitKind::Int(17, LitIntType::Unsuffixed) = lit3.node;
-    if let ExprKind::Block(block, label) = arms[1].body.kind;
+    if arms[1].guard.is_none();
+    if let ExprKind::Block(block, None) = arms[1].body.kind;
     if block.stmts.len() == 1;
     if let StmtKind::Local(local1) = block.stmts[0].kind;
     if let Some(init1) = local1.init;
@@ -25,6 +27,7 @@ if_chain! {
     if let ExprKind::Path(ref qpath) = trailing_expr.kind;
     if match_qpath(qpath, &["x"]);
     if let PatKind::Wild = arms[2].pat.kind;
+    if arms[2].guard.is_none();
     if let ExprKind::Lit(ref lit5) = arms[2].body.kind;
     if let LitKind::Int(1, LitIntType::Unsuffixed) = lit5.node;
     if let PatKind::Binding(BindingAnnotation::Unannotated, _, name1, None) = local.pat.kind;
diff --git a/tests/ui/author/repeat.stdout b/tests/ui/author/repeat.stdout
index af66bb48022..f16350e4b5e 100644
--- a/tests/ui/author/repeat.stdout
+++ b/tests/ui/author/repeat.stdout
@@ -2,7 +2,8 @@ if_chain! {
     if let ExprKind::Repeat(value, length) = expr.kind;
     if let ExprKind::Lit(ref lit) = value.kind;
     if let LitKind::Int(1, LitIntType::Unsigned(UintTy::U8)) = lit.node;
-    if let ExprKind::Lit(ref lit1) = length.value.kind;
+    let expr1 = &cx.tcx.hir().body(length.body).value;
+    if let ExprKind::Lit(ref lit1) = expr1.kind;
     if let LitKind::Int(5, LitIntType::Unsuffixed) = lit1.node;
     then {
         // report your lint here
diff --git a/tests/ui/author/struct.stdout b/tests/ui/author/struct.stdout
index ffedd87625d..ded5abd8d33 100644
--- a/tests/ui/author/struct.stdout
+++ b/tests/ui/author/struct.stdout
@@ -2,17 +2,18 @@ if_chain! {
     if let ExprKind::Struct(qpath, fields, None) = expr.kind;
     if match_qpath(qpath, &["Test"]);
     if fields.len() == 1;
-    if fields[0].ident.name.as_str() == "field";
-    if let Some(higher::If { cond: cond, then: then, r#else: else_expr}) = higher::If::hir(fields[0].expr);
-    if let ExprKind::Lit(ref lit) = cond.kind;
+    if fields[0].ident.as_str() == "field";
+    if let ExprKind::If(cond, then, Some(else_expr)) = fields[0].expr.kind;
+    if let ExprKind::DropTemps(expr1) = cond.kind;
+    if let ExprKind::Lit(ref lit) = expr1.kind;
     if let LitKind::Bool(true) = lit.node;
-    if let ExprKind::Block(block, label) = then.kind;
-    if block.stmts.len() == 0;
+    if let ExprKind::Block(block, None) = then.kind;
+    if block.stmts.is_empty();
     if let Some(trailing_expr) = block.expr;
     if let ExprKind::Lit(ref lit1) = trailing_expr.kind;
     if let LitKind::Int(1, LitIntType::Unsuffixed) = lit1.node;
-    if let ExprKind::Block(block1, label1) = else_expr.kind;
-    if block1.stmts.len() == 0;
+    if let ExprKind::Block(block1, None) = else_expr.kind;
+    if block1.stmts.is_empty();
     if let Some(trailing_expr1) = block1.expr;
     if let ExprKind::Lit(ref lit2) = trailing_expr1.kind;
     if let LitKind::Int(0, LitIntType::Unsuffixed) = lit2.node;
@@ -21,29 +22,31 @@ if_chain! {
     }
 }
 if_chain! {
-    if let PatKind::Struct(ref qpath, fields, false) = arm.kind;
+    if let PatKind::Struct(ref qpath, fields, false) = arm.pat.kind;
     if match_qpath(qpath, &["Test"]);
     if fields.len() == 1;
-    if fields[0].ident.name.as_str() == "field";
-    if let PatKind::Lit(lit_expr) = fields[0].kind;
+    if fields[0].ident.as_str() == "field";
+    if let PatKind::Lit(lit_expr) = fields[0].pat.kind;
     if let ExprKind::Lit(ref lit) = lit_expr.kind;
     if let LitKind::Int(1, LitIntType::Unsuffixed) = lit.node;
-    if let ExprKind::Block(block, label) = lit_expr.kind;
-    if block.stmts.len() == 0;
+    if arm.guard.is_none();
+    if let ExprKind::Block(block, None) = arm.body.kind;
+    if block.stmts.is_empty();
     if block.expr.is_none();
     then {
         // report your lint here
     }
 }
 if_chain! {
-    if let PatKind::TupleStruct(ref qpath, fields, None) = arm.kind;
+    if let PatKind::TupleStruct(ref qpath, fields, None) = arm.pat.kind;
     if match_qpath(qpath, &["TestTuple"]);
     if fields.len() == 1;
     if let PatKind::Lit(lit_expr) = fields[0].kind;
     if let ExprKind::Lit(ref lit) = lit_expr.kind;
     if let LitKind::Int(1, LitIntType::Unsuffixed) = lit.node;
-    if let ExprKind::Block(block, label) = lit_expr.kind;
-    if block.stmts.len() == 0;
+    if arm.guard.is_none();
+    if let ExprKind::Block(block, None) = arm.body.kind;
+    if block.stmts.is_empty();
     if block.expr.is_none();
     then {
         // report your lint here
@@ -51,7 +54,7 @@ if_chain! {
 }
 if_chain! {
     if let ExprKind::MethodCall(method_name, _, args, _) = expr.kind;
-    if method_name.ident.name.as_str() == test;
+    if method_name.ident.as_str() == "test";
     if args.len() == 1;
     if let ExprKind::Path(ref qpath) = args[0].kind;
     if match_qpath(qpath, &["test_method_call"]);
-- 
cgit 1.4.1-3-g733a5


From e444cbe5d67b92e1c0989ec4d36758c2b036014b Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Tue, 31 Aug 2021 19:17:24 +0200
Subject: New `index_refutable_slice` lint

* Finding pattern slices for `avoidable_slice_indexing`
* `avoidable_slice_indexing` analysing slice usage
* Add configuration to `avoidable_slice_indexing`
* Emitting `avoidable_slice_indexing` with suggestions
* Dogfooding and fixing bugs
* Add ui-toml test for `avoidable_slice_indexing`
* Correctly suggest `ref` keywords for `avoidable_slice_indexing`
* Test and document `mut` for `avoid_slice_indexing`
* Handle macros with `avoidable_slice_indexing` lint
* Ignore slices with sub patterns in `avoidable_slice_indexing`
* Update lint description for `avoidable_slice_indexing`
* Move `avoidable_slice_indexing` to nursery
* Added more tests for `avoidable_slice_indexing`
* Update documentation and message for `avoidable_slice_indexing`
* Teach `avoidable_slice_indexing` about `HirId`s and `Visitors`
* Rename lint to `index_refutable_slice` and connected config
---
 CHANGELOG.md                                       |   1 +
 clippy_lints/src/index_refutable_slice.rs          | 276 +++++++++++++++++++++
 clippy_lints/src/lib.register_lints.rs             |   1 +
 clippy_lints/src/lib.register_nursery.rs           |   1 +
 clippy_lints/src/lib.rs                            |   8 +
 clippy_lints/src/unwrap.rs                         |   4 +-
 clippy_lints/src/utils/conf.rs                     |   8 +-
 clippy_utils/src/msrvs.rs                          |   2 +-
 clippy_utils/src/ty.rs                             |   1 +
 .../max_suggested_slice_pattern_length/clippy.toml |   1 +
 .../index_refutable_slice.rs                       |  23 ++
 .../index_refutable_slice.stderr                   |  22 ++
 tests/ui-toml/min_rust_version/min_rust_version.rs |  10 +
 .../toml_unknown_key/conf_unknown_key.stderr       |   2 +-
 .../index_refutable_slice/if_let_slice_binding.rs  | 166 +++++++++++++
 .../if_let_slice_binding.stderr                    | 158 ++++++++++++
 .../slice_indexing_in_macro.rs                     |  28 +++
 .../slice_indexing_in_macro.stderr                 |  22 ++
 18 files changed, 729 insertions(+), 5 deletions(-)
 create mode 100644 clippy_lints/src/index_refutable_slice.rs
 create mode 100644 tests/ui-toml/max_suggested_slice_pattern_length/clippy.toml
 create mode 100644 tests/ui-toml/max_suggested_slice_pattern_length/index_refutable_slice.rs
 create mode 100644 tests/ui-toml/max_suggested_slice_pattern_length/index_refutable_slice.stderr
 create mode 100644 tests/ui/index_refutable_slice/if_let_slice_binding.rs
 create mode 100644 tests/ui/index_refutable_slice/if_let_slice_binding.stderr
 create mode 100644 tests/ui/index_refutable_slice/slice_indexing_in_macro.rs
 create mode 100644 tests/ui/index_refutable_slice/slice_indexing_in_macro.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 85a6a6be8b7..1059f0ac7cd 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2904,6 +2904,7 @@ Released 2018-09-13
 [`imprecise_flops`]: https://rust-lang.github.io/rust-clippy/master/index.html#imprecise_flops
 [`inconsistent_digit_grouping`]: https://rust-lang.github.io/rust-clippy/master/index.html#inconsistent_digit_grouping
 [`inconsistent_struct_constructor`]: https://rust-lang.github.io/rust-clippy/master/index.html#inconsistent_struct_constructor
+[`index_refutable_slice`]: https://rust-lang.github.io/rust-clippy/master/index.html#index_refutable_slice
 [`indexing_slicing`]: https://rust-lang.github.io/rust-clippy/master/index.html#indexing_slicing
 [`ineffective_bit_mask`]: https://rust-lang.github.io/rust-clippy/master/index.html#ineffective_bit_mask
 [`inefficient_to_string`]: https://rust-lang.github.io/rust-clippy/master/index.html#inefficient_to_string
diff --git a/clippy_lints/src/index_refutable_slice.rs b/clippy_lints/src/index_refutable_slice.rs
new file mode 100644
index 00000000000..69f1c90beec
--- /dev/null
+++ b/clippy_lints/src/index_refutable_slice.rs
@@ -0,0 +1,276 @@
+use clippy_utils::consts::{constant, Constant};
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::higher::IfLet;
+use clippy_utils::ty::is_copy;
+use clippy_utils::{is_expn_of, is_lint_allowed, meets_msrv, msrvs, path_to_local};
+use if_chain::if_chain;
+use rustc_data_structures::fx::{FxHashMap, FxHashSet};
+use rustc_errors::Applicability;
+use rustc_hir as hir;
+use rustc_hir::intravisit::{self, NestedVisitorMap, Visitor};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_middle::hir::map::Map;
+use rustc_middle::ty;
+use rustc_semver::RustcVersion;
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::{symbol::Ident, Span};
+use std::convert::TryInto;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// The lint checks for slice bindings in patterns that are only used to
+    /// access individual slice values.
+    ///
+    /// ### Why is this bad?
+    /// Accessing slice values using indices can lead to panics. Using refutable
+    /// patterns can avoid these. Binding to individual values also improves the
+    /// readability as they can be named.
+    ///
+    /// ### Limitations
+    /// This lint currently only checks for immutable access inside `if let`
+    /// patterns.
+    ///
+    /// ### Example
+    /// ```rust
+    /// let slice: Option<&[u32]> = Some(&[1, 2, 3]);
+    ///
+    /// if let Some(slice) = slice {
+    ///     println!("{}", slice[0]);
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// let slice: Option<&[u32]> = Some(&[1, 2, 3]);
+    ///
+    /// if let Some(&[first, ..]) = slice {
+    ///     println!("{}", first);
+    /// }
+    /// ```
+    #[clippy::version = "1.58.0"]
+    pub INDEX_REFUTABLE_SLICE,
+    nursery,
+    "avoid indexing on slices which could be destructed"
+}
+
+#[derive(Copy, Clone)]
+pub struct IndexRefutableSlice {
+    max_suggested_slice: u64,
+    msrv: Option<RustcVersion>,
+}
+
+impl IndexRefutableSlice {
+    pub fn new(max_suggested_slice_pattern_length: u64, msrv: Option<RustcVersion>) -> Self {
+        Self {
+            max_suggested_slice: max_suggested_slice_pattern_length,
+            msrv,
+        }
+    }
+}
+
+impl_lint_pass!(IndexRefutableSlice => [INDEX_REFUTABLE_SLICE]);
+
+impl LateLintPass<'_> for IndexRefutableSlice {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
+        if_chain! {
+            if !expr.span.from_expansion() || is_expn_of(expr.span, "if_chain").is_some();
+            if let Some(IfLet {let_pat, if_then, ..}) = IfLet::hir(cx, expr);
+            if !is_lint_allowed(cx, INDEX_REFUTABLE_SLICE, expr.hir_id);
+            if meets_msrv(self.msrv.as_ref(), &msrvs::SLICE_PATTERNS);
+
+            let found_slices = find_slice_values(cx, let_pat);
+            if !found_slices.is_empty();
+            let filtered_slices = filter_lintable_slices(cx, found_slices, self.max_suggested_slice, if_then);
+            if !filtered_slices.is_empty();
+            then {
+                for slice in filtered_slices.values() {
+                    lint_slice(cx, slice);
+                }
+            }
+        }
+    }
+
+    extract_msrv_attr!(LateContext);
+}
+
+fn find_slice_values(cx: &LateContext<'_>, pat: &hir::Pat<'_>) -> FxHashMap<hir::HirId, SliceLintInformation> {
+    let mut removed_pat: FxHashSet<hir::HirId> = FxHashSet::default();
+    let mut slices: FxHashMap<hir::HirId, SliceLintInformation> = FxHashMap::default();
+    pat.walk_always(|pat| {
+        if let hir::PatKind::Binding(binding, value_hir_id, ident, sub_pat) = pat.kind {
+            // We'll just ignore mut and ref mut for simplicity sake right now
+            if let hir::BindingAnnotation::Mutable | hir::BindingAnnotation::RefMut = binding {
+                return;
+            }
+
+            // This block catches bindings with sub patterns. It would be hard to build a correct suggestion
+            // for them and it's likely that the user knows what they are doing in such a case.
+            if removed_pat.contains(&value_hir_id) {
+                return;
+            }
+            if sub_pat.is_some() {
+                removed_pat.insert(value_hir_id);
+                slices.remove(&value_hir_id);
+                return;
+            }
+
+            let bound_ty = cx.typeck_results().node_type(pat.hir_id);
+            if let ty::Slice(inner_ty) | ty::Array(inner_ty, _) = bound_ty.peel_refs().kind() {
+                // The values need to use the `ref` keyword if they can't be copied.
+                // This will need to be adjusted if the lint want to support multable access in the future
+                let src_is_ref = bound_ty.is_ref() && binding != hir::BindingAnnotation::Ref;
+                let needs_ref = !(src_is_ref || is_copy(cx, inner_ty));
+
+                let slice_info = slices
+                    .entry(value_hir_id)
+                    .or_insert_with(|| SliceLintInformation::new(ident, needs_ref));
+                slice_info.pattern_spans.push(pat.span);
+            }
+        }
+    });
+
+    slices
+}
+
+fn lint_slice(cx: &LateContext<'_>, slice: &SliceLintInformation) {
+    let used_indices = slice
+        .index_use
+        .iter()
+        .map(|(index, _)| *index)
+        .collect::<FxHashSet<_>>();
+
+    let value_name = |index| format!("{}_{}", slice.ident.name, index);
+
+    if let Some(max_index) = used_indices.iter().max() {
+        let opt_ref = if slice.needs_ref { "ref " } else { "" };
+        let pat_sugg_idents = (0..=*max_index)
+            .map(|index| {
+                if used_indices.contains(&index) {
+                    format!("{}{}", opt_ref, value_name(index))
+                } else {
+                    "_".to_string()
+                }
+            })
+            .collect::<Vec<_>>();
+        let pat_sugg = format!("[{}, ..]", pat_sugg_idents.join(", "));
+
+        span_lint_and_then(
+            cx,
+            INDEX_REFUTABLE_SLICE,
+            slice.ident.span,
+            "this binding can be a slice pattern to avoid indexing",
+            |diag| {
+                diag.multipart_suggestion(
+                    "try using a slice pattern here",
+                    slice
+                        .pattern_spans
+                        .iter()
+                        .map(|span| (*span, pat_sugg.clone()))
+                        .collect(),
+                    Applicability::MaybeIncorrect,
+                );
+
+                diag.multipart_suggestion(
+                    "and replace the index expressions here",
+                    slice
+                        .index_use
+                        .iter()
+                        .map(|(index, span)| (*span, value_name(*index)))
+                        .collect(),
+                    Applicability::MaybeIncorrect,
+                );
+
+                // The lint message doesn't contain a warning about the removed index expression,
+                // since `filter_lintable_slices` will only return slices where all access indices
+                // are known at compile time. Therefore, they can be removed without side effects.
+            },
+        );
+    }
+}
+
+#[derive(Debug)]
+struct SliceLintInformation {
+    ident: Ident,
+    needs_ref: bool,
+    pattern_spans: Vec<Span>,
+    index_use: Vec<(u64, Span)>,
+}
+
+impl SliceLintInformation {
+    fn new(ident: Ident, needs_ref: bool) -> Self {
+        Self {
+            ident,
+            needs_ref,
+            pattern_spans: Vec::new(),
+            index_use: Vec::new(),
+        }
+    }
+}
+
+fn filter_lintable_slices<'a, 'tcx>(
+    cx: &'a LateContext<'tcx>,
+    slice_lint_info: FxHashMap<hir::HirId, SliceLintInformation>,
+    max_suggested_slice: u64,
+    scope: &'tcx hir::Expr<'tcx>,
+) -> FxHashMap<hir::HirId, SliceLintInformation> {
+    let mut visitor = SliceIndexLintingVisitor {
+        cx,
+        slice_lint_info,
+        max_suggested_slice,
+    };
+
+    intravisit::walk_expr(&mut visitor, scope);
+
+    visitor.slice_lint_info
+}
+
+struct SliceIndexLintingVisitor<'a, 'tcx> {
+    cx: &'a LateContext<'tcx>,
+    slice_lint_info: FxHashMap<hir::HirId, SliceLintInformation>,
+    max_suggested_slice: u64,
+}
+
+impl<'a, 'tcx> Visitor<'tcx> for SliceIndexLintingVisitor<'a, 'tcx> {
+    type Map = Map<'tcx>;
+
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::OnlyBodies(self.cx.tcx.hir())
+    }
+
+    fn visit_expr(&mut self, expr: &'tcx hir::Expr<'tcx>) {
+        if let Some(local_id) = path_to_local(expr) {
+            let Self {
+                cx,
+                ref mut slice_lint_info,
+                max_suggested_slice,
+            } = *self;
+
+            if_chain! {
+                // Check if this is even a local we're interested in
+                if let Some(use_info) = slice_lint_info.get_mut(&local_id);
+
+                let map = cx.tcx.hir();
+
+                // Checking for slice indexing
+                let parent_id = map.get_parent_node(expr.hir_id);
+                if let Some(hir::Node::Expr(parent_expr)) = map.find(parent_id);
+                if let hir::ExprKind::Index(_, index_expr) = parent_expr.kind;
+                if let Some((Constant::Int(index_value), _)) = constant(cx, cx.typeck_results(), index_expr);
+                if let Ok(index_value) = index_value.try_into();
+                if index_value < max_suggested_slice;
+
+                // Make sure that this slice index is read only
+                let maybe_addrof_id = map.get_parent_node(parent_id);
+                if let Some(hir::Node::Expr(maybe_addrof_expr)) = map.find(maybe_addrof_id);
+                if let hir::ExprKind::AddrOf(_kind, hir::Mutability::Not, _inner_expr) = maybe_addrof_expr.kind;
+                then {
+                    use_info.index_use.push((index_value, map.span(parent_expr.hir_id)));
+                    return;
+                }
+            }
+
+            // The slice was used for something other than indexing
+            self.slice_lint_info.remove(&local_id);
+        }
+        intravisit::walk_expr(self, expr);
+    }
+}
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index b32c9b060ae..6d1d45f8900 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -168,6 +168,7 @@ store.register_lints(&[
     implicit_return::IMPLICIT_RETURN,
     implicit_saturating_sub::IMPLICIT_SATURATING_SUB,
     inconsistent_struct_constructor::INCONSISTENT_STRUCT_CONSTRUCTOR,
+    index_refutable_slice::INDEX_REFUTABLE_SLICE,
     indexing_slicing::INDEXING_SLICING,
     indexing_slicing::OUT_OF_BOUNDS_INDEXING,
     infinite_iter::INFINITE_ITER,
diff --git a/clippy_lints/src/lib.register_nursery.rs b/clippy_lints/src/lib.register_nursery.rs
index 44c75a11eec..cc0eb71be69 100644
--- a/clippy_lints/src/lib.register_nursery.rs
+++ b/clippy_lints/src/lib.register_nursery.rs
@@ -13,6 +13,7 @@ store.register_group(true, "clippy::nursery", Some("clippy_nursery"), vec![
     LintId::of(floating_point_arithmetic::IMPRECISE_FLOPS),
     LintId::of(floating_point_arithmetic::SUBOPTIMAL_FLOPS),
     LintId::of(future_not_send::FUTURE_NOT_SEND),
+    LintId::of(index_refutable_slice::INDEX_REFUTABLE_SLICE),
     LintId::of(let_if_seq::USELESS_LET_IF_SEQ),
     LintId::of(missing_const_for_fn::MISSING_CONST_FOR_FN),
     LintId::of(mutable_debug_assertion::DEBUG_ASSERT_WITH_MUT_CALL),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 6aa136371cf..2445a0aeed0 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -238,6 +238,7 @@ mod implicit_hasher;
 mod implicit_return;
 mod implicit_saturating_sub;
 mod inconsistent_struct_constructor;
+mod index_refutable_slice;
 mod indexing_slicing;
 mod infinite_iter;
 mod inherent_impl;
@@ -580,6 +581,13 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
 
     store.register_late_pass(|| Box::new(size_of_in_element_count::SizeOfInElementCount));
     store.register_late_pass(|| Box::new(same_name_method::SameNameMethod));
+    let max_suggested_slice_pattern_length = conf.max_suggested_slice_pattern_length;
+    store.register_late_pass(move || {
+        Box::new(index_refutable_slice::IndexRefutableSlice::new(
+            max_suggested_slice_pattern_length,
+            msrv,
+        ))
+    });
     store.register_late_pass(|| Box::new(map_clone::MapClone));
     store.register_late_pass(|| Box::new(map_err_ignore::MapErrIgnore));
     store.register_late_pass(|| Box::new(shadow::Shadow::default()));
diff --git a/clippy_lints/src/unwrap.rs b/clippy_lints/src/unwrap.rs
index 9e83cae79bc..71771aae44b 100644
--- a/clippy_lints/src/unwrap.rs
+++ b/clippy_lints/src/unwrap.rs
@@ -231,8 +231,8 @@ impl<'a, 'tcx> Visitor<'tcx> for UnwrappableVariablesVisitor<'a, 'tcx> {
         } else {
             // find `unwrap[_err]()` calls:
             if_chain! {
-                if let ExprKind::MethodCall(method_name, _, args, _) = expr.kind;
-                if let Some(id) = path_to_local(&args[0]);
+                if let ExprKind::MethodCall(method_name, _, [self_arg, ..], _) = expr.kind;
+                if let Some(id) = path_to_local(self_arg);
                 if [sym::unwrap, sym::expect, sym!(unwrap_err)].contains(&method_name.ident.name);
                 let call_to_unwrap = [sym::unwrap, sym::expect].contains(&method_name.ident.name);
                 if let Some(unwrappable) = self.unwrappables.iter()
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 3c4f114fe59..1a170807980 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -148,7 +148,7 @@ define_Conf! {
     ///
     /// Suppress lints whenever the suggested change would cause breakage for other crates.
     (avoid_breaking_exported_api: bool = true),
-    /// Lint: MANUAL_SPLIT_ONCE, MANUAL_STR_REPEAT, CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR, IF_THEN_SOME_ELSE_NONE, APPROX_CONSTANT, DEPRECATED_CFG_ATTR.
+    /// Lint: MANUAL_SPLIT_ONCE, MANUAL_STR_REPEAT, CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR, IF_THEN_SOME_ELSE_NONE, APPROX_CONSTANT, DEPRECATED_CFG_ATTR, INDEX_REFUTABLE_SLICE.
     ///
     /// The minimum rust version that the project supports
     (msrv: Option<String> = None),
@@ -296,6 +296,12 @@ define_Conf! {
     ///
     /// Whether to apply the raw pointer heuristic to determine if a type is `Send`.
     (enable_raw_pointer_heuristic_for_send: bool = true),
+    /// Lint: INDEX_REFUTABLE_SLICE.
+    ///
+    /// When Clippy suggests using a slice pattern, this is the maximum number of elements allowed in
+    /// the slice pattern that is suggested. If more elements would be necessary, the lint is suppressed.
+    /// For example, `[_, _, _, e, ..]` is a slice pattern with 4 elements.
+    (max_suggested_slice_pattern_length: u64 = 3),
 }
 
 /// Search for the configuration file.
diff --git a/clippy_utils/src/msrvs.rs b/clippy_utils/src/msrvs.rs
index f3913203f4b..66d07c9d0e8 100644
--- a/clippy_utils/src/msrvs.rs
+++ b/clippy_utils/src/msrvs.rs
@@ -19,7 +19,7 @@ msrv_aliases! {
     1,46,0 { CONST_IF_MATCH }
     1,45,0 { STR_STRIP_PREFIX }
     1,43,0 { LOG2_10, LOG10_2 }
-    1,42,0 { MATCHES_MACRO }
+    1,42,0 { MATCHES_MACRO, SLICE_PATTERNS }
     1,41,0 { RE_REBALANCING_COHERENCE, RESULT_MAP_OR_ELSE }
     1,40,0 { MEM_TAKE, NON_EXHAUSTIVE, OPTION_AS_DEREF }
     1,38,0 { POINTER_CAST }
diff --git a/clippy_utils/src/ty.rs b/clippy_utils/src/ty.rs
index 69715828270..babab07ea9f 100644
--- a/clippy_utils/src/ty.rs
+++ b/clippy_utils/src/ty.rs
@@ -19,6 +19,7 @@ use rustc_trait_selection::traits::query::normalize::AtExt;
 
 use crate::{match_def_path, must_use_attr};
 
+// Checks if the given type implements copy.
 pub fn is_copy<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
     ty.is_copy_modulo_regions(cx.tcx.at(DUMMY_SP), cx.param_env)
 }
diff --git a/tests/ui-toml/max_suggested_slice_pattern_length/clippy.toml b/tests/ui-toml/max_suggested_slice_pattern_length/clippy.toml
new file mode 100644
index 00000000000..78c7e63b410
--- /dev/null
+++ b/tests/ui-toml/max_suggested_slice_pattern_length/clippy.toml
@@ -0,0 +1 @@
+max-suggested-slice-pattern-length = 8
diff --git a/tests/ui-toml/max_suggested_slice_pattern_length/index_refutable_slice.rs b/tests/ui-toml/max_suggested_slice_pattern_length/index_refutable_slice.rs
new file mode 100644
index 00000000000..21849a14fa9
--- /dev/null
+++ b/tests/ui-toml/max_suggested_slice_pattern_length/index_refutable_slice.rs
@@ -0,0 +1,23 @@
+#![deny(clippy::index_refutable_slice)]
+
+fn below_limit() {
+    let slice: Option<&[u32]> = Some(&[1, 2, 3]);
+    if let Some(slice) = slice {
+        // This would usually not be linted but is included now due to the
+        // index limit in the config file
+        println!("{}", slice[7]);
+    }
+}
+
+fn above_limit() {
+    let slice: Option<&[u32]> = Some(&[1, 2, 3]);
+    if let Some(slice) = slice {
+        // This will not be linted as 8 is above the limit
+        println!("{}", slice[8]);
+    }
+}
+
+fn main() {
+    below_limit();
+    above_limit();
+}
diff --git a/tests/ui-toml/max_suggested_slice_pattern_length/index_refutable_slice.stderr b/tests/ui-toml/max_suggested_slice_pattern_length/index_refutable_slice.stderr
new file mode 100644
index 00000000000..d319e65d06c
--- /dev/null
+++ b/tests/ui-toml/max_suggested_slice_pattern_length/index_refutable_slice.stderr
@@ -0,0 +1,22 @@
+error: this binding can be a slice pattern to avoid indexing
+  --> $DIR/index_refutable_slice.rs:5:17
+   |
+LL |     if let Some(slice) = slice {
+   |                 ^^^^^
+   |
+note: the lint level is defined here
+  --> $DIR/index_refutable_slice.rs:1:9
+   |
+LL | #![deny(clippy::index_refutable_slice)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+help: try using a slice pattern here
+   |
+LL |     if let Some([_, _, _, _, _, _, _, slice_7, ..]) = slice {
+   |                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+help: and replace the index expressions here
+   |
+LL |         println!("{}", slice_7);
+   |                        ~~~~~~~
+
+error: aborting due to previous error
+
diff --git a/tests/ui-toml/min_rust_version/min_rust_version.rs b/tests/ui-toml/min_rust_version/min_rust_version.rs
index bc41efa42a1..8e104926524 100644
--- a/tests/ui-toml/min_rust_version/min_rust_version.rs
+++ b/tests/ui-toml/min_rust_version/min_rust_version.rs
@@ -59,10 +59,20 @@ fn manual_strip_msrv() {
     }
 }
 
+fn check_index_refutable_slice() {
+    // This shouldn't trigger `clippy::index_refutable_slice` as the suggestion
+    // would only be valid from 1.42.0 onward
+    let slice: Option<&[u32]> = Some(&[1]);
+    if let Some(slice) = slice {
+        println!("{}", slice[0]);
+    }
+}
+
 fn main() {
     option_as_ref_deref();
     match_like_matches();
     match_same_arms();
     match_same_arms2();
     manual_strip_msrv();
+    check_index_refutable_slice();
 }
diff --git a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
index 97bab1308aa..00ddbd608a7 100644
--- a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
+++ b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
@@ -1,4 +1,4 @@
-error: error reading Clippy's configuration file `$DIR/clippy.toml`: unknown field `foobar`, expected one of `avoid-breaking-exported-api`, `msrv`, `blacklisted-names`, `cognitive-complexity-threshold`, `cyclomatic-complexity-threshold`, `doc-valid-idents`, `too-many-arguments-threshold`, `type-complexity-threshold`, `single-char-binding-names-threshold`, `too-large-for-stack`, `enum-variant-name-threshold`, `enum-variant-size-threshold`, `verbose-bit-mask-threshold`, `literal-representation-threshold`, `trivial-copy-size-limit`, `pass-by-value-size-limit`, `too-many-lines-threshold`, `array-size-threshold`, `vec-box-size-threshold`, `max-trait-bounds`, `max-struct-bools`, `max-fn-params-bools`, `warn-on-all-wildcard-imports`, `disallowed-methods`, `disallowed-types`, `unreadable-literal-lint-fractions`, `upper-case-acronyms-aggressive`, `cargo-ignore-publish`, `standard-macro-braces`, `enforced-import-renames`, `allowed-scripts`, `enable-raw-pointer-heuristic-for-send`, `third-party` at line 5 column 1
+error: error reading Clippy's configuration file `$DIR/clippy.toml`: unknown field `foobar`, expected one of `avoid-breaking-exported-api`, `msrv`, `blacklisted-names`, `cognitive-complexity-threshold`, `cyclomatic-complexity-threshold`, `doc-valid-idents`, `too-many-arguments-threshold`, `type-complexity-threshold`, `single-char-binding-names-threshold`, `too-large-for-stack`, `enum-variant-name-threshold`, `enum-variant-size-threshold`, `verbose-bit-mask-threshold`, `literal-representation-threshold`, `trivial-copy-size-limit`, `pass-by-value-size-limit`, `too-many-lines-threshold`, `array-size-threshold`, `vec-box-size-threshold`, `max-trait-bounds`, `max-struct-bools`, `max-fn-params-bools`, `warn-on-all-wildcard-imports`, `disallowed-methods`, `disallowed-types`, `unreadable-literal-lint-fractions`, `upper-case-acronyms-aggressive`, `cargo-ignore-publish`, `standard-macro-braces`, `enforced-import-renames`, `allowed-scripts`, `enable-raw-pointer-heuristic-for-send`, `max-suggested-slice-pattern-length`, `third-party` at line 5 column 1
 
 error: aborting due to previous error
 
diff --git a/tests/ui/index_refutable_slice/if_let_slice_binding.rs b/tests/ui/index_refutable_slice/if_let_slice_binding.rs
new file mode 100644
index 00000000000..c2c0c520dc6
--- /dev/null
+++ b/tests/ui/index_refutable_slice/if_let_slice_binding.rs
@@ -0,0 +1,166 @@
+#![deny(clippy::index_refutable_slice)]
+
+enum SomeEnum<T> {
+    One(T),
+    Two(T),
+    Three(T),
+    Four(T),
+}
+
+fn lintable_examples() {
+    // Try with reference
+    let slice: Option<&[u32]> = Some(&[1, 2, 3]);
+    if let Some(slice) = slice {
+        println!("{}", slice[0]);
+    }
+
+    // Try with copy
+    let slice: Option<[u32; 3]> = Some([1, 2, 3]);
+    if let Some(slice) = slice {
+        println!("{}", slice[0]);
+    }
+
+    // Try with long slice and small indices
+    let slice: Option<[u32; 9]> = Some([1, 2, 3, 4, 5, 6, 7, 8, 9]);
+    if let Some(slice) = slice {
+        println!("{}", slice[2]);
+        println!("{}", slice[0]);
+    }
+
+    // Multiple bindings
+    let slice_wrapped: SomeEnum<[u32; 3]> = SomeEnum::One([5, 6, 7]);
+    if let SomeEnum::One(slice) | SomeEnum::Three(slice) = slice_wrapped {
+        println!("{}", slice[0]);
+    }
+
+    // Two lintable slices in one if let
+    let a_wrapped: SomeEnum<[u32; 3]> = SomeEnum::One([9, 5, 1]);
+    let b_wrapped: Option<[u32; 2]> = Some([4, 6]);
+    if let (SomeEnum::Three(a), Some(b)) = (a_wrapped, b_wrapped) {
+        println!("{} -> {}", a[2], b[1]);
+    }
+
+    // This requires the slice values to be borrowed as the slice values can only be
+    // borrowed and `String` doesn't implement copy
+    let slice: Option<[String; 2]> = Some([String::from("1"), String::from("2")]);
+    if let Some(ref slice) = slice {
+        println!("{:?}", slice[1]);
+    }
+    println!("{:?}", slice);
+
+    // This should not suggest using the `ref` keyword as the scrutinee is already
+    // a reference
+    let slice: Option<[String; 2]> = Some([String::from("1"), String::from("2")]);
+    if let Some(slice) = &slice {
+        println!("{:?}", slice[0]);
+    }
+    println!("{:?}", slice);
+}
+
+fn slice_index_above_limit() {
+    let slice: Option<&[u32]> = Some(&[1, 2, 3]);
+
+    if let Some(slice) = slice {
+        // Would cause a panic, IDK
+        println!("{}", slice[7]);
+    }
+}
+
+fn slice_is_used() {
+    let slice: Option<&[u32]> = Some(&[1, 2, 3]);
+    if let Some(slice) = slice {
+        println!("{:?}", slice.len());
+    }
+
+    let slice: Option<&[u32]> = Some(&[1, 2, 3]);
+    if let Some(slice) = slice {
+        println!("{:?}", slice.to_vec());
+    }
+
+    let opt: Option<[String; 2]> = Some([String::from("Hello"), String::from("world")]);
+    if let Some(slice) = opt {
+        if !slice.is_empty() {
+            println!("first: {}", slice[0]);
+        }
+    }
+}
+
+/// The slice is used by an external function and should therefore not be linted
+fn check_slice_as_arg() {
+    fn is_interesting<T>(slice: &[T; 2]) -> bool {
+        !slice.is_empty()
+    }
+
+    let slice_wrapped: Option<[String; 2]> = Some([String::from("Hello"), String::from("world")]);
+    if let Some(slice) = &slice_wrapped {
+        if is_interesting(slice) {
+            println!("This is interesting {}", slice[0]);
+        }
+    }
+    println!("{:?}", slice_wrapped);
+}
+
+fn check_slice_in_struct() {
+    #[derive(Debug)]
+    struct Wrapper<'a> {
+        inner: Option<&'a [String]>,
+        is_awesome: bool,
+    }
+
+    impl<'a> Wrapper<'a> {
+        fn is_super_awesome(&self) -> bool {
+            self.is_awesome
+        }
+    }
+
+    let inner = &[String::from("New"), String::from("World")];
+    let wrap = Wrapper {
+        inner: Some(inner),
+        is_awesome: true,
+    };
+
+    // Test 1: Field access
+    if let Some(slice) = wrap.inner {
+        if wrap.is_awesome {
+            println!("This is awesome! {}", slice[0]);
+        }
+    }
+
+    // Test 2: function access
+    if let Some(slice) = wrap.inner {
+        if wrap.is_super_awesome() {
+            println!("This is super awesome! {}", slice[0]);
+        }
+    }
+    println!("Complete wrap: {:?}", wrap);
+}
+
+/// This would be a nice additional feature to have in the future, but adding it
+/// now would make the PR too large. This is therefore only a test that we don't
+/// lint cases we can't make a reasonable suggestion for
+fn mutable_slice_index() {
+    // Mut access
+    let mut slice: Option<[String; 1]> = Some([String::from("Penguin")]);
+    if let Some(ref mut slice) = slice {
+        slice[0] = String::from("Mr. Penguin");
+    }
+    println!("Use after modification: {:?}", slice);
+
+    // Mut access on reference
+    let mut slice: Option<[String; 1]> = Some([String::from("Cat")]);
+    if let Some(slice) = &mut slice {
+        slice[0] = String::from("Lord Meow Meow");
+    }
+    println!("Use after modification: {:?}", slice);
+}
+
+/// The lint will ignore bindings with sub patterns as it would be hard
+/// to build correct suggestions for these instances :)
+fn binding_with_sub_pattern() {
+    let slice: Option<&[u32]> = Some(&[1, 2, 3]);
+    if let Some(slice @ [_, _, _]) = slice {
+        println!("{:?}", slice[2]);
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/index_refutable_slice/if_let_slice_binding.stderr b/tests/ui/index_refutable_slice/if_let_slice_binding.stderr
new file mode 100644
index 00000000000..a607df9b876
--- /dev/null
+++ b/tests/ui/index_refutable_slice/if_let_slice_binding.stderr
@@ -0,0 +1,158 @@
+error: this binding can be a slice pattern to avoid indexing
+  --> $DIR/if_let_slice_binding.rs:13:17
+   |
+LL |     if let Some(slice) = slice {
+   |                 ^^^^^
+   |
+note: the lint level is defined here
+  --> $DIR/if_let_slice_binding.rs:1:9
+   |
+LL | #![deny(clippy::index_refutable_slice)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+help: try using a slice pattern here
+   |
+LL |     if let Some([slice_0, ..]) = slice {
+   |                 ~~~~~~~~~~~~~
+help: and replace the index expressions here
+   |
+LL |         println!("{}", slice_0);
+   |                        ~~~~~~~
+
+error: this binding can be a slice pattern to avoid indexing
+  --> $DIR/if_let_slice_binding.rs:19:17
+   |
+LL |     if let Some(slice) = slice {
+   |                 ^^^^^
+   |
+help: try using a slice pattern here
+   |
+LL |     if let Some([slice_0, ..]) = slice {
+   |                 ~~~~~~~~~~~~~
+help: and replace the index expressions here
+   |
+LL |         println!("{}", slice_0);
+   |                        ~~~~~~~
+
+error: this binding can be a slice pattern to avoid indexing
+  --> $DIR/if_let_slice_binding.rs:25:17
+   |
+LL |     if let Some(slice) = slice {
+   |                 ^^^^^
+   |
+help: try using a slice pattern here
+   |
+LL |     if let Some([slice_0, _, slice_2, ..]) = slice {
+   |                 ~~~~~~~~~~~~~~~~~~~~~~~~~
+help: and replace the index expressions here
+   |
+LL ~         println!("{}", slice_2);
+LL ~         println!("{}", slice_0);
+   |
+
+error: this binding can be a slice pattern to avoid indexing
+  --> $DIR/if_let_slice_binding.rs:32:26
+   |
+LL |     if let SomeEnum::One(slice) | SomeEnum::Three(slice) = slice_wrapped {
+   |                          ^^^^^
+   |
+help: try using a slice pattern here
+   |
+LL |     if let SomeEnum::One([slice_0, ..]) | SomeEnum::Three([slice_0, ..]) = slice_wrapped {
+   |                          ~~~~~~~~~~~~~                    ~~~~~~~~~~~~~
+help: and replace the index expressions here
+   |
+LL |         println!("{}", slice_0);
+   |                        ~~~~~~~
+
+error: this binding can be a slice pattern to avoid indexing
+  --> $DIR/if_let_slice_binding.rs:39:29
+   |
+LL |     if let (SomeEnum::Three(a), Some(b)) = (a_wrapped, b_wrapped) {
+   |                             ^
+   |
+help: try using a slice pattern here
+   |
+LL |     if let (SomeEnum::Three([_, _, a_2, ..]), Some(b)) = (a_wrapped, b_wrapped) {
+   |                             ~~~~~~~~~~~~~~~
+help: and replace the index expressions here
+   |
+LL |         println!("{} -> {}", a_2, b[1]);
+   |                              ~~~
+
+error: this binding can be a slice pattern to avoid indexing
+  --> $DIR/if_let_slice_binding.rs:39:38
+   |
+LL |     if let (SomeEnum::Three(a), Some(b)) = (a_wrapped, b_wrapped) {
+   |                                      ^
+   |
+help: try using a slice pattern here
+   |
+LL |     if let (SomeEnum::Three(a), Some([_, b_1, ..])) = (a_wrapped, b_wrapped) {
+   |                                      ~~~~~~~~~~~~
+help: and replace the index expressions here
+   |
+LL |         println!("{} -> {}", a[2], b_1);
+   |                                    ~~~
+
+error: this binding can be a slice pattern to avoid indexing
+  --> $DIR/if_let_slice_binding.rs:46:21
+   |
+LL |     if let Some(ref slice) = slice {
+   |                     ^^^^^
+   |
+help: try using a slice pattern here
+   |
+LL |     if let Some([_, ref slice_1, ..]) = slice {
+   |                 ~~~~~~~~~~~~~~~~~~~~
+help: and replace the index expressions here
+   |
+LL |         println!("{:?}", slice_1);
+   |                          ~~~~~~~
+
+error: this binding can be a slice pattern to avoid indexing
+  --> $DIR/if_let_slice_binding.rs:54:17
+   |
+LL |     if let Some(slice) = &slice {
+   |                 ^^^^^
+   |
+help: try using a slice pattern here
+   |
+LL |     if let Some([slice_0, ..]) = &slice {
+   |                 ~~~~~~~~~~~~~
+help: and replace the index expressions here
+   |
+LL |         println!("{:?}", slice_0);
+   |                          ~~~~~~~
+
+error: this binding can be a slice pattern to avoid indexing
+  --> $DIR/if_let_slice_binding.rs:123:17
+   |
+LL |     if let Some(slice) = wrap.inner {
+   |                 ^^^^^
+   |
+help: try using a slice pattern here
+   |
+LL |     if let Some([slice_0, ..]) = wrap.inner {
+   |                 ~~~~~~~~~~~~~
+help: and replace the index expressions here
+   |
+LL |             println!("This is awesome! {}", slice_0);
+   |                                             ~~~~~~~
+
+error: this binding can be a slice pattern to avoid indexing
+  --> $DIR/if_let_slice_binding.rs:130:17
+   |
+LL |     if let Some(slice) = wrap.inner {
+   |                 ^^^^^
+   |
+help: try using a slice pattern here
+   |
+LL |     if let Some([slice_0, ..]) = wrap.inner {
+   |                 ~~~~~~~~~~~~~
+help: and replace the index expressions here
+   |
+LL |             println!("This is super awesome! {}", slice_0);
+   |                                                   ~~~~~~~
+
+error: aborting due to 10 previous errors
+
diff --git a/tests/ui/index_refutable_slice/slice_indexing_in_macro.rs b/tests/ui/index_refutable_slice/slice_indexing_in_macro.rs
new file mode 100644
index 00000000000..406e82083f8
--- /dev/null
+++ b/tests/ui/index_refutable_slice/slice_indexing_in_macro.rs
@@ -0,0 +1,28 @@
+#![deny(clippy::index_refutable_slice)]
+
+extern crate if_chain;
+use if_chain::if_chain;
+
+macro_rules! if_let_slice_macro {
+    () => {
+        // This would normally be linted
+        let slice: Option<&[u32]> = Some(&[1, 2, 3]);
+        if let Some(slice) = slice {
+            println!("{}", slice[0]);
+        }
+    };
+}
+
+fn main() {
+    // Don't lint this
+    if_let_slice_macro!();
+
+    // Do lint this
+    if_chain! {
+        let slice: Option<&[u32]> = Some(&[1, 2, 3]);
+        if let Some(slice) = slice;
+        then {
+            println!("{}", slice[0]);
+        }
+    }
+}
diff --git a/tests/ui/index_refutable_slice/slice_indexing_in_macro.stderr b/tests/ui/index_refutable_slice/slice_indexing_in_macro.stderr
new file mode 100644
index 00000000000..11b19428b4f
--- /dev/null
+++ b/tests/ui/index_refutable_slice/slice_indexing_in_macro.stderr
@@ -0,0 +1,22 @@
+error: this binding can be a slice pattern to avoid indexing
+  --> $DIR/slice_indexing_in_macro.rs:23:21
+   |
+LL |         if let Some(slice) = slice;
+   |                     ^^^^^
+   |
+note: the lint level is defined here
+  --> $DIR/slice_indexing_in_macro.rs:1:9
+   |
+LL | #![deny(clippy::index_refutable_slice)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+help: try using a slice pattern here
+   |
+LL |         if let Some([slice_0, ..]) = slice;
+   |                     ~~~~~~~~~~~~~
+help: and replace the index expressions here
+   |
+LL |             println!("{}", slice_0);
+   |                            ~~~~~~~
+
+error: aborting due to previous error
+
-- 
cgit 1.4.1-3-g733a5


From d4c8cb63a474c2365664a68e35153adef3cdd9b9 Mon Sep 17 00:00:00 2001
From: 5225225 <5225225@mailbox.org>
Date: Fri, 12 Nov 2021 17:01:35 +0000
Subject: Change cast_lossless message for bools only

---
 clippy_lints/src/casts/cast_lossless.rs | 17 +++++++++++++----
 tests/ui/cast_lossless_bool.stderr      | 26 +++++++++++++-------------
 2 files changed, 26 insertions(+), 17 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/cast_lossless.rs b/clippy_lints/src/casts/cast_lossless.rs
index cc360fc9c76..4a95bed1148 100644
--- a/clippy_lints/src/casts/cast_lossless.rs
+++ b/clippy_lints/src/casts/cast_lossless.rs
@@ -40,14 +40,23 @@ pub(super) fn check(
         },
     );
 
+    let message = if cast_from.is_bool() {
+        format!(
+            "casting `{0:}` to `{1:}` is more cleanly stated with `{1:}::from(_)`",
+            cast_from, cast_to
+        )
+    } else {
+        format!(
+            "casting `{}` to `{}` may become silently lossy if you later change the type",
+            cast_from, cast_to
+        )
+    };
+
     span_lint_and_sugg(
         cx,
         CAST_LOSSLESS,
         expr.span,
-        &format!(
-            "casting `{}` to `{}` may become silently lossy if you later change the type",
-            cast_from, cast_to
-        ),
+        &message,
         "try",
         format!("{}::from({})", cast_to, sugg),
         applicability,
diff --git a/tests/ui/cast_lossless_bool.stderr b/tests/ui/cast_lossless_bool.stderr
index a0d11f08acf..6b148336011 100644
--- a/tests/ui/cast_lossless_bool.stderr
+++ b/tests/ui/cast_lossless_bool.stderr
@@ -1,4 +1,4 @@
-error: casting `bool` to `u8` may become silently lossy if you later change the type
+error: casting `bool` to `u8` is more cleanly stated with `u8::from(_)`
   --> $DIR/cast_lossless_bool.rs:8:13
    |
 LL |     let _ = true as u8;
@@ -6,73 +6,73 @@ LL |     let _ = true as u8;
    |
    = note: `-D clippy::cast-lossless` implied by `-D warnings`
 
-error: casting `bool` to `u16` may become silently lossy if you later change the type
+error: casting `bool` to `u16` is more cleanly stated with `u16::from(_)`
   --> $DIR/cast_lossless_bool.rs:9:13
    |
 LL |     let _ = true as u16;
    |             ^^^^^^^^^^^ help: try: `u16::from(true)`
 
-error: casting `bool` to `u32` may become silently lossy if you later change the type
+error: casting `bool` to `u32` is more cleanly stated with `u32::from(_)`
   --> $DIR/cast_lossless_bool.rs:10:13
    |
 LL |     let _ = true as u32;
    |             ^^^^^^^^^^^ help: try: `u32::from(true)`
 
-error: casting `bool` to `u64` may become silently lossy if you later change the type
+error: casting `bool` to `u64` is more cleanly stated with `u64::from(_)`
   --> $DIR/cast_lossless_bool.rs:11:13
    |
 LL |     let _ = true as u64;
    |             ^^^^^^^^^^^ help: try: `u64::from(true)`
 
-error: casting `bool` to `u128` may become silently lossy if you later change the type
+error: casting `bool` to `u128` is more cleanly stated with `u128::from(_)`
   --> $DIR/cast_lossless_bool.rs:12:13
    |
 LL |     let _ = true as u128;
    |             ^^^^^^^^^^^^ help: try: `u128::from(true)`
 
-error: casting `bool` to `usize` may become silently lossy if you later change the type
+error: casting `bool` to `usize` is more cleanly stated with `usize::from(_)`
   --> $DIR/cast_lossless_bool.rs:13:13
    |
 LL |     let _ = true as usize;
    |             ^^^^^^^^^^^^^ help: try: `usize::from(true)`
 
-error: casting `bool` to `i8` may become silently lossy if you later change the type
+error: casting `bool` to `i8` is more cleanly stated with `i8::from(_)`
   --> $DIR/cast_lossless_bool.rs:15:13
    |
 LL |     let _ = true as i8;
    |             ^^^^^^^^^^ help: try: `i8::from(true)`
 
-error: casting `bool` to `i16` may become silently lossy if you later change the type
+error: casting `bool` to `i16` is more cleanly stated with `i16::from(_)`
   --> $DIR/cast_lossless_bool.rs:16:13
    |
 LL |     let _ = true as i16;
    |             ^^^^^^^^^^^ help: try: `i16::from(true)`
 
-error: casting `bool` to `i32` may become silently lossy if you later change the type
+error: casting `bool` to `i32` is more cleanly stated with `i32::from(_)`
   --> $DIR/cast_lossless_bool.rs:17:13
    |
 LL |     let _ = true as i32;
    |             ^^^^^^^^^^^ help: try: `i32::from(true)`
 
-error: casting `bool` to `i64` may become silently lossy if you later change the type
+error: casting `bool` to `i64` is more cleanly stated with `i64::from(_)`
   --> $DIR/cast_lossless_bool.rs:18:13
    |
 LL |     let _ = true as i64;
    |             ^^^^^^^^^^^ help: try: `i64::from(true)`
 
-error: casting `bool` to `i128` may become silently lossy if you later change the type
+error: casting `bool` to `i128` is more cleanly stated with `i128::from(_)`
   --> $DIR/cast_lossless_bool.rs:19:13
    |
 LL |     let _ = true as i128;
    |             ^^^^^^^^^^^^ help: try: `i128::from(true)`
 
-error: casting `bool` to `isize` may become silently lossy if you later change the type
+error: casting `bool` to `isize` is more cleanly stated with `isize::from(_)`
   --> $DIR/cast_lossless_bool.rs:20:13
    |
 LL |     let _ = true as isize;
    |             ^^^^^^^^^^^^^ help: try: `isize::from(true)`
 
-error: casting `bool` to `u16` may become silently lossy if you later change the type
+error: casting `bool` to `u16` is more cleanly stated with `u16::from(_)`
   --> $DIR/cast_lossless_bool.rs:23:13
    |
 LL |     let _ = (true | false) as u16;
-- 
cgit 1.4.1-3-g733a5


From 80a263d4693a3108cb70ec567e9618f02d2d332b Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Fri, 12 Nov 2021 19:12:17 -0500
Subject: Fix `manual_map` suggestion when used with unsafe functions and
 unsafe blocks.

---
 clippy_lints/src/manual_map.rs      | 95 ++++++++++++++++++++++++++-----------
 tests/ui/manual_map_option_2.fixed  |  8 ++++
 tests/ui/manual_map_option_2.rs     | 14 ++++++
 tests/ui/manual_map_option_2.stderr | 22 ++++++++-
 4 files changed, 111 insertions(+), 28 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_map.rs b/clippy_lints/src/manual_map.rs
index cf5dabd9462..6234932363f 100644
--- a/clippy_lints/src/manual_map.rs
+++ b/clippy_lints/src/manual_map.rs
@@ -2,7 +2,7 @@ use crate::{map_unit_fn::OPTION_MAP_UNIT_FN, matches::MATCH_AS_REF};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::higher::IfLetOrMatch;
 use clippy_utils::source::{snippet_with_applicability, snippet_with_context};
-use clippy_utils::ty::{is_type_diagnostic_item, peel_mid_ty_refs_is_mutable};
+use clippy_utils::ty::{is_type_diagnostic_item, peel_mid_ty_refs_is_mutable, type_is_unsafe_function};
 use clippy_utils::{
     can_move_expr_to_closure, in_constant, is_else_clause, is_lang_ctor, is_lint_allowed, path_to_local_id,
     peel_hir_expr_refs, peel_hir_expr_while, CaptureKind,
@@ -11,7 +11,8 @@ use rustc_ast::util::parser::PREC_POSTFIX;
 use rustc_errors::Applicability;
 use rustc_hir::LangItem::{OptionNone, OptionSome};
 use rustc_hir::{
-    def::Res, Arm, BindingAnnotation, Block, Expr, ExprKind, HirId, Mutability, Pat, PatKind, Path, QPath,
+    def::Res, Arm, BindingAnnotation, Block, BlockCheckMode, Expr, ExprKind, HirId, Mutability, Pat, PatKind, Path,
+    QPath, UnsafeSource,
 };
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
@@ -93,20 +94,20 @@ impl LateLintPass<'_> for ManualMap {
             return;
         }
 
-        let some_expr = match get_some_expr(cx, some_expr, expr_ctxt) {
+        let some_expr = match get_some_expr(cx, some_expr, false, expr_ctxt) {
             Some(expr) => expr,
             None => return,
         };
 
         // These two lints will go back and forth with each other.
-        if cx.typeck_results().expr_ty(some_expr) == cx.tcx.types.unit
+        if cx.typeck_results().expr_ty(some_expr.expr) == cx.tcx.types.unit
             && !is_lint_allowed(cx, OPTION_MAP_UNIT_FN, expr.hir_id)
         {
             return;
         }
 
         // `map` won't perform any adjustments.
-        if !cx.typeck_results().expr_adjustments(some_expr).is_empty() {
+        if !cx.typeck_results().expr_adjustments(some_expr.expr).is_empty() {
             return;
         }
 
@@ -120,7 +121,7 @@ impl LateLintPass<'_> for ManualMap {
             None => "",
         };
 
-        match can_move_expr_to_closure(cx, some_expr) {
+        match can_move_expr_to_closure(cx, some_expr.expr) {
             Some(captures) => {
                 // Check if captures the closure will need conflict with borrows made in the scrutinee.
                 // TODO: check all the references made in the scrutinee expression. This will require interacting
@@ -158,12 +159,14 @@ impl LateLintPass<'_> for ManualMap {
             };
 
         let body_str = if let PatKind::Binding(annotation, id, some_binding, None) = some_pat.kind {
-            match can_pass_as_func(cx, id, some_expr) {
-                Some(func) if func.span.ctxt() == some_expr.span.ctxt() => {
+            if_chain! {
+                if !some_expr.needs_unsafe_block;
+                if let Some(func) = can_pass_as_func(cx, id, some_expr.expr);
+                if func.span.ctxt() == some_expr.expr.span.ctxt();
+                then {
                     snippet_with_applicability(cx, func.span, "..", &mut app).into_owned()
-                },
-                _ => {
-                    if path_to_local_id(some_expr, id)
+                } else {
+                    if path_to_local_id(some_expr.expr, id)
                         && !is_lint_allowed(cx, MATCH_AS_REF, expr.hir_id)
                         && binding_ref.is_some()
                     {
@@ -176,21 +179,38 @@ impl LateLintPass<'_> for ManualMap {
                     } else {
                         ""
                     };
-                    format!(
-                        "|{}{}| {}",
-                        annotation,
-                        some_binding,
-                        snippet_with_context(cx, some_expr.span, expr_ctxt, "..", &mut app).0
-                    )
-                },
+                    if some_expr.needs_unsafe_block {
+                        format!(
+                            "|{}{}| unsafe {{ {} }}",
+                            annotation,
+                            some_binding,
+                            snippet_with_context(cx, some_expr.expr.span, expr_ctxt, "..", &mut app).0
+                        )
+                    } else {
+                        format!(
+                            "|{}{}| {}",
+                            annotation,
+                            some_binding,
+                            snippet_with_context(cx, some_expr.expr.span, expr_ctxt, "..", &mut app).0
+                        )
+                    }
+                }
             }
         } else if !is_wild_none && explicit_ref.is_none() {
             // TODO: handle explicit reference annotations.
-            format!(
-                "|{}| {}",
-                snippet_with_context(cx, some_pat.span, expr_ctxt, "..", &mut app).0,
-                snippet_with_context(cx, some_expr.span, expr_ctxt, "..", &mut app).0
-            )
+            if some_expr.needs_unsafe_block {
+                format!(
+                    "|{}| unsafe {{ {} }}",
+                    snippet_with_context(cx, some_pat.span, expr_ctxt, "..", &mut app).0,
+                    snippet_with_context(cx, some_expr.expr.span, expr_ctxt, "..", &mut app).0
+                )
+            } else {
+                format!(
+                    "|{}| {}",
+                    snippet_with_context(cx, some_pat.span, expr_ctxt, "..", &mut app).0,
+                    snippet_with_context(cx, some_expr.expr.span, expr_ctxt, "..", &mut app).0
+                )
+            }
         } else {
             // Refutable bindings and mixed reference annotations can't be handled by `map`.
             return;
@@ -217,7 +237,9 @@ impl LateLintPass<'_> for ManualMap {
 fn can_pass_as_func(cx: &LateContext<'tcx>, binding: HirId, expr: &'tcx Expr<'_>) -> Option<&'tcx Expr<'tcx>> {
     match expr.kind {
         ExprKind::Call(func, [arg])
-            if path_to_local_id(arg, binding) && cx.typeck_results().expr_adjustments(arg).is_empty() =>
+            if path_to_local_id(arg, binding)
+                && cx.typeck_results().expr_adjustments(arg).is_empty()
+                && !type_is_unsafe_function(cx, cx.typeck_results().expr_ty(func).peel_refs()) =>
         {
             Some(func)
         },
@@ -237,6 +259,11 @@ enum OptionPat<'a> {
     },
 }
 
+struct SomeExpr<'tcx> {
+    expr: &'tcx Expr<'tcx>,
+    needs_unsafe_block: bool,
+}
+
 // Try to parse into a recognized `Option` pattern.
 // i.e. `_`, `None`, `Some(..)`, or a reference to any of those.
 fn try_parse_pattern(cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>, ctxt: SyntaxContext) -> Option<OptionPat<'tcx>> {
@@ -257,7 +284,12 @@ fn try_parse_pattern(cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>, ctxt: SyntaxCon
 }
 
 // Checks for an expression wrapped by the `Some` constructor. Returns the contained expression.
-fn get_some_expr(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, ctxt: SyntaxContext) -> Option<&'tcx Expr<'tcx>> {
+fn get_some_expr(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx Expr<'_>,
+    needs_unsafe_block: bool,
+    ctxt: SyntaxContext,
+) -> Option<SomeExpr<'tcx>> {
     // TODO: Allow more complex expressions.
     match expr.kind {
         ExprKind::Call(
@@ -266,15 +298,24 @@ fn get_some_expr(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, ctxt: SyntaxConte
                 ..
             },
             [arg],
-        ) if ctxt == expr.span.ctxt() && is_lang_ctor(cx, qpath, OptionSome) => Some(arg),
+        ) if ctxt == expr.span.ctxt() && is_lang_ctor(cx, qpath, OptionSome) => Some(SomeExpr {
+            expr: arg,
+            needs_unsafe_block,
+        }),
         ExprKind::Block(
             Block {
                 stmts: [],
                 expr: Some(expr),
+                rules,
                 ..
             },
             _,
-        ) => get_some_expr(cx, expr, ctxt),
+        ) => get_some_expr(
+            cx,
+            expr,
+            needs_unsafe_block || *rules == BlockCheckMode::UnsafeBlock(UnsafeSource::UserProvided),
+            ctxt,
+        ),
         _ => None,
     }
 }
diff --git a/tests/ui/manual_map_option_2.fixed b/tests/ui/manual_map_option_2.fixed
index 8cc12149403..a004ea79d3b 100644
--- a/tests/ui/manual_map_option_2.fixed
+++ b/tests/ui/manual_map_option_2.fixed
@@ -47,4 +47,12 @@ fn main() {
     let _ = s.as_ref().map(|x| {
             if let Some(ref s) = s { (x.clone(), s) } else { panic!() }
         });
+
+    unsafe fn f(x: u32) -> u32 {
+        x
+    }
+    unsafe {
+        let _ = Some(0).map(|x| f(x));
+    }
+    let _ = Some(0).map(|x| unsafe { f(x) });
 }
diff --git a/tests/ui/manual_map_option_2.rs b/tests/ui/manual_map_option_2.rs
index 0862b201ead..0119e2bd998 100644
--- a/tests/ui/manual_map_option_2.rs
+++ b/tests/ui/manual_map_option_2.rs
@@ -53,4 +53,18 @@ fn main() {
         }),
         None => None,
     };
+
+    unsafe fn f(x: u32) -> u32 {
+        x
+    }
+    unsafe {
+        let _ = match Some(0) {
+            Some(x) => Some(f(x)),
+            None => None,
+        };
+    }
+    let _ = match Some(0) {
+        Some(x) => unsafe { Some(f(x)) },
+        None => None,
+    };
 }
diff --git a/tests/ui/manual_map_option_2.stderr b/tests/ui/manual_map_option_2.stderr
index 711ff6c4a4b..a3143638cfc 100644
--- a/tests/ui/manual_map_option_2.stderr
+++ b/tests/ui/manual_map_option_2.stderr
@@ -39,5 +39,25 @@ LL +             if let Some(ref s) = s { (x.clone(), s) } else { panic!() }
 LL ~         });
    |
 
-error: aborting due to 2 previous errors
+error: manual implementation of `Option::map`
+  --> $DIR/manual_map_option_2.rs:61:17
+   |
+LL |           let _ = match Some(0) {
+   |  _________________^
+LL | |             Some(x) => Some(f(x)),
+LL | |             None => None,
+LL | |         };
+   | |_________^ help: try this: `Some(0).map(|x| f(x))`
+
+error: manual implementation of `Option::map`
+  --> $DIR/manual_map_option_2.rs:66:13
+   |
+LL |       let _ = match Some(0) {
+   |  _____________^
+LL | |         Some(x) => unsafe { Some(f(x)) },
+LL | |         None => None,
+LL | |     };
+   | |_____^ help: try this: `Some(0).map(|x| unsafe { f(x) })`
+
+error: aborting due to 4 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 2ed4a8a3e6fc8d53225ded631e815a767859184e Mon Sep 17 00:00:00 2001
From: togami2864 <tuabobo123@gmail.com>
Date: Sat, 13 Nov 2021 22:38:28 +0900
Subject: fix suggestion in option_map_or_none

---
 clippy_lints/src/methods/option_map_or_none.rs |  6 +++---
 tests/ui/option_map_or_none.fixed              |  4 ++--
 tests/ui/option_map_or_none.stderr             | 10 +++++-----
 3 files changed, 10 insertions(+), 10 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/option_map_or_none.rs b/clippy_lints/src/methods/option_map_or_none.rs
index e99b6b07d15..8f61bd97b45 100644
--- a/clippy_lints/src/methods/option_map_or_none.rs
+++ b/clippy_lints/src/methods/option_map_or_none.rs
@@ -53,12 +53,12 @@ pub(super) fn check<'tcx>(
             let self_snippet = snippet(cx, recv.span, "..");
             let func_snippet = snippet(cx, map_arg.span, "..");
             let msg = "called `map_or(None, ..)` on an `Option` value. This can be done more directly by calling \
-                       `and_then(..)` instead";
+                       `map(..)` instead";
             (
                 OPTION_MAP_OR_NONE,
                 msg,
-                "try using `and_then` instead",
-                format!("{0}.and_then({1})", self_snippet, func_snippet),
+                "try using `map` instead",
+                format!("{0}.map({1})", self_snippet, func_snippet),
             )
         } else if f_arg_is_some {
             let msg = "called `map_or(None, Some)` on a `Result` value. This can be done more directly by calling \
diff --git a/tests/ui/option_map_or_none.fixed b/tests/ui/option_map_or_none.fixed
index d80c3c7c1b7..429ef00003f 100644
--- a/tests/ui/option_map_or_none.fixed
+++ b/tests/ui/option_map_or_none.fixed
@@ -7,10 +7,10 @@ fn main() {
 
     // Check `OPTION_MAP_OR_NONE`.
     // Single line case.
-    let _ = opt.and_then(|x| Some(x + 1));
+    let _ = opt.map(|x| Some(x + 1));
     // Multi-line case.
     #[rustfmt::skip]
-    let _ = opt.and_then(|x| {
+    let _ = opt.map(|x| {
                         Some(x + 1)
                        });
 }
diff --git a/tests/ui/option_map_or_none.stderr b/tests/ui/option_map_or_none.stderr
index 27d68b85e6f..b011515934d 100644
--- a/tests/ui/option_map_or_none.stderr
+++ b/tests/ui/option_map_or_none.stderr
@@ -1,12 +1,12 @@
-error: called `map_or(None, ..)` on an `Option` value. This can be done more directly by calling `and_then(..)` instead
+error: called `map_or(None, ..)` on an `Option` value. This can be done more directly by calling `map(..)` instead
   --> $DIR/option_map_or_none.rs:10:13
    |
 LL |     let _ = opt.map_or(None, |x| Some(x + 1));
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try using `and_then` instead: `opt.and_then(|x| Some(x + 1))`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try using `map` instead: `opt.map(|x| Some(x + 1))`
    |
    = note: `-D clippy::option-map-or-none` implied by `-D warnings`
 
-error: called `map_or(None, ..)` on an `Option` value. This can be done more directly by calling `and_then(..)` instead
+error: called `map_or(None, ..)` on an `Option` value. This can be done more directly by calling `map(..)` instead
   --> $DIR/option_map_or_none.rs:13:13
    |
 LL |       let _ = opt.map_or(None, |x| {
@@ -15,9 +15,9 @@ LL | |                         Some(x + 1)
 LL | |                        });
    | |_________________________^
    |
-help: try using `and_then` instead
+help: try using `map` instead
    |
-LL ~     let _ = opt.and_then(|x| {
+LL ~     let _ = opt.map(|x| {
 LL +                         Some(x + 1)
 LL ~                        });
    |
-- 
cgit 1.4.1-3-g733a5


From 3fe11e776c223201045ff9938f8eaec6053ceb3a Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Sat, 13 Nov 2021 23:16:02 +0100
Subject: option_if_let_else: don't expand macros in suggestion

Fixes #7973

changelog: don't expand macros in suggestion of clippy::option_if_let_else
---
 clippy_lints/src/option_if_let_else.rs |  6 +++---
 tests/ui/option_if_let_else.fixed      | 13 +++++++++++++
 tests/ui/option_if_let_else.rs         | 17 +++++++++++++++++
 tests/ui/option_if_let_else.stderr     | 20 +++++++++++++++-----
 4 files changed, 48 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/option_if_let_else.rs b/clippy_lints/src/option_if_let_else.rs
index df72f4b0eb2..f7c19baf7f9 100644
--- a/clippy_lints/src/option_if_let_else.rs
+++ b/clippy_lints/src/option_if_let_else.rs
@@ -111,7 +111,7 @@ fn extract_body_from_expr<'a>(expr: &'a Expr<'a>) -> Option<&'a Expr<'a>> {
 fn format_option_in_sugg(cx: &LateContext<'_>, cond_expr: &Expr<'_>, as_ref: bool, as_mut: bool) -> String {
     format!(
         "{}{}",
-        Sugg::hir(cx, cond_expr, "..").maybe_par(),
+        Sugg::hir_with_macro_callsite(cx, cond_expr, "..").maybe_par(),
         if as_mut {
             ".as_mut()"
         } else if as_ref {
@@ -184,8 +184,8 @@ fn detect_option_if_let_else<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>) ->
             Some(OptionIfLetElseOccurence {
                 option: format_option_in_sugg(cx, cond_expr, as_ref, as_mut),
                 method_sugg: method_sugg.to_string(),
-                some_expr: format!("|{}{}| {}", capture_mut, capture_name, Sugg::hir(cx, some_body, "..")),
-                none_expr: format!("{}{}", if method_sugg == "map_or" { "" } else { "|| " }, Sugg::hir(cx, none_body, "..")),
+                some_expr: format!("|{}{}| {}", capture_mut, capture_name, Sugg::hir_with_macro_callsite(cx, some_body, "..")),
+                none_expr: format!("{}{}", if method_sugg == "map_or" { "" } else { "|| " }, Sugg::hir_with_macro_callsite(cx, none_body, "..")),
             })
         } else {
             None
diff --git a/tests/ui/option_if_let_else.fixed b/tests/ui/option_if_let_else.fixed
index 9cb6a9d1ecc..9fdea79fe71 100644
--- a/tests/ui/option_if_let_else.fixed
+++ b/tests/ui/option_if_let_else.fixed
@@ -75,6 +75,17 @@ fn negative_tests(arg: Option<u32>) -> u32 {
     7
 }
 
+// #7973
+fn pattern_to_vec(pattern: &str) -> Vec<String> {
+    pattern
+        .trim_matches('/')
+        .split('/')
+        .flat_map(|s| {
+            s.find('.').map_or_else(|| vec![s.to_string()], |idx| vec![s[..idx].to_string(), s[idx..].to_string()])
+        })
+        .collect::<Vec<_>>()
+}
+
 fn main() {
     let optional = Some(5);
     let _ = optional.map_or(5, |x| x + 2);
@@ -146,4 +157,6 @@ fn main() {
         // Don't lint. `await` can't be moved into a closure.
         let _ = if let Some(x) = Some(0) { _f1(x).await } else { 0 };
     }
+
+    let _ = pattern_to_vec("hello world");
 }
diff --git a/tests/ui/option_if_let_else.rs b/tests/ui/option_if_let_else.rs
index b3ba5eb870a..c228b2f43d1 100644
--- a/tests/ui/option_if_let_else.rs
+++ b/tests/ui/option_if_let_else.rs
@@ -94,6 +94,21 @@ fn negative_tests(arg: Option<u32>) -> u32 {
     7
 }
 
+// #7973
+fn pattern_to_vec(pattern: &str) -> Vec<String> {
+    pattern
+        .trim_matches('/')
+        .split('/')
+        .flat_map(|s| {
+            if let Some(idx) = s.find('.') {
+                vec![s[..idx].to_string(), s[idx..].to_string()]
+            } else {
+                vec![s.to_string()]
+            }
+        })
+        .collect::<Vec<_>>()
+}
+
 fn main() {
     let optional = Some(5);
     let _ = if let Some(x) = optional { x + 2 } else { 5 };
@@ -171,4 +186,6 @@ fn main() {
         // Don't lint. `await` can't be moved into a closure.
         let _ = if let Some(x) = Some(0) { _f1(x).await } else { 0 };
     }
+
+    let _ = pattern_to_vec("hello world");
 }
diff --git a/tests/ui/option_if_let_else.stderr b/tests/ui/option_if_let_else.stderr
index 685bb48ea37..d7711bc1c47 100644
--- a/tests/ui/option_if_let_else.stderr
+++ b/tests/ui/option_if_let_else.stderr
@@ -142,14 +142,24 @@ LL +         y
 LL ~     }, |x| x * x * x * x);
    |
 
+error: use Option::map_or_else instead of an if let/else
+  --> $DIR/option_if_let_else.rs:103:13
+   |
+LL | /             if let Some(idx) = s.find('.') {
+LL | |                 vec![s[..idx].to_string(), s[idx..].to_string()]
+LL | |             } else {
+LL | |                 vec![s.to_string()]
+LL | |             }
+   | |_____________^ help: try: `s.find('.').map_or_else(|| vec![s.to_string()], |idx| vec![s[..idx].to_string(), s[idx..].to_string()])`
+
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:99:13
+  --> $DIR/option_if_let_else.rs:114:13
    |
 LL |     let _ = if let Some(x) = optional { x + 2 } else { 5 };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `optional.map_or(5, |x| x + 2)`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:108:13
+  --> $DIR/option_if_let_else.rs:123:13
    |
 LL |       let _ = if let Some(x) = Some(0) {
    |  _____________^
@@ -171,13 +181,13 @@ LL ~         });
    |
 
 error: use Option::map_or_else instead of an if let/else
-  --> $DIR/option_if_let_else.rs:136:13
+  --> $DIR/option_if_let_else.rs:151:13
    |
 LL |     let _ = if let Some(x) = Some(0) { s.len() + x } else { s.len() };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Some(0).map_or_else(|| s.len(), |x| s.len() + x)`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:140:13
+  --> $DIR/option_if_let_else.rs:155:13
    |
 LL |       let _ = if let Some(x) = Some(0) {
    |  _____________^
@@ -196,5 +206,5 @@ LL +         s.len() + x
 LL ~     });
    |
 
-error: aborting due to 14 previous errors
+error: aborting due to 15 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 3e20e300f6c54f9139452d27a9559b4ba524e4c5 Mon Sep 17 00:00:00 2001
From: Skyler Calaman <54462713+Blckbrry-Pi@users.noreply.github.com>
Date: Sun, 14 Nov 2021 18:18:43 -0500
Subject: Fix specific code outlined in issue #7975.

Still needs to generalize to other mixes of let bindings, `map` method calls, etc.
---
 clippy_lints/src/loops/needless_collect.rs | 125 +++++++++++++++++++++++------
 tests/ui/needless_collect_indirect.rs      |  12 +++
 2 files changed, 113 insertions(+), 24 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/needless_collect.rs b/clippy_lints/src/loops/needless_collect.rs
index e87f4b66912..22c123e9e04 100644
--- a/clippy_lints/src/loops/needless_collect.rs
+++ b/clippy_lints/src/loops/needless_collect.rs
@@ -3,13 +3,15 @@ use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_hir_and_then};
 use clippy_utils::source::{snippet, snippet_with_applicability};
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{is_trait_method, path_to_local_id};
+use clippy_utils::{can_move_expr_to_closure, is_trait_method, path_to_local_id, CaptureKind};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_block, walk_expr, NestedVisitorMap, Visitor};
-use rustc_hir::{Block, Expr, ExprKind, HirId, PatKind, StmtKind};
+use rustc_hir::{Block, Expr, ExprKind, HirId, HirIdSet, Local, Mutability, Node, PatKind, Stmt, StmtKind};
 use rustc_lint::LateContext;
 use rustc_middle::hir::map::Map;
+use rustc_middle::ty::subst::GenericArgKind;
+use rustc_middle::ty::{TyKind, TyS};
 use rustc_span::sym;
 use rustc_span::{MultiSpan, Span};
 
@@ -83,7 +85,8 @@ fn check_needless_collect_indirect_usage<'tcx>(expr: &'tcx Expr<'_>, cx: &LateCo
                     is_type_diagnostic_item(cx, ty, sym::VecDeque) ||
                     is_type_diagnostic_item(cx, ty, sym::BinaryHeap) ||
                     is_type_diagnostic_item(cx, ty, sym::LinkedList);
-                if let Some(iter_calls) = detect_iter_and_into_iters(block, id);
+                let iter_ty = cx.typeck_results().expr_ty(iter_source);
+                if let Some(iter_calls) = detect_iter_and_into_iters(block, id, cx, get_captured_ids(cx, iter_ty));
                 if let [iter_call] = &*iter_calls;
                 then {
                     let mut used_count_visitor = UsedCountVisitor {
@@ -167,34 +170,57 @@ enum IterFunctionKind {
     Contains(Span),
 }
 
-struct IterFunctionVisitor {
+struct IterFunctionVisitor<'b, 'a> {
+    illegal_mutable_capture_ids: HirIdSet,
+    current_mutably_captured_ids: HirIdSet,
+    cx: &'a LateContext<'b>,
     uses: Vec<IterFunction>,
     seen_other: bool,
     target: HirId,
 }
-impl<'tcx> Visitor<'tcx> for IterFunctionVisitor {
+impl<'tcx> Visitor<'tcx> for IterFunctionVisitor<'_, 'tcx> {
+    fn visit_block(&mut self, block: &'txc Block<'tcx>) {
+        for elem in block.stmts.iter().filter_map(get_expr_from_stmt).chain(block.expr) {
+            self.current_mutably_captured_ids = HirIdSet::default();
+            self.visit_expr(elem);
+        }
+    }
+
     fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) {
         // Check function calls on our collection
         if let ExprKind::MethodCall(method_name, _, [recv, args @ ..], _) = &expr.kind {
+            if method_name.ident.name == sym!(collect) && is_trait_method(self.cx, expr, sym::Iterator) {
+                self.current_mutably_captured_ids = get_captured_ids(self.cx, self.cx.typeck_results().expr_ty(recv));
+                self.visit_expr(recv);
+                return;
+            }
+
             if path_to_local_id(recv, self.target) {
-                match &*method_name.ident.name.as_str() {
-                    "into_iter" => self.uses.push(IterFunction {
-                        func: IterFunctionKind::IntoIter,
-                        span: expr.span,
-                    }),
-                    "len" => self.uses.push(IterFunction {
-                        func: IterFunctionKind::Len,
-                        span: expr.span,
-                    }),
-                    "is_empty" => self.uses.push(IterFunction {
-                        func: IterFunctionKind::IsEmpty,
-                        span: expr.span,
-                    }),
-                    "contains" => self.uses.push(IterFunction {
-                        func: IterFunctionKind::Contains(args[0].span),
-                        span: expr.span,
-                    }),
-                    _ => self.seen_other = true,
+                if self
+                    .illegal_mutable_capture_ids
+                    .intersection(&self.current_mutably_captured_ids)
+                    .next()
+                    .is_none()
+                {
+                    match &*method_name.ident.name.as_str() {
+                        "into_iter" => self.uses.push(IterFunction {
+                            func: IterFunctionKind::IntoIter,
+                            span: expr.span,
+                        }),
+                        "len" => self.uses.push(IterFunction {
+                            func: IterFunctionKind::Len,
+                            span: expr.span,
+                        }),
+                        "is_empty" => self.uses.push(IterFunction {
+                            func: IterFunctionKind::IsEmpty,
+                            span: expr.span,
+                        }),
+                        "contains" => self.uses.push(IterFunction {
+                            func: IterFunctionKind::Contains(args[0].span),
+                            span: expr.span,
+                        }),
+                        _ => self.seen_other = true,
+                    }
                 }
                 return;
             }
@@ -213,6 +239,14 @@ impl<'tcx> Visitor<'tcx> for IterFunctionVisitor {
     }
 }
 
+fn get_expr_from_stmt<'v>(stmt: &'v Stmt<'v>) -> Option<&'v Expr<'v>> {
+    match stmt.kind {
+        StmtKind::Expr(expr) | StmtKind::Semi(expr) => Some(expr),
+        StmtKind::Item(..) => None,
+        StmtKind::Local(Local { init, .. }) => *init,
+    }
+}
+
 struct UsedCountVisitor<'a, 'tcx> {
     cx: &'a LateContext<'tcx>,
     id: HirId,
@@ -237,12 +271,55 @@ impl<'a, 'tcx> Visitor<'tcx> for UsedCountVisitor<'a, 'tcx> {
 
 /// Detect the occurrences of calls to `iter` or `into_iter` for the
 /// given identifier
-fn detect_iter_and_into_iters<'tcx>(block: &'tcx Block<'tcx>, id: HirId) -> Option<Vec<IterFunction>> {
+fn detect_iter_and_into_iters<'tcx: 'a, 'a>(
+    block: &'tcx Block<'tcx>,
+    id: HirId,
+    cx: &'a LateContext<'tcx>,
+    captured_ids: HirIdSet,
+) -> Option<Vec<IterFunction>> {
     let mut visitor = IterFunctionVisitor {
         uses: Vec::new(),
         target: id,
         seen_other: false,
+        cx,
+        current_mutably_captured_ids: HirIdSet::default(),
+        illegal_mutable_capture_ids: captured_ids,
     };
     visitor.visit_block(block);
     if visitor.seen_other { None } else { Some(visitor.uses) }
 }
+
+#[allow(rustc::usage_of_ty_tykind)]
+fn get_captured_ids(cx: &LateContext<'tcx>, ty: &'_ TyS<'_>) -> HirIdSet {
+    fn get_captured_ids_recursive(cx: &LateContext<'tcx>, ty: &'_ TyS<'_>, set: &mut HirIdSet) {
+        match ty.kind() {
+            TyKind::Adt(_, generics) => {
+                for generic in *generics {
+                    if let GenericArgKind::Type(ty) = generic.unpack() {
+                        get_captured_ids_recursive(cx, ty, set);
+                    }
+                }
+            },
+            TyKind::Closure(def_id, _) => {
+                let closure_hir_node = cx.tcx.hir().get_if_local(*def_id).unwrap();
+                if let Node::Expr(closure_expr) = closure_hir_node {
+                    can_move_expr_to_closure(cx, closure_expr)
+                        .unwrap()
+                        .into_iter()
+                        .for_each(|(hir_id, capture_kind)| {
+                            if matches!(capture_kind, CaptureKind::Ref(Mutability::Mut)) {
+                                set.insert(hir_id);
+                            }
+                        });
+                }
+            },
+            _ => (),
+        }
+    }
+
+    let mut set = HirIdSet::default();
+
+    get_captured_ids_recursive(cx, ty, &mut set);
+
+    set
+}
diff --git a/tests/ui/needless_collect_indirect.rs b/tests/ui/needless_collect_indirect.rs
index 2c94235b8f5..7f2d86b0925 100644
--- a/tests/ui/needless_collect_indirect.rs
+++ b/tests/ui/needless_collect_indirect.rs
@@ -76,6 +76,18 @@ mod issue7110 {
     }
 }
 
+mod issue7975 {
+    use super::*;
+
+    fn shouldnt_lint() -> Vec<()> {
+        let test_vec: Vec<()> = vec![];
+        let mut vec_2: Vec<()> = vec![];
+        let mut_ref = &mut vec_2;
+        let collected_vec: Vec<_> = test_vec.into_iter().map(|_| mut_ref.push(())).collect();
+        collected_vec.into_iter().map(|_| mut_ref.push(())).collect()
+    }
+}
+
 fn allow_test() {
     #[allow(clippy::needless_collect)]
     let v = [1].iter().collect::<Vec<_>>();
-- 
cgit 1.4.1-3-g733a5


From 634e79c65574269a6a6dc2fec3b78848ddf2fdd0 Mon Sep 17 00:00:00 2001
From: surechen <chenshuo17@huawei.com>
Date: Thu, 11 Nov 2021 09:59:31 +0800
Subject: Support suggestion for #7854

I think the detection of parking_lot's mutex and rwlock is valuable, so submit this pr, please help judge and review, thank you.

Make let_underscore_lock support parking_lot.

changelog: Make let_underscore_lock support parking_lot
---
 Cargo.toml                          |  1 +
 clippy_lints/src/let_underscore.rs  |  7 ++++--
 clippy_utils/src/paths.rs           |  2 ++
 tests/compile-test.rs               |  3 +++
 tests/ui/let_underscore_lock.rs     | 14 +++++++++++
 tests/ui/let_underscore_lock.stderr | 46 +++++++++++++++++++++++++++++++------
 6 files changed, 64 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/Cargo.toml b/Cargo.toml
index ed7fb144013..a5514d05eef 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -47,6 +47,7 @@ itertools = "0.10"
 quote = "1.0"
 serde = { version = "1.0", features = ["derive"] }
 syn = { version = "1.0", features = ["full"] }
+parking_lot = "0.11.2"
 
 [build-dependencies]
 rustc_tools_util = { version = "0.2", path = "rustc_tools_util" }
diff --git a/clippy_lints/src/let_underscore.rs b/clippy_lints/src/let_underscore.rs
index 9efd7aba7e8..c9693115e33 100644
--- a/clippy_lints/src/let_underscore.rs
+++ b/clippy_lints/src/let_underscore.rs
@@ -33,7 +33,8 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for `let _ = sync_lock`
+    /// Checks for `let _ = sync_lock`.
+    /// This supports `mutex` and `rwlock` in `std::sync` and `parking_lot`.
     ///
     /// ### Why is this bad?
     /// This statement immediately drops the lock instead of
@@ -101,10 +102,12 @@ declare_clippy_lint! {
 
 declare_lint_pass!(LetUnderscore => [LET_UNDERSCORE_MUST_USE, LET_UNDERSCORE_LOCK, LET_UNDERSCORE_DROP]);
 
-const SYNC_GUARD_PATHS: [&[&str]; 3] = [
+const SYNC_GUARD_PATHS: [&[&str]; 5] = [
     &paths::MUTEX_GUARD,
     &paths::RWLOCK_READ_GUARD,
     &paths::RWLOCK_WRITE_GUARD,
+    &paths::PARKING_LOT_RAWMUTEX,
+    &paths::PARKING_LOT_RAWRWLOCK,
 ];
 
 impl<'tcx> LateLintPass<'tcx> for LetUnderscore {
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index 501b08a47f1..480923bbb02 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -110,6 +110,8 @@ pub(super) const PANICKING_PANIC: [&str; 3] = ["core", "panicking", "panic"];
 pub(super) const PANICKING_PANIC_FMT: [&str; 3] = ["core", "panicking", "panic_fmt"];
 pub(super) const PANICKING_PANIC_STR: [&str; 3] = ["core", "panicking", "panic_str"];
 pub(super) const PANIC_ANY: [&str; 3] = ["std", "panic", "panic_any"];
+pub const PARKING_LOT_RAWMUTEX: [&str; 3] = ["parking_lot", "raw_mutex", "RawMutex"];
+pub const PARKING_LOT_RAWRWLOCK: [&str; 3] = ["parking_lot", "raw_rwlock", "RawRwLock"];
 pub const PARKING_LOT_MUTEX_GUARD: [&str; 2] = ["parking_lot", "MutexGuard"];
 pub const PARKING_LOT_RWLOCK_READ_GUARD: [&str; 2] = ["parking_lot", "RwLockReadGuard"];
 pub const PARKING_LOT_RWLOCK_WRITE_GUARD: [&str; 2] = ["parking_lot", "RwLockWriteGuard"];
diff --git a/tests/compile-test.rs b/tests/compile-test.rs
index c15835ef299..2e87db39b57 100644
--- a/tests/compile-test.rs
+++ b/tests/compile-test.rs
@@ -28,6 +28,7 @@ static TEST_DEPENDENCIES: &[&str] = &[
     "serde",
     "serde_derive",
     "syn",
+    "parking_lot",
 ];
 
 // Test dependencies may need an `extern crate` here to ensure that they show up
@@ -41,6 +42,8 @@ extern crate if_chain;
 #[allow(unused_extern_crates)]
 extern crate itertools;
 #[allow(unused_extern_crates)]
+extern crate parking_lot;
+#[allow(unused_extern_crates)]
 extern crate quote;
 #[allow(unused_extern_crates)]
 extern crate syn;
diff --git a/tests/ui/let_underscore_lock.rs b/tests/ui/let_underscore_lock.rs
index 88fb216a743..539d74d1d4c 100644
--- a/tests/ui/let_underscore_lock.rs
+++ b/tests/ui/let_underscore_lock.rs
@@ -1,5 +1,7 @@
 #![warn(clippy::let_underscore_lock)]
 
+extern crate parking_lot;
+
 fn main() {
     let m = std::sync::Mutex::new(());
     let rw = std::sync::RwLock::new(());
@@ -10,4 +12,16 @@ fn main() {
     let _ = m.try_lock();
     let _ = rw.try_read();
     let _ = rw.try_write();
+
+    use parking_lot::{lock_api::RawMutex, Mutex, RwLock};
+
+    let p_m: Mutex<()> = Mutex::const_new(RawMutex::INIT, ());
+    let _ = p_m.lock();
+
+    let p_m1 = Mutex::new(0);
+    let _ = p_m1.lock();
+
+    let p_rw = RwLock::new(0);
+    let _ = p_rw.read();
+    let _ = p_rw.write();
 }
diff --git a/tests/ui/let_underscore_lock.stderr b/tests/ui/let_underscore_lock.stderr
index 5d5f6059ef1..3a2bc17bf7b 100644
--- a/tests/ui/let_underscore_lock.stderr
+++ b/tests/ui/let_underscore_lock.stderr
@@ -1,5 +1,5 @@
 error: non-binding let on a synchronization lock
-  --> $DIR/let_underscore_lock.rs:7:5
+  --> $DIR/let_underscore_lock.rs:9:5
    |
 LL |     let _ = m.lock();
    |     ^^^^^^^^^^^^^^^^^
@@ -8,7 +8,7 @@ LL |     let _ = m.lock();
    = help: consider using an underscore-prefixed named binding or dropping explicitly with `std::mem::drop`
 
 error: non-binding let on a synchronization lock
-  --> $DIR/let_underscore_lock.rs:8:5
+  --> $DIR/let_underscore_lock.rs:10:5
    |
 LL |     let _ = rw.read();
    |     ^^^^^^^^^^^^^^^^^^
@@ -16,7 +16,7 @@ LL |     let _ = rw.read();
    = help: consider using an underscore-prefixed named binding or dropping explicitly with `std::mem::drop`
 
 error: non-binding let on a synchronization lock
-  --> $DIR/let_underscore_lock.rs:9:5
+  --> $DIR/let_underscore_lock.rs:11:5
    |
 LL |     let _ = rw.write();
    |     ^^^^^^^^^^^^^^^^^^^
@@ -24,7 +24,7 @@ LL |     let _ = rw.write();
    = help: consider using an underscore-prefixed named binding or dropping explicitly with `std::mem::drop`
 
 error: non-binding let on a synchronization lock
-  --> $DIR/let_underscore_lock.rs:10:5
+  --> $DIR/let_underscore_lock.rs:12:5
    |
 LL |     let _ = m.try_lock();
    |     ^^^^^^^^^^^^^^^^^^^^^
@@ -32,7 +32,7 @@ LL |     let _ = m.try_lock();
    = help: consider using an underscore-prefixed named binding or dropping explicitly with `std::mem::drop`
 
 error: non-binding let on a synchronization lock
-  --> $DIR/let_underscore_lock.rs:11:5
+  --> $DIR/let_underscore_lock.rs:13:5
    |
 LL |     let _ = rw.try_read();
    |     ^^^^^^^^^^^^^^^^^^^^^^
@@ -40,12 +40,44 @@ LL |     let _ = rw.try_read();
    = help: consider using an underscore-prefixed named binding or dropping explicitly with `std::mem::drop`
 
 error: non-binding let on a synchronization lock
-  --> $DIR/let_underscore_lock.rs:12:5
+  --> $DIR/let_underscore_lock.rs:14:5
    |
 LL |     let _ = rw.try_write();
    |     ^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: consider using an underscore-prefixed named binding or dropping explicitly with `std::mem::drop`
 
-error: aborting due to 6 previous errors
+error: non-binding let on a synchronization lock
+  --> $DIR/let_underscore_lock.rs:19:5
+   |
+LL |     let _ = p_m.lock();
+   |     ^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using an underscore-prefixed named binding or dropping explicitly with `std::mem::drop`
+
+error: non-binding let on a synchronization lock
+  --> $DIR/let_underscore_lock.rs:22:5
+   |
+LL |     let _ = p_m1.lock();
+   |     ^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using an underscore-prefixed named binding or dropping explicitly with `std::mem::drop`
+
+error: non-binding let on a synchronization lock
+  --> $DIR/let_underscore_lock.rs:25:5
+   |
+LL |     let _ = p_rw.read();
+   |     ^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using an underscore-prefixed named binding or dropping explicitly with `std::mem::drop`
+
+error: non-binding let on a synchronization lock
+  --> $DIR/let_underscore_lock.rs:26:5
+   |
+LL |     let _ = p_rw.write();
+   |     ^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using an underscore-prefixed named binding or dropping explicitly with `std::mem::drop`
+
+error: aborting due to 10 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From bbffe825ed12231e333bd641eb46aa477cde3b8f Mon Sep 17 00:00:00 2001
From: togami2864 <tuabobo123@gmail.com>
Date: Tue, 16 Nov 2021 02:06:31 +0900
Subject: add reduce_unit_expression

---
 clippy_lints/src/methods/option_map_or_none.rs | 138 ++++++++++++++++---------
 tests/ui/option_map_or_none.fixed              |   6 +-
 tests/ui/option_map_or_none.stderr             |  10 +-
 3 files changed, 96 insertions(+), 58 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/option_map_or_none.rs b/clippy_lints/src/methods/option_map_or_none.rs
index 8f61bd97b45..00a4dda9701 100644
--- a/clippy_lints/src/methods/option_map_or_none.rs
+++ b/clippy_lints/src/methods/option_map_or_none.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::is_lang_ctor;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::{is_lang_ctor, single_segment_path};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_hir::LangItem::{OptionNone, OptionSome};
@@ -11,6 +11,26 @@ use rustc_span::symbol::sym;
 use super::OPTION_MAP_OR_NONE;
 use super::RESULT_MAP_OR_INTO_OPTION;
 
+fn reduce_unit_expression<'a>(
+    cx: &LateContext<'_>,
+    expr: &'a hir::Expr<'_>,
+) -> Option<(&'a hir::Expr<'a>, &'a [hir::Expr<'a>])> {
+    match expr.kind {
+        hir::ExprKind::Call(func, arg_char) => Some((func, arg_char)),
+        hir::ExprKind::Block(block, _) => {
+            match block.expr {
+                Some(inner_expr) => {
+                    // If block only contains an expression,
+                    // reduce `{ X }` to `X`
+                    reduce_unit_expression(cx, inner_expr)
+                },
+                _ => None,
+            }
+        },
+        _ => None,
+    }
+}
+
 /// lint use of `_.map_or(None, _)` for `Option`s and `Result`s
 pub(super) fn check<'tcx>(
     cx: &LateContext<'tcx>,
@@ -31,58 +51,78 @@ pub(super) fn check<'tcx>(
         return;
     }
 
-    let (lint_name, msg, instead, hint) = {
-        let default_arg_is_none = if let hir::ExprKind::Path(ref qpath) = def_arg.kind {
-            is_lang_ctor(cx, qpath, OptionNone)
-        } else {
-            return;
-        };
+    // let (lint_name, msg, instead, hint) = {
+    let default_arg_is_none = if let hir::ExprKind::Path(ref qpath) = def_arg.kind {
+        is_lang_ctor(cx, qpath, OptionNone)
+    } else {
+        return;
+    };
 
-        if !default_arg_is_none {
-            // nothing to lint!
-            return;
-        }
+    if !default_arg_is_none {
+        // nothing to lint!
+        return;
+    }
 
-        let f_arg_is_some = if let hir::ExprKind::Path(ref qpath) = map_arg.kind {
-            is_lang_ctor(cx, qpath, OptionSome)
-        } else {
-            false
-        };
+    let f_arg_is_some = if let hir::ExprKind::Path(ref qpath) = map_arg.kind {
+        is_lang_ctor(cx, qpath, OptionSome)
+    } else {
+        false
+    };
 
-        if is_option {
-            let self_snippet = snippet(cx, recv.span, "..");
-            let func_snippet = snippet(cx, map_arg.span, "..");
-            let msg = "called `map_or(None, ..)` on an `Option` value. This can be done more directly by calling \
+    if is_option {
+        let self_snippet = snippet(cx, recv.span, "..");
+        if let hir::ExprKind::Closure(_, _, id, _, _) = map_arg.kind {
+            if_chain! {
+                let body = cx.tcx.hir().body(id);
+                if let Some((func, arg_char)) = reduce_unit_expression(cx, &body.value);
+                if arg_char.len() == 1;
+                if let hir::ExprKind::Path(ref qpath) = func.kind;
+                if let Some(segment) = single_segment_path(qpath);
+                if segment.ident.name == sym::Some;
+                then {
+                    let func_snippet = snippet(cx, arg_char[0].span, "..");
+                    let msg = "called `map_or(None, ..)` on an `Option` value. This can be done more directly by calling \
                        `map(..)` instead";
-            (
-                OPTION_MAP_OR_NONE,
-                msg,
-                "try using `map` instead",
-                format!("{0}.map({1})", self_snippet, func_snippet),
-            )
-        } else if f_arg_is_some {
-            let msg = "called `map_or(None, Some)` on a `Result` value. This can be done more directly by calling \
-                       `ok()` instead";
-            let self_snippet = snippet(cx, recv.span, "..");
-            (
-                RESULT_MAP_OR_INTO_OPTION,
-                msg,
-                "try using `ok` instead",
-                format!("{0}.ok()", self_snippet),
-            )
-        } else {
-            // nothing to lint!
-            return;
+                    return span_lint_and_sugg(
+                        cx,
+                        OPTION_MAP_OR_NONE,
+                        expr.span,
+                        msg,
+                        "try using `map` instead",
+                        format!("{0}.map({1})", self_snippet, func_snippet),
+                        Applicability::MachineApplicable,
+                    );
+                }
+            }
         }
-    };
 
-    span_lint_and_sugg(
-        cx,
-        lint_name,
-        expr.span,
-        msg,
-        instead,
-        hint,
-        Applicability::MachineApplicable,
-    );
+        let func_snippet = snippet(cx, map_arg.span, "..");
+        let msg = "called `map_or(None, ..)` on an `Option` value. This can be done more directly by calling \
+                       `and_then(..)` instead";
+        span_lint_and_sugg(
+            cx,
+            OPTION_MAP_OR_NONE,
+            expr.span,
+            msg,
+            "try using `and_then` instead",
+            format!("{0}.and_then({1})", self_snippet, func_snippet),
+            Applicability::MachineApplicable,
+        )
+    } else if f_arg_is_some {
+        let msg = "called `map_or(None, Some)` on a `Result` value. This can be done more directly by calling \
+                       `ok()` instead";
+        let self_snippet = snippet(cx, recv.span, "..");
+        span_lint_and_sugg(
+            cx,
+            RESULT_MAP_OR_INTO_OPTION,
+            expr.span,
+            msg,
+            "try using `ok` instead",
+            format!("{0}.ok()", self_snippet),
+            Applicability::MachineApplicable,
+        )
+    } else {
+        // nothing to lint!
+        return;
+    }
 }
diff --git a/tests/ui/option_map_or_none.fixed b/tests/ui/option_map_or_none.fixed
index 77ad2d5285a..9333cb89c9a 100644
--- a/tests/ui/option_map_or_none.fixed
+++ b/tests/ui/option_map_or_none.fixed
@@ -5,7 +5,7 @@
 fn main() {
     let opt = Some(1);
     let bar = |_| {
-       Some(1)
+        Some(1)
     };
 
     // Check `OPTION_MAP_OR_NONE`.
@@ -13,9 +13,7 @@ fn main() {
     let _ :Option<i32> = opt.map(|x| x + 1);
     // Multi-line case.
     #[rustfmt::skip]
-    let _ :Option<i32> = opt.map(|x| {
-                        x + 1
-                       });
+    let _ :Option<i32> = opt.map(|x| x + 1);
     // function returning `Option`
     let _ :Option<i32> = opt.and_then(bar);
 }
diff --git a/tests/ui/option_map_or_none.stderr b/tests/ui/option_map_or_none.stderr
index 86ac93b9c80..3d75f2776f6 100644
--- a/tests/ui/option_map_or_none.stderr
+++ b/tests/ui/option_map_or_none.stderr
@@ -1,16 +1,16 @@
 error: called `map_or(None, ..)` on an `Option` value. This can be done more directly by calling `map(..)` instead
-  --> $DIR/option_map_or_none.rs:10:13
+  --> $DIR/option_map_or_none.rs:13:26
    |
 LL |     let _ :Option<i32> = opt.map_or(None, |x| Some(x + 1));
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try using `map` instead: `opt.map(|x| x + 1)`
+   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try using `map` instead: `opt.map(|x| x + 1)`
    |
    = note: `-D clippy::option-map-or-none` implied by `-D warnings`
 
 error: called `map_or(None, ..)` on an `Option` value. This can be done more directly by calling `map(..)` instead
-  --> $DIR/option_map_or_none.rs:13:13
+  --> $DIR/option_map_or_none.rs:16:26
    |
 LL |       let _ :Option<i32> = opt.map_or(None, |x| {
-   |  _____________^
+   |  __________________________^
 LL | |                         Some(x + 1)
 LL | |                        });
    | |_________________________^
@@ -22,7 +22,7 @@ LL +                         x + 1
 LL ~                        });
    |
 
-error: called `map_or(None, ..)` on an `Option` value. This can be done more directly by calling `map(..)` instead
+error: called `map_or(None, ..)` on an `Option` value. This can be done more directly by calling `and_then(..)` instead
   --> $DIR/option_map_or_none.rs:20:26
    |
 LL |     let _ :Option<i32> = opt.map_or(None, bar);
-- 
cgit 1.4.1-3-g733a5


From 02e0726149a8fd9963b2b81f8c15587520445cc6 Mon Sep 17 00:00:00 2001
From: togami2864 <tuabobo123@gmail.com>
Date: Tue, 16 Nov 2021 02:29:02 +0900
Subject: fix a bug that the closure arguments are not displayed

---
 clippy_lints/src/methods/option_map_or_none.rs | 19 ++++++++-----------
 tests/ui/option_map_or_none.stderr             |  9 +--------
 2 files changed, 9 insertions(+), 19 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/option_map_or_none.rs b/clippy_lints/src/methods/option_map_or_none.rs
index 00a4dda9701..a18db4d9371 100644
--- a/clippy_lints/src/methods/option_map_or_none.rs
+++ b/clippy_lints/src/methods/option_map_or_none.rs
@@ -21,7 +21,7 @@ fn reduce_unit_expression<'a>(
             match block.expr {
                 Some(inner_expr) => {
                     // If block only contains an expression,
-                    // reduce `{ X }` to `X`
+                    // reduce `|x| { x + 1 }` to `|x| x + 1`
                     reduce_unit_expression(cx, inner_expr)
                 },
                 _ => None,
@@ -51,7 +51,6 @@ pub(super) fn check<'tcx>(
         return;
     }
 
-    // let (lint_name, msg, instead, hint) = {
     let default_arg_is_none = if let hir::ExprKind::Path(ref qpath) = def_arg.kind {
         is_lang_ctor(cx, qpath, OptionNone)
     } else {
@@ -71,7 +70,8 @@ pub(super) fn check<'tcx>(
 
     if is_option {
         let self_snippet = snippet(cx, recv.span, "..");
-        if let hir::ExprKind::Closure(_, _, id, _, _) = map_arg.kind {
+        if let hir::ExprKind::Closure(_, _, id, span, _) = map_arg.kind {
+            let arg_snippet = snippet(cx, span, "..");
             if_chain! {
                 let body = cx.tcx.hir().body(id);
                 if let Some((func, arg_char)) = reduce_unit_expression(cx, &body.value);
@@ -89,7 +89,7 @@ pub(super) fn check<'tcx>(
                         expr.span,
                         msg,
                         "try using `map` instead",
-                        format!("{0}.map({1})", self_snippet, func_snippet),
+                        format!("{0}.map({1} {2})", self_snippet, arg_snippet,func_snippet),
                         Applicability::MachineApplicable,
                     );
                 }
@@ -99,7 +99,7 @@ pub(super) fn check<'tcx>(
         let func_snippet = snippet(cx, map_arg.span, "..");
         let msg = "called `map_or(None, ..)` on an `Option` value. This can be done more directly by calling \
                        `and_then(..)` instead";
-        span_lint_and_sugg(
+        return span_lint_and_sugg(
             cx,
             OPTION_MAP_OR_NONE,
             expr.span,
@@ -107,12 +107,12 @@ pub(super) fn check<'tcx>(
             "try using `and_then` instead",
             format!("{0}.and_then({1})", self_snippet, func_snippet),
             Applicability::MachineApplicable,
-        )
+        );
     } else if f_arg_is_some {
         let msg = "called `map_or(None, Some)` on a `Result` value. This can be done more directly by calling \
                        `ok()` instead";
         let self_snippet = snippet(cx, recv.span, "..");
-        span_lint_and_sugg(
+        return span_lint_and_sugg(
             cx,
             RESULT_MAP_OR_INTO_OPTION,
             expr.span,
@@ -120,9 +120,6 @@ pub(super) fn check<'tcx>(
             "try using `ok` instead",
             format!("{0}.ok()", self_snippet),
             Applicability::MachineApplicable,
-        )
-    } else {
-        // nothing to lint!
-        return;
+        );
     }
 }
diff --git a/tests/ui/option_map_or_none.stderr b/tests/ui/option_map_or_none.stderr
index 3d75f2776f6..560b767fba2 100644
--- a/tests/ui/option_map_or_none.stderr
+++ b/tests/ui/option_map_or_none.stderr
@@ -13,14 +13,7 @@ LL |       let _ :Option<i32> = opt.map_or(None, |x| {
    |  __________________________^
 LL | |                         Some(x + 1)
 LL | |                        });
-   | |_________________________^
-   |
-help: try using `map` instead
-   |
-LL ~     let _ :Option<i32> = opt.map(|x| {
-LL +                         x + 1
-LL ~                        });
-   |
+   | |_________________________^ help: try using `map` instead: `opt.map(|x| x + 1)`
 
 error: called `map_or(None, ..)` on an `Option` value. This can be done more directly by calling `and_then(..)` instead
   --> $DIR/option_map_or_none.rs:20:26
-- 
cgit 1.4.1-3-g733a5


From cd5781648a93ca851459c8397c2bb1dfa3dd393b Mon Sep 17 00:00:00 2001
From: togami2864 <tuabobo123@gmail.com>
Date: Tue, 16 Nov 2021 02:30:54 +0900
Subject: add comment

---
 clippy_lints/src/methods/option_map_or_none.rs | 1 +
 1 file changed, 1 insertion(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/option_map_or_none.rs b/clippy_lints/src/methods/option_map_or_none.rs
index a18db4d9371..ac2a5b70004 100644
--- a/clippy_lints/src/methods/option_map_or_none.rs
+++ b/clippy_lints/src/methods/option_map_or_none.rs
@@ -11,6 +11,7 @@ use rustc_span::symbol::sym;
 use super::OPTION_MAP_OR_NONE;
 use super::RESULT_MAP_OR_INTO_OPTION;
 
+/// The expression inside a closure may or may not have surrounding braces
 fn reduce_unit_expression<'a>(
     cx: &LateContext<'_>,
     expr: &'a hir::Expr<'_>,
-- 
cgit 1.4.1-3-g733a5


From 300282c09aa8e922699b4fc7e2c608b4f8d81719 Mon Sep 17 00:00:00 2001
From: togami2864 <tuabobo123@gmail.com>
Date: Tue, 16 Nov 2021 02:53:35 +0900
Subject: fix fmt

---
 clippy_lints/src/methods/option_map_or_none.rs |  3 ++-
 tests/ui/option_map_or_none.fixed              | 10 ++++------
 tests/ui/option_map_or_none.rs                 | 10 ++++------
 tests/ui/option_map_or_none.stderr             | 12 ++++++------
 4 files changed, 16 insertions(+), 19 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/option_map_or_none.rs b/clippy_lints/src/methods/option_map_or_none.rs
index ac2a5b70004..3a93d912e8c 100644
--- a/clippy_lints/src/methods/option_map_or_none.rs
+++ b/clippy_lints/src/methods/option_map_or_none.rs
@@ -11,7 +11,8 @@ use rustc_span::symbol::sym;
 use super::OPTION_MAP_OR_NONE;
 use super::RESULT_MAP_OR_INTO_OPTION;
 
-/// The expression inside a closure may or may not have surrounding braces
+// The expression inside a closure may or may not have surrounding braces
+// which causes problems when generating a suggestion.
 fn reduce_unit_expression<'a>(
     cx: &LateContext<'_>,
     expr: &'a hir::Expr<'_>,
diff --git a/tests/ui/option_map_or_none.fixed b/tests/ui/option_map_or_none.fixed
index 9333cb89c9a..abaf88be8ca 100644
--- a/tests/ui/option_map_or_none.fixed
+++ b/tests/ui/option_map_or_none.fixed
@@ -4,16 +4,14 @@
 
 fn main() {
     let opt = Some(1);
-    let bar = |_| {
-        Some(1)
-    };
+    let bar = |_| Some(1);
 
     // Check `OPTION_MAP_OR_NONE`.
     // Single line case.
-    let _ :Option<i32> = opt.map(|x| x + 1);
+    let _: Option<i32> = opt.map(|x| x + 1);
     // Multi-line case.
     #[rustfmt::skip]
-    let _ :Option<i32> = opt.map(|x| x + 1);
+    let _: Option<i32> = opt.map(|x| x + 1);
     // function returning `Option`
-    let _ :Option<i32> = opt.and_then(bar);
+    let _: Option<i32> = opt.and_then(bar);
 }
diff --git a/tests/ui/option_map_or_none.rs b/tests/ui/option_map_or_none.rs
index 789531b7215..a63b63c4dc0 100644
--- a/tests/ui/option_map_or_none.rs
+++ b/tests/ui/option_map_or_none.rs
@@ -4,18 +4,16 @@
 
 fn main() {
     let opt = Some(1);
-    let bar = |_| {
-        Some(1)
-    };
+    let bar = |_| Some(1);
 
     // Check `OPTION_MAP_OR_NONE`.
     // Single line case.
-    let _ :Option<i32> = opt.map_or(None, |x| Some(x + 1));
+    let _: Option<i32> = opt.map_or(None, |x| Some(x + 1));
     // Multi-line case.
     #[rustfmt::skip]
-    let _ :Option<i32> = opt.map_or(None, |x| {
+    let _: Option<i32> = opt.map_or(None, |x| {
                         Some(x + 1)
                        });
     // function returning `Option`
-    let _ :Option<i32> = opt.map_or(None, bar);
+    let _: Option<i32> = opt.map_or(None, bar);
 }
diff --git a/tests/ui/option_map_or_none.stderr b/tests/ui/option_map_or_none.stderr
index 560b767fba2..aec46cb005f 100644
--- a/tests/ui/option_map_or_none.stderr
+++ b/tests/ui/option_map_or_none.stderr
@@ -1,24 +1,24 @@
 error: called `map_or(None, ..)` on an `Option` value. This can be done more directly by calling `map(..)` instead
-  --> $DIR/option_map_or_none.rs:13:26
+  --> $DIR/option_map_or_none.rs:11:26
    |
-LL |     let _ :Option<i32> = opt.map_or(None, |x| Some(x + 1));
+LL |     let _: Option<i32> = opt.map_or(None, |x| Some(x + 1));
    |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try using `map` instead: `opt.map(|x| x + 1)`
    |
    = note: `-D clippy::option-map-or-none` implied by `-D warnings`
 
 error: called `map_or(None, ..)` on an `Option` value. This can be done more directly by calling `map(..)` instead
-  --> $DIR/option_map_or_none.rs:16:26
+  --> $DIR/option_map_or_none.rs:14:26
    |
-LL |       let _ :Option<i32> = opt.map_or(None, |x| {
+LL |       let _: Option<i32> = opt.map_or(None, |x| {
    |  __________________________^
 LL | |                         Some(x + 1)
 LL | |                        });
    | |_________________________^ help: try using `map` instead: `opt.map(|x| x + 1)`
 
 error: called `map_or(None, ..)` on an `Option` value. This can be done more directly by calling `and_then(..)` instead
-  --> $DIR/option_map_or_none.rs:20:26
+  --> $DIR/option_map_or_none.rs:18:26
    |
-LL |     let _ :Option<i32> = opt.map_or(None, bar);
+LL |     let _: Option<i32> = opt.map_or(None, bar);
    |                          ^^^^^^^^^^^^^^^^^^^^^ help: try using `and_then` instead: `opt.and_then(bar)`
 
 error: aborting due to 3 previous errors
-- 
cgit 1.4.1-3-g733a5


From 0a30fdcd3c5ab9803983671a4452dff7e31f9e80 Mon Sep 17 00:00:00 2001
From: togami2864 <tuabobo123@gmail.com>
Date: Tue, 16 Nov 2021 03:02:08 +0900
Subject: move the let statement out of the macro

---
 clippy_lints/src/methods/option_map_or_none.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/option_map_or_none.rs b/clippy_lints/src/methods/option_map_or_none.rs
index 3a93d912e8c..12ccaa24c3b 100644
--- a/clippy_lints/src/methods/option_map_or_none.rs
+++ b/clippy_lints/src/methods/option_map_or_none.rs
@@ -74,8 +74,8 @@ pub(super) fn check<'tcx>(
         let self_snippet = snippet(cx, recv.span, "..");
         if let hir::ExprKind::Closure(_, _, id, span, _) = map_arg.kind {
             let arg_snippet = snippet(cx, span, "..");
+            let body = cx.tcx.hir().body(id);
             if_chain! {
-                let body = cx.tcx.hir().body(id);
                 if let Some((func, arg_char)) = reduce_unit_expression(cx, &body.value);
                 if arg_char.len() == 1;
                 if let hir::ExprKind::Path(ref qpath) = func.kind;
-- 
cgit 1.4.1-3-g733a5


From 8ded385ddc7e48b4e80633b7b66bb0ea2e56ec38 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Mon, 15 Nov 2021 11:58:25 -0500
Subject: Improve `needless_borrow` lint.

* Lint when a borrow is auto dereferenced more than once
* Lint when the expression is used as the expression of a block for a match arm

Moves `needless_borrow` and `ref_binding_to_reference` to `dereference`
lint pass in preperation for `explicit_auto_deref` lint.
---
 clippy_lints/src/bytecount.rs             |   4 +-
 clippy_lints/src/dereference.rs           | 335 +++++++++++++++++++++++++++++-
 clippy_lints/src/lib.register_all.rs      |   2 +-
 clippy_lints/src/lib.register_lints.rs    |   4 +-
 clippy_lints/src/lib.register_pedantic.rs |   2 +-
 clippy_lints/src/lib.register_style.rs    |   2 +-
 clippy_lints/src/lib.rs                   |   2 -
 clippy_lints/src/needless_borrow.rs       | 284 -------------------------
 tests/ui/needless_borrow.fixed            |  23 +-
 tests/ui/needless_borrow.rs               |  23 +-
 tests/ui/needless_borrow.stderr           |  50 ++++-
 11 files changed, 425 insertions(+), 306 deletions(-)
 delete mode 100644 clippy_lints/src/needless_borrow.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/bytecount.rs b/clippy_lints/src/bytecount.rs
index a938ada9d2a..afb317421d0 100644
--- a/clippy_lints/src/bytecount.rs
+++ b/clippy_lints/src/bytecount.rs
@@ -74,10 +74,10 @@ impl<'tcx> LateLintPass<'tcx> for ByteCount {
                     if (p == sym::iter || p == sym!(iter_mut)) && args.len() == 1 {
                         &args[0]
                     } else {
-                        &filter_recv
+                        filter_recv
                     }
                 } else {
-                    &filter_recv
+                    filter_recv
                 };
                 let mut applicability = Applicability::MaybeIncorrect;
                 span_lint_and_sugg(
diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index bbaae94d3dd..fa2b348591b 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -1,14 +1,20 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::source::snippet_with_context;
+use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
+use clippy_utils::source::{snippet_with_applicability, snippet_with_context};
 use clippy_utils::ty::peel_mid_ty_refs;
-use clippy_utils::{get_parent_node, is_lint_allowed};
-use rustc_ast::util::parser::PREC_PREFIX;
+use clippy_utils::{get_parent_expr, get_parent_node, is_lint_allowed, path_to_local};
+use rustc_ast::util::parser::{PREC_POSTFIX, PREC_PREFIX};
+use rustc_data_structures::fx::FxIndexMap;
 use rustc_errors::Applicability;
-use rustc_hir::{BorrowKind, Expr, ExprKind, HirId, MatchSource, Mutability, Node, UnOp};
+use rustc_hir::{
+    BindingAnnotation, Body, BodyId, BorrowKind, Destination, Expr, ExprKind, HirId, MatchSource, Mutability, Node,
+    Pat, PatKind, UnOp,
+};
 use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::adjustment::{Adjust, Adjustment, AutoBorrow};
 use rustc_middle::ty::{self, Ty, TyCtxt, TyS, TypeckResults};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::{symbol::sym, Span};
+use std::iter;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -40,8 +46,64 @@ declare_clippy_lint! {
     "Explicit use of deref or deref_mut method while not in a method chain."
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for address of operations (`&`) that are going to
+    /// be dereferenced immediately by the compiler.
+    ///
+    /// ### Why is this bad?
+    /// Suggests that the receiver of the expression borrows
+    /// the expression.
+    ///
+    /// ### Example
+    /// ```rust
+    /// fn fun(_a: &i32) {}
+    ///
+    /// // Bad
+    /// let x: &i32 = &&&&&&5;
+    /// fun(&x);
+    ///
+    /// // Good
+    /// let x: &i32 = &5;
+    /// fun(x);
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub NEEDLESS_BORROW,
+    style,
+    "taking a reference that is going to be automatically dereferenced"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `ref` bindings which create a reference to a reference.
+    ///
+    /// ### Why is this bad?
+    /// The address-of operator at the use site is clearer about the need for a reference.
+    ///
+    /// ### Example
+    /// ```rust
+    /// // Bad
+    /// let x = Some("");
+    /// if let Some(ref x) = x {
+    ///     // use `x` here
+    /// }
+    ///
+    /// // Good
+    /// let x = Some("");
+    /// if let Some(x) = x {
+    ///     // use `&x` here
+    /// }
+    /// ```
+    #[clippy::version = "1.54.0"]
+    pub REF_BINDING_TO_REFERENCE,
+    pedantic,
+    "`ref` binding to a reference"
+}
+
 impl_lint_pass!(Dereferencing => [
     EXPLICIT_DEREF_METHODS,
+    NEEDLESS_BORROW,
+    REF_BINDING_TO_REFERENCE,
 ]);
 
 #[derive(Default)]
@@ -52,6 +114,18 @@ pub struct Dereferencing {
     // expression. This is to store the id of that expression so it can be skipped when
     // `check_expr` is called for it.
     skip_expr: Option<HirId>,
+
+    /// The body the first local was found in. Used to emit lints when the traversal of the body has
+    /// been finished. Note we can't lint at the end of every body as they can be nested within each
+    /// other.
+    current_body: Option<BodyId>,
+    /// The list of locals currently being checked by the lint.
+    /// If the value is `None`, then the binding has been seen as a ref pattern, but is not linted.
+    /// This is needed for or patterns where one of the branches can be linted, but another can not
+    /// be.
+    ///
+    /// e.g. `m!(x) | Foo::Bar(ref x)`
+    ref_locals: FxIndexMap<HirId, Option<RefPat>>,
 }
 
 struct StateData {
@@ -68,6 +142,9 @@ enum State {
         ty_changed_count: usize,
         is_final_ufcs: bool,
     },
+    DerefedBorrow {
+        count: u32,
+    },
 }
 
 // A reference operation considered by this lint pass
@@ -77,13 +154,29 @@ enum RefOp {
     AddrOf,
 }
 
+struct RefPat {
+    /// Whether every usage of the binding is dereferenced.
+    always_deref: bool,
+    /// The spans of all the ref bindings for this local.
+    spans: Vec<Span>,
+    /// The applicability of this suggestion.
+    app: Applicability,
+    /// All the replacements which need to be made.
+    replacements: Vec<(Span, String)>,
+}
+
 impl<'tcx> LateLintPass<'tcx> for Dereferencing {
+    #[allow(clippy::too_many_lines)]
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         // Skip path expressions from deref calls. e.g. `Deref::deref(e)`
         if Some(expr.hir_id) == self.skip_expr.take() {
             return;
         }
 
+        if let Some(local) = path_to_local(expr) {
+            self.check_local_usage(cx, expr, local);
+        }
+
         // Stop processing sub expressions when a macro call is seen
         if expr.span.from_expansion() {
             if let Some((state, data)) = self.state.take() {
@@ -128,6 +221,48 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing {
                             },
                         ));
                     },
+                    RefOp::AddrOf => {
+                        // Find the number of times the borrow is auto-derefed.
+                        let mut iter = find_adjustments(cx.tcx, typeck, expr).iter();
+                        if let Some((i, adjust)) = iter.by_ref().enumerate().find_map(|(i, adjust)| {
+                            if !matches!(adjust.kind, Adjust::Deref(_)) {
+                                Some((i, adjust))
+                            } else if !adjust.target.is_ref() {
+                                // Add one to the number of references found.
+                                Some((i + 1, adjust))
+                            } else {
+                                None
+                            }
+                        }) {
+                            // Found two consecutive derefs. At least one can be removed.
+                            if i > 1 {
+                                let target_mut = iter::once(adjust)
+                                    .chain(iter)
+                                    .find_map(|adjust| match adjust.kind {
+                                        Adjust::Borrow(AutoBorrow::Ref(_, m)) => Some(m.into()),
+                                        _ => None,
+                                    })
+                                    // This default should never happen. Auto-deref always reborrows.
+                                    .unwrap_or(Mutability::Not);
+                                self.state = Some((
+                                    // Subtract one for the current borrow expression, and one to cover the last
+                                    // reference which can't be removed (it's either reborrowed, or needed for
+                                    // auto-deref to happen).
+                                    State::DerefedBorrow {
+                                        count:
+                                            // Truncation here would require more than a `u32::MAX` level reference. The compiler
+                                            // does not support this.
+                                            #[allow(clippy::cast_possible_truncation)]
+                                            { i as u32 - 2 }
+                                    },
+                                    StateData {
+                                        span: expr.span,
+                                        target_mut,
+                                    },
+                                ));
+                            }
+                        }
+                    },
                     _ => (),
                 }
             },
@@ -144,10 +279,80 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing {
                     data,
                 ));
             },
+            (Some((State::DerefedBorrow { count }, data)), RefOp::AddrOf) if count != 0 => {
+                self.state = Some((State::DerefedBorrow { count: count - 1 }, data));
+            },
 
             (Some((state, data)), _) => report(cx, expr, state, data),
         }
     }
+
+    fn check_pat(&mut self, cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>) {
+        if let PatKind::Binding(BindingAnnotation::Ref, id, name, _) = pat.kind {
+            if let Some(opt_prev_pat) = self.ref_locals.get_mut(&id) {
+                // This binding id has been seen before. Add this pattern to the list of changes.
+                if let Some(prev_pat) = opt_prev_pat {
+                    if pat.span.from_expansion() {
+                        // Doesn't match the context of the previous pattern. Can't lint here.
+                        *opt_prev_pat = None;
+                    } else {
+                        prev_pat.spans.push(pat.span);
+                        prev_pat.replacements.push((
+                            pat.span,
+                            snippet_with_context(cx, name.span, pat.span.ctxt(), "..", &mut prev_pat.app)
+                                .0
+                                .into(),
+                        ));
+                    }
+                }
+                return;
+            }
+
+            if_chain! {
+                if !pat.span.from_expansion();
+                if let ty::Ref(_, tam, _) = *cx.typeck_results().pat_ty(pat).kind();
+                // only lint immutable refs, because borrowed `&mut T` cannot be moved out
+                if let ty::Ref(_, _, Mutability::Not) = *tam.kind();
+                then {
+                    let mut app = Applicability::MachineApplicable;
+                    let snip = snippet_with_context(cx, name.span, pat.span.ctxt(), "..", &mut app).0;
+                    self.current_body = self.current_body.or(cx.enclosing_body);
+                    self.ref_locals.insert(
+                        id,
+                        Some(RefPat {
+                            always_deref: true,
+                            spans: vec![pat.span],
+                            app,
+                            replacements: vec![(pat.span, snip.into())],
+                        }),
+                    );
+                }
+            }
+        }
+    }
+
+    fn check_body_post(&mut self, cx: &LateContext<'tcx>, body: &'tcx Body<'_>) {
+        if Some(body.id()) == self.current_body {
+            for pat in self.ref_locals.drain(..).filter_map(|(_, x)| x) {
+                let replacements = pat.replacements;
+                let app = pat.app;
+                span_lint_and_then(
+                    cx,
+                    if pat.always_deref {
+                        NEEDLESS_BORROW
+                    } else {
+                        REF_BINDING_TO_REFERENCE
+                    },
+                    pat.spans,
+                    "this pattern creates a reference to a reference",
+                    |diag| {
+                        diag.multipart_suggestion("try this", replacements, app);
+                    },
+                );
+            }
+            self.current_body = None;
+        }
+    }
 }
 
 fn try_parse_ref_op(
@@ -251,6 +456,48 @@ fn is_linted_explicit_deref_position(parent: Option<Node<'_>>, child_id: HirId,
     }
 }
 
+/// Adjustments are sometimes made in the parent block rather than the expression itself.
+fn find_adjustments(
+    tcx: TyCtxt<'tcx>,
+    typeck: &'tcx TypeckResults<'_>,
+    expr: &'tcx Expr<'_>,
+) -> &'tcx [Adjustment<'tcx>] {
+    let map = tcx.hir();
+    let mut iter = map.parent_iter(expr.hir_id);
+    let mut prev = expr;
+
+    loop {
+        match typeck.expr_adjustments(prev) {
+            [] => (),
+            a => break a,
+        };
+
+        match iter.next().map(|(_, x)| x) {
+            Some(Node::Block(_)) => {
+                if let Some((_, Node::Expr(e))) = iter.next() {
+                    prev = e;
+                } else {
+                    // This shouldn't happen. Blocks are always contained in an expression.
+                    break &[];
+                }
+            },
+            Some(Node::Expr(&Expr {
+                kind: ExprKind::Break(Destination { target_id: Ok(id), .. }, _),
+                ..
+            })) => {
+                if let Some(Node::Expr(e)) = map.find(id) {
+                    prev = e;
+                    iter = map.parent_iter(id);
+                } else {
+                    // This shouldn't happen. The destination should exist.
+                    break &[];
+                }
+            },
+            _ => break &[],
+        }
+    }
+}
+
 #[allow(clippy::needless_pass_by_value)]
 fn report(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, state: State, data: StateData) {
     match state {
@@ -301,5 +548,83 @@ fn report(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, state: State, data: Stat
                 app,
             );
         },
+        State::DerefedBorrow { .. } => {
+            let mut app = Applicability::MachineApplicable;
+            let snip = snippet_with_context(cx, expr.span, data.span.ctxt(), "..", &mut app).0;
+            span_lint_and_sugg(
+                cx,
+                NEEDLESS_BORROW,
+                data.span,
+                &format!(
+                    "this expression borrows a reference (`{}`) that is immediately dereferenced by the compiler",
+                    cx.typeck_results().expr_ty(expr),
+                ),
+                "change this to",
+                snip.into(),
+                app,
+            );
+        },
+    }
+}
+
+impl Dereferencing {
+    fn check_local_usage(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>, local: HirId) {
+        if let Some(outer_pat) = self.ref_locals.get_mut(&local) {
+            if let Some(pat) = outer_pat {
+                // Check for auto-deref
+                if !matches!(
+                    cx.typeck_results().expr_adjustments(e),
+                    [
+                        Adjustment {
+                            kind: Adjust::Deref(_),
+                            ..
+                        },
+                        Adjustment {
+                            kind: Adjust::Deref(_),
+                            ..
+                        },
+                        ..
+                    ]
+                ) {
+                    match get_parent_expr(cx, e) {
+                        // Field accesses are the same no matter the number of references.
+                        Some(Expr {
+                            kind: ExprKind::Field(..),
+                            ..
+                        }) => (),
+                        Some(&Expr {
+                            span,
+                            kind: ExprKind::Unary(UnOp::Deref, _),
+                            ..
+                        }) if !span.from_expansion() => {
+                            // Remove explicit deref.
+                            let snip = snippet_with_context(cx, e.span, span.ctxt(), "..", &mut pat.app).0;
+                            pat.replacements.push((span, snip.into()));
+                        },
+                        Some(parent) if !parent.span.from_expansion() => {
+                            // Double reference might be needed at this point.
+                            if parent.precedence().order() == PREC_POSTFIX {
+                                // Parentheses would be needed here, don't lint.
+                                *outer_pat = None;
+                            } else {
+                                pat.always_deref = false;
+                                let snip = snippet_with_context(cx, e.span, parent.span.ctxt(), "..", &mut pat.app).0;
+                                pat.replacements.push((e.span, format!("&{}", snip)));
+                            }
+                        },
+                        _ if !e.span.from_expansion() => {
+                            // Double reference might be needed at this point.
+                            pat.always_deref = false;
+                            let snip = snippet_with_applicability(cx, e.span, "..", &mut pat.app);
+                            pat.replacements.push((e.span, format!("&{}", snip)));
+                        },
+                        // Edge case for macros. The span of the identifier will usually match the context of the
+                        // binding, but not if the identifier was created in a macro. e.g. `concat_idents` and proc
+                        // macros
+                        _ => *outer_pat = None,
+                    }
+                }
+            }
+        }
     }
 }
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 15edb79d36c..e24ed9905b6 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -33,6 +33,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(copies::IFS_SAME_COND),
     LintId::of(copies::IF_SAME_THEN_ELSE),
     LintId::of(default::FIELD_REASSIGN_WITH_DEFAULT),
+    LintId::of(dereference::NEEDLESS_BORROW),
     LintId::of(derivable_impls::DERIVABLE_IMPLS),
     LintId::of(derive::DERIVE_HASH_XOR_EQ),
     LintId::of(derive::DERIVE_ORD_XOR_PARTIAL_ORD),
@@ -203,7 +204,6 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(needless_arbitrary_self_type::NEEDLESS_ARBITRARY_SELF_TYPE),
     LintId::of(needless_bool::BOOL_COMPARISON),
     LintId::of(needless_bool::NEEDLESS_BOOL),
-    LintId::of(needless_borrow::NEEDLESS_BORROW),
     LintId::of(needless_borrowed_ref::NEEDLESS_BORROWED_REFERENCE),
     LintId::of(needless_option_as_deref::NEEDLESS_OPTION_AS_DEREF),
     LintId::of(needless_question_mark::NEEDLESS_QUESTION_MARK),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 6d1d45f8900..1458d6eab1a 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -92,6 +92,8 @@ store.register_lints(&[
     default::FIELD_REASSIGN_WITH_DEFAULT,
     default_numeric_fallback::DEFAULT_NUMERIC_FALLBACK,
     dereference::EXPLICIT_DEREF_METHODS,
+    dereference::NEEDLESS_BORROW,
+    dereference::REF_BINDING_TO_REFERENCE,
     derivable_impls::DERIVABLE_IMPLS,
     derive::DERIVE_HASH_XOR_EQ,
     derive::DERIVE_ORD_XOR_PARTIAL_ORD,
@@ -356,8 +358,6 @@ store.register_lints(&[
     needless_bitwise_bool::NEEDLESS_BITWISE_BOOL,
     needless_bool::BOOL_COMPARISON,
     needless_bool::NEEDLESS_BOOL,
-    needless_borrow::NEEDLESS_BORROW,
-    needless_borrow::REF_BINDING_TO_REFERENCE,
     needless_borrowed_ref::NEEDLESS_BORROWED_REFERENCE,
     needless_continue::NEEDLESS_CONTINUE,
     needless_for_each::NEEDLESS_FOR_EACH,
diff --git a/clippy_lints/src/lib.register_pedantic.rs b/clippy_lints/src/lib.register_pedantic.rs
index 404ca20b5ab..5ee7799f9c5 100644
--- a/clippy_lints/src/lib.register_pedantic.rs
+++ b/clippy_lints/src/lib.register_pedantic.rs
@@ -21,6 +21,7 @@ store.register_group(true, "clippy::pedantic", Some("clippy_pedantic"), vec![
     LintId::of(copy_iterator::COPY_ITERATOR),
     LintId::of(default::DEFAULT_TRAIT_ACCESS),
     LintId::of(dereference::EXPLICIT_DEREF_METHODS),
+    LintId::of(dereference::REF_BINDING_TO_REFERENCE),
     LintId::of(derive::EXPL_IMPL_CLONE_ON_COPY),
     LintId::of(derive::UNSAFE_DERIVE_DESERIALIZE),
     LintId::of(doc::DOC_MARKDOWN),
@@ -68,7 +69,6 @@ store.register_group(true, "clippy::pedantic", Some("clippy_pedantic"), vec![
     LintId::of(misc::USED_UNDERSCORE_BINDING),
     LintId::of(mut_mut::MUT_MUT),
     LintId::of(needless_bitwise_bool::NEEDLESS_BITWISE_BOOL),
-    LintId::of(needless_borrow::REF_BINDING_TO_REFERENCE),
     LintId::of(needless_continue::NEEDLESS_CONTINUE),
     LintId::of(needless_for_each::NEEDLESS_FOR_EACH),
     LintId::of(needless_pass_by_value::NEEDLESS_PASS_BY_VALUE),
diff --git a/clippy_lints/src/lib.register_style.rs b/clippy_lints/src/lib.register_style.rs
index 744880bda3e..f336441ea84 100644
--- a/clippy_lints/src/lib.register_style.rs
+++ b/clippy_lints/src/lib.register_style.rs
@@ -15,6 +15,7 @@ store.register_group(true, "clippy::style", Some("clippy_style"), vec![
     LintId::of(collapsible_match::COLLAPSIBLE_MATCH),
     LintId::of(comparison_chain::COMPARISON_CHAIN),
     LintId::of(default::FIELD_REASSIGN_WITH_DEFAULT),
+    LintId::of(dereference::NEEDLESS_BORROW),
     LintId::of(doc::MISSING_SAFETY_DOC),
     LintId::of(doc::NEEDLESS_DOCTEST_MAIN),
     LintId::of(enum_variants::ENUM_VARIANT_NAMES),
@@ -81,7 +82,6 @@ store.register_group(true, "clippy::style", Some("clippy_style"), vec![
     LintId::of(misc_early::REDUNDANT_PATTERN),
     LintId::of(mut_mutex_lock::MUT_MUTEX_LOCK),
     LintId::of(mut_reference::UNNECESSARY_MUT_PASSED),
-    LintId::of(needless_borrow::NEEDLESS_BORROW),
     LintId::of(neg_multiply::NEG_MULTIPLY),
     LintId::of(new_without_default::NEW_WITHOUT_DEFAULT),
     LintId::of(non_copy_const::BORROW_INTERIOR_MUTABLE_CONST),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 22f34491962..60109e8aebc 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -297,7 +297,6 @@ mod mutex_atomic;
 mod needless_arbitrary_self_type;
 mod needless_bitwise_bool;
 mod needless_bool;
-mod needless_borrow;
 mod needless_borrowed_ref;
 mod needless_continue;
 mod needless_for_each;
@@ -602,7 +601,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(zero_div_zero::ZeroDiv));
     store.register_late_pass(|| Box::new(mutex_atomic::Mutex));
     store.register_late_pass(|| Box::new(needless_update::NeedlessUpdate));
-    store.register_late_pass(|| Box::new(needless_borrow::NeedlessBorrow::default()));
     store.register_late_pass(|| Box::new(needless_borrowed_ref::NeedlessBorrowedRef));
     store.register_late_pass(|| Box::new(no_effect::NoEffect));
     store.register_late_pass(|| Box::new(temporary_assignment::TemporaryAssignment));
diff --git a/clippy_lints/src/needless_borrow.rs b/clippy_lints/src/needless_borrow.rs
deleted file mode 100644
index 6709fed91bd..00000000000
--- a/clippy_lints/src/needless_borrow.rs
+++ /dev/null
@@ -1,284 +0,0 @@
-//! Checks for needless address of operations (`&`)
-//!
-//! This lint is **warn** by default
-
-use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::source::{snippet_opt, snippet_with_applicability, snippet_with_context};
-use clippy_utils::{get_parent_expr, path_to_local};
-use if_chain::if_chain;
-use rustc_ast::util::parser::PREC_POSTFIX;
-use rustc_data_structures::fx::FxIndexMap;
-use rustc_errors::Applicability;
-use rustc_hir::{BindingAnnotation, Body, BodyId, BorrowKind, Expr, ExprKind, HirId, Mutability, Pat, PatKind, UnOp};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty;
-use rustc_middle::ty::adjustment::{Adjust, Adjustment};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::Span;
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for address of operations (`&`) that are going to
-    /// be dereferenced immediately by the compiler.
-    ///
-    /// ### Why is this bad?
-    /// Suggests that the receiver of the expression borrows
-    /// the expression.
-    ///
-    /// ### Example
-    /// ```rust
-    /// fn fun(_a: &i32) {}
-    ///
-    /// // Bad
-    /// let x: &i32 = &&&&&&5;
-    /// fun(&x);
-    ///
-    /// // Good
-    /// let x: &i32 = &5;
-    /// fun(x);
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub NEEDLESS_BORROW,
-    style,
-    "taking a reference that is going to be automatically dereferenced"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for `ref` bindings which create a reference to a reference.
-    ///
-    /// ### Why is this bad?
-    /// The address-of operator at the use site is clearer about the need for a reference.
-    ///
-    /// ### Example
-    /// ```rust
-    /// // Bad
-    /// let x = Some("");
-    /// if let Some(ref x) = x {
-    ///     // use `x` here
-    /// }
-    ///
-    /// // Good
-    /// let x = Some("");
-    /// if let Some(x) = x {
-    ///     // use `&x` here
-    /// }
-    /// ```
-    #[clippy::version = "1.54.0"]
-    pub REF_BINDING_TO_REFERENCE,
-    pedantic,
-    "`ref` binding to a reference"
-}
-
-impl_lint_pass!(NeedlessBorrow => [NEEDLESS_BORROW, REF_BINDING_TO_REFERENCE]);
-#[derive(Default)]
-pub struct NeedlessBorrow {
-    /// The body the first local was found in. Used to emit lints when the traversal of the body has
-    /// been finished. Note we can't lint at the end of every body as they can be nested within each
-    /// other.
-    current_body: Option<BodyId>,
-    /// The list of locals currently being checked by the lint.
-    /// If the value is `None`, then the binding has been seen as a ref pattern, but is not linted.
-    /// This is needed for or patterns where one of the branches can be linted, but another can not
-    /// be.
-    ///
-    /// e.g. `m!(x) | Foo::Bar(ref x)`
-    ref_locals: FxIndexMap<HirId, Option<RefPat>>,
-}
-
-struct RefPat {
-    /// Whether every usage of the binding is dereferenced.
-    always_deref: bool,
-    /// The spans of all the ref bindings for this local.
-    spans: Vec<Span>,
-    /// The applicability of this suggestion.
-    app: Applicability,
-    /// All the replacements which need to be made.
-    replacements: Vec<(Span, String)>,
-}
-
-impl<'tcx> LateLintPass<'tcx> for NeedlessBorrow {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
-        if let Some(local) = path_to_local(e) {
-            self.check_local_usage(cx, e, local);
-        }
-
-        if e.span.from_expansion() {
-            return;
-        }
-        if let ExprKind::AddrOf(BorrowKind::Ref, mutability, inner) = e.kind {
-            if let ty::Ref(_, ty, _) = cx.typeck_results().expr_ty(inner).kind() {
-                for adj3 in cx.typeck_results().expr_adjustments(e).windows(3) {
-                    if let [
-                        Adjustment {
-                            kind: Adjust::Deref(_), ..
-                        },
-                        Adjustment {
-                            kind: Adjust::Deref(_), ..
-                        },
-                        Adjustment {
-                            kind: Adjust::Borrow(_),
-                            ..
-                        },
-                    ] = *adj3
-                    {
-                        let help_msg_ty = if matches!(mutability, Mutability::Not) {
-                            format!("&{}", ty)
-                        } else {
-                            format!("&mut {}", ty)
-                        };
-
-                        span_lint_and_then(
-                            cx,
-                            NEEDLESS_BORROW,
-                            e.span,
-                            &format!(
-                                "this expression borrows a reference (`{}`) that is immediately dereferenced \
-                             by the compiler",
-                                help_msg_ty
-                            ),
-                            |diag| {
-                                if let Some(snippet) = snippet_opt(cx, inner.span) {
-                                    diag.span_suggestion(
-                                        e.span,
-                                        "change this to",
-                                        snippet,
-                                        Applicability::MachineApplicable,
-                                    );
-                                }
-                            },
-                        );
-                    }
-                }
-            }
-        }
-    }
-
-    fn check_pat(&mut self, cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>) {
-        if let PatKind::Binding(BindingAnnotation::Ref, id, name, _) = pat.kind {
-            if let Some(opt_prev_pat) = self.ref_locals.get_mut(&id) {
-                // This binding id has been seen before. Add this pattern to the list of changes.
-                if let Some(prev_pat) = opt_prev_pat {
-                    if pat.span.from_expansion() {
-                        // Doesn't match the context of the previous pattern. Can't lint here.
-                        *opt_prev_pat = None;
-                    } else {
-                        prev_pat.spans.push(pat.span);
-                        prev_pat.replacements.push((
-                            pat.span,
-                            snippet_with_context(cx, name.span, pat.span.ctxt(), "..", &mut prev_pat.app)
-                                .0
-                                .into(),
-                        ));
-                    }
-                }
-                return;
-            }
-
-            if_chain! {
-                if !pat.span.from_expansion();
-                if let ty::Ref(_, tam, _) = *cx.typeck_results().pat_ty(pat).kind();
-                // only lint immutable refs, because borrowed `&mut T` cannot be moved out
-                if let ty::Ref(_, _, Mutability::Not) = *tam.kind();
-                then {
-                    let mut app = Applicability::MachineApplicable;
-                    let snip = snippet_with_context(cx, name.span, pat.span.ctxt(), "..", &mut app).0;
-                    self.current_body = self.current_body.or(cx.enclosing_body);
-                    self.ref_locals.insert(
-                        id,
-                        Some(RefPat {
-                            always_deref: true,
-                            spans: vec![pat.span],
-                            app,
-                            replacements: vec![(pat.span, snip.into())],
-                        }),
-                    );
-                }
-            }
-        }
-    }
-
-    fn check_body_post(&mut self, cx: &LateContext<'tcx>, body: &'tcx Body<'_>) {
-        if Some(body.id()) == self.current_body {
-            for pat in self.ref_locals.drain(..).filter_map(|(_, x)| x) {
-                let replacements = pat.replacements;
-                let app = pat.app;
-                span_lint_and_then(
-                    cx,
-                    if pat.always_deref {
-                        NEEDLESS_BORROW
-                    } else {
-                        REF_BINDING_TO_REFERENCE
-                    },
-                    pat.spans,
-                    "this pattern creates a reference to a reference",
-                    |diag| {
-                        diag.multipart_suggestion("try this", replacements, app);
-                    },
-                );
-            }
-            self.current_body = None;
-        }
-    }
-}
-impl NeedlessBorrow {
-    fn check_local_usage(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>, local: HirId) {
-        if let Some(outer_pat) = self.ref_locals.get_mut(&local) {
-            if let Some(pat) = outer_pat {
-                // Check for auto-deref
-                if !matches!(
-                    cx.typeck_results().expr_adjustments(e),
-                    [
-                        Adjustment {
-                            kind: Adjust::Deref(_),
-                            ..
-                        },
-                        Adjustment {
-                            kind: Adjust::Deref(_),
-                            ..
-                        },
-                        ..
-                    ]
-                ) {
-                    match get_parent_expr(cx, e) {
-                        // Field accesses are the same no matter the number of references.
-                        Some(Expr {
-                            kind: ExprKind::Field(..),
-                            ..
-                        }) => (),
-                        Some(&Expr {
-                            span,
-                            kind: ExprKind::Unary(UnOp::Deref, _),
-                            ..
-                        }) if !span.from_expansion() => {
-                            // Remove explicit deref.
-                            let snip = snippet_with_context(cx, e.span, span.ctxt(), "..", &mut pat.app).0;
-                            pat.replacements.push((span, snip.into()));
-                        },
-                        Some(parent) if !parent.span.from_expansion() => {
-                            // Double reference might be needed at this point.
-                            if parent.precedence().order() == PREC_POSTFIX {
-                                // Parentheses would be needed here, don't lint.
-                                *outer_pat = None;
-                            } else {
-                                pat.always_deref = false;
-                                let snip = snippet_with_context(cx, e.span, parent.span.ctxt(), "..", &mut pat.app).0;
-                                pat.replacements.push((e.span, format!("&{}", snip)));
-                            }
-                        },
-                        _ if !e.span.from_expansion() => {
-                            // Double reference might be needed at this point.
-                            pat.always_deref = false;
-                            let snip = snippet_with_applicability(cx, e.span, "..", &mut pat.app);
-                            pat.replacements.push((e.span, format!("&{}", snip)));
-                        },
-                        // Edge case for macros. The span of the identifier will usually match the context of the
-                        // binding, but not if the identifier was created in a macro. e.g. `concat_idents` and proc
-                        // macros
-                        _ => *outer_pat = None,
-                    }
-                }
-            }
-        }
-    }
-}
diff --git a/tests/ui/needless_borrow.fixed b/tests/ui/needless_borrow.fixed
index 42c2bb9f414..9e37fb92559 100644
--- a/tests/ui/needless_borrow.fixed
+++ b/tests/ui/needless_borrow.fixed
@@ -1,9 +1,10 @@
 // run-rustfix
 
 #[warn(clippy::all, clippy::needless_borrow)]
-#[allow(unused_variables)]
+#[allow(unused_variables, clippy::unnecessary_mut_passed)]
 fn main() {
     let a = 5;
+    let ref_a = &a;
     let _ = x(&a); // no warning
     let _ = x(&a); // warn
 
@@ -21,11 +22,29 @@ fn main() {
         44 => &a,
         45 => {
             println!("foo");
-            &&a // FIXME: this should lint, too
+            &a
         },
         46 => &a,
+        47 => {
+            println!("foo");
+            loop {
+                println!("{}", a);
+                if a == 25 {
+                    break ref_a;
+                }
+            }
+        },
         _ => panic!(),
     };
+
+    let _ = x(&a);
+    let _ = x(&a);
+    let _ = x(&mut b);
+    let _ = x(ref_a);
+    {
+        let b = &mut b;
+        x(b);
+    }
 }
 
 #[allow(clippy::needless_borrowed_reference)]
diff --git a/tests/ui/needless_borrow.rs b/tests/ui/needless_borrow.rs
index 31977416bc7..093277784be 100644
--- a/tests/ui/needless_borrow.rs
+++ b/tests/ui/needless_borrow.rs
@@ -1,9 +1,10 @@
 // run-rustfix
 
 #[warn(clippy::all, clippy::needless_borrow)]
-#[allow(unused_variables)]
+#[allow(unused_variables, clippy::unnecessary_mut_passed)]
 fn main() {
     let a = 5;
+    let ref_a = &a;
     let _ = x(&a); // no warning
     let _ = x(&&a); // warn
 
@@ -21,11 +22,29 @@ fn main() {
         44 => &a,
         45 => {
             println!("foo");
-            &&a // FIXME: this should lint, too
+            &&a
         },
         46 => &&a,
+        47 => {
+            println!("foo");
+            loop {
+                println!("{}", a);
+                if a == 25 {
+                    break &ref_a;
+                }
+            }
+        },
         _ => panic!(),
     };
+
+    let _ = x(&&&a);
+    let _ = x(&mut &&a);
+    let _ = x(&&&mut b);
+    let _ = x(&&ref_a);
+    {
+        let b = &mut b;
+        x(&b);
+    }
 }
 
 #[allow(clippy::needless_borrowed_reference)]
diff --git a/tests/ui/needless_borrow.stderr b/tests/ui/needless_borrow.stderr
index 012d62e2871..03a5b3d260e 100644
--- a/tests/ui/needless_borrow.stderr
+++ b/tests/ui/needless_borrow.stderr
@@ -1,5 +1,5 @@
 error: this expression borrows a reference (`&i32`) that is immediately dereferenced by the compiler
-  --> $DIR/needless_borrow.rs:8:15
+  --> $DIR/needless_borrow.rs:9:15
    |
 LL |     let _ = x(&&a); // warn
    |               ^^^ help: change this to: `&a`
@@ -7,16 +7,58 @@ LL |     let _ = x(&&a); // warn
    = note: `-D clippy::needless-borrow` implied by `-D warnings`
 
 error: this expression borrows a reference (`&mut i32`) that is immediately dereferenced by the compiler
-  --> $DIR/needless_borrow.rs:12:13
+  --> $DIR/needless_borrow.rs:13:13
    |
 LL |     mut_ref(&mut &mut b); // warn
    |             ^^^^^^^^^^^ help: change this to: `&mut b`
 
 error: this expression borrows a reference (`&i32`) that is immediately dereferenced by the compiler
-  --> $DIR/needless_borrow.rs:26:15
+  --> $DIR/needless_borrow.rs:25:13
+   |
+LL |             &&a
+   |             ^^^ help: change this to: `&a`
+
+error: this expression borrows a reference (`&i32`) that is immediately dereferenced by the compiler
+  --> $DIR/needless_borrow.rs:27:15
    |
 LL |         46 => &&a,
    |               ^^^ help: change this to: `&a`
 
-error: aborting due to 3 previous errors
+error: this expression borrows a reference (`&i32`) that is immediately dereferenced by the compiler
+  --> $DIR/needless_borrow.rs:33:27
+   |
+LL |                     break &ref_a;
+   |                           ^^^^^^ help: change this to: `ref_a`
+
+error: this expression borrows a reference (`&i32`) that is immediately dereferenced by the compiler
+  --> $DIR/needless_borrow.rs:40:15
+   |
+LL |     let _ = x(&&&a);
+   |               ^^^^ help: change this to: `&a`
+
+error: this expression borrows a reference (`&i32`) that is immediately dereferenced by the compiler
+  --> $DIR/needless_borrow.rs:41:15
+   |
+LL |     let _ = x(&mut &&a);
+   |               ^^^^^^^^ help: change this to: `&a`
+
+error: this expression borrows a reference (`&mut i32`) that is immediately dereferenced by the compiler
+  --> $DIR/needless_borrow.rs:42:15
+   |
+LL |     let _ = x(&&&mut b);
+   |               ^^^^^^^^ help: change this to: `&mut b`
+
+error: this expression borrows a reference (`&i32`) that is immediately dereferenced by the compiler
+  --> $DIR/needless_borrow.rs:43:15
+   |
+LL |     let _ = x(&&ref_a);
+   |               ^^^^^^^ help: change this to: `ref_a`
+
+error: this expression borrows a reference (`&mut i32`) that is immediately dereferenced by the compiler
+  --> $DIR/needless_borrow.rs:46:11
+   |
+LL |         x(&b);
+   |           ^^ help: change this to: `b`
+
+error: aborting due to 10 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 2938ffd0d94d93893ca32202cb3b6a6b69559bfb Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Tue, 17 Aug 2021 16:22:48 -0400
Subject: Improve heuristics for determining whether eager of lazy evaluation
 is preferred

---
 clippy_lints/src/functions/too_many_lines.rs       |   4 +-
 .../src/methods/from_iter_instead_of_collect.rs    |   2 +-
 clippy_lints/src/methods/or_fun_call.rs            |  59 ++--
 clippy_lints/src/methods/unnecessary_lazy_eval.rs  |   2 +-
 clippy_lints/src/option_if_let_else.rs             |   6 +-
 clippy_utils/src/eager_or_lazy.rs                  | 307 ++++++++++++++-------
 clippy_utils/src/paths.rs                          |   1 +
 clippy_utils/src/ty.rs                             |  21 +-
 clippy_utils/src/visitors.rs                       |  94 ++++++-
 tests/ui/needless_return.fixed                     |   1 +
 tests/ui/needless_return.rs                        |   1 +
 tests/ui/needless_return.stderr                    |  36 +--
 tests/ui/option_if_let_else.fixed                  |   2 +-
 tests/ui/option_if_let_else.stderr                 |   4 +-
 tests/ui/or_fun_call.fixed                         |  30 +-
 tests/ui/or_fun_call.rs                            |  18 +-
 tests/ui/or_fun_call.stderr                        |  60 +---
 17 files changed, 408 insertions(+), 240 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/functions/too_many_lines.rs b/clippy_lints/src/functions/too_many_lines.rs
index 008ef661b55..65efbbab41a 100644
--- a/clippy_lints/src/functions/too_many_lines.rs
+++ b/clippy_lints/src/functions/too_many_lines.rs
@@ -56,8 +56,8 @@ pub(super) fn check_fn(
                     continue;
                 }
             } else {
-                let multi_idx = line.find("/*").unwrap_or_else(|| line.len());
-                let single_idx = line.find("//").unwrap_or_else(|| line.len());
+                let multi_idx = line.find("/*").unwrap_or(line.len());
+                let single_idx = line.find("//").unwrap_or(line.len());
                 code_in_line |= multi_idx > 0 && single_idx > 0;
                 // Implies multi_idx is below line.len()
                 if multi_idx < single_idx {
diff --git a/clippy_lints/src/methods/from_iter_instead_of_collect.rs b/clippy_lints/src/methods/from_iter_instead_of_collect.rs
index 99c03844f49..8ea9312c0f7 100644
--- a/clippy_lints/src/methods/from_iter_instead_of_collect.rs
+++ b/clippy_lints/src/methods/from_iter_instead_of_collect.rs
@@ -69,7 +69,7 @@ fn extract_turbofish(cx: &LateContext<'_>, expr: &hir::Expr<'_>, ty: Ty<'tcx>) -
                         // i.e.: 2 wildcards in `std::collections::BTreeMap<&i32, &char>`
                         let ty_str = ty.to_string();
                         let start = ty_str.find('<').unwrap_or(0);
-                        let end = ty_str.find('>').unwrap_or_else(|| ty_str.len());
+                        let end = ty_str.find('>').unwrap_or(ty_str.len());
                         let nb_wildcard = ty_str[start..end].split(',').count();
                         let wildcards = format!("_{}", ", _".repeat(nb_wildcard - 1));
                         format!("{}<{}>", elements.join("::"), wildcards)
diff --git a/clippy_lints/src/methods/or_fun_call.rs b/clippy_lints/src/methods/or_fun_call.rs
index fe9ffde0d33..4e4653dadca 100644
--- a/clippy_lints/src/methods/or_fun_call.rs
+++ b/clippy_lints/src/methods/or_fun_call.rs
@@ -1,16 +1,12 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::eager_or_lazy::is_lazyness_candidate;
-use clippy_utils::is_trait_item;
+use clippy_utils::eager_or_lazy::switch_to_lazy_eval;
 use clippy_utils::source::{snippet, snippet_with_applicability, snippet_with_macro_callsite};
-use clippy_utils::ty::implements_trait;
-use clippy_utils::ty::{is_type_diagnostic_item, match_type};
-use clippy_utils::{contains_return, last_path_segment, paths};
+use clippy_utils::ty::{implements_trait, match_type};
+use clippy_utils::{contains_return, is_trait_item, last_path_segment, paths};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
-use rustc_hir::{BlockCheckMode, UnsafeSource};
 use rustc_lint::LateContext;
-use rustc_middle::ty;
 use rustc_span::source_map::Span;
 use rustc_span::symbol::{kw, sym};
 use std::borrow::Cow;
@@ -96,25 +92,10 @@ pub(super) fn check<'tcx>(
             (&paths::RESULT, true, &["or", "unwrap_or"], "else"),
         ];
 
-        if let hir::ExprKind::MethodCall(path, _, [self_arg, ..], _) = &arg.kind {
-            if path.ident.name == sym::len {
-                let ty = cx.typeck_results().expr_ty(self_arg).peel_refs();
-
-                match ty.kind() {
-                    ty::Slice(_) | ty::Array(_, _) | ty::Str => return,
-                    _ => (),
-                }
-
-                if is_type_diagnostic_item(cx, ty, sym::Vec) {
-                    return;
-                }
-            }
-        }
-
         if_chain! {
             if KNOW_TYPES.iter().any(|k| k.2.contains(&name));
 
-            if is_lazyness_candidate(cx, arg);
+            if switch_to_lazy_eval(cx, arg);
             if !contains_return(arg);
 
             let self_ty = cx.typeck_results().expr_ty(self_expr);
@@ -166,26 +147,30 @@ pub(super) fn check<'tcx>(
         }
     }
 
-    if args.len() == 2 {
-        match args[1].kind {
+    if let [self_arg, arg] = args {
+        let inner_arg = if let hir::ExprKind::Block(
+            hir::Block {
+                stmts: [],
+                expr: Some(expr),
+                ..
+            },
+            _,
+        ) = arg.kind
+        {
+            expr
+        } else {
+            arg
+        };
+        match inner_arg.kind {
             hir::ExprKind::Call(fun, or_args) => {
                 let or_has_args = !or_args.is_empty();
-                if !check_unwrap_or_default(cx, name, fun, &args[0], &args[1], or_has_args, expr.span) {
+                if !check_unwrap_or_default(cx, name, fun, self_arg, arg, or_has_args, expr.span) {
                     let fun_span = if or_has_args { None } else { Some(fun.span) };
-                    check_general_case(cx, name, method_span, &args[0], &args[1], expr.span, fun_span);
+                    check_general_case(cx, name, method_span, self_arg, arg, expr.span, fun_span);
                 }
             },
             hir::ExprKind::Index(..) | hir::ExprKind::MethodCall(..) => {
-                check_general_case(cx, name, method_span, &args[0], &args[1], expr.span, None);
-            },
-            hir::ExprKind::Block(block, _)
-                if block.rules == BlockCheckMode::UnsafeBlock(UnsafeSource::UserProvided) =>
-            {
-                if let Some(block_expr) = block.expr {
-                    if let hir::ExprKind::MethodCall(..) = block_expr.kind {
-                        check_general_case(cx, name, method_span, &args[0], &args[1], expr.span, None);
-                    }
-                }
+                check_general_case(cx, name, method_span, self_arg, arg, expr.span, None);
             },
             _ => (),
         }
diff --git a/clippy_lints/src/methods/unnecessary_lazy_eval.rs b/clippy_lints/src/methods/unnecessary_lazy_eval.rs
index 740af750b48..1e2765263c8 100644
--- a/clippy_lints/src/methods/unnecessary_lazy_eval.rs
+++ b/clippy_lints/src/methods/unnecessary_lazy_eval.rs
@@ -30,7 +30,7 @@ pub(super) fn check<'tcx>(
                 return;
             }
 
-            if eager_or_lazy::is_eagerness_candidate(cx, body_expr) {
+            if eager_or_lazy::switch_to_eager_eval(cx, body_expr) {
                 let msg = if is_option {
                     "unnecessary closure used to substitute value for `Option::None`"
                 } else {
diff --git a/clippy_lints/src/option_if_let_else.rs b/clippy_lints/src/option_if_let_else.rs
index f7c19baf7f9..262be17f617 100644
--- a/clippy_lints/src/option_if_let_else.rs
+++ b/clippy_lints/src/option_if_let_else.rs
@@ -147,11 +147,7 @@ fn detect_option_if_let_else<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>) ->
             let capture_mut = if bind_annotation == &BindingAnnotation::Mutable { "mut " } else { "" };
             let some_body = extract_body_from_expr(if_then)?;
             let none_body = extract_body_from_expr(if_else)?;
-            let method_sugg = if eager_or_lazy::is_eagerness_candidate(cx, none_body) {
-                "map_or"
-            } else {
-                "map_or_else"
-            };
+            let method_sugg = if eager_or_lazy::switch_to_eager_eval(cx, none_body) { "map_or" } else { "map_or_else" };
             let capture_name = id.name.to_ident_string();
             let (as_ref, as_mut) = match &let_expr.kind {
                 ExprKind::AddrOf(_, Mutability::Not, _) => (true, false),
diff --git a/clippy_utils/src/eager_or_lazy.rs b/clippy_utils/src/eager_or_lazy.rs
index 1ea7ccfb752..c2645ac730a 100644
--- a/clippy_utils/src/eager_or_lazy.rs
+++ b/clippy_utils/src/eager_or_lazy.rs
@@ -9,128 +9,227 @@
 //!  - or-fun-call
 //!  - option-if-let-else
 
-use crate::is_ctor_or_promotable_const_function;
-use crate::ty::is_type_diagnostic_item;
+use crate::ty::{all_predicates_of, is_copy};
+use crate::visitors::is_const_evaluatable;
 use rustc_hir::def::{DefKind, Res};
-
-use rustc_hir::intravisit;
-use rustc_hir::intravisit::{NestedVisitorMap, Visitor};
-
-use rustc_hir::{Block, Expr, ExprKind, Path, QPath};
+use rustc_hir::intravisit::{walk_expr, ErasedMap, NestedVisitorMap, Visitor};
+use rustc_hir::{def_id::DefId, Block, Expr, ExprKind, QPath, UnOp};
 use rustc_lint::LateContext;
-use rustc_middle::hir::map::Map;
-use rustc_span::sym;
-
-/// Is the expr pure (is it free from side-effects)?
-/// This function is named so to stress that it isn't exhaustive and returns FNs.
-fn identify_some_pure_patterns(expr: &Expr<'_>) -> bool {
-    match expr.kind {
-        ExprKind::Lit(..) | ExprKind::ConstBlock(..) | ExprKind::Path(..) | ExprKind::Field(..) => true,
-        ExprKind::AddrOf(_, _, addr_of_expr) => identify_some_pure_patterns(addr_of_expr),
-        ExprKind::Tup(tup_exprs) => tup_exprs.iter().all(identify_some_pure_patterns),
-        ExprKind::Struct(_, fields, expr) => {
-            fields.iter().all(|f| identify_some_pure_patterns(f.expr)) && expr.map_or(true, identify_some_pure_patterns)
-        },
-        ExprKind::Call(
-            &Expr {
-                kind:
-                    ExprKind::Path(QPath::Resolved(
-                        _,
-                        Path {
-                            res: Res::Def(DefKind::Ctor(..) | DefKind::Variant, ..),
-                            ..
-                        },
-                    )),
-                ..
-            },
-            args,
-        ) => args.iter().all(identify_some_pure_patterns),
-        ExprKind::Block(
-            &Block {
-                stmts,
-                expr: Some(expr),
-                ..
-            },
-            _,
-        ) => stmts.is_empty() && identify_some_pure_patterns(expr),
-        ExprKind::Box(..)
-        | ExprKind::Array(..)
-        | ExprKind::Call(..)
-        | ExprKind::MethodCall(..)
-        | ExprKind::Binary(..)
-        | ExprKind::Unary(..)
-        | ExprKind::Let(..)
-        | ExprKind::Cast(..)
-        | ExprKind::Type(..)
-        | ExprKind::DropTemps(..)
-        | ExprKind::Loop(..)
-        | ExprKind::If(..)
-        | ExprKind::Match(..)
-        | ExprKind::Closure(..)
-        | ExprKind::Block(..)
-        | ExprKind::Assign(..)
-        | ExprKind::AssignOp(..)
-        | ExprKind::Index(..)
-        | ExprKind::Break(..)
-        | ExprKind::Continue(..)
-        | ExprKind::Ret(..)
-        | ExprKind::InlineAsm(..)
-        | ExprKind::LlvmInlineAsm(..)
-        | ExprKind::Repeat(..)
-        | ExprKind::Yield(..)
-        | ExprKind::Err => false,
+use rustc_middle::ty::{self, PredicateKind};
+use rustc_span::{sym, Symbol};
+use std::cmp;
+use std::ops;
+
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+enum EagernessSuggestion {
+    // The expression is cheap and should be evaluated eagerly
+    Eager,
+    // The expression may be cheap, so don't suggested lazy evaluation; or the expression may not be safe to switch to
+    // eager evaluation.
+    NoChange,
+    // The expression is likely expensive and should be evaluated lazily.
+    Lazy,
+    // The expression cannot be placed into a closure.
+    ForceNoChange,
+}
+impl ops::BitOr for EagernessSuggestion {
+    type Output = Self;
+    fn bitor(self, rhs: Self) -> Self {
+        cmp::max(self, rhs)
     }
 }
-
-/// Identify some potentially computationally expensive patterns.
-/// This function is named so to stress that its implementation is non-exhaustive.
-/// It returns FNs and FPs.
-fn identify_some_potentially_expensive_patterns<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
-    // Searches an expression for method calls or function calls that aren't ctors
-    struct FunCallFinder<'a, 'tcx> {
-        cx: &'a LateContext<'tcx>,
-        found: bool,
+impl ops::BitOrAssign for EagernessSuggestion {
+    fn bitor_assign(&mut self, rhs: Self) {
+        *self = *self | rhs;
     }
+}
 
-    impl<'a, 'tcx> intravisit::Visitor<'tcx> for FunCallFinder<'a, 'tcx> {
-        type Map = Map<'tcx>;
-
-        fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) {
-            let call_found = match &expr.kind {
-                // ignore enum and struct constructors
-                ExprKind::Call(..) => !is_ctor_or_promotable_const_function(self.cx, expr),
-                ExprKind::Index(obj, _) => {
-                    let ty = self.cx.typeck_results().expr_ty(obj);
-                    is_type_diagnostic_item(self.cx, ty, sym::HashMap)
-                        || is_type_diagnostic_item(self.cx, ty, sym::BTreeMap)
-                },
-                ExprKind::MethodCall(..) => true,
-                _ => false,
-            };
+/// Determine the eagerness of the given function call.
+fn fn_eagerness(cx: &LateContext<'tcx>, fn_id: DefId, name: Symbol, args: &'tcx [Expr<'_>]) -> EagernessSuggestion {
+    use EagernessSuggestion::{Eager, Lazy, NoChange};
+    let name = &*name.as_str();
 
-            if call_found {
-                self.found |= true;
-            }
+    let ty = match cx.tcx.impl_of_method(fn_id) {
+        Some(id) => cx.tcx.type_of(id),
+        None => return Lazy,
+    };
 
-            if !self.found {
-                intravisit::walk_expr(self, expr);
+    if (name.starts_with("as_") || name == "len" || name == "is_empty") && args.len() == 1 {
+        if matches!(
+            cx.tcx.crate_name(fn_id.krate),
+            sym::std | sym::core | sym::alloc | sym::proc_macro
+        ) {
+            Eager
+        } else {
+            NoChange
+        }
+    } else if let ty::Adt(def, subs) = ty.kind() {
+        // Types where the only fields are generic types (or references to) with no trait bounds other
+        // than marker traits.
+        // Due to the limited operations on these types functions should be fairly cheap.
+        if def
+            .variants
+            .iter()
+            .flat_map(|v| v.fields.iter())
+            .any(|x| matches!(cx.tcx.type_of(x.did).peel_refs().kind(), ty::Param(_)))
+            && all_predicates_of(cx.tcx, fn_id).all(|(pred, _)| match pred.kind().skip_binder() {
+                PredicateKind::Trait(pred) => cx.tcx.trait_def(pred.trait_ref.def_id).is_marker,
+                _ => true,
+            })
+            && subs.types().all(|x| matches!(x.peel_refs().kind(), ty::Param(_)))
+        {
+            // Limit the function to either `(self) -> bool` or `(&self) -> bool`
+            match &**cx.tcx.fn_sig(fn_id).skip_binder().inputs_and_output {
+                [arg, res] if !arg.is_mutable_ptr() && arg.peel_refs() == ty && res.is_bool() => NoChange,
+                _ => Lazy,
             }
+        } else {
+            Lazy
         }
+    } else {
+        Lazy
+    }
+}
 
+#[allow(clippy::too_many_lines)]
+fn expr_eagerness(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> EagernessSuggestion {
+    struct V<'cx, 'tcx> {
+        cx: &'cx LateContext<'tcx>,
+        eagerness: EagernessSuggestion,
+    }
+
+    impl<'cx, 'tcx> Visitor<'tcx> for V<'cx, 'tcx> {
+        type Map = ErasedMap<'tcx>;
         fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
             NestedVisitorMap::None
         }
+
+        fn visit_expr(&mut self, e: &'tcx Expr<'_>) {
+            use EagernessSuggestion::{ForceNoChange, Lazy, NoChange};
+            if self.eagerness == ForceNoChange {
+                return;
+            }
+            match e.kind {
+                ExprKind::Call(
+                    &Expr {
+                        kind: ExprKind::Path(ref path),
+                        hir_id,
+                        ..
+                    },
+                    args,
+                ) => match self.cx.qpath_res(path, hir_id) {
+                    Res::Def(DefKind::Ctor(..) | DefKind::Variant, _) | Res::SelfCtor(_) => (),
+                    Res::Def(_, id) if self.cx.tcx.is_promotable_const_fn(id) => (),
+                    // No need to walk the arguments here, `is_const_evaluatable` already did
+                    Res::Def(..) if is_const_evaluatable(self.cx, e) => {
+                        self.eagerness |= NoChange;
+                        return;
+                    },
+                    Res::Def(_, id) => match path {
+                        QPath::Resolved(_, p) => {
+                            self.eagerness |= fn_eagerness(self.cx, id, p.segments.last().unwrap().ident.name, args);
+                        },
+                        QPath::TypeRelative(_, name) => {
+                            self.eagerness |= fn_eagerness(self.cx, id, name.ident.name, args);
+                        },
+                        QPath::LangItem(..) => self.eagerness = Lazy,
+                    },
+                    _ => self.eagerness = Lazy,
+                },
+                // No need to walk the arguments here, `is_const_evaluatable` already did
+                ExprKind::MethodCall(..) if is_const_evaluatable(self.cx, e) => {
+                    self.eagerness |= NoChange;
+                    return;
+                },
+                ExprKind::MethodCall(name, _, args, _) => {
+                    self.eagerness |= self
+                        .cx
+                        .typeck_results()
+                        .type_dependent_def_id(e.hir_id)
+                        .map_or(Lazy, |id| fn_eagerness(self.cx, id, name.ident.name, args));
+                },
+                ExprKind::Index(_, e) => {
+                    let ty = self.cx.typeck_results().expr_ty_adjusted(e);
+                    if is_copy(self.cx, ty) && !ty.is_ref() {
+                        self.eagerness |= NoChange;
+                    } else {
+                        self.eagerness = Lazy;
+                    }
+                },
+
+                // Dereferences should be cheap, but dereferencing a raw pointer earlier may not be safe.
+                ExprKind::Unary(UnOp::Deref, e) if !self.cx.typeck_results().expr_ty(e).is_unsafe_ptr() => (),
+                ExprKind::Unary(UnOp::Deref, _) => self.eagerness |= NoChange,
+
+                ExprKind::Unary(_, e)
+                    if matches!(
+                        self.cx.typeck_results().expr_ty(e).kind(),
+                        ty::Bool | ty::Int(_) | ty::Uint(_),
+                    ) => {},
+                ExprKind::Binary(_, lhs, rhs)
+                    if self.cx.typeck_results().expr_ty(lhs).is_primitive()
+                        && self.cx.typeck_results().expr_ty(rhs).is_primitive() => {},
+
+                // Can't be moved into a closure
+                ExprKind::Break(..)
+                | ExprKind::Continue(_)
+                | ExprKind::Ret(_)
+                | ExprKind::InlineAsm(_)
+                | ExprKind::LlvmInlineAsm(_)
+                | ExprKind::Yield(..)
+                | ExprKind::Err => {
+                    self.eagerness = ForceNoChange;
+                    return;
+                },
+
+                // Memory allocation, custom operator, loop, or call to an unknown function
+                ExprKind::Box(_)
+                | ExprKind::Unary(..)
+                | ExprKind::Binary(..)
+                | ExprKind::Loop(..)
+                | ExprKind::Call(..) => self.eagerness = Lazy,
+
+                ExprKind::ConstBlock(_)
+                | ExprKind::Array(_)
+                | ExprKind::Tup(_)
+                | ExprKind::Lit(_)
+                | ExprKind::Cast(..)
+                | ExprKind::Type(..)
+                | ExprKind::DropTemps(_)
+                | ExprKind::Let(..)
+                | ExprKind::If(..)
+                | ExprKind::Match(..)
+                | ExprKind::Closure(..)
+                | ExprKind::Field(..)
+                | ExprKind::Path(_)
+                | ExprKind::AddrOf(..)
+                | ExprKind::Struct(..)
+                | ExprKind::Repeat(..)
+                | ExprKind::Block(Block { stmts: [], .. }, _) => (),
+
+                // Assignment might be to a local defined earlier, so don't eagerly evaluate.
+                // Blocks with multiple statements might be expensive, so don't eagerly evaluate.
+                // TODO: Actually check if either of these are true here.
+                ExprKind::Assign(..) | ExprKind::AssignOp(..) | ExprKind::Block(..) => self.eagerness |= NoChange,
+            }
+            walk_expr(self, e);
+        }
     }
 
-    let mut finder = FunCallFinder { cx, found: false };
-    finder.visit_expr(expr);
-    finder.found
+    let mut v = V {
+        cx,
+        eagerness: EagernessSuggestion::Eager,
+    };
+    v.visit_expr(e);
+    v.eagerness
 }
 
-pub fn is_eagerness_candidate<'a, 'tcx>(cx: &'a LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
-    !identify_some_potentially_expensive_patterns(cx, expr) && identify_some_pure_patterns(expr)
+/// Whether the given expression should be changed to evaluate eagerly
+pub fn switch_to_eager_eval(cx: &'_ LateContext<'tcx>, expr: &'tcx Expr<'_>) -> bool {
+    expr_eagerness(cx, expr) == EagernessSuggestion::Eager
 }
 
-pub fn is_lazyness_candidate<'a, 'tcx>(cx: &'a LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
-    identify_some_potentially_expensive_patterns(cx, expr)
+/// Whether the given expression should be changed to evaluate lazily
+pub fn switch_to_lazy_eval(cx: &'_ LateContext<'tcx>, expr: &'tcx Expr<'_>) -> bool {
+    expr_eagerness(cx, expr) == EagernessSuggestion::Lazy
 }
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index 480923bbb02..b04d1736426 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -28,6 +28,7 @@ pub const ASREF_TRAIT: [&str; 3] = ["core", "convert", "AsRef"];
 pub(super) const BEGIN_PANIC: [&str; 3] = ["std", "panicking", "begin_panic"];
 /// Preferably use the diagnostic item `sym::Borrow` where possible
 pub const BORROW_TRAIT: [&str; 3] = ["core", "borrow", "Borrow"];
+pub const BORROW_MUT_TRAIT: [&str; 3] = ["core", "borrow", "BorrowMut"];
 pub const BTREEMAP_CONTAINS_KEY: [&str; 6] = ["alloc", "collections", "btree", "map", "BTreeMap", "contains_key"];
 pub const BTREEMAP_ENTRY: [&str; 6] = ["alloc", "collections", "btree", "map", "entry", "Entry"];
 pub const BTREEMAP_INSERT: [&str; 6] = ["alloc", "collections", "btree", "map", "BTreeMap", "insert"];
diff --git a/clippy_utils/src/ty.rs b/clippy_utils/src/ty.rs
index babab07ea9f..438c39bea0a 100644
--- a/clippy_utils/src/ty.rs
+++ b/clippy_utils/src/ty.rs
@@ -10,12 +10,12 @@ use rustc_hir::{TyKind, Unsafety};
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::LateContext;
 use rustc_middle::ty::subst::{GenericArg, GenericArgKind};
-use rustc_middle::ty::{self, AdtDef, IntTy, Ty, TyCtxt, TypeFoldable, UintTy};
-use rustc_span::sym;
-use rustc_span::symbol::{Ident, Symbol};
-use rustc_span::DUMMY_SP;
+use rustc_middle::ty::{self, AdtDef, IntTy, Predicate, Ty, TyCtxt, TypeFoldable, UintTy};
+use rustc_span::symbol::Ident;
+use rustc_span::{sym, Span, Symbol, DUMMY_SP};
 use rustc_trait_selection::infer::InferCtxtExt;
 use rustc_trait_selection::traits::query::normalize::AtExt;
+use std::iter;
 
 use crate::{match_def_path, must_use_attr};
 
@@ -391,3 +391,16 @@ pub fn is_uninit_value_valid_for_ty(cx: &LateContext<'_>, ty: Ty<'_>) -> bool {
         _ => false,
     }
 }
+
+/// Gets an iterator over all predicates which apply to the given item.
+pub fn all_predicates_of(tcx: TyCtxt<'_>, id: DefId) -> impl Iterator<Item = &(Predicate<'_>, Span)> {
+    let mut next_id = Some(id);
+    iter::from_fn(move || {
+        next_id.take().map(|id| {
+            let preds = tcx.predicates_of(id);
+            next_id = preds.parent;
+            preds.predicates.iter()
+        })
+    })
+    .flatten()
+}
diff --git a/clippy_utils/src/visitors.rs b/clippy_utils/src/visitors.rs
index 988f6cf1d51..823df5cb751 100644
--- a/clippy_utils/src/visitors.rs
+++ b/clippy_utils/src/visitors.rs
@@ -1,9 +1,11 @@
 use crate::path_to_local_id;
 use rustc_hir as hir;
+use rustc_hir::def::{DefKind, Res};
 use rustc_hir::intravisit::{self, walk_expr, NestedVisitorMap, Visitor};
-use rustc_hir::{def::Res, Arm, Block, Body, BodyId, Expr, ExprKind, HirId, Stmt};
+use rustc_hir::{Arm, Block, Body, BodyId, Expr, ExprKind, HirId, Stmt, UnOp};
 use rustc_lint::LateContext;
 use rustc_middle::hir::map::Map;
+use rustc_middle::ty;
 
 /// Convenience method for creating a `Visitor` with just `visit_expr` overridden and nested
 /// bodies (i.e. closures) are visited.
@@ -225,3 +227,93 @@ pub fn is_local_used(cx: &LateContext<'tcx>, visitable: impl Visitable<'tcx>, id
     drop(visitor);
     is_used
 }
+
+/// Checks if the given expression is a constant.
+pub fn is_const_evaluatable(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> bool {
+    struct V<'a, 'tcx> {
+        cx: &'a LateContext<'tcx>,
+        is_const: bool,
+    }
+    impl<'tcx> Visitor<'tcx> for V<'_, 'tcx> {
+        type Map = Map<'tcx>;
+        fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+            NestedVisitorMap::OnlyBodies(self.cx.tcx.hir())
+        }
+
+        fn visit_expr(&mut self, e: &'tcx Expr<'_>) {
+            if !self.is_const {
+                return;
+            }
+            match e.kind {
+                ExprKind::ConstBlock(_) => return,
+                ExprKind::Call(
+                    &Expr {
+                        kind: ExprKind::Path(ref p),
+                        hir_id,
+                        ..
+                    },
+                    _,
+                ) if self
+                    .cx
+                    .qpath_res(p, hir_id)
+                    .opt_def_id()
+                    .map_or(false, |id| self.cx.tcx.is_const_fn_raw(id)) => {},
+                ExprKind::MethodCall(..)
+                    if self
+                        .cx
+                        .typeck_results()
+                        .type_dependent_def_id(e.hir_id)
+                        .map_or(false, |id| self.cx.tcx.is_const_fn_raw(id)) => {},
+                ExprKind::Binary(_, lhs, rhs)
+                    if self.cx.typeck_results().expr_ty(lhs).peel_refs().is_primitive_ty()
+                        && self.cx.typeck_results().expr_ty(rhs).peel_refs().is_primitive_ty() => {},
+                ExprKind::Unary(UnOp::Deref, e) if self.cx.typeck_results().expr_ty(e).is_ref() => (),
+                ExprKind::Unary(_, e) if self.cx.typeck_results().expr_ty(e).peel_refs().is_primitive_ty() => (),
+                ExprKind::Index(base, _)
+                    if matches!(
+                        self.cx.typeck_results().expr_ty(base).peel_refs().kind(),
+                        ty::Slice(_) | ty::Array(..)
+                    ) => {},
+                ExprKind::Path(ref p)
+                    if matches!(
+                        self.cx.qpath_res(p, e.hir_id),
+                        Res::Def(
+                            DefKind::Const
+                                | DefKind::AssocConst
+                                | DefKind::AnonConst
+                                | DefKind::ConstParam
+                                | DefKind::Ctor(..)
+                                | DefKind::Fn
+                                | DefKind::AssocFn,
+                            _
+                        ) | Res::SelfCtor(_)
+                    ) => {},
+
+                ExprKind::AddrOf(..)
+                | ExprKind::Array(_)
+                | ExprKind::Block(..)
+                | ExprKind::Cast(..)
+                | ExprKind::DropTemps(_)
+                | ExprKind::Field(..)
+                | ExprKind::If(..)
+                | ExprKind::Let(..)
+                | ExprKind::Lit(_)
+                | ExprKind::Match(..)
+                | ExprKind::Repeat(..)
+                | ExprKind::Struct(..)
+                | ExprKind::Tup(_)
+                | ExprKind::Type(..) => (),
+
+                _ => {
+                    self.is_const = false;
+                    return;
+                },
+            }
+            walk_expr(self, e);
+        }
+    }
+
+    let mut v = V { cx, is_const: true };
+    v.visit_expr(e);
+    v.is_const
+}
diff --git a/tests/ui/needless_return.fixed b/tests/ui/needless_return.fixed
index 812ce7163cd..83f467c8400 100644
--- a/tests/ui/needless_return.fixed
+++ b/tests/ui/needless_return.fixed
@@ -108,6 +108,7 @@ fn test_return_in_macro() {
 }
 
 mod issue6501 {
+    #[allow(clippy::unnecessary_lazy_evaluations)]
     fn foo(bar: Result<(), ()>) {
         bar.unwrap_or_else(|_| {})
     }
diff --git a/tests/ui/needless_return.rs b/tests/ui/needless_return.rs
index c42567b517c..341caf18bd6 100644
--- a/tests/ui/needless_return.rs
+++ b/tests/ui/needless_return.rs
@@ -108,6 +108,7 @@ fn test_return_in_macro() {
 }
 
 mod issue6501 {
+    #[allow(clippy::unnecessary_lazy_evaluations)]
     fn foo(bar: Result<(), ()>) {
         bar.unwrap_or_else(|_| return)
     }
diff --git a/tests/ui/needless_return.stderr b/tests/ui/needless_return.stderr
index 74dda971fda..c0abc2c63dd 100644
--- a/tests/ui/needless_return.stderr
+++ b/tests/ui/needless_return.stderr
@@ -85,109 +85,109 @@ LL |         return String::new();
    |         ^^^^^^^^^^^^^^^^^^^^^ help: remove `return`: `String::new()`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:112:32
+  --> $DIR/needless_return.rs:113:32
    |
 LL |         bar.unwrap_or_else(|_| return)
    |                                ^^^^^^ help: replace `return` with an empty block: `{}`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:117:13
+  --> $DIR/needless_return.rs:118:13
    |
 LL |             return;
    |             ^^^^^^^ help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:119:20
+  --> $DIR/needless_return.rs:120:20
    |
 LL |         let _ = || return;
    |                    ^^^^^^ help: replace `return` with an empty block: `{}`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:125:32
+  --> $DIR/needless_return.rs:126:32
    |
 LL |         res.unwrap_or_else(|_| return Foo)
    |                                ^^^^^^^^^^ help: remove `return`: `Foo`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:134:5
+  --> $DIR/needless_return.rs:135:5
    |
 LL |     return true;
    |     ^^^^^^^^^^^^ help: remove `return`: `true`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:138:5
+  --> $DIR/needless_return.rs:139:5
    |
 LL |     return true;
    |     ^^^^^^^^^^^^ help: remove `return`: `true`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:143:9
+  --> $DIR/needless_return.rs:144:9
    |
 LL |         return true;
    |         ^^^^^^^^^^^^ help: remove `return`: `true`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:145:9
+  --> $DIR/needless_return.rs:146:9
    |
 LL |         return false;
    |         ^^^^^^^^^^^^^ help: remove `return`: `false`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:151:17
+  --> $DIR/needless_return.rs:152:17
    |
 LL |         true => return false,
    |                 ^^^^^^^^^^^^ help: remove `return`: `false`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:153:13
+  --> $DIR/needless_return.rs:154:13
    |
 LL |             return true;
    |             ^^^^^^^^^^^^ help: remove `return`: `true`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:160:9
+  --> $DIR/needless_return.rs:161:9
    |
 LL |         return true;
    |         ^^^^^^^^^^^^ help: remove `return`: `true`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:162:16
+  --> $DIR/needless_return.rs:163:16
    |
 LL |     let _ = || return true;
    |                ^^^^^^^^^^^ help: remove `return`: `true`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:170:5
+  --> $DIR/needless_return.rs:171:5
    |
 LL |     return;
    |     ^^^^^^^ help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:175:9
+  --> $DIR/needless_return.rs:176:9
    |
 LL |         return;
    |         ^^^^^^^ help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:177:9
+  --> $DIR/needless_return.rs:178:9
    |
 LL |         return;
    |         ^^^^^^^ help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:184:14
+  --> $DIR/needless_return.rs:185:14
    |
 LL |         _ => return,
    |              ^^^^^^ help: replace `return` with an empty block: `{}`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:199:9
+  --> $DIR/needless_return.rs:200:9
    |
 LL |         return String::from("test");
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove `return`: `String::from("test")`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:201:9
+  --> $DIR/needless_return.rs:202:9
    |
 LL |         return String::new();
    |         ^^^^^^^^^^^^^^^^^^^^^ help: remove `return`: `String::new()`
diff --git a/tests/ui/option_if_let_else.fixed b/tests/ui/option_if_let_else.fixed
index 9fdea79fe71..ce3093c542a 100644
--- a/tests/ui/option_if_let_else.fixed
+++ b/tests/ui/option_if_let_else.fixed
@@ -121,7 +121,7 @@ fn main() {
 
     let s = String::new();
     // Lint, both branches immutably borrow `s`.
-    let _ = Some(0).map_or_else(|| s.len(), |x| s.len() + x);
+    let _ = Some(0).map_or(s.len(), |x| s.len() + x);
 
     let s = String::new();
     // Lint, `Some` branch consumes `s`, but else branch doesn't use `s`.
diff --git a/tests/ui/option_if_let_else.stderr b/tests/ui/option_if_let_else.stderr
index d7711bc1c47..4e64cd7cdb1 100644
--- a/tests/ui/option_if_let_else.stderr
+++ b/tests/ui/option_if_let_else.stderr
@@ -180,11 +180,11 @@ LL +             }
 LL ~         });
    |
 
-error: use Option::map_or_else instead of an if let/else
+error: use Option::map_or instead of an if let/else
   --> $DIR/option_if_let_else.rs:151:13
    |
 LL |     let _ = if let Some(x) = Some(0) { s.len() + x } else { s.len() };
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Some(0).map_or_else(|| s.len(), |x| s.len() + x)`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Some(0).map_or(s.len(), |x| s.len() + x)`
 
 error: use Option::map_or instead of an if let/else
   --> $DIR/option_if_let_else.rs:155:13
diff --git a/tests/ui/or_fun_call.fixed b/tests/ui/or_fun_call.fixed
index c2f94d0e857..d6d6ab49734 100644
--- a/tests/ui/or_fun_call.fixed
+++ b/tests/ui/or_fun_call.fixed
@@ -43,7 +43,7 @@ fn or_fun_call() {
     with_enum.unwrap_or(Enum::A(5));
 
     let with_const_fn = Some(Duration::from_secs(1));
-    with_const_fn.unwrap_or_else(|| Duration::from_secs(5));
+    with_const_fn.unwrap_or(Duration::from_secs(5));
 
     let with_constructor = Some(vec![1]);
     with_constructor.unwrap_or_else(make);
@@ -79,16 +79,16 @@ fn or_fun_call() {
     without_default.unwrap_or_else(Foo::new);
 
     let mut map = HashMap::<u64, String>::new();
-    map.entry(42).or_insert_with(String::new);
+    map.entry(42).or_insert(String::new());
 
     let mut map_vec = HashMap::<u64, Vec<i32>>::new();
-    map_vec.entry(42).or_insert_with(Vec::new);
+    map_vec.entry(42).or_insert(vec![]);
 
     let mut btree = BTreeMap::<u64, String>::new();
-    btree.entry(42).or_insert_with(String::new);
+    btree.entry(42).or_insert(String::new());
 
     let mut btree_vec = BTreeMap::<u64, Vec<i32>>::new();
-    btree_vec.entry(42).or_insert_with(Vec::new);
+    btree_vec.entry(42).or_insert(vec![]);
 
     let stringy = Some(String::from(""));
     let _ = stringy.unwrap_or_else(|| "".to_owned());
@@ -129,7 +129,7 @@ fn test_or_with_ctors() {
 
     let b = "b".to_string();
     let _ = Some(Bar("a".to_string(), Duration::from_secs(1)))
-        .or_else(|| Some(Bar(b, Duration::from_secs(2))));
+        .or(Some(Bar(b, Duration::from_secs(2))));
 
     let vec = vec!["foo"];
     let _ = opt.ok_or(vec.len());
@@ -155,16 +155,24 @@ fn f() -> Option<()> {
 }
 
 mod issue6675 {
+    unsafe fn ptr_to_ref<'a, T>(p: *const T) -> &'a T {
+        #[allow(unused)]
+        let x = vec![0; 1000]; // future-proofing, make this function expensive.
+        &*p
+    }
+
     unsafe fn foo() {
-        let mut s = "test".to_owned();
-        None.unwrap_or_else(|| s.as_mut_vec());
+        let s = "test".to_owned();
+        let s = &s as *const _;
+        None.unwrap_or_else(|| ptr_to_ref(s));
     }
 
     fn bar() {
-        let mut s = "test".to_owned();
-        None.unwrap_or_else(|| unsafe { s.as_mut_vec() });
+        let s = "test".to_owned();
+        let s = &s as *const _;
+        None.unwrap_or_else(|| unsafe { ptr_to_ref(s) });
         #[rustfmt::skip]
-        None.unwrap_or_else(|| unsafe { s.as_mut_vec() });
+        None.unwrap_or_else(|| unsafe { ptr_to_ref(s) });
     }
 }
 
diff --git a/tests/ui/or_fun_call.rs b/tests/ui/or_fun_call.rs
index afaf92961b0..8eadc6ce3b4 100644
--- a/tests/ui/or_fun_call.rs
+++ b/tests/ui/or_fun_call.rs
@@ -155,16 +155,24 @@ fn f() -> Option<()> {
 }
 
 mod issue6675 {
+    unsafe fn ptr_to_ref<'a, T>(p: *const T) -> &'a T {
+        #[allow(unused)]
+        let x = vec![0; 1000]; // future-proofing, make this function expensive.
+        &*p
+    }
+
     unsafe fn foo() {
-        let mut s = "test".to_owned();
-        None.unwrap_or(s.as_mut_vec());
+        let s = "test".to_owned();
+        let s = &s as *const _;
+        None.unwrap_or(ptr_to_ref(s));
     }
 
     fn bar() {
-        let mut s = "test".to_owned();
-        None.unwrap_or(unsafe { s.as_mut_vec() });
+        let s = "test".to_owned();
+        let s = &s as *const _;
+        None.unwrap_or(unsafe { ptr_to_ref(s) });
         #[rustfmt::skip]
-        None.unwrap_or( unsafe { s.as_mut_vec() }    );
+        None.unwrap_or( unsafe { ptr_to_ref(s) }    );
     }
 }
 
diff --git a/tests/ui/or_fun_call.stderr b/tests/ui/or_fun_call.stderr
index b2bcbd38c2d..9d0c42b10c2 100644
--- a/tests/ui/or_fun_call.stderr
+++ b/tests/ui/or_fun_call.stderr
@@ -1,16 +1,10 @@
-error: use of `unwrap_or` followed by a function call
-  --> $DIR/or_fun_call.rs:46:19
-   |
-LL |     with_const_fn.unwrap_or(Duration::from_secs(5));
-   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|| Duration::from_secs(5))`
-   |
-   = note: `-D clippy::or-fun-call` implied by `-D warnings`
-
 error: use of `unwrap_or` followed by a function call
   --> $DIR/or_fun_call.rs:49:22
    |
 LL |     with_constructor.unwrap_or(make());
    |                      ^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(make)`
+   |
+   = note: `-D clippy::or-fun-call` implied by `-D warnings`
 
 error: use of `unwrap_or` followed by a call to `new`
   --> $DIR/or_fun_call.rs:52:5
@@ -72,30 +66,6 @@ error: use of `unwrap_or` followed by a function call
 LL |     without_default.unwrap_or(Foo::new());
    |                     ^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(Foo::new)`
 
-error: use of `or_insert` followed by a function call
-  --> $DIR/or_fun_call.rs:82:19
-   |
-LL |     map.entry(42).or_insert(String::new());
-   |                   ^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `or_insert_with(String::new)`
-
-error: use of `or_insert` followed by a function call
-  --> $DIR/or_fun_call.rs:85:23
-   |
-LL |     map_vec.entry(42).or_insert(vec![]);
-   |                       ^^^^^^^^^^^^^^^^^ help: try this: `or_insert_with(Vec::new)`
-
-error: use of `or_insert` followed by a function call
-  --> $DIR/or_fun_call.rs:88:21
-   |
-LL |     btree.entry(42).or_insert(String::new());
-   |                     ^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `or_insert_with(String::new)`
-
-error: use of `or_insert` followed by a function call
-  --> $DIR/or_fun_call.rs:91:25
-   |
-LL |     btree_vec.entry(42).or_insert(vec![]);
-   |                         ^^^^^^^^^^^^^^^^^ help: try this: `or_insert_with(Vec::new)`
-
 error: use of `unwrap_or` followed by a function call
   --> $DIR/or_fun_call.rs:94:21
    |
@@ -120,29 +90,23 @@ error: use of `or` followed by a function call
 LL |     let _ = Some("a".to_string()).or(Some("b".to_string()));
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `or_else(|| Some("b".to_string()))`
 
-error: use of `or` followed by a function call
-  --> $DIR/or_fun_call.rs:132:10
-   |
-LL |         .or(Some(Bar(b, Duration::from_secs(2))));
-   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `or_else(|| Some(Bar(b, Duration::from_secs(2))))`
-
 error: use of `unwrap_or` followed by a function call
-  --> $DIR/or_fun_call.rs:160:14
+  --> $DIR/or_fun_call.rs:167:14
    |
-LL |         None.unwrap_or(s.as_mut_vec());
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|| s.as_mut_vec())`
+LL |         None.unwrap_or(ptr_to_ref(s));
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|| ptr_to_ref(s))`
 
 error: use of `unwrap_or` followed by a function call
-  --> $DIR/or_fun_call.rs:165:14
+  --> $DIR/or_fun_call.rs:173:14
    |
-LL |         None.unwrap_or(unsafe { s.as_mut_vec() });
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|| unsafe { s.as_mut_vec() })`
+LL |         None.unwrap_or(unsafe { ptr_to_ref(s) });
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|| unsafe { ptr_to_ref(s) })`
 
 error: use of `unwrap_or` followed by a function call
-  --> $DIR/or_fun_call.rs:167:14
+  --> $DIR/or_fun_call.rs:175:14
    |
-LL |         None.unwrap_or( unsafe { s.as_mut_vec() }    );
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|| unsafe { s.as_mut_vec() })`
+LL |         None.unwrap_or( unsafe { ptr_to_ref(s) }    );
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|| unsafe { ptr_to_ref(s) })`
 
-error: aborting due to 24 previous errors
+error: aborting due to 18 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 7605bac2cb72627e29d0a82a70d5496a5a7a1827 Mon Sep 17 00:00:00 2001
From: togami2864 <tuabobo123@gmail.com>
Date: Tue, 16 Nov 2021 23:07:19 +0900
Subject: resolve CI

---
 clippy_lints/src/methods/option_map_or_none.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/option_map_or_none.rs b/clippy_lints/src/methods/option_map_or_none.rs
index 12ccaa24c3b..b5652838892 100644
--- a/clippy_lints/src/methods/option_map_or_none.rs
+++ b/clippy_lints/src/methods/option_map_or_none.rs
@@ -72,10 +72,10 @@ pub(super) fn check<'tcx>(
 
     if is_option {
         let self_snippet = snippet(cx, recv.span, "..");
-        if let hir::ExprKind::Closure(_, _, id, span, _) = map_arg.kind {
+        if_chain! {
+        if let hir::ExprKind::Closure(_, _, id, span, _) = map_arg.kind;
             let arg_snippet = snippet(cx, span, "..");
             let body = cx.tcx.hir().body(id);
-            if_chain! {
                 if let Some((func, arg_char)) = reduce_unit_expression(cx, &body.value);
                 if arg_char.len() == 1;
                 if let hir::ExprKind::Path(ref qpath) = func.kind;
@@ -95,7 +95,7 @@ pub(super) fn check<'tcx>(
                         Applicability::MachineApplicable,
                     );
                 }
-            }
+
         }
 
         let func_snippet = snippet(cx, map_arg.span, "..");
-- 
cgit 1.4.1-3-g733a5


From 5b3c00f012dade7a1586cc8cca4b9e4a20888315 Mon Sep 17 00:00:00 2001
From: Skyler Calaman <54462713+Blckbrry-Pi@users.noreply.github.com>
Date: Tue, 16 Nov 2021 09:18:49 -0500
Subject: Successfully generalize prevention of suggestions causing multiple
 mutable borrows.

Also add some more tests to check that it's working.
---
 clippy_lints/src/loops/needless_collect.rs | 82 +++++++++++++++++++++++-------
 tests/ui/needless_collect_indirect.rs      | 21 +++++++-
 2 files changed, 84 insertions(+), 19 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/needless_collect.rs b/clippy_lints/src/loops/needless_collect.rs
index 22c123e9e04..aeecf226b2d 100644
--- a/clippy_lints/src/loops/needless_collect.rs
+++ b/clippy_lints/src/loops/needless_collect.rs
@@ -3,8 +3,9 @@ use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_hir_and_then};
 use clippy_utils::source::{snippet, snippet_with_applicability};
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{can_move_expr_to_closure, is_trait_method, path_to_local_id, CaptureKind};
+use clippy_utils::{can_move_expr_to_closure, is_trait_method, path_to_local, path_to_local_id, CaptureKind};
 use if_chain::if_chain;
+use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_block, walk_expr, NestedVisitorMap, Visitor};
 use rustc_hir::{Block, Expr, ExprKind, HirId, HirIdSet, Local, Mutability, Node, PatKind, Stmt, StmtKind};
@@ -174,15 +175,23 @@ struct IterFunctionVisitor<'b, 'a> {
     illegal_mutable_capture_ids: HirIdSet,
     current_mutably_captured_ids: HirIdSet,
     cx: &'a LateContext<'b>,
-    uses: Vec<IterFunction>,
+    uses: Vec<Option<IterFunction>>,
+    hir_id_uses_map: FxHashMap<HirId, usize>,
+    current_statement_hir_id: Option<HirId>,
     seen_other: bool,
     target: HirId,
 }
 impl<'tcx> Visitor<'tcx> for IterFunctionVisitor<'_, 'tcx> {
     fn visit_block(&mut self, block: &'txc Block<'tcx>) {
-        for elem in block.stmts.iter().filter_map(get_expr_from_stmt).chain(block.expr) {
-            self.current_mutably_captured_ids = HirIdSet::default();
-            self.visit_expr(elem);
+        for (expr, hir_id) in block
+            .stmts
+            .iter()
+            .filter_map(get_expr_and_hir_id_from_stmt)
+            .chain(block.expr.map(|expr| (expr, None)))
+        {
+            self.current_statement_hir_id = hir_id;
+            self.current_mutably_captured_ids = get_captured_ids(self.cx, self.cx.typeck_results().expr_ty(expr));
+            self.visit_expr(expr);
         }
     }
 
@@ -202,28 +211,53 @@ impl<'tcx> Visitor<'tcx> for IterFunctionVisitor<'_, 'tcx> {
                     .next()
                     .is_none()
                 {
+                    if let Some(hir_id) = self.current_statement_hir_id {
+                        self.hir_id_uses_map.insert(hir_id, self.uses.len());
+                    }
                     match &*method_name.ident.name.as_str() {
-                        "into_iter" => self.uses.push(IterFunction {
+                        "into_iter" => self.uses.push(Some(IterFunction {
                             func: IterFunctionKind::IntoIter,
                             span: expr.span,
-                        }),
-                        "len" => self.uses.push(IterFunction {
+                        })),
+                        "len" => self.uses.push(Some(IterFunction {
                             func: IterFunctionKind::Len,
                             span: expr.span,
-                        }),
-                        "is_empty" => self.uses.push(IterFunction {
+                        })),
+                        "is_empty" => self.uses.push(Some(IterFunction {
                             func: IterFunctionKind::IsEmpty,
                             span: expr.span,
-                        }),
-                        "contains" => self.uses.push(IterFunction {
+                        })),
+                        "contains" => self.uses.push(Some(IterFunction {
                             func: IterFunctionKind::Contains(args[0].span),
                             span: expr.span,
-                        }),
-                        _ => self.seen_other = true,
+                        })),
+                        _ => {
+                            self.seen_other = true;
+                            if let Some(hir_id) = self.current_statement_hir_id {
+                                self.hir_id_uses_map.remove(&hir_id);
+                            }
+                        },
                     }
                 }
                 return;
             }
+
+            if let Some(hir_id) = path_to_local(recv) {
+                if let Some(index) = self.hir_id_uses_map.remove(&hir_id) {
+                    if self
+                        .illegal_mutable_capture_ids
+                        .intersection(&self.current_mutably_captured_ids)
+                        .next()
+                        .is_none()
+                    {
+                        if let Some(hir_id) = self.current_statement_hir_id {
+                            self.hir_id_uses_map.insert(hir_id, index);
+                        }
+                    } else {
+                        self.uses[index] = None;
+                    }
+                }
+            }
         }
         // Check if the collection is used for anything else
         if path_to_local_id(expr, self.target) {
@@ -239,11 +273,17 @@ impl<'tcx> Visitor<'tcx> for IterFunctionVisitor<'_, 'tcx> {
     }
 }
 
-fn get_expr_from_stmt<'v>(stmt: &'v Stmt<'v>) -> Option<&'v Expr<'v>> {
+fn get_expr_and_hir_id_from_stmt<'v>(stmt: &'v Stmt<'v>) -> Option<(&'v Expr<'v>, Option<HirId>)> {
     match stmt.kind {
-        StmtKind::Expr(expr) | StmtKind::Semi(expr) => Some(expr),
+        StmtKind::Expr(expr) | StmtKind::Semi(expr) => Some((expr, None)),
         StmtKind::Item(..) => None,
-        StmtKind::Local(Local { init, .. }) => *init,
+        StmtKind::Local(Local { init, pat, .. }) => {
+            if let PatKind::Binding(_, hir_id, ..) = pat.kind {
+                init.map(|init_expr| (init_expr, Some(hir_id)))
+            } else {
+                init.map(|init_expr| (init_expr, None))
+            }
+        },
     }
 }
 
@@ -284,9 +324,15 @@ fn detect_iter_and_into_iters<'tcx: 'a, 'a>(
         cx,
         current_mutably_captured_ids: HirIdSet::default(),
         illegal_mutable_capture_ids: captured_ids,
+        hir_id_uses_map: FxHashMap::default(),
+        current_statement_hir_id: None,
     };
     visitor.visit_block(block);
-    if visitor.seen_other { None } else { Some(visitor.uses) }
+    if visitor.seen_other {
+        None
+    } else {
+        Some(visitor.uses.into_iter().flatten().collect())
+    }
 }
 
 #[allow(rustc::usage_of_ty_tykind)]
diff --git a/tests/ui/needless_collect_indirect.rs b/tests/ui/needless_collect_indirect.rs
index 7f2d86b0925..1f11d1f8d56 100644
--- a/tests/ui/needless_collect_indirect.rs
+++ b/tests/ui/needless_collect_indirect.rs
@@ -79,13 +79,32 @@ mod issue7110 {
 mod issue7975 {
     use super::*;
 
-    fn shouldnt_lint() -> Vec<()> {
+    fn direct_mapping_with_used_mutable_reference() -> Vec<()> {
         let test_vec: Vec<()> = vec![];
         let mut vec_2: Vec<()> = vec![];
         let mut_ref = &mut vec_2;
         let collected_vec: Vec<_> = test_vec.into_iter().map(|_| mut_ref.push(())).collect();
         collected_vec.into_iter().map(|_| mut_ref.push(())).collect()
     }
+
+    fn indirectly_mapping_with_used_mutable_reference() -> Vec<()> {
+        let test_vec: Vec<()> = vec![];
+        let mut vec_2: Vec<()> = vec![];
+        let mut_ref = &mut vec_2;
+        let collected_vec: Vec<_> = test_vec.into_iter().map(|_| mut_ref.push(())).collect();
+        let iter = collected_vec.into_iter();
+        iter.map(|_| mut_ref.push(())).collect()
+    }
+
+    fn indirect_collect_after_indirect_mapping_with_used_mutable_reference() -> Vec<()> {
+        let test_vec: Vec<()> = vec![];
+        let mut vec_2: Vec<()> = vec![];
+        let mut_ref = &mut vec_2;
+        let collected_vec: Vec<_> = test_vec.into_iter().map(|_| mut_ref.push(())).collect();
+        let iter = collected_vec.into_iter();
+        let mapped_iter = iter.map(|_| mut_ref.push(()));
+        mapped_iter.collect()
+    }
 }
 
 fn allow_test() {
-- 
cgit 1.4.1-3-g733a5


From c52b389b161e1a403647a6ca482a9ef8fc391549 Mon Sep 17 00:00:00 2001
From: Skyler Calaman <54462713+Blckbrry-Pi@users.noreply.github.com>
Date: Tue, 16 Nov 2021 11:29:26 -0500
Subject: Fix readability suggestions.

1. Make the lifetime contained in LateContext `'tcx`.
2. Fix `'txc` to `'tcx` because it was a typo.
3. Refactor `IterFunctionVisitor`'s `visit_block` method to be more readable.
4. Replace uses of `rustc_middle::ty::TyKind` with `rustc::middle::ty`, and remove the `#[allow(...)]`.

(Thank you llogiq for all these suggestions!)
---
 clippy_lints/src/loops/needless_collect.rs | 35 ++++++++++++++++--------------
 1 file changed, 19 insertions(+), 16 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/needless_collect.rs b/clippy_lints/src/loops/needless_collect.rs
index aeecf226b2d..6f3acb45ba4 100644
--- a/clippy_lints/src/loops/needless_collect.rs
+++ b/clippy_lints/src/loops/needless_collect.rs
@@ -12,7 +12,7 @@ use rustc_hir::{Block, Expr, ExprKind, HirId, HirIdSet, Local, Mutability, Node,
 use rustc_lint::LateContext;
 use rustc_middle::hir::map::Map;
 use rustc_middle::ty::subst::GenericArgKind;
-use rustc_middle::ty::{TyKind, TyS};
+use rustc_middle::ty::{self, TyS};
 use rustc_span::sym;
 use rustc_span::{MultiSpan, Span};
 
@@ -171,10 +171,10 @@ enum IterFunctionKind {
     Contains(Span),
 }
 
-struct IterFunctionVisitor<'b, 'a> {
+struct IterFunctionVisitor<'a, 'tcx> {
     illegal_mutable_capture_ids: HirIdSet,
     current_mutably_captured_ids: HirIdSet,
-    cx: &'a LateContext<'b>,
+    cx: &'a LateContext<'tcx>,
     uses: Vec<Option<IterFunction>>,
     hir_id_uses_map: FxHashMap<HirId, usize>,
     current_statement_hir_id: Option<HirId>,
@@ -182,16 +182,12 @@ struct IterFunctionVisitor<'b, 'a> {
     target: HirId,
 }
 impl<'tcx> Visitor<'tcx> for IterFunctionVisitor<'_, 'tcx> {
-    fn visit_block(&mut self, block: &'txc Block<'tcx>) {
-        for (expr, hir_id) in block
-            .stmts
-            .iter()
-            .filter_map(get_expr_and_hir_id_from_stmt)
-            .chain(block.expr.map(|expr| (expr, None)))
-        {
-            self.current_statement_hir_id = hir_id;
-            self.current_mutably_captured_ids = get_captured_ids(self.cx, self.cx.typeck_results().expr_ty(expr));
-            self.visit_expr(expr);
+    fn visit_block(&mut self, block: &'tcx Block<'tcx>) {
+        for (expr, hir_id) in block.stmts.iter().filter_map(get_expr_and_hir_id_from_stmt) {
+            self.visit_block_expr(expr, hir_id);
+        }
+        if let Some(expr) = block.expr {
+            self.visit_block_expr(expr, None);
         }
     }
 
@@ -273,6 +269,14 @@ impl<'tcx> Visitor<'tcx> for IterFunctionVisitor<'_, 'tcx> {
     }
 }
 
+impl<'tcx> IterFunctionVisitor<'_, 'tcx> {
+    fn visit_block_expr(&mut self, expr: &'tcx Expr<'tcx>, hir_id: Option<HirId>) {
+        self.current_statement_hir_id = hir_id;
+        self.current_mutably_captured_ids = get_captured_ids(self.cx, self.cx.typeck_results().expr_ty(expr));
+        self.visit_expr(expr);
+    }
+}
+
 fn get_expr_and_hir_id_from_stmt<'v>(stmt: &'v Stmt<'v>) -> Option<(&'v Expr<'v>, Option<HirId>)> {
     match stmt.kind {
         StmtKind::Expr(expr) | StmtKind::Semi(expr) => Some((expr, None)),
@@ -335,18 +339,17 @@ fn detect_iter_and_into_iters<'tcx: 'a, 'a>(
     }
 }
 
-#[allow(rustc::usage_of_ty_tykind)]
 fn get_captured_ids(cx: &LateContext<'tcx>, ty: &'_ TyS<'_>) -> HirIdSet {
     fn get_captured_ids_recursive(cx: &LateContext<'tcx>, ty: &'_ TyS<'_>, set: &mut HirIdSet) {
         match ty.kind() {
-            TyKind::Adt(_, generics) => {
+            ty::Adt(_, generics) => {
                 for generic in *generics {
                     if let GenericArgKind::Type(ty) = generic.unpack() {
                         get_captured_ids_recursive(cx, ty, set);
                     }
                 }
             },
-            TyKind::Closure(def_id, _) => {
+            ty::Closure(def_id, _) => {
                 let closure_hir_node = cx.tcx.hir().get_if_local(*def_id).unwrap();
                 if let Node::Expr(closure_expr) = closure_hir_node {
                     can_move_expr_to_closure(cx, closure_expr)
-- 
cgit 1.4.1-3-g733a5


From e9bf5ec6597a24cc4f24523b58b2e0e90be7a053 Mon Sep 17 00:00:00 2001
From: F3real <stefan92ff@yandex.com>
Date: Wed, 17 Nov 2021 00:50:07 +0100
Subject: Don't show no_effect warning on unit structs implementing fn* traits

---
 clippy_lints/src/no_effect.rs | 11 ++++++--
 tests/ui/no_effect.rs         | 35 ++++++++++++++++++++++++-
 tests/ui/no_effect.stderr     | 60 +++++++++++++++++++++----------------------
 3 files changed, 73 insertions(+), 33 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/no_effect.rs b/clippy_lints/src/no_effect.rs
index 31134743d02..cd54de3ee4b 100644
--- a/clippy_lints/src/no_effect.rs
+++ b/clippy_lints/src/no_effect.rs
@@ -133,9 +133,12 @@ fn has_no_effect(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
         },
         ExprKind::Call(callee, args) => {
             if let ExprKind::Path(ref qpath) = callee.kind {
-                let res = cx.qpath_res(qpath, callee.hir_id);
+                if cx.typeck_results().type_dependent_def(expr.hir_id).is_some() {
+                    // type-dependent function call like `impl FnOnce for X`
+                    return false;
+                }
                 let def_matched = matches!(
-                    res,
+                    cx.qpath_res(qpath, callee.hir_id),
                     Res::Def(DefKind::Struct | DefKind::Variant | DefKind::Ctor(..), ..)
                 );
                 if def_matched || is_range_literal(expr) {
@@ -238,6 +241,10 @@ fn reduce_expression<'a>(cx: &LateContext<'_>, expr: &'a Expr<'a>) -> Option<Vec
         },
         ExprKind::Call(callee, args) => {
             if let ExprKind::Path(ref qpath) = callee.kind {
+                if cx.typeck_results().type_dependent_def(expr.hir_id).is_some() {
+                    // type-dependent function call like `impl FnOnce for X`
+                    return None;
+                }
                 let res = cx.qpath_res(qpath, callee.hir_id);
                 match res {
                     Res::Def(DefKind::Struct | DefKind::Variant | DefKind::Ctor(..), ..)
diff --git a/tests/ui/no_effect.rs b/tests/ui/no_effect.rs
index 7bcc4cad0d3..5427c88faf3 100644
--- a/tests/ui/no_effect.rs
+++ b/tests/ui/no_effect.rs
@@ -1,4 +1,4 @@
-#![feature(box_syntax)]
+#![feature(box_syntax, fn_traits, unboxed_closures)]
 #![warn(clippy::no_effect_underscore_binding)]
 #![allow(dead_code)]
 #![allow(path_statements)]
@@ -58,6 +58,36 @@ unsafe fn unsafe_fn() -> i32 {
     0
 }
 
+struct GreetStruct1;
+
+impl FnOnce<(&str,)> for GreetStruct1 {
+    type Output = ();
+
+    extern "rust-call" fn call_once(self, (who,): (&str,)) -> Self::Output {
+        println!("hello {}", who);
+    }
+}
+
+struct GreetStruct2();
+
+impl FnOnce<(&str,)> for GreetStruct2 {
+    type Output = ();
+
+    extern "rust-call" fn call_once(self, (who,): (&str,)) -> Self::Output {
+        println!("hello {}", who);
+    }
+}
+
+struct GreetStruct3 {}
+
+impl FnOnce<(&str,)> for GreetStruct3 {
+    type Output = ();
+
+    extern "rust-call" fn call_once(self, (who,): (&str,)) -> Self::Output {
+        println!("hello {}", who);
+    }
+}
+
 fn main() {
     let s = get_struct();
     let s2 = get_struct();
@@ -108,4 +138,7 @@ fn main() {
     DropTuple(0);
     DropEnum::Tuple(0);
     DropEnum::Struct { field: 0 };
+    GreetStruct1("world");
+    GreetStruct2()("world");
+    GreetStruct3 {}("world");
 }
diff --git a/tests/ui/no_effect.stderr b/tests/ui/no_effect.stderr
index a5dbc9fef45..06b88bb5bee 100644
--- a/tests/ui/no_effect.stderr
+++ b/tests/ui/no_effect.stderr
@@ -1,5 +1,5 @@
 error: statement with no effect
-  --> $DIR/no_effect.rs:65:5
+  --> $DIR/no_effect.rs:95:5
    |
 LL |     0;
    |     ^^
@@ -7,157 +7,157 @@ LL |     0;
    = note: `-D clippy::no-effect` implied by `-D warnings`
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:66:5
+  --> $DIR/no_effect.rs:96:5
    |
 LL |     s2;
    |     ^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:67:5
+  --> $DIR/no_effect.rs:97:5
    |
 LL |     Unit;
    |     ^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:68:5
+  --> $DIR/no_effect.rs:98:5
    |
 LL |     Tuple(0);
    |     ^^^^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:69:5
+  --> $DIR/no_effect.rs:99:5
    |
 LL |     Struct { field: 0 };
    |     ^^^^^^^^^^^^^^^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:70:5
+  --> $DIR/no_effect.rs:100:5
    |
 LL |     Struct { ..s };
    |     ^^^^^^^^^^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:71:5
+  --> $DIR/no_effect.rs:101:5
    |
 LL |     Union { a: 0 };
    |     ^^^^^^^^^^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:72:5
+  --> $DIR/no_effect.rs:102:5
    |
 LL |     Enum::Tuple(0);
    |     ^^^^^^^^^^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:73:5
+  --> $DIR/no_effect.rs:103:5
    |
 LL |     Enum::Struct { field: 0 };
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:74:5
+  --> $DIR/no_effect.rs:104:5
    |
 LL |     5 + 6;
    |     ^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:75:5
+  --> $DIR/no_effect.rs:105:5
    |
 LL |     *&42;
    |     ^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:76:5
+  --> $DIR/no_effect.rs:106:5
    |
 LL |     &6;
    |     ^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:77:5
+  --> $DIR/no_effect.rs:107:5
    |
 LL |     (5, 6, 7);
    |     ^^^^^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:78:5
+  --> $DIR/no_effect.rs:108:5
    |
 LL |     box 42;
    |     ^^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:79:5
+  --> $DIR/no_effect.rs:109:5
    |
 LL |     ..;
    |     ^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:80:5
+  --> $DIR/no_effect.rs:110:5
    |
 LL |     5..;
    |     ^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:81:5
+  --> $DIR/no_effect.rs:111:5
    |
 LL |     ..5;
    |     ^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:82:5
+  --> $DIR/no_effect.rs:112:5
    |
 LL |     5..6;
    |     ^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:83:5
+  --> $DIR/no_effect.rs:113:5
    |
 LL |     5..=6;
    |     ^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:84:5
+  --> $DIR/no_effect.rs:114:5
    |
 LL |     [42, 55];
    |     ^^^^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:85:5
+  --> $DIR/no_effect.rs:115:5
    |
 LL |     [42, 55][1];
    |     ^^^^^^^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:86:5
+  --> $DIR/no_effect.rs:116:5
    |
 LL |     (42, 55).1;
    |     ^^^^^^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:87:5
+  --> $DIR/no_effect.rs:117:5
    |
 LL |     [42; 55];
    |     ^^^^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:88:5
+  --> $DIR/no_effect.rs:118:5
    |
 LL |     [42; 55][13];
    |     ^^^^^^^^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:90:5
+  --> $DIR/no_effect.rs:120:5
    |
 LL |     || x += 5;
    |     ^^^^^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:92:5
+  --> $DIR/no_effect.rs:122:5
    |
 LL |     FooString { s: s };
    |     ^^^^^^^^^^^^^^^^^^^
 
 error: binding to `_` prefixed variable with no side-effect
-  --> $DIR/no_effect.rs:93:5
+  --> $DIR/no_effect.rs:123:5
    |
 LL |     let _unused = 1;
    |     ^^^^^^^^^^^^^^^^
@@ -165,19 +165,19 @@ LL |     let _unused = 1;
    = note: `-D clippy::no-effect-underscore-binding` implied by `-D warnings`
 
 error: binding to `_` prefixed variable with no side-effect
-  --> $DIR/no_effect.rs:94:5
+  --> $DIR/no_effect.rs:124:5
    |
 LL |     let _penguin = || println!("Some helpful closure");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: binding to `_` prefixed variable with no side-effect
-  --> $DIR/no_effect.rs:95:5
+  --> $DIR/no_effect.rs:125:5
    |
 LL |     let _duck = Struct { field: 0 };
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: binding to `_` prefixed variable with no side-effect
-  --> $DIR/no_effect.rs:96:5
+  --> $DIR/no_effect.rs:126:5
    |
 LL |     let _cat = [2, 4, 6, 8][2];
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From c051656c836bf11335781afbabe1690ea7542f49 Mon Sep 17 00:00:00 2001
From: surechen <chenshuo17@huawei.com>
Date: Fri, 29 Oct 2021 11:32:37 +0800
Subject: fixes: #7889

1. Fix the problem of manual_split_once changing the original behavior.
2. Add a new lint needless_splitn.

changelog: Fix the problem of manual_split_once changing the original behavior and add a new lint needless_splitn.
---
 CHANGELOG.md                                  |   1 +
 clippy_lints/src/lib.register_all.rs          |   1 +
 clippy_lints/src/lib.register_complexity.rs   |   1 +
 clippy_lints/src/lib.register_lints.rs        |   1 +
 clippy_lints/src/methods/manual_split_once.rs | 211 -----------------
 clippy_lints/src/methods/mod.rs               |  34 ++-
 clippy_lints/src/methods/str_splitn.rs        | 323 ++++++++++++++++++++++++++
 tests/ui/manual_split_once.fixed              |   6 +-
 tests/ui/manual_split_once.rs                 |   2 +-
 tests/ui/manual_split_once.stderr             |  10 +-
 tests/ui/needless_splitn.fixed                |  27 +++
 tests/ui/needless_splitn.rs                   |  27 +++
 tests/ui/needless_splitn.stderr               |  40 ++++
 tests/ui/suspicious_splitn.rs                 |   1 +
 tests/ui/suspicious_splitn.stderr             |  18 +-
 15 files changed, 468 insertions(+), 235 deletions(-)
 delete mode 100644 clippy_lints/src/methods/manual_split_once.rs
 create mode 100644 clippy_lints/src/methods/str_splitn.rs
 create mode 100644 tests/ui/needless_splitn.fixed
 create mode 100644 tests/ui/needless_splitn.rs
 create mode 100644 tests/ui/needless_splitn.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 267bc07d8fa..55c4c4c7a27 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3038,6 +3038,7 @@ Released 2018-09-13
 [`needless_question_mark`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_question_mark
 [`needless_range_loop`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_range_loop
 [`needless_return`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_return
+[`needless_splitn`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_splitn
 [`needless_update`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_update
 [`neg_cmp_op_on_partial_ord`]: https://rust-lang.github.io/rust-clippy/master/index.html#neg_cmp_op_on_partial_ord
 [`neg_multiply`]: https://rust-lang.github.io/rust-clippy/master/index.html#neg_multiply
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 4e123f27ec0..32c24a4aade 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -160,6 +160,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(methods::MANUAL_STR_REPEAT),
     LintId::of(methods::MAP_COLLECT_RESULT_UNIT),
     LintId::of(methods::MAP_IDENTITY),
+    LintId::of(methods::NEEDLESS_SPLITN),
     LintId::of(methods::NEW_RET_NO_SELF),
     LintId::of(methods::OK_EXPECT),
     LintId::of(methods::OPTION_AS_REF_DEREF),
diff --git a/clippy_lints/src/lib.register_complexity.rs b/clippy_lints/src/lib.register_complexity.rs
index c51341bdf0c..dcc95cf6c07 100644
--- a/clippy_lints/src/lib.register_complexity.rs
+++ b/clippy_lints/src/lib.register_complexity.rs
@@ -42,6 +42,7 @@ store.register_group(true, "clippy::complexity", Some("clippy_complexity"), vec!
     LintId::of(methods::MANUAL_FIND_MAP),
     LintId::of(methods::MANUAL_SPLIT_ONCE),
     LintId::of(methods::MAP_IDENTITY),
+    LintId::of(methods::NEEDLESS_SPLITN),
     LintId::of(methods::OPTION_AS_REF_DEREF),
     LintId::of(methods::OPTION_FILTER_MAP),
     LintId::of(methods::SEARCH_IS_SOME),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 249bf77a8f2..872e86ffcfb 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -288,6 +288,7 @@ store.register_lints(&[
     methods::MAP_FLATTEN,
     methods::MAP_IDENTITY,
     methods::MAP_UNWRAP_OR,
+    methods::NEEDLESS_SPLITN,
     methods::NEW_RET_NO_SELF,
     methods::OK_EXPECT,
     methods::OPTION_AS_REF_DEREF,
diff --git a/clippy_lints/src/methods/manual_split_once.rs b/clippy_lints/src/methods/manual_split_once.rs
deleted file mode 100644
index 13eb72251bb..00000000000
--- a/clippy_lints/src/methods/manual_split_once.rs
+++ /dev/null
@@ -1,211 +0,0 @@
-use clippy_utils::consts::{constant, Constant};
-use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::source::snippet_with_context;
-use clippy_utils::{is_diag_item_method, match_def_path, paths};
-use if_chain::if_chain;
-use rustc_errors::Applicability;
-use rustc_hir::{Expr, ExprKind, HirId, LangItem, Node, QPath};
-use rustc_lint::LateContext;
-use rustc_middle::ty::{self, adjustment::Adjust};
-use rustc_span::{symbol::sym, Span, SyntaxContext};
-
-use super::MANUAL_SPLIT_ONCE;
-
-pub(super) fn check(cx: &LateContext<'_>, method_name: &str, expr: &Expr<'_>, self_arg: &Expr<'_>, pat_arg: &Expr<'_>) {
-    if !cx.typeck_results().expr_ty_adjusted(self_arg).peel_refs().is_str() {
-        return;
-    }
-
-    let ctxt = expr.span.ctxt();
-    let (method_name, msg, reverse) = if method_name == "splitn" {
-        ("split_once", "manual implementation of `split_once`", false)
-    } else {
-        ("rsplit_once", "manual implementation of `rsplit_once`", true)
-    };
-    let usage = match parse_iter_usage(cx, ctxt, cx.tcx.hir().parent_iter(expr.hir_id), reverse) {
-        Some(x) => x,
-        None => return,
-    };
-
-    let mut app = Applicability::MachineApplicable;
-    let self_snip = snippet_with_context(cx, self_arg.span, ctxt, "..", &mut app).0;
-    let pat_snip = snippet_with_context(cx, pat_arg.span, ctxt, "..", &mut app).0;
-
-    let sugg = match usage.kind {
-        IterUsageKind::NextTuple => {
-            format!("{}.{}({})", self_snip, method_name, pat_snip)
-        },
-        IterUsageKind::RNextTuple => format!("{}.{}({}).map(|(x, y)| (y, x))", self_snip, method_name, pat_snip),
-        IterUsageKind::Next => {
-            let self_deref = {
-                let adjust = cx.typeck_results().expr_adjustments(self_arg);
-                if adjust.is_empty() {
-                    String::new()
-                } else if cx.typeck_results().expr_ty(self_arg).is_box()
-                    || adjust
-                        .iter()
-                        .any(|a| matches!(a.kind, Adjust::Deref(Some(_))) || a.target.is_box())
-                {
-                    format!("&{}", "*".repeat(adjust.len() - 1))
-                } else {
-                    "*".repeat(adjust.len() - 2)
-                }
-            };
-            if usage.unwrap_kind.is_some() {
-                format!(
-                    "{}.{}({}).map_or({}{}, |x| x.0)",
-                    &self_snip, method_name, pat_snip, self_deref, &self_snip
-                )
-            } else {
-                format!(
-                    "Some({}.{}({}).map_or({}{}, |x| x.0))",
-                    &self_snip, method_name, pat_snip, self_deref, &self_snip
-                )
-            }
-        },
-        IterUsageKind::Second => {
-            let access_str = match usage.unwrap_kind {
-                Some(UnwrapKind::Unwrap) => ".unwrap().1",
-                Some(UnwrapKind::QuestionMark) => "?.1",
-                None => ".map(|x| x.1)",
-            };
-            format!("{}.{}({}){}", self_snip, method_name, pat_snip, access_str)
-        },
-    };
-
-    span_lint_and_sugg(cx, MANUAL_SPLIT_ONCE, usage.span, msg, "try this", sugg, app);
-}
-
-enum IterUsageKind {
-    Next,
-    Second,
-    NextTuple,
-    RNextTuple,
-}
-
-enum UnwrapKind {
-    Unwrap,
-    QuestionMark,
-}
-
-struct IterUsage {
-    kind: IterUsageKind,
-    unwrap_kind: Option<UnwrapKind>,
-    span: Span,
-}
-
-#[allow(clippy::too_many_lines)]
-fn parse_iter_usage(
-    cx: &LateContext<'tcx>,
-    ctxt: SyntaxContext,
-    mut iter: impl Iterator<Item = (HirId, Node<'tcx>)>,
-    reverse: bool,
-) -> Option<IterUsage> {
-    let (kind, span) = match iter.next() {
-        Some((_, Node::Expr(e))) if e.span.ctxt() == ctxt => {
-            let (name, args) = if let ExprKind::MethodCall(name, _, [_, args @ ..], _) = e.kind {
-                (name, args)
-            } else {
-                return None;
-            };
-            let did = cx.typeck_results().type_dependent_def_id(e.hir_id)?;
-            let iter_id = cx.tcx.get_diagnostic_item(sym::Iterator)?;
-
-            match (&*name.ident.as_str(), args) {
-                ("next", []) if cx.tcx.trait_of_item(did) == Some(iter_id) => {
-                    if reverse {
-                        (IterUsageKind::Second, e.span)
-                    } else {
-                        (IterUsageKind::Next, e.span)
-                    }
-                },
-                ("next_tuple", []) => {
-                    return if_chain! {
-                        if match_def_path(cx, did, &paths::ITERTOOLS_NEXT_TUPLE);
-                        if let ty::Adt(adt_def, subs) = cx.typeck_results().expr_ty(e).kind();
-                        if cx.tcx.is_diagnostic_item(sym::Option, adt_def.did);
-                        if let ty::Tuple(subs) = subs.type_at(0).kind();
-                        if subs.len() == 2;
-                        then {
-                            Some(IterUsage {
-                                kind: if reverse { IterUsageKind::RNextTuple } else { IterUsageKind::NextTuple },
-                                span: e.span,
-                                unwrap_kind: None
-                            })
-                        } else {
-                            None
-                        }
-                    };
-                },
-                ("nth" | "skip", [idx_expr]) if cx.tcx.trait_of_item(did) == Some(iter_id) => {
-                    if let Some((Constant::Int(idx), _)) = constant(cx, cx.typeck_results(), idx_expr) {
-                        let span = if name.ident.as_str() == "nth" {
-                            e.span
-                        } else {
-                            if_chain! {
-                                if let Some((_, Node::Expr(next_expr))) = iter.next();
-                                if let ExprKind::MethodCall(next_name, _, [_], _) = next_expr.kind;
-                                if next_name.ident.name == sym::next;
-                                if next_expr.span.ctxt() == ctxt;
-                                if let Some(next_id) = cx.typeck_results().type_dependent_def_id(next_expr.hir_id);
-                                if cx.tcx.trait_of_item(next_id) == Some(iter_id);
-                                then {
-                                    next_expr.span
-                                } else {
-                                    return None;
-                                }
-                            }
-                        };
-                        match if reverse { idx ^ 1 } else { idx } {
-                            0 => (IterUsageKind::Next, span),
-                            1 => (IterUsageKind::Second, span),
-                            _ => return None,
-                        }
-                    } else {
-                        return None;
-                    }
-                },
-                _ => return None,
-            }
-        },
-        _ => return None,
-    };
-
-    let (unwrap_kind, span) = if let Some((_, Node::Expr(e))) = iter.next() {
-        match e.kind {
-            ExprKind::Call(
-                Expr {
-                    kind: ExprKind::Path(QPath::LangItem(LangItem::TryTraitBranch, _)),
-                    ..
-                },
-                _,
-            ) => {
-                let parent_span = e.span.parent_callsite().unwrap();
-                if parent_span.ctxt() == ctxt {
-                    (Some(UnwrapKind::QuestionMark), parent_span)
-                } else {
-                    (None, span)
-                }
-            },
-            _ if e.span.ctxt() != ctxt => (None, span),
-            ExprKind::MethodCall(name, _, [_], _)
-                if name.ident.name == sym::unwrap
-                    && cx
-                        .typeck_results()
-                        .type_dependent_def_id(e.hir_id)
-                        .map_or(false, |id| is_diag_item_method(cx, id, sym::Option)) =>
-            {
-                (Some(UnwrapKind::Unwrap), e.span)
-            },
-            _ => (None, span),
-        }
-    } else {
-        (None, span)
-    };
-
-    Some(IterUsage {
-        kind,
-        unwrap_kind,
-        span,
-    })
-}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 26c29fbb289..d36d84c9c43 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -33,7 +33,6 @@ mod iter_nth_zero;
 mod iter_skip_next;
 mod iterator_step_by_zero;
 mod manual_saturating_arithmetic;
-mod manual_split_once;
 mod manual_str_repeat;
 mod map_collect_result_unit;
 mod map_flatten;
@@ -50,6 +49,7 @@ mod single_char_insert_string;
 mod single_char_pattern;
 mod single_char_push_string;
 mod skip_while_next;
+mod str_splitn;
 mod string_extend_chars;
 mod suspicious_map;
 mod suspicious_splitn;
@@ -1798,6 +1798,30 @@ declare_clippy_lint! {
     "replace `.splitn(2, pat)` with `.split_once(pat)`"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usages of `str::splitn` (or `str::rsplitn`) where using `str::split` would be the same.
+    /// ### Why is this bad?
+    /// The function `split` is simpler and there is no performance difference in these cases, considering
+    /// that both functions return a lazy iterator.
+    /// ### Example
+    /// ```rust
+    /// // Bad
+    /// let str = "key=value=add";
+    /// let _ = str.splitn(3, '=').next().unwrap();
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// // Good
+    /// let str = "key=value=add";
+    /// let _ = str.split('=').next().unwrap();
+    /// ```
+    #[clippy::version = "1.58.0"]
+    pub NEEDLESS_SPLITN,
+    complexity,
+    "usages of `str::splitn` that can be replaced with `str::split`"
+}
+
 pub struct Methods {
     avoid_breaking_exported_api: bool,
     msrv: Option<RustcVersion>,
@@ -1876,7 +1900,8 @@ impl_lint_pass!(Methods => [
     SUSPICIOUS_SPLITN,
     MANUAL_STR_REPEAT,
     EXTEND_WITH_DRAIN,
-    MANUAL_SPLIT_ONCE
+    MANUAL_SPLIT_ONCE,
+    NEEDLESS_SPLITN
 ]);
 
 /// Extracts a method call name, args, and `Span` of the method name.
@@ -2208,7 +2233,10 @@ fn check_methods<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, msrv: Optio
                 if let Some((Constant::Int(count), _)) = constant(cx, cx.typeck_results(), count_arg) {
                     suspicious_splitn::check(cx, name, expr, recv, count);
                     if count == 2 && meets_msrv(msrv, &msrvs::STR_SPLIT_ONCE) {
-                        manual_split_once::check(cx, name, expr, recv, pat_arg);
+                        str_splitn::check_manual_split_once(cx, name, expr, recv, pat_arg);
+                    }
+                    if count >= 2 {
+                        str_splitn::check_needless_splitn(cx, name, expr, recv, pat_arg, count);
                     }
                 }
             },
diff --git a/clippy_lints/src/methods/str_splitn.rs b/clippy_lints/src/methods/str_splitn.rs
new file mode 100644
index 00000000000..2595f734f11
--- /dev/null
+++ b/clippy_lints/src/methods/str_splitn.rs
@@ -0,0 +1,323 @@
+use clippy_utils::consts::{constant, Constant};
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet_with_context;
+use clippy_utils::{is_diag_item_method, match_def_path, paths};
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind, HirId, LangItem, Node, QPath};
+use rustc_lint::LateContext;
+use rustc_middle::ty::{self, adjustment::Adjust};
+use rustc_span::{symbol::sym, Span, SyntaxContext};
+
+use super::MANUAL_SPLIT_ONCE;
+
+pub(super) fn check_manual_split_once(
+    cx: &LateContext<'_>,
+    method_name: &str,
+    expr: &Expr<'_>,
+    self_arg: &Expr<'_>,
+    pat_arg: &Expr<'_>,
+) {
+    if !cx.typeck_results().expr_ty_adjusted(self_arg).peel_refs().is_str() {
+        return;
+    }
+
+    let ctxt = expr.span.ctxt();
+    let (method_name, msg, reverse) = if method_name == "splitn" {
+        ("split_once", "manual implementation of `split_once`", false)
+    } else {
+        ("rsplit_once", "manual implementation of `rsplit_once`", true)
+    };
+    let usage = match parse_iter_usage(cx, ctxt, cx.tcx.hir().parent_iter(expr.hir_id), reverse) {
+        Some(x) => x,
+        None => return,
+    };
+
+    let mut app = Applicability::MachineApplicable;
+    let self_snip = snippet_with_context(cx, self_arg.span, ctxt, "..", &mut app).0;
+    let pat_snip = snippet_with_context(cx, pat_arg.span, ctxt, "..", &mut app).0;
+
+    let sugg = match usage.kind {
+        IterUsageKind::NextTuple => {
+            format!("{}.{}({})", self_snip, method_name, pat_snip)
+        },
+        IterUsageKind::RNextTuple => format!("{}.{}({}).map(|(x, y)| (y, x))", self_snip, method_name, pat_snip),
+        IterUsageKind::Next | IterUsageKind::Second => {
+            let self_deref = {
+                let adjust = cx.typeck_results().expr_adjustments(self_arg);
+                if adjust.is_empty() {
+                    String::new()
+                } else if cx.typeck_results().expr_ty(self_arg).is_box()
+                    || adjust
+                        .iter()
+                        .any(|a| matches!(a.kind, Adjust::Deref(Some(_))) || a.target.is_box())
+                {
+                    format!("&{}", "*".repeat(adjust.len() - 1))
+                } else {
+                    "*".repeat(adjust.len() - 2)
+                }
+            };
+            if matches!(usage.kind, IterUsageKind::Next) {
+                match usage.unwrap_kind {
+                    Some(UnwrapKind::Unwrap) => {
+                        if reverse {
+                            format!("{}.{}({}).unwrap().0", self_snip, method_name, pat_snip)
+                        } else {
+                            format!(
+                                "{}.{}({}).map_or({}{}, |x| x.0)",
+                                self_snip, method_name, pat_snip, self_deref, &self_snip
+                            )
+                        }
+                    },
+                    Some(UnwrapKind::QuestionMark) => {
+                        format!(
+                            "{}.{}({}).map_or({}{}, |x| x.0)",
+                            self_snip, method_name, pat_snip, self_deref, &self_snip
+                        )
+                    },
+                    None => {
+                        format!(
+                            "Some({}.{}({}).map_or({}{}, |x| x.0))",
+                            &self_snip, method_name, pat_snip, self_deref, &self_snip
+                        )
+                    },
+                }
+            } else {
+                match usage.unwrap_kind {
+                    Some(UnwrapKind::Unwrap) => {
+                        if reverse {
+                            // In this case, no better suggestion is offered.
+                            return;
+                        }
+                        format!("{}.{}({}).unwrap().1", self_snip, method_name, pat_snip)
+                    },
+                    Some(UnwrapKind::QuestionMark) => {
+                        format!("{}.{}({})?.1", self_snip, method_name, pat_snip)
+                    },
+                    None => {
+                        format!("{}.{}({}).map(|x| x.1)", self_snip, method_name, pat_snip)
+                    },
+                }
+            }
+        },
+    };
+
+    span_lint_and_sugg(cx, MANUAL_SPLIT_ONCE, usage.span, msg, "try this", sugg, app);
+}
+
+enum IterUsageKind {
+    Next,
+    Second,
+    NextTuple,
+    RNextTuple,
+}
+
+enum UnwrapKind {
+    Unwrap,
+    QuestionMark,
+}
+
+struct IterUsage {
+    kind: IterUsageKind,
+    unwrap_kind: Option<UnwrapKind>,
+    span: Span,
+}
+
+#[allow(clippy::too_many_lines)]
+fn parse_iter_usage(
+    cx: &LateContext<'tcx>,
+    ctxt: SyntaxContext,
+    mut iter: impl Iterator<Item = (HirId, Node<'tcx>)>,
+    reverse: bool,
+) -> Option<IterUsage> {
+    let (kind, span) = match iter.next() {
+        Some((_, Node::Expr(e))) if e.span.ctxt() == ctxt => {
+            let (name, args) = if let ExprKind::MethodCall(name, _, [_, args @ ..], _) = e.kind {
+                (name, args)
+            } else {
+                return None;
+            };
+            let did = cx.typeck_results().type_dependent_def_id(e.hir_id)?;
+            let iter_id = cx.tcx.get_diagnostic_item(sym::Iterator)?;
+
+            match (&*name.ident.as_str(), args) {
+                ("next", []) if cx.tcx.trait_of_item(did) == Some(iter_id) => {
+                    if reverse {
+                        (IterUsageKind::Second, e.span)
+                    } else {
+                        (IterUsageKind::Next, e.span)
+                    }
+                },
+                ("next_tuple", []) => {
+                    return if_chain! {
+                        if match_def_path(cx, did, &paths::ITERTOOLS_NEXT_TUPLE);
+                        if let ty::Adt(adt_def, subs) = cx.typeck_results().expr_ty(e).kind();
+                        if cx.tcx.is_diagnostic_item(sym::Option, adt_def.did);
+                        if let ty::Tuple(subs) = subs.type_at(0).kind();
+                        if subs.len() == 2;
+                        then {
+                            Some(IterUsage {
+                                kind: if reverse { IterUsageKind::RNextTuple } else { IterUsageKind::NextTuple },
+                                span: e.span,
+                                unwrap_kind: None
+                            })
+                        } else {
+                            None
+                        }
+                    };
+                },
+                ("nth" | "skip", [idx_expr]) if cx.tcx.trait_of_item(did) == Some(iter_id) => {
+                    if let Some((Constant::Int(idx), _)) = constant(cx, cx.typeck_results(), idx_expr) {
+                        let span = if name.ident.as_str() == "nth" {
+                            e.span
+                        } else {
+                            if_chain! {
+                                if let Some((_, Node::Expr(next_expr))) = iter.next();
+                                if let ExprKind::MethodCall(next_name, _, [_], _) = next_expr.kind;
+                                if next_name.ident.name == sym::next;
+                                if next_expr.span.ctxt() == ctxt;
+                                if let Some(next_id) = cx.typeck_results().type_dependent_def_id(next_expr.hir_id);
+                                if cx.tcx.trait_of_item(next_id) == Some(iter_id);
+                                then {
+                                    next_expr.span
+                                } else {
+                                    return None;
+                                }
+                            }
+                        };
+                        match if reverse { idx ^ 1 } else { idx } {
+                            0 => (IterUsageKind::Next, span),
+                            1 => (IterUsageKind::Second, span),
+                            _ => return None,
+                        }
+                    } else {
+                        return None;
+                    }
+                },
+                _ => return None,
+            }
+        },
+        _ => return None,
+    };
+
+    let (unwrap_kind, span) = if let Some((_, Node::Expr(e))) = iter.next() {
+        match e.kind {
+            ExprKind::Call(
+                Expr {
+                    kind: ExprKind::Path(QPath::LangItem(LangItem::TryTraitBranch, _)),
+                    ..
+                },
+                _,
+            ) => {
+                let parent_span = e.span.parent_callsite().unwrap();
+                if parent_span.ctxt() == ctxt {
+                    (Some(UnwrapKind::QuestionMark), parent_span)
+                } else {
+                    (None, span)
+                }
+            },
+            _ if e.span.ctxt() != ctxt => (None, span),
+            ExprKind::MethodCall(name, _, [_], _)
+                if name.ident.name == sym::unwrap
+                    && cx
+                        .typeck_results()
+                        .type_dependent_def_id(e.hir_id)
+                        .map_or(false, |id| is_diag_item_method(cx, id, sym::Option)) =>
+            {
+                (Some(UnwrapKind::Unwrap), e.span)
+            },
+            _ => (None, span),
+        }
+    } else {
+        (None, span)
+    };
+
+    Some(IterUsage {
+        kind,
+        unwrap_kind,
+        span,
+    })
+}
+
+use super::NEEDLESS_SPLITN;
+
+pub(super) fn check_needless_splitn(
+    cx: &LateContext<'_>,
+    method_name: &str,
+    expr: &Expr<'_>,
+    self_arg: &Expr<'_>,
+    pat_arg: &Expr<'_>,
+    count: u128,
+) {
+    if !cx.typeck_results().expr_ty_adjusted(self_arg).peel_refs().is_str() {
+        return;
+    }
+    let ctxt = expr.span.ctxt();
+    let mut app = Applicability::MachineApplicable;
+    let (reverse, message) = if method_name == "splitn" {
+        (false, "unnecessary use of `splitn`")
+    } else {
+        (true, "unnecessary use of `rsplitn`")
+    };
+    if_chain! {
+        if count >= 2;
+        if check_iter(cx, ctxt, cx.tcx.hir().parent_iter(expr.hir_id), count);
+        then {
+            span_lint_and_sugg(
+                cx,
+                NEEDLESS_SPLITN,
+                expr.span,
+                message,
+                "try this",
+                format!(
+                    "{}.{}({})",
+                    snippet_with_context(cx, self_arg.span, ctxt, "..", &mut app).0,
+                    if reverse {"rsplit"} else {"split"},
+                    snippet_with_context(cx, pat_arg.span, ctxt, "..", &mut app).0
+                ),
+                app,
+            );
+        }
+    }
+}
+
+fn check_iter(
+    cx: &LateContext<'tcx>,
+    ctxt: SyntaxContext,
+    mut iter: impl Iterator<Item = (HirId, Node<'tcx>)>,
+    count: u128,
+) -> bool {
+    match iter.next() {
+        Some((_, Node::Expr(e))) if e.span.ctxt() == ctxt => {
+            let (name, args) = if let ExprKind::MethodCall(name, _, [_, args @ ..], _) = e.kind {
+                (name, args)
+            } else {
+                return false;
+            };
+            if_chain! {
+                if let Some(did) = cx.typeck_results().type_dependent_def_id(e.hir_id);
+                if let Some(iter_id) = cx.tcx.get_diagnostic_item(sym::Iterator);
+                then {
+                    match (&*name.ident.as_str(), args) {
+                        ("next", []) if cx.tcx.trait_of_item(did) == Some(iter_id) => {
+                            return true;
+                        },
+                        ("next_tuple", []) if count > 2 => {
+                            return true;
+                        },
+                        ("nth", [idx_expr]) if cx.tcx.trait_of_item(did) == Some(iter_id) => {
+                            if let Some((Constant::Int(idx), _)) = constant(cx, cx.typeck_results(), idx_expr) {
+                                if count > idx + 1 {
+                                    return true;
+                                }
+                            }
+                        },
+                        _ =>  return false,
+                    }
+                }
+            }
+        },
+        _ => return false,
+    };
+    false
+}
diff --git a/tests/ui/manual_split_once.fixed b/tests/ui/manual_split_once.fixed
index 992baf1f185..d5113df569a 100644
--- a/tests/ui/manual_split_once.fixed
+++ b/tests/ui/manual_split_once.fixed
@@ -2,7 +2,7 @@
 
 #![feature(custom_inner_attributes)]
 #![warn(clippy::manual_split_once)]
-#![allow(clippy::iter_skip_next, clippy::iter_nth_zero)]
+#![allow(clippy::iter_skip_next, clippy::iter_nth_zero, clippy::needless_splitn)]
 
 extern crate itertools;
 
@@ -38,8 +38,8 @@ fn main() {
     let _ = [0, 1, 2].splitn(2, |&x| x == 1).nth(1).unwrap();
 
     // `rsplitn` gives the results in the reverse order of `rsplit_once`
-    let _ = "key=value".rsplit_once('=').unwrap().1;
-    let _ = "key=value".rsplit_once('=').map_or("key=value", |x| x.0);
+    let _ = "key=value".rsplitn(2, '=').next().unwrap();
+    let _ = "key=value".rsplit_once('=').unwrap().0;
     let _ = "key=value".rsplit_once('=').map(|x| x.1);
     let (_, _) = "key=value".rsplit_once('=').map(|(x, y)| (y, x)).unwrap();
 }
diff --git a/tests/ui/manual_split_once.rs b/tests/ui/manual_split_once.rs
index 4f92ab6b812..80e02952dbd 100644
--- a/tests/ui/manual_split_once.rs
+++ b/tests/ui/manual_split_once.rs
@@ -2,7 +2,7 @@
 
 #![feature(custom_inner_attributes)]
 #![warn(clippy::manual_split_once)]
-#![allow(clippy::iter_skip_next, clippy::iter_nth_zero)]
+#![allow(clippy::iter_skip_next, clippy::iter_nth_zero, clippy::needless_splitn)]
 
 extern crate itertools;
 
diff --git a/tests/ui/manual_split_once.stderr b/tests/ui/manual_split_once.stderr
index 7bea2303d92..af9c7a2d41b 100644
--- a/tests/ui/manual_split_once.stderr
+++ b/tests/ui/manual_split_once.stderr
@@ -72,17 +72,11 @@ error: manual implementation of `split_once`
 LL |         let _ = s.splitn(2, "key=value").skip(1).next()?;
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `s.split_once("key=value")?.1`
 
-error: manual implementation of `rsplit_once`
-  --> $DIR/manual_split_once.rs:41:13
-   |
-LL |     let _ = "key=value".rsplitn(2, '=').next().unwrap();
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `"key=value".rsplit_once('=').unwrap().1`
-
 error: manual implementation of `rsplit_once`
   --> $DIR/manual_split_once.rs:42:13
    |
 LL |     let _ = "key=value".rsplitn(2, '=').nth(1).unwrap();
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `"key=value".rsplit_once('=').map_or("key=value", |x| x.0)`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `"key=value".rsplit_once('=').unwrap().0`
 
 error: manual implementation of `rsplit_once`
   --> $DIR/manual_split_once.rs:43:13
@@ -102,5 +96,5 @@ error: manual implementation of `split_once`
 LL |     let _ = "key=value".splitn(2, '=').nth(1).unwrap();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `"key=value".split_once('=').unwrap().1`
 
-error: aborting due to 17 previous errors
+error: aborting due to 16 previous errors
 
diff --git a/tests/ui/needless_splitn.fixed b/tests/ui/needless_splitn.fixed
new file mode 100644
index 00000000000..f6a4b2f17d3
--- /dev/null
+++ b/tests/ui/needless_splitn.fixed
@@ -0,0 +1,27 @@
+// run-rustfix
+// edition:2018
+
+#![feature(custom_inner_attributes)]
+#![warn(clippy::needless_splitn)]
+#![allow(clippy::iter_skip_next, clippy::iter_nth_zero, clippy::manual_split_once)]
+
+extern crate itertools;
+
+#[allow(unused_imports)]
+use itertools::Itertools;
+
+fn main() {
+    let str = "key=value=end";
+    let _ = str.split('=').next();
+    let _ = str.split('=').nth(0);
+    let _ = str.splitn(2, '=').nth(1);
+    let (_, _) = str.splitn(2, '=').next_tuple().unwrap();
+    let (_, _) = str.split('=').next_tuple().unwrap();
+    let _: Vec<&str> = str.splitn(3, '=').collect();
+
+    let _ = str.rsplit('=').next();
+    let _ = str.rsplit('=').nth(0);
+    let _ = str.rsplitn(2, '=').nth(1);
+    let (_, _) = str.rsplitn(2, '=').next_tuple().unwrap();
+    let (_, _) = str.rsplit('=').next_tuple().unwrap();
+}
diff --git a/tests/ui/needless_splitn.rs b/tests/ui/needless_splitn.rs
new file mode 100644
index 00000000000..6ba32255bb2
--- /dev/null
+++ b/tests/ui/needless_splitn.rs
@@ -0,0 +1,27 @@
+// run-rustfix
+// edition:2018
+
+#![feature(custom_inner_attributes)]
+#![warn(clippy::needless_splitn)]
+#![allow(clippy::iter_skip_next, clippy::iter_nth_zero, clippy::manual_split_once)]
+
+extern crate itertools;
+
+#[allow(unused_imports)]
+use itertools::Itertools;
+
+fn main() {
+    let str = "key=value=end";
+    let _ = str.splitn(2, '=').next();
+    let _ = str.splitn(2, '=').nth(0);
+    let _ = str.splitn(2, '=').nth(1);
+    let (_, _) = str.splitn(2, '=').next_tuple().unwrap();
+    let (_, _) = str.splitn(3, '=').next_tuple().unwrap();
+    let _: Vec<&str> = str.splitn(3, '=').collect();
+
+    let _ = str.rsplitn(2, '=').next();
+    let _ = str.rsplitn(2, '=').nth(0);
+    let _ = str.rsplitn(2, '=').nth(1);
+    let (_, _) = str.rsplitn(2, '=').next_tuple().unwrap();
+    let (_, _) = str.rsplitn(3, '=').next_tuple().unwrap();
+}
diff --git a/tests/ui/needless_splitn.stderr b/tests/ui/needless_splitn.stderr
new file mode 100644
index 00000000000..66de2256554
--- /dev/null
+++ b/tests/ui/needless_splitn.stderr
@@ -0,0 +1,40 @@
+error: unnecessary use of `splitn`
+  --> $DIR/needless_splitn.rs:15:13
+   |
+LL |     let _ = str.splitn(2, '=').next();
+   |             ^^^^^^^^^^^^^^^^^^ help: try this: `str.split('=')`
+   |
+   = note: `-D clippy::needless-splitn` implied by `-D warnings`
+
+error: unnecessary use of `splitn`
+  --> $DIR/needless_splitn.rs:16:13
+   |
+LL |     let _ = str.splitn(2, '=').nth(0);
+   |             ^^^^^^^^^^^^^^^^^^ help: try this: `str.split('=')`
+
+error: unnecessary use of `splitn`
+  --> $DIR/needless_splitn.rs:19:18
+   |
+LL |     let (_, _) = str.splitn(3, '=').next_tuple().unwrap();
+   |                  ^^^^^^^^^^^^^^^^^^ help: try this: `str.split('=')`
+
+error: unnecessary use of `rsplitn`
+  --> $DIR/needless_splitn.rs:22:13
+   |
+LL |     let _ = str.rsplitn(2, '=').next();
+   |             ^^^^^^^^^^^^^^^^^^^ help: try this: `str.rsplit('=')`
+
+error: unnecessary use of `rsplitn`
+  --> $DIR/needless_splitn.rs:23:13
+   |
+LL |     let _ = str.rsplitn(2, '=').nth(0);
+   |             ^^^^^^^^^^^^^^^^^^^ help: try this: `str.rsplit('=')`
+
+error: unnecessary use of `rsplitn`
+  --> $DIR/needless_splitn.rs:26:18
+   |
+LL |     let (_, _) = str.rsplitn(3, '=').next_tuple().unwrap();
+   |                  ^^^^^^^^^^^^^^^^^^^ help: try this: `str.rsplit('=')`
+
+error: aborting due to 6 previous errors
+
diff --git a/tests/ui/suspicious_splitn.rs b/tests/ui/suspicious_splitn.rs
index a21d94cf20b..528f2ddcc86 100644
--- a/tests/ui/suspicious_splitn.rs
+++ b/tests/ui/suspicious_splitn.rs
@@ -1,4 +1,5 @@
 #![warn(clippy::suspicious_splitn)]
+#![allow(clippy::needless_splitn)]
 
 fn main() {
     let _ = "a,b,c".splitn(3, ',');
diff --git a/tests/ui/suspicious_splitn.stderr b/tests/ui/suspicious_splitn.stderr
index b6220ae2393..3bcd681fa49 100644
--- a/tests/ui/suspicious_splitn.stderr
+++ b/tests/ui/suspicious_splitn.stderr
@@ -1,5 +1,5 @@
 error: `splitn` called with `0` splits
-  --> $DIR/suspicious_splitn.rs:9:13
+  --> $DIR/suspicious_splitn.rs:10:13
    |
 LL |     let _ = "a,b".splitn(0, ',');
    |             ^^^^^^^^^^^^^^^^^^^^
@@ -8,7 +8,7 @@ LL |     let _ = "a,b".splitn(0, ',');
    = note: the resulting iterator will always return `None`
 
 error: `rsplitn` called with `0` splits
-  --> $DIR/suspicious_splitn.rs:10:13
+  --> $DIR/suspicious_splitn.rs:11:13
    |
 LL |     let _ = "a,b".rsplitn(0, ',');
    |             ^^^^^^^^^^^^^^^^^^^^^
@@ -16,7 +16,7 @@ LL |     let _ = "a,b".rsplitn(0, ',');
    = note: the resulting iterator will always return `None`
 
 error: `splitn` called with `1` split
-  --> $DIR/suspicious_splitn.rs:11:13
+  --> $DIR/suspicious_splitn.rs:12:13
    |
 LL |     let _ = "a,b".splitn(1, ',');
    |             ^^^^^^^^^^^^^^^^^^^^
@@ -24,7 +24,7 @@ LL |     let _ = "a,b".splitn(1, ',');
    = note: the resulting iterator will always return the entire string followed by `None`
 
 error: `splitn` called with `0` splits
-  --> $DIR/suspicious_splitn.rs:12:13
+  --> $DIR/suspicious_splitn.rs:13:13
    |
 LL |     let _ = [0, 1, 2].splitn(0, |&x| x == 1);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -32,7 +32,7 @@ LL |     let _ = [0, 1, 2].splitn(0, |&x| x == 1);
    = note: the resulting iterator will always return `None`
 
 error: `splitn_mut` called with `0` splits
-  --> $DIR/suspicious_splitn.rs:13:13
+  --> $DIR/suspicious_splitn.rs:14:13
    |
 LL |     let _ = [0, 1, 2].splitn_mut(0, |&x| x == 1);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -40,7 +40,7 @@ LL |     let _ = [0, 1, 2].splitn_mut(0, |&x| x == 1);
    = note: the resulting iterator will always return `None`
 
 error: `splitn` called with `1` split
-  --> $DIR/suspicious_splitn.rs:14:13
+  --> $DIR/suspicious_splitn.rs:15:13
    |
 LL |     let _ = [0, 1, 2].splitn(1, |&x| x == 1);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -48,7 +48,7 @@ LL |     let _ = [0, 1, 2].splitn(1, |&x| x == 1);
    = note: the resulting iterator will always return the entire slice followed by `None`
 
 error: `rsplitn_mut` called with `1` split
-  --> $DIR/suspicious_splitn.rs:15:13
+  --> $DIR/suspicious_splitn.rs:16:13
    |
 LL |     let _ = [0, 1, 2].rsplitn_mut(1, |&x| x == 1);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -56,7 +56,7 @@ LL |     let _ = [0, 1, 2].rsplitn_mut(1, |&x| x == 1);
    = note: the resulting iterator will always return the entire slice followed by `None`
 
 error: `splitn` called with `1` split
-  --> $DIR/suspicious_splitn.rs:18:13
+  --> $DIR/suspicious_splitn.rs:19:13
    |
 LL |     let _ = "a,b".splitn(X + 1, ',');
    |             ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -64,7 +64,7 @@ LL |     let _ = "a,b".splitn(X + 1, ',');
    = note: the resulting iterator will always return the entire string followed by `None`
 
 error: `splitn` called with `0` splits
-  --> $DIR/suspicious_splitn.rs:19:13
+  --> $DIR/suspicious_splitn.rs:20:13
    |
 LL |     let _ = "a,b".splitn(X, ',');
    |             ^^^^^^^^^^^^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From 3f3d7c20052e3fd4bcebbb5d32ebc1fa33cf33a7 Mon Sep 17 00:00:00 2001
From: Takayuki Nakata <f.seasons017@gmail.com>
Date: Wed, 17 Nov 2021 22:35:01 +0900
Subject: Fix ICE on `undocumented_unsafe_blocks`

---
 clippy_lints/src/undocumented_unsafe_blocks.rs |  4 ++--
 tests/ui/undocumented_unsafe_blocks.rs         |  4 ++++
 tests/ui/undocumented_unsafe_blocks.stderr     | 14 +++++++++++++-
 3 files changed, 19 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/undocumented_unsafe_blocks.rs b/clippy_lints/src/undocumented_unsafe_blocks.rs
index c886faf5d28..ccc49caf47c 100644
--- a/clippy_lints/src/undocumented_unsafe_blocks.rs
+++ b/clippy_lints/src/undocumented_unsafe_blocks.rs
@@ -137,10 +137,10 @@ impl UndocumentedUnsafeBlocks {
 
         let between_span = if block_span.from_expansion() {
             self.macro_expansion = true;
-            enclosing_scope_span.with_hi(block_span.hi())
+            enclosing_scope_span.with_hi(block_span.hi()).source_callsite()
         } else {
             self.macro_expansion = false;
-            enclosing_scope_span.to(block_span)
+            enclosing_scope_span.to(block_span).source_callsite()
         };
 
         let file_name = source_map.span_to_filename(between_span);
diff --git a/tests/ui/undocumented_unsafe_blocks.rs b/tests/ui/undocumented_unsafe_blocks.rs
index 52577323a58..7e510d89475 100644
--- a/tests/ui/undocumented_unsafe_blocks.rs
+++ b/tests/ui/undocumented_unsafe_blocks.rs
@@ -284,4 +284,8 @@ fn interference() {
     unsafe {};
 }
 
+pub fn print_binary_tree() {
+    println!("{}", unsafe { String::from_utf8_unchecked(vec![]) });
+}
+
 fn main() {}
diff --git a/tests/ui/undocumented_unsafe_blocks.stderr b/tests/ui/undocumented_unsafe_blocks.stderr
index 613e9ffca45..ebe589001a1 100644
--- a/tests/ui/undocumented_unsafe_blocks.stderr
+++ b/tests/ui/undocumented_unsafe_blocks.stderr
@@ -155,5 +155,17 @@ LL ~     // Safety: ...
 LL ~     unsafe {};
    |
 
-error: aborting due to 13 previous errors
+error: unsafe block missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:288:20
+   |
+LL |     println!("{}", unsafe { String::from_utf8_unchecked(vec![]) });
+   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider adding a safety comment
+   |
+LL ~     println!("{}", // Safety: ...
+LL ~     unsafe { String::from_utf8_unchecked(vec![]) });
+   |
+
+error: aborting due to 14 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 006c4426577bf243f7218f951d0c9ada6b4fe737 Mon Sep 17 00:00:00 2001
From: togami2864 <tuabobo123@gmail.com>
Date: Thu, 18 Nov 2021 00:36:11 +0900
Subject: check whether stmts is empty or not in block

---
 clippy_lints/src/methods/option_map_or_none.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/option_map_or_none.rs b/clippy_lints/src/methods/option_map_or_none.rs
index b5652838892..5e5c1038e82 100644
--- a/clippy_lints/src/methods/option_map_or_none.rs
+++ b/clippy_lints/src/methods/option_map_or_none.rs
@@ -20,8 +20,8 @@ fn reduce_unit_expression<'a>(
     match expr.kind {
         hir::ExprKind::Call(func, arg_char) => Some((func, arg_char)),
         hir::ExprKind::Block(block, _) => {
-            match block.expr {
-                Some(inner_expr) => {
+            match (block.stmts, block.expr) {
+                (&[], Some(inner_expr)) => {
                     // If block only contains an expression,
                     // reduce `|x| { x + 1 }` to `|x| x + 1`
                     reduce_unit_expression(cx, inner_expr)
-- 
cgit 1.4.1-3-g733a5


From 8506f662942a689c5f217b1c82eff45a06fb9f37 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Wed, 17 Nov 2021 10:36:13 -0500
Subject: Minor simplification to `manual_map`

---
 clippy_lints/src/manual_map.rs | 29 +++++++----------------------
 1 file changed, 7 insertions(+), 22 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_map.rs b/clippy_lints/src/manual_map.rs
index 6234932363f..4d8ad566e6b 100644
--- a/clippy_lints/src/manual_map.rs
+++ b/clippy_lints/src/manual_map.rs
@@ -179,37 +179,22 @@ impl LateLintPass<'_> for ManualMap {
                     } else {
                         ""
                     };
+                    let expr_snip = snippet_with_context(cx, some_expr.expr.span, expr_ctxt, "..", &mut app).0;
                     if some_expr.needs_unsafe_block {
-                        format!(
-                            "|{}{}| unsafe {{ {} }}",
-                            annotation,
-                            some_binding,
-                            snippet_with_context(cx, some_expr.expr.span, expr_ctxt, "..", &mut app).0
-                        )
+                        format!("|{}{}| unsafe {{ {} }}", annotation, some_binding, expr_snip)
                     } else {
-                        format!(
-                            "|{}{}| {}",
-                            annotation,
-                            some_binding,
-                            snippet_with_context(cx, some_expr.expr.span, expr_ctxt, "..", &mut app).0
-                        )
+                        format!("|{}{}| {}", annotation, some_binding, expr_snip)
                     }
                 }
             }
         } else if !is_wild_none && explicit_ref.is_none() {
             // TODO: handle explicit reference annotations.
+            let pat_snip = snippet_with_context(cx, some_pat.span, expr_ctxt, "..", &mut app).0;
+            let expr_snip = snippet_with_context(cx, some_expr.expr.span, expr_ctxt, "..", &mut app).0;
             if some_expr.needs_unsafe_block {
-                format!(
-                    "|{}| unsafe {{ {} }}",
-                    snippet_with_context(cx, some_pat.span, expr_ctxt, "..", &mut app).0,
-                    snippet_with_context(cx, some_expr.expr.span, expr_ctxt, "..", &mut app).0
-                )
+                format!("|{}| unsafe {{ {} }}", pat_snip, expr_snip)
             } else {
-                format!(
-                    "|{}| {}",
-                    snippet_with_context(cx, some_pat.span, expr_ctxt, "..", &mut app).0,
-                    snippet_with_context(cx, some_expr.expr.span, expr_ctxt, "..", &mut app).0
-                )
+                format!("|{}| {}", pat_snip, expr_snip)
             }
         } else {
             // Refutable bindings and mixed reference annotations can't be handled by `map`.
-- 
cgit 1.4.1-3-g733a5


From b7f18916fa46c6ed25aed3b27e149850864b1f0e Mon Sep 17 00:00:00 2001
From: Philipp Hansch <dev@phansch.net>
Date: Wed, 17 Nov 2021 07:39:21 +0100
Subject: Pluralize disallowed_type lint

This was brought up in [Zulip] and is also mentioned in the lint naming
conventions. Since this is still a nursery lint, I think there shouldn't
be any problem in renaming it.

[Zulip]: https://rust-lang.zulipchat.com/#narrow/stream/257328-clippy/topic/disallow_type.20vs.20disallowed-types
---
 CHANGELOG.md                                       |  8 +--
 clippy_lints/src/disallowed_type.rs                | 14 ++---
 clippy_lints/src/lib.register_lints.rs             |  2 +-
 clippy_lints/src/lib.register_nursery.rs           |  2 +-
 clippy_lints/src/lib.rs                            |  3 +-
 clippy_lints/src/utils/conf.rs                     |  4 +-
 .../toml_disallowed_type/conf_disallowed_type.rs   |  2 +-
 .../conf_disallowed_type.stderr                    |  2 +-
 tests/ui/rename.fixed                              |  2 +
 tests/ui/rename.rs                                 |  2 +
 tests/ui/rename.stderr                             | 68 ++++++++++++----------
 11 files changed, 60 insertions(+), 49 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index f6bbcbdad89..e21e550ede2 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -174,7 +174,7 @@ Current stable, released 2021-10-21
 
 * [`needless_continue`]: Now also lints in `loop { continue; }` case
   [#7477](https://github.com/rust-lang/rust-clippy/pull/7477)
-* [`disallowed_type`]: Now also primitive types can be disallowed
+* [`disallowed_types`]: Now also primitive types can be disallowed
   [#7488](https://github.com/rust-lang/rust-clippy/pull/7488)
 * [`manual_swap`]: Now also lints on xor swaps
   [#7506](https://github.com/rust-lang/rust-clippy/pull/7506)
@@ -248,7 +248,7 @@ Released 2021-09-09
   [#7403](https://github.com/rust-lang/rust-clippy/pull/7403)
 * [`disallowed_script_idents`]
   [#7400](https://github.com/rust-lang/rust-clippy/pull/7400)
-* [`disallowed_type`]
+* [`disallowed_types`]
   [#7315](https://github.com/rust-lang/rust-clippy/pull/7315)
 * [`missing_enforced_import_renames`]
   [#7300](https://github.com/rust-lang/rust-clippy/pull/7300)
@@ -294,7 +294,7 @@ Released 2021-09-09
   [#7379](https://github.com/rust-lang/rust-clippy/pull/7379)
 * [`redundant_closure`]: Suggests `&mut` for `FnMut`
   [#7437](https://github.com/rust-lang/rust-clippy/pull/7437)
-* [`disallowed_method`], [`disallowed_type`]: The configuration values `disallowed-method` and `disallowed-type`
+* [`disallowed_method`], [`disallowed_types`]: The configuration values `disallowed-method` and `disallowed-type`
   no longer require fully qualified paths
   [#7345](https://github.com/rust-lang/rust-clippy/pull/7345)
 * [`zst_offset`]: Fixed lint invocation after it was accidentally suppressed
@@ -2823,7 +2823,7 @@ Released 2018-09-13
 [`derive_ord_xor_partial_ord`]: https://rust-lang.github.io/rust-clippy/master/index.html#derive_ord_xor_partial_ord
 [`disallowed_method`]: https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_method
 [`disallowed_script_idents`]: https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_script_idents
-[`disallowed_type`]: https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_type
+[`disallowed_types`]: https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_types
 [`diverging_sub_expression`]: https://rust-lang.github.io/rust-clippy/master/index.html#diverging_sub_expression
 [`doc_markdown`]: https://rust-lang.github.io/rust-clippy/master/index.html#doc_markdown
 [`double_comparisons`]: https://rust-lang.github.io/rust-clippy/master/index.html#double_comparisons
diff --git a/clippy_lints/src/disallowed_type.rs b/clippy_lints/src/disallowed_type.rs
index 7e784ca2244..eaed4032713 100644
--- a/clippy_lints/src/disallowed_type.rs
+++ b/clippy_lints/src/disallowed_type.rs
@@ -43,18 +43,18 @@ declare_clippy_lint! {
     /// use std::collections::HashMap;
     /// ```
     #[clippy::version = "1.55.0"]
-    pub DISALLOWED_TYPE,
+    pub DISALLOWED_TYPES,
     nursery,
-    "use of a disallowed type"
+    "use of disallowed types"
 }
 #[derive(Clone, Debug)]
-pub struct DisallowedType {
+pub struct DisallowedTypes {
     conf_disallowed: Vec<conf::DisallowedType>,
     def_ids: FxHashMap<DefId, Option<String>>,
     prim_tys: FxHashMap<PrimTy, Option<String>>,
 }
 
-impl DisallowedType {
+impl DisallowedTypes {
     pub fn new(conf_disallowed: Vec<conf::DisallowedType>) -> Self {
         Self {
             conf_disallowed,
@@ -80,9 +80,9 @@ impl DisallowedType {
     }
 }
 
-impl_lint_pass!(DisallowedType => [DISALLOWED_TYPE]);
+impl_lint_pass!(DisallowedTypes => [DISALLOWED_TYPES]);
 
-impl<'tcx> LateLintPass<'tcx> for DisallowedType {
+impl<'tcx> LateLintPass<'tcx> for DisallowedTypes {
     fn check_crate(&mut self, cx: &LateContext<'_>) {
         for conf in &self.conf_disallowed {
             let (path, reason) = match conf {
@@ -125,7 +125,7 @@ impl<'tcx> LateLintPass<'tcx> for DisallowedType {
 fn emit(cx: &LateContext<'_>, name: &str, span: Span, reason: Option<&str>) {
     span_lint_and_then(
         cx,
-        DISALLOWED_TYPE,
+        DISALLOWED_TYPES,
         span,
         &format!("`{}` is not allowed according to config", name),
         |diag| {
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index d931227765f..4a4fd76da07 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -99,7 +99,7 @@ store.register_lints(&[
     derive::UNSAFE_DERIVE_DESERIALIZE,
     disallowed_method::DISALLOWED_METHOD,
     disallowed_script_idents::DISALLOWED_SCRIPT_IDENTS,
-    disallowed_type::DISALLOWED_TYPE,
+    disallowed_type::DISALLOWED_TYPES,
     doc::DOC_MARKDOWN,
     doc::MISSING_ERRORS_DOC,
     doc::MISSING_PANICS_DOC,
diff --git a/clippy_lints/src/lib.register_nursery.rs b/clippy_lints/src/lib.register_nursery.rs
index cc0eb71be69..3adb9881a71 100644
--- a/clippy_lints/src/lib.register_nursery.rs
+++ b/clippy_lints/src/lib.register_nursery.rs
@@ -7,7 +7,7 @@ store.register_group(true, "clippy::nursery", Some("clippy_nursery"), vec![
     LintId::of(cognitive_complexity::COGNITIVE_COMPLEXITY),
     LintId::of(copies::BRANCHES_SHARING_CODE),
     LintId::of(disallowed_method::DISALLOWED_METHOD),
-    LintId::of(disallowed_type::DISALLOWED_TYPE),
+    LintId::of(disallowed_type::DISALLOWED_TYPES),
     LintId::of(equatable_if_let::EQUATABLE_IF_LET),
     LintId::of(fallible_impl_from::FALLIBLE_IMPL_FROM),
     LintId::of(floating_point_arithmetic::IMPRECISE_FLOPS),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 2445a0aeed0..d65ef3b8728 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -827,7 +827,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_early_pass(move || Box::new(module_style::ModStyle));
     store.register_late_pass(|| Box::new(unused_async::UnusedAsync));
     let disallowed_types = conf.disallowed_types.clone();
-    store.register_late_pass(move || Box::new(disallowed_type::DisallowedType::new(disallowed_types.clone())));
+    store.register_late_pass(move || Box::new(disallowed_type::DisallowedTypes::new(disallowed_types.clone())));
     let import_renames = conf.enforced_import_renames.clone();
     store.register_late_pass(move || {
         Box::new(missing_enforced_import_rename::ImportRename::new(
@@ -924,6 +924,7 @@ pub fn register_renamed(ls: &mut rustc_lint::LintStore) {
     ls.register_renamed("clippy::zero_width_space", "clippy::invisible_characters");
     ls.register_renamed("clippy::single_char_push_str", "clippy::single_char_add_str");
     ls.register_renamed("clippy::if_let_some_result", "clippy::match_result_ok");
+    ls.register_renamed("clippy::disallowed_type", "clippy::disallowed_types");
 
     // uplifted lints
     ls.register_renamed("clippy::invalid_ref", "invalid_value");
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 1a170807980..18e28cc4ca3 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -23,7 +23,7 @@ pub enum DisallowedMethod {
     WithReason { path: String, reason: Option<String> },
 }
 
-/// A single disallowed type, used by the `DISALLOWED_TYPE` lint.
+/// A single disallowed type, used by the `DISALLOWED_TYPES` lint.
 #[derive(Clone, Debug, Deserialize)]
 #[serde(untagged)]
 pub enum DisallowedType {
@@ -260,7 +260,7 @@ define_Conf! {
     ///
     /// The list of disallowed methods, written as fully qualified paths.
     (disallowed_methods: Vec<crate::utils::conf::DisallowedMethod> = Vec::new()),
-    /// Lint: DISALLOWED_TYPE.
+    /// Lint: DISALLOWED_TYPES.
     ///
     /// The list of disallowed types, written as fully qualified paths.
     (disallowed_types: Vec<crate::utils::conf::DisallowedType> = Vec::new()),
diff --git a/tests/ui-toml/toml_disallowed_type/conf_disallowed_type.rs b/tests/ui-toml/toml_disallowed_type/conf_disallowed_type.rs
index 410f0765055..7f28efd676f 100644
--- a/tests/ui-toml/toml_disallowed_type/conf_disallowed_type.rs
+++ b/tests/ui-toml/toml_disallowed_type/conf_disallowed_type.rs
@@ -1,4 +1,4 @@
-#![warn(clippy::disallowed_type)]
+#![warn(clippy::disallowed_types)]
 
 extern crate quote;
 extern crate syn;
diff --git a/tests/ui-toml/toml_disallowed_type/conf_disallowed_type.stderr b/tests/ui-toml/toml_disallowed_type/conf_disallowed_type.stderr
index 08a400a8367..25efd62d0ec 100644
--- a/tests/ui-toml/toml_disallowed_type/conf_disallowed_type.stderr
+++ b/tests/ui-toml/toml_disallowed_type/conf_disallowed_type.stderr
@@ -4,7 +4,7 @@ error: `std::sync::atomic::AtomicU32` is not allowed according to config
 LL | use std::sync::atomic::AtomicU32;
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = note: `-D clippy::disallowed-type` implied by `-D warnings`
+   = note: `-D clippy::disallowed-types` implied by `-D warnings`
 
 error: `std::time::Instant` is not allowed according to config
   --> $DIR/conf_disallowed_type.rs:8:1
diff --git a/tests/ui/rename.fixed b/tests/ui/rename.fixed
index cc295b509bc..2517eeeaa01 100644
--- a/tests/ui/rename.fixed
+++ b/tests/ui/rename.fixed
@@ -17,6 +17,7 @@
 #![allow(clippy::invisible_characters)]
 #![allow(clippy::single_char_add_str)]
 #![allow(clippy::match_result_ok)]
+#![allow(clippy::disallowed_types)]
 // uplifted lints
 #![allow(invalid_value)]
 #![allow(array_into_iter)]
@@ -49,6 +50,7 @@
 #![warn(clippy::invisible_characters)]
 #![warn(clippy::single_char_add_str)]
 #![warn(clippy::match_result_ok)]
+#![warn(clippy::disallowed_types)]
 // uplifted lints
 #![warn(invalid_value)]
 #![warn(array_into_iter)]
diff --git a/tests/ui/rename.rs b/tests/ui/rename.rs
index 377075c0246..7205ee0da8f 100644
--- a/tests/ui/rename.rs
+++ b/tests/ui/rename.rs
@@ -17,6 +17,7 @@
 #![allow(clippy::invisible_characters)]
 #![allow(clippy::single_char_add_str)]
 #![allow(clippy::match_result_ok)]
+#![allow(clippy::disallowed_types)]
 // uplifted lints
 #![allow(invalid_value)]
 #![allow(array_into_iter)]
@@ -49,6 +50,7 @@
 #![warn(clippy::zero_width_space)]
 #![warn(clippy::single_char_push_str)]
 #![warn(clippy::if_let_some_result)]
+#![warn(clippy::disallowed_type)]
 // uplifted lints
 #![warn(clippy::invalid_ref)]
 #![warn(clippy::into_iter_on_array)]
diff --git a/tests/ui/rename.stderr b/tests/ui/rename.stderr
index d720f10d117..1449112996f 100644
--- a/tests/ui/rename.stderr
+++ b/tests/ui/rename.stderr
@@ -1,5 +1,5 @@
 error: lint `clippy::stutter` has been renamed to `clippy::module_name_repetitions`
-  --> $DIR/rename.rs:31:9
+  --> $DIR/rename.rs:32:9
    |
 LL | #![warn(clippy::stutter)]
    |         ^^^^^^^^^^^^^^^ help: use the new name: `clippy::module_name_repetitions`
@@ -7,178 +7,184 @@ LL | #![warn(clippy::stutter)]
    = note: `-D renamed-and-removed-lints` implied by `-D warnings`
 
 error: lint `clippy::new_without_default_derive` has been renamed to `clippy::new_without_default`
-  --> $DIR/rename.rs:32:9
+  --> $DIR/rename.rs:33:9
    |
 LL | #![warn(clippy::new_without_default_derive)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::new_without_default`
 
 error: lint `clippy::const_static_lifetime` has been renamed to `clippy::redundant_static_lifetimes`
-  --> $DIR/rename.rs:33:9
+  --> $DIR/rename.rs:34:9
    |
 LL | #![warn(clippy::const_static_lifetime)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::redundant_static_lifetimes`
 
 error: lint `clippy::cyclomatic_complexity` has been renamed to `clippy::cognitive_complexity`
-  --> $DIR/rename.rs:34:9
+  --> $DIR/rename.rs:35:9
    |
 LL | #![warn(clippy::cyclomatic_complexity)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::cognitive_complexity`
 
 error: lint `clippy::option_and_then_some` has been renamed to `clippy::bind_instead_of_map`
-  --> $DIR/rename.rs:35:9
+  --> $DIR/rename.rs:36:9
    |
 LL | #![warn(clippy::option_and_then_some)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::bind_instead_of_map`
 
 error: lint `clippy::box_vec` has been renamed to `clippy::box_collection`
-  --> $DIR/rename.rs:36:9
+  --> $DIR/rename.rs:37:9
    |
 LL | #![warn(clippy::box_vec)]
    |         ^^^^^^^^^^^^^^^ help: use the new name: `clippy::box_collection`
 
 error: lint `clippy::block_in_if_condition_expr` has been renamed to `clippy::blocks_in_if_conditions`
-  --> $DIR/rename.rs:37:9
+  --> $DIR/rename.rs:38:9
    |
 LL | #![warn(clippy::block_in_if_condition_expr)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::blocks_in_if_conditions`
 
 error: lint `clippy::block_in_if_condition_stmt` has been renamed to `clippy::blocks_in_if_conditions`
-  --> $DIR/rename.rs:38:9
+  --> $DIR/rename.rs:39:9
    |
 LL | #![warn(clippy::block_in_if_condition_stmt)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::blocks_in_if_conditions`
 
 error: lint `clippy::option_map_unwrap_or` has been renamed to `clippy::map_unwrap_or`
-  --> $DIR/rename.rs:39:9
+  --> $DIR/rename.rs:40:9
    |
 LL | #![warn(clippy::option_map_unwrap_or)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::map_unwrap_or`
 
 error: lint `clippy::option_map_unwrap_or_else` has been renamed to `clippy::map_unwrap_or`
-  --> $DIR/rename.rs:40:9
+  --> $DIR/rename.rs:41:9
    |
 LL | #![warn(clippy::option_map_unwrap_or_else)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::map_unwrap_or`
 
 error: lint `clippy::result_map_unwrap_or_else` has been renamed to `clippy::map_unwrap_or`
-  --> $DIR/rename.rs:41:9
+  --> $DIR/rename.rs:42:9
    |
 LL | #![warn(clippy::result_map_unwrap_or_else)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::map_unwrap_or`
 
 error: lint `clippy::option_unwrap_used` has been renamed to `clippy::unwrap_used`
-  --> $DIR/rename.rs:42:9
+  --> $DIR/rename.rs:43:9
    |
 LL | #![warn(clippy::option_unwrap_used)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::unwrap_used`
 
 error: lint `clippy::result_unwrap_used` has been renamed to `clippy::unwrap_used`
-  --> $DIR/rename.rs:43:9
+  --> $DIR/rename.rs:44:9
    |
 LL | #![warn(clippy::result_unwrap_used)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::unwrap_used`
 
 error: lint `clippy::option_expect_used` has been renamed to `clippy::expect_used`
-  --> $DIR/rename.rs:44:9
+  --> $DIR/rename.rs:45:9
    |
 LL | #![warn(clippy::option_expect_used)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::expect_used`
 
 error: lint `clippy::result_expect_used` has been renamed to `clippy::expect_used`
-  --> $DIR/rename.rs:45:9
+  --> $DIR/rename.rs:46:9
    |
 LL | #![warn(clippy::result_expect_used)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::expect_used`
 
 error: lint `clippy::for_loop_over_option` has been renamed to `clippy::for_loops_over_fallibles`
-  --> $DIR/rename.rs:46:9
+  --> $DIR/rename.rs:47:9
    |
 LL | #![warn(clippy::for_loop_over_option)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::for_loops_over_fallibles`
 
 error: lint `clippy::for_loop_over_result` has been renamed to `clippy::for_loops_over_fallibles`
-  --> $DIR/rename.rs:47:9
+  --> $DIR/rename.rs:48:9
    |
 LL | #![warn(clippy::for_loop_over_result)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::for_loops_over_fallibles`
 
 error: lint `clippy::identity_conversion` has been renamed to `clippy::useless_conversion`
-  --> $DIR/rename.rs:48:9
+  --> $DIR/rename.rs:49:9
    |
 LL | #![warn(clippy::identity_conversion)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::useless_conversion`
 
 error: lint `clippy::zero_width_space` has been renamed to `clippy::invisible_characters`
-  --> $DIR/rename.rs:49:9
+  --> $DIR/rename.rs:50:9
    |
 LL | #![warn(clippy::zero_width_space)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::invisible_characters`
 
 error: lint `clippy::single_char_push_str` has been renamed to `clippy::single_char_add_str`
-  --> $DIR/rename.rs:50:9
+  --> $DIR/rename.rs:51:9
    |
 LL | #![warn(clippy::single_char_push_str)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::single_char_add_str`
 
 error: lint `clippy::if_let_some_result` has been renamed to `clippy::match_result_ok`
-  --> $DIR/rename.rs:51:9
+  --> $DIR/rename.rs:52:9
    |
 LL | #![warn(clippy::if_let_some_result)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::match_result_ok`
 
-error: lint `clippy::invalid_ref` has been renamed to `invalid_value`
+error: lint `clippy::disallowed_type` has been renamed to `clippy::disallowed_types`
   --> $DIR/rename.rs:53:9
    |
+LL | #![warn(clippy::disallowed_type)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::disallowed_types`
+
+error: lint `clippy::invalid_ref` has been renamed to `invalid_value`
+  --> $DIR/rename.rs:55:9
+   |
 LL | #![warn(clippy::invalid_ref)]
    |         ^^^^^^^^^^^^^^^^^^^ help: use the new name: `invalid_value`
 
 error: lint `clippy::into_iter_on_array` has been renamed to `array_into_iter`
-  --> $DIR/rename.rs:54:9
+  --> $DIR/rename.rs:56:9
    |
 LL | #![warn(clippy::into_iter_on_array)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `array_into_iter`
 
 error: lint `clippy::unused_label` has been renamed to `unused_labels`
-  --> $DIR/rename.rs:55:9
+  --> $DIR/rename.rs:57:9
    |
 LL | #![warn(clippy::unused_label)]
    |         ^^^^^^^^^^^^^^^^^^^^ help: use the new name: `unused_labels`
 
 error: lint `clippy::drop_bounds` has been renamed to `drop_bounds`
-  --> $DIR/rename.rs:56:9
+  --> $DIR/rename.rs:58:9
    |
 LL | #![warn(clippy::drop_bounds)]
    |         ^^^^^^^^^^^^^^^^^^^ help: use the new name: `drop_bounds`
 
 error: lint `clippy::temporary_cstring_as_ptr` has been renamed to `temporary_cstring_as_ptr`
-  --> $DIR/rename.rs:57:9
+  --> $DIR/rename.rs:59:9
    |
 LL | #![warn(clippy::temporary_cstring_as_ptr)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `temporary_cstring_as_ptr`
 
 error: lint `clippy::panic_params` has been renamed to `non_fmt_panics`
-  --> $DIR/rename.rs:58:9
+  --> $DIR/rename.rs:60:9
    |
 LL | #![warn(clippy::panic_params)]
    |         ^^^^^^^^^^^^^^^^^^^^ help: use the new name: `non_fmt_panics`
 
 error: lint `clippy::unknown_clippy_lints` has been renamed to `unknown_lints`
-  --> $DIR/rename.rs:59:9
+  --> $DIR/rename.rs:61:9
    |
 LL | #![warn(clippy::unknown_clippy_lints)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `unknown_lints`
 
 error: lint `clippy::invalid_atomic_ordering` has been renamed to `invalid_atomic_ordering`
-  --> $DIR/rename.rs:60:9
+  --> $DIR/rename.rs:62:9
    |
 LL | #![warn(clippy::invalid_atomic_ordering)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `invalid_atomic_ordering`
 
 error: lint `clippy::mem_discriminant_non_enum` has been renamed to `enum_intrinsics_non_enums`
-  --> $DIR/rename.rs:61:9
+  --> $DIR/rename.rs:63:9
    |
 LL | #![warn(clippy::mem_discriminant_non_enum)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `enum_intrinsics_non_enums`
 
-error: aborting due to 30 previous errors
+error: aborting due to 31 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From a0d81d1327fc1678119441e256f54128220b7ed4 Mon Sep 17 00:00:00 2001
From: Philipp Hansch <dev@phansch.net>
Date: Wed, 17 Nov 2021 07:47:43 +0100
Subject: Pluralize disallowed_type lint filenames

This way they match up with the pluralized lint name as well.
---
 clippy_lints/src/disallowed_type.rs                | 137 ---------------------
 clippy_lints/src/disallowed_types.rs               | 137 +++++++++++++++++++++
 clippy_lints/src/lib.register_lints.rs             |   2 +-
 clippy_lints/src/lib.register_nursery.rs           |   2 +-
 clippy_lints/src/lib.rs                            |   4 +-
 tests/ui-toml/toml_disallowed_type/clippy.toml     |  15 ---
 .../toml_disallowed_type/conf_disallowed_type.rs   |  42 -------
 .../conf_disallowed_type.stderr                    | 132 --------------------
 tests/ui-toml/toml_disallowed_types/clippy.toml    |  15 +++
 .../toml_disallowed_types/conf_disallowed_types.rs |  42 +++++++
 .../conf_disallowed_types.stderr                   | 132 ++++++++++++++++++++
 11 files changed, 330 insertions(+), 330 deletions(-)
 delete mode 100644 clippy_lints/src/disallowed_type.rs
 create mode 100644 clippy_lints/src/disallowed_types.rs
 delete mode 100644 tests/ui-toml/toml_disallowed_type/clippy.toml
 delete mode 100644 tests/ui-toml/toml_disallowed_type/conf_disallowed_type.rs
 delete mode 100644 tests/ui-toml/toml_disallowed_type/conf_disallowed_type.stderr
 create mode 100644 tests/ui-toml/toml_disallowed_types/clippy.toml
 create mode 100644 tests/ui-toml/toml_disallowed_types/conf_disallowed_types.rs
 create mode 100644 tests/ui-toml/toml_disallowed_types/conf_disallowed_types.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/disallowed_type.rs b/clippy_lints/src/disallowed_type.rs
deleted file mode 100644
index eaed4032713..00000000000
--- a/clippy_lints/src/disallowed_type.rs
+++ /dev/null
@@ -1,137 +0,0 @@
-use clippy_utils::diagnostics::span_lint_and_then;
-
-use rustc_data_structures::fx::FxHashMap;
-use rustc_hir::{
-    def::Res, def_id::DefId, Item, ItemKind, PolyTraitRef, PrimTy, TraitBoundModifier, Ty, TyKind, UseKind,
-};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::Span;
-
-use crate::utils::conf;
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Denies the configured types in clippy.toml.
-    ///
-    /// ### Why is this bad?
-    /// Some types are undesirable in certain contexts.
-    ///
-    /// ### Example:
-    /// An example clippy.toml configuration:
-    /// ```toml
-    /// # clippy.toml
-    /// disallowed-types = [
-    ///     # Can use a string as the path of the disallowed type.
-    ///     "std::collections::BTreeMap",
-    ///     # Can also use an inline table with a `path` key.
-    ///     { path = "std::net::TcpListener" },
-    ///     # When using an inline table, can add a `reason` for why the type
-    ///     # is disallowed.
-    ///     { path = "std::net::Ipv4Addr", reason = "no IPv4 allowed" },
-    /// ]
-    /// ```
-    ///
-    /// ```rust,ignore
-    /// use std::collections::BTreeMap;
-    /// // or its use
-    /// let x = std::collections::BTreeMap::new();
-    /// ```
-    /// Use instead:
-    /// ```rust,ignore
-    /// // A similar type that is allowed by the config
-    /// use std::collections::HashMap;
-    /// ```
-    #[clippy::version = "1.55.0"]
-    pub DISALLOWED_TYPES,
-    nursery,
-    "use of disallowed types"
-}
-#[derive(Clone, Debug)]
-pub struct DisallowedTypes {
-    conf_disallowed: Vec<conf::DisallowedType>,
-    def_ids: FxHashMap<DefId, Option<String>>,
-    prim_tys: FxHashMap<PrimTy, Option<String>>,
-}
-
-impl DisallowedTypes {
-    pub fn new(conf_disallowed: Vec<conf::DisallowedType>) -> Self {
-        Self {
-            conf_disallowed,
-            def_ids: FxHashMap::default(),
-            prim_tys: FxHashMap::default(),
-        }
-    }
-
-    fn check_res_emit(&self, cx: &LateContext<'_>, res: &Res, span: Span) {
-        match res {
-            Res::Def(_, did) => {
-                if let Some(reason) = self.def_ids.get(did) {
-                    emit(cx, &cx.tcx.def_path_str(*did), span, reason.as_deref());
-                }
-            },
-            Res::PrimTy(prim) => {
-                if let Some(reason) = self.prim_tys.get(prim) {
-                    emit(cx, prim.name_str(), span, reason.as_deref());
-                }
-            },
-            _ => {},
-        }
-    }
-}
-
-impl_lint_pass!(DisallowedTypes => [DISALLOWED_TYPES]);
-
-impl<'tcx> LateLintPass<'tcx> for DisallowedTypes {
-    fn check_crate(&mut self, cx: &LateContext<'_>) {
-        for conf in &self.conf_disallowed {
-            let (path, reason) = match conf {
-                conf::DisallowedType::Simple(path) => (path, None),
-                conf::DisallowedType::WithReason { path, reason } => (
-                    path,
-                    reason.as_ref().map(|reason| format!("{} (from clippy.toml)", reason)),
-                ),
-            };
-            let segs: Vec<_> = path.split("::").collect();
-            match clippy_utils::path_to_res(cx, &segs) {
-                Res::Def(_, id) => {
-                    self.def_ids.insert(id, reason);
-                },
-                Res::PrimTy(ty) => {
-                    self.prim_tys.insert(ty, reason);
-                },
-                _ => {},
-            }
-        }
-    }
-
-    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
-        if let ItemKind::Use(path, UseKind::Single) = &item.kind {
-            self.check_res_emit(cx, &path.res, item.span);
-        }
-    }
-
-    fn check_ty(&mut self, cx: &LateContext<'tcx>, ty: &'tcx Ty<'tcx>) {
-        if let TyKind::Path(path) = &ty.kind {
-            self.check_res_emit(cx, &cx.qpath_res(path, ty.hir_id), ty.span);
-        }
-    }
-
-    fn check_poly_trait_ref(&mut self, cx: &LateContext<'tcx>, poly: &'tcx PolyTraitRef<'tcx>, _: TraitBoundModifier) {
-        self.check_res_emit(cx, &poly.trait_ref.path.res, poly.trait_ref.path.span);
-    }
-}
-
-fn emit(cx: &LateContext<'_>, name: &str, span: Span, reason: Option<&str>) {
-    span_lint_and_then(
-        cx,
-        DISALLOWED_TYPES,
-        span,
-        &format!("`{}` is not allowed according to config", name),
-        |diag| {
-            if let Some(reason) = reason {
-                diag.note(reason);
-            }
-        },
-    );
-}
diff --git a/clippy_lints/src/disallowed_types.rs b/clippy_lints/src/disallowed_types.rs
new file mode 100644
index 00000000000..eaed4032713
--- /dev/null
+++ b/clippy_lints/src/disallowed_types.rs
@@ -0,0 +1,137 @@
+use clippy_utils::diagnostics::span_lint_and_then;
+
+use rustc_data_structures::fx::FxHashMap;
+use rustc_hir::{
+    def::Res, def_id::DefId, Item, ItemKind, PolyTraitRef, PrimTy, TraitBoundModifier, Ty, TyKind, UseKind,
+};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::Span;
+
+use crate::utils::conf;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Denies the configured types in clippy.toml.
+    ///
+    /// ### Why is this bad?
+    /// Some types are undesirable in certain contexts.
+    ///
+    /// ### Example:
+    /// An example clippy.toml configuration:
+    /// ```toml
+    /// # clippy.toml
+    /// disallowed-types = [
+    ///     # Can use a string as the path of the disallowed type.
+    ///     "std::collections::BTreeMap",
+    ///     # Can also use an inline table with a `path` key.
+    ///     { path = "std::net::TcpListener" },
+    ///     # When using an inline table, can add a `reason` for why the type
+    ///     # is disallowed.
+    ///     { path = "std::net::Ipv4Addr", reason = "no IPv4 allowed" },
+    /// ]
+    /// ```
+    ///
+    /// ```rust,ignore
+    /// use std::collections::BTreeMap;
+    /// // or its use
+    /// let x = std::collections::BTreeMap::new();
+    /// ```
+    /// Use instead:
+    /// ```rust,ignore
+    /// // A similar type that is allowed by the config
+    /// use std::collections::HashMap;
+    /// ```
+    #[clippy::version = "1.55.0"]
+    pub DISALLOWED_TYPES,
+    nursery,
+    "use of disallowed types"
+}
+#[derive(Clone, Debug)]
+pub struct DisallowedTypes {
+    conf_disallowed: Vec<conf::DisallowedType>,
+    def_ids: FxHashMap<DefId, Option<String>>,
+    prim_tys: FxHashMap<PrimTy, Option<String>>,
+}
+
+impl DisallowedTypes {
+    pub fn new(conf_disallowed: Vec<conf::DisallowedType>) -> Self {
+        Self {
+            conf_disallowed,
+            def_ids: FxHashMap::default(),
+            prim_tys: FxHashMap::default(),
+        }
+    }
+
+    fn check_res_emit(&self, cx: &LateContext<'_>, res: &Res, span: Span) {
+        match res {
+            Res::Def(_, did) => {
+                if let Some(reason) = self.def_ids.get(did) {
+                    emit(cx, &cx.tcx.def_path_str(*did), span, reason.as_deref());
+                }
+            },
+            Res::PrimTy(prim) => {
+                if let Some(reason) = self.prim_tys.get(prim) {
+                    emit(cx, prim.name_str(), span, reason.as_deref());
+                }
+            },
+            _ => {},
+        }
+    }
+}
+
+impl_lint_pass!(DisallowedTypes => [DISALLOWED_TYPES]);
+
+impl<'tcx> LateLintPass<'tcx> for DisallowedTypes {
+    fn check_crate(&mut self, cx: &LateContext<'_>) {
+        for conf in &self.conf_disallowed {
+            let (path, reason) = match conf {
+                conf::DisallowedType::Simple(path) => (path, None),
+                conf::DisallowedType::WithReason { path, reason } => (
+                    path,
+                    reason.as_ref().map(|reason| format!("{} (from clippy.toml)", reason)),
+                ),
+            };
+            let segs: Vec<_> = path.split("::").collect();
+            match clippy_utils::path_to_res(cx, &segs) {
+                Res::Def(_, id) => {
+                    self.def_ids.insert(id, reason);
+                },
+                Res::PrimTy(ty) => {
+                    self.prim_tys.insert(ty, reason);
+                },
+                _ => {},
+            }
+        }
+    }
+
+    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
+        if let ItemKind::Use(path, UseKind::Single) = &item.kind {
+            self.check_res_emit(cx, &path.res, item.span);
+        }
+    }
+
+    fn check_ty(&mut self, cx: &LateContext<'tcx>, ty: &'tcx Ty<'tcx>) {
+        if let TyKind::Path(path) = &ty.kind {
+            self.check_res_emit(cx, &cx.qpath_res(path, ty.hir_id), ty.span);
+        }
+    }
+
+    fn check_poly_trait_ref(&mut self, cx: &LateContext<'tcx>, poly: &'tcx PolyTraitRef<'tcx>, _: TraitBoundModifier) {
+        self.check_res_emit(cx, &poly.trait_ref.path.res, poly.trait_ref.path.span);
+    }
+}
+
+fn emit(cx: &LateContext<'_>, name: &str, span: Span, reason: Option<&str>) {
+    span_lint_and_then(
+        cx,
+        DISALLOWED_TYPES,
+        span,
+        &format!("`{}` is not allowed according to config", name),
+        |diag| {
+            if let Some(reason) = reason {
+                diag.note(reason);
+            }
+        },
+    );
+}
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 4a4fd76da07..f48cfb81b62 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -99,7 +99,7 @@ store.register_lints(&[
     derive::UNSAFE_DERIVE_DESERIALIZE,
     disallowed_method::DISALLOWED_METHOD,
     disallowed_script_idents::DISALLOWED_SCRIPT_IDENTS,
-    disallowed_type::DISALLOWED_TYPES,
+    disallowed_types::DISALLOWED_TYPES,
     doc::DOC_MARKDOWN,
     doc::MISSING_ERRORS_DOC,
     doc::MISSING_PANICS_DOC,
diff --git a/clippy_lints/src/lib.register_nursery.rs b/clippy_lints/src/lib.register_nursery.rs
index 3adb9881a71..ac7e6df6fc7 100644
--- a/clippy_lints/src/lib.register_nursery.rs
+++ b/clippy_lints/src/lib.register_nursery.rs
@@ -7,7 +7,7 @@ store.register_group(true, "clippy::nursery", Some("clippy_nursery"), vec![
     LintId::of(cognitive_complexity::COGNITIVE_COMPLEXITY),
     LintId::of(copies::BRANCHES_SHARING_CODE),
     LintId::of(disallowed_method::DISALLOWED_METHOD),
-    LintId::of(disallowed_type::DISALLOWED_TYPES),
+    LintId::of(disallowed_types::DISALLOWED_TYPES),
     LintId::of(equatable_if_let::EQUATABLE_IF_LET),
     LintId::of(fallible_impl_from::FALLIBLE_IMPL_FROM),
     LintId::of(floating_point_arithmetic::IMPRECISE_FLOPS),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index d65ef3b8728..83b57fba02a 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -196,7 +196,7 @@ mod derivable_impls;
 mod derive;
 mod disallowed_method;
 mod disallowed_script_idents;
-mod disallowed_type;
+mod disallowed_types;
 mod doc;
 mod double_comparison;
 mod double_parens;
@@ -827,7 +827,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_early_pass(move || Box::new(module_style::ModStyle));
     store.register_late_pass(|| Box::new(unused_async::UnusedAsync));
     let disallowed_types = conf.disallowed_types.clone();
-    store.register_late_pass(move || Box::new(disallowed_type::DisallowedTypes::new(disallowed_types.clone())));
+    store.register_late_pass(move || Box::new(disallowed_types::DisallowedTypes::new(disallowed_types.clone())));
     let import_renames = conf.enforced_import_renames.clone();
     store.register_late_pass(move || {
         Box::new(missing_enforced_import_rename::ImportRename::new(
diff --git a/tests/ui-toml/toml_disallowed_type/clippy.toml b/tests/ui-toml/toml_disallowed_type/clippy.toml
deleted file mode 100644
index 6cb9e2ef954..00000000000
--- a/tests/ui-toml/toml_disallowed_type/clippy.toml
+++ /dev/null
@@ -1,15 +0,0 @@
-disallowed-types = [
-    "std::collections::HashMap",
-    "std::sync::atomic::AtomicU32",
-    "syn::TypePath",
-    "proc_macro2::Ident",
-    "std::thread::Thread",
-    "std::time::Instant",
-    "std::io::Read",
-    "std::primitive::usize",
-    "bool",
-    # can give path and reason with an inline table
-    { path = "std::net::Ipv4Addr", reason = "no IPv4 allowed" },
-    # can use an inline table but omit reason
-    { path = "std::net::TcpListener" },
-]
diff --git a/tests/ui-toml/toml_disallowed_type/conf_disallowed_type.rs b/tests/ui-toml/toml_disallowed_type/conf_disallowed_type.rs
deleted file mode 100644
index 7f28efd676f..00000000000
--- a/tests/ui-toml/toml_disallowed_type/conf_disallowed_type.rs
+++ /dev/null
@@ -1,42 +0,0 @@
-#![warn(clippy::disallowed_types)]
-
-extern crate quote;
-extern crate syn;
-
-use std::sync as foo;
-use std::sync::atomic::AtomicU32;
-use std::time::Instant as Sneaky;
-
-struct HashMap;
-
-fn bad_return_type() -> fn() -> Sneaky {
-    todo!()
-}
-
-fn bad_arg_type(_: impl Fn(Sneaky) -> foo::atomic::AtomicU32) {}
-
-fn trait_obj(_: &dyn std::io::Read) {}
-
-fn full_and_single_path_prim(_: usize, _: bool) {}
-
-fn const_generics<const C: usize>() {}
-
-struct GenArg<const U: usize>([u8; U]);
-
-static BAD: foo::atomic::AtomicPtr<()> = foo::atomic::AtomicPtr::new(std::ptr::null_mut());
-
-fn ip(_: std::net::Ipv4Addr) {}
-
-fn listener(_: std::net::TcpListener) {}
-
-#[allow(clippy::diverging_sub_expression)]
-fn main() {
-    let _: std::collections::HashMap<(), ()> = std::collections::HashMap::new();
-    let _ = Sneaky::now();
-    let _ = foo::atomic::AtomicU32::new(0);
-    static FOO: std::sync::atomic::AtomicU32 = foo::atomic::AtomicU32::new(1);
-    let _: std::collections::BTreeMap<(), syn::TypePath> = Default::default();
-    let _ = syn::Ident::new("", todo!());
-    let _ = HashMap;
-    let _: usize = 64_usize;
-}
diff --git a/tests/ui-toml/toml_disallowed_type/conf_disallowed_type.stderr b/tests/ui-toml/toml_disallowed_type/conf_disallowed_type.stderr
deleted file mode 100644
index 25efd62d0ec..00000000000
--- a/tests/ui-toml/toml_disallowed_type/conf_disallowed_type.stderr
+++ /dev/null
@@ -1,132 +0,0 @@
-error: `std::sync::atomic::AtomicU32` is not allowed according to config
-  --> $DIR/conf_disallowed_type.rs:7:1
-   |
-LL | use std::sync::atomic::AtomicU32;
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: `-D clippy::disallowed-types` implied by `-D warnings`
-
-error: `std::time::Instant` is not allowed according to config
-  --> $DIR/conf_disallowed_type.rs:8:1
-   |
-LL | use std::time::Instant as Sneaky;
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: `std::time::Instant` is not allowed according to config
-  --> $DIR/conf_disallowed_type.rs:12:33
-   |
-LL | fn bad_return_type() -> fn() -> Sneaky {
-   |                                 ^^^^^^
-
-error: `std::time::Instant` is not allowed according to config
-  --> $DIR/conf_disallowed_type.rs:16:28
-   |
-LL | fn bad_arg_type(_: impl Fn(Sneaky) -> foo::atomic::AtomicU32) {}
-   |                            ^^^^^^
-
-error: `std::sync::atomic::AtomicU32` is not allowed according to config
-  --> $DIR/conf_disallowed_type.rs:16:39
-   |
-LL | fn bad_arg_type(_: impl Fn(Sneaky) -> foo::atomic::AtomicU32) {}
-   |                                       ^^^^^^^^^^^^^^^^^^^^^^
-
-error: `std::io::Read` is not allowed according to config
-  --> $DIR/conf_disallowed_type.rs:18:22
-   |
-LL | fn trait_obj(_: &dyn std::io::Read) {}
-   |                      ^^^^^^^^^^^^^
-
-error: `usize` is not allowed according to config
-  --> $DIR/conf_disallowed_type.rs:20:33
-   |
-LL | fn full_and_single_path_prim(_: usize, _: bool) {}
-   |                                 ^^^^^
-
-error: `bool` is not allowed according to config
-  --> $DIR/conf_disallowed_type.rs:20:43
-   |
-LL | fn full_and_single_path_prim(_: usize, _: bool) {}
-   |                                           ^^^^
-
-error: `usize` is not allowed according to config
-  --> $DIR/conf_disallowed_type.rs:22:28
-   |
-LL | fn const_generics<const C: usize>() {}
-   |                            ^^^^^
-
-error: `usize` is not allowed according to config
-  --> $DIR/conf_disallowed_type.rs:24:24
-   |
-LL | struct GenArg<const U: usize>([u8; U]);
-   |                        ^^^^^
-
-error: `std::net::Ipv4Addr` is not allowed according to config
-  --> $DIR/conf_disallowed_type.rs:28:10
-   |
-LL | fn ip(_: std::net::Ipv4Addr) {}
-   |          ^^^^^^^^^^^^^^^^^^
-   |
-   = note: no IPv4 allowed (from clippy.toml)
-
-error: `std::net::TcpListener` is not allowed according to config
-  --> $DIR/conf_disallowed_type.rs:30:16
-   |
-LL | fn listener(_: std::net::TcpListener) {}
-   |                ^^^^^^^^^^^^^^^^^^^^^
-
-error: `std::collections::HashMap` is not allowed according to config
-  --> $DIR/conf_disallowed_type.rs:34:48
-   |
-LL |     let _: std::collections::HashMap<(), ()> = std::collections::HashMap::new();
-   |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: `std::collections::HashMap` is not allowed according to config
-  --> $DIR/conf_disallowed_type.rs:34:12
-   |
-LL |     let _: std::collections::HashMap<(), ()> = std::collections::HashMap::new();
-   |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: `std::time::Instant` is not allowed according to config
-  --> $DIR/conf_disallowed_type.rs:35:13
-   |
-LL |     let _ = Sneaky::now();
-   |             ^^^^^^
-
-error: `std::sync::atomic::AtomicU32` is not allowed according to config
-  --> $DIR/conf_disallowed_type.rs:36:13
-   |
-LL |     let _ = foo::atomic::AtomicU32::new(0);
-   |             ^^^^^^^^^^^^^^^^^^^^^^
-
-error: `std::sync::atomic::AtomicU32` is not allowed according to config
-  --> $DIR/conf_disallowed_type.rs:37:17
-   |
-LL |     static FOO: std::sync::atomic::AtomicU32 = foo::atomic::AtomicU32::new(1);
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: `std::sync::atomic::AtomicU32` is not allowed according to config
-  --> $DIR/conf_disallowed_type.rs:37:48
-   |
-LL |     static FOO: std::sync::atomic::AtomicU32 = foo::atomic::AtomicU32::new(1);
-   |                                                ^^^^^^^^^^^^^^^^^^^^^^
-
-error: `syn::TypePath` is not allowed according to config
-  --> $DIR/conf_disallowed_type.rs:38:43
-   |
-LL |     let _: std::collections::BTreeMap<(), syn::TypePath> = Default::default();
-   |                                           ^^^^^^^^^^^^^
-
-error: `syn::Ident` is not allowed according to config
-  --> $DIR/conf_disallowed_type.rs:39:13
-   |
-LL |     let _ = syn::Ident::new("", todo!());
-   |             ^^^^^^^^^^
-
-error: `usize` is not allowed according to config
-  --> $DIR/conf_disallowed_type.rs:41:12
-   |
-LL |     let _: usize = 64_usize;
-   |            ^^^^^
-
-error: aborting due to 21 previous errors
-
diff --git a/tests/ui-toml/toml_disallowed_types/clippy.toml b/tests/ui-toml/toml_disallowed_types/clippy.toml
new file mode 100644
index 00000000000..6cb9e2ef954
--- /dev/null
+++ b/tests/ui-toml/toml_disallowed_types/clippy.toml
@@ -0,0 +1,15 @@
+disallowed-types = [
+    "std::collections::HashMap",
+    "std::sync::atomic::AtomicU32",
+    "syn::TypePath",
+    "proc_macro2::Ident",
+    "std::thread::Thread",
+    "std::time::Instant",
+    "std::io::Read",
+    "std::primitive::usize",
+    "bool",
+    # can give path and reason with an inline table
+    { path = "std::net::Ipv4Addr", reason = "no IPv4 allowed" },
+    # can use an inline table but omit reason
+    { path = "std::net::TcpListener" },
+]
diff --git a/tests/ui-toml/toml_disallowed_types/conf_disallowed_types.rs b/tests/ui-toml/toml_disallowed_types/conf_disallowed_types.rs
new file mode 100644
index 00000000000..7f28efd676f
--- /dev/null
+++ b/tests/ui-toml/toml_disallowed_types/conf_disallowed_types.rs
@@ -0,0 +1,42 @@
+#![warn(clippy::disallowed_types)]
+
+extern crate quote;
+extern crate syn;
+
+use std::sync as foo;
+use std::sync::atomic::AtomicU32;
+use std::time::Instant as Sneaky;
+
+struct HashMap;
+
+fn bad_return_type() -> fn() -> Sneaky {
+    todo!()
+}
+
+fn bad_arg_type(_: impl Fn(Sneaky) -> foo::atomic::AtomicU32) {}
+
+fn trait_obj(_: &dyn std::io::Read) {}
+
+fn full_and_single_path_prim(_: usize, _: bool) {}
+
+fn const_generics<const C: usize>() {}
+
+struct GenArg<const U: usize>([u8; U]);
+
+static BAD: foo::atomic::AtomicPtr<()> = foo::atomic::AtomicPtr::new(std::ptr::null_mut());
+
+fn ip(_: std::net::Ipv4Addr) {}
+
+fn listener(_: std::net::TcpListener) {}
+
+#[allow(clippy::diverging_sub_expression)]
+fn main() {
+    let _: std::collections::HashMap<(), ()> = std::collections::HashMap::new();
+    let _ = Sneaky::now();
+    let _ = foo::atomic::AtomicU32::new(0);
+    static FOO: std::sync::atomic::AtomicU32 = foo::atomic::AtomicU32::new(1);
+    let _: std::collections::BTreeMap<(), syn::TypePath> = Default::default();
+    let _ = syn::Ident::new("", todo!());
+    let _ = HashMap;
+    let _: usize = 64_usize;
+}
diff --git a/tests/ui-toml/toml_disallowed_types/conf_disallowed_types.stderr b/tests/ui-toml/toml_disallowed_types/conf_disallowed_types.stderr
new file mode 100644
index 00000000000..e3ece799c7c
--- /dev/null
+++ b/tests/ui-toml/toml_disallowed_types/conf_disallowed_types.stderr
@@ -0,0 +1,132 @@
+error: `std::sync::atomic::AtomicU32` is not allowed according to config
+  --> $DIR/conf_disallowed_types.rs:7:1
+   |
+LL | use std::sync::atomic::AtomicU32;
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::disallowed-types` implied by `-D warnings`
+
+error: `std::time::Instant` is not allowed according to config
+  --> $DIR/conf_disallowed_types.rs:8:1
+   |
+LL | use std::time::Instant as Sneaky;
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: `std::time::Instant` is not allowed according to config
+  --> $DIR/conf_disallowed_types.rs:12:33
+   |
+LL | fn bad_return_type() -> fn() -> Sneaky {
+   |                                 ^^^^^^
+
+error: `std::time::Instant` is not allowed according to config
+  --> $DIR/conf_disallowed_types.rs:16:28
+   |
+LL | fn bad_arg_type(_: impl Fn(Sneaky) -> foo::atomic::AtomicU32) {}
+   |                            ^^^^^^
+
+error: `std::sync::atomic::AtomicU32` is not allowed according to config
+  --> $DIR/conf_disallowed_types.rs:16:39
+   |
+LL | fn bad_arg_type(_: impl Fn(Sneaky) -> foo::atomic::AtomicU32) {}
+   |                                       ^^^^^^^^^^^^^^^^^^^^^^
+
+error: `std::io::Read` is not allowed according to config
+  --> $DIR/conf_disallowed_types.rs:18:22
+   |
+LL | fn trait_obj(_: &dyn std::io::Read) {}
+   |                      ^^^^^^^^^^^^^
+
+error: `usize` is not allowed according to config
+  --> $DIR/conf_disallowed_types.rs:20:33
+   |
+LL | fn full_and_single_path_prim(_: usize, _: bool) {}
+   |                                 ^^^^^
+
+error: `bool` is not allowed according to config
+  --> $DIR/conf_disallowed_types.rs:20:43
+   |
+LL | fn full_and_single_path_prim(_: usize, _: bool) {}
+   |                                           ^^^^
+
+error: `usize` is not allowed according to config
+  --> $DIR/conf_disallowed_types.rs:22:28
+   |
+LL | fn const_generics<const C: usize>() {}
+   |                            ^^^^^
+
+error: `usize` is not allowed according to config
+  --> $DIR/conf_disallowed_types.rs:24:24
+   |
+LL | struct GenArg<const U: usize>([u8; U]);
+   |                        ^^^^^
+
+error: `std::net::Ipv4Addr` is not allowed according to config
+  --> $DIR/conf_disallowed_types.rs:28:10
+   |
+LL | fn ip(_: std::net::Ipv4Addr) {}
+   |          ^^^^^^^^^^^^^^^^^^
+   |
+   = note: no IPv4 allowed (from clippy.toml)
+
+error: `std::net::TcpListener` is not allowed according to config
+  --> $DIR/conf_disallowed_types.rs:30:16
+   |
+LL | fn listener(_: std::net::TcpListener) {}
+   |                ^^^^^^^^^^^^^^^^^^^^^
+
+error: `std::collections::HashMap` is not allowed according to config
+  --> $DIR/conf_disallowed_types.rs:34:48
+   |
+LL |     let _: std::collections::HashMap<(), ()> = std::collections::HashMap::new();
+   |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: `std::collections::HashMap` is not allowed according to config
+  --> $DIR/conf_disallowed_types.rs:34:12
+   |
+LL |     let _: std::collections::HashMap<(), ()> = std::collections::HashMap::new();
+   |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: `std::time::Instant` is not allowed according to config
+  --> $DIR/conf_disallowed_types.rs:35:13
+   |
+LL |     let _ = Sneaky::now();
+   |             ^^^^^^
+
+error: `std::sync::atomic::AtomicU32` is not allowed according to config
+  --> $DIR/conf_disallowed_types.rs:36:13
+   |
+LL |     let _ = foo::atomic::AtomicU32::new(0);
+   |             ^^^^^^^^^^^^^^^^^^^^^^
+
+error: `std::sync::atomic::AtomicU32` is not allowed according to config
+  --> $DIR/conf_disallowed_types.rs:37:17
+   |
+LL |     static FOO: std::sync::atomic::AtomicU32 = foo::atomic::AtomicU32::new(1);
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: `std::sync::atomic::AtomicU32` is not allowed according to config
+  --> $DIR/conf_disallowed_types.rs:37:48
+   |
+LL |     static FOO: std::sync::atomic::AtomicU32 = foo::atomic::AtomicU32::new(1);
+   |                                                ^^^^^^^^^^^^^^^^^^^^^^
+
+error: `syn::TypePath` is not allowed according to config
+  --> $DIR/conf_disallowed_types.rs:38:43
+   |
+LL |     let _: std::collections::BTreeMap<(), syn::TypePath> = Default::default();
+   |                                           ^^^^^^^^^^^^^
+
+error: `syn::Ident` is not allowed according to config
+  --> $DIR/conf_disallowed_types.rs:39:13
+   |
+LL |     let _ = syn::Ident::new("", todo!());
+   |             ^^^^^^^^^^
+
+error: `usize` is not allowed according to config
+  --> $DIR/conf_disallowed_types.rs:41:12
+   |
+LL |     let _: usize = 64_usize;
+   |            ^^^^^
+
+error: aborting due to 21 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 9b38fb7b71d97e9ee04f210a34df4f99e51a20ef Mon Sep 17 00:00:00 2001
From: flip1995 <philipp.krones@embecosm.com>
Date: Thu, 18 Nov 2021 14:08:48 +0100
Subject: Also pluralize disallowed_method(s) lint

To stay consistent with the sister lint disallowed_type, also rename the
disallowed_method lint to disallowed_methods.
---
 CHANGELOG.md                                       |  10 +-
 clippy_lints/src/disallowed_method.rs              | 107 ---------------------
 clippy_lints/src/disallowed_methods.rs             | 107 +++++++++++++++++++++
 clippy_lints/src/lib.register_lints.rs             |   2 +-
 clippy_lints/src/lib.register_nursery.rs           |   2 +-
 clippy_lints/src/lib.rs                            |   5 +-
 clippy_lints/src/utils/conf.rs                     |   4 +-
 tests/ui-toml/toml_disallowed_method/clippy.toml   |   8 --
 .../conf_disallowed_method.rs                      |  12 ---
 .../conf_disallowed_method.stderr                  |  24 -----
 tests/ui-toml/toml_disallowed_methods/clippy.toml  |   8 ++
 .../conf_disallowed_methods.rs                     |  12 +++
 .../conf_disallowed_methods.stderr                 |  24 +++++
 tests/ui/rename.fixed                              |   3 +
 tests/ui/rename.rs                                 |   3 +
 tests/ui/rename.stderr                             |  70 ++++++++------
 16 files changed, 207 insertions(+), 194 deletions(-)
 delete mode 100644 clippy_lints/src/disallowed_method.rs
 create mode 100644 clippy_lints/src/disallowed_methods.rs
 delete mode 100644 tests/ui-toml/toml_disallowed_method/clippy.toml
 delete mode 100644 tests/ui-toml/toml_disallowed_method/conf_disallowed_method.rs
 delete mode 100644 tests/ui-toml/toml_disallowed_method/conf_disallowed_method.stderr
 create mode 100644 tests/ui-toml/toml_disallowed_methods/clippy.toml
 create mode 100644 tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.rs
 create mode 100644 tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index e21e550ede2..dadf01419f7 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -70,7 +70,7 @@ Current beta, release 2021-12-02
   [#7560](https://github.com/rust-lang/rust-clippy/pull/7560)
 * [`unnecessary_unwrap`]: Now also checks for `expect`s
   [#7584](https://github.com/rust-lang/rust-clippy/pull/7584)
-* [`disallowed_method`]: Allow adding a reason that will be displayed with the
+* [`disallowed_methods`]: Allow adding a reason that will be displayed with the
   lint message
   [#7621](https://github.com/rust-lang/rust-clippy/pull/7621)
 * [`approx_constant`]: Now checks the MSRV for `LOG10_2` and `LOG2_10`
@@ -294,7 +294,7 @@ Released 2021-09-09
   [#7379](https://github.com/rust-lang/rust-clippy/pull/7379)
 * [`redundant_closure`]: Suggests `&mut` for `FnMut`
   [#7437](https://github.com/rust-lang/rust-clippy/pull/7437)
-* [`disallowed_method`], [`disallowed_types`]: The configuration values `disallowed-method` and `disallowed-type`
+* [`disallowed_methods`], [`disallowed_types`]: The configuration values `disallowed-method` and `disallowed-type`
   no longer require fully qualified paths
   [#7345](https://github.com/rust-lang/rust-clippy/pull/7345)
 * [`zst_offset`]: Fixed lint invocation after it was accidentally suppressed
@@ -703,7 +703,7 @@ Released 2021-05-06
 
 ### Enhancements
 
-* [`disallowed_method`]: Now supports functions in addition to methods
+* [`disallowed_methods`]: Now supports functions in addition to methods
   [#6674](https://github.com/rust-lang/rust-clippy/pull/6674)
 * [`upper_case_acronyms`]: Added a new configuration `upper-case-acronyms-aggressive` to
   trigger the lint if there is more than one uppercase character next to each other
@@ -1044,7 +1044,7 @@ Released 2020-12-31
 
 * [`field_reassign_with_default`] [#5911](https://github.com/rust-lang/rust-clippy/pull/5911)
 * [`await_holding_refcell_ref`] [#6029](https://github.com/rust-lang/rust-clippy/pull/6029)
-* [`disallowed_method`] [#6081](https://github.com/rust-lang/rust-clippy/pull/6081)
+* [`disallowed_methods`] [#6081](https://github.com/rust-lang/rust-clippy/pull/6081)
 * [`inline_asm_x86_att_syntax`] [#6092](https://github.com/rust-lang/rust-clippy/pull/6092)
 * [`inline_asm_x86_intel_syntax`] [#6092](https://github.com/rust-lang/rust-clippy/pull/6092)
 * [`from_iter_instead_of_collect`] [#6101](https://github.com/rust-lang/rust-clippy/pull/6101)
@@ -2821,7 +2821,7 @@ Released 2018-09-13
 [`derivable_impls`]: https://rust-lang.github.io/rust-clippy/master/index.html#derivable_impls
 [`derive_hash_xor_eq`]: https://rust-lang.github.io/rust-clippy/master/index.html#derive_hash_xor_eq
 [`derive_ord_xor_partial_ord`]: https://rust-lang.github.io/rust-clippy/master/index.html#derive_ord_xor_partial_ord
-[`disallowed_method`]: https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_method
+[`disallowed_methods`]: https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_methods
 [`disallowed_script_idents`]: https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_script_idents
 [`disallowed_types`]: https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_types
 [`diverging_sub_expression`]: https://rust-lang.github.io/rust-clippy/master/index.html#diverging_sub_expression
diff --git a/clippy_lints/src/disallowed_method.rs b/clippy_lints/src/disallowed_method.rs
deleted file mode 100644
index c2217353b32..00000000000
--- a/clippy_lints/src/disallowed_method.rs
+++ /dev/null
@@ -1,107 +0,0 @@
-use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::fn_def_id;
-
-use rustc_hir::{def::Res, def_id::DefIdMap, Expr};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
-
-use crate::utils::conf;
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Denies the configured methods and functions in clippy.toml
-    ///
-    /// ### Why is this bad?
-    /// Some methods are undesirable in certain contexts, and it's beneficial to
-    /// lint for them as needed.
-    ///
-    /// ### Example
-    /// An example clippy.toml configuration:
-    /// ```toml
-    /// # clippy.toml
-    /// disallowed-methods = [
-    ///     # Can use a string as the path of the disallowed method.
-    ///     "std::boxed::Box::new",
-    ///     # Can also use an inline table with a `path` key.
-    ///     { path = "std::time::Instant::now" },
-    ///     # When using an inline table, can add a `reason` for why the method
-    ///     # is disallowed.
-    ///     { path = "std::vec::Vec::leak", reason = "no leaking memory" },
-    /// ]
-    /// ```
-    ///
-    /// ```rust,ignore
-    /// // Example code where clippy issues a warning
-    /// let xs = vec![1, 2, 3, 4];
-    /// xs.leak(); // Vec::leak is disallowed in the config.
-    /// // The diagnostic contains the message "no leaking memory".
-    ///
-    /// let _now = Instant::now(); // Instant::now is disallowed in the config.
-    ///
-    /// let _box = Box::new(3); // Box::new is disallowed in the config.
-    /// ```
-    ///
-    /// Use instead:
-    /// ```rust,ignore
-    /// // Example code which does not raise clippy warning
-    /// let mut xs = Vec::new(); // Vec::new is _not_ disallowed in the config.
-    /// xs.push(123); // Vec::push is _not_ disallowed in the config.
-    /// ```
-    #[clippy::version = "1.49.0"]
-    pub DISALLOWED_METHOD,
-    nursery,
-    "use of a disallowed method call"
-}
-
-#[derive(Clone, Debug)]
-pub struct DisallowedMethod {
-    conf_disallowed: Vec<conf::DisallowedMethod>,
-    disallowed: DefIdMap<Option<String>>,
-}
-
-impl DisallowedMethod {
-    pub fn new(conf_disallowed: Vec<conf::DisallowedMethod>) -> Self {
-        Self {
-            conf_disallowed,
-            disallowed: DefIdMap::default(),
-        }
-    }
-}
-
-impl_lint_pass!(DisallowedMethod => [DISALLOWED_METHOD]);
-
-impl<'tcx> LateLintPass<'tcx> for DisallowedMethod {
-    fn check_crate(&mut self, cx: &LateContext<'_>) {
-        for conf in &self.conf_disallowed {
-            let (path, reason) = match conf {
-                conf::DisallowedMethod::Simple(path) => (path, None),
-                conf::DisallowedMethod::WithReason { path, reason } => (
-                    path,
-                    reason.as_ref().map(|reason| format!("{} (from clippy.toml)", reason)),
-                ),
-            };
-            let segs: Vec<_> = path.split("::").collect();
-            if let Res::Def(_, id) = clippy_utils::path_to_res(cx, &segs) {
-                self.disallowed.insert(id, reason);
-            }
-        }
-    }
-
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        let def_id = match fn_def_id(cx, expr) {
-            Some(def_id) => def_id,
-            None => return,
-        };
-        let reason = match self.disallowed.get(&def_id) {
-            Some(reason) => reason,
-            None => return,
-        };
-        let func_path = cx.tcx.def_path_str(def_id);
-        let msg = format!("use of a disallowed method `{}`", func_path);
-        span_lint_and_then(cx, DISALLOWED_METHOD, expr.span, &msg, |diag| {
-            if let Some(reason) = reason {
-                diag.note(reason);
-            }
-        });
-    }
-}
diff --git a/clippy_lints/src/disallowed_methods.rs b/clippy_lints/src/disallowed_methods.rs
new file mode 100644
index 00000000000..6d4065907fb
--- /dev/null
+++ b/clippy_lints/src/disallowed_methods.rs
@@ -0,0 +1,107 @@
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::fn_def_id;
+
+use rustc_hir::{def::Res, def_id::DefIdMap, Expr};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+
+use crate::utils::conf;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Denies the configured methods and functions in clippy.toml
+    ///
+    /// ### Why is this bad?
+    /// Some methods are undesirable in certain contexts, and it's beneficial to
+    /// lint for them as needed.
+    ///
+    /// ### Example
+    /// An example clippy.toml configuration:
+    /// ```toml
+    /// # clippy.toml
+    /// disallowed-methods = [
+    ///     # Can use a string as the path of the disallowed method.
+    ///     "std::boxed::Box::new",
+    ///     # Can also use an inline table with a `path` key.
+    ///     { path = "std::time::Instant::now" },
+    ///     # When using an inline table, can add a `reason` for why the method
+    ///     # is disallowed.
+    ///     { path = "std::vec::Vec::leak", reason = "no leaking memory" },
+    /// ]
+    /// ```
+    ///
+    /// ```rust,ignore
+    /// // Example code where clippy issues a warning
+    /// let xs = vec![1, 2, 3, 4];
+    /// xs.leak(); // Vec::leak is disallowed in the config.
+    /// // The diagnostic contains the message "no leaking memory".
+    ///
+    /// let _now = Instant::now(); // Instant::now is disallowed in the config.
+    ///
+    /// let _box = Box::new(3); // Box::new is disallowed in the config.
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust,ignore
+    /// // Example code which does not raise clippy warning
+    /// let mut xs = Vec::new(); // Vec::new is _not_ disallowed in the config.
+    /// xs.push(123); // Vec::push is _not_ disallowed in the config.
+    /// ```
+    #[clippy::version = "1.49.0"]
+    pub DISALLOWED_METHODS,
+    nursery,
+    "use of a disallowed method call"
+}
+
+#[derive(Clone, Debug)]
+pub struct DisallowedMethods {
+    conf_disallowed: Vec<conf::DisallowedMethod>,
+    disallowed: DefIdMap<Option<String>>,
+}
+
+impl DisallowedMethods {
+    pub fn new(conf_disallowed: Vec<conf::DisallowedMethod>) -> Self {
+        Self {
+            conf_disallowed,
+            disallowed: DefIdMap::default(),
+        }
+    }
+}
+
+impl_lint_pass!(DisallowedMethods => [DISALLOWED_METHODS]);
+
+impl<'tcx> LateLintPass<'tcx> for DisallowedMethods {
+    fn check_crate(&mut self, cx: &LateContext<'_>) {
+        for conf in &self.conf_disallowed {
+            let (path, reason) = match conf {
+                conf::DisallowedMethod::Simple(path) => (path, None),
+                conf::DisallowedMethod::WithReason { path, reason } => (
+                    path,
+                    reason.as_ref().map(|reason| format!("{} (from clippy.toml)", reason)),
+                ),
+            };
+            let segs: Vec<_> = path.split("::").collect();
+            if let Res::Def(_, id) = clippy_utils::path_to_res(cx, &segs) {
+                self.disallowed.insert(id, reason);
+            }
+        }
+    }
+
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        let def_id = match fn_def_id(cx, expr) {
+            Some(def_id) => def_id,
+            None => return,
+        };
+        let reason = match self.disallowed.get(&def_id) {
+            Some(reason) => reason,
+            None => return,
+        };
+        let func_path = cx.tcx.def_path_str(def_id);
+        let msg = format!("use of a disallowed method `{}`", func_path);
+        span_lint_and_then(cx, DISALLOWED_METHODS, expr.span, &msg, |diag| {
+            if let Some(reason) = reason {
+                diag.note(reason);
+            }
+        });
+    }
+}
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index f48cfb81b62..970a379de4e 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -97,7 +97,7 @@ store.register_lints(&[
     derive::DERIVE_ORD_XOR_PARTIAL_ORD,
     derive::EXPL_IMPL_CLONE_ON_COPY,
     derive::UNSAFE_DERIVE_DESERIALIZE,
-    disallowed_method::DISALLOWED_METHOD,
+    disallowed_methods::DISALLOWED_METHODS,
     disallowed_script_idents::DISALLOWED_SCRIPT_IDENTS,
     disallowed_types::DISALLOWED_TYPES,
     doc::DOC_MARKDOWN,
diff --git a/clippy_lints/src/lib.register_nursery.rs b/clippy_lints/src/lib.register_nursery.rs
index ac7e6df6fc7..59182fd8175 100644
--- a/clippy_lints/src/lib.register_nursery.rs
+++ b/clippy_lints/src/lib.register_nursery.rs
@@ -6,7 +6,7 @@ store.register_group(true, "clippy::nursery", Some("clippy_nursery"), vec![
     LintId::of(attrs::EMPTY_LINE_AFTER_OUTER_ATTR),
     LintId::of(cognitive_complexity::COGNITIVE_COMPLEXITY),
     LintId::of(copies::BRANCHES_SHARING_CODE),
-    LintId::of(disallowed_method::DISALLOWED_METHOD),
+    LintId::of(disallowed_methods::DISALLOWED_METHODS),
     LintId::of(disallowed_types::DISALLOWED_TYPES),
     LintId::of(equatable_if_let::EQUATABLE_IF_LET),
     LintId::of(fallible_impl_from::FALLIBLE_IMPL_FROM),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 83b57fba02a..c471fdc86be 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -194,7 +194,7 @@ mod default_numeric_fallback;
 mod dereference;
 mod derivable_impls;
 mod derive;
-mod disallowed_method;
+mod disallowed_methods;
 mod disallowed_script_idents;
 mod disallowed_types;
 mod doc;
@@ -808,7 +808,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(semicolon_if_nothing_returned::SemicolonIfNothingReturned));
     store.register_late_pass(|| Box::new(async_yields_async::AsyncYieldsAsync));
     let disallowed_methods = conf.disallowed_methods.clone();
-    store.register_late_pass(move || Box::new(disallowed_method::DisallowedMethod::new(disallowed_methods.clone())));
+    store.register_late_pass(move || Box::new(disallowed_methods::DisallowedMethods::new(disallowed_methods.clone())));
     store.register_early_pass(|| Box::new(asm_syntax::InlineAsmX86AttSyntax));
     store.register_early_pass(|| Box::new(asm_syntax::InlineAsmX86IntelSyntax));
     store.register_late_pass(|| Box::new(undropped_manually_drops::UndroppedManuallyDrops));
@@ -925,6 +925,7 @@ pub fn register_renamed(ls: &mut rustc_lint::LintStore) {
     ls.register_renamed("clippy::single_char_push_str", "clippy::single_char_add_str");
     ls.register_renamed("clippy::if_let_some_result", "clippy::match_result_ok");
     ls.register_renamed("clippy::disallowed_type", "clippy::disallowed_types");
+    ls.register_renamed("clippy::disallowed_method", "clippy::disallowed_methods");
 
     // uplifted lints
     ls.register_renamed("clippy::invalid_ref", "invalid_value");
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 18e28cc4ca3..9c83d30eb9c 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -15,7 +15,7 @@ pub struct Rename {
     pub rename: String,
 }
 
-/// A single disallowed method, used by the `DISALLOWED_METHOD` lint.
+/// A single disallowed method, used by the `DISALLOWED_METHODS` lint.
 #[derive(Clone, Debug, Deserialize)]
 #[serde(untagged)]
 pub enum DisallowedMethod {
@@ -256,7 +256,7 @@ define_Conf! {
     ///
     /// Whether to allow certain wildcard imports (prelude, super in tests).
     (warn_on_all_wildcard_imports: bool = false),
-    /// Lint: DISALLOWED_METHOD.
+    /// Lint: DISALLOWED_METHODS.
     ///
     /// The list of disallowed methods, written as fully qualified paths.
     (disallowed_methods: Vec<crate::utils::conf::DisallowedMethod> = Vec::new()),
diff --git a/tests/ui-toml/toml_disallowed_method/clippy.toml b/tests/ui-toml/toml_disallowed_method/clippy.toml
deleted file mode 100644
index f1d4a4619c5..00000000000
--- a/tests/ui-toml/toml_disallowed_method/clippy.toml
+++ /dev/null
@@ -1,8 +0,0 @@
-disallowed-methods = [
-    # just a string is shorthand for path only
-    "std::iter::Iterator::sum",
-    # can give path and reason with an inline table
-    { path = "regex::Regex::is_match", reason = "no matching allowed" },
-    # can use an inline table but omit reason
-    { path = "regex::Regex::new" },
-]
diff --git a/tests/ui-toml/toml_disallowed_method/conf_disallowed_method.rs b/tests/ui-toml/toml_disallowed_method/conf_disallowed_method.rs
deleted file mode 100644
index 1901a99377e..00000000000
--- a/tests/ui-toml/toml_disallowed_method/conf_disallowed_method.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-#![warn(clippy::disallowed_method)]
-
-extern crate regex;
-use regex::Regex;
-
-fn main() {
-    let re = Regex::new(r"ab.*c").unwrap();
-    re.is_match("abc");
-
-    let a = vec![1, 2, 3, 4];
-    a.iter().sum::<i32>();
-}
diff --git a/tests/ui-toml/toml_disallowed_method/conf_disallowed_method.stderr b/tests/ui-toml/toml_disallowed_method/conf_disallowed_method.stderr
deleted file mode 100644
index 38123220a43..00000000000
--- a/tests/ui-toml/toml_disallowed_method/conf_disallowed_method.stderr
+++ /dev/null
@@ -1,24 +0,0 @@
-error: use of a disallowed method `regex::Regex::new`
-  --> $DIR/conf_disallowed_method.rs:7:14
-   |
-LL |     let re = Regex::new(r"ab.*c").unwrap();
-   |              ^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: `-D clippy::disallowed-method` implied by `-D warnings`
-
-error: use of a disallowed method `regex::Regex::is_match`
-  --> $DIR/conf_disallowed_method.rs:8:5
-   |
-LL |     re.is_match("abc");
-   |     ^^^^^^^^^^^^^^^^^^
-   |
-   = note: no matching allowed (from clippy.toml)
-
-error: use of a disallowed method `std::iter::Iterator::sum`
-  --> $DIR/conf_disallowed_method.rs:11:5
-   |
-LL |     a.iter().sum::<i32>();
-   |     ^^^^^^^^^^^^^^^^^^^^^
-
-error: aborting due to 3 previous errors
-
diff --git a/tests/ui-toml/toml_disallowed_methods/clippy.toml b/tests/ui-toml/toml_disallowed_methods/clippy.toml
new file mode 100644
index 00000000000..f1d4a4619c5
--- /dev/null
+++ b/tests/ui-toml/toml_disallowed_methods/clippy.toml
@@ -0,0 +1,8 @@
+disallowed-methods = [
+    # just a string is shorthand for path only
+    "std::iter::Iterator::sum",
+    # can give path and reason with an inline table
+    { path = "regex::Regex::is_match", reason = "no matching allowed" },
+    # can use an inline table but omit reason
+    { path = "regex::Regex::new" },
+]
diff --git a/tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.rs b/tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.rs
new file mode 100644
index 00000000000..cb449b45bde
--- /dev/null
+++ b/tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.rs
@@ -0,0 +1,12 @@
+#![warn(clippy::disallowed_methods)]
+
+extern crate regex;
+use regex::Regex;
+
+fn main() {
+    let re = Regex::new(r"ab.*c").unwrap();
+    re.is_match("abc");
+
+    let a = vec![1, 2, 3, 4];
+    a.iter().sum::<i32>();
+}
diff --git a/tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.stderr b/tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.stderr
new file mode 100644
index 00000000000..999ead10d51
--- /dev/null
+++ b/tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.stderr
@@ -0,0 +1,24 @@
+error: use of a disallowed method `regex::Regex::new`
+  --> $DIR/conf_disallowed_methods.rs:7:14
+   |
+LL |     let re = Regex::new(r"ab.*c").unwrap();
+   |              ^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::disallowed-methods` implied by `-D warnings`
+
+error: use of a disallowed method `regex::Regex::is_match`
+  --> $DIR/conf_disallowed_methods.rs:8:5
+   |
+LL |     re.is_match("abc");
+   |     ^^^^^^^^^^^^^^^^^^
+   |
+   = note: no matching allowed (from clippy.toml)
+
+error: use of a disallowed method `std::iter::Iterator::sum`
+  --> $DIR/conf_disallowed_methods.rs:11:5
+   |
+LL |     a.iter().sum::<i32>();
+   |     ^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 3 previous errors
+
diff --git a/tests/ui/rename.fixed b/tests/ui/rename.fixed
index 2517eeeaa01..b9425733a8b 100644
--- a/tests/ui/rename.fixed
+++ b/tests/ui/rename.fixed
@@ -6,6 +6,7 @@
 #![allow(clippy::module_name_repetitions)]
 #![allow(clippy::new_without_default)]
 #![allow(clippy::redundant_static_lifetimes)]
+#![allow(clippy::cognitive_complexity)]
 #![allow(clippy::bind_instead_of_map)]
 #![allow(clippy::box_collection)]
 #![allow(clippy::blocks_in_if_conditions)]
@@ -18,6 +19,7 @@
 #![allow(clippy::single_char_add_str)]
 #![allow(clippy::match_result_ok)]
 #![allow(clippy::disallowed_types)]
+#![allow(clippy::disallowed_methods)]
 // uplifted lints
 #![allow(invalid_value)]
 #![allow(array_into_iter)]
@@ -51,6 +53,7 @@
 #![warn(clippy::single_char_add_str)]
 #![warn(clippy::match_result_ok)]
 #![warn(clippy::disallowed_types)]
+#![warn(clippy::disallowed_methods)]
 // uplifted lints
 #![warn(invalid_value)]
 #![warn(array_into_iter)]
diff --git a/tests/ui/rename.rs b/tests/ui/rename.rs
index 7205ee0da8f..341c003b9df 100644
--- a/tests/ui/rename.rs
+++ b/tests/ui/rename.rs
@@ -6,6 +6,7 @@
 #![allow(clippy::module_name_repetitions)]
 #![allow(clippy::new_without_default)]
 #![allow(clippy::redundant_static_lifetimes)]
+#![allow(clippy::cognitive_complexity)]
 #![allow(clippy::bind_instead_of_map)]
 #![allow(clippy::box_collection)]
 #![allow(clippy::blocks_in_if_conditions)]
@@ -18,6 +19,7 @@
 #![allow(clippy::single_char_add_str)]
 #![allow(clippy::match_result_ok)]
 #![allow(clippy::disallowed_types)]
+#![allow(clippy::disallowed_methods)]
 // uplifted lints
 #![allow(invalid_value)]
 #![allow(array_into_iter)]
@@ -51,6 +53,7 @@
 #![warn(clippy::single_char_push_str)]
 #![warn(clippy::if_let_some_result)]
 #![warn(clippy::disallowed_type)]
+#![warn(clippy::disallowed_method)]
 // uplifted lints
 #![warn(clippy::invalid_ref)]
 #![warn(clippy::into_iter_on_array)]
diff --git a/tests/ui/rename.stderr b/tests/ui/rename.stderr
index 1449112996f..cdec2808f1d 100644
--- a/tests/ui/rename.stderr
+++ b/tests/ui/rename.stderr
@@ -1,5 +1,5 @@
 error: lint `clippy::stutter` has been renamed to `clippy::module_name_repetitions`
-  --> $DIR/rename.rs:32:9
+  --> $DIR/rename.rs:34:9
    |
 LL | #![warn(clippy::stutter)]
    |         ^^^^^^^^^^^^^^^ help: use the new name: `clippy::module_name_repetitions`
@@ -7,184 +7,190 @@ LL | #![warn(clippy::stutter)]
    = note: `-D renamed-and-removed-lints` implied by `-D warnings`
 
 error: lint `clippy::new_without_default_derive` has been renamed to `clippy::new_without_default`
-  --> $DIR/rename.rs:33:9
+  --> $DIR/rename.rs:35:9
    |
 LL | #![warn(clippy::new_without_default_derive)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::new_without_default`
 
 error: lint `clippy::const_static_lifetime` has been renamed to `clippy::redundant_static_lifetimes`
-  --> $DIR/rename.rs:34:9
+  --> $DIR/rename.rs:36:9
    |
 LL | #![warn(clippy::const_static_lifetime)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::redundant_static_lifetimes`
 
 error: lint `clippy::cyclomatic_complexity` has been renamed to `clippy::cognitive_complexity`
-  --> $DIR/rename.rs:35:9
+  --> $DIR/rename.rs:37:9
    |
 LL | #![warn(clippy::cyclomatic_complexity)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::cognitive_complexity`
 
 error: lint `clippy::option_and_then_some` has been renamed to `clippy::bind_instead_of_map`
-  --> $DIR/rename.rs:36:9
+  --> $DIR/rename.rs:38:9
    |
 LL | #![warn(clippy::option_and_then_some)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::bind_instead_of_map`
 
 error: lint `clippy::box_vec` has been renamed to `clippy::box_collection`
-  --> $DIR/rename.rs:37:9
+  --> $DIR/rename.rs:39:9
    |
 LL | #![warn(clippy::box_vec)]
    |         ^^^^^^^^^^^^^^^ help: use the new name: `clippy::box_collection`
 
 error: lint `clippy::block_in_if_condition_expr` has been renamed to `clippy::blocks_in_if_conditions`
-  --> $DIR/rename.rs:38:9
+  --> $DIR/rename.rs:40:9
    |
 LL | #![warn(clippy::block_in_if_condition_expr)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::blocks_in_if_conditions`
 
 error: lint `clippy::block_in_if_condition_stmt` has been renamed to `clippy::blocks_in_if_conditions`
-  --> $DIR/rename.rs:39:9
+  --> $DIR/rename.rs:41:9
    |
 LL | #![warn(clippy::block_in_if_condition_stmt)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::blocks_in_if_conditions`
 
 error: lint `clippy::option_map_unwrap_or` has been renamed to `clippy::map_unwrap_or`
-  --> $DIR/rename.rs:40:9
+  --> $DIR/rename.rs:42:9
    |
 LL | #![warn(clippy::option_map_unwrap_or)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::map_unwrap_or`
 
 error: lint `clippy::option_map_unwrap_or_else` has been renamed to `clippy::map_unwrap_or`
-  --> $DIR/rename.rs:41:9
+  --> $DIR/rename.rs:43:9
    |
 LL | #![warn(clippy::option_map_unwrap_or_else)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::map_unwrap_or`
 
 error: lint `clippy::result_map_unwrap_or_else` has been renamed to `clippy::map_unwrap_or`
-  --> $DIR/rename.rs:42:9
+  --> $DIR/rename.rs:44:9
    |
 LL | #![warn(clippy::result_map_unwrap_or_else)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::map_unwrap_or`
 
 error: lint `clippy::option_unwrap_used` has been renamed to `clippy::unwrap_used`
-  --> $DIR/rename.rs:43:9
+  --> $DIR/rename.rs:45:9
    |
 LL | #![warn(clippy::option_unwrap_used)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::unwrap_used`
 
 error: lint `clippy::result_unwrap_used` has been renamed to `clippy::unwrap_used`
-  --> $DIR/rename.rs:44:9
+  --> $DIR/rename.rs:46:9
    |
 LL | #![warn(clippy::result_unwrap_used)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::unwrap_used`
 
 error: lint `clippy::option_expect_used` has been renamed to `clippy::expect_used`
-  --> $DIR/rename.rs:45:9
+  --> $DIR/rename.rs:47:9
    |
 LL | #![warn(clippy::option_expect_used)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::expect_used`
 
 error: lint `clippy::result_expect_used` has been renamed to `clippy::expect_used`
-  --> $DIR/rename.rs:46:9
+  --> $DIR/rename.rs:48:9
    |
 LL | #![warn(clippy::result_expect_used)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::expect_used`
 
 error: lint `clippy::for_loop_over_option` has been renamed to `clippy::for_loops_over_fallibles`
-  --> $DIR/rename.rs:47:9
+  --> $DIR/rename.rs:49:9
    |
 LL | #![warn(clippy::for_loop_over_option)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::for_loops_over_fallibles`
 
 error: lint `clippy::for_loop_over_result` has been renamed to `clippy::for_loops_over_fallibles`
-  --> $DIR/rename.rs:48:9
+  --> $DIR/rename.rs:50:9
    |
 LL | #![warn(clippy::for_loop_over_result)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::for_loops_over_fallibles`
 
 error: lint `clippy::identity_conversion` has been renamed to `clippy::useless_conversion`
-  --> $DIR/rename.rs:49:9
+  --> $DIR/rename.rs:51:9
    |
 LL | #![warn(clippy::identity_conversion)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::useless_conversion`
 
 error: lint `clippy::zero_width_space` has been renamed to `clippy::invisible_characters`
-  --> $DIR/rename.rs:50:9
+  --> $DIR/rename.rs:52:9
    |
 LL | #![warn(clippy::zero_width_space)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::invisible_characters`
 
 error: lint `clippy::single_char_push_str` has been renamed to `clippy::single_char_add_str`
-  --> $DIR/rename.rs:51:9
+  --> $DIR/rename.rs:53:9
    |
 LL | #![warn(clippy::single_char_push_str)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::single_char_add_str`
 
 error: lint `clippy::if_let_some_result` has been renamed to `clippy::match_result_ok`
-  --> $DIR/rename.rs:52:9
+  --> $DIR/rename.rs:54:9
    |
 LL | #![warn(clippy::if_let_some_result)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::match_result_ok`
 
 error: lint `clippy::disallowed_type` has been renamed to `clippy::disallowed_types`
-  --> $DIR/rename.rs:53:9
+  --> $DIR/rename.rs:55:9
    |
 LL | #![warn(clippy::disallowed_type)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::disallowed_types`
 
+error: lint `clippy::disallowed_method` has been renamed to `clippy::disallowed_methods`
+  --> $DIR/rename.rs:56:9
+   |
+LL | #![warn(clippy::disallowed_method)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::disallowed_methods`
+
 error: lint `clippy::invalid_ref` has been renamed to `invalid_value`
-  --> $DIR/rename.rs:55:9
+  --> $DIR/rename.rs:58:9
    |
 LL | #![warn(clippy::invalid_ref)]
    |         ^^^^^^^^^^^^^^^^^^^ help: use the new name: `invalid_value`
 
 error: lint `clippy::into_iter_on_array` has been renamed to `array_into_iter`
-  --> $DIR/rename.rs:56:9
+  --> $DIR/rename.rs:59:9
    |
 LL | #![warn(clippy::into_iter_on_array)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `array_into_iter`
 
 error: lint `clippy::unused_label` has been renamed to `unused_labels`
-  --> $DIR/rename.rs:57:9
+  --> $DIR/rename.rs:60:9
    |
 LL | #![warn(clippy::unused_label)]
    |         ^^^^^^^^^^^^^^^^^^^^ help: use the new name: `unused_labels`
 
 error: lint `clippy::drop_bounds` has been renamed to `drop_bounds`
-  --> $DIR/rename.rs:58:9
+  --> $DIR/rename.rs:61:9
    |
 LL | #![warn(clippy::drop_bounds)]
    |         ^^^^^^^^^^^^^^^^^^^ help: use the new name: `drop_bounds`
 
 error: lint `clippy::temporary_cstring_as_ptr` has been renamed to `temporary_cstring_as_ptr`
-  --> $DIR/rename.rs:59:9
+  --> $DIR/rename.rs:62:9
    |
 LL | #![warn(clippy::temporary_cstring_as_ptr)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `temporary_cstring_as_ptr`
 
 error: lint `clippy::panic_params` has been renamed to `non_fmt_panics`
-  --> $DIR/rename.rs:60:9
+  --> $DIR/rename.rs:63:9
    |
 LL | #![warn(clippy::panic_params)]
    |         ^^^^^^^^^^^^^^^^^^^^ help: use the new name: `non_fmt_panics`
 
 error: lint `clippy::unknown_clippy_lints` has been renamed to `unknown_lints`
-  --> $DIR/rename.rs:61:9
+  --> $DIR/rename.rs:64:9
    |
 LL | #![warn(clippy::unknown_clippy_lints)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `unknown_lints`
 
 error: lint `clippy::invalid_atomic_ordering` has been renamed to `invalid_atomic_ordering`
-  --> $DIR/rename.rs:62:9
+  --> $DIR/rename.rs:65:9
    |
 LL | #![warn(clippy::invalid_atomic_ordering)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `invalid_atomic_ordering`
 
 error: lint `clippy::mem_discriminant_non_enum` has been renamed to `enum_intrinsics_non_enums`
-  --> $DIR/rename.rs:63:9
+  --> $DIR/rename.rs:66:9
    |
 LL | #![warn(clippy::mem_discriminant_non_enum)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `enum_intrinsics_non_enums`
 
-error: aborting due to 31 previous errors
+error: aborting due to 32 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From c443f8fb95da16cb9bd30bc9662f506a9e9c5a5c Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Fri, 19 Nov 2021 20:02:49 -0500
Subject: Fix `strlen_on_c_strings` when not used with a full path

---
 clippy_lints/src/strlen_on_c_strings.rs | 41 +++++++++++++++------------------
 clippy_utils/src/lib.rs                 |  8 +++++++
 clippy_utils/src/paths.rs               |  1 -
 tests/ui/strlen_on_c_strings.rs         |  3 +++
 tests/ui/strlen_on_c_strings.stderr     | 17 +++++++++++---
 5 files changed, 43 insertions(+), 27 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/strlen_on_c_strings.rs b/clippy_lints/src/strlen_on_c_strings.rs
index be7431f11aa..dc28bb97400 100644
--- a/clippy_lints/src/strlen_on_c_strings.rs
+++ b/clippy_lints/src/strlen_on_c_strings.rs
@@ -1,13 +1,13 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::paths;
-use clippy_utils::source::snippet_with_macro_callsite;
-use clippy_utils::ty::{is_type_diagnostic_item, is_type_ref_to_diagnostic_item};
+use clippy_utils::match_libc_symbol;
+use clippy_utils::source::snippet_with_context;
+use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::symbol::{sym, Symbol};
+use rustc_span::symbol::sym;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -40,28 +40,23 @@ declare_lint_pass!(StrlenOnCStrings => [STRLEN_ON_C_STRINGS]);
 
 impl LateLintPass<'tcx> for StrlenOnCStrings {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
-        if expr.span.from_expansion() {
-            return;
-        }
-
         if_chain! {
+            if !expr.span.from_expansion();
             if let hir::ExprKind::Call(func, [recv]) = expr.kind;
-            if let hir::ExprKind::Path(hir::QPath::Resolved(_, path)) = func.kind;
-
-            if (&paths::LIBC_STRLEN).iter().map(|x| Symbol::intern(x)).eq(
-                path.segments.iter().map(|seg| seg.ident.name));
-            if let hir::ExprKind::MethodCall(path, _, args, _) = recv.kind;
-            if args.len() == 1;
-            if !args.iter().any(|e| e.span.from_expansion());
+            if let hir::ExprKind::Path(path) = &func.kind;
+            if let Some(did) = cx.qpath_res(path, func.hir_id).opt_def_id();
+            if match_libc_symbol(cx, did, "strlen");
+            if let hir::ExprKind::MethodCall(path, _, [self_arg], _) = recv.kind;
+            if !recv.span.from_expansion();
             if path.ident.name == sym::as_ptr;
             then {
-                let cstring = &args[0];
-                let ty = cx.typeck_results().expr_ty(cstring);
-                let val_name = snippet_with_macro_callsite(cx, cstring.span, "..");
-                let sugg = if is_type_diagnostic_item(cx, ty, sym::cstring_type){
-                    format!("{}.as_bytes().len()", val_name)
-                } else if is_type_ref_to_diagnostic_item(cx, ty, sym::CStr){
-                    format!("{}.to_bytes().len()", val_name)
+                let ty = cx.typeck_results().expr_ty(self_arg).peel_refs();
+                let mut app = Applicability::Unspecified;
+                let val_name = snippet_with_context(cx, self_arg.span, expr.span.ctxt(), "..", &mut app).0;
+                let method_name = if is_type_diagnostic_item(cx, ty, sym::cstring_type) {
+                    "as_bytes"
+                } else if is_type_diagnostic_item(cx, ty, sym::CStr) {
+                    "to_bytes"
                 } else {
                     return;
                 };
@@ -72,7 +67,7 @@ impl LateLintPass<'tcx> for StrlenOnCStrings {
                     expr.span,
                     "using `libc::strlen` on a `CString` or `CStr` value",
                     "try this (you might also need to get rid of `unsafe` block in some cases):",
-                    sugg,
+                    format!("{}.{}().len()", val_name, method_name),
                     Applicability::Unspecified // Sometimes unnecessary `unsafe` block
                 );
             }
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 3fdea55aaa1..f011380c127 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -1597,6 +1597,14 @@ pub fn match_def_path<'tcx>(cx: &LateContext<'tcx>, did: DefId, syms: &[&str]) -
     syms.iter().map(|x| Symbol::intern(x)).eq(path.iter().copied())
 }
 
+/// Checks if the given `DefId` matches the `libc` item.
+pub fn match_libc_symbol(cx: &LateContext<'_>, did: DefId, name: &str) -> bool {
+    let path = cx.get_def_path(did);
+    // libc is meant to be used as a flat list of names, but they're all actually defined in different
+    // modules based on the target platform. Ignore everything but crate name and the item name.
+    path.first().map_or(false, |s| s.as_str() == "libc") && path.last().map_or(false, |s| s.as_str() == name)
+}
+
 pub fn match_panic_call(cx: &LateContext<'_>, expr: &'tcx Expr<'_>) -> Option<&'tcx Expr<'tcx>> {
     if let ExprKind::Call(func, [arg]) = expr.kind {
         expr_path_res(cx, func)
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index b04d1736426..3ffa548e470 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -86,7 +86,6 @@ pub const ITERTOOLS_NEXT_TUPLE: [&str; 3] = ["itertools", "Itertools", "next_tup
 pub const KW_MODULE: [&str; 3] = ["rustc_span", "symbol", "kw"];
 #[cfg(feature = "internal-lints")]
 pub const LATE_CONTEXT: [&str; 2] = ["rustc_lint", "LateContext"];
-pub const LIBC_STRLEN: [&str; 2] = ["libc", "strlen"];
 #[cfg(any(feature = "internal-lints", feature = "metadata-collector-lint"))]
 pub const LINT: [&str; 2] = ["rustc_lint_defs", "Lint"];
 pub const MEM_DISCRIMINANT: [&str; 3] = ["core", "mem", "discriminant"];
diff --git a/tests/ui/strlen_on_c_strings.rs b/tests/ui/strlen_on_c_strings.rs
index 21902fa8483..121ddf1b9b1 100644
--- a/tests/ui/strlen_on_c_strings.rs
+++ b/tests/ui/strlen_on_c_strings.rs
@@ -3,6 +3,7 @@
 #![feature(rustc_private)]
 extern crate libc;
 
+use libc::strlen;
 use std::ffi::{CStr, CString};
 
 fn main() {
@@ -13,4 +14,6 @@ fn main() {
     // CStr
     let cstr = CStr::from_bytes_with_nul(b"foo\0").expect("CStr::from_bytes_with_nul failed");
     let len = unsafe { libc::strlen(cstr.as_ptr()) };
+
+    let len = unsafe { strlen(cstr.as_ptr()) };
 }
diff --git a/tests/ui/strlen_on_c_strings.stderr b/tests/ui/strlen_on_c_strings.stderr
index e0ca511557c..5576d9d2676 100644
--- a/tests/ui/strlen_on_c_strings.stderr
+++ b/tests/ui/strlen_on_c_strings.stderr
@@ -1,5 +1,5 @@
 error: using `libc::strlen` on a `CString` or `CStr` value
-  --> $DIR/strlen_on_c_strings.rs:11:24
+  --> $DIR/strlen_on_c_strings.rs:12:24
    |
 LL |     let len = unsafe { libc::strlen(cstring.as_ptr()) };
    |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -11,7 +11,7 @@ LL |     let len = unsafe { cstring.as_bytes().len() };
    |                        ~~~~~~~~~~~~~~~~~~~~~~~~
 
 error: using `libc::strlen` on a `CString` or `CStr` value
-  --> $DIR/strlen_on_c_strings.rs:15:24
+  --> $DIR/strlen_on_c_strings.rs:16:24
    |
 LL |     let len = unsafe { libc::strlen(cstr.as_ptr()) };
    |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -21,5 +21,16 @@ help: try this (you might also need to get rid of `unsafe` block in some cases):
 LL |     let len = unsafe { cstr.to_bytes().len() };
    |                        ~~~~~~~~~~~~~~~~~~~~~
 
-error: aborting due to 2 previous errors
+error: using `libc::strlen` on a `CString` or `CStr` value
+  --> $DIR/strlen_on_c_strings.rs:18:24
+   |
+LL |     let len = unsafe { strlen(cstr.as_ptr()) };
+   |                        ^^^^^^^^^^^^^^^^^^^^^
+   |
+help: try this (you might also need to get rid of `unsafe` block in some cases):
+   |
+LL |     let len = unsafe { cstr.to_bytes().len() };
+   |                        ~~~~~~~~~~~~~~~~~~~~~
+
+error: aborting due to 3 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 0d1f1cec44c501971b9f89e4c26346eeb5d4de18 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Fri, 19 Nov 2021 20:51:20 -0500
Subject: Remove surrounding unsafe block in `strlen_on_c_strings` when
 possible

---
 clippy_lints/src/strlen_on_c_strings.rs | 34 +++++++++++------
 clippy_utils/src/visitors.rs            | 67 ++++++++++++++++++++++++++++++++-
 tests/ui/strlen_on_c_strings.rs         | 12 ++++++
 tests/ui/strlen_on_c_strings.stderr     | 46 +++++++++++++---------
 4 files changed, 128 insertions(+), 31 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/strlen_on_c_strings.rs b/clippy_lints/src/strlen_on_c_strings.rs
index dc28bb97400..fee01fb0bd1 100644
--- a/clippy_lints/src/strlen_on_c_strings.rs
+++ b/clippy_lints/src/strlen_on_c_strings.rs
@@ -1,10 +1,11 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::match_libc_symbol;
 use clippy_utils::source::snippet_with_context;
 use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::visitors::is_expr_unsafe;
+use clippy_utils::{get_parent_node, match_libc_symbol};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
-use rustc_hir as hir;
+use rustc_hir::{Block, BlockCheckMode, Expr, ExprKind, Node, UnsafeSource};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::symbol::sym;
@@ -39,20 +40,31 @@ declare_clippy_lint! {
 declare_lint_pass!(StrlenOnCStrings => [STRLEN_ON_C_STRINGS]);
 
 impl LateLintPass<'tcx> for StrlenOnCStrings {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if_chain! {
             if !expr.span.from_expansion();
-            if let hir::ExprKind::Call(func, [recv]) = expr.kind;
-            if let hir::ExprKind::Path(path) = &func.kind;
+            if let ExprKind::Call(func, [recv]) = expr.kind;
+            if let ExprKind::Path(path) = &func.kind;
             if let Some(did) = cx.qpath_res(path, func.hir_id).opt_def_id();
             if match_libc_symbol(cx, did, "strlen");
-            if let hir::ExprKind::MethodCall(path, _, [self_arg], _) = recv.kind;
+            if let ExprKind::MethodCall(path, _, [self_arg], _) = recv.kind;
             if !recv.span.from_expansion();
             if path.ident.name == sym::as_ptr;
             then {
+                let ctxt = expr.span.ctxt();
+                let span = match get_parent_node(cx.tcx, expr.hir_id) {
+                    Some(Node::Block(&Block {
+                        rules: BlockCheckMode::UnsafeBlock(UnsafeSource::UserProvided), span, ..
+                    }))
+                    if span.ctxt() == ctxt && !is_expr_unsafe(cx, self_arg) => {
+                        span
+                    }
+                    _ => expr.span,
+                };
+
                 let ty = cx.typeck_results().expr_ty(self_arg).peel_refs();
-                let mut app = Applicability::Unspecified;
-                let val_name = snippet_with_context(cx, self_arg.span, expr.span.ctxt(), "..", &mut app).0;
+                let mut app = Applicability::MachineApplicable;
+                let val_name = snippet_with_context(cx, self_arg.span, ctxt, "..", &mut app).0;
                 let method_name = if is_type_diagnostic_item(cx, ty, sym::cstring_type) {
                     "as_bytes"
                 } else if is_type_diagnostic_item(cx, ty, sym::CStr) {
@@ -64,11 +76,11 @@ impl LateLintPass<'tcx> for StrlenOnCStrings {
                 span_lint_and_sugg(
                     cx,
                     STRLEN_ON_C_STRINGS,
-                    expr.span,
+                    span,
                     "using `libc::strlen` on a `CString` or `CStr` value",
-                    "try this (you might also need to get rid of `unsafe` block in some cases):",
+                    "try this",
                     format!("{}.{}().len()", val_name, method_name),
-                    Applicability::Unspecified // Sometimes unnecessary `unsafe` block
+                    app,
                 );
             }
         }
diff --git a/clippy_utils/src/visitors.rs b/clippy_utils/src/visitors.rs
index 823df5cb751..4bfd3c64b9c 100644
--- a/clippy_utils/src/visitors.rs
+++ b/clippy_utils/src/visitors.rs
@@ -1,8 +1,10 @@
 use crate::path_to_local_id;
 use rustc_hir as hir;
 use rustc_hir::def::{DefKind, Res};
-use rustc_hir::intravisit::{self, walk_expr, NestedVisitorMap, Visitor};
-use rustc_hir::{Arm, Block, Body, BodyId, Expr, ExprKind, HirId, Stmt, UnOp};
+use rustc_hir::intravisit::{self, walk_block, walk_expr, NestedVisitorMap, Visitor};
+use rustc_hir::{
+    Arm, Block, BlockCheckMode, Body, BodyId, Expr, ExprKind, HirId, ItemId, ItemKind, Stmt, UnOp, Unsafety,
+};
 use rustc_lint::LateContext;
 use rustc_middle::hir::map::Map;
 use rustc_middle::ty;
@@ -317,3 +319,64 @@ pub fn is_const_evaluatable(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> bool {
     v.visit_expr(e);
     v.is_const
 }
+
+/// Checks if the given expression performs an unsafe operation outside of an unsafe block.
+pub fn is_expr_unsafe(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> bool {
+    struct V<'a, 'tcx> {
+        cx: &'a LateContext<'tcx>,
+        is_unsafe: bool,
+    }
+    impl<'tcx> Visitor<'tcx> for V<'_, 'tcx> {
+        type Map = Map<'tcx>;
+        fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+            NestedVisitorMap::OnlyBodies(self.cx.tcx.hir())
+        }
+        fn visit_expr(&mut self, e: &'tcx Expr<'_>) {
+            if self.is_unsafe {
+                return;
+            }
+            match e.kind {
+                ExprKind::Unary(UnOp::Deref, e) if self.cx.typeck_results().expr_ty(e).is_unsafe_ptr() => {
+                    self.is_unsafe = true;
+                },
+                ExprKind::MethodCall(..)
+                    if self
+                        .cx
+                        .typeck_results()
+                        .type_dependent_def_id(e.hir_id)
+                        .map_or(false, |id| self.cx.tcx.fn_sig(id).unsafety() == Unsafety::Unsafe) =>
+                {
+                    self.is_unsafe = true;
+                },
+                ExprKind::Call(func, _) => match *self.cx.typeck_results().expr_ty(func).peel_refs().kind() {
+                    ty::FnDef(id, _) if self.cx.tcx.fn_sig(id).unsafety() == Unsafety::Unsafe => self.is_unsafe = true,
+                    ty::FnPtr(sig) if sig.unsafety() == Unsafety::Unsafe => self.is_unsafe = true,
+                    _ => walk_expr(self, e),
+                },
+                ExprKind::Path(ref p)
+                    if self
+                        .cx
+                        .qpath_res(p, e.hir_id)
+                        .opt_def_id()
+                        .map_or(false, |id| self.cx.tcx.is_mutable_static(id)) =>
+                {
+                    self.is_unsafe = true;
+                },
+                _ => walk_expr(self, e),
+            }
+        }
+        fn visit_block(&mut self, b: &'tcx Block<'_>) {
+            if !matches!(b.rules, BlockCheckMode::UnsafeBlock(_)) {
+                walk_block(self, b);
+            }
+        }
+        fn visit_nested_item(&mut self, id: ItemId) {
+            if let ItemKind::Impl(i) = &self.cx.tcx.hir().item(id).kind {
+                self.is_unsafe = i.unsafety == Unsafety::Unsafe;
+            }
+        }
+    }
+    let mut v = V { cx, is_unsafe: false };
+    v.visit_expr(e);
+    v.is_unsafe
+}
diff --git a/tests/ui/strlen_on_c_strings.rs b/tests/ui/strlen_on_c_strings.rs
index 121ddf1b9b1..a3451d992a0 100644
--- a/tests/ui/strlen_on_c_strings.rs
+++ b/tests/ui/strlen_on_c_strings.rs
@@ -16,4 +16,16 @@ fn main() {
     let len = unsafe { libc::strlen(cstr.as_ptr()) };
 
     let len = unsafe { strlen(cstr.as_ptr()) };
+
+    let pcstr: *const &CStr = &cstr;
+    let len = unsafe { strlen((*pcstr).as_ptr()) };
+
+    unsafe fn unsafe_identity<T>(x: T) -> T {
+        x
+    }
+    let len = unsafe { strlen(unsafe_identity(cstr).as_ptr()) };
+    let len = unsafe { strlen(unsafe { unsafe_identity(cstr) }.as_ptr()) };
+
+    let f: unsafe fn(_) -> _ = unsafe_identity;
+    let len = unsafe { strlen(f(cstr).as_ptr()) };
 }
diff --git a/tests/ui/strlen_on_c_strings.stderr b/tests/ui/strlen_on_c_strings.stderr
index 5576d9d2676..0dbecda62e3 100644
--- a/tests/ui/strlen_on_c_strings.stderr
+++ b/tests/ui/strlen_on_c_strings.stderr
@@ -1,36 +1,46 @@
 error: using `libc::strlen` on a `CString` or `CStr` value
-  --> $DIR/strlen_on_c_strings.rs:12:24
+  --> $DIR/strlen_on_c_strings.rs:12:15
    |
 LL |     let len = unsafe { libc::strlen(cstring.as_ptr()) };
-   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `cstring.as_bytes().len()`
    |
    = note: `-D clippy::strlen-on-c-strings` implied by `-D warnings`
-help: try this (you might also need to get rid of `unsafe` block in some cases):
-   |
-LL |     let len = unsafe { cstring.as_bytes().len() };
-   |                        ~~~~~~~~~~~~~~~~~~~~~~~~
 
 error: using `libc::strlen` on a `CString` or `CStr` value
-  --> $DIR/strlen_on_c_strings.rs:16:24
+  --> $DIR/strlen_on_c_strings.rs:16:15
    |
 LL |     let len = unsafe { libc::strlen(cstr.as_ptr()) };
-   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `cstr.to_bytes().len()`
+
+error: using `libc::strlen` on a `CString` or `CStr` value
+  --> $DIR/strlen_on_c_strings.rs:18:15
    |
-help: try this (you might also need to get rid of `unsafe` block in some cases):
+LL |     let len = unsafe { strlen(cstr.as_ptr()) };
+   |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `cstr.to_bytes().len()`
+
+error: using `libc::strlen` on a `CString` or `CStr` value
+  --> $DIR/strlen_on_c_strings.rs:21:24
    |
-LL |     let len = unsafe { cstr.to_bytes().len() };
-   |                        ~~~~~~~~~~~~~~~~~~~~~
+LL |     let len = unsafe { strlen((*pcstr).as_ptr()) };
+   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `(*pcstr).to_bytes().len()`
 
 error: using `libc::strlen` on a `CString` or `CStr` value
-  --> $DIR/strlen_on_c_strings.rs:18:24
+  --> $DIR/strlen_on_c_strings.rs:26:24
    |
-LL |     let len = unsafe { strlen(cstr.as_ptr()) };
-   |                        ^^^^^^^^^^^^^^^^^^^^^
+LL |     let len = unsafe { strlen(unsafe_identity(cstr).as_ptr()) };
+   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unsafe_identity(cstr).to_bytes().len()`
+
+error: using `libc::strlen` on a `CString` or `CStr` value
+  --> $DIR/strlen_on_c_strings.rs:27:15
    |
-help: try this (you might also need to get rid of `unsafe` block in some cases):
+LL |     let len = unsafe { strlen(unsafe { unsafe_identity(cstr) }.as_ptr()) };
+   |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unsafe { unsafe_identity(cstr) }.to_bytes().len()`
+
+error: using `libc::strlen` on a `CString` or `CStr` value
+  --> $DIR/strlen_on_c_strings.rs:30:24
    |
-LL |     let len = unsafe { cstr.to_bytes().len() };
-   |                        ~~~~~~~~~~~~~~~~~~~~~
+LL |     let len = unsafe { strlen(f(cstr).as_ptr()) };
+   |                        ^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `f(cstr).to_bytes().len()`
 
-error: aborting due to 3 previous errors
+error: aborting due to 7 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From f4c75cde5e5226912995f6809e96efd2ac2c2348 Mon Sep 17 00:00:00 2001
From: ThibsG <thibsg@pm.me>
Date: Tue, 13 Jul 2021 11:26:24 +0200
Subject: Fix `any()` not taking reference in `search_is_some` lint

---
 clippy_lints/src/methods/search_is_some.rs | 22 +++++++++++++++++--
 tests/ui/search_is_some_fixable.fixed      | 35 ++++++++++++++++++++++++++++++
 tests/ui/search_is_some_fixable.rs         | 35 ++++++++++++++++++++++++++++++
 tests/ui/search_is_some_fixable.stderr     | 14 +++++++++++-
 4 files changed, 103 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/search_is_some.rs b/clippy_lints/src/methods/search_is_some.rs
index 0f2e58d8983..42a0a09f385 100644
--- a/clippy_lints/src/methods/search_is_some.rs
+++ b/clippy_lints/src/methods/search_is_some.rs
@@ -45,9 +45,27 @@ pub(super) fn check<'tcx>(
                 then {
                     if let hir::PatKind::Ref(..) = closure_arg.pat.kind {
                         Some(search_snippet.replacen('&', "", 1))
-                    } else if let PatKind::Binding(_, _, ident, _) = strip_pat_refs(closure_arg.pat).kind {
+                    } else if let PatKind::Binding(annotation, _, ident, _) = strip_pat_refs(closure_arg.pat).kind {
                         let name = &*ident.name.as_str();
-                        Some(search_snippet.replace(&format!("*{}", name), name))
+                        let old_search_snippet = search_snippet.clone();
+                        let search_snippet = search_snippet.replace(&format!("*{}", name), name);
+
+                        if_chain! {
+                            // if there is no dereferencing used in closure body
+                            if old_search_snippet == search_snippet;
+                            if annotation == hir::BindingAnnotation::Unannotated;
+                            if let ty::Ref(_, inner_ty, _) = cx.typeck_results().node_type(closure_arg.hir_id).kind();
+                            if let ty::Ref(..) = inner_ty.kind();
+                            // put an `&` in the closure body, but skip closure params
+                            if let Some((start, end)) = old_search_snippet.split_once(&name);
+
+                            then {
+                                let end = end.replace(name, &format!("&{}", name));
+                                Some(format!("{}{}{}", start, name, end))
+                            } else {
+                                Some(search_snippet)
+                            }
+                        }
                     } else {
                         None
                     }
diff --git a/tests/ui/search_is_some_fixable.fixed b/tests/ui/search_is_some_fixable.fixed
index 62ff16f67f4..029f557ffa6 100644
--- a/tests/ui/search_is_some_fixable.fixed
+++ b/tests/ui/search_is_some_fixable.fixed
@@ -66,3 +66,38 @@ fn is_none() {
     let _ = !s1[2..].contains(&s2);
     let _ = !s1[2..].contains(&s2[2..]);
 }
+
+#[allow(clippy::clone_on_copy, clippy::map_clone)]
+mod issue7392 {
+    struct Player {
+        hand: Vec<usize>,
+    }
+    fn filter() {
+        let p = Player {
+            hand: vec![1, 2, 3, 4, 5],
+        };
+        let filter_hand = vec![5];
+        let _ = p
+            .hand
+            .iter()
+            .filter(|c| !filter_hand.iter().any(|cc| c == &cc))
+            .map(|c| c.clone())
+            .collect::<Vec<_>>();
+    }
+
+    struct PlayerTuple {
+        hand: Vec<(usize, char)>,
+    }
+    fn filter_tuple() {
+        let p = PlayerTuple {
+            hand: vec![(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd'), (5, 'e')],
+        };
+        let filter_hand = vec![5];
+        let _ = p
+            .hand
+            .iter()
+            .filter(|(c, _)| !filter_hand.iter().any(|cc| c == cc))
+            .map(|c| c.clone())
+            .collect::<Vec<_>>();
+    }
+}
diff --git a/tests/ui/search_is_some_fixable.rs b/tests/ui/search_is_some_fixable.rs
index 8407f716647..b8f8fe3d3c1 100644
--- a/tests/ui/search_is_some_fixable.rs
+++ b/tests/ui/search_is_some_fixable.rs
@@ -66,3 +66,38 @@ fn is_none() {
     let _ = s1[2..].find(&s2).is_none();
     let _ = s1[2..].find(&s2[2..]).is_none();
 }
+
+#[allow(clippy::clone_on_copy, clippy::map_clone)]
+mod issue7392 {
+    struct Player {
+        hand: Vec<usize>,
+    }
+    fn filter() {
+        let p = Player {
+            hand: vec![1, 2, 3, 4, 5],
+        };
+        let filter_hand = vec![5];
+        let _ = p
+            .hand
+            .iter()
+            .filter(|c| filter_hand.iter().find(|cc| c == cc).is_none())
+            .map(|c| c.clone())
+            .collect::<Vec<_>>();
+    }
+
+    struct PlayerTuple {
+        hand: Vec<(usize, char)>,
+    }
+    fn filter_tuple() {
+        let p = PlayerTuple {
+            hand: vec![(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd'), (5, 'e')],
+        };
+        let filter_hand = vec![5];
+        let _ = p
+            .hand
+            .iter()
+            .filter(|(c, _)| filter_hand.iter().find(|cc| c == *cc).is_none())
+            .map(|c| c.clone())
+            .collect::<Vec<_>>();
+    }
+}
diff --git a/tests/ui/search_is_some_fixable.stderr b/tests/ui/search_is_some_fixable.stderr
index bd1b6955a97..0d92722229c 100644
--- a/tests/ui/search_is_some_fixable.stderr
+++ b/tests/ui/search_is_some_fixable.stderr
@@ -180,5 +180,17 @@ error: called `is_none()` after calling `find()` on a string
 LL |     let _ = s1[2..].find(&s2[2..]).is_none();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.contains()` instead: `!s1[2..].contains(&s2[2..])`
 
-error: aborting due to 30 previous errors
+error: called `is_none()` after searching an `Iterator` with `find`
+  --> $DIR/search_is_some_fixable.rs:83:25
+   |
+LL |             .filter(|c| filter_hand.iter().find(|cc| c == cc).is_none())
+   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.any()` instead: `!filter_hand.iter().any(|cc| c == &cc)`
+
+error: called `is_none()` after searching an `Iterator` with `find`
+  --> $DIR/search_is_some_fixable.rs:99:30
+   |
+LL |             .filter(|(c, _)| filter_hand.iter().find(|cc| c == *cc).is_none())
+   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.any()` instead: `!filter_hand.iter().any(|cc| c == cc)`
+
+error: aborting due to 32 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 5ed93af9c41e552c8d85390e2387d01eb9429174 Mon Sep 17 00:00:00 2001
From: ThibsG <Thibs@debian.com>
Date: Mon, 9 Aug 2021 12:00:35 +0200
Subject: Use `ExprUseVisitor` and multipart suggestion to avoid iffy `String`
 replacement

---
 clippy_lints/src/methods/search_is_some.rs | 186 ++++++++++++++++++++++-------
 tests/ui/search_is_some.rs                 |  45 +++++++
 tests/ui/search_is_some.stderr             | 128 +++++++++++++++++++-
 tests/ui/search_is_some_fixable.fixed      |  43 -------
 tests/ui/search_is_some_fixable.rs         |  43 -------
 tests/ui/search_is_some_fixable.stderr     |  98 ++++-----------
 6 files changed, 334 insertions(+), 209 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/search_is_some.rs b/clippy_lints/src/methods/search_is_some.rs
index 42a0a09f385..71fca601747 100644
--- a/clippy_lints/src/methods/search_is_some.rs
+++ b/clippy_lints/src/methods/search_is_some.rs
@@ -1,15 +1,19 @@
-use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg};
+use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::{snippet, snippet_with_applicability};
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::{is_trait_method, strip_pat_refs};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
-use rustc_hir::PatKind;
+use rustc_hir::{self, HirId, HirIdMap, HirIdSet, PatKind};
+use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::LateContext;
+use rustc_middle::hir::place::ProjectionKind;
+use rustc_middle::mir::FakeReadCause;
 use rustc_middle::ty;
 use rustc_span::source_map::Span;
 use rustc_span::symbol::sym;
+use rustc_typeck::expr_use_visitor::{Delegate, ExprUseVisitor, PlaceBase, PlaceWithHirId};
 
 use super::SEARCH_IS_SOME;
 
@@ -42,30 +46,42 @@ pub(super) fn check<'tcx>(
                 if let hir::ExprKind::Closure(_, _, body_id, ..) = search_arg.kind;
                 let closure_body = cx.tcx.hir().body(body_id);
                 if let Some(closure_arg) = closure_body.params.get(0);
+
                 then {
                     if let hir::PatKind::Ref(..) = closure_arg.pat.kind {
-                        Some(search_snippet.replacen('&', "", 1))
-                    } else if let PatKind::Binding(annotation, _, ident, _) = strip_pat_refs(closure_arg.pat).kind {
-                        let name = &*ident.name.as_str();
-                        let old_search_snippet = search_snippet.clone();
-                        let search_snippet = search_snippet.replace(&format!("*{}", name), name);
-
-                        if_chain! {
-                            // if there is no dereferencing used in closure body
-                            if old_search_snippet == search_snippet;
-                            if annotation == hir::BindingAnnotation::Unannotated;
-                            if let ty::Ref(_, inner_ty, _) = cx.typeck_results().node_type(closure_arg.hir_id).kind();
-                            if let ty::Ref(..) = inner_ty.kind();
-                            // put an `&` in the closure body, but skip closure params
-                            if let Some((start, end)) = old_search_snippet.split_once(&name);
-
-                            then {
-                                let end = end.replace(name, &format!("&{}", name));
-                                Some(format!("{}{}{}", start, name, end))
-                            } else {
-                                Some(search_snippet)
+                        Some((search_snippet.replacen('&', "", 1), None))
+                    } else if let PatKind::Binding(..) = strip_pat_refs(closure_arg.pat).kind {
+                        let mut visitor = DerefDelegate {
+                            cx,
+                            set: HirIdSet::default(),
+                            deref_suggs: HirIdMap::default(),
+                            borrow_suggs: HirIdMap::default()
+                        };
+
+                        let fn_def_id = cx.tcx.hir().local_def_id(search_arg.hir_id);
+                        cx.tcx.infer_ctxt().enter(|infcx| {
+                            ExprUseVisitor::new(
+                                &mut visitor, &infcx, fn_def_id, cx.param_env, cx.typeck_results()
+                            ).consume_body(closure_body);
+                        });
+
+                        let replacements = if visitor.set.is_empty() {
+                            None
+                        } else {
+                            let mut deref_suggs = Vec::new();
+                            let mut borrow_suggs = Vec::new();
+                            for node in visitor.set {
+                                let span = cx.tcx.hir().span(node);
+                                if let Some(sugg) = visitor.deref_suggs.get(&node) {
+                                    deref_suggs.push((span, sugg.clone()));
+                                }
+                                if let Some(sugg) = visitor.borrow_suggs.get(&node) {
+                                    borrow_suggs.push((span, sugg.clone()));
+                                }
                             }
-                        }
+                            Some((deref_suggs, borrow_suggs))
+                        };
+                        Some((search_snippet.to_string(), replacements))
                     } else {
                         None
                     }
@@ -74,35 +90,38 @@ pub(super) fn check<'tcx>(
                 }
             };
             // add note if not multi-line
-            if is_some {
-                span_lint_and_sugg(
-                    cx,
-                    SEARCH_IS_SOME,
+            let (closure_snippet, replacements) = any_search_snippet
+                .as_ref()
+                .map_or((&*search_snippet, None), |s| (&s.0, s.1.clone()));
+            let (span, help, sugg) = if is_some {
+                (
                     method_span.with_hi(expr.span.hi()),
-                    &msg,
                     "use `any()` instead",
-                    format!(
-                        "any({})",
-                        any_search_snippet.as_ref().map_or(&*search_snippet, String::as_str)
-                    ),
-                    Applicability::MachineApplicable,
-                );
+                    format!("any({})", closure_snippet),
+                )
             } else {
                 let iter = snippet(cx, search_recv.span, "..");
-                span_lint_and_sugg(
-                    cx,
-                    SEARCH_IS_SOME,
+                (
                     expr.span,
-                    &msg,
                     "use `!_.any()` instead",
-                    format!(
-                        "!{}.any({})",
-                        iter,
-                        any_search_snippet.as_ref().map_or(&*search_snippet, String::as_str)
-                    ),
-                    Applicability::MachineApplicable,
-                );
-            }
+                    format!("!{}.any({})", iter, closure_snippet),
+                )
+            };
+
+            span_lint_and_then(cx, SEARCH_IS_SOME, span, &msg, |db| {
+                if let Some((deref_suggs, borrow_suggs)) = replacements {
+                    db.span_suggestion(span, help, sugg, Applicability::MaybeIncorrect);
+
+                    if !deref_suggs.is_empty() {
+                        db.multipart_suggestion("...and remove deref", deref_suggs, Applicability::MaybeIncorrect);
+                    }
+                    if !borrow_suggs.is_empty() {
+                        db.multipart_suggestion("...and borrow variable", borrow_suggs, Applicability::MaybeIncorrect);
+                    }
+                } else {
+                    db.span_suggestion(span, help, sugg, Applicability::MachineApplicable);
+                }
+            });
         } else {
             let hint = format!(
                 "this is more succinctly expressed by calling `any()`{}",
@@ -164,3 +183,78 @@ pub(super) fn check<'tcx>(
         }
     }
 }
+
+struct DerefDelegate<'a, 'tcx> {
+    cx: &'a LateContext<'tcx>,
+    set: HirIdSet,
+    deref_suggs: HirIdMap<String>,
+    borrow_suggs: HirIdMap<String>,
+}
+
+impl<'tcx> Delegate<'tcx> for DerefDelegate<'_, 'tcx> {
+    fn consume(&mut self, cmt: &PlaceWithHirId<'tcx>, _: HirId) {
+        if let PlaceBase::Local(id) = cmt.place.base {
+            let map = self.cx.tcx.hir();
+            if cmt.place.projections.is_empty() {
+                self.set.insert(cmt.hir_id);
+            } else {
+                let mut replacement_str = map.name(id).to_string();
+                let last_deref = cmt
+                    .place
+                    .projections
+                    .iter()
+                    .rposition(|proj| proj.kind == ProjectionKind::Deref);
+
+                if let Some(pos) = last_deref {
+                    let mut projections = cmt.place.projections.clone();
+                    projections.truncate(pos);
+
+                    for item in projections {
+                        if item.kind == ProjectionKind::Deref {
+                            replacement_str = format!("*{}", replacement_str);
+                        }
+                    }
+
+                    self.set.insert(cmt.hir_id);
+                    self.deref_suggs.insert(cmt.hir_id, replacement_str);
+                }
+            }
+        }
+    }
+
+    fn borrow(&mut self, cmt: &PlaceWithHirId<'tcx>, _: HirId, _: ty::BorrowKind) {
+        if let PlaceBase::Local(id) = cmt.place.base {
+            let map = self.cx.tcx.hir();
+            if cmt.place.projections.is_empty() {
+                let replacement_str = format!("&{}", map.name(id).to_string());
+                self.set.insert(cmt.hir_id);
+                self.borrow_suggs.insert(cmt.hir_id, replacement_str);
+            } else {
+                let mut replacement_str = map.name(id).to_string();
+                let last_deref = cmt
+                    .place
+                    .projections
+                    .iter()
+                    .rposition(|proj| proj.kind == ProjectionKind::Deref);
+
+                if let Some(pos) = last_deref {
+                    let mut projections = cmt.place.projections.clone();
+                    projections.truncate(pos);
+
+                    for item in projections {
+                        if item.kind == ProjectionKind::Deref {
+                            replacement_str = format!("*{}", replacement_str);
+                        }
+                    }
+
+                    self.set.insert(cmt.hir_id);
+                    self.deref_suggs.insert(cmt.hir_id, replacement_str);
+                }
+            }
+        }
+    }
+
+    fn mutate(&mut self, _: &PlaceWithHirId<'tcx>, _: HirId) {}
+
+    fn fake_read(&mut self, _: rustc_typeck::expr_use_visitor::Place<'tcx>, _: FakeReadCause, _: HirId) {}
+}
diff --git a/tests/ui/search_is_some.rs b/tests/ui/search_is_some.rs
index 72bc6ef35d3..dfc79207ca7 100644
--- a/tests/ui/search_is_some.rs
+++ b/tests/ui/search_is_some.rs
@@ -36,6 +36,11 @@ fn main() {
     // check that we don't lint if `find()` is called with
     // `Pattern` that is not a string
     let _ = "hello world".find(|c: char| c == 'o' || c == 'l').is_some();
+
+    // Check `find().is_some()`, single-line case.
+    let _ = (0..1).find(|x| **y == *x).is_some(); // one dereference less
+    let _ = (0..1).find(|x| *x == 0).is_some();
+    let _ = v.iter().find(|x| **x == 0).is_some();
 }
 
 #[rustfmt::skip]
@@ -70,4 +75,44 @@ fn is_none() {
     // check that we don't lint if `find()` is called with
     // `Pattern` that is not a string
     let _ = "hello world".find(|c: char| c == 'o' || c == 'l').is_none();
+
+    // Check `find().is_none()`, single-line case.
+    let _ = (0..1).find(|x| **y == *x).is_none(); // one dereference less
+    let _ = (0..1).find(|x| *x == 0).is_none();
+    let _ = v.iter().find(|x| **x == 0).is_none();
+}
+
+#[allow(clippy::clone_on_copy, clippy::map_clone)]
+mod issue7392 {
+    struct Player {
+        hand: Vec<usize>,
+    }
+    fn filter() {
+        let p = Player {
+            hand: vec![1, 2, 3, 4, 5],
+        };
+        let filter_hand = vec![5];
+        let _ = p
+            .hand
+            .iter()
+            .filter(|c| filter_hand.iter().find(|cc| c == cc).is_none())
+            .map(|c| c.clone())
+            .collect::<Vec<_>>();
+    }
+
+    struct PlayerTuple {
+        hand: Vec<(usize, char)>,
+    }
+    fn filter_tuple() {
+        let p = PlayerTuple {
+            hand: vec![(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd'), (5, 'e')],
+        };
+        let filter_hand = vec![5];
+        let _ = p
+            .hand
+            .iter()
+            .filter(|(c, _)| filter_hand.iter().find(|cc| c == *cc).is_none())
+            .map(|c| c.clone())
+            .collect::<Vec<_>>();
+    }
 }
diff --git a/tests/ui/search_is_some.stderr b/tests/ui/search_is_some.stderr
index f3c758e451e..8db936fd948 100644
--- a/tests/ui/search_is_some.stderr
+++ b/tests/ui/search_is_some.stderr
@@ -35,8 +35,53 @@ LL | |                    ).is_some();
    |
    = help: this is more succinctly expressed by calling `any()`
 
+error: called `is_some()` after searching an `Iterator` with `find`
+  --> $DIR/search_is_some.rs:41:20
+   |
+LL |     let _ = (0..1).find(|x| **y == *x).is_some(); // one dereference less
+   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `any()` instead
+   |
+LL |     let _ = (0..1).any(|x| **y == *x); // one dereference less
+   |                    ^^^^^^^^^^^^^^^^^^
+help: ...and remove deref
+   |
+LL |     let _ = (0..1).find(|x| **y == x).is_some(); // one dereference less
+   |                                    ^
+
+error: called `is_some()` after searching an `Iterator` with `find`
+  --> $DIR/search_is_some.rs:42:20
+   |
+LL |     let _ = (0..1).find(|x| *x == 0).is_some();
+   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `any()` instead
+   |
+LL |     let _ = (0..1).any(|x| *x == 0);
+   |                    ^^^^^^^^^^^^^^^^
+help: ...and remove deref
+   |
+LL |     let _ = (0..1).find(|x| x == 0).is_some();
+   |                             ^
+
+error: called `is_some()` after searching an `Iterator` with `find`
+  --> $DIR/search_is_some.rs:43:22
+   |
+LL |     let _ = v.iter().find(|x| **x == 0).is_some();
+   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `any()` instead
+   |
+LL |     let _ = v.iter().any(|x| **x == 0);
+   |                      ^^^^^^^^^^^^^^^^^
+help: ...and remove deref
+   |
+LL |     let _ = v.iter().find(|x| *x == 0).is_some();
+   |                               ^^
+
 error: called `is_none()` after searching an `Iterator` with `find`
-  --> $DIR/search_is_some.rs:48:13
+  --> $DIR/search_is_some.rs:53:13
    |
 LL |       let _ = v.iter().find(|&x| {
    |  _____________^
@@ -48,7 +93,7 @@ LL | |                    ).is_none();
    = help: this is more succinctly expressed by calling `any()` with negation
 
 error: called `is_none()` after searching an `Iterator` with `position`
-  --> $DIR/search_is_some.rs:54:13
+  --> $DIR/search_is_some.rs:59:13
    |
 LL |       let _ = v.iter().position(|&x| {
    |  _____________^
@@ -60,7 +105,7 @@ LL | |                    ).is_none();
    = help: this is more succinctly expressed by calling `any()` with negation
 
 error: called `is_none()` after searching an `Iterator` with `rposition`
-  --> $DIR/search_is_some.rs:60:13
+  --> $DIR/search_is_some.rs:65:13
    |
 LL |       let _ = v.iter().rposition(|&x| {
    |  _____________^
@@ -71,5 +116,80 @@ LL | |                    ).is_none();
    |
    = help: this is more succinctly expressed by calling `any()` with negation
 
-error: aborting due to 6 previous errors
+error: called `is_none()` after searching an `Iterator` with `find`
+  --> $DIR/search_is_some.rs:80:13
+   |
+LL |     let _ = (0..1).find(|x| **y == *x).is_none(); // one dereference less
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `!_.any()` instead
+   |
+LL |     let _ = !(0..1).any(|x| **y == *x); // one dereference less
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
+help: ...and remove deref
+   |
+LL |     let _ = (0..1).find(|x| **y == x).is_none(); // one dereference less
+   |                                    ^
+
+error: called `is_none()` after searching an `Iterator` with `find`
+  --> $DIR/search_is_some.rs:81:13
+   |
+LL |     let _ = (0..1).find(|x| *x == 0).is_none();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `!_.any()` instead
+   |
+LL |     let _ = !(0..1).any(|x| *x == 0);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^
+help: ...and remove deref
+   |
+LL |     let _ = (0..1).find(|x| x == 0).is_none();
+   |                             ^
+
+error: called `is_none()` after searching an `Iterator` with `find`
+  --> $DIR/search_is_some.rs:82:13
+   |
+LL |     let _ = v.iter().find(|x| **x == 0).is_none();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `!_.any()` instead
+   |
+LL |     let _ = !v.iter().any(|x| **x == 0);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+help: ...and remove deref
+   |
+LL |     let _ = v.iter().find(|x| *x == 0).is_none();
+   |                               ^^
+
+error: called `is_none()` after searching an `Iterator` with `find`
+  --> $DIR/search_is_some.rs:98:25
+   |
+LL |             .filter(|c| filter_hand.iter().find(|cc| c == cc).is_none())
+   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `!_.any()` instead
+   |
+LL |             .filter(|c| !filter_hand.iter().any(|cc| c == cc))
+   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+help: ...and borrow variable
+   |
+LL |             .filter(|c| filter_hand.iter().find(|cc| c == &cc).is_none())
+   |                                                           ^^^
+
+error: called `is_none()` after searching an `Iterator` with `find`
+  --> $DIR/search_is_some.rs:114:30
+   |
+LL |             .filter(|(c, _)| filter_hand.iter().find(|cc| c == *cc).is_none())
+   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `!_.any()` instead
+   |
+LL |             .filter(|(c, _)| !filter_hand.iter().any(|cc| c == *cc))
+   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+help: ...and remove deref
+   |
+LL |             .filter(|(c, _)| filter_hand.iter().find(|cc| c == cc).is_none())
+   |                                                                ^^
+
+error: aborting due to 14 previous errors
 
diff --git a/tests/ui/search_is_some_fixable.fixed b/tests/ui/search_is_some_fixable.fixed
index 029f557ffa6..6994df427ba 100644
--- a/tests/ui/search_is_some_fixable.fixed
+++ b/tests/ui/search_is_some_fixable.fixed
@@ -4,13 +4,9 @@
 
 fn main() {
     let v = vec![3, 2, 1, 0, -1, -2, -3];
-    let y = &&42;
 
     // Check `find().is_some()`, single-line case.
     let _ = v.iter().any(|x| *x < 0);
-    let _ = (0..1).any(|x| **y == x); // one dereference less
-    let _ = (0..1).any(|x| x == 0);
-    let _ = v.iter().any(|x| *x == 0);
 
     // Check `position().is_some()`, single-line case.
     let _ = v.iter().any(|&x| x < 0);
@@ -36,13 +32,9 @@ fn main() {
 
 fn is_none() {
     let v = vec![3, 2, 1, 0, -1, -2, -3];
-    let y = &&42;
 
     // Check `find().is_none()`, single-line case.
     let _ = !v.iter().any(|x| *x < 0);
-    let _ = !(0..1).any(|x| **y == x); // one dereference less
-    let _ = !(0..1).any(|x| x == 0);
-    let _ = !v.iter().any(|x| *x == 0);
 
     // Check `position().is_none()`, single-line case.
     let _ = !v.iter().any(|&x| x < 0);
@@ -66,38 +58,3 @@ fn is_none() {
     let _ = !s1[2..].contains(&s2);
     let _ = !s1[2..].contains(&s2[2..]);
 }
-
-#[allow(clippy::clone_on_copy, clippy::map_clone)]
-mod issue7392 {
-    struct Player {
-        hand: Vec<usize>,
-    }
-    fn filter() {
-        let p = Player {
-            hand: vec![1, 2, 3, 4, 5],
-        };
-        let filter_hand = vec![5];
-        let _ = p
-            .hand
-            .iter()
-            .filter(|c| !filter_hand.iter().any(|cc| c == &cc))
-            .map(|c| c.clone())
-            .collect::<Vec<_>>();
-    }
-
-    struct PlayerTuple {
-        hand: Vec<(usize, char)>,
-    }
-    fn filter_tuple() {
-        let p = PlayerTuple {
-            hand: vec![(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd'), (5, 'e')],
-        };
-        let filter_hand = vec![5];
-        let _ = p
-            .hand
-            .iter()
-            .filter(|(c, _)| !filter_hand.iter().any(|cc| c == cc))
-            .map(|c| c.clone())
-            .collect::<Vec<_>>();
-    }
-}
diff --git a/tests/ui/search_is_some_fixable.rs b/tests/ui/search_is_some_fixable.rs
index b8f8fe3d3c1..d4c9d89e7b8 100644
--- a/tests/ui/search_is_some_fixable.rs
+++ b/tests/ui/search_is_some_fixable.rs
@@ -4,13 +4,9 @@
 
 fn main() {
     let v = vec![3, 2, 1, 0, -1, -2, -3];
-    let y = &&42;
 
     // Check `find().is_some()`, single-line case.
     let _ = v.iter().find(|&x| *x < 0).is_some();
-    let _ = (0..1).find(|x| **y == *x).is_some(); // one dereference less
-    let _ = (0..1).find(|x| *x == 0).is_some();
-    let _ = v.iter().find(|x| **x == 0).is_some();
 
     // Check `position().is_some()`, single-line case.
     let _ = v.iter().position(|&x| x < 0).is_some();
@@ -36,13 +32,9 @@ fn main() {
 
 fn is_none() {
     let v = vec![3, 2, 1, 0, -1, -2, -3];
-    let y = &&42;
 
     // Check `find().is_none()`, single-line case.
     let _ = v.iter().find(|&x| *x < 0).is_none();
-    let _ = (0..1).find(|x| **y == *x).is_none(); // one dereference less
-    let _ = (0..1).find(|x| *x == 0).is_none();
-    let _ = v.iter().find(|x| **x == 0).is_none();
 
     // Check `position().is_none()`, single-line case.
     let _ = v.iter().position(|&x| x < 0).is_none();
@@ -66,38 +58,3 @@ fn is_none() {
     let _ = s1[2..].find(&s2).is_none();
     let _ = s1[2..].find(&s2[2..]).is_none();
 }
-
-#[allow(clippy::clone_on_copy, clippy::map_clone)]
-mod issue7392 {
-    struct Player {
-        hand: Vec<usize>,
-    }
-    fn filter() {
-        let p = Player {
-            hand: vec![1, 2, 3, 4, 5],
-        };
-        let filter_hand = vec![5];
-        let _ = p
-            .hand
-            .iter()
-            .filter(|c| filter_hand.iter().find(|cc| c == cc).is_none())
-            .map(|c| c.clone())
-            .collect::<Vec<_>>();
-    }
-
-    struct PlayerTuple {
-        hand: Vec<(usize, char)>,
-    }
-    fn filter_tuple() {
-        let p = PlayerTuple {
-            hand: vec![(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd'), (5, 'e')],
-        };
-        let filter_hand = vec![5];
-        let _ = p
-            .hand
-            .iter()
-            .filter(|(c, _)| filter_hand.iter().find(|cc| c == *cc).is_none())
-            .map(|c| c.clone())
-            .collect::<Vec<_>>();
-    }
-}
diff --git a/tests/ui/search_is_some_fixable.stderr b/tests/ui/search_is_some_fixable.stderr
index 0d92722229c..5e77c9a5bac 100644
--- a/tests/ui/search_is_some_fixable.stderr
+++ b/tests/ui/search_is_some_fixable.stderr
@@ -1,196 +1,148 @@
 error: called `is_some()` after searching an `Iterator` with `find`
-  --> $DIR/search_is_some_fixable.rs:10:22
+  --> $DIR/search_is_some_fixable.rs:9:22
    |
 LL |     let _ = v.iter().find(|&x| *x < 0).is_some();
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `any()` instead: `any(|x| *x < 0)`
    |
    = note: `-D clippy::search-is-some` implied by `-D warnings`
 
-error: called `is_some()` after searching an `Iterator` with `find`
-  --> $DIR/search_is_some_fixable.rs:11:20
-   |
-LL |     let _ = (0..1).find(|x| **y == *x).is_some(); // one dereference less
-   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `any()` instead: `any(|x| **y == x)`
-
-error: called `is_some()` after searching an `Iterator` with `find`
-  --> $DIR/search_is_some_fixable.rs:12:20
-   |
-LL |     let _ = (0..1).find(|x| *x == 0).is_some();
-   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `any()` instead: `any(|x| x == 0)`
-
-error: called `is_some()` after searching an `Iterator` with `find`
-  --> $DIR/search_is_some_fixable.rs:13:22
-   |
-LL |     let _ = v.iter().find(|x| **x == 0).is_some();
-   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `any()` instead: `any(|x| *x == 0)`
-
 error: called `is_some()` after searching an `Iterator` with `position`
-  --> $DIR/search_is_some_fixable.rs:16:22
+  --> $DIR/search_is_some_fixable.rs:12:22
    |
 LL |     let _ = v.iter().position(|&x| x < 0).is_some();
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `any()` instead: `any(|&x| x < 0)`
 
 error: called `is_some()` after searching an `Iterator` with `rposition`
-  --> $DIR/search_is_some_fixable.rs:19:22
+  --> $DIR/search_is_some_fixable.rs:15:22
    |
 LL |     let _ = v.iter().rposition(|&x| x < 0).is_some();
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `any()` instead: `any(|&x| x < 0)`
 
 error: called `is_some()` after calling `find()` on a string
-  --> $DIR/search_is_some_fixable.rs:24:27
+  --> $DIR/search_is_some_fixable.rs:20:27
    |
 LL |     let _ = "hello world".find("world").is_some();
    |                           ^^^^^^^^^^^^^^^^^^^^^^^ help: use `contains()` instead: `contains("world")`
 
 error: called `is_some()` after calling `find()` on a string
-  --> $DIR/search_is_some_fixable.rs:25:27
+  --> $DIR/search_is_some_fixable.rs:21:27
    |
 LL |     let _ = "hello world".find(&s2).is_some();
    |                           ^^^^^^^^^^^^^^^^^^^ help: use `contains()` instead: `contains(&s2)`
 
 error: called `is_some()` after calling `find()` on a string
-  --> $DIR/search_is_some_fixable.rs:26:27
+  --> $DIR/search_is_some_fixable.rs:22:27
    |
 LL |     let _ = "hello world".find(&s2[2..]).is_some();
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^ help: use `contains()` instead: `contains(&s2[2..])`
 
 error: called `is_some()` after calling `find()` on a string
-  --> $DIR/search_is_some_fixable.rs:28:16
+  --> $DIR/search_is_some_fixable.rs:24:16
    |
 LL |     let _ = s1.find("world").is_some();
    |                ^^^^^^^^^^^^^^^^^^^^^^^ help: use `contains()` instead: `contains("world")`
 
 error: called `is_some()` after calling `find()` on a string
-  --> $DIR/search_is_some_fixable.rs:29:16
+  --> $DIR/search_is_some_fixable.rs:25:16
    |
 LL |     let _ = s1.find(&s2).is_some();
    |                ^^^^^^^^^^^^^^^^^^^ help: use `contains()` instead: `contains(&s2)`
 
 error: called `is_some()` after calling `find()` on a string
-  --> $DIR/search_is_some_fixable.rs:30:16
+  --> $DIR/search_is_some_fixable.rs:26:16
    |
 LL |     let _ = s1.find(&s2[2..]).is_some();
    |                ^^^^^^^^^^^^^^^^^^^^^^^^ help: use `contains()` instead: `contains(&s2[2..])`
 
 error: called `is_some()` after calling `find()` on a string
-  --> $DIR/search_is_some_fixable.rs:32:21
+  --> $DIR/search_is_some_fixable.rs:28:21
    |
 LL |     let _ = s1[2..].find("world").is_some();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^ help: use `contains()` instead: `contains("world")`
 
 error: called `is_some()` after calling `find()` on a string
-  --> $DIR/search_is_some_fixable.rs:33:21
+  --> $DIR/search_is_some_fixable.rs:29:21
    |
 LL |     let _ = s1[2..].find(&s2).is_some();
    |                     ^^^^^^^^^^^^^^^^^^^ help: use `contains()` instead: `contains(&s2)`
 
 error: called `is_some()` after calling `find()` on a string
-  --> $DIR/search_is_some_fixable.rs:34:21
+  --> $DIR/search_is_some_fixable.rs:30:21
    |
 LL |     let _ = s1[2..].find(&s2[2..]).is_some();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^ help: use `contains()` instead: `contains(&s2[2..])`
 
 error: called `is_none()` after searching an `Iterator` with `find`
-  --> $DIR/search_is_some_fixable.rs:42:13
+  --> $DIR/search_is_some_fixable.rs:37:13
    |
 LL |     let _ = v.iter().find(|&x| *x < 0).is_none();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.any()` instead: `!v.iter().any(|x| *x < 0)`
 
-error: called `is_none()` after searching an `Iterator` with `find`
-  --> $DIR/search_is_some_fixable.rs:43:13
-   |
-LL |     let _ = (0..1).find(|x| **y == *x).is_none(); // one dereference less
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.any()` instead: `!(0..1).any(|x| **y == x)`
-
-error: called `is_none()` after searching an `Iterator` with `find`
-  --> $DIR/search_is_some_fixable.rs:44:13
-   |
-LL |     let _ = (0..1).find(|x| *x == 0).is_none();
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.any()` instead: `!(0..1).any(|x| x == 0)`
-
-error: called `is_none()` after searching an `Iterator` with `find`
-  --> $DIR/search_is_some_fixable.rs:45:13
-   |
-LL |     let _ = v.iter().find(|x| **x == 0).is_none();
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.any()` instead: `!v.iter().any(|x| *x == 0)`
-
 error: called `is_none()` after searching an `Iterator` with `position`
-  --> $DIR/search_is_some_fixable.rs:48:13
+  --> $DIR/search_is_some_fixable.rs:40:13
    |
 LL |     let _ = v.iter().position(|&x| x < 0).is_none();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.any()` instead: `!v.iter().any(|&x| x < 0)`
 
 error: called `is_none()` after searching an `Iterator` with `rposition`
-  --> $DIR/search_is_some_fixable.rs:51:13
+  --> $DIR/search_is_some_fixable.rs:43:13
    |
 LL |     let _ = v.iter().rposition(|&x| x < 0).is_none();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.any()` instead: `!v.iter().any(|&x| x < 0)`
 
 error: called `is_none()` after calling `find()` on a string
-  --> $DIR/search_is_some_fixable.rs:57:13
+  --> $DIR/search_is_some_fixable.rs:49:13
    |
 LL |     let _ = "hello world".find("world").is_none();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.contains()` instead: `!"hello world".contains("world")`
 
 error: called `is_none()` after calling `find()` on a string
-  --> $DIR/search_is_some_fixable.rs:58:13
+  --> $DIR/search_is_some_fixable.rs:50:13
    |
 LL |     let _ = "hello world".find(&s2).is_none();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.contains()` instead: `!"hello world".contains(&s2)`
 
 error: called `is_none()` after calling `find()` on a string
-  --> $DIR/search_is_some_fixable.rs:59:13
+  --> $DIR/search_is_some_fixable.rs:51:13
    |
 LL |     let _ = "hello world".find(&s2[2..]).is_none();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.contains()` instead: `!"hello world".contains(&s2[2..])`
 
 error: called `is_none()` after calling `find()` on a string
-  --> $DIR/search_is_some_fixable.rs:61:13
+  --> $DIR/search_is_some_fixable.rs:53:13
    |
 LL |     let _ = s1.find("world").is_none();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.contains()` instead: `!s1.contains("world")`
 
 error: called `is_none()` after calling `find()` on a string
-  --> $DIR/search_is_some_fixable.rs:62:13
+  --> $DIR/search_is_some_fixable.rs:54:13
    |
 LL |     let _ = s1.find(&s2).is_none();
    |             ^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.contains()` instead: `!s1.contains(&s2)`
 
 error: called `is_none()` after calling `find()` on a string
-  --> $DIR/search_is_some_fixable.rs:63:13
+  --> $DIR/search_is_some_fixable.rs:55:13
    |
 LL |     let _ = s1.find(&s2[2..]).is_none();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.contains()` instead: `!s1.contains(&s2[2..])`
 
 error: called `is_none()` after calling `find()` on a string
-  --> $DIR/search_is_some_fixable.rs:65:13
+  --> $DIR/search_is_some_fixable.rs:57:13
    |
 LL |     let _ = s1[2..].find("world").is_none();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.contains()` instead: `!s1[2..].contains("world")`
 
 error: called `is_none()` after calling `find()` on a string
-  --> $DIR/search_is_some_fixable.rs:66:13
+  --> $DIR/search_is_some_fixable.rs:58:13
    |
 LL |     let _ = s1[2..].find(&s2).is_none();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.contains()` instead: `!s1[2..].contains(&s2)`
 
 error: called `is_none()` after calling `find()` on a string
-  --> $DIR/search_is_some_fixable.rs:67:13
+  --> $DIR/search_is_some_fixable.rs:59:13
    |
 LL |     let _ = s1[2..].find(&s2[2..]).is_none();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.contains()` instead: `!s1[2..].contains(&s2[2..])`
 
-error: called `is_none()` after searching an `Iterator` with `find`
-  --> $DIR/search_is_some_fixable.rs:83:25
-   |
-LL |             .filter(|c| filter_hand.iter().find(|cc| c == cc).is_none())
-   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.any()` instead: `!filter_hand.iter().any(|cc| c == &cc)`
-
-error: called `is_none()` after searching an `Iterator` with `find`
-  --> $DIR/search_is_some_fixable.rs:99:30
-   |
-LL |             .filter(|(c, _)| filter_hand.iter().find(|cc| c == *cc).is_none())
-   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.any()` instead: `!filter_hand.iter().any(|cc| c == cc)`
-
-error: aborting due to 32 previous errors
+error: aborting due to 24 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From b38f173aa329d6a5932414b9c76227d790faee76 Mon Sep 17 00:00:00 2001
From: ThibsG <thibsg@pm.me>
Date: Wed, 18 Aug 2021 16:51:34 +0200
Subject: Build suggestion within visitor + add more tests

---
 clippy_lints/src/methods/search_is_some.rs | 202 +++++++++++++++--------------
 tests/ui/search_is_some.rs                 |  45 -------
 tests/ui/search_is_some.stderr             | 128 +-----------------
 tests/ui/search_is_some_fixable.fixed      |  54 ++++++++
 tests/ui/search_is_some_fixable.rs         |  57 ++++++++
 tests/ui/search_is_some_fixable.stderr     | 163 +++++++++++++++++++----
 6 files changed, 355 insertions(+), 294 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/search_is_some.rs b/clippy_lints/src/methods/search_is_some.rs
index 71fca601747..ee0e6d3a33f 100644
--- a/clippy_lints/src/methods/search_is_some.rs
+++ b/clippy_lints/src/methods/search_is_some.rs
@@ -1,17 +1,17 @@
-use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg, span_lint_and_then};
+use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg};
 use clippy_utils::source::{snippet, snippet_with_applicability};
 use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{is_trait_method, strip_pat_refs};
+use clippy_utils::{get_parent_expr_for_hir, is_trait_method, strip_pat_refs};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
-use rustc_hir::{self, HirId, HirIdMap, HirIdSet, PatKind};
+use rustc_hir::{self, Expr, ExprKind, HirId, PatKind};
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::LateContext;
 use rustc_middle::hir::place::ProjectionKind;
-use rustc_middle::mir::FakeReadCause;
+use rustc_middle::mir::{FakeReadCause, Mutability};
 use rustc_middle::ty;
-use rustc_span::source_map::Span;
+use rustc_span::source_map::{BytePos, Span};
 use rustc_span::symbol::sym;
 use rustc_typeck::expr_use_visitor::{Delegate, ExprUseVisitor, PlaceBase, PlaceWithHirId};
 
@@ -46,42 +46,12 @@ pub(super) fn check<'tcx>(
                 if let hir::ExprKind::Closure(_, _, body_id, ..) = search_arg.kind;
                 let closure_body = cx.tcx.hir().body(body_id);
                 if let Some(closure_arg) = closure_body.params.get(0);
-
                 then {
                     if let hir::PatKind::Ref(..) = closure_arg.pat.kind {
-                        Some((search_snippet.replacen('&', "", 1), None))
+                        Some(search_snippet.replacen('&', "", 1))
                     } else if let PatKind::Binding(..) = strip_pat_refs(closure_arg.pat).kind {
-                        let mut visitor = DerefDelegate {
-                            cx,
-                            set: HirIdSet::default(),
-                            deref_suggs: HirIdMap::default(),
-                            borrow_suggs: HirIdMap::default()
-                        };
-
-                        let fn_def_id = cx.tcx.hir().local_def_id(search_arg.hir_id);
-                        cx.tcx.infer_ctxt().enter(|infcx| {
-                            ExprUseVisitor::new(
-                                &mut visitor, &infcx, fn_def_id, cx.param_env, cx.typeck_results()
-                            ).consume_body(closure_body);
-                        });
-
-                        let replacements = if visitor.set.is_empty() {
-                            None
-                        } else {
-                            let mut deref_suggs = Vec::new();
-                            let mut borrow_suggs = Vec::new();
-                            for node in visitor.set {
-                                let span = cx.tcx.hir().span(node);
-                                if let Some(sugg) = visitor.deref_suggs.get(&node) {
-                                    deref_suggs.push((span, sugg.clone()));
-                                }
-                                if let Some(sugg) = visitor.borrow_suggs.get(&node) {
-                                    borrow_suggs.push((span, sugg.clone()));
-                                }
-                            }
-                            Some((deref_suggs, borrow_suggs))
-                        };
-                        Some((search_snippet.to_string(), replacements))
+                        get_closure_suggestion(cx, search_arg, closure_body)
+                            .or_else(|| Some(search_snippet.to_string()))
                     } else {
                         None
                     }
@@ -90,38 +60,35 @@ pub(super) fn check<'tcx>(
                 }
             };
             // add note if not multi-line
-            let (closure_snippet, replacements) = any_search_snippet
-                .as_ref()
-                .map_or((&*search_snippet, None), |s| (&s.0, s.1.clone()));
-            let (span, help, sugg) = if is_some {
-                (
+            if is_some {
+                span_lint_and_sugg(
+                    cx,
+                    SEARCH_IS_SOME,
                     method_span.with_hi(expr.span.hi()),
+                    &msg,
                     "use `any()` instead",
-                    format!("any({})", closure_snippet),
-                )
+                    format!(
+                        "any({})",
+                        any_search_snippet.as_ref().map_or(&*search_snippet, String::as_str)
+                    ),
+                    Applicability::MachineApplicable,
+                );
             } else {
                 let iter = snippet(cx, search_recv.span, "..");
-                (
+                span_lint_and_sugg(
+                    cx,
+                    SEARCH_IS_SOME,
                     expr.span,
+                    &msg,
                     "use `!_.any()` instead",
-                    format!("!{}.any({})", iter, closure_snippet),
-                )
-            };
-
-            span_lint_and_then(cx, SEARCH_IS_SOME, span, &msg, |db| {
-                if let Some((deref_suggs, borrow_suggs)) = replacements {
-                    db.span_suggestion(span, help, sugg, Applicability::MaybeIncorrect);
-
-                    if !deref_suggs.is_empty() {
-                        db.multipart_suggestion("...and remove deref", deref_suggs, Applicability::MaybeIncorrect);
-                    }
-                    if !borrow_suggs.is_empty() {
-                        db.multipart_suggestion("...and borrow variable", borrow_suggs, Applicability::MaybeIncorrect);
-                    }
-                } else {
-                    db.span_suggestion(span, help, sugg, Applicability::MachineApplicable);
-                }
-            });
+                    format!(
+                        "!{}.any({})",
+                        iter,
+                        any_search_snippet.as_ref().map_or(&*search_snippet, String::as_str)
+                    ),
+                    Applicability::MachineApplicable,
+                );
+            }
         } else {
             let hint = format!(
                 "this is more succinctly expressed by calling `any()`{}",
@@ -184,53 +151,86 @@ pub(super) fn check<'tcx>(
     }
 }
 
+fn get_closure_suggestion<'tcx>(
+    cx: &LateContext<'_>,
+    search_arg: &'tcx hir::Expr<'_>,
+    closure_body: &hir::Body<'_>,
+) -> Option<String> {
+    let mut visitor = DerefDelegate {
+        cx,
+        closure_span: search_arg.span,
+        next_pos: None,
+        suggestion_start: String::new(),
+        suggestion_end: String::new(),
+    };
+
+    let fn_def_id = cx.tcx.hir().local_def_id(search_arg.hir_id);
+    cx.tcx.infer_ctxt().enter(|infcx| {
+        ExprUseVisitor::new(&mut visitor, &infcx, fn_def_id, cx.param_env, cx.typeck_results())
+            .consume_body(closure_body);
+    });
+
+    if visitor.suggestion_start.is_empty() {
+        None
+    } else {
+        Some(format!("{}{}", visitor.suggestion_start, visitor.suggestion_end))
+    }
+}
+
 struct DerefDelegate<'a, 'tcx> {
     cx: &'a LateContext<'tcx>,
-    set: HirIdSet,
-    deref_suggs: HirIdMap<String>,
-    borrow_suggs: HirIdMap<String>,
+    closure_span: Span,
+    next_pos: Option<BytePos>,
+    suggestion_start: String,
+    suggestion_end: String,
 }
 
 impl<'tcx> Delegate<'tcx> for DerefDelegate<'_, 'tcx> {
-    fn consume(&mut self, cmt: &PlaceWithHirId<'tcx>, _: HirId) {
+    fn consume(&mut self, _: &PlaceWithHirId<'tcx>, _: HirId) {}
+
+    fn borrow(&mut self, cmt: &PlaceWithHirId<'tcx>, _: HirId, _: ty::BorrowKind) {
         if let PlaceBase::Local(id) = cmt.place.base {
             let map = self.cx.tcx.hir();
-            if cmt.place.projections.is_empty() {
-                self.set.insert(cmt.hir_id);
+            let ident_str = map.name(id).to_string();
+            let span = map.span(cmt.hir_id);
+            let start_span = if let Some(next_pos) = self.next_pos {
+                Span::new(next_pos, span.lo(), span.ctxt())
             } else {
-                let mut replacement_str = map.name(id).to_string();
-                let last_deref = cmt
-                    .place
-                    .projections
-                    .iter()
-                    .rposition(|proj| proj.kind == ProjectionKind::Deref);
+                self.closure_span.until(span)
+            };
+            let start_snip = snippet(self.cx, start_span, "..");
+            let end_span = Span::new(span.hi(), self.closure_span.hi(), span.ctxt());
+            let end_snip = snippet(self.cx, end_span, "..");
 
-                if let Some(pos) = last_deref {
-                    let mut projections = cmt.place.projections.clone();
-                    projections.truncate(pos);
+            if cmt.place.projections.is_empty() {
+                self.suggestion_start.push_str(&format!("{}&{}", start_snip, ident_str));
+            } else {
+                let parent_expr = get_parent_expr_for_hir(self.cx, cmt.hir_id);
+                if let Some(Expr { hir_id: _, kind, .. }) = parent_expr {
+                    if let ExprKind::Call(_, args) | ExprKind::MethodCall(_, _, args, _) = kind {
+                        let args_to_handle = args.iter().filter(|arg| arg.hir_id == cmt.hir_id).collect::<Vec<_>>();
+                        if !args_to_handle.is_empty() {
+                            for arg in &args_to_handle {
+                                let arg_ty_kind = self.cx.typeck_results().expr_ty(arg).kind();
+                                if matches!(arg_ty_kind, ty::Ref(_, _, Mutability::Not)) {
+                                    let start_span = if let Some(next_pos) = self.next_pos {
+                                        Span::new(next_pos, span.lo(), span.ctxt())
+                                    } else {
+                                        self.closure_span.until(span)
+                                    };
+                                    let start_snip = snippet(self.cx, start_span, "..");
 
-                    for item in projections {
-                        if item.kind == ProjectionKind::Deref {
-                            replacement_str = format!("*{}", replacement_str);
+                                    self.suggestion_start.push_str(&format!("{}&{}", start_snip, ident_str));
+                                    self.suggestion_end = end_snip.to_string();
+                                    self.next_pos = Some(span.hi());
+                                }
+                            }
+                            return;
                         }
                     }
-
-                    self.set.insert(cmt.hir_id);
-                    self.deref_suggs.insert(cmt.hir_id, replacement_str);
                 }
-            }
-        }
-    }
 
-    fn borrow(&mut self, cmt: &PlaceWithHirId<'tcx>, _: HirId, _: ty::BorrowKind) {
-        if let PlaceBase::Local(id) = cmt.place.base {
-            let map = self.cx.tcx.hir();
-            if cmt.place.projections.is_empty() {
-                let replacement_str = format!("&{}", map.name(id).to_string());
-                self.set.insert(cmt.hir_id);
-                self.borrow_suggs.insert(cmt.hir_id, replacement_str);
-            } else {
-                let mut replacement_str = map.name(id).to_string();
+                let mut replacement_str = ident_str;
                 let last_deref = cmt
                     .place
                     .projections
@@ -246,11 +246,13 @@ impl<'tcx> Delegate<'tcx> for DerefDelegate<'_, 'tcx> {
                             replacement_str = format!("*{}", replacement_str);
                         }
                     }
-
-                    self.set.insert(cmt.hir_id);
-                    self.deref_suggs.insert(cmt.hir_id, replacement_str);
                 }
+
+                self.suggestion_start
+                    .push_str(&format!("{}{}", start_snip, replacement_str));
+                self.suggestion_end = end_snip.to_string();
             }
+            self.next_pos = Some(span.hi());
         }
     }
 
diff --git a/tests/ui/search_is_some.rs b/tests/ui/search_is_some.rs
index dfc79207ca7..72bc6ef35d3 100644
--- a/tests/ui/search_is_some.rs
+++ b/tests/ui/search_is_some.rs
@@ -36,11 +36,6 @@ fn main() {
     // check that we don't lint if `find()` is called with
     // `Pattern` that is not a string
     let _ = "hello world".find(|c: char| c == 'o' || c == 'l').is_some();
-
-    // Check `find().is_some()`, single-line case.
-    let _ = (0..1).find(|x| **y == *x).is_some(); // one dereference less
-    let _ = (0..1).find(|x| *x == 0).is_some();
-    let _ = v.iter().find(|x| **x == 0).is_some();
 }
 
 #[rustfmt::skip]
@@ -75,44 +70,4 @@ fn is_none() {
     // check that we don't lint if `find()` is called with
     // `Pattern` that is not a string
     let _ = "hello world".find(|c: char| c == 'o' || c == 'l').is_none();
-
-    // Check `find().is_none()`, single-line case.
-    let _ = (0..1).find(|x| **y == *x).is_none(); // one dereference less
-    let _ = (0..1).find(|x| *x == 0).is_none();
-    let _ = v.iter().find(|x| **x == 0).is_none();
-}
-
-#[allow(clippy::clone_on_copy, clippy::map_clone)]
-mod issue7392 {
-    struct Player {
-        hand: Vec<usize>,
-    }
-    fn filter() {
-        let p = Player {
-            hand: vec![1, 2, 3, 4, 5],
-        };
-        let filter_hand = vec![5];
-        let _ = p
-            .hand
-            .iter()
-            .filter(|c| filter_hand.iter().find(|cc| c == cc).is_none())
-            .map(|c| c.clone())
-            .collect::<Vec<_>>();
-    }
-
-    struct PlayerTuple {
-        hand: Vec<(usize, char)>,
-    }
-    fn filter_tuple() {
-        let p = PlayerTuple {
-            hand: vec![(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd'), (5, 'e')],
-        };
-        let filter_hand = vec![5];
-        let _ = p
-            .hand
-            .iter()
-            .filter(|(c, _)| filter_hand.iter().find(|cc| c == *cc).is_none())
-            .map(|c| c.clone())
-            .collect::<Vec<_>>();
-    }
 }
diff --git a/tests/ui/search_is_some.stderr b/tests/ui/search_is_some.stderr
index 8db936fd948..f3c758e451e 100644
--- a/tests/ui/search_is_some.stderr
+++ b/tests/ui/search_is_some.stderr
@@ -35,53 +35,8 @@ LL | |                    ).is_some();
    |
    = help: this is more succinctly expressed by calling `any()`
 
-error: called `is_some()` after searching an `Iterator` with `find`
-  --> $DIR/search_is_some.rs:41:20
-   |
-LL |     let _ = (0..1).find(|x| **y == *x).is_some(); // one dereference less
-   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: use `any()` instead
-   |
-LL |     let _ = (0..1).any(|x| **y == *x); // one dereference less
-   |                    ^^^^^^^^^^^^^^^^^^
-help: ...and remove deref
-   |
-LL |     let _ = (0..1).find(|x| **y == x).is_some(); // one dereference less
-   |                                    ^
-
-error: called `is_some()` after searching an `Iterator` with `find`
-  --> $DIR/search_is_some.rs:42:20
-   |
-LL |     let _ = (0..1).find(|x| *x == 0).is_some();
-   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: use `any()` instead
-   |
-LL |     let _ = (0..1).any(|x| *x == 0);
-   |                    ^^^^^^^^^^^^^^^^
-help: ...and remove deref
-   |
-LL |     let _ = (0..1).find(|x| x == 0).is_some();
-   |                             ^
-
-error: called `is_some()` after searching an `Iterator` with `find`
-  --> $DIR/search_is_some.rs:43:22
-   |
-LL |     let _ = v.iter().find(|x| **x == 0).is_some();
-   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: use `any()` instead
-   |
-LL |     let _ = v.iter().any(|x| **x == 0);
-   |                      ^^^^^^^^^^^^^^^^^
-help: ...and remove deref
-   |
-LL |     let _ = v.iter().find(|x| *x == 0).is_some();
-   |                               ^^
-
 error: called `is_none()` after searching an `Iterator` with `find`
-  --> $DIR/search_is_some.rs:53:13
+  --> $DIR/search_is_some.rs:48:13
    |
 LL |       let _ = v.iter().find(|&x| {
    |  _____________^
@@ -93,7 +48,7 @@ LL | |                    ).is_none();
    = help: this is more succinctly expressed by calling `any()` with negation
 
 error: called `is_none()` after searching an `Iterator` with `position`
-  --> $DIR/search_is_some.rs:59:13
+  --> $DIR/search_is_some.rs:54:13
    |
 LL |       let _ = v.iter().position(|&x| {
    |  _____________^
@@ -105,7 +60,7 @@ LL | |                    ).is_none();
    = help: this is more succinctly expressed by calling `any()` with negation
 
 error: called `is_none()` after searching an `Iterator` with `rposition`
-  --> $DIR/search_is_some.rs:65:13
+  --> $DIR/search_is_some.rs:60:13
    |
 LL |       let _ = v.iter().rposition(|&x| {
    |  _____________^
@@ -116,80 +71,5 @@ LL | |                    ).is_none();
    |
    = help: this is more succinctly expressed by calling `any()` with negation
 
-error: called `is_none()` after searching an `Iterator` with `find`
-  --> $DIR/search_is_some.rs:80:13
-   |
-LL |     let _ = (0..1).find(|x| **y == *x).is_none(); // one dereference less
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: use `!_.any()` instead
-   |
-LL |     let _ = !(0..1).any(|x| **y == *x); // one dereference less
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
-help: ...and remove deref
-   |
-LL |     let _ = (0..1).find(|x| **y == x).is_none(); // one dereference less
-   |                                    ^
-
-error: called `is_none()` after searching an `Iterator` with `find`
-  --> $DIR/search_is_some.rs:81:13
-   |
-LL |     let _ = (0..1).find(|x| *x == 0).is_none();
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: use `!_.any()` instead
-   |
-LL |     let _ = !(0..1).any(|x| *x == 0);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^
-help: ...and remove deref
-   |
-LL |     let _ = (0..1).find(|x| x == 0).is_none();
-   |                             ^
-
-error: called `is_none()` after searching an `Iterator` with `find`
-  --> $DIR/search_is_some.rs:82:13
-   |
-LL |     let _ = v.iter().find(|x| **x == 0).is_none();
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: use `!_.any()` instead
-   |
-LL |     let _ = !v.iter().any(|x| **x == 0);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^
-help: ...and remove deref
-   |
-LL |     let _ = v.iter().find(|x| *x == 0).is_none();
-   |                               ^^
-
-error: called `is_none()` after searching an `Iterator` with `find`
-  --> $DIR/search_is_some.rs:98:25
-   |
-LL |             .filter(|c| filter_hand.iter().find(|cc| c == cc).is_none())
-   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: use `!_.any()` instead
-   |
-LL |             .filter(|c| !filter_hand.iter().any(|cc| c == cc))
-   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-help: ...and borrow variable
-   |
-LL |             .filter(|c| filter_hand.iter().find(|cc| c == &cc).is_none())
-   |                                                           ^^^
-
-error: called `is_none()` after searching an `Iterator` with `find`
-  --> $DIR/search_is_some.rs:114:30
-   |
-LL |             .filter(|(c, _)| filter_hand.iter().find(|cc| c == *cc).is_none())
-   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: use `!_.any()` instead
-   |
-LL |             .filter(|(c, _)| !filter_hand.iter().any(|cc| c == *cc))
-   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-help: ...and remove deref
-   |
-LL |             .filter(|(c, _)| filter_hand.iter().find(|cc| c == cc).is_none())
-   |                                                                ^^
-
-error: aborting due to 14 previous errors
+error: aborting due to 6 previous errors
 
diff --git a/tests/ui/search_is_some_fixable.fixed b/tests/ui/search_is_some_fixable.fixed
index 6994df427ba..967b3d1be43 100644
--- a/tests/ui/search_is_some_fixable.fixed
+++ b/tests/ui/search_is_some_fixable.fixed
@@ -4,9 +4,19 @@
 
 fn main() {
     let v = vec![3, 2, 1, 0, -1, -2, -3];
+    let y = &&42;
 
     // Check `find().is_some()`, single-line case.
     let _ = v.iter().any(|x| *x < 0);
+    let _ = (0..1).any(|x| **y == x); // one dereference less
+    let _ = (0..1).any(|x| x == 0);
+    let _ = v.iter().any(|x| *x == 0);
+    let _ = (4..5).any(|x| x == 1 || x == 3 || x == 5);
+    let _ = (1..3).any(|x| [1, 2, 3].contains(&x));
+    let _ = (1..3).any(|x| x == 0 || [1, 2, 3].contains(&x));
+    let _ = (1..3).any(|x| [1, 2, 3].contains(&x) || x == 0);
+    let _ = (1..3)
+        .any(|x| [1, 2, 3].contains(&x) || x == 0 || [4, 5, 6].contains(&x) || x == -1);
 
     // Check `position().is_some()`, single-line case.
     let _ = v.iter().any(|&x| x < 0);
@@ -32,9 +42,18 @@ fn main() {
 
 fn is_none() {
     let v = vec![3, 2, 1, 0, -1, -2, -3];
+    let y = &&42;
 
     // Check `find().is_none()`, single-line case.
     let _ = !v.iter().any(|x| *x < 0);
+    let _ = !(0..1).any(|x| **y == x); // one dereference less
+    let _ = !(0..1).any(|x| x == 0);
+    let _ = !v.iter().any(|x| *x == 0);
+    let _ = !(4..5).any(|x| x == 1 || x == 3 || x == 5);
+    let _ = !(1..3).any(|x| [1, 2, 3].contains(&x));
+    let _ = !(1..3).any(|x| x == 0 || [1, 2, 3].contains(&x));
+    let _ = !(1..3).any(|x| [1, 2, 3].contains(&x) || x == 0);
+    let _ = !(1..3).any(|x| [1, 2, 3].contains(&x) || x == 0 || [4, 5, 6].contains(&x) || x == -1);
 
     // Check `position().is_none()`, single-line case.
     let _ = !v.iter().any(|&x| x < 0);
@@ -58,3 +77,38 @@ fn is_none() {
     let _ = !s1[2..].contains(&s2);
     let _ = !s1[2..].contains(&s2[2..]);
 }
+
+#[allow(clippy::clone_on_copy, clippy::map_clone)]
+mod issue7392 {
+    struct Player {
+        hand: Vec<usize>,
+    }
+    fn filter() {
+        let p = Player {
+            hand: vec![1, 2, 3, 4, 5],
+        };
+        let filter_hand = vec![5];
+        let _ = p
+            .hand
+            .iter()
+            .filter(|c| !filter_hand.iter().any(|cc| c == &cc))
+            .map(|c| c.clone())
+            .collect::<Vec<_>>();
+    }
+
+    struct PlayerTuple {
+        hand: Vec<(usize, char)>,
+    }
+    fn filter_tuple() {
+        let p = PlayerTuple {
+            hand: vec![(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd'), (5, 'e')],
+        };
+        let filter_hand = vec![5];
+        let _ = p
+            .hand
+            .iter()
+            .filter(|(c, _)| !filter_hand.iter().any(|cc| c == cc))
+            .map(|c| c.clone())
+            .collect::<Vec<_>>();
+    }
+}
diff --git a/tests/ui/search_is_some_fixable.rs b/tests/ui/search_is_some_fixable.rs
index d4c9d89e7b8..e642523a532 100644
--- a/tests/ui/search_is_some_fixable.rs
+++ b/tests/ui/search_is_some_fixable.rs
@@ -4,9 +4,20 @@
 
 fn main() {
     let v = vec![3, 2, 1, 0, -1, -2, -3];
+    let y = &&42;
 
     // Check `find().is_some()`, single-line case.
     let _ = v.iter().find(|&x| *x < 0).is_some();
+    let _ = (0..1).find(|x| **y == *x).is_some(); // one dereference less
+    let _ = (0..1).find(|x| *x == 0).is_some();
+    let _ = v.iter().find(|x| **x == 0).is_some();
+    let _ = (4..5).find(|x| *x == 1 || *x == 3 || *x == 5).is_some();
+    let _ = (1..3).find(|x| [1, 2, 3].contains(x)).is_some();
+    let _ = (1..3).find(|x| *x == 0 || [1, 2, 3].contains(x)).is_some();
+    let _ = (1..3).find(|x| [1, 2, 3].contains(x) || *x == 0).is_some();
+    let _ = (1..3)
+        .find(|x| [1, 2, 3].contains(x) || *x == 0 || [4, 5, 6].contains(x) || *x == -1)
+        .is_some();
 
     // Check `position().is_some()`, single-line case.
     let _ = v.iter().position(|&x| x < 0).is_some();
@@ -32,9 +43,20 @@ fn main() {
 
 fn is_none() {
     let v = vec![3, 2, 1, 0, -1, -2, -3];
+    let y = &&42;
 
     // Check `find().is_none()`, single-line case.
     let _ = v.iter().find(|&x| *x < 0).is_none();
+    let _ = (0..1).find(|x| **y == *x).is_none(); // one dereference less
+    let _ = (0..1).find(|x| *x == 0).is_none();
+    let _ = v.iter().find(|x| **x == 0).is_none();
+    let _ = (4..5).find(|x| *x == 1 || *x == 3 || *x == 5).is_none();
+    let _ = (1..3).find(|x| [1, 2, 3].contains(x)).is_none();
+    let _ = (1..3).find(|x| *x == 0 || [1, 2, 3].contains(x)).is_none();
+    let _ = (1..3).find(|x| [1, 2, 3].contains(x) || *x == 0).is_none();
+    let _ = (1..3)
+        .find(|x| [1, 2, 3].contains(x) || *x == 0 || [4, 5, 6].contains(x) || *x == -1)
+        .is_none();
 
     // Check `position().is_none()`, single-line case.
     let _ = v.iter().position(|&x| x < 0).is_none();
@@ -58,3 +80,38 @@ fn is_none() {
     let _ = s1[2..].find(&s2).is_none();
     let _ = s1[2..].find(&s2[2..]).is_none();
 }
+
+#[allow(clippy::clone_on_copy, clippy::map_clone)]
+mod issue7392 {
+    struct Player {
+        hand: Vec<usize>,
+    }
+    fn filter() {
+        let p = Player {
+            hand: vec![1, 2, 3, 4, 5],
+        };
+        let filter_hand = vec![5];
+        let _ = p
+            .hand
+            .iter()
+            .filter(|c| filter_hand.iter().find(|cc| c == cc).is_none())
+            .map(|c| c.clone())
+            .collect::<Vec<_>>();
+    }
+
+    struct PlayerTuple {
+        hand: Vec<(usize, char)>,
+    }
+    fn filter_tuple() {
+        let p = PlayerTuple {
+            hand: vec![(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd'), (5, 'e')],
+        };
+        let filter_hand = vec![5];
+        let _ = p
+            .hand
+            .iter()
+            .filter(|(c, _)| filter_hand.iter().find(|cc| c == *cc).is_none())
+            .map(|c| c.clone())
+            .collect::<Vec<_>>();
+    }
+}
diff --git a/tests/ui/search_is_some_fixable.stderr b/tests/ui/search_is_some_fixable.stderr
index 5e77c9a5bac..3bb8cc573ec 100644
--- a/tests/ui/search_is_some_fixable.stderr
+++ b/tests/ui/search_is_some_fixable.stderr
@@ -1,148 +1,261 @@
 error: called `is_some()` after searching an `Iterator` with `find`
-  --> $DIR/search_is_some_fixable.rs:9:22
+  --> $DIR/search_is_some_fixable.rs:10:22
    |
 LL |     let _ = v.iter().find(|&x| *x < 0).is_some();
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `any()` instead: `any(|x| *x < 0)`
    |
    = note: `-D clippy::search-is-some` implied by `-D warnings`
 
+error: called `is_some()` after searching an `Iterator` with `find`
+  --> $DIR/search_is_some_fixable.rs:11:20
+   |
+LL |     let _ = (0..1).find(|x| **y == *x).is_some(); // one dereference less
+   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `any()` instead: `any(|x| **y == x)`
+
+error: called `is_some()` after searching an `Iterator` with `find`
+  --> $DIR/search_is_some_fixable.rs:12:20
+   |
+LL |     let _ = (0..1).find(|x| *x == 0).is_some();
+   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `any()` instead: `any(|x| x == 0)`
+
+error: called `is_some()` after searching an `Iterator` with `find`
+  --> $DIR/search_is_some_fixable.rs:13:22
+   |
+LL |     let _ = v.iter().find(|x| **x == 0).is_some();
+   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `any()` instead: `any(|x| *x == 0)`
+
+error: called `is_some()` after searching an `Iterator` with `find`
+  --> $DIR/search_is_some_fixable.rs:14:20
+   |
+LL |     let _ = (4..5).find(|x| *x == 1 || *x == 3 || *x == 5).is_some();
+   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `any()` instead: `any(|x| x == 1 || x == 3 || x == 5)`
+
+error: called `is_some()` after searching an `Iterator` with `find`
+  --> $DIR/search_is_some_fixable.rs:15:20
+   |
+LL |     let _ = (1..3).find(|x| [1, 2, 3].contains(x)).is_some();
+   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `any()` instead: `any(|x| [1, 2, 3].contains(&x))`
+
+error: called `is_some()` after searching an `Iterator` with `find`
+  --> $DIR/search_is_some_fixable.rs:16:20
+   |
+LL |     let _ = (1..3).find(|x| *x == 0 || [1, 2, 3].contains(x)).is_some();
+   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `any()` instead: `any(|x| x == 0 || [1, 2, 3].contains(&x))`
+
+error: called `is_some()` after searching an `Iterator` with `find`
+  --> $DIR/search_is_some_fixable.rs:17:20
+   |
+LL |     let _ = (1..3).find(|x| [1, 2, 3].contains(x) || *x == 0).is_some();
+   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `any()` instead: `any(|x| [1, 2, 3].contains(&x) || x == 0)`
+
+error: called `is_some()` after searching an `Iterator` with `find`
+  --> $DIR/search_is_some_fixable.rs:19:10
+   |
+LL |           .find(|x| [1, 2, 3].contains(x) || *x == 0 || [4, 5, 6].contains(x) || *x == -1)
+   |  __________^
+LL | |         .is_some();
+   | |__________________^ help: use `any()` instead: `any(|x| [1, 2, 3].contains(&x) || x == 0 || [4, 5, 6].contains(&x) || x == -1)`
+
 error: called `is_some()` after searching an `Iterator` with `position`
-  --> $DIR/search_is_some_fixable.rs:12:22
+  --> $DIR/search_is_some_fixable.rs:23:22
    |
 LL |     let _ = v.iter().position(|&x| x < 0).is_some();
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `any()` instead: `any(|&x| x < 0)`
 
 error: called `is_some()` after searching an `Iterator` with `rposition`
-  --> $DIR/search_is_some_fixable.rs:15:22
+  --> $DIR/search_is_some_fixable.rs:26:22
    |
 LL |     let _ = v.iter().rposition(|&x| x < 0).is_some();
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `any()` instead: `any(|&x| x < 0)`
 
 error: called `is_some()` after calling `find()` on a string
-  --> $DIR/search_is_some_fixable.rs:20:27
+  --> $DIR/search_is_some_fixable.rs:31:27
    |
 LL |     let _ = "hello world".find("world").is_some();
    |                           ^^^^^^^^^^^^^^^^^^^^^^^ help: use `contains()` instead: `contains("world")`
 
 error: called `is_some()` after calling `find()` on a string
-  --> $DIR/search_is_some_fixable.rs:21:27
+  --> $DIR/search_is_some_fixable.rs:32:27
    |
 LL |     let _ = "hello world".find(&s2).is_some();
    |                           ^^^^^^^^^^^^^^^^^^^ help: use `contains()` instead: `contains(&s2)`
 
 error: called `is_some()` after calling `find()` on a string
-  --> $DIR/search_is_some_fixable.rs:22:27
+  --> $DIR/search_is_some_fixable.rs:33:27
    |
 LL |     let _ = "hello world".find(&s2[2..]).is_some();
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^ help: use `contains()` instead: `contains(&s2[2..])`
 
 error: called `is_some()` after calling `find()` on a string
-  --> $DIR/search_is_some_fixable.rs:24:16
+  --> $DIR/search_is_some_fixable.rs:35:16
    |
 LL |     let _ = s1.find("world").is_some();
    |                ^^^^^^^^^^^^^^^^^^^^^^^ help: use `contains()` instead: `contains("world")`
 
 error: called `is_some()` after calling `find()` on a string
-  --> $DIR/search_is_some_fixable.rs:25:16
+  --> $DIR/search_is_some_fixable.rs:36:16
    |
 LL |     let _ = s1.find(&s2).is_some();
    |                ^^^^^^^^^^^^^^^^^^^ help: use `contains()` instead: `contains(&s2)`
 
 error: called `is_some()` after calling `find()` on a string
-  --> $DIR/search_is_some_fixable.rs:26:16
+  --> $DIR/search_is_some_fixable.rs:37:16
    |
 LL |     let _ = s1.find(&s2[2..]).is_some();
    |                ^^^^^^^^^^^^^^^^^^^^^^^^ help: use `contains()` instead: `contains(&s2[2..])`
 
 error: called `is_some()` after calling `find()` on a string
-  --> $DIR/search_is_some_fixable.rs:28:21
+  --> $DIR/search_is_some_fixable.rs:39:21
    |
 LL |     let _ = s1[2..].find("world").is_some();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^ help: use `contains()` instead: `contains("world")`
 
 error: called `is_some()` after calling `find()` on a string
-  --> $DIR/search_is_some_fixable.rs:29:21
+  --> $DIR/search_is_some_fixable.rs:40:21
    |
 LL |     let _ = s1[2..].find(&s2).is_some();
    |                     ^^^^^^^^^^^^^^^^^^^ help: use `contains()` instead: `contains(&s2)`
 
 error: called `is_some()` after calling `find()` on a string
-  --> $DIR/search_is_some_fixable.rs:30:21
+  --> $DIR/search_is_some_fixable.rs:41:21
    |
 LL |     let _ = s1[2..].find(&s2[2..]).is_some();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^ help: use `contains()` instead: `contains(&s2[2..])`
 
 error: called `is_none()` after searching an `Iterator` with `find`
-  --> $DIR/search_is_some_fixable.rs:37:13
+  --> $DIR/search_is_some_fixable.rs:49:13
    |
 LL |     let _ = v.iter().find(|&x| *x < 0).is_none();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.any()` instead: `!v.iter().any(|x| *x < 0)`
 
+error: called `is_none()` after searching an `Iterator` with `find`
+  --> $DIR/search_is_some_fixable.rs:50:13
+   |
+LL |     let _ = (0..1).find(|x| **y == *x).is_none(); // one dereference less
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.any()` instead: `!(0..1).any(|x| **y == x)`
+
+error: called `is_none()` after searching an `Iterator` with `find`
+  --> $DIR/search_is_some_fixable.rs:51:13
+   |
+LL |     let _ = (0..1).find(|x| *x == 0).is_none();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.any()` instead: `!(0..1).any(|x| x == 0)`
+
+error: called `is_none()` after searching an `Iterator` with `find`
+  --> $DIR/search_is_some_fixable.rs:52:13
+   |
+LL |     let _ = v.iter().find(|x| **x == 0).is_none();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.any()` instead: `!v.iter().any(|x| *x == 0)`
+
+error: called `is_none()` after searching an `Iterator` with `find`
+  --> $DIR/search_is_some_fixable.rs:53:13
+   |
+LL |     let _ = (4..5).find(|x| *x == 1 || *x == 3 || *x == 5).is_none();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.any()` instead: `!(4..5).any(|x| x == 1 || x == 3 || x == 5)`
+
+error: called `is_none()` after searching an `Iterator` with `find`
+  --> $DIR/search_is_some_fixable.rs:54:13
+   |
+LL |     let _ = (1..3).find(|x| [1, 2, 3].contains(x)).is_none();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.any()` instead: `!(1..3).any(|x| [1, 2, 3].contains(&x))`
+
+error: called `is_none()` after searching an `Iterator` with `find`
+  --> $DIR/search_is_some_fixable.rs:55:13
+   |
+LL |     let _ = (1..3).find(|x| *x == 0 || [1, 2, 3].contains(x)).is_none();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.any()` instead: `!(1..3).any(|x| x == 0 || [1, 2, 3].contains(&x))`
+
+error: called `is_none()` after searching an `Iterator` with `find`
+  --> $DIR/search_is_some_fixable.rs:56:13
+   |
+LL |     let _ = (1..3).find(|x| [1, 2, 3].contains(x) || *x == 0).is_none();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.any()` instead: `!(1..3).any(|x| [1, 2, 3].contains(&x) || x == 0)`
+
+error: called `is_none()` after searching an `Iterator` with `find`
+  --> $DIR/search_is_some_fixable.rs:57:13
+   |
+LL |       let _ = (1..3)
+   |  _____________^
+LL | |         .find(|x| [1, 2, 3].contains(x) || *x == 0 || [4, 5, 6].contains(x) || *x == -1)
+LL | |         .is_none();
+   | |__________________^ help: use `!_.any()` instead: `!(1..3).any(|x| [1, 2, 3].contains(&x) || x == 0 || [4, 5, 6].contains(&x) || x == -1)`
+
 error: called `is_none()` after searching an `Iterator` with `position`
-  --> $DIR/search_is_some_fixable.rs:40:13
+  --> $DIR/search_is_some_fixable.rs:62:13
    |
 LL |     let _ = v.iter().position(|&x| x < 0).is_none();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.any()` instead: `!v.iter().any(|&x| x < 0)`
 
 error: called `is_none()` after searching an `Iterator` with `rposition`
-  --> $DIR/search_is_some_fixable.rs:43:13
+  --> $DIR/search_is_some_fixable.rs:65:13
    |
 LL |     let _ = v.iter().rposition(|&x| x < 0).is_none();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.any()` instead: `!v.iter().any(|&x| x < 0)`
 
 error: called `is_none()` after calling `find()` on a string
-  --> $DIR/search_is_some_fixable.rs:49:13
+  --> $DIR/search_is_some_fixable.rs:71:13
    |
 LL |     let _ = "hello world".find("world").is_none();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.contains()` instead: `!"hello world".contains("world")`
 
 error: called `is_none()` after calling `find()` on a string
-  --> $DIR/search_is_some_fixable.rs:50:13
+  --> $DIR/search_is_some_fixable.rs:72:13
    |
 LL |     let _ = "hello world".find(&s2).is_none();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.contains()` instead: `!"hello world".contains(&s2)`
 
 error: called `is_none()` after calling `find()` on a string
-  --> $DIR/search_is_some_fixable.rs:51:13
+  --> $DIR/search_is_some_fixable.rs:73:13
    |
 LL |     let _ = "hello world".find(&s2[2..]).is_none();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.contains()` instead: `!"hello world".contains(&s2[2..])`
 
 error: called `is_none()` after calling `find()` on a string
-  --> $DIR/search_is_some_fixable.rs:53:13
+  --> $DIR/search_is_some_fixable.rs:75:13
    |
 LL |     let _ = s1.find("world").is_none();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.contains()` instead: `!s1.contains("world")`
 
 error: called `is_none()` after calling `find()` on a string
-  --> $DIR/search_is_some_fixable.rs:54:13
+  --> $DIR/search_is_some_fixable.rs:76:13
    |
 LL |     let _ = s1.find(&s2).is_none();
    |             ^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.contains()` instead: `!s1.contains(&s2)`
 
 error: called `is_none()` after calling `find()` on a string
-  --> $DIR/search_is_some_fixable.rs:55:13
+  --> $DIR/search_is_some_fixable.rs:77:13
    |
 LL |     let _ = s1.find(&s2[2..]).is_none();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.contains()` instead: `!s1.contains(&s2[2..])`
 
 error: called `is_none()` after calling `find()` on a string
-  --> $DIR/search_is_some_fixable.rs:57:13
+  --> $DIR/search_is_some_fixable.rs:79:13
    |
 LL |     let _ = s1[2..].find("world").is_none();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.contains()` instead: `!s1[2..].contains("world")`
 
 error: called `is_none()` after calling `find()` on a string
-  --> $DIR/search_is_some_fixable.rs:58:13
+  --> $DIR/search_is_some_fixable.rs:80:13
    |
 LL |     let _ = s1[2..].find(&s2).is_none();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.contains()` instead: `!s1[2..].contains(&s2)`
 
 error: called `is_none()` after calling `find()` on a string
-  --> $DIR/search_is_some_fixable.rs:59:13
+  --> $DIR/search_is_some_fixable.rs:81:13
    |
 LL |     let _ = s1[2..].find(&s2[2..]).is_none();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.contains()` instead: `!s1[2..].contains(&s2[2..])`
 
-error: aborting due to 24 previous errors
+error: called `is_none()` after searching an `Iterator` with `find`
+  --> $DIR/search_is_some_fixable.rs:97:25
+   |
+LL |             .filter(|c| filter_hand.iter().find(|cc| c == cc).is_none())
+   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.any()` instead: `!filter_hand.iter().any(|cc| c == &cc)`
+
+error: called `is_none()` after searching an `Iterator` with `find`
+  --> $DIR/search_is_some_fixable.rs:113:30
+   |
+LL |             .filter(|(c, _)| filter_hand.iter().find(|cc| c == *cc).is_none())
+   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.any()` instead: `!filter_hand.iter().any(|cc| c == cc)`
+
+error: aborting due to 42 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 6dca4f261d01584aac507379649458fbaf04d4c8 Mon Sep 17 00:00:00 2001
From: ThibsG <thibsg@pm.me>
Date: Thu, 19 Aug 2021 11:50:05 +0200
Subject: Add some doc for `search_is_some` lint

---
 clippy_lints/src/methods/search_is_some.rs | 11 +++++++++++
 1 file changed, 11 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/search_is_some.rs b/clippy_lints/src/methods/search_is_some.rs
index ee0e6d3a33f..b0bfe8d80e0 100644
--- a/clippy_lints/src/methods/search_is_some.rs
+++ b/clippy_lints/src/methods/search_is_some.rs
@@ -50,6 +50,8 @@ pub(super) fn check<'tcx>(
                     if let hir::PatKind::Ref(..) = closure_arg.pat.kind {
                         Some(search_snippet.replacen('&', "", 1))
                     } else if let PatKind::Binding(..) = strip_pat_refs(closure_arg.pat).kind {
+                        // `find()` provides a reference to the item, but `any` does not,
+                        // so we should fix item usages for suggestion
                         get_closure_suggestion(cx, search_arg, closure_body)
                             .or_else(|| Some(search_snippet.to_string()))
                     } else {
@@ -151,6 +153,9 @@ pub(super) fn check<'tcx>(
     }
 }
 
+// Build suggestion gradually by handling closure arg specific usages,
+// such as explicit deref and borrowing cases.
+// Returns `None` if no such use cases have been triggered in closure body
 fn get_closure_suggestion<'tcx>(
     cx: &LateContext<'_>,
     search_arg: &'tcx hir::Expr<'_>,
@@ -203,8 +208,12 @@ impl<'tcx> Delegate<'tcx> for DerefDelegate<'_, 'tcx> {
             let end_snip = snippet(self.cx, end_span, "..");
 
             if cmt.place.projections.is_empty() {
+                // handle item without any projection, that needs an explicit borrowing
+                // i.e.: suggest `&x` instead of `x`
                 self.suggestion_start.push_str(&format!("{}&{}", start_snip, ident_str));
             } else {
+                // cases where a parent call is using the item
+                // i.e.: suggest `.contains(&x)` for `.find(|x| [1, 2, 3].contains(x)).is_none()`
                 let parent_expr = get_parent_expr_for_hir(self.cx, cmt.hir_id);
                 if let Some(Expr { hir_id: _, kind, .. }) = parent_expr {
                     if let ExprKind::Call(_, args) | ExprKind::MethodCall(_, _, args, _) = kind {
@@ -230,6 +239,8 @@ impl<'tcx> Delegate<'tcx> for DerefDelegate<'_, 'tcx> {
                     }
                 }
 
+                // handle item projections by removing one explicit deref
+                // i.e.: suggest `*x` instead of `**x`
                 let mut replacement_str = ident_str;
                 let last_deref = cmt
                     .place
-- 
cgit 1.4.1-3-g733a5


From e24aba2c1a8663c2ddebdae740689f8a7bdcadb7 Mon Sep 17 00:00:00 2001
From: ThibsG <thibsg@pm.me>
Date: Tue, 7 Sep 2021 11:06:50 +0200
Subject: Use applicability for snippets

---
 clippy_lints/src/methods/search_is_some.rs | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/search_is_some.rs b/clippy_lints/src/methods/search_is_some.rs
index b0bfe8d80e0..ec09bfd743d 100644
--- a/clippy_lints/src/methods/search_is_some.rs
+++ b/clippy_lints/src/methods/search_is_some.rs
@@ -167,6 +167,7 @@ fn get_closure_suggestion<'tcx>(
         next_pos: None,
         suggestion_start: String::new(),
         suggestion_end: String::new(),
+        applicability: Applicability::MachineApplicable,
     };
 
     let fn_def_id = cx.tcx.hir().local_def_id(search_arg.hir_id);
@@ -188,6 +189,7 @@ struct DerefDelegate<'a, 'tcx> {
     next_pos: Option<BytePos>,
     suggestion_start: String,
     suggestion_end: String,
+    applicability: Applicability,
 }
 
 impl<'tcx> Delegate<'tcx> for DerefDelegate<'_, 'tcx> {
@@ -203,9 +205,9 @@ impl<'tcx> Delegate<'tcx> for DerefDelegate<'_, 'tcx> {
             } else {
                 self.closure_span.until(span)
             };
-            let start_snip = snippet(self.cx, start_span, "..");
+            let start_snip = snippet_with_applicability(self.cx, start_span, "..", &mut self.applicability);
             let end_span = Span::new(span.hi(), self.closure_span.hi(), span.ctxt());
-            let end_snip = snippet(self.cx, end_span, "..");
+            let end_snip = snippet_with_applicability(self.cx, end_span, "..", &mut self.applicability);
 
             if cmt.place.projections.is_empty() {
                 // handle item without any projection, that needs an explicit borrowing
@@ -227,11 +229,14 @@ impl<'tcx> Delegate<'tcx> for DerefDelegate<'_, 'tcx> {
                                     } else {
                                         self.closure_span.until(span)
                                     };
-                                    let start_snip = snippet(self.cx, start_span, "..");
+                                    let start_snip =
+                                        snippet_with_applicability(self.cx, start_span, "..", &mut self.applicability);
 
                                     self.suggestion_start.push_str(&format!("{}&{}", start_snip, ident_str));
                                     self.suggestion_end = end_snip.to_string();
                                     self.next_pos = Some(span.hi());
+                                } else {
+                                    self.applicability = Applicability::Unspecified;
                                 }
                             }
                             return;
-- 
cgit 1.4.1-3-g733a5


From 9ab4b673eb41cca04a626797bb130bda4a14bd1b Mon Sep 17 00:00:00 2001
From: ThibsG <thibsg@pm.me>
Date: Tue, 7 Sep 2021 11:18:27 +0200
Subject: Simplifying `next_pos` init

---
 clippy_lints/src/methods/search_is_some.rs | 20 ++++++--------------
 1 file changed, 6 insertions(+), 14 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/search_is_some.rs b/clippy_lints/src/methods/search_is_some.rs
index ec09bfd743d..b38b8e44f1c 100644
--- a/clippy_lints/src/methods/search_is_some.rs
+++ b/clippy_lints/src/methods/search_is_some.rs
@@ -164,7 +164,7 @@ fn get_closure_suggestion<'tcx>(
     let mut visitor = DerefDelegate {
         cx,
         closure_span: search_arg.span,
-        next_pos: None,
+        next_pos: search_arg.span.lo(),
         suggestion_start: String::new(),
         suggestion_end: String::new(),
         applicability: Applicability::MachineApplicable,
@@ -186,7 +186,7 @@ fn get_closure_suggestion<'tcx>(
 struct DerefDelegate<'a, 'tcx> {
     cx: &'a LateContext<'tcx>,
     closure_span: Span,
-    next_pos: Option<BytePos>,
+    next_pos: BytePos,
     suggestion_start: String,
     suggestion_end: String,
     applicability: Applicability,
@@ -200,11 +200,7 @@ impl<'tcx> Delegate<'tcx> for DerefDelegate<'_, 'tcx> {
             let map = self.cx.tcx.hir();
             let ident_str = map.name(id).to_string();
             let span = map.span(cmt.hir_id);
-            let start_span = if let Some(next_pos) = self.next_pos {
-                Span::new(next_pos, span.lo(), span.ctxt())
-            } else {
-                self.closure_span.until(span)
-            };
+            let start_span = Span::new(self.next_pos, span.lo(), span.ctxt());
             let start_snip = snippet_with_applicability(self.cx, start_span, "..", &mut self.applicability);
             let end_span = Span::new(span.hi(), self.closure_span.hi(), span.ctxt());
             let end_snip = snippet_with_applicability(self.cx, end_span, "..", &mut self.applicability);
@@ -224,17 +220,13 @@ impl<'tcx> Delegate<'tcx> for DerefDelegate<'_, 'tcx> {
                             for arg in &args_to_handle {
                                 let arg_ty_kind = self.cx.typeck_results().expr_ty(arg).kind();
                                 if matches!(arg_ty_kind, ty::Ref(_, _, Mutability::Not)) {
-                                    let start_span = if let Some(next_pos) = self.next_pos {
-                                        Span::new(next_pos, span.lo(), span.ctxt())
-                                    } else {
-                                        self.closure_span.until(span)
-                                    };
+                                    let start_span = Span::new(self.next_pos, span.lo(), span.ctxt());
                                     let start_snip =
                                         snippet_with_applicability(self.cx, start_span, "..", &mut self.applicability);
 
                                     self.suggestion_start.push_str(&format!("{}&{}", start_snip, ident_str));
                                     self.suggestion_end = end_snip.to_string();
-                                    self.next_pos = Some(span.hi());
+                                    self.next_pos = span.hi();
                                 } else {
                                     self.applicability = Applicability::Unspecified;
                                 }
@@ -268,7 +260,7 @@ impl<'tcx> Delegate<'tcx> for DerefDelegate<'_, 'tcx> {
                     .push_str(&format!("{}{}", start_snip, replacement_str));
                 self.suggestion_end = end_snip.to_string();
             }
-            self.next_pos = Some(span.hi());
+            self.next_pos = span.hi();
         }
     }
 
-- 
cgit 1.4.1-3-g733a5


From d0dd797709540f460ee6c9ac26f1231335781b40 Mon Sep 17 00:00:00 2001
From: ThibsG <thibsg@pm.me>
Date: Tue, 7 Sep 2021 11:59:53 +0200
Subject: Build end of suggestion only once at the end of the process

---
 clippy_lints/src/methods/search_is_some.rs | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/search_is_some.rs b/clippy_lints/src/methods/search_is_some.rs
index b38b8e44f1c..e793c50ac9d 100644
--- a/clippy_lints/src/methods/search_is_some.rs
+++ b/clippy_lints/src/methods/search_is_some.rs
@@ -166,7 +166,6 @@ fn get_closure_suggestion<'tcx>(
         closure_span: search_arg.span,
         next_pos: search_arg.span.lo(),
         suggestion_start: String::new(),
-        suggestion_end: String::new(),
         applicability: Applicability::MachineApplicable,
     };
 
@@ -179,7 +178,7 @@ fn get_closure_suggestion<'tcx>(
     if visitor.suggestion_start.is_empty() {
         None
     } else {
-        Some(format!("{}{}", visitor.suggestion_start, visitor.suggestion_end))
+        Some(visitor.finish())
     }
 }
 
@@ -188,10 +187,17 @@ struct DerefDelegate<'a, 'tcx> {
     closure_span: Span,
     next_pos: BytePos,
     suggestion_start: String,
-    suggestion_end: String,
     applicability: Applicability,
 }
 
+impl DerefDelegate<'_, 'tcx> {
+    pub fn finish(&mut self) -> String {
+        let end_span = Span::new(self.next_pos, self.closure_span.hi(), self.closure_span.ctxt());
+        let end_snip = snippet_with_applicability(self.cx, end_span, "..", &mut self.applicability);
+        format!("{}{}", self.suggestion_start, end_snip)
+    }
+}
+
 impl<'tcx> Delegate<'tcx> for DerefDelegate<'_, 'tcx> {
     fn consume(&mut self, _: &PlaceWithHirId<'tcx>, _: HirId) {}
 
@@ -202,8 +208,6 @@ impl<'tcx> Delegate<'tcx> for DerefDelegate<'_, 'tcx> {
             let span = map.span(cmt.hir_id);
             let start_span = Span::new(self.next_pos, span.lo(), span.ctxt());
             let start_snip = snippet_with_applicability(self.cx, start_span, "..", &mut self.applicability);
-            let end_span = Span::new(span.hi(), self.closure_span.hi(), span.ctxt());
-            let end_snip = snippet_with_applicability(self.cx, end_span, "..", &mut self.applicability);
 
             if cmt.place.projections.is_empty() {
                 // handle item without any projection, that needs an explicit borrowing
@@ -225,7 +229,6 @@ impl<'tcx> Delegate<'tcx> for DerefDelegate<'_, 'tcx> {
                                         snippet_with_applicability(self.cx, start_span, "..", &mut self.applicability);
 
                                     self.suggestion_start.push_str(&format!("{}&{}", start_snip, ident_str));
-                                    self.suggestion_end = end_snip.to_string();
                                     self.next_pos = span.hi();
                                 } else {
                                     self.applicability = Applicability::Unspecified;
@@ -258,7 +261,6 @@ impl<'tcx> Delegate<'tcx> for DerefDelegate<'_, 'tcx> {
 
                 self.suggestion_start
                     .push_str(&format!("{}{}", start_snip, replacement_str));
-                self.suggestion_end = end_snip.to_string();
             }
             self.next_pos = span.hi();
         }
-- 
cgit 1.4.1-3-g733a5


From 97783a8cb9b154b17abbf0084fe8a16d490cf801 Mon Sep 17 00:00:00 2001
From: ThibsG <thibsg@pm.me>
Date: Tue, 7 Sep 2021 12:31:14 +0200
Subject: Return a struct and add applicability

---
 clippy_lints/src/methods/search_is_some.rs | 25 +++++++++++++++++++------
 1 file changed, 19 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/search_is_some.rs b/clippy_lints/src/methods/search_is_some.rs
index e793c50ac9d..a1206199460 100644
--- a/clippy_lints/src/methods/search_is_some.rs
+++ b/clippy_lints/src/methods/search_is_some.rs
@@ -41,6 +41,7 @@ pub(super) fn check<'tcx>(
         if search_snippet.lines().count() <= 1 {
             // suggest `any(|x| ..)` instead of `any(|&x| ..)` for `find(|&x| ..).is_some()`
             // suggest `any(|..| *..)` instead of `any(|..| **..)` for `find(|..| **..).is_some()`
+            let mut applicability = Applicability::MachineApplicable;
             let any_search_snippet = if_chain! {
                 if search_method == "find";
                 if let hir::ExprKind::Closure(_, _, body_id, ..) = search_arg.kind;
@@ -52,8 +53,12 @@ pub(super) fn check<'tcx>(
                     } else if let PatKind::Binding(..) = strip_pat_refs(closure_arg.pat).kind {
                         // `find()` provides a reference to the item, but `any` does not,
                         // so we should fix item usages for suggestion
-                        get_closure_suggestion(cx, search_arg, closure_body)
-                            .or_else(|| Some(search_snippet.to_string()))
+                        if let Some(closure_sugg) = get_closure_suggestion(cx, search_arg, closure_body) {
+                            applicability = closure_sugg.applicability;
+                            Some(closure_sugg.suggestion)
+                        } else {
+                            Some(search_snippet.to_string())
+                        }
                     } else {
                         None
                     }
@@ -73,7 +78,7 @@ pub(super) fn check<'tcx>(
                         "any({})",
                         any_search_snippet.as_ref().map_or(&*search_snippet, String::as_str)
                     ),
-                    Applicability::MachineApplicable,
+                    applicability,
                 );
             } else {
                 let iter = snippet(cx, search_recv.span, "..");
@@ -88,7 +93,7 @@ pub(super) fn check<'tcx>(
                         iter,
                         any_search_snippet.as_ref().map_or(&*search_snippet, String::as_str)
                     ),
-                    Applicability::MachineApplicable,
+                    applicability,
                 );
             }
         } else {
@@ -153,6 +158,11 @@ pub(super) fn check<'tcx>(
     }
 }
 
+struct ClosureSugg {
+    applicability: Applicability,
+    suggestion: String,
+}
+
 // Build suggestion gradually by handling closure arg specific usages,
 // such as explicit deref and borrowing cases.
 // Returns `None` if no such use cases have been triggered in closure body
@@ -160,7 +170,7 @@ fn get_closure_suggestion<'tcx>(
     cx: &LateContext<'_>,
     search_arg: &'tcx hir::Expr<'_>,
     closure_body: &hir::Body<'_>,
-) -> Option<String> {
+) -> Option<ClosureSugg> {
     let mut visitor = DerefDelegate {
         cx,
         closure_span: search_arg.span,
@@ -178,7 +188,10 @@ fn get_closure_suggestion<'tcx>(
     if visitor.suggestion_start.is_empty() {
         None
     } else {
-        Some(visitor.finish())
+        Some(ClosureSugg {
+            applicability: visitor.applicability,
+            suggestion: visitor.finish(),
+        })
     }
 }
 
-- 
cgit 1.4.1-3-g733a5


From 91dd9c46de11b9abeb391d5b19707c5e7ddfef98 Mon Sep 17 00:00:00 2001
From: ThibsG <thibsg@pm.me>
Date: Sun, 12 Sep 2021 11:31:11 +0200
Subject: Handle other projection kinds

---
 clippy_lints/src/methods/search_is_some.rs  | 80 ++++++++++++++++++++++++-----
 tests/ui/search_is_some_fixable_none.fixed  | 24 +++++++++
 tests/ui/search_is_some_fixable_none.rs     | 26 ++++++++++
 tests/ui/search_is_some_fixable_none.stderr | 36 ++++++++++++-
 tests/ui/search_is_some_fixable_some.fixed  | 25 +++++++++
 tests/ui/search_is_some_fixable_some.rs     | 26 ++++++++++
 tests/ui/search_is_some_fixable_some.stderr | 28 +++++++++-
 7 files changed, 231 insertions(+), 14 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/search_is_some.rs b/clippy_lints/src/methods/search_is_some.rs
index a1206199460..d09baf50e49 100644
--- a/clippy_lints/src/methods/search_is_some.rs
+++ b/clippy_lints/src/methods/search_is_some.rs
@@ -220,7 +220,7 @@ impl<'tcx> Delegate<'tcx> for DerefDelegate<'_, 'tcx> {
             let ident_str = map.name(id).to_string();
             let span = map.span(cmt.hir_id);
             let start_span = Span::new(self.next_pos, span.lo(), span.ctxt());
-            let start_snip = snippet_with_applicability(self.cx, start_span, "..", &mut self.applicability);
+            let mut start_snip = snippet_with_applicability(self.cx, start_span, "..", &mut self.applicability);
 
             if cmt.place.projections.is_empty() {
                 // handle item without any projection, that needs an explicit borrowing
@@ -255,19 +255,75 @@ impl<'tcx> Delegate<'tcx> for DerefDelegate<'_, 'tcx> {
                 // handle item projections by removing one explicit deref
                 // i.e.: suggest `*x` instead of `**x`
                 let mut replacement_str = ident_str;
-                let last_deref = cmt
-                    .place
-                    .projections
-                    .iter()
-                    .rposition(|proj| proj.kind == ProjectionKind::Deref);
 
-                if let Some(pos) = last_deref {
-                    let mut projections = cmt.place.projections.clone();
-                    projections.truncate(pos);
+                // handle index projection first
+                let index_handled = cmt.place.projections.iter().any(|proj| match proj.kind {
+                    // Index projection like `|x| foo[x]`
+                    // the index is dropped so we can't get it to build the suggestion,
+                    // so the span is set-up again to get more code, using `span.hi()` (i.e.: `foo[x]`)
+                    // instead of `span.lo()` (i.e.: `foo`)
+                    ProjectionKind::Index => {
+                        let start_span = Span::new(self.next_pos, span.hi(), span.ctxt());
+                        start_snip = snippet_with_applicability(self.cx, start_span, "..", &mut self.applicability);
+                        replacement_str.clear();
+                        true
+                    },
+                    _ => false,
+                });
+
+                // looking for projections other that need to be handled differently
+                let other_projections_handled = cmt.place.projections.iter().enumerate().any(|(i, proj)| {
+                    match proj.kind {
+                        // Field projection like `|v| v.foo`
+                        ProjectionKind::Field(idx, variant) => match cmt.place.ty_before_projection(i).kind() {
+                            ty::Adt(def, ..) => {
+                                replacement_str = format!(
+                                    "{}.{}",
+                                    replacement_str,
+                                    def.variants[variant].fields[idx as usize].ident.name.as_str()
+                                );
+                                true
+                            },
+                            ty::Tuple(_) => {
+                                replacement_str = format!("{}.{}", replacement_str, idx);
+                                true
+                            },
+                            _ => false,
+                        },
+                        ProjectionKind::Index => false, /* handled previously */
+                        // note: unable to capture `Subslice` kind in tests
+                        ProjectionKind::Subslice => false,
+                        ProjectionKind::Deref => {
+                            // explicit deref for arrays should be avoided in the suggestion
+                            // i.e.: `|sub| *sub[1..4].len() == 3` is not expected
+                            match cmt.place.ty_before_projection(i).kind() {
+                                // dereferencing an array (i.e.: `|sub| sub[1..4].len() == 3`)
+                                ty::Ref(_, inner, _) => match inner.kind() {
+                                    ty::Ref(_, innermost, _) if innermost.is_array() => true,
+                                    _ => false,
+                                },
+                                _ => false,
+                            }
+                        },
+                    }
+                });
 
-                    for item in projections {
-                        if item.kind == ProjectionKind::Deref {
-                            replacement_str = format!("*{}", replacement_str);
+                // handle `ProjectionKind::Deref` if no special case detected
+                if !index_handled && !other_projections_handled {
+                    let last_deref = cmt
+                        .place
+                        .projections
+                        .iter()
+                        .rposition(|proj| proj.kind == ProjectionKind::Deref);
+
+                    if let Some(pos) = last_deref {
+                        let mut projections = cmt.place.projections.clone();
+                        projections.truncate(pos);
+
+                        for item in projections {
+                            if item.kind == ProjectionKind::Deref {
+                                replacement_str = format!("*{}", replacement_str);
+                            }
                         }
                     }
                 }
diff --git a/tests/ui/search_is_some_fixable_none.fixed b/tests/ui/search_is_some_fixable_none.fixed
index 5d9953f9b3c..222731fd212 100644
--- a/tests/ui/search_is_some_fixable_none.fixed
+++ b/tests/ui/search_is_some_fixable_none.fixed
@@ -73,4 +73,28 @@ mod issue7392 {
             .map(|c| c.clone())
             .collect::<Vec<_>>();
     }
+
+    fn field_projection() {
+        struct Foo {
+            foo: i32,
+            bar: u32,
+        }
+        let vfoo = vec![Foo { foo: 1, bar: 2 }];
+        let _ = !vfoo.iter().any(|v| v.foo == 1 && v.bar == 2);
+
+        let vfoo = vec![(42, Foo { foo: 1, bar: 2 })];
+        let _ = !vfoo
+            .iter().any(|(i, v)| *i == 42 && v.foo == 1 && v.bar == 2);
+    }
+
+    fn index_projection() {
+        let vfoo = vec![[0, 1, 2, 3]];
+        let _ = !vfoo.iter().any(|a| a[0] == 42);
+    }
+
+    #[allow(clippy::match_like_matches_macro)]
+    fn slice_projection() {
+        let vfoo = vec![[0, 1, 2, 3, 0, 1, 2, 3]];
+        let _ = !vfoo.iter().any(|sub| sub[1..4].len() == 3);
+    }
 }
diff --git a/tests/ui/search_is_some_fixable_none.rs b/tests/ui/search_is_some_fixable_none.rs
index 2a8aadfd0e0..43ac1a07667 100644
--- a/tests/ui/search_is_some_fixable_none.rs
+++ b/tests/ui/search_is_some_fixable_none.rs
@@ -75,4 +75,30 @@ mod issue7392 {
             .map(|c| c.clone())
             .collect::<Vec<_>>();
     }
+
+    fn field_projection() {
+        struct Foo {
+            foo: i32,
+            bar: u32,
+        }
+        let vfoo = vec![Foo { foo: 1, bar: 2 }];
+        let _ = vfoo.iter().find(|v| v.foo == 1 && v.bar == 2).is_none();
+
+        let vfoo = vec![(42, Foo { foo: 1, bar: 2 })];
+        let _ = vfoo
+            .iter()
+            .find(|(i, v)| *i == 42 && v.foo == 1 && v.bar == 2)
+            .is_none();
+    }
+
+    fn index_projection() {
+        let vfoo = vec![[0, 1, 2, 3]];
+        let _ = vfoo.iter().find(|a| a[0] == 42).is_none();
+    }
+
+    #[allow(clippy::match_like_matches_macro)]
+    fn slice_projection() {
+        let vfoo = vec![[0, 1, 2, 3, 0, 1, 2, 3]];
+        let _ = vfoo.iter().find(|sub| sub[1..4].len() == 3).is_none();
+    }
 }
diff --git a/tests/ui/search_is_some_fixable_none.stderr b/tests/ui/search_is_some_fixable_none.stderr
index 34768feb6dd..fa344046aeb 100644
--- a/tests/ui/search_is_some_fixable_none.stderr
+++ b/tests/ui/search_is_some_fixable_none.stderr
@@ -135,5 +135,39 @@ error: called `is_none()` after searching an `Iterator` with `find`
 LL |             .filter(|(c, _)| filter_hand.iter().find(|cc| c == *cc).is_none())
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.any()` instead: `!filter_hand.iter().any(|cc| c == cc)`
 
-error: aborting due to 22 previous errors
+error: called `is_none()` after searching an `Iterator` with `find`
+  --> $DIR/search_is_some_fixable_none.rs:85:17
+   |
+LL |         let _ = vfoo.iter().find(|v| v.foo == 1 && v.bar == 2).is_none();
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.any()` instead: `!vfoo.iter().any(|v| v.foo == 1 && v.bar == 2)`
+
+error: called `is_none()` after searching an `Iterator` with `find`
+  --> $DIR/search_is_some_fixable_none.rs:88:17
+   |
+LL |           let _ = vfoo
+   |  _________________^
+LL | |             .iter()
+LL | |             .find(|(i, v)| *i == 42 && v.foo == 1 && v.bar == 2)
+LL | |             .is_none();
+   | |______________________^
+   |
+help: use `!_.any()` instead
+   |
+LL ~         let _ = !vfoo
+LL ~             .iter().any(|(i, v)| *i == 42 && v.foo == 1 && v.bar == 2);
+   |
+
+error: called `is_none()` after searching an `Iterator` with `find`
+  --> $DIR/search_is_some_fixable_none.rs:96:17
+   |
+LL |         let _ = vfoo.iter().find(|a| a[0] == 42).is_none();
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.any()` instead: `!vfoo.iter().any(|a| a[0] == 42)`
+
+error: called `is_none()` after searching an `Iterator` with `find`
+  --> $DIR/search_is_some_fixable_none.rs:102:17
+   |
+LL |         let _ = vfoo.iter().find(|sub| sub[1..4].len() == 3).is_none();
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.any()` instead: `!vfoo.iter().any(|sub| sub[1..4].len() == 3)`
+
+error: aborting due to 26 previous errors
 
diff --git a/tests/ui/search_is_some_fixable_some.fixed b/tests/ui/search_is_some_fixable_some.fixed
index 94a4c7b3639..ae9478a42e9 100644
--- a/tests/ui/search_is_some_fixable_some.fixed
+++ b/tests/ui/search_is_some_fixable_some.fixed
@@ -73,4 +73,29 @@ mod issue7392 {
             .map(|c| c.clone())
             .collect::<Vec<_>>();
     }
+
+    fn field_projection() {
+        struct Foo {
+            foo: i32,
+            bar: u32,
+        }
+        let vfoo = vec![Foo { foo: 1, bar: 2 }];
+        let _ = vfoo.iter().any(|v| v.foo == 1 && v.bar == 2);
+
+        let vfoo = vec![(42, Foo { foo: 1, bar: 2 })];
+        let _ = vfoo
+            .iter()
+            .any(|(i, v)| *i == 42 && v.foo == 1 && v.bar == 2);
+    }
+
+    fn index_projection() {
+        let vfoo = vec![[0, 1, 2, 3]];
+        let _ = vfoo.iter().any(|a| a[0] == 42);
+    }
+
+    #[allow(clippy::match_like_matches_macro)]
+    fn slice_projection() {
+        let vfoo = vec![[0, 1, 2, 3, 0, 1, 2, 3]];
+        let _ = vfoo.iter().any(|sub| sub[1..4].len() == 3);
+    }
 }
diff --git a/tests/ui/search_is_some_fixable_some.rs b/tests/ui/search_is_some_fixable_some.rs
index 8887b0327e2..98c3e7c1a68 100644
--- a/tests/ui/search_is_some_fixable_some.rs
+++ b/tests/ui/search_is_some_fixable_some.rs
@@ -74,4 +74,30 @@ mod issue7392 {
             .map(|c| c.clone())
             .collect::<Vec<_>>();
     }
+
+    fn field_projection() {
+        struct Foo {
+            foo: i32,
+            bar: u32,
+        }
+        let vfoo = vec![Foo { foo: 1, bar: 2 }];
+        let _ = vfoo.iter().find(|v| v.foo == 1 && v.bar == 2).is_some();
+
+        let vfoo = vec![(42, Foo { foo: 1, bar: 2 })];
+        let _ = vfoo
+            .iter()
+            .find(|(i, v)| *i == 42 && v.foo == 1 && v.bar == 2)
+            .is_some();
+    }
+
+    fn index_projection() {
+        let vfoo = vec![[0, 1, 2, 3]];
+        let _ = vfoo.iter().find(|a| a[0] == 42).is_some();
+    }
+
+    #[allow(clippy::match_like_matches_macro)]
+    fn slice_projection() {
+        let vfoo = vec![[0, 1, 2, 3, 0, 1, 2, 3]];
+        let _ = vfoo.iter().find(|sub| sub[1..4].len() == 3).is_some();
+    }
 }
diff --git a/tests/ui/search_is_some_fixable_some.stderr b/tests/ui/search_is_some_fixable_some.stderr
index 90615a85ca3..4161b5eec0a 100644
--- a/tests/ui/search_is_some_fixable_some.stderr
+++ b/tests/ui/search_is_some_fixable_some.stderr
@@ -134,5 +134,31 @@ error: called `is_some()` after searching an `Iterator` with `find`
 LL |             .filter(|(c, _)| filter_hand.iter().find(|cc| c == *cc).is_some())
    |                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `any()` instead: `any(|cc| c == cc)`
 
-error: aborting due to 22 previous errors
+error: called `is_some()` after searching an `Iterator` with `find`
+  --> $DIR/search_is_some_fixable_some.rs:84:29
+   |
+LL |         let _ = vfoo.iter().find(|v| v.foo == 1 && v.bar == 2).is_some();
+   |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `any()` instead: `any(|v| v.foo == 1 && v.bar == 2)`
+
+error: called `is_some()` after searching an `Iterator` with `find`
+  --> $DIR/search_is_some_fixable_some.rs:89:14
+   |
+LL |               .find(|(i, v)| *i == 42 && v.foo == 1 && v.bar == 2)
+   |  ______________^
+LL | |             .is_some();
+   | |______________________^ help: use `any()` instead: `any(|(i, v)| *i == 42 && v.foo == 1 && v.bar == 2)`
+
+error: called `is_some()` after searching an `Iterator` with `find`
+  --> $DIR/search_is_some_fixable_some.rs:95:29
+   |
+LL |         let _ = vfoo.iter().find(|a| a[0] == 42).is_some();
+   |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `any()` instead: `any(|a| a[0] == 42)`
+
+error: called `is_some()` after searching an `Iterator` with `find`
+  --> $DIR/search_is_some_fixable_some.rs:101:29
+   |
+LL |         let _ = vfoo.iter().find(|sub| sub[1..4].len() == 3).is_some();
+   |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `any()` instead: `any(|sub| sub[1..4].len() == 3)`
+
+error: aborting due to 26 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 788c9ccc938ac0384fd06a071806502121af1a5a Mon Sep 17 00:00:00 2001
From: ThibsG <thibsg@pm.me>
Date: Sun, 12 Sep 2021 11:40:14 +0200
Subject: Applying refactoring for simplified code

---
 clippy_lints/src/methods/search_is_some.rs | 47 ++++++++++++++----------------
 1 file changed, 22 insertions(+), 25 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/search_is_some.rs b/clippy_lints/src/methods/search_is_some.rs
index d09baf50e49..a5e6a8df03f 100644
--- a/clippy_lints/src/methods/search_is_some.rs
+++ b/clippy_lints/src/methods/search_is_some.rs
@@ -5,7 +5,7 @@ use clippy_utils::{get_parent_expr_for_hir, is_trait_method, strip_pat_refs};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
-use rustc_hir::{self, Expr, ExprKind, HirId, PatKind};
+use rustc_hir::{self, ExprKind, HirId, PatKind};
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::LateContext;
 use rustc_middle::hir::place::ProjectionKind;
@@ -229,26 +229,23 @@ impl<'tcx> Delegate<'tcx> for DerefDelegate<'_, 'tcx> {
             } else {
                 // cases where a parent call is using the item
                 // i.e.: suggest `.contains(&x)` for `.find(|x| [1, 2, 3].contains(x)).is_none()`
-                let parent_expr = get_parent_expr_for_hir(self.cx, cmt.hir_id);
-                if let Some(Expr { hir_id: _, kind, .. }) = parent_expr {
-                    if let ExprKind::Call(_, args) | ExprKind::MethodCall(_, _, args, _) = kind {
-                        let args_to_handle = args.iter().filter(|arg| arg.hir_id == cmt.hir_id).collect::<Vec<_>>();
-                        if !args_to_handle.is_empty() {
-                            for arg in &args_to_handle {
-                                let arg_ty_kind = self.cx.typeck_results().expr_ty(arg).kind();
-                                if matches!(arg_ty_kind, ty::Ref(_, _, Mutability::Not)) {
-                                    let start_span = Span::new(self.next_pos, span.lo(), span.ctxt());
-                                    let start_snip =
-                                        snippet_with_applicability(self.cx, start_span, "..", &mut self.applicability);
+                if let Some(parent_expr) = get_parent_expr_for_hir(self.cx, cmt.hir_id) {
+                    if let ExprKind::Call(..) | ExprKind::MethodCall(..) = parent_expr.kind {
+                        let expr = self.cx.tcx.hir().expect_expr(cmt.hir_id);
+                        let arg_ty_kind = self.cx.typeck_results().expr_ty(expr).kind();
 
-                                    self.suggestion_start.push_str(&format!("{}&{}", start_snip, ident_str));
-                                    self.next_pos = span.hi();
-                                } else {
-                                    self.applicability = Applicability::Unspecified;
-                                }
-                            }
-                            return;
+                        // Note: this should always be true, as `find` only gives us a reference which are not mutable
+                        if matches!(arg_ty_kind, ty::Ref(_, _, Mutability::Not)) {
+                            let start_span = Span::new(self.next_pos, span.lo(), span.ctxt());
+                            let start_snip =
+                                snippet_with_applicability(self.cx, start_span, "..", &mut self.applicability);
+
+                            self.suggestion_start.push_str(&format!("{}&{}", start_snip, ident_str));
+                            self.next_pos = span.hi();
+                        } else {
+                            self.applicability = Applicability::Unspecified;
                         }
+                        return;
                     }
                 }
 
@@ -290,17 +287,17 @@ impl<'tcx> Delegate<'tcx> for DerefDelegate<'_, 'tcx> {
                             },
                             _ => false,
                         },
-                        ProjectionKind::Index => false, /* handled previously */
-                        // note: unable to capture `Subslice` kind in tests
-                        ProjectionKind::Subslice => false,
+                        // handled previously
+                        ProjectionKind::Index |
+                            // note: unable to trigger `Subslice` kind in tests
+                            ProjectionKind::Subslice => false,
                         ProjectionKind::Deref => {
                             // explicit deref for arrays should be avoided in the suggestion
                             // i.e.: `|sub| *sub[1..4].len() == 3` is not expected
                             match cmt.place.ty_before_projection(i).kind() {
                                 // dereferencing an array (i.e.: `|sub| sub[1..4].len() == 3`)
-                                ty::Ref(_, inner, _) => match inner.kind() {
-                                    ty::Ref(_, innermost, _) if innermost.is_array() => true,
-                                    _ => false,
+                                ty::Ref(_, inner, _) => {
+                                    matches!(inner.kind(), ty::Ref(_, innermost, _) if innermost.is_array())
                                 },
                                 _ => false,
                             }
-- 
cgit 1.4.1-3-g733a5


From ac45a83ad5df284a4680f0c3c90d86f7a177e41f Mon Sep 17 00:00:00 2001
From: ThibsG <thibsg@pm.me>
Date: Tue, 14 Sep 2021 14:53:28 +0200
Subject: Handle multiple reference levels into binding type and add more tests

---
 clippy_lints/src/methods/search_is_some.rs  | 29 ++++++++++++++++++++++++-----
 tests/ui/search_is_some_fixable_none.fixed  | 11 +++++++++++
 tests/ui/search_is_some_fixable_none.rs     | 11 +++++++++++
 tests/ui/search_is_some_fixable_none.stderr | 14 +++++++++++++-
 tests/ui/search_is_some_fixable_some.fixed  | 11 +++++++++++
 tests/ui/search_is_some_fixable_some.rs     | 11 +++++++++++
 tests/ui/search_is_some_fixable_some.stderr | 14 +++++++++++++-
 7 files changed, 94 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/search_is_some.rs b/clippy_lints/src/methods/search_is_some.rs
index a5e6a8df03f..dca4d84f6b1 100644
--- a/clippy_lints/src/methods/search_is_some.rs
+++ b/clippy_lints/src/methods/search_is_some.rs
@@ -50,12 +50,26 @@ pub(super) fn check<'tcx>(
                 then {
                     if let hir::PatKind::Ref(..) = closure_arg.pat.kind {
                         Some(search_snippet.replacen('&', "", 1))
-                    } else if let PatKind::Binding(..) = strip_pat_refs(closure_arg.pat).kind {
+                    } else if let PatKind::Binding(_, binding_id, _, _) = strip_pat_refs(closure_arg.pat).kind {
+                        // this binding is composed of at least two levels of references, so we need to remove one
+                        let binding_type = cx.typeck_results().node_type(binding_id);
+                        let innermost_is_ref = if let ty::Ref(_, inner,_) = binding_type.kind() {
+                            matches!(inner.kind(), ty::Ref(_, innermost, _) if innermost.is_ref())
+                        } else {
+                            false
+                        };
+
                         // `find()` provides a reference to the item, but `any` does not,
                         // so we should fix item usages for suggestion
                         if let Some(closure_sugg) = get_closure_suggestion(cx, search_arg, closure_body) {
                             applicability = closure_sugg.applicability;
-                            Some(closure_sugg.suggestion)
+                            if innermost_is_ref {
+                                Some(closure_sugg.suggestion.replacen('&', "", 1))
+                            } else {
+                                Some(closure_sugg.suggestion)
+                            }
+                        } else if innermost_is_ref {
+                            Some(search_snippet.replacen('&', "", 1))
                         } else {
                             Some(search_snippet.to_string())
                         }
@@ -230,7 +244,7 @@ impl<'tcx> Delegate<'tcx> for DerefDelegate<'_, 'tcx> {
                 // cases where a parent call is using the item
                 // i.e.: suggest `.contains(&x)` for `.find(|x| [1, 2, 3].contains(x)).is_none()`
                 if let Some(parent_expr) = get_parent_expr_for_hir(self.cx, cmt.hir_id) {
-                    if let ExprKind::Call(..) | ExprKind::MethodCall(..) = parent_expr.kind {
+                    if let ExprKind::Call(_, call_args) | ExprKind::MethodCall(_, _, call_args, _) = parent_expr.kind {
                         let expr = self.cx.tcx.hir().expect_expr(cmt.hir_id);
                         let arg_ty_kind = self.cx.typeck_results().expr_ty(expr).kind();
 
@@ -239,8 +253,13 @@ impl<'tcx> Delegate<'tcx> for DerefDelegate<'_, 'tcx> {
                             let start_span = Span::new(self.next_pos, span.lo(), span.ctxt());
                             let start_snip =
                                 snippet_with_applicability(self.cx, start_span, "..", &mut self.applicability);
-
-                            self.suggestion_start.push_str(&format!("{}&{}", start_snip, ident_str));
+                            // do not suggest ampersand if the ident is the method caller
+                            let ident_sugg = if !call_args.is_empty() && call_args[0].hir_id == cmt.hir_id {
+                                format!("{}{}", start_snip, ident_str)
+                            } else {
+                                format!("{}&{}", start_snip, ident_str)
+                            };
+                            self.suggestion_start.push_str(&ident_sugg);
                             self.next_pos = span.hi();
                         } else {
                             self.applicability = Applicability::Unspecified;
diff --git a/tests/ui/search_is_some_fixable_none.fixed b/tests/ui/search_is_some_fixable_none.fixed
index 222731fd212..811bb1e3176 100644
--- a/tests/ui/search_is_some_fixable_none.fixed
+++ b/tests/ui/search_is_some_fixable_none.fixed
@@ -97,4 +97,15 @@ mod issue7392 {
         let vfoo = vec![[0, 1, 2, 3, 0, 1, 2, 3]];
         let _ = !vfoo.iter().any(|sub| sub[1..4].len() == 3);
     }
+
+    fn please(x: &u32) -> bool {
+        *x == 9
+    }
+
+    fn more_projections() {
+        let x = 19;
+        let ppx: &u32 = &x;
+        let _ = ![ppx].iter().any(|ppp_x: &&u32| please(ppp_x));
+        let _ = ![String::from("Hey hey")].iter().any(|s| s.len() == 2);
+    }
 }
diff --git a/tests/ui/search_is_some_fixable_none.rs b/tests/ui/search_is_some_fixable_none.rs
index 43ac1a07667..c6fbb5e2d26 100644
--- a/tests/ui/search_is_some_fixable_none.rs
+++ b/tests/ui/search_is_some_fixable_none.rs
@@ -101,4 +101,15 @@ mod issue7392 {
         let vfoo = vec![[0, 1, 2, 3, 0, 1, 2, 3]];
         let _ = vfoo.iter().find(|sub| sub[1..4].len() == 3).is_none();
     }
+
+    fn please(x: &u32) -> bool {
+        *x == 9
+    }
+
+    fn more_projections() {
+        let x = 19;
+        let ppx: &u32 = &x;
+        let _ = [ppx].iter().find(|ppp_x: &&&u32| please(**ppp_x)).is_none();
+        let _ = [String::from("Hey hey")].iter().find(|s| s.len() == 2).is_none();
+    }
 }
diff --git a/tests/ui/search_is_some_fixable_none.stderr b/tests/ui/search_is_some_fixable_none.stderr
index fa344046aeb..b89ddabee55 100644
--- a/tests/ui/search_is_some_fixable_none.stderr
+++ b/tests/ui/search_is_some_fixable_none.stderr
@@ -169,5 +169,17 @@ error: called `is_none()` after searching an `Iterator` with `find`
 LL |         let _ = vfoo.iter().find(|sub| sub[1..4].len() == 3).is_none();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.any()` instead: `!vfoo.iter().any(|sub| sub[1..4].len() == 3)`
 
-error: aborting due to 26 previous errors
+error: called `is_none()` after searching an `Iterator` with `find`
+  --> $DIR/search_is_some_fixable_none.rs:112:17
+   |
+LL |         let _ = [ppx].iter().find(|ppp_x: &&&u32| please(**ppp_x)).is_none();
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.any()` instead: `![ppx].iter().any(|ppp_x: &&u32| please(ppp_x))`
+
+error: called `is_none()` after searching an `Iterator` with `find`
+  --> $DIR/search_is_some_fixable_none.rs:113:17
+   |
+LL |         let _ = [String::from("Hey hey")].iter().find(|s| s.len() == 2).is_none();
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.any()` instead: `![String::from("Hey hey")].iter().any(|s| s.len() == 2)`
+
+error: aborting due to 28 previous errors
 
diff --git a/tests/ui/search_is_some_fixable_some.fixed b/tests/ui/search_is_some_fixable_some.fixed
index ae9478a42e9..76b7f3d05d5 100644
--- a/tests/ui/search_is_some_fixable_some.fixed
+++ b/tests/ui/search_is_some_fixable_some.fixed
@@ -98,4 +98,15 @@ mod issue7392 {
         let vfoo = vec![[0, 1, 2, 3, 0, 1, 2, 3]];
         let _ = vfoo.iter().any(|sub| sub[1..4].len() == 3);
     }
+
+    fn please(x: &u32) -> bool {
+        *x == 9
+    }
+
+    fn more_projections() {
+        let x = 19;
+        let ppx: &u32 = &x;
+        let _ = [ppx].iter().any(|ppp_x: &&u32| please(ppp_x));
+        let _ = [String::from("Hey hey")].iter().any(|s| s.len() == 2);
+    }
 }
diff --git a/tests/ui/search_is_some_fixable_some.rs b/tests/ui/search_is_some_fixable_some.rs
index 98c3e7c1a68..364250e6ed8 100644
--- a/tests/ui/search_is_some_fixable_some.rs
+++ b/tests/ui/search_is_some_fixable_some.rs
@@ -100,4 +100,15 @@ mod issue7392 {
         let vfoo = vec![[0, 1, 2, 3, 0, 1, 2, 3]];
         let _ = vfoo.iter().find(|sub| sub[1..4].len() == 3).is_some();
     }
+
+    fn please(x: &u32) -> bool {
+        *x == 9
+    }
+
+    fn more_projections() {
+        let x = 19;
+        let ppx: &u32 = &x;
+        let _ = [ppx].iter().find(|ppp_x: &&&u32| please(**ppp_x)).is_some();
+        let _ = [String::from("Hey hey")].iter().find(|s| s.len() == 2).is_some();
+    }
 }
diff --git a/tests/ui/search_is_some_fixable_some.stderr b/tests/ui/search_is_some_fixable_some.stderr
index 4161b5eec0a..183d99497ac 100644
--- a/tests/ui/search_is_some_fixable_some.stderr
+++ b/tests/ui/search_is_some_fixable_some.stderr
@@ -160,5 +160,17 @@ error: called `is_some()` after searching an `Iterator` with `find`
 LL |         let _ = vfoo.iter().find(|sub| sub[1..4].len() == 3).is_some();
    |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `any()` instead: `any(|sub| sub[1..4].len() == 3)`
 
-error: aborting due to 26 previous errors
+error: called `is_some()` after searching an `Iterator` with `find`
+  --> $DIR/search_is_some_fixable_some.rs:111:30
+   |
+LL |         let _ = [ppx].iter().find(|ppp_x: &&&u32| please(**ppp_x)).is_some();
+   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `any()` instead: `any(|ppp_x: &&u32| please(ppp_x))`
+
+error: called `is_some()` after searching an `Iterator` with `find`
+  --> $DIR/search_is_some_fixable_some.rs:112:50
+   |
+LL |         let _ = [String::from("Hey hey")].iter().find(|s| s.len() == 2).is_some();
+   |                                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `any()` instead: `any(|s| s.len() == 2)`
+
+error: aborting due to 28 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 6d1ccbf46682b99f0301488bfffff403e824b4d7 Mon Sep 17 00:00:00 2001
From: ThibsG <thibsg@pm.me>
Date: Sun, 19 Sep 2021 08:08:54 +0200
Subject: Correct suggestion when dereferencing enough, calling a function

---
 clippy_lints/src/methods/search_is_some.rs  |  3 +--
 tests/ui/search_is_some_fixable_none.fixed  |  7 +++++++
 tests/ui/search_is_some_fixable_none.rs     |  7 +++++++
 tests/ui/search_is_some_fixable_none.stderr | 12 +++++++++---
 tests/ui/search_is_some_fixable_some.fixed  |  7 +++++++
 tests/ui/search_is_some_fixable_some.rs     |  7 +++++++
 tests/ui/search_is_some_fixable_some.stderr | 12 +++++++++---
 7 files changed, 47 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/search_is_some.rs b/clippy_lints/src/methods/search_is_some.rs
index dca4d84f6b1..98ad7f3866f 100644
--- a/clippy_lints/src/methods/search_is_some.rs
+++ b/clippy_lints/src/methods/search_is_some.rs
@@ -248,7 +248,6 @@ impl<'tcx> Delegate<'tcx> for DerefDelegate<'_, 'tcx> {
                         let expr = self.cx.tcx.hir().expect_expr(cmt.hir_id);
                         let arg_ty_kind = self.cx.typeck_results().expr_ty(expr).kind();
 
-                        // Note: this should always be true, as `find` only gives us a reference which are not mutable
                         if matches!(arg_ty_kind, ty::Ref(_, _, Mutability::Not)) {
                             let start_span = Span::new(self.next_pos, span.lo(), span.ctxt());
                             let start_snip =
@@ -261,10 +260,10 @@ impl<'tcx> Delegate<'tcx> for DerefDelegate<'_, 'tcx> {
                             };
                             self.suggestion_start.push_str(&ident_sugg);
                             self.next_pos = span.hi();
+                            return;
                         } else {
                             self.applicability = Applicability::Unspecified;
                         }
-                        return;
                     }
                 }
 
diff --git a/tests/ui/search_is_some_fixable_none.fixed b/tests/ui/search_is_some_fixable_none.fixed
index 811bb1e3176..c7c0b766015 100644
--- a/tests/ui/search_is_some_fixable_none.fixed
+++ b/tests/ui/search_is_some_fixable_none.fixed
@@ -102,10 +102,17 @@ mod issue7392 {
         *x == 9
     }
 
+    fn simple_fn(x: u32) -> bool {
+        x == 78
+    }
+
     fn more_projections() {
         let x = 19;
         let ppx: &u32 = &x;
         let _ = ![ppx].iter().any(|ppp_x: &&u32| please(ppp_x));
         let _ = ![String::from("Hey hey")].iter().any(|s| s.len() == 2);
+
+        let v = vec![3, 2, 1, 0];
+        let _ = !v.iter().any(|x| simple_fn(*x));
     }
 }
diff --git a/tests/ui/search_is_some_fixable_none.rs b/tests/ui/search_is_some_fixable_none.rs
index c6fbb5e2d26..6b41da4f2f8 100644
--- a/tests/ui/search_is_some_fixable_none.rs
+++ b/tests/ui/search_is_some_fixable_none.rs
@@ -106,10 +106,17 @@ mod issue7392 {
         *x == 9
     }
 
+    fn simple_fn(x: u32) -> bool {
+        x == 78
+    }
+
     fn more_projections() {
         let x = 19;
         let ppx: &u32 = &x;
         let _ = [ppx].iter().find(|ppp_x: &&&u32| please(**ppp_x)).is_none();
         let _ = [String::from("Hey hey")].iter().find(|s| s.len() == 2).is_none();
+
+        let v = vec![3, 2, 1, 0];
+        let _ = v.iter().find(|x| simple_fn(**x)).is_none();
     }
 }
diff --git a/tests/ui/search_is_some_fixable_none.stderr b/tests/ui/search_is_some_fixable_none.stderr
index b89ddabee55..4313a2d526c 100644
--- a/tests/ui/search_is_some_fixable_none.stderr
+++ b/tests/ui/search_is_some_fixable_none.stderr
@@ -170,16 +170,22 @@ LL |         let _ = vfoo.iter().find(|sub| sub[1..4].len() == 3).is_none();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.any()` instead: `!vfoo.iter().any(|sub| sub[1..4].len() == 3)`
 
 error: called `is_none()` after searching an `Iterator` with `find`
-  --> $DIR/search_is_some_fixable_none.rs:112:17
+  --> $DIR/search_is_some_fixable_none.rs:116:17
    |
 LL |         let _ = [ppx].iter().find(|ppp_x: &&&u32| please(**ppp_x)).is_none();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.any()` instead: `![ppx].iter().any(|ppp_x: &&u32| please(ppp_x))`
 
 error: called `is_none()` after searching an `Iterator` with `find`
-  --> $DIR/search_is_some_fixable_none.rs:113:17
+  --> $DIR/search_is_some_fixable_none.rs:117:17
    |
 LL |         let _ = [String::from("Hey hey")].iter().find(|s| s.len() == 2).is_none();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.any()` instead: `![String::from("Hey hey")].iter().any(|s| s.len() == 2)`
 
-error: aborting due to 28 previous errors
+error: called `is_none()` after searching an `Iterator` with `find`
+  --> $DIR/search_is_some_fixable_none.rs:120:17
+   |
+LL |         let _ = v.iter().find(|x| simple_fn(**x)).is_none();
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.any()` instead: `!v.iter().any(|x| simple_fn(*x))`
+
+error: aborting due to 29 previous errors
 
diff --git a/tests/ui/search_is_some_fixable_some.fixed b/tests/ui/search_is_some_fixable_some.fixed
index 76b7f3d05d5..833168cf242 100644
--- a/tests/ui/search_is_some_fixable_some.fixed
+++ b/tests/ui/search_is_some_fixable_some.fixed
@@ -103,10 +103,17 @@ mod issue7392 {
         *x == 9
     }
 
+    fn simple_fn(x: u32) -> bool {
+        x == 78
+    }
+
     fn more_projections() {
         let x = 19;
         let ppx: &u32 = &x;
         let _ = [ppx].iter().any(|ppp_x: &&u32| please(ppp_x));
         let _ = [String::from("Hey hey")].iter().any(|s| s.len() == 2);
+
+        let v = vec![3, 2, 1, 0];
+        let _ = v.iter().any(|x| simple_fn(*x));
     }
 }
diff --git a/tests/ui/search_is_some_fixable_some.rs b/tests/ui/search_is_some_fixable_some.rs
index 364250e6ed8..f9fb241de3f 100644
--- a/tests/ui/search_is_some_fixable_some.rs
+++ b/tests/ui/search_is_some_fixable_some.rs
@@ -105,10 +105,17 @@ mod issue7392 {
         *x == 9
     }
 
+    fn simple_fn(x: u32) -> bool {
+        x == 78
+    }
+
     fn more_projections() {
         let x = 19;
         let ppx: &u32 = &x;
         let _ = [ppx].iter().find(|ppp_x: &&&u32| please(**ppp_x)).is_some();
         let _ = [String::from("Hey hey")].iter().find(|s| s.len() == 2).is_some();
+
+        let v = vec![3, 2, 1, 0];
+        let _ = v.iter().find(|x| simple_fn(**x)).is_some();
     }
 }
diff --git a/tests/ui/search_is_some_fixable_some.stderr b/tests/ui/search_is_some_fixable_some.stderr
index 183d99497ac..01b13cea2cd 100644
--- a/tests/ui/search_is_some_fixable_some.stderr
+++ b/tests/ui/search_is_some_fixable_some.stderr
@@ -161,16 +161,22 @@ LL |         let _ = vfoo.iter().find(|sub| sub[1..4].len() == 3).is_some();
    |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `any()` instead: `any(|sub| sub[1..4].len() == 3)`
 
 error: called `is_some()` after searching an `Iterator` with `find`
-  --> $DIR/search_is_some_fixable_some.rs:111:30
+  --> $DIR/search_is_some_fixable_some.rs:115:30
    |
 LL |         let _ = [ppx].iter().find(|ppp_x: &&&u32| please(**ppp_x)).is_some();
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `any()` instead: `any(|ppp_x: &&u32| please(ppp_x))`
 
 error: called `is_some()` after searching an `Iterator` with `find`
-  --> $DIR/search_is_some_fixable_some.rs:112:50
+  --> $DIR/search_is_some_fixable_some.rs:116:50
    |
 LL |         let _ = [String::from("Hey hey")].iter().find(|s| s.len() == 2).is_some();
    |                                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `any()` instead: `any(|s| s.len() == 2)`
 
-error: aborting due to 28 previous errors
+error: called `is_some()` after searching an `Iterator` with `find`
+  --> $DIR/search_is_some_fixable_some.rs:119:26
+   |
+LL |         let _ = v.iter().find(|x| simple_fn(**x)).is_some();
+   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `any()` instead: `any(|x| simple_fn(*x))`
+
+error: aborting due to 29 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 7a55407cc37ddb1bf1d3d95e52db7b6402259966 Mon Sep 17 00:00:00 2001
From: ThibsG <thibsg@pm.me>
Date: Tue, 21 Sep 2021 14:54:19 +0200
Subject: Fix suggestions when call functions involved taking by ref

---
 clippy_lints/src/methods/search_is_some.rs  | 93 +++++++++++++++++------------
 tests/ui/search_is_some_fixable_none.fixed  | 50 +++++++++++++++-
 tests/ui/search_is_some_fixable_none.rs     | 52 +++++++++++++++-
 tests/ui/search_is_some_fixable_none.stderr | 46 ++++++++++++--
 tests/ui/search_is_some_fixable_some.fixed  | 51 +++++++++++++++-
 tests/ui/search_is_some_fixable_some.rs     | 52 +++++++++++++++-
 tests/ui/search_is_some_fixable_some.stderr | 38 ++++++++++--
 7 files changed, 325 insertions(+), 57 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/search_is_some.rs b/clippy_lints/src/methods/search_is_some.rs
index 98ad7f3866f..25a2c48e269 100644
--- a/clippy_lints/src/methods/search_is_some.rs
+++ b/clippy_lints/src/methods/search_is_some.rs
@@ -1,3 +1,5 @@
+use std::iter;
+
 use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg};
 use clippy_utils::source::{snippet, snippet_with_applicability};
 use clippy_utils::ty::is_type_diagnostic_item;
@@ -223,6 +225,26 @@ impl DerefDelegate<'_, 'tcx> {
         let end_snip = snippet_with_applicability(self.cx, end_span, "..", &mut self.applicability);
         format!("{}{}", self.suggestion_start, end_snip)
     }
+
+    fn func_takes_arg_by_ref(&self, parent_expr: &'tcx hir::Expr<'_>, cmt_hir_id: HirId) -> bool {
+        if_chain! {
+            if let ExprKind::Call(func, call_args) = parent_expr.kind;
+            let typ = self.cx.typeck_results().expr_ty(func);
+            if let ty::FnDef(..) = typ.kind();
+
+            then {
+                let mut takes_by_ref = false;
+                for (arg, ty) in iter::zip(call_args, typ.fn_sig(self.cx.tcx).skip_binder().inputs()) {
+                    if arg.hir_id == cmt_hir_id {
+                        takes_by_ref = matches!(ty.kind(), ty::Ref(_, inner, _) if inner.is_ref());
+                    }
+                }
+                takes_by_ref
+            } else {
+                false
+            }
+        }
+    }
 }
 
 impl<'tcx> Delegate<'tcx> for DerefDelegate<'_, 'tcx> {
@@ -252,18 +274,23 @@ impl<'tcx> Delegate<'tcx> for DerefDelegate<'_, 'tcx> {
                             let start_span = Span::new(self.next_pos, span.lo(), span.ctxt());
                             let start_snip =
                                 snippet_with_applicability(self.cx, start_span, "..", &mut self.applicability);
+
+                            // suggest ampersand if call function is taking args by ref
+                            let takes_arg_by_ref = self.func_takes_arg_by_ref(parent_expr, cmt.hir_id);
+
                             // do not suggest ampersand if the ident is the method caller
-                            let ident_sugg = if !call_args.is_empty() && call_args[0].hir_id == cmt.hir_id {
-                                format!("{}{}", start_snip, ident_str)
-                            } else {
-                                format!("{}&{}", start_snip, ident_str)
-                            };
+                            let ident_sugg =
+                                if !call_args.is_empty() && call_args[0].hir_id == cmt.hir_id && !takes_arg_by_ref {
+                                    format!("{}{}", start_snip, ident_str)
+                                } else {
+                                    format!("{}&{}", start_snip, ident_str)
+                                };
                             self.suggestion_start.push_str(&ident_sugg);
                             self.next_pos = span.hi();
                             return;
-                        } else {
-                            self.applicability = Applicability::Unspecified;
                         }
+
+                        self.applicability = Applicability::Unspecified;
                     }
                 }
 
@@ -271,23 +298,8 @@ impl<'tcx> Delegate<'tcx> for DerefDelegate<'_, 'tcx> {
                 // i.e.: suggest `*x` instead of `**x`
                 let mut replacement_str = ident_str;
 
-                // handle index projection first
-                let index_handled = cmt.place.projections.iter().any(|proj| match proj.kind {
-                    // Index projection like `|x| foo[x]`
-                    // the index is dropped so we can't get it to build the suggestion,
-                    // so the span is set-up again to get more code, using `span.hi()` (i.e.: `foo[x]`)
-                    // instead of `span.lo()` (i.e.: `foo`)
-                    ProjectionKind::Index => {
-                        let start_span = Span::new(self.next_pos, span.hi(), span.ctxt());
-                        start_snip = snippet_with_applicability(self.cx, start_span, "..", &mut self.applicability);
-                        replacement_str.clear();
-                        true
-                    },
-                    _ => false,
-                });
-
-                // looking for projections other that need to be handled differently
-                let other_projections_handled = cmt.place.projections.iter().enumerate().any(|(i, proj)| {
+                let mut projections_handled = false;
+                cmt.place.projections.iter().enumerate().for_each(|(i, proj)| {
                     match proj.kind {
                         // Field projection like `|v| v.foo`
                         ProjectionKind::Field(idx, variant) => match cmt.place.ty_before_projection(i).kind() {
@@ -297,34 +309,41 @@ impl<'tcx> Delegate<'tcx> for DerefDelegate<'_, 'tcx> {
                                     replacement_str,
                                     def.variants[variant].fields[idx as usize].ident.name.as_str()
                                 );
-                                true
+                                projections_handled = true;
                             },
                             ty::Tuple(_) => {
                                 replacement_str = format!("{}.{}", replacement_str, idx);
-                                true
+                                projections_handled = true;
                             },
-                            _ => false,
+                            _ => (),
+                        },
+                        // Index projection like `|x| foo[x]`
+                        // the index is dropped so we can't get it to build the suggestion,
+                        // so the span is set-up again to get more code, using `span.hi()` (i.e.: `foo[x]`)
+                        // instead of `span.lo()` (i.e.: `foo`)
+                        ProjectionKind::Index => {
+                            let start_span = Span::new(self.next_pos, span.hi(), span.ctxt());
+                            start_snip = snippet_with_applicability(self.cx, start_span, "..", &mut self.applicability);
+                            replacement_str.clear();
+                            projections_handled = true;
                         },
-                        // handled previously
-                        ProjectionKind::Index |
-                            // note: unable to trigger `Subslice` kind in tests
-                            ProjectionKind::Subslice => false,
+                        // note: unable to trigger `Subslice` kind in tests
+                        ProjectionKind::Subslice => (),
                         ProjectionKind::Deref => {
                             // explicit deref for arrays should be avoided in the suggestion
                             // i.e.: `|sub| *sub[1..4].len() == 3` is not expected
-                            match cmt.place.ty_before_projection(i).kind() {
+                            if let ty::Ref(_, inner, _) = cmt.place.ty_before_projection(i).kind() {
                                 // dereferencing an array (i.e.: `|sub| sub[1..4].len() == 3`)
-                                ty::Ref(_, inner, _) => {
-                                    matches!(inner.kind(), ty::Ref(_, innermost, _) if innermost.is_array())
-                                },
-                                _ => false,
+                                if matches!(inner.kind(), ty::Ref(_, innermost, _) if innermost.is_array()) {
+                                    projections_handled = true;
+                                }
                             }
                         },
                     }
                 });
 
                 // handle `ProjectionKind::Deref` if no special case detected
-                if !index_handled && !other_projections_handled {
+                if !projections_handled {
                     let last_deref = cmt
                         .place
                         .projections
diff --git a/tests/ui/search_is_some_fixable_none.fixed b/tests/ui/search_is_some_fixable_none.fixed
index c7c0b766015..6b8a614bbda 100644
--- a/tests/ui/search_is_some_fixable_none.fixed
+++ b/tests/ui/search_is_some_fixable_none.fixed
@@ -102,10 +102,14 @@ mod issue7392 {
         *x == 9
     }
 
-    fn simple_fn(x: u32) -> bool {
+    fn deref_enough(x: u32) -> bool {
         x == 78
     }
 
+    fn arg_no_deref(x: &&u32) -> bool {
+        **x == 78
+    }
+
     fn more_projections() {
         let x = 19;
         let ppx: &u32 = &x;
@@ -113,6 +117,48 @@ mod issue7392 {
         let _ = ![String::from("Hey hey")].iter().any(|s| s.len() == 2);
 
         let v = vec![3, 2, 1, 0];
-        let _ = !v.iter().any(|x| simple_fn(*x));
+        let _ = !v.iter().any(|x| deref_enough(*x));
+
+        #[allow(clippy::redundant_closure)]
+        let _ = !v.iter().any(|x| arg_no_deref(&x));
+    }
+
+    fn field_index_projection() {
+        struct FooDouble {
+            bar: Vec<Vec<i32>>,
+        }
+        struct Foo {
+            bar: Vec<i32>,
+        }
+        struct FooOuter {
+            inner: Foo,
+            inner_double: FooDouble,
+        }
+        let vfoo = vec![FooOuter {
+            inner: Foo { bar: vec![0, 1, 2, 3] },
+            inner_double: FooDouble {
+                bar: vec![vec![0, 1, 2, 3]],
+            },
+        }];
+        let _ = !vfoo
+            .iter().any(|v| v.inner_double.bar[0][0] == 2 && v.inner.bar[0] == 2);
+    }
+
+    fn index_field_projection() {
+        struct Foo {
+            bar: i32,
+        }
+        struct FooOuter {
+            inner: Vec<Foo>,
+        }
+        let vfoo = vec![FooOuter {
+            inner: vec![Foo { bar: 0 }],
+        }];
+        let _ = !vfoo.iter().any(|v| v.inner[0].bar == 2);
+    }
+
+    fn double_deref_index_projection() {
+        let vfoo = vec![&&[0, 1, 2, 3]];
+        let _ = !vfoo.iter().any(|x| (**x)[0] == 9);
     }
 }
diff --git a/tests/ui/search_is_some_fixable_none.rs b/tests/ui/search_is_some_fixable_none.rs
index 6b41da4f2f8..acaae650921 100644
--- a/tests/ui/search_is_some_fixable_none.rs
+++ b/tests/ui/search_is_some_fixable_none.rs
@@ -106,10 +106,14 @@ mod issue7392 {
         *x == 9
     }
 
-    fn simple_fn(x: u32) -> bool {
+    fn deref_enough(x: u32) -> bool {
         x == 78
     }
 
+    fn arg_no_deref(x: &&u32) -> bool {
+        **x == 78
+    }
+
     fn more_projections() {
         let x = 19;
         let ppx: &u32 = &x;
@@ -117,6 +121,50 @@ mod issue7392 {
         let _ = [String::from("Hey hey")].iter().find(|s| s.len() == 2).is_none();
 
         let v = vec![3, 2, 1, 0];
-        let _ = v.iter().find(|x| simple_fn(**x)).is_none();
+        let _ = v.iter().find(|x| deref_enough(**x)).is_none();
+
+        #[allow(clippy::redundant_closure)]
+        let _ = v.iter().find(|x| arg_no_deref(x)).is_none();
+    }
+
+    fn field_index_projection() {
+        struct FooDouble {
+            bar: Vec<Vec<i32>>,
+        }
+        struct Foo {
+            bar: Vec<i32>,
+        }
+        struct FooOuter {
+            inner: Foo,
+            inner_double: FooDouble,
+        }
+        let vfoo = vec![FooOuter {
+            inner: Foo { bar: vec![0, 1, 2, 3] },
+            inner_double: FooDouble {
+                bar: vec![vec![0, 1, 2, 3]],
+            },
+        }];
+        let _ = vfoo
+            .iter()
+            .find(|v| v.inner_double.bar[0][0] == 2 && v.inner.bar[0] == 2)
+            .is_none();
+    }
+
+    fn index_field_projection() {
+        struct Foo {
+            bar: i32,
+        }
+        struct FooOuter {
+            inner: Vec<Foo>,
+        }
+        let vfoo = vec![FooOuter {
+            inner: vec![Foo { bar: 0 }],
+        }];
+        let _ = vfoo.iter().find(|v| v.inner[0].bar == 2).is_none();
+    }
+
+    fn double_deref_index_projection() {
+        let vfoo = vec![&&[0, 1, 2, 3]];
+        let _ = vfoo.iter().find(|x| (**x)[0] == 9).is_none();
     }
 }
diff --git a/tests/ui/search_is_some_fixable_none.stderr b/tests/ui/search_is_some_fixable_none.stderr
index 4313a2d526c..64e81c6b94a 100644
--- a/tests/ui/search_is_some_fixable_none.stderr
+++ b/tests/ui/search_is_some_fixable_none.stderr
@@ -170,22 +170,56 @@ LL |         let _ = vfoo.iter().find(|sub| sub[1..4].len() == 3).is_none();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.any()` instead: `!vfoo.iter().any(|sub| sub[1..4].len() == 3)`
 
 error: called `is_none()` after searching an `Iterator` with `find`
-  --> $DIR/search_is_some_fixable_none.rs:116:17
+  --> $DIR/search_is_some_fixable_none.rs:120:17
    |
 LL |         let _ = [ppx].iter().find(|ppp_x: &&&u32| please(**ppp_x)).is_none();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.any()` instead: `![ppx].iter().any(|ppp_x: &&u32| please(ppp_x))`
 
 error: called `is_none()` after searching an `Iterator` with `find`
-  --> $DIR/search_is_some_fixable_none.rs:117:17
+  --> $DIR/search_is_some_fixable_none.rs:121:17
    |
 LL |         let _ = [String::from("Hey hey")].iter().find(|s| s.len() == 2).is_none();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.any()` instead: `![String::from("Hey hey")].iter().any(|s| s.len() == 2)`
 
 error: called `is_none()` after searching an `Iterator` with `find`
-  --> $DIR/search_is_some_fixable_none.rs:120:17
+  --> $DIR/search_is_some_fixable_none.rs:124:17
+   |
+LL |         let _ = v.iter().find(|x| deref_enough(**x)).is_none();
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.any()` instead: `!v.iter().any(|x| deref_enough(*x))`
+
+error: called `is_none()` after searching an `Iterator` with `find`
+  --> $DIR/search_is_some_fixable_none.rs:127:17
+   |
+LL |         let _ = v.iter().find(|x| arg_no_deref(x)).is_none();
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.any()` instead: `!v.iter().any(|x| arg_no_deref(&x))`
+
+error: called `is_none()` after searching an `Iterator` with `find`
+  --> $DIR/search_is_some_fixable_none.rs:147:17
+   |
+LL |           let _ = vfoo
+   |  _________________^
+LL | |             .iter()
+LL | |             .find(|v| v.inner_double.bar[0][0] == 2 && v.inner.bar[0] == 2)
+LL | |             .is_none();
+   | |______________________^
+   |
+help: use `!_.any()` instead
+   |
+LL ~         let _ = !vfoo
+LL ~             .iter().any(|v| v.inner_double.bar[0][0] == 2 && v.inner.bar[0] == 2);
+   |
+
+error: called `is_none()` after searching an `Iterator` with `find`
+  --> $DIR/search_is_some_fixable_none.rs:163:17
+   |
+LL |         let _ = vfoo.iter().find(|v| v.inner[0].bar == 2).is_none();
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.any()` instead: `!vfoo.iter().any(|v| v.inner[0].bar == 2)`
+
+error: called `is_none()` after searching an `Iterator` with `find`
+  --> $DIR/search_is_some_fixable_none.rs:168:17
    |
-LL |         let _ = v.iter().find(|x| simple_fn(**x)).is_none();
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.any()` instead: `!v.iter().any(|x| simple_fn(*x))`
+LL |         let _ = vfoo.iter().find(|x| (**x)[0] == 9).is_none();
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.any()` instead: `!vfoo.iter().any(|x| (**x)[0] == 9)`
 
-error: aborting due to 29 previous errors
+error: aborting due to 33 previous errors
 
diff --git a/tests/ui/search_is_some_fixable_some.fixed b/tests/ui/search_is_some_fixable_some.fixed
index 833168cf242..7eb07d639a5 100644
--- a/tests/ui/search_is_some_fixable_some.fixed
+++ b/tests/ui/search_is_some_fixable_some.fixed
@@ -103,10 +103,14 @@ mod issue7392 {
         *x == 9
     }
 
-    fn simple_fn(x: u32) -> bool {
+    fn deref_enough(x: u32) -> bool {
         x == 78
     }
 
+    fn arg_no_deref(x: &&u32) -> bool {
+        **x == 78
+    }
+
     fn more_projections() {
         let x = 19;
         let ppx: &u32 = &x;
@@ -114,6 +118,49 @@ mod issue7392 {
         let _ = [String::from("Hey hey")].iter().any(|s| s.len() == 2);
 
         let v = vec![3, 2, 1, 0];
-        let _ = v.iter().any(|x| simple_fn(*x));
+        let _ = v.iter().any(|x| deref_enough(*x));
+
+        #[allow(clippy::redundant_closure)]
+        let _ = v.iter().any(|x| arg_no_deref(&x));
+    }
+
+    fn field_index_projection() {
+        struct FooDouble {
+            bar: Vec<Vec<i32>>,
+        }
+        struct Foo {
+            bar: Vec<i32>,
+        }
+        struct FooOuter {
+            inner: Foo,
+            inner_double: FooDouble,
+        }
+        let vfoo = vec![FooOuter {
+            inner: Foo { bar: vec![0, 1, 2, 3] },
+            inner_double: FooDouble {
+                bar: vec![vec![0, 1, 2, 3]],
+            },
+        }];
+        let _ = vfoo
+            .iter()
+            .any(|v| v.inner_double.bar[0][0] == 2 && v.inner.bar[0] == 2);
+    }
+
+    fn index_field_projection() {
+        struct Foo {
+            bar: i32,
+        }
+        struct FooOuter {
+            inner: Vec<Foo>,
+        }
+        let vfoo = vec![FooOuter {
+            inner: vec![Foo { bar: 0 }],
+        }];
+        let _ = vfoo.iter().any(|v| v.inner[0].bar == 2);
+    }
+
+    fn double_deref_index_projection() {
+        let vfoo = vec![&&[0, 1, 2, 3]];
+        let _ = vfoo.iter().any(|x| (**x)[0] == 9);
     }
 }
diff --git a/tests/ui/search_is_some_fixable_some.rs b/tests/ui/search_is_some_fixable_some.rs
index f9fb241de3f..b9ebd399a35 100644
--- a/tests/ui/search_is_some_fixable_some.rs
+++ b/tests/ui/search_is_some_fixable_some.rs
@@ -105,10 +105,14 @@ mod issue7392 {
         *x == 9
     }
 
-    fn simple_fn(x: u32) -> bool {
+    fn deref_enough(x: u32) -> bool {
         x == 78
     }
 
+    fn arg_no_deref(x: &&u32) -> bool {
+        **x == 78
+    }
+
     fn more_projections() {
         let x = 19;
         let ppx: &u32 = &x;
@@ -116,6 +120,50 @@ mod issue7392 {
         let _ = [String::from("Hey hey")].iter().find(|s| s.len() == 2).is_some();
 
         let v = vec![3, 2, 1, 0];
-        let _ = v.iter().find(|x| simple_fn(**x)).is_some();
+        let _ = v.iter().find(|x| deref_enough(**x)).is_some();
+
+        #[allow(clippy::redundant_closure)]
+        let _ = v.iter().find(|x| arg_no_deref(x)).is_some();
+    }
+
+    fn field_index_projection() {
+        struct FooDouble {
+            bar: Vec<Vec<i32>>,
+        }
+        struct Foo {
+            bar: Vec<i32>,
+        }
+        struct FooOuter {
+            inner: Foo,
+            inner_double: FooDouble,
+        }
+        let vfoo = vec![FooOuter {
+            inner: Foo { bar: vec![0, 1, 2, 3] },
+            inner_double: FooDouble {
+                bar: vec![vec![0, 1, 2, 3]],
+            },
+        }];
+        let _ = vfoo
+            .iter()
+            .find(|v| v.inner_double.bar[0][0] == 2 && v.inner.bar[0] == 2)
+            .is_some();
+    }
+
+    fn index_field_projection() {
+        struct Foo {
+            bar: i32,
+        }
+        struct FooOuter {
+            inner: Vec<Foo>,
+        }
+        let vfoo = vec![FooOuter {
+            inner: vec![Foo { bar: 0 }],
+        }];
+        let _ = vfoo.iter().find(|v| v.inner[0].bar == 2).is_some();
+    }
+
+    fn double_deref_index_projection() {
+        let vfoo = vec![&&[0, 1, 2, 3]];
+        let _ = vfoo.iter().find(|x| (**x)[0] == 9).is_some();
     }
 }
diff --git a/tests/ui/search_is_some_fixable_some.stderr b/tests/ui/search_is_some_fixable_some.stderr
index 01b13cea2cd..b62cf9c4702 100644
--- a/tests/ui/search_is_some_fixable_some.stderr
+++ b/tests/ui/search_is_some_fixable_some.stderr
@@ -161,22 +161,48 @@ LL |         let _ = vfoo.iter().find(|sub| sub[1..4].len() == 3).is_some();
    |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `any()` instead: `any(|sub| sub[1..4].len() == 3)`
 
 error: called `is_some()` after searching an `Iterator` with `find`
-  --> $DIR/search_is_some_fixable_some.rs:115:30
+  --> $DIR/search_is_some_fixable_some.rs:119:30
    |
 LL |         let _ = [ppx].iter().find(|ppp_x: &&&u32| please(**ppp_x)).is_some();
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `any()` instead: `any(|ppp_x: &&u32| please(ppp_x))`
 
 error: called `is_some()` after searching an `Iterator` with `find`
-  --> $DIR/search_is_some_fixable_some.rs:116:50
+  --> $DIR/search_is_some_fixable_some.rs:120:50
    |
 LL |         let _ = [String::from("Hey hey")].iter().find(|s| s.len() == 2).is_some();
    |                                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `any()` instead: `any(|s| s.len() == 2)`
 
 error: called `is_some()` after searching an `Iterator` with `find`
-  --> $DIR/search_is_some_fixable_some.rs:119:26
+  --> $DIR/search_is_some_fixable_some.rs:123:26
    |
-LL |         let _ = v.iter().find(|x| simple_fn(**x)).is_some();
-   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `any()` instead: `any(|x| simple_fn(*x))`
+LL |         let _ = v.iter().find(|x| deref_enough(**x)).is_some();
+   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `any()` instead: `any(|x| deref_enough(*x))`
 
-error: aborting due to 29 previous errors
+error: called `is_some()` after searching an `Iterator` with `find`
+  --> $DIR/search_is_some_fixable_some.rs:126:26
+   |
+LL |         let _ = v.iter().find(|x| arg_no_deref(x)).is_some();
+   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `any()` instead: `any(|x| arg_no_deref(&x))`
+
+error: called `is_some()` after searching an `Iterator` with `find`
+  --> $DIR/search_is_some_fixable_some.rs:148:14
+   |
+LL |               .find(|v| v.inner_double.bar[0][0] == 2 && v.inner.bar[0] == 2)
+   |  ______________^
+LL | |             .is_some();
+   | |______________________^ help: use `any()` instead: `any(|v| v.inner_double.bar[0][0] == 2 && v.inner.bar[0] == 2)`
+
+error: called `is_some()` after searching an `Iterator` with `find`
+  --> $DIR/search_is_some_fixable_some.rs:162:29
+   |
+LL |         let _ = vfoo.iter().find(|v| v.inner[0].bar == 2).is_some();
+   |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `any()` instead: `any(|v| v.inner[0].bar == 2)`
+
+error: called `is_some()` after searching an `Iterator` with `find`
+  --> $DIR/search_is_some_fixable_some.rs:167:29
+   |
+LL |         let _ = vfoo.iter().find(|x| (**x)[0] == 9).is_some();
+   |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `any()` instead: `any(|x| (**x)[0] == 9)`
+
+error: aborting due to 33 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 90a72f506c55b2c2fc1f64b13c9c048a65846bba Mon Sep 17 00:00:00 2001
From: ThibsG <thibsg@pm.me>
Date: Fri, 1 Oct 2021 16:57:57 +0200
Subject: Handle args taken by ref also for `MethodCall`

---
 clippy_lints/src/methods/search_is_some.rs  | 43 +++++++++++++----------------
 tests/ui/search_is_some_fixable_none.fixed  | 13 +++++++++
 tests/ui/search_is_some_fixable_none.rs     | 13 +++++++++
 tests/ui/search_is_some_fixable_none.stderr |  8 +++++-
 tests/ui/search_is_some_fixable_some.fixed  | 13 +++++++++
 tests/ui/search_is_some_fixable_some.rs     | 13 +++++++++
 tests/ui/search_is_some_fixable_some.stderr |  8 +++++-
 7 files changed, 85 insertions(+), 26 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/search_is_some.rs b/clippy_lints/src/methods/search_is_some.rs
index 25a2c48e269..4f8517b946a 100644
--- a/clippy_lints/src/methods/search_is_some.rs
+++ b/clippy_lints/src/methods/search_is_some.rs
@@ -227,23 +227,23 @@ impl DerefDelegate<'_, 'tcx> {
     }
 
     fn func_takes_arg_by_ref(&self, parent_expr: &'tcx hir::Expr<'_>, cmt_hir_id: HirId) -> bool {
-        if_chain! {
-            if let ExprKind::Call(func, call_args) = parent_expr.kind;
-            let typ = self.cx.typeck_results().expr_ty(func);
-            if let ty::FnDef(..) = typ.kind();
-
-            then {
-                let mut takes_by_ref = false;
-                for (arg, ty) in iter::zip(call_args, typ.fn_sig(self.cx.tcx).skip_binder().inputs()) {
-                    if arg.hir_id == cmt_hir_id {
-                        takes_by_ref = matches!(ty.kind(), ty::Ref(_, inner, _) if inner.is_ref());
-                    }
+        let (call_args, inputs) = match parent_expr.kind {
+            ExprKind::MethodCall(_, _, call_args, _) => {
+                if let Some(method_did) = self.cx.typeck_results().type_dependent_def_id(parent_expr.hir_id) {
+                    (call_args, self.cx.tcx.fn_sig(method_did).skip_binder().inputs())
+                } else {
+                    return false;
                 }
-                takes_by_ref
-            } else {
-                false
-            }
-        }
+            },
+            ExprKind::Call(func, call_args) => {
+                let typ = self.cx.typeck_results().expr_ty(func);
+                (call_args, typ.fn_sig(self.cx.tcx).skip_binder().inputs())
+            },
+            _ => return false,
+        };
+
+        iter::zip(call_args, inputs)
+            .any(|(arg, ty)| arg.hir_id == cmt_hir_id && matches!(ty.kind(), ty::Ref(_, inner, _) if inner.is_ref()))
     }
 }
 
@@ -271,10 +271,6 @@ impl<'tcx> Delegate<'tcx> for DerefDelegate<'_, 'tcx> {
                         let arg_ty_kind = self.cx.typeck_results().expr_ty(expr).kind();
 
                         if matches!(arg_ty_kind, ty::Ref(_, _, Mutability::Not)) {
-                            let start_span = Span::new(self.next_pos, span.lo(), span.ctxt());
-                            let start_snip =
-                                snippet_with_applicability(self.cx, start_span, "..", &mut self.applicability);
-
                             // suggest ampersand if call function is taking args by ref
                             let takes_arg_by_ref = self.func_takes_arg_by_ref(parent_expr, cmt.hir_id);
 
@@ -294,14 +290,12 @@ impl<'tcx> Delegate<'tcx> for DerefDelegate<'_, 'tcx> {
                     }
                 }
 
-                // handle item projections by removing one explicit deref
-                // i.e.: suggest `*x` instead of `**x`
                 let mut replacement_str = ident_str;
-
                 let mut projections_handled = false;
                 cmt.place.projections.iter().enumerate().for_each(|(i, proj)| {
                     match proj.kind {
                         // Field projection like `|v| v.foo`
+                        // no adjustment needed here, as field projections are handled by the compiler
                         ProjectionKind::Field(idx, variant) => match cmt.place.ty_before_projection(i).kind() {
                             ty::Adt(def, ..) => {
                                 replacement_str = format!(
@@ -342,7 +336,8 @@ impl<'tcx> Delegate<'tcx> for DerefDelegate<'_, 'tcx> {
                     }
                 });
 
-                // handle `ProjectionKind::Deref` if no special case detected
+                // handle `ProjectionKind::Deref` by removing one explicit deref
+                // if no special case was detected (i.e.: suggest `*x` instead of `**x`)
                 if !projections_handled {
                     let last_deref = cmt
                         .place
diff --git a/tests/ui/search_is_some_fixable_none.fixed b/tests/ui/search_is_some_fixable_none.fixed
index 6b8a614bbda..0d1ed343c0c 100644
--- a/tests/ui/search_is_some_fixable_none.fixed
+++ b/tests/ui/search_is_some_fixable_none.fixed
@@ -161,4 +161,17 @@ mod issue7392 {
         let vfoo = vec![&&[0, 1, 2, 3]];
         let _ = !vfoo.iter().any(|x| (**x)[0] == 9);
     }
+
+    fn method_call_by_ref() {
+        struct Foo {
+            bar: u32,
+        }
+        impl Foo {
+            pub fn by_ref(&self, x: &u32) -> bool {
+                *x == self.bar
+            }
+        }
+        let vfoo = vec![Foo { bar: 1 }];
+        let _ = !vfoo.iter().any(|v| v.by_ref(&v.bar));
+    }
 }
diff --git a/tests/ui/search_is_some_fixable_none.rs b/tests/ui/search_is_some_fixable_none.rs
index acaae650921..2c638d929cb 100644
--- a/tests/ui/search_is_some_fixable_none.rs
+++ b/tests/ui/search_is_some_fixable_none.rs
@@ -167,4 +167,17 @@ mod issue7392 {
         let vfoo = vec![&&[0, 1, 2, 3]];
         let _ = vfoo.iter().find(|x| (**x)[0] == 9).is_none();
     }
+
+    fn method_call_by_ref() {
+        struct Foo {
+            bar: u32,
+        }
+        impl Foo {
+            pub fn by_ref(&self, x: &u32) -> bool {
+                *x == self.bar
+            }
+        }
+        let vfoo = vec![Foo { bar: 1 }];
+        let _ = vfoo.iter().find(|v| v.by_ref(&v.bar)).is_none();
+    }
 }
diff --git a/tests/ui/search_is_some_fixable_none.stderr b/tests/ui/search_is_some_fixable_none.stderr
index 64e81c6b94a..0c34067c139 100644
--- a/tests/ui/search_is_some_fixable_none.stderr
+++ b/tests/ui/search_is_some_fixable_none.stderr
@@ -221,5 +221,11 @@ error: called `is_none()` after searching an `Iterator` with `find`
 LL |         let _ = vfoo.iter().find(|x| (**x)[0] == 9).is_none();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.any()` instead: `!vfoo.iter().any(|x| (**x)[0] == 9)`
 
-error: aborting due to 33 previous errors
+error: called `is_none()` after searching an `Iterator` with `find`
+  --> $DIR/search_is_some_fixable_none.rs:181:17
+   |
+LL |         let _ = vfoo.iter().find(|v| v.by_ref(&v.bar)).is_none();
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.any()` instead: `!vfoo.iter().any(|v| v.by_ref(&v.bar))`
+
+error: aborting due to 34 previous errors
 
diff --git a/tests/ui/search_is_some_fixable_some.fixed b/tests/ui/search_is_some_fixable_some.fixed
index 7eb07d639a5..43471e35493 100644
--- a/tests/ui/search_is_some_fixable_some.fixed
+++ b/tests/ui/search_is_some_fixable_some.fixed
@@ -163,4 +163,17 @@ mod issue7392 {
         let vfoo = vec![&&[0, 1, 2, 3]];
         let _ = vfoo.iter().any(|x| (**x)[0] == 9);
     }
+
+    fn method_call_by_ref() {
+        struct Foo {
+            bar: u32,
+        }
+        impl Foo {
+            pub fn by_ref(&self, x: &u32) -> bool {
+                *x == self.bar
+            }
+        }
+        let vfoo = vec![Foo { bar: 1 }];
+        let _ = vfoo.iter().any(|v| v.by_ref(&v.bar));
+    }
 }
diff --git a/tests/ui/search_is_some_fixable_some.rs b/tests/ui/search_is_some_fixable_some.rs
index b9ebd399a35..82d3072d2f3 100644
--- a/tests/ui/search_is_some_fixable_some.rs
+++ b/tests/ui/search_is_some_fixable_some.rs
@@ -166,4 +166,17 @@ mod issue7392 {
         let vfoo = vec![&&[0, 1, 2, 3]];
         let _ = vfoo.iter().find(|x| (**x)[0] == 9).is_some();
     }
+
+    fn method_call_by_ref() {
+        struct Foo {
+            bar: u32,
+        }
+        impl Foo {
+            pub fn by_ref(&self, x: &u32) -> bool {
+                *x == self.bar
+            }
+        }
+        let vfoo = vec![Foo { bar: 1 }];
+        let _ = vfoo.iter().find(|v| v.by_ref(&v.bar)).is_some();
+    }
 }
diff --git a/tests/ui/search_is_some_fixable_some.stderr b/tests/ui/search_is_some_fixable_some.stderr
index b62cf9c4702..5e8885991ac 100644
--- a/tests/ui/search_is_some_fixable_some.stderr
+++ b/tests/ui/search_is_some_fixable_some.stderr
@@ -204,5 +204,11 @@ error: called `is_some()` after searching an `Iterator` with `find`
 LL |         let _ = vfoo.iter().find(|x| (**x)[0] == 9).is_some();
    |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `any()` instead: `any(|x| (**x)[0] == 9)`
 
-error: aborting due to 33 previous errors
+error: called `is_some()` after searching an `Iterator` with `find`
+  --> $DIR/search_is_some_fixable_some.rs:180:29
+   |
+LL |         let _ = vfoo.iter().find(|v| v.by_ref(&v.bar)).is_some();
+   |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `any()` instead: `any(|v| v.by_ref(&v.bar))`
+
+error: aborting due to 34 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From abaaf744fdbe8106bc82ceaa34e8499d5436fc3c Mon Sep 17 00:00:00 2001
From: ThibsG <thibsg@pm.me>
Date: Fri, 1 Oct 2021 17:29:37 +0200
Subject: Add some notes about `MethodCall` cases

---
 clippy_lints/src/methods/search_is_some.rs | 14 ++++++++++----
 1 file changed, 10 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/search_is_some.rs b/clippy_lints/src/methods/search_is_some.rs
index 4f8517b946a..d08abc5b3de 100644
--- a/clippy_lints/src/methods/search_is_some.rs
+++ b/clippy_lints/src/methods/search_is_some.rs
@@ -221,7 +221,7 @@ struct DerefDelegate<'a, 'tcx> {
 
 impl DerefDelegate<'_, 'tcx> {
     pub fn finish(&mut self) -> String {
-        let end_span = Span::new(self.next_pos, self.closure_span.hi(), self.closure_span.ctxt());
+        let end_span = Span::new(self.next_pos, self.closure_span.hi(), self.closure_span.ctxt(), None);
         let end_snip = snippet_with_applicability(self.cx, end_span, "..", &mut self.applicability);
         format!("{}{}", self.suggestion_start, end_snip)
     }
@@ -255,7 +255,7 @@ impl<'tcx> Delegate<'tcx> for DerefDelegate<'_, 'tcx> {
             let map = self.cx.tcx.hir();
             let ident_str = map.name(id).to_string();
             let span = map.span(cmt.hir_id);
-            let start_span = Span::new(self.next_pos, span.lo(), span.ctxt());
+            let start_span = Span::new(self.next_pos, span.lo(), span.ctxt(), None);
             let mut start_snip = snippet_with_applicability(self.cx, start_span, "..", &mut self.applicability);
 
             if cmt.place.projections.is_empty() {
@@ -263,8 +263,14 @@ impl<'tcx> Delegate<'tcx> for DerefDelegate<'_, 'tcx> {
                 // i.e.: suggest `&x` instead of `x`
                 self.suggestion_start.push_str(&format!("{}&{}", start_snip, ident_str));
             } else {
-                // cases where a parent call is using the item
+                // cases where a parent `Call` or `MethodCall` is using the item
                 // i.e.: suggest `.contains(&x)` for `.find(|x| [1, 2, 3].contains(x)).is_none()`
+                //
+                // Note about method calls:
+                // - compiler automatically dereference references if the target type is a reference (works also for
+                //   function call)
+                // - `self` arguments in the case of `x.is_something()` are also automatically (de)referenced, and
+                //   no projection should be suggested
                 if let Some(parent_expr) = get_parent_expr_for_hir(self.cx, cmt.hir_id) {
                     if let ExprKind::Call(_, call_args) | ExprKind::MethodCall(_, _, call_args, _) = parent_expr.kind {
                         let expr = self.cx.tcx.hir().expect_expr(cmt.hir_id);
@@ -316,7 +322,7 @@ impl<'tcx> Delegate<'tcx> for DerefDelegate<'_, 'tcx> {
                         // so the span is set-up again to get more code, using `span.hi()` (i.e.: `foo[x]`)
                         // instead of `span.lo()` (i.e.: `foo`)
                         ProjectionKind::Index => {
-                            let start_span = Span::new(self.next_pos, span.hi(), span.ctxt());
+                            let start_span = Span::new(self.next_pos, span.hi(), span.ctxt(), None);
                             start_snip = snippet_with_applicability(self.cx, start_span, "..", &mut self.applicability);
                             replacement_str.clear();
                             projections_handled = true;
-- 
cgit 1.4.1-3-g733a5


From 2ff702cbb547ea02381820536b27a575f14ba59e Mon Sep 17 00:00:00 2001
From: ThibsG <thibsg@pm.me>
Date: Wed, 20 Oct 2021 22:18:12 +0200
Subject: Rephrase the fn checking for a double ref, not only one

---
 clippy_lints/src/methods/search_is_some.rs | 20 +++++++++++---------
 1 file changed, 11 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/search_is_some.rs b/clippy_lints/src/methods/search_is_some.rs
index d08abc5b3de..96e040d9261 100644
--- a/clippy_lints/src/methods/search_is_some.rs
+++ b/clippy_lints/src/methods/search_is_some.rs
@@ -226,7 +226,7 @@ impl DerefDelegate<'_, 'tcx> {
         format!("{}{}", self.suggestion_start, end_snip)
     }
 
-    fn func_takes_arg_by_ref(&self, parent_expr: &'tcx hir::Expr<'_>, cmt_hir_id: HirId) -> bool {
+    fn func_takes_arg_by_double_ref(&self, parent_expr: &'tcx hir::Expr<'_>, cmt_hir_id: HirId) -> bool {
         let (call_args, inputs) = match parent_expr.kind {
             ExprKind::MethodCall(_, _, call_args, _) => {
                 if let Some(method_did) = self.cx.typeck_results().type_dependent_def_id(parent_expr.hir_id) {
@@ -277,16 +277,18 @@ impl<'tcx> Delegate<'tcx> for DerefDelegate<'_, 'tcx> {
                         let arg_ty_kind = self.cx.typeck_results().expr_ty(expr).kind();
 
                         if matches!(arg_ty_kind, ty::Ref(_, _, Mutability::Not)) {
-                            // suggest ampersand if call function is taking args by ref
-                            let takes_arg_by_ref = self.func_takes_arg_by_ref(parent_expr, cmt.hir_id);
+                            // suggest ampersand if call function is taking args by double reference
+                            let takes_arg_by_double_ref = self.func_takes_arg_by_double_ref(parent_expr, cmt.hir_id);
 
                             // do not suggest ampersand if the ident is the method caller
-                            let ident_sugg =
-                                if !call_args.is_empty() && call_args[0].hir_id == cmt.hir_id && !takes_arg_by_ref {
-                                    format!("{}{}", start_snip, ident_str)
-                                } else {
-                                    format!("{}&{}", start_snip, ident_str)
-                                };
+                            let ident_sugg = if !call_args.is_empty()
+                                && call_args[0].hir_id == cmt.hir_id
+                                && !takes_arg_by_double_ref
+                            {
+                                format!("{}{}", start_snip, ident_str)
+                            } else {
+                                format!("{}&{}", start_snip, ident_str)
+                            };
                             self.suggestion_start.push_str(&ident_sugg);
                             self.next_pos = span.hi();
                             return;
-- 
cgit 1.4.1-3-g733a5


From 1176b8e5e9e697978ad563924f1561b52b330c07 Mon Sep 17 00:00:00 2001
From: ThibsG <thibsg@pm.me>
Date: Mon, 1 Nov 2021 09:11:43 +0100
Subject: Handle closures with type annotations on args

---
 clippy_lints/src/methods/search_is_some.rs  | 144 +++++++++++++++-------------
 tests/ui/search_is_some_fixable_none.fixed  |   3 +
 tests/ui/search_is_some_fixable_none.rs     |   3 +
 tests/ui/search_is_some_fixable_none.stderr |  28 ++++--
 tests/ui/search_is_some_fixable_some.fixed  |   3 +
 tests/ui/search_is_some_fixable_some.rs     |   3 +
 tests/ui/search_is_some_fixable_some.stderr |  28 ++++--
 7 files changed, 132 insertions(+), 80 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/search_is_some.rs b/clippy_lints/src/methods/search_is_some.rs
index 96e040d9261..7baae4faa23 100644
--- a/clippy_lints/src/methods/search_is_some.rs
+++ b/clippy_lints/src/methods/search_is_some.rs
@@ -7,7 +7,7 @@ use clippy_utils::{get_parent_expr_for_hir, is_trait_method, strip_pat_refs};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
-use rustc_hir::{self, ExprKind, HirId, PatKind};
+use rustc_hir::{self, ExprKind, HirId, MutTy, PatKind, TyKind};
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::LateContext;
 use rustc_middle::hir::place::ProjectionKind;
@@ -52,26 +52,12 @@ pub(super) fn check<'tcx>(
                 then {
                     if let hir::PatKind::Ref(..) = closure_arg.pat.kind {
                         Some(search_snippet.replacen('&', "", 1))
-                    } else if let PatKind::Binding(_, binding_id, _, _) = strip_pat_refs(closure_arg.pat).kind {
-                        // this binding is composed of at least two levels of references, so we need to remove one
-                        let binding_type = cx.typeck_results().node_type(binding_id);
-                        let innermost_is_ref = if let ty::Ref(_, inner,_) = binding_type.kind() {
-                            matches!(inner.kind(), ty::Ref(_, innermost, _) if innermost.is_ref())
-                        } else {
-                            false
-                        };
-
+                    } else if let PatKind::Binding(..) = strip_pat_refs(closure_arg.pat).kind {
                         // `find()` provides a reference to the item, but `any` does not,
                         // so we should fix item usages for suggestion
-                        if let Some(closure_sugg) = get_closure_suggestion(cx, search_arg, closure_body) {
+                        if let Some(closure_sugg) = get_closure_suggestion(cx, search_arg) {
                             applicability = closure_sugg.applicability;
-                            if innermost_is_ref {
-                                Some(closure_sugg.suggestion.replacen('&', "", 1))
-                            } else {
-                                Some(closure_sugg.suggestion)
-                            }
-                        } else if innermost_is_ref {
-                            Some(search_snippet.replacen('&', "", 1))
+                            Some(closure_sugg.suggestion)
                         } else {
                             Some(search_snippet.to_string())
                         }
@@ -174,6 +160,7 @@ pub(super) fn check<'tcx>(
     }
 }
 
+#[derive(Debug)]
 struct ClosureSugg {
     applicability: Applicability,
     suggestion: String,
@@ -182,38 +169,45 @@ struct ClosureSugg {
 // Build suggestion gradually by handling closure arg specific usages,
 // such as explicit deref and borrowing cases.
 // Returns `None` if no such use cases have been triggered in closure body
-fn get_closure_suggestion<'tcx>(
-    cx: &LateContext<'_>,
-    search_arg: &'tcx hir::Expr<'_>,
-    closure_body: &hir::Body<'_>,
-) -> Option<ClosureSugg> {
-    let mut visitor = DerefDelegate {
-        cx,
-        closure_span: search_arg.span,
-        next_pos: search_arg.span.lo(),
-        suggestion_start: String::new(),
-        applicability: Applicability::MachineApplicable,
-    };
+fn get_closure_suggestion<'tcx>(cx: &LateContext<'_>, search_expr: &'tcx hir::Expr<'_>) -> Option<ClosureSugg> {
+    if let hir::ExprKind::Closure(_, fn_decl, body_id, ..) = search_expr.kind {
+        let closure_body = cx.tcx.hir().body(body_id);
+        // is closure arg a double reference (i.e.: `|x: &&i32| ...`)
+        let closure_arg_is_double_ref = if let TyKind::Rptr(_, MutTy { ty, .. }) = fn_decl.inputs[0].kind {
+            matches!(ty.kind, TyKind::Rptr(_, MutTy { .. }))
+        } else {
+            false
+        };
+
+        let mut visitor = DerefDelegate {
+            cx,
+            closure_span: search_expr.span,
+            closure_arg_is_double_ref,
+            next_pos: search_expr.span.lo(),
+            suggestion_start: String::new(),
+            applicability: Applicability::MachineApplicable,
+        };
 
-    let fn_def_id = cx.tcx.hir().local_def_id(search_arg.hir_id);
-    cx.tcx.infer_ctxt().enter(|infcx| {
-        ExprUseVisitor::new(&mut visitor, &infcx, fn_def_id, cx.param_env, cx.typeck_results())
-            .consume_body(closure_body);
-    });
+        let fn_def_id = cx.tcx.hir().local_def_id(search_expr.hir_id);
+        cx.tcx.infer_ctxt().enter(|infcx| {
+            ExprUseVisitor::new(&mut visitor, &infcx, fn_def_id, cx.param_env, cx.typeck_results())
+                .consume_body(closure_body);
+        });
 
-    if visitor.suggestion_start.is_empty() {
-        None
-    } else {
-        Some(ClosureSugg {
-            applicability: visitor.applicability,
-            suggestion: visitor.finish(),
-        })
+        if !visitor.suggestion_start.is_empty() {
+            return Some(ClosureSugg {
+                applicability: visitor.applicability,
+                suggestion: visitor.finish(),
+            });
+        }
     }
+    None
 }
 
 struct DerefDelegate<'a, 'tcx> {
     cx: &'a LateContext<'tcx>,
     closure_span: Span,
+    closure_arg_is_double_ref: bool,
     next_pos: BytePos,
     suggestion_start: String,
     applicability: Applicability,
@@ -223,7 +217,12 @@ impl DerefDelegate<'_, 'tcx> {
     pub fn finish(&mut self) -> String {
         let end_span = Span::new(self.next_pos, self.closure_span.hi(), self.closure_span.ctxt(), None);
         let end_snip = snippet_with_applicability(self.cx, end_span, "..", &mut self.applicability);
-        format!("{}{}", self.suggestion_start, end_snip)
+        let sugg = format!("{}{}", self.suggestion_start, end_snip);
+        if self.closure_arg_is_double_ref {
+            sugg.replacen('&', "", 1)
+        } else {
+            sugg
+        }
     }
 
     fn func_takes_arg_by_double_ref(&self, parent_expr: &'tcx hir::Expr<'_>, cmt_hir_id: HirId) -> bool {
@@ -261,6 +260,7 @@ impl<'tcx> Delegate<'tcx> for DerefDelegate<'_, 'tcx> {
             if cmt.place.projections.is_empty() {
                 // handle item without any projection, that needs an explicit borrowing
                 // i.e.: suggest `&x` instead of `x`
+                self.closure_arg_is_double_ref = false;
                 self.suggestion_start.push_str(&format!("{}&{}", start_snip, ident_str));
             } else {
                 // cases where a parent `Call` or `MethodCall` is using the item
@@ -272,29 +272,43 @@ impl<'tcx> Delegate<'tcx> for DerefDelegate<'_, 'tcx> {
                 // - `self` arguments in the case of `x.is_something()` are also automatically (de)referenced, and
                 //   no projection should be suggested
                 if let Some(parent_expr) = get_parent_expr_for_hir(self.cx, cmt.hir_id) {
-                    if let ExprKind::Call(_, call_args) | ExprKind::MethodCall(_, _, call_args, _) = parent_expr.kind {
-                        let expr = self.cx.tcx.hir().expect_expr(cmt.hir_id);
-                        let arg_ty_kind = self.cx.typeck_results().expr_ty(expr).kind();
-
-                        if matches!(arg_ty_kind, ty::Ref(_, _, Mutability::Not)) {
-                            // suggest ampersand if call function is taking args by double reference
-                            let takes_arg_by_double_ref = self.func_takes_arg_by_double_ref(parent_expr, cmt.hir_id);
-
-                            // do not suggest ampersand if the ident is the method caller
-                            let ident_sugg = if !call_args.is_empty()
-                                && call_args[0].hir_id == cmt.hir_id
-                                && !takes_arg_by_double_ref
-                            {
-                                format!("{}{}", start_snip, ident_str)
-                            } else {
-                                format!("{}&{}", start_snip, ident_str)
-                            };
-                            self.suggestion_start.push_str(&ident_sugg);
+                    match &parent_expr.kind {
+                        // given expression is the self argument and will be handled completely by the compiler
+                        // i.e.: `|x| x.is_something()`
+                        ExprKind::MethodCall(_, _, [self_expr, ..], _) if self_expr.hir_id == cmt.hir_id => {
+                            self.suggestion_start.push_str(&format!("{}{}", start_snip, ident_str));
                             self.next_pos = span.hi();
                             return;
-                        }
+                        },
+                        // item is used in a call
+                        // i.e.: `Call`: `|x| please(x)` or `MethodCall`: `|x| [1, 2, 3].contains(x)`
+                        ExprKind::Call(_, [call_args @ ..]) | ExprKind::MethodCall(_, _, [_, call_args @ ..], _) => {
+                            let expr = self.cx.tcx.hir().expect_expr(cmt.hir_id);
+                            let arg_ty_kind = self.cx.typeck_results().expr_ty(expr).kind();
 
-                        self.applicability = Applicability::Unspecified;
+                            if matches!(arg_ty_kind, ty::Ref(_, _, Mutability::Not)) {
+                                // suggest ampersand if call function is taking args by double reference
+                                let takes_arg_by_double_ref =
+                                    self.func_takes_arg_by_double_ref(parent_expr, cmt.hir_id);
+
+                                // no need to bind again if the function doesn't take arg by double ref
+                                // and if the item is already a double ref
+                                let ident_sugg = if !call_args.is_empty()
+                                    && !takes_arg_by_double_ref
+                                    && self.closure_arg_is_double_ref
+                                {
+                                    format!("{}{}", start_snip, ident_str)
+                                } else {
+                                    format!("{}&{}", start_snip, ident_str)
+                                };
+                                self.suggestion_start.push_str(&ident_sugg);
+                                self.next_pos = span.hi();
+                                return;
+                            }
+
+                            self.applicability = Applicability::Unspecified;
+                        },
+                        _ => (),
                     }
                 }
 
@@ -346,7 +360,9 @@ impl<'tcx> Delegate<'tcx> for DerefDelegate<'_, 'tcx> {
 
                 // handle `ProjectionKind::Deref` by removing one explicit deref
                 // if no special case was detected (i.e.: suggest `*x` instead of `**x`)
-                if !projections_handled {
+                if projections_handled {
+                    self.closure_arg_is_double_ref = false;
+                } else {
                     let last_deref = cmt
                         .place
                         .projections
diff --git a/tests/ui/search_is_some_fixable_none.fixed b/tests/ui/search_is_some_fixable_none.fixed
index 240a6957893..adc6b2739c4 100644
--- a/tests/ui/search_is_some_fixable_none.fixed
+++ b/tests/ui/search_is_some_fixable_none.fixed
@@ -118,9 +118,12 @@ mod issue7392 {
 
         let v = vec![3, 2, 1, 0];
         let _ = !v.iter().any(|x| deref_enough(*x));
+        let _ = !v.iter().any(|x: &u32| deref_enough(*x));
 
         #[allow(clippy::redundant_closure)]
         let _ = !v.iter().any(|x| arg_no_deref(&x));
+        #[allow(clippy::redundant_closure)]
+        let _ = !v.iter().any(|x: &u32| arg_no_deref(&x));
     }
 
     fn field_index_projection() {
diff --git a/tests/ui/search_is_some_fixable_none.rs b/tests/ui/search_is_some_fixable_none.rs
index 7e8fc14a7bd..f0be2be4788 100644
--- a/tests/ui/search_is_some_fixable_none.rs
+++ b/tests/ui/search_is_some_fixable_none.rs
@@ -122,9 +122,12 @@ mod issue7392 {
 
         let v = vec![3, 2, 1, 0];
         let _ = v.iter().find(|x| deref_enough(**x)).is_none();
+        let _ = v.iter().find(|x: &&u32| deref_enough(**x)).is_none();
 
         #[allow(clippy::redundant_closure)]
         let _ = v.iter().find(|x| arg_no_deref(x)).is_none();
+        #[allow(clippy::redundant_closure)]
+        let _ = v.iter().find(|x: &&u32| arg_no_deref(x)).is_none();
     }
 
     fn field_index_projection() {
diff --git a/tests/ui/search_is_some_fixable_none.stderr b/tests/ui/search_is_some_fixable_none.stderr
index c78830a3b5d..910d5ad37b8 100644
--- a/tests/ui/search_is_some_fixable_none.stderr
+++ b/tests/ui/search_is_some_fixable_none.stderr
@@ -188,13 +188,25 @@ LL |         let _ = v.iter().find(|x| deref_enough(**x)).is_none();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.any()` instead: `!v.iter().any(|x| deref_enough(*x))`
 
 error: called `is_none()` after searching an `Iterator` with `find`
-  --> $DIR/search_is_some_fixable_none.rs:127:17
+  --> $DIR/search_is_some_fixable_none.rs:125:17
+   |
+LL |         let _ = v.iter().find(|x: &&u32| deref_enough(**x)).is_none();
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.any()` instead: `!v.iter().any(|x: &u32| deref_enough(*x))`
+
+error: called `is_none()` after searching an `Iterator` with `find`
+  --> $DIR/search_is_some_fixable_none.rs:128:17
    |
 LL |         let _ = v.iter().find(|x| arg_no_deref(x)).is_none();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.any()` instead: `!v.iter().any(|x| arg_no_deref(&x))`
 
 error: called `is_none()` after searching an `Iterator` with `find`
-  --> $DIR/search_is_some_fixable_none.rs:147:17
+  --> $DIR/search_is_some_fixable_none.rs:130:17
+   |
+LL |         let _ = v.iter().find(|x: &&u32| arg_no_deref(x)).is_none();
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.any()` instead: `!v.iter().any(|x: &u32| arg_no_deref(&x))`
+
+error: called `is_none()` after searching an `Iterator` with `find`
+  --> $DIR/search_is_some_fixable_none.rs:150:17
    |
 LL |           let _ = vfoo
    |  _________________^
@@ -210,34 +222,34 @@ LL ~             .iter().any(|v| v.inner_double.bar[0][0] == 2 && v.inner.bar[0]
    |
 
 error: called `is_none()` after searching an `Iterator` with `find`
-  --> $DIR/search_is_some_fixable_none.rs:163:17
+  --> $DIR/search_is_some_fixable_none.rs:166:17
    |
 LL |         let _ = vfoo.iter().find(|v| v.inner[0].bar == 2).is_none();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.any()` instead: `!vfoo.iter().any(|v| v.inner[0].bar == 2)`
 
 error: called `is_none()` after searching an `Iterator` with `find`
-  --> $DIR/search_is_some_fixable_none.rs:168:17
+  --> $DIR/search_is_some_fixable_none.rs:171:17
    |
 LL |         let _ = vfoo.iter().find(|x| (**x)[0] == 9).is_none();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.any()` instead: `!vfoo.iter().any(|x| (**x)[0] == 9)`
 
 error: called `is_none()` after searching an `Iterator` with `find`
-  --> $DIR/search_is_some_fixable_none.rs:181:17
+  --> $DIR/search_is_some_fixable_none.rs:184:17
    |
 LL |         let _ = vfoo.iter().find(|v| v.by_ref(&v.bar)).is_none();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.any()` instead: `!vfoo.iter().any(|v| v.by_ref(&v.bar))`
 
 error: called `is_none()` after searching an `Iterator` with `find`
-  --> $DIR/search_is_some_fixable_none.rs:185:17
+  --> $DIR/search_is_some_fixable_none.rs:188:17
    |
 LL |         let _ = [&(&1, 2), &(&3, 4), &(&5, 4)].iter().find(|(&x, y)| x == *y).is_none();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.any()` instead: `![&(&1, 2), &(&3, 4), &(&5, 4)].iter().any(|(&x, y)| x == *y)`
 
 error: called `is_none()` after searching an `Iterator` with `find`
-  --> $DIR/search_is_some_fixable_none.rs:186:17
+  --> $DIR/search_is_some_fixable_none.rs:189:17
    |
 LL |         let _ = [&(&1, 2), &(&3, 4), &(&5, 4)].iter().find(|&(&x, y)| x == *y).is_none();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.any()` instead: `![&(&1, 2), &(&3, 4), &(&5, 4)].iter().any(|(&x, y)| x == *y)`
 
-error: aborting due to 36 previous errors
+error: aborting due to 38 previous errors
 
diff --git a/tests/ui/search_is_some_fixable_some.fixed b/tests/ui/search_is_some_fixable_some.fixed
index 267324cbe6a..2799ae0a98b 100644
--- a/tests/ui/search_is_some_fixable_some.fixed
+++ b/tests/ui/search_is_some_fixable_some.fixed
@@ -119,9 +119,12 @@ mod issue7392 {
 
         let v = vec![3, 2, 1, 0];
         let _ = v.iter().any(|x| deref_enough(*x));
+        let _ = v.iter().any(|x: &u32| deref_enough(*x));
 
         #[allow(clippy::redundant_closure)]
         let _ = v.iter().any(|x| arg_no_deref(&x));
+        #[allow(clippy::redundant_closure)]
+        let _ = v.iter().any(|x: &u32| arg_no_deref(&x));
     }
 
     fn field_index_projection() {
diff --git a/tests/ui/search_is_some_fixable_some.rs b/tests/ui/search_is_some_fixable_some.rs
index 53f80e2c87e..bf9d50d9057 100644
--- a/tests/ui/search_is_some_fixable_some.rs
+++ b/tests/ui/search_is_some_fixable_some.rs
@@ -121,9 +121,12 @@ mod issue7392 {
 
         let v = vec![3, 2, 1, 0];
         let _ = v.iter().find(|x| deref_enough(**x)).is_some();
+        let _ = v.iter().find(|x: &&u32| deref_enough(**x)).is_some();
 
         #[allow(clippy::redundant_closure)]
         let _ = v.iter().find(|x| arg_no_deref(x)).is_some();
+        #[allow(clippy::redundant_closure)]
+        let _ = v.iter().find(|x: &&u32| arg_no_deref(x)).is_some();
     }
 
     fn field_index_projection() {
diff --git a/tests/ui/search_is_some_fixable_some.stderr b/tests/ui/search_is_some_fixable_some.stderr
index e8784bba6eb..71680bc8d2a 100644
--- a/tests/ui/search_is_some_fixable_some.stderr
+++ b/tests/ui/search_is_some_fixable_some.stderr
@@ -179,13 +179,25 @@ LL |         let _ = v.iter().find(|x| deref_enough(**x)).is_some();
    |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `any()` instead: `any(|x| deref_enough(*x))`
 
 error: called `is_some()` after searching an `Iterator` with `find`
-  --> $DIR/search_is_some_fixable_some.rs:126:26
+  --> $DIR/search_is_some_fixable_some.rs:124:26
+   |
+LL |         let _ = v.iter().find(|x: &&u32| deref_enough(**x)).is_some();
+   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `any()` instead: `any(|x: &u32| deref_enough(*x))`
+
+error: called `is_some()` after searching an `Iterator` with `find`
+  --> $DIR/search_is_some_fixable_some.rs:127:26
    |
 LL |         let _ = v.iter().find(|x| arg_no_deref(x)).is_some();
    |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `any()` instead: `any(|x| arg_no_deref(&x))`
 
 error: called `is_some()` after searching an `Iterator` with `find`
-  --> $DIR/search_is_some_fixable_some.rs:148:14
+  --> $DIR/search_is_some_fixable_some.rs:129:26
+   |
+LL |         let _ = v.iter().find(|x: &&u32| arg_no_deref(x)).is_some();
+   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `any()` instead: `any(|x: &u32| arg_no_deref(&x))`
+
+error: called `is_some()` after searching an `Iterator` with `find`
+  --> $DIR/search_is_some_fixable_some.rs:151:14
    |
 LL |               .find(|v| v.inner_double.bar[0][0] == 2 && v.inner.bar[0] == 2)
    |  ______________^
@@ -193,34 +205,34 @@ LL | |             .is_some();
    | |______________________^ help: use `any()` instead: `any(|v| v.inner_double.bar[0][0] == 2 && v.inner.bar[0] == 2)`
 
 error: called `is_some()` after searching an `Iterator` with `find`
-  --> $DIR/search_is_some_fixable_some.rs:162:29
+  --> $DIR/search_is_some_fixable_some.rs:165:29
    |
 LL |         let _ = vfoo.iter().find(|v| v.inner[0].bar == 2).is_some();
    |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `any()` instead: `any(|v| v.inner[0].bar == 2)`
 
 error: called `is_some()` after searching an `Iterator` with `find`
-  --> $DIR/search_is_some_fixable_some.rs:167:29
+  --> $DIR/search_is_some_fixable_some.rs:170:29
    |
 LL |         let _ = vfoo.iter().find(|x| (**x)[0] == 9).is_some();
    |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `any()` instead: `any(|x| (**x)[0] == 9)`
 
 error: called `is_some()` after searching an `Iterator` with `find`
-  --> $DIR/search_is_some_fixable_some.rs:180:29
+  --> $DIR/search_is_some_fixable_some.rs:183:29
    |
 LL |         let _ = vfoo.iter().find(|v| v.by_ref(&v.bar)).is_some();
    |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `any()` instead: `any(|v| v.by_ref(&v.bar))`
 
 error: called `is_some()` after searching an `Iterator` with `find`
-  --> $DIR/search_is_some_fixable_some.rs:184:55
+  --> $DIR/search_is_some_fixable_some.rs:187:55
    |
 LL |         let _ = [&(&1, 2), &(&3, 4), &(&5, 4)].iter().find(|(&x, y)| x == *y).is_some();
    |                                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `any()` instead: `any(|(&x, y)| x == *y)`
 
 error: called `is_some()` after searching an `Iterator` with `find`
-  --> $DIR/search_is_some_fixable_some.rs:185:55
+  --> $DIR/search_is_some_fixable_some.rs:188:55
    |
 LL |         let _ = [&(&1, 2), &(&3, 4), &(&5, 4)].iter().find(|&(&x, y)| x == *y).is_some();
    |                                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `any()` instead: `any(|(&x, y)| x == *y)`
 
-error: aborting due to 36 previous errors
+error: aborting due to 38 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 5ebede0c14d00f50a2db3d5a8e944563e40244c7 Mon Sep 17 00:00:00 2001
From: ThibsG <thibsg@pm.me>
Date: Sat, 20 Nov 2021 09:37:37 +0100
Subject: Fix full projection identifier + move applicability to
 `MaybeIncorrect`

---
 clippy_lints/src/methods/search_is_some.rs  | 42 ++++++++++++++++++-----------
 tests/ui/search_is_some_fixable_none.fixed  | 31 +++++++++++++++++++++
 tests/ui/search_is_some_fixable_none.rs     | 31 +++++++++++++++++++++
 tests/ui/search_is_some_fixable_none.stderr | 40 ++++++++++++++++++++++++++-
 tests/ui/search_is_some_fixable_some.fixed  | 31 +++++++++++++++++++++
 tests/ui/search_is_some_fixable_some.rs     | 31 +++++++++++++++++++++
 tests/ui/search_is_some_fixable_some.stderr | 40 ++++++++++++++++++++++++++-
 7 files changed, 228 insertions(+), 18 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/search_is_some.rs b/clippy_lints/src/methods/search_is_some.rs
index 7baae4faa23..a3449c1fe12 100644
--- a/clippy_lints/src/methods/search_is_some.rs
+++ b/clippy_lints/src/methods/search_is_some.rs
@@ -185,7 +185,7 @@ fn get_closure_suggestion<'tcx>(cx: &LateContext<'_>, search_expr: &'tcx hir::Ex
             closure_arg_is_double_ref,
             next_pos: search_expr.span.lo(),
             suggestion_start: String::new(),
-            applicability: Applicability::MachineApplicable,
+            applicability: Applicability::MaybeIncorrect,
         };
 
         let fn_def_id = cx.tcx.hir().local_def_id(search_expr.hir_id);
@@ -252,11 +252,15 @@ impl<'tcx> Delegate<'tcx> for DerefDelegate<'_, 'tcx> {
     fn borrow(&mut self, cmt: &PlaceWithHirId<'tcx>, _: HirId, _: ty::BorrowKind) {
         if let PlaceBase::Local(id) = cmt.place.base {
             let map = self.cx.tcx.hir();
-            let ident_str = map.name(id).to_string();
             let span = map.span(cmt.hir_id);
             let start_span = Span::new(self.next_pos, span.lo(), span.ctxt(), None);
             let mut start_snip = snippet_with_applicability(self.cx, start_span, "..", &mut self.applicability);
 
+            // identifier referring to the variable currently triggered (i.e.: `fp`)
+            let ident_str = map.name(id).to_string();
+            // full identifier that includes projection (i.e.: `fp.field`)
+            let ident_str_with_proj = snippet(self.cx, span, "..").to_string();
+
             if cmt.place.projections.is_empty() {
                 // handle item without any projection, that needs an explicit borrowing
                 // i.e.: suggest `&x` instead of `x`
@@ -276,7 +280,8 @@ impl<'tcx> Delegate<'tcx> for DerefDelegate<'_, 'tcx> {
                         // given expression is the self argument and will be handled completely by the compiler
                         // i.e.: `|x| x.is_something()`
                         ExprKind::MethodCall(_, _, [self_expr, ..], _) if self_expr.hir_id == cmt.hir_id => {
-                            self.suggestion_start.push_str(&format!("{}{}", start_snip, ident_str));
+                            self.suggestion_start
+                                .push_str(&format!("{}{}", start_snip, ident_str_with_proj));
                             self.next_pos = span.hi();
                             return;
                         },
@@ -291,13 +296,26 @@ impl<'tcx> Delegate<'tcx> for DerefDelegate<'_, 'tcx> {
                                 let takes_arg_by_double_ref =
                                     self.func_takes_arg_by_double_ref(parent_expr, cmt.hir_id);
 
+                                // compiler will automatically dereference field projection, so no need
+                                // to suggest ampersand, but full identifier that includes projection is required
+                                let has_field_projection = cmt
+                                    .place
+                                    .projections
+                                    .iter()
+                                    .any(|proj| matches!(proj.kind, ProjectionKind::Field(..)));
+
                                 // no need to bind again if the function doesn't take arg by double ref
                                 // and if the item is already a double ref
                                 let ident_sugg = if !call_args.is_empty()
                                     && !takes_arg_by_double_ref
-                                    && self.closure_arg_is_double_ref
+                                    && (self.closure_arg_is_double_ref || has_field_projection)
                                 {
-                                    format!("{}{}", start_snip, ident_str)
+                                    let ident = if has_field_projection {
+                                        ident_str_with_proj
+                                    } else {
+                                        ident_str
+                                    };
+                                    format!("{}{}", start_snip, ident)
                                 } else {
                                     format!("{}&{}", start_snip, ident_str)
                                 };
@@ -318,17 +336,9 @@ impl<'tcx> Delegate<'tcx> for DerefDelegate<'_, 'tcx> {
                     match proj.kind {
                         // Field projection like `|v| v.foo`
                         // no adjustment needed here, as field projections are handled by the compiler
-                        ProjectionKind::Field(idx, variant) => match cmt.place.ty_before_projection(i).kind() {
-                            ty::Adt(def, ..) => {
-                                replacement_str = format!(
-                                    "{}.{}",
-                                    replacement_str,
-                                    def.variants[variant].fields[idx as usize].ident.name.as_str()
-                                );
-                                projections_handled = true;
-                            },
-                            ty::Tuple(_) => {
-                                replacement_str = format!("{}.{}", replacement_str, idx);
+                        ProjectionKind::Field(..) => match cmt.place.ty_before_projection(i).kind() {
+                            ty::Adt(..) | ty::Tuple(_) => {
+                                replacement_str = ident_str_with_proj.clone();
                                 projections_handled = true;
                             },
                             _ => (),
diff --git a/tests/ui/search_is_some_fixable_none.fixed b/tests/ui/search_is_some_fixable_none.fixed
index adc6b2739c4..6831fb2cf59 100644
--- a/tests/ui/search_is_some_fixable_none.fixed
+++ b/tests/ui/search_is_some_fixable_none.fixed
@@ -182,4 +182,35 @@ mod issue7392 {
         let _ = ![&(&1, 2), &(&3, 4), &(&5, 4)].iter().any(|(&x, y)| x == *y);
         let _ = ![&(&1, 2), &(&3, 4), &(&5, 4)].iter().any(|(&x, y)| x == *y);
     }
+
+    fn test_string_1(s: &str) -> bool {
+        s.is_empty()
+    }
+
+    fn test_u32_1(s: &u32) -> bool {
+        s.is_power_of_two()
+    }
+
+    fn test_u32_2(s: u32) -> bool {
+        s.is_power_of_two()
+    }
+
+    fn projection_in_args_test() {
+        // Index projections
+        let lst = &[String::from("Hello"), String::from("world")];
+        let v: Vec<&[String]> = vec![lst];
+        let _ = !v.iter().any(|s| s[0].is_empty());
+        let _ = !v.iter().any(|s| test_string_1(&s[0]));
+
+        // Field projections
+        struct FieldProjection<'a> {
+            field: &'a u32,
+        }
+        let field = 123456789;
+        let instance = FieldProjection { field: &field };
+        let v = vec![instance];
+        let _ = !v.iter().any(|fp| fp.field.is_power_of_two());
+        let _ = !v.iter().any(|fp| test_u32_1(fp.field));
+        let _ = !v.iter().any(|fp| test_u32_2(*fp.field));
+    }
 }
diff --git a/tests/ui/search_is_some_fixable_none.rs b/tests/ui/search_is_some_fixable_none.rs
index f0be2be4788..778f4f6fa25 100644
--- a/tests/ui/search_is_some_fixable_none.rs
+++ b/tests/ui/search_is_some_fixable_none.rs
@@ -188,4 +188,35 @@ mod issue7392 {
         let _ = [&(&1, 2), &(&3, 4), &(&5, 4)].iter().find(|(&x, y)| x == *y).is_none();
         let _ = [&(&1, 2), &(&3, 4), &(&5, 4)].iter().find(|&(&x, y)| x == *y).is_none();
     }
+
+    fn test_string_1(s: &String) -> bool {
+        s.is_empty()
+    }
+
+    fn test_u32_1(s: &u32) -> bool {
+        s.is_power_of_two()
+    }
+
+    fn test_u32_2(s: u32) -> bool {
+        s.is_power_of_two()
+    }
+
+    fn projection_in_args_test() {
+        // Index projections
+        let lst = &[String::from("Hello"), String::from("world")];
+        let v: Vec<&[String]> = vec![lst];
+        let _ = v.iter().find(|s| s[0].is_empty()).is_none();
+        let _ = v.iter().find(|s| test_string_1(&s[0])).is_none();
+
+        // Field projections
+        struct FieldProjection<'a> {
+            field: &'a u32,
+        }
+        let field = 123456789;
+        let instance = FieldProjection { field: &field };
+        let v = vec![instance];
+        let _ = v.iter().find(|fp| fp.field.is_power_of_two()).is_none();
+        let _ = v.iter().find(|fp| test_u32_1(fp.field)).is_none();
+        let _ = v.iter().find(|fp| test_u32_2(*fp.field)).is_none();
+    }
 }
diff --git a/tests/ui/search_is_some_fixable_none.stderr b/tests/ui/search_is_some_fixable_none.stderr
index 910d5ad37b8..7c5e5eb589c 100644
--- a/tests/ui/search_is_some_fixable_none.stderr
+++ b/tests/ui/search_is_some_fixable_none.stderr
@@ -251,5 +251,43 @@ error: called `is_none()` after searching an `Iterator` with `find`
 LL |         let _ = [&(&1, 2), &(&3, 4), &(&5, 4)].iter().find(|&(&x, y)| x == *y).is_none();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.any()` instead: `![&(&1, 2), &(&3, 4), &(&5, 4)].iter().any(|(&x, y)| x == *y)`
 
-error: aborting due to 38 previous errors
+error: writing `&String` instead of `&str` involves a new object where a slice will do
+  --> $DIR/search_is_some_fixable_none.rs:192:25
+   |
+LL |     fn test_string_1(s: &String) -> bool {
+   |                         ^^^^^^^ help: change this to: `&str`
+   |
+   = note: `-D clippy::ptr-arg` implied by `-D warnings`
+
+error: called `is_none()` after searching an `Iterator` with `find`
+  --> $DIR/search_is_some_fixable_none.rs:208:17
+   |
+LL |         let _ = v.iter().find(|s| s[0].is_empty()).is_none();
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.any()` instead: `!v.iter().any(|s| s[0].is_empty())`
+
+error: called `is_none()` after searching an `Iterator` with `find`
+  --> $DIR/search_is_some_fixable_none.rs:209:17
+   |
+LL |         let _ = v.iter().find(|s| test_string_1(&s[0])).is_none();
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.any()` instead: `!v.iter().any(|s| test_string_1(&s[0]))`
+
+error: called `is_none()` after searching an `Iterator` with `find`
+  --> $DIR/search_is_some_fixable_none.rs:218:17
+   |
+LL |         let _ = v.iter().find(|fp| fp.field.is_power_of_two()).is_none();
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.any()` instead: `!v.iter().any(|fp| fp.field.is_power_of_two())`
+
+error: called `is_none()` after searching an `Iterator` with `find`
+  --> $DIR/search_is_some_fixable_none.rs:219:17
+   |
+LL |         let _ = v.iter().find(|fp| test_u32_1(fp.field)).is_none();
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.any()` instead: `!v.iter().any(|fp| test_u32_1(fp.field))`
+
+error: called `is_none()` after searching an `Iterator` with `find`
+  --> $DIR/search_is_some_fixable_none.rs:220:17
+   |
+LL |         let _ = v.iter().find(|fp| test_u32_2(*fp.field)).is_none();
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.any()` instead: `!v.iter().any(|fp| test_u32_2(*fp.field))`
+
+error: aborting due to 44 previous errors
 
diff --git a/tests/ui/search_is_some_fixable_some.fixed b/tests/ui/search_is_some_fixable_some.fixed
index 2799ae0a98b..7c940a2b069 100644
--- a/tests/ui/search_is_some_fixable_some.fixed
+++ b/tests/ui/search_is_some_fixable_some.fixed
@@ -184,4 +184,35 @@ mod issue7392 {
         let _ = [&(&1, 2), &(&3, 4), &(&5, 4)].iter().any(|(&x, y)| x == *y);
         let _ = [&(&1, 2), &(&3, 4), &(&5, 4)].iter().any(|(&x, y)| x == *y);
     }
+
+    fn test_string_1(s: &str) -> bool {
+        s.is_empty()
+    }
+
+    fn test_u32_1(s: &u32) -> bool {
+        s.is_power_of_two()
+    }
+
+    fn test_u32_2(s: u32) -> bool {
+        s.is_power_of_two()
+    }
+
+    fn projection_in_args_test() {
+        // Index projections
+        let lst = &[String::from("Hello"), String::from("world")];
+        let v: Vec<&[String]> = vec![lst];
+        let _ = v.iter().any(|s| s[0].is_empty());
+        let _ = v.iter().any(|s| test_string_1(&s[0]));
+
+        // Field projections
+        struct FieldProjection<'a> {
+            field: &'a u32,
+        }
+        let field = 123456789;
+        let instance = FieldProjection { field: &field };
+        let v = vec![instance];
+        let _ = v.iter().any(|fp| fp.field.is_power_of_two());
+        let _ = v.iter().any(|fp| test_u32_1(fp.field));
+        let _ = v.iter().any(|fp| test_u32_2(*fp.field));
+    }
 }
diff --git a/tests/ui/search_is_some_fixable_some.rs b/tests/ui/search_is_some_fixable_some.rs
index bf9d50d9057..241641fceae 100644
--- a/tests/ui/search_is_some_fixable_some.rs
+++ b/tests/ui/search_is_some_fixable_some.rs
@@ -187,4 +187,35 @@ mod issue7392 {
         let _ = [&(&1, 2), &(&3, 4), &(&5, 4)].iter().find(|(&x, y)| x == *y).is_some();
         let _ = [&(&1, 2), &(&3, 4), &(&5, 4)].iter().find(|&(&x, y)| x == *y).is_some();
     }
+
+    fn test_string_1(s: &String) -> bool {
+        s.is_empty()
+    }
+
+    fn test_u32_1(s: &u32) -> bool {
+        s.is_power_of_two()
+    }
+
+    fn test_u32_2(s: u32) -> bool {
+        s.is_power_of_two()
+    }
+
+    fn projection_in_args_test() {
+        // Index projections
+        let lst = &[String::from("Hello"), String::from("world")];
+        let v: Vec<&[String]> = vec![lst];
+        let _ = v.iter().find(|s| s[0].is_empty()).is_some();
+        let _ = v.iter().find(|s| test_string_1(&s[0])).is_some();
+
+        // Field projections
+        struct FieldProjection<'a> {
+            field: &'a u32,
+        }
+        let field = 123456789;
+        let instance = FieldProjection { field: &field };
+        let v = vec![instance];
+        let _ = v.iter().find(|fp| fp.field.is_power_of_two()).is_some();
+        let _ = v.iter().find(|fp| test_u32_1(fp.field)).is_some();
+        let _ = v.iter().find(|fp| test_u32_2(*fp.field)).is_some();
+    }
 }
diff --git a/tests/ui/search_is_some_fixable_some.stderr b/tests/ui/search_is_some_fixable_some.stderr
index 71680bc8d2a..9212c6e71ff 100644
--- a/tests/ui/search_is_some_fixable_some.stderr
+++ b/tests/ui/search_is_some_fixable_some.stderr
@@ -234,5 +234,43 @@ error: called `is_some()` after searching an `Iterator` with `find`
 LL |         let _ = [&(&1, 2), &(&3, 4), &(&5, 4)].iter().find(|&(&x, y)| x == *y).is_some();
    |                                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `any()` instead: `any(|(&x, y)| x == *y)`
 
-error: aborting due to 38 previous errors
+error: writing `&String` instead of `&str` involves a new object where a slice will do
+  --> $DIR/search_is_some_fixable_some.rs:191:25
+   |
+LL |     fn test_string_1(s: &String) -> bool {
+   |                         ^^^^^^^ help: change this to: `&str`
+   |
+   = note: `-D clippy::ptr-arg` implied by `-D warnings`
+
+error: called `is_some()` after searching an `Iterator` with `find`
+  --> $DIR/search_is_some_fixable_some.rs:207:26
+   |
+LL |         let _ = v.iter().find(|s| s[0].is_empty()).is_some();
+   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `any()` instead: `any(|s| s[0].is_empty())`
+
+error: called `is_some()` after searching an `Iterator` with `find`
+  --> $DIR/search_is_some_fixable_some.rs:208:26
+   |
+LL |         let _ = v.iter().find(|s| test_string_1(&s[0])).is_some();
+   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `any()` instead: `any(|s| test_string_1(&s[0]))`
+
+error: called `is_some()` after searching an `Iterator` with `find`
+  --> $DIR/search_is_some_fixable_some.rs:217:26
+   |
+LL |         let _ = v.iter().find(|fp| fp.field.is_power_of_two()).is_some();
+   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `any()` instead: `any(|fp| fp.field.is_power_of_two())`
+
+error: called `is_some()` after searching an `Iterator` with `find`
+  --> $DIR/search_is_some_fixable_some.rs:218:26
+   |
+LL |         let _ = v.iter().find(|fp| test_u32_1(fp.field)).is_some();
+   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `any()` instead: `any(|fp| test_u32_1(fp.field))`
+
+error: called `is_some()` after searching an `Iterator` with `find`
+  --> $DIR/search_is_some_fixable_some.rs:219:26
+   |
+LL |         let _ = v.iter().find(|fp| test_u32_2(*fp.field)).is_some();
+   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `any()` instead: `any(|fp| test_u32_2(*fp.field))`
+
+error: aborting due to 44 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 982124acfafce0c14ace9cf48ab946b4a5901dd3 Mon Sep 17 00:00:00 2001
From: Georg Brandl <georg@python.org>
Date: Sat, 20 Nov 2021 11:23:49 +0100
Subject: Add new lint `octal_escapes`

This checks for sequences in strings that would be octal character
escapes in C, but are not supported in Rust.  It suggests either
to use the `\x00` escape, or an equivalent hex escape if the octal
was intended.
---
 CHANGELOG.md                                |   1 +
 clippy_lints/src/lib.register_all.rs        |   1 +
 clippy_lints/src/lib.register_lints.rs      |   1 +
 clippy_lints/src/lib.register_suspicious.rs |   1 +
 clippy_lints/src/lib.rs                     |   2 +
 clippy_lints/src/octal_escapes.rs           | 131 ++++++++++++++++++++++++++++
 tests/ui/octal_escapes.rs                   |  12 +++
 tests/ui/octal_escapes.stderr               |  67 ++++++++++++++
 8 files changed, 216 insertions(+)
 create mode 100644 clippy_lints/src/octal_escapes.rs
 create mode 100644 tests/ui/octal_escapes.rs
 create mode 100644 tests/ui/octal_escapes.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index dadf01419f7..401557b3eac 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3056,6 +3056,7 @@ Released 2018-09-13
 [`nonsensical_open_options`]: https://rust-lang.github.io/rust-clippy/master/index.html#nonsensical_open_options
 [`nonstandard_macro_braces`]: https://rust-lang.github.io/rust-clippy/master/index.html#nonstandard_macro_braces
 [`not_unsafe_ptr_arg_deref`]: https://rust-lang.github.io/rust-clippy/master/index.html#not_unsafe_ptr_arg_deref
+[`octal_escapes`]: https://rust-lang.github.io/rust-clippy/master/index.html#octal_escapes
 [`ok_expect`]: https://rust-lang.github.io/rust-clippy/master/index.html#ok_expect
 [`op_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#op_ref
 [`option_as_ref_deref`]: https://rust-lang.github.io/rust-clippy/master/index.html#option_as_ref_deref
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 5ed2729b99b..612240135ac 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -219,6 +219,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(non_expressive_names::JUST_UNDERSCORES_AND_DIGITS),
     LintId::of(non_octal_unix_permissions::NON_OCTAL_UNIX_PERMISSIONS),
     LintId::of(non_send_fields_in_send_ty::NON_SEND_FIELDS_IN_SEND_TY),
+    LintId::of(octal_escapes::OCTAL_ESCAPES),
     LintId::of(open_options::NONSENSICAL_OPEN_OPTIONS),
     LintId::of(option_env_unwrap::OPTION_ENV_UNWRAP),
     LintId::of(overflow_check_conditional::OVERFLOW_CHECK_CONDITIONAL),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 000c7226685..19c35a5e5f4 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -380,6 +380,7 @@ store.register_lints(&[
     non_octal_unix_permissions::NON_OCTAL_UNIX_PERMISSIONS,
     non_send_fields_in_send_ty::NON_SEND_FIELDS_IN_SEND_TY,
     nonstandard_macro_braces::NONSTANDARD_MACRO_BRACES,
+    octal_escapes::OCTAL_ESCAPES,
     open_options::NONSENSICAL_OPEN_OPTIONS,
     option_env_unwrap::OPTION_ENV_UNWRAP,
     option_if_let_else::OPTION_IF_LET_ELSE,
diff --git a/clippy_lints/src/lib.register_suspicious.rs b/clippy_lints/src/lib.register_suspicious.rs
index a3f964d1580..414bfc42fdf 100644
--- a/clippy_lints/src/lib.register_suspicious.rs
+++ b/clippy_lints/src/lib.register_suspicious.rs
@@ -16,6 +16,7 @@ store.register_group(true, "clippy::suspicious", Some("clippy_suspicious"), vec!
     LintId::of(methods::SUSPICIOUS_MAP),
     LintId::of(mut_key::MUTABLE_KEY_TYPE),
     LintId::of(non_send_fields_in_send_ty::NON_SEND_FIELDS_IN_SEND_TY),
+    LintId::of(octal_escapes::OCTAL_ESCAPES),
     LintId::of(suspicious_trait_impl::SUSPICIOUS_ARITHMETIC_IMPL),
     LintId::of(suspicious_trait_impl::SUSPICIOUS_OP_ASSIGN_IMPL),
 ])
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 449fa8a6311..3dafdf8f0d5 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -312,6 +312,7 @@ mod non_expressive_names;
 mod non_octal_unix_permissions;
 mod non_send_fields_in_send_ty;
 mod nonstandard_macro_braces;
+mod octal_escapes;
 mod open_options;
 mod option_env_unwrap;
 mod option_if_let_else;
@@ -849,6 +850,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(match_str_case_mismatch::MatchStrCaseMismatch));
     store.register_late_pass(move || Box::new(format_args::FormatArgs));
     store.register_late_pass(|| Box::new(trailing_empty_array::TrailingEmptyArray));
+    store.register_early_pass(|| Box::new(octal_escapes::OctalEscapes));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/octal_escapes.rs b/clippy_lints/src/octal_escapes.rs
new file mode 100644
index 00000000000..9ae269bc7d9
--- /dev/null
+++ b/clippy_lints/src/octal_escapes.rs
@@ -0,0 +1,131 @@
+use clippy_utils::diagnostics::span_lint_and_then;
+use rustc_ast::ast::{Expr, ExprKind};
+use rustc_ast::token::{Lit, LitKind};
+use rustc_errors::Applicability;
+use rustc_lint::{EarlyContext, EarlyLintPass};
+use rustc_middle::lint::in_external_macro;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::Span;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `\0` escapes in string and byte literals that look like octal character
+    /// escapes in C
+    ///
+    /// ### Why is this bad?
+    /// Rust does not support octal notation for character escapes. `\0` is always a
+    /// null byte/character, and any following digits do not form part of the escape
+    /// sequence.
+    ///
+    /// ### Known problems
+    /// The actual meaning can be the intended one. `\x00` can be used in these
+    /// cases to be unambigious.
+    ///
+    /// # Example
+    /// ```rust
+    /// // Bad
+    /// let one = "\033[1m Bold? \033[0m";  // \033 intended as escape
+    /// let two = "\033\0";                 // \033 intended as null-3-3
+    ///
+    /// // Good
+    /// let one = "\x1b[1mWill this be bold?\x1b[0m";
+    /// let two = "\x0033\x00";
+    /// ```
+    #[clippy::version = "1.58.0"]
+    pub OCTAL_ESCAPES,
+    suspicious,
+    "string escape sequences looking like octal characters"
+}
+
+declare_lint_pass!(OctalEscapes => [OCTAL_ESCAPES]);
+
+impl EarlyLintPass for OctalEscapes {
+    fn check_expr(&mut self, cx: &EarlyContext<'tcx>, expr: &Expr) {
+        if in_external_macro(cx.sess, expr.span) {
+            return;
+        }
+
+        if let ExprKind::Lit(lit) = &expr.kind {
+            if matches!(lit.token.kind, LitKind::Str) {
+                check_lit(cx, &lit.token, lit.span, true);
+            } else if matches!(lit.token.kind, LitKind::ByteStr) {
+                check_lit(cx, &lit.token, lit.span, false);
+            }
+        }
+    }
+}
+
+fn check_lit(cx: &EarlyContext<'tcx>, lit: &Lit, span: Span, is_string: bool) {
+    let contents = lit.symbol.as_str();
+    let mut iter = contents.char_indices();
+
+    // go through the string, looking for \0[0-7]
+    while let Some((from, ch)) = iter.next() {
+        if ch == '\\' {
+            if let Some((mut to, '0')) = iter.next() {
+                // collect all further potentially octal digits
+                while let Some((j, '0'..='7')) = iter.next() {
+                    to = j + 1;
+                }
+                // if it's more than just `\0` we have a match
+                if to > from + 2 {
+                    emit(cx, &contents, from, to, span, is_string);
+                    return;
+                }
+            }
+        }
+    }
+}
+
+fn emit(cx: &EarlyContext<'tcx>, contents: &str, from: usize, to: usize, span: Span, is_string: bool) {
+    // construct a replacement escape for that case that octal was intended
+    let escape = &contents[from + 1..to];
+    let literal_suggestion = if is_string {
+        u32::from_str_radix(escape, 8).ok().and_then(|n| {
+            if n < 256 {
+                Some(format!("\\x{:02x}", n))
+            } else if n <= std::char::MAX as u32 {
+                Some(format!("\\u{{{:x}}}", n))
+            } else {
+                None
+            }
+        })
+    } else {
+        u8::from_str_radix(escape, 8).ok().map(|n| format!("\\x{:02x}", n))
+    };
+
+    span_lint_and_then(
+        cx,
+        OCTAL_ESCAPES,
+        span,
+        &format!(
+            "octal-looking escape in {} literal",
+            if is_string { "string" } else { "byte string" }
+        ),
+        |diag| {
+            diag.help(&format!(
+                "octal escapes are not supported, `\\0` is always a null {}",
+                if is_string { "character" } else { "byte" }
+            ));
+            // suggestion 1: equivalent hex escape
+            if let Some(sugg) = literal_suggestion {
+                diag.span_suggestion(
+                    span,
+                    "if an octal escape is intended, use",
+                    format!("\"{}{}{}\"", &contents[..from], sugg, &contents[to..]),
+                    Applicability::MaybeIncorrect,
+                );
+            }
+            // suggestion 2: unambiguous null byte
+            diag.span_suggestion(
+                span,
+                &format!(
+                    "if the null {} is intended, disambiguate using",
+                    if is_string { "character" } else { "byte" }
+                ),
+                format!("\"{}\\x00{}\"", &contents[..from], &contents[from + 2..]),
+                Applicability::MaybeIncorrect,
+            );
+        },
+    );
+}
diff --git a/tests/ui/octal_escapes.rs b/tests/ui/octal_escapes.rs
new file mode 100644
index 00000000000..5ddee73c020
--- /dev/null
+++ b/tests/ui/octal_escapes.rs
@@ -0,0 +1,12 @@
+#![warn(clippy::octal_escapes)]
+
+fn main() {
+    let _bad1 = "\033[0m";
+    let _bad2 = b"\033[0m";
+    let _bad3 = "\\\033[0m";
+    let _bad4 = "\01234567";
+    let _bad5 = "\0\03";
+
+    let _good1 = "\\033[0m";
+    let _good2 = "\0\\0";
+}
diff --git a/tests/ui/octal_escapes.stderr b/tests/ui/octal_escapes.stderr
new file mode 100644
index 00000000000..8a93e781bed
--- /dev/null
+++ b/tests/ui/octal_escapes.stderr
@@ -0,0 +1,67 @@
+error: octal-looking escape in string literal
+  --> $DIR/octal_escapes.rs:4:17
+   |
+LL |     let _bad1 = "/033[0m";
+   |                 ^^^^^^^^^
+   |
+   = note: `-D clippy::octal-escapes` implied by `-D warnings`
+   = help: octal escapes are not supported, `/0` is always a null character
+help: if an octal escape is intended, use
+   |
+LL |     let _bad1 = "/x1b[0m";
+   |                 ~~~~~~~~~
+help: if the null character is intended, disambiguate using
+   |
+LL |     let _bad1 = "/x0033[0m";
+   |                 ~~~~~~~~~~~
+
+error: octal-looking escape in byte string literal
+  --> $DIR/octal_escapes.rs:5:17
+   |
+LL |     let _bad2 = b"/033[0m";
+   |                 ^^^^^^^^^^
+   |
+   = help: octal escapes are not supported, `/0` is always a null byte
+help: if an octal escape is intended, use
+   |
+LL |     let _bad2 = "/x1b[0m";
+   |                 ~~~~~~~~~
+help: if the null byte is intended, disambiguate using
+   |
+LL |     let _bad2 = "/x0033[0m";
+   |                 ~~~~~~~~~~~
+
+error: octal-looking escape in string literal
+  --> $DIR/octal_escapes.rs:6:17
+   |
+LL |     let _bad3 = "//033[0m";
+   |                 ^^^^^^^^^^^
+   |
+   = help: octal escapes are not supported, `/0` is always a null character
+help: if an octal escape is intended, use
+   |
+LL |     let _bad3 = "//x1b[0m";
+   |                 ~~~~~~~~~~~
+help: if the null character is intended, disambiguate using
+   |
+LL |     let _bad3 = "//x0033[0m";
+   |                 ~~~~~~~~~~~~~
+
+error: octal-looking escape in string literal
+  --> $DIR/octal_escapes.rs:7:17
+   |
+LL |     let _bad4 = "/01234567";
+   |                 ^^^^^^^^^^^
+   |
+   = help: octal escapes are not supported, `/0` is always a null character
+help: if an octal escape is intended, use
+   |
+LL |     let _bad4 = "/u{53977}";
+   |                 ~~~~~~~~~~~
+help: if the null character is intended, disambiguate using
+   |
+LL |     let _bad4 = "/x001234567";
+   |                 ~~~~~~~~~~~~~
+
+error: aborting due to 4 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 1c8085d705849e528bf754e9db3b0e0521883d6d Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Sat, 20 Nov 2021 15:04:08 +0100
Subject: Allow `suboptimal_flops` in const functions

---
 clippy_lints/src/floating_point_arithmetic.rs |  7 ++++++-
 tests/ui/floating_point_abs.fixed             |  6 ++++++
 tests/ui/floating_point_abs.rs                |  6 ++++++
 tests/ui/floating_point_abs.stderr            | 16 ++++++++--------
 tests/ui/floating_point_mul_add.fixed         | 11 +++++++++++
 tests/ui/floating_point_mul_add.rs            | 11 +++++++++++
 tests/ui/floating_point_mul_add.stderr        | 20 ++++++++++----------
 tests/ui/floating_point_rad.fixed             |  7 +++++++
 tests/ui/floating_point_rad.rs                |  7 +++++++
 tests/ui/floating_point_rad.stderr            |  4 ++--
 10 files changed, 74 insertions(+), 21 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/floating_point_arithmetic.rs b/clippy_lints/src/floating_point_arithmetic.rs
index 914723a4802..3df511ea8e7 100644
--- a/clippy_lints/src/floating_point_arithmetic.rs
+++ b/clippy_lints/src/floating_point_arithmetic.rs
@@ -4,7 +4,7 @@ use clippy_utils::consts::{
 };
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::higher;
-use clippy_utils::{eq_expr_value, get_parent_expr, numeric_literal, sugg};
+use clippy_utils::{eq_expr_value, get_parent_expr, in_constant, numeric_literal, sugg};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind, PathSegment, UnOp};
@@ -687,6 +687,11 @@ fn check_radians(cx: &LateContext<'_>, expr: &Expr<'_>) {
 
 impl<'tcx> LateLintPass<'tcx> for FloatingPointArithmetic {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        // All of these operations are currently not const.
+        if in_constant(cx, expr.hir_id) {
+            return;
+        }
+
         if let ExprKind::MethodCall(path, _, args, _) = &expr.kind {
             let recv_ty = cx.typeck_results().expr_ty(&args[0]);
 
diff --git a/tests/ui/floating_point_abs.fixed b/tests/ui/floating_point_abs.fixed
index cea727257c4..ca747fefc64 100644
--- a/tests/ui/floating_point_abs.fixed
+++ b/tests/ui/floating_point_abs.fixed
@@ -1,6 +1,12 @@
 // run-rustfix
+#![feature(const_fn_floating_point_arithmetic)]
 #![warn(clippy::suboptimal_flops)]
 
+/// Allow suboptimal ops in constant context
+pub const fn in_const_context(num: f64) -> f64 {
+    if num >= 0.0 { num } else { -num }
+}
+
 struct A {
     a: f64,
     b: f64,
diff --git a/tests/ui/floating_point_abs.rs b/tests/ui/floating_point_abs.rs
index ba8a8f18fa2..e4b60657497 100644
--- a/tests/ui/floating_point_abs.rs
+++ b/tests/ui/floating_point_abs.rs
@@ -1,6 +1,12 @@
 // run-rustfix
+#![feature(const_fn_floating_point_arithmetic)]
 #![warn(clippy::suboptimal_flops)]
 
+/// Allow suboptimal ops in constant context
+pub const fn in_const_context(num: f64) -> f64 {
+    if num >= 0.0 { num } else { -num }
+}
+
 struct A {
     a: f64,
     b: f64,
diff --git a/tests/ui/floating_point_abs.stderr b/tests/ui/floating_point_abs.stderr
index 35af70201fa..db8290423ae 100644
--- a/tests/ui/floating_point_abs.stderr
+++ b/tests/ui/floating_point_abs.stderr
@@ -1,5 +1,5 @@
 error: manual implementation of `abs` method
-  --> $DIR/floating_point_abs.rs:10:5
+  --> $DIR/floating_point_abs.rs:16:5
    |
 LL |     if num >= 0.0 { num } else { -num }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `num.abs()`
@@ -7,43 +7,43 @@ LL |     if num >= 0.0 { num } else { -num }
    = note: `-D clippy::suboptimal-flops` implied by `-D warnings`
 
 error: manual implementation of `abs` method
-  --> $DIR/floating_point_abs.rs:14:5
+  --> $DIR/floating_point_abs.rs:20:5
    |
 LL |     if 0.0 < num { num } else { -num }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `num.abs()`
 
 error: manual implementation of `abs` method
-  --> $DIR/floating_point_abs.rs:18:5
+  --> $DIR/floating_point_abs.rs:24:5
    |
 LL |     if a.a > 0.0 { a.a } else { -a.a }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `a.a.abs()`
 
 error: manual implementation of `abs` method
-  --> $DIR/floating_point_abs.rs:22:5
+  --> $DIR/floating_point_abs.rs:28:5
    |
 LL |     if 0.0 >= num { -num } else { num }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `num.abs()`
 
 error: manual implementation of `abs` method
-  --> $DIR/floating_point_abs.rs:26:5
+  --> $DIR/floating_point_abs.rs:32:5
    |
 LL |     if a.a < 0.0 { -a.a } else { a.a }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `a.a.abs()`
 
 error: manual implementation of negation of `abs` method
-  --> $DIR/floating_point_abs.rs:30:5
+  --> $DIR/floating_point_abs.rs:36:5
    |
 LL |     if num < 0.0 { num } else { -num }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `-num.abs()`
 
 error: manual implementation of negation of `abs` method
-  --> $DIR/floating_point_abs.rs:34:5
+  --> $DIR/floating_point_abs.rs:40:5
    |
 LL |     if 0.0 >= num { num } else { -num }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `-num.abs()`
 
 error: manual implementation of negation of `abs` method
-  --> $DIR/floating_point_abs.rs:39:12
+  --> $DIR/floating_point_abs.rs:45:12
    |
 LL |         a: if a.a >= 0.0 { -a.a } else { a.a },
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `-a.a.abs()`
diff --git a/tests/ui/floating_point_mul_add.fixed b/tests/ui/floating_point_mul_add.fixed
index 911700bab00..169ec02f82b 100644
--- a/tests/ui/floating_point_mul_add.fixed
+++ b/tests/ui/floating_point_mul_add.fixed
@@ -1,6 +1,17 @@
 // run-rustfix
+#![feature(const_fn_floating_point_arithmetic)]
 #![warn(clippy::suboptimal_flops)]
 
+/// Allow suboptimal_ops in constant context
+pub const fn in_const_context() {
+    let a: f64 = 1234.567;
+    let b: f64 = 45.67834;
+    let c: f64 = 0.0004;
+
+    let _ = a * b + c;
+    let _ = c + a * b;
+}
+
 fn main() {
     let a: f64 = 1234.567;
     let b: f64 = 45.67834;
diff --git a/tests/ui/floating_point_mul_add.rs b/tests/ui/floating_point_mul_add.rs
index d202385fc8a..5338d4fc2b7 100644
--- a/tests/ui/floating_point_mul_add.rs
+++ b/tests/ui/floating_point_mul_add.rs
@@ -1,6 +1,17 @@
 // run-rustfix
+#![feature(const_fn_floating_point_arithmetic)]
 #![warn(clippy::suboptimal_flops)]
 
+/// Allow suboptimal_ops in constant context
+pub const fn in_const_context() {
+    let a: f64 = 1234.567;
+    let b: f64 = 45.67834;
+    let c: f64 = 0.0004;
+
+    let _ = a * b + c;
+    let _ = c + a * b;
+}
+
 fn main() {
     let a: f64 = 1234.567;
     let b: f64 = 45.67834;
diff --git a/tests/ui/floating_point_mul_add.stderr b/tests/ui/floating_point_mul_add.stderr
index ac8d0c0cae0..e637bbf90ca 100644
--- a/tests/ui/floating_point_mul_add.stderr
+++ b/tests/ui/floating_point_mul_add.stderr
@@ -1,5 +1,5 @@
 error: multiply and add expressions can be calculated more efficiently and accurately
-  --> $DIR/floating_point_mul_add.rs:10:13
+  --> $DIR/floating_point_mul_add.rs:21:13
    |
 LL |     let _ = a * b + c;
    |             ^^^^^^^^^ help: consider using: `a.mul_add(b, c)`
@@ -7,55 +7,55 @@ LL |     let _ = a * b + c;
    = note: `-D clippy::suboptimal-flops` implied by `-D warnings`
 
 error: multiply and add expressions can be calculated more efficiently and accurately
-  --> $DIR/floating_point_mul_add.rs:11:13
+  --> $DIR/floating_point_mul_add.rs:22:13
    |
 LL |     let _ = c + a * b;
    |             ^^^^^^^^^ help: consider using: `a.mul_add(b, c)`
 
 error: multiply and add expressions can be calculated more efficiently and accurately
-  --> $DIR/floating_point_mul_add.rs:12:13
+  --> $DIR/floating_point_mul_add.rs:23:13
    |
 LL |     let _ = a + 2.0 * 4.0;
    |             ^^^^^^^^^^^^^ help: consider using: `2.0f64.mul_add(4.0, a)`
 
 error: multiply and add expressions can be calculated more efficiently and accurately
-  --> $DIR/floating_point_mul_add.rs:13:13
+  --> $DIR/floating_point_mul_add.rs:24:13
    |
 LL |     let _ = a + 2. * 4.;
    |             ^^^^^^^^^^^ help: consider using: `2.0f64.mul_add(4., a)`
 
 error: multiply and add expressions can be calculated more efficiently and accurately
-  --> $DIR/floating_point_mul_add.rs:15:13
+  --> $DIR/floating_point_mul_add.rs:26:13
    |
 LL |     let _ = (a * b) + c;
    |             ^^^^^^^^^^^ help: consider using: `a.mul_add(b, c)`
 
 error: multiply and add expressions can be calculated more efficiently and accurately
-  --> $DIR/floating_point_mul_add.rs:16:13
+  --> $DIR/floating_point_mul_add.rs:27:13
    |
 LL |     let _ = c + (a * b);
    |             ^^^^^^^^^^^ help: consider using: `a.mul_add(b, c)`
 
 error: multiply and add expressions can be calculated more efficiently and accurately
-  --> $DIR/floating_point_mul_add.rs:17:13
+  --> $DIR/floating_point_mul_add.rs:28:13
    |
 LL |     let _ = a * b * c + d;
    |             ^^^^^^^^^^^^^ help: consider using: `(a * b).mul_add(c, d)`
 
 error: multiply and add expressions can be calculated more efficiently and accurately
-  --> $DIR/floating_point_mul_add.rs:19:13
+  --> $DIR/floating_point_mul_add.rs:30:13
    |
 LL |     let _ = a.mul_add(b, c) * a.mul_add(b, c) + a.mul_add(b, c) + c;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `a.mul_add(b, c).mul_add(a.mul_add(b, c), a.mul_add(b, c))`
 
 error: multiply and add expressions can be calculated more efficiently and accurately
-  --> $DIR/floating_point_mul_add.rs:20:13
+  --> $DIR/floating_point_mul_add.rs:31:13
    |
 LL |     let _ = 1234.567_f64 * 45.67834_f64 + 0.0004_f64;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `1234.567_f64.mul_add(45.67834_f64, 0.0004_f64)`
 
 error: multiply and add expressions can be calculated more efficiently and accurately
-  --> $DIR/floating_point_mul_add.rs:22:13
+  --> $DIR/floating_point_mul_add.rs:33:13
    |
 LL |     let _ = (a * a + b).sqrt();
    |             ^^^^^^^^^^^ help: consider using: `a.mul_add(a, b)`
diff --git a/tests/ui/floating_point_rad.fixed b/tests/ui/floating_point_rad.fixed
index 92480c5db8b..a35bb1c27f3 100644
--- a/tests/ui/floating_point_rad.fixed
+++ b/tests/ui/floating_point_rad.fixed
@@ -1,6 +1,13 @@
 // run-rustfix
+#![feature(const_fn_floating_point_arithmetic)]
 #![warn(clippy::suboptimal_flops)]
 
+/// Allow suboptimal_flops in constant context
+pub const fn const_context() {
+    let x = 3f32;
+    let _ = x * 180f32 / std::f32::consts::PI;
+}
+
 fn main() {
     let x = 3f32;
     let _ = x.to_degrees();
diff --git a/tests/ui/floating_point_rad.rs b/tests/ui/floating_point_rad.rs
index 062e7c3fdc1..834db4be533 100644
--- a/tests/ui/floating_point_rad.rs
+++ b/tests/ui/floating_point_rad.rs
@@ -1,6 +1,13 @@
 // run-rustfix
+#![feature(const_fn_floating_point_arithmetic)]
 #![warn(clippy::suboptimal_flops)]
 
+/// Allow suboptimal_flops in constant context
+pub const fn const_context() {
+    let x = 3f32;
+    let _ = x * 180f32 / std::f32::consts::PI;
+}
+
 fn main() {
     let x = 3f32;
     let _ = x * 180f32 / std::f32::consts::PI;
diff --git a/tests/ui/floating_point_rad.stderr b/tests/ui/floating_point_rad.stderr
index a6ffdca64ee..acecddbca53 100644
--- a/tests/ui/floating_point_rad.stderr
+++ b/tests/ui/floating_point_rad.stderr
@@ -1,5 +1,5 @@
 error: conversion to degrees can be done more accurately
-  --> $DIR/floating_point_rad.rs:6:13
+  --> $DIR/floating_point_rad.rs:13:13
    |
 LL |     let _ = x * 180f32 / std::f32::consts::PI;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.to_degrees()`
@@ -7,7 +7,7 @@ LL |     let _ = x * 180f32 / std::f32::consts::PI;
    = note: `-D clippy::suboptimal-flops` implied by `-D warnings`
 
 error: conversion to radians can be done more accurately
-  --> $DIR/floating_point_rad.rs:7:13
+  --> $DIR/floating_point_rad.rs:14:13
    |
 LL |     let _ = x * std::f32::consts::PI / 180f32;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.to_radians()`
-- 
cgit 1.4.1-3-g733a5


From 092fe209a6568ade22046dbf4e78455d5aeeb5fa Mon Sep 17 00:00:00 2001
From: ThibsG <thibsg@pm.me>
Date: Sat, 20 Nov 2021 10:00:50 +0100
Subject: Move deref closure builder to `clippy_utils::sugg` module

---
 clippy_lints/src/methods/search_is_some.rs | 258 +-------------------------
 clippy_utils/src/sugg.rs                   | 278 ++++++++++++++++++++++++++++-
 2 files changed, 279 insertions(+), 257 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/search_is_some.rs b/clippy_lints/src/methods/search_is_some.rs
index a3449c1fe12..5ed4ba94884 100644
--- a/clippy_lints/src/methods/search_is_some.rs
+++ b/clippy_lints/src/methods/search_is_some.rs
@@ -1,21 +1,16 @@
-use std::iter;
-
 use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg};
 use clippy_utils::source::{snippet, snippet_with_applicability};
+use clippy_utils::sugg::deref_closure_args;
 use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{get_parent_expr_for_hir, is_trait_method, strip_pat_refs};
+use clippy_utils::{is_trait_method, strip_pat_refs};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
-use rustc_hir::{self, ExprKind, HirId, MutTy, PatKind, TyKind};
-use rustc_infer::infer::TyCtxtInferExt;
+use rustc_hir::PatKind;
 use rustc_lint::LateContext;
-use rustc_middle::hir::place::ProjectionKind;
-use rustc_middle::mir::{FakeReadCause, Mutability};
 use rustc_middle::ty;
-use rustc_span::source_map::{BytePos, Span};
+use rustc_span::source_map::Span;
 use rustc_span::symbol::sym;
-use rustc_typeck::expr_use_visitor::{Delegate, ExprUseVisitor, PlaceBase, PlaceWithHirId};
 
 use super::SEARCH_IS_SOME;
 
@@ -55,7 +50,7 @@ pub(super) fn check<'tcx>(
                     } else if let PatKind::Binding(..) = strip_pat_refs(closure_arg.pat).kind {
                         // `find()` provides a reference to the item, but `any` does not,
                         // so we should fix item usages for suggestion
-                        if let Some(closure_sugg) = get_closure_suggestion(cx, search_arg) {
+                        if let Some(closure_sugg) = deref_closure_args(cx, search_arg) {
                             applicability = closure_sugg.applicability;
                             Some(closure_sugg.suggestion)
                         } else {
@@ -159,246 +154,3 @@ pub(super) fn check<'tcx>(
         }
     }
 }
-
-#[derive(Debug)]
-struct ClosureSugg {
-    applicability: Applicability,
-    suggestion: String,
-}
-
-// Build suggestion gradually by handling closure arg specific usages,
-// such as explicit deref and borrowing cases.
-// Returns `None` if no such use cases have been triggered in closure body
-fn get_closure_suggestion<'tcx>(cx: &LateContext<'_>, search_expr: &'tcx hir::Expr<'_>) -> Option<ClosureSugg> {
-    if let hir::ExprKind::Closure(_, fn_decl, body_id, ..) = search_expr.kind {
-        let closure_body = cx.tcx.hir().body(body_id);
-        // is closure arg a double reference (i.e.: `|x: &&i32| ...`)
-        let closure_arg_is_double_ref = if let TyKind::Rptr(_, MutTy { ty, .. }) = fn_decl.inputs[0].kind {
-            matches!(ty.kind, TyKind::Rptr(_, MutTy { .. }))
-        } else {
-            false
-        };
-
-        let mut visitor = DerefDelegate {
-            cx,
-            closure_span: search_expr.span,
-            closure_arg_is_double_ref,
-            next_pos: search_expr.span.lo(),
-            suggestion_start: String::new(),
-            applicability: Applicability::MaybeIncorrect,
-        };
-
-        let fn_def_id = cx.tcx.hir().local_def_id(search_expr.hir_id);
-        cx.tcx.infer_ctxt().enter(|infcx| {
-            ExprUseVisitor::new(&mut visitor, &infcx, fn_def_id, cx.param_env, cx.typeck_results())
-                .consume_body(closure_body);
-        });
-
-        if !visitor.suggestion_start.is_empty() {
-            return Some(ClosureSugg {
-                applicability: visitor.applicability,
-                suggestion: visitor.finish(),
-            });
-        }
-    }
-    None
-}
-
-struct DerefDelegate<'a, 'tcx> {
-    cx: &'a LateContext<'tcx>,
-    closure_span: Span,
-    closure_arg_is_double_ref: bool,
-    next_pos: BytePos,
-    suggestion_start: String,
-    applicability: Applicability,
-}
-
-impl DerefDelegate<'_, 'tcx> {
-    pub fn finish(&mut self) -> String {
-        let end_span = Span::new(self.next_pos, self.closure_span.hi(), self.closure_span.ctxt(), None);
-        let end_snip = snippet_with_applicability(self.cx, end_span, "..", &mut self.applicability);
-        let sugg = format!("{}{}", self.suggestion_start, end_snip);
-        if self.closure_arg_is_double_ref {
-            sugg.replacen('&', "", 1)
-        } else {
-            sugg
-        }
-    }
-
-    fn func_takes_arg_by_double_ref(&self, parent_expr: &'tcx hir::Expr<'_>, cmt_hir_id: HirId) -> bool {
-        let (call_args, inputs) = match parent_expr.kind {
-            ExprKind::MethodCall(_, _, call_args, _) => {
-                if let Some(method_did) = self.cx.typeck_results().type_dependent_def_id(parent_expr.hir_id) {
-                    (call_args, self.cx.tcx.fn_sig(method_did).skip_binder().inputs())
-                } else {
-                    return false;
-                }
-            },
-            ExprKind::Call(func, call_args) => {
-                let typ = self.cx.typeck_results().expr_ty(func);
-                (call_args, typ.fn_sig(self.cx.tcx).skip_binder().inputs())
-            },
-            _ => return false,
-        };
-
-        iter::zip(call_args, inputs)
-            .any(|(arg, ty)| arg.hir_id == cmt_hir_id && matches!(ty.kind(), ty::Ref(_, inner, _) if inner.is_ref()))
-    }
-}
-
-impl<'tcx> Delegate<'tcx> for DerefDelegate<'_, 'tcx> {
-    fn consume(&mut self, _: &PlaceWithHirId<'tcx>, _: HirId) {}
-
-    fn borrow(&mut self, cmt: &PlaceWithHirId<'tcx>, _: HirId, _: ty::BorrowKind) {
-        if let PlaceBase::Local(id) = cmt.place.base {
-            let map = self.cx.tcx.hir();
-            let span = map.span(cmt.hir_id);
-            let start_span = Span::new(self.next_pos, span.lo(), span.ctxt(), None);
-            let mut start_snip = snippet_with_applicability(self.cx, start_span, "..", &mut self.applicability);
-
-            // identifier referring to the variable currently triggered (i.e.: `fp`)
-            let ident_str = map.name(id).to_string();
-            // full identifier that includes projection (i.e.: `fp.field`)
-            let ident_str_with_proj = snippet(self.cx, span, "..").to_string();
-
-            if cmt.place.projections.is_empty() {
-                // handle item without any projection, that needs an explicit borrowing
-                // i.e.: suggest `&x` instead of `x`
-                self.closure_arg_is_double_ref = false;
-                self.suggestion_start.push_str(&format!("{}&{}", start_snip, ident_str));
-            } else {
-                // cases where a parent `Call` or `MethodCall` is using the item
-                // i.e.: suggest `.contains(&x)` for `.find(|x| [1, 2, 3].contains(x)).is_none()`
-                //
-                // Note about method calls:
-                // - compiler automatically dereference references if the target type is a reference (works also for
-                //   function call)
-                // - `self` arguments in the case of `x.is_something()` are also automatically (de)referenced, and
-                //   no projection should be suggested
-                if let Some(parent_expr) = get_parent_expr_for_hir(self.cx, cmt.hir_id) {
-                    match &parent_expr.kind {
-                        // given expression is the self argument and will be handled completely by the compiler
-                        // i.e.: `|x| x.is_something()`
-                        ExprKind::MethodCall(_, _, [self_expr, ..], _) if self_expr.hir_id == cmt.hir_id => {
-                            self.suggestion_start
-                                .push_str(&format!("{}{}", start_snip, ident_str_with_proj));
-                            self.next_pos = span.hi();
-                            return;
-                        },
-                        // item is used in a call
-                        // i.e.: `Call`: `|x| please(x)` or `MethodCall`: `|x| [1, 2, 3].contains(x)`
-                        ExprKind::Call(_, [call_args @ ..]) | ExprKind::MethodCall(_, _, [_, call_args @ ..], _) => {
-                            let expr = self.cx.tcx.hir().expect_expr(cmt.hir_id);
-                            let arg_ty_kind = self.cx.typeck_results().expr_ty(expr).kind();
-
-                            if matches!(arg_ty_kind, ty::Ref(_, _, Mutability::Not)) {
-                                // suggest ampersand if call function is taking args by double reference
-                                let takes_arg_by_double_ref =
-                                    self.func_takes_arg_by_double_ref(parent_expr, cmt.hir_id);
-
-                                // compiler will automatically dereference field projection, so no need
-                                // to suggest ampersand, but full identifier that includes projection is required
-                                let has_field_projection = cmt
-                                    .place
-                                    .projections
-                                    .iter()
-                                    .any(|proj| matches!(proj.kind, ProjectionKind::Field(..)));
-
-                                // no need to bind again if the function doesn't take arg by double ref
-                                // and if the item is already a double ref
-                                let ident_sugg = if !call_args.is_empty()
-                                    && !takes_arg_by_double_ref
-                                    && (self.closure_arg_is_double_ref || has_field_projection)
-                                {
-                                    let ident = if has_field_projection {
-                                        ident_str_with_proj
-                                    } else {
-                                        ident_str
-                                    };
-                                    format!("{}{}", start_snip, ident)
-                                } else {
-                                    format!("{}&{}", start_snip, ident_str)
-                                };
-                                self.suggestion_start.push_str(&ident_sugg);
-                                self.next_pos = span.hi();
-                                return;
-                            }
-
-                            self.applicability = Applicability::Unspecified;
-                        },
-                        _ => (),
-                    }
-                }
-
-                let mut replacement_str = ident_str;
-                let mut projections_handled = false;
-                cmt.place.projections.iter().enumerate().for_each(|(i, proj)| {
-                    match proj.kind {
-                        // Field projection like `|v| v.foo`
-                        // no adjustment needed here, as field projections are handled by the compiler
-                        ProjectionKind::Field(..) => match cmt.place.ty_before_projection(i).kind() {
-                            ty::Adt(..) | ty::Tuple(_) => {
-                                replacement_str = ident_str_with_proj.clone();
-                                projections_handled = true;
-                            },
-                            _ => (),
-                        },
-                        // Index projection like `|x| foo[x]`
-                        // the index is dropped so we can't get it to build the suggestion,
-                        // so the span is set-up again to get more code, using `span.hi()` (i.e.: `foo[x]`)
-                        // instead of `span.lo()` (i.e.: `foo`)
-                        ProjectionKind::Index => {
-                            let start_span = Span::new(self.next_pos, span.hi(), span.ctxt(), None);
-                            start_snip = snippet_with_applicability(self.cx, start_span, "..", &mut self.applicability);
-                            replacement_str.clear();
-                            projections_handled = true;
-                        },
-                        // note: unable to trigger `Subslice` kind in tests
-                        ProjectionKind::Subslice => (),
-                        ProjectionKind::Deref => {
-                            // explicit deref for arrays should be avoided in the suggestion
-                            // i.e.: `|sub| *sub[1..4].len() == 3` is not expected
-                            if let ty::Ref(_, inner, _) = cmt.place.ty_before_projection(i).kind() {
-                                // dereferencing an array (i.e.: `|sub| sub[1..4].len() == 3`)
-                                if matches!(inner.kind(), ty::Ref(_, innermost, _) if innermost.is_array()) {
-                                    projections_handled = true;
-                                }
-                            }
-                        },
-                    }
-                });
-
-                // handle `ProjectionKind::Deref` by removing one explicit deref
-                // if no special case was detected (i.e.: suggest `*x` instead of `**x`)
-                if projections_handled {
-                    self.closure_arg_is_double_ref = false;
-                } else {
-                    let last_deref = cmt
-                        .place
-                        .projections
-                        .iter()
-                        .rposition(|proj| proj.kind == ProjectionKind::Deref);
-
-                    if let Some(pos) = last_deref {
-                        let mut projections = cmt.place.projections.clone();
-                        projections.truncate(pos);
-
-                        for item in projections {
-                            if item.kind == ProjectionKind::Deref {
-                                replacement_str = format!("*{}", replacement_str);
-                            }
-                        }
-                    }
-                }
-
-                self.suggestion_start
-                    .push_str(&format!("{}{}", start_snip, replacement_str));
-            }
-            self.next_pos = span.hi();
-        }
-    }
-
-    fn mutate(&mut self, _: &PlaceWithHirId<'tcx>, _: HirId) {}
-
-    fn fake_read(&mut self, _: rustc_typeck::expr_use_visitor::Place<'tcx>, _: FakeReadCause, _: HirId) {}
-}
diff --git a/clippy_utils/src/sugg.rs b/clippy_utils/src/sugg.rs
index 01fb944cc36..e8a35f8c8dc 100644
--- a/clippy_utils/src/sugg.rs
+++ b/clippy_utils/src/sugg.rs
@@ -1,19 +1,27 @@
 //! Contains utility functions to generate suggestions.
 #![deny(clippy::missing_docs_in_private_items)]
 
-use crate::higher;
-use crate::source::{snippet, snippet_opt, snippet_with_context, snippet_with_macro_callsite};
+use crate::source::{
+    snippet, snippet_opt, snippet_with_applicability, snippet_with_context, snippet_with_macro_callsite,
+};
+use crate::{get_parent_expr_for_hir, higher};
 use rustc_ast::util::parser::AssocOp;
 use rustc_ast::{ast, token};
 use rustc_ast_pretty::pprust::token_kind_to_string;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
+use rustc_hir::{ExprKind, HirId, MutTy, TyKind};
+use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::{EarlyContext, LateContext, LintContext};
-use rustc_span::source_map::{CharPos, Span};
-use rustc_span::{BytePos, Pos, SyntaxContext};
+use rustc_middle::hir::place::ProjectionKind;
+use rustc_middle::mir::{FakeReadCause, Mutability};
+use rustc_middle::ty;
+use rustc_span::source_map::{BytePos, CharPos, Pos, Span, SyntaxContext};
+use rustc_typeck::expr_use_visitor::{Delegate, ExprUseVisitor, PlaceBase, PlaceWithHirId};
 use std::borrow::Cow;
 use std::convert::TryInto;
 use std::fmt::Display;
+use std::iter;
 use std::ops::{Add, Neg, Not, Sub};
 
 /// A helper type to build suggestion correctly handling parentheses.
@@ -716,6 +724,268 @@ impl<T: LintContext> DiagnosticBuilderExt<T> for rustc_errors::DiagnosticBuilder
     }
 }
 
+/// Suggestion results for handling closure
+/// args dereferencing and borrowing
+pub struct DerefClosure {
+    /// confidence on the built suggestion
+    pub applicability: Applicability,
+    /// gradually built suggestion
+    pub suggestion: String,
+}
+
+/// Build suggestion gradually by handling closure arg specific usages,
+/// such as explicit deref and borrowing cases.
+/// Returns `None` if no such use cases have been triggered in closure body
+///
+/// note: this only works on single line immutable closures
+pub fn deref_closure_args<'tcx>(cx: &LateContext<'_>, search_expr: &'tcx hir::Expr<'_>) -> Option<DerefClosure> {
+    if let hir::ExprKind::Closure(_, fn_decl, body_id, ..) = search_expr.kind {
+        let closure_body = cx.tcx.hir().body(body_id);
+        // is closure arg a double reference (i.e.: `|x: &&i32| ...`)
+        let closure_arg_is_double_ref = if let TyKind::Rptr(_, MutTy { ty, .. }) = fn_decl.inputs[0].kind {
+            matches!(ty.kind, TyKind::Rptr(_, MutTy { .. }))
+        } else {
+            false
+        };
+
+        let mut visitor = DerefDelegate {
+            cx,
+            closure_span: search_expr.span,
+            closure_arg_is_double_ref,
+            next_pos: search_expr.span.lo(),
+            suggestion_start: String::new(),
+            applicability: Applicability::MaybeIncorrect,
+        };
+
+        let fn_def_id = cx.tcx.hir().local_def_id(search_expr.hir_id);
+        cx.tcx.infer_ctxt().enter(|infcx| {
+            ExprUseVisitor::new(&mut visitor, &infcx, fn_def_id, cx.param_env, cx.typeck_results())
+                .consume_body(closure_body);
+        });
+
+        if !visitor.suggestion_start.is_empty() {
+            return Some(DerefClosure {
+                applicability: visitor.applicability,
+                suggestion: visitor.finish(),
+            });
+        }
+    }
+    None
+}
+
+/// Visitor struct used for tracking down
+/// dereferencing and borrowing of closure's args
+struct DerefDelegate<'a, 'tcx> {
+    /// The late context of the lint
+    cx: &'a LateContext<'tcx>,
+    /// The span of the input closure to adapt
+    closure_span: Span,
+    /// Indicates if the arg of the closure is a double reference
+    closure_arg_is_double_ref: bool,
+    /// last position of the span to gradually build the suggestion
+    next_pos: BytePos,
+    /// starting part of the gradually built suggestion
+    suggestion_start: String,
+    /// confidence on the built suggestion
+    applicability: Applicability,
+}
+
+impl DerefDelegate<'_, 'tcx> {
+    /// build final suggestion:
+    /// - create the ending part of suggestion
+    /// - concatenate starting and ending parts
+    /// - potentially remove needless borrowing
+    pub fn finish(&mut self) -> String {
+        let end_span = Span::new(self.next_pos, self.closure_span.hi(), self.closure_span.ctxt(), None);
+        let end_snip = snippet_with_applicability(self.cx, end_span, "..", &mut self.applicability);
+        let sugg = format!("{}{}", self.suggestion_start, end_snip);
+        if self.closure_arg_is_double_ref {
+            sugg.replacen('&', "", 1)
+        } else {
+            sugg
+        }
+    }
+
+    /// indicates whether the function from `parent_expr` takes its args by double reference
+    fn func_takes_arg_by_double_ref(&self, parent_expr: &'tcx hir::Expr<'_>, cmt_hir_id: HirId) -> bool {
+        let (call_args, inputs) = match parent_expr.kind {
+            ExprKind::MethodCall(_, _, call_args, _) => {
+                if let Some(method_did) = self.cx.typeck_results().type_dependent_def_id(parent_expr.hir_id) {
+                    (call_args, self.cx.tcx.fn_sig(method_did).skip_binder().inputs())
+                } else {
+                    return false;
+                }
+            },
+            ExprKind::Call(func, call_args) => {
+                let typ = self.cx.typeck_results().expr_ty(func);
+                (call_args, typ.fn_sig(self.cx.tcx).skip_binder().inputs())
+            },
+            _ => return false,
+        };
+
+        iter::zip(call_args, inputs)
+            .any(|(arg, ty)| arg.hir_id == cmt_hir_id && matches!(ty.kind(), ty::Ref(_, inner, _) if inner.is_ref()))
+    }
+}
+
+impl<'tcx> Delegate<'tcx> for DerefDelegate<'_, 'tcx> {
+    fn consume(&mut self, _: &PlaceWithHirId<'tcx>, _: HirId) {}
+
+    #[allow(clippy::too_many_lines)]
+    fn borrow(&mut self, cmt: &PlaceWithHirId<'tcx>, _: HirId, _: ty::BorrowKind) {
+        if let PlaceBase::Local(id) = cmt.place.base {
+            let map = self.cx.tcx.hir();
+            let span = map.span(cmt.hir_id);
+            let start_span = Span::new(self.next_pos, span.lo(), span.ctxt(), None);
+            let mut start_snip = snippet_with_applicability(self.cx, start_span, "..", &mut self.applicability);
+
+            // identifier referring to the variable currently triggered (i.e.: `fp`)
+            let ident_str = map.name(id).to_string();
+            // full identifier that includes projection (i.e.: `fp.field`)
+            let ident_str_with_proj = snippet(self.cx, span, "..").to_string();
+
+            if cmt.place.projections.is_empty() {
+                // handle item without any projection, that needs an explicit borrowing
+                // i.e.: suggest `&x` instead of `x`
+                self.closure_arg_is_double_ref = false;
+                self.suggestion_start.push_str(&format!("{}&{}", start_snip, ident_str));
+            } else {
+                // cases where a parent `Call` or `MethodCall` is using the item
+                // i.e.: suggest `.contains(&x)` for `.find(|x| [1, 2, 3].contains(x)).is_none()`
+                //
+                // Note about method calls:
+                // - compiler automatically dereference references if the target type is a reference (works also for
+                //   function call)
+                // - `self` arguments in the case of `x.is_something()` are also automatically (de)referenced, and
+                //   no projection should be suggested
+                if let Some(parent_expr) = get_parent_expr_for_hir(self.cx, cmt.hir_id) {
+                    match &parent_expr.kind {
+                        // given expression is the self argument and will be handled completely by the compiler
+                        // i.e.: `|x| x.is_something()`
+                        ExprKind::MethodCall(_, _, [self_expr, ..], _) if self_expr.hir_id == cmt.hir_id => {
+                            self.suggestion_start
+                                .push_str(&format!("{}{}", start_snip, ident_str_with_proj));
+                            self.next_pos = span.hi();
+                            return;
+                        },
+                        // item is used in a call
+                        // i.e.: `Call`: `|x| please(x)` or `MethodCall`: `|x| [1, 2, 3].contains(x)`
+                        ExprKind::Call(_, [call_args @ ..]) | ExprKind::MethodCall(_, _, [_, call_args @ ..], _) => {
+                            let expr = self.cx.tcx.hir().expect_expr(cmt.hir_id);
+                            let arg_ty_kind = self.cx.typeck_results().expr_ty(expr).kind();
+
+                            if matches!(arg_ty_kind, ty::Ref(_, _, Mutability::Not)) {
+                                // suggest ampersand if call function is taking args by double reference
+                                let takes_arg_by_double_ref =
+                                    self.func_takes_arg_by_double_ref(parent_expr, cmt.hir_id);
+
+                                // compiler will automatically dereference field projection, so no need
+                                // to suggest ampersand, but full identifier that includes projection is required
+                                let has_field_projection = cmt
+                                    .place
+                                    .projections
+                                    .iter()
+                                    .any(|proj| matches!(proj.kind, ProjectionKind::Field(..)));
+
+                                // no need to bind again if the function doesn't take arg by double ref
+                                // and if the item is already a double ref
+                                let ident_sugg = if !call_args.is_empty()
+                                    && !takes_arg_by_double_ref
+                                    && (self.closure_arg_is_double_ref || has_field_projection)
+                                {
+                                    let ident = if has_field_projection {
+                                        ident_str_with_proj
+                                    } else {
+                                        ident_str
+                                    };
+                                    format!("{}{}", start_snip, ident)
+                                } else {
+                                    format!("{}&{}", start_snip, ident_str)
+                                };
+                                self.suggestion_start.push_str(&ident_sugg);
+                                self.next_pos = span.hi();
+                                return;
+                            }
+
+                            self.applicability = Applicability::Unspecified;
+                        },
+                        _ => (),
+                    }
+                }
+
+                let mut replacement_str = ident_str;
+                let mut projections_handled = false;
+                cmt.place.projections.iter().enumerate().for_each(|(i, proj)| {
+                    match proj.kind {
+                        // Field projection like `|v| v.foo`
+                        // no adjustment needed here, as field projections are handled by the compiler
+                        ProjectionKind::Field(..) => match cmt.place.ty_before_projection(i).kind() {
+                            ty::Adt(..) | ty::Tuple(_) => {
+                                replacement_str = ident_str_with_proj.clone();
+                                projections_handled = true;
+                            },
+                            _ => (),
+                        },
+                        // Index projection like `|x| foo[x]`
+                        // the index is dropped so we can't get it to build the suggestion,
+                        // so the span is set-up again to get more code, using `span.hi()` (i.e.: `foo[x]`)
+                        // instead of `span.lo()` (i.e.: `foo`)
+                        ProjectionKind::Index => {
+                            let start_span = Span::new(self.next_pos, span.hi(), span.ctxt(), None);
+                            start_snip = snippet_with_applicability(self.cx, start_span, "..", &mut self.applicability);
+                            replacement_str.clear();
+                            projections_handled = true;
+                        },
+                        // note: unable to trigger `Subslice` kind in tests
+                        ProjectionKind::Subslice => (),
+                        ProjectionKind::Deref => {
+                            // explicit deref for arrays should be avoided in the suggestion
+                            // i.e.: `|sub| *sub[1..4].len() == 3` is not expected
+                            if let ty::Ref(_, inner, _) = cmt.place.ty_before_projection(i).kind() {
+                                // dereferencing an array (i.e.: `|sub| sub[1..4].len() == 3`)
+                                if matches!(inner.kind(), ty::Ref(_, innermost, _) if innermost.is_array()) {
+                                    projections_handled = true;
+                                }
+                            }
+                        },
+                    }
+                });
+
+                // handle `ProjectionKind::Deref` by removing one explicit deref
+                // if no special case was detected (i.e.: suggest `*x` instead of `**x`)
+                if projections_handled {
+                    self.closure_arg_is_double_ref = false;
+                } else {
+                    let last_deref = cmt
+                        .place
+                        .projections
+                        .iter()
+                        .rposition(|proj| proj.kind == ProjectionKind::Deref);
+
+                    if let Some(pos) = last_deref {
+                        let mut projections = cmt.place.projections.clone();
+                        projections.truncate(pos);
+
+                        for item in projections {
+                            if item.kind == ProjectionKind::Deref {
+                                replacement_str = format!("*{}", replacement_str);
+                            }
+                        }
+                    }
+                }
+
+                self.suggestion_start
+                    .push_str(&format!("{}{}", start_snip, replacement_str));
+            }
+            self.next_pos = span.hi();
+        }
+    }
+
+    fn mutate(&mut self, _: &PlaceWithHirId<'tcx>, _: HirId) {}
+
+    fn fake_read(&mut self, _: rustc_typeck::expr_use_visitor::Place<'tcx>, _: FakeReadCause, _: HirId) {}
+}
+
 #[cfg(test)]
 mod test {
     use super::Sugg;
-- 
cgit 1.4.1-3-g733a5


From 0c4055c28353856bcc3cd22d77d1d89359d1825b Mon Sep 17 00:00:00 2001
From: Georg Brandl <georg@python.org>
Date: Sat, 20 Nov 2021 18:13:24 +0100
Subject: Avoid inline hints with double backticks for `doc-markdown`

---
 clippy_lints/src/doc.rs              |  21 +++-
 tests/ui/doc/doc-fixable.stderr      | 209 ++++++++++++++++++++++++++++++-----
 tests/ui/doc/unbalanced_ticks.stderr |  21 +++-
 3 files changed, 212 insertions(+), 39 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/doc.rs b/clippy_lints/src/doc.rs
index c1ce851a67d..2cdd59c5691 100644
--- a/clippy_lints/src/doc.rs
+++ b/clippy_lints/src/doc.rs
@@ -1,5 +1,5 @@
 use clippy_utils::attrs::is_doc_hidden;
-use clippy_utils::diagnostics::{span_lint, span_lint_and_help, span_lint_and_note, span_lint_and_sugg};
+use clippy_utils::diagnostics::{span_lint, span_lint_and_help, span_lint_and_note, span_lint_and_then};
 use clippy_utils::source::{first_line_of_span, snippet_with_applicability};
 use clippy_utils::ty::{implements_trait, is_type_diagnostic_item};
 use clippy_utils::{is_entrypoint_fn, is_expn_of, match_panic_def_id, method_chain_args, return_ty};
@@ -10,7 +10,7 @@ use rustc_ast::token::CommentKind;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_data_structures::sync::Lrc;
 use rustc_errors::emitter::EmitterWriter;
-use rustc_errors::{Applicability, Handler};
+use rustc_errors::{Applicability, Handler, SuggestionStyle};
 use rustc_hir as hir;
 use rustc_hir::intravisit::{self, NestedVisitorMap, Visitor};
 use rustc_hir::{AnonConst, Expr, ExprKind, QPath};
@@ -770,14 +770,23 @@ fn check_word(cx: &LateContext<'_>, word: &str, span: Span) {
     if has_underscore(word) || word.contains("::") || is_camel_case(word) {
         let mut applicability = Applicability::MachineApplicable;
 
-        span_lint_and_sugg(
+        span_lint_and_then(
             cx,
             DOC_MARKDOWN,
             span,
             "item in documentation is missing backticks",
-            "try",
-            format!("`{}`", snippet_with_applicability(cx, span, "..", &mut applicability)),
-            applicability,
+            |diag| {
+                let snippet = snippet_with_applicability(cx, span, "..", &mut applicability);
+                diag.span_suggestion_with_style(
+                    span,
+                    "try",
+                    format!("`{}`", snippet),
+                    applicability,
+                    // always show the suggestion in a separate line, since the
+                    // inline presentation adds another pair of backticks
+                    SuggestionStyle::ShowAlways,
+                );
+            },
         );
     }
 }
diff --git a/tests/ui/doc/doc-fixable.stderr b/tests/ui/doc/doc-fixable.stderr
index 31132f86edb..40345370c04 100644
--- a/tests/ui/doc/doc-fixable.stderr
+++ b/tests/ui/doc/doc-fixable.stderr
@@ -2,183 +2,332 @@ error: item in documentation is missing backticks
   --> $DIR/doc-fixable.rs:9:9
    |
 LL | /// The foo_bar function does _nothing_. See also foo::bar. (note the dot there)
-   |         ^^^^^^^ help: try: ``foo_bar``
+   |         ^^^^^^^
    |
    = note: `-D clippy::doc-markdown` implied by `-D warnings`
+help: try
+   |
+LL | /// The `foo_bar` function does _nothing_. See also foo::bar. (note the dot there)
+   |         ~~~~~~~~~
 
 error: item in documentation is missing backticks
   --> $DIR/doc-fixable.rs:9:51
    |
 LL | /// The foo_bar function does _nothing_. See also foo::bar. (note the dot there)
-   |                                                   ^^^^^^^^ help: try: ``foo::bar``
+   |                                                   ^^^^^^^^
+   |
+help: try
+   |
+LL | /// The foo_bar function does _nothing_. See also `foo::bar`. (note the dot there)
+   |                                                   ~~~~~~~~~~
 
 error: item in documentation is missing backticks
   --> $DIR/doc-fixable.rs:10:83
    |
 LL | /// Markdown is _weird_. I mean _really weird_. This /_ is ok. So is `_`. But not Foo::some_fun
-   |                                                                                   ^^^^^^^^^^^^^ help: try: ``Foo::some_fun``
+   |                                                                                   ^^^^^^^^^^^^^
+   |
+help: try
+   |
+LL | /// Markdown is _weird_. I mean _really weird_. This /_ is ok. So is `_`. But not `Foo::some_fun`
+   |                                                                                   ~~~~~~~~~~~~~~~
 
 error: item in documentation is missing backticks
   --> $DIR/doc-fixable.rs:12:13
    |
 LL | /// Here be ::a::global:path, and _::another::global::path_.  :: is not a path though.
-   |             ^^^^^^^^^^^^^^^^ help: try: ``::a::global:path``
+   |             ^^^^^^^^^^^^^^^^
+   |
+help: try
+   |
+LL | /// Here be `::a::global:path`, and _::another::global::path_.  :: is not a path though.
+   |             ~~~~~~~~~~~~~~~~~~
 
 error: item in documentation is missing backticks
   --> $DIR/doc-fixable.rs:12:36
    |
 LL | /// Here be ::a::global:path, and _::another::global::path_.  :: is not a path though.
-   |                                    ^^^^^^^^^^^^^^^^^^^^^^^ help: try: ``::another::global::path``
+   |                                    ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: try
+   |
+LL | /// Here be ::a::global:path, and _`::another::global::path`_.  :: is not a path though.
+   |                                    ~~~~~~~~~~~~~~~~~~~~~~~~~
 
 error: item in documentation is missing backticks
   --> $DIR/doc-fixable.rs:13:25
    |
 LL | /// Import an item from ::awesome::global::blob:: (Intended postfix)
-   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: ``::awesome::global::blob::``
+   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: try
+   |
+LL | /// Import an item from `::awesome::global::blob::` (Intended postfix)
+   |                         ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 error: item in documentation is missing backticks
   --> $DIR/doc-fixable.rs:14:31
    |
 LL | /// These are the options for ::Cat: (Intended trailing single colon, shouldn't be linted)
-   |                               ^^^^^ help: try: ``::Cat``
+   |                               ^^^^^
+   |
+help: try
+   |
+LL | /// These are the options for `::Cat`: (Intended trailing single colon, shouldn't be linted)
+   |                               ~~~~~~~
 
 error: item in documentation is missing backticks
   --> $DIR/doc-fixable.rs:15:22
    |
 LL | /// That's not code ~NotInCodeBlock~.
-   |                      ^^^^^^^^^^^^^^ help: try: ``NotInCodeBlock``
+   |                      ^^^^^^^^^^^^^^
+   |
+help: try
+   |
+LL | /// That's not code ~`NotInCodeBlock`~.
+   |                      ~~~~~~~~~~~~~~~~
 
 error: item in documentation is missing backticks
   --> $DIR/doc-fixable.rs:16:5
    |
 LL | /// be_sure_we_got_to_the_end_of_it
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: ``be_sure_we_got_to_the_end_of_it``
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: try
+   |
+LL | /// `be_sure_we_got_to_the_end_of_it`
+   |     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 error: item in documentation is missing backticks
   --> $DIR/doc-fixable.rs:30:5
    |
 LL | /// be_sure_we_got_to_the_end_of_it
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: ``be_sure_we_got_to_the_end_of_it``
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: try
+   |
+LL | /// `be_sure_we_got_to_the_end_of_it`
+   |     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 error: item in documentation is missing backticks
   --> $DIR/doc-fixable.rs:37:5
    |
 LL | /// be_sure_we_got_to_the_end_of_it
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: ``be_sure_we_got_to_the_end_of_it``
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: try
+   |
+LL | /// `be_sure_we_got_to_the_end_of_it`
+   |     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 error: item in documentation is missing backticks
   --> $DIR/doc-fixable.rs:51:5
    |
 LL | /// be_sure_we_got_to_the_end_of_it
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: ``be_sure_we_got_to_the_end_of_it``
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: try
+   |
+LL | /// `be_sure_we_got_to_the_end_of_it`
+   |     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 error: item in documentation is missing backticks
   --> $DIR/doc-fixable.rs:74:5
    |
 LL | /// be_sure_we_got_to_the_end_of_it
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: ``be_sure_we_got_to_the_end_of_it``
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: try
+   |
+LL | /// `be_sure_we_got_to_the_end_of_it`
+   |     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 error: item in documentation is missing backticks
   --> $DIR/doc-fixable.rs:78:22
    |
 LL | /// This test has [a link_with_underscores][chunked-example] inside it. See #823.
-   |                      ^^^^^^^^^^^^^^^^^^^^^ help: try: ``link_with_underscores``
+   |                      ^^^^^^^^^^^^^^^^^^^^^
+   |
+help: try
+   |
+LL | /// This test has [a `link_with_underscores`][chunked-example] inside it. See #823.
+   |                      ~~~~~~~~~~~~~~~~~~~~~~~
 
 error: item in documentation is missing backticks
   --> $DIR/doc-fixable.rs:81:21
    |
 LL | /// It can also be [inline_link2].
-   |                     ^^^^^^^^^^^^ help: try: ``inline_link2``
+   |                     ^^^^^^^^^^^^
+   |
+help: try
+   |
+LL | /// It can also be [`inline_link2`].
+   |                     ~~~~~~~~~~~~~~
 
 error: item in documentation is missing backticks
   --> $DIR/doc-fixable.rs:91:5
    |
 LL | /// be_sure_we_got_to_the_end_of_it
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: ``be_sure_we_got_to_the_end_of_it``
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: try
+   |
+LL | /// `be_sure_we_got_to_the_end_of_it`
+   |     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 error: item in documentation is missing backticks
   --> $DIR/doc-fixable.rs:99:8
    |
 LL | /// ## CamelCaseThing
-   |        ^^^^^^^^^^^^^^ help: try: ``CamelCaseThing``
+   |        ^^^^^^^^^^^^^^
+   |
+help: try
+   |
+LL | /// ## `CamelCaseThing`
+   |        ~~~~~~~~~~~~~~~~
 
 error: item in documentation is missing backticks
   --> $DIR/doc-fixable.rs:102:7
    |
 LL | /// # CamelCaseThing
-   |       ^^^^^^^^^^^^^^ help: try: ``CamelCaseThing``
+   |       ^^^^^^^^^^^^^^
+   |
+help: try
+   |
+LL | /// # `CamelCaseThing`
+   |       ~~~~~~~~~~~~~~~~
 
 error: item in documentation is missing backticks
   --> $DIR/doc-fixable.rs:104:22
    |
 LL | /// Not a title #897 CamelCaseThing
-   |                      ^^^^^^^^^^^^^^ help: try: ``CamelCaseThing``
+   |                      ^^^^^^^^^^^^^^
+   |
+help: try
+   |
+LL | /// Not a title #897 `CamelCaseThing`
+   |                      ~~~~~~~~~~~~~~~~
 
 error: item in documentation is missing backticks
   --> $DIR/doc-fixable.rs:105:5
    |
 LL | /// be_sure_we_got_to_the_end_of_it
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: ``be_sure_we_got_to_the_end_of_it``
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: try
+   |
+LL | /// `be_sure_we_got_to_the_end_of_it`
+   |     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 error: item in documentation is missing backticks
   --> $DIR/doc-fixable.rs:112:5
    |
 LL | /// be_sure_we_got_to_the_end_of_it
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: ``be_sure_we_got_to_the_end_of_it``
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: try
+   |
+LL | /// `be_sure_we_got_to_the_end_of_it`
+   |     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 error: item in documentation is missing backticks
   --> $DIR/doc-fixable.rs:125:5
    |
 LL | /// be_sure_we_got_to_the_end_of_it
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: ``be_sure_we_got_to_the_end_of_it``
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: try
+   |
+LL | /// `be_sure_we_got_to_the_end_of_it`
+   |     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 error: item in documentation is missing backticks
   --> $DIR/doc-fixable.rs:136:43
    |
 LL | /** E.g., serialization of an empty list: FooBar
-   |                                           ^^^^^^ help: try: ``FooBar``
+   |                                           ^^^^^^
+   |
+help: try
+   |
+LL | /** E.g., serialization of an empty list: `FooBar`
+   |                                           ~~~~~~~~
 
 error: item in documentation is missing backticks
   --> $DIR/doc-fixable.rs:141:5
    |
 LL | And BarQuz too.
-   |     ^^^^^^ help: try: ``BarQuz``
+   |     ^^^^^^
+   |
+help: try
+   |
+LL | And `BarQuz` too.
+   |     ~~~~~~~~
 
 error: item in documentation is missing backticks
   --> $DIR/doc-fixable.rs:142:1
    |
 LL | be_sure_we_got_to_the_end_of_it
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: ``be_sure_we_got_to_the_end_of_it``
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: try
+   |
+LL | `be_sure_we_got_to_the_end_of_it`
+   |
 
 error: item in documentation is missing backticks
   --> $DIR/doc-fixable.rs:147:43
    |
 LL | /** E.g., serialization of an empty list: FooBar
-   |                                           ^^^^^^ help: try: ``FooBar``
+   |                                           ^^^^^^
+   |
+help: try
+   |
+LL | /** E.g., serialization of an empty list: `FooBar`
+   |                                           ~~~~~~~~
 
 error: item in documentation is missing backticks
   --> $DIR/doc-fixable.rs:152:5
    |
 LL | And BarQuz too.
-   |     ^^^^^^ help: try: ``BarQuz``
+   |     ^^^^^^
+   |
+help: try
+   |
+LL | And `BarQuz` too.
+   |     ~~~~~~~~
 
 error: item in documentation is missing backticks
   --> $DIR/doc-fixable.rs:153:1
    |
 LL | be_sure_we_got_to_the_end_of_it
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: ``be_sure_we_got_to_the_end_of_it``
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: try
+   |
+LL | `be_sure_we_got_to_the_end_of_it`
+   |
 
 error: item in documentation is missing backticks
   --> $DIR/doc-fixable.rs:164:5
    |
 LL | /// be_sure_we_got_to_the_end_of_it
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: ``be_sure_we_got_to_the_end_of_it``
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: try
+   |
+LL | /// `be_sure_we_got_to_the_end_of_it`
+   |     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 error: item in documentation is missing backticks
   --> $DIR/doc-fixable.rs:183:22
    |
 LL | /// An iterator over mycrate::Collection's values.
-   |                      ^^^^^^^^^^^^^^^^^^^ help: try: ``mycrate::Collection``
+   |                      ^^^^^^^^^^^^^^^^^^^
+   |
+help: try
+   |
+LL | /// An iterator over `mycrate::Collection`'s values.
+   |                      ~~~~~~~~~~~~~~~~~~~~~
 
 error: aborting due to 30 previous errors
 
diff --git a/tests/ui/doc/unbalanced_ticks.stderr b/tests/ui/doc/unbalanced_ticks.stderr
index 9670e5c24fb..a462b98871a 100644
--- a/tests/ui/doc/unbalanced_ticks.stderr
+++ b/tests/ui/doc/unbalanced_ticks.stderr
@@ -22,7 +22,12 @@ error: item in documentation is missing backticks
   --> $DIR/unbalanced_ticks.rs:15:32
    |
 LL | /// This paragraph is fine and should_be linted normally.
-   |                                ^^^^^^^^^ help: try: ``should_be``
+   |                                ^^^^^^^^^
+   |
+help: try
+   |
+LL | /// This paragraph is fine and `should_be` linted normally.
+   |                                ~~~~~~~~~~~
 
 error: backticks are unbalanced
   --> $DIR/unbalanced_ticks.rs:17:1
@@ -36,7 +41,12 @@ error: item in documentation is missing backticks
   --> $DIR/unbalanced_ticks.rs:30:8
    |
 LL | /// ## not_fine
-   |        ^^^^^^^^ help: try: ``not_fine``
+   |        ^^^^^^^^
+   |
+help: try
+   |
+LL | /// ## `not_fine`
+   |        ~~~~~~~~~~
 
 error: backticks are unbalanced
   --> $DIR/unbalanced_ticks.rs:32:1
@@ -58,7 +68,12 @@ error: item in documentation is missing backticks
   --> $DIR/unbalanced_ticks.rs:35:23
    |
 LL | /// - This item needs backticks_here
-   |                       ^^^^^^^^^^^^^^ help: try: ``backticks_here``
+   |                       ^^^^^^^^^^^^^^
+   |
+help: try
+   |
+LL | /// - This item needs `backticks_here`
+   |                       ~~~~~~~~~~~~~~~~
 
 error: aborting due to 8 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 846c0bef075922032ea21a42750fdadfe2542e5a Mon Sep 17 00:00:00 2001
From: surechen <chenshuo17@huawei.com>
Date: Fri, 19 Nov 2021 16:46:34 +0800
Subject: Fixes #7915

Fix shadow_same's positive false for async function's params:

Example Code:
```rust
#![deny(clippy::shadow_same)]

pub async fn foo(_a: i32) {
}
```
Output:
```
error: `_a` is shadowed by itself in `_a
```

Hir:
```rust
pub async fn foo(_a: i32)
 ->
     /*impl Trait*/ #[lang = "from_generator"](move |mut _task_context|
                                                   {
                                                       let _a = _a;
                                                       { let _t = { }; _t }
                                                   })
```

Skip checking async function's params.

changelog: Fix shadow_same's positive false for async function's params
---
 clippy_lints/src/shadow.rs |  7 ++++++-
 tests/ui/shadow.rs         |  6 ++++++
 tests/ui/shadow.stderr     | 14 +++++++++++++-
 3 files changed, 25 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/shadow.rs b/clippy_lints/src/shadow.rs
index 5f82aed872c..f6880af0cab 100644
--- a/clippy_lints/src/shadow.rs
+++ b/clippy_lints/src/shadow.rs
@@ -105,11 +105,16 @@ impl<'tcx> LateLintPass<'tcx> for Shadow {
             PatKind::Binding(_, hir_id, ident, _) => (hir_id, ident),
             _ => return,
         };
+
+        if pat.span.desugaring_kind().is_some() {
+            return;
+        }
+
         if ident.span.from_expansion() || ident.span.is_dummy() {
             return;
         }
-        let HirId { owner, local_id } = id;
 
+        let HirId { owner, local_id } = id;
         // get (or insert) the list of items for this owner and symbol
         let data = self.bindings.last_mut().unwrap();
         let items_with_name = data.entry(ident.name).or_default();
diff --git a/tests/ui/shadow.rs b/tests/ui/shadow.rs
index 55caef59f7f..06f6949b66f 100644
--- a/tests/ui/shadow.rs
+++ b/tests/ui/shadow.rs
@@ -79,4 +79,10 @@ fn question_mark() -> Option<()> {
     None
 }
 
+pub async fn foo1(_a: i32) {}
+
+pub async fn foo2(_a: i32, _b: i64) {
+    let _b = _a;
+}
+
 fn main() {}
diff --git a/tests/ui/shadow.stderr b/tests/ui/shadow.stderr
index feed6e1ba8b..dcc7d4e6b2f 100644
--- a/tests/ui/shadow.stderr
+++ b/tests/ui/shadow.stderr
@@ -241,5 +241,17 @@ note: previous binding is here
 LL |     let _ = |[x]: [u32; 1]| {
    |               ^
 
-error: aborting due to 20 previous errors
+error: `_b` shadows a previous, unrelated binding
+  --> $DIR/shadow.rs:85:9
+   |
+LL |     let _b = _a;
+   |         ^^
+   |
+note: previous binding is here
+  --> $DIR/shadow.rs:84:28
+   |
+LL | pub async fn foo2(_a: i32, _b: i64) {
+   |                            ^^
+
+error: aborting due to 21 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 850e7f533e8dc8ed37957550e88be0b0e34d7170 Mon Sep 17 00:00:00 2001
From: Georg Brandl <georg@python.org>
Date: Sun, 21 Nov 2021 16:06:19 +0100
Subject: `octal_escapes`: updates from review, fix byte string prefix

---
 clippy_lints/src/octal_escapes.rs |  44 ++++++--------
 tests/ui/octal_escapes.rs         |   8 +++
 tests/ui/octal_escapes.stderr     | 118 ++++++++++++++++++++++++++++++++++----
 3 files changed, 131 insertions(+), 39 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/octal_escapes.rs b/clippy_lints/src/octal_escapes.rs
index 9ae269bc7d9..b3a4ab121e1 100644
--- a/clippy_lints/src/octal_escapes.rs
+++ b/clippy_lints/src/octal_escapes.rs
@@ -9,8 +9,8 @@ use rustc_span::Span;
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for `\0` escapes in string and byte literals that look like octal character
-    /// escapes in C
+    /// Checks for `\0` escapes in string and byte literals that look like octal
+    /// character escapes in C.
     ///
     /// ### Why is this bad?
     /// Rust does not support octal notation for character escapes. `\0` is always a
@@ -57,20 +57,18 @@ impl EarlyLintPass for OctalEscapes {
 
 fn check_lit(cx: &EarlyContext<'tcx>, lit: &Lit, span: Span, is_string: bool) {
     let contents = lit.symbol.as_str();
-    let mut iter = contents.char_indices();
+    let mut iter = contents.char_indices().peekable();
 
     // go through the string, looking for \0[0-7]
     while let Some((from, ch)) = iter.next() {
         if ch == '\\' {
-            if let Some((mut to, '0')) = iter.next() {
-                // collect all further potentially octal digits
-                while let Some((j, '0'..='7')) = iter.next() {
-                    to = j + 1;
-                }
-                // if it's more than just `\0` we have a match
-                if to > from + 2 {
-                    emit(cx, &contents, from, to, span, is_string);
-                    return;
+            if let Some((_, '0')) = iter.next() {
+                // collect up to two further octal digits
+                if let Some((mut to, '0'..='7')) = iter.next() {
+                    if let Some((_, '0'..='7')) = iter.peek() {
+                        to += 1;
+                    }
+                    emit(cx, &contents, from, to + 1, span, is_string);
                 }
             }
         }
@@ -80,19 +78,9 @@ fn check_lit(cx: &EarlyContext<'tcx>, lit: &Lit, span: Span, is_string: bool) {
 fn emit(cx: &EarlyContext<'tcx>, contents: &str, from: usize, to: usize, span: Span, is_string: bool) {
     // construct a replacement escape for that case that octal was intended
     let escape = &contents[from + 1..to];
-    let literal_suggestion = if is_string {
-        u32::from_str_radix(escape, 8).ok().and_then(|n| {
-            if n < 256 {
-                Some(format!("\\x{:02x}", n))
-            } else if n <= std::char::MAX as u32 {
-                Some(format!("\\u{{{:x}}}", n))
-            } else {
-                None
-            }
-        })
-    } else {
-        u8::from_str_radix(escape, 8).ok().map(|n| format!("\\x{:02x}", n))
-    };
+    // the maximum value is \077, or \x3f
+    let literal_suggestion = u8::from_str_radix(escape, 8).ok().map(|n| format!("\\x{:02x}", n));
+    let prefix = if is_string { "" } else { "b" };
 
     span_lint_and_then(
         cx,
@@ -111,8 +99,8 @@ fn emit(cx: &EarlyContext<'tcx>, contents: &str, from: usize, to: usize, span: S
             if let Some(sugg) = literal_suggestion {
                 diag.span_suggestion(
                     span,
-                    "if an octal escape is intended, use",
-                    format!("\"{}{}{}\"", &contents[..from], sugg, &contents[to..]),
+                    "if an octal escape was intended, use the hexadecimal representation instead",
+                    format!("{}\"{}{}{}\"", prefix, &contents[..from], sugg, &contents[to..]),
                     Applicability::MaybeIncorrect,
                 );
             }
@@ -123,7 +111,7 @@ fn emit(cx: &EarlyContext<'tcx>, contents: &str, from: usize, to: usize, span: S
                     "if the null {} is intended, disambiguate using",
                     if is_string { "character" } else { "byte" }
                 ),
-                format!("\"{}\\x00{}\"", &contents[..from], &contents[from + 2..]),
+                format!("{}\"{}\\x00{}\"", prefix, &contents[..from], &contents[from + 2..]),
                 Applicability::MaybeIncorrect,
             );
         },
diff --git a/tests/ui/octal_escapes.rs b/tests/ui/octal_escapes.rs
index 5ddee73c020..53145ef0fd2 100644
--- a/tests/ui/octal_escapes.rs
+++ b/tests/ui/octal_escapes.rs
@@ -4,9 +4,17 @@ fn main() {
     let _bad1 = "\033[0m";
     let _bad2 = b"\033[0m";
     let _bad3 = "\\\033[0m";
+    // maximum 3 digits (\012 is the escape)
     let _bad4 = "\01234567";
     let _bad5 = "\0\03";
+    let _bad6 = "Text-\055\077-MoreText";
+    let _bad7 = "EvenMoreText-\01\02-ShortEscapes";
+    let _bad8 = "锈\01锈";
+    let _bad9 = "锈\011锈";
 
     let _good1 = "\\033[0m";
     let _good2 = "\0\\0";
+    let _good3 = "\0\0";
+    let _good4 = "X\0\0X";
+    let _good5 = "锈\0锈";
 }
diff --git a/tests/ui/octal_escapes.stderr b/tests/ui/octal_escapes.stderr
index 8a93e781bed..8c27dc0cf05 100644
--- a/tests/ui/octal_escapes.stderr
+++ b/tests/ui/octal_escapes.stderr
@@ -6,7 +6,7 @@ LL |     let _bad1 = "/033[0m";
    |
    = note: `-D clippy::octal-escapes` implied by `-D warnings`
    = help: octal escapes are not supported, `/0` is always a null character
-help: if an octal escape is intended, use
+help: if an octal escape was intended, use the hexadecimal representation instead
    |
 LL |     let _bad1 = "/x1b[0m";
    |                 ~~~~~~~~~
@@ -22,14 +22,14 @@ LL |     let _bad2 = b"/033[0m";
    |                 ^^^^^^^^^^
    |
    = help: octal escapes are not supported, `/0` is always a null byte
-help: if an octal escape is intended, use
+help: if an octal escape was intended, use the hexadecimal representation instead
    |
-LL |     let _bad2 = "/x1b[0m";
-   |                 ~~~~~~~~~
+LL |     let _bad2 = b"/x1b[0m";
+   |                 ~~~~~~~~~~
 help: if the null byte is intended, disambiguate using
    |
-LL |     let _bad2 = "/x0033[0m";
-   |                 ~~~~~~~~~~~
+LL |     let _bad2 = b"/x0033[0m";
+   |                 ~~~~~~~~~~~~
 
 error: octal-looking escape in string literal
   --> $DIR/octal_escapes.rs:6:17
@@ -38,7 +38,7 @@ LL |     let _bad3 = "//033[0m";
    |                 ^^^^^^^^^^^
    |
    = help: octal escapes are not supported, `/0` is always a null character
-help: if an octal escape is intended, use
+help: if an octal escape was intended, use the hexadecimal representation instead
    |
 LL |     let _bad3 = "//x1b[0m";
    |                 ~~~~~~~~~~~
@@ -48,20 +48,116 @@ LL |     let _bad3 = "//x0033[0m";
    |                 ~~~~~~~~~~~~~
 
 error: octal-looking escape in string literal
-  --> $DIR/octal_escapes.rs:7:17
+  --> $DIR/octal_escapes.rs:8:17
    |
 LL |     let _bad4 = "/01234567";
    |                 ^^^^^^^^^^^
    |
    = help: octal escapes are not supported, `/0` is always a null character
-help: if an octal escape is intended, use
+help: if an octal escape was intended, use the hexadecimal representation instead
    |
-LL |     let _bad4 = "/u{53977}";
+LL |     let _bad4 = "/x0a34567";
    |                 ~~~~~~~~~~~
 help: if the null character is intended, disambiguate using
    |
 LL |     let _bad4 = "/x001234567";
    |                 ~~~~~~~~~~~~~
 
-error: aborting due to 4 previous errors
+error: octal-looking escape in string literal
+  --> $DIR/octal_escapes.rs:10:17
+   |
+LL |     let _bad6 = "Text-/055/077-MoreText";
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: octal escapes are not supported, `/0` is always a null character
+help: if an octal escape was intended, use the hexadecimal representation instead
+   |
+LL |     let _bad6 = "Text-/x2d/077-MoreText";
+   |                 ~~~~~~~~~~~~~~~~~~~~~~~~
+help: if the null character is intended, disambiguate using
+   |
+LL |     let _bad6 = "Text-/x0055/077-MoreText";
+   |                 ~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+error: octal-looking escape in string literal
+  --> $DIR/octal_escapes.rs:10:17
+   |
+LL |     let _bad6 = "Text-/055/077-MoreText";
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: octal escapes are not supported, `/0` is always a null character
+help: if an octal escape was intended, use the hexadecimal representation instead
+   |
+LL |     let _bad6 = "Text-/055/x3f-MoreText";
+   |                 ~~~~~~~~~~~~~~~~~~~~~~~~
+help: if the null character is intended, disambiguate using
+   |
+LL |     let _bad6 = "Text-/055/x0077-MoreText";
+   |                 ~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+error: octal-looking escape in string literal
+  --> $DIR/octal_escapes.rs:11:17
+   |
+LL |     let _bad7 = "EvenMoreText-/01/02-ShortEscapes";
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: octal escapes are not supported, `/0` is always a null character
+help: if an octal escape was intended, use the hexadecimal representation instead
+   |
+LL |     let _bad7 = "EvenMoreText-/x01/02-ShortEscapes";
+   |                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+help: if the null character is intended, disambiguate using
+   |
+LL |     let _bad7 = "EvenMoreText-/x001/02-ShortEscapes";
+   |                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+error: octal-looking escape in string literal
+  --> $DIR/octal_escapes.rs:11:17
+   |
+LL |     let _bad7 = "EvenMoreText-/01/02-ShortEscapes";
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: octal escapes are not supported, `/0` is always a null character
+help: if an octal escape was intended, use the hexadecimal representation instead
+   |
+LL |     let _bad7 = "EvenMoreText-/01/x02-ShortEscapes";
+   |                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+help: if the null character is intended, disambiguate using
+   |
+LL |     let _bad7 = "EvenMoreText-/01/x002-ShortEscapes";
+   |                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+error: octal-looking escape in string literal
+  --> $DIR/octal_escapes.rs:12:17
+   |
+LL |     let _bad8 = "锈/01锈";
+   |                 ^^^^^^^^^
+   |
+   = help: octal escapes are not supported, `/0` is always a null character
+help: if an octal escape was intended, use the hexadecimal representation instead
+   |
+LL |     let _bad8 = "锈/x01锈";
+   |                 ~~~~~~~~~~
+help: if the null character is intended, disambiguate using
+   |
+LL |     let _bad8 = "锈/x001锈";
+   |                 ~~~~~~~~~~~
+
+error: octal-looking escape in string literal
+  --> $DIR/octal_escapes.rs:13:17
+   |
+LL |     let _bad9 = "锈/011锈";
+   |                 ^^^^^^^^^^
+   |
+   = help: octal escapes are not supported, `/0` is always a null character
+help: if an octal escape was intended, use the hexadecimal representation instead
+   |
+LL |     let _bad9 = "锈/x09锈";
+   |                 ~~~~~~~~~~
+help: if the null character is intended, disambiguate using
+   |
+LL |     let _bad9 = "锈/x0011锈";
+   |                 ~~~~~~~~~~~~
+
+error: aborting due to 10 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 0bc25d04c6aed8a40f415b9a8eaaeb136feda0e3 Mon Sep 17 00:00:00 2001
From: Georg Brandl <georg@python.org>
Date: Mon, 22 Nov 2021 18:18:16 +0100
Subject: octal_escapes: emit only one lint for all cases found each literal

---
 clippy_lints/src/octal_escapes.rs | 69 +++++++++++++++++++++++++++------------
 tests/ui/octal_escapes.stderr     | 46 ++++----------------------
 2 files changed, 55 insertions(+), 60 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/octal_escapes.rs b/clippy_lints/src/octal_escapes.rs
index b3a4ab121e1..0e27be25985 100644
--- a/clippy_lints/src/octal_escapes.rs
+++ b/clippy_lints/src/octal_escapes.rs
@@ -6,6 +6,7 @@ use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::Span;
+use std::fmt::Write;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -13,9 +14,14 @@ declare_clippy_lint! {
     /// character escapes in C.
     ///
     /// ### Why is this bad?
-    /// Rust does not support octal notation for character escapes. `\0` is always a
-    /// null byte/character, and any following digits do not form part of the escape
-    /// sequence.
+    ///
+    /// C and other languages support octal character escapes in strings, where
+    /// a backslash is followed by up to three octal digits. For example, `\033`
+    /// stands for the ASCII character 27 (ESC). Rust does not support this
+    /// notation, but has the escape code `\0` which stands for a null
+    /// byte/character, and any following digits do not form part of the escape
+    /// sequence. Therefore, `\033` is not a compiler error but the result may
+    /// be surprising.
     ///
     /// ### Known problems
     /// The actual meaning can be the intended one. `\x00` can be used in these
@@ -58,8 +64,9 @@ impl EarlyLintPass for OctalEscapes {
 fn check_lit(cx: &EarlyContext<'tcx>, lit: &Lit, span: Span, is_string: bool) {
     let contents = lit.symbol.as_str();
     let mut iter = contents.char_indices().peekable();
+    let mut found = vec![];
 
-    // go through the string, looking for \0[0-7]
+    // go through the string, looking for \0[0-7][0-7]?
     while let Some((from, ch)) = iter.next() {
         if ch == '\\' {
             if let Some((_, '0')) = iter.next() {
@@ -68,19 +75,41 @@ fn check_lit(cx: &EarlyContext<'tcx>, lit: &Lit, span: Span, is_string: bool) {
                     if let Some((_, '0'..='7')) = iter.peek() {
                         to += 1;
                     }
-                    emit(cx, &contents, from, to + 1, span, is_string);
+                    found.push((from, to + 1));
                 }
             }
         }
     }
-}
 
-fn emit(cx: &EarlyContext<'tcx>, contents: &str, from: usize, to: usize, span: Span, is_string: bool) {
-    // construct a replacement escape for that case that octal was intended
-    let escape = &contents[from + 1..to];
-    // the maximum value is \077, or \x3f
-    let literal_suggestion = u8::from_str_radix(escape, 8).ok().map(|n| format!("\\x{:02x}", n));
-    let prefix = if is_string { "" } else { "b" };
+    if found.is_empty() {
+        return;
+    }
+
+    // construct two suggestion strings, one with \x escapes with octal meaning
+    // as in C, and one with \x00 for null bytes.
+    let mut suggest_1 = if is_string { "\"" } else { "b\"" }.to_string();
+    let mut suggest_2 = suggest_1.clone();
+    let mut index = 0;
+    for (from, to) in found {
+        suggest_1.push_str(&contents[index..from]);
+        suggest_2.push_str(&contents[index..from]);
+
+        // construct a replacement escape
+        // the maximum value is \077, or \x3f, so u8 is sufficient here
+        if let Ok(n) = u8::from_str_radix(&contents[from + 1..to], 8) {
+            write!(&mut suggest_1, "\\x{:02x}", n).unwrap();
+        }
+
+        // append the null byte as \x00 and the following digits literally
+        suggest_2.push_str("\\x00");
+        suggest_2.push_str(&contents[from + 2..to]);
+
+        index = to;
+    }
+    suggest_1.push_str(&contents[index..]);
+    suggest_1.push('"');
+    suggest_2.push_str(&contents[index..]);
+    suggest_2.push('"');
 
     span_lint_and_then(
         cx,
@@ -96,14 +125,12 @@ fn emit(cx: &EarlyContext<'tcx>, contents: &str, from: usize, to: usize, span: S
                 if is_string { "character" } else { "byte" }
             ));
             // suggestion 1: equivalent hex escape
-            if let Some(sugg) = literal_suggestion {
-                diag.span_suggestion(
-                    span,
-                    "if an octal escape was intended, use the hexadecimal representation instead",
-                    format!("{}\"{}{}{}\"", prefix, &contents[..from], sugg, &contents[to..]),
-                    Applicability::MaybeIncorrect,
-                );
-            }
+            diag.span_suggestion(
+                span,
+                "if an octal escape was intended, use the hexadecimal representation instead",
+                suggest_1,
+                Applicability::MaybeIncorrect,
+            );
             // suggestion 2: unambiguous null byte
             diag.span_suggestion(
                 span,
@@ -111,7 +138,7 @@ fn emit(cx: &EarlyContext<'tcx>, contents: &str, from: usize, to: usize, span: S
                     "if the null {} is intended, disambiguate using",
                     if is_string { "character" } else { "byte" }
                 ),
-                format!("{}\"{}\\x00{}\"", prefix, &contents[..from], &contents[from + 2..]),
+                suggest_2,
                 Applicability::MaybeIncorrect,
             );
         },
diff --git a/tests/ui/octal_escapes.stderr b/tests/ui/octal_escapes.stderr
index 8c27dc0cf05..54f5bbb0fc4 100644
--- a/tests/ui/octal_escapes.stderr
+++ b/tests/ui/octal_escapes.stderr
@@ -72,28 +72,12 @@ LL |     let _bad6 = "Text-/055/077-MoreText";
    = help: octal escapes are not supported, `/0` is always a null character
 help: if an octal escape was intended, use the hexadecimal representation instead
    |
-LL |     let _bad6 = "Text-/x2d/077-MoreText";
+LL |     let _bad6 = "Text-/x2d/x3f-MoreText";
    |                 ~~~~~~~~~~~~~~~~~~~~~~~~
 help: if the null character is intended, disambiguate using
    |
-LL |     let _bad6 = "Text-/x0055/077-MoreText";
-   |                 ~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-error: octal-looking escape in string literal
-  --> $DIR/octal_escapes.rs:10:17
-   |
-LL |     let _bad6 = "Text-/055/077-MoreText";
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: octal escapes are not supported, `/0` is always a null character
-help: if an octal escape was intended, use the hexadecimal representation instead
-   |
-LL |     let _bad6 = "Text-/055/x3f-MoreText";
-   |                 ~~~~~~~~~~~~~~~~~~~~~~~~
-help: if the null character is intended, disambiguate using
-   |
-LL |     let _bad6 = "Text-/055/x0077-MoreText";
-   |                 ~~~~~~~~~~~~~~~~~~~~~~~~~~
+LL |     let _bad6 = "Text-/x0055/x0077-MoreText";
+   |                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 error: octal-looking escape in string literal
   --> $DIR/octal_escapes.rs:11:17
@@ -104,28 +88,12 @@ LL |     let _bad7 = "EvenMoreText-/01/02-ShortEscapes";
    = help: octal escapes are not supported, `/0` is always a null character
 help: if an octal escape was intended, use the hexadecimal representation instead
    |
-LL |     let _bad7 = "EvenMoreText-/x01/02-ShortEscapes";
-   |                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-help: if the null character is intended, disambiguate using
-   |
-LL |     let _bad7 = "EvenMoreText-/x001/02-ShortEscapes";
+LL |     let _bad7 = "EvenMoreText-/x01/x02-ShortEscapes";
    |                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-error: octal-looking escape in string literal
-  --> $DIR/octal_escapes.rs:11:17
-   |
-LL |     let _bad7 = "EvenMoreText-/01/02-ShortEscapes";
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: octal escapes are not supported, `/0` is always a null character
-help: if an octal escape was intended, use the hexadecimal representation instead
-   |
-LL |     let _bad7 = "EvenMoreText-/01/x02-ShortEscapes";
-   |                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 help: if the null character is intended, disambiguate using
    |
-LL |     let _bad7 = "EvenMoreText-/01/x002-ShortEscapes";
-   |                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+LL |     let _bad7 = "EvenMoreText-/x001/x002-ShortEscapes";
+   |                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 error: octal-looking escape in string literal
   --> $DIR/octal_escapes.rs:12:17
@@ -159,5 +127,5 @@ help: if the null character is intended, disambiguate using
 LL |     let _bad9 = "锈/x0011锈";
    |                 ~~~~~~~~~~~~
 
-error: aborting due to 10 previous errors
+error: aborting due to 8 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 1210bb40d35829672744c1d58f3614723a7e1bad Mon Sep 17 00:00:00 2001
From: Georg Brandl <georg@python.org>
Date: Mon, 22 Nov 2021 21:02:03 +0100
Subject: octal_escapes: note on print!() format strings

---
 clippy_lints/src/octal_escapes.rs | 4 ++++
 1 file changed, 4 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/octal_escapes.rs b/clippy_lints/src/octal_escapes.rs
index 0e27be25985..9c971437645 100644
--- a/clippy_lints/src/octal_escapes.rs
+++ b/clippy_lints/src/octal_escapes.rs
@@ -27,6 +27,10 @@ declare_clippy_lint! {
     /// The actual meaning can be the intended one. `\x00` can be used in these
     /// cases to be unambigious.
     ///
+    /// The lint does not trigger for format strings in `print!()`, `write!()`
+    /// and friends since the string is already preprocessed when Clippy lints
+    /// can see it.
+    ///
     /// # Example
     /// ```rust
     /// // Bad
-- 
cgit 1.4.1-3-g733a5


From ec3d1c8ca31c392e50c3605d461a9ee6f929c97c Mon Sep 17 00:00:00 2001
From: dswij <dswijj@gmail.com>
Date: Tue, 16 Nov 2021 13:39:52 +0800
Subject: Fix FP on `if_then_some_else_none` when there is early return

---
 clippy_lints/src/if_then_some_else_none.rs | 13 +++++++++++--
 tests/ui/if_then_some_else_none.rs         | 11 +++++++++++
 2 files changed, 22 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/if_then_some_else_none.rs b/clippy_lints/src/if_then_some_else_none.rs
index d95f5d41071..30d222bd7d2 100644
--- a/clippy_lints/src/if_then_some_else_none.rs
+++ b/clippy_lints/src/if_then_some_else_none.rs
@@ -1,9 +1,9 @@
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::source::snippet_with_macro_callsite;
-use clippy_utils::{higher, is_else_clause, is_lang_ctor, meets_msrv, msrvs};
+use clippy_utils::{contains_return, higher, is_else_clause, is_lang_ctor, meets_msrv, msrvs};
 use if_chain::if_chain;
 use rustc_hir::LangItem::{OptionNone, OptionSome};
-use rustc_hir::{Expr, ExprKind};
+use rustc_hir::{Expr, ExprKind, Stmt, StmtKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_semver::RustcVersion;
@@ -82,6 +82,7 @@ impl LateLintPass<'_> for IfThenSomeElseNone {
             if let Some(els_expr) = els_block.expr;
             if let ExprKind::Path(ref qpath) = els_expr.kind;
             if is_lang_ctor(cx, qpath, OptionNone);
+            if !stmts_contains_early_return(then_block.stmts);
             then {
                 let cond_snip = snippet_with_macro_callsite(cx, cond.span, "[condition]");
                 let cond_snip = if matches!(cond.kind, ExprKind::Unary(_, _) | ExprKind::Binary(_, _, _)) {
@@ -114,3 +115,11 @@ impl LateLintPass<'_> for IfThenSomeElseNone {
 
     extract_msrv_attr!(LateContext);
 }
+
+fn stmts_contains_early_return(stmts: &[Stmt<'_>]) -> bool {
+    stmts.iter().any(|stmt| {
+        let Stmt { kind: StmtKind::Semi(e), .. } = stmt else { return false };
+
+        contains_return(e)
+    })
+}
diff --git a/tests/ui/if_then_some_else_none.rs b/tests/ui/if_then_some_else_none.rs
index 54789bf9320..3bc3a039524 100644
--- a/tests/ui/if_then_some_else_none.rs
+++ b/tests/ui/if_then_some_else_none.rs
@@ -102,3 +102,14 @@ fn into_some<T>(v: T) -> Option<T> {
 fn into_none<T>() -> Option<T> {
     None
 }
+
+// Should not warn
+fn f(b: bool, v: Option<()>) -> Option<()> {
+    if b {
+        v?; // This is a potential early return, is not equivalent with `bool::then`
+
+        Some(())
+    } else {
+        None
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 3957244120444d2ff9a5e43a0a2df97d79168174 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Thu, 18 Nov 2021 13:54:49 +0000
Subject: Add `needless_late_init` lint

---
 CHANGELOG.md                                |   1 +
 clippy_lints/src/lib.register_all.rs        |   1 +
 clippy_lints/src/lib.register_lints.rs      |   1 +
 clippy_lints/src/lib.register_style.rs      |   1 +
 clippy_lints/src/lib.rs                     |   2 +
 clippy_lints/src/needless_late_init.rs      | 345 ++++++++++++++++++++++++++++
 clippy_lints/src/no_effect.rs               |   9 +-
 tests/ui/let_if_seq.stderr                  |  43 +++-
 tests/ui/min_max.rs                         |   7 +-
 tests/ui/min_max.stderr                     |  26 +--
 tests/ui/needless_late_init.rs              | 133 +++++++++++
 tests/ui/needless_late_init.stderr          | 108 +++++++++
 tests/ui/needless_late_init_fixable.fixed   |  38 +++
 tests/ui/needless_late_init_fixable.rs      |  38 +++
 tests/ui/needless_late_init_fixable.stderr  | 103 +++++++++
 tests/ui/redundant_closure_call_late.rs     |   1 +
 tests/ui/redundant_closure_call_late.stderr |   6 +-
 tests/ui/redundant_else.rs                  |   2 +-
 18 files changed, 838 insertions(+), 27 deletions(-)
 create mode 100644 clippy_lints/src/needless_late_init.rs
 create mode 100644 tests/ui/needless_late_init.rs
 create mode 100644 tests/ui/needless_late_init.stderr
 create mode 100644 tests/ui/needless_late_init_fixable.fixed
 create mode 100644 tests/ui/needless_late_init_fixable.rs
 create mode 100644 tests/ui/needless_late_init_fixable.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 401557b3eac..157ea0c963a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3033,6 +3033,7 @@ Released 2018-09-13
 [`needless_continue`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_continue
 [`needless_doctest_main`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_doctest_main
 [`needless_for_each`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_for_each
+[`needless_late_init`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_late_init
 [`needless_lifetimes`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_lifetimes
 [`needless_option_as_deref`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_option_as_deref
 [`needless_pass_by_value`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_pass_by_value
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 612240135ac..04912120e27 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -206,6 +206,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(needless_bool::BOOL_COMPARISON),
     LintId::of(needless_bool::NEEDLESS_BOOL),
     LintId::of(needless_borrowed_ref::NEEDLESS_BORROWED_REFERENCE),
+    LintId::of(needless_late_init::NEEDLESS_LATE_INIT),
     LintId::of(needless_option_as_deref::NEEDLESS_OPTION_AS_DEREF),
     LintId::of(needless_question_mark::NEEDLESS_QUESTION_MARK),
     LintId::of(needless_update::NEEDLESS_UPDATE),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 19c35a5e5f4..bb159e50373 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -362,6 +362,7 @@ store.register_lints(&[
     needless_borrowed_ref::NEEDLESS_BORROWED_REFERENCE,
     needless_continue::NEEDLESS_CONTINUE,
     needless_for_each::NEEDLESS_FOR_EACH,
+    needless_late_init::NEEDLESS_LATE_INIT,
     needless_option_as_deref::NEEDLESS_OPTION_AS_DEREF,
     needless_pass_by_value::NEEDLESS_PASS_BY_VALUE,
     needless_question_mark::NEEDLESS_QUESTION_MARK,
diff --git a/clippy_lints/src/lib.register_style.rs b/clippy_lints/src/lib.register_style.rs
index f336441ea84..ea87e7e7a73 100644
--- a/clippy_lints/src/lib.register_style.rs
+++ b/clippy_lints/src/lib.register_style.rs
@@ -82,6 +82,7 @@ store.register_group(true, "clippy::style", Some("clippy_style"), vec![
     LintId::of(misc_early::REDUNDANT_PATTERN),
     LintId::of(mut_mutex_lock::MUT_MUTEX_LOCK),
     LintId::of(mut_reference::UNNECESSARY_MUT_PASSED),
+    LintId::of(needless_late_init::NEEDLESS_LATE_INIT),
     LintId::of(neg_multiply::NEG_MULTIPLY),
     LintId::of(new_without_default::NEW_WITHOUT_DEFAULT),
     LintId::of(non_copy_const::BORROW_INTERIOR_MUTABLE_CONST),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 3dafdf8f0d5..bd9710ec407 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -299,6 +299,7 @@ mod needless_bool;
 mod needless_borrowed_ref;
 mod needless_continue;
 mod needless_for_each;
+mod needless_late_init;
 mod needless_option_as_deref;
 mod needless_pass_by_value;
 mod needless_question_mark;
@@ -851,6 +852,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(move || Box::new(format_args::FormatArgs));
     store.register_late_pass(|| Box::new(trailing_empty_array::TrailingEmptyArray));
     store.register_early_pass(|| Box::new(octal_escapes::OctalEscapes));
+    store.register_late_pass(|| Box::new(needless_late_init::NeedlessLateInit));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/needless_late_init.rs b/clippy_lints/src/needless_late_init.rs
new file mode 100644
index 00000000000..d2f040dc36a
--- /dev/null
+++ b/clippy_lints/src/needless_late_init.rs
@@ -0,0 +1,345 @@
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::path_to_local;
+use clippy_utils::source::snippet_opt;
+use clippy_utils::visitors::{expr_visitor, is_local_used};
+use rustc_errors::Applicability;
+use rustc_hir::intravisit::Visitor;
+use rustc_hir::{Block, Expr, ExprKind, HirId, Local, LocalSource, MatchSource, Node, Pat, PatKind, Stmt, StmtKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::Span;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for late initializations that can be replaced by a let statement
+    /// with an initializer.
+    ///
+    /// ### Why is this bad?
+    /// Assigning in the let statement is less repetitive.
+    ///
+    /// ### Example
+    /// ```rust
+    /// let a;
+    /// a = 1;
+    ///
+    /// let b;
+    /// match 3 {
+    ///     0 => b = "zero",
+    ///     1 => b = "one",
+    ///     _ => b = "many",
+    /// }
+    ///
+    /// let c;
+    /// if true {
+    ///     c = 1;
+    /// } else {
+    ///     c = -1;
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// let a = 1;
+    ///
+    /// let b = match 3 {
+    ///     0 => "zero",
+    ///     1 => "one",
+    ///     _ => "many",
+    /// };
+    ///
+    /// let c = if true {
+    ///     1
+    /// } else {
+    ///     -1
+    /// };
+    /// ```
+    #[clippy::version = "1.58.0"]
+    pub NEEDLESS_LATE_INIT,
+    style,
+    "late initializations that can be replaced by a let statement with an initializer"
+}
+declare_lint_pass!(NeedlessLateInit => [NEEDLESS_LATE_INIT]);
+
+fn contains_assign_expr<'tcx>(cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'tcx>) -> bool {
+    let mut seen = false;
+    expr_visitor(cx, |expr| {
+        if let ExprKind::Assign(..) = expr.kind {
+            seen = true;
+        }
+
+        !seen
+    })
+    .visit_stmt(stmt);
+
+    seen
+}
+
+#[derive(Debug)]
+struct LocalAssign {
+    lhs_id: HirId,
+    lhs_span: Span,
+    rhs_span: Span,
+    span: Span,
+}
+
+impl LocalAssign {
+    fn from_expr(expr: &Expr<'_>, span: Span) -> Option<Self> {
+        if let ExprKind::Assign(lhs, rhs, _) = expr.kind {
+            if lhs.span.from_expansion() {
+                return None;
+            }
+
+            Some(Self {
+                lhs_id: path_to_local(lhs)?,
+                lhs_span: lhs.span,
+                rhs_span: rhs.span.source_callsite(),
+                span,
+            })
+        } else {
+            None
+        }
+    }
+
+    fn new<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, binding_id: HirId) -> Option<LocalAssign> {
+        let assign = match expr.kind {
+            ExprKind::Block(Block { expr: Some(expr), .. }, _) => Self::from_expr(expr, expr.span),
+            ExprKind::Block(block, _) => {
+                if_chain! {
+                    if let Some((last, other_stmts)) = block.stmts.split_last();
+                    if let StmtKind::Expr(expr) | StmtKind::Semi(expr) = last.kind;
+
+                    let assign = Self::from_expr(expr, last.span)?;
+
+                    // avoid visiting if not needed
+                    if assign.lhs_id == binding_id;
+                    if other_stmts.iter().all(|stmt| !contains_assign_expr(cx, stmt));
+
+                    then {
+                        Some(assign)
+                    } else {
+                        None
+                    }
+                }
+            },
+            ExprKind::Assign(..) => Self::from_expr(expr, expr.span),
+            _ => None,
+        }?;
+
+        if assign.lhs_id == binding_id {
+            Some(assign)
+        } else {
+            None
+        }
+    }
+}
+
+fn assignment_suggestions<'tcx>(
+    cx: &LateContext<'tcx>,
+    binding_id: HirId,
+    exprs: impl IntoIterator<Item = &'tcx Expr<'tcx>>,
+) -> Option<(Applicability, Vec<(Span, String)>)> {
+    let mut assignments = Vec::new();
+
+    for expr in exprs {
+        let ty = cx.typeck_results().expr_ty(expr);
+
+        if ty.is_never() {
+            continue;
+        }
+        if !ty.is_unit() {
+            return None;
+        }
+
+        let assign = LocalAssign::new(cx, expr, binding_id)?;
+
+        assignments.push(assign);
+    }
+
+    let suggestions = assignments
+        .into_iter()
+        .map(|assignment| Some((assignment.span, snippet_opt(cx, assignment.rhs_span)?)))
+        .collect::<Option<Vec<(Span, String)>>>()?;
+
+    let applicability = if suggestions.len() > 1 {
+        // multiple suggestions don't work with rustfix in multipart_suggest
+        // https://github.com/rust-lang/rustfix/issues/141
+        Applicability::Unspecified
+    } else {
+        Applicability::MachineApplicable
+    };
+    Some((applicability, suggestions))
+}
+
+struct Usage<'tcx> {
+    stmt: &'tcx Stmt<'tcx>,
+    expr: &'tcx Expr<'tcx>,
+    needs_semi: bool,
+}
+
+fn first_usage<'tcx>(
+    cx: &LateContext<'tcx>,
+    binding_id: HirId,
+    local_stmt_id: HirId,
+    block: &'tcx Block<'tcx>,
+) -> Option<Usage<'tcx>> {
+    block
+        .stmts
+        .iter()
+        .skip_while(|stmt| stmt.hir_id != local_stmt_id)
+        .skip(1)
+        .find(|&stmt| is_local_used(cx, stmt, binding_id))
+        .and_then(|stmt| match stmt.kind {
+            StmtKind::Expr(expr) => Some(Usage {
+                stmt,
+                expr,
+                needs_semi: true,
+            }),
+            StmtKind::Semi(expr) => Some(Usage {
+                stmt,
+                expr,
+                needs_semi: false,
+            }),
+            _ => None,
+        })
+}
+
+fn local_snippet_without_semicolon(cx: &LateContext<'_>, local: &Local<'_>) -> Option<String> {
+    let span = local.span.with_hi(match local.ty {
+        // let <pat>: <ty>;
+        // ~~~~~~~~~~~~~~~
+        Some(ty) => ty.span.hi(),
+        // let <pat>;
+        // ~~~~~~~~~
+        None => local.pat.span.hi(),
+    });
+
+    snippet_opt(cx, span)
+}
+
+fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    local: &'tcx Local<'tcx>,
+    local_stmt: &'tcx Stmt<'tcx>,
+    block: &'tcx Block<'tcx>,
+    binding_id: HirId,
+) -> Option<()> {
+    let usage = first_usage(cx, binding_id, local_stmt.hir_id, block)?;
+    let binding_name = cx.tcx.hir().opt_name(binding_id)?;
+    let let_snippet = local_snippet_without_semicolon(cx, local)?;
+
+    match usage.expr.kind {
+        ExprKind::Assign(..) => {
+            let assign = LocalAssign::new(cx, usage.expr, binding_id)?;
+
+            span_lint_and_then(
+                cx,
+                NEEDLESS_LATE_INIT,
+                local_stmt.span,
+                "unneeded late initalization",
+                |diag| {
+                    diag.tool_only_span_suggestion(
+                        local_stmt.span,
+                        "remove the local",
+                        String::new(),
+                        Applicability::MachineApplicable,
+                    );
+
+                    diag.span_suggestion(
+                        assign.lhs_span,
+                        &format!("declare `{}` here", binding_name),
+                        let_snippet,
+                        Applicability::MachineApplicable,
+                    );
+                },
+            );
+        },
+        ExprKind::If(_, then_expr, Some(else_expr)) => {
+            let (applicability, suggestions) = assignment_suggestions(cx, binding_id, [then_expr, else_expr])?;
+
+            span_lint_and_then(
+                cx,
+                NEEDLESS_LATE_INIT,
+                local_stmt.span,
+                "unneeded late initalization",
+                |diag| {
+                    diag.tool_only_span_suggestion(local_stmt.span, "remove the local", String::new(), applicability);
+
+                    diag.span_suggestion_verbose(
+                        usage.stmt.span.shrink_to_lo(),
+                        &format!("declare `{}` here", binding_name),
+                        format!("{} = ", let_snippet),
+                        applicability,
+                    );
+
+                    diag.multipart_suggestion("remove the assignments from the branches", suggestions, applicability);
+
+                    if usage.needs_semi {
+                        diag.span_suggestion(
+                            usage.stmt.span.shrink_to_hi(),
+                            "add a semicolon after the if expression",
+                            ";".to_string(),
+                            applicability,
+                        );
+                    }
+                },
+            );
+        },
+        ExprKind::Match(_, arms, MatchSource::Normal) => {
+            let (applicability, suggestions) = assignment_suggestions(cx, binding_id, arms.iter().map(|arm| arm.body))?;
+
+            span_lint_and_then(
+                cx,
+                NEEDLESS_LATE_INIT,
+                local_stmt.span,
+                "unneeded late initalization",
+                |diag| {
+                    diag.tool_only_span_suggestion(local_stmt.span, "remove the local", String::new(), applicability);
+
+                    diag.span_suggestion_verbose(
+                        usage.stmt.span.shrink_to_lo(),
+                        &format!("declare `{}` here", binding_name),
+                        format!("{} = ", let_snippet),
+                        applicability,
+                    );
+
+                    diag.multipart_suggestion("remove the assignments from the match arms", suggestions, applicability);
+
+                    if usage.needs_semi {
+                        diag.span_suggestion(
+                            usage.stmt.span.shrink_to_hi(),
+                            "add a semicolon after the match expression",
+                            ";".to_string(),
+                            applicability,
+                        );
+                    }
+                },
+            );
+        },
+        _ => {},
+    };
+
+    Some(())
+}
+
+impl LateLintPass<'tcx> for NeedlessLateInit {
+    fn check_local(&mut self, cx: &LateContext<'tcx>, local: &'tcx Local<'tcx>) {
+        let mut parents = cx.tcx.hir().parent_iter(local.hir_id);
+
+        if_chain! {
+            if let Local {
+                init: None,
+                pat: &Pat {
+                    kind: PatKind::Binding(_, binding_id, _, None),
+                    ..
+                },
+                source: LocalSource::Normal,
+                ..
+            } = local;
+            if let Some((_, Node::Stmt(local_stmt))) = parents.next();
+            if let Some((_, Node::Block(block))) = parents.next();
+
+            then {
+                check(cx, local, local_stmt, block, binding_id);
+            }
+        }
+    }
+}
diff --git a/clippy_lints/src/no_effect.rs b/clippy_lints/src/no_effect.rs
index cd54de3ee4b..6fcc9ca29b9 100644
--- a/clippy_lints/src/no_effect.rs
+++ b/clippy_lints/src/no_effect.rs
@@ -164,12 +164,13 @@ fn check_unnecessary_operation(cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) {
         if !&reduced.iter().any(|e| e.span.from_expansion());
         then {
             if let ExprKind::Index(..) = &expr.kind {
-                let snippet;
-                if let (Some(arr), Some(func)) = (snippet_opt(cx, reduced[0].span), snippet_opt(cx, reduced[1].span)) {
-                    snippet = format!("assert!({}.len() > {});", &arr, &func);
+                let snippet = if let (Some(arr), Some(func)) =
+                    (snippet_opt(cx, reduced[0].span), snippet_opt(cx, reduced[1].span))
+                {
+                    format!("assert!({}.len() > {});", &arr, &func)
                 } else {
                     return;
-                }
+                };
                 span_lint_hir_and_then(
                     cx,
                     UNNECESSARY_OPERATION,
diff --git a/tests/ui/let_if_seq.stderr b/tests/ui/let_if_seq.stderr
index 9cf2e10a5ee..3a522628fea 100644
--- a/tests/ui/let_if_seq.stderr
+++ b/tests/ui/let_if_seq.stderr
@@ -1,3 +1,23 @@
+error: unneeded late initalization
+  --> $DIR/let_if_seq.rs:48:5
+   |
+LL |     let foo;
+   |     ^^^^^^^^
+   |
+   = note: `-D clippy::needless-late-init` implied by `-D warnings`
+help: declare `foo` here
+   |
+LL |     let foo = if f() {
+   |     +++++++++
+help: remove the assignments from the branches
+   |
+LL |         0
+   |
+help: add a semicolon after the if expression
+   |
+LL |     };
+   |      +
+
 error: `if _ { .. } else { .. }` is an expression
   --> $DIR/let_if_seq.rs:65:5
    |
@@ -46,5 +66,26 @@ LL | |     }
    |
    = note: you might not need `mut` at all
 
-error: aborting due to 4 previous errors
+error: unneeded late initalization
+  --> $DIR/let_if_seq.rs:78:5
+   |
+LL |     let quz;
+   |     ^^^^^^^^
+   |
+help: declare `quz` here
+   |
+LL |     let quz = if f() {
+   |     +++++++++
+help: remove the assignments from the branches
+   |
+LL ~         42
+LL |     } else {
+LL ~         0
+   |
+help: add a semicolon after the if expression
+   |
+LL |     };
+   |      +
+
+error: aborting due to 6 previous errors
 
diff --git a/tests/ui/min_max.rs b/tests/ui/min_max.rs
index f7ed72a11cf..b2bc97f4744 100644
--- a/tests/ui/min_max.rs
+++ b/tests/ui/min_max.rs
@@ -19,8 +19,7 @@ impl NotOrd {
 }
 
 fn main() {
-    let x;
-    x = 2usize;
+    let x = 2usize;
     min(1, max(3, x));
     min(max(3, x), 1);
     max(min(x, 1), 3);
@@ -35,9 +34,7 @@ fn main() {
     let y = 2isize;
     min(max(y, -1), 3);
 
-    let s;
-    s = "Hello";
-
+    let s = "Hello";
     min("Apple", max("Zoo", s));
     max(min(s, "Apple"), "Zoo");
 
diff --git a/tests/ui/min_max.stderr b/tests/ui/min_max.stderr
index 9f8e26fa406..c70b77eabbd 100644
--- a/tests/ui/min_max.stderr
+++ b/tests/ui/min_max.stderr
@@ -1,5 +1,5 @@
 error: this `min`/`max` combination leads to constant result
-  --> $DIR/min_max.rs:24:5
+  --> $DIR/min_max.rs:23:5
    |
 LL |     min(1, max(3, x));
    |     ^^^^^^^^^^^^^^^^^
@@ -7,73 +7,73 @@ LL |     min(1, max(3, x));
    = note: `-D clippy::min-max` implied by `-D warnings`
 
 error: this `min`/`max` combination leads to constant result
-  --> $DIR/min_max.rs:25:5
+  --> $DIR/min_max.rs:24:5
    |
 LL |     min(max(3, x), 1);
    |     ^^^^^^^^^^^^^^^^^
 
 error: this `min`/`max` combination leads to constant result
-  --> $DIR/min_max.rs:26:5
+  --> $DIR/min_max.rs:25:5
    |
 LL |     max(min(x, 1), 3);
    |     ^^^^^^^^^^^^^^^^^
 
 error: this `min`/`max` combination leads to constant result
-  --> $DIR/min_max.rs:27:5
+  --> $DIR/min_max.rs:26:5
    |
 LL |     max(3, min(x, 1));
    |     ^^^^^^^^^^^^^^^^^
 
 error: this `min`/`max` combination leads to constant result
-  --> $DIR/min_max.rs:29:5
+  --> $DIR/min_max.rs:28:5
    |
 LL |     my_max(3, my_min(x, 1));
    |     ^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this `min`/`max` combination leads to constant result
-  --> $DIR/min_max.rs:41:5
+  --> $DIR/min_max.rs:38:5
    |
 LL |     min("Apple", max("Zoo", s));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this `min`/`max` combination leads to constant result
-  --> $DIR/min_max.rs:42:5
+  --> $DIR/min_max.rs:39:5
    |
 LL |     max(min(s, "Apple"), "Zoo");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this `min`/`max` combination leads to constant result
-  --> $DIR/min_max.rs:47:5
+  --> $DIR/min_max.rs:44:5
    |
 LL |     x.min(1).max(3);
    |     ^^^^^^^^^^^^^^^
 
 error: this `min`/`max` combination leads to constant result
-  --> $DIR/min_max.rs:48:5
+  --> $DIR/min_max.rs:45:5
    |
 LL |     x.max(3).min(1);
    |     ^^^^^^^^^^^^^^^
 
 error: this `min`/`max` combination leads to constant result
-  --> $DIR/min_max.rs:49:5
+  --> $DIR/min_max.rs:46:5
    |
 LL |     f.max(3f32).min(1f32);
    |     ^^^^^^^^^^^^^^^^^^^^^
 
 error: this `min`/`max` combination leads to constant result
-  --> $DIR/min_max.rs:55:5
+  --> $DIR/min_max.rs:52:5
    |
 LL |     max(x.min(1), 3);
    |     ^^^^^^^^^^^^^^^^
 
 error: this `min`/`max` combination leads to constant result
-  --> $DIR/min_max.rs:58:5
+  --> $DIR/min_max.rs:55:5
    |
 LL |     s.max("Zoo").min("Apple");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this `min`/`max` combination leads to constant result
-  --> $DIR/min_max.rs:59:5
+  --> $DIR/min_max.rs:56:5
    |
 LL |     s.min("Apple").max("Zoo");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/needless_late_init.rs b/tests/ui/needless_late_init.rs
new file mode 100644
index 00000000000..37b3cb34e2a
--- /dev/null
+++ b/tests/ui/needless_late_init.rs
@@ -0,0 +1,133 @@
+#![allow(unused)]
+
+fn main() {
+    let a;
+    let n = 1;
+    match n {
+        1 => a = "one",
+        _ => {
+            a = "two";
+        },
+    }
+
+    let b;
+    if n == 3 {
+        b = "four";
+    } else {
+        b = "five"
+    }
+
+    let c;
+    if let Some(n) = Some(5) {
+        c = n;
+    } else {
+        c = -50;
+    }
+
+    let d;
+    if true {
+        let temp = 5;
+        d = temp;
+    } else {
+        d = 15;
+    }
+
+    let e;
+    if true {
+        e = format!("{} {}", a, b);
+    } else {
+        e = format!("{}", c);
+    }
+
+    println!("{}", a);
+}
+
+fn does_not_lint() {
+    let z;
+    if false {
+        z = 1;
+    }
+
+    let x;
+    let y;
+    if true {
+        x = 1;
+    } else {
+        y = 1;
+    }
+
+    let mut x;
+    if true {
+        x = 5;
+        x = 10 / x;
+    } else {
+        x = 2;
+    }
+
+    let x;
+    let _ = match 1 {
+        1 => x = 10,
+        _ => x = 20,
+    };
+
+    // using tuples would be possible, but not always preferable
+    let x;
+    let y;
+    if true {
+        x = 1;
+        y = 2;
+    } else {
+        x = 3;
+        y = 4;
+    }
+
+    // could match with a smarter heuristic to avoid multiple assignments
+    let x;
+    if true {
+        let mut y = 5;
+        y = 6;
+        x = y;
+    } else {
+        x = 2;
+    }
+
+    let (x, y);
+    if true {
+        x = 1;
+    } else {
+        x = 2;
+    }
+    y = 3;
+
+    macro_rules! assign {
+        ($i:ident) => {
+            $i = 1;
+        };
+    }
+    let x;
+    assign!(x);
+
+    let x;
+    if true {
+        assign!(x);
+    } else {
+        x = 2;
+    }
+
+    macro_rules! in_macro {
+        () => {
+            let x;
+            x = 1;
+
+            let x;
+            if true {
+                x = 1;
+            } else {
+                x = 2;
+            }
+        };
+    }
+    in_macro!();
+
+    println!("{}", x);
+}
diff --git a/tests/ui/needless_late_init.stderr b/tests/ui/needless_late_init.stderr
new file mode 100644
index 00000000000..ece50773f45
--- /dev/null
+++ b/tests/ui/needless_late_init.stderr
@@ -0,0 +1,108 @@
+error: unneeded late initalization
+  --> $DIR/needless_late_init.rs:4:5
+   |
+LL |     let a;
+   |     ^^^^^^
+   |
+   = note: `-D clippy::needless-late-init` implied by `-D warnings`
+help: declare `a` here
+   |
+LL |     let a = match n {
+   |     +++++++
+help: remove the assignments from the match arms
+   |
+LL ~         1 => "one",
+LL |         _ => {
+LL ~             "two"
+   |
+help: add a semicolon after the match expression
+   |
+LL |     };
+   |      +
+
+error: unneeded late initalization
+  --> $DIR/needless_late_init.rs:13:5
+   |
+LL |     let b;
+   |     ^^^^^^
+   |
+help: declare `b` here
+   |
+LL |     let b = if n == 3 {
+   |     +++++++
+help: remove the assignments from the branches
+   |
+LL ~         "four"
+LL |     } else {
+LL ~         "five"
+   |
+help: add a semicolon after the if expression
+   |
+LL |     };
+   |      +
+
+error: unneeded late initalization
+  --> $DIR/needless_late_init.rs:20:5
+   |
+LL |     let c;
+   |     ^^^^^^
+   |
+help: declare `c` here
+   |
+LL |     let c = if let Some(n) = Some(5) {
+   |     +++++++
+help: remove the assignments from the branches
+   |
+LL ~         n
+LL |     } else {
+LL ~         -50
+   |
+help: add a semicolon after the if expression
+   |
+LL |     };
+   |      +
+
+error: unneeded late initalization
+  --> $DIR/needless_late_init.rs:27:5
+   |
+LL |     let d;
+   |     ^^^^^^
+   |
+help: declare `d` here
+   |
+LL |     let d = if true {
+   |     +++++++
+help: remove the assignments from the branches
+   |
+LL ~         temp
+LL |     } else {
+LL ~         15
+   |
+help: add a semicolon after the if expression
+   |
+LL |     };
+   |      +
+
+error: unneeded late initalization
+  --> $DIR/needless_late_init.rs:35:5
+   |
+LL |     let e;
+   |     ^^^^^^
+   |
+help: declare `e` here
+   |
+LL |     let e = if true {
+   |     +++++++
+help: remove the assignments from the branches
+   |
+LL ~         format!("{} {}", a, b)
+LL |     } else {
+LL ~         format!("{}", c)
+   |
+help: add a semicolon after the if expression
+   |
+LL |     };
+   |      +
+
+error: aborting due to 5 previous errors
+
diff --git a/tests/ui/needless_late_init_fixable.fixed b/tests/ui/needless_late_init_fixable.fixed
new file mode 100644
index 00000000000..32d5d04fde4
--- /dev/null
+++ b/tests/ui/needless_late_init_fixable.fixed
@@ -0,0 +1,38 @@
+// run-rustfix
+
+#![allow(unused, clippy::assign_op_pattern)]
+
+fn main() {
+    
+    let a = "zero";
+
+    
+    
+    let b = 1;
+    let c = 2;
+
+    
+    let d: usize = 1;
+
+    
+    let mut e = 1;
+    e = 2;
+
+    
+    let f = match 1 {
+        1 => "three",
+        _ => return,
+    }; // has semi
+
+    
+    let g: usize = if true {
+        5
+    } else {
+        panic!();
+    };
+
+    
+    let h = format!("{}", e);
+
+    println!("{}", a);
+}
diff --git a/tests/ui/needless_late_init_fixable.rs b/tests/ui/needless_late_init_fixable.rs
new file mode 100644
index 00000000000..6bc85f68632
--- /dev/null
+++ b/tests/ui/needless_late_init_fixable.rs
@@ -0,0 +1,38 @@
+// run-rustfix
+
+#![allow(unused, clippy::assign_op_pattern)]
+
+fn main() {
+    let a;
+    a = "zero";
+
+    let b;
+    let c;
+    b = 1;
+    c = 2;
+
+    let d: usize;
+    d = 1;
+
+    let mut e;
+    e = 1;
+    e = 2;
+
+    let f;
+    match 1 {
+        1 => f = "three",
+        _ => return,
+    }; // has semi
+
+    let g: usize;
+    if true {
+        g = 5;
+    } else {
+        panic!();
+    }
+
+    let h;
+    h = format!("{}", e);
+
+    println!("{}", a);
+}
diff --git a/tests/ui/needless_late_init_fixable.stderr b/tests/ui/needless_late_init_fixable.stderr
new file mode 100644
index 00000000000..05491496cd7
--- /dev/null
+++ b/tests/ui/needless_late_init_fixable.stderr
@@ -0,0 +1,103 @@
+error: unneeded late initalization
+  --> $DIR/needless_late_init_fixable.rs:6:5
+   |
+LL |     let a;
+   |     ^^^^^^
+   |
+   = note: `-D clippy::needless-late-init` implied by `-D warnings`
+help: declare `a` here
+   |
+LL |     let a = "zero";
+   |     ~~~~~
+
+error: unneeded late initalization
+  --> $DIR/needless_late_init_fixable.rs:9:5
+   |
+LL |     let b;
+   |     ^^^^^^
+   |
+help: declare `b` here
+   |
+LL |     let b = 1;
+   |     ~~~~~
+
+error: unneeded late initalization
+  --> $DIR/needless_late_init_fixable.rs:10:5
+   |
+LL |     let c;
+   |     ^^^^^^
+   |
+help: declare `c` here
+   |
+LL |     let c = 2;
+   |     ~~~~~
+
+error: unneeded late initalization
+  --> $DIR/needless_late_init_fixable.rs:14:5
+   |
+LL |     let d: usize;
+   |     ^^^^^^^^^^^^^
+   |
+help: declare `d` here
+   |
+LL |     let d: usize = 1;
+   |     ~~~~~~~~~~~~
+
+error: unneeded late initalization
+  --> $DIR/needless_late_init_fixable.rs:17:5
+   |
+LL |     let mut e;
+   |     ^^^^^^^^^^
+   |
+help: declare `e` here
+   |
+LL |     let mut e = 1;
+   |     ~~~~~~~~~
+
+error: unneeded late initalization
+  --> $DIR/needless_late_init_fixable.rs:21:5
+   |
+LL |     let f;
+   |     ^^^^^^
+   |
+help: declare `f` here
+   |
+LL |     let f = match 1 {
+   |     +++++++
+help: remove the assignments from the match arms
+   |
+LL |         1 => "three",
+   |              ~~~~~~~
+
+error: unneeded late initalization
+  --> $DIR/needless_late_init_fixable.rs:27:5
+   |
+LL |     let g: usize;
+   |     ^^^^^^^^^^^^^
+   |
+help: declare `g` here
+   |
+LL |     let g: usize = if true {
+   |     ++++++++++++++
+help: remove the assignments from the branches
+   |
+LL |         5
+   |
+help: add a semicolon after the if expression
+   |
+LL |     };
+   |      +
+
+error: unneeded late initalization
+  --> $DIR/needless_late_init_fixable.rs:34:5
+   |
+LL |     let h;
+   |     ^^^^^^
+   |
+help: declare `h` here
+   |
+LL |     let h = format!("{}", e);
+   |     ~~~~~
+
+error: aborting due to 8 previous errors
+
diff --git a/tests/ui/redundant_closure_call_late.rs b/tests/ui/redundant_closure_call_late.rs
index 1f4864b7289..5612827bd39 100644
--- a/tests/ui/redundant_closure_call_late.rs
+++ b/tests/ui/redundant_closure_call_late.rs
@@ -1,6 +1,7 @@
 // non rustfixable, see redundant_closure_call_fixable.rs
 
 #![warn(clippy::redundant_closure_call)]
+#![allow(clippy::needless_late_init)]
 
 fn main() {
     let mut i = 1;
diff --git a/tests/ui/redundant_closure_call_late.stderr b/tests/ui/redundant_closure_call_late.stderr
index 7c8865f1bd3..4eca43a2b59 100644
--- a/tests/ui/redundant_closure_call_late.stderr
+++ b/tests/ui/redundant_closure_call_late.stderr
@@ -1,5 +1,5 @@
 error: closure called just once immediately after it was declared
-  --> $DIR/redundant_closure_call_late.rs:15:5
+  --> $DIR/redundant_closure_call_late.rs:16:5
    |
 LL |     i = redun_closure();
    |     ^^^^^^^^^^^^^^^^^^^
@@ -7,13 +7,13 @@ LL |     i = redun_closure();
    = note: `-D clippy::redundant-closure-call` implied by `-D warnings`
 
 error: closure called just once immediately after it was declared
-  --> $DIR/redundant_closure_call_late.rs:19:5
+  --> $DIR/redundant_closure_call_late.rs:20:5
    |
 LL |     i = shadowed_closure();
    |     ^^^^^^^^^^^^^^^^^^^^^^
 
 error: closure called just once immediately after it was declared
-  --> $DIR/redundant_closure_call_late.rs:21:5
+  --> $DIR/redundant_closure_call_late.rs:22:5
    |
 LL |     i = shadowed_closure();
    |     ^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/redundant_else.rs b/tests/ui/redundant_else.rs
index e8a6e940c01..64f566735cd 100644
--- a/tests/ui/redundant_else.rs
+++ b/tests/ui/redundant_else.rs
@@ -1,5 +1,5 @@
 #![warn(clippy::redundant_else)]
-#![allow(clippy::needless_return, clippy::if_same_then_else)]
+#![allow(clippy::needless_return, clippy::if_same_then_else, clippy::needless_late_init)]
 
 fn main() {
     loop {
-- 
cgit 1.4.1-3-g733a5


From c0bad8bcab1cb3365e813de97c1f122e64b04510 Mon Sep 17 00:00:00 2001
From: Dharma Saputra Wijaya <dswijj@gmail.com>
Date: Thu, 25 Nov 2021 09:10:50 +0800
Subject: Add more descriptive help info for `needless_question_mark`

---
 clippy_lints/src/needless_question_mark.rs | 33 ++++++++++++++++++------------
 tests/ui/needless_question_mark.stderr     | 24 +++++++++++-----------
 2 files changed, 32 insertions(+), 25 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/needless_question_mark.rs b/clippy_lints/src/needless_question_mark.rs
index 3ca933ea8fb..1ffed6a0524 100644
--- a/clippy_lints/src/needless_question_mark.rs
+++ b/clippy_lints/src/needless_question_mark.rs
@@ -93,10 +93,16 @@ impl LateLintPass<'_> for NeedlessQuestionMark {
 }
 
 fn check(cx: &LateContext<'_>, expr: &Expr<'_>) {
-    let inner_expr = if_chain! {
+    if_chain! {
         if let ExprKind::Call(path, [arg]) = &expr.kind;
         if let ExprKind::Path(ref qpath) = &path.kind;
-        if is_lang_ctor(cx, qpath, OptionSome) || is_lang_ctor(cx, qpath, ResultOk);
+        let sugg_remove = if is_lang_ctor(cx, qpath, OptionSome) {
+            "Some()"
+        } else if is_lang_ctor(cx, qpath, ResultOk) {
+            "Ok()"
+        } else {
+            return;
+        };
         if let ExprKind::Match(inner_expr_with_q, _, MatchSource::TryDesugar) = &arg.kind;
         if let ExprKind::Call(called, [inner_expr]) = &inner_expr_with_q.kind;
         if let ExprKind::Path(QPath::LangItem(LangItem::TryTraitBranch, _)) = &called.kind;
@@ -104,15 +110,16 @@ fn check(cx: &LateContext<'_>, expr: &Expr<'_>) {
         let expr_ty = cx.typeck_results().expr_ty(expr);
         let inner_ty = cx.typeck_results().expr_ty(inner_expr);
         if TyS::same_type(expr_ty, inner_ty);
-        then { inner_expr } else { return; }
-    };
-    span_lint_and_sugg(
-        cx,
-        NEEDLESS_QUESTION_MARK,
-        expr.span,
-        "question mark operator is useless here",
-        "try",
-        format!("{}", snippet(cx, inner_expr.span, r#""...""#)),
-        Applicability::MachineApplicable,
-    );
+        then {
+            span_lint_and_sugg(
+                cx,
+                NEEDLESS_QUESTION_MARK,
+                expr.span,
+                "question mark operator is useless here",
+                &format!("try removing question mark and `{}`", sugg_remove),
+                format!("{}", snippet(cx, inner_expr.span, r#""...""#)),
+                Applicability::MachineApplicable,
+            );
+        }
+    }
 }
diff --git a/tests/ui/needless_question_mark.stderr b/tests/ui/needless_question_mark.stderr
index 02bf50d077a..57c3d48c761 100644
--- a/tests/ui/needless_question_mark.stderr
+++ b/tests/ui/needless_question_mark.stderr
@@ -2,7 +2,7 @@ error: question mark operator is useless here
   --> $DIR/needless_question_mark.rs:23:12
    |
 LL |     return Some(to.magic?);
-   |            ^^^^^^^^^^^^^^^ help: try: `to.magic`
+   |            ^^^^^^^^^^^^^^^ help: try removing question mark and `Some()`: `to.magic`
    |
    = note: `-D clippy::needless-question-mark` implied by `-D warnings`
 
@@ -10,67 +10,67 @@ error: question mark operator is useless here
   --> $DIR/needless_question_mark.rs:31:12
    |
 LL |     return Some(to.magic?)
-   |            ^^^^^^^^^^^^^^^ help: try: `to.magic`
+   |            ^^^^^^^^^^^^^^^ help: try removing question mark and `Some()`: `to.magic`
 
 error: question mark operator is useless here
   --> $DIR/needless_question_mark.rs:36:5
    |
 LL |     Some(to.magic?)
-   |     ^^^^^^^^^^^^^^^ help: try: `to.magic`
+   |     ^^^^^^^^^^^^^^^ help: try removing question mark and `Some()`: `to.magic`
 
 error: question mark operator is useless here
   --> $DIR/needless_question_mark.rs:41:21
    |
 LL |     to.and_then(|t| Some(t.magic?))
-   |                     ^^^^^^^^^^^^^^ help: try: `t.magic`
+   |                     ^^^^^^^^^^^^^^ help: try removing question mark and `Some()`: `t.magic`
 
 error: question mark operator is useless here
   --> $DIR/needless_question_mark.rs:50:9
    |
 LL |         Some(t.magic?)
-   |         ^^^^^^^^^^^^^^ help: try: `t.magic`
+   |         ^^^^^^^^^^^^^^ help: try removing question mark and `Some()`: `t.magic`
 
 error: question mark operator is useless here
   --> $DIR/needless_question_mark.rs:55:12
    |
 LL |     return Ok(tr.magic?);
-   |            ^^^^^^^^^^^^^ help: try: `tr.magic`
+   |            ^^^^^^^^^^^^^ help: try removing question mark and `Ok()`: `tr.magic`
 
 error: question mark operator is useless here
   --> $DIR/needless_question_mark.rs:62:12
    |
 LL |     return Ok(tr.magic?)
-   |            ^^^^^^^^^^^^^ help: try: `tr.magic`
+   |            ^^^^^^^^^^^^^ help: try removing question mark and `Ok()`: `tr.magic`
 
 error: question mark operator is useless here
   --> $DIR/needless_question_mark.rs:66:5
    |
 LL |     Ok(tr.magic?)
-   |     ^^^^^^^^^^^^^ help: try: `tr.magic`
+   |     ^^^^^^^^^^^^^ help: try removing question mark and `Ok()`: `tr.magic`
 
 error: question mark operator is useless here
   --> $DIR/needless_question_mark.rs:70:21
    |
 LL |     tr.and_then(|t| Ok(t.magic?))
-   |                     ^^^^^^^^^^^^ help: try: `t.magic`
+   |                     ^^^^^^^^^^^^ help: try removing question mark and `Ok()`: `t.magic`
 
 error: question mark operator is useless here
   --> $DIR/needless_question_mark.rs:78:9
    |
 LL |         Ok(t.magic?)
-   |         ^^^^^^^^^^^^ help: try: `t.magic`
+   |         ^^^^^^^^^^^^ help: try removing question mark and `Ok()`: `t.magic`
 
 error: question mark operator is useless here
   --> $DIR/needless_question_mark.rs:85:16
    |
 LL |         return Ok(t.magic?);
-   |                ^^^^^^^^^^^^ help: try: `t.magic`
+   |                ^^^^^^^^^^^^ help: try removing question mark and `Ok()`: `t.magic`
 
 error: question mark operator is useless here
   --> $DIR/needless_question_mark.rs:120:27
    |
 LL |         || -> Option<_> { Some(Some($expr)?) }()
-   |                           ^^^^^^^^^^^^^^^^^^ help: try: `Some($expr)`
+   |                           ^^^^^^^^^^^^^^^^^^ help: try removing question mark and `Some()`: `Some($expr)`
 ...
 LL |     let _x = some_and_qmark_in_macro!(x?);
    |              ---------------------------- in this macro invocation
-- 
cgit 1.4.1-3-g733a5


From 063f8aa094a740b98b0dab49d8361441c8f1d0c4 Mon Sep 17 00:00:00 2001
From: Maybe Waffle <waffle.lapkin@gmail.com>
Date: Thu, 25 Nov 2021 11:50:57 +0300
Subject: Ignore associated types in traits when considering type complexity

---
 clippy_lints/src/types/mod.rs          |  8 +++++---
 tests/ui/type_complexity_issue_1013.rs | 23 +++++++++++++++++++++++
 2 files changed, 28 insertions(+), 3 deletions(-)
 create mode 100644 tests/ui/type_complexity_issue_1013.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types/mod.rs b/clippy_lints/src/types/mod.rs
index 5a7ef760a30..69cd49d884c 100644
--- a/clippy_lints/src/types/mod.rs
+++ b/clippy_lints/src/types/mod.rs
@@ -350,7 +350,7 @@ impl<'tcx> LateLintPass<'tcx> for Types {
 
     fn check_impl_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx ImplItem<'_>) {
         match item.kind {
-            ImplItemKind::Const(ty, _) | ImplItemKind::TyAlias(ty) => self.check_ty(
+            ImplItemKind::Const(ty, _) => self.check_ty(
                 cx,
                 ty,
                 CheckTyContext {
@@ -358,8 +358,10 @@ impl<'tcx> LateLintPass<'tcx> for Types {
                     ..CheckTyContext::default()
                 },
             ),
-            // methods are covered by check_fn
-            ImplItemKind::Fn(..) => (),
+            // Methods are covered by check_fn.
+            // Type aliases are ignored because oftentimes it's impossible to
+            // make type alias declaration in trait simpler, see #1013
+            ImplItemKind::Fn(..) | ImplItemKind::TyAlias(..) => (),
         }
     }
 
diff --git a/tests/ui/type_complexity_issue_1013.rs b/tests/ui/type_complexity_issue_1013.rs
new file mode 100644
index 00000000000..c68ab3aaf94
--- /dev/null
+++ b/tests/ui/type_complexity_issue_1013.rs
@@ -0,0 +1,23 @@
+#![warn(clippy::type_complexity)]
+use std::iter::{Filter, Map};
+use std::vec::IntoIter;
+
+struct S;
+
+impl IntoIterator for S {
+    type Item = i32;
+    // Should not warn since there is no way to simplify this
+    type IntoIter = Filter<Map<IntoIter<i32>, fn(i32) -> i32>, fn(&i32) -> bool>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        fn m(a: i32) -> i32 {
+            a
+        }
+        fn p(_: &i32) -> bool {
+            true
+        }
+        vec![1i32, 2, 3].into_iter().map(m as fn(_) -> _).filter(p)
+    }
+}
+
+fn main() {}
-- 
cgit 1.4.1-3-g733a5


From a745cc55f3e5658e90c971d6532529c2526bf87b Mon Sep 17 00:00:00 2001
From: togami2864 <tuabobo123@gmail.com>
Date: Fri, 26 Nov 2021 18:42:41 +0900
Subject: make non_ascii_literal to catch char

---
 clippy_lints/src/unicode.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unicode.rs b/clippy_lints/src/unicode.rs
index a514e8c44e2..b5e4bc75bd1 100644
--- a/clippy_lints/src/unicode.rs
+++ b/clippy_lints/src/unicode.rs
@@ -75,7 +75,7 @@ declare_lint_pass!(Unicode => [INVISIBLE_CHARACTERS, NON_ASCII_LITERAL, UNICODE_
 impl LateLintPass<'_> for Unicode {
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &'_ Expr<'_>) {
         if let ExprKind::Lit(ref lit) = expr.kind {
-            if let LitKind::Str(_, _) = lit.node {
+            if let LitKind::Str(_, _) |  LitKind::Char(_)= lit.node {
                 check_str(cx, lit.span, expr.hir_id);
             }
         }
-- 
cgit 1.4.1-3-g733a5


From e8ef6ca5e31f6cd648aca9c0cfe7a9743ec880d7 Mon Sep 17 00:00:00 2001
From: togami2864 <tuabobo123@gmail.com>
Date: Fri, 26 Nov 2021 18:49:14 +0900
Subject: fix stderr

---
 clippy_lints/src/unicode.rs |  2 +-
 tests/ui/unicode.stderr     | 14 +++++++++++++-
 2 files changed, 14 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unicode.rs b/clippy_lints/src/unicode.rs
index b5e4bc75bd1..82d7a1cbb8e 100644
--- a/clippy_lints/src/unicode.rs
+++ b/clippy_lints/src/unicode.rs
@@ -75,7 +75,7 @@ declare_lint_pass!(Unicode => [INVISIBLE_CHARACTERS, NON_ASCII_LITERAL, UNICODE_
 impl LateLintPass<'_> for Unicode {
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &'_ Expr<'_>) {
         if let ExprKind::Lit(ref lit) = expr.kind {
-            if let LitKind::Str(_, _) |  LitKind::Char(_)= lit.node {
+            if let LitKind::Str(_, _) | LitKind::Char(_) = lit.node {
                 check_str(cx, lit.span, expr.hir_id);
             }
         }
diff --git a/tests/ui/unicode.stderr b/tests/ui/unicode.stderr
index 3fca463c620..3f54e3880e7 100644
--- a/tests/ui/unicode.stderr
+++ b/tests/ui/unicode.stderr
@@ -34,5 +34,17 @@ LL |     print!("Üben!");
    |
    = note: `-D clippy::non-ascii-literal` implied by `-D warnings`
 
-error: aborting due to 5 previous errors
+error: literal non-ASCII character detected
+  --> $DIR/unicode.rs:26:32
+   |
+LL |     const _EMPTY_BLOCK: char = '▱';
+   |                                ^^^ help: consider replacing the string with: `'/u{25b1}'`
+
+error: literal non-ASCII character detected
+  --> $DIR/unicode.rs:27:31
+   |
+LL |     const _FULL_BLOCK: char = '▰';
+   |                               ^^^ help: consider replacing the string with: `'/u{25b0}'`
+
+error: aborting due to 7 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From e6a6ed44b20a50bb99cb3da56ff3b5fc31a84cac Mon Sep 17 00:00:00 2001
From: togami2864 <tuabobo123@gmail.com>
Date: Fri, 26 Nov 2021 18:52:27 +0900
Subject: fix doc

---
 clippy_lints/src/unicode.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unicode.rs b/clippy_lints/src/unicode.rs
index 82d7a1cbb8e..11d9705b8c6 100644
--- a/clippy_lints/src/unicode.rs
+++ b/clippy_lints/src/unicode.rs
@@ -28,7 +28,7 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for non-ASCII characters in string literals.
+    /// Checks for non-ASCII characters in string literals or char.
     ///
     /// ### Why is this bad?
     /// Yeah, we know, the 90's called and wanted their charset
-- 
cgit 1.4.1-3-g733a5


From cd8b72443dd4af41d12ae22848a456d4833b1313 Mon Sep 17 00:00:00 2001
From: togami2864 <tuabobo123@gmail.com>
Date: Fri, 26 Nov 2021 19:27:14 +0900
Subject: fix small nit

---
 clippy_lints/src/unicode.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unicode.rs b/clippy_lints/src/unicode.rs
index 11d9705b8c6..fbc4732e0ce 100644
--- a/clippy_lints/src/unicode.rs
+++ b/clippy_lints/src/unicode.rs
@@ -28,7 +28,7 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for non-ASCII characters in string literals or char.
+    /// Checks for non-ASCII characters in string and char literals.
     ///
     /// ### Why is this bad?
     /// Yeah, we know, the 90's called and wanted their charset
-- 
cgit 1.4.1-3-g733a5


From d346ec94fe3477ee2ee0cf41061a92c156db8701 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Fri, 26 Nov 2021 14:16:48 +0000
Subject: Add async/const fn tests for needless-late-init

+nits
---
 clippy_lints/src/needless_late_init.rs     | 16 +++++----
 tests/ui/let_if_seq.rs                     |  3 +-
 tests/ui/let_if_seq.stderr                 | 51 +++------------------------
 tests/ui/needless_late_init.rs             | 34 ++++++++++++++++++
 tests/ui/needless_late_init.stderr         | 56 ++++++++++++++++++++++++++----
 tests/ui/needless_late_init_fixable.stderr |  4 +--
 6 files changed, 102 insertions(+), 62 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/needless_late_init.rs b/clippy_lints/src/needless_late_init.rs
index d2f040dc36a..e0522f3fe0b 100644
--- a/clippy_lints/src/needless_late_init.rs
+++ b/clippy_lints/src/needless_late_init.rs
@@ -11,11 +11,11 @@ use rustc_span::Span;
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for late initializations that can be replaced by a let statement
+    /// Checks for late initializations that can be replaced by a `let` statement
     /// with an initializer.
     ///
     /// ### Why is this bad?
-    /// Assigning in the let statement is less repetitive.
+    /// Assigning in the `let` statement is less repetitive.
     ///
     /// ### Example
     /// ```rust
@@ -55,7 +55,7 @@ declare_clippy_lint! {
     #[clippy::version = "1.58.0"]
     pub NEEDLESS_LATE_INIT,
     style,
-    "late initializations that can be replaced by a let statement with an initializer"
+    "late initializations that can be replaced by a `let` statement with an initializer"
 }
 declare_lint_pass!(NeedlessLateInit => [NEEDLESS_LATE_INIT]);
 
@@ -275,7 +275,7 @@ fn check<'tcx>(
                     if usage.needs_semi {
                         diag.span_suggestion(
                             usage.stmt.span.shrink_to_hi(),
-                            "add a semicolon after the if expression",
+                            "add a semicolon after the `if` expression",
                             ";".to_string(),
                             applicability,
                         );
@@ -301,12 +301,16 @@ fn check<'tcx>(
                         applicability,
                     );
 
-                    diag.multipart_suggestion("remove the assignments from the match arms", suggestions, applicability);
+                    diag.multipart_suggestion(
+                        "remove the assignments from the `match` arms",
+                        suggestions,
+                        applicability,
+                    );
 
                     if usage.needs_semi {
                         diag.span_suggestion(
                             usage.stmt.span.shrink_to_hi(),
-                            "add a semicolon after the match expression",
+                            "add a semicolon after the `match` expression",
                             ";".to_string(),
                             applicability,
                         );
diff --git a/tests/ui/let_if_seq.rs b/tests/ui/let_if_seq.rs
index 2d8f3c2f0e7..c5cb2eb1fe1 100644
--- a/tests/ui/let_if_seq.rs
+++ b/tests/ui/let_if_seq.rs
@@ -3,7 +3,8 @@
     unused_assignments,
     clippy::similar_names,
     clippy::blacklisted_name,
-    clippy::branches_sharing_code
+    clippy::branches_sharing_code,
+    clippy::needless_late_init
 )]
 #![warn(clippy::useless_let_if_seq)]
 
diff --git a/tests/ui/let_if_seq.stderr b/tests/ui/let_if_seq.stderr
index 3a522628fea..271ccce681c 100644
--- a/tests/ui/let_if_seq.stderr
+++ b/tests/ui/let_if_seq.stderr
@@ -1,25 +1,5 @@
-error: unneeded late initalization
-  --> $DIR/let_if_seq.rs:48:5
-   |
-LL |     let foo;
-   |     ^^^^^^^^
-   |
-   = note: `-D clippy::needless-late-init` implied by `-D warnings`
-help: declare `foo` here
-   |
-LL |     let foo = if f() {
-   |     +++++++++
-help: remove the assignments from the branches
-   |
-LL |         0
-   |
-help: add a semicolon after the if expression
-   |
-LL |     };
-   |      +
-
 error: `if _ { .. } else { .. }` is an expression
-  --> $DIR/let_if_seq.rs:65:5
+  --> $DIR/let_if_seq.rs:66:5
    |
 LL | /     let mut foo = 0;
 LL | |     if f() {
@@ -31,7 +11,7 @@ LL | |     }
    = note: you might not need `mut` at all
 
 error: `if _ { .. } else { .. }` is an expression
-  --> $DIR/let_if_seq.rs:70:5
+  --> $DIR/let_if_seq.rs:71:5
    |
 LL | /     let mut bar = 0;
 LL | |     if f() {
@@ -45,7 +25,7 @@ LL | |     }
    = note: you might not need `mut` at all
 
 error: `if _ { .. } else { .. }` is an expression
-  --> $DIR/let_if_seq.rs:78:5
+  --> $DIR/let_if_seq.rs:79:5
    |
 LL | /     let quz;
 LL | |     if f() {
@@ -56,7 +36,7 @@ LL | |     }
    | |_____^ help: it is more idiomatic to write: `let quz = if f() { 42 } else { 0 };`
 
 error: `if _ { .. } else { .. }` is an expression
-  --> $DIR/let_if_seq.rs:107:5
+  --> $DIR/let_if_seq.rs:108:5
    |
 LL | /     let mut baz = 0;
 LL | |     if f() {
@@ -66,26 +46,5 @@ LL | |     }
    |
    = note: you might not need `mut` at all
 
-error: unneeded late initalization
-  --> $DIR/let_if_seq.rs:78:5
-   |
-LL |     let quz;
-   |     ^^^^^^^^
-   |
-help: declare `quz` here
-   |
-LL |     let quz = if f() {
-   |     +++++++++
-help: remove the assignments from the branches
-   |
-LL ~         42
-LL |     } else {
-LL ~         0
-   |
-help: add a semicolon after the if expression
-   |
-LL |     };
-   |      +
-
-error: aborting due to 6 previous errors
+error: aborting due to 4 previous errors
 
diff --git a/tests/ui/needless_late_init.rs b/tests/ui/needless_late_init.rs
index 37b3cb34e2a..6fdb4cc566f 100644
--- a/tests/ui/needless_late_init.rs
+++ b/tests/ui/needless_late_init.rs
@@ -42,6 +42,40 @@ fn main() {
     println!("{}", a);
 }
 
+async fn in_async() -> &'static str {
+    async fn f() -> &'static str {
+        "one"
+    }
+
+    let a;
+    let n = 1;
+    match n {
+        1 => a = f().await,
+        _ => {
+            a = "two";
+        },
+    }
+
+    a
+}
+
+const fn in_const() -> &'static str {
+    const fn f() -> &'static str {
+        "one"
+    }
+
+    let a;
+    let n = 1;
+    match n {
+        1 => a = f(),
+        _ => {
+            a = "two";
+        },
+    }
+
+    a
+}
+
 fn does_not_lint() {
     let z;
     if false {
diff --git a/tests/ui/needless_late_init.stderr b/tests/ui/needless_late_init.stderr
index ece50773f45..cbb7538c63b 100644
--- a/tests/ui/needless_late_init.stderr
+++ b/tests/ui/needless_late_init.stderr
@@ -9,13 +9,13 @@ help: declare `a` here
    |
 LL |     let a = match n {
    |     +++++++
-help: remove the assignments from the match arms
+help: remove the assignments from the `match` arms
    |
 LL ~         1 => "one",
 LL |         _ => {
 LL ~             "two"
    |
-help: add a semicolon after the match expression
+help: add a semicolon after the `match` expression
    |
 LL |     };
    |      +
@@ -36,7 +36,7 @@ LL ~         "four"
 LL |     } else {
 LL ~         "five"
    |
-help: add a semicolon after the if expression
+help: add a semicolon after the `if` expression
    |
 LL |     };
    |      +
@@ -57,7 +57,7 @@ LL ~         n
 LL |     } else {
 LL ~         -50
    |
-help: add a semicolon after the if expression
+help: add a semicolon after the `if` expression
    |
 LL |     };
    |      +
@@ -78,7 +78,7 @@ LL ~         temp
 LL |     } else {
 LL ~         15
    |
-help: add a semicolon after the if expression
+help: add a semicolon after the `if` expression
    |
 LL |     };
    |      +
@@ -99,10 +99,52 @@ LL ~         format!("{} {}", a, b)
 LL |     } else {
 LL ~         format!("{}", c)
    |
-help: add a semicolon after the if expression
+help: add a semicolon after the `if` expression
    |
 LL |     };
    |      +
 
-error: aborting due to 5 previous errors
+error: unneeded late initalization
+  --> $DIR/needless_late_init.rs:50:5
+   |
+LL |     let a;
+   |     ^^^^^^
+   |
+help: declare `a` here
+   |
+LL |     let a = match n {
+   |     +++++++
+help: remove the assignments from the `match` arms
+   |
+LL ~         1 => f().await,
+LL |         _ => {
+LL ~             "two"
+   |
+help: add a semicolon after the `match` expression
+   |
+LL |     };
+   |      +
+
+error: unneeded late initalization
+  --> $DIR/needless_late_init.rs:67:5
+   |
+LL |     let a;
+   |     ^^^^^^
+   |
+help: declare `a` here
+   |
+LL |     let a = match n {
+   |     +++++++
+help: remove the assignments from the `match` arms
+   |
+LL ~         1 => f(),
+LL |         _ => {
+LL ~             "two"
+   |
+help: add a semicolon after the `match` expression
+   |
+LL |     };
+   |      +
+
+error: aborting due to 7 previous errors
 
diff --git a/tests/ui/needless_late_init_fixable.stderr b/tests/ui/needless_late_init_fixable.stderr
index 05491496cd7..a0ce4f812f4 100644
--- a/tests/ui/needless_late_init_fixable.stderr
+++ b/tests/ui/needless_late_init_fixable.stderr
@@ -64,7 +64,7 @@ help: declare `f` here
    |
 LL |     let f = match 1 {
    |     +++++++
-help: remove the assignments from the match arms
+help: remove the assignments from the `match` arms
    |
 LL |         1 => "three",
    |              ~~~~~~~
@@ -83,7 +83,7 @@ help: remove the assignments from the branches
    |
 LL |         5
    |
-help: add a semicolon after the if expression
+help: add a semicolon after the `if` expression
    |
 LL |     };
    |      +
-- 
cgit 1.4.1-3-g733a5


From f51bbc7db93e1e15489d0b43abc110410e44576b Mon Sep 17 00:00:00 2001
From: togami2864 <tuabobo123@gmail.com>
Date: Sat, 20 Nov 2021 18:53:15 +0900
Subject: apply iter_cloned_collect to copied()

---
 clippy_lints/src/methods/iter_cloned_collect.rs | 6 +++---
 clippy_lints/src/methods/mod.rs                 | 4 +++-
 tests/ui/iter_cloned_collect.fixed              | 3 +++
 tests/ui/iter_cloned_collect.stderr             | 8 +++++++-
 4 files changed, 16 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/iter_cloned_collect.rs b/clippy_lints/src/methods/iter_cloned_collect.rs
index dd4ef6e4b58..30d56113c6c 100644
--- a/clippy_lints/src/methods/iter_cloned_collect.rs
+++ b/clippy_lints/src/methods/iter_cloned_collect.rs
@@ -9,7 +9,7 @@ use rustc_span::sym;
 
 use super::ITER_CLONED_COLLECT;
 
-pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &hir::Expr<'_>, recv: &'tcx hir::Expr<'_>) {
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, method_name: &str, expr: &hir::Expr<'_>, recv: &'tcx hir::Expr<'_>) {
     if_chain! {
         if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(expr), sym::Vec);
         if let Some(slice) = derefs_to_slice(cx, recv, cx.typeck_results().expr_ty(recv));
@@ -20,8 +20,8 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &hir::Expr<'_>, recv: &'
                 cx,
                 ITER_CLONED_COLLECT,
                 to_replace,
-                "called `iter().cloned().collect()` on a slice to create a `Vec`. Calling `to_vec()` is both faster and \
-                more readable",
+                &format!("called `iter().{}().collect()` on a slice to create a `Vec`. Calling `to_vec()` is both faster and \
+                more readable", method_name),
                 "try",
                 ".to_vec()".to_string(),
                 Applicability::MachineApplicable,
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 6ab5015ca78..a325da75ba6 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -2204,7 +2204,9 @@ fn check_methods<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, msrv: Optio
             ("assume_init", []) => uninit_assumed_init::check(cx, expr, recv),
             ("cloned", []) => cloned_instead_of_copied::check(cx, expr, recv, span, msrv),
             ("collect", []) => match method_call!(recv) {
-                Some(("cloned", [recv2], _)) => iter_cloned_collect::check(cx, expr, recv2),
+                Some((name @ ("cloned" | "copied"), [recv2], _)) => {
+                    iter_cloned_collect::check(cx, name, expr, recv2);
+                },
                 Some(("map", [m_recv, m_arg], _)) => {
                     map_collect_result_unit::check(cx, expr, m_recv, m_arg, recv);
                 },
diff --git a/tests/ui/iter_cloned_collect.fixed b/tests/ui/iter_cloned_collect.fixed
index 39cc58cd298..9b862133580 100644
--- a/tests/ui/iter_cloned_collect.fixed
+++ b/tests/ui/iter_cloned_collect.fixed
@@ -23,4 +23,7 @@ fn main() {
     // Issue #6808
     let arr: [u8; 64] = [0; 64];
     let _: Vec<_> = arr.to_vec();
+
+    // Issue #6703
+    let _: Vec<isize> = v.to_vec();
 }
diff --git a/tests/ui/iter_cloned_collect.stderr b/tests/ui/iter_cloned_collect.stderr
index e1df61794ce..b2cc497bf43 100644
--- a/tests/ui/iter_cloned_collect.stderr
+++ b/tests/ui/iter_cloned_collect.stderr
@@ -28,5 +28,11 @@ error: called `iter().cloned().collect()` on a slice to create a `Vec`. Calling
 LL |     let _: Vec<_> = arr.iter().cloned().collect();
    |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `.to_vec()`
 
-error: aborting due to 4 previous errors
+error: called `iter().copied().collect()` on a slice to create a `Vec`. Calling `to_vec()` is both faster and more readable
+  --> $DIR/iter_cloned_collect.rs:31:26
+   |
+LL |     let _: Vec<isize> = v.iter().copied().collect();
+   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `.to_vec()`
+
+error: aborting due to 5 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From f26821c96948dbb2c6a4a8f17ba4b0634d3d2034 Mon Sep 17 00:00:00 2001
From: vallentin <mail@vallentin.dev>
Date: Thu, 2 Dec 2021 18:07:28 +0100
Subject: Fixed same_name_method description

---
 clippy_lints/src/same_name_method.rs |  6 +++---
 tests/ui/same_name_method.stderr     | 10 +++++-----
 2 files changed, 8 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/same_name_method.rs b/clippy_lints/src/same_name_method.rs
index 3f38d12fb55..1bbaa104e60 100644
--- a/clippy_lints/src/same_name_method.rs
+++ b/clippy_lints/src/same_name_method.rs
@@ -11,7 +11,7 @@ use std::collections::{BTreeMap, BTreeSet};
 
 declare_clippy_lint! {
     /// ### What it does
-    /// It lints if a struct has two method with same time:
+    /// It lints if a struct has two methods with the same name:
     /// one from a trait, another not from trait.
     ///
     /// ### Why is this bad?
@@ -100,7 +100,7 @@ impl<'tcx> LateLintPass<'tcx> for SameNameMethod {
                                         cx,
                                         SAME_NAME_METHOD,
                                         *impl_span,
-                                        "method's name is same to an existing method in a trait",
+                                        "method's name is the same as an existing method in a trait",
                                         |diag| {
                                             diag.span_note(
                                                 trait_method_span,
@@ -139,7 +139,7 @@ impl<'tcx> LateLintPass<'tcx> for SameNameMethod {
                                         cx,
                                         SAME_NAME_METHOD,
                                         impl_span,
-                                        "method's name is same to an existing method in a trait",
+                                        "method's name is the same as an existing method in a trait",
                                         |diag| {
                                             // TODO should we `span_note` on every trait?
                                             // iterate on trait_spans?
diff --git a/tests/ui/same_name_method.stderr b/tests/ui/same_name_method.stderr
index 0f9139b41b9..c32c3dd9880 100644
--- a/tests/ui/same_name_method.stderr
+++ b/tests/ui/same_name_method.stderr
@@ -1,4 +1,4 @@
-error: method's name is same to an existing method in a trait
+error: method's name is the same as an existing method in a trait
   --> $DIR/same_name_method.rs:20:13
    |
 LL |             fn foo() {}
@@ -11,7 +11,7 @@ note: existing `foo` defined here
 LL |             fn foo() {}
    |             ^^^^^^^^^^^
 
-error: method's name is same to an existing method in a trait
+error: method's name is the same as an existing method in a trait
   --> $DIR/same_name_method.rs:44:13
    |
 LL |             fn foo() {}
@@ -23,7 +23,7 @@ note: existing `foo` defined here
 LL |             fn foo() {}
    |             ^^^^^^^^^^^
 
-error: method's name is same to an existing method in a trait
+error: method's name is the same as an existing method in a trait
   --> $DIR/same_name_method.rs:58:13
    |
 LL |             fn foo() {}
@@ -35,7 +35,7 @@ note: existing `foo` defined here
 LL |         impl T1 for S {}
    |         ^^^^^^^^^^^^^^^^
 
-error: method's name is same to an existing method in a trait
+error: method's name is the same as an existing method in a trait
   --> $DIR/same_name_method.rs:70:13
    |
 LL |             fn foo() {}
@@ -47,7 +47,7 @@ note: existing `foo` defined here
 LL |         impl T1 for S {}
    |         ^^^^^^^^^^^^^^^^
 
-error: method's name is same to an existing method in a trait
+error: method's name is the same as an existing method in a trait
   --> $DIR/same_name_method.rs:34:13
    |
 LL |             fn clone() {}
-- 
cgit 1.4.1-3-g733a5


From 5cc451bc6cb9fc74c85e44be4a510e9c14f03914 Mon Sep 17 00:00:00 2001
From: frobiac <frobiac@gmail.com>
Date: Thu, 2 Dec 2021 23:47:23 +0100
Subject: Escape backslash for singe_char_pattern.rs

---
 clippy_lints/src/methods/utils.rs   |  8 +++++++-
 tests/ui/single_char_pattern.fixed  |  3 +++
 tests/ui/single_char_pattern.rs     |  3 +++
 tests/ui/single_char_pattern.stderr | 14 +++++++++++++-
 4 files changed, 26 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/utils.rs b/clippy_lints/src/methods/utils.rs
index ba2ce73a116..11ad881ee7b 100644
--- a/clippy_lints/src/methods/utils.rs
+++ b/clippy_lints/src/methods/utils.rs
@@ -66,7 +66,13 @@ pub(super) fn get_hint_if_single_char_arg(
                 // for regular string: "a"
                 &snip[1..(snip.len() - 1)]
             };
-            let hint = format!("'{}'", if ch == "'" { "\\'" } else { ch });
+
+            let hint = format!("'{}'", match ch {
+                "'" => "\\'" ,
+                r"\" => "\\\\",
+                _ => ch,
+            });
+
             Some(hint)
         } else {
             None
diff --git a/tests/ui/single_char_pattern.fixed b/tests/ui/single_char_pattern.fixed
index 1abd2b7883d..ea26defd3d5 100644
--- a/tests/ui/single_char_pattern.fixed
+++ b/tests/ui/single_char_pattern.fixed
@@ -56,4 +56,7 @@ fn main() {
     x.split('a');
     x.split('\'');
     x.split('#');
+    // Must escape backslash in raw strings when converting to char #8060
+    x.split('\\');
+    x.split('\\');
 }
diff --git a/tests/ui/single_char_pattern.rs b/tests/ui/single_char_pattern.rs
index e662bf34be2..eb2d0274fa2 100644
--- a/tests/ui/single_char_pattern.rs
+++ b/tests/ui/single_char_pattern.rs
@@ -56,4 +56,7 @@ fn main() {
     x.split(r###"a"###);
     x.split(r###"'"###);
     x.split(r###"#"###);
+    // Must escape backslash in raw strings when converting to char #8060
+    x.split(r#"\"#);
+    x.split(r"\");
 }
diff --git a/tests/ui/single_char_pattern.stderr b/tests/ui/single_char_pattern.stderr
index 22d4b2d460f..f438d3da8ee 100644
--- a/tests/ui/single_char_pattern.stderr
+++ b/tests/ui/single_char_pattern.stderr
@@ -192,5 +192,17 @@ error: single-character string constant used as pattern
 LL |     x.split(r###"#"###);
    |             ^^^^^^^^^^ help: try using a `char` instead: `'#'`
 
-error: aborting due to 32 previous errors
+error: single-character string constant used as pattern
+  --> $DIR/single_char_pattern.rs:60:13
+   |
+LL |     x.split(r#"/"#);
+   |             ^^^^^^ help: try using a `char` instead: `'/'`
+
+error: single-character string constant used as pattern
+  --> $DIR/single_char_pattern.rs:61:13
+   |
+LL |     x.split(r"/");
+   |             ^^^^ help: try using a `char` instead: `'/'`
+
+error: aborting due to 34 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 11ad5a26a97962e76ae532f09cd64ed032a3a598 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Fri, 3 Dec 2021 19:29:57 +0100
Subject: Add note about crate lint level attributes to pre-expansion lints

---
 clippy_lints/src/dbg_macro.rs |  8 ++++++++
 clippy_lints/src/write.rs     | 16 ++++++++++++++--
 2 files changed, 22 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/dbg_macro.rs b/clippy_lints/src/dbg_macro.rs
index 1aae4c81c73..5a0b60fdfbc 100644
--- a/clippy_lints/src/dbg_macro.rs
+++ b/clippy_lints/src/dbg_macro.rs
@@ -15,6 +15,14 @@ declare_clippy_lint! {
     /// `dbg!` macro is intended as a debugging tool. It
     /// should not be in version control.
     ///
+    /// ### Known problems
+    /// * The lint level is unaffected by crate attributes. The level can still
+    ///   be set for functions, modules and other items. To change the level for
+    ///   the entire crate, please use command line flags. More information and a
+    ///   configuration example can be found in [clippy#6610].
+    ///
+    /// [clippy#6610]: https://github.com/rust-lang/rust-clippy/issues/6610#issuecomment-977120558
+    ///
     /// ### Example
     /// ```rust,ignore
     /// // Bad
diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs
index bfa9407285b..c90fca24ad4 100644
--- a/clippy_lints/src/write.rs
+++ b/clippy_lints/src/write.rs
@@ -72,7 +72,13 @@ declare_clippy_lint! {
     /// application and might forget to remove those prints afterward.
     ///
     /// ### Known problems
-    /// Only catches `print!` and `println!` calls.
+    /// * Only catches `print!` and `println!` calls.
+    /// * The lint level is unaffected by crate attributes. The level can still
+    ///   be set for functions, modules and other items. To change the level for
+    ///   the entire crate, please use command line flags. More information and a
+    ///   configuration example can be found in [clippy#6610].
+    ///
+    /// [clippy#6610]: https://github.com/rust-lang/rust-clippy/issues/6610#issuecomment-977120558
     ///
     /// ### Example
     /// ```rust
@@ -94,7 +100,13 @@ declare_clippy_lint! {
     /// application and might forget to remove those prints afterward.
     ///
     /// ### Known problems
-    /// Only catches `eprint!` and `eprintln!` calls.
+    /// * Only catches `eprint!` and `eprintln!` calls.
+    /// * The lint level is unaffected by crate attributes. The level can still
+    ///   be set for functions, modules and other items. To change the level for
+    ///   the entire crate, please use command line flags. More information and a
+    ///   configuration example can be found in [clippy#6610].
+    ///
+    /// [clippy#6610]: https://github.com/rust-lang/rust-clippy/issues/6610#issuecomment-977120558
     ///
     /// ### Example
     /// ```rust
-- 
cgit 1.4.1-3-g733a5


From de9de4fef1219a98b0203ef67f348e6548dc80fe Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Wed, 1 Dec 2021 08:38:54 -0600
Subject: Upgrade map_flatten to complexity

---
 clippy_lints/src/lib.register_all.rs        |  1 +
 clippy_lints/src/lib.register_complexity.rs |  1 +
 clippy_lints/src/lib.register_pedantic.rs   |  1 -
 clippy_lints/src/methods/mod.rs             |  2 +-
 tests/ui/option_env_unwrap.rs               |  1 +
 tests/ui/option_env_unwrap.stderr           | 12 ++++++------
 tests/ui/option_filter_map.fixed            | 10 ++++++----
 tests/ui/option_filter_map.rs               | 10 ++++++----
 tests/ui/option_filter_map.stderr           | 16 ++++++++--------
 9 files changed, 30 insertions(+), 24 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 04912120e27..b7b5f059de6 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -159,6 +159,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(methods::MANUAL_SPLIT_ONCE),
     LintId::of(methods::MANUAL_STR_REPEAT),
     LintId::of(methods::MAP_COLLECT_RESULT_UNIT),
+    LintId::of(methods::MAP_FLATTEN),
     LintId::of(methods::MAP_IDENTITY),
     LintId::of(methods::NEEDLESS_SPLITN),
     LintId::of(methods::NEW_RET_NO_SELF),
diff --git a/clippy_lints/src/lib.register_complexity.rs b/clippy_lints/src/lib.register_complexity.rs
index dcc95cf6c07..a21ddf73a11 100644
--- a/clippy_lints/src/lib.register_complexity.rs
+++ b/clippy_lints/src/lib.register_complexity.rs
@@ -41,6 +41,7 @@ store.register_group(true, "clippy::complexity", Some("clippy_complexity"), vec!
     LintId::of(methods::MANUAL_FILTER_MAP),
     LintId::of(methods::MANUAL_FIND_MAP),
     LintId::of(methods::MANUAL_SPLIT_ONCE),
+    LintId::of(methods::MAP_FLATTEN),
     LintId::of(methods::MAP_IDENTITY),
     LintId::of(methods::NEEDLESS_SPLITN),
     LintId::of(methods::OPTION_AS_REF_DEREF),
diff --git a/clippy_lints/src/lib.register_pedantic.rs b/clippy_lints/src/lib.register_pedantic.rs
index 5ee7799f9c5..70a4a624378 100644
--- a/clippy_lints/src/lib.register_pedantic.rs
+++ b/clippy_lints/src/lib.register_pedantic.rs
@@ -63,7 +63,6 @@ store.register_group(true, "clippy::pedantic", Some("clippy_pedantic"), vec![
     LintId::of(methods::FROM_ITER_INSTEAD_OF_COLLECT),
     LintId::of(methods::IMPLICIT_CLONE),
     LintId::of(methods::INEFFICIENT_TO_STRING),
-    LintId::of(methods::MAP_FLATTEN),
     LintId::of(methods::MAP_UNWRAP_OR),
     LintId::of(misc::FLOAT_CMP),
     LintId::of(misc::USED_UNDERSCORE_BINDING),
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index a325da75ba6..ad6fb0c613b 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -543,7 +543,7 @@ declare_clippy_lint! {
     /// ```
     #[clippy::version = "1.31.0"]
     pub MAP_FLATTEN,
-    pedantic,
+    complexity,
     "using combinations of `flatten` and `map` which can usually be written as a single method call"
 }
 
diff --git a/tests/ui/option_env_unwrap.rs b/tests/ui/option_env_unwrap.rs
index 642c77460a3..0141fb7856d 100644
--- a/tests/ui/option_env_unwrap.rs
+++ b/tests/ui/option_env_unwrap.rs
@@ -1,5 +1,6 @@
 // aux-build:macro_rules.rs
 #![warn(clippy::option_env_unwrap)]
+#![allow(clippy::map_flatten)]
 
 #[macro_use]
 extern crate macro_rules;
diff --git a/tests/ui/option_env_unwrap.stderr b/tests/ui/option_env_unwrap.stderr
index e6a58b0b2b7..885ac096cc8 100644
--- a/tests/ui/option_env_unwrap.stderr
+++ b/tests/ui/option_env_unwrap.stderr
@@ -1,5 +1,5 @@
 error: this will panic at run-time if the environment variable doesn't exist at compile-time
-  --> $DIR/option_env_unwrap.rs:17:13
+  --> $DIR/option_env_unwrap.rs:18:13
    |
 LL |     let _ = option_env!("PATH").unwrap();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -8,7 +8,7 @@ LL |     let _ = option_env!("PATH").unwrap();
    = help: consider using the `env!` macro instead
 
 error: this will panic at run-time if the environment variable doesn't exist at compile-time
-  --> $DIR/option_env_unwrap.rs:18:13
+  --> $DIR/option_env_unwrap.rs:19:13
    |
 LL |     let _ = option_env!("PATH").expect("environment variable PATH isn't set");
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -16,7 +16,7 @@ LL |     let _ = option_env!("PATH").expect("environment variable PATH isn't set
    = help: consider using the `env!` macro instead
 
 error: this will panic at run-time if the environment variable doesn't exist at compile-time
-  --> $DIR/option_env_unwrap.rs:9:9
+  --> $DIR/option_env_unwrap.rs:10:9
    |
 LL |         option_env!($env).unwrap()
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -28,7 +28,7 @@ LL |     let _ = option_env_unwrap!("PATH");
    = note: this error originates in the macro `option_env_unwrap` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: this will panic at run-time if the environment variable doesn't exist at compile-time
-  --> $DIR/option_env_unwrap.rs:12:9
+  --> $DIR/option_env_unwrap.rs:13:9
    |
 LL |         option_env!($env).expect($message)
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -40,7 +40,7 @@ LL |     let _ = option_env_unwrap!("PATH", "environment variable PATH isn't set
    = note: this error originates in the macro `option_env_unwrap` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: this will panic at run-time if the environment variable doesn't exist at compile-time
-  --> $DIR/option_env_unwrap.rs:21:13
+  --> $DIR/option_env_unwrap.rs:22:13
    |
 LL |     let _ = option_env_unwrap_external!("PATH");
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -49,7 +49,7 @@ LL |     let _ = option_env_unwrap_external!("PATH");
    = note: this error originates in the macro `option_env_unwrap_external` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: this will panic at run-time if the environment variable doesn't exist at compile-time
-  --> $DIR/option_env_unwrap.rs:22:13
+  --> $DIR/option_env_unwrap.rs:23:13
    |
 LL |     let _ = option_env_unwrap_external!("PATH", "environment variable PATH isn't set");
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/option_filter_map.fixed b/tests/ui/option_filter_map.fixed
index f9d1825ade0..b20f73f3110 100644
--- a/tests/ui/option_filter_map.fixed
+++ b/tests/ui/option_filter_map.fixed
@@ -1,8 +1,6 @@
-#![warn(clippy::option_filter_map)]
 // run-rustfix
-fn odds_out(x: i32) -> Option<i32> {
-    if x % 2 == 0 { Some(x) } else { None }
-}
+#![warn(clippy::option_filter_map)]
+#![allow(clippy::map_flatten)]
 
 fn main() {
     let _ = Some(Some(1)).flatten();
@@ -21,3 +19,7 @@ fn main() {
         .map(odds_out)
         .flatten();
 }
+
+fn odds_out(x: i32) -> Option<i32> {
+    if x % 2 == 0 { Some(x) } else { None }
+}
diff --git a/tests/ui/option_filter_map.rs b/tests/ui/option_filter_map.rs
index 588e1ccccce..7abaaa0fb83 100644
--- a/tests/ui/option_filter_map.rs
+++ b/tests/ui/option_filter_map.rs
@@ -1,8 +1,6 @@
-#![warn(clippy::option_filter_map)]
 // run-rustfix
-fn odds_out(x: i32) -> Option<i32> {
-    if x % 2 == 0 { Some(x) } else { None }
-}
+#![warn(clippy::option_filter_map)]
+#![allow(clippy::map_flatten)]
 
 fn main() {
     let _ = Some(Some(1)).filter(Option::is_some).map(Option::unwrap);
@@ -23,3 +21,7 @@ fn main() {
         .filter(|o| o.is_some())
         .map(|o| o.unwrap());
 }
+
+fn odds_out(x: i32) -> Option<i32> {
+    if x % 2 == 0 { Some(x) } else { None }
+}
diff --git a/tests/ui/option_filter_map.stderr b/tests/ui/option_filter_map.stderr
index 31a82969d5a..4a030ac9ab0 100644
--- a/tests/ui/option_filter_map.stderr
+++ b/tests/ui/option_filter_map.stderr
@@ -1,5 +1,5 @@
 error: `filter` for `Some` followed by `unwrap`
-  --> $DIR/option_filter_map.rs:8:27
+  --> $DIR/option_filter_map.rs:6:27
    |
 LL |     let _ = Some(Some(1)).filter(Option::is_some).map(Option::unwrap);
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
@@ -7,37 +7,37 @@ LL |     let _ = Some(Some(1)).filter(Option::is_some).map(Option::unwrap);
    = note: `-D clippy::option-filter-map` implied by `-D warnings`
 
 error: `filter` for `Some` followed by `unwrap`
-  --> $DIR/option_filter_map.rs:9:27
+  --> $DIR/option_filter_map.rs:7:27
    |
 LL |     let _ = Some(Some(1)).filter(|o| o.is_some()).map(|o| o.unwrap());
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
 
 error: `filter` for `Some` followed by `unwrap`
-  --> $DIR/option_filter_map.rs:10:35
+  --> $DIR/option_filter_map.rs:8:35
    |
 LL |     let _ = Some(1).map(odds_out).filter(Option::is_some).map(Option::unwrap);
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
 
 error: `filter` for `Some` followed by `unwrap`
-  --> $DIR/option_filter_map.rs:11:35
+  --> $DIR/option_filter_map.rs:9:35
    |
 LL |     let _ = Some(1).map(odds_out).filter(|o| o.is_some()).map(|o| o.unwrap());
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
 
 error: `filter` for `Some` followed by `unwrap`
-  --> $DIR/option_filter_map.rs:13:39
+  --> $DIR/option_filter_map.rs:11:39
    |
 LL |     let _ = vec![Some(1)].into_iter().filter(Option::is_some).map(Option::unwrap);
    |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
 
 error: `filter` for `Some` followed by `unwrap`
-  --> $DIR/option_filter_map.rs:14:39
+  --> $DIR/option_filter_map.rs:12:39
    |
 LL |     let _ = vec![Some(1)].into_iter().filter(|o| o.is_some()).map(|o| o.unwrap());
    |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
 
 error: `filter` for `Some` followed by `unwrap`
-  --> $DIR/option_filter_map.rs:18:10
+  --> $DIR/option_filter_map.rs:16:10
    |
 LL |           .filter(Option::is_some)
    |  __________^
@@ -45,7 +45,7 @@ LL | |         .map(Option::unwrap);
    | |____________________________^ help: consider using `flatten` instead: `flatten()`
 
 error: `filter` for `Some` followed by `unwrap`
-  --> $DIR/option_filter_map.rs:23:10
+  --> $DIR/option_filter_map.rs:21:10
    |
 LL |           .filter(|o| o.is_some())
    |  __________^
-- 
cgit 1.4.1-3-g733a5


From 844996b42e27a2dea559ca4a5f78328bb2b22508 Mon Sep 17 00:00:00 2001
From: Yechan Bae <yechan@gatech.edu>
Date: Fri, 3 Dec 2021 19:11:40 -0500
Subject: Consider NonNull as a pointer type

---
 clippy_lints/src/non_send_fields_in_send_ty.rs | 28 +++++++++++++++++---------
 clippy_utils/src/paths.rs                      |  1 +
 tests/ui/non_send_fields_in_send_ty.rs         |  5 +++++
 tests/ui/non_send_fields_in_send_ty.stderr     | 20 +++++++++---------
 4 files changed, 34 insertions(+), 20 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/non_send_fields_in_send_ty.rs b/clippy_lints/src/non_send_fields_in_send_ty.rs
index 9c07488bfe6..bba542ce8ca 100644
--- a/clippy_lints/src/non_send_fields_in_send_ty.rs
+++ b/clippy_lints/src/non_send_fields_in_send_ty.rs
@@ -1,11 +1,12 @@
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::is_lint_allowed;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::{implements_trait, is_copy};
+use clippy_utils::{is_lint_allowed, match_def_path, paths};
 use rustc_ast::ImplPolarity;
 use rustc_hir::def_id::DefId;
 use rustc_hir::{FieldDef, Item, ItemKind, Node};
 use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::{self, subst::GenericArgKind, Ty};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::sym;
@@ -77,6 +78,7 @@ impl<'tcx> LateLintPass<'tcx> for NonSendFieldInSendTy {
         // single `AdtDef` may have multiple `Send` impls due to generic
         // parameters, and the lint is much easier to implement in this way.
         if_chain! {
+            if !in_external_macro(cx.tcx.sess, item.span);
             if let Some(send_trait) = cx.tcx.get_diagnostic_item(sym::Send);
             if let ItemKind::Impl(hir_impl) = &item.kind;
             if let Some(trait_ref) = &hir_impl.of_trait;
@@ -181,7 +183,7 @@ fn ty_allowed_without_raw_pointer_heuristic<'tcx>(cx: &LateContext<'tcx>, ty: Ty
         return true;
     }
 
-    if is_copy(cx, ty) && !contains_raw_pointer(cx, ty) {
+    if is_copy(cx, ty) && !contains_pointer_like(cx, ty) {
         return true;
     }
 
@@ -201,7 +203,7 @@ fn ty_allowed_with_raw_pointer_heuristic<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'t
             .all(|ty| ty_allowed_with_raw_pointer_heuristic(cx, ty, send_trait)),
         ty::Array(ty, _) | ty::Slice(ty) => ty_allowed_with_raw_pointer_heuristic(cx, ty, send_trait),
         ty::Adt(_, substs) => {
-            if contains_raw_pointer(cx, ty) {
+            if contains_pointer_like(cx, ty) {
                 // descends only if ADT contains any raw pointers
                 substs.iter().all(|generic_arg| match generic_arg.unpack() {
                     GenericArgKind::Type(ty) => ty_allowed_with_raw_pointer_heuristic(cx, ty, send_trait),
@@ -218,14 +220,20 @@ fn ty_allowed_with_raw_pointer_heuristic<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'t
     }
 }
 
-/// Checks if the type contains any raw pointers in substs (including nested ones).
-fn contains_raw_pointer<'tcx>(cx: &LateContext<'tcx>, target_ty: Ty<'tcx>) -> bool {
+/// Checks if the type contains any pointer-like types in substs (including nested ones)
+fn contains_pointer_like<'tcx>(cx: &LateContext<'tcx>, target_ty: Ty<'tcx>) -> bool {
     for ty_node in target_ty.walk(cx.tcx) {
-        if_chain! {
-            if let GenericArgKind::Type(inner_ty) = ty_node.unpack();
-            if let ty::RawPtr(_) = inner_ty.kind();
-            then {
-                return true;
+        if let GenericArgKind::Type(inner_ty) = ty_node.unpack() {
+            match inner_ty.kind() {
+                ty::RawPtr(_) => {
+                    return true;
+                },
+                ty::Adt(adt_def, _) => {
+                    if match_def_path(cx, adt_def.did, &paths::PTR_NON_NULL) {
+                        return true;
+                    }
+                },
+                _ => (),
             }
         }
     }
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index 3ffa548e470..6171823abbb 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -206,3 +206,4 @@ pub const WEAK_RC: [&str; 3] = ["alloc", "rc", "Weak"];
 pub const WRITE_MACRO: [&str; 3] = ["core", "macros", "write"];
 #[allow(clippy::invalid_paths)] // `check_path` does not seem to work for macros
 pub const WRITELN_MACRO: [&str; 3] = ["core", "macros", "writeln"];
+pub const PTR_NON_NULL: [&str; 4] = ["core", "ptr", "non_null", "NonNull"];
diff --git a/tests/ui/non_send_fields_in_send_ty.rs b/tests/ui/non_send_fields_in_send_ty.rs
index eca7f5e5655..828248d922f 100644
--- a/tests/ui/non_send_fields_in_send_ty.rs
+++ b/tests/ui/non_send_fields_in_send_ty.rs
@@ -69,6 +69,11 @@ pub enum MyOption<T> {
 
 unsafe impl<T> Send for MyOption<T> {}
 
+// Test types that contain `NonNull` instead of raw pointers (#8045)
+pub struct WrappedNonNull(UnsafeCell<NonNull<()>>);
+
+unsafe impl Send for WrappedNonNull {}
+
 // Multiple type parameters
 pub struct MultiParam<A, B> {
     vec: Vec<(A, B)>,
diff --git a/tests/ui/non_send_fields_in_send_ty.stderr b/tests/ui/non_send_fields_in_send_ty.stderr
index 8b8a1d16d9b..3c4da36b3e0 100644
--- a/tests/ui/non_send_fields_in_send_ty.stderr
+++ b/tests/ui/non_send_fields_in_send_ty.stderr
@@ -103,65 +103,65 @@ LL |     MySome(T),
    = help: add `T: Send` bound in `Send` impl
 
 error: this implementation is unsound, as some fields in `MultiParam<A, B>` are `!Send`
-  --> $DIR/non_send_fields_in_send_ty.rs:77:1
+  --> $DIR/non_send_fields_in_send_ty.rs:82:1
    |
 LL | unsafe impl<A, B> Send for MultiParam<A, B> {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: the type of field `vec` is `!Send`
-  --> $DIR/non_send_fields_in_send_ty.rs:74:5
+  --> $DIR/non_send_fields_in_send_ty.rs:79:5
    |
 LL |     vec: Vec<(A, B)>,
    |     ^^^^^^^^^^^^^^^^
    = help: add bounds on type parameters `A, B` that satisfy `Vec<(A, B)>: Send`
 
 error: this implementation is unsound, as some fields in `HeuristicTest` are `!Send`
-  --> $DIR/non_send_fields_in_send_ty.rs:95:1
+  --> $DIR/non_send_fields_in_send_ty.rs:100:1
    |
 LL | unsafe impl Send for HeuristicTest {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: the type of field `field4` is `!Send`
-  --> $DIR/non_send_fields_in_send_ty.rs:90:5
+  --> $DIR/non_send_fields_in_send_ty.rs:95:5
    |
 LL |     field4: (*const NonSend, Rc<u8>),
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    = help: use a thread-safe type that implements `Send`
 
 error: this implementation is unsound, as some fields in `AttrTest3<T>` are `!Send`
-  --> $DIR/non_send_fields_in_send_ty.rs:114:1
+  --> $DIR/non_send_fields_in_send_ty.rs:119:1
    |
 LL | unsafe impl<T> Send for AttrTest3<T> {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: the type of field `0` is `!Send`
-  --> $DIR/non_send_fields_in_send_ty.rs:109:11
+  --> $DIR/non_send_fields_in_send_ty.rs:114:11
    |
 LL |     Enum2(T),
    |           ^
    = help: add `T: Send` bound in `Send` impl
 
 error: this implementation is unsound, as some fields in `Complex<P, u32>` are `!Send`
-  --> $DIR/non_send_fields_in_send_ty.rs:122:1
+  --> $DIR/non_send_fields_in_send_ty.rs:127:1
    |
 LL | unsafe impl<P> Send for Complex<P, u32> {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: the type of field `field1` is `!Send`
-  --> $DIR/non_send_fields_in_send_ty.rs:118:5
+  --> $DIR/non_send_fields_in_send_ty.rs:123:5
    |
 LL |     field1: A,
    |     ^^^^^^^^^
    = help: add `P: Send` bound in `Send` impl
 
 error: this implementation is unsound, as some fields in `Complex<Q, MutexGuard<'static, bool>>` are `!Send`
-  --> $DIR/non_send_fields_in_send_ty.rs:125:1
+  --> $DIR/non_send_fields_in_send_ty.rs:130:1
    |
 LL | unsafe impl<Q: Send> Send for Complex<Q, MutexGuard<'static, bool>> {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: the type of field `field2` is `!Send`
-  --> $DIR/non_send_fields_in_send_ty.rs:119:5
+  --> $DIR/non_send_fields_in_send_ty.rs:124:5
    |
 LL |     field2: B,
    |     ^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From e3c60444ce6652198c0986c98fe7bd0f8de5f987 Mon Sep 17 00:00:00 2001
From: nixx quality <nixx@is-fantabulo.us>
Date: Sun, 5 Dec 2021 17:33:52 +0100
Subject: fix some false negatives for single_char_pattern

---
 clippy_lints/src/methods/single_char_pattern.rs |  7 +-
 tests/ui/single_char_pattern.fixed              |  7 +-
 tests/ui/single_char_pattern.rs                 |  7 +-
 tests/ui/single_char_pattern.stderr             | 94 ++++++++++++++++---------
 4 files changed, 80 insertions(+), 35 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/single_char_pattern.rs b/clippy_lints/src/methods/single_char_pattern.rs
index d313a3db479..bf9006c6906 100644
--- a/clippy_lints/src/methods/single_char_pattern.rs
+++ b/clippy_lints/src/methods/single_char_pattern.rs
@@ -9,18 +9,21 @@ use rustc_span::symbol::Symbol;
 
 use super::SINGLE_CHAR_PATTERN;
 
-const PATTERN_METHODS: [(&str, usize); 19] = [
+const PATTERN_METHODS: [(&str, usize); 24] = [
     ("contains", 1),
     ("starts_with", 1),
     ("ends_with", 1),
     ("find", 1),
     ("rfind", 1),
     ("split", 1),
+    ("split_inclusive", 1),
     ("rsplit", 1),
     ("split_terminator", 1),
     ("rsplit_terminator", 1),
     ("splitn", 2),
     ("rsplitn", 2),
+    ("split_once", 1),
+    ("rsplit_once", 1),
     ("matches", 1),
     ("rmatches", 1),
     ("match_indices", 1),
@@ -29,6 +32,8 @@ const PATTERN_METHODS: [(&str, usize); 19] = [
     ("strip_suffix", 1),
     ("trim_start_matches", 1),
     ("trim_end_matches", 1),
+    ("replace", 1),
+    ("replacen", 1),
 ];
 
 /// lint for length-1 `str`s for methods in `PATTERN_METHODS`
diff --git a/tests/ui/single_char_pattern.fixed b/tests/ui/single_char_pattern.fixed
index ea26defd3d5..68e26726724 100644
--- a/tests/ui/single_char_pattern.fixed
+++ b/tests/ui/single_char_pattern.fixed
@@ -17,6 +17,7 @@ fn main() {
     x.split('💣');
     // Can't use this lint for unicode code points which don't fit in a char
     x.split("❤️");
+    x.split_inclusive('x');
     x.contains('x');
     x.starts_with('x');
     x.ends_with('x');
@@ -27,6 +28,8 @@ fn main() {
     x.rsplit_terminator('x');
     x.splitn(2, 'x');
     x.rsplitn(2, 'x');
+    x.split_once('x');
+    x.rsplit_once('x');
     x.matches('x');
     x.rmatches('x');
     x.match_indices('x');
@@ -35,6 +38,8 @@ fn main() {
     x.trim_end_matches('x');
     x.strip_prefix('x');
     x.strip_suffix('x');
+    x.replace('x', "y");
+    x.replacen('x', "y", 3);
     // Make sure we escape characters correctly.
     x.split('\n');
     x.split('\'');
@@ -43,7 +48,7 @@ fn main() {
     let h = HashSet::<String>::new();
     h.contains("X"); // should not warn
 
-    x.replace(";", ",").split(','); // issue #2978
+    x.replace(';', ",").split(','); // issue #2978
     x.starts_with('\x03'); // issue #2996
 
     // Issue #3204
diff --git a/tests/ui/single_char_pattern.rs b/tests/ui/single_char_pattern.rs
index eb2d0274fa2..186202d78ec 100644
--- a/tests/ui/single_char_pattern.rs
+++ b/tests/ui/single_char_pattern.rs
@@ -17,6 +17,7 @@ fn main() {
     x.split("💣");
     // Can't use this lint for unicode code points which don't fit in a char
     x.split("❤️");
+    x.split_inclusive("x");
     x.contains("x");
     x.starts_with("x");
     x.ends_with("x");
@@ -27,6 +28,8 @@ fn main() {
     x.rsplit_terminator("x");
     x.splitn(2, "x");
     x.rsplitn(2, "x");
+    x.split_once("x");
+    x.rsplit_once("x");
     x.matches("x");
     x.rmatches("x");
     x.match_indices("x");
@@ -35,6 +38,8 @@ fn main() {
     x.trim_end_matches("x");
     x.strip_prefix("x");
     x.strip_suffix("x");
+    x.replace("x", "y");
+    x.replacen("x", "y", 3);
     // Make sure we escape characters correctly.
     x.split("\n");
     x.split("'");
@@ -43,7 +48,7 @@ fn main() {
     let h = HashSet::<String>::new();
     h.contains("X"); // should not warn
 
-    x.replace(";", ",").split(","); // issue #2978
+    x.replace(';', ",").split(","); // issue #2978
     x.starts_with("\x03"); // issue #2996
 
     // Issue #3204
diff --git a/tests/ui/single_char_pattern.stderr b/tests/ui/single_char_pattern.stderr
index f438d3da8ee..5564aac674d 100644
--- a/tests/ui/single_char_pattern.stderr
+++ b/tests/ui/single_char_pattern.stderr
@@ -25,184 +25,214 @@ LL |     x.split("💣");
    |             ^^^^ help: try using a `char` instead: `'💣'`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:20:16
+  --> $DIR/single_char_pattern.rs:20:23
+   |
+LL |     x.split_inclusive("x");
+   |                       ^^^ help: try using a `char` instead: `'x'`
+
+error: single-character string constant used as pattern
+  --> $DIR/single_char_pattern.rs:21:16
    |
 LL |     x.contains("x");
    |                ^^^ help: try using a `char` instead: `'x'`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:21:19
+  --> $DIR/single_char_pattern.rs:22:19
    |
 LL |     x.starts_with("x");
    |                   ^^^ help: try using a `char` instead: `'x'`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:22:17
+  --> $DIR/single_char_pattern.rs:23:17
    |
 LL |     x.ends_with("x");
    |                 ^^^ help: try using a `char` instead: `'x'`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:23:12
+  --> $DIR/single_char_pattern.rs:24:12
    |
 LL |     x.find("x");
    |            ^^^ help: try using a `char` instead: `'x'`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:24:13
+  --> $DIR/single_char_pattern.rs:25:13
    |
 LL |     x.rfind("x");
    |             ^^^ help: try using a `char` instead: `'x'`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:25:14
+  --> $DIR/single_char_pattern.rs:26:14
    |
 LL |     x.rsplit("x");
    |              ^^^ help: try using a `char` instead: `'x'`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:26:24
+  --> $DIR/single_char_pattern.rs:27:24
    |
 LL |     x.split_terminator("x");
    |                        ^^^ help: try using a `char` instead: `'x'`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:27:25
+  --> $DIR/single_char_pattern.rs:28:25
    |
 LL |     x.rsplit_terminator("x");
    |                         ^^^ help: try using a `char` instead: `'x'`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:28:17
+  --> $DIR/single_char_pattern.rs:29:17
    |
 LL |     x.splitn(2, "x");
    |                 ^^^ help: try using a `char` instead: `'x'`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:29:18
+  --> $DIR/single_char_pattern.rs:30:18
    |
 LL |     x.rsplitn(2, "x");
    |                  ^^^ help: try using a `char` instead: `'x'`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:30:15
+  --> $DIR/single_char_pattern.rs:31:18
+   |
+LL |     x.split_once("x");
+   |                  ^^^ help: try using a `char` instead: `'x'`
+
+error: single-character string constant used as pattern
+  --> $DIR/single_char_pattern.rs:32:19
+   |
+LL |     x.rsplit_once("x");
+   |                   ^^^ help: try using a `char` instead: `'x'`
+
+error: single-character string constant used as pattern
+  --> $DIR/single_char_pattern.rs:33:15
    |
 LL |     x.matches("x");
    |               ^^^ help: try using a `char` instead: `'x'`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:31:16
+  --> $DIR/single_char_pattern.rs:34:16
    |
 LL |     x.rmatches("x");
    |                ^^^ help: try using a `char` instead: `'x'`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:32:21
+  --> $DIR/single_char_pattern.rs:35:21
    |
 LL |     x.match_indices("x");
    |                     ^^^ help: try using a `char` instead: `'x'`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:33:22
+  --> $DIR/single_char_pattern.rs:36:22
    |
 LL |     x.rmatch_indices("x");
    |                      ^^^ help: try using a `char` instead: `'x'`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:34:26
+  --> $DIR/single_char_pattern.rs:37:26
    |
 LL |     x.trim_start_matches("x");
    |                          ^^^ help: try using a `char` instead: `'x'`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:35:24
+  --> $DIR/single_char_pattern.rs:38:24
    |
 LL |     x.trim_end_matches("x");
    |                        ^^^ help: try using a `char` instead: `'x'`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:36:20
+  --> $DIR/single_char_pattern.rs:39:20
    |
 LL |     x.strip_prefix("x");
    |                    ^^^ help: try using a `char` instead: `'x'`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:37:20
+  --> $DIR/single_char_pattern.rs:40:20
    |
 LL |     x.strip_suffix("x");
    |                    ^^^ help: try using a `char` instead: `'x'`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:39:13
+  --> $DIR/single_char_pattern.rs:41:15
+   |
+LL |     x.replace("x", "y");
+   |               ^^^ help: try using a `char` instead: `'x'`
+
+error: single-character string constant used as pattern
+  --> $DIR/single_char_pattern.rs:42:16
+   |
+LL |     x.replacen("x", "y", 3);
+   |                ^^^ help: try using a `char` instead: `'x'`
+
+error: single-character string constant used as pattern
+  --> $DIR/single_char_pattern.rs:44:13
    |
 LL |     x.split("/n");
    |             ^^^^ help: try using a `char` instead: `'/n'`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:40:13
+  --> $DIR/single_char_pattern.rs:45:13
    |
 LL |     x.split("'");
    |             ^^^ help: try using a `char` instead: `'/''`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:41:13
+  --> $DIR/single_char_pattern.rs:46:13
    |
 LL |     x.split("/'");
    |             ^^^^ help: try using a `char` instead: `'/''`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:46:31
+  --> $DIR/single_char_pattern.rs:51:31
    |
-LL |     x.replace(";", ",").split(","); // issue #2978
+LL |     x.replace(';', ",").split(","); // issue #2978
    |                               ^^^ help: try using a `char` instead: `','`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:47:19
+  --> $DIR/single_char_pattern.rs:52:19
    |
 LL |     x.starts_with("/x03"); // issue #2996
    |                   ^^^^^^ help: try using a `char` instead: `'/x03'`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:54:13
+  --> $DIR/single_char_pattern.rs:59:13
    |
 LL |     x.split(r"a");
    |             ^^^^ help: try using a `char` instead: `'a'`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:55:13
+  --> $DIR/single_char_pattern.rs:60:13
    |
 LL |     x.split(r#"a"#);
    |             ^^^^^^ help: try using a `char` instead: `'a'`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:56:13
+  --> $DIR/single_char_pattern.rs:61:13
    |
 LL |     x.split(r###"a"###);
    |             ^^^^^^^^^^ help: try using a `char` instead: `'a'`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:57:13
+  --> $DIR/single_char_pattern.rs:62:13
    |
 LL |     x.split(r###"'"###);
    |             ^^^^^^^^^^ help: try using a `char` instead: `'/''`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:58:13
+  --> $DIR/single_char_pattern.rs:63:13
    |
 LL |     x.split(r###"#"###);
    |             ^^^^^^^^^^ help: try using a `char` instead: `'#'`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:60:13
+  --> $DIR/single_char_pattern.rs:65:13
    |
 LL |     x.split(r#"/"#);
    |             ^^^^^^ help: try using a `char` instead: `'/'`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:61:13
+  --> $DIR/single_char_pattern.rs:66:13
    |
 LL |     x.split(r"/");
    |             ^^^^ help: try using a `char` instead: `'/'`
 
-error: aborting due to 34 previous errors
+error: aborting due to 39 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 01e302b2f734a7d877c1918122315309aabe34ff Mon Sep 17 00:00:00 2001
From: nixx quality <nixx@is-fantabulo.us>
Date: Sun, 5 Dec 2021 21:50:05 +0100
Subject: Fix dogfood

---
 clippy_lints/src/map_unit_fn.rs              | 2 +-
 clippy_lints/src/nonstandard_macro_braces.rs | 2 +-
 clippy_lints/src/self_named_constructors.rs  | 2 +-
 clippy_lints/src/unicode.rs                  | 6 +++---
 clippy_lints/src/write.rs                    | 4 ++--
 5 files changed, 8 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/map_unit_fn.rs b/clippy_lints/src/map_unit_fn.rs
index a84de3e079b..58c686d95b3 100644
--- a/clippy_lints/src/map_unit_fn.rs
+++ b/clippy_lints/src/map_unit_fn.rs
@@ -190,7 +190,7 @@ fn unit_closure<'tcx>(
 /// Anything else will return `a`.
 fn let_binding_name(cx: &LateContext<'_>, var_arg: &hir::Expr<'_>) -> String {
     match &var_arg.kind {
-        hir::ExprKind::Field(_, _) => snippet(cx, var_arg.span, "_").replace(".", "_"),
+        hir::ExprKind::Field(_, _) => snippet(cx, var_arg.span, "_").replace('.', "_"),
         hir::ExprKind::Path(_) => format!("_{}", snippet(cx, var_arg.span, "")),
         _ => "a".to_string(),
     }
diff --git a/clippy_lints/src/nonstandard_macro_braces.rs b/clippy_lints/src/nonstandard_macro_braces.rs
index 3dcc9e26c9e..a04d589f880 100644
--- a/clippy_lints/src/nonstandard_macro_braces.rs
+++ b/clippy_lints/src/nonstandard_macro_braces.rs
@@ -112,7 +112,7 @@ fn is_offending_macro<'a>(cx: &EarlyContext<'_>, span: Span, mac_braces: &'a Mac
         if snip.starts_with(&format!("{}!", name));
         if unnested_or_local();
         // make formatting consistent
-        let c = snip.replace(" ", "");
+        let c = snip.replace(' ', "");
         if !c.starts_with(&format!("{}!{}", name, braces.0));
         if !mac_braces.done.contains(&span.ctxt().outer_expn_data().call_site);
         then {
diff --git a/clippy_lints/src/self_named_constructors.rs b/clippy_lints/src/self_named_constructors.rs
index 96c525ba649..d386663e498 100644
--- a/clippy_lints/src/self_named_constructors.rs
+++ b/clippy_lints/src/self_named_constructors.rs
@@ -76,7 +76,7 @@ impl<'tcx> LateLintPass<'tcx> for SelfNamedConstructors {
             let self_id = cx.tcx.hir().local_def_id_to_hir_id(self_local_did);
             if let Some(Node::Item(x)) = cx.tcx.hir().find(self_id);
             let type_name = x.ident.name.as_str().to_lowercase();
-            if impl_item.ident.name.as_str() == type_name || impl_item.ident.name.as_str().replace("_", "") == type_name;
+            if impl_item.ident.name.as_str() == type_name || impl_item.ident.name.as_str().replace('_', "") == type_name;
 
             then {
                 span_lint(
diff --git a/clippy_lints/src/unicode.rs b/clippy_lints/src/unicode.rs
index fbc4732e0ce..afd7be89a4e 100644
--- a/clippy_lints/src/unicode.rs
+++ b/clippy_lints/src/unicode.rs
@@ -106,9 +106,9 @@ fn check_str(cx: &LateContext<'_>, span: Span, id: HirId) {
             "invisible character detected",
             "consider replacing the string with",
             string
-                .replace("\u{200B}", "\\u{200B}")
-                .replace("\u{ad}", "\\u{AD}")
-                .replace("\u{2060}", "\\u{2060}"),
+                .replace('\u{200B}', "\\u{200B}")
+                .replace('\u{ad}', "\\u{AD}")
+                .replace('\u{2060}', "\\u{2060}"),
             Applicability::MachineApplicable,
         );
     }
diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs
index c90fca24ad4..5bf0cffdbad 100644
--- a/clippy_lints/src/write.rs
+++ b/clippy_lints/src/write.rs
@@ -583,10 +583,10 @@ impl Write {
             let replacement: String = match lit.token.kind {
                 LitKind::Integer | LitKind::Float | LitKind::Err => continue,
                 LitKind::StrRaw(_) | LitKind::ByteStrRaw(_) if matches!(fmtstr.style, StrStyle::Raw(_)) => {
-                    lit.token.symbol.as_str().replace("{", "{{").replace("}", "}}")
+                    lit.token.symbol.as_str().replace('{', "{{").replace('}', "}}")
                 },
                 LitKind::Str | LitKind::ByteStr if matches!(fmtstr.style, StrStyle::Cooked) => {
-                    lit.token.symbol.as_str().replace("{", "{{").replace("}", "}}")
+                    lit.token.symbol.as_str().replace('{', "{{").replace('}', "}}")
                 },
                 LitKind::StrRaw(_) | LitKind::Str | LitKind::ByteStrRaw(_) | LitKind::ByteStr => continue,
                 LitKind::Byte | LitKind::Char => match &*lit.token.symbol.as_str() {
-- 
cgit 1.4.1-3-g733a5


From 01ca66cbd70ecfa7ba6294219ecba9f6ad9c8b2b Mon Sep 17 00:00:00 2001
From: dswij <dswijj@gmail.com>
Date: Mon, 6 Dec 2021 17:18:17 +0800
Subject: Fix FP on `question_mark` if returned object is not local

---
 clippy_lints/src/question_mark.rs |  2 +-
 tests/ui/question_mark.fixed      | 19 +++++++++++++++++++
 tests/ui/question_mark.rs         | 19 +++++++++++++++++++
 3 files changed, 39 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/question_mark.rs b/clippy_lints/src/question_mark.rs
index a5531993ee6..7d30c34e956 100644
--- a/clippy_lints/src/question_mark.rs
+++ b/clippy_lints/src/question_mark.rs
@@ -183,7 +183,7 @@ impl QuestionMark {
                 false
             },
             ExprKind::Ret(Some(ret_expr)) => Self::expression_returns_unmodified_err(cx, ret_expr, cond_expr),
-            ExprKind::Path(_) => path_to_local(expr) == path_to_local(cond_expr),
+            ExprKind::Path(_) => path_to_local(expr).is_some() && path_to_local(expr) == path_to_local(cond_expr),
             _ => false,
         }
     }
diff --git a/tests/ui/question_mark.fixed b/tests/ui/question_mark.fixed
index e93469e5f55..13ce0f32d4b 100644
--- a/tests/ui/question_mark.fixed
+++ b/tests/ui/question_mark.fixed
@@ -136,6 +136,24 @@ fn result_func(x: Result<i32, i32>) -> Result<i32, i32> {
     Ok(y)
 }
 
+// see issue #8019
+pub enum NotOption {
+    None,
+    First,
+    AfterFirst,
+}
+
+fn obj(_: i32) -> Result<(), NotOption> {
+    Err(NotOption::First)
+}
+
+fn f() -> NotOption {
+    if obj(2).is_err() {
+        return NotOption::None;
+    }
+    NotOption::First
+}
+
 fn main() {
     some_func(Some(42));
     some_func(None);
@@ -157,4 +175,5 @@ fn main() {
     func();
 
     let _ = result_func(Ok(42));
+    let _ = f();
 }
diff --git a/tests/ui/question_mark.rs b/tests/ui/question_mark.rs
index dd179e9bee8..60590fd9311 100644
--- a/tests/ui/question_mark.rs
+++ b/tests/ui/question_mark.rs
@@ -168,6 +168,24 @@ fn result_func(x: Result<i32, i32>) -> Result<i32, i32> {
     Ok(y)
 }
 
+// see issue #8019
+pub enum NotOption {
+    None,
+    First,
+    AfterFirst,
+}
+
+fn obj(_: i32) -> Result<(), NotOption> {
+    Err(NotOption::First)
+}
+
+fn f() -> NotOption {
+    if obj(2).is_err() {
+        return NotOption::None;
+    }
+    NotOption::First
+}
+
 fn main() {
     some_func(Some(42));
     some_func(None);
@@ -189,4 +207,5 @@ fn main() {
     func();
 
     let _ = result_func(Ok(42));
+    let _ = f();
 }
-- 
cgit 1.4.1-3-g733a5


From 4a39707795862c8732aee0de07a075f5dc4e5036 Mon Sep 17 00:00:00 2001
From: Andre Bogus <bogusandre@gmail.com>
Date: Thu, 2 Dec 2021 22:47:57 +0100
Subject: Parenthesize blocks in `needless_bool` suggestion

Because the `if .. {}` statement already puts the condition in
expression scope, contained blocks would be parsed as complete
statements, so any `&` binary expression whose left operand ended in a
block would lead to a non-compiling suggestion.

This adds a visitor to identify such expressions and add parentheses.

This fixes #8052.
---
 clippy_lints/src/needless_bool.rs     | 38 +++++++++++++++++++++++++++++--
 tests/ui/needless_bool/fixable.fixed  | 17 ++++++++++++++
 tests/ui/needless_bool/fixable.rs     | 21 ++++++++++++++++++
 tests/ui/needless_bool/fixable.stderr | 42 ++++++++++++++++++++++++++---------
 4 files changed, 106 insertions(+), 12 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/needless_bool.rs b/clippy_lints/src/needless_bool.rs
index 3709f3948c2..e7809436252 100644
--- a/clippy_lints/src/needless_bool.rs
+++ b/clippy_lints/src/needless_bool.rs
@@ -6,10 +6,10 @@ use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg};
 use clippy_utils::higher;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::sugg::Sugg;
-use clippy_utils::{is_else_clause, is_expn_of};
+use clippy_utils::{get_parent_node, is_else_clause, is_expn_of};
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
-use rustc_hir::{BinOpKind, Block, Expr, ExprKind, StmtKind, UnOp};
+use rustc_hir::{BinOpKind, Block, Expr, ExprKind, HirId, Node, StmtKind, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Spanned;
@@ -74,6 +74,36 @@ declare_clippy_lint! {
 
 declare_lint_pass!(NeedlessBool => [NEEDLESS_BOOL]);
 
+fn condition_needs_parentheses(e: &Expr<'_>) -> bool {
+    let mut inner = e;
+    while let ExprKind::Binary(_, i, _)
+    | ExprKind::Call(i, _)
+    | ExprKind::Cast(i, _)
+    | ExprKind::Type(i, _)
+    | ExprKind::Index(i, _) = inner.kind
+    {
+        if matches!(
+            i.kind,
+            ExprKind::Block(..)
+                | ExprKind::ConstBlock(..)
+                | ExprKind::If(..)
+                | ExprKind::Loop(..)
+                | ExprKind::Match(..)
+        ) {
+            return true;
+        }
+        inner = i;
+    }
+    false
+}
+
+fn is_parent_stmt(cx: &LateContext<'_>, id: HirId) -> bool {
+    matches!(
+        get_parent_node(cx.tcx, id),
+        Some(Node::Stmt(..) | Node::Block(Block { stmts: &[], .. }))
+    )
+}
+
 impl<'tcx> LateLintPass<'tcx> for NeedlessBool {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
         use self::Expression::{Bool, RetBool};
@@ -99,6 +129,10 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessBool {
                     snip = snip.blockify();
                 }
 
+                if condition_needs_parentheses(cond) && is_parent_stmt(cx, e.hir_id) {
+                    snip = snip.maybe_par();
+                }
+
                 span_lint_and_sugg(
                     cx,
                     NEEDLESS_BOOL,
diff --git a/tests/ui/needless_bool/fixable.fixed b/tests/ui/needless_bool/fixable.fixed
index a2e3988daff..85da1f4e104 100644
--- a/tests/ui/needless_bool/fixable.fixed
+++ b/tests/ui/needless_bool/fixable.fixed
@@ -53,6 +53,7 @@ fn main() {
     needless_bool(x);
     needless_bool2(x);
     needless_bool3(x);
+    needless_bool_condition();
 }
 
 fn bool_ret3(x: bool) -> bool {
@@ -98,3 +99,19 @@ fn needless_bool_in_the_suggestion_wraps_the_predicate_of_if_else_statement_in_b
         true
     } else { !returns_bool() };
 }
+
+unsafe fn no(v: u8) -> u8 {
+    v
+}
+
+#[allow(clippy::unnecessary_operation)]
+fn needless_bool_condition() -> bool {
+    (unsafe { no(4) } & 1 != 0);
+    let _brackets_unneeded = unsafe { no(4) } & 1 != 0;
+    fn foo() -> bool {
+        // parentheses are needed here
+        (unsafe { no(4) } & 1 != 0)
+    }
+
+    foo()
+}
diff --git a/tests/ui/needless_bool/fixable.rs b/tests/ui/needless_bool/fixable.rs
index 75805e85789..add60630251 100644
--- a/tests/ui/needless_bool/fixable.rs
+++ b/tests/ui/needless_bool/fixable.rs
@@ -65,6 +65,7 @@ fn main() {
     needless_bool(x);
     needless_bool2(x);
     needless_bool3(x);
+    needless_bool_condition();
 }
 
 fn bool_ret3(x: bool) -> bool {
@@ -130,3 +131,23 @@ fn needless_bool_in_the_suggestion_wraps_the_predicate_of_if_else_statement_in_b
         true
     };
 }
+
+unsafe fn no(v: u8) -> u8 {
+    v
+}
+
+#[allow(clippy::unnecessary_operation)]
+fn needless_bool_condition() -> bool {
+    if unsafe { no(4) } & 1 != 0 {
+        true
+    } else {
+        false
+    };
+    let _brackets_unneeded = if unsafe { no(4) } & 1 != 0 { true } else { false };
+    fn foo() -> bool {
+        // parentheses are needed here
+        if unsafe { no(4) } & 1 != 0 { true } else { false }
+    }
+
+    foo()
+}
diff --git a/tests/ui/needless_bool/fixable.stderr b/tests/ui/needless_bool/fixable.stderr
index 1fa12add167..22c0a7bb491 100644
--- a/tests/ui/needless_bool/fixable.stderr
+++ b/tests/ui/needless_bool/fixable.stderr
@@ -31,7 +31,7 @@ LL | |     };
    | |_____^ help: you can reduce it to: `!(x && y)`
 
 error: this if-then-else expression returns a bool literal
-  --> $DIR/fixable.rs:71:5
+  --> $DIR/fixable.rs:72:5
    |
 LL | /     if x {
 LL | |         return true;
@@ -41,7 +41,7 @@ LL | |     };
    | |_____^ help: you can reduce it to: `return x`
 
 error: this if-then-else expression returns a bool literal
-  --> $DIR/fixable.rs:79:5
+  --> $DIR/fixable.rs:80:5
    |
 LL | /     if x {
 LL | |         return false;
@@ -51,7 +51,7 @@ LL | |     };
    | |_____^ help: you can reduce it to: `return !x`
 
 error: this if-then-else expression returns a bool literal
-  --> $DIR/fixable.rs:87:5
+  --> $DIR/fixable.rs:88:5
    |
 LL | /     if x && y {
 LL | |         return true;
@@ -61,7 +61,7 @@ LL | |     };
    | |_____^ help: you can reduce it to: `return x && y`
 
 error: this if-then-else expression returns a bool literal
-  --> $DIR/fixable.rs:95:5
+  --> $DIR/fixable.rs:96:5
    |
 LL | /     if x && y {
 LL | |         return false;
@@ -71,7 +71,7 @@ LL | |     };
    | |_____^ help: you can reduce it to: `return !(x && y)`
 
 error: equality checks against true are unnecessary
-  --> $DIR/fixable.rs:103:8
+  --> $DIR/fixable.rs:104:8
    |
 LL |     if x == true {};
    |        ^^^^^^^^^ help: try simplifying it as shown: `x`
@@ -79,25 +79,25 @@ LL |     if x == true {};
    = note: `-D clippy::bool-comparison` implied by `-D warnings`
 
 error: equality checks against false can be replaced by a negation
-  --> $DIR/fixable.rs:107:8
+  --> $DIR/fixable.rs:108:8
    |
 LL |     if x == false {};
    |        ^^^^^^^^^^ help: try simplifying it as shown: `!x`
 
 error: equality checks against true are unnecessary
-  --> $DIR/fixable.rs:117:8
+  --> $DIR/fixable.rs:118:8
    |
 LL |     if x == true {};
    |        ^^^^^^^^^ help: try simplifying it as shown: `x`
 
 error: equality checks against false can be replaced by a negation
-  --> $DIR/fixable.rs:118:8
+  --> $DIR/fixable.rs:119:8
    |
 LL |     if x == false {};
    |        ^^^^^^^^^^ help: try simplifying it as shown: `!x`
 
 error: this if-then-else expression returns a bool literal
-  --> $DIR/fixable.rs:127:12
+  --> $DIR/fixable.rs:128:12
    |
 LL |       } else if returns_bool() {
    |  ____________^
@@ -107,5 +107,27 @@ LL | |         true
 LL | |     };
    | |_____^ help: you can reduce it to: `{ !returns_bool() }`
 
-error: aborting due to 12 previous errors
+error: this if-then-else expression returns a bool literal
+  --> $DIR/fixable.rs:141:5
+   |
+LL | /     if unsafe { no(4) } & 1 != 0 {
+LL | |         true
+LL | |     } else {
+LL | |         false
+LL | |     };
+   | |_____^ help: you can reduce it to: `(unsafe { no(4) } & 1 != 0)`
+
+error: this if-then-else expression returns a bool literal
+  --> $DIR/fixable.rs:146:30
+   |
+LL |     let _brackets_unneeded = if unsafe { no(4) } & 1 != 0 { true } else { false };
+   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: you can reduce it to: `unsafe { no(4) } & 1 != 0`
+
+error: this if-then-else expression returns a bool literal
+  --> $DIR/fixable.rs:149:9
+   |
+LL |         if unsafe { no(4) } & 1 != 0 { true } else { false }
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: you can reduce it to: `(unsafe { no(4) } & 1 != 0)`
+
+error: aborting due to 15 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 284b63a687cf9aef61ae4a1ef178ba2c4df60735 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Thu, 1 Apr 2021 10:31:11 -0500
Subject: Rename remove_blocks to peel_blocks

---
 clippy_lints/src/bytecount.rs                   |  4 +--
 clippy_lints/src/derivable_impls.rs             |  4 +--
 clippy_lints/src/map_clone.rs                   |  5 ++--
 clippy_lints/src/matches.rs                     | 10 ++++----
 clippy_lints/src/methods/bind_instead_of_map.rs |  4 +--
 clippy_lints/src/methods/filter_map.rs          |  4 +--
 clippy_lints/src/methods/option_as_ref_deref.rs |  4 +--
 clippy_lints/src/methods/unnecessary_fold.rs    |  4 +--
 clippy_utils/src/lib.rs                         | 33 ++++++++++++++-----------
 9 files changed, 38 insertions(+), 34 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/bytecount.rs b/clippy_lints/src/bytecount.rs
index afb317421d0..657c1f88c7d 100644
--- a/clippy_lints/src/bytecount.rs
+++ b/clippy_lints/src/bytecount.rs
@@ -2,7 +2,7 @@ use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::match_type;
 use clippy_utils::visitors::is_local_used;
-use clippy_utils::{path_to_local_id, paths, peel_ref_operators, remove_blocks, strip_pat_refs};
+use clippy_utils::{path_to_local_id, paths, peel_blocks, peel_ref_operators, strip_pat_refs};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind, PatKind};
@@ -55,7 +55,7 @@ impl<'tcx> LateLintPass<'tcx> for ByteCount {
                        cx.typeck_results().expr_ty(filter_recv).peel_refs(),
                        &paths::SLICE_ITER);
             let operand_is_arg = |expr| {
-                let expr = peel_ref_operators(cx, remove_blocks(expr));
+                let expr = peel_ref_operators(cx, peel_blocks(expr));
                 path_to_local_id(expr, arg_id)
             };
             let needle = if operand_is_arg(l) {
diff --git a/clippy_lints/src/derivable_impls.rs b/clippy_lints/src/derivable_impls.rs
index d0fab2b48fb..eccb18982f3 100644
--- a/clippy_lints/src/derivable_impls.rs
+++ b/clippy_lints/src/derivable_impls.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_help;
-use clippy_utils::{is_automatically_derived, is_default_equivalent, remove_blocks};
+use clippy_utils::{is_automatically_derived, is_default_equivalent, peel_blocks};
 use rustc_hir::{
     def::{DefKind, Res},
     Body, Expr, ExprKind, GenericArg, Impl, ImplItemKind, Item, ItemKind, Node, PathSegment, QPath, TyKind,
@@ -95,7 +95,7 @@ impl<'tcx> LateLintPass<'tcx> for DerivableImpls {
                         }
                     }
                 }
-                let should_emit = match remove_blocks(func_expr).kind {
+                let should_emit = match peel_blocks(func_expr).kind {
                     ExprKind::Tup(fields) => fields.iter().all(|e| is_default_equivalent(cx, e)),
                     ExprKind::Call(callee, args)
                         if is_path_self(callee) => args.iter().all(|e| is_default_equivalent(cx, e)),
diff --git a/clippy_lints/src/map_clone.rs b/clippy_lints/src/map_clone.rs
index c2b78e21861..174c7da28d3 100644
--- a/clippy_lints/src/map_clone.rs
+++ b/clippy_lints/src/map_clone.rs
@@ -1,8 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::is_trait_method;
-use clippy_utils::remove_blocks;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::{is_copy, is_type_diagnostic_item};
+use clippy_utils::{is_trait_method, peel_blocks};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
@@ -60,7 +59,7 @@ impl<'tcx> LateLintPass<'tcx> for MapClone {
             if let hir::ExprKind::Closure(_, _, body_id, _, _) = args[1].kind;
             then {
                 let closure_body = cx.tcx.hir().body(body_id);
-                let closure_expr = remove_blocks(&closure_body.value);
+                let closure_expr = peel_blocks(&closure_body.value);
                 match closure_body.params[0].pat.kind {
                     hir::PatKind::Ref(inner, hir::Mutability::Not) => if let hir::PatKind::Binding(
                         hir::BindingAnnotation::Unannotated, .., name, None
diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index 08c23ca6d32..385232f4d71 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -9,7 +9,7 @@ use clippy_utils::ty::{implements_trait, is_type_diagnostic_item, match_type, pe
 use clippy_utils::visitors::is_local_used;
 use clippy_utils::{
     get_parent_expr, is_expn_of, is_lang_ctor, is_lint_allowed, is_refutable, is_unit_expr, is_wild, meets_msrv, msrvs,
-    path_to_local, path_to_local_id, peel_hir_pat_refs, peel_n_hir_expr_refs, recurse_or_patterns, remove_blocks,
+    path_to_local, path_to_local_id, peel_blocks, peel_hir_pat_refs, peel_n_hir_expr_refs, recurse_or_patterns,
     strip_pat_refs,
 };
 use clippy_utils::{paths, search_same, SpanlessEq, SpanlessHash};
@@ -659,7 +659,7 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
                 QPath::Resolved(None, variant_name), args, _) = arms[0].pat.kind;
             if args.len() == 1;
             if let PatKind::Binding(_, arg, ..) = strip_pat_refs(&args[0]).kind;
-            let body = remove_blocks(arms[0].body);
+            let body = peel_blocks(arms[0].body);
             if path_to_local_id(body, arg);
 
             then {
@@ -724,7 +724,7 @@ fn check_single_match(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>], exp
             return;
         }
         let els = arms[1].body;
-        let els = if is_unit_expr(remove_blocks(els)) {
+        let els = if is_unit_expr(peel_blocks(els)) {
             None
         } else if let ExprKind::Block(Block { stmts, expr: block_expr, .. }, _) = els.kind {
             if stmts.len() == 1 && block_expr.is_none() || stmts.is_empty() && block_expr.is_some() {
@@ -1482,7 +1482,7 @@ fn check_match_single_binding<'a>(cx: &LateContext<'a>, ex: &Expr<'a>, arms: &[A
 
     let matched_vars = ex.span;
     let bind_names = arms[0].pat.span;
-    let match_body = remove_blocks(arms[0].body);
+    let match_body = peel_blocks(arms[0].body);
     let mut snippet_body = if match_body.span.from_expansion() {
         Sugg::hir_with_macro_callsite(cx, match_body, "..").to_string()
     } else {
@@ -1679,7 +1679,7 @@ fn is_ref_some_arm(cx: &LateContext<'_>, arm: &Arm<'_>) -> Option<BindingAnnotat
         if is_lang_ctor(cx, qpath, OptionSome);
         if let PatKind::Binding(rb, .., ident, _) = first_pat.kind;
         if rb == BindingAnnotation::Ref || rb == BindingAnnotation::RefMut;
-        if let ExprKind::Call(e, args) = remove_blocks(arm.body).kind;
+        if let ExprKind::Call(e, args) = peel_blocks(arm.body).kind;
         if let ExprKind::Path(ref some_path) = e.kind;
         if is_lang_ctor(cx, some_path, OptionSome) && args.len() == 1;
         if let ExprKind::Path(QPath::Resolved(_, path2)) = args[0].kind;
diff --git a/clippy_lints/src/methods/bind_instead_of_map.rs b/clippy_lints/src/methods/bind_instead_of_map.rs
index b7690cf9222..150bafc0f5d 100644
--- a/clippy_lints/src/methods/bind_instead_of_map.rs
+++ b/clippy_lints/src/methods/bind_instead_of_map.rs
@@ -1,7 +1,7 @@
 use super::{contains_return, BIND_INSTEAD_OF_MAP};
 use clippy_utils::diagnostics::{multispan_sugg_with_applicability, span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::{snippet, snippet_with_macro_callsite};
-use clippy_utils::{remove_blocks, visitors::find_all_ret_expressions};
+use clippy_utils::{peel_blocks, visitors::find_all_ret_expressions};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
@@ -152,7 +152,7 @@ pub(crate) trait BindInsteadOfMap {
         match arg.kind {
             hir::ExprKind::Closure(_, _, body_id, closure_args_span, _) => {
                 let closure_body = cx.tcx.hir().body(body_id);
-                let closure_expr = remove_blocks(&closure_body.value);
+                let closure_expr = peel_blocks(&closure_body.value);
 
                 if Self::lint_closure_autofixable(cx, expr, recv, closure_expr, closure_args_span) {
                     true
diff --git a/clippy_lints/src/methods/filter_map.rs b/clippy_lints/src/methods/filter_map.rs
index c96c817bb8b..6d8733c08b4 100644
--- a/clippy_lints/src/methods/filter_map.rs
+++ b/clippy_lints/src/methods/filter_map.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::{indent_of, reindent_multiline, snippet};
 use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{is_trait_method, path_to_local_id, remove_blocks, SpanlessEq};
+use clippy_utils::{is_trait_method, path_to_local_id, peel_blocks, SpanlessEq};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
@@ -25,7 +25,7 @@ fn is_method<'tcx>(cx: &LateContext<'tcx>, expr: &hir::Expr<'_>, method_name: Sy
         },
         hir::ExprKind::Closure(_, _, c, _, _) => {
             let body = cx.tcx.hir().body(*c);
-            let closure_expr = remove_blocks(&body.value);
+            let closure_expr = peel_blocks(&body.value);
             let arg_id = body.params[0].pat.hir_id;
             match closure_expr.kind {
                 hir::ExprKind::MethodCall(hir::PathSegment { ident, .. }, _, args, _) => {
diff --git a/clippy_lints/src/methods/option_as_ref_deref.rs b/clippy_lints/src/methods/option_as_ref_deref.rs
index d3f40d26208..fa74a8f3dc3 100644
--- a/clippy_lints/src/methods/option_as_ref_deref.rs
+++ b/clippy_lints/src/methods/option_as_ref_deref.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{match_def_path, meets_msrv, msrvs, path_to_local_id, paths, remove_blocks};
+use clippy_utils::{match_def_path, meets_msrv, msrvs, path_to_local_id, paths, peel_blocks};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
@@ -53,7 +53,7 @@ pub(super) fn check<'tcx>(
             }),
         hir::ExprKind::Closure(_, _, body_id, _, _) => {
             let closure_body = cx.tcx.hir().body(body_id);
-            let closure_expr = remove_blocks(&closure_body.value);
+            let closure_expr = peel_blocks(&closure_body.value);
 
             match &closure_expr.kind {
                 hir::ExprKind::MethodCall(_, _, args, _) => {
diff --git a/clippy_lints/src/methods/unnecessary_fold.rs b/clippy_lints/src/methods/unnecessary_fold.rs
index 4c4034437da..47a81199608 100644
--- a/clippy_lints/src/methods/unnecessary_fold.rs
+++ b/clippy_lints/src/methods/unnecessary_fold.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::{is_trait_method, path_to_local_id, remove_blocks, strip_pat_refs};
+use clippy_utils::{is_trait_method, path_to_local_id, peel_blocks, strip_pat_refs};
 use if_chain::if_chain;
 use rustc_ast::ast;
 use rustc_errors::Applicability;
@@ -31,7 +31,7 @@ pub(super) fn check(
             // Extract the body of the closure passed to fold
             if let hir::ExprKind::Closure(_, _, body_id, _, _) = acc.kind;
             let closure_body = cx.tcx.hir().body(body_id);
-            let closure_expr = remove_blocks(&closure_body.value);
+            let closure_expr = peel_blocks(&closure_body.value);
 
             // Check if the closure body is of the form `acc <op> some_expr(x)`
             if let hir::ExprKind::Binary(ref bin_op, left_expr, right_expr) = closure_expr.kind;
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index f011380c127..2991c5880d5 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -1224,6 +1224,25 @@ pub fn get_parent_as_impl(tcx: TyCtxt<'_>, id: HirId) -> Option<&Impl<'_>> {
     }
 }
 
+/// Removes blocks around an expression, only if the block contains just one expression
+/// and no statements.
+///
+/// Examples:
+///  * `{}`       -> `{}`
+///  * `{ x }`    -> `x`
+///  * `{{ x }}`  -> `x`
+///  * `{ x; }`   -> `{ x; }`
+///  * `{ x; y }` -> `{ x; y }`
+pub fn peel_blocks<'tcx>(mut expr: &'tcx Expr<'tcx>) -> &'tcx Expr<'tcx> {
+    while let ExprKind::Block(block, ..) = expr.kind {
+        match (block.stmts.is_empty(), block.expr.as_ref()) {
+            (true, Some(e)) => expr = e,
+            _ => break,
+        }
+    }
+    expr
+}
+
 /// Checks if the given expression is the else clause of either an `if` or `if let` expression.
 pub fn is_else_clause(tcx: TyCtxt<'_>, expr: &Expr<'_>) -> bool {
     let mut iter = tcx.hir().parent_iter(expr.hir_id);
@@ -1405,20 +1424,6 @@ pub fn is_automatically_derived(attrs: &[ast::Attribute]) -> bool {
     has_attr(attrs, sym::automatically_derived)
 }
 
-/// Remove blocks around an expression.
-///
-/// Ie. `x`, `{ x }` and `{{{{ x }}}}` all give `x`. `{ x; y }` and `{}` return
-/// themselves.
-pub fn remove_blocks<'tcx>(mut expr: &'tcx Expr<'tcx>) -> &'tcx Expr<'tcx> {
-    while let ExprKind::Block(block, ..) = expr.kind {
-        match (block.stmts.is_empty(), block.expr.as_ref()) {
-            (true, Some(e)) => expr = e,
-            _ => break,
-        }
-    }
-    expr
-}
-
 pub fn is_self(slf: &Param<'_>) -> bool {
     if let PatKind::Binding(.., name, _) = slf.pat.kind {
         name.name == kw::SelfLower
-- 
cgit 1.4.1-3-g733a5


From f690ef6f5c0d6af58e8e908b8e08c09c4921ac35 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Mon, 29 Nov 2021 08:34:36 -0600
Subject: Refactors with peel_blocks

---
 clippy_lints/src/assertions_on_constants.rs        |  12 +--
 clippy_lints/src/collapsible_match.rs              |  20 +---
 clippy_lints/src/floating_point_arithmetic.rs      |  12 +--
 clippy_lints/src/if_then_some_else_none.rs         |   7 +-
 clippy_lints/src/implicit_saturating_sub.rs        |  16 +--
 clippy_lints/src/loops/manual_flatten.rs           | 112 +++++++++------------
 clippy_lints/src/loops/never_loop.rs               |   4 +-
 clippy_lints/src/manual_map.rs                     |  15 +--
 clippy_lints/src/no_effect.rs                      |   6 +-
 clippy_lints/src/option_if_let_else.rs             |  33 +-----
 clippy_lints/src/question_mark.rs                  |  63 ++----------
 clippy_lints/src/strings.rs                        |   7 +-
 clippy_lints/src/utils/internal_lints.rs           |  10 +-
 .../src/utils/internal_lints/metadata_collector.rs |  11 +-
 clippy_utils/src/lib.rs                            |  75 +++++++++++---
 15 files changed, 151 insertions(+), 252 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/assertions_on_constants.rs b/clippy_lints/src/assertions_on_constants.rs
index 521fc84ee9c..b7f414742f1 100644
--- a/clippy_lints/src/assertions_on_constants.rs
+++ b/clippy_lints/src/assertions_on_constants.rs
@@ -2,7 +2,7 @@ use clippy_utils::consts::{constant, Constant};
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::higher;
 use clippy_utils::source::snippet_opt;
-use clippy_utils::{is_direct_expn_of, is_expn_of, match_panic_call};
+use clippy_utils::{is_direct_expn_of, is_expn_of, match_panic_call, peel_blocks};
 use if_chain::if_chain;
 use rustc_hir::{Expr, ExprKind, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
@@ -122,15 +122,7 @@ fn match_assert_with_message<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>)
         if let ExprKind::Unary(UnOp::Not, expr) = cond.kind;
         // bind the first argument of the `assert!` macro
         if let Some((Constant::Bool(is_true), _)) = constant(cx, cx.typeck_results(), expr);
-        // block
-        if let ExprKind::Block(block, _) = then.kind;
-        if block.stmts.is_empty();
-        if let Some(block_expr) = &block.expr;
-        // inner block is optional. unwrap it if it exists, or use the expression as is otherwise.
-        if let Some(begin_panic_call) = match block_expr.kind {
-            ExprKind::Block(inner_block, _) => &inner_block.expr,
-            _ => &block.expr,
-        };
+        let begin_panic_call = peel_blocks(then);
         // function call
         if let Some(arg) = match_panic_call(cx, begin_panic_call);
         // bind the second argument of the `assert!` macro if it exists
diff --git a/clippy_lints/src/collapsible_match.rs b/clippy_lints/src/collapsible_match.rs
index 626f9971f01..c71e9f10f79 100644
--- a/clippy_lints/src/collapsible_match.rs
+++ b/clippy_lints/src/collapsible_match.rs
@@ -1,10 +1,10 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::higher::IfLetOrMatch;
 use clippy_utils::visitors::is_local_used;
-use clippy_utils::{is_lang_ctor, is_unit_expr, path_to_local, peel_ref_operators, SpanlessEq};
+use clippy_utils::{is_lang_ctor, is_unit_expr, path_to_local, peel_blocks_with_stmt, peel_ref_operators, SpanlessEq};
 use if_chain::if_chain;
 use rustc_hir::LangItem::OptionNone;
-use rustc_hir::{Arm, Expr, ExprKind, Guard, HirId, Pat, PatKind, StmtKind};
+use rustc_hir::{Arm, Expr, Guard, HirId, Pat, PatKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::{MultiSpan, Span};
@@ -75,7 +75,7 @@ fn check_arm<'tcx>(
     outer_guard: Option<&'tcx Guard<'tcx>>,
     outer_else_body: Option<&'tcx Expr<'tcx>>,
 ) {
-    let inner_expr = strip_singleton_blocks(outer_then_body);
+    let inner_expr = peel_blocks_with_stmt(outer_then_body);
     if_chain! {
         if let Some(inner) = IfLetOrMatch::parse(cx, inner_expr);
         if let Some((inner_scrutinee, inner_then_pat, inner_else_body)) = match inner {
@@ -138,20 +138,6 @@ fn check_arm<'tcx>(
     }
 }
 
-fn strip_singleton_blocks<'hir>(mut expr: &'hir Expr<'hir>) -> &'hir Expr<'hir> {
-    while let ExprKind::Block(block, _) = expr.kind {
-        match (block.stmts, block.expr) {
-            ([stmt], None) => match stmt.kind {
-                StmtKind::Expr(e) | StmtKind::Semi(e) => expr = e,
-                _ => break,
-            },
-            ([], Some(e)) => expr = e,
-            _ => break,
-        }
-    }
-    expr
-}
-
 /// A "wild-like" arm has a wild (`_`) or `None` pattern and no guard. Such arms can be "collapsed"
 /// into a single wild arm without any significant loss in semantics or readability.
 fn arm_is_wild_like(cx: &LateContext<'_>, arm: &Arm<'_>) -> bool {
diff --git a/clippy_lints/src/floating_point_arithmetic.rs b/clippy_lints/src/floating_point_arithmetic.rs
index 3df511ea8e7..2de2bfc040b 100644
--- a/clippy_lints/src/floating_point_arithmetic.rs
+++ b/clippy_lints/src/floating_point_arithmetic.rs
@@ -4,7 +4,7 @@ use clippy_utils::consts::{
 };
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::higher;
-use clippy_utils::{eq_expr_value, get_parent_expr, in_constant, numeric_literal, sugg};
+use clippy_utils::{eq_expr_value, get_parent_expr, in_constant, numeric_literal, peel_blocks, sugg};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind, PathSegment, UnOp};
@@ -546,13 +546,9 @@ fn are_negated<'a>(cx: &LateContext<'_>, expr1: &'a Expr<'a>, expr2: &'a Expr<'a
 
 fn check_custom_abs(cx: &LateContext<'_>, expr: &Expr<'_>) {
     if_chain! {
-        if let Some(higher::If { cond, then, r#else }) = higher::If::hir(expr);
-        if let ExprKind::Block(block, _) = then.kind;
-        if block.stmts.is_empty();
-        if let Some(if_body_expr) = block.expr;
-        if let Some(ExprKind::Block(else_block, _)) = r#else.map(|el| &el.kind);
-        if else_block.stmts.is_empty();
-        if let Some(else_body_expr) = else_block.expr;
+        if let Some(higher::If { cond, then, r#else: Some(r#else) }) = higher::If::hir(expr);
+        let if_body_expr = peel_blocks(then);
+        let else_body_expr = peel_blocks(r#else);
         if let Some((if_expr_positive, body)) = are_negated(cx, if_body_expr, else_body_expr);
         then {
             let positive_abs_sugg = (
diff --git a/clippy_lints/src/if_then_some_else_none.rs b/clippy_lints/src/if_then_some_else_none.rs
index 30d222bd7d2..16e5c5ca603 100644
--- a/clippy_lints/src/if_then_some_else_none.rs
+++ b/clippy_lints/src/if_then_some_else_none.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::source::snippet_with_macro_callsite;
-use clippy_utils::{contains_return, higher, is_else_clause, is_lang_ctor, meets_msrv, msrvs};
+use clippy_utils::{contains_return, higher, is_else_clause, is_lang_ctor, meets_msrv, msrvs, peel_blocks};
 use if_chain::if_chain;
 use rustc_hir::LangItem::{OptionNone, OptionSome};
 use rustc_hir::{Expr, ExprKind, Stmt, StmtKind};
@@ -77,10 +77,7 @@ impl LateLintPass<'_> for IfThenSomeElseNone {
             if let ExprKind::Call(then_call, [then_arg]) = then_expr.kind;
             if let ExprKind::Path(ref then_call_qpath) = then_call.kind;
             if is_lang_ctor(cx, then_call_qpath, OptionSome);
-            if let ExprKind::Block(els_block, _) = els.kind;
-            if els_block.stmts.is_empty();
-            if let Some(els_expr) = els_block.expr;
-            if let ExprKind::Path(ref qpath) = els_expr.kind;
+            if let ExprKind::Path(ref qpath) = peel_blocks(els).kind;
             if is_lang_ctor(cx, qpath, OptionNone);
             if !stmts_contains_early_return(then_block.stmts);
             then {
diff --git a/clippy_lints/src/implicit_saturating_sub.rs b/clippy_lints/src/implicit_saturating_sub.rs
index 4088c54623d..26a196aab59 100644
--- a/clippy_lints/src/implicit_saturating_sub.rs
+++ b/clippy_lints/src/implicit_saturating_sub.rs
@@ -1,10 +1,9 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::higher;
-use clippy_utils::SpanlessEq;
+use clippy_utils::{higher, peel_blocks_with_stmt, SpanlessEq};
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
-use rustc_hir::{lang_items::LangItem, BinOpKind, Expr, ExprKind, QPath, StmtKind};
+use rustc_hir::{lang_items::LangItem, BinOpKind, Expr, ExprKind, QPath};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
@@ -52,13 +51,8 @@ impl<'tcx> LateLintPass<'tcx> for ImplicitSaturatingSub {
             // Ensure that the binary operator is >, != and <
             if BinOpKind::Ne == cond_op.node || BinOpKind::Gt == cond_op.node || BinOpKind::Lt == cond_op.node;
 
-            // Check if the true condition block has only one statement
-            if let ExprKind::Block(block, _) = then.kind;
-            if block.stmts.len() == 1 && block.expr.is_none();
-
             // Check if assign operation is done
-            if let StmtKind::Semi(e) = block.stmts[0].kind;
-            if let Some(target) = subtracts_one(cx, e);
+            if let Some(target) = subtracts_one(cx, then);
 
             // Extracting out the variable name
             if let ExprKind::Path(QPath::Resolved(_, ares_path)) = target.kind;
@@ -138,8 +132,8 @@ impl<'tcx> LateLintPass<'tcx> for ImplicitSaturatingSub {
     }
 }
 
-fn subtracts_one<'a>(cx: &LateContext<'_>, expr: &Expr<'a>) -> Option<&'a Expr<'a>> {
-    match expr.kind {
+fn subtracts_one<'a>(cx: &LateContext<'_>, expr: &'a Expr<'a>) -> Option<&'a Expr<'a>> {
+    match peel_blocks_with_stmt(expr).kind {
         ExprKind::AssignOp(ref op1, target, value) => {
             if_chain! {
                 if BinOpKind::Sub == op1.node;
diff --git a/clippy_lints/src/loops/manual_flatten.rs b/clippy_lints/src/loops/manual_flatten.rs
index 5b6e27085d5..d276c901059 100644
--- a/clippy_lints/src/loops/manual_flatten.rs
+++ b/clippy_lints/src/loops/manual_flatten.rs
@@ -3,11 +3,11 @@ use super::MANUAL_FLATTEN;
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::higher;
 use clippy_utils::visitors::is_local_used;
-use clippy_utils::{is_lang_ctor, path_to_local_id};
+use clippy_utils::{is_lang_ctor, path_to_local_id, peel_blocks_with_stmt};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::LangItem::{OptionSome, ResultOk};
-use rustc_hir::{Expr, ExprKind, Pat, PatKind, StmtKind};
+use rustc_hir::{Expr, Pat, PatKind};
 use rustc_lint::LateContext;
 use rustc_middle::ty;
 use rustc_span::source_map::Span;
@@ -21,71 +21,55 @@ pub(super) fn check<'tcx>(
     body: &'tcx Expr<'_>,
     span: Span,
 ) {
-    if let ExprKind::Block(block, _) = body.kind {
-        // Ensure the `if let` statement is the only expression or statement in the for-loop
-        let inner_expr = if block.stmts.len() == 1 && block.expr.is_none() {
-            let match_stmt = &block.stmts[0];
-            if let StmtKind::Semi(inner_expr) = match_stmt.kind {
-                Some(inner_expr)
-            } else {
-                None
-            }
-        } else if block.stmts.is_empty() {
-            block.expr
-        } else {
-            None
-        };
+    let inner_expr = peel_blocks_with_stmt(body);
+    if_chain! {
+        if let Some(higher::IfLet { let_pat, let_expr, if_then, if_else: None })
+            = higher::IfLet::hir(cx, inner_expr);
+        // Ensure match_expr in `if let` statement is the same as the pat from the for-loop
+        if let PatKind::Binding(_, pat_hir_id, _, _) = pat.kind;
+        if path_to_local_id(let_expr, pat_hir_id);
+        // Ensure the `if let` statement is for the `Some` variant of `Option` or the `Ok` variant of `Result`
+        if let PatKind::TupleStruct(ref qpath, _, _) = let_pat.kind;
+        let some_ctor = is_lang_ctor(cx, qpath, OptionSome);
+        let ok_ctor = is_lang_ctor(cx, qpath, ResultOk);
+        if some_ctor || ok_ctor;
+        // Ensure expr in `if let` is not used afterwards
+        if !is_local_used(cx, if_then, pat_hir_id);
+        then {
+            let if_let_type = if some_ctor { "Some" } else { "Ok" };
+            // Prepare the error message
+            let msg = format!("unnecessary `if let` since only the `{}` variant of the iterator element is used", if_let_type);
 
-        if_chain! {
-            if let Some(inner_expr) = inner_expr;
-            if let Some(higher::IfLet { let_pat, let_expr, if_then, if_else: None })
-                = higher::IfLet::hir(cx, inner_expr);
-            // Ensure match_expr in `if let` statement is the same as the pat from the for-loop
-            if let PatKind::Binding(_, pat_hir_id, _, _) = pat.kind;
-            if path_to_local_id(let_expr, pat_hir_id);
-            // Ensure the `if let` statement is for the `Some` variant of `Option` or the `Ok` variant of `Result`
-            if let PatKind::TupleStruct(ref qpath, _, _) = let_pat.kind;
-            let some_ctor = is_lang_ctor(cx, qpath, OptionSome);
-            let ok_ctor = is_lang_ctor(cx, qpath, ResultOk);
-            if some_ctor || ok_ctor;
-            // Ensure epxr in `if let` is not used afterwards
-            if !is_local_used(cx, if_then, pat_hir_id);
-            then {
-                let if_let_type = if some_ctor { "Some" } else { "Ok" };
-                // Prepare the error message
-                let msg = format!("unnecessary `if let` since only the `{}` variant of the iterator element is used", if_let_type);
-
-                // Prepare the help message
-                let mut applicability = Applicability::MaybeIncorrect;
-                let arg_snippet = make_iterator_snippet(cx, arg, &mut applicability);
-                let copied = match cx.typeck_results().expr_ty(let_expr).kind() {
-                    ty::Ref(_, inner, _) => match inner.kind() {
-                        ty::Ref(..) => ".copied()",
-                        _ => ""
-                    }
+            // Prepare the help message
+            let mut applicability = Applicability::MaybeIncorrect;
+            let arg_snippet = make_iterator_snippet(cx, arg, &mut applicability);
+            let copied = match cx.typeck_results().expr_ty(let_expr).kind() {
+                ty::Ref(_, inner, _) => match inner.kind() {
+                    ty::Ref(..) => ".copied()",
                     _ => ""
-                };
+                }
+                _ => ""
+            };
 
-                span_lint_and_then(
-                    cx,
-                    MANUAL_FLATTEN,
-                    span,
-                    &msg,
-                    |diag| {
-                        let sugg = format!("{}{}.flatten()", arg_snippet, copied);
-                        diag.span_suggestion(
-                            arg.span,
-                            "try",
-                            sugg,
-                            Applicability::MaybeIncorrect,
-                        );
-                        diag.span_help(
-                            inner_expr.span,
-                            "...and remove the `if let` statement in the for loop",
-                        );
-                    }
-                );
-            }
+            span_lint_and_then(
+                cx,
+                MANUAL_FLATTEN,
+                span,
+                &msg,
+                |diag| {
+                    let sugg = format!("{}{}.flatten()", arg_snippet, copied);
+                    diag.span_suggestion(
+                        arg.span,
+                        "try",
+                        sugg,
+                        Applicability::MaybeIncorrect,
+                    );
+                    diag.span_help(
+                        inner_expr.span,
+                        "...and remove the `if let` statement in the for loop",
+                    );
+                }
+            );
         }
     }
 }
diff --git a/clippy_lints/src/loops/never_loop.rs b/clippy_lints/src/loops/never_loop.rs
index 86b7d6d989a..68ffcd1abfb 100644
--- a/clippy_lints/src/loops/never_loop.rs
+++ b/clippy_lints/src/loops/never_loop.rs
@@ -92,9 +92,7 @@ fn combine_branches(b1: NeverLoopResult, b2: NeverLoopResult) -> NeverLoopResult
 }
 
 fn never_loop_block(block: &Block<'_>, main_loop_id: HirId) -> NeverLoopResult {
-    let stmts = block.stmts.iter().map(stmt_to_expr);
-    let expr = once(block.expr);
-    let mut iter = stmts.chain(expr).flatten();
+    let mut iter = block.stmts.iter().filter_map(stmt_to_expr).chain(block.expr);
     never_loop_expr_seq(&mut iter, main_loop_id)
 }
 
diff --git a/clippy_lints/src/manual_map.rs b/clippy_lints/src/manual_map.rs
index 4d8ad566e6b..34a70ca76c6 100644
--- a/clippy_lints/src/manual_map.rs
+++ b/clippy_lints/src/manual_map.rs
@@ -5,7 +5,7 @@ use clippy_utils::source::{snippet_with_applicability, snippet_with_context};
 use clippy_utils::ty::{is_type_diagnostic_item, peel_mid_ty_refs_is_mutable, type_is_unsafe_function};
 use clippy_utils::{
     can_move_expr_to_closure, in_constant, is_else_clause, is_lang_ctor, is_lint_allowed, path_to_local_id,
-    peel_hir_expr_refs, peel_hir_expr_while, CaptureKind,
+    peel_blocks, peel_hir_expr_refs, peel_hir_expr_while, CaptureKind,
 };
 use rustc_ast::util::parser::PREC_POSTFIX;
 use rustc_errors::Applicability;
@@ -307,16 +307,5 @@ fn get_some_expr(
 
 // Checks for the `None` value.
 fn is_none_expr(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> bool {
-    match expr.kind {
-        ExprKind::Path(ref qpath) => is_lang_ctor(cx, qpath, OptionNone),
-        ExprKind::Block(
-            Block {
-                stmts: [],
-                expr: Some(expr),
-                ..
-            },
-            _,
-        ) => is_none_expr(cx, expr),
-        _ => false,
-    }
+    matches!(peel_blocks(expr).kind, ExprKind::Path(ref qpath) if is_lang_ctor(cx, qpath, OptionNone))
 }
diff --git a/clippy_lints/src/no_effect.rs b/clippy_lints/src/no_effect.rs
index 6fcc9ca29b9..9d5babc5de8 100644
--- a/clippy_lints/src/no_effect.rs
+++ b/clippy_lints/src/no_effect.rs
@@ -1,5 +1,6 @@
 use clippy_utils::diagnostics::{span_lint_hir, span_lint_hir_and_then};
 use clippy_utils::is_lint_allowed;
+use clippy_utils::peel_blocks;
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::has_drop;
 use rustc_errors::Applicability;
@@ -114,7 +115,7 @@ fn has_no_effect(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
     if expr.span.from_expansion() {
         return false;
     }
-    match expr.kind {
+    match peel_blocks(expr).kind {
         ExprKind::Lit(..) | ExprKind::Closure(..) => true,
         ExprKind::Path(..) => !has_drop(cx, cx.typeck_results().expr_ty(expr)),
         ExprKind::Index(a, b) | ExprKind::Binary(_, a, b) => has_no_effect(cx, a) && has_no_effect(cx, b),
@@ -150,9 +151,6 @@ fn has_no_effect(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
                 false
             }
         },
-        ExprKind::Block(block, _) => {
-            block.stmts.is_empty() && block.expr.as_ref().map_or(false, |expr| has_no_effect(cx, expr))
-        },
         _ => false,
     }
 }
diff --git a/clippy_lints/src/option_if_let_else.rs b/clippy_lints/src/option_if_let_else.rs
index 262be17f617..897207ebf50 100644
--- a/clippy_lints/src/option_if_let_else.rs
+++ b/clippy_lints/src/option_if_let_else.rs
@@ -1,15 +1,14 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::higher;
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::{
-    can_move_expr_to_closure, eager_or_lazy, in_constant, is_else_clause, is_lang_ctor, peel_hir_expr_while,
-    CaptureKind,
+    can_move_expr_to_closure, eager_or_lazy, higher, in_constant, is_else_clause, is_lang_ctor, peel_blocks,
+    peel_hir_expr_while, CaptureKind,
 };
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::LangItem::OptionSome;
-use rustc_hir::{def::Res, BindingAnnotation, Block, Expr, ExprKind, Mutability, PatKind, Path, QPath, UnOp};
+use rustc_hir::{def::Res, BindingAnnotation, Expr, ExprKind, Mutability, PatKind, Path, QPath, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::sym;
@@ -86,28 +85,6 @@ struct OptionIfLetElseOccurence {
     none_expr: String,
 }
 
-/// Extracts the body of a given arm. If the arm contains only an expression,
-/// then it returns the expression. Otherwise, it returns the entire block
-fn extract_body_from_expr<'a>(expr: &'a Expr<'a>) -> Option<&'a Expr<'a>> {
-    if let ExprKind::Block(
-        Block {
-            stmts: block_stmts,
-            expr: Some(block_expr),
-            ..
-        },
-        _,
-    ) = expr.kind
-    {
-        if let [] = block_stmts {
-            Some(block_expr)
-        } else {
-            Some(expr)
-        }
-    } else {
-        None
-    }
-}
-
 fn format_option_in_sugg(cx: &LateContext<'_>, cond_expr: &Expr<'_>, as_ref: bool, as_mut: bool) -> String {
     format!(
         "{}{}",
@@ -145,8 +122,8 @@ fn detect_option_if_let_else<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>) ->
 
         then {
             let capture_mut = if bind_annotation == &BindingAnnotation::Mutable { "mut " } else { "" };
-            let some_body = extract_body_from_expr(if_then)?;
-            let none_body = extract_body_from_expr(if_else)?;
+            let some_body = peel_blocks(if_then);
+            let none_body = peel_blocks(if_else);
             let method_sugg = if eager_or_lazy::switch_to_eager_eval(cx, none_body) { "map_or" } else { "map_or_else" };
             let capture_name = id.name.to_ident_string();
             let (as_ref, as_mut) = match &let_expr.kind {
diff --git a/clippy_lints/src/question_mark.rs b/clippy_lints/src/question_mark.rs
index a5531993ee6..65a962dcd21 100644
--- a/clippy_lints/src/question_mark.rs
+++ b/clippy_lints/src/question_mark.rs
@@ -1,14 +1,13 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::higher;
-use clippy_utils::is_lang_ctor;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{eq_expr_value, path_to_local, path_to_local_id};
+use clippy_utils::{eq_expr_value, is_lang_ctor, path_to_local, path_to_local_id, peel_blocks, peel_blocks_with_stmt};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::LangItem::{OptionNone, OptionSome, ResultOk};
-use rustc_hir::{BindingAnnotation, Block, Expr, ExprKind, PatKind, StmtKind};
+use rustc_hir::{BindingAnnotation, Expr, ExprKind, PatKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::sym;
@@ -68,14 +67,8 @@ impl QuestionMark {
                 let receiver_str = &Sugg::hir_with_applicability(cx, subject, "..", &mut applicability);
                 let mut replacement: Option<String> = None;
                 if let Some(else_inner) = r#else {
-                    if_chain! {
-                        if let ExprKind::Block(block, None) = &else_inner.kind;
-                        if block.stmts.is_empty();
-                        if let Some(block_expr) = &block.expr;
-                        if eq_expr_value(cx, subject, block_expr);
-                        then {
-                            replacement = Some(format!("Some({}?)", receiver_str));
-                        }
+                    if eq_expr_value(cx, subject, peel_blocks(else_inner)) {
+                        replacement = Some(format!("Some({}?)", receiver_str));
                     }
                 } else if Self::moves_by_default(cx, subject)
                     && !matches!(subject.kind, ExprKind::Call(..) | ExprKind::MethodCall(..))
@@ -110,10 +103,7 @@ impl QuestionMark {
 
             if let PatKind::Binding(annot, bind_id, _, _) = fields[0].kind;
             let by_ref = matches!(annot, BindingAnnotation::Ref | BindingAnnotation::RefMut);
-            if let ExprKind::Block(block, None) = if_then.kind;
-            if block.stmts.is_empty();
-            if let Some(trailing_expr) = &block.expr;
-            if path_to_local_id(trailing_expr, bind_id);
+            if path_to_local_id(peel_blocks(if_then), bind_id);
             then {
                 let mut applicability = Applicability::MachineApplicable;
                 let receiver_str = snippet_with_applicability(cx, let_expr.span, "..", &mut applicability);
@@ -159,14 +149,7 @@ impl QuestionMark {
     }
 
     fn expression_returns_none(cx: &LateContext<'_>, expression: &Expr<'_>) -> bool {
-        match expression.kind {
-            ExprKind::Block(block, _) => {
-                if let Some(return_expression) = Self::return_expression(block) {
-                    return Self::expression_returns_none(cx, return_expression);
-                }
-
-                false
-            },
+        match peel_blocks_with_stmt(expression).kind {
             ExprKind::Ret(Some(expr)) => Self::expression_returns_none(cx, expr),
             ExprKind::Path(ref qpath) => is_lang_ctor(cx, qpath, OptionNone),
             _ => false,
@@ -174,44 +157,12 @@ impl QuestionMark {
     }
 
     fn expression_returns_unmodified_err(cx: &LateContext<'_>, expr: &Expr<'_>, cond_expr: &Expr<'_>) -> bool {
-        match expr.kind {
-            ExprKind::Block(block, _) => {
-                if let Some(return_expression) = Self::return_expression(block) {
-                    return Self::expression_returns_unmodified_err(cx, return_expression, cond_expr);
-                }
-
-                false
-            },
+        match peel_blocks_with_stmt(expr).kind {
             ExprKind::Ret(Some(ret_expr)) => Self::expression_returns_unmodified_err(cx, ret_expr, cond_expr),
             ExprKind::Path(_) => path_to_local(expr) == path_to_local(cond_expr),
             _ => false,
         }
     }
-
-    fn return_expression<'tcx>(block: &Block<'tcx>) -> Option<&'tcx Expr<'tcx>> {
-        // Check if last expression is a return statement. Then, return the expression
-        if_chain! {
-            if block.stmts.len() == 1;
-            if let Some(expr) = block.stmts.iter().last();
-            if let StmtKind::Semi(expr) = expr.kind;
-            if let ExprKind::Ret(Some(ret_expr)) = expr.kind;
-
-            then {
-                return Some(ret_expr);
-            }
-        }
-
-        // Check for `return` without a semicolon.
-        if_chain! {
-            if block.stmts.is_empty();
-            if let Some(ExprKind::Ret(Some(ret_expr))) = block.expr.as_ref().map(|e| &e.kind);
-            then {
-                return Some(ret_expr);
-            }
-        }
-
-        None
-    }
 }
 
 impl<'tcx> LateLintPass<'tcx> for QuestionMark {
diff --git a/clippy_lints/src/strings.rs b/clippy_lints/src/strings.rs
index 368274440d5..b03f4583365 100644
--- a/clippy_lints/src/strings.rs
+++ b/clippy_lints/src/strings.rs
@@ -1,8 +1,8 @@
 use clippy_utils::diagnostics::{span_lint, span_lint_and_help, span_lint_and_sugg};
 use clippy_utils::source::{snippet, snippet_with_applicability};
 use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::SpanlessEq;
 use clippy_utils::{get_parent_expr, is_lint_allowed, match_function_call, method_calls, paths};
+use clippy_utils::{peel_blocks, SpanlessEq};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, BorrowKind, Expr, ExprKind, LangItem, QPath};
@@ -201,7 +201,7 @@ fn is_string(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
 }
 
 fn is_add(cx: &LateContext<'_>, src: &Expr<'_>, target: &Expr<'_>) -> bool {
-    match src.kind {
+    match peel_blocks(src).kind {
         ExprKind::Binary(
             Spanned {
                 node: BinOpKind::Add, ..
@@ -209,9 +209,6 @@ fn is_add(cx: &LateContext<'_>, src: &Expr<'_>, target: &Expr<'_>) -> bool {
             left,
             _,
         ) => SpanlessEq::new(cx).eq_expr(target, left),
-        ExprKind::Block(block, _) => {
-            block.stmts.is_empty() && block.expr.as_ref().map_or(false, |expr| is_add(cx, expr, target))
-        },
         _ => false,
     }
 }
diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs
index 1f97c8ba7e6..81e9c2e15c9 100644
--- a/clippy_lints/src/utils/internal_lints.rs
+++ b/clippy_lints/src/utils/internal_lints.rs
@@ -1,11 +1,10 @@
 use clippy_utils::consts::{constant_simple, Constant};
 use clippy_utils::diagnostics::{span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then};
-use clippy_utils::higher;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::match_type;
 use clippy_utils::{
-    is_else_clause, is_expn_of, is_expr_path_def_path, is_lint_allowed, match_def_path, method_calls, path_to_res,
-    paths, SpanlessEq,
+    higher, is_else_clause, is_expn_of, is_expr_path_def_path, is_lint_allowed, match_def_path, method_calls,
+    path_to_res, paths, peel_blocks_with_stmt, SpanlessEq,
 };
 use if_chain::if_chain;
 use rustc_ast as ast;
@@ -662,10 +661,7 @@ impl<'tcx> LateLintPass<'tcx> for CollapsibleCalls {
             if and_then_args.len() == 5;
             if let ExprKind::Closure(_, _, body_id, _, _) = &and_then_args[4].kind;
             let body = cx.tcx.hir().body(*body_id);
-            if let ExprKind::Block(block, _) = &body.value.kind;
-            let stmts = &block.stmts;
-            if stmts.len() == 1 && block.expr.is_none();
-            if let StmtKind::Semi(only_expr) = &stmts[0].kind;
+            let only_expr = peel_blocks_with_stmt(&body.value);
             if let ExprKind::MethodCall(ps, _, span_call_args, _) = &only_expr.kind;
             then {
                 let and_then_snippets = get_and_then_snippets(cx, and_then_args);
diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index 8051c58bad7..7707eebd622 100644
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -8,6 +8,11 @@
 //! during any comparison or mapping. (Please take care of this, it's not fun to spend time on such
 //! a simple mistake)
 
+use crate::utils::internal_lints::{extract_clippy_version_value, is_lint_ref_type};
+
+use clippy_utils::diagnostics::span_lint;
+use clippy_utils::ty::{match_type, walk_ptrs_ty_depth};
+use clippy_utils::{last_path_segment, match_def_path, match_function_call, match_path, paths};
 use if_chain::if_chain;
 use rustc_ast as ast;
 use rustc_data_structures::fx::FxHashMap;
@@ -25,12 +30,6 @@ use std::fs::{self, OpenOptions};
 use std::io::prelude::*;
 use std::path::Path;
 
-use crate::utils::internal_lints::{extract_clippy_version_value, is_lint_ref_type};
-use clippy_utils::{
-    diagnostics::span_lint, last_path_segment, match_def_path, match_function_call, match_path, paths, ty::match_type,
-    ty::walk_ptrs_ty_depth,
-};
-
 /// This is the output file of the lint collector.
 const OUTPUT_FILE: &str = "../util/gh-pages/lints.json";
 /// These lints are excluded from the export.
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 2991c5880d5..4e214361435 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -73,10 +73,10 @@ use rustc_hir::intravisit::{walk_expr, ErasedMap, FnKind, NestedVisitorMap, Visi
 use rustc_hir::itemlikevisit::ItemLikeVisitor;
 use rustc_hir::LangItem::{OptionNone, ResultErr, ResultOk};
 use rustc_hir::{
-    def, Arm, BindingAnnotation, Block, Body, Constness, Destination, Expr, ExprKind, FnDecl, ForeignItem, GenericArgs,
-    HirId, Impl, ImplItem, ImplItemKind, IsAsync, Item, ItemKind, LangItem, Local, MatchSource, Mutability, Node,
-    Param, Pat, PatKind, Path, PathSegment, PrimTy, QPath, Stmt, StmtKind, TraitItem, TraitItemKind, TraitRef, TyKind,
-    UnOp,
+    def, Arm, BindingAnnotation, Block, BlockCheckMode, Body, Constness, Destination, Expr, ExprKind, FnDecl,
+    ForeignItem, GenericArgs, HirId, Impl, ImplItem, ImplItemKind, IsAsync, Item, ItemKind, LangItem, Local,
+    MatchSource, Mutability, Node, Param, Pat, PatKind, Path, PathSegment, PrimTy, QPath, Stmt, StmtKind, TraitItem,
+    TraitItemKind, TraitRef, TyKind, UnOp,
 };
 use rustc_lint::{LateContext, Level, Lint, LintContext};
 use rustc_middle::hir::exports::Export;
@@ -1225,20 +1225,65 @@ pub fn get_parent_as_impl(tcx: TyCtxt<'_>, id: HirId) -> Option<&Impl<'_>> {
 }
 
 /// Removes blocks around an expression, only if the block contains just one expression
-/// and no statements.
+/// and no statements. Unsafe blocks are not removed.
 ///
 /// Examples:
-///  * `{}`       -> `{}`
-///  * `{ x }`    -> `x`
-///  * `{{ x }}`  -> `x`
-///  * `{ x; }`   -> `{ x; }`
-///  * `{ x; y }` -> `{ x; y }`
-pub fn peel_blocks<'tcx>(mut expr: &'tcx Expr<'tcx>) -> &'tcx Expr<'tcx> {
-    while let ExprKind::Block(block, ..) = expr.kind {
-        match (block.stmts.is_empty(), block.expr.as_ref()) {
-            (true, Some(e)) => expr = e,
-            _ => break,
+///  * `{}`               -> `{}`
+///  * `{ x }`            -> `x`
+///  * `{{ x }}`          -> `x`
+///  * `{ x; }`           -> `{ x; }`
+///  * `{ x; y }`         -> `{ x; y }`
+///  * `{ unsafe { x } }` -> `unsafe { x }`
+pub fn peel_blocks<'a>(mut expr: &'a Expr<'a>) -> &'a Expr<'a> {
+    while let ExprKind::Block(
+        Block {
+            stmts: [],
+            expr: Some(inner),
+            rules: BlockCheckMode::DefaultBlock,
+            ..
+        },
+        _,
+    ) = expr.kind
+    {
+        expr = inner;
+    }
+    expr
+}
+
+/// Removes blocks around an expression, only if the block contains just one expression
+/// or just one expression statement with a semicolon. Unsafe blocks are not removed.
+///
+/// Examples:
+///  * `{}`               -> `{}`
+///  * `{ x }`            -> `x`
+///  * `{ x; }`           -> `x`
+///  * `{{ x; }}`         -> `x`
+///  * `{ x; y }`         -> `{ x; y }`
+///  * `{ unsafe { x } }` -> `unsafe { x }`
+pub fn peel_blocks_with_stmt<'a>(mut expr: &'a Expr<'a>) -> &'a Expr<'a> {
+    while let ExprKind::Block(
+        Block {
+            stmts: [],
+            expr: Some(inner),
+            rules: BlockCheckMode::DefaultBlock,
+            ..
         }
+        | Block {
+            stmts:
+                [
+                    Stmt {
+                        kind: StmtKind::Expr(inner) | StmtKind::Semi(inner),
+                        ..
+                    },
+                ],
+            expr: None,
+            rules: BlockCheckMode::DefaultBlock,
+            ..
+        },
+        _,
+    ) = expr.kind
+    {
+        expr = inner;
     }
     expr
 }
-- 
cgit 1.4.1-3-g733a5


From 16bbd243f9e5c71ff0481c7168a32f4f442c582f Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Wed, 24 Mar 2021 19:17:25 -0500
Subject: Simplify needless_bool

---
 clippy_lints/src/needless_bool.rs | 63 ++++++++++++---------------------------
 1 file changed, 19 insertions(+), 44 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/needless_bool.rs b/clippy_lints/src/needless_bool.rs
index e7809436252..d391fbecf82 100644
--- a/clippy_lints/src/needless_bool.rs
+++ b/clippy_lints/src/needless_bool.rs
@@ -6,10 +6,10 @@ use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg};
 use clippy_utils::higher;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::sugg::Sugg;
-use clippy_utils::{get_parent_node, is_else_clause, is_expn_of};
+use clippy_utils::{get_parent_node, is_else_clause, is_expn_of, peel_blocks, peel_blocks_with_stmt};
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
-use rustc_hir::{BinOpKind, Block, Expr, ExprKind, HirId, Node, StmtKind, UnOp};
+use rustc_hir::{BinOpKind, Block, Expr, ExprKind, HirId, Node, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Spanned;
@@ -143,8 +143,8 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessBool {
                     applicability,
                 );
             };
-            if let ExprKind::Block(then, _) = then.kind {
-                match (fetch_bool_block(then), fetch_bool_expr(r#else)) {
+            if let Some((a, b)) = fetch_bool_block(then).and_then(|a| Some((a, fetch_bool_block(r#else)?))) {
+                match (a, b) {
                     (RetBool(true), RetBool(true)) | (Bool(true), Bool(true)) => {
                         span_lint(
                             cx,
@@ -167,8 +167,6 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessBool {
                     (Bool(false), Bool(true)) => reduce(false, true),
                     _ => (),
                 }
-            } else {
-                panic!("IfExpr `then` node is not an `ExprKind::Block`");
             }
         }
     }
@@ -271,8 +269,6 @@ fn check_comparison<'a, 'tcx>(
     right_false: Option<(impl FnOnce(Sugg<'a>) -> Sugg<'a>, &str)>,
     no_literal: Option<(impl FnOnce(Sugg<'a>, Sugg<'a>) -> Sugg<'a>, &str)>,
 ) {
-    use self::Expression::{Bool, Other};
-
     if let ExprKind::Binary(op, left_side, right_side) = e.kind {
         let (l_ty, r_ty) = (
             cx.typeck_results().expr_ty(left_side),
@@ -304,19 +300,19 @@ fn check_comparison<'a, 'tcx>(
             }
 
             match (fetch_bool_expr(left_side), fetch_bool_expr(right_side)) {
-                (Bool(true), Other) => left_true.map_or((), |(h, m)| {
+                (Some(true), None) => left_true.map_or((), |(h, m)| {
                     suggest_bool_comparison(cx, e, right_side, applicability, m, h);
                 }),
-                (Other, Bool(true)) => right_true.map_or((), |(h, m)| {
+                (None, Some(true)) => right_true.map_or((), |(h, m)| {
                     suggest_bool_comparison(cx, e, left_side, applicability, m, h);
                 }),
-                (Bool(false), Other) => left_false.map_or((), |(h, m)| {
+                (Some(false), None) => left_false.map_or((), |(h, m)| {
                     suggest_bool_comparison(cx, e, right_side, applicability, m, h);
                 }),
-                (Other, Bool(false)) => right_false.map_or((), |(h, m)| {
+                (None, Some(false)) => right_false.map_or((), |(h, m)| {
                     suggest_bool_comparison(cx, e, left_side, applicability, m, h);
                 }),
-                (Other, Other) => no_literal.map_or((), |(h, m)| {
+                (None, None) => no_literal.map_or((), |(h, m)| {
                     let left_side = Sugg::hir_with_applicability(cx, left_side, "..", &mut applicability);
                     let right_side = Sugg::hir_with_applicability(cx, right_side, "..", &mut applicability);
                     span_lint_and_sugg(
@@ -365,41 +361,20 @@ fn suggest_bool_comparison<'a, 'tcx>(
 enum Expression {
     Bool(bool),
     RetBool(bool),
-    Other,
 }
 
-fn fetch_bool_block(block: &Block<'_>) -> Expression {
-    match (&*block.stmts, block.expr.as_ref()) {
-        (&[], Some(e)) => fetch_bool_expr(&**e),
-        (&[ref e], None) => {
-            if let StmtKind::Semi(e) = e.kind {
-                if let ExprKind::Ret(_) = e.kind {
-                    fetch_bool_expr(e)
-                } else {
-                    Expression::Other
-                }
-            } else {
-                Expression::Other
-            }
-        },
-        _ => Expression::Other,
+fn fetch_bool_block(expr: &Expr<'_>) -> Option<Expression> {
+    match peel_blocks_with_stmt(expr).kind {
+        ExprKind::Ret(Some(ret)) => Some(Expression::RetBool(fetch_bool_expr(ret)?)),
+        _ => Some(Expression::Bool(fetch_bool_expr(expr)?)),
     }
 }
 
-fn fetch_bool_expr(expr: &Expr<'_>) -> Expression {
-    match expr.kind {
-        ExprKind::Block(block, _) => fetch_bool_block(block),
-        ExprKind::Lit(ref lit_ptr) => {
-            if let LitKind::Bool(value) = lit_ptr.node {
-                Expression::Bool(value)
-            } else {
-                Expression::Other
-            }
-        },
-        ExprKind::Ret(Some(expr)) => match fetch_bool_expr(expr) {
-            Expression::Bool(value) => Expression::RetBool(value),
-            _ => Expression::Other,
-        },
-        _ => Expression::Other,
+fn fetch_bool_expr(expr: &Expr<'_>) -> Option<bool> {
+    if let ExprKind::Lit(ref lit_ptr) = peel_blocks(expr).kind {
+        if let LitKind::Bool(value) = lit_ptr.node {
+            return Some(value);
+        }
     }
+    None
 }
-- 
cgit 1.4.1-3-g733a5


From d91b91ae570c3ff0f4fc774b46d76bd732f1b446 Mon Sep 17 00:00:00 2001
From: Joel Natividad <1980690+jqnatividad@users.noreply.github.com>
Date: Mon, 6 Dec 2021 19:11:19 -0500
Subject: `needless_lifetimes` Known problems typo

fixes #8084
---
 clippy_lints/src/lifetimes.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lifetimes.rs b/clippy_lints/src/lifetimes.rs
index fad3343d128..0e2b78609c2 100644
--- a/clippy_lints/src/lifetimes.rs
+++ b/clippy_lints/src/lifetimes.rs
@@ -29,7 +29,7 @@ declare_clippy_lint! {
     ///
     /// ### Known problems
     /// - We bail out if the function has a `where` clause where lifetimes
-    /// are mentioned due to potenial false positives.
+    /// are mentioned due to potential false positives.
     /// - Lifetime bounds such as `impl Foo + 'a` and `T: 'a` must be elided with the
     /// placeholder notation `'_` because the fully elided notation leaves the type bound to `'static`.
     ///
-- 
cgit 1.4.1-3-g733a5


From b5fa5b37cc541971e55a1192fac00f26724a9d66 Mon Sep 17 00:00:00 2001
From: dswij <dswijj@gmail.com>
Date: Tue, 7 Dec 2021 15:34:44 +0800
Subject: `option_if_let_else` Do not warn when complex subpat is present

---
 clippy_lints/src/option_if_let_else.rs |  2 +-
 tests/ui/option_if_let_else.fixed      | 14 ++++++++++++++
 tests/ui/option_if_let_else.rs         | 14 ++++++++++++++
 tests/ui/option_if_let_else.stderr     |  8 ++++----
 4 files changed, 33 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/option_if_let_else.rs b/clippy_lints/src/option_if_let_else.rs
index 897207ebf50..953de0f72a8 100644
--- a/clippy_lints/src/option_if_let_else.rs
+++ b/clippy_lints/src/option_if_let_else.rs
@@ -112,7 +112,7 @@ fn detect_option_if_let_else<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>) ->
         if !is_result_ok(cx, let_expr); // Don't lint on Result::ok because a different lint does it already
         if let PatKind::TupleStruct(struct_qpath, [inner_pat], _) = &let_pat.kind;
         if is_lang_ctor(cx, struct_qpath, OptionSome);
-        if let PatKind::Binding(bind_annotation, _, id, _) = &inner_pat.kind;
+        if let PatKind::Binding(bind_annotation, _, id, None) = &inner_pat.kind;
         if let Some(some_captures) = can_move_expr_to_closure(cx, if_then);
         if let Some(none_captures) = can_move_expr_to_closure(cx, if_else);
         if some_captures
diff --git a/tests/ui/option_if_let_else.fixed b/tests/ui/option_if_let_else.fixed
index ce3093c542a..7790c816481 100644
--- a/tests/ui/option_if_let_else.fixed
+++ b/tests/ui/option_if_let_else.fixed
@@ -86,6 +86,19 @@ fn pattern_to_vec(pattern: &str) -> Vec<String> {
         .collect::<Vec<_>>()
 }
 
+enum DummyEnum {
+    One(u8),
+    Two,
+}
+
+// should not warn since there is a compled complex subpat
+// see #7991
+fn complex_subpat() -> DummyEnum {
+    let x = Some(DummyEnum::One(1));
+    let _ = if let Some(_one @ DummyEnum::One(..)) = x { 1 } else { 2 };
+    DummyEnum::Two
+}
+
 fn main() {
     let optional = Some(5);
     let _ = optional.map_or(5, |x| x + 2);
@@ -159,4 +172,5 @@ fn main() {
     }
 
     let _ = pattern_to_vec("hello world");
+    let _ = complex_subpat();
 }
diff --git a/tests/ui/option_if_let_else.rs b/tests/ui/option_if_let_else.rs
index c228b2f43d1..3d9f76ee4a6 100644
--- a/tests/ui/option_if_let_else.rs
+++ b/tests/ui/option_if_let_else.rs
@@ -109,6 +109,19 @@ fn pattern_to_vec(pattern: &str) -> Vec<String> {
         .collect::<Vec<_>>()
 }
 
+enum DummyEnum {
+    One(u8),
+    Two,
+}
+
+// should not warn since there is a compled complex subpat
+// see #7991
+fn complex_subpat() -> DummyEnum {
+    let x = Some(DummyEnum::One(1));
+    let _ = if let Some(_one @ DummyEnum::One(..)) = x { 1 } else { 2 };
+    DummyEnum::Two
+}
+
 fn main() {
     let optional = Some(5);
     let _ = if let Some(x) = optional { x + 2 } else { 5 };
@@ -188,4 +201,5 @@ fn main() {
     }
 
     let _ = pattern_to_vec("hello world");
+    let _ = complex_subpat();
 }
diff --git a/tests/ui/option_if_let_else.stderr b/tests/ui/option_if_let_else.stderr
index 4e64cd7cdb1..546131ceb5b 100644
--- a/tests/ui/option_if_let_else.stderr
+++ b/tests/ui/option_if_let_else.stderr
@@ -153,13 +153,13 @@ LL | |             }
    | |_____________^ help: try: `s.find('.').map_or_else(|| vec![s.to_string()], |idx| vec![s[..idx].to_string(), s[idx..].to_string()])`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:114:13
+  --> $DIR/option_if_let_else.rs:127:13
    |
 LL |     let _ = if let Some(x) = optional { x + 2 } else { 5 };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `optional.map_or(5, |x| x + 2)`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:123:13
+  --> $DIR/option_if_let_else.rs:136:13
    |
 LL |       let _ = if let Some(x) = Some(0) {
    |  _____________^
@@ -181,13 +181,13 @@ LL ~         });
    |
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:151:13
+  --> $DIR/option_if_let_else.rs:164:13
    |
 LL |     let _ = if let Some(x) = Some(0) { s.len() + x } else { s.len() };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Some(0).map_or(s.len(), |x| s.len() + x)`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:155:13
+  --> $DIR/option_if_let_else.rs:168:13
    |
 LL |       let _ = if let Some(x) = Some(0) {
    |  _____________^
-- 
cgit 1.4.1-3-g733a5


From ee0d71e103a7de8afe225ba5357c446b08a6fbe3 Mon Sep 17 00:00:00 2001
From: Yechan Bae <yechan@gatech.edu>
Date: Fri, 3 Dec 2021 20:28:14 -0500
Subject: Clarify the purpose of the lint

---
 clippy_lints/src/non_send_fields_in_send_ty.rs     | 30 +++++++------
 .../strict_non_send_fields_in_send_ty/test.stderr  | 28 ++++++------
 tests/ui/non_send_fields_in_send_ty.stderr         | 52 +++++++++++-----------
 3 files changed, 57 insertions(+), 53 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/non_send_fields_in_send_ty.rs b/clippy_lints/src/non_send_fields_in_send_ty.rs
index bba542ce8ca..88cbf3eae0d 100644
--- a/clippy_lints/src/non_send_fields_in_send_ty.rs
+++ b/clippy_lints/src/non_send_fields_in_send_ty.rs
@@ -13,24 +13,28 @@ use rustc_span::sym;
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Warns about fields in struct implementing `Send` that are neither `Send` nor `Copy`.
+    /// This lint warns about a `Send` implementation for a type that
+    /// contains fields that are not safe to be sent across threads.
+    /// It tries to detect fields that can cause a soundness issue
+    /// when sent to another thread (e.g., `Rc`) while allowing `!Send` fields
+    /// that are expected to exist in a `Send` type such as raw pointers.
     ///
     /// ### Why is this bad?
-    /// Sending the struct to another thread will transfer the ownership to
-    /// the new thread by dropping in the current thread during the transfer.
-    /// This causes soundness issues for non-`Send` fields, as they are also
-    /// dropped and might not be set up to handle this.
+    /// Sending the struct to another thread effectively sends all of its fields,
+    /// and the fields that do not implement `Send` can lead to soundness bugs
+    /// such as data races when accessed in a thread
+    /// that is different from the thread that created it.
     ///
     /// See:
     /// * [*The Rustonomicon* about *Send and Sync*](https://doc.rust-lang.org/nomicon/send-and-sync.html)
     /// * [The documentation of `Send`](https://doc.rust-lang.org/std/marker/trait.Send.html)
     ///
     /// ### Known Problems
-    /// Data structures that contain raw pointers may cause false positives.
-    /// They are sometimes safe to be sent across threads but do not implement
-    /// the `Send` trait. This lint has a heuristic to filter out basic cases
-    /// such as `Vec<*const T>`, but it's not perfect. Feel free to create an
-    /// issue if you have a suggestion on how this heuristic can be improved.
+    /// This lint relies on heuristics to distinguish types that are actually
+    /// unsafe to be sent across threads and `!Send` types that are expected to
+    /// exist in  `Send` type. Its rule can filter out basic cases such as
+    /// `Vec<*const T>`, but it's not perfect. Feel free to create an issue if
+    /// you have a suggestion on how this heuristic can be improved.
     ///
     /// ### Example
     /// ```rust,ignore
@@ -47,7 +51,7 @@ declare_clippy_lint! {
     #[clippy::version = "1.57.0"]
     pub NON_SEND_FIELDS_IN_SEND_TY,
     suspicious,
-    "there is field that does not implement `Send` in a `Send` struct"
+    "there is a field that is not safe to be sent to another thread in a `Send` struct"
 }
 
 #[derive(Copy, Clone)]
@@ -120,14 +124,14 @@ impl<'tcx> LateLintPass<'tcx> for NonSendFieldInSendTy {
                         NON_SEND_FIELDS_IN_SEND_TY,
                         item.span,
                         &format!(
-                            "this implementation is unsound, as some fields in `{}` are `!Send`",
+                            "there are some fields in `{}` are not safe to be sent to another thread",
                             snippet(cx, hir_impl.self_ty.span, "Unknown")
                         ),
                         |diag| {
                             for field in non_send_fields {
                                 diag.span_note(
                                     field.def.span,
-                                    &format!("the type of field `{}` is `!Send`", field.def.ident.name),
+                                    &format!("it is not safe to send field `{}` to another thread", field.def.ident.name),
                                 );
 
                                 match field.generic_params.len() {
diff --git a/tests/ui-toml/strict_non_send_fields_in_send_ty/test.stderr b/tests/ui-toml/strict_non_send_fields_in_send_ty/test.stderr
index b07f9dd3df3..c3c4b67b463 100644
--- a/tests/ui-toml/strict_non_send_fields_in_send_ty/test.stderr
+++ b/tests/ui-toml/strict_non_send_fields_in_send_ty/test.stderr
@@ -1,86 +1,86 @@
-error: this implementation is unsound, as some fields in `NoGeneric` are `!Send`
+error: there are some fields in `NoGeneric` are not safe to be sent to another thread
   --> $DIR/test.rs:11:1
    |
 LL | unsafe impl Send for NoGeneric {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::non-send-fields-in-send-ty` implied by `-D warnings`
-note: the type of field `rc_is_not_send` is `!Send`
+note: it is not safe to send field `rc_is_not_send` to another thread
   --> $DIR/test.rs:8:5
    |
 LL |     rc_is_not_send: Rc<String>,
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
    = help: use a thread-safe type that implements `Send`
 
-error: this implementation is unsound, as some fields in `MultiField<T>` are `!Send`
+error: there are some fields in `MultiField<T>` are not safe to be sent to another thread
   --> $DIR/test.rs:19:1
    |
 LL | unsafe impl<T> Send for MultiField<T> {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-note: the type of field `field1` is `!Send`
+note: it is not safe to send field `field1` to another thread
   --> $DIR/test.rs:14:5
    |
 LL |     field1: T,
    |     ^^^^^^^^^
    = help: add `T: Send` bound in `Send` impl
-note: the type of field `field2` is `!Send`
+note: it is not safe to send field `field2` to another thread
   --> $DIR/test.rs:15:5
    |
 LL |     field2: T,
    |     ^^^^^^^^^
    = help: add `T: Send` bound in `Send` impl
-note: the type of field `field3` is `!Send`
+note: it is not safe to send field `field3` to another thread
   --> $DIR/test.rs:16:5
    |
 LL |     field3: T,
    |     ^^^^^^^^^
    = help: add `T: Send` bound in `Send` impl
 
-error: this implementation is unsound, as some fields in `MyOption<T>` are `!Send`
+error: there are some fields in `MyOption<T>` are not safe to be sent to another thread
   --> $DIR/test.rs:26:1
    |
 LL | unsafe impl<T> Send for MyOption<T> {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-note: the type of field `0` is `!Send`
+note: it is not safe to send field `0` to another thread
   --> $DIR/test.rs:22:12
    |
 LL |     MySome(T),
    |            ^
    = help: add `T: Send` bound in `Send` impl
 
-error: this implementation is unsound, as some fields in `HeuristicTest` are `!Send`
+error: there are some fields in `HeuristicTest` are not safe to be sent to another thread
   --> $DIR/test.rs:41:1
    |
 LL | unsafe impl Send for HeuristicTest {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-note: the type of field `field1` is `!Send`
+note: it is not safe to send field `field1` to another thread
   --> $DIR/test.rs:34:5
    |
 LL |     field1: Vec<*const NonSend>,
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
    = help: use a thread-safe type that implements `Send`
-note: the type of field `field2` is `!Send`
+note: it is not safe to send field `field2` to another thread
   --> $DIR/test.rs:35:5
    |
 LL |     field2: [*const NonSend; 3],
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
    = help: use a thread-safe type that implements `Send`
-note: the type of field `field3` is `!Send`
+note: it is not safe to send field `field3` to another thread
   --> $DIR/test.rs:36:5
    |
 LL |     field3: (*const NonSend, *const NonSend, *const NonSend),
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    = help: use a thread-safe type that implements `Send`
-note: the type of field `field4` is `!Send`
+note: it is not safe to send field `field4` to another thread
   --> $DIR/test.rs:37:5
    |
 LL |     field4: (*const NonSend, Rc<u8>),
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    = help: use a thread-safe type that implements `Send`
-note: the type of field `field5` is `!Send`
+note: it is not safe to send field `field5` to another thread
   --> $DIR/test.rs:38:5
    |
 LL |     field5: Vec<Vec<*const NonSend>>,
diff --git a/tests/ui/non_send_fields_in_send_ty.stderr b/tests/ui/non_send_fields_in_send_ty.stderr
index 3c4da36b3e0..aeaaef794f9 100644
--- a/tests/ui/non_send_fields_in_send_ty.stderr
+++ b/tests/ui/non_send_fields_in_send_ty.stderr
@@ -1,166 +1,166 @@
-error: this implementation is unsound, as some fields in `RingBuffer<T>` are `!Send`
+error: there are some fields in `RingBuffer<T>` are not safe to be sent to another thread
   --> $DIR/non_send_fields_in_send_ty.rs:16:1
    |
 LL | unsafe impl<T> Send for RingBuffer<T> {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::non-send-fields-in-send-ty` implied by `-D warnings`
-note: the type of field `data` is `!Send`
+note: it is not safe to send field `data` to another thread
   --> $DIR/non_send_fields_in_send_ty.rs:11:5
    |
 LL |     data: Vec<UnsafeCell<T>>,
    |     ^^^^^^^^^^^^^^^^^^^^^^^^
    = help: add bounds on type parameter `T` that satisfy `Vec<UnsafeCell<T>>: Send`
 
-error: this implementation is unsound, as some fields in `MvccRwLock<T>` are `!Send`
+error: there are some fields in `MvccRwLock<T>` are not safe to be sent to another thread
   --> $DIR/non_send_fields_in_send_ty.rs:24:1
    |
 LL | unsafe impl<T> Send for MvccRwLock<T> {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-note: the type of field `lock` is `!Send`
+note: it is not safe to send field `lock` to another thread
   --> $DIR/non_send_fields_in_send_ty.rs:21:5
    |
 LL |     lock: Mutex<Box<T>>,
    |     ^^^^^^^^^^^^^^^^^^^
    = help: add bounds on type parameter `T` that satisfy `Mutex<Box<T>>: Send`
 
-error: this implementation is unsound, as some fields in `ArcGuard<RC, T>` are `!Send`
+error: there are some fields in `ArcGuard<RC, T>` are not safe to be sent to another thread
   --> $DIR/non_send_fields_in_send_ty.rs:32:1
    |
 LL | unsafe impl<RC, T: Send> Send for ArcGuard<RC, T> {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-note: the type of field `head` is `!Send`
+note: it is not safe to send field `head` to another thread
   --> $DIR/non_send_fields_in_send_ty.rs:29:5
    |
 LL |     head: Arc<RC>,
    |     ^^^^^^^^^^^^^
    = help: add bounds on type parameter `RC` that satisfy `Arc<RC>: Send`
 
-error: this implementation is unsound, as some fields in `DeviceHandle<T>` are `!Send`
+error: there are some fields in `DeviceHandle<T>` are not safe to be sent to another thread
   --> $DIR/non_send_fields_in_send_ty.rs:48:1
    |
 LL | unsafe impl<T: UsbContext> Send for DeviceHandle<T> {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-note: the type of field `context` is `!Send`
+note: it is not safe to send field `context` to another thread
   --> $DIR/non_send_fields_in_send_ty.rs:44:5
    |
 LL |     context: T,
    |     ^^^^^^^^^^
    = help: add `T: Send` bound in `Send` impl
 
-error: this implementation is unsound, as some fields in `NoGeneric` are `!Send`
+error: there are some fields in `NoGeneric` are not safe to be sent to another thread
   --> $DIR/non_send_fields_in_send_ty.rs:55:1
    |
 LL | unsafe impl Send for NoGeneric {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-note: the type of field `rc_is_not_send` is `!Send`
+note: it is not safe to send field `rc_is_not_send` to another thread
   --> $DIR/non_send_fields_in_send_ty.rs:52:5
    |
 LL |     rc_is_not_send: Rc<String>,
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
    = help: use a thread-safe type that implements `Send`
 
-error: this implementation is unsound, as some fields in `MultiField<T>` are `!Send`
+error: there are some fields in `MultiField<T>` are not safe to be sent to another thread
   --> $DIR/non_send_fields_in_send_ty.rs:63:1
    |
 LL | unsafe impl<T> Send for MultiField<T> {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-note: the type of field `field1` is `!Send`
+note: it is not safe to send field `field1` to another thread
   --> $DIR/non_send_fields_in_send_ty.rs:58:5
    |
 LL |     field1: T,
    |     ^^^^^^^^^
    = help: add `T: Send` bound in `Send` impl
-note: the type of field `field2` is `!Send`
+note: it is not safe to send field `field2` to another thread
   --> $DIR/non_send_fields_in_send_ty.rs:59:5
    |
 LL |     field2: T,
    |     ^^^^^^^^^
    = help: add `T: Send` bound in `Send` impl
-note: the type of field `field3` is `!Send`
+note: it is not safe to send field `field3` to another thread
   --> $DIR/non_send_fields_in_send_ty.rs:60:5
    |
 LL |     field3: T,
    |     ^^^^^^^^^
    = help: add `T: Send` bound in `Send` impl
 
-error: this implementation is unsound, as some fields in `MyOption<T>` are `!Send`
+error: there are some fields in `MyOption<T>` are not safe to be sent to another thread
   --> $DIR/non_send_fields_in_send_ty.rs:70:1
    |
 LL | unsafe impl<T> Send for MyOption<T> {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-note: the type of field `0` is `!Send`
+note: it is not safe to send field `0` to another thread
   --> $DIR/non_send_fields_in_send_ty.rs:66:12
    |
 LL |     MySome(T),
    |            ^
    = help: add `T: Send` bound in `Send` impl
 
-error: this implementation is unsound, as some fields in `MultiParam<A, B>` are `!Send`
+error: there are some fields in `MultiParam<A, B>` are not safe to be sent to another thread
   --> $DIR/non_send_fields_in_send_ty.rs:82:1
    |
 LL | unsafe impl<A, B> Send for MultiParam<A, B> {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-note: the type of field `vec` is `!Send`
+note: it is not safe to send field `vec` to another thread
   --> $DIR/non_send_fields_in_send_ty.rs:79:5
    |
 LL |     vec: Vec<(A, B)>,
    |     ^^^^^^^^^^^^^^^^
    = help: add bounds on type parameters `A, B` that satisfy `Vec<(A, B)>: Send`
 
-error: this implementation is unsound, as some fields in `HeuristicTest` are `!Send`
+error: there are some fields in `HeuristicTest` are not safe to be sent to another thread
   --> $DIR/non_send_fields_in_send_ty.rs:100:1
    |
 LL | unsafe impl Send for HeuristicTest {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-note: the type of field `field4` is `!Send`
+note: it is not safe to send field `field4` to another thread
   --> $DIR/non_send_fields_in_send_ty.rs:95:5
    |
 LL |     field4: (*const NonSend, Rc<u8>),
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    = help: use a thread-safe type that implements `Send`
 
-error: this implementation is unsound, as some fields in `AttrTest3<T>` are `!Send`
+error: there are some fields in `AttrTest3<T>` are not safe to be sent to another thread
   --> $DIR/non_send_fields_in_send_ty.rs:119:1
    |
 LL | unsafe impl<T> Send for AttrTest3<T> {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-note: the type of field `0` is `!Send`
+note: it is not safe to send field `0` to another thread
   --> $DIR/non_send_fields_in_send_ty.rs:114:11
    |
 LL |     Enum2(T),
    |           ^
    = help: add `T: Send` bound in `Send` impl
 
-error: this implementation is unsound, as some fields in `Complex<P, u32>` are `!Send`
+error: there are some fields in `Complex<P, u32>` are not safe to be sent to another thread
   --> $DIR/non_send_fields_in_send_ty.rs:127:1
    |
 LL | unsafe impl<P> Send for Complex<P, u32> {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-note: the type of field `field1` is `!Send`
+note: it is not safe to send field `field1` to another thread
   --> $DIR/non_send_fields_in_send_ty.rs:123:5
    |
 LL |     field1: A,
    |     ^^^^^^^^^
    = help: add `P: Send` bound in `Send` impl
 
-error: this implementation is unsound, as some fields in `Complex<Q, MutexGuard<'static, bool>>` are `!Send`
+error: there are some fields in `Complex<Q, MutexGuard<'static, bool>>` are not safe to be sent to another thread
   --> $DIR/non_send_fields_in_send_ty.rs:130:1
    |
 LL | unsafe impl<Q: Send> Send for Complex<Q, MutexGuard<'static, bool>> {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-note: the type of field `field2` is `!Send`
+note: it is not safe to send field `field2` to another thread
   --> $DIR/non_send_fields_in_send_ty.rs:124:5
    |
 LL |     field2: B,
-- 
cgit 1.4.1-3-g733a5


From c0fd250c62abccc0b453677969fa69ddeb6f06d4 Mon Sep 17 00:00:00 2001
From: Yechan Bae <yechan@gatech.edu>
Date: Tue, 7 Dec 2021 10:02:58 -0500
Subject: Fix grammar issues

---
 clippy_lints/src/non_send_fields_in_send_ty.rs     |  4 ++--
 .../strict_non_send_fields_in_send_ty/test.stderr  |  8 ++++----
 tests/ui/non_send_fields_in_send_ty.stderr         | 24 +++++++++++-----------
 3 files changed, 18 insertions(+), 18 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/non_send_fields_in_send_ty.rs b/clippy_lints/src/non_send_fields_in_send_ty.rs
index 88cbf3eae0d..97f492e518a 100644
--- a/clippy_lints/src/non_send_fields_in_send_ty.rs
+++ b/clippy_lints/src/non_send_fields_in_send_ty.rs
@@ -17,7 +17,7 @@ declare_clippy_lint! {
     /// contains fields that are not safe to be sent across threads.
     /// It tries to detect fields that can cause a soundness issue
     /// when sent to another thread (e.g., `Rc`) while allowing `!Send` fields
-    /// that are expected to exist in a `Send` type such as raw pointers.
+    /// that are expected to exist in a `Send` type, such as raw pointers.
     ///
     /// ### Why is this bad?
     /// Sending the struct to another thread effectively sends all of its fields,
@@ -124,7 +124,7 @@ impl<'tcx> LateLintPass<'tcx> for NonSendFieldInSendTy {
                         NON_SEND_FIELDS_IN_SEND_TY,
                         item.span,
                         &format!(
-                            "there are some fields in `{}` are not safe to be sent to another thread",
+                            "some fields in `{}` are not safe to be sent to another thread",
                             snippet(cx, hir_impl.self_ty.span, "Unknown")
                         ),
                         |diag| {
diff --git a/tests/ui-toml/strict_non_send_fields_in_send_ty/test.stderr b/tests/ui-toml/strict_non_send_fields_in_send_ty/test.stderr
index c3c4b67b463..49eecf18b4c 100644
--- a/tests/ui-toml/strict_non_send_fields_in_send_ty/test.stderr
+++ b/tests/ui-toml/strict_non_send_fields_in_send_ty/test.stderr
@@ -1,4 +1,4 @@
-error: there are some fields in `NoGeneric` are not safe to be sent to another thread
+error: some fields in `NoGeneric` are not safe to be sent to another thread
   --> $DIR/test.rs:11:1
    |
 LL | unsafe impl Send for NoGeneric {}
@@ -12,7 +12,7 @@ LL |     rc_is_not_send: Rc<String>,
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
    = help: use a thread-safe type that implements `Send`
 
-error: there are some fields in `MultiField<T>` are not safe to be sent to another thread
+error: some fields in `MultiField<T>` are not safe to be sent to another thread
   --> $DIR/test.rs:19:1
    |
 LL | unsafe impl<T> Send for MultiField<T> {}
@@ -37,7 +37,7 @@ LL |     field3: T,
    |     ^^^^^^^^^
    = help: add `T: Send` bound in `Send` impl
 
-error: there are some fields in `MyOption<T>` are not safe to be sent to another thread
+error: some fields in `MyOption<T>` are not safe to be sent to another thread
   --> $DIR/test.rs:26:1
    |
 LL | unsafe impl<T> Send for MyOption<T> {}
@@ -50,7 +50,7 @@ LL |     MySome(T),
    |            ^
    = help: add `T: Send` bound in `Send` impl
 
-error: there are some fields in `HeuristicTest` are not safe to be sent to another thread
+error: some fields in `HeuristicTest` are not safe to be sent to another thread
   --> $DIR/test.rs:41:1
    |
 LL | unsafe impl Send for HeuristicTest {}
diff --git a/tests/ui/non_send_fields_in_send_ty.stderr b/tests/ui/non_send_fields_in_send_ty.stderr
index aeaaef794f9..60df4e226e4 100644
--- a/tests/ui/non_send_fields_in_send_ty.stderr
+++ b/tests/ui/non_send_fields_in_send_ty.stderr
@@ -1,4 +1,4 @@
-error: there are some fields in `RingBuffer<T>` are not safe to be sent to another thread
+error: some fields in `RingBuffer<T>` are not safe to be sent to another thread
   --> $DIR/non_send_fields_in_send_ty.rs:16:1
    |
 LL | unsafe impl<T> Send for RingBuffer<T> {}
@@ -12,7 +12,7 @@ LL |     data: Vec<UnsafeCell<T>>,
    |     ^^^^^^^^^^^^^^^^^^^^^^^^
    = help: add bounds on type parameter `T` that satisfy `Vec<UnsafeCell<T>>: Send`
 
-error: there are some fields in `MvccRwLock<T>` are not safe to be sent to another thread
+error: some fields in `MvccRwLock<T>` are not safe to be sent to another thread
   --> $DIR/non_send_fields_in_send_ty.rs:24:1
    |
 LL | unsafe impl<T> Send for MvccRwLock<T> {}
@@ -25,7 +25,7 @@ LL |     lock: Mutex<Box<T>>,
    |     ^^^^^^^^^^^^^^^^^^^
    = help: add bounds on type parameter `T` that satisfy `Mutex<Box<T>>: Send`
 
-error: there are some fields in `ArcGuard<RC, T>` are not safe to be sent to another thread
+error: some fields in `ArcGuard<RC, T>` are not safe to be sent to another thread
   --> $DIR/non_send_fields_in_send_ty.rs:32:1
    |
 LL | unsafe impl<RC, T: Send> Send for ArcGuard<RC, T> {}
@@ -38,7 +38,7 @@ LL |     head: Arc<RC>,
    |     ^^^^^^^^^^^^^
    = help: add bounds on type parameter `RC` that satisfy `Arc<RC>: Send`
 
-error: there are some fields in `DeviceHandle<T>` are not safe to be sent to another thread
+error: some fields in `DeviceHandle<T>` are not safe to be sent to another thread
   --> $DIR/non_send_fields_in_send_ty.rs:48:1
    |
 LL | unsafe impl<T: UsbContext> Send for DeviceHandle<T> {}
@@ -51,7 +51,7 @@ LL |     context: T,
    |     ^^^^^^^^^^
    = help: add `T: Send` bound in `Send` impl
 
-error: there are some fields in `NoGeneric` are not safe to be sent to another thread
+error: some fields in `NoGeneric` are not safe to be sent to another thread
   --> $DIR/non_send_fields_in_send_ty.rs:55:1
    |
 LL | unsafe impl Send for NoGeneric {}
@@ -64,7 +64,7 @@ LL |     rc_is_not_send: Rc<String>,
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
    = help: use a thread-safe type that implements `Send`
 
-error: there are some fields in `MultiField<T>` are not safe to be sent to another thread
+error: some fields in `MultiField<T>` are not safe to be sent to another thread
   --> $DIR/non_send_fields_in_send_ty.rs:63:1
    |
 LL | unsafe impl<T> Send for MultiField<T> {}
@@ -89,7 +89,7 @@ LL |     field3: T,
    |     ^^^^^^^^^
    = help: add `T: Send` bound in `Send` impl
 
-error: there are some fields in `MyOption<T>` are not safe to be sent to another thread
+error: some fields in `MyOption<T>` are not safe to be sent to another thread
   --> $DIR/non_send_fields_in_send_ty.rs:70:1
    |
 LL | unsafe impl<T> Send for MyOption<T> {}
@@ -102,7 +102,7 @@ LL |     MySome(T),
    |            ^
    = help: add `T: Send` bound in `Send` impl
 
-error: there are some fields in `MultiParam<A, B>` are not safe to be sent to another thread
+error: some fields in `MultiParam<A, B>` are not safe to be sent to another thread
   --> $DIR/non_send_fields_in_send_ty.rs:82:1
    |
 LL | unsafe impl<A, B> Send for MultiParam<A, B> {}
@@ -115,7 +115,7 @@ LL |     vec: Vec<(A, B)>,
    |     ^^^^^^^^^^^^^^^^
    = help: add bounds on type parameters `A, B` that satisfy `Vec<(A, B)>: Send`
 
-error: there are some fields in `HeuristicTest` are not safe to be sent to another thread
+error: some fields in `HeuristicTest` are not safe to be sent to another thread
   --> $DIR/non_send_fields_in_send_ty.rs:100:1
    |
 LL | unsafe impl Send for HeuristicTest {}
@@ -128,7 +128,7 @@ LL |     field4: (*const NonSend, Rc<u8>),
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    = help: use a thread-safe type that implements `Send`
 
-error: there are some fields in `AttrTest3<T>` are not safe to be sent to another thread
+error: some fields in `AttrTest3<T>` are not safe to be sent to another thread
   --> $DIR/non_send_fields_in_send_ty.rs:119:1
    |
 LL | unsafe impl<T> Send for AttrTest3<T> {}
@@ -141,7 +141,7 @@ LL |     Enum2(T),
    |           ^
    = help: add `T: Send` bound in `Send` impl
 
-error: there are some fields in `Complex<P, u32>` are not safe to be sent to another thread
+error: some fields in `Complex<P, u32>` are not safe to be sent to another thread
   --> $DIR/non_send_fields_in_send_ty.rs:127:1
    |
 LL | unsafe impl<P> Send for Complex<P, u32> {}
@@ -154,7 +154,7 @@ LL |     field1: A,
    |     ^^^^^^^^^
    = help: add `P: Send` bound in `Send` impl
 
-error: there are some fields in `Complex<Q, MutexGuard<'static, bool>>` are not safe to be sent to another thread
+error: some fields in `Complex<Q, MutexGuard<'static, bool>>` are not safe to be sent to another thread
   --> $DIR/non_send_fields_in_send_ty.rs:130:1
    |
 LL | unsafe impl<Q: Send> Send for Complex<Q, MutexGuard<'static, bool>> {}
-- 
cgit 1.4.1-3-g733a5


From 5d63a286383b0a0ed03aa2568e306a3a154e3fa9 Mon Sep 17 00:00:00 2001
From: Yechan Bae <yechan@gatech.edu>
Date: Tue, 7 Dec 2021 10:45:59 -0500
Subject: Move `non_send_fields_in_send_ty` back to `nursery`

---
 clippy_lints/src/lib.register_all.rs           | 1 -
 clippy_lints/src/lib.register_nursery.rs       | 1 +
 clippy_lints/src/lib.register_suspicious.rs    | 1 -
 clippy_lints/src/non_send_fields_in_send_ty.rs | 2 +-
 4 files changed, 2 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index b7b5f059de6..85ca2cf308d 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -220,7 +220,6 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(non_copy_const::DECLARE_INTERIOR_MUTABLE_CONST),
     LintId::of(non_expressive_names::JUST_UNDERSCORES_AND_DIGITS),
     LintId::of(non_octal_unix_permissions::NON_OCTAL_UNIX_PERMISSIONS),
-    LintId::of(non_send_fields_in_send_ty::NON_SEND_FIELDS_IN_SEND_TY),
     LintId::of(octal_escapes::OCTAL_ESCAPES),
     LintId::of(open_options::NONSENSICAL_OPEN_OPTIONS),
     LintId::of(option_env_unwrap::OPTION_ENV_UNWRAP),
diff --git a/clippy_lints/src/lib.register_nursery.rs b/clippy_lints/src/lib.register_nursery.rs
index 59182fd8175..e3cf0670018 100644
--- a/clippy_lints/src/lib.register_nursery.rs
+++ b/clippy_lints/src/lib.register_nursery.rs
@@ -18,6 +18,7 @@ store.register_group(true, "clippy::nursery", Some("clippy_nursery"), vec![
     LintId::of(missing_const_for_fn::MISSING_CONST_FOR_FN),
     LintId::of(mutable_debug_assertion::DEBUG_ASSERT_WITH_MUT_CALL),
     LintId::of(mutex_atomic::MUTEX_INTEGER),
+    LintId::of(non_send_fields_in_send_ty::NON_SEND_FIELDS_IN_SEND_TY),
     LintId::of(nonstandard_macro_braces::NONSTANDARD_MACRO_BRACES),
     LintId::of(option_if_let_else::OPTION_IF_LET_ELSE),
     LintId::of(path_buf_push_overwrite::PATH_BUF_PUSH_OVERWRITE),
diff --git a/clippy_lints/src/lib.register_suspicious.rs b/clippy_lints/src/lib.register_suspicious.rs
index 414bfc42fdf..10f8ae4b7f7 100644
--- a/clippy_lints/src/lib.register_suspicious.rs
+++ b/clippy_lints/src/lib.register_suspicious.rs
@@ -15,7 +15,6 @@ store.register_group(true, "clippy::suspicious", Some("clippy_suspicious"), vec!
     LintId::of(loops::MUT_RANGE_BOUND),
     LintId::of(methods::SUSPICIOUS_MAP),
     LintId::of(mut_key::MUTABLE_KEY_TYPE),
-    LintId::of(non_send_fields_in_send_ty::NON_SEND_FIELDS_IN_SEND_TY),
     LintId::of(octal_escapes::OCTAL_ESCAPES),
     LintId::of(suspicious_trait_impl::SUSPICIOUS_ARITHMETIC_IMPL),
     LintId::of(suspicious_trait_impl::SUSPICIOUS_OP_ASSIGN_IMPL),
diff --git a/clippy_lints/src/non_send_fields_in_send_ty.rs b/clippy_lints/src/non_send_fields_in_send_ty.rs
index 97f492e518a..203f03d3603 100644
--- a/clippy_lints/src/non_send_fields_in_send_ty.rs
+++ b/clippy_lints/src/non_send_fields_in_send_ty.rs
@@ -50,7 +50,7 @@ declare_clippy_lint! {
     /// or specify correct bounds on generic type parameters (`T: Send`).
     #[clippy::version = "1.57.0"]
     pub NON_SEND_FIELDS_IN_SEND_TY,
-    suspicious,
+    nursery,
     "there is a field that is not safe to be sent to another thread in a `Send` struct"
 }
 
-- 
cgit 1.4.1-3-g733a5


From 8dfb3ec8a45316365f6d950fe7d46e120cd42301 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Fri, 3 Dec 2021 16:35:04 +0100
Subject: Add new lint to warn when #[must_use] attribute should be used on a
 method

---
 CHANGELOG.md                                 |   1 +
 clippy_lints/src/lib.register_all.rs         |   1 +
 clippy_lints/src/lib.register_lints.rs       |   1 +
 clippy_lints/src/lib.register_suspicious.rs  |   1 +
 clippy_lints/src/lib.rs                      |   2 +
 clippy_lints/src/return_self_not_must_use.rs | 105 +++++++++++++++++++++++++++
 clippy_utils/src/lib.rs                      |   7 ++
 tests/ui/return_self_not_must_use.rs         |  42 +++++++++++
 tests/ui/return_self_not_must_use.stderr     |  26 +++++++
 9 files changed, 186 insertions(+)
 create mode 100644 clippy_lints/src/return_self_not_must_use.rs
 create mode 100644 tests/ui/return_self_not_must_use.rs
 create mode 100644 tests/ui/return_self_not_must_use.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 157ea0c963a..2f64cd0e914 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3118,6 +3118,7 @@ Released 2018-09-13
 [`result_map_or_into_option`]: https://rust-lang.github.io/rust-clippy/master/index.html#result_map_or_into_option
 [`result_map_unit_fn`]: https://rust-lang.github.io/rust-clippy/master/index.html#result_map_unit_fn
 [`result_unit_err`]: https://rust-lang.github.io/rust-clippy/master/index.html#result_unit_err
+[`return_self_not_must_use`]: https://rust-lang.github.io/rust-clippy/master/index.html#return_self_not_must_use
 [`reversed_empty_ranges`]: https://rust-lang.github.io/rust-clippy/master/index.html#reversed_empty_ranges
 [`same_functions_in_if_condition`]: https://rust-lang.github.io/rust-clippy/master/index.html#same_functions_in_if_condition
 [`same_item_push`]: https://rust-lang.github.io/rust-clippy/master/index.html#same_item_push
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 04912120e27..f836d6443cd 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -245,6 +245,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(reference::REF_IN_DEREF),
     LintId::of(regex::INVALID_REGEX),
     LintId::of(repeat_once::REPEAT_ONCE),
+    LintId::of(return_self_not_must_use::RETURN_SELF_NOT_MUST_USE),
     LintId::of(returns::LET_AND_RETURN),
     LintId::of(returns::NEEDLESS_RETURN),
     LintId::of(self_assignment::SELF_ASSIGNMENT),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index bb159e50373..68889f4f50a 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -422,6 +422,7 @@ store.register_lints(&[
     regex::INVALID_REGEX,
     regex::TRIVIAL_REGEX,
     repeat_once::REPEAT_ONCE,
+    return_self_not_must_use::RETURN_SELF_NOT_MUST_USE,
     returns::LET_AND_RETURN,
     returns::NEEDLESS_RETURN,
     same_name_method::SAME_NAME_METHOD,
diff --git a/clippy_lints/src/lib.register_suspicious.rs b/clippy_lints/src/lib.register_suspicious.rs
index 414bfc42fdf..70dc9254879 100644
--- a/clippy_lints/src/lib.register_suspicious.rs
+++ b/clippy_lints/src/lib.register_suspicious.rs
@@ -17,6 +17,7 @@ store.register_group(true, "clippy::suspicious", Some("clippy_suspicious"), vec!
     LintId::of(mut_key::MUTABLE_KEY_TYPE),
     LintId::of(non_send_fields_in_send_ty::NON_SEND_FIELDS_IN_SEND_TY),
     LintId::of(octal_escapes::OCTAL_ESCAPES),
+    LintId::of(return_self_not_must_use::RETURN_SELF_NOT_MUST_USE),
     LintId::of(suspicious_trait_impl::SUSPICIOUS_ARITHMETIC_IMPL),
     LintId::of(suspicious_trait_impl::SUSPICIOUS_OP_ASSIGN_IMPL),
 ])
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index bd9710ec407..c6b14ecac43 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -341,6 +341,7 @@ mod ref_option_ref;
 mod reference;
 mod regex;
 mod repeat_once;
+mod return_self_not_must_use;
 mod returns;
 mod same_name_method;
 mod self_assignment;
@@ -853,6 +854,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(trailing_empty_array::TrailingEmptyArray));
     store.register_early_pass(|| Box::new(octal_escapes::OctalEscapes));
     store.register_late_pass(|| Box::new(needless_late_init::NeedlessLateInit));
+    store.register_late_pass(|| Box::new(return_self_not_must_use::ReturnSelfNotMustUse));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/return_self_not_must_use.rs b/clippy_lints/src/return_self_not_must_use.rs
new file mode 100644
index 00000000000..1118da6c8cb
--- /dev/null
+++ b/clippy_lints/src/return_self_not_must_use.rs
@@ -0,0 +1,105 @@
+use clippy_utils::{diagnostics::span_lint, must_use_attr, nth_arg, return_ty};
+use rustc_hir::def_id::LocalDefId;
+use rustc_hir::intravisit::FnKind;
+use rustc_hir::{Body, FnDecl, HirId, TraitItem, TraitItemKind};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_middle::lint::in_external_macro;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::Span;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// This lint warns when a method returning `Self` doesn't have the `#[must_use]` attribute.
+    ///
+    /// ### Why is this bad?
+    /// It prevents to "forget" to use the newly created value.
+    ///
+    /// ### Limitations
+    /// This lint is only applied on methods taking a `self` argument. It would be mostly noise
+    /// if it was added on constructors for example.
+    ///
+    /// ### Example
+    /// ```rust
+    /// pub struct Bar;
+    ///
+    /// impl Bar {
+    ///     // Bad
+    ///     pub fn bar(&self) -> Self {
+    ///         Self
+    ///     }
+    ///
+    ///     // Good
+    ///     #[must_use]
+    ///     pub fn foo(&self) -> Self {
+    ///         Self
+    ///     }
+    /// }
+    /// ```
+    #[clippy::version = "1.59.0"]
+    pub RETURN_SELF_NOT_MUST_USE,
+    suspicious,
+    "missing `#[must_use]` annotation on a method returning `Self`"
+}
+
+declare_lint_pass!(ReturnSelfNotMustUse => [RETURN_SELF_NOT_MUST_USE]);
+
+fn check_method(cx: &LateContext<'tcx>, decl: &'tcx FnDecl<'tcx>, fn_def: LocalDefId, span: Span, hir_id: HirId) {
+    if_chain! {
+        // If it comes from an external macro, better ignore it.
+        if !in_external_macro(cx.sess(), span);
+        if decl.implicit_self.has_implicit_self();
+        // We only show this warning for public exported methods.
+        if cx.access_levels.is_exported(fn_def);
+        if cx.tcx.visibility(fn_def.to_def_id()).is_public();
+        // No need to warn if the attribute is already present.
+        if must_use_attr(cx.tcx.hir().attrs(hir_id)).is_none();
+        let ret_ty = return_ty(cx, hir_id);
+        let self_arg = nth_arg(cx, hir_id, 0);
+        // If `Self` has the same type as the returned type, then we want to warn.
+        //
+        // For this check, we don't want to remove the reference on the returned type because if
+        // there is one, we shouldn't emit a warning!
+        if self_arg.peel_refs() == ret_ty;
+
+        then {
+            span_lint(
+                cx,
+                RETURN_SELF_NOT_MUST_USE,
+                span,
+                "missing `#[must_use]` attribute on a method returning `Self`",
+            );
+        }
+    }
+}
+
+impl<'tcx> LateLintPass<'tcx> for ReturnSelfNotMustUse {
+    fn check_fn(
+        &mut self,
+        cx: &LateContext<'tcx>,
+        kind: FnKind<'tcx>,
+        decl: &'tcx FnDecl<'tcx>,
+        _: &'tcx Body<'tcx>,
+        span: Span,
+        hir_id: HirId,
+    ) {
+        if_chain! {
+            // We are only interested in methods, not in functions or associated functions.
+            if matches!(kind, FnKind::Method(_, _, _));
+            if let Some(fn_def) = cx.tcx.hir().opt_local_def_id(hir_id);
+            if let Some(impl_def) = cx.tcx.impl_of_method(fn_def.to_def_id());
+            // We don't want this method to be te implementation of a trait because the
+            // `#[must_use]` should be put on the trait definition directly.
+            if cx.tcx.trait_id_of_impl(impl_def).is_none();
+
+            then {
+                check_method(cx, decl, fn_def, span, hir_id);
+            }
+        }
+    }
+
+    fn check_trait_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx TraitItem<'tcx>) {
+        if let TraitItemKind::Fn(ref sig, _) = item.kind {
+            check_method(cx, sig.decl, item.def_id, item.span, item.hir_id());
+        }
+    }
+}
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index f011380c127..779c812ca0b 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -1329,6 +1329,13 @@ pub fn return_ty<'tcx>(cx: &LateContext<'tcx>, fn_item: hir::HirId) -> Ty<'tcx>
     cx.tcx.erase_late_bound_regions(ret_ty)
 }
 
+/// Convenience function to get the nth argument type of a function.
+pub fn nth_arg<'tcx>(cx: &LateContext<'tcx>, fn_item: hir::HirId, nth: usize) -> Ty<'tcx> {
+    let fn_def_id = cx.tcx.hir().local_def_id(fn_item);
+    let arg = cx.tcx.fn_sig(fn_def_id).input(nth);
+    cx.tcx.erase_late_bound_regions(arg)
+}
+
 /// Checks if an expression is constructing a tuple-like enum variant or struct
 pub fn is_ctor_or_promotable_const_function(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
     if let ExprKind::Call(fun, _) = expr.kind {
diff --git a/tests/ui/return_self_not_must_use.rs b/tests/ui/return_self_not_must_use.rs
new file mode 100644
index 00000000000..bdf3f3d7995
--- /dev/null
+++ b/tests/ui/return_self_not_must_use.rs
@@ -0,0 +1,42 @@
+#![crate_type = "lib"]
+
+#[derive(Clone)]
+pub struct Bar;
+
+pub trait Whatever {
+    fn what(&self) -> Self;
+    // There should be no warning here!
+    fn what2(&self) -> &Self;
+}
+
+impl Bar {
+    // There should be no warning here!
+    pub fn not_new() -> Self {
+        Self
+    }
+    pub fn foo(&self) -> Self {
+        Self
+    }
+    pub fn bar(self) -> Self {
+        self
+    }
+    // There should be no warning here!
+    fn foo2(&self) -> Self {
+        Self
+    }
+    // There should be no warning here!
+    pub fn foo3(&self) -> &Self {
+        self
+    }
+}
+
+impl Whatever for Bar {
+    // There should be no warning here!
+    fn what(&self) -> Self {
+        self.foo2()
+    }
+    // There should be no warning here!
+    fn what2(&self) -> &Self {
+        self
+    }
+}
diff --git a/tests/ui/return_self_not_must_use.stderr b/tests/ui/return_self_not_must_use.stderr
new file mode 100644
index 00000000000..3793a5559ba
--- /dev/null
+++ b/tests/ui/return_self_not_must_use.stderr
@@ -0,0 +1,26 @@
+error: missing `#[must_use]` attribute on a method returning `Self`
+  --> $DIR/return_self_not_must_use.rs:7:5
+   |
+LL |     fn what(&self) -> Self;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::return-self-not-must-use` implied by `-D warnings`
+
+error: missing `#[must_use]` attribute on a method returning `Self`
+  --> $DIR/return_self_not_must_use.rs:17:5
+   |
+LL | /     pub fn foo(&self) -> Self {
+LL | |         Self
+LL | |     }
+   | |_____^
+
+error: missing `#[must_use]` attribute on a method returning `Self`
+  --> $DIR/return_self_not_must_use.rs:20:5
+   |
+LL | /     pub fn bar(self) -> Self {
+LL | |         self
+LL | |     }
+   | |_____^
+
+error: aborting due to 3 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From c176568abd9290088ec604be644c021caa81f508 Mon Sep 17 00:00:00 2001
From: Maybe Waffle <waffle.lapkin@gmail.com>
Date: Wed, 8 Dec 2021 14:27:49 +0300
Subject: Ignore associated items in trait *implementations* when considering
 type complexity

---
 clippy_lints/src/types/mod.rs   | 40 +++++++++++++++++++++++++++++-----------
 tests/ui/type_complexity.rs     |  3 ++-
 tests/ui/type_complexity.stderr | 20 ++++----------------
 3 files changed, 35 insertions(+), 28 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types/mod.rs b/clippy_lints/src/types/mod.rs
index 69cd49d884c..481e5957435 100644
--- a/clippy_lints/src/types/mod.rs
+++ b/clippy_lints/src/types/mod.rs
@@ -350,14 +350,24 @@ impl<'tcx> LateLintPass<'tcx> for Types {
 
     fn check_impl_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx ImplItem<'_>) {
         match item.kind {
-            ImplItemKind::Const(ty, _) => self.check_ty(
-                cx,
-                ty,
-                CheckTyContext {
-                    is_in_trait_impl: true,
-                    ..CheckTyContext::default()
-                },
-            ),
+            ImplItemKind::Const(ty, _) => {
+                let is_in_trait_impl = if let Some(hir::Node::Item(item)) =
+                    cx.tcx.hir().find(cx.tcx.hir().get_parent_item(item.hir_id()))
+                {
+                    matches!(item.kind, ItemKind::Impl(hir::Impl { of_trait: Some(_), .. }))
+                } else {
+                    false
+                };
+
+                self.check_ty(
+                    cx,
+                    ty,
+                    CheckTyContext {
+                        is_in_trait_impl,
+                        ..CheckTyContext::default()
+                    },
+                );
+            },
             // Methods are covered by check_fn.
             // Type aliases are ignored because oftentimes it's impossible to
             // make type alias declaration in trait simpler, see #1013
@@ -419,6 +429,14 @@ impl Types {
     }
 
     fn check_fn_decl(&mut self, cx: &LateContext<'_>, decl: &FnDecl<'_>, context: CheckTyContext) {
+        // Ignore functions in trait implementations as they are usually forced by the trait definition.
+        //
+        // FIXME: idially we would like to warn *if the compicated type can be simplified*, but it's hard to
+        // check.
+        if context.is_in_trait_impl {
+            return;
+        }
+
         for input in decl.inputs {
             self.check_ty(cx, input, context);
         }
@@ -437,12 +455,12 @@ impl Types {
             return;
         }
 
-        if !context.is_nested_call && type_complexity::check(cx, hir_ty, self.type_complexity_threshold) {
+        // Skip trait implementations; see issue #605.
+        if context.is_in_trait_impl {
             return;
         }
 
-        // Skip trait implementations; see issue #605.
-        if context.is_in_trait_impl {
+        if !context.is_nested_call && type_complexity::check(cx, hir_ty, self.type_complexity_threshold) {
             return;
         }
 
diff --git a/tests/ui/type_complexity.rs b/tests/ui/type_complexity.rs
index 62d00e00729..86a7bd7b627 100644
--- a/tests/ui/type_complexity.rs
+++ b/tests/ui/type_complexity.rs
@@ -30,11 +30,12 @@ trait T {
     fn def_method(&self, p: Vec<Vec<Box<(u32, u32, u32, u32)>>>) {}
 }
 
+// Should not warn since there is likely no way to simplify this (#1013)
 impl T for () {
     const A: Vec<Vec<Box<(u32, u32, u32, u32)>>> = vec![];
 
-    // Should not warn since there is likely no way to simplify this (#1013)
     type B = Vec<Vec<Box<(u32, u32, u32, u32)>>>;
+
     fn method(&self, p: Vec<Vec<Box<(u32, u32, u32, u32)>>>) {}
 }
 
diff --git a/tests/ui/type_complexity.stderr b/tests/ui/type_complexity.stderr
index 693f2adcfc8..9da7edb1c3b 100644
--- a/tests/ui/type_complexity.stderr
+++ b/tests/ui/type_complexity.stderr
@@ -73,34 +73,22 @@ LL |     fn def_method(&self, p: Vec<Vec<Box<(u32, u32, u32, u32)>>>) {}
    |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: very complex type used. Consider factoring parts into `type` definitions
-  --> $DIR/type_complexity.rs:34:14
-   |
-LL |     const A: Vec<Vec<Box<(u32, u32, u32, u32)>>> = vec![];
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: very complex type used. Consider factoring parts into `type` definitions
-  --> $DIR/type_complexity.rs:38:25
-   |
-LL |     fn method(&self, p: Vec<Vec<Box<(u32, u32, u32, u32)>>>) {}
-   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: very complex type used. Consider factoring parts into `type` definitions
-  --> $DIR/type_complexity.rs:41:15
+  --> $DIR/type_complexity.rs:42:15
    |
 LL | fn test1() -> Vec<Vec<Box<(u32, u32, u32, u32)>>> {
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: very complex type used. Consider factoring parts into `type` definitions
-  --> $DIR/type_complexity.rs:45:14
+  --> $DIR/type_complexity.rs:46:14
    |
 LL | fn test2(_x: Vec<Vec<Box<(u32, u32, u32, u32)>>>) {}
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: very complex type used. Consider factoring parts into `type` definitions
-  --> $DIR/type_complexity.rs:48:13
+  --> $DIR/type_complexity.rs:49:13
    |
 LL |     let _y: Vec<Vec<Box<(u32, u32, u32, u32)>>> = vec![];
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 17 previous errors
+error: aborting due to 15 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 392b2eff4b29cb590f1001dba12e5eed790b9841 Mon Sep 17 00:00:00 2001
From: Caio <c410.f3r@gmail.com>
Date: Wed, 8 Dec 2021 20:02:28 -0300
Subject: Fix `blocks_in_if_conditions` false positive

---
 clippy_lints/src/blocks_in_if_conditions.rs | 8 +++++---
 tests/ui/blocks_in_if_conditions_closure.rs | 8 ++++++++
 2 files changed, 13 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/blocks_in_if_conditions.rs b/clippy_lints/src/blocks_in_if_conditions.rs
index 47e5b0d583d..ff7b9fb2254 100644
--- a/clippy_lints/src/blocks_in_if_conditions.rs
+++ b/clippy_lints/src/blocks_in_if_conditions.rs
@@ -72,9 +72,11 @@ impl<'a, 'tcx> Visitor<'tcx> for ExVisitor<'a, 'tcx> {
 
             let body = self.cx.tcx.hir().body(eid);
             let ex = &body.value;
-            if matches!(ex.kind, ExprKind::Block(_, _)) && !body.value.span.from_expansion() {
-                self.found_block = Some(ex);
-                return;
+            if let ExprKind::Block(block, _) = ex.kind {
+                if !body.value.span.from_expansion() && !block.stmts.is_empty() {
+                    self.found_block = Some(ex);
+                    return;
+                }
             }
         }
         walk_expr(self, expr);
diff --git a/tests/ui/blocks_in_if_conditions_closure.rs b/tests/ui/blocks_in_if_conditions_closure.rs
index 2856943b9be..169589f6d4e 100644
--- a/tests/ui/blocks_in_if_conditions_closure.rs
+++ b/tests/ui/blocks_in_if_conditions_closure.rs
@@ -44,6 +44,14 @@ fn macro_in_closure() {
     }
 }
 
+fn closure(_: impl FnMut()) -> bool {
+    true
+}
+
+fn function_with_empty_closure() {
+    if closure(|| {}) {}
+}
+
 #[rustfmt::skip]
 fn main() {
     let mut range = 0..10;
-- 
cgit 1.4.1-3-g733a5


From 468c86e4a3fa31b8c670422ea63875428e899b7f Mon Sep 17 00:00:00 2001
From: "Samuel E. Moelius III" <sam@moeli.us>
Date: Mon, 15 Nov 2021 19:25:08 -0500
Subject: Add `unnecessary_to_owned` lint

---
 CHANGELOG.md                                     |   1 +
 clippy_lints/src/lib.register_all.rs             |   1 +
 clippy_lints/src/lib.register_lints.rs           |   1 +
 clippy_lints/src/lib.register_perf.rs            |   1 +
 clippy_lints/src/methods/mod.rs                  |  31 +-
 clippy_lints/src/methods/unnecessary_to_owned.rs | 328 +++++++++++++++++++
 clippy_lints/src/unit_return_expecting_ord.rs    |   2 +-
 clippy_utils/src/paths.rs                        |   2 +
 tests/ui/unnecessary_to_owned.fixed              | 170 ++++++++++
 tests/ui/unnecessary_to_owned.rs                 | 170 ++++++++++
 tests/ui/unnecessary_to_owned.stderr             | 382 +++++++++++++++++++++++
 11 files changed, 1087 insertions(+), 2 deletions(-)
 create mode 100644 clippy_lints/src/methods/unnecessary_to_owned.rs
 create mode 100644 tests/ui/unnecessary_to_owned.fixed
 create mode 100644 tests/ui/unnecessary_to_owned.rs
 create mode 100644 tests/ui/unnecessary_to_owned.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 2f64cd0e914..7b5279cda6e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3210,6 +3210,7 @@ Released 2018-09-13
 [`unnecessary_operation`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_operation
 [`unnecessary_self_imports`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_self_imports
 [`unnecessary_sort_by`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_sort_by
+[`unnecessary_to_owned`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_to_owned
 [`unnecessary_unwrap`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_unwrap
 [`unnecessary_wraps`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_wraps
 [`unneeded_field_pattern`]: https://rust-lang.github.io/rust-clippy/master/index.html#unneeded_field_pattern
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 9ac77d63879..3d3999d4cc0 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -181,6 +181,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(methods::UNNECESSARY_FILTER_MAP),
     LintId::of(methods::UNNECESSARY_FOLD),
     LintId::of(methods::UNNECESSARY_LAZY_EVALUATIONS),
+    LintId::of(methods::UNNECESSARY_TO_OWNED),
     LintId::of(methods::UNWRAP_OR_ELSE_DEFAULT),
     LintId::of(methods::USELESS_ASREF),
     LintId::of(methods::WRONG_SELF_CONVENTION),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 68889f4f50a..766c5ba1bcb 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -315,6 +315,7 @@ store.register_lints(&[
     methods::UNNECESSARY_FILTER_MAP,
     methods::UNNECESSARY_FOLD,
     methods::UNNECESSARY_LAZY_EVALUATIONS,
+    methods::UNNECESSARY_TO_OWNED,
     methods::UNWRAP_OR_ELSE_DEFAULT,
     methods::UNWRAP_USED,
     methods::USELESS_ASREF,
diff --git a/clippy_lints/src/lib.register_perf.rs b/clippy_lints/src/lib.register_perf.rs
index a0d5cf9418e..2ea0b696f1f 100644
--- a/clippy_lints/src/lib.register_perf.rs
+++ b/clippy_lints/src/lib.register_perf.rs
@@ -17,6 +17,7 @@ store.register_group(true, "clippy::perf", Some("clippy_perf"), vec![
     LintId::of(methods::MANUAL_STR_REPEAT),
     LintId::of(methods::OR_FUN_CALL),
     LintId::of(methods::SINGLE_CHAR_PATTERN),
+    LintId::of(methods::UNNECESSARY_TO_OWNED),
     LintId::of(misc::CMP_OWNED),
     LintId::of(mutex_atomic::MUTEX_ATOMIC),
     LintId::of(redundant_clone::REDUNDANT_CLONE),
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 58ec2213535..a0de296fd07 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -57,6 +57,7 @@ mod uninit_assumed_init;
 mod unnecessary_filter_map;
 mod unnecessary_fold;
 mod unnecessary_lazy_eval;
+mod unnecessary_to_owned;
 mod unwrap_or_else_default;
 mod unwrap_used;
 mod useless_asref;
@@ -1885,6 +1886,32 @@ declare_clippy_lint! {
     "usages of `str::splitn` that can be replaced with `str::split`"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for unnecessary calls to [`ToOwned::to_owned`](https://doc.rust-lang.org/std/borrow/trait.ToOwned.html#tymethod.to_owned)
+    /// and other `to_owned`-like functions.
+    ///
+    /// ### Why is this bad?
+    /// The unnecessary calls result in unnecessary allocations.
+    ///
+    /// ### Example
+    /// ```rust
+    /// let path = std::path::Path::new("x");
+    /// foo(&path.to_string_lossy().to_string());
+    /// fn foo(s: &str) {}
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// let path = std::path::Path::new("x");
+    /// foo(&path.to_string_lossy());
+    /// fn foo(s: &str) {}
+    /// ```
+    #[clippy::version = "1.58.0"]
+    pub UNNECESSARY_TO_OWNED,
+    perf,
+    "unnecessary calls to `to_owned`-like functions"
+}
+
 pub struct Methods {
     avoid_breaking_exported_api: bool,
     msrv: Option<RustcVersion>,
@@ -1964,7 +1991,8 @@ impl_lint_pass!(Methods => [
     MANUAL_STR_REPEAT,
     EXTEND_WITH_DRAIN,
     MANUAL_SPLIT_ONCE,
-    NEEDLESS_SPLITN
+    NEEDLESS_SPLITN,
+    UNNECESSARY_TO_OWNED
 ]);
 
 /// Extracts a method call name, args, and `Span` of the method name.
@@ -2007,6 +2035,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
                 single_char_add_str::check(cx, expr, args);
                 into_iter_on_ref::check(cx, expr, *method_span, method_call.ident.name, args);
                 single_char_pattern::check(cx, expr, method_call.ident.name, args);
+                unnecessary_to_owned::check(cx, expr, method_call.ident.name, args);
             },
             hir::ExprKind::Binary(op, lhs, rhs) if op.node == hir::BinOpKind::Eq || op.node == hir::BinOpKind::Ne => {
                 let mut info = BinaryExprInfo {
diff --git a/clippy_lints/src/methods/unnecessary_to_owned.rs b/clippy_lints/src/methods/unnecessary_to_owned.rs
new file mode 100644
index 00000000000..307de7bb65a
--- /dev/null
+++ b/clippy_lints/src/methods/unnecessary_to_owned.rs
@@ -0,0 +1,328 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet_opt;
+use clippy_utils::ty::{implements_trait, is_copy, peel_mid_ty_refs};
+use clippy_utils::{get_parent_expr, match_def_path, paths};
+use rustc_errors::Applicability;
+use rustc_hir::{def_id::DefId, BorrowKind, Expr, ExprKind};
+use rustc_lint::LateContext;
+use rustc_middle::mir::Mutability;
+use rustc_middle::ty::adjustment::{Adjust, Adjustment, OverloadedDeref};
+use rustc_middle::ty::subst::{GenericArg, GenericArgKind, SubstsRef};
+use rustc_middle::ty::{self, PredicateKind, ProjectionPredicate, TraitPredicate, Ty};
+use rustc_span::{sym, Symbol};
+use std::cmp::max;
+
+use super::UNNECESSARY_TO_OWNED;
+
+const TO_OWNED_LIKE_PATHS: &[&[&str]] = &[
+    &paths::COW_INTO_OWNED,
+    &paths::OS_STR_TO_OS_STRING,
+    &paths::PATH_TO_PATH_BUF,
+    &paths::SLICE_TO_VEC,
+    &paths::TO_OWNED_METHOD,
+    &paths::TO_STRING_METHOD,
+];
+
+pub fn check(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, method_name: Symbol, args: &'tcx [Expr<'tcx>]) {
+    if_chain! {
+        if let Some(method_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
+        if TO_OWNED_LIKE_PATHS
+            .iter()
+            .any(|path| match_def_path(cx, method_def_id, path));
+        if let [receiver] = args;
+        then {
+            // At this point, we know the call is of a `to_owned`-like function. The functions
+            // `check_addr_of_expr` and `check_call_arg` determine whether the call is unnecessary
+            // based on its context, that is, whether it is a referent in an `AddrOf` expression or
+            // an argument in a function call.
+            if check_addr_of_expr(cx, expr, method_name, receiver) {
+                return;
+            }
+            check_call_arg(cx, expr, method_name, receiver);
+        }
+    }
+}
+
+/// Checks whether `expr` is a referent in an `AddrOf` expression and, if so, determines whether its
+/// call of a `to_owned`-like function is unnecessary.
+fn check_addr_of_expr(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx Expr<'tcx>,
+    method_name: Symbol,
+    receiver: &'tcx Expr<'tcx>,
+) -> bool {
+    if_chain! {
+        if let Some(parent) = get_parent_expr(cx, expr);
+        if let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Not, _) = parent.kind;
+        let adjustments = cx.typeck_results().expr_adjustments(parent).iter().collect::<Vec<_>>();
+        if let Some(target_ty) = match adjustments[..]
+        {
+            // For matching uses of `Cow::from`
+            [
+                Adjustment {
+                    kind: Adjust::Deref(None),
+                    ..
+                },
+                Adjustment {
+                    kind: Adjust::Borrow(_),
+                    target: target_ty,
+                },
+            ]
+            // For matching uses of arrays
+            | [
+                Adjustment {
+                    kind: Adjust::Deref(None),
+                    ..
+                },
+                Adjustment {
+                    kind: Adjust::Borrow(_),
+                    ..
+                },
+                Adjustment {
+                    kind: Adjust::Pointer(_),
+                    target: target_ty,
+                },
+            ]
+            // For matching everything else
+            | [
+                Adjustment {
+                    kind: Adjust::Deref(None),
+                    ..
+                },
+                Adjustment {
+                    kind: Adjust::Deref(Some(OverloadedDeref { .. })),
+                    ..
+                },
+                Adjustment {
+                    kind: Adjust::Borrow(_),
+                    target: target_ty,
+                },
+            ] => Some(target_ty),
+            _ => None,
+        };
+        then {
+            let (target_ty, n_target_refs) = peel_mid_ty_refs(target_ty);
+            let receiver_ty = cx.typeck_results().expr_ty(receiver);
+            let (receiver_ty, n_receiver_refs) = peel_mid_ty_refs(receiver_ty);
+            if_chain! {
+                if receiver_ty == target_ty;
+                if n_target_refs >= n_receiver_refs;
+                if let Some(receiver_snippet) = snippet_opt(cx, receiver.span);
+                then {
+                    span_lint_and_sugg(
+                        cx,
+                        UNNECESSARY_TO_OWNED,
+                        parent.span,
+                        &format!("unnecessary use of `{}`", method_name),
+                        "use",
+                        format!("{:&>width$}{}", "", receiver_snippet, width = n_target_refs - n_receiver_refs),
+                        Applicability::MachineApplicable,
+                    );
+                    return true;
+                }
+            }
+            if implements_deref_trait(cx, receiver_ty, target_ty) {
+                span_lint_and_sugg(
+                    cx,
+                    UNNECESSARY_TO_OWNED,
+                    expr.span.with_lo(receiver.span.hi()),
+                    &format!("unnecessary use of `{}`", method_name),
+                    "remove this",
+                    String::new(),
+                    Applicability::MachineApplicable,
+                );
+                return true;
+            }
+            if_chain! {
+                if let Some(as_ref_trait_id) = cx.tcx.get_diagnostic_item(sym::AsRef);
+                if implements_trait(cx, receiver_ty, as_ref_trait_id, &[GenericArg::from(target_ty)]);
+                if let Some(receiver_snippet) = snippet_opt(cx, receiver.span);
+                then {
+                    span_lint_and_sugg(
+                        cx,
+                        UNNECESSARY_TO_OWNED,
+                        parent.span,
+                        &format!("unnecessary use of `{}`", method_name),
+                        "use",
+                        format!("{}.as_ref()", receiver_snippet),
+                        Applicability::MachineApplicable,
+                    );
+                    return true;
+                }
+            }
+        }
+    }
+    false
+}
+
+/// Checks whether `expr` is an argument in a function call and, if so, determines whether its call
+/// of a `to_owned`-like function is unnecessary.
+fn check_call_arg(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, method_name: Symbol, receiver: &'tcx Expr<'tcx>) {
+    if_chain! {
+        if let Some((maybe_call, maybe_arg)) = skip_addr_of_ancestors(cx, expr);
+        if let Some((callee_def_id, call_substs, call_args)) = get_callee_substs_and_args(cx, maybe_call);
+        let fn_sig = cx.tcx.fn_sig(callee_def_id).skip_binder();
+        if let Some(i) = call_args.iter().position(|arg| arg.hir_id == maybe_arg.hir_id);
+        if let Some(input) = fn_sig.inputs().get(i);
+        let (input, n_refs) = peel_mid_ty_refs(input);
+        if let (trait_predicates, projection_predicates) = get_input_traits_and_projections(cx, callee_def_id, input);
+        if let Some(sized_def_id) = cx.tcx.lang_items().sized_trait();
+        if let [trait_predicate] = trait_predicates
+            .iter()
+            .filter(|trait_predicate| trait_predicate.def_id() != sized_def_id)
+            .collect::<Vec<_>>()[..];
+        if let Some(deref_trait_id) = cx.tcx.get_diagnostic_item(sym::Deref);
+        if let Some(as_ref_trait_id) = cx.tcx.get_diagnostic_item(sym::AsRef);
+        let receiver_ty = cx.typeck_results().expr_ty(receiver);
+        // If the callee has type parameters, they could appear in `projection_predicate.ty` or the
+        // types of `trait_predicate.trait_ref.substs`.
+        if if trait_predicate.def_id() == deref_trait_id {
+            if let [projection_predicate] = projection_predicates[..] {
+                let normalized_ty =
+                    cx.tcx.subst_and_normalize_erasing_regions(call_substs, cx.param_env, projection_predicate.ty);
+                implements_deref_trait(cx, receiver_ty, normalized_ty)
+            } else {
+                false
+            }
+        } else if trait_predicate.def_id() == as_ref_trait_id {
+            let composed_substs = compose_substs(
+                cx,
+                &trait_predicate.trait_ref.substs.iter().skip(1).collect::<Vec<_>>()[..],
+                call_substs
+            );
+            implements_trait(cx, receiver_ty, as_ref_trait_id, &composed_substs)
+        } else {
+            false
+        };
+        // We can't add an `&` when the trait is `Deref` because `Target = &T` won't match
+        // `Target = T`.
+        if n_refs > 0 || is_copy(cx, receiver_ty) || trait_predicate.def_id() != deref_trait_id;
+        let n_refs = max(n_refs, if is_copy(cx, receiver_ty) { 0 } else { 1 });
+        if let Some(receiver_snippet) = snippet_opt(cx, receiver.span);
+        then {
+            span_lint_and_sugg(
+                cx,
+                UNNECESSARY_TO_OWNED,
+                maybe_arg.span,
+                &format!("unnecessary use of `{}`", method_name),
+                "use",
+                format!("{:&>width$}{}", "", receiver_snippet, width = n_refs),
+                Applicability::MachineApplicable,
+            );
+        }
+    }
+}
+
+/// Walks an expression's ancestors until it finds a non-`AddrOf` expression. Returns the first such
+/// expression found (if any) along with the immediately prior expression.
+fn skip_addr_of_ancestors(
+    cx: &LateContext<'tcx>,
+    mut expr: &'tcx Expr<'tcx>,
+) -> Option<(&'tcx Expr<'tcx>, &'tcx Expr<'tcx>)> {
+    while let Some(parent) = get_parent_expr(cx, expr) {
+        if let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Not, _) = parent.kind {
+            expr = parent;
+        } else {
+            return Some((parent, expr));
+        }
+    }
+    None
+}
+
+/// Checks whether an expression is a function or method call and, if so, returns its `DefId`,
+/// `Substs`, and arguments.
+fn get_callee_substs_and_args(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx Expr<'tcx>,
+) -> Option<(DefId, SubstsRef<'tcx>, &'tcx [Expr<'tcx>])> {
+    if_chain! {
+        if let ExprKind::Call(callee, args) = expr.kind;
+        let callee_ty = cx.typeck_results().expr_ty(callee);
+        if let ty::FnDef(callee_def_id, _) = callee_ty.kind();
+        then {
+            let substs = cx.typeck_results().node_substs(callee.hir_id);
+            return Some((*callee_def_id, substs, args));
+        }
+    }
+    if_chain! {
+        if let ExprKind::MethodCall(_, _, args, _) = expr.kind;
+        if let Some(method_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
+        then {
+            let substs = cx.typeck_results().node_substs(expr.hir_id);
+            return Some((method_def_id, substs, args));
+        }
+    }
+    None
+}
+
+/// Returns the `TraitPredicate`s and `ProjectionPredicate`s for a function's input type.
+fn get_input_traits_and_projections(
+    cx: &LateContext<'tcx>,
+    callee_def_id: DefId,
+    input: Ty<'tcx>,
+) -> (Vec<TraitPredicate<'tcx>>, Vec<ProjectionPredicate<'tcx>>) {
+    let mut trait_predicates = Vec::new();
+    let mut projection_predicates = Vec::new();
+    for (predicate, _) in cx.tcx.predicates_of(callee_def_id).predicates.iter() {
+        // `substs` should have 1 + n elements. The first is the type on the left hand side of an
+        // `as`. The remaining n are trait parameters.
+        let is_input_substs = |substs: SubstsRef<'tcx>| {
+            if_chain! {
+                if let Some(arg) = substs.iter().next();
+                if let GenericArgKind::Type(arg_ty) = arg.unpack();
+                if arg_ty == input;
+                then {
+                    true
+                } else {
+                    false
+                }
+            }
+        };
+        match predicate.kind().skip_binder() {
+            PredicateKind::Trait(trait_predicate) => {
+                if is_input_substs(trait_predicate.trait_ref.substs) {
+                    trait_predicates.push(trait_predicate);
+                }
+            },
+            PredicateKind::Projection(projection_predicate) => {
+                if is_input_substs(projection_predicate.projection_ty.substs) {
+                    projection_predicates.push(projection_predicate);
+                }
+            },
+            _ => {},
+        }
+    }
+    (trait_predicates, projection_predicates)
+}
+
+/// Composes two substitutions by applying the latter to the types of the former.
+fn compose_substs(cx: &LateContext<'tcx>, left: &[GenericArg<'tcx>], right: SubstsRef<'tcx>) -> Vec<GenericArg<'tcx>> {
+    left.iter()
+        .map(|arg| {
+            if let GenericArgKind::Type(arg_ty) = arg.unpack() {
+                let normalized_ty = cx.tcx.subst_and_normalize_erasing_regions(right, cx.param_env, arg_ty);
+                GenericArg::from(normalized_ty)
+            } else {
+                *arg
+            }
+        })
+        .collect()
+}
+
+/// Helper function to check whether a type implements the `Deref` trait.
+fn implements_deref_trait(cx: &LateContext<'tcx>, ty: Ty<'tcx>, deref_target_ty: Ty<'tcx>) -> bool {
+    if_chain! {
+        if let Some(deref_trait_id) = cx.tcx.get_diagnostic_item(sym::Deref);
+        if implements_trait(cx, ty, deref_trait_id, &[]);
+        if let Some(deref_target_id) = cx.tcx.lang_items().deref_target();
+        let substs = cx.tcx.mk_substs_trait(ty, &[]);
+        let projection_ty = cx.tcx.mk_projection(deref_target_id, substs);
+        let normalized_ty = cx.tcx.normalize_erasing_regions(cx.param_env, projection_ty);
+        if normalized_ty == deref_target_ty;
+        then {
+            true
+        } else {
+            false
+        }
+    }
+}
diff --git a/clippy_lints/src/unit_return_expecting_ord.rs b/clippy_lints/src/unit_return_expecting_ord.rs
index 9fb8f236899..fe35ff33d35 100644
--- a/clippy_lints/src/unit_return_expecting_ord.rs
+++ b/clippy_lints/src/unit_return_expecting_ord.rs
@@ -169,7 +169,7 @@ impl<'tcx> LateLintPass<'tcx> for UnitReturnExpectingOrd {
                                     trait_name
                                 ),
                                 Some(last_semi),
-                                &"probably caused by this trailing semicolon".to_string(),
+                                "probably caused by this trailing semicolon",
                             );
                         },
                         None => {},
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index 6171823abbb..634a452d6f1 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -36,6 +36,7 @@ pub const CLONE_TRAIT_METHOD: [&str; 4] = ["core", "clone", "Clone", "clone"];
 pub const CMP_MAX: [&str; 3] = ["core", "cmp", "max"];
 pub const CMP_MIN: [&str; 3] = ["core", "cmp", "min"];
 pub const COW: [&str; 3] = ["alloc", "borrow", "Cow"];
+pub const COW_INTO_OWNED: [&str; 4] = ["alloc", "borrow", "Cow", "into_owned"];
 pub const CSTRING_AS_C_STR: [&str; 5] = ["std", "ffi", "c_str", "CString", "as_c_str"];
 pub const DEFAULT_TRAIT_METHOD: [&str; 4] = ["core", "default", "Default", "default"];
 pub const DEREF_MUT_TRAIT_METHOD: [&str; 5] = ["core", "ops", "deref", "DerefMut", "deref_mut"];
@@ -170,6 +171,7 @@ pub const SLICE_FROM_RAW_PARTS: [&str; 4] = ["core", "slice", "raw", "from_raw_p
 pub const SLICE_FROM_RAW_PARTS_MUT: [&str; 4] = ["core", "slice", "raw", "from_raw_parts_mut"];
 pub const SLICE_INTO_VEC: [&str; 4] = ["alloc", "slice", "<impl [T]>", "into_vec"];
 pub const SLICE_ITER: [&str; 4] = ["core", "slice", "iter", "Iter"];
+pub const SLICE_TO_VEC: [&str; 4] = ["alloc", "slice", "<impl [T]>", "to_vec"];
 pub const STDERR: [&str; 4] = ["std", "io", "stdio", "stderr"];
 pub const STDOUT: [&str; 4] = ["std", "io", "stdio", "stdout"];
 pub const CONVERT_IDENTITY: [&str; 3] = ["core", "convert", "identity"];
diff --git a/tests/ui/unnecessary_to_owned.fixed b/tests/ui/unnecessary_to_owned.fixed
new file mode 100644
index 00000000000..f1a5dc91a7e
--- /dev/null
+++ b/tests/ui/unnecessary_to_owned.fixed
@@ -0,0 +1,170 @@
+// run-rustfix
+
+#![allow(clippy::ptr_arg)]
+// Some of the expressions that `redundant_clone` flags overlap with ours. Enabling it interferes
+// with `rustfix`.
+#![allow(clippy::redundant_clone)]
+// `needless_borrow` is for checking the fixed code.
+#![warn(clippy::needless_borrow)]
+#![warn(clippy::unnecessary_to_owned)]
+
+use std::borrow::Cow;
+use std::ffi::{CStr, OsStr};
+use std::ops::Deref;
+
+#[derive(Clone)]
+struct X(String);
+
+impl Deref for X {
+    type Target = [u8];
+    fn deref(&self) -> &[u8] {
+        self.0.as_bytes()
+    }
+}
+
+impl AsRef<str> for X {
+    fn as_ref(&self) -> &str {
+        self.0.as_str()
+    }
+}
+
+impl ToString for X {
+    fn to_string(&self) -> String {
+        self.0.to_string()
+    }
+}
+
+impl X {
+    fn join(&self, other: impl AsRef<str>) -> Self {
+        let mut s = self.0.clone();
+        s.push_str(other.as_ref());
+        Self(s)
+    }
+}
+
+fn main() {
+    let c_str = CStr::from_bytes_with_nul(&[0]).unwrap();
+    let os_str = OsStr::new("x");
+    let path = std::path::Path::new("x");
+    let s = "x";
+    let array = ["x"];
+    let array_ref = &["x"];
+    let slice = &["x"][..];
+    let x = X(String::from("x"));
+
+    require_c_str(&Cow::from(c_str));
+    require_c_str(c_str);
+
+    require_os_str(os_str);
+    require_os_str(&Cow::from(os_str));
+    require_os_str(os_str);
+
+    require_path(path);
+    require_path(&Cow::from(path));
+    require_path(path);
+
+    require_str(s);
+    require_str(&Cow::from(s));
+    require_str(s);
+    require_str(x.as_ref());
+
+    require_slice(slice);
+    require_slice(&Cow::from(slice));
+    require_slice(array.as_ref());
+    require_slice(array_ref.as_ref());
+    require_slice(slice);
+    require_slice(&x);
+
+    require_x(&Cow::<X>::Owned(x.clone()));
+    require_x(&x);
+
+    require_deref_c_str(c_str);
+    require_deref_os_str(os_str);
+    require_deref_path(path);
+    require_deref_str(s);
+    require_deref_slice(slice);
+
+    require_impl_deref_c_str(c_str);
+    require_impl_deref_os_str(os_str);
+    require_impl_deref_path(path);
+    require_impl_deref_str(s);
+    require_impl_deref_slice(slice);
+
+    require_deref_str_slice(s, slice);
+    require_deref_slice_str(slice, s);
+
+    require_as_ref_c_str(c_str);
+    require_as_ref_os_str(os_str);
+    require_as_ref_path(path);
+    require_as_ref_str(s);
+    require_as_ref_str(&x);
+    require_as_ref_slice(array);
+    require_as_ref_slice(array_ref);
+    require_as_ref_slice(slice);
+
+    require_impl_as_ref_c_str(c_str);
+    require_impl_as_ref_os_str(os_str);
+    require_impl_as_ref_path(path);
+    require_impl_as_ref_str(s);
+    require_impl_as_ref_str(&x);
+    require_impl_as_ref_slice(array);
+    require_impl_as_ref_slice(array_ref);
+    require_impl_as_ref_slice(slice);
+
+    require_as_ref_str_slice(s, array);
+    require_as_ref_str_slice(s, array_ref);
+    require_as_ref_str_slice(s, slice);
+    require_as_ref_slice_str(array, s);
+    require_as_ref_slice_str(array_ref, s);
+    require_as_ref_slice_str(slice, s);
+
+    let _ = x.join(&x);
+
+    // negative tests
+    require_string(&s.to_string());
+    require_string(&Cow::from(s).into_owned());
+    require_string(&s.to_owned());
+    require_string(&x.to_string());
+
+    // `X` isn't copy.
+    require_deref_slice(x.to_owned());
+}
+
+fn require_c_str(_: &CStr) {}
+fn require_os_str(_: &OsStr) {}
+fn require_path(_: &std::path::Path) {}
+fn require_str(_: &str) {}
+fn require_slice<T>(_: &[T]) {}
+fn require_x(_: &X) {}
+
+fn require_deref_c_str<T: Deref<Target = CStr>>(_: T) {}
+fn require_deref_os_str<T: Deref<Target = OsStr>>(_: T) {}
+fn require_deref_path<T: Deref<Target = std::path::Path>>(_: T) {}
+fn require_deref_str<T: Deref<Target = str>>(_: T) {}
+fn require_deref_slice<T, U: Deref<Target = [T]>>(_: U) {}
+
+fn require_impl_deref_c_str(_: impl Deref<Target = CStr>) {}
+fn require_impl_deref_os_str(_: impl Deref<Target = OsStr>) {}
+fn require_impl_deref_path(_: impl Deref<Target = std::path::Path>) {}
+fn require_impl_deref_str(_: impl Deref<Target = str>) {}
+fn require_impl_deref_slice<T>(_: impl Deref<Target = [T]>) {}
+
+fn require_deref_str_slice<T: Deref<Target = str>, U, V: Deref<Target = [U]>>(_: T, _: V) {}
+fn require_deref_slice_str<T, U: Deref<Target = [T]>, V: Deref<Target = str>>(_: U, _: V) {}
+
+fn require_as_ref_c_str<T: AsRef<CStr>>(_: T) {}
+fn require_as_ref_os_str<T: AsRef<OsStr>>(_: T) {}
+fn require_as_ref_path<T: AsRef<std::path::Path>>(_: T) {}
+fn require_as_ref_str<T: AsRef<str>>(_: T) {}
+fn require_as_ref_slice<T, U: AsRef<[T]>>(_: U) {}
+
+fn require_impl_as_ref_c_str(_: impl AsRef<CStr>) {}
+fn require_impl_as_ref_os_str(_: impl AsRef<OsStr>) {}
+fn require_impl_as_ref_path(_: impl AsRef<std::path::Path>) {}
+fn require_impl_as_ref_str(_: impl AsRef<str>) {}
+fn require_impl_as_ref_slice<T>(_: impl AsRef<[T]>) {}
+
+fn require_as_ref_str_slice<T: AsRef<str>, U, V: AsRef<[U]>>(_: T, _: V) {}
+fn require_as_ref_slice_str<T, U: AsRef<[T]>, V: AsRef<str>>(_: U, _: V) {}
+
+fn require_string(_: &String) {}
diff --git a/tests/ui/unnecessary_to_owned.rs b/tests/ui/unnecessary_to_owned.rs
new file mode 100644
index 00000000000..081ff635bbd
--- /dev/null
+++ b/tests/ui/unnecessary_to_owned.rs
@@ -0,0 +1,170 @@
+// run-rustfix
+
+#![allow(clippy::ptr_arg)]
+// Some of the expressions that `redundant_clone` flags overlap with ours. Enabling it interferes
+// with `rustfix`.
+#![allow(clippy::redundant_clone)]
+// `needless_borrow` is for checking the fixed code.
+#![warn(clippy::needless_borrow)]
+#![warn(clippy::unnecessary_to_owned)]
+
+use std::borrow::Cow;
+use std::ffi::{CStr, OsStr};
+use std::ops::Deref;
+
+#[derive(Clone)]
+struct X(String);
+
+impl Deref for X {
+    type Target = [u8];
+    fn deref(&self) -> &[u8] {
+        self.0.as_bytes()
+    }
+}
+
+impl AsRef<str> for X {
+    fn as_ref(&self) -> &str {
+        self.0.as_str()
+    }
+}
+
+impl ToString for X {
+    fn to_string(&self) -> String {
+        self.0.to_string()
+    }
+}
+
+impl X {
+    fn join(&self, other: impl AsRef<str>) -> Self {
+        let mut s = self.0.clone();
+        s.push_str(other.as_ref());
+        Self(s)
+    }
+}
+
+fn main() {
+    let c_str = CStr::from_bytes_with_nul(&[0]).unwrap();
+    let os_str = OsStr::new("x");
+    let path = std::path::Path::new("x");
+    let s = "x";
+    let array = ["x"];
+    let array_ref = &["x"];
+    let slice = &["x"][..];
+    let x = X(String::from("x"));
+
+    require_c_str(&Cow::from(c_str).into_owned());
+    require_c_str(&c_str.to_owned());
+
+    require_os_str(&os_str.to_os_string());
+    require_os_str(&Cow::from(os_str).into_owned());
+    require_os_str(&os_str.to_owned());
+
+    require_path(&path.to_path_buf());
+    require_path(&Cow::from(path).into_owned());
+    require_path(&path.to_owned());
+
+    require_str(&s.to_string());
+    require_str(&Cow::from(s).into_owned());
+    require_str(&s.to_owned());
+    require_str(&x.to_string());
+
+    require_slice(&slice.to_vec());
+    require_slice(&Cow::from(slice).into_owned());
+    require_slice(&array.to_owned());
+    require_slice(&array_ref.to_owned());
+    require_slice(&slice.to_owned());
+    require_slice(&x.to_owned());
+
+    require_x(&Cow::<X>::Owned(x.clone()).into_owned());
+    require_x(&x.to_owned());
+
+    require_deref_c_str(c_str.to_owned());
+    require_deref_os_str(os_str.to_owned());
+    require_deref_path(path.to_owned());
+    require_deref_str(s.to_owned());
+    require_deref_slice(slice.to_owned());
+
+    require_impl_deref_c_str(c_str.to_owned());
+    require_impl_deref_os_str(os_str.to_owned());
+    require_impl_deref_path(path.to_owned());
+    require_impl_deref_str(s.to_owned());
+    require_impl_deref_slice(slice.to_owned());
+
+    require_deref_str_slice(s.to_owned(), slice.to_owned());
+    require_deref_slice_str(slice.to_owned(), s.to_owned());
+
+    require_as_ref_c_str(c_str.to_owned());
+    require_as_ref_os_str(os_str.to_owned());
+    require_as_ref_path(path.to_owned());
+    require_as_ref_str(s.to_owned());
+    require_as_ref_str(x.to_owned());
+    require_as_ref_slice(array.to_owned());
+    require_as_ref_slice(array_ref.to_owned());
+    require_as_ref_slice(slice.to_owned());
+
+    require_impl_as_ref_c_str(c_str.to_owned());
+    require_impl_as_ref_os_str(os_str.to_owned());
+    require_impl_as_ref_path(path.to_owned());
+    require_impl_as_ref_str(s.to_owned());
+    require_impl_as_ref_str(x.to_owned());
+    require_impl_as_ref_slice(array.to_owned());
+    require_impl_as_ref_slice(array_ref.to_owned());
+    require_impl_as_ref_slice(slice.to_owned());
+
+    require_as_ref_str_slice(s.to_owned(), array.to_owned());
+    require_as_ref_str_slice(s.to_owned(), array_ref.to_owned());
+    require_as_ref_str_slice(s.to_owned(), slice.to_owned());
+    require_as_ref_slice_str(array.to_owned(), s.to_owned());
+    require_as_ref_slice_str(array_ref.to_owned(), s.to_owned());
+    require_as_ref_slice_str(slice.to_owned(), s.to_owned());
+
+    let _ = x.join(&x.to_string());
+
+    // negative tests
+    require_string(&s.to_string());
+    require_string(&Cow::from(s).into_owned());
+    require_string(&s.to_owned());
+    require_string(&x.to_string());
+
+    // `X` isn't copy.
+    require_deref_slice(x.to_owned());
+}
+
+fn require_c_str(_: &CStr) {}
+fn require_os_str(_: &OsStr) {}
+fn require_path(_: &std::path::Path) {}
+fn require_str(_: &str) {}
+fn require_slice<T>(_: &[T]) {}
+fn require_x(_: &X) {}
+
+fn require_deref_c_str<T: Deref<Target = CStr>>(_: T) {}
+fn require_deref_os_str<T: Deref<Target = OsStr>>(_: T) {}
+fn require_deref_path<T: Deref<Target = std::path::Path>>(_: T) {}
+fn require_deref_str<T: Deref<Target = str>>(_: T) {}
+fn require_deref_slice<T, U: Deref<Target = [T]>>(_: U) {}
+
+fn require_impl_deref_c_str(_: impl Deref<Target = CStr>) {}
+fn require_impl_deref_os_str(_: impl Deref<Target = OsStr>) {}
+fn require_impl_deref_path(_: impl Deref<Target = std::path::Path>) {}
+fn require_impl_deref_str(_: impl Deref<Target = str>) {}
+fn require_impl_deref_slice<T>(_: impl Deref<Target = [T]>) {}
+
+fn require_deref_str_slice<T: Deref<Target = str>, U, V: Deref<Target = [U]>>(_: T, _: V) {}
+fn require_deref_slice_str<T, U: Deref<Target = [T]>, V: Deref<Target = str>>(_: U, _: V) {}
+
+fn require_as_ref_c_str<T: AsRef<CStr>>(_: T) {}
+fn require_as_ref_os_str<T: AsRef<OsStr>>(_: T) {}
+fn require_as_ref_path<T: AsRef<std::path::Path>>(_: T) {}
+fn require_as_ref_str<T: AsRef<str>>(_: T) {}
+fn require_as_ref_slice<T, U: AsRef<[T]>>(_: U) {}
+
+fn require_impl_as_ref_c_str(_: impl AsRef<CStr>) {}
+fn require_impl_as_ref_os_str(_: impl AsRef<OsStr>) {}
+fn require_impl_as_ref_path(_: impl AsRef<std::path::Path>) {}
+fn require_impl_as_ref_str(_: impl AsRef<str>) {}
+fn require_impl_as_ref_slice<T>(_: impl AsRef<[T]>) {}
+
+fn require_as_ref_str_slice<T: AsRef<str>, U, V: AsRef<[U]>>(_: T, _: V) {}
+fn require_as_ref_slice_str<T, U: AsRef<[T]>, V: AsRef<str>>(_: U, _: V) {}
+
+fn require_string(_: &String) {}
diff --git a/tests/ui/unnecessary_to_owned.stderr b/tests/ui/unnecessary_to_owned.stderr
new file mode 100644
index 00000000000..b15dd4c7ee7
--- /dev/null
+++ b/tests/ui/unnecessary_to_owned.stderr
@@ -0,0 +1,382 @@
+error: unnecessary use of `into_owned`
+  --> $DIR/unnecessary_to_owned.rs:55:36
+   |
+LL |     require_c_str(&Cow::from(c_str).into_owned());
+   |                                    ^^^^^^^^^^^^^ help: remove this
+   |
+   = note: `-D clippy::unnecessary-to-owned` implied by `-D warnings`
+
+error: unnecessary use of `to_owned`
+  --> $DIR/unnecessary_to_owned.rs:56:19
+   |
+LL |     require_c_str(&c_str.to_owned());
+   |                   ^^^^^^^^^^^^^^^^^ help: use: `c_str`
+
+error: unnecessary use of `to_os_string`
+  --> $DIR/unnecessary_to_owned.rs:58:20
+   |
+LL |     require_os_str(&os_str.to_os_string());
+   |                    ^^^^^^^^^^^^^^^^^^^^^^ help: use: `os_str`
+
+error: unnecessary use of `into_owned`
+  --> $DIR/unnecessary_to_owned.rs:59:38
+   |
+LL |     require_os_str(&Cow::from(os_str).into_owned());
+   |                                      ^^^^^^^^^^^^^ help: remove this
+
+error: unnecessary use of `to_owned`
+  --> $DIR/unnecessary_to_owned.rs:60:20
+   |
+LL |     require_os_str(&os_str.to_owned());
+   |                    ^^^^^^^^^^^^^^^^^^ help: use: `os_str`
+
+error: unnecessary use of `to_path_buf`
+  --> $DIR/unnecessary_to_owned.rs:62:18
+   |
+LL |     require_path(&path.to_path_buf());
+   |                  ^^^^^^^^^^^^^^^^^^^ help: use: `path`
+
+error: unnecessary use of `into_owned`
+  --> $DIR/unnecessary_to_owned.rs:63:34
+   |
+LL |     require_path(&Cow::from(path).into_owned());
+   |                                  ^^^^^^^^^^^^^ help: remove this
+
+error: unnecessary use of `to_owned`
+  --> $DIR/unnecessary_to_owned.rs:64:18
+   |
+LL |     require_path(&path.to_owned());
+   |                  ^^^^^^^^^^^^^^^^ help: use: `path`
+
+error: unnecessary use of `to_string`
+  --> $DIR/unnecessary_to_owned.rs:66:17
+   |
+LL |     require_str(&s.to_string());
+   |                 ^^^^^^^^^^^^^^ help: use: `s`
+
+error: unnecessary use of `into_owned`
+  --> $DIR/unnecessary_to_owned.rs:67:30
+   |
+LL |     require_str(&Cow::from(s).into_owned());
+   |                              ^^^^^^^^^^^^^ help: remove this
+
+error: unnecessary use of `to_owned`
+  --> $DIR/unnecessary_to_owned.rs:68:17
+   |
+LL |     require_str(&s.to_owned());
+   |                 ^^^^^^^^^^^^^ help: use: `s`
+
+error: unnecessary use of `to_string`
+  --> $DIR/unnecessary_to_owned.rs:69:17
+   |
+LL |     require_str(&x.to_string());
+   |                 ^^^^^^^^^^^^^^ help: use: `x.as_ref()`
+
+error: unnecessary use of `to_vec`
+  --> $DIR/unnecessary_to_owned.rs:71:19
+   |
+LL |     require_slice(&slice.to_vec());
+   |                   ^^^^^^^^^^^^^^^ help: use: `slice`
+
+error: unnecessary use of `into_owned`
+  --> $DIR/unnecessary_to_owned.rs:72:36
+   |
+LL |     require_slice(&Cow::from(slice).into_owned());
+   |                                    ^^^^^^^^^^^^^ help: remove this
+
+error: unnecessary use of `to_owned`
+  --> $DIR/unnecessary_to_owned.rs:73:19
+   |
+LL |     require_slice(&array.to_owned());
+   |                   ^^^^^^^^^^^^^^^^^ help: use: `array.as_ref()`
+
+error: unnecessary use of `to_owned`
+  --> $DIR/unnecessary_to_owned.rs:74:19
+   |
+LL |     require_slice(&array_ref.to_owned());
+   |                   ^^^^^^^^^^^^^^^^^^^^^ help: use: `array_ref.as_ref()`
+
+error: unnecessary use of `to_owned`
+  --> $DIR/unnecessary_to_owned.rs:75:19
+   |
+LL |     require_slice(&slice.to_owned());
+   |                   ^^^^^^^^^^^^^^^^^ help: use: `slice`
+
+error: unnecessary use of `to_owned`
+  --> $DIR/unnecessary_to_owned.rs:76:21
+   |
+LL |     require_slice(&x.to_owned());
+   |                     ^^^^^^^^^^^ help: remove this
+
+error: unnecessary use of `into_owned`
+  --> $DIR/unnecessary_to_owned.rs:78:42
+   |
+LL |     require_x(&Cow::<X>::Owned(x.clone()).into_owned());
+   |                                          ^^^^^^^^^^^^^ help: remove this
+
+error: unnecessary use of `to_owned`
+  --> $DIR/unnecessary_to_owned.rs:79:15
+   |
+LL |     require_x(&x.to_owned());
+   |               ^^^^^^^^^^^^^ help: use: `&x`
+
+error: unnecessary use of `to_owned`
+  --> $DIR/unnecessary_to_owned.rs:81:25
+   |
+LL |     require_deref_c_str(c_str.to_owned());
+   |                         ^^^^^^^^^^^^^^^^ help: use: `c_str`
+
+error: unnecessary use of `to_owned`
+  --> $DIR/unnecessary_to_owned.rs:82:26
+   |
+LL |     require_deref_os_str(os_str.to_owned());
+   |                          ^^^^^^^^^^^^^^^^^ help: use: `os_str`
+
+error: unnecessary use of `to_owned`
+  --> $DIR/unnecessary_to_owned.rs:83:24
+   |
+LL |     require_deref_path(path.to_owned());
+   |                        ^^^^^^^^^^^^^^^ help: use: `path`
+
+error: unnecessary use of `to_owned`
+  --> $DIR/unnecessary_to_owned.rs:84:23
+   |
+LL |     require_deref_str(s.to_owned());
+   |                       ^^^^^^^^^^^^ help: use: `s`
+
+error: unnecessary use of `to_owned`
+  --> $DIR/unnecessary_to_owned.rs:85:25
+   |
+LL |     require_deref_slice(slice.to_owned());
+   |                         ^^^^^^^^^^^^^^^^ help: use: `slice`
+
+error: unnecessary use of `to_owned`
+  --> $DIR/unnecessary_to_owned.rs:87:30
+   |
+LL |     require_impl_deref_c_str(c_str.to_owned());
+   |                              ^^^^^^^^^^^^^^^^ help: use: `c_str`
+
+error: unnecessary use of `to_owned`
+  --> $DIR/unnecessary_to_owned.rs:88:31
+   |
+LL |     require_impl_deref_os_str(os_str.to_owned());
+   |                               ^^^^^^^^^^^^^^^^^ help: use: `os_str`
+
+error: unnecessary use of `to_owned`
+  --> $DIR/unnecessary_to_owned.rs:89:29
+   |
+LL |     require_impl_deref_path(path.to_owned());
+   |                             ^^^^^^^^^^^^^^^ help: use: `path`
+
+error: unnecessary use of `to_owned`
+  --> $DIR/unnecessary_to_owned.rs:90:28
+   |
+LL |     require_impl_deref_str(s.to_owned());
+   |                            ^^^^^^^^^^^^ help: use: `s`
+
+error: unnecessary use of `to_owned`
+  --> $DIR/unnecessary_to_owned.rs:91:30
+   |
+LL |     require_impl_deref_slice(slice.to_owned());
+   |                              ^^^^^^^^^^^^^^^^ help: use: `slice`
+
+error: unnecessary use of `to_owned`
+  --> $DIR/unnecessary_to_owned.rs:93:29
+   |
+LL |     require_deref_str_slice(s.to_owned(), slice.to_owned());
+   |                             ^^^^^^^^^^^^ help: use: `s`
+
+error: unnecessary use of `to_owned`
+  --> $DIR/unnecessary_to_owned.rs:93:43
+   |
+LL |     require_deref_str_slice(s.to_owned(), slice.to_owned());
+   |                                           ^^^^^^^^^^^^^^^^ help: use: `slice`
+
+error: unnecessary use of `to_owned`
+  --> $DIR/unnecessary_to_owned.rs:94:29
+   |
+LL |     require_deref_slice_str(slice.to_owned(), s.to_owned());
+   |                             ^^^^^^^^^^^^^^^^ help: use: `slice`
+
+error: unnecessary use of `to_owned`
+  --> $DIR/unnecessary_to_owned.rs:94:47
+   |
+LL |     require_deref_slice_str(slice.to_owned(), s.to_owned());
+   |                                               ^^^^^^^^^^^^ help: use: `s`
+
+error: unnecessary use of `to_owned`
+  --> $DIR/unnecessary_to_owned.rs:96:26
+   |
+LL |     require_as_ref_c_str(c_str.to_owned());
+   |                          ^^^^^^^^^^^^^^^^ help: use: `c_str`
+
+error: unnecessary use of `to_owned`
+  --> $DIR/unnecessary_to_owned.rs:97:27
+   |
+LL |     require_as_ref_os_str(os_str.to_owned());
+   |                           ^^^^^^^^^^^^^^^^^ help: use: `os_str`
+
+error: unnecessary use of `to_owned`
+  --> $DIR/unnecessary_to_owned.rs:98:25
+   |
+LL |     require_as_ref_path(path.to_owned());
+   |                         ^^^^^^^^^^^^^^^ help: use: `path`
+
+error: unnecessary use of `to_owned`
+  --> $DIR/unnecessary_to_owned.rs:99:24
+   |
+LL |     require_as_ref_str(s.to_owned());
+   |                        ^^^^^^^^^^^^ help: use: `s`
+
+error: unnecessary use of `to_owned`
+  --> $DIR/unnecessary_to_owned.rs:100:24
+   |
+LL |     require_as_ref_str(x.to_owned());
+   |                        ^^^^^^^^^^^^ help: use: `&x`
+
+error: unnecessary use of `to_owned`
+  --> $DIR/unnecessary_to_owned.rs:101:26
+   |
+LL |     require_as_ref_slice(array.to_owned());
+   |                          ^^^^^^^^^^^^^^^^ help: use: `array`
+
+error: unnecessary use of `to_owned`
+  --> $DIR/unnecessary_to_owned.rs:102:26
+   |
+LL |     require_as_ref_slice(array_ref.to_owned());
+   |                          ^^^^^^^^^^^^^^^^^^^^ help: use: `array_ref`
+
+error: unnecessary use of `to_owned`
+  --> $DIR/unnecessary_to_owned.rs:103:26
+   |
+LL |     require_as_ref_slice(slice.to_owned());
+   |                          ^^^^^^^^^^^^^^^^ help: use: `slice`
+
+error: unnecessary use of `to_owned`
+  --> $DIR/unnecessary_to_owned.rs:105:31
+   |
+LL |     require_impl_as_ref_c_str(c_str.to_owned());
+   |                               ^^^^^^^^^^^^^^^^ help: use: `c_str`
+
+error: unnecessary use of `to_owned`
+  --> $DIR/unnecessary_to_owned.rs:106:32
+   |
+LL |     require_impl_as_ref_os_str(os_str.to_owned());
+   |                                ^^^^^^^^^^^^^^^^^ help: use: `os_str`
+
+error: unnecessary use of `to_owned`
+  --> $DIR/unnecessary_to_owned.rs:107:30
+   |
+LL |     require_impl_as_ref_path(path.to_owned());
+   |                              ^^^^^^^^^^^^^^^ help: use: `path`
+
+error: unnecessary use of `to_owned`
+  --> $DIR/unnecessary_to_owned.rs:108:29
+   |
+LL |     require_impl_as_ref_str(s.to_owned());
+   |                             ^^^^^^^^^^^^ help: use: `s`
+
+error: unnecessary use of `to_owned`
+  --> $DIR/unnecessary_to_owned.rs:109:29
+   |
+LL |     require_impl_as_ref_str(x.to_owned());
+   |                             ^^^^^^^^^^^^ help: use: `&x`
+
+error: unnecessary use of `to_owned`
+  --> $DIR/unnecessary_to_owned.rs:110:31
+   |
+LL |     require_impl_as_ref_slice(array.to_owned());
+   |                               ^^^^^^^^^^^^^^^^ help: use: `array`
+
+error: unnecessary use of `to_owned`
+  --> $DIR/unnecessary_to_owned.rs:111:31
+   |
+LL |     require_impl_as_ref_slice(array_ref.to_owned());
+   |                               ^^^^^^^^^^^^^^^^^^^^ help: use: `array_ref`
+
+error: unnecessary use of `to_owned`
+  --> $DIR/unnecessary_to_owned.rs:112:31
+   |
+LL |     require_impl_as_ref_slice(slice.to_owned());
+   |                               ^^^^^^^^^^^^^^^^ help: use: `slice`
+
+error: unnecessary use of `to_owned`
+  --> $DIR/unnecessary_to_owned.rs:114:30
+   |
+LL |     require_as_ref_str_slice(s.to_owned(), array.to_owned());
+   |                              ^^^^^^^^^^^^ help: use: `s`
+
+error: unnecessary use of `to_owned`
+  --> $DIR/unnecessary_to_owned.rs:114:44
+   |
+LL |     require_as_ref_str_slice(s.to_owned(), array.to_owned());
+   |                                            ^^^^^^^^^^^^^^^^ help: use: `array`
+
+error: unnecessary use of `to_owned`
+  --> $DIR/unnecessary_to_owned.rs:115:30
+   |
+LL |     require_as_ref_str_slice(s.to_owned(), array_ref.to_owned());
+   |                              ^^^^^^^^^^^^ help: use: `s`
+
+error: unnecessary use of `to_owned`
+  --> $DIR/unnecessary_to_owned.rs:115:44
+   |
+LL |     require_as_ref_str_slice(s.to_owned(), array_ref.to_owned());
+   |                                            ^^^^^^^^^^^^^^^^^^^^ help: use: `array_ref`
+
+error: unnecessary use of `to_owned`
+  --> $DIR/unnecessary_to_owned.rs:116:30
+   |
+LL |     require_as_ref_str_slice(s.to_owned(), slice.to_owned());
+   |                              ^^^^^^^^^^^^ help: use: `s`
+
+error: unnecessary use of `to_owned`
+  --> $DIR/unnecessary_to_owned.rs:116:44
+   |
+LL |     require_as_ref_str_slice(s.to_owned(), slice.to_owned());
+   |                                            ^^^^^^^^^^^^^^^^ help: use: `slice`
+
+error: unnecessary use of `to_owned`
+  --> $DIR/unnecessary_to_owned.rs:117:30
+   |
+LL |     require_as_ref_slice_str(array.to_owned(), s.to_owned());
+   |                              ^^^^^^^^^^^^^^^^ help: use: `array`
+
+error: unnecessary use of `to_owned`
+  --> $DIR/unnecessary_to_owned.rs:117:48
+   |
+LL |     require_as_ref_slice_str(array.to_owned(), s.to_owned());
+   |                                                ^^^^^^^^^^^^ help: use: `s`
+
+error: unnecessary use of `to_owned`
+  --> $DIR/unnecessary_to_owned.rs:118:30
+   |
+LL |     require_as_ref_slice_str(array_ref.to_owned(), s.to_owned());
+   |                              ^^^^^^^^^^^^^^^^^^^^ help: use: `array_ref`
+
+error: unnecessary use of `to_owned`
+  --> $DIR/unnecessary_to_owned.rs:118:52
+   |
+LL |     require_as_ref_slice_str(array_ref.to_owned(), s.to_owned());
+   |                                                    ^^^^^^^^^^^^ help: use: `s`
+
+error: unnecessary use of `to_owned`
+  --> $DIR/unnecessary_to_owned.rs:119:30
+   |
+LL |     require_as_ref_slice_str(slice.to_owned(), s.to_owned());
+   |                              ^^^^^^^^^^^^^^^^ help: use: `slice`
+
+error: unnecessary use of `to_owned`
+  --> $DIR/unnecessary_to_owned.rs:119:48
+   |
+LL |     require_as_ref_slice_str(slice.to_owned(), s.to_owned());
+   |                                                ^^^^^^^^^^^^ help: use: `s`
+
+error: unnecessary use of `to_string`
+  --> $DIR/unnecessary_to_owned.rs:121:20
+   |
+LL |     let _ = x.join(&x.to_string());
+   |                    ^^^^^^^^^^^^^^ help: use: `&x`
+
+error: aborting due to 63 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 290f74be4e83fc610ad99d9c1cc1d7d5d96f2697 Mon Sep 17 00:00:00 2001
From: "Samuel E. Moelius III" <sam@moeli.us>
Date: Tue, 30 Nov 2021 05:52:01 -0500
Subject: Address review comments

* Share a list of methods with `implicit_clone`
* Ensure no overlap with `redundant_clone`
---
 clippy_lints/src/methods/implicit_clone.rs       | 26 +++++---
 clippy_lints/src/methods/unnecessary_to_owned.rs | 76 ++++++++++++++++--------
 clippy_utils/src/paths.rs                        |  2 -
 tests/ui/unnecessary_to_owned.fixed              | 27 +++++----
 tests/ui/unnecessary_to_owned.rs                 | 27 +++++----
 tests/ui/unnecessary_to_owned.stderr             | 69 +++++++++++++++++----
 6 files changed, 160 insertions(+), 67 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/implicit_clone.rs b/clippy_lints/src/methods/implicit_clone.rs
index 81c42de145f..ff7904ce582 100644
--- a/clippy_lints/src/methods/implicit_clone.rs
+++ b/clippy_lints/src/methods/implicit_clone.rs
@@ -12,15 +12,7 @@ use super::IMPLICIT_CLONE;
 pub fn check(cx: &LateContext<'_>, method_name: &str, expr: &hir::Expr<'_>, recv: &hir::Expr<'_>, span: Span) {
     if_chain! {
         if let Some(method_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
-        if match method_name {
-            "to_os_string" => is_diag_item_method(cx, method_def_id, sym::OsStr),
-            "to_owned" => is_diag_trait_item(cx, method_def_id, sym::ToOwned),
-            "to_path_buf" => is_diag_item_method(cx, method_def_id, sym::Path),
-            "to_vec" => cx.tcx.impl_of_method(method_def_id)
-                .map(|impl_did| Some(impl_did) == cx.tcx.lang_items().slice_alloc_impl())
-                == Some(true),
-            _ => false,
-        };
+        if is_clone_like(cx, method_name, method_def_id);
         let return_type = cx.typeck_results().expr_ty(expr);
         let input_type = cx.typeck_results().expr_ty(recv).peel_refs();
         if let Some(ty_name) = input_type.ty_adt_def().map(|adt_def| cx.tcx.item_name(adt_def.did));
@@ -38,3 +30,19 @@ pub fn check(cx: &LateContext<'_>, method_name: &str, expr: &hir::Expr<'_>, recv
         }
     }
 }
+
+/// Returns true if the named method can be used to clone the receiver.
+pub fn is_clone_like(cx: &LateContext<'_>, method_name: &str, method_def_id: hir::def_id::DefId) -> bool {
+    match method_name {
+        "to_os_string" => is_diag_item_method(cx, method_def_id, sym::OsStr),
+        "to_owned" => is_diag_trait_item(cx, method_def_id, sym::ToOwned),
+        "to_path_buf" => is_diag_item_method(cx, method_def_id, sym::Path),
+        "to_vec" => {
+            cx.tcx
+                .impl_of_method(method_def_id)
+                .map(|impl_did| Some(impl_did) == cx.tcx.lang_items().slice_alloc_impl())
+                == Some(true)
+        },
+        _ => false,
+    }
+}
diff --git a/clippy_lints/src/methods/unnecessary_to_owned.rs b/clippy_lints/src/methods/unnecessary_to_owned.rs
index 307de7bb65a..b380f734bff 100644
--- a/clippy_lints/src/methods/unnecessary_to_owned.rs
+++ b/clippy_lints/src/methods/unnecessary_to_owned.rs
@@ -1,7 +1,8 @@
+use super::implicit_clone::is_clone_like;
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::{implements_trait, is_copy, peel_mid_ty_refs};
-use clippy_utils::{get_parent_expr, match_def_path, paths};
+use clippy_utils::{get_parent_expr, is_diag_item_method, is_diag_trait_item};
 use rustc_errors::Applicability;
 use rustc_hir::{def_id::DefId, BorrowKind, Expr, ExprKind};
 use rustc_lint::LateContext;
@@ -14,28 +15,17 @@ use std::cmp::max;
 
 use super::UNNECESSARY_TO_OWNED;
 
-const TO_OWNED_LIKE_PATHS: &[&[&str]] = &[
-    &paths::COW_INTO_OWNED,
-    &paths::OS_STR_TO_OS_STRING,
-    &paths::PATH_TO_PATH_BUF,
-    &paths::SLICE_TO_VEC,
-    &paths::TO_OWNED_METHOD,
-    &paths::TO_STRING_METHOD,
-];
-
 pub fn check(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, method_name: Symbol, args: &'tcx [Expr<'tcx>]) {
     if_chain! {
         if let Some(method_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
-        if TO_OWNED_LIKE_PATHS
-            .iter()
-            .any(|path| match_def_path(cx, method_def_id, path));
+        if is_to_owned_like(cx, method_name, method_def_id);
         if let [receiver] = args;
         then {
             // At this point, we know the call is of a `to_owned`-like function. The functions
             // `check_addr_of_expr` and `check_call_arg` determine whether the call is unnecessary
             // based on its context, that is, whether it is a referent in an `AddrOf` expression or
             // an argument in a function call.
-            if check_addr_of_expr(cx, expr, method_name, receiver) {
+            if check_addr_of_expr(cx, expr, method_name, method_def_id, receiver) {
                 return;
             }
             check_call_arg(cx, expr, method_name, receiver);
@@ -45,10 +35,12 @@ pub fn check(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, method_name: Symbol
 
 /// Checks whether `expr` is a referent in an `AddrOf` expression and, if so, determines whether its
 /// call of a `to_owned`-like function is unnecessary.
+#[allow(clippy::too_many_lines)]
 fn check_addr_of_expr(
     cx: &LateContext<'tcx>,
     expr: &'tcx Expr<'tcx>,
     method_name: Symbol,
+    method_def_id: DefId,
     receiver: &'tcx Expr<'tcx>,
 ) -> bool {
     if_chain! {
@@ -100,14 +92,17 @@ fn check_addr_of_expr(
             ] => Some(target_ty),
             _ => None,
         };
+        let receiver_ty = cx.typeck_results().expr_ty(receiver);
+        // Only flag cases where the receiver is copyable or the method is `Cow::into_owned`. This
+        // restriction is to ensure there is not overlap between `redundant_clone` and this lint.
+        if is_copy(cx, receiver_ty) || is_cow_into_owned(cx, method_name, method_def_id);
+        if let Some(receiver_snippet) = snippet_opt(cx, receiver.span);
         then {
             let (target_ty, n_target_refs) = peel_mid_ty_refs(target_ty);
-            let receiver_ty = cx.typeck_results().expr_ty(receiver);
             let (receiver_ty, n_receiver_refs) = peel_mid_ty_refs(receiver_ty);
             if_chain! {
                 if receiver_ty == target_ty;
                 if n_target_refs >= n_receiver_refs;
-                if let Some(receiver_snippet) = snippet_opt(cx, receiver.span);
                 then {
                     span_lint_and_sugg(
                         cx,
@@ -122,21 +117,32 @@ fn check_addr_of_expr(
                 }
             }
             if implements_deref_trait(cx, receiver_ty, target_ty) {
-                span_lint_and_sugg(
-                    cx,
-                    UNNECESSARY_TO_OWNED,
-                    expr.span.with_lo(receiver.span.hi()),
-                    &format!("unnecessary use of `{}`", method_name),
-                    "remove this",
-                    String::new(),
-                    Applicability::MachineApplicable,
-                );
+                if n_receiver_refs > 0 {
+                    span_lint_and_sugg(
+                        cx,
+                        UNNECESSARY_TO_OWNED,
+                        parent.span,
+                        &format!("unnecessary use of `{}`", method_name),
+                        "use",
+                        receiver_snippet,
+                        Applicability::MachineApplicable,
+                    );
+                } else {
+                    span_lint_and_sugg(
+                        cx,
+                        UNNECESSARY_TO_OWNED,
+                        expr.span.with_lo(receiver.span.hi()),
+                        &format!("unnecessary use of `{}`", method_name),
+                        "remove this",
+                        String::new(),
+                        Applicability::MachineApplicable,
+                    );
+                }
                 return true;
             }
             if_chain! {
                 if let Some(as_ref_trait_id) = cx.tcx.get_diagnostic_item(sym::AsRef);
                 if implements_trait(cx, receiver_ty, as_ref_trait_id, &[GenericArg::from(target_ty)]);
-                if let Some(receiver_snippet) = snippet_opt(cx, receiver.span);
                 then {
                     span_lint_and_sugg(
                         cx,
@@ -326,3 +332,21 @@ fn implements_deref_trait(cx: &LateContext<'tcx>, ty: Ty<'tcx>, deref_target_ty:
         }
     }
 }
+
+/// Returns true if the named method can be used to convert the receiver to its "owned"
+/// representation.
+fn is_to_owned_like(cx: &LateContext<'_>, method_name: Symbol, method_def_id: DefId) -> bool {
+    is_clone_like(cx, &*method_name.as_str(), method_def_id)
+        || is_cow_into_owned(cx, method_name, method_def_id)
+        || is_to_string(cx, method_name, method_def_id)
+}
+
+/// Returns true if the named method is `Cow::into_owned`.
+fn is_cow_into_owned(cx: &LateContext<'_>, method_name: Symbol, method_def_id: DefId) -> bool {
+    method_name.as_str() == "into_owned" && is_diag_item_method(cx, method_def_id, sym::Cow)
+}
+
+/// Returns true if the named method is `ToString::to_string`.
+fn is_to_string(cx: &LateContext<'_>, method_name: Symbol, method_def_id: DefId) -> bool {
+    method_name.as_str() == "to_string" && is_diag_trait_item(cx, method_def_id, sym::ToString)
+}
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index 634a452d6f1..6171823abbb 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -36,7 +36,6 @@ pub const CLONE_TRAIT_METHOD: [&str; 4] = ["core", "clone", "Clone", "clone"];
 pub const CMP_MAX: [&str; 3] = ["core", "cmp", "max"];
 pub const CMP_MIN: [&str; 3] = ["core", "cmp", "min"];
 pub const COW: [&str; 3] = ["alloc", "borrow", "Cow"];
-pub const COW_INTO_OWNED: [&str; 4] = ["alloc", "borrow", "Cow", "into_owned"];
 pub const CSTRING_AS_C_STR: [&str; 5] = ["std", "ffi", "c_str", "CString", "as_c_str"];
 pub const DEFAULT_TRAIT_METHOD: [&str; 4] = ["core", "default", "Default", "default"];
 pub const DEREF_MUT_TRAIT_METHOD: [&str; 5] = ["core", "ops", "deref", "DerefMut", "deref_mut"];
@@ -171,7 +170,6 @@ pub const SLICE_FROM_RAW_PARTS: [&str; 4] = ["core", "slice", "raw", "from_raw_p
 pub const SLICE_FROM_RAW_PARTS_MUT: [&str; 4] = ["core", "slice", "raw", "from_raw_parts_mut"];
 pub const SLICE_INTO_VEC: [&str; 4] = ["alloc", "slice", "<impl [T]>", "into_vec"];
 pub const SLICE_ITER: [&str; 4] = ["core", "slice", "iter", "Iter"];
-pub const SLICE_TO_VEC: [&str; 4] = ["alloc", "slice", "<impl [T]>", "to_vec"];
 pub const STDERR: [&str; 4] = ["std", "io", "stdio", "stderr"];
 pub const STDOUT: [&str; 4] = ["std", "io", "stdio", "stdout"];
 pub const CONVERT_IDENTITY: [&str; 3] = ["core", "convert", "identity"];
diff --git a/tests/ui/unnecessary_to_owned.fixed b/tests/ui/unnecessary_to_owned.fixed
index f1a5dc91a7e..bd9ef1fff42 100644
--- a/tests/ui/unnecessary_to_owned.fixed
+++ b/tests/ui/unnecessary_to_owned.fixed
@@ -1,15 +1,14 @@
 // run-rustfix
 
 #![allow(clippy::ptr_arg)]
-// Some of the expressions that `redundant_clone` flags overlap with ours. Enabling it interferes
-// with `rustfix`.
-#![allow(clippy::redundant_clone)]
-// `needless_borrow` is for checking the fixed code.
+// `needless_borrow` is to ensure there are no needles borrows in the fixed code.
 #![warn(clippy::needless_borrow)]
+// `redundant_clone` is to ensure there is no overlap between that lint and this one.
+#![warn(clippy::redundant_clone)]
 #![warn(clippy::unnecessary_to_owned)]
 
 use std::borrow::Cow;
-use std::ffi::{CStr, OsStr};
+use std::ffi::{CStr, CString, OsStr, OsString};
 use std::ops::Deref;
 
 #[derive(Clone)]
@@ -51,6 +50,7 @@ fn main() {
     let array_ref = &["x"];
     let slice = &["x"][..];
     let x = X(String::from("x"));
+    let x_ref = &x;
 
     require_c_str(&Cow::from(c_str));
     require_c_str(c_str);
@@ -66,17 +66,17 @@ fn main() {
     require_str(s);
     require_str(&Cow::from(s));
     require_str(s);
-    require_str(x.as_ref());
+    require_str(x_ref.as_ref());
 
     require_slice(slice);
     require_slice(&Cow::from(slice));
     require_slice(array.as_ref());
     require_slice(array_ref.as_ref());
     require_slice(slice);
-    require_slice(&x);
+    require_slice(x_ref);
 
     require_x(&Cow::<X>::Owned(x.clone()));
-    require_x(&x);
+    require_x(x_ref);
 
     require_deref_c_str(c_str);
     require_deref_os_str(os_str);
@@ -118,16 +118,23 @@ fn main() {
     require_as_ref_slice_str(array_ref, s);
     require_as_ref_slice_str(slice, s);
 
-    let _ = x.join(&x);
+    let _ = x.join(x_ref);
 
     // negative tests
     require_string(&s.to_string());
     require_string(&Cow::from(s).into_owned());
     require_string(&s.to_owned());
-    require_string(&x.to_string());
+    require_string(&x_ref.to_string());
 
     // `X` isn't copy.
+    require_slice(&x.to_owned());
     require_deref_slice(x.to_owned());
+
+    // The following should be flagged by `redundant_clone`, but not by this lint.
+    require_c_str(&CString::from_vec_with_nul(vec![0]).unwrap());
+    require_os_str(&OsString::from("x"));
+    require_path(&std::path::PathBuf::from("x"));
+    require_str(&String::from("x"));
 }
 
 fn require_c_str(_: &CStr) {}
diff --git a/tests/ui/unnecessary_to_owned.rs b/tests/ui/unnecessary_to_owned.rs
index 081ff635bbd..1bf30e22893 100644
--- a/tests/ui/unnecessary_to_owned.rs
+++ b/tests/ui/unnecessary_to_owned.rs
@@ -1,15 +1,14 @@
 // run-rustfix
 
 #![allow(clippy::ptr_arg)]
-// Some of the expressions that `redundant_clone` flags overlap with ours. Enabling it interferes
-// with `rustfix`.
-#![allow(clippy::redundant_clone)]
-// `needless_borrow` is for checking the fixed code.
+// `needless_borrow` is to ensure there are no needles borrows in the fixed code.
 #![warn(clippy::needless_borrow)]
+// `redundant_clone` is to ensure there is no overlap between that lint and this one.
+#![warn(clippy::redundant_clone)]
 #![warn(clippy::unnecessary_to_owned)]
 
 use std::borrow::Cow;
-use std::ffi::{CStr, OsStr};
+use std::ffi::{CStr, CString, OsStr, OsString};
 use std::ops::Deref;
 
 #[derive(Clone)]
@@ -51,6 +50,7 @@ fn main() {
     let array_ref = &["x"];
     let slice = &["x"][..];
     let x = X(String::from("x"));
+    let x_ref = &x;
 
     require_c_str(&Cow::from(c_str).into_owned());
     require_c_str(&c_str.to_owned());
@@ -66,17 +66,17 @@ fn main() {
     require_str(&s.to_string());
     require_str(&Cow::from(s).into_owned());
     require_str(&s.to_owned());
-    require_str(&x.to_string());
+    require_str(&x_ref.to_string());
 
     require_slice(&slice.to_vec());
     require_slice(&Cow::from(slice).into_owned());
     require_slice(&array.to_owned());
     require_slice(&array_ref.to_owned());
     require_slice(&slice.to_owned());
-    require_slice(&x.to_owned());
+    require_slice(&x_ref.to_owned());
 
     require_x(&Cow::<X>::Owned(x.clone()).into_owned());
-    require_x(&x.to_owned());
+    require_x(&x_ref.to_owned());
 
     require_deref_c_str(c_str.to_owned());
     require_deref_os_str(os_str.to_owned());
@@ -118,16 +118,23 @@ fn main() {
     require_as_ref_slice_str(array_ref.to_owned(), s.to_owned());
     require_as_ref_slice_str(slice.to_owned(), s.to_owned());
 
-    let _ = x.join(&x.to_string());
+    let _ = x.join(&x_ref.to_string());
 
     // negative tests
     require_string(&s.to_string());
     require_string(&Cow::from(s).into_owned());
     require_string(&s.to_owned());
-    require_string(&x.to_string());
+    require_string(&x_ref.to_string());
 
     // `X` isn't copy.
+    require_slice(&x.to_owned());
     require_deref_slice(x.to_owned());
+
+    // The following should be flagged by `redundant_clone`, but not by this lint.
+    require_c_str(&CString::from_vec_with_nul(vec![0]).unwrap().to_owned());
+    require_os_str(&OsString::from("x").to_os_string());
+    require_path(&std::path::PathBuf::from("x").to_path_buf());
+    require_str(&String::from("x").to_string());
 }
 
 fn require_c_str(_: &CStr) {}
diff --git a/tests/ui/unnecessary_to_owned.stderr b/tests/ui/unnecessary_to_owned.stderr
index b15dd4c7ee7..83cc53ef3a2 100644
--- a/tests/ui/unnecessary_to_owned.stderr
+++ b/tests/ui/unnecessary_to_owned.stderr
@@ -1,3 +1,52 @@
+error: redundant clone
+  --> $DIR/unnecessary_to_owned.rs:134:64
+   |
+LL |     require_c_str(&CString::from_vec_with_nul(vec![0]).unwrap().to_owned());
+   |                                                                ^^^^^^^^^^^ help: remove this
+   |
+   = note: `-D clippy::redundant-clone` implied by `-D warnings`
+note: this value is dropped without further use
+  --> $DIR/unnecessary_to_owned.rs:134:20
+   |
+LL |     require_c_str(&CString::from_vec_with_nul(vec![0]).unwrap().to_owned());
+   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: redundant clone
+  --> $DIR/unnecessary_to_owned.rs:135:40
+   |
+LL |     require_os_str(&OsString::from("x").to_os_string());
+   |                                        ^^^^^^^^^^^^^^^ help: remove this
+   |
+note: this value is dropped without further use
+  --> $DIR/unnecessary_to_owned.rs:135:21
+   |
+LL |     require_os_str(&OsString::from("x").to_os_string());
+   |                     ^^^^^^^^^^^^^^^^^^^
+
+error: redundant clone
+  --> $DIR/unnecessary_to_owned.rs:136:48
+   |
+LL |     require_path(&std::path::PathBuf::from("x").to_path_buf());
+   |                                                ^^^^^^^^^^^^^^ help: remove this
+   |
+note: this value is dropped without further use
+  --> $DIR/unnecessary_to_owned.rs:136:19
+   |
+LL |     require_path(&std::path::PathBuf::from("x").to_path_buf());
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: redundant clone
+  --> $DIR/unnecessary_to_owned.rs:137:35
+   |
+LL |     require_str(&String::from("x").to_string());
+   |                                   ^^^^^^^^^^^^ help: remove this
+   |
+note: this value is dropped without further use
+  --> $DIR/unnecessary_to_owned.rs:137:18
+   |
+LL |     require_str(&String::from("x").to_string());
+   |                  ^^^^^^^^^^^^^^^^^
+
 error: unnecessary use of `into_owned`
   --> $DIR/unnecessary_to_owned.rs:55:36
    |
@@ -69,8 +118,8 @@ LL |     require_str(&s.to_owned());
 error: unnecessary use of `to_string`
   --> $DIR/unnecessary_to_owned.rs:69:17
    |
-LL |     require_str(&x.to_string());
-   |                 ^^^^^^^^^^^^^^ help: use: `x.as_ref()`
+LL |     require_str(&x_ref.to_string());
+   |                 ^^^^^^^^^^^^^^^^^^ help: use: `x_ref.as_ref()`
 
 error: unnecessary use of `to_vec`
   --> $DIR/unnecessary_to_owned.rs:71:19
@@ -103,10 +152,10 @@ LL |     require_slice(&slice.to_owned());
    |                   ^^^^^^^^^^^^^^^^^ help: use: `slice`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:76:21
+  --> $DIR/unnecessary_to_owned.rs:76:19
    |
-LL |     require_slice(&x.to_owned());
-   |                     ^^^^^^^^^^^ help: remove this
+LL |     require_slice(&x_ref.to_owned());
+   |                   ^^^^^^^^^^^^^^^^^ help: use: `x_ref`
 
 error: unnecessary use of `into_owned`
   --> $DIR/unnecessary_to_owned.rs:78:42
@@ -117,8 +166,8 @@ LL |     require_x(&Cow::<X>::Owned(x.clone()).into_owned());
 error: unnecessary use of `to_owned`
   --> $DIR/unnecessary_to_owned.rs:79:15
    |
-LL |     require_x(&x.to_owned());
-   |               ^^^^^^^^^^^^^ help: use: `&x`
+LL |     require_x(&x_ref.to_owned());
+   |               ^^^^^^^^^^^^^^^^^ help: use: `x_ref`
 
 error: unnecessary use of `to_owned`
   --> $DIR/unnecessary_to_owned.rs:81:25
@@ -375,8 +424,8 @@ LL |     require_as_ref_slice_str(slice.to_owned(), s.to_owned());
 error: unnecessary use of `to_string`
   --> $DIR/unnecessary_to_owned.rs:121:20
    |
-LL |     let _ = x.join(&x.to_string());
-   |                    ^^^^^^^^^^^^^^ help: use: `&x`
+LL |     let _ = x.join(&x_ref.to_string());
+   |                    ^^^^^^^^^^^^^^^^^^ help: use: `x_ref`
 
-error: aborting due to 63 previous errors
+error: aborting due to 67 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 3807905e08a8b5bee2160766d12b12ea4e71392f Mon Sep 17 00:00:00 2001
From: "Samuel E. Moelius III" <sam@moeli.us>
Date: Mon, 13 Dec 2021 05:49:43 -0500
Subject: Handle `to_vec` on for loop expression #8069

---
 clippy_lints/src/methods/mod.rs                    |   1 +
 .../src/methods/unnecessary_iter_cloned.rs         | 177 ++++++++++++++++++
 clippy_lints/src/methods/unnecessary_to_owned.rs   | 149 ++++++++++-----
 clippy_utils/src/ty.rs                             |  22 ++-
 clippy_utils/src/usage.rs                          |   2 +-
 tests/ui/unnecessary_iter_cloned.fixed             | 142 ++++++++++++++
 tests/ui/unnecessary_iter_cloned.rs                | 142 ++++++++++++++
 tests/ui/unnecessary_iter_cloned.stderr            |  35 ++++
 tests/ui/unnecessary_to_owned.fixed                |  45 ++++-
 tests/ui/unnecessary_to_owned.rs                   |  45 ++++-
 tests/ui/unnecessary_to_owned.stderr               | 208 ++++++++++++++-------
 11 files changed, 829 insertions(+), 139 deletions(-)
 create mode 100644 clippy_lints/src/methods/unnecessary_iter_cloned.rs
 create mode 100644 tests/ui/unnecessary_iter_cloned.fixed
 create mode 100644 tests/ui/unnecessary_iter_cloned.rs
 create mode 100644 tests/ui/unnecessary_iter_cloned.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index a0de296fd07..6a61e662698 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -56,6 +56,7 @@ mod suspicious_splitn;
 mod uninit_assumed_init;
 mod unnecessary_filter_map;
 mod unnecessary_fold;
+mod unnecessary_iter_cloned;
 mod unnecessary_lazy_eval;
 mod unnecessary_to_owned;
 mod unwrap_or_else_default;
diff --git a/clippy_lints/src/methods/unnecessary_iter_cloned.rs b/clippy_lints/src/methods/unnecessary_iter_cloned.rs
new file mode 100644
index 00000000000..8300df03e99
--- /dev/null
+++ b/clippy_lints/src/methods/unnecessary_iter_cloned.rs
@@ -0,0 +1,177 @@
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::higher::ForLoop;
+use clippy_utils::source::snippet_opt;
+use clippy_utils::ty::{get_associated_type, get_iterator_item_ty, implements_trait};
+use clippy_utils::{fn_def_id, get_parent_expr, path_to_local_id, usage};
+use rustc_errors::Applicability;
+use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
+use rustc_hir::{def_id::DefId, BorrowKind, Expr, ExprKind, HirId, LangItem, Mutability, Pat};
+use rustc_lint::LateContext;
+use rustc_middle::{hir::map::Map, ty};
+use rustc_span::{sym, Symbol};
+
+use super::UNNECESSARY_TO_OWNED;
+
+pub fn check(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, method_name: Symbol, receiver: &'tcx Expr<'tcx>) -> bool {
+    if_chain! {
+        if let Some(parent) = get_parent_expr(cx, expr);
+        if let Some(callee_def_id) = fn_def_id(cx, parent);
+        if is_into_iter(cx, callee_def_id);
+        then {
+            check_for_loop_iter(cx, parent, method_name, receiver)
+        } else {
+            false
+        }
+    }
+}
+
+/// Checks whether `expr` is an iterator in a `for` loop and, if so, determines whether the
+/// iterated-over items could be iterated over by reference. The reason why `check` above does not
+/// include this code directly is so that it can be called from
+/// `unnecessary_into_owned::check_into_iter_call_arg`.
+pub fn check_for_loop_iter(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx Expr<'tcx>,
+    method_name: Symbol,
+    receiver: &'tcx Expr<'tcx>,
+) -> bool {
+    if_chain! {
+        if let Some(grandparent) = get_parent_expr(cx, expr).and_then(|parent| get_parent_expr(cx, parent));
+        if let Some(ForLoop { pat, body, .. }) = ForLoop::hir(grandparent);
+        let (clone_or_copy_needed, addr_of_exprs) = clone_or_copy_needed(cx, pat, body);
+        if !clone_or_copy_needed;
+        if let Some(receiver_snippet) = snippet_opt(cx, receiver.span);
+        then {
+            let snippet = if_chain! {
+                if let ExprKind::MethodCall(maybe_iter_method_name, _, [collection], _) = receiver.kind;
+                if maybe_iter_method_name.ident.name == sym::iter;
+
+                if let Some(iterator_trait_id) = cx.tcx.get_diagnostic_item(sym::Iterator);
+                let receiver_ty = cx.typeck_results().expr_ty(receiver);
+                if implements_trait(cx, receiver_ty, iterator_trait_id, &[]);
+                if let Some(iter_item_ty) = get_iterator_item_ty(cx, receiver_ty);
+
+                if let Some(into_iterator_trait_id) = cx.tcx.get_diagnostic_item(sym::IntoIterator);
+                let collection_ty = cx.typeck_results().expr_ty(collection);
+                if implements_trait(cx, collection_ty, into_iterator_trait_id, &[]);
+                if let Some(into_iter_item_ty) = get_associated_type(cx, collection_ty, into_iterator_trait_id, "Item");
+
+                if iter_item_ty == into_iter_item_ty;
+                if let Some(collection_snippet) = snippet_opt(cx, collection.span);
+                then {
+                    collection_snippet
+                } else {
+                    receiver_snippet
+                }
+            };
+            span_lint_and_then(
+                cx,
+                UNNECESSARY_TO_OWNED,
+                expr.span,
+                &format!("unnecessary use of `{}`", method_name),
+                |diag| {
+                    diag.span_suggestion(expr.span, "use", snippet, Applicability::MachineApplicable);
+                    for addr_of_expr in addr_of_exprs {
+                        match addr_of_expr.kind {
+                            ExprKind::AddrOf(_, _, referent) => {
+                                let span = addr_of_expr.span.with_hi(referent.span.lo());
+                                diag.span_suggestion(span, "remove this `&`", String::new(), Applicability::MachineApplicable);
+                            }
+                            _ => unreachable!(),
+                        }
+                    }
+                }
+            );
+            return true;
+        }
+    }
+    false
+}
+
+/// The core logic of `check_for_loop_iter` above, this function wraps a use of
+/// `CloneOrCopyVisitor`.
+fn clone_or_copy_needed(
+    cx: &LateContext<'tcx>,
+    pat: &Pat<'tcx>,
+    body: &'tcx Expr<'tcx>,
+) -> (bool, Vec<&'tcx Expr<'tcx>>) {
+    let mut visitor = CloneOrCopyVisitor {
+        cx,
+        binding_hir_ids: pat_bindings(pat),
+        clone_or_copy_needed: false,
+        addr_of_exprs: Vec::new(),
+    };
+    visitor.visit_expr(body);
+    (visitor.clone_or_copy_needed, visitor.addr_of_exprs)
+}
+
+/// Returns a vector of all `HirId`s bound by the pattern.
+fn pat_bindings(pat: &Pat<'_>) -> Vec<HirId> {
+    let mut collector = usage::ParamBindingIdCollector {
+        binding_hir_ids: Vec::new(),
+    };
+    collector.visit_pat(pat);
+    collector.binding_hir_ids
+}
+
+/// `clone_or_copy_needed` will be false when `CloneOrCopyVisitor` is done visiting if the only
+/// operations performed on `binding_hir_ids` are:
+/// * to take non-mutable references to them
+/// * to use them as non-mutable `&self` in method calls
+/// If any of `binding_hir_ids` is used in any other way, then `clone_or_copy_needed` will be true
+/// when `CloneOrCopyVisitor` is done visiting.
+struct CloneOrCopyVisitor<'cx, 'tcx> {
+    cx: &'cx LateContext<'tcx>,
+    binding_hir_ids: Vec<HirId>,
+    clone_or_copy_needed: bool,
+    addr_of_exprs: Vec<&'tcx Expr<'tcx>>,
+}
+
+impl<'cx, 'tcx> Visitor<'tcx> for CloneOrCopyVisitor<'cx, 'tcx> {
+    type Map = Map<'tcx>;
+
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::OnlyBodies(self.cx.tcx.hir())
+    }
+
+    fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) {
+        walk_expr(self, expr);
+        if self.is_binding(expr) {
+            if let Some(parent) = get_parent_expr(self.cx, expr) {
+                match parent.kind {
+                    ExprKind::AddrOf(BorrowKind::Ref, Mutability::Not, _) => {
+                        self.addr_of_exprs.push(parent);
+                        return;
+                    },
+                    ExprKind::MethodCall(_, _, args, _) => {
+                        if_chain! {
+                            if args.iter().skip(1).all(|arg| !self.is_binding(arg));
+                            if let Some(method_def_id) = self.cx.typeck_results().type_dependent_def_id(parent.hir_id);
+                            let method_ty = self.cx.tcx.type_of(method_def_id);
+                            let self_ty = method_ty.fn_sig(self.cx.tcx).input(0).skip_binder();
+                            if matches!(self_ty.kind(), ty::Ref(_, _, Mutability::Not));
+                            then {
+                                return;
+                            }
+                        }
+                    },
+                    _ => {},
+                }
+            }
+            self.clone_or_copy_needed = true;
+        }
+    }
+}
+
+impl<'cx, 'tcx> CloneOrCopyVisitor<'cx, 'tcx> {
+    fn is_binding(&self, expr: &Expr<'tcx>) -> bool {
+        self.binding_hir_ids
+            .iter()
+            .any(|hir_id| path_to_local_id(expr, *hir_id))
+    }
+}
+
+/// Returns true if the named method is `IntoIterator::into_iter`.
+pub fn is_into_iter(cx: &LateContext<'_>, callee_def_id: DefId) -> bool {
+    cx.tcx.lang_items().require(LangItem::IntoIterIntoIter) == Ok(callee_def_id)
+}
diff --git a/clippy_lints/src/methods/unnecessary_to_owned.rs b/clippy_lints/src/methods/unnecessary_to_owned.rs
index b380f734bff..c5af7483ae6 100644
--- a/clippy_lints/src/methods/unnecessary_to_owned.rs
+++ b/clippy_lints/src/methods/unnecessary_to_owned.rs
@@ -1,8 +1,9 @@
 use super::implicit_clone::is_clone_like;
+use super::unnecessary_iter_cloned::{self, is_into_iter};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_opt;
-use clippy_utils::ty::{implements_trait, is_copy, peel_mid_ty_refs};
-use clippy_utils::{get_parent_expr, is_diag_item_method, is_diag_trait_item};
+use clippy_utils::ty::{get_associated_type, get_iterator_item_ty, implements_trait, is_copy, peel_mid_ty_refs};
+use clippy_utils::{fn_def_id, get_parent_expr, is_diag_item_method, is_diag_trait_item};
 use rustc_errors::Applicability;
 use rustc_hir::{def_id::DefId, BorrowKind, Expr, ExprKind};
 use rustc_lint::LateContext;
@@ -18,17 +19,23 @@ use super::UNNECESSARY_TO_OWNED;
 pub fn check(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, method_name: Symbol, args: &'tcx [Expr<'tcx>]) {
     if_chain! {
         if let Some(method_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
-        if is_to_owned_like(cx, method_name, method_def_id);
         if let [receiver] = args;
         then {
-            // At this point, we know the call is of a `to_owned`-like function. The functions
-            // `check_addr_of_expr` and `check_call_arg` determine whether the call is unnecessary
-            // based on its context, that is, whether it is a referent in an `AddrOf` expression or
-            // an argument in a function call.
-            if check_addr_of_expr(cx, expr, method_name, method_def_id, receiver) {
-                return;
+            if is_cloned_or_copied(cx, method_name, method_def_id) {
+                unnecessary_iter_cloned::check(cx, expr, method_name, receiver);
+            } else if is_to_owned_like(cx, method_name, method_def_id) {
+                // At this point, we know the call is of a `to_owned`-like function. The functions
+                // `check_addr_of_expr` and `check_call_arg` determine whether the call is unnecessary
+                // based on its context, that is, whether it is a referent in an `AddrOf` expression, an
+                // argument in a `into_iter` call, or an argument in the call of some other function.
+                if check_addr_of_expr(cx, expr, method_name, method_def_id, receiver) {
+                    return;
+                }
+                if check_into_iter_call_arg(cx, expr, method_name, receiver) {
+                    return;
+                }
+                check_other_call_arg(cx, expr, method_name, receiver);
             }
-            check_call_arg(cx, expr, method_name, receiver);
         }
     }
 }
@@ -116,29 +123,34 @@ fn check_addr_of_expr(
                     return true;
                 }
             }
-            if implements_deref_trait(cx, receiver_ty, target_ty) {
-                if n_receiver_refs > 0 {
-                    span_lint_and_sugg(
-                        cx,
-                        UNNECESSARY_TO_OWNED,
-                        parent.span,
-                        &format!("unnecessary use of `{}`", method_name),
-                        "use",
-                        receiver_snippet,
-                        Applicability::MachineApplicable,
-                    );
-                } else {
-                    span_lint_and_sugg(
-                        cx,
-                        UNNECESSARY_TO_OWNED,
-                        expr.span.with_lo(receiver.span.hi()),
-                        &format!("unnecessary use of `{}`", method_name),
-                        "remove this",
-                        String::new(),
-                        Applicability::MachineApplicable,
-                    );
+            if_chain! {
+                if let Some(deref_trait_id) = cx.tcx.get_diagnostic_item(sym::Deref);
+                if implements_trait(cx, receiver_ty, deref_trait_id, &[]);
+                if get_associated_type(cx, receiver_ty, deref_trait_id, "Target") == Some(target_ty);
+                then {
+                    if n_receiver_refs > 0 {
+                        span_lint_and_sugg(
+                            cx,
+                            UNNECESSARY_TO_OWNED,
+                            parent.span,
+                            &format!("unnecessary use of `{}`", method_name),
+                            "use",
+                            receiver_snippet,
+                            Applicability::MachineApplicable,
+                        );
+                    } else {
+                        span_lint_and_sugg(
+                            cx,
+                            UNNECESSARY_TO_OWNED,
+                            expr.span.with_lo(receiver.span.hi()),
+                            &format!("unnecessary use of `{}`", method_name),
+                            "remove this",
+                            String::new(),
+                            Applicability::MachineApplicable,
+                        );
+                    }
+                    return true;
                 }
-                return true;
             }
             if_chain! {
                 if let Some(as_ref_trait_id) = cx.tcx.get_diagnostic_item(sym::AsRef);
@@ -161,9 +173,55 @@ fn check_addr_of_expr(
     false
 }
 
+/// Checks whether `expr` is an argument in an `into_iter` call and, if so, determines whether its
+/// call of a `to_owned`-like function is unnecessary.
+fn check_into_iter_call_arg(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx Expr<'tcx>,
+    method_name: Symbol,
+    receiver: &'tcx Expr<'tcx>,
+) -> bool {
+    if_chain! {
+        if let Some(parent) = get_parent_expr(cx, expr);
+        if let Some(callee_def_id) = fn_def_id(cx, parent);
+        if is_into_iter(cx, callee_def_id);
+        if let Some(iterator_trait_id) = cx.tcx.get_diagnostic_item(sym::Iterator);
+        let parent_ty = cx.typeck_results().expr_ty(parent);
+        if implements_trait(cx, parent_ty, iterator_trait_id, &[]);
+        if let Some(item_ty) = get_iterator_item_ty(cx, parent_ty);
+        if let Some(receiver_snippet) = snippet_opt(cx, receiver.span);
+        then {
+            if unnecessary_iter_cloned::check_for_loop_iter(cx, parent, method_name, receiver) {
+                return true;
+            }
+            let cloned_or_copied = if is_copy(cx, item_ty) {
+                "copied"
+            } else {
+                "cloned"
+            };
+            span_lint_and_sugg(
+                cx,
+                UNNECESSARY_TO_OWNED,
+                parent.span,
+                &format!("unnecessary use of `{}`", method_name),
+                "use",
+                format!("{}.iter().{}()", receiver_snippet, cloned_or_copied),
+                Applicability::MachineApplicable,
+            );
+            return true;
+        }
+    }
+    false
+}
+
 /// Checks whether `expr` is an argument in a function call and, if so, determines whether its call
 /// of a `to_owned`-like function is unnecessary.
-fn check_call_arg(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, method_name: Symbol, receiver: &'tcx Expr<'tcx>) {
+fn check_other_call_arg(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx Expr<'tcx>,
+    method_name: Symbol,
+    receiver: &'tcx Expr<'tcx>,
+) -> bool {
     if_chain! {
         if let Some((maybe_call, maybe_arg)) = skip_addr_of_ancestors(cx, expr);
         if let Some((callee_def_id, call_substs, call_args)) = get_callee_substs_and_args(cx, maybe_call);
@@ -186,7 +244,8 @@ fn check_call_arg(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, method_name: S
             if let [projection_predicate] = projection_predicates[..] {
                 let normalized_ty =
                     cx.tcx.subst_and_normalize_erasing_regions(call_substs, cx.param_env, projection_predicate.ty);
-                implements_deref_trait(cx, receiver_ty, normalized_ty)
+                implements_trait(cx, receiver_ty, deref_trait_id, &[])
+                    && get_associated_type(cx, receiver_ty, deref_trait_id, "Target") == Some(normalized_ty)
             } else {
                 false
             }
@@ -215,8 +274,10 @@ fn check_call_arg(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, method_name: S
                 format!("{:&>width$}{}", "", receiver_snippet, width = n_refs),
                 Applicability::MachineApplicable,
             );
+            return true;
         }
     }
+    false
 }
 
 /// Walks an expression's ancestors until it finds a non-`AddrOf` expression. Returns the first such
@@ -315,22 +376,10 @@ fn compose_substs(cx: &LateContext<'tcx>, left: &[GenericArg<'tcx>], right: Subs
         .collect()
 }
 
-/// Helper function to check whether a type implements the `Deref` trait.
-fn implements_deref_trait(cx: &LateContext<'tcx>, ty: Ty<'tcx>, deref_target_ty: Ty<'tcx>) -> bool {
-    if_chain! {
-        if let Some(deref_trait_id) = cx.tcx.get_diagnostic_item(sym::Deref);
-        if implements_trait(cx, ty, deref_trait_id, &[]);
-        if let Some(deref_target_id) = cx.tcx.lang_items().deref_target();
-        let substs = cx.tcx.mk_substs_trait(ty, &[]);
-        let projection_ty = cx.tcx.mk_projection(deref_target_id, substs);
-        let normalized_ty = cx.tcx.normalize_erasing_regions(cx.param_env, projection_ty);
-        if normalized_ty == deref_target_ty;
-        then {
-            true
-        } else {
-            false
-        }
-    }
+/// Returns true if the named method is `Iterator::cloned` or `Iterator::copied`.
+fn is_cloned_or_copied(cx: &LateContext<'_>, method_name: Symbol, method_def_id: DefId) -> bool {
+    (method_name.as_str() == "cloned" || method_name.as_str() == "copied")
+        && is_diag_trait_item(cx, method_def_id, sym::Iterator)
 }
 
 /// Returns true if the named method can be used to convert the receiver to its "owned"
diff --git a/clippy_utils/src/ty.rs b/clippy_utils/src/ty.rs
index 438c39bea0a..6d191d4a59b 100644
--- a/clippy_utils/src/ty.rs
+++ b/clippy_utils/src/ty.rs
@@ -58,14 +58,20 @@ pub fn contains_adt_constructor<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>, adt: &'tc
 pub fn get_iterator_item_ty<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Option<Ty<'tcx>> {
     cx.tcx
         .get_diagnostic_item(sym::Iterator)
-        .and_then(|iter_did| {
-            cx.tcx.associated_items(iter_did).find_by_name_and_kind(
-                cx.tcx,
-                Ident::from_str("Item"),
-                ty::AssocKind::Type,
-                iter_did,
-            )
-        })
+        .and_then(|iter_did| get_associated_type(cx, ty, iter_did, "Item"))
+}
+
+/// Returns the associated type `name` for `ty` as an implementation of `trait_id`.
+/// Do not invoke without first verifying that the type implements the trait.
+pub fn get_associated_type<'tcx>(
+    cx: &LateContext<'tcx>,
+    ty: Ty<'tcx>,
+    trait_id: DefId,
+    name: &str,
+) -> Option<Ty<'tcx>> {
+    cx.tcx
+        .associated_items(trait_id)
+        .find_by_name_and_kind(cx.tcx, Ident::from_str(name), ty::AssocKind::Type, trait_id)
         .map(|assoc| {
             let proj = cx.tcx.mk_projection(assoc.def_id, cx.tcx.mk_substs_trait(ty, &[]));
             cx.tcx.normalize_erasing_regions(cx.param_env, proj)
diff --git a/clippy_utils/src/usage.rs b/clippy_utils/src/usage.rs
index dfe8a66c2a1..2066915e1d1 100644
--- a/clippy_utils/src/usage.rs
+++ b/clippy_utils/src/usage.rs
@@ -78,7 +78,7 @@ impl<'tcx> Delegate<'tcx> for MutVarsDelegate {
 }
 
 pub struct ParamBindingIdCollector {
-    binding_hir_ids: Vec<hir::HirId>,
+    pub binding_hir_ids: Vec<hir::HirId>,
 }
 impl<'tcx> ParamBindingIdCollector {
     fn collect_binding_hir_ids(body: &'tcx hir::Body<'tcx>) -> Vec<hir::HirId> {
diff --git a/tests/ui/unnecessary_iter_cloned.fixed b/tests/ui/unnecessary_iter_cloned.fixed
new file mode 100644
index 00000000000..e01e9f07baf
--- /dev/null
+++ b/tests/ui/unnecessary_iter_cloned.fixed
@@ -0,0 +1,142 @@
+// run-rustfix
+
+#![allow(unused_assignments)]
+#![warn(clippy::unnecessary_to_owned)]
+
+#[allow(dead_code)]
+#[derive(Clone, Copy)]
+enum FileType {
+    Account,
+    PrivateKey,
+    Certificate,
+}
+
+fn main() {
+    let path = std::path::Path::new("x");
+
+    let _ = check_files(&[(FileType::Account, path)]);
+    let _ = check_files_vec(vec![(FileType::Account, path)]);
+
+    // negative tests
+    let _ = check_files_ref(&[(FileType::Account, path)]);
+    let _ = check_files_mut(&[(FileType::Account, path)]);
+    let _ = check_files_ref_mut(&[(FileType::Account, path)]);
+    let _ = check_files_self_and_arg(&[(FileType::Account, path)]);
+    let _ = check_files_mut_path_buf(&[(FileType::Account, std::path::PathBuf::new())]);
+}
+
+// `check_files` and its variants are based on:
+// https://github.com/breard-r/acmed/blob/1f0dcc32aadbc5e52de6d23b9703554c0f925113/acmed/src/storage.rs#L262
+fn check_files(files: &[(FileType, &std::path::Path)]) -> bool {
+    for (t, path) in files {
+        let other = match get_file_path(t) {
+            Ok(p) => p,
+            Err(_) => {
+                return false;
+            },
+        };
+        if !path.is_file() || !other.is_file() {
+            return false;
+        }
+    }
+    true
+}
+
+fn check_files_vec(files: Vec<(FileType, &std::path::Path)>) -> bool {
+    for (t, path) in files.iter() {
+        let other = match get_file_path(t) {
+            Ok(p) => p,
+            Err(_) => {
+                return false;
+            },
+        };
+        if !path.is_file() || !other.is_file() {
+            return false;
+        }
+    }
+    true
+}
+
+fn check_files_ref(files: &[(FileType, &std::path::Path)]) -> bool {
+    for (ref t, path) in files.iter().copied() {
+        let other = match get_file_path(t) {
+            Ok(p) => p,
+            Err(_) => {
+                return false;
+            },
+        };
+        if !path.is_file() || !other.is_file() {
+            return false;
+        }
+    }
+    true
+}
+
+#[allow(unused_assignments)]
+fn check_files_mut(files: &[(FileType, &std::path::Path)]) -> bool {
+    for (mut t, path) in files.iter().copied() {
+        t = FileType::PrivateKey;
+        let other = match get_file_path(&t) {
+            Ok(p) => p,
+            Err(_) => {
+                return false;
+            },
+        };
+        if !path.is_file() || !other.is_file() {
+            return false;
+        }
+    }
+    true
+}
+
+fn check_files_ref_mut(files: &[(FileType, &std::path::Path)]) -> bool {
+    for (ref mut t, path) in files.iter().copied() {
+        *t = FileType::PrivateKey;
+        let other = match get_file_path(t) {
+            Ok(p) => p,
+            Err(_) => {
+                return false;
+            },
+        };
+        if !path.is_file() || !other.is_file() {
+            return false;
+        }
+    }
+    true
+}
+
+fn check_files_self_and_arg(files: &[(FileType, &std::path::Path)]) -> bool {
+    for (t, path) in files.iter().copied() {
+        let other = match get_file_path(&t) {
+            Ok(p) => p,
+            Err(_) => {
+                return false;
+            },
+        };
+        if !path.join(path).is_file() || !other.is_file() {
+            return false;
+        }
+    }
+    true
+}
+
+#[allow(unused_assignments)]
+fn check_files_mut_path_buf(files: &[(FileType, std::path::PathBuf)]) -> bool {
+    for (mut t, path) in files.iter().cloned() {
+        t = FileType::PrivateKey;
+        let other = match get_file_path(&t) {
+            Ok(p) => p,
+            Err(_) => {
+                return false;
+            },
+        };
+        if !path.is_file() || !other.is_file() {
+            return false;
+        }
+    }
+    true
+}
+
+fn get_file_path(_file_type: &FileType) -> Result<std::path::PathBuf, std::io::Error> {
+    Ok(std::path::PathBuf::new())
+}
diff --git a/tests/ui/unnecessary_iter_cloned.rs b/tests/ui/unnecessary_iter_cloned.rs
new file mode 100644
index 00000000000..6ef2966c8b7
--- /dev/null
+++ b/tests/ui/unnecessary_iter_cloned.rs
@@ -0,0 +1,142 @@
+// run-rustfix
+
+#![allow(unused_assignments)]
+#![warn(clippy::unnecessary_to_owned)]
+
+#[allow(dead_code)]
+#[derive(Clone, Copy)]
+enum FileType {
+    Account,
+    PrivateKey,
+    Certificate,
+}
+
+fn main() {
+    let path = std::path::Path::new("x");
+
+    let _ = check_files(&[(FileType::Account, path)]);
+    let _ = check_files_vec(vec![(FileType::Account, path)]);
+
+    // negative tests
+    let _ = check_files_ref(&[(FileType::Account, path)]);
+    let _ = check_files_mut(&[(FileType::Account, path)]);
+    let _ = check_files_ref_mut(&[(FileType::Account, path)]);
+    let _ = check_files_self_and_arg(&[(FileType::Account, path)]);
+    let _ = check_files_mut_path_buf(&[(FileType::Account, std::path::PathBuf::new())]);
+}
+
+// `check_files` and its variants are based on:
+// https://github.com/breard-r/acmed/blob/1f0dcc32aadbc5e52de6d23b9703554c0f925113/acmed/src/storage.rs#L262
+fn check_files(files: &[(FileType, &std::path::Path)]) -> bool {
+    for (t, path) in files.iter().copied() {
+        let other = match get_file_path(&t) {
+            Ok(p) => p,
+            Err(_) => {
+                return false;
+            },
+        };
+        if !path.is_file() || !other.is_file() {
+            return false;
+        }
+    }
+    true
+}
+
+fn check_files_vec(files: Vec<(FileType, &std::path::Path)>) -> bool {
+    for (t, path) in files.iter().copied() {
+        let other = match get_file_path(&t) {
+            Ok(p) => p,
+            Err(_) => {
+                return false;
+            },
+        };
+        if !path.is_file() || !other.is_file() {
+            return false;
+        }
+    }
+    true
+}
+
+fn check_files_ref(files: &[(FileType, &std::path::Path)]) -> bool {
+    for (ref t, path) in files.iter().copied() {
+        let other = match get_file_path(t) {
+            Ok(p) => p,
+            Err(_) => {
+                return false;
+            },
+        };
+        if !path.is_file() || !other.is_file() {
+            return false;
+        }
+    }
+    true
+}
+
+#[allow(unused_assignments)]
+fn check_files_mut(files: &[(FileType, &std::path::Path)]) -> bool {
+    for (mut t, path) in files.iter().copied() {
+        t = FileType::PrivateKey;
+        let other = match get_file_path(&t) {
+            Ok(p) => p,
+            Err(_) => {
+                return false;
+            },
+        };
+        if !path.is_file() || !other.is_file() {
+            return false;
+        }
+    }
+    true
+}
+
+fn check_files_ref_mut(files: &[(FileType, &std::path::Path)]) -> bool {
+    for (ref mut t, path) in files.iter().copied() {
+        *t = FileType::PrivateKey;
+        let other = match get_file_path(t) {
+            Ok(p) => p,
+            Err(_) => {
+                return false;
+            },
+        };
+        if !path.is_file() || !other.is_file() {
+            return false;
+        }
+    }
+    true
+}
+
+fn check_files_self_and_arg(files: &[(FileType, &std::path::Path)]) -> bool {
+    for (t, path) in files.iter().copied() {
+        let other = match get_file_path(&t) {
+            Ok(p) => p,
+            Err(_) => {
+                return false;
+            },
+        };
+        if !path.join(path).is_file() || !other.is_file() {
+            return false;
+        }
+    }
+    true
+}
+
+#[allow(unused_assignments)]
+fn check_files_mut_path_buf(files: &[(FileType, std::path::PathBuf)]) -> bool {
+    for (mut t, path) in files.iter().cloned() {
+        t = FileType::PrivateKey;
+        let other = match get_file_path(&t) {
+            Ok(p) => p,
+            Err(_) => {
+                return false;
+            },
+        };
+        if !path.is_file() || !other.is_file() {
+            return false;
+        }
+    }
+    true
+}
+
+fn get_file_path(_file_type: &FileType) -> Result<std::path::PathBuf, std::io::Error> {
+    Ok(std::path::PathBuf::new())
+}
diff --git a/tests/ui/unnecessary_iter_cloned.stderr b/tests/ui/unnecessary_iter_cloned.stderr
new file mode 100644
index 00000000000..e44379f8aa0
--- /dev/null
+++ b/tests/ui/unnecessary_iter_cloned.stderr
@@ -0,0 +1,35 @@
+error: unnecessary use of `copied`
+  --> $DIR/unnecessary_iter_cloned.rs:31:22
+   |
+LL |     for (t, path) in files.iter().copied() {
+   |                      ^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::unnecessary-to-owned` implied by `-D warnings`
+help: use
+   |
+LL |     for (t, path) in files {
+   |                      ~~~~~
+help: remove this `&`
+   |
+LL -         let other = match get_file_path(&t) {
+LL +         let other = match get_file_path(t) {
+   | 
+
+error: unnecessary use of `copied`
+  --> $DIR/unnecessary_iter_cloned.rs:46:22
+   |
+LL |     for (t, path) in files.iter().copied() {
+   |                      ^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use
+   |
+LL |     for (t, path) in files.iter() {
+   |                      ~~~~~~~~~~~~
+help: remove this `&`
+   |
+LL -         let other = match get_file_path(&t) {
+LL +         let other = match get_file_path(t) {
+   | 
+
+error: aborting due to 2 previous errors
+
diff --git a/tests/ui/unnecessary_to_owned.fixed b/tests/ui/unnecessary_to_owned.fixed
index bd9ef1fff42..720138db137 100644
--- a/tests/ui/unnecessary_to_owned.fixed
+++ b/tests/ui/unnecessary_to_owned.fixed
@@ -1,10 +1,6 @@
 // run-rustfix
 
 #![allow(clippy::ptr_arg)]
-// `needless_borrow` is to ensure there are no needles borrows in the fixed code.
-#![warn(clippy::needless_borrow)]
-// `redundant_clone` is to ensure there is no overlap between that lint and this one.
-#![warn(clippy::redundant_clone)]
 #![warn(clippy::unnecessary_to_owned)]
 
 use std::borrow::Cow;
@@ -41,6 +37,14 @@ impl X {
     }
 }
 
+#[allow(dead_code)]
+#[derive(Clone)]
+enum FileType {
+    Account,
+    PrivateKey,
+    Certificate,
+}
+
 fn main() {
     let c_str = CStr::from_bytes_with_nul(&[0]).unwrap();
     let os_str = OsStr::new("x");
@@ -120,6 +124,18 @@ fn main() {
 
     let _ = x.join(x_ref);
 
+    let _ = slice.iter().copied();
+    let _ = slice.iter().copied();
+    let _ = [std::path::PathBuf::new()][..].iter().cloned();
+    let _ = [std::path::PathBuf::new()][..].iter().cloned();
+
+    let _ = slice.iter().copied();
+    let _ = slice.iter().copied();
+    let _ = [std::path::PathBuf::new()][..].iter().cloned();
+    let _ = [std::path::PathBuf::new()][..].iter().cloned();
+
+    let _ = check_files(&[FileType::Account]);
+
     // negative tests
     require_string(&s.to_string());
     require_string(&Cow::from(s).into_owned());
@@ -174,4 +190,25 @@ fn require_impl_as_ref_slice<T>(_: impl AsRef<[T]>) {}
 fn require_as_ref_str_slice<T: AsRef<str>, U, V: AsRef<[U]>>(_: T, _: V) {}
 fn require_as_ref_slice_str<T, U: AsRef<[T]>, V: AsRef<str>>(_: U, _: V) {}
 
+// `check_files` is based on:
+// https://github.com/breard-r/acmed/blob/1f0dcc32aadbc5e52de6d23b9703554c0f925113/acmed/src/storage.rs#L262
+fn check_files(file_types: &[FileType]) -> bool {
+    for t in file_types {
+        let path = match get_file_path(t) {
+            Ok(p) => p,
+            Err(_) => {
+                return false;
+            },
+        };
+        if !path.is_file() {
+            return false;
+        }
+    }
+    true
+}
+
+fn get_file_path(_file_type: &FileType) -> Result<std::path::PathBuf, std::io::Error> {
+    Ok(std::path::PathBuf::new())
+}
+
 fn require_string(_: &String) {}
diff --git a/tests/ui/unnecessary_to_owned.rs b/tests/ui/unnecessary_to_owned.rs
index 1bf30e22893..60b2e718f5d 100644
--- a/tests/ui/unnecessary_to_owned.rs
+++ b/tests/ui/unnecessary_to_owned.rs
@@ -1,10 +1,6 @@
 // run-rustfix
 
 #![allow(clippy::ptr_arg)]
-// `needless_borrow` is to ensure there are no needles borrows in the fixed code.
-#![warn(clippy::needless_borrow)]
-// `redundant_clone` is to ensure there is no overlap between that lint and this one.
-#![warn(clippy::redundant_clone)]
 #![warn(clippy::unnecessary_to_owned)]
 
 use std::borrow::Cow;
@@ -41,6 +37,14 @@ impl X {
     }
 }
 
+#[allow(dead_code)]
+#[derive(Clone)]
+enum FileType {
+    Account,
+    PrivateKey,
+    Certificate,
+}
+
 fn main() {
     let c_str = CStr::from_bytes_with_nul(&[0]).unwrap();
     let os_str = OsStr::new("x");
@@ -120,6 +124,18 @@ fn main() {
 
     let _ = x.join(&x_ref.to_string());
 
+    let _ = slice.to_vec().into_iter();
+    let _ = slice.to_owned().into_iter();
+    let _ = [std::path::PathBuf::new()][..].to_vec().into_iter();
+    let _ = [std::path::PathBuf::new()][..].to_owned().into_iter();
+
+    let _ = IntoIterator::into_iter(slice.to_vec());
+    let _ = IntoIterator::into_iter(slice.to_owned());
+    let _ = IntoIterator::into_iter([std::path::PathBuf::new()][..].to_vec());
+    let _ = IntoIterator::into_iter([std::path::PathBuf::new()][..].to_owned());
+
+    let _ = check_files(&[FileType::Account]);
+
     // negative tests
     require_string(&s.to_string());
     require_string(&Cow::from(s).into_owned());
@@ -174,4 +190,25 @@ fn require_impl_as_ref_slice<T>(_: impl AsRef<[T]>) {}
 fn require_as_ref_str_slice<T: AsRef<str>, U, V: AsRef<[U]>>(_: T, _: V) {}
 fn require_as_ref_slice_str<T, U: AsRef<[T]>, V: AsRef<str>>(_: U, _: V) {}
 
+// `check_files` is based on:
+// https://github.com/breard-r/acmed/blob/1f0dcc32aadbc5e52de6d23b9703554c0f925113/acmed/src/storage.rs#L262
+fn check_files(file_types: &[FileType]) -> bool {
+    for t in file_types.to_vec() {
+        let path = match get_file_path(&t) {
+            Ok(p) => p,
+            Err(_) => {
+                return false;
+            },
+        };
+        if !path.is_file() {
+            return false;
+        }
+    }
+    true
+}
+
+fn get_file_path(_file_type: &FileType) -> Result<std::path::PathBuf, std::io::Error> {
+    Ok(std::path::PathBuf::new())
+}
+
 fn require_string(_: &String) {}
diff --git a/tests/ui/unnecessary_to_owned.stderr b/tests/ui/unnecessary_to_owned.stderr
index 83cc53ef3a2..1dfc65e22e2 100644
--- a/tests/ui/unnecessary_to_owned.stderr
+++ b/tests/ui/unnecessary_to_owned.stderr
@@ -1,54 +1,54 @@
 error: redundant clone
-  --> $DIR/unnecessary_to_owned.rs:134:64
+  --> $DIR/unnecessary_to_owned.rs:150:64
    |
 LL |     require_c_str(&CString::from_vec_with_nul(vec![0]).unwrap().to_owned());
    |                                                                ^^^^^^^^^^^ help: remove this
    |
    = note: `-D clippy::redundant-clone` implied by `-D warnings`
 note: this value is dropped without further use
-  --> $DIR/unnecessary_to_owned.rs:134:20
+  --> $DIR/unnecessary_to_owned.rs:150:20
    |
 LL |     require_c_str(&CString::from_vec_with_nul(vec![0]).unwrap().to_owned());
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: redundant clone
-  --> $DIR/unnecessary_to_owned.rs:135:40
+  --> $DIR/unnecessary_to_owned.rs:151:40
    |
 LL |     require_os_str(&OsString::from("x").to_os_string());
    |                                        ^^^^^^^^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> $DIR/unnecessary_to_owned.rs:135:21
+  --> $DIR/unnecessary_to_owned.rs:151:21
    |
 LL |     require_os_str(&OsString::from("x").to_os_string());
    |                     ^^^^^^^^^^^^^^^^^^^
 
 error: redundant clone
-  --> $DIR/unnecessary_to_owned.rs:136:48
+  --> $DIR/unnecessary_to_owned.rs:152:48
    |
 LL |     require_path(&std::path::PathBuf::from("x").to_path_buf());
    |                                                ^^^^^^^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> $DIR/unnecessary_to_owned.rs:136:19
+  --> $DIR/unnecessary_to_owned.rs:152:19
    |
 LL |     require_path(&std::path::PathBuf::from("x").to_path_buf());
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: redundant clone
-  --> $DIR/unnecessary_to_owned.rs:137:35
+  --> $DIR/unnecessary_to_owned.rs:153:35
    |
 LL |     require_str(&String::from("x").to_string());
    |                                   ^^^^^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> $DIR/unnecessary_to_owned.rs:137:18
+  --> $DIR/unnecessary_to_owned.rs:153:18
    |
 LL |     require_str(&String::from("x").to_string());
    |                  ^^^^^^^^^^^^^^^^^
 
 error: unnecessary use of `into_owned`
-  --> $DIR/unnecessary_to_owned.rs:55:36
+  --> $DIR/unnecessary_to_owned.rs:59:36
    |
 LL |     require_c_str(&Cow::from(c_str).into_owned());
    |                                    ^^^^^^^^^^^^^ help: remove this
@@ -56,376 +56,440 @@ LL |     require_c_str(&Cow::from(c_str).into_owned());
    = note: `-D clippy::unnecessary-to-owned` implied by `-D warnings`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:56:19
+  --> $DIR/unnecessary_to_owned.rs:60:19
    |
 LL |     require_c_str(&c_str.to_owned());
    |                   ^^^^^^^^^^^^^^^^^ help: use: `c_str`
 
 error: unnecessary use of `to_os_string`
-  --> $DIR/unnecessary_to_owned.rs:58:20
+  --> $DIR/unnecessary_to_owned.rs:62:20
    |
 LL |     require_os_str(&os_str.to_os_string());
    |                    ^^^^^^^^^^^^^^^^^^^^^^ help: use: `os_str`
 
 error: unnecessary use of `into_owned`
-  --> $DIR/unnecessary_to_owned.rs:59:38
+  --> $DIR/unnecessary_to_owned.rs:63:38
    |
 LL |     require_os_str(&Cow::from(os_str).into_owned());
    |                                      ^^^^^^^^^^^^^ help: remove this
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:60:20
+  --> $DIR/unnecessary_to_owned.rs:64:20
    |
 LL |     require_os_str(&os_str.to_owned());
    |                    ^^^^^^^^^^^^^^^^^^ help: use: `os_str`
 
 error: unnecessary use of `to_path_buf`
-  --> $DIR/unnecessary_to_owned.rs:62:18
+  --> $DIR/unnecessary_to_owned.rs:66:18
    |
 LL |     require_path(&path.to_path_buf());
    |                  ^^^^^^^^^^^^^^^^^^^ help: use: `path`
 
 error: unnecessary use of `into_owned`
-  --> $DIR/unnecessary_to_owned.rs:63:34
+  --> $DIR/unnecessary_to_owned.rs:67:34
    |
 LL |     require_path(&Cow::from(path).into_owned());
    |                                  ^^^^^^^^^^^^^ help: remove this
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:64:18
+  --> $DIR/unnecessary_to_owned.rs:68:18
    |
 LL |     require_path(&path.to_owned());
    |                  ^^^^^^^^^^^^^^^^ help: use: `path`
 
 error: unnecessary use of `to_string`
-  --> $DIR/unnecessary_to_owned.rs:66:17
+  --> $DIR/unnecessary_to_owned.rs:70:17
    |
 LL |     require_str(&s.to_string());
    |                 ^^^^^^^^^^^^^^ help: use: `s`
 
 error: unnecessary use of `into_owned`
-  --> $DIR/unnecessary_to_owned.rs:67:30
+  --> $DIR/unnecessary_to_owned.rs:71:30
    |
 LL |     require_str(&Cow::from(s).into_owned());
    |                              ^^^^^^^^^^^^^ help: remove this
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:68:17
+  --> $DIR/unnecessary_to_owned.rs:72:17
    |
 LL |     require_str(&s.to_owned());
    |                 ^^^^^^^^^^^^^ help: use: `s`
 
 error: unnecessary use of `to_string`
-  --> $DIR/unnecessary_to_owned.rs:69:17
+  --> $DIR/unnecessary_to_owned.rs:73:17
    |
 LL |     require_str(&x_ref.to_string());
    |                 ^^^^^^^^^^^^^^^^^^ help: use: `x_ref.as_ref()`
 
 error: unnecessary use of `to_vec`
-  --> $DIR/unnecessary_to_owned.rs:71:19
+  --> $DIR/unnecessary_to_owned.rs:75:19
    |
 LL |     require_slice(&slice.to_vec());
    |                   ^^^^^^^^^^^^^^^ help: use: `slice`
 
 error: unnecessary use of `into_owned`
-  --> $DIR/unnecessary_to_owned.rs:72:36
+  --> $DIR/unnecessary_to_owned.rs:76:36
    |
 LL |     require_slice(&Cow::from(slice).into_owned());
    |                                    ^^^^^^^^^^^^^ help: remove this
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:73:19
+  --> $DIR/unnecessary_to_owned.rs:77:19
    |
 LL |     require_slice(&array.to_owned());
    |                   ^^^^^^^^^^^^^^^^^ help: use: `array.as_ref()`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:74:19
+  --> $DIR/unnecessary_to_owned.rs:78:19
    |
 LL |     require_slice(&array_ref.to_owned());
    |                   ^^^^^^^^^^^^^^^^^^^^^ help: use: `array_ref.as_ref()`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:75:19
+  --> $DIR/unnecessary_to_owned.rs:79:19
    |
 LL |     require_slice(&slice.to_owned());
    |                   ^^^^^^^^^^^^^^^^^ help: use: `slice`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:76:19
+  --> $DIR/unnecessary_to_owned.rs:80:19
    |
 LL |     require_slice(&x_ref.to_owned());
    |                   ^^^^^^^^^^^^^^^^^ help: use: `x_ref`
 
 error: unnecessary use of `into_owned`
-  --> $DIR/unnecessary_to_owned.rs:78:42
+  --> $DIR/unnecessary_to_owned.rs:82:42
    |
 LL |     require_x(&Cow::<X>::Owned(x.clone()).into_owned());
    |                                          ^^^^^^^^^^^^^ help: remove this
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:79:15
+  --> $DIR/unnecessary_to_owned.rs:83:15
    |
 LL |     require_x(&x_ref.to_owned());
    |               ^^^^^^^^^^^^^^^^^ help: use: `x_ref`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:81:25
+  --> $DIR/unnecessary_to_owned.rs:85:25
    |
 LL |     require_deref_c_str(c_str.to_owned());
    |                         ^^^^^^^^^^^^^^^^ help: use: `c_str`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:82:26
+  --> $DIR/unnecessary_to_owned.rs:86:26
    |
 LL |     require_deref_os_str(os_str.to_owned());
    |                          ^^^^^^^^^^^^^^^^^ help: use: `os_str`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:83:24
+  --> $DIR/unnecessary_to_owned.rs:87:24
    |
 LL |     require_deref_path(path.to_owned());
    |                        ^^^^^^^^^^^^^^^ help: use: `path`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:84:23
+  --> $DIR/unnecessary_to_owned.rs:88:23
    |
 LL |     require_deref_str(s.to_owned());
    |                       ^^^^^^^^^^^^ help: use: `s`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:85:25
+  --> $DIR/unnecessary_to_owned.rs:89:25
    |
 LL |     require_deref_slice(slice.to_owned());
    |                         ^^^^^^^^^^^^^^^^ help: use: `slice`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:87:30
+  --> $DIR/unnecessary_to_owned.rs:91:30
    |
 LL |     require_impl_deref_c_str(c_str.to_owned());
    |                              ^^^^^^^^^^^^^^^^ help: use: `c_str`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:88:31
+  --> $DIR/unnecessary_to_owned.rs:92:31
    |
 LL |     require_impl_deref_os_str(os_str.to_owned());
    |                               ^^^^^^^^^^^^^^^^^ help: use: `os_str`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:89:29
+  --> $DIR/unnecessary_to_owned.rs:93:29
    |
 LL |     require_impl_deref_path(path.to_owned());
    |                             ^^^^^^^^^^^^^^^ help: use: `path`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:90:28
+  --> $DIR/unnecessary_to_owned.rs:94:28
    |
 LL |     require_impl_deref_str(s.to_owned());
    |                            ^^^^^^^^^^^^ help: use: `s`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:91:30
+  --> $DIR/unnecessary_to_owned.rs:95:30
    |
 LL |     require_impl_deref_slice(slice.to_owned());
    |                              ^^^^^^^^^^^^^^^^ help: use: `slice`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:93:29
+  --> $DIR/unnecessary_to_owned.rs:97:29
    |
 LL |     require_deref_str_slice(s.to_owned(), slice.to_owned());
    |                             ^^^^^^^^^^^^ help: use: `s`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:93:43
+  --> $DIR/unnecessary_to_owned.rs:97:43
    |
 LL |     require_deref_str_slice(s.to_owned(), slice.to_owned());
    |                                           ^^^^^^^^^^^^^^^^ help: use: `slice`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:94:29
+  --> $DIR/unnecessary_to_owned.rs:98:29
    |
 LL |     require_deref_slice_str(slice.to_owned(), s.to_owned());
    |                             ^^^^^^^^^^^^^^^^ help: use: `slice`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:94:47
+  --> $DIR/unnecessary_to_owned.rs:98:47
    |
 LL |     require_deref_slice_str(slice.to_owned(), s.to_owned());
    |                                               ^^^^^^^^^^^^ help: use: `s`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:96:26
+  --> $DIR/unnecessary_to_owned.rs:100:26
    |
 LL |     require_as_ref_c_str(c_str.to_owned());
    |                          ^^^^^^^^^^^^^^^^ help: use: `c_str`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:97:27
+  --> $DIR/unnecessary_to_owned.rs:101:27
    |
 LL |     require_as_ref_os_str(os_str.to_owned());
    |                           ^^^^^^^^^^^^^^^^^ help: use: `os_str`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:98:25
+  --> $DIR/unnecessary_to_owned.rs:102:25
    |
 LL |     require_as_ref_path(path.to_owned());
    |                         ^^^^^^^^^^^^^^^ help: use: `path`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:99:24
+  --> $DIR/unnecessary_to_owned.rs:103:24
    |
 LL |     require_as_ref_str(s.to_owned());
    |                        ^^^^^^^^^^^^ help: use: `s`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:100:24
+  --> $DIR/unnecessary_to_owned.rs:104:24
    |
 LL |     require_as_ref_str(x.to_owned());
    |                        ^^^^^^^^^^^^ help: use: `&x`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:101:26
+  --> $DIR/unnecessary_to_owned.rs:105:26
    |
 LL |     require_as_ref_slice(array.to_owned());
    |                          ^^^^^^^^^^^^^^^^ help: use: `array`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:102:26
+  --> $DIR/unnecessary_to_owned.rs:106:26
    |
 LL |     require_as_ref_slice(array_ref.to_owned());
    |                          ^^^^^^^^^^^^^^^^^^^^ help: use: `array_ref`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:103:26
+  --> $DIR/unnecessary_to_owned.rs:107:26
    |
 LL |     require_as_ref_slice(slice.to_owned());
    |                          ^^^^^^^^^^^^^^^^ help: use: `slice`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:105:31
+  --> $DIR/unnecessary_to_owned.rs:109:31
    |
 LL |     require_impl_as_ref_c_str(c_str.to_owned());
    |                               ^^^^^^^^^^^^^^^^ help: use: `c_str`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:106:32
+  --> $DIR/unnecessary_to_owned.rs:110:32
    |
 LL |     require_impl_as_ref_os_str(os_str.to_owned());
    |                                ^^^^^^^^^^^^^^^^^ help: use: `os_str`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:107:30
+  --> $DIR/unnecessary_to_owned.rs:111:30
    |
 LL |     require_impl_as_ref_path(path.to_owned());
    |                              ^^^^^^^^^^^^^^^ help: use: `path`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:108:29
+  --> $DIR/unnecessary_to_owned.rs:112:29
    |
 LL |     require_impl_as_ref_str(s.to_owned());
    |                             ^^^^^^^^^^^^ help: use: `s`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:109:29
+  --> $DIR/unnecessary_to_owned.rs:113:29
    |
 LL |     require_impl_as_ref_str(x.to_owned());
    |                             ^^^^^^^^^^^^ help: use: `&x`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:110:31
+  --> $DIR/unnecessary_to_owned.rs:114:31
    |
 LL |     require_impl_as_ref_slice(array.to_owned());
    |                               ^^^^^^^^^^^^^^^^ help: use: `array`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:111:31
+  --> $DIR/unnecessary_to_owned.rs:115:31
    |
 LL |     require_impl_as_ref_slice(array_ref.to_owned());
    |                               ^^^^^^^^^^^^^^^^^^^^ help: use: `array_ref`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:112:31
+  --> $DIR/unnecessary_to_owned.rs:116:31
    |
 LL |     require_impl_as_ref_slice(slice.to_owned());
    |                               ^^^^^^^^^^^^^^^^ help: use: `slice`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:114:30
+  --> $DIR/unnecessary_to_owned.rs:118:30
    |
 LL |     require_as_ref_str_slice(s.to_owned(), array.to_owned());
    |                              ^^^^^^^^^^^^ help: use: `s`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:114:44
+  --> $DIR/unnecessary_to_owned.rs:118:44
    |
 LL |     require_as_ref_str_slice(s.to_owned(), array.to_owned());
    |                                            ^^^^^^^^^^^^^^^^ help: use: `array`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:115:30
+  --> $DIR/unnecessary_to_owned.rs:119:30
    |
 LL |     require_as_ref_str_slice(s.to_owned(), array_ref.to_owned());
    |                              ^^^^^^^^^^^^ help: use: `s`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:115:44
+  --> $DIR/unnecessary_to_owned.rs:119:44
    |
 LL |     require_as_ref_str_slice(s.to_owned(), array_ref.to_owned());
    |                                            ^^^^^^^^^^^^^^^^^^^^ help: use: `array_ref`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:116:30
+  --> $DIR/unnecessary_to_owned.rs:120:30
    |
 LL |     require_as_ref_str_slice(s.to_owned(), slice.to_owned());
    |                              ^^^^^^^^^^^^ help: use: `s`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:116:44
+  --> $DIR/unnecessary_to_owned.rs:120:44
    |
 LL |     require_as_ref_str_slice(s.to_owned(), slice.to_owned());
    |                                            ^^^^^^^^^^^^^^^^ help: use: `slice`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:117:30
+  --> $DIR/unnecessary_to_owned.rs:121:30
    |
 LL |     require_as_ref_slice_str(array.to_owned(), s.to_owned());
    |                              ^^^^^^^^^^^^^^^^ help: use: `array`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:117:48
+  --> $DIR/unnecessary_to_owned.rs:121:48
    |
 LL |     require_as_ref_slice_str(array.to_owned(), s.to_owned());
    |                                                ^^^^^^^^^^^^ help: use: `s`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:118:30
+  --> $DIR/unnecessary_to_owned.rs:122:30
    |
 LL |     require_as_ref_slice_str(array_ref.to_owned(), s.to_owned());
    |                              ^^^^^^^^^^^^^^^^^^^^ help: use: `array_ref`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:118:52
+  --> $DIR/unnecessary_to_owned.rs:122:52
    |
 LL |     require_as_ref_slice_str(array_ref.to_owned(), s.to_owned());
    |                                                    ^^^^^^^^^^^^ help: use: `s`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:119:30
+  --> $DIR/unnecessary_to_owned.rs:123:30
    |
 LL |     require_as_ref_slice_str(slice.to_owned(), s.to_owned());
    |                              ^^^^^^^^^^^^^^^^ help: use: `slice`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:119:48
+  --> $DIR/unnecessary_to_owned.rs:123:48
    |
 LL |     require_as_ref_slice_str(slice.to_owned(), s.to_owned());
    |                                                ^^^^^^^^^^^^ help: use: `s`
 
 error: unnecessary use of `to_string`
-  --> $DIR/unnecessary_to_owned.rs:121:20
+  --> $DIR/unnecessary_to_owned.rs:125:20
    |
 LL |     let _ = x.join(&x_ref.to_string());
    |                    ^^^^^^^^^^^^^^^^^^ help: use: `x_ref`
 
-error: aborting due to 67 previous errors
+error: unnecessary use of `to_vec`
+  --> $DIR/unnecessary_to_owned.rs:127:13
+   |
+LL |     let _ = slice.to_vec().into_iter();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `slice.iter().copied()`
+
+error: unnecessary use of `to_owned`
+  --> $DIR/unnecessary_to_owned.rs:128:13
+   |
+LL |     let _ = slice.to_owned().into_iter();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `slice.iter().copied()`
+
+error: unnecessary use of `to_vec`
+  --> $DIR/unnecessary_to_owned.rs:129:13
+   |
+LL |     let _ = [std::path::PathBuf::new()][..].to_vec().into_iter();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `[std::path::PathBuf::new()][..].iter().cloned()`
+
+error: unnecessary use of `to_owned`
+  --> $DIR/unnecessary_to_owned.rs:130:13
+   |
+LL |     let _ = [std::path::PathBuf::new()][..].to_owned().into_iter();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `[std::path::PathBuf::new()][..].iter().cloned()`
+
+error: unnecessary use of `to_vec`
+  --> $DIR/unnecessary_to_owned.rs:132:13
+   |
+LL |     let _ = IntoIterator::into_iter(slice.to_vec());
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `slice.iter().copied()`
+
+error: unnecessary use of `to_owned`
+  --> $DIR/unnecessary_to_owned.rs:133:13
+   |
+LL |     let _ = IntoIterator::into_iter(slice.to_owned());
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `slice.iter().copied()`
+
+error: unnecessary use of `to_vec`
+  --> $DIR/unnecessary_to_owned.rs:134:13
+   |
+LL |     let _ = IntoIterator::into_iter([std::path::PathBuf::new()][..].to_vec());
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `[std::path::PathBuf::new()][..].iter().cloned()`
+
+error: unnecessary use of `to_owned`
+  --> $DIR/unnecessary_to_owned.rs:135:13
+   |
+LL |     let _ = IntoIterator::into_iter([std::path::PathBuf::new()][..].to_owned());
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `[std::path::PathBuf::new()][..].iter().cloned()`
+
+error: unnecessary use of `to_vec`
+  --> $DIR/unnecessary_to_owned.rs:196:14
+   |
+LL |     for t in file_types.to_vec() {
+   |              ^^^^^^^^^^^^^^^^^^^
+   |
+help: use
+   |
+LL |     for t in file_types {
+   |              ~~~~~~~~~~
+help: remove this `&`
+   |
+LL -         let path = match get_file_path(&t) {
+LL +         let path = match get_file_path(t) {
+   | 
+
+error: aborting due to 76 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From cb609a99044adc07ea4cdb0b4927f4ad461bb4b5 Mon Sep 17 00:00:00 2001
From: "Samuel E. Moelius III" <sam@moeli.us>
Date: Mon, 13 Dec 2021 12:27:47 -0500
Subject: Add comma

---
 clippy_lints/src/methods/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 6a61e662698..27189180248 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1993,7 +1993,7 @@ impl_lint_pass!(Methods => [
     EXTEND_WITH_DRAIN,
     MANUAL_SPLIT_ONCE,
     NEEDLESS_SPLITN,
-    UNNECESSARY_TO_OWNED
+    UNNECESSARY_TO_OWNED,
 ]);
 
 /// Extracts a method call name, args, and `Span` of the method name.
-- 
cgit 1.4.1-3-g733a5


From 3beb6b1908e03bbf645ecdac7d56a772b5d8a8ef Mon Sep 17 00:00:00 2001
From: "Samuel E. Moelius III" <sam@moeli.us>
Date: Tue, 14 Dec 2021 18:36:19 -0500
Subject: Address review comments

---
 clippy_lints/src/methods/mod.rs                  |  2 +-
 clippy_lints/src/methods/unnecessary_to_owned.rs | 26 ++++++++++--------------
 2 files changed, 12 insertions(+), 16 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 27189180248..3c43671dd34 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1893,7 +1893,7 @@ declare_clippy_lint! {
     /// and other `to_owned`-like functions.
     ///
     /// ### Why is this bad?
-    /// The unnecessary calls result in unnecessary allocations.
+    /// The unnecessary calls result in useless allocations.
     ///
     /// ### Example
     /// ```rust
diff --git a/clippy_lints/src/methods/unnecessary_to_owned.rs b/clippy_lints/src/methods/unnecessary_to_owned.rs
index c5af7483ae6..c48bacfce0d 100644
--- a/clippy_lints/src/methods/unnecessary_to_owned.rs
+++ b/clippy_lints/src/methods/unnecessary_to_owned.rs
@@ -107,21 +107,17 @@ fn check_addr_of_expr(
         then {
             let (target_ty, n_target_refs) = peel_mid_ty_refs(target_ty);
             let (receiver_ty, n_receiver_refs) = peel_mid_ty_refs(receiver_ty);
-            if_chain! {
-                if receiver_ty == target_ty;
-                if n_target_refs >= n_receiver_refs;
-                then {
-                    span_lint_and_sugg(
-                        cx,
-                        UNNECESSARY_TO_OWNED,
-                        parent.span,
-                        &format!("unnecessary use of `{}`", method_name),
-                        "use",
-                        format!("{:&>width$}{}", "", receiver_snippet, width = n_target_refs - n_receiver_refs),
-                        Applicability::MachineApplicable,
-                    );
-                    return true;
-                }
+            if receiver_ty == target_ty && n_target_refs >= n_receiver_refs {
+                span_lint_and_sugg(
+                    cx,
+                    UNNECESSARY_TO_OWNED,
+                    parent.span,
+                    &format!("unnecessary use of `{}`", method_name),
+                    "use",
+                    format!("{:&>width$}{}", "", receiver_snippet, width = n_target_refs - n_receiver_refs),
+                    Applicability::MachineApplicable,
+                );
+                return true;
             }
             if_chain! {
                 if let Some(deref_trait_id) = cx.tcx.get_diagnostic_item(sym::Deref);
-- 
cgit 1.4.1-3-g733a5


From b8913894a13431bea99400dc9f53a1fd9f41a6c6 Mon Sep 17 00:00:00 2001
From: "Samuel E. Moelius III" <sam@moeli.us>
Date: Wed, 15 Dec 2021 05:25:47 -0500
Subject: Expand `is_clone_like` comment

---
 clippy_lints/src/methods/implicit_clone.rs | 3 +++
 1 file changed, 3 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/implicit_clone.rs b/clippy_lints/src/methods/implicit_clone.rs
index ff7904ce582..90492ffda3c 100644
--- a/clippy_lints/src/methods/implicit_clone.rs
+++ b/clippy_lints/src/methods/implicit_clone.rs
@@ -32,6 +32,9 @@ pub fn check(cx: &LateContext<'_>, method_name: &str, expr: &hir::Expr<'_>, recv
 }
 
 /// Returns true if the named method can be used to clone the receiver.
+/// Note that `to_string` is not flagged by `implicit_clone`. So other lints that call
+/// `is_clone_like` and that do flag `to_string` must handle it separately. See, e.g.,
+/// `is_to_owned_like` in `unnecessary_to_owned.rs`.
 pub fn is_clone_like(cx: &LateContext<'_>, method_name: &str, method_def_id: hir::def_id::DefId) -> bool {
     match method_name {
         "to_os_string" => is_diag_item_method(cx, method_def_id, sym::OsStr),
-- 
cgit 1.4.1-3-g733a5


From eba441391d7830081befd4b2dfa23a0b78ace92b Mon Sep 17 00:00:00 2001
From: r00ster91 <r00ster91@protonmail.com>
Date: Fri, 17 Dec 2021 20:48:38 +0100
Subject: Fix SAFETY comment tag casing in undocumented_unsafe_blocks

---
 clippy_lints/src/undocumented_unsafe_blocks.rs |  6 ++--
 tests/ui/crashes/ice-7868.stderr               |  2 +-
 tests/ui/undocumented_unsafe_blocks.rs         | 38 +++++++++++++-------------
 tests/ui/undocumented_unsafe_blocks.stderr     | 30 ++++++++++----------
 4 files changed, 38 insertions(+), 38 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/undocumented_unsafe_blocks.rs b/clippy_lints/src/undocumented_unsafe_blocks.rs
index ccc49caf47c..3d3b4a6679d 100644
--- a/clippy_lints/src/undocumented_unsafe_blocks.rs
+++ b/clippy_lints/src/undocumented_unsafe_blocks.rs
@@ -15,7 +15,7 @@ use std::borrow::Cow;
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for `unsafe` blocks without a `// Safety: ` comment
+    /// Checks for `unsafe` blocks without a `// SAFETY: ` comment
     /// explaining why the unsafe operations performed inside
     /// the block are safe.
     ///
@@ -36,7 +36,7 @@ declare_clippy_lint! {
     /// use std::ptr::NonNull;
     /// let a = &mut 42;
     ///
-    /// // Safety: references are guaranteed to be non-null.
+    /// // SAFETY: references are guaranteed to be non-null.
     /// let ptr = unsafe { NonNull::new_unchecked(a) };
     /// ```
     #[clippy::version = "1.58.0"]
@@ -213,7 +213,7 @@ impl UndocumentedUnsafeBlocks {
             );
         } else {
             let block_indent = indent_of(cx, span);
-            let suggestion = format!("// Safety: ...\n{}", snippet(cx, span, ".."));
+            let suggestion = format!("// SAFETY: ...\n{}", snippet(cx, span, ".."));
 
             span_lint_and_sugg(
                 cx,
diff --git a/tests/ui/crashes/ice-7868.stderr b/tests/ui/crashes/ice-7868.stderr
index d7b49eb89a2..111350a6280 100644
--- a/tests/ui/crashes/ice-7868.stderr
+++ b/tests/ui/crashes/ice-7868.stderr
@@ -7,7 +7,7 @@ LL |     unsafe { 0 };
    = note: `-D clippy::undocumented-unsafe-blocks` implied by `-D warnings`
 help: consider adding a safety comment
    |
-LL ~     // Safety: ...
+LL ~     // SAFETY: ...
 LL ~     unsafe { 0 };
    |
 
diff --git a/tests/ui/undocumented_unsafe_blocks.rs b/tests/ui/undocumented_unsafe_blocks.rs
index 7e510d89475..380303d8152 100644
--- a/tests/ui/undocumented_unsafe_blocks.rs
+++ b/tests/ui/undocumented_unsafe_blocks.rs
@@ -5,7 +5,7 @@
 fn nested_local() {
     let _ = {
         let _ = {
-            // Safety:
+            // SAFETY:
             let _ = unsafe {};
         };
     };
@@ -14,7 +14,7 @@ fn nested_local() {
 fn deep_nest() {
     let _ = {
         let _ = {
-            // Safety:
+            // SAFETY:
             let _ = unsafe {};
 
             // Safety:
@@ -28,7 +28,7 @@ fn deep_nest() {
                                 // Safety:
                                 let _ = unsafe {};
 
-                                // Safety:
+                                // SAFETY:
                                 unsafe {};
                             };
                         };
@@ -44,7 +44,7 @@ fn deep_nest() {
         unsafe {};
     };
 
-    // Safety:
+    // SAFETY:
     unsafe {};
 }
 
@@ -59,7 +59,7 @@ fn line_comment() {
 }
 
 fn line_comment_newlines() {
-    // Safety:
+    // SAFETY:
 
     unsafe {}
 }
@@ -84,7 +84,7 @@ fn block_comment() {
 }
 
 fn block_comment_newlines() {
-    /* Safety: */
+    /* SAFETY: */
 
     unsafe {}
 }
@@ -96,7 +96,7 @@ fn inline_block_comment() {
 
 fn block_comment_with_extras() {
     /* This is a description
-     * Safety:
+     * SAFETY:
      */
     unsafe {}
 }
@@ -122,7 +122,7 @@ fn buried_safety() {
 }
 
 fn safety_with_prepended_text() {
-    // This is a test. Safety:
+    // This is a test. safety:
     unsafe {}
 }
 
@@ -132,7 +132,7 @@ fn local_line_comment() {
 }
 
 fn local_block_comment() {
-    /* Safety: */
+    /* SAFETY: */
     let _ = unsafe {};
 }
 
@@ -142,18 +142,18 @@ fn comment_array() {
 }
 
 fn comment_tuple() {
-    // Safety:
+    // sAFETY:
     let _ = (42, unsafe {}, "test", unsafe {});
 }
 
 fn comment_unary() {
-    // Safety:
+    // SAFETY:
     let _ = *unsafe { &42 };
 }
 
 #[allow(clippy::match_single_binding)]
 fn comment_match() {
-    // Safety:
+    // SAFETY:
     let _ = match unsafe {} {
         _ => {},
     };
@@ -177,7 +177,7 @@ fn comment_macro_call() {
     }
 
     t!(
-        // Safety:
+        // SAFETY:
         unsafe {}
     );
 }
@@ -194,18 +194,18 @@ fn comment_macro_def() {
 }
 
 fn non_ascii_comment() {
-    // ॐ᧻໒ Safety: ௵∰
+    // ॐ᧻໒ SaFeTy: ௵∰
     unsafe {};
 }
 
 fn local_commented_block() {
     let _ =
-        // Safety:
+        // safety:
         unsafe {};
 }
 
 fn local_nest() {
-    // Safety:
+    // safety:
     let _ = [(42, unsafe {}, unsafe {}), (52, unsafe {}, unsafe {})];
 }
 
@@ -267,17 +267,17 @@ fn no_comment_macro_def() {
 }
 
 fn trailing_comment() {
-    unsafe {} // Safety:
+    unsafe {} // SAFETY:
 }
 
 fn internal_comment() {
     unsafe {
-        // Safety:
+        // SAFETY:
     }
 }
 
 fn interference() {
-    // Safety
+    // SAFETY
 
     let _ = 42;
 
diff --git a/tests/ui/undocumented_unsafe_blocks.stderr b/tests/ui/undocumented_unsafe_blocks.stderr
index ebe589001a1..f69d0da54e0 100644
--- a/tests/ui/undocumented_unsafe_blocks.stderr
+++ b/tests/ui/undocumented_unsafe_blocks.stderr
@@ -7,7 +7,7 @@ LL |     unsafe {}
    = note: `-D clippy::undocumented-unsafe-blocks` implied by `-D warnings`
 help: consider adding a safety comment
    |
-LL ~     // Safety: ...
+LL ~     // SAFETY: ...
 LL +     unsafe {}
    |
 
@@ -19,7 +19,7 @@ LL |     let _ = [unsafe { 14 }, unsafe { 15 }, 42, unsafe { 16 }];
    |
 help: consider adding a safety comment
    |
-LL ~     // Safety: ...
+LL ~     // SAFETY: ...
 LL +     let _ = [unsafe { 14 }, unsafe { 15 }, 42, unsafe { 16 }];
    |
 
@@ -31,7 +31,7 @@ LL |     let _ = (42, unsafe {}, "test", unsafe {});
    |
 help: consider adding a safety comment
    |
-LL ~     // Safety: ...
+LL ~     // SAFETY: ...
 LL +     let _ = (42, unsafe {}, "test", unsafe {});
    |
 
@@ -43,7 +43,7 @@ LL |     let _ = *unsafe { &42 };
    |
 help: consider adding a safety comment
    |
-LL ~     // Safety: ...
+LL ~     // SAFETY: ...
 LL +     let _ = *unsafe { &42 };
    |
 
@@ -55,7 +55,7 @@ LL |     let _ = match unsafe {} {
    |
 help: consider adding a safety comment
    |
-LL ~     // Safety: ...
+LL ~     // SAFETY: ...
 LL +     let _ = match unsafe {} {
    |
 
@@ -67,7 +67,7 @@ LL |     let _ = &unsafe {};
    |
 help: consider adding a safety comment
    |
-LL ~     // Safety: ...
+LL ~     // SAFETY: ...
 LL +     let _ = &unsafe {};
    |
 
@@ -79,7 +79,7 @@ LL |     let _ = [unsafe {}; 5];
    |
 help: consider adding a safety comment
    |
-LL ~     // Safety: ...
+LL ~     // SAFETY: ...
 LL +     let _ = [unsafe {}; 5];
    |
 
@@ -91,7 +91,7 @@ LL |     let _ = unsafe {};
    |
 help: consider adding a safety comment
    |
-LL ~     // Safety: ...
+LL ~     // SAFETY: ...
 LL +     let _ = unsafe {};
    |
 
@@ -103,7 +103,7 @@ LL |     t!(unsafe {});
    |
 help: consider adding a safety comment
    |
-LL ~     t!(// Safety: ...
+LL ~     t!(// SAFETY: ...
 LL ~     unsafe {});
    |
 
@@ -122,13 +122,13 @@ LL |     t!();
 error: unsafe block missing a safety comment
   --> $DIR/undocumented_unsafe_blocks.rs:270:5
    |
-LL |     unsafe {} // Safety:
+LL |     unsafe {} // SAFETY:
    |     ^^^^^^^^^
    |
 help: consider adding a safety comment
    |
-LL ~     // Safety: ...
-LL ~     unsafe {} // Safety:
+LL ~     // SAFETY: ...
+LL ~     unsafe {} // SAFETY:
    |
 
 error: unsafe block missing a safety comment
@@ -139,7 +139,7 @@ LL |     unsafe {
    |
 help: consider adding a safety comment
    |
-LL ~     // Safety: ...
+LL ~     // SAFETY: ...
 LL +     unsafe {
    |
 
@@ -151,7 +151,7 @@ LL |     unsafe {};
    |
 help: consider adding a safety comment
    |
-LL ~     // Safety: ...
+LL ~     // SAFETY: ...
 LL ~     unsafe {};
    |
 
@@ -163,7 +163,7 @@ LL |     println!("{}", unsafe { String::from_utf8_unchecked(vec![]) });
    |
 help: consider adding a safety comment
    |
-LL ~     println!("{}", // Safety: ...
+LL ~     println!("{}", // SAFETY: ...
 LL ~     unsafe { String::from_utf8_unchecked(vec![]) });
    |
 
-- 
cgit 1.4.1-3-g733a5


From 4da55202050818d7bb2ac5d4eabdf8dd1a1b7ff9 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Sat, 18 Dec 2021 15:26:16 +0100
Subject: Ensure that RETURN_SELF_NOT_MUST_USE is not emitted if the method
 already has a must_use attribute

---
 clippy_lints/src/return_self_not_must_use.rs |  4 +++-
 tests/ui/return_self_not_must_use.rs         | 17 +++++++++++------
 2 files changed, 14 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/return_self_not_must_use.rs b/clippy_lints/src/return_self_not_must_use.rs
index 1118da6c8cb..2ff7f6bbb38 100644
--- a/clippy_lints/src/return_self_not_must_use.rs
+++ b/clippy_lints/src/return_self_not_must_use.rs
@@ -5,7 +5,7 @@ use rustc_hir::{Body, FnDecl, HirId, TraitItem, TraitItemKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::Span;
+use rustc_span::{sym, Span};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -86,6 +86,8 @@ impl<'tcx> LateLintPass<'tcx> for ReturnSelfNotMustUse {
             // We are only interested in methods, not in functions or associated functions.
             if matches!(kind, FnKind::Method(_, _, _));
             if let Some(fn_def) = cx.tcx.hir().opt_local_def_id(hir_id);
+            // We don't want to emit this lint if the `#[must_use]` attribute is already there.
+            if !cx.tcx.hir().attrs(hir_id).iter().any(|attr| attr.has_name(sym::must_use));
             if let Some(impl_def) = cx.tcx.impl_of_method(fn_def.to_def_id());
             // We don't want this method to be te implementation of a trait because the
             // `#[must_use]` should be put on the trait definition directly.
diff --git a/tests/ui/return_self_not_must_use.rs b/tests/ui/return_self_not_must_use.rs
index bdf3f3d7995..2fa389dec0a 100644
--- a/tests/ui/return_self_not_must_use.rs
+++ b/tests/ui/return_self_not_must_use.rs
@@ -5,12 +5,12 @@ pub struct Bar;
 
 pub trait Whatever {
     fn what(&self) -> Self;
-    // There should be no warning here!
+    // There should be no warning here! (returns a reference)
     fn what2(&self) -> &Self;
 }
 
 impl Bar {
-    // There should be no warning here!
+    // There should be no warning here! (note taking a self argument)
     pub fn not_new() -> Self {
         Self
     }
@@ -20,22 +20,27 @@ impl Bar {
     pub fn bar(self) -> Self {
         self
     }
-    // There should be no warning here!
+    // There should be no warning here! (private method)
     fn foo2(&self) -> Self {
         Self
     }
-    // There should be no warning here!
+    // There should be no warning here! (returns a reference)
     pub fn foo3(&self) -> &Self {
         self
     }
+    // There should be no warning here! (already a `must_use` attribute)
+    #[must_use]
+    pub fn foo4(&self) -> Self {
+        Self
+    }
 }
 
 impl Whatever for Bar {
-    // There should be no warning here!
+    // There should be no warning here! (comes from the trait)
     fn what(&self) -> Self {
         self.foo2()
     }
-    // There should be no warning here!
+    // There should be no warning here! (comes from the trait)
     fn what2(&self) -> &Self {
         self
     }
-- 
cgit 1.4.1-3-g733a5


From 07a00efe61fcb1e52103c2acb6f921ced6d11749 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Sun, 19 Dec 2021 15:10:36 +0100
Subject: Don't emit RETURN_SELF_NOT_MUST_USE lint if `Self` already is marked
 as `#[must_use]`

---
 clippy_lints/src/return_self_not_must_use.rs | 11 ++++++-----
 tests/ui/return_self_not_must_use.rs         | 10 ++++++++++
 2 files changed, 16 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/return_self_not_must_use.rs b/clippy_lints/src/return_self_not_must_use.rs
index 2ff7f6bbb38..b57ec96bc7e 100644
--- a/clippy_lints/src/return_self_not_must_use.rs
+++ b/clippy_lints/src/return_self_not_must_use.rs
@@ -1,4 +1,5 @@
-use clippy_utils::{diagnostics::span_lint, must_use_attr, nth_arg, return_ty};
+use clippy_utils::ty::is_must_use_ty;
+use clippy_utils::{diagnostics::span_lint, nth_arg, return_ty};
 use rustc_hir::def_id::LocalDefId;
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::{Body, FnDecl, HirId, TraitItem, TraitItemKind};
@@ -50,9 +51,9 @@ fn check_method(cx: &LateContext<'tcx>, decl: &'tcx FnDecl<'tcx>, fn_def: LocalD
         if decl.implicit_self.has_implicit_self();
         // We only show this warning for public exported methods.
         if cx.access_levels.is_exported(fn_def);
+        // We don't want to emit this lint if the `#[must_use]` attribute is already there.
+        if !cx.tcx.hir().attrs(hir_id).iter().any(|attr| attr.has_name(sym::must_use));
         if cx.tcx.visibility(fn_def.to_def_id()).is_public();
-        // No need to warn if the attribute is already present.
-        if must_use_attr(cx.tcx.hir().attrs(hir_id)).is_none();
         let ret_ty = return_ty(cx, hir_id);
         let self_arg = nth_arg(cx, hir_id, 0);
         // If `Self` has the same type as the returned type, then we want to warn.
@@ -60,6 +61,8 @@ fn check_method(cx: &LateContext<'tcx>, decl: &'tcx FnDecl<'tcx>, fn_def: LocalD
         // For this check, we don't want to remove the reference on the returned type because if
         // there is one, we shouldn't emit a warning!
         if self_arg.peel_refs() == ret_ty;
+        // If `Self` is already marked as `#[must_use]`, no need for the attribute here.
+        if !is_must_use_ty(cx, ret_ty);
 
         then {
             span_lint(
@@ -86,8 +89,6 @@ impl<'tcx> LateLintPass<'tcx> for ReturnSelfNotMustUse {
             // We are only interested in methods, not in functions or associated functions.
             if matches!(kind, FnKind::Method(_, _, _));
             if let Some(fn_def) = cx.tcx.hir().opt_local_def_id(hir_id);
-            // We don't want to emit this lint if the `#[must_use]` attribute is already there.
-            if !cx.tcx.hir().attrs(hir_id).iter().any(|attr| attr.has_name(sym::must_use));
             if let Some(impl_def) = cx.tcx.impl_of_method(fn_def.to_def_id());
             // We don't want this method to be te implementation of a trait because the
             // `#[must_use]` should be put on the trait definition directly.
diff --git a/tests/ui/return_self_not_must_use.rs b/tests/ui/return_self_not_must_use.rs
index 2fa389dec0a..7dd5742dae9 100644
--- a/tests/ui/return_self_not_must_use.rs
+++ b/tests/ui/return_self_not_must_use.rs
@@ -45,3 +45,13 @@ impl Whatever for Bar {
         self
     }
 }
+
+#[must_use]
+pub struct Foo;
+
+impl Foo {
+    // There should be no warning here! (`Foo` already implements `#[must_use]`)
+    fn foo(&self) -> Self {
+        Self
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 5ad37b1a4b34af381b93f603e4c948928a8a6124 Mon Sep 17 00:00:00 2001
From: Oussama <abdelmoumenoussama@gmail.com>
Date: Sun, 19 Dec 2021 09:48:25 +0100
Subject: add suggestion for neg_multiply lint

---
 clippy_lints/src/neg_multiply.rs | 26 ++++++++++++++++++++++----
 tests/ui/neg_multiply.stderr     |  8 ++++----
 2 files changed, 26 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/neg_multiply.rs b/clippy_lints/src/neg_multiply.rs
index cb67fab1740..78645e50bff 100644
--- a/clippy_lints/src/neg_multiply.rs
+++ b/clippy_lints/src/neg_multiply.rs
@@ -1,7 +1,8 @@
 use clippy_utils::consts::{self, Constant};
-use clippy_utils::diagnostics::span_lint;
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use if_chain::if_chain;
-use rustc_hir::{BinOpKind, Expr, ExprKind, UnOp};
+use rustc_errors::Applicability;
+use rustc_hir::{BinOpKind, Expr, ExprKind, QPath, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
@@ -18,7 +19,11 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```ignore
-    /// x * -1
+    /// // Bad
+    /// let a = x * -1;
+    ///
+    /// // Good
+    /// let b = -x;
     /// ```
     #[clippy::version = "pre 1.29.0"]
     pub NEG_MULTIPLY,
@@ -49,8 +54,21 @@ fn check_mul(cx: &LateContext<'_>, span: Span, lit: &Expr<'_>, exp: &Expr<'_>) {
         if let ExprKind::Lit(ref l) = lit.kind;
         if consts::lit_to_constant(&l.node, cx.typeck_results().expr_ty_opt(lit)) == Constant::Int(1);
         if cx.typeck_results().expr_ty(exp).is_integral();
+        if let ExprKind::Path(QPath::Resolved(_, var_path)) = exp.kind;
+
         then {
-            span_lint(cx, NEG_MULTIPLY, span, "negation by multiplying with `-1`");
+            let var_name = var_path.segments[0].ident.name.as_str();
+            let suggestion = format!("-{var}",var=var_name);
+            let applicability = Applicability::MachineApplicable;
+            span_lint_and_sugg(
+                    cx,
+                    NEG_MULTIPLY,
+                    span,
+                    "this `multiplication with -1` can be written more succinctly",
+                    "consider using",
+                    suggestion,
+                    applicability,
+                );
         }
     }
 }
diff --git a/tests/ui/neg_multiply.stderr b/tests/ui/neg_multiply.stderr
index ad677f6d6fb..ce5f46fca56 100644
--- a/tests/ui/neg_multiply.stderr
+++ b/tests/ui/neg_multiply.stderr
@@ -1,16 +1,16 @@
-error: negation by multiplying with `-1`
+error: this `multiplication with -1` can be written more succinctly
   --> $DIR/neg_multiply.rs:27:5
    |
 LL |     x * -1;
-   |     ^^^^^^
+   |     ^^^^^^ help: consider using: `-x`
    |
    = note: `-D clippy::neg-multiply` implied by `-D warnings`
 
-error: negation by multiplying with `-1`
+error: this `multiplication with -1` can be written more succinctly
   --> $DIR/neg_multiply.rs:29:5
    |
 LL |     -1 * x;
-   |     ^^^^^^
+   |     ^^^^^^ help: consider using: `-x`
 
 error: aborting due to 2 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 88e40bc73db441b931372a11b99c308f4bf0427f Mon Sep 17 00:00:00 2001
From: Oussama <abdelmoumenoussama@gmail.com>
Date: Tue, 21 Dec 2021 22:00:14 +0100
Subject: Add support for suggestion when using an expression

---
 clippy_lints/src/neg_multiply.rs | 13 ++++++------
 tests/ui/neg_multiply.fixed      | 44 ++++++++++++++++++++++++++++++++++++++++
 tests/ui/neg_multiply.rs         |  9 ++++++++
 tests/ui/neg_multiply.stderr     | 42 +++++++++++++++++++++++++++++++++-----
 4 files changed, 96 insertions(+), 12 deletions(-)
 create mode 100644 tests/ui/neg_multiply.fixed

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/neg_multiply.rs b/clippy_lints/src/neg_multiply.rs
index 78645e50bff..0d05c83ffe4 100644
--- a/clippy_lints/src/neg_multiply.rs
+++ b/clippy_lints/src/neg_multiply.rs
@@ -1,8 +1,9 @@
 use clippy_utils::consts::{self, Constant};
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet_with_applicability;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
-use rustc_hir::{BinOpKind, Expr, ExprKind, QPath, UnOp};
+use rustc_hir::{BinOpKind, Expr, ExprKind, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
@@ -28,7 +29,7 @@ declare_clippy_lint! {
     #[clippy::version = "pre 1.29.0"]
     pub NEG_MULTIPLY,
     style,
-    "multiplying integers with `-1`"
+    "multiplying integers by `-1`"
 }
 
 declare_lint_pass!(NegMultiply => [NEG_MULTIPLY]);
@@ -54,17 +55,15 @@ fn check_mul(cx: &LateContext<'_>, span: Span, lit: &Expr<'_>, exp: &Expr<'_>) {
         if let ExprKind::Lit(ref l) = lit.kind;
         if consts::lit_to_constant(&l.node, cx.typeck_results().expr_ty_opt(lit)) == Constant::Int(1);
         if cx.typeck_results().expr_ty(exp).is_integral();
-        if let ExprKind::Path(QPath::Resolved(_, var_path)) = exp.kind;
 
         then {
-            let var_name = var_path.segments[0].ident.name.as_str();
-            let suggestion = format!("-{var}",var=var_name);
-            let applicability = Applicability::MachineApplicable;
+            let mut applicability = Applicability::MachineApplicable;
+            let suggestion = format!("-{}", snippet_with_applicability(cx, exp.span, "..", &mut applicability));
             span_lint_and_sugg(
                     cx,
                     NEG_MULTIPLY,
                     span,
-                    "this `multiplication with -1` can be written more succinctly",
+                    "this multiplication by -1 can be written more succinctly",
                     "consider using",
                     suggestion,
                     applicability,
diff --git a/tests/ui/neg_multiply.fixed b/tests/ui/neg_multiply.fixed
new file mode 100644
index 00000000000..8546173cfd5
--- /dev/null
+++ b/tests/ui/neg_multiply.fixed
@@ -0,0 +1,44 @@
+// run-rustfix
+#![warn(clippy::neg_multiply)]
+#![allow(clippy::no_effect, clippy::unnecessary_operation)]
+
+use std::ops::Mul;
+
+struct X;
+
+impl Mul<isize> for X {
+    type Output = X;
+
+    fn mul(self, _r: isize) -> Self {
+        self
+    }
+}
+
+impl Mul<X> for isize {
+    type Output = X;
+
+    fn mul(self, _r: X) -> X {
+        X
+    }
+}
+
+fn main() {
+    let x = 0;
+
+    -x;
+
+    -x;
+
+    100 + -x;
+
+    -(100 + x);
+
+    -17;
+
+    0xcafe | -0xff00;
+
+    -1 * -1; // should be ok
+
+    X * -1; // should be ok
+    -1 * X; // should also be ok
+}
diff --git a/tests/ui/neg_multiply.rs b/tests/ui/neg_multiply.rs
index d4a20ce9db1..9f48e4d9c12 100644
--- a/tests/ui/neg_multiply.rs
+++ b/tests/ui/neg_multiply.rs
@@ -1,3 +1,4 @@
+// run-rustfix
 #![warn(clippy::neg_multiply)]
 #![allow(clippy::no_effect, clippy::unnecessary_operation)]
 
@@ -28,6 +29,14 @@ fn main() {
 
     -1 * x;
 
+    100 + x * -1;
+
+    (100 + x) * -1;
+
+    -1 * 17;
+
+    0xcafe | 0xff00 * -1;
+
     -1 * -1; // should be ok
 
     X * -1; // should be ok
diff --git a/tests/ui/neg_multiply.stderr b/tests/ui/neg_multiply.stderr
index ce5f46fca56..0a4bc074295 100644
--- a/tests/ui/neg_multiply.stderr
+++ b/tests/ui/neg_multiply.stderr
@@ -1,16 +1,48 @@
-error: this `multiplication with -1` can be written more succinctly
-  --> $DIR/neg_multiply.rs:27:5
+error: operator precedence can trip the unwary
+  --> $DIR/neg_multiply.rs:38:5
+   |
+LL |     0xcafe | 0xff00 * -1;
+   |     ^^^^^^^^^^^^^^^^^^^^ help: consider parenthesizing your expression: `0xcafe | (0xff00 * -1)`
+   |
+   = note: `-D clippy::precedence` implied by `-D warnings`
+
+error: this multiplication by -1 can be written more succinctly
+  --> $DIR/neg_multiply.rs:28:5
    |
 LL |     x * -1;
    |     ^^^^^^ help: consider using: `-x`
    |
    = note: `-D clippy::neg-multiply` implied by `-D warnings`
 
-error: this `multiplication with -1` can be written more succinctly
-  --> $DIR/neg_multiply.rs:29:5
+error: this multiplication by -1 can be written more succinctly
+  --> $DIR/neg_multiply.rs:30:5
    |
 LL |     -1 * x;
    |     ^^^^^^ help: consider using: `-x`
 
-error: aborting due to 2 previous errors
+error: this multiplication by -1 can be written more succinctly
+  --> $DIR/neg_multiply.rs:32:11
+   |
+LL |     100 + x * -1;
+   |           ^^^^^^ help: consider using: `-x`
+
+error: this multiplication by -1 can be written more succinctly
+  --> $DIR/neg_multiply.rs:34:5
+   |
+LL |     (100 + x) * -1;
+   |     ^^^^^^^^^^^^^^ help: consider using: `-(100 + x)`
+
+error: this multiplication by -1 can be written more succinctly
+  --> $DIR/neg_multiply.rs:36:5
+   |
+LL |     -1 * 17;
+   |     ^^^^^^^ help: consider using: `-17`
+
+error: this multiplication by -1 can be written more succinctly
+  --> $DIR/neg_multiply.rs:38:14
+   |
+LL |     0xcafe | 0xff00 * -1;
+   |              ^^^^^^^^^^^ help: consider using: `-0xff00`
+
+error: aborting due to 7 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 79cf41297af69b2e46be6ad77986ebe2a41a4667 Mon Sep 17 00:00:00 2001
From: Piotr Mikulski <piotr@near.org>
Date: Thu, 23 Dec 2021 19:13:57 -0800
Subject: Imrpove `unwrap_or_else_default`

---
 clippy_lints/src/methods/unwrap_or_else_default.rs | 5 +++--
 tests/ui/unwrap_or_else_default.fixed              | 3 +++
 tests/ui/unwrap_or_else_default.rs                 | 3 +++
 3 files changed, 9 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/unwrap_or_else_default.rs b/clippy_lints/src/methods/unwrap_or_else_default.rs
index 276467b1dfd..4811048439c 100644
--- a/clippy_lints/src/methods/unwrap_or_else_default.rs
+++ b/clippy_lints/src/methods/unwrap_or_else_default.rs
@@ -2,7 +2,8 @@
 
 use super::UNWRAP_OR_ELSE_DEFAULT;
 use clippy_utils::{
-    diagnostics::span_lint_and_sugg, is_trait_item, source::snippet_with_applicability, ty::is_type_diagnostic_item,
+    diagnostics::span_lint_and_sugg, is_default_equivalent, is_trait_item, source::snippet_with_applicability,
+    ty::is_type_diagnostic_item,
 };
 use rustc_errors::Applicability;
 use rustc_hir as hir;
@@ -24,7 +25,7 @@ pub(super) fn check<'tcx>(
 
     if_chain! {
         if is_option || is_result;
-        if is_trait_item(cx, u_arg, sym::Default);
+        if is_trait_item(cx, u_arg, sym::Default) || is_default_equivalent(cx, u_arg);
         then {
             let mut applicability = Applicability::MachineApplicable;
 
diff --git a/tests/ui/unwrap_or_else_default.fixed b/tests/ui/unwrap_or_else_default.fixed
index 7ac3f426c97..5849dc4cebb 100644
--- a/tests/ui/unwrap_or_else_default.fixed
+++ b/tests/ui/unwrap_or_else_default.fixed
@@ -66,6 +66,9 @@ fn unwrap_or_else_default() {
 
     let with_default_type = Some(1);
     with_default_type.unwrap_or_default();
+
+    let with_default_type: Option<Vec<u64>> = None;
+    with_default_type.unwrap_or_default();
 }
 
 fn main() {}
diff --git a/tests/ui/unwrap_or_else_default.rs b/tests/ui/unwrap_or_else_default.rs
index 82b727a039e..d55664990ae 100644
--- a/tests/ui/unwrap_or_else_default.rs
+++ b/tests/ui/unwrap_or_else_default.rs
@@ -66,6 +66,9 @@ fn unwrap_or_else_default() {
 
     let with_default_type = Some(1);
     with_default_type.unwrap_or_else(u64::default);
+
+    let with_default_type: Option<Vec<u64>> = None;
+    with_default_type.unwrap_or_else(Vec::new);
 }
 
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 26cc55133ea52a7909b37183d3dea724bdf1c87b Mon Sep 17 00:00:00 2001
From: Piotr Mikulski <piotr@near.org>
Date: Thu, 23 Dec 2021 21:41:00 -0800
Subject: rewrite the PR

---
 clippy_lints/src/methods/unwrap_or_else_default.rs | 25 ++++++++++++++++++----
 clippy_utils/src/lib.rs                            |  2 +-
 tests/ui/unwrap_or_else_default.fixed              |  2 +-
 tests/ui/unwrap_or_else_default.stderr             | 10 +++++++--
 4 files changed, 31 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/unwrap_or_else_default.rs b/clippy_lints/src/methods/unwrap_or_else_default.rs
index 4811048439c..5f04d8e1828 100644
--- a/clippy_lints/src/methods/unwrap_or_else_default.rs
+++ b/clippy_lints/src/methods/unwrap_or_else_default.rs
@@ -1,10 +1,11 @@
 //! Lint for `some_result_or_option.unwrap_or_else(Default::default)`
 
 use super::UNWRAP_OR_ELSE_DEFAULT;
-use clippy_utils::{
-    diagnostics::span_lint_and_sugg, is_default_equivalent, is_trait_item, source::snippet_with_applicability,
-    ty::is_type_diagnostic_item,
+use clippy_utils::{diagnostics::span_lint_and_sugg, is_trait_item, source::snippet_with_applicability, ty::is_type_diagnostic_item,
+                   is_default_equivalent_ctor, is_diag_trait_item
 };
+use rustc_hir::ExprKind;
+
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
@@ -23,9 +24,25 @@ pub(super) fn check<'tcx>(
     let is_option = is_type_diagnostic_item(cx, recv_ty, sym::Option);
     let is_result = is_type_diagnostic_item(cx, recv_ty, sym::Result);
 
+    let is_default_eq = match &u_arg.kind {
+        ExprKind::Path(qpath) => {
+            if let Some(repl_def_id) = cx.qpath_res(qpath, u_arg.hir_id).opt_def_id() {
+                if is_diag_trait_item(cx, repl_def_id, sym::Default)
+                    || is_default_equivalent_ctor(cx, repl_def_id, qpath) {
+                    true
+                } else {
+                    false
+                }
+            } else {
+                false
+            }
+        },
+        _ => {false}
+    };
+
     if_chain! {
         if is_option || is_result;
-        if is_trait_item(cx, u_arg, sym::Default) || is_default_equivalent(cx, u_arg);
+        if is_trait_item(cx, u_arg, sym::Default) || is_default_eq;
         then {
             let mut applicability = Applicability::MachineApplicable;
 
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 76f4408573b..1b56bfbe1d6 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -637,7 +637,7 @@ pub fn can_mut_borrow_both(cx: &LateContext<'_>, e1: &Expr<'_>, e2: &Expr<'_>) -
 
 /// Returns true if the `def_id` associated with the `path` is recognized as a "default-equivalent"
 /// constructor from the std library
-fn is_default_equivalent_ctor(cx: &LateContext<'_>, def_id: DefId, path: &QPath<'_>) -> bool {
+pub fn is_default_equivalent_ctor(cx: &LateContext<'_>, def_id: DefId, path: &QPath<'_>) -> bool {
     let std_types_symbols = &[
         sym::String,
         sym::Vec,
diff --git a/tests/ui/unwrap_or_else_default.fixed b/tests/ui/unwrap_or_else_default.fixed
index 5849dc4cebb..c2b9bd2c881 100644
--- a/tests/ui/unwrap_or_else_default.fixed
+++ b/tests/ui/unwrap_or_else_default.fixed
@@ -45,7 +45,7 @@ fn unwrap_or_else_default() {
     with_enum.unwrap_or_else(Enum::A);
 
     let with_new = Some(vec![1]);
-    with_new.unwrap_or_else(Vec::new);
+    with_new.unwrap_or_default();
 
     let with_err: Result<_, ()> = Ok(vec![1]);
     with_err.unwrap_or_else(make);
diff --git a/tests/ui/unwrap_or_else_default.stderr b/tests/ui/unwrap_or_else_default.stderr
index feb215b09f6..b49b7fb77c2 100644
--- a/tests/ui/unwrap_or_else_default.stderr
+++ b/tests/ui/unwrap_or_else_default.stderr
@@ -1,10 +1,16 @@
+error: use of `.unwrap_or_else(..)` to construct default value
+  --> $DIR/unwrap_or_else_default.rs:48:5
+   |
+LL |     with_new.unwrap_or_else(Vec::new);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `with_new.unwrap_or_default()`
+   |
+   = note: `-D clippy::unwrap-or-else-default` implied by `-D warnings`
+
 error: use of `.unwrap_or_else(..)` to construct default value
   --> $DIR/unwrap_or_else_default.rs:62:5
    |
 LL |     with_real_default.unwrap_or_else(<HasDefaultAndDuplicate as Default>::default);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `with_real_default.unwrap_or_default()`
-   |
-   = note: `-D clippy::unwrap-or-else-default` implied by `-D warnings`
 
 error: use of `.unwrap_or_else(..)` to construct default value
   --> $DIR/unwrap_or_else_default.rs:65:5
-- 
cgit 1.4.1-3-g733a5


From ab77c924e9e26dcaa28c0eb861d08eb3ee998b6c Mon Sep 17 00:00:00 2001
From: Piotr Mikulski <piotr@near.org>
Date: Thu, 23 Dec 2021 21:44:13 -0800
Subject: cargo dev fmt

---
 clippy_lints/src/methods/unwrap_or_else_default.rs | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/unwrap_or_else_default.rs b/clippy_lints/src/methods/unwrap_or_else_default.rs
index 5f04d8e1828..e8827b1e5af 100644
--- a/clippy_lints/src/methods/unwrap_or_else_default.rs
+++ b/clippy_lints/src/methods/unwrap_or_else_default.rs
@@ -1,8 +1,9 @@
 //! Lint for `some_result_or_option.unwrap_or_else(Default::default)`
 
 use super::UNWRAP_OR_ELSE_DEFAULT;
-use clippy_utils::{diagnostics::span_lint_and_sugg, is_trait_item, source::snippet_with_applicability, ty::is_type_diagnostic_item,
-                   is_default_equivalent_ctor, is_diag_trait_item
+use clippy_utils::{
+    diagnostics::span_lint_and_sugg, is_default_equivalent_ctor, is_diag_trait_item, is_trait_item,
+    source::snippet_with_applicability, ty::is_type_diagnostic_item,
 };
 use rustc_hir::ExprKind;
 
@@ -28,7 +29,8 @@ pub(super) fn check<'tcx>(
         ExprKind::Path(qpath) => {
             if let Some(repl_def_id) = cx.qpath_res(qpath, u_arg.hir_id).opt_def_id() {
                 if is_diag_trait_item(cx, repl_def_id, sym::Default)
-                    || is_default_equivalent_ctor(cx, repl_def_id, qpath) {
+                    || is_default_equivalent_ctor(cx, repl_def_id, qpath)
+                {
                     true
                 } else {
                     false
@@ -37,7 +39,7 @@ pub(super) fn check<'tcx>(
                 false
             }
         },
-        _ => {false}
+        _ => false,
     };
 
     if_chain! {
-- 
cgit 1.4.1-3-g733a5


From 8b19845ffb7b9b6fd760f0bf8066731028377237 Mon Sep 17 00:00:00 2001
From: Piotr Mikulski <piotr@near.org>
Date: Thu, 23 Dec 2021 21:46:21 -0800
Subject: refactor

---
 clippy_lints/src/methods/unwrap_or_else_default.rs | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/unwrap_or_else_default.rs b/clippy_lints/src/methods/unwrap_or_else_default.rs
index e8827b1e5af..cde707790ef 100644
--- a/clippy_lints/src/methods/unwrap_or_else_default.rs
+++ b/clippy_lints/src/methods/unwrap_or_else_default.rs
@@ -5,8 +5,6 @@ use clippy_utils::{
     diagnostics::span_lint_and_sugg, is_default_equivalent_ctor, is_diag_trait_item, is_trait_item,
     source::snippet_with_applicability, ty::is_type_diagnostic_item,
 };
-use rustc_hir::ExprKind;
-
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
@@ -26,7 +24,7 @@ pub(super) fn check<'tcx>(
     let is_result = is_type_diagnostic_item(cx, recv_ty, sym::Result);
 
     let is_default_eq = match &u_arg.kind {
-        ExprKind::Path(qpath) => {
+        hir::ExprKind::Path(qpath) => {
             if let Some(repl_def_id) = cx.qpath_res(qpath, u_arg.hir_id).opt_def_id() {
                 if is_diag_trait_item(cx, repl_def_id, sym::Default)
                     || is_default_equivalent_ctor(cx, repl_def_id, qpath)
-- 
cgit 1.4.1-3-g733a5


From 4b3a87f8866bf0a76a7fd63d35331be5566db791 Mon Sep 17 00:00:00 2001
From: Piotr Mikulski <piotr@near.org>
Date: Thu, 23 Dec 2021 21:47:31 -0800
Subject: clippy

---
 clippy_lints/src/methods/unwrap_or_else_default.rs | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/unwrap_or_else_default.rs b/clippy_lints/src/methods/unwrap_or_else_default.rs
index cde707790ef..14185503092 100644
--- a/clippy_lints/src/methods/unwrap_or_else_default.rs
+++ b/clippy_lints/src/methods/unwrap_or_else_default.rs
@@ -26,13 +26,8 @@ pub(super) fn check<'tcx>(
     let is_default_eq = match &u_arg.kind {
         hir::ExprKind::Path(qpath) => {
             if let Some(repl_def_id) = cx.qpath_res(qpath, u_arg.hir_id).opt_def_id() {
-                if is_diag_trait_item(cx, repl_def_id, sym::Default)
+                is_diag_trait_item(cx, repl_def_id, sym::Default)
                     || is_default_equivalent_ctor(cx, repl_def_id, qpath)
-                {
-                    true
-                } else {
-                    false
-                }
             } else {
                 false
             }
-- 
cgit 1.4.1-3-g733a5


From 01b74114824b4e0f6b94986dd93a6f481e29936c Mon Sep 17 00:00:00 2001
From: Piotr Mikulski <piotr@near.org>
Date: Thu, 23 Dec 2021 22:00:14 -0800
Subject: Refactor

---
 clippy_lints/src/methods/unwrap_or_else_default.rs | 18 +++----------
 clippy_utils/src/lib.rs                            | 31 +++++++++++++---------
 2 files changed, 21 insertions(+), 28 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/unwrap_or_else_default.rs b/clippy_lints/src/methods/unwrap_or_else_default.rs
index 14185503092..e641b5c4599 100644
--- a/clippy_lints/src/methods/unwrap_or_else_default.rs
+++ b/clippy_lints/src/methods/unwrap_or_else_default.rs
@@ -2,8 +2,8 @@
 
 use super::UNWRAP_OR_ELSE_DEFAULT;
 use clippy_utils::{
-    diagnostics::span_lint_and_sugg, is_default_equivalent_ctor, is_diag_trait_item, is_trait_item,
-    source::snippet_with_applicability, ty::is_type_diagnostic_item,
+    diagnostics::span_lint_and_sugg, is_default_equivalent_call, is_trait_item, source::snippet_with_applicability,
+    ty::is_type_diagnostic_item,
 };
 use rustc_errors::Applicability;
 use rustc_hir as hir;
@@ -23,21 +23,9 @@ pub(super) fn check<'tcx>(
     let is_option = is_type_diagnostic_item(cx, recv_ty, sym::Option);
     let is_result = is_type_diagnostic_item(cx, recv_ty, sym::Result);
 
-    let is_default_eq = match &u_arg.kind {
-        hir::ExprKind::Path(qpath) => {
-            if let Some(repl_def_id) = cx.qpath_res(qpath, u_arg.hir_id).opt_def_id() {
-                is_diag_trait_item(cx, repl_def_id, sym::Default)
-                    || is_default_equivalent_ctor(cx, repl_def_id, qpath)
-            } else {
-                false
-            }
-        },
-        _ => false,
-    };
-
     if_chain! {
         if is_option || is_result;
-        if is_trait_item(cx, u_arg, sym::Default) || is_default_eq;
+        if is_trait_item(cx, u_arg, sym::Default) || is_default_equivalent_call(cx, u_arg);
         then {
             let mut applicability = Applicability::MachineApplicable;
 
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 1b56bfbe1d6..4af870d3155 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -637,7 +637,7 @@ pub fn can_mut_borrow_both(cx: &LateContext<'_>, e1: &Expr<'_>, e2: &Expr<'_>) -
 
 /// Returns true if the `def_id` associated with the `path` is recognized as a "default-equivalent"
 /// constructor from the std library
-pub fn is_default_equivalent_ctor(cx: &LateContext<'_>, def_id: DefId, path: &QPath<'_>) -> bool {
+fn is_default_equivalent_ctor(cx: &LateContext<'_>, def_id: DefId, path: &QPath<'_>) -> bool {
     let std_types_symbols = &[
         sym::String,
         sym::Vec,
@@ -664,6 +664,22 @@ pub fn is_default_equivalent_ctor(cx: &LateContext<'_>, def_id: DefId, path: &QP
     false
 }
 
+/// Return true if the expr is equal to `Default::default` when evaluated.
+pub fn is_default_equivalent_call(cx: &LateContext<'_>, repl_func: &Expr<'_>) -> bool {
+    if_chain! {
+        if let hir::ExprKind::Path(ref repl_func_qpath) = repl_func.kind;
+        if let Some(repl_def_id) = cx.qpath_res(repl_func_qpath, repl_func.hir_id).opt_def_id();
+        if is_diag_trait_item(cx, repl_def_id, sym::Default)
+            || is_default_equivalent_ctor(cx, repl_def_id, repl_func_qpath);
+        then {
+            true
+        }
+        else {
+            false
+        }
+    }
+}
+
 /// Returns true if the expr is equal to `Default::default()` of it's type when evaluated.
 /// It doesn't cover all cases, for example indirect function calls (some of std
 /// functions are supported) but it is the best we have.
@@ -686,18 +702,7 @@ pub fn is_default_equivalent(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
                 false
             }
         },
-        ExprKind::Call(repl_func, _) => if_chain! {
-            if let ExprKind::Path(ref repl_func_qpath) = repl_func.kind;
-            if let Some(repl_def_id) = cx.qpath_res(repl_func_qpath, repl_func.hir_id).opt_def_id();
-            if is_diag_trait_item(cx, repl_def_id, sym::Default)
-                || is_default_equivalent_ctor(cx, repl_def_id, repl_func_qpath);
-            then {
-                true
-            }
-            else {
-                false
-            }
-        },
+        ExprKind::Call(repl_func, _) => is_default_equivalent_call(cx, repl_func),
         ExprKind::Path(qpath) => is_lang_ctor(cx, qpath, OptionNone),
         ExprKind::AddrOf(rustc_hir::BorrowKind::Ref, _, expr) => matches!(expr.kind, ExprKind::Array([])),
         _ => false,
-- 
cgit 1.4.1-3-g733a5


From 2a47dbc7a67ff691ccfddc7b01d07639215c900b Mon Sep 17 00:00:00 2001
From: Piotr Mikulski <piotr@near.org>
Date: Thu, 23 Dec 2021 22:12:08 -0800
Subject: Simplify code

---
 clippy_lints/src/methods/unwrap_or_else_default.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/unwrap_or_else_default.rs b/clippy_lints/src/methods/unwrap_or_else_default.rs
index e641b5c4599..f3af281d6ca 100644
--- a/clippy_lints/src/methods/unwrap_or_else_default.rs
+++ b/clippy_lints/src/methods/unwrap_or_else_default.rs
@@ -2,7 +2,7 @@
 
 use super::UNWRAP_OR_ELSE_DEFAULT;
 use clippy_utils::{
-    diagnostics::span_lint_and_sugg, is_default_equivalent_call, is_trait_item, source::snippet_with_applicability,
+    diagnostics::span_lint_and_sugg, is_default_equivalent_call, source::snippet_with_applicability,
     ty::is_type_diagnostic_item,
 };
 use rustc_errors::Applicability;
@@ -25,7 +25,7 @@ pub(super) fn check<'tcx>(
 
     if_chain! {
         if is_option || is_result;
-        if is_trait_item(cx, u_arg, sym::Default) || is_default_equivalent_call(cx, u_arg);
+        if is_default_equivalent_call(cx, u_arg);
         then {
             let mut applicability = Applicability::MachineApplicable;
 
-- 
cgit 1.4.1-3-g733a5


From 0b6d1fdea210877c54e3334c610cf7ff209e11ae Mon Sep 17 00:00:00 2001
From: hotate29 <hotate_oc@yahoo.co.jp>
Date: Wed, 15 Dec 2021 23:23:36 +0900
Subject: refactor ```Sugg::BinOp```

---
 clippy_lints/src/loops/manual_memcpy.rs          |  26 +--
 clippy_lints/src/needless_bool.rs                |  12 +-
 clippy_utils/src/sugg.rs                         | 264 +++++++++++++----------
 tests/ui/manual_memcpy/with_loop_counters.stderr |   2 +-
 4 files changed, 166 insertions(+), 138 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/manual_memcpy.rs b/clippy_lints/src/loops/manual_memcpy.rs
index aa382f8a974..c62fa5e998b 100644
--- a/clippy_lints/src/loops/manual_memcpy.rs
+++ b/clippy_lints/src/loops/manual_memcpy.rs
@@ -12,6 +12,7 @@ use rustc_hir::{BinOpKind, Block, Expr, ExprKind, HirId, Pat, PatKind, StmtKind}
 use rustc_lint::LateContext;
 use rustc_middle::ty::{self, Ty};
 use rustc_span::symbol::sym;
+use std::fmt::Display;
 use std::iter::Iterator;
 
 /// Checks for for loops that sequentially copy items from one slice-like
@@ -108,7 +109,7 @@ fn build_manual_memcpy_suggestion<'tcx>(
     src: &IndexExpr<'_>,
 ) -> String {
     fn print_offset(offset: MinifyingSugg<'static>) -> MinifyingSugg<'static> {
-        if offset.as_str() == "0" {
+        if offset.to_string() == "0" {
             sugg::EMPTY.into()
         } else {
             offset
@@ -123,7 +124,7 @@ fn build_manual_memcpy_suggestion<'tcx>(
             if let Some(arg) = len_args.get(0);
             if path_to_local(arg) == path_to_local(base);
             then {
-                if sugg.as_str() == end_str {
+                if sugg.to_string() == end_str {
                     sugg::EMPTY.into()
                 } else {
                     sugg
@@ -147,7 +148,7 @@ fn build_manual_memcpy_suggestion<'tcx>(
             print_offset(apply_offset(&start_str, &idx_expr.idx_offset)).into_sugg(),
             print_limit(
                 end,
-                end_str.as_str(),
+                end_str.to_string().as_str(),
                 idx_expr.base,
                 apply_offset(&end_str, &idx_expr.idx_offset),
             )
@@ -159,7 +160,7 @@ fn build_manual_memcpy_suggestion<'tcx>(
                 print_offset(apply_offset(&counter_start, &idx_expr.idx_offset)).into_sugg(),
                 print_limit(
                     end,
-                    end_str.as_str(),
+                    end_str.to_string().as_str(),
                     idx_expr.base,
                     apply_offset(&end_str, &idx_expr.idx_offset) + &counter_start - &start_str,
                 )
@@ -202,12 +203,13 @@ fn build_manual_memcpy_suggestion<'tcx>(
 #[derive(Clone)]
 struct MinifyingSugg<'a>(Sugg<'a>);
 
-impl<'a> MinifyingSugg<'a> {
-    fn as_str(&self) -> &str {
-        let (Sugg::NonParen(s) | Sugg::MaybeParen(s) | Sugg::BinOp(_, s)) = &self.0;
-        s.as_ref()
+impl Display for MinifyingSugg<'a> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        self.0.fmt(f)
     }
+}
 
+impl<'a> MinifyingSugg<'a> {
     fn into_sugg(self) -> Sugg<'a> {
         self.0
     }
@@ -222,7 +224,7 @@ impl<'a> From<Sugg<'a>> for MinifyingSugg<'a> {
 impl std::ops::Add for &MinifyingSugg<'static> {
     type Output = MinifyingSugg<'static>;
     fn add(self, rhs: &MinifyingSugg<'static>) -> MinifyingSugg<'static> {
-        match (self.as_str(), rhs.as_str()) {
+        match (self.to_string().as_str(), rhs.to_string().as_str()) {
             ("0", _) => rhs.clone(),
             (_, "0") => self.clone(),
             (_, _) => (&self.0 + &rhs.0).into(),
@@ -233,7 +235,7 @@ impl std::ops::Add for &MinifyingSugg<'static> {
 impl std::ops::Sub for &MinifyingSugg<'static> {
     type Output = MinifyingSugg<'static>;
     fn sub(self, rhs: &MinifyingSugg<'static>) -> MinifyingSugg<'static> {
-        match (self.as_str(), rhs.as_str()) {
+        match (self.to_string().as_str(), rhs.to_string().as_str()) {
             (_, "0") => self.clone(),
             ("0", _) => (-rhs.0.clone()).into(),
             (x, y) if x == y => sugg::ZERO.into(),
@@ -245,7 +247,7 @@ impl std::ops::Sub for &MinifyingSugg<'static> {
 impl std::ops::Add<&MinifyingSugg<'static>> for MinifyingSugg<'static> {
     type Output = MinifyingSugg<'static>;
     fn add(self, rhs: &MinifyingSugg<'static>) -> MinifyingSugg<'static> {
-        match (self.as_str(), rhs.as_str()) {
+        match (self.to_string().as_str(), rhs.to_string().as_str()) {
             ("0", _) => rhs.clone(),
             (_, "0") => self,
             (_, _) => (self.0 + &rhs.0).into(),
@@ -256,7 +258,7 @@ impl std::ops::Add<&MinifyingSugg<'static>> for MinifyingSugg<'static> {
 impl std::ops::Sub<&MinifyingSugg<'static>> for MinifyingSugg<'static> {
     type Output = MinifyingSugg<'static>;
     fn sub(self, rhs: &MinifyingSugg<'static>) -> MinifyingSugg<'static> {
-        match (self.as_str(), rhs.as_str()) {
+        match (self.to_string().as_str(), rhs.to_string().as_str()) {
             (_, "0") => self,
             ("0", _) => (-rhs.0.clone()).into(),
             (x, y) if x == y => sugg::ZERO.into(),
diff --git a/clippy_lints/src/needless_bool.rs b/clippy_lints/src/needless_bool.rs
index d391fbecf82..778d49cb4b6 100644
--- a/clippy_lints/src/needless_bool.rs
+++ b/clippy_lints/src/needless_bool.rs
@@ -187,14 +187,14 @@ impl<'tcx> LateLintPass<'tcx> for BoolComparison {
                 BinOpKind::Eq => {
                     let true_case = Some((|h| h, "equality checks against true are unnecessary"));
                     let false_case = Some((
-                        |h: Sugg<'_>| !h,
+                        |h: Sugg<'tcx>| !h,
                         "equality checks against false can be replaced by a negation",
                     ));
                     check_comparison(cx, e, true_case, false_case, true_case, false_case, ignore_no_literal);
                 },
                 BinOpKind::Ne => {
                     let true_case = Some((
-                        |h: Sugg<'_>| !h,
+                        |h: Sugg<'tcx>| !h,
                         "inequality checks against true can be replaced by a negation",
                     ));
                     let false_case = Some((|h| h, "inequality checks against false are unnecessary"));
@@ -206,12 +206,12 @@ impl<'tcx> LateLintPass<'tcx> for BoolComparison {
                     ignore_case,
                     Some((|h| h, "greater than checks against false are unnecessary")),
                     Some((
-                        |h: Sugg<'_>| !h,
+                        |h: Sugg<'tcx>| !h,
                         "less than comparison against true can be replaced by a negation",
                     )),
                     ignore_case,
                     Some((
-                        |l: Sugg<'_>, r: Sugg<'_>| (!l).bit_and(&r),
+                        |l: Sugg<'tcx>, r: Sugg<'tcx>| (!l).bit_and(&r),
                         "order comparisons between booleans can be simplified",
                     )),
                 ),
@@ -219,14 +219,14 @@ impl<'tcx> LateLintPass<'tcx> for BoolComparison {
                     cx,
                     e,
                     Some((
-                        |h: Sugg<'_>| !h,
+                        |h: Sugg<'tcx>| !h,
                         "less than comparison against true can be replaced by a negation",
                     )),
                     ignore_case,
                     ignore_case,
                     Some((|h| h, "greater than checks against false are unnecessary")),
                     Some((
-                        |l: Sugg<'_>, r: Sugg<'_>| l.bit_and(&(!r)),
+                        |l: Sugg<'tcx>, r: Sugg<'tcx>| l.bit_and(&(!r)),
                         "order comparisons between booleans can be simplified",
                     )),
                 ),
diff --git a/clippy_utils/src/sugg.rs b/clippy_utils/src/sugg.rs
index 8989872cbce..0a240a8b763 100644
--- a/clippy_utils/src/sugg.rs
+++ b/clippy_utils/src/sugg.rs
@@ -1,9 +1,7 @@
 //! Contains utility functions to generate suggestions.
 #![deny(clippy::missing_docs_in_private_items)]
 
-use crate::source::{
-    snippet, snippet_opt, snippet_with_applicability, snippet_with_context, snippet_with_macro_callsite,
-};
+use crate::source::{snippet, snippet_opt, snippet_with_applicability, snippet_with_macro_callsite};
 use crate::{get_parent_expr_for_hir, higher};
 use rustc_ast::util::parser::AssocOp;
 use rustc_ast::{ast, token};
@@ -33,7 +31,7 @@ pub enum Sugg<'a> {
     MaybeParen(Cow<'a, str>),
     /// A binary operator expression, including `as`-casts and explicit type
     /// coercion.
-    BinOp(AssocOp, Cow<'a, str>),
+    BinOp(AssocOp, Cow<'a, str>, Cow<'a, str>),
 }
 
 /// Literal constant `0`, for convenience.
@@ -46,7 +44,8 @@ pub const EMPTY: Sugg<'static> = Sugg::NonParen(Cow::Borrowed(""));
 impl Display for Sugg<'_> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
         match *self {
-            Sugg::NonParen(ref s) | Sugg::MaybeParen(ref s) | Sugg::BinOp(_, ref s) => s.fmt(f),
+            Sugg::NonParen(ref s) | Sugg::MaybeParen(ref s) => s.fmt(f),
+            Sugg::BinOp(op, ref lhs, ref rhs) => binop_to_string(op, lhs, rhs).fmt(f),
         }
     }
 }
@@ -55,10 +54,8 @@ impl Display for Sugg<'_> {
 impl<'a> Sugg<'a> {
     /// Prepare a suggestion from an expression.
     pub fn hir_opt(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> Option<Self> {
-        snippet_opt(cx, expr.span).map(|snippet| {
-            let snippet = Cow::Owned(snippet);
-            Self::hir_from_snippet(expr, snippet)
-        })
+        let get_snippet = |span| snippet(cx, span, "");
+        snippet_opt(cx, expr.span).map(|_| Self::hir_from_snippet(expr, get_snippet))
     }
 
     /// Convenience function around `hir_opt` for suggestions with a default
@@ -93,9 +90,8 @@ impl<'a> Sugg<'a> {
 
     /// Same as `hir`, but will use the pre expansion span if the `expr` was in a macro.
     pub fn hir_with_macro_callsite(cx: &LateContext<'_>, expr: &hir::Expr<'_>, default: &'a str) -> Self {
-        let snippet = snippet_with_macro_callsite(cx, expr.span, default);
-
-        Self::hir_from_snippet(expr, snippet)
+        let get_snippet = |span| snippet_with_macro_callsite(cx, span, default);
+        Self::hir_from_snippet(expr, get_snippet)
     }
 
     /// Same as `hir`, but first walks the span up to the given context. This will result in the
@@ -112,24 +108,26 @@ impl<'a> Sugg<'a> {
         default: &'a str,
         applicability: &mut Applicability,
     ) -> Self {
-        let (snippet, in_macro) = snippet_with_context(cx, expr.span, ctxt, default, applicability);
-
-        if in_macro {
-            Sugg::NonParen(snippet)
+        if expr.span.ctxt() == ctxt {
+            Self::hir_from_snippet(expr, |span| snippet(cx, span, default))
         } else {
-            Self::hir_from_snippet(expr, snippet)
+            let snip = snippet_with_applicability(cx, expr.span, default, applicability);
+            Sugg::NonParen(snip)
         }
     }
 
     /// Generate a suggestion for an expression with the given snippet. This is used by the `hir_*`
     /// function variants of `Sugg`, since these use different snippet functions.
-    fn hir_from_snippet(expr: &hir::Expr<'_>, snippet: Cow<'a, str>) -> Self {
+    fn hir_from_snippet(expr: &hir::Expr<'_>, get_snippet: impl Fn(Span) -> Cow<'a, str>) -> Self {
         if let Some(range) = higher::Range::hir(expr) {
             let op = match range.limits {
                 ast::RangeLimits::HalfOpen => AssocOp::DotDot,
                 ast::RangeLimits::Closed => AssocOp::DotDotEq,
             };
-            return Sugg::BinOp(op, snippet);
+            let start = range.start.map_or("".into(), |expr| get_snippet(expr.span));
+            let end = range.end.map_or("".into(), |expr| get_snippet(expr.span));
+
+            return Sugg::BinOp(op, start, end);
         }
 
         match expr.kind {
@@ -139,7 +137,7 @@ impl<'a> Sugg<'a> {
             | hir::ExprKind::Let(..)
             | hir::ExprKind::Closure(..)
             | hir::ExprKind::Unary(..)
-            | hir::ExprKind::Match(..) => Sugg::MaybeParen(snippet),
+            | hir::ExprKind::Match(..) => Sugg::MaybeParen(get_snippet(expr.span)),
             hir::ExprKind::Continue(..)
             | hir::ExprKind::Yield(..)
             | hir::ExprKind::Array(..)
@@ -160,12 +158,20 @@ impl<'a> Sugg<'a> {
             | hir::ExprKind::Struct(..)
             | hir::ExprKind::Tup(..)
             | hir::ExprKind::DropTemps(_)
-            | hir::ExprKind::Err => Sugg::NonParen(snippet),
-            hir::ExprKind::Assign(..) => Sugg::BinOp(AssocOp::Assign, snippet),
-            hir::ExprKind::AssignOp(op, ..) => Sugg::BinOp(hirbinop2assignop(op), snippet),
-            hir::ExprKind::Binary(op, ..) => Sugg::BinOp(AssocOp::from_ast_binop(op.node.into()), snippet),
-            hir::ExprKind::Cast(..) => Sugg::BinOp(AssocOp::As, snippet),
-            hir::ExprKind::Type(..) => Sugg::BinOp(AssocOp::Colon, snippet),
+            | hir::ExprKind::Err => Sugg::NonParen(get_snippet(expr.span)),
+            hir::ExprKind::Assign(lhs, rhs, _) => {
+                Sugg::BinOp(AssocOp::Assign, get_snippet(lhs.span), get_snippet(rhs.span))
+            },
+            hir::ExprKind::AssignOp(op, lhs, rhs) => {
+                Sugg::BinOp(hirbinop2assignop(op), get_snippet(lhs.span), get_snippet(rhs.span))
+            },
+            hir::ExprKind::Binary(op, lhs, rhs) => Sugg::BinOp(
+                AssocOp::from_ast_binop(op.node.into()),
+                get_snippet(lhs.span),
+                get_snippet(rhs.span),
+            ),
+            hir::ExprKind::Cast(lhs, ty) => Sugg::BinOp(AssocOp::As, get_snippet(lhs.span), get_snippet(ty.span)),
+            hir::ExprKind::Type(lhs, ty) => Sugg::BinOp(AssocOp::Colon, get_snippet(lhs.span), get_snippet(ty.span)),
         }
     }
 
@@ -173,10 +179,12 @@ impl<'a> Sugg<'a> {
     pub fn ast(cx: &EarlyContext<'_>, expr: &ast::Expr, default: &'a str) -> Self {
         use rustc_ast::ast::RangeLimits;
 
-        let snippet = if expr.span.from_expansion() {
-            snippet_with_macro_callsite(cx, expr.span, default)
-        } else {
-            snippet(cx, expr.span, default)
+        let get_whole_snippet = || {
+            if expr.span.from_expansion() {
+                snippet_with_macro_callsite(cx, expr.span, default)
+            } else {
+                snippet(cx, expr.span, default)
+            }
         };
 
         match expr.kind {
@@ -186,7 +194,7 @@ impl<'a> Sugg<'a> {
             | ast::ExprKind::If(..)
             | ast::ExprKind::Let(..)
             | ast::ExprKind::Unary(..)
-            | ast::ExprKind::Match(..) => Sugg::MaybeParen(snippet),
+            | ast::ExprKind::Match(..) => Sugg::MaybeParen(get_whole_snippet()),
             ast::ExprKind::Async(..)
             | ast::ExprKind::Block(..)
             | ast::ExprKind::Break(..)
@@ -215,14 +223,42 @@ impl<'a> Sugg<'a> {
             | ast::ExprKind::Array(..)
             | ast::ExprKind::While(..)
             | ast::ExprKind::Await(..)
-            | ast::ExprKind::Err => Sugg::NonParen(snippet),
-            ast::ExprKind::Range(.., RangeLimits::HalfOpen) => Sugg::BinOp(AssocOp::DotDot, snippet),
-            ast::ExprKind::Range(.., RangeLimits::Closed) => Sugg::BinOp(AssocOp::DotDotEq, snippet),
-            ast::ExprKind::Assign(..) => Sugg::BinOp(AssocOp::Assign, snippet),
-            ast::ExprKind::AssignOp(op, ..) => Sugg::BinOp(astbinop2assignop(op), snippet),
-            ast::ExprKind::Binary(op, ..) => Sugg::BinOp(AssocOp::from_ast_binop(op.node), snippet),
-            ast::ExprKind::Cast(..) => Sugg::BinOp(AssocOp::As, snippet),
-            ast::ExprKind::Type(..) => Sugg::BinOp(AssocOp::Colon, snippet),
+            | ast::ExprKind::Err => Sugg::NonParen(get_whole_snippet()),
+            ast::ExprKind::Range(ref lhs, ref rhs, RangeLimits::HalfOpen) => Sugg::BinOp(
+                AssocOp::DotDot,
+                lhs.as_ref().map_or("".into(), |lhs| snippet(cx, lhs.span, default)),
+                rhs.as_ref().map_or("".into(), |rhs| snippet(cx, rhs.span, default)),
+            ),
+            ast::ExprKind::Range(ref lhs, ref rhs, RangeLimits::Closed) => Sugg::BinOp(
+                AssocOp::DotDotEq,
+                lhs.as_ref().map_or("".into(), |lhs| snippet(cx, lhs.span, default)),
+                rhs.as_ref().map_or("".into(), |rhs| snippet(cx, rhs.span, default)),
+            ),
+            ast::ExprKind::Assign(ref lhs, ref rhs, _) => Sugg::BinOp(
+                AssocOp::Assign,
+                snippet(cx, lhs.span, default),
+                snippet(cx, rhs.span, default),
+            ),
+            ast::ExprKind::AssignOp(op, ref lhs, ref rhs) => Sugg::BinOp(
+                astbinop2assignop(op),
+                snippet(cx, lhs.span, default),
+                snippet(cx, rhs.span, default),
+            ),
+            ast::ExprKind::Binary(op, ref lhs, ref rhs) => Sugg::BinOp(
+                AssocOp::from_ast_binop(op.node),
+                snippet(cx, lhs.span, default),
+                snippet(cx, rhs.span, default),
+            ),
+            ast::ExprKind::Cast(ref lhs, ref ty) => Sugg::BinOp(
+                AssocOp::As,
+                snippet(cx, lhs.span, default),
+                snippet(cx, ty.span, default),
+            ),
+            ast::ExprKind::Type(ref lhs, ref ty) => Sugg::BinOp(
+                AssocOp::Colon,
+                snippet(cx, lhs.span, default),
+                snippet(cx, ty.span, default),
+            ),
         }
     }
 
@@ -306,17 +342,51 @@ impl<'a> Sugg<'a> {
                     Sugg::NonParen(format!("({})", sugg).into())
                 }
             },
-            Sugg::BinOp(_, sugg) => {
-                if has_enclosing_paren(&sugg) {
-                    Sugg::NonParen(sugg)
-                } else {
-                    Sugg::NonParen(format!("({})", sugg).into())
-                }
+            Sugg::BinOp(op, lhs, rhs) => {
+                let sugg = binop_to_string(op, &lhs, &rhs);
+                Sugg::NonParen(format!("({})", sugg).into())
             },
         }
     }
 }
 
+/// Generates a string from the operator and both sides.
+fn binop_to_string(op: AssocOp, lhs: &str, rhs: &str) -> String {
+    match op {
+        AssocOp::Add
+        | AssocOp::Subtract
+        | AssocOp::Multiply
+        | AssocOp::Divide
+        | AssocOp::Modulus
+        | AssocOp::LAnd
+        | AssocOp::LOr
+        | AssocOp::BitXor
+        | AssocOp::BitAnd
+        | AssocOp::BitOr
+        | AssocOp::ShiftLeft
+        | AssocOp::ShiftRight
+        | AssocOp::Equal
+        | AssocOp::Less
+        | AssocOp::LessEqual
+        | AssocOp::NotEqual
+        | AssocOp::Greater
+        | AssocOp::GreaterEqual => format!(
+            "{} {} {}",
+            lhs,
+            op.to_ast_binop().expect("Those are AST ops").to_string(),
+            rhs
+        ),
+        AssocOp::Assign => format!("{} = {}", lhs, rhs),
+        AssocOp::AssignOp(op) => {
+            format!("{} {}= {}", lhs, token_kind_to_string(&token::BinOp(op)), rhs)
+        },
+        AssocOp::As => format!("{} as {}", lhs, rhs),
+        AssocOp::DotDot => format!("{}..{}", lhs, rhs),
+        AssocOp::DotDotEq => format!("{}..={}", lhs, rhs),
+        AssocOp::Colon => format!("{}: {}", lhs, rhs),
+    }
+}
+
 /// Return `true` if `sugg` is enclosed in parenthesis.
 fn has_enclosing_paren(sugg: impl AsRef<str>) -> bool {
     let mut chars = sugg.as_ref().chars();
@@ -391,34 +461,22 @@ impl Neg for Sugg<'_> {
     }
 }
 
-impl Not for Sugg<'_> {
-    type Output = Sugg<'static>;
-    fn not(self) -> Sugg<'static> {
+impl Not for Sugg<'a> {
+    type Output = Sugg<'a>;
+    fn not(self) -> Sugg<'a> {
         use AssocOp::{Equal, Greater, GreaterEqual, Less, LessEqual, NotEqual};
 
-        /// Convert ```AssocOp``` to a string of operators.
-        fn op_as_str(op: AssocOp) -> &'static str {
-            op.to_ast_binop().unwrap().to_string()
-        }
-
-        /// Replace the operator in the Snippet.
-        fn replace_op(from_op: AssocOp, to_op: AssocOp, snip: Cow<'_, str>) -> Sugg<'static> {
-            let from = op_as_str(from_op);
-            let to = op_as_str(to_op);
-            let snip = snip.into_owned().replace(from, to);
-            Sugg::BinOp(to_op, Cow::Owned(snip))
-        }
-
-        if let Sugg::BinOp(op, snip) = self {
-            match op {
-                Equal => replace_op(op, NotEqual, snip),
-                NotEqual => replace_op(op, Equal, snip),
-                Less => replace_op(op, GreaterEqual, snip),
-                GreaterEqual => replace_op(op, Less, snip),
-                Greater => replace_op(op, LessEqual, snip),
-                LessEqual => replace_op(op, Greater, snip),
-                _ => make_unop("!", Sugg::BinOp(op, snip)),
-            }
+        if let Sugg::BinOp(op, lhs, rhs) = self {
+            let to_op = match op {
+                Equal => NotEqual,
+                NotEqual => Equal,
+                Less => GreaterEqual,
+                GreaterEqual => Less,
+                Greater => LessEqual,
+                LessEqual => Greater,
+                _ => return make_unop("!", Sugg::BinOp(op, lhs, rhs)),
+            };
+            Sugg::BinOp(to_op, lhs, rhs)
         } else {
             make_unop("!", self)
         }
@@ -490,53 +548,21 @@ pub fn make_assoc(op: AssocOp, lhs: &Sugg<'_>, rhs: &Sugg<'_>) -> Sugg<'static>
             || is_shift(other) && is_arith(op)
     }
 
-    let lhs_paren = if let Sugg::BinOp(lop, _) = *lhs {
+    let lhs_paren = if let Sugg::BinOp(lop, _, _) = *lhs {
         needs_paren(op, lop, Associativity::Left)
     } else {
         false
     };
 
-    let rhs_paren = if let Sugg::BinOp(rop, _) = *rhs {
+    let rhs_paren = if let Sugg::BinOp(rop, _, _) = *rhs {
         needs_paren(op, rop, Associativity::Right)
     } else {
         false
     };
 
-    let lhs = ParenHelper::new(lhs_paren, lhs);
-    let rhs = ParenHelper::new(rhs_paren, rhs);
-    let sugg = match op {
-        AssocOp::Add
-        | AssocOp::BitAnd
-        | AssocOp::BitOr
-        | AssocOp::BitXor
-        | AssocOp::Divide
-        | AssocOp::Equal
-        | AssocOp::Greater
-        | AssocOp::GreaterEqual
-        | AssocOp::LAnd
-        | AssocOp::LOr
-        | AssocOp::Less
-        | AssocOp::LessEqual
-        | AssocOp::Modulus
-        | AssocOp::Multiply
-        | AssocOp::NotEqual
-        | AssocOp::ShiftLeft
-        | AssocOp::ShiftRight
-        | AssocOp::Subtract => format!(
-            "{} {} {}",
-            lhs,
-            op.to_ast_binop().expect("Those are AST ops").to_string(),
-            rhs
-        ),
-        AssocOp::Assign => format!("{} = {}", lhs, rhs),
-        AssocOp::AssignOp(op) => format!("{} {}= {}", lhs, token_kind_to_string(&token::BinOp(op)), rhs),
-        AssocOp::As => format!("{} as {}", lhs, rhs),
-        AssocOp::DotDot => format!("{}..{}", lhs, rhs),
-        AssocOp::DotDotEq => format!("{}..={}", lhs, rhs),
-        AssocOp::Colon => format!("{}: {}", lhs, rhs),
-    };
-
-    Sugg::BinOp(op, sugg.into())
+    let lhs = ParenHelper::new(lhs_paren, lhs).to_string();
+    let rhs = ParenHelper::new(rhs_paren, rhs).to_string();
+    Sugg::BinOp(op, lhs.into(), rhs.into())
 }
 
 /// Convenience wrapper around `make_assoc` and `AssocOp::from_ast_binop`.
@@ -1034,10 +1060,10 @@ mod test {
 
     #[test]
     fn binop_maybe_par() {
-        let sugg = Sugg::BinOp(AssocOp::Add, "(1 + 1)".into());
+        let sugg = Sugg::BinOp(AssocOp::Add, "1".into(), "1".into());
         assert_eq!("(1 + 1)", sugg.maybe_par().to_string());
 
-        let sugg = Sugg::BinOp(AssocOp::Add, "(1 + 1) + (1 + 1)".into());
+        let sugg = Sugg::BinOp(AssocOp::Add, "(1 + 1)".into(), "(1 + 1)".into());
         assert_eq!("((1 + 1) + (1 + 1))", sugg.maybe_par().to_string());
     }
     #[test]
@@ -1045,32 +1071,32 @@ mod test {
         use AssocOp::{Add, Equal, Greater, GreaterEqual, LAnd, LOr, Less, LessEqual, NotEqual};
 
         // Invert the comparison operator.
-        let sugg = Sugg::BinOp(Equal, "1 == 1".into());
+        let sugg = Sugg::BinOp(Equal, "1".into(), "1".into());
         assert_eq!("1 != 1", (!sugg).to_string());
 
-        let sugg = Sugg::BinOp(NotEqual, "1 != 1".into());
+        let sugg = Sugg::BinOp(NotEqual, "1".into(), "1".into());
         assert_eq!("1 == 1", (!sugg).to_string());
 
-        let sugg = Sugg::BinOp(Less, "1 < 1".into());
+        let sugg = Sugg::BinOp(Less, "1".into(), "1".into());
         assert_eq!("1 >= 1", (!sugg).to_string());
 
-        let sugg = Sugg::BinOp(LessEqual, "1 <= 1".into());
+        let sugg = Sugg::BinOp(LessEqual, "1".into(), "1".into());
         assert_eq!("1 > 1", (!sugg).to_string());
 
-        let sugg = Sugg::BinOp(Greater, "1 > 1".into());
+        let sugg = Sugg::BinOp(Greater, "1".into(), "1".into());
         assert_eq!("1 <= 1", (!sugg).to_string());
 
-        let sugg = Sugg::BinOp(GreaterEqual, "1 >= 1".into());
+        let sugg = Sugg::BinOp(GreaterEqual, "1".into(), "1".into());
         assert_eq!("1 < 1", (!sugg).to_string());
 
         // Other operators are inverted like !(..).
-        let sugg = Sugg::BinOp(Add, "1 + 1".into());
+        let sugg = Sugg::BinOp(Add, "1".into(), "1".into());
         assert_eq!("!(1 + 1)", (!sugg).to_string());
 
-        let sugg = Sugg::BinOp(LAnd, "1 && 1".into());
+        let sugg = Sugg::BinOp(LAnd, "1".into(), "1".into());
         assert_eq!("!(1 && 1)", (!sugg).to_string());
 
-        let sugg = Sugg::BinOp(LOr, "1 || 1".into());
+        let sugg = Sugg::BinOp(LOr, "1".into(), "1".into());
         assert_eq!("!(1 || 1)", (!sugg).to_string());
     }
 }
diff --git a/tests/ui/manual_memcpy/with_loop_counters.stderr b/tests/ui/manual_memcpy/with_loop_counters.stderr
index 0243158dec5..2e3ebadd7b5 100644
--- a/tests/ui/manual_memcpy/with_loop_counters.stderr
+++ b/tests/ui/manual_memcpy/with_loop_counters.stderr
@@ -43,7 +43,7 @@ LL | /     for i in 3..(3 + src.len()) {
 LL | |         dst[i] = src[count];
 LL | |         count += 1;
 LL | |     }
-   | |_____^ help: try replacing the loop by: `dst[3..(3 + src.len())].clone_from_slice(&src[..((3 + src.len()) - 3)]);`
+   | |_____^ help: try replacing the loop by: `dst[3..(3 + src.len())].clone_from_slice(&src[..(3 + src.len() - 3)]);`
 
 error: it looks like you're manually copying between slices
   --> $DIR/with_loop_counters.rs:35:5
-- 
cgit 1.4.1-3-g733a5


From 07b6927180915ed6a8379c8cc9bec069d13ff0dc Mon Sep 17 00:00:00 2001
From: hotate29 <hotate_oc@yahoo.co.jp>
Date: Fri, 24 Dec 2021 23:54:15 +0900
Subject: Change ```floating_point_arthmetic::detect_hypot()``` to enclose the
 expression in parentheses.

---
 clippy_lints/src/floating_point_arithmetic.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/floating_point_arithmetic.rs b/clippy_lints/src/floating_point_arithmetic.rs
index 2de2bfc040b..06cd78582bb 100644
--- a/clippy_lints/src/floating_point_arithmetic.rs
+++ b/clippy_lints/src/floating_point_arithmetic.rs
@@ -356,7 +356,7 @@ fn detect_hypot(cx: &LateContext<'_>, args: &[Expr<'_>]) -> Option<String> {
             if eq_expr_value(cx, lmul_lhs, lmul_rhs);
             if eq_expr_value(cx, rmul_lhs, rmul_rhs);
             then {
-                return Some(format!("{}.hypot({})", Sugg::hir(cx, lmul_lhs, ".."), Sugg::hir(cx, rmul_lhs, "..")));
+                return Some(format!("{}.hypot({})", Sugg::hir(cx, lmul_lhs, "..").maybe_par(), Sugg::hir(cx, rmul_lhs, "..")));
             }
         }
 
@@ -379,7 +379,7 @@ fn detect_hypot(cx: &LateContext<'_>, args: &[Expr<'_>]) -> Option<String> {
             if let Some((rvalue, _)) = constant(cx, cx.typeck_results(), rargs_1);
             if Int(2) == lvalue && Int(2) == rvalue;
             then {
-                return Some(format!("{}.hypot({})", Sugg::hir(cx, largs_0, ".."), Sugg::hir(cx, rargs_0, "..")));
+                return Some(format!("{}.hypot({})", Sugg::hir(cx, largs_0, "..").maybe_par(), Sugg::hir(cx, rargs_0, "..")));
             }
         }
     }
-- 
cgit 1.4.1-3-g733a5


From a172439f29301d7c34645406f439f064edc58d69 Mon Sep 17 00:00:00 2001
From: hotate29 <hotate_oc@yahoo.co.jp>
Date: Tue, 21 Dec 2021 21:45:55 +0900
Subject: Change to enclose both sides of Range in parentheses.

---
 clippy_lints/src/ranges.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/ranges.rs b/clippy_lints/src/ranges.rs
index 09c64485bbb..a1e67c33abf 100644
--- a/clippy_lints/src/ranges.rs
+++ b/clippy_lints/src/ranges.rs
@@ -378,8 +378,8 @@ fn check_exclusive_range_plus_one(cx: &LateContext<'_>, expr: &Expr<'_>) {
                 span,
                 "an inclusive range would be more readable",
                 |diag| {
-                    let start = start.map_or(String::new(), |x| Sugg::hir(cx, x, "x").to_string());
-                    let end = Sugg::hir(cx, y, "y");
+                    let start = start.map_or(String::new(), |x| Sugg::hir(cx, x, "x").maybe_par().to_string());
+                    let end = Sugg::hir(cx, y, "y").maybe_par();
                     if let Some(is_wrapped) = &snippet_opt(cx, span) {
                         if is_wrapped.starts_with('(') && is_wrapped.ends_with(')') {
                             diag.span_suggestion(
@@ -415,8 +415,8 @@ fn check_inclusive_range_minus_one(cx: &LateContext<'_>, expr: &Expr<'_>) {
                 expr.span,
                 "an exclusive range would be more readable",
                 |diag| {
-                    let start = start.map_or(String::new(), |x| Sugg::hir(cx, x, "x").to_string());
-                    let end = Sugg::hir(cx, y, "y");
+                    let start = start.map_or(String::new(), |x| Sugg::hir(cx, x, "x").maybe_par().to_string());
+                    let end = Sugg::hir(cx, y, "y").maybe_par();
                     diag.span_suggestion(
                         expr.span,
                         "use",
-- 
cgit 1.4.1-3-g733a5


From 1b67aa74bdcbf3939241e19dd16ff0bcc6150d94 Mon Sep 17 00:00:00 2001
From: Elliot Bobrow <elliotgreybobrow@gmail.com>
Date: Fri, 24 Dec 2021 13:20:40 -0800
Subject: fix `shadow_reuse` false negative for if let bindings

---
 clippy_lints/src/shadow.rs |  4 ++--
 tests/ui/shadow.rs         |  2 ++
 tests/ui/shadow.stderr     | 18 +++++++++++++++---
 3 files changed, 19 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/shadow.rs b/clippy_lints/src/shadow.rs
index f6880af0cab..516cb939c15 100644
--- a/clippy_lints/src/shadow.rs
+++ b/clippy_lints/src/shadow.rs
@@ -220,14 +220,14 @@ fn is_self_shadow(cx: &LateContext<'_>, pat: &Pat<'_>, mut expr: &Expr<'_>, hir_
     }
 }
 
-/// Finds the "init" expression for a pattern: `let <pat> = <init>;` or
+/// Finds the "init" expression for a pattern: `let <pat> = <init>;` (or `if let`) or
 /// `match <init> { .., <pat> => .., .. }`
 fn find_init<'tcx>(cx: &LateContext<'tcx>, hir_id: HirId) -> Option<&'tcx Expr<'tcx>> {
     for (_, node) in cx.tcx.hir().parent_iter(hir_id) {
         let init = match node {
             Node::Arm(_) | Node::Pat(_) => continue,
             Node::Expr(expr) => match expr.kind {
-                ExprKind::Match(e, _, _) => Some(e),
+                ExprKind::Match(e, _, _) | ExprKind::Let(_, e, _) => Some(e),
                 _ => None,
             },
             Node::Local(local) => local.init,
diff --git a/tests/ui/shadow.rs b/tests/ui/shadow.rs
index 06f6949b66f..0321f8c4cdf 100644
--- a/tests/ui/shadow.rs
+++ b/tests/ui/shadow.rs
@@ -47,6 +47,8 @@ fn syntax() {
     let _ = |[x]: [u32; 1]| {
         let x = 1;
     };
+    let y = Some(1);
+    if let Some(y) = y {}
 }
 
 fn negative() {
diff --git a/tests/ui/shadow.stderr b/tests/ui/shadow.stderr
index dcc7d4e6b2f..f8b9221d555 100644
--- a/tests/ui/shadow.stderr
+++ b/tests/ui/shadow.stderr
@@ -241,17 +241,29 @@ note: previous binding is here
 LL |     let _ = |[x]: [u32; 1]| {
    |               ^
 
+error: `y` is shadowed
+  --> $DIR/shadow.rs:51:17
+   |
+LL |     if let Some(y) = y {}
+   |                 ^
+   |
+note: previous binding is here
+  --> $DIR/shadow.rs:50:9
+   |
+LL |     let y = Some(1);
+   |         ^
+
 error: `_b` shadows a previous, unrelated binding
-  --> $DIR/shadow.rs:85:9
+  --> $DIR/shadow.rs:87:9
    |
 LL |     let _b = _a;
    |         ^^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:84:28
+  --> $DIR/shadow.rs:86:28
    |
 LL | pub async fn foo2(_a: i32, _b: i64) {
    |                            ^^
 
-error: aborting due to 21 previous errors
+error: aborting due to 22 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 23ffa3ca0485bcdf1b0c553dbc134f33f16c7036 Mon Sep 17 00:00:00 2001
From: Andre Bogus <bogusandre@gmail.com>
Date: Sat, 25 Dec 2021 13:11:54 +0100
Subject: fix an ICE on unwrapping a None

---
 clippy_lints/src/casts/unnecessary_cast.rs | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/unnecessary_cast.rs b/clippy_lints/src/casts/unnecessary_cast.rs
index 9ed359922fd..1915d990c12 100644
--- a/clippy_lints/src/casts/unnecessary_cast.rs
+++ b/clippy_lints/src/casts/unnecessary_cast.rs
@@ -49,8 +49,9 @@ pub(super) fn check(
                 if cast_from.kind() == cast_to.kind() =>
             {
                 if let Some(src) = snippet_opt(cx, lit.span) {
-                    let num_lit = NumericLiteral::from_lit_kind(&src, &lit.node).unwrap();
-                    lint_unnecessary_cast(cx, expr, num_lit.integer, cast_from, cast_to);
+                    if let Some(num_lit) = NumericLiteral::from_lit_kind(&src, &lit.node) {
+                        lint_unnecessary_cast(cx, expr, num_lit.integer, cast_from, cast_to);
+                    }
                 }
             },
             _ => {
-- 
cgit 1.4.1-3-g733a5


From f327f0e2b60597b0b6b171c7cbfef5832238d3a2 Mon Sep 17 00:00:00 2001
From: dswij <dswijj@gmail.com>
Date: Wed, 15 Dec 2021 12:08:13 +0800
Subject: Refactor `enum_variants`

---
 clippy_lints/src/enum_variants.rs | 77 ++++++++++++++++++++-------------------
 1 file changed, 40 insertions(+), 37 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/enum_variants.rs b/clippy_lints/src/enum_variants.rs
index fc3a35efaf8..75cc20a5cda 100644
--- a/clippy_lints/src/enum_variants.rs
+++ b/clippy_lints/src/enum_variants.rs
@@ -3,7 +3,7 @@
 use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
 use clippy_utils::source::is_present_in_source;
 use clippy_utils::str_utils::{self, count_match_end, count_match_start};
-use rustc_hir::{EnumDef, Item, ItemKind};
+use rustc_hir::{EnumDef, Item, ItemKind, Variant};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::Span;
@@ -115,50 +115,54 @@ impl EnumVariantNames {
 }
 
 impl_lint_pass!(EnumVariantNames => [
-    ENUM_VARIANT_NAMES,
-    MODULE_NAME_REPETITIONS,
-    MODULE_INCEPTION
+                ENUM_VARIANT_NAMES,
+                MODULE_NAME_REPETITIONS,
+                MODULE_INCEPTION
 ]);
 
-fn check_variant(
-    cx: &LateContext<'_>,
-    threshold: u64,
-    def: &EnumDef<'_>,
-    item_name: &str,
-    item_name_chars: usize,
-    span: Span,
-) {
+fn check_enum_start(cx: &LateContext<'_>, item_name: &str, variant: &Variant<'_>) {
+    let name = variant.ident.name.as_str();
+    let item_name_chars = item_name.chars().count();
+
+    if count_match_start(item_name, &name).char_count == item_name_chars
+        && name.chars().nth(item_name_chars).map_or(false, |c| !c.is_lowercase())
+        && name.chars().nth(item_name_chars + 1).map_or(false, |c| !c.is_numeric())
+    {
+        span_lint(
+            cx,
+            ENUM_VARIANT_NAMES,
+            variant.span,
+            "variant name starts with the enum's name",
+        );
+    }
+}
+
+fn check_enum_end(cx: &LateContext<'_>, item_name: &str, variant: &Variant<'_>) {
+    let name = variant.ident.name.as_str();
+    let item_name_chars = item_name.chars().count();
+
+    if count_match_end(item_name, &name).char_count == item_name_chars {
+        span_lint(
+            cx,
+            ENUM_VARIANT_NAMES,
+            variant.span,
+            "variant name ends with the enum's name",
+        );
+    }
+}
+
+fn check_variant(cx: &LateContext<'_>, threshold: u64, def: &EnumDef<'_>, item_name: &str, span: Span) {
     if (def.variants.len() as u64) < threshold {
         return;
     }
-    for var in def.variants {
-        let name = var.ident.name.as_str();
-        if count_match_start(item_name, &name).char_count == item_name_chars
-            && name.chars().nth(item_name_chars).map_or(false, |c| !c.is_lowercase())
-            && name.chars().nth(item_name_chars + 1).map_or(false, |c| !c.is_numeric())
-        {
-            span_lint(
-                cx,
-                ENUM_VARIANT_NAMES,
-                var.span,
-                "variant name starts with the enum's name",
-            );
-        }
-        if count_match_end(item_name, &name).char_count == item_name_chars {
-            span_lint(
-                cx,
-                ENUM_VARIANT_NAMES,
-                var.span,
-                "variant name ends with the enum's name",
-            );
-        }
-    }
+
     let first = &def.variants[0].ident.name.as_str();
     let mut pre = &first[..str_utils::camel_case_until(&*first).byte_index];
     let mut post = &first[str_utils::camel_case_start(&*first).byte_index..];
     for var in def.variants {
+        check_enum_start(cx, item_name, var);
+        check_enum_end(cx, item_name, var);
         let name = var.ident.name.as_str();
-
         let pre_match = count_match_start(pre, &name).byte_count;
         pre = &pre[..pre_match];
         let pre_camel = str_utils::camel_case_until(pre).byte_index;
@@ -233,7 +237,6 @@ impl LateLintPass<'_> for EnumVariantNames {
     #[allow(clippy::similar_names)]
     fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
         let item_name = item.ident.name.as_str();
-        let item_name_chars = item_name.chars().count();
         let item_camel = to_camel_case(&item_name);
         if !item.span.from_expansion() && is_present_in_source(cx, item.span) {
             if let Some(&(ref mod_name, ref mod_camel)) = self.modules.last() {
@@ -283,7 +286,7 @@ impl LateLintPass<'_> for EnumVariantNames {
         }
         if let ItemKind::Enum(ref def, _) = item.kind {
             if !(self.avoid_breaking_exported_api && cx.access_levels.is_exported(item.def_id)) {
-                check_variant(cx, self.threshold, def, &item_name, item_name_chars, item.span);
+                check_variant(cx, self.threshold, def, &item_name, item.span);
             }
         }
         self.modules.push((item.ident.name, item_camel));
-- 
cgit 1.4.1-3-g733a5


From d58fdfbf3c995d241677f0dff76d30b5157d0d0f Mon Sep 17 00:00:00 2001
From: dswij <dswijj@gmail.com>
Date: Wed, 22 Dec 2021 23:18:11 +0800
Subject: Fix False Positive on `enum_variants` when prefixes are not
 camel-case

---
 clippy_lints/src/enum_variants.rs | 48 ++++++++++++++++++---------------------
 1 file changed, 22 insertions(+), 26 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/enum_variants.rs b/clippy_lints/src/enum_variants.rs
index 75cc20a5cda..9862a8c4f52 100644
--- a/clippy_lints/src/enum_variants.rs
+++ b/clippy_lints/src/enum_variants.rs
@@ -2,7 +2,7 @@
 
 use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
 use clippy_utils::source::is_present_in_source;
-use clippy_utils::str_utils::{self, count_match_end, count_match_start};
+use clippy_utils::str_utils::{camel_case_split, count_match_end, count_match_start};
 use rustc_hir::{EnumDef, Item, ItemKind, Variant};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
@@ -157,39 +157,35 @@ fn check_variant(cx: &LateContext<'_>, threshold: u64, def: &EnumDef<'_>, item_n
     }
 
     let first = &def.variants[0].ident.name.as_str();
-    let mut pre = &first[..str_utils::camel_case_until(&*first).byte_index];
-    let mut post = &first[str_utils::camel_case_start(&*first).byte_index..];
+    let mut pre = camel_case_split(first);
+    let mut post = pre.clone();
+    post.reverse();
     for var in def.variants {
         check_enum_start(cx, item_name, var);
         check_enum_end(cx, item_name, var);
         let name = var.ident.name.as_str();
-        let pre_match = count_match_start(pre, &name).byte_count;
-        pre = &pre[..pre_match];
-        let pre_camel = str_utils::camel_case_until(pre).byte_index;
-        pre = &pre[..pre_camel];
-        while let Some((next, last)) = name[pre.len()..].chars().zip(pre.chars().rev()).next() {
-            if next.is_numeric() {
-                return;
-            }
-            if next.is_lowercase() {
-                let last = pre.len() - last.len_utf8();
-                let last_camel = str_utils::camel_case_until(&pre[..last]);
-                pre = &pre[..last_camel.byte_index];
-            } else {
-                break;
-            }
-        }
 
-        let post_match = count_match_end(post, &name);
-        let post_end = post.len() - post_match.byte_count;
-        post = &post[post_end..];
-        let post_camel = str_utils::camel_case_start(post);
-        post = &post[post_camel.byte_index..];
+        let variant_split = camel_case_split(&name);
+
+        pre = pre
+            .iter()
+            .copied()
+            .zip(variant_split.iter().copied())
+            .take_while(|(a, b)| a == b)
+            .map(|e| e.0)
+            .collect();
+        post = post
+            .iter()
+            .copied()
+            .zip(variant_split.iter().rev().copied())
+            .take_while(|(a, b)| a == b)
+            .map(|e| e.0)
+            .collect();
     }
     let (what, value) = match (pre.is_empty(), post.is_empty()) {
         (true, true) => return,
-        (false, _) => ("pre", pre),
-        (true, false) => ("post", post),
+        (false, _) => ("pre", pre.join("")),
+        (true, false) => ("post", post.join("")),
     };
     span_lint_and_help(
         cx,
-- 
cgit 1.4.1-3-g733a5


From c8f016f921d8ade5bf97315d722bf24badca8519 Mon Sep 17 00:00:00 2001
From: dswij <dswijj@gmail.com>
Date: Thu, 23 Dec 2021 13:55:41 +0800
Subject: Fix reversed suggestion on postfix

---
 clippy_lints/src/enum_variants.rs | 5 ++++-
 tests/ui/enum_variants.stderr     | 4 ++--
 2 files changed, 6 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/enum_variants.rs b/clippy_lints/src/enum_variants.rs
index 9862a8c4f52..fd359b4e36f 100644
--- a/clippy_lints/src/enum_variants.rs
+++ b/clippy_lints/src/enum_variants.rs
@@ -185,7 +185,10 @@ fn check_variant(cx: &LateContext<'_>, threshold: u64, def: &EnumDef<'_>, item_n
     let (what, value) = match (pre.is_empty(), post.is_empty()) {
         (true, true) => return,
         (false, _) => ("pre", pre.join("")),
-        (true, false) => ("post", post.join("")),
+        (true, false) => {
+            post.reverse();
+            ("post", post.join(""))
+        },
     };
     span_lint_and_help(
         cx,
diff --git a/tests/ui/enum_variants.stderr b/tests/ui/enum_variants.stderr
index 82a2b3dccb0..8a3265086e8 100644
--- a/tests/ui/enum_variants.stderr
+++ b/tests/ui/enum_variants.stderr
@@ -96,7 +96,7 @@ LL | | }
    |
    = help: remove the prefixes and use full paths to the variants instead of glob imports
 
-error: all variants have the same postfix: `DataI`
+error: all variants have the same postfix: `IData`
   --> $DIR/enum_variants.rs:136:1
    |
 LL | / enum IDataRequest {
@@ -108,7 +108,7 @@ LL | | }
    |
    = help: remove the postfixes and use full paths to the variants instead of glob imports
 
-error: all variants have the same postfix: `DataIH`
+error: all variants have the same postfix: `HIData`
   --> $DIR/enum_variants.rs:142:1
    |
 LL | / enum HIDataRequest {
-- 
cgit 1.4.1-3-g733a5


From 6f7e5cbe21d99b7867d8d7383fd2ab753da1d256 Mon Sep 17 00:00:00 2001
From: dswij <dswijj@gmail.com>
Date: Fri, 24 Dec 2021 12:10:34 +0800
Subject: Some minor cleanup

---
 clippy_lints/src/enum_variants.rs | 16 ++++++-------
 clippy_utils/src/str_utils.rs     | 48 ++++++++++++++++++++++-----------------
 2 files changed, 34 insertions(+), 30 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/enum_variants.rs b/clippy_lints/src/enum_variants.rs
index fd359b4e36f..b13fd25c6e1 100644
--- a/clippy_lints/src/enum_variants.rs
+++ b/clippy_lints/src/enum_variants.rs
@@ -115,9 +115,9 @@ impl EnumVariantNames {
 }
 
 impl_lint_pass!(EnumVariantNames => [
-                ENUM_VARIANT_NAMES,
-                MODULE_NAME_REPETITIONS,
-                MODULE_INCEPTION
+    ENUM_VARIANT_NAMES,
+    MODULE_NAME_REPETITIONS,
+    MODULE_INCEPTION
 ]);
 
 fn check_enum_start(cx: &LateContext<'_>, item_name: &str, variant: &Variant<'_>) {
@@ -169,17 +169,15 @@ fn check_variant(cx: &LateContext<'_>, threshold: u64, def: &EnumDef<'_>, item_n
 
         pre = pre
             .iter()
-            .copied()
-            .zip(variant_split.iter().copied())
+            .zip(variant_split.iter())
             .take_while(|(a, b)| a == b)
-            .map(|e| e.0)
+            .map(|e| *e.0)
             .collect();
         post = post
             .iter()
-            .copied()
-            .zip(variant_split.iter().rev().copied())
+            .zip(variant_split.iter().rev())
             .take_while(|(a, b)| a == b)
-            .map(|e| e.0)
+            .map(|e| *e.0)
             .collect();
     }
     let (what, value) = match (pre.is_empty(), post.is_empty()) {
diff --git a/clippy_utils/src/str_utils.rs b/clippy_utils/src/str_utils.rs
index 7200baf5b3c..03a9d3c25fd 100644
--- a/clippy_utils/src/str_utils.rs
+++ b/clippy_utils/src/str_utils.rs
@@ -77,6 +77,9 @@ pub fn camel_case_start(s: &str) -> StrIndex {
 /// # use clippy_utils::str_utils::{camel_case_start_from_idx, StrIndex};
 /// assert_eq!(camel_case_start_from_idx("AbcDef", 0), StrIndex::new(0, 0));
 /// assert_eq!(camel_case_start_from_idx("AbcDef", 1), StrIndex::new(3, 3));
+/// assert_eq!(camel_case_start_from_idx("AbcDefGhi", 0), StrIndex::new(0, 0));
+/// assert_eq!(camel_case_start_from_idx("AbcDefGhi", 1), StrIndex::new(3, 3));
+/// assert_eq!(camel_case_start_from_idx("Abcdefg", 1), StrIndex::new(7, 7));
 /// ```
 pub fn camel_case_start_from_idx(s: &str, start_idx: usize) -> StrIndex {
     let char_count = s.chars().count();
@@ -94,7 +97,7 @@ pub fn camel_case_start_from_idx(s: &str, start_idx: usize) -> StrIndex {
     let mut last_index = StrIndex::new(char_count, s.len());
     for (char_index, (byte_index, c)) in iter {
         if byte_index < start_idx {
-            continue;
+            break;
         }
         if down {
             if c.is_uppercase() {
@@ -120,12 +123,17 @@ pub fn camel_case_start_from_idx(s: &str, start_idx: usize) -> StrIndex {
 /// Get the indexes of camel case components of a string `s`
 ///
 /// ```
-/// # use clippy_utils::str_utils::{camel_case_indexes, StrIndex};
-/// assert_eq!(camel_case_indexes("AbcDef"), vec![StrIndex::new(0, 0), StrIndex::new(3, 3),
-/// StrIndex::new(6, 6)]);
-/// assert_eq!(camel_case_indexes("abcDef"), vec![StrIndex::new(3, 3), StrIndex::new(6, 6)]);
+/// # use clippy_utils::str_utils::{camel_case_indices, StrIndex};
+/// assert_eq!(
+///     camel_case_indices("AbcDef"),
+///     vec![StrIndex::new(0, 0), StrIndex::new(3, 3), StrIndex::new(6, 6)]
+/// );
+/// assert_eq!(
+///     camel_case_indices("abcDef"),
+///     vec![StrIndex::new(3, 3), StrIndex::new(6, 6)]
+/// );
 /// ```
-pub fn camel_case_indexes(s: &str) -> Vec<StrIndex> {
+pub fn camel_case_indices(s: &str) -> Vec<StrIndex> {
     let mut result = Vec::new();
     let mut str_idx = camel_case_start(s);
 
@@ -146,20 +154,15 @@ pub fn camel_case_indexes(s: &str) -> Vec<StrIndex> {
 /// assert_eq!(camel_case_split("AbcDef"), vec!["Abc", "Def"]);
 /// ```
 pub fn camel_case_split(s: &str) -> Vec<&str> {
-    let offsets = camel_case_indexes(s);
-    let mut idxs_iter = offsets.iter().map(|str_idx| str_idx.byte_index).peekable();
-    let idxs: Vec<usize> = if let Some(&idx) = idxs_iter.peek() {
-        if idx == 0 {
-            idxs_iter.collect()
-        } else {
-            Vec::<usize>::from([0]).into_iter().chain(idxs_iter).collect()
-        }
-    } else {
-        return vec![s];
-    };
-    let split_points: Vec<(&usize, &usize)> = idxs[..idxs.len() - 1].iter().zip(&idxs[1..]).collect();
+    let mut offsets = camel_case_indices(s)
+        .iter()
+        .map(|e| e.byte_index)
+        .collect::<Vec<usize>>();
+    if offsets[0] != 0 {
+        offsets.insert(0, 0);
+    }
 
-    split_points.iter().map(|(&start, &stop)| &s[start..stop]).collect()
+    offsets.windows(2).map(|w| &s[w[0]..w[1]]).collect()
 }
 
 /// Dealing with sting comparison can be complicated, this struct ensures that both the
@@ -298,11 +301,14 @@ mod test {
         assert_eq!(camel_case_start_from_idx("AbcDef", 0), StrIndex::new(0, 0));
         assert_eq!(camel_case_start_from_idx("AbcDef", 1), StrIndex::new(3, 3));
         assert_eq!(camel_case_start_from_idx("AbcDef", 4), StrIndex::new(6, 6));
+        assert_eq!(camel_case_start_from_idx("AbcDefGhi", 0), StrIndex::new(0, 0));
+        assert_eq!(camel_case_start_from_idx("AbcDefGhi", 1), StrIndex::new(3, 3));
+        assert_eq!(camel_case_start_from_idx("Abcdefg", 1), StrIndex::new(7, 7));
     }
 
     #[test]
-    fn camel_case_indexes_full() {
-        assert_eq!(camel_case_indexes("Abc\u{f6}\u{f6}DD"), vec![StrIndex::new(7, 9)]);
+    fn camel_case_indices_full() {
+        assert_eq!(camel_case_indices("Abc\u{f6}\u{f6}DD"), vec![StrIndex::new(7, 9)]);
     }
 
     #[test]
-- 
cgit 1.4.1-3-g733a5


From b82c9ce3af0bd338ef3e532eae8a9f87d6981bf0 Mon Sep 17 00:00:00 2001
From: dswij <dswijj@gmail.com>
Date: Fri, 24 Dec 2021 12:32:12 +0800
Subject: Add limitation description for `enum_variant_names`

`enum_variant_names` will consider characters with no case to be a part
of prefixes/suffixes substring that are compared. This means `Foo1` and
`Foo2` has different prefixes (`Foo1` and `Foo2` prefix respeectively).
This applies to all non-ascii characters with no casing.
---
 clippy_lints/src/enum_variants.rs | 6 ++++++
 1 file changed, 6 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/enum_variants.rs b/clippy_lints/src/enum_variants.rs
index b13fd25c6e1..6e1fa836b8f 100644
--- a/clippy_lints/src/enum_variants.rs
+++ b/clippy_lints/src/enum_variants.rs
@@ -18,6 +18,12 @@ declare_clippy_lint! {
     /// Enumeration variant names should specify their variant,
     /// not repeat the enumeration name.
     ///
+    /// ### Limitations
+    /// Characters with no casing will be considered when comparing prefixes/suffixes
+    /// This applies to numbers and non-ascii characters without casing
+    /// e.g. `Foo1` and `Foo2` is considered to have different prefixes
+    /// (the prefixes are `Foo1` and `Foo2` respectively), as also `Bar螃`, `Bar蟹`
+    ///
     /// ### Example
     /// ```rust
     /// enum Cake {
-- 
cgit 1.4.1-3-g733a5


From 4ffd66074a462b30d15da8d40cc0f356dd43bb1c Mon Sep 17 00:00:00 2001
From: surechen <chenshuo17@huawei.com>
Date: Fri, 17 Dec 2021 10:03:59 +0800
Subject: Fixes #8128

changelog: Fix error suggestion of skip(..).next() for immutable variable.
---
 clippy_lints/src/methods/iter_skip_next.rs | 32 ++++++++++++++++++++----
 tests/ui/iter_skip_next.fixed              | 15 ++++++++++++
 tests/ui/iter_skip_next.rs                 | 15 ++++++++++++
 tests/ui/iter_skip_next.stderr             | 28 +++++++++++++++++----
 tests/ui/iter_skip_next_unfixable.rs       | 19 +++++++++++++++
 tests/ui/iter_skip_next_unfixable.stderr   | 39 ++++++++++++++++++++++++++++++
 6 files changed, 138 insertions(+), 10 deletions(-)
 create mode 100644 tests/ui/iter_skip_next_unfixable.rs
 create mode 100644 tests/ui/iter_skip_next_unfixable.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/iter_skip_next.rs b/clippy_lints/src/methods/iter_skip_next.rs
index e32594757d0..f5410c7fd7f 100644
--- a/clippy_lints/src/methods/iter_skip_next.rs
+++ b/clippy_lints/src/methods/iter_skip_next.rs
@@ -1,8 +1,10 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::is_trait_method;
+use clippy_utils::path_to_local;
 use clippy_utils::source::snippet;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
+use rustc_hir::{BindingAnnotation, Node, PatKind};
 use rustc_lint::LateContext;
 use rustc_span::sym;
 
@@ -11,14 +13,34 @@ use super::ITER_SKIP_NEXT;
 pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr<'_>, arg: &hir::Expr<'_>) {
     // lint if caller of skip is an Iterator
     if is_trait_method(cx, expr, sym::Iterator) {
-        span_lint_and_sugg(
+        let mut application = Applicability::MachineApplicable;
+        span_lint_and_then(
             cx,
             ITER_SKIP_NEXT,
             expr.span.trim_start(recv.span).unwrap(),
             "called `skip(..).next()` on an iterator",
-            "use `nth` instead",
-            format!(".nth({})", snippet(cx, arg.span, "..")),
-            Applicability::MachineApplicable,
+            |diag| {
+                if_chain! {
+                    if let Some(id) = path_to_local(recv);
+                    if let Node::Binding(pat) = cx.tcx.hir().get(id);
+                    if let PatKind::Binding(ann, _, _, _)  = pat.kind;
+                    if ann != BindingAnnotation::Mutable;
+                    then {
+                        application = Applicability::Unspecified;
+                        diag.span_help(
+                            pat.span,
+                            &format!("for this change `{}` has to be mutable", snippet(cx, pat.span, "..")),
+                        );
+                    }
+                }
+
+                diag.span_suggestion(
+                    expr.span.trim_start(recv.span).unwrap(),
+                    "use `nth` instead",
+                    format!(".nth({})", snippet(cx, arg.span, "..")),
+                    application,
+                );
+            },
         );
     }
 }
diff --git a/tests/ui/iter_skip_next.fixed b/tests/ui/iter_skip_next.fixed
index 928b6acb951..2db4c2bee7f 100644
--- a/tests/ui/iter_skip_next.fixed
+++ b/tests/ui/iter_skip_next.fixed
@@ -4,6 +4,7 @@
 #![warn(clippy::iter_skip_next)]
 #![allow(clippy::blacklisted_name)]
 #![allow(clippy::iter_nth)]
+#![allow(unused_mut, dead_code)]
 
 extern crate option_helpers;
 
@@ -19,4 +20,18 @@ fn main() {
     let foo = IteratorFalsePositives { foo: 0 };
     let _ = foo.skip(42).next();
     let _ = foo.filter().skip(42).next();
+
+    // fix #8128
+    let test_string = "1|1 2";
+    let mut sp = test_string.split('|').map(|s| s.trim());
+    let _: Vec<&str> = sp.nth(1).unwrap().split(' ').collect();
+    if let Some(mut s) = Some(test_string.split('|').map(|s| s.trim())) {
+        let _: Vec<&str> = s.nth(1).unwrap().split(' ').collect();
+    };
+    fn check<T>(mut s: T)
+    where
+        T: Iterator<Item = String>,
+    {
+        let _: Vec<&str> = s.nth(1).unwrap().split(' ').collect();
+    }
 }
diff --git a/tests/ui/iter_skip_next.rs b/tests/ui/iter_skip_next.rs
index 7075e2598eb..692edb9aed9 100644
--- a/tests/ui/iter_skip_next.rs
+++ b/tests/ui/iter_skip_next.rs
@@ -4,6 +4,7 @@
 #![warn(clippy::iter_skip_next)]
 #![allow(clippy::blacklisted_name)]
 #![allow(clippy::iter_nth)]
+#![allow(unused_mut, dead_code)]
 
 extern crate option_helpers;
 
@@ -19,4 +20,18 @@ fn main() {
     let foo = IteratorFalsePositives { foo: 0 };
     let _ = foo.skip(42).next();
     let _ = foo.filter().skip(42).next();
+
+    // fix #8128
+    let test_string = "1|1 2";
+    let mut sp = test_string.split('|').map(|s| s.trim());
+    let _: Vec<&str> = sp.skip(1).next().unwrap().split(' ').collect();
+    if let Some(mut s) = Some(test_string.split('|').map(|s| s.trim())) {
+        let _: Vec<&str> = s.skip(1).next().unwrap().split(' ').collect();
+    };
+    fn check<T>(mut s: T)
+    where
+        T: Iterator<Item = String>,
+    {
+        let _: Vec<&str> = s.skip(1).next().unwrap().split(' ').collect();
+    }
 }
diff --git a/tests/ui/iter_skip_next.stderr b/tests/ui/iter_skip_next.stderr
index 486de718bb5..ca6970b27f1 100644
--- a/tests/ui/iter_skip_next.stderr
+++ b/tests/ui/iter_skip_next.stderr
@@ -1,5 +1,5 @@
 error: called `skip(..).next()` on an iterator
-  --> $DIR/iter_skip_next.rs:15:28
+  --> $DIR/iter_skip_next.rs:16:28
    |
 LL |     let _ = some_vec.iter().skip(42).next();
    |                            ^^^^^^^^^^^^^^^^ help: use `nth` instead: `.nth(42)`
@@ -7,22 +7,40 @@ LL |     let _ = some_vec.iter().skip(42).next();
    = note: `-D clippy::iter-skip-next` implied by `-D warnings`
 
 error: called `skip(..).next()` on an iterator
-  --> $DIR/iter_skip_next.rs:16:36
+  --> $DIR/iter_skip_next.rs:17:36
    |
 LL |     let _ = some_vec.iter().cycle().skip(42).next();
    |                                    ^^^^^^^^^^^^^^^^ help: use `nth` instead: `.nth(42)`
 
 error: called `skip(..).next()` on an iterator
-  --> $DIR/iter_skip_next.rs:17:20
+  --> $DIR/iter_skip_next.rs:18:20
    |
 LL |     let _ = (1..10).skip(10).next();
    |                    ^^^^^^^^^^^^^^^^ help: use `nth` instead: `.nth(10)`
 
 error: called `skip(..).next()` on an iterator
-  --> $DIR/iter_skip_next.rs:18:33
+  --> $DIR/iter_skip_next.rs:19:33
    |
 LL |     let _ = &some_vec[..].iter().skip(3).next();
    |                                 ^^^^^^^^^^^^^^^ help: use `nth` instead: `.nth(3)`
 
-error: aborting due to 4 previous errors
+error: called `skip(..).next()` on an iterator
+  --> $DIR/iter_skip_next.rs:27:26
+   |
+LL |     let _: Vec<&str> = sp.skip(1).next().unwrap().split(' ').collect();
+   |                          ^^^^^^^^^^^^^^^ help: use `nth` instead: `.nth(1)`
+
+error: called `skip(..).next()` on an iterator
+  --> $DIR/iter_skip_next.rs:29:29
+   |
+LL |         let _: Vec<&str> = s.skip(1).next().unwrap().split(' ').collect();
+   |                             ^^^^^^^^^^^^^^^ help: use `nth` instead: `.nth(1)`
+
+error: called `skip(..).next()` on an iterator
+  --> $DIR/iter_skip_next.rs:35:29
+   |
+LL |         let _: Vec<&str> = s.skip(1).next().unwrap().split(' ').collect();
+   |                             ^^^^^^^^^^^^^^^ help: use `nth` instead: `.nth(1)`
+
+error: aborting due to 7 previous errors
 
diff --git a/tests/ui/iter_skip_next_unfixable.rs b/tests/ui/iter_skip_next_unfixable.rs
new file mode 100644
index 00000000000..3607330cfa0
--- /dev/null
+++ b/tests/ui/iter_skip_next_unfixable.rs
@@ -0,0 +1,19 @@
+#![warn(clippy::iter_skip_next)]
+#![allow(dead_code)]
+
+/// Checks implementation of `ITER_SKIP_NEXT` lint
+fn main() {
+    // fix #8128
+    let test_string = "1|1 2";
+    let sp = test_string.split('|').map(|s| s.trim());
+    let _: Vec<&str> = sp.skip(1).next().unwrap().split(' ').collect();
+    if let Some(s) = Some(test_string.split('|').map(|s| s.trim())) {
+        let _: Vec<&str> = s.skip(1).next().unwrap().split(' ').collect();
+    };
+    fn check<T>(s: T)
+    where
+        T: Iterator<Item = String>,
+    {
+        let _: Vec<&str> = s.skip(1).next().unwrap().split(' ').collect();
+    }
+}
diff --git a/tests/ui/iter_skip_next_unfixable.stderr b/tests/ui/iter_skip_next_unfixable.stderr
new file mode 100644
index 00000000000..74c327c7483
--- /dev/null
+++ b/tests/ui/iter_skip_next_unfixable.stderr
@@ -0,0 +1,39 @@
+error: called `skip(..).next()` on an iterator
+  --> $DIR/iter_skip_next_unfixable.rs:9:26
+   |
+LL |     let _: Vec<&str> = sp.skip(1).next().unwrap().split(' ').collect();
+   |                          ^^^^^^^^^^^^^^^ help: use `nth` instead: `.nth(1)`
+   |
+   = note: `-D clippy::iter-skip-next` implied by `-D warnings`
+help: for this change `sp` has to be mutable
+  --> $DIR/iter_skip_next_unfixable.rs:8:9
+   |
+LL |     let sp = test_string.split('|').map(|s| s.trim());
+   |         ^^
+
+error: called `skip(..).next()` on an iterator
+  --> $DIR/iter_skip_next_unfixable.rs:11:29
+   |
+LL |         let _: Vec<&str> = s.skip(1).next().unwrap().split(' ').collect();
+   |                             ^^^^^^^^^^^^^^^ help: use `nth` instead: `.nth(1)`
+   |
+help: for this change `s` has to be mutable
+  --> $DIR/iter_skip_next_unfixable.rs:10:17
+   |
+LL |     if let Some(s) = Some(test_string.split('|').map(|s| s.trim())) {
+   |                 ^
+
+error: called `skip(..).next()` on an iterator
+  --> $DIR/iter_skip_next_unfixable.rs:17:29
+   |
+LL |         let _: Vec<&str> = s.skip(1).next().unwrap().split(' ').collect();
+   |                             ^^^^^^^^^^^^^^^ help: use `nth` instead: `.nth(1)`
+   |
+help: for this change `s` has to be mutable
+  --> $DIR/iter_skip_next_unfixable.rs:13:17
+   |
+LL |     fn check<T>(s: T)
+   |                 ^
+
+error: aborting due to 3 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 3ebd2bc2e4fac8f56e1399872ea449594a280daa Mon Sep 17 00:00:00 2001
From: Andre Bogus <bogusandre@gmail.com>
Date: Sat, 25 Dec 2021 16:52:58 +0100
Subject: new lint: `init-numbered-fields`

---
 CHANGELOG.md                             |  1 +
 clippy_lints/src/init_numbered_fields.rs | 80 ++++++++++++++++++++++++++++++++
 clippy_lints/src/lib.register_all.rs     |  1 +
 clippy_lints/src/lib.register_lints.rs   |  1 +
 clippy_lints/src/lib.register_style.rs   |  1 +
 clippy_lints/src/lib.rs                  |  8 +++-
 clippy_lints/src/macro_use.rs            |  6 +--
 clippy_utils/src/lib.rs                  |  7 +++
 tests/ui/numbered_fields.fixed           | 33 +++++++++++++
 tests/ui/numbered_fields.rs              | 41 ++++++++++++++++
 tests/ui/numbered_fields.stderr          | 26 +++++++++++
 11 files changed, 198 insertions(+), 7 deletions(-)
 create mode 100644 clippy_lints/src/init_numbered_fields.rs
 create mode 100644 tests/ui/numbered_fields.fixed
 create mode 100644 tests/ui/numbered_fields.rs
 create mode 100644 tests/ui/numbered_fields.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index c09310e5556..27bac4718b6 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3026,6 +3026,7 @@ Released 2018-09-13
 [`infinite_iter`]: https://rust-lang.github.io/rust-clippy/master/index.html#infinite_iter
 [`inherent_to_string`]: https://rust-lang.github.io/rust-clippy/master/index.html#inherent_to_string
 [`inherent_to_string_shadow_display`]: https://rust-lang.github.io/rust-clippy/master/index.html#inherent_to_string_shadow_display
+[`init_numbered_fields`]: https://rust-lang.github.io/rust-clippy/master/index.html#init_numbered_fields
 [`inline_always`]: https://rust-lang.github.io/rust-clippy/master/index.html#inline_always
 [`inline_asm_x86_att_syntax`]: https://rust-lang.github.io/rust-clippy/master/index.html#inline_asm_x86_att_syntax
 [`inline_asm_x86_intel_syntax`]: https://rust-lang.github.io/rust-clippy/master/index.html#inline_asm_x86_intel_syntax
diff --git a/clippy_lints/src/init_numbered_fields.rs b/clippy_lints/src/init_numbered_fields.rs
new file mode 100644
index 00000000000..5fe6725b581
--- /dev/null
+++ b/clippy_lints/src/init_numbered_fields.rs
@@ -0,0 +1,80 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::in_macro;
+use clippy_utils::source::snippet_with_applicability;
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use std::borrow::Cow;
+use std::cmp::Reverse;
+use std::collections::BinaryHeap;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for tuple structs initialized with field syntax.
+    /// It will however not lint if a base initializer is present.
+    /// The lint will also ignore code in macros.
+    ///
+    /// ### Why is this bad?
+    /// This may be confusing to the uninitiated and adds no
+    /// benefit as opposed to tuple initializers
+    ///
+    /// ### Example
+    /// ```rust
+    /// struct TupleStruct(u8, u16);
+    ///
+    /// let _ = TupleStruct {
+    ///     0: 1,
+    ///     1: 23,
+    /// };
+    ///
+    /// // should be written as
+    /// let base = TupleStruct(1, 23);
+    ///
+    /// // This is OK however
+    /// let _ = TupleStruct { 0: 42, ..base };
+    /// ```
+    #[clippy::version = "1.59.0"]
+    pub INIT_NUMBERED_FIELDS,
+    style,
+    "numbered fields in tuple struct initializer"
+}
+
+declare_lint_pass!(NumberedFields => [INIT_NUMBERED_FIELDS]);
+
+impl<'tcx> LateLintPass<'tcx> for NumberedFields {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
+        if let ExprKind::Struct(path, fields, None) = e.kind {
+            if !fields.is_empty()
+                && !in_macro(e.span)
+                && fields
+                    .iter()
+                    .all(|f| f.ident.as_str().as_bytes().iter().all(u8::is_ascii_digit))
+            {
+                let expr_spans = fields
+                    .iter()
+                    .map(|f| (Reverse(f.ident.as_str().parse::<usize>().unwrap()), f.expr.span))
+                    .collect::<BinaryHeap<_>>();
+                let mut appl = Applicability::MachineApplicable;
+                let snippet = format!(
+                    "{}({})",
+                    snippet_with_applicability(cx, path.span(), "..", &mut appl),
+                    expr_spans
+                        .into_iter_sorted()
+                        .map(|(_, span)| snippet_with_applicability(cx, span, "..", &mut appl))
+                        .intersperse(Cow::Borrowed(", "))
+                        .collect::<String>()
+                );
+                span_lint_and_sugg(
+                    cx,
+                    INIT_NUMBERED_FIELDS,
+                    e.span,
+                    "used a field initializer for a tuple struct",
+                    "try this instead",
+                    snippet,
+                    appl,
+                );
+            }
+        }
+    }
+}
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 3d3999d4cc0..944411087e9 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -81,6 +81,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(infinite_iter::INFINITE_ITER),
     LintId::of(inherent_to_string::INHERENT_TO_STRING),
     LintId::of(inherent_to_string::INHERENT_TO_STRING_SHADOW_DISPLAY),
+    LintId::of(init_numbered_fields::INIT_NUMBERED_FIELDS),
     LintId::of(inline_fn_without_body::INLINE_FN_WITHOUT_BODY),
     LintId::of(int_plus_one::INT_PLUS_ONE),
     LintId::of(large_const_arrays::LARGE_CONST_ARRAYS),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 766c5ba1bcb..002122793f3 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -178,6 +178,7 @@ store.register_lints(&[
     inherent_impl::MULTIPLE_INHERENT_IMPL,
     inherent_to_string::INHERENT_TO_STRING,
     inherent_to_string::INHERENT_TO_STRING_SHADOW_DISPLAY,
+    init_numbered_fields::INIT_NUMBERED_FIELDS,
     inline_fn_without_body::INLINE_FN_WITHOUT_BODY,
     int_plus_one::INT_PLUS_ONE,
     integer_division::INTEGER_DIVISION,
diff --git a/clippy_lints/src/lib.register_style.rs b/clippy_lints/src/lib.register_style.rs
index ea87e7e7a73..1a0b869d40a 100644
--- a/clippy_lints/src/lib.register_style.rs
+++ b/clippy_lints/src/lib.register_style.rs
@@ -29,6 +29,7 @@ store.register_group(true, "clippy::style", Some("clippy_style"), vec![
     LintId::of(functions::MUST_USE_UNIT),
     LintId::of(functions::RESULT_UNIT_ERR),
     LintId::of(inherent_to_string::INHERENT_TO_STRING),
+    LintId::of(init_numbered_fields::INIT_NUMBERED_FIELDS),
     LintId::of(len_zero::COMPARISON_TO_EMPTY),
     LintId::of(len_zero::LEN_WITHOUT_IS_EMPTY),
     LintId::of(len_zero::LEN_ZERO),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index d1c7956a7a5..d4687a1e287 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1,13 +1,15 @@
 // error-pattern:cargo-clippy
 
+#![feature(binary_heap_into_iter_sorted)]
 #![feature(box_patterns)]
+#![feature(control_flow_enum)]
 #![feature(drain_filter)]
 #![feature(in_band_lifetimes)]
+#![feature(iter_intersperse)]
+#![feature(let_else)]
 #![feature(once_cell)]
 #![feature(rustc_private)]
 #![feature(stmt_expr_attributes)]
-#![feature(control_flow_enum)]
-#![feature(let_else)]
 #![recursion_limit = "512"]
 #![cfg_attr(feature = "deny-warnings", deny(warnings))]
 #![allow(clippy::missing_docs_in_private_items, clippy::must_use_candidate)]
@@ -242,6 +244,7 @@ mod indexing_slicing;
 mod infinite_iter;
 mod inherent_impl;
 mod inherent_to_string;
+mod init_numbered_fields;
 mod inline_fn_without_body;
 mod int_plus_one;
 mod integer_division;
@@ -854,6 +857,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_early_pass(|| Box::new(octal_escapes::OctalEscapes));
     store.register_late_pass(|| Box::new(needless_late_init::NeedlessLateInit));
     store.register_late_pass(|| Box::new(return_self_not_must_use::ReturnSelfNotMustUse));
+    store.register_late_pass(|| Box::new(init_numbered_fields::NumberedFields));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/macro_use.rs b/clippy_lints/src/macro_use.rs
index 262a26951c6..bbc14fc535d 100644
--- a/clippy_lints/src/macro_use.rs
+++ b/clippy_lints/src/macro_use.rs
@@ -1,4 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::in_macro;
 use clippy_utils::source::snippet;
 use hir::def::{DefKind, Res};
 use if_chain::if_chain;
@@ -8,7 +9,6 @@ use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::hygiene::ExpnKind;
 use rustc_span::{edition::Edition, sym, Span};
 
 declare_clippy_lint! {
@@ -214,7 +214,3 @@ impl<'tcx> LateLintPass<'tcx> for MacroUseImports {
         }
     }
 }
-
-fn in_macro(span: Span) -> bool {
-    span.from_expansion() && !matches!(span.ctxt().outer_expn_data().kind, ExpnKind::Desugaring(..))
-}
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 4af870d3155..a04db7d570e 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -142,6 +142,13 @@ macro_rules! extract_msrv_attr {
     };
 }
 
+/// Returns `true` if the span comes from a macro expansion, no matter if from a
+/// macro by example or from a procedural macro
+#[must_use]
+pub fn in_macro(span: Span) -> bool {
+    span.from_expansion() && !matches!(span.ctxt().outer_expn_data().kind, ExpnKind::Desugaring(..))
+}
+
 /// Returns `true` if the two spans come from differing expansions (i.e., one is
 /// from a macro and one isn't).
 #[must_use]
diff --git a/tests/ui/numbered_fields.fixed b/tests/ui/numbered_fields.fixed
new file mode 100644
index 00000000000..1da97e96879
--- /dev/null
+++ b/tests/ui/numbered_fields.fixed
@@ -0,0 +1,33 @@
+//run-rustfix
+#![warn(clippy::init_numbered_fields)]
+
+#[derive(Default)]
+struct TupleStruct(u32, u32, u8);
+
+// This shouldn't lint because it's in a macro
+macro_rules! tuple_struct_init {
+    () => {
+        TupleStruct { 0: 0, 1: 1, 2: 2 }
+    };
+}
+
+fn main() {
+    let tuple_struct = TupleStruct::default();
+
+    // This should lint
+    let _ = TupleStruct(1u32, 42, 23u8);
+
+    // This should also lint and order the fields correctly
+    let _ = TupleStruct(1u32, 3u32, 2u8);
+
+    // Ok because of default initializer
+    let _ = TupleStruct { 0: 42, ..tuple_struct };
+
+    let _ = TupleStruct {
+        1: 23,
+        ..TupleStruct::default()
+    };
+
+    // Ok because it's in macro
+    let _ = tuple_struct_init!();
+}
diff --git a/tests/ui/numbered_fields.rs b/tests/ui/numbered_fields.rs
new file mode 100644
index 00000000000..08ec405a560
--- /dev/null
+++ b/tests/ui/numbered_fields.rs
@@ -0,0 +1,41 @@
+//run-rustfix
+#![warn(clippy::init_numbered_fields)]
+
+#[derive(Default)]
+struct TupleStruct(u32, u32, u8);
+
+// This shouldn't lint because it's in a macro
+macro_rules! tuple_struct_init {
+    () => {
+        TupleStruct { 0: 0, 1: 1, 2: 2 }
+    };
+}
+
+fn main() {
+    let tuple_struct = TupleStruct::default();
+
+    // This should lint
+    let _ = TupleStruct {
+        0: 1u32,
+        1: 42,
+        2: 23u8,
+    };
+
+    // This should also lint and order the fields correctly
+    let _ = TupleStruct {
+        0: 1u32,
+        2: 2u8,
+        1: 3u32,
+    };
+
+    // Ok because of default initializer
+    let _ = TupleStruct { 0: 42, ..tuple_struct };
+
+    let _ = TupleStruct {
+        1: 23,
+        ..TupleStruct::default()
+    };
+
+    // Ok because it's in macro
+    let _ = tuple_struct_init!();
+}
diff --git a/tests/ui/numbered_fields.stderr b/tests/ui/numbered_fields.stderr
new file mode 100644
index 00000000000..01691c8b141
--- /dev/null
+++ b/tests/ui/numbered_fields.stderr
@@ -0,0 +1,26 @@
+error: used a field initializer for a tuple struct
+  --> $DIR/numbered_fields.rs:18:13
+   |
+LL |       let _ = TupleStruct {
+   |  _____________^
+LL | |         0: 1u32,
+LL | |         1: 42,
+LL | |         2: 23u8,
+LL | |     };
+   | |_____^ help: try this instead: `TupleStruct(1u32, 42, 23u8)`
+   |
+   = note: `-D clippy::init-numbered-fields` implied by `-D warnings`
+
+error: used a field initializer for a tuple struct
+  --> $DIR/numbered_fields.rs:25:13
+   |
+LL |       let _ = TupleStruct {
+   |  _____________^
+LL | |         0: 1u32,
+LL | |         2: 2u8,
+LL | |         1: 3u32,
+LL | |     };
+   | |_____^ help: try this instead: `TupleStruct(1u32, 3u32, 2u8)`
+
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From ba70842c625abed2a61aa84dd0a7bd4b7b874063 Mon Sep 17 00:00:00 2001
From: Alex Ozdemir <aozdemir@hmc.edu>
Date: Mon, 27 Dec 2021 16:06:27 -0800
Subject: Limit the identity_op lint to integral operands.

If operands are being applied to non-integers, then the lint is likely
wrong.
---
 clippy_lints/src/identity_op.rs | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/identity_op.rs b/clippy_lints/src/identity_op.rs
index b4e7bbc7671..a833e17917e 100644
--- a/clippy_lints/src/identity_op.rs
+++ b/clippy_lints/src/identity_op.rs
@@ -61,10 +61,13 @@ impl<'tcx> LateLintPass<'tcx> for IdentityOp {
 }
 
 fn is_allowed(cx: &LateContext<'_>, cmp: BinOp, left: &Expr<'_>, right: &Expr<'_>) -> bool {
-    // `1 << 0` is a common pattern in bit manipulation code
-    cmp.node == BinOpKind::Shl
-        && constant_simple(cx, cx.typeck_results(), right) == Some(Constant::Int(0))
-        && constant_simple(cx, cx.typeck_results(), left) == Some(Constant::Int(1))
+    // This lint applies to integers
+    !cx.typeck_results().expr_ty(left).is_integral()
+        || !cx.typeck_results().expr_ty(right).is_integral()
+        // `1 << 0` is a common pattern in bit manipulation code
+        || (cmp.node == BinOpKind::Shl
+            && constant_simple(cx, cx.typeck_results(), right) == Some(Constant::Int(0))
+            && constant_simple(cx, cx.typeck_results(), left) == Some(Constant::Int(1)))
 }
 
 fn check(cx: &LateContext<'_>, e: &Expr<'_>, m: i8, span: Span, arg: Span) {
-- 
cgit 1.4.1-3-g733a5


From fc72e910fbd72b7b30a6cb0b6390e0b7b8d907d8 Mon Sep 17 00:00:00 2001
From: bors <bors@rust-lang.org>
Date: Tue, 28 Dec 2021 11:15:53 +0000
Subject: `needless_return` suggest return unit type on void returns

closes #8177

previously, `needless_return` suggests an empty block `{}` to replace void `return` on match arms, this PR improve the suggestion by suggesting a unit instead.

changelog: `needless_return` suggests `()` instead of `{}` on match arms
---
 clippy_lints/src/returns.rs     | 14 +++++++++-
 tests/ui/needless_return.fixed  | 15 +++++++++--
 tests/ui/needless_return.rs     | 11 ++++++++
 tests/ui/needless_return.stderr | 58 +++++++++++++++++++++++++----------------
 4 files changed, 72 insertions(+), 26 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
index 494bc7dda18..112ccdcdd42 100644
--- a/clippy_lints/src/returns.rs
+++ b/clippy_lints/src/returns.rs
@@ -73,6 +73,7 @@ declare_clippy_lint! {
 enum RetReplacement {
     Empty,
     Block,
+    Unit,
 }
 
 declare_lint_pass!(Return => [LET_AND_RETURN, NEEDLESS_RETURN]);
@@ -212,7 +213,7 @@ fn check_final_expr<'tcx>(
         // (except for unit type functions) so we don't match it
         ExprKind::Match(_, arms, MatchSource::Normal) => {
             for arm in arms.iter() {
-                check_final_expr(cx, arm.body, Some(arm.body.span), RetReplacement::Block);
+                check_final_expr(cx, arm.body, Some(arm.body.span), RetReplacement::Unit);
             }
         },
         ExprKind::DropTemps(expr) => check_final_expr(cx, expr, None, RetReplacement::Empty),
@@ -259,6 +260,17 @@ fn emit_return_lint(cx: &LateContext<'_>, ret_span: Span, inner_span: Option<Spa
                     Applicability::MachineApplicable,
                 );
             },
+            RetReplacement::Unit => {
+                span_lint_and_sugg(
+                    cx,
+                    NEEDLESS_RETURN,
+                    ret_span,
+                    "unneeded `return` statement",
+                    "replace `return` with a unit value",
+                    "()".to_string(),
+                    Applicability::MachineApplicable,
+                );
+            },
         },
     }
 }
diff --git a/tests/ui/needless_return.fixed b/tests/ui/needless_return.fixed
index 83f467c8400..603d438d558 100644
--- a/tests/ui/needless_return.fixed
+++ b/tests/ui/needless_return.fixed
@@ -71,7 +71,18 @@ fn test_void_if_fun(b: bool) {
 fn test_void_match(x: u32) {
     match x {
         0 => (),
-        _ => {},
+        _ => (),
+    }
+}
+
+fn test_nested_match(x: u32) {
+    match x {
+        0 => (),
+        1 => {
+            let _ = 42;
+            
+        },
+        _ => (),
     }
 }
 
@@ -182,7 +193,7 @@ async fn async_test_void_if_fun(b: bool) {
 async fn async_test_void_match(x: u32) {
     match x {
         0 => (),
-        _ => {},
+        _ => (),
     }
 }
 
diff --git a/tests/ui/needless_return.rs b/tests/ui/needless_return.rs
index 341caf18bd6..c6c8cb9ec15 100644
--- a/tests/ui/needless_return.rs
+++ b/tests/ui/needless_return.rs
@@ -75,6 +75,17 @@ fn test_void_match(x: u32) {
     }
 }
 
+fn test_nested_match(x: u32) {
+    match x {
+        0 => (),
+        1 => {
+            let _ = 42;
+            return;
+        },
+        _ => return,
+    }
+}
+
 fn read_line() -> String {
     use std::io::BufRead;
     let stdin = ::std::io::stdin();
diff --git a/tests/ui/needless_return.stderr b/tests/ui/needless_return.stderr
index c0abc2c63dd..5bc787c56a6 100644
--- a/tests/ui/needless_return.stderr
+++ b/tests/ui/needless_return.stderr
@@ -70,127 +70,139 @@ error: unneeded `return` statement
   --> $DIR/needless_return.rs:74:14
    |
 LL |         _ => return,
-   |              ^^^^^^ help: replace `return` with an empty block: `{}`
+   |              ^^^^^^ help: replace `return` with a unit value: `()`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:89:9
+  --> $DIR/needless_return.rs:83:13
+   |
+LL |             return;
+   |             ^^^^^^^ help: remove `return`
+
+error: unneeded `return` statement
+  --> $DIR/needless_return.rs:85:14
+   |
+LL |         _ => return,
+   |              ^^^^^^ help: replace `return` with a unit value: `()`
+
+error: unneeded `return` statement
+  --> $DIR/needless_return.rs:100:9
    |
 LL |         return String::from("test");
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove `return`: `String::from("test")`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:91:9
+  --> $DIR/needless_return.rs:102:9
    |
 LL |         return String::new();
    |         ^^^^^^^^^^^^^^^^^^^^^ help: remove `return`: `String::new()`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:113:32
+  --> $DIR/needless_return.rs:124:32
    |
 LL |         bar.unwrap_or_else(|_| return)
    |                                ^^^^^^ help: replace `return` with an empty block: `{}`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:118:13
+  --> $DIR/needless_return.rs:129:13
    |
 LL |             return;
    |             ^^^^^^^ help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:120:20
+  --> $DIR/needless_return.rs:131:20
    |
 LL |         let _ = || return;
    |                    ^^^^^^ help: replace `return` with an empty block: `{}`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:126:32
+  --> $DIR/needless_return.rs:137:32
    |
 LL |         res.unwrap_or_else(|_| return Foo)
    |                                ^^^^^^^^^^ help: remove `return`: `Foo`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:135:5
+  --> $DIR/needless_return.rs:146:5
    |
 LL |     return true;
    |     ^^^^^^^^^^^^ help: remove `return`: `true`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:139:5
+  --> $DIR/needless_return.rs:150:5
    |
 LL |     return true;
    |     ^^^^^^^^^^^^ help: remove `return`: `true`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:144:9
+  --> $DIR/needless_return.rs:155:9
    |
 LL |         return true;
    |         ^^^^^^^^^^^^ help: remove `return`: `true`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:146:9
+  --> $DIR/needless_return.rs:157:9
    |
 LL |         return false;
    |         ^^^^^^^^^^^^^ help: remove `return`: `false`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:152:17
+  --> $DIR/needless_return.rs:163:17
    |
 LL |         true => return false,
    |                 ^^^^^^^^^^^^ help: remove `return`: `false`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:154:13
+  --> $DIR/needless_return.rs:165:13
    |
 LL |             return true;
    |             ^^^^^^^^^^^^ help: remove `return`: `true`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:161:9
+  --> $DIR/needless_return.rs:172:9
    |
 LL |         return true;
    |         ^^^^^^^^^^^^ help: remove `return`: `true`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:163:16
+  --> $DIR/needless_return.rs:174:16
    |
 LL |     let _ = || return true;
    |                ^^^^^^^^^^^ help: remove `return`: `true`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:171:5
+  --> $DIR/needless_return.rs:182:5
    |
 LL |     return;
    |     ^^^^^^^ help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:176:9
+  --> $DIR/needless_return.rs:187:9
    |
 LL |         return;
    |         ^^^^^^^ help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:178:9
+  --> $DIR/needless_return.rs:189:9
    |
 LL |         return;
    |         ^^^^^^^ help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:185:14
+  --> $DIR/needless_return.rs:196:14
    |
 LL |         _ => return,
-   |              ^^^^^^ help: replace `return` with an empty block: `{}`
+   |              ^^^^^^ help: replace `return` with a unit value: `()`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:200:9
+  --> $DIR/needless_return.rs:211:9
    |
 LL |         return String::from("test");
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove `return`: `String::from("test")`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:202:9
+  --> $DIR/needless_return.rs:213:9
    |
 LL |         return String::new();
    |         ^^^^^^^^^^^^^^^^^^^^^ help: remove `return`: `String::new()`
 
-error: aborting due to 32 previous errors
+error: aborting due to 34 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From bc0579f5bf10c28de8ca75127d97b884170471ef Mon Sep 17 00:00:00 2001
From: Alex Ozdemir <aozdemir@hmc.edu>
Date: Tue, 28 Dec 2021 08:19:47 -0800
Subject: test

---
 clippy_lints/src/identity_op.rs |  4 ++--
 tests/ui/identity_op.rs         | 14 ++++++++++++++
 tests/ui/identity_op.stderr     | 30 ++++++++++++++++++------------
 3 files changed, 34 insertions(+), 14 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/identity_op.rs b/clippy_lints/src/identity_op.rs
index a833e17917e..de60e284cad 100644
--- a/clippy_lints/src/identity_op.rs
+++ b/clippy_lints/src/identity_op.rs
@@ -62,8 +62,8 @@ impl<'tcx> LateLintPass<'tcx> for IdentityOp {
 
 fn is_allowed(cx: &LateContext<'_>, cmp: BinOp, left: &Expr<'_>, right: &Expr<'_>) -> bool {
     // This lint applies to integers
-    !cx.typeck_results().expr_ty(left).is_integral()
-        || !cx.typeck_results().expr_ty(right).is_integral()
+    !cx.typeck_results().expr_ty(left).peel_refs().is_integral()
+        || !cx.typeck_results().expr_ty(right).peel_refs().is_integral()
         // `1 << 0` is a common pattern in bit manipulation code
         || (cmp.node == BinOpKind::Shl
             && constant_simple(cx, cx.typeck_results(), right) == Some(Constant::Int(0))
diff --git a/tests/ui/identity_op.rs b/tests/ui/identity_op.rs
index ceaacaaf6bd..a3985b68fbb 100644
--- a/tests/ui/identity_op.rs
+++ b/tests/ui/identity_op.rs
@@ -2,6 +2,16 @@ const ONE: i64 = 1;
 const NEG_ONE: i64 = -1;
 const ZERO: i64 = 0;
 
+struct A(String);
+
+impl std::ops::Shl<i32> for A {
+    type Output = A;
+    fn shl(mut self, other: i32) -> Self {
+        self.0.push_str(&format!("{}", other));
+        self
+    }
+}
+
 #[allow(
     clippy::eq_op,
     clippy::no_effect,
@@ -38,4 +48,8 @@ fn main() {
     42 << 0;
     1 >> 0;
     42 >> 0;
+    &x >> 0;
+
+    let mut a = A("".into());
+    let b = a << 0; // no error: non-integer
 }
diff --git a/tests/ui/identity_op.stderr b/tests/ui/identity_op.stderr
index d8d44a74f9a..5b63eb9cc4f 100644
--- a/tests/ui/identity_op.stderr
+++ b/tests/ui/identity_op.stderr
@@ -1,5 +1,5 @@
 error: the operation is ineffective. Consider reducing it to `x`
-  --> $DIR/identity_op.rs:16:5
+  --> $DIR/identity_op.rs:26:5
    |
 LL |     x + 0;
    |     ^^^^^
@@ -7,64 +7,70 @@ LL |     x + 0;
    = note: `-D clippy::identity-op` implied by `-D warnings`
 
 error: the operation is ineffective. Consider reducing it to `x`
-  --> $DIR/identity_op.rs:17:5
+  --> $DIR/identity_op.rs:27:5
    |
 LL |     x + (1 - 1);
    |     ^^^^^^^^^^^
 
 error: the operation is ineffective. Consider reducing it to `x`
-  --> $DIR/identity_op.rs:19:5
+  --> $DIR/identity_op.rs:29:5
    |
 LL |     0 + x;
    |     ^^^^^
 
 error: the operation is ineffective. Consider reducing it to `x`
-  --> $DIR/identity_op.rs:22:5
+  --> $DIR/identity_op.rs:32:5
    |
 LL |     x | (0);
    |     ^^^^^^^
 
 error: the operation is ineffective. Consider reducing it to `x`
-  --> $DIR/identity_op.rs:25:5
+  --> $DIR/identity_op.rs:35:5
    |
 LL |     x * 1;
    |     ^^^^^
 
 error: the operation is ineffective. Consider reducing it to `x`
-  --> $DIR/identity_op.rs:26:5
+  --> $DIR/identity_op.rs:36:5
    |
 LL |     1 * x;
    |     ^^^^^
 
 error: the operation is ineffective. Consider reducing it to `x`
-  --> $DIR/identity_op.rs:32:5
+  --> $DIR/identity_op.rs:42:5
    |
 LL |     -1 & x;
    |     ^^^^^^
 
 error: the operation is ineffective. Consider reducing it to `u`
-  --> $DIR/identity_op.rs:35:5
+  --> $DIR/identity_op.rs:45:5
    |
 LL |     u & 255;
    |     ^^^^^^^
 
 error: the operation is ineffective. Consider reducing it to `42`
-  --> $DIR/identity_op.rs:38:5
+  --> $DIR/identity_op.rs:48:5
    |
 LL |     42 << 0;
    |     ^^^^^^^
 
 error: the operation is ineffective. Consider reducing it to `1`
-  --> $DIR/identity_op.rs:39:5
+  --> $DIR/identity_op.rs:49:5
    |
 LL |     1 >> 0;
    |     ^^^^^^
 
 error: the operation is ineffective. Consider reducing it to `42`
-  --> $DIR/identity_op.rs:40:5
+  --> $DIR/identity_op.rs:50:5
    |
 LL |     42 >> 0;
    |     ^^^^^^^
 
-error: aborting due to 11 previous errors
+error: the operation is ineffective. Consider reducing it to `&x`
+  --> $DIR/identity_op.rs:51:5
+   |
+LL |     &x >> 0;
+   |     ^^^^^^^
+
+error: aborting due to 12 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From ee6d5c5cdae8b7cb3198800a615855169fc0b3de Mon Sep 17 00:00:00 2001
From: Alex Ozdemir <aozdemir@hmc.edu>
Date: Tue, 28 Dec 2021 08:32:55 -0800
Subject: contants peel_refs to catch `x << &0`

---
 clippy_lints/src/identity_op.rs | 4 ++--
 clippy_utils/src/consts.rs      | 8 ++++++++
 tests/ui/identity_op.rs         | 3 ++-
 tests/ui/identity_op.stderr     | 8 +++++++-
 4 files changed, 19 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/identity_op.rs b/clippy_lints/src/identity_op.rs
index de60e284cad..f824f20ca40 100644
--- a/clippy_lints/src/identity_op.rs
+++ b/clippy_lints/src/identity_op.rs
@@ -71,8 +71,8 @@ fn is_allowed(cx: &LateContext<'_>, cmp: BinOp, left: &Expr<'_>, right: &Expr<'_
 }
 
 fn check(cx: &LateContext<'_>, e: &Expr<'_>, m: i8, span: Span, arg: Span) {
-    if let Some(Constant::Int(v)) = constant_simple(cx, cx.typeck_results(), e) {
-        let check = match *cx.typeck_results().expr_ty(e).kind() {
+    if let Some(Constant::Int(v)) = constant_simple(cx, cx.typeck_results(), e).map(Constant::peel_refs) {
+        let check = match *cx.typeck_results().expr_ty(e).peel_refs().kind() {
             ty::Int(ity) => unsext(cx.tcx, -1_i128, ity),
             ty::Uint(uty) => clip(cx.tcx, !0, uty),
             _ => return,
diff --git a/clippy_utils/src/consts.rs b/clippy_utils/src/consts.rs
index 04347672e0f..1cf8f9721b5 100644
--- a/clippy_utils/src/consts.rs
+++ b/clippy_utils/src/consts.rs
@@ -168,6 +168,14 @@ impl Constant {
             None
         }
     }
+
+    #[must_use]
+    pub fn peel_refs(mut self) -> Self {
+        while let Constant::Ref(r) = self {
+            self = *r;
+        }
+        self
+    }
 }
 
 /// Parses a `LitKind` to a `Constant`.
diff --git a/tests/ui/identity_op.rs b/tests/ui/identity_op.rs
index a3985b68fbb..2ed4b5db574 100644
--- a/tests/ui/identity_op.rs
+++ b/tests/ui/identity_op.rs
@@ -11,11 +11,11 @@ impl std::ops::Shl<i32> for A {
         self
     }
 }
-
 #[allow(
     clippy::eq_op,
     clippy::no_effect,
     clippy::unnecessary_operation,
+    clippy::op_ref,
     clippy::double_parens
 )]
 #[warn(clippy::identity_op)]
@@ -49,6 +49,7 @@ fn main() {
     1 >> 0;
     42 >> 0;
     &x >> 0;
+    x >> &0;
 
     let mut a = A("".into());
     let b = a << 0; // no error: non-integer
diff --git a/tests/ui/identity_op.stderr b/tests/ui/identity_op.stderr
index 5b63eb9cc4f..ff34b38db01 100644
--- a/tests/ui/identity_op.stderr
+++ b/tests/ui/identity_op.stderr
@@ -72,5 +72,11 @@ error: the operation is ineffective. Consider reducing it to `&x`
 LL |     &x >> 0;
    |     ^^^^^^^
 
-error: aborting due to 12 previous errors
+error: the operation is ineffective. Consider reducing it to `x`
+  --> $DIR/identity_op.rs:52:5
+   |
+LL |     x >> &0;
+   |     ^^^^^^^
+
+error: aborting due to 13 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From d5c4119d428439accc65a54167872038f0ff1e74 Mon Sep 17 00:00:00 2001
From: BB <bartlomiejbetka@gmail.com>
Date: Tue, 28 Dec 2021 17:45:43 +0100
Subject: Fixed issues with to_radians and to_degrees lints

---
 clippy_lints/src/floating_point_arithmetic.rs | 30 +++++++++++++++++++++++++--
 tests/ui/floating_point_rad.fixed             |  5 +++++
 tests/ui/floating_point_rad.rs                |  5 +++++
 tests/ui/floating_point_rad.stderr            | 28 +++++++++++++++++++++++--
 4 files changed, 64 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/floating_point_arithmetic.rs b/clippy_lints/src/floating_point_arithmetic.rs
index 2de2bfc040b..f801d95563d 100644
--- a/clippy_lints/src/floating_point_arithmetic.rs
+++ b/clippy_lints/src/floating_point_arithmetic.rs
@@ -654,26 +654,52 @@ fn check_radians(cx: &LateContext<'_>, expr: &Expr<'_>) {
             if (F32(f32_consts::PI) == rvalue || F64(f64_consts::PI) == rvalue) &&
                (F32(180_f32) == lvalue || F64(180_f64) == lvalue)
             {
+                let mut proposal = format!("{}.to_degrees()", Sugg::hir(cx, mul_lhs, ".."));
+                if_chain! {
+                    if let ExprKind::Lit(ref literal) = mul_lhs.kind;
+                    if let ast::LitKind::Float(ref value, float_type) = literal.node;
+                    if float_type == ast::LitFloatType::Unsuffixed;
+                    then {
+                        if value.as_str().ends_with('.') {
+                            proposal = format!("{}0_f64.to_degrees()", Sugg::hir(cx, mul_lhs, ".."));
+                        } else {
+                            proposal = format!("{}_f64.to_degrees()", Sugg::hir(cx, mul_lhs, ".."));
+                        }
+                    }
+                }
                 span_lint_and_sugg(
                     cx,
                     SUBOPTIMAL_FLOPS,
                     expr.span,
                     "conversion to degrees can be done more accurately",
                     "consider using",
-                    format!("{}.to_degrees()", Sugg::hir(cx, mul_lhs, "..")),
+                    proposal,
                     Applicability::MachineApplicable,
                 );
             } else if
                 (F32(180_f32) == rvalue || F64(180_f64) == rvalue) &&
                 (F32(f32_consts::PI) == lvalue || F64(f64_consts::PI) == lvalue)
             {
+                let mut proposal = format!("{}.to_radians()", Sugg::hir(cx, mul_lhs, ".."));
+                if_chain! {
+                    if let ExprKind::Lit(ref literal) = mul_lhs.kind;
+                    if let ast::LitKind::Float(ref value, float_type) = literal.node;
+                    if float_type == ast::LitFloatType::Unsuffixed;
+                    then {
+                        if value.as_str().ends_with('.') {
+                            proposal = format!("{}0_f64.to_radians()", Sugg::hir(cx, mul_lhs, ".."));
+                        } else {
+                            proposal = format!("{}_f64.to_radians()", Sugg::hir(cx, mul_lhs, ".."));
+                        }
+                    }
+                }
                 span_lint_and_sugg(
                     cx,
                     SUBOPTIMAL_FLOPS,
                     expr.span,
                     "conversion to radians can be done more accurately",
                     "consider using",
-                    format!("{}.to_radians()", Sugg::hir(cx, mul_lhs, "..")),
+                    proposal,
                     Applicability::MachineApplicable,
                 );
             }
diff --git a/tests/ui/floating_point_rad.fixed b/tests/ui/floating_point_rad.fixed
index a35bb1c27f3..ce91fe176c6 100644
--- a/tests/ui/floating_point_rad.fixed
+++ b/tests/ui/floating_point_rad.fixed
@@ -11,7 +11,12 @@ pub const fn const_context() {
 fn main() {
     let x = 3f32;
     let _ = x.to_degrees();
+    let _ = 90.0_f64.to_degrees();
+    let _ = 90.5_f64.to_degrees();
     let _ = x.to_radians();
+    let _ = 90.0_f64.to_radians();
+    let _ = 90.5_f64.to_radians();
+    // let _ = 90.5 * 80. * std::f32::consts::PI / 180f32;
     // Cases where the lint shouldn't be applied
     let _ = x * 90f32 / std::f32::consts::PI;
     let _ = x * std::f32::consts::PI / 90f32;
diff --git a/tests/ui/floating_point_rad.rs b/tests/ui/floating_point_rad.rs
index 834db4be533..8f323498614 100644
--- a/tests/ui/floating_point_rad.rs
+++ b/tests/ui/floating_point_rad.rs
@@ -11,7 +11,12 @@ pub const fn const_context() {
 fn main() {
     let x = 3f32;
     let _ = x * 180f32 / std::f32::consts::PI;
+    let _ = 90. * 180f64 / std::f64::consts::PI;
+    let _ = 90.5 * 180f64 / std::f64::consts::PI;
     let _ = x * std::f32::consts::PI / 180f32;
+    let _ = 90. * std::f32::consts::PI / 180f32;
+    let _ = 90.5 * std::f32::consts::PI / 180f32;
+    // let _ = 90.5 * 80. * std::f32::consts::PI / 180f32;
     // Cases where the lint shouldn't be applied
     let _ = x * 90f32 / std::f32::consts::PI;
     let _ = x * std::f32::consts::PI / 90f32;
diff --git a/tests/ui/floating_point_rad.stderr b/tests/ui/floating_point_rad.stderr
index acecddbca53..f12d3d23f3a 100644
--- a/tests/ui/floating_point_rad.stderr
+++ b/tests/ui/floating_point_rad.stderr
@@ -6,11 +6,35 @@ LL |     let _ = x * 180f32 / std::f32::consts::PI;
    |
    = note: `-D clippy::suboptimal-flops` implied by `-D warnings`
 
-error: conversion to radians can be done more accurately
+error: conversion to degrees can be done more accurately
   --> $DIR/floating_point_rad.rs:14:13
    |
+LL |     let _ = 90. * 180f64 / std::f64::consts::PI;
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `90.0_f64.to_degrees()`
+
+error: conversion to degrees can be done more accurately
+  --> $DIR/floating_point_rad.rs:15:13
+   |
+LL |     let _ = 90.5 * 180f64 / std::f64::consts::PI;
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `90.5_f64.to_degrees()`
+
+error: conversion to radians can be done more accurately
+  --> $DIR/floating_point_rad.rs:16:13
+   |
 LL |     let _ = x * std::f32::consts::PI / 180f32;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.to_radians()`
 
-error: aborting due to 2 previous errors
+error: conversion to radians can be done more accurately
+  --> $DIR/floating_point_rad.rs:17:13
+   |
+LL |     let _ = 90. * std::f32::consts::PI / 180f32;
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `90.0_f64.to_radians()`
+
+error: conversion to radians can be done more accurately
+  --> $DIR/floating_point_rad.rs:18:13
+   |
+LL |     let _ = 90.5 * std::f32::consts::PI / 180f32;
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `90.5_f64.to_radians()`
+
+error: aborting due to 6 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 828ddbe414d77d61292a72ffb9ade85cd6e72cda Mon Sep 17 00:00:00 2001
From: Elliot Bobrow <elliotgreybobrow@gmail.com>
Date: Wed, 29 Dec 2021 08:52:40 -0800
Subject: fix [`redundant_closure`] fp with `Arc`

---
 clippy_lints/src/eta_reduction.rs |  5 +++++
 tests/ui/eta.fixed                | 11 +++++++++++
 tests/ui/eta.rs                   | 11 +++++++++++
 3 files changed, 27 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/eta_reduction.rs b/clippy_lints/src/eta_reduction.rs
index 5a4b4247104..b22515a3907 100644
--- a/clippy_lints/src/eta_reduction.rs
+++ b/clippy_lints/src/eta_reduction.rs
@@ -1,6 +1,7 @@
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::higher::VecArgs;
 use clippy_utils::source::snippet_opt;
+use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::usage::local_used_after_expr;
 use clippy_utils::{get_enclosing_loop_or_closure, higher, path_to_local, path_to_local_id};
 use if_chain::if_chain;
@@ -12,6 +13,7 @@ use rustc_middle::ty::adjustment::{Adjust, Adjustment, AutoBorrow};
 use rustc_middle::ty::subst::Subst;
 use rustc_middle::ty::{self, ClosureKind, Ty, TypeFoldable};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::symbol::sym;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -113,6 +115,9 @@ impl<'tcx> LateLintPass<'tcx> for EtaReduction {
             // A type param function ref like `T::f` is not 'static, however
             // it is if cast like `T::f as fn()`. This seems like a rustc bug.
             if !substs.types().any(|t| matches!(t.kind(), ty::Param(_)));
+            let callee_ty_unadjusted = cx.typeck_results().expr_ty(callee).peel_refs();
+            if !is_type_diagnostic_item(cx, callee_ty_unadjusted, sym::Arc);
+            if !is_type_diagnostic_item(cx, callee_ty_unadjusted, sym::Rc);
             then {
                 span_lint_and_then(cx, REDUNDANT_CLOSURE, expr.span, "redundant closure", |diag| {
                     if let Some(mut snippet) = snippet_opt(cx, callee.span) {
diff --git a/tests/ui/eta.fixed b/tests/ui/eta.fixed
index 1de79667f55..f938f710688 100644
--- a/tests/ui/eta.fixed
+++ b/tests/ui/eta.fixed
@@ -248,3 +248,14 @@ mod type_param_bound {
         take(X::fun as fn());
     }
 }
+
+// #8073 Don't replace closure with `Arc<F>` or `Rc<F>`
+fn arc_fp() {
+    let rc = std::rc::Rc::new(|| 7);
+    let arc = std::sync::Arc::new(|n| n + 1);
+    let ref_arc = &std::sync::Arc::new(|_| 5);
+
+    true.then(|| rc());
+    (0..5).map(|n| arc(n));
+    Some(4).map(|n| ref_arc(n));
+}
diff --git a/tests/ui/eta.rs b/tests/ui/eta.rs
index 86abd347baa..075bbc74922 100644
--- a/tests/ui/eta.rs
+++ b/tests/ui/eta.rs
@@ -248,3 +248,14 @@ mod type_param_bound {
         take(X::fun as fn());
     }
 }
+
+// #8073 Don't replace closure with `Arc<F>` or `Rc<F>`
+fn arc_fp() {
+    let rc = std::rc::Rc::new(|| 7);
+    let arc = std::sync::Arc::new(|n| n + 1);
+    let ref_arc = &std::sync::Arc::new(|_| 5);
+
+    true.then(|| rc());
+    (0..5).map(|n| arc(n));
+    Some(4).map(|n| ref_arc(n));
+}
-- 
cgit 1.4.1-3-g733a5


From 2b5257e4c770c6a4964a7897fa1348be5050797f Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Thu, 30 Dec 2021 13:37:14 -0600
Subject: Remove method_call! macro

---
 clippy_lints/src/methods/mod.rs | 41 ++++++++++++++++-------------------------
 1 file changed, 16 insertions(+), 25 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 4e33b2ff14c..ad07370f26d 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -80,7 +80,6 @@ use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::{self, TraitRef, Ty, TyS};
 use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::symbol::Symbol;
 use rustc_span::{sym, Span};
 use rustc_typeck::hir_ty_to_ty;
 
@@ -1997,24 +1996,16 @@ impl_lint_pass!(Methods => [
 ]);
 
 /// Extracts a method call name, args, and `Span` of the method name.
-fn method_call<'tcx>(recv: &'tcx hir::Expr<'tcx>) -> Option<(Symbol, &'tcx [hir::Expr<'tcx>], Span)> {
+fn method_call<'tcx>(recv: &'tcx hir::Expr<'tcx>) -> Option<(&'tcx str, &'tcx [hir::Expr<'tcx>], Span)> {
     if let ExprKind::MethodCall(path, span, args, _) = recv.kind {
         if !args.iter().any(|e| e.span.from_expansion()) {
-            return Some((path.ident.name, args, span));
+            let name = path.ident.name.as_str();
+            return Some((name, args, span));
         }
     }
     None
 }
 
-/// Same as `method_call` but the `Symbol` is dereferenced into a temporary `&str`
-macro_rules! method_call {
-    ($expr:expr) => {
-        method_call($expr)
-            .as_ref()
-            .map(|&(ref name, args, span)| (name.as_str(), args, span))
-    };
-}
-
 impl<'tcx> LateLintPass<'tcx> for Methods {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
         if expr.span.from_expansion() {
@@ -2217,7 +2208,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
 
 #[allow(clippy::too_many_lines)]
 fn check_methods<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, msrv: Option<&RustcVersion>) {
-    if let Some((name, [recv, args @ ..], span)) = method_call!(expr) {
+    if let Some((name, [recv, args @ ..], span)) = method_call(expr) {
         match (name, args) {
             ("add" | "offset" | "sub" | "wrapping_offset" | "wrapping_add" | "wrapping_sub", [_arg]) => {
                 zst_offset::check(cx, expr, recv);
@@ -2233,7 +2224,7 @@ fn check_methods<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, msrv: Optio
             ("as_ref", []) => useless_asref::check(cx, expr, "as_ref", recv),
             ("assume_init", []) => uninit_assumed_init::check(cx, expr, recv),
             ("cloned", []) => cloned_instead_of_copied::check(cx, expr, recv, span, msrv),
-            ("collect", []) => match method_call!(recv) {
+            ("collect", []) => match method_call(recv) {
                 Some((name @ ("cloned" | "copied"), [recv2], _)) => {
                     iter_cloned_collect::check(cx, name, expr, recv2);
                 },
@@ -2247,14 +2238,14 @@ fn check_methods<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, msrv: Optio
                 },
                 _ => {},
             },
-            ("count", []) => match method_call!(recv) {
+            ("count", []) => match method_call(recv) {
                 Some((name @ ("into_iter" | "iter" | "iter_mut"), [recv2], _)) => {
                     iter_count::check(cx, expr, recv2, name);
                 },
                 Some(("map", [_, arg], _)) => suspicious_map::check(cx, expr, recv, arg),
                 _ => {},
             },
-            ("expect", [_]) => match method_call!(recv) {
+            ("expect", [_]) => match method_call(recv) {
                 Some(("ok", [recv], _)) => ok_expect::check(cx, expr, recv),
                 _ => expect_used::check(cx, expr, recv),
             },
@@ -2271,13 +2262,13 @@ fn check_methods<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, msrv: Optio
                 flat_map_option::check(cx, expr, arg, span);
             },
             ("flatten", []) => {
-                if let Some(("map", [recv, map_arg], _)) = method_call!(recv) {
+                if let Some(("map", [recv, map_arg], _)) = method_call(recv) {
                     map_flatten::check(cx, expr, recv, map_arg);
                 }
             },
             ("fold", [init, acc]) => unnecessary_fold::check(cx, expr, init, acc, span),
             ("for_each", [_]) => {
-                if let Some(("inspect", [_, _], span2)) = method_call!(recv) {
+                if let Some(("inspect", [_, _], span2)) = method_call(recv) {
                     inspect_for_each::check(cx, expr, span2);
                 }
             },
@@ -2286,7 +2277,7 @@ fn check_methods<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, msrv: Optio
             ("is_none", []) => check_is_some_is_none(cx, expr, recv, false),
             ("is_some", []) => check_is_some_is_none(cx, expr, recv, true),
             ("map", [m_arg]) => {
-                if let Some((name, [recv2, args @ ..], span2)) = method_call!(recv) {
+                if let Some((name, [recv2, args @ ..], span2)) = method_call(recv) {
                     match (name, args) {
                         ("as_mut", []) => option_as_ref_deref::check(cx, expr, recv2, m_arg, true, msrv),
                         ("as_ref", []) => option_as_ref_deref::check(cx, expr, recv2, m_arg, false, msrv),
@@ -2301,7 +2292,7 @@ fn check_methods<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, msrv: Optio
             },
             ("map_or", [def, map]) => option_map_or_none::check(cx, expr, recv, def, map),
             ("next", []) => {
-                if let Some((name, [recv, args @ ..], _)) = method_call!(recv) {
+                if let Some((name, [recv, args @ ..], _)) = method_call(recv) {
                     match (name, args) {
                         ("filter", [arg]) => filter_next::check(cx, expr, recv, arg),
                         ("filter_map", [arg]) => filter_map_next::check(cx, expr, recv, arg, msrv),
@@ -2312,7 +2303,7 @@ fn check_methods<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, msrv: Optio
                     }
                 }
             },
-            ("nth", [n_arg]) => match method_call!(recv) {
+            ("nth", [n_arg]) => match method_call(recv) {
                 Some(("bytes", [recv2], _)) => bytes_nth::check(cx, expr, recv2, n_arg),
                 Some(("iter", [recv2], _)) => iter_nth::check(cx, expr, recv2, recv, n_arg, false),
                 Some(("iter_mut", [recv2], _)) => iter_nth::check(cx, expr, recv2, recv, n_arg, true),
@@ -2344,12 +2335,12 @@ fn check_methods<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, msrv: Optio
             ("to_os_string" | "to_owned" | "to_path_buf" | "to_vec", []) => {
                 implicit_clone::check(cx, name, expr, recv, span);
             },
-            ("unwrap", []) => match method_call!(recv) {
+            ("unwrap", []) => match method_call(recv) {
                 Some(("get", [recv, get_arg], _)) => get_unwrap::check(cx, expr, recv, get_arg, false),
                 Some(("get_mut", [recv, get_arg], _)) => get_unwrap::check(cx, expr, recv, get_arg, true),
                 _ => unwrap_used::check(cx, expr, recv),
             },
-            ("unwrap_or", [u_arg]) => match method_call!(recv) {
+            ("unwrap_or", [u_arg]) => match method_call(recv) {
                 Some((arith @ ("checked_add" | "checked_sub" | "checked_mul"), [lhs, rhs], _)) => {
                     manual_saturating_arithmetic::check(cx, expr, lhs, rhs, u_arg, &arith["checked_".len()..]);
                 },
@@ -2358,7 +2349,7 @@ fn check_methods<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, msrv: Optio
                 },
                 _ => {},
             },
-            ("unwrap_or_else", [u_arg]) => match method_call!(recv) {
+            ("unwrap_or_else", [u_arg]) => match method_call(recv) {
                 Some(("map", [recv, map_arg], _)) if map_unwrap_or::check(cx, expr, recv, map_arg, u_arg, msrv) => {},
                 _ => {
                     unwrap_or_else_default::check(cx, expr, recv, u_arg);
@@ -2371,7 +2362,7 @@ fn check_methods<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, msrv: Optio
 }
 
 fn check_is_some_is_none(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'_>, is_some: bool) {
-    if let Some((name @ ("find" | "position" | "rposition"), [f_recv, arg], span)) = method_call!(recv) {
+    if let Some((name @ ("find" | "position" | "rposition"), [f_recv, arg], span)) = method_call(recv) {
         search_is_some::check(cx, expr, name, is_some, f_recv, arg, recv, span);
     }
 }
-- 
cgit 1.4.1-3-g733a5


From 65d1f83d2c593c7997b4fe781814eb0fb69272e9 Mon Sep 17 00:00:00 2001
From: Nick Mathewson <nickm@torproject.org>
Date: Mon, 27 Dec 2021 11:17:17 -0500
Subject: Extend [`unused_io_amount`] to cover AsyncRead and AsyncWrite.

Clippy helpfully warns about code like this, telling you that you
probably meant "write_all":

    fn say_hi<W:Write>(w: &mut W) {
       w.write(b"hello").unwrap();
    }

This patch attempts to extend the lint so it also covers this
case:

    async fn say_hi<W:AsyncWrite>(w: &mut W) {
       w.write(b"hello").await.unwrap();
    }

(I've run into this second case several times in my own programming,
and so have my coworkers, so unless we're especially accident-prone
in this area, it's probably worth addressing?)

This patch covers the Async{Read,Write}Ext traits in futures-rs,
and in tokio, since both are quite widely used.

changelog: [`unused_io_amount`] now supports AsyncReadExt and AsyncWriteExt.
---
 Cargo.toml                           |  2 +
 clippy_lints/src/unused_io_amount.rs | 75 +++++++++++++++++++++++++++++++-----
 clippy_utils/src/paths.rs            |  8 ++++
 tests/compile-test.rs                |  6 +++
 tests/ui/unused_io_amount.rs         | 53 +++++++++++++++++++++++++
 tests/ui/unused_io_amount.stderr     | 58 ++++++++++++++++++++++------
 6 files changed, 181 insertions(+), 21 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/Cargo.toml b/Cargo.toml
index 8661a867758..79a7ec92071 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -47,7 +47,9 @@ itertools = "0.10"
 quote = "1.0"
 serde = { version = "1.0", features = ["derive"] }
 syn = { version = "1.0", features = ["full"] }
+futures = "0.3"
 parking_lot = "0.11.2"
+tokio = { version = "1", features = ["io-util"] }
 
 [build-dependencies]
 rustc_tools_util = { version = "0.2", path = "rustc_tools_util" }
diff --git a/clippy_lints/src/unused_io_amount.rs b/clippy_lints/src/unused_io_amount.rs
index 004530db086..8afd8472db7 100644
--- a/clippy_lints/src/unused_io_amount.rs
+++ b/clippy_lints/src/unused_io_amount.rs
@@ -17,10 +17,17 @@ declare_clippy_lint! {
     /// partial-write/read, use
     /// `write_all`/`read_exact` instead.
     ///
+    /// When working with asynchronous code (either with the `futures`
+    /// crate or with `tokio`), a similar issue exists for
+    /// `AsyncWriteExt::write()` and `AsyncReadExt::read()` : these
+    /// functions are also not guaranteed to process the entire
+    /// buffer.  Your code should either handle partial-writes/reads, or
+    /// call the `write_all`/`read_exact` methods on those traits instead.
+    ///
     /// ### Known problems
     /// Detects only common patterns.
     ///
-    /// ### Example
+    /// ### Examples
     /// ```rust,ignore
     /// use std::io;
     /// fn foo<W: io::Write>(w: &mut W) -> io::Result<()> {
@@ -68,6 +75,23 @@ impl<'tcx> LateLintPass<'tcx> for UnusedIoAmount {
     }
 }
 
+/// If `expr` is an (e).await, return the inner expression "e" that's being
+/// waited on.  Otherwise return None.
+fn try_remove_await<'a>(expr: &'a hir::Expr<'a>) -> Option<&hir::Expr<'a>> {
+    if let hir::ExprKind::Match(expr, _, hir::MatchSource::AwaitDesugar) = expr.kind {
+        if let hir::ExprKind::Call(func, [ref arg_0, ..]) = expr.kind {
+            if matches!(
+                func.kind,
+                hir::ExprKind::Path(hir::QPath::LangItem(hir::LangItem::IntoFutureIntoFuture, ..))
+            ) {
+                return Some(arg_0);
+            }
+        }
+    }
+
+    None
+}
+
 fn check_map_error(cx: &LateContext<'_>, call: &hir::Expr<'_>, expr: &hir::Expr<'_>) {
     let mut call = call;
     while let hir::ExprKind::MethodCall(path, _, args, _) = call.kind {
@@ -77,30 +101,61 @@ fn check_map_error(cx: &LateContext<'_>, call: &hir::Expr<'_>, expr: &hir::Expr<
             break;
         }
     }
-    check_method_call(cx, call, expr);
+
+    if let Some(call) = try_remove_await(call) {
+        check_method_call(cx, call, expr, true);
+    } else {
+        check_method_call(cx, call, expr, false);
+    }
 }
 
-fn check_method_call(cx: &LateContext<'_>, call: &hir::Expr<'_>, expr: &hir::Expr<'_>) {
+fn check_method_call(cx: &LateContext<'_>, call: &hir::Expr<'_>, expr: &hir::Expr<'_>, is_await: bool) {
     if let hir::ExprKind::MethodCall(path, _, _, _) = call.kind {
         let symbol = path.ident.as_str();
-        let read_trait = match_trait_method(cx, call, &paths::IO_READ);
-        let write_trait = match_trait_method(cx, call, &paths::IO_WRITE);
+        let read_trait = if is_await {
+            match_trait_method(cx, call, &paths::FUTURES_IO_ASYNCREADEXT)
+                || match_trait_method(cx, call, &paths::TOKIO_IO_ASYNCREADEXT)
+        } else {
+            match_trait_method(cx, call, &paths::IO_READ)
+        };
+        let write_trait = if is_await {
+            match_trait_method(cx, call, &paths::FUTURES_IO_ASYNCWRITEEXT)
+                || match_trait_method(cx, call, &paths::TOKIO_IO_ASYNCWRITEEXT)
+        } else {
+            match_trait_method(cx, call, &paths::IO_WRITE)
+        };
 
-        match (read_trait, write_trait, symbol) {
-            (true, _, "read") => span_lint(
+        match (read_trait, write_trait, symbol, is_await) {
+            (true, _, "read", false) => span_lint(
                 cx,
                 UNUSED_IO_AMOUNT,
                 expr.span,
                 "read amount is not handled. Use `Read::read_exact` instead",
             ),
-            (true, _, "read_vectored") => span_lint(cx, UNUSED_IO_AMOUNT, expr.span, "read amount is not handled"),
-            (_, true, "write") => span_lint(
+            (true, _, "read", true) => span_lint(
+                cx,
+                UNUSED_IO_AMOUNT,
+                expr.span,
+                "read amount is not handled. Use `AsyncReadExt::read_exact` instead",
+            ),
+            (true, _, "read_vectored", _) => {
+                span_lint(cx, UNUSED_IO_AMOUNT, expr.span, "read amount is not handled");
+            },
+            (_, true, "write", false) => span_lint(
                 cx,
                 UNUSED_IO_AMOUNT,
                 expr.span,
                 "written amount is not handled. Use `Write::write_all` instead",
             ),
-            (_, true, "write_vectored") => span_lint(cx, UNUSED_IO_AMOUNT, expr.span, "written amount is not handled"),
+            (_, true, "write", true) => span_lint(
+                cx,
+                UNUSED_IO_AMOUNT,
+                expr.span,
+                "written amount is not handled. Use `AsyncWriteExt::write_all` instead",
+            ),
+            (_, true, "write_vectored", _) => {
+                span_lint(cx, UNUSED_IO_AMOUNT, expr.span, "written amount is not handled");
+            },
             _ => (),
         }
     }
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index 6171823abbb..aa3b3af2356 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -64,6 +64,10 @@ pub const FROM_ITERATOR: [&str; 5] = ["core", "iter", "traits", "collect", "From
 pub const FROM_ITERATOR_METHOD: [&str; 6] = ["core", "iter", "traits", "collect", "FromIterator", "from_iter"];
 pub const FROM_STR_METHOD: [&str; 5] = ["core", "str", "traits", "FromStr", "from_str"];
 pub const FUTURE_FROM_GENERATOR: [&str; 3] = ["core", "future", "from_generator"];
+#[allow(clippy::invalid_paths)] // internal lints do not know about all external crates
+pub const FUTURES_IO_ASYNCREADEXT: [&str; 3] = ["futures_util", "io", "AsyncReadExt"];
+#[allow(clippy::invalid_paths)] // internal lints do not know about all external crates
+pub const FUTURES_IO_ASYNCWRITEEXT: [&str; 3] = ["futures_util", "io", "AsyncWriteExt"];
 pub const HASH: [&str; 3] = ["core", "hash", "Hash"];
 pub const HASHMAP_CONTAINS_KEY: [&str; 6] = ["std", "collections", "hash", "map", "HashMap", "contains_key"];
 pub const HASHMAP_ENTRY: [&str; 5] = ["std", "collections", "hash", "map", "Entry"];
@@ -194,6 +198,10 @@ pub const SYM_MODULE: [&str; 3] = ["rustc_span", "symbol", "sym"];
 pub const SYNTAX_CONTEXT: [&str; 3] = ["rustc_span", "hygiene", "SyntaxContext"];
 pub const TO_OWNED_METHOD: [&str; 4] = ["alloc", "borrow", "ToOwned", "to_owned"];
 pub const TO_STRING_METHOD: [&str; 4] = ["alloc", "string", "ToString", "to_string"];
+#[allow(clippy::invalid_paths)] // internal lints do not know about all external crates
+pub const TOKIO_IO_ASYNCREADEXT: [&str; 5] = ["tokio", "io", "util", "async_read_ext", "AsyncReadExt"];
+#[allow(clippy::invalid_paths)] // internal lints do not know about all external crates
+pub const TOKIO_IO_ASYNCWRITEEXT: [&str; 5] = ["tokio", "io", "util", "async_write_ext", "AsyncWriteExt"];
 pub const TRY_FROM: [&str; 4] = ["core", "convert", "TryFrom", "try_from"];
 pub const VEC_AS_MUT_SLICE: [&str; 4] = ["alloc", "vec", "Vec", "as_mut_slice"];
 pub const VEC_AS_SLICE: [&str; 4] = ["alloc", "vec", "Vec", "as_slice"];
diff --git a/tests/compile-test.rs b/tests/compile-test.rs
index a2d58491872..d602d2042ee 100644
--- a/tests/compile-test.rs
+++ b/tests/compile-test.rs
@@ -21,6 +21,7 @@ const RUN_INTERNAL_TESTS: bool = cfg!(feature = "internal-lints");
 static TEST_DEPENDENCIES: &[&str] = &[
     "clippy_utils",
     "derive_new",
+    "futures",
     "if_chain",
     "itertools",
     "quote",
@@ -28,6 +29,7 @@ static TEST_DEPENDENCIES: &[&str] = &[
     "serde",
     "serde_derive",
     "syn",
+    "tokio",
     "parking_lot",
 ];
 
@@ -38,6 +40,8 @@ extern crate clippy_utils;
 #[allow(unused_extern_crates)]
 extern crate derive_new;
 #[allow(unused_extern_crates)]
+extern crate futures;
+#[allow(unused_extern_crates)]
 extern crate if_chain;
 #[allow(unused_extern_crates)]
 extern crate itertools;
@@ -47,6 +51,8 @@ extern crate parking_lot;
 extern crate quote;
 #[allow(unused_extern_crates)]
 extern crate syn;
+#[allow(unused_extern_crates)]
+extern crate tokio;
 
 /// Produces a string with an `--extern` flag for all UI test crate
 /// dependencies.
diff --git a/tests/ui/unused_io_amount.rs b/tests/ui/unused_io_amount.rs
index 8b141e25942..4b059558173 100644
--- a/tests/ui/unused_io_amount.rs
+++ b/tests/ui/unused_io_amount.rs
@@ -1,6 +1,8 @@
 #![allow(dead_code)]
 #![warn(clippy::unused_io_amount)]
 
+extern crate futures;
+use futures::io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt};
 use std::io::{self, Read};
 
 fn question_mark<T: io::Read + io::Write>(s: &mut T) -> io::Result<()> {
@@ -61,4 +63,55 @@ fn combine_or(file: &str) -> Result<(), Error> {
     Ok(())
 }
 
+async fn bad_async_write<W: AsyncWrite + Unpin>(w: &mut W) {
+    w.write(b"hello world").await.unwrap();
+}
+
+async fn bad_async_read<R: AsyncRead + Unpin>(r: &mut R) {
+    let mut buf = [0u8; 0];
+    r.read(&mut buf[..]).await.unwrap();
+}
+
+async fn io_not_ignored_async_write<W: AsyncWrite + Unpin>(mut w: W) {
+    // Here we're forgetting to await the future, so we should get a
+    // warning about _that_ (or we would, if it were enabled), but we
+    // won't get one about ignoring the return value.
+    w.write(b"hello world");
+}
+
+fn bad_async_write_closure<W: AsyncWrite + Unpin + 'static>(w: W) -> impl futures::Future<Output = io::Result<()>> {
+    let mut w = w;
+    async move {
+        w.write(b"hello world").await?;
+        Ok(())
+    }
+}
+
+async fn async_read_nested_or<R: AsyncRead + Unpin>(r: &mut R, do_it: bool) -> Result<[u8; 1], Error> {
+    let mut buf = [0u8; 1];
+    if do_it {
+        r.read(&mut buf[..]).await.or(Err(Error::Kind))?;
+    }
+    Ok(buf)
+}
+
+use tokio::io::{AsyncRead as TokioAsyncRead, AsyncReadExt as _, AsyncWrite as TokioAsyncWrite, AsyncWriteExt as _};
+
+async fn bad_async_write_tokio<W: TokioAsyncWrite + Unpin>(w: &mut W) {
+    w.write(b"hello world").await.unwrap();
+}
+
+async fn bad_async_read_tokio<R: TokioAsyncRead + Unpin>(r: &mut R) {
+    let mut buf = [0u8; 0];
+    r.read(&mut buf[..]).await.unwrap();
+}
+
+async fn undetected_bad_async_write<W: AsyncWrite + Unpin>(w: &mut W) {
+    // It would be good to detect this case some day, but the current lint
+    // doesn't handle it. (The documentation says that this lint "detects
+    // only common patterns".)
+    let future = w.write(b"Hello world");
+    future.await.unwrap();
+}
+
 fn main() {}
diff --git a/tests/ui/unused_io_amount.stderr b/tests/ui/unused_io_amount.stderr
index d8dfc0e5a79..3852d0622d6 100644
--- a/tests/ui/unused_io_amount.stderr
+++ b/tests/ui/unused_io_amount.stderr
@@ -1,5 +1,5 @@
 error: written amount is not handled. Use `Write::write_all` instead
-  --> $DIR/unused_io_amount.rs:7:5
+  --> $DIR/unused_io_amount.rs:9:5
    |
 LL |     s.write(b"test")?;
    |     ^^^^^^^^^^^^^^^^^
@@ -7,55 +7,55 @@ LL |     s.write(b"test")?;
    = note: `-D clippy::unused-io-amount` implied by `-D warnings`
 
 error: read amount is not handled. Use `Read::read_exact` instead
-  --> $DIR/unused_io_amount.rs:9:5
+  --> $DIR/unused_io_amount.rs:11:5
    |
 LL |     s.read(&mut buf)?;
    |     ^^^^^^^^^^^^^^^^^
 
 error: written amount is not handled. Use `Write::write_all` instead
-  --> $DIR/unused_io_amount.rs:14:5
+  --> $DIR/unused_io_amount.rs:16:5
    |
 LL |     s.write(b"test").unwrap();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: read amount is not handled. Use `Read::read_exact` instead
-  --> $DIR/unused_io_amount.rs:16:5
+  --> $DIR/unused_io_amount.rs:18:5
    |
 LL |     s.read(&mut buf).unwrap();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: read amount is not handled
-  --> $DIR/unused_io_amount.rs:20:5
+  --> $DIR/unused_io_amount.rs:22:5
    |
 LL |     s.read_vectored(&mut [io::IoSliceMut::new(&mut [])])?;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: written amount is not handled
-  --> $DIR/unused_io_amount.rs:21:5
+  --> $DIR/unused_io_amount.rs:23:5
    |
 LL |     s.write_vectored(&[io::IoSlice::new(&[])])?;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: read amount is not handled. Use `Read::read_exact` instead
-  --> $DIR/unused_io_amount.rs:28:5
+  --> $DIR/unused_io_amount.rs:30:5
    |
 LL |     reader.read(&mut result).ok()?;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: read amount is not handled. Use `Read::read_exact` instead
-  --> $DIR/unused_io_amount.rs:37:5
+  --> $DIR/unused_io_amount.rs:39:5
    |
 LL |     reader.read(&mut result).or_else(|err| Err(err))?;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: read amount is not handled. Use `Read::read_exact` instead
-  --> $DIR/unused_io_amount.rs:49:5
+  --> $DIR/unused_io_amount.rs:51:5
    |
 LL |     reader.read(&mut result).or(Err(Error::Kind))?;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: read amount is not handled. Use `Read::read_exact` instead
-  --> $DIR/unused_io_amount.rs:56:5
+  --> $DIR/unused_io_amount.rs:58:5
    |
 LL | /     reader
 LL | |         .read(&mut result)
@@ -64,5 +64,41 @@ LL | |         .or(Err(Error::Kind))
 LL | |         .expect("error");
    | |________________________^
 
-error: aborting due to 10 previous errors
+error: written amount is not handled. Use `AsyncWriteExt::write_all` instead
+  --> $DIR/unused_io_amount.rs:67:5
+   |
+LL |     w.write(b"hello world").await.unwrap();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: read amount is not handled. Use `AsyncReadExt::read_exact` instead
+  --> $DIR/unused_io_amount.rs:72:5
+   |
+LL |     r.read(&mut buf[..]).await.unwrap();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: written amount is not handled. Use `AsyncWriteExt::write_all` instead
+  --> $DIR/unused_io_amount.rs:85:9
+   |
+LL |         w.write(b"hello world").await?;
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: read amount is not handled. Use `AsyncReadExt::read_exact` instead
+  --> $DIR/unused_io_amount.rs:93:9
+   |
+LL |         r.read(&mut buf[..]).await.or(Err(Error::Kind))?;
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: written amount is not handled. Use `AsyncWriteExt::write_all` instead
+  --> $DIR/unused_io_amount.rs:101:5
+   |
+LL |     w.write(b"hello world").await.unwrap();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: read amount is not handled. Use `AsyncReadExt::read_exact` instead
+  --> $DIR/unused_io_amount.rs:106:5
+   |
+LL |     r.read(&mut buf[..]).await.unwrap();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 16 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From b6bcf0c51b0d719cfd141c1c010b41ebe74f2abb Mon Sep 17 00:00:00 2001
From: Nick Mathewson <nickm@torproject.org>
Date: Fri, 31 Dec 2021 12:20:02 -0500
Subject: unused_io_amount: Use span_lint_and_help.

This improves the quality of the genrated output and makes it
more in line with other lint messages.

changelog: [`unused_io_amount`]: Improve help text
---
 clippy_lints/src/unused_io_amount.rs | 26 +++++++++++------
 tests/ui/unused_io_amount.stderr     | 55 +++++++++++++++++++++++++++---------
 2 files changed, 58 insertions(+), 23 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unused_io_amount.rs b/clippy_lints/src/unused_io_amount.rs
index 8afd8472db7..287ac5b4a90 100644
--- a/clippy_lints/src/unused_io_amount.rs
+++ b/clippy_lints/src/unused_io_amount.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint;
+use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
 use clippy_utils::{is_try, match_trait_method, paths};
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass};
@@ -126,32 +126,40 @@ fn check_method_call(cx: &LateContext<'_>, call: &hir::Expr<'_>, expr: &hir::Exp
         };
 
         match (read_trait, write_trait, symbol, is_await) {
-            (true, _, "read", false) => span_lint(
+            (true, _, "read", false) => span_lint_and_help(
                 cx,
                 UNUSED_IO_AMOUNT,
                 expr.span,
-                "read amount is not handled. Use `Read::read_exact` instead",
+                "read amount is not handled",
+                None,
+                "use `Read::read_exact` instead, or handle partial reads",
             ),
-            (true, _, "read", true) => span_lint(
+            (true, _, "read", true) => span_lint_and_help(
                 cx,
                 UNUSED_IO_AMOUNT,
                 expr.span,
-                "read amount is not handled. Use `AsyncReadExt::read_exact` instead",
+                "read amount is not handled",
+                None,
+                "use `AsyncReadExt::read_exact` instead, or handle partial reads",
             ),
             (true, _, "read_vectored", _) => {
                 span_lint(cx, UNUSED_IO_AMOUNT, expr.span, "read amount is not handled");
             },
-            (_, true, "write", false) => span_lint(
+            (_, true, "write", false) => span_lint_and_help(
                 cx,
                 UNUSED_IO_AMOUNT,
                 expr.span,
-                "written amount is not handled. Use `Write::write_all` instead",
+                "written amount is not handled",
+                None,
+                "use `Write::write_all` instead, or handle partial writes",
             ),
-            (_, true, "write", true) => span_lint(
+            (_, true, "write", true) => span_lint_and_help(
                 cx,
                 UNUSED_IO_AMOUNT,
                 expr.span,
-                "written amount is not handled. Use `AsyncWriteExt::write_all` instead",
+                "written amount is not handled",
+                None,
+                "use `AsyncWriteExt::write_all` instead, or handle partial writes",
             ),
             (_, true, "write_vectored", _) => {
                 span_lint(cx, UNUSED_IO_AMOUNT, expr.span, "written amount is not handled");
diff --git a/tests/ui/unused_io_amount.stderr b/tests/ui/unused_io_amount.stderr
index 3852d0622d6..e5bdd993aa1 100644
--- a/tests/ui/unused_io_amount.stderr
+++ b/tests/ui/unused_io_amount.stderr
@@ -1,28 +1,35 @@
-error: written amount is not handled. Use `Write::write_all` instead
+error: written amount is not handled
   --> $DIR/unused_io_amount.rs:9:5
    |
 LL |     s.write(b"test")?;
    |     ^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::unused-io-amount` implied by `-D warnings`
+   = help: use `Write::write_all` instead, or handle partial writes
 
-error: read amount is not handled. Use `Read::read_exact` instead
+error: read amount is not handled
   --> $DIR/unused_io_amount.rs:11:5
    |
 LL |     s.read(&mut buf)?;
    |     ^^^^^^^^^^^^^^^^^
+   |
+   = help: use `Read::read_exact` instead, or handle partial reads
 
-error: written amount is not handled. Use `Write::write_all` instead
+error: written amount is not handled
   --> $DIR/unused_io_amount.rs:16:5
    |
 LL |     s.write(b"test").unwrap();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use `Write::write_all` instead, or handle partial writes
 
-error: read amount is not handled. Use `Read::read_exact` instead
+error: read amount is not handled
   --> $DIR/unused_io_amount.rs:18:5
    |
 LL |     s.read(&mut buf).unwrap();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use `Read::read_exact` instead, or handle partial reads
 
 error: read amount is not handled
   --> $DIR/unused_io_amount.rs:22:5
@@ -36,25 +43,31 @@ error: written amount is not handled
 LL |     s.write_vectored(&[io::IoSlice::new(&[])])?;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: read amount is not handled. Use `Read::read_exact` instead
+error: read amount is not handled
   --> $DIR/unused_io_amount.rs:30:5
    |
 LL |     reader.read(&mut result).ok()?;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use `Read::read_exact` instead, or handle partial reads
 
-error: read amount is not handled. Use `Read::read_exact` instead
+error: read amount is not handled
   --> $DIR/unused_io_amount.rs:39:5
    |
 LL |     reader.read(&mut result).or_else(|err| Err(err))?;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use `Read::read_exact` instead, or handle partial reads
 
-error: read amount is not handled. Use `Read::read_exact` instead
+error: read amount is not handled
   --> $DIR/unused_io_amount.rs:51:5
    |
 LL |     reader.read(&mut result).or(Err(Error::Kind))?;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use `Read::read_exact` instead, or handle partial reads
 
-error: read amount is not handled. Use `Read::read_exact` instead
+error: read amount is not handled
   --> $DIR/unused_io_amount.rs:58:5
    |
 LL | /     reader
@@ -63,42 +76,56 @@ LL | |         .or(Err(Error::Kind))
 LL | |         .or(Err(Error::Kind))
 LL | |         .expect("error");
    | |________________________^
+   |
+   = help: use `Read::read_exact` instead, or handle partial reads
 
-error: written amount is not handled. Use `AsyncWriteExt::write_all` instead
+error: written amount is not handled
   --> $DIR/unused_io_amount.rs:67:5
    |
 LL |     w.write(b"hello world").await.unwrap();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use `AsyncWriteExt::write_all` instead, or handle partial writes
 
-error: read amount is not handled. Use `AsyncReadExt::read_exact` instead
+error: read amount is not handled
   --> $DIR/unused_io_amount.rs:72:5
    |
 LL |     r.read(&mut buf[..]).await.unwrap();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use `AsyncReadExt::read_exact` instead, or handle partial reads
 
-error: written amount is not handled. Use `AsyncWriteExt::write_all` instead
+error: written amount is not handled
   --> $DIR/unused_io_amount.rs:85:9
    |
 LL |         w.write(b"hello world").await?;
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use `AsyncWriteExt::write_all` instead, or handle partial writes
 
-error: read amount is not handled. Use `AsyncReadExt::read_exact` instead
+error: read amount is not handled
   --> $DIR/unused_io_amount.rs:93:9
    |
 LL |         r.read(&mut buf[..]).await.or(Err(Error::Kind))?;
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use `AsyncReadExt::read_exact` instead, or handle partial reads
 
-error: written amount is not handled. Use `AsyncWriteExt::write_all` instead
+error: written amount is not handled
   --> $DIR/unused_io_amount.rs:101:5
    |
 LL |     w.write(b"hello world").await.unwrap();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use `AsyncWriteExt::write_all` instead, or handle partial writes
 
-error: read amount is not handled. Use `AsyncReadExt::read_exact` instead
+error: read amount is not handled
   --> $DIR/unused_io_amount.rs:106:5
    |
 LL |     r.read(&mut buf[..]).await.unwrap();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use `AsyncReadExt::read_exact` instead, or handle partial reads
 
 error: aborting due to 16 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 3d41358a554cb70e23e001f6ac92cf79d805b671 Mon Sep 17 00:00:00 2001
From: Nick Mathewson <nickm@torproject.org>
Date: Fri, 31 Dec 2021 23:39:40 -0500
Subject: wrong_self_convention: Match `SelfKind::No` more restrictively

The `wrong_self_convention` lint uses a `SelfKind` type to decide
whether a method has the right kind of "self" for its name, or whether
the kind of "self" it has makes its name confusable for a method in
a common trait.  One possibility is `SelfKind::No`, which is supposed
to mean "No `self`".

Previously, SelfKind::No matched everything _except_ Self, including
references to Self.  This patch changes it to match Self, &Self, &mut
Self, Box<Self>, and so on.

For example, this kind of method was allowed before:

```
impl S {
    // Should trigger the lint, because
    // "methods called `is_*` usually take `self` by reference or no `self`"
    fn is_foo(&mut self) -> bool { todo!() }
}
```

But since SelfKind::No matched "&mut self", no lint was triggered
(see #8142).

With this patch, the code above now gives a lint as expected.

Fixes #8142

changelog: [`wrong_self_convention`] rejects `self` references in more cases
---
 clippy_lints/src/methods/mod.rs       |  8 +++++++-
 clippy_lints/src/redundant_clone.rs   |  4 ++--
 tests/ui/issue_4266.stderr            | 11 ++++++++++-
 tests/ui/wrong_self_convention.rs     | 21 +++++++++++++++++++++
 tests/ui/wrong_self_convention.stderr | 10 +++++++++-
 5 files changed, 49 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 4e33b2ff14c..8a2a468c852 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -2535,11 +2535,17 @@ impl SelfKind {
             implements_trait(cx, ty, trait_def_id, &[parent_ty.into()])
         }
 
+        fn matches_none<'a>(cx: &LateContext<'a>, parent_ty: Ty<'a>, ty: Ty<'a>) -> bool {
+            !matches_value(cx, parent_ty, ty)
+                && !matches_ref(cx, hir::Mutability::Not, parent_ty, ty)
+                && !matches_ref(cx, hir::Mutability::Mut, parent_ty, ty)
+        }
+
         match self {
             Self::Value => matches_value(cx, parent_ty, ty),
             Self::Ref => matches_ref(cx, hir::Mutability::Not, parent_ty, ty) || ty == parent_ty && is_copy(cx, ty),
             Self::RefMut => matches_ref(cx, hir::Mutability::Mut, parent_ty, ty),
-            Self::No => ty != parent_ty,
+            Self::No => matches_none(cx, parent_ty, ty),
         }
     }
 
diff --git a/clippy_lints/src/redundant_clone.rs b/clippy_lints/src/redundant_clone.rs
index 1cf349f8aa7..1991a01fb60 100644
--- a/clippy_lints/src/redundant_clone.rs
+++ b/clippy_lints/src/redundant_clone.rs
@@ -220,7 +220,7 @@ impl<'tcx> LateLintPass<'tcx> for RedundantClone {
                     continue;
                 } else if let Some(loc) = clone_usage.cloned_consume_or_mutate_loc {
                     // cloned value is mutated, and the clone is alive.
-                    if possible_borrower.is_alive_at(ret_local, loc) {
+                    if possible_borrower.local_is_alive_at(ret_local, loc) {
                         continue;
                     }
                 }
@@ -767,7 +767,7 @@ impl PossibleBorrowerMap<'_, '_> {
         self.bitset.0 == self.bitset.1
     }
 
-    fn is_alive_at(&mut self, local: mir::Local, at: mir::Location) -> bool {
+    fn local_is_alive_at(&mut self, local: mir::Local, at: mir::Location) -> bool {
         self.maybe_live.seek_after_primary_effect(at);
         self.maybe_live.contains(local)
     }
diff --git a/tests/ui/issue_4266.stderr b/tests/ui/issue_4266.stderr
index 20419457b47..e5042aaa776 100644
--- a/tests/ui/issue_4266.stderr
+++ b/tests/ui/issue_4266.stderr
@@ -12,5 +12,14 @@ error: explicit lifetimes given in parameter types where they could be elided (o
 LL | async fn one_to_one<'a>(s: &'a str) -> &'a str {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 2 previous errors
+error: methods called `new` usually take no `self`
+  --> $DIR/issue_4266.rs:27:22
+   |
+LL |     pub async fn new(&mut self) -> Self {
+   |                      ^^^^^^^^^
+   |
+   = note: `-D clippy::wrong-self-convention` implied by `-D warnings`
+   = help: consider choosing a less ambiguous name
+
+error: aborting due to 3 previous errors
 
diff --git a/tests/ui/wrong_self_convention.rs b/tests/ui/wrong_self_convention.rs
index 1b9da8a55e5..f8fee4b3ab2 100644
--- a/tests/ui/wrong_self_convention.rs
+++ b/tests/ui/wrong_self_convention.rs
@@ -188,3 +188,24 @@ mod issue6727 {
         }
     }
 }
+
+pub mod issue8142 {
+    struct S;
+
+    impl S {
+        // Should lint: is_ methods should only take &self, or no self at all.
+        fn is_still_buggy(&mut self) -> bool {
+            false
+        }
+
+        // Should not lint: "no self at all" is allowed.
+        fn is_forty_two(x: u32) -> bool {
+            x == 42
+        }
+
+        // Should not lint: &self is allowed.
+        fn is_test_code(&self) -> bool {
+            true
+        }
+    }
+}
diff --git a/tests/ui/wrong_self_convention.stderr b/tests/ui/wrong_self_convention.stderr
index 590ee6d9c52..5493a99572e 100644
--- a/tests/ui/wrong_self_convention.stderr
+++ b/tests/ui/wrong_self_convention.stderr
@@ -191,5 +191,13 @@ LL |         fn to_u64(self) -> u64 {
    |
    = help: consider choosing a less ambiguous name
 
-error: aborting due to 24 previous errors
+error: methods called `is_*` usually take `self` by reference or no `self`
+  --> $DIR/wrong_self_convention.rs:197:27
+   |
+LL |         fn is_still_buggy(&mut self) -> bool {
+   |                           ^^^^^^^^^
+   |
+   = help: consider choosing a less ambiguous name
+
+error: aborting due to 25 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 262b148d8830efa4773f05b27403f94e47d27f52 Mon Sep 17 00:00:00 2001
From: bors <bors@rust-lang.org>
Date: Sat, 1 Jan 2022 13:16:49 +0000
Subject: return_self_not_must_use document `#[must_use]` on the type

Inspired by a discussion in rust-lang/rust-clippy#8197

---

r? `@llogiq`

changelog: none

The lint is this on nightly, therefore no changelog entry for you xD
---
 clippy_lints/src/return_self_not_must_use.rs | 36 +++++++++++++++++++++++-----
 tests/ui/return_self_not_must_use.stderr     |  5 ++++
 2 files changed, 35 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/return_self_not_must_use.rs b/clippy_lints/src/return_self_not_must_use.rs
index b57ec96bc7e..935bbc37d75 100644
--- a/clippy_lints/src/return_self_not_must_use.rs
+++ b/clippy_lints/src/return_self_not_must_use.rs
@@ -1,5 +1,6 @@
+use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::ty::is_must_use_ty;
-use clippy_utils::{diagnostics::span_lint, nth_arg, return_ty};
+use clippy_utils::{nth_arg, return_ty};
 use rustc_hir::def_id::LocalDefId;
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::{Body, FnDecl, HirId, TraitItem, TraitItemKind};
@@ -13,25 +14,46 @@ declare_clippy_lint! {
     /// This lint warns when a method returning `Self` doesn't have the `#[must_use]` attribute.
     ///
     /// ### Why is this bad?
-    /// It prevents to "forget" to use the newly created value.
+    /// Methods returning `Self` often create new values, having the `#[must_use]` attribute
+    /// prevents users from "forgetting" to use the newly created value.
+    ///
+    /// The `#[must_use]` attribute can be added to the type itself to ensure that instances
+    /// are never forgotten. Functions returning a type marked with `#[must_use]` will not be
+    /// linted, as the usage is already enforced by the type attribute.
     ///
     /// ### Limitations
     /// This lint is only applied on methods taking a `self` argument. It would be mostly noise
     /// if it was added on constructors for example.
     ///
     /// ### Example
+    /// Missing attribute
     /// ```rust
     /// pub struct Bar;
-    ///
     /// impl Bar {
     ///     // Bad
     ///     pub fn bar(&self) -> Self {
     ///         Self
     ///     }
+    /// }
+    /// ```
     ///
-    ///     // Good
+    /// It's better to have the `#[must_use]` attribute on the method like this:
+    /// ```rust
+    /// pub struct Bar;
+    /// impl Bar {
     ///     #[must_use]
-    ///     pub fn foo(&self) -> Self {
+    ///     pub fn bar(&self) -> Self {
+    ///         Self
+    ///     }
+    /// }
+    /// ```
+    ///
+    /// Or on the type definition like this:
+    /// ```rust
+    /// #[must_use]
+    /// pub struct Bar;
+    /// impl Bar {
+    ///     pub fn bar(&self) -> Self {
     ///         Self
     ///     }
     /// }
@@ -65,11 +87,13 @@ fn check_method(cx: &LateContext<'tcx>, decl: &'tcx FnDecl<'tcx>, fn_def: LocalD
         if !is_must_use_ty(cx, ret_ty);
 
         then {
-            span_lint(
+            span_lint_and_help(
                 cx,
                 RETURN_SELF_NOT_MUST_USE,
                 span,
                 "missing `#[must_use]` attribute on a method returning `Self`",
+                None,
+                "consider adding the `#[must_use]` attribute to the method or directly to the `Self` type"
             );
         }
     }
diff --git a/tests/ui/return_self_not_must_use.stderr b/tests/ui/return_self_not_must_use.stderr
index 3793a5559ba..8af10cb65c4 100644
--- a/tests/ui/return_self_not_must_use.stderr
+++ b/tests/ui/return_self_not_must_use.stderr
@@ -5,6 +5,7 @@ LL |     fn what(&self) -> Self;
    |     ^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::return-self-not-must-use` implied by `-D warnings`
+   = help: consider adding the `#[must_use]` attribute to the method or directly to the `Self` type
 
 error: missing `#[must_use]` attribute on a method returning `Self`
   --> $DIR/return_self_not_must_use.rs:17:5
@@ -13,6 +14,8 @@ LL | /     pub fn foo(&self) -> Self {
 LL | |         Self
 LL | |     }
    | |_____^
+   |
+   = help: consider adding the `#[must_use]` attribute to the method or directly to the `Self` type
 
 error: missing `#[must_use]` attribute on a method returning `Self`
   --> $DIR/return_self_not_must_use.rs:20:5
@@ -21,6 +24,8 @@ LL | /     pub fn bar(self) -> Self {
 LL | |         self
 LL | |     }
    | |_____^
+   |
+   = help: consider adding the `#[must_use]` attribute to the method or directly to the `Self` type
 
 error: aborting due to 3 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From e8b6b2ac0c115e7208d725b4f6340e68194d0cf3 Mon Sep 17 00:00:00 2001
From: Wigy <attila@parity.io>
Date: Fri, 31 Dec 2021 09:37:39 +0100
Subject: erasing_op lint ignored when output type is different from the
 non-const one

---
 clippy_lints/src/erasing_op.rs | 26 +++++++++++++++++++-------
 tests/ui/erasing_op.rs         | 34 ++++++++++++++++++++++++++++++++++
 tests/ui/erasing_op.stderr     | 20 ++++++++++++++++----
 tests/ui/identity_op.rs        | 13 +++++++++++++
 tests/ui/identity_op.stderr    | 26 +++++++++++++-------------
 5 files changed, 95 insertions(+), 24 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/erasing_op.rs b/clippy_lints/src/erasing_op.rs
index d49cec26be5..bb6acd8c5dd 100644
--- a/clippy_lints/src/erasing_op.rs
+++ b/clippy_lints/src/erasing_op.rs
@@ -1,9 +1,11 @@
 use clippy_utils::consts::{constant_simple, Constant};
 use clippy_utils::diagnostics::span_lint;
+use clippy_utils::ty::same_type_and_consts;
+
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::TypeckResults;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::source_map::Span;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -35,24 +37,34 @@ impl<'tcx> LateLintPass<'tcx> for ErasingOp {
             return;
         }
         if let ExprKind::Binary(ref cmp, left, right) = e.kind {
+            let tck = cx.typeck_results();
             match cmp.node {
                 BinOpKind::Mul | BinOpKind::BitAnd => {
-                    check(cx, left, e.span);
-                    check(cx, right, e.span);
+                    check(cx, tck, left, right, e);
+                    check(cx, tck, right, left, e);
                 },
-                BinOpKind::Div => check(cx, left, e.span),
+                BinOpKind::Div => check(cx, tck, left, right, e),
                 _ => (),
             }
         }
     }
 }
 
-fn check(cx: &LateContext<'_>, e: &Expr<'_>, span: Span) {
-    if constant_simple(cx, cx.typeck_results(), e) == Some(Constant::Int(0)) {
+fn different_types(tck: &TypeckResults<'tcx>, input: &'tcx Expr<'_>, output: &'tcx Expr<'_>) -> bool {
+    let input_ty = tck.expr_ty(input).peel_refs();
+    let output_ty = tck.expr_ty(output).peel_refs();
+    !same_type_and_consts(input_ty, output_ty)
+}
+
+fn check(cx: &LateContext<'cx>, tck: &TypeckResults<'cx>, op: &Expr<'cx>, other: &Expr<'cx>, parent: &Expr<'cx>) {
+    if constant_simple(cx, tck, op) == Some(Constant::Int(0)) {
+        if different_types(tck, other, parent) {
+            return;
+        }
         span_lint(
             cx,
             ERASING_OP,
-            span,
+            parent.span,
             "this operation will always return zero. This is likely not the intended outcome",
         );
     }
diff --git a/tests/ui/erasing_op.rs b/tests/ui/erasing_op.rs
index 1540062a4bc..ae2fad0086d 100644
--- a/tests/ui/erasing_op.rs
+++ b/tests/ui/erasing_op.rs
@@ -1,3 +1,34 @@
+struct Length(u8);
+struct Meter;
+
+impl core::ops::Mul<Meter> for u8 {
+    type Output = Length;
+    fn mul(self, _: Meter) -> Length {
+        Length(self)
+    }
+}
+
+#[derive(Clone, Default, PartialEq, Eq, Hash)]
+struct Vec1 {
+    x: i32,
+}
+
+impl core::ops::Mul<Vec1> for i32 {
+    type Output = Vec1;
+    fn mul(self, mut right: Vec1) -> Vec1 {
+        right.x *= self;
+        right
+    }
+}
+
+impl core::ops::Mul<i32> for Vec1 {
+    type Output = Vec1;
+    fn mul(mut self, right: i32) -> Vec1 {
+        self.x *= right;
+        self
+    }
+}
+
 #[allow(clippy::no_effect)]
 #[warn(clippy::erasing_op)]
 fn main() {
@@ -6,4 +37,7 @@ fn main() {
     x * 0;
     0 & x;
     0 / x;
+    0 * Meter; // no error: Output type is different from the non-zero argument
+    0 * Vec1 { x: 5 };
+    Vec1 { x: 5 } * 0;
 }
diff --git a/tests/ui/erasing_op.stderr b/tests/ui/erasing_op.stderr
index e54ce85f98e..165ed9bfe58 100644
--- a/tests/ui/erasing_op.stderr
+++ b/tests/ui/erasing_op.stderr
@@ -1,5 +1,5 @@
 error: this operation will always return zero. This is likely not the intended outcome
-  --> $DIR/erasing_op.rs:6:5
+  --> $DIR/erasing_op.rs:37:5
    |
 LL |     x * 0;
    |     ^^^^^
@@ -7,16 +7,28 @@ LL |     x * 0;
    = note: `-D clippy::erasing-op` implied by `-D warnings`
 
 error: this operation will always return zero. This is likely not the intended outcome
-  --> $DIR/erasing_op.rs:7:5
+  --> $DIR/erasing_op.rs:38:5
    |
 LL |     0 & x;
    |     ^^^^^
 
 error: this operation will always return zero. This is likely not the intended outcome
-  --> $DIR/erasing_op.rs:8:5
+  --> $DIR/erasing_op.rs:39:5
    |
 LL |     0 / x;
    |     ^^^^^
 
-error: aborting due to 3 previous errors
+error: this operation will always return zero. This is likely not the intended outcome
+  --> $DIR/erasing_op.rs:41:5
+   |
+LL |     0 * Vec1 { x: 5 };
+   |     ^^^^^^^^^^^^^^^^^
+
+error: this operation will always return zero. This is likely not the intended outcome
+  --> $DIR/erasing_op.rs:42:5
+   |
+LL |     Vec1 { x: 5 } * 0;
+   |     ^^^^^^^^^^^^^^^^^
+
+error: aborting due to 5 previous errors
 
diff --git a/tests/ui/identity_op.rs b/tests/ui/identity_op.rs
index 2ed4b5db574..12bbda71f43 100644
--- a/tests/ui/identity_op.rs
+++ b/tests/ui/identity_op.rs
@@ -11,6 +11,17 @@ impl std::ops::Shl<i32> for A {
         self
     }
 }
+
+struct Length(u8);
+struct Meter;
+
+impl core::ops::Mul<Meter> for u8 {
+    type Output = Length;
+    fn mul(self, _: Meter) -> Length {
+        Length(self)
+    }
+}
+
 #[allow(
     clippy::eq_op,
     clippy::no_effect,
@@ -53,4 +64,6 @@ fn main() {
 
     let mut a = A("".into());
     let b = a << 0; // no error: non-integer
+
+    1 * Meter; // no error: non-integer
 }
diff --git a/tests/ui/identity_op.stderr b/tests/ui/identity_op.stderr
index ff34b38db01..0103cf5457e 100644
--- a/tests/ui/identity_op.stderr
+++ b/tests/ui/identity_op.stderr
@@ -1,5 +1,5 @@
 error: the operation is ineffective. Consider reducing it to `x`
-  --> $DIR/identity_op.rs:26:5
+  --> $DIR/identity_op.rs:37:5
    |
 LL |     x + 0;
    |     ^^^^^
@@ -7,73 +7,73 @@ LL |     x + 0;
    = note: `-D clippy::identity-op` implied by `-D warnings`
 
 error: the operation is ineffective. Consider reducing it to `x`
-  --> $DIR/identity_op.rs:27:5
+  --> $DIR/identity_op.rs:38:5
    |
 LL |     x + (1 - 1);
    |     ^^^^^^^^^^^
 
 error: the operation is ineffective. Consider reducing it to `x`
-  --> $DIR/identity_op.rs:29:5
+  --> $DIR/identity_op.rs:40:5
    |
 LL |     0 + x;
    |     ^^^^^
 
 error: the operation is ineffective. Consider reducing it to `x`
-  --> $DIR/identity_op.rs:32:5
+  --> $DIR/identity_op.rs:43:5
    |
 LL |     x | (0);
    |     ^^^^^^^
 
 error: the operation is ineffective. Consider reducing it to `x`
-  --> $DIR/identity_op.rs:35:5
+  --> $DIR/identity_op.rs:46:5
    |
 LL |     x * 1;
    |     ^^^^^
 
 error: the operation is ineffective. Consider reducing it to `x`
-  --> $DIR/identity_op.rs:36:5
+  --> $DIR/identity_op.rs:47:5
    |
 LL |     1 * x;
    |     ^^^^^
 
 error: the operation is ineffective. Consider reducing it to `x`
-  --> $DIR/identity_op.rs:42:5
+  --> $DIR/identity_op.rs:53:5
    |
 LL |     -1 & x;
    |     ^^^^^^
 
 error: the operation is ineffective. Consider reducing it to `u`
-  --> $DIR/identity_op.rs:45:5
+  --> $DIR/identity_op.rs:56:5
    |
 LL |     u & 255;
    |     ^^^^^^^
 
 error: the operation is ineffective. Consider reducing it to `42`
-  --> $DIR/identity_op.rs:48:5
+  --> $DIR/identity_op.rs:59:5
    |
 LL |     42 << 0;
    |     ^^^^^^^
 
 error: the operation is ineffective. Consider reducing it to `1`
-  --> $DIR/identity_op.rs:49:5
+  --> $DIR/identity_op.rs:60:5
    |
 LL |     1 >> 0;
    |     ^^^^^^
 
 error: the operation is ineffective. Consider reducing it to `42`
-  --> $DIR/identity_op.rs:50:5
+  --> $DIR/identity_op.rs:61:5
    |
 LL |     42 >> 0;
    |     ^^^^^^^
 
 error: the operation is ineffective. Consider reducing it to `&x`
-  --> $DIR/identity_op.rs:51:5
+  --> $DIR/identity_op.rs:62:5
    |
 LL |     &x >> 0;
    |     ^^^^^^^
 
 error: the operation is ineffective. Consider reducing it to `x`
-  --> $DIR/identity_op.rs:52:5
+  --> $DIR/identity_op.rs:63:5
    |
 LL |     x >> &0;
    |     ^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From ff58efb2b26e395f2887dad2f904aee26da3dc13 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Mon, 3 Jan 2022 23:13:31 -0500
Subject: Better detect when a field can be moved from in
 `while_let_on_iterator`

---
 clippy_lints/src/loops/while_let_on_iterator.rs | 35 ++++++++++++++++++-------
 tests/ui/while_let_on_iterator.fixed            | 30 +++++++++++++++++++++
 tests/ui/while_let_on_iterator.rs               | 30 +++++++++++++++++++++
 tests/ui/while_let_on_iterator.stderr           | 16 +++++++++--
 4 files changed, 100 insertions(+), 11 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/while_let_on_iterator.rs b/clippy_lints/src/loops/while_let_on_iterator.rs
index b390476a664..942d6ca6b4a 100644
--- a/clippy_lints/src/loops/while_let_on_iterator.rs
+++ b/clippy_lints/src/loops/while_let_on_iterator.rs
@@ -8,12 +8,13 @@ use clippy_utils::{
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_expr, ErasedMap, NestedVisitorMap, Visitor};
-use rustc_hir::{def::Res, Expr, ExprKind, HirId, Local, PatKind, QPath, UnOp};
+use rustc_hir::{def::Res, Expr, ExprKind, HirId, Local, Mutability, PatKind, QPath, UnOp};
 use rustc_lint::LateContext;
-use rustc_span::{symbol::sym, Span, Symbol};
+use rustc_middle::ty::adjustment::Adjust;
+use rustc_span::{symbol::sym, Symbol};
 
 pub(super) fn check(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-    let (scrutinee_expr, iter_expr, some_pat, loop_expr) = if_chain! {
+    let (scrutinee_expr, iter_expr_struct, iter_expr, some_pat, loop_expr) = if_chain! {
         if let Some(higher::WhileLet { if_then, let_pat, let_expr }) = higher::WhileLet::hir(expr);
         // check for `Some(..)` pattern
         if let PatKind::TupleStruct(QPath::Resolved(None, pat_path), some_pat, _) = let_pat.kind;
@@ -27,7 +28,7 @@ pub(super) fn check(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         // get the loop containing the match expression
         if !uses_iter(cx, &iter_expr_struct, if_then);
         then {
-            (let_expr, iter_expr_struct, some_pat, expr)
+            (let_expr, iter_expr_struct, iter_expr, some_pat, expr)
         } else {
             return;
         }
@@ -47,7 +48,11 @@ pub(super) fn check(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
     // If the iterator is a field or the iterator is accessed after the loop is complete it needs to be
     // borrowed mutably. TODO: If the struct can be partially moved from and the struct isn't used
     // afterwards a mutable borrow of a field isn't necessary.
-    let by_ref = if !iter_expr.fields.is_empty() || needs_mutable_borrow(cx, &iter_expr, loop_expr) {
+    let by_ref = if cx.typeck_results().expr_ty(iter_expr).ref_mutability() == Some(Mutability::Mut)
+        || !iter_expr_struct.can_move
+        || !iter_expr_struct.fields.is_empty()
+        || needs_mutable_borrow(cx, &iter_expr_struct, loop_expr)
+    {
         ".by_ref()"
     } else {
         ""
@@ -67,26 +72,36 @@ pub(super) fn check(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
 
 #[derive(Debug)]
 struct IterExpr {
-    /// The span of the whole expression, not just the path and fields stored here.
-    span: Span,
     /// The fields used, in order of child to parent.
     fields: Vec<Symbol>,
     /// The path being used.
     path: Res,
+    /// Whether or not the iterator can be moved.
+    can_move: bool,
 }
 
 /// Parses any expression to find out which field of which variable is used. Will return `None` if
 /// the expression might have side effects.
 fn try_parse_iter_expr(cx: &LateContext<'_>, mut e: &Expr<'_>) -> Option<IterExpr> {
-    let span = e.span;
     let mut fields = Vec::new();
+    let mut can_move = true;
     loop {
+        if cx
+            .typeck_results()
+            .expr_adjustments(e)
+            .iter()
+            .any(|a| matches!(a.kind, Adjust::Deref(Some(..))))
+        {
+            // Custom deref impls need to borrow the whole value as it's captured by reference
+            can_move = false;
+            fields.clear();
+        }
         match e.kind {
             ExprKind::Path(ref path) => {
                 break Some(IterExpr {
-                    span,
                     fields,
                     path: cx.qpath_res(path, e.hir_id),
+                    can_move,
                 });
             },
             ExprKind::Field(base, name) => {
@@ -99,10 +114,12 @@ fn try_parse_iter_expr(cx: &LateContext<'_>, mut e: &Expr<'_>) -> Option<IterExp
             // Shouldn't have side effects, but there's no way to trace which field is used. So forget which fields have
             // already been seen.
             ExprKind::Index(base, idx) if !idx.can_have_side_effects() => {
+                can_move = false;
                 fields.clear();
                 e = base;
             },
             ExprKind::Unary(UnOp::Deref, base) => {
+                can_move = false;
                 fields.clear();
                 e = base;
             },
diff --git a/tests/ui/while_let_on_iterator.fixed b/tests/ui/while_let_on_iterator.fixed
index 1e74ad2de65..cb8892a3f00 100644
--- a/tests/ui/while_let_on_iterator.fixed
+++ b/tests/ui/while_let_on_iterator.fixed
@@ -372,6 +372,36 @@ fn exact_match_with_single_field() {
     }
 }
 
+fn custom_deref() {
+    struct S1<T> {
+        x: T,
+    }
+    struct S2<T>(S1<T>);
+    impl<T> core::ops::Deref for S2<T> {
+        type Target = S1<T>;
+        fn deref(&self) -> &Self::Target {
+            &self.0
+        }
+    }
+    impl<T> core::ops::DerefMut for S2<T> {
+        fn deref_mut(&mut self) -> &mut Self::Target {
+            &mut self.0
+        }
+    }
+
+    let mut s = S2(S1 { x: 0..10 });
+    for x in s.x.by_ref() {
+        println!("{}", x);
+    }
+}
+
+fn issue_8113() {
+    let mut x = [0..10];
+    for x in x[0].by_ref() {
+        println!("{}", x);
+    }
+}
+
 fn main() {
     let mut it = 0..20;
     for _ in it {
diff --git a/tests/ui/while_let_on_iterator.rs b/tests/ui/while_let_on_iterator.rs
index 69cb636cee8..d9157184495 100644
--- a/tests/ui/while_let_on_iterator.rs
+++ b/tests/ui/while_let_on_iterator.rs
@@ -372,6 +372,36 @@ fn exact_match_with_single_field() {
     }
 }
 
+fn custom_deref() {
+    struct S1<T> {
+        x: T,
+    }
+    struct S2<T>(S1<T>);
+    impl<T> core::ops::Deref for S2<T> {
+        type Target = S1<T>;
+        fn deref(&self) -> &Self::Target {
+            &self.0
+        }
+    }
+    impl<T> core::ops::DerefMut for S2<T> {
+        fn deref_mut(&mut self) -> &mut Self::Target {
+            &mut self.0
+        }
+    }
+
+    let mut s = S2(S1 { x: 0..10 });
+    while let Some(x) = s.x.next() {
+        println!("{}", x);
+    }
+}
+
+fn issue_8113() {
+    let mut x = [0..10];
+    while let Some(x) = x[0].next() {
+        println!("{}", x);
+    }
+}
+
 fn main() {
     let mut it = 0..20;
     while let Some(..) = it.next() {
diff --git a/tests/ui/while_let_on_iterator.stderr b/tests/ui/while_let_on_iterator.stderr
index 1a11ba26eef..fb2b0f2467c 100644
--- a/tests/ui/while_let_on_iterator.stderr
+++ b/tests/ui/while_let_on_iterator.stderr
@@ -123,10 +123,22 @@ LL |     while let Some(x) = it.0.next() {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for x in it.0.by_ref()`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:377:5
+  --> $DIR/while_let_on_iterator.rs:393:5
+   |
+LL |     while let Some(x) = s.x.next() {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for x in s.x.by_ref()`
+
+error: this loop could be written as a `for` loop
+  --> $DIR/while_let_on_iterator.rs:400:5
+   |
+LL |     while let Some(x) = x[0].next() {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for x in x[0].by_ref()`
+
+error: this loop could be written as a `for` loop
+  --> $DIR/while_let_on_iterator.rs:407:5
    |
 LL |     while let Some(..) = it.next() {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for _ in it`
 
-error: aborting due to 21 previous errors
+error: aborting due to 23 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 00da1b8f14989b57e56ed28da177b5819a2b53f9 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Tue, 4 Jan 2022 11:58:39 -0600
Subject: Remove in_macro from utils

---
 clippy_lints/src/init_numbered_fields.rs | 3 +--
 clippy_lints/src/macro_use.rs            | 6 +++++-
 clippy_utils/src/lib.rs                  | 7 -------
 3 files changed, 6 insertions(+), 10 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/init_numbered_fields.rs b/clippy_lints/src/init_numbered_fields.rs
index 5fe6725b581..9284e002409 100644
--- a/clippy_lints/src/init_numbered_fields.rs
+++ b/clippy_lints/src/init_numbered_fields.rs
@@ -1,5 +1,4 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::in_macro;
 use clippy_utils::source::snippet_with_applicability;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
@@ -46,7 +45,7 @@ impl<'tcx> LateLintPass<'tcx> for NumberedFields {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
         if let ExprKind::Struct(path, fields, None) = e.kind {
             if !fields.is_empty()
-                && !in_macro(e.span)
+                && !e.span.from_expansion()
                 && fields
                     .iter()
                     .all(|f| f.ident.as_str().as_bytes().iter().all(u8::is_ascii_digit))
diff --git a/clippy_lints/src/macro_use.rs b/clippy_lints/src/macro_use.rs
index bbc14fc535d..262a26951c6 100644
--- a/clippy_lints/src/macro_use.rs
+++ b/clippy_lints/src/macro_use.rs
@@ -1,5 +1,4 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::in_macro;
 use clippy_utils::source::snippet;
 use hir::def::{DefKind, Res};
 use if_chain::if_chain;
@@ -9,6 +8,7 @@ use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::hygiene::ExpnKind;
 use rustc_span::{edition::Edition, sym, Span};
 
 declare_clippy_lint! {
@@ -214,3 +214,7 @@ impl<'tcx> LateLintPass<'tcx> for MacroUseImports {
         }
     }
 }
+
+fn in_macro(span: Span) -> bool {
+    span.from_expansion() && !matches!(span.ctxt().outer_expn_data().kind, ExpnKind::Desugaring(..))
+}
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 54d470ca738..c6bf96d5193 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -147,13 +147,6 @@ macro_rules! extract_msrv_attr {
     };
 }
 
-/// Returns `true` if the span comes from a macro expansion, no matter if from a
-/// macro by example or from a procedural macro
-#[must_use]
-pub fn in_macro(span: Span) -> bool {
-    span.from_expansion() && !matches!(span.ctxt().outer_expn_data().kind, ExpnKind::Desugaring(..))
-}
-
 /// Returns `true` if the two spans come from differing expansions (i.e., one is
 /// from a macro and one isn't).
 #[must_use]
-- 
cgit 1.4.1-3-g733a5


From 2dd216a186bc3b0cea9b2afe889f99aa9f0a5d9f Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Tue, 4 Jan 2022 14:20:27 -0500
Subject: Check for full equality in `type_repetition_in_bounds` rather than
 just equal hashes

---
 clippy_lints/src/trait_bounds.rs      | 39 +++++++++++++++++++++++++----------
 clippy_utils/src/hir_utils.rs         |  4 +++-
 tests/ui/type_repetition_in_bounds.rs | 10 +++++++++
 3 files changed, 41 insertions(+), 12 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/trait_bounds.rs b/clippy_lints/src/trait_bounds.rs
index fb4abceac25..f2848ad3790 100644
--- a/clippy_lints/src/trait_bounds.rs
+++ b/clippy_lints/src/trait_bounds.rs
@@ -1,11 +1,12 @@
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::source::{snippet, snippet_with_applicability};
-use clippy_utils::SpanlessHash;
+use clippy_utils::{SpanlessEq, SpanlessHash};
+use core::hash::{Hash, Hasher};
 use if_chain::if_chain;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_data_structures::unhash::UnhashMap;
 use rustc_errors::Applicability;
-use rustc_hir::{def::Res, GenericBound, Generics, ParamName, Path, QPath, TyKind, WherePredicate};
+use rustc_hir::{def::Res, GenericBound, Generics, ParamName, Path, QPath, Ty, TyKind, WherePredicate};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::Span;
@@ -94,24 +95,40 @@ fn get_trait_res_span_from_bound(bound: &GenericBound<'_>) -> Option<(Res, Span)
 }
 
 impl TraitBounds {
-    fn check_type_repetition(self, cx: &LateContext<'_>, gen: &'_ Generics<'_>) {
+    fn check_type_repetition<'tcx>(self, cx: &LateContext<'tcx>, gen: &'tcx Generics<'_>) {
+        struct SpanlessTy<'cx, 'tcx> {
+            ty: &'tcx Ty<'tcx>,
+            cx: &'cx LateContext<'tcx>,
+        }
+        impl PartialEq for SpanlessTy<'_, '_> {
+            fn eq(&self, other: &Self) -> bool {
+                let mut eq = SpanlessEq::new(self.cx);
+                eq.inter_expr().eq_ty(self.ty, other.ty)
+            }
+        }
+        impl Hash for SpanlessTy<'_, '_> {
+            fn hash<H: Hasher>(&self, h: &mut H) {
+                let mut t = SpanlessHash::new(self.cx);
+                t.hash_ty(self.ty);
+                h.write_u64(t.finish());
+            }
+        }
+        impl Eq for SpanlessTy<'_, '_> {}
+
         if gen.span.from_expansion() {
             return;
         }
-        let hash = |ty| -> u64 {
-            let mut hasher = SpanlessHash::new(cx);
-            hasher.hash_ty(ty);
-            hasher.finish()
-        };
-        let mut map: UnhashMap<u64, Vec<&GenericBound<'_>>> = UnhashMap::default();
+        let mut map: UnhashMap<SpanlessTy<'_, '_>, Vec<&GenericBound<'_>>> = UnhashMap::default();
         let mut applicability = Applicability::MaybeIncorrect;
         for bound in gen.where_clause.predicates {
             if_chain! {
                 if let WherePredicate::BoundPredicate(ref p) = bound;
                 if p.bounds.len() as u64 <= self.max_trait_bounds;
                 if !p.span.from_expansion();
-                let h = hash(p.bounded_ty);
-                if let Some(ref v) = map.insert(h, p.bounds.iter().collect::<Vec<_>>());
+                if let Some(ref v) = map.insert(
+                    SpanlessTy { ty: p.bounded_ty, cx },
+                    p.bounds.iter().collect::<Vec<_>>()
+                );
 
                 then {
                     let mut hint_string = format!(
diff --git a/clippy_utils/src/hir_utils.rs b/clippy_utils/src/hir_utils.rs
index ad50759effa..9df296beb60 100644
--- a/clippy_utils/src/hir_utils.rs
+++ b/clippy_utils/src/hir_utils.rs
@@ -388,7 +388,7 @@ impl HirEqInterExpr<'_, '_, '_> {
     }
 
     #[allow(clippy::similar_names)]
-    fn eq_ty(&mut self, left: &Ty<'_>, right: &Ty<'_>) -> bool {
+    pub fn eq_ty(&mut self, left: &Ty<'_>, right: &Ty<'_>) -> bool {
         match (&left.kind, &right.kind) {
             (&TyKind::Slice(l_vec), &TyKind::Slice(r_vec)) => self.eq_ty(l_vec, r_vec),
             (&TyKind::Array(lt, ref ll_id), &TyKind::Array(rt, ref rl_id)) => {
@@ -845,6 +845,8 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> {
     pub fn hash_path(&mut self, path: &Path<'_>) {
         match path.res {
             // constant hash since equality is dependant on inter-expression context
+            // e.g. The expressions `if let Some(x) = foo() {}` and `if let Some(y) = foo() {}` are considered equal
+            // even though the binding names are different and they have different `HirId`s.
             Res::Local(_) => 1_usize.hash(&mut self.s),
             _ => {
                 for seg in path.segments {
diff --git a/tests/ui/type_repetition_in_bounds.rs b/tests/ui/type_repetition_in_bounds.rs
index 766190f2099..fc740ee11d6 100644
--- a/tests/ui/type_repetition_in_bounds.rs
+++ b/tests/ui/type_repetition_in_bounds.rs
@@ -69,4 +69,14 @@ mod issue4326 {
     }
 }
 
+// Issue #7360
+struct Foo<T, U>
+where
+    T: Clone,
+    U: Clone,
+{
+    t: T,
+    u: U,
+}
+
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 786f874c349b995ebed5e3d8f20db1cf65f20782 Mon Sep 17 00:00:00 2001
From: bors <bors@rust-lang.org>
Date: Tue, 4 Jan 2022 22:32:02 +0000
Subject: New macro utils

changelog: none

Sorry, this is a big one. A lot of interrelated changes and I wanted to put the new utils to use to make sure they are somewhat battle-tested. We may want to divide some of the lint-specific refactoring commits into batches for smaller reviewing tasks. I could also split into more PRs.

Introduces a bunch of new utils at `clippy_utils::macros::...`. Please read through the docs and give any feedback! I'm happy to introduce `MacroCall` and various functions to retrieve an instance. It feels like the missing puzzle piece. I'm also introducing `ExpnId` from rustc as "useful for Clippy too". `@rust-lang/clippy`

Fixes #7843 by not parsing every node of macro implementations, at least the major offenders.

I probably want to get rid of `is_expn_of` at some point.
---
 clippy_lints/src/assertions_on_constants.rs   | 120 ++----
 clippy_lints/src/attrs.rs                     |  18 +-
 clippy_lints/src/bool_assert_comparison.rs    |  73 ++--
 clippy_lints/src/doc.rs                       |  33 +-
 clippy_lints/src/eq_op.rs                     |  45 +--
 clippy_lints/src/explicit_write.rs            |   6 +-
 clippy_lints/src/fallible_impl_from.rs        |  15 +-
 clippy_lints/src/format.rs                    |  33 +-
 clippy_lints/src/format_args.rs               |  53 +--
 clippy_lints/src/manual_assert.rs             |  68 +---
 clippy_lints/src/matches.rs                   |  24 +-
 clippy_lints/src/methods/expect_fun_call.rs   |  21 +-
 clippy_lints/src/mutable_debug_assertion.rs   |  42 +-
 clippy_lints/src/panic_in_result_fn.rs        |  32 +-
 clippy_lints/src/panic_unimplemented.rs       |  56 ++-
 clippy_lints/src/unit_types/unit_cmp.rs       |  40 +-
 clippy_lints/src/utils/internal_lints.rs      |  11 +-
 clippy_utils/Cargo.toml                       |   1 +
 clippy_utils/src/ast_utils.rs                 |  32 --
 clippy_utils/src/higher.rs                    | 295 +-------------
 clippy_utils/src/lib.rs                       |  40 +-
 clippy_utils/src/macros.rs                    | 539 ++++++++++++++++++++++++++
 clippy_utils/src/paths.rs                     |   5 -
 tests/ui/assertions_on_constants.rs           |   1 -
 tests/ui/assertions_on_constants.stderr       |  42 +-
 tests/ui/eq_op_macros.stderr                  |  44 +--
 tests/ui/missing_panics_doc.stderr            |   6 -
 tests/ui/panic_in_result_fn.stderr            |   6 -
 tests/ui/panic_in_result_fn_assertions.stderr |   3 -
 tests/ui/panicking_macros.stderr              |  21 -
 tests/ui/unit_cmp.stderr                      |   8 -
 31 files changed, 868 insertions(+), 865 deletions(-)
 create mode 100644 clippy_utils/src/macros.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/assertions_on_constants.rs b/clippy_lints/src/assertions_on_constants.rs
index b7f414742f1..c82837746bd 100644
--- a/clippy_lints/src/assertions_on_constants.rs
+++ b/clippy_lints/src/assertions_on_constants.rs
@@ -1,12 +1,10 @@
 use clippy_utils::consts::{constant, Constant};
 use clippy_utils::diagnostics::span_lint_and_help;
-use clippy_utils::higher;
-use clippy_utils::source::snippet_opt;
-use clippy_utils::{is_direct_expn_of, is_expn_of, match_panic_call, peel_blocks};
-use if_chain::if_chain;
-use rustc_hir::{Expr, ExprKind, UnOp};
+use clippy_utils::macros::{find_assert_args, root_macro_call_first_node, PanicExpn};
+use rustc_hir::Expr;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::sym;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -36,107 +34,39 @@ declare_lint_pass!(AssertionsOnConstants => [ASSERTIONS_ON_CONSTANTS]);
 
 impl<'tcx> LateLintPass<'tcx> for AssertionsOnConstants {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
-        let lint_true = |is_debug: bool| {
-            span_lint_and_help(
-                cx,
-                ASSERTIONS_ON_CONSTANTS,
-                e.span,
-                if is_debug {
-                    "`debug_assert!(true)` will be optimized out by the compiler"
-                } else {
-                    "`assert!(true)` will be optimized out by the compiler"
-                },
-                None,
-                "remove it",
-            );
+        let Some(macro_call) = root_macro_call_first_node(cx, e) else { return };
+        let is_debug = match cx.tcx.get_diagnostic_name(macro_call.def_id) {
+            Some(sym::debug_assert_macro) => true,
+            Some(sym::assert_macro) => false,
+            _ => return,
         };
-        let lint_false_without_message = || {
+        let Some((condition, panic_expn)) = find_assert_args(cx, e, macro_call.expn) else { return };
+        let Some((Constant::Bool(val), _)) = constant(cx, cx.typeck_results(), condition) else { return };
+        if val {
             span_lint_and_help(
                 cx,
                 ASSERTIONS_ON_CONSTANTS,
-                e.span,
-                "`assert!(false)` should probably be replaced",
+                macro_call.span,
+                &format!(
+                    "`{}!(true)` will be optimized out by the compiler",
+                    cx.tcx.item_name(macro_call.def_id)
+                ),
                 None,
-                "use `panic!()` or `unreachable!()`",
+                "remove it",
             );
-        };
-        let lint_false_with_message = |panic_message: String| {
+        } else if !is_debug {
+            let (assert_arg, panic_arg) = match panic_expn {
+                PanicExpn::Empty => ("", ""),
+                _ => (", ..", ".."),
+            };
             span_lint_and_help(
                 cx,
                 ASSERTIONS_ON_CONSTANTS,
-                e.span,
-                &format!("`assert!(false, {})` should probably be replaced", panic_message),
+                macro_call.span,
+                &format!("`assert!(false{})` should probably be replaced", assert_arg),
                 None,
-                &format!("use `panic!({})` or `unreachable!({})`", panic_message, panic_message),
+                &format!("use `panic!({})` or `unreachable!({0})`", panic_arg),
             );
-        };
-
-        if let Some(debug_assert_span) = is_expn_of(e.span, "debug_assert") {
-            if debug_assert_span.from_expansion() {
-                return;
-            }
-            if_chain! {
-                if let ExprKind::Unary(_, lit) = e.kind;
-                if let Some((Constant::Bool(is_true), _)) = constant(cx, cx.typeck_results(), lit);
-                if is_true;
-                then {
-                    lint_true(true);
-                }
-            };
-        } else if let Some(assert_span) = is_direct_expn_of(e.span, "assert") {
-            if assert_span.from_expansion() {
-                return;
-            }
-            if let Some(assert_match) = match_assert_with_message(cx, e) {
-                match assert_match {
-                    // matched assert but not message
-                    AssertKind::WithoutMessage(false) => lint_false_without_message(),
-                    AssertKind::WithoutMessage(true) | AssertKind::WithMessage(_, true) => lint_true(false),
-                    AssertKind::WithMessage(panic_message, false) => lint_false_with_message(panic_message),
-                };
-            }
-        }
-    }
-}
-
-/// Result of calling `match_assert_with_message`.
-enum AssertKind {
-    WithMessage(String, bool),
-    WithoutMessage(bool),
-}
-
-/// Check if the expression matches
-///
-/// ```rust,ignore
-/// if !c {
-///   {
-///     ::std::rt::begin_panic(message, _)
-///   }
-/// }
-/// ```
-///
-/// where `message` is any expression and `c` is a constant bool.
-fn match_assert_with_message<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<AssertKind> {
-    if_chain! {
-        if let Some(higher::If { cond, then, .. }) = higher::If::hir(expr);
-        if let ExprKind::Unary(UnOp::Not, expr) = cond.kind;
-        // bind the first argument of the `assert!` macro
-        if let Some((Constant::Bool(is_true), _)) = constant(cx, cx.typeck_results(), expr);
-        let begin_panic_call = peel_blocks(then);
-        // function call
-        if let Some(arg) = match_panic_call(cx, begin_panic_call);
-        // bind the second argument of the `assert!` macro if it exists
-        if let panic_message = snippet_opt(cx, arg.span);
-        // second argument of begin_panic is irrelevant
-        // as is the second match arm
-        then {
-            // an empty message occurs when it was generated by the macro
-            // (and not passed by the user)
-            return panic_message
-                .filter(|msg| !msg.is_empty())
-                .map(|msg| AssertKind::WithMessage(msg, is_true))
-                .or(Some(AssertKind::WithoutMessage(is_true)));
         }
     }
-    None
 }
diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs
index 0629674307b..a58d12ddd6b 100644
--- a/clippy_lints/src/attrs.rs
+++ b/clippy_lints/src/attrs.rs
@@ -1,9 +1,10 @@
 //! checks for attributes
 
 use clippy_utils::diagnostics::{span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then};
+use clippy_utils::macros::{is_panic, macro_backtrace};
 use clippy_utils::msrvs;
 use clippy_utils::source::{first_line_of_span, is_present_in_source, snippet_opt, without_block_comments};
-use clippy_utils::{extract_msrv_attr, match_panic_def_id, meets_msrv};
+use clippy_utils::{extract_msrv_attr, meets_msrv};
 use if_chain::if_chain;
 use rustc_ast::{AttrKind, AttrStyle, Attribute, Lit, LitKind, MetaItemKind, NestedMetaItem};
 use rustc_errors::Applicability;
@@ -443,20 +444,15 @@ fn is_relevant_block(cx: &LateContext<'_>, typeck_results: &ty::TypeckResults<'_
 }
 
 fn is_relevant_expr(cx: &LateContext<'_>, typeck_results: &ty::TypeckResults<'_>, expr: &Expr<'_>) -> bool {
+    if macro_backtrace(expr.span).last().map_or(false, |macro_call| {
+        is_panic(cx, macro_call.def_id) || cx.tcx.item_name(macro_call.def_id) == sym::unreachable
+    }) {
+        return false;
+    }
     match &expr.kind {
         ExprKind::Block(block, _) => is_relevant_block(cx, typeck_results, block),
         ExprKind::Ret(Some(e)) => is_relevant_expr(cx, typeck_results, e),
         ExprKind::Ret(None) | ExprKind::Break(_, None) => false,
-        ExprKind::Call(path_expr, _) => {
-            if let ExprKind::Path(qpath) = &path_expr.kind {
-                typeck_results
-                    .qpath_res(qpath, path_expr.hir_id)
-                    .opt_def_id()
-                    .map_or(true, |fun_id| !match_panic_def_id(cx, fun_id))
-            } else {
-                true
-            }
-        },
         _ => true,
     }
 }
diff --git a/clippy_lints/src/bool_assert_comparison.rs b/clippy_lints/src/bool_assert_comparison.rs
index d0b8c52a36a..ea2cfb0bc08 100644
--- a/clippy_lints/src/bool_assert_comparison.rs
+++ b/clippy_lints/src/bool_assert_comparison.rs
@@ -1,4 +1,5 @@
-use clippy_utils::{diagnostics::span_lint_and_sugg, higher, is_direct_expn_of, ty::implements_trait};
+use clippy_utils::macros::{find_assert_eq_args, root_macro_call_first_node};
+use clippy_utils::{diagnostics::span_lint_and_sugg, ty::implements_trait};
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, Lit};
@@ -66,44 +67,40 @@ fn is_impl_not_trait_with_bool_out(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) ->
 
 impl<'tcx> LateLintPass<'tcx> for BoolAssertComparison {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        let macros = ["assert_eq", "debug_assert_eq"];
-        let inverted_macros = ["assert_ne", "debug_assert_ne"];
-
-        for mac in macros.iter().chain(inverted_macros.iter()) {
-            if let Some(span) = is_direct_expn_of(expr.span, mac) {
-                if let Some(args) = higher::extract_assert_macro_args(expr) {
-                    if let [a, b, ..] = args[..] {
-                        let nb_bool_args = usize::from(is_bool_lit(a)) + usize::from(is_bool_lit(b));
-
-                        if nb_bool_args != 1 {
-                            // If there are two boolean arguments, we definitely don't understand
-                            // what's going on, so better leave things as is...
-                            //
-                            // Or there is simply no boolean and then we can leave things as is!
-                            return;
-                        }
-
-                        if !is_impl_not_trait_with_bool_out(cx, a) || !is_impl_not_trait_with_bool_out(cx, b) {
-                            // At this point the expression which is not a boolean
-                            // literal does not implement Not trait with a bool output,
-                            // so we cannot suggest to rewrite our code
-                            return;
-                        }
+        let Some(macro_call) = root_macro_call_first_node(cx, expr) else { return };
+        let macro_name = cx.tcx.item_name(macro_call.def_id);
+        if !matches!(
+            macro_name.as_str(),
+            "assert_eq" | "debug_assert_eq" | "assert_ne" | "debug_assert_ne"
+        ) {
+            return;
+        }
+        let Some ((a, b, _)) = find_assert_eq_args(cx, expr, macro_call.expn) else { return };
+        if !(is_bool_lit(a) ^ is_bool_lit(b)) {
+            // If there are two boolean arguments, we definitely don't understand
+            // what's going on, so better leave things as is...
+            //
+            // Or there is simply no boolean and then we can leave things as is!
+            return;
+        }
 
-                        let non_eq_mac = &mac[..mac.len() - 3];
-                        span_lint_and_sugg(
-                            cx,
-                            BOOL_ASSERT_COMPARISON,
-                            span,
-                            &format!("used `{}!` with a literal bool", mac),
-                            "replace it with",
-                            format!("{}!(..)", non_eq_mac),
-                            Applicability::MaybeIncorrect,
-                        );
-                        return;
-                    }
-                }
-            }
+        if !is_impl_not_trait_with_bool_out(cx, a) || !is_impl_not_trait_with_bool_out(cx, b) {
+            // At this point the expression which is not a boolean
+            // literal does not implement Not trait with a bool output,
+            // so we cannot suggest to rewrite our code
+            return;
         }
+
+        let macro_name = macro_name.as_str();
+        let non_eq_mac = &macro_name[..macro_name.len() - 3];
+        span_lint_and_sugg(
+            cx,
+            BOOL_ASSERT_COMPARISON,
+            macro_call.span,
+            &format!("used `{}!` with a literal bool", macro_name),
+            "replace it with",
+            format!("{}!(..)", non_eq_mac),
+            Applicability::MaybeIncorrect,
+        );
     }
 }
diff --git a/clippy_lints/src/doc.rs b/clippy_lints/src/doc.rs
index 3650e4f91a0..9d4195e400d 100644
--- a/clippy_lints/src/doc.rs
+++ b/clippy_lints/src/doc.rs
@@ -1,8 +1,9 @@
 use clippy_utils::attrs::is_doc_hidden;
 use clippy_utils::diagnostics::{span_lint, span_lint_and_help, span_lint_and_note, span_lint_and_then};
+use clippy_utils::macros::{is_panic, root_macro_call_first_node};
 use clippy_utils::source::{first_line_of_span, snippet_with_applicability};
 use clippy_utils::ty::{implements_trait, is_type_diagnostic_item};
-use clippy_utils::{is_entrypoint_fn, is_expn_of, match_panic_def_id, method_chain_args, return_ty};
+use clippy_utils::{is_entrypoint_fn, method_chain_args, return_ty};
 use if_chain::if_chain;
 use itertools::Itertools;
 use rustc_ast::ast::{Async, AttrKind, Attribute, Fn, FnRetTy, ItemKind};
@@ -13,7 +14,7 @@ use rustc_errors::emitter::EmitterWriter;
 use rustc_errors::{Applicability, Handler, SuggestionStyle};
 use rustc_hir as hir;
 use rustc_hir::intravisit::{self, NestedVisitorMap, Visitor};
-use rustc_hir::{AnonConst, Expr, ExprKind, QPath};
+use rustc_hir::{AnonConst, Expr};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::map::Map;
 use rustc_middle::lint::in_external_macro;
@@ -805,24 +806,17 @@ impl<'a, 'tcx> Visitor<'tcx> for FindPanicUnwrap<'a, 'tcx> {
             return;
         }
 
-        // check for `begin_panic`
-        if_chain! {
-            if let ExprKind::Call(func_expr, _) = expr.kind;
-            if let ExprKind::Path(QPath::Resolved(_, path)) = func_expr.kind;
-            if let Some(path_def_id) = path.res.opt_def_id();
-            if match_panic_def_id(self.cx, path_def_id);
-            if is_expn_of(expr.span, "unreachable").is_none();
-            if !is_expn_of_debug_assertions(expr.span);
-            then {
-                self.panic_span = Some(expr.span);
+        if let Some(macro_call) = root_macro_call_first_node(self.cx, expr) {
+            if is_panic(self.cx, macro_call.def_id)
+                || matches!(
+                    self.cx.tcx.item_name(macro_call.def_id).as_str(),
+                    "assert" | "assert_eq" | "assert_ne" | "todo"
+                )
+            {
+                self.panic_span = Some(macro_call.span);
             }
         }
 
-        // check for `assert_eq` or `assert_ne`
-        if is_expn_of(expr.span, "assert_eq").is_some() || is_expn_of(expr.span, "assert_ne").is_some() {
-            self.panic_span = Some(expr.span);
-        }
-
         // check for `unwrap`
         if let Some(arglists) = method_chain_args(expr, &["unwrap"]) {
             let receiver_ty = self.typeck_results.expr_ty(&arglists[0][0]).peel_refs();
@@ -844,8 +838,3 @@ impl<'a, 'tcx> Visitor<'tcx> for FindPanicUnwrap<'a, 'tcx> {
         NestedVisitorMap::OnlyBodies(self.cx.tcx.hir())
     }
 }
-
-fn is_expn_of_debug_assertions(span: Span) -> bool {
-    const MACRO_NAMES: &[&str] = &["debug_assert", "debug_assert_eq", "debug_assert_ne"];
-    MACRO_NAMES.iter().any(|name| is_expn_of(span, name).is_some())
-}
diff --git a/clippy_lints/src/eq_op.rs b/clippy_lints/src/eq_op.rs
index 10123460527..df75b815436 100644
--- a/clippy_lints/src/eq_op.rs
+++ b/clippy_lints/src/eq_op.rs
@@ -1,10 +1,11 @@
 use clippy_utils::diagnostics::{multispan_sugg, span_lint, span_lint_and_then};
+use clippy_utils::macros::{find_assert_eq_args, first_node_macro_backtrace};
 use clippy_utils::source::snippet;
 use clippy_utils::ty::{implements_trait, is_copy};
-use clippy_utils::{ast_utils::is_useless_with_eq_exprs, eq_expr_value, higher, is_expn_of, is_in_test_function};
+use clippy_utils::{ast_utils::is_useless_with_eq_exprs, eq_expr_value, is_in_test_function};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
-use rustc_hir::{BinOpKind, BorrowKind, Expr, ExprKind, StmtKind};
+use rustc_hir::{BinOpKind, BorrowKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
@@ -68,32 +69,26 @@ declare_clippy_lint! {
 
 declare_lint_pass!(EqOp => [EQ_OP, OP_REF]);
 
-const ASSERT_MACRO_NAMES: [&str; 4] = ["assert_eq", "assert_ne", "debug_assert_eq", "debug_assert_ne"];
-
 impl<'tcx> LateLintPass<'tcx> for EqOp {
     #[allow(clippy::similar_names, clippy::too_many_lines)]
     fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
-        if let ExprKind::Block(block, _) = e.kind {
-            for stmt in block.stmts {
-                for amn in &ASSERT_MACRO_NAMES {
-                    if_chain! {
-                        if is_expn_of(stmt.span, amn).is_some();
-                        if let StmtKind::Semi(matchexpr) = stmt.kind;
-                        if let Some(macro_args) = higher::extract_assert_macro_args(matchexpr);
-                        if macro_args.len() == 2;
-                        let (lhs, rhs) = (macro_args[0], macro_args[1]);
-                        if eq_expr_value(cx, lhs, rhs);
-                        if !is_in_test_function(cx.tcx, e.hir_id);
-                        then {
-                            span_lint(
-                                cx,
-                                EQ_OP,
-                                lhs.span.to(rhs.span),
-                                &format!("identical args used in this `{}!` macro call", amn),
-                            );
-                        }
-                    }
-                }
+        if_chain! {
+            if let Some((macro_call, macro_name)) = first_node_macro_backtrace(cx, e).find_map(|macro_call| {
+                let name = cx.tcx.item_name(macro_call.def_id);
+                matches!(name.as_str(), "assert_eq" | "assert_ne" | "debug_assert_eq" | "debug_assert_ne")
+                    .then(|| (macro_call, name))
+            });
+            if let Some((lhs, rhs, _)) = find_assert_eq_args(cx, e, macro_call.expn);
+            if eq_expr_value(cx, lhs, rhs);
+            if macro_call.is_local();
+            if !is_in_test_function(cx.tcx, e.hir_id);
+            then {
+                span_lint(
+                    cx,
+                    EQ_OP,
+                    lhs.span.to(rhs.span),
+                    &format!("identical args used in this `{}!` macro call", macro_name),
+                );
             }
         }
         if let ExprKind::Binary(op, left, right) = e.kind {
diff --git a/clippy_lints/src/explicit_write.rs b/clippy_lints/src/explicit_write.rs
index 6b327b9ce17..98e5234e0aa 100644
--- a/clippy_lints/src/explicit_write.rs
+++ b/clippy_lints/src/explicit_write.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg};
-use clippy_utils::higher::FormatArgsExpn;
+use clippy_utils::macros::FormatArgsExpn;
 use clippy_utils::{is_expn_of, match_function_call, paths};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
@@ -48,7 +48,7 @@ impl<'tcx> LateLintPass<'tcx> for ExplicitWrite {
             } else {
                 None
             };
-            if let Some(format_args) = FormatArgsExpn::parse(write_arg);
+            if let Some(format_args) = FormatArgsExpn::parse(cx, write_arg);
             then {
                 let calling_macro =
                     // ordering is important here, since `writeln!` uses `write!` internally
@@ -80,7 +80,7 @@ impl<'tcx> LateLintPass<'tcx> for ExplicitWrite {
                     )
                 };
                 let msg = format!("use of `{}.unwrap()`", used);
-                if let [write_output] = *format_args.format_string_symbols {
+                if let [write_output] = *format_args.format_string_parts {
                     let mut write_output = write_output.to_string();
                     if write_output.ends_with('\n') {
                         write_output.pop();
diff --git a/clippy_lints/src/fallible_impl_from.rs b/clippy_lints/src/fallible_impl_from.rs
index 05d300058cf..02f1baf27fa 100644
--- a/clippy_lints/src/fallible_impl_from.rs
+++ b/clippy_lints/src/fallible_impl_from.rs
@@ -1,6 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::macros::{is_panic, root_macro_call_first_node};
+use clippy_utils::method_chain_args;
 use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{is_expn_of, match_panic_def_id, method_chain_args};
 use if_chain::if_chain;
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass};
@@ -68,7 +69,7 @@ impl<'tcx> LateLintPass<'tcx> for FallibleImplFrom {
 
 fn lint_impl_body<'tcx>(cx: &LateContext<'tcx>, impl_span: Span, impl_items: &[hir::ImplItemRef]) {
     use rustc_hir::intravisit::{self, NestedVisitorMap, Visitor};
-    use rustc_hir::{Expr, ExprKind, ImplItemKind, QPath};
+    use rustc_hir::{Expr, ImplItemKind};
 
     struct FindPanicUnwrap<'a, 'tcx> {
         lcx: &'a LateContext<'tcx>,
@@ -80,14 +81,8 @@ fn lint_impl_body<'tcx>(cx: &LateContext<'tcx>, impl_span: Span, impl_items: &[h
         type Map = Map<'tcx>;
 
         fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
-            // check for `begin_panic`
-            if_chain! {
-                if let ExprKind::Call(func_expr, _) = expr.kind;
-                if let ExprKind::Path(QPath::Resolved(_, path)) = func_expr.kind;
-                if let Some(path_def_id) = path.res.opt_def_id();
-                if match_panic_def_id(self.lcx, path_def_id);
-                if is_expn_of(expr.span, "unreachable").is_none();
-                then {
+            if let Some(macro_call) = root_macro_call_first_node(self.lcx, expr) {
+                if is_panic(self.lcx, macro_call.def_id) {
                     self.result.push(expr.span);
                 }
             }
diff --git a/clippy_lints/src/format.rs b/clippy_lints/src/format.rs
index 3f043e5f2f1..688d8f8630f 100644
--- a/clippy_lints/src/format.rs
+++ b/clippy_lints/src/format.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::higher::FormatExpn;
+use clippy_utils::macros::{root_macro_call_first_node, FormatArgsExpn};
 use clippy_utils::source::{snippet_opt, snippet_with_applicability};
 use clippy_utils::sugg::Sugg;
 use if_chain::if_chain;
@@ -43,38 +43,41 @@ declare_lint_pass!(UselessFormat => [USELESS_FORMAT]);
 
 impl<'tcx> LateLintPass<'tcx> for UselessFormat {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        let FormatExpn { call_site, format_args } = match FormatExpn::parse(expr) {
-            Some(e) if !e.call_site.from_expansion() => e,
-            _ => return,
+        let (format_args, call_site) = if_chain! {
+            if let Some(macro_call) = root_macro_call_first_node(cx, expr);
+            if cx.tcx.is_diagnostic_item(sym::format_macro, macro_call.def_id);
+            if let Some(format_args) = FormatArgsExpn::find_nested(cx, expr, macro_call.expn);
+            then {
+                (format_args, macro_call.span)
+            } else {
+                return
+            }
         };
 
         let mut applicability = Applicability::MachineApplicable;
         if format_args.value_args.is_empty() {
-            if format_args.format_string_parts.is_empty() {
-                span_useless_format_empty(cx, call_site, "String::new()".to_owned(), applicability);
-            } else {
-                if_chain! {
-                    if let [e] = &*format_args.format_string_parts;
-                    if let ExprKind::Lit(lit) = &e.kind;
-                    if let Some(s_src) = snippet_opt(cx, lit.span);
-                    then {
+            match *format_args.format_string_parts {
+                [] => span_useless_format_empty(cx, call_site, "String::new()".to_owned(), applicability),
+                [_] => {
+                    if let Some(s_src) = snippet_opt(cx, format_args.format_string_span) {
                         // Simulate macro expansion, converting {{ and }} to { and }.
                         let s_expand = s_src.replace("{{", "{").replace("}}", "}");
                         let sugg = format!("{}.to_string()", s_expand);
                         span_useless_format(cx, call_site, sugg, applicability);
                     }
-                }
+                },
+                [..] => {},
             }
         } else if let [value] = *format_args.value_args {
             if_chain! {
-                if format_args.format_string_symbols == [kw::Empty];
+                if format_args.format_string_parts == [kw::Empty];
                 if match cx.typeck_results().expr_ty(value).peel_refs().kind() {
                     ty::Adt(adt, _) => cx.tcx.is_diagnostic_item(sym::String, adt.did),
                     ty::Str => true,
                     _ => false,
                 };
                 if let Some(args) = format_args.args();
-                if args.iter().all(|arg| arg.is_display() && !arg.has_string_formatting());
+                if args.iter().all(|arg| arg.format_trait == sym::Display && !arg.has_string_formatting());
                 then {
                     let is_new_string = match value.kind {
                         ExprKind::Binary(..) => true,
diff --git a/clippy_lints/src/format_args.rs b/clippy_lints/src/format_args.rs
index f0e1a67dcdd..ae423d799d7 100644
--- a/clippy_lints/src/format_args.rs
+++ b/clippy_lints/src/format_args.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
-use clippy_utils::higher::{FormatArgsArg, FormatArgsExpn, FormatExpn};
+use clippy_utils::macros::{FormatArgsArg, FormatArgsExpn};
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::implements_trait;
 use clippy_utils::{is_diag_trait_item, match_def_path, paths};
@@ -83,7 +83,7 @@ const FORMAT_MACRO_DIAG_ITEMS: &[Symbol] = &[sym::format_macro, sym::std_panic_m
 impl<'tcx> LateLintPass<'tcx> for FormatArgs {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
         if_chain! {
-            if let Some(format_args) = FormatArgsExpn::parse(expr);
+            if let Some(format_args) = FormatArgsExpn::parse(cx, expr);
             let expr_expn_data = expr.span.ctxt().outer_expn_data();
             let outermost_expn_data = outermost_expn_data(expr_expn_data);
             if let Some(macro_def_id) = outermost_expn_data.macro_def_id;
@@ -97,7 +97,7 @@ impl<'tcx> LateLintPass<'tcx> for FormatArgs {
             if let Some(args) = format_args.args();
             then {
                 for (i, arg) in args.iter().enumerate() {
-                    if !arg.is_display() {
+                    if arg.format_trait != sym::Display {
                         continue;
                     }
                     if arg.has_string_formatting() {
@@ -106,8 +106,8 @@ impl<'tcx> LateLintPass<'tcx> for FormatArgs {
                     if is_aliased(&args, i) {
                         continue;
                     }
-                    check_format_in_format_args(cx, outermost_expn_data.call_site, name, arg);
-                    check_to_string_in_format_args(cx, name, arg);
+                    check_format_in_format_args(cx, outermost_expn_data.call_site, name, arg.value);
+                    check_to_string_in_format_args(cx, name, arg.value);
                 }
             }
         }
@@ -122,30 +122,31 @@ fn outermost_expn_data(expn_data: ExpnData) -> ExpnData {
     }
 }
 
-fn check_format_in_format_args(cx: &LateContext<'_>, call_site: Span, name: Symbol, arg: &FormatArgsArg<'_>) {
-    if_chain! {
-        if FormatExpn::parse(arg.value).is_some();
-        if !arg.value.span.ctxt().outer_expn_data().call_site.from_expansion();
-        then {
-            span_lint_and_then(
-                cx,
-                FORMAT_IN_FORMAT_ARGS,
-                call_site,
-                &format!("`format!` in `{}!` args", name),
-                |diag| {
-                    diag.help(&format!(
-                        "combine the `format!(..)` arguments with the outer `{}!(..)` call",
-                        name
-                    ));
-                    diag.help("or consider changing `format!` to `format_args!`");
-                },
-            );
-        }
+fn check_format_in_format_args(cx: &LateContext<'_>, call_site: Span, name: Symbol, arg: &Expr<'_>) {
+    let expn_data = arg.span.ctxt().outer_expn_data();
+    if expn_data.call_site.from_expansion() {
+        return;
+    }
+    let Some(mac_id) = expn_data.macro_def_id else { return };
+    if !cx.tcx.is_diagnostic_item(sym::format_macro, mac_id) {
+        return;
     }
+    span_lint_and_then(
+        cx,
+        FORMAT_IN_FORMAT_ARGS,
+        call_site,
+        &format!("`format!` in `{}!` args", name),
+        |diag| {
+            diag.help(&format!(
+                "combine the `format!(..)` arguments with the outer `{}!(..)` call",
+                name
+            ));
+            diag.help("or consider changing `format!` to `format_args!`");
+        },
+    );
 }
 
-fn check_to_string_in_format_args<'tcx>(cx: &LateContext<'tcx>, name: Symbol, arg: &FormatArgsArg<'tcx>) {
-    let value = arg.value;
+fn check_to_string_in_format_args(cx: &LateContext<'_>, name: Symbol, value: &Expr<'_>) {
     if_chain! {
         if !value.span.from_expansion();
         if let ExprKind::MethodCall(_, _, [receiver], _) = value.kind;
diff --git a/clippy_lints/src/manual_assert.rs b/clippy_lints/src/manual_assert.rs
index 5a2a965716c..e3a34b22e32 100644
--- a/clippy_lints/src/manual_assert.rs
+++ b/clippy_lints/src/manual_assert.rs
@@ -1,11 +1,12 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::higher::PanicExpn;
+use clippy_utils::macros::{root_macro_call, FormatArgsExpn};
 use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::{is_expn_of, sugg};
+use clippy_utils::{peel_blocks_with_stmt, sugg};
 use rustc_errors::Applicability;
-use rustc_hir::{Block, Expr, ExprKind, StmtKind, UnOp};
+use rustc_hir::{Expr, ExprKind, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::sym;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -35,64 +36,33 @@ declare_clippy_lint! {
 declare_lint_pass!(ManualAssert => [MANUAL_ASSERT]);
 
 impl LateLintPass<'_> for ManualAssert {
-    fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &Expr<'tcx>) {
         if_chain! {
-            if let Expr {
-                kind: ExprKind:: If(cond, Expr {
-                    kind: ExprKind::Block(
-                        Block {
-                            stmts: [stmt],
-                            ..
-                        },
-                        _),
-                    ..
-                }, None),
-                ..
-            } = &expr;
-            if is_expn_of(stmt.span, "panic").is_some();
+            if let ExprKind::If(cond, then, None) = expr.kind;
             if !matches!(cond.kind, ExprKind::Let(_));
-            if let StmtKind::Semi(semi) = stmt.kind;
+            if !expr.span.from_expansion();
+            let then = peel_blocks_with_stmt(then);
+            if let Some(macro_call) = root_macro_call(then.span);
+            if cx.tcx.item_name(macro_call.def_id) == sym::panic;
             if !cx.tcx.sess.source_map().is_multiline(cond.span);
-
+            if let Some(format_args) = FormatArgsExpn::find_nested(cx, then, macro_call.expn);
             then {
-                let call = if_chain! {
-                    if let ExprKind::Block(block, _) = semi.kind;
-                    if let Some(init) = block.expr;
-                    then {
-                        init
-                    } else {
-                        semi
-                    }
-                };
-                let span = if let Some(panic_expn) = PanicExpn::parse(call) {
-                    match *panic_expn.format_args.value_args {
-                        [] => panic_expn.format_args.format_string_span,
-                        [.., last] => panic_expn.format_args.format_string_span.to(last.span),
-                    }
-                } else if let ExprKind::Call(_, [format_args]) = call.kind {
-                    format_args.span
-                } else {
-                    return
-                };
                 let mut applicability = Applicability::MachineApplicable;
-                let sugg = snippet_with_applicability(cx, span, "..", &mut applicability);
-                let cond_sugg = if let ExprKind::DropTemps(e, ..) = cond.kind {
-                    if let Expr{kind: ExprKind::Unary(UnOp::Not, not_expr), ..} = e {
-                         sugg::Sugg::hir_with_applicability(cx, not_expr, "..", &mut applicability).maybe_par().to_string()
-                    } else {
-                       format!("!{}", sugg::Sugg::hir_with_applicability(cx, e, "..", &mut applicability).maybe_par())
-                    }
-                } else {
-                   format!("!{}", sugg::Sugg::hir_with_applicability(cx, cond, "..", &mut applicability).maybe_par())
+                let format_args_snip = snippet_with_applicability(cx, format_args.inputs_span(), "..", &mut applicability);
+                let cond = cond.peel_drop_temps();
+                let (cond, not) = match cond.kind {
+                    ExprKind::Unary(UnOp::Not, e) => (e, ""),
+                    _ => (cond, "!"),
                 };
-
+                let cond_sugg = sugg::Sugg::hir_with_applicability(cx, cond, "..", &mut applicability).maybe_par();
+                let sugg = format!("assert!({not}{cond_sugg}, {format_args_snip});");
                 span_lint_and_sugg(
                     cx,
                     MANUAL_ASSERT,
                     expr.span,
                     "only a `panic!` in `if`-then statement",
                     "try",
-                    format!("assert!({}, {});", cond_sugg, sugg),
+                    sugg,
                     Applicability::MachineApplicable,
                 );
             }
diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index 22970507f96..0d693499bc6 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -2,16 +2,17 @@ use clippy_utils::consts::{constant, constant_full_int, miri_to_const, FullInt};
 use clippy_utils::diagnostics::{
     multispan_sugg, span_lint_and_help, span_lint_and_note, span_lint_and_sugg, span_lint_and_then,
 };
-use clippy_utils::higher;
+use clippy_utils::macros::{is_panic, root_macro_call};
 use clippy_utils::source::{expr_block, indent_of, snippet, snippet_block, snippet_opt, snippet_with_applicability};
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::{implements_trait, is_type_diagnostic_item, match_type, peel_mid_ty_refs};
 use clippy_utils::visitors::is_local_used;
 use clippy_utils::{
-    get_parent_expr, is_expn_of, is_lang_ctor, is_lint_allowed, is_refutable, is_unit_expr, is_wild, meets_msrv, msrvs,
+    get_parent_expr, is_lang_ctor, is_lint_allowed, is_refutable, is_unit_expr, is_wild, meets_msrv, msrvs,
     path_to_local, path_to_local_id, peel_blocks, peel_hir_pat_refs, peel_n_hir_expr_refs, recurse_or_patterns,
     strip_pat_refs,
 };
+use clippy_utils::{higher, peel_blocks_with_stmt};
 use clippy_utils::{paths, search_same, SpanlessEq, SpanlessHash};
 use core::iter::{once, ExactSizeIterator};
 use if_chain::if_chain;
@@ -974,7 +975,8 @@ fn check_wild_err_arm<'tcx>(cx: &LateContext<'tcx>, ex: &Expr<'tcx>, arms: &[Arm
                     }
                     if_chain! {
                         if matching_wild;
-                        if is_panic_call(arm.body);
+                        if let Some(macro_call) = root_macro_call(peel_blocks_with_stmt(arm.body).span);
+                        if is_panic(cx, macro_call.def_id);
                         then {
                             // `Err(_)` or `Err(_e)` arm with `panic!` found
                             span_lint_and_note(cx,
@@ -1179,22 +1181,6 @@ fn check_wild_enum_match(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>])
     };
 }
 
-// If the block contains only a `panic!` macro (as expression or statement)
-fn is_panic_call(expr: &Expr<'_>) -> bool {
-    // Unwrap any wrapping blocks
-    let span = if let ExprKind::Block(block, _) = expr.kind {
-        match (&block.expr, block.stmts.len(), block.stmts.first()) {
-            (&Some(exp), 0, _) => exp.span,
-            (&None, 1, Some(stmt)) => stmt.span,
-            _ => return false,
-        }
-    } else {
-        expr.span
-    };
-
-    is_expn_of(span, "panic").is_some() && is_expn_of(span, "unreachable").is_none()
-}
-
 fn check_match_ref_pats<'a, 'b, I>(cx: &LateContext<'_>, ex: &Expr<'_>, pats: I, expr: &Expr<'_>)
 where
     'b: 'a,
diff --git a/clippy_lints/src/methods/expect_fun_call.rs b/clippy_lints/src/methods/expect_fun_call.rs
index 0ec9387f9c4..866eaff5b1d 100644
--- a/clippy_lints/src/methods/expect_fun_call.rs
+++ b/clippy_lints/src/methods/expect_fun_call.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::higher::FormatExpn;
+use clippy_utils::macros::{root_macro_call_first_node, FormatArgsExpn};
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_errors::Applicability;
@@ -14,7 +14,13 @@ use super::EXPECT_FUN_CALL;
 
 /// Checks for the `EXPECT_FUN_CALL` lint.
 #[allow(clippy::too_many_lines)]
-pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, method_span: Span, name: &str, args: &[hir::Expr<'_>]) {
+pub(super) fn check(
+    cx: &LateContext<'tcx>,
+    expr: &hir::Expr<'_>,
+    method_span: Span,
+    name: &str,
+    args: &'tcx [hir::Expr<'tcx>],
+) {
     // Strip `&`, `as_ref()` and `as_str()` off `arg` until we're left with either a `String` or
     // `&str`
     fn get_arg_root<'a>(cx: &LateContext<'_>, arg: &'a hir::Expr<'a>) -> &'a hir::Expr<'a> {
@@ -128,11 +134,12 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, method_span: Spa
     let mut applicability = Applicability::MachineApplicable;
 
     //Special handling for `format!` as arg_root
-    if let Some(format_expn) = FormatExpn::parse(arg_root) {
-        let span = match *format_expn.format_args.value_args {
-            [] => format_expn.format_args.format_string_span,
-            [.., last] => format_expn.format_args.format_string_span.to(last.span),
-        };
+    if let Some(macro_call) = root_macro_call_first_node(cx, arg_root) {
+        if !cx.tcx.is_diagnostic_item(sym::format_macro, macro_call.def_id) {
+            return;
+        }
+        let Some(format_args) = FormatArgsExpn::find_nested(cx, arg_root, macro_call.expn) else { return };
+        let span = format_args.inputs_span();
         let sugg = snippet_with_applicability(cx, span, "..", &mut applicability);
         span_lint_and_sugg(
             cx,
diff --git a/clippy_lints/src/mutable_debug_assertion.rs b/clippy_lints/src/mutable_debug_assertion.rs
index fa7274990db..49d4b3a1850 100644
--- a/clippy_lints/src/mutable_debug_assertion.rs
+++ b/clippy_lints/src/mutable_debug_assertion.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint;
-use clippy_utils::{higher, is_direct_expn_of};
+use clippy_utils::macros::{find_assert_eq_args, root_macro_call_first_node};
 use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
 use rustc_hir::{BorrowKind, Expr, ExprKind, MatchSource, Mutability};
 use rustc_lint::{LateContext, LateLintPass};
@@ -34,26 +34,30 @@ declare_clippy_lint! {
 
 declare_lint_pass!(DebugAssertWithMutCall => [DEBUG_ASSERT_WITH_MUT_CALL]);
 
-const DEBUG_MACRO_NAMES: [&str; 3] = ["debug_assert", "debug_assert_eq", "debug_assert_ne"];
-
 impl<'tcx> LateLintPass<'tcx> for DebugAssertWithMutCall {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
-        for dmn in &DEBUG_MACRO_NAMES {
-            if is_direct_expn_of(e.span, dmn).is_some() {
-                if let Some(macro_args) = higher::extract_assert_macro_args(e) {
-                    for arg in macro_args {
-                        let mut visitor = MutArgVisitor::new(cx);
-                        visitor.visit_expr(arg);
-                        if let Some(span) = visitor.expr_span() {
-                            span_lint(
-                                cx,
-                                DEBUG_ASSERT_WITH_MUT_CALL,
-                                span,
-                                &format!("do not call a function with mutable arguments inside of `{}!`", dmn),
-                            );
-                        }
-                    }
-                }
+        let Some(macro_call) = root_macro_call_first_node(cx, e) else { return };
+        let macro_name = cx.tcx.item_name(macro_call.def_id);
+        if !matches!(
+            macro_name.as_str(),
+            "debug_assert" | "debug_assert_eq" | "debug_assert_ne"
+        ) {
+            return;
+        }
+        let Some((lhs, rhs, _)) = find_assert_eq_args(cx, e, macro_call.expn) else { return };
+        for arg in [lhs, rhs] {
+            let mut visitor = MutArgVisitor::new(cx);
+            visitor.visit_expr(arg);
+            if let Some(span) = visitor.expr_span() {
+                span_lint(
+                    cx,
+                    DEBUG_ASSERT_WITH_MUT_CALL,
+                    span,
+                    &format!(
+                        "do not call a function with mutable arguments inside of `{}!`",
+                        macro_name
+                    ),
+                );
             }
         }
     }
diff --git a/clippy_lints/src/panic_in_result_fn.rs b/clippy_lints/src/panic_in_result_fn.rs
index 8769c045214..b7a56970b33 100644
--- a/clippy_lints/src/panic_in_result_fn.rs
+++ b/clippy_lints/src/panic_in_result_fn.rs
@@ -1,8 +1,10 @@
 use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::macros::root_macro_call_first_node;
+use clippy_utils::return_ty;
 use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{find_macro_calls, is_expn_of, return_ty};
+use clippy_utils::visitors::expr_visitor_no_bodies;
 use rustc_hir as hir;
-use rustc_hir::intravisit::FnKind;
+use rustc_hir::intravisit::{FnKind, Visitor};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::{sym, Span};
@@ -55,19 +57,19 @@ impl<'tcx> LateLintPass<'tcx> for PanicInResultFn {
 }
 
 fn lint_impl_body<'tcx>(cx: &LateContext<'tcx>, impl_span: Span, body: &'tcx hir::Body<'tcx>) {
-    let mut panics = find_macro_calls(
-        &[
-            "unimplemented",
-            "unreachable",
-            "panic",
-            "todo",
-            "assert",
-            "assert_eq",
-            "assert_ne",
-        ],
-        body,
-    );
-    panics.retain(|span| is_expn_of(*span, "debug_assert").is_none());
+    let mut panics = Vec::new();
+    expr_visitor_no_bodies(|expr| {
+        let Some(macro_call) = root_macro_call_first_node(cx, expr) else { return true };
+        if matches!(
+            &*cx.tcx.item_name(macro_call.def_id).as_str(),
+            "unimplemented" | "unreachable" | "panic" | "todo" | "assert" | "assert_eq" | "assert_ne"
+        ) {
+            panics.push(macro_call.span);
+            return false;
+        }
+        true
+    })
+    .visit_expr(&body.value);
     if !panics.is_empty() {
         span_lint_and_then(
             cx,
diff --git a/clippy_lints/src/panic_unimplemented.rs b/clippy_lints/src/panic_unimplemented.rs
index edfac824ded..6ef6b9a20aa 100644
--- a/clippy_lints/src/panic_unimplemented.rs
+++ b/clippy_lints/src/panic_unimplemented.rs
@@ -1,10 +1,8 @@
 use clippy_utils::diagnostics::span_lint;
-use clippy_utils::{is_expn_of, match_panic_call};
-use if_chain::if_chain;
+use clippy_utils::macros::{is_panic, root_macro_call_first_node};
 use rustc_hir::Expr;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::Span;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -78,37 +76,37 @@ declare_lint_pass!(PanicUnimplemented => [UNIMPLEMENTED, UNREACHABLE, TODO, PANI
 
 impl<'tcx> LateLintPass<'tcx> for PanicUnimplemented {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if match_panic_call(cx, expr).is_some()
-            && (is_expn_of(expr.span, "debug_assert").is_none() && is_expn_of(expr.span, "assert").is_none())
-        {
-            let span = get_outer_span(expr);
-            if is_expn_of(expr.span, "unimplemented").is_some() {
+        let Some(macro_call) = root_macro_call_first_node(cx, expr) else { return };
+        if is_panic(cx, macro_call.def_id) {
+            span_lint(
+                cx,
+                PANIC,
+                macro_call.span,
+                "`panic` should not be present in production code",
+            );
+            return;
+        }
+        match cx.tcx.item_name(macro_call.def_id).as_str() {
+            "todo" => {
+                span_lint(
+                    cx,
+                    TODO,
+                    macro_call.span,
+                    "`todo` should not be present in production code",
+                );
+            },
+            "unimplemented" => {
                 span_lint(
                     cx,
                     UNIMPLEMENTED,
-                    span,
+                    macro_call.span,
                     "`unimplemented` should not be present in production code",
                 );
-            } else if is_expn_of(expr.span, "todo").is_some() {
-                span_lint(cx, TODO, span, "`todo` should not be present in production code");
-            } else if is_expn_of(expr.span, "unreachable").is_some() {
-                span_lint(cx, UNREACHABLE, span, "usage of the `unreachable!` macro");
-            } else if is_expn_of(expr.span, "panic").is_some() {
-                span_lint(cx, PANIC, span, "`panic` should not be present in production code");
-            }
-        }
-    }
-}
-
-fn get_outer_span(expr: &Expr<'_>) -> Span {
-    if_chain! {
-        if expr.span.from_expansion();
-        let first = expr.span.ctxt().outer_expn_data().call_site;
-        if first.from_expansion();
-        then {
-            first.ctxt().outer_expn_data().call_site
-        } else {
-            expr.span
+            },
+            "unreachable" => {
+                span_lint(cx, UNREACHABLE, macro_call.span, "usage of the `unreachable!` macro");
+            },
+            _ => {},
         }
     }
 }
diff --git a/clippy_lints/src/unit_types/unit_cmp.rs b/clippy_lints/src/unit_types/unit_cmp.rs
index 6d9aff47421..1dd8895ebd0 100644
--- a/clippy_lints/src/unit_types/unit_cmp.rs
+++ b/clippy_lints/src/unit_types/unit_cmp.rs
@@ -1,35 +1,29 @@
 use clippy_utils::diagnostics::span_lint;
+use clippy_utils::macros::{find_assert_eq_args, root_macro_call_first_node};
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::LateContext;
-use rustc_span::hygiene::{ExpnKind, MacroKind};
 
 use super::UNIT_CMP;
 
 pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>) {
     if expr.span.from_expansion() {
-        if let Some(callee) = expr.span.source_callee() {
-            if let ExpnKind::Macro(MacroKind::Bang, symbol) = callee.kind {
-                if let ExprKind::Binary(ref cmp, left, _) = expr.kind {
-                    let op = cmp.node;
-                    if op.is_comparison() && cx.typeck_results().expr_ty(left).is_unit() {
-                        let result = match symbol.as_str() {
-                            "assert_eq" | "debug_assert_eq" => "succeed",
-                            "assert_ne" | "debug_assert_ne" => "fail",
-                            _ => return,
-                        };
-                        span_lint(
-                            cx,
-                            UNIT_CMP,
-                            expr.span,
-                            &format!(
-                                "`{}` of unit values detected. This will always {}",
-                                symbol.as_str(),
-                                result
-                            ),
-                        );
-                    }
-                }
+        if let Some(macro_call) = root_macro_call_first_node(cx, expr) {
+            let macro_name = cx.tcx.item_name(macro_call.def_id);
+            let result = match macro_name.as_str() {
+                "assert_eq" | "debug_assert_eq" => "succeed",
+                "assert_ne" | "debug_assert_ne" => "fail",
+                _ => return,
+            };
+            let Some ((left, _, _)) = find_assert_eq_args(cx, expr, macro_call.expn) else { return };
+            if !cx.typeck_results().expr_ty(left).is_unit() {
+                return;
             }
+            span_lint(
+                cx,
+                UNIT_CMP,
+                macro_call.span,
+                &format!("`{}` of unit values detected. This will always {}", macro_name, result),
+            );
         }
         return;
     }
diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs
index e98dcd3cf98..165004e5b41 100644
--- a/clippy_lints/src/utils/internal_lints.rs
+++ b/clippy_lints/src/utils/internal_lints.rs
@@ -1,5 +1,6 @@
 use clippy_utils::consts::{constant_simple, Constant};
 use clippy_utils::diagnostics::{span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then};
+use clippy_utils::macros::root_macro_call_first_node;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::match_type;
 use clippy_utils::{
@@ -410,9 +411,13 @@ impl<'tcx> LateLintPass<'tcx> for LintWithoutLintPass {
                 }
                 self.declared_lints.insert(item.ident.name, item.span);
             }
-        } else if is_expn_of(item.span, "impl_lint_pass").is_some()
-            || is_expn_of(item.span, "declare_lint_pass").is_some()
-        {
+        } else if let Some(macro_call) = root_macro_call_first_node(cx, item) {
+            if !matches!(
+                &*cx.tcx.item_name(macro_call.def_id).as_str(),
+                "impl_lint_pass" | "declare_lint_pass"
+            ) {
+                return;
+            }
             if let hir::ItemKind::Impl(hir::Impl {
                 of_trait: None,
                 items: impl_item_refs,
diff --git a/clippy_utils/Cargo.toml b/clippy_utils/Cargo.toml
index 0ba0b59ed13..af1e2eb4dd1 100644
--- a/clippy_utils/Cargo.toml
+++ b/clippy_utils/Cargo.toml
@@ -5,6 +5,7 @@ edition = "2021"
 publish = false
 
 [dependencies]
+arrayvec = { version = "0.7", default-features = false }
 if_chain = "1.0"
 rustc-semver = "1.1"
 
diff --git a/clippy_utils/src/ast_utils.rs b/clippy_utils/src/ast_utils.rs
index 8400bfbbd99..3d3180521ab 100644
--- a/clippy_utils/src/ast_utils.rs
+++ b/clippy_utils/src/ast_utils.rs
@@ -5,7 +5,6 @@
 #![allow(clippy::similar_names, clippy::wildcard_imports, clippy::enum_glob_use)]
 
 use crate::{both, over};
-use if_chain::if_chain;
 use rustc_ast::ptr::P;
 use rustc_ast::{self as ast, *};
 use rustc_span::symbol::Ident;
@@ -679,34 +678,3 @@ pub fn eq_mac_args(l: &MacArgs, r: &MacArgs) -> bool {
         _ => false,
     }
 }
-
-/// Extract args from an assert-like macro.
-///
-/// Currently working with:
-/// - `assert_eq!` and `assert_ne!`
-/// - `debug_assert_eq!` and `debug_assert_ne!`
-///
-/// For example:
-///
-/// `debug_assert_eq!(a, b)` will return Some([a, b])
-pub fn extract_assert_macro_args(mut expr: &Expr) -> Option<[&Expr; 2]> {
-    if_chain! {
-        if let ExprKind::If(_, ref block, _) = expr.kind;
-        if let StmtKind::Semi(ref e) = block.stmts.get(0)?.kind;
-        then {
-            expr = e;
-        }
-    }
-    if_chain! {
-        if let ExprKind::Block(ref block, _) = expr.kind;
-        if let StmtKind::Expr(ref expr) = block.stmts.get(0)?.kind;
-        if let ExprKind::Match(ref match_expr, _) = expr.kind;
-        if let ExprKind::Tup(ref tup) = match_expr.kind;
-        if let [a, b, ..] = tup.as_slice();
-        if let (&ExprKind::AddrOf(_, _, ref a), &ExprKind::AddrOf(_, _, ref b)) = (&a.kind, &b.kind);
-        then {
-            return Some([&*a, &*b]);
-        }
-    }
-    None
-}
diff --git a/clippy_utils/src/higher.rs b/clippy_utils/src/higher.rs
index c764c35d444..160a51740cd 100644
--- a/clippy_utils/src/higher.rs
+++ b/clippy_utils/src/higher.rs
@@ -3,15 +3,13 @@
 #![deny(clippy::missing_docs_in_private_items)]
 
 use crate::ty::is_type_diagnostic_item;
-use crate::{is_expn_of, last_path_segment, match_def_path, paths};
+use crate::{is_expn_of, match_def_path, paths};
 use if_chain::if_chain;
 use rustc_ast::ast::{self, LitKind};
 use rustc_hir as hir;
-use rustc_hir::{
-    Arm, Block, BorrowKind, Expr, ExprKind, HirId, LoopSource, MatchSource, Node, Pat, QPath, StmtKind, UnOp,
-};
+use rustc_hir::{Arm, Block, Expr, ExprKind, HirId, LoopSource, MatchSource, Node, Pat, QPath};
 use rustc_lint::LateContext;
-use rustc_span::{sym, symbol, ExpnKind, Span, Symbol};
+use rustc_span::{sym, symbol, Span};
 
 /// The essential nodes of a desugared for loop as well as the entire span:
 /// `for pat in arg { body }` becomes `(pat, arg, body)`. Return `(pat, arg, body, span)`.
@@ -428,293 +426,6 @@ pub fn binop(op: hir::BinOpKind) -> ast::BinOpKind {
     }
 }
 
-/// Extract args from an assert-like macro.
-/// Currently working with:
-/// - `assert!`, `assert_eq!` and `assert_ne!`
-/// - `debug_assert!`, `debug_assert_eq!` and `debug_assert_ne!`
-/// For example:
-/// `assert!(expr)` will return `Some([expr])`
-/// `debug_assert_eq!(a, b)` will return `Some([a, b])`
-pub fn extract_assert_macro_args<'tcx>(e: &'tcx Expr<'tcx>) -> Option<Vec<&'tcx Expr<'tcx>>> {
-    /// Try to match the AST for a pattern that contains a match, for example when two args are
-    /// compared
-    fn ast_matchblock(matchblock_expr: &'tcx Expr<'tcx>) -> Option<Vec<&Expr<'_>>> {
-        if_chain! {
-            if let ExprKind::Match(headerexpr, _, _) = &matchblock_expr.kind;
-            if let ExprKind::Tup([lhs, rhs]) = &headerexpr.kind;
-            if let ExprKind::AddrOf(BorrowKind::Ref, _, lhs) = lhs.kind;
-            if let ExprKind::AddrOf(BorrowKind::Ref, _, rhs) = rhs.kind;
-            then {
-                return Some(vec![lhs, rhs]);
-            }
-        }
-        None
-    }
-
-    if let ExprKind::Block(block, _) = e.kind {
-        if block.stmts.len() == 1 {
-            if let StmtKind::Semi(matchexpr) = block.stmts.get(0)?.kind {
-                // macros with unique arg: `{debug_}assert!` (e.g., `debug_assert!(some_condition)`)
-                if_chain! {
-                    if let Some(If { cond, .. }) = If::hir(matchexpr);
-                    if let ExprKind::Unary(UnOp::Not, condition) = cond.kind;
-                    then {
-                        return Some(vec![condition]);
-                    }
-                }
-
-                // debug macros with two args: `debug_assert_{ne, eq}` (e.g., `assert_ne!(a, b)`)
-                if_chain! {
-                    if let ExprKind::Block(matchblock,_) = matchexpr.kind;
-                    if let Some(matchblock_expr) = matchblock.expr;
-                    then {
-                        return ast_matchblock(matchblock_expr);
-                    }
-                }
-            }
-        } else if let Some(matchblock_expr) = block.expr {
-            // macros with two args: `assert_{ne, eq}` (e.g., `assert_ne!(a, b)`)
-            return ast_matchblock(matchblock_expr);
-        }
-    }
-    None
-}
-
-/// A parsed `format!` expansion
-pub struct FormatExpn<'tcx> {
-    /// Span of `format!(..)`
-    pub call_site: Span,
-    /// Inner `format_args!` expansion
-    pub format_args: FormatArgsExpn<'tcx>,
-}
-
-impl FormatExpn<'tcx> {
-    /// Parses an expanded `format!` invocation
-    pub fn parse(expr: &'tcx Expr<'tcx>) -> Option<Self> {
-        if_chain! {
-            if let ExprKind::Block(block, _) = expr.kind;
-            if let [stmt] = block.stmts;
-            if let StmtKind::Local(local) = stmt.kind;
-            if let Some(init) = local.init;
-            if let ExprKind::Call(_, [format_args]) = init.kind;
-            let expn_data = expr.span.ctxt().outer_expn_data();
-            if let ExpnKind::Macro(_, sym::format) = expn_data.kind;
-            if let Some(format_args) = FormatArgsExpn::parse(format_args);
-            then {
-                Some(FormatExpn {
-                    call_site: expn_data.call_site,
-                    format_args,
-                })
-            } else {
-                None
-            }
-        }
-    }
-}
-
-/// A parsed `format_args!` expansion
-pub struct FormatArgsExpn<'tcx> {
-    /// Span of the first argument, the format string
-    pub format_string_span: Span,
-    /// Values passed after the format string
-    pub value_args: Vec<&'tcx Expr<'tcx>>,
-
-    /// String literal expressions which represent the format string split by "{}"
-    pub format_string_parts: &'tcx [Expr<'tcx>],
-    /// Symbols corresponding to [`Self::format_string_parts`]
-    pub format_string_symbols: Vec<Symbol>,
-    /// Expressions like `ArgumentV1::new(arg0, Debug::fmt)`
-    pub args: &'tcx [Expr<'tcx>],
-    /// The final argument passed to `Arguments::new_v1_formatted`, if applicable
-    pub fmt_expr: Option<&'tcx Expr<'tcx>>,
-}
-
-impl FormatArgsExpn<'tcx> {
-    /// Parses an expanded `format_args!` or `format_args_nl!` invocation
-    pub fn parse(expr: &'tcx Expr<'tcx>) -> Option<Self> {
-        if_chain! {
-            if let ExpnKind::Macro(_, name) = expr.span.ctxt().outer_expn_data().kind;
-            let name = name.as_str();
-            if name.ends_with("format_args") || name.ends_with("format_args_nl");
-            if let ExprKind::Call(_, args) = expr.kind;
-            if let Some((strs_ref, args, fmt_expr)) = match args {
-                // Arguments::new_v1
-                [strs_ref, args] => Some((strs_ref, args, None)),
-                // Arguments::new_v1_formatted
-                [strs_ref, args, fmt_expr, _unsafe_arg] => Some((strs_ref, args, Some(fmt_expr))),
-                _ => None,
-            };
-            if let ExprKind::AddrOf(BorrowKind::Ref, _, strs_arr) = strs_ref.kind;
-            if let ExprKind::Array(format_string_parts) = strs_arr.kind;
-            if let Some(format_string_symbols) = format_string_parts
-                .iter()
-                .map(|e| {
-                    if let ExprKind::Lit(lit) = &e.kind {
-                        if let LitKind::Str(symbol, _style) = lit.node {
-                            return Some(symbol);
-                        }
-                    }
-                    None
-                })
-                .collect();
-            if let ExprKind::AddrOf(BorrowKind::Ref, _, args) = args.kind;
-            if let ExprKind::Match(args, [arm], _) = args.kind;
-            if let ExprKind::Tup(value_args) = args.kind;
-            if let Some(value_args) = value_args
-                .iter()
-                .map(|e| match e.kind {
-                    ExprKind::AddrOf(_, _, e) => Some(e),
-                    _ => None,
-                })
-                .collect();
-            if let ExprKind::Array(args) = arm.body.kind;
-            then {
-                Some(FormatArgsExpn {
-                    format_string_span: strs_ref.span,
-                    value_args,
-                    format_string_parts,
-                    format_string_symbols,
-                    args,
-                    fmt_expr,
-                })
-            } else {
-                None
-            }
-        }
-    }
-
-    /// Returns a vector of `FormatArgsArg`.
-    pub fn args(&self) -> Option<Vec<FormatArgsArg<'tcx>>> {
-        if let Some(expr) = self.fmt_expr {
-            if_chain! {
-                if let ExprKind::AddrOf(BorrowKind::Ref, _, expr) = expr.kind;
-                if let ExprKind::Array(exprs) = expr.kind;
-                then {
-                    exprs.iter().map(|fmt| {
-                        if_chain! {
-                            // struct `core::fmt::rt::v1::Argument`
-                            if let ExprKind::Struct(_, fields, _) = fmt.kind;
-                            if let Some(position_field) = fields.iter().find(|f| f.ident.name == sym::position);
-                            if let ExprKind::Lit(lit) = &position_field.expr.kind;
-                            if let LitKind::Int(position, _) = lit.node;
-                            if let Ok(i) = usize::try_from(position);
-                            let arg = &self.args[i];
-                            if let ExprKind::Call(_, [arg_name, _]) = arg.kind;
-                            if let ExprKind::Field(_, j) = arg_name.kind;
-                            if let Ok(j) = j.name.as_str().parse::<usize>();
-                            then {
-                                Some(FormatArgsArg { value: self.value_args[j], arg, fmt: Some(fmt) })
-                            } else {
-                                None
-                            }
-                        }
-                    }).collect()
-                } else {
-                    None
-                }
-            }
-        } else {
-            Some(
-                self.value_args
-                    .iter()
-                    .zip(self.args.iter())
-                    .map(|(value, arg)| FormatArgsArg { value, arg, fmt: None })
-                    .collect(),
-            )
-        }
-    }
-}
-
-/// Type representing a `FormatArgsExpn`'s format arguments
-pub struct FormatArgsArg<'tcx> {
-    /// An element of `value_args` according to `position`
-    pub value: &'tcx Expr<'tcx>,
-    /// An element of `args` according to `position`
-    pub arg: &'tcx Expr<'tcx>,
-    /// An element of `fmt_expn`
-    pub fmt: Option<&'tcx Expr<'tcx>>,
-}
-
-impl<'tcx> FormatArgsArg<'tcx> {
-    /// Returns true if any formatting parameters are used that would have an effect on strings,
-    /// like `{:+2}` instead of just `{}`.
-    pub fn has_string_formatting(&self) -> bool {
-        self.fmt.map_or(false, |fmt| {
-            // `!` because these conditions check that `self` is unformatted.
-            !if_chain! {
-                // struct `core::fmt::rt::v1::Argument`
-                if let ExprKind::Struct(_, fields, _) = fmt.kind;
-                if let Some(format_field) = fields.iter().find(|f| f.ident.name == sym::format);
-                // struct `core::fmt::rt::v1::FormatSpec`
-                if let ExprKind::Struct(_, subfields, _) = format_field.expr.kind;
-                let mut precision_found = false;
-                let mut width_found = false;
-                if subfields.iter().all(|field| {
-                    match field.ident.name {
-                        sym::precision => {
-                            precision_found = true;
-                            if let ExprKind::Path(ref precision_path) = field.expr.kind {
-                                last_path_segment(precision_path).ident.name == sym::Implied
-                            } else {
-                                false
-                            }
-                        }
-                        sym::width => {
-                            width_found = true;
-                            if let ExprKind::Path(ref width_qpath) = field.expr.kind {
-                                last_path_segment(width_qpath).ident.name == sym::Implied
-                            } else {
-                                false
-                            }
-                        }
-                        _ => true,
-                    }
-                });
-                if precision_found && width_found;
-                then { true } else { false }
-            }
-        })
-    }
-
-    /// Returns true if the argument is formatted using `Display::fmt`.
-    pub fn is_display(&self) -> bool {
-        if_chain! {
-            if let ExprKind::Call(_, [_, format_field]) = self.arg.kind;
-            if let ExprKind::Path(QPath::Resolved(_, path)) = format_field.kind;
-            if let [.., t, _] = path.segments;
-            if t.ident.name == sym::Display;
-            then { true } else { false }
-        }
-    }
-}
-
-/// A parsed `panic!` expansion
-pub struct PanicExpn<'tcx> {
-    /// Span of `panic!(..)`
-    pub call_site: Span,
-    /// Inner `format_args!` expansion
-    pub format_args: FormatArgsExpn<'tcx>,
-}
-
-impl PanicExpn<'tcx> {
-    /// Parses an expanded `panic!` invocation
-    pub fn parse(expr: &'tcx Expr<'tcx>) -> Option<Self> {
-        if_chain! {
-            if let ExprKind::Call(_, [format_args]) = expr.kind;
-            let expn_data = expr.span.ctxt().outer_expn_data();
-            if let Some(format_args) = FormatArgsExpn::parse(format_args);
-            then {
-                Some(PanicExpn {
-                    call_site: expn_data.call_site,
-                    format_args,
-                })
-            } else {
-                None
-            }
-        }
-    }
-}
-
 /// A parsed `Vec` initialization expression
 #[derive(Clone, Copy)]
 pub enum VecInitKind {
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 54d470ca738..bbb70e3adb5 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -44,6 +44,7 @@ pub mod diagnostics;
 pub mod eager_or_lazy;
 pub mod higher;
 mod hir_utils;
+pub mod macros;
 pub mod msrvs;
 pub mod numeric_literal;
 pub mod paths;
@@ -1138,19 +1139,6 @@ pub fn contains_return(expr: &hir::Expr<'_>) -> bool {
     found
 }
 
-/// Finds calls of the specified macros in a function body.
-pub fn find_macro_calls(names: &[&str], body: &Body<'_>) -> Vec<Span> {
-    let mut result = Vec::new();
-    expr_visitor_no_bodies(|expr| {
-        if names.iter().any(|fun| is_expn_of(expr.span, fun).is_some()) {
-            result.push(expr.span);
-        }
-        true
-    })
-    .visit_expr(&body.value);
-    result
-}
-
 /// Extends the span to the beginning of the spans line, incl. whitespaces.
 ///
 /// ```rust
@@ -1679,32 +1667,6 @@ pub fn match_libc_symbol(cx: &LateContext<'_>, did: DefId, name: &str) -> bool {
     path.first().map_or(false, |s| s.as_str() == "libc") && path.last().map_or(false, |s| s.as_str() == name)
 }
 
-pub fn match_panic_call(cx: &LateContext<'_>, expr: &'tcx Expr<'_>) -> Option<&'tcx Expr<'tcx>> {
-    if let ExprKind::Call(func, [arg]) = expr.kind {
-        expr_path_res(cx, func)
-            .opt_def_id()
-            .map_or(false, |id| match_panic_def_id(cx, id))
-            .then(|| arg)
-    } else {
-        None
-    }
-}
-
-pub fn match_panic_def_id(cx: &LateContext<'_>, did: DefId) -> bool {
-    match_any_def_paths(
-        cx,
-        did,
-        &[
-            &paths::BEGIN_PANIC,
-            &paths::PANIC_ANY,
-            &paths::PANICKING_PANIC,
-            &paths::PANICKING_PANIC_FMT,
-            &paths::PANICKING_PANIC_STR,
-        ],
-    )
-    .is_some()
-}
-
 /// Returns the list of condition expressions and the list of blocks in a
 /// sequence of `if/else`.
 /// E.g., this returns `([a, b], [c, d, e])` for the expression
diff --git a/clippy_utils/src/macros.rs b/clippy_utils/src/macros.rs
new file mode 100644
index 00000000000..2bf43aeb995
--- /dev/null
+++ b/clippy_utils/src/macros.rs
@@ -0,0 +1,539 @@
+#![allow(clippy::similar_names)] // `expr` and `expn`
+
+use crate::visitors::expr_visitor_no_bodies;
+
+use arrayvec::ArrayVec;
+use if_chain::if_chain;
+use rustc_ast::ast::LitKind;
+use rustc_hir::intravisit::Visitor;
+use rustc_hir::{self as hir, Expr, ExprKind, HirId, Node, QPath};
+use rustc_lint::LateContext;
+use rustc_span::def_id::DefId;
+use rustc_span::hygiene::{MacroKind, SyntaxContext};
+use rustc_span::{sym, ExpnData, ExpnId, ExpnKind, Span, Symbol};
+use std::ops::ControlFlow;
+
+/// A macro call, like `vec![1, 2, 3]`.
+///
+/// Use `tcx.item_name(macro_call.def_id)` to get the macro name.
+/// Even better is to check if it is a diagnostic item.
+///
+/// This structure is similar to `ExpnData` but it precludes desugaring expansions.
+#[derive(Debug)]
+pub struct MacroCall {
+    /// Macro `DefId`
+    pub def_id: DefId,
+    /// Kind of macro
+    pub kind: MacroKind,
+    /// The expansion produced by the macro call
+    pub expn: ExpnId,
+    /// Span of the macro call site
+    pub span: Span,
+}
+
+impl MacroCall {
+    pub fn is_local(&self) -> bool {
+        span_is_local(self.span)
+    }
+}
+
+/// Returns an iterator of expansions that created the given span
+pub fn expn_backtrace(mut span: Span) -> impl Iterator<Item = (ExpnId, ExpnData)> {
+    std::iter::from_fn(move || {
+        let ctxt = span.ctxt();
+        if ctxt == SyntaxContext::root() {
+            return None;
+        }
+        let expn = ctxt.outer_expn();
+        let data = expn.expn_data();
+        span = data.call_site;
+        Some((expn, data))
+    })
+}
+
+/// Checks whether the span is from the root expansion or a locally defined macro
+pub fn span_is_local(span: Span) -> bool {
+    !span.from_expansion() || expn_is_local(span.ctxt().outer_expn())
+}
+
+/// Checks whether the expansion is the root expansion or a locally defined macro
+pub fn expn_is_local(expn: ExpnId) -> bool {
+    if expn == ExpnId::root() {
+        return true;
+    }
+    let data = expn.expn_data();
+    let backtrace = expn_backtrace(data.call_site);
+    std::iter::once((expn, data))
+        .chain(backtrace)
+        .find_map(|(_, data)| data.macro_def_id)
+        .map_or(true, DefId::is_local)
+}
+
+/// Returns an iterator of macro expansions that created the given span.
+/// Note that desugaring expansions are skipped.
+pub fn macro_backtrace(span: Span) -> impl Iterator<Item = MacroCall> {
+    expn_backtrace(span).filter_map(|(expn, data)| match data {
+        ExpnData {
+            kind: ExpnKind::Macro(kind, _),
+            macro_def_id: Some(def_id),
+            call_site: span,
+            ..
+        } => Some(MacroCall {
+            def_id,
+            kind,
+            expn,
+            span,
+        }),
+        _ => None,
+    })
+}
+
+/// If the macro backtrace of `span` has a macro call at the root expansion
+/// (i.e. not a nested macro call), returns `Some` with the `MacroCall`
+pub fn root_macro_call(span: Span) -> Option<MacroCall> {
+    macro_backtrace(span).last()
+}
+
+/// Like [`root_macro_call`], but only returns `Some` if `node` is the "first node"
+/// produced by the macro call, as in [`first_node_in_macro`].
+pub fn root_macro_call_first_node(cx: &LateContext<'_>, node: &impl HirNode) -> Option<MacroCall> {
+    if first_node_in_macro(cx, node) != Some(ExpnId::root()) {
+        return None;
+    }
+    root_macro_call(node.span())
+}
+
+/// Like [`macro_backtrace`], but only returns macro calls where `node` is the "first node" of the
+/// macro call, as in [`first_node_in_macro`].
+pub fn first_node_macro_backtrace(cx: &LateContext<'_>, node: &impl HirNode) -> impl Iterator<Item = MacroCall> {
+    let span = node.span();
+    first_node_in_macro(cx, node)
+        .into_iter()
+        .flat_map(move |expn| macro_backtrace(span).take_while(move |macro_call| macro_call.expn != expn))
+}
+
+/// If `node` is the "first node" in a macro expansion, returns `Some` with the `ExpnId` of the
+/// macro call site (i.e. the parent of the macro expansion). This generally means that `node`
+/// is the outermost node of an entire macro expansion, but there are some caveats noted below.
+/// This is useful for finding macro calls while visiting the HIR without processing the macro call
+/// at every node within its expansion.
+///
+/// If you already have immediate access to the parent node, it is simpler to
+/// just check the context of that span directly (e.g. `parent.span.from_expansion()`).
+///
+/// If a macro call is in statement position, it expands to one or more statements.
+/// In that case, each statement *and* their immediate descendants will all yield `Some`
+/// with the `ExpnId` of the containing block.
+///
+/// A node may be the "first node" of multiple macro calls in a macro backtrace.
+/// The expansion of the outermost macro call site is returned in such cases.
+pub fn first_node_in_macro(cx: &LateContext<'_>, node: &impl HirNode) -> Option<ExpnId> {
+    // get the macro expansion or return `None` if not found
+    // `macro_backtrace` importantly ignores desugaring expansions
+    let expn = macro_backtrace(node.span()).next()?.expn;
+
+    // get the parent node, possibly skipping over a statement
+    // if the parent is not found, it is sensible to return `Some(root)`
+    let hir = cx.tcx.hir();
+    let mut parent_iter = hir.parent_iter(node.hir_id());
+    let (parent_id, _) = match parent_iter.next() {
+        None => return Some(ExpnId::root()),
+        Some((_, Node::Stmt(_))) => match parent_iter.next() {
+            None => return Some(ExpnId::root()),
+            Some(next) => next,
+        },
+        Some(next) => next,
+    };
+
+    // get the macro expansion of the parent node
+    let parent_span = hir.span(parent_id);
+    let Some(parent_macro_call) = macro_backtrace(parent_span).next() else {
+        // the parent node is not in a macro
+        return Some(ExpnId::root());
+    };
+
+    if parent_macro_call.expn.is_descendant_of(expn) {
+        // `node` is input to a macro call
+        return None;
+    }
+
+    Some(parent_macro_call.expn)
+}
+
+/* Specific Macro Utils */
+
+/// Is `def_id` of `std::panic`, `core::panic` or any inner implementation macros
+pub fn is_panic(cx: &LateContext<'_>, def_id: DefId) -> bool {
+    let Some(name) = cx.tcx.get_diagnostic_name(def_id) else { return false };
+    matches!(
+        name.as_str(),
+        "core_panic_macro"
+            | "std_panic_macro"
+            | "core_panic_2015_macro"
+            | "std_panic_2015_macro"
+            | "core_panic_2021_macro"
+    )
+}
+
+pub enum PanicExpn<'a> {
+    /// No arguments - `panic!()`
+    Empty,
+    /// A string literal or any `&str` - `panic!("message")` or `panic!(message)`
+    Str(&'a Expr<'a>),
+    /// A single argument that implements `Display` - `panic!("{}", object)`
+    Display(&'a Expr<'a>),
+    /// Anything else - `panic!("error {}: {}", a, b)`
+    Format(FormatArgsExpn<'a>),
+}
+
+impl<'a> PanicExpn<'a> {
+    pub fn parse(cx: &LateContext<'_>, expr: &'a Expr<'a>) -> Option<Self> {
+        if !macro_backtrace(expr.span).any(|macro_call| is_panic(cx, macro_call.def_id)) {
+            return None;
+        }
+        let ExprKind::Call(callee, [arg]) = expr.kind else { return None };
+        let ExprKind::Path(QPath::Resolved(_, path)) = callee.kind else { return None };
+        let result = match path.segments.last().unwrap().ident.as_str() {
+            "panic" if arg.span.ctxt() == expr.span.ctxt() => Self::Empty,
+            "panic" | "panic_str" => Self::Str(arg),
+            "panic_display" => {
+                let ExprKind::AddrOf(_, _, e) = arg.kind else { return None };
+                Self::Display(e)
+            },
+            "panic_fmt" => Self::Format(FormatArgsExpn::parse(cx, arg)?),
+            _ => return None,
+        };
+        Some(result)
+    }
+}
+
+/// Finds the arguments of an `assert!` or `debug_assert!` macro call within the macro expansion
+pub fn find_assert_args<'a>(
+    cx: &LateContext<'_>,
+    expr: &'a Expr<'a>,
+    expn: ExpnId,
+) -> Option<(&'a Expr<'a>, PanicExpn<'a>)> {
+    find_assert_args_inner(cx, expr, expn).map(|([e], p)| (e, p))
+}
+
+/// Finds the arguments of an `assert_eq!` or `debug_assert_eq!` macro call within the macro
+/// expansion
+pub fn find_assert_eq_args<'a>(
+    cx: &LateContext<'_>,
+    expr: &'a Expr<'a>,
+    expn: ExpnId,
+) -> Option<(&'a Expr<'a>, &'a Expr<'a>, PanicExpn<'a>)> {
+    find_assert_args_inner(cx, expr, expn).map(|([a, b], p)| (a, b, p))
+}
+
+fn find_assert_args_inner<'a, const N: usize>(
+    cx: &LateContext<'_>,
+    expr: &'a Expr<'a>,
+    expn: ExpnId,
+) -> Option<([&'a Expr<'a>; N], PanicExpn<'a>)> {
+    let macro_id = expn.expn_data().macro_def_id?;
+    let (expr, expn) = match cx.tcx.item_name(macro_id).as_str().strip_prefix("debug_") {
+        None => (expr, expn),
+        Some(inner_name) => find_assert_within_debug_assert(cx, expr, expn, Symbol::intern(inner_name))?,
+    };
+    let mut args = ArrayVec::new();
+    let mut panic_expn = None;
+    expr_visitor_no_bodies(|e| {
+        if args.is_full() {
+            if panic_expn.is_none() && e.span.ctxt() != expr.span.ctxt() {
+                panic_expn = PanicExpn::parse(cx, e);
+            }
+            panic_expn.is_none()
+        } else if is_assert_arg(cx, e, expn) {
+            args.push(e);
+            false
+        } else {
+            true
+        }
+    })
+    .visit_expr(expr);
+    let args = args.into_inner().ok()?;
+    // if no `panic!(..)` is found, use `PanicExpn::Empty`
+    // to indicate that the default assertion message is used
+    let panic_expn = panic_expn.unwrap_or(PanicExpn::Empty);
+    Some((args, panic_expn))
+}
+
+fn find_assert_within_debug_assert<'a>(
+    cx: &LateContext<'_>,
+    expr: &'a Expr<'a>,
+    expn: ExpnId,
+    assert_name: Symbol,
+) -> Option<(&'a Expr<'a>, ExpnId)> {
+    let mut found = None;
+    expr_visitor_no_bodies(|e| {
+        if found.is_some() || !e.span.from_expansion() {
+            return false;
+        }
+        let e_expn = e.span.ctxt().outer_expn();
+        if e_expn == expn {
+            return true;
+        }
+        if e_expn.expn_data().macro_def_id.map(|id| cx.tcx.item_name(id)) == Some(assert_name) {
+            found = Some((e, e_expn));
+        }
+        false
+    })
+    .visit_expr(expr);
+    found
+}
+
+fn is_assert_arg(cx: &LateContext<'_>, expr: &'a Expr<'a>, assert_expn: ExpnId) -> bool {
+    if !expr.span.from_expansion() {
+        return true;
+    }
+    let result = macro_backtrace(expr.span).try_for_each(|macro_call| {
+        if macro_call.expn == assert_expn {
+            ControlFlow::Break(false)
+        } else {
+            match cx.tcx.item_name(macro_call.def_id) {
+                // `cfg!(debug_assertions)` in `debug_assert!`
+                sym::cfg => ControlFlow::CONTINUE,
+                // assert!(other_macro!(..))
+                _ => ControlFlow::Break(true),
+            }
+        }
+    });
+    match result {
+        ControlFlow::Break(is_assert_arg) => is_assert_arg,
+        ControlFlow::Continue(()) => true,
+    }
+}
+
+/// A parsed `format_args!` expansion
+pub struct FormatArgsExpn<'tcx> {
+    /// Span of the first argument, the format string
+    pub format_string_span: Span,
+    /// The format string split by formatted args like `{..}`
+    pub format_string_parts: Vec<Symbol>,
+    /// Values passed after the format string
+    pub value_args: Vec<&'tcx Expr<'tcx>>,
+    /// Each element is a `value_args` index and a formatting trait (e.g. `sym::Debug`)
+    pub formatters: Vec<(usize, Symbol)>,
+    /// List of `fmt::v1::Argument { .. }` expressions. If this is empty,
+    /// then `formatters` represents the format args (`{..}`).
+    /// If this is non-empty, it represents the format args, and the `position`
+    /// parameters within the struct expressions are indexes of `formatters`.
+    pub specs: Vec<&'tcx Expr<'tcx>>,
+}
+
+impl FormatArgsExpn<'tcx> {
+    /// Parses an expanded `format_args!` or `format_args_nl!` invocation
+    pub fn parse(cx: &LateContext<'_>, expr: &'tcx Expr<'tcx>) -> Option<Self> {
+        macro_backtrace(expr.span).find(|macro_call| {
+            matches!(
+                cx.tcx.item_name(macro_call.def_id),
+                sym::const_format_args | sym::format_args | sym::format_args_nl
+            )
+        })?;
+        let mut format_string_span: Option<Span> = None;
+        let mut format_string_parts: Vec<Symbol> = Vec::new();
+        let mut value_args: Vec<&Expr<'_>> = Vec::new();
+        let mut formatters: Vec<(usize, Symbol)> = Vec::new();
+        let mut specs: Vec<&Expr<'_>> = Vec::new();
+        expr_visitor_no_bodies(|e| {
+            // if we're still inside of the macro definition...
+            if e.span.ctxt() == expr.span.ctxt() {
+                // ArgumnetV1::new(<value>, <format_trait>::fmt)
+                if_chain! {
+                    if let ExprKind::Call(callee, [val, fmt_path]) = e.kind;
+                    if let ExprKind::Path(QPath::TypeRelative(ty, seg)) = callee.kind;
+                    if seg.ident.name == sym::new;
+                    if let hir::TyKind::Path(QPath::Resolved(_, path)) = ty.kind;
+                    if path.segments.last().unwrap().ident.name == sym::ArgumentV1;
+                    if let ExprKind::Path(QPath::Resolved(_, path)) = fmt_path.kind;
+                    if let [.., fmt_trait, _fmt] = path.segments;
+                    then {
+                        let val_idx = if_chain! {
+                            if val.span.ctxt() == expr.span.ctxt();
+                            if let ExprKind::Field(_, field) = val.kind;
+                            if let Ok(idx) = field.name.as_str().parse();
+                            then {
+                                // tuple index
+                                idx
+                            } else {
+                                // assume the value expression is passed directly
+                                formatters.len()
+                            }
+                        };
+                        formatters.push((val_idx, fmt_trait.ident.name));
+                    }
+                }
+                if let ExprKind::Struct(QPath::Resolved(_, path), ..) = e.kind {
+                    if path.segments.last().unwrap().ident.name == sym::Argument {
+                        specs.push(e);
+                    }
+                }
+                // walk through the macro expansion
+                return true;
+            }
+            // assume that the first expr with a differing context represents
+            // (and has the span of) the format string
+            if format_string_span.is_none() {
+                format_string_span = Some(e.span);
+                let span = e.span;
+                // walk the expr and collect string literals which are format string parts
+                expr_visitor_no_bodies(|e| {
+                    if e.span.ctxt() != span.ctxt() {
+                        // defensive check, probably doesn't happen
+                        return false;
+                    }
+                    if let ExprKind::Lit(lit) = &e.kind {
+                        if let LitKind::Str(symbol, _s) = lit.node {
+                            format_string_parts.push(symbol);
+                        }
+                    }
+                    true
+                })
+                .visit_expr(e);
+            } else {
+                // assume that any further exprs with a differing context are value args
+                value_args.push(e);
+            }
+            // don't walk anything not from the macro expansion (e.a. inputs)
+            false
+        })
+        .visit_expr(expr);
+        Some(FormatArgsExpn {
+            format_string_span: format_string_span?,
+            format_string_parts,
+            value_args,
+            formatters,
+            specs,
+        })
+    }
+
+    /// Finds a nested call to `format_args!` within a `format!`-like macro call
+    pub fn find_nested(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, expn_id: ExpnId) -> Option<Self> {
+        let mut format_args = None;
+        expr_visitor_no_bodies(|e| {
+            if format_args.is_some() {
+                return false;
+            }
+            let e_ctxt = e.span.ctxt();
+            if e_ctxt == expr.span.ctxt() {
+                return true;
+            }
+            if e_ctxt.outer_expn().is_descendant_of(expn_id) {
+                format_args = FormatArgsExpn::parse(cx, e);
+            }
+            false
+        })
+        .visit_expr(expr);
+        format_args
+    }
+
+    /// Returns a vector of `FormatArgsArg`.
+    pub fn args(&self) -> Option<Vec<FormatArgsArg<'tcx>>> {
+        if self.specs.is_empty() {
+            let args = std::iter::zip(&self.value_args, &self.formatters)
+                .map(|(value, &(_, format_trait))| FormatArgsArg {
+                    value,
+                    format_trait,
+                    spec: None,
+                })
+                .collect();
+            return Some(args);
+        }
+        self.specs
+            .iter()
+            .map(|spec| {
+                if_chain! {
+                    // struct `core::fmt::rt::v1::Argument`
+                    if let ExprKind::Struct(_, fields, _) = spec.kind;
+                    if let Some(position_field) = fields.iter().find(|f| f.ident.name == sym::position);
+                    if let ExprKind::Lit(lit) = &position_field.expr.kind;
+                    if let LitKind::Int(position, _) = lit.node;
+                    if let Ok(i) = usize::try_from(position);
+                    if let Some(&(j, format_trait)) = self.formatters.get(i);
+                    then {
+                        Some(FormatArgsArg { value: self.value_args[j], format_trait, spec: Some(spec) })
+                    } else {
+                        None
+                    }
+                }
+            })
+            .collect()
+    }
+
+    /// Span of all inputs
+    pub fn inputs_span(&self) -> Span {
+        match *self.value_args {
+            [] => self.format_string_span,
+            [.., last] => self.format_string_span.to(last.span),
+        }
+    }
+}
+
+/// Type representing a `FormatArgsExpn`'s format arguments
+pub struct FormatArgsArg<'tcx> {
+    /// An element of `value_args` according to `position`
+    pub value: &'tcx Expr<'tcx>,
+    /// An element of `args` according to `position`
+    pub format_trait: Symbol,
+    /// An element of `specs`
+    pub spec: Option<&'tcx Expr<'tcx>>,
+}
+
+impl<'tcx> FormatArgsArg<'tcx> {
+    /// Returns true if any formatting parameters are used that would have an effect on strings,
+    /// like `{:+2}` instead of just `{}`.
+    pub fn has_string_formatting(&self) -> bool {
+        self.spec.map_or(false, |spec| {
+            // `!` because these conditions check that `self` is unformatted.
+            !if_chain! {
+                // struct `core::fmt::rt::v1::Argument`
+                if let ExprKind::Struct(_, fields, _) = spec.kind;
+                if let Some(format_field) = fields.iter().find(|f| f.ident.name == sym::format);
+                // struct `core::fmt::rt::v1::FormatSpec`
+                if let ExprKind::Struct(_, subfields, _) = format_field.expr.kind;
+                if subfields.iter().all(|field| match field.ident.name {
+                    sym::precision | sym::width => match field.expr.kind {
+                        ExprKind::Path(QPath::Resolved(_, path)) => {
+                            path.segments.last().unwrap().ident.name == sym::Implied
+                        }
+                        _ => false,
+                    }
+                    _ => true,
+                });
+                then { true } else { false }
+            }
+        })
+    }
+}
+
+/// A node with a `HirId` and a `Span`
+pub trait HirNode {
+    fn hir_id(&self) -> HirId;
+    fn span(&self) -> Span;
+}
+
+macro_rules! impl_hir_node {
+    ($($t:ident),*) => {
+        $(impl HirNode for hir::$t<'_> {
+            fn hir_id(&self) -> HirId {
+                self.hir_id
+            }
+            fn span(&self) -> Span {
+                self.span
+            }
+        })*
+    };
+}
+
+impl_hir_node!(Expr, Pat);
+
+impl HirNode for hir::Item<'_> {
+    fn hir_id(&self) -> HirId {
+        self.hir_id()
+    }
+
+    fn span(&self) -> Span {
+        self.span
+    }
+}
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index aa3b3af2356..27db53a6e6d 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -25,7 +25,6 @@ pub const ASSERT_MACRO: [&str; 4] = ["core", "macros", "builtin", "assert"];
 pub const ASSERT_NE_MACRO: [&str; 3] = ["core", "macros", "assert_ne"];
 pub const ASMUT_TRAIT: [&str; 3] = ["core", "convert", "AsMut"];
 pub const ASREF_TRAIT: [&str; 3] = ["core", "convert", "AsRef"];
-pub(super) const BEGIN_PANIC: [&str; 3] = ["std", "panicking", "begin_panic"];
 /// Preferably use the diagnostic item `sym::Borrow` where possible
 pub const BORROW_TRAIT: [&str; 3] = ["core", "borrow", "Borrow"];
 pub const BORROW_MUT_TRAIT: [&str; 3] = ["core", "borrow", "BorrowMut"];
@@ -110,10 +109,6 @@ pub const OPTION_SOME: [&str; 4] = ["core", "option", "Option", "Some"];
 pub const ORD: [&str; 3] = ["core", "cmp", "Ord"];
 pub const OS_STRING_AS_OS_STR: [&str; 5] = ["std", "ffi", "os_str", "OsString", "as_os_str"];
 pub const OS_STR_TO_OS_STRING: [&str; 5] = ["std", "ffi", "os_str", "OsStr", "to_os_string"];
-pub(super) const PANICKING_PANIC: [&str; 3] = ["core", "panicking", "panic"];
-pub(super) const PANICKING_PANIC_FMT: [&str; 3] = ["core", "panicking", "panic_fmt"];
-pub(super) const PANICKING_PANIC_STR: [&str; 3] = ["core", "panicking", "panic_str"];
-pub(super) const PANIC_ANY: [&str; 3] = ["std", "panic", "panic_any"];
 pub const PARKING_LOT_RAWMUTEX: [&str; 3] = ["parking_lot", "raw_mutex", "RawMutex"];
 pub const PARKING_LOT_RAWRWLOCK: [&str; 3] = ["parking_lot", "raw_rwlock", "RawRwLock"];
 pub const PARKING_LOT_MUTEX_GUARD: [&str; 2] = ["parking_lot", "MutexGuard"];
diff --git a/tests/ui/assertions_on_constants.rs b/tests/ui/assertions_on_constants.rs
index cb516d0f977..7477c01ca78 100644
--- a/tests/ui/assertions_on_constants.rs
+++ b/tests/ui/assertions_on_constants.rs
@@ -1,4 +1,3 @@
-//FIXME: suggestions are wrongly expanded, this should be fixed along with #7843
 #![allow(non_fmt_panics)]
 
 macro_rules! assert_const {
diff --git a/tests/ui/assertions_on_constants.stderr b/tests/ui/assertions_on_constants.stderr
index ec80ec702fb..e1f818814d5 100644
--- a/tests/ui/assertions_on_constants.stderr
+++ b/tests/ui/assertions_on_constants.stderr
@@ -1,75 +1,75 @@
 error: `assert!(true)` will be optimized out by the compiler
-  --> $DIR/assertions_on_constants.rs:11:5
+  --> $DIR/assertions_on_constants.rs:10:5
    |
 LL |     assert!(true);
    |     ^^^^^^^^^^^^^
    |
    = note: `-D clippy::assertions-on-constants` implied by `-D warnings`
    = help: remove it
-   = note: this error originates in the macro `assert` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: `assert!(false)` should probably be replaced
-  --> $DIR/assertions_on_constants.rs:12:5
+  --> $DIR/assertions_on_constants.rs:11:5
    |
 LL |     assert!(false);
    |     ^^^^^^^^^^^^^^
    |
    = help: use `panic!()` or `unreachable!()`
-   = note: this error originates in the macro `assert` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: `assert!(true)` will be optimized out by the compiler
-  --> $DIR/assertions_on_constants.rs:13:5
+  --> $DIR/assertions_on_constants.rs:12:5
    |
 LL |     assert!(true, "true message");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: remove it
-   = note: this error originates in the macro `assert` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: `assert!(false, $crate::const_format_args!($($t)+))` should probably be replaced
-  --> $DIR/assertions_on_constants.rs:14:5
+error: `assert!(false, ..)` should probably be replaced
+  --> $DIR/assertions_on_constants.rs:13:5
    |
 LL |     assert!(false, "false message");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: use `panic!($crate::const_format_args!($($t)+))` or `unreachable!($crate::const_format_args!($($t)+))`
-   = note: this error originates in the macro `assert` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = help: use `panic!(..)` or `unreachable!(..)`
+
+error: `assert!(false, ..)` should probably be replaced
+  --> $DIR/assertions_on_constants.rs:16:5
+   |
+LL |     assert!(false, "{}", msg.to_uppercase());
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use `panic!(..)` or `unreachable!(..)`
 
 error: `assert!(true)` will be optimized out by the compiler
-  --> $DIR/assertions_on_constants.rs:20:5
+  --> $DIR/assertions_on_constants.rs:19:5
    |
 LL |     assert!(B);
    |     ^^^^^^^^^^
    |
    = help: remove it
-   = note: this error originates in the macro `assert` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: `assert!(false)` should probably be replaced
-  --> $DIR/assertions_on_constants.rs:23:5
+  --> $DIR/assertions_on_constants.rs:22:5
    |
 LL |     assert!(C);
    |     ^^^^^^^^^^
    |
    = help: use `panic!()` or `unreachable!()`
-   = note: this error originates in the macro `assert` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: `assert!(false, $crate::const_format_args!($($t)+))` should probably be replaced
-  --> $DIR/assertions_on_constants.rs:24:5
+error: `assert!(false, ..)` should probably be replaced
+  --> $DIR/assertions_on_constants.rs:23:5
    |
 LL |     assert!(C, "C message");
    |     ^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: use `panic!($crate::const_format_args!($($t)+))` or `unreachable!($crate::const_format_args!($($t)+))`
-   = note: this error originates in the macro `assert` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = help: use `panic!(..)` or `unreachable!(..)`
 
 error: `debug_assert!(true)` will be optimized out by the compiler
-  --> $DIR/assertions_on_constants.rs:26:5
+  --> $DIR/assertions_on_constants.rs:25:5
    |
 LL |     debug_assert!(true);
    |     ^^^^^^^^^^^^^^^^^^^
    |
    = help: remove it
-   = note: this error originates in the macro `$crate::assert` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to 8 previous errors
+error: aborting due to 9 previous errors
 
diff --git a/tests/ui/eq_op_macros.stderr b/tests/ui/eq_op_macros.stderr
index 885415b42c7..cd9f1826e59 100644
--- a/tests/ui/eq_op_macros.stderr
+++ b/tests/ui/eq_op_macros.stderr
@@ -21,6 +21,28 @@ LL |     assert_in_macro_def!();
    |
    = note: this error originates in the macro `assert_in_macro_def` (in Nightly builds, run with -Z macro-backtrace for more info)
 
+error: identical args used in this `debug_assert_eq!` macro call
+  --> $DIR/eq_op_macros.rs:9:26
+   |
+LL |         debug_assert_eq!(a, a);
+   |                          ^^^^
+...
+LL |     assert_in_macro_def!();
+   |     ---------------------- in this macro invocation
+   |
+   = note: this error originates in the macro `assert_in_macro_def` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: identical args used in this `debug_assert_ne!` macro call
+  --> $DIR/eq_op_macros.rs:10:26
+   |
+LL |         debug_assert_ne!(a, a);
+   |                          ^^^^
+...
+LL |     assert_in_macro_def!();
+   |     ---------------------- in this macro invocation
+   |
+   = note: this error originates in the macro `assert_in_macro_def` (in Nightly builds, run with -Z macro-backtrace for more info)
+
 error: identical args used in this `assert_eq!` macro call
   --> $DIR/eq_op_macros.rs:22:16
    |
@@ -45,28 +67,6 @@ error: identical args used in this `assert_ne!` macro call
 LL |     assert_ne!(a + 1, a + 1);
    |                ^^^^^^^^^^^^
 
-error: identical args used in this `debug_assert_eq!` macro call
-  --> $DIR/eq_op_macros.rs:9:26
-   |
-LL |         debug_assert_eq!(a, a);
-   |                          ^^^^
-...
-LL |     assert_in_macro_def!();
-   |     ---------------------- in this macro invocation
-   |
-   = note: this error originates in the macro `assert_in_macro_def` (in Nightly builds, run with -Z macro-backtrace for more info)
-
-error: identical args used in this `debug_assert_ne!` macro call
-  --> $DIR/eq_op_macros.rs:10:26
-   |
-LL |         debug_assert_ne!(a, a);
-   |                          ^^^^
-...
-LL |     assert_in_macro_def!();
-   |     ---------------------- in this macro invocation
-   |
-   = note: this error originates in the macro `assert_in_macro_def` (in Nightly builds, run with -Z macro-backtrace for more info)
-
 error: identical args used in this `debug_assert_eq!` macro call
   --> $DIR/eq_op_macros.rs:38:22
    |
diff --git a/tests/ui/missing_panics_doc.stderr b/tests/ui/missing_panics_doc.stderr
index 8bccbaefe23..91ebd695238 100644
--- a/tests/ui/missing_panics_doc.stderr
+++ b/tests/ui/missing_panics_doc.stderr
@@ -27,7 +27,6 @@ note: first possible panic found here
    |
 LL |     panic!("This function panics")
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   = note: this error originates in the macro `$crate::panic::panic_2021` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: docs for function which may panic missing `# Panics` section
   --> $DIR/missing_panics_doc.rs:17:1
@@ -42,7 +41,6 @@ note: first possible panic found here
    |
 LL |     todo!()
    |     ^^^^^^^
-   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: docs for function which may panic missing `# Panics` section
   --> $DIR/missing_panics_doc.rs:22:1
@@ -61,7 +59,6 @@ note: first possible panic found here
    |
 LL |             panic!()
    |             ^^^^^^^^
-   = note: this error originates in the macro `$crate::panic::panic_2021` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: docs for function which may panic missing `# Panics` section
   --> $DIR/missing_panics_doc.rs:31:1
@@ -76,7 +73,6 @@ note: first possible panic found here
    |
 LL |     if true { unreachable!() } else { panic!() }
    |                                       ^^^^^^^^
-   = note: this error originates in the macro `$crate::panic::panic_2021` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: docs for function which may panic missing `# Panics` section
   --> $DIR/missing_panics_doc.rs:36:1
@@ -92,7 +88,6 @@ note: first possible panic found here
    |
 LL |     assert_eq!(x, 0);
    |     ^^^^^^^^^^^^^^^^
-   = note: this error originates in the macro `assert_eq` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: docs for function which may panic missing `# Panics` section
   --> $DIR/missing_panics_doc.rs:42:1
@@ -108,7 +103,6 @@ note: first possible panic found here
    |
 LL |     assert_ne!(x, 0);
    |     ^^^^^^^^^^^^^^^^
-   = note: this error originates in the macro `assert_ne` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: aborting due to 7 previous errors
 
diff --git a/tests/ui/panic_in_result_fn.stderr b/tests/ui/panic_in_result_fn.stderr
index 78d09b8b210..561503ae54f 100644
--- a/tests/ui/panic_in_result_fn.stderr
+++ b/tests/ui/panic_in_result_fn.stderr
@@ -14,7 +14,6 @@ note: return Err() instead of panicking
    |
 LL |         panic!("error");
    |         ^^^^^^^^^^^^^^^
-   = note: this error originates in the macro `$crate::panic::panic_2021` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: used `unimplemented!()`, `unreachable!()`, `todo!()`, `panic!()` or assertion in a function that returns `Result`
   --> $DIR/panic_in_result_fn.rs:11:5
@@ -31,7 +30,6 @@ note: return Err() instead of panicking
    |
 LL |         unimplemented!();
    |         ^^^^^^^^^^^^^^^^
-   = note: this error originates in the macro `unimplemented` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: used `unimplemented!()`, `unreachable!()`, `todo!()`, `panic!()` or assertion in a function that returns `Result`
   --> $DIR/panic_in_result_fn.rs:16:5
@@ -48,7 +46,6 @@ note: return Err() instead of panicking
    |
 LL |         unreachable!();
    |         ^^^^^^^^^^^^^^
-   = note: this error originates in the macro `unreachable` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: used `unimplemented!()`, `unreachable!()`, `todo!()`, `panic!()` or assertion in a function that returns `Result`
   --> $DIR/panic_in_result_fn.rs:21:5
@@ -65,7 +62,6 @@ note: return Err() instead of panicking
    |
 LL |         todo!("Finish this");
    |         ^^^^^^^^^^^^^^^^^^^^
-   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: used `unimplemented!()`, `unreachable!()`, `todo!()`, `panic!()` or assertion in a function that returns `Result`
   --> $DIR/panic_in_result_fn.rs:52:1
@@ -82,7 +78,6 @@ note: return Err() instead of panicking
    |
 LL |     panic!("error");
    |     ^^^^^^^^^^^^^^^
-   = note: this error originates in the macro `$crate::panic::panic_2021` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: used `unimplemented!()`, `unreachable!()`, `todo!()`, `panic!()` or assertion in a function that returns `Result`
   --> $DIR/panic_in_result_fn.rs:67:1
@@ -99,7 +94,6 @@ note: return Err() instead of panicking
    |
 LL |     todo!("finish main method");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: aborting due to 6 previous errors
 
diff --git a/tests/ui/panic_in_result_fn_assertions.stderr b/tests/ui/panic_in_result_fn_assertions.stderr
index 7501d6d85ed..b6aa005e7b5 100644
--- a/tests/ui/panic_in_result_fn_assertions.stderr
+++ b/tests/ui/panic_in_result_fn_assertions.stderr
@@ -15,7 +15,6 @@ note: return Err() instead of panicking
    |
 LL |         assert!(x == 5, "wrong argument");
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   = note: this error originates in the macro `assert` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: used `unimplemented!()`, `unreachable!()`, `todo!()`, `panic!()` or assertion in a function that returns `Result`
   --> $DIR/panic_in_result_fn_assertions.rs:13:5
@@ -33,7 +32,6 @@ note: return Err() instead of panicking
    |
 LL |         assert_eq!(x, 5);
    |         ^^^^^^^^^^^^^^^^
-   = note: this error originates in the macro `assert_eq` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: used `unimplemented!()`, `unreachable!()`, `todo!()`, `panic!()` or assertion in a function that returns `Result`
   --> $DIR/panic_in_result_fn_assertions.rs:19:5
@@ -51,7 +49,6 @@ note: return Err() instead of panicking
    |
 LL |         assert_ne!(x, 1);
    |         ^^^^^^^^^^^^^^^^
-   = note: this error originates in the macro `assert_ne` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: aborting due to 3 previous errors
 
diff --git a/tests/ui/panicking_macros.stderr b/tests/ui/panicking_macros.stderr
index 2b607ff5888..bfd1c7a3801 100644
--- a/tests/ui/panicking_macros.stderr
+++ b/tests/ui/panicking_macros.stderr
@@ -25,23 +25,18 @@ LL |     todo!();
    |     ^^^^^^^
    |
    = note: `-D clippy::todo` implied by `-D warnings`
-   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: `todo` should not be present in production code
   --> $DIR/panicking_macros.rs:17:5
    |
 LL |     todo!("message");
    |     ^^^^^^^^^^^^^^^^
-   |
-   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: `todo` should not be present in production code
   --> $DIR/panicking_macros.rs:18:5
    |
 LL |     todo!("{} {}", "panic with", "multiple arguments");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: `unimplemented` should not be present in production code
   --> $DIR/panicking_macros.rs:24:5
@@ -50,23 +45,18 @@ LL |     unimplemented!();
    |     ^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::unimplemented` implied by `-D warnings`
-   = note: this error originates in the macro `unimplemented` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: `unimplemented` should not be present in production code
   --> $DIR/panicking_macros.rs:25:5
    |
 LL |     unimplemented!("message");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: this error originates in the macro `unimplemented` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: `unimplemented` should not be present in production code
   --> $DIR/panicking_macros.rs:26:5
    |
 LL |     unimplemented!("{} {}", "panic with", "multiple arguments");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: this error originates in the macro `unimplemented` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the `unreachable!` macro
   --> $DIR/panicking_macros.rs:32:5
@@ -75,23 +65,18 @@ LL |     unreachable!();
    |     ^^^^^^^^^^^^^^
    |
    = note: `-D clippy::unreachable` implied by `-D warnings`
-   = note: this error originates in the macro `unreachable` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the `unreachable!` macro
   --> $DIR/panicking_macros.rs:33:5
    |
 LL |     unreachable!("message");
    |     ^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: this error originates in the macro `$crate::unreachable` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the `unreachable!` macro
   --> $DIR/panicking_macros.rs:34:5
    |
 LL |     unreachable!("{} {}", "panic with", "multiple arguments");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: this error originates in the macro `unreachable` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: `panic` should not be present in production code
   --> $DIR/panicking_macros.rs:40:5
@@ -104,24 +89,18 @@ error: `todo` should not be present in production code
    |
 LL |     todo!();
    |     ^^^^^^^
-   |
-   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: `unimplemented` should not be present in production code
   --> $DIR/panicking_macros.rs:42:5
    |
 LL |     unimplemented!();
    |     ^^^^^^^^^^^^^^^^
-   |
-   = note: this error originates in the macro `unimplemented` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the `unreachable!` macro
   --> $DIR/panicking_macros.rs:43:5
    |
 LL |     unreachable!();
    |     ^^^^^^^^^^^^^^
-   |
-   = note: this error originates in the macro `unreachable` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: aborting due to 16 previous errors
 
diff --git a/tests/ui/unit_cmp.stderr b/tests/ui/unit_cmp.stderr
index 2b5a7b348b9..824506a4257 100644
--- a/tests/ui/unit_cmp.stderr
+++ b/tests/ui/unit_cmp.stderr
@@ -33,8 +33,6 @@ LL | |         },
 LL | |         }
 LL | |     );
    | |_____^
-   |
-   = note: this error originates in the macro `assert_eq` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: `debug_assert_eq` of unit values detected. This will always succeed
   --> $DIR/unit_cmp.rs:32:5
@@ -47,8 +45,6 @@ LL | |         },
 LL | |         }
 LL | |     );
    | |_____^
-   |
-   = note: this error originates in the macro `$crate::assert_eq` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: `assert_ne` of unit values detected. This will always fail
   --> $DIR/unit_cmp.rs:41:5
@@ -61,8 +57,6 @@ LL | |         },
 LL | |         }
 LL | |     );
    | |_____^
-   |
-   = note: this error originates in the macro `assert_ne` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: `debug_assert_ne` of unit values detected. This will always fail
   --> $DIR/unit_cmp.rs:49:5
@@ -75,8 +69,6 @@ LL | |         },
 LL | |         }
 LL | |     );
    | |_____^
-   |
-   = note: this error originates in the macro `$crate::assert_ne` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: aborting due to 6 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From a4ebf6f78e8a3f586251e7d0e4c72af51b436de5 Mon Sep 17 00:00:00 2001
From: "Samuel E. Moelius III" <sam@moeli.us>
Date: Thu, 30 Dec 2021 18:43:34 -0500
Subject: Change `unnecessary_to_owned` `into_iter` suggestions to
 `MaybeIncorrect`

---
 clippy_lints/src/methods/unnecessary_iter_cloned.rs | 17 ++++++++++++++---
 clippy_lints/src/methods/unnecessary_to_owned.rs    | 13 +++++++++++--
 2 files changed, 25 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/unnecessary_iter_cloned.rs b/clippy_lints/src/methods/unnecessary_iter_cloned.rs
index 8300df03e99..4f589a6d318 100644
--- a/clippy_lints/src/methods/unnecessary_iter_cloned.rs
+++ b/clippy_lints/src/methods/unnecessary_iter_cloned.rs
@@ -18,7 +18,7 @@ pub fn check(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, method_name: Symbol
         if let Some(callee_def_id) = fn_def_id(cx, parent);
         if is_into_iter(cx, callee_def_id);
         then {
-            check_for_loop_iter(cx, parent, method_name, receiver)
+            check_for_loop_iter(cx, parent, method_name, receiver, false)
         } else {
             false
         }
@@ -34,6 +34,7 @@ pub fn check_for_loop_iter(
     expr: &'tcx Expr<'tcx>,
     method_name: Symbol,
     receiver: &'tcx Expr<'tcx>,
+    cloned_before_iter: bool,
 ) -> bool {
     if_chain! {
         if let Some(grandparent) = get_parent_expr(cx, expr).and_then(|parent| get_parent_expr(cx, parent));
@@ -70,12 +71,22 @@ pub fn check_for_loop_iter(
                 expr.span,
                 &format!("unnecessary use of `{}`", method_name),
                 |diag| {
-                    diag.span_suggestion(expr.span, "use", snippet, Applicability::MachineApplicable);
+                    // If `check_into_iter_call_arg` called `check_for_loop_iter` because a call to
+                    // a `to_owned`-like function was removed, then the next suggestion may be
+                    // incorrect. This is because the iterator that results from the call's removal
+                    // could hold a reference to a resource that is used mutably. See
+                    // https://github.com/rust-lang/rust-clippy/issues/8148.
+                    let applicability = if cloned_before_iter {
+                        Applicability::MaybeIncorrect
+                    } else {
+                        Applicability::MachineApplicable
+                    };
+                    diag.span_suggestion(expr.span, "use", snippet, applicability);
                     for addr_of_expr in addr_of_exprs {
                         match addr_of_expr.kind {
                             ExprKind::AddrOf(_, _, referent) => {
                                 let span = addr_of_expr.span.with_hi(referent.span.lo());
-                                diag.span_suggestion(span, "remove this `&`", String::new(), Applicability::MachineApplicable);
+                                diag.span_suggestion(span, "remove this `&`", String::new(), applicability);
                             }
                             _ => unreachable!(),
                         }
diff --git a/clippy_lints/src/methods/unnecessary_to_owned.rs b/clippy_lints/src/methods/unnecessary_to_owned.rs
index c48bacfce0d..7e17f163b21 100644
--- a/clippy_lints/src/methods/unnecessary_to_owned.rs
+++ b/clippy_lints/src/methods/unnecessary_to_owned.rs
@@ -187,7 +187,13 @@ fn check_into_iter_call_arg(
         if let Some(item_ty) = get_iterator_item_ty(cx, parent_ty);
         if let Some(receiver_snippet) = snippet_opt(cx, receiver.span);
         then {
-            if unnecessary_iter_cloned::check_for_loop_iter(cx, parent, method_name, receiver) {
+            if unnecessary_iter_cloned::check_for_loop_iter(
+                cx,
+                parent,
+                method_name,
+                receiver,
+                true,
+            ) {
                 return true;
             }
             let cloned_or_copied = if is_copy(cx, item_ty) {
@@ -195,6 +201,9 @@ fn check_into_iter_call_arg(
             } else {
                 "cloned"
             };
+            // The next suggestion may be incorrect because the removal of the `to_owned`-like
+            // function could cause the iterator to hold a reference to a resource that is used
+            // mutably. See https://github.com/rust-lang/rust-clippy/issues/8148.
             span_lint_and_sugg(
                 cx,
                 UNNECESSARY_TO_OWNED,
@@ -202,7 +211,7 @@ fn check_into_iter_call_arg(
                 &format!("unnecessary use of `{}`", method_name),
                 "use",
                 format!("{}.iter().{}()", receiver_snippet, cloned_or_copied),
-                Applicability::MachineApplicable,
+                Applicability::MaybeIncorrect,
             );
             return true;
         }
-- 
cgit 1.4.1-3-g733a5


From 14f34454b04e6fd578ccbeaed99d8d3ad3ba1bc9 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Wed, 5 Jan 2022 12:15:10 -0500
Subject: Don't lint `DequeVec` in `manual_memcpy`

---
 clippy_lints/src/loops/manual_memcpy.rs | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/manual_memcpy.rs b/clippy_lints/src/loops/manual_memcpy.rs
index c62fa5e998b..0bff868641c 100644
--- a/clippy_lints/src/loops/manual_memcpy.rs
+++ b/clippy_lints/src/loops/manual_memcpy.rs
@@ -2,7 +2,6 @@ use super::{IncrementVisitor, InitializeVisitor, MANUAL_MEMCPY};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet;
 use clippy_utils::sugg::Sugg;
-use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::{get_enclosing_block, higher, path_to_local, sugg};
 use if_chain::if_chain;
 use rustc_ast::ast;
@@ -325,13 +324,12 @@ struct Start<'hir> {
 }
 
 fn is_slice_like<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'_>) -> bool {
-    let is_slice = match ty.kind() {
+    match ty.kind() {
+        ty::Adt(adt, _) => cx.tcx.is_diagnostic_item(sym::Vec, adt.did),
         ty::Ref(_, subty, _) => is_slice_like(cx, subty),
         ty::Slice(..) | ty::Array(..) => true,
         _ => false,
-    };
-
-    is_slice || is_type_diagnostic_item(cx, ty, sym::Vec) || is_type_diagnostic_item(cx, ty, sym::VecDeque)
+    }
 }
 
 fn fetch_cloned_expr<'tcx>(expr: &'tcx Expr<'tcx>) -> &'tcx Expr<'tcx> {
-- 
cgit 1.4.1-3-g733a5


From 3925def9cf0daace7e725840d6044ad9d831c40d Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Wed, 5 Jan 2022 12:35:35 -0500
Subject: Suggest `copy_from_slice` for `manual_memcpy` when possible

---
 clippy_lints/src/loops/manual_memcpy.rs            | 29 ++++++++++++++--------
 tests/ui/manual_memcpy/with_loop_counters.stderr   | 24 +++++++++---------
 .../ui/manual_memcpy/without_loop_counters.stderr  | 26 +++++++++----------
 3 files changed, 44 insertions(+), 35 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/manual_memcpy.rs b/clippy_lints/src/loops/manual_memcpy.rs
index 0bff868641c..17302f43c32 100644
--- a/clippy_lints/src/loops/manual_memcpy.rs
+++ b/clippy_lints/src/loops/manual_memcpy.rs
@@ -2,6 +2,7 @@ use super::{IncrementVisitor, InitializeVisitor, MANUAL_MEMCPY};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet;
 use clippy_utils::sugg::Sugg;
+use clippy_utils::ty::is_copy;
 use clippy_utils::{get_enclosing_block, higher, path_to_local, sugg};
 use if_chain::if_chain;
 use rustc_ast::ast;
@@ -61,15 +62,15 @@ pub(super) fn check<'tcx>(
                         if_chain! {
                             if let ExprKind::Index(base_left, idx_left) = lhs.kind;
                             if let ExprKind::Index(base_right, idx_right) = rhs.kind;
-                            if is_slice_like(cx, cx.typeck_results().expr_ty(base_left));
-                            if is_slice_like(cx, cx.typeck_results().expr_ty(base_right));
+                            if let Some(ty) = get_slice_like_element_ty(cx, cx.typeck_results().expr_ty(base_left));
+                            if get_slice_like_element_ty(cx, cx.typeck_results().expr_ty(base_right)).is_some();
                             if let Some((start_left, offset_left)) = get_details_from_idx(cx, idx_left, &starts);
                             if let Some((start_right, offset_right)) = get_details_from_idx(cx, idx_right, &starts);
 
                             // Source and destination must be different
                             if path_to_local(base_left) != path_to_local(base_right);
                             then {
-                                Some((IndexExpr { base: base_left, idx: start_left, idx_offset: offset_left },
+                                Some((ty, IndexExpr { base: base_left, idx: start_left, idx_offset: offset_left },
                                     IndexExpr { base: base_right, idx: start_right, idx_offset: offset_right }))
                             } else {
                                 None
@@ -77,7 +78,7 @@ pub(super) fn check<'tcx>(
                         }
                     })
                 })
-                .map(|o| o.map(|(dst, src)| build_manual_memcpy_suggestion(cx, start, end, limits, &dst, &src)))
+                .map(|o| o.map(|(ty, dst, src)| build_manual_memcpy_suggestion(cx, start, end, limits, ty, &dst, &src)))
                 .collect::<Option<Vec<_>>>()
                 .filter(|v| !v.is_empty())
                 .map(|v| v.join("\n    "));
@@ -104,6 +105,7 @@ fn build_manual_memcpy_suggestion<'tcx>(
     start: &Expr<'_>,
     end: &Expr<'_>,
     limits: ast::RangeLimits,
+    elem_ty: Ty<'tcx>,
     dst: &IndexExpr<'_>,
     src: &IndexExpr<'_>,
 ) -> String {
@@ -186,9 +188,16 @@ fn build_manual_memcpy_suggestion<'tcx>(
         .into()
     };
 
+    let method_str = if is_copy(cx, elem_ty) {
+        "copy_from_slice"
+    } else {
+        "clone_from_slice"
+    };
+
     format!(
-        "{}.clone_from_slice(&{}[{}..{}]);",
+        "{}.{}(&{}[{}..{}]);",
         dst,
+        method_str,
         src_base_str,
         src_offset.maybe_par(),
         src_limit.maybe_par()
@@ -323,12 +332,12 @@ struct Start<'hir> {
     kind: StartKind<'hir>,
 }
 
-fn is_slice_like<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'_>) -> bool {
+fn get_slice_like_element_ty<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Option<Ty<'tcx>> {
     match ty.kind() {
-        ty::Adt(adt, _) => cx.tcx.is_diagnostic_item(sym::Vec, adt.did),
-        ty::Ref(_, subty, _) => is_slice_like(cx, subty),
-        ty::Slice(..) | ty::Array(..) => true,
-        _ => false,
+        ty::Adt(adt, subs) if cx.tcx.is_diagnostic_item(sym::Vec, adt.did) => Some(subs.type_at(0)),
+        ty::Ref(_, subty, _) => get_slice_like_element_ty(cx, subty),
+        ty::Slice(ty) | ty::Array(ty, _) => Some(ty),
+        _ => None,
     }
 }
 
diff --git a/tests/ui/manual_memcpy/with_loop_counters.stderr b/tests/ui/manual_memcpy/with_loop_counters.stderr
index 2e3ebadd7b5..79d40c0bcb1 100644
--- a/tests/ui/manual_memcpy/with_loop_counters.stderr
+++ b/tests/ui/manual_memcpy/with_loop_counters.stderr
@@ -5,7 +5,7 @@ LL | /     for i in 3..src.len() {
 LL | |         dst[i] = src[count];
 LL | |         count += 1;
 LL | |     }
-   | |_____^ help: try replacing the loop by: `dst[3..src.len()].clone_from_slice(&src[..(src.len() - 3)]);`
+   | |_____^ help: try replacing the loop by: `dst[3..src.len()].copy_from_slice(&src[..(src.len() - 3)]);`
    |
    = note: `-D clippy::manual-memcpy` implied by `-D warnings`
 
@@ -16,7 +16,7 @@ LL | /     for i in 3..src.len() {
 LL | |         dst[count] = src[i];
 LL | |         count += 1;
 LL | |     }
-   | |_____^ help: try replacing the loop by: `dst[..(src.len() - 3)].clone_from_slice(&src[3..]);`
+   | |_____^ help: try replacing the loop by: `dst[..(src.len() - 3)].copy_from_slice(&src[3..]);`
 
 error: it looks like you're manually copying between slices
   --> $DIR/with_loop_counters.rs:17:5
@@ -25,7 +25,7 @@ LL | /     for i in 0..src.len() {
 LL | |         dst[count] = src[i];
 LL | |         count += 1;
 LL | |     }
-   | |_____^ help: try replacing the loop by: `dst[3..(src.len() + 3)].clone_from_slice(&src[..]);`
+   | |_____^ help: try replacing the loop by: `dst[3..(src.len() + 3)].copy_from_slice(&src[..]);`
 
 error: it looks like you're manually copying between slices
   --> $DIR/with_loop_counters.rs:23:5
@@ -34,7 +34,7 @@ LL | /     for i in 0..src.len() {
 LL | |         dst[i] = src[count];
 LL | |         count += 1;
 LL | |     }
-   | |_____^ help: try replacing the loop by: `dst[..src.len()].clone_from_slice(&src[3..(src.len() + 3)]);`
+   | |_____^ help: try replacing the loop by: `dst[..src.len()].copy_from_slice(&src[3..(src.len() + 3)]);`
 
 error: it looks like you're manually copying between slices
   --> $DIR/with_loop_counters.rs:29:5
@@ -43,7 +43,7 @@ LL | /     for i in 3..(3 + src.len()) {
 LL | |         dst[i] = src[count];
 LL | |         count += 1;
 LL | |     }
-   | |_____^ help: try replacing the loop by: `dst[3..(3 + src.len())].clone_from_slice(&src[..(3 + src.len() - 3)]);`
+   | |_____^ help: try replacing the loop by: `dst[3..(3 + src.len())].copy_from_slice(&src[..(3 + src.len() - 3)]);`
 
 error: it looks like you're manually copying between slices
   --> $DIR/with_loop_counters.rs:35:5
@@ -52,7 +52,7 @@ LL | /     for i in 5..src.len() {
 LL | |         dst[i] = src[count - 2];
 LL | |         count += 1;
 LL | |     }
-   | |_____^ help: try replacing the loop by: `dst[5..src.len()].clone_from_slice(&src[(3 - 2)..((src.len() - 2) + 3 - 5)]);`
+   | |_____^ help: try replacing the loop by: `dst[5..src.len()].copy_from_slice(&src[(3 - 2)..((src.len() - 2) + 3 - 5)]);`
 
 error: it looks like you're manually copying between slices
   --> $DIR/with_loop_counters.rs:41:5
@@ -61,7 +61,7 @@ LL | /     for i in 0..dst.len() {
 LL | |         dst[i] = src[count];
 LL | |         count += 1;
 LL | |     }
-   | |_____^ help: try replacing the loop by: `dst.clone_from_slice(&src[2..(dst.len() + 2)]);`
+   | |_____^ help: try replacing the loop by: `dst.copy_from_slice(&src[2..(dst.len() + 2)]);`
 
 error: it looks like you're manually copying between slices
   --> $DIR/with_loop_counters.rs:47:5
@@ -70,7 +70,7 @@ LL | /     for i in 3..10 {
 LL | |         dst[i] = src[count];
 LL | |         count += 1;
 LL | |     }
-   | |_____^ help: try replacing the loop by: `dst[3..10].clone_from_slice(&src[5..(10 + 5 - 3)]);`
+   | |_____^ help: try replacing the loop by: `dst[3..10].copy_from_slice(&src[5..(10 + 5 - 3)]);`
 
 error: it looks like you're manually copying between slices
   --> $DIR/with_loop_counters.rs:54:5
@@ -85,8 +85,8 @@ LL | |     }
    |
 help: try replacing the loop by
    |
-LL ~     dst[3..(src.len() + 3)].clone_from_slice(&src[..]);
-LL +     dst2[30..(src.len() + 30)].clone_from_slice(&src[..]);
+LL ~     dst[3..(src.len() + 3)].copy_from_slice(&src[..]);
+LL +     dst2[30..(src.len() + 30)].copy_from_slice(&src[..]);
    |
 
 error: it looks like you're manually copying between slices
@@ -96,7 +96,7 @@ LL | /     for i in 0..1 << 1 {
 LL | |         dst[count] = src[i + 2];
 LL | |         count += 1;
 LL | |     }
-   | |_____^ help: try replacing the loop by: `dst[(0 << 1)..((1 << 1) + (0 << 1))].clone_from_slice(&src[2..((1 << 1) + 2)]);`
+   | |_____^ help: try replacing the loop by: `dst[(0 << 1)..((1 << 1) + (0 << 1))].copy_from_slice(&src[2..((1 << 1) + 2)]);`
 
 error: it looks like you're manually copying between slices
   --> $DIR/with_loop_counters.rs:71:5
@@ -105,7 +105,7 @@ LL | /     for i in 3..src.len() {
 LL | |         dst[i] = src[count];
 LL | |         count += 1
 LL | |     }
-   | |_____^ help: try replacing the loop by: `dst[3..src.len()].clone_from_slice(&src[..(src.len() - 3)]);`
+   | |_____^ help: try replacing the loop by: `dst[3..src.len()].copy_from_slice(&src[..(src.len() - 3)]);`
 
 error: aborting due to 11 previous errors
 
diff --git a/tests/ui/manual_memcpy/without_loop_counters.stderr b/tests/ui/manual_memcpy/without_loop_counters.stderr
index 8ff0137a812..654dee32a1e 100644
--- a/tests/ui/manual_memcpy/without_loop_counters.stderr
+++ b/tests/ui/manual_memcpy/without_loop_counters.stderr
@@ -4,7 +4,7 @@ error: it looks like you're manually copying between slices
 LL | /     for i in 0..src.len() {
 LL | |         dst[i] = src[i];
 LL | |     }
-   | |_____^ help: try replacing the loop by: `dst[..src.len()].clone_from_slice(&src[..]);`
+   | |_____^ help: try replacing the loop by: `dst[..src.len()].copy_from_slice(&src[..]);`
    |
    = note: `-D clippy::manual-memcpy` implied by `-D warnings`
 
@@ -14,7 +14,7 @@ error: it looks like you're manually copying between slices
 LL | /     for i in 0..src.len() {
 LL | |         dst[i + 10] = src[i];
 LL | |     }
-   | |_____^ help: try replacing the loop by: `dst[10..(src.len() + 10)].clone_from_slice(&src[..]);`
+   | |_____^ help: try replacing the loop by: `dst[10..(src.len() + 10)].copy_from_slice(&src[..]);`
 
 error: it looks like you're manually copying between slices
   --> $DIR/without_loop_counters.rs:17:5
@@ -22,7 +22,7 @@ error: it looks like you're manually copying between slices
 LL | /     for i in 0..src.len() {
 LL | |         dst[i] = src[i + 10];
 LL | |     }
-   | |_____^ help: try replacing the loop by: `dst[..src.len()].clone_from_slice(&src[10..(src.len() + 10)]);`
+   | |_____^ help: try replacing the loop by: `dst[..src.len()].copy_from_slice(&src[10..(src.len() + 10)]);`
 
 error: it looks like you're manually copying between slices
   --> $DIR/without_loop_counters.rs:22:5
@@ -30,7 +30,7 @@ error: it looks like you're manually copying between slices
 LL | /     for i in 11..src.len() {
 LL | |         dst[i] = src[i - 10];
 LL | |     }
-   | |_____^ help: try replacing the loop by: `dst[11..src.len()].clone_from_slice(&src[(11 - 10)..(src.len() - 10)]);`
+   | |_____^ help: try replacing the loop by: `dst[11..src.len()].copy_from_slice(&src[(11 - 10)..(src.len() - 10)]);`
 
 error: it looks like you're manually copying between slices
   --> $DIR/without_loop_counters.rs:27:5
@@ -38,7 +38,7 @@ error: it looks like you're manually copying between slices
 LL | /     for i in 0..dst.len() {
 LL | |         dst[i] = src[i];
 LL | |     }
-   | |_____^ help: try replacing the loop by: `dst.clone_from_slice(&src[..dst.len()]);`
+   | |_____^ help: try replacing the loop by: `dst.copy_from_slice(&src[..dst.len()]);`
 
 error: it looks like you're manually copying between slices
   --> $DIR/without_loop_counters.rs:40:5
@@ -51,8 +51,8 @@ LL | |     }
    |
 help: try replacing the loop by
    |
-LL ~     dst[10..256].clone_from_slice(&src[(10 - 5)..(256 - 5)]);
-LL +     dst2[(10 + 500)..(256 + 500)].clone_from_slice(&src[10..256]);
+LL ~     dst[10..256].copy_from_slice(&src[(10 - 5)..(256 - 5)]);
+LL +     dst2[(10 + 500)..(256 + 500)].copy_from_slice(&src[10..256]);
    |
 
 error: it looks like you're manually copying between slices
@@ -61,7 +61,7 @@ error: it looks like you're manually copying between slices
 LL | /     for i in 10..LOOP_OFFSET {
 LL | |         dst[i + LOOP_OFFSET] = src[i - some_var];
 LL | |     }
-   | |_____^ help: try replacing the loop by: `dst[(10 + LOOP_OFFSET)..(LOOP_OFFSET + LOOP_OFFSET)].clone_from_slice(&src[(10 - some_var)..(LOOP_OFFSET - some_var)]);`
+   | |_____^ help: try replacing the loop by: `dst[(10 + LOOP_OFFSET)..(LOOP_OFFSET + LOOP_OFFSET)].copy_from_slice(&src[(10 - some_var)..(LOOP_OFFSET - some_var)]);`
 
 error: it looks like you're manually copying between slices
   --> $DIR/without_loop_counters.rs:65:5
@@ -69,7 +69,7 @@ error: it looks like you're manually copying between slices
 LL | /     for i in 0..src_vec.len() {
 LL | |         dst_vec[i] = src_vec[i];
 LL | |     }
-   | |_____^ help: try replacing the loop by: `dst_vec[..src_vec.len()].clone_from_slice(&src_vec[..]);`
+   | |_____^ help: try replacing the loop by: `dst_vec[..src_vec.len()].copy_from_slice(&src_vec[..]);`
 
 error: it looks like you're manually copying between slices
   --> $DIR/without_loop_counters.rs:94:5
@@ -77,7 +77,7 @@ error: it looks like you're manually copying between slices
 LL | /     for i in from..from + src.len() {
 LL | |         dst[i] = src[i - from];
 LL | |     }
-   | |_____^ help: try replacing the loop by: `dst[from..(from + src.len())].clone_from_slice(&src[..(from + src.len() - from)]);`
+   | |_____^ help: try replacing the loop by: `dst[from..(from + src.len())].copy_from_slice(&src[..(from + src.len() - from)]);`
 
 error: it looks like you're manually copying between slices
   --> $DIR/without_loop_counters.rs:98:5
@@ -85,7 +85,7 @@ error: it looks like you're manually copying between slices
 LL | /     for i in from..from + 3 {
 LL | |         dst[i] = src[i - from];
 LL | |     }
-   | |_____^ help: try replacing the loop by: `dst[from..(from + 3)].clone_from_slice(&src[..(from + 3 - from)]);`
+   | |_____^ help: try replacing the loop by: `dst[from..(from + 3)].copy_from_slice(&src[..(from + 3 - from)]);`
 
 error: it looks like you're manually copying between slices
   --> $DIR/without_loop_counters.rs:103:5
@@ -93,7 +93,7 @@ error: it looks like you're manually copying between slices
 LL | /     for i in 0..5 {
 LL | |         dst[i - 0] = src[i];
 LL | |     }
-   | |_____^ help: try replacing the loop by: `dst[..5].clone_from_slice(&src[..5]);`
+   | |_____^ help: try replacing the loop by: `dst[..5].copy_from_slice(&src[..5]);`
 
 error: it looks like you're manually copying between slices
   --> $DIR/without_loop_counters.rs:108:5
@@ -101,7 +101,7 @@ error: it looks like you're manually copying between slices
 LL | /     for i in 0..0 {
 LL | |         dst[i] = src[i];
 LL | |     }
-   | |_____^ help: try replacing the loop by: `dst[..0].clone_from_slice(&src[..0]);`
+   | |_____^ help: try replacing the loop by: `dst[..0].copy_from_slice(&src[..0]);`
 
 error: it looks like you're manually copying between slices
   --> $DIR/without_loop_counters.rs:120:5
-- 
cgit 1.4.1-3-g733a5


From 2cc38a23227e743aa24b7656ccbcee768ebef5ac Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Wed, 5 Jan 2022 13:46:35 -0500
Subject: Lint `iter_not_returning_iterator` on the trait definition rather
 than the implementation

---
 clippy_lints/src/iter_not_returning_iterator.rs | 61 +++++++++++++++++--------
 tests/ui/iter_not_returning_iterator.rs         | 12 +++++
 tests/ui/iter_not_returning_iterator.stderr     |  8 +++-
 3 files changed, 60 insertions(+), 21 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/iter_not_returning_iterator.rs b/clippy_lints/src/iter_not_returning_iterator.rs
index 0af6b3b7d46..91d3c00039a 100644
--- a/clippy_lints/src/iter_not_returning_iterator.rs
+++ b/clippy_lints/src/iter_not_returning_iterator.rs
@@ -1,8 +1,7 @@
-use clippy_utils::{diagnostics::span_lint, return_ty, ty::implements_trait};
-use rustc_hir::{ImplItem, ImplItemKind};
+use clippy_utils::{diagnostics::span_lint, get_parent_node, ty::implements_trait};
+use rustc_hir::{def_id::LocalDefId, FnSig, ImplItem, ImplItemKind, Item, ItemKind, Node, TraitItem, TraitItemKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::symbol::kw;
 use rustc_span::symbol::sym;
 
 declare_clippy_lint! {
@@ -41,25 +40,47 @@ declare_clippy_lint! {
 declare_lint_pass!(IterNotReturningIterator => [ITER_NOT_RETURNING_ITERATOR]);
 
 impl LateLintPass<'_> for IterNotReturningIterator {
-    fn check_impl_item(&mut self, cx: &LateContext<'tcx>, impl_item: &'tcx ImplItem<'tcx>) {
-        let name = impl_item.ident.name.as_str();
-        if_chain! {
-            if let ImplItemKind::Fn(fn_sig, _) = &impl_item.kind;
-            let ret_ty = return_ty(cx, impl_item.hir_id());
-            if matches!(name, "iter" | "iter_mut");
-            if let [param] = cx.tcx.fn_arg_names(impl_item.def_id);
-            if param.name == kw::SelfLower;
-            if let Some(iter_trait_id) = cx.tcx.get_diagnostic_item(sym::Iterator);
-            if !implements_trait(cx, ret_ty, iter_trait_id, &[]);
+    fn check_trait_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx TraitItem<'_>) {
+        let name = item.ident.name.as_str();
+        if matches!(name, "iter" | "iter_mut") {
+            if let TraitItemKind::Fn(fn_sig, _) = &item.kind {
+                check_sig(cx, name, fn_sig, item.def_id);
+            }
+        }
+    }
 
-            then {
-                span_lint(
-                    cx,
-                    ITER_NOT_RETURNING_ITERATOR,
-                    fn_sig.span,
-                    &format!("this method is named `{}` but its return type does not implement `Iterator`", name),
-                );
+    fn check_impl_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx ImplItem<'tcx>) {
+        let name = item.ident.name.as_str();
+        if matches!(name, "iter" | "iter_mut")
+            && !matches!(
+                get_parent_node(cx.tcx, item.hir_id()),
+                Some(Node::Item(Item { kind: ItemKind::Impl(i), .. })) if i.of_trait.is_some()
+            )
+        {
+            if let ImplItemKind::Fn(fn_sig, _) = &item.kind {
+                check_sig(cx, name, fn_sig, item.def_id);
             }
         }
     }
 }
+
+fn check_sig(cx: &LateContext<'_>, name: &str, sig: &FnSig<'_>, fn_id: LocalDefId) {
+    if sig.decl.implicit_self.has_implicit_self() {
+        let ret_ty = cx.tcx.fn_sig(fn_id).skip_binder().output();
+        if cx
+            .tcx
+            .get_diagnostic_item(sym::Iterator)
+            .map_or(false, |iter_id| !implements_trait(cx, ret_ty, iter_id, &[]))
+        {
+            span_lint(
+                cx,
+                ITER_NOT_RETURNING_ITERATOR,
+                sig.span,
+                &format!(
+                    "this method is named `{}` but its return type does not implement `Iterator`",
+                    name
+                ),
+            );
+        }
+    }
+}
diff --git a/tests/ui/iter_not_returning_iterator.rs b/tests/ui/iter_not_returning_iterator.rs
index 377f760b3c4..f5ee044576c 100644
--- a/tests/ui/iter_not_returning_iterator.rs
+++ b/tests/ui/iter_not_returning_iterator.rs
@@ -44,4 +44,16 @@ impl Iterator for Counter {
     }
 }
 
+trait Iter {
+    type I;
+    fn iter(&self) -> Self::I;
+}
+
+impl Iter for () {
+    type I = core::slice::Iter<'static, ()>;
+    fn iter(&self) -> Self::I {
+        [].iter()
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/iter_not_returning_iterator.stderr b/tests/ui/iter_not_returning_iterator.stderr
index 2273cd0be66..ddb2b88d5f9 100644
--- a/tests/ui/iter_not_returning_iterator.stderr
+++ b/tests/ui/iter_not_returning_iterator.stderr
@@ -12,5 +12,11 @@ error: this method is named `iter_mut` but its return type does not implement `I
 LL |     fn iter_mut(&self) -> Counter2 {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 2 previous errors
+error: this method is named `iter` but its return type does not implement `Iterator`
+  --> $DIR/iter_not_returning_iterator.rs:49:5
+   |
+LL |     fn iter(&self) -> Self::I;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 3 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From d98339d3e002b8b1bddf225e98c3140d7f1cecc7 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Wed, 5 Jan 2022 13:57:45 -0500
Subject: Handle type projections in `iter_not_returning_iterator`

---
 clippy_lints/src/iter_not_returning_iterator.rs | 4 ++++
 tests/ui/iter_not_returning_iterator.rs         | 8 ++++++++
 tests/ui/iter_not_returning_iterator.stderr     | 2 +-
 3 files changed, 13 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/iter_not_returning_iterator.rs b/clippy_lints/src/iter_not_returning_iterator.rs
index 91d3c00039a..017a8a779d9 100644
--- a/clippy_lints/src/iter_not_returning_iterator.rs
+++ b/clippy_lints/src/iter_not_returning_iterator.rs
@@ -67,6 +67,10 @@ impl LateLintPass<'_> for IterNotReturningIterator {
 fn check_sig(cx: &LateContext<'_>, name: &str, sig: &FnSig<'_>, fn_id: LocalDefId) {
     if sig.decl.implicit_self.has_implicit_self() {
         let ret_ty = cx.tcx.fn_sig(fn_id).skip_binder().output();
+        let ret_ty = cx
+            .tcx
+            .try_normalize_erasing_regions(cx.param_env, ret_ty)
+            .unwrap_or(ret_ty);
         if cx
             .tcx
             .get_diagnostic_item(sym::Iterator)
diff --git a/tests/ui/iter_not_returning_iterator.rs b/tests/ui/iter_not_returning_iterator.rs
index f5ee044576c..2c91e02e842 100644
--- a/tests/ui/iter_not_returning_iterator.rs
+++ b/tests/ui/iter_not_returning_iterator.rs
@@ -44,6 +44,7 @@ impl Iterator for Counter {
     }
 }
 
+// Issue #8225
 trait Iter {
     type I;
     fn iter(&self) -> Self::I;
@@ -56,4 +57,11 @@ impl Iter for () {
     }
 }
 
+struct S;
+impl S {
+    fn iter(&self) -> <() as Iter>::I {
+        ().iter()
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/iter_not_returning_iterator.stderr b/tests/ui/iter_not_returning_iterator.stderr
index ddb2b88d5f9..44f02955836 100644
--- a/tests/ui/iter_not_returning_iterator.stderr
+++ b/tests/ui/iter_not_returning_iterator.stderr
@@ -13,7 +13,7 @@ LL |     fn iter_mut(&self) -> Counter2 {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this method is named `iter` but its return type does not implement `Iterator`
-  --> $DIR/iter_not_returning_iterator.rs:49:5
+  --> $DIR/iter_not_returning_iterator.rs:50:5
    |
 LL |     fn iter(&self) -> Self::I;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From 366234a515ab6538c83e5b58481b2c45abd72d76 Mon Sep 17 00:00:00 2001
From: "Samuel E. Moelius III" <sam@moeli.us>
Date: Sat, 8 Jan 2022 09:09:52 -0500
Subject: Add `unnecessary_to_owned` "Known problems" section

---
 clippy_lints/src/methods/mod.rs | 5 +++++
 1 file changed, 5 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 4e33b2ff14c..6572c7111b3 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1895,6 +1895,11 @@ declare_clippy_lint! {
     /// ### Why is this bad?
     /// The unnecessary calls result in useless allocations.
     ///
+    /// ### Known problems
+    /// `unnecessary_to_owned` can falsely trigger if `IntoIterator::into_iter` is applied to an
+    /// owned copy of a resource and the resource is later used mutably. See
+    /// [#8148](https://github.com/rust-lang/rust-clippy/issues/8148).
+    ///
     /// ### Example
     /// ```rust
     /// let path = std::path::Path::new("x");
-- 
cgit 1.4.1-3-g733a5


From f690978023d7465d05abe9a1288100f192e74193 Mon Sep 17 00:00:00 2001
From: dswij <dswijj@gmail.com>
Date: Thu, 6 Jan 2022 18:43:44 +0800
Subject: cover trait for `trait_duplication_in_bounds`

---
 clippy_lints/src/trait_bounds.rs            | 68 ++++++++++++++++++++++++-----
 tests/ui/trait_duplication_in_bounds.rs     | 37 ++++++++++++++++
 tests/ui/trait_duplication_in_bounds.stderr | 34 ++++++++++++++-
 3 files changed, 128 insertions(+), 11 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/trait_bounds.rs b/clippy_lints/src/trait_bounds.rs
index f2848ad3790..c91b24462c0 100644
--- a/clippy_lints/src/trait_bounds.rs
+++ b/clippy_lints/src/trait_bounds.rs
@@ -3,10 +3,14 @@ use clippy_utils::source::{snippet, snippet_with_applicability};
 use clippy_utils::{SpanlessEq, SpanlessHash};
 use core::hash::{Hash, Hasher};
 use if_chain::if_chain;
-use rustc_data_structures::fx::FxHashMap;
+use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_data_structures::unhash::UnhashMap;
 use rustc_errors::Applicability;
-use rustc_hir::{def::Res, GenericBound, Generics, ParamName, Path, QPath, Ty, TyKind, WherePredicate};
+use rustc_hir::def::Res;
+use rustc_hir::{
+    GenericBound, Generics, Item, ItemKind, Node, ParamName, Path, PathSegment, QPath, TraitItem, Ty, TyKind,
+    WherePredicate,
+};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::Span;
@@ -84,6 +88,46 @@ impl<'tcx> LateLintPass<'tcx> for TraitBounds {
         self.check_type_repetition(cx, gen);
         check_trait_bound_duplication(cx, gen);
     }
+
+    fn check_trait_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx TraitItem<'tcx>) {
+        let Generics { where_clause, .. } = &item.generics;
+        let mut self_bounds_set = FxHashSet::default();
+
+        for predicate in where_clause.predicates {
+            if_chain! {
+                if let WherePredicate::BoundPredicate(ref bound_predicate) = predicate;
+                if !bound_predicate.span.from_expansion();
+                if let TyKind::Path(QPath::Resolved(_, Path { segments, .. })) = bound_predicate.bounded_ty.kind;
+                if let Some(PathSegment { res: Some(Res::SelfTy(Some(def_id), _)), .. }) = segments.first();
+
+                if let Some(
+                    Node::Item(
+                        Item {
+                            kind: ItemKind::Trait(_, _, _, self_bounds, _),
+                            .. }
+                        )
+                    ) = cx.tcx.hir().get_if_local(*def_id);
+                then {
+                    if self_bounds_set.is_empty() {
+                        for bound in self_bounds.iter() {
+                            let Some((self_res, _)) = get_trait_res_span_from_bound(bound) else { continue };
+                            self_bounds_set.insert(self_res);
+                        }
+                    }
+
+                    bound_predicate
+                        .bounds
+                        .iter()
+                        .filter_map(get_trait_res_span_from_bound)
+                        .for_each(|(trait_item_res, span)| {
+                            if self_bounds_set.get(&trait_item_res).is_some() {
+                                emit_lint(cx, span);
+                            }
+                        });
+                }
+            }
+        }
+    }
 }
 
 fn get_trait_res_span_from_bound(bound: &GenericBound<'_>) -> Option<(Res, Span)> {
@@ -198,17 +242,21 @@ fn check_trait_bound_duplication(cx: &LateContext<'_>, gen: &'_ Generics<'_>) {
                     if let Some((_, span_direct)) = trait_resolutions_direct
                                                 .iter()
                                                 .find(|(res_direct, _)| *res_direct == res_where) {
-                        span_lint_and_help(
-                            cx,
-                            TRAIT_DUPLICATION_IN_BOUNDS,
-                            *span_direct,
-                            "this trait bound is already specified in the where clause",
-                            None,
-                            "consider removing this trait bound",
-                        );
+                        emit_lint(cx, *span_direct);
                     }
                 }
             }
         }
     }
 }
+
+fn emit_lint(cx: &LateContext<'_>, span: Span) {
+    span_lint_and_help(
+        cx,
+        TRAIT_DUPLICATION_IN_BOUNDS,
+        span,
+        "this trait bound is already specified in the where clause",
+        None,
+        "consider removing this trait bound",
+    );
+}
diff --git a/tests/ui/trait_duplication_in_bounds.rs b/tests/ui/trait_duplication_in_bounds.rs
index cb2b0054e35..3e490126273 100644
--- a/tests/ui/trait_duplication_in_bounds.rs
+++ b/tests/ui/trait_duplication_in_bounds.rs
@@ -28,4 +28,41 @@ where
     unimplemented!();
 }
 
+trait T: Default {
+    fn f()
+    where
+        Self: Default;
+}
+
+trait U: Default {
+    fn f()
+    where
+        Self: Clone;
+}
+
+trait ZZ: Default {
+    fn f()
+    where
+        Self: Default + Clone;
+}
+
+trait BadTrait: Default + Clone {
+    fn f()
+    where
+        Self: Default + Clone;
+}
+
+#[derive(Default, Clone)]
+struct Life {}
+
+impl T for Life {
+    // this should not warn
+    fn f() {}
+}
+
+impl U for Life {
+    // this should not warn
+    fn f() {}
+}
+
 fn main() {}
diff --git a/tests/ui/trait_duplication_in_bounds.stderr b/tests/ui/trait_duplication_in_bounds.stderr
index 027e1c75204..6326139c187 100644
--- a/tests/ui/trait_duplication_in_bounds.stderr
+++ b/tests/ui/trait_duplication_in_bounds.stderr
@@ -19,5 +19,37 @@ LL | fn bad_foo<T: Clone + Default, Z: Copy>(arg0: T, arg1: Z)
    |
    = help: consider removing this trait bound
 
-error: aborting due to 2 previous errors
+error: this trait bound is already specified in the where clause
+  --> $DIR/trait_duplication_in_bounds.rs:34:15
+   |
+LL |         Self: Default;
+   |               ^^^^^^^
+   |
+   = help: consider removing this trait bound
+
+error: this trait bound is already specified in the where clause
+  --> $DIR/trait_duplication_in_bounds.rs:46:15
+   |
+LL |         Self: Default + Clone;
+   |               ^^^^^^^
+   |
+   = help: consider removing this trait bound
+
+error: this trait bound is already specified in the where clause
+  --> $DIR/trait_duplication_in_bounds.rs:52:15
+   |
+LL |         Self: Default + Clone;
+   |               ^^^^^^^
+   |
+   = help: consider removing this trait bound
+
+error: this trait bound is already specified in the where clause
+  --> $DIR/trait_duplication_in_bounds.rs:52:25
+   |
+LL |         Self: Default + Clone;
+   |                         ^^^^^
+   |
+   = help: consider removing this trait bound
+
+error: aborting due to 6 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From a6f80fccb19a52305ff88d960b4bb4e74df3d8b2 Mon Sep 17 00:00:00 2001
From: bors <bors@rust-lang.org>
Date: Sun, 9 Jan 2022 14:27:36 +0000
Subject: new lint: `single_char_lifetime_names`

This pull request adds a lint against single character lifetime names, as they might not divulge enough information about the purpose of the lifetime. This can make code harder to understand. I placed this in `restriction` rather than `pedantic` (as suggested in #8233) since most of the Rust ecosystem already uses single character lifetime names (to my knowledge, at least) and since single character lifetime names aren't incorrect. I'd be happy to change this upon request, however. Fixes #8233.

- [x] Followed lint naming conventions
- [x] Added passing UI tests (including committed `.stderr` file)
- [x] `cargo test` passes locally
- [x] Executed `cargo dev update_lints`
- [x] Added lint documentation
- [x] Run `cargo dev fmt`

changelog: new lint: [`single_char_lifetime_names`]
---
 CHANGELOG.md                                   |  1 +
 clippy_lints/src/lib.register_lints.rs         |  1 +
 clippy_lints/src/lib.register_restriction.rs   |  1 +
 clippy_lints/src/lib.rs                        |  2 +
 clippy_lints/src/single_char_lifetime_names.rs | 63 ++++++++++++++++++++++++++
 tests/ui/single_char_lifetime_names.rs         | 43 ++++++++++++++++++
 tests/ui/single_char_lifetime_names.stderr     | 43 ++++++++++++++++++
 7 files changed, 154 insertions(+)
 create mode 100644 clippy_lints/src/single_char_lifetime_names.rs
 create mode 100644 tests/ui/single_char_lifetime_names.rs
 create mode 100644 tests/ui/single_char_lifetime_names.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 27bac4718b6..83fd8396bc7 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3253,6 +3253,7 @@ Released 2018-09-13
 [`should_implement_trait`]: https://rust-lang.github.io/rust-clippy/master/index.html#should_implement_trait
 [`similar_names`]: https://rust-lang.github.io/rust-clippy/master/index.html#similar_names
 [`single_char_add_str`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_char_add_str
+[`single_char_lifetime_names`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_char_lifetime_names
 [`single_char_pattern`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_char_pattern
 [`single_component_path_imports`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_component_path_imports
 [`single_element_loop`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_element_loop
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 002122793f3..f9241d943b2 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -435,6 +435,7 @@ store.register_lints(&[
     shadow::SHADOW_REUSE,
     shadow::SHADOW_SAME,
     shadow::SHADOW_UNRELATED,
+    single_char_lifetime_names::SINGLE_CHAR_LIFETIME_NAMES,
     single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS,
     size_of_in_element_count::SIZE_OF_IN_ELEMENT_COUNT,
     slow_vector_initialization::SLOW_VECTOR_INITIALIZATION,
diff --git a/clippy_lints/src/lib.register_restriction.rs b/clippy_lints/src/lib.register_restriction.rs
index eab389a9bd8..e7e2798da7d 100644
--- a/clippy_lints/src/lib.register_restriction.rs
+++ b/clippy_lints/src/lib.register_restriction.rs
@@ -54,6 +54,7 @@ store.register_group(true, "clippy::restriction", Some("clippy_restriction"), ve
     LintId::of(shadow::SHADOW_REUSE),
     LintId::of(shadow::SHADOW_SAME),
     LintId::of(shadow::SHADOW_UNRELATED),
+    LintId::of(single_char_lifetime_names::SINGLE_CHAR_LIFETIME_NAMES),
     LintId::of(strings::STRING_ADD),
     LintId::of(strings::STRING_SLICE),
     LintId::of(strings::STRING_TO_STRING),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index d4687a1e287..c31acb5f4ef 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -351,6 +351,7 @@ mod self_named_constructors;
 mod semicolon_if_nothing_returned;
 mod serde_api;
 mod shadow;
+mod single_char_lifetime_names;
 mod single_component_path_imports;
 mod size_of_in_element_count;
 mod slow_vector_initialization;
@@ -858,6 +859,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(needless_late_init::NeedlessLateInit));
     store.register_late_pass(|| Box::new(return_self_not_must_use::ReturnSelfNotMustUse));
     store.register_late_pass(|| Box::new(init_numbered_fields::NumberedFields));
+    store.register_early_pass(|| Box::new(single_char_lifetime_names::SingleCharLifetimeNames));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/single_char_lifetime_names.rs b/clippy_lints/src/single_char_lifetime_names.rs
new file mode 100644
index 00000000000..ee82666b5af
--- /dev/null
+++ b/clippy_lints/src/single_char_lifetime_names.rs
@@ -0,0 +1,63 @@
+use clippy_utils::diagnostics::span_lint_and_help;
+use rustc_ast::ast::{GenericParam, GenericParamKind};
+use rustc_lint::{EarlyContext, EarlyLintPass};
+use rustc_middle::lint::in_external_macro;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for lifetimes with names which are one character
+    /// long.
+    ///
+    /// ### Why is this bad?
+    /// A single character is likely not enough to express the
+    /// purpose of a lifetime. Using a longer name can make code
+    /// easier to understand, especially for those who are new to
+    /// Rust.
+    ///
+    /// ### Known problems
+    /// Rust programmers and learning resources tend to use single
+    /// character lifetimes, so this lint is at odds with the
+    /// ecosystem at large. In addition, the lifetime's purpose may
+    /// be obvious or, rarely, expressible in one character.
+    ///
+    /// ### Example
+    /// ```rust
+    /// struct DiagnosticCtx<'a> {
+    ///     source: &'a str,
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// struct DiagnosticCtx<'src> {
+    ///     source: &'src str,
+    /// }
+    /// ```
+    #[clippy::version = "1.59.0"]
+    pub SINGLE_CHAR_LIFETIME_NAMES,
+    restriction,
+    "warns against single-character lifetime names"
+}
+
+declare_lint_pass!(SingleCharLifetimeNames => [SINGLE_CHAR_LIFETIME_NAMES]);
+
+impl EarlyLintPass for SingleCharLifetimeNames {
+    fn check_generic_param(&mut self, ctx: &EarlyContext<'_>, param: &GenericParam) {
+        if in_external_macro(ctx.sess, param.ident.span) {
+            return;
+        }
+
+        if let GenericParamKind::Lifetime = param.kind {
+            if !param.is_placeholder && param.ident.as_str().len() <= 2 {
+                span_lint_and_help(
+                    ctx,
+                    SINGLE_CHAR_LIFETIME_NAMES,
+                    param.ident.span,
+                    "single-character lifetime names are likely uninformative",
+                    None,
+                    "use a more informative name",
+                );
+            }
+        }
+    }
+}
diff --git a/tests/ui/single_char_lifetime_names.rs b/tests/ui/single_char_lifetime_names.rs
new file mode 100644
index 00000000000..261d8bc7260
--- /dev/null
+++ b/tests/ui/single_char_lifetime_names.rs
@@ -0,0 +1,43 @@
+#![warn(clippy::single_char_lifetime_names)]
+
+// Lifetimes should only be linted when they're introduced
+struct DiagnosticCtx<'a, 'b>
+where
+    'a: 'b,
+{
+    _source: &'a str,
+    _unit: &'b (),
+}
+
+// Only the lifetimes on the `impl`'s generics should be linted
+impl<'a, 'b> DiagnosticCtx<'a, 'b> {
+    fn new(source: &'a str, unit: &'b ()) -> DiagnosticCtx<'a, 'b> {
+        Self {
+            _source: source,
+            _unit: unit,
+        }
+    }
+}
+
+// No lifetimes should be linted here
+impl<'src, 'unit> DiagnosticCtx<'src, 'unit> {
+    fn new_pass(source: &'src str, unit: &'unit ()) -> DiagnosticCtx<'src, 'unit> {
+        Self {
+            _source: source,
+            _unit: unit,
+        }
+    }
+}
+
+// Only 'a should be linted here
+fn split_once<'a>(base: &'a str, other: &'_ str) -> (&'a str, Option<&'a str>) {
+    base.split_once(other)
+        .map(|(left, right)| (left, Some(right)))
+        .unwrap_or((base, None))
+}
+
+fn main() {
+    let src = "loop {}";
+    let unit = ();
+    DiagnosticCtx::new(src, &unit);
+}
diff --git a/tests/ui/single_char_lifetime_names.stderr b/tests/ui/single_char_lifetime_names.stderr
new file mode 100644
index 00000000000..013b64f46a8
--- /dev/null
+++ b/tests/ui/single_char_lifetime_names.stderr
@@ -0,0 +1,43 @@
+error: single-character lifetime names are likely uninformative
+  --> $DIR/single_char_lifetime_names.rs:4:22
+   |
+LL | struct DiagnosticCtx<'a, 'b>
+   |                      ^^
+   |
+   = note: `-D clippy::single-char-lifetime-names` implied by `-D warnings`
+   = help: use a more informative name
+
+error: single-character lifetime names are likely uninformative
+  --> $DIR/single_char_lifetime_names.rs:4:26
+   |
+LL | struct DiagnosticCtx<'a, 'b>
+   |                          ^^
+   |
+   = help: use a more informative name
+
+error: single-character lifetime names are likely uninformative
+  --> $DIR/single_char_lifetime_names.rs:13:6
+   |
+LL | impl<'a, 'b> DiagnosticCtx<'a, 'b> {
+   |      ^^
+   |
+   = help: use a more informative name
+
+error: single-character lifetime names are likely uninformative
+  --> $DIR/single_char_lifetime_names.rs:13:10
+   |
+LL | impl<'a, 'b> DiagnosticCtx<'a, 'b> {
+   |          ^^
+   |
+   = help: use a more informative name
+
+error: single-character lifetime names are likely uninformative
+  --> $DIR/single_char_lifetime_names.rs:33:15
+   |
+LL | fn split_once<'a>(base: &'a str, other: &'_ str) -> (&'a str, Option<&'a str>) {
+   |               ^^
+   |
+   = help: use a more informative name
+
+error: aborting due to 5 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From e2ce4f9462c1d65b4dce084186c0e532c27fe5a3 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Sun, 9 Jan 2022 18:22:38 -0600
Subject: Combine internal features in clippy_lints

---
 .cargo/config.toml                                 |  2 +-
 .github/workflows/clippy.yml                       |  6 ++---
 .github/workflows/clippy_bors.yml                  |  6 ++---
 Cargo.toml                                         |  3 +--
 clippy_dev/src/update_lints.rs                     |  2 +-
 clippy_lints/Cargo.toml                            |  3 +--
 clippy_lints/src/lib.register_lints.rs             | 28 +++++++++++-----------
 clippy_lints/src/lib.rs                            | 13 ++++------
 clippy_lints/src/utils/conf.rs                     |  2 +-
 clippy_lints/src/utils/internal_lints.rs           |  2 +-
 .../src/utils/internal_lints/metadata_collector.rs |  3 +--
 clippy_lints/src/utils/mod.rs                      |  2 +-
 tests/compile-test.rs                              |  2 +-
 tests/dogfood.rs                                   | 10 ++++----
 14 files changed, 39 insertions(+), 45 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/.cargo/config.toml b/.cargo/config.toml
index c9ae0a961b6..f3dd9275a42 100644
--- a/.cargo/config.toml
+++ b/.cargo/config.toml
@@ -2,7 +2,7 @@
 uitest = "test --test compile-test"
 dev = "run --package clippy_dev --bin clippy_dev --manifest-path clippy_dev/Cargo.toml --"
 lintcheck = "run --package lintcheck --bin lintcheck --manifest-path lintcheck/Cargo.toml  -- "
-collect-metadata = "test --test dogfood --features metadata-collector-lint -- run_metadata_collection_lint --ignored"
+collect-metadata = "test --test dogfood --features internal -- run_metadata_collection_lint --ignored"
 
 [build]
 # -Zbinary-dep-depinfo allows us to track which rlib files to use for compiling UI tests
diff --git a/.github/workflows/clippy.yml b/.github/workflows/clippy.yml
index a14e530df4e..8b5e814b177 100644
--- a/.github/workflows/clippy.yml
+++ b/.github/workflows/clippy.yml
@@ -49,13 +49,13 @@ jobs:
         echo "LD_LIBRARY_PATH=${SYSROOT}/lib${LD_LIBRARY_PATH+:${LD_LIBRARY_PATH}}" >> $GITHUB_ENV
 
     - name: Build
-      run: cargo build --features deny-warnings,internal-lints,metadata-collector-lint
+      run: cargo build --features deny-warnings,internal
 
     - name: Test
-      run: cargo test --features deny-warnings,internal-lints,metadata-collector-lint
+      run: cargo test --features deny-warnings,internal
 
     - name: Test clippy_lints
-      run: cargo test --features deny-warnings,internal-lints,metadata-collector-lint
+      run: cargo test --features deny-warnings,internal
       working-directory: clippy_lints
 
     - name: Test clippy_utils
diff --git a/.github/workflows/clippy_bors.yml b/.github/workflows/clippy_bors.yml
index 06522606347..eb045ec30dc 100644
--- a/.github/workflows/clippy_bors.yml
+++ b/.github/workflows/clippy_bors.yml
@@ -112,13 +112,13 @@ jobs:
         echo "$SYSROOT/bin" >> $GITHUB_PATH
 
     - name: Build
-      run: cargo build --features deny-warnings,internal-lints,metadata-collector-lint
+      run: cargo build --features deny-warnings,internal
 
     - name: Test
-      run: cargo test --features deny-warnings,internal-lints,metadata-collector-lint
+      run: cargo test --features deny-warnings,internal
 
     - name: Test clippy_lints
-      run: cargo test --features deny-warnings,internal-lints,metadata-collector-lint
+      run: cargo test --features deny-warnings,internal
       working-directory: clippy_lints
 
     - name: Test clippy_utils
diff --git a/Cargo.toml b/Cargo.toml
index 79a7ec92071..cb49dd84c39 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -57,8 +57,7 @@ rustc_tools_util = { version = "0.2", path = "rustc_tools_util" }
 [features]
 deny-warnings = ["clippy_lints/deny-warnings"]
 integration = ["tempfile"]
-internal-lints = ["clippy_lints/internal-lints"]
-metadata-collector-lint = ["internal-lints", "clippy_lints/metadata-collector-lint"]
+internal = ["clippy_lints/internal"]
 
 [package.metadata.rust-analyzer]
 # This package uses #[feature(rustc_private)]
diff --git a/clippy_dev/src/update_lints.rs b/clippy_dev/src/update_lints.rs
index 8dd073ef405..d368ef1f46a 100644
--- a/clippy_dev/src/update_lints.rs
+++ b/clippy_dev/src/update_lints.rs
@@ -321,7 +321,7 @@ fn gen_register_lint_list<'a>(
 
     for (is_public, module_name, lint_name) in details {
         if !is_public {
-            output.push_str("    #[cfg(feature = \"internal-lints\")]\n");
+            output.push_str("    #[cfg(feature = \"internal\")]\n");
         }
         output.push_str(&format!("    {}::{},\n", module_name, lint_name));
     }
diff --git a/clippy_lints/Cargo.toml b/clippy_lints/Cargo.toml
index 639138ac9c5..e9f87b60ece 100644
--- a/clippy_lints/Cargo.toml
+++ b/clippy_lints/Cargo.toml
@@ -30,8 +30,7 @@ url = { version = "2.2", features = ["serde"] }
 [features]
 deny-warnings = ["clippy_utils/deny-warnings"]
 # build clippy with internal lints enabled, off by default
-internal-lints = ["clippy_utils/internal"]
-metadata-collector-lint = ["serde_json", "clippy_utils/internal"]
+internal = ["clippy_utils/internal", "serde_json"]
 
 [package.metadata.rust-analyzer]
 # This crate uses #[feature(rustc_private)]
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index f9241d943b2..832178c2db5 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -3,33 +3,33 @@
 // Manual edits will be overwritten.
 
 store.register_lints(&[
-    #[cfg(feature = "internal-lints")]
+    #[cfg(feature = "internal")]
     utils::internal_lints::CLIPPY_LINTS_INTERNAL,
-    #[cfg(feature = "internal-lints")]
+    #[cfg(feature = "internal")]
     utils::internal_lints::COLLAPSIBLE_SPAN_LINT_CALLS,
-    #[cfg(feature = "internal-lints")]
+    #[cfg(feature = "internal")]
     utils::internal_lints::COMPILER_LINT_FUNCTIONS,
-    #[cfg(feature = "internal-lints")]
+    #[cfg(feature = "internal")]
     utils::internal_lints::DEFAULT_LINT,
-    #[cfg(feature = "internal-lints")]
+    #[cfg(feature = "internal")]
     utils::internal_lints::IF_CHAIN_STYLE,
-    #[cfg(feature = "internal-lints")]
+    #[cfg(feature = "internal")]
     utils::internal_lints::INTERNING_DEFINED_SYMBOL,
-    #[cfg(feature = "internal-lints")]
+    #[cfg(feature = "internal")]
     utils::internal_lints::INVALID_CLIPPY_VERSION_ATTRIBUTE,
-    #[cfg(feature = "internal-lints")]
+    #[cfg(feature = "internal")]
     utils::internal_lints::INVALID_PATHS,
-    #[cfg(feature = "internal-lints")]
+    #[cfg(feature = "internal")]
     utils::internal_lints::LINT_WITHOUT_LINT_PASS,
-    #[cfg(feature = "internal-lints")]
+    #[cfg(feature = "internal")]
     utils::internal_lints::MATCH_TYPE_ON_DIAGNOSTIC_ITEM,
-    #[cfg(feature = "internal-lints")]
+    #[cfg(feature = "internal")]
     utils::internal_lints::MISSING_CLIPPY_VERSION_ATTRIBUTE,
-    #[cfg(feature = "internal-lints")]
+    #[cfg(feature = "internal")]
     utils::internal_lints::OUTER_EXPN_EXPN_DATA,
-    #[cfg(feature = "internal-lints")]
+    #[cfg(feature = "internal")]
     utils::internal_lints::PRODUCE_ICE,
-    #[cfg(feature = "internal-lints")]
+    #[cfg(feature = "internal")]
     utils::internal_lints::UNNECESSARY_SYMBOL_STR,
     absurd_extreme_comparisons::ABSURD_EXTREME_COMPARISONS,
     approx_const::APPROX_CONSTANT,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index c31acb5f4ef..0d765c2bcde 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -153,12 +153,9 @@ macro_rules! declare_clippy_lint {
     };
 }
 
-#[cfg(feature = "metadata-collector-lint")]
+#[cfg(feature = "internal")]
 mod deprecated_lints;
-#[cfg_attr(
-    any(feature = "internal-lints", feature = "metadata-collector-lint"),
-    allow(clippy::missing_clippy_version_attribute)
-)]
+#[cfg_attr(feature = "internal", allow(clippy::missing_clippy_version_attribute))]
 mod utils;
 
 // begin lints modules, do not remove this comment, it’s used in `update_lints`
@@ -472,7 +469,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     include!("lib.register_restriction.rs");
     include!("lib.register_pedantic.rs");
 
-    #[cfg(feature = "internal-lints")]
+    #[cfg(feature = "internal")]
     include!("lib.register_internal.rs");
 
     include!("lib.register_all.rs");
@@ -484,7 +481,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     include!("lib.register_cargo.rs");
     include!("lib.register_nursery.rs");
 
-    #[cfg(feature = "metadata-collector-lint")]
+    #[cfg(feature = "internal")]
     {
         if std::env::var("ENABLE_METADATA_COLLECTION").eq(&Ok("1".to_string())) {
             store.register_late_pass(|| Box::new(utils::internal_lints::metadata_collector::MetadataCollector::new()));
@@ -493,7 +490,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     }
 
     // all the internal lints
-    #[cfg(feature = "internal-lints")]
+    #[cfg(feature = "internal")]
     {
         store.register_early_pass(|| Box::new(utils::internal_lints::ClippyLintsInternal));
         store.register_early_pass(|| Box::new(utils::internal_lints::ProduceIce));
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 9c83d30eb9c..4e1c538c1c2 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -113,7 +113,7 @@ macro_rules! define_Conf {
             }
         }
 
-        #[cfg(feature = "metadata-collector-lint")]
+        #[cfg(feature = "internal")]
         pub mod metadata {
             use crate::utils::internal_lints::metadata_collector::ClippyConfiguration;
 
diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs
index 165004e5b41..67faca70d5c 100644
--- a/clippy_lints/src/utils/internal_lints.rs
+++ b/clippy_lints/src/utils/internal_lints.rs
@@ -35,7 +35,7 @@ use rustc_typeck::hir_ty_to_ty;
 
 use std::borrow::{Borrow, Cow};
 
-#[cfg(feature = "metadata-collector-lint")]
+#[cfg(feature = "internal")]
 pub mod metadata_collector;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index 7707eebd622..02f5d45cc18 100644
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -1,8 +1,7 @@
 //! This lint is used to collect metadata about clippy lints. This metadata is exported as a json
 //! file and then used to generate the [clippy lint list](https://rust-lang.github.io/rust-clippy/master/index.html)
 //!
-//! This module and therefor the entire lint is guarded by a feature flag called
-//! `metadata-collector-lint`
+//! This module and therefore the entire lint is guarded by a feature flag called `internal`
 //!
 //! The module transforms all lint names to ascii lowercase to ensure that we don't have mismatches
 //! during any comparison or mapping. (Please take care of this, it's not fun to spend time on such
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index b67448e3a57..dc385ebacba 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -1,5 +1,5 @@
 pub mod author;
 pub mod conf;
 pub mod inspector;
-#[cfg(any(feature = "internal-lints", feature = "metadata-collector-lint"))]
+#[cfg(feature = "internal")]
 pub mod internal_lints;
diff --git a/tests/compile-test.rs b/tests/compile-test.rs
index d602d2042ee..762b67fc585 100644
--- a/tests/compile-test.rs
+++ b/tests/compile-test.rs
@@ -15,7 +15,7 @@ use std::path::{Path, PathBuf};
 mod cargo;
 
 // whether to run internal tests or not
-const RUN_INTERNAL_TESTS: bool = cfg!(feature = "internal-lints");
+const RUN_INTERNAL_TESTS: bool = cfg!(feature = "internal");
 
 /// All crates used in UI tests are listed here
 static TEST_DEPENDENCIES: &[&str] = &[
diff --git a/tests/dogfood.rs b/tests/dogfood.rs
index a37cdfed126..6f7de9c67a9 100644
--- a/tests/dogfood.rs
+++ b/tests/dogfood.rs
@@ -42,8 +42,8 @@ fn dogfood_clippy() {
         .args(&["-D", "clippy::pedantic"])
         .arg("-Cdebuginfo=0"); // disable debuginfo to generate less data in the target dir
 
-    // internal lints only exist if we build with the internal-lints feature
-    if cfg!(feature = "internal-lints") {
+    // internal lints only exist if we build with the internal feature
+    if cfg!(feature = "internal") {
         command.args(&["-D", "clippy::internal"]);
     }
 
@@ -180,7 +180,7 @@ fn dogfood_subprojects() {
 
 #[test]
 #[ignore]
-#[cfg(feature = "metadata-collector-lint")]
+#[cfg(feature = "internal")]
 fn run_metadata_collection_lint() {
     use std::fs::File;
     use std::time::SystemTime;
@@ -233,8 +233,8 @@ fn run_clippy_for_project(project: &str) {
         .args(&["-D", "clippy::pedantic"])
         .arg("-Cdebuginfo=0"); // disable debuginfo to generate less data in the target dir
 
-    // internal lints only exist if we build with the internal-lints feature
-    if cfg!(feature = "internal-lints") {
+    // internal lints only exist if we build with the internal feature
+    if cfg!(feature = "internal") {
         command.args(&["-D", "clippy::internal"]);
     }
 
-- 
cgit 1.4.1-3-g733a5


From f4dc348ad580cb5958f724a1a5ac7b538ef35515 Mon Sep 17 00:00:00 2001
From: dswij <dswijj@gmail.com>
Date: Mon, 10 Jan 2022 12:45:01 +0800
Subject: `trait_duplication_in_bounds` Update description and add test

---
 clippy_lints/src/trait_bounds.rs            | 29 ++++++++++++++++-------------
 tests/ui/trait_duplication_in_bounds.rs     |  8 ++++++++
 tests/ui/trait_duplication_in_bounds.stderr | 24 ++++++++++++++++--------
 3 files changed, 40 insertions(+), 21 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/trait_bounds.rs b/clippy_lints/src/trait_bounds.rs
index c91b24462c0..6369aafe3f9 100644
--- a/clippy_lints/src/trait_bounds.rs
+++ b/clippy_lints/src/trait_bounds.rs
@@ -121,7 +121,14 @@ impl<'tcx> LateLintPass<'tcx> for TraitBounds {
                         .filter_map(get_trait_res_span_from_bound)
                         .for_each(|(trait_item_res, span)| {
                             if self_bounds_set.get(&trait_item_res).is_some() {
-                                emit_lint(cx, span);
+                                span_lint_and_help(
+                                    cx,
+                                    TRAIT_DUPLICATION_IN_BOUNDS,
+                                    span,
+                                    "this trait bound is already specified in trait declaration",
+                                    None,
+                                    "consider removing this trait bound",
+                                );
                             }
                         });
                 }
@@ -242,21 +249,17 @@ fn check_trait_bound_duplication(cx: &LateContext<'_>, gen: &'_ Generics<'_>) {
                     if let Some((_, span_direct)) = trait_resolutions_direct
                                                 .iter()
                                                 .find(|(res_direct, _)| *res_direct == res_where) {
-                        emit_lint(cx, *span_direct);
+                        span_lint_and_help(
+                            cx,
+                            TRAIT_DUPLICATION_IN_BOUNDS,
+                            *span_direct,
+                            "this trait bound is already specified in the where clause",
+                            None,
+                            "consider removing this trait bound",
+                        );
                     }
                 }
             }
         }
     }
 }
-
-fn emit_lint(cx: &LateContext<'_>, span: Span) {
-    span_lint_and_help(
-        cx,
-        TRAIT_DUPLICATION_IN_BOUNDS,
-        span,
-        "this trait bound is already specified in the where clause",
-        None,
-        "consider removing this trait bound",
-    );
-}
diff --git a/tests/ui/trait_duplication_in_bounds.rs b/tests/ui/trait_duplication_in_bounds.rs
index 3e490126273..2edb202892a 100644
--- a/tests/ui/trait_duplication_in_bounds.rs
+++ b/tests/ui/trait_duplication_in_bounds.rs
@@ -41,6 +41,8 @@ trait U: Default {
 }
 
 trait ZZ: Default {
+    fn g();
+    fn h();
     fn f()
     where
         Self: Default + Clone;
@@ -50,6 +52,12 @@ trait BadTrait: Default + Clone {
     fn f()
     where
         Self: Default + Clone;
+    fn g()
+    where
+        Self: Default;
+    fn h()
+    where
+        Self: Copy;
 }
 
 #[derive(Default, Clone)]
diff --git a/tests/ui/trait_duplication_in_bounds.stderr b/tests/ui/trait_duplication_in_bounds.stderr
index 6326139c187..e0c7a7ec618 100644
--- a/tests/ui/trait_duplication_in_bounds.stderr
+++ b/tests/ui/trait_duplication_in_bounds.stderr
@@ -19,7 +19,7 @@ LL | fn bad_foo<T: Clone + Default, Z: Copy>(arg0: T, arg1: Z)
    |
    = help: consider removing this trait bound
 
-error: this trait bound is already specified in the where clause
+error: this trait bound is already specified in trait declaration
   --> $DIR/trait_duplication_in_bounds.rs:34:15
    |
 LL |         Self: Default;
@@ -27,29 +27,37 @@ LL |         Self: Default;
    |
    = help: consider removing this trait bound
 
-error: this trait bound is already specified in the where clause
-  --> $DIR/trait_duplication_in_bounds.rs:46:15
+error: this trait bound is already specified in trait declaration
+  --> $DIR/trait_duplication_in_bounds.rs:48:15
    |
 LL |         Self: Default + Clone;
    |               ^^^^^^^
    |
    = help: consider removing this trait bound
 
-error: this trait bound is already specified in the where clause
-  --> $DIR/trait_duplication_in_bounds.rs:52:15
+error: this trait bound is already specified in trait declaration
+  --> $DIR/trait_duplication_in_bounds.rs:54:15
    |
 LL |         Self: Default + Clone;
    |               ^^^^^^^
    |
    = help: consider removing this trait bound
 
-error: this trait bound is already specified in the where clause
-  --> $DIR/trait_duplication_in_bounds.rs:52:25
+error: this trait bound is already specified in trait declaration
+  --> $DIR/trait_duplication_in_bounds.rs:54:25
    |
 LL |         Self: Default + Clone;
    |                         ^^^^^
    |
    = help: consider removing this trait bound
 
-error: aborting due to 6 previous errors
+error: this trait bound is already specified in trait declaration
+  --> $DIR/trait_duplication_in_bounds.rs:57:15
+   |
+LL |         Self: Default;
+   |               ^^^^^^^
+   |
+   = help: consider removing this trait bound
+
+error: aborting due to 7 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From cf86cee4fe68a8bc6919eaba6689f6c31cfa1b5f Mon Sep 17 00:00:00 2001
From: Taiki Endo <te316e89@gmail.com>
Date: Mon, 10 Jan 2022 23:36:13 +0900
Subject: Downgrade mutex_atomic to nursery

---
 clippy_lints/src/lib.register_all.rs     |  1 -
 clippy_lints/src/lib.register_nursery.rs |  1 +
 clippy_lints/src/lib.register_perf.rs    |  1 -
 clippy_lints/src/mutex_atomic.rs         |  2 +-
 tests/ui/mutex_atomic.rs                 |  1 +
 tests/ui/mutex_atomic.stderr             | 14 +++++++-------
 6 files changed, 10 insertions(+), 10 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 944411087e9..47b85caa580 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -204,7 +204,6 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(mut_key::MUTABLE_KEY_TYPE),
     LintId::of(mut_mutex_lock::MUT_MUTEX_LOCK),
     LintId::of(mut_reference::UNNECESSARY_MUT_PASSED),
-    LintId::of(mutex_atomic::MUTEX_ATOMIC),
     LintId::of(needless_arbitrary_self_type::NEEDLESS_ARBITRARY_SELF_TYPE),
     LintId::of(needless_bool::BOOL_COMPARISON),
     LintId::of(needless_bool::NEEDLESS_BOOL),
diff --git a/clippy_lints/src/lib.register_nursery.rs b/clippy_lints/src/lib.register_nursery.rs
index e3cf0670018..d21d9506ede 100644
--- a/clippy_lints/src/lib.register_nursery.rs
+++ b/clippy_lints/src/lib.register_nursery.rs
@@ -17,6 +17,7 @@ store.register_group(true, "clippy::nursery", Some("clippy_nursery"), vec![
     LintId::of(let_if_seq::USELESS_LET_IF_SEQ),
     LintId::of(missing_const_for_fn::MISSING_CONST_FOR_FN),
     LintId::of(mutable_debug_assertion::DEBUG_ASSERT_WITH_MUT_CALL),
+    LintId::of(mutex_atomic::MUTEX_ATOMIC),
     LintId::of(mutex_atomic::MUTEX_INTEGER),
     LintId::of(non_send_fields_in_send_ty::NON_SEND_FIELDS_IN_SEND_TY),
     LintId::of(nonstandard_macro_braces::NONSTANDARD_MACRO_BRACES),
diff --git a/clippy_lints/src/lib.register_perf.rs b/clippy_lints/src/lib.register_perf.rs
index 2ea0b696f1f..f9ffd4cf829 100644
--- a/clippy_lints/src/lib.register_perf.rs
+++ b/clippy_lints/src/lib.register_perf.rs
@@ -19,7 +19,6 @@ store.register_group(true, "clippy::perf", Some("clippy_perf"), vec![
     LintId::of(methods::SINGLE_CHAR_PATTERN),
     LintId::of(methods::UNNECESSARY_TO_OWNED),
     LintId::of(misc::CMP_OWNED),
-    LintId::of(mutex_atomic::MUTEX_ATOMIC),
     LintId::of(redundant_clone::REDUNDANT_CLONE),
     LintId::of(slow_vector_initialization::SLOW_VECTOR_INITIALIZATION),
     LintId::of(stable_sort_primitive::STABLE_SORT_PRIMITIVE),
diff --git a/clippy_lints/src/mutex_atomic.rs b/clippy_lints/src/mutex_atomic.rs
index 816377fe65e..73823779e49 100644
--- a/clippy_lints/src/mutex_atomic.rs
+++ b/clippy_lints/src/mutex_atomic.rs
@@ -38,7 +38,7 @@ declare_clippy_lint! {
     /// ```
     #[clippy::version = "pre 1.29.0"]
     pub MUTEX_ATOMIC,
-    perf,
+    nursery,
     "using a mutex where an atomic value could be used instead"
 }
 
diff --git a/tests/ui/mutex_atomic.rs b/tests/ui/mutex_atomic.rs
index b9d78b7f479..71063d9ce46 100644
--- a/tests/ui/mutex_atomic.rs
+++ b/tests/ui/mutex_atomic.rs
@@ -1,5 +1,6 @@
 #![warn(clippy::all)]
 #![warn(clippy::mutex_integer)]
+#![warn(clippy::mutex_atomic)]
 
 fn main() {
     use std::sync::Mutex;
diff --git a/tests/ui/mutex_atomic.stderr b/tests/ui/mutex_atomic.stderr
index a3511ba708a..ef7ad9b7576 100644
--- a/tests/ui/mutex_atomic.stderr
+++ b/tests/ui/mutex_atomic.stderr
@@ -1,5 +1,5 @@
 error: consider using an `AtomicBool` instead of a `Mutex` here; if you just want the locking behavior and not the internal type, consider using `Mutex<()>`
-  --> $DIR/mutex_atomic.rs:6:5
+  --> $DIR/mutex_atomic.rs:7:5
    |
 LL |     Mutex::new(true);
    |     ^^^^^^^^^^^^^^^^
@@ -7,31 +7,31 @@ LL |     Mutex::new(true);
    = note: `-D clippy::mutex-atomic` implied by `-D warnings`
 
 error: consider using an `AtomicUsize` instead of a `Mutex` here; if you just want the locking behavior and not the internal type, consider using `Mutex<()>`
-  --> $DIR/mutex_atomic.rs:7:5
+  --> $DIR/mutex_atomic.rs:8:5
    |
 LL |     Mutex::new(5usize);
    |     ^^^^^^^^^^^^^^^^^^
 
 error: consider using an `AtomicIsize` instead of a `Mutex` here; if you just want the locking behavior and not the internal type, consider using `Mutex<()>`
-  --> $DIR/mutex_atomic.rs:8:5
+  --> $DIR/mutex_atomic.rs:9:5
    |
 LL |     Mutex::new(9isize);
    |     ^^^^^^^^^^^^^^^^^^
 
 error: consider using an `AtomicPtr` instead of a `Mutex` here; if you just want the locking behavior and not the internal type, consider using `Mutex<()>`
-  --> $DIR/mutex_atomic.rs:10:5
+  --> $DIR/mutex_atomic.rs:11:5
    |
 LL |     Mutex::new(&x as *const u32);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: consider using an `AtomicPtr` instead of a `Mutex` here; if you just want the locking behavior and not the internal type, consider using `Mutex<()>`
-  --> $DIR/mutex_atomic.rs:11:5
+  --> $DIR/mutex_atomic.rs:12:5
    |
 LL |     Mutex::new(&mut x as *mut u32);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: consider using an `AtomicUsize` instead of a `Mutex` here; if you just want the locking behavior and not the internal type, consider using `Mutex<()>`
-  --> $DIR/mutex_atomic.rs:12:5
+  --> $DIR/mutex_atomic.rs:13:5
    |
 LL |     Mutex::new(0u32);
    |     ^^^^^^^^^^^^^^^^
@@ -39,7 +39,7 @@ LL |     Mutex::new(0u32);
    = note: `-D clippy::mutex-integer` implied by `-D warnings`
 
 error: consider using an `AtomicIsize` instead of a `Mutex` here; if you just want the locking behavior and not the internal type, consider using `Mutex<()>`
-  --> $DIR/mutex_atomic.rs:13:5
+  --> $DIR/mutex_atomic.rs:14:5
    |
 LL |     Mutex::new(0i32);
    |     ^^^^^^^^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From 5f143c603eb643e1da9ccab60d53d10cdc7e0e06 Mon Sep 17 00:00:00 2001
From: Taiki Endo <te316e89@gmail.com>
Date: Tue, 11 Jan 2022 02:17:14 +0900
Subject: Warn disallowed_methods and disallowed_types by default

---
 clippy_lints/src/disallowed_methods.rs   | 5 ++++-
 clippy_lints/src/disallowed_types.rs     | 5 ++++-
 clippy_lints/src/lib.register_all.rs     | 2 ++
 clippy_lints/src/lib.register_nursery.rs | 2 --
 clippy_lints/src/lib.register_style.rs   | 2 ++
 5 files changed, 12 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/disallowed_methods.rs b/clippy_lints/src/disallowed_methods.rs
index 6d4065907fb..6d5b1efe270 100644
--- a/clippy_lints/src/disallowed_methods.rs
+++ b/clippy_lints/src/disallowed_methods.rs
@@ -11,6 +11,9 @@ declare_clippy_lint! {
     /// ### What it does
     /// Denies the configured methods and functions in clippy.toml
     ///
+    /// Note: Even though this lint is warn-by-default, it will only trigger if
+    /// methods are defined in the clippy.toml file.
+    ///
     /// ### Why is this bad?
     /// Some methods are undesirable in certain contexts, and it's beneficial to
     /// lint for them as needed.
@@ -49,7 +52,7 @@ declare_clippy_lint! {
     /// ```
     #[clippy::version = "1.49.0"]
     pub DISALLOWED_METHODS,
-    nursery,
+    style,
     "use of a disallowed method call"
 }
 
diff --git a/clippy_lints/src/disallowed_types.rs b/clippy_lints/src/disallowed_types.rs
index eaed4032713..ea4b49b46fe 100644
--- a/clippy_lints/src/disallowed_types.rs
+++ b/clippy_lints/src/disallowed_types.rs
@@ -14,6 +14,9 @@ declare_clippy_lint! {
     /// ### What it does
     /// Denies the configured types in clippy.toml.
     ///
+    /// Note: Even though this lint is warn-by-default, it will only trigger if
+    /// types are defined in the clippy.toml file.
+    ///
     /// ### Why is this bad?
     /// Some types are undesirable in certain contexts.
     ///
@@ -44,7 +47,7 @@ declare_clippy_lint! {
     /// ```
     #[clippy::version = "1.55.0"]
     pub DISALLOWED_TYPES,
-    nursery,
+    style,
     "use of disallowed types"
 }
 #[derive(Clone, Debug)]
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 944411087e9..5c7835db1aa 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -37,6 +37,8 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(derivable_impls::DERIVABLE_IMPLS),
     LintId::of(derive::DERIVE_HASH_XOR_EQ),
     LintId::of(derive::DERIVE_ORD_XOR_PARTIAL_ORD),
+    LintId::of(disallowed_methods::DISALLOWED_METHODS),
+    LintId::of(disallowed_types::DISALLOWED_TYPES),
     LintId::of(doc::MISSING_SAFETY_DOC),
     LintId::of(doc::NEEDLESS_DOCTEST_MAIN),
     LintId::of(double_comparison::DOUBLE_COMPARISONS),
diff --git a/clippy_lints/src/lib.register_nursery.rs b/clippy_lints/src/lib.register_nursery.rs
index e3cf0670018..4d4317cc984 100644
--- a/clippy_lints/src/lib.register_nursery.rs
+++ b/clippy_lints/src/lib.register_nursery.rs
@@ -6,8 +6,6 @@ store.register_group(true, "clippy::nursery", Some("clippy_nursery"), vec![
     LintId::of(attrs::EMPTY_LINE_AFTER_OUTER_ATTR),
     LintId::of(cognitive_complexity::COGNITIVE_COMPLEXITY),
     LintId::of(copies::BRANCHES_SHARING_CODE),
-    LintId::of(disallowed_methods::DISALLOWED_METHODS),
-    LintId::of(disallowed_types::DISALLOWED_TYPES),
     LintId::of(equatable_if_let::EQUATABLE_IF_LET),
     LintId::of(fallible_impl_from::FALLIBLE_IMPL_FROM),
     LintId::of(floating_point_arithmetic::IMPRECISE_FLOPS),
diff --git a/clippy_lints/src/lib.register_style.rs b/clippy_lints/src/lib.register_style.rs
index 1a0b869d40a..57de34f41ac 100644
--- a/clippy_lints/src/lib.register_style.rs
+++ b/clippy_lints/src/lib.register_style.rs
@@ -16,6 +16,8 @@ store.register_group(true, "clippy::style", Some("clippy_style"), vec![
     LintId::of(comparison_chain::COMPARISON_CHAIN),
     LintId::of(default::FIELD_REASSIGN_WITH_DEFAULT),
     LintId::of(dereference::NEEDLESS_BORROW),
+    LintId::of(disallowed_methods::DISALLOWED_METHODS),
+    LintId::of(disallowed_types::DISALLOWED_TYPES),
     LintId::of(doc::MISSING_SAFETY_DOC),
     LintId::of(doc::NEEDLESS_DOCTEST_MAIN),
     LintId::of(enum_variants::ENUM_VARIANT_NAMES),
-- 
cgit 1.4.1-3-g733a5


From 3298de7f661b1f91dec5faef8eb6d36a6b30ffa0 Mon Sep 17 00:00:00 2001
From: Federico Guerinoni <guerinoni.federico@gmail.com>
Date: Sun, 2 Jan 2022 14:26:44 +0100
Subject: Add borrow_as_ptr lint

Closes: #6995

Signed-off-by: Federico Guerinoni <guerinoni.federico@gmail.com>
Co-authored-by: Paolo Barbolini <paolo@paolo565.org>
---
 CHANGELOG.md                                       |  1 +
 README.md                                          |  2 +-
 clippy_lints/src/borrow_as_ptr.rs                  | 97 ++++++++++++++++++++++
 clippy_lints/src/lib.register_lints.rs             |  1 +
 clippy_lints/src/lib.register_pedantic.rs          |  1 +
 clippy_lints/src/lib.rs                            |  2 +
 clippy_utils/src/msrvs.rs                          |  1 +
 tests/ui/as_conversions.rs                         |  1 +
 tests/ui/as_conversions.stderr                     |  6 +-
 tests/ui/borrow_as_ptr.fixed                       | 10 +++
 tests/ui/borrow_as_ptr.rs                          | 10 +++
 tests/ui/borrow_as_ptr.stderr                      | 16 ++++
 tests/ui/borrow_as_ptr_no_std.fixed                | 22 +++++
 tests/ui/borrow_as_ptr_no_std.rs                   | 22 +++++
 tests/ui/borrow_as_ptr_no_std.stderr               | 16 ++++
 tests/ui/cast_alignment.rs                         |  8 +-
 tests/ui/cast_alignment.stderr                     |  8 +-
 tests/ui/cast_ref_to_mut.rs                        |  2 +-
 tests/ui/mutex_atomic.rs                           |  1 +
 tests/ui/mutex_atomic.stderr                       | 14 ++--
 tests/ui/or_fun_call.fixed                         |  2 +-
 tests/ui/or_fun_call.rs                            |  2 +-
 tests/ui/transmute.rs                              |  2 +-
 tests/ui/transmute_ptr_to_ptr.rs                   |  1 +
 tests/ui/transmute_ptr_to_ptr.stderr               | 12 +--
 tests/ui/transmutes_expressible_as_ptr_casts.fixed |  3 +-
 tests/ui/transmutes_expressible_as_ptr_casts.rs    |  3 +-
 .../ui/transmutes_expressible_as_ptr_casts.stderr  | 16 ++--
 tests/ui/unnecessary_cast_fixable.fixed            |  7 +-
 tests/ui/unnecessary_cast_fixable.rs               |  7 +-
 tests/ui/unnecessary_cast_fixable.stderr           | 34 ++++----
 tests/ui/vtable_address_comparisons.rs             |  2 +
 tests/ui/vtable_address_comparisons.stderr         | 20 ++---
 tests/ui/zero_offset.rs                            |  1 +
 tests/ui/zero_offset.stderr                        | 16 ++--
 35 files changed, 294 insertions(+), 75 deletions(-)
 create mode 100644 clippy_lints/src/borrow_as_ptr.rs
 create mode 100644 tests/ui/borrow_as_ptr.fixed
 create mode 100644 tests/ui/borrow_as_ptr.rs
 create mode 100644 tests/ui/borrow_as_ptr.stderr
 create mode 100644 tests/ui/borrow_as_ptr_no_std.fixed
 create mode 100644 tests/ui/borrow_as_ptr_no_std.rs
 create mode 100644 tests/ui/borrow_as_ptr_no_std.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 83fd8396bc7..e521995a188 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2887,6 +2887,7 @@ Released 2018-09-13
 [`blocks_in_if_conditions`]: https://rust-lang.github.io/rust-clippy/master/index.html#blocks_in_if_conditions
 [`bool_assert_comparison`]: https://rust-lang.github.io/rust-clippy/master/index.html#bool_assert_comparison
 [`bool_comparison`]: https://rust-lang.github.io/rust-clippy/master/index.html#bool_comparison
+[`borrow_as_ptr`]: https://rust-lang.github.io/rust-clippy/master/index.html#borrow_as_ptr
 [`borrow_interior_mutable_const`]: https://rust-lang.github.io/rust-clippy/master/index.html#borrow_interior_mutable_const
 [`borrowed_box`]: https://rust-lang.github.io/rust-clippy/master/index.html#borrowed_box
 [`box_collection`]: https://rust-lang.github.io/rust-clippy/master/index.html#box_collection
diff --git a/README.md b/README.md
index 1bbd89e7822..de72e8d124d 100644
--- a/README.md
+++ b/README.md
@@ -5,7 +5,7 @@
 
 A collection of lints to catch common mistakes and improve your [Rust](https://github.com/rust-lang/rust) code.
 
-[There are over 450 lints included in this crate!](https://rust-lang.github.io/rust-clippy/master/index.html)
+[There are over 500 lints included in this crate!](https://rust-lang.github.io/rust-clippy/master/index.html)
 
 Lints are divided into categories, each with a default [lint level](https://doc.rust-lang.org/rustc/lints/levels.html).
 You can choose how much Clippy is supposed to ~~annoy~~ help you by changing the lint level by category.
diff --git a/clippy_lints/src/borrow_as_ptr.rs b/clippy_lints/src/borrow_as_ptr.rs
new file mode 100644
index 00000000000..b8f5217af2b
--- /dev/null
+++ b/clippy_lints/src/borrow_as_ptr.rs
@@ -0,0 +1,97 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::is_no_std_crate;
+use clippy_utils::source::snippet_opt;
+use clippy_utils::{meets_msrv, msrvs};
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir::{BorrowKind, Expr, ExprKind, Mutability, TyKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_semver::RustcVersion;
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for the usage of `&expr as *const T` or
+    /// `&mut expr as *mut T`, and suggest using `ptr::addr_of` or
+    /// `ptr::addr_of_mut` instead.
+    ///
+    /// ### Why is this bad?
+    /// This would improve readability and avoid creating a reference
+    /// that points to an uninitialized value or unaligned place.
+    /// Read the `ptr::addr_of` docs for more information.
+    ///
+    /// ### Example
+    /// ```rust
+    /// let val = 1;
+    /// let p = &val as *const i32;
+    ///
+    /// let mut val_mut = 1;
+    /// let p_mut = &mut val_mut as *mut i32;
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// let val = 1;
+    /// let p = std::ptr::addr_of!(val);
+    ///
+    /// let mut val_mut = 1;
+    /// let p_mut = std::ptr::addr_of_mut!(val_mut);
+    /// ```
+    #[clippy::version = "1.60.0"]
+    pub BORROW_AS_PTR,
+    pedantic,
+    "borrowing just to cast to a raw pointer"
+}
+
+impl_lint_pass!(BorrowAsPtr => [BORROW_AS_PTR]);
+
+pub struct BorrowAsPtr {
+    msrv: Option<RustcVersion>,
+}
+
+impl BorrowAsPtr {
+    #[must_use]
+    pub fn new(msrv: Option<RustcVersion>) -> Self {
+        Self { msrv }
+    }
+}
+
+impl<'tcx> LateLintPass<'tcx> for BorrowAsPtr {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        if !meets_msrv(self.msrv.as_ref(), &msrvs::BORROW_AS_PTR) {
+            return;
+        }
+
+        if expr.span.from_expansion() {
+            return;
+        }
+
+        if_chain! {
+            if let ExprKind::Cast(left_expr, ty) = &expr.kind;
+            if let TyKind::Ptr(_) = ty.kind;
+            if let ExprKind::AddrOf(BorrowKind::Ref, mutability, e) = &left_expr.kind;
+
+            then {
+                let core_or_std = if is_no_std_crate(cx) { "core" } else { "std" };
+                let macro_name = match mutability {
+                    Mutability::Not => "addr_of",
+                    Mutability::Mut => "addr_of_mut",
+                };
+
+                span_lint_and_sugg(
+                    cx,
+                    BORROW_AS_PTR,
+                    expr.span,
+                    "borrow as raw pointer",
+                    "try",
+                    format!(
+                        "{}::ptr::{}!({})",
+                        core_or_std,
+                        macro_name,
+                        snippet_opt(cx, e.span).unwrap()
+                    ),
+                    Applicability::MachineApplicable,
+                );
+            }
+        }
+    }
+}
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 832178c2db5..09e4f6ae275 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -59,6 +59,7 @@ store.register_lints(&[
     bool_assert_comparison::BOOL_ASSERT_COMPARISON,
     booleans::LOGIC_BUG,
     booleans::NONMINIMAL_BOOL,
+    borrow_as_ptr::BORROW_AS_PTR,
     bytecount::NAIVE_BYTECOUNT,
     cargo_common_metadata::CARGO_COMMON_METADATA,
     case_sensitive_file_extension_comparisons::CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS,
diff --git a/clippy_lints/src/lib.register_pedantic.rs b/clippy_lints/src/lib.register_pedantic.rs
index 70a4a624378..1744b7c8250 100644
--- a/clippy_lints/src/lib.register_pedantic.rs
+++ b/clippy_lints/src/lib.register_pedantic.rs
@@ -7,6 +7,7 @@ store.register_group(true, "clippy::pedantic", Some("clippy_pedantic"), vec![
     LintId::of(await_holding_invalid::AWAIT_HOLDING_LOCK),
     LintId::of(await_holding_invalid::AWAIT_HOLDING_REFCELL_REF),
     LintId::of(bit_mask::VERBOSE_BIT_MASK),
+    LintId::of(borrow_as_ptr::BORROW_AS_PTR),
     LintId::of(bytecount::NAIVE_BYTECOUNT),
     LintId::of(case_sensitive_file_extension_comparisons::CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS),
     LintId::of(casts::CAST_LOSSLESS),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 0d765c2bcde..732df4d2b8b 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -174,6 +174,7 @@ mod blacklisted_name;
 mod blocks_in_if_conditions;
 mod bool_assert_comparison;
 mod booleans;
+mod borrow_as_ptr;
 mod bytecount;
 mod cargo_common_metadata;
 mod case_sensitive_file_extension_comparisons;
@@ -857,6 +858,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(return_self_not_must_use::ReturnSelfNotMustUse));
     store.register_late_pass(|| Box::new(init_numbered_fields::NumberedFields));
     store.register_early_pass(|| Box::new(single_char_lifetime_names::SingleCharLifetimeNames));
+    store.register_late_pass(move || Box::new(borrow_as_ptr::BorrowAsPtr::new(msrv)));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_utils/src/msrvs.rs b/clippy_utils/src/msrvs.rs
index 0cec7d6a5e4..af677d8b00f 100644
--- a/clippy_utils/src/msrvs.rs
+++ b/clippy_utils/src/msrvs.rs
@@ -14,6 +14,7 @@ macro_rules! msrv_aliases {
 msrv_aliases! {
     1,53,0 { OR_PATTERNS }
     1,52,0 { STR_SPLIT_ONCE }
+    1,51,0 { BORROW_AS_PTR }
     1,50,0 { BOOL_THEN }
     1,47,0 { TAU }
     1,46,0 { CONST_IF_MATCH }
diff --git a/tests/ui/as_conversions.rs b/tests/ui/as_conversions.rs
index cd745feec6d..ba4394defbf 100644
--- a/tests/ui/as_conversions.rs
+++ b/tests/ui/as_conversions.rs
@@ -1,6 +1,7 @@
 // aux-build:macro_rules.rs
 
 #![warn(clippy::as_conversions)]
+#![allow(clippy::borrow_as_ptr)]
 
 #[macro_use]
 extern crate macro_rules;
diff --git a/tests/ui/as_conversions.stderr b/tests/ui/as_conversions.stderr
index f5f75d3aee0..d11b56171b0 100644
--- a/tests/ui/as_conversions.stderr
+++ b/tests/ui/as_conversions.stderr
@@ -1,5 +1,5 @@
 error: using a potentially dangerous silent `as` conversion
-  --> $DIR/as_conversions.rs:14:13
+  --> $DIR/as_conversions.rs:15:13
    |
 LL |     let i = 0u32 as u64;
    |             ^^^^^^^^^^^
@@ -8,7 +8,7 @@ LL |     let i = 0u32 as u64;
    = help: consider using a safe wrapper for this conversion
 
 error: using a potentially dangerous silent `as` conversion
-  --> $DIR/as_conversions.rs:16:13
+  --> $DIR/as_conversions.rs:17:13
    |
 LL |     let j = &i as *const u64 as *mut u64;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -16,7 +16,7 @@ LL |     let j = &i as *const u64 as *mut u64;
    = help: consider using a safe wrapper for this conversion
 
 error: using a potentially dangerous silent `as` conversion
-  --> $DIR/as_conversions.rs:16:13
+  --> $DIR/as_conversions.rs:17:13
    |
 LL |     let j = &i as *const u64 as *mut u64;
    |             ^^^^^^^^^^^^^^^^
diff --git a/tests/ui/borrow_as_ptr.fixed b/tests/ui/borrow_as_ptr.fixed
new file mode 100644
index 00000000000..ff5c6a8c377
--- /dev/null
+++ b/tests/ui/borrow_as_ptr.fixed
@@ -0,0 +1,10 @@
+// run-rustfix
+#![warn(clippy::borrow_as_ptr)]
+
+fn main() {
+    let val = 1;
+    let _p = std::ptr::addr_of!(val);
+
+    let mut val_mut = 1;
+    let _p_mut = std::ptr::addr_of_mut!(val_mut);
+}
diff --git a/tests/ui/borrow_as_ptr.rs b/tests/ui/borrow_as_ptr.rs
new file mode 100644
index 00000000000..0f62ec6ee58
--- /dev/null
+++ b/tests/ui/borrow_as_ptr.rs
@@ -0,0 +1,10 @@
+// run-rustfix
+#![warn(clippy::borrow_as_ptr)]
+
+fn main() {
+    let val = 1;
+    let _p = &val as *const i32;
+
+    let mut val_mut = 1;
+    let _p_mut = &mut val_mut as *mut i32;
+}
diff --git a/tests/ui/borrow_as_ptr.stderr b/tests/ui/borrow_as_ptr.stderr
new file mode 100644
index 00000000000..be1ed733056
--- /dev/null
+++ b/tests/ui/borrow_as_ptr.stderr
@@ -0,0 +1,16 @@
+error: borrow as raw pointer
+  --> $DIR/borrow_as_ptr.rs:6:14
+   |
+LL |     let _p = &val as *const i32;
+   |              ^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::addr_of!(val)`
+   |
+   = note: `-D clippy::borrow-as-ptr` implied by `-D warnings`
+
+error: borrow as raw pointer
+  --> $DIR/borrow_as_ptr.rs:9:18
+   |
+LL |     let _p_mut = &mut val_mut as *mut i32;
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::addr_of_mut!(val_mut)`
+
+error: aborting due to 2 previous errors
+
diff --git a/tests/ui/borrow_as_ptr_no_std.fixed b/tests/ui/borrow_as_ptr_no_std.fixed
new file mode 100644
index 00000000000..eaba3b1c20c
--- /dev/null
+++ b/tests/ui/borrow_as_ptr_no_std.fixed
@@ -0,0 +1,22 @@
+// run-rustfix
+#![warn(clippy::borrow_as_ptr)]
+#![feature(lang_items, start, libc)]
+#![no_std]
+
+#[start]
+fn main(_argc: isize, _argv: *const *const u8) -> isize {
+    let val = 1;
+    let _p = core::ptr::addr_of!(val);
+
+    let mut val_mut = 1;
+    let _p_mut = core::ptr::addr_of_mut!(val_mut);
+    0
+}
+
+#[panic_handler]
+fn panic(_info: &core::panic::PanicInfo) -> ! {
+    loop {}
+}
+
+#[lang = "eh_personality"]
+extern "C" fn eh_personality() {}
diff --git a/tests/ui/borrow_as_ptr_no_std.rs b/tests/ui/borrow_as_ptr_no_std.rs
new file mode 100644
index 00000000000..d83f9d1f875
--- /dev/null
+++ b/tests/ui/borrow_as_ptr_no_std.rs
@@ -0,0 +1,22 @@
+// run-rustfix
+#![warn(clippy::borrow_as_ptr)]
+#![feature(lang_items, start, libc)]
+#![no_std]
+
+#[start]
+fn main(_argc: isize, _argv: *const *const u8) -> isize {
+    let val = 1;
+    let _p = &val as *const i32;
+
+    let mut val_mut = 1;
+    let _p_mut = &mut val_mut as *mut i32;
+    0
+}
+
+#[panic_handler]
+fn panic(_info: &core::panic::PanicInfo) -> ! {
+    loop {}
+}
+
+#[lang = "eh_personality"]
+extern "C" fn eh_personality() {}
diff --git a/tests/ui/borrow_as_ptr_no_std.stderr b/tests/ui/borrow_as_ptr_no_std.stderr
new file mode 100644
index 00000000000..84c8ba7d07f
--- /dev/null
+++ b/tests/ui/borrow_as_ptr_no_std.stderr
@@ -0,0 +1,16 @@
+error: borrow as raw pointer
+  --> $DIR/borrow_as_ptr_no_std.rs:9:14
+   |
+LL |     let _p = &val as *const i32;
+   |              ^^^^^^^^^^^^^^^^^^ help: try: `core::ptr::addr_of!(val)`
+   |
+   = note: `-D clippy::borrow-as-ptr` implied by `-D warnings`
+
+error: borrow as raw pointer
+  --> $DIR/borrow_as_ptr_no_std.rs:12:18
+   |
+LL |     let _p_mut = &mut val_mut as *mut i32;
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `core::ptr::addr_of_mut!(val_mut)`
+
+error: aborting due to 2 previous errors
+
diff --git a/tests/ui/cast_alignment.rs b/tests/ui/cast_alignment.rs
index d011e84b115..659591fffbe 100644
--- a/tests/ui/cast_alignment.rs
+++ b/tests/ui/cast_alignment.rs
@@ -4,7 +4,13 @@
 extern crate libc;
 
 #[warn(clippy::cast_ptr_alignment)]
-#[allow(clippy::no_effect, clippy::unnecessary_operation, clippy::cast_lossless)]
+#[allow(
+    clippy::no_effect,
+    clippy::unnecessary_operation,
+    clippy::cast_lossless,
+    clippy::borrow_as_ptr
+)]
+
 fn main() {
     /* These should be warned against */
 
diff --git a/tests/ui/cast_alignment.stderr b/tests/ui/cast_alignment.stderr
index 7998b787b91..aedd3684455 100644
--- a/tests/ui/cast_alignment.stderr
+++ b/tests/ui/cast_alignment.stderr
@@ -1,5 +1,5 @@
 error: casting from `*const u8` to a more-strictly-aligned pointer (`*const u16`) (1 < 2 bytes)
-  --> $DIR/cast_alignment.rs:12:5
+  --> $DIR/cast_alignment.rs:18:5
    |
 LL |     (&1u8 as *const u8) as *const u16;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -7,19 +7,19 @@ LL |     (&1u8 as *const u8) as *const u16;
    = note: `-D clippy::cast-ptr-alignment` implied by `-D warnings`
 
 error: casting from `*mut u8` to a more-strictly-aligned pointer (`*mut u16`) (1 < 2 bytes)
-  --> $DIR/cast_alignment.rs:13:5
+  --> $DIR/cast_alignment.rs:19:5
    |
 LL |     (&mut 1u8 as *mut u8) as *mut u16;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: casting from `*const u8` to a more-strictly-aligned pointer (`*const u16`) (1 < 2 bytes)
-  --> $DIR/cast_alignment.rs:16:5
+  --> $DIR/cast_alignment.rs:22:5
    |
 LL |     (&1u8 as *const u8).cast::<u16>();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: casting from `*mut u8` to a more-strictly-aligned pointer (`*mut u16`) (1 < 2 bytes)
-  --> $DIR/cast_alignment.rs:17:5
+  --> $DIR/cast_alignment.rs:23:5
    |
 LL |     (&mut 1u8 as *mut u8).cast::<u16>();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/cast_ref_to_mut.rs b/tests/ui/cast_ref_to_mut.rs
index 089e5cfabe4..c48a734ba32 100644
--- a/tests/ui/cast_ref_to_mut.rs
+++ b/tests/ui/cast_ref_to_mut.rs
@@ -1,5 +1,5 @@
 #![warn(clippy::cast_ref_to_mut)]
-#![allow(clippy::no_effect)]
+#![allow(clippy::no_effect, clippy::borrow_as_ptr)]
 
 extern "C" {
     // N.B., mutability can be easily incorrect in FFI calls -- as
diff --git a/tests/ui/mutex_atomic.rs b/tests/ui/mutex_atomic.rs
index 71063d9ce46..47b3dad3989 100644
--- a/tests/ui/mutex_atomic.rs
+++ b/tests/ui/mutex_atomic.rs
@@ -1,6 +1,7 @@
 #![warn(clippy::all)]
 #![warn(clippy::mutex_integer)]
 #![warn(clippy::mutex_atomic)]
+#![allow(clippy::borrow_as_ptr)]
 
 fn main() {
     use std::sync::Mutex;
diff --git a/tests/ui/mutex_atomic.stderr b/tests/ui/mutex_atomic.stderr
index ef7ad9b7576..262028a8723 100644
--- a/tests/ui/mutex_atomic.stderr
+++ b/tests/ui/mutex_atomic.stderr
@@ -1,5 +1,5 @@
 error: consider using an `AtomicBool` instead of a `Mutex` here; if you just want the locking behavior and not the internal type, consider using `Mutex<()>`
-  --> $DIR/mutex_atomic.rs:7:5
+  --> $DIR/mutex_atomic.rs:8:5
    |
 LL |     Mutex::new(true);
    |     ^^^^^^^^^^^^^^^^
@@ -7,31 +7,31 @@ LL |     Mutex::new(true);
    = note: `-D clippy::mutex-atomic` implied by `-D warnings`
 
 error: consider using an `AtomicUsize` instead of a `Mutex` here; if you just want the locking behavior and not the internal type, consider using `Mutex<()>`
-  --> $DIR/mutex_atomic.rs:8:5
+  --> $DIR/mutex_atomic.rs:9:5
    |
 LL |     Mutex::new(5usize);
    |     ^^^^^^^^^^^^^^^^^^
 
 error: consider using an `AtomicIsize` instead of a `Mutex` here; if you just want the locking behavior and not the internal type, consider using `Mutex<()>`
-  --> $DIR/mutex_atomic.rs:9:5
+  --> $DIR/mutex_atomic.rs:10:5
    |
 LL |     Mutex::new(9isize);
    |     ^^^^^^^^^^^^^^^^^^
 
 error: consider using an `AtomicPtr` instead of a `Mutex` here; if you just want the locking behavior and not the internal type, consider using `Mutex<()>`
-  --> $DIR/mutex_atomic.rs:11:5
+  --> $DIR/mutex_atomic.rs:12:5
    |
 LL |     Mutex::new(&x as *const u32);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: consider using an `AtomicPtr` instead of a `Mutex` here; if you just want the locking behavior and not the internal type, consider using `Mutex<()>`
-  --> $DIR/mutex_atomic.rs:12:5
+  --> $DIR/mutex_atomic.rs:13:5
    |
 LL |     Mutex::new(&mut x as *mut u32);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: consider using an `AtomicUsize` instead of a `Mutex` here; if you just want the locking behavior and not the internal type, consider using `Mutex<()>`
-  --> $DIR/mutex_atomic.rs:13:5
+  --> $DIR/mutex_atomic.rs:14:5
    |
 LL |     Mutex::new(0u32);
    |     ^^^^^^^^^^^^^^^^
@@ -39,7 +39,7 @@ LL |     Mutex::new(0u32);
    = note: `-D clippy::mutex-integer` implied by `-D warnings`
 
 error: consider using an `AtomicIsize` instead of a `Mutex` here; if you just want the locking behavior and not the internal type, consider using `Mutex<()>`
-  --> $DIR/mutex_atomic.rs:14:5
+  --> $DIR/mutex_atomic.rs:15:5
    |
 LL |     Mutex::new(0i32);
    |     ^^^^^^^^^^^^^^^^
diff --git a/tests/ui/or_fun_call.fixed b/tests/ui/or_fun_call.fixed
index d6d6ab49734..87cdb3ace47 100644
--- a/tests/ui/or_fun_call.fixed
+++ b/tests/ui/or_fun_call.fixed
@@ -2,7 +2,7 @@
 
 #![warn(clippy::or_fun_call)]
 #![allow(dead_code)]
-#![allow(clippy::unnecessary_wraps)]
+#![allow(clippy::unnecessary_wraps, clippy::borrow_as_ptr)]
 
 use std::collections::BTreeMap;
 use std::collections::HashMap;
diff --git a/tests/ui/or_fun_call.rs b/tests/ui/or_fun_call.rs
index 8eadc6ce3b4..3f69cef301c 100644
--- a/tests/ui/or_fun_call.rs
+++ b/tests/ui/or_fun_call.rs
@@ -2,7 +2,7 @@
 
 #![warn(clippy::or_fun_call)]
 #![allow(dead_code)]
-#![allow(clippy::unnecessary_wraps)]
+#![allow(clippy::unnecessary_wraps, clippy::borrow_as_ptr)]
 
 use std::collections::BTreeMap;
 use std::collections::HashMap;
diff --git a/tests/ui/transmute.rs b/tests/ui/transmute.rs
index 6a7037d8f38..9b681a79aae 100644
--- a/tests/ui/transmute.rs
+++ b/tests/ui/transmute.rs
@@ -1,4 +1,4 @@
-#![allow(dead_code)]
+#![allow(dead_code, clippy::borrow_as_ptr)]
 
 extern crate core;
 
diff --git a/tests/ui/transmute_ptr_to_ptr.rs b/tests/ui/transmute_ptr_to_ptr.rs
index 9e213aab68c..f06ffab5d9b 100644
--- a/tests/ui/transmute_ptr_to_ptr.rs
+++ b/tests/ui/transmute_ptr_to_ptr.rs
@@ -1,4 +1,5 @@
 #![warn(clippy::transmute_ptr_to_ptr)]
+#![allow(clippy::borrow_as_ptr)]
 
 // Make sure we can modify lifetimes, which is one of the recommended uses
 // of transmute
diff --git a/tests/ui/transmute_ptr_to_ptr.stderr b/tests/ui/transmute_ptr_to_ptr.stderr
index 4d1b8fcc199..49a8a3347e4 100644
--- a/tests/ui/transmute_ptr_to_ptr.stderr
+++ b/tests/ui/transmute_ptr_to_ptr.stderr
@@ -1,5 +1,5 @@
 error: transmute from a pointer to a pointer
-  --> $DIR/transmute_ptr_to_ptr.rs:29:29
+  --> $DIR/transmute_ptr_to_ptr.rs:30:29
    |
 LL |         let _: *const f32 = std::mem::transmute(ptr);
    |                             ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `ptr as *const f32`
@@ -7,31 +7,31 @@ LL |         let _: *const f32 = std::mem::transmute(ptr);
    = note: `-D clippy::transmute-ptr-to-ptr` implied by `-D warnings`
 
 error: transmute from a pointer to a pointer
-  --> $DIR/transmute_ptr_to_ptr.rs:30:27
+  --> $DIR/transmute_ptr_to_ptr.rs:31:27
    |
 LL |         let _: *mut f32 = std::mem::transmute(mut_ptr);
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `mut_ptr as *mut f32`
 
 error: transmute from a reference to a reference
-  --> $DIR/transmute_ptr_to_ptr.rs:32:23
+  --> $DIR/transmute_ptr_to_ptr.rs:33:23
    |
 LL |         let _: &f32 = std::mem::transmute(&1u32);
    |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&*(&1u32 as *const u32 as *const f32)`
 
 error: transmute from a reference to a reference
-  --> $DIR/transmute_ptr_to_ptr.rs:33:23
+  --> $DIR/transmute_ptr_to_ptr.rs:34:23
    |
 LL |         let _: &f64 = std::mem::transmute(&1f32);
    |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&*(&1f32 as *const f32 as *const f64)`
 
 error: transmute from a reference to a reference
-  --> $DIR/transmute_ptr_to_ptr.rs:36:27
+  --> $DIR/transmute_ptr_to_ptr.rs:37:27
    |
 LL |         let _: &mut f32 = std::mem::transmute(&mut 1u32);
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&mut *(&mut 1u32 as *mut u32 as *mut f32)`
 
 error: transmute from a reference to a reference
-  --> $DIR/transmute_ptr_to_ptr.rs:37:37
+  --> $DIR/transmute_ptr_to_ptr.rs:38:37
    |
 LL |         let _: &GenericParam<f32> = std::mem::transmute(&GenericParam { t: 1u32 });
    |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&*(&GenericParam { t: 1u32 } as *const GenericParam<u32> as *const GenericParam<f32>)`
diff --git a/tests/ui/transmutes_expressible_as_ptr_casts.fixed b/tests/ui/transmutes_expressible_as_ptr_casts.fixed
index b6f1e83181c..9ae0ed0b13f 100644
--- a/tests/ui/transmutes_expressible_as_ptr_casts.fixed
+++ b/tests/ui/transmutes_expressible_as_ptr_casts.fixed
@@ -4,8 +4,7 @@
 // would otherwise be responsible for
 #![warn(clippy::useless_transmute)]
 #![warn(clippy::transmute_ptr_to_ptr)]
-#![allow(unused_unsafe)]
-#![allow(dead_code)]
+#![allow(dead_code, unused_unsafe, clippy::borrow_as_ptr)]
 
 use std::mem::{size_of, transmute};
 
diff --git a/tests/ui/transmutes_expressible_as_ptr_casts.rs b/tests/ui/transmutes_expressible_as_ptr_casts.rs
index 0205d1ece60..985cf9a075d 100644
--- a/tests/ui/transmutes_expressible_as_ptr_casts.rs
+++ b/tests/ui/transmutes_expressible_as_ptr_casts.rs
@@ -4,8 +4,7 @@
 // would otherwise be responsible for
 #![warn(clippy::useless_transmute)]
 #![warn(clippy::transmute_ptr_to_ptr)]
-#![allow(unused_unsafe)]
-#![allow(dead_code)]
+#![allow(dead_code, unused_unsafe, clippy::borrow_as_ptr)]
 
 use std::mem::{size_of, transmute};
 
diff --git a/tests/ui/transmutes_expressible_as_ptr_casts.stderr b/tests/ui/transmutes_expressible_as_ptr_casts.stderr
index 1157b179317..e8496a325d6 100644
--- a/tests/ui/transmutes_expressible_as_ptr_casts.stderr
+++ b/tests/ui/transmutes_expressible_as_ptr_casts.stderr
@@ -1,5 +1,5 @@
 error: transmute from an integer to a pointer
-  --> $DIR/transmutes_expressible_as_ptr_casts.rs:19:39
+  --> $DIR/transmutes_expressible_as_ptr_casts.rs:18:39
    |
 LL |     let _ptr_i32_transmute = unsafe { transmute::<usize, *const i32>(usize::MAX) };
    |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `usize::MAX as *const i32`
@@ -7,7 +7,7 @@ LL |     let _ptr_i32_transmute = unsafe { transmute::<usize, *const i32>(usize:
    = note: `-D clippy::useless-transmute` implied by `-D warnings`
 
 error: transmute from a pointer to a pointer
-  --> $DIR/transmutes_expressible_as_ptr_casts.rs:23:38
+  --> $DIR/transmutes_expressible_as_ptr_casts.rs:22:38
    |
 LL |     let _ptr_i8_transmute = unsafe { transmute::<*const i32, *const i8>(ptr_i32) };
    |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `ptr_i32 as *const i8`
@@ -15,13 +15,13 @@ LL |     let _ptr_i8_transmute = unsafe { transmute::<*const i32, *const i8>(ptr
    = note: `-D clippy::transmute-ptr-to-ptr` implied by `-D warnings`
 
 error: transmute from a pointer to a pointer
-  --> $DIR/transmutes_expressible_as_ptr_casts.rs:29:46
+  --> $DIR/transmutes_expressible_as_ptr_casts.rs:28:46
    |
 LL |     let _ptr_to_unsized_transmute = unsafe { transmute::<*const [i32], *const [u16]>(slice_ptr) };
    |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `slice_ptr as *const [u16]`
 
 error: transmute from `*const i32` to `usize` which could be expressed as a pointer cast instead
-  --> $DIR/transmutes_expressible_as_ptr_casts.rs:35:50
+  --> $DIR/transmutes_expressible_as_ptr_casts.rs:34:50
    |
 LL |     let _usize_from_int_ptr_transmute = unsafe { transmute::<*const i32, usize>(ptr_i32) };
    |                                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `ptr_i32 as usize`
@@ -29,25 +29,25 @@ LL |     let _usize_from_int_ptr_transmute = unsafe { transmute::<*const i32, us
    = note: `-D clippy::transmutes-expressible-as-ptr-casts` implied by `-D warnings`
 
 error: transmute from a reference to a pointer
-  --> $DIR/transmutes_expressible_as_ptr_casts.rs:41:41
+  --> $DIR/transmutes_expressible_as_ptr_casts.rs:40:41
    |
 LL |     let _array_ptr_transmute = unsafe { transmute::<&[i32; 4], *const [i32; 4]>(array_ref) };
    |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `array_ref as *const [i32; 4]`
 
 error: transmute from `fn(usize) -> u8 {main::foo}` to `*const usize` which could be expressed as a pointer cast instead
-  --> $DIR/transmutes_expressible_as_ptr_casts.rs:49:41
+  --> $DIR/transmutes_expressible_as_ptr_casts.rs:48:41
    |
 LL |     let _usize_ptr_transmute = unsafe { transmute::<fn(usize) -> u8, *const usize>(foo) };
    |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `foo as *const usize`
 
 error: transmute from `fn(usize) -> u8 {main::foo}` to `usize` which could be expressed as a pointer cast instead
-  --> $DIR/transmutes_expressible_as_ptr_casts.rs:53:49
+  --> $DIR/transmutes_expressible_as_ptr_casts.rs:52:49
    |
 LL |     let _usize_from_fn_ptr_transmute = unsafe { transmute::<fn(usize) -> u8, usize>(foo) };
    |                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `foo as usize`
 
 error: transmute from a reference to a pointer
-  --> $DIR/transmutes_expressible_as_ptr_casts.rs:65:14
+  --> $DIR/transmutes_expressible_as_ptr_casts.rs:64:14
    |
 LL |     unsafe { transmute::<&[i32; 1], *const u8>(in_param) }
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `in_param as *const [i32; 1] as *const u8`
diff --git a/tests/ui/unnecessary_cast_fixable.fixed b/tests/ui/unnecessary_cast_fixable.fixed
index bda0f2c47cd..3332f49c80c 100644
--- a/tests/ui/unnecessary_cast_fixable.fixed
+++ b/tests/ui/unnecessary_cast_fixable.fixed
@@ -1,7 +1,12 @@
 // run-rustfix
 
 #![warn(clippy::unnecessary_cast)]
-#![allow(clippy::no_effect, clippy::unnecessary_operation, clippy::nonstandard_macro_braces)]
+#![allow(
+    clippy::no_effect,
+    clippy::unnecessary_operation,
+    clippy::nonstandard_macro_braces,
+    clippy::borrow_as_ptr
+)]
 
 fn main() {
     // casting integer literal to float is unnecessary
diff --git a/tests/ui/unnecessary_cast_fixable.rs b/tests/ui/unnecessary_cast_fixable.rs
index f7a4f2a5988..ec01e938779 100644
--- a/tests/ui/unnecessary_cast_fixable.rs
+++ b/tests/ui/unnecessary_cast_fixable.rs
@@ -1,7 +1,12 @@
 // run-rustfix
 
 #![warn(clippy::unnecessary_cast)]
-#![allow(clippy::no_effect, clippy::unnecessary_operation, clippy::nonstandard_macro_braces)]
+#![allow(
+    clippy::no_effect,
+    clippy::unnecessary_operation,
+    clippy::nonstandard_macro_braces,
+    clippy::borrow_as_ptr
+)]
 
 fn main() {
     // casting integer literal to float is unnecessary
diff --git a/tests/ui/unnecessary_cast_fixable.stderr b/tests/ui/unnecessary_cast_fixable.stderr
index 3695a8f819c..a281143281b 100644
--- a/tests/ui/unnecessary_cast_fixable.stderr
+++ b/tests/ui/unnecessary_cast_fixable.stderr
@@ -1,5 +1,5 @@
 error: casting integer literal to `f32` is unnecessary
-  --> $DIR/unnecessary_cast_fixable.rs:8:5
+  --> $DIR/unnecessary_cast_fixable.rs:13:5
    |
 LL |     100 as f32;
    |     ^^^^^^^^^^ help: try: `100_f32`
@@ -7,97 +7,97 @@ LL |     100 as f32;
    = note: `-D clippy::unnecessary-cast` implied by `-D warnings`
 
 error: casting integer literal to `f64` is unnecessary
-  --> $DIR/unnecessary_cast_fixable.rs:9:5
+  --> $DIR/unnecessary_cast_fixable.rs:14:5
    |
 LL |     100 as f64;
    |     ^^^^^^^^^^ help: try: `100_f64`
 
 error: casting integer literal to `f64` is unnecessary
-  --> $DIR/unnecessary_cast_fixable.rs:10:5
+  --> $DIR/unnecessary_cast_fixable.rs:15:5
    |
 LL |     100_i32 as f64;
    |     ^^^^^^^^^^^^^^ help: try: `100_f64`
 
 error: casting integer literal to `f32` is unnecessary
-  --> $DIR/unnecessary_cast_fixable.rs:11:13
+  --> $DIR/unnecessary_cast_fixable.rs:16:13
    |
 LL |     let _ = -100 as f32;
    |             ^^^^^^^^^^^ help: try: `-100_f32`
 
 error: casting integer literal to `f64` is unnecessary
-  --> $DIR/unnecessary_cast_fixable.rs:12:13
+  --> $DIR/unnecessary_cast_fixable.rs:17:13
    |
 LL |     let _ = -100 as f64;
    |             ^^^^^^^^^^^ help: try: `-100_f64`
 
 error: casting integer literal to `f64` is unnecessary
-  --> $DIR/unnecessary_cast_fixable.rs:13:13
+  --> $DIR/unnecessary_cast_fixable.rs:18:13
    |
 LL |     let _ = -100_i32 as f64;
    |             ^^^^^^^^^^^^^^^ help: try: `-100_f64`
 
 error: casting float literal to `f32` is unnecessary
-  --> $DIR/unnecessary_cast_fixable.rs:14:5
+  --> $DIR/unnecessary_cast_fixable.rs:19:5
    |
 LL |     100. as f32;
    |     ^^^^^^^^^^^ help: try: `100_f32`
 
 error: casting float literal to `f64` is unnecessary
-  --> $DIR/unnecessary_cast_fixable.rs:15:5
+  --> $DIR/unnecessary_cast_fixable.rs:20:5
    |
 LL |     100. as f64;
    |     ^^^^^^^^^^^ help: try: `100_f64`
 
 error: casting integer literal to `u32` is unnecessary
-  --> $DIR/unnecessary_cast_fixable.rs:27:5
+  --> $DIR/unnecessary_cast_fixable.rs:32:5
    |
 LL |     1 as u32;
    |     ^^^^^^^^ help: try: `1_u32`
 
 error: casting integer literal to `i32` is unnecessary
-  --> $DIR/unnecessary_cast_fixable.rs:28:5
+  --> $DIR/unnecessary_cast_fixable.rs:33:5
    |
 LL |     0x10 as i32;
    |     ^^^^^^^^^^^ help: try: `0x10_i32`
 
 error: casting integer literal to `usize` is unnecessary
-  --> $DIR/unnecessary_cast_fixable.rs:29:5
+  --> $DIR/unnecessary_cast_fixable.rs:34:5
    |
 LL |     0b10 as usize;
    |     ^^^^^^^^^^^^^ help: try: `0b10_usize`
 
 error: casting integer literal to `u16` is unnecessary
-  --> $DIR/unnecessary_cast_fixable.rs:30:5
+  --> $DIR/unnecessary_cast_fixable.rs:35:5
    |
 LL |     0o73 as u16;
    |     ^^^^^^^^^^^ help: try: `0o73_u16`
 
 error: casting integer literal to `u32` is unnecessary
-  --> $DIR/unnecessary_cast_fixable.rs:31:5
+  --> $DIR/unnecessary_cast_fixable.rs:36:5
    |
 LL |     1_000_000_000 as u32;
    |     ^^^^^^^^^^^^^^^^^^^^ help: try: `1_000_000_000_u32`
 
 error: casting float literal to `f64` is unnecessary
-  --> $DIR/unnecessary_cast_fixable.rs:33:5
+  --> $DIR/unnecessary_cast_fixable.rs:38:5
    |
 LL |     1.0 as f64;
    |     ^^^^^^^^^^ help: try: `1.0_f64`
 
 error: casting float literal to `f32` is unnecessary
-  --> $DIR/unnecessary_cast_fixable.rs:34:5
+  --> $DIR/unnecessary_cast_fixable.rs:39:5
    |
 LL |     0.5 as f32;
    |     ^^^^^^^^^^ help: try: `0.5_f32`
 
 error: casting integer literal to `i32` is unnecessary
-  --> $DIR/unnecessary_cast_fixable.rs:38:13
+  --> $DIR/unnecessary_cast_fixable.rs:43:13
    |
 LL |     let _ = -1 as i32;
    |             ^^^^^^^^^ help: try: `-1_i32`
 
 error: casting float literal to `f32` is unnecessary
-  --> $DIR/unnecessary_cast_fixable.rs:39:13
+  --> $DIR/unnecessary_cast_fixable.rs:44:13
    |
 LL |     let _ = -1.0 as f32;
    |             ^^^^^^^^^^^ help: try: `-1.0_f32`
diff --git a/tests/ui/vtable_address_comparisons.rs b/tests/ui/vtable_address_comparisons.rs
index c91d96ee18a..a9a4a0f5a6b 100644
--- a/tests/ui/vtable_address_comparisons.rs
+++ b/tests/ui/vtable_address_comparisons.rs
@@ -4,6 +4,8 @@ use std::rc::Rc;
 use std::sync::Arc;
 
 #[warn(clippy::vtable_address_comparisons)]
+#[allow(clippy::borrow_as_ptr)]
+
 fn main() {
     let a: *const dyn Debug = &1 as &dyn Debug;
     let b: *const dyn Debug = &1 as &dyn Debug;
diff --git a/tests/ui/vtable_address_comparisons.stderr b/tests/ui/vtable_address_comparisons.stderr
index 76bd57217d7..2f1be61e5df 100644
--- a/tests/ui/vtable_address_comparisons.stderr
+++ b/tests/ui/vtable_address_comparisons.stderr
@@ -1,5 +1,5 @@
 error: comparing trait object pointers compares a non-unique vtable address
-  --> $DIR/vtable_address_comparisons.rs:12:13
+  --> $DIR/vtable_address_comparisons.rs:14:13
    |
 LL |     let _ = a == b;
    |             ^^^^^^
@@ -8,7 +8,7 @@ LL |     let _ = a == b;
    = help: consider extracting and comparing data pointers only
 
 error: comparing trait object pointers compares a non-unique vtable address
-  --> $DIR/vtable_address_comparisons.rs:13:13
+  --> $DIR/vtable_address_comparisons.rs:15:13
    |
 LL |     let _ = a != b;
    |             ^^^^^^
@@ -16,7 +16,7 @@ LL |     let _ = a != b;
    = help: consider extracting and comparing data pointers only
 
 error: comparing trait object pointers compares a non-unique vtable address
-  --> $DIR/vtable_address_comparisons.rs:14:13
+  --> $DIR/vtable_address_comparisons.rs:16:13
    |
 LL |     let _ = a < b;
    |             ^^^^^
@@ -24,7 +24,7 @@ LL |     let _ = a < b;
    = help: consider extracting and comparing data pointers only
 
 error: comparing trait object pointers compares a non-unique vtable address
-  --> $DIR/vtable_address_comparisons.rs:15:13
+  --> $DIR/vtable_address_comparisons.rs:17:13
    |
 LL |     let _ = a <= b;
    |             ^^^^^^
@@ -32,7 +32,7 @@ LL |     let _ = a <= b;
    = help: consider extracting and comparing data pointers only
 
 error: comparing trait object pointers compares a non-unique vtable address
-  --> $DIR/vtable_address_comparisons.rs:16:13
+  --> $DIR/vtable_address_comparisons.rs:18:13
    |
 LL |     let _ = a > b;
    |             ^^^^^
@@ -40,7 +40,7 @@ LL |     let _ = a > b;
    = help: consider extracting and comparing data pointers only
 
 error: comparing trait object pointers compares a non-unique vtable address
-  --> $DIR/vtable_address_comparisons.rs:17:13
+  --> $DIR/vtable_address_comparisons.rs:19:13
    |
 LL |     let _ = a >= b;
    |             ^^^^^^
@@ -48,7 +48,7 @@ LL |     let _ = a >= b;
    = help: consider extracting and comparing data pointers only
 
 error: comparing trait object pointers compares a non-unique vtable address
-  --> $DIR/vtable_address_comparisons.rs:18:5
+  --> $DIR/vtable_address_comparisons.rs:20:5
    |
 LL |     ptr::eq(a, b);
    |     ^^^^^^^^^^^^^
@@ -56,7 +56,7 @@ LL |     ptr::eq(a, b);
    = help: consider extracting and comparing data pointers only
 
 error: comparing trait object pointers compares a non-unique vtable address
-  --> $DIR/vtable_address_comparisons.rs:22:5
+  --> $DIR/vtable_address_comparisons.rs:24:5
    |
 LL |     ptr::eq(a, b);
    |     ^^^^^^^^^^^^^
@@ -64,7 +64,7 @@ LL |     ptr::eq(a, b);
    = help: consider extracting and comparing data pointers only
 
 error: comparing trait object pointers compares a non-unique vtable address
-  --> $DIR/vtable_address_comparisons.rs:25:5
+  --> $DIR/vtable_address_comparisons.rs:27:5
    |
 LL |     Rc::ptr_eq(&a, &a);
    |     ^^^^^^^^^^^^^^^^^^
@@ -72,7 +72,7 @@ LL |     Rc::ptr_eq(&a, &a);
    = help: consider extracting and comparing data pointers only
 
 error: comparing trait object pointers compares a non-unique vtable address
-  --> $DIR/vtable_address_comparisons.rs:28:5
+  --> $DIR/vtable_address_comparisons.rs:30:5
    |
 LL |     Arc::ptr_eq(&a, &a);
    |     ^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/zero_offset.rs b/tests/ui/zero_offset.rs
index 6c190a4c86c..fd9ac1fa766 100644
--- a/tests/ui/zero_offset.rs
+++ b/tests/ui/zero_offset.rs
@@ -1,3 +1,4 @@
+#[allow(clippy::borrow_as_ptr)]
 fn main() {
     unsafe {
         let m = &mut () as *mut ();
diff --git a/tests/ui/zero_offset.stderr b/tests/ui/zero_offset.stderr
index b12c8e9a73c..481a446571a 100644
--- a/tests/ui/zero_offset.stderr
+++ b/tests/ui/zero_offset.stderr
@@ -1,5 +1,5 @@
 error: offset calculation on zero-sized value
-  --> $DIR/zero_offset.rs:4:9
+  --> $DIR/zero_offset.rs:5:9
    |
 LL |         m.offset(0);
    |         ^^^^^^^^^^^
@@ -7,43 +7,43 @@ LL |         m.offset(0);
    = note: `#[deny(clippy::zst_offset)]` on by default
 
 error: offset calculation on zero-sized value
-  --> $DIR/zero_offset.rs:5:9
+  --> $DIR/zero_offset.rs:6:9
    |
 LL |         m.wrapping_add(0);
    |         ^^^^^^^^^^^^^^^^^
 
 error: offset calculation on zero-sized value
-  --> $DIR/zero_offset.rs:6:9
+  --> $DIR/zero_offset.rs:7:9
    |
 LL |         m.sub(0);
    |         ^^^^^^^^
 
 error: offset calculation on zero-sized value
-  --> $DIR/zero_offset.rs:7:9
+  --> $DIR/zero_offset.rs:8:9
    |
 LL |         m.wrapping_sub(0);
    |         ^^^^^^^^^^^^^^^^^
 
 error: offset calculation on zero-sized value
-  --> $DIR/zero_offset.rs:10:9
+  --> $DIR/zero_offset.rs:11:9
    |
 LL |         c.offset(0);
    |         ^^^^^^^^^^^
 
 error: offset calculation on zero-sized value
-  --> $DIR/zero_offset.rs:11:9
+  --> $DIR/zero_offset.rs:12:9
    |
 LL |         c.wrapping_add(0);
    |         ^^^^^^^^^^^^^^^^^
 
 error: offset calculation on zero-sized value
-  --> $DIR/zero_offset.rs:12:9
+  --> $DIR/zero_offset.rs:13:9
    |
 LL |         c.sub(0);
    |         ^^^^^^^^
 
 error: offset calculation on zero-sized value
-  --> $DIR/zero_offset.rs:13:9
+  --> $DIR/zero_offset.rs:14:9
    |
 LL |         c.wrapping_sub(0);
    |         ^^^^^^^^^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From 02ec39b2ff69ce3275724e234ebcb72d310766ca Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Tue, 11 Jan 2022 09:52:23 -0600
Subject: Stop using in_band_lifetimes

---
 clippy_lints/src/bool_assert_comparison.rs         |  2 +-
 .../case_sensitive_file_extension_comparisons.rs   |  2 +-
 clippy_lints/src/casts/cast_ptr_alignment.rs       |  2 +-
 clippy_lints/src/casts/cast_ref_to_mut.rs          |  2 +-
 clippy_lints/src/casts/char_lit_as_u8.rs           |  2 +-
 clippy_lints/src/casts/ptr_as_ptr.rs               |  2 +-
 clippy_lints/src/copies.rs                         | 14 +++-----
 clippy_lints/src/default.rs                        |  4 +--
 clippy_lints/src/default_numeric_fallback.rs       |  2 +-
 clippy_lints/src/dereference.rs                    | 10 +++---
 clippy_lints/src/entry.rs                          | 10 +++---
 clippy_lints/src/equatable_if_let.rs               |  2 +-
 clippy_lints/src/erasing_op.rs                     | 10 ++++--
 clippy_lints/src/from_over_into.rs                 |  2 +-
 clippy_lints/src/from_str_radix_10.rs              |  2 +-
 clippy_lints/src/functions/must_use.rs             |  6 ++--
 .../src/functions/not_unsafe_ptr_arg_deref.rs      |  6 ++--
 clippy_lints/src/functions/result_unit_err.rs      |  6 ++--
 clippy_lints/src/functions/too_many_arguments.rs   | 12 +++----
 clippy_lints/src/functions/too_many_lines.rs       |  4 +--
 clippy_lints/src/if_then_some_else_none.rs         |  2 +-
 clippy_lints/src/implicit_return.rs                |  4 +--
 .../src/inconsistent_struct_constructor.rs         |  2 +-
 clippy_lints/src/index_refutable_slice.rs          |  2 +-
 clippy_lints/src/iter_not_returning_iterator.rs    |  2 +-
 clippy_lints/src/len_zero.rs                       |  2 +-
 clippy_lints/src/lib.rs                            |  1 -
 clippy_lints/src/loops/empty_loop.rs               |  2 +-
 clippy_lints/src/loops/explicit_into_iter_loop.rs  |  2 +-
 clippy_lints/src/loops/manual_memcpy.rs            |  2 +-
 clippy_lints/src/loops/mut_range_bound.rs          |  2 +-
 clippy_lints/src/loops/needless_collect.rs         |  4 +--
 clippy_lints/src/loops/never_loop.rs               |  4 +--
 clippy_lints/src/loops/while_let_loop.rs           |  2 +-
 clippy_lints/src/loops/while_let_on_iterator.rs    | 14 ++++----
 clippy_lints/src/manual_assert.rs                  |  2 +-
 clippy_lints/src/manual_map.rs                     | 17 ++++++----
 clippy_lints/src/manual_ok_or.rs                   |  2 +-
 clippy_lints/src/manual_unwrap_or.rs               |  2 +-
 clippy_lints/src/match_str_case_mismatch.rs        |  2 +-
 clippy_lints/src/matches.rs                        | 12 ++++---
 clippy_lints/src/methods/expect_fun_call.rs        |  2 +-
 .../src/methods/from_iter_instead_of_collect.rs    |  2 +-
 clippy_lints/src/methods/str_splitn.rs             |  4 +--
 .../src/methods/unnecessary_iter_cloned.rs         | 10 +++---
 clippy_lints/src/methods/unnecessary_to_owned.rs   | 29 ++++++++--------
 clippy_lints/src/misc.rs                           |  2 +-
 clippy_lints/src/needless_for_each.rs              |  2 +-
 clippy_lints/src/needless_late_init.rs             |  2 +-
 clippy_lints/src/no_effect.rs                      |  4 +--
 clippy_lints/src/non_octal_unix_permissions.rs     |  2 +-
 clippy_lints/src/octal_escapes.rs                  |  4 +--
 clippy_lints/src/ptr_eq.rs                         |  2 +-
 clippy_lints/src/redundant_slicing.rs              |  2 +-
 clippy_lints/src/return_self_not_must_use.rs       |  2 +-
 clippy_lints/src/semicolon_if_nothing_returned.rs  |  2 +-
 clippy_lints/src/size_of_in_element_count.rs       |  7 ++--
 clippy_lints/src/strings.rs                        |  4 +--
 clippy_lints/src/strlen_on_c_strings.rs            |  2 +-
 clippy_lints/src/suspicious_operation_groupings.rs |  4 +--
 clippy_lints/src/trailing_empty_array.rs           |  2 +-
 clippy_lints/src/undocumented_unsafe_blocks.rs     |  4 +--
 clippy_lints/src/undropped_manually_drops.rs       |  2 +-
 clippy_lints/src/uninit_vec.rs                     |  4 +--
 clippy_lints/src/unit_hash.rs                      |  2 +-
 .../src/utils/internal_lints/metadata_collector.rs | 12 +++----
 clippy_lints/src/vec_init_then_push.rs             |  2 +-
 clippy_utils/src/consts.rs                         |  2 +-
 clippy_utils/src/eager_or_lazy.rs                  | 13 +++++---
 clippy_utils/src/lib.rs                            | 39 ++++++++++++----------
 clippy_utils/src/macros.rs                         |  4 +--
 clippy_utils/src/qualify_min_const_fn.rs           | 25 ++++++++++----
 clippy_utils/src/source.rs                         |  2 +-
 clippy_utils/src/sugg.rs                           |  4 +--
 clippy_utils/src/ty.rs                             |  4 +--
 clippy_utils/src/visitors.rs                       |  8 ++---
 doc/common_tools_writing_lints.md                  |  2 +-
 77 files changed, 216 insertions(+), 189 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/bool_assert_comparison.rs b/clippy_lints/src/bool_assert_comparison.rs
index ea2cfb0bc08..c50e214be28 100644
--- a/clippy_lints/src/bool_assert_comparison.rs
+++ b/clippy_lints/src/bool_assert_comparison.rs
@@ -42,7 +42,7 @@ fn is_bool_lit(e: &Expr<'_>) -> bool {
     ) && !e.span.from_expansion()
 }
 
-fn is_impl_not_trait_with_bool_out(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> bool {
+fn is_impl_not_trait_with_bool_out(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
     let ty = cx.typeck_results().expr_ty(e);
 
     cx.tcx
diff --git a/clippy_lints/src/case_sensitive_file_extension_comparisons.rs b/clippy_lints/src/case_sensitive_file_extension_comparisons.rs
index 3f286dd9e2f..e8f39cd3709 100644
--- a/clippy_lints/src/case_sensitive_file_extension_comparisons.rs
+++ b/clippy_lints/src/case_sensitive_file_extension_comparisons.rs
@@ -67,7 +67,7 @@ fn check_case_sensitive_file_extension_comparison(ctx: &LateContext<'_>, expr: &
     None
 }
 
-impl LateLintPass<'tcx> for CaseSensitiveFileExtensionComparisons {
+impl<'tcx> LateLintPass<'tcx> for CaseSensitiveFileExtensionComparisons {
     fn check_expr(&mut self, ctx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
         if let Some(span) = check_case_sensitive_file_extension_comparison(ctx, expr) {
             span_lint_and_help(
diff --git a/clippy_lints/src/casts/cast_ptr_alignment.rs b/clippy_lints/src/casts/cast_ptr_alignment.rs
index 248b35b024e..b9de5510455 100644
--- a/clippy_lints/src/casts/cast_ptr_alignment.rs
+++ b/clippy_lints/src/casts/cast_ptr_alignment.rs
@@ -9,7 +9,7 @@ use rustc_span::symbol::sym;
 
 use super::CAST_PTR_ALIGNMENT;
 
-pub(super) fn check(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>) {
     if let ExprKind::Cast(cast_expr, cast_to) = expr.kind {
         if is_hir_ty_cfg_dependant(cx, cast_to) {
             return;
diff --git a/clippy_lints/src/casts/cast_ref_to_mut.rs b/clippy_lints/src/casts/cast_ref_to_mut.rs
index d9bf1ea58b9..15f2f81f407 100644
--- a/clippy_lints/src/casts/cast_ref_to_mut.rs
+++ b/clippy_lints/src/casts/cast_ref_to_mut.rs
@@ -6,7 +6,7 @@ use rustc_middle::ty;
 
 use super::CAST_REF_TO_MUT;
 
-pub(super) fn check(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>) {
     if_chain! {
         if let ExprKind::Unary(UnOp::Deref, e) = &expr.kind;
         if let ExprKind::Cast(e, t) = &e.kind;
diff --git a/clippy_lints/src/casts/char_lit_as_u8.rs b/clippy_lints/src/casts/char_lit_as_u8.rs
index 099a0de881f..7cc406018db 100644
--- a/clippy_lints/src/casts/char_lit_as_u8.rs
+++ b/clippy_lints/src/casts/char_lit_as_u8.rs
@@ -9,7 +9,7 @@ use rustc_middle::ty::{self, UintTy};
 
 use super::CHAR_LIT_AS_U8;
 
-pub(super) fn check(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>) {
     if_chain! {
         if let ExprKind::Cast(e, _) = &expr.kind;
         if let ExprKind::Lit(l) = &e.kind;
diff --git a/clippy_lints/src/casts/ptr_as_ptr.rs b/clippy_lints/src/casts/ptr_as_ptr.rs
index 3132d3a5cf0..fb04f93fbcf 100644
--- a/clippy_lints/src/casts/ptr_as_ptr.rs
+++ b/clippy_lints/src/casts/ptr_as_ptr.rs
@@ -12,7 +12,7 @@ use rustc_semver::RustcVersion;
 
 use super::PTR_AS_PTR;
 
-pub(super) fn check(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, msrv: &Option<RustcVersion>) {
+pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, msrv: &Option<RustcVersion>) {
     if !meets_msrv(msrv.as_ref(), &msrvs::POINTER_CAST) {
         return;
     }
diff --git a/clippy_lints/src/copies.rs b/clippy_lints/src/copies.rs
index d07bc23235b..73ce656ad15 100644
--- a/clippy_lints/src/copies.rs
+++ b/clippy_lints/src/copies.rs
@@ -316,7 +316,7 @@ struct BlockEqual {
 
 /// This function can also trigger the `IF_SAME_THEN_ELSE` in which case it'll return `None` to
 /// abort any further processing and avoid duplicate lint triggers.
-fn scan_block_for_eq(cx: &LateContext<'tcx>, blocks: &[&Block<'tcx>]) -> Option<BlockEqual> {
+fn scan_block_for_eq(cx: &LateContext<'_>, blocks: &[&Block<'_>]) -> Option<BlockEqual> {
     let mut start_eq = usize::MAX;
     let mut end_eq = usize::MAX;
     let mut expr_eq = true;
@@ -385,11 +385,7 @@ fn scan_block_for_eq(cx: &LateContext<'tcx>, blocks: &[&Block<'tcx>]) -> Option<
     })
 }
 
-fn check_for_warn_of_moved_symbol(
-    cx: &LateContext<'tcx>,
-    symbols: &FxHashSet<Symbol>,
-    if_expr: &'tcx Expr<'_>,
-) -> bool {
+fn check_for_warn_of_moved_symbol(cx: &LateContext<'_>, symbols: &FxHashSet<Symbol>, if_expr: &Expr<'_>) -> bool {
     get_enclosing_block(cx, if_expr.hir_id).map_or(false, |block| {
         let ignore_span = block.span.shrink_to_lo().to(if_expr.span);
 
@@ -419,13 +415,13 @@ fn check_for_warn_of_moved_symbol(
 }
 
 fn emit_branches_sharing_code_lint(
-    cx: &LateContext<'tcx>,
+    cx: &LateContext<'_>,
     start_stmts: usize,
     end_stmts: usize,
     lint_end: bool,
     warn_about_moved_symbol: bool,
-    blocks: &[&Block<'tcx>],
-    if_expr: &'tcx Expr<'_>,
+    blocks: &[&Block<'_>],
+    if_expr: &Expr<'_>,
 ) {
     if start_stmts == 0 && !lint_end {
         return;
diff --git a/clippy_lints/src/default.rs b/clippy_lints/src/default.rs
index a0b137efe22..4274943a3d1 100644
--- a/clippy_lints/src/default.rs
+++ b/clippy_lints/src/default.rs
@@ -77,7 +77,7 @@ pub struct Default {
 
 impl_lint_pass!(Default => [DEFAULT_TRAIT_ACCESS, FIELD_REASSIGN_WITH_DEFAULT]);
 
-impl LateLintPass<'_> for Default {
+impl<'tcx> LateLintPass<'tcx> for Default {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if_chain! {
             if !expr.span.from_expansion();
@@ -110,7 +110,7 @@ impl LateLintPass<'_> for Default {
     }
 
     #[allow(clippy::too_many_lines)]
-    fn check_block<'tcx>(&mut self, cx: &LateContext<'tcx>, block: &Block<'tcx>) {
+    fn check_block(&mut self, cx: &LateContext<'tcx>, block: &Block<'tcx>) {
         // start from the `let mut _ = _::default();` and look at all the following
         // statements, see if they re-assign the fields of the binding
         let stmts_head = match block.stmts {
diff --git a/clippy_lints/src/default_numeric_fallback.rs b/clippy_lints/src/default_numeric_fallback.rs
index 3573ea5f026..e5131c497ae 100644
--- a/clippy_lints/src/default_numeric_fallback.rs
+++ b/clippy_lints/src/default_numeric_fallback.rs
@@ -54,7 +54,7 @@ declare_clippy_lint! {
 
 declare_lint_pass!(DefaultNumericFallback => [DEFAULT_NUMERIC_FALLBACK]);
 
-impl LateLintPass<'_> for DefaultNumericFallback {
+impl<'tcx> LateLintPass<'tcx> for DefaultNumericFallback {
     fn check_body(&mut self, cx: &LateContext<'tcx>, body: &'tcx Body<'_>) {
         let mut visitor = NumericFallbackVisitor::new(cx);
         visitor.visit_body(body);
diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index fa2b348591b..bf077a212fd 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -355,7 +355,7 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing {
     }
 }
 
-fn try_parse_ref_op(
+fn try_parse_ref_op<'tcx>(
     tcx: TyCtxt<'tcx>,
     typeck: &'tcx TypeckResults<'_>,
     expr: &'tcx Expr<'_>,
@@ -387,7 +387,7 @@ fn try_parse_ref_op(
 
 // Checks whether the type for a deref call actually changed the type, not just the mutability of
 // the reference.
-fn deref_method_same_type(result_ty: Ty<'tcx>, arg_ty: Ty<'tcx>) -> bool {
+fn deref_method_same_type(result_ty: Ty<'_>, arg_ty: Ty<'_>) -> bool {
     match (result_ty.kind(), arg_ty.kind()) {
         (ty::Ref(_, result_ty, _), ty::Ref(_, arg_ty, _)) => TyS::same_type(result_ty, arg_ty),
 
@@ -457,7 +457,7 @@ fn is_linted_explicit_deref_position(parent: Option<Node<'_>>, child_id: HirId,
 }
 
 /// Adjustments are sometimes made in the parent block rather than the expression itself.
-fn find_adjustments(
+fn find_adjustments<'tcx>(
     tcx: TyCtxt<'tcx>,
     typeck: &'tcx TypeckResults<'_>,
     expr: &'tcx Expr<'_>,
@@ -499,7 +499,7 @@ fn find_adjustments(
 }
 
 #[allow(clippy::needless_pass_by_value)]
-fn report(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, state: State, data: StateData) {
+fn report(cx: &LateContext<'_>, expr: &Expr<'_>, state: State, data: StateData) {
     match state {
         State::DerefMethod {
             ty_changed_count,
@@ -568,7 +568,7 @@ fn report(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, state: State, data: Stat
 }
 
 impl Dereferencing {
-    fn check_local_usage(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>, local: HirId) {
+    fn check_local_usage(&mut self, cx: &LateContext<'_>, e: &Expr<'_>, local: HirId) {
         if let Some(outer_pat) = self.ref_locals.get_mut(&local) {
             if let Some(pat) = outer_pat {
                 // Check for auto-deref
diff --git a/clippy_lints/src/entry.rs b/clippy_lints/src/entry.rs
index 3d92eb16870..3ce239273e2 100644
--- a/clippy_lints/src/entry.rs
+++ b/clippy_lints/src/entry.rs
@@ -233,7 +233,7 @@ struct ContainsExpr<'tcx> {
     key: &'tcx Expr<'tcx>,
     call_ctxt: SyntaxContext,
 }
-fn try_parse_contains(cx: &LateContext<'_>, expr: &'tcx Expr<'_>) -> Option<(MapType, ContainsExpr<'tcx>)> {
+fn try_parse_contains<'tcx>(cx: &LateContext<'_>, expr: &'tcx Expr<'_>) -> Option<(MapType, ContainsExpr<'tcx>)> {
     let mut negated = false;
     let expr = peel_hir_expr_while(expr, |e| match e.kind {
         ExprKind::Unary(UnOp::Not, e) => {
@@ -280,7 +280,7 @@ struct InsertExpr<'tcx> {
     key: &'tcx Expr<'tcx>,
     value: &'tcx Expr<'tcx>,
 }
-fn try_parse_insert(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<InsertExpr<'tcx>> {
+fn try_parse_insert<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<InsertExpr<'tcx>> {
     if let ExprKind::MethodCall(_, _, [map, key, value], _) = expr.kind {
         let id = cx.typeck_results().type_dependent_def_id(expr.hir_id)?;
         if match_def_path(cx, id, &paths::BTREEMAP_INSERT) || match_def_path(cx, id, &paths::HASHMAP_INSERT) {
@@ -301,7 +301,7 @@ enum Edit<'tcx> {
     /// An insertion into the map.
     Insertion(Insertion<'tcx>),
 }
-impl Edit<'tcx> {
+impl<'tcx> Edit<'tcx> {
     fn as_insertion(self) -> Option<Insertion<'tcx>> {
         if let Self::Insertion(i) = self { Some(i) } else { None }
     }
@@ -532,7 +532,7 @@ struct InsertSearchResults<'tcx> {
     allow_insert_closure: bool,
     is_single_insert: bool,
 }
-impl InsertSearchResults<'tcx> {
+impl<'tcx> InsertSearchResults<'tcx> {
     fn as_single_insertion(&self) -> Option<Insertion<'tcx>> {
         self.is_single_insert.then(|| self.edits[0].as_insertion().unwrap())
     }
@@ -633,7 +633,7 @@ impl InsertSearchResults<'tcx> {
     }
 }
 
-fn find_insert_calls(
+fn find_insert_calls<'tcx>(
     cx: &LateContext<'tcx>,
     contains_expr: &ContainsExpr<'tcx>,
     expr: &'tcx Expr<'_>,
diff --git a/clippy_lints/src/equatable_if_let.rs b/clippy_lints/src/equatable_if_let.rs
index 06d128f5527..cf47e581ccb 100644
--- a/clippy_lints/src/equatable_if_let.rs
+++ b/clippy_lints/src/equatable_if_let.rs
@@ -56,7 +56,7 @@ fn unary_pattern(pat: &Pat<'_>) -> bool {
     }
 }
 
-fn is_structural_partial_eq(cx: &LateContext<'tcx>, ty: Ty<'tcx>, other: Ty<'tcx>) -> bool {
+fn is_structural_partial_eq<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>, other: Ty<'tcx>) -> bool {
     if let Some(def_id) = cx.tcx.lang_items().eq_trait() {
         implements_trait(cx, ty, def_id, &[other.into()])
     } else {
diff --git a/clippy_lints/src/erasing_op.rs b/clippy_lints/src/erasing_op.rs
index bb6acd8c5dd..c1a84973c42 100644
--- a/clippy_lints/src/erasing_op.rs
+++ b/clippy_lints/src/erasing_op.rs
@@ -50,13 +50,19 @@ impl<'tcx> LateLintPass<'tcx> for ErasingOp {
     }
 }
 
-fn different_types(tck: &TypeckResults<'tcx>, input: &'tcx Expr<'_>, output: &'tcx Expr<'_>) -> bool {
+fn different_types(tck: &TypeckResults<'_>, input: &Expr<'_>, output: &Expr<'_>) -> bool {
     let input_ty = tck.expr_ty(input).peel_refs();
     let output_ty = tck.expr_ty(output).peel_refs();
     !same_type_and_consts(input_ty, output_ty)
 }
 
-fn check(cx: &LateContext<'cx>, tck: &TypeckResults<'cx>, op: &Expr<'cx>, other: &Expr<'cx>, parent: &Expr<'cx>) {
+fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    tck: &TypeckResults<'tcx>,
+    op: &Expr<'tcx>,
+    other: &Expr<'tcx>,
+    parent: &Expr<'tcx>,
+) {
     if constant_simple(cx, tck, op) == Some(Constant::Int(0)) {
         if different_types(tck, other, parent) {
             return;
diff --git a/clippy_lints/src/from_over_into.rs b/clippy_lints/src/from_over_into.rs
index 866ff216f84..5ece2cc5ac4 100644
--- a/clippy_lints/src/from_over_into.rs
+++ b/clippy_lints/src/from_over_into.rs
@@ -53,7 +53,7 @@ impl FromOverInto {
 
 impl_lint_pass!(FromOverInto => [FROM_OVER_INTO]);
 
-impl LateLintPass<'_> for FromOverInto {
+impl<'tcx> LateLintPass<'tcx> for FromOverInto {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) {
         if !meets_msrv(self.msrv.as_ref(), &msrvs::RE_REBALANCING_COHERENCE) {
             return;
diff --git a/clippy_lints/src/from_str_radix_10.rs b/clippy_lints/src/from_str_radix_10.rs
index 73e800073b0..57b07513205 100644
--- a/clippy_lints/src/from_str_radix_10.rs
+++ b/clippy_lints/src/from_str_radix_10.rs
@@ -43,7 +43,7 @@ declare_clippy_lint! {
 
 declare_lint_pass!(FromStrRadix10 => [FROM_STR_RADIX_10]);
 
-impl LateLintPass<'tcx> for FromStrRadix10 {
+impl<'tcx> LateLintPass<'tcx> for FromStrRadix10 {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, exp: &Expr<'tcx>) {
         if_chain! {
             if let ExprKind::Call(maybe_path, arguments) = &exp.kind;
diff --git a/clippy_lints/src/functions/must_use.rs b/clippy_lints/src/functions/must_use.rs
index 77d08081c07..f2b4aefaead 100644
--- a/clippy_lints/src/functions/must_use.rs
+++ b/clippy_lints/src/functions/must_use.rs
@@ -18,7 +18,7 @@ use clippy_utils::{match_def_path, must_use_attr, return_ty, trait_ref_of_method
 
 use super::{DOUBLE_MUST_USE, MUST_USE_CANDIDATE, MUST_USE_UNIT};
 
-pub(super) fn check_item(cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) {
+pub(super) fn check_item<'tcx>(cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) {
     let attrs = cx.tcx.hir().attrs(item.hir_id());
     let attr = must_use_attr(attrs);
     if let hir::ItemKind::Fn(ref sig, ref _generics, ref body_id) = item.kind {
@@ -40,7 +40,7 @@ pub(super) fn check_item(cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) {
     }
 }
 
-pub(super) fn check_impl_item(cx: &LateContext<'tcx>, item: &'tcx hir::ImplItem<'_>) {
+pub(super) fn check_impl_item<'tcx>(cx: &LateContext<'tcx>, item: &'tcx hir::ImplItem<'_>) {
     if let hir::ImplItemKind::Fn(ref sig, ref body_id) = item.kind {
         let is_public = cx.access_levels.is_exported(item.def_id);
         let fn_header_span = item.span.with_hi(sig.decl.output.span().hi());
@@ -62,7 +62,7 @@ pub(super) fn check_impl_item(cx: &LateContext<'tcx>, item: &'tcx hir::ImplItem<
     }
 }
 
-pub(super) fn check_trait_item(cx: &LateContext<'tcx>, item: &'tcx hir::TraitItem<'_>) {
+pub(super) fn check_trait_item<'tcx>(cx: &LateContext<'tcx>, item: &'tcx hir::TraitItem<'_>) {
     if let hir::TraitItemKind::Fn(ref sig, ref eid) = item.kind {
         let is_public = cx.access_levels.is_exported(item.def_id);
         let fn_header_span = item.span.with_hi(sig.decl.output.span().hi());
diff --git a/clippy_lints/src/functions/not_unsafe_ptr_arg_deref.rs b/clippy_lints/src/functions/not_unsafe_ptr_arg_deref.rs
index f83789bb219..6d829a18b2e 100644
--- a/clippy_lints/src/functions/not_unsafe_ptr_arg_deref.rs
+++ b/clippy_lints/src/functions/not_unsafe_ptr_arg_deref.rs
@@ -9,7 +9,7 @@ use clippy_utils::{iter_input_pats, path_to_local};
 
 use super::NOT_UNSAFE_PTR_ARG_DEREF;
 
-pub(super) fn check_fn(
+pub(super) fn check_fn<'tcx>(
     cx: &LateContext<'tcx>,
     kind: intravisit::FnKind<'tcx>,
     decl: &'tcx hir::FnDecl<'tcx>,
@@ -25,14 +25,14 @@ pub(super) fn check_fn(
     check_raw_ptr(cx, unsafety, decl, body, cx.tcx.hir().local_def_id(hir_id));
 }
 
-pub(super) fn check_trait_item(cx: &LateContext<'tcx>, item: &'tcx hir::TraitItem<'_>) {
+pub(super) fn check_trait_item<'tcx>(cx: &LateContext<'tcx>, item: &'tcx hir::TraitItem<'_>) {
     if let hir::TraitItemKind::Fn(ref sig, hir::TraitFn::Provided(eid)) = item.kind {
         let body = cx.tcx.hir().body(eid);
         check_raw_ptr(cx, sig.header.unsafety, sig.decl, body, item.def_id);
     }
 }
 
-fn check_raw_ptr(
+fn check_raw_ptr<'tcx>(
     cx: &LateContext<'tcx>,
     unsafety: hir::Unsafety,
     decl: &'tcx hir::FnDecl<'tcx>,
diff --git a/clippy_lints/src/functions/result_unit_err.rs b/clippy_lints/src/functions/result_unit_err.rs
index 71f6f87ae60..73f08a04989 100644
--- a/clippy_lints/src/functions/result_unit_err.rs
+++ b/clippy_lints/src/functions/result_unit_err.rs
@@ -13,7 +13,7 @@ use clippy_utils::ty::is_type_diagnostic_item;
 
 use super::RESULT_UNIT_ERR;
 
-pub(super) fn check_item(cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) {
+pub(super) fn check_item(cx: &LateContext<'_>, item: &hir::Item<'_>) {
     if let hir::ItemKind::Fn(ref sig, ref _generics, _) = item.kind {
         let is_public = cx.access_levels.is_exported(item.def_id);
         let fn_header_span = item.span.with_hi(sig.decl.output.span().hi());
@@ -23,7 +23,7 @@ pub(super) fn check_item(cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) {
     }
 }
 
-pub(super) fn check_impl_item(cx: &LateContext<'tcx>, item: &'tcx hir::ImplItem<'_>) {
+pub(super) fn check_impl_item(cx: &LateContext<'_>, item: &hir::ImplItem<'_>) {
     if let hir::ImplItemKind::Fn(ref sig, _) = item.kind {
         let is_public = cx.access_levels.is_exported(item.def_id);
         let fn_header_span = item.span.with_hi(sig.decl.output.span().hi());
@@ -33,7 +33,7 @@ pub(super) fn check_impl_item(cx: &LateContext<'tcx>, item: &'tcx hir::ImplItem<
     }
 }
 
-pub(super) fn check_trait_item(cx: &LateContext<'tcx>, item: &'tcx hir::TraitItem<'_>) {
+pub(super) fn check_trait_item(cx: &LateContext<'_>, item: &hir::TraitItem<'_>) {
     if let hir::TraitItemKind::Fn(ref sig, _) = item.kind {
         let is_public = cx.access_levels.is_exported(item.def_id);
         let fn_header_span = item.span.with_hi(sig.decl.output.span().hi());
diff --git a/clippy_lints/src/functions/too_many_arguments.rs b/clippy_lints/src/functions/too_many_arguments.rs
index 63a14d8d4cd..3af960491ed 100644
--- a/clippy_lints/src/functions/too_many_arguments.rs
+++ b/clippy_lints/src/functions/too_many_arguments.rs
@@ -9,9 +9,9 @@ use clippy_utils::is_trait_impl_item;
 use super::TOO_MANY_ARGUMENTS;
 
 pub(super) fn check_fn(
-    cx: &LateContext<'tcx>,
-    kind: intravisit::FnKind<'tcx>,
-    decl: &'tcx hir::FnDecl<'_>,
+    cx: &LateContext<'_>,
+    kind: intravisit::FnKind<'_>,
+    decl: &hir::FnDecl<'_>,
     span: Span,
     hir_id: hir::HirId,
     too_many_arguments_threshold: u64,
@@ -39,11 +39,7 @@ pub(super) fn check_fn(
     }
 }
 
-pub(super) fn check_trait_item(
-    cx: &LateContext<'tcx>,
-    item: &'tcx hir::TraitItem<'_>,
-    too_many_arguments_threshold: u64,
-) {
+pub(super) fn check_trait_item(cx: &LateContext<'_>, item: &hir::TraitItem<'_>, too_many_arguments_threshold: u64) {
     if let hir::TraitItemKind::Fn(ref sig, _) = item.kind {
         // don't lint extern functions decls, it's not their fault
         if sig.header.abi == Abi::Rust {
diff --git a/clippy_lints/src/functions/too_many_lines.rs b/clippy_lints/src/functions/too_many_lines.rs
index 65efbbab41a..54bdea7ea25 100644
--- a/clippy_lints/src/functions/too_many_lines.rs
+++ b/clippy_lints/src/functions/too_many_lines.rs
@@ -11,9 +11,9 @@ use super::TOO_MANY_LINES;
 
 pub(super) fn check_fn(
     cx: &LateContext<'_>,
-    kind: FnKind<'tcx>,
+    kind: FnKind<'_>,
     span: Span,
-    body: &'tcx hir::Body<'_>,
+    body: &hir::Body<'_>,
     too_many_lines_threshold: u64,
 ) {
     // Closures must be contained in a parent body, which will be checked for `too_many_lines`.
diff --git a/clippy_lints/src/if_then_some_else_none.rs b/clippy_lints/src/if_then_some_else_none.rs
index 16e5c5ca603..9525c163ece 100644
--- a/clippy_lints/src/if_then_some_else_none.rs
+++ b/clippy_lints/src/if_then_some_else_none.rs
@@ -55,7 +55,7 @@ impl IfThenSomeElseNone {
 
 impl_lint_pass!(IfThenSomeElseNone => [IF_THEN_SOME_ELSE_NONE]);
 
-impl LateLintPass<'_> for IfThenSomeElseNone {
+impl<'tcx> LateLintPass<'tcx> for IfThenSomeElseNone {
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &'tcx Expr<'_>) {
         if !meets_msrv(self.msrv.as_ref(), &msrvs::BOOL_THEN) {
             return;
diff --git a/clippy_lints/src/implicit_return.rs b/clippy_lints/src/implicit_return.rs
index 07caeada80d..d650d6e9a85 100644
--- a/clippy_lints/src/implicit_return.rs
+++ b/clippy_lints/src/implicit_return.rs
@@ -94,8 +94,8 @@ fn get_call_site(span: Span, ctxt: SyntaxContext) -> Option<Span> {
 }
 
 fn lint_implicit_returns(
-    cx: &LateContext<'tcx>,
-    expr: &'tcx Expr<'_>,
+    cx: &LateContext<'_>,
+    expr: &Expr<'_>,
     // The context of the function body.
     ctxt: SyntaxContext,
     // Whether the expression is from a macro expansion.
diff --git a/clippy_lints/src/inconsistent_struct_constructor.rs b/clippy_lints/src/inconsistent_struct_constructor.rs
index 1debdef9d86..9e03065e7fb 100644
--- a/clippy_lints/src/inconsistent_struct_constructor.rs
+++ b/clippy_lints/src/inconsistent_struct_constructor.rs
@@ -63,7 +63,7 @@ declare_clippy_lint! {
 
 declare_lint_pass!(InconsistentStructConstructor => [INCONSISTENT_STRUCT_CONSTRUCTOR]);
 
-impl LateLintPass<'_> for InconsistentStructConstructor {
+impl<'tcx> LateLintPass<'tcx> for InconsistentStructConstructor {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
         if_chain! {
             if !expr.span.from_expansion();
diff --git a/clippy_lints/src/index_refutable_slice.rs b/clippy_lints/src/index_refutable_slice.rs
index 69f1c90beec..073313e2bad 100644
--- a/clippy_lints/src/index_refutable_slice.rs
+++ b/clippy_lints/src/index_refutable_slice.rs
@@ -69,7 +69,7 @@ impl IndexRefutableSlice {
 
 impl_lint_pass!(IndexRefutableSlice => [INDEX_REFUTABLE_SLICE]);
 
-impl LateLintPass<'_> for IndexRefutableSlice {
+impl<'tcx> LateLintPass<'tcx> for IndexRefutableSlice {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
         if_chain! {
             if !expr.span.from_expansion() || is_expn_of(expr.span, "if_chain").is_some();
diff --git a/clippy_lints/src/iter_not_returning_iterator.rs b/clippy_lints/src/iter_not_returning_iterator.rs
index 017a8a779d9..d3bdc819a9f 100644
--- a/clippy_lints/src/iter_not_returning_iterator.rs
+++ b/clippy_lints/src/iter_not_returning_iterator.rs
@@ -39,7 +39,7 @@ declare_clippy_lint! {
 
 declare_lint_pass!(IterNotReturningIterator => [ITER_NOT_RETURNING_ITERATOR]);
 
-impl LateLintPass<'_> for IterNotReturningIterator {
+impl<'tcx> LateLintPass<'tcx> for IterNotReturningIterator {
     fn check_trait_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx TraitItem<'_>) {
         let name = item.ident.name.as_str();
         if matches!(name, "iter" | "iter_mut") {
diff --git a/clippy_lints/src/len_zero.rs b/clippy_lints/src/len_zero.rs
index 20e6220ec7d..265c24b1c97 100644
--- a/clippy_lints/src/len_zero.rs
+++ b/clippy_lints/src/len_zero.rs
@@ -245,7 +245,7 @@ enum LenOutput<'tcx> {
     Option(DefId),
     Result(DefId, Ty<'tcx>),
 }
-fn parse_len_output(cx: &LateContext<'_>, sig: FnSig<'tcx>) -> Option<LenOutput<'tcx>> {
+fn parse_len_output<'tcx>(cx: &LateContext<'_>, sig: FnSig<'tcx>) -> Option<LenOutput<'tcx>> {
     match *sig.output().kind() {
         ty::Int(_) | ty::Uint(_) => Some(LenOutput::Integral),
         ty::Adt(adt, subs) if cx.tcx.is_diagnostic_item(sym::Option, adt.did) => {
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 0d765c2bcde..175a35e7994 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -4,7 +4,6 @@
 #![feature(box_patterns)]
 #![feature(control_flow_enum)]
 #![feature(drain_filter)]
-#![feature(in_band_lifetimes)]
 #![feature(iter_intersperse)]
 #![feature(let_else)]
 #![feature(once_cell)]
diff --git a/clippy_lints/src/loops/empty_loop.rs b/clippy_lints/src/loops/empty_loop.rs
index dda09fecdf9..823cf0f4322 100644
--- a/clippy_lints/src/loops/empty_loop.rs
+++ b/clippy_lints/src/loops/empty_loop.rs
@@ -5,7 +5,7 @@ use clippy_utils::{is_in_panic_handler, is_no_std_crate};
 use rustc_hir::{Block, Expr};
 use rustc_lint::LateContext;
 
-pub(super) fn check(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, loop_block: &'tcx Block<'_>) {
+pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, loop_block: &Block<'_>) {
     if loop_block.stmts.is_empty() && loop_block.expr.is_none() && !is_in_panic_handler(cx, expr) {
         let msg = "empty `loop {}` wastes CPU cycles";
         let help = if is_no_std_crate(cx) {
diff --git a/clippy_lints/src/loops/explicit_into_iter_loop.rs b/clippy_lints/src/loops/explicit_into_iter_loop.rs
index 1bab0d99b69..17246cc5426 100644
--- a/clippy_lints/src/loops/explicit_into_iter_loop.rs
+++ b/clippy_lints/src/loops/explicit_into_iter_loop.rs
@@ -8,7 +8,7 @@ use rustc_lint::LateContext;
 use rustc_middle::ty::TyS;
 use rustc_span::symbol::sym;
 
-pub(super) fn check(cx: &LateContext<'_>, self_arg: &'hir Expr<'hir>, call_expr: &Expr<'_>) {
+pub(super) fn check(cx: &LateContext<'_>, self_arg: &Expr<'_>, call_expr: &Expr<'_>) {
     let self_ty = cx.typeck_results().expr_ty(self_arg);
     let self_ty_adjusted = cx.typeck_results().expr_ty_adjusted(self_arg);
     if !(TyS::same_type(self_ty, self_ty_adjusted) && is_trait_method(cx, call_expr, sym::IntoIterator)) {
diff --git a/clippy_lints/src/loops/manual_memcpy.rs b/clippy_lints/src/loops/manual_memcpy.rs
index c62fa5e998b..c439f701da1 100644
--- a/clippy_lints/src/loops/manual_memcpy.rs
+++ b/clippy_lints/src/loops/manual_memcpy.rs
@@ -203,7 +203,7 @@ fn build_manual_memcpy_suggestion<'tcx>(
 #[derive(Clone)]
 struct MinifyingSugg<'a>(Sugg<'a>);
 
-impl Display for MinifyingSugg<'a> {
+impl<'a> Display for MinifyingSugg<'a> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         self.0.fmt(f)
     }
diff --git a/clippy_lints/src/loops/mut_range_bound.rs b/clippy_lints/src/loops/mut_range_bound.rs
index aedf0844937..37a57d8feb1 100644
--- a/clippy_lints/src/loops/mut_range_bound.rs
+++ b/clippy_lints/src/loops/mut_range_bound.rs
@@ -147,7 +147,7 @@ impl BreakAfterExprVisitor {
     }
 }
 
-impl intravisit::Visitor<'tcx> for BreakAfterExprVisitor {
+impl<'tcx> intravisit::Visitor<'tcx> for BreakAfterExprVisitor {
     type Map = Map<'tcx>;
 
     fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
diff --git a/clippy_lints/src/loops/needless_collect.rs b/clippy_lints/src/loops/needless_collect.rs
index ba895f35faa..6248680aa62 100644
--- a/clippy_lints/src/loops/needless_collect.rs
+++ b/clippy_lints/src/loops/needless_collect.rs
@@ -339,8 +339,8 @@ fn detect_iter_and_into_iters<'tcx: 'a, 'a>(
     }
 }
 
-fn get_captured_ids(cx: &LateContext<'tcx>, ty: &'_ TyS<'_>) -> HirIdSet {
-    fn get_captured_ids_recursive(cx: &LateContext<'tcx>, ty: &'_ TyS<'_>, set: &mut HirIdSet) {
+fn get_captured_ids(cx: &LateContext<'_>, ty: &'_ TyS<'_>) -> HirIdSet {
+    fn get_captured_ids_recursive(cx: &LateContext<'_>, ty: &'_ TyS<'_>, set: &mut HirIdSet) {
         match ty.kind() {
             ty::Adt(_, generics) => {
                 for generic in *generics {
diff --git a/clippy_lints/src/loops/never_loop.rs b/clippy_lints/src/loops/never_loop.rs
index a3aa6be6afd..bb1b3e2a1ec 100644
--- a/clippy_lints/src/loops/never_loop.rs
+++ b/clippy_lints/src/loops/never_loop.rs
@@ -10,8 +10,8 @@ use rustc_span::Span;
 use std::iter::{once, Iterator};
 
 pub(super) fn check(
-    cx: &LateContext<'tcx>,
-    block: &'tcx Block<'_>,
+    cx: &LateContext<'_>,
+    block: &Block<'_>,
     loop_id: HirId,
     span: Span,
     for_loop: Option<&ForLoop<'_>>,
diff --git a/clippy_lints/src/loops/while_let_loop.rs b/clippy_lints/src/loops/while_let_loop.rs
index 4dcd5c87722..8f57df0be6b 100644
--- a/clippy_lints/src/loops/while_let_loop.rs
+++ b/clippy_lints/src/loops/while_let_loop.rs
@@ -7,7 +7,7 @@ use rustc_hir::{Block, Expr, ExprKind, MatchSource, Pat, StmtKind};
 use rustc_lint::{LateContext, LintContext};
 use rustc_middle::lint::in_external_macro;
 
-pub(super) fn check(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, loop_block: &'tcx Block<'_>) {
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, loop_block: &'tcx Block<'_>) {
     // extract the expression from the first statement (if any) in a block
     let inner_stmt_expr = extract_expr_from_first_stmt(loop_block);
     // or extract the first expression (if any) from the block
diff --git a/clippy_lints/src/loops/while_let_on_iterator.rs b/clippy_lints/src/loops/while_let_on_iterator.rs
index 942d6ca6b4a..750328d1d01 100644
--- a/clippy_lints/src/loops/while_let_on_iterator.rs
+++ b/clippy_lints/src/loops/while_let_on_iterator.rs
@@ -13,7 +13,7 @@ use rustc_lint::LateContext;
 use rustc_middle::ty::adjustment::Adjust;
 use rustc_span::{symbol::sym, Symbol};
 
-pub(super) fn check(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
     let (scrutinee_expr, iter_expr_struct, iter_expr, some_pat, loop_expr) = if_chain! {
         if let Some(higher::WhileLet { if_then, let_pat, let_expr }) = higher::WhileLet::hir(expr);
         // check for `Some(..)` pattern
@@ -191,7 +191,7 @@ fn is_expr_same_child_or_parent_field(cx: &LateContext<'_>, expr: &Expr<'_>, fie
 
 /// Strips off all field and path expressions. This will return true if a field or path has been
 /// skipped. Used to skip them after failing to check for equality.
-fn skip_fields_and_path(expr: &'tcx Expr<'_>) -> (Option<&'tcx Expr<'tcx>>, bool) {
+fn skip_fields_and_path<'tcx>(expr: &'tcx Expr<'_>) -> (Option<&'tcx Expr<'tcx>>, bool) {
     let mut e = expr;
     let e = loop {
         match e.kind {
@@ -204,13 +204,13 @@ fn skip_fields_and_path(expr: &'tcx Expr<'_>) -> (Option<&'tcx Expr<'tcx>>, bool
 }
 
 /// Checks if the given expression uses the iterator.
-fn uses_iter(cx: &LateContext<'tcx>, iter_expr: &IterExpr, container: &'tcx Expr<'_>) -> bool {
+fn uses_iter<'tcx>(cx: &LateContext<'tcx>, iter_expr: &IterExpr, container: &'tcx Expr<'_>) -> bool {
     struct V<'a, 'b, 'tcx> {
         cx: &'a LateContext<'tcx>,
         iter_expr: &'b IterExpr,
         uses_iter: bool,
     }
-    impl Visitor<'tcx> for V<'_, '_, 'tcx> {
+    impl<'tcx> Visitor<'tcx> for V<'_, '_, 'tcx> {
         type Map = ErasedMap<'tcx>;
         fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
             NestedVisitorMap::None
@@ -245,7 +245,7 @@ fn uses_iter(cx: &LateContext<'tcx>, iter_expr: &IterExpr, container: &'tcx Expr
 }
 
 #[allow(clippy::too_many_lines)]
-fn needs_mutable_borrow(cx: &LateContext<'tcx>, iter_expr: &IterExpr, loop_expr: &'tcx Expr<'_>) -> bool {
+fn needs_mutable_borrow(cx: &LateContext<'_>, iter_expr: &IterExpr, loop_expr: &Expr<'_>) -> bool {
     struct AfterLoopVisitor<'a, 'b, 'tcx> {
         cx: &'a LateContext<'tcx>,
         iter_expr: &'b IterExpr,
@@ -253,7 +253,7 @@ fn needs_mutable_borrow(cx: &LateContext<'tcx>, iter_expr: &IterExpr, loop_expr:
         after_loop: bool,
         used_iter: bool,
     }
-    impl Visitor<'tcx> for AfterLoopVisitor<'_, '_, 'tcx> {
+    impl<'tcx> Visitor<'tcx> for AfterLoopVisitor<'_, '_, 'tcx> {
         type Map = ErasedMap<'tcx>;
         fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
             NestedVisitorMap::None
@@ -292,7 +292,7 @@ fn needs_mutable_borrow(cx: &LateContext<'tcx>, iter_expr: &IterExpr, loop_expr:
         found_local: bool,
         used_after: bool,
     }
-    impl Visitor<'tcx> for NestedLoopVisitor<'a, 'b, 'tcx> {
+    impl<'a, 'b, 'tcx> Visitor<'tcx> for NestedLoopVisitor<'a, 'b, 'tcx> {
         type Map = ErasedMap<'tcx>;
 
         fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
diff --git a/clippy_lints/src/manual_assert.rs b/clippy_lints/src/manual_assert.rs
index e3a34b22e32..26b53ab5d68 100644
--- a/clippy_lints/src/manual_assert.rs
+++ b/clippy_lints/src/manual_assert.rs
@@ -35,7 +35,7 @@ declare_clippy_lint! {
 
 declare_lint_pass!(ManualAssert => [MANUAL_ASSERT]);
 
-impl LateLintPass<'_> for ManualAssert {
+impl<'tcx> LateLintPass<'tcx> for ManualAssert {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &Expr<'tcx>) {
         if_chain! {
             if let ExprKind::If(cond, then, None) = expr.kind;
diff --git a/clippy_lints/src/manual_map.rs b/clippy_lints/src/manual_map.rs
index 34a70ca76c6..8475e367b09 100644
--- a/clippy_lints/src/manual_map.rs
+++ b/clippy_lints/src/manual_map.rs
@@ -45,7 +45,7 @@ declare_clippy_lint! {
 
 declare_lint_pass!(ManualMap => [MANUAL_MAP]);
 
-impl LateLintPass<'_> for ManualMap {
+impl<'tcx> LateLintPass<'tcx> for ManualMap {
     #[allow(clippy::too_many_lines)]
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         let (scrutinee, then_pat, then_body, else_pat, else_body) = match IfLetOrMatch::parse(cx, expr) {
@@ -219,7 +219,7 @@ impl LateLintPass<'_> for ManualMap {
 
 // Checks whether the expression could be passed as a function, or whether a closure is needed.
 // Returns the function to be passed to `map` if it exists.
-fn can_pass_as_func(cx: &LateContext<'tcx>, binding: HirId, expr: &'tcx Expr<'_>) -> Option<&'tcx Expr<'tcx>> {
+fn can_pass_as_func<'tcx>(cx: &LateContext<'tcx>, binding: HirId, expr: &'tcx Expr<'_>) -> Option<&'tcx Expr<'tcx>> {
     match expr.kind {
         ExprKind::Call(func, [arg])
             if path_to_local_id(arg, binding)
@@ -251,8 +251,13 @@ struct SomeExpr<'tcx> {
 
 // Try to parse into a recognized `Option` pattern.
 // i.e. `_`, `None`, `Some(..)`, or a reference to any of those.
-fn try_parse_pattern(cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>, ctxt: SyntaxContext) -> Option<OptionPat<'tcx>> {
-    fn f(cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>, ref_count: usize, ctxt: SyntaxContext) -> Option<OptionPat<'tcx>> {
+fn try_parse_pattern<'tcx>(cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>, ctxt: SyntaxContext) -> Option<OptionPat<'tcx>> {
+    fn f<'tcx>(
+        cx: &LateContext<'tcx>,
+        pat: &'tcx Pat<'_>,
+        ref_count: usize,
+        ctxt: SyntaxContext,
+    ) -> Option<OptionPat<'tcx>> {
         match pat.kind {
             PatKind::Wild => Some(OptionPat::Wild),
             PatKind::Ref(pat, _) => f(cx, pat, ref_count + 1, ctxt),
@@ -269,7 +274,7 @@ fn try_parse_pattern(cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>, ctxt: SyntaxCon
 }
 
 // Checks for an expression wrapped by the `Some` constructor. Returns the contained expression.
-fn get_some_expr(
+fn get_some_expr<'tcx>(
     cx: &LateContext<'tcx>,
     expr: &'tcx Expr<'_>,
     needs_unsafe_block: bool,
@@ -306,6 +311,6 @@ fn get_some_expr(
 }
 
 // Checks for the `None` value.
-fn is_none_expr(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> bool {
+fn is_none_expr(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
     matches!(peel_blocks(expr).kind, ExprKind::Path(ref qpath) if is_lang_ctor(cx, qpath, OptionNone))
 }
diff --git a/clippy_lints/src/manual_ok_or.rs b/clippy_lints/src/manual_ok_or.rs
index b60e2dc366b..bd083e3e9e2 100644
--- a/clippy_lints/src/manual_ok_or.rs
+++ b/clippy_lints/src/manual_ok_or.rs
@@ -40,7 +40,7 @@ declare_clippy_lint! {
 
 declare_lint_pass!(ManualOkOr => [MANUAL_OK_OR]);
 
-impl LateLintPass<'_> for ManualOkOr {
+impl<'tcx> LateLintPass<'tcx> for ManualOkOr {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, scrutinee: &'tcx Expr<'tcx>) {
         if in_external_macro(cx.sess(), scrutinee.span) {
             return;
diff --git a/clippy_lints/src/manual_unwrap_or.rs b/clippy_lints/src/manual_unwrap_or.rs
index aac3c6e0de2..b3a91d9f18f 100644
--- a/clippy_lints/src/manual_unwrap_or.rs
+++ b/clippy_lints/src/manual_unwrap_or.rs
@@ -43,7 +43,7 @@ declare_clippy_lint! {
 
 declare_lint_pass!(ManualUnwrapOr => [MANUAL_UNWRAP_OR]);
 
-impl LateLintPass<'_> for ManualUnwrapOr {
+impl<'tcx> LateLintPass<'tcx> for ManualUnwrapOr {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
         if in_external_macro(cx.sess(), expr.span) || in_constant(cx, expr.hir_id) {
             return;
diff --git a/clippy_lints/src/match_str_case_mismatch.rs b/clippy_lints/src/match_str_case_mismatch.rs
index 2c0fc218ca0..1fc7eb72142 100644
--- a/clippy_lints/src/match_str_case_mismatch.rs
+++ b/clippy_lints/src/match_str_case_mismatch.rs
@@ -55,7 +55,7 @@ enum CaseMethod {
     AsciiUppercase,
 }
 
-impl LateLintPass<'_> for MatchStrCaseMismatch {
+impl<'tcx> LateLintPass<'tcx> for MatchStrCaseMismatch {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if_chain! {
             if !in_external_macro(cx.tcx.sess, expr.span);
diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index 0d693499bc6..66c1886710f 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -999,7 +999,7 @@ enum CommonPrefixSearcher<'a> {
     Path(&'a [PathSegment<'a>]),
     Mixed,
 }
-impl CommonPrefixSearcher<'a> {
+impl<'a> CommonPrefixSearcher<'a> {
     fn with_path(&mut self, path: &'a [PathSegment<'a>]) {
         match path {
             [path @ .., _] => self.with_prefix(path),
@@ -1804,11 +1804,15 @@ mod redundant_pattern_match {
     /// Checks if the drop order for a type matters. Some std types implement drop solely to
     /// deallocate memory. For these types, and composites containing them, changing the drop order
     /// won't result in any observable side effects.
-    fn type_needs_ordered_drop(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
+    fn type_needs_ordered_drop<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
         type_needs_ordered_drop_inner(cx, ty, &mut FxHashSet::default())
     }
 
-    fn type_needs_ordered_drop_inner(cx: &LateContext<'tcx>, ty: Ty<'tcx>, seen: &mut FxHashSet<Ty<'tcx>>) -> bool {
+    fn type_needs_ordered_drop_inner<'tcx>(
+        cx: &LateContext<'tcx>,
+        ty: Ty<'tcx>,
+        seen: &mut FxHashSet<Ty<'tcx>>,
+    ) -> bool {
         if !seen.insert(ty) {
             return false;
         }
@@ -1870,7 +1874,7 @@ mod redundant_pattern_match {
 
     // Checks if there are any temporaries created in the given expression for which drop order
     // matters.
-    fn temporaries_need_ordered_drop(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
+    fn temporaries_need_ordered_drop<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
         struct V<'a, 'tcx> {
             cx: &'a LateContext<'tcx>,
             res: bool,
diff --git a/clippy_lints/src/methods/expect_fun_call.rs b/clippy_lints/src/methods/expect_fun_call.rs
index 866eaff5b1d..0f39470f342 100644
--- a/clippy_lints/src/methods/expect_fun_call.rs
+++ b/clippy_lints/src/methods/expect_fun_call.rs
@@ -14,7 +14,7 @@ use super::EXPECT_FUN_CALL;
 
 /// Checks for the `EXPECT_FUN_CALL` lint.
 #[allow(clippy::too_many_lines)]
-pub(super) fn check(
+pub(super) fn check<'tcx>(
     cx: &LateContext<'tcx>,
     expr: &hir::Expr<'_>,
     method_span: Span,
diff --git a/clippy_lints/src/methods/from_iter_instead_of_collect.rs b/clippy_lints/src/methods/from_iter_instead_of_collect.rs
index 8ea9312c0f7..6436e28a63c 100644
--- a/clippy_lints/src/methods/from_iter_instead_of_collect.rs
+++ b/clippy_lints/src/methods/from_iter_instead_of_collect.rs
@@ -37,7 +37,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::Exp
     }
 }
 
-fn extract_turbofish(cx: &LateContext<'_>, expr: &hir::Expr<'_>, ty: Ty<'tcx>) -> String {
+fn extract_turbofish(cx: &LateContext<'_>, expr: &hir::Expr<'_>, ty: Ty<'_>) -> String {
     fn strip_angle_brackets(s: &str) -> Option<&str> {
         s.strip_prefix('<')?.strip_suffix('>')
     }
diff --git a/clippy_lints/src/methods/str_splitn.rs b/clippy_lints/src/methods/str_splitn.rs
index 70f20da1d6d..514bdadc442 100644
--- a/clippy_lints/src/methods/str_splitn.rs
+++ b/clippy_lints/src/methods/str_splitn.rs
@@ -124,7 +124,7 @@ struct IterUsage {
 }
 
 #[allow(clippy::too_many_lines)]
-fn parse_iter_usage(
+fn parse_iter_usage<'tcx>(
     cx: &LateContext<'tcx>,
     ctxt: SyntaxContext,
     mut iter: impl Iterator<Item = (HirId, Node<'tcx>)>,
@@ -281,7 +281,7 @@ pub(super) fn check_needless_splitn(
     }
 }
 
-fn check_iter(
+fn check_iter<'tcx>(
     cx: &LateContext<'tcx>,
     ctxt: SyntaxContext,
     mut iter: impl Iterator<Item = (HirId, Node<'tcx>)>,
diff --git a/clippy_lints/src/methods/unnecessary_iter_cloned.rs b/clippy_lints/src/methods/unnecessary_iter_cloned.rs
index 4f589a6d318..5999245ea7d 100644
--- a/clippy_lints/src/methods/unnecessary_iter_cloned.rs
+++ b/clippy_lints/src/methods/unnecessary_iter_cloned.rs
@@ -12,7 +12,7 @@ use rustc_span::{sym, Symbol};
 
 use super::UNNECESSARY_TO_OWNED;
 
-pub fn check(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, method_name: Symbol, receiver: &'tcx Expr<'tcx>) -> bool {
+pub fn check(cx: &LateContext<'_>, expr: &Expr<'_>, method_name: Symbol, receiver: &Expr<'_>) -> bool {
     if_chain! {
         if let Some(parent) = get_parent_expr(cx, expr);
         if let Some(callee_def_id) = fn_def_id(cx, parent);
@@ -30,10 +30,10 @@ pub fn check(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, method_name: Symbol
 /// include this code directly is so that it can be called from
 /// `unnecessary_into_owned::check_into_iter_call_arg`.
 pub fn check_for_loop_iter(
-    cx: &LateContext<'tcx>,
-    expr: &'tcx Expr<'tcx>,
+    cx: &LateContext<'_>,
+    expr: &Expr<'_>,
     method_name: Symbol,
-    receiver: &'tcx Expr<'tcx>,
+    receiver: &Expr<'_>,
     cloned_before_iter: bool,
 ) -> bool {
     if_chain! {
@@ -101,7 +101,7 @@ pub fn check_for_loop_iter(
 
 /// The core logic of `check_for_loop_iter` above, this function wraps a use of
 /// `CloneOrCopyVisitor`.
-fn clone_or_copy_needed(
+fn clone_or_copy_needed<'tcx>(
     cx: &LateContext<'tcx>,
     pat: &Pat<'tcx>,
     body: &'tcx Expr<'tcx>,
diff --git a/clippy_lints/src/methods/unnecessary_to_owned.rs b/clippy_lints/src/methods/unnecessary_to_owned.rs
index 7e17f163b21..e5b6d296b2d 100644
--- a/clippy_lints/src/methods/unnecessary_to_owned.rs
+++ b/clippy_lints/src/methods/unnecessary_to_owned.rs
@@ -16,7 +16,7 @@ use std::cmp::max;
 
 use super::UNNECESSARY_TO_OWNED;
 
-pub fn check(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, method_name: Symbol, args: &'tcx [Expr<'tcx>]) {
+pub fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, method_name: Symbol, args: &'tcx [Expr<'tcx>]) {
     if_chain! {
         if let Some(method_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
         if let [receiver] = args;
@@ -44,11 +44,11 @@ pub fn check(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, method_name: Symbol
 /// call of a `to_owned`-like function is unnecessary.
 #[allow(clippy::too_many_lines)]
 fn check_addr_of_expr(
-    cx: &LateContext<'tcx>,
-    expr: &'tcx Expr<'tcx>,
+    cx: &LateContext<'_>,
+    expr: &Expr<'_>,
     method_name: Symbol,
     method_def_id: DefId,
-    receiver: &'tcx Expr<'tcx>,
+    receiver: &Expr<'_>,
 ) -> bool {
     if_chain! {
         if let Some(parent) = get_parent_expr(cx, expr);
@@ -171,12 +171,7 @@ fn check_addr_of_expr(
 
 /// Checks whether `expr` is an argument in an `into_iter` call and, if so, determines whether its
 /// call of a `to_owned`-like function is unnecessary.
-fn check_into_iter_call_arg(
-    cx: &LateContext<'tcx>,
-    expr: &'tcx Expr<'tcx>,
-    method_name: Symbol,
-    receiver: &'tcx Expr<'tcx>,
-) -> bool {
+fn check_into_iter_call_arg(cx: &LateContext<'_>, expr: &Expr<'_>, method_name: Symbol, receiver: &Expr<'_>) -> bool {
     if_chain! {
         if let Some(parent) = get_parent_expr(cx, expr);
         if let Some(callee_def_id) = fn_def_id(cx, parent);
@@ -221,7 +216,7 @@ fn check_into_iter_call_arg(
 
 /// Checks whether `expr` is an argument in a function call and, if so, determines whether its call
 /// of a `to_owned`-like function is unnecessary.
-fn check_other_call_arg(
+fn check_other_call_arg<'tcx>(
     cx: &LateContext<'tcx>,
     expr: &'tcx Expr<'tcx>,
     method_name: Symbol,
@@ -287,7 +282,7 @@ fn check_other_call_arg(
 
 /// Walks an expression's ancestors until it finds a non-`AddrOf` expression. Returns the first such
 /// expression found (if any) along with the immediately prior expression.
-fn skip_addr_of_ancestors(
+fn skip_addr_of_ancestors<'tcx>(
     cx: &LateContext<'tcx>,
     mut expr: &'tcx Expr<'tcx>,
 ) -> Option<(&'tcx Expr<'tcx>, &'tcx Expr<'tcx>)> {
@@ -303,7 +298,7 @@ fn skip_addr_of_ancestors(
 
 /// Checks whether an expression is a function or method call and, if so, returns its `DefId`,
 /// `Substs`, and arguments.
-fn get_callee_substs_and_args(
+fn get_callee_substs_and_args<'tcx>(
     cx: &LateContext<'tcx>,
     expr: &'tcx Expr<'tcx>,
 ) -> Option<(DefId, SubstsRef<'tcx>, &'tcx [Expr<'tcx>])> {
@@ -328,7 +323,7 @@ fn get_callee_substs_and_args(
 }
 
 /// Returns the `TraitPredicate`s and `ProjectionPredicate`s for a function's input type.
-fn get_input_traits_and_projections(
+fn get_input_traits_and_projections<'tcx>(
     cx: &LateContext<'tcx>,
     callee_def_id: DefId,
     input: Ty<'tcx>,
@@ -368,7 +363,11 @@ fn get_input_traits_and_projections(
 }
 
 /// Composes two substitutions by applying the latter to the types of the former.
-fn compose_substs(cx: &LateContext<'tcx>, left: &[GenericArg<'tcx>], right: SubstsRef<'tcx>) -> Vec<GenericArg<'tcx>> {
+fn compose_substs<'tcx>(
+    cx: &LateContext<'tcx>,
+    left: &[GenericArg<'tcx>],
+    right: SubstsRef<'tcx>,
+) -> Vec<GenericArg<'tcx>> {
     left.iter()
         .map(|arg| {
             if let GenericArgKind::Type(arg_ty) = arg.unpack() {
diff --git a/clippy_lints/src/misc.rs b/clippy_lints/src/misc.rs
index 401dc27811d..21b3f81d5d9 100644
--- a/clippy_lints/src/misc.rs
+++ b/clippy_lints/src/misc.rs
@@ -717,7 +717,7 @@ fn check_cast(cx: &LateContext<'_>, span: Span, e: &Expr<'_>, ty: &hir::Ty<'_>)
     }
 }
 
-fn check_binary(
+fn check_binary<'a>(
     cx: &LateContext<'a>,
     expr: &Expr<'_>,
     cmp: &rustc_span::source_map::Spanned<rustc_hir::BinOpKind>,
diff --git a/clippy_lints/src/needless_for_each.rs b/clippy_lints/src/needless_for_each.rs
index 0c1da035173..19d58f7474b 100644
--- a/clippy_lints/src/needless_for_each.rs
+++ b/clippy_lints/src/needless_for_each.rs
@@ -48,7 +48,7 @@ declare_clippy_lint! {
 
 declare_lint_pass!(NeedlessForEach => [NEEDLESS_FOR_EACH]);
 
-impl LateLintPass<'_> for NeedlessForEach {
+impl<'tcx> LateLintPass<'tcx> for NeedlessForEach {
     fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) {
         let expr = match stmt.kind {
             StmtKind::Expr(expr) | StmtKind::Semi(expr) => expr,
diff --git a/clippy_lints/src/needless_late_init.rs b/clippy_lints/src/needless_late_init.rs
index 094a3f111ba..9957afcbf04 100644
--- a/clippy_lints/src/needless_late_init.rs
+++ b/clippy_lints/src/needless_late_init.rs
@@ -330,7 +330,7 @@ fn check<'tcx>(
     Some(())
 }
 
-impl LateLintPass<'tcx> for NeedlessLateInit {
+impl<'tcx> LateLintPass<'tcx> for NeedlessLateInit {
     fn check_local(&mut self, cx: &LateContext<'tcx>, local: &'tcx Local<'tcx>) {
         let mut parents = cx.tcx.hir().parent_iter(local.hir_id);
 
diff --git a/clippy_lints/src/no_effect.rs b/clippy_lints/src/no_effect.rs
index 9d5babc5de8..5bf8a1ba1ca 100644
--- a/clippy_lints/src/no_effect.rs
+++ b/clippy_lints/src/no_effect.rs
@@ -82,7 +82,7 @@ impl<'tcx> LateLintPass<'tcx> for NoEffect {
     }
 }
 
-fn check_no_effect(cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) -> bool {
+fn check_no_effect(cx: &LateContext<'_>, stmt: &Stmt<'_>) -> bool {
     if let StmtKind::Semi(expr) = stmt.kind {
         if has_no_effect(cx, expr) {
             span_lint_hir(cx, NO_EFFECT, expr.hir_id, stmt.span, "statement with no effect");
@@ -155,7 +155,7 @@ fn has_no_effect(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
     }
 }
 
-fn check_unnecessary_operation(cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) {
+fn check_unnecessary_operation(cx: &LateContext<'_>, stmt: &Stmt<'_>) {
     if_chain! {
         if let StmtKind::Semi(expr) = stmt.kind;
         if let Some(reduced) = reduce_expression(cx, expr);
diff --git a/clippy_lints/src/non_octal_unix_permissions.rs b/clippy_lints/src/non_octal_unix_permissions.rs
index 4b57dbc4c41..e46fee4cac5 100644
--- a/clippy_lints/src/non_octal_unix_permissions.rs
+++ b/clippy_lints/src/non_octal_unix_permissions.rs
@@ -40,7 +40,7 @@ declare_clippy_lint! {
 
 declare_lint_pass!(NonOctalUnixPermissions => [NON_OCTAL_UNIX_PERMISSIONS]);
 
-impl LateLintPass<'_> for NonOctalUnixPermissions {
+impl<'tcx> LateLintPass<'tcx> for NonOctalUnixPermissions {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
         match &expr.kind {
             ExprKind::MethodCall(path, _, [func, param], _) => {
diff --git a/clippy_lints/src/octal_escapes.rs b/clippy_lints/src/octal_escapes.rs
index 9c971437645..e0da12f77fc 100644
--- a/clippy_lints/src/octal_escapes.rs
+++ b/clippy_lints/src/octal_escapes.rs
@@ -50,7 +50,7 @@ declare_clippy_lint! {
 declare_lint_pass!(OctalEscapes => [OCTAL_ESCAPES]);
 
 impl EarlyLintPass for OctalEscapes {
-    fn check_expr(&mut self, cx: &EarlyContext<'tcx>, expr: &Expr) {
+    fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
         if in_external_macro(cx.sess, expr.span) {
             return;
         }
@@ -65,7 +65,7 @@ impl EarlyLintPass for OctalEscapes {
     }
 }
 
-fn check_lit(cx: &EarlyContext<'tcx>, lit: &Lit, span: Span, is_string: bool) {
+fn check_lit(cx: &EarlyContext<'_>, lit: &Lit, span: Span, is_string: bool) {
     let contents = lit.symbol.as_str();
     let mut iter = contents.char_indices().peekable();
     let mut found = vec![];
diff --git a/clippy_lints/src/ptr_eq.rs b/clippy_lints/src/ptr_eq.rs
index 3c126fc1ca6..2bec93ac606 100644
--- a/clippy_lints/src/ptr_eq.rs
+++ b/clippy_lints/src/ptr_eq.rs
@@ -39,7 +39,7 @@ declare_lint_pass!(PtrEq => [PTR_EQ]);
 
 static LINT_MSG: &str = "use `std::ptr::eq` when comparing raw pointers";
 
-impl LateLintPass<'_> for PtrEq {
+impl<'tcx> LateLintPass<'tcx> for PtrEq {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if expr.span.from_expansion() {
             return;
diff --git a/clippy_lints/src/redundant_slicing.rs b/clippy_lints/src/redundant_slicing.rs
index b2bd0103d11..7c88b42ea31 100644
--- a/clippy_lints/src/redundant_slicing.rs
+++ b/clippy_lints/src/redundant_slicing.rs
@@ -42,7 +42,7 @@ declare_clippy_lint! {
 
 declare_lint_pass!(RedundantSlicing => [REDUNDANT_SLICING]);
 
-impl LateLintPass<'_> for RedundantSlicing {
+impl<'tcx> LateLintPass<'tcx> for RedundantSlicing {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if expr.span.from_expansion() {
             return;
diff --git a/clippy_lints/src/return_self_not_must_use.rs b/clippy_lints/src/return_self_not_must_use.rs
index 935bbc37d75..5dafd08cf3b 100644
--- a/clippy_lints/src/return_self_not_must_use.rs
+++ b/clippy_lints/src/return_self_not_must_use.rs
@@ -66,7 +66,7 @@ declare_clippy_lint! {
 
 declare_lint_pass!(ReturnSelfNotMustUse => [RETURN_SELF_NOT_MUST_USE]);
 
-fn check_method(cx: &LateContext<'tcx>, decl: &'tcx FnDecl<'tcx>, fn_def: LocalDefId, span: Span, hir_id: HirId) {
+fn check_method(cx: &LateContext<'_>, decl: &FnDecl<'_>, fn_def: LocalDefId, span: Span, hir_id: HirId) {
     if_chain! {
         // If it comes from an external macro, better ignore it.
         if !in_external_macro(cx.sess(), span);
diff --git a/clippy_lints/src/semicolon_if_nothing_returned.rs b/clippy_lints/src/semicolon_if_nothing_returned.rs
index 0b3bbbc8155..729694da46d 100644
--- a/clippy_lints/src/semicolon_if_nothing_returned.rs
+++ b/clippy_lints/src/semicolon_if_nothing_returned.rs
@@ -37,7 +37,7 @@ declare_clippy_lint! {
 
 declare_lint_pass!(SemicolonIfNothingReturned => [SEMICOLON_IF_NOTHING_RETURNED]);
 
-impl LateLintPass<'_> for SemicolonIfNothingReturned {
+impl<'tcx> LateLintPass<'tcx> for SemicolonIfNothingReturned {
     fn check_block(&mut self, cx: &LateContext<'tcx>, block: &'tcx Block<'tcx>) {
         if_chain! {
             if !block.span.from_expansion();
diff --git a/clippy_lints/src/size_of_in_element_count.rs b/clippy_lints/src/size_of_in_element_count.rs
index df1e85afdd7..9b195f3c0a2 100644
--- a/clippy_lints/src/size_of_in_element_count.rs
+++ b/clippy_lints/src/size_of_in_element_count.rs
@@ -37,7 +37,7 @@ declare_clippy_lint! {
 
 declare_lint_pass!(SizeOfInElementCount => [SIZE_OF_IN_ELEMENT_COUNT]);
 
-fn get_size_of_ty(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, inverted: bool) -> Option<Ty<'tcx>> {
+fn get_size_of_ty<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, inverted: bool) -> Option<Ty<'tcx>> {
     match expr.kind {
         ExprKind::Call(count_func, _func_args) => {
             if_chain! {
@@ -64,7 +64,10 @@ fn get_size_of_ty(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, inverted: bool)
     }
 }
 
-fn get_pointee_ty_and_count_expr(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<(Ty<'tcx>, &'tcx Expr<'tcx>)> {
+fn get_pointee_ty_and_count_expr<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx Expr<'_>,
+) -> Option<(Ty<'tcx>, &'tcx Expr<'tcx>)> {
     const FUNCTIONS: [&[&str]; 8] = [
         &paths::PTR_COPY_NONOVERLAPPING,
         &paths::PTR_COPY,
diff --git a/clippy_lints/src/strings.rs b/clippy_lints/src/strings.rs
index ad8e72ad764..b4a71aefd43 100644
--- a/clippy_lints/src/strings.rs
+++ b/clippy_lints/src/strings.rs
@@ -381,7 +381,7 @@ declare_clippy_lint! {
 
 declare_lint_pass!(StrToString => [STR_TO_STRING]);
 
-impl LateLintPass<'_> for StrToString {
+impl<'tcx> LateLintPass<'tcx> for StrToString {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &Expr<'_>) {
         if_chain! {
             if let ExprKind::MethodCall(path, _, [self_arg, ..], _) = &expr.kind;
@@ -431,7 +431,7 @@ declare_clippy_lint! {
 
 declare_lint_pass!(StringToString => [STRING_TO_STRING]);
 
-impl LateLintPass<'_> for StringToString {
+impl<'tcx> LateLintPass<'tcx> for StringToString {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &Expr<'_>) {
         if_chain! {
             if let ExprKind::MethodCall(path, _, [self_arg, ..], _) = &expr.kind;
diff --git a/clippy_lints/src/strlen_on_c_strings.rs b/clippy_lints/src/strlen_on_c_strings.rs
index fee01fb0bd1..d6e948a7560 100644
--- a/clippy_lints/src/strlen_on_c_strings.rs
+++ b/clippy_lints/src/strlen_on_c_strings.rs
@@ -39,7 +39,7 @@ declare_clippy_lint! {
 
 declare_lint_pass!(StrlenOnCStrings => [STRLEN_ON_C_STRINGS]);
 
-impl LateLintPass<'tcx> for StrlenOnCStrings {
+impl<'tcx> LateLintPass<'tcx> for StrlenOnCStrings {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if_chain! {
             if !expr.span.from_expansion();
diff --git a/clippy_lints/src/suspicious_operation_groupings.rs b/clippy_lints/src/suspicious_operation_groupings.rs
index faf43fd9fc1..ca725918e87 100644
--- a/clippy_lints/src/suspicious_operation_groupings.rs
+++ b/clippy_lints/src/suspicious_operation_groupings.rs
@@ -355,7 +355,7 @@ struct BinaryOp<'exprs> {
     right: &'exprs Expr,
 }
 
-impl BinaryOp<'exprs> {
+impl<'exprs> BinaryOp<'exprs> {
     fn new(op: BinOpKind, span: Span, (left, right): (&'exprs Expr, &'exprs Expr)) -> Self {
         Self { op, span, left, right }
     }
@@ -419,7 +419,7 @@ fn chained_binops(kind: &ExprKind) -> Option<Vec<BinaryOp<'_>>> {
     }
 }
 
-fn chained_binops_helper(left_outer: &'expr Expr, right_outer: &'expr Expr) -> Option<Vec<BinaryOp<'expr>>> {
+fn chained_binops_helper<'expr>(left_outer: &'expr Expr, right_outer: &'expr Expr) -> Option<Vec<BinaryOp<'expr>>> {
     match (&left_outer.kind, &right_outer.kind) {
         (
             ExprKind::Paren(ref left_e) | ExprKind::Unary(_, ref left_e),
diff --git a/clippy_lints/src/trailing_empty_array.rs b/clippy_lints/src/trailing_empty_array.rs
index 47c0a84cd46..bf1cbf4f692 100644
--- a/clippy_lints/src/trailing_empty_array.rs
+++ b/clippy_lints/src/trailing_empty_array.rs
@@ -53,7 +53,7 @@ impl<'tcx> LateLintPass<'tcx> for TrailingEmptyArray {
     }
 }
 
-fn is_struct_with_trailing_zero_sized_array(cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) -> bool {
+fn is_struct_with_trailing_zero_sized_array(cx: &LateContext<'_>, item: &Item<'_>) -> bool {
     if_chain! {
         // First check if last field is an array
         if let ItemKind::Struct(data, _) = &item.kind;
diff --git a/clippy_lints/src/undocumented_unsafe_blocks.rs b/clippy_lints/src/undocumented_unsafe_blocks.rs
index 3d3b4a6679d..697ed267e2f 100644
--- a/clippy_lints/src/undocumented_unsafe_blocks.rs
+++ b/clippy_lints/src/undocumented_unsafe_blocks.rs
@@ -113,8 +113,8 @@ impl LateLintPass<'_> for UndocumentedUnsafeBlocks {
     }
 }
 
-impl<'hir> Visitor<'hir> for UndocumentedUnsafeBlocks {
-    type Map = Map<'hir>;
+impl<'v> Visitor<'v> for UndocumentedUnsafeBlocks {
+    type Map = Map<'v>;
 
     fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
         NestedVisitorMap::None
diff --git a/clippy_lints/src/undropped_manually_drops.rs b/clippy_lints/src/undropped_manually_drops.rs
index c58fa67a023..7557e14d11f 100644
--- a/clippy_lints/src/undropped_manually_drops.rs
+++ b/clippy_lints/src/undropped_manually_drops.rs
@@ -36,7 +36,7 @@ declare_clippy_lint! {
 
 declare_lint_pass!(UndroppedManuallyDrops => [UNDROPPED_MANUALLY_DROPS]);
 
-impl LateLintPass<'tcx> for UndroppedManuallyDrops {
+impl<'tcx> LateLintPass<'tcx> for UndroppedManuallyDrops {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if let Some([arg_0, ..]) = match_function_call(cx, expr, &paths::DROP) {
             let ty = cx.typeck_results().expr_ty(arg_0);
diff --git a/clippy_lints/src/uninit_vec.rs b/clippy_lints/src/uninit_vec.rs
index 46cc76b150e..2ffaf24f942 100644
--- a/clippy_lints/src/uninit_vec.rs
+++ b/clippy_lints/src/uninit_vec.rs
@@ -78,7 +78,7 @@ impl<'tcx> LateLintPass<'tcx> for UninitVec {
     }
 }
 
-fn handle_uninit_vec_pair(
+fn handle_uninit_vec_pair<'tcx>(
     cx: &LateContext<'tcx>,
     maybe_init_or_reserve: &'tcx Stmt<'tcx>,
     maybe_set_len: &'tcx Expr<'tcx>,
@@ -196,7 +196,7 @@ fn is_reserve(cx: &LateContext<'_>, path: &PathSegment<'_>, self_expr: &Expr<'_>
 }
 
 /// Returns self if the expression is `Vec::set_len()`
-fn extract_set_len_self(cx: &LateContext<'_>, expr: &'tcx Expr<'_>) -> Option<(&'tcx Expr<'tcx>, Span)> {
+fn extract_set_len_self<'tcx>(cx: &LateContext<'_>, expr: &'tcx Expr<'_>) -> Option<(&'tcx Expr<'tcx>, Span)> {
     // peel unsafe blocks in `unsafe { vec.set_len() }`
     let expr = peel_hir_expr_while(expr, |e| {
         if let ExprKind::Block(block, _) = e.kind {
diff --git a/clippy_lints/src/unit_hash.rs b/clippy_lints/src/unit_hash.rs
index 26b4e0f58a8..dcf8a9d7c84 100644
--- a/clippy_lints/src/unit_hash.rs
+++ b/clippy_lints/src/unit_hash.rs
@@ -46,7 +46,7 @@ declare_clippy_lint! {
 }
 declare_lint_pass!(UnitHash => [UNIT_HASH]);
 
-impl LateLintPass<'tcx> for UnitHash {
+impl<'tcx> LateLintPass<'tcx> for UnitHash {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
         if_chain! {
             if let ExprKind::MethodCall(name_ident, _, args, _) = &expr.kind;
diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index 02f5d45cc18..4e46d79dc08 100644
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -577,7 +577,7 @@ fn get_lint_version(cx: &LateContext<'_>, item: &Item<'_>) -> String {
 fn get_lint_group_and_level_or_lint(
     cx: &LateContext<'_>,
     lint_name: &str,
-    item: &'hir Item<'_>,
+    item: &Item<'_>,
 ) -> Option<(String, &'static str)> {
     let result = cx
         .lint_store
@@ -696,20 +696,20 @@ fn extract_emission_info<'hir>(
 }
 
 /// Resolves the possible lints that this expression could reference
-fn resolve_lints(cx: &LateContext<'hir>, expr: &'hir hir::Expr<'hir>) -> Vec<String> {
+fn resolve_lints<'hir>(cx: &LateContext<'hir>, expr: &'hir hir::Expr<'hir>) -> Vec<String> {
     let mut resolver = LintResolver::new(cx);
     resolver.visit_expr(expr);
     resolver.lints
 }
 
 /// This function tries to resolve the linked applicability to the given expression.
-fn resolve_applicability(cx: &LateContext<'hir>, expr: &'hir hir::Expr<'hir>) -> Option<usize> {
+fn resolve_applicability<'hir>(cx: &LateContext<'hir>, expr: &'hir hir::Expr<'hir>) -> Option<usize> {
     let mut resolver = ApplicabilityResolver::new(cx);
     resolver.visit_expr(expr);
     resolver.complete()
 }
 
-fn check_is_multi_part(cx: &LateContext<'hir>, closure_expr: &'hir hir::Expr<'hir>) -> bool {
+fn check_is_multi_part<'hir>(cx: &LateContext<'hir>, closure_expr: &'hir hir::Expr<'hir>) -> bool {
     if let ExprKind::Closure(_, _, body_id, _, _) = closure_expr.kind {
         let mut scanner = IsMultiSpanScanner::new(cx);
         intravisit::walk_body(&mut scanner, cx.tcx.hir().body(body_id));
@@ -824,7 +824,7 @@ impl<'a, 'hir> intravisit::Visitor<'hir> for ApplicabilityResolver<'a, 'hir> {
 }
 
 /// This returns the parent local node if the expression is a reference one
-fn get_parent_local(cx: &LateContext<'hir>, expr: &'hir hir::Expr<'hir>) -> Option<&'hir hir::Local<'hir>> {
+fn get_parent_local<'hir>(cx: &LateContext<'hir>, expr: &'hir hir::Expr<'hir>) -> Option<&'hir hir::Local<'hir>> {
     if let ExprKind::Path(QPath::Resolved(_, path)) = expr.kind {
         if let hir::def::Res::Local(local_hir) = path.res {
             return get_parent_local_hir_id(cx, local_hir);
@@ -834,7 +834,7 @@ fn get_parent_local(cx: &LateContext<'hir>, expr: &'hir hir::Expr<'hir>) -> Opti
     None
 }
 
-fn get_parent_local_hir_id(cx: &LateContext<'hir>, hir_id: hir::HirId) -> Option<&'hir hir::Local<'hir>> {
+fn get_parent_local_hir_id<'hir>(cx: &LateContext<'hir>, hir_id: hir::HirId) -> Option<&'hir hir::Local<'hir>> {
     let map = cx.tcx.hir();
 
     match map.find(map.get_parent_node(hir_id)) {
diff --git a/clippy_lints/src/vec_init_then_push.rs b/clippy_lints/src/vec_init_then_push.rs
index 1bc0eb6303c..43474da3450 100644
--- a/clippy_lints/src/vec_init_then_push.rs
+++ b/clippy_lints/src/vec_init_then_push.rs
@@ -77,7 +77,7 @@ impl VecPushSearcher {
     }
 }
 
-impl LateLintPass<'_> for VecInitThenPush {
+impl<'tcx> LateLintPass<'tcx> for VecInitThenPush {
     fn check_block(&mut self, _: &LateContext<'tcx>, _: &'tcx Block<'tcx>) {
         self.searcher = None;
     }
diff --git a/clippy_utils/src/consts.rs b/clippy_utils/src/consts.rs
index 5c024612f8e..34c5af848a6 100644
--- a/clippy_utils/src/consts.rs
+++ b/clippy_utils/src/consts.rs
@@ -223,7 +223,7 @@ pub fn constant_simple<'tcx>(
     constant(lcx, typeck_results, e).and_then(|(cst, res)| if res { None } else { Some(cst) })
 }
 
-pub fn constant_full_int(
+pub fn constant_full_int<'tcx>(
     lcx: &LateContext<'tcx>,
     typeck_results: &ty::TypeckResults<'tcx>,
     e: &Expr<'_>,
diff --git a/clippy_utils/src/eager_or_lazy.rs b/clippy_utils/src/eager_or_lazy.rs
index 61e529a6079..c3936ec95d4 100644
--- a/clippy_utils/src/eager_or_lazy.rs
+++ b/clippy_utils/src/eager_or_lazy.rs
@@ -45,7 +45,12 @@ impl ops::BitOrAssign for EagernessSuggestion {
 }
 
 /// Determine the eagerness of the given function call.
-fn fn_eagerness(cx: &LateContext<'tcx>, fn_id: DefId, name: Symbol, args: &'tcx [Expr<'_>]) -> EagernessSuggestion {
+fn fn_eagerness<'tcx>(
+    cx: &LateContext<'tcx>,
+    fn_id: DefId,
+    name: Symbol,
+    args: &'tcx [Expr<'_>],
+) -> EagernessSuggestion {
     use EagernessSuggestion::{Eager, Lazy, NoChange};
     let name = name.as_str();
 
@@ -92,7 +97,7 @@ fn fn_eagerness(cx: &LateContext<'tcx>, fn_id: DefId, name: Symbol, args: &'tcx
 }
 
 #[allow(clippy::too_many_lines)]
-fn expr_eagerness(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> EagernessSuggestion {
+fn expr_eagerness<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> EagernessSuggestion {
     struct V<'cx, 'tcx> {
         cx: &'cx LateContext<'tcx>,
         eagerness: EagernessSuggestion,
@@ -225,11 +230,11 @@ fn expr_eagerness(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> EagernessSuggest
 }
 
 /// Whether the given expression should be changed to evaluate eagerly
-pub fn switch_to_eager_eval(cx: &'_ LateContext<'tcx>, expr: &'tcx Expr<'_>) -> bool {
+pub fn switch_to_eager_eval<'tcx>(cx: &'_ LateContext<'tcx>, expr: &'tcx Expr<'_>) -> bool {
     expr_eagerness(cx, expr) == EagernessSuggestion::Eager
 }
 
 /// Whether the given expression should be changed to evaluate lazily
-pub fn switch_to_lazy_eval(cx: &'_ LateContext<'tcx>, expr: &'tcx Expr<'_>) -> bool {
+pub fn switch_to_lazy_eval<'tcx>(cx: &'_ LateContext<'tcx>, expr: &'tcx Expr<'_>) -> bool {
     expr_eagerness(cx, expr) == EagernessSuggestion::Lazy
 }
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 16bcffb8df9..9f2018385f3 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -1,6 +1,5 @@
 #![feature(box_patterns)]
 #![feature(control_flow_enum)]
-#![feature(in_band_lifetimes)]
 #![feature(let_else)]
 #![feature(once_cell)]
 #![feature(rustc_private)]
@@ -128,7 +127,7 @@ macro_rules! extract_msrv_attr {
         extract_msrv_attr!(@EarlyContext);
     };
     (@$context:ident$(, $call:tt)?) => {
-        fn enter_lint_attrs(&mut self, cx: &rustc_lint::$context<'tcx>, attrs: &'tcx [rustc_ast::ast::Attribute]) {
+        fn enter_lint_attrs(&mut self, cx: &rustc_lint::$context<'_>, attrs: &[rustc_ast::ast::Attribute]) {
             use $crate::get_unique_inner_attr;
             match get_unique_inner_attr(cx.sess$($call)?, attrs, "msrv") {
                 Some(msrv_attr) => {
@@ -277,7 +276,11 @@ pub fn is_wild(pat: &Pat<'_>) -> bool {
 }
 
 /// Checks if the first type parameter is a lang item.
-pub fn is_ty_param_lang_item(cx: &LateContext<'_>, qpath: &QPath<'tcx>, item: LangItem) -> Option<&'tcx hir::Ty<'tcx>> {
+pub fn is_ty_param_lang_item<'tcx>(
+    cx: &LateContext<'_>,
+    qpath: &QPath<'tcx>,
+    item: LangItem,
+) -> Option<&'tcx hir::Ty<'tcx>> {
     let ty = get_qpath_generic_tys(qpath).next()?;
 
     if let TyKind::Path(qpath) = &ty.kind {
@@ -293,7 +296,7 @@ pub fn is_ty_param_lang_item(cx: &LateContext<'_>, qpath: &QPath<'tcx>, item: La
 }
 
 /// Checks if the first type parameter is a diagnostic item.
-pub fn is_ty_param_diagnostic_item(
+pub fn is_ty_param_diagnostic_item<'tcx>(
     cx: &LateContext<'_>,
     qpath: &QPath<'tcx>,
     item: Symbol,
@@ -370,7 +373,7 @@ pub fn last_path_segment<'tcx>(path: &QPath<'tcx>) -> &'tcx PathSegment<'tcx> {
     }
 }
 
-pub fn get_qpath_generics(path: &QPath<'tcx>) -> Option<&'tcx GenericArgs<'tcx>> {
+pub fn get_qpath_generics<'tcx>(path: &QPath<'tcx>) -> Option<&'tcx GenericArgs<'tcx>> {
     match path {
         QPath::Resolved(_, p) => p.segments.last().and_then(|s| s.args),
         QPath::TypeRelative(_, s) => s.args,
@@ -378,7 +381,7 @@ pub fn get_qpath_generics(path: &QPath<'tcx>) -> Option<&'tcx GenericArgs<'tcx>>
     }
 }
 
-pub fn get_qpath_generic_tys(path: &QPath<'tcx>) -> impl Iterator<Item = &'tcx hir::Ty<'tcx>> {
+pub fn get_qpath_generic_tys<'tcx>(path: &QPath<'tcx>) -> impl Iterator<Item = &'tcx hir::Ty<'tcx>> {
     get_qpath_generics(path)
         .map_or([].as_ref(), |a| a.args)
         .iter()
@@ -767,7 +770,7 @@ pub fn is_default_equivalent(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
 ///
 /// Note that this check is not recursive, so passing the `if` expression will always return true
 /// even though sub-expressions might return false.
-pub fn can_move_expr_to_closure_no_visit(
+pub fn can_move_expr_to_closure_no_visit<'tcx>(
     cx: &LateContext<'tcx>,
     expr: &'tcx Expr<'_>,
     loop_ids: &[HirId],
@@ -842,7 +845,7 @@ impl std::ops::BitOrAssign for CaptureKind {
 /// Note as this will walk up to parent expressions until the capture can be determined it should
 /// only be used while making a closure somewhere a value is consumed. e.g. a block, match arm, or
 /// function argument (other than a receiver).
-pub fn capture_local_usage(cx: &LateContext<'tcx>, e: &Expr<'_>) -> CaptureKind {
+pub fn capture_local_usage<'tcx>(cx: &LateContext<'tcx>, e: &Expr<'_>) -> CaptureKind {
     fn pat_capture_kind(cx: &LateContext<'_>, pat: &Pat<'_>) -> CaptureKind {
         let mut capture = CaptureKind::Ref(Mutability::Not);
         pat.each_binding_or_first(&mut |_, id, span, _| match cx
@@ -942,7 +945,7 @@ pub fn capture_local_usage(cx: &LateContext<'tcx>, e: &Expr<'_>) -> CaptureKind
 
 /// Checks if the expression can be moved into a closure as is. This will return a list of captures
 /// if so, otherwise, `None`.
-pub fn can_move_expr_to_closure(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<HirIdMap<CaptureKind>> {
+pub fn can_move_expr_to_closure<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<HirIdMap<CaptureKind>> {
     struct V<'cx, 'tcx> {
         cx: &'cx LateContext<'tcx>,
         // Stack of potential break targets contained in the expression.
@@ -955,7 +958,7 @@ pub fn can_move_expr_to_closure(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) ->
         /// mutable reference.
         captures: HirIdMap<CaptureKind>,
     }
-    impl Visitor<'tcx> for V<'_, 'tcx> {
+    impl<'tcx> Visitor<'tcx> for V<'_, 'tcx> {
         type Map = ErasedMap<'tcx>;
         fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
             NestedVisitorMap::None
@@ -1212,7 +1215,7 @@ pub fn get_enclosing_block<'tcx>(cx: &LateContext<'tcx>, hir_id: HirId) -> Optio
 }
 
 /// Gets the loop or closure enclosing the given expression, if any.
-pub fn get_enclosing_loop_or_closure(tcx: TyCtxt<'tcx>, expr: &Expr<'_>) -> Option<&'tcx Expr<'tcx>> {
+pub fn get_enclosing_loop_or_closure<'tcx>(tcx: TyCtxt<'tcx>, expr: &Expr<'_>) -> Option<&'tcx Expr<'tcx>> {
     for (_, node) in tcx.hir().parent_iter(expr.hir_id) {
         match node {
             Node::Expr(
@@ -1720,7 +1723,7 @@ pub fn is_async_fn(kind: FnKind<'_>) -> bool {
 }
 
 /// Peels away all the compiler generated code surrounding the body of an async function,
-pub fn get_async_fn_body(tcx: TyCtxt<'tcx>, body: &Body<'_>) -> Option<&'tcx Expr<'tcx>> {
+pub fn get_async_fn_body<'tcx>(tcx: TyCtxt<'tcx>, body: &Body<'_>) -> Option<&'tcx Expr<'tcx>> {
     if let ExprKind::Call(
         _,
         &[
@@ -1824,7 +1827,7 @@ pub fn is_expr_identity_function(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool
 }
 
 /// Gets the node where an expression is either used, or it's type is unified with another branch.
-pub fn get_expr_use_or_unification_node(tcx: TyCtxt<'tcx>, expr: &Expr<'_>) -> Option<Node<'tcx>> {
+pub fn get_expr_use_or_unification_node<'tcx>(tcx: TyCtxt<'tcx>, expr: &Expr<'_>) -> Option<Node<'tcx>> {
     let mut child_id = expr.hir_id;
     let mut iter = tcx.hir().parent_iter(child_id);
     loop {
@@ -2030,8 +2033,8 @@ where
 
 /// Peels off all references on the pattern. Returns the underlying pattern and the number of
 /// references removed.
-pub fn peel_hir_pat_refs(pat: &'a Pat<'a>) -> (&'a Pat<'a>, usize) {
-    fn peel(pat: &'a Pat<'a>, count: usize) -> (&'a Pat<'a>, usize) {
+pub fn peel_hir_pat_refs<'a>(pat: &'a Pat<'a>) -> (&'a Pat<'a>, usize) {
+    fn peel<'a>(pat: &'a Pat<'a>, count: usize) -> (&'a Pat<'a>, usize) {
         if let PatKind::Ref(pat, _) = pat.kind {
             peel(pat, count + 1)
         } else {
@@ -2054,7 +2057,7 @@ pub fn peel_hir_expr_while<'tcx>(
 
 /// Peels off up to the given number of references on the expression. Returns the underlying
 /// expression and the number of references removed.
-pub fn peel_n_hir_expr_refs(expr: &'a Expr<'a>, count: usize) -> (&'a Expr<'a>, usize) {
+pub fn peel_n_hir_expr_refs<'a>(expr: &'a Expr<'a>, count: usize) -> (&'a Expr<'a>, usize) {
     let mut remaining = count;
     let e = peel_hir_expr_while(expr, |e| match e.kind {
         ExprKind::AddrOf(ast::BorrowKind::Ref, _, e) if remaining != 0 => {
@@ -2068,7 +2071,7 @@ pub fn peel_n_hir_expr_refs(expr: &'a Expr<'a>, count: usize) -> (&'a Expr<'a>,
 
 /// Peels off all references on the expression. Returns the underlying expression and the number of
 /// references removed.
-pub fn peel_hir_expr_refs(expr: &'a Expr<'a>) -> (&'a Expr<'a>, usize) {
+pub fn peel_hir_expr_refs<'a>(expr: &'a Expr<'a>) -> (&'a Expr<'a>, usize) {
     let mut count = 0;
     let e = peel_hir_expr_while(expr, |e| match e.kind {
         ExprKind::AddrOf(ast::BorrowKind::Ref, _, e) => {
@@ -2151,7 +2154,7 @@ impl<'hir> ItemLikeVisitor<'hir> for TestItemNamesVisitor<'hir> {
 
 static TEST_ITEM_NAMES_CACHE: SyncOnceCell<Mutex<FxHashMap<LocalDefId, Vec<Symbol>>>> = SyncOnceCell::new();
 
-fn with_test_item_names(tcx: TyCtxt<'tcx>, module: LocalDefId, f: impl Fn(&[Symbol]) -> bool) -> bool {
+fn with_test_item_names<'tcx>(tcx: TyCtxt<'tcx>, module: LocalDefId, f: impl Fn(&[Symbol]) -> bool) -> bool {
     let cache = TEST_ITEM_NAMES_CACHE.get_or_init(|| Mutex::new(FxHashMap::default()));
     let mut map: MutexGuard<'_, FxHashMap<LocalDefId, Vec<Symbol>>> = cache.lock().unwrap();
     match map.entry(module) {
diff --git a/clippy_utils/src/macros.rs b/clippy_utils/src/macros.rs
index 2bf43aeb995..a3e336d701c 100644
--- a/clippy_utils/src/macros.rs
+++ b/clippy_utils/src/macros.rs
@@ -283,7 +283,7 @@ fn find_assert_within_debug_assert<'a>(
     found
 }
 
-fn is_assert_arg(cx: &LateContext<'_>, expr: &'a Expr<'a>, assert_expn: ExpnId) -> bool {
+fn is_assert_arg(cx: &LateContext<'_>, expr: &Expr<'_>, assert_expn: ExpnId) -> bool {
     if !expr.span.from_expansion() {
         return true;
     }
@@ -322,7 +322,7 @@ pub struct FormatArgsExpn<'tcx> {
     pub specs: Vec<&'tcx Expr<'tcx>>,
 }
 
-impl FormatArgsExpn<'tcx> {
+impl<'tcx> FormatArgsExpn<'tcx> {
     /// Parses an expanded `format_args!` or `format_args_nl!` invocation
     pub fn parse(cx: &LateContext<'_>, expr: &'tcx Expr<'tcx>) -> Option<Self> {
         macro_backtrace(expr.span).find(|macro_call| {
diff --git a/clippy_utils/src/qualify_min_const_fn.rs b/clippy_utils/src/qualify_min_const_fn.rs
index 1a4da1627b7..d6d43e93e7a 100644
--- a/clippy_utils/src/qualify_min_const_fn.rs
+++ b/clippy_utils/src/qualify_min_const_fn.rs
@@ -19,7 +19,7 @@ use std::borrow::Cow;
 
 type McfResult = Result<(), (Span, Cow<'static, str>)>;
 
-pub fn is_min_const_fn(tcx: TyCtxt<'tcx>, body: &'a Body<'tcx>, msrv: Option<&RustcVersion>) -> McfResult {
+pub fn is_min_const_fn<'a, 'tcx>(tcx: TyCtxt<'tcx>, body: &'a Body<'tcx>, msrv: Option<&RustcVersion>) -> McfResult {
     let def_id = body.source.def_id();
     let mut current = def_id;
     loop {
@@ -85,7 +85,7 @@ pub fn is_min_const_fn(tcx: TyCtxt<'tcx>, body: &'a Body<'tcx>, msrv: Option<&Ru
     Ok(())
 }
 
-fn check_ty(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>, span: Span) -> McfResult {
+fn check_ty<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>, span: Span) -> McfResult {
     for arg in ty.walk(tcx) {
         let ty = match arg.unpack() {
             GenericArgKind::Type(ty) => ty,
@@ -133,7 +133,13 @@ fn check_ty(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>, span: Span) -> McfResult {
     Ok(())
 }
 
-fn check_rvalue(tcx: TyCtxt<'tcx>, body: &Body<'tcx>, def_id: DefId, rvalue: &Rvalue<'tcx>, span: Span) -> McfResult {
+fn check_rvalue<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    body: &Body<'tcx>,
+    def_id: DefId,
+    rvalue: &Rvalue<'tcx>,
+    span: Span,
+) -> McfResult {
     match rvalue {
         Rvalue::ThreadLocalRef(_) => Err((span, "cannot access thread local storage in const fn".into())),
         Rvalue::Repeat(operand, _) | Rvalue::Use(operand) => check_operand(tcx, operand, span, body),
@@ -211,7 +217,12 @@ fn check_rvalue(tcx: TyCtxt<'tcx>, body: &Body<'tcx>, def_id: DefId, rvalue: &Rv
     }
 }
 
-fn check_statement(tcx: TyCtxt<'tcx>, body: &Body<'tcx>, def_id: DefId, statement: &Statement<'tcx>) -> McfResult {
+fn check_statement<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    body: &Body<'tcx>,
+    def_id: DefId,
+    statement: &Statement<'tcx>,
+) -> McfResult {
     let span = statement.source_info.span;
     match &statement.kind {
         StatementKind::Assign(box (place, rval)) => {
@@ -240,7 +251,7 @@ fn check_statement(tcx: TyCtxt<'tcx>, body: &Body<'tcx>, def_id: DefId, statemen
     }
 }
 
-fn check_operand(tcx: TyCtxt<'tcx>, operand: &Operand<'tcx>, span: Span, body: &Body<'tcx>) -> McfResult {
+fn check_operand<'tcx>(tcx: TyCtxt<'tcx>, operand: &Operand<'tcx>, span: Span, body: &Body<'tcx>) -> McfResult {
     match operand {
         Operand::Move(place) | Operand::Copy(place) => check_place(tcx, *place, span, body),
         Operand::Constant(c) => match c.check_static_ptr(tcx) {
@@ -250,7 +261,7 @@ fn check_operand(tcx: TyCtxt<'tcx>, operand: &Operand<'tcx>, span: Span, body: &
     }
 }
 
-fn check_place(tcx: TyCtxt<'tcx>, place: Place<'tcx>, span: Span, body: &Body<'tcx>) -> McfResult {
+fn check_place<'tcx>(tcx: TyCtxt<'tcx>, place: Place<'tcx>, span: Span, body: &Body<'tcx>) -> McfResult {
     let mut cursor = place.projection.as_ref();
     while let [ref proj_base @ .., elem] = *cursor {
         cursor = proj_base;
@@ -275,7 +286,7 @@ fn check_place(tcx: TyCtxt<'tcx>, place: Place<'tcx>, span: Span, body: &Body<'t
     Ok(())
 }
 
-fn check_terminator(
+fn check_terminator<'a, 'tcx>(
     tcx: TyCtxt<'tcx>,
     body: &'a Body<'tcx>,
     terminator: &Terminator<'tcx>,
diff --git a/clippy_utils/src/source.rs b/clippy_utils/src/source.rs
index d928317259d..dbad607c58e 100644
--- a/clippy_utils/src/source.rs
+++ b/clippy_utils/src/source.rs
@@ -281,7 +281,7 @@ pub fn snippet_block_with_applicability<'a, T: LintContext>(
 /// correctly get a snippet of `vec![]`.
 ///
 /// This will also return whether or not the snippet is a macro call.
-pub fn snippet_with_context(
+pub fn snippet_with_context<'a>(
     cx: &LateContext<'_>,
     span: Span,
     outer: SyntaxContext,
diff --git a/clippy_utils/src/sugg.rs b/clippy_utils/src/sugg.rs
index 92662c59226..87bc8232dde 100644
--- a/clippy_utils/src/sugg.rs
+++ b/clippy_utils/src/sugg.rs
@@ -461,7 +461,7 @@ impl Neg for Sugg<'_> {
     }
 }
 
-impl Not for Sugg<'a> {
+impl<'a> Not for Sugg<'a> {
     type Output = Sugg<'a>;
     fn not(self) -> Sugg<'a> {
         use AssocOp::{Equal, Greater, GreaterEqual, Less, LessEqual, NotEqual};
@@ -846,7 +846,7 @@ struct DerefDelegate<'a, 'tcx> {
     applicability: Applicability,
 }
 
-impl DerefDelegate<'_, 'tcx> {
+impl<'tcx> DerefDelegate<'_, 'tcx> {
     /// build final suggestion:
     /// - create the ending part of suggestion
     /// - concatenate starting and ending parts
diff --git a/clippy_utils/src/ty.rs b/clippy_utils/src/ty.rs
index 6d191d4a59b..72317447159 100644
--- a/clippy_utils/src/ty.rs
+++ b/clippy_utils/src/ty.rs
@@ -25,7 +25,7 @@ pub fn is_copy<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
 }
 
 /// Checks whether a type can be partially moved.
-pub fn can_partially_move_ty(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
+pub fn can_partially_move_ty<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
     if has_drop(cx, ty) || is_copy(cx, ty) {
         return false;
     }
@@ -366,7 +366,7 @@ pub fn walk_ptrs_ty_depth(ty: Ty<'_>) -> (Ty<'_>, usize) {
 
 /// Returns `true` if types `a` and `b` are same types having same `Const` generic args,
 /// otherwise returns `false`
-pub fn same_type_and_consts(a: Ty<'tcx>, b: Ty<'tcx>) -> bool {
+pub fn same_type_and_consts<'tcx>(a: Ty<'tcx>, b: Ty<'tcx>) -> bool {
     match (&a.kind(), &b.kind()) {
         (&ty::Adt(did_a, substs_a), &ty::Adt(did_b, substs_b)) => {
             if did_a != did_b {
diff --git a/clippy_utils/src/visitors.rs b/clippy_utils/src/visitors.rs
index 4bfd3c64b9c..b60cd4736f3 100644
--- a/clippy_utils/src/visitors.rs
+++ b/clippy_utils/src/visitors.rs
@@ -173,7 +173,7 @@ pub trait Visitable<'tcx> {
 }
 macro_rules! visitable_ref {
     ($t:ident, $f:ident) => {
-        impl Visitable<'tcx> for &'tcx $t<'tcx> {
+        impl<'tcx> Visitable<'tcx> for &'tcx $t<'tcx> {
             fn visit<V: Visitor<'tcx>>(self, visitor: &mut V) {
                 visitor.$f(self);
             }
@@ -217,7 +217,7 @@ pub fn is_res_used(cx: &LateContext<'_>, res: Res, body: BodyId) -> bool {
 }
 
 /// Checks if the given local is used.
-pub fn is_local_used(cx: &LateContext<'tcx>, visitable: impl Visitable<'tcx>, id: HirId) -> bool {
+pub fn is_local_used<'tcx>(cx: &LateContext<'tcx>, visitable: impl Visitable<'tcx>, id: HirId) -> bool {
     let mut is_used = false;
     let mut visitor = expr_visitor(cx, |expr| {
         if !is_used {
@@ -231,7 +231,7 @@ pub fn is_local_used(cx: &LateContext<'tcx>, visitable: impl Visitable<'tcx>, id
 }
 
 /// Checks if the given expression is a constant.
-pub fn is_const_evaluatable(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> bool {
+pub fn is_const_evaluatable<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> bool {
     struct V<'a, 'tcx> {
         cx: &'a LateContext<'tcx>,
         is_const: bool,
@@ -321,7 +321,7 @@ pub fn is_const_evaluatable(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> bool {
 }
 
 /// Checks if the given expression performs an unsafe operation outside of an unsafe block.
-pub fn is_expr_unsafe(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> bool {
+pub fn is_expr_unsafe<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> bool {
     struct V<'a, 'tcx> {
         cx: &'a LateContext<'tcx>,
         is_unsafe: bool,
diff --git a/doc/common_tools_writing_lints.md b/doc/common_tools_writing_lints.md
index c7e51d53f51..207b0be1548 100644
--- a/doc/common_tools_writing_lints.md
+++ b/doc/common_tools_writing_lints.md
@@ -60,7 +60,7 @@ Two noticeable items here:
 Starting with an `expr`, you can check whether it is calling a specific method `some_method`:
 
 ```rust
-impl LateLintPass<'_> for MyStructLint {
+impl<'tcx> LateLintPass<'tcx> for MyStructLint {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
         if_chain! {
             // Check our expr is calling a method
-- 
cgit 1.4.1-3-g733a5


From 7e989ec07a2725c8ba88f2030ef7099bb44f08e6 Mon Sep 17 00:00:00 2001
From: Pradyumna Rahul <prkinformed@gmail.com>
Date: Mon, 10 Jan 2022 21:44:10 +0530
Subject: Improve documentation for `borrowed-box` lint

---
 clippy_lints/src/types/mod.rs | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types/mod.rs b/clippy_lints/src/types/mod.rs
index 481e5957435..9d57505e55e 100644
--- a/clippy_lints/src/types/mod.rs
+++ b/clippy_lints/src/types/mod.rs
@@ -167,8 +167,9 @@ declare_clippy_lint! {
     /// Check the [Box documentation](https://doc.rust-lang.org/std/boxed/index.html) for more information.
     ///
     /// ### Why is this bad?
-    /// Any `&Box<T>` can also be a `&T`, which is more
-    /// general.
+    /// A `&Box<T>` parameter requires the function caller to box `T` first before passing it to a function.
+    /// Using `&T` defines a concrete type for the parameter and generalizes the function, this would also
+    /// auto-deref to `&T` at the function call site if passed a `&Box<T>`.
     ///
     /// ### Example
     /// ```rust,ignore
-- 
cgit 1.4.1-3-g733a5


From d32277d78edfec2c8293fb887aff1783d4595653 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Wed, 12 Jan 2022 00:25:42 -0500
Subject: Don't lint `deref_addrof` when the two operations occur in different
 expansions

---
 clippy_lints/src/reference.rs | 1 +
 tests/ui/deref_addrof.fixed   | 2 ++
 tests/ui/deref_addrof.rs      | 2 ++
 tests/ui/deref_addrof.stderr  | 4 ++--
 4 files changed, 7 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/reference.rs b/clippy_lints/src/reference.rs
index 22ae7a291d0..b2448372370 100644
--- a/clippy_lints/src/reference.rs
+++ b/clippy_lints/src/reference.rs
@@ -50,6 +50,7 @@ impl EarlyLintPass for DerefAddrOf {
         if_chain! {
             if let ExprKind::Unary(UnOp::Deref, ref deref_target) = e.kind;
             if let ExprKind::AddrOf(_, ref mutability, ref addrof_target) = without_parens(deref_target).kind;
+            if deref_target.span.ctxt() == e.span.ctxt();
             if !addrof_target.span.from_expansion();
             then {
                 let mut applicability = Applicability::MachineApplicable;
diff --git a/tests/ui/deref_addrof.fixed b/tests/ui/deref_addrof.fixed
index 0029fc673f1..2f489deb1ee 100644
--- a/tests/ui/deref_addrof.fixed
+++ b/tests/ui/deref_addrof.fixed
@@ -37,6 +37,8 @@ fn main() {
     let b = &a;
 
     let b = *aref;
+
+    let _ = unsafe { *core::ptr::addr_of!(a) };
 }
 
 #[rustfmt::skip]
diff --git a/tests/ui/deref_addrof.rs b/tests/ui/deref_addrof.rs
index f2f02dd5e72..49f360b9a7f 100644
--- a/tests/ui/deref_addrof.rs
+++ b/tests/ui/deref_addrof.rs
@@ -37,6 +37,8 @@ fn main() {
     let b = *&&a;
 
     let b = **&aref;
+
+    let _ = unsafe { *core::ptr::addr_of!(a) };
 }
 
 #[rustfmt::skip]
diff --git a/tests/ui/deref_addrof.stderr b/tests/ui/deref_addrof.stderr
index 5bc1cbfa215..75371fcdb96 100644
--- a/tests/ui/deref_addrof.stderr
+++ b/tests/ui/deref_addrof.stderr
@@ -49,7 +49,7 @@ LL |     let b = **&aref;
    |              ^^^^^^ help: try this: `aref`
 
 error: immediately dereferencing a reference
-  --> $DIR/deref_addrof.rs:45:9
+  --> $DIR/deref_addrof.rs:47:9
    |
 LL |         *& $visitor
    |         ^^^^^^^^^^^ help: try this: `$visitor`
@@ -60,7 +60,7 @@ LL |         m!(self)
    = note: this error originates in the macro `m` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: immediately dereferencing a reference
-  --> $DIR/deref_addrof.rs:52:9
+  --> $DIR/deref_addrof.rs:54:9
    |
 LL |         *& mut $visitor
    |         ^^^^^^^^^^^^^^^ help: try this: `$visitor`
-- 
cgit 1.4.1-3-g733a5


From 166737f3cbbe2157454c759cb56662c941c6031c Mon Sep 17 00:00:00 2001
From: Paolo Barbolini <paolo@paolo565.org>
Date: Sun, 2 Jan 2022 23:34:10 +0100
Subject: Add manual_bits lint

---
 CHANGELOG.md                           |   1 +
 clippy_lints/src/lib.register_all.rs   |   1 +
 clippy_lints/src/lib.register_lints.rs |   1 +
 clippy_lints/src/lib.register_style.rs |   1 +
 clippy_lints/src/lib.rs                |   2 +
 clippy_lints/src/manual_bits.rs        | 107 +++++++++++++++++++++++
 clippy_utils/src/msrvs.rs              |   2 +-
 tests/ui/manual_bits.fixed             |  48 ++++++++++
 tests/ui/manual_bits.rs                |  48 ++++++++++
 tests/ui/manual_bits.stderr            | 154 +++++++++++++++++++++++++++++++++
 10 files changed, 364 insertions(+), 1 deletion(-)
 create mode 100644 clippy_lints/src/manual_bits.rs
 create mode 100644 tests/ui/manual_bits.fixed
 create mode 100644 tests/ui/manual_bits.rs
 create mode 100644 tests/ui/manual_bits.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index e521995a188..8f4da9a3827 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3071,6 +3071,7 @@ Released 2018-09-13
 [`main_recursion`]: https://rust-lang.github.io/rust-clippy/master/index.html#main_recursion
 [`manual_assert`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_assert
 [`manual_async_fn`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_async_fn
+[`manual_bits`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_bits
 [`manual_filter_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_filter_map
 [`manual_find_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_find_map
 [`manual_flatten`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_flatten
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 0cab28cfafa..26fb4259952 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -115,6 +115,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(loops::WHILE_LET_ON_ITERATOR),
     LintId::of(main_recursion::MAIN_RECURSION),
     LintId::of(manual_async_fn::MANUAL_ASYNC_FN),
+    LintId::of(manual_bits::MANUAL_BITS),
     LintId::of(manual_map::MANUAL_MAP),
     LintId::of(manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE),
     LintId::of(manual_strip::MANUAL_STRIP),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 09e4f6ae275..746bdb19c3d 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -226,6 +226,7 @@ store.register_lints(&[
     main_recursion::MAIN_RECURSION,
     manual_assert::MANUAL_ASSERT,
     manual_async_fn::MANUAL_ASYNC_FN,
+    manual_bits::MANUAL_BITS,
     manual_map::MANUAL_MAP,
     manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE,
     manual_ok_or::MANUAL_OK_OR,
diff --git a/clippy_lints/src/lib.register_style.rs b/clippy_lints/src/lib.register_style.rs
index 57de34f41ac..05211476ff2 100644
--- a/clippy_lints/src/lib.register_style.rs
+++ b/clippy_lints/src/lib.register_style.rs
@@ -43,6 +43,7 @@ store.register_group(true, "clippy::style", Some("clippy_style"), vec![
     LintId::of(loops::WHILE_LET_ON_ITERATOR),
     LintId::of(main_recursion::MAIN_RECURSION),
     LintId::of(manual_async_fn::MANUAL_ASYNC_FN),
+    LintId::of(manual_bits::MANUAL_BITS),
     LintId::of(manual_map::MANUAL_MAP),
     LintId::of(manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE),
     LintId::of(map_clone::MAP_CLONE),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 80d979362f8..79e9882fef4 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -261,6 +261,7 @@ mod macro_use;
 mod main_recursion;
 mod manual_assert;
 mod manual_async_fn;
+mod manual_bits;
 mod manual_map;
 mod manual_non_exhaustive;
 mod manual_ok_or;
@@ -858,6 +859,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(init_numbered_fields::NumberedFields));
     store.register_early_pass(|| Box::new(single_char_lifetime_names::SingleCharLifetimeNames));
     store.register_late_pass(move || Box::new(borrow_as_ptr::BorrowAsPtr::new(msrv)));
+    store.register_late_pass(move || Box::new(manual_bits::ManualBits::new(msrv)));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/manual_bits.rs b/clippy_lints/src/manual_bits.rs
new file mode 100644
index 00000000000..50bf2527e39
--- /dev/null
+++ b/clippy_lints/src/manual_bits.rs
@@ -0,0 +1,107 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet_opt;
+use clippy_utils::{match_def_path, meets_msrv, msrvs, paths};
+use rustc_ast::ast::LitKind;
+use rustc_errors::Applicability;
+use rustc_hir::{BinOpKind, Expr, ExprKind, GenericArg, QPath};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::{self, Ty};
+use rustc_semver::RustcVersion;
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for uses of `std::mem::size_of::<T>() * 8` when
+    /// `T::BITS` is available.
+    ///
+    /// ### Why is this bad?
+    /// Can be written as the shorter `T::BITS`.
+    ///
+    /// ### Example
+    /// ```rust
+    /// std::mem::size_of::<usize>() * 8;
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// usize::BITS;
+    /// ```
+    #[clippy::version = "1.60.0"]
+    pub MANUAL_BITS,
+    style,
+    "manual implementation of `size_of::<T>() * 8` can be simplified with `T::BITS`"
+}
+
+#[derive(Clone)]
+pub struct ManualBits {
+    msrv: Option<RustcVersion>,
+}
+
+impl ManualBits {
+    #[must_use]
+    pub fn new(msrv: Option<RustcVersion>) -> Self {
+        Self { msrv }
+    }
+}
+
+impl_lint_pass!(ManualBits => [MANUAL_BITS]);
+
+impl<'tcx> LateLintPass<'tcx> for ManualBits {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        if !meets_msrv(self.msrv.as_ref(), &msrvs::MANUAL_BITS) {
+            return;
+        }
+
+        if_chain! {
+            if let ExprKind::Binary(bin_op, left_expr, right_expr) = expr.kind;
+            if let BinOpKind::Mul = &bin_op.node;
+            if let Some((real_ty, resolved_ty, other_expr)) = get_one_size_of_ty(cx, left_expr, right_expr);
+            if matches!(resolved_ty.kind(), ty::Int(_) | ty::Uint(_));
+            if let ExprKind::Lit(lit) = &other_expr.kind;
+            if let LitKind::Int(8, _) = lit.node;
+
+            then {
+                span_lint_and_sugg(
+                    cx,
+                    MANUAL_BITS,
+                    expr.span,
+                    "usage of `mem::size_of::<T>()` to obtain the size of `T` in bits",
+                    "consider using",
+                    format!("{}::BITS", snippet_opt(cx, real_ty.span).unwrap()),
+                    Applicability::MachineApplicable,
+                );
+            }
+        }
+    }
+}
+
+fn get_one_size_of_ty<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr1: &'tcx Expr<'_>,
+    expr2: &'tcx Expr<'_>,
+) -> Option<(&'tcx rustc_hir::Ty<'tcx>, Ty<'tcx>, &'tcx Expr<'tcx>)> {
+    match (get_size_of_ty(cx, expr1), get_size_of_ty(cx, expr2)) {
+        (Some((real_ty, resolved_ty)), None) => Some((real_ty, resolved_ty, expr2)),
+        (None, Some((real_ty, resolved_ty))) => Some((real_ty, resolved_ty, expr1)),
+        _ => None,
+    }
+}
+
+fn get_size_of_ty<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<(&'tcx rustc_hir::Ty<'tcx>, Ty<'tcx>)> {
+    if_chain! {
+        if let ExprKind::Call(count_func, _func_args) = expr.kind;
+        if let ExprKind::Path(ref count_func_qpath) = count_func.kind;
+
+        if let QPath::Resolved(_, count_func_path) = count_func_qpath;
+        if let Some(segment_zero) = count_func_path.segments.get(0);
+        if let Some(args) = segment_zero.args;
+        if let Some(GenericArg::Type(real_ty)) = args.args.get(0);
+
+        if let Some(def_id) = cx.qpath_res(count_func_qpath, count_func.hir_id).opt_def_id();
+        if match_def_path(cx, def_id, &paths::MEM_SIZE_OF);
+        then {
+            cx.typeck_results().node_substs(count_func.hir_id).types().next().map(|resolved_ty| (real_ty, resolved_ty))
+        } else {
+            None
+        }
+    }
+}
diff --git a/clippy_utils/src/msrvs.rs b/clippy_utils/src/msrvs.rs
index af677d8b00f..a5b409ad96b 100644
--- a/clippy_utils/src/msrvs.rs
+++ b/clippy_utils/src/msrvs.rs
@@ -12,7 +12,7 @@ macro_rules! msrv_aliases {
 
 // names may refer to stabilized feature flags or library items
 msrv_aliases! {
-    1,53,0 { OR_PATTERNS }
+    1,53,0 { OR_PATTERNS, MANUAL_BITS }
     1,52,0 { STR_SPLIT_ONCE }
     1,51,0 { BORROW_AS_PTR }
     1,50,0 { BOOL_THEN }
diff --git a/tests/ui/manual_bits.fixed b/tests/ui/manual_bits.fixed
new file mode 100644
index 00000000000..4f1b19b75b8
--- /dev/null
+++ b/tests/ui/manual_bits.fixed
@@ -0,0 +1,48 @@
+// run-rustfix
+
+#![warn(clippy::manual_bits)]
+#![allow(clippy::no_effect, path_statements, unused_must_use, clippy::unnecessary_operation)]
+
+use std::mem::{size_of, size_of_val};
+
+fn main() {
+    i8::BITS;
+    i16::BITS;
+    i32::BITS;
+    i64::BITS;
+    i128::BITS;
+    isize::BITS;
+
+    u8::BITS;
+    u16::BITS;
+    u32::BITS;
+    u64::BITS;
+    u128::BITS;
+    usize::BITS;
+
+    i8::BITS;
+    i16::BITS;
+    i32::BITS;
+    i64::BITS;
+    i128::BITS;
+    isize::BITS;
+
+    u8::BITS;
+    u16::BITS;
+    u32::BITS;
+    u64::BITS;
+    u128::BITS;
+    usize::BITS;
+
+    size_of::<usize>() * 4;
+    4 * size_of::<usize>();
+    size_of::<bool>() * 8;
+    8 * size_of::<bool>();
+
+    size_of_val(&0u32) * 8;
+
+    type Word = u32;
+    Word::BITS;
+    type Bool = bool;
+    size_of::<Bool>() * 8;
+}
diff --git a/tests/ui/manual_bits.rs b/tests/ui/manual_bits.rs
new file mode 100644
index 00000000000..f8a01313e6a
--- /dev/null
+++ b/tests/ui/manual_bits.rs
@@ -0,0 +1,48 @@
+// run-rustfix
+
+#![warn(clippy::manual_bits)]
+#![allow(clippy::no_effect, path_statements, unused_must_use, clippy::unnecessary_operation)]
+
+use std::mem::{size_of, size_of_val};
+
+fn main() {
+    size_of::<i8>() * 8;
+    size_of::<i16>() * 8;
+    size_of::<i32>() * 8;
+    size_of::<i64>() * 8;
+    size_of::<i128>() * 8;
+    size_of::<isize>() * 8;
+
+    size_of::<u8>() * 8;
+    size_of::<u16>() * 8;
+    size_of::<u32>() * 8;
+    size_of::<u64>() * 8;
+    size_of::<u128>() * 8;
+    size_of::<usize>() * 8;
+
+    8 * size_of::<i8>();
+    8 * size_of::<i16>();
+    8 * size_of::<i32>();
+    8 * size_of::<i64>();
+    8 * size_of::<i128>();
+    8 * size_of::<isize>();
+
+    8 * size_of::<u8>();
+    8 * size_of::<u16>();
+    8 * size_of::<u32>();
+    8 * size_of::<u64>();
+    8 * size_of::<u128>();
+    8 * size_of::<usize>();
+
+    size_of::<usize>() * 4;
+    4 * size_of::<usize>();
+    size_of::<bool>() * 8;
+    8 * size_of::<bool>();
+
+    size_of_val(&0u32) * 8;
+
+    type Word = u32;
+    size_of::<Word>() * 8;
+    type Bool = bool;
+    size_of::<Bool>() * 8;
+}
diff --git a/tests/ui/manual_bits.stderr b/tests/ui/manual_bits.stderr
new file mode 100644
index 00000000000..c4f5af2dcb0
--- /dev/null
+++ b/tests/ui/manual_bits.stderr
@@ -0,0 +1,154 @@
+error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
+  --> $DIR/manual_bits.rs:9:5
+   |
+LL |     size_of::<i8>() * 8;
+   |     ^^^^^^^^^^^^^^^^^^^ help: consider using: `i8::BITS`
+   |
+   = note: `-D clippy::manual-bits` implied by `-D warnings`
+
+error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
+  --> $DIR/manual_bits.rs:10:5
+   |
+LL |     size_of::<i16>() * 8;
+   |     ^^^^^^^^^^^^^^^^^^^^ help: consider using: `i16::BITS`
+
+error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
+  --> $DIR/manual_bits.rs:11:5
+   |
+LL |     size_of::<i32>() * 8;
+   |     ^^^^^^^^^^^^^^^^^^^^ help: consider using: `i32::BITS`
+
+error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
+  --> $DIR/manual_bits.rs:12:5
+   |
+LL |     size_of::<i64>() * 8;
+   |     ^^^^^^^^^^^^^^^^^^^^ help: consider using: `i64::BITS`
+
+error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
+  --> $DIR/manual_bits.rs:13:5
+   |
+LL |     size_of::<i128>() * 8;
+   |     ^^^^^^^^^^^^^^^^^^^^^ help: consider using: `i128::BITS`
+
+error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
+  --> $DIR/manual_bits.rs:14:5
+   |
+LL |     size_of::<isize>() * 8;
+   |     ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `isize::BITS`
+
+error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
+  --> $DIR/manual_bits.rs:16:5
+   |
+LL |     size_of::<u8>() * 8;
+   |     ^^^^^^^^^^^^^^^^^^^ help: consider using: `u8::BITS`
+
+error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
+  --> $DIR/manual_bits.rs:17:5
+   |
+LL |     size_of::<u16>() * 8;
+   |     ^^^^^^^^^^^^^^^^^^^^ help: consider using: `u16::BITS`
+
+error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
+  --> $DIR/manual_bits.rs:18:5
+   |
+LL |     size_of::<u32>() * 8;
+   |     ^^^^^^^^^^^^^^^^^^^^ help: consider using: `u32::BITS`
+
+error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
+  --> $DIR/manual_bits.rs:19:5
+   |
+LL |     size_of::<u64>() * 8;
+   |     ^^^^^^^^^^^^^^^^^^^^ help: consider using: `u64::BITS`
+
+error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
+  --> $DIR/manual_bits.rs:20:5
+   |
+LL |     size_of::<u128>() * 8;
+   |     ^^^^^^^^^^^^^^^^^^^^^ help: consider using: `u128::BITS`
+
+error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
+  --> $DIR/manual_bits.rs:21:5
+   |
+LL |     size_of::<usize>() * 8;
+   |     ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `usize::BITS`
+
+error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
+  --> $DIR/manual_bits.rs:23:5
+   |
+LL |     8 * size_of::<i8>();
+   |     ^^^^^^^^^^^^^^^^^^^ help: consider using: `i8::BITS`
+
+error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
+  --> $DIR/manual_bits.rs:24:5
+   |
+LL |     8 * size_of::<i16>();
+   |     ^^^^^^^^^^^^^^^^^^^^ help: consider using: `i16::BITS`
+
+error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
+  --> $DIR/manual_bits.rs:25:5
+   |
+LL |     8 * size_of::<i32>();
+   |     ^^^^^^^^^^^^^^^^^^^^ help: consider using: `i32::BITS`
+
+error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
+  --> $DIR/manual_bits.rs:26:5
+   |
+LL |     8 * size_of::<i64>();
+   |     ^^^^^^^^^^^^^^^^^^^^ help: consider using: `i64::BITS`
+
+error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
+  --> $DIR/manual_bits.rs:27:5
+   |
+LL |     8 * size_of::<i128>();
+   |     ^^^^^^^^^^^^^^^^^^^^^ help: consider using: `i128::BITS`
+
+error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
+  --> $DIR/manual_bits.rs:28:5
+   |
+LL |     8 * size_of::<isize>();
+   |     ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `isize::BITS`
+
+error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
+  --> $DIR/manual_bits.rs:30:5
+   |
+LL |     8 * size_of::<u8>();
+   |     ^^^^^^^^^^^^^^^^^^^ help: consider using: `u8::BITS`
+
+error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
+  --> $DIR/manual_bits.rs:31:5
+   |
+LL |     8 * size_of::<u16>();
+   |     ^^^^^^^^^^^^^^^^^^^^ help: consider using: `u16::BITS`
+
+error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
+  --> $DIR/manual_bits.rs:32:5
+   |
+LL |     8 * size_of::<u32>();
+   |     ^^^^^^^^^^^^^^^^^^^^ help: consider using: `u32::BITS`
+
+error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
+  --> $DIR/manual_bits.rs:33:5
+   |
+LL |     8 * size_of::<u64>();
+   |     ^^^^^^^^^^^^^^^^^^^^ help: consider using: `u64::BITS`
+
+error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
+  --> $DIR/manual_bits.rs:34:5
+   |
+LL |     8 * size_of::<u128>();
+   |     ^^^^^^^^^^^^^^^^^^^^^ help: consider using: `u128::BITS`
+
+error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
+  --> $DIR/manual_bits.rs:35:5
+   |
+LL |     8 * size_of::<usize>();
+   |     ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `usize::BITS`
+
+error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
+  --> $DIR/manual_bits.rs:45:5
+   |
+LL |     size_of::<Word>() * 8;
+   |     ^^^^^^^^^^^^^^^^^^^^^ help: consider using: `Word::BITS`
+
+error: aborting due to 25 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 04eb27aeaf283415011d7786fa4091f0ceaf8a11 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Thu, 9 Dec 2021 20:42:44 +0000
Subject: Use method name from conf::DisallowedMethod

Since def_path_str returns e.g. "core::f32::<impl f32>::clamp" for
"f32::clamp"
---
 clippy_lints/src/disallowed_methods.rs             | 29 +++++++++-------------
 clippy_lints/src/utils/conf.rs                     |  8 ++++++
 tests/ui-toml/toml_disallowed_methods/clippy.toml  |  2 ++
 .../conf_disallowed_methods.rs                     |  7 +++++-
 .../conf_disallowed_methods.stderr                 | 14 ++++++++++-
 5 files changed, 41 insertions(+), 19 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/disallowed_methods.rs b/clippy_lints/src/disallowed_methods.rs
index 6d5b1efe270..73c00d97020 100644
--- a/clippy_lints/src/disallowed_methods.rs
+++ b/clippy_lints/src/disallowed_methods.rs
@@ -59,7 +59,7 @@ declare_clippy_lint! {
 #[derive(Clone, Debug)]
 pub struct DisallowedMethods {
     conf_disallowed: Vec<conf::DisallowedMethod>,
-    disallowed: DefIdMap<Option<String>>,
+    disallowed: DefIdMap<usize>,
 }
 
 impl DisallowedMethods {
@@ -75,17 +75,10 @@ impl_lint_pass!(DisallowedMethods => [DISALLOWED_METHODS]);
 
 impl<'tcx> LateLintPass<'tcx> for DisallowedMethods {
     fn check_crate(&mut self, cx: &LateContext<'_>) {
-        for conf in &self.conf_disallowed {
-            let (path, reason) = match conf {
-                conf::DisallowedMethod::Simple(path) => (path, None),
-                conf::DisallowedMethod::WithReason { path, reason } => (
-                    path,
-                    reason.as_ref().map(|reason| format!("{} (from clippy.toml)", reason)),
-                ),
-            };
-            let segs: Vec<_> = path.split("::").collect();
+        for (index, conf) in self.conf_disallowed.iter().enumerate() {
+            let segs: Vec<_> = conf.path().split("::").collect();
             if let Res::Def(_, id) = clippy_utils::path_to_res(cx, &segs) {
-                self.disallowed.insert(id, reason);
+                self.disallowed.insert(id, index);
             }
         }
     }
@@ -95,15 +88,17 @@ impl<'tcx> LateLintPass<'tcx> for DisallowedMethods {
             Some(def_id) => def_id,
             None => return,
         };
-        let reason = match self.disallowed.get(&def_id) {
-            Some(reason) => reason,
+        let conf = match self.disallowed.get(&def_id) {
+            Some(&index) => &self.conf_disallowed[index],
             None => return,
         };
-        let func_path = cx.tcx.def_path_str(def_id);
-        let msg = format!("use of a disallowed method `{}`", func_path);
+        let msg = format!("use of a disallowed method `{}`", conf.path());
         span_lint_and_then(cx, DISALLOWED_METHODS, expr.span, &msg, |diag| {
-            if let Some(reason) = reason {
-                diag.note(reason);
+            if let conf::DisallowedMethod::WithReason {
+                reason: Some(reason), ..
+            } = conf
+            {
+                diag.note(&format!("{} (from clippy.toml)", reason));
             }
         });
     }
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 4e1c538c1c2..d6deb50cc90 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -23,6 +23,14 @@ pub enum DisallowedMethod {
     WithReason { path: String, reason: Option<String> },
 }
 
+impl DisallowedMethod {
+    pub fn path(&self) -> &str {
+        let (Self::Simple(path) | Self::WithReason { path, .. }) = self;
+
+        path
+    }
+}
+
 /// A single disallowed type, used by the `DISALLOWED_TYPES` lint.
 #[derive(Clone, Debug, Deserialize)]
 #[serde(untagged)]
diff --git a/tests/ui-toml/toml_disallowed_methods/clippy.toml b/tests/ui-toml/toml_disallowed_methods/clippy.toml
index f1d4a4619c5..c902d21123d 100644
--- a/tests/ui-toml/toml_disallowed_methods/clippy.toml
+++ b/tests/ui-toml/toml_disallowed_methods/clippy.toml
@@ -1,6 +1,8 @@
 disallowed-methods = [
     # just a string is shorthand for path only
     "std::iter::Iterator::sum",
+    "f32::clamp",
+    "slice::sort_unstable",
     # can give path and reason with an inline table
     { path = "regex::Regex::is_match", reason = "no matching allowed" },
     # can use an inline table but omit reason
diff --git a/tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.rs b/tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.rs
index cb449b45bde..338b3b5b28f 100644
--- a/tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.rs
+++ b/tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.rs
@@ -7,6 +7,11 @@ fn main() {
     let re = Regex::new(r"ab.*c").unwrap();
     re.is_match("abc");
 
-    let a = vec![1, 2, 3, 4];
+    let mut a = vec![1, 2, 3, 4];
     a.iter().sum::<i32>();
+
+    a.sort_unstable();
+
+    let _ = 2.0f32.clamp(3.0f32, 4.0f32);
+    let _ = 2.0f64.clamp(3.0f64, 4.0f64);
 }
diff --git a/tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.stderr b/tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.stderr
index 999ead10d51..5533676aea2 100644
--- a/tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.stderr
+++ b/tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.stderr
@@ -20,5 +20,17 @@ error: use of a disallowed method `std::iter::Iterator::sum`
 LL |     a.iter().sum::<i32>();
    |     ^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 3 previous errors
+error: use of a disallowed method `slice::sort_unstable`
+  --> $DIR/conf_disallowed_methods.rs:13:5
+   |
+LL |     a.sort_unstable();
+   |     ^^^^^^^^^^^^^^^^^
+
+error: use of a disallowed method `f32::clamp`
+  --> $DIR/conf_disallowed_methods.rs:15:13
+   |
+LL |     let _ = 2.0f32.clamp(3.0f32, 4.0f32);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 5 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From ad95279c34272949d6babc31d54209434a97f46e Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Wed, 5 Jan 2022 18:27:10 -0500
Subject: Suggest deref when needed in `implicit_clone`

---
 clippy_lints/src/methods/implicit_clone.rs | 21 ++++++++----
 clippy_lints/src/methods/mod.rs            |  2 +-
 tests/ui/implicit_clone.rs                 |  9 +++++
 tests/ui/implicit_clone.stderr             | 54 ++++++++++++++++++------------
 4 files changed, 58 insertions(+), 28 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/implicit_clone.rs b/clippy_lints/src/methods/implicit_clone.rs
index 90492ffda3c..865e7702b71 100644
--- a/clippy_lints/src/methods/implicit_clone.rs
+++ b/clippy_lints/src/methods/implicit_clone.rs
@@ -1,31 +1,40 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet_with_context;
+use clippy_utils::ty::peel_mid_ty_refs;
 use clippy_utils::{is_diag_item_method, is_diag_trait_item};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
 use rustc_middle::ty::TyS;
-use rustc_span::{sym, Span};
+use rustc_span::sym;
 
 use super::IMPLICIT_CLONE;
 
-pub fn check(cx: &LateContext<'_>, method_name: &str, expr: &hir::Expr<'_>, recv: &hir::Expr<'_>, span: Span) {
+pub fn check(cx: &LateContext<'_>, method_name: &str, expr: &hir::Expr<'_>, recv: &hir::Expr<'_>) {
     if_chain! {
         if let Some(method_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
         if is_clone_like(cx, method_name, method_def_id);
         let return_type = cx.typeck_results().expr_ty(expr);
-        let input_type = cx.typeck_results().expr_ty(recv).peel_refs();
+        let input_type = cx.typeck_results().expr_ty(recv);
+        let (input_type, ref_count) = peel_mid_ty_refs(input_type);
         if let Some(ty_name) = input_type.ty_adt_def().map(|adt_def| cx.tcx.item_name(adt_def.did));
         if TyS::same_type(return_type, input_type);
         then {
+            let mut app = Applicability::MachineApplicable;
+            let recv_snip = snippet_with_context(cx, recv.span, expr.span.ctxt(), "..", &mut app).0;
             span_lint_and_sugg(
                 cx,
                 IMPLICIT_CLONE,
-                span,
+                expr.span,
                 &format!("implicitly cloning a `{}` by calling `{}` on its dereferenced type", ty_name, method_name),
                 "consider using",
-                "clone".to_string(),
-                Applicability::MachineApplicable
+                if ref_count > 1 {
+                    format!("({}{}).clone()", "*".repeat(ref_count - 1), recv_snip)
+                } else {
+                    format!("{}.clone()", recv_snip)
+                },
+                app,
             );
         }
     }
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 8a2a468c852..ae5bfadbc5f 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -2342,7 +2342,7 @@ fn check_methods<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, msrv: Optio
             },
             ("step_by", [arg]) => iterator_step_by_zero::check(cx, expr, arg),
             ("to_os_string" | "to_owned" | "to_path_buf" | "to_vec", []) => {
-                implicit_clone::check(cx, name, expr, recv, span);
+                implicit_clone::check(cx, name, expr, recv);
             },
             ("unwrap", []) => match method_call!(recv) {
                 Some(("get", [recv, get_arg], _)) => get_unwrap::check(cx, expr, recv, get_arg, false),
diff --git a/tests/ui/implicit_clone.rs b/tests/ui/implicit_clone.rs
index cef71cf79d7..639fecb8927 100644
--- a/tests/ui/implicit_clone.rs
+++ b/tests/ui/implicit_clone.rs
@@ -105,4 +105,13 @@ fn main() {
     let os_str = OsStr::new("foo");
     let _ = os_str.to_owned();
     let _ = os_str.to_os_string();
+
+    // issue #8227
+    let pathbuf_ref = &pathbuf;
+    let pathbuf_ref = &pathbuf_ref;
+    let _ = pathbuf_ref.to_owned(); // Don't lint. Returns `&PathBuf`
+    let _ = pathbuf_ref.to_path_buf();
+    let pathbuf_ref = &pathbuf_ref;
+    let _ = pathbuf_ref.to_owned(); // Don't lint. Returns `&&PathBuf`
+    let _ = pathbuf_ref.to_path_buf();
 }
diff --git a/tests/ui/implicit_clone.stderr b/tests/ui/implicit_clone.stderr
index e6f7527b672..0f412424190 100644
--- a/tests/ui/implicit_clone.stderr
+++ b/tests/ui/implicit_clone.stderr
@@ -1,64 +1,76 @@
 error: implicitly cloning a `Vec` by calling `to_owned` on its dereferenced type
-  --> $DIR/implicit_clone.rs:65:17
+  --> $DIR/implicit_clone.rs:65:13
    |
 LL |     let _ = vec.to_owned();
-   |                 ^^^^^^^^ help: consider using: `clone`
+   |             ^^^^^^^^^^^^^^ help: consider using: `vec.clone()`
    |
    = note: `-D clippy::implicit-clone` implied by `-D warnings`
 
 error: implicitly cloning a `Vec` by calling `to_vec` on its dereferenced type
-  --> $DIR/implicit_clone.rs:66:17
+  --> $DIR/implicit_clone.rs:66:13
    |
 LL |     let _ = vec.to_vec();
-   |                 ^^^^^^ help: consider using: `clone`
+   |             ^^^^^^^^^^^^ help: consider using: `vec.clone()`
 
 error: implicitly cloning a `Vec` by calling `to_owned` on its dereferenced type
-  --> $DIR/implicit_clone.rs:70:21
+  --> $DIR/implicit_clone.rs:70:13
    |
 LL |     let _ = vec_ref.to_owned();
-   |                     ^^^^^^^^ help: consider using: `clone`
+   |             ^^^^^^^^^^^^^^^^^^ help: consider using: `vec_ref.clone()`
 
 error: implicitly cloning a `Vec` by calling `to_vec` on its dereferenced type
-  --> $DIR/implicit_clone.rs:71:21
+  --> $DIR/implicit_clone.rs:71:13
    |
 LL |     let _ = vec_ref.to_vec();
-   |                     ^^^^^^ help: consider using: `clone`
+   |             ^^^^^^^^^^^^^^^^ help: consider using: `vec_ref.clone()`
 
 error: implicitly cloning a `String` by calling `to_owned` on its dereferenced type
-  --> $DIR/implicit_clone.rs:83:17
+  --> $DIR/implicit_clone.rs:83:13
    |
 LL |     let _ = str.to_owned();
-   |                 ^^^^^^^^ help: consider using: `clone`
+   |             ^^^^^^^^^^^^^^ help: consider using: `str.clone()`
 
 error: implicitly cloning a `Kitten` by calling `to_owned` on its dereferenced type
-  --> $DIR/implicit_clone.rs:87:20
+  --> $DIR/implicit_clone.rs:87:13
    |
 LL |     let _ = kitten.to_owned();
-   |                    ^^^^^^^^ help: consider using: `clone`
+   |             ^^^^^^^^^^^^^^^^^ help: consider using: `kitten.clone()`
 
 error: implicitly cloning a `PathBuf` by calling `to_owned` on its dereferenced type
-  --> $DIR/implicit_clone.rs:97:21
+  --> $DIR/implicit_clone.rs:97:13
    |
 LL |     let _ = pathbuf.to_owned();
-   |                     ^^^^^^^^ help: consider using: `clone`
+   |             ^^^^^^^^^^^^^^^^^^ help: consider using: `pathbuf.clone()`
 
 error: implicitly cloning a `PathBuf` by calling `to_path_buf` on its dereferenced type
-  --> $DIR/implicit_clone.rs:98:21
+  --> $DIR/implicit_clone.rs:98:13
    |
 LL |     let _ = pathbuf.to_path_buf();
-   |                     ^^^^^^^^^^^ help: consider using: `clone`
+   |             ^^^^^^^^^^^^^^^^^^^^^ help: consider using: `pathbuf.clone()`
 
 error: implicitly cloning a `OsString` by calling `to_owned` on its dereferenced type
-  --> $DIR/implicit_clone.rs:101:23
+  --> $DIR/implicit_clone.rs:101:13
    |
 LL |     let _ = os_string.to_owned();
-   |                       ^^^^^^^^ help: consider using: `clone`
+   |             ^^^^^^^^^^^^^^^^^^^^ help: consider using: `os_string.clone()`
 
 error: implicitly cloning a `OsString` by calling `to_os_string` on its dereferenced type
-  --> $DIR/implicit_clone.rs:102:23
+  --> $DIR/implicit_clone.rs:102:13
    |
 LL |     let _ = os_string.to_os_string();
-   |                       ^^^^^^^^^^^^ help: consider using: `clone`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `os_string.clone()`
 
-error: aborting due to 10 previous errors
+error: implicitly cloning a `PathBuf` by calling `to_path_buf` on its dereferenced type
+  --> $DIR/implicit_clone.rs:113:13
+   |
+LL |     let _ = pathbuf_ref.to_path_buf();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(*pathbuf_ref).clone()`
+
+error: implicitly cloning a `PathBuf` by calling `to_path_buf` on its dereferenced type
+  --> $DIR/implicit_clone.rs:116:13
+   |
+LL |     let _ = pathbuf_ref.to_path_buf();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(**pathbuf_ref).clone()`
+
+error: aborting due to 12 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 7ed86bf82210042a894620e1537e86a7fe2ce5b6 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sun, 9 Jan 2022 09:35:55 -0500
Subject: Changes to `ptr_arg`

* Track the argument when used to initialize simple `let` bindings
* Check if the argument is passed to a function requiring the original type
* Use `multipart_suggestion` rather than multiple suggestions
* Check if the name given in the source code matches the name of the actual type
---
 clippy_lints/src/ptr.rs                     | 605 +++++++++++++++++++---------
 clippy_lints/src/unnested_or_patterns.rs    |   4 +-
 clippy_utils/src/lib.rs                     |  32 +-
 clippy_utils/src/ty.rs                      | 113 +++++-
 tests/ui/ptr_arg.rs                         |  29 +-
 tests/ui/ptr_arg.stderr                     | 158 ++++----
 tests/ui/search_is_some_fixable_none.rs     |   2 +-
 tests/ui/search_is_some_fixable_none.stderr |  10 +-
 tests/ui/search_is_some_fixable_some.rs     |   2 +-
 tests/ui/search_is_some_fixable_some.stderr |  10 +-
 tests/ui/slow_vector_initialization.rs      |   2 +-
 11 files changed, 643 insertions(+), 324 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs
index c08a19d520b..b74ba40d452 100644
--- a/clippy_lints/src/ptr.rs
+++ b/clippy_lints/src/ptr.rs
@@ -1,30 +1,36 @@
 //! Checks for usage of  `&Vec[_]` and `&String`.
 
 use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg, span_lint_and_then};
-use clippy_utils::ptr::get_spans;
 use clippy_utils::source::snippet_opt;
-use clippy_utils::ty::walk_ptrs_hir_ty;
-use clippy_utils::{expr_path_res, is_lint_allowed, match_any_diagnostic_items, paths};
+use clippy_utils::ty::expr_sig;
+use clippy_utils::{
+    expr_path_res, get_expr_use_or_unification_node, is_lint_allowed, match_any_diagnostic_items, path_to_local, paths,
+};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
-use rustc_hir::def::Res;
+use rustc_hir::def_id::DefId;
+use rustc_hir::hir_id::HirIdMap;
+use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor};
 use rustc_hir::{
-    BinOpKind, BodyId, Expr, ExprKind, FnDecl, FnRetTy, GenericArg, Impl, ImplItem, ImplItemKind, Item, ItemKind,
-    Lifetime, MutTy, Mutability, Node, PathSegment, QPath, TraitFn, TraitItem, TraitItemKind, Ty, TyKind,
+    self as hir, AnonConst, BinOpKind, BindingAnnotation, Body, Expr, ExprKind, FnDecl, FnRetTy, GenericArg,
+    ImplItemKind, ItemKind, Lifetime, LifetimeName, Mutability, Node, Param, ParamName, PatKind, QPath, TraitFn,
+    TraitItem, TraitItemKind, TyKind,
 };
 use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::hir::map::Map;
+use rustc_middle::ty::{self, AssocItems, AssocKind, Ty};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
 use rustc_span::symbol::Symbol;
 use rustc_span::{sym, MultiSpan};
-use std::borrow::Cow;
+use std::fmt;
+use std::iter;
 
 declare_clippy_lint! {
     /// ### What it does
-    /// This lint checks for function arguments of type `&String`
-    /// or `&Vec` unless the references are mutable. It will also suggest you
-    /// replace `.clone()` calls with the appropriate `.to_owned()`/`to_string()`
-    /// calls.
+    /// This lint checks for function arguments of type `&String`, `&Vec`,
+    /// `&PathBuf`, and `Cow<_>`. It will also suggest you replace `.clone()` calls
+    /// with the appropriate `.to_owned()`/`to_string()` calls.
     ///
     /// ### Why is this bad?
     /// Requiring the argument to be of the specific size
@@ -32,28 +38,7 @@ declare_clippy_lint! {
     /// or `&str` usually suffice and can be obtained from other types, too.
     ///
     /// ### Known problems
-    /// The lint does not follow data. So if you have an
-    /// argument `x` and write `let y = x; y.clone()` the lint will not suggest
-    /// changing that `.clone()` to `.to_owned()`.
-    ///
-    /// Other functions called from this function taking a `&String` or `&Vec`
-    /// argument may also fail to compile if you change the argument. Applying
-    /// this lint on them will fix the problem, but they may be in other crates.
-    ///
-    /// One notable example of a function that may cause issues, and which cannot
-    /// easily be changed due to being in the standard library is `Vec::contains`.
-    /// when called on a `Vec<Vec<T>>`. If a `&Vec` is passed to that method then
-    /// it will compile, but if a `&[T]` is passed then it will not compile.
-    ///
-    /// ```ignore
-    /// fn cannot_take_a_slice(v: &Vec<u8>) -> bool {
-    ///     let vec_of_vecs: Vec<Vec<u8>> = some_other_fn();
-    ///
-    ///     vec_of_vecs.contains(v)
-    /// }
-    /// ```
-    ///
-    /// Also there may be `fn(&Vec)`-typed references pointing to your function.
+    /// There may be `fn(&Vec)`-typed references pointing to your function.
     /// If you have them, you will get a compiler error after applying this lint's
     /// suggestions. You then have the choice to undo your changes or change the
     /// type of the reference.
@@ -155,32 +140,86 @@ declare_clippy_lint! {
 declare_lint_pass!(Ptr => [PTR_ARG, CMP_NULL, MUT_FROM_REF, INVALID_NULL_PTR_USAGE]);
 
 impl<'tcx> LateLintPass<'tcx> for Ptr {
-    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
-        if let ItemKind::Fn(ref sig, _, body_id) = item.kind {
-            check_fn(cx, sig.decl, Some(body_id));
-        }
-    }
+    fn check_trait_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx TraitItem<'_>) {
+        if let TraitItemKind::Fn(sig, trait_method) = &item.kind {
+            if matches!(trait_method, TraitFn::Provided(_)) {
+                // Handled by check body.
+                return;
+            }
 
-    fn check_impl_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx ImplItem<'_>) {
-        if let ImplItemKind::Fn(ref sig, body_id) = item.kind {
-            let parent_item = cx.tcx.hir().get_parent_item(item.hir_id());
-            if let Some(Node::Item(it)) = cx.tcx.hir().find(parent_item) {
-                if let ItemKind::Impl(Impl { of_trait: Some(_), .. }) = it.kind {
-                    return; // ignore trait impls
-                }
+            check_mut_from_ref(cx, sig.decl);
+            for arg in check_fn_args(
+                cx,
+                cx.tcx.fn_sig(item.def_id).skip_binder().inputs(),
+                sig.decl.inputs,
+                &[],
+            ) {
+                span_lint_and_sugg(
+                    cx,
+                    PTR_ARG,
+                    arg.span,
+                    &arg.build_msg(),
+                    "change this to",
+                    format!("{}{}", arg.ref_prefix, arg.deref_ty.display(cx)),
+                    Applicability::Unspecified,
+                );
             }
-            check_fn(cx, sig.decl, Some(body_id));
         }
     }
 
-    fn check_trait_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx TraitItem<'_>) {
-        if let TraitItemKind::Fn(ref sig, ref trait_method) = item.kind {
-            let body_id = if let TraitFn::Provided(b) = *trait_method {
-                Some(b)
-            } else {
-                None
-            };
-            check_fn(cx, sig.decl, body_id);
+    fn check_body(&mut self, cx: &LateContext<'tcx>, body: &'tcx Body<'_>) {
+        let hir = cx.tcx.hir();
+        let mut parents = hir.parent_iter(body.value.hir_id);
+        let (item_id, decl) = match parents.next() {
+            Some((_, Node::Item(i))) => {
+                if let ItemKind::Fn(sig, ..) = &i.kind {
+                    (i.def_id, sig.decl)
+                } else {
+                    return;
+                }
+            },
+            Some((_, Node::ImplItem(i))) => {
+                if !matches!(parents.next(),
+                    Some((_, Node::Item(i))) if matches!(&i.kind, ItemKind::Impl(i) if i.of_trait.is_none())
+                ) {
+                    return;
+                }
+                if let ImplItemKind::Fn(sig, _) = &i.kind {
+                    (i.def_id, sig.decl)
+                } else {
+                    return;
+                }
+            },
+            Some((_, Node::TraitItem(i))) => {
+                if let TraitItemKind::Fn(sig, _) = &i.kind {
+                    (i.def_id, sig.decl)
+                } else {
+                    return;
+                }
+            },
+            _ => return,
+        };
+
+        check_mut_from_ref(cx, decl);
+        let sig = cx.tcx.fn_sig(item_id).skip_binder();
+        let lint_args: Vec<_> = check_fn_args(cx, sig.inputs(), decl.inputs, body.params).collect();
+        let results = check_ptr_arg_usage(cx, body, &lint_args);
+
+        for (result, args) in results.iter().zip(lint_args.iter()).filter(|(r, _)| !r.skip) {
+            span_lint_and_then(cx, PTR_ARG, args.span, &args.build_msg(), |diag| {
+                diag.multipart_suggestion(
+                    "change this to",
+                    iter::once((args.span, format!("{}{}", args.ref_prefix, args.deref_ty.display(cx))))
+                        .chain(result.replacements.iter().map(|r| {
+                            (
+                                r.expr_span,
+                                format!("{}{}", snippet_opt(cx, r.self_span).unwrap(), r.replacement),
+                            )
+                        }))
+                        .collect(),
+                    Applicability::Unspecified,
+                );
+            });
         }
     }
 
@@ -247,154 +286,202 @@ fn check_invalid_ptr_usage<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
     }
 }
 
-#[allow(clippy::too_many_lines)]
-fn check_fn(cx: &LateContext<'_>, decl: &FnDecl<'_>, opt_body_id: Option<BodyId>) {
-    let body = opt_body_id.map(|id| cx.tcx.hir().body(id));
-
-    for (idx, arg) in decl.inputs.iter().enumerate() {
-        // Honor the allow attribute on parameters. See issue 5644.
-        if let Some(body) = &body {
-            if is_lint_allowed(cx, PTR_ARG, body.params[idx].hir_id) {
-                continue;
-            }
-        }
+#[derive(Default)]
+struct PtrArgResult {
+    skip: bool,
+    replacements: Vec<PtrArgReplacement>,
+}
 
-        let (item_name, path) = if_chain! {
-            if let TyKind::Rptr(_, MutTy { ty, mutbl: Mutability::Not }) = arg.kind;
-            if let TyKind::Path(QPath::Resolved(_, path)) = ty.kind;
-            if let Res::Def(_, did) = path.res;
-            if let Some(item_name) = cx.tcx.get_diagnostic_name(did);
-            then {
-                (item_name, path)
-            } else {
-                continue
-            }
-        };
+struct PtrArgReplacement {
+    expr_span: Span,
+    self_span: Span,
+    replacement: &'static str,
+}
 
-        match item_name {
-            sym::Vec => {
-                if let Some(spans) = get_spans(cx, opt_body_id, idx, &[("clone", ".to_owned()")]) {
-                    span_lint_and_then(
-                        cx,
-                        PTR_ARG,
-                        arg.span,
-                        "writing `&Vec<_>` instead of `&[_]` involves one more reference and cannot be used \
-                         with non-Vec-based slices",
-                        |diag| {
-                            if let Some(ref snippet) = get_only_generic_arg_snippet(cx, arg) {
-                                diag.span_suggestion(
-                                    arg.span,
-                                    "change this to",
-                                    format!("&[{}]", snippet),
-                                    Applicability::Unspecified,
-                                );
-                            }
-                            for (clonespan, suggestion) in spans {
-                                diag.span_suggestion(
-                                    clonespan,
-                                    &snippet_opt(cx, clonespan).map_or("change the call to".into(), |x| {
-                                        Cow::Owned(format!("change `{}` to", x))
-                                    }),
-                                    suggestion.into(),
-                                    Applicability::Unspecified,
-                                );
-                            }
-                        },
-                    );
-                }
-            },
-            sym::String => {
-                if let Some(spans) = get_spans(cx, opt_body_id, idx, &[("clone", ".to_string()"), ("as_str", "")]) {
-                    span_lint_and_then(
-                        cx,
-                        PTR_ARG,
-                        arg.span,
-                        "writing `&String` instead of `&str` involves a new object where a slice will do",
-                        |diag| {
-                            diag.span_suggestion(arg.span, "change this to", "&str".into(), Applicability::Unspecified);
-                            for (clonespan, suggestion) in spans {
-                                diag.span_suggestion_short(
-                                    clonespan,
-                                    &snippet_opt(cx, clonespan).map_or("change the call to".into(), |x| {
-                                        Cow::Owned(format!("change `{}` to", x))
-                                    }),
-                                    suggestion.into(),
-                                    Applicability::Unspecified,
-                                );
-                            }
-                        },
-                    );
-                }
+struct PtrArg<'tcx> {
+    idx: usize,
+    span: Span,
+    ty_did: DefId,
+    ty_name: Symbol,
+    method_renames: &'static [(&'static str, &'static str)],
+    ref_prefix: RefPrefix,
+    deref_ty: DerefTy<'tcx>,
+    deref_assoc_items: Option<(DefId, &'tcx AssocItems<'tcx>)>,
+}
+impl PtrArg<'_> {
+    fn build_msg(&self) -> String {
+        format!(
+            "writing `&{}{}` instead of `&{}{}` involves a new object where a slice will do",
+            self.ref_prefix.mutability.prefix_str(),
+            self.ty_name,
+            self.ref_prefix.mutability.prefix_str(),
+            self.deref_ty.argless_str(),
+        )
+    }
+}
+
+struct RefPrefix {
+    lt: LifetimeName,
+    mutability: Mutability,
+}
+impl fmt::Display for RefPrefix {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        use fmt::Write;
+        f.write_char('&')?;
+        match self.lt {
+            LifetimeName::Param(ParamName::Plain(name)) => {
+                name.fmt(f)?;
+                f.write_char(' ')?;
             },
-            sym::PathBuf => {
-                if let Some(spans) = get_spans(cx, opt_body_id, idx, &[("clone", ".to_path_buf()"), ("as_path", "")]) {
-                    span_lint_and_then(
-                        cx,
-                        PTR_ARG,
-                        arg.span,
-                        "writing `&PathBuf` instead of `&Path` involves a new object where a slice will do",
-                        |diag| {
-                            diag.span_suggestion(
-                                arg.span,
-                                "change this to",
-                                "&Path".into(),
-                                Applicability::Unspecified,
-                            );
-                            for (clonespan, suggestion) in spans {
-                                diag.span_suggestion_short(
-                                    clonespan,
-                                    &snippet_opt(cx, clonespan).map_or("change the call to".into(), |x| {
-                                        Cow::Owned(format!("change `{}` to", x))
-                                    }),
-                                    suggestion.into(),
-                                    Applicability::Unspecified,
-                                );
-                            }
-                        },
-                    );
+            LifetimeName::Underscore => f.write_str("'_ ")?,
+            LifetimeName::Static => f.write_str("'static ")?,
+            _ => (),
+        }
+        f.write_str(self.mutability.prefix_str())
+    }
+}
+
+struct DerefTyDisplay<'a, 'tcx>(&'a LateContext<'tcx>, &'a DerefTy<'tcx>);
+impl fmt::Display for DerefTyDisplay<'_, '_> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        use std::fmt::Write;
+        match self.1 {
+            DerefTy::Str => f.write_str("str"),
+            DerefTy::Path => f.write_str("Path"),
+            DerefTy::Slice(hir_ty, ty) => {
+                f.write_char('[')?;
+                match hir_ty.and_then(|s| snippet_opt(self.0, s)) {
+                    Some(s) => f.write_str(&s)?,
+                    None => ty.fmt(f)?,
                 }
+                f.write_char(']')
             },
-            sym::Cow => {
-                if_chain! {
-                    if let [ref bx] = *path.segments;
-                    if let Some(params) = bx.args;
-                    if !params.parenthesized;
-                    if let Some(inner) = params.args.iter().find_map(|arg| match arg {
-                        GenericArg::Type(ty) => Some(ty),
-                        _ => None,
-                    });
-                    let replacement = snippet_opt(cx, inner.span);
-                    if let Some(r) = replacement;
-                    then {
+        }
+    }
+}
+
+enum DerefTy<'tcx> {
+    Str,
+    Path,
+    Slice(Option<Span>, Ty<'tcx>),
+}
+impl<'tcx> DerefTy<'tcx> {
+    fn argless_str(&self) -> &'static str {
+        match *self {
+            Self::Str => "str",
+            Self::Path => "Path",
+            Self::Slice(..) => "[_]",
+        }
+    }
+
+    fn display<'a>(&'a self, cx: &'a LateContext<'tcx>) -> DerefTyDisplay<'a, 'tcx> {
+        DerefTyDisplay(cx, self)
+    }
+}
+
+fn check_fn_args<'cx, 'tcx: 'cx>(
+    cx: &'cx LateContext<'tcx>,
+    tys: &'tcx [Ty<'_>],
+    hir_tys: &'tcx [hir::Ty<'_>],
+    params: &'tcx [Param<'_>],
+) -> impl Iterator<Item = PtrArg<'tcx>> + 'cx {
+    tys.iter().enumerate().filter_map(|(i, ty)| {
+        if_chain! {
+            if let ty::Ref(_, ty, mutability) = *ty.kind();
+            if let ty::Adt(adt, substs) = *ty.kind();
+
+            let hir_ty = &hir_tys[i];
+            if let TyKind::Rptr(lt, ref ty) = hir_ty.kind;
+            if let TyKind::Path(QPath::Resolved(None, path)) = ty.ty.kind;
+
+            if let [.., name] = path.segments;
+            if cx.tcx.item_name(adt.did) == name.ident.name;
+
+            if !is_lint_allowed(cx, PTR_ARG, hir_ty.hir_id);
+            if params.get(i).map_or(true, |p| !is_lint_allowed(cx, PTR_ARG, p.hir_id));
+
+            then {
+                let (method_renames, deref_ty, deref_impl_id) = match cx.tcx.get_diagnostic_name(adt.did) {
+                    Some(sym::Vec) => (
+                        [("clone", ".to_owned()")].as_slice(),
+                        DerefTy::Slice(
+                            name.args
+                                .and_then(|args| args.args.first())
+                                .and_then(|arg| if let GenericArg::Type(ty) = arg {
+                                    Some(ty.span)
+                                } else {
+                                    None
+                                }),
+                            substs.type_at(0),
+                        ),
+                        cx.tcx.lang_items().slice_impl()
+                    ),
+                    Some(sym::String) => (
+                        [("clone", ".to_owned()"), ("as_str", "")].as_slice(),
+                        DerefTy::Str,
+                        cx.tcx.lang_items().str_impl()
+                    ),
+                    Some(sym::PathBuf) => (
+                        [("clone", ".to_path_buf()"), ("as_path", "")].as_slice(),
+                        DerefTy::Path,
+                        None,
+                    ),
+                    Some(sym::Cow) => {
+                        let ty_name = name.args
+                            .and_then(|args| {
+                                args.args.iter().find_map(|a| match a {
+                                    GenericArg::Type(x) => Some(x),
+                                    _ => None,
+                                })
+                            })
+                            .and_then(|arg| snippet_opt(cx, arg.span))
+                            .unwrap_or_else(|| substs.type_at(1).to_string());
                         span_lint_and_sugg(
                             cx,
                             PTR_ARG,
-                            arg.span,
+                            hir_ty.span,
                             "using a reference to `Cow` is not recommended",
                             "change this to",
-                            "&".to_owned() + &r,
+                            format!("&{}{}", mutability.prefix_str(), ty_name),
                             Applicability::Unspecified,
                         );
-                    }
-                }
-            },
-            _ => {},
+                        return None;
+                    },
+                    _ => return None,
+                };
+                return Some(PtrArg {
+                    idx: i,
+                    span: hir_ty.span,
+                    ty_did: adt.did,
+                    ty_name: name.ident.name,
+                    method_renames,
+                    ref_prefix: RefPrefix {
+                        lt: lt.name,
+                        mutability,
+                    },
+                    deref_ty,
+                    deref_assoc_items: deref_impl_id.map(|id| (id, cx.tcx.associated_items(id))),
+                });
+            }
         }
-    }
+        None
+    })
+}
 
+fn check_mut_from_ref(cx: &LateContext<'_>, decl: &FnDecl<'_>) {
     if let FnRetTy::Return(ty) = decl.output {
         if let Some((out, Mutability::Mut, _)) = get_rptr_lm(ty) {
             let mut immutables = vec![];
-            for (_, ref mutbl, ref argspan) in decl
+            for (_, mutbl, argspan) in decl
                 .inputs
                 .iter()
                 .filter_map(get_rptr_lm)
                 .filter(|&(lt, _, _)| lt.name == out.name)
             {
-                if *mutbl == Mutability::Mut {
+                if mutbl == Mutability::Mut {
                     return;
                 }
-                immutables.push(*argspan);
+                immutables.push(argspan);
             }
             if immutables.is_empty() {
                 return;
@@ -413,24 +500,158 @@ fn check_fn(cx: &LateContext<'_>, decl: &FnDecl<'_>, opt_body_id: Option<BodyId>
     }
 }
 
-fn get_only_generic_arg_snippet(cx: &LateContext<'_>, arg: &Ty<'_>) -> Option<String> {
-    if_chain! {
-        if let TyKind::Path(QPath::Resolved(_, path)) = walk_ptrs_hir_ty(arg).kind;
-        if let Some(&PathSegment{args: Some(parameters), ..}) = path.segments.last();
-        let types: Vec<_> = parameters.args.iter().filter_map(|arg| match arg {
-            GenericArg::Type(ty) => Some(ty),
-            _ => None,
-        }).collect();
-        if types.len() == 1;
-        then {
-            snippet_opt(cx, types[0].span)
-        } else {
-            None
+#[allow(clippy::too_many_lines)]
+fn check_ptr_arg_usage<'tcx>(cx: &LateContext<'tcx>, body: &'tcx Body<'_>, args: &[PtrArg<'tcx>]) -> Vec<PtrArgResult> {
+    struct V<'cx, 'tcx> {
+        cx: &'cx LateContext<'tcx>,
+        /// Map from a local id to which argument it cam from (index into `Self::args` and
+        /// `Self::results`)
+        bindings: HirIdMap<usize>,
+        /// The arguments being checked.
+        args: &'cx [PtrArg<'tcx>],
+        /// The results for each argument (len should match args.len)
+        results: Vec<PtrArgResult>,
+        /// The number of arguments which can't be linted. Used to return early.
+        skip_count: usize,
+    }
+    impl<'tcx> Visitor<'tcx> for V<'_, 'tcx> {
+        type Map = Map<'tcx>;
+        fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+            NestedVisitorMap::OnlyBodies(self.cx.tcx.hir())
+        }
+
+        fn visit_anon_const(&mut self, _: &'tcx AnonConst) {}
+
+        fn visit_expr(&mut self, e: &'tcx Expr<'_>) {
+            if self.skip_count == self.args.len() {
+                return;
+            }
+
+            // Check if this is local we care about
+            let args_idx = match path_to_local(e).and_then(|id| self.bindings.get(&id)) {
+                Some(&i) => i,
+                None => return walk_expr(self, e),
+            };
+            let args = &self.args[args_idx];
+            let result = &mut self.results[args_idx];
+
+            // Helper function to handle early returns.
+            let mut set_skip_flag = || {
+                if result.skip {
+                    self.skip_count += 1;
+                }
+                result.skip = true;
+            };
+
+            match get_expr_use_or_unification_node(self.cx.tcx, e) {
+                Some((Node::Stmt(_), _)) => (),
+                Some((Node::Local(l), _)) => {
+                    // Only trace simple bindings. e.g `let x = y;`
+                    if let PatKind::Binding(BindingAnnotation::Unannotated, id, _, None) = l.pat.kind {
+                        self.bindings.insert(id, args_idx);
+                    } else {
+                        set_skip_flag();
+                    }
+                },
+                Some((Node::Expr(e), child_id)) => match e.kind {
+                    ExprKind::Call(f, expr_args) => {
+                        let i = expr_args.iter().position(|arg| arg.hir_id == child_id).unwrap_or(0);
+                        if expr_sig(self.cx, f)
+                            .map(|sig| sig.input(i).skip_binder().peel_refs())
+                            .map_or(true, |ty| match *ty.kind() {
+                                ty::Param(_) => true,
+                                ty::Adt(def, _) => def.did == args.ty_did,
+                                _ => false,
+                            })
+                        {
+                            // Passed to a function taking the non-dereferenced type.
+                            set_skip_flag();
+                        }
+                    },
+                    ExprKind::MethodCall(name, _, expr_args @ [self_arg, ..], _) => {
+                        let i = expr_args.iter().position(|arg| arg.hir_id == child_id).unwrap_or(0);
+                        if i == 0 {
+                            // Check if the method can be renamed.
+                            let name = name.ident.as_str();
+                            if let Some((_, replacement)) = args.method_renames.iter().find(|&&(x, _)| x == name) {
+                                result.replacements.push(PtrArgReplacement {
+                                    expr_span: e.span,
+                                    self_span: self_arg.span,
+                                    replacement,
+                                });
+                                return;
+                            }
+                        }
+
+                        let id = if let Some(x) = self.cx.typeck_results().type_dependent_def_id(e.hir_id) {
+                            x
+                        } else {
+                            set_skip_flag();
+                            return;
+                        };
+
+                        match *self.cx.tcx.fn_sig(id).skip_binder().inputs()[i].peel_refs().kind() {
+                            ty::Param(_) => {
+                                set_skip_flag();
+                            },
+                            // If the types match check for methods which exist on both types. e.g. `Vec::len` and
+                            // `slice::len`
+                            ty::Adt(def, _)
+                                if def.did == args.ty_did
+                                    && (i != 0
+                                        || self.cx.tcx.trait_of_item(id).is_some()
+                                        || !args.deref_assoc_items.map_or(false, |(id, items)| {
+                                            items
+                                                .find_by_name_and_kind(self.cx.tcx, name.ident, AssocKind::Fn, id)
+                                                .is_some()
+                                        })) =>
+                            {
+                                set_skip_flag();
+                            },
+                            _ => (),
+                        }
+                    },
+                    // Indexing is fine for currently supported types.
+                    ExprKind::Index(e, _) if e.hir_id == child_id => (),
+                    _ => set_skip_flag(),
+                },
+                _ => set_skip_flag(),
+            }
         }
     }
+
+    let mut skip_count = 0;
+    let mut results = args.iter().map(|_| PtrArgResult::default()).collect::<Vec<_>>();
+    let mut v = V {
+        cx,
+        bindings: args
+            .iter()
+            .enumerate()
+            .filter_map(|(i, arg)| {
+                let param = &body.params[arg.idx];
+                match param.pat.kind {
+                    PatKind::Binding(BindingAnnotation::Unannotated, id, _, None)
+                        if !is_lint_allowed(cx, PTR_ARG, param.hir_id) =>
+                    {
+                        Some((id, i))
+                    },
+                    _ => {
+                        skip_count += 1;
+                        results[arg.idx].skip = true;
+                        None
+                    },
+                }
+            })
+            .collect(),
+        args,
+        results,
+        skip_count,
+    };
+    v.visit_expr(&body.value);
+    v.results
 }
 
-fn get_rptr_lm<'tcx>(ty: &'tcx Ty<'tcx>) -> Option<(&'tcx Lifetime, Mutability, Span)> {
+fn get_rptr_lm<'tcx>(ty: &'tcx hir::Ty<'tcx>) -> Option<(&'tcx Lifetime, Mutability, Span)> {
     if let TyKind::Rptr(ref lt, ref m) = ty.kind {
         Some((lt, m.mutbl, ty.span))
     } else {
diff --git a/clippy_lints/src/unnested_or_patterns.rs b/clippy_lints/src/unnested_or_patterns.rs
index 0bd151fed91..1d4fe9cfd3c 100644
--- a/clippy_lints/src/unnested_or_patterns.rs
+++ b/clippy_lints/src/unnested_or_patterns.rs
@@ -291,7 +291,7 @@ fn transform_with_focus_on_idx(alternatives: &mut Vec<P<Pat>>, focus_idx: usize)
 fn extend_with_struct_pat(
     qself1: &Option<ast::QSelf>,
     path1: &ast::Path,
-    fps1: &mut Vec<ast::PatField>,
+    fps1: &mut [ast::PatField],
     rest1: bool,
     start: usize,
     alternatives: &mut Vec<P<Pat>>,
@@ -332,7 +332,7 @@ fn extend_with_struct_pat(
 /// while also requiring `ps1[..n] ~ ps2[..n]` (pre) and `ps1[n + 1..] ~ ps2[n + 1..]` (post),
 /// where `~` denotes semantic equality.
 fn extend_with_matching_product(
-    targets: &mut Vec<P<Pat>>,
+    targets: &mut [P<Pat>],
     start: usize,
     alternatives: &mut Vec<P<Pat>>,
     predicate: impl Fn(&PatKind, &[P<Pat>], usize) -> bool,
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 44f634b6519..ea40752af77 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -1843,7 +1843,8 @@ pub fn is_expr_identity_function(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool
 }
 
 /// Gets the node where an expression is either used, or it's type is unified with another branch.
-pub fn get_expr_use_or_unification_node<'tcx>(tcx: TyCtxt<'tcx>, expr: &Expr<'_>) -> Option<Node<'tcx>> {
+/// Returns both the node and the `HirId` of the closest child node.
+pub fn get_expr_use_or_unification_node<'tcx>(tcx: TyCtxt<'tcx>, expr: &Expr<'_>) -> Option<(Node<'tcx>, HirId)> {
     let mut child_id = expr.hir_id;
     let mut iter = tcx.hir().parent_iter(child_id);
     loop {
@@ -1855,9 +1856,9 @@ pub fn get_expr_use_or_unification_node<'tcx>(tcx: TyCtxt<'tcx>, expr: &Expr<'_>
                 ExprKind::Match(_, [arm], _) if arm.hir_id == child_id => child_id = expr.hir_id,
                 ExprKind::Block(..) | ExprKind::DropTemps(_) => child_id = expr.hir_id,
                 ExprKind::If(_, then_expr, None) if then_expr.hir_id == child_id => break None,
-                _ => break Some(Node::Expr(expr)),
+                _ => break Some((Node::Expr(expr), child_id)),
             },
-            Some((_, node)) => break Some(node),
+            Some((_, node)) => break Some((node, child_id)),
         }
     }
 }
@@ -1866,18 +1867,21 @@ pub fn get_expr_use_or_unification_node<'tcx>(tcx: TyCtxt<'tcx>, expr: &Expr<'_>
 pub fn is_expr_used_or_unified(tcx: TyCtxt<'_>, expr: &Expr<'_>) -> bool {
     !matches!(
         get_expr_use_or_unification_node(tcx, expr),
-        None | Some(Node::Stmt(Stmt {
-            kind: StmtKind::Expr(_)
-                | StmtKind::Semi(_)
-                | StmtKind::Local(Local {
-                    pat: Pat {
-                        kind: PatKind::Wild,
+        None | Some((
+            Node::Stmt(Stmt {
+                kind: StmtKind::Expr(_)
+                    | StmtKind::Semi(_)
+                    | StmtKind::Local(Local {
+                        pat: Pat {
+                            kind: PatKind::Wild,
+                            ..
+                        },
                         ..
-                    },
-                    ..
-                }),
-            ..
-        }))
+                    }),
+                ..
+            }),
+            _
+        ))
     )
 }
 
diff --git a/clippy_utils/src/ty.rs b/clippy_utils/src/ty.rs
index 72317447159..dc24bc8e252 100644
--- a/clippy_utils/src/ty.rs
+++ b/clippy_utils/src/ty.rs
@@ -5,19 +5,22 @@
 use rustc_ast::ast::Mutability;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_hir as hir;
+use rustc_hir::def::{CtorKind, DefKind, Res};
 use rustc_hir::def_id::DefId;
-use rustc_hir::{TyKind, Unsafety};
+use rustc_hir::{Expr, TyKind, Unsafety};
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::LateContext;
-use rustc_middle::ty::subst::{GenericArg, GenericArgKind};
-use rustc_middle::ty::{self, AdtDef, IntTy, Predicate, Ty, TyCtxt, TypeFoldable, UintTy};
+use rustc_middle::ty::subst::{GenericArg, GenericArgKind, Subst};
+use rustc_middle::ty::{
+    self, AdtDef, Binder, FnSig, IntTy, Predicate, PredicateKind, Ty, TyCtxt, TypeFoldable, UintTy,
+};
 use rustc_span::symbol::Ident;
 use rustc_span::{sym, Span, Symbol, DUMMY_SP};
 use rustc_trait_selection::infer::InferCtxtExt;
 use rustc_trait_selection::traits::query::normalize::AtExt;
 use std::iter;
 
-use crate::{match_def_path, must_use_attr};
+use crate::{expr_path_res, match_def_path, must_use_attr};
 
 // Checks if the given type implements copy.
 pub fn is_copy<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
@@ -410,3 +413,105 @@ pub fn all_predicates_of(tcx: TyCtxt<'_>, id: DefId) -> impl Iterator<Item = &(P
     })
     .flatten()
 }
+
+/// A signature for a function like type.
+#[derive(Clone, Copy)]
+pub enum ExprFnSig<'tcx> {
+    Sig(Binder<'tcx, FnSig<'tcx>>),
+    Closure(Binder<'tcx, FnSig<'tcx>>),
+    Trait(Binder<'tcx, Ty<'tcx>>, Option<Binder<'tcx, Ty<'tcx>>>),
+}
+impl<'tcx> ExprFnSig<'tcx> {
+    /// Gets the argument type at the given offset.
+    pub fn input(self, i: usize) -> Binder<'tcx, Ty<'tcx>> {
+        match self {
+            Self::Sig(sig) => sig.input(i),
+            Self::Closure(sig) => sig.input(0).map_bound(|ty| ty.tuple_element_ty(i).unwrap()),
+            Self::Trait(inputs, _) => inputs.map_bound(|ty| ty.tuple_element_ty(i).unwrap()),
+        }
+    }
+
+    /// Gets the result type, if one could be found. Note that the result type of a trait may not be
+    /// specified.
+    pub fn output(self) -> Option<Binder<'tcx, Ty<'tcx>>> {
+        match self {
+            Self::Sig(sig) | Self::Closure(sig) => Some(sig.output()),
+            Self::Trait(_, output) => output,
+        }
+    }
+}
+
+/// If the expression is function like, get the signature for it.
+pub fn expr_sig<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>) -> Option<ExprFnSig<'tcx>> {
+    if let Res::Def(DefKind::Fn | DefKind::Ctor(_, CtorKind::Fn) | DefKind::AssocFn, id) = expr_path_res(cx, expr) {
+        Some(ExprFnSig::Sig(cx.tcx.fn_sig(id)))
+    } else {
+        let ty = cx.typeck_results().expr_ty_adjusted(expr).peel_refs();
+        match *ty.kind() {
+            ty::Closure(_, subs) => Some(ExprFnSig::Closure(subs.as_closure().sig())),
+            ty::FnDef(id, subs) => Some(ExprFnSig::Sig(cx.tcx.fn_sig(id).subst(cx.tcx, subs))),
+            ty::FnPtr(sig) => Some(ExprFnSig::Sig(sig)),
+            ty::Dynamic(bounds, _) => {
+                let lang_items = cx.tcx.lang_items();
+                match bounds.principal() {
+                    Some(bound)
+                        if Some(bound.def_id()) == lang_items.fn_trait()
+                            || Some(bound.def_id()) == lang_items.fn_once_trait()
+                            || Some(bound.def_id()) == lang_items.fn_mut_trait() =>
+                    {
+                        let output = bounds
+                            .projection_bounds()
+                            .find(|p| lang_items.fn_once_output().map_or(false, |id| id == p.item_def_id()))
+                            .map(|p| p.map_bound(|p| p.ty));
+                        Some(ExprFnSig::Trait(bound.map_bound(|b| b.substs.type_at(0)), output))
+                    },
+                    _ => None,
+                }
+            },
+            ty::Param(_) | ty::Projection(..) => {
+                let mut inputs = None;
+                let mut output = None;
+                let lang_items = cx.tcx.lang_items();
+
+                for (pred, _) in all_predicates_of(cx.tcx, cx.typeck_results().hir_owner.to_def_id()) {
+                    let mut is_input = false;
+                    if let Some(ty) = pred
+                        .kind()
+                        .map_bound(|pred| match pred {
+                            PredicateKind::Trait(p)
+                                if (lang_items.fn_trait() == Some(p.def_id())
+                                    || lang_items.fn_mut_trait() == Some(p.def_id())
+                                    || lang_items.fn_once_trait() == Some(p.def_id()))
+                                    && p.self_ty() == ty =>
+                            {
+                                is_input = true;
+                                Some(p.trait_ref.substs.type_at(1))
+                            },
+                            PredicateKind::Projection(p)
+                                if Some(p.projection_ty.item_def_id) == lang_items.fn_once_output()
+                                    && p.projection_ty.self_ty() == ty =>
+                            {
+                                is_input = false;
+                                Some(p.ty)
+                            },
+                            _ => None,
+                        })
+                        .transpose()
+                    {
+                        if is_input && inputs.is_none() {
+                            inputs = Some(ty);
+                        } else if !is_input && output.is_none() {
+                            output = Some(ty);
+                        } else {
+                            // Multiple different fn trait impls. Is this even allowed?
+                            return None;
+                        }
+                    }
+                }
+
+                inputs.map(|ty| ExprFnSig::Trait(ty, output))
+            },
+            _ => None,
+        }
+    }
+}
diff --git a/tests/ui/ptr_arg.rs b/tests/ui/ptr_arg.rs
index 67bfef06a05..6cd7e96d7c1 100644
--- a/tests/ui/ptr_arg.rs
+++ b/tests/ui/ptr_arg.rs
@@ -9,7 +9,6 @@ fn do_vec(x: &Vec<i64>) {
 }
 
 fn do_vec_mut(x: &mut Vec<i64>) {
-    // no error here
     //Nothing here
 }
 
@@ -18,7 +17,6 @@ fn do_str(x: &String) {
 }
 
 fn do_str_mut(x: &mut String) {
-    // no error here
     //Nothing here either
 }
 
@@ -27,7 +25,6 @@ fn do_path(x: &PathBuf) {
 }
 
 fn do_path_mut(x: &mut PathBuf) {
-    // no error here
     //Nothing here either
 }
 
@@ -52,7 +49,7 @@ fn cloned(x: &Vec<u8>) -> Vec<u8> {
     let e = x.clone();
     let f = e.clone(); // OK
     let g = x;
-    let h = g.clone(); // Alas, we cannot reliably detect this without following data.
+    let h = g.clone();
     let i = (e).clone();
     x.clone()
 }
@@ -156,6 +153,30 @@ mod issue6509 {
     }
 }
 
+fn mut_vec_slice_methods(v: &mut Vec<u32>) {
+    v.copy_within(1..5, 10);
+}
+
+fn mut_vec_vec_methods(v: &mut Vec<u32>) {
+    v.clear();
+}
+
+fn vec_contains(v: &Vec<u32>) -> bool {
+    [vec![], vec![0]].as_slice().contains(v)
+}
+
+fn fn_requires_vec(v: &Vec<u32>) -> bool {
+    vec_contains(v)
+}
+
+// fn impl_fn_requires_vec(v: &Vec<u32>, f: impl Fn(&Vec<u32>)) {
+//     f(v);
+// }
+
+// fn dyn_fn_requires_vec(v: &Vec<u32>, f: &dyn Fn(&Vec<u32>)) {
+//     f(v);
+// }
+
 // No error for types behind an alias (#7699)
 type A = Vec<u8>;
 fn aliased(a: &A) {}
diff --git a/tests/ui/ptr_arg.stderr b/tests/ui/ptr_arg.stderr
index 64594eb870c..a9613daadde 100644
--- a/tests/ui/ptr_arg.stderr
+++ b/tests/ui/ptr_arg.stderr
@@ -1,4 +1,4 @@
-error: writing `&Vec<_>` instead of `&[_]` involves one more reference and cannot be used with non-Vec-based slices
+error: writing `&Vec` instead of `&[_]` involves a new object where a slice will do
   --> $DIR/ptr_arg.rs:7:14
    |
 LL | fn do_vec(x: &Vec<i64>) {
@@ -6,170 +6,154 @@ LL | fn do_vec(x: &Vec<i64>) {
    |
    = note: `-D clippy::ptr-arg` implied by `-D warnings`
 
+error: writing `&mut Vec` instead of `&mut [_]` involves a new object where a slice will do
+  --> $DIR/ptr_arg.rs:11:18
+   |
+LL | fn do_vec_mut(x: &mut Vec<i64>) {
+   |                  ^^^^^^^^^^^^^ help: change this to: `&mut [i64]`
+
 error: writing `&String` instead of `&str` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:16:14
+  --> $DIR/ptr_arg.rs:15:14
    |
 LL | fn do_str(x: &String) {
    |              ^^^^^^^ help: change this to: `&str`
 
+error: writing `&mut String` instead of `&mut str` involves a new object where a slice will do
+  --> $DIR/ptr_arg.rs:19:18
+   |
+LL | fn do_str_mut(x: &mut String) {
+   |                  ^^^^^^^^^^^ help: change this to: `&mut str`
+
 error: writing `&PathBuf` instead of `&Path` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:25:15
+  --> $DIR/ptr_arg.rs:23:15
    |
 LL | fn do_path(x: &PathBuf) {
    |               ^^^^^^^^ help: change this to: `&Path`
 
-error: writing `&Vec<_>` instead of `&[_]` involves one more reference and cannot be used with non-Vec-based slices
-  --> $DIR/ptr_arg.rs:38:18
+error: writing `&mut PathBuf` instead of `&mut Path` involves a new object where a slice will do
+  --> $DIR/ptr_arg.rs:27:19
+   |
+LL | fn do_path_mut(x: &mut PathBuf) {
+   |                   ^^^^^^^^^^^^ help: change this to: `&mut Path`
+
+error: writing `&Vec` instead of `&[_]` involves a new object where a slice will do
+  --> $DIR/ptr_arg.rs:35:18
    |
 LL |     fn do_vec(x: &Vec<i64>);
    |                  ^^^^^^^^^ help: change this to: `&[i64]`
 
-error: writing `&Vec<_>` instead of `&[_]` involves one more reference and cannot be used with non-Vec-based slices
-  --> $DIR/ptr_arg.rs:51:14
+error: writing `&Vec` instead of `&[_]` involves a new object where a slice will do
+  --> $DIR/ptr_arg.rs:48:14
    |
 LL | fn cloned(x: &Vec<u8>) -> Vec<u8> {
    |              ^^^^^^^^
    |
 help: change this to
    |
-LL | fn cloned(x: &[u8]) -> Vec<u8> {
-   |              ~~~~~
-help: change `x.clone()` to
-   |
-LL |     let e = x.to_owned();
-   |             ~~~~~~~~~~~~
-help: change `x.clone()` to
-   |
-LL |     x.to_owned()
-   |
+LL ~ fn cloned(x: &[u8]) -> Vec<u8> {
+LL ~     let e = x.to_owned();
+LL |     let f = e.clone(); // OK
+LL |     let g = x;
+LL ~     let h = g.to_owned();
+LL |     let i = (e).clone();
+ ...
 
 error: writing `&String` instead of `&str` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:60:18
+  --> $DIR/ptr_arg.rs:57:18
    |
 LL | fn str_cloned(x: &String) -> String {
    |                  ^^^^^^^
    |
 help: change this to
    |
-LL | fn str_cloned(x: &str) -> String {
-   |                  ~~~~
-help: change `x.clone()` to
-   |
-LL |     let a = x.to_string();
-   |             ~~~~~~~~~~~~~
-help: change `x.clone()` to
-   |
-LL |     let b = x.to_string();
-   |             ~~~~~~~~~~~~~
-help: change `x.clone()` to
-   |
-LL |     x.to_string()
+LL ~ fn str_cloned(x: &str) -> String {
+LL ~     let a = x.to_owned();
+LL ~     let b = x.to_owned();
+LL |     let c = b.clone();
+LL |     let d = a.clone().clone().clone();
+LL ~     x.to_owned()
    |
 
 error: writing `&PathBuf` instead of `&Path` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:68:19
+  --> $DIR/ptr_arg.rs:65:19
    |
 LL | fn path_cloned(x: &PathBuf) -> PathBuf {
    |                   ^^^^^^^^
    |
 help: change this to
    |
-LL | fn path_cloned(x: &Path) -> PathBuf {
-   |                   ~~~~~
-help: change `x.clone()` to
-   |
-LL |     let a = x.to_path_buf();
-   |             ~~~~~~~~~~~~~~~
-help: change `x.clone()` to
-   |
-LL |     let b = x.to_path_buf();
-   |             ~~~~~~~~~~~~~~~
-help: change `x.clone()` to
-   |
-LL |     x.to_path_buf()
+LL ~ fn path_cloned(x: &Path) -> PathBuf {
+LL ~     let a = x.to_path_buf();
+LL ~     let b = x.to_path_buf();
+LL |     let c = b.clone();
+LL |     let d = a.clone().clone().clone();
+LL ~     x.to_path_buf()
    |
 
 error: writing `&String` instead of `&str` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:76:44
+  --> $DIR/ptr_arg.rs:73:44
    |
 LL | fn false_positive_capacity(x: &Vec<u8>, y: &String) {
    |                                            ^^^^^^^
    |
 help: change this to
    |
-LL | fn false_positive_capacity(x: &Vec<u8>, y: &str) {
-   |                                            ~~~~
-help: change `y.clone()` to
+LL ~ fn false_positive_capacity(x: &Vec<u8>, y: &str) {
+LL |     let a = x.capacity();
+LL ~     let b = y.to_owned();
+LL ~     let c = y;
    |
-LL |     let b = y.to_string();
-   |             ~~~~~~~~~~~~~
-help: change `y.as_str()` to
-   |
-LL |     let c = y;
-   |             ~
 
 error: using a reference to `Cow` is not recommended
-  --> $DIR/ptr_arg.rs:90:25
+  --> $DIR/ptr_arg.rs:87:25
    |
 LL | fn test_cow_with_ref(c: &Cow<[i32]>) {}
    |                         ^^^^^^^^^^^ help: change this to: `&[i32]`
 
-error: writing `&Vec<_>` instead of `&[_]` involves one more reference and cannot be used with non-Vec-based slices
-  --> $DIR/ptr_arg.rs:143:21
+error: writing `&Vec` instead of `&[_]` involves a new object where a slice will do
+  --> $DIR/ptr_arg.rs:140:21
    |
 LL |     fn foo_vec(vec: &Vec<u8>) {
    |                     ^^^^^^^^
    |
 help: change this to
    |
-LL |     fn foo_vec(vec: &[u8]) {
-   |                     ~~~~~
-help: change `vec.clone()` to
-   |
-LL |         let _ = vec.to_owned().pop();
-   |                 ~~~~~~~~~~~~~~
-help: change `vec.clone()` to
+LL ~     fn foo_vec(vec: &[u8]) {
+LL ~         let _ = vec.to_owned().pop();
+LL ~         let _ = vec.to_owned().clone();
    |
-LL |         let _ = vec.to_owned().clone();
-   |                 ~~~~~~~~~~~~~~
 
 error: writing `&PathBuf` instead of `&Path` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:148:23
+  --> $DIR/ptr_arg.rs:145:23
    |
 LL |     fn foo_path(path: &PathBuf) {
    |                       ^^^^^^^^
    |
 help: change this to
    |
-LL |     fn foo_path(path: &Path) {
-   |                       ~~~~~
-help: change `path.clone()` to
+LL ~     fn foo_path(path: &Path) {
+LL ~         let _ = path.to_path_buf().pop();
+LL ~         let _ = path.to_path_buf().clone();
    |
-LL |         let _ = path.to_path_buf().pop();
-   |                 ~~~~~~~~~~~~~~~~~~
-help: change `path.clone()` to
-   |
-LL |         let _ = path.to_path_buf().clone();
-   |                 ~~~~~~~~~~~~~~~~~~
 
 error: writing `&PathBuf` instead of `&Path` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:153:21
+  --> $DIR/ptr_arg.rs:150:21
    |
 LL |     fn foo_str(str: &PathBuf) {
    |                     ^^^^^^^^
    |
 help: change this to
    |
-LL |     fn foo_str(str: &Path) {
-   |                     ~~~~~
-help: change `str.clone()` to
+LL ~     fn foo_str(str: &Path) {
+LL ~         let _ = str.to_path_buf().pop();
+LL ~         let _ = str.to_path_buf().clone();
    |
-LL |         let _ = str.to_path_buf().pop();
-   |                 ~~~~~~~~~~~~~~~~~
-help: change `str.clone()` to
+
+error: writing `&mut Vec` instead of `&mut [_]` involves a new object where a slice will do
+  --> $DIR/ptr_arg.rs:156:29
    |
-LL |         let _ = str.to_path_buf().clone();
-   |                 ~~~~~~~~~~~~~~~~~
+LL | fn mut_vec_slice_methods(v: &mut Vec<u32>) {
+   |                             ^^^^^^^^^^^^^ help: change this to: `&mut [u32]`
 
-error: aborting due to 12 previous errors
+error: aborting due to 16 previous errors
 
diff --git a/tests/ui/search_is_some_fixable_none.rs b/tests/ui/search_is_some_fixable_none.rs
index 778f4f6fa25..767518ab0c0 100644
--- a/tests/ui/search_is_some_fixable_none.rs
+++ b/tests/ui/search_is_some_fixable_none.rs
@@ -189,7 +189,7 @@ mod issue7392 {
         let _ = [&(&1, 2), &(&3, 4), &(&5, 4)].iter().find(|&(&x, y)| x == *y).is_none();
     }
 
-    fn test_string_1(s: &String) -> bool {
+    fn test_string_1(s: &str) -> bool {
         s.is_empty()
     }
 
diff --git a/tests/ui/search_is_some_fixable_none.stderr b/tests/ui/search_is_some_fixable_none.stderr
index 7c5e5eb589c..933ce5cf42d 100644
--- a/tests/ui/search_is_some_fixable_none.stderr
+++ b/tests/ui/search_is_some_fixable_none.stderr
@@ -251,14 +251,6 @@ error: called `is_none()` after searching an `Iterator` with `find`
 LL |         let _ = [&(&1, 2), &(&3, 4), &(&5, 4)].iter().find(|&(&x, y)| x == *y).is_none();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.any()` instead: `![&(&1, 2), &(&3, 4), &(&5, 4)].iter().any(|(&x, y)| x == *y)`
 
-error: writing `&String` instead of `&str` involves a new object where a slice will do
-  --> $DIR/search_is_some_fixable_none.rs:192:25
-   |
-LL |     fn test_string_1(s: &String) -> bool {
-   |                         ^^^^^^^ help: change this to: `&str`
-   |
-   = note: `-D clippy::ptr-arg` implied by `-D warnings`
-
 error: called `is_none()` after searching an `Iterator` with `find`
   --> $DIR/search_is_some_fixable_none.rs:208:17
    |
@@ -289,5 +281,5 @@ error: called `is_none()` after searching an `Iterator` with `find`
 LL |         let _ = v.iter().find(|fp| test_u32_2(*fp.field)).is_none();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `!_.any()` instead: `!v.iter().any(|fp| test_u32_2(*fp.field))`
 
-error: aborting due to 44 previous errors
+error: aborting due to 43 previous errors
 
diff --git a/tests/ui/search_is_some_fixable_some.rs b/tests/ui/search_is_some_fixable_some.rs
index 241641fceae..77fd52e4ce7 100644
--- a/tests/ui/search_is_some_fixable_some.rs
+++ b/tests/ui/search_is_some_fixable_some.rs
@@ -188,7 +188,7 @@ mod issue7392 {
         let _ = [&(&1, 2), &(&3, 4), &(&5, 4)].iter().find(|&(&x, y)| x == *y).is_some();
     }
 
-    fn test_string_1(s: &String) -> bool {
+    fn test_string_1(s: &str) -> bool {
         s.is_empty()
     }
 
diff --git a/tests/ui/search_is_some_fixable_some.stderr b/tests/ui/search_is_some_fixable_some.stderr
index 9212c6e71ff..8b424f18ef5 100644
--- a/tests/ui/search_is_some_fixable_some.stderr
+++ b/tests/ui/search_is_some_fixable_some.stderr
@@ -234,14 +234,6 @@ error: called `is_some()` after searching an `Iterator` with `find`
 LL |         let _ = [&(&1, 2), &(&3, 4), &(&5, 4)].iter().find(|&(&x, y)| x == *y).is_some();
    |                                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `any()` instead: `any(|(&x, y)| x == *y)`
 
-error: writing `&String` instead of `&str` involves a new object where a slice will do
-  --> $DIR/search_is_some_fixable_some.rs:191:25
-   |
-LL |     fn test_string_1(s: &String) -> bool {
-   |                         ^^^^^^^ help: change this to: `&str`
-   |
-   = note: `-D clippy::ptr-arg` implied by `-D warnings`
-
 error: called `is_some()` after searching an `Iterator` with `find`
   --> $DIR/search_is_some_fixable_some.rs:207:26
    |
@@ -272,5 +264,5 @@ error: called `is_some()` after searching an `Iterator` with `find`
 LL |         let _ = v.iter().find(|fp| test_u32_2(*fp.field)).is_some();
    |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `any()` instead: `any(|fp| test_u32_2(*fp.field))`
 
-error: aborting due to 44 previous errors
+error: aborting due to 43 previous errors
 
diff --git a/tests/ui/slow_vector_initialization.rs b/tests/ui/slow_vector_initialization.rs
index c5ae3ff769b..7e3d357ae50 100644
--- a/tests/ui/slow_vector_initialization.rs
+++ b/tests/ui/slow_vector_initialization.rs
@@ -53,7 +53,7 @@ fn resize_vector() {
     vec1.resize(10, 0);
 }
 
-fn do_stuff(vec: &mut Vec<u8>) {}
+fn do_stuff(vec: &mut [u8]) {}
 
 fn extend_vector_with_manipulations_between() {
     let len = 300;
-- 
cgit 1.4.1-3-g733a5


From 875b2400837390b5bcce7c649a0fdd8dbe341150 Mon Sep 17 00:00:00 2001
From: SeeSpring <30735327+SeeSpring@users.noreply.github.com>
Date: Thu, 13 Jan 2022 09:27:08 -0500
Subject: Apply `not_unsafe_ptr_arg_deref` to type aliases

---
 .../src/functions/not_unsafe_ptr_arg_deref.rs      | 11 +++++----
 tests/ui/functions.rs                              |  8 +++++++
 tests/ui/functions.stderr                          | 26 ++++++++++++++++++----
 3 files changed, 37 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/functions/not_unsafe_ptr_arg_deref.rs b/clippy_lints/src/functions/not_unsafe_ptr_arg_deref.rs
index 6d829a18b2e..834f6d2425e 100644
--- a/clippy_lints/src/functions/not_unsafe_ptr_arg_deref.rs
+++ b/clippy_lints/src/functions/not_unsafe_ptr_arg_deref.rs
@@ -42,8 +42,7 @@ fn check_raw_ptr<'tcx>(
     let expr = &body.value;
     if unsafety == hir::Unsafety::Normal && cx.access_levels.is_exported(def_id) {
         let raw_ptrs = iter_input_pats(decl, body)
-            .zip(decl.inputs.iter())
-            .filter_map(|(arg, ty)| raw_ptr_arg(arg, ty))
+            .filter_map(|arg| raw_ptr_arg(cx, arg))
             .collect::<HirIdSet>();
 
         if !raw_ptrs.is_empty() {
@@ -59,8 +58,12 @@ fn check_raw_ptr<'tcx>(
     }
 }
 
-fn raw_ptr_arg(arg: &hir::Param<'_>, ty: &hir::Ty<'_>) -> Option<hir::HirId> {
-    if let (&hir::PatKind::Binding(_, id, _, _), &hir::TyKind::Ptr(_)) = (&arg.pat.kind, &ty.kind) {
+fn raw_ptr_arg(cx: &LateContext<'_>, arg: &hir::Param<'_>) -> Option<hir::HirId> {
+    if let (&hir::PatKind::Binding(_, id, _, _), Some(&ty::RawPtr(_))) = (
+        &arg.pat.kind,
+        cx.maybe_typeck_results()
+            .map(|typeck_results| typeck_results.pat_ty(arg.pat).kind()),
+    ) {
         Some(id)
     } else {
         None
diff --git a/tests/ui/functions.rs b/tests/ui/functions.rs
index 271754cb06e..5521870eaec 100644
--- a/tests/ui/functions.rs
+++ b/tests/ui/functions.rs
@@ -78,6 +78,14 @@ pub fn public(p: *const u8) {
     unsafe { std::ptr::read(p) };
 }
 
+type Alias = *const u8;
+
+pub fn type_alias(p: Alias) {
+    println!("{}", unsafe { *p });
+    println!("{:?}", unsafe { p.as_ref() });
+    unsafe { std::ptr::read(p) };
+}
+
 impl Bar {
     fn private(self, p: *const u8) {
         println!("{}", unsafe { *p });
diff --git a/tests/ui/functions.stderr b/tests/ui/functions.stderr
index a2b8c2a384b..8ebd4997f4f 100644
--- a/tests/ui/functions.stderr
+++ b/tests/ui/functions.stderr
@@ -69,22 +69,40 @@ LL |     unsafe { std::ptr::read(p) };
    |                             ^
 
 error: this public function might dereference a raw pointer but is not marked `unsafe`
-  --> $DIR/functions.rs:87:34
+  --> $DIR/functions.rs:84:30
+   |
+LL |     println!("{}", unsafe { *p });
+   |                              ^
+
+error: this public function might dereference a raw pointer but is not marked `unsafe`
+  --> $DIR/functions.rs:85:31
+   |
+LL |     println!("{:?}", unsafe { p.as_ref() });
+   |                               ^
+
+error: this public function might dereference a raw pointer but is not marked `unsafe`
+  --> $DIR/functions.rs:86:29
+   |
+LL |     unsafe { std::ptr::read(p) };
+   |                             ^
+
+error: this public function might dereference a raw pointer but is not marked `unsafe`
+  --> $DIR/functions.rs:95:34
    |
 LL |         println!("{}", unsafe { *p });
    |                                  ^
 
 error: this public function might dereference a raw pointer but is not marked `unsafe`
-  --> $DIR/functions.rs:88:35
+  --> $DIR/functions.rs:96:35
    |
 LL |         println!("{:?}", unsafe { p.as_ref() });
    |                                   ^
 
 error: this public function might dereference a raw pointer but is not marked `unsafe`
-  --> $DIR/functions.rs:89:33
+  --> $DIR/functions.rs:97:33
    |
 LL |         unsafe { std::ptr::read(p) };
    |                                 ^
 
-error: aborting due to 13 previous errors
+error: aborting due to 16 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From adc3e669fa73c611869e693d0c5af92b852c674d Mon Sep 17 00:00:00 2001
From: Andrew Archibald <andrew@aarchibald.com>
Date: Thu, 13 Jan 2022 13:20:30 -0700
Subject: Escape pipes in Markdown tables

---
 clippy_lints/src/bit_mask.rs | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/bit_mask.rs b/clippy_lints/src/bit_mask.rs
index 0977cf22b2c..ca4af66cad1 100644
--- a/clippy_lints/src/bit_mask.rs
+++ b/clippy_lints/src/bit_mask.rs
@@ -18,14 +18,14 @@ declare_clippy_lint! {
     /// {`!=`, `>=`, `>`, `!=`, `>=`, `>`}) can be determined from the following
     /// table:
     ///
-    /// |Comparison  |Bit Op|Example     |is always|Formula               |
-    /// |------------|------|------------|---------|----------------------|
-    /// |`==` or `!=`| `&`  |`x & 2 == 3`|`false`  |`c & m != c`          |
-    /// |`<`  or `>=`| `&`  |`x & 2 < 3` |`true`   |`m < c`               |
-    /// |`>`  or `<=`| `&`  |`x & 1 > 1` |`false`  |`m <= c`              |
-    /// |`==` or `!=`| `|`  |`x | 1 == 0`|`false`  |`c | m != c`          |
-    /// |`<`  or `>=`| `|`  |`x | 1 < 1` |`false`  |`m >= c`              |
-    /// |`<=` or `>` | `|`  |`x | 1 > 0` |`true`   |`m > c`               |
+    /// |Comparison  |Bit Op|Example      |is always|Formula               |
+    /// |------------|------|-------------|---------|----------------------|
+    /// |`==` or `!=`| `&`  |`x & 2 == 3` |`false`  |`c & m != c`          |
+    /// |`<`  or `>=`| `&`  |`x & 2 < 3`  |`true`   |`m < c`               |
+    /// |`>`  or `<=`| `&`  |`x & 1 > 1`  |`false`  |`m <= c`              |
+    /// |`==` or `!=`| `\|` |`x \| 1 == 0`|`false`  |`c \| m != c`         |
+    /// |`<`  or `>=`| `\|` |`x \| 1 < 1` |`false`  |`m >= c`              |
+    /// |`<=` or `>` | `\|` |`x \| 1 > 0` |`true`   |`m > c`               |
     ///
     /// ### Why is this bad?
     /// If the bits that the comparison cares about are always
@@ -53,10 +53,10 @@ declare_clippy_lint! {
     /// without changing the outcome. The basic structure can be seen in the
     /// following table:
     ///
-    /// |Comparison| Bit Op  |Example    |equals |
-    /// |----------|---------|-----------|-------|
-    /// |`>` / `<=`|`|` / `^`|`x | 2 > 3`|`x > 3`|
-    /// |`<` / `>=`|`|` / `^`|`x ^ 1 < 4`|`x < 4`|
+    /// |Comparison| Bit Op   |Example     |equals |
+    /// |----------|----------|------------|-------|
+    /// |`>` / `<=`|`\|` / `^`|`x \| 2 > 3`|`x > 3`|
+    /// |`<` / `>=`|`\|` / `^`|`x ^ 1 < 4` |`x < 4`|
     ///
     /// ### Why is this bad?
     /// Not equally evil as [`bad_bit_mask`](#bad_bit_mask),
-- 
cgit 1.4.1-3-g733a5


From 9e7858545a2c0427120065431809653e3bb78ce2 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Fri, 14 Jan 2022 23:45:05 +0100
Subject: Add `msrv` config for `map_clone`

---
 clippy_lints/src/lib.rs                            |  2 +-
 clippy_lints/src/map_clone.rs                      | 66 +++++++++++++---------
 clippy_lints/src/utils/conf.rs                     |  2 +-
 tests/ui-toml/min_rust_version/min_rust_version.rs |  5 ++
 .../min_rust_version/min_rust_version.stderr       | 10 ++++
 5 files changed, 56 insertions(+), 29 deletions(-)
 create mode 100644 tests/ui-toml/min_rust_version/min_rust_version.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 79e9882fef4..ed25d6fd297 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -581,6 +581,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(move || Box::new(needless_question_mark::NeedlessQuestionMark));
     store.register_late_pass(move || Box::new(casts::Casts::new(msrv)));
     store.register_early_pass(move || Box::new(unnested_or_patterns::UnnestedOrPatterns::new(msrv)));
+    store.register_late_pass(move || Box::new(map_clone::MapClone::new(msrv)));
 
     store.register_late_pass(|| Box::new(size_of_in_element_count::SizeOfInElementCount));
     store.register_late_pass(|| Box::new(same_name_method::SameNameMethod));
@@ -591,7 +592,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
             msrv,
         ))
     });
-    store.register_late_pass(|| Box::new(map_clone::MapClone));
     store.register_late_pass(|| Box::new(map_err_ignore::MapErrIgnore));
     store.register_late_pass(|| Box::new(shadow::Shadow::default()));
     store.register_late_pass(|| Box::new(unit_types::UnitTypes));
diff --git a/clippy_lints/src/map_clone.rs b/clippy_lints/src/map_clone.rs
index 174c7da28d3..5b203fd3d92 100644
--- a/clippy_lints/src/map_clone.rs
+++ b/clippy_lints/src/map_clone.rs
@@ -1,15 +1,16 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::{is_copy, is_type_diagnostic_item};
-use clippy_utils::{is_trait_method, peel_blocks};
+use clippy_utils::{is_trait_method, meets_msrv, msrvs, peel_blocks};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
-use rustc_lint::{LateContext, LateLintPass};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::mir::Mutability;
 use rustc_middle::ty;
 use rustc_middle::ty::adjustment::Adjust;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_semver::RustcVersion;
+use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::symbol::Ident;
 use rustc_span::{sym, Span};
 
@@ -42,7 +43,17 @@ declare_clippy_lint! {
     "using `iterator.map(|x| x.clone())`, or dereferencing closures for `Copy` types"
 }
 
-declare_lint_pass!(MapClone => [MAP_CLONE]);
+pub struct MapClone {
+    msrv: Option<RustcVersion>,
+}
+
+impl_lint_pass!(MapClone => [MAP_CLONE]);
+
+impl MapClone {
+    pub fn new(msrv: Option<RustcVersion>) -> Self {
+        Self { msrv }
+    }
+}
 
 impl<'tcx> LateLintPass<'tcx> for MapClone {
     fn check_expr(&mut self, cx: &LateContext<'_>, e: &hir::Expr<'_>) {
@@ -65,7 +76,7 @@ impl<'tcx> LateLintPass<'tcx> for MapClone {
                         hir::BindingAnnotation::Unannotated, .., name, None
                     ) = inner.kind {
                         if ident_eq(name, closure_expr) {
-                            lint(cx, e.span, args[0].span, true);
+                            self.lint_explicit_closure(cx, e.span, args[0].span, true);
                         }
                     },
                     hir::PatKind::Binding(hir::BindingAnnotation::Unannotated, .., name, None) => {
@@ -73,7 +84,7 @@ impl<'tcx> LateLintPass<'tcx> for MapClone {
                             hir::ExprKind::Unary(hir::UnOp::Deref, inner) => {
                                 if ident_eq(name, inner) {
                                     if let ty::Ref(.., Mutability::Not) = cx.typeck_results().expr_ty(inner).kind() {
-                                        lint(cx, e.span, args[0].span, true);
+                                        self.lint_explicit_closure(cx, e.span, args[0].span, true);
                                     }
                                 }
                             },
@@ -90,7 +101,7 @@ impl<'tcx> LateLintPass<'tcx> for MapClone {
                                     if let ty::Ref(_, ty, mutability) = obj_ty.kind() {
                                         if matches!(mutability, Mutability::Not) {
                                             let copy = is_copy(cx, ty);
-                                            lint(cx, e.span, args[0].span, copy);
+                                            self.lint_explicit_closure(cx, e.span, args[0].span, copy);
                                         }
                                     } else {
                                         lint_needless_cloning(cx, e.span, args[0].span);
@@ -105,6 +116,8 @@ impl<'tcx> LateLintPass<'tcx> for MapClone {
             }
         }
     }
+
+    extract_msrv_attr!(LateContext);
 }
 
 fn ident_eq(name: Ident, path: &hir::Expr<'_>) -> bool {
@@ -127,31 +140,30 @@ fn lint_needless_cloning(cx: &LateContext<'_>, root: Span, receiver: Span) {
     );
 }
 
-fn lint(cx: &LateContext<'_>, replace: Span, root: Span, copied: bool) {
-    let mut applicability = Applicability::MachineApplicable;
-    if copied {
-        span_lint_and_sugg(
-            cx,
-            MAP_CLONE,
-            replace,
-            "you are using an explicit closure for copying elements",
-            "consider calling the dedicated `copied` method",
-            format!(
-                "{}.copied()",
-                snippet_with_applicability(cx, root, "..", &mut applicability)
-            ),
-            applicability,
-        );
-    } else {
+impl MapClone {
+    fn lint_explicit_closure(&self, cx: &LateContext<'_>, replace: Span, root: Span, is_copy: bool) {
+        let mut applicability = Applicability::MachineApplicable;
+        let message = if is_copy {
+            "you are using an explicit closure for copying elements"
+        } else {
+            "you are using an explicit closure for cloning elements"
+        };
+        let sugg_method = if is_copy && meets_msrv(self.msrv.as_ref(), &msrvs::ITERATOR_COPIED) {
+            "copied"
+        } else {
+            "cloned"
+        };
+
         span_lint_and_sugg(
             cx,
             MAP_CLONE,
             replace,
-            "you are using an explicit closure for cloning elements",
-            "consider calling the dedicated `cloned` method",
+            message,
+            &format!("consider calling the dedicated `{}` method", sugg_method),
             format!(
-                "{}.cloned()",
-                snippet_with_applicability(cx, root, "..", &mut applicability)
+                "{}.{}()",
+                snippet_with_applicability(cx, root, "..", &mut applicability),
+                sugg_method,
             ),
             applicability,
         );
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index d6deb50cc90..0cc6f520698 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -156,7 +156,7 @@ define_Conf! {
     ///
     /// Suppress lints whenever the suggested change would cause breakage for other crates.
     (avoid_breaking_exported_api: bool = true),
-    /// Lint: MANUAL_SPLIT_ONCE, MANUAL_STR_REPEAT, CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR, IF_THEN_SOME_ELSE_NONE, APPROX_CONSTANT, DEPRECATED_CFG_ATTR, INDEX_REFUTABLE_SLICE.
+    /// Lint: MANUAL_SPLIT_ONCE, MANUAL_STR_REPEAT, CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR, IF_THEN_SOME_ELSE_NONE, APPROX_CONSTANT, DEPRECATED_CFG_ATTR, INDEX_REFUTABLE_SLICE, MAP_CLONE.
     ///
     /// The minimum rust version that the project supports
     (msrv: Option<String> = None),
diff --git a/tests/ui-toml/min_rust_version/min_rust_version.rs b/tests/ui-toml/min_rust_version/min_rust_version.rs
index 8e104926524..213252f7b58 100644
--- a/tests/ui-toml/min_rust_version/min_rust_version.rs
+++ b/tests/ui-toml/min_rust_version/min_rust_version.rs
@@ -68,6 +68,11 @@ fn check_index_refutable_slice() {
     }
 }
 
+fn map_clone_suggest_copied() {
+    // This should still trigger the lint but suggest `cloned()` instead of `copied()`
+    let _: Option<u64> = Some(&16).map(|b| *b);
+}
+
 fn main() {
     option_as_ref_deref();
     match_like_matches();
diff --git a/tests/ui-toml/min_rust_version/min_rust_version.stderr b/tests/ui-toml/min_rust_version/min_rust_version.stderr
new file mode 100644
index 00000000000..f226c012ca8
--- /dev/null
+++ b/tests/ui-toml/min_rust_version/min_rust_version.stderr
@@ -0,0 +1,10 @@
+error: you are using an explicit closure for copying elements
+  --> $DIR/min_rust_version.rs:73:26
+   |
+LL |     let _: Option<u64> = Some(&16).map(|b| *b);
+   |                          ^^^^^^^^^^^^^^^^^^^^^ help: consider calling the dedicated `cloned` method: `Some(&16).cloned()`
+   |
+   = note: `-D clippy::map-clone` implied by `-D warnings`
+
+error: aborting due to previous error
+
-- 
cgit 1.4.1-3-g733a5


From 1afeb7106514557e19b2eb48529a9a96879ca4d3 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Sat, 15 Jan 2022 00:39:06 +0100
Subject: Track `msrv` attribute for `manual_bits` and `borrow_as_prt`

---
 clippy_lints/src/borrow_as_ptr.rs                     |  4 +++-
 clippy_lints/src/manual_bits.rs                       |  4 +++-
 clippy_lints/src/utils/conf.rs                        |  2 +-
 tests/ui-toml/min_rust_version/min_rust_version.rs    | 19 +++++++++++++++++--
 .../ui-toml/min_rust_version/min_rust_version.stderr  |  2 +-
 5 files changed, 25 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/borrow_as_ptr.rs b/clippy_lints/src/borrow_as_ptr.rs
index b8f5217af2b..265cdeab094 100644
--- a/clippy_lints/src/borrow_as_ptr.rs
+++ b/clippy_lints/src/borrow_as_ptr.rs
@@ -5,7 +5,7 @@ use clippy_utils::{meets_msrv, msrvs};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{BorrowKind, Expr, ExprKind, Mutability, TyKind};
-use rustc_lint::{LateContext, LateLintPass};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 
@@ -94,4 +94,6 @@ impl<'tcx> LateLintPass<'tcx> for BorrowAsPtr {
             }
         }
     }
+
+    extract_msrv_attr!(LateContext);
 }
diff --git a/clippy_lints/src/manual_bits.rs b/clippy_lints/src/manual_bits.rs
index 50bf2527e39..a72ef1d2de2 100644
--- a/clippy_lints/src/manual_bits.rs
+++ b/clippy_lints/src/manual_bits.rs
@@ -4,7 +4,7 @@ use clippy_utils::{match_def_path, meets_msrv, msrvs, paths};
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind, GenericArg, QPath};
-use rustc_lint::{LateContext, LateLintPass};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::ty::{self, Ty};
 use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
@@ -72,6 +72,8 @@ impl<'tcx> LateLintPass<'tcx> for ManualBits {
             }
         }
     }
+
+    extract_msrv_attr!(LateContext);
 }
 
 fn get_one_size_of_ty<'tcx>(
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 0cc6f520698..c9d99617c1e 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -156,7 +156,7 @@ define_Conf! {
     ///
     /// Suppress lints whenever the suggested change would cause breakage for other crates.
     (avoid_breaking_exported_api: bool = true),
-    /// Lint: MANUAL_SPLIT_ONCE, MANUAL_STR_REPEAT, CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR, IF_THEN_SOME_ELSE_NONE, APPROX_CONSTANT, DEPRECATED_CFG_ATTR, INDEX_REFUTABLE_SLICE, MAP_CLONE.
+    /// Lint: MANUAL_SPLIT_ONCE, MANUAL_STR_REPEAT, CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR, IF_THEN_SOME_ELSE_NONE, APPROX_CONSTANT, DEPRECATED_CFG_ATTR, INDEX_REFUTABLE_SLICE, MAP_CLONE, BORROW_AS_PTR, MANUAL_BITS.
     ///
     /// The minimum rust version that the project supports
     (msrv: Option<String> = None),
diff --git a/tests/ui-toml/min_rust_version/min_rust_version.rs b/tests/ui-toml/min_rust_version/min_rust_version.rs
index 213252f7b58..1e3ec123a3c 100644
--- a/tests/ui-toml/min_rust_version/min_rust_version.rs
+++ b/tests/ui-toml/min_rust_version/min_rust_version.rs
@@ -1,6 +1,7 @@
-#![allow(clippy::redundant_clone)]
-#![warn(clippy::manual_non_exhaustive)]
+#![allow(clippy::redundant_clone, clippy::unnecessary_operation)]
+#![warn(clippy::manual_non_exhaustive, clippy::borrow_as_ptr, clippy::manual_bits)]
 
+use std::mem::{size_of, size_of_val};
 use std::ops::Deref;
 
 mod enums {
@@ -73,6 +74,19 @@ fn map_clone_suggest_copied() {
     let _: Option<u64> = Some(&16).map(|b| *b);
 }
 
+fn borrow_as_ptr() {
+    let val = 1;
+    let _p = &val as *const i32;
+
+    let mut val_mut = 1;
+    let _p_mut = &mut val_mut as *mut i32;
+}
+
+fn manual_bits() {
+    size_of::<i8>() * 8;
+    size_of_val(&0u32) * 8;
+}
+
 fn main() {
     option_as_ref_deref();
     match_like_matches();
@@ -80,4 +94,5 @@ fn main() {
     match_same_arms2();
     manual_strip_msrv();
     check_index_refutable_slice();
+    borrow_as_ptr();
 }
diff --git a/tests/ui-toml/min_rust_version/min_rust_version.stderr b/tests/ui-toml/min_rust_version/min_rust_version.stderr
index f226c012ca8..a1e7361c0cb 100644
--- a/tests/ui-toml/min_rust_version/min_rust_version.stderr
+++ b/tests/ui-toml/min_rust_version/min_rust_version.stderr
@@ -1,5 +1,5 @@
 error: you are using an explicit closure for copying elements
-  --> $DIR/min_rust_version.rs:73:26
+  --> $DIR/min_rust_version.rs:74:26
    |
 LL |     let _: Option<u64> = Some(&16).map(|b| *b);
    |                          ^^^^^^^^^^^^^^^^^^^^^ help: consider calling the dedicated `cloned` method: `Some(&16).cloned()`
-- 
cgit 1.4.1-3-g733a5


From 70a6d7b012822576ca299b07f612392ca1e0fb91 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sat, 15 Jan 2022 00:15:25 -0500
Subject: Erase late bound regions in `iter_not_returning_iterator`

---
 clippy_lints/src/iter_not_returning_iterator.rs | 2 +-
 tests/ui/iter_not_returning_iterator.rs         | 7 +++++++
 2 files changed, 8 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/iter_not_returning_iterator.rs b/clippy_lints/src/iter_not_returning_iterator.rs
index d3bdc819a9f..b56d87c5348 100644
--- a/clippy_lints/src/iter_not_returning_iterator.rs
+++ b/clippy_lints/src/iter_not_returning_iterator.rs
@@ -66,7 +66,7 @@ impl<'tcx> LateLintPass<'tcx> for IterNotReturningIterator {
 
 fn check_sig(cx: &LateContext<'_>, name: &str, sig: &FnSig<'_>, fn_id: LocalDefId) {
     if sig.decl.implicit_self.has_implicit_self() {
-        let ret_ty = cx.tcx.fn_sig(fn_id).skip_binder().output();
+        let ret_ty = cx.tcx.erase_late_bound_regions(cx.tcx.fn_sig(fn_id).output());
         let ret_ty = cx
             .tcx
             .try_normalize_erasing_regions(cx.param_env, ret_ty)
diff --git a/tests/ui/iter_not_returning_iterator.rs b/tests/ui/iter_not_returning_iterator.rs
index 2c91e02e842..cce216fc649 100644
--- a/tests/ui/iter_not_returning_iterator.rs
+++ b/tests/ui/iter_not_returning_iterator.rs
@@ -64,4 +64,11 @@ impl S {
     }
 }
 
+struct S2([u8]);
+impl S2 {
+    fn iter(&self) -> core::slice::Iter<u8> {
+        self.0.iter()
+    }
+}
+
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From ee84ac3396d9ea09c2160ff892cd297ef1b2ea70 Mon Sep 17 00:00:00 2001
From: Marek Downar <marek.downar@evomedia.pl>
Date: Sat, 15 Jan 2022 15:51:46 +0100
Subject: issue #8239: Printed hint for lint or_fun_call is cropped and does
 not show the solution

---
 clippy_lints/src/methods/or_fun_call.rs | 17 +++++++++++++----
 1 file changed, 13 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/or_fun_call.rs b/clippy_lints/src/methods/or_fun_call.rs
index 4e4653dadca..6fb67ff89c3 100644
--- a/clippy_lints/src/methods/or_fun_call.rs
+++ b/clippy_lints/src/methods/or_fun_call.rs
@@ -4,6 +4,7 @@ use clippy_utils::source::{snippet, snippet_with_applicability, snippet_with_mac
 use clippy_utils::ty::{implements_trait, match_type};
 use clippy_utils::{contains_return, is_trait_item, last_path_segment, paths};
 use if_chain::if_chain;
+use rustc_errors::emitter::MAX_SUGGESTION_HIGHLIGHT_LINES;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
@@ -52,16 +53,24 @@ pub(super) fn check<'tcx>(
 
             then {
                 let mut applicability = Applicability::MachineApplicable;
+                let hint = ".unwrap_or_default()";
+                let mut sugg: String = format!(
+                    "{}{}",
+                    snippet_with_applicability(cx, self_expr.span, "..", &mut applicability),
+                    hint
+                );
+
+                if sugg.lines().count() > MAX_SUGGESTION_HIGHLIGHT_LINES {
+                    sugg = hint.to_string();
+                }
+
                 span_lint_and_sugg(
                     cx,
                     OR_FUN_CALL,
                     span,
                     &format!("use of `{}` followed by a call to `{}`", name, path),
                     "try this",
-                    format!(
-                        "{}.unwrap_or_default()",
-                        snippet_with_applicability(cx, self_expr.span, "..", &mut applicability)
-                    ),
+                    sugg,
                     applicability,
                 );
 
-- 
cgit 1.4.1-3-g733a5


From 49502727e7db97055d04c7f06e04b73b05fdb7e2 Mon Sep 17 00:00:00 2001
From: Marek Downar <marek.downar@evomedia.pl>
Date: Sat, 15 Jan 2022 22:19:01 +0100
Subject: issue #8239: fix to prev commit && 4 test cases

---
 clippy_lints/src/methods/or_fun_call.rs | 13 +++++---
 tests/ui/or_fun_call.fixed              | 48 +++++++++++++++++++++++++++++
 tests/ui/or_fun_call.rs                 | 50 ++++++++++++++++++++++++++++++
 tests/ui/or_fun_call.stderr             | 54 ++++++++++++++++++++++++++++++++-
 4 files changed, 160 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/or_fun_call.rs b/clippy_lints/src/methods/or_fun_call.rs
index 6fb67ff89c3..c35a2e57a66 100644
--- a/clippy_lints/src/methods/or_fun_call.rs
+++ b/clippy_lints/src/methods/or_fun_call.rs
@@ -24,6 +24,7 @@ pub(super) fn check<'tcx>(
     args: &'tcx [hir::Expr<'_>],
 ) {
     /// Checks for `unwrap_or(T::new())` or `unwrap_or(T::default())`.
+    #[allow(clippy::too_many_arguments)]
     fn check_unwrap_or_default(
         cx: &LateContext<'_>,
         name: &str,
@@ -32,6 +33,7 @@ pub(super) fn check<'tcx>(
         arg: &hir::Expr<'_>,
         or_has_args: bool,
         span: Span,
+        method_span: Span,
     ) -> bool {
         let is_default_default = || is_trait_item(cx, fun, sym::Default);
 
@@ -53,21 +55,24 @@ pub(super) fn check<'tcx>(
 
             then {
                 let mut applicability = Applicability::MachineApplicable;
-                let hint = ".unwrap_or_default()";
+                let hint = "unwrap_or_default()";
+                let mut shrink = span;
+
                 let mut sugg: String = format!(
-                    "{}{}",
+                    "{}.{}",
                     snippet_with_applicability(cx, self_expr.span, "..", &mut applicability),
                     hint
                 );
 
                 if sugg.lines().count() > MAX_SUGGESTION_HIGHLIGHT_LINES {
+                    shrink = method_span.with_hi(span.hi());
                     sugg = hint.to_string();
                 }
 
                 span_lint_and_sugg(
                     cx,
                     OR_FUN_CALL,
-                    span,
+                    shrink,
                     &format!("use of `{}` followed by a call to `{}`", name, path),
                     "try this",
                     sugg,
@@ -173,7 +178,7 @@ pub(super) fn check<'tcx>(
         match inner_arg.kind {
             hir::ExprKind::Call(fun, or_args) => {
                 let or_has_args = !or_args.is_empty();
-                if !check_unwrap_or_default(cx, name, fun, self_arg, arg, or_has_args, expr.span) {
+                if !check_unwrap_or_default(cx, name, fun, self_arg, arg, or_has_args, expr.span, method_span) {
                     let fun_span = if or_has_args { None } else { Some(fun.span) };
                     check_general_case(cx, name, method_span, self_arg, arg, expr.span, fun_span);
                 }
diff --git a/tests/ui/or_fun_call.fixed b/tests/ui/or_fun_call.fixed
index 87cdb3ace47..fe8f5c9fc62 100644
--- a/tests/ui/or_fun_call.fixed
+++ b/tests/ui/or_fun_call.fixed
@@ -176,4 +176,52 @@ mod issue6675 {
     }
 }
 
+mod issue8239 {
+    unsafe fn more_than_max_suggestion_highest_lines_0() {
+        let frames = Vec::new();
+        frames
+            .iter()
+            .map(|f: &String| f.to_lowercase())
+            .reduce(|mut acc, f| {
+                acc.push_str(&f);
+                acc
+            })
+            .unwrap_or_default();
+    }
+
+    unsafe fn more_to_max_suggestion_highest_lines_1() {
+        let frames = Vec::new();
+        let iter = frames.iter();
+        iter.map(|f: &String| f.to_lowercase())
+            .reduce(|mut acc, f| {
+                let _ = "";
+                let _ = "";
+                acc.push_str(&f);
+                acc
+            })
+            .unwrap_or_default();
+    }
+
+    unsafe fn equal_to_max_suggestion_highest_lines() {
+        let frames = Vec::new();
+        let iter = frames.iter();
+        iter.map(|f: &String| f.to_lowercase())
+            .reduce(|mut acc, f| {
+                let _ = "";
+                acc.push_str(&f);
+                acc
+            }).unwrap_or_default();
+    }
+
+    unsafe fn less_than_max_suggestion_highest_lines() {
+        let frames = Vec::new();
+        let iter = frames.iter();
+        let map = iter.map(|f: &String| f.to_lowercase());
+        map.reduce(|mut acc, f| {
+            acc.push_str(&f);
+            acc
+        }).unwrap_or_default();
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/or_fun_call.rs b/tests/ui/or_fun_call.rs
index 3f69cef301c..a702d9dadd4 100644
--- a/tests/ui/or_fun_call.rs
+++ b/tests/ui/or_fun_call.rs
@@ -176,4 +176,54 @@ mod issue6675 {
     }
 }
 
+mod issue8239 {
+    unsafe fn more_than_max_suggestion_highest_lines_0() {
+        let frames = Vec::new();
+        frames
+            .iter()
+            .map(|f: &String| f.to_lowercase())
+            .reduce(|mut acc, f| {
+                acc.push_str(&f);
+                acc
+            })
+            .unwrap_or(String::new());
+    }
+
+    unsafe fn more_to_max_suggestion_highest_lines_1() {
+        let frames = Vec::new();
+        let iter = frames.iter();
+        iter.map(|f: &String| f.to_lowercase())
+            .reduce(|mut acc, f| {
+                let _ = "";
+                let _ = "";
+                acc.push_str(&f);
+                acc
+            })
+            .unwrap_or(String::new());
+    }
+
+    unsafe fn equal_to_max_suggestion_highest_lines() {
+        let frames = Vec::new();
+        let iter = frames.iter();
+        iter.map(|f: &String| f.to_lowercase())
+            .reduce(|mut acc, f| {
+                let _ = "";
+                acc.push_str(&f);
+                acc
+            })
+            .unwrap_or(String::new());
+    }
+
+    unsafe fn less_than_max_suggestion_highest_lines() {
+        let frames = Vec::new();
+        let iter = frames.iter();
+        let map = iter.map(|f: &String| f.to_lowercase());
+        map.reduce(|mut acc, f| {
+            acc.push_str(&f);
+            acc
+        })
+        .unwrap_or(String::new());
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/or_fun_call.stderr b/tests/ui/or_fun_call.stderr
index 9d0c42b10c2..549b00ae3c4 100644
--- a/tests/ui/or_fun_call.stderr
+++ b/tests/ui/or_fun_call.stderr
@@ -108,5 +108,57 @@ error: use of `unwrap_or` followed by a function call
 LL |         None.unwrap_or( unsafe { ptr_to_ref(s) }    );
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|| unsafe { ptr_to_ref(s) })`
 
-error: aborting due to 18 previous errors
+error: use of `unwrap_or` followed by a call to `new`
+  --> $DIR/or_fun_call.rs:189:14
+   |
+LL |             .unwrap_or(String::new());
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_default()`
+
+error: use of `unwrap_or` followed by a call to `new`
+  --> $DIR/or_fun_call.rs:202:14
+   |
+LL |             .unwrap_or(String::new());
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_default()`
+
+error: use of `unwrap_or` followed by a call to `new`
+  --> $DIR/or_fun_call.rs:208:9
+   |
+LL | /         iter.map(|f: &String| f.to_lowercase())
+LL | |             .reduce(|mut acc, f| {
+LL | |                 let _ = "";
+LL | |                 acc.push_str(&f);
+LL | |                 acc
+LL | |             })
+LL | |             .unwrap_or(String::new());
+   | |_____________________________________^
+   |
+help: try this
+   |
+LL ~         iter.map(|f: &String| f.to_lowercase())
+LL +             .reduce(|mut acc, f| {
+LL +                 let _ = "";
+LL +                 acc.push_str(&f);
+LL +                 acc
+LL ~             }).unwrap_or_default();
+   |
+
+error: use of `unwrap_or` followed by a call to `new`
+  --> $DIR/or_fun_call.rs:221:9
+   |
+LL | /         map.reduce(|mut acc, f| {
+LL | |             acc.push_str(&f);
+LL | |             acc
+LL | |         })
+LL | |         .unwrap_or(String::new());
+   | |_________________________________^
+   |
+help: try this
+   |
+LL ~         map.reduce(|mut acc, f| {
+LL +             acc.push_str(&f);
+LL +             acc
+LL ~         }).unwrap_or_default();
+   |
+
+error: aborting due to 22 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From cb384ff03b7a10bca10b962d9907c0d56ba3086f Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sat, 15 Jan 2022 14:33:43 -0500
Subject: Handle implicit named arguments in `useless_format`

---
 clippy_lints/src/format.rs | 19 +++++++++++++++++--
 tests/ui/format.fixed      |  6 ++++++
 tests/ui/format.rs         |  6 ++++++
 tests/ui/format.stderr     | 14 +++++++++++++-
 4 files changed, 42 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/format.rs b/clippy_lints/src/format.rs
index 688d8f8630f..395c920c997 100644
--- a/clippy_lints/src/format.rs
+++ b/clippy_lints/src/format.rs
@@ -9,7 +9,7 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::symbol::kw;
-use rustc_span::{sym, Span};
+use rustc_span::{sym, BytePos, Span};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -84,7 +84,22 @@ impl<'tcx> LateLintPass<'tcx> for UselessFormat {
                         ExprKind::MethodCall(path, ..) => path.ident.name.as_str() == "to_string",
                         _ => false,
                     };
-                    let sugg = if is_new_string {
+                    let sugg = if format_args.format_string_span.contains(value.span) {
+                        // Implicit argument. e.g. `format!("{x}")` span points to `{x}`
+                        let spdata = value.span.data();
+                        let span = Span::new(
+                            spdata.lo + BytePos(1),
+                            spdata.hi - BytePos(1),
+                            spdata.ctxt,
+                            spdata.parent
+                        );
+                        let snip = snippet_with_applicability(cx, span, "..", &mut applicability);
+                        if is_new_string {
+                            snip.into()
+                        } else {
+                            format!("{snip}.to_string()")
+                        }
+                    } else if is_new_string {
                         snippet_with_applicability(cx, value.span, "..", &mut applicability).into_owned()
                     } else {
                         let sugg = Sugg::hir_with_applicability(cx, value, "<arg>", &mut applicability);
diff --git a/tests/ui/format.fixed b/tests/ui/format.fixed
index 64cb7b1cfb8..78d2bfd474e 100644
--- a/tests/ui/format.fixed
+++ b/tests/ui/format.fixed
@@ -73,4 +73,10 @@ fn main() {
     let _s: String = (&*v.join("\n")).to_string();
 
     format!("prepend {:+}", "s");
+
+    // Issue #8290
+    let x = "foo";
+    let _ = x.to_string();
+    let _ = format!("{x:?}"); // Don't lint on debug
+    let _ = x.to_string();
 }
diff --git a/tests/ui/format.rs b/tests/ui/format.rs
index a065b1b5683..009c1aa216f 100644
--- a/tests/ui/format.rs
+++ b/tests/ui/format.rs
@@ -75,4 +75,10 @@ fn main() {
     let _s: String = format!("{}", &*v.join("\n"));
 
     format!("prepend {:+}", "s");
+
+    // Issue #8290
+    let x = "foo";
+    let _ = format!("{x}");
+    let _ = format!("{x:?}"); // Don't lint on debug
+    let _ = format!("{y}", y = x);
 }
diff --git a/tests/ui/format.stderr b/tests/ui/format.stderr
index 58ad7499bb2..660be57585e 100644
--- a/tests/ui/format.stderr
+++ b/tests/ui/format.stderr
@@ -99,5 +99,17 @@ error: useless use of `format!`
 LL |     let _s: String = format!("{}", &*v.join("/n"));
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `(&*v.join("/n")).to_string()`
 
-error: aborting due to 15 previous errors
+error: useless use of `format!`
+  --> $DIR/format.rs:81:13
+   |
+LL |     let _ = format!("{x}");
+   |             ^^^^^^^^^^^^^^ help: consider using `.to_string()`: `x.to_string()`
+
+error: useless use of `format!`
+  --> $DIR/format.rs:83:13
+   |
+LL |     let _ = format!("{y}", y = x);
+   |             ^^^^^^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `x.to_string()`
+
+error: aborting due to 17 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From fb5f51d3ebb2c6b119a7343037cbe780f1a3bf2c Mon Sep 17 00:00:00 2001
From: Elliot Bobrow <elliotgreybobrow@gmail.com>
Date: Sun, 16 Jan 2022 09:17:22 -0800
Subject: fix op_ref false positive

---
 clippy_lints/src/eq_op.rs | 69 ++++++++++++++++++++++++++++++++++++++++++++++-
 tests/ui/op_ref.rs        | 39 ++++++++++++++++++++++++++-
 tests/ui/op_ref.stderr    | 18 ++++++++++++-
 3 files changed, 123 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/eq_op.rs b/clippy_lints/src/eq_op.rs
index df75b815436..24d7613e6f8 100644
--- a/clippy_lints/src/eq_op.rs
+++ b/clippy_lints/src/eq_op.rs
@@ -1,12 +1,16 @@
 use clippy_utils::diagnostics::{multispan_sugg, span_lint, span_lint_and_then};
+use clippy_utils::get_enclosing_block;
 use clippy_utils::macros::{find_assert_eq_args, first_node_macro_backtrace};
 use clippy_utils::source::snippet;
 use clippy_utils::ty::{implements_trait, is_copy};
 use clippy_utils::{ast_utils::is_useless_with_eq_exprs, eq_expr_value, is_in_test_function};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
-use rustc_hir::{BinOpKind, BorrowKind, Expr, ExprKind};
+use rustc_hir::{
+    def::Res, def_id::DefId, BinOpKind, BorrowKind, Expr, ExprKind, GenericArg, ItemKind, QPath, Ty, TyKind,
+};
 use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::{self, TyS};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
@@ -146,6 +150,13 @@ impl<'tcx> LateLintPass<'tcx> for EqOp {
                         let rty = cx.typeck_results().expr_ty(r);
                         let lcpy = is_copy(cx, lty);
                         let rcpy = is_copy(cx, rty);
+                        if let Some((self_ty, other_ty)) = in_impl(cx, e, trait_id) {
+                            if (are_equal(cx, rty, self_ty) && are_equal(cx, lty, other_ty))
+                                || (are_equal(cx, rty, other_ty) && are_equal(cx, lty, self_ty))
+                            {
+                                return; // Don't lint
+                            }
+                        }
                         // either operator autorefs or both args are copyable
                         if (requires_ref || (lcpy && rcpy)) && implements_trait(cx, lty, trait_id, &[rty.into()]) {
                             span_lint_and_then(
@@ -206,6 +217,14 @@ impl<'tcx> LateLintPass<'tcx> for EqOp {
                     // &foo == bar
                     (&ExprKind::AddrOf(BorrowKind::Ref, _, l), _) => {
                         let lty = cx.typeck_results().expr_ty(l);
+                        if let Some((self_ty, other_ty)) = in_impl(cx, e, trait_id) {
+                            let rty = cx.typeck_results().expr_ty(right);
+                            if (are_equal(cx, rty, self_ty) && are_equal(cx, lty, other_ty))
+                                || (are_equal(cx, rty, other_ty) && are_equal(cx, lty, self_ty))
+                            {
+                                return; // Don't lint
+                            }
+                        }
                         let lcpy = is_copy(cx, lty);
                         if (requires_ref || lcpy)
                             && implements_trait(cx, lty, trait_id, &[cx.typeck_results().expr_ty(right).into()])
@@ -230,6 +249,14 @@ impl<'tcx> LateLintPass<'tcx> for EqOp {
                     // foo == &bar
                     (_, &ExprKind::AddrOf(BorrowKind::Ref, _, r)) => {
                         let rty = cx.typeck_results().expr_ty(r);
+                        if let Some((self_ty, other_ty)) = in_impl(cx, e, trait_id) {
+                            let lty = cx.typeck_results().expr_ty(left);
+                            if (are_equal(cx, rty, self_ty) && are_equal(cx, lty, other_ty))
+                                || (are_equal(cx, rty, other_ty) && are_equal(cx, lty, self_ty))
+                            {
+                                return; // Don't lint
+                            }
+                        }
                         let rcpy = is_copy(cx, rty);
                         if (requires_ref || rcpy)
                             && implements_trait(cx, cx.typeck_results().expr_ty(left), trait_id, &[rty.into()])
@@ -251,3 +278,43 @@ impl<'tcx> LateLintPass<'tcx> for EqOp {
         }
     }
 }
+
+fn in_impl<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>, bin_op: DefId) -> Option<(&'tcx Ty<'tcx>, &'tcx Ty<'tcx>)> {
+    if_chain! {
+        if let Some(block) = get_enclosing_block(cx, e.hir_id);
+        if let Some(impl_def_id) = cx.tcx.impl_of_method(block.hir_id.owner.to_def_id());
+        let item = cx.tcx.hir().expect_item(impl_def_id.expect_local());
+        if let ItemKind::Impl(item) = &item.kind;
+        if let Some(of_trait) = &item.of_trait;
+        if let Some(seg) = of_trait.path.segments.last();
+        if let Some(Res::Def(_, trait_id)) = seg.res;
+        if trait_id == bin_op;
+        if let Some(generic_args) = seg.args;
+        if let Some(GenericArg::Type(other_ty)) = generic_args.args.last();
+
+        then {
+            Some((item.self_ty, other_ty))
+        }
+        else {
+            None
+        }
+    }
+}
+
+fn are_equal<'tcx>(cx: &LateContext<'tcx>, middle_ty: &TyS<'_>, hir_ty: &Ty<'_>) -> bool {
+    if_chain! {
+        if let ty::Adt(adt_def, _) = middle_ty.kind();
+        if let Some(local_did) = adt_def.did.as_local();
+        let item = cx.tcx.hir().expect_item(local_did);
+        let middle_ty_id = item.def_id.to_def_id();
+        if let TyKind::Path(QPath::Resolved(_, path)) = hir_ty.kind;
+        if let Res::Def(_, hir_ty_id) = path.res;
+
+        then {
+            hir_ty_id == middle_ty_id
+        }
+        else {
+            false
+        }
+    }
+}
diff --git a/tests/ui/op_ref.rs b/tests/ui/op_ref.rs
index ab9c4d34c88..d8bf66603d9 100644
--- a/tests/ui/op_ref.rs
+++ b/tests/ui/op_ref.rs
@@ -1,7 +1,7 @@
 #![allow(unused_variables, clippy::blacklisted_name)]
 #![warn(clippy::op_ref)]
 use std::collections::HashSet;
-use std::ops::BitAnd;
+use std::ops::{BitAnd, Mul};
 
 fn main() {
     let tracked_fds: HashSet<i32> = HashSet::new();
@@ -55,3 +55,40 @@ fn main() {
     let y = Y(2);
     let z = x & &y;
 }
+
+#[derive(Clone, Copy)]
+struct A(i32);
+#[derive(Clone, Copy)]
+struct B(i32);
+
+impl Mul<&A> for B {
+    type Output = i32;
+    fn mul(self, rhs: &A) -> Self::Output {
+        self.0 * rhs.0
+    }
+}
+impl Mul<A> for B {
+    type Output = i32;
+    fn mul(self, rhs: A) -> Self::Output {
+        // Should not lint because removing the reference would lead to unconditional recursion
+        self * &rhs
+    }
+}
+impl Mul<&A> for A {
+    type Output = i32;
+    fn mul(self, rhs: &A) -> Self::Output {
+        self.0 * rhs.0
+    }
+}
+impl Mul<A> for A {
+    type Output = i32;
+    fn mul(self, rhs: A) -> Self::Output {
+        let one = B(1);
+        let two = 2;
+        let three = 3;
+        let _ = one * &self;
+        let _ = two + &three;
+        // Removing the reference would lead to unconditional recursion
+        self * &rhs
+    }
+}
diff --git a/tests/ui/op_ref.stderr b/tests/ui/op_ref.stderr
index 992417084bd..fe36c01166f 100644
--- a/tests/ui/op_ref.stderr
+++ b/tests/ui/op_ref.stderr
@@ -18,5 +18,21 @@ LL |     let z = x & &y;
    |                 |
    |                 help: use the right value directly: `y`
 
-error: aborting due to 2 previous errors
+error: taken reference of right operand
+  --> $DIR/op_ref.rs:89:17
+   |
+LL |         let _ = one * &self;
+   |                 ^^^^^^-----
+   |                       |
+   |                       help: use the right value directly: `self`
+
+error: taken reference of right operand
+  --> $DIR/op_ref.rs:90:17
+   |
+LL |         let _ = two + &three;
+   |                 ^^^^^^------
+   |                       |
+   |                       help: use the right value directly: `three`
+
+error: aborting due to 4 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 1c9b31d3503e3c324ffc12f1fbf9bab5e318decb Mon Sep 17 00:00:00 2001
From: Piotr Mikulski <piotr@near.org>
Date: Thu, 30 Dec 2021 22:39:53 -0800
Subject: New line: cloned_next

---
 CHANGELOG.md                                      |  1 +
 clippy_lints/src/lib.register_all.rs              |  1 +
 clippy_lints/src/lib.register_lints.rs            |  1 +
 clippy_lints/src/lib.register_perf.rs             |  1 +
 clippy_lints/src/methods/iter_overeager_cloned.rs | 62 +++++++++++++++
 clippy_lints/src/methods/mod.rs                   | 91 +++++++++++++++++++----
 tests/ui/iter_overeager_cloned.fixed              | 45 +++++++++++
 tests/ui/iter_overeager_cloned.rs                 | 47 ++++++++++++
 tests/ui/iter_overeager_cloned.stderr             | 58 +++++++++++++++
 9 files changed, 292 insertions(+), 15 deletions(-)
 create mode 100644 clippy_lints/src/methods/iter_overeager_cloned.rs
 create mode 100644 tests/ui/iter_overeager_cloned.fixed
 create mode 100644 tests/ui/iter_overeager_cloned.rs
 create mode 100644 tests/ui/iter_overeager_cloned.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 8f4da9a3827..258a8256f53 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3049,6 +3049,7 @@ Released 2018-09-13
 [`iter_not_returning_iterator`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_not_returning_iterator
 [`iter_nth`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_nth
 [`iter_nth_zero`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_nth_zero
+[`iter_overeager_cloned`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_overeager_cloned
 [`iter_skip_next`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_skip_next
 [`iterator_step_by_zero`]: https://rust-lang.github.io/rust-clippy/master/index.html#iterator_step_by_zero
 [`just_underscores_and_digits`]: https://rust-lang.github.io/rust-clippy/master/index.html#just_underscores_and_digits
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 26fb4259952..eba51099496 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -156,6 +156,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(methods::ITER_NEXT_SLICE),
     LintId::of(methods::ITER_NTH),
     LintId::of(methods::ITER_NTH_ZERO),
+    LintId::of(methods::ITER_OVEREAGER_CLONED),
     LintId::of(methods::ITER_SKIP_NEXT),
     LintId::of(methods::MANUAL_FILTER_MAP),
     LintId::of(methods::MANUAL_FIND_MAP),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 746bdb19c3d..56146a0fd3a 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -288,6 +288,7 @@ store.register_lints(&[
     methods::ITER_NEXT_SLICE,
     methods::ITER_NTH,
     methods::ITER_NTH_ZERO,
+    methods::ITER_OVEREAGER_CLONED,
     methods::ITER_SKIP_NEXT,
     methods::MANUAL_FILTER_MAP,
     methods::MANUAL_FIND_MAP,
diff --git a/clippy_lints/src/lib.register_perf.rs b/clippy_lints/src/lib.register_perf.rs
index f9ffd4cf829..c44ef124bfa 100644
--- a/clippy_lints/src/lib.register_perf.rs
+++ b/clippy_lints/src/lib.register_perf.rs
@@ -14,6 +14,7 @@ store.register_group(true, "clippy::perf", Some("clippy_perf"), vec![
     LintId::of(methods::EXPECT_FUN_CALL),
     LintId::of(methods::EXTEND_WITH_DRAIN),
     LintId::of(methods::ITER_NTH),
+    LintId::of(methods::ITER_OVEREAGER_CLONED),
     LintId::of(methods::MANUAL_STR_REPEAT),
     LintId::of(methods::OR_FUN_CALL),
     LintId::of(methods::SINGLE_CHAR_PATTERN),
diff --git a/clippy_lints/src/methods/iter_overeager_cloned.rs b/clippy_lints/src/methods/iter_overeager_cloned.rs
new file mode 100644
index 00000000000..ca33bfc643d
--- /dev/null
+++ b/clippy_lints/src/methods/iter_overeager_cloned.rs
@@ -0,0 +1,62 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet;
+use clippy_utils::ty::{get_iterator_item_ty, is_copy};
+use itertools::Itertools;
+use rustc_errors::Applicability;
+use rustc_hir as hir;
+use rustc_lint::LateContext;
+use rustc_middle::ty;
+use std::ops::Not;
+
+use super::ITER_OVEREAGER_CLONED;
+use crate::redundant_clone::REDUNDANT_CLONE;
+
+/// lint overeager use of `cloned()` for `Iterator`s
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx hir::Expr<'_>,
+    recv: &'tcx hir::Expr<'_>,
+    name: &str,
+    map_arg: &[hir::Expr<'_>],
+) {
+    // Check if it's iterator and get type associated with `Item`.
+    let inner_ty = match get_iterator_item_ty(cx, cx.typeck_results().expr_ty_adjusted(recv)) {
+        Some(ty) => ty,
+        _ => return,
+    };
+
+    match inner_ty.kind() {
+        ty::Ref(_, ty, _) if !is_copy(cx, ty) => {},
+        _ => return,
+    };
+
+    let (lint, preserve_cloned) = match name {
+        "count" => (REDUNDANT_CLONE, false),
+        _ => (ITER_OVEREAGER_CLONED, true),
+    };
+    let wildcard_params = map_arg.is_empty().not().then(|| "...").unwrap_or_default();
+    let msg = format!(
+        "called `cloned().{}({})` on an `Iterator`. It may be more efficient to call `{}({}){}` instead",
+        name,
+        wildcard_params,
+        name,
+        wildcard_params,
+        preserve_cloned.then(|| ".cloned()").unwrap_or_default(),
+    );
+
+    span_lint_and_sugg(
+        cx,
+        lint,
+        expr.span,
+        &msg,
+        "try this",
+        format!(
+            "{}.{}({}){}",
+            snippet(cx, recv.span, ".."),
+            name,
+            map_arg.iter().map(|a| snippet(cx, a.span, "..")).join(", "),
+            preserve_cloned.then(|| ".cloned()").unwrap_or_default(),
+        ),
+        Applicability::MachineApplicable,
+    );
+}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index a3cfdd3d4ba..cff625112e5 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -30,6 +30,7 @@ mod iter_count;
 mod iter_next_slice;
 mod iter_nth;
 mod iter_nth_zero;
+mod iter_overeager_cloned;
 mod iter_skip_next;
 mod iterator_step_by_zero;
 mod manual_saturating_arithmetic;
@@ -106,6 +107,41 @@ declare_clippy_lint! {
     "used `cloned` where `copied` could be used instead"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of `_.cloned().<func>()` where call to `.cloned()` can be postponed.
+    ///
+    /// ### Why is this bad?
+    /// It's often inefficient to clone all elements of an iterator, when eventually, only some
+    /// of them will be consumed.
+    ///
+    /// ### Examples
+    /// ```rust
+    /// # let vec = vec!["string".to_string()];
+    ///
+    /// // Bad
+    /// vec.iter().cloned().take(10);
+    ///
+    /// // Good
+    /// vec.iter().take(10).cloned();
+    ///
+    /// // Bad
+    /// vec.iter().cloned().last();
+    ///
+    /// // Good
+    /// vec.iter().last().cloned();
+    ///
+    /// ```
+    /// ### Known Problems
+    /// This `lint` removes the side of effect of cloning items in the iterator.
+    /// A code that relies on that side-effect could fail.
+    ///
+    #[clippy::version = "1.59.0"]
+    pub ITER_OVEREAGER_CLONED,
+    perf,
+    "using `cloned()` early with `Iterator::iter()` can lead to some performance inefficiencies"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for usages of `Iterator::flat_map()` where `filter_map()` could be
@@ -1950,6 +1986,7 @@ impl_lint_pass!(Methods => [
     CLONE_ON_COPY,
     CLONE_ON_REF_PTR,
     CLONE_DOUBLE_REF,
+    ITER_OVEREAGER_CLONED,
     CLONED_INSTEAD_OF_COPIED,
     FLAT_MAP_OPTION,
     INEFFICIENT_TO_STRING,
@@ -2243,9 +2280,10 @@ fn check_methods<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, msrv: Optio
                 },
                 _ => {},
             },
-            ("count", []) => match method_call(recv) {
-                Some((name @ ("into_iter" | "iter" | "iter_mut"), [recv2], _)) => {
-                    iter_count::check(cx, expr, recv2, name);
+            (name @ "count", args @ []) => match method_call(recv) {
+                Some(("cloned", [recv2], _)) => iter_overeager_cloned::check(cx, expr, recv2, name, args),
+                Some((name2 @ ("into_iter" | "iter" | "iter_mut"), [recv2], _)) => {
+                    iter_count::check(cx, expr, recv2, name2);
                 },
                 Some(("map", [_, arg], _)) => suspicious_map::check(cx, expr, recv, arg),
                 _ => {},
@@ -2266,10 +2304,10 @@ fn check_methods<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, msrv: Optio
                 flat_map_identity::check(cx, expr, arg, span);
                 flat_map_option::check(cx, expr, arg, span);
             },
-            ("flatten", []) => {
-                if let Some(("map", [recv, map_arg], _)) = method_call(recv) {
-                    map_flatten::check(cx, expr, recv, map_arg);
-                }
+            (name @ "flatten", args @ []) => match method_call(recv) {
+                Some(("map", [recv, map_arg], _)) => map_flatten::check(cx, expr, recv, map_arg),
+                Some(("cloned", [recv2], _)) => iter_overeager_cloned::check(cx, expr, recv2, name, args),
+                _ => {},
             },
             ("fold", [init, acc]) => unnecessary_fold::check(cx, expr, init, acc, span),
             ("for_each", [_]) => {
@@ -2281,6 +2319,13 @@ fn check_methods<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, msrv: Optio
             ("is_file", []) => filetype_is_file::check(cx, expr, recv),
             ("is_none", []) => check_is_some_is_none(cx, expr, recv, false),
             ("is_some", []) => check_is_some_is_none(cx, expr, recv, true),
+            ("last", args @ []) => {
+                if let Some((name2, [recv2, args2 @ ..], _span2)) = method_call(recv) {
+                    if let ("cloned", []) = (name2, args2) {
+                        iter_overeager_cloned::check(cx, expr, recv2, name, args);
+                    }
+                }
+            },
             ("map", [m_arg]) => {
                 if let Some((name, [recv2, args @ ..], span2)) = method_call(recv) {
                     match (name, args) {
@@ -2296,20 +2341,22 @@ fn check_methods<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, msrv: Optio
                 map_identity::check(cx, expr, recv, m_arg, span);
             },
             ("map_or", [def, map]) => option_map_or_none::check(cx, expr, recv, def, map),
-            ("next", []) => {
-                if let Some((name, [recv, args @ ..], _)) = method_call(recv) {
-                    match (name, args) {
-                        ("filter", [arg]) => filter_next::check(cx, expr, recv, arg),
-                        ("filter_map", [arg]) => filter_map_next::check(cx, expr, recv, arg, msrv),
-                        ("iter", []) => iter_next_slice::check(cx, expr, recv),
-                        ("skip", [arg]) => iter_skip_next::check(cx, expr, recv, arg),
+            (name @ "next", args @ []) => {
+                if let Some((name2, [recv2, args2 @ ..], _)) = method_call(recv) {
+                    match (name2, args2) {
+                        ("cloned", []) => iter_overeager_cloned::check(cx, expr, recv2, name, args),
+                        ("filter", [arg]) => filter_next::check(cx, expr, recv2, arg),
+                        ("filter_map", [arg]) => filter_map_next::check(cx, expr, recv2, arg, msrv),
+                        ("iter", []) => iter_next_slice::check(cx, expr, recv2),
+                        ("skip", [arg]) => iter_skip_next::check(cx, expr, recv2, arg),
                         ("skip_while", [_]) => skip_while_next::check(cx, expr),
                         _ => {},
                     }
                 }
             },
-            ("nth", [n_arg]) => match method_call(recv) {
+            ("nth", args @ [n_arg]) => match method_call(recv) {
                 Some(("bytes", [recv2], _)) => bytes_nth::check(cx, expr, recv2, n_arg),
+                Some(("cloned", [recv2], _)) => iter_overeager_cloned::check(cx, expr, recv2, name, args),
                 Some(("iter", [recv2], _)) => iter_nth::check(cx, expr, recv2, recv, n_arg, false),
                 Some(("iter_mut", [recv2], _)) => iter_nth::check(cx, expr, recv2, recv, n_arg, true),
                 _ => iter_nth_zero::check(cx, expr, recv, n_arg),
@@ -2320,6 +2367,13 @@ fn check_methods<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, msrv: Optio
                     unnecessary_lazy_eval::check(cx, expr, recv, arg, "or");
                 }
             },
+            ("skip", args) => {
+                if let Some((name2, [recv2, args2 @ ..], _span2)) = method_call(recv) {
+                    if let ("cloned", []) = (name2, args2) {
+                        iter_overeager_cloned::check(cx, expr, recv2, name, args);
+                    }
+                }
+            },
             ("splitn" | "rsplitn", [count_arg, pat_arg]) => {
                 if let Some((Constant::Int(count), _)) = constant(cx, cx.typeck_results(), count_arg) {
                     suspicious_splitn::check(cx, name, expr, recv, count);
@@ -2337,6 +2391,13 @@ fn check_methods<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, msrv: Optio
                 }
             },
             ("step_by", [arg]) => iterator_step_by_zero::check(cx, expr, arg),
+            ("take", args @ [_arg]) => {
+                if let Some((name2, [recv2, args2 @ ..], _span2)) = method_call(recv) {
+                    if let ("cloned", []) = (name2, args2) {
+                        iter_overeager_cloned::check(cx, expr, recv2, name, args);
+                    }
+                }
+            },
             ("to_os_string" | "to_owned" | "to_path_buf" | "to_vec", []) => {
                 implicit_clone::check(cx, name, expr, recv);
             },
diff --git a/tests/ui/iter_overeager_cloned.fixed b/tests/ui/iter_overeager_cloned.fixed
new file mode 100644
index 00000000000..a9041671101
--- /dev/null
+++ b/tests/ui/iter_overeager_cloned.fixed
@@ -0,0 +1,45 @@
+// run-rustfix
+#![warn(clippy::iter_overeager_cloned, clippy::redundant_clone, clippy::filter_next)]
+
+fn main() {
+    let vec = vec!["1".to_string(), "2".to_string(), "3".to_string()];
+
+    let _: Option<String> = vec.iter().last().cloned();
+
+    let _: Option<String> = vec.iter().chain(vec.iter()).next().cloned();
+
+    let _: usize = vec.iter().filter(|x| x == &"2").count();
+
+    let _: Vec<_> = vec.iter().take(2).cloned().collect();
+
+    let _: Vec<_> = vec.iter().skip(2).cloned().collect();
+
+    let _ = vec.iter().filter(|x| x == &"2").nth(2).cloned();
+
+    let _ = [Some(Some("str".to_string())), Some(Some("str".to_string()))]
+        .iter().flatten().cloned();
+
+    // Not implemented yet
+    let _ = vec.iter().cloned().filter(|x| x.starts_with('2'));
+
+    // Not implemented yet
+    let _ = vec.iter().cloned().map(|x| x.len());
+
+    // This would fail if changed.
+    let _ = vec.iter().cloned().map(|x| x + "2");
+
+    // Not implemented yet
+    let _ = vec.iter().cloned().find(|x| x == "2");
+
+    // Not implemented yet
+    let _ = vec.iter().cloned().for_each(|x| assert!(!x.is_empty()));
+
+    // Not implemented yet
+    let _ = vec.iter().cloned().all(|x| x.len() == 1);
+
+    // Not implemented yet
+    let _ = vec.iter().cloned().any(|x| x.len() == 1);
+
+    // Should probably stay as it is.
+    let _ = [0, 1, 2, 3, 4].iter().cloned().take(10);
+}
diff --git a/tests/ui/iter_overeager_cloned.rs b/tests/ui/iter_overeager_cloned.rs
new file mode 100644
index 00000000000..dd04e33a4b3
--- /dev/null
+++ b/tests/ui/iter_overeager_cloned.rs
@@ -0,0 +1,47 @@
+// run-rustfix
+#![warn(clippy::iter_overeager_cloned, clippy::redundant_clone, clippy::filter_next)]
+
+fn main() {
+    let vec = vec!["1".to_string(), "2".to_string(), "3".to_string()];
+
+    let _: Option<String> = vec.iter().cloned().last();
+
+    let _: Option<String> = vec.iter().chain(vec.iter()).cloned().next();
+
+    let _: usize = vec.iter().filter(|x| x == &"2").cloned().count();
+
+    let _: Vec<_> = vec.iter().cloned().take(2).collect();
+
+    let _: Vec<_> = vec.iter().cloned().skip(2).collect();
+
+    let _ = vec.iter().filter(|x| x == &"2").cloned().nth(2);
+
+    let _ = [Some(Some("str".to_string())), Some(Some("str".to_string()))]
+        .iter()
+        .cloned()
+        .flatten();
+
+    // Not implemented yet
+    let _ = vec.iter().cloned().filter(|x| x.starts_with('2'));
+
+    // Not implemented yet
+    let _ = vec.iter().cloned().map(|x| x.len());
+
+    // This would fail if changed.
+    let _ = vec.iter().cloned().map(|x| x + "2");
+
+    // Not implemented yet
+    let _ = vec.iter().cloned().find(|x| x == "2");
+
+    // Not implemented yet
+    let _ = vec.iter().cloned().for_each(|x| assert!(!x.is_empty()));
+
+    // Not implemented yet
+    let _ = vec.iter().cloned().all(|x| x.len() == 1);
+
+    // Not implemented yet
+    let _ = vec.iter().cloned().any(|x| x.len() == 1);
+
+    // Should probably stay as it is.
+    let _ = [0, 1, 2, 3, 4].iter().cloned().take(10);
+}
diff --git a/tests/ui/iter_overeager_cloned.stderr b/tests/ui/iter_overeager_cloned.stderr
new file mode 100644
index 00000000000..e36b0e36fbd
--- /dev/null
+++ b/tests/ui/iter_overeager_cloned.stderr
@@ -0,0 +1,58 @@
+error: called `cloned().last()` on an `Iterator`. It may be more efficient to call `last().cloned()` instead
+  --> $DIR/iter_overeager_cloned.rs:7:29
+   |
+LL |     let _: Option<String> = vec.iter().cloned().last();
+   |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `vec.iter().last().cloned()`
+   |
+   = note: `-D clippy::iter-overeager-cloned` implied by `-D warnings`
+
+error: called `cloned().next()` on an `Iterator`. It may be more efficient to call `next().cloned()` instead
+  --> $DIR/iter_overeager_cloned.rs:9:29
+   |
+LL |     let _: Option<String> = vec.iter().chain(vec.iter()).cloned().next();
+   |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `vec.iter().chain(vec.iter()).next().cloned()`
+
+error: called `cloned().count()` on an `Iterator`. It may be more efficient to call `count()` instead
+  --> $DIR/iter_overeager_cloned.rs:11:20
+   |
+LL |     let _: usize = vec.iter().filter(|x| x == &"2").cloned().count();
+   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `vec.iter().filter(|x| x == &"2").count()`
+   |
+   = note: `-D clippy::redundant-clone` implied by `-D warnings`
+
+error: called `cloned().take(...)` on an `Iterator`. It may be more efficient to call `take(...).cloned()` instead
+  --> $DIR/iter_overeager_cloned.rs:13:21
+   |
+LL |     let _: Vec<_> = vec.iter().cloned().take(2).collect();
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `vec.iter().take(2).cloned()`
+
+error: called `cloned().skip(...)` on an `Iterator`. It may be more efficient to call `skip(...).cloned()` instead
+  --> $DIR/iter_overeager_cloned.rs:15:21
+   |
+LL |     let _: Vec<_> = vec.iter().cloned().skip(2).collect();
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `vec.iter().skip(2).cloned()`
+
+error: called `cloned().nth(...)` on an `Iterator`. It may be more efficient to call `nth(...).cloned()` instead
+  --> $DIR/iter_overeager_cloned.rs:17:13
+   |
+LL |     let _ = vec.iter().filter(|x| x == &"2").cloned().nth(2);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `vec.iter().filter(|x| x == &"2").nth(2).cloned()`
+
+error: called `cloned().flatten()` on an `Iterator`. It may be more efficient to call `flatten().cloned()` instead
+  --> $DIR/iter_overeager_cloned.rs:19:13
+   |
+LL |       let _ = [Some(Some("str".to_string())), Some(Some("str".to_string()))]
+   |  _____________^
+LL | |         .iter()
+LL | |         .cloned()
+LL | |         .flatten();
+   | |__________________^
+   |
+help: try this
+   |
+LL ~     let _ = [Some(Some("str".to_string())), Some(Some("str".to_string()))]
+LL ~         .iter().flatten().cloned();
+   |
+
+error: aborting due to 7 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From d48d247309f024b4d009a528e243e4567a98aa8e Mon Sep 17 00:00:00 2001
From: Piotr Mikulski <piotr@near.org>
Date: Sun, 16 Jan 2022 10:19:48 -0800
Subject: Fix clippy warnings

---
 clippy_lints/src/methods/mod.rs | 9 +--------
 1 file changed, 1 insertion(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index cff625112e5..f9d8e03a499 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -2319,7 +2319,7 @@ fn check_methods<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, msrv: Optio
             ("is_file", []) => filetype_is_file::check(cx, expr, recv),
             ("is_none", []) => check_is_some_is_none(cx, expr, recv, false),
             ("is_some", []) => check_is_some_is_none(cx, expr, recv, true),
-            ("last", args @ []) => {
+            ("last" | "skip", args @ []) => {
                 if let Some((name2, [recv2, args2 @ ..], _span2)) = method_call(recv) {
                     if let ("cloned", []) = (name2, args2) {
                         iter_overeager_cloned::check(cx, expr, recv2, name, args);
@@ -2367,13 +2367,6 @@ fn check_methods<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, msrv: Optio
                     unnecessary_lazy_eval::check(cx, expr, recv, arg, "or");
                 }
             },
-            ("skip", args) => {
-                if let Some((name2, [recv2, args2 @ ..], _span2)) = method_call(recv) {
-                    if let ("cloned", []) = (name2, args2) {
-                        iter_overeager_cloned::check(cx, expr, recv2, name, args);
-                    }
-                }
-            },
             ("splitn" | "rsplitn", [count_arg, pat_arg]) => {
                 if let Some((Constant::Int(count), _)) = constant(cx, cx.typeck_results(), count_arg) {
                     suspicious_splitn::check(cx, name, expr, recv, count);
-- 
cgit 1.4.1-3-g733a5


From 36396c6b972714bda6c25ab14a7a954136b8654f Mon Sep 17 00:00:00 2001
From: Piotr Mikulski <piotr@near.org>
Date: Sun, 16 Jan 2022 10:32:45 -0800
Subject: Fix tests

---
 clippy_lints/src/methods/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index f9d8e03a499..d75ab0c4b1b 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -2319,7 +2319,7 @@ fn check_methods<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, msrv: Optio
             ("is_file", []) => filetype_is_file::check(cx, expr, recv),
             ("is_none", []) => check_is_some_is_none(cx, expr, recv, false),
             ("is_some", []) => check_is_some_is_none(cx, expr, recv, true),
-            ("last" | "skip", args @ []) => {
+            ("last", args @ []) | ("skip", args @ [_]) => {
                 if let Some((name2, [recv2, args2 @ ..], _span2)) = method_call(recv) {
                     if let ("cloned", []) = (name2, args2) {
                         iter_overeager_cloned::check(cx, expr, recv2, name, args);
-- 
cgit 1.4.1-3-g733a5


From 5b6ec8c57d82be1697f2be4dffbb8f12cf376ff2 Mon Sep 17 00:00:00 2001
From: Marek Downar <marek.downar@evomedia.pl>
Date: Sun, 16 Jan 2022 20:27:00 +0100
Subject: #8214 cmp_owned suggestion flips the comparison

---
 clippy_lints/src/misc.rs                  | 21 +++++++++++++++++++--
 tests/ui/cmp_owned/comparison_flip.fixed  | 29 +++++++++++++++++++++++++++++
 tests/ui/cmp_owned/comparison_flip.rs     | 29 +++++++++++++++++++++++++++++
 tests/ui/cmp_owned/comparison_flip.stderr | 18 ++++++++++++++++++
 4 files changed, 95 insertions(+), 2 deletions(-)
 create mode 100644 tests/ui/cmp_owned/comparison_flip.fixed
 create mode 100644 tests/ui/cmp_owned/comparison_flip.rs
 create mode 100644 tests/ui/cmp_owned/comparison_flip.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/misc.rs b/clippy_lints/src/misc.rs
index 21b3f81d5d9..8db71d1e967 100644
--- a/clippy_lints/src/misc.rs
+++ b/clippy_lints/src/misc.rs
@@ -548,6 +548,7 @@ fn is_array(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
     matches!(&cx.typeck_results().expr_ty(expr).peel_refs().kind(), ty::Array(_, _))
 }
 
+#[allow(clippy::too_many_lines)]
 fn check_to_owned(cx: &LateContext<'_>, expr: &Expr<'_>, other: &Expr<'_>, left: bool) {
     #[derive(Default)]
     struct EqImpl {
@@ -644,10 +645,26 @@ fn check_to_owned(cx: &LateContext<'_>, expr: &Expr<'_>, other: &Expr<'_>, left:
                 hint = expr_snip;
             } else {
                 span = expr.span.to(other.span);
+
+                let cmp_span = if other.span < expr.span {
+                    other.span.between(expr.span)
+                } else {
+                    expr.span.between(other.span)
+                };
                 if eq_impl.ty_eq_other {
-                    hint = format!("{} == {}", expr_snip, snippet(cx, other.span, ".."));
+                    hint = format!(
+                        "{}{}{}",
+                        expr_snip,
+                        snippet(cx, cmp_span, ".."),
+                        snippet(cx, other.span, "..")
+                    );
                 } else {
-                    hint = format!("{} == {}", snippet(cx, other.span, ".."), expr_snip);
+                    hint = format!(
+                        "{}{}{}",
+                        snippet(cx, other.span, ".."),
+                        snippet(cx, cmp_span, ".."),
+                        expr_snip
+                    );
                 }
             }
 
diff --git a/tests/ui/cmp_owned/comparison_flip.fixed b/tests/ui/cmp_owned/comparison_flip.fixed
new file mode 100644
index 00000000000..44e41bdd114
--- /dev/null
+++ b/tests/ui/cmp_owned/comparison_flip.fixed
@@ -0,0 +1,29 @@
+// run-rustfix
+
+use std::fmt::{self, Display};
+
+fn main() {
+    let a = Foo;
+
+    if a != "bar" {
+        println!("foo");
+    }
+
+    if a != "bar" {
+        println!("foo");
+    }
+}
+
+struct Foo;
+
+impl Display for Foo {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "foo")
+    }
+}
+
+impl PartialEq<&str> for Foo {
+    fn eq(&self, other: &&str) -> bool {
+        "foo" == *other
+    }
+}
diff --git a/tests/ui/cmp_owned/comparison_flip.rs b/tests/ui/cmp_owned/comparison_flip.rs
new file mode 100644
index 00000000000..662673abb62
--- /dev/null
+++ b/tests/ui/cmp_owned/comparison_flip.rs
@@ -0,0 +1,29 @@
+// run-rustfix
+
+use std::fmt::{self, Display};
+
+fn main() {
+    let a = Foo;
+
+    if a.to_string() != "bar" {
+        println!("foo");
+    }
+
+    if "bar" != a.to_string() {
+        println!("foo");
+    }
+}
+
+struct Foo;
+
+impl Display for Foo {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "foo")
+    }
+}
+
+impl PartialEq<&str> for Foo {
+    fn eq(&self, other: &&str) -> bool {
+        "foo" == *other
+    }
+}
diff --git a/tests/ui/cmp_owned/comparison_flip.stderr b/tests/ui/cmp_owned/comparison_flip.stderr
new file mode 100644
index 00000000000..e4d0d822bb1
--- /dev/null
+++ b/tests/ui/cmp_owned/comparison_flip.stderr
@@ -0,0 +1,18 @@
+error: this creates an owned instance just for comparison
+  --> $DIR/comparison_flip.rs:8:8
+   |
+LL |     if a.to_string() != "bar" {
+   |        ^^^^^^^^^^^^^ help: try: `a`
+   |
+   = note: `-D clippy::cmp-owned` implied by `-D warnings`
+
+error: this creates an owned instance just for comparison
+  --> $DIR/comparison_flip.rs:12:17
+   |
+LL |     if "bar" != a.to_string() {
+   |        ---------^^^^^^^^^^^^^
+   |        |
+   |        help: try: `a != "bar"`
+
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 5461ed670eecedad74c82dd91ba532249d2073fb Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sun, 16 Jan 2022 09:46:02 -0500
Subject: Don't lint `if_same_then_else` with `if let` conditions

---
 clippy_lints/src/copies.rs     | 29 +++++++++++++++++------------
 tests/ui/if_same_then_else2.rs | 17 +++++++++++++++++
 2 files changed, 34 insertions(+), 12 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/copies.rs b/clippy_lints/src/copies.rs
index 73ce656ad15..f44d370a8fd 100644
--- a/clippy_lints/src/copies.rs
+++ b/clippy_lints/src/copies.rs
@@ -183,7 +183,7 @@ impl<'tcx> LateLintPass<'tcx> for CopyAndPaste {
                 lint_same_cond(cx, &conds);
                 lint_same_fns_in_if_cond(cx, &conds);
                 // Block duplication
-                lint_same_then_else(cx, &blocks, conds.len() == blocks.len(), expr);
+                lint_same_then_else(cx, &conds, &blocks, conds.len() == blocks.len(), expr);
             }
         }
     }
@@ -192,6 +192,7 @@ impl<'tcx> LateLintPass<'tcx> for CopyAndPaste {
 /// Implementation of `BRANCHES_SHARING_CODE` and `IF_SAME_THEN_ELSE` if the blocks are equal.
 fn lint_same_then_else<'tcx>(
     cx: &LateContext<'tcx>,
+    conds: &[&'tcx Expr<'_>],
     blocks: &[&Block<'tcx>],
     has_conditional_else: bool,
     expr: &'tcx Expr<'_>,
@@ -204,7 +205,7 @@ fn lint_same_then_else<'tcx>(
     // Check if each block has shared code
     let has_expr = blocks[0].expr.is_some();
 
-    let (start_eq, mut end_eq, expr_eq) = if let Some(block_eq) = scan_block_for_eq(cx, blocks) {
+    let (start_eq, mut end_eq, expr_eq) = if let Some(block_eq) = scan_block_for_eq(cx, conds, blocks) {
         (block_eq.start_eq, block_eq.end_eq, block_eq.expr_eq)
     } else {
         return;
@@ -316,14 +317,14 @@ struct BlockEqual {
 
 /// This function can also trigger the `IF_SAME_THEN_ELSE` in which case it'll return `None` to
 /// abort any further processing and avoid duplicate lint triggers.
-fn scan_block_for_eq(cx: &LateContext<'_>, blocks: &[&Block<'_>]) -> Option<BlockEqual> {
+fn scan_block_for_eq(cx: &LateContext<'_>, conds: &[&Expr<'_>], blocks: &[&Block<'_>]) -> Option<BlockEqual> {
     let mut start_eq = usize::MAX;
     let mut end_eq = usize::MAX;
     let mut expr_eq = true;
-    let mut iter = blocks.windows(2);
-    while let Some(&[win0, win1]) = iter.next() {
-        let l_stmts = win0.stmts;
-        let r_stmts = win1.stmts;
+    let mut iter = blocks.windows(2).enumerate();
+    while let Some((i, &[block0, block1])) = iter.next() {
+        let l_stmts = block0.stmts;
+        let r_stmts = block1.stmts;
 
         // `SpanlessEq` now keeps track of the locals and is therefore context sensitive clippy#6752.
         // The comparison therefore needs to be done in a way that builds the correct context.
@@ -340,22 +341,26 @@ fn scan_block_for_eq(cx: &LateContext<'_>, blocks: &[&Block<'_>]) -> Option<Bloc
             it1.zip(it2)
                 .fold(0, |acc, (l, r)| if evaluator.eq_stmt(l, r) { acc + 1 } else { 0 })
         };
-        let block_expr_eq = both(&win0.expr, &win1.expr, |l, r| evaluator.eq_expr(l, r));
+        let block_expr_eq = both(&block0.expr, &block1.expr, |l, r| evaluator.eq_expr(l, r));
 
         // IF_SAME_THEN_ELSE
         if_chain! {
             if block_expr_eq;
             if l_stmts.len() == r_stmts.len();
             if l_stmts.len() == current_start_eq;
-            if !is_lint_allowed(cx, IF_SAME_THEN_ELSE, win0.hir_id);
-            if !is_lint_allowed(cx, IF_SAME_THEN_ELSE, win1.hir_id);
+            // `conds` may have one last item than `blocks`.
+            // Any `i` from `blocks.windows(2)` will exist in `conds`, but `i+1` may not exist on the last iteration.
+            if !matches!(conds[i].kind, ExprKind::Let(..));
+            if !matches!(conds.get(i + 1).map(|e| &e.kind), Some(ExprKind::Let(..)));
+            if !is_lint_allowed(cx, IF_SAME_THEN_ELSE, block0.hir_id);
+            if !is_lint_allowed(cx, IF_SAME_THEN_ELSE, block1.hir_id);
             then {
                 span_lint_and_note(
                     cx,
                     IF_SAME_THEN_ELSE,
-                    win0.span,
+                    block0.span,
                     "this `if` has identical blocks",
-                    Some(win1.span),
+                    Some(block1.span),
                     "same as this",
                 );
 
diff --git a/tests/ui/if_same_then_else2.rs b/tests/ui/if_same_then_else2.rs
index 69189d9e0c0..0016009a02f 100644
--- a/tests/ui/if_same_then_else2.rs
+++ b/tests/ui/if_same_then_else2.rs
@@ -138,6 +138,23 @@ fn if_same_then_else2() -> Result<&'static str, ()> {
         let (y, x) = (1, 2);
         return Ok(&foo[x..y]);
     }
+
+    // Issue #7579
+    let _ = if let Some(0) = None { 0 } else { 0 };
+
+    if true {
+        return Err(());
+    } else if let Some(0) = None {
+        return Err(());
+    }
+
+    let _ = if let Some(0) = None {
+        0
+    } else if let Some(1) = None {
+        0
+    } else {
+        0
+    };
 }
 
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 69d78ceeba0627d650d6058a456fdfb2df0eaa7f Mon Sep 17 00:00:00 2001
From: Marek Downar <marek.downar@evomedia.pl>
Date: Mon, 17 Jan 2022 12:34:03 +0100
Subject: removing unsafe from test fn's && renaming shrink to sugg_span

---
 clippy_lints/src/methods/or_fun_call.rs | 6 +++---
 tests/ui/or_fun_call.fixed              | 8 ++++----
 tests/ui/or_fun_call.rs                 | 8 ++++----
 3 files changed, 11 insertions(+), 11 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/or_fun_call.rs b/clippy_lints/src/methods/or_fun_call.rs
index c35a2e57a66..448dc4e6147 100644
--- a/clippy_lints/src/methods/or_fun_call.rs
+++ b/clippy_lints/src/methods/or_fun_call.rs
@@ -56,7 +56,7 @@ pub(super) fn check<'tcx>(
             then {
                 let mut applicability = Applicability::MachineApplicable;
                 let hint = "unwrap_or_default()";
-                let mut shrink = span;
+                let mut sugg_span = span;
 
                 let mut sugg: String = format!(
                     "{}.{}",
@@ -65,14 +65,14 @@ pub(super) fn check<'tcx>(
                 );
 
                 if sugg.lines().count() > MAX_SUGGESTION_HIGHLIGHT_LINES {
-                    shrink = method_span.with_hi(span.hi());
+                    sugg_span = method_span.with_hi(span.hi());
                     sugg = hint.to_string();
                 }
 
                 span_lint_and_sugg(
                     cx,
                     OR_FUN_CALL,
-                    shrink,
+                    sugg_span,
                     &format!("use of `{}` followed by a call to `{}`", name, path),
                     "try this",
                     sugg,
diff --git a/tests/ui/or_fun_call.fixed b/tests/ui/or_fun_call.fixed
index fe8f5c9fc62..3208048e0d5 100644
--- a/tests/ui/or_fun_call.fixed
+++ b/tests/ui/or_fun_call.fixed
@@ -177,7 +177,7 @@ mod issue6675 {
 }
 
 mod issue8239 {
-    unsafe fn more_than_max_suggestion_highest_lines_0() {
+    fn more_than_max_suggestion_highest_lines_0() {
         let frames = Vec::new();
         frames
             .iter()
@@ -189,7 +189,7 @@ mod issue8239 {
             .unwrap_or_default();
     }
 
-    unsafe fn more_to_max_suggestion_highest_lines_1() {
+    fn more_to_max_suggestion_highest_lines_1() {
         let frames = Vec::new();
         let iter = frames.iter();
         iter.map(|f: &String| f.to_lowercase())
@@ -202,7 +202,7 @@ mod issue8239 {
             .unwrap_or_default();
     }
 
-    unsafe fn equal_to_max_suggestion_highest_lines() {
+    fn equal_to_max_suggestion_highest_lines() {
         let frames = Vec::new();
         let iter = frames.iter();
         iter.map(|f: &String| f.to_lowercase())
@@ -213,7 +213,7 @@ mod issue8239 {
             }).unwrap_or_default();
     }
 
-    unsafe fn less_than_max_suggestion_highest_lines() {
+    fn less_than_max_suggestion_highest_lines() {
         let frames = Vec::new();
         let iter = frames.iter();
         let map = iter.map(|f: &String| f.to_lowercase());
diff --git a/tests/ui/or_fun_call.rs b/tests/ui/or_fun_call.rs
index a702d9dadd4..57ab5f03ee2 100644
--- a/tests/ui/or_fun_call.rs
+++ b/tests/ui/or_fun_call.rs
@@ -177,7 +177,7 @@ mod issue6675 {
 }
 
 mod issue8239 {
-    unsafe fn more_than_max_suggestion_highest_lines_0() {
+    fn more_than_max_suggestion_highest_lines_0() {
         let frames = Vec::new();
         frames
             .iter()
@@ -189,7 +189,7 @@ mod issue8239 {
             .unwrap_or(String::new());
     }
 
-    unsafe fn more_to_max_suggestion_highest_lines_1() {
+    fn more_to_max_suggestion_highest_lines_1() {
         let frames = Vec::new();
         let iter = frames.iter();
         iter.map(|f: &String| f.to_lowercase())
@@ -202,7 +202,7 @@ mod issue8239 {
             .unwrap_or(String::new());
     }
 
-    unsafe fn equal_to_max_suggestion_highest_lines() {
+    fn equal_to_max_suggestion_highest_lines() {
         let frames = Vec::new();
         let iter = frames.iter();
         iter.map(|f: &String| f.to_lowercase())
@@ -214,7 +214,7 @@ mod issue8239 {
             .unwrap_or(String::new());
     }
 
-    unsafe fn less_than_max_suggestion_highest_lines() {
+    fn less_than_max_suggestion_highest_lines() {
         let frames = Vec::new();
         let iter = frames.iter();
         let map = iter.map(|f: &String| f.to_lowercase());
-- 
cgit 1.4.1-3-g733a5


From 2d3eb5082a96f20dfeb25e8b3d0a8aa5a084e486 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Mon, 17 Jan 2022 12:25:38 +0100
Subject: Move `return_self_not_must_use` to `pedantic`

---
 clippy_lints/src/lib.register_all.rs         | 1 -
 clippy_lints/src/lib.register_pedantic.rs    | 1 +
 clippy_lints/src/lib.register_suspicious.rs  | 1 -
 clippy_lints/src/return_self_not_must_use.rs | 2 +-
 tests/ui/return_self_not_must_use.rs         | 1 +
 tests/ui/return_self_not_must_use.stderr     | 6 +++---
 6 files changed, 6 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index eba51099496..87fd7f99748 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -250,7 +250,6 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(reference::REF_IN_DEREF),
     LintId::of(regex::INVALID_REGEX),
     LintId::of(repeat_once::REPEAT_ONCE),
-    LintId::of(return_self_not_must_use::RETURN_SELF_NOT_MUST_USE),
     LintId::of(returns::LET_AND_RETURN),
     LintId::of(returns::NEEDLESS_RETURN),
     LintId::of(self_assignment::SELF_ASSIGNMENT),
diff --git a/clippy_lints/src/lib.register_pedantic.rs b/clippy_lints/src/lib.register_pedantic.rs
index 1744b7c8250..1292675f4a9 100644
--- a/clippy_lints/src/lib.register_pedantic.rs
+++ b/clippy_lints/src/lib.register_pedantic.rs
@@ -81,6 +81,7 @@ store.register_group(true, "clippy::pedantic", Some("clippy_pedantic"), vec![
     LintId::of(ranges::RANGE_PLUS_ONE),
     LintId::of(redundant_else::REDUNDANT_ELSE),
     LintId::of(ref_option_ref::REF_OPTION_REF),
+    LintId::of(return_self_not_must_use::RETURN_SELF_NOT_MUST_USE),
     LintId::of(semicolon_if_nothing_returned::SEMICOLON_IF_NOTHING_RETURNED),
     LintId::of(strings::STRING_ADD_ASSIGN),
     LintId::of(trait_bounds::TRAIT_DUPLICATION_IN_BOUNDS),
diff --git a/clippy_lints/src/lib.register_suspicious.rs b/clippy_lints/src/lib.register_suspicious.rs
index 8594338ffa5..10f8ae4b7f7 100644
--- a/clippy_lints/src/lib.register_suspicious.rs
+++ b/clippy_lints/src/lib.register_suspicious.rs
@@ -16,7 +16,6 @@ store.register_group(true, "clippy::suspicious", Some("clippy_suspicious"), vec!
     LintId::of(methods::SUSPICIOUS_MAP),
     LintId::of(mut_key::MUTABLE_KEY_TYPE),
     LintId::of(octal_escapes::OCTAL_ESCAPES),
-    LintId::of(return_self_not_must_use::RETURN_SELF_NOT_MUST_USE),
     LintId::of(suspicious_trait_impl::SUSPICIOUS_ARITHMETIC_IMPL),
     LintId::of(suspicious_trait_impl::SUSPICIOUS_OP_ASSIGN_IMPL),
 ])
diff --git a/clippy_lints/src/return_self_not_must_use.rs b/clippy_lints/src/return_self_not_must_use.rs
index 5dafd08cf3b..79f104eac0b 100644
--- a/clippy_lints/src/return_self_not_must_use.rs
+++ b/clippy_lints/src/return_self_not_must_use.rs
@@ -60,7 +60,7 @@ declare_clippy_lint! {
     /// ```
     #[clippy::version = "1.59.0"]
     pub RETURN_SELF_NOT_MUST_USE,
-    suspicious,
+    pedantic,
     "missing `#[must_use]` annotation on a method returning `Self`"
 }
 
diff --git a/tests/ui/return_self_not_must_use.rs b/tests/ui/return_self_not_must_use.rs
index 7dd5742dae9..9b33ad6d3f6 100644
--- a/tests/ui/return_self_not_must_use.rs
+++ b/tests/ui/return_self_not_must_use.rs
@@ -1,4 +1,5 @@
 #![crate_type = "lib"]
+#![warn(clippy::return_self_not_must_use)]
 
 #[derive(Clone)]
 pub struct Bar;
diff --git a/tests/ui/return_self_not_must_use.stderr b/tests/ui/return_self_not_must_use.stderr
index 8af10cb65c4..94be87dfa31 100644
--- a/tests/ui/return_self_not_must_use.stderr
+++ b/tests/ui/return_self_not_must_use.stderr
@@ -1,5 +1,5 @@
 error: missing `#[must_use]` attribute on a method returning `Self`
-  --> $DIR/return_self_not_must_use.rs:7:5
+  --> $DIR/return_self_not_must_use.rs:8:5
    |
 LL |     fn what(&self) -> Self;
    |     ^^^^^^^^^^^^^^^^^^^^^^^
@@ -8,7 +8,7 @@ LL |     fn what(&self) -> Self;
    = help: consider adding the `#[must_use]` attribute to the method or directly to the `Self` type
 
 error: missing `#[must_use]` attribute on a method returning `Self`
-  --> $DIR/return_self_not_must_use.rs:17:5
+  --> $DIR/return_self_not_must_use.rs:18:5
    |
 LL | /     pub fn foo(&self) -> Self {
 LL | |         Self
@@ -18,7 +18,7 @@ LL | |     }
    = help: consider adding the `#[must_use]` attribute to the method or directly to the `Self` type
 
 error: missing `#[must_use]` attribute on a method returning `Self`
-  --> $DIR/return_self_not_must_use.rs:20:5
+  --> $DIR/return_self_not_must_use.rs:21:5
    |
 LL | /     pub fn bar(self) -> Self {
 LL | |         self
-- 
cgit 1.4.1-3-g733a5


From d9f401a53a4eb6231c38323fb283d9a593f6c438 Mon Sep 17 00:00:00 2001
From: Noah Lev <camelidcamel@gmail.com>
Date: Tue, 18 Jan 2022 16:17:43 -0800
Subject: Remove unnecessary `Symbol` stringification

This should (slightly) improve performance and enhance code quality.
---
 clippy_lints/src/matches.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index 60dd957db01..017e4a33980 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -30,7 +30,7 @@ use rustc_middle::ty::{self, Ty, TyS, VariantDef};
 use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::{Span, Spanned};
-use rustc_span::sym;
+use rustc_span::{sym, symbol::kw};
 use std::cmp::Ordering;
 use std::collections::hash_map::Entry;
 
@@ -961,13 +961,13 @@ fn check_wild_err_arm<'tcx>(cx: &LateContext<'tcx>, ex: &Expr<'tcx>, arms: &[Arm
                 let path_str = rustc_hir_pretty::to_string(rustc_hir_pretty::NO_ANN, |s| s.print_qpath(path, false));
                 if path_str == "Err" {
                     let mut matching_wild = inner.iter().any(is_wild);
-                    let mut ident_bind_name = String::from("_");
+                    let mut ident_bind_name = kw::Underscore;
                     if !matching_wild {
                         // Looking for unused bindings (i.e.: `_e`)
                         for pat in inner.iter() {
                             if let PatKind::Binding(_, id, ident, None) = pat.kind {
                                 if ident.as_str().starts_with('_') && !is_local_used(cx, arm.body, id) {
-                                    ident_bind_name = ident.name.as_str().to_string();
+                                    ident_bind_name = ident.name;
                                     matching_wild = true;
                                 }
                             }
@@ -982,7 +982,7 @@ fn check_wild_err_arm<'tcx>(cx: &LateContext<'tcx>, ex: &Expr<'tcx>, arms: &[Arm
                             span_lint_and_note(cx,
                                 MATCH_WILD_ERR_ARM,
                                 arm.pat.span,
-                                &format!("`Err({})` matches all errors", &ident_bind_name),
+                                &format!("`Err({})` matches all errors", ident_bind_name),
                                 None,
                                 "match each error separately or use the error output, or use `.except(msg)` if the error case is unreachable",
                             );
-- 
cgit 1.4.1-3-g733a5


From 4c1549ecc8111cc6d3e42b309e3e71fe78d16958 Mon Sep 17 00:00:00 2001
From: dswij <dswijj@gmail.com>
Date: Thu, 20 Jan 2022 13:38:48 +0800
Subject: `trait_duplication_in_bounds` checks path segments for trait items

---
 clippy_lints/src/trait_bounds.rs            | 58 +++++++++++++++--------------
 tests/ui/trait_duplication_in_bounds.rs     | 22 +++++++++++
 tests/ui/trait_duplication_in_bounds.stderr | 24 ++++++++----
 3 files changed, 68 insertions(+), 36 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/trait_bounds.rs b/clippy_lints/src/trait_bounds.rs
index 6369aafe3f9..5257f5302cd 100644
--- a/clippy_lints/src/trait_bounds.rs
+++ b/clippy_lints/src/trait_bounds.rs
@@ -3,7 +3,7 @@ use clippy_utils::source::{snippet, snippet_with_applicability};
 use clippy_utils::{SpanlessEq, SpanlessHash};
 use core::hash::{Hash, Hasher};
 use if_chain::if_chain;
-use rustc_data_structures::fx::{FxHashMap, FxHashSet};
+use rustc_data_structures::fx::FxHashMap;
 use rustc_data_structures::unhash::UnhashMap;
 use rustc_errors::Applicability;
 use rustc_hir::def::Res;
@@ -91,7 +91,7 @@ impl<'tcx> LateLintPass<'tcx> for TraitBounds {
 
     fn check_trait_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx TraitItem<'tcx>) {
         let Generics { where_clause, .. } = &item.generics;
-        let mut self_bounds_set = FxHashSet::default();
+        let mut self_bounds_map = FxHashMap::default();
 
         for predicate in where_clause.predicates {
             if_chain! {
@@ -108,27 +108,29 @@ impl<'tcx> LateLintPass<'tcx> for TraitBounds {
                         )
                     ) = cx.tcx.hir().get_if_local(*def_id);
                 then {
-                    if self_bounds_set.is_empty() {
+                    if self_bounds_map.is_empty() {
                         for bound in self_bounds.iter() {
-                            let Some((self_res, _)) = get_trait_res_span_from_bound(bound) else { continue };
-                            self_bounds_set.insert(self_res);
+                            let Some((self_res, self_segments, _)) = get_trait_info_from_bound(bound) else { continue };
+                            self_bounds_map.insert(self_res, self_segments);
                         }
                     }
 
                     bound_predicate
                         .bounds
                         .iter()
-                        .filter_map(get_trait_res_span_from_bound)
-                        .for_each(|(trait_item_res, span)| {
-                            if self_bounds_set.get(&trait_item_res).is_some() {
-                                span_lint_and_help(
-                                    cx,
-                                    TRAIT_DUPLICATION_IN_BOUNDS,
-                                    span,
-                                    "this trait bound is already specified in trait declaration",
-                                    None,
-                                    "consider removing this trait bound",
-                                );
+                        .filter_map(get_trait_info_from_bound)
+                        .for_each(|(trait_item_res, trait_item_segments, span)| {
+                            if let Some(self_segments) = self_bounds_map.get(&trait_item_res) {
+                                if SpanlessEq::new(cx).eq_path_segments(self_segments, trait_item_segments) {
+                                    span_lint_and_help(
+                                        cx,
+                                        TRAIT_DUPLICATION_IN_BOUNDS,
+                                        span,
+                                        "this trait bound is already specified in trait declaration",
+                                        None,
+                                        "consider removing this trait bound",
+                                    );
+                                }
                             }
                         });
                 }
@@ -137,14 +139,6 @@ impl<'tcx> LateLintPass<'tcx> for TraitBounds {
     }
 }
 
-fn get_trait_res_span_from_bound(bound: &GenericBound<'_>) -> Option<(Res, Span)> {
-    if let GenericBound::Trait(t, _) = bound {
-        Some((t.trait_ref.path.res, t.span))
-    } else {
-        None
-    }
-}
-
 impl TraitBounds {
     fn check_type_repetition<'tcx>(self, cx: &LateContext<'tcx>, gen: &'tcx Generics<'_>) {
         struct SpanlessTy<'cx, 'tcx> {
@@ -231,7 +225,7 @@ fn check_trait_bound_duplication(cx: &LateContext<'_>, gen: &'_ Generics<'_>) {
             let res = param
                 .bounds
                 .iter()
-                .filter_map(get_trait_res_span_from_bound)
+                .filter_map(get_trait_info_from_bound)
                 .collect::<Vec<_>>();
             map.insert(*ident, res);
         }
@@ -245,10 +239,10 @@ fn check_trait_bound_duplication(cx: &LateContext<'_>, gen: &'_ Generics<'_>) {
             if let Some(segment) = segments.first();
             if let Some(trait_resolutions_direct) = map.get(&segment.ident);
             then {
-                for (res_where, _) in bound_predicate.bounds.iter().filter_map(get_trait_res_span_from_bound) {
-                    if let Some((_, span_direct)) = trait_resolutions_direct
+                for (res_where, _,  _) in bound_predicate.bounds.iter().filter_map(get_trait_info_from_bound) {
+                    if let Some((_, _, span_direct)) = trait_resolutions_direct
                                                 .iter()
-                                                .find(|(res_direct, _)| *res_direct == res_where) {
+                                                .find(|(res_direct, _, _)| *res_direct == res_where) {
                         span_lint_and_help(
                             cx,
                             TRAIT_DUPLICATION_IN_BOUNDS,
@@ -263,3 +257,11 @@ fn check_trait_bound_duplication(cx: &LateContext<'_>, gen: &'_ Generics<'_>) {
         }
     }
 }
+
+fn get_trait_info_from_bound<'a>(bound: &'a GenericBound<'_>) -> Option<(Res, &'a [PathSegment<'a>], Span)> {
+    if let GenericBound::Trait(t, _) = bound {
+        Some((t.trait_ref.path.res, t.trait_ref.path.segments, t.span))
+    } else {
+        None
+    }
+}
diff --git a/tests/ui/trait_duplication_in_bounds.rs b/tests/ui/trait_duplication_in_bounds.rs
index 2edb202892a..21de19a2601 100644
--- a/tests/ui/trait_duplication_in_bounds.rs
+++ b/tests/ui/trait_duplication_in_bounds.rs
@@ -1,5 +1,6 @@
 #![deny(clippy::trait_duplication_in_bounds)]
 
+use std::collections::BTreeMap;
 use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Sub, SubAssign};
 
 fn bad_foo<T: Clone + Default, Z: Copy>(arg0: T, arg1: Z)
@@ -73,4 +74,25 @@ impl U for Life {
     fn f() {}
 }
 
+// should not warn
+trait Iter: Iterator {
+    fn into_group_btreemap<K, V>(self) -> BTreeMap<K, Vec<V>>
+    where
+        Self: Iterator<Item = (K, V)> + Sized,
+        K: Ord + Eq,
+    {
+        unimplemented!();
+    }
+}
+
+struct Foo {}
+
+trait FooIter: Iterator<Item = Foo> {
+    fn bar()
+    where
+        Self: Iterator<Item = Foo>,
+    {
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/trait_duplication_in_bounds.stderr b/tests/ui/trait_duplication_in_bounds.stderr
index e0c7a7ec618..6f8c8e47dfb 100644
--- a/tests/ui/trait_duplication_in_bounds.stderr
+++ b/tests/ui/trait_duplication_in_bounds.stderr
@@ -1,5 +1,5 @@
 error: this trait bound is already specified in the where clause
-  --> $DIR/trait_duplication_in_bounds.rs:5:15
+  --> $DIR/trait_duplication_in_bounds.rs:6:15
    |
 LL | fn bad_foo<T: Clone + Default, Z: Copy>(arg0: T, arg1: Z)
    |               ^^^^^
@@ -12,7 +12,7 @@ LL | #![deny(clippy::trait_duplication_in_bounds)]
    = help: consider removing this trait bound
 
 error: this trait bound is already specified in the where clause
-  --> $DIR/trait_duplication_in_bounds.rs:5:23
+  --> $DIR/trait_duplication_in_bounds.rs:6:23
    |
 LL | fn bad_foo<T: Clone + Default, Z: Copy>(arg0: T, arg1: Z)
    |                       ^^^^^^^
@@ -20,7 +20,7 @@ LL | fn bad_foo<T: Clone + Default, Z: Copy>(arg0: T, arg1: Z)
    = help: consider removing this trait bound
 
 error: this trait bound is already specified in trait declaration
-  --> $DIR/trait_duplication_in_bounds.rs:34:15
+  --> $DIR/trait_duplication_in_bounds.rs:35:15
    |
 LL |         Self: Default;
    |               ^^^^^^^
@@ -28,7 +28,7 @@ LL |         Self: Default;
    = help: consider removing this trait bound
 
 error: this trait bound is already specified in trait declaration
-  --> $DIR/trait_duplication_in_bounds.rs:48:15
+  --> $DIR/trait_duplication_in_bounds.rs:49:15
    |
 LL |         Self: Default + Clone;
    |               ^^^^^^^
@@ -36,7 +36,7 @@ LL |         Self: Default + Clone;
    = help: consider removing this trait bound
 
 error: this trait bound is already specified in trait declaration
-  --> $DIR/trait_duplication_in_bounds.rs:54:15
+  --> $DIR/trait_duplication_in_bounds.rs:55:15
    |
 LL |         Self: Default + Clone;
    |               ^^^^^^^
@@ -44,7 +44,7 @@ LL |         Self: Default + Clone;
    = help: consider removing this trait bound
 
 error: this trait bound is already specified in trait declaration
-  --> $DIR/trait_duplication_in_bounds.rs:54:25
+  --> $DIR/trait_duplication_in_bounds.rs:55:25
    |
 LL |         Self: Default + Clone;
    |                         ^^^^^
@@ -52,12 +52,20 @@ LL |         Self: Default + Clone;
    = help: consider removing this trait bound
 
 error: this trait bound is already specified in trait declaration
-  --> $DIR/trait_duplication_in_bounds.rs:57:15
+  --> $DIR/trait_duplication_in_bounds.rs:58:15
    |
 LL |         Self: Default;
    |               ^^^^^^^
    |
    = help: consider removing this trait bound
 
-error: aborting due to 7 previous errors
+error: this trait bound is already specified in trait declaration
+  --> $DIR/trait_duplication_in_bounds.rs:93:15
+   |
+LL |         Self: Iterator<Item = Foo>,
+   |               ^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider removing this trait bound
+
+error: aborting due to 8 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From a5a07e503f524a0e8b92938301857b3007579115 Mon Sep 17 00:00:00 2001
From: Georgy Komarov <jubnzv@gmail.com>
Date: Thu, 20 Jan 2022 14:50:14 +0300
Subject: single_match: Don't lint non-exhaustive matches; support tuples

This commit changes the behavior of `single_match` lint.

After that, we won't lint non-exhaustive matches like this:

```rust
match Some(v) {
    Some(a) => println!("${:?}", a),
    None => {},
}
```

The rationale is that, because the type of `a` could be changed, so the
user can get non-exhaustive match after applying the suggested lint (see
https://github.com/rust-lang/rust-clippy/issues/8282#issuecomment-1013566068
for context).

We also will lint `match` constructions with tuples. When we see the
tuples on the both arms, we will check them both at the same time, and
if they form exhaustive match, we could display the warning.

Closes #8282
---
 clippy_lints/src/matches.rs       | 145 +++++++++++++++++++++++++++++++++-----
 tests/ui/single_match.rs          |  50 +++++++++++++
 tests/ui/single_match.stderr      |  38 +++++++---
 tests/ui/single_match_else.stderr |  42 +----------
 4 files changed, 206 insertions(+), 69 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index 60dd957db01..9da05245069 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -5,7 +5,7 @@ use clippy_utils::diagnostics::{
 use clippy_utils::macros::{is_panic, root_macro_call};
 use clippy_utils::source::{expr_block, indent_of, snippet, snippet_block, snippet_opt, snippet_with_applicability};
 use clippy_utils::sugg::Sugg;
-use clippy_utils::ty::{implements_trait, is_type_diagnostic_item, match_type, peel_mid_ty_refs};
+use clippy_utils::ty::{implements_trait, is_type_diagnostic_item, peel_mid_ty_refs};
 use clippy_utils::visitors::is_local_used;
 use clippy_utils::{
     get_parent_expr, is_lang_ctor, is_lint_allowed, is_refutable, is_unit_expr, is_wild, meets_msrv, msrvs,
@@ -31,7 +31,7 @@ use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::{Span, Spanned};
 use rustc_span::sym;
-use std::cmp::Ordering;
+use std::cmp::{max, Ordering};
 use std::collections::hash_map::Entry;
 
 declare_clippy_lint! {
@@ -741,7 +741,7 @@ fn check_single_match(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>], exp
         let ty = cx.typeck_results().expr_ty(ex);
         if *ty.kind() != ty::Bool || is_lint_allowed(cx, MATCH_BOOL, ex.hir_id) {
             check_single_match_single_pattern(cx, ex, arms, expr, els);
-            check_single_match_opt_like(cx, ex, arms, expr, ty, els);
+            check_single_match_opt_like(cx, ex, arms, expr, els);
         }
     }
 }
@@ -835,7 +835,6 @@ fn check_single_match_opt_like(
     ex: &Expr<'_>,
     arms: &[Arm<'_>],
     expr: &Expr<'_>,
-    ty: Ty<'_>,
     els: Option<&Expr<'_>>,
 ) {
     // list of candidate `Enum`s we know will never get any more members
@@ -849,25 +848,135 @@ fn check_single_match_opt_like(
         (&paths::RESULT, "Ok"),
     ];
 
-    let path = match arms[1].pat.kind {
-        PatKind::TupleStruct(ref path, inner, _) => {
-            // Contains any non wildcard patterns (e.g., `Err(err)`)?
-            if !inner.iter().all(is_wild) {
-                return;
+    // We want to suggest to exclude an arm that contains only wildcards or forms the ehaustive
+    // match with the second branch.
+    if !contains_only_wilds(arms[1].pat) && !form_exhaustive_tuples(arms[0].pat, arms[1].pat) {
+        return;
+    }
+
+    let mut paths = Vec::new();
+    if !collect_pat_paths(&mut paths, arms[1].pat) {
+        return;
+    }
+
+    let in_candidate_enum = |path: &String| -> bool {
+        for &(_, pat_path) in candidates {
+            if path == pat_path {
+                return true;
+            }
+        }
+        false
+    };
+    if paths.iter().all(in_candidate_enum) {
+        report_single_match_single_pattern(cx, ex, arms, expr, els);
+    }
+}
+
+/// Collects paths from the given paths. Returns true if the given pattern could be simplified,
+/// false otherwise.
+fn collect_pat_paths(acc: &mut Vec<String>, pat: &Pat<'_>) -> bool {
+    match pat.kind {
+        PatKind::Wild => true,
+        PatKind::Tuple(inner, _) => {
+            for p in inner {
+                if !collect_pat_paths(acc, p) {
+                    return false;
+                }
             }
-            rustc_hir_pretty::to_string(rustc_hir_pretty::NO_ANN, |s| s.print_qpath(path, false))
+            true
+        },
+        PatKind::TupleStruct(ref path, ..) => {
+            acc.push(rustc_hir_pretty::to_string(rustc_hir_pretty::NO_ANN, |s| {
+                s.print_qpath(path, false);
+            }));
+            true
+        },
+        PatKind::Binding(BindingAnnotation::Unannotated, .., ident, None) => {
+            acc.push(ident.to_string());
+            true
         },
-        PatKind::Binding(BindingAnnotation::Unannotated, .., ident, None) => ident.to_string(),
         PatKind::Path(ref path) => {
-            rustc_hir_pretty::to_string(rustc_hir_pretty::NO_ANN, |s| s.print_qpath(path, false))
+            acc.push(rustc_hir_pretty::to_string(rustc_hir_pretty::NO_ANN, |s| {
+                s.print_qpath(path, false);
+            }));
+            true
         },
-        _ => return,
-    };
+        _ => false,
+    }
+}
 
-    for &(ty_path, pat_path) in candidates {
-        if path == *pat_path && match_type(cx, ty, ty_path) {
-            report_single_match_single_pattern(cx, ex, arms, expr, els);
-        }
+/// Returns true if the given arm of pattern matching contains wildcard patterns.
+fn contains_only_wilds(pat: &Pat<'_>) -> bool {
+    match pat.kind {
+        PatKind::Wild => true,
+        PatKind::Tuple(inner, _) | PatKind::TupleStruct(_, inner, ..) => inner.iter().all(contains_only_wilds),
+        _ => false,
+    }
+}
+
+/// Returns true if the given patterns form the tuples that exhaustively matches all possible
+/// parameters.
+///
+/// Here are some examples:
+///
+/// ```
+/// // Doesn't form exhaustive match, because the first arm may contain not only E::V.
+/// match x {
+///     (Some(E::V), _) => todo!(),
+///     (None, _) => {}
+/// }
+///
+/// // Forms exhaustive match, because the patterns cover all possible cases at the same positions.
+/// match x {
+///     (Some(_), _) => todo!(),
+///     (None, _) => {}
+/// }
+/// ```
+fn form_exhaustive_tuples(left: &Pat<'_>, right: &Pat<'_>) -> bool {
+    match (&left.kind, &right.kind) {
+        (PatKind::Wild, _) | (_, PatKind::Wild) => true,
+        (PatKind::Tuple(left_in, left_pos), PatKind::Tuple(right_in, right_pos)) => {
+            // We don't actually know the position and presence of the `..` (dotdot) operator in
+            // the arms, so we need to evaluate the correct offsets here in order to iterate in
+            // both arms at the same time.
+            let len = max(
+                left_in.len() + {
+                    if left_pos.is_some() { 1 } else { 0 }
+                },
+                right_in.len() + {
+                    if right_pos.is_some() { 1 } else { 0 }
+                },
+            );
+            let mut left_pos = left_pos.unwrap_or(usize::MAX);
+            let mut right_pos = right_pos.unwrap_or(usize::MAX);
+            let mut left_span = 0;
+            let mut right_span = 0;
+            for i in 0..len {
+                let mut found_dotdot = false;
+                if i == left_pos {
+                    left_span += 1;
+                    if left_span < len - left_in.len() {
+                        left_pos += 1;
+                    }
+                    found_dotdot = true;
+                }
+                if i == right_pos {
+                    right_span += 1;
+                    if right_span < len - right_in.len() {
+                        right_pos += 1;
+                    }
+                    found_dotdot = true;
+                }
+                if found_dotdot {
+                    continue;
+                }
+                if !contains_only_wilds(&left_in[i - left_span]) && !contains_only_wilds(&right_in[i - right_span]) {
+                    return false;
+                }
+            }
+            true
+        },
+        _ => false,
     }
 }
 
diff --git a/tests/ui/single_match.rs b/tests/ui/single_match.rs
index b1819e08d53..aa93f4d8ca5 100644
--- a/tests/ui/single_match.rs
+++ b/tests/ui/single_match.rs
@@ -145,6 +145,56 @@ fn if_suggestion() {
     };
 }
 
+// See: issue #8282
+fn ranges() {
+    enum E {
+        V,
+    }
+    let x = (Some(E::V), Some(42));
+
+    // don't lint
+    match x {
+        (Some(E::V), _) => {},
+        (None, _) => {},
+    }
+
+    // lint
+    match x {
+        (Some(_), _) => {},
+        (None, _) => {},
+    }
+
+    // lint
+    match x {
+        (Some(E::V), _) => todo!(),
+        (_, _) => {},
+    }
+
+    // lint
+    match (Some(42), Some(E::V), Some(42)) {
+        (.., Some(E::V), _) => {},
+        (..) => {},
+    }
+
+    // don't lint
+    match (Some(E::V), Some(E::V), Some(E::V)) {
+        (.., Some(E::V), _) => {},
+        (.., None, _) => {},
+    }
+
+    // don't lint
+    match (Some(E::V), Some(E::V), Some(E::V)) {
+        (Some(E::V), ..) => {},
+        (None, ..) => {},
+    }
+
+    // don't lint
+    match (Some(E::V), Some(E::V), Some(E::V)) {
+        (_, Some(E::V), ..) => {},
+        (_, None, ..) => {},
+    }
+}
+
 macro_rules! single_match {
     ($num:literal) => {
         match $num {
diff --git a/tests/ui/single_match.stderr b/tests/ui/single_match.stderr
index c261b5111c8..f72ad853fed 100644
--- a/tests/ui/single_match.stderr
+++ b/tests/ui/single_match.stderr
@@ -38,15 +38,6 @@ LL | |         _ => {},
 LL | |     };
    | |_____^ help: try this: `if let (2..=3, 7..=9) = z { dummy() }`
 
-error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
-  --> $DIR/single_match.rs:54:5
-   |
-LL | /     match x {
-LL | |         Some(y) => dummy(),
-LL | |         None => (),
-LL | |     };
-   | |_____^ help: try this: `if let Some(y) = x { dummy() }`
-
 error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
   --> $DIR/single_match.rs:59:5
    |
@@ -128,5 +119,32 @@ LL | |         _ => (),
 LL | |     };
    | |_____^ help: try this: `if let None = x { println!() }`
 
-error: aborting due to 13 previous errors
+error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
+  --> $DIR/single_match.rs:162:5
+   |
+LL | /     match x {
+LL | |         (Some(_), _) => {},
+LL | |         (None, _) => {},
+LL | |     }
+   | |_____^ help: try this: `if let (Some(_), _) = x {}`
+
+error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
+  --> $DIR/single_match.rs:168:5
+   |
+LL | /     match x {
+LL | |         (Some(E::V), _) => todo!(),
+LL | |         (_, _) => {},
+LL | |     }
+   | |_____^ help: try this: `if let (Some(E::V), _) = x { todo!() }`
+
+error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
+  --> $DIR/single_match.rs:174:5
+   |
+LL | /     match (Some(42), Some(E::V), Some(42)) {
+LL | |         (.., Some(E::V), _) => {},
+LL | |         (..) => {},
+LL | |     }
+   | |_____^ help: try this: `if let (.., Some(E::V), _) = (Some(42), Some(E::V), Some(42)) {}`
+
+error: aborting due to 15 previous errors
 
diff --git a/tests/ui/single_match_else.stderr b/tests/ui/single_match_else.stderr
index c61d80a905c..21ea704b62a 100644
--- a/tests/ui/single_match_else.stderr
+++ b/tests/ui/single_match_else.stderr
@@ -19,45 +19,5 @@ LL +         None
 LL +     }
    |
 
-error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
-  --> $DIR/single_match_else.rs:70:5
-   |
-LL | /     match Some(1) {
-LL | |         Some(a) => println!("${:?}", a),
-LL | |         None => {
-LL | |             println!("else block");
-LL | |             return
-LL | |         },
-LL | |     }
-   | |_____^
-   |
-help: try this
-   |
-LL ~     if let Some(a) = Some(1) { println!("${:?}", a) } else {
-LL +         println!("else block");
-LL +         return
-LL +     }
-   |
-
-error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
-  --> $DIR/single_match_else.rs:79:5
-   |
-LL | /     match Some(1) {
-LL | |         Some(a) => println!("${:?}", a),
-LL | |         None => {
-LL | |             println!("else block");
-LL | |             return;
-LL | |         },
-LL | |     }
-   | |_____^
-   |
-help: try this
-   |
-LL ~     if let Some(a) = Some(1) { println!("${:?}", a) } else {
-LL +         println!("else block");
-LL +         return;
-LL +     }
-   |
-
-error: aborting due to 3 previous errors
+error: aborting due to previous error
 
-- 
cgit 1.4.1-3-g733a5


From 49ae73b450b61f0240e629ced2024a9474f35adc Mon Sep 17 00:00:00 2001
From: Georgy Komarov <jubnzv@gmail.com>
Date: Fri, 21 Jan 2022 07:28:40 +0300
Subject: matches: Simplify code

---
 clippy_lints/src/matches.rs | 9 +--------
 1 file changed, 1 insertion(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index 9da05245069..be9eff4237b 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -877,14 +877,7 @@ fn check_single_match_opt_like(
 fn collect_pat_paths(acc: &mut Vec<String>, pat: &Pat<'_>) -> bool {
     match pat.kind {
         PatKind::Wild => true,
-        PatKind::Tuple(inner, _) => {
-            for p in inner {
-                if !collect_pat_paths(acc, p) {
-                    return false;
-                }
-            }
-            true
-        },
+        PatKind::Tuple(inner, _) => inner.iter().all(|p| collect_pat_paths(acc, p)),
         PatKind::TupleStruct(ref path, ..) => {
             acc.push(rustc_hir_pretty::to_string(rustc_hir_pretty::NO_ANN, |s| {
                 s.print_qpath(path, false);
-- 
cgit 1.4.1-3-g733a5


From 7c563175c7b2e7eeb2a917707c09236b77321946 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Fri, 21 Jan 2022 12:40:33 +0000
Subject: Don't suggest an empty variant name in `enum_variant_names`

---
 clippy_lints/src/enum_variants.rs | 3 +++
 tests/ui/enum_variants.rs         | 7 +++++++
 2 files changed, 10 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/enum_variants.rs b/clippy_lints/src/enum_variants.rs
index 4f89e567430..1f4353fa4f7 100644
--- a/clippy_lints/src/enum_variants.rs
+++ b/clippy_lints/src/enum_variants.rs
@@ -172,6 +172,9 @@ fn check_variant(cx: &LateContext<'_>, threshold: u64, def: &EnumDef<'_>, item_n
         let name = var.ident.name.as_str();
 
         let variant_split = camel_case_split(name);
+        if variant_split.len() == 1 {
+            return;
+        }
 
         pre = pre
             .iter()
diff --git a/tests/ui/enum_variants.rs b/tests/ui/enum_variants.rs
index d3662a0a213..b2bf7c4e360 100644
--- a/tests/ui/enum_variants.rs
+++ b/tests/ui/enum_variants.rs
@@ -151,4 +151,11 @@ enum North {
     NoRight,
 }
 
+// #8324
+enum Phase {
+    PreLookup,
+    Lookup,
+    PostLookup,
+}
+
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 048297b5b265188ca9864d410a8bebb090e2f5ba Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Fri, 21 Jan 2022 09:43:41 -0500
Subject: `ptr_arg` cleanup

---
 clippy_lints/src/ptr.rs | 162 +++++++++++++++++++++++++-----------------------
 tests/ui/ptr_arg.rs     |  12 ++--
 2 files changed, 89 insertions(+), 85 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs
index b74ba40d452..c2ade4f0db7 100644
--- a/clippy_lints/src/ptr.rs
+++ b/clippy_lints/src/ptr.rs
@@ -385,87 +385,91 @@ fn check_fn_args<'cx, 'tcx: 'cx>(
     hir_tys: &'tcx [hir::Ty<'_>],
     params: &'tcx [Param<'_>],
 ) -> impl Iterator<Item = PtrArg<'tcx>> + 'cx {
-    tys.iter().enumerate().filter_map(|(i, ty)| {
-        if_chain! {
-            if let ty::Ref(_, ty, mutability) = *ty.kind();
-            if let ty::Adt(adt, substs) = *ty.kind();
-
-            let hir_ty = &hir_tys[i];
-            if let TyKind::Rptr(lt, ref ty) = hir_ty.kind;
-            if let TyKind::Path(QPath::Resolved(None, path)) = ty.ty.kind;
-
-            if let [.., name] = path.segments;
-            if cx.tcx.item_name(adt.did) == name.ident.name;
-
-            if !is_lint_allowed(cx, PTR_ARG, hir_ty.hir_id);
-            if params.get(i).map_or(true, |p| !is_lint_allowed(cx, PTR_ARG, p.hir_id));
-
-            then {
-                let (method_renames, deref_ty, deref_impl_id) = match cx.tcx.get_diagnostic_name(adt.did) {
-                    Some(sym::Vec) => (
-                        [("clone", ".to_owned()")].as_slice(),
-                        DerefTy::Slice(
-                            name.args
-                                .and_then(|args| args.args.first())
-                                .and_then(|arg| if let GenericArg::Type(ty) = arg {
-                                    Some(ty.span)
-                                } else {
-                                    None
-                                }),
-                            substs.type_at(0),
+    tys.iter()
+        .zip(hir_tys.iter())
+        .enumerate()
+        .filter_map(|(i, (ty, hir_ty))| {
+            if_chain! {
+                if let ty::Ref(_, ty, mutability) = *ty.kind();
+                if let ty::Adt(adt, substs) = *ty.kind();
+
+                if let TyKind::Rptr(lt, ref ty) = hir_ty.kind;
+                if let TyKind::Path(QPath::Resolved(None, path)) = ty.ty.kind;
+
+                // Check that the name as typed matches the actual name of the type.
+                // e.g. `fn foo(_: &Foo)` shouldn't trigger the lint when `Foo` is an alias for `Vec`
+                if let [.., name] = path.segments;
+                if cx.tcx.item_name(adt.did) == name.ident.name;
+
+                if !is_lint_allowed(cx, PTR_ARG, hir_ty.hir_id);
+                if params.get(i).map_or(true, |p| !is_lint_allowed(cx, PTR_ARG, p.hir_id));
+
+                then {
+                    let (method_renames, deref_ty, deref_impl_id) = match cx.tcx.get_diagnostic_name(adt.did) {
+                        Some(sym::Vec) => (
+                            [("clone", ".to_owned()")].as_slice(),
+                            DerefTy::Slice(
+                                name.args
+                                    .and_then(|args| args.args.first())
+                                    .and_then(|arg| if let GenericArg::Type(ty) = arg {
+                                        Some(ty.span)
+                                    } else {
+                                        None
+                                    }),
+                                substs.type_at(0),
+                            ),
+                            cx.tcx.lang_items().slice_impl()
                         ),
-                        cx.tcx.lang_items().slice_impl()
-                    ),
-                    Some(sym::String) => (
-                        [("clone", ".to_owned()"), ("as_str", "")].as_slice(),
-                        DerefTy::Str,
-                        cx.tcx.lang_items().str_impl()
-                    ),
-                    Some(sym::PathBuf) => (
-                        [("clone", ".to_path_buf()"), ("as_path", "")].as_slice(),
-                        DerefTy::Path,
-                        None,
-                    ),
-                    Some(sym::Cow) => {
-                        let ty_name = name.args
-                            .and_then(|args| {
-                                args.args.iter().find_map(|a| match a {
-                                    GenericArg::Type(x) => Some(x),
-                                    _ => None,
+                        Some(sym::String) => (
+                            [("clone", ".to_owned()"), ("as_str", "")].as_slice(),
+                            DerefTy::Str,
+                            cx.tcx.lang_items().str_impl()
+                        ),
+                        Some(sym::PathBuf) => (
+                            [("clone", ".to_path_buf()"), ("as_path", "")].as_slice(),
+                            DerefTy::Path,
+                            None,
+                        ),
+                        Some(sym::Cow) => {
+                            let ty_name = name.args
+                                .and_then(|args| {
+                                    args.args.iter().find_map(|a| match a {
+                                        GenericArg::Type(x) => Some(x),
+                                        _ => None,
+                                    })
                                 })
-                            })
-                            .and_then(|arg| snippet_opt(cx, arg.span))
-                            .unwrap_or_else(|| substs.type_at(1).to_string());
-                        span_lint_and_sugg(
-                            cx,
-                            PTR_ARG,
-                            hir_ty.span,
-                            "using a reference to `Cow` is not recommended",
-                            "change this to",
-                            format!("&{}{}", mutability.prefix_str(), ty_name),
-                            Applicability::Unspecified,
-                        );
-                        return None;
-                    },
-                    _ => return None,
-                };
-                return Some(PtrArg {
-                    idx: i,
-                    span: hir_ty.span,
-                    ty_did: adt.did,
-                    ty_name: name.ident.name,
-                    method_renames,
-                    ref_prefix: RefPrefix {
-                        lt: lt.name,
-                        mutability,
-                    },
-                    deref_ty,
-                    deref_assoc_items: deref_impl_id.map(|id| (id, cx.tcx.associated_items(id))),
-                });
+                                .and_then(|arg| snippet_opt(cx, arg.span))
+                                .unwrap_or_else(|| substs.type_at(1).to_string());
+                            span_lint_and_sugg(
+                                cx,
+                                PTR_ARG,
+                                hir_ty.span,
+                                "using a reference to `Cow` is not recommended",
+                                "change this to",
+                                format!("&{}{}", mutability.prefix_str(), ty_name),
+                                Applicability::Unspecified,
+                            );
+                            return None;
+                        },
+                        _ => return None,
+                    };
+                    return Some(PtrArg {
+                        idx: i,
+                        span: hir_ty.span,
+                        ty_did: adt.did,
+                        ty_name: name.ident.name,
+                        method_renames,
+                        ref_prefix: RefPrefix {
+                            lt: lt.name,
+                            mutability,
+                        },
+                        deref_ty,
+                        deref_assoc_items: deref_impl_id.map(|id| (id, cx.tcx.associated_items(id))),
+                    });
+                }
             }
-        }
-        None
-    })
+            None
+        })
 }
 
 fn check_mut_from_ref(cx: &LateContext<'_>, decl: &FnDecl<'_>) {
@@ -504,7 +508,7 @@ fn check_mut_from_ref(cx: &LateContext<'_>, decl: &FnDecl<'_>) {
 fn check_ptr_arg_usage<'tcx>(cx: &LateContext<'tcx>, body: &'tcx Body<'_>, args: &[PtrArg<'tcx>]) -> Vec<PtrArgResult> {
     struct V<'cx, 'tcx> {
         cx: &'cx LateContext<'tcx>,
-        /// Map from a local id to which argument it cam from (index into `Self::args` and
+        /// Map from a local id to which argument it came from (index into `Self::args` and
         /// `Self::results`)
         bindings: HirIdMap<usize>,
         /// The arguments being checked.
diff --git a/tests/ui/ptr_arg.rs b/tests/ui/ptr_arg.rs
index 6cd7e96d7c1..ed724237808 100644
--- a/tests/ui/ptr_arg.rs
+++ b/tests/ui/ptr_arg.rs
@@ -169,13 +169,13 @@ fn fn_requires_vec(v: &Vec<u32>) -> bool {
     vec_contains(v)
 }
 
-// fn impl_fn_requires_vec(v: &Vec<u32>, f: impl Fn(&Vec<u32>)) {
-//     f(v);
-// }
+fn impl_fn_requires_vec(v: &Vec<u32>, f: impl Fn(&Vec<u32>)) {
+    f(v);
+}
 
-// fn dyn_fn_requires_vec(v: &Vec<u32>, f: &dyn Fn(&Vec<u32>)) {
-//     f(v);
-// }
+fn dyn_fn_requires_vec(v: &Vec<u32>, f: &dyn Fn(&Vec<u32>)) {
+    f(v);
+}
 
 // No error for types behind an alias (#7699)
 type A = Vec<u8>;
-- 
cgit 1.4.1-3-g733a5


From 15c068ed0f4d231beabb22975cbca7fd33996ce5 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Mon, 3 Jan 2022 12:44:33 -0500
Subject: Fix `needless_borrow` causing mutable borrows to be moved

---
 clippy_lints/src/dereference.rs | 79 ++++++++++++++++++++++++++++-------------
 tests/ui/needless_borrow.fixed  | 17 +++++++++
 tests/ui/needless_borrow.rs     | 17 +++++++++
 tests/ui/needless_borrow.stderr | 26 +++++++++++++-
 4 files changed, 114 insertions(+), 25 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index bf077a212fd..9645f1a03be 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -10,11 +10,10 @@ use rustc_hir::{
     Pat, PatKind, UnOp,
 };
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty::adjustment::{Adjust, Adjustment, AutoBorrow};
+use rustc_middle::ty::adjustment::{Adjust, Adjustment, AutoBorrow, AutoBorrowMutability};
 use rustc_middle::ty::{self, Ty, TyCtxt, TyS, TypeckResults};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::{symbol::sym, Span};
-use std::iter;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -226,40 +225,58 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing {
                         let mut iter = find_adjustments(cx.tcx, typeck, expr).iter();
                         if let Some((i, adjust)) = iter.by_ref().enumerate().find_map(|(i, adjust)| {
                             if !matches!(adjust.kind, Adjust::Deref(_)) {
-                                Some((i, adjust))
+                                Some((i, Some(adjust)))
                             } else if !adjust.target.is_ref() {
-                                // Add one to the number of references found.
-                                Some((i + 1, adjust))
+                                // Include the current deref.
+                                Some((i + 1, None))
                             } else {
                                 None
                             }
                         }) {
-                            // Found two consecutive derefs. At least one can be removed.
                             if i > 1 {
-                                let target_mut = iter::once(adjust)
-                                    .chain(iter)
-                                    .find_map(|adjust| match adjust.kind {
-                                        Adjust::Borrow(AutoBorrow::Ref(_, m)) => Some(m.into()),
-                                        _ => None,
-                                    })
-                                    // This default should never happen. Auto-deref always reborrows.
-                                    .unwrap_or(Mutability::Not);
-                                self.state = Some((
-                                    // Subtract one for the current borrow expression, and one to cover the last
-                                    // reference which can't be removed (it's either reborrowed, or needed for
-                                    // auto-deref to happen).
-                                    State::DerefedBorrow {
+                                // If the next adjustment is a mutable borrow, then check to see if the compiler will
+                                // insert a re-borrow here. If not, leave an extra borrow here to avoid attempting to
+                                // move the a mutable reference.
+                                let (i, target_mut) = if let Some(&Adjust::Borrow(AutoBorrow::Ref(_, mutability))) =
+                                    adjust.or_else(|| iter.next()).map(|a| &a.kind)
+                                {
+                                    if matches!(mutability, AutoBorrowMutability::Mut { .. })
+                                        && !is_auto_reborrow_position(parent, expr.hir_id)
+                                    {
+                                        (i - 1, Mutability::Mut)
+                                    } else {
+                                        (i, mutability.into())
+                                    }
+                                } else {
+                                    (
+                                        i,
+                                        iter.find_map(|adjust| match adjust.kind {
+                                            Adjust::Borrow(AutoBorrow::Ref(_, m)) => Some(m.into()),
+                                            _ => None,
+                                        })
+                                        // This default should never happen. Auto-deref always reborrows.
+                                        .unwrap_or(Mutability::Not),
+                                    )
+                                };
+
+                                if i > 1 {
+                                    self.state = Some((
+                                        // Subtract one for the current borrow expression, and one to cover the last
+                                        // reference which can't be removed (it's either reborrowed, or needed for
+                                        // auto-deref to happen).
+                                        State::DerefedBorrow {
                                         count:
                                             // Truncation here would require more than a `u32::MAX` level reference. The compiler
                                             // does not support this.
                                             #[allow(clippy::cast_possible_truncation)]
                                             { i as u32 - 2 }
                                     },
-                                    StateData {
-                                        span: expr.span,
-                                        target_mut,
-                                    },
-                                ));
+                                        StateData {
+                                            span: expr.span,
+                                            target_mut,
+                                        },
+                                    ));
+                                }
                             }
                         }
                     },
@@ -456,6 +473,20 @@ fn is_linted_explicit_deref_position(parent: Option<Node<'_>>, child_id: HirId,
     }
 }
 
+/// Checks if the given expression is in a position which can be auto-reborrowed.
+/// Note: This is only correct assuming auto-deref is already occurring.
+fn is_auto_reborrow_position(parent: Option<Node<'_>>, child_id: HirId) -> bool {
+    match parent {
+        Some(Node::Expr(parent)) => match parent.kind {
+            ExprKind::MethodCall(..) => true,
+            ExprKind::Call(callee, _) => callee.hir_id != child_id,
+            _ => false,
+        },
+        Some(Node::Local(_)) => true,
+        _ => false,
+    }
+}
+
 /// Adjustments are sometimes made in the parent block rather than the expression itself.
 fn find_adjustments<'tcx>(
     tcx: TyCtxt<'tcx>,
diff --git a/tests/ui/needless_borrow.fixed b/tests/ui/needless_borrow.fixed
index 9e37fb92559..2a87b520ce5 100644
--- a/tests/ui/needless_borrow.fixed
+++ b/tests/ui/needless_borrow.fixed
@@ -45,6 +45,23 @@ fn main() {
         let b = &mut b;
         x(b);
     }
+
+    // Issue #8191
+    let mut x = 5;
+    let mut x = &mut x;
+
+    mut_ref(x);
+    mut_ref(x);
+    let y: &mut i32 = x;
+    let y: &mut i32 = x;
+
+    let y = match 0 {
+        // Don't lint. Removing the borrow would move 'x'
+        0 => &mut x,
+        _ => &mut *x,
+    };
+
+    *x = 5;
 }
 
 #[allow(clippy::needless_borrowed_reference)]
diff --git a/tests/ui/needless_borrow.rs b/tests/ui/needless_borrow.rs
index 093277784be..4a98350711f 100644
--- a/tests/ui/needless_borrow.rs
+++ b/tests/ui/needless_borrow.rs
@@ -45,6 +45,23 @@ fn main() {
         let b = &mut b;
         x(&b);
     }
+
+    // Issue #8191
+    let mut x = 5;
+    let mut x = &mut x;
+
+    mut_ref(&mut x);
+    mut_ref(&mut &mut x);
+    let y: &mut i32 = &mut x;
+    let y: &mut i32 = &mut &mut x;
+
+    let y = match 0 {
+        // Don't lint. Removing the borrow would move 'x'
+        0 => &mut x,
+        _ => &mut *x,
+    };
+
+    *x = 5;
 }
 
 #[allow(clippy::needless_borrowed_reference)]
diff --git a/tests/ui/needless_borrow.stderr b/tests/ui/needless_borrow.stderr
index 03a5b3d260e..2211f957982 100644
--- a/tests/ui/needless_borrow.stderr
+++ b/tests/ui/needless_borrow.stderr
@@ -60,5 +60,29 @@ error: this expression borrows a reference (`&mut i32`) that is immediately dere
 LL |         x(&b);
    |           ^^ help: change this to: `b`
 
-error: aborting due to 10 previous errors
+error: this expression borrows a reference (`&mut i32`) that is immediately dereferenced by the compiler
+  --> $DIR/needless_borrow.rs:53:13
+   |
+LL |     mut_ref(&mut x);
+   |             ^^^^^^ help: change this to: `x`
+
+error: this expression borrows a reference (`&mut i32`) that is immediately dereferenced by the compiler
+  --> $DIR/needless_borrow.rs:54:13
+   |
+LL |     mut_ref(&mut &mut x);
+   |             ^^^^^^^^^^^ help: change this to: `x`
+
+error: this expression borrows a reference (`&mut i32`) that is immediately dereferenced by the compiler
+  --> $DIR/needless_borrow.rs:55:23
+   |
+LL |     let y: &mut i32 = &mut x;
+   |                       ^^^^^^ help: change this to: `x`
+
+error: this expression borrows a reference (`&mut i32`) that is immediately dereferenced by the compiler
+  --> $DIR/needless_borrow.rs:56:23
+   |
+LL |     let y: &mut i32 = &mut &mut x;
+   |                       ^^^^^^^^^^^ help: change this to: `x`
+
+error: aborting due to 14 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 9ef6e2199c885ffd671b321dfbf16ff0934f4d80 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Fri, 14 Jan 2022 14:24:25 +0000
Subject: `needless_lifetimes`: ignore lifetimes in explicit self types

---
 clippy_lints/src/lifetimes.rs      | 52 +++++++++++++++++----
 tests/ui/needless_lifetimes.rs     | 51 ++++++++++++++++++++-
 tests/ui/needless_lifetimes.stderr | 94 +++++++++++++++++++++++++++-----------
 3 files changed, 162 insertions(+), 35 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lifetimes.rs b/clippy_lints/src/lifetimes.rs
index 0e2b78609c2..618cf4b8b22 100644
--- a/clippy_lints/src/lifetimes.rs
+++ b/clippy_lints/src/lifetimes.rs
@@ -15,7 +15,7 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::map::Map;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
-use rustc_span::symbol::{kw, Symbol};
+use rustc_span::symbol::{kw, Ident, Symbol};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -85,7 +85,7 @@ declare_lint_pass!(Lifetimes => [NEEDLESS_LIFETIMES, EXTRA_UNUSED_LIFETIMES]);
 impl<'tcx> LateLintPass<'tcx> for Lifetimes {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
         if let ItemKind::Fn(ref sig, ref generics, id) = item.kind {
-            check_fn_inner(cx, sig.decl, Some(id), generics, item.span, true);
+            check_fn_inner(cx, sig.decl, Some(id), None, generics, item.span, true);
         }
     }
 
@@ -96,6 +96,7 @@ impl<'tcx> LateLintPass<'tcx> for Lifetimes {
                 cx,
                 sig.decl,
                 Some(id),
+                None,
                 &item.generics,
                 item.span,
                 report_extra_lifetimes,
@@ -105,11 +106,11 @@ impl<'tcx> LateLintPass<'tcx> for Lifetimes {
 
     fn check_trait_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx TraitItem<'_>) {
         if let TraitItemKind::Fn(ref sig, ref body) = item.kind {
-            let body = match *body {
-                TraitFn::Required(_) => None,
-                TraitFn::Provided(id) => Some(id),
+            let (body, trait_sig) = match *body {
+                TraitFn::Required(sig) => (None, Some(sig)),
+                TraitFn::Provided(id) => (Some(id), None),
             };
-            check_fn_inner(cx, sig.decl, body, &item.generics, item.span, true);
+            check_fn_inner(cx, sig.decl, body, trait_sig, &item.generics, item.span, true);
         }
     }
 }
@@ -126,6 +127,7 @@ fn check_fn_inner<'tcx>(
     cx: &LateContext<'tcx>,
     decl: &'tcx FnDecl<'_>,
     body: Option<BodyId>,
+    trait_sig: Option<&[Ident]>,
     generics: &'tcx Generics<'_>,
     span: Span,
     report_extra_lifetimes: bool,
@@ -167,7 +169,7 @@ fn check_fn_inner<'tcx>(
             }
         }
     }
-    if could_use_elision(cx, decl, body, generics.params) {
+    if could_use_elision(cx, decl, body, trait_sig, generics.params) {
         span_lint(
             cx,
             NEEDLESS_LIFETIMES,
@@ -181,10 +183,31 @@ fn check_fn_inner<'tcx>(
     }
 }
 
+// elision doesn't work for explicit self types, see rust-lang/rust#69064
+fn explicit_self_type<'tcx>(cx: &LateContext<'tcx>, func: &FnDecl<'tcx>, ident: Option<Ident>) -> bool {
+    if_chain! {
+        if let Some(ident) = ident;
+        if ident.name == kw::SelfLower;
+        if !func.implicit_self.has_implicit_self();
+
+        if let Some(self_ty) = func.inputs.first();
+        then {
+            let mut visitor = RefVisitor::new(cx);
+            visitor.visit_ty(self_ty);
+
+            !visitor.all_lts().is_empty()
+        }
+        else {
+            false
+        }
+    }
+}
+
 fn could_use_elision<'tcx>(
     cx: &LateContext<'tcx>,
     func: &'tcx FnDecl<'_>,
     body: Option<BodyId>,
+    trait_sig: Option<&[Ident]>,
     named_generics: &'tcx [GenericParam<'_>],
 ) -> bool {
     // There are two scenarios where elision works:
@@ -235,11 +258,24 @@ fn could_use_elision<'tcx>(
     let input_lts = input_visitor.lts;
     let output_lts = output_visitor.lts;
 
+    if let Some(trait_sig) = trait_sig {
+        if explicit_self_type(cx, func, trait_sig.first().copied()) {
+            return false;
+        }
+    }
+
     if let Some(body_id) = body {
+        let body = cx.tcx.hir().body(body_id);
+
+        let first_ident = body.params.first().and_then(|param| param.pat.simple_ident());
+        if explicit_self_type(cx, func, first_ident) {
+            return false;
+        }
+
         let mut checker = BodyLifetimeChecker {
             lifetimes_used_in_body: false,
         };
-        checker.visit_expr(&cx.tcx.hir().body(body_id).value);
+        checker.visit_expr(&body.value);
         if checker.lifetimes_used_in_body {
             return false;
         }
diff --git a/tests/ui/needless_lifetimes.rs b/tests/ui/needless_lifetimes.rs
index b07c4a23810..f3eafe8e927 100644
--- a/tests/ui/needless_lifetimes.rs
+++ b/tests/ui/needless_lifetimes.rs
@@ -1,5 +1,11 @@
 #![warn(clippy::needless_lifetimes)]
-#![allow(dead_code, clippy::needless_pass_by_value, clippy::unnecessary_wraps, dyn_drop)]
+#![allow(
+    dead_code,
+    clippy::boxed_local,
+    clippy::needless_pass_by_value,
+    clippy::unnecessary_wraps,
+    dyn_drop
+)]
 
 fn distinct_lifetimes<'a, 'b>(_x: &'a u8, _y: &'b u8, _z: u8) {}
 
@@ -369,4 +375,47 @@ mod issue6159 {
     }
 }
 
+mod issue7296 {
+    use std::rc::Rc;
+    use std::sync::Arc;
+
+    struct Foo;
+    impl Foo {
+        fn implicit<'a>(&'a self) -> &'a () {
+            &()
+        }
+        fn implicit_mut<'a>(&'a mut self) -> &'a () {
+            &()
+        }
+
+        fn explicit<'a>(self: &'a Arc<Self>) -> &'a () {
+            &()
+        }
+        fn explicit_mut<'a>(self: &'a mut Rc<Self>) -> &'a () {
+            &()
+        }
+
+        fn lifetime_elsewhere<'a>(self: Box<Self>, here: &'a ()) -> &'a () {
+            &()
+        }
+    }
+
+    trait Bar {
+        fn implicit<'a>(&'a self) -> &'a ();
+        fn implicit_provided<'a>(&'a self) -> &'a () {
+            &()
+        }
+
+        fn explicit<'a>(self: &'a Arc<Self>) -> &'a ();
+        fn explicit_provided<'a>(self: &'a Arc<Self>) -> &'a () {
+            &()
+        }
+
+        fn lifetime_elsewhere<'a>(self: Box<Self>, here: &'a ()) -> &'a ();
+        fn lifetime_elsewhere_provided<'a>(self: Box<Self>, here: &'a ()) -> &'a () {
+            &()
+        }
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/needless_lifetimes.stderr b/tests/ui/needless_lifetimes.stderr
index 4114e6f1832..ffa152427a9 100644
--- a/tests/ui/needless_lifetimes.stderr
+++ b/tests/ui/needless_lifetimes.stderr
@@ -1,5 +1,5 @@
 error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
-  --> $DIR/needless_lifetimes.rs:4:1
+  --> $DIR/needless_lifetimes.rs:10:1
    |
 LL | fn distinct_lifetimes<'a, 'b>(_x: &'a u8, _y: &'b u8, _z: u8) {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -7,148 +7,190 @@ LL | fn distinct_lifetimes<'a, 'b>(_x: &'a u8, _y: &'b u8, _z: u8) {}
    = note: `-D clippy::needless-lifetimes` implied by `-D warnings`
 
 error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
-  --> $DIR/needless_lifetimes.rs:6:1
+  --> $DIR/needless_lifetimes.rs:12:1
    |
 LL | fn distinct_and_static<'a, 'b>(_x: &'a u8, _y: &'b u8, _z: &'static u8) {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
-  --> $DIR/needless_lifetimes.rs:16:1
+  --> $DIR/needless_lifetimes.rs:22:1
    |
 LL | fn in_and_out<'a>(x: &'a u8, _y: u8) -> &'a u8 {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
-  --> $DIR/needless_lifetimes.rs:50:1
+  --> $DIR/needless_lifetimes.rs:56:1
    |
 LL | fn deep_reference_3<'a>(x: &'a u8, _y: u8) -> Result<&'a u8, ()> {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
-  --> $DIR/needless_lifetimes.rs:55:1
+  --> $DIR/needless_lifetimes.rs:61:1
    |
 LL | fn where_clause_without_lt<'a, T>(x: &'a u8, _y: u8) -> Result<&'a u8, ()>
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
-  --> $DIR/needless_lifetimes.rs:67:1
+  --> $DIR/needless_lifetimes.rs:73:1
    |
 LL | fn lifetime_param_2<'a, 'b>(_x: Ref<'a>, _y: &'b u8) {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
-  --> $DIR/needless_lifetimes.rs:91:1
+  --> $DIR/needless_lifetimes.rs:97:1
    |
 LL | fn fn_bound_2<'a, F, I>(_m: Lt<'a, I>, _f: F) -> Lt<'a, I>
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
-  --> $DIR/needless_lifetimes.rs:121:5
+  --> $DIR/needless_lifetimes.rs:127:5
    |
 LL |     fn self_and_out<'s>(&'s self) -> &'s u8 {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
-  --> $DIR/needless_lifetimes.rs:130:5
+  --> $DIR/needless_lifetimes.rs:136:5
    |
 LL |     fn distinct_self_and_in<'s, 't>(&'s self, _x: &'t u8) {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
-  --> $DIR/needless_lifetimes.rs:149:1
+  --> $DIR/needless_lifetimes.rs:155:1
    |
 LL | fn struct_with_lt<'a>(_foo: Foo<'a>) -> &'a str {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
-  --> $DIR/needless_lifetimes.rs:179:1
+  --> $DIR/needless_lifetimes.rs:185:1
    |
 LL | fn trait_obj_elided2<'a>(_arg: &'a dyn Drop) -> &'a str {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
-  --> $DIR/needless_lifetimes.rs:185:1
+  --> $DIR/needless_lifetimes.rs:191:1
    |
 LL | fn alias_with_lt<'a>(_foo: FooAlias<'a>) -> &'a str {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
-  --> $DIR/needless_lifetimes.rs:204:1
+  --> $DIR/needless_lifetimes.rs:210:1
    |
 LL | fn named_input_elided_output<'a>(_arg: &'a str) -> &str {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
-  --> $DIR/needless_lifetimes.rs:212:1
+  --> $DIR/needless_lifetimes.rs:218:1
    |
 LL | fn trait_bound_ok<'a, T: WithLifetime<'static>>(_: &'a u8, _: T) {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
-  --> $DIR/needless_lifetimes.rs:248:1
+  --> $DIR/needless_lifetimes.rs:254:1
    |
 LL | fn out_return_type_lts<'a>(e: &'a str) -> Cow<'a> {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
-  --> $DIR/needless_lifetimes.rs:255:9
+  --> $DIR/needless_lifetimes.rs:261:9
    |
 LL |         fn needless_lt<'a>(x: &'a u8) {}
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
-  --> $DIR/needless_lifetimes.rs:259:9
+  --> $DIR/needless_lifetimes.rs:265:9
    |
 LL |         fn needless_lt<'a>(_x: &'a u8) {}
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
-  --> $DIR/needless_lifetimes.rs:272:9
+  --> $DIR/needless_lifetimes.rs:278:9
    |
 LL |         fn baz<'a>(&'a self) -> impl Foo + 'a {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
-  --> $DIR/needless_lifetimes.rs:301:5
+  --> $DIR/needless_lifetimes.rs:307:5
    |
 LL |     fn impl_trait_elidable_nested_named_lifetimes<'a>(i: &'a i32, f: impl for<'b> Fn(&'b i32) -> &'b i32) -> &'a i32 {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
-  --> $DIR/needless_lifetimes.rs:304:5
+  --> $DIR/needless_lifetimes.rs:310:5
    |
 LL |     fn impl_trait_elidable_nested_anonymous_lifetimes<'a>(i: &'a i32, f: impl Fn(&i32) -> &i32) -> &'a i32 {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
-  --> $DIR/needless_lifetimes.rs:313:5
+  --> $DIR/needless_lifetimes.rs:319:5
    |
 LL |     fn generics_elidable<'a, T: Fn(&i32) -> &i32>(i: &'a i32, f: T) -> &'a i32 {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
-  --> $DIR/needless_lifetimes.rs:325:5
+  --> $DIR/needless_lifetimes.rs:331:5
    |
 LL |     fn where_clause_elidadable<'a, T>(i: &'a i32, f: T) -> &'a i32
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
-  --> $DIR/needless_lifetimes.rs:340:5
+  --> $DIR/needless_lifetimes.rs:346:5
    |
 LL |     fn pointer_fn_elidable<'a>(i: &'a i32, f: fn(&i32) -> &i32) -> &'a i32 {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
-  --> $DIR/needless_lifetimes.rs:353:5
+  --> $DIR/needless_lifetimes.rs:359:5
    |
 LL |     fn nested_fn_pointer_3<'a>(_: &'a i32) -> fn(fn(&i32) -> &i32) -> i32 {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
-  --> $DIR/needless_lifetimes.rs:356:5
+  --> $DIR/needless_lifetimes.rs:362:5
    |
 LL |     fn nested_fn_pointer_4<'a>(_: &'a i32) -> impl Fn(fn(&i32)) {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 25 previous errors
+error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+  --> $DIR/needless_lifetimes.rs:384:9
+   |
+LL |         fn implicit<'a>(&'a self) -> &'a () {
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+  --> $DIR/needless_lifetimes.rs:387:9
+   |
+LL |         fn implicit_mut<'a>(&'a mut self) -> &'a () {
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+  --> $DIR/needless_lifetimes.rs:398:9
+   |
+LL |         fn lifetime_elsewhere<'a>(self: Box<Self>, here: &'a ()) -> &'a () {
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+  --> $DIR/needless_lifetimes.rs:404:9
+   |
+LL |         fn implicit<'a>(&'a self) -> &'a ();
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+  --> $DIR/needless_lifetimes.rs:405:9
+   |
+LL |         fn implicit_provided<'a>(&'a self) -> &'a () {
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+  --> $DIR/needless_lifetimes.rs:414:9
+   |
+LL |         fn lifetime_elsewhere<'a>(self: Box<Self>, here: &'a ()) -> &'a ();
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+  --> $DIR/needless_lifetimes.rs:415:9
+   |
+LL |         fn lifetime_elsewhere_provided<'a>(self: Box<Self>, here: &'a ()) -> &'a () {
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 32 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 9e9110e4f3fd8d982dbde873b0c5168b8a3968ed Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Tue, 11 Jan 2022 14:31:35 -0500
Subject: Remove final reference on fields and method calls in
 `needless_borrow`

---
 CHANGELOG.md                         |   2 +-
 clippy_lints/src/dereference.rs      | 212 ++++++++++++++++++++++-------------
 clippy_lints/src/implicit_hasher.rs  |   2 +-
 clippy_lints/src/octal_escapes.rs    |   2 +-
 clippy_utils/src/sugg.rs             |   2 +-
 tests/ui/bytecount.rs                |   2 +
 tests/ui/bytecount.stderr            |   8 +-
 tests/ui/clone_on_copy.fixed         |   3 +-
 tests/ui/clone_on_copy.rs            |   3 +-
 tests/ui/clone_on_copy.stderr        |  16 +--
 tests/ui/duration_subsec.fixed       |   2 +-
 tests/ui/duration_subsec.rs          |   2 +-
 tests/ui/eta.fixed                   |   9 +-
 tests/ui/eta.rs                      |   7 +-
 tests/ui/eta.stderr                  |  50 ++++-----
 tests/ui/for_loop_fixable.fixed      |   7 +-
 tests/ui/for_loop_fixable.rs         |   7 +-
 tests/ui/for_loop_fixable.stderr     |  30 ++---
 tests/ui/needless_borrow.fixed       |  10 ++
 tests/ui/needless_borrow.rs          |  10 ++
 tests/ui/needless_borrow.stderr      |  74 +++++++++---
 tests/ui/useless_asref.fixed         |   2 +-
 tests/ui/useless_asref.rs            |   2 +-
 tests/ui/write_literal.rs            |  48 ++++----
 tests/ui/write_literal.stderr        | 110 +++++++++---------
 tests/ui/write_literal_2.rs          |  16 +--
 tests/ui/write_literal_2.stderr      |  50 ++++-----
 tests/ui/write_with_newline.rs       |  56 ++++-----
 tests/ui/write_with_newline.stderr   |  72 ++++++------
 tests/ui/writeln_empty_string.fixed  |  10 +-
 tests/ui/writeln_empty_string.rs     |  10 +-
 tests/ui/writeln_empty_string.stderr |  12 +-
 32 files changed, 485 insertions(+), 363 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 258a8256f53..8e65a799ead 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -981,7 +981,7 @@ Released 2021-03-25
   [#6532](https://github.com/rust-lang/rust-clippy/pull/6532)
 * [`single_match`] Suggest `if` over `if let` when possible
   [#6574](https://github.com/rust-lang/rust-clippy/pull/6574)
-* [`ref_in_deref`] Use parentheses correctly in suggestion
+* `ref_in_deref` Use parentheses correctly in suggestion
   [#6609](https://github.com/rust-lang/rust-clippy/pull/6609)
 * [`stable_sort_primitive`] Clarify error message
   [#6611](https://github.com/rust-lang/rust-clippy/pull/6611)
diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index 9645f1a03be..70f45646596 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -1,5 +1,6 @@
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::{snippet_with_applicability, snippet_with_context};
+use clippy_utils::sugg::has_enclosing_paren;
 use clippy_utils::ty::peel_mid_ty_refs;
 use clippy_utils::{get_parent_expr, get_parent_node, is_lint_allowed, path_to_local};
 use rustc_ast::util::parser::{PREC_POSTFIX, PREC_PREFIX};
@@ -130,8 +131,6 @@ pub struct Dereferencing {
 struct StateData {
     /// Span of the top level expression
     span: Span,
-    /// The required mutability
-    target_mut: Mutability,
 }
 
 enum State {
@@ -140,9 +139,13 @@ enum State {
         // The number of calls in a sequence which changed the referenced type
         ty_changed_count: usize,
         is_final_ufcs: bool,
+        /// The required mutability
+        target_mut: Mutability,
     },
     DerefedBorrow {
-        count: u32,
+        count: usize,
+        required_precedence: i8,
+        msg: &'static str,
     },
 }
 
@@ -213,77 +216,98 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing {
                                     1
                                 },
                                 is_final_ufcs: matches!(expr.kind, ExprKind::Call(..)),
-                            },
-                            StateData {
-                                span: expr.span,
                                 target_mut,
                             },
+                            StateData { span: expr.span },
                         ));
                     },
                     RefOp::AddrOf => {
                         // Find the number of times the borrow is auto-derefed.
                         let mut iter = find_adjustments(cx.tcx, typeck, expr).iter();
-                        if let Some((i, adjust)) = iter.by_ref().enumerate().find_map(|(i, adjust)| {
-                            if !matches!(adjust.kind, Adjust::Deref(_)) {
-                                Some((i, Some(adjust)))
-                            } else if !adjust.target.is_ref() {
-                                // Include the current deref.
-                                Some((i + 1, None))
-                            } else {
-                                None
-                            }
-                        }) {
-                            if i > 1 {
-                                // If the next adjustment is a mutable borrow, then check to see if the compiler will
-                                // insert a re-borrow here. If not, leave an extra borrow here to avoid attempting to
-                                // move the a mutable reference.
-                                let (i, target_mut) = if let Some(&Adjust::Borrow(AutoBorrow::Ref(_, mutability))) =
-                                    adjust.or_else(|| iter.next()).map(|a| &a.kind)
-                                {
-                                    if matches!(mutability, AutoBorrowMutability::Mut { .. })
-                                        && !is_auto_reborrow_position(parent, expr.hir_id)
-                                    {
-                                        (i - 1, Mutability::Mut)
-                                    } else {
-                                        (i, mutability.into())
+                        let mut deref_count = 0usize;
+                        let next_adjust = loop {
+                            match iter.next() {
+                                Some(adjust) => {
+                                    if !matches!(adjust.kind, Adjust::Deref(_)) {
+                                        break Some(adjust);
+                                    } else if !adjust.target.is_ref() {
+                                        deref_count += 1;
+                                        break iter.next();
                                     }
-                                } else {
-                                    (
-                                        i,
-                                        iter.find_map(|adjust| match adjust.kind {
-                                            Adjust::Borrow(AutoBorrow::Ref(_, m)) => Some(m.into()),
-                                            _ => None,
-                                        })
-                                        // This default should never happen. Auto-deref always reborrows.
-                                        .unwrap_or(Mutability::Not),
-                                    )
-                                };
-
-                                if i > 1 {
-                                    self.state = Some((
-                                        // Subtract one for the current borrow expression, and one to cover the last
-                                        // reference which can't be removed (it's either reborrowed, or needed for
-                                        // auto-deref to happen).
-                                        State::DerefedBorrow {
-                                        count:
-                                            // Truncation here would require more than a `u32::MAX` level reference. The compiler
-                                            // does not support this.
-                                            #[allow(clippy::cast_possible_truncation)]
-                                            { i as u32 - 2 }
-                                    },
-                                        StateData {
-                                            span: expr.span,
-                                            target_mut,
-                                        },
-                                    ));
-                                }
+                                    deref_count += 1;
+                                },
+                                None => break None,
+                            };
+                        };
+
+                        // Determine the required number of references before any can be removed. In all cases the
+                        // reference made by the current expression will be removed. After that there are four cases to
+                        // handle.
+                        //
+                        // 1. Auto-borrow will trigger in the current position, so no further references are required.
+                        // 2. Auto-deref ends at a reference, or the underlying type, so one extra needs to be left to
+                        //    handle the automatically inserted re-borrow.
+                        // 3. Auto-deref hits a user-defined `Deref` impl, so at least one reference needs to exist to
+                        //    start auto-deref.
+                        // 4. If the chain of non-user-defined derefs ends with a mutable re-borrow, and re-borrow
+                        //    adjustments will not be inserted automatically, then leave one further reference to avoid
+                        //    moving a mutable borrow.
+                        //    e.g.
+                        //        fn foo<T>(x: &mut Option<&mut T>, y: &mut T) {
+                        //            let x = match x {
+                        //                // Removing the borrow will cause `x` to be moved
+                        //                Some(x) => &mut *x,
+                        //                None => y
+                        //            };
+                        //        }
+                        let deref_msg =
+                            "this expression creates a reference which is immediately dereferenced by the compiler";
+                        let borrow_msg = "this expression borrows a value the compiler would automatically borrow";
+
+                        let (required_refs, required_precedence, msg) = if is_auto_borrow_position(parent, expr.hir_id)
+                        {
+                            (1, PREC_POSTFIX, if deref_count == 1 { borrow_msg } else { deref_msg })
+                        } else if let Some(&Adjust::Borrow(AutoBorrow::Ref(_, mutability))) =
+                            next_adjust.map(|a| &a.kind)
+                        {
+                            if matches!(mutability, AutoBorrowMutability::Mut { .. })
+                                && !is_auto_reborrow_position(parent)
+                            {
+                                (3, 0, deref_msg)
+                            } else {
+                                (2, 0, deref_msg)
                             }
+                        } else {
+                            (2, 0, deref_msg)
+                        };
+
+                        if deref_count >= required_refs {
+                            self.state = Some((
+                                State::DerefedBorrow {
+                                    // One of the required refs is for the current borrow expression, the remaining ones
+                                    // can't be removed without breaking the code. See earlier comment.
+                                    count: deref_count - required_refs,
+                                    required_precedence,
+                                    msg,
+                                },
+                                StateData { span: expr.span },
+                            ));
                         }
                     },
                     _ => (),
                 }
             },
-            (Some((State::DerefMethod { ty_changed_count, .. }, data)), RefOp::Method(_)) => {
+            (
+                Some((
+                    State::DerefMethod {
+                        target_mut,
+                        ty_changed_count,
+                        ..
+                    },
+                    data,
+                )),
+                RefOp::Method(_),
+            ) => {
                 self.state = Some((
                     State::DerefMethod {
                         ty_changed_count: if deref_method_same_type(typeck.expr_ty(expr), typeck.expr_ty(sub_expr)) {
@@ -292,12 +316,30 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing {
                             ty_changed_count + 1
                         },
                         is_final_ufcs: matches!(expr.kind, ExprKind::Call(..)),
+                        target_mut,
                     },
                     data,
                 ));
             },
-            (Some((State::DerefedBorrow { count }, data)), RefOp::AddrOf) if count != 0 => {
-                self.state = Some((State::DerefedBorrow { count: count - 1 }, data));
+            (
+                Some((
+                    State::DerefedBorrow {
+                        count,
+                        required_precedence,
+                        msg,
+                    },
+                    data,
+                )),
+                RefOp::AddrOf,
+            ) if count != 0 => {
+                self.state = Some((
+                    State::DerefedBorrow {
+                        count: count - 1,
+                        required_precedence,
+                        msg,
+                    },
+                    data,
+                ));
             },
 
             (Some((state, data)), _) => report(cx, expr, state, data),
@@ -475,18 +517,28 @@ fn is_linted_explicit_deref_position(parent: Option<Node<'_>>, child_id: HirId,
 
 /// Checks if the given expression is in a position which can be auto-reborrowed.
 /// Note: This is only correct assuming auto-deref is already occurring.
-fn is_auto_reborrow_position(parent: Option<Node<'_>>, child_id: HirId) -> bool {
+fn is_auto_reborrow_position(parent: Option<Node<'_>>) -> bool {
     match parent {
-        Some(Node::Expr(parent)) => match parent.kind {
-            ExprKind::MethodCall(..) => true,
-            ExprKind::Call(callee, _) => callee.hir_id != child_id,
-            _ => false,
-        },
+        Some(Node::Expr(parent)) => matches!(parent.kind, ExprKind::MethodCall(..) | ExprKind::Call(..)),
         Some(Node::Local(_)) => true,
         _ => false,
     }
 }
 
+/// Checks if the given expression is a position which can auto-borrow.
+fn is_auto_borrow_position(parent: Option<Node<'_>>, child_id: HirId) -> bool {
+    if let Some(Node::Expr(parent)) = parent {
+        match parent.kind {
+            ExprKind::MethodCall(_, _, [self_arg, ..], _) => self_arg.hir_id == child_id,
+            ExprKind::Field(..) => true,
+            ExprKind::Call(f, _) => f.hir_id == child_id,
+            _ => false,
+        }
+    } else {
+        false
+    }
+}
+
 /// Adjustments are sometimes made in the parent block rather than the expression itself.
 fn find_adjustments<'tcx>(
     tcx: TyCtxt<'tcx>,
@@ -535,6 +587,7 @@ fn report(cx: &LateContext<'_>, expr: &Expr<'_>, state: State, data: StateData)
         State::DerefMethod {
             ty_changed_count,
             is_final_ufcs,
+            target_mut,
         } => {
             let mut app = Applicability::MachineApplicable;
             let (expr_str, expr_is_macro_call) = snippet_with_context(cx, expr.span, data.span.ctxt(), "..", &mut app);
@@ -549,12 +602,12 @@ fn report(cx: &LateContext<'_>, expr: &Expr<'_>, state: State, data: StateData)
             };
             let addr_of_str = if ty_changed_count < ref_count {
                 // Check if a reborrow from &mut T -> &T is required.
-                if data.target_mut == Mutability::Not && matches!(ty.kind(), ty::Ref(_, _, Mutability::Mut)) {
+                if target_mut == Mutability::Not && matches!(ty.kind(), ty::Ref(_, _, Mutability::Mut)) {
                     "&*"
                 } else {
                     ""
                 }
-            } else if data.target_mut == Mutability::Mut {
+            } else if target_mut == Mutability::Mut {
                 "&mut "
             } else {
                 "&"
@@ -570,7 +623,7 @@ fn report(cx: &LateContext<'_>, expr: &Expr<'_>, state: State, data: StateData)
                 cx,
                 EXPLICIT_DEREF_METHODS,
                 data.span,
-                match data.target_mut {
+                match target_mut {
                     Mutability::Not => "explicit `deref` method call",
                     Mutability::Mut => "explicit `deref_mut` method call",
                 },
@@ -579,19 +632,24 @@ fn report(cx: &LateContext<'_>, expr: &Expr<'_>, state: State, data: StateData)
                 app,
             );
         },
-        State::DerefedBorrow { .. } => {
+        State::DerefedBorrow {
+            required_precedence,
+            msg,
+            ..
+        } => {
             let mut app = Applicability::MachineApplicable;
             let snip = snippet_with_context(cx, expr.span, data.span.ctxt(), "..", &mut app).0;
             span_lint_and_sugg(
                 cx,
                 NEEDLESS_BORROW,
                 data.span,
-                &format!(
-                    "this expression borrows a reference (`{}`) that is immediately dereferenced by the compiler",
-                    cx.typeck_results().expr_ty(expr),
-                ),
+                msg,
                 "change this to",
-                snip.into(),
+                if required_precedence > expr.precedence().order() && !has_enclosing_paren(&snip) {
+                    format!("({})", snip)
+                } else {
+                    snip.into()
+                },
                 app,
             );
         },
diff --git a/clippy_lints/src/implicit_hasher.rs b/clippy_lints/src/implicit_hasher.rs
index 6358228dd47..2818b3e006a 100644
--- a/clippy_lints/src/implicit_hasher.rs
+++ b/clippy_lints/src/implicit_hasher.rs
@@ -179,7 +179,7 @@ impl<'tcx> LateLintPass<'tcx> for ImplicitHasher {
                             )
                             .and_then(|snip| {
                                 let i = snip.find("fn")?;
-                                Some(item.span.lo() + BytePos((i + (&snip[i..]).find('(')?) as u32))
+                                Some(item.span.lo() + BytePos((i + snip[i..].find('(')?) as u32))
                             })
                             .expect("failed to create span for type parameters");
                             Span::new(pos, pos, item.span.ctxt(), item.span.parent())
diff --git a/clippy_lints/src/octal_escapes.rs b/clippy_lints/src/octal_escapes.rs
index e0da12f77fc..b446cf9b6c2 100644
--- a/clippy_lints/src/octal_escapes.rs
+++ b/clippy_lints/src/octal_escapes.rs
@@ -101,7 +101,7 @@ fn check_lit(cx: &EarlyContext<'_>, lit: &Lit, span: Span, is_string: bool) {
         // construct a replacement escape
         // the maximum value is \077, or \x3f, so u8 is sufficient here
         if let Ok(n) = u8::from_str_radix(&contents[from + 1..to], 8) {
-            write!(&mut suggest_1, "\\x{:02x}", n).unwrap();
+            write!(suggest_1, "\\x{:02x}", n).unwrap();
         }
 
         // append the null byte as \x00 and the following digits literally
diff --git a/clippy_utils/src/sugg.rs b/clippy_utils/src/sugg.rs
index 87bc8232dde..be1928045b8 100644
--- a/clippy_utils/src/sugg.rs
+++ b/clippy_utils/src/sugg.rs
@@ -388,7 +388,7 @@ fn binop_to_string(op: AssocOp, lhs: &str, rhs: &str) -> String {
 }
 
 /// Return `true` if `sugg` is enclosed in parenthesis.
-fn has_enclosing_paren(sugg: impl AsRef<str>) -> bool {
+pub fn has_enclosing_paren(sugg: impl AsRef<str>) -> bool {
     let mut chars = sugg.as_ref().chars();
     if chars.next() == Some('(') {
         let mut depth = 1;
diff --git a/tests/ui/bytecount.rs b/tests/ui/bytecount.rs
index c724ee21be3..d3ad26921bf 100644
--- a/tests/ui/bytecount.rs
+++ b/tests/ui/bytecount.rs
@@ -1,3 +1,5 @@
+#![allow(clippy::needless_borrow)]
+
 #[deny(clippy::naive_bytecount)]
 fn main() {
     let x = vec![0_u8; 16];
diff --git a/tests/ui/bytecount.stderr b/tests/ui/bytecount.stderr
index 1dc37fc8b25..68d838c1f82 100644
--- a/tests/ui/bytecount.stderr
+++ b/tests/ui/bytecount.stderr
@@ -1,23 +1,23 @@
 error: you appear to be counting bytes the naive way
-  --> $DIR/bytecount.rs:5:13
+  --> $DIR/bytecount.rs:7:13
    |
 LL |     let _ = x.iter().filter(|&&a| a == 0).count(); // naive byte count
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using the bytecount crate: `bytecount::count(x, 0)`
    |
 note: the lint level is defined here
-  --> $DIR/bytecount.rs:1:8
+  --> $DIR/bytecount.rs:3:8
    |
 LL | #[deny(clippy::naive_bytecount)]
    |        ^^^^^^^^^^^^^^^^^^^^^^^
 
 error: you appear to be counting bytes the naive way
-  --> $DIR/bytecount.rs:7:13
+  --> $DIR/bytecount.rs:9:13
    |
 LL |     let _ = (&x[..]).iter().filter(|&a| *a == 0).count(); // naive byte count
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using the bytecount crate: `bytecount::count((&x[..]), 0)`
 
 error: you appear to be counting bytes the naive way
-  --> $DIR/bytecount.rs:19:13
+  --> $DIR/bytecount.rs:21:13
    |
 LL |     let _ = x.iter().filter(|a| b + 1 == **a).count(); // naive byte count
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using the bytecount crate: `bytecount::count(x, b + 1)`
diff --git a/tests/ui/clone_on_copy.fixed b/tests/ui/clone_on_copy.fixed
index 8d43f64768d..dc062762604 100644
--- a/tests/ui/clone_on_copy.fixed
+++ b/tests/ui/clone_on_copy.fixed
@@ -7,7 +7,8 @@
     clippy::no_effect,
     clippy::unnecessary_operation,
     clippy::vec_init_then_push,
-    clippy::toplevel_ref_arg
+    clippy::toplevel_ref_arg,
+    clippy::needless_borrow
 )]
 
 use std::cell::RefCell;
diff --git a/tests/ui/clone_on_copy.rs b/tests/ui/clone_on_copy.rs
index f15501f7184..8c39d0d55dd 100644
--- a/tests/ui/clone_on_copy.rs
+++ b/tests/ui/clone_on_copy.rs
@@ -7,7 +7,8 @@
     clippy::no_effect,
     clippy::unnecessary_operation,
     clippy::vec_init_then_push,
-    clippy::toplevel_ref_arg
+    clippy::toplevel_ref_arg,
+    clippy::needless_borrow
 )]
 
 use std::cell::RefCell;
diff --git a/tests/ui/clone_on_copy.stderr b/tests/ui/clone_on_copy.stderr
index e7d28b4320b..861543d0aa9 100644
--- a/tests/ui/clone_on_copy.stderr
+++ b/tests/ui/clone_on_copy.stderr
@@ -1,5 +1,5 @@
 error: using `clone` on type `i32` which implements the `Copy` trait
-  --> $DIR/clone_on_copy.rs:24:5
+  --> $DIR/clone_on_copy.rs:25:5
    |
 LL |     42.clone();
    |     ^^^^^^^^^^ help: try removing the `clone` call: `42`
@@ -7,43 +7,43 @@ LL |     42.clone();
    = note: `-D clippy::clone-on-copy` implied by `-D warnings`
 
 error: using `clone` on type `i32` which implements the `Copy` trait
-  --> $DIR/clone_on_copy.rs:28:5
+  --> $DIR/clone_on_copy.rs:29:5
    |
 LL |     (&42).clone();
    |     ^^^^^^^^^^^^^ help: try dereferencing it: `*(&42)`
 
 error: using `clone` on type `i32` which implements the `Copy` trait
-  --> $DIR/clone_on_copy.rs:31:5
+  --> $DIR/clone_on_copy.rs:32:5
    |
 LL |     rc.borrow().clone();
    |     ^^^^^^^^^^^^^^^^^^^ help: try dereferencing it: `*rc.borrow()`
 
 error: using `clone` on type `u32` which implements the `Copy` trait
-  --> $DIR/clone_on_copy.rs:34:5
+  --> $DIR/clone_on_copy.rs:35:5
    |
 LL |     x.clone().rotate_left(1);
    |     ^^^^^^^^^ help: try removing the `clone` call: `x`
 
 error: using `clone` on type `i32` which implements the `Copy` trait
-  --> $DIR/clone_on_copy.rs:48:5
+  --> $DIR/clone_on_copy.rs:49:5
    |
 LL |     m!(42).clone();
    |     ^^^^^^^^^^^^^^ help: try removing the `clone` call: `m!(42)`
 
 error: using `clone` on type `[u32; 2]` which implements the `Copy` trait
-  --> $DIR/clone_on_copy.rs:58:5
+  --> $DIR/clone_on_copy.rs:59:5
    |
 LL |     x.clone()[0];
    |     ^^^^^^^^^ help: try dereferencing it: `(*x)`
 
 error: using `clone` on type `char` which implements the `Copy` trait
-  --> $DIR/clone_on_copy.rs:68:14
+  --> $DIR/clone_on_copy.rs:69:14
    |
 LL |     is_ascii('z'.clone());
    |              ^^^^^^^^^^^ help: try removing the `clone` call: `'z'`
 
 error: using `clone` on type `i32` which implements the `Copy` trait
-  --> $DIR/clone_on_copy.rs:72:14
+  --> $DIR/clone_on_copy.rs:73:14
    |
 LL |     vec.push(42.clone());
    |              ^^^^^^^^^^ help: try removing the `clone` call: `42`
diff --git a/tests/ui/duration_subsec.fixed b/tests/ui/duration_subsec.fixed
index ee5c7863eff..d92b8998e88 100644
--- a/tests/ui/duration_subsec.fixed
+++ b/tests/ui/duration_subsec.fixed
@@ -1,5 +1,5 @@
 // run-rustfix
-#![allow(dead_code)]
+#![allow(dead_code, clippy::needless_borrow)]
 #![warn(clippy::duration_subsec)]
 
 use std::time::Duration;
diff --git a/tests/ui/duration_subsec.rs b/tests/ui/duration_subsec.rs
index 3c9d2a28621..08da804996d 100644
--- a/tests/ui/duration_subsec.rs
+++ b/tests/ui/duration_subsec.rs
@@ -1,5 +1,5 @@
 // run-rustfix
-#![allow(dead_code)]
+#![allow(dead_code, clippy::needless_borrow)]
 #![warn(clippy::duration_subsec)]
 
 use std::time::Duration;
diff --git a/tests/ui/eta.fixed b/tests/ui/eta.fixed
index f938f710688..618f80cdcf8 100644
--- a/tests/ui/eta.fixed
+++ b/tests/ui/eta.fixed
@@ -5,13 +5,10 @@
     clippy::no_effect,
     clippy::redundant_closure_call,
     clippy::needless_pass_by_value,
-    clippy::option_map_unit_fn
-)]
-#![warn(
-    clippy::redundant_closure,
-    clippy::redundant_closure_for_method_calls,
+    clippy::option_map_unit_fn,
     clippy::needless_borrow
 )]
+#![warn(clippy::redundant_closure, clippy::redundant_closure_for_method_calls)]
 
 use std::path::{Path, PathBuf};
 
@@ -34,7 +31,7 @@ fn main() {
     Some(1).map(closure_mac!()); // don't lint closure in macro expansion
     let _: Option<Vec<u8>> = true.then(std::vec::Vec::new); // special case vec!
     let d = Some(1u8).map(|a| foo(foo2(a))); //is adjusted?
-    all(&[1, 2, 3], &2, below); //is adjusted
+    all(&[1, 2, 3], &&2, below); //is adjusted
     unsafe {
         Some(1u8).map(|a| unsafe_fn(a)); // unsafe fn
     }
diff --git a/tests/ui/eta.rs b/tests/ui/eta.rs
index 075bbc74922..a759e6eb514 100644
--- a/tests/ui/eta.rs
+++ b/tests/ui/eta.rs
@@ -5,13 +5,10 @@
     clippy::no_effect,
     clippy::redundant_closure_call,
     clippy::needless_pass_by_value,
-    clippy::option_map_unit_fn
-)]
-#![warn(
-    clippy::redundant_closure,
-    clippy::redundant_closure_for_method_calls,
+    clippy::option_map_unit_fn,
     clippy::needless_borrow
 )]
+#![warn(clippy::redundant_closure, clippy::redundant_closure_for_method_calls)]
 
 use std::path::{Path, PathBuf};
 
diff --git a/tests/ui/eta.stderr b/tests/ui/eta.stderr
index 8092f04c3fc..cda84982c9b 100644
--- a/tests/ui/eta.stderr
+++ b/tests/ui/eta.stderr
@@ -1,5 +1,5 @@
 error: redundant closure
-  --> $DIR/eta.rs:31:27
+  --> $DIR/eta.rs:28:27
    |
 LL |     let a = Some(1u8).map(|a| foo(a));
    |                           ^^^^^^^^^^ help: replace the closure with the function itself: `foo`
@@ -7,45 +7,37 @@ LL |     let a = Some(1u8).map(|a| foo(a));
    = note: `-D clippy::redundant-closure` implied by `-D warnings`
 
 error: redundant closure
-  --> $DIR/eta.rs:35:40
+  --> $DIR/eta.rs:32:40
    |
 LL |     let _: Option<Vec<u8>> = true.then(|| vec![]); // special case vec!
    |                                        ^^^^^^^^^ help: replace the closure with `Vec::new`: `std::vec::Vec::new`
 
 error: redundant closure
-  --> $DIR/eta.rs:36:35
+  --> $DIR/eta.rs:33:35
    |
 LL |     let d = Some(1u8).map(|a| foo((|b| foo2(b))(a))); //is adjusted?
    |                                   ^^^^^^^^^^^^^ help: replace the closure with the function itself: `foo2`
 
-error: this expression borrows a reference (`&u8`) that is immediately dereferenced by the compiler
-  --> $DIR/eta.rs:37:21
-   |
-LL |     all(&[1, 2, 3], &&2, |x, y| below(x, y)); //is adjusted
-   |                     ^^^ help: change this to: `&2`
-   |
-   = note: `-D clippy::needless-borrow` implied by `-D warnings`
-
 error: redundant closure
-  --> $DIR/eta.rs:37:26
+  --> $DIR/eta.rs:34:26
    |
 LL |     all(&[1, 2, 3], &&2, |x, y| below(x, y)); //is adjusted
    |                          ^^^^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `below`
 
 error: redundant closure
-  --> $DIR/eta.rs:43:27
+  --> $DIR/eta.rs:40:27
    |
 LL |     let e = Some(1u8).map(|a| divergent(a));
    |                           ^^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `divergent`
 
 error: redundant closure
-  --> $DIR/eta.rs:44:27
+  --> $DIR/eta.rs:41:27
    |
 LL |     let e = Some(1u8).map(|a| generic(a));
    |                           ^^^^^^^^^^^^^^ help: replace the closure with the function itself: `generic`
 
 error: redundant closure
-  --> $DIR/eta.rs:90:51
+  --> $DIR/eta.rs:87:51
    |
 LL |     let e = Some(TestStruct { some_ref: &i }).map(|a| a.foo());
    |                                                   ^^^^^^^^^^^ help: replace the closure with the method itself: `TestStruct::foo`
@@ -53,82 +45,82 @@ LL |     let e = Some(TestStruct { some_ref: &i }).map(|a| a.foo());
    = note: `-D clippy::redundant-closure-for-method-calls` implied by `-D warnings`
 
 error: redundant closure
-  --> $DIR/eta.rs:91:51
+  --> $DIR/eta.rs:88:51
    |
 LL |     let e = Some(TestStruct { some_ref: &i }).map(|a| a.trait_foo());
    |                                                   ^^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `TestTrait::trait_foo`
 
 error: redundant closure
-  --> $DIR/eta.rs:93:42
+  --> $DIR/eta.rs:90:42
    |
 LL |     let e = Some(&mut vec![1, 2, 3]).map(|v| v.clear());
    |                                          ^^^^^^^^^^^^^ help: replace the closure with the method itself: `std::vec::Vec::clear`
 
 error: redundant closure
-  --> $DIR/eta.rs:97:29
+  --> $DIR/eta.rs:94:29
    |
 LL |     let e = Some("str").map(|s| s.to_string());
    |                             ^^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `std::string::ToString::to_string`
 
 error: redundant closure
-  --> $DIR/eta.rs:98:27
+  --> $DIR/eta.rs:95:27
    |
 LL |     let e = Some('a').map(|s| s.to_uppercase());
    |                           ^^^^^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `char::to_uppercase`
 
 error: redundant closure
-  --> $DIR/eta.rs:100:65
+  --> $DIR/eta.rs:97:65
    |
 LL |     let e: std::vec::Vec<char> = vec!['a', 'b', 'c'].iter().map(|c| c.to_ascii_uppercase()).collect();
    |                                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `char::to_ascii_uppercase`
 
 error: redundant closure
-  --> $DIR/eta.rs:163:22
+  --> $DIR/eta.rs:160:22
    |
 LL |     requires_fn_once(|| x());
    |                      ^^^^^^ help: replace the closure with the function itself: `x`
 
 error: redundant closure
-  --> $DIR/eta.rs:170:27
+  --> $DIR/eta.rs:167:27
    |
 LL |     let a = Some(1u8).map(|a| foo_ptr(a));
    |                           ^^^^^^^^^^^^^^ help: replace the closure with the function itself: `foo_ptr`
 
 error: redundant closure
-  --> $DIR/eta.rs:175:27
+  --> $DIR/eta.rs:172:27
    |
 LL |     let a = Some(1u8).map(|a| closure(a));
    |                           ^^^^^^^^^^^^^^ help: replace the closure with the function itself: `closure`
 
 error: redundant closure
-  --> $DIR/eta.rs:207:28
+  --> $DIR/eta.rs:204:28
    |
 LL |     x.into_iter().for_each(|x| add_to_res(x));
    |                            ^^^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `&mut add_to_res`
 
 error: redundant closure
-  --> $DIR/eta.rs:208:28
+  --> $DIR/eta.rs:205:28
    |
 LL |     y.into_iter().for_each(|x| add_to_res(x));
    |                            ^^^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `&mut add_to_res`
 
 error: redundant closure
-  --> $DIR/eta.rs:209:28
+  --> $DIR/eta.rs:206:28
    |
 LL |     z.into_iter().for_each(|x| add_to_res(x));
    |                            ^^^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `add_to_res`
 
 error: redundant closure
-  --> $DIR/eta.rs:216:21
+  --> $DIR/eta.rs:213:21
    |
 LL |         Some(1).map(|n| closure(n));
    |                     ^^^^^^^^^^^^^^ help: replace the closure with the function itself: `&mut closure`
 
 error: redundant closure
-  --> $DIR/eta.rs:235:21
+  --> $DIR/eta.rs:232:21
    |
 LL |     map_str_to_path(|s| s.as_ref());
    |                     ^^^^^^^^^^^^^^ help: replace the closure with the method itself: `std::convert::AsRef::as_ref`
 
-error: aborting due to 21 previous errors
+error: aborting due to 20 previous errors
 
diff --git a/tests/ui/for_loop_fixable.fixed b/tests/ui/for_loop_fixable.fixed
index f373e905d05..aa69781d15a 100644
--- a/tests/ui/for_loop_fixable.fixed
+++ b/tests/ui/for_loop_fixable.fixed
@@ -23,7 +23,12 @@ impl Unrelated {
     clippy::iter_next_loop,
     clippy::for_kv_map
 )]
-#[allow(clippy::linkedlist, clippy::unnecessary_mut_passed, clippy::similar_names)]
+#[allow(
+    clippy::linkedlist,
+    clippy::unnecessary_mut_passed,
+    clippy::similar_names,
+    clippy::needless_borrow
+)]
 #[allow(unused_variables)]
 fn main() {
     let mut vec = vec![1, 2, 3, 4];
diff --git a/tests/ui/for_loop_fixable.rs b/tests/ui/for_loop_fixable.rs
index 3814583bb6e..7c063d99511 100644
--- a/tests/ui/for_loop_fixable.rs
+++ b/tests/ui/for_loop_fixable.rs
@@ -23,7 +23,12 @@ impl Unrelated {
     clippy::iter_next_loop,
     clippy::for_kv_map
 )]
-#[allow(clippy::linkedlist, clippy::unnecessary_mut_passed, clippy::similar_names)]
+#[allow(
+    clippy::linkedlist,
+    clippy::unnecessary_mut_passed,
+    clippy::similar_names,
+    clippy::needless_borrow
+)]
 #[allow(unused_variables)]
 fn main() {
     let mut vec = vec![1, 2, 3, 4];
diff --git a/tests/ui/for_loop_fixable.stderr b/tests/ui/for_loop_fixable.stderr
index 009dbe1a0bf..ddfe66d675f 100644
--- a/tests/ui/for_loop_fixable.stderr
+++ b/tests/ui/for_loop_fixable.stderr
@@ -1,5 +1,5 @@
 error: it is more concise to loop over references to containers instead of using explicit iteration methods
-  --> $DIR/for_loop_fixable.rs:38:15
+  --> $DIR/for_loop_fixable.rs:43:15
    |
 LL |     for _v in vec.iter() {}
    |               ^^^^^^^^^^ help: to write this more concisely, try: `&vec`
@@ -7,13 +7,13 @@ LL |     for _v in vec.iter() {}
    = note: `-D clippy::explicit-iter-loop` implied by `-D warnings`
 
 error: it is more concise to loop over references to containers instead of using explicit iteration methods
-  --> $DIR/for_loop_fixable.rs:40:15
+  --> $DIR/for_loop_fixable.rs:45:15
    |
 LL |     for _v in vec.iter_mut() {}
    |               ^^^^^^^^^^^^^^ help: to write this more concisely, try: `&mut vec`
 
 error: it is more concise to loop over containers instead of using explicit iteration methods
-  --> $DIR/for_loop_fixable.rs:43:15
+  --> $DIR/for_loop_fixable.rs:48:15
    |
 LL |     for _v in out_vec.into_iter() {}
    |               ^^^^^^^^^^^^^^^^^^^ help: to write this more concisely, try: `out_vec`
@@ -21,73 +21,73 @@ LL |     for _v in out_vec.into_iter() {}
    = note: `-D clippy::explicit-into-iter-loop` implied by `-D warnings`
 
 error: it is more concise to loop over references to containers instead of using explicit iteration methods
-  --> $DIR/for_loop_fixable.rs:48:15
+  --> $DIR/for_loop_fixable.rs:53:15
    |
 LL |     for _v in [1, 2, 3].iter() {}
    |               ^^^^^^^^^^^^^^^^ help: to write this more concisely, try: `&[1, 2, 3]`
 
 error: it is more concise to loop over references to containers instead of using explicit iteration methods
-  --> $DIR/for_loop_fixable.rs:52:15
+  --> $DIR/for_loop_fixable.rs:57:15
    |
 LL |     for _v in [0; 32].iter() {}
    |               ^^^^^^^^^^^^^^ help: to write this more concisely, try: `&[0; 32]`
 
 error: it is more concise to loop over references to containers instead of using explicit iteration methods
-  --> $DIR/for_loop_fixable.rs:57:15
+  --> $DIR/for_loop_fixable.rs:62:15
    |
 LL |     for _v in ll.iter() {}
    |               ^^^^^^^^^ help: to write this more concisely, try: `&ll`
 
 error: it is more concise to loop over references to containers instead of using explicit iteration methods
-  --> $DIR/for_loop_fixable.rs:60:15
+  --> $DIR/for_loop_fixable.rs:65:15
    |
 LL |     for _v in vd.iter() {}
    |               ^^^^^^^^^ help: to write this more concisely, try: `&vd`
 
 error: it is more concise to loop over references to containers instead of using explicit iteration methods
-  --> $DIR/for_loop_fixable.rs:63:15
+  --> $DIR/for_loop_fixable.rs:68:15
    |
 LL |     for _v in bh.iter() {}
    |               ^^^^^^^^^ help: to write this more concisely, try: `&bh`
 
 error: it is more concise to loop over references to containers instead of using explicit iteration methods
-  --> $DIR/for_loop_fixable.rs:66:15
+  --> $DIR/for_loop_fixable.rs:71:15
    |
 LL |     for _v in hm.iter() {}
    |               ^^^^^^^^^ help: to write this more concisely, try: `&hm`
 
 error: it is more concise to loop over references to containers instead of using explicit iteration methods
-  --> $DIR/for_loop_fixable.rs:69:15
+  --> $DIR/for_loop_fixable.rs:74:15
    |
 LL |     for _v in bt.iter() {}
    |               ^^^^^^^^^ help: to write this more concisely, try: `&bt`
 
 error: it is more concise to loop over references to containers instead of using explicit iteration methods
-  --> $DIR/for_loop_fixable.rs:72:15
+  --> $DIR/for_loop_fixable.rs:77:15
    |
 LL |     for _v in hs.iter() {}
    |               ^^^^^^^^^ help: to write this more concisely, try: `&hs`
 
 error: it is more concise to loop over references to containers instead of using explicit iteration methods
-  --> $DIR/for_loop_fixable.rs:75:15
+  --> $DIR/for_loop_fixable.rs:80:15
    |
 LL |     for _v in bs.iter() {}
    |               ^^^^^^^^^ help: to write this more concisely, try: `&bs`
 
 error: it is more concise to loop over containers instead of using explicit iteration methods
-  --> $DIR/for_loop_fixable.rs:250:18
+  --> $DIR/for_loop_fixable.rs:255:18
    |
 LL |         for i in iterator.into_iter() {
    |                  ^^^^^^^^^^^^^^^^^^^^ help: to write this more concisely, try: `iterator`
 
 error: it is more concise to loop over references to containers instead of using explicit iteration methods
-  --> $DIR/for_loop_fixable.rs:270:18
+  --> $DIR/for_loop_fixable.rs:275:18
    |
 LL |         for _ in t.into_iter() {}
    |                  ^^^^^^^^^^^^^ help: to write this more concisely, try: `&t`
 
 error: it is more concise to loop over containers instead of using explicit iteration methods
-  --> $DIR/for_loop_fixable.rs:272:18
+  --> $DIR/for_loop_fixable.rs:277:18
    |
 LL |         for _ in r.into_iter() {}
    |                  ^^^^^^^^^^^^^ help: to write this more concisely, try: `r`
diff --git a/tests/ui/needless_borrow.fixed b/tests/ui/needless_borrow.fixed
index 2a87b520ce5..b856f1375d3 100644
--- a/tests/ui/needless_borrow.fixed
+++ b/tests/ui/needless_borrow.fixed
@@ -62,6 +62,16 @@ fn main() {
     };
 
     *x = 5;
+
+    let s = String::new();
+    let _ = s.len();
+    let _ = s.capacity();
+    let _ = s.capacity();
+
+    let x = (1, 2);
+    let _ = x.0;
+    let x = &x as *const (i32, i32);
+    let _ = unsafe { (*x).0 };
 }
 
 #[allow(clippy::needless_borrowed_reference)]
diff --git a/tests/ui/needless_borrow.rs b/tests/ui/needless_borrow.rs
index 4a98350711f..0bfe222a3dc 100644
--- a/tests/ui/needless_borrow.rs
+++ b/tests/ui/needless_borrow.rs
@@ -62,6 +62,16 @@ fn main() {
     };
 
     *x = 5;
+
+    let s = String::new();
+    let _ = (&s).len();
+    let _ = (&s).capacity();
+    let _ = (&&s).capacity();
+
+    let x = (1, 2);
+    let _ = (&x).0;
+    let x = &x as *const (i32, i32);
+    let _ = unsafe { (&*x).0 };
 }
 
 #[allow(clippy::needless_borrowed_reference)]
diff --git a/tests/ui/needless_borrow.stderr b/tests/ui/needless_borrow.stderr
index 2211f957982..e67718879ec 100644
--- a/tests/ui/needless_borrow.stderr
+++ b/tests/ui/needless_borrow.stderr
@@ -1,4 +1,18 @@
-error: this expression borrows a reference (`&i32`) that is immediately dereferenced by the compiler
+error: creating a reference that is immediately dereferenced
+  --> $DIR/needless_borrow.rs:72:13
+   |
+LL |     let _ = (&x).0;
+   |             ^^^^ help: try this: `x`
+   |
+   = note: `-D clippy::ref-in-deref` implied by `-D warnings`
+
+error: creating a reference that is immediately dereferenced
+  --> $DIR/needless_borrow.rs:74:22
+   |
+LL |     let _ = unsafe { (&*x).0 };
+   |                      ^^^^^ help: try this: `(*x)`
+
+error: this expression creates a reference which is immediately dereferenced by the compiler
   --> $DIR/needless_borrow.rs:9:15
    |
 LL |     let _ = x(&&a); // warn
@@ -6,83 +20,113 @@ LL |     let _ = x(&&a); // warn
    |
    = note: `-D clippy::needless-borrow` implied by `-D warnings`
 
-error: this expression borrows a reference (`&mut i32`) that is immediately dereferenced by the compiler
+error: this expression creates a reference which is immediately dereferenced by the compiler
   --> $DIR/needless_borrow.rs:13:13
    |
 LL |     mut_ref(&mut &mut b); // warn
    |             ^^^^^^^^^^^ help: change this to: `&mut b`
 
-error: this expression borrows a reference (`&i32`) that is immediately dereferenced by the compiler
+error: this expression creates a reference which is immediately dereferenced by the compiler
   --> $DIR/needless_borrow.rs:25:13
    |
 LL |             &&a
    |             ^^^ help: change this to: `&a`
 
-error: this expression borrows a reference (`&i32`) that is immediately dereferenced by the compiler
+error: this expression creates a reference which is immediately dereferenced by the compiler
   --> $DIR/needless_borrow.rs:27:15
    |
 LL |         46 => &&a,
    |               ^^^ help: change this to: `&a`
 
-error: this expression borrows a reference (`&i32`) that is immediately dereferenced by the compiler
+error: this expression creates a reference which is immediately dereferenced by the compiler
   --> $DIR/needless_borrow.rs:33:27
    |
 LL |                     break &ref_a;
    |                           ^^^^^^ help: change this to: `ref_a`
 
-error: this expression borrows a reference (`&i32`) that is immediately dereferenced by the compiler
+error: this expression creates a reference which is immediately dereferenced by the compiler
   --> $DIR/needless_borrow.rs:40:15
    |
 LL |     let _ = x(&&&a);
    |               ^^^^ help: change this to: `&a`
 
-error: this expression borrows a reference (`&i32`) that is immediately dereferenced by the compiler
+error: this expression creates a reference which is immediately dereferenced by the compiler
   --> $DIR/needless_borrow.rs:41:15
    |
 LL |     let _ = x(&mut &&a);
    |               ^^^^^^^^ help: change this to: `&a`
 
-error: this expression borrows a reference (`&mut i32`) that is immediately dereferenced by the compiler
+error: this expression creates a reference which is immediately dereferenced by the compiler
   --> $DIR/needless_borrow.rs:42:15
    |
 LL |     let _ = x(&&&mut b);
    |               ^^^^^^^^ help: change this to: `&mut b`
 
-error: this expression borrows a reference (`&i32`) that is immediately dereferenced by the compiler
+error: this expression creates a reference which is immediately dereferenced by the compiler
   --> $DIR/needless_borrow.rs:43:15
    |
 LL |     let _ = x(&&ref_a);
    |               ^^^^^^^ help: change this to: `ref_a`
 
-error: this expression borrows a reference (`&mut i32`) that is immediately dereferenced by the compiler
+error: this expression creates a reference which is immediately dereferenced by the compiler
   --> $DIR/needless_borrow.rs:46:11
    |
 LL |         x(&b);
    |           ^^ help: change this to: `b`
 
-error: this expression borrows a reference (`&mut i32`) that is immediately dereferenced by the compiler
+error: this expression creates a reference which is immediately dereferenced by the compiler
   --> $DIR/needless_borrow.rs:53:13
    |
 LL |     mut_ref(&mut x);
    |             ^^^^^^ help: change this to: `x`
 
-error: this expression borrows a reference (`&mut i32`) that is immediately dereferenced by the compiler
+error: this expression creates a reference which is immediately dereferenced by the compiler
   --> $DIR/needless_borrow.rs:54:13
    |
 LL |     mut_ref(&mut &mut x);
    |             ^^^^^^^^^^^ help: change this to: `x`
 
-error: this expression borrows a reference (`&mut i32`) that is immediately dereferenced by the compiler
+error: this expression creates a reference which is immediately dereferenced by the compiler
   --> $DIR/needless_borrow.rs:55:23
    |
 LL |     let y: &mut i32 = &mut x;
    |                       ^^^^^^ help: change this to: `x`
 
-error: this expression borrows a reference (`&mut i32`) that is immediately dereferenced by the compiler
+error: this expression creates a reference which is immediately dereferenced by the compiler
   --> $DIR/needless_borrow.rs:56:23
    |
 LL |     let y: &mut i32 = &mut &mut x;
    |                       ^^^^^^^^^^^ help: change this to: `x`
 
-error: aborting due to 14 previous errors
+error: this expression borrows a value the compiler would automatically borrow
+  --> $DIR/needless_borrow.rs:67:13
+   |
+LL |     let _ = (&s).len();
+   |             ^^^^ help: change this to: `s`
+
+error: this expression borrows a value the compiler would automatically borrow
+  --> $DIR/needless_borrow.rs:68:13
+   |
+LL |     let _ = (&s).capacity();
+   |             ^^^^ help: change this to: `s`
+
+error: this expression creates a reference which is immediately dereferenced by the compiler
+  --> $DIR/needless_borrow.rs:69:13
+   |
+LL |     let _ = (&&s).capacity();
+   |             ^^^^^ help: change this to: `s`
+
+error: this expression borrows a value the compiler would automatically borrow
+  --> $DIR/needless_borrow.rs:72:13
+   |
+LL |     let _ = (&x).0;
+   |             ^^^^ help: change this to: `x`
+
+error: this expression borrows a value the compiler would automatically borrow
+  --> $DIR/needless_borrow.rs:74:22
+   |
+LL |     let _ = unsafe { (&*x).0 };
+   |                      ^^^^^ help: change this to: `(*x)`
+
+error: aborting due to 21 previous errors
 
diff --git a/tests/ui/useless_asref.fixed b/tests/ui/useless_asref.fixed
index e356f13d087..e431661d180 100644
--- a/tests/ui/useless_asref.fixed
+++ b/tests/ui/useless_asref.fixed
@@ -67,7 +67,7 @@ fn not_ok() {
         foo_rslice(mrrrrrslice);
         foo_rslice(mrrrrrslice);
     }
-    #[allow(unused_parens, clippy::double_parens)]
+    #[allow(unused_parens, clippy::double_parens, clippy::needless_borrow)]
     foo_rrrrmr((&&&&MoreRef));
 
     generic_not_ok(mrslice);
diff --git a/tests/ui/useless_asref.rs b/tests/ui/useless_asref.rs
index 2a80291f5d8..6ae931d7aa4 100644
--- a/tests/ui/useless_asref.rs
+++ b/tests/ui/useless_asref.rs
@@ -67,7 +67,7 @@ fn not_ok() {
         foo_rslice(mrrrrrslice.as_ref());
         foo_rslice(mrrrrrslice);
     }
-    #[allow(unused_parens, clippy::double_parens)]
+    #[allow(unused_parens, clippy::double_parens, clippy::needless_borrow)]
     foo_rrrrmr((&&&&MoreRef).as_ref());
 
     generic_not_ok(mrslice);
diff --git a/tests/ui/write_literal.rs b/tests/ui/write_literal.rs
index 0a127858def..44669174411 100644
--- a/tests/ui/write_literal.rs
+++ b/tests/ui/write_literal.rs
@@ -7,37 +7,37 @@ fn main() {
     let mut v = Vec::new();
 
     // these should be fine
-    write!(&mut v, "Hello");
-    writeln!(&mut v, "Hello");
+    write!(v, "Hello");
+    writeln!(v, "Hello");
     let world = "world";
-    writeln!(&mut v, "Hello {}", world);
-    writeln!(&mut v, "Hello {world}", world = world);
-    writeln!(&mut v, "3 in hex is {:X}", 3);
-    writeln!(&mut v, "2 + 1 = {:.4}", 3);
-    writeln!(&mut v, "2 + 1 = {:5.4}", 3);
-    writeln!(&mut v, "Debug test {:?}", "hello, world");
-    writeln!(&mut v, "{0:8} {1:>8}", "hello", "world");
-    writeln!(&mut v, "{1:8} {0:>8}", "hello", "world");
-    writeln!(&mut v, "{foo:8} {bar:>8}", foo = "hello", bar = "world");
-    writeln!(&mut v, "{bar:8} {foo:>8}", foo = "hello", bar = "world");
-    writeln!(&mut v, "{number:>width$}", number = 1, width = 6);
-    writeln!(&mut v, "{number:>0width$}", number = 1, width = 6);
-    writeln!(&mut v, "{} of {:b} people know binary, the other half doesn't", 1, 2);
-    writeln!(&mut v, "10 / 4 is {}", 2.5);
-    writeln!(&mut v, "2 + 1 = {}", 3);
+    writeln!(v, "Hello {}", world);
+    writeln!(v, "Hello {world}", world = world);
+    writeln!(v, "3 in hex is {:X}", 3);
+    writeln!(v, "2 + 1 = {:.4}", 3);
+    writeln!(v, "2 + 1 = {:5.4}", 3);
+    writeln!(v, "Debug test {:?}", "hello, world");
+    writeln!(v, "{0:8} {1:>8}", "hello", "world");
+    writeln!(v, "{1:8} {0:>8}", "hello", "world");
+    writeln!(v, "{foo:8} {bar:>8}", foo = "hello", bar = "world");
+    writeln!(v, "{bar:8} {foo:>8}", foo = "hello", bar = "world");
+    writeln!(v, "{number:>width$}", number = 1, width = 6);
+    writeln!(v, "{number:>0width$}", number = 1, width = 6);
+    writeln!(v, "{} of {:b} people know binary, the other half doesn't", 1, 2);
+    writeln!(v, "10 / 4 is {}", 2.5);
+    writeln!(v, "2 + 1 = {}", 3);
 
     // these should throw warnings
-    write!(&mut v, "Hello {}", "world");
-    writeln!(&mut v, "Hello {} {}", world, "world");
-    writeln!(&mut v, "Hello {}", "world");
+    write!(v, "Hello {}", "world");
+    writeln!(v, "Hello {} {}", world, "world");
+    writeln!(v, "Hello {}", "world");
 
     // positional args don't change the fact
     // that we're using a literal -- this should
     // throw a warning
-    writeln!(&mut v, "{0} {1}", "hello", "world");
-    writeln!(&mut v, "{1} {0}", "hello", "world");
+    writeln!(v, "{0} {1}", "hello", "world");
+    writeln!(v, "{1} {0}", "hello", "world");
 
     // named args shouldn't change anything either
-    writeln!(&mut v, "{foo} {bar}", foo = "hello", bar = "world");
-    writeln!(&mut v, "{bar} {foo}", foo = "hello", bar = "world");
+    writeln!(v, "{foo} {bar}", foo = "hello", bar = "world");
+    writeln!(v, "{bar} {foo}", foo = "hello", bar = "world");
 }
diff --git a/tests/ui/write_literal.stderr b/tests/ui/write_literal.stderr
index e0297c00231..593e9493ec5 100644
--- a/tests/ui/write_literal.stderr
+++ b/tests/ui/write_literal.stderr
@@ -1,134 +1,134 @@
 error: literal with an empty format string
-  --> $DIR/write_literal.rs:30:32
+  --> $DIR/write_literal.rs:30:27
    |
-LL |     write!(&mut v, "Hello {}", "world");
-   |                                ^^^^^^^
+LL |     write!(v, "Hello {}", "world");
+   |                           ^^^^^^^
    |
    = note: `-D clippy::write-literal` implied by `-D warnings`
 help: try this
    |
-LL -     write!(&mut v, "Hello {}", "world");
-LL +     write!(&mut v, "Hello world");
+LL -     write!(v, "Hello {}", "world");
+LL +     write!(v, "Hello world");
    | 
 
 error: literal with an empty format string
-  --> $DIR/write_literal.rs:31:44
+  --> $DIR/write_literal.rs:31:39
    |
-LL |     writeln!(&mut v, "Hello {} {}", world, "world");
-   |                                            ^^^^^^^
+LL |     writeln!(v, "Hello {} {}", world, "world");
+   |                                       ^^^^^^^
    |
 help: try this
    |
-LL -     writeln!(&mut v, "Hello {} {}", world, "world");
-LL +     writeln!(&mut v, "Hello {} world", world);
+LL -     writeln!(v, "Hello {} {}", world, "world");
+LL +     writeln!(v, "Hello {} world", world);
    | 
 
 error: literal with an empty format string
-  --> $DIR/write_literal.rs:32:34
+  --> $DIR/write_literal.rs:32:29
    |
-LL |     writeln!(&mut v, "Hello {}", "world");
-   |                                  ^^^^^^^
+LL |     writeln!(v, "Hello {}", "world");
+   |                             ^^^^^^^
    |
 help: try this
    |
-LL -     writeln!(&mut v, "Hello {}", "world");
-LL +     writeln!(&mut v, "Hello world");
+LL -     writeln!(v, "Hello {}", "world");
+LL +     writeln!(v, "Hello world");
    | 
 
 error: literal with an empty format string
-  --> $DIR/write_literal.rs:37:33
+  --> $DIR/write_literal.rs:37:28
    |
-LL |     writeln!(&mut v, "{0} {1}", "hello", "world");
-   |                                 ^^^^^^^
+LL |     writeln!(v, "{0} {1}", "hello", "world");
+   |                            ^^^^^^^
    |
 help: try this
    |
-LL -     writeln!(&mut v, "{0} {1}", "hello", "world");
-LL +     writeln!(&mut v, "hello {1}", "world");
+LL -     writeln!(v, "{0} {1}", "hello", "world");
+LL +     writeln!(v, "hello {1}", "world");
    | 
 
 error: literal with an empty format string
-  --> $DIR/write_literal.rs:37:42
+  --> $DIR/write_literal.rs:37:37
    |
-LL |     writeln!(&mut v, "{0} {1}", "hello", "world");
-   |                                          ^^^^^^^
+LL |     writeln!(v, "{0} {1}", "hello", "world");
+   |                                     ^^^^^^^
    |
 help: try this
    |
-LL -     writeln!(&mut v, "{0} {1}", "hello", "world");
-LL +     writeln!(&mut v, "{0} world", "hello");
+LL -     writeln!(v, "{0} {1}", "hello", "world");
+LL +     writeln!(v, "{0} world", "hello");
    | 
 
 error: literal with an empty format string
-  --> $DIR/write_literal.rs:38:33
+  --> $DIR/write_literal.rs:38:28
    |
-LL |     writeln!(&mut v, "{1} {0}", "hello", "world");
-   |                                 ^^^^^^^
+LL |     writeln!(v, "{1} {0}", "hello", "world");
+   |                            ^^^^^^^
    |
 help: try this
    |
-LL -     writeln!(&mut v, "{1} {0}", "hello", "world");
-LL +     writeln!(&mut v, "{1} hello", "world");
+LL -     writeln!(v, "{1} {0}", "hello", "world");
+LL +     writeln!(v, "{1} hello", "world");
    | 
 
 error: literal with an empty format string
-  --> $DIR/write_literal.rs:38:42
+  --> $DIR/write_literal.rs:38:37
    |
-LL |     writeln!(&mut v, "{1} {0}", "hello", "world");
-   |                                          ^^^^^^^
+LL |     writeln!(v, "{1} {0}", "hello", "world");
+   |                                     ^^^^^^^
    |
 help: try this
    |
-LL -     writeln!(&mut v, "{1} {0}", "hello", "world");
-LL +     writeln!(&mut v, "world {0}", "hello");
+LL -     writeln!(v, "{1} {0}", "hello", "world");
+LL +     writeln!(v, "world {0}", "hello");
    | 
 
 error: literal with an empty format string
-  --> $DIR/write_literal.rs:41:37
+  --> $DIR/write_literal.rs:41:32
    |
-LL |     writeln!(&mut v, "{foo} {bar}", foo = "hello", bar = "world");
-   |                                     ^^^^^^^^^^^^^
+LL |     writeln!(v, "{foo} {bar}", foo = "hello", bar = "world");
+   |                                ^^^^^^^^^^^^^
    |
 help: try this
    |
-LL -     writeln!(&mut v, "{foo} {bar}", foo = "hello", bar = "world");
-LL +     writeln!(&mut v, "hello {bar}", bar = "world");
+LL -     writeln!(v, "{foo} {bar}", foo = "hello", bar = "world");
+LL +     writeln!(v, "hello {bar}", bar = "world");
    | 
 
 error: literal with an empty format string
-  --> $DIR/write_literal.rs:41:52
+  --> $DIR/write_literal.rs:41:47
    |
-LL |     writeln!(&mut v, "{foo} {bar}", foo = "hello", bar = "world");
-   |                                                    ^^^^^^^^^^^^^
+LL |     writeln!(v, "{foo} {bar}", foo = "hello", bar = "world");
+   |                                               ^^^^^^^^^^^^^
    |
 help: try this
    |
-LL -     writeln!(&mut v, "{foo} {bar}", foo = "hello", bar = "world");
-LL +     writeln!(&mut v, "{foo} world", foo = "hello");
+LL -     writeln!(v, "{foo} {bar}", foo = "hello", bar = "world");
+LL +     writeln!(v, "{foo} world", foo = "hello");
    | 
 
 error: literal with an empty format string
-  --> $DIR/write_literal.rs:42:37
+  --> $DIR/write_literal.rs:42:32
    |
-LL |     writeln!(&mut v, "{bar} {foo}", foo = "hello", bar = "world");
-   |                                     ^^^^^^^^^^^^^
+LL |     writeln!(v, "{bar} {foo}", foo = "hello", bar = "world");
+   |                                ^^^^^^^^^^^^^
    |
 help: try this
    |
-LL -     writeln!(&mut v, "{bar} {foo}", foo = "hello", bar = "world");
-LL +     writeln!(&mut v, "{bar} hello", bar = "world");
+LL -     writeln!(v, "{bar} {foo}", foo = "hello", bar = "world");
+LL +     writeln!(v, "{bar} hello", bar = "world");
    | 
 
 error: literal with an empty format string
-  --> $DIR/write_literal.rs:42:52
+  --> $DIR/write_literal.rs:42:47
    |
-LL |     writeln!(&mut v, "{bar} {foo}", foo = "hello", bar = "world");
-   |                                                    ^^^^^^^^^^^^^
+LL |     writeln!(v, "{bar} {foo}", foo = "hello", bar = "world");
+   |                                               ^^^^^^^^^^^^^
    |
 help: try this
    |
-LL -     writeln!(&mut v, "{bar} {foo}", foo = "hello", bar = "world");
-LL +     writeln!(&mut v, "world {foo}", foo = "hello");
+LL -     writeln!(v, "{bar} {foo}", foo = "hello", bar = "world");
+LL +     writeln!(v, "world {foo}", foo = "hello");
    | 
 
 error: aborting due to 11 previous errors
diff --git a/tests/ui/write_literal_2.rs b/tests/ui/write_literal_2.rs
index f341e8215e1..ba0d7be5eaa 100644
--- a/tests/ui/write_literal_2.rs
+++ b/tests/ui/write_literal_2.rs
@@ -6,20 +6,20 @@ use std::io::Write;
 fn main() {
     let mut v = Vec::new();
 
-    writeln!(&mut v, "{}", "{hello}");
-    writeln!(&mut v, r"{}", r"{hello}");
-    writeln!(&mut v, "{}", '\'');
-    writeln!(&mut v, "{}", '"');
-    writeln!(&mut v, r"{}", '"'); // don't lint
-    writeln!(&mut v, r"{}", '\'');
+    writeln!(v, "{}", "{hello}");
+    writeln!(v, r"{}", r"{hello}");
+    writeln!(v, "{}", '\'');
+    writeln!(v, "{}", '"');
+    writeln!(v, r"{}", '"'); // don't lint
+    writeln!(v, r"{}", '\'');
     writeln!(
-        &mut v,
+        v,
         "some {}",
         "hello \
         world!"
     );
     writeln!(
-        &mut v,
+        v,
         "some {}\
         {} \\ {}",
         "1", "2", "3",
diff --git a/tests/ui/write_literal_2.stderr b/tests/ui/write_literal_2.stderr
index 73c6b885813..fc40fbfa9e2 100644
--- a/tests/ui/write_literal_2.stderr
+++ b/tests/ui/write_literal_2.stderr
@@ -1,62 +1,62 @@
 error: literal with an empty format string
-  --> $DIR/write_literal_2.rs:9:28
+  --> $DIR/write_literal_2.rs:9:23
    |
-LL |     writeln!(&mut v, "{}", "{hello}");
-   |                            ^^^^^^^^^
+LL |     writeln!(v, "{}", "{hello}");
+   |                       ^^^^^^^^^
    |
    = note: `-D clippy::write-literal` implied by `-D warnings`
 help: try this
    |
-LL -     writeln!(&mut v, "{}", "{hello}");
-LL +     writeln!(&mut v, "{{hello}}");
+LL -     writeln!(v, "{}", "{hello}");
+LL +     writeln!(v, "{{hello}}");
    | 
 
 error: literal with an empty format string
-  --> $DIR/write_literal_2.rs:10:29
+  --> $DIR/write_literal_2.rs:10:24
    |
-LL |     writeln!(&mut v, r"{}", r"{hello}");
-   |                             ^^^^^^^^^^
+LL |     writeln!(v, r"{}", r"{hello}");
+   |                        ^^^^^^^^^^
    |
 help: try this
    |
-LL -     writeln!(&mut v, r"{}", r"{hello}");
-LL +     writeln!(&mut v, r"{{hello}}");
+LL -     writeln!(v, r"{}", r"{hello}");
+LL +     writeln!(v, r"{{hello}}");
    | 
 
 error: literal with an empty format string
-  --> $DIR/write_literal_2.rs:11:28
+  --> $DIR/write_literal_2.rs:11:23
    |
-LL |     writeln!(&mut v, "{}", '/'');
-   |                            ^^^^
+LL |     writeln!(v, "{}", '/'');
+   |                       ^^^^
    |
 help: try this
    |
-LL -     writeln!(&mut v, "{}", '/'');
-LL +     writeln!(&mut v, "'");
+LL -     writeln!(v, "{}", '/'');
+LL +     writeln!(v, "'");
    | 
 
 error: literal with an empty format string
-  --> $DIR/write_literal_2.rs:12:28
+  --> $DIR/write_literal_2.rs:12:23
    |
-LL |     writeln!(&mut v, "{}", '"');
-   |                            ^^^
+LL |     writeln!(v, "{}", '"');
+   |                       ^^^
    |
 help: try this
    |
-LL -     writeln!(&mut v, "{}", '"');
-LL +     writeln!(&mut v, "/"");
+LL -     writeln!(v, "{}", '"');
+LL +     writeln!(v, "/"");
    | 
 
 error: literal with an empty format string
-  --> $DIR/write_literal_2.rs:14:29
+  --> $DIR/write_literal_2.rs:14:24
    |
-LL |     writeln!(&mut v, r"{}", '/'');
-   |                             ^^^^
+LL |     writeln!(v, r"{}", '/'');
+   |                        ^^^^
    |
 help: try this
    |
-LL -     writeln!(&mut v, r"{}", '/'');
-LL +     writeln!(&mut v, r"'");
+LL -     writeln!(v, r"{}", '/'');
+LL +     writeln!(v, r"'");
    | 
 
 error: literal with an empty format string
diff --git a/tests/ui/write_with_newline.rs b/tests/ui/write_with_newline.rs
index 1c1b1b58402..446d6914d34 100644
--- a/tests/ui/write_with_newline.rs
+++ b/tests/ui/write_with_newline.rs
@@ -10,50 +10,50 @@ fn main() {
     let mut v = Vec::new();
 
     // These should fail
-    write!(&mut v, "Hello\n");
-    write!(&mut v, "Hello {}\n", "world");
-    write!(&mut v, "Hello {} {}\n", "world", "#2");
-    write!(&mut v, "{}\n", 1265);
-    write!(&mut v, "\n");
+    write!(v, "Hello\n");
+    write!(v, "Hello {}\n", "world");
+    write!(v, "Hello {} {}\n", "world", "#2");
+    write!(v, "{}\n", 1265);
+    write!(v, "\n");
 
     // These should be fine
-    write!(&mut v, "");
-    write!(&mut v, "Hello");
-    writeln!(&mut v, "Hello");
-    writeln!(&mut v, "Hello\n");
-    writeln!(&mut v, "Hello {}\n", "world");
-    write!(&mut v, "Issue\n{}", 1265);
-    write!(&mut v, "{}", 1265);
-    write!(&mut v, "\n{}", 1275);
-    write!(&mut v, "\n\n");
-    write!(&mut v, "like eof\n\n");
-    write!(&mut v, "Hello {} {}\n\n", "world", "#2");
-    writeln!(&mut v, "\ndon't\nwarn\nfor\nmultiple\nnewlines\n"); // #3126
-    writeln!(&mut v, "\nbla\n\n"); // #3126
+    write!(v, "");
+    write!(v, "Hello");
+    writeln!(v, "Hello");
+    writeln!(v, "Hello\n");
+    writeln!(v, "Hello {}\n", "world");
+    write!(v, "Issue\n{}", 1265);
+    write!(v, "{}", 1265);
+    write!(v, "\n{}", 1275);
+    write!(v, "\n\n");
+    write!(v, "like eof\n\n");
+    write!(v, "Hello {} {}\n\n", "world", "#2");
+    writeln!(v, "\ndon't\nwarn\nfor\nmultiple\nnewlines\n"); // #3126
+    writeln!(v, "\nbla\n\n"); // #3126
 
     // Escaping
-    write!(&mut v, "\\n"); // #3514
-    write!(&mut v, "\\\n"); // should fail
-    write!(&mut v, "\\\\n");
+    write!(v, "\\n"); // #3514
+    write!(v, "\\\n"); // should fail
+    write!(v, "\\\\n");
 
     // Raw strings
-    write!(&mut v, r"\n"); // #3778
+    write!(v, r"\n"); // #3778
 
     // Literal newlines should also fail
     write!(
-        &mut v,
+        v,
         "
 "
     );
     write!(
-        &mut v,
+        v,
         r"
 "
     );
 
     // Don't warn on CRLF (#4208)
-    write!(&mut v, "\r\n");
-    write!(&mut v, "foo\r\n");
-    write!(&mut v, "\\r\n"); //~ ERROR
-    write!(&mut v, "foo\rbar\n");
+    write!(v, "\r\n");
+    write!(v, "foo\r\n");
+    write!(v, "\\r\n"); //~ ERROR
+    write!(v, "foo\rbar\n");
 }
diff --git a/tests/ui/write_with_newline.stderr b/tests/ui/write_with_newline.stderr
index 186459e50b6..3314a2a6e24 100644
--- a/tests/ui/write_with_newline.stderr
+++ b/tests/ui/write_with_newline.stderr
@@ -1,81 +1,81 @@
 error: using `write!()` with a format string that ends in a single newline
   --> $DIR/write_with_newline.rs:13:5
    |
-LL |     write!(&mut v, "Hello/n");
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |     write!(v, "Hello/n");
+   |     ^^^^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::write-with-newline` implied by `-D warnings`
 help: use `writeln!()` instead
    |
-LL -     write!(&mut v, "Hello/n");
-LL +     writeln!(&mut v, "Hello");
+LL -     write!(v, "Hello/n");
+LL +     writeln!(v, "Hello");
    | 
 
 error: using `write!()` with a format string that ends in a single newline
   --> $DIR/write_with_newline.rs:14:5
    |
-LL |     write!(&mut v, "Hello {}/n", "world");
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |     write!(v, "Hello {}/n", "world");
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: use `writeln!()` instead
    |
-LL -     write!(&mut v, "Hello {}/n", "world");
-LL +     writeln!(&mut v, "Hello {}", "world");
+LL -     write!(v, "Hello {}/n", "world");
+LL +     writeln!(v, "Hello {}", "world");
    | 
 
 error: using `write!()` with a format string that ends in a single newline
   --> $DIR/write_with_newline.rs:15:5
    |
-LL |     write!(&mut v, "Hello {} {}/n", "world", "#2");
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |     write!(v, "Hello {} {}/n", "world", "#2");
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: use `writeln!()` instead
    |
-LL -     write!(&mut v, "Hello {} {}/n", "world", "#2");
-LL +     writeln!(&mut v, "Hello {} {}", "world", "#2");
+LL -     write!(v, "Hello {} {}/n", "world", "#2");
+LL +     writeln!(v, "Hello {} {}", "world", "#2");
    | 
 
 error: using `write!()` with a format string that ends in a single newline
   --> $DIR/write_with_newline.rs:16:5
    |
-LL |     write!(&mut v, "{}/n", 1265);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |     write!(v, "{}/n", 1265);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: use `writeln!()` instead
    |
-LL -     write!(&mut v, "{}/n", 1265);
-LL +     writeln!(&mut v, "{}", 1265);
+LL -     write!(v, "{}/n", 1265);
+LL +     writeln!(v, "{}", 1265);
    | 
 
 error: using `write!()` with a format string that ends in a single newline
   --> $DIR/write_with_newline.rs:17:5
    |
-LL |     write!(&mut v, "/n");
-   |     ^^^^^^^^^^^^^^^^^^^^
+LL |     write!(v, "/n");
+   |     ^^^^^^^^^^^^^^^
    |
 help: use `writeln!()` instead
    |
-LL -     write!(&mut v, "/n");
-LL +     writeln!(&mut v);
+LL -     write!(v, "/n");
+LL +     writeln!(v);
    | 
 
 error: using `write!()` with a format string that ends in a single newline
   --> $DIR/write_with_newline.rs:36:5
    |
-LL |     write!(&mut v, "//n"); // should fail
-   |     ^^^^^^^^^^^^^^^^^^^^^^
+LL |     write!(v, "//n"); // should fail
+   |     ^^^^^^^^^^^^^^^^^
    |
 help: use `writeln!()` instead
    |
-LL -     write!(&mut v, "//n"); // should fail
-LL +     writeln!(&mut v, "/"); // should fail
+LL -     write!(v, "//n"); // should fail
+LL +     writeln!(v, "/"); // should fail
    | 
 
 error: using `write!()` with a format string that ends in a single newline
   --> $DIR/write_with_newline.rs:43:5
    |
 LL | /     write!(
-LL | |         &mut v,
+LL | |         v,
 LL | |         "
 LL | | "
 LL | |     );
@@ -84,7 +84,7 @@ LL | |     );
 help: use `writeln!()` instead
    |
 LL ~     writeln!(
-LL |         &mut v,
+LL |         v,
 LL ~         ""
    |
 
@@ -92,7 +92,7 @@ error: using `write!()` with a format string that ends in a single newline
   --> $DIR/write_with_newline.rs:48:5
    |
 LL | /     write!(
-LL | |         &mut v,
+LL | |         v,
 LL | |         r"
 LL | | "
 LL | |     );
@@ -101,32 +101,32 @@ LL | |     );
 help: use `writeln!()` instead
    |
 LL ~     writeln!(
-LL |         &mut v,
+LL |         v,
 LL ~         r""
    |
 
 error: using `write!()` with a format string that ends in a single newline
   --> $DIR/write_with_newline.rs:57:5
    |
-LL |     write!(&mut v, "/r/n"); //~ ERROR
-   |     ^^^^^^^^^^^^^^^^^^^^^^^
+LL |     write!(v, "/r/n"); //~ ERROR
+   |     ^^^^^^^^^^^^^^^^^^
    |
 help: use `writeln!()` instead
    |
-LL -     write!(&mut v, "/r/n"); //~ ERROR
-LL +     writeln!(&mut v, "/r"); //~ ERROR
+LL -     write!(v, "/r/n"); //~ ERROR
+LL +     writeln!(v, "/r"); //~ ERROR
    | 
 
 error: using `write!()` with a format string that ends in a single newline
   --> $DIR/write_with_newline.rs:58:5
    |
-LL |     write!(&mut v, "foo/rbar/n");
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |     write!(v, "foo/rbar/n");
+   |     ^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: use `writeln!()` instead
    |
-LL -     write!(&mut v, "foo/rbar/n");
-LL +     writeln!(&mut v, "foo/rbar");
+LL -     write!(v, "foo/rbar/n");
+LL +     writeln!(v, "foo/rbar");
    | 
 
 error: aborting due to 10 previous errors
diff --git a/tests/ui/writeln_empty_string.fixed b/tests/ui/writeln_empty_string.fixed
index c3ac15b0375..e7d94acd130 100644
--- a/tests/ui/writeln_empty_string.fixed
+++ b/tests/ui/writeln_empty_string.fixed
@@ -8,13 +8,13 @@ fn main() {
     let mut v = Vec::new();
 
     // These should fail
-    writeln!(&mut v);
+    writeln!(v);
 
     let mut suggestion = Vec::new();
-    writeln!(&mut suggestion);
+    writeln!(suggestion);
 
     // These should be fine
-    writeln!(&mut v);
-    writeln!(&mut v, " ");
-    write!(&mut v, "");
+    writeln!(v);
+    writeln!(v, " ");
+    write!(v, "");
 }
diff --git a/tests/ui/writeln_empty_string.rs b/tests/ui/writeln_empty_string.rs
index 9a8894b6c0d..662c62f0211 100644
--- a/tests/ui/writeln_empty_string.rs
+++ b/tests/ui/writeln_empty_string.rs
@@ -8,13 +8,13 @@ fn main() {
     let mut v = Vec::new();
 
     // These should fail
-    writeln!(&mut v, "");
+    writeln!(v, "");
 
     let mut suggestion = Vec::new();
-    writeln!(&mut suggestion, "");
+    writeln!(suggestion, "");
 
     // These should be fine
-    writeln!(&mut v);
-    writeln!(&mut v, " ");
-    write!(&mut v, "");
+    writeln!(v);
+    writeln!(v, " ");
+    write!(v, "");
 }
diff --git a/tests/ui/writeln_empty_string.stderr b/tests/ui/writeln_empty_string.stderr
index 99635229b3e..ac65aadfc0e 100644
--- a/tests/ui/writeln_empty_string.stderr
+++ b/tests/ui/writeln_empty_string.stderr
@@ -1,16 +1,16 @@
-error: using `writeln!(&mut v, "")`
+error: using `writeln!(v, "")`
   --> $DIR/writeln_empty_string.rs:11:5
    |
-LL |     writeln!(&mut v, "");
-   |     ^^^^^^^^^^^^^^^^^^^^ help: replace it with: `writeln!(&mut v)`
+LL |     writeln!(v, "");
+   |     ^^^^^^^^^^^^^^^ help: replace it with: `writeln!(v)`
    |
    = note: `-D clippy::writeln-empty-string` implied by `-D warnings`
 
-error: using `writeln!(&mut suggestion, "")`
+error: using `writeln!(suggestion, "")`
   --> $DIR/writeln_empty_string.rs:14:5
    |
-LL |     writeln!(&mut suggestion, "");
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `writeln!(&mut suggestion)`
+LL |     writeln!(suggestion, "");
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `writeln!(suggestion)`
 
 error: aborting due to 2 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From c61514086dd6727874a1046e7cd54f028283a270 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Tue, 11 Jan 2022 19:44:33 -0500
Subject: Subsume `ref_in_deref` into `needless_borrow`

---
 CHANGELOG.md                                       |  1 -
 clippy_lints/src/lib.register_all.rs               |  1 -
 clippy_lints/src/lib.register_complexity.rs        |  1 -
 clippy_lints/src/lib.register_lints.rs             |  1 -
 clippy_lints/src/lib.rs                            |  2 +-
 clippy_lints/src/reference.rs                      | 57 ----------------------
 tests/ui/borrow_interior_mutable_const/others.rs   |  6 +--
 .../ui/borrow_interior_mutable_const/others.stderr | 28 +++++------
 tests/ui/explicit_deref_methods.fixed              |  2 +-
 tests/ui/explicit_deref_methods.rs                 |  2 +-
 tests/ui/format.fixed                              |  7 ++-
 tests/ui/format.rs                                 |  7 ++-
 tests/ui/format.stderr                             | 34 ++++++-------
 tests/ui/needless_borrow.stderr                    | 16 +-----
 tests/ui/redundant_pattern_matching_option.fixed   |  2 +-
 tests/ui/redundant_pattern_matching_option.rs      |  2 +-
 tests/ui/rename.fixed                              |  1 +
 tests/ui/rename.rs                                 |  1 +
 tests/ui/rename.stderr                             | 26 ++++++----
 tests/ui/unnecessary_ref.fixed                     | 23 ---------
 tests/ui/unnecessary_ref.rs                        | 23 ---------
 tests/ui/unnecessary_ref.stderr                    | 22 ---------
 22 files changed, 68 insertions(+), 197 deletions(-)
 delete mode 100644 tests/ui/unnecessary_ref.fixed
 delete mode 100644 tests/ui/unnecessary_ref.rs
 delete mode 100644 tests/ui/unnecessary_ref.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 8e65a799ead..d66e6cf7fb6 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3227,7 +3227,6 @@ Released 2018-09-13
 [`redundant_slicing`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_slicing
 [`redundant_static_lifetimes`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_static_lifetimes
 [`ref_binding_to_reference`]: https://rust-lang.github.io/rust-clippy/master/index.html#ref_binding_to_reference
-[`ref_in_deref`]: https://rust-lang.github.io/rust-clippy/master/index.html#ref_in_deref
 [`ref_option_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#ref_option_ref
 [`regex_macro`]: https://rust-lang.github.io/rust-clippy/master/index.html#regex_macro
 [`repeat_once`]: https://rust-lang.github.io/rust-clippy/master/index.html#repeat_once
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 87fd7f99748..4721b7f2b47 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -247,7 +247,6 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(redundant_slicing::REDUNDANT_SLICING),
     LintId::of(redundant_static_lifetimes::REDUNDANT_STATIC_LIFETIMES),
     LintId::of(reference::DEREF_ADDROF),
-    LintId::of(reference::REF_IN_DEREF),
     LintId::of(regex::INVALID_REGEX),
     LintId::of(repeat_once::REPEAT_ONCE),
     LintId::of(returns::LET_AND_RETURN),
diff --git a/clippy_lints/src/lib.register_complexity.rs b/clippy_lints/src/lib.register_complexity.rs
index a21ddf73a11..bd5ff613447 100644
--- a/clippy_lints/src/lib.register_complexity.rs
+++ b/clippy_lints/src/lib.register_complexity.rs
@@ -71,7 +71,6 @@ store.register_group(true, "clippy::complexity", Some("clippy_complexity"), vec!
     LintId::of(redundant_closure_call::REDUNDANT_CLOSURE_CALL),
     LintId::of(redundant_slicing::REDUNDANT_SLICING),
     LintId::of(reference::DEREF_ADDROF),
-    LintId::of(reference::REF_IN_DEREF),
     LintId::of(repeat_once::REPEAT_ONCE),
     LintId::of(strings::STRING_FROM_UTF8_AS_BYTES),
     LintId::of(strlen_on_c_strings::STRLEN_ON_C_STRINGS),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 56146a0fd3a..2d2693832e9 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -423,7 +423,6 @@ store.register_lints(&[
     redundant_static_lifetimes::REDUNDANT_STATIC_LIFETIMES,
     ref_option_ref::REF_OPTION_REF,
     reference::DEREF_ADDROF,
-    reference::REF_IN_DEREF,
     regex::INVALID_REGEX,
     regex::TRIVIAL_REGEX,
     repeat_once::REPEAT_ONCE,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 79e9882fef4..6e825a601b2 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -703,7 +703,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(mut_key::MutableKeyType));
     store.register_late_pass(|| Box::new(modulo_arithmetic::ModuloArithmetic));
     store.register_early_pass(|| Box::new(reference::DerefAddrOf));
-    store.register_early_pass(|| Box::new(reference::RefInDeref));
     store.register_early_pass(|| Box::new(double_parens::DoubleParens));
     store.register_late_pass(|| Box::new(to_string_in_display::ToStringInDisplay::new()));
     store.register_early_pass(|| Box::new(unsafe_removed_from_name::UnsafeNameRemoval));
@@ -935,6 +934,7 @@ pub fn register_renamed(ls: &mut rustc_lint::LintStore) {
     ls.register_renamed("clippy::if_let_some_result", "clippy::match_result_ok");
     ls.register_renamed("clippy::disallowed_type", "clippy::disallowed_types");
     ls.register_renamed("clippy::disallowed_method", "clippy::disallowed_methods");
+    ls.register_renamed("clippy::ref_in_deref", "clippy::needless_borrow");
 
     // uplifted lints
     ls.register_renamed("clippy::invalid_ref", "invalid_value");
diff --git a/clippy_lints/src/reference.rs b/clippy_lints/src/reference.rs
index b2448372370..811a7bb9c15 100644
--- a/clippy_lints/src/reference.rs
+++ b/clippy_lints/src/reference.rs
@@ -1,6 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::{snippet_opt, snippet_with_applicability};
-use clippy_utils::sugg::Sugg;
 use if_chain::if_chain;
 use rustc_ast::ast::{Expr, ExprKind, Mutability, UnOp};
 use rustc_errors::Applicability;
@@ -104,59 +103,3 @@ impl EarlyLintPass for DerefAddrOf {
         }
     }
 }
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for references in expressions that use
-    /// auto dereference.
-    ///
-    /// ### Why is this bad?
-    /// The reference is a no-op and is automatically
-    /// dereferenced by the compiler and makes the code less clear.
-    ///
-    /// ### Example
-    /// ```rust
-    /// struct Point(u32, u32);
-    /// let point = Point(30, 20);
-    /// let x = (&point).0;
-    /// ```
-    /// Use instead:
-    /// ```rust
-    /// # struct Point(u32, u32);
-    /// # let point = Point(30, 20);
-    /// let x = point.0;
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub REF_IN_DEREF,
-    complexity,
-    "Use of reference in auto dereference expression."
-}
-
-declare_lint_pass!(RefInDeref => [REF_IN_DEREF]);
-
-impl EarlyLintPass for RefInDeref {
-    fn check_expr(&mut self, cx: &EarlyContext<'_>, e: &Expr) {
-        if_chain! {
-            if let ExprKind::Field(ref object, _) = e.kind;
-            if let ExprKind::Paren(ref parened) = object.kind;
-            if let ExprKind::AddrOf(_, _, ref inner) = parened.kind;
-            then {
-                let applicability = if inner.span.from_expansion() {
-                    Applicability::MaybeIncorrect
-                } else {
-                    Applicability::MachineApplicable
-                };
-                let sugg = Sugg::ast(cx, inner, "_").maybe_par();
-                span_lint_and_sugg(
-                    cx,
-                    REF_IN_DEREF,
-                    object.span,
-                    "creating a reference that is immediately dereferenced",
-                    "try this",
-                    sugg.to_string(),
-                    applicability,
-                );
-            }
-        }
-    }
-}
diff --git a/tests/ui/borrow_interior_mutable_const/others.rs b/tests/ui/borrow_interior_mutable_const/others.rs
index 4327f12c37c..eefeb1decb6 100644
--- a/tests/ui/borrow_interior_mutable_const/others.rs
+++ b/tests/ui/borrow_interior_mutable_const/others.rs
@@ -1,9 +1,5 @@
 #![warn(clippy::borrow_interior_mutable_const)]
-#![allow(
-    clippy::declare_interior_mutable_const,
-    clippy::ref_in_deref,
-    clippy::needless_borrow
-)]
+#![allow(clippy::declare_interior_mutable_const, clippy::needless_borrow)]
 #![allow(const_item_mutation)]
 
 use std::borrow::Cow;
diff --git a/tests/ui/borrow_interior_mutable_const/others.stderr b/tests/ui/borrow_interior_mutable_const/others.stderr
index f146b97cf61..9a908cf30e9 100644
--- a/tests/ui/borrow_interior_mutable_const/others.stderr
+++ b/tests/ui/borrow_interior_mutable_const/others.stderr
@@ -1,5 +1,5 @@
 error: a `const` item with interior mutability should not be borrowed
-  --> $DIR/others.rs:58:5
+  --> $DIR/others.rs:54:5
    |
 LL |     ATOMIC.store(1, Ordering::SeqCst); //~ ERROR interior mutability
    |     ^^^^^^
@@ -8,7 +8,7 @@ LL |     ATOMIC.store(1, Ordering::SeqCst); //~ ERROR interior mutability
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> $DIR/others.rs:59:16
+  --> $DIR/others.rs:55:16
    |
 LL |     assert_eq!(ATOMIC.load(Ordering::SeqCst), 5); //~ ERROR interior mutability
    |                ^^^^^^
@@ -16,7 +16,7 @@ LL |     assert_eq!(ATOMIC.load(Ordering::SeqCst), 5); //~ ERROR interior mutabi
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> $DIR/others.rs:62:22
+  --> $DIR/others.rs:58:22
    |
 LL |     let _once_ref = &ONCE_INIT; //~ ERROR interior mutability
    |                      ^^^^^^^^^
@@ -24,7 +24,7 @@ LL |     let _once_ref = &ONCE_INIT; //~ ERROR interior mutability
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> $DIR/others.rs:63:25
+  --> $DIR/others.rs:59:25
    |
 LL |     let _once_ref_2 = &&ONCE_INIT; //~ ERROR interior mutability
    |                         ^^^^^^^^^
@@ -32,7 +32,7 @@ LL |     let _once_ref_2 = &&ONCE_INIT; //~ ERROR interior mutability
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> $DIR/others.rs:64:27
+  --> $DIR/others.rs:60:27
    |
 LL |     let _once_ref_4 = &&&&ONCE_INIT; //~ ERROR interior mutability
    |                           ^^^^^^^^^
@@ -40,7 +40,7 @@ LL |     let _once_ref_4 = &&&&ONCE_INIT; //~ ERROR interior mutability
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> $DIR/others.rs:65:26
+  --> $DIR/others.rs:61:26
    |
 LL |     let _once_mut = &mut ONCE_INIT; //~ ERROR interior mutability
    |                          ^^^^^^^^^
@@ -48,7 +48,7 @@ LL |     let _once_mut = &mut ONCE_INIT; //~ ERROR interior mutability
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> $DIR/others.rs:76:14
+  --> $DIR/others.rs:72:14
    |
 LL |     let _ = &ATOMIC_TUPLE; //~ ERROR interior mutability
    |              ^^^^^^^^^^^^
@@ -56,7 +56,7 @@ LL |     let _ = &ATOMIC_TUPLE; //~ ERROR interior mutability
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> $DIR/others.rs:77:14
+  --> $DIR/others.rs:73:14
    |
 LL |     let _ = &ATOMIC_TUPLE.0; //~ ERROR interior mutability
    |              ^^^^^^^^^^^^
@@ -64,7 +64,7 @@ LL |     let _ = &ATOMIC_TUPLE.0; //~ ERROR interior mutability
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> $DIR/others.rs:78:19
+  --> $DIR/others.rs:74:19
    |
 LL |     let _ = &(&&&&ATOMIC_TUPLE).0; //~ ERROR interior mutability
    |                   ^^^^^^^^^^^^
@@ -72,7 +72,7 @@ LL |     let _ = &(&&&&ATOMIC_TUPLE).0; //~ ERROR interior mutability
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> $DIR/others.rs:79:14
+  --> $DIR/others.rs:75:14
    |
 LL |     let _ = &ATOMIC_TUPLE.0[0]; //~ ERROR interior mutability
    |              ^^^^^^^^^^^^
@@ -80,7 +80,7 @@ LL |     let _ = &ATOMIC_TUPLE.0[0]; //~ ERROR interior mutability
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> $DIR/others.rs:80:13
+  --> $DIR/others.rs:76:13
    |
 LL |     let _ = ATOMIC_TUPLE.0[0].load(Ordering::SeqCst); //~ ERROR interior mutability
    |             ^^^^^^^^^^^^
@@ -88,7 +88,7 @@ LL |     let _ = ATOMIC_TUPLE.0[0].load(Ordering::SeqCst); //~ ERROR interior mu
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> $DIR/others.rs:86:13
+  --> $DIR/others.rs:82:13
    |
 LL |     let _ = ATOMIC_TUPLE.0[0]; //~ ERROR interior mutability
    |             ^^^^^^^^^^^^
@@ -96,7 +96,7 @@ LL |     let _ = ATOMIC_TUPLE.0[0]; //~ ERROR interior mutability
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> $DIR/others.rs:91:5
+  --> $DIR/others.rs:87:5
    |
 LL |     CELL.set(2); //~ ERROR interior mutability
    |     ^^^^
@@ -104,7 +104,7 @@ LL |     CELL.set(2); //~ ERROR interior mutability
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> $DIR/others.rs:92:16
+  --> $DIR/others.rs:88:16
    |
 LL |     assert_eq!(CELL.get(), 6); //~ ERROR interior mutability
    |                ^^^^
diff --git a/tests/ui/explicit_deref_methods.fixed b/tests/ui/explicit_deref_methods.fixed
index 48e2aae75d0..3de2a51ffa5 100644
--- a/tests/ui/explicit_deref_methods.fixed
+++ b/tests/ui/explicit_deref_methods.fixed
@@ -1,6 +1,6 @@
 // run-rustfix
 
-#![allow(unused_variables, clippy::clone_double_ref)]
+#![allow(unused_variables, clippy::clone_double_ref, clippy::needless_borrow)]
 #![warn(clippy::explicit_deref_methods)]
 
 use std::ops::{Deref, DerefMut};
diff --git a/tests/ui/explicit_deref_methods.rs b/tests/ui/explicit_deref_methods.rs
index d8c8c0c5ca3..a08d7596422 100644
--- a/tests/ui/explicit_deref_methods.rs
+++ b/tests/ui/explicit_deref_methods.rs
@@ -1,6 +1,6 @@
 // run-rustfix
 
-#![allow(unused_variables, clippy::clone_double_ref)]
+#![allow(unused_variables, clippy::clone_double_ref, clippy::needless_borrow)]
 #![warn(clippy::explicit_deref_methods)]
 
 use std::ops::{Deref, DerefMut};
diff --git a/tests/ui/format.fixed b/tests/ui/format.fixed
index 78d2bfd474e..d08f8f52495 100644
--- a/tests/ui/format.fixed
+++ b/tests/ui/format.fixed
@@ -1,6 +1,11 @@
 // run-rustfix
 
-#![allow(clippy::print_literal, clippy::redundant_clone, clippy::to_string_in_format_args)]
+#![allow(
+    clippy::print_literal,
+    clippy::redundant_clone,
+    clippy::to_string_in_format_args,
+    clippy::needless_borrow
+)]
 #![warn(clippy::useless_format)]
 
 struct Foo(pub String);
diff --git a/tests/ui/format.rs b/tests/ui/format.rs
index 009c1aa216f..4a10b580d26 100644
--- a/tests/ui/format.rs
+++ b/tests/ui/format.rs
@@ -1,6 +1,11 @@
 // run-rustfix
 
-#![allow(clippy::print_literal, clippy::redundant_clone, clippy::to_string_in_format_args)]
+#![allow(
+    clippy::print_literal,
+    clippy::redundant_clone,
+    clippy::to_string_in_format_args,
+    clippy::needless_borrow
+)]
 #![warn(clippy::useless_format)]
 
 struct Foo(pub String);
diff --git a/tests/ui/format.stderr b/tests/ui/format.stderr
index 660be57585e..f25c7fb1ff1 100644
--- a/tests/ui/format.stderr
+++ b/tests/ui/format.stderr
@@ -1,5 +1,5 @@
 error: useless use of `format!`
-  --> $DIR/format.rs:13:5
+  --> $DIR/format.rs:18:5
    |
 LL |     format!("foo");
    |     ^^^^^^^^^^^^^^ help: consider using `.to_string()`: `"foo".to_string()`
@@ -7,19 +7,19 @@ LL |     format!("foo");
    = note: `-D clippy::useless-format` implied by `-D warnings`
 
 error: useless use of `format!`
-  --> $DIR/format.rs:14:5
+  --> $DIR/format.rs:19:5
    |
 LL |     format!("{{}}");
    |     ^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `"{}".to_string()`
 
 error: useless use of `format!`
-  --> $DIR/format.rs:15:5
+  --> $DIR/format.rs:20:5
    |
 LL |     format!("{{}} abc {{}}");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `"{} abc {}".to_string()`
 
 error: useless use of `format!`
-  --> $DIR/format.rs:16:5
+  --> $DIR/format.rs:21:5
    |
 LL | /     format!(
 LL | |         r##"foo {{}}
@@ -34,79 +34,79 @@ LL ~ " bar"##.to_string();
    |
 
 error: useless use of `format!`
-  --> $DIR/format.rs:21:13
+  --> $DIR/format.rs:26:13
    |
 LL |     let _ = format!("");
    |             ^^^^^^^^^^^ help: consider using `String::new()`: `String::new()`
 
 error: useless use of `format!`
-  --> $DIR/format.rs:23:5
+  --> $DIR/format.rs:28:5
    |
 LL |     format!("{}", "foo");
    |     ^^^^^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `"foo".to_string()`
 
 error: useless use of `format!`
-  --> $DIR/format.rs:27:5
+  --> $DIR/format.rs:32:5
    |
 LL |     format!("{:+}", "foo"); // Warn when the format makes no difference.
    |     ^^^^^^^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `"foo".to_string()`
 
 error: useless use of `format!`
-  --> $DIR/format.rs:28:5
+  --> $DIR/format.rs:33:5
    |
 LL |     format!("{:<}", "foo"); // Warn when the format makes no difference.
    |     ^^^^^^^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `"foo".to_string()`
 
 error: useless use of `format!`
-  --> $DIR/format.rs:33:5
+  --> $DIR/format.rs:38:5
    |
 LL |     format!("{}", arg);
    |     ^^^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `arg.to_string()`
 
 error: useless use of `format!`
-  --> $DIR/format.rs:37:5
+  --> $DIR/format.rs:42:5
    |
 LL |     format!("{:+}", arg); // Warn when the format makes no difference.
    |     ^^^^^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `arg.to_string()`
 
 error: useless use of `format!`
-  --> $DIR/format.rs:38:5
+  --> $DIR/format.rs:43:5
    |
 LL |     format!("{:<}", arg); // Warn when the format makes no difference.
    |     ^^^^^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `arg.to_string()`
 
 error: useless use of `format!`
-  --> $DIR/format.rs:65:5
+  --> $DIR/format.rs:70:5
    |
 LL |     format!("{}", 42.to_string());
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `42.to_string()`
 
 error: useless use of `format!`
-  --> $DIR/format.rs:67:5
+  --> $DIR/format.rs:72:5
    |
 LL |     format!("{}", x.display().to_string());
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `x.display().to_string()`
 
 error: useless use of `format!`
-  --> $DIR/format.rs:71:18
+  --> $DIR/format.rs:76:18
    |
 LL |     let _ = Some(format!("{}", a + "bar"));
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `a + "bar"`
 
 error: useless use of `format!`
-  --> $DIR/format.rs:75:22
+  --> $DIR/format.rs:80:22
    |
 LL |     let _s: String = format!("{}", &*v.join("/n"));
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `(&*v.join("/n")).to_string()`
 
 error: useless use of `format!`
-  --> $DIR/format.rs:81:13
+  --> $DIR/format.rs:86:13
    |
 LL |     let _ = format!("{x}");
    |             ^^^^^^^^^^^^^^ help: consider using `.to_string()`: `x.to_string()`
 
 error: useless use of `format!`
-  --> $DIR/format.rs:83:13
+  --> $DIR/format.rs:88:13
    |
 LL |     let _ = format!("{y}", y = x);
    |             ^^^^^^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `x.to_string()`
diff --git a/tests/ui/needless_borrow.stderr b/tests/ui/needless_borrow.stderr
index e67718879ec..b90e8448db0 100644
--- a/tests/ui/needless_borrow.stderr
+++ b/tests/ui/needless_borrow.stderr
@@ -1,17 +1,3 @@
-error: creating a reference that is immediately dereferenced
-  --> $DIR/needless_borrow.rs:72:13
-   |
-LL |     let _ = (&x).0;
-   |             ^^^^ help: try this: `x`
-   |
-   = note: `-D clippy::ref-in-deref` implied by `-D warnings`
-
-error: creating a reference that is immediately dereferenced
-  --> $DIR/needless_borrow.rs:74:22
-   |
-LL |     let _ = unsafe { (&*x).0 };
-   |                      ^^^^^ help: try this: `(*x)`
-
 error: this expression creates a reference which is immediately dereferenced by the compiler
   --> $DIR/needless_borrow.rs:9:15
    |
@@ -128,5 +114,5 @@ error: this expression borrows a value the compiler would automatically borrow
 LL |     let _ = unsafe { (&*x).0 };
    |                      ^^^^^ help: change this to: `(*x)`
 
-error: aborting due to 21 previous errors
+error: aborting due to 19 previous errors
 
diff --git a/tests/ui/redundant_pattern_matching_option.fixed b/tests/ui/redundant_pattern_matching_option.fixed
index cc93859269c..a89845c1dd3 100644
--- a/tests/ui/redundant_pattern_matching_option.fixed
+++ b/tests/ui/redundant_pattern_matching_option.fixed
@@ -81,7 +81,7 @@ const fn issue6067() {
     None::<()>.is_none();
 }
 
-#[allow(clippy::deref_addrof, dead_code)]
+#[allow(clippy::deref_addrof, dead_code, clippy::needless_borrow)]
 fn issue7921() {
     if (&None::<()>).is_none() {}
     if (&None::<()>).is_none() {}
diff --git a/tests/ui/redundant_pattern_matching_option.rs b/tests/ui/redundant_pattern_matching_option.rs
index 280dca40c01..d6f44403487 100644
--- a/tests/ui/redundant_pattern_matching_option.rs
+++ b/tests/ui/redundant_pattern_matching_option.rs
@@ -96,7 +96,7 @@ const fn issue6067() {
     };
 }
 
-#[allow(clippy::deref_addrof, dead_code)]
+#[allow(clippy::deref_addrof, dead_code, clippy::needless_borrow)]
 fn issue7921() {
     if let None = *(&None::<()>) {}
     if let None = *&None::<()> {}
diff --git a/tests/ui/rename.fixed b/tests/ui/rename.fixed
index b9425733a8b..8bddec576ed 100644
--- a/tests/ui/rename.fixed
+++ b/tests/ui/rename.fixed
@@ -54,6 +54,7 @@
 #![warn(clippy::match_result_ok)]
 #![warn(clippy::disallowed_types)]
 #![warn(clippy::disallowed_methods)]
+#![warn(clippy::needless_borrow)]
 // uplifted lints
 #![warn(invalid_value)]
 #![warn(array_into_iter)]
diff --git a/tests/ui/rename.rs b/tests/ui/rename.rs
index 341c003b9df..d2010d71d2c 100644
--- a/tests/ui/rename.rs
+++ b/tests/ui/rename.rs
@@ -54,6 +54,7 @@
 #![warn(clippy::if_let_some_result)]
 #![warn(clippy::disallowed_type)]
 #![warn(clippy::disallowed_method)]
+#![warn(clippy::ref_in_deref)]
 // uplifted lints
 #![warn(clippy::invalid_ref)]
 #![warn(clippy::into_iter_on_array)]
diff --git a/tests/ui/rename.stderr b/tests/ui/rename.stderr
index cdec2808f1d..45cb8b786f5 100644
--- a/tests/ui/rename.stderr
+++ b/tests/ui/rename.stderr
@@ -138,59 +138,65 @@ error: lint `clippy::disallowed_method` has been renamed to `clippy::disallowed_
 LL | #![warn(clippy::disallowed_method)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::disallowed_methods`
 
+error: lint `clippy::ref_in_deref` has been renamed to `clippy::needless_borrow`
+  --> $DIR/rename.rs:57:9
+   |
+LL | #![warn(clippy::ref_in_deref)]
+   |         ^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::needless_borrow`
+
 error: lint `clippy::invalid_ref` has been renamed to `invalid_value`
-  --> $DIR/rename.rs:58:9
+  --> $DIR/rename.rs:59:9
    |
 LL | #![warn(clippy::invalid_ref)]
    |         ^^^^^^^^^^^^^^^^^^^ help: use the new name: `invalid_value`
 
 error: lint `clippy::into_iter_on_array` has been renamed to `array_into_iter`
-  --> $DIR/rename.rs:59:9
+  --> $DIR/rename.rs:60:9
    |
 LL | #![warn(clippy::into_iter_on_array)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `array_into_iter`
 
 error: lint `clippy::unused_label` has been renamed to `unused_labels`
-  --> $DIR/rename.rs:60:9
+  --> $DIR/rename.rs:61:9
    |
 LL | #![warn(clippy::unused_label)]
    |         ^^^^^^^^^^^^^^^^^^^^ help: use the new name: `unused_labels`
 
 error: lint `clippy::drop_bounds` has been renamed to `drop_bounds`
-  --> $DIR/rename.rs:61:9
+  --> $DIR/rename.rs:62:9
    |
 LL | #![warn(clippy::drop_bounds)]
    |         ^^^^^^^^^^^^^^^^^^^ help: use the new name: `drop_bounds`
 
 error: lint `clippy::temporary_cstring_as_ptr` has been renamed to `temporary_cstring_as_ptr`
-  --> $DIR/rename.rs:62:9
+  --> $DIR/rename.rs:63:9
    |
 LL | #![warn(clippy::temporary_cstring_as_ptr)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `temporary_cstring_as_ptr`
 
 error: lint `clippy::panic_params` has been renamed to `non_fmt_panics`
-  --> $DIR/rename.rs:63:9
+  --> $DIR/rename.rs:64:9
    |
 LL | #![warn(clippy::panic_params)]
    |         ^^^^^^^^^^^^^^^^^^^^ help: use the new name: `non_fmt_panics`
 
 error: lint `clippy::unknown_clippy_lints` has been renamed to `unknown_lints`
-  --> $DIR/rename.rs:64:9
+  --> $DIR/rename.rs:65:9
    |
 LL | #![warn(clippy::unknown_clippy_lints)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `unknown_lints`
 
 error: lint `clippy::invalid_atomic_ordering` has been renamed to `invalid_atomic_ordering`
-  --> $DIR/rename.rs:65:9
+  --> $DIR/rename.rs:66:9
    |
 LL | #![warn(clippy::invalid_atomic_ordering)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `invalid_atomic_ordering`
 
 error: lint `clippy::mem_discriminant_non_enum` has been renamed to `enum_intrinsics_non_enums`
-  --> $DIR/rename.rs:66:9
+  --> $DIR/rename.rs:67:9
    |
 LL | #![warn(clippy::mem_discriminant_non_enum)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `enum_intrinsics_non_enums`
 
-error: aborting due to 32 previous errors
+error: aborting due to 33 previous errors
 
diff --git a/tests/ui/unnecessary_ref.fixed b/tests/ui/unnecessary_ref.fixed
deleted file mode 100644
index d927bae976f..00000000000
--- a/tests/ui/unnecessary_ref.fixed
+++ /dev/null
@@ -1,23 +0,0 @@
-// run-rustfix
-
-#![feature(stmt_expr_attributes)]
-#![allow(unused_variables, dead_code)]
-
-struct Outer {
-    inner: u32,
-}
-
-#[deny(clippy::ref_in_deref)]
-fn main() {
-    let outer = Outer { inner: 0 };
-    let inner = outer.inner;
-}
-
-struct Apple;
-impl Apple {
-    fn hello(&self) {}
-}
-struct Package(pub *const Apple);
-fn foobar(package: *const Package) {
-    unsafe { &*(*package).0 }.hello();
-}
diff --git a/tests/ui/unnecessary_ref.rs b/tests/ui/unnecessary_ref.rs
deleted file mode 100644
index 86bfb76ec26..00000000000
--- a/tests/ui/unnecessary_ref.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-// run-rustfix
-
-#![feature(stmt_expr_attributes)]
-#![allow(unused_variables, dead_code)]
-
-struct Outer {
-    inner: u32,
-}
-
-#[deny(clippy::ref_in_deref)]
-fn main() {
-    let outer = Outer { inner: 0 };
-    let inner = (&outer).inner;
-}
-
-struct Apple;
-impl Apple {
-    fn hello(&self) {}
-}
-struct Package(pub *const Apple);
-fn foobar(package: *const Package) {
-    unsafe { &*(&*package).0 }.hello();
-}
diff --git a/tests/ui/unnecessary_ref.stderr b/tests/ui/unnecessary_ref.stderr
deleted file mode 100644
index 436f4bcf738..00000000000
--- a/tests/ui/unnecessary_ref.stderr
+++ /dev/null
@@ -1,22 +0,0 @@
-error: creating a reference that is immediately dereferenced
-  --> $DIR/unnecessary_ref.rs:13:17
-   |
-LL |     let inner = (&outer).inner;
-   |                 ^^^^^^^^ help: try this: `outer`
-   |
-note: the lint level is defined here
-  --> $DIR/unnecessary_ref.rs:10:8
-   |
-LL | #[deny(clippy::ref_in_deref)]
-   |        ^^^^^^^^^^^^^^^^^^^^
-
-error: creating a reference that is immediately dereferenced
-  --> $DIR/unnecessary_ref.rs:22:16
-   |
-LL |     unsafe { &*(&*package).0 }.hello();
-   |                ^^^^^^^^^^^ help: try this: `(*package)`
-   |
-   = note: `-D clippy::ref-in-deref` implied by `-D warnings`
-
-error: aborting due to 2 previous errors
-
-- 
cgit 1.4.1-3-g733a5


From a05276620c67a05b50ad3a28ef143a62e08f12b7 Mon Sep 17 00:00:00 2001
From: dswij <dswijj@gmail.com>
Date: Tue, 18 Jan 2022 18:41:00 +0800
Subject: fix `needless_question_mark` not considering async fn

---
 clippy_lints/src/needless_question_mark.rs | 23 +++++++++++++++++++++--
 tests/ui/needless_question_mark.fixed      | 13 +++++++++++++
 tests/ui/needless_question_mark.rs         | 13 +++++++++++++
 tests/ui/needless_question_mark.stderr     | 14 +++++++++++++-
 4 files changed, 60 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/needless_question_mark.rs b/clippy_lints/src/needless_question_mark.rs
index 0e7ae43ce2d..d4c823d1c1a 100644
--- a/clippy_lints/src/needless_question_mark.rs
+++ b/clippy_lints/src/needless_question_mark.rs
@@ -4,7 +4,7 @@ use clippy_utils::source::snippet;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::LangItem::{OptionSome, ResultOk};
-use rustc_hir::{Body, Expr, ExprKind, LangItem, MatchSource, QPath};
+use rustc_hir::{AsyncGeneratorKind, Block, Body, Expr, ExprKind, GeneratorKind, LangItem, MatchSource, QPath};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::TyS;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -88,7 +88,26 @@ impl LateLintPass<'_> for NeedlessQuestionMark {
     }
 
     fn check_body(&mut self, cx: &LateContext<'_>, body: &'_ Body<'_>) {
-        check(cx, body.value.peel_blocks());
+        if let Some(GeneratorKind::Async(AsyncGeneratorKind::Fn)) = body.generator_kind {
+            if let ExprKind::Block(
+                Block {
+                    expr:
+                        Some(Expr {
+                            kind: ExprKind::DropTemps(async_body),
+                            ..
+                        }),
+                    ..
+                },
+                _,
+            ) = body.value.kind
+            {
+                if let ExprKind::Block(Block { expr: Some(expr), .. }, ..) = async_body.kind {
+                    check(cx, expr);
+                }
+            }
+        } else {
+            check(cx, body.value.peel_blocks());
+        }
     }
 }
 
diff --git a/tests/ui/needless_question_mark.fixed b/tests/ui/needless_question_mark.fixed
index f1fc81aa12b..ba9d15e59d0 100644
--- a/tests/ui/needless_question_mark.fixed
+++ b/tests/ui/needless_question_mark.fixed
@@ -125,3 +125,16 @@ pub fn test2() {
     let x = Some(3);
     let _x = some_and_qmark_in_macro!(x?);
 }
+
+async fn async_option_bad(to: TO) -> Option<usize> {
+    let _ = Some(3);
+    to.magic
+}
+
+async fn async_deref_ref(s: Option<&String>) -> Option<&str> {
+    Some(s?)
+}
+
+async fn async_result_bad(s: TR) -> Result<usize, bool> {
+    s.magic
+}
diff --git a/tests/ui/needless_question_mark.rs b/tests/ui/needless_question_mark.rs
index 44a0c5f61b5..3a6523e8fe8 100644
--- a/tests/ui/needless_question_mark.rs
+++ b/tests/ui/needless_question_mark.rs
@@ -125,3 +125,16 @@ pub fn test2() {
     let x = Some(3);
     let _x = some_and_qmark_in_macro!(x?);
 }
+
+async fn async_option_bad(to: TO) -> Option<usize> {
+    let _ = Some(3);
+    Some(to.magic?)
+}
+
+async fn async_deref_ref(s: Option<&String>) -> Option<&str> {
+    Some(s?)
+}
+
+async fn async_result_bad(s: TR) -> Result<usize, bool> {
+    Ok(s.magic?)
+}
diff --git a/tests/ui/needless_question_mark.stderr b/tests/ui/needless_question_mark.stderr
index 57c3d48c761..f8308e24e77 100644
--- a/tests/ui/needless_question_mark.stderr
+++ b/tests/ui/needless_question_mark.stderr
@@ -77,5 +77,17 @@ LL |     let _x = some_and_qmark_in_macro!(x?);
    |
    = note: this error originates in the macro `some_and_qmark_in_macro` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to 12 previous errors
+error: question mark operator is useless here
+  --> $DIR/needless_question_mark.rs:131:5
+   |
+LL |     Some(to.magic?)
+   |     ^^^^^^^^^^^^^^^ help: try removing question mark and `Some()`: `to.magic`
+
+error: question mark operator is useless here
+  --> $DIR/needless_question_mark.rs:139:5
+   |
+LL |     Ok(s.magic?)
+   |     ^^^^^^^^^^^^ help: try removing question mark and `Ok()`: `s.magic`
+
+error: aborting due to 14 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 0d7273fef6e2d3861afbb65ca70d21b43ac764fe Mon Sep 17 00:00:00 2001
From: Dharma Saputra Wijaya <dswijj@gmail.com>
Date: Tue, 25 Jan 2022 22:19:19 +0800
Subject: fix bad suggestion on `numeric_literal`

---
 clippy_lints/src/casts/unnecessary_cast.rs | 11 +++------
 clippy_utils/src/numeric_literal.rs        |  9 ++++++-
 tests/ui/unnecessary_cast.rs               |  7 ++++++
 tests/ui/unnecessary_cast.stderr           | 38 ++++++++++++++++++++++++++----
 4 files changed, 52 insertions(+), 13 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/unnecessary_cast.rs b/clippy_lints/src/casts/unnecessary_cast.rs
index 1915d990c12..470c8c7ea26 100644
--- a/clippy_lints/src/casts/unnecessary_cast.rs
+++ b/clippy_lints/src/casts/unnecessary_cast.rs
@@ -23,15 +23,14 @@ pub(super) fn check(
 
         if_chain! {
             if let LitKind::Int(n, _) = lit.node;
-            if let Some(src) = snippet_opt(cx, lit.span);
+            if let Some(src) = snippet_opt(cx, cast_expr.span);
             if cast_to.is_floating_point();
             if let Some(num_lit) = NumericLiteral::from_lit_kind(&src, &lit.node);
             let from_nbits = 128 - n.leading_zeros();
             let to_nbits = fp_ty_mantissa_nbits(cast_to);
             if from_nbits != 0 && to_nbits != 0 && from_nbits <= to_nbits && num_lit.is_decimal();
             then {
-                let literal_str = if is_unary_neg(cast_expr) { format!("-{}", num_lit.integer) } else { num_lit.integer.into() };
-                lint_unnecessary_cast(cx, expr, &literal_str, cast_from, cast_to);
+                lint_unnecessary_cast(cx, expr, num_lit.integer, cast_from, cast_to);
                 return true
             }
         }
@@ -48,7 +47,7 @@ pub(super) fn check(
             | LitKind::Float(_, LitFloatType::Suffixed(_))
                 if cast_from.kind() == cast_to.kind() =>
             {
-                if let Some(src) = snippet_opt(cx, lit.span) {
+                if let Some(src) = snippet_opt(cx, cast_expr.span) {
                     if let Some(num_lit) = NumericLiteral::from_lit_kind(&src, &lit.node) {
                         lint_unnecessary_cast(cx, expr, num_lit.integer, cast_from, cast_to);
                     }
@@ -113,7 +112,3 @@ fn fp_ty_mantissa_nbits(typ: Ty<'_>) -> u32 {
         _ => 0,
     }
 }
-
-fn is_unary_neg(expr: &Expr<'_>) -> bool {
-    matches!(expr.kind, ExprKind::Unary(UnOp::Neg, _))
-}
diff --git a/clippy_utils/src/numeric_literal.rs b/clippy_utils/src/numeric_literal.rs
index 68dd1b29845..908ff822712 100644
--- a/clippy_utils/src/numeric_literal.rs
+++ b/clippy_utils/src/numeric_literal.rs
@@ -51,7 +51,14 @@ impl<'a> NumericLiteral<'a> {
     }
 
     pub fn from_lit_kind(src: &'a str, lit_kind: &LitKind) -> Option<NumericLiteral<'a>> {
-        if lit_kind.is_numeric() && src.chars().next().map_or(false, |c| c.is_digit(10)) {
+        let unsigned_src = src.strip_prefix('-').map_or(src, |s| s);
+        if lit_kind.is_numeric()
+            && unsigned_src
+                .trim_start()
+                .chars()
+                .next()
+                .map_or(false, |c| c.is_digit(10))
+        {
             let (unsuffixed, suffix) = split_suffix(src, lit_kind);
             let float = matches!(lit_kind, LitKind::Float(..));
             Some(NumericLiteral::new(unsuffixed, suffix, float))
diff --git a/tests/ui/unnecessary_cast.rs b/tests/ui/unnecessary_cast.rs
index e8f2fb46665..b77c19f2ba5 100644
--- a/tests/ui/unnecessary_cast.rs
+++ b/tests/ui/unnecessary_cast.rs
@@ -1,6 +1,7 @@
 #![warn(clippy::unnecessary_cast)]
 #![allow(clippy::no_effect)]
 
+#[rustfmt::skip]
 fn main() {
     // Test cast_unnecessary
     1i32 as i32;
@@ -8,6 +9,12 @@ fn main() {
     false as bool;
     &1i32 as &i32;
 
+    -1_i32 as i32;
+    - 1_i32 as i32;
+    -1f32 as f32;
+    1_i32 as i32;
+    1_f32 as f32;
+
     // macro version
     macro_rules! foo {
         ($a:ident, $b:ident) => {
diff --git a/tests/ui/unnecessary_cast.stderr b/tests/ui/unnecessary_cast.stderr
index 70aa448af68..a5a93c6110c 100644
--- a/tests/ui/unnecessary_cast.stderr
+++ b/tests/ui/unnecessary_cast.stderr
@@ -1,5 +1,5 @@
 error: casting integer literal to `i32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:6:5
+  --> $DIR/unnecessary_cast.rs:7:5
    |
 LL |     1i32 as i32;
    |     ^^^^^^^^^^^ help: try: `1_i32`
@@ -7,16 +7,46 @@ LL |     1i32 as i32;
    = note: `-D clippy::unnecessary-cast` implied by `-D warnings`
 
 error: casting float literal to `f32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:7:5
+  --> $DIR/unnecessary_cast.rs:8:5
    |
 LL |     1f32 as f32;
    |     ^^^^^^^^^^^ help: try: `1_f32`
 
 error: casting to the same type is unnecessary (`bool` -> `bool`)
-  --> $DIR/unnecessary_cast.rs:8:5
+  --> $DIR/unnecessary_cast.rs:9:5
    |
 LL |     false as bool;
    |     ^^^^^^^^^^^^^ help: try: `false`
 
-error: aborting due to 3 previous errors
+error: casting integer literal to `i32` is unnecessary
+  --> $DIR/unnecessary_cast.rs:12:5
+   |
+LL |     -1_i32 as i32;
+   |     ^^^^^^^^^^^^^ help: try: `-1_i32`
+
+error: casting integer literal to `i32` is unnecessary
+  --> $DIR/unnecessary_cast.rs:13:5
+   |
+LL |     - 1_i32 as i32;
+   |     ^^^^^^^^^^^^^^ help: try: `- 1_i32`
+
+error: casting float literal to `f32` is unnecessary
+  --> $DIR/unnecessary_cast.rs:14:5
+   |
+LL |     -1f32 as f32;
+   |     ^^^^^^^^^^^^ help: try: `-1_f32`
+
+error: casting integer literal to `i32` is unnecessary
+  --> $DIR/unnecessary_cast.rs:15:5
+   |
+LL |     1_i32 as i32;
+   |     ^^^^^^^^^^^^ help: try: `1_i32`
+
+error: casting float literal to `f32` is unnecessary
+  --> $DIR/unnecessary_cast.rs:16:5
+   |
+LL |     1_f32 as f32;
+   |     ^^^^^^^^^^^^ help: try: `1_f32`
+
+error: aborting due to 8 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 4aee3b1f1e977136b401cc6633da5f1234501347 Mon Sep 17 00:00:00 2001
From: Georgy Komarov <jubnzv@gmail.com>
Date: Wed, 26 Jan 2022 14:46:30 +0300
Subject: matches: Clarify the behavior of exhaustive check

---
 clippy_lints/src/matches.rs | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index dc6e4f96969..71842ded69d 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -848,9 +848,9 @@ fn check_single_match_opt_like(
         (&paths::RESULT, "Ok"),
     ];
 
-    // We want to suggest to exclude an arm that contains only wildcards or forms the ehaustive
-    // match with the second branch.
-    if !contains_only_wilds(arms[1].pat) && !form_exhaustive_tuples(arms[0].pat, arms[1].pat) {
+    // We want to suggest to exclude an arm that contains only wildcards or forms the exhaustive
+    // match with the second branch, without enum variants in matches.
+    if !contains_only_wilds(arms[1].pat) && !form_exhaustive_matches(arms[0].pat, arms[1].pat) {
         return;
     }
 
@@ -907,30 +907,30 @@ fn contains_only_wilds(pat: &Pat<'_>) -> bool {
     }
 }
 
-/// Returns true if the given patterns form the tuples that exhaustively matches all possible
-/// parameters.
+/// Returns true if the given patterns forms only exhaustive matches that don't contain enum
+/// patterns without a wildcard.
 ///
-/// Here are some examples:
+/// For example:
 ///
 /// ```
-/// // Doesn't form exhaustive match, because the first arm may contain not only E::V.
+/// // Returns false, because the first arm contain enum without a wildcard.
 /// match x {
 ///     (Some(E::V), _) => todo!(),
 ///     (None, _) => {}
 /// }
 ///
-/// // Forms exhaustive match, because the patterns cover all possible cases at the same positions.
+/// // Returns true, because the both arms form exhaustive matches and without enum variants.
 /// match x {
 ///     (Some(_), _) => todo!(),
 ///     (None, _) => {}
 /// }
 /// ```
-fn form_exhaustive_tuples(left: &Pat<'_>, right: &Pat<'_>) -> bool {
+fn form_exhaustive_matches(left: &Pat<'_>, right: &Pat<'_>) -> bool {
     match (&left.kind, &right.kind) {
         (PatKind::Wild, _) | (_, PatKind::Wild) => true,
         (PatKind::Tuple(left_in, left_pos), PatKind::Tuple(right_in, right_pos)) => {
-            // We don't actually know the position and presence of the `..` (dotdot) operator in
-            // the arms, so we need to evaluate the correct offsets here in order to iterate in
+            // We don't actually know the position and the presence of the `..` (dotdot) operator
+            // in the arms, so we need to evaluate the correct offsets here in order to iterate in
             // both arms at the same time.
             let len = max(
                 left_in.len() + {
-- 
cgit 1.4.1-3-g733a5


From 81015870df891084b24497718af086f0575a121b Mon Sep 17 00:00:00 2001
From: Georgy Komarov <jubnzv@gmail.com>
Date: Wed, 26 Jan 2022 18:02:32 +0300
Subject: matches: Improve naming. NFC.

---
 clippy_lints/src/matches.rs | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index 71842ded69d..e8789a92f13 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -942,20 +942,20 @@ fn form_exhaustive_matches(left: &Pat<'_>, right: &Pat<'_>) -> bool {
             );
             let mut left_pos = left_pos.unwrap_or(usize::MAX);
             let mut right_pos = right_pos.unwrap_or(usize::MAX);
-            let mut left_span = 0;
-            let mut right_span = 0;
+            let mut left_dot_space = 0;
+            let mut right_dot_space = 0;
             for i in 0..len {
                 let mut found_dotdot = false;
                 if i == left_pos {
-                    left_span += 1;
-                    if left_span < len - left_in.len() {
+                    left_dot_space += 1;
+                    if left_dot_space < len - left_in.len() {
                         left_pos += 1;
                     }
                     found_dotdot = true;
                 }
                 if i == right_pos {
-                    right_span += 1;
-                    if right_span < len - right_in.len() {
+                    right_dot_space += 1;
+                    if right_dot_space < len - right_in.len() {
                         right_pos += 1;
                     }
                     found_dotdot = true;
@@ -963,7 +963,9 @@ fn form_exhaustive_matches(left: &Pat<'_>, right: &Pat<'_>) -> bool {
                 if found_dotdot {
                     continue;
                 }
-                if !contains_only_wilds(&left_in[i - left_span]) && !contains_only_wilds(&right_in[i - right_span]) {
+                if !contains_only_wilds(&left_in[i - left_dot_space])
+                    && !contains_only_wilds(&right_in[i - right_dot_space])
+                {
                     return false;
                 }
             }
-- 
cgit 1.4.1-3-g733a5


From 467a0bfdea3ba03de05b90a3de85d4467a28762e Mon Sep 17 00:00:00 2001
From: Georgy Komarov <jubnzv@gmail.com>
Date: Wed, 26 Jan 2022 18:20:35 +0300
Subject: matches: Restore `match_type` logic; add tests for these cases

---
 clippy_lints/src/matches.rs | 45 ++++++++++++++++++++++++++-------------------
 tests/ui/single_match.rs    | 26 ++++++++++++++++++++++++++
 2 files changed, 52 insertions(+), 19 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index e8789a92f13..47c02e22821 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -5,7 +5,7 @@ use clippy_utils::diagnostics::{
 use clippy_utils::macros::{is_panic, root_macro_call};
 use clippy_utils::source::{expr_block, indent_of, snippet, snippet_block, snippet_opt, snippet_with_applicability};
 use clippy_utils::sugg::Sugg;
-use clippy_utils::ty::{implements_trait, is_type_diagnostic_item, peel_mid_ty_refs};
+use clippy_utils::ty::{implements_trait, is_type_diagnostic_item, match_type, peel_mid_ty_refs};
 use clippy_utils::visitors::is_local_used;
 use clippy_utils::{
     get_parent_expr, is_lang_ctor, is_lint_allowed, is_refutable, is_unit_expr, is_wild, meets_msrv, msrvs,
@@ -741,7 +741,7 @@ fn check_single_match(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>], exp
         let ty = cx.typeck_results().expr_ty(ex);
         if *ty.kind() != ty::Bool || is_lint_allowed(cx, MATCH_BOOL, ex.hir_id) {
             check_single_match_single_pattern(cx, ex, arms, expr, els);
-            check_single_match_opt_like(cx, ex, arms, expr, els);
+            check_single_match_opt_like(cx, ex, arms, expr, ty, els);
         }
     }
 }
@@ -830,11 +830,12 @@ fn report_single_match_single_pattern(
     );
 }
 
-fn check_single_match_opt_like(
-    cx: &LateContext<'_>,
+fn check_single_match_opt_like<'a>(
+    cx: &LateContext<'a>,
     ex: &Expr<'_>,
     arms: &[Arm<'_>],
     expr: &Expr<'_>,
+    ty: Ty<'a>,
     els: Option<&Expr<'_>>,
 ) {
     // list of candidate `Enum`s we know will never get any more members
@@ -854,44 +855,50 @@ fn check_single_match_opt_like(
         return;
     }
 
-    let mut paths = Vec::new();
-    if !collect_pat_paths(&mut paths, arms[1].pat) {
+    let mut paths_and_types = Vec::new();
+    if !collect_pat_paths(&mut paths_and_types, cx, arms[1].pat, ty) {
         return;
     }
 
-    let in_candidate_enum = |path: &String| -> bool {
-        for &(_, pat_path) in candidates {
-            if path == pat_path {
+    let in_candidate_enum = |path_info: &(String, &TyS<'_>)| -> bool {
+        let (path, ty) = path_info;
+        for &(ty_path, pat_path) in candidates {
+            if path == pat_path && match_type(cx, ty, ty_path) {
                 return true;
             }
         }
         false
     };
-    if paths.iter().all(in_candidate_enum) {
+    if paths_and_types.iter().all(in_candidate_enum) {
         report_single_match_single_pattern(cx, ex, arms, expr, els);
     }
 }
 
-/// Collects paths from the given paths. Returns true if the given pattern could be simplified,
-/// false otherwise.
-fn collect_pat_paths(acc: &mut Vec<String>, pat: &Pat<'_>) -> bool {
+/// Collects paths and their types from the given patterns. Returns true if the given pattern could
+/// be simplified, false otherwise.
+fn collect_pat_paths<'a>(acc: &mut Vec<(String, Ty<'a>)>, cx: &LateContext<'a>, pat: &Pat<'_>, ty: Ty<'a>) -> bool {
     match pat.kind {
         PatKind::Wild => true,
-        PatKind::Tuple(inner, _) => inner.iter().all(|p| collect_pat_paths(acc, p)),
+        PatKind::Tuple(inner, _) => inner.iter().all(|p| {
+            let p_ty = cx.typeck_results().pat_ty(p);
+            collect_pat_paths(acc, cx, p, p_ty)
+        }),
         PatKind::TupleStruct(ref path, ..) => {
-            acc.push(rustc_hir_pretty::to_string(rustc_hir_pretty::NO_ANN, |s| {
+            let path = rustc_hir_pretty::to_string(rustc_hir_pretty::NO_ANN, |s| {
                 s.print_qpath(path, false);
-            }));
+            });
+            acc.push((path, ty));
             true
         },
         PatKind::Binding(BindingAnnotation::Unannotated, .., ident, None) => {
-            acc.push(ident.to_string());
+            acc.push((ident.to_string(), ty));
             true
         },
         PatKind::Path(ref path) => {
-            acc.push(rustc_hir_pretty::to_string(rustc_hir_pretty::NO_ANN, |s| {
+            let path = rustc_hir_pretty::to_string(rustc_hir_pretty::NO_ANN, |s| {
                 s.print_qpath(path, false);
-            }));
+            });
+            acc.push((path, ty));
             true
         },
         _ => false,
diff --git a/tests/ui/single_match.rs b/tests/ui/single_match.rs
index 0e50b3e4a6e..bd371888046 100644
--- a/tests/ui/single_match.rs
+++ b/tests/ui/single_match.rs
@@ -197,6 +197,32 @@ fn ranges() {
     }
 }
 
+fn skip_type_aliases() {
+    enum OptionEx {
+        Some(i32),
+        None,
+    }
+    enum ResultEx {
+        Err(i32),
+        Ok(i32),
+    }
+
+    use OptionEx::{None, Some};
+    use ResultEx::{Err, Ok};
+
+    // don't lint
+    match Err(42) {
+        Ok(_) => dummy(),
+        Err(_) => (),
+    };
+
+    // don't lint
+    match Some(1i32) {
+        Some(_) => dummy(),
+        None => (),
+    };
+}
+
 macro_rules! single_match {
     ($num:literal) => {
         match $num {
-- 
cgit 1.4.1-3-g733a5


From a8fdf5ca8aab08ba56678a4bce36f9da5ae8e52d Mon Sep 17 00:00:00 2001
From: Georgy Komarov <jubnzv@gmail.com>
Date: Wed, 26 Jan 2022 19:09:31 +0300
Subject: matches: Remove extra comment

---
 clippy_lints/src/matches.rs | 16 ----------------
 1 file changed, 16 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index 47c02e22821..ab030ffb406 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -916,22 +916,6 @@ fn contains_only_wilds(pat: &Pat<'_>) -> bool {
 
 /// Returns true if the given patterns forms only exhaustive matches that don't contain enum
 /// patterns without a wildcard.
-///
-/// For example:
-///
-/// ```
-/// // Returns false, because the first arm contain enum without a wildcard.
-/// match x {
-///     (Some(E::V), _) => todo!(),
-///     (None, _) => {}
-/// }
-///
-/// // Returns true, because the both arms form exhaustive matches and without enum variants.
-/// match x {
-///     (Some(_), _) => todo!(),
-///     (None, _) => {}
-/// }
-/// ```
 fn form_exhaustive_matches(left: &Pat<'_>, right: &Pat<'_>) -> bool {
     match (&left.kind, &right.kind) {
         (PatKind::Wild, _) | (_, PatKind::Wild) => true,
-- 
cgit 1.4.1-3-g733a5


From 23fd95a5e99acf35b471ca9b01230d7578bfac5f Mon Sep 17 00:00:00 2001
From: max <36980911+pr2502@users.noreply.github.com>
Date: Sat, 8 Jan 2022 23:10:20 +0100
Subject: fix underflow in `check_manual_split_once` lint

---
 clippy_lints/src/methods/str_splitn.rs |  6 +++---
 tests/ui/crashes/ice-8250.rs           |  6 ++++++
 tests/ui/crashes/ice-8250.stderr       | 18 ++++++++++++++++++
 3 files changed, 27 insertions(+), 3 deletions(-)
 create mode 100644 tests/ui/crashes/ice-8250.rs
 create mode 100644 tests/ui/crashes/ice-8250.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/str_splitn.rs b/clippy_lints/src/methods/str_splitn.rs
index 70f20da1d6d..e8a3562c393 100644
--- a/clippy_lints/src/methods/str_splitn.rs
+++ b/clippy_lints/src/methods/str_splitn.rs
@@ -45,16 +45,16 @@ pub(super) fn check_manual_split_once(
         IterUsageKind::Next | IterUsageKind::Second => {
             let self_deref = {
                 let adjust = cx.typeck_results().expr_adjustments(self_arg);
-                if adjust.is_empty() {
+                if adjust.len() < 2 {
                     String::new()
                 } else if cx.typeck_results().expr_ty(self_arg).is_box()
                     || adjust
                         .iter()
                         .any(|a| matches!(a.kind, Adjust::Deref(Some(_))) || a.target.is_box())
                 {
-                    format!("&{}", "*".repeat(adjust.len() - 1))
+                    format!("&{}", "*".repeat(adjust.len().saturating_sub(1)))
                 } else {
-                    "*".repeat(adjust.len() - 2)
+                    "*".repeat(adjust.len().saturating_sub(2))
                 }
             };
             if matches!(usage.kind, IterUsageKind::Next) {
diff --git a/tests/ui/crashes/ice-8250.rs b/tests/ui/crashes/ice-8250.rs
new file mode 100644
index 00000000000..d9a5ee1162a
--- /dev/null
+++ b/tests/ui/crashes/ice-8250.rs
@@ -0,0 +1,6 @@
+fn _f(s: &str) -> Option<()> {
+    let _ = s[1..].splitn(2, '.').next()?;
+    Some(())
+}
+
+fn main() {}
diff --git a/tests/ui/crashes/ice-8250.stderr b/tests/ui/crashes/ice-8250.stderr
new file mode 100644
index 00000000000..04ea4456656
--- /dev/null
+++ b/tests/ui/crashes/ice-8250.stderr
@@ -0,0 +1,18 @@
+error: manual implementation of `split_once`
+  --> $DIR/ice-8250.rs:2:13
+   |
+LL |     let _ = s[1..].splitn(2, '.').next()?;
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `s[1..].split_once('.').map_or(s[1..], |x| x.0)`
+   |
+   = note: `-D clippy::manual-split-once` implied by `-D warnings`
+
+error: unnecessary use of `splitn`
+  --> $DIR/ice-8250.rs:2:13
+   |
+LL |     let _ = s[1..].splitn(2, '.').next()?;
+   |             ^^^^^^^^^^^^^^^^^^^^^ help: try this: `s[1..].split('.')`
+   |
+   = note: `-D clippy::needless-splitn` implied by `-D warnings`
+
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 515ed80b9d63e20c196a7739118c2f316a097106 Mon Sep 17 00:00:00 2001
From: dswij <dswijj@gmail.com>
Date: Tue, 25 Jan 2022 16:18:32 +0800
Subject: Update docs for `map_flatten` on `Option`

---
 clippy_lints/src/methods/mod.rs | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index d75ab0c4b1b..45f2992df91 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -566,17 +566,20 @@ declare_clippy_lint! {
     ///
     /// ### Why is this bad?
     /// Readability, this can be written more concisely as
-    /// `_.flat_map(_)`
+    /// `_.flat_map(_)` for `Iterator` or `_.and_then(_)` for `Option`
     ///
     /// ### Example
     /// ```rust
     /// let vec = vec![vec![1]];
+    /// let opt = Some(5);
     ///
     /// // Bad
     /// vec.iter().map(|x| x.iter()).flatten();
+    /// opt.map(|x| Some(x * 2)).flatten();
     ///
     /// // Good
     /// vec.iter().flat_map(|x| x.iter());
+    /// opt.and_then(|x| Some(x * 2));
     /// ```
     #[clippy::version = "1.31.0"]
     pub MAP_FLATTEN,
-- 
cgit 1.4.1-3-g733a5


From cc975929c528d0883d7553c53dc47030c08d01e0 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Wed, 5 Jan 2022 20:36:22 -0600
Subject: Rename path_to_res to def_path_res

---
 clippy_lints/src/disallowed_methods.rs             |  2 +-
 clippy_lints/src/disallowed_types.rs               |  2 +-
 clippy_lints/src/missing_enforced_import_rename.rs |  2 +-
 clippy_lints/src/utils/internal_lints.rs           | 10 +++++-----
 clippy_utils/src/lib.rs                            |  7 ++++---
 5 files changed, 12 insertions(+), 11 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/disallowed_methods.rs b/clippy_lints/src/disallowed_methods.rs
index 73c00d97020..4c12202c84a 100644
--- a/clippy_lints/src/disallowed_methods.rs
+++ b/clippy_lints/src/disallowed_methods.rs
@@ -77,7 +77,7 @@ impl<'tcx> LateLintPass<'tcx> for DisallowedMethods {
     fn check_crate(&mut self, cx: &LateContext<'_>) {
         for (index, conf) in self.conf_disallowed.iter().enumerate() {
             let segs: Vec<_> = conf.path().split("::").collect();
-            if let Res::Def(_, id) = clippy_utils::path_to_res(cx, &segs) {
+            if let Res::Def(_, id) = clippy_utils::def_path_res(cx, &segs) {
                 self.disallowed.insert(id, index);
             }
         }
diff --git a/clippy_lints/src/disallowed_types.rs b/clippy_lints/src/disallowed_types.rs
index ea4b49b46fe..14f89edce61 100644
--- a/clippy_lints/src/disallowed_types.rs
+++ b/clippy_lints/src/disallowed_types.rs
@@ -96,7 +96,7 @@ impl<'tcx> LateLintPass<'tcx> for DisallowedTypes {
                 ),
             };
             let segs: Vec<_> = path.split("::").collect();
-            match clippy_utils::path_to_res(cx, &segs) {
+            match clippy_utils::def_path_res(cx, &segs) {
                 Res::Def(_, id) => {
                     self.def_ids.insert(id, reason);
                 },
diff --git a/clippy_lints/src/missing_enforced_import_rename.rs b/clippy_lints/src/missing_enforced_import_rename.rs
index 566e15ab2a6..3d0a2382283 100644
--- a/clippy_lints/src/missing_enforced_import_rename.rs
+++ b/clippy_lints/src/missing_enforced_import_rename.rs
@@ -58,7 +58,7 @@ impl_lint_pass!(ImportRename => [MISSING_ENFORCED_IMPORT_RENAMES]);
 impl LateLintPass<'_> for ImportRename {
     fn check_crate(&mut self, cx: &LateContext<'_>) {
         for Rename { path, rename } in &self.conf_renames {
-            if let Res::Def(_, id) = clippy_utils::path_to_res(cx, &path.split("::").collect::<Vec<_>>()) {
+            if let Res::Def(_, id) = clippy_utils::def_path_res(cx, &path.split("::").collect::<Vec<_>>()) {
                 self.renames.insert(id, Symbol::intern(rename));
             }
         }
diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs
index f170ff69154..dc0f515bfe5 100644
--- a/clippy_lints/src/utils/internal_lints.rs
+++ b/clippy_lints/src/utils/internal_lints.rs
@@ -4,8 +4,8 @@ use clippy_utils::macros::root_macro_call_first_node;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::match_type;
 use clippy_utils::{
-    higher, is_else_clause, is_expn_of, is_expr_path_def_path, is_lint_allowed, match_def_path, method_calls,
-    path_to_res, paths, peel_blocks_with_stmt, SpanlessEq,
+    def_path_res, higher, is_else_clause, is_expn_of, is_expr_path_def_path, is_lint_allowed, match_def_path,
+    method_calls, paths, peel_blocks_with_stmt, SpanlessEq,
 };
 use if_chain::if_chain;
 use rustc_ast as ast;
@@ -844,7 +844,7 @@ impl<'tcx> LateLintPass<'tcx> for MatchTypeOnDiagItem {
             // Extract the path to the matched type
             if let Some(segments) = path_to_matched_type(cx, ty_path);
             let segments: Vec<&str> = segments.iter().map(Symbol::as_str).collect();
-            if let Some(ty_did) = path_to_res(cx, &segments[..]).opt_def_id();
+            if let Some(ty_did) = def_path_res(cx, &segments[..]).opt_def_id();
             // Check if the matched type is a diagnostic item
             if let Some(item_name) = cx.tcx.get_diagnostic_name(ty_did);
             then {
@@ -917,7 +917,7 @@ fn path_to_matched_type(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> Option<Ve
 // This is not a complete resolver for paths. It works on all the paths currently used in the paths
 // module.  That's all it does and all it needs to do.
 pub fn check_path(cx: &LateContext<'_>, path: &[&str]) -> bool {
-    if path_to_res(cx, path) != Res::Err {
+    if def_path_res(cx, path) != Res::Err {
         return true;
     }
 
@@ -999,7 +999,7 @@ impl<'tcx> LateLintPass<'tcx> for InterningDefinedSymbol {
         }
 
         for &module in &[&paths::KW_MODULE, &paths::SYM_MODULE] {
-            if let Some(def_id) = path_to_res(cx, module).opt_def_id() {
+            if let Some(def_id) = def_path_res(cx, module).opt_def_id() {
                 for item in cx.tcx.module_children(def_id).iter() {
                     if_chain! {
                         if let Res::Def(DefKind::Const, item_def_id) = item.res;
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index a2f1f469651..28bca902e19 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -497,8 +497,9 @@ pub fn path_to_local_id(expr: &Expr<'_>, id: HirId) -> bool {
     path_to_local(expr) == Some(id)
 }
 
-/// Gets the definition associated to a path.
-pub fn path_to_res(cx: &LateContext<'_>, path: &[&str]) -> Res {
+/// Resolves a def path like `std::vec::Vec`.
+/// This function is expensive and should be used sparingly.
+pub fn def_path_res(cx: &LateContext<'_>, path: &[&str]) -> Res {
     macro_rules! try_res {
         ($e:expr) => {
             match $e {
@@ -574,7 +575,7 @@ pub fn path_to_res(cx: &LateContext<'_>, path: &[&str]) -> Res {
 /// Convenience function to get the `DefId` of a trait by path.
 /// It could be a trait or trait alias.
 pub fn get_trait_def_id(cx: &LateContext<'_>, path: &[&str]) -> Option<DefId> {
-    match path_to_res(cx, path) {
+    match def_path_res(cx, path) {
         Res::Def(DefKind::Trait | DefKind::TraitAlias, trait_id) => Some(trait_id),
         _ => None,
     }
-- 
cgit 1.4.1-3-g733a5


From 20781f195d205dcc3fa244a659dfc5b3547a87d3 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Mon, 17 Jan 2022 12:57:45 -0600
Subject: Rename qpath_generic_tys

---
 clippy_lints/src/types/rc_buffer.rs            | 6 +++---
 clippy_lints/src/types/redundant_allocation.rs | 4 ++--
 clippy_utils/src/lib.rs                        | 6 +++---
 3 files changed, 8 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types/rc_buffer.rs b/clippy_lints/src/types/rc_buffer.rs
index 31c4abdfc95..0a2df7d2188 100644
--- a/clippy_lints/src/types/rc_buffer.rs
+++ b/clippy_lints/src/types/rc_buffer.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::{get_qpath_generic_tys, is_ty_param_diagnostic_item};
+use clippy_utils::{is_ty_param_diagnostic_item, qpath_generic_tys};
 use rustc_errors::Applicability;
 use rustc_hir::{self as hir, def_id::DefId, QPath, TyKind};
 use rustc_lint::LateContext;
@@ -25,7 +25,7 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_
                 TyKind::Path(qpath) => qpath,
                 _ => return false,
             };
-            let inner_span = match get_qpath_generic_tys(qpath).next() {
+            let inner_span = match qpath_generic_tys(qpath).next() {
                 Some(ty) => ty.span,
                 None => return false,
             };
@@ -60,7 +60,7 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_
                 TyKind::Path(qpath) => qpath,
                 _ => return false,
             };
-            let inner_span = match get_qpath_generic_tys(qpath).next() {
+            let inner_span = match qpath_generic_tys(qpath).next() {
                 Some(ty) => ty.span,
                 None => return false,
             };
diff --git a/clippy_lints/src/types/redundant_allocation.rs b/clippy_lints/src/types/redundant_allocation.rs
index ac7bdd6a1eb..8638197a584 100644
--- a/clippy_lints/src/types/redundant_allocation.rs
+++ b/clippy_lints/src/types/redundant_allocation.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::{snippet, snippet_with_applicability};
-use clippy_utils::{get_qpath_generic_tys, is_ty_param_diagnostic_item, is_ty_param_lang_item};
+use clippy_utils::{is_ty_param_diagnostic_item, is_ty_param_lang_item, qpath_generic_tys};
 use rustc_errors::Applicability;
 use rustc_hir::{self as hir, def_id::DefId, LangItem, QPath, TyKind};
 use rustc_lint::LateContext;
@@ -53,7 +53,7 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_
         TyKind::Path(inner_qpath) => inner_qpath,
         _ => return false,
     };
-    let inner_span = match get_qpath_generic_tys(inner_qpath).next() {
+    let inner_span = match qpath_generic_tys(inner_qpath).next() {
         Some(ty) => {
             // Box<Box<dyn T>> is smaller than Box<dyn T> because of wide pointers
             if matches!(ty.kind, TyKind::TraitObject(..)) {
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 8cc4f0449e3..64634c64602 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -268,7 +268,7 @@ pub fn is_ty_param_lang_item<'tcx>(
     qpath: &QPath<'tcx>,
     item: LangItem,
 ) -> Option<&'tcx hir::Ty<'tcx>> {
-    let ty = get_qpath_generic_tys(qpath).next()?;
+    let ty = qpath_generic_tys(qpath).next()?;
 
     if let TyKind::Path(qpath) = &ty.kind {
         cx.qpath_res(qpath, ty.hir_id)
@@ -288,7 +288,7 @@ pub fn is_ty_param_diagnostic_item<'tcx>(
     qpath: &QPath<'tcx>,
     item: Symbol,
 ) -> Option<&'tcx hir::Ty<'tcx>> {
-    let ty = get_qpath_generic_tys(qpath).next()?;
+    let ty = qpath_generic_tys(qpath).next()?;
 
     if let TyKind::Path(qpath) = &ty.kind {
         cx.qpath_res(qpath, ty.hir_id)
@@ -368,7 +368,7 @@ pub fn get_qpath_generics<'tcx>(path: &QPath<'tcx>) -> Option<&'tcx GenericArgs<
     }
 }
 
-pub fn get_qpath_generic_tys<'tcx>(path: &QPath<'tcx>) -> impl Iterator<Item = &'tcx hir::Ty<'tcx>> {
+pub fn qpath_generic_tys<'tcx>(path: &QPath<'tcx>) -> impl Iterator<Item = &'tcx hir::Ty<'tcx>> {
     get_qpath_generics(path)
         .map_or([].as_ref(), |a| a.args)
         .iter()
-- 
cgit 1.4.1-3-g733a5


From 66a83d33ea9a39d1fc0f4c2ca058c0ce4884a71a Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Wed, 5 Jan 2022 20:56:29 -0600
Subject: Factor out some ty param utils

---
 clippy_lints/src/types/box_collection.rs       | 27 ++++++++----------
 clippy_lints/src/types/option_option.rs        | 30 ++++++++++++--------
 clippy_lints/src/types/rc_buffer.rs            | 33 ++++++++++++++--------
 clippy_lints/src/types/rc_mutex.rs             |  6 ++--
 clippy_lints/src/types/redundant_allocation.rs | 19 ++++++-------
 clippy_utils/src/lib.rs                        | 38 --------------------------
 6 files changed, 63 insertions(+), 90 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types/box_collection.rs b/clippy_lints/src/types/box_collection.rs
index 538c10a5b20..21a9558ec07 100644
--- a/clippy_lints/src/types/box_collection.rs
+++ b/clippy_lints/src/types/box_collection.rs
@@ -1,8 +1,8 @@
 use clippy_utils::diagnostics::span_lint_and_help;
-use clippy_utils::is_ty_param_diagnostic_item;
+use clippy_utils::{path_def_id, qpath_generic_tys};
 use rustc_hir::{self as hir, def_id::DefId, QPath};
 use rustc_lint::LateContext;
-use rustc_span::symbol::sym;
+use rustc_span::{sym, Symbol};
 
 use super::BOX_COLLECTION;
 
@@ -11,10 +11,9 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_
         if Some(def_id) == cx.tcx.lang_items().owned_box();
         if let Some(item_type) = get_std_collection(cx, qpath);
         then {
-            let generic = if item_type == "String" {
-                ""
-            } else {
-                "<..>"
+            let generic = match item_type {
+                sym::String => "",
+                _ => "<..>",
             };
             span_lint_and_help(
                 cx,
@@ -37,14 +36,10 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_
     }
 }
 
-fn get_std_collection(cx: &LateContext<'_>, qpath: &QPath<'_>) -> Option<&'static str> {
-    if is_ty_param_diagnostic_item(cx, qpath, sym::Vec).is_some() {
-        Some("Vec")
-    } else if is_ty_param_diagnostic_item(cx, qpath, sym::String).is_some() {
-        Some("String")
-    } else if is_ty_param_diagnostic_item(cx, qpath, sym::HashMap).is_some() {
-        Some("HashMap")
-    } else {
-        None
-    }
+fn get_std_collection(cx: &LateContext<'_>, qpath: &QPath<'_>) -> Option<Symbol> {
+    let param = qpath_generic_tys(qpath).next()?;
+    let id = path_def_id(cx, param)?;
+    cx.tcx
+        .get_diagnostic_name(id)
+        .filter(|&name| matches!(name, sym::HashMap | sym::String | sym::Vec))
 }
diff --git a/clippy_lints/src/types/option_option.rs b/clippy_lints/src/types/option_option.rs
index 903e62995c6..8767e3c30a6 100644
--- a/clippy_lints/src/types/option_option.rs
+++ b/clippy_lints/src/types/option_option.rs
@@ -1,5 +1,6 @@
 use clippy_utils::diagnostics::span_lint;
-use clippy_utils::is_ty_param_diagnostic_item;
+use clippy_utils::{path_def_id, qpath_generic_tys};
+use if_chain::if_chain;
 use rustc_hir::{self as hir, def_id::DefId, QPath};
 use rustc_lint::LateContext;
 use rustc_span::symbol::sym;
@@ -7,16 +8,21 @@ use rustc_span::symbol::sym;
 use super::OPTION_OPTION;
 
 pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_>, def_id: DefId) -> bool {
-    if cx.tcx.is_diagnostic_item(sym::Option, def_id) && is_ty_param_diagnostic_item(cx, qpath, sym::Option).is_some() {
-        span_lint(
-            cx,
-            OPTION_OPTION,
-            hir_ty.span,
-            "consider using `Option<T>` instead of `Option<Option<T>>` or a custom \
-                                 enum if you need to distinguish all 3 cases",
-        );
-        true
-    } else {
-        false
+    if_chain! {
+        if cx.tcx.is_diagnostic_item(sym::Option, def_id);
+        if let Some(arg) = qpath_generic_tys(qpath).next();
+        if path_def_id(cx, arg) == Some(def_id);
+        then {
+            span_lint(
+                cx,
+                OPTION_OPTION,
+                hir_ty.span,
+                "consider using `Option<T>` instead of `Option<Option<T>>` or a custom \
+                                     enum if you need to distinguish all 3 cases",
+            );
+            true
+        } else {
+            false
+        }
     }
 }
diff --git a/clippy_lints/src/types/rc_buffer.rs b/clippy_lints/src/types/rc_buffer.rs
index 0a2df7d2188..4d72a29e8c7 100644
--- a/clippy_lints/src/types/rc_buffer.rs
+++ b/clippy_lints/src/types/rc_buffer.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::{is_ty_param_diagnostic_item, qpath_generic_tys};
+use clippy_utils::{path_def_id, qpath_generic_tys};
 use rustc_errors::Applicability;
 use rustc_hir::{self as hir, def_id::DefId, QPath, TyKind};
 use rustc_lint::LateContext;
@@ -20,7 +20,12 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_
                 format!("Rc<{}>", alternate),
                 Applicability::MachineApplicable,
             );
-        } else if let Some(ty) = is_ty_param_diagnostic_item(cx, qpath, sym::Vec) {
+        } else {
+            let Some(ty) = qpath_generic_tys(qpath).next() else { return false };
+            let Some(id) = path_def_id(cx, ty) else { return false };
+            if !cx.tcx.is_diagnostic_item(sym::Vec, id) {
+                return false;
+            }
             let qpath = match &ty.kind {
                 TyKind::Path(qpath) => qpath,
                 _ => return false,
@@ -55,7 +60,11 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_
                 format!("Arc<{}>", alternate),
                 Applicability::MachineApplicable,
             );
-        } else if let Some(ty) = is_ty_param_diagnostic_item(cx, qpath, sym::Vec) {
+        } else if let Some(ty) = qpath_generic_tys(qpath).next() {
+            let Some(id) = path_def_id(cx, ty) else { return false };
+            if !cx.tcx.is_diagnostic_item(sym::Vec, id) {
+                return false;
+            }
             let qpath = match &ty.kind {
                 TyKind::Path(qpath) => qpath,
                 _ => return false,
@@ -85,13 +94,13 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_
 }
 
 fn match_buffer_type(cx: &LateContext<'_>, qpath: &QPath<'_>) -> Option<&'static str> {
-    if is_ty_param_diagnostic_item(cx, qpath, sym::String).is_some() {
-        Some("str")
-    } else if is_ty_param_diagnostic_item(cx, qpath, sym::OsString).is_some() {
-        Some("std::ffi::OsStr")
-    } else if is_ty_param_diagnostic_item(cx, qpath, sym::PathBuf).is_some() {
-        Some("std::path::Path")
-    } else {
-        None
-    }
+    let ty = qpath_generic_tys(qpath).next()?;
+    let id = path_def_id(cx, ty)?;
+    let path = match cx.tcx.get_diagnostic_name(id)? {
+        sym::String => "str",
+        sym::OsString => "std::ffi::OsStr",
+        sym::PathBuf => "std::path::Path",
+        _ => return None,
+    };
+    Some(path)
 }
diff --git a/clippy_lints/src/types/rc_mutex.rs b/clippy_lints/src/types/rc_mutex.rs
index d54608a07bb..a75972cf3dd 100644
--- a/clippy_lints/src/types/rc_mutex.rs
+++ b/clippy_lints/src/types/rc_mutex.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_help;
-use clippy_utils::is_ty_param_diagnostic_item;
+use clippy_utils::{path_def_id, qpath_generic_tys};
 use if_chain::if_chain;
 use rustc_hir::{self as hir, def_id::DefId, QPath};
 use rustc_lint::LateContext;
@@ -10,7 +10,9 @@ use super::RC_MUTEX;
 pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_>, def_id: DefId) -> bool {
     if_chain! {
         if cx.tcx.is_diagnostic_item(sym::Rc, def_id) ;
-        if let Some(_) = is_ty_param_diagnostic_item(cx, qpath, sym::Mutex) ;
+        if let Some(arg) = qpath_generic_tys(qpath).next();
+        if let Some(id) = path_def_id(cx, arg);
+        if cx.tcx.is_diagnostic_item(sym::Mutex, id);
         then {
             span_lint_and_help(
                 cx,
diff --git a/clippy_lints/src/types/redundant_allocation.rs b/clippy_lints/src/types/redundant_allocation.rs
index 8638197a584..10d2ae2eb1d 100644
--- a/clippy_lints/src/types/redundant_allocation.rs
+++ b/clippy_lints/src/types/redundant_allocation.rs
@@ -1,8 +1,8 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::{snippet, snippet_with_applicability};
-use clippy_utils::{is_ty_param_diagnostic_item, is_ty_param_lang_item, qpath_generic_tys};
+use clippy_utils::{path_def_id, qpath_generic_tys};
 use rustc_errors::Applicability;
-use rustc_hir::{self as hir, def_id::DefId, LangItem, QPath, TyKind};
+use rustc_hir::{self as hir, def_id::DefId, QPath, TyKind};
 use rustc_lint::LateContext;
 use rustc_span::symbol::sym;
 
@@ -39,14 +39,13 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_
         return true;
     }
 
-    let (inner_sym, ty) = if let Some(ty) = is_ty_param_lang_item(cx, qpath, LangItem::OwnedBox) {
-        ("Box", ty)
-    } else if let Some(ty) = is_ty_param_diagnostic_item(cx, qpath, sym::Rc) {
-        ("Rc", ty)
-    } else if let Some(ty) = is_ty_param_diagnostic_item(cx, qpath, sym::Arc) {
-        ("Arc", ty)
-    } else {
-        return false;
+    let Some(ty) = qpath_generic_tys(qpath).next() else { return false };
+    let Some(id) = path_def_id(cx, ty) else { return false };
+    let (inner_sym, ty) = match cx.tcx.get_diagnostic_name(id) {
+        Some(sym::Arc) => ("Arc", ty),
+        Some(sym::Rc) => ("Rc", ty),
+        _ if Some(id) == cx.tcx.lang_items().owned_box() => ("Box", ty),
+        _ => return false,
     };
 
     let inner_qpath = match &ty.kind {
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 82d50238666..ed73364841c 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -262,44 +262,6 @@ pub fn is_wild(pat: &Pat<'_>) -> bool {
     matches!(pat.kind, PatKind::Wild)
 }
 
-/// Checks if the first type parameter is a lang item.
-pub fn is_ty_param_lang_item<'tcx>(
-    cx: &LateContext<'_>,
-    qpath: &QPath<'tcx>,
-    item: LangItem,
-) -> Option<&'tcx hir::Ty<'tcx>> {
-    let ty = qpath_generic_tys(qpath).next()?;
-
-    if let TyKind::Path(qpath) = &ty.kind {
-        cx.qpath_res(qpath, ty.hir_id)
-            .opt_def_id()
-            .map_or(false, |id| {
-                cx.tcx.lang_items().require(item).map_or(false, |lang_id| id == lang_id)
-            })
-            .then(|| ty)
-    } else {
-        None
-    }
-}
-
-/// Checks if the first type parameter is a diagnostic item.
-pub fn is_ty_param_diagnostic_item<'tcx>(
-    cx: &LateContext<'_>,
-    qpath: &QPath<'tcx>,
-    item: Symbol,
-) -> Option<&'tcx hir::Ty<'tcx>> {
-    let ty = qpath_generic_tys(qpath).next()?;
-
-    if let TyKind::Path(qpath) = &ty.kind {
-        cx.qpath_res(qpath, ty.hir_id)
-            .opt_def_id()
-            .map_or(false, |id| cx.tcx.is_diagnostic_item(item, id))
-            .then(|| ty)
-    } else {
-        None
-    }
-}
-
 /// Checks if the method call given in `expr` belongs to the given trait.
 /// This is a deprecated function, consider using [`is_trait_method`].
 pub fn match_trait_method(cx: &LateContext<'_>, expr: &Expr<'_>, path: &[&str]) -> bool {
-- 
cgit 1.4.1-3-g733a5


From deadc255883a726abee105564bc9a0f65f01e62b Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Tue, 2 Nov 2021 09:43:31 -0500
Subject: Factor out differing_macro_contexts

---
 clippy_lints/src/blocks_in_if_conditions.rs      |  6 +++---
 clippy_lints/src/formatting.rs                   | 14 ++++++--------
 clippy_lints/src/implicit_hasher.rs              |  3 +--
 clippy_lints/src/methods/option_map_unwrap_or.rs |  3 +--
 clippy_lints/src/swap.rs                         |  4 ++--
 clippy_lints/src/unwrap.rs                       |  7 ++++---
 clippy_utils/src/hir_utils.rs                    |  3 +--
 clippy_utils/src/lib.rs                          |  7 -------
 doc/common_tools_writing_lints.md                |  8 ++++++--
 9 files changed, 24 insertions(+), 31 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/blocks_in_if_conditions.rs b/clippy_lints/src/blocks_in_if_conditions.rs
index c4956bacf43..4c4dd85d518 100644
--- a/clippy_lints/src/blocks_in_if_conditions.rs
+++ b/clippy_lints/src/blocks_in_if_conditions.rs
@@ -1,8 +1,8 @@
 use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg};
+use clippy_utils::get_parent_expr;
 use clippy_utils::higher;
 use clippy_utils::source::snippet_block_with_applicability;
 use clippy_utils::ty::implements_trait;
-use clippy_utils::{differing_macro_contexts, get_parent_expr};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_expr, Visitor};
@@ -97,7 +97,7 @@ impl<'tcx> LateLintPass<'tcx> for BlocksInIfConditions {
                         if let Some(ex) = &block.expr {
                             // don't dig into the expression here, just suggest that they remove
                             // the block
-                            if expr.span.from_expansion() || differing_macro_contexts(expr.span, ex.span) {
+                            if expr.span.from_expansion() || ex.span.from_expansion() {
                                 return;
                             }
                             let mut applicability = Applicability::MachineApplicable;
@@ -122,7 +122,7 @@ impl<'tcx> LateLintPass<'tcx> for BlocksInIfConditions {
                         }
                     } else {
                         let span = block.expr.as_ref().map_or_else(|| block.stmts[0].span, |e| e.span);
-                        if span.from_expansion() || differing_macro_contexts(expr.span, span) {
+                        if span.from_expansion() || expr.span.from_expansion() {
                             return;
                         }
                         // move block higher
diff --git a/clippy_lints/src/formatting.rs b/clippy_lints/src/formatting.rs
index ae18f8081bc..57964b8d48e 100644
--- a/clippy_lints/src/formatting.rs
+++ b/clippy_lints/src/formatting.rs
@@ -1,5 +1,4 @@
 use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_note};
-use clippy_utils::differing_macro_contexts;
 use clippy_utils::source::snippet_opt;
 use if_chain::if_chain;
 use rustc_ast::ast::{BinOpKind, Block, Expr, ExprKind, StmtKind, UnOp};
@@ -135,7 +134,7 @@ impl EarlyLintPass for Formatting {
 /// Implementation of the `SUSPICIOUS_ASSIGNMENT_FORMATTING` lint.
 fn check_assign(cx: &EarlyContext<'_>, expr: &Expr) {
     if let ExprKind::Assign(ref lhs, ref rhs, _) = expr.kind {
-        if !differing_macro_contexts(lhs.span, rhs.span) && !lhs.span.from_expansion() {
+        if !lhs.span.from_expansion() && !rhs.span.from_expansion() {
             let eq_span = lhs.span.between(rhs.span);
             if let ExprKind::Unary(op, ref sub_rhs) = rhs.kind {
                 if let Some(eq_snippet) = snippet_opt(cx, eq_span) {
@@ -165,7 +164,7 @@ fn check_assign(cx: &EarlyContext<'_>, expr: &Expr) {
 fn check_unop(cx: &EarlyContext<'_>, expr: &Expr) {
     if_chain! {
         if let ExprKind::Binary(ref binop, ref lhs, ref rhs) = expr.kind;
-        if !differing_macro_contexts(lhs.span, rhs.span) && !lhs.span.from_expansion();
+        if !lhs.span.from_expansion() && !rhs.span.from_expansion();
         // span between BinOp LHS and RHS
         let binop_span = lhs.span.between(rhs.span);
         // if RHS is an UnOp
@@ -206,8 +205,8 @@ fn check_else(cx: &EarlyContext<'_>, expr: &Expr) {
     if_chain! {
         if let ExprKind::If(_, then, Some(else_)) = &expr.kind;
         if is_block(else_) || is_if(else_);
-        if !differing_macro_contexts(then.span, else_.span);
-        if !then.span.from_expansion() && !in_external_macro(cx.sess(), expr.span);
+        if !then.span.from_expansion() && !else_.span.from_expansion();
+        if !in_external_macro(cx.sess(), expr.span);
 
         // workaround for rust-lang/rust#43081
         if expr.span.lo().0 != 0 && expr.span.hi().0 != 0;
@@ -268,7 +267,7 @@ fn check_array(cx: &EarlyContext<'_>, expr: &Expr) {
         for element in array {
             if_chain! {
                 if let ExprKind::Binary(ref op, ref lhs, _) = element.kind;
-                if has_unary_equivalent(op.node) && !differing_macro_contexts(lhs.span, op.span);
+                if has_unary_equivalent(op.node) && lhs.span.ctxt() == op.span.ctxt();
                 let space_span = lhs.span.between(op.span);
                 if let Some(space_snippet) = snippet_opt(cx, space_span);
                 let lint_span = lhs.span.with_lo(lhs.span.hi());
@@ -291,8 +290,7 @@ fn check_array(cx: &EarlyContext<'_>, expr: &Expr) {
 
 fn check_missing_else(cx: &EarlyContext<'_>, first: &Expr, second: &Expr) {
     if_chain! {
-        if !differing_macro_contexts(first.span, second.span);
-        if !first.span.from_expansion();
+        if !first.span.from_expansion() && !second.span.from_expansion();
         if let ExprKind::If(cond_expr, ..) = &first.kind;
         if is_block(second) || is_if(second);
 
diff --git a/clippy_lints/src/implicit_hasher.rs b/clippy_lints/src/implicit_hasher.rs
index eed25e9bc0e..3fb7e5dfd6c 100644
--- a/clippy_lints/src/implicit_hasher.rs
+++ b/clippy_lints/src/implicit_hasher.rs
@@ -17,7 +17,6 @@ use rustc_typeck::hir_ty_to_ty;
 use if_chain::if_chain;
 
 use clippy_utils::diagnostics::{multispan_sugg, span_lint_and_then};
-use clippy_utils::differing_macro_contexts;
 use clippy_utils::source::{snippet, snippet_opt};
 use clippy_utils::ty::is_type_diagnostic_item;
 
@@ -123,7 +122,7 @@ impl<'tcx> LateLintPass<'tcx> for ImplicitHasher {
                 vis.visit_ty(impl_.self_ty);
 
                 for target in &vis.found {
-                    if differing_macro_contexts(item.span, target.span()) {
+                    if item.span.ctxt() != target.span().ctxt() {
                         return;
                     }
 
diff --git a/clippy_lints/src/methods/option_map_unwrap_or.rs b/clippy_lints/src/methods/option_map_unwrap_or.rs
index 9c6f4211031..6c641af59f9 100644
--- a/clippy_lints/src/methods/option_map_unwrap_or.rs
+++ b/clippy_lints/src/methods/option_map_unwrap_or.rs
@@ -1,5 +1,4 @@
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::differing_macro_contexts;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::is_copy;
 use clippy_utils::ty::is_type_diagnostic_item;
@@ -48,7 +47,7 @@ pub(super) fn check<'tcx>(
             }
         }
 
-        if differing_macro_contexts(unwrap_arg.span, map_span) {
+        if unwrap_arg.span.ctxt() != map_span.ctxt() {
             return;
         }
 
diff --git a/clippy_lints/src/swap.rs b/clippy_lints/src/swap.rs
index 4c10b12437d..1885f3ca414 100644
--- a/clippy_lints/src/swap.rs
+++ b/clippy_lints/src/swap.rs
@@ -2,7 +2,7 @@ use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{can_mut_borrow_both, differing_macro_contexts, eq_expr_value, std_or_core};
+use clippy_utils::{can_mut_borrow_both, eq_expr_value, std_or_core};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Block, Expr, ExprKind, PatKind, QPath, Stmt, StmtKind};
@@ -172,7 +172,7 @@ fn check_suspicious_swap(cx: &LateContext<'_>, block: &Block<'_>) {
         if_chain! {
             if let StmtKind::Semi(first) = w[0].kind;
             if let StmtKind::Semi(second) = w[1].kind;
-            if !differing_macro_contexts(first.span, second.span);
+            if first.span.ctxt() == second.span.ctxt();
             if let ExprKind::Assign(lhs0, rhs0, _) = first.kind;
             if let ExprKind::Assign(lhs1, rhs1, _) = second.kind;
             if eq_expr_value(cx, lhs0, rhs1);
diff --git a/clippy_lints/src/unwrap.rs b/clippy_lints/src/unwrap.rs
index e9840487013..9b9e25326f9 100644
--- a/clippy_lints/src/unwrap.rs
+++ b/clippy_lints/src/unwrap.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::higher;
 use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{differing_macro_contexts, path_to_local, usage::is_potentially_mutated};
+use clippy_utils::{path_to_local, usage::is_potentially_mutated};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_expr, walk_fn, FnKind, Visitor};
@@ -238,8 +238,9 @@ impl<'a, 'tcx> Visitor<'tcx> for UnwrappableVariablesVisitor<'a, 'tcx> {
                 if let Some(unwrappable) = self.unwrappables.iter()
                     .find(|u| u.local_id == id);
                 // Span contexts should not differ with the conditional branch
-                if !differing_macro_contexts(unwrappable.branch.span, expr.span);
-                if !differing_macro_contexts(unwrappable.branch.span, unwrappable.check.span);
+                let span_ctxt = expr.span.ctxt();
+                if unwrappable.branch.span.ctxt() == span_ctxt;
+                if unwrappable.check.span.ctxt() == span_ctxt;
                 then {
                     if call_to_unwrap == unwrappable.safe_to_unwrap {
                         let is_entire_condition = unwrappable.is_entire_condition;
diff --git a/clippy_utils/src/hir_utils.rs b/clippy_utils/src/hir_utils.rs
index ed573ad9056..a2b10c12eb9 100644
--- a/clippy_utils/src/hir_utils.rs
+++ b/clippy_utils/src/hir_utils.rs
@@ -1,5 +1,4 @@
 use crate::consts::{constant_context, constant_simple};
-use crate::differing_macro_contexts;
 use crate::source::snippet_opt;
 use rustc_ast::ast::InlineAsmTemplatePiece;
 use rustc_data_structures::fx::FxHasher;
@@ -186,7 +185,7 @@ impl HirEqInterExpr<'_, '_, '_> {
 
     #[allow(clippy::similar_names)]
     pub fn eq_expr(&mut self, left: &Expr<'_>, right: &Expr<'_>) -> bool {
-        if !self.inner.allow_side_effects && differing_macro_contexts(left.span, right.span) {
+        if !self.inner.allow_side_effects && left.span.ctxt() != right.span.ctxt() {
             return false;
         }
 
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index ed73364841c..f10f130bc32 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -134,13 +134,6 @@ macro_rules! extract_msrv_attr {
     };
 }
 
-/// Returns `true` if the two spans come from differing expansions (i.e., one is
-/// from a macro and one isn't).
-#[must_use]
-pub fn differing_macro_contexts(lhs: Span, rhs: Span) -> bool {
-    rhs.ctxt() != lhs.ctxt()
-}
-
 /// If the given expression is a local binding, find the initializer expression.
 /// If that initializer expression is another local binding, find its initializer again.
 /// This process repeats as long as possible (but usually no more than once). Initializer
diff --git a/doc/common_tools_writing_lints.md b/doc/common_tools_writing_lints.md
index 6c8a3dc418b..36c454745ba 100644
--- a/doc/common_tools_writing_lints.md
+++ b/doc/common_tools_writing_lints.md
@@ -235,7 +235,11 @@ Use the following functions to deal with macros:
    assert_eq!(in_external_macro(cx.sess(), match_span), true);
    ```
 
-- `differing_macro_contexts()`: returns true if the two given spans are not from the same context
+- `span.ctxt()`: the span's context represents whether it is from expansion, and if so, what expanded it
+
+One thing `SpanContext` is useful for is to check if two spans are in the same context. For example,
+in `a == b`, `a` and `b` have the same context. In a `macro_rules!` with `a == $b`, `$b` is expanded to some
+expression with a different context from `a`.
 
    ```rust
    macro_rules! m {
@@ -252,7 +256,7 @@ Use the following functions to deal with macros:
    // These spans are not from the same context
    // x.is_some() is from inside the macro
    // x.unwrap() is from outside the macro
-   assert_eq!(differing_macro_contexts(x_is_some_span, x_unwrap_span), true);
+   assert_eq!(x_is_some_span.ctxt(), x_unwrap_span.ctxt());
    ```
 
 [TyS]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/struct.TyS.html
-- 
cgit 1.4.1-3-g733a5


From 98c6381a387ac05e27c03ccfc64146bf4934f5c8 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Thu, 6 Jan 2022 09:31:38 -0600
Subject: Factor out single_segment_path

---
 clippy_lints/src/loops/single_element_loop.rs  | 24 ++++++++++--------------
 clippy_lints/src/methods/chars_cmp.rs          | 15 ++++++---------
 clippy_lints/src/methods/option_map_or_none.rs | 13 ++++++-------
 clippy_lints/src/ranges.rs                     | 26 +++++++-------------------
 clippy_utils/src/lib.rs                        |  8 --------
 5 files changed, 29 insertions(+), 57 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/single_element_loop.rs b/clippy_lints/src/loops/single_element_loop.rs
index 15f419e4410..36ecd83f7d6 100644
--- a/clippy_lints/src/loops/single_element_loop.rs
+++ b/clippy_lints/src/loops/single_element_loop.rs
@@ -1,10 +1,9 @@
 use super::SINGLE_ELEMENT_LOOP;
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::single_segment_path;
-use clippy_utils::source::{indent_of, snippet};
+use clippy_utils::source::{indent_of, snippet_with_applicability};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
-use rustc_hir::{BorrowKind, Expr, ExprKind, Pat, PatKind};
+use rustc_hir::{BorrowKind, Expr, ExprKind, Pat};
 use rustc_lint::LateContext;
 
 pub(super) fn check<'tcx>(
@@ -16,24 +15,21 @@ pub(super) fn check<'tcx>(
 ) {
     let arg_expr = match arg.kind {
         ExprKind::AddrOf(BorrowKind::Ref, _, ref_arg) => ref_arg,
-        ExprKind::MethodCall(method, args, _) if args.len() == 1 && method.ident.name == rustc_span::sym::iter => {
-            &args[0]
-        },
+        ExprKind::MethodCall(method, [arg], _) if method.ident.name == rustc_span::sym::iter => arg,
         _ => return,
     };
     if_chain! {
-        if let PatKind::Binding(.., target, _) = pat.kind;
         if let ExprKind::Array([arg_expression]) = arg_expr.kind;
-        if let ExprKind::Path(ref list_item) = arg_expression.kind;
-        if let Some(list_item_name) = single_segment_path(list_item).map(|ps| ps.ident.name);
         if let ExprKind::Block(block, _) = body.kind;
         if !block.stmts.is_empty();
-
         then {
-            let mut block_str = snippet(cx, block.span, "..").into_owned();
+            let mut applicability = Applicability::MachineApplicable;
+            let pat_snip = snippet_with_applicability(cx, pat.span, "..", &mut applicability);
+            let arg_snip = snippet_with_applicability(cx, arg_expression.span, "..", &mut applicability);
+            let mut block_str = snippet_with_applicability(cx, block.span, "..", &mut applicability).into_owned();
             block_str.remove(0);
             block_str.pop();
-
+            let indent = " ".repeat(indent_of(cx, block.stmts[0].span).unwrap_or(0));
 
             span_lint_and_sugg(
                 cx,
@@ -41,8 +37,8 @@ pub(super) fn check<'tcx>(
                 expr.span,
                 "for loop over a single element",
                 "try",
-                format!("{{\n{}let {} = &{};{}}}", " ".repeat(indent_of(cx, block.stmts[0].span).unwrap_or(0)), target.name, list_item_name, block_str),
-                Applicability::MachineApplicable
+                format!("{{\n{}let {} = &{};{}}}", indent, pat_snip, arg_snip, block_str),
+                applicability,
             )
         }
     }
diff --git a/clippy_lints/src/methods/chars_cmp.rs b/clippy_lints/src/methods/chars_cmp.rs
index 514c4118765..2cf2c5641bf 100644
--- a/clippy_lints/src/methods/chars_cmp.rs
+++ b/clippy_lints/src/methods/chars_cmp.rs
@@ -1,13 +1,12 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::{method_chain_args, single_segment_path};
+use clippy_utils::{method_chain_args, path_def_id};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
 use rustc_lint::Lint;
-use rustc_middle::ty;
-use rustc_span::sym;
+use rustc_middle::ty::{self, DefIdTree};
 
 /// Wrapper fn for `CHARS_NEXT_CMP` and `CHARS_LAST_CMP` lints.
 pub(super) fn check(
@@ -19,11 +18,9 @@ pub(super) fn check(
 ) -> bool {
     if_chain! {
         if let Some(args) = method_chain_args(info.chain, chain_methods);
-        if let hir::ExprKind::Call(fun, arg_char) = info.other.kind;
-        if arg_char.len() == 1;
-        if let hir::ExprKind::Path(ref qpath) = fun.kind;
-        if let Some(segment) = single_segment_path(qpath);
-        if segment.ident.name == sym::Some;
+        if let hir::ExprKind::Call(fun, [arg_char]) = info.other.kind;
+        if let Some(id) = path_def_id(cx, fun).and_then(|ctor_id| cx.tcx.parent(ctor_id));
+        if Some(id) == cx.tcx.lang_items().option_some_variant();
         then {
             let mut applicability = Applicability::MachineApplicable;
             let self_ty = cx.typeck_results().expr_ty_adjusted(&args[0][0]).peel_refs();
@@ -42,7 +39,7 @@ pub(super) fn check(
                         if info.eq { "" } else { "!" },
                         snippet_with_applicability(cx, args[0][0].span, "..", &mut applicability),
                         suggest,
-                        snippet_with_applicability(cx, arg_char[0].span, "..", &mut applicability)),
+                        snippet_with_applicability(cx, arg_char.span, "..", &mut applicability)),
                 applicability,
             );
 
diff --git a/clippy_lints/src/methods/option_map_or_none.rs b/clippy_lints/src/methods/option_map_or_none.rs
index 5e5c1038e82..bdf8cea1207 100644
--- a/clippy_lints/src/methods/option_map_or_none.rs
+++ b/clippy_lints/src/methods/option_map_or_none.rs
@@ -1,11 +1,12 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{is_lang_ctor, single_segment_path};
+use clippy_utils::{is_lang_ctor, path_def_id};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_hir::LangItem::{OptionNone, OptionSome};
 use rustc_lint::LateContext;
+use rustc_middle::ty::DefIdTree;
 use rustc_span::symbol::sym;
 
 use super::OPTION_MAP_OR_NONE;
@@ -76,13 +77,11 @@ pub(super) fn check<'tcx>(
         if let hir::ExprKind::Closure(_, _, id, span, _) = map_arg.kind;
             let arg_snippet = snippet(cx, span, "..");
             let body = cx.tcx.hir().body(id);
-                if let Some((func, arg_char)) = reduce_unit_expression(cx, &body.value);
-                if arg_char.len() == 1;
-                if let hir::ExprKind::Path(ref qpath) = func.kind;
-                if let Some(segment) = single_segment_path(qpath);
-                if segment.ident.name == sym::Some;
+                if let Some((func, [arg_char])) = reduce_unit_expression(cx, &body.value);
+                if let Some(id) = path_def_id(cx, func).and_then(|ctor_id| cx.tcx.parent(ctor_id));
+                if Some(id) == cx.tcx.lang_items().option_some_variant();
                 then {
-                    let func_snippet = snippet(cx, arg_char[0].span, "..");
+                    let func_snippet = snippet(cx, arg_char.span, "..");
                     let msg = "called `map_or(None, ..)` on an `Option` value. This can be done more directly by calling \
                        `map(..)` instead";
                     return span_lint_and_sugg(
diff --git a/clippy_lints/src/ranges.rs b/clippy_lints/src/ranges.rs
index 8065ed3ffc5..e213c208794 100644
--- a/clippy_lints/src/ranges.rs
+++ b/clippy_lints/src/ranges.rs
@@ -2,19 +2,18 @@ use clippy_utils::consts::{constant, Constant};
 use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::{snippet, snippet_opt, snippet_with_applicability};
 use clippy_utils::sugg::Sugg;
-use clippy_utils::{get_parent_expr, in_constant, is_integer_const, meets_msrv, msrvs, single_segment_path};
+use clippy_utils::{get_parent_expr, in_constant, is_integer_const, meets_msrv, msrvs, path_to_local};
 use clippy_utils::{higher, SpanlessEq};
 use if_chain::if_chain;
 use rustc_ast::ast::RangeLimits;
 use rustc_errors::Applicability;
-use rustc_hir::{BinOpKind, Expr, ExprKind, PathSegment, QPath};
+use rustc_hir::{BinOpKind, Expr, ExprKind, HirId, PathSegment, QPath};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
 use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::{Span, Spanned};
 use rustc_span::sym;
-use rustc_span::symbol::Ident;
 use std::cmp::Ordering;
 
 declare_clippy_lint! {
@@ -220,12 +219,12 @@ fn check_possible_range_contains(cx: &LateContext<'_>, op: BinOpKind, l: &Expr<'
         _ => return,
     };
     // value, name, order (higher/lower), inclusiveness
-    if let (Some((lval, lname, name_span, lval_span, lord, linc)), Some((rval, rname, _, rval_span, rord, rinc))) =
+    if let (Some((lval, lid, name_span, lval_span, lord, linc)), Some((rval, rid, _, rval_span, rord, rinc))) =
         (check_range_bounds(cx, l), check_range_bounds(cx, r))
     {
         // we only lint comparisons on the same name and with different
         // direction
-        if lname != rname || lord == rord {
+        if lid != rid || lord == rord {
             return;
         }
         let ord = Constant::partial_cmp(cx.tcx, cx.typeck_results().expr_ty(l), &lval, &rval);
@@ -293,7 +292,7 @@ fn check_possible_range_contains(cx: &LateContext<'_>, op: BinOpKind, l: &Expr<'
     }
 }
 
-fn check_range_bounds(cx: &LateContext<'_>, ex: &Expr<'_>) -> Option<(Constant, Ident, Span, Span, Ordering, bool)> {
+fn check_range_bounds(cx: &LateContext<'_>, ex: &Expr<'_>) -> Option<(Constant, HirId, Span, Span, Ordering, bool)> {
     if let ExprKind::Binary(ref op, l, r) = ex.kind {
         let (inclusive, ordering) = match op.node {
             BinOpKind::Gt => (false, Ordering::Greater),
@@ -302,11 +301,11 @@ fn check_range_bounds(cx: &LateContext<'_>, ex: &Expr<'_>) -> Option<(Constant,
             BinOpKind::Le => (true, Ordering::Less),
             _ => return None,
         };
-        if let Some(id) = match_ident(l) {
+        if let Some(id) = path_to_local(l) {
             if let Some((c, _)) = constant(cx, cx.typeck_results(), r) {
                 return Some((c, id, l.span, r.span, ordering, inclusive));
             }
-        } else if let Some(id) = match_ident(r) {
+        } else if let Some(id) = path_to_local(r) {
             if let Some((c, _)) = constant(cx, cx.typeck_results(), l) {
                 return Some((c, id, r.span, l.span, ordering.reverse(), inclusive));
             }
@@ -315,17 +314,6 @@ fn check_range_bounds(cx: &LateContext<'_>, ex: &Expr<'_>) -> Option<(Constant,
     None
 }
 
-fn match_ident(e: &Expr<'_>) -> Option<Ident> {
-    if let ExprKind::Path(ref qpath) = e.kind {
-        if let Some(seg) = single_segment_path(qpath) {
-            if seg.args.is_none() {
-                return Some(seg.ident);
-            }
-        }
-    }
-    None
-}
-
 fn check_range_zip_with_len(cx: &LateContext<'_>, path: &PathSegment<'_>, args: &[Expr<'_>], span: Span) {
     if_chain! {
         if path.ident.as_str() == "zip";
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index f10f130bc32..3df7af601cf 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -326,14 +326,6 @@ pub fn qpath_generic_tys<'tcx>(qpath: &QPath<'tcx>) -> impl Iterator<Item = &'tc
         })
 }
 
-pub fn single_segment_path<'tcx>(path: &QPath<'tcx>) -> Option<&'tcx PathSegment<'tcx>> {
-    match *path {
-        QPath::Resolved(_, path) => path.segments.get(0),
-        QPath::TypeRelative(_, seg) => Some(seg),
-        QPath::LangItem(..) => None,
-    }
-}
-
 /// THIS METHOD IS DEPRECATED and will eventually be removed since it does not match against the
 /// entire path or resolved `DefId`. Prefer using `match_def_path`. Consider getting a `DefId` from
 /// `QPath::Resolved.1.res.opt_def_id()`.
-- 
cgit 1.4.1-3-g733a5


From 3771fe4adeafc0825a562b5b542ce1be0350b7dd Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Thu, 6 Jan 2022 09:35:25 -0600
Subject: Factor out expr_path_res

---
 clippy_lints/src/misc.rs |  7 +++----
 clippy_lints/src/ptr.rs  |  7 ++++---
 clippy_utils/src/lib.rs  | 17 ++---------------
 clippy_utils/src/ty.rs   |  4 ++--
 4 files changed, 11 insertions(+), 24 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/misc.rs b/clippy_lints/src/misc.rs
index 3918bdbdf43..ac82dd306a5 100644
--- a/clippy_lints/src/misc.rs
+++ b/clippy_lints/src/misc.rs
@@ -20,8 +20,8 @@ use rustc_span::symbol::sym;
 use clippy_utils::consts::{constant, Constant};
 use clippy_utils::sugg::Sugg;
 use clippy_utils::{
-    expr_path_res, get_item_name, get_parent_expr, in_constant, is_diag_trait_item, is_integer_const, iter_input_pats,
-    last_path_segment, match_any_def_paths, paths, unsext, SpanlessEq,
+    get_item_name, get_parent_expr, in_constant, is_diag_trait_item, is_integer_const, iter_input_pats,
+    last_path_segment, match_any_def_paths, path_def_id, paths, unsext, SpanlessEq,
 };
 
 declare_clippy_lint! {
@@ -583,8 +583,7 @@ fn check_to_owned(cx: &LateContext<'_>, expr: &Expr<'_>, other: &Expr<'_>, left:
             )
         },
         ExprKind::Call(path, [arg]) => {
-            if expr_path_res(cx, path)
-                .opt_def_id()
+            if path_def_id(cx, path)
                 .and_then(|id| match_any_def_paths(cx, id, &[&paths::FROM_STR_METHOD, &paths::FROM_FROM]))
                 .is_some()
             {
diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs
index b5d65542de0..26717c0c0fd 100644
--- a/clippy_lints/src/ptr.rs
+++ b/clippy_lints/src/ptr.rs
@@ -4,7 +4,8 @@ use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg, span_lint_and_the
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::expr_sig;
 use clippy_utils::{
-    expr_path_res, get_expr_use_or_unification_node, is_lint_allowed, match_any_diagnostic_items, path_to_local, paths,
+    expr_path_res, get_expr_use_or_unification_node, is_lint_allowed, is_lint_allowed, match_any_diagnostic_items,
+    path_def_id, path_to_local, paths, paths,
 };
 use if_chain::if_chain;
 use rustc_errors::Applicability;
@@ -665,8 +666,8 @@ fn get_rptr_lm<'tcx>(ty: &'tcx hir::Ty<'tcx>) -> Option<(&'tcx Lifetime, Mutabil
 
 fn is_null_path(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
     if let ExprKind::Call(pathexp, []) = expr.kind {
-        expr_path_res(cx, pathexp).opt_def_id().map_or(false, |id| {
-            match_any_diagnostic_items(cx, id, &[sym::ptr_null, sym::ptr_null_mut]).is_some()
+        path_def_id(cx, pathexp).map_or(false, |id| {
+            matches!(cx.tcx.get_diagnostic_name(id), Some(sym::ptr_null | sym::ptr_null_mut))
         })
     } else {
         false
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 3df7af601cf..eeadc6d4dda 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -357,15 +357,6 @@ pub fn match_qpath(path: &QPath<'_>, segments: &[&str]) -> bool {
     }
 }
 
-/// If the expression is a path, resolve it. Otherwise, return `Res::Err`.
-pub fn expr_path_res(cx: &LateContext<'_>, expr: &Expr<'_>) -> Res {
-    if let ExprKind::Path(p) = &expr.kind {
-        cx.qpath_res(p, expr.hir_id)
-    } else {
-        Res::Err
-    }
-}
-
 /// Resolves the path to a `DefId` and checks if it matches the given path.
 pub fn is_qpath_def_path(cx: &LateContext<'_>, path: &QPath<'_>, hir_id: HirId, segments: &[&str]) -> bool {
     cx.qpath_res(path, hir_id)
@@ -377,17 +368,13 @@ pub fn is_qpath_def_path(cx: &LateContext<'_>, path: &QPath<'_>, hir_id: HirId,
 ///
 /// Please use `is_expr_diagnostic_item` if the target is a diagnostic item.
 pub fn is_expr_path_def_path(cx: &LateContext<'_>, expr: &Expr<'_>, segments: &[&str]) -> bool {
-    expr_path_res(cx, expr)
-        .opt_def_id()
-        .map_or(false, |id| match_def_path(cx, id, segments))
+    path_def_id(cx, expr).map_or(false, |id| match_def_path(cx, id, segments))
 }
 
 /// If the expression is a path, resolves it to a `DefId` and checks if it matches the given
 /// diagnostic item.
 pub fn is_expr_diagnostic_item(cx: &LateContext<'_>, expr: &Expr<'_>, diag_item: Symbol) -> bool {
-    expr_path_res(cx, expr)
-        .opt_def_id()
-        .map_or(false, |id| cx.tcx.is_diagnostic_item(diag_item, id))
+    path_def_id(cx, expr).map_or(false, |id| cx.tcx.is_diagnostic_item(diag_item, id))
 }
 
 /// THIS METHOD IS DEPRECATED and will eventually be removed since it does not match against the
diff --git a/clippy_utils/src/ty.rs b/clippy_utils/src/ty.rs
index d057da73302..aa3ea2d23da 100644
--- a/clippy_utils/src/ty.rs
+++ b/clippy_utils/src/ty.rs
@@ -20,7 +20,7 @@ use rustc_trait_selection::infer::InferCtxtExt;
 use rustc_trait_selection::traits::query::normalize::AtExt;
 use std::iter;
 
-use crate::{expr_path_res, match_def_path, must_use_attr};
+use crate::{match_def_path, must_use_attr, path_res};
 
 // Checks if the given type implements copy.
 pub fn is_copy<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
@@ -443,7 +443,7 @@ impl<'tcx> ExprFnSig<'tcx> {
 
 /// If the expression is function like, get the signature for it.
 pub fn expr_sig<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>) -> Option<ExprFnSig<'tcx>> {
-    if let Res::Def(DefKind::Fn | DefKind::Ctor(_, CtorKind::Fn) | DefKind::AssocFn, id) = expr_path_res(cx, expr) {
+    if let Res::Def(DefKind::Fn | DefKind::Ctor(_, CtorKind::Fn) | DefKind::AssocFn, id) = path_res(cx, expr) {
         Some(ExprFnSig::Sig(cx.tcx.fn_sig(id)))
     } else {
         let ty = cx.typeck_results().expr_ty_adjusted(expr).peel_refs();
-- 
cgit 1.4.1-3-g733a5


From ece7fa4f9c4e934a3176de9abcf9ab3b71a6dd7c Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Thu, 6 Jan 2022 09:39:46 -0600
Subject: Factor out match_any_diagnostic_items

---
 clippy_lints/src/ptr.rs                            |  5 +---
 .../src/transmute/unsound_collection_transmute.rs  | 30 ++++++++++++----------
 clippy_utils/src/lib.rs                            | 10 +-------
 3 files changed, 18 insertions(+), 27 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs
index 26717c0c0fd..6decd18b0a3 100644
--- a/clippy_lints/src/ptr.rs
+++ b/clippy_lints/src/ptr.rs
@@ -3,10 +3,7 @@
 use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::expr_sig;
-use clippy_utils::{
-    expr_path_res, get_expr_use_or_unification_node, is_lint_allowed, is_lint_allowed, match_any_diagnostic_items,
-    path_def_id, path_to_local, paths, paths,
-};
+use clippy_utils::{get_expr_use_or_unification_node, is_lint_allowed, path_def_id, path_to_local, paths};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::def_id::DefId;
diff --git a/clippy_lints/src/transmute/unsound_collection_transmute.rs b/clippy_lints/src/transmute/unsound_collection_transmute.rs
index 2ce8d4031d7..2d67401a15f 100644
--- a/clippy_lints/src/transmute/unsound_collection_transmute.rs
+++ b/clippy_lints/src/transmute/unsound_collection_transmute.rs
@@ -1,29 +1,31 @@
 use super::utils::is_layout_incompatible;
 use super::UNSOUND_COLLECTION_TRANSMUTE;
 use clippy_utils::diagnostics::span_lint;
-use clippy_utils::match_any_diagnostic_items;
 use rustc_hir::Expr;
 use rustc_lint::LateContext;
 use rustc_middle::ty::{self, Ty};
-use rustc_span::symbol::{sym, Symbol};
-
-// used to check for UNSOUND_COLLECTION_TRANSMUTE
-static COLLECTIONS: &[Symbol] = &[
-    sym::Vec,
-    sym::VecDeque,
-    sym::BinaryHeap,
-    sym::BTreeSet,
-    sym::BTreeMap,
-    sym::HashSet,
-    sym::HashMap,
-];
+use rustc_span::symbol::sym;
 
 /// Checks for `unsound_collection_transmute` lint.
 /// Returns `true` if it's triggered, otherwise returns `false`.
 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>, from_ty: Ty<'tcx>, to_ty: Ty<'tcx>) -> bool {
     match (&from_ty.kind(), &to_ty.kind()) {
         (ty::Adt(from_adt, from_substs), ty::Adt(to_adt, to_substs)) => {
-            if from_adt.did != to_adt.did || match_any_diagnostic_items(cx, to_adt.did, COLLECTIONS).is_none() {
+            if from_adt.did != to_adt.did {
+                return false;
+            }
+            if !matches!(
+                cx.tcx.get_diagnostic_name(to_adt.did),
+                Some(
+                    sym::BTreeMap
+                        | sym::BTreeSet
+                        | sym::BinaryHeap
+                        | sym::HashMap
+                        | sym::HashSet
+                        | sym::Vec
+                        | sym::VecDeque
+                )
+            ) {
                 return false;
             }
             if from_substs
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index eeadc6d4dda..62066987232 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -1615,7 +1615,7 @@ pub fn match_function_call<'tcx>(
 /// Checks if the given `DefId` matches any of the paths. Returns the index of matching path, if
 /// any.
 ///
-/// Please use `match_any_diagnostic_items` if the targets are all diagnostic items.
+/// Please use `tcx.get_diagnostic_name` if the targets are all diagnostic items.
 pub fn match_any_def_paths(cx: &LateContext<'_>, did: DefId, paths: &[&[&str]]) -> Option<usize> {
     let search_path = cx.get_def_path(did);
     paths
@@ -1623,14 +1623,6 @@ pub fn match_any_def_paths(cx: &LateContext<'_>, did: DefId, paths: &[&[&str]])
         .position(|p| p.iter().map(|x| Symbol::intern(x)).eq(search_path.iter().copied()))
 }
 
-/// Checks if the given `DefId` matches any of provided diagnostic items. Returns the index of
-/// matching path, if any.
-pub fn match_any_diagnostic_items(cx: &LateContext<'_>, def_id: DefId, diag_items: &[Symbol]) -> Option<usize> {
-    diag_items
-        .iter()
-        .position(|item| cx.tcx.is_diagnostic_item(*item, def_id))
-}
-
 /// Checks if the given `DefId` matches the path.
 pub fn match_def_path<'tcx>(cx: &LateContext<'tcx>, did: DefId, syms: &[&str]) -> bool {
     // We should probably move to Symbols in Clippy as well rather than interning every time.
-- 
cgit 1.4.1-3-g733a5


From bd583d91a1bf3717f724a38531e142aa4a9ee6cc Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Thu, 6 Jan 2022 12:41:17 -0600
Subject: Factor out is_qpath_def_path

---
 clippy_lints/src/infinite_iter.rs                  | 12 ++---
 clippy_lints/src/matches.rs                        | 62 ++++++++++++----------
 .../src/methods/manual_saturating_arithmetic.rs    |  8 +--
 clippy_utils/src/lib.rs                            | 10 +---
 4 files changed, 44 insertions(+), 48 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/infinite_iter.rs b/clippy_lints/src/infinite_iter.rs
index 3008e86ef8b..b6badef02f5 100644
--- a/clippy_lints/src/infinite_iter.rs
+++ b/clippy_lints/src/infinite_iter.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::ty::{implements_trait, is_type_diagnostic_item};
-use clippy_utils::{get_trait_def_id, higher, is_qpath_def_path, paths};
+use clippy_utils::{get_trait_def_id, higher, match_def_path, path_def_id, paths};
 use rustc_hir::{BorrowKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -167,13 +167,9 @@ fn is_infinite(cx: &LateContext<'_>, expr: &Expr<'_>) -> Finiteness {
         },
         ExprKind::Block(block, _) => block.expr.as_ref().map_or(Finite, |e| is_infinite(cx, e)),
         ExprKind::Box(e) | ExprKind::AddrOf(BorrowKind::Ref, _, e) => is_infinite(cx, e),
-        ExprKind::Call(path, _) => {
-            if let ExprKind::Path(ref qpath) = path.kind {
-                is_qpath_def_path(cx, qpath, path.hir_id, &paths::ITER_REPEAT).into()
-            } else {
-                Finite
-            }
-        },
+        ExprKind::Call(path, _) => path_def_id(cx, path)
+            .map_or(false, |id| match_def_path(cx, id, &paths::ITER_REPEAT))
+            .into(),
         ExprKind::Struct(..) => higher::Range::hir(expr).map_or(false, |r| r.end.is_none()).into(),
         _ => Finite,
     }
diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
index 2579404fb18..81ae4dacdf6 100644
--- a/clippy_lints/src/matches.rs
+++ b/clippy_lints/src/matches.rs
@@ -1765,22 +1765,22 @@ where
 mod redundant_pattern_match {
     use super::REDUNDANT_PATTERN_MATCHING;
     use clippy_utils::diagnostics::span_lint_and_then;
-    use clippy_utils::higher;
     use clippy_utils::source::snippet;
     use clippy_utils::sugg::Sugg;
     use clippy_utils::ty::{implements_trait, is_type_diagnostic_item, is_type_lang_item, match_type};
-    use clippy_utils::{is_lang_ctor, is_qpath_def_path, is_trait_method, paths};
+    use clippy_utils::{higher, match_def_path};
+    use clippy_utils::{is_lang_ctor, is_trait_method, paths};
     use if_chain::if_chain;
     use rustc_ast::ast::LitKind;
     use rustc_data_structures::fx::FxHashSet;
     use rustc_errors::Applicability;
-    use rustc_hir::LangItem::{OptionNone, OptionSome, PollPending, PollReady, ResultErr, ResultOk};
+    use rustc_hir::LangItem::{OptionNone, PollPending};
     use rustc_hir::{
         intravisit::{walk_expr, Visitor},
         Arm, Block, Expr, ExprKind, LangItem, MatchSource, Node, Pat, PatKind, QPath, UnOp,
     };
     use rustc_lint::LateContext;
-    use rustc_middle::ty::{self, subst::GenericArgKind, Ty};
+    use rustc_middle::ty::{self, subst::GenericArgKind, DefIdTree, Ty};
     use rustc_span::sym;
 
     pub fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
@@ -1956,28 +1956,31 @@ mod redundant_pattern_match {
         has_else: bool,
     ) {
         // also look inside refs
-        let mut kind = &let_pat.kind;
         // if we have &None for example, peel it so we can detect "if let None = x"
-        if let PatKind::Ref(inner, _mutability) = kind {
-            kind = &inner.kind;
-        }
+        let check_pat = match let_pat.kind {
+            PatKind::Ref(inner, _mutability) => inner,
+            _ => let_pat,
+        };
         let op_ty = cx.typeck_results().expr_ty(let_expr);
         // Determine which function should be used, and the type contained by the corresponding
         // variant.
-        let (good_method, inner_ty) = match kind {
-            PatKind::TupleStruct(ref path, [sub_pat], _) => {
+        let (good_method, inner_ty) = match check_pat.kind {
+            PatKind::TupleStruct(ref qpath, [sub_pat], _) => {
                 if let PatKind::Wild = sub_pat.kind {
-                    if is_lang_ctor(cx, path, ResultOk) {
+                    let res = cx.typeck_results().qpath_res(qpath, check_pat.hir_id);
+                    let Some(id) = res.opt_def_id().and_then(|ctor_id| cx.tcx.parent(ctor_id)) else { return };
+                    let lang_items = cx.tcx.lang_items();
+                    if Some(id) == lang_items.result_ok_variant() {
                         ("is_ok()", try_get_generic_ty(op_ty, 0).unwrap_or(op_ty))
-                    } else if is_lang_ctor(cx, path, ResultErr) {
+                    } else if Some(id) == lang_items.result_err_variant() {
                         ("is_err()", try_get_generic_ty(op_ty, 1).unwrap_or(op_ty))
-                    } else if is_lang_ctor(cx, path, OptionSome) {
+                    } else if Some(id) == lang_items.option_some_variant() {
                         ("is_some()", op_ty)
-                    } else if is_lang_ctor(cx, path, PollReady) {
+                    } else if Some(id) == lang_items.poll_ready_variant() {
                         ("is_ready()", op_ty)
-                    } else if is_qpath_def_path(cx, path, sub_pat.hir_id, &paths::IPADDR_V4) {
+                    } else if match_def_path(cx, id, &paths::IPADDR_V4) {
                         ("is_ipv4()", op_ty)
-                    } else if is_qpath_def_path(cx, path, sub_pat.hir_id, &paths::IPADDR_V6) {
+                    } else if match_def_path(cx, id, &paths::IPADDR_V6) {
                         ("is_ipv6()", op_ty)
                     } else {
                         return;
@@ -2177,17 +2180,22 @@ mod redundant_pattern_match {
         should_be_left: &'a str,
         should_be_right: &'a str,
     ) -> Option<&'a str> {
-        let body_node_pair = if is_qpath_def_path(cx, path_left, arms[0].pat.hir_id, expected_left)
-            && is_qpath_def_path(cx, path_right, arms[1].pat.hir_id, expected_right)
-        {
-            (&(*arms[0].body).kind, &(*arms[1].body).kind)
-        } else if is_qpath_def_path(cx, path_right, arms[1].pat.hir_id, expected_left)
-            && is_qpath_def_path(cx, path_left, arms[0].pat.hir_id, expected_right)
-        {
-            (&(*arms[1].body).kind, &(*arms[0].body).kind)
-        } else {
-            return None;
-        };
+        let left_id = cx
+            .typeck_results()
+            .qpath_res(path_left, arms[0].pat.hir_id)
+            .opt_def_id()?;
+        let right_id = cx
+            .typeck_results()
+            .qpath_res(path_right, arms[1].pat.hir_id)
+            .opt_def_id()?;
+        let body_node_pair =
+            if match_def_path(cx, left_id, expected_left) && match_def_path(cx, right_id, expected_right) {
+                (&(*arms[0].body).kind, &(*arms[1].body).kind)
+            } else if match_def_path(cx, right_id, expected_left) && match_def_path(cx, right_id, expected_right) {
+                (&(*arms[1].body).kind, &(*arms[0].body).kind)
+            } else {
+                return None;
+            };
 
         match body_node_pair {
             (ExprKind::Lit(ref lit_left), ExprKind::Lit(ref lit_right)) => match (&lit_left.node, &lit_right.node) {
diff --git a/clippy_lints/src/methods/manual_saturating_arithmetic.rs b/clippy_lints/src/methods/manual_saturating_arithmetic.rs
index 4307cbf0050..0fe510beaa0 100644
--- a/clippy_lints/src/methods/manual_saturating_arithmetic.rs
+++ b/clippy_lints/src/methods/manual_saturating_arithmetic.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::is_qpath_def_path;
 use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::{match_def_path, path_def_id};
 use if_chain::if_chain;
 use rustc_ast::ast;
 use rustc_errors::Applicability;
@@ -93,12 +93,12 @@ fn is_min_or_max<'tcx>(cx: &LateContext<'tcx>, expr: &hir::Expr<'_>) -> Option<M
     let ty_str = ty.to_string();
 
     // `std::T::MAX` `std::T::MIN` constants
-    if let hir::ExprKind::Path(path) = &expr.kind {
-        if is_qpath_def_path(cx, path, expr.hir_id, &["core", &ty_str, "MAX"][..]) {
+    if let Some(id) = path_def_id(cx, expr) {
+        if match_def_path(cx, id, &["core", &ty_str, "MAX"]) {
             return Some(MinMax::Max);
         }
 
-        if is_qpath_def_path(cx, path, expr.hir_id, &["core", &ty_str, "MIN"][..]) {
+        if match_def_path(cx, id, &["core", &ty_str, "MIN"]) {
             return Some(MinMax::Min);
         }
     }
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 62066987232..f4fdb7c13d3 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -357,13 +357,6 @@ pub fn match_qpath(path: &QPath<'_>, segments: &[&str]) -> bool {
     }
 }
 
-/// Resolves the path to a `DefId` and checks if it matches the given path.
-pub fn is_qpath_def_path(cx: &LateContext<'_>, path: &QPath<'_>, hir_id: HirId, segments: &[&str]) -> bool {
-    cx.qpath_res(path, hir_id)
-        .opt_def_id()
-        .map_or(false, |id| match_def_path(cx, id, segments))
-}
-
 /// If the expression is a path, resolves it to a `DefId` and checks if it matches the given path.
 ///
 /// Please use `is_expr_diagnostic_item` if the target is a diagnostic item.
@@ -1775,8 +1768,7 @@ pub fn is_expr_identity_function(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool
 
     match expr.kind {
         ExprKind::Closure(_, _, body_id, _, _) => is_body_identity_function(cx, cx.tcx.hir().body(body_id)),
-        ExprKind::Path(ref path) => is_qpath_def_path(cx, path, expr.hir_id, &paths::CONVERT_IDENTITY),
-        _ => false,
+        _ => path_def_id(cx, expr).map_or(false, |id| match_def_path(cx, id, &paths::CONVERT_IDENTITY)),
     }
 }
 
-- 
cgit 1.4.1-3-g733a5


From b7000b2a5363430af917f7a4df17d1b7a10f5cc4 Mon Sep 17 00:00:00 2001
From: Georgy Komarov <jubnzv@gmail.com>
Date: Sat, 15 Jan 2022 12:27:24 +0300
Subject: Add `default_union_representation` lint

Closes #8235
---
 CHANGELOG.md                                     |   1 +
 clippy_lints/src/default_union_representation.rs | 105 +++++++++++++++++++++++
 clippy_lints/src/lib.register_lints.rs           |   1 +
 clippy_lints/src/lib.register_restriction.rs     |   1 +
 clippy_lints/src/lib.rs                          |   2 +
 tests/ui/default_union_representation.rs         |  78 +++++++++++++++++
 tests/ui/default_union_representation.stderr     |  48 +++++++++++
 7 files changed, 236 insertions(+)
 create mode 100644 clippy_lints/src/default_union_representation.rs
 create mode 100644 tests/ui/default_union_representation.rs
 create mode 100644 tests/ui/default_union_representation.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 8f4da9a3827..60f84c769b7 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2930,6 +2930,7 @@ Released 2018-09-13
 [`declare_interior_mutable_const`]: https://rust-lang.github.io/rust-clippy/master/index.html#declare_interior_mutable_const
 [`default_numeric_fallback`]: https://rust-lang.github.io/rust-clippy/master/index.html#default_numeric_fallback
 [`default_trait_access`]: https://rust-lang.github.io/rust-clippy/master/index.html#default_trait_access
+[`default_union_representation`]: https://rust-lang.github.io/rust-clippy/master/index.html#default_union_representation
 [`deprecated_cfg_attr`]: https://rust-lang.github.io/rust-clippy/master/index.html#deprecated_cfg_attr
 [`deprecated_semver`]: https://rust-lang.github.io/rust-clippy/master/index.html#deprecated_semver
 [`deref_addrof`]: https://rust-lang.github.io/rust-clippy/master/index.html#deref_addrof
diff --git a/clippy_lints/src/default_union_representation.rs b/clippy_lints/src/default_union_representation.rs
new file mode 100644
index 00000000000..9b5da0bd8a6
--- /dev/null
+++ b/clippy_lints/src/default_union_representation.rs
@@ -0,0 +1,105 @@
+use clippy_utils::diagnostics::span_lint_and_help;
+use rustc_hir::{self as hir, HirId, Item, ItemKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::layout::LayoutOf;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::sym;
+use rustc_typeck::hir_ty_to_ty;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Displays a warning when a union is declared with the default representation (without a `#[repr(C)]` attribute).
+    ///
+    /// ### Why is this bad?
+    /// Unions in Rust have unspecified layout by default, despite many people thinking that they
+    /// lay out each field at the start of the union (like C does). That is, there are no guarantees
+    /// about the offset of the fields for unions with multiple non-ZST fields without an explicitly
+    /// specified layout. These cases may lead to undefined behavior in unsafe blocks.
+    ///
+    /// ### Example
+    /// ```rust
+    /// union Foo {
+    ///     a: i32,
+    ///     b: u32,
+    /// }
+    ///
+    /// fn main() {
+    ///     let _x: u32 = unsafe {
+    ///         Foo { a: 0_i32 }.b // Undefined behaviour: `b` is allowed to be padding
+    ///     };
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// #[repr(C)]
+    /// union Foo {
+    ///     a: i32,
+    ///     b: u32,
+    /// }
+    ///
+    /// fn main() {
+    ///     let _x: u32 = unsafe {
+    ///         Foo { a: 0_i32 }.b // Now defined behaviour, this is just an i32 -> u32 transmute
+    ///     };
+    /// }
+    /// ```
+    #[clippy::version = "1.60.0"]
+    pub DEFAULT_UNION_REPRESENTATION,
+    restriction,
+    "unions without a `#[repr(C)]` attribute"
+}
+declare_lint_pass!(DefaultUnionRepresentation => [DEFAULT_UNION_REPRESENTATION]);
+
+impl<'tcx> LateLintPass<'tcx> for DefaultUnionRepresentation {
+    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
+        if is_union_with_two_non_zst_fields(cx, item) && !has_c_repr_attr(cx, item.hir_id()) {
+            span_lint_and_help(
+                cx,
+                DEFAULT_UNION_REPRESENTATION,
+                item.span,
+                "this union has the default representation",
+                None,
+                &format!(
+                    "consider annotating `{}` with `#[repr(C)]` to explicitly specify memory layout",
+                    cx.tcx.def_path_str(item.def_id.to_def_id())
+                ),
+            );
+        }
+    }
+}
+
+/// Returns true if the given item is a union with at least two non-ZST fields.
+fn is_union_with_two_non_zst_fields(cx: &LateContext<'_>, item: &Item<'_>) -> bool {
+    if let ItemKind::Union(data, _) = &item.kind {
+        data.fields().iter().filter(|f| !is_zst(cx, f.ty)).count() >= 2
+    } else {
+        false
+    }
+}
+
+fn is_zst(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>) -> bool {
+    if hir_ty.span.from_expansion() {
+        return false;
+    }
+    let ty = hir_ty_to_ty(cx.tcx, hir_ty);
+    if let Ok(layout) = cx.layout_of(ty) {
+        layout.is_zst()
+    } else {
+        false
+    }
+}
+
+fn has_c_repr_attr(cx: &LateContext<'_>, hir_id: HirId) -> bool {
+    cx.tcx.hir().attrs(hir_id).iter().any(|attr| {
+        if attr.has_name(sym::repr) {
+            if let Some(items) = attr.meta_item_list() {
+                for item in items {
+                    if item.is_word() && matches!(item.name_or_empty(), sym::C) {
+                        return true;
+                    }
+                }
+            }
+        }
+        false
+    })
+}
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 746bdb19c3d..c768df1554c 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -92,6 +92,7 @@ store.register_lints(&[
     default::DEFAULT_TRAIT_ACCESS,
     default::FIELD_REASSIGN_WITH_DEFAULT,
     default_numeric_fallback::DEFAULT_NUMERIC_FALLBACK,
+    default_union_representation::DEFAULT_UNION_REPRESENTATION,
     dereference::EXPLICIT_DEREF_METHODS,
     dereference::NEEDLESS_BORROW,
     dereference::REF_BINDING_TO_REFERENCE,
diff --git a/clippy_lints/src/lib.register_restriction.rs b/clippy_lints/src/lib.register_restriction.rs
index e7e2798da7d..5a89fdb05a9 100644
--- a/clippy_lints/src/lib.register_restriction.rs
+++ b/clippy_lints/src/lib.register_restriction.rs
@@ -12,6 +12,7 @@ store.register_group(true, "clippy::restriction", Some("clippy_restriction"), ve
     LintId::of(create_dir::CREATE_DIR),
     LintId::of(dbg_macro::DBG_MACRO),
     LintId::of(default_numeric_fallback::DEFAULT_NUMERIC_FALLBACK),
+    LintId::of(default_union_representation::DEFAULT_UNION_REPRESENTATION),
     LintId::of(disallowed_script_idents::DISALLOWED_SCRIPT_IDENTS),
     LintId::of(else_if_without_else::ELSE_IF_WITHOUT_ELSE),
     LintId::of(exhaustive_items::EXHAUSTIVE_ENUMS),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 79e9882fef4..1dfc03dc34b 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -189,6 +189,7 @@ mod create_dir;
 mod dbg_macro;
 mod default;
 mod default_numeric_fallback;
+mod default_union_representation;
 mod dereference;
 mod derivable_impls;
 mod derive;
@@ -860,6 +861,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_early_pass(|| Box::new(single_char_lifetime_names::SingleCharLifetimeNames));
     store.register_late_pass(move || Box::new(borrow_as_ptr::BorrowAsPtr::new(msrv)));
     store.register_late_pass(move || Box::new(manual_bits::ManualBits::new(msrv)));
+    store.register_late_pass(|| Box::new(default_union_representation::DefaultUnionRepresentation));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/tests/ui/default_union_representation.rs b/tests/ui/default_union_representation.rs
new file mode 100644
index 00000000000..93b2d33da2c
--- /dev/null
+++ b/tests/ui/default_union_representation.rs
@@ -0,0 +1,78 @@
+#![feature(transparent_unions)]
+#![warn(clippy::default_union_representation)]
+
+union NoAttribute {
+    a: i32,
+    b: u32,
+}
+
+#[repr(C)]
+union ReprC {
+    a: i32,
+    b: u32,
+}
+
+#[repr(packed)]
+union ReprPacked {
+    a: i32,
+    b: u32,
+}
+
+#[repr(C, packed)]
+union ReprCPacked {
+    a: i32,
+    b: u32,
+}
+
+#[repr(C, align(32))]
+union ReprCAlign {
+    a: i32,
+    b: u32,
+}
+
+#[repr(align(32))]
+union ReprAlign {
+    a: i32,
+    b: u32,
+}
+
+union SingleZST {
+    f0: (),
+}
+union ZSTsAndField1 {
+    f0: u32,
+    f1: (),
+    f2: (),
+    f3: (),
+}
+union ZSTsAndField2 {
+    f0: (),
+    f1: (),
+    f2: u32,
+    f3: (),
+}
+union ZSTAndTwoFields {
+    f0: u32,
+    f1: u64,
+    f2: (),
+}
+
+#[repr(C)]
+union CZSTAndTwoFields {
+    f0: u32,
+    f1: u64,
+    f2: (),
+}
+
+#[repr(transparent)]
+union ReprTransparent {
+    a: i32,
+}
+
+#[repr(transparent)]
+union ReprTransparentZST {
+    a: i32,
+    b: (),
+}
+
+fn main() {}
diff --git a/tests/ui/default_union_representation.stderr b/tests/ui/default_union_representation.stderr
new file mode 100644
index 00000000000..138884af868
--- /dev/null
+++ b/tests/ui/default_union_representation.stderr
@@ -0,0 +1,48 @@
+error: this union has the default representation
+  --> $DIR/default_union_representation.rs:4:1
+   |
+LL | / union NoAttribute {
+LL | |     a: i32,
+LL | |     b: u32,
+LL | | }
+   | |_^
+   |
+   = note: `-D clippy::default-union-representation` implied by `-D warnings`
+   = help: consider annotating `NoAttribute` with `#[repr(C)]` to explicitly specify memory layout
+
+error: this union has the default representation
+  --> $DIR/default_union_representation.rs:16:1
+   |
+LL | / union ReprPacked {
+LL | |     a: i32,
+LL | |     b: u32,
+LL | | }
+   | |_^
+   |
+   = help: consider annotating `ReprPacked` with `#[repr(C)]` to explicitly specify memory layout
+
+error: this union has the default representation
+  --> $DIR/default_union_representation.rs:34:1
+   |
+LL | / union ReprAlign {
+LL | |     a: i32,
+LL | |     b: u32,
+LL | | }
+   | |_^
+   |
+   = help: consider annotating `ReprAlign` with `#[repr(C)]` to explicitly specify memory layout
+
+error: this union has the default representation
+  --> $DIR/default_union_representation.rs:54:1
+   |
+LL | / union ZSTAndTwoFields {
+LL | |     f0: u32,
+LL | |     f1: u64,
+LL | |     f2: (),
+LL | | }
+   | |_^
+   |
+   = help: consider annotating `ZSTAndTwoFields` with `#[repr(C)]` to explicitly specify memory layout
+
+error: aborting due to 4 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 66bb7263b50f47878784902b5a208b7b26b74bc1 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sat, 29 Jan 2022 09:45:47 -0500
Subject: Don't lint `ptr_arg` for `&mut _` types in trait items

---
 clippy_lints/src/ptr.rs | 20 ++++++++++++++------
 tests/ui/ptr_arg.rs     |  6 ++++++
 2 files changed, 20 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs
index b5d65542de0..77bf5f002f7 100644
--- a/clippy_lints/src/ptr.rs
+++ b/clippy_lints/src/ptr.rs
@@ -153,7 +153,9 @@ impl<'tcx> LateLintPass<'tcx> for Ptr {
                 cx.tcx.fn_sig(item.def_id).skip_binder().inputs(),
                 sig.decl.inputs,
                 &[],
-            ) {
+            )
+            .filter(|arg| arg.mutability() == Mutability::Not)
+            {
                 span_lint_and_sugg(
                     cx,
                     PTR_ARG,
@@ -170,10 +172,10 @@ impl<'tcx> LateLintPass<'tcx> for Ptr {
     fn check_body(&mut self, cx: &LateContext<'tcx>, body: &'tcx Body<'_>) {
         let hir = cx.tcx.hir();
         let mut parents = hir.parent_iter(body.value.hir_id);
-        let (item_id, decl) = match parents.next() {
+        let (item_id, decl, is_trait_item) = match parents.next() {
             Some((_, Node::Item(i))) => {
                 if let ItemKind::Fn(sig, ..) = &i.kind {
-                    (i.def_id, sig.decl)
+                    (i.def_id, sig.decl, false)
                 } else {
                     return;
                 }
@@ -185,14 +187,14 @@ impl<'tcx> LateLintPass<'tcx> for Ptr {
                     return;
                 }
                 if let ImplItemKind::Fn(sig, _) = &i.kind {
-                    (i.def_id, sig.decl)
+                    (i.def_id, sig.decl, false)
                 } else {
                     return;
                 }
             },
             Some((_, Node::TraitItem(i))) => {
                 if let TraitItemKind::Fn(sig, _) = &i.kind {
-                    (i.def_id, sig.decl)
+                    (i.def_id, sig.decl, true)
                 } else {
                     return;
                 }
@@ -202,7 +204,9 @@ impl<'tcx> LateLintPass<'tcx> for Ptr {
 
         check_mut_from_ref(cx, decl);
         let sig = cx.tcx.fn_sig(item_id).skip_binder();
-        let lint_args: Vec<_> = check_fn_args(cx, sig.inputs(), decl.inputs, body.params).collect();
+        let lint_args: Vec<_> = check_fn_args(cx, sig.inputs(), decl.inputs, body.params)
+            .filter(|arg| !is_trait_item || arg.mutability() == Mutability::Not)
+            .collect();
         let results = check_ptr_arg_usage(cx, body, &lint_args);
 
         for (result, args) in results.iter().zip(lint_args.iter()).filter(|(r, _)| !r.skip) {
@@ -318,6 +322,10 @@ impl PtrArg<'_> {
             self.deref_ty.argless_str(),
         )
     }
+
+    fn mutability(&self) -> Mutability {
+        self.ref_prefix.mutability
+    }
 }
 
 struct RefPrefix {
diff --git a/tests/ui/ptr_arg.rs b/tests/ui/ptr_arg.rs
index ed724237808..00b99da2631 100644
--- a/tests/ui/ptr_arg.rs
+++ b/tests/ui/ptr_arg.rs
@@ -180,3 +180,9 @@ fn dyn_fn_requires_vec(v: &Vec<u32>, f: &dyn Fn(&Vec<u32>)) {
 // No error for types behind an alias (#7699)
 type A = Vec<u8>;
 fn aliased(a: &A) {}
+
+// Issue #8366
+pub trait Trait {
+    fn f(v: &mut Vec<i32>);
+    fn f2(v: &mut Vec<i32>) {}
+}
-- 
cgit 1.4.1-3-g733a5


From 8ccd26462032427741f753424702e78e1050e96b Mon Sep 17 00:00:00 2001
From: tamaron <tamaron1203@gmail.com>
Date: Sun, 30 Jan 2022 12:56:07 +0900
Subject: modify code

---
 clippy_lints/src/methods/mod.rs | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 18d4867b7eb..7847adce0f1 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -2402,10 +2402,13 @@ fn check_methods<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, msrv: Optio
             ("to_os_string" | "to_owned" | "to_path_buf" | "to_vec", []) => {
                 implicit_clone::check(cx, name, expr, recv);
             },
-            ("unwrap", []) => match method_call(recv) {
-                Some(("get", [recv, get_arg], _)) => get_unwrap::check(cx, expr, recv, get_arg, false),
-                Some(("get_mut", [recv, get_arg], _)) => get_unwrap::check(cx, expr, recv, get_arg, true),
-                _ => unwrap_used::check(cx, expr, recv),
+            ("unwrap", []) => {
+                match method_call(recv) {
+                    Some(("get", [recv, get_arg], _)) => get_unwrap::check(cx, expr, recv, get_arg, false),
+                    Some(("get_mut", [recv, get_arg], _)) => get_unwrap::check(cx, expr, recv, get_arg, true),
+                    _ => {},
+                }
+                unwrap_used::check(cx, expr, recv);
             },
             ("unwrap_or", [u_arg]) => match method_call(recv) {
                 Some((arith @ ("checked_add" | "checked_sub" | "checked_mul"), [lhs, rhs], _)) => {
-- 
cgit 1.4.1-3-g733a5


From 1a2364e534b75377c9e5727b29dca5017596bb1f Mon Sep 17 00:00:00 2001
From: tamaron <tamaron1203@gmail.com>
Date: Sun, 30 Jan 2022 14:59:25 +0900
Subject: fix code

---
 clippy_lints/src/methods/mod.rs | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 7847adce0f1..5b4a152afd5 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -2404,8 +2404,12 @@ fn check_methods<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, msrv: Optio
             },
             ("unwrap", []) => {
                 match method_call(recv) {
-                    Some(("get", [recv, get_arg], _)) => get_unwrap::check(cx, expr, recv, get_arg, false),
-                    Some(("get_mut", [recv, get_arg], _)) => get_unwrap::check(cx, expr, recv, get_arg, true),
+                    Some(("get", [recv, get_arg], _)) => {
+                        get_unwrap::check(cx, expr, recv, get_arg, false);
+                    },
+                    Some(("get_mut", [recv, get_arg], _)) => {
+                        get_unwrap::check(cx, expr, recv, get_arg, true);
+                    },
                     _ => {},
                 }
                 unwrap_used::check(cx, expr, recv);
-- 
cgit 1.4.1-3-g733a5


From 5faa7ebb709dfbd8d0b7274ffda05b08d70b8a3d Mon Sep 17 00:00:00 2001
From: dswij <dswijj@gmail.com>
Date: Mon, 31 Jan 2022 13:35:14 +0800
Subject: Fix `chars_next_cmp` suggestion not escaped

---
 clippy_lints/src/methods/chars_cmp_with_unwrap.rs |  2 +-
 tests/ui/starts_ends_with.fixed                   | 10 ++++-
 tests/ui/starts_ends_with.rs                      | 10 ++++-
 tests/ui/starts_ends_with.stderr                  | 50 +++++++++++++++++------
 4 files changed, 56 insertions(+), 16 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/chars_cmp_with_unwrap.rs b/clippy_lints/src/methods/chars_cmp_with_unwrap.rs
index 4275857757f..a7c0e43923e 100644
--- a/clippy_lints/src/methods/chars_cmp_with_unwrap.rs
+++ b/clippy_lints/src/methods/chars_cmp_with_unwrap.rs
@@ -32,7 +32,7 @@ pub(super) fn check<'tcx>(
                         if info.eq { "" } else { "!" },
                         snippet_with_applicability(cx, args[0][0].span, "..", &mut applicability),
                         suggest,
-                        c),
+                        c.escape_default()),
                 applicability,
             );
 
diff --git a/tests/ui/starts_ends_with.fixed b/tests/ui/starts_ends_with.fixed
index 7dfcf9c91e4..983fac7afe6 100644
--- a/tests/ui/starts_ends_with.fixed
+++ b/tests/ui/starts_ends_with.fixed
@@ -7,6 +7,10 @@ fn main() {}
 fn starts_with() {
     "".starts_with(' ');
     !"".starts_with(' ');
+
+    // Ensure that suggestion is escaped correctly
+    "".starts_with('\n');
+    !"".starts_with('\n');
 }
 
 fn chars_cmp_with_unwrap() {
@@ -31,7 +35,7 @@ fn chars_cmp_with_unwrap() {
         // !s.ends_with('o')
         // Nothing here
     }
-    if !s.ends_with('o') {
+    if !s.ends_with('\n') {
         // !s.ends_with('o')
         // Nothing here
     }
@@ -43,4 +47,8 @@ fn ends_with() {
     !"".ends_with(' ');
     "".ends_with(' ');
     !"".ends_with(' ');
+
+    // Ensure that suggestion is escaped correctly
+    "".ends_with('\n');
+    !"".ends_with('\n');
 }
diff --git a/tests/ui/starts_ends_with.rs b/tests/ui/starts_ends_with.rs
index e48a4246354..e3335dd2e2e 100644
--- a/tests/ui/starts_ends_with.rs
+++ b/tests/ui/starts_ends_with.rs
@@ -7,6 +7,10 @@ fn main() {}
 fn starts_with() {
     "".chars().next() == Some(' ');
     Some(' ') != "".chars().next();
+
+    // Ensure that suggestion is escaped correctly
+    "".chars().next() == Some('\n');
+    Some('\n') != "".chars().next();
 }
 
 fn chars_cmp_with_unwrap() {
@@ -31,7 +35,7 @@ fn chars_cmp_with_unwrap() {
         // !s.ends_with('o')
         // Nothing here
     }
-    if s.chars().last().unwrap() != 'o' {
+    if s.chars().last().unwrap() != '\n' {
         // !s.ends_with('o')
         // Nothing here
     }
@@ -43,4 +47,8 @@ fn ends_with() {
     Some(' ') != "".chars().last();
     "".chars().next_back() == Some(' ');
     Some(' ') != "".chars().next_back();
+
+    // Ensure that suggestion is escaped correctly
+    "".chars().last() == Some('\n');
+    Some('\n') != "".chars().last();
 }
diff --git a/tests/ui/starts_ends_with.stderr b/tests/ui/starts_ends_with.stderr
index 7c726d0e010..2dd9f53b802 100644
--- a/tests/ui/starts_ends_with.stderr
+++ b/tests/ui/starts_ends_with.stderr
@@ -13,13 +13,25 @@ LL |     Some(' ') != "".chars().next();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: like this: `!"".starts_with(' ')`
 
 error: you should use the `starts_with` method
-  --> $DIR/starts_ends_with.rs:14:8
+  --> $DIR/starts_ends_with.rs:12:5
+   |
+LL |     "".chars().next() == Some('/n');
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: like this: `"".starts_with('/n')`
+
+error: you should use the `starts_with` method
+  --> $DIR/starts_ends_with.rs:13:5
+   |
+LL |     Some('/n') != "".chars().next();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: like this: `!"".starts_with('/n')`
+
+error: you should use the `starts_with` method
+  --> $DIR/starts_ends_with.rs:18:8
    |
 LL |     if s.chars().next().unwrap() == 'f' {
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: like this: `s.starts_with('f')`
 
 error: you should use the `ends_with` method
-  --> $DIR/starts_ends_with.rs:18:8
+  --> $DIR/starts_ends_with.rs:22:8
    |
 LL |     if s.chars().next_back().unwrap() == 'o' {
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: like this: `s.ends_with('o')`
@@ -27,52 +39,64 @@ LL |     if s.chars().next_back().unwrap() == 'o' {
    = note: `-D clippy::chars-last-cmp` implied by `-D warnings`
 
 error: you should use the `ends_with` method
-  --> $DIR/starts_ends_with.rs:22:8
+  --> $DIR/starts_ends_with.rs:26:8
    |
 LL |     if s.chars().last().unwrap() == 'o' {
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: like this: `s.ends_with('o')`
 
 error: you should use the `starts_with` method
-  --> $DIR/starts_ends_with.rs:26:8
+  --> $DIR/starts_ends_with.rs:30:8
    |
 LL |     if s.chars().next().unwrap() != 'f' {
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: like this: `!s.starts_with('f')`
 
 error: you should use the `ends_with` method
-  --> $DIR/starts_ends_with.rs:30:8
+  --> $DIR/starts_ends_with.rs:34:8
    |
 LL |     if s.chars().next_back().unwrap() != 'o' {
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: like this: `!s.ends_with('o')`
 
 error: you should use the `ends_with` method
-  --> $DIR/starts_ends_with.rs:34:8
+  --> $DIR/starts_ends_with.rs:38:8
    |
-LL |     if s.chars().last().unwrap() != 'o' {
-   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: like this: `!s.ends_with('o')`
+LL |     if s.chars().last().unwrap() != '/n' {
+   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: like this: `!s.ends_with('/n')`
 
 error: you should use the `ends_with` method
-  --> $DIR/starts_ends_with.rs:42:5
+  --> $DIR/starts_ends_with.rs:46:5
    |
 LL |     "".chars().last() == Some(' ');
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: like this: `"".ends_with(' ')`
 
 error: you should use the `ends_with` method
-  --> $DIR/starts_ends_with.rs:43:5
+  --> $DIR/starts_ends_with.rs:47:5
    |
 LL |     Some(' ') != "".chars().last();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: like this: `!"".ends_with(' ')`
 
 error: you should use the `ends_with` method
-  --> $DIR/starts_ends_with.rs:44:5
+  --> $DIR/starts_ends_with.rs:48:5
    |
 LL |     "".chars().next_back() == Some(' ');
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: like this: `"".ends_with(' ')`
 
 error: you should use the `ends_with` method
-  --> $DIR/starts_ends_with.rs:45:5
+  --> $DIR/starts_ends_with.rs:49:5
    |
 LL |     Some(' ') != "".chars().next_back();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: like this: `!"".ends_with(' ')`
 
-error: aborting due to 12 previous errors
+error: you should use the `ends_with` method
+  --> $DIR/starts_ends_with.rs:52:5
+   |
+LL |     "".chars().last() == Some('/n');
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: like this: `"".ends_with('/n')`
+
+error: you should use the `ends_with` method
+  --> $DIR/starts_ends_with.rs:53:5
+   |
+LL |     Some('/n') != "".chars().last();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: like this: `!"".ends_with('/n')`
+
+error: aborting due to 16 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 97e5a70f472db51ea319367b5b424a55a77a2187 Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Thu, 20 Jan 2022 23:00:50 +0100
Subject: warn if we find multiple clippy configs

Fixes #8323
---
 clippy_lints/src/utils/conf.rs | 20 +++++++++++++++++++-
 1 file changed, 19 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index c9d99617c1e..36a7e67af6f 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -322,6 +322,9 @@ pub fn lookup_conf_file() -> io::Result<Option<PathBuf>> {
     let mut current = env::var_os("CLIPPY_CONF_DIR")
         .or_else(|| env::var_os("CARGO_MANIFEST_DIR"))
         .map_or_else(|| PathBuf::from("."), PathBuf::from);
+
+    let mut found_config: Option<PathBuf> = None;
+
     loop {
         for config_file_name in &CONFIG_FILE_NAMES {
             if let Ok(config_file) = current.join(config_file_name).canonicalize() {
@@ -329,11 +332,26 @@ pub fn lookup_conf_file() -> io::Result<Option<PathBuf>> {
                     Err(e) if e.kind() == io::ErrorKind::NotFound => {},
                     Err(e) => return Err(e),
                     Ok(md) if md.is_dir() => {},
-                    Ok(_) => return Ok(Some(config_file)),
+                    Ok(_) => {
+                        // warn if we happen to find two config files
+                        if let Some(ref found_config_) = found_config {
+                            eprintln!(
+                                "Warning: found two config files: {} and {}.\nUsing the first one!",
+                                found_config_.display(),
+                                config_file.display(),
+                            );
+                        } else {
+                            found_config = Some(config_file);
+                        }
+                    },
                 }
             }
         }
 
+        if found_config.is_some() {
+            return Ok(found_config);
+        }
+
         // If the current directory has no parent, we're done searching.
         if !current.pop() {
             return Ok(None);
-- 
cgit 1.4.1-3-g733a5


From 1193abe4c85ecd57f1a5634629874fb153a180ee Mon Sep 17 00:00:00 2001
From: Matthias Krüger <matthias.krueger@famsik.de>
Date: Sun, 30 Jan 2022 13:32:35 +0100
Subject: multiple configs: add tests

---
 clippy_lints/src/utils/conf.rs                            | 4 ++--
 tests/ui-cargo/multiple_config_files/no_warn/Cargo.toml   | 8 ++++++++
 tests/ui-cargo/multiple_config_files/no_warn/clippy.toml  | 1 +
 tests/ui-cargo/multiple_config_files/no_warn/src/main.rs  | 3 +++
 tests/ui-cargo/multiple_config_files/warn/.clippy.toml    | 1 +
 tests/ui-cargo/multiple_config_files/warn/Cargo.toml      | 8 ++++++++
 tests/ui-cargo/multiple_config_files/warn/clippy.toml     | 1 +
 tests/ui-cargo/multiple_config_files/warn/src/main.rs     | 3 +++
 tests/ui-cargo/multiple_config_files/warn/src/main.stderr | 2 ++
 9 files changed, 29 insertions(+), 2 deletions(-)
 create mode 100644 tests/ui-cargo/multiple_config_files/no_warn/Cargo.toml
 create mode 100644 tests/ui-cargo/multiple_config_files/no_warn/clippy.toml
 create mode 100644 tests/ui-cargo/multiple_config_files/no_warn/src/main.rs
 create mode 100644 tests/ui-cargo/multiple_config_files/warn/.clippy.toml
 create mode 100644 tests/ui-cargo/multiple_config_files/warn/Cargo.toml
 create mode 100644 tests/ui-cargo/multiple_config_files/warn/clippy.toml
 create mode 100644 tests/ui-cargo/multiple_config_files/warn/src/main.rs
 create mode 100644 tests/ui-cargo/multiple_config_files/warn/src/main.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 36a7e67af6f..680b2eb1da7 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -333,10 +333,10 @@ pub fn lookup_conf_file() -> io::Result<Option<PathBuf>> {
                     Err(e) => return Err(e),
                     Ok(md) if md.is_dir() => {},
                     Ok(_) => {
-                        // warn if we happen to find two config files
+                        // warn if we happen to find two config files #8323
                         if let Some(ref found_config_) = found_config {
                             eprintln!(
-                                "Warning: found two config files: {} and {}.\nUsing the first one!",
+                                "Using config file `{}`\nWarning: `{}` will be ignored.",
                                 found_config_.display(),
                                 config_file.display(),
                             );
diff --git a/tests/ui-cargo/multiple_config_files/no_warn/Cargo.toml b/tests/ui-cargo/multiple_config_files/no_warn/Cargo.toml
new file mode 100644
index 00000000000..79c973cbfd2
--- /dev/null
+++ b/tests/ui-cargo/multiple_config_files/no_warn/Cargo.toml
@@ -0,0 +1,8 @@
+[package]
+name = "no_warn"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
diff --git a/tests/ui-cargo/multiple_config_files/no_warn/clippy.toml b/tests/ui-cargo/multiple_config_files/no_warn/clippy.toml
new file mode 100644
index 00000000000..cda8d17eed4
--- /dev/null
+++ b/tests/ui-cargo/multiple_config_files/no_warn/clippy.toml
@@ -0,0 +1 @@
+avoid-breaking-exported-api = false
diff --git a/tests/ui-cargo/multiple_config_files/no_warn/src/main.rs b/tests/ui-cargo/multiple_config_files/no_warn/src/main.rs
new file mode 100644
index 00000000000..e7a11a969c0
--- /dev/null
+++ b/tests/ui-cargo/multiple_config_files/no_warn/src/main.rs
@@ -0,0 +1,3 @@
+fn main() {
+    println!("Hello, world!");
+}
diff --git a/tests/ui-cargo/multiple_config_files/warn/.clippy.toml b/tests/ui-cargo/multiple_config_files/warn/.clippy.toml
new file mode 100644
index 00000000000..cda8d17eed4
--- /dev/null
+++ b/tests/ui-cargo/multiple_config_files/warn/.clippy.toml
@@ -0,0 +1 @@
+avoid-breaking-exported-api = false
diff --git a/tests/ui-cargo/multiple_config_files/warn/Cargo.toml b/tests/ui-cargo/multiple_config_files/warn/Cargo.toml
new file mode 100644
index 00000000000..3d5c707579b
--- /dev/null
+++ b/tests/ui-cargo/multiple_config_files/warn/Cargo.toml
@@ -0,0 +1,8 @@
+[package]
+name = "warn"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
diff --git a/tests/ui-cargo/multiple_config_files/warn/clippy.toml b/tests/ui-cargo/multiple_config_files/warn/clippy.toml
new file mode 100644
index 00000000000..cda8d17eed4
--- /dev/null
+++ b/tests/ui-cargo/multiple_config_files/warn/clippy.toml
@@ -0,0 +1 @@
+avoid-breaking-exported-api = false
diff --git a/tests/ui-cargo/multiple_config_files/warn/src/main.rs b/tests/ui-cargo/multiple_config_files/warn/src/main.rs
new file mode 100644
index 00000000000..e7a11a969c0
--- /dev/null
+++ b/tests/ui-cargo/multiple_config_files/warn/src/main.rs
@@ -0,0 +1,3 @@
+fn main() {
+    println!("Hello, world!");
+}
diff --git a/tests/ui-cargo/multiple_config_files/warn/src/main.stderr b/tests/ui-cargo/multiple_config_files/warn/src/main.stderr
new file mode 100644
index 00000000000..2abb4e3e06e
--- /dev/null
+++ b/tests/ui-cargo/multiple_config_files/warn/src/main.stderr
@@ -0,0 +1,2 @@
+Using config file `$SRC_DIR/tests/ui-cargo/multiple_config_files/warn/.clippy.toml`
+Warning: `$SRC_DIR/tests/ui-cargo/multiple_config_files/warn/clippy.toml` will be ignored.
-- 
cgit 1.4.1-3-g733a5


From 0e1cbc5cd1d2e2a52b934dda1701d46fdb4e09b8 Mon Sep 17 00:00:00 2001
From: tamaron <tamaron1203@gmail.com>
Date: Tue, 1 Feb 2022 13:43:39 +0900
Subject: fix code

---
 clippy_lints/src/loops/utils.rs | 17 ++++++++++-------
 1 file changed, 10 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/utils.rs b/clippy_lints/src/loops/utils.rs
index eac0f03b142..9082ab94374 100644
--- a/clippy_lints/src/loops/utils.rs
+++ b/clippy_lints/src/loops/utils.rs
@@ -7,7 +7,7 @@ use rustc_hir::intravisit::{walk_expr, walk_local, walk_pat, walk_stmt, Visitor}
 use rustc_hir::{BinOpKind, BorrowKind, Expr, ExprKind, HirId, HirIdMap, Local, Mutability, Pat, PatKind, Stmt};
 use rustc_lint::LateContext;
 use rustc_middle::hir::nested_filter;
-use rustc_middle::ty::Ty;
+use rustc_middle::ty::{self, Ty};
 use rustc_span::source_map::Spanned;
 use rustc_span::symbol::{sym, Symbol};
 use rustc_typeck::hir_ty_to_ty;
@@ -332,17 +332,20 @@ pub(super) fn make_iterator_snippet(cx: &LateContext<'_>, arg: &Expr<'_>, applic
     } else {
         // (&x).into_iter() ==> x.iter()
         // (&mut x).into_iter() ==> x.iter_mut()
-        match &arg.kind {
-            ExprKind::AddrOf(BorrowKind::Ref, mutability, arg_inner)
-                if has_iter_method(cx, cx.typeck_results().expr_ty(arg_inner)).is_some() =>
-            {
-                let meth_name = match mutability {
+        let arg_ty = cx.typeck_results().expr_ty_adjusted(arg);
+        match &arg_ty.kind() {
+            ty::Ref(_, inner_ty, mutbl) if has_iter_method(cx, inner_ty).is_some() => {
+                let meth_name = match mutbl {
                     Mutability::Mut => "iter_mut",
                     Mutability::Not => "iter",
                 };
+                let caller = match &arg.kind {
+                    ExprKind::AddrOf(BorrowKind::Ref, _, arg_inner) => arg_inner,
+                    _ => arg,
+                };
                 format!(
                     "{}.{}()",
-                    sugg::Sugg::hir_with_applicability(cx, arg_inner, "_", applic_ref).maybe_par(),
+                    sugg::Sugg::hir_with_applicability(cx, caller, "_", applic_ref).maybe_par(),
                     meth_name,
                 )
             },
-- 
cgit 1.4.1-3-g733a5


From cb29e3effbf72db2e1f5177336bfb3309ec8805e Mon Sep 17 00:00:00 2001
From: cameron <cameron.studdstreet@gmail.com>
Date: Tue, 1 Feb 2022 11:21:42 +0000
Subject: add doc_link_with_quotes lint

---
 CHANGELOG.md                              |  1 +
 clippy_lints/src/doc_link_with_quotes.rs  | 60 +++++++++++++++++++++++++++++++
 clippy_lints/src/lib.register_lints.rs    |  1 +
 clippy_lints/src/lib.register_pedantic.rs |  1 +
 clippy_lints/src/lib.rs                   |  2 ++
 tests/ui/doc_link_with_quotes.rs          | 12 +++++++
 tests/ui/doc_link_with_quotes.stderr      | 10 ++++++
 7 files changed, 87 insertions(+)
 create mode 100644 clippy_lints/src/doc_link_with_quotes.rs
 create mode 100644 tests/ui/doc_link_with_quotes.rs
 create mode 100644 tests/ui/doc_link_with_quotes.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9548366daf9..42b002407b6 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2941,6 +2941,7 @@ Released 2018-09-13
 [`disallowed_script_idents`]: https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_script_idents
 [`disallowed_types`]: https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_types
 [`diverging_sub_expression`]: https://rust-lang.github.io/rust-clippy/master/index.html#diverging_sub_expression
+[`doc_link_with_quotes`]: https://rust-lang.github.io/rust-clippy/master/index.html#doc_link_with_quotes
 [`doc_markdown`]: https://rust-lang.github.io/rust-clippy/master/index.html#doc_markdown
 [`double_comparisons`]: https://rust-lang.github.io/rust-clippy/master/index.html#double_comparisons
 [`double_must_use`]: https://rust-lang.github.io/rust-clippy/master/index.html#double_must_use
diff --git a/clippy_lints/src/doc_link_with_quotes.rs b/clippy_lints/src/doc_link_with_quotes.rs
new file mode 100644
index 00000000000..cb07f57e870
--- /dev/null
+++ b/clippy_lints/src/doc_link_with_quotes.rs
@@ -0,0 +1,60 @@
+use clippy_utils::diagnostics::span_lint;
+use itertools::Itertools;
+use rustc_ast::{AttrKind, Attribute};
+use rustc_lint::{EarlyContext, EarlyLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Detects the syntax `['foo']` in documentation comments (notice quotes instead of backticks)
+    /// outside of code blocks
+    /// ### Why is this bad?
+    /// It is likely a typo when defining an intra-doc link
+    ///
+    /// ### Example
+    /// ```rust
+    /// /// See also: ['foo']
+    /// fn bar() {}
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// /// See also: [`foo`]
+    /// fn bar() {}
+    /// ```
+    #[clippy::version = "1.60.0"]
+    pub DOC_LINK_WITH_QUOTES,
+    pedantic,
+    "possible typo for an intra-doc link"
+}
+declare_lint_pass!(DocLinkWithQuotes => [DOC_LINK_WITH_QUOTES]);
+
+impl EarlyLintPass for DocLinkWithQuotes {
+    fn check_attribute(&mut self, ctx: &EarlyContext<'_>, attr: &Attribute) {
+        if let AttrKind::DocComment(_, symbol) = attr.kind {
+            if contains_quote_link(symbol.as_str()) {
+                span_lint(
+                    ctx,
+                    DOC_LINK_WITH_QUOTES,
+                    attr.span,
+                    "possible intra-doc link using quotes instead of backticks",
+                );
+            }
+        }
+    }
+}
+
+fn contains_quote_link(s: &str) -> bool {
+    let mut in_backticks = false;
+    let mut found_opening = false;
+
+    for c in s.chars().tuple_windows::<(char, char)>() {
+        match c {
+            ('`', _) => in_backticks = !in_backticks,
+            ('[', '\'') if !in_backticks => found_opening = true,
+            ('\'', ']') if !in_backticks && found_opening => return true,
+            _ => {},
+        }
+    }
+
+    false
+}
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index e5e1c052c15..42c530428f3 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -109,6 +109,7 @@ store.register_lints(&[
     doc::MISSING_PANICS_DOC,
     doc::MISSING_SAFETY_DOC,
     doc::NEEDLESS_DOCTEST_MAIN,
+    doc_link_with_quotes::DOC_LINK_WITH_QUOTES,
     double_comparison::DOUBLE_COMPARISONS,
     double_parens::DOUBLE_PARENS,
     drop_forget_ref::DROP_COPY,
diff --git a/clippy_lints/src/lib.register_pedantic.rs b/clippy_lints/src/lib.register_pedantic.rs
index 1292675f4a9..de72420706b 100644
--- a/clippy_lints/src/lib.register_pedantic.rs
+++ b/clippy_lints/src/lib.register_pedantic.rs
@@ -28,6 +28,7 @@ store.register_group(true, "clippy::pedantic", Some("clippy_pedantic"), vec![
     LintId::of(doc::DOC_MARKDOWN),
     LintId::of(doc::MISSING_ERRORS_DOC),
     LintId::of(doc::MISSING_PANICS_DOC),
+    LintId::of(doc_link_with_quotes::DOC_LINK_WITH_QUOTES),
     LintId::of(empty_enum::EMPTY_ENUM),
     LintId::of(enum_variants::MODULE_NAME_REPETITIONS),
     LintId::of(eta_reduction::REDUNDANT_CLOSURE_FOR_METHOD_CALLS),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 9d42185dc0e..644c2418289 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -197,6 +197,7 @@ mod disallowed_methods;
 mod disallowed_script_idents;
 mod disallowed_types;
 mod doc;
+mod doc_link_with_quotes;
 mod double_comparison;
 mod double_parens;
 mod drop_forget_ref;
@@ -861,6 +862,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(move || Box::new(borrow_as_ptr::BorrowAsPtr::new(msrv)));
     store.register_late_pass(move || Box::new(manual_bits::ManualBits::new(msrv)));
     store.register_late_pass(|| Box::new(default_union_representation::DefaultUnionRepresentation));
+    store.register_early_pass(|| Box::new(doc_link_with_quotes::DocLinkWithQuotes));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/tests/ui/doc_link_with_quotes.rs b/tests/ui/doc_link_with_quotes.rs
new file mode 100644
index 00000000000..ab52fb1a4a6
--- /dev/null
+++ b/tests/ui/doc_link_with_quotes.rs
@@ -0,0 +1,12 @@
+#![warn(clippy::doc_link_with_quotes)]
+
+fn main() {
+    foo()
+}
+
+/// Calls ['bar']
+pub fn foo() {
+    bar()
+}
+
+pub fn bar() {}
diff --git a/tests/ui/doc_link_with_quotes.stderr b/tests/ui/doc_link_with_quotes.stderr
new file mode 100644
index 00000000000..bf6d57d8afe
--- /dev/null
+++ b/tests/ui/doc_link_with_quotes.stderr
@@ -0,0 +1,10 @@
+error: possible intra-doc link using quotes instead of backticks
+  --> $DIR/doc_link_with_quotes.rs:7:1
+   |
+LL | /// Calls ['bar']
+   | ^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::doc-link-with-quotes` implied by `-D warnings`
+
+error: aborting due to previous error
+
-- 
cgit 1.4.1-3-g733a5


From 8ef87455b07e527dd636423751591910dac2e166 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Tue, 1 Feb 2022 10:53:25 -0500
Subject: Minor cleanup on transmute lints

---
 clippy_lints/src/transmute/mod.rs                  | 31 +++++++++++-----------
 .../src/transmute/transmute_float_to_int.rs        |  4 +--
 .../src/transmute/transmute_int_to_bool.rs         |  4 +--
 .../src/transmute/transmute_int_to_char.rs         |  4 +--
 .../src/transmute/transmute_int_to_float.rs        |  4 +--
 .../src/transmute/transmute_num_to_bytes.rs        |  4 +--
 clippy_lints/src/transmute/transmute_ptr_to_ptr.rs |  4 +--
 clippy_lints/src/transmute/transmute_ptr_to_ref.rs |  4 +--
 clippy_lints/src/transmute/transmute_ref_to_ref.rs |  6 ++---
 .../transmutes_expressible_as_ptr_casts.rs         |  4 +--
 clippy_lints/src/transmute/useless_transmute.rs    |  6 ++---
 11 files changed, 37 insertions(+), 38 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/transmute/mod.rs b/clippy_lints/src/transmute/mod.rs
index 3ad4ec74bf5..c370941dd9c 100644
--- a/clippy_lints/src/transmute/mod.rs
+++ b/clippy_lints/src/transmute/mod.rs
@@ -372,10 +372,9 @@ declare_lint_pass!(Transmute => [
 ]);
 
 impl<'tcx> LateLintPass<'tcx> for Transmute {
-    #[allow(clippy::similar_names, clippy::too_many_lines)]
     fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
         if_chain! {
-            if let ExprKind::Call(path_expr, args) = e.kind;
+            if let ExprKind::Call(path_expr, [arg]) = e.kind;
             if let ExprKind::Path(ref qpath) = path_expr.kind;
             if let Some(def_id) = cx.qpath_res(qpath, path_expr.hir_id).opt_def_id();
             if cx.tcx.is_diagnostic_item(sym::transmute, def_id);
@@ -385,28 +384,28 @@ impl<'tcx> LateLintPass<'tcx> for Transmute {
                 // And see https://github.com/rust-lang/rust/issues/51911 for dereferencing raw pointers.
                 let const_context = in_constant(cx, e.hir_id);
 
-                let from_ty = cx.typeck_results().expr_ty(&args[0]);
+                let from_ty = cx.typeck_results().expr_ty(arg);
                 let to_ty = cx.typeck_results().expr_ty(e);
 
                 // If useless_transmute is triggered, the other lints can be skipped.
-                if useless_transmute::check(cx, e, from_ty, to_ty, args) {
+                if useless_transmute::check(cx, e, from_ty, to_ty, arg) {
                     return;
                 }
 
-                let mut linted = wrong_transmute::check(cx, e, from_ty, to_ty);
-                linted |= crosspointer_transmute::check(cx, e, from_ty, to_ty);
-                linted |= transmute_ptr_to_ref::check(cx, e, from_ty, to_ty, args, qpath);
-                linted |= transmute_int_to_char::check(cx, e, from_ty, to_ty, args);
-                linted |= transmute_ref_to_ref::check(cx, e, from_ty, to_ty, args, const_context);
-                linted |= transmute_ptr_to_ptr::check(cx, e, from_ty, to_ty, args);
-                linted |= transmute_int_to_bool::check(cx, e, from_ty, to_ty, args);
-                linted |= transmute_int_to_float::check(cx, e, from_ty, to_ty, args, const_context);
-                linted |= transmute_float_to_int::check(cx, e, from_ty, to_ty, args, const_context);
-                linted |= transmute_num_to_bytes::check(cx, e, from_ty, to_ty, args, const_context);
-                linted |= unsound_collection_transmute::check(cx, e, from_ty, to_ty);
+                let linted = wrong_transmute::check(cx, e, from_ty, to_ty)
+                    | crosspointer_transmute::check(cx, e, from_ty, to_ty)
+                    | transmute_ptr_to_ref::check(cx, e, from_ty, to_ty, arg, qpath)
+                    | transmute_int_to_char::check(cx, e, from_ty, to_ty, arg)
+                    | transmute_ref_to_ref::check(cx, e, from_ty, to_ty, arg, const_context)
+                    | transmute_ptr_to_ptr::check(cx, e, from_ty, to_ty, arg)
+                    | transmute_int_to_bool::check(cx, e, from_ty, to_ty, arg)
+                    | transmute_int_to_float::check(cx, e, from_ty, to_ty, arg, const_context)
+                    | transmute_float_to_int::check(cx, e, from_ty, to_ty, arg, const_context)
+                    | transmute_num_to_bytes::check(cx, e, from_ty, to_ty, arg, const_context)
+                    | unsound_collection_transmute::check(cx, e, from_ty, to_ty);
 
                 if !linted {
-                    transmutes_expressible_as_ptr_casts::check(cx, e, from_ty, to_ty, args);
+                    transmutes_expressible_as_ptr_casts::check(cx, e, from_ty, to_ty, arg);
                 }
             }
         }
diff --git a/clippy_lints/src/transmute/transmute_float_to_int.rs b/clippy_lints/src/transmute/transmute_float_to_int.rs
index 3aa3c393ba5..f4656283b1c 100644
--- a/clippy_lints/src/transmute/transmute_float_to_int.rs
+++ b/clippy_lints/src/transmute/transmute_float_to_int.rs
@@ -15,7 +15,7 @@ pub(super) fn check<'tcx>(
     e: &'tcx Expr<'_>,
     from_ty: Ty<'tcx>,
     to_ty: Ty<'tcx>,
-    args: &'tcx [Expr<'_>],
+    arg: &'tcx Expr<'_>,
     const_context: bool,
 ) -> bool {
     match (&from_ty.kind(), &to_ty.kind()) {
@@ -26,7 +26,7 @@ pub(super) fn check<'tcx>(
                 e.span,
                 &format!("transmute from a `{}` to a `{}`", from_ty, to_ty),
                 |diag| {
-                    let mut expr = &args[0];
+                    let mut expr = arg;
                     let mut arg = sugg::Sugg::hir(cx, expr, "..");
 
                     if let ExprKind::Unary(UnOp::Neg, inner_expr) = &expr.kind {
diff --git a/clippy_lints/src/transmute/transmute_int_to_bool.rs b/clippy_lints/src/transmute/transmute_int_to_bool.rs
index cc0a5643e2a..8c50b58ca4b 100644
--- a/clippy_lints/src/transmute/transmute_int_to_bool.rs
+++ b/clippy_lints/src/transmute/transmute_int_to_bool.rs
@@ -15,7 +15,7 @@ pub(super) fn check<'tcx>(
     e: &'tcx Expr<'_>,
     from_ty: Ty<'tcx>,
     to_ty: Ty<'tcx>,
-    args: &'tcx [Expr<'_>],
+    arg: &'tcx Expr<'_>,
 ) -> bool {
     match (&from_ty.kind(), &to_ty.kind()) {
         (ty::Int(ty::IntTy::I8) | ty::Uint(ty::UintTy::U8), ty::Bool) => {
@@ -25,7 +25,7 @@ pub(super) fn check<'tcx>(
                 e.span,
                 &format!("transmute from a `{}` to a `bool`", from_ty),
                 |diag| {
-                    let arg = sugg::Sugg::hir(cx, &args[0], "..");
+                    let arg = sugg::Sugg::hir(cx, arg, "..");
                     let zero = sugg::Sugg::NonParen(Cow::from("0"));
                     diag.span_suggestion(
                         e.span,
diff --git a/clippy_lints/src/transmute/transmute_int_to_char.rs b/clippy_lints/src/transmute/transmute_int_to_char.rs
index e83d2e06b9a..3eb07b68992 100644
--- a/clippy_lints/src/transmute/transmute_int_to_char.rs
+++ b/clippy_lints/src/transmute/transmute_int_to_char.rs
@@ -14,7 +14,7 @@ pub(super) fn check<'tcx>(
     e: &'tcx Expr<'_>,
     from_ty: Ty<'tcx>,
     to_ty: Ty<'tcx>,
-    args: &'tcx [Expr<'_>],
+    arg: &'tcx Expr<'_>,
 ) -> bool {
     match (&from_ty.kind(), &to_ty.kind()) {
         (ty::Int(ty::IntTy::I32) | ty::Uint(ty::UintTy::U32), &ty::Char) => {
@@ -24,7 +24,7 @@ pub(super) fn check<'tcx>(
                 e.span,
                 &format!("transmute from a `{}` to a `char`", from_ty),
                 |diag| {
-                    let arg = sugg::Sugg::hir(cx, &args[0], "..");
+                    let arg = sugg::Sugg::hir(cx, arg, "..");
                     let arg = if let ty::Int(_) = from_ty.kind() {
                         arg.as_ty(ast::UintTy::U32.name_str())
                     } else {
diff --git a/clippy_lints/src/transmute/transmute_int_to_float.rs b/clippy_lints/src/transmute/transmute_int_to_float.rs
index 05eee380d6f..b8703052e6c 100644
--- a/clippy_lints/src/transmute/transmute_int_to_float.rs
+++ b/clippy_lints/src/transmute/transmute_int_to_float.rs
@@ -13,7 +13,7 @@ pub(super) fn check<'tcx>(
     e: &'tcx Expr<'_>,
     from_ty: Ty<'tcx>,
     to_ty: Ty<'tcx>,
-    args: &'tcx [Expr<'_>],
+    arg: &'tcx Expr<'_>,
     const_context: bool,
 ) -> bool {
     match (&from_ty.kind(), &to_ty.kind()) {
@@ -24,7 +24,7 @@ pub(super) fn check<'tcx>(
                 e.span,
                 &format!("transmute from a `{}` to a `{}`", from_ty, to_ty),
                 |diag| {
-                    let arg = sugg::Sugg::hir(cx, &args[0], "..");
+                    let arg = sugg::Sugg::hir(cx, arg, "..");
                     let arg = if let ty::Int(int_ty) = from_ty.kind() {
                         arg.as_ty(format!(
                             "u{}",
diff --git a/clippy_lints/src/transmute/transmute_num_to_bytes.rs b/clippy_lints/src/transmute/transmute_num_to_bytes.rs
index 5ba58a76494..52d193d11e1 100644
--- a/clippy_lints/src/transmute/transmute_num_to_bytes.rs
+++ b/clippy_lints/src/transmute/transmute_num_to_bytes.rs
@@ -13,7 +13,7 @@ pub(super) fn check<'tcx>(
     e: &'tcx Expr<'_>,
     from_ty: Ty<'tcx>,
     to_ty: Ty<'tcx>,
-    args: &'tcx [Expr<'_>],
+    arg: &'tcx Expr<'_>,
     const_context: bool,
 ) -> bool {
     match (&from_ty.kind(), &to_ty.kind()) {
@@ -33,7 +33,7 @@ pub(super) fn check<'tcx>(
                 e.span,
                 &format!("transmute from a `{}` to a `{}`", from_ty, to_ty),
                 |diag| {
-                    let arg = sugg::Sugg::hir(cx, &args[0], "..");
+                    let arg = sugg::Sugg::hir(cx, arg, "..");
                     diag.span_suggestion(
                         e.span,
                         "consider using `to_ne_bytes()`",
diff --git a/clippy_lints/src/transmute/transmute_ptr_to_ptr.rs b/clippy_lints/src/transmute/transmute_ptr_to_ptr.rs
index 7b646bfc0c6..d712b33de9e 100644
--- a/clippy_lints/src/transmute/transmute_ptr_to_ptr.rs
+++ b/clippy_lints/src/transmute/transmute_ptr_to_ptr.rs
@@ -13,7 +13,7 @@ pub(super) fn check<'tcx>(
     e: &'tcx Expr<'_>,
     from_ty: Ty<'tcx>,
     to_ty: Ty<'tcx>,
-    args: &'tcx [Expr<'_>],
+    arg: &'tcx Expr<'_>,
 ) -> bool {
     match (&from_ty.kind(), &to_ty.kind()) {
         (ty::RawPtr(_), ty::RawPtr(to_ty)) => {
@@ -23,7 +23,7 @@ pub(super) fn check<'tcx>(
                 e.span,
                 "transmute from a pointer to a pointer",
                 |diag| {
-                    if let Some(arg) = sugg::Sugg::hir_opt(cx, &args[0]) {
+                    if let Some(arg) = sugg::Sugg::hir_opt(cx, arg) {
                         let sugg = arg.as_ty(cx.tcx.mk_ptr(*to_ty));
                         diag.span_suggestion(e.span, "try", sugg.to_string(), Applicability::Unspecified);
                     }
diff --git a/clippy_lints/src/transmute/transmute_ptr_to_ref.rs b/clippy_lints/src/transmute/transmute_ptr_to_ref.rs
index f14eef93645..5699f8e92cf 100644
--- a/clippy_lints/src/transmute/transmute_ptr_to_ref.rs
+++ b/clippy_lints/src/transmute/transmute_ptr_to_ref.rs
@@ -14,7 +14,7 @@ pub(super) fn check<'tcx>(
     e: &'tcx Expr<'_>,
     from_ty: Ty<'tcx>,
     to_ty: Ty<'tcx>,
-    args: &'tcx [Expr<'_>],
+    arg: &'tcx Expr<'_>,
     qpath: &'tcx QPath<'_>,
 ) -> bool {
     match (&from_ty.kind(), &to_ty.kind()) {
@@ -28,7 +28,7 @@ pub(super) fn check<'tcx>(
                     from_ty, to_ty
                 ),
                 |diag| {
-                    let arg = sugg::Sugg::hir(cx, &args[0], "..");
+                    let arg = sugg::Sugg::hir(cx, arg, "..");
                     let (deref, cast) = if *mutbl == Mutability::Mut {
                         ("&mut *", "*mut")
                     } else {
diff --git a/clippy_lints/src/transmute/transmute_ref_to_ref.rs b/clippy_lints/src/transmute/transmute_ref_to_ref.rs
index d105e37abf9..fdef8bac7f9 100644
--- a/clippy_lints/src/transmute/transmute_ref_to_ref.rs
+++ b/clippy_lints/src/transmute/transmute_ref_to_ref.rs
@@ -15,7 +15,7 @@ pub(super) fn check<'tcx>(
     e: &'tcx Expr<'_>,
     from_ty: Ty<'tcx>,
     to_ty: Ty<'tcx>,
-    args: &'tcx [Expr<'_>],
+    arg: &'tcx Expr<'_>,
     const_context: bool,
 ) -> bool {
     let mut triggered = false;
@@ -41,7 +41,7 @@ pub(super) fn check<'tcx>(
                     format!(
                         "std::str::from_utf8{}({}).unwrap()",
                         postfix,
-                        snippet(cx, args[0].span, ".."),
+                        snippet(cx, arg.span, ".."),
                     ),
                     Applicability::Unspecified,
                 );
@@ -54,7 +54,7 @@ pub(super) fn check<'tcx>(
                         TRANSMUTE_PTR_TO_PTR,
                         e.span,
                         "transmute from a reference to a reference",
-                        |diag| if let Some(arg) = sugg::Sugg::hir_opt(cx, &args[0]) {
+                        |diag| if let Some(arg) = sugg::Sugg::hir_opt(cx, arg) {
                             let ty_from_and_mut = ty::TypeAndMut {
                                 ty: ty_from,
                                 mutbl: *from_mutbl
diff --git a/clippy_lints/src/transmute/transmutes_expressible_as_ptr_casts.rs b/clippy_lints/src/transmute/transmutes_expressible_as_ptr_casts.rs
index e2c6d130f3c..626d7cd46fc 100644
--- a/clippy_lints/src/transmute/transmutes_expressible_as_ptr_casts.rs
+++ b/clippy_lints/src/transmute/transmutes_expressible_as_ptr_casts.rs
@@ -14,7 +14,7 @@ pub(super) fn check<'tcx>(
     e: &'tcx Expr<'_>,
     from_ty: Ty<'tcx>,
     to_ty: Ty<'tcx>,
-    args: &'tcx [Expr<'_>],
+    arg: &'tcx Expr<'_>,
 ) -> bool {
     if can_be_expressed_as_pointer_cast(cx, e, from_ty, to_ty) {
         span_lint_and_then(
@@ -26,7 +26,7 @@ pub(super) fn check<'tcx>(
                 from_ty, to_ty
             ),
             |diag| {
-                if let Some(arg) = sugg::Sugg::hir_opt(cx, &args[0]) {
+                if let Some(arg) = sugg::Sugg::hir_opt(cx, arg) {
                     let sugg = arg.as_ty(&to_ty.to_string()).to_string();
                     diag.span_suggestion(e.span, "try", sugg, Applicability::MachineApplicable);
                 }
diff --git a/clippy_lints/src/transmute/useless_transmute.rs b/clippy_lints/src/transmute/useless_transmute.rs
index 445bcf60fa7..998f97eb5d8 100644
--- a/clippy_lints/src/transmute/useless_transmute.rs
+++ b/clippy_lints/src/transmute/useless_transmute.rs
@@ -13,7 +13,7 @@ pub(super) fn check<'tcx>(
     e: &'tcx Expr<'_>,
     from_ty: Ty<'tcx>,
     to_ty: Ty<'tcx>,
-    args: &'tcx [Expr<'_>],
+    arg: &'tcx Expr<'_>,
 ) -> bool {
     match (&from_ty.kind(), &to_ty.kind()) {
         _ if from_ty == to_ty => {
@@ -32,7 +32,7 @@ pub(super) fn check<'tcx>(
                 e.span,
                 "transmute from a reference to a pointer",
                 |diag| {
-                    if let Some(arg) = sugg::Sugg::hir_opt(cx, &args[0]) {
+                    if let Some(arg) = sugg::Sugg::hir_opt(cx, arg) {
                         let rty_and_mut = ty::TypeAndMut {
                             ty: rty,
                             mutbl: *rty_mutbl,
@@ -57,7 +57,7 @@ pub(super) fn check<'tcx>(
                 e.span,
                 "transmute from an integer to a pointer",
                 |diag| {
-                    if let Some(arg) = sugg::Sugg::hir_opt(cx, &args[0]) {
+                    if let Some(arg) = sugg::Sugg::hir_opt(cx, arg) {
                         diag.span_suggestion(
                             e.span,
                             "try",
-- 
cgit 1.4.1-3-g733a5


From e4f45c22e24c0a739f32ef152dfd4287257e20cb Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Tue, 1 Feb 2022 15:05:20 -0500
Subject: Fix ICE in `ptr_arg`

---
 clippy_lints/src/ptr.rs      | 2 +-
 tests/ui/crashes/ice-8386.rs | 3 +++
 2 files changed, 4 insertions(+), 1 deletion(-)
 create mode 100644 tests/ui/crashes/ice-8386.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs
index 77bf5f002f7..5c13f660c6b 100644
--- a/clippy_lints/src/ptr.rs
+++ b/clippy_lints/src/ptr.rs
@@ -649,7 +649,7 @@ fn check_ptr_arg_usage<'tcx>(cx: &LateContext<'tcx>, body: &'tcx Body<'_>, args:
                     },
                     _ => {
                         skip_count += 1;
-                        results[arg.idx].skip = true;
+                        results[i].skip = true;
                         None
                     },
                 }
diff --git a/tests/ui/crashes/ice-8386.rs b/tests/ui/crashes/ice-8386.rs
new file mode 100644
index 00000000000..3e38b1408d8
--- /dev/null
+++ b/tests/ui/crashes/ice-8386.rs
@@ -0,0 +1,3 @@
+fn f(x: u32, mut arg: &String) {}
+
+fn main() {}
-- 
cgit 1.4.1-3-g733a5


From f5fd9ded000d7968b6641d2b17f4eca53a4a8f67 Mon Sep 17 00:00:00 2001
From: tamaron <tamaron1203@gmail.com>
Date: Wed, 2 Feb 2022 11:25:15 +0900
Subject: chore

---
 clippy_lints/src/loops/utils.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/utils.rs b/clippy_lints/src/loops/utils.rs
index 9082ab94374..b6c746d3e39 100644
--- a/clippy_lints/src/loops/utils.rs
+++ b/clippy_lints/src/loops/utils.rs
@@ -335,7 +335,7 @@ pub(super) fn make_iterator_snippet(cx: &LateContext<'_>, arg: &Expr<'_>, applic
         let arg_ty = cx.typeck_results().expr_ty_adjusted(arg);
         match &arg_ty.kind() {
             ty::Ref(_, inner_ty, mutbl) if has_iter_method(cx, inner_ty).is_some() => {
-                let meth_name = match mutbl {
+                let method_name = match mutbl {
                     Mutability::Mut => "iter_mut",
                     Mutability::Not => "iter",
                 };
@@ -346,7 +346,7 @@ pub(super) fn make_iterator_snippet(cx: &LateContext<'_>, arg: &Expr<'_>, applic
                 format!(
                     "{}.{}()",
                     sugg::Sugg::hir_with_applicability(cx, caller, "_", applic_ref).maybe_par(),
-                    meth_name,
+                    method_name,
                 )
             },
             _ => format!(
-- 
cgit 1.4.1-3-g733a5


From 144b4a59c7a3d18a0dd2c4316061672d00516ea3 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Fri, 28 Jan 2022 14:58:14 +0000
Subject: Add `explicit_write` suggestions for `write!`s with format args

---
 clippy_lints/src/explicit_write.rs         | 41 +++++++++++++----------------
 tests/ui/explicit_write.fixed              | 12 +++++++++
 tests/ui/explicit_write.rs                 | 12 +++++++++
 tests/ui/explicit_write.stderr             | 42 +++++++++++++++++++++++-------
 tests/ui/explicit_write_non_rustfix.rs     |  8 ------
 tests/ui/explicit_write_non_rustfix.stderr | 11 --------
 6 files changed, 75 insertions(+), 51 deletions(-)
 delete mode 100644 tests/ui/explicit_write_non_rustfix.rs
 delete mode 100644 tests/ui/explicit_write_non_rustfix.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/explicit_write.rs b/clippy_lints/src/explicit_write.rs
index f326fd83d18..3e2217c28da 100644
--- a/clippy_lints/src/explicit_write.rs
+++ b/clippy_lints/src/explicit_write.rs
@@ -1,5 +1,6 @@
-use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg};
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::macros::FormatArgsExpn;
+use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::{is_expn_of, match_function_call, paths};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
@@ -79,28 +80,22 @@ impl<'tcx> LateLintPass<'tcx> for ExplicitWrite {
                         "print".into(),
                     )
                 };
-                let msg = format!("use of `{}.unwrap()`", used);
-                if let [write_output] = *format_args.format_string_parts {
-                    let mut write_output = write_output.to_string();
-                    if write_output.ends_with('\n') {
-                        write_output.pop();
-                    }
-
-                    let sugg = format!("{}{}!(\"{}\")", prefix, sugg_mac, write_output.escape_default());
-                    span_lint_and_sugg(
-                        cx,
-                        EXPLICIT_WRITE,
-                        expr.span,
-                        &msg,
-                        "try this",
-                        sugg,
-                        Applicability::MachineApplicable
-                    );
-                } else {
-                    // We don't have a proper suggestion
-                    let help = format!("consider using `{}{}!` instead", prefix, sugg_mac);
-                    span_lint_and_help(cx, EXPLICIT_WRITE, expr.span, &msg, None, &help);
-                }
+                let mut applicability = Applicability::MachineApplicable;
+                let inputs_snippet = snippet_with_applicability(
+                    cx,
+                    format_args.inputs_span(),
+                    "..",
+                    &mut applicability,
+                );
+                span_lint_and_sugg(
+                    cx,
+                    EXPLICIT_WRITE,
+                    expr.span,
+                    &format!("use of `{}.unwrap()`", used),
+                    "try this",
+                    format!("{}{}!({})", prefix, sugg_mac, inputs_snippet),
+                    applicability,
+                )
             }
         }
     }
diff --git a/tests/ui/explicit_write.fixed b/tests/ui/explicit_write.fixed
index 692d2ca675f..74d0e529028 100644
--- a/tests/ui/explicit_write.fixed
+++ b/tests/ui/explicit_write.fixed
@@ -10,6 +10,12 @@ fn stderr() -> String {
     String::new()
 }
 
+macro_rules! one {
+    () => {
+        1
+    };
+}
+
 fn main() {
     // these should warn
     {
@@ -24,6 +30,12 @@ fn main() {
         // including newlines
         println!("test\ntest");
         eprintln!("test\ntest");
+
+        let value = 1;
+        eprintln!("with {}", value);
+        eprintln!("with {} {}", 2, value);
+        eprintln!("with {value}");
+        eprintln!("macro arg {}", one!());
     }
     // these should not warn, different destination
     {
diff --git a/tests/ui/explicit_write.rs b/tests/ui/explicit_write.rs
index 455c5ef55d0..e7a698d3e01 100644
--- a/tests/ui/explicit_write.rs
+++ b/tests/ui/explicit_write.rs
@@ -10,6 +10,12 @@ fn stderr() -> String {
     String::new()
 }
 
+macro_rules! one {
+    () => {
+        1
+    };
+}
+
 fn main() {
     // these should warn
     {
@@ -24,6 +30,12 @@ fn main() {
         // including newlines
         writeln!(std::io::stdout(), "test\ntest").unwrap();
         writeln!(std::io::stderr(), "test\ntest").unwrap();
+
+        let value = 1;
+        writeln!(std::io::stderr(), "with {}", value).unwrap();
+        writeln!(std::io::stderr(), "with {} {}", 2, value).unwrap();
+        writeln!(std::io::stderr(), "with {value}").unwrap();
+        writeln!(std::io::stderr(), "macro arg {}", one!()).unwrap();
     }
     // these should not warn, different destination
     {
diff --git a/tests/ui/explicit_write.stderr b/tests/ui/explicit_write.stderr
index 9feef9c0dc8..29ae0cdece2 100644
--- a/tests/ui/explicit_write.stderr
+++ b/tests/ui/explicit_write.stderr
@@ -1,5 +1,5 @@
 error: use of `write!(stdout(), ...).unwrap()`
-  --> $DIR/explicit_write.rs:17:9
+  --> $DIR/explicit_write.rs:23:9
    |
 LL |         write!(std::io::stdout(), "test").unwrap();
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `print!("test")`
@@ -7,46 +7,70 @@ LL |         write!(std::io::stdout(), "test").unwrap();
    = note: `-D clippy::explicit-write` implied by `-D warnings`
 
 error: use of `write!(stderr(), ...).unwrap()`
-  --> $DIR/explicit_write.rs:18:9
+  --> $DIR/explicit_write.rs:24:9
    |
 LL |         write!(std::io::stderr(), "test").unwrap();
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `eprint!("test")`
 
 error: use of `writeln!(stdout(), ...).unwrap()`
-  --> $DIR/explicit_write.rs:19:9
+  --> $DIR/explicit_write.rs:25:9
    |
 LL |         writeln!(std::io::stdout(), "test").unwrap();
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `println!("test")`
 
 error: use of `writeln!(stderr(), ...).unwrap()`
-  --> $DIR/explicit_write.rs:20:9
+  --> $DIR/explicit_write.rs:26:9
    |
 LL |         writeln!(std::io::stderr(), "test").unwrap();
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `eprintln!("test")`
 
 error: use of `stdout().write_fmt(...).unwrap()`
-  --> $DIR/explicit_write.rs:21:9
+  --> $DIR/explicit_write.rs:27:9
    |
 LL |         std::io::stdout().write_fmt(format_args!("test")).unwrap();
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `print!("test")`
 
 error: use of `stderr().write_fmt(...).unwrap()`
-  --> $DIR/explicit_write.rs:22:9
+  --> $DIR/explicit_write.rs:28:9
    |
 LL |         std::io::stderr().write_fmt(format_args!("test")).unwrap();
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `eprint!("test")`
 
 error: use of `writeln!(stdout(), ...).unwrap()`
-  --> $DIR/explicit_write.rs:25:9
+  --> $DIR/explicit_write.rs:31:9
    |
 LL |         writeln!(std::io::stdout(), "test/ntest").unwrap();
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `println!("test/ntest")`
 
 error: use of `writeln!(stderr(), ...).unwrap()`
-  --> $DIR/explicit_write.rs:26:9
+  --> $DIR/explicit_write.rs:32:9
    |
 LL |         writeln!(std::io::stderr(), "test/ntest").unwrap();
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `eprintln!("test/ntest")`
 
-error: aborting due to 8 previous errors
+error: use of `writeln!(stderr(), ...).unwrap()`
+  --> $DIR/explicit_write.rs:35:9
+   |
+LL |         writeln!(std::io::stderr(), "with {}", value).unwrap();
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `eprintln!("with {}", value)`
+
+error: use of `writeln!(stderr(), ...).unwrap()`
+  --> $DIR/explicit_write.rs:36:9
+   |
+LL |         writeln!(std::io::stderr(), "with {} {}", 2, value).unwrap();
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `eprintln!("with {} {}", 2, value)`
+
+error: use of `writeln!(stderr(), ...).unwrap()`
+  --> $DIR/explicit_write.rs:37:9
+   |
+LL |         writeln!(std::io::stderr(), "with {value}").unwrap();
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `eprintln!("with {value}")`
+
+error: use of `writeln!(stderr(), ...).unwrap()`
+  --> $DIR/explicit_write.rs:38:9
+   |
+LL |         writeln!(std::io::stderr(), "macro arg {}", one!()).unwrap();
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `eprintln!("macro arg {}", one!())`
+
+error: aborting due to 12 previous errors
 
diff --git a/tests/ui/explicit_write_non_rustfix.rs b/tests/ui/explicit_write_non_rustfix.rs
deleted file mode 100644
index f21e8ef935b..00000000000
--- a/tests/ui/explicit_write_non_rustfix.rs
+++ /dev/null
@@ -1,8 +0,0 @@
-#![allow(unused_imports, clippy::blacklisted_name)]
-#![warn(clippy::explicit_write)]
-
-fn main() {
-    use std::io::Write;
-    let bar = "bar";
-    writeln!(std::io::stderr(), "foo {}", bar).unwrap();
-}
diff --git a/tests/ui/explicit_write_non_rustfix.stderr b/tests/ui/explicit_write_non_rustfix.stderr
deleted file mode 100644
index b94ec6403dd..00000000000
--- a/tests/ui/explicit_write_non_rustfix.stderr
+++ /dev/null
@@ -1,11 +0,0 @@
-error: use of `writeln!(stderr(), ...).unwrap()`
-  --> $DIR/explicit_write_non_rustfix.rs:7:5
-   |
-LL |     writeln!(std::io::stderr(), "foo {}", bar).unwrap();
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: `-D clippy::explicit-write` implied by `-D warnings`
-   = help: consider using `eprintln!` instead
-
-error: aborting due to previous error
-
-- 
cgit 1.4.1-3-g733a5


From 3403b3e7175936f694403767b93803df3e606fc0 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Tue, 1 Feb 2022 14:53:12 -0500
Subject: Add lint `transumte_undefined_repr`

---
 CHANGELOG.md                                       |   1 +
 clippy_lints/src/lib.register_all.rs               |   1 +
 clippy_lints/src/lib.register_correctness.rs       |   1 +
 clippy_lints/src/lib.register_lints.rs             |   1 +
 clippy_lints/src/lib.rs                            |   1 +
 clippy_lints/src/transmute/mod.rs                  |  31 ++-
 .../src/transmute/transmute_undefined_repr.rs      | 291 +++++++++++++++++++++
 tests/ui/crashes/ice-4968.rs                       |   1 +
 tests/ui/transmute_undefined_repr.rs               |  44 ++++
 tests/ui/transmute_undefined_repr.stderr           |  44 ++++
 10 files changed, 415 insertions(+), 1 deletion(-)
 create mode 100644 clippy_lints/src/transmute/transmute_undefined_repr.rs
 create mode 100644 tests/ui/transmute_undefined_repr.rs
 create mode 100644 tests/ui/transmute_undefined_repr.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9548366daf9..7fb31f6d2b2 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3304,6 +3304,7 @@ Released 2018-09-13
 [`transmute_num_to_bytes`]: https://rust-lang.github.io/rust-clippy/master/index.html#transmute_num_to_bytes
 [`transmute_ptr_to_ptr`]: https://rust-lang.github.io/rust-clippy/master/index.html#transmute_ptr_to_ptr
 [`transmute_ptr_to_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#transmute_ptr_to_ref
+[`transmute_undefined_repr`]: https://rust-lang.github.io/rust-clippy/master/index.html#transmute_undefined_repr
 [`transmutes_expressible_as_ptr_casts`]: https://rust-lang.github.io/rust-clippy/master/index.html#transmutes_expressible_as_ptr_casts
 [`transmuting_null`]: https://rust-lang.github.io/rust-clippy/master/index.html#transmuting_null
 [`trivial_regex`]: https://rust-lang.github.io/rust-clippy/master/index.html#trivial_regex
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 4721b7f2b47..d93e34e76b4 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -277,6 +277,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(transmute::TRANSMUTE_INT_TO_FLOAT),
     LintId::of(transmute::TRANSMUTE_NUM_TO_BYTES),
     LintId::of(transmute::TRANSMUTE_PTR_TO_REF),
+    LintId::of(transmute::TRANSMUTE_UNDEFINED_REPR),
     LintId::of(transmute::UNSOUND_COLLECTION_TRANSMUTE),
     LintId::of(transmute::WRONG_TRANSMUTE),
     LintId::of(transmuting_null::TRANSMUTING_NULL),
diff --git a/clippy_lints/src/lib.register_correctness.rs b/clippy_lints/src/lib.register_correctness.rs
index 4217fd3a3ea..d013daa8e08 100644
--- a/clippy_lints/src/lib.register_correctness.rs
+++ b/clippy_lints/src/lib.register_correctness.rs
@@ -58,6 +58,7 @@ store.register_group(true, "clippy::correctness", Some("clippy_correctness"), ve
     LintId::of(size_of_in_element_count::SIZE_OF_IN_ELEMENT_COUNT),
     LintId::of(swap::ALMOST_SWAPPED),
     LintId::of(to_string_in_display::TO_STRING_IN_DISPLAY),
+    LintId::of(transmute::TRANSMUTE_UNDEFINED_REPR),
     LintId::of(transmute::UNSOUND_COLLECTION_TRANSMUTE),
     LintId::of(transmute::WRONG_TRANSMUTE),
     LintId::of(transmuting_null::TRANSMUTING_NULL),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index e5e1c052c15..a80320a578f 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -473,6 +473,7 @@ store.register_lints(&[
     transmute::TRANSMUTE_NUM_TO_BYTES,
     transmute::TRANSMUTE_PTR_TO_PTR,
     transmute::TRANSMUTE_PTR_TO_REF,
+    transmute::TRANSMUTE_UNDEFINED_REPR,
     transmute::UNSOUND_COLLECTION_TRANSMUTE,
     transmute::USELESS_TRANSMUTE,
     transmute::WRONG_TRANSMUTE,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 9d42185dc0e..0b07726519e 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -5,6 +5,7 @@
 #![feature(control_flow_enum)]
 #![feature(drain_filter)]
 #![feature(iter_intersperse)]
+#![feature(let_chains)]
 #![feature(let_else)]
 #![feature(once_cell)]
 #![feature(rustc_private)]
diff --git a/clippy_lints/src/transmute/mod.rs b/clippy_lints/src/transmute/mod.rs
index c370941dd9c..4c320deecc2 100644
--- a/clippy_lints/src/transmute/mod.rs
+++ b/clippy_lints/src/transmute/mod.rs
@@ -7,6 +7,7 @@ mod transmute_num_to_bytes;
 mod transmute_ptr_to_ptr;
 mod transmute_ptr_to_ref;
 mod transmute_ref_to_ref;
+mod transmute_undefined_repr;
 mod transmutes_expressible_as_ptr_casts;
 mod unsound_collection_transmute;
 mod useless_transmute;
@@ -355,6 +356,30 @@ declare_clippy_lint! {
     "transmute between collections of layout-incompatible types"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for transmutes either to or from a type which does not have a defined representation.
+    ///
+    /// ### Why is this bad?
+    /// The results of such a transmute are not defined.
+    ///
+    /// ### Example
+    /// ```rust
+    /// struct Foo<T>(u32, T);
+    /// let _ = unsafe { core::mem::transmute::<Foo<u32>, Foo<i32>>(Foo(0u32, 0u32)) };
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// #[repr(C)]
+    /// struct Foo<T>(u32, T);
+    /// let _ = unsafe { core::mem::transmute::<Foo<u32>, Foo<i32>>(Foo(0u32, 0u32)) };
+    /// ```
+    #[clippy::version = "1.60.0"]
+    pub TRANSMUTE_UNDEFINED_REPR,
+    correctness,
+    "transmute to or from a type with an undefined representation"
+}
+
 declare_lint_pass!(Transmute => [
     CROSSPOINTER_TRANSMUTE,
     TRANSMUTE_PTR_TO_REF,
@@ -369,6 +394,7 @@ declare_lint_pass!(Transmute => [
     TRANSMUTE_NUM_TO_BYTES,
     UNSOUND_COLLECTION_TRANSMUTE,
     TRANSMUTES_EXPRESSIBLE_AS_PTR_CASTS,
+    TRANSMUTE_UNDEFINED_REPR,
 ]);
 
 impl<'tcx> LateLintPass<'tcx> for Transmute {
@@ -402,7 +428,10 @@ impl<'tcx> LateLintPass<'tcx> for Transmute {
                     | transmute_int_to_float::check(cx, e, from_ty, to_ty, arg, const_context)
                     | transmute_float_to_int::check(cx, e, from_ty, to_ty, arg, const_context)
                     | transmute_num_to_bytes::check(cx, e, from_ty, to_ty, arg, const_context)
-                    | unsound_collection_transmute::check(cx, e, from_ty, to_ty);
+                    | (
+                        unsound_collection_transmute::check(cx, e, from_ty, to_ty)
+                        || transmute_undefined_repr::check(cx, e, from_ty, to_ty)
+                    );
 
                 if !linted {
                     transmutes_expressible_as_ptr_casts::check(cx, e, from_ty, to_ty, arg);
diff --git a/clippy_lints/src/transmute/transmute_undefined_repr.rs b/clippy_lints/src/transmute/transmute_undefined_repr.rs
new file mode 100644
index 00000000000..4b7c493278f
--- /dev/null
+++ b/clippy_lints/src/transmute/transmute_undefined_repr.rs
@@ -0,0 +1,291 @@
+use super::TRANSMUTE_UNDEFINED_REPR;
+use clippy_utils::diagnostics::span_lint_and_then;
+use rustc_hir::Expr;
+use rustc_lint::LateContext;
+use rustc_middle::ty::subst::{GenericArg, Subst};
+use rustc_middle::ty::{self, Ty, TyS, TypeAndMut};
+use rustc_span::Span;
+
+#[allow(clippy::too_many_lines)]
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    e: &'tcx Expr<'_>,
+    from_ty_orig: Ty<'tcx>,
+    to_ty_orig: Ty<'tcx>,
+) -> bool {
+    let mut from_ty = cx.tcx.erase_regions(from_ty_orig);
+    let mut to_ty = cx.tcx.erase_regions(to_ty_orig);
+
+    while !TyS::same_type(from_ty, to_ty) {
+        match reduce_refs(cx, e.span, from_ty, to_ty) {
+            ReducedTys::FromFatPtr { unsized_ty, .. } => {
+                span_lint_and_then(
+                    cx,
+                    TRANSMUTE_UNDEFINED_REPR,
+                    e.span,
+                    &format!("transmute from `{}` which has an undefined layout", from_ty_orig),
+                    |diag| {
+                        if !TyS::same_type(from_ty_orig.peel_refs(), unsized_ty) {
+                            diag.note(&format!("the contained type `&{}` has an undefined layout", unsized_ty));
+                        }
+                    },
+                );
+                return true;
+            },
+            ReducedTys::ToFatPtr { unsized_ty, .. } => {
+                span_lint_and_then(
+                    cx,
+                    TRANSMUTE_UNDEFINED_REPR,
+                    e.span,
+                    &format!("transmute to `{}` which has an undefined layout", to_ty_orig),
+                    |diag| {
+                        if !TyS::same_type(to_ty_orig.peel_refs(), unsized_ty) {
+                            diag.note(&format!("the contained type `&{}` has an undefined layout", unsized_ty));
+                        }
+                    },
+                );
+                return true;
+            },
+            ReducedTys::ToPtr {
+                from_ty: from_sub_ty,
+                to_ty: to_sub_ty,
+            } => match reduce_ty(cx, from_sub_ty) {
+                ReducedTy::UnorderedFields(from_ty) => {
+                    span_lint_and_then(
+                        cx,
+                        TRANSMUTE_UNDEFINED_REPR,
+                        e.span,
+                        &format!("transmute from `{}` which has an undefined layout", from_ty_orig),
+                        |diag| {
+                            if !TyS::same_type(from_ty_orig.peel_refs(), from_ty) {
+                                diag.note(&format!("the contained type `{}` has an undefined layout", from_ty));
+                            }
+                        },
+                    );
+                    return true;
+                },
+                ReducedTy::Ref(from_sub_ty) => {
+                    from_ty = from_sub_ty;
+                    to_ty = to_sub_ty;
+                    continue;
+                },
+                _ => break,
+            },
+            ReducedTys::FromPtr {
+                from_ty: from_sub_ty,
+                to_ty: to_sub_ty,
+            } => match reduce_ty(cx, to_sub_ty) {
+                ReducedTy::UnorderedFields(to_ty) => {
+                    span_lint_and_then(
+                        cx,
+                        TRANSMUTE_UNDEFINED_REPR,
+                        e.span,
+                        &format!("transmute to `{}` which has an undefined layout", to_ty_orig),
+                        |diag| {
+                            if !TyS::same_type(to_ty_orig.peel_refs(), to_ty) {
+                                diag.note(&format!("the contained type `{}` has an undefined layout", to_ty));
+                            }
+                        },
+                    );
+                    return true;
+                },
+                ReducedTy::Ref(to_sub_ty) => {
+                    from_ty = from_sub_ty;
+                    to_ty = to_sub_ty;
+                    continue;
+                },
+                _ => break,
+            },
+            ReducedTys::Other {
+                from_ty: from_sub_ty,
+                to_ty: to_sub_ty,
+            } => match (reduce_ty(cx, from_sub_ty), reduce_ty(cx, to_sub_ty)) {
+                (ReducedTy::IntArray, _) | (_, ReducedTy::IntArray) => return false,
+                (ReducedTy::UnorderedFields(from_ty), ReducedTy::UnorderedFields(to_ty))
+                    if !TyS::same_type(from_ty, to_ty) =>
+                {
+                    span_lint_and_then(
+                        cx,
+                        TRANSMUTE_UNDEFINED_REPR,
+                        e.span,
+                        &format!(
+                            "transmute from `{}` to `{}`, both of which have an undefined layout",
+                            from_ty_orig, to_ty_orig
+                        ),
+                        |diag| {
+                            if let (Some(from_def), Some(to_def)) = (from_ty.ty_adt_def(), to_ty.ty_adt_def())
+                                && from_def == to_def
+                            {
+                                diag.note(&format!(
+                                    "two instances of the same generic type (`{}`) may have different layouts",
+                                    cx.tcx.item_name(from_def.did)
+                                ));
+                            } else {
+                                if !TyS::same_type(from_ty_orig.peel_refs(), from_ty) {
+                                    diag.note(&format!("the contained type `{}` has an undefined layout", from_ty));
+                                }
+                                if !TyS::same_type(to_ty_orig.peel_refs(), to_ty) {
+                                    diag.note(&format!("the contained type `{}` has an undefined layout", to_ty));
+                                }
+                            }
+                        },
+                    );
+                    return true;
+                },
+                (
+                    ReducedTy::UnorderedFields(from_ty),
+                    ReducedTy::Other(_) | ReducedTy::OrderedFields(_) | ReducedTy::Ref(_),
+                ) => {
+                    span_lint_and_then(
+                        cx,
+                        TRANSMUTE_UNDEFINED_REPR,
+                        e.span,
+                        &format!("transmute from `{}` which has an undefined layout", from_ty_orig),
+                        |diag| {
+                            if !TyS::same_type(from_ty_orig.peel_refs(), from_ty) {
+                                diag.note(&format!("the contained type `{}` has an undefined layout", from_ty));
+                            }
+                        },
+                    );
+                    return true;
+                },
+                (
+                    ReducedTy::Other(_) | ReducedTy::OrderedFields(_) | ReducedTy::Ref(_),
+                    ReducedTy::UnorderedFields(to_ty),
+                ) => {
+                    span_lint_and_then(
+                        cx,
+                        TRANSMUTE_UNDEFINED_REPR,
+                        e.span,
+                        &format!("transmute into `{}` which has an undefined layout", to_ty_orig),
+                        |diag| {
+                            if !TyS::same_type(to_ty_orig.peel_refs(), to_ty) {
+                                diag.note(&format!("the contained type `{}` has an undefined layout", to_ty));
+                            }
+                        },
+                    );
+                    return true;
+                },
+                (ReducedTy::Ref(from_sub_ty), ReducedTy::Ref(to_sub_ty)) => {
+                    from_ty = from_sub_ty;
+                    to_ty = to_sub_ty;
+                    continue;
+                },
+                (
+                    ReducedTy::OrderedFields(_) | ReducedTy::Ref(_) | ReducedTy::Other(_),
+                    ReducedTy::OrderedFields(_) | ReducedTy::Ref(_) | ReducedTy::Other(_),
+                )
+                | (ReducedTy::UnorderedFields(_), ReducedTy::UnorderedFields(_)) => break,
+            },
+        }
+    }
+
+    false
+}
+
+enum ReducedTys<'tcx> {
+    FromFatPtr { unsized_ty: Ty<'tcx> },
+    ToFatPtr { unsized_ty: Ty<'tcx> },
+    ToPtr { from_ty: Ty<'tcx>, to_ty: Ty<'tcx> },
+    FromPtr { from_ty: Ty<'tcx>, to_ty: Ty<'tcx> },
+    Other { from_ty: Ty<'tcx>, to_ty: Ty<'tcx> },
+}
+
+fn reduce_refs<'tcx>(
+    cx: &LateContext<'tcx>,
+    span: Span,
+    mut from_ty: Ty<'tcx>,
+    mut to_ty: Ty<'tcx>,
+) -> ReducedTys<'tcx> {
+    loop {
+        return match (from_ty.kind(), to_ty.kind()) {
+            (
+                ty::Ref(_, from_sub_ty, _) | ty::RawPtr(TypeAndMut { ty: from_sub_ty, .. }),
+                ty::Ref(_, to_sub_ty, _) | ty::RawPtr(TypeAndMut { ty: to_sub_ty, .. }),
+            ) => {
+                from_ty = from_sub_ty;
+                to_ty = to_sub_ty;
+                continue;
+            },
+            (ty::Ref(_, unsized_ty, _) | ty::RawPtr(TypeAndMut { ty: unsized_ty, .. }), _)
+                if !unsized_ty.is_sized(cx.tcx.at(span), cx.param_env) =>
+            {
+                ReducedTys::FromFatPtr { unsized_ty }
+            },
+            (_, ty::Ref(_, unsized_ty, _) | ty::RawPtr(TypeAndMut { ty: unsized_ty, .. }))
+                if !unsized_ty.is_sized(cx.tcx.at(span), cx.param_env) =>
+            {
+                ReducedTys::ToFatPtr { unsized_ty }
+            },
+            (ty::Ref(_, from_ty, _) | ty::RawPtr(TypeAndMut { ty: from_ty, .. }), _) => {
+                ReducedTys::FromPtr { from_ty, to_ty }
+            },
+            (_, ty::Ref(_, to_ty, _) | ty::RawPtr(TypeAndMut { ty: to_ty, .. })) => {
+                ReducedTys::ToPtr { from_ty, to_ty }
+            },
+            _ => ReducedTys::Other { from_ty, to_ty },
+        };
+    }
+}
+
+enum ReducedTy<'tcx> {
+    OrderedFields(Ty<'tcx>),
+    UnorderedFields(Ty<'tcx>),
+    Ref(Ty<'tcx>),
+    Other(Ty<'tcx>),
+    IntArray,
+}
+
+fn reduce_ty<'tcx>(cx: &LateContext<'tcx>, mut ty: Ty<'tcx>) -> ReducedTy<'tcx> {
+    loop {
+        ty = cx.tcx.try_normalize_erasing_regions(cx.param_env, ty).unwrap_or(ty);
+        return match *ty.kind() {
+            ty::Array(sub_ty, _) if matches!(sub_ty.kind(), ty::Int(_) | ty::Uint(_)) => ReducedTy::IntArray,
+            ty::Array(sub_ty, _) | ty::Slice(sub_ty) => {
+                ty = sub_ty;
+                continue;
+            },
+            ty::Tuple(args) => {
+                let mut iter = args.iter().map(GenericArg::expect_ty);
+                let Some(sized_ty) = iter.find(|ty| !is_zero_sized_ty(cx, ty)) else {
+                    return ReducedTy::OrderedFields(ty);
+                };
+                if iter.all(|ty| is_zero_sized_ty(cx, ty)) {
+                    ty = sized_ty;
+                    continue;
+                }
+                ReducedTy::UnorderedFields(ty)
+            },
+            ty::Adt(def, substs) if def.is_struct() => {
+                if def.repr.inhibit_struct_field_reordering_opt() {
+                    return ReducedTy::OrderedFields(ty);
+                }
+                let mut iter = def
+                    .non_enum_variant()
+                    .fields
+                    .iter()
+                    .map(|f| cx.tcx.type_of(f.did).subst(cx.tcx, substs));
+                let Some(sized_ty) = iter.find(|ty| !is_zero_sized_ty(cx, ty)) else {
+                    return ReducedTy::OrderedFields(ty);
+                };
+                if iter.all(|ty| is_zero_sized_ty(cx, ty)) {
+                    ty = sized_ty;
+                    continue;
+                }
+                ReducedTy::UnorderedFields(ty)
+            },
+            ty::Ref(..) | ty::RawPtr(_) => ReducedTy::Ref(ty),
+            _ => ReducedTy::Other(ty),
+        };
+    }
+}
+
+fn is_zero_sized_ty<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
+    if let Ok(ty) = cx.tcx.try_normalize_erasing_regions(cx.param_env, ty)
+        && let Ok(layout) = cx.tcx.layout_of(cx.param_env.and(ty))
+    {
+        layout.layout.size.bytes() == 0
+    } else {
+        false
+    }
+}
diff --git a/tests/ui/crashes/ice-4968.rs b/tests/ui/crashes/ice-4968.rs
index 3822f174598..e0510d942c2 100644
--- a/tests/ui/crashes/ice-4968.rs
+++ b/tests/ui/crashes/ice-4968.rs
@@ -3,6 +3,7 @@
 // Test for https://github.com/rust-lang/rust-clippy/issues/4968
 
 #![warn(clippy::unsound_collection_transmute)]
+#![allow(clippy::transmute_undefined_repr)]
 
 trait Trait {
     type Assoc;
diff --git a/tests/ui/transmute_undefined_repr.rs b/tests/ui/transmute_undefined_repr.rs
new file mode 100644
index 00000000000..71539940fbf
--- /dev/null
+++ b/tests/ui/transmute_undefined_repr.rs
@@ -0,0 +1,44 @@
+#![warn(clippy::transmute_undefined_repr)]
+#![allow(clippy::unit_arg)]
+
+fn value<T>() -> T {
+    unimplemented!()
+}
+
+struct Empty;
+struct Ty<T>(T);
+struct Ty2<T, U>(T, U);
+
+#[repr(C)]
+struct Ty2C<T, U>(T, U);
+
+fn main() {
+    unsafe {
+        let _: () = core::mem::transmute(value::<Empty>());
+        let _: Empty = core::mem::transmute(value::<()>());
+
+        let _: Ty<u32> = core::mem::transmute(value::<u32>());
+        let _: Ty<u32> = core::mem::transmute(value::<u32>());
+
+        let _: Ty2C<u32, i32> = core::mem::transmute(value::<Ty2<u32, i32>>()); // Lint, Ty2 is unordered
+        let _: Ty2<u32, i32> = core::mem::transmute(value::<Ty2C<u32, i32>>()); // Lint, Ty2 is unordered
+
+        let _: Ty2<u32, i32> = core::mem::transmute(value::<Ty<Ty2<u32, i32>>>()); // Ok, Ty2 types are the same
+        let _: Ty<Ty2<u32, i32>> = core::mem::transmute(value::<Ty2<u32, i32>>()); // Ok, Ty2 types are the same
+
+        let _: Ty2<u32, f32> = core::mem::transmute(value::<Ty<Ty2<u32, i32>>>()); // Lint, different Ty2 instances
+        let _: Ty<Ty2<u32, i32>> = core::mem::transmute(value::<Ty2<u32, f32>>()); // Lint, different Ty2 instances
+
+        let _: Ty<&()> = core::mem::transmute(value::<&()>());
+        let _: &() = core::mem::transmute(value::<Ty<&()>>());
+
+        let _: &Ty2<u32, f32> = core::mem::transmute(value::<Ty<&Ty2<u32, i32>>>()); // Lint, different Ty2 instances
+        let _: Ty<&Ty2<u32, i32>> = core::mem::transmute(value::<&Ty2<u32, f32>>()); // Lint, different Ty2 instances
+
+        let _: Ty<usize> = core::mem::transmute(value::<&Ty2<u32, i32>>()); // Ok, pointer to usize conversion
+        let _: &Ty2<u32, i32> = core::mem::transmute(value::<Ty<usize>>()); // Ok, pointer to usize conversion
+
+        let _: Ty<[u8; 8]> = core::mem::transmute(value::<Ty2<u32, i32>>()); // Ok, transmute to byte array
+        let _: Ty2<u32, i32> = core::mem::transmute(value::<Ty<[u8; 8]>>()); // Ok, transmute from byte array
+    }
+}
diff --git a/tests/ui/transmute_undefined_repr.stderr b/tests/ui/transmute_undefined_repr.stderr
new file mode 100644
index 00000000000..040c63c7afa
--- /dev/null
+++ b/tests/ui/transmute_undefined_repr.stderr
@@ -0,0 +1,44 @@
+error: transmute from `Ty2<u32, i32>` which has an undefined layout
+  --> $DIR/transmute_undefined_repr.rs:23:33
+   |
+LL |         let _: Ty2C<u32, i32> = core::mem::transmute(value::<Ty2<u32, i32>>()); // Lint, Ty2 is unordered
+   |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::transmute-undefined-repr` implied by `-D warnings`
+
+error: transmute into `Ty2<u32, i32>` which has an undefined layout
+  --> $DIR/transmute_undefined_repr.rs:24:32
+   |
+LL |         let _: Ty2<u32, i32> = core::mem::transmute(value::<Ty2C<u32, i32>>()); // Lint, Ty2 is unordered
+   |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: transmute from `Ty<Ty2<u32, i32>>` to `Ty2<u32, f32>`, both of which have an undefined layout
+  --> $DIR/transmute_undefined_repr.rs:29:32
+   |
+LL |         let _: Ty2<u32, f32> = core::mem::transmute(value::<Ty<Ty2<u32, i32>>>()); // Lint, different Ty2 instances
+   |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: two instances of the same generic type (`Ty2`) may have different layouts
+
+error: transmute from `Ty2<u32, f32>` to `Ty<Ty2<u32, i32>>`, both of which have an undefined layout
+  --> $DIR/transmute_undefined_repr.rs:30:36
+   |
+LL |         let _: Ty<Ty2<u32, i32>> = core::mem::transmute(value::<Ty2<u32, f32>>()); // Lint, different Ty2 instances
+   |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: two instances of the same generic type (`Ty2`) may have different layouts
+
+error: transmute to `&Ty2<u32, f32>` which has an undefined layout
+  --> $DIR/transmute_undefined_repr.rs:35:33
+   |
+LL |         let _: &Ty2<u32, f32> = core::mem::transmute(value::<Ty<&Ty2<u32, i32>>>()); // Lint, different Ty2 instances
+   |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: transmute from `&Ty2<u32, f32>` which has an undefined layout
+  --> $DIR/transmute_undefined_repr.rs:36:37
+   |
+LL |         let _: Ty<&Ty2<u32, i32>> = core::mem::transmute(value::<&Ty2<u32, f32>>()); // Lint, different Ty2 instances
+   |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 6 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 68993b1f6cf94701ff420e51aa927c568ae7eef2 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sun, 6 Feb 2022 09:42:10 -0500
Subject: Small `transmute_float_to_int` cleanup

---
 .../src/transmute/transmute_float_to_int.rs        | 29 +++++++++++-----------
 1 file changed, 14 insertions(+), 15 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/transmute/transmute_float_to_int.rs b/clippy_lints/src/transmute/transmute_float_to_int.rs
index f4656283b1c..d5ef86dc4e5 100644
--- a/clippy_lints/src/transmute/transmute_float_to_int.rs
+++ b/clippy_lints/src/transmute/transmute_float_to_int.rs
@@ -15,7 +15,7 @@ pub(super) fn check<'tcx>(
     e: &'tcx Expr<'_>,
     from_ty: Ty<'tcx>,
     to_ty: Ty<'tcx>,
-    arg: &'tcx Expr<'_>,
+    mut arg: &'tcx Expr<'_>,
     const_context: bool,
 ) -> bool {
     match (&from_ty.kind(), &to_ty.kind()) {
@@ -26,37 +26,36 @@ pub(super) fn check<'tcx>(
                 e.span,
                 &format!("transmute from a `{}` to a `{}`", from_ty, to_ty),
                 |diag| {
-                    let mut expr = arg;
-                    let mut arg = sugg::Sugg::hir(cx, expr, "..");
+                    let mut sugg = sugg::Sugg::hir(cx, arg, "..");
 
-                    if let ExprKind::Unary(UnOp::Neg, inner_expr) = &expr.kind {
-                        expr = inner_expr;
+                    if let ExprKind::Unary(UnOp::Neg, inner_expr) = &arg.kind {
+                        arg = inner_expr;
                     }
 
                     if_chain! {
                         // if the expression is a float literal and it is unsuffixed then
                         // add a suffix so the suggestion is valid and unambiguous
-                        if let ExprKind::Lit(lit) = &expr.kind;
+                        if let ExprKind::Lit(lit) = &arg.kind;
                         if let ast::LitKind::Float(_, ast::LitFloatType::Unsuffixed) = lit.node;
                         then {
-                            let op = format!("{}{}", arg, float_ty.name_str()).into();
-                            match arg {
-                                sugg::Sugg::MaybeParen(_) => arg = sugg::Sugg::MaybeParen(op),
-                                _ => arg = sugg::Sugg::NonParen(op)
+                            let op = format!("{}{}", sugg, float_ty.name_str()).into();
+                            match sugg {
+                                sugg::Sugg::MaybeParen(_) => sugg = sugg::Sugg::MaybeParen(op),
+                                _ => sugg = sugg::Sugg::NonParen(op)
                             }
                         }
                     }
 
-                    arg = sugg::Sugg::NonParen(format!("{}.to_bits()", arg.maybe_par()).into());
+                    sugg = sugg::Sugg::NonParen(format!("{}.to_bits()", sugg.maybe_par()).into());
 
                     // cast the result of `to_bits` if `to_ty` is signed
-                    arg = if let ty::Int(int_ty) = to_ty.kind() {
-                        arg.as_ty(int_ty.name_str().to_string())
+                    sugg = if let ty::Int(int_ty) = to_ty.kind() {
+                        sugg.as_ty(int_ty.name_str().to_string())
                     } else {
-                        arg
+                        sugg
                     };
 
-                    diag.span_suggestion(e.span, "consider using", arg.to_string(), Applicability::Unspecified);
+                    diag.span_suggestion(e.span, "consider using", sugg.to_string(), Applicability::Unspecified);
                 },
             );
             true
-- 
cgit 1.4.1-3-g733a5


From f7be9564e5e7803365d6225883c1711dae694de5 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sun, 6 Feb 2022 13:35:57 -0500
Subject: Move `matches.rs` to `mod.rs`

---
 clippy_lints/src/matches.rs     | 2445 ---------------------------------------
 clippy_lints/src/matches/mod.rs | 2445 +++++++++++++++++++++++++++++++++++++++
 2 files changed, 2445 insertions(+), 2445 deletions(-)
 delete mode 100644 clippy_lints/src/matches.rs
 create mode 100644 clippy_lints/src/matches/mod.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs
deleted file mode 100644
index 67fb918d20c..00000000000
--- a/clippy_lints/src/matches.rs
+++ /dev/null
@@ -1,2445 +0,0 @@
-use clippy_utils::consts::{constant, constant_full_int, miri_to_const, FullInt};
-use clippy_utils::diagnostics::{
-    multispan_sugg, span_lint_and_help, span_lint_and_note, span_lint_and_sugg, span_lint_and_then,
-};
-use clippy_utils::macros::{is_panic, root_macro_call};
-use clippy_utils::source::{expr_block, indent_of, snippet, snippet_block, snippet_opt, snippet_with_applicability};
-use clippy_utils::sugg::Sugg;
-use clippy_utils::ty::{implements_trait, is_type_diagnostic_item, match_type, peel_mid_ty_refs};
-use clippy_utils::visitors::is_local_used;
-use clippy_utils::{
-    get_parent_expr, is_lang_ctor, is_lint_allowed, is_refutable, is_unit_expr, is_wild, meets_msrv, msrvs,
-    path_to_local, path_to_local_id, peel_blocks, peel_hir_pat_refs, peel_n_hir_expr_refs, recurse_or_patterns,
-    strip_pat_refs,
-};
-use clippy_utils::{higher, peel_blocks_with_stmt};
-use clippy_utils::{paths, search_same, SpanlessEq, SpanlessHash};
-use core::iter::{once, ExactSizeIterator};
-use if_chain::if_chain;
-use rustc_ast::ast::{Attribute, LitKind};
-use rustc_errors::Applicability;
-use rustc_hir::def::{CtorKind, DefKind, Res};
-use rustc_hir::LangItem::{OptionNone, OptionSome};
-use rustc_hir::{
-    self as hir, Arm, BindingAnnotation, Block, BorrowKind, Expr, ExprKind, Guard, HirId, Local, MatchSource,
-    Mutability, Node, Pat, PatKind, PathSegment, QPath, RangeEnd, TyKind,
-};
-use rustc_hir::{HirIdMap, HirIdSet};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty::{self, Ty, TyS, VariantDef};
-use rustc_semver::RustcVersion;
-use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::source_map::{Span, Spanned};
-use rustc_span::{sym, symbol::kw};
-use std::cmp::{max, Ordering};
-use std::collections::hash_map::Entry;
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for matches with a single arm where an `if let`
-    /// will usually suffice.
-    ///
-    /// ### Why is this bad?
-    /// Just readability – `if let` nests less than a `match`.
-    ///
-    /// ### Example
-    /// ```rust
-    /// # fn bar(stool: &str) {}
-    /// # let x = Some("abc");
-    /// // Bad
-    /// match x {
-    ///     Some(ref foo) => bar(foo),
-    ///     _ => (),
-    /// }
-    ///
-    /// // Good
-    /// if let Some(ref foo) = x {
-    ///     bar(foo);
-    /// }
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub SINGLE_MATCH,
-    style,
-    "a `match` statement with a single nontrivial arm (i.e., where the other arm is `_ => {}`) instead of `if let`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for matches with two arms where an `if let else` will
-    /// usually suffice.
-    ///
-    /// ### Why is this bad?
-    /// Just readability – `if let` nests less than a `match`.
-    ///
-    /// ### Known problems
-    /// Personal style preferences may differ.
-    ///
-    /// ### Example
-    /// Using `match`:
-    ///
-    /// ```rust
-    /// # fn bar(foo: &usize) {}
-    /// # let other_ref: usize = 1;
-    /// # let x: Option<&usize> = Some(&1);
-    /// match x {
-    ///     Some(ref foo) => bar(foo),
-    ///     _ => bar(&other_ref),
-    /// }
-    /// ```
-    ///
-    /// Using `if let` with `else`:
-    ///
-    /// ```rust
-    /// # fn bar(foo: &usize) {}
-    /// # let other_ref: usize = 1;
-    /// # let x: Option<&usize> = Some(&1);
-    /// if let Some(ref foo) = x {
-    ///     bar(foo);
-    /// } else {
-    ///     bar(&other_ref);
-    /// }
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub SINGLE_MATCH_ELSE,
-    pedantic,
-    "a `match` statement with two arms where the second arm's pattern is a placeholder instead of a specific match pattern"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for matches where all arms match a reference,
-    /// suggesting to remove the reference and deref the matched expression
-    /// instead. It also checks for `if let &foo = bar` blocks.
-    ///
-    /// ### Why is this bad?
-    /// It just makes the code less readable. That reference
-    /// destructuring adds nothing to the code.
-    ///
-    /// ### Example
-    /// ```rust,ignore
-    /// // Bad
-    /// match x {
-    ///     &A(ref y) => foo(y),
-    ///     &B => bar(),
-    ///     _ => frob(&x),
-    /// }
-    ///
-    /// // Good
-    /// match *x {
-    ///     A(ref y) => foo(y),
-    ///     B => bar(),
-    ///     _ => frob(x),
-    /// }
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub MATCH_REF_PATS,
-    style,
-    "a `match` or `if let` with all arms prefixed with `&` instead of deref-ing the match expression"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for matches where match expression is a `bool`. It
-    /// suggests to replace the expression with an `if...else` block.
-    ///
-    /// ### Why is this bad?
-    /// It makes the code less readable.
-    ///
-    /// ### Example
-    /// ```rust
-    /// # fn foo() {}
-    /// # fn bar() {}
-    /// let condition: bool = true;
-    /// match condition {
-    ///     true => foo(),
-    ///     false => bar(),
-    /// }
-    /// ```
-    /// Use if/else instead:
-    /// ```rust
-    /// # fn foo() {}
-    /// # fn bar() {}
-    /// let condition: bool = true;
-    /// if condition {
-    ///     foo();
-    /// } else {
-    ///     bar();
-    /// }
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub MATCH_BOOL,
-    pedantic,
-    "a `match` on a boolean expression instead of an `if..else` block"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for overlapping match arms.
-    ///
-    /// ### Why is this bad?
-    /// It is likely to be an error and if not, makes the code
-    /// less obvious.
-    ///
-    /// ### Example
-    /// ```rust
-    /// let x = 5;
-    /// match x {
-    ///     1..=10 => println!("1 ... 10"),
-    ///     5..=15 => println!("5 ... 15"),
-    ///     _ => (),
-    /// }
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub MATCH_OVERLAPPING_ARM,
-    style,
-    "a `match` with overlapping arms"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for arm which matches all errors with `Err(_)`
-    /// and take drastic actions like `panic!`.
-    ///
-    /// ### Why is this bad?
-    /// It is generally a bad practice, similar to
-    /// catching all exceptions in java with `catch(Exception)`
-    ///
-    /// ### Example
-    /// ```rust
-    /// let x: Result<i32, &str> = Ok(3);
-    /// match x {
-    ///     Ok(_) => println!("ok"),
-    ///     Err(_) => panic!("err"),
-    /// }
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub MATCH_WILD_ERR_ARM,
-    pedantic,
-    "a `match` with `Err(_)` arm and take drastic actions"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for match which is used to add a reference to an
-    /// `Option` value.
-    ///
-    /// ### Why is this bad?
-    /// Using `as_ref()` or `as_mut()` instead is shorter.
-    ///
-    /// ### Example
-    /// ```rust
-    /// let x: Option<()> = None;
-    ///
-    /// // Bad
-    /// let r: Option<&()> = match x {
-    ///     None => None,
-    ///     Some(ref v) => Some(v),
-    /// };
-    ///
-    /// // Good
-    /// let r: Option<&()> = x.as_ref();
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub MATCH_AS_REF,
-    complexity,
-    "a `match` on an Option value instead of using `as_ref()` or `as_mut`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for wildcard enum matches using `_`.
-    ///
-    /// ### Why is this bad?
-    /// New enum variants added by library updates can be missed.
-    ///
-    /// ### Known problems
-    /// Suggested replacements may be incorrect if guards exhaustively cover some
-    /// variants, and also may not use correct path to enum if it's not present in the current scope.
-    ///
-    /// ### Example
-    /// ```rust
-    /// # enum Foo { A(usize), B(usize) }
-    /// # let x = Foo::B(1);
-    /// // Bad
-    /// match x {
-    ///     Foo::A(_) => {},
-    ///     _ => {},
-    /// }
-    ///
-    /// // Good
-    /// match x {
-    ///     Foo::A(_) => {},
-    ///     Foo::B(_) => {},
-    /// }
-    /// ```
-    #[clippy::version = "1.34.0"]
-    pub WILDCARD_ENUM_MATCH_ARM,
-    restriction,
-    "a wildcard enum match arm using `_`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for wildcard enum matches for a single variant.
-    ///
-    /// ### Why is this bad?
-    /// New enum variants added by library updates can be missed.
-    ///
-    /// ### Known problems
-    /// Suggested replacements may not use correct path to enum
-    /// if it's not present in the current scope.
-    ///
-    /// ### Example
-    /// ```rust
-    /// # enum Foo { A, B, C }
-    /// # let x = Foo::B;
-    /// // Bad
-    /// match x {
-    ///     Foo::A => {},
-    ///     Foo::B => {},
-    ///     _ => {},
-    /// }
-    ///
-    /// // Good
-    /// match x {
-    ///     Foo::A => {},
-    ///     Foo::B => {},
-    ///     Foo::C => {},
-    /// }
-    /// ```
-    #[clippy::version = "1.45.0"]
-    pub MATCH_WILDCARD_FOR_SINGLE_VARIANTS,
-    pedantic,
-    "a wildcard enum match for a single variant"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for wildcard pattern used with others patterns in same match arm.
-    ///
-    /// ### Why is this bad?
-    /// Wildcard pattern already covers any other pattern as it will match anyway.
-    /// It makes the code less readable, especially to spot wildcard pattern use in match arm.
-    ///
-    /// ### Example
-    /// ```rust
-    /// // Bad
-    /// match "foo" {
-    ///     "a" => {},
-    ///     "bar" | _ => {},
-    /// }
-    ///
-    /// // Good
-    /// match "foo" {
-    ///     "a" => {},
-    ///     _ => {},
-    /// }
-    /// ```
-    #[clippy::version = "1.42.0"]
-    pub WILDCARD_IN_OR_PATTERNS,
-    complexity,
-    "a wildcard pattern used with others patterns in same match arm"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for matches being used to destructure a single-variant enum
-    /// or tuple struct where a `let` will suffice.
-    ///
-    /// ### Why is this bad?
-    /// Just readability – `let` doesn't nest, whereas a `match` does.
-    ///
-    /// ### Example
-    /// ```rust
-    /// enum Wrapper {
-    ///     Data(i32),
-    /// }
-    ///
-    /// let wrapper = Wrapper::Data(42);
-    ///
-    /// let data = match wrapper {
-    ///     Wrapper::Data(i) => i,
-    /// };
-    /// ```
-    ///
-    /// The correct use would be:
-    /// ```rust
-    /// enum Wrapper {
-    ///     Data(i32),
-    /// }
-    ///
-    /// let wrapper = Wrapper::Data(42);
-    /// let Wrapper::Data(data) = wrapper;
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub INFALLIBLE_DESTRUCTURING_MATCH,
-    style,
-    "a `match` statement with a single infallible arm instead of a `let`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for useless match that binds to only one value.
-    ///
-    /// ### Why is this bad?
-    /// Readability and needless complexity.
-    ///
-    /// ### Known problems
-    ///  Suggested replacements may be incorrect when `match`
-    /// is actually binding temporary value, bringing a 'dropped while borrowed' error.
-    ///
-    /// ### Example
-    /// ```rust
-    /// # let a = 1;
-    /// # let b = 2;
-    ///
-    /// // Bad
-    /// match (a, b) {
-    ///     (c, d) => {
-    ///         // useless match
-    ///     }
-    /// }
-    ///
-    /// // Good
-    /// let (c, d) = (a, b);
-    /// ```
-    #[clippy::version = "1.43.0"]
-    pub MATCH_SINGLE_BINDING,
-    complexity,
-    "a match with a single binding instead of using `let` statement"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for unnecessary '..' pattern binding on struct when all fields are explicitly matched.
-    ///
-    /// ### Why is this bad?
-    /// Correctness and readability. It's like having a wildcard pattern after
-    /// matching all enum variants explicitly.
-    ///
-    /// ### Example
-    /// ```rust
-    /// # struct A { a: i32 }
-    /// let a = A { a: 5 };
-    ///
-    /// // Bad
-    /// match a {
-    ///     A { a: 5, .. } => {},
-    ///     _ => {},
-    /// }
-    ///
-    /// // Good
-    /// match a {
-    ///     A { a: 5 } => {},
-    ///     _ => {},
-    /// }
-    /// ```
-    #[clippy::version = "1.43.0"]
-    pub REST_PAT_IN_FULLY_BOUND_STRUCTS,
-    restriction,
-    "a match on a struct that binds all fields but still uses the wildcard pattern"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Lint for redundant pattern matching over `Result`, `Option`,
-    /// `std::task::Poll` or `std::net::IpAddr`
-    ///
-    /// ### Why is this bad?
-    /// It's more concise and clear to just use the proper
-    /// utility function
-    ///
-    /// ### Known problems
-    /// This will change the drop order for the matched type. Both `if let` and
-    /// `while let` will drop the value at the end of the block, both `if` and `while` will drop the
-    /// value before entering the block. For most types this change will not matter, but for a few
-    /// types this will not be an acceptable change (e.g. locks). See the
-    /// [reference](https://doc.rust-lang.org/reference/destructors.html#drop-scopes) for more about
-    /// drop order.
-    ///
-    /// ### Example
-    /// ```rust
-    /// # use std::task::Poll;
-    /// # use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
-    /// if let Ok(_) = Ok::<i32, i32>(42) {}
-    /// if let Err(_) = Err::<i32, i32>(42) {}
-    /// if let None = None::<()> {}
-    /// if let Some(_) = Some(42) {}
-    /// if let Poll::Pending = Poll::Pending::<()> {}
-    /// if let Poll::Ready(_) = Poll::Ready(42) {}
-    /// if let IpAddr::V4(_) = IpAddr::V4(Ipv4Addr::LOCALHOST) {}
-    /// if let IpAddr::V6(_) = IpAddr::V6(Ipv6Addr::LOCALHOST) {}
-    /// match Ok::<i32, i32>(42) {
-    ///     Ok(_) => true,
-    ///     Err(_) => false,
-    /// };
-    /// ```
-    ///
-    /// The more idiomatic use would be:
-    ///
-    /// ```rust
-    /// # use std::task::Poll;
-    /// # use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
-    /// if Ok::<i32, i32>(42).is_ok() {}
-    /// if Err::<i32, i32>(42).is_err() {}
-    /// if None::<()>.is_none() {}
-    /// if Some(42).is_some() {}
-    /// if Poll::Pending::<()>.is_pending() {}
-    /// if Poll::Ready(42).is_ready() {}
-    /// if IpAddr::V4(Ipv4Addr::LOCALHOST).is_ipv4() {}
-    /// if IpAddr::V6(Ipv6Addr::LOCALHOST).is_ipv6() {}
-    /// Ok::<i32, i32>(42).is_ok();
-    /// ```
-    #[clippy::version = "1.31.0"]
-    pub REDUNDANT_PATTERN_MATCHING,
-    style,
-    "use the proper utility function avoiding an `if let`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for `match`  or `if let` expressions producing a
-    /// `bool` that could be written using `matches!`
-    ///
-    /// ### Why is this bad?
-    /// Readability and needless complexity.
-    ///
-    /// ### Known problems
-    /// This lint falsely triggers, if there are arms with
-    /// `cfg` attributes that remove an arm evaluating to `false`.
-    ///
-    /// ### Example
-    /// ```rust
-    /// let x = Some(5);
-    ///
-    /// // Bad
-    /// let a = match x {
-    ///     Some(0) => true,
-    ///     _ => false,
-    /// };
-    ///
-    /// let a = if let Some(0) = x {
-    ///     true
-    /// } else {
-    ///     false
-    /// };
-    ///
-    /// // Good
-    /// let a = matches!(x, Some(0));
-    /// ```
-    #[clippy::version = "1.47.0"]
-    pub MATCH_LIKE_MATCHES_MACRO,
-    style,
-    "a match that could be written with the matches! macro"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for `match` with identical arm bodies.
-    ///
-    /// ### Why is this bad?
-    /// This is probably a copy & paste error. If arm bodies
-    /// are the same on purpose, you can factor them
-    /// [using `|`](https://doc.rust-lang.org/book/patterns.html#multiple-patterns).
-    ///
-    /// ### Known problems
-    /// False positive possible with order dependent `match`
-    /// (see issue
-    /// [#860](https://github.com/rust-lang/rust-clippy/issues/860)).
-    ///
-    /// ### Example
-    /// ```rust,ignore
-    /// match foo {
-    ///     Bar => bar(),
-    ///     Quz => quz(),
-    ///     Baz => bar(), // <= oops
-    /// }
-    /// ```
-    ///
-    /// This should probably be
-    /// ```rust,ignore
-    /// match foo {
-    ///     Bar => bar(),
-    ///     Quz => quz(),
-    ///     Baz => baz(), // <= fixed
-    /// }
-    /// ```
-    ///
-    /// or if the original code was not a typo:
-    /// ```rust,ignore
-    /// match foo {
-    ///     Bar | Baz => bar(), // <= shows the intent better
-    ///     Quz => quz(),
-    /// }
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub MATCH_SAME_ARMS,
-    pedantic,
-    "`match` with identical arm bodies"
-}
-
-#[derive(Default)]
-pub struct Matches {
-    msrv: Option<RustcVersion>,
-    infallible_destructuring_match_linted: bool,
-}
-
-impl Matches {
-    #[must_use]
-    pub fn new(msrv: Option<RustcVersion>) -> Self {
-        Self {
-            msrv,
-            ..Matches::default()
-        }
-    }
-}
-
-impl_lint_pass!(Matches => [
-    SINGLE_MATCH,
-    MATCH_REF_PATS,
-    MATCH_BOOL,
-    SINGLE_MATCH_ELSE,
-    MATCH_OVERLAPPING_ARM,
-    MATCH_WILD_ERR_ARM,
-    MATCH_AS_REF,
-    WILDCARD_ENUM_MATCH_ARM,
-    MATCH_WILDCARD_FOR_SINGLE_VARIANTS,
-    WILDCARD_IN_OR_PATTERNS,
-    MATCH_SINGLE_BINDING,
-    INFALLIBLE_DESTRUCTURING_MATCH,
-    REST_PAT_IN_FULLY_BOUND_STRUCTS,
-    REDUNDANT_PATTERN_MATCHING,
-    MATCH_LIKE_MATCHES_MACRO,
-    MATCH_SAME_ARMS,
-]);
-
-impl<'tcx> LateLintPass<'tcx> for Matches {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if expr.span.from_expansion() {
-            return;
-        }
-
-        redundant_pattern_match::check(cx, expr);
-
-        if meets_msrv(self.msrv.as_ref(), &msrvs::MATCHES_MACRO) {
-            if !check_match_like_matches(cx, expr) {
-                lint_match_arms(cx, expr);
-            }
-        } else {
-            lint_match_arms(cx, expr);
-        }
-
-        if let ExprKind::Match(ex, arms, MatchSource::Normal) = expr.kind {
-            check_single_match(cx, ex, arms, expr);
-            check_match_bool(cx, ex, arms, expr);
-            check_overlapping_arms(cx, ex, arms);
-            check_wild_err_arm(cx, ex, arms);
-            check_wild_enum_match(cx, ex, arms);
-            check_match_as_ref(cx, ex, arms, expr);
-            check_wild_in_or_pats(cx, arms);
-
-            if self.infallible_destructuring_match_linted {
-                self.infallible_destructuring_match_linted = false;
-            } else {
-                check_match_single_binding(cx, ex, arms, expr);
-            }
-        }
-        if let ExprKind::Match(ex, arms, _) = expr.kind {
-            check_match_ref_pats(cx, ex, arms.iter().map(|el| el.pat), expr);
-        }
-    }
-
-    fn check_local(&mut self, cx: &LateContext<'tcx>, local: &'tcx Local<'_>) {
-        if_chain! {
-            if !local.span.from_expansion();
-            if let Some(expr) = local.init;
-            if let ExprKind::Match(target, arms, MatchSource::Normal) = expr.kind;
-            if arms.len() == 1 && arms[0].guard.is_none();
-            if let PatKind::TupleStruct(
-                QPath::Resolved(None, variant_name), args, _) = arms[0].pat.kind;
-            if args.len() == 1;
-            if let PatKind::Binding(_, arg, ..) = strip_pat_refs(&args[0]).kind;
-            let body = peel_blocks(arms[0].body);
-            if path_to_local_id(body, arg);
-
-            then {
-                let mut applicability = Applicability::MachineApplicable;
-                self.infallible_destructuring_match_linted = true;
-                span_lint_and_sugg(
-                    cx,
-                    INFALLIBLE_DESTRUCTURING_MATCH,
-                    local.span,
-                    "you seem to be trying to use `match` to destructure a single infallible pattern. \
-                    Consider using `let`",
-                    "try this",
-                    format!(
-                        "let {}({}) = {};",
-                        snippet_with_applicability(cx, variant_name.span, "..", &mut applicability),
-                        snippet_with_applicability(cx, local.pat.span, "..", &mut applicability),
-                        snippet_with_applicability(cx, target.span, "..", &mut applicability),
-                    ),
-                    applicability,
-                );
-            }
-        }
-    }
-
-    fn check_pat(&mut self, cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>) {
-        if_chain! {
-            if !pat.span.from_expansion();
-            if let PatKind::Struct(QPath::Resolved(_, path), fields, true) = pat.kind;
-            if let Some(def_id) = path.res.opt_def_id();
-            let ty = cx.tcx.type_of(def_id);
-            if let ty::Adt(def, _) = ty.kind();
-            if def.is_struct() || def.is_union();
-            if fields.len() == def.non_enum_variant().fields.len();
-
-            then {
-                span_lint_and_help(
-                    cx,
-                    REST_PAT_IN_FULLY_BOUND_STRUCTS,
-                    pat.span,
-                    "unnecessary use of `..` pattern in struct binding. All fields were already bound",
-                    None,
-                    "consider removing `..` from this binding",
-                );
-            }
-        }
-    }
-
-    extract_msrv_attr!(LateContext);
-}
-
-#[rustfmt::skip]
-fn check_single_match(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>], expr: &Expr<'_>) {
-    if arms.len() == 2 && arms[0].guard.is_none() && arms[1].guard.is_none() {
-        if expr.span.from_expansion() {
-            // Don't lint match expressions present in
-            // macro_rules! block
-            return;
-        }
-        if let PatKind::Or(..) = arms[0].pat.kind {
-            // don't lint for or patterns for now, this makes
-            // the lint noisy in unnecessary situations
-            return;
-        }
-        let els = arms[1].body;
-        let els = if is_unit_expr(peel_blocks(els)) {
-            None
-        } else if let ExprKind::Block(Block { stmts, expr: block_expr, .. }, _) = els.kind {
-            if stmts.len() == 1 && block_expr.is_none() || stmts.is_empty() && block_expr.is_some() {
-                // single statement/expr "else" block, don't lint
-                return;
-            }
-            // block with 2+ statements or 1 expr and 1+ statement
-            Some(els)
-        } else {
-            // not a block, don't lint
-            return;
-        };
-
-        let ty = cx.typeck_results().expr_ty(ex);
-        if *ty.kind() != ty::Bool || is_lint_allowed(cx, MATCH_BOOL, ex.hir_id) {
-            check_single_match_single_pattern(cx, ex, arms, expr, els);
-            check_single_match_opt_like(cx, ex, arms, expr, ty, els);
-        }
-    }
-}
-
-fn check_single_match_single_pattern(
-    cx: &LateContext<'_>,
-    ex: &Expr<'_>,
-    arms: &[Arm<'_>],
-    expr: &Expr<'_>,
-    els: Option<&Expr<'_>>,
-) {
-    if is_wild(arms[1].pat) {
-        report_single_match_single_pattern(cx, ex, arms, expr, els);
-    }
-}
-
-fn report_single_match_single_pattern(
-    cx: &LateContext<'_>,
-    ex: &Expr<'_>,
-    arms: &[Arm<'_>],
-    expr: &Expr<'_>,
-    els: Option<&Expr<'_>>,
-) {
-    let lint = if els.is_some() { SINGLE_MATCH_ELSE } else { SINGLE_MATCH };
-    let els_str = els.map_or(String::new(), |els| {
-        format!(" else {}", expr_block(cx, els, None, "..", Some(expr.span)))
-    });
-
-    let (pat, pat_ref_count) = peel_hir_pat_refs(arms[0].pat);
-    let (msg, sugg) = if_chain! {
-        if let PatKind::Path(_) | PatKind::Lit(_) = pat.kind;
-        let (ty, ty_ref_count) = peel_mid_ty_refs(cx.typeck_results().expr_ty(ex));
-        if let Some(spe_trait_id) = cx.tcx.lang_items().structural_peq_trait();
-        if let Some(pe_trait_id) = cx.tcx.lang_items().eq_trait();
-        if ty.is_integral() || ty.is_char() || ty.is_str()
-            || (implements_trait(cx, ty, spe_trait_id, &[])
-                && implements_trait(cx, ty, pe_trait_id, &[ty.into()]));
-        then {
-            // scrutinee derives PartialEq and the pattern is a constant.
-            let pat_ref_count = match pat.kind {
-                // string literals are already a reference.
-                PatKind::Lit(Expr { kind: ExprKind::Lit(lit), .. }) if lit.node.is_str() => pat_ref_count + 1,
-                _ => pat_ref_count,
-            };
-            // References are only implicitly added to the pattern, so no overflow here.
-            // e.g. will work: match &Some(_) { Some(_) => () }
-            // will not: match Some(_) { &Some(_) => () }
-            let ref_count_diff = ty_ref_count - pat_ref_count;
-
-            // Try to remove address of expressions first.
-            let (ex, removed) = peel_n_hir_expr_refs(ex, ref_count_diff);
-            let ref_count_diff = ref_count_diff - removed;
-
-            let msg = "you seem to be trying to use `match` for an equality check. Consider using `if`";
-            let sugg = format!(
-                "if {} == {}{} {}{}",
-                snippet(cx, ex.span, ".."),
-                // PartialEq for different reference counts may not exist.
-                "&".repeat(ref_count_diff),
-                snippet(cx, arms[0].pat.span, ".."),
-                expr_block(cx, arms[0].body, None, "..", Some(expr.span)),
-                els_str,
-            );
-            (msg, sugg)
-        } else {
-            let msg = "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`";
-            let sugg = format!(
-                "if let {} = {} {}{}",
-                snippet(cx, arms[0].pat.span, ".."),
-                snippet(cx, ex.span, ".."),
-                expr_block(cx, arms[0].body, None, "..", Some(expr.span)),
-                els_str,
-            );
-            (msg, sugg)
-        }
-    };
-
-    span_lint_and_sugg(
-        cx,
-        lint,
-        expr.span,
-        msg,
-        "try this",
-        sugg,
-        Applicability::HasPlaceholders,
-    );
-}
-
-fn check_single_match_opt_like<'a>(
-    cx: &LateContext<'a>,
-    ex: &Expr<'_>,
-    arms: &[Arm<'_>],
-    expr: &Expr<'_>,
-    ty: Ty<'a>,
-    els: Option<&Expr<'_>>,
-) {
-    // list of candidate `Enum`s we know will never get any more members
-    let candidates = &[
-        (&paths::COW, "Borrowed"),
-        (&paths::COW, "Cow::Borrowed"),
-        (&paths::COW, "Cow::Owned"),
-        (&paths::COW, "Owned"),
-        (&paths::OPTION, "None"),
-        (&paths::RESULT, "Err"),
-        (&paths::RESULT, "Ok"),
-    ];
-
-    // We want to suggest to exclude an arm that contains only wildcards or forms the exhaustive
-    // match with the second branch, without enum variants in matches.
-    if !contains_only_wilds(arms[1].pat) && !form_exhaustive_matches(arms[0].pat, arms[1].pat) {
-        return;
-    }
-
-    let mut paths_and_types = Vec::new();
-    if !collect_pat_paths(&mut paths_and_types, cx, arms[1].pat, ty) {
-        return;
-    }
-
-    let in_candidate_enum = |path_info: &(String, &TyS<'_>)| -> bool {
-        let (path, ty) = path_info;
-        for &(ty_path, pat_path) in candidates {
-            if path == pat_path && match_type(cx, ty, ty_path) {
-                return true;
-            }
-        }
-        false
-    };
-    if paths_and_types.iter().all(in_candidate_enum) {
-        report_single_match_single_pattern(cx, ex, arms, expr, els);
-    }
-}
-
-/// Collects paths and their types from the given patterns. Returns true if the given pattern could
-/// be simplified, false otherwise.
-fn collect_pat_paths<'a>(acc: &mut Vec<(String, Ty<'a>)>, cx: &LateContext<'a>, pat: &Pat<'_>, ty: Ty<'a>) -> bool {
-    match pat.kind {
-        PatKind::Wild => true,
-        PatKind::Tuple(inner, _) => inner.iter().all(|p| {
-            let p_ty = cx.typeck_results().pat_ty(p);
-            collect_pat_paths(acc, cx, p, p_ty)
-        }),
-        PatKind::TupleStruct(ref path, ..) => {
-            let path = rustc_hir_pretty::to_string(rustc_hir_pretty::NO_ANN, |s| {
-                s.print_qpath(path, false);
-            });
-            acc.push((path, ty));
-            true
-        },
-        PatKind::Binding(BindingAnnotation::Unannotated, .., ident, None) => {
-            acc.push((ident.to_string(), ty));
-            true
-        },
-        PatKind::Path(ref path) => {
-            let path = rustc_hir_pretty::to_string(rustc_hir_pretty::NO_ANN, |s| {
-                s.print_qpath(path, false);
-            });
-            acc.push((path, ty));
-            true
-        },
-        _ => false,
-    }
-}
-
-/// Returns true if the given arm of pattern matching contains wildcard patterns.
-fn contains_only_wilds(pat: &Pat<'_>) -> bool {
-    match pat.kind {
-        PatKind::Wild => true,
-        PatKind::Tuple(inner, _) | PatKind::TupleStruct(_, inner, ..) => inner.iter().all(contains_only_wilds),
-        _ => false,
-    }
-}
-
-/// Returns true if the given patterns forms only exhaustive matches that don't contain enum
-/// patterns without a wildcard.
-fn form_exhaustive_matches(left: &Pat<'_>, right: &Pat<'_>) -> bool {
-    match (&left.kind, &right.kind) {
-        (PatKind::Wild, _) | (_, PatKind::Wild) => true,
-        (PatKind::Tuple(left_in, left_pos), PatKind::Tuple(right_in, right_pos)) => {
-            // We don't actually know the position and the presence of the `..` (dotdot) operator
-            // in the arms, so we need to evaluate the correct offsets here in order to iterate in
-            // both arms at the same time.
-            let len = max(
-                left_in.len() + {
-                    if left_pos.is_some() { 1 } else { 0 }
-                },
-                right_in.len() + {
-                    if right_pos.is_some() { 1 } else { 0 }
-                },
-            );
-            let mut left_pos = left_pos.unwrap_or(usize::MAX);
-            let mut right_pos = right_pos.unwrap_or(usize::MAX);
-            let mut left_dot_space = 0;
-            let mut right_dot_space = 0;
-            for i in 0..len {
-                let mut found_dotdot = false;
-                if i == left_pos {
-                    left_dot_space += 1;
-                    if left_dot_space < len - left_in.len() {
-                        left_pos += 1;
-                    }
-                    found_dotdot = true;
-                }
-                if i == right_pos {
-                    right_dot_space += 1;
-                    if right_dot_space < len - right_in.len() {
-                        right_pos += 1;
-                    }
-                    found_dotdot = true;
-                }
-                if found_dotdot {
-                    continue;
-                }
-                if !contains_only_wilds(&left_in[i - left_dot_space])
-                    && !contains_only_wilds(&right_in[i - right_dot_space])
-                {
-                    return false;
-                }
-            }
-            true
-        },
-        _ => false,
-    }
-}
-
-fn check_match_bool(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>], expr: &Expr<'_>) {
-    // Type of expression is `bool`.
-    if *cx.typeck_results().expr_ty(ex).kind() == ty::Bool {
-        span_lint_and_then(
-            cx,
-            MATCH_BOOL,
-            expr.span,
-            "you seem to be trying to match on a boolean expression",
-            move |diag| {
-                if arms.len() == 2 {
-                    // no guards
-                    let exprs = if let PatKind::Lit(arm_bool) = arms[0].pat.kind {
-                        if let ExprKind::Lit(ref lit) = arm_bool.kind {
-                            match lit.node {
-                                LitKind::Bool(true) => Some((&*arms[0].body, &*arms[1].body)),
-                                LitKind::Bool(false) => Some((&*arms[1].body, &*arms[0].body)),
-                                _ => None,
-                            }
-                        } else {
-                            None
-                        }
-                    } else {
-                        None
-                    };
-
-                    if let Some((true_expr, false_expr)) = exprs {
-                        let sugg = match (is_unit_expr(true_expr), is_unit_expr(false_expr)) {
-                            (false, false) => Some(format!(
-                                "if {} {} else {}",
-                                snippet(cx, ex.span, "b"),
-                                expr_block(cx, true_expr, None, "..", Some(expr.span)),
-                                expr_block(cx, false_expr, None, "..", Some(expr.span))
-                            )),
-                            (false, true) => Some(format!(
-                                "if {} {}",
-                                snippet(cx, ex.span, "b"),
-                                expr_block(cx, true_expr, None, "..", Some(expr.span))
-                            )),
-                            (true, false) => {
-                                let test = Sugg::hir(cx, ex, "..");
-                                Some(format!(
-                                    "if {} {}",
-                                    !test,
-                                    expr_block(cx, false_expr, None, "..", Some(expr.span))
-                                ))
-                            },
-                            (true, true) => None,
-                        };
-
-                        if let Some(sugg) = sugg {
-                            diag.span_suggestion(
-                                expr.span,
-                                "consider using an `if`/`else` expression",
-                                sugg,
-                                Applicability::HasPlaceholders,
-                            );
-                        }
-                    }
-                }
-            },
-        );
-    }
-}
-
-fn check_overlapping_arms<'tcx>(cx: &LateContext<'tcx>, ex: &'tcx Expr<'_>, arms: &'tcx [Arm<'_>]) {
-    if arms.len() >= 2 && cx.typeck_results().expr_ty(ex).is_integral() {
-        let ranges = all_ranges(cx, arms, cx.typeck_results().expr_ty(ex));
-        if !ranges.is_empty() {
-            if let Some((start, end)) = overlapping(&ranges) {
-                span_lint_and_note(
-                    cx,
-                    MATCH_OVERLAPPING_ARM,
-                    start.span,
-                    "some ranges overlap",
-                    Some(end.span),
-                    "overlaps with this",
-                );
-            }
-        }
-    }
-}
-
-fn check_wild_err_arm<'tcx>(cx: &LateContext<'tcx>, ex: &Expr<'tcx>, arms: &[Arm<'tcx>]) {
-    let ex_ty = cx.typeck_results().expr_ty(ex).peel_refs();
-    if is_type_diagnostic_item(cx, ex_ty, sym::Result) {
-        for arm in arms {
-            if let PatKind::TupleStruct(ref path, inner, _) = arm.pat.kind {
-                let path_str = rustc_hir_pretty::to_string(rustc_hir_pretty::NO_ANN, |s| s.print_qpath(path, false));
-                if path_str == "Err" {
-                    let mut matching_wild = inner.iter().any(is_wild);
-                    let mut ident_bind_name = kw::Underscore;
-                    if !matching_wild {
-                        // Looking for unused bindings (i.e.: `_e`)
-                        for pat in inner.iter() {
-                            if let PatKind::Binding(_, id, ident, None) = pat.kind {
-                                if ident.as_str().starts_with('_') && !is_local_used(cx, arm.body, id) {
-                                    ident_bind_name = ident.name;
-                                    matching_wild = true;
-                                }
-                            }
-                        }
-                    }
-                    if_chain! {
-                        if matching_wild;
-                        if let Some(macro_call) = root_macro_call(peel_blocks_with_stmt(arm.body).span);
-                        if is_panic(cx, macro_call.def_id);
-                        then {
-                            // `Err(_)` or `Err(_e)` arm with `panic!` found
-                            span_lint_and_note(cx,
-                                MATCH_WILD_ERR_ARM,
-                                arm.pat.span,
-                                &format!("`Err({})` matches all errors", ident_bind_name),
-                                None,
-                                "match each error separately or use the error output, or use `.except(msg)` if the error case is unreachable",
-                            );
-                        }
-                    }
-                }
-            }
-        }
-    }
-}
-
-enum CommonPrefixSearcher<'a> {
-    None,
-    Path(&'a [PathSegment<'a>]),
-    Mixed,
-}
-impl<'a> CommonPrefixSearcher<'a> {
-    fn with_path(&mut self, path: &'a [PathSegment<'a>]) {
-        match path {
-            [path @ .., _] => self.with_prefix(path),
-            [] => (),
-        }
-    }
-
-    fn with_prefix(&mut self, path: &'a [PathSegment<'a>]) {
-        match self {
-            Self::None => *self = Self::Path(path),
-            Self::Path(self_path)
-                if path
-                    .iter()
-                    .map(|p| p.ident.name)
-                    .eq(self_path.iter().map(|p| p.ident.name)) => {},
-            Self::Path(_) => *self = Self::Mixed,
-            Self::Mixed => (),
-        }
-    }
-}
-
-fn is_hidden(cx: &LateContext<'_>, variant_def: &VariantDef) -> bool {
-    let attrs = cx.tcx.get_attrs(variant_def.def_id);
-    clippy_utils::attrs::is_doc_hidden(attrs) || clippy_utils::attrs::is_unstable(attrs)
-}
-
-#[allow(clippy::too_many_lines)]
-fn check_wild_enum_match(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>]) {
-    let ty = cx.typeck_results().expr_ty(ex).peel_refs();
-    let adt_def = match ty.kind() {
-        ty::Adt(adt_def, _)
-            if adt_def.is_enum()
-                && !(is_type_diagnostic_item(cx, ty, sym::Option) || is_type_diagnostic_item(cx, ty, sym::Result)) =>
-        {
-            adt_def
-        },
-        _ => return,
-    };
-
-    // First pass - check for violation, but don't do much book-keeping because this is hopefully
-    // the uncommon case, and the book-keeping is slightly expensive.
-    let mut wildcard_span = None;
-    let mut wildcard_ident = None;
-    let mut has_non_wild = false;
-    for arm in arms {
-        match peel_hir_pat_refs(arm.pat).0.kind {
-            PatKind::Wild => wildcard_span = Some(arm.pat.span),
-            PatKind::Binding(_, _, ident, None) => {
-                wildcard_span = Some(arm.pat.span);
-                wildcard_ident = Some(ident);
-            },
-            _ => has_non_wild = true,
-        }
-    }
-    let wildcard_span = match wildcard_span {
-        Some(x) if has_non_wild => x,
-        _ => return,
-    };
-
-    // Accumulate the variants which should be put in place of the wildcard because they're not
-    // already covered.
-    let has_hidden = adt_def.variants.iter().any(|x| is_hidden(cx, x));
-    let mut missing_variants: Vec<_> = adt_def.variants.iter().filter(|x| !is_hidden(cx, x)).collect();
-
-    let mut path_prefix = CommonPrefixSearcher::None;
-    for arm in arms {
-        // Guards mean that this case probably isn't exhaustively covered. Technically
-        // this is incorrect, as we should really check whether each variant is exhaustively
-        // covered by the set of guards that cover it, but that's really hard to do.
-        recurse_or_patterns(arm.pat, |pat| {
-            let path = match &peel_hir_pat_refs(pat).0.kind {
-                PatKind::Path(path) => {
-                    #[allow(clippy::match_same_arms)]
-                    let id = match cx.qpath_res(path, pat.hir_id) {
-                        Res::Def(
-                            DefKind::Const | DefKind::ConstParam | DefKind::AnonConst | DefKind::InlineConst,
-                            _,
-                        ) => return,
-                        Res::Def(_, id) => id,
-                        _ => return,
-                    };
-                    if arm.guard.is_none() {
-                        missing_variants.retain(|e| e.ctor_def_id != Some(id));
-                    }
-                    path
-                },
-                PatKind::TupleStruct(path, patterns, ..) => {
-                    if let Some(id) = cx.qpath_res(path, pat.hir_id).opt_def_id() {
-                        if arm.guard.is_none() && patterns.iter().all(|p| !is_refutable(cx, p)) {
-                            missing_variants.retain(|e| e.ctor_def_id != Some(id));
-                        }
-                    }
-                    path
-                },
-                PatKind::Struct(path, patterns, ..) => {
-                    if let Some(id) = cx.qpath_res(path, pat.hir_id).opt_def_id() {
-                        if arm.guard.is_none() && patterns.iter().all(|p| !is_refutable(cx, p.pat)) {
-                            missing_variants.retain(|e| e.def_id != id);
-                        }
-                    }
-                    path
-                },
-                _ => return,
-            };
-            match path {
-                QPath::Resolved(_, path) => path_prefix.with_path(path.segments),
-                QPath::TypeRelative(
-                    hir::Ty {
-                        kind: TyKind::Path(QPath::Resolved(_, path)),
-                        ..
-                    },
-                    _,
-                ) => path_prefix.with_prefix(path.segments),
-                _ => (),
-            }
-        });
-    }
-
-    let format_suggestion = |variant: &VariantDef| {
-        format!(
-            "{}{}{}{}",
-            if let Some(ident) = wildcard_ident {
-                format!("{} @ ", ident.name)
-            } else {
-                String::new()
-            },
-            if let CommonPrefixSearcher::Path(path_prefix) = path_prefix {
-                let mut s = String::new();
-                for seg in path_prefix {
-                    s.push_str(seg.ident.as_str());
-                    s.push_str("::");
-                }
-                s
-            } else {
-                let mut s = cx.tcx.def_path_str(adt_def.did);
-                s.push_str("::");
-                s
-            },
-            variant.name,
-            match variant.ctor_kind {
-                CtorKind::Fn if variant.fields.len() == 1 => "(_)",
-                CtorKind::Fn => "(..)",
-                CtorKind::Const => "",
-                CtorKind::Fictive => "{ .. }",
-            }
-        )
-    };
-
-    match missing_variants.as_slice() {
-        [] => (),
-        [x] if !adt_def.is_variant_list_non_exhaustive() && !has_hidden => span_lint_and_sugg(
-            cx,
-            MATCH_WILDCARD_FOR_SINGLE_VARIANTS,
-            wildcard_span,
-            "wildcard matches only a single variant and will also match any future added variants",
-            "try this",
-            format_suggestion(x),
-            Applicability::MaybeIncorrect,
-        ),
-        variants => {
-            let mut suggestions: Vec<_> = variants.iter().copied().map(format_suggestion).collect();
-            let message = if adt_def.is_variant_list_non_exhaustive() || has_hidden {
-                suggestions.push("_".into());
-                "wildcard matches known variants and will also match future added variants"
-            } else {
-                "wildcard match will also match any future added variants"
-            };
-
-            span_lint_and_sugg(
-                cx,
-                WILDCARD_ENUM_MATCH_ARM,
-                wildcard_span,
-                message,
-                "try this",
-                suggestions.join(" | "),
-                Applicability::MaybeIncorrect,
-            );
-        },
-    };
-}
-
-fn check_match_ref_pats<'a, 'b, I>(cx: &LateContext<'_>, ex: &Expr<'_>, pats: I, expr: &Expr<'_>)
-where
-    'b: 'a,
-    I: Clone + Iterator<Item = &'a Pat<'b>>,
-{
-    if !has_multiple_ref_pats(pats.clone()) {
-        return;
-    }
-
-    let (first_sugg, msg, title);
-    let span = ex.span.source_callsite();
-    if let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Not, inner) = ex.kind {
-        first_sugg = once((span, Sugg::hir_with_macro_callsite(cx, inner, "..").to_string()));
-        msg = "try";
-        title = "you don't need to add `&` to both the expression and the patterns";
-    } else {
-        first_sugg = once((span, Sugg::hir_with_macro_callsite(cx, ex, "..").deref().to_string()));
-        msg = "instead of prefixing all patterns with `&`, you can dereference the expression";
-        title = "you don't need to add `&` to all patterns";
-    }
-
-    let remaining_suggs = pats.filter_map(|pat| {
-        if let PatKind::Ref(refp, _) = pat.kind {
-            Some((pat.span, snippet(cx, refp.span, "..").to_string()))
-        } else {
-            None
-        }
-    });
-
-    span_lint_and_then(cx, MATCH_REF_PATS, expr.span, title, |diag| {
-        if !expr.span.from_expansion() {
-            multispan_sugg(diag, msg, first_sugg.chain(remaining_suggs));
-        }
-    });
-}
-
-fn check_match_as_ref(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>], expr: &Expr<'_>) {
-    if arms.len() == 2 && arms[0].guard.is_none() && arms[1].guard.is_none() {
-        let arm_ref: Option<BindingAnnotation> = if is_none_arm(cx, &arms[0]) {
-            is_ref_some_arm(cx, &arms[1])
-        } else if is_none_arm(cx, &arms[1]) {
-            is_ref_some_arm(cx, &arms[0])
-        } else {
-            None
-        };
-        if let Some(rb) = arm_ref {
-            let suggestion = if rb == BindingAnnotation::Ref {
-                "as_ref"
-            } else {
-                "as_mut"
-            };
-
-            let output_ty = cx.typeck_results().expr_ty(expr);
-            let input_ty = cx.typeck_results().expr_ty(ex);
-
-            let cast = if_chain! {
-                if let ty::Adt(_, substs) = input_ty.kind();
-                let input_ty = substs.type_at(0);
-                if let ty::Adt(_, substs) = output_ty.kind();
-                let output_ty = substs.type_at(0);
-                if let ty::Ref(_, output_ty, _) = *output_ty.kind();
-                if input_ty != output_ty;
-                then {
-                    ".map(|x| x as _)"
-                } else {
-                    ""
-                }
-            };
-
-            let mut applicability = Applicability::MachineApplicable;
-            span_lint_and_sugg(
-                cx,
-                MATCH_AS_REF,
-                expr.span,
-                &format!("use `{}()` instead", suggestion),
-                "try this",
-                format!(
-                    "{}.{}(){}",
-                    snippet_with_applicability(cx, ex.span, "_", &mut applicability),
-                    suggestion,
-                    cast,
-                ),
-                applicability,
-            );
-        }
-    }
-}
-
-fn check_wild_in_or_pats(cx: &LateContext<'_>, arms: &[Arm<'_>]) {
-    for arm in arms {
-        if let PatKind::Or(fields) = arm.pat.kind {
-            // look for multiple fields in this arm that contains at least one Wild pattern
-            if fields.len() > 1 && fields.iter().any(is_wild) {
-                span_lint_and_help(
-                    cx,
-                    WILDCARD_IN_OR_PATTERNS,
-                    arm.pat.span,
-                    "wildcard pattern covers any other pattern as it will match anyway",
-                    None,
-                    "consider handling `_` separately",
-                );
-            }
-        }
-    }
-}
-
-/// Lint a `match` or `if let .. { .. } else { .. }` expr that could be replaced by `matches!`
-fn check_match_like_matches<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> bool {
-    if let Some(higher::IfLet {
-        let_pat,
-        let_expr,
-        if_then,
-        if_else: Some(if_else),
-    }) = higher::IfLet::hir(cx, expr)
-    {
-        return find_matches_sugg(
-            cx,
-            let_expr,
-            IntoIterator::into_iter([(&[][..], Some(let_pat), if_then, None), (&[][..], None, if_else, None)]),
-            expr,
-            true,
-        );
-    }
-
-    if let ExprKind::Match(scrut, arms, MatchSource::Normal) = expr.kind {
-        return find_matches_sugg(
-            cx,
-            scrut,
-            arms.iter().map(|arm| {
-                (
-                    cx.tcx.hir().attrs(arm.hir_id),
-                    Some(arm.pat),
-                    arm.body,
-                    arm.guard.as_ref(),
-                )
-            }),
-            expr,
-            false,
-        );
-    }
-
-    false
-}
-
-/// Lint a `match` or `if let` for replacement by `matches!`
-fn find_matches_sugg<'a, 'b, I>(
-    cx: &LateContext<'_>,
-    ex: &Expr<'_>,
-    mut iter: I,
-    expr: &Expr<'_>,
-    is_if_let: bool,
-) -> bool
-where
-    'b: 'a,
-    I: Clone
-        + DoubleEndedIterator
-        + ExactSizeIterator
-        + Iterator<
-            Item = (
-                &'a [Attribute],
-                Option<&'a Pat<'b>>,
-                &'a Expr<'b>,
-                Option<&'a Guard<'b>>,
-            ),
-        >,
-{
-    if_chain! {
-        if iter.len() >= 2;
-        if cx.typeck_results().expr_ty(expr).is_bool();
-        if let Some((_, last_pat_opt, last_expr, _)) = iter.next_back();
-        let iter_without_last = iter.clone();
-        if let Some((first_attrs, _, first_expr, first_guard)) = iter.next();
-        if let Some(b0) = find_bool_lit(&first_expr.kind, is_if_let);
-        if let Some(b1) = find_bool_lit(&last_expr.kind, is_if_let);
-        if b0 != b1;
-        if first_guard.is_none() || iter.len() == 0;
-        if first_attrs.is_empty();
-        if iter
-            .all(|arm| {
-                find_bool_lit(&arm.2.kind, is_if_let).map_or(false, |b| b == b0) && arm.3.is_none() && arm.0.is_empty()
-            });
-        then {
-            if let Some(last_pat) = last_pat_opt {
-                if !is_wild(last_pat) {
-                    return false;
-                }
-            }
-
-            // The suggestion may be incorrect, because some arms can have `cfg` attributes
-            // evaluated into `false` and so such arms will be stripped before.
-            let mut applicability = Applicability::MaybeIncorrect;
-            let pat = {
-                use itertools::Itertools as _;
-                iter_without_last
-                    .filter_map(|arm| {
-                        let pat_span = arm.1?.span;
-                        Some(snippet_with_applicability(cx, pat_span, "..", &mut applicability))
-                    })
-                    .join(" | ")
-            };
-            let pat_and_guard = if let Some(Guard::If(g)) = first_guard {
-                format!("{} if {}", pat, snippet_with_applicability(cx, g.span, "..", &mut applicability))
-            } else {
-                pat
-            };
-
-            // strip potential borrows (#6503), but only if the type is a reference
-            let mut ex_new = ex;
-            if let ExprKind::AddrOf(BorrowKind::Ref, .., ex_inner) = ex.kind {
-                if let ty::Ref(..) = cx.typeck_results().expr_ty(ex_inner).kind() {
-                    ex_new = ex_inner;
-                }
-            };
-            span_lint_and_sugg(
-                cx,
-                MATCH_LIKE_MATCHES_MACRO,
-                expr.span,
-                &format!("{} expression looks like `matches!` macro", if is_if_let { "if let .. else" } else { "match" }),
-                "try this",
-                format!(
-                    "{}matches!({}, {})",
-                    if b0 { "" } else { "!" },
-                    snippet_with_applicability(cx, ex_new.span, "..", &mut applicability),
-                    pat_and_guard,
-                ),
-                applicability,
-            );
-            true
-        } else {
-            false
-        }
-    }
-}
-
-/// Extract a `bool` or `{ bool }`
-fn find_bool_lit(ex: &ExprKind<'_>, is_if_let: bool) -> Option<bool> {
-    match ex {
-        ExprKind::Lit(Spanned {
-            node: LitKind::Bool(b), ..
-        }) => Some(*b),
-        ExprKind::Block(
-            rustc_hir::Block {
-                stmts: &[],
-                expr: Some(exp),
-                ..
-            },
-            _,
-        ) if is_if_let => {
-            if let ExprKind::Lit(Spanned {
-                node: LitKind::Bool(b), ..
-            }) = exp.kind
-            {
-                Some(b)
-            } else {
-                None
-            }
-        },
-        _ => None,
-    }
-}
-
-#[allow(clippy::too_many_lines)]
-fn check_match_single_binding<'a>(cx: &LateContext<'a>, ex: &Expr<'a>, arms: &[Arm<'_>], expr: &Expr<'_>) {
-    if expr.span.from_expansion() || arms.len() != 1 || is_refutable(cx, arms[0].pat) {
-        return;
-    }
-
-    // HACK:
-    // This is a hack to deal with arms that are excluded by macros like `#[cfg]`. It is only used here
-    // to prevent false positives as there is currently no better way to detect if code was excluded by
-    // a macro. See PR #6435
-    if_chain! {
-        if let Some(match_snippet) = snippet_opt(cx, expr.span);
-        if let Some(arm_snippet) = snippet_opt(cx, arms[0].span);
-        if let Some(ex_snippet) = snippet_opt(cx, ex.span);
-        let rest_snippet = match_snippet.replace(&arm_snippet, "").replace(&ex_snippet, "");
-        if rest_snippet.contains("=>");
-        then {
-            // The code it self contains another thick arrow "=>"
-            // -> Either another arm or a comment
-            return;
-        }
-    }
-
-    let matched_vars = ex.span;
-    let bind_names = arms[0].pat.span;
-    let match_body = peel_blocks(arms[0].body);
-    let mut snippet_body = if match_body.span.from_expansion() {
-        Sugg::hir_with_macro_callsite(cx, match_body, "..").to_string()
-    } else {
-        snippet_block(cx, match_body.span, "..", Some(expr.span)).to_string()
-    };
-
-    // Do we need to add ';' to suggestion ?
-    match match_body.kind {
-        ExprKind::Block(block, _) => {
-            // macro + expr_ty(body) == ()
-            if block.span.from_expansion() && cx.typeck_results().expr_ty(match_body).is_unit() {
-                snippet_body.push(';');
-            }
-        },
-        _ => {
-            // expr_ty(body) == ()
-            if cx.typeck_results().expr_ty(match_body).is_unit() {
-                snippet_body.push(';');
-            }
-        },
-    }
-
-    let mut applicability = Applicability::MaybeIncorrect;
-    match arms[0].pat.kind {
-        PatKind::Binding(..) | PatKind::Tuple(_, _) | PatKind::Struct(..) => {
-            // If this match is in a local (`let`) stmt
-            let (target_span, sugg) = if let Some(parent_let_node) = opt_parent_let(cx, ex) {
-                (
-                    parent_let_node.span,
-                    format!(
-                        "let {} = {};\n{}let {} = {};",
-                        snippet_with_applicability(cx, bind_names, "..", &mut applicability),
-                        snippet_with_applicability(cx, matched_vars, "..", &mut applicability),
-                        " ".repeat(indent_of(cx, expr.span).unwrap_or(0)),
-                        snippet_with_applicability(cx, parent_let_node.pat.span, "..", &mut applicability),
-                        snippet_body
-                    ),
-                )
-            } else {
-                // If we are in closure, we need curly braces around suggestion
-                let mut indent = " ".repeat(indent_of(cx, ex.span).unwrap_or(0));
-                let (mut cbrace_start, mut cbrace_end) = ("".to_string(), "".to_string());
-                if let Some(parent_expr) = get_parent_expr(cx, expr) {
-                    if let ExprKind::Closure(..) = parent_expr.kind {
-                        cbrace_end = format!("\n{}}}", indent);
-                        // Fix body indent due to the closure
-                        indent = " ".repeat(indent_of(cx, bind_names).unwrap_or(0));
-                        cbrace_start = format!("{{\n{}", indent);
-                    }
-                }
-                // If the parent is already an arm, and the body is another match statement,
-                // we need curly braces around suggestion
-                let parent_node_id = cx.tcx.hir().get_parent_node(expr.hir_id);
-                if let Node::Arm(arm) = &cx.tcx.hir().get(parent_node_id) {
-                    if let ExprKind::Match(..) = arm.body.kind {
-                        cbrace_end = format!("\n{}}}", indent);
-                        // Fix body indent due to the match
-                        indent = " ".repeat(indent_of(cx, bind_names).unwrap_or(0));
-                        cbrace_start = format!("{{\n{}", indent);
-                    }
-                }
-                (
-                    expr.span,
-                    format!(
-                        "{}let {} = {};\n{}{}{}",
-                        cbrace_start,
-                        snippet_with_applicability(cx, bind_names, "..", &mut applicability),
-                        snippet_with_applicability(cx, matched_vars, "..", &mut applicability),
-                        indent,
-                        snippet_body,
-                        cbrace_end
-                    ),
-                )
-            };
-            span_lint_and_sugg(
-                cx,
-                MATCH_SINGLE_BINDING,
-                target_span,
-                "this match could be written as a `let` statement",
-                "consider using `let` statement",
-                sugg,
-                applicability,
-            );
-        },
-        PatKind::Wild => {
-            if ex.can_have_side_effects() {
-                let indent = " ".repeat(indent_of(cx, expr.span).unwrap_or(0));
-                let sugg = format!(
-                    "{};\n{}{}",
-                    snippet_with_applicability(cx, ex.span, "..", &mut applicability),
-                    indent,
-                    snippet_body
-                );
-                span_lint_and_sugg(
-                    cx,
-                    MATCH_SINGLE_BINDING,
-                    expr.span,
-                    "this match could be replaced by its scrutinee and body",
-                    "consider using the scrutinee and body instead",
-                    sugg,
-                    applicability,
-                );
-            } else {
-                span_lint_and_sugg(
-                    cx,
-                    MATCH_SINGLE_BINDING,
-                    expr.span,
-                    "this match could be replaced by its body itself",
-                    "consider using the match body instead",
-                    snippet_body,
-                    Applicability::MachineApplicable,
-                );
-            }
-        },
-        _ => (),
-    }
-}
-
-/// Returns true if the `ex` match expression is in a local (`let`) statement
-fn opt_parent_let<'a>(cx: &LateContext<'a>, ex: &Expr<'a>) -> Option<&'a Local<'a>> {
-    let map = &cx.tcx.hir();
-    if_chain! {
-        if let Some(Node::Expr(parent_arm_expr)) = map.find(map.get_parent_node(ex.hir_id));
-        if let Some(Node::Local(parent_let_expr)) = map.find(map.get_parent_node(parent_arm_expr.hir_id));
-        then {
-            return Some(parent_let_expr);
-        }
-    }
-    None
-}
-
-/// Gets the ranges for each range pattern arm. Applies `ty` bounds for open ranges.
-fn all_ranges<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>], ty: Ty<'tcx>) -> Vec<SpannedRange<FullInt>> {
-    arms.iter()
-        .filter_map(|arm| {
-            if let Arm { pat, guard: None, .. } = *arm {
-                if let PatKind::Range(ref lhs, ref rhs, range_end) = pat.kind {
-                    let lhs_const = match lhs {
-                        Some(lhs) => constant(cx, cx.typeck_results(), lhs)?.0,
-                        None => miri_to_const(ty.numeric_min_val(cx.tcx)?)?,
-                    };
-                    let rhs_const = match rhs {
-                        Some(rhs) => constant(cx, cx.typeck_results(), rhs)?.0,
-                        None => miri_to_const(ty.numeric_max_val(cx.tcx)?)?,
-                    };
-
-                    let lhs_val = lhs_const.int_value(cx, ty)?;
-                    let rhs_val = rhs_const.int_value(cx, ty)?;
-
-                    let rhs_bound = match range_end {
-                        RangeEnd::Included => EndBound::Included(rhs_val),
-                        RangeEnd::Excluded => EndBound::Excluded(rhs_val),
-                    };
-                    return Some(SpannedRange {
-                        span: pat.span,
-                        node: (lhs_val, rhs_bound),
-                    });
-                }
-
-                if let PatKind::Lit(value) = pat.kind {
-                    let value = constant_full_int(cx, cx.typeck_results(), value)?;
-                    return Some(SpannedRange {
-                        span: pat.span,
-                        node: (value, EndBound::Included(value)),
-                    });
-                }
-            }
-            None
-        })
-        .collect()
-}
-
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-pub enum EndBound<T> {
-    Included(T),
-    Excluded(T),
-}
-
-#[derive(Debug, Eq, PartialEq)]
-struct SpannedRange<T> {
-    pub span: Span,
-    pub node: (T, EndBound<T>),
-}
-
-// Checks if arm has the form `None => None`
-fn is_none_arm(cx: &LateContext<'_>, arm: &Arm<'_>) -> bool {
-    matches!(arm.pat.kind, PatKind::Path(ref qpath) if is_lang_ctor(cx, qpath, OptionNone))
-}
-
-// Checks if arm has the form `Some(ref v) => Some(v)` (checks for `ref` and `ref mut`)
-fn is_ref_some_arm(cx: &LateContext<'_>, arm: &Arm<'_>) -> Option<BindingAnnotation> {
-    if_chain! {
-        if let PatKind::TupleStruct(ref qpath, [first_pat, ..], _) = arm.pat.kind;
-        if is_lang_ctor(cx, qpath, OptionSome);
-        if let PatKind::Binding(rb, .., ident, _) = first_pat.kind;
-        if rb == BindingAnnotation::Ref || rb == BindingAnnotation::RefMut;
-        if let ExprKind::Call(e, args) = peel_blocks(arm.body).kind;
-        if let ExprKind::Path(ref some_path) = e.kind;
-        if is_lang_ctor(cx, some_path, OptionSome) && args.len() == 1;
-        if let ExprKind::Path(QPath::Resolved(_, path2)) = args[0].kind;
-        if path2.segments.len() == 1 && ident.name == path2.segments[0].ident.name;
-        then {
-            return Some(rb)
-        }
-    }
-    None
-}
-
-fn has_multiple_ref_pats<'a, 'b, I>(pats: I) -> bool
-where
-    'b: 'a,
-    I: Iterator<Item = &'a Pat<'b>>,
-{
-    let mut ref_count = 0;
-    for opt in pats.map(|pat| match pat.kind {
-        PatKind::Ref(..) => Some(true), // &-patterns
-        PatKind::Wild => Some(false),   // an "anything" wildcard is also fine
-        _ => None,                      // any other pattern is not fine
-    }) {
-        if let Some(inner) = opt {
-            if inner {
-                ref_count += 1;
-            }
-        } else {
-            return false;
-        }
-    }
-    ref_count > 1
-}
-
-fn overlapping<T>(ranges: &[SpannedRange<T>]) -> Option<(&SpannedRange<T>, &SpannedRange<T>)>
-where
-    T: Copy + Ord,
-{
-    #[derive(Copy, Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
-    enum BoundKind {
-        EndExcluded,
-        Start,
-        EndIncluded,
-    }
-
-    #[derive(Copy, Clone, Debug, Eq, PartialEq)]
-    struct RangeBound<'a, T>(T, BoundKind, &'a SpannedRange<T>);
-
-    impl<'a, T: Copy + Ord> PartialOrd for RangeBound<'a, T> {
-        fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-            Some(self.cmp(other))
-        }
-    }
-
-    impl<'a, T: Copy + Ord> Ord for RangeBound<'a, T> {
-        fn cmp(&self, RangeBound(other_value, other_kind, _): &Self) -> Ordering {
-            let RangeBound(self_value, self_kind, _) = *self;
-            (self_value, self_kind).cmp(&(*other_value, *other_kind))
-        }
-    }
-
-    let mut values = Vec::with_capacity(2 * ranges.len());
-
-    for r @ SpannedRange { node: (start, end), .. } in ranges {
-        values.push(RangeBound(*start, BoundKind::Start, r));
-        values.push(match end {
-            EndBound::Excluded(val) => RangeBound(*val, BoundKind::EndExcluded, r),
-            EndBound::Included(val) => RangeBound(*val, BoundKind::EndIncluded, r),
-        });
-    }
-
-    values.sort();
-
-    let mut started = vec![];
-
-    for RangeBound(_, kind, range) in values {
-        match kind {
-            BoundKind::Start => started.push(range),
-            BoundKind::EndExcluded | BoundKind::EndIncluded => {
-                let mut overlap = None;
-
-                while let Some(last_started) = started.pop() {
-                    if last_started == range {
-                        break;
-                    }
-                    overlap = Some(last_started);
-                }
-
-                if let Some(first_overlapping) = overlap {
-                    return Some((range, first_overlapping));
-                }
-            },
-        }
-    }
-
-    None
-}
-
-mod redundant_pattern_match {
-    use super::REDUNDANT_PATTERN_MATCHING;
-    use clippy_utils::diagnostics::span_lint_and_then;
-    use clippy_utils::source::snippet;
-    use clippy_utils::sugg::Sugg;
-    use clippy_utils::ty::{implements_trait, is_type_diagnostic_item, is_type_lang_item, match_type};
-    use clippy_utils::{higher, match_def_path};
-    use clippy_utils::{is_lang_ctor, is_trait_method, paths};
-    use if_chain::if_chain;
-    use rustc_ast::ast::LitKind;
-    use rustc_data_structures::fx::FxHashSet;
-    use rustc_errors::Applicability;
-    use rustc_hir::LangItem::{OptionNone, PollPending};
-    use rustc_hir::{
-        intravisit::{walk_expr, Visitor},
-        Arm, Block, Expr, ExprKind, LangItem, MatchSource, Node, Pat, PatKind, QPath, UnOp,
-    };
-    use rustc_lint::LateContext;
-    use rustc_middle::ty::{self, subst::GenericArgKind, DefIdTree, Ty};
-    use rustc_span::sym;
-
-    pub fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if let Some(higher::IfLet {
-            if_else,
-            let_pat,
-            let_expr,
-            ..
-        }) = higher::IfLet::hir(cx, expr)
-        {
-            find_sugg_for_if_let(cx, expr, let_pat, let_expr, "if", if_else.is_some());
-        }
-        if let ExprKind::Match(op, arms, MatchSource::Normal) = &expr.kind {
-            find_sugg_for_match(cx, expr, op, arms);
-        }
-        if let Some(higher::WhileLet { let_pat, let_expr, .. }) = higher::WhileLet::hir(expr) {
-            find_sugg_for_if_let(cx, expr, let_pat, let_expr, "while", false);
-        }
-    }
-
-    /// Checks if the drop order for a type matters. Some std types implement drop solely to
-    /// deallocate memory. For these types, and composites containing them, changing the drop order
-    /// won't result in any observable side effects.
-    fn type_needs_ordered_drop<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
-        type_needs_ordered_drop_inner(cx, ty, &mut FxHashSet::default())
-    }
-
-    fn type_needs_ordered_drop_inner<'tcx>(
-        cx: &LateContext<'tcx>,
-        ty: Ty<'tcx>,
-        seen: &mut FxHashSet<Ty<'tcx>>,
-    ) -> bool {
-        if !seen.insert(ty) {
-            return false;
-        }
-        if !ty.needs_drop(cx.tcx, cx.param_env) {
-            false
-        } else if !cx
-            .tcx
-            .lang_items()
-            .drop_trait()
-            .map_or(false, |id| implements_trait(cx, ty, id, &[]))
-        {
-            // This type doesn't implement drop, so no side effects here.
-            // Check if any component type has any.
-            match ty.kind() {
-                ty::Tuple(_) => ty.tuple_fields().any(|ty| type_needs_ordered_drop_inner(cx, ty, seen)),
-                ty::Array(ty, _) => type_needs_ordered_drop_inner(cx, ty, seen),
-                ty::Adt(adt, subs) => adt
-                    .all_fields()
-                    .map(|f| f.ty(cx.tcx, subs))
-                    .any(|ty| type_needs_ordered_drop_inner(cx, ty, seen)),
-                _ => true,
-            }
-        }
-        // Check for std types which implement drop, but only for memory allocation.
-        else if is_type_diagnostic_item(cx, ty, sym::Vec)
-            || is_type_lang_item(cx, ty, LangItem::OwnedBox)
-            || is_type_diagnostic_item(cx, ty, sym::Rc)
-            || is_type_diagnostic_item(cx, ty, sym::Arc)
-            || is_type_diagnostic_item(cx, ty, sym::cstring_type)
-            || is_type_diagnostic_item(cx, ty, sym::BTreeMap)
-            || is_type_diagnostic_item(cx, ty, sym::LinkedList)
-            || match_type(cx, ty, &paths::WEAK_RC)
-            || match_type(cx, ty, &paths::WEAK_ARC)
-        {
-            // Check all of the generic arguments.
-            if let ty::Adt(_, subs) = ty.kind() {
-                subs.types().any(|ty| type_needs_ordered_drop_inner(cx, ty, seen))
-            } else {
-                true
-            }
-        } else {
-            true
-        }
-    }
-
-    // Extract the generic arguments out of a type
-    fn try_get_generic_ty(ty: Ty<'_>, index: usize) -> Option<Ty<'_>> {
-        if_chain! {
-            if let ty::Adt(_, subs) = ty.kind();
-            if let Some(sub) = subs.get(index);
-            if let GenericArgKind::Type(sub_ty) = sub.unpack();
-            then {
-                Some(sub_ty)
-            } else {
-                None
-            }
-        }
-    }
-
-    // Checks if there are any temporaries created in the given expression for which drop order
-    // matters.
-    fn temporaries_need_ordered_drop<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
-        struct V<'a, 'tcx> {
-            cx: &'a LateContext<'tcx>,
-            res: bool,
-        }
-        impl<'a, 'tcx> Visitor<'tcx> for V<'a, 'tcx> {
-            fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) {
-                match expr.kind {
-                    // Taking the reference of a value leaves a temporary
-                    // e.g. In `&String::new()` the string is a temporary value.
-                    // Remaining fields are temporary values
-                    // e.g. In `(String::new(), 0).1` the string is a temporary value.
-                    ExprKind::AddrOf(_, _, expr) | ExprKind::Field(expr, _) => {
-                        if !matches!(expr.kind, ExprKind::Path(_)) {
-                            if type_needs_ordered_drop(self.cx, self.cx.typeck_results().expr_ty(expr)) {
-                                self.res = true;
-                            } else {
-                                self.visit_expr(expr);
-                            }
-                        }
-                    },
-                    // the base type is alway taken by reference.
-                    // e.g. In `(vec![0])[0]` the vector is a temporary value.
-                    ExprKind::Index(base, index) => {
-                        if !matches!(base.kind, ExprKind::Path(_)) {
-                            if type_needs_ordered_drop(self.cx, self.cx.typeck_results().expr_ty(base)) {
-                                self.res = true;
-                            } else {
-                                self.visit_expr(base);
-                            }
-                        }
-                        self.visit_expr(index);
-                    },
-                    // Method calls can take self by reference.
-                    // e.g. In `String::new().len()` the string is a temporary value.
-                    ExprKind::MethodCall(_, [self_arg, args @ ..], _) => {
-                        if !matches!(self_arg.kind, ExprKind::Path(_)) {
-                            let self_by_ref = self
-                                .cx
-                                .typeck_results()
-                                .type_dependent_def_id(expr.hir_id)
-                                .map_or(false, |id| self.cx.tcx.fn_sig(id).skip_binder().inputs()[0].is_ref());
-                            if self_by_ref
-                                && type_needs_ordered_drop(self.cx, self.cx.typeck_results().expr_ty(self_arg))
-                            {
-                                self.res = true;
-                            } else {
-                                self.visit_expr(self_arg);
-                            }
-                        }
-                        args.iter().for_each(|arg| self.visit_expr(arg));
-                    },
-                    // Either explicitly drops values, or changes control flow.
-                    ExprKind::DropTemps(_)
-                    | ExprKind::Ret(_)
-                    | ExprKind::Break(..)
-                    | ExprKind::Yield(..)
-                    | ExprKind::Block(Block { expr: None, .. }, _)
-                    | ExprKind::Loop(..) => (),
-
-                    // Only consider the final expression.
-                    ExprKind::Block(Block { expr: Some(expr), .. }, _) => self.visit_expr(expr),
-
-                    _ => walk_expr(self, expr),
-                }
-            }
-        }
-
-        let mut v = V { cx, res: false };
-        v.visit_expr(expr);
-        v.res
-    }
-
-    fn find_sugg_for_if_let<'tcx>(
-        cx: &LateContext<'tcx>,
-        expr: &'tcx Expr<'_>,
-        let_pat: &Pat<'_>,
-        let_expr: &'tcx Expr<'_>,
-        keyword: &'static str,
-        has_else: bool,
-    ) {
-        // also look inside refs
-        // if we have &None for example, peel it so we can detect "if let None = x"
-        let check_pat = match let_pat.kind {
-            PatKind::Ref(inner, _mutability) => inner,
-            _ => let_pat,
-        };
-        let op_ty = cx.typeck_results().expr_ty(let_expr);
-        // Determine which function should be used, and the type contained by the corresponding
-        // variant.
-        let (good_method, inner_ty) = match check_pat.kind {
-            PatKind::TupleStruct(ref qpath, [sub_pat], _) => {
-                if let PatKind::Wild = sub_pat.kind {
-                    let res = cx.typeck_results().qpath_res(qpath, check_pat.hir_id);
-                    let Some(id) = res.opt_def_id().and_then(|ctor_id| cx.tcx.parent(ctor_id)) else { return };
-                    let lang_items = cx.tcx.lang_items();
-                    if Some(id) == lang_items.result_ok_variant() {
-                        ("is_ok()", try_get_generic_ty(op_ty, 0).unwrap_or(op_ty))
-                    } else if Some(id) == lang_items.result_err_variant() {
-                        ("is_err()", try_get_generic_ty(op_ty, 1).unwrap_or(op_ty))
-                    } else if Some(id) == lang_items.option_some_variant() {
-                        ("is_some()", op_ty)
-                    } else if Some(id) == lang_items.poll_ready_variant() {
-                        ("is_ready()", op_ty)
-                    } else if match_def_path(cx, id, &paths::IPADDR_V4) {
-                        ("is_ipv4()", op_ty)
-                    } else if match_def_path(cx, id, &paths::IPADDR_V6) {
-                        ("is_ipv6()", op_ty)
-                    } else {
-                        return;
-                    }
-                } else {
-                    return;
-                }
-            },
-            PatKind::Path(ref path) => {
-                let method = if is_lang_ctor(cx, path, OptionNone) {
-                    "is_none()"
-                } else if is_lang_ctor(cx, path, PollPending) {
-                    "is_pending()"
-                } else {
-                    return;
-                };
-                // `None` and `Pending` don't have an inner type.
-                (method, cx.tcx.types.unit)
-            },
-            _ => return,
-        };
-
-        // If this is the last expression in a block or there is an else clause then the whole
-        // type needs to be considered, not just the inner type of the branch being matched on.
-        // Note the last expression in a block is dropped after all local bindings.
-        let check_ty = if has_else
-            || (keyword == "if" && matches!(cx.tcx.hir().parent_iter(expr.hir_id).next(), Some((_, Node::Block(..)))))
-        {
-            op_ty
-        } else {
-            inner_ty
-        };
-
-        // All temporaries created in the scrutinee expression are dropped at the same time as the
-        // scrutinee would be, so they have to be considered as well.
-        // e.g. in `if let Some(x) = foo.lock().unwrap().baz.as_ref() { .. }` the lock will be held
-        // for the duration if body.
-        let needs_drop = type_needs_ordered_drop(cx, check_ty) || temporaries_need_ordered_drop(cx, let_expr);
-
-        // check that `while_let_on_iterator` lint does not trigger
-        if_chain! {
-            if keyword == "while";
-            if let ExprKind::MethodCall(method_path, _, _) = let_expr.kind;
-            if method_path.ident.name == sym::next;
-            if is_trait_method(cx, let_expr, sym::Iterator);
-            then {
-                return;
-            }
-        }
-
-        let result_expr = match &let_expr.kind {
-            ExprKind::AddrOf(_, _, borrowed) => borrowed,
-            ExprKind::Unary(UnOp::Deref, deref) => deref,
-            _ => let_expr,
-        };
-
-        span_lint_and_then(
-            cx,
-            REDUNDANT_PATTERN_MATCHING,
-            let_pat.span,
-            &format!("redundant pattern matching, consider using `{}`", good_method),
-            |diag| {
-                // if/while let ... = ... { ... }
-                // ^^^^^^^^^^^^^^^^^^^^^^^^^^^
-                let expr_span = expr.span;
-
-                // if/while let ... = ... { ... }
-                //                 ^^^
-                let op_span = result_expr.span.source_callsite();
-
-                // if/while let ... = ... { ... }
-                // ^^^^^^^^^^^^^^^^^^^
-                let span = expr_span.until(op_span.shrink_to_hi());
-
-                let app = if needs_drop {
-                    Applicability::MaybeIncorrect
-                } else {
-                    Applicability::MachineApplicable
-                };
-
-                let sugg = Sugg::hir_with_macro_callsite(cx, result_expr, "_")
-                    .maybe_par()
-                    .to_string();
-
-                diag.span_suggestion(span, "try this", format!("{} {}.{}", keyword, sugg, good_method), app);
-
-                if needs_drop {
-                    diag.note("this will change drop order of the result, as well as all temporaries");
-                    diag.note("add `#[allow(clippy::redundant_pattern_matching)]` if this is important");
-                }
-            },
-        );
-    }
-
-    fn find_sugg_for_match<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, op: &Expr<'_>, arms: &[Arm<'_>]) {
-        if arms.len() == 2 {
-            let node_pair = (&arms[0].pat.kind, &arms[1].pat.kind);
-
-            let found_good_method = match node_pair {
-                (
-                    PatKind::TupleStruct(ref path_left, patterns_left, _),
-                    PatKind::TupleStruct(ref path_right, patterns_right, _),
-                ) if patterns_left.len() == 1 && patterns_right.len() == 1 => {
-                    if let (PatKind::Wild, PatKind::Wild) = (&patterns_left[0].kind, &patterns_right[0].kind) {
-                        find_good_method_for_match(
-                            cx,
-                            arms,
-                            path_left,
-                            path_right,
-                            &paths::RESULT_OK,
-                            &paths::RESULT_ERR,
-                            "is_ok()",
-                            "is_err()",
-                        )
-                        .or_else(|| {
-                            find_good_method_for_match(
-                                cx,
-                                arms,
-                                path_left,
-                                path_right,
-                                &paths::IPADDR_V4,
-                                &paths::IPADDR_V6,
-                                "is_ipv4()",
-                                "is_ipv6()",
-                            )
-                        })
-                    } else {
-                        None
-                    }
-                },
-                (PatKind::TupleStruct(ref path_left, patterns, _), PatKind::Path(ref path_right))
-                | (PatKind::Path(ref path_left), PatKind::TupleStruct(ref path_right, patterns, _))
-                    if patterns.len() == 1 =>
-                {
-                    if let PatKind::Wild = patterns[0].kind {
-                        find_good_method_for_match(
-                            cx,
-                            arms,
-                            path_left,
-                            path_right,
-                            &paths::OPTION_SOME,
-                            &paths::OPTION_NONE,
-                            "is_some()",
-                            "is_none()",
-                        )
-                        .or_else(|| {
-                            find_good_method_for_match(
-                                cx,
-                                arms,
-                                path_left,
-                                path_right,
-                                &paths::POLL_READY,
-                                &paths::POLL_PENDING,
-                                "is_ready()",
-                                "is_pending()",
-                            )
-                        })
-                    } else {
-                        None
-                    }
-                },
-                _ => None,
-            };
-
-            if let Some(good_method) = found_good_method {
-                let span = expr.span.to(op.span);
-                let result_expr = match &op.kind {
-                    ExprKind::AddrOf(_, _, borrowed) => borrowed,
-                    _ => op,
-                };
-                span_lint_and_then(
-                    cx,
-                    REDUNDANT_PATTERN_MATCHING,
-                    expr.span,
-                    &format!("redundant pattern matching, consider using `{}`", good_method),
-                    |diag| {
-                        diag.span_suggestion(
-                            span,
-                            "try this",
-                            format!("{}.{}", snippet(cx, result_expr.span, "_"), good_method),
-                            Applicability::MaybeIncorrect, // snippet
-                        );
-                    },
-                );
-            }
-        }
-    }
-
-    #[allow(clippy::too_many_arguments)]
-    fn find_good_method_for_match<'a>(
-        cx: &LateContext<'_>,
-        arms: &[Arm<'_>],
-        path_left: &QPath<'_>,
-        path_right: &QPath<'_>,
-        expected_left: &[&str],
-        expected_right: &[&str],
-        should_be_left: &'a str,
-        should_be_right: &'a str,
-    ) -> Option<&'a str> {
-        let left_id = cx
-            .typeck_results()
-            .qpath_res(path_left, arms[0].pat.hir_id)
-            .opt_def_id()?;
-        let right_id = cx
-            .typeck_results()
-            .qpath_res(path_right, arms[1].pat.hir_id)
-            .opt_def_id()?;
-        let body_node_pair =
-            if match_def_path(cx, left_id, expected_left) && match_def_path(cx, right_id, expected_right) {
-                (&(*arms[0].body).kind, &(*arms[1].body).kind)
-            } else if match_def_path(cx, right_id, expected_left) && match_def_path(cx, right_id, expected_right) {
-                (&(*arms[1].body).kind, &(*arms[0].body).kind)
-            } else {
-                return None;
-            };
-
-        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)) => Some(should_be_left),
-                (LitKind::Bool(false), LitKind::Bool(true)) => Some(should_be_right),
-                _ => None,
-            },
-            _ => None,
-        }
-    }
-}
-
-#[test]
-fn test_overlapping() {
-    use rustc_span::source_map::DUMMY_SP;
-
-    let sp = |s, e| SpannedRange {
-        span: DUMMY_SP,
-        node: (s, e),
-    };
-
-    assert_eq!(None, overlapping::<u8>(&[]));
-    assert_eq!(None, overlapping(&[sp(1, EndBound::Included(4))]));
-    assert_eq!(
-        None,
-        overlapping(&[sp(1, EndBound::Included(4)), sp(5, EndBound::Included(6))])
-    );
-    assert_eq!(
-        None,
-        overlapping(&[
-            sp(1, EndBound::Included(4)),
-            sp(5, EndBound::Included(6)),
-            sp(10, EndBound::Included(11))
-        ],)
-    );
-    assert_eq!(
-        Some((&sp(1, EndBound::Included(4)), &sp(3, EndBound::Included(6)))),
-        overlapping(&[sp(1, EndBound::Included(4)), sp(3, EndBound::Included(6))])
-    );
-    assert_eq!(
-        Some((&sp(5, EndBound::Included(6)), &sp(6, EndBound::Included(11)))),
-        overlapping(&[
-            sp(1, EndBound::Included(4)),
-            sp(5, EndBound::Included(6)),
-            sp(6, EndBound::Included(11))
-        ],)
-    );
-}
-
-/// Implementation of `MATCH_SAME_ARMS`.
-fn lint_match_arms<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>) {
-    if let ExprKind::Match(_, arms, MatchSource::Normal) = expr.kind {
-        let hash = |&(_, arm): &(usize, &Arm<'_>)| -> u64 {
-            let mut h = SpanlessHash::new(cx);
-            h.hash_expr(arm.body);
-            h.finish()
-        };
-
-        let eq = |&(lindex, lhs): &(usize, &Arm<'_>), &(rindex, rhs): &(usize, &Arm<'_>)| -> bool {
-            let min_index = usize::min(lindex, rindex);
-            let max_index = usize::max(lindex, rindex);
-
-            let mut local_map: HirIdMap<HirId> = HirIdMap::default();
-            let eq_fallback = |a: &Expr<'_>, b: &Expr<'_>| {
-                if_chain! {
-                    if let Some(a_id) = path_to_local(a);
-                    if let Some(b_id) = path_to_local(b);
-                    let entry = match local_map.entry(a_id) {
-                        Entry::Vacant(entry) => entry,
-                        // check if using the same bindings as before
-                        Entry::Occupied(entry) => return *entry.get() == b_id,
-                    };
-                    // the names technically don't have to match; this makes the lint more conservative
-                    if cx.tcx.hir().name(a_id) == cx.tcx.hir().name(b_id);
-                    if TyS::same_type(cx.typeck_results().expr_ty(a), cx.typeck_results().expr_ty(b));
-                    if pat_contains_local(lhs.pat, a_id);
-                    if pat_contains_local(rhs.pat, b_id);
-                    then {
-                        entry.insert(b_id);
-                        true
-                    } else {
-                        false
-                    }
-                }
-            };
-            // Arms with a guard are ignored, those can’t always be merged together
-            // This is also the case for arms in-between each there is an arm with a guard
-            (min_index..=max_index).all(|index| arms[index].guard.is_none())
-                && SpanlessEq::new(cx)
-                    .expr_fallback(eq_fallback)
-                    .eq_expr(lhs.body, rhs.body)
-                // these checks could be removed to allow unused bindings
-                && bindings_eq(lhs.pat, local_map.keys().copied().collect())
-                && bindings_eq(rhs.pat, local_map.values().copied().collect())
-        };
-
-        let indexed_arms: Vec<(usize, &Arm<'_>)> = arms.iter().enumerate().collect();
-        for (&(_, i), &(_, j)) in search_same(&indexed_arms, hash, eq) {
-            span_lint_and_then(
-                cx,
-                MATCH_SAME_ARMS,
-                j.body.span,
-                "this `match` has identical arm bodies",
-                |diag| {
-                    diag.span_note(i.body.span, "same as this");
-
-                    // Note: this does not use `span_suggestion` on purpose:
-                    // there is no clean way
-                    // to remove the other arm. Building a span and suggest to replace it to ""
-                    // makes an even more confusing error message. Also in order not to make up a
-                    // span for the whole pattern, the suggestion is only shown when there is only
-                    // one pattern. The user should know about `|` if they are already using it…
-
-                    let lhs = snippet(cx, i.pat.span, "<pat1>");
-                    let rhs = snippet(cx, j.pat.span, "<pat2>");
-
-                    if let PatKind::Wild = j.pat.kind {
-                        // if the last arm is _, then i could be integrated into _
-                        // note that i.pat cannot be _, because that would mean that we're
-                        // hiding all the subsequent arms, and rust won't compile
-                        diag.span_note(
-                            i.body.span,
-                            &format!(
-                                "`{}` has the same arm body as the `_` wildcard, consider removing it",
-                                lhs
-                            ),
-                        );
-                    } else {
-                        diag.span_help(i.pat.span, &format!("consider refactoring into `{} | {}`", lhs, rhs,))
-                            .help("...or consider changing the match arm bodies");
-                    }
-                },
-            );
-        }
-    }
-}
-
-fn pat_contains_local(pat: &Pat<'_>, id: HirId) -> bool {
-    let mut result = false;
-    pat.walk_short(|p| {
-        result |= matches!(p.kind, PatKind::Binding(_, binding_id, ..) if binding_id == id);
-        !result
-    });
-    result
-}
-
-/// Returns true if all the bindings in the `Pat` are in `ids` and vice versa
-fn bindings_eq(pat: &Pat<'_>, mut ids: HirIdSet) -> bool {
-    let mut result = true;
-    pat.each_binding_or_first(&mut |_, id, _, _| result &= ids.remove(&id));
-    result && ids.is_empty()
-}
diff --git a/clippy_lints/src/matches/mod.rs b/clippy_lints/src/matches/mod.rs
new file mode 100644
index 00000000000..67fb918d20c
--- /dev/null
+++ b/clippy_lints/src/matches/mod.rs
@@ -0,0 +1,2445 @@
+use clippy_utils::consts::{constant, constant_full_int, miri_to_const, FullInt};
+use clippy_utils::diagnostics::{
+    multispan_sugg, span_lint_and_help, span_lint_and_note, span_lint_and_sugg, span_lint_and_then,
+};
+use clippy_utils::macros::{is_panic, root_macro_call};
+use clippy_utils::source::{expr_block, indent_of, snippet, snippet_block, snippet_opt, snippet_with_applicability};
+use clippy_utils::sugg::Sugg;
+use clippy_utils::ty::{implements_trait, is_type_diagnostic_item, match_type, peel_mid_ty_refs};
+use clippy_utils::visitors::is_local_used;
+use clippy_utils::{
+    get_parent_expr, is_lang_ctor, is_lint_allowed, is_refutable, is_unit_expr, is_wild, meets_msrv, msrvs,
+    path_to_local, path_to_local_id, peel_blocks, peel_hir_pat_refs, peel_n_hir_expr_refs, recurse_or_patterns,
+    strip_pat_refs,
+};
+use clippy_utils::{higher, peel_blocks_with_stmt};
+use clippy_utils::{paths, search_same, SpanlessEq, SpanlessHash};
+use core::iter::{once, ExactSizeIterator};
+use if_chain::if_chain;
+use rustc_ast::ast::{Attribute, LitKind};
+use rustc_errors::Applicability;
+use rustc_hir::def::{CtorKind, DefKind, Res};
+use rustc_hir::LangItem::{OptionNone, OptionSome};
+use rustc_hir::{
+    self as hir, Arm, BindingAnnotation, Block, BorrowKind, Expr, ExprKind, Guard, HirId, Local, MatchSource,
+    Mutability, Node, Pat, PatKind, PathSegment, QPath, RangeEnd, TyKind,
+};
+use rustc_hir::{HirIdMap, HirIdSet};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::{self, Ty, TyS, VariantDef};
+use rustc_semver::RustcVersion;
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::source_map::{Span, Spanned};
+use rustc_span::{sym, symbol::kw};
+use std::cmp::{max, Ordering};
+use std::collections::hash_map::Entry;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for matches with a single arm where an `if let`
+    /// will usually suffice.
+    ///
+    /// ### Why is this bad?
+    /// Just readability – `if let` nests less than a `match`.
+    ///
+    /// ### Example
+    /// ```rust
+    /// # fn bar(stool: &str) {}
+    /// # let x = Some("abc");
+    /// // Bad
+    /// match x {
+    ///     Some(ref foo) => bar(foo),
+    ///     _ => (),
+    /// }
+    ///
+    /// // Good
+    /// if let Some(ref foo) = x {
+    ///     bar(foo);
+    /// }
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub SINGLE_MATCH,
+    style,
+    "a `match` statement with a single nontrivial arm (i.e., where the other arm is `_ => {}`) instead of `if let`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for matches with two arms where an `if let else` will
+    /// usually suffice.
+    ///
+    /// ### Why is this bad?
+    /// Just readability – `if let` nests less than a `match`.
+    ///
+    /// ### Known problems
+    /// Personal style preferences may differ.
+    ///
+    /// ### Example
+    /// Using `match`:
+    ///
+    /// ```rust
+    /// # fn bar(foo: &usize) {}
+    /// # let other_ref: usize = 1;
+    /// # let x: Option<&usize> = Some(&1);
+    /// match x {
+    ///     Some(ref foo) => bar(foo),
+    ///     _ => bar(&other_ref),
+    /// }
+    /// ```
+    ///
+    /// Using `if let` with `else`:
+    ///
+    /// ```rust
+    /// # fn bar(foo: &usize) {}
+    /// # let other_ref: usize = 1;
+    /// # let x: Option<&usize> = Some(&1);
+    /// if let Some(ref foo) = x {
+    ///     bar(foo);
+    /// } else {
+    ///     bar(&other_ref);
+    /// }
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub SINGLE_MATCH_ELSE,
+    pedantic,
+    "a `match` statement with two arms where the second arm's pattern is a placeholder instead of a specific match pattern"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for matches where all arms match a reference,
+    /// suggesting to remove the reference and deref the matched expression
+    /// instead. It also checks for `if let &foo = bar` blocks.
+    ///
+    /// ### Why is this bad?
+    /// It just makes the code less readable. That reference
+    /// destructuring adds nothing to the code.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// // Bad
+    /// match x {
+    ///     &A(ref y) => foo(y),
+    ///     &B => bar(),
+    ///     _ => frob(&x),
+    /// }
+    ///
+    /// // Good
+    /// match *x {
+    ///     A(ref y) => foo(y),
+    ///     B => bar(),
+    ///     _ => frob(x),
+    /// }
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub MATCH_REF_PATS,
+    style,
+    "a `match` or `if let` with all arms prefixed with `&` instead of deref-ing the match expression"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for matches where match expression is a `bool`. It
+    /// suggests to replace the expression with an `if...else` block.
+    ///
+    /// ### Why is this bad?
+    /// It makes the code less readable.
+    ///
+    /// ### Example
+    /// ```rust
+    /// # fn foo() {}
+    /// # fn bar() {}
+    /// let condition: bool = true;
+    /// match condition {
+    ///     true => foo(),
+    ///     false => bar(),
+    /// }
+    /// ```
+    /// Use if/else instead:
+    /// ```rust
+    /// # fn foo() {}
+    /// # fn bar() {}
+    /// let condition: bool = true;
+    /// if condition {
+    ///     foo();
+    /// } else {
+    ///     bar();
+    /// }
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub MATCH_BOOL,
+    pedantic,
+    "a `match` on a boolean expression instead of an `if..else` block"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for overlapping match arms.
+    ///
+    /// ### Why is this bad?
+    /// It is likely to be an error and if not, makes the code
+    /// less obvious.
+    ///
+    /// ### Example
+    /// ```rust
+    /// let x = 5;
+    /// match x {
+    ///     1..=10 => println!("1 ... 10"),
+    ///     5..=15 => println!("5 ... 15"),
+    ///     _ => (),
+    /// }
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub MATCH_OVERLAPPING_ARM,
+    style,
+    "a `match` with overlapping arms"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for arm which matches all errors with `Err(_)`
+    /// and take drastic actions like `panic!`.
+    ///
+    /// ### Why is this bad?
+    /// It is generally a bad practice, similar to
+    /// catching all exceptions in java with `catch(Exception)`
+    ///
+    /// ### Example
+    /// ```rust
+    /// let x: Result<i32, &str> = Ok(3);
+    /// match x {
+    ///     Ok(_) => println!("ok"),
+    ///     Err(_) => panic!("err"),
+    /// }
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub MATCH_WILD_ERR_ARM,
+    pedantic,
+    "a `match` with `Err(_)` arm and take drastic actions"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for match which is used to add a reference to an
+    /// `Option` value.
+    ///
+    /// ### Why is this bad?
+    /// Using `as_ref()` or `as_mut()` instead is shorter.
+    ///
+    /// ### Example
+    /// ```rust
+    /// let x: Option<()> = None;
+    ///
+    /// // Bad
+    /// let r: Option<&()> = match x {
+    ///     None => None,
+    ///     Some(ref v) => Some(v),
+    /// };
+    ///
+    /// // Good
+    /// let r: Option<&()> = x.as_ref();
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub MATCH_AS_REF,
+    complexity,
+    "a `match` on an Option value instead of using `as_ref()` or `as_mut`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for wildcard enum matches using `_`.
+    ///
+    /// ### Why is this bad?
+    /// New enum variants added by library updates can be missed.
+    ///
+    /// ### Known problems
+    /// Suggested replacements may be incorrect if guards exhaustively cover some
+    /// variants, and also may not use correct path to enum if it's not present in the current scope.
+    ///
+    /// ### Example
+    /// ```rust
+    /// # enum Foo { A(usize), B(usize) }
+    /// # let x = Foo::B(1);
+    /// // Bad
+    /// match x {
+    ///     Foo::A(_) => {},
+    ///     _ => {},
+    /// }
+    ///
+    /// // Good
+    /// match x {
+    ///     Foo::A(_) => {},
+    ///     Foo::B(_) => {},
+    /// }
+    /// ```
+    #[clippy::version = "1.34.0"]
+    pub WILDCARD_ENUM_MATCH_ARM,
+    restriction,
+    "a wildcard enum match arm using `_`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for wildcard enum matches for a single variant.
+    ///
+    /// ### Why is this bad?
+    /// New enum variants added by library updates can be missed.
+    ///
+    /// ### Known problems
+    /// Suggested replacements may not use correct path to enum
+    /// if it's not present in the current scope.
+    ///
+    /// ### Example
+    /// ```rust
+    /// # enum Foo { A, B, C }
+    /// # let x = Foo::B;
+    /// // Bad
+    /// match x {
+    ///     Foo::A => {},
+    ///     Foo::B => {},
+    ///     _ => {},
+    /// }
+    ///
+    /// // Good
+    /// match x {
+    ///     Foo::A => {},
+    ///     Foo::B => {},
+    ///     Foo::C => {},
+    /// }
+    /// ```
+    #[clippy::version = "1.45.0"]
+    pub MATCH_WILDCARD_FOR_SINGLE_VARIANTS,
+    pedantic,
+    "a wildcard enum match for a single variant"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for wildcard pattern used with others patterns in same match arm.
+    ///
+    /// ### Why is this bad?
+    /// Wildcard pattern already covers any other pattern as it will match anyway.
+    /// It makes the code less readable, especially to spot wildcard pattern use in match arm.
+    ///
+    /// ### Example
+    /// ```rust
+    /// // Bad
+    /// match "foo" {
+    ///     "a" => {},
+    ///     "bar" | _ => {},
+    /// }
+    ///
+    /// // Good
+    /// match "foo" {
+    ///     "a" => {},
+    ///     _ => {},
+    /// }
+    /// ```
+    #[clippy::version = "1.42.0"]
+    pub WILDCARD_IN_OR_PATTERNS,
+    complexity,
+    "a wildcard pattern used with others patterns in same match arm"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for matches being used to destructure a single-variant enum
+    /// or tuple struct where a `let` will suffice.
+    ///
+    /// ### Why is this bad?
+    /// Just readability – `let` doesn't nest, whereas a `match` does.
+    ///
+    /// ### Example
+    /// ```rust
+    /// enum Wrapper {
+    ///     Data(i32),
+    /// }
+    ///
+    /// let wrapper = Wrapper::Data(42);
+    ///
+    /// let data = match wrapper {
+    ///     Wrapper::Data(i) => i,
+    /// };
+    /// ```
+    ///
+    /// The correct use would be:
+    /// ```rust
+    /// enum Wrapper {
+    ///     Data(i32),
+    /// }
+    ///
+    /// let wrapper = Wrapper::Data(42);
+    /// let Wrapper::Data(data) = wrapper;
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub INFALLIBLE_DESTRUCTURING_MATCH,
+    style,
+    "a `match` statement with a single infallible arm instead of a `let`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for useless match that binds to only one value.
+    ///
+    /// ### Why is this bad?
+    /// Readability and needless complexity.
+    ///
+    /// ### Known problems
+    ///  Suggested replacements may be incorrect when `match`
+    /// is actually binding temporary value, bringing a 'dropped while borrowed' error.
+    ///
+    /// ### Example
+    /// ```rust
+    /// # let a = 1;
+    /// # let b = 2;
+    ///
+    /// // Bad
+    /// match (a, b) {
+    ///     (c, d) => {
+    ///         // useless match
+    ///     }
+    /// }
+    ///
+    /// // Good
+    /// let (c, d) = (a, b);
+    /// ```
+    #[clippy::version = "1.43.0"]
+    pub MATCH_SINGLE_BINDING,
+    complexity,
+    "a match with a single binding instead of using `let` statement"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for unnecessary '..' pattern binding on struct when all fields are explicitly matched.
+    ///
+    /// ### Why is this bad?
+    /// Correctness and readability. It's like having a wildcard pattern after
+    /// matching all enum variants explicitly.
+    ///
+    /// ### Example
+    /// ```rust
+    /// # struct A { a: i32 }
+    /// let a = A { a: 5 };
+    ///
+    /// // Bad
+    /// match a {
+    ///     A { a: 5, .. } => {},
+    ///     _ => {},
+    /// }
+    ///
+    /// // Good
+    /// match a {
+    ///     A { a: 5 } => {},
+    ///     _ => {},
+    /// }
+    /// ```
+    #[clippy::version = "1.43.0"]
+    pub REST_PAT_IN_FULLY_BOUND_STRUCTS,
+    restriction,
+    "a match on a struct that binds all fields but still uses the wildcard pattern"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Lint for redundant pattern matching over `Result`, `Option`,
+    /// `std::task::Poll` or `std::net::IpAddr`
+    ///
+    /// ### Why is this bad?
+    /// It's more concise and clear to just use the proper
+    /// utility function
+    ///
+    /// ### Known problems
+    /// This will change the drop order for the matched type. Both `if let` and
+    /// `while let` will drop the value at the end of the block, both `if` and `while` will drop the
+    /// value before entering the block. For most types this change will not matter, but for a few
+    /// types this will not be an acceptable change (e.g. locks). See the
+    /// [reference](https://doc.rust-lang.org/reference/destructors.html#drop-scopes) for more about
+    /// drop order.
+    ///
+    /// ### Example
+    /// ```rust
+    /// # use std::task::Poll;
+    /// # use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
+    /// if let Ok(_) = Ok::<i32, i32>(42) {}
+    /// if let Err(_) = Err::<i32, i32>(42) {}
+    /// if let None = None::<()> {}
+    /// if let Some(_) = Some(42) {}
+    /// if let Poll::Pending = Poll::Pending::<()> {}
+    /// if let Poll::Ready(_) = Poll::Ready(42) {}
+    /// if let IpAddr::V4(_) = IpAddr::V4(Ipv4Addr::LOCALHOST) {}
+    /// if let IpAddr::V6(_) = IpAddr::V6(Ipv6Addr::LOCALHOST) {}
+    /// match Ok::<i32, i32>(42) {
+    ///     Ok(_) => true,
+    ///     Err(_) => false,
+    /// };
+    /// ```
+    ///
+    /// The more idiomatic use would be:
+    ///
+    /// ```rust
+    /// # use std::task::Poll;
+    /// # use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
+    /// if Ok::<i32, i32>(42).is_ok() {}
+    /// if Err::<i32, i32>(42).is_err() {}
+    /// if None::<()>.is_none() {}
+    /// if Some(42).is_some() {}
+    /// if Poll::Pending::<()>.is_pending() {}
+    /// if Poll::Ready(42).is_ready() {}
+    /// if IpAddr::V4(Ipv4Addr::LOCALHOST).is_ipv4() {}
+    /// if IpAddr::V6(Ipv6Addr::LOCALHOST).is_ipv6() {}
+    /// Ok::<i32, i32>(42).is_ok();
+    /// ```
+    #[clippy::version = "1.31.0"]
+    pub REDUNDANT_PATTERN_MATCHING,
+    style,
+    "use the proper utility function avoiding an `if let`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `match`  or `if let` expressions producing a
+    /// `bool` that could be written using `matches!`
+    ///
+    /// ### Why is this bad?
+    /// Readability and needless complexity.
+    ///
+    /// ### Known problems
+    /// This lint falsely triggers, if there are arms with
+    /// `cfg` attributes that remove an arm evaluating to `false`.
+    ///
+    /// ### Example
+    /// ```rust
+    /// let x = Some(5);
+    ///
+    /// // Bad
+    /// let a = match x {
+    ///     Some(0) => true,
+    ///     _ => false,
+    /// };
+    ///
+    /// let a = if let Some(0) = x {
+    ///     true
+    /// } else {
+    ///     false
+    /// };
+    ///
+    /// // Good
+    /// let a = matches!(x, Some(0));
+    /// ```
+    #[clippy::version = "1.47.0"]
+    pub MATCH_LIKE_MATCHES_MACRO,
+    style,
+    "a match that could be written with the matches! macro"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `match` with identical arm bodies.
+    ///
+    /// ### Why is this bad?
+    /// This is probably a copy & paste error. If arm bodies
+    /// are the same on purpose, you can factor them
+    /// [using `|`](https://doc.rust-lang.org/book/patterns.html#multiple-patterns).
+    ///
+    /// ### Known problems
+    /// False positive possible with order dependent `match`
+    /// (see issue
+    /// [#860](https://github.com/rust-lang/rust-clippy/issues/860)).
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// match foo {
+    ///     Bar => bar(),
+    ///     Quz => quz(),
+    ///     Baz => bar(), // <= oops
+    /// }
+    /// ```
+    ///
+    /// This should probably be
+    /// ```rust,ignore
+    /// match foo {
+    ///     Bar => bar(),
+    ///     Quz => quz(),
+    ///     Baz => baz(), // <= fixed
+    /// }
+    /// ```
+    ///
+    /// or if the original code was not a typo:
+    /// ```rust,ignore
+    /// match foo {
+    ///     Bar | Baz => bar(), // <= shows the intent better
+    ///     Quz => quz(),
+    /// }
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub MATCH_SAME_ARMS,
+    pedantic,
+    "`match` with identical arm bodies"
+}
+
+#[derive(Default)]
+pub struct Matches {
+    msrv: Option<RustcVersion>,
+    infallible_destructuring_match_linted: bool,
+}
+
+impl Matches {
+    #[must_use]
+    pub fn new(msrv: Option<RustcVersion>) -> Self {
+        Self {
+            msrv,
+            ..Matches::default()
+        }
+    }
+}
+
+impl_lint_pass!(Matches => [
+    SINGLE_MATCH,
+    MATCH_REF_PATS,
+    MATCH_BOOL,
+    SINGLE_MATCH_ELSE,
+    MATCH_OVERLAPPING_ARM,
+    MATCH_WILD_ERR_ARM,
+    MATCH_AS_REF,
+    WILDCARD_ENUM_MATCH_ARM,
+    MATCH_WILDCARD_FOR_SINGLE_VARIANTS,
+    WILDCARD_IN_OR_PATTERNS,
+    MATCH_SINGLE_BINDING,
+    INFALLIBLE_DESTRUCTURING_MATCH,
+    REST_PAT_IN_FULLY_BOUND_STRUCTS,
+    REDUNDANT_PATTERN_MATCHING,
+    MATCH_LIKE_MATCHES_MACRO,
+    MATCH_SAME_ARMS,
+]);
+
+impl<'tcx> LateLintPass<'tcx> for Matches {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        if expr.span.from_expansion() {
+            return;
+        }
+
+        redundant_pattern_match::check(cx, expr);
+
+        if meets_msrv(self.msrv.as_ref(), &msrvs::MATCHES_MACRO) {
+            if !check_match_like_matches(cx, expr) {
+                lint_match_arms(cx, expr);
+            }
+        } else {
+            lint_match_arms(cx, expr);
+        }
+
+        if let ExprKind::Match(ex, arms, MatchSource::Normal) = expr.kind {
+            check_single_match(cx, ex, arms, expr);
+            check_match_bool(cx, ex, arms, expr);
+            check_overlapping_arms(cx, ex, arms);
+            check_wild_err_arm(cx, ex, arms);
+            check_wild_enum_match(cx, ex, arms);
+            check_match_as_ref(cx, ex, arms, expr);
+            check_wild_in_or_pats(cx, arms);
+
+            if self.infallible_destructuring_match_linted {
+                self.infallible_destructuring_match_linted = false;
+            } else {
+                check_match_single_binding(cx, ex, arms, expr);
+            }
+        }
+        if let ExprKind::Match(ex, arms, _) = expr.kind {
+            check_match_ref_pats(cx, ex, arms.iter().map(|el| el.pat), expr);
+        }
+    }
+
+    fn check_local(&mut self, cx: &LateContext<'tcx>, local: &'tcx Local<'_>) {
+        if_chain! {
+            if !local.span.from_expansion();
+            if let Some(expr) = local.init;
+            if let ExprKind::Match(target, arms, MatchSource::Normal) = expr.kind;
+            if arms.len() == 1 && arms[0].guard.is_none();
+            if let PatKind::TupleStruct(
+                QPath::Resolved(None, variant_name), args, _) = arms[0].pat.kind;
+            if args.len() == 1;
+            if let PatKind::Binding(_, arg, ..) = strip_pat_refs(&args[0]).kind;
+            let body = peel_blocks(arms[0].body);
+            if path_to_local_id(body, arg);
+
+            then {
+                let mut applicability = Applicability::MachineApplicable;
+                self.infallible_destructuring_match_linted = true;
+                span_lint_and_sugg(
+                    cx,
+                    INFALLIBLE_DESTRUCTURING_MATCH,
+                    local.span,
+                    "you seem to be trying to use `match` to destructure a single infallible pattern. \
+                    Consider using `let`",
+                    "try this",
+                    format!(
+                        "let {}({}) = {};",
+                        snippet_with_applicability(cx, variant_name.span, "..", &mut applicability),
+                        snippet_with_applicability(cx, local.pat.span, "..", &mut applicability),
+                        snippet_with_applicability(cx, target.span, "..", &mut applicability),
+                    ),
+                    applicability,
+                );
+            }
+        }
+    }
+
+    fn check_pat(&mut self, cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>) {
+        if_chain! {
+            if !pat.span.from_expansion();
+            if let PatKind::Struct(QPath::Resolved(_, path), fields, true) = pat.kind;
+            if let Some(def_id) = path.res.opt_def_id();
+            let ty = cx.tcx.type_of(def_id);
+            if let ty::Adt(def, _) = ty.kind();
+            if def.is_struct() || def.is_union();
+            if fields.len() == def.non_enum_variant().fields.len();
+
+            then {
+                span_lint_and_help(
+                    cx,
+                    REST_PAT_IN_FULLY_BOUND_STRUCTS,
+                    pat.span,
+                    "unnecessary use of `..` pattern in struct binding. All fields were already bound",
+                    None,
+                    "consider removing `..` from this binding",
+                );
+            }
+        }
+    }
+
+    extract_msrv_attr!(LateContext);
+}
+
+#[rustfmt::skip]
+fn check_single_match(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>], expr: &Expr<'_>) {
+    if arms.len() == 2 && arms[0].guard.is_none() && arms[1].guard.is_none() {
+        if expr.span.from_expansion() {
+            // Don't lint match expressions present in
+            // macro_rules! block
+            return;
+        }
+        if let PatKind::Or(..) = arms[0].pat.kind {
+            // don't lint for or patterns for now, this makes
+            // the lint noisy in unnecessary situations
+            return;
+        }
+        let els = arms[1].body;
+        let els = if is_unit_expr(peel_blocks(els)) {
+            None
+        } else if let ExprKind::Block(Block { stmts, expr: block_expr, .. }, _) = els.kind {
+            if stmts.len() == 1 && block_expr.is_none() || stmts.is_empty() && block_expr.is_some() {
+                // single statement/expr "else" block, don't lint
+                return;
+            }
+            // block with 2+ statements or 1 expr and 1+ statement
+            Some(els)
+        } else {
+            // not a block, don't lint
+            return;
+        };
+
+        let ty = cx.typeck_results().expr_ty(ex);
+        if *ty.kind() != ty::Bool || is_lint_allowed(cx, MATCH_BOOL, ex.hir_id) {
+            check_single_match_single_pattern(cx, ex, arms, expr, els);
+            check_single_match_opt_like(cx, ex, arms, expr, ty, els);
+        }
+    }
+}
+
+fn check_single_match_single_pattern(
+    cx: &LateContext<'_>,
+    ex: &Expr<'_>,
+    arms: &[Arm<'_>],
+    expr: &Expr<'_>,
+    els: Option<&Expr<'_>>,
+) {
+    if is_wild(arms[1].pat) {
+        report_single_match_single_pattern(cx, ex, arms, expr, els);
+    }
+}
+
+fn report_single_match_single_pattern(
+    cx: &LateContext<'_>,
+    ex: &Expr<'_>,
+    arms: &[Arm<'_>],
+    expr: &Expr<'_>,
+    els: Option<&Expr<'_>>,
+) {
+    let lint = if els.is_some() { SINGLE_MATCH_ELSE } else { SINGLE_MATCH };
+    let els_str = els.map_or(String::new(), |els| {
+        format!(" else {}", expr_block(cx, els, None, "..", Some(expr.span)))
+    });
+
+    let (pat, pat_ref_count) = peel_hir_pat_refs(arms[0].pat);
+    let (msg, sugg) = if_chain! {
+        if let PatKind::Path(_) | PatKind::Lit(_) = pat.kind;
+        let (ty, ty_ref_count) = peel_mid_ty_refs(cx.typeck_results().expr_ty(ex));
+        if let Some(spe_trait_id) = cx.tcx.lang_items().structural_peq_trait();
+        if let Some(pe_trait_id) = cx.tcx.lang_items().eq_trait();
+        if ty.is_integral() || ty.is_char() || ty.is_str()
+            || (implements_trait(cx, ty, spe_trait_id, &[])
+                && implements_trait(cx, ty, pe_trait_id, &[ty.into()]));
+        then {
+            // scrutinee derives PartialEq and the pattern is a constant.
+            let pat_ref_count = match pat.kind {
+                // string literals are already a reference.
+                PatKind::Lit(Expr { kind: ExprKind::Lit(lit), .. }) if lit.node.is_str() => pat_ref_count + 1,
+                _ => pat_ref_count,
+            };
+            // References are only implicitly added to the pattern, so no overflow here.
+            // e.g. will work: match &Some(_) { Some(_) => () }
+            // will not: match Some(_) { &Some(_) => () }
+            let ref_count_diff = ty_ref_count - pat_ref_count;
+
+            // Try to remove address of expressions first.
+            let (ex, removed) = peel_n_hir_expr_refs(ex, ref_count_diff);
+            let ref_count_diff = ref_count_diff - removed;
+
+            let msg = "you seem to be trying to use `match` for an equality check. Consider using `if`";
+            let sugg = format!(
+                "if {} == {}{} {}{}",
+                snippet(cx, ex.span, ".."),
+                // PartialEq for different reference counts may not exist.
+                "&".repeat(ref_count_diff),
+                snippet(cx, arms[0].pat.span, ".."),
+                expr_block(cx, arms[0].body, None, "..", Some(expr.span)),
+                els_str,
+            );
+            (msg, sugg)
+        } else {
+            let msg = "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`";
+            let sugg = format!(
+                "if let {} = {} {}{}",
+                snippet(cx, arms[0].pat.span, ".."),
+                snippet(cx, ex.span, ".."),
+                expr_block(cx, arms[0].body, None, "..", Some(expr.span)),
+                els_str,
+            );
+            (msg, sugg)
+        }
+    };
+
+    span_lint_and_sugg(
+        cx,
+        lint,
+        expr.span,
+        msg,
+        "try this",
+        sugg,
+        Applicability::HasPlaceholders,
+    );
+}
+
+fn check_single_match_opt_like<'a>(
+    cx: &LateContext<'a>,
+    ex: &Expr<'_>,
+    arms: &[Arm<'_>],
+    expr: &Expr<'_>,
+    ty: Ty<'a>,
+    els: Option<&Expr<'_>>,
+) {
+    // list of candidate `Enum`s we know will never get any more members
+    let candidates = &[
+        (&paths::COW, "Borrowed"),
+        (&paths::COW, "Cow::Borrowed"),
+        (&paths::COW, "Cow::Owned"),
+        (&paths::COW, "Owned"),
+        (&paths::OPTION, "None"),
+        (&paths::RESULT, "Err"),
+        (&paths::RESULT, "Ok"),
+    ];
+
+    // We want to suggest to exclude an arm that contains only wildcards or forms the exhaustive
+    // match with the second branch, without enum variants in matches.
+    if !contains_only_wilds(arms[1].pat) && !form_exhaustive_matches(arms[0].pat, arms[1].pat) {
+        return;
+    }
+
+    let mut paths_and_types = Vec::new();
+    if !collect_pat_paths(&mut paths_and_types, cx, arms[1].pat, ty) {
+        return;
+    }
+
+    let in_candidate_enum = |path_info: &(String, &TyS<'_>)| -> bool {
+        let (path, ty) = path_info;
+        for &(ty_path, pat_path) in candidates {
+            if path == pat_path && match_type(cx, ty, ty_path) {
+                return true;
+            }
+        }
+        false
+    };
+    if paths_and_types.iter().all(in_candidate_enum) {
+        report_single_match_single_pattern(cx, ex, arms, expr, els);
+    }
+}
+
+/// Collects paths and their types from the given patterns. Returns true if the given pattern could
+/// be simplified, false otherwise.
+fn collect_pat_paths<'a>(acc: &mut Vec<(String, Ty<'a>)>, cx: &LateContext<'a>, pat: &Pat<'_>, ty: Ty<'a>) -> bool {
+    match pat.kind {
+        PatKind::Wild => true,
+        PatKind::Tuple(inner, _) => inner.iter().all(|p| {
+            let p_ty = cx.typeck_results().pat_ty(p);
+            collect_pat_paths(acc, cx, p, p_ty)
+        }),
+        PatKind::TupleStruct(ref path, ..) => {
+            let path = rustc_hir_pretty::to_string(rustc_hir_pretty::NO_ANN, |s| {
+                s.print_qpath(path, false);
+            });
+            acc.push((path, ty));
+            true
+        },
+        PatKind::Binding(BindingAnnotation::Unannotated, .., ident, None) => {
+            acc.push((ident.to_string(), ty));
+            true
+        },
+        PatKind::Path(ref path) => {
+            let path = rustc_hir_pretty::to_string(rustc_hir_pretty::NO_ANN, |s| {
+                s.print_qpath(path, false);
+            });
+            acc.push((path, ty));
+            true
+        },
+        _ => false,
+    }
+}
+
+/// Returns true if the given arm of pattern matching contains wildcard patterns.
+fn contains_only_wilds(pat: &Pat<'_>) -> bool {
+    match pat.kind {
+        PatKind::Wild => true,
+        PatKind::Tuple(inner, _) | PatKind::TupleStruct(_, inner, ..) => inner.iter().all(contains_only_wilds),
+        _ => false,
+    }
+}
+
+/// Returns true if the given patterns forms only exhaustive matches that don't contain enum
+/// patterns without a wildcard.
+fn form_exhaustive_matches(left: &Pat<'_>, right: &Pat<'_>) -> bool {
+    match (&left.kind, &right.kind) {
+        (PatKind::Wild, _) | (_, PatKind::Wild) => true,
+        (PatKind::Tuple(left_in, left_pos), PatKind::Tuple(right_in, right_pos)) => {
+            // We don't actually know the position and the presence of the `..` (dotdot) operator
+            // in the arms, so we need to evaluate the correct offsets here in order to iterate in
+            // both arms at the same time.
+            let len = max(
+                left_in.len() + {
+                    if left_pos.is_some() { 1 } else { 0 }
+                },
+                right_in.len() + {
+                    if right_pos.is_some() { 1 } else { 0 }
+                },
+            );
+            let mut left_pos = left_pos.unwrap_or(usize::MAX);
+            let mut right_pos = right_pos.unwrap_or(usize::MAX);
+            let mut left_dot_space = 0;
+            let mut right_dot_space = 0;
+            for i in 0..len {
+                let mut found_dotdot = false;
+                if i == left_pos {
+                    left_dot_space += 1;
+                    if left_dot_space < len - left_in.len() {
+                        left_pos += 1;
+                    }
+                    found_dotdot = true;
+                }
+                if i == right_pos {
+                    right_dot_space += 1;
+                    if right_dot_space < len - right_in.len() {
+                        right_pos += 1;
+                    }
+                    found_dotdot = true;
+                }
+                if found_dotdot {
+                    continue;
+                }
+                if !contains_only_wilds(&left_in[i - left_dot_space])
+                    && !contains_only_wilds(&right_in[i - right_dot_space])
+                {
+                    return false;
+                }
+            }
+            true
+        },
+        _ => false,
+    }
+}
+
+fn check_match_bool(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>], expr: &Expr<'_>) {
+    // Type of expression is `bool`.
+    if *cx.typeck_results().expr_ty(ex).kind() == ty::Bool {
+        span_lint_and_then(
+            cx,
+            MATCH_BOOL,
+            expr.span,
+            "you seem to be trying to match on a boolean expression",
+            move |diag| {
+                if arms.len() == 2 {
+                    // no guards
+                    let exprs = if let PatKind::Lit(arm_bool) = arms[0].pat.kind {
+                        if let ExprKind::Lit(ref lit) = arm_bool.kind {
+                            match lit.node {
+                                LitKind::Bool(true) => Some((&*arms[0].body, &*arms[1].body)),
+                                LitKind::Bool(false) => Some((&*arms[1].body, &*arms[0].body)),
+                                _ => None,
+                            }
+                        } else {
+                            None
+                        }
+                    } else {
+                        None
+                    };
+
+                    if let Some((true_expr, false_expr)) = exprs {
+                        let sugg = match (is_unit_expr(true_expr), is_unit_expr(false_expr)) {
+                            (false, false) => Some(format!(
+                                "if {} {} else {}",
+                                snippet(cx, ex.span, "b"),
+                                expr_block(cx, true_expr, None, "..", Some(expr.span)),
+                                expr_block(cx, false_expr, None, "..", Some(expr.span))
+                            )),
+                            (false, true) => Some(format!(
+                                "if {} {}",
+                                snippet(cx, ex.span, "b"),
+                                expr_block(cx, true_expr, None, "..", Some(expr.span))
+                            )),
+                            (true, false) => {
+                                let test = Sugg::hir(cx, ex, "..");
+                                Some(format!(
+                                    "if {} {}",
+                                    !test,
+                                    expr_block(cx, false_expr, None, "..", Some(expr.span))
+                                ))
+                            },
+                            (true, true) => None,
+                        };
+
+                        if let Some(sugg) = sugg {
+                            diag.span_suggestion(
+                                expr.span,
+                                "consider using an `if`/`else` expression",
+                                sugg,
+                                Applicability::HasPlaceholders,
+                            );
+                        }
+                    }
+                }
+            },
+        );
+    }
+}
+
+fn check_overlapping_arms<'tcx>(cx: &LateContext<'tcx>, ex: &'tcx Expr<'_>, arms: &'tcx [Arm<'_>]) {
+    if arms.len() >= 2 && cx.typeck_results().expr_ty(ex).is_integral() {
+        let ranges = all_ranges(cx, arms, cx.typeck_results().expr_ty(ex));
+        if !ranges.is_empty() {
+            if let Some((start, end)) = overlapping(&ranges) {
+                span_lint_and_note(
+                    cx,
+                    MATCH_OVERLAPPING_ARM,
+                    start.span,
+                    "some ranges overlap",
+                    Some(end.span),
+                    "overlaps with this",
+                );
+            }
+        }
+    }
+}
+
+fn check_wild_err_arm<'tcx>(cx: &LateContext<'tcx>, ex: &Expr<'tcx>, arms: &[Arm<'tcx>]) {
+    let ex_ty = cx.typeck_results().expr_ty(ex).peel_refs();
+    if is_type_diagnostic_item(cx, ex_ty, sym::Result) {
+        for arm in arms {
+            if let PatKind::TupleStruct(ref path, inner, _) = arm.pat.kind {
+                let path_str = rustc_hir_pretty::to_string(rustc_hir_pretty::NO_ANN, |s| s.print_qpath(path, false));
+                if path_str == "Err" {
+                    let mut matching_wild = inner.iter().any(is_wild);
+                    let mut ident_bind_name = kw::Underscore;
+                    if !matching_wild {
+                        // Looking for unused bindings (i.e.: `_e`)
+                        for pat in inner.iter() {
+                            if let PatKind::Binding(_, id, ident, None) = pat.kind {
+                                if ident.as_str().starts_with('_') && !is_local_used(cx, arm.body, id) {
+                                    ident_bind_name = ident.name;
+                                    matching_wild = true;
+                                }
+                            }
+                        }
+                    }
+                    if_chain! {
+                        if matching_wild;
+                        if let Some(macro_call) = root_macro_call(peel_blocks_with_stmt(arm.body).span);
+                        if is_panic(cx, macro_call.def_id);
+                        then {
+                            // `Err(_)` or `Err(_e)` arm with `panic!` found
+                            span_lint_and_note(cx,
+                                MATCH_WILD_ERR_ARM,
+                                arm.pat.span,
+                                &format!("`Err({})` matches all errors", ident_bind_name),
+                                None,
+                                "match each error separately or use the error output, or use `.except(msg)` if the error case is unreachable",
+                            );
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+enum CommonPrefixSearcher<'a> {
+    None,
+    Path(&'a [PathSegment<'a>]),
+    Mixed,
+}
+impl<'a> CommonPrefixSearcher<'a> {
+    fn with_path(&mut self, path: &'a [PathSegment<'a>]) {
+        match path {
+            [path @ .., _] => self.with_prefix(path),
+            [] => (),
+        }
+    }
+
+    fn with_prefix(&mut self, path: &'a [PathSegment<'a>]) {
+        match self {
+            Self::None => *self = Self::Path(path),
+            Self::Path(self_path)
+                if path
+                    .iter()
+                    .map(|p| p.ident.name)
+                    .eq(self_path.iter().map(|p| p.ident.name)) => {},
+            Self::Path(_) => *self = Self::Mixed,
+            Self::Mixed => (),
+        }
+    }
+}
+
+fn is_hidden(cx: &LateContext<'_>, variant_def: &VariantDef) -> bool {
+    let attrs = cx.tcx.get_attrs(variant_def.def_id);
+    clippy_utils::attrs::is_doc_hidden(attrs) || clippy_utils::attrs::is_unstable(attrs)
+}
+
+#[allow(clippy::too_many_lines)]
+fn check_wild_enum_match(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>]) {
+    let ty = cx.typeck_results().expr_ty(ex).peel_refs();
+    let adt_def = match ty.kind() {
+        ty::Adt(adt_def, _)
+            if adt_def.is_enum()
+                && !(is_type_diagnostic_item(cx, ty, sym::Option) || is_type_diagnostic_item(cx, ty, sym::Result)) =>
+        {
+            adt_def
+        },
+        _ => return,
+    };
+
+    // First pass - check for violation, but don't do much book-keeping because this is hopefully
+    // the uncommon case, and the book-keeping is slightly expensive.
+    let mut wildcard_span = None;
+    let mut wildcard_ident = None;
+    let mut has_non_wild = false;
+    for arm in arms {
+        match peel_hir_pat_refs(arm.pat).0.kind {
+            PatKind::Wild => wildcard_span = Some(arm.pat.span),
+            PatKind::Binding(_, _, ident, None) => {
+                wildcard_span = Some(arm.pat.span);
+                wildcard_ident = Some(ident);
+            },
+            _ => has_non_wild = true,
+        }
+    }
+    let wildcard_span = match wildcard_span {
+        Some(x) if has_non_wild => x,
+        _ => return,
+    };
+
+    // Accumulate the variants which should be put in place of the wildcard because they're not
+    // already covered.
+    let has_hidden = adt_def.variants.iter().any(|x| is_hidden(cx, x));
+    let mut missing_variants: Vec<_> = adt_def.variants.iter().filter(|x| !is_hidden(cx, x)).collect();
+
+    let mut path_prefix = CommonPrefixSearcher::None;
+    for arm in arms {
+        // Guards mean that this case probably isn't exhaustively covered. Technically
+        // this is incorrect, as we should really check whether each variant is exhaustively
+        // covered by the set of guards that cover it, but that's really hard to do.
+        recurse_or_patterns(arm.pat, |pat| {
+            let path = match &peel_hir_pat_refs(pat).0.kind {
+                PatKind::Path(path) => {
+                    #[allow(clippy::match_same_arms)]
+                    let id = match cx.qpath_res(path, pat.hir_id) {
+                        Res::Def(
+                            DefKind::Const | DefKind::ConstParam | DefKind::AnonConst | DefKind::InlineConst,
+                            _,
+                        ) => return,
+                        Res::Def(_, id) => id,
+                        _ => return,
+                    };
+                    if arm.guard.is_none() {
+                        missing_variants.retain(|e| e.ctor_def_id != Some(id));
+                    }
+                    path
+                },
+                PatKind::TupleStruct(path, patterns, ..) => {
+                    if let Some(id) = cx.qpath_res(path, pat.hir_id).opt_def_id() {
+                        if arm.guard.is_none() && patterns.iter().all(|p| !is_refutable(cx, p)) {
+                            missing_variants.retain(|e| e.ctor_def_id != Some(id));
+                        }
+                    }
+                    path
+                },
+                PatKind::Struct(path, patterns, ..) => {
+                    if let Some(id) = cx.qpath_res(path, pat.hir_id).opt_def_id() {
+                        if arm.guard.is_none() && patterns.iter().all(|p| !is_refutable(cx, p.pat)) {
+                            missing_variants.retain(|e| e.def_id != id);
+                        }
+                    }
+                    path
+                },
+                _ => return,
+            };
+            match path {
+                QPath::Resolved(_, path) => path_prefix.with_path(path.segments),
+                QPath::TypeRelative(
+                    hir::Ty {
+                        kind: TyKind::Path(QPath::Resolved(_, path)),
+                        ..
+                    },
+                    _,
+                ) => path_prefix.with_prefix(path.segments),
+                _ => (),
+            }
+        });
+    }
+
+    let format_suggestion = |variant: &VariantDef| {
+        format!(
+            "{}{}{}{}",
+            if let Some(ident) = wildcard_ident {
+                format!("{} @ ", ident.name)
+            } else {
+                String::new()
+            },
+            if let CommonPrefixSearcher::Path(path_prefix) = path_prefix {
+                let mut s = String::new();
+                for seg in path_prefix {
+                    s.push_str(seg.ident.as_str());
+                    s.push_str("::");
+                }
+                s
+            } else {
+                let mut s = cx.tcx.def_path_str(adt_def.did);
+                s.push_str("::");
+                s
+            },
+            variant.name,
+            match variant.ctor_kind {
+                CtorKind::Fn if variant.fields.len() == 1 => "(_)",
+                CtorKind::Fn => "(..)",
+                CtorKind::Const => "",
+                CtorKind::Fictive => "{ .. }",
+            }
+        )
+    };
+
+    match missing_variants.as_slice() {
+        [] => (),
+        [x] if !adt_def.is_variant_list_non_exhaustive() && !has_hidden => span_lint_and_sugg(
+            cx,
+            MATCH_WILDCARD_FOR_SINGLE_VARIANTS,
+            wildcard_span,
+            "wildcard matches only a single variant and will also match any future added variants",
+            "try this",
+            format_suggestion(x),
+            Applicability::MaybeIncorrect,
+        ),
+        variants => {
+            let mut suggestions: Vec<_> = variants.iter().copied().map(format_suggestion).collect();
+            let message = if adt_def.is_variant_list_non_exhaustive() || has_hidden {
+                suggestions.push("_".into());
+                "wildcard matches known variants and will also match future added variants"
+            } else {
+                "wildcard match will also match any future added variants"
+            };
+
+            span_lint_and_sugg(
+                cx,
+                WILDCARD_ENUM_MATCH_ARM,
+                wildcard_span,
+                message,
+                "try this",
+                suggestions.join(" | "),
+                Applicability::MaybeIncorrect,
+            );
+        },
+    };
+}
+
+fn check_match_ref_pats<'a, 'b, I>(cx: &LateContext<'_>, ex: &Expr<'_>, pats: I, expr: &Expr<'_>)
+where
+    'b: 'a,
+    I: Clone + Iterator<Item = &'a Pat<'b>>,
+{
+    if !has_multiple_ref_pats(pats.clone()) {
+        return;
+    }
+
+    let (first_sugg, msg, title);
+    let span = ex.span.source_callsite();
+    if let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Not, inner) = ex.kind {
+        first_sugg = once((span, Sugg::hir_with_macro_callsite(cx, inner, "..").to_string()));
+        msg = "try";
+        title = "you don't need to add `&` to both the expression and the patterns";
+    } else {
+        first_sugg = once((span, Sugg::hir_with_macro_callsite(cx, ex, "..").deref().to_string()));
+        msg = "instead of prefixing all patterns with `&`, you can dereference the expression";
+        title = "you don't need to add `&` to all patterns";
+    }
+
+    let remaining_suggs = pats.filter_map(|pat| {
+        if let PatKind::Ref(refp, _) = pat.kind {
+            Some((pat.span, snippet(cx, refp.span, "..").to_string()))
+        } else {
+            None
+        }
+    });
+
+    span_lint_and_then(cx, MATCH_REF_PATS, expr.span, title, |diag| {
+        if !expr.span.from_expansion() {
+            multispan_sugg(diag, msg, first_sugg.chain(remaining_suggs));
+        }
+    });
+}
+
+fn check_match_as_ref(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>], expr: &Expr<'_>) {
+    if arms.len() == 2 && arms[0].guard.is_none() && arms[1].guard.is_none() {
+        let arm_ref: Option<BindingAnnotation> = if is_none_arm(cx, &arms[0]) {
+            is_ref_some_arm(cx, &arms[1])
+        } else if is_none_arm(cx, &arms[1]) {
+            is_ref_some_arm(cx, &arms[0])
+        } else {
+            None
+        };
+        if let Some(rb) = arm_ref {
+            let suggestion = if rb == BindingAnnotation::Ref {
+                "as_ref"
+            } else {
+                "as_mut"
+            };
+
+            let output_ty = cx.typeck_results().expr_ty(expr);
+            let input_ty = cx.typeck_results().expr_ty(ex);
+
+            let cast = if_chain! {
+                if let ty::Adt(_, substs) = input_ty.kind();
+                let input_ty = substs.type_at(0);
+                if let ty::Adt(_, substs) = output_ty.kind();
+                let output_ty = substs.type_at(0);
+                if let ty::Ref(_, output_ty, _) = *output_ty.kind();
+                if input_ty != output_ty;
+                then {
+                    ".map(|x| x as _)"
+                } else {
+                    ""
+                }
+            };
+
+            let mut applicability = Applicability::MachineApplicable;
+            span_lint_and_sugg(
+                cx,
+                MATCH_AS_REF,
+                expr.span,
+                &format!("use `{}()` instead", suggestion),
+                "try this",
+                format!(
+                    "{}.{}(){}",
+                    snippet_with_applicability(cx, ex.span, "_", &mut applicability),
+                    suggestion,
+                    cast,
+                ),
+                applicability,
+            );
+        }
+    }
+}
+
+fn check_wild_in_or_pats(cx: &LateContext<'_>, arms: &[Arm<'_>]) {
+    for arm in arms {
+        if let PatKind::Or(fields) = arm.pat.kind {
+            // look for multiple fields in this arm that contains at least one Wild pattern
+            if fields.len() > 1 && fields.iter().any(is_wild) {
+                span_lint_and_help(
+                    cx,
+                    WILDCARD_IN_OR_PATTERNS,
+                    arm.pat.span,
+                    "wildcard pattern covers any other pattern as it will match anyway",
+                    None,
+                    "consider handling `_` separately",
+                );
+            }
+        }
+    }
+}
+
+/// Lint a `match` or `if let .. { .. } else { .. }` expr that could be replaced by `matches!`
+fn check_match_like_matches<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> bool {
+    if let Some(higher::IfLet {
+        let_pat,
+        let_expr,
+        if_then,
+        if_else: Some(if_else),
+    }) = higher::IfLet::hir(cx, expr)
+    {
+        return find_matches_sugg(
+            cx,
+            let_expr,
+            IntoIterator::into_iter([(&[][..], Some(let_pat), if_then, None), (&[][..], None, if_else, None)]),
+            expr,
+            true,
+        );
+    }
+
+    if let ExprKind::Match(scrut, arms, MatchSource::Normal) = expr.kind {
+        return find_matches_sugg(
+            cx,
+            scrut,
+            arms.iter().map(|arm| {
+                (
+                    cx.tcx.hir().attrs(arm.hir_id),
+                    Some(arm.pat),
+                    arm.body,
+                    arm.guard.as_ref(),
+                )
+            }),
+            expr,
+            false,
+        );
+    }
+
+    false
+}
+
+/// Lint a `match` or `if let` for replacement by `matches!`
+fn find_matches_sugg<'a, 'b, I>(
+    cx: &LateContext<'_>,
+    ex: &Expr<'_>,
+    mut iter: I,
+    expr: &Expr<'_>,
+    is_if_let: bool,
+) -> bool
+where
+    'b: 'a,
+    I: Clone
+        + DoubleEndedIterator
+        + ExactSizeIterator
+        + Iterator<
+            Item = (
+                &'a [Attribute],
+                Option<&'a Pat<'b>>,
+                &'a Expr<'b>,
+                Option<&'a Guard<'b>>,
+            ),
+        >,
+{
+    if_chain! {
+        if iter.len() >= 2;
+        if cx.typeck_results().expr_ty(expr).is_bool();
+        if let Some((_, last_pat_opt, last_expr, _)) = iter.next_back();
+        let iter_without_last = iter.clone();
+        if let Some((first_attrs, _, first_expr, first_guard)) = iter.next();
+        if let Some(b0) = find_bool_lit(&first_expr.kind, is_if_let);
+        if let Some(b1) = find_bool_lit(&last_expr.kind, is_if_let);
+        if b0 != b1;
+        if first_guard.is_none() || iter.len() == 0;
+        if first_attrs.is_empty();
+        if iter
+            .all(|arm| {
+                find_bool_lit(&arm.2.kind, is_if_let).map_or(false, |b| b == b0) && arm.3.is_none() && arm.0.is_empty()
+            });
+        then {
+            if let Some(last_pat) = last_pat_opt {
+                if !is_wild(last_pat) {
+                    return false;
+                }
+            }
+
+            // The suggestion may be incorrect, because some arms can have `cfg` attributes
+            // evaluated into `false` and so such arms will be stripped before.
+            let mut applicability = Applicability::MaybeIncorrect;
+            let pat = {
+                use itertools::Itertools as _;
+                iter_without_last
+                    .filter_map(|arm| {
+                        let pat_span = arm.1?.span;
+                        Some(snippet_with_applicability(cx, pat_span, "..", &mut applicability))
+                    })
+                    .join(" | ")
+            };
+            let pat_and_guard = if let Some(Guard::If(g)) = first_guard {
+                format!("{} if {}", pat, snippet_with_applicability(cx, g.span, "..", &mut applicability))
+            } else {
+                pat
+            };
+
+            // strip potential borrows (#6503), but only if the type is a reference
+            let mut ex_new = ex;
+            if let ExprKind::AddrOf(BorrowKind::Ref, .., ex_inner) = ex.kind {
+                if let ty::Ref(..) = cx.typeck_results().expr_ty(ex_inner).kind() {
+                    ex_new = ex_inner;
+                }
+            };
+            span_lint_and_sugg(
+                cx,
+                MATCH_LIKE_MATCHES_MACRO,
+                expr.span,
+                &format!("{} expression looks like `matches!` macro", if is_if_let { "if let .. else" } else { "match" }),
+                "try this",
+                format!(
+                    "{}matches!({}, {})",
+                    if b0 { "" } else { "!" },
+                    snippet_with_applicability(cx, ex_new.span, "..", &mut applicability),
+                    pat_and_guard,
+                ),
+                applicability,
+            );
+            true
+        } else {
+            false
+        }
+    }
+}
+
+/// Extract a `bool` or `{ bool }`
+fn find_bool_lit(ex: &ExprKind<'_>, is_if_let: bool) -> Option<bool> {
+    match ex {
+        ExprKind::Lit(Spanned {
+            node: LitKind::Bool(b), ..
+        }) => Some(*b),
+        ExprKind::Block(
+            rustc_hir::Block {
+                stmts: &[],
+                expr: Some(exp),
+                ..
+            },
+            _,
+        ) if is_if_let => {
+            if let ExprKind::Lit(Spanned {
+                node: LitKind::Bool(b), ..
+            }) = exp.kind
+            {
+                Some(b)
+            } else {
+                None
+            }
+        },
+        _ => None,
+    }
+}
+
+#[allow(clippy::too_many_lines)]
+fn check_match_single_binding<'a>(cx: &LateContext<'a>, ex: &Expr<'a>, arms: &[Arm<'_>], expr: &Expr<'_>) {
+    if expr.span.from_expansion() || arms.len() != 1 || is_refutable(cx, arms[0].pat) {
+        return;
+    }
+
+    // HACK:
+    // This is a hack to deal with arms that are excluded by macros like `#[cfg]`. It is only used here
+    // to prevent false positives as there is currently no better way to detect if code was excluded by
+    // a macro. See PR #6435
+    if_chain! {
+        if let Some(match_snippet) = snippet_opt(cx, expr.span);
+        if let Some(arm_snippet) = snippet_opt(cx, arms[0].span);
+        if let Some(ex_snippet) = snippet_opt(cx, ex.span);
+        let rest_snippet = match_snippet.replace(&arm_snippet, "").replace(&ex_snippet, "");
+        if rest_snippet.contains("=>");
+        then {
+            // The code it self contains another thick arrow "=>"
+            // -> Either another arm or a comment
+            return;
+        }
+    }
+
+    let matched_vars = ex.span;
+    let bind_names = arms[0].pat.span;
+    let match_body = peel_blocks(arms[0].body);
+    let mut snippet_body = if match_body.span.from_expansion() {
+        Sugg::hir_with_macro_callsite(cx, match_body, "..").to_string()
+    } else {
+        snippet_block(cx, match_body.span, "..", Some(expr.span)).to_string()
+    };
+
+    // Do we need to add ';' to suggestion ?
+    match match_body.kind {
+        ExprKind::Block(block, _) => {
+            // macro + expr_ty(body) == ()
+            if block.span.from_expansion() && cx.typeck_results().expr_ty(match_body).is_unit() {
+                snippet_body.push(';');
+            }
+        },
+        _ => {
+            // expr_ty(body) == ()
+            if cx.typeck_results().expr_ty(match_body).is_unit() {
+                snippet_body.push(';');
+            }
+        },
+    }
+
+    let mut applicability = Applicability::MaybeIncorrect;
+    match arms[0].pat.kind {
+        PatKind::Binding(..) | PatKind::Tuple(_, _) | PatKind::Struct(..) => {
+            // If this match is in a local (`let`) stmt
+            let (target_span, sugg) = if let Some(parent_let_node) = opt_parent_let(cx, ex) {
+                (
+                    parent_let_node.span,
+                    format!(
+                        "let {} = {};\n{}let {} = {};",
+                        snippet_with_applicability(cx, bind_names, "..", &mut applicability),
+                        snippet_with_applicability(cx, matched_vars, "..", &mut applicability),
+                        " ".repeat(indent_of(cx, expr.span).unwrap_or(0)),
+                        snippet_with_applicability(cx, parent_let_node.pat.span, "..", &mut applicability),
+                        snippet_body
+                    ),
+                )
+            } else {
+                // If we are in closure, we need curly braces around suggestion
+                let mut indent = " ".repeat(indent_of(cx, ex.span).unwrap_or(0));
+                let (mut cbrace_start, mut cbrace_end) = ("".to_string(), "".to_string());
+                if let Some(parent_expr) = get_parent_expr(cx, expr) {
+                    if let ExprKind::Closure(..) = parent_expr.kind {
+                        cbrace_end = format!("\n{}}}", indent);
+                        // Fix body indent due to the closure
+                        indent = " ".repeat(indent_of(cx, bind_names).unwrap_or(0));
+                        cbrace_start = format!("{{\n{}", indent);
+                    }
+                }
+                // If the parent is already an arm, and the body is another match statement,
+                // we need curly braces around suggestion
+                let parent_node_id = cx.tcx.hir().get_parent_node(expr.hir_id);
+                if let Node::Arm(arm) = &cx.tcx.hir().get(parent_node_id) {
+                    if let ExprKind::Match(..) = arm.body.kind {
+                        cbrace_end = format!("\n{}}}", indent);
+                        // Fix body indent due to the match
+                        indent = " ".repeat(indent_of(cx, bind_names).unwrap_or(0));
+                        cbrace_start = format!("{{\n{}", indent);
+                    }
+                }
+                (
+                    expr.span,
+                    format!(
+                        "{}let {} = {};\n{}{}{}",
+                        cbrace_start,
+                        snippet_with_applicability(cx, bind_names, "..", &mut applicability),
+                        snippet_with_applicability(cx, matched_vars, "..", &mut applicability),
+                        indent,
+                        snippet_body,
+                        cbrace_end
+                    ),
+                )
+            };
+            span_lint_and_sugg(
+                cx,
+                MATCH_SINGLE_BINDING,
+                target_span,
+                "this match could be written as a `let` statement",
+                "consider using `let` statement",
+                sugg,
+                applicability,
+            );
+        },
+        PatKind::Wild => {
+            if ex.can_have_side_effects() {
+                let indent = " ".repeat(indent_of(cx, expr.span).unwrap_or(0));
+                let sugg = format!(
+                    "{};\n{}{}",
+                    snippet_with_applicability(cx, ex.span, "..", &mut applicability),
+                    indent,
+                    snippet_body
+                );
+                span_lint_and_sugg(
+                    cx,
+                    MATCH_SINGLE_BINDING,
+                    expr.span,
+                    "this match could be replaced by its scrutinee and body",
+                    "consider using the scrutinee and body instead",
+                    sugg,
+                    applicability,
+                );
+            } else {
+                span_lint_and_sugg(
+                    cx,
+                    MATCH_SINGLE_BINDING,
+                    expr.span,
+                    "this match could be replaced by its body itself",
+                    "consider using the match body instead",
+                    snippet_body,
+                    Applicability::MachineApplicable,
+                );
+            }
+        },
+        _ => (),
+    }
+}
+
+/// Returns true if the `ex` match expression is in a local (`let`) statement
+fn opt_parent_let<'a>(cx: &LateContext<'a>, ex: &Expr<'a>) -> Option<&'a Local<'a>> {
+    let map = &cx.tcx.hir();
+    if_chain! {
+        if let Some(Node::Expr(parent_arm_expr)) = map.find(map.get_parent_node(ex.hir_id));
+        if let Some(Node::Local(parent_let_expr)) = map.find(map.get_parent_node(parent_arm_expr.hir_id));
+        then {
+            return Some(parent_let_expr);
+        }
+    }
+    None
+}
+
+/// Gets the ranges for each range pattern arm. Applies `ty` bounds for open ranges.
+fn all_ranges<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>], ty: Ty<'tcx>) -> Vec<SpannedRange<FullInt>> {
+    arms.iter()
+        .filter_map(|arm| {
+            if let Arm { pat, guard: None, .. } = *arm {
+                if let PatKind::Range(ref lhs, ref rhs, range_end) = pat.kind {
+                    let lhs_const = match lhs {
+                        Some(lhs) => constant(cx, cx.typeck_results(), lhs)?.0,
+                        None => miri_to_const(ty.numeric_min_val(cx.tcx)?)?,
+                    };
+                    let rhs_const = match rhs {
+                        Some(rhs) => constant(cx, cx.typeck_results(), rhs)?.0,
+                        None => miri_to_const(ty.numeric_max_val(cx.tcx)?)?,
+                    };
+
+                    let lhs_val = lhs_const.int_value(cx, ty)?;
+                    let rhs_val = rhs_const.int_value(cx, ty)?;
+
+                    let rhs_bound = match range_end {
+                        RangeEnd::Included => EndBound::Included(rhs_val),
+                        RangeEnd::Excluded => EndBound::Excluded(rhs_val),
+                    };
+                    return Some(SpannedRange {
+                        span: pat.span,
+                        node: (lhs_val, rhs_bound),
+                    });
+                }
+
+                if let PatKind::Lit(value) = pat.kind {
+                    let value = constant_full_int(cx, cx.typeck_results(), value)?;
+                    return Some(SpannedRange {
+                        span: pat.span,
+                        node: (value, EndBound::Included(value)),
+                    });
+                }
+            }
+            None
+        })
+        .collect()
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum EndBound<T> {
+    Included(T),
+    Excluded(T),
+}
+
+#[derive(Debug, Eq, PartialEq)]
+struct SpannedRange<T> {
+    pub span: Span,
+    pub node: (T, EndBound<T>),
+}
+
+// Checks if arm has the form `None => None`
+fn is_none_arm(cx: &LateContext<'_>, arm: &Arm<'_>) -> bool {
+    matches!(arm.pat.kind, PatKind::Path(ref qpath) if is_lang_ctor(cx, qpath, OptionNone))
+}
+
+// Checks if arm has the form `Some(ref v) => Some(v)` (checks for `ref` and `ref mut`)
+fn is_ref_some_arm(cx: &LateContext<'_>, arm: &Arm<'_>) -> Option<BindingAnnotation> {
+    if_chain! {
+        if let PatKind::TupleStruct(ref qpath, [first_pat, ..], _) = arm.pat.kind;
+        if is_lang_ctor(cx, qpath, OptionSome);
+        if let PatKind::Binding(rb, .., ident, _) = first_pat.kind;
+        if rb == BindingAnnotation::Ref || rb == BindingAnnotation::RefMut;
+        if let ExprKind::Call(e, args) = peel_blocks(arm.body).kind;
+        if let ExprKind::Path(ref some_path) = e.kind;
+        if is_lang_ctor(cx, some_path, OptionSome) && args.len() == 1;
+        if let ExprKind::Path(QPath::Resolved(_, path2)) = args[0].kind;
+        if path2.segments.len() == 1 && ident.name == path2.segments[0].ident.name;
+        then {
+            return Some(rb)
+        }
+    }
+    None
+}
+
+fn has_multiple_ref_pats<'a, 'b, I>(pats: I) -> bool
+where
+    'b: 'a,
+    I: Iterator<Item = &'a Pat<'b>>,
+{
+    let mut ref_count = 0;
+    for opt in pats.map(|pat| match pat.kind {
+        PatKind::Ref(..) => Some(true), // &-patterns
+        PatKind::Wild => Some(false),   // an "anything" wildcard is also fine
+        _ => None,                      // any other pattern is not fine
+    }) {
+        if let Some(inner) = opt {
+            if inner {
+                ref_count += 1;
+            }
+        } else {
+            return false;
+        }
+    }
+    ref_count > 1
+}
+
+fn overlapping<T>(ranges: &[SpannedRange<T>]) -> Option<(&SpannedRange<T>, &SpannedRange<T>)>
+where
+    T: Copy + Ord,
+{
+    #[derive(Copy, Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
+    enum BoundKind {
+        EndExcluded,
+        Start,
+        EndIncluded,
+    }
+
+    #[derive(Copy, Clone, Debug, Eq, PartialEq)]
+    struct RangeBound<'a, T>(T, BoundKind, &'a SpannedRange<T>);
+
+    impl<'a, T: Copy + Ord> PartialOrd for RangeBound<'a, T> {
+        fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+            Some(self.cmp(other))
+        }
+    }
+
+    impl<'a, T: Copy + Ord> Ord for RangeBound<'a, T> {
+        fn cmp(&self, RangeBound(other_value, other_kind, _): &Self) -> Ordering {
+            let RangeBound(self_value, self_kind, _) = *self;
+            (self_value, self_kind).cmp(&(*other_value, *other_kind))
+        }
+    }
+
+    let mut values = Vec::with_capacity(2 * ranges.len());
+
+    for r @ SpannedRange { node: (start, end), .. } in ranges {
+        values.push(RangeBound(*start, BoundKind::Start, r));
+        values.push(match end {
+            EndBound::Excluded(val) => RangeBound(*val, BoundKind::EndExcluded, r),
+            EndBound::Included(val) => RangeBound(*val, BoundKind::EndIncluded, r),
+        });
+    }
+
+    values.sort();
+
+    let mut started = vec![];
+
+    for RangeBound(_, kind, range) in values {
+        match kind {
+            BoundKind::Start => started.push(range),
+            BoundKind::EndExcluded | BoundKind::EndIncluded => {
+                let mut overlap = None;
+
+                while let Some(last_started) = started.pop() {
+                    if last_started == range {
+                        break;
+                    }
+                    overlap = Some(last_started);
+                }
+
+                if let Some(first_overlapping) = overlap {
+                    return Some((range, first_overlapping));
+                }
+            },
+        }
+    }
+
+    None
+}
+
+mod redundant_pattern_match {
+    use super::REDUNDANT_PATTERN_MATCHING;
+    use clippy_utils::diagnostics::span_lint_and_then;
+    use clippy_utils::source::snippet;
+    use clippy_utils::sugg::Sugg;
+    use clippy_utils::ty::{implements_trait, is_type_diagnostic_item, is_type_lang_item, match_type};
+    use clippy_utils::{higher, match_def_path};
+    use clippy_utils::{is_lang_ctor, is_trait_method, paths};
+    use if_chain::if_chain;
+    use rustc_ast::ast::LitKind;
+    use rustc_data_structures::fx::FxHashSet;
+    use rustc_errors::Applicability;
+    use rustc_hir::LangItem::{OptionNone, PollPending};
+    use rustc_hir::{
+        intravisit::{walk_expr, Visitor},
+        Arm, Block, Expr, ExprKind, LangItem, MatchSource, Node, Pat, PatKind, QPath, UnOp,
+    };
+    use rustc_lint::LateContext;
+    use rustc_middle::ty::{self, subst::GenericArgKind, DefIdTree, Ty};
+    use rustc_span::sym;
+
+    pub fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        if let Some(higher::IfLet {
+            if_else,
+            let_pat,
+            let_expr,
+            ..
+        }) = higher::IfLet::hir(cx, expr)
+        {
+            find_sugg_for_if_let(cx, expr, let_pat, let_expr, "if", if_else.is_some());
+        }
+        if let ExprKind::Match(op, arms, MatchSource::Normal) = &expr.kind {
+            find_sugg_for_match(cx, expr, op, arms);
+        }
+        if let Some(higher::WhileLet { let_pat, let_expr, .. }) = higher::WhileLet::hir(expr) {
+            find_sugg_for_if_let(cx, expr, let_pat, let_expr, "while", false);
+        }
+    }
+
+    /// Checks if the drop order for a type matters. Some std types implement drop solely to
+    /// deallocate memory. For these types, and composites containing them, changing the drop order
+    /// won't result in any observable side effects.
+    fn type_needs_ordered_drop<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
+        type_needs_ordered_drop_inner(cx, ty, &mut FxHashSet::default())
+    }
+
+    fn type_needs_ordered_drop_inner<'tcx>(
+        cx: &LateContext<'tcx>,
+        ty: Ty<'tcx>,
+        seen: &mut FxHashSet<Ty<'tcx>>,
+    ) -> bool {
+        if !seen.insert(ty) {
+            return false;
+        }
+        if !ty.needs_drop(cx.tcx, cx.param_env) {
+            false
+        } else if !cx
+            .tcx
+            .lang_items()
+            .drop_trait()
+            .map_or(false, |id| implements_trait(cx, ty, id, &[]))
+        {
+            // This type doesn't implement drop, so no side effects here.
+            // Check if any component type has any.
+            match ty.kind() {
+                ty::Tuple(_) => ty.tuple_fields().any(|ty| type_needs_ordered_drop_inner(cx, ty, seen)),
+                ty::Array(ty, _) => type_needs_ordered_drop_inner(cx, ty, seen),
+                ty::Adt(adt, subs) => adt
+                    .all_fields()
+                    .map(|f| f.ty(cx.tcx, subs))
+                    .any(|ty| type_needs_ordered_drop_inner(cx, ty, seen)),
+                _ => true,
+            }
+        }
+        // Check for std types which implement drop, but only for memory allocation.
+        else if is_type_diagnostic_item(cx, ty, sym::Vec)
+            || is_type_lang_item(cx, ty, LangItem::OwnedBox)
+            || is_type_diagnostic_item(cx, ty, sym::Rc)
+            || is_type_diagnostic_item(cx, ty, sym::Arc)
+            || is_type_diagnostic_item(cx, ty, sym::cstring_type)
+            || is_type_diagnostic_item(cx, ty, sym::BTreeMap)
+            || is_type_diagnostic_item(cx, ty, sym::LinkedList)
+            || match_type(cx, ty, &paths::WEAK_RC)
+            || match_type(cx, ty, &paths::WEAK_ARC)
+        {
+            // Check all of the generic arguments.
+            if let ty::Adt(_, subs) = ty.kind() {
+                subs.types().any(|ty| type_needs_ordered_drop_inner(cx, ty, seen))
+            } else {
+                true
+            }
+        } else {
+            true
+        }
+    }
+
+    // Extract the generic arguments out of a type
+    fn try_get_generic_ty(ty: Ty<'_>, index: usize) -> Option<Ty<'_>> {
+        if_chain! {
+            if let ty::Adt(_, subs) = ty.kind();
+            if let Some(sub) = subs.get(index);
+            if let GenericArgKind::Type(sub_ty) = sub.unpack();
+            then {
+                Some(sub_ty)
+            } else {
+                None
+            }
+        }
+    }
+
+    // Checks if there are any temporaries created in the given expression for which drop order
+    // matters.
+    fn temporaries_need_ordered_drop<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
+        struct V<'a, 'tcx> {
+            cx: &'a LateContext<'tcx>,
+            res: bool,
+        }
+        impl<'a, 'tcx> Visitor<'tcx> for V<'a, 'tcx> {
+            fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) {
+                match expr.kind {
+                    // Taking the reference of a value leaves a temporary
+                    // e.g. In `&String::new()` the string is a temporary value.
+                    // Remaining fields are temporary values
+                    // e.g. In `(String::new(), 0).1` the string is a temporary value.
+                    ExprKind::AddrOf(_, _, expr) | ExprKind::Field(expr, _) => {
+                        if !matches!(expr.kind, ExprKind::Path(_)) {
+                            if type_needs_ordered_drop(self.cx, self.cx.typeck_results().expr_ty(expr)) {
+                                self.res = true;
+                            } else {
+                                self.visit_expr(expr);
+                            }
+                        }
+                    },
+                    // the base type is alway taken by reference.
+                    // e.g. In `(vec![0])[0]` the vector is a temporary value.
+                    ExprKind::Index(base, index) => {
+                        if !matches!(base.kind, ExprKind::Path(_)) {
+                            if type_needs_ordered_drop(self.cx, self.cx.typeck_results().expr_ty(base)) {
+                                self.res = true;
+                            } else {
+                                self.visit_expr(base);
+                            }
+                        }
+                        self.visit_expr(index);
+                    },
+                    // Method calls can take self by reference.
+                    // e.g. In `String::new().len()` the string is a temporary value.
+                    ExprKind::MethodCall(_, [self_arg, args @ ..], _) => {
+                        if !matches!(self_arg.kind, ExprKind::Path(_)) {
+                            let self_by_ref = self
+                                .cx
+                                .typeck_results()
+                                .type_dependent_def_id(expr.hir_id)
+                                .map_or(false, |id| self.cx.tcx.fn_sig(id).skip_binder().inputs()[0].is_ref());
+                            if self_by_ref
+                                && type_needs_ordered_drop(self.cx, self.cx.typeck_results().expr_ty(self_arg))
+                            {
+                                self.res = true;
+                            } else {
+                                self.visit_expr(self_arg);
+                            }
+                        }
+                        args.iter().for_each(|arg| self.visit_expr(arg));
+                    },
+                    // Either explicitly drops values, or changes control flow.
+                    ExprKind::DropTemps(_)
+                    | ExprKind::Ret(_)
+                    | ExprKind::Break(..)
+                    | ExprKind::Yield(..)
+                    | ExprKind::Block(Block { expr: None, .. }, _)
+                    | ExprKind::Loop(..) => (),
+
+                    // Only consider the final expression.
+                    ExprKind::Block(Block { expr: Some(expr), .. }, _) => self.visit_expr(expr),
+
+                    _ => walk_expr(self, expr),
+                }
+            }
+        }
+
+        let mut v = V { cx, res: false };
+        v.visit_expr(expr);
+        v.res
+    }
+
+    fn find_sugg_for_if_let<'tcx>(
+        cx: &LateContext<'tcx>,
+        expr: &'tcx Expr<'_>,
+        let_pat: &Pat<'_>,
+        let_expr: &'tcx Expr<'_>,
+        keyword: &'static str,
+        has_else: bool,
+    ) {
+        // also look inside refs
+        // if we have &None for example, peel it so we can detect "if let None = x"
+        let check_pat = match let_pat.kind {
+            PatKind::Ref(inner, _mutability) => inner,
+            _ => let_pat,
+        };
+        let op_ty = cx.typeck_results().expr_ty(let_expr);
+        // Determine which function should be used, and the type contained by the corresponding
+        // variant.
+        let (good_method, inner_ty) = match check_pat.kind {
+            PatKind::TupleStruct(ref qpath, [sub_pat], _) => {
+                if let PatKind::Wild = sub_pat.kind {
+                    let res = cx.typeck_results().qpath_res(qpath, check_pat.hir_id);
+                    let Some(id) = res.opt_def_id().and_then(|ctor_id| cx.tcx.parent(ctor_id)) else { return };
+                    let lang_items = cx.tcx.lang_items();
+                    if Some(id) == lang_items.result_ok_variant() {
+                        ("is_ok()", try_get_generic_ty(op_ty, 0).unwrap_or(op_ty))
+                    } else if Some(id) == lang_items.result_err_variant() {
+                        ("is_err()", try_get_generic_ty(op_ty, 1).unwrap_or(op_ty))
+                    } else if Some(id) == lang_items.option_some_variant() {
+                        ("is_some()", op_ty)
+                    } else if Some(id) == lang_items.poll_ready_variant() {
+                        ("is_ready()", op_ty)
+                    } else if match_def_path(cx, id, &paths::IPADDR_V4) {
+                        ("is_ipv4()", op_ty)
+                    } else if match_def_path(cx, id, &paths::IPADDR_V6) {
+                        ("is_ipv6()", op_ty)
+                    } else {
+                        return;
+                    }
+                } else {
+                    return;
+                }
+            },
+            PatKind::Path(ref path) => {
+                let method = if is_lang_ctor(cx, path, OptionNone) {
+                    "is_none()"
+                } else if is_lang_ctor(cx, path, PollPending) {
+                    "is_pending()"
+                } else {
+                    return;
+                };
+                // `None` and `Pending` don't have an inner type.
+                (method, cx.tcx.types.unit)
+            },
+            _ => return,
+        };
+
+        // If this is the last expression in a block or there is an else clause then the whole
+        // type needs to be considered, not just the inner type of the branch being matched on.
+        // Note the last expression in a block is dropped after all local bindings.
+        let check_ty = if has_else
+            || (keyword == "if" && matches!(cx.tcx.hir().parent_iter(expr.hir_id).next(), Some((_, Node::Block(..)))))
+        {
+            op_ty
+        } else {
+            inner_ty
+        };
+
+        // All temporaries created in the scrutinee expression are dropped at the same time as the
+        // scrutinee would be, so they have to be considered as well.
+        // e.g. in `if let Some(x) = foo.lock().unwrap().baz.as_ref() { .. }` the lock will be held
+        // for the duration if body.
+        let needs_drop = type_needs_ordered_drop(cx, check_ty) || temporaries_need_ordered_drop(cx, let_expr);
+
+        // check that `while_let_on_iterator` lint does not trigger
+        if_chain! {
+            if keyword == "while";
+            if let ExprKind::MethodCall(method_path, _, _) = let_expr.kind;
+            if method_path.ident.name == sym::next;
+            if is_trait_method(cx, let_expr, sym::Iterator);
+            then {
+                return;
+            }
+        }
+
+        let result_expr = match &let_expr.kind {
+            ExprKind::AddrOf(_, _, borrowed) => borrowed,
+            ExprKind::Unary(UnOp::Deref, deref) => deref,
+            _ => let_expr,
+        };
+
+        span_lint_and_then(
+            cx,
+            REDUNDANT_PATTERN_MATCHING,
+            let_pat.span,
+            &format!("redundant pattern matching, consider using `{}`", good_method),
+            |diag| {
+                // if/while let ... = ... { ... }
+                // ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+                let expr_span = expr.span;
+
+                // if/while let ... = ... { ... }
+                //                 ^^^
+                let op_span = result_expr.span.source_callsite();
+
+                // if/while let ... = ... { ... }
+                // ^^^^^^^^^^^^^^^^^^^
+                let span = expr_span.until(op_span.shrink_to_hi());
+
+                let app = if needs_drop {
+                    Applicability::MaybeIncorrect
+                } else {
+                    Applicability::MachineApplicable
+                };
+
+                let sugg = Sugg::hir_with_macro_callsite(cx, result_expr, "_")
+                    .maybe_par()
+                    .to_string();
+
+                diag.span_suggestion(span, "try this", format!("{} {}.{}", keyword, sugg, good_method), app);
+
+                if needs_drop {
+                    diag.note("this will change drop order of the result, as well as all temporaries");
+                    diag.note("add `#[allow(clippy::redundant_pattern_matching)]` if this is important");
+                }
+            },
+        );
+    }
+
+    fn find_sugg_for_match<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, op: &Expr<'_>, arms: &[Arm<'_>]) {
+        if arms.len() == 2 {
+            let node_pair = (&arms[0].pat.kind, &arms[1].pat.kind);
+
+            let found_good_method = match node_pair {
+                (
+                    PatKind::TupleStruct(ref path_left, patterns_left, _),
+                    PatKind::TupleStruct(ref path_right, patterns_right, _),
+                ) if patterns_left.len() == 1 && patterns_right.len() == 1 => {
+                    if let (PatKind::Wild, PatKind::Wild) = (&patterns_left[0].kind, &patterns_right[0].kind) {
+                        find_good_method_for_match(
+                            cx,
+                            arms,
+                            path_left,
+                            path_right,
+                            &paths::RESULT_OK,
+                            &paths::RESULT_ERR,
+                            "is_ok()",
+                            "is_err()",
+                        )
+                        .or_else(|| {
+                            find_good_method_for_match(
+                                cx,
+                                arms,
+                                path_left,
+                                path_right,
+                                &paths::IPADDR_V4,
+                                &paths::IPADDR_V6,
+                                "is_ipv4()",
+                                "is_ipv6()",
+                            )
+                        })
+                    } else {
+                        None
+                    }
+                },
+                (PatKind::TupleStruct(ref path_left, patterns, _), PatKind::Path(ref path_right))
+                | (PatKind::Path(ref path_left), PatKind::TupleStruct(ref path_right, patterns, _))
+                    if patterns.len() == 1 =>
+                {
+                    if let PatKind::Wild = patterns[0].kind {
+                        find_good_method_for_match(
+                            cx,
+                            arms,
+                            path_left,
+                            path_right,
+                            &paths::OPTION_SOME,
+                            &paths::OPTION_NONE,
+                            "is_some()",
+                            "is_none()",
+                        )
+                        .or_else(|| {
+                            find_good_method_for_match(
+                                cx,
+                                arms,
+                                path_left,
+                                path_right,
+                                &paths::POLL_READY,
+                                &paths::POLL_PENDING,
+                                "is_ready()",
+                                "is_pending()",
+                            )
+                        })
+                    } else {
+                        None
+                    }
+                },
+                _ => None,
+            };
+
+            if let Some(good_method) = found_good_method {
+                let span = expr.span.to(op.span);
+                let result_expr = match &op.kind {
+                    ExprKind::AddrOf(_, _, borrowed) => borrowed,
+                    _ => op,
+                };
+                span_lint_and_then(
+                    cx,
+                    REDUNDANT_PATTERN_MATCHING,
+                    expr.span,
+                    &format!("redundant pattern matching, consider using `{}`", good_method),
+                    |diag| {
+                        diag.span_suggestion(
+                            span,
+                            "try this",
+                            format!("{}.{}", snippet(cx, result_expr.span, "_"), good_method),
+                            Applicability::MaybeIncorrect, // snippet
+                        );
+                    },
+                );
+            }
+        }
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn find_good_method_for_match<'a>(
+        cx: &LateContext<'_>,
+        arms: &[Arm<'_>],
+        path_left: &QPath<'_>,
+        path_right: &QPath<'_>,
+        expected_left: &[&str],
+        expected_right: &[&str],
+        should_be_left: &'a str,
+        should_be_right: &'a str,
+    ) -> Option<&'a str> {
+        let left_id = cx
+            .typeck_results()
+            .qpath_res(path_left, arms[0].pat.hir_id)
+            .opt_def_id()?;
+        let right_id = cx
+            .typeck_results()
+            .qpath_res(path_right, arms[1].pat.hir_id)
+            .opt_def_id()?;
+        let body_node_pair =
+            if match_def_path(cx, left_id, expected_left) && match_def_path(cx, right_id, expected_right) {
+                (&(*arms[0].body).kind, &(*arms[1].body).kind)
+            } else if match_def_path(cx, right_id, expected_left) && match_def_path(cx, right_id, expected_right) {
+                (&(*arms[1].body).kind, &(*arms[0].body).kind)
+            } else {
+                return None;
+            };
+
+        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)) => Some(should_be_left),
+                (LitKind::Bool(false), LitKind::Bool(true)) => Some(should_be_right),
+                _ => None,
+            },
+            _ => None,
+        }
+    }
+}
+
+#[test]
+fn test_overlapping() {
+    use rustc_span::source_map::DUMMY_SP;
+
+    let sp = |s, e| SpannedRange {
+        span: DUMMY_SP,
+        node: (s, e),
+    };
+
+    assert_eq!(None, overlapping::<u8>(&[]));
+    assert_eq!(None, overlapping(&[sp(1, EndBound::Included(4))]));
+    assert_eq!(
+        None,
+        overlapping(&[sp(1, EndBound::Included(4)), sp(5, EndBound::Included(6))])
+    );
+    assert_eq!(
+        None,
+        overlapping(&[
+            sp(1, EndBound::Included(4)),
+            sp(5, EndBound::Included(6)),
+            sp(10, EndBound::Included(11))
+        ],)
+    );
+    assert_eq!(
+        Some((&sp(1, EndBound::Included(4)), &sp(3, EndBound::Included(6)))),
+        overlapping(&[sp(1, EndBound::Included(4)), sp(3, EndBound::Included(6))])
+    );
+    assert_eq!(
+        Some((&sp(5, EndBound::Included(6)), &sp(6, EndBound::Included(11)))),
+        overlapping(&[
+            sp(1, EndBound::Included(4)),
+            sp(5, EndBound::Included(6)),
+            sp(6, EndBound::Included(11))
+        ],)
+    );
+}
+
+/// Implementation of `MATCH_SAME_ARMS`.
+fn lint_match_arms<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>) {
+    if let ExprKind::Match(_, arms, MatchSource::Normal) = expr.kind {
+        let hash = |&(_, arm): &(usize, &Arm<'_>)| -> u64 {
+            let mut h = SpanlessHash::new(cx);
+            h.hash_expr(arm.body);
+            h.finish()
+        };
+
+        let eq = |&(lindex, lhs): &(usize, &Arm<'_>), &(rindex, rhs): &(usize, &Arm<'_>)| -> bool {
+            let min_index = usize::min(lindex, rindex);
+            let max_index = usize::max(lindex, rindex);
+
+            let mut local_map: HirIdMap<HirId> = HirIdMap::default();
+            let eq_fallback = |a: &Expr<'_>, b: &Expr<'_>| {
+                if_chain! {
+                    if let Some(a_id) = path_to_local(a);
+                    if let Some(b_id) = path_to_local(b);
+                    let entry = match local_map.entry(a_id) {
+                        Entry::Vacant(entry) => entry,
+                        // check if using the same bindings as before
+                        Entry::Occupied(entry) => return *entry.get() == b_id,
+                    };
+                    // the names technically don't have to match; this makes the lint more conservative
+                    if cx.tcx.hir().name(a_id) == cx.tcx.hir().name(b_id);
+                    if TyS::same_type(cx.typeck_results().expr_ty(a), cx.typeck_results().expr_ty(b));
+                    if pat_contains_local(lhs.pat, a_id);
+                    if pat_contains_local(rhs.pat, b_id);
+                    then {
+                        entry.insert(b_id);
+                        true
+                    } else {
+                        false
+                    }
+                }
+            };
+            // Arms with a guard are ignored, those can’t always be merged together
+            // This is also the case for arms in-between each there is an arm with a guard
+            (min_index..=max_index).all(|index| arms[index].guard.is_none())
+                && SpanlessEq::new(cx)
+                    .expr_fallback(eq_fallback)
+                    .eq_expr(lhs.body, rhs.body)
+                // these checks could be removed to allow unused bindings
+                && bindings_eq(lhs.pat, local_map.keys().copied().collect())
+                && bindings_eq(rhs.pat, local_map.values().copied().collect())
+        };
+
+        let indexed_arms: Vec<(usize, &Arm<'_>)> = arms.iter().enumerate().collect();
+        for (&(_, i), &(_, j)) in search_same(&indexed_arms, hash, eq) {
+            span_lint_and_then(
+                cx,
+                MATCH_SAME_ARMS,
+                j.body.span,
+                "this `match` has identical arm bodies",
+                |diag| {
+                    diag.span_note(i.body.span, "same as this");
+
+                    // Note: this does not use `span_suggestion` on purpose:
+                    // there is no clean way
+                    // to remove the other arm. Building a span and suggest to replace it to ""
+                    // makes an even more confusing error message. Also in order not to make up a
+                    // span for the whole pattern, the suggestion is only shown when there is only
+                    // one pattern. The user should know about `|` if they are already using it…
+
+                    let lhs = snippet(cx, i.pat.span, "<pat1>");
+                    let rhs = snippet(cx, j.pat.span, "<pat2>");
+
+                    if let PatKind::Wild = j.pat.kind {
+                        // if the last arm is _, then i could be integrated into _
+                        // note that i.pat cannot be _, because that would mean that we're
+                        // hiding all the subsequent arms, and rust won't compile
+                        diag.span_note(
+                            i.body.span,
+                            &format!(
+                                "`{}` has the same arm body as the `_` wildcard, consider removing it",
+                                lhs
+                            ),
+                        );
+                    } else {
+                        diag.span_help(i.pat.span, &format!("consider refactoring into `{} | {}`", lhs, rhs,))
+                            .help("...or consider changing the match arm bodies");
+                    }
+                },
+            );
+        }
+    }
+}
+
+fn pat_contains_local(pat: &Pat<'_>, id: HirId) -> bool {
+    let mut result = false;
+    pat.walk_short(|p| {
+        result |= matches!(p.kind, PatKind::Binding(_, binding_id, ..) if binding_id == id);
+        !result
+    });
+    result
+}
+
+/// Returns true if all the bindings in the `Pat` are in `ids` and vice versa
+fn bindings_eq(pat: &Pat<'_>, mut ids: HirIdSet) -> bool {
+    let mut result = true;
+    pat.each_binding_or_first(&mut |_, id, _, _| result &= ids.remove(&id));
+    result && ids.is_empty()
+}
-- 
cgit 1.4.1-3-g733a5


From e41a6fc042cdd40f415eba4288d5c5e1161266b1 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sun, 6 Feb 2022 13:42:17 -0500
Subject: Split out `match_like_matches_macro`

---
 clippy_lints/src/matches/match_like_matches.rs | 166 ++++++++++++++++++++++++
 clippy_lints/src/matches/mod.rs                | 172 ++-----------------------
 2 files changed, 175 insertions(+), 163 deletions(-)
 create mode 100644 clippy_lints/src/matches/match_like_matches.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/match_like_matches.rs b/clippy_lints/src/matches/match_like_matches.rs
new file mode 100644
index 00000000000..d605b6d73c0
--- /dev/null
+++ b/clippy_lints/src/matches/match_like_matches.rs
@@ -0,0 +1,166 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::{higher, is_wild};
+use rustc_ast::{Attribute, LitKind};
+use rustc_errors::Applicability;
+use rustc_hir::{BorrowKind, Expr, ExprKind, Guard, MatchSource, Pat};
+use rustc_lint::LateContext;
+use rustc_middle::ty;
+use rustc_span::source_map::Spanned;
+
+use super::MATCH_LIKE_MATCHES_MACRO;
+
+/// Lint a `match` or `if let .. { .. } else { .. }` expr that could be replaced by `matches!`
+pub(crate) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> bool {
+    if let Some(higher::IfLet {
+        let_pat,
+        let_expr,
+        if_then,
+        if_else: Some(if_else),
+    }) = higher::IfLet::hir(cx, expr)
+    {
+        return find_matches_sugg(
+            cx,
+            let_expr,
+            IntoIterator::into_iter([(&[][..], Some(let_pat), if_then, None), (&[][..], None, if_else, None)]),
+            expr,
+            true,
+        );
+    }
+
+    if let ExprKind::Match(scrut, arms, MatchSource::Normal) = expr.kind {
+        return find_matches_sugg(
+            cx,
+            scrut,
+            arms.iter().map(|arm| {
+                (
+                    cx.tcx.hir().attrs(arm.hir_id),
+                    Some(arm.pat),
+                    arm.body,
+                    arm.guard.as_ref(),
+                )
+            }),
+            expr,
+            false,
+        );
+    }
+
+    false
+}
+
+/// Lint a `match` or `if let` for replacement by `matches!`
+fn find_matches_sugg<'a, 'b, I>(
+    cx: &LateContext<'_>,
+    ex: &Expr<'_>,
+    mut iter: I,
+    expr: &Expr<'_>,
+    is_if_let: bool,
+) -> bool
+where
+    'b: 'a,
+    I: Clone
+        + DoubleEndedIterator
+        + ExactSizeIterator
+        + Iterator<
+            Item = (
+                &'a [Attribute],
+                Option<&'a Pat<'b>>,
+                &'a Expr<'b>,
+                Option<&'a Guard<'b>>,
+            ),
+        >,
+{
+    if_chain! {
+        if iter.len() >= 2;
+        if cx.typeck_results().expr_ty(expr).is_bool();
+        if let Some((_, last_pat_opt, last_expr, _)) = iter.next_back();
+        let iter_without_last = iter.clone();
+        if let Some((first_attrs, _, first_expr, first_guard)) = iter.next();
+        if let Some(b0) = find_bool_lit(&first_expr.kind, is_if_let);
+        if let Some(b1) = find_bool_lit(&last_expr.kind, is_if_let);
+        if b0 != b1;
+        if first_guard.is_none() || iter.len() == 0;
+        if first_attrs.is_empty();
+        if iter
+            .all(|arm| {
+                find_bool_lit(&arm.2.kind, is_if_let).map_or(false, |b| b == b0) && arm.3.is_none() && arm.0.is_empty()
+            });
+        then {
+            if let Some(last_pat) = last_pat_opt {
+                if !is_wild(last_pat) {
+                    return false;
+                }
+            }
+
+            // The suggestion may be incorrect, because some arms can have `cfg` attributes
+            // evaluated into `false` and so such arms will be stripped before.
+            let mut applicability = Applicability::MaybeIncorrect;
+            let pat = {
+                use itertools::Itertools as _;
+                iter_without_last
+                    .filter_map(|arm| {
+                        let pat_span = arm.1?.span;
+                        Some(snippet_with_applicability(cx, pat_span, "..", &mut applicability))
+                    })
+                    .join(" | ")
+            };
+            let pat_and_guard = if let Some(Guard::If(g)) = first_guard {
+                format!("{} if {}", pat, snippet_with_applicability(cx, g.span, "..", &mut applicability))
+            } else {
+                pat
+            };
+
+            // strip potential borrows (#6503), but only if the type is a reference
+            let mut ex_new = ex;
+            if let ExprKind::AddrOf(BorrowKind::Ref, .., ex_inner) = ex.kind {
+                if let ty::Ref(..) = cx.typeck_results().expr_ty(ex_inner).kind() {
+                    ex_new = ex_inner;
+                }
+            };
+            span_lint_and_sugg(
+                cx,
+                MATCH_LIKE_MATCHES_MACRO,
+                expr.span,
+                &format!("{} expression looks like `matches!` macro", if is_if_let { "if let .. else" } else { "match" }),
+                "try this",
+                format!(
+                    "{}matches!({}, {})",
+                    if b0 { "" } else { "!" },
+                    snippet_with_applicability(cx, ex_new.span, "..", &mut applicability),
+                    pat_and_guard,
+                ),
+                applicability,
+            );
+            true
+        } else {
+            false
+        }
+    }
+}
+
+/// Extract a `bool` or `{ bool }`
+fn find_bool_lit(ex: &ExprKind<'_>, is_if_let: bool) -> Option<bool> {
+    match ex {
+        ExprKind::Lit(Spanned {
+            node: LitKind::Bool(b), ..
+        }) => Some(*b),
+        ExprKind::Block(
+            rustc_hir::Block {
+                stmts: &[],
+                expr: Some(exp),
+                ..
+            },
+            _,
+        ) if is_if_let => {
+            if let ExprKind::Lit(Spanned {
+                node: LitKind::Bool(b), ..
+            }) = exp.kind
+            {
+                Some(b)
+            } else {
+                None
+            }
+        },
+        _ => None,
+    }
+}
diff --git a/clippy_lints/src/matches/mod.rs b/clippy_lints/src/matches/mod.rs
index 67fb918d20c..ff07fc6d4d4 100644
--- a/clippy_lints/src/matches/mod.rs
+++ b/clippy_lints/src/matches/mod.rs
@@ -3,6 +3,7 @@ use clippy_utils::diagnostics::{
     multispan_sugg, span_lint_and_help, span_lint_and_note, span_lint_and_sugg, span_lint_and_then,
 };
 use clippy_utils::macros::{is_panic, root_macro_call};
+use clippy_utils::peel_blocks_with_stmt;
 use clippy_utils::source::{expr_block, indent_of, snippet, snippet_block, snippet_opt, snippet_with_applicability};
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::{implements_trait, is_type_diagnostic_item, match_type, peel_mid_ty_refs};
@@ -12,28 +13,28 @@ use clippy_utils::{
     path_to_local, path_to_local_id, peel_blocks, peel_hir_pat_refs, peel_n_hir_expr_refs, recurse_or_patterns,
     strip_pat_refs,
 };
-use clippy_utils::{higher, peel_blocks_with_stmt};
 use clippy_utils::{paths, search_same, SpanlessEq, SpanlessHash};
-use core::iter::{once, ExactSizeIterator};
+use core::iter::once;
 use if_chain::if_chain;
-use rustc_ast::ast::{Attribute, LitKind};
+use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::def::{CtorKind, DefKind, Res};
 use rustc_hir::LangItem::{OptionNone, OptionSome};
 use rustc_hir::{
-    self as hir, Arm, BindingAnnotation, Block, BorrowKind, Expr, ExprKind, Guard, HirId, Local, MatchSource,
-    Mutability, Node, Pat, PatKind, PathSegment, QPath, RangeEnd, TyKind,
+    self as hir, Arm, BindingAnnotation, Block, BorrowKind, Expr, ExprKind, HirId, Local, MatchSource, Mutability,
+    Node, Pat, PatKind, PathSegment, QPath, RangeEnd, TyKind,
 };
 use rustc_hir::{HirIdMap, HirIdSet};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{self, Ty, TyS, VariantDef};
 use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::source_map::{Span, Spanned};
-use rustc_span::{sym, symbol::kw};
+use rustc_span::{sym, symbol::kw, Span};
 use std::cmp::{max, Ordering};
 use std::collections::hash_map::Entry;
 
+mod match_like_matches;
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for matches with a single arm where an `if let`
@@ -622,7 +623,7 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
         redundant_pattern_match::check(cx, expr);
 
         if meets_msrv(self.msrv.as_ref(), &msrvs::MATCHES_MACRO) {
-            if !check_match_like_matches(cx, expr) {
+            if !match_like_matches::check(cx, expr) {
                 lint_match_arms(cx, expr);
             }
         } else {
@@ -1382,161 +1383,6 @@ fn check_wild_in_or_pats(cx: &LateContext<'_>, arms: &[Arm<'_>]) {
     }
 }
 
-/// Lint a `match` or `if let .. { .. } else { .. }` expr that could be replaced by `matches!`
-fn check_match_like_matches<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> bool {
-    if let Some(higher::IfLet {
-        let_pat,
-        let_expr,
-        if_then,
-        if_else: Some(if_else),
-    }) = higher::IfLet::hir(cx, expr)
-    {
-        return find_matches_sugg(
-            cx,
-            let_expr,
-            IntoIterator::into_iter([(&[][..], Some(let_pat), if_then, None), (&[][..], None, if_else, None)]),
-            expr,
-            true,
-        );
-    }
-
-    if let ExprKind::Match(scrut, arms, MatchSource::Normal) = expr.kind {
-        return find_matches_sugg(
-            cx,
-            scrut,
-            arms.iter().map(|arm| {
-                (
-                    cx.tcx.hir().attrs(arm.hir_id),
-                    Some(arm.pat),
-                    arm.body,
-                    arm.guard.as_ref(),
-                )
-            }),
-            expr,
-            false,
-        );
-    }
-
-    false
-}
-
-/// Lint a `match` or `if let` for replacement by `matches!`
-fn find_matches_sugg<'a, 'b, I>(
-    cx: &LateContext<'_>,
-    ex: &Expr<'_>,
-    mut iter: I,
-    expr: &Expr<'_>,
-    is_if_let: bool,
-) -> bool
-where
-    'b: 'a,
-    I: Clone
-        + DoubleEndedIterator
-        + ExactSizeIterator
-        + Iterator<
-            Item = (
-                &'a [Attribute],
-                Option<&'a Pat<'b>>,
-                &'a Expr<'b>,
-                Option<&'a Guard<'b>>,
-            ),
-        >,
-{
-    if_chain! {
-        if iter.len() >= 2;
-        if cx.typeck_results().expr_ty(expr).is_bool();
-        if let Some((_, last_pat_opt, last_expr, _)) = iter.next_back();
-        let iter_without_last = iter.clone();
-        if let Some((first_attrs, _, first_expr, first_guard)) = iter.next();
-        if let Some(b0) = find_bool_lit(&first_expr.kind, is_if_let);
-        if let Some(b1) = find_bool_lit(&last_expr.kind, is_if_let);
-        if b0 != b1;
-        if first_guard.is_none() || iter.len() == 0;
-        if first_attrs.is_empty();
-        if iter
-            .all(|arm| {
-                find_bool_lit(&arm.2.kind, is_if_let).map_or(false, |b| b == b0) && arm.3.is_none() && arm.0.is_empty()
-            });
-        then {
-            if let Some(last_pat) = last_pat_opt {
-                if !is_wild(last_pat) {
-                    return false;
-                }
-            }
-
-            // The suggestion may be incorrect, because some arms can have `cfg` attributes
-            // evaluated into `false` and so such arms will be stripped before.
-            let mut applicability = Applicability::MaybeIncorrect;
-            let pat = {
-                use itertools::Itertools as _;
-                iter_without_last
-                    .filter_map(|arm| {
-                        let pat_span = arm.1?.span;
-                        Some(snippet_with_applicability(cx, pat_span, "..", &mut applicability))
-                    })
-                    .join(" | ")
-            };
-            let pat_and_guard = if let Some(Guard::If(g)) = first_guard {
-                format!("{} if {}", pat, snippet_with_applicability(cx, g.span, "..", &mut applicability))
-            } else {
-                pat
-            };
-
-            // strip potential borrows (#6503), but only if the type is a reference
-            let mut ex_new = ex;
-            if let ExprKind::AddrOf(BorrowKind::Ref, .., ex_inner) = ex.kind {
-                if let ty::Ref(..) = cx.typeck_results().expr_ty(ex_inner).kind() {
-                    ex_new = ex_inner;
-                }
-            };
-            span_lint_and_sugg(
-                cx,
-                MATCH_LIKE_MATCHES_MACRO,
-                expr.span,
-                &format!("{} expression looks like `matches!` macro", if is_if_let { "if let .. else" } else { "match" }),
-                "try this",
-                format!(
-                    "{}matches!({}, {})",
-                    if b0 { "" } else { "!" },
-                    snippet_with_applicability(cx, ex_new.span, "..", &mut applicability),
-                    pat_and_guard,
-                ),
-                applicability,
-            );
-            true
-        } else {
-            false
-        }
-    }
-}
-
-/// Extract a `bool` or `{ bool }`
-fn find_bool_lit(ex: &ExprKind<'_>, is_if_let: bool) -> Option<bool> {
-    match ex {
-        ExprKind::Lit(Spanned {
-            node: LitKind::Bool(b), ..
-        }) => Some(*b),
-        ExprKind::Block(
-            rustc_hir::Block {
-                stmts: &[],
-                expr: Some(exp),
-                ..
-            },
-            _,
-        ) if is_if_let => {
-            if let ExprKind::Lit(Spanned {
-                node: LitKind::Bool(b), ..
-            }) = exp.kind
-            {
-                Some(b)
-            } else {
-                None
-            }
-        },
-        _ => None,
-    }
-}
-
 #[allow(clippy::too_many_lines)]
 fn check_match_single_binding<'a>(cx: &LateContext<'a>, ex: &Expr<'a>, arms: &[Arm<'_>], expr: &Expr<'_>) {
     if expr.span.from_expansion() || arms.len() != 1 || is_refutable(cx, arms[0].pat) {
-- 
cgit 1.4.1-3-g733a5


From 64548250e7c740d0376d638214df65fb2ace35f1 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sun, 6 Feb 2022 13:53:51 -0500
Subject: Split out `match_same_arms`

---
 clippy_lints/src/matches/match_same_arms.rs | 112 ++++++++++++++++++++++++++
 clippy_lints/src/matches/mod.rs             | 120 ++--------------------------
 2 files changed, 119 insertions(+), 113 deletions(-)
 create mode 100644 clippy_lints/src/matches/match_same_arms.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/match_same_arms.rs b/clippy_lints/src/matches/match_same_arms.rs
new file mode 100644
index 00000000000..7efbd540fdb
--- /dev/null
+++ b/clippy_lints/src/matches/match_same_arms.rs
@@ -0,0 +1,112 @@
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::source::snippet;
+use clippy_utils::{path_to_local, search_same, SpanlessEq, SpanlessHash};
+use rustc_hir::{Arm, Expr, ExprKind, HirId, HirIdMap, HirIdSet, MatchSource, Pat, PatKind};
+use rustc_lint::LateContext;
+use rustc_middle::ty::TyS;
+use std::collections::hash_map::Entry;
+
+use super::MATCH_SAME_ARMS;
+
+pub(crate) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>) {
+    if let ExprKind::Match(_, arms, MatchSource::Normal) = expr.kind {
+        let hash = |&(_, arm): &(usize, &Arm<'_>)| -> u64 {
+            let mut h = SpanlessHash::new(cx);
+            h.hash_expr(arm.body);
+            h.finish()
+        };
+
+        let eq = |&(lindex, lhs): &(usize, &Arm<'_>), &(rindex, rhs): &(usize, &Arm<'_>)| -> bool {
+            let min_index = usize::min(lindex, rindex);
+            let max_index = usize::max(lindex, rindex);
+
+            let mut local_map: HirIdMap<HirId> = HirIdMap::default();
+            let eq_fallback = |a: &Expr<'_>, b: &Expr<'_>| {
+                if_chain! {
+                    if let Some(a_id) = path_to_local(a);
+                    if let Some(b_id) = path_to_local(b);
+                    let entry = match local_map.entry(a_id) {
+                        Entry::Vacant(entry) => entry,
+                        // check if using the same bindings as before
+                        Entry::Occupied(entry) => return *entry.get() == b_id,
+                    };
+                    // the names technically don't have to match; this makes the lint more conservative
+                    if cx.tcx.hir().name(a_id) == cx.tcx.hir().name(b_id);
+                    if TyS::same_type(cx.typeck_results().expr_ty(a), cx.typeck_results().expr_ty(b));
+                    if pat_contains_local(lhs.pat, a_id);
+                    if pat_contains_local(rhs.pat, b_id);
+                    then {
+                        entry.insert(b_id);
+                        true
+                    } else {
+                        false
+                    }
+                }
+            };
+            // Arms with a guard are ignored, those can’t always be merged together
+            // This is also the case for arms in-between each there is an arm with a guard
+            (min_index..=max_index).all(|index| arms[index].guard.is_none())
+                && SpanlessEq::new(cx)
+                    .expr_fallback(eq_fallback)
+                    .eq_expr(lhs.body, rhs.body)
+                // these checks could be removed to allow unused bindings
+                && bindings_eq(lhs.pat, local_map.keys().copied().collect())
+                && bindings_eq(rhs.pat, local_map.values().copied().collect())
+        };
+
+        let indexed_arms: Vec<(usize, &Arm<'_>)> = arms.iter().enumerate().collect();
+        for (&(_, i), &(_, j)) in search_same(&indexed_arms, hash, eq) {
+            span_lint_and_then(
+                cx,
+                MATCH_SAME_ARMS,
+                j.body.span,
+                "this `match` has identical arm bodies",
+                |diag| {
+                    diag.span_note(i.body.span, "same as this");
+
+                    // Note: this does not use `span_suggestion` on purpose:
+                    // there is no clean way
+                    // to remove the other arm. Building a span and suggest to replace it to ""
+                    // makes an even more confusing error message. Also in order not to make up a
+                    // span for the whole pattern, the suggestion is only shown when there is only
+                    // one pattern. The user should know about `|` if they are already using it…
+
+                    let lhs = snippet(cx, i.pat.span, "<pat1>");
+                    let rhs = snippet(cx, j.pat.span, "<pat2>");
+
+                    if let PatKind::Wild = j.pat.kind {
+                        // if the last arm is _, then i could be integrated into _
+                        // note that i.pat cannot be _, because that would mean that we're
+                        // hiding all the subsequent arms, and rust won't compile
+                        diag.span_note(
+                            i.body.span,
+                            &format!(
+                                "`{}` has the same arm body as the `_` wildcard, consider removing it",
+                                lhs
+                            ),
+                        );
+                    } else {
+                        diag.span_help(i.pat.span, &format!("consider refactoring into `{} | {}`", lhs, rhs,))
+                            .help("...or consider changing the match arm bodies");
+                    }
+                },
+            );
+        }
+    }
+}
+
+fn pat_contains_local(pat: &Pat<'_>, id: HirId) -> bool {
+    let mut result = false;
+    pat.walk_short(|p| {
+        result |= matches!(p.kind, PatKind::Binding(_, binding_id, ..) if binding_id == id);
+        !result
+    });
+    result
+}
+
+/// Returns true if all the bindings in the `Pat` are in `ids` and vice versa
+fn bindings_eq(pat: &Pat<'_>, mut ids: HirIdSet) -> bool {
+    let mut result = true;
+    pat.each_binding_or_first(&mut |_, id, _, _| result &= ids.remove(&id));
+    result && ids.is_empty()
+}
diff --git a/clippy_lints/src/matches/mod.rs b/clippy_lints/src/matches/mod.rs
index ff07fc6d4d4..529f759ba0e 100644
--- a/clippy_lints/src/matches/mod.rs
+++ b/clippy_lints/src/matches/mod.rs
@@ -3,6 +3,7 @@ use clippy_utils::diagnostics::{
     multispan_sugg, span_lint_and_help, span_lint_and_note, span_lint_and_sugg, span_lint_and_then,
 };
 use clippy_utils::macros::{is_panic, root_macro_call};
+use clippy_utils::paths;
 use clippy_utils::peel_blocks_with_stmt;
 use clippy_utils::source::{expr_block, indent_of, snippet, snippet_block, snippet_opt, snippet_with_applicability};
 use clippy_utils::sugg::Sugg;
@@ -10,10 +11,8 @@ use clippy_utils::ty::{implements_trait, is_type_diagnostic_item, match_type, pe
 use clippy_utils::visitors::is_local_used;
 use clippy_utils::{
     get_parent_expr, is_lang_ctor, is_lint_allowed, is_refutable, is_unit_expr, is_wild, meets_msrv, msrvs,
-    path_to_local, path_to_local_id, peel_blocks, peel_hir_pat_refs, peel_n_hir_expr_refs, recurse_or_patterns,
-    strip_pat_refs,
+    path_to_local_id, peel_blocks, peel_hir_pat_refs, peel_n_hir_expr_refs, recurse_or_patterns, strip_pat_refs,
 };
-use clippy_utils::{paths, search_same, SpanlessEq, SpanlessHash};
 use core::iter::once;
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
@@ -21,19 +20,18 @@ use rustc_errors::Applicability;
 use rustc_hir::def::{CtorKind, DefKind, Res};
 use rustc_hir::LangItem::{OptionNone, OptionSome};
 use rustc_hir::{
-    self as hir, Arm, BindingAnnotation, Block, BorrowKind, Expr, ExprKind, HirId, Local, MatchSource, Mutability,
-    Node, Pat, PatKind, PathSegment, QPath, RangeEnd, TyKind,
+    self as hir, Arm, BindingAnnotation, Block, BorrowKind, Expr, ExprKind, Local, MatchSource, Mutability, Node, Pat,
+    PatKind, PathSegment, QPath, RangeEnd, TyKind,
 };
-use rustc_hir::{HirIdMap, HirIdSet};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{self, Ty, TyS, VariantDef};
 use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::{sym, symbol::kw, Span};
 use std::cmp::{max, Ordering};
-use std::collections::hash_map::Entry;
 
 mod match_like_matches;
+mod match_same_arms;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -624,10 +622,10 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
 
         if meets_msrv(self.msrv.as_ref(), &msrvs::MATCHES_MACRO) {
             if !match_like_matches::check(cx, expr) {
-                lint_match_arms(cx, expr);
+                match_same_arms::check(cx, expr);
             }
         } else {
-            lint_match_arms(cx, expr);
+            match_same_arms::check(cx, expr);
         }
 
         if let ExprKind::Match(ex, arms, MatchSource::Normal) = expr.kind {
@@ -2185,107 +2183,3 @@ fn test_overlapping() {
         ],)
     );
 }
-
-/// Implementation of `MATCH_SAME_ARMS`.
-fn lint_match_arms<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>) {
-    if let ExprKind::Match(_, arms, MatchSource::Normal) = expr.kind {
-        let hash = |&(_, arm): &(usize, &Arm<'_>)| -> u64 {
-            let mut h = SpanlessHash::new(cx);
-            h.hash_expr(arm.body);
-            h.finish()
-        };
-
-        let eq = |&(lindex, lhs): &(usize, &Arm<'_>), &(rindex, rhs): &(usize, &Arm<'_>)| -> bool {
-            let min_index = usize::min(lindex, rindex);
-            let max_index = usize::max(lindex, rindex);
-
-            let mut local_map: HirIdMap<HirId> = HirIdMap::default();
-            let eq_fallback = |a: &Expr<'_>, b: &Expr<'_>| {
-                if_chain! {
-                    if let Some(a_id) = path_to_local(a);
-                    if let Some(b_id) = path_to_local(b);
-                    let entry = match local_map.entry(a_id) {
-                        Entry::Vacant(entry) => entry,
-                        // check if using the same bindings as before
-                        Entry::Occupied(entry) => return *entry.get() == b_id,
-                    };
-                    // the names technically don't have to match; this makes the lint more conservative
-                    if cx.tcx.hir().name(a_id) == cx.tcx.hir().name(b_id);
-                    if TyS::same_type(cx.typeck_results().expr_ty(a), cx.typeck_results().expr_ty(b));
-                    if pat_contains_local(lhs.pat, a_id);
-                    if pat_contains_local(rhs.pat, b_id);
-                    then {
-                        entry.insert(b_id);
-                        true
-                    } else {
-                        false
-                    }
-                }
-            };
-            // Arms with a guard are ignored, those can’t always be merged together
-            // This is also the case for arms in-between each there is an arm with a guard
-            (min_index..=max_index).all(|index| arms[index].guard.is_none())
-                && SpanlessEq::new(cx)
-                    .expr_fallback(eq_fallback)
-                    .eq_expr(lhs.body, rhs.body)
-                // these checks could be removed to allow unused bindings
-                && bindings_eq(lhs.pat, local_map.keys().copied().collect())
-                && bindings_eq(rhs.pat, local_map.values().copied().collect())
-        };
-
-        let indexed_arms: Vec<(usize, &Arm<'_>)> = arms.iter().enumerate().collect();
-        for (&(_, i), &(_, j)) in search_same(&indexed_arms, hash, eq) {
-            span_lint_and_then(
-                cx,
-                MATCH_SAME_ARMS,
-                j.body.span,
-                "this `match` has identical arm bodies",
-                |diag| {
-                    diag.span_note(i.body.span, "same as this");
-
-                    // Note: this does not use `span_suggestion` on purpose:
-                    // there is no clean way
-                    // to remove the other arm. Building a span and suggest to replace it to ""
-                    // makes an even more confusing error message. Also in order not to make up a
-                    // span for the whole pattern, the suggestion is only shown when there is only
-                    // one pattern. The user should know about `|` if they are already using it…
-
-                    let lhs = snippet(cx, i.pat.span, "<pat1>");
-                    let rhs = snippet(cx, j.pat.span, "<pat2>");
-
-                    if let PatKind::Wild = j.pat.kind {
-                        // if the last arm is _, then i could be integrated into _
-                        // note that i.pat cannot be _, because that would mean that we're
-                        // hiding all the subsequent arms, and rust won't compile
-                        diag.span_note(
-                            i.body.span,
-                            &format!(
-                                "`{}` has the same arm body as the `_` wildcard, consider removing it",
-                                lhs
-                            ),
-                        );
-                    } else {
-                        diag.span_help(i.pat.span, &format!("consider refactoring into `{} | {}`", lhs, rhs,))
-                            .help("...or consider changing the match arm bodies");
-                    }
-                },
-            );
-        }
-    }
-}
-
-fn pat_contains_local(pat: &Pat<'_>, id: HirId) -> bool {
-    let mut result = false;
-    pat.walk_short(|p| {
-        result |= matches!(p.kind, PatKind::Binding(_, binding_id, ..) if binding_id == id);
-        !result
-    });
-    result
-}
-
-/// Returns true if all the bindings in the `Pat` are in `ids` and vice versa
-fn bindings_eq(pat: &Pat<'_>, mut ids: HirIdSet) -> bool {
-    let mut result = true;
-    pat.each_binding_or_first(&mut |_, id, _, _| result &= ids.remove(&id));
-    result && ids.is_empty()
-}
-- 
cgit 1.4.1-3-g733a5


From f2b6ed7cb243b482803e23494a56f9d7ddc19453 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sun, 6 Feb 2022 14:03:45 -0500
Subject: Split out `redundant_pattern_match`

---
 clippy_lints/src/matches/mod.rs                    | 447 +--------------------
 .../src/matches/redundant_pattern_match.rs         | 436 ++++++++++++++++++++
 2 files changed, 437 insertions(+), 446 deletions(-)
 create mode 100644 clippy_lints/src/matches/redundant_pattern_match.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/mod.rs b/clippy_lints/src/matches/mod.rs
index 529f759ba0e..4b09bdb98ec 100644
--- a/clippy_lints/src/matches/mod.rs
+++ b/clippy_lints/src/matches/mod.rs
@@ -32,6 +32,7 @@ use std::cmp::{max, Ordering};
 
 mod match_like_matches;
 mod match_same_arms;
+mod redundant_pattern_match;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -1701,452 +1702,6 @@ where
     None
 }
 
-mod redundant_pattern_match {
-    use super::REDUNDANT_PATTERN_MATCHING;
-    use clippy_utils::diagnostics::span_lint_and_then;
-    use clippy_utils::source::snippet;
-    use clippy_utils::sugg::Sugg;
-    use clippy_utils::ty::{implements_trait, is_type_diagnostic_item, is_type_lang_item, match_type};
-    use clippy_utils::{higher, match_def_path};
-    use clippy_utils::{is_lang_ctor, is_trait_method, paths};
-    use if_chain::if_chain;
-    use rustc_ast::ast::LitKind;
-    use rustc_data_structures::fx::FxHashSet;
-    use rustc_errors::Applicability;
-    use rustc_hir::LangItem::{OptionNone, PollPending};
-    use rustc_hir::{
-        intravisit::{walk_expr, Visitor},
-        Arm, Block, Expr, ExprKind, LangItem, MatchSource, Node, Pat, PatKind, QPath, UnOp,
-    };
-    use rustc_lint::LateContext;
-    use rustc_middle::ty::{self, subst::GenericArgKind, DefIdTree, Ty};
-    use rustc_span::sym;
-
-    pub fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if let Some(higher::IfLet {
-            if_else,
-            let_pat,
-            let_expr,
-            ..
-        }) = higher::IfLet::hir(cx, expr)
-        {
-            find_sugg_for_if_let(cx, expr, let_pat, let_expr, "if", if_else.is_some());
-        }
-        if let ExprKind::Match(op, arms, MatchSource::Normal) = &expr.kind {
-            find_sugg_for_match(cx, expr, op, arms);
-        }
-        if let Some(higher::WhileLet { let_pat, let_expr, .. }) = higher::WhileLet::hir(expr) {
-            find_sugg_for_if_let(cx, expr, let_pat, let_expr, "while", false);
-        }
-    }
-
-    /// Checks if the drop order for a type matters. Some std types implement drop solely to
-    /// deallocate memory. For these types, and composites containing them, changing the drop order
-    /// won't result in any observable side effects.
-    fn type_needs_ordered_drop<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
-        type_needs_ordered_drop_inner(cx, ty, &mut FxHashSet::default())
-    }
-
-    fn type_needs_ordered_drop_inner<'tcx>(
-        cx: &LateContext<'tcx>,
-        ty: Ty<'tcx>,
-        seen: &mut FxHashSet<Ty<'tcx>>,
-    ) -> bool {
-        if !seen.insert(ty) {
-            return false;
-        }
-        if !ty.needs_drop(cx.tcx, cx.param_env) {
-            false
-        } else if !cx
-            .tcx
-            .lang_items()
-            .drop_trait()
-            .map_or(false, |id| implements_trait(cx, ty, id, &[]))
-        {
-            // This type doesn't implement drop, so no side effects here.
-            // Check if any component type has any.
-            match ty.kind() {
-                ty::Tuple(_) => ty.tuple_fields().any(|ty| type_needs_ordered_drop_inner(cx, ty, seen)),
-                ty::Array(ty, _) => type_needs_ordered_drop_inner(cx, ty, seen),
-                ty::Adt(adt, subs) => adt
-                    .all_fields()
-                    .map(|f| f.ty(cx.tcx, subs))
-                    .any(|ty| type_needs_ordered_drop_inner(cx, ty, seen)),
-                _ => true,
-            }
-        }
-        // Check for std types which implement drop, but only for memory allocation.
-        else if is_type_diagnostic_item(cx, ty, sym::Vec)
-            || is_type_lang_item(cx, ty, LangItem::OwnedBox)
-            || is_type_diagnostic_item(cx, ty, sym::Rc)
-            || is_type_diagnostic_item(cx, ty, sym::Arc)
-            || is_type_diagnostic_item(cx, ty, sym::cstring_type)
-            || is_type_diagnostic_item(cx, ty, sym::BTreeMap)
-            || is_type_diagnostic_item(cx, ty, sym::LinkedList)
-            || match_type(cx, ty, &paths::WEAK_RC)
-            || match_type(cx, ty, &paths::WEAK_ARC)
-        {
-            // Check all of the generic arguments.
-            if let ty::Adt(_, subs) = ty.kind() {
-                subs.types().any(|ty| type_needs_ordered_drop_inner(cx, ty, seen))
-            } else {
-                true
-            }
-        } else {
-            true
-        }
-    }
-
-    // Extract the generic arguments out of a type
-    fn try_get_generic_ty(ty: Ty<'_>, index: usize) -> Option<Ty<'_>> {
-        if_chain! {
-            if let ty::Adt(_, subs) = ty.kind();
-            if let Some(sub) = subs.get(index);
-            if let GenericArgKind::Type(sub_ty) = sub.unpack();
-            then {
-                Some(sub_ty)
-            } else {
-                None
-            }
-        }
-    }
-
-    // Checks if there are any temporaries created in the given expression for which drop order
-    // matters.
-    fn temporaries_need_ordered_drop<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
-        struct V<'a, 'tcx> {
-            cx: &'a LateContext<'tcx>,
-            res: bool,
-        }
-        impl<'a, 'tcx> Visitor<'tcx> for V<'a, 'tcx> {
-            fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) {
-                match expr.kind {
-                    // Taking the reference of a value leaves a temporary
-                    // e.g. In `&String::new()` the string is a temporary value.
-                    // Remaining fields are temporary values
-                    // e.g. In `(String::new(), 0).1` the string is a temporary value.
-                    ExprKind::AddrOf(_, _, expr) | ExprKind::Field(expr, _) => {
-                        if !matches!(expr.kind, ExprKind::Path(_)) {
-                            if type_needs_ordered_drop(self.cx, self.cx.typeck_results().expr_ty(expr)) {
-                                self.res = true;
-                            } else {
-                                self.visit_expr(expr);
-                            }
-                        }
-                    },
-                    // the base type is alway taken by reference.
-                    // e.g. In `(vec![0])[0]` the vector is a temporary value.
-                    ExprKind::Index(base, index) => {
-                        if !matches!(base.kind, ExprKind::Path(_)) {
-                            if type_needs_ordered_drop(self.cx, self.cx.typeck_results().expr_ty(base)) {
-                                self.res = true;
-                            } else {
-                                self.visit_expr(base);
-                            }
-                        }
-                        self.visit_expr(index);
-                    },
-                    // Method calls can take self by reference.
-                    // e.g. In `String::new().len()` the string is a temporary value.
-                    ExprKind::MethodCall(_, [self_arg, args @ ..], _) => {
-                        if !matches!(self_arg.kind, ExprKind::Path(_)) {
-                            let self_by_ref = self
-                                .cx
-                                .typeck_results()
-                                .type_dependent_def_id(expr.hir_id)
-                                .map_or(false, |id| self.cx.tcx.fn_sig(id).skip_binder().inputs()[0].is_ref());
-                            if self_by_ref
-                                && type_needs_ordered_drop(self.cx, self.cx.typeck_results().expr_ty(self_arg))
-                            {
-                                self.res = true;
-                            } else {
-                                self.visit_expr(self_arg);
-                            }
-                        }
-                        args.iter().for_each(|arg| self.visit_expr(arg));
-                    },
-                    // Either explicitly drops values, or changes control flow.
-                    ExprKind::DropTemps(_)
-                    | ExprKind::Ret(_)
-                    | ExprKind::Break(..)
-                    | ExprKind::Yield(..)
-                    | ExprKind::Block(Block { expr: None, .. }, _)
-                    | ExprKind::Loop(..) => (),
-
-                    // Only consider the final expression.
-                    ExprKind::Block(Block { expr: Some(expr), .. }, _) => self.visit_expr(expr),
-
-                    _ => walk_expr(self, expr),
-                }
-            }
-        }
-
-        let mut v = V { cx, res: false };
-        v.visit_expr(expr);
-        v.res
-    }
-
-    fn find_sugg_for_if_let<'tcx>(
-        cx: &LateContext<'tcx>,
-        expr: &'tcx Expr<'_>,
-        let_pat: &Pat<'_>,
-        let_expr: &'tcx Expr<'_>,
-        keyword: &'static str,
-        has_else: bool,
-    ) {
-        // also look inside refs
-        // if we have &None for example, peel it so we can detect "if let None = x"
-        let check_pat = match let_pat.kind {
-            PatKind::Ref(inner, _mutability) => inner,
-            _ => let_pat,
-        };
-        let op_ty = cx.typeck_results().expr_ty(let_expr);
-        // Determine which function should be used, and the type contained by the corresponding
-        // variant.
-        let (good_method, inner_ty) = match check_pat.kind {
-            PatKind::TupleStruct(ref qpath, [sub_pat], _) => {
-                if let PatKind::Wild = sub_pat.kind {
-                    let res = cx.typeck_results().qpath_res(qpath, check_pat.hir_id);
-                    let Some(id) = res.opt_def_id().and_then(|ctor_id| cx.tcx.parent(ctor_id)) else { return };
-                    let lang_items = cx.tcx.lang_items();
-                    if Some(id) == lang_items.result_ok_variant() {
-                        ("is_ok()", try_get_generic_ty(op_ty, 0).unwrap_or(op_ty))
-                    } else if Some(id) == lang_items.result_err_variant() {
-                        ("is_err()", try_get_generic_ty(op_ty, 1).unwrap_or(op_ty))
-                    } else if Some(id) == lang_items.option_some_variant() {
-                        ("is_some()", op_ty)
-                    } else if Some(id) == lang_items.poll_ready_variant() {
-                        ("is_ready()", op_ty)
-                    } else if match_def_path(cx, id, &paths::IPADDR_V4) {
-                        ("is_ipv4()", op_ty)
-                    } else if match_def_path(cx, id, &paths::IPADDR_V6) {
-                        ("is_ipv6()", op_ty)
-                    } else {
-                        return;
-                    }
-                } else {
-                    return;
-                }
-            },
-            PatKind::Path(ref path) => {
-                let method = if is_lang_ctor(cx, path, OptionNone) {
-                    "is_none()"
-                } else if is_lang_ctor(cx, path, PollPending) {
-                    "is_pending()"
-                } else {
-                    return;
-                };
-                // `None` and `Pending` don't have an inner type.
-                (method, cx.tcx.types.unit)
-            },
-            _ => return,
-        };
-
-        // If this is the last expression in a block or there is an else clause then the whole
-        // type needs to be considered, not just the inner type of the branch being matched on.
-        // Note the last expression in a block is dropped after all local bindings.
-        let check_ty = if has_else
-            || (keyword == "if" && matches!(cx.tcx.hir().parent_iter(expr.hir_id).next(), Some((_, Node::Block(..)))))
-        {
-            op_ty
-        } else {
-            inner_ty
-        };
-
-        // All temporaries created in the scrutinee expression are dropped at the same time as the
-        // scrutinee would be, so they have to be considered as well.
-        // e.g. in `if let Some(x) = foo.lock().unwrap().baz.as_ref() { .. }` the lock will be held
-        // for the duration if body.
-        let needs_drop = type_needs_ordered_drop(cx, check_ty) || temporaries_need_ordered_drop(cx, let_expr);
-
-        // check that `while_let_on_iterator` lint does not trigger
-        if_chain! {
-            if keyword == "while";
-            if let ExprKind::MethodCall(method_path, _, _) = let_expr.kind;
-            if method_path.ident.name == sym::next;
-            if is_trait_method(cx, let_expr, sym::Iterator);
-            then {
-                return;
-            }
-        }
-
-        let result_expr = match &let_expr.kind {
-            ExprKind::AddrOf(_, _, borrowed) => borrowed,
-            ExprKind::Unary(UnOp::Deref, deref) => deref,
-            _ => let_expr,
-        };
-
-        span_lint_and_then(
-            cx,
-            REDUNDANT_PATTERN_MATCHING,
-            let_pat.span,
-            &format!("redundant pattern matching, consider using `{}`", good_method),
-            |diag| {
-                // if/while let ... = ... { ... }
-                // ^^^^^^^^^^^^^^^^^^^^^^^^^^^
-                let expr_span = expr.span;
-
-                // if/while let ... = ... { ... }
-                //                 ^^^
-                let op_span = result_expr.span.source_callsite();
-
-                // if/while let ... = ... { ... }
-                // ^^^^^^^^^^^^^^^^^^^
-                let span = expr_span.until(op_span.shrink_to_hi());
-
-                let app = if needs_drop {
-                    Applicability::MaybeIncorrect
-                } else {
-                    Applicability::MachineApplicable
-                };
-
-                let sugg = Sugg::hir_with_macro_callsite(cx, result_expr, "_")
-                    .maybe_par()
-                    .to_string();
-
-                diag.span_suggestion(span, "try this", format!("{} {}.{}", keyword, sugg, good_method), app);
-
-                if needs_drop {
-                    diag.note("this will change drop order of the result, as well as all temporaries");
-                    diag.note("add `#[allow(clippy::redundant_pattern_matching)]` if this is important");
-                }
-            },
-        );
-    }
-
-    fn find_sugg_for_match<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, op: &Expr<'_>, arms: &[Arm<'_>]) {
-        if arms.len() == 2 {
-            let node_pair = (&arms[0].pat.kind, &arms[1].pat.kind);
-
-            let found_good_method = match node_pair {
-                (
-                    PatKind::TupleStruct(ref path_left, patterns_left, _),
-                    PatKind::TupleStruct(ref path_right, patterns_right, _),
-                ) if patterns_left.len() == 1 && patterns_right.len() == 1 => {
-                    if let (PatKind::Wild, PatKind::Wild) = (&patterns_left[0].kind, &patterns_right[0].kind) {
-                        find_good_method_for_match(
-                            cx,
-                            arms,
-                            path_left,
-                            path_right,
-                            &paths::RESULT_OK,
-                            &paths::RESULT_ERR,
-                            "is_ok()",
-                            "is_err()",
-                        )
-                        .or_else(|| {
-                            find_good_method_for_match(
-                                cx,
-                                arms,
-                                path_left,
-                                path_right,
-                                &paths::IPADDR_V4,
-                                &paths::IPADDR_V6,
-                                "is_ipv4()",
-                                "is_ipv6()",
-                            )
-                        })
-                    } else {
-                        None
-                    }
-                },
-                (PatKind::TupleStruct(ref path_left, patterns, _), PatKind::Path(ref path_right))
-                | (PatKind::Path(ref path_left), PatKind::TupleStruct(ref path_right, patterns, _))
-                    if patterns.len() == 1 =>
-                {
-                    if let PatKind::Wild = patterns[0].kind {
-                        find_good_method_for_match(
-                            cx,
-                            arms,
-                            path_left,
-                            path_right,
-                            &paths::OPTION_SOME,
-                            &paths::OPTION_NONE,
-                            "is_some()",
-                            "is_none()",
-                        )
-                        .or_else(|| {
-                            find_good_method_for_match(
-                                cx,
-                                arms,
-                                path_left,
-                                path_right,
-                                &paths::POLL_READY,
-                                &paths::POLL_PENDING,
-                                "is_ready()",
-                                "is_pending()",
-                            )
-                        })
-                    } else {
-                        None
-                    }
-                },
-                _ => None,
-            };
-
-            if let Some(good_method) = found_good_method {
-                let span = expr.span.to(op.span);
-                let result_expr = match &op.kind {
-                    ExprKind::AddrOf(_, _, borrowed) => borrowed,
-                    _ => op,
-                };
-                span_lint_and_then(
-                    cx,
-                    REDUNDANT_PATTERN_MATCHING,
-                    expr.span,
-                    &format!("redundant pattern matching, consider using `{}`", good_method),
-                    |diag| {
-                        diag.span_suggestion(
-                            span,
-                            "try this",
-                            format!("{}.{}", snippet(cx, result_expr.span, "_"), good_method),
-                            Applicability::MaybeIncorrect, // snippet
-                        );
-                    },
-                );
-            }
-        }
-    }
-
-    #[allow(clippy::too_many_arguments)]
-    fn find_good_method_for_match<'a>(
-        cx: &LateContext<'_>,
-        arms: &[Arm<'_>],
-        path_left: &QPath<'_>,
-        path_right: &QPath<'_>,
-        expected_left: &[&str],
-        expected_right: &[&str],
-        should_be_left: &'a str,
-        should_be_right: &'a str,
-    ) -> Option<&'a str> {
-        let left_id = cx
-            .typeck_results()
-            .qpath_res(path_left, arms[0].pat.hir_id)
-            .opt_def_id()?;
-        let right_id = cx
-            .typeck_results()
-            .qpath_res(path_right, arms[1].pat.hir_id)
-            .opt_def_id()?;
-        let body_node_pair =
-            if match_def_path(cx, left_id, expected_left) && match_def_path(cx, right_id, expected_right) {
-                (&(*arms[0].body).kind, &(*arms[1].body).kind)
-            } else if match_def_path(cx, right_id, expected_left) && match_def_path(cx, right_id, expected_right) {
-                (&(*arms[1].body).kind, &(*arms[0].body).kind)
-            } else {
-                return None;
-            };
-
-        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)) => Some(should_be_left),
-                (LitKind::Bool(false), LitKind::Bool(true)) => Some(should_be_right),
-                _ => None,
-            },
-            _ => None,
-        }
-    }
-}
-
 #[test]
 fn test_overlapping() {
     use rustc_span::source_map::DUMMY_SP;
diff --git a/clippy_lints/src/matches/redundant_pattern_match.rs b/clippy_lints/src/matches/redundant_pattern_match.rs
new file mode 100644
index 00000000000..61c5fa0872f
--- /dev/null
+++ b/clippy_lints/src/matches/redundant_pattern_match.rs
@@ -0,0 +1,436 @@
+use super::REDUNDANT_PATTERN_MATCHING;
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::source::snippet;
+use clippy_utils::sugg::Sugg;
+use clippy_utils::ty::{implements_trait, is_type_diagnostic_item, is_type_lang_item, match_type};
+use clippy_utils::{higher, match_def_path};
+use clippy_utils::{is_lang_ctor, is_trait_method, paths};
+use if_chain::if_chain;
+use rustc_ast::ast::LitKind;
+use rustc_data_structures::fx::FxHashSet;
+use rustc_errors::Applicability;
+use rustc_hir::LangItem::{OptionNone, PollPending};
+use rustc_hir::{
+    intravisit::{walk_expr, Visitor},
+    Arm, Block, Expr, ExprKind, LangItem, MatchSource, Node, Pat, PatKind, QPath, UnOp,
+};
+use rustc_lint::LateContext;
+use rustc_middle::ty::{self, subst::GenericArgKind, DefIdTree, Ty};
+use rustc_span::sym;
+
+pub fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+    if let Some(higher::IfLet {
+        if_else,
+        let_pat,
+        let_expr,
+        ..
+    }) = higher::IfLet::hir(cx, expr)
+    {
+        find_sugg_for_if_let(cx, expr, let_pat, let_expr, "if", if_else.is_some());
+    }
+    if let ExprKind::Match(op, arms, MatchSource::Normal) = &expr.kind {
+        find_sugg_for_match(cx, expr, op, arms);
+    }
+    if let Some(higher::WhileLet { let_pat, let_expr, .. }) = higher::WhileLet::hir(expr) {
+        find_sugg_for_if_let(cx, expr, let_pat, let_expr, "while", false);
+    }
+}
+
+/// Checks if the drop order for a type matters. Some std types implement drop solely to
+/// deallocate memory. For these types, and composites containing them, changing the drop order
+/// won't result in any observable side effects.
+fn type_needs_ordered_drop<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
+    type_needs_ordered_drop_inner(cx, ty, &mut FxHashSet::default())
+}
+
+fn type_needs_ordered_drop_inner<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>, seen: &mut FxHashSet<Ty<'tcx>>) -> bool {
+    if !seen.insert(ty) {
+        return false;
+    }
+    if !ty.needs_drop(cx.tcx, cx.param_env) {
+        false
+    } else if !cx
+        .tcx
+        .lang_items()
+        .drop_trait()
+        .map_or(false, |id| implements_trait(cx, ty, id, &[]))
+    {
+        // This type doesn't implement drop, so no side effects here.
+        // Check if any component type has any.
+        match ty.kind() {
+            ty::Tuple(_) => ty.tuple_fields().any(|ty| type_needs_ordered_drop_inner(cx, ty, seen)),
+            ty::Array(ty, _) => type_needs_ordered_drop_inner(cx, ty, seen),
+            ty::Adt(adt, subs) => adt
+                .all_fields()
+                .map(|f| f.ty(cx.tcx, subs))
+                .any(|ty| type_needs_ordered_drop_inner(cx, ty, seen)),
+            _ => true,
+        }
+    }
+    // Check for std types which implement drop, but only for memory allocation.
+    else if is_type_diagnostic_item(cx, ty, sym::Vec)
+        || is_type_lang_item(cx, ty, LangItem::OwnedBox)
+        || is_type_diagnostic_item(cx, ty, sym::Rc)
+        || is_type_diagnostic_item(cx, ty, sym::Arc)
+        || is_type_diagnostic_item(cx, ty, sym::cstring_type)
+        || is_type_diagnostic_item(cx, ty, sym::BTreeMap)
+        || is_type_diagnostic_item(cx, ty, sym::LinkedList)
+        || match_type(cx, ty, &paths::WEAK_RC)
+        || match_type(cx, ty, &paths::WEAK_ARC)
+    {
+        // Check all of the generic arguments.
+        if let ty::Adt(_, subs) = ty.kind() {
+            subs.types().any(|ty| type_needs_ordered_drop_inner(cx, ty, seen))
+        } else {
+            true
+        }
+    } else {
+        true
+    }
+}
+
+// Extract the generic arguments out of a type
+fn try_get_generic_ty(ty: Ty<'_>, index: usize) -> Option<Ty<'_>> {
+    if_chain! {
+        if let ty::Adt(_, subs) = ty.kind();
+        if let Some(sub) = subs.get(index);
+        if let GenericArgKind::Type(sub_ty) = sub.unpack();
+        then {
+            Some(sub_ty)
+        } else {
+            None
+        }
+    }
+}
+
+// Checks if there are any temporaries created in the given expression for which drop order
+// matters.
+fn temporaries_need_ordered_drop<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
+    struct V<'a, 'tcx> {
+        cx: &'a LateContext<'tcx>,
+        res: bool,
+    }
+    impl<'a, 'tcx> Visitor<'tcx> for V<'a, 'tcx> {
+        fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) {
+            match expr.kind {
+                // Taking the reference of a value leaves a temporary
+                // e.g. In `&String::new()` the string is a temporary value.
+                // Remaining fields are temporary values
+                // e.g. In `(String::new(), 0).1` the string is a temporary value.
+                ExprKind::AddrOf(_, _, expr) | ExprKind::Field(expr, _) => {
+                    if !matches!(expr.kind, ExprKind::Path(_)) {
+                        if type_needs_ordered_drop(self.cx, self.cx.typeck_results().expr_ty(expr)) {
+                            self.res = true;
+                        } else {
+                            self.visit_expr(expr);
+                        }
+                    }
+                },
+                // the base type is alway taken by reference.
+                // e.g. In `(vec![0])[0]` the vector is a temporary value.
+                ExprKind::Index(base, index) => {
+                    if !matches!(base.kind, ExprKind::Path(_)) {
+                        if type_needs_ordered_drop(self.cx, self.cx.typeck_results().expr_ty(base)) {
+                            self.res = true;
+                        } else {
+                            self.visit_expr(base);
+                        }
+                    }
+                    self.visit_expr(index);
+                },
+                // Method calls can take self by reference.
+                // e.g. In `String::new().len()` the string is a temporary value.
+                ExprKind::MethodCall(_, [self_arg, args @ ..], _) => {
+                    if !matches!(self_arg.kind, ExprKind::Path(_)) {
+                        let self_by_ref = self
+                            .cx
+                            .typeck_results()
+                            .type_dependent_def_id(expr.hir_id)
+                            .map_or(false, |id| self.cx.tcx.fn_sig(id).skip_binder().inputs()[0].is_ref());
+                        if self_by_ref && type_needs_ordered_drop(self.cx, self.cx.typeck_results().expr_ty(self_arg)) {
+                            self.res = true;
+                        } else {
+                            self.visit_expr(self_arg);
+                        }
+                    }
+                    args.iter().for_each(|arg| self.visit_expr(arg));
+                },
+                // Either explicitly drops values, or changes control flow.
+                ExprKind::DropTemps(_)
+                | ExprKind::Ret(_)
+                | ExprKind::Break(..)
+                | ExprKind::Yield(..)
+                | ExprKind::Block(Block { expr: None, .. }, _)
+                | ExprKind::Loop(..) => (),
+
+                // Only consider the final expression.
+                ExprKind::Block(Block { expr: Some(expr), .. }, _) => self.visit_expr(expr),
+
+                _ => walk_expr(self, expr),
+            }
+        }
+    }
+
+    let mut v = V { cx, res: false };
+    v.visit_expr(expr);
+    v.res
+}
+
+fn find_sugg_for_if_let<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx Expr<'_>,
+    let_pat: &Pat<'_>,
+    let_expr: &'tcx Expr<'_>,
+    keyword: &'static str,
+    has_else: bool,
+) {
+    // also look inside refs
+    // if we have &None for example, peel it so we can detect "if let None = x"
+    let check_pat = match let_pat.kind {
+        PatKind::Ref(inner, _mutability) => inner,
+        _ => let_pat,
+    };
+    let op_ty = cx.typeck_results().expr_ty(let_expr);
+    // Determine which function should be used, and the type contained by the corresponding
+    // variant.
+    let (good_method, inner_ty) = match check_pat.kind {
+        PatKind::TupleStruct(ref qpath, [sub_pat], _) => {
+            if let PatKind::Wild = sub_pat.kind {
+                let res = cx.typeck_results().qpath_res(qpath, check_pat.hir_id);
+                let Some(id) = res.opt_def_id().and_then(|ctor_id| cx.tcx.parent(ctor_id)) else { return };
+                let lang_items = cx.tcx.lang_items();
+                if Some(id) == lang_items.result_ok_variant() {
+                    ("is_ok()", try_get_generic_ty(op_ty, 0).unwrap_or(op_ty))
+                } else if Some(id) == lang_items.result_err_variant() {
+                    ("is_err()", try_get_generic_ty(op_ty, 1).unwrap_or(op_ty))
+                } else if Some(id) == lang_items.option_some_variant() {
+                    ("is_some()", op_ty)
+                } else if Some(id) == lang_items.poll_ready_variant() {
+                    ("is_ready()", op_ty)
+                } else if match_def_path(cx, id, &paths::IPADDR_V4) {
+                    ("is_ipv4()", op_ty)
+                } else if match_def_path(cx, id, &paths::IPADDR_V6) {
+                    ("is_ipv6()", op_ty)
+                } else {
+                    return;
+                }
+            } else {
+                return;
+            }
+        },
+        PatKind::Path(ref path) => {
+            let method = if is_lang_ctor(cx, path, OptionNone) {
+                "is_none()"
+            } else if is_lang_ctor(cx, path, PollPending) {
+                "is_pending()"
+            } else {
+                return;
+            };
+            // `None` and `Pending` don't have an inner type.
+            (method, cx.tcx.types.unit)
+        },
+        _ => return,
+    };
+
+    // If this is the last expression in a block or there is an else clause then the whole
+    // type needs to be considered, not just the inner type of the branch being matched on.
+    // Note the last expression in a block is dropped after all local bindings.
+    let check_ty = if has_else
+        || (keyword == "if" && matches!(cx.tcx.hir().parent_iter(expr.hir_id).next(), Some((_, Node::Block(..)))))
+    {
+        op_ty
+    } else {
+        inner_ty
+    };
+
+    // All temporaries created in the scrutinee expression are dropped at the same time as the
+    // scrutinee would be, so they have to be considered as well.
+    // e.g. in `if let Some(x) = foo.lock().unwrap().baz.as_ref() { .. }` the lock will be held
+    // for the duration if body.
+    let needs_drop = type_needs_ordered_drop(cx, check_ty) || temporaries_need_ordered_drop(cx, let_expr);
+
+    // check that `while_let_on_iterator` lint does not trigger
+    if_chain! {
+        if keyword == "while";
+        if let ExprKind::MethodCall(method_path, _, _) = let_expr.kind;
+        if method_path.ident.name == sym::next;
+        if is_trait_method(cx, let_expr, sym::Iterator);
+        then {
+            return;
+        }
+    }
+
+    let result_expr = match &let_expr.kind {
+        ExprKind::AddrOf(_, _, borrowed) => borrowed,
+        ExprKind::Unary(UnOp::Deref, deref) => deref,
+        _ => let_expr,
+    };
+
+    span_lint_and_then(
+        cx,
+        REDUNDANT_PATTERN_MATCHING,
+        let_pat.span,
+        &format!("redundant pattern matching, consider using `{}`", good_method),
+        |diag| {
+            // if/while let ... = ... { ... }
+            // ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+            let expr_span = expr.span;
+
+            // if/while let ... = ... { ... }
+            //                 ^^^
+            let op_span = result_expr.span.source_callsite();
+
+            // if/while let ... = ... { ... }
+            // ^^^^^^^^^^^^^^^^^^^
+            let span = expr_span.until(op_span.shrink_to_hi());
+
+            let app = if needs_drop {
+                Applicability::MaybeIncorrect
+            } else {
+                Applicability::MachineApplicable
+            };
+
+            let sugg = Sugg::hir_with_macro_callsite(cx, result_expr, "_")
+                .maybe_par()
+                .to_string();
+
+            diag.span_suggestion(span, "try this", format!("{} {}.{}", keyword, sugg, good_method), app);
+
+            if needs_drop {
+                diag.note("this will change drop order of the result, as well as all temporaries");
+                diag.note("add `#[allow(clippy::redundant_pattern_matching)]` if this is important");
+            }
+        },
+    );
+}
+
+fn find_sugg_for_match<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, op: &Expr<'_>, arms: &[Arm<'_>]) {
+    if arms.len() == 2 {
+        let node_pair = (&arms[0].pat.kind, &arms[1].pat.kind);
+
+        let found_good_method = match node_pair {
+            (
+                PatKind::TupleStruct(ref path_left, patterns_left, _),
+                PatKind::TupleStruct(ref path_right, patterns_right, _),
+            ) if patterns_left.len() == 1 && patterns_right.len() == 1 => {
+                if let (PatKind::Wild, PatKind::Wild) = (&patterns_left[0].kind, &patterns_right[0].kind) {
+                    find_good_method_for_match(
+                        cx,
+                        arms,
+                        path_left,
+                        path_right,
+                        &paths::RESULT_OK,
+                        &paths::RESULT_ERR,
+                        "is_ok()",
+                        "is_err()",
+                    )
+                    .or_else(|| {
+                        find_good_method_for_match(
+                            cx,
+                            arms,
+                            path_left,
+                            path_right,
+                            &paths::IPADDR_V4,
+                            &paths::IPADDR_V6,
+                            "is_ipv4()",
+                            "is_ipv6()",
+                        )
+                    })
+                } else {
+                    None
+                }
+            },
+            (PatKind::TupleStruct(ref path_left, patterns, _), PatKind::Path(ref path_right))
+            | (PatKind::Path(ref path_left), PatKind::TupleStruct(ref path_right, patterns, _))
+                if patterns.len() == 1 =>
+            {
+                if let PatKind::Wild = patterns[0].kind {
+                    find_good_method_for_match(
+                        cx,
+                        arms,
+                        path_left,
+                        path_right,
+                        &paths::OPTION_SOME,
+                        &paths::OPTION_NONE,
+                        "is_some()",
+                        "is_none()",
+                    )
+                    .or_else(|| {
+                        find_good_method_for_match(
+                            cx,
+                            arms,
+                            path_left,
+                            path_right,
+                            &paths::POLL_READY,
+                            &paths::POLL_PENDING,
+                            "is_ready()",
+                            "is_pending()",
+                        )
+                    })
+                } else {
+                    None
+                }
+            },
+            _ => None,
+        };
+
+        if let Some(good_method) = found_good_method {
+            let span = expr.span.to(op.span);
+            let result_expr = match &op.kind {
+                ExprKind::AddrOf(_, _, borrowed) => borrowed,
+                _ => op,
+            };
+            span_lint_and_then(
+                cx,
+                REDUNDANT_PATTERN_MATCHING,
+                expr.span,
+                &format!("redundant pattern matching, consider using `{}`", good_method),
+                |diag| {
+                    diag.span_suggestion(
+                        span,
+                        "try this",
+                        format!("{}.{}", snippet(cx, result_expr.span, "_"), good_method),
+                        Applicability::MaybeIncorrect, // snippet
+                    );
+                },
+            );
+        }
+    }
+}
+
+#[allow(clippy::too_many_arguments)]
+fn find_good_method_for_match<'a>(
+    cx: &LateContext<'_>,
+    arms: &[Arm<'_>],
+    path_left: &QPath<'_>,
+    path_right: &QPath<'_>,
+    expected_left: &[&str],
+    expected_right: &[&str],
+    should_be_left: &'a str,
+    should_be_right: &'a str,
+) -> Option<&'a str> {
+    let left_id = cx
+        .typeck_results()
+        .qpath_res(path_left, arms[0].pat.hir_id)
+        .opt_def_id()?;
+    let right_id = cx
+        .typeck_results()
+        .qpath_res(path_right, arms[1].pat.hir_id)
+        .opt_def_id()?;
+    let body_node_pair = if match_def_path(cx, left_id, expected_left) && match_def_path(cx, right_id, expected_right) {
+        (&(*arms[0].body).kind, &(*arms[1].body).kind)
+    } else if match_def_path(cx, right_id, expected_left) && match_def_path(cx, right_id, expected_right) {
+        (&(*arms[1].body).kind, &(*arms[0].body).kind)
+    } else {
+        return None;
+    };
+
+    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)) => Some(should_be_left),
+            (LitKind::Bool(false), LitKind::Bool(true)) => Some(should_be_right),
+            _ => None,
+        },
+        _ => None,
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From f23dc16e1df17e7d2c62d11bc3b180aba644624b Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sun, 6 Feb 2022 14:18:00 -0500
Subject: Split out `single_match`

---
 clippy_lints/src/matches/mod.rs          | 272 +------------------------------
 clippy_lints/src/matches/single_match.rs | 269 ++++++++++++++++++++++++++++++
 2 files changed, 277 insertions(+), 264 deletions(-)
 create mode 100644 clippy_lints/src/matches/single_match.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/mod.rs b/clippy_lints/src/matches/mod.rs
index 4b09bdb98ec..5173102a9e5 100644
--- a/clippy_lints/src/matches/mod.rs
+++ b/clippy_lints/src/matches/mod.rs
@@ -3,15 +3,14 @@ use clippy_utils::diagnostics::{
     multispan_sugg, span_lint_and_help, span_lint_and_note, span_lint_and_sugg, span_lint_and_then,
 };
 use clippy_utils::macros::{is_panic, root_macro_call};
-use clippy_utils::paths;
 use clippy_utils::peel_blocks_with_stmt;
 use clippy_utils::source::{expr_block, indent_of, snippet, snippet_block, snippet_opt, snippet_with_applicability};
 use clippy_utils::sugg::Sugg;
-use clippy_utils::ty::{implements_trait, is_type_diagnostic_item, match_type, peel_mid_ty_refs};
+use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::visitors::is_local_used;
 use clippy_utils::{
-    get_parent_expr, is_lang_ctor, is_lint_allowed, is_refutable, is_unit_expr, is_wild, meets_msrv, msrvs,
-    path_to_local_id, peel_blocks, peel_hir_pat_refs, peel_n_hir_expr_refs, recurse_or_patterns, strip_pat_refs,
+    get_parent_expr, is_lang_ctor, is_refutable, is_unit_expr, is_wild, meets_msrv, msrvs, path_to_local_id,
+    peel_blocks, peel_hir_pat_refs, recurse_or_patterns, strip_pat_refs,
 };
 use core::iter::once;
 use if_chain::if_chain;
@@ -20,19 +19,20 @@ use rustc_errors::Applicability;
 use rustc_hir::def::{CtorKind, DefKind, Res};
 use rustc_hir::LangItem::{OptionNone, OptionSome};
 use rustc_hir::{
-    self as hir, Arm, BindingAnnotation, Block, BorrowKind, Expr, ExprKind, Local, MatchSource, Mutability, Node, Pat,
+    self as hir, Arm, BindingAnnotation, BorrowKind, Expr, ExprKind, Local, MatchSource, Mutability, Node, Pat,
     PatKind, PathSegment, QPath, RangeEnd, TyKind,
 };
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty::{self, Ty, TyS, VariantDef};
+use rustc_middle::ty::{self, Ty, VariantDef};
 use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::{sym, symbol::kw, Span};
-use std::cmp::{max, Ordering};
+use std::cmp::Ordering;
 
 mod match_like_matches;
 mod match_same_arms;
 mod redundant_pattern_match;
+mod single_match;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -630,7 +630,7 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
         }
 
         if let ExprKind::Match(ex, arms, MatchSource::Normal) = expr.kind {
-            check_single_match(cx, ex, arms, expr);
+            single_match::check(cx, ex, arms, expr);
             check_match_bool(cx, ex, arms, expr);
             check_overlapping_arms(cx, ex, arms);
             check_wild_err_arm(cx, ex, arms);
@@ -710,262 +710,6 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
     extract_msrv_attr!(LateContext);
 }
 
-#[rustfmt::skip]
-fn check_single_match(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>], expr: &Expr<'_>) {
-    if arms.len() == 2 && arms[0].guard.is_none() && arms[1].guard.is_none() {
-        if expr.span.from_expansion() {
-            // Don't lint match expressions present in
-            // macro_rules! block
-            return;
-        }
-        if let PatKind::Or(..) = arms[0].pat.kind {
-            // don't lint for or patterns for now, this makes
-            // the lint noisy in unnecessary situations
-            return;
-        }
-        let els = arms[1].body;
-        let els = if is_unit_expr(peel_blocks(els)) {
-            None
-        } else if let ExprKind::Block(Block { stmts, expr: block_expr, .. }, _) = els.kind {
-            if stmts.len() == 1 && block_expr.is_none() || stmts.is_empty() && block_expr.is_some() {
-                // single statement/expr "else" block, don't lint
-                return;
-            }
-            // block with 2+ statements or 1 expr and 1+ statement
-            Some(els)
-        } else {
-            // not a block, don't lint
-            return;
-        };
-
-        let ty = cx.typeck_results().expr_ty(ex);
-        if *ty.kind() != ty::Bool || is_lint_allowed(cx, MATCH_BOOL, ex.hir_id) {
-            check_single_match_single_pattern(cx, ex, arms, expr, els);
-            check_single_match_opt_like(cx, ex, arms, expr, ty, els);
-        }
-    }
-}
-
-fn check_single_match_single_pattern(
-    cx: &LateContext<'_>,
-    ex: &Expr<'_>,
-    arms: &[Arm<'_>],
-    expr: &Expr<'_>,
-    els: Option<&Expr<'_>>,
-) {
-    if is_wild(arms[1].pat) {
-        report_single_match_single_pattern(cx, ex, arms, expr, els);
-    }
-}
-
-fn report_single_match_single_pattern(
-    cx: &LateContext<'_>,
-    ex: &Expr<'_>,
-    arms: &[Arm<'_>],
-    expr: &Expr<'_>,
-    els: Option<&Expr<'_>>,
-) {
-    let lint = if els.is_some() { SINGLE_MATCH_ELSE } else { SINGLE_MATCH };
-    let els_str = els.map_or(String::new(), |els| {
-        format!(" else {}", expr_block(cx, els, None, "..", Some(expr.span)))
-    });
-
-    let (pat, pat_ref_count) = peel_hir_pat_refs(arms[0].pat);
-    let (msg, sugg) = if_chain! {
-        if let PatKind::Path(_) | PatKind::Lit(_) = pat.kind;
-        let (ty, ty_ref_count) = peel_mid_ty_refs(cx.typeck_results().expr_ty(ex));
-        if let Some(spe_trait_id) = cx.tcx.lang_items().structural_peq_trait();
-        if let Some(pe_trait_id) = cx.tcx.lang_items().eq_trait();
-        if ty.is_integral() || ty.is_char() || ty.is_str()
-            || (implements_trait(cx, ty, spe_trait_id, &[])
-                && implements_trait(cx, ty, pe_trait_id, &[ty.into()]));
-        then {
-            // scrutinee derives PartialEq and the pattern is a constant.
-            let pat_ref_count = match pat.kind {
-                // string literals are already a reference.
-                PatKind::Lit(Expr { kind: ExprKind::Lit(lit), .. }) if lit.node.is_str() => pat_ref_count + 1,
-                _ => pat_ref_count,
-            };
-            // References are only implicitly added to the pattern, so no overflow here.
-            // e.g. will work: match &Some(_) { Some(_) => () }
-            // will not: match Some(_) { &Some(_) => () }
-            let ref_count_diff = ty_ref_count - pat_ref_count;
-
-            // Try to remove address of expressions first.
-            let (ex, removed) = peel_n_hir_expr_refs(ex, ref_count_diff);
-            let ref_count_diff = ref_count_diff - removed;
-
-            let msg = "you seem to be trying to use `match` for an equality check. Consider using `if`";
-            let sugg = format!(
-                "if {} == {}{} {}{}",
-                snippet(cx, ex.span, ".."),
-                // PartialEq for different reference counts may not exist.
-                "&".repeat(ref_count_diff),
-                snippet(cx, arms[0].pat.span, ".."),
-                expr_block(cx, arms[0].body, None, "..", Some(expr.span)),
-                els_str,
-            );
-            (msg, sugg)
-        } else {
-            let msg = "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`";
-            let sugg = format!(
-                "if let {} = {} {}{}",
-                snippet(cx, arms[0].pat.span, ".."),
-                snippet(cx, ex.span, ".."),
-                expr_block(cx, arms[0].body, None, "..", Some(expr.span)),
-                els_str,
-            );
-            (msg, sugg)
-        }
-    };
-
-    span_lint_and_sugg(
-        cx,
-        lint,
-        expr.span,
-        msg,
-        "try this",
-        sugg,
-        Applicability::HasPlaceholders,
-    );
-}
-
-fn check_single_match_opt_like<'a>(
-    cx: &LateContext<'a>,
-    ex: &Expr<'_>,
-    arms: &[Arm<'_>],
-    expr: &Expr<'_>,
-    ty: Ty<'a>,
-    els: Option<&Expr<'_>>,
-) {
-    // list of candidate `Enum`s we know will never get any more members
-    let candidates = &[
-        (&paths::COW, "Borrowed"),
-        (&paths::COW, "Cow::Borrowed"),
-        (&paths::COW, "Cow::Owned"),
-        (&paths::COW, "Owned"),
-        (&paths::OPTION, "None"),
-        (&paths::RESULT, "Err"),
-        (&paths::RESULT, "Ok"),
-    ];
-
-    // We want to suggest to exclude an arm that contains only wildcards or forms the exhaustive
-    // match with the second branch, without enum variants in matches.
-    if !contains_only_wilds(arms[1].pat) && !form_exhaustive_matches(arms[0].pat, arms[1].pat) {
-        return;
-    }
-
-    let mut paths_and_types = Vec::new();
-    if !collect_pat_paths(&mut paths_and_types, cx, arms[1].pat, ty) {
-        return;
-    }
-
-    let in_candidate_enum = |path_info: &(String, &TyS<'_>)| -> bool {
-        let (path, ty) = path_info;
-        for &(ty_path, pat_path) in candidates {
-            if path == pat_path && match_type(cx, ty, ty_path) {
-                return true;
-            }
-        }
-        false
-    };
-    if paths_and_types.iter().all(in_candidate_enum) {
-        report_single_match_single_pattern(cx, ex, arms, expr, els);
-    }
-}
-
-/// Collects paths and their types from the given patterns. Returns true if the given pattern could
-/// be simplified, false otherwise.
-fn collect_pat_paths<'a>(acc: &mut Vec<(String, Ty<'a>)>, cx: &LateContext<'a>, pat: &Pat<'_>, ty: Ty<'a>) -> bool {
-    match pat.kind {
-        PatKind::Wild => true,
-        PatKind::Tuple(inner, _) => inner.iter().all(|p| {
-            let p_ty = cx.typeck_results().pat_ty(p);
-            collect_pat_paths(acc, cx, p, p_ty)
-        }),
-        PatKind::TupleStruct(ref path, ..) => {
-            let path = rustc_hir_pretty::to_string(rustc_hir_pretty::NO_ANN, |s| {
-                s.print_qpath(path, false);
-            });
-            acc.push((path, ty));
-            true
-        },
-        PatKind::Binding(BindingAnnotation::Unannotated, .., ident, None) => {
-            acc.push((ident.to_string(), ty));
-            true
-        },
-        PatKind::Path(ref path) => {
-            let path = rustc_hir_pretty::to_string(rustc_hir_pretty::NO_ANN, |s| {
-                s.print_qpath(path, false);
-            });
-            acc.push((path, ty));
-            true
-        },
-        _ => false,
-    }
-}
-
-/// Returns true if the given arm of pattern matching contains wildcard patterns.
-fn contains_only_wilds(pat: &Pat<'_>) -> bool {
-    match pat.kind {
-        PatKind::Wild => true,
-        PatKind::Tuple(inner, _) | PatKind::TupleStruct(_, inner, ..) => inner.iter().all(contains_only_wilds),
-        _ => false,
-    }
-}
-
-/// Returns true if the given patterns forms only exhaustive matches that don't contain enum
-/// patterns without a wildcard.
-fn form_exhaustive_matches(left: &Pat<'_>, right: &Pat<'_>) -> bool {
-    match (&left.kind, &right.kind) {
-        (PatKind::Wild, _) | (_, PatKind::Wild) => true,
-        (PatKind::Tuple(left_in, left_pos), PatKind::Tuple(right_in, right_pos)) => {
-            // We don't actually know the position and the presence of the `..` (dotdot) operator
-            // in the arms, so we need to evaluate the correct offsets here in order to iterate in
-            // both arms at the same time.
-            let len = max(
-                left_in.len() + {
-                    if left_pos.is_some() { 1 } else { 0 }
-                },
-                right_in.len() + {
-                    if right_pos.is_some() { 1 } else { 0 }
-                },
-            );
-            let mut left_pos = left_pos.unwrap_or(usize::MAX);
-            let mut right_pos = right_pos.unwrap_or(usize::MAX);
-            let mut left_dot_space = 0;
-            let mut right_dot_space = 0;
-            for i in 0..len {
-                let mut found_dotdot = false;
-                if i == left_pos {
-                    left_dot_space += 1;
-                    if left_dot_space < len - left_in.len() {
-                        left_pos += 1;
-                    }
-                    found_dotdot = true;
-                }
-                if i == right_pos {
-                    right_dot_space += 1;
-                    if right_dot_space < len - right_in.len() {
-                        right_pos += 1;
-                    }
-                    found_dotdot = true;
-                }
-                if found_dotdot {
-                    continue;
-                }
-                if !contains_only_wilds(&left_in[i - left_dot_space])
-                    && !contains_only_wilds(&right_in[i - right_dot_space])
-                {
-                    return false;
-                }
-            }
-            true
-        },
-        _ => false,
-    }
-}
-
 fn check_match_bool(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>], expr: &Expr<'_>) {
     // Type of expression is `bool`.
     if *cx.typeck_results().expr_ty(ex).kind() == ty::Bool {
diff --git a/clippy_lints/src/matches/single_match.rs b/clippy_lints/src/matches/single_match.rs
new file mode 100644
index 00000000000..6ba279eaf12
--- /dev/null
+++ b/clippy_lints/src/matches/single_match.rs
@@ -0,0 +1,269 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::{expr_block, snippet};
+use clippy_utils::ty::{implements_trait, match_type, peel_mid_ty_refs};
+use clippy_utils::{
+    is_lint_allowed, is_unit_expr, is_wild, paths, peel_blocks, peel_hir_pat_refs, peel_n_hir_expr_refs,
+};
+use core::cmp::max;
+use rustc_errors::Applicability;
+use rustc_hir::{Arm, BindingAnnotation, Block, Expr, ExprKind, Pat, PatKind};
+use rustc_lint::LateContext;
+use rustc_middle::ty::{self, Ty, TyS};
+
+use super::{MATCH_BOOL, SINGLE_MATCH, SINGLE_MATCH_ELSE};
+
+#[rustfmt::skip]
+pub(crate) fn check(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>], expr: &Expr<'_>) {
+    if arms.len() == 2 && arms[0].guard.is_none() && arms[1].guard.is_none() {
+        if expr.span.from_expansion() {
+            // Don't lint match expressions present in
+            // macro_rules! block
+            return;
+        }
+        if let PatKind::Or(..) = arms[0].pat.kind {
+            // don't lint for or patterns for now, this makes
+            // the lint noisy in unnecessary situations
+            return;
+        }
+        let els = arms[1].body;
+        let els = if is_unit_expr(peel_blocks(els)) {
+            None
+        } else if let ExprKind::Block(Block { stmts, expr: block_expr, .. }, _) = els.kind {
+            if stmts.len() == 1 && block_expr.is_none() || stmts.is_empty() && block_expr.is_some() {
+                // single statement/expr "else" block, don't lint
+                return;
+            }
+            // block with 2+ statements or 1 expr and 1+ statement
+            Some(els)
+        } else {
+            // not a block, don't lint
+            return;
+        };
+
+        let ty = cx.typeck_results().expr_ty(ex);
+        if *ty.kind() != ty::Bool || is_lint_allowed(cx, MATCH_BOOL, ex.hir_id) {
+            check_single_pattern(cx, ex, arms, expr, els);
+            check_opt_like(cx, ex, arms, expr, ty, els);
+        }
+    }
+}
+
+fn check_single_pattern(
+    cx: &LateContext<'_>,
+    ex: &Expr<'_>,
+    arms: &[Arm<'_>],
+    expr: &Expr<'_>,
+    els: Option<&Expr<'_>>,
+) {
+    if is_wild(arms[1].pat) {
+        report_single_pattern(cx, ex, arms, expr, els);
+    }
+}
+
+fn report_single_pattern(
+    cx: &LateContext<'_>,
+    ex: &Expr<'_>,
+    arms: &[Arm<'_>],
+    expr: &Expr<'_>,
+    els: Option<&Expr<'_>>,
+) {
+    let lint = if els.is_some() { SINGLE_MATCH_ELSE } else { SINGLE_MATCH };
+    let els_str = els.map_or(String::new(), |els| {
+        format!(" else {}", expr_block(cx, els, None, "..", Some(expr.span)))
+    });
+
+    let (pat, pat_ref_count) = peel_hir_pat_refs(arms[0].pat);
+    let (msg, sugg) = if_chain! {
+        if let PatKind::Path(_) | PatKind::Lit(_) = pat.kind;
+        let (ty, ty_ref_count) = peel_mid_ty_refs(cx.typeck_results().expr_ty(ex));
+        if let Some(spe_trait_id) = cx.tcx.lang_items().structural_peq_trait();
+        if let Some(pe_trait_id) = cx.tcx.lang_items().eq_trait();
+        if ty.is_integral() || ty.is_char() || ty.is_str()
+            || (implements_trait(cx, ty, spe_trait_id, &[])
+                && implements_trait(cx, ty, pe_trait_id, &[ty.into()]));
+        then {
+            // scrutinee derives PartialEq and the pattern is a constant.
+            let pat_ref_count = match pat.kind {
+                // string literals are already a reference.
+                PatKind::Lit(Expr { kind: ExprKind::Lit(lit), .. }) if lit.node.is_str() => pat_ref_count + 1,
+                _ => pat_ref_count,
+            };
+            // References are only implicitly added to the pattern, so no overflow here.
+            // e.g. will work: match &Some(_) { Some(_) => () }
+            // will not: match Some(_) { &Some(_) => () }
+            let ref_count_diff = ty_ref_count - pat_ref_count;
+
+            // Try to remove address of expressions first.
+            let (ex, removed) = peel_n_hir_expr_refs(ex, ref_count_diff);
+            let ref_count_diff = ref_count_diff - removed;
+
+            let msg = "you seem to be trying to use `match` for an equality check. Consider using `if`";
+            let sugg = format!(
+                "if {} == {}{} {}{}",
+                snippet(cx, ex.span, ".."),
+                // PartialEq for different reference counts may not exist.
+                "&".repeat(ref_count_diff),
+                snippet(cx, arms[0].pat.span, ".."),
+                expr_block(cx, arms[0].body, None, "..", Some(expr.span)),
+                els_str,
+            );
+            (msg, sugg)
+        } else {
+            let msg = "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`";
+            let sugg = format!(
+                "if let {} = {} {}{}",
+                snippet(cx, arms[0].pat.span, ".."),
+                snippet(cx, ex.span, ".."),
+                expr_block(cx, arms[0].body, None, "..", Some(expr.span)),
+                els_str,
+            );
+            (msg, sugg)
+        }
+    };
+
+    span_lint_and_sugg(
+        cx,
+        lint,
+        expr.span,
+        msg,
+        "try this",
+        sugg,
+        Applicability::HasPlaceholders,
+    );
+}
+
+fn check_opt_like<'a>(
+    cx: &LateContext<'a>,
+    ex: &Expr<'_>,
+    arms: &[Arm<'_>],
+    expr: &Expr<'_>,
+    ty: Ty<'a>,
+    els: Option<&Expr<'_>>,
+) {
+    // list of candidate `Enum`s we know will never get any more members
+    let candidates = &[
+        (&paths::COW, "Borrowed"),
+        (&paths::COW, "Cow::Borrowed"),
+        (&paths::COW, "Cow::Owned"),
+        (&paths::COW, "Owned"),
+        (&paths::OPTION, "None"),
+        (&paths::RESULT, "Err"),
+        (&paths::RESULT, "Ok"),
+    ];
+
+    // We want to suggest to exclude an arm that contains only wildcards or forms the exhaustive
+    // match with the second branch, without enum variants in matches.
+    if !contains_only_wilds(arms[1].pat) && !form_exhaustive_matches(arms[0].pat, arms[1].pat) {
+        return;
+    }
+
+    let mut paths_and_types = Vec::new();
+    if !collect_pat_paths(&mut paths_and_types, cx, arms[1].pat, ty) {
+        return;
+    }
+
+    let in_candidate_enum = |path_info: &(String, &TyS<'_>)| -> bool {
+        let (path, ty) = path_info;
+        for &(ty_path, pat_path) in candidates {
+            if path == pat_path && match_type(cx, ty, ty_path) {
+                return true;
+            }
+        }
+        false
+    };
+    if paths_and_types.iter().all(in_candidate_enum) {
+        report_single_pattern(cx, ex, arms, expr, els);
+    }
+}
+
+/// Collects paths and their types from the given patterns. Returns true if the given pattern could
+/// be simplified, false otherwise.
+fn collect_pat_paths<'a>(acc: &mut Vec<(String, Ty<'a>)>, cx: &LateContext<'a>, pat: &Pat<'_>, ty: Ty<'a>) -> bool {
+    match pat.kind {
+        PatKind::Wild => true,
+        PatKind::Tuple(inner, _) => inner.iter().all(|p| {
+            let p_ty = cx.typeck_results().pat_ty(p);
+            collect_pat_paths(acc, cx, p, p_ty)
+        }),
+        PatKind::TupleStruct(ref path, ..) => {
+            let path = rustc_hir_pretty::to_string(rustc_hir_pretty::NO_ANN, |s| {
+                s.print_qpath(path, false);
+            });
+            acc.push((path, ty));
+            true
+        },
+        PatKind::Binding(BindingAnnotation::Unannotated, .., ident, None) => {
+            acc.push((ident.to_string(), ty));
+            true
+        },
+        PatKind::Path(ref path) => {
+            let path = rustc_hir_pretty::to_string(rustc_hir_pretty::NO_ANN, |s| {
+                s.print_qpath(path, false);
+            });
+            acc.push((path, ty));
+            true
+        },
+        _ => false,
+    }
+}
+
+/// Returns true if the given arm of pattern matching contains wildcard patterns.
+fn contains_only_wilds(pat: &Pat<'_>) -> bool {
+    match pat.kind {
+        PatKind::Wild => true,
+        PatKind::Tuple(inner, _) | PatKind::TupleStruct(_, inner, ..) => inner.iter().all(contains_only_wilds),
+        _ => false,
+    }
+}
+
+/// Returns true if the given patterns forms only exhaustive matches that don't contain enum
+/// patterns without a wildcard.
+fn form_exhaustive_matches(left: &Pat<'_>, right: &Pat<'_>) -> bool {
+    match (&left.kind, &right.kind) {
+        (PatKind::Wild, _) | (_, PatKind::Wild) => true,
+        (PatKind::Tuple(left_in, left_pos), PatKind::Tuple(right_in, right_pos)) => {
+            // We don't actually know the position and the presence of the `..` (dotdot) operator
+            // in the arms, so we need to evaluate the correct offsets here in order to iterate in
+            // both arms at the same time.
+            let len = max(
+                left_in.len() + {
+                    if left_pos.is_some() { 1 } else { 0 }
+                },
+                right_in.len() + {
+                    if right_pos.is_some() { 1 } else { 0 }
+                },
+            );
+            let mut left_pos = left_pos.unwrap_or(usize::MAX);
+            let mut right_pos = right_pos.unwrap_or(usize::MAX);
+            let mut left_dot_space = 0;
+            let mut right_dot_space = 0;
+            for i in 0..len {
+                let mut found_dotdot = false;
+                if i == left_pos {
+                    left_dot_space += 1;
+                    if left_dot_space < len - left_in.len() {
+                        left_pos += 1;
+                    }
+                    found_dotdot = true;
+                }
+                if i == right_pos {
+                    right_dot_space += 1;
+                    if right_dot_space < len - right_in.len() {
+                        right_pos += 1;
+                    }
+                    found_dotdot = true;
+                }
+                if found_dotdot {
+                    continue;
+                }
+                if !contains_only_wilds(&left_in[i - left_dot_space])
+                    && !contains_only_wilds(&right_in[i - right_dot_space])
+                {
+                    return false;
+                }
+            }
+            true
+        },
+        _ => false,
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From f3dd909e0f2900420915f55a3f6cea6000b18cad Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sun, 6 Feb 2022 14:25:53 -0500
Subject: Split out `match_bool`

---
 clippy_lints/src/matches/match_bool.rs | 75 ++++++++++++++++++++++++++++++++++
 clippy_lints/src/matches/mod.rs        | 74 +++------------------------------
 2 files changed, 80 insertions(+), 69 deletions(-)
 create mode 100644 clippy_lints/src/matches/match_bool.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/match_bool.rs b/clippy_lints/src/matches/match_bool.rs
new file mode 100644
index 00000000000..90c50b994d2
--- /dev/null
+++ b/clippy_lints/src/matches/match_bool.rs
@@ -0,0 +1,75 @@
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::is_unit_expr;
+use clippy_utils::source::{expr_block, snippet};
+use clippy_utils::sugg::Sugg;
+use rustc_ast::LitKind;
+use rustc_errors::Applicability;
+use rustc_hir::{Arm, Expr, ExprKind, PatKind};
+use rustc_lint::LateContext;
+use rustc_middle::ty;
+
+use super::MATCH_BOOL;
+
+pub(crate) fn check(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>], expr: &Expr<'_>) {
+    // Type of expression is `bool`.
+    if *cx.typeck_results().expr_ty(ex).kind() == ty::Bool {
+        span_lint_and_then(
+            cx,
+            MATCH_BOOL,
+            expr.span,
+            "you seem to be trying to match on a boolean expression",
+            move |diag| {
+                if arms.len() == 2 {
+                    // no guards
+                    let exprs = if let PatKind::Lit(arm_bool) = arms[0].pat.kind {
+                        if let ExprKind::Lit(ref lit) = arm_bool.kind {
+                            match lit.node {
+                                LitKind::Bool(true) => Some((&*arms[0].body, &*arms[1].body)),
+                                LitKind::Bool(false) => Some((&*arms[1].body, &*arms[0].body)),
+                                _ => None,
+                            }
+                        } else {
+                            None
+                        }
+                    } else {
+                        None
+                    };
+
+                    if let Some((true_expr, false_expr)) = exprs {
+                        let sugg = match (is_unit_expr(true_expr), is_unit_expr(false_expr)) {
+                            (false, false) => Some(format!(
+                                "if {} {} else {}",
+                                snippet(cx, ex.span, "b"),
+                                expr_block(cx, true_expr, None, "..", Some(expr.span)),
+                                expr_block(cx, false_expr, None, "..", Some(expr.span))
+                            )),
+                            (false, true) => Some(format!(
+                                "if {} {}",
+                                snippet(cx, ex.span, "b"),
+                                expr_block(cx, true_expr, None, "..", Some(expr.span))
+                            )),
+                            (true, false) => {
+                                let test = Sugg::hir(cx, ex, "..");
+                                Some(format!(
+                                    "if {} {}",
+                                    !test,
+                                    expr_block(cx, false_expr, None, "..", Some(expr.span))
+                                ))
+                            },
+                            (true, true) => None,
+                        };
+
+                        if let Some(sugg) = sugg {
+                            diag.span_suggestion(
+                                expr.span,
+                                "consider using an `if`/`else` expression",
+                                sugg,
+                                Applicability::HasPlaceholders,
+                            );
+                        }
+                    }
+                }
+            },
+        );
+    }
+}
diff --git a/clippy_lints/src/matches/mod.rs b/clippy_lints/src/matches/mod.rs
index 5173102a9e5..4775e07d24b 100644
--- a/clippy_lints/src/matches/mod.rs
+++ b/clippy_lints/src/matches/mod.rs
@@ -4,17 +4,16 @@ use clippy_utils::diagnostics::{
 };
 use clippy_utils::macros::{is_panic, root_macro_call};
 use clippy_utils::peel_blocks_with_stmt;
-use clippy_utils::source::{expr_block, indent_of, snippet, snippet_block, snippet_opt, snippet_with_applicability};
+use clippy_utils::source::{indent_of, snippet, snippet_block, snippet_opt, snippet_with_applicability};
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::visitors::is_local_used;
 use clippy_utils::{
-    get_parent_expr, is_lang_ctor, is_refutable, is_unit_expr, is_wild, meets_msrv, msrvs, path_to_local_id,
-    peel_blocks, peel_hir_pat_refs, recurse_or_patterns, strip_pat_refs,
+    get_parent_expr, is_lang_ctor, is_refutable, is_wild, meets_msrv, msrvs, path_to_local_id, peel_blocks,
+    peel_hir_pat_refs, recurse_or_patterns, strip_pat_refs,
 };
 use core::iter::once;
 use if_chain::if_chain;
-use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::def::{CtorKind, DefKind, Res};
 use rustc_hir::LangItem::{OptionNone, OptionSome};
@@ -29,6 +28,7 @@ use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::{sym, symbol::kw, Span};
 use std::cmp::Ordering;
 
+mod match_bool;
 mod match_like_matches;
 mod match_same_arms;
 mod redundant_pattern_match;
@@ -631,7 +631,7 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
 
         if let ExprKind::Match(ex, arms, MatchSource::Normal) = expr.kind {
             single_match::check(cx, ex, arms, expr);
-            check_match_bool(cx, ex, arms, expr);
+            match_bool::check(cx, ex, arms, expr);
             check_overlapping_arms(cx, ex, arms);
             check_wild_err_arm(cx, ex, arms);
             check_wild_enum_match(cx, ex, arms);
@@ -710,70 +710,6 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
     extract_msrv_attr!(LateContext);
 }
 
-fn check_match_bool(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>], expr: &Expr<'_>) {
-    // Type of expression is `bool`.
-    if *cx.typeck_results().expr_ty(ex).kind() == ty::Bool {
-        span_lint_and_then(
-            cx,
-            MATCH_BOOL,
-            expr.span,
-            "you seem to be trying to match on a boolean expression",
-            move |diag| {
-                if arms.len() == 2 {
-                    // no guards
-                    let exprs = if let PatKind::Lit(arm_bool) = arms[0].pat.kind {
-                        if let ExprKind::Lit(ref lit) = arm_bool.kind {
-                            match lit.node {
-                                LitKind::Bool(true) => Some((&*arms[0].body, &*arms[1].body)),
-                                LitKind::Bool(false) => Some((&*arms[1].body, &*arms[0].body)),
-                                _ => None,
-                            }
-                        } else {
-                            None
-                        }
-                    } else {
-                        None
-                    };
-
-                    if let Some((true_expr, false_expr)) = exprs {
-                        let sugg = match (is_unit_expr(true_expr), is_unit_expr(false_expr)) {
-                            (false, false) => Some(format!(
-                                "if {} {} else {}",
-                                snippet(cx, ex.span, "b"),
-                                expr_block(cx, true_expr, None, "..", Some(expr.span)),
-                                expr_block(cx, false_expr, None, "..", Some(expr.span))
-                            )),
-                            (false, true) => Some(format!(
-                                "if {} {}",
-                                snippet(cx, ex.span, "b"),
-                                expr_block(cx, true_expr, None, "..", Some(expr.span))
-                            )),
-                            (true, false) => {
-                                let test = Sugg::hir(cx, ex, "..");
-                                Some(format!(
-                                    "if {} {}",
-                                    !test,
-                                    expr_block(cx, false_expr, None, "..", Some(expr.span))
-                                ))
-                            },
-                            (true, true) => None,
-                        };
-
-                        if let Some(sugg) = sugg {
-                            diag.span_suggestion(
-                                expr.span,
-                                "consider using an `if`/`else` expression",
-                                sugg,
-                                Applicability::HasPlaceholders,
-                            );
-                        }
-                    }
-                }
-            },
-        );
-    }
-}
-
 fn check_overlapping_arms<'tcx>(cx: &LateContext<'tcx>, ex: &'tcx Expr<'_>, arms: &'tcx [Arm<'_>]) {
     if arms.len() >= 2 && cx.typeck_results().expr_ty(ex).is_integral() {
         let ranges = all_ranges(cx, arms, cx.typeck_results().expr_ty(ex));
-- 
cgit 1.4.1-3-g733a5


From 2a70439ef080f9b0a2bf08d124035ac120c6e0ee Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sun, 6 Feb 2022 14:36:24 -0500
Subject: Split out `overlapping_arms`

---
 clippy_lints/src/matches/mod.rs              | 183 +--------------------------
 clippy_lints/src/matches/overlapping_arms.rs | 181 ++++++++++++++++++++++++++
 2 files changed, 186 insertions(+), 178 deletions(-)
 create mode 100644 clippy_lints/src/matches/overlapping_arms.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/mod.rs b/clippy_lints/src/matches/mod.rs
index 4775e07d24b..a7fc399bfe2 100644
--- a/clippy_lints/src/matches/mod.rs
+++ b/clippy_lints/src/matches/mod.rs
@@ -1,4 +1,3 @@
-use clippy_utils::consts::{constant, constant_full_int, miri_to_const, FullInt};
 use clippy_utils::diagnostics::{
     multispan_sugg, span_lint_and_help, span_lint_and_note, span_lint_and_sugg, span_lint_and_then,
 };
@@ -19,18 +18,18 @@ use rustc_hir::def::{CtorKind, DefKind, Res};
 use rustc_hir::LangItem::{OptionNone, OptionSome};
 use rustc_hir::{
     self as hir, Arm, BindingAnnotation, BorrowKind, Expr, ExprKind, Local, MatchSource, Mutability, Node, Pat,
-    PatKind, PathSegment, QPath, RangeEnd, TyKind,
+    PatKind, PathSegment, QPath, TyKind,
 };
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty::{self, Ty, VariantDef};
+use rustc_middle::ty::{self, VariantDef};
 use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::{sym, symbol::kw, Span};
-use std::cmp::Ordering;
+use rustc_span::{sym, symbol::kw};
 
 mod match_bool;
 mod match_like_matches;
 mod match_same_arms;
+mod overlapping_arms;
 mod redundant_pattern_match;
 mod single_match;
 
@@ -632,7 +631,7 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
         if let ExprKind::Match(ex, arms, MatchSource::Normal) = expr.kind {
             single_match::check(cx, ex, arms, expr);
             match_bool::check(cx, ex, arms, expr);
-            check_overlapping_arms(cx, ex, arms);
+            overlapping_arms::check(cx, ex, arms);
             check_wild_err_arm(cx, ex, arms);
             check_wild_enum_match(cx, ex, arms);
             check_match_as_ref(cx, ex, arms, expr);
@@ -710,24 +709,6 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
     extract_msrv_attr!(LateContext);
 }
 
-fn check_overlapping_arms<'tcx>(cx: &LateContext<'tcx>, ex: &'tcx Expr<'_>, arms: &'tcx [Arm<'_>]) {
-    if arms.len() >= 2 && cx.typeck_results().expr_ty(ex).is_integral() {
-        let ranges = all_ranges(cx, arms, cx.typeck_results().expr_ty(ex));
-        if !ranges.is_empty() {
-            if let Some((start, end)) = overlapping(&ranges) {
-                span_lint_and_note(
-                    cx,
-                    MATCH_OVERLAPPING_ARM,
-                    start.span,
-                    "some ranges overlap",
-                    Some(end.span),
-                    "overlaps with this",
-                );
-            }
-        }
-    }
-}
-
 fn check_wild_err_arm<'tcx>(cx: &LateContext<'tcx>, ex: &Expr<'tcx>, arms: &[Arm<'tcx>]) {
     let ex_ty = cx.typeck_results().expr_ty(ex).peel_refs();
     if is_type_diagnostic_item(cx, ex_ty, sym::Result) {
@@ -1219,59 +1200,6 @@ fn opt_parent_let<'a>(cx: &LateContext<'a>, ex: &Expr<'a>) -> Option<&'a Local<'
     None
 }
 
-/// Gets the ranges for each range pattern arm. Applies `ty` bounds for open ranges.
-fn all_ranges<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>], ty: Ty<'tcx>) -> Vec<SpannedRange<FullInt>> {
-    arms.iter()
-        .filter_map(|arm| {
-            if let Arm { pat, guard: None, .. } = *arm {
-                if let PatKind::Range(ref lhs, ref rhs, range_end) = pat.kind {
-                    let lhs_const = match lhs {
-                        Some(lhs) => constant(cx, cx.typeck_results(), lhs)?.0,
-                        None => miri_to_const(ty.numeric_min_val(cx.tcx)?)?,
-                    };
-                    let rhs_const = match rhs {
-                        Some(rhs) => constant(cx, cx.typeck_results(), rhs)?.0,
-                        None => miri_to_const(ty.numeric_max_val(cx.tcx)?)?,
-                    };
-
-                    let lhs_val = lhs_const.int_value(cx, ty)?;
-                    let rhs_val = rhs_const.int_value(cx, ty)?;
-
-                    let rhs_bound = match range_end {
-                        RangeEnd::Included => EndBound::Included(rhs_val),
-                        RangeEnd::Excluded => EndBound::Excluded(rhs_val),
-                    };
-                    return Some(SpannedRange {
-                        span: pat.span,
-                        node: (lhs_val, rhs_bound),
-                    });
-                }
-
-                if let PatKind::Lit(value) = pat.kind {
-                    let value = constant_full_int(cx, cx.typeck_results(), value)?;
-                    return Some(SpannedRange {
-                        span: pat.span,
-                        node: (value, EndBound::Included(value)),
-                    });
-                }
-            }
-            None
-        })
-        .collect()
-}
-
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-pub enum EndBound<T> {
-    Included(T),
-    Excluded(T),
-}
-
-#[derive(Debug, Eq, PartialEq)]
-struct SpannedRange<T> {
-    pub span: Span,
-    pub node: (T, EndBound<T>),
-}
-
 // Checks if arm has the form `None => None`
 fn is_none_arm(cx: &LateContext<'_>, arm: &Arm<'_>) -> bool {
     matches!(arm.pat.kind, PatKind::Path(ref qpath) if is_lang_ctor(cx, qpath, OptionNone))
@@ -1317,104 +1245,3 @@ where
     }
     ref_count > 1
 }
-
-fn overlapping<T>(ranges: &[SpannedRange<T>]) -> Option<(&SpannedRange<T>, &SpannedRange<T>)>
-where
-    T: Copy + Ord,
-{
-    #[derive(Copy, Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
-    enum BoundKind {
-        EndExcluded,
-        Start,
-        EndIncluded,
-    }
-
-    #[derive(Copy, Clone, Debug, Eq, PartialEq)]
-    struct RangeBound<'a, T>(T, BoundKind, &'a SpannedRange<T>);
-
-    impl<'a, T: Copy + Ord> PartialOrd for RangeBound<'a, T> {
-        fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-            Some(self.cmp(other))
-        }
-    }
-
-    impl<'a, T: Copy + Ord> Ord for RangeBound<'a, T> {
-        fn cmp(&self, RangeBound(other_value, other_kind, _): &Self) -> Ordering {
-            let RangeBound(self_value, self_kind, _) = *self;
-            (self_value, self_kind).cmp(&(*other_value, *other_kind))
-        }
-    }
-
-    let mut values = Vec::with_capacity(2 * ranges.len());
-
-    for r @ SpannedRange { node: (start, end), .. } in ranges {
-        values.push(RangeBound(*start, BoundKind::Start, r));
-        values.push(match end {
-            EndBound::Excluded(val) => RangeBound(*val, BoundKind::EndExcluded, r),
-            EndBound::Included(val) => RangeBound(*val, BoundKind::EndIncluded, r),
-        });
-    }
-
-    values.sort();
-
-    let mut started = vec![];
-
-    for RangeBound(_, kind, range) in values {
-        match kind {
-            BoundKind::Start => started.push(range),
-            BoundKind::EndExcluded | BoundKind::EndIncluded => {
-                let mut overlap = None;
-
-                while let Some(last_started) = started.pop() {
-                    if last_started == range {
-                        break;
-                    }
-                    overlap = Some(last_started);
-                }
-
-                if let Some(first_overlapping) = overlap {
-                    return Some((range, first_overlapping));
-                }
-            },
-        }
-    }
-
-    None
-}
-
-#[test]
-fn test_overlapping() {
-    use rustc_span::source_map::DUMMY_SP;
-
-    let sp = |s, e| SpannedRange {
-        span: DUMMY_SP,
-        node: (s, e),
-    };
-
-    assert_eq!(None, overlapping::<u8>(&[]));
-    assert_eq!(None, overlapping(&[sp(1, EndBound::Included(4))]));
-    assert_eq!(
-        None,
-        overlapping(&[sp(1, EndBound::Included(4)), sp(5, EndBound::Included(6))])
-    );
-    assert_eq!(
-        None,
-        overlapping(&[
-            sp(1, EndBound::Included(4)),
-            sp(5, EndBound::Included(6)),
-            sp(10, EndBound::Included(11))
-        ],)
-    );
-    assert_eq!(
-        Some((&sp(1, EndBound::Included(4)), &sp(3, EndBound::Included(6)))),
-        overlapping(&[sp(1, EndBound::Included(4)), sp(3, EndBound::Included(6))])
-    );
-    assert_eq!(
-        Some((&sp(5, EndBound::Included(6)), &sp(6, EndBound::Included(11)))),
-        overlapping(&[
-            sp(1, EndBound::Included(4)),
-            sp(5, EndBound::Included(6)),
-            sp(6, EndBound::Included(11))
-        ],)
-    );
-}
diff --git a/clippy_lints/src/matches/overlapping_arms.rs b/clippy_lints/src/matches/overlapping_arms.rs
new file mode 100644
index 00000000000..7e658126690
--- /dev/null
+++ b/clippy_lints/src/matches/overlapping_arms.rs
@@ -0,0 +1,181 @@
+use clippy_utils::consts::{constant, constant_full_int, miri_to_const, FullInt};
+use clippy_utils::diagnostics::span_lint_and_note;
+use core::cmp::Ordering;
+use rustc_hir::{Arm, Expr, PatKind, RangeEnd};
+use rustc_lint::LateContext;
+use rustc_middle::ty::Ty;
+use rustc_span::Span;
+
+use super::MATCH_OVERLAPPING_ARM;
+
+pub(crate) fn check<'tcx>(cx: &LateContext<'tcx>, ex: &'tcx Expr<'_>, arms: &'tcx [Arm<'_>]) {
+    if arms.len() >= 2 && cx.typeck_results().expr_ty(ex).is_integral() {
+        let ranges = all_ranges(cx, arms, cx.typeck_results().expr_ty(ex));
+        if !ranges.is_empty() {
+            if let Some((start, end)) = overlapping(&ranges) {
+                span_lint_and_note(
+                    cx,
+                    MATCH_OVERLAPPING_ARM,
+                    start.span,
+                    "some ranges overlap",
+                    Some(end.span),
+                    "overlaps with this",
+                );
+            }
+        }
+    }
+}
+
+/// Gets the ranges for each range pattern arm. Applies `ty` bounds for open ranges.
+fn all_ranges<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>], ty: Ty<'tcx>) -> Vec<SpannedRange<FullInt>> {
+    arms.iter()
+        .filter_map(|arm| {
+            if let Arm { pat, guard: None, .. } = *arm {
+                if let PatKind::Range(ref lhs, ref rhs, range_end) = pat.kind {
+                    let lhs_const = match lhs {
+                        Some(lhs) => constant(cx, cx.typeck_results(), lhs)?.0,
+                        None => miri_to_const(ty.numeric_min_val(cx.tcx)?)?,
+                    };
+                    let rhs_const = match rhs {
+                        Some(rhs) => constant(cx, cx.typeck_results(), rhs)?.0,
+                        None => miri_to_const(ty.numeric_max_val(cx.tcx)?)?,
+                    };
+
+                    let lhs_val = lhs_const.int_value(cx, ty)?;
+                    let rhs_val = rhs_const.int_value(cx, ty)?;
+
+                    let rhs_bound = match range_end {
+                        RangeEnd::Included => EndBound::Included(rhs_val),
+                        RangeEnd::Excluded => EndBound::Excluded(rhs_val),
+                    };
+                    return Some(SpannedRange {
+                        span: pat.span,
+                        node: (lhs_val, rhs_bound),
+                    });
+                }
+
+                if let PatKind::Lit(value) = pat.kind {
+                    let value = constant_full_int(cx, cx.typeck_results(), value)?;
+                    return Some(SpannedRange {
+                        span: pat.span,
+                        node: (value, EndBound::Included(value)),
+                    });
+                }
+            }
+            None
+        })
+        .collect()
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum EndBound<T> {
+    Included(T),
+    Excluded(T),
+}
+
+#[derive(Debug, Eq, PartialEq)]
+struct SpannedRange<T> {
+    pub span: Span,
+    pub node: (T, EndBound<T>),
+}
+
+fn overlapping<T>(ranges: &[SpannedRange<T>]) -> Option<(&SpannedRange<T>, &SpannedRange<T>)>
+where
+    T: Copy + Ord,
+{
+    #[derive(Copy, Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
+    enum BoundKind {
+        EndExcluded,
+        Start,
+        EndIncluded,
+    }
+
+    #[derive(Copy, Clone, Debug, Eq, PartialEq)]
+    struct RangeBound<'a, T>(T, BoundKind, &'a SpannedRange<T>);
+
+    impl<'a, T: Copy + Ord> PartialOrd for RangeBound<'a, T> {
+        fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+            Some(self.cmp(other))
+        }
+    }
+
+    impl<'a, T: Copy + Ord> Ord for RangeBound<'a, T> {
+        fn cmp(&self, RangeBound(other_value, other_kind, _): &Self) -> Ordering {
+            let RangeBound(self_value, self_kind, _) = *self;
+            (self_value, self_kind).cmp(&(*other_value, *other_kind))
+        }
+    }
+
+    let mut values = Vec::with_capacity(2 * ranges.len());
+
+    for r @ SpannedRange { node: (start, end), .. } in ranges {
+        values.push(RangeBound(*start, BoundKind::Start, r));
+        values.push(match end {
+            EndBound::Excluded(val) => RangeBound(*val, BoundKind::EndExcluded, r),
+            EndBound::Included(val) => RangeBound(*val, BoundKind::EndIncluded, r),
+        });
+    }
+
+    values.sort();
+
+    let mut started = vec![];
+
+    for RangeBound(_, kind, range) in values {
+        match kind {
+            BoundKind::Start => started.push(range),
+            BoundKind::EndExcluded | BoundKind::EndIncluded => {
+                let mut overlap = None;
+
+                while let Some(last_started) = started.pop() {
+                    if last_started == range {
+                        break;
+                    }
+                    overlap = Some(last_started);
+                }
+
+                if let Some(first_overlapping) = overlap {
+                    return Some((range, first_overlapping));
+                }
+            },
+        }
+    }
+
+    None
+}
+
+#[test]
+fn test_overlapping() {
+    use rustc_span::source_map::DUMMY_SP;
+
+    let sp = |s, e| SpannedRange {
+        span: DUMMY_SP,
+        node: (s, e),
+    };
+
+    assert_eq!(None, overlapping::<u8>(&[]));
+    assert_eq!(None, overlapping(&[sp(1, EndBound::Included(4))]));
+    assert_eq!(
+        None,
+        overlapping(&[sp(1, EndBound::Included(4)), sp(5, EndBound::Included(6))])
+    );
+    assert_eq!(
+        None,
+        overlapping(&[
+            sp(1, EndBound::Included(4)),
+            sp(5, EndBound::Included(6)),
+            sp(10, EndBound::Included(11))
+        ],)
+    );
+    assert_eq!(
+        Some((&sp(1, EndBound::Included(4)), &sp(3, EndBound::Included(6)))),
+        overlapping(&[sp(1, EndBound::Included(4)), sp(3, EndBound::Included(6))])
+    );
+    assert_eq!(
+        Some((&sp(5, EndBound::Included(6)), &sp(6, EndBound::Included(11)))),
+        overlapping(&[
+            sp(1, EndBound::Included(4)),
+            sp(5, EndBound::Included(6)),
+            sp(6, EndBound::Included(11))
+        ],)
+    );
+}
-- 
cgit 1.4.1-3-g733a5


From dc75695e973d608903e1860db45b950b1a4cd470 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sun, 6 Feb 2022 16:08:05 -0500
Subject: Split out `match_wild_err_arm`

---
 clippy_lints/src/matches/match_wild_err_arm.rs | 51 +++++++++++++++++++++++++
 clippy_lints/src/matches/mod.rs                | 53 ++------------------------
 2 files changed, 55 insertions(+), 49 deletions(-)
 create mode 100644 clippy_lints/src/matches/match_wild_err_arm.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/match_wild_err_arm.rs b/clippy_lints/src/matches/match_wild_err_arm.rs
new file mode 100644
index 00000000000..bc16f17b619
--- /dev/null
+++ b/clippy_lints/src/matches/match_wild_err_arm.rs
@@ -0,0 +1,51 @@
+use clippy_utils::diagnostics::span_lint_and_note;
+use clippy_utils::macros::{is_panic, root_macro_call};
+use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::visitors::is_local_used;
+use clippy_utils::{is_wild, peel_blocks_with_stmt};
+use rustc_hir::{Arm, Expr, PatKind};
+use rustc_lint::LateContext;
+use rustc_span::symbol::{kw, sym};
+
+use super::MATCH_WILD_ERR_ARM;
+
+pub(crate) fn check<'tcx>(cx: &LateContext<'tcx>, ex: &Expr<'tcx>, arms: &[Arm<'tcx>]) {
+    let ex_ty = cx.typeck_results().expr_ty(ex).peel_refs();
+    if is_type_diagnostic_item(cx, ex_ty, sym::Result) {
+        for arm in arms {
+            if let PatKind::TupleStruct(ref path, inner, _) = arm.pat.kind {
+                let path_str = rustc_hir_pretty::to_string(rustc_hir_pretty::NO_ANN, |s| s.print_qpath(path, false));
+                if path_str == "Err" {
+                    let mut matching_wild = inner.iter().any(is_wild);
+                    let mut ident_bind_name = kw::Underscore;
+                    if !matching_wild {
+                        // Looking for unused bindings (i.e.: `_e`)
+                        for pat in inner.iter() {
+                            if let PatKind::Binding(_, id, ident, None) = pat.kind {
+                                if ident.as_str().starts_with('_') && !is_local_used(cx, arm.body, id) {
+                                    ident_bind_name = ident.name;
+                                    matching_wild = true;
+                                }
+                            }
+                        }
+                    }
+                    if_chain! {
+                        if matching_wild;
+                        if let Some(macro_call) = root_macro_call(peel_blocks_with_stmt(arm.body).span);
+                        if is_panic(cx, macro_call.def_id);
+                        then {
+                            // `Err(_)` or `Err(_e)` arm with `panic!` found
+                            span_lint_and_note(cx,
+                                MATCH_WILD_ERR_ARM,
+                                arm.pat.span,
+                                &format!("`Err({})` matches all errors", ident_bind_name),
+                                None,
+                                "match each error separately or use the error output, or use `.except(msg)` if the error case is unreachable",
+                            );
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/clippy_lints/src/matches/mod.rs b/clippy_lints/src/matches/mod.rs
index a7fc399bfe2..e2a103c58d1 100644
--- a/clippy_lints/src/matches/mod.rs
+++ b/clippy_lints/src/matches/mod.rs
@@ -1,12 +1,7 @@
-use clippy_utils::diagnostics::{
-    multispan_sugg, span_lint_and_help, span_lint_and_note, span_lint_and_sugg, span_lint_and_then,
-};
-use clippy_utils::macros::{is_panic, root_macro_call};
-use clippy_utils::peel_blocks_with_stmt;
+use clippy_utils::diagnostics::{multispan_sugg, span_lint_and_help, span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::{indent_of, snippet, snippet_block, snippet_opt, snippet_with_applicability};
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::visitors::is_local_used;
 use clippy_utils::{
     get_parent_expr, is_lang_ctor, is_refutable, is_wild, meets_msrv, msrvs, path_to_local_id, peel_blocks,
     peel_hir_pat_refs, recurse_or_patterns, strip_pat_refs,
@@ -24,11 +19,12 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{self, VariantDef};
 use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::{sym, symbol::kw};
+use rustc_span::sym;
 
 mod match_bool;
 mod match_like_matches;
 mod match_same_arms;
+mod match_wild_err_arm;
 mod overlapping_arms;
 mod redundant_pattern_match;
 mod single_match;
@@ -632,7 +628,7 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
             single_match::check(cx, ex, arms, expr);
             match_bool::check(cx, ex, arms, expr);
             overlapping_arms::check(cx, ex, arms);
-            check_wild_err_arm(cx, ex, arms);
+            match_wild_err_arm::check(cx, ex, arms);
             check_wild_enum_match(cx, ex, arms);
             check_match_as_ref(cx, ex, arms, expr);
             check_wild_in_or_pats(cx, arms);
@@ -709,47 +705,6 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
     extract_msrv_attr!(LateContext);
 }
 
-fn check_wild_err_arm<'tcx>(cx: &LateContext<'tcx>, ex: &Expr<'tcx>, arms: &[Arm<'tcx>]) {
-    let ex_ty = cx.typeck_results().expr_ty(ex).peel_refs();
-    if is_type_diagnostic_item(cx, ex_ty, sym::Result) {
-        for arm in arms {
-            if let PatKind::TupleStruct(ref path, inner, _) = arm.pat.kind {
-                let path_str = rustc_hir_pretty::to_string(rustc_hir_pretty::NO_ANN, |s| s.print_qpath(path, false));
-                if path_str == "Err" {
-                    let mut matching_wild = inner.iter().any(is_wild);
-                    let mut ident_bind_name = kw::Underscore;
-                    if !matching_wild {
-                        // Looking for unused bindings (i.e.: `_e`)
-                        for pat in inner.iter() {
-                            if let PatKind::Binding(_, id, ident, None) = pat.kind {
-                                if ident.as_str().starts_with('_') && !is_local_used(cx, arm.body, id) {
-                                    ident_bind_name = ident.name;
-                                    matching_wild = true;
-                                }
-                            }
-                        }
-                    }
-                    if_chain! {
-                        if matching_wild;
-                        if let Some(macro_call) = root_macro_call(peel_blocks_with_stmt(arm.body).span);
-                        if is_panic(cx, macro_call.def_id);
-                        then {
-                            // `Err(_)` or `Err(_e)` arm with `panic!` found
-                            span_lint_and_note(cx,
-                                MATCH_WILD_ERR_ARM,
-                                arm.pat.span,
-                                &format!("`Err({})` matches all errors", ident_bind_name),
-                                None,
-                                "match each error separately or use the error output, or use `.except(msg)` if the error case is unreachable",
-                            );
-                        }
-                    }
-                }
-            }
-        }
-    }
-}
-
 enum CommonPrefixSearcher<'a> {
     None,
     Path(&'a [PathSegment<'a>]),
-- 
cgit 1.4.1-3-g733a5


From 75923dff5baa8de3acdec3026aac487033fe68fe Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sun, 6 Feb 2022 16:18:05 -0500
Subject: Split out `wildcard_enum_match_arm` and
 `match_wildcard_for_single_variants`

---
 clippy_lints/src/matches/match_wild_enum.rs | 198 +++++++++++++++++++++++++++
 clippy_lints/src/matches/mod.rs             | 200 +---------------------------
 2 files changed, 203 insertions(+), 195 deletions(-)
 create mode 100644 clippy_lints/src/matches/match_wild_enum.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/match_wild_enum.rs b/clippy_lints/src/matches/match_wild_enum.rs
new file mode 100644
index 00000000000..3515286d5b4
--- /dev/null
+++ b/clippy_lints/src/matches/match_wild_enum.rs
@@ -0,0 +1,198 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::{is_refutable, peel_hir_pat_refs, recurse_or_patterns};
+use rustc_errors::Applicability;
+use rustc_hir::def::{CtorKind, DefKind, Res};
+use rustc_hir::{Arm, Expr, PatKind, PathSegment, QPath, Ty, TyKind};
+use rustc_lint::LateContext;
+use rustc_middle::ty::{self, VariantDef};
+use rustc_span::sym;
+
+use super::{MATCH_WILDCARD_FOR_SINGLE_VARIANTS, WILDCARD_ENUM_MATCH_ARM};
+
+#[allow(clippy::too_many_lines)]
+pub(crate) fn check(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>]) {
+    let ty = cx.typeck_results().expr_ty(ex).peel_refs();
+    let adt_def = match ty.kind() {
+        ty::Adt(adt_def, _)
+            if adt_def.is_enum()
+                && !(is_type_diagnostic_item(cx, ty, sym::Option) || is_type_diagnostic_item(cx, ty, sym::Result)) =>
+        {
+            adt_def
+        },
+        _ => return,
+    };
+
+    // First pass - check for violation, but don't do much book-keeping because this is hopefully
+    // the uncommon case, and the book-keeping is slightly expensive.
+    let mut wildcard_span = None;
+    let mut wildcard_ident = None;
+    let mut has_non_wild = false;
+    for arm in arms {
+        match peel_hir_pat_refs(arm.pat).0.kind {
+            PatKind::Wild => wildcard_span = Some(arm.pat.span),
+            PatKind::Binding(_, _, ident, None) => {
+                wildcard_span = Some(arm.pat.span);
+                wildcard_ident = Some(ident);
+            },
+            _ => has_non_wild = true,
+        }
+    }
+    let wildcard_span = match wildcard_span {
+        Some(x) if has_non_wild => x,
+        _ => return,
+    };
+
+    // Accumulate the variants which should be put in place of the wildcard because they're not
+    // already covered.
+    let has_hidden = adt_def.variants.iter().any(|x| is_hidden(cx, x));
+    let mut missing_variants: Vec<_> = adt_def.variants.iter().filter(|x| !is_hidden(cx, x)).collect();
+
+    let mut path_prefix = CommonPrefixSearcher::None;
+    for arm in arms {
+        // Guards mean that this case probably isn't exhaustively covered. Technically
+        // this is incorrect, as we should really check whether each variant is exhaustively
+        // covered by the set of guards that cover it, but that's really hard to do.
+        recurse_or_patterns(arm.pat, |pat| {
+            let path = match &peel_hir_pat_refs(pat).0.kind {
+                PatKind::Path(path) => {
+                    #[allow(clippy::match_same_arms)]
+                    let id = match cx.qpath_res(path, pat.hir_id) {
+                        Res::Def(
+                            DefKind::Const | DefKind::ConstParam | DefKind::AnonConst | DefKind::InlineConst,
+                            _,
+                        ) => return,
+                        Res::Def(_, id) => id,
+                        _ => return,
+                    };
+                    if arm.guard.is_none() {
+                        missing_variants.retain(|e| e.ctor_def_id != Some(id));
+                    }
+                    path
+                },
+                PatKind::TupleStruct(path, patterns, ..) => {
+                    if let Some(id) = cx.qpath_res(path, pat.hir_id).opt_def_id() {
+                        if arm.guard.is_none() && patterns.iter().all(|p| !is_refutable(cx, p)) {
+                            missing_variants.retain(|e| e.ctor_def_id != Some(id));
+                        }
+                    }
+                    path
+                },
+                PatKind::Struct(path, patterns, ..) => {
+                    if let Some(id) = cx.qpath_res(path, pat.hir_id).opt_def_id() {
+                        if arm.guard.is_none() && patterns.iter().all(|p| !is_refutable(cx, p.pat)) {
+                            missing_variants.retain(|e| e.def_id != id);
+                        }
+                    }
+                    path
+                },
+                _ => return,
+            };
+            match path {
+                QPath::Resolved(_, path) => path_prefix.with_path(path.segments),
+                QPath::TypeRelative(
+                    Ty {
+                        kind: TyKind::Path(QPath::Resolved(_, path)),
+                        ..
+                    },
+                    _,
+                ) => path_prefix.with_prefix(path.segments),
+                _ => (),
+            }
+        });
+    }
+
+    let format_suggestion = |variant: &VariantDef| {
+        format!(
+            "{}{}{}{}",
+            if let Some(ident) = wildcard_ident {
+                format!("{} @ ", ident.name)
+            } else {
+                String::new()
+            },
+            if let CommonPrefixSearcher::Path(path_prefix) = path_prefix {
+                let mut s = String::new();
+                for seg in path_prefix {
+                    s.push_str(seg.ident.as_str());
+                    s.push_str("::");
+                }
+                s
+            } else {
+                let mut s = cx.tcx.def_path_str(adt_def.did);
+                s.push_str("::");
+                s
+            },
+            variant.name,
+            match variant.ctor_kind {
+                CtorKind::Fn if variant.fields.len() == 1 => "(_)",
+                CtorKind::Fn => "(..)",
+                CtorKind::Const => "",
+                CtorKind::Fictive => "{ .. }",
+            }
+        )
+    };
+
+    match missing_variants.as_slice() {
+        [] => (),
+        [x] if !adt_def.is_variant_list_non_exhaustive() && !has_hidden => span_lint_and_sugg(
+            cx,
+            MATCH_WILDCARD_FOR_SINGLE_VARIANTS,
+            wildcard_span,
+            "wildcard matches only a single variant and will also match any future added variants",
+            "try this",
+            format_suggestion(x),
+            Applicability::MaybeIncorrect,
+        ),
+        variants => {
+            let mut suggestions: Vec<_> = variants.iter().copied().map(format_suggestion).collect();
+            let message = if adt_def.is_variant_list_non_exhaustive() || has_hidden {
+                suggestions.push("_".into());
+                "wildcard matches known variants and will also match future added variants"
+            } else {
+                "wildcard match will also match any future added variants"
+            };
+
+            span_lint_and_sugg(
+                cx,
+                WILDCARD_ENUM_MATCH_ARM,
+                wildcard_span,
+                message,
+                "try this",
+                suggestions.join(" | "),
+                Applicability::MaybeIncorrect,
+            );
+        },
+    };
+}
+
+enum CommonPrefixSearcher<'a> {
+    None,
+    Path(&'a [PathSegment<'a>]),
+    Mixed,
+}
+impl<'a> CommonPrefixSearcher<'a> {
+    fn with_path(&mut self, path: &'a [PathSegment<'a>]) {
+        match path {
+            [path @ .., _] => self.with_prefix(path),
+            [] => (),
+        }
+    }
+
+    fn with_prefix(&mut self, path: &'a [PathSegment<'a>]) {
+        match self {
+            Self::None => *self = Self::Path(path),
+            Self::Path(self_path)
+                if path
+                    .iter()
+                    .map(|p| p.ident.name)
+                    .eq(self_path.iter().map(|p| p.ident.name)) => {},
+            Self::Path(_) => *self = Self::Mixed,
+            Self::Mixed => (),
+        }
+    }
+}
+
+fn is_hidden(cx: &LateContext<'_>, variant_def: &VariantDef) -> bool {
+    let attrs = cx.tcx.get_attrs(variant_def.def_id);
+    clippy_utils::attrs::is_doc_hidden(attrs) || clippy_utils::attrs::is_unstable(attrs)
+}
diff --git a/clippy_lints/src/matches/mod.rs b/clippy_lints/src/matches/mod.rs
index e2a103c58d1..8c67380ed52 100644
--- a/clippy_lints/src/matches/mod.rs
+++ b/clippy_lints/src/matches/mod.rs
@@ -1,29 +1,26 @@
 use clippy_utils::diagnostics::{multispan_sugg, span_lint_and_help, span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::{indent_of, snippet, snippet_block, snippet_opt, snippet_with_applicability};
 use clippy_utils::sugg::Sugg;
-use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::{
     get_parent_expr, is_lang_ctor, is_refutable, is_wild, meets_msrv, msrvs, path_to_local_id, peel_blocks,
-    peel_hir_pat_refs, recurse_or_patterns, strip_pat_refs,
+    strip_pat_refs,
 };
 use core::iter::once;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
-use rustc_hir::def::{CtorKind, DefKind, Res};
 use rustc_hir::LangItem::{OptionNone, OptionSome};
 use rustc_hir::{
-    self as hir, Arm, BindingAnnotation, BorrowKind, Expr, ExprKind, Local, MatchSource, Mutability, Node, Pat,
-    PatKind, PathSegment, QPath, TyKind,
+    Arm, BindingAnnotation, BorrowKind, Expr, ExprKind, Local, MatchSource, Mutability, Node, Pat, PatKind, QPath,
 };
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty::{self, VariantDef};
+use rustc_middle::ty;
 use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::sym;
 
 mod match_bool;
 mod match_like_matches;
 mod match_same_arms;
+mod match_wild_enum;
 mod match_wild_err_arm;
 mod overlapping_arms;
 mod redundant_pattern_match;
@@ -629,7 +626,7 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
             match_bool::check(cx, ex, arms, expr);
             overlapping_arms::check(cx, ex, arms);
             match_wild_err_arm::check(cx, ex, arms);
-            check_wild_enum_match(cx, ex, arms);
+            match_wild_enum::check(cx, ex, arms);
             check_match_as_ref(cx, ex, arms, expr);
             check_wild_in_or_pats(cx, arms);
 
@@ -705,193 +702,6 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
     extract_msrv_attr!(LateContext);
 }
 
-enum CommonPrefixSearcher<'a> {
-    None,
-    Path(&'a [PathSegment<'a>]),
-    Mixed,
-}
-impl<'a> CommonPrefixSearcher<'a> {
-    fn with_path(&mut self, path: &'a [PathSegment<'a>]) {
-        match path {
-            [path @ .., _] => self.with_prefix(path),
-            [] => (),
-        }
-    }
-
-    fn with_prefix(&mut self, path: &'a [PathSegment<'a>]) {
-        match self {
-            Self::None => *self = Self::Path(path),
-            Self::Path(self_path)
-                if path
-                    .iter()
-                    .map(|p| p.ident.name)
-                    .eq(self_path.iter().map(|p| p.ident.name)) => {},
-            Self::Path(_) => *self = Self::Mixed,
-            Self::Mixed => (),
-        }
-    }
-}
-
-fn is_hidden(cx: &LateContext<'_>, variant_def: &VariantDef) -> bool {
-    let attrs = cx.tcx.get_attrs(variant_def.def_id);
-    clippy_utils::attrs::is_doc_hidden(attrs) || clippy_utils::attrs::is_unstable(attrs)
-}
-
-#[allow(clippy::too_many_lines)]
-fn check_wild_enum_match(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>]) {
-    let ty = cx.typeck_results().expr_ty(ex).peel_refs();
-    let adt_def = match ty.kind() {
-        ty::Adt(adt_def, _)
-            if adt_def.is_enum()
-                && !(is_type_diagnostic_item(cx, ty, sym::Option) || is_type_diagnostic_item(cx, ty, sym::Result)) =>
-        {
-            adt_def
-        },
-        _ => return,
-    };
-
-    // First pass - check for violation, but don't do much book-keeping because this is hopefully
-    // the uncommon case, and the book-keeping is slightly expensive.
-    let mut wildcard_span = None;
-    let mut wildcard_ident = None;
-    let mut has_non_wild = false;
-    for arm in arms {
-        match peel_hir_pat_refs(arm.pat).0.kind {
-            PatKind::Wild => wildcard_span = Some(arm.pat.span),
-            PatKind::Binding(_, _, ident, None) => {
-                wildcard_span = Some(arm.pat.span);
-                wildcard_ident = Some(ident);
-            },
-            _ => has_non_wild = true,
-        }
-    }
-    let wildcard_span = match wildcard_span {
-        Some(x) if has_non_wild => x,
-        _ => return,
-    };
-
-    // Accumulate the variants which should be put in place of the wildcard because they're not
-    // already covered.
-    let has_hidden = adt_def.variants.iter().any(|x| is_hidden(cx, x));
-    let mut missing_variants: Vec<_> = adt_def.variants.iter().filter(|x| !is_hidden(cx, x)).collect();
-
-    let mut path_prefix = CommonPrefixSearcher::None;
-    for arm in arms {
-        // Guards mean that this case probably isn't exhaustively covered. Technically
-        // this is incorrect, as we should really check whether each variant is exhaustively
-        // covered by the set of guards that cover it, but that's really hard to do.
-        recurse_or_patterns(arm.pat, |pat| {
-            let path = match &peel_hir_pat_refs(pat).0.kind {
-                PatKind::Path(path) => {
-                    #[allow(clippy::match_same_arms)]
-                    let id = match cx.qpath_res(path, pat.hir_id) {
-                        Res::Def(
-                            DefKind::Const | DefKind::ConstParam | DefKind::AnonConst | DefKind::InlineConst,
-                            _,
-                        ) => return,
-                        Res::Def(_, id) => id,
-                        _ => return,
-                    };
-                    if arm.guard.is_none() {
-                        missing_variants.retain(|e| e.ctor_def_id != Some(id));
-                    }
-                    path
-                },
-                PatKind::TupleStruct(path, patterns, ..) => {
-                    if let Some(id) = cx.qpath_res(path, pat.hir_id).opt_def_id() {
-                        if arm.guard.is_none() && patterns.iter().all(|p| !is_refutable(cx, p)) {
-                            missing_variants.retain(|e| e.ctor_def_id != Some(id));
-                        }
-                    }
-                    path
-                },
-                PatKind::Struct(path, patterns, ..) => {
-                    if let Some(id) = cx.qpath_res(path, pat.hir_id).opt_def_id() {
-                        if arm.guard.is_none() && patterns.iter().all(|p| !is_refutable(cx, p.pat)) {
-                            missing_variants.retain(|e| e.def_id != id);
-                        }
-                    }
-                    path
-                },
-                _ => return,
-            };
-            match path {
-                QPath::Resolved(_, path) => path_prefix.with_path(path.segments),
-                QPath::TypeRelative(
-                    hir::Ty {
-                        kind: TyKind::Path(QPath::Resolved(_, path)),
-                        ..
-                    },
-                    _,
-                ) => path_prefix.with_prefix(path.segments),
-                _ => (),
-            }
-        });
-    }
-
-    let format_suggestion = |variant: &VariantDef| {
-        format!(
-            "{}{}{}{}",
-            if let Some(ident) = wildcard_ident {
-                format!("{} @ ", ident.name)
-            } else {
-                String::new()
-            },
-            if let CommonPrefixSearcher::Path(path_prefix) = path_prefix {
-                let mut s = String::new();
-                for seg in path_prefix {
-                    s.push_str(seg.ident.as_str());
-                    s.push_str("::");
-                }
-                s
-            } else {
-                let mut s = cx.tcx.def_path_str(adt_def.did);
-                s.push_str("::");
-                s
-            },
-            variant.name,
-            match variant.ctor_kind {
-                CtorKind::Fn if variant.fields.len() == 1 => "(_)",
-                CtorKind::Fn => "(..)",
-                CtorKind::Const => "",
-                CtorKind::Fictive => "{ .. }",
-            }
-        )
-    };
-
-    match missing_variants.as_slice() {
-        [] => (),
-        [x] if !adt_def.is_variant_list_non_exhaustive() && !has_hidden => span_lint_and_sugg(
-            cx,
-            MATCH_WILDCARD_FOR_SINGLE_VARIANTS,
-            wildcard_span,
-            "wildcard matches only a single variant and will also match any future added variants",
-            "try this",
-            format_suggestion(x),
-            Applicability::MaybeIncorrect,
-        ),
-        variants => {
-            let mut suggestions: Vec<_> = variants.iter().copied().map(format_suggestion).collect();
-            let message = if adt_def.is_variant_list_non_exhaustive() || has_hidden {
-                suggestions.push("_".into());
-                "wildcard matches known variants and will also match future added variants"
-            } else {
-                "wildcard match will also match any future added variants"
-            };
-
-            span_lint_and_sugg(
-                cx,
-                WILDCARD_ENUM_MATCH_ARM,
-                wildcard_span,
-                message,
-                "try this",
-                suggestions.join(" | "),
-                Applicability::MaybeIncorrect,
-            );
-        },
-    };
-}
-
 fn check_match_ref_pats<'a, 'b, I>(cx: &LateContext<'_>, ex: &Expr<'_>, pats: I, expr: &Expr<'_>)
 where
     'b: 'a,
-- 
cgit 1.4.1-3-g733a5


From bccf06f60184cedc780e3936799d2aa63cf28b7e Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sun, 6 Feb 2022 16:24:14 -0500
Subject: Split out `match_as_ref`

---
 clippy_lints/src/matches/match_as_ref.rs | 85 +++++++++++++++++++++++++++++++
 clippy_lints/src/matches/mod.rs          | 87 ++------------------------------
 2 files changed, 89 insertions(+), 83 deletions(-)
 create mode 100644 clippy_lints/src/matches/match_as_ref.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/match_as_ref.rs b/clippy_lints/src/matches/match_as_ref.rs
new file mode 100644
index 00000000000..d914eba0171
--- /dev/null
+++ b/clippy_lints/src/matches/match_as_ref.rs
@@ -0,0 +1,85 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::{is_lang_ctor, peel_blocks};
+use rustc_errors::Applicability;
+use rustc_hir::{Arm, BindingAnnotation, Expr, ExprKind, LangItem, PatKind, QPath};
+use rustc_lint::LateContext;
+use rustc_middle::ty;
+
+use super::MATCH_AS_REF;
+
+pub(crate) fn check(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>], expr: &Expr<'_>) {
+    if arms.len() == 2 && arms[0].guard.is_none() && arms[1].guard.is_none() {
+        let arm_ref: Option<BindingAnnotation> = if is_none_arm(cx, &arms[0]) {
+            is_ref_some_arm(cx, &arms[1])
+        } else if is_none_arm(cx, &arms[1]) {
+            is_ref_some_arm(cx, &arms[0])
+        } else {
+            None
+        };
+        if let Some(rb) = arm_ref {
+            let suggestion = if rb == BindingAnnotation::Ref {
+                "as_ref"
+            } else {
+                "as_mut"
+            };
+
+            let output_ty = cx.typeck_results().expr_ty(expr);
+            let input_ty = cx.typeck_results().expr_ty(ex);
+
+            let cast = if_chain! {
+                if let ty::Adt(_, substs) = input_ty.kind();
+                let input_ty = substs.type_at(0);
+                if let ty::Adt(_, substs) = output_ty.kind();
+                let output_ty = substs.type_at(0);
+                if let ty::Ref(_, output_ty, _) = *output_ty.kind();
+                if input_ty != output_ty;
+                then {
+                    ".map(|x| x as _)"
+                } else {
+                    ""
+                }
+            };
+
+            let mut applicability = Applicability::MachineApplicable;
+            span_lint_and_sugg(
+                cx,
+                MATCH_AS_REF,
+                expr.span,
+                &format!("use `{}()` instead", suggestion),
+                "try this",
+                format!(
+                    "{}.{}(){}",
+                    snippet_with_applicability(cx, ex.span, "_", &mut applicability),
+                    suggestion,
+                    cast,
+                ),
+                applicability,
+            );
+        }
+    }
+}
+
+// Checks if arm has the form `None => None`
+fn is_none_arm(cx: &LateContext<'_>, arm: &Arm<'_>) -> bool {
+    matches!(arm.pat.kind, PatKind::Path(ref qpath) if is_lang_ctor(cx, qpath, LangItem::OptionNone))
+}
+
+// Checks if arm has the form `Some(ref v) => Some(v)` (checks for `ref` and `ref mut`)
+fn is_ref_some_arm(cx: &LateContext<'_>, arm: &Arm<'_>) -> Option<BindingAnnotation> {
+    if_chain! {
+        if let PatKind::TupleStruct(ref qpath, [first_pat, ..], _) = arm.pat.kind;
+        if is_lang_ctor(cx, qpath, LangItem::OptionSome);
+        if let PatKind::Binding(rb, .., ident, _) = first_pat.kind;
+        if rb == BindingAnnotation::Ref || rb == BindingAnnotation::RefMut;
+        if let ExprKind::Call(e, args) = peel_blocks(arm.body).kind;
+        if let ExprKind::Path(ref some_path) = e.kind;
+        if is_lang_ctor(cx, some_path, LangItem::OptionSome) && args.len() == 1;
+        if let ExprKind::Path(QPath::Resolved(_, path2)) = args[0].kind;
+        if path2.segments.len() == 1 && ident.name == path2.segments[0].ident.name;
+        then {
+            return Some(rb)
+        }
+    }
+    None
+}
diff --git a/clippy_lints/src/matches/mod.rs b/clippy_lints/src/matches/mod.rs
index 8c67380ed52..b48cdcb7d71 100644
--- a/clippy_lints/src/matches/mod.rs
+++ b/clippy_lints/src/matches/mod.rs
@@ -2,21 +2,18 @@ use clippy_utils::diagnostics::{multispan_sugg, span_lint_and_help, span_lint_an
 use clippy_utils::source::{indent_of, snippet, snippet_block, snippet_opt, snippet_with_applicability};
 use clippy_utils::sugg::Sugg;
 use clippy_utils::{
-    get_parent_expr, is_lang_ctor, is_refutable, is_wild, meets_msrv, msrvs, path_to_local_id, peel_blocks,
-    strip_pat_refs,
+    get_parent_expr, is_refutable, is_wild, meets_msrv, msrvs, path_to_local_id, peel_blocks, strip_pat_refs,
 };
 use core::iter::once;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
-use rustc_hir::LangItem::{OptionNone, OptionSome};
-use rustc_hir::{
-    Arm, BindingAnnotation, BorrowKind, Expr, ExprKind, Local, MatchSource, Mutability, Node, Pat, PatKind, QPath,
-};
+use rustc_hir::{Arm, BorrowKind, Expr, ExprKind, Local, MatchSource, Mutability, Node, Pat, PatKind, QPath};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
 use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 
+mod match_as_ref;
 mod match_bool;
 mod match_like_matches;
 mod match_same_arms;
@@ -627,7 +624,7 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
             overlapping_arms::check(cx, ex, arms);
             match_wild_err_arm::check(cx, ex, arms);
             match_wild_enum::check(cx, ex, arms);
-            check_match_as_ref(cx, ex, arms, expr);
+            match_as_ref::check(cx, ex, arms, expr);
             check_wild_in_or_pats(cx, arms);
 
             if self.infallible_destructuring_match_linted {
@@ -738,58 +735,6 @@ where
     });
 }
 
-fn check_match_as_ref(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>], expr: &Expr<'_>) {
-    if arms.len() == 2 && arms[0].guard.is_none() && arms[1].guard.is_none() {
-        let arm_ref: Option<BindingAnnotation> = if is_none_arm(cx, &arms[0]) {
-            is_ref_some_arm(cx, &arms[1])
-        } else if is_none_arm(cx, &arms[1]) {
-            is_ref_some_arm(cx, &arms[0])
-        } else {
-            None
-        };
-        if let Some(rb) = arm_ref {
-            let suggestion = if rb == BindingAnnotation::Ref {
-                "as_ref"
-            } else {
-                "as_mut"
-            };
-
-            let output_ty = cx.typeck_results().expr_ty(expr);
-            let input_ty = cx.typeck_results().expr_ty(ex);
-
-            let cast = if_chain! {
-                if let ty::Adt(_, substs) = input_ty.kind();
-                let input_ty = substs.type_at(0);
-                if let ty::Adt(_, substs) = output_ty.kind();
-                let output_ty = substs.type_at(0);
-                if let ty::Ref(_, output_ty, _) = *output_ty.kind();
-                if input_ty != output_ty;
-                then {
-                    ".map(|x| x as _)"
-                } else {
-                    ""
-                }
-            };
-
-            let mut applicability = Applicability::MachineApplicable;
-            span_lint_and_sugg(
-                cx,
-                MATCH_AS_REF,
-                expr.span,
-                &format!("use `{}()` instead", suggestion),
-                "try this",
-                format!(
-                    "{}.{}(){}",
-                    snippet_with_applicability(cx, ex.span, "_", &mut applicability),
-                    suggestion,
-                    cast,
-                ),
-                applicability,
-            );
-        }
-    }
-}
-
 fn check_wild_in_or_pats(cx: &LateContext<'_>, arms: &[Arm<'_>]) {
     for arm in arms {
         if let PatKind::Or(fields) = arm.pat.kind {
@@ -965,30 +910,6 @@ fn opt_parent_let<'a>(cx: &LateContext<'a>, ex: &Expr<'a>) -> Option<&'a Local<'
     None
 }
 
-// Checks if arm has the form `None => None`
-fn is_none_arm(cx: &LateContext<'_>, arm: &Arm<'_>) -> bool {
-    matches!(arm.pat.kind, PatKind::Path(ref qpath) if is_lang_ctor(cx, qpath, OptionNone))
-}
-
-// Checks if arm has the form `Some(ref v) => Some(v)` (checks for `ref` and `ref mut`)
-fn is_ref_some_arm(cx: &LateContext<'_>, arm: &Arm<'_>) -> Option<BindingAnnotation> {
-    if_chain! {
-        if let PatKind::TupleStruct(ref qpath, [first_pat, ..], _) = arm.pat.kind;
-        if is_lang_ctor(cx, qpath, OptionSome);
-        if let PatKind::Binding(rb, .., ident, _) = first_pat.kind;
-        if rb == BindingAnnotation::Ref || rb == BindingAnnotation::RefMut;
-        if let ExprKind::Call(e, args) = peel_blocks(arm.body).kind;
-        if let ExprKind::Path(ref some_path) = e.kind;
-        if is_lang_ctor(cx, some_path, OptionSome) && args.len() == 1;
-        if let ExprKind::Path(QPath::Resolved(_, path2)) = args[0].kind;
-        if path2.segments.len() == 1 && ident.name == path2.segments[0].ident.name;
-        then {
-            return Some(rb)
-        }
-    }
-    None
-}
-
 fn has_multiple_ref_pats<'a, 'b, I>(pats: I) -> bool
 where
     'b: 'a,
-- 
cgit 1.4.1-3-g733a5


From 1da26c8a70c13a0b897f70209c7c33f993d178f9 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sun, 6 Feb 2022 16:38:34 -0500
Subject: Split out `match_single_binding`

---
 clippy_lints/src/matches/match_single_binding.rs | 166 ++++++++++++++++++++++
 clippy_lints/src/matches/mod.rs                  | 168 +----------------------
 2 files changed, 171 insertions(+), 163 deletions(-)
 create mode 100644 clippy_lints/src/matches/match_single_binding.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/match_single_binding.rs b/clippy_lints/src/matches/match_single_binding.rs
new file mode 100644
index 00000000000..8ae19e03f1a
--- /dev/null
+++ b/clippy_lints/src/matches/match_single_binding.rs
@@ -0,0 +1,166 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::{indent_of, snippet_block, snippet_opt, snippet_with_applicability};
+use clippy_utils::sugg::Sugg;
+use clippy_utils::{get_parent_expr, is_refutable, peel_blocks};
+use rustc_errors::Applicability;
+use rustc_hir::{Arm, Expr, ExprKind, Local, Node, PatKind};
+use rustc_lint::LateContext;
+
+use super::MATCH_SINGLE_BINDING;
+
+#[allow(clippy::too_many_lines)]
+pub(crate) fn check<'a>(cx: &LateContext<'a>, ex: &Expr<'a>, arms: &[Arm<'_>], expr: &Expr<'_>) {
+    if expr.span.from_expansion() || arms.len() != 1 || is_refutable(cx, arms[0].pat) {
+        return;
+    }
+
+    // HACK:
+    // This is a hack to deal with arms that are excluded by macros like `#[cfg]`. It is only used here
+    // to prevent false positives as there is currently no better way to detect if code was excluded by
+    // a macro. See PR #6435
+    if_chain! {
+        if let Some(match_snippet) = snippet_opt(cx, expr.span);
+        if let Some(arm_snippet) = snippet_opt(cx, arms[0].span);
+        if let Some(ex_snippet) = snippet_opt(cx, ex.span);
+        let rest_snippet = match_snippet.replace(&arm_snippet, "").replace(&ex_snippet, "");
+        if rest_snippet.contains("=>");
+        then {
+            // The code it self contains another thick arrow "=>"
+            // -> Either another arm or a comment
+            return;
+        }
+    }
+
+    let matched_vars = ex.span;
+    let bind_names = arms[0].pat.span;
+    let match_body = peel_blocks(arms[0].body);
+    let mut snippet_body = if match_body.span.from_expansion() {
+        Sugg::hir_with_macro_callsite(cx, match_body, "..").to_string()
+    } else {
+        snippet_block(cx, match_body.span, "..", Some(expr.span)).to_string()
+    };
+
+    // Do we need to add ';' to suggestion ?
+    match match_body.kind {
+        ExprKind::Block(block, _) => {
+            // macro + expr_ty(body) == ()
+            if block.span.from_expansion() && cx.typeck_results().expr_ty(match_body).is_unit() {
+                snippet_body.push(';');
+            }
+        },
+        _ => {
+            // expr_ty(body) == ()
+            if cx.typeck_results().expr_ty(match_body).is_unit() {
+                snippet_body.push(';');
+            }
+        },
+    }
+
+    let mut applicability = Applicability::MaybeIncorrect;
+    match arms[0].pat.kind {
+        PatKind::Binding(..) | PatKind::Tuple(_, _) | PatKind::Struct(..) => {
+            // If this match is in a local (`let`) stmt
+            let (target_span, sugg) = if let Some(parent_let_node) = opt_parent_let(cx, ex) {
+                (
+                    parent_let_node.span,
+                    format!(
+                        "let {} = {};\n{}let {} = {};",
+                        snippet_with_applicability(cx, bind_names, "..", &mut applicability),
+                        snippet_with_applicability(cx, matched_vars, "..", &mut applicability),
+                        " ".repeat(indent_of(cx, expr.span).unwrap_or(0)),
+                        snippet_with_applicability(cx, parent_let_node.pat.span, "..", &mut applicability),
+                        snippet_body
+                    ),
+                )
+            } else {
+                // If we are in closure, we need curly braces around suggestion
+                let mut indent = " ".repeat(indent_of(cx, ex.span).unwrap_or(0));
+                let (mut cbrace_start, mut cbrace_end) = ("".to_string(), "".to_string());
+                if let Some(parent_expr) = get_parent_expr(cx, expr) {
+                    if let ExprKind::Closure(..) = parent_expr.kind {
+                        cbrace_end = format!("\n{}}}", indent);
+                        // Fix body indent due to the closure
+                        indent = " ".repeat(indent_of(cx, bind_names).unwrap_or(0));
+                        cbrace_start = format!("{{\n{}", indent);
+                    }
+                }
+                // If the parent is already an arm, and the body is another match statement,
+                // we need curly braces around suggestion
+                let parent_node_id = cx.tcx.hir().get_parent_node(expr.hir_id);
+                if let Node::Arm(arm) = &cx.tcx.hir().get(parent_node_id) {
+                    if let ExprKind::Match(..) = arm.body.kind {
+                        cbrace_end = format!("\n{}}}", indent);
+                        // Fix body indent due to the match
+                        indent = " ".repeat(indent_of(cx, bind_names).unwrap_or(0));
+                        cbrace_start = format!("{{\n{}", indent);
+                    }
+                }
+                (
+                    expr.span,
+                    format!(
+                        "{}let {} = {};\n{}{}{}",
+                        cbrace_start,
+                        snippet_with_applicability(cx, bind_names, "..", &mut applicability),
+                        snippet_with_applicability(cx, matched_vars, "..", &mut applicability),
+                        indent,
+                        snippet_body,
+                        cbrace_end
+                    ),
+                )
+            };
+            span_lint_and_sugg(
+                cx,
+                MATCH_SINGLE_BINDING,
+                target_span,
+                "this match could be written as a `let` statement",
+                "consider using `let` statement",
+                sugg,
+                applicability,
+            );
+        },
+        PatKind::Wild => {
+            if ex.can_have_side_effects() {
+                let indent = " ".repeat(indent_of(cx, expr.span).unwrap_or(0));
+                let sugg = format!(
+                    "{};\n{}{}",
+                    snippet_with_applicability(cx, ex.span, "..", &mut applicability),
+                    indent,
+                    snippet_body
+                );
+                span_lint_and_sugg(
+                    cx,
+                    MATCH_SINGLE_BINDING,
+                    expr.span,
+                    "this match could be replaced by its scrutinee and body",
+                    "consider using the scrutinee and body instead",
+                    sugg,
+                    applicability,
+                );
+            } else {
+                span_lint_and_sugg(
+                    cx,
+                    MATCH_SINGLE_BINDING,
+                    expr.span,
+                    "this match could be replaced by its body itself",
+                    "consider using the match body instead",
+                    snippet_body,
+                    Applicability::MachineApplicable,
+                );
+            }
+        },
+        _ => (),
+    }
+}
+
+/// Returns true if the `ex` match expression is in a local (`let`) statement
+fn opt_parent_let<'a>(cx: &LateContext<'a>, ex: &Expr<'a>) -> Option<&'a Local<'a>> {
+    let map = &cx.tcx.hir();
+    if_chain! {
+        if let Some(Node::Expr(parent_arm_expr)) = map.find(map.get_parent_node(ex.hir_id));
+        if let Some(Node::Local(parent_let_expr)) = map.find(map.get_parent_node(parent_arm_expr.hir_id));
+        then {
+            return Some(parent_let_expr);
+        }
+    }
+    None
+}
diff --git a/clippy_lints/src/matches/mod.rs b/clippy_lints/src/matches/mod.rs
index b48cdcb7d71..c2bf2aa6c9d 100644
--- a/clippy_lints/src/matches/mod.rs
+++ b/clippy_lints/src/matches/mod.rs
@@ -1,13 +1,11 @@
 use clippy_utils::diagnostics::{multispan_sugg, span_lint_and_help, span_lint_and_sugg, span_lint_and_then};
-use clippy_utils::source::{indent_of, snippet, snippet_block, snippet_opt, snippet_with_applicability};
+use clippy_utils::source::{snippet, snippet_with_applicability};
 use clippy_utils::sugg::Sugg;
-use clippy_utils::{
-    get_parent_expr, is_refutable, is_wild, meets_msrv, msrvs, path_to_local_id, peel_blocks, strip_pat_refs,
-};
+use clippy_utils::{is_wild, meets_msrv, msrvs, path_to_local_id, peel_blocks, strip_pat_refs};
 use core::iter::once;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
-use rustc_hir::{Arm, BorrowKind, Expr, ExprKind, Local, MatchSource, Mutability, Node, Pat, PatKind, QPath};
+use rustc_hir::{Arm, BorrowKind, Expr, ExprKind, Local, MatchSource, Mutability, Pat, PatKind, QPath};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
 use rustc_semver::RustcVersion;
@@ -17,6 +15,7 @@ mod match_as_ref;
 mod match_bool;
 mod match_like_matches;
 mod match_same_arms;
+mod match_single_binding;
 mod match_wild_enum;
 mod match_wild_err_arm;
 mod overlapping_arms;
@@ -630,7 +629,7 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
             if self.infallible_destructuring_match_linted {
                 self.infallible_destructuring_match_linted = false;
             } else {
-                check_match_single_binding(cx, ex, arms, expr);
+                match_single_binding::check(cx, ex, arms, expr);
             }
         }
         if let ExprKind::Match(ex, arms, _) = expr.kind {
@@ -753,163 +752,6 @@ fn check_wild_in_or_pats(cx: &LateContext<'_>, arms: &[Arm<'_>]) {
     }
 }
 
-#[allow(clippy::too_many_lines)]
-fn check_match_single_binding<'a>(cx: &LateContext<'a>, ex: &Expr<'a>, arms: &[Arm<'_>], expr: &Expr<'_>) {
-    if expr.span.from_expansion() || arms.len() != 1 || is_refutable(cx, arms[0].pat) {
-        return;
-    }
-
-    // HACK:
-    // This is a hack to deal with arms that are excluded by macros like `#[cfg]`. It is only used here
-    // to prevent false positives as there is currently no better way to detect if code was excluded by
-    // a macro. See PR #6435
-    if_chain! {
-        if let Some(match_snippet) = snippet_opt(cx, expr.span);
-        if let Some(arm_snippet) = snippet_opt(cx, arms[0].span);
-        if let Some(ex_snippet) = snippet_opt(cx, ex.span);
-        let rest_snippet = match_snippet.replace(&arm_snippet, "").replace(&ex_snippet, "");
-        if rest_snippet.contains("=>");
-        then {
-            // The code it self contains another thick arrow "=>"
-            // -> Either another arm or a comment
-            return;
-        }
-    }
-
-    let matched_vars = ex.span;
-    let bind_names = arms[0].pat.span;
-    let match_body = peel_blocks(arms[0].body);
-    let mut snippet_body = if match_body.span.from_expansion() {
-        Sugg::hir_with_macro_callsite(cx, match_body, "..").to_string()
-    } else {
-        snippet_block(cx, match_body.span, "..", Some(expr.span)).to_string()
-    };
-
-    // Do we need to add ';' to suggestion ?
-    match match_body.kind {
-        ExprKind::Block(block, _) => {
-            // macro + expr_ty(body) == ()
-            if block.span.from_expansion() && cx.typeck_results().expr_ty(match_body).is_unit() {
-                snippet_body.push(';');
-            }
-        },
-        _ => {
-            // expr_ty(body) == ()
-            if cx.typeck_results().expr_ty(match_body).is_unit() {
-                snippet_body.push(';');
-            }
-        },
-    }
-
-    let mut applicability = Applicability::MaybeIncorrect;
-    match arms[0].pat.kind {
-        PatKind::Binding(..) | PatKind::Tuple(_, _) | PatKind::Struct(..) => {
-            // If this match is in a local (`let`) stmt
-            let (target_span, sugg) = if let Some(parent_let_node) = opt_parent_let(cx, ex) {
-                (
-                    parent_let_node.span,
-                    format!(
-                        "let {} = {};\n{}let {} = {};",
-                        snippet_with_applicability(cx, bind_names, "..", &mut applicability),
-                        snippet_with_applicability(cx, matched_vars, "..", &mut applicability),
-                        " ".repeat(indent_of(cx, expr.span).unwrap_or(0)),
-                        snippet_with_applicability(cx, parent_let_node.pat.span, "..", &mut applicability),
-                        snippet_body
-                    ),
-                )
-            } else {
-                // If we are in closure, we need curly braces around suggestion
-                let mut indent = " ".repeat(indent_of(cx, ex.span).unwrap_or(0));
-                let (mut cbrace_start, mut cbrace_end) = ("".to_string(), "".to_string());
-                if let Some(parent_expr) = get_parent_expr(cx, expr) {
-                    if let ExprKind::Closure(..) = parent_expr.kind {
-                        cbrace_end = format!("\n{}}}", indent);
-                        // Fix body indent due to the closure
-                        indent = " ".repeat(indent_of(cx, bind_names).unwrap_or(0));
-                        cbrace_start = format!("{{\n{}", indent);
-                    }
-                }
-                // If the parent is already an arm, and the body is another match statement,
-                // we need curly braces around suggestion
-                let parent_node_id = cx.tcx.hir().get_parent_node(expr.hir_id);
-                if let Node::Arm(arm) = &cx.tcx.hir().get(parent_node_id) {
-                    if let ExprKind::Match(..) = arm.body.kind {
-                        cbrace_end = format!("\n{}}}", indent);
-                        // Fix body indent due to the match
-                        indent = " ".repeat(indent_of(cx, bind_names).unwrap_or(0));
-                        cbrace_start = format!("{{\n{}", indent);
-                    }
-                }
-                (
-                    expr.span,
-                    format!(
-                        "{}let {} = {};\n{}{}{}",
-                        cbrace_start,
-                        snippet_with_applicability(cx, bind_names, "..", &mut applicability),
-                        snippet_with_applicability(cx, matched_vars, "..", &mut applicability),
-                        indent,
-                        snippet_body,
-                        cbrace_end
-                    ),
-                )
-            };
-            span_lint_and_sugg(
-                cx,
-                MATCH_SINGLE_BINDING,
-                target_span,
-                "this match could be written as a `let` statement",
-                "consider using `let` statement",
-                sugg,
-                applicability,
-            );
-        },
-        PatKind::Wild => {
-            if ex.can_have_side_effects() {
-                let indent = " ".repeat(indent_of(cx, expr.span).unwrap_or(0));
-                let sugg = format!(
-                    "{};\n{}{}",
-                    snippet_with_applicability(cx, ex.span, "..", &mut applicability),
-                    indent,
-                    snippet_body
-                );
-                span_lint_and_sugg(
-                    cx,
-                    MATCH_SINGLE_BINDING,
-                    expr.span,
-                    "this match could be replaced by its scrutinee and body",
-                    "consider using the scrutinee and body instead",
-                    sugg,
-                    applicability,
-                );
-            } else {
-                span_lint_and_sugg(
-                    cx,
-                    MATCH_SINGLE_BINDING,
-                    expr.span,
-                    "this match could be replaced by its body itself",
-                    "consider using the match body instead",
-                    snippet_body,
-                    Applicability::MachineApplicable,
-                );
-            }
-        },
-        _ => (),
-    }
-}
-
-/// Returns true if the `ex` match expression is in a local (`let`) statement
-fn opt_parent_let<'a>(cx: &LateContext<'a>, ex: &Expr<'a>) -> Option<&'a Local<'a>> {
-    let map = &cx.tcx.hir();
-    if_chain! {
-        if let Some(Node::Expr(parent_arm_expr)) = map.find(map.get_parent_node(ex.hir_id));
-        if let Some(Node::Local(parent_let_expr)) = map.find(map.get_parent_node(parent_arm_expr.hir_id));
-        then {
-            return Some(parent_let_expr);
-        }
-    }
-    None
-}
-
 fn has_multiple_ref_pats<'a, 'b, I>(pats: I) -> bool
 where
     'b: 'a,
-- 
cgit 1.4.1-3-g733a5


From fb1093c56189e1386376715f4a61990b90289cca Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sun, 6 Feb 2022 16:44:52 -0500
Subject: Split out `match_ref_pats`

---
 clippy_lints/src/matches/match_ref_pats.rs | 66 ++++++++++++++++++++++++++++
 clippy_lints/src/matches/mod.rs            | 69 +++---------------------------
 2 files changed, 71 insertions(+), 64 deletions(-)
 create mode 100644 clippy_lints/src/matches/match_ref_pats.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/match_ref_pats.rs b/clippy_lints/src/matches/match_ref_pats.rs
new file mode 100644
index 00000000000..80f964ba1b7
--- /dev/null
+++ b/clippy_lints/src/matches/match_ref_pats.rs
@@ -0,0 +1,66 @@
+use clippy_utils::diagnostics::{multispan_sugg, span_lint_and_then};
+use clippy_utils::source::snippet;
+use clippy_utils::sugg::Sugg;
+use core::iter::once;
+use rustc_hir::{BorrowKind, Expr, ExprKind, Mutability, Pat, PatKind};
+use rustc_lint::LateContext;
+
+use super::MATCH_REF_PATS;
+
+pub(crate) fn check<'a, 'b, I>(cx: &LateContext<'_>, ex: &Expr<'_>, pats: I, expr: &Expr<'_>)
+where
+    'b: 'a,
+    I: Clone + Iterator<Item = &'a Pat<'b>>,
+{
+    if !has_multiple_ref_pats(pats.clone()) {
+        return;
+    }
+
+    let (first_sugg, msg, title);
+    let span = ex.span.source_callsite();
+    if let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Not, inner) = ex.kind {
+        first_sugg = once((span, Sugg::hir_with_macro_callsite(cx, inner, "..").to_string()));
+        msg = "try";
+        title = "you don't need to add `&` to both the expression and the patterns";
+    } else {
+        first_sugg = once((span, Sugg::hir_with_macro_callsite(cx, ex, "..").deref().to_string()));
+        msg = "instead of prefixing all patterns with `&`, you can dereference the expression";
+        title = "you don't need to add `&` to all patterns";
+    }
+
+    let remaining_suggs = pats.filter_map(|pat| {
+        if let PatKind::Ref(refp, _) = pat.kind {
+            Some((pat.span, snippet(cx, refp.span, "..").to_string()))
+        } else {
+            None
+        }
+    });
+
+    span_lint_and_then(cx, MATCH_REF_PATS, expr.span, title, |diag| {
+        if !expr.span.from_expansion() {
+            multispan_sugg(diag, msg, first_sugg.chain(remaining_suggs));
+        }
+    });
+}
+
+fn has_multiple_ref_pats<'a, 'b, I>(pats: I) -> bool
+where
+    'b: 'a,
+    I: Iterator<Item = &'a Pat<'b>>,
+{
+    let mut ref_count = 0;
+    for opt in pats.map(|pat| match pat.kind {
+        PatKind::Ref(..) => Some(true), // &-patterns
+        PatKind::Wild => Some(false),   // an "anything" wildcard is also fine
+        _ => None,                      // any other pattern is not fine
+    }) {
+        if let Some(inner) = opt {
+            if inner {
+                ref_count += 1;
+            }
+        } else {
+            return false;
+        }
+    }
+    ref_count > 1
+}
diff --git a/clippy_lints/src/matches/mod.rs b/clippy_lints/src/matches/mod.rs
index c2bf2aa6c9d..56f1031f9b9 100644
--- a/clippy_lints/src/matches/mod.rs
+++ b/clippy_lints/src/matches/mod.rs
@@ -1,11 +1,9 @@
-use clippy_utils::diagnostics::{multispan_sugg, span_lint_and_help, span_lint_and_sugg, span_lint_and_then};
-use clippy_utils::source::{snippet, snippet_with_applicability};
-use clippy_utils::sugg::Sugg;
+use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg};
+use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::{is_wild, meets_msrv, msrvs, path_to_local_id, peel_blocks, strip_pat_refs};
-use core::iter::once;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
-use rustc_hir::{Arm, BorrowKind, Expr, ExprKind, Local, MatchSource, Mutability, Pat, PatKind, QPath};
+use rustc_hir::{Arm, Expr, ExprKind, Local, MatchSource, Pat, PatKind, QPath};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
 use rustc_semver::RustcVersion;
@@ -14,6 +12,7 @@ use rustc_session::{declare_tool_lint, impl_lint_pass};
 mod match_as_ref;
 mod match_bool;
 mod match_like_matches;
+mod match_ref_pats;
 mod match_same_arms;
 mod match_single_binding;
 mod match_wild_enum;
@@ -633,7 +632,7 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
             }
         }
         if let ExprKind::Match(ex, arms, _) = expr.kind {
-            check_match_ref_pats(cx, ex, arms.iter().map(|el| el.pat), expr);
+            match_ref_pats::check(cx, ex, arms.iter().map(|el| el.pat), expr);
         }
     }
 
@@ -698,42 +697,6 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
     extract_msrv_attr!(LateContext);
 }
 
-fn check_match_ref_pats<'a, 'b, I>(cx: &LateContext<'_>, ex: &Expr<'_>, pats: I, expr: &Expr<'_>)
-where
-    'b: 'a,
-    I: Clone + Iterator<Item = &'a Pat<'b>>,
-{
-    if !has_multiple_ref_pats(pats.clone()) {
-        return;
-    }
-
-    let (first_sugg, msg, title);
-    let span = ex.span.source_callsite();
-    if let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Not, inner) = ex.kind {
-        first_sugg = once((span, Sugg::hir_with_macro_callsite(cx, inner, "..").to_string()));
-        msg = "try";
-        title = "you don't need to add `&` to both the expression and the patterns";
-    } else {
-        first_sugg = once((span, Sugg::hir_with_macro_callsite(cx, ex, "..").deref().to_string()));
-        msg = "instead of prefixing all patterns with `&`, you can dereference the expression";
-        title = "you don't need to add `&` to all patterns";
-    }
-
-    let remaining_suggs = pats.filter_map(|pat| {
-        if let PatKind::Ref(refp, _) = pat.kind {
-            Some((pat.span, snippet(cx, refp.span, "..").to_string()))
-        } else {
-            None
-        }
-    });
-
-    span_lint_and_then(cx, MATCH_REF_PATS, expr.span, title, |diag| {
-        if !expr.span.from_expansion() {
-            multispan_sugg(diag, msg, first_sugg.chain(remaining_suggs));
-        }
-    });
-}
-
 fn check_wild_in_or_pats(cx: &LateContext<'_>, arms: &[Arm<'_>]) {
     for arm in arms {
         if let PatKind::Or(fields) = arm.pat.kind {
@@ -751,25 +714,3 @@ fn check_wild_in_or_pats(cx: &LateContext<'_>, arms: &[Arm<'_>]) {
         }
     }
 }
-
-fn has_multiple_ref_pats<'a, 'b, I>(pats: I) -> bool
-where
-    'b: 'a,
-    I: Iterator<Item = &'a Pat<'b>>,
-{
-    let mut ref_count = 0;
-    for opt in pats.map(|pat| match pat.kind {
-        PatKind::Ref(..) => Some(true), // &-patterns
-        PatKind::Wild => Some(false),   // an "anything" wildcard is also fine
-        _ => None,                      // any other pattern is not fine
-    }) {
-        if let Some(inner) = opt {
-            if inner {
-                ref_count += 1;
-            }
-        } else {
-            return false;
-        }
-    }
-    ref_count > 1
-}
-- 
cgit 1.4.1-3-g733a5


From 64779233238b3dcadae13bdeebac82445c1e8f6d Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Mon, 7 Feb 2022 12:28:57 -0500
Subject: Split out `infalliable_detructuring_match`

---
 .../src/matches/infalliable_detructuring_match.rs  | 44 ++++++++++++++++++++++
 clippy_lints/src/matches/mod.rs                    | 40 ++------------------
 2 files changed, 48 insertions(+), 36 deletions(-)
 create mode 100644 clippy_lints/src/matches/infalliable_detructuring_match.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/infalliable_detructuring_match.rs b/clippy_lints/src/matches/infalliable_detructuring_match.rs
new file mode 100644
index 00000000000..2472acb6f6e
--- /dev/null
+++ b/clippy_lints/src/matches/infalliable_detructuring_match.rs
@@ -0,0 +1,44 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::{path_to_local_id, peel_blocks, strip_pat_refs};
+use rustc_errors::Applicability;
+use rustc_hir::{ExprKind, Local, MatchSource, PatKind, QPath};
+use rustc_lint::LateContext;
+
+use super::INFALLIBLE_DESTRUCTURING_MATCH;
+
+pub(crate) fn check(cx: &LateContext<'_>, local: &Local<'_>) -> bool {
+    if_chain! {
+        if !local.span.from_expansion();
+        if let Some(expr) = local.init;
+        if let ExprKind::Match(target, arms, MatchSource::Normal) = expr.kind;
+        if arms.len() == 1 && arms[0].guard.is_none();
+        if let PatKind::TupleStruct(
+            QPath::Resolved(None, variant_name), args, _) = arms[0].pat.kind;
+        if args.len() == 1;
+        if let PatKind::Binding(_, arg, ..) = strip_pat_refs(&args[0]).kind;
+        let body = peel_blocks(arms[0].body);
+        if path_to_local_id(body, arg);
+
+        then {
+            let mut applicability = Applicability::MachineApplicable;
+            span_lint_and_sugg(
+                cx,
+                INFALLIBLE_DESTRUCTURING_MATCH,
+                local.span,
+                "you seem to be trying to use `match` to destructure a single infallible pattern. \
+                Consider using `let`",
+                "try this",
+                format!(
+                    "let {}({}) = {};",
+                    snippet_with_applicability(cx, variant_name.span, "..", &mut applicability),
+                    snippet_with_applicability(cx, local.pat.span, "..", &mut applicability),
+                    snippet_with_applicability(cx, target.span, "..", &mut applicability),
+                ),
+                applicability,
+            );
+            return true;
+        }
+    }
+    false
+}
diff --git a/clippy_lints/src/matches/mod.rs b/clippy_lints/src/matches/mod.rs
index 56f1031f9b9..0adfa424ee1 100644
--- a/clippy_lints/src/matches/mod.rs
+++ b/clippy_lints/src/matches/mod.rs
@@ -1,14 +1,13 @@
-use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg};
-use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::{is_wild, meets_msrv, msrvs, path_to_local_id, peel_blocks, strip_pat_refs};
+use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::{is_wild, meets_msrv, msrvs};
 use if_chain::if_chain;
-use rustc_errors::Applicability;
 use rustc_hir::{Arm, Expr, ExprKind, Local, MatchSource, Pat, PatKind, QPath};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
 use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 
+mod infalliable_detructuring_match;
 mod match_as_ref;
 mod match_bool;
 mod match_like_matches;
@@ -637,38 +636,7 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
     }
 
     fn check_local(&mut self, cx: &LateContext<'tcx>, local: &'tcx Local<'_>) {
-        if_chain! {
-            if !local.span.from_expansion();
-            if let Some(expr) = local.init;
-            if let ExprKind::Match(target, arms, MatchSource::Normal) = expr.kind;
-            if arms.len() == 1 && arms[0].guard.is_none();
-            if let PatKind::TupleStruct(
-                QPath::Resolved(None, variant_name), args, _) = arms[0].pat.kind;
-            if args.len() == 1;
-            if let PatKind::Binding(_, arg, ..) = strip_pat_refs(&args[0]).kind;
-            let body = peel_blocks(arms[0].body);
-            if path_to_local_id(body, arg);
-
-            then {
-                let mut applicability = Applicability::MachineApplicable;
-                self.infallible_destructuring_match_linted = true;
-                span_lint_and_sugg(
-                    cx,
-                    INFALLIBLE_DESTRUCTURING_MATCH,
-                    local.span,
-                    "you seem to be trying to use `match` to destructure a single infallible pattern. \
-                    Consider using `let`",
-                    "try this",
-                    format!(
-                        "let {}({}) = {};",
-                        snippet_with_applicability(cx, variant_name.span, "..", &mut applicability),
-                        snippet_with_applicability(cx, local.pat.span, "..", &mut applicability),
-                        snippet_with_applicability(cx, target.span, "..", &mut applicability),
-                    ),
-                    applicability,
-                );
-            }
-        }
+        self.infallible_destructuring_match_linted |= infalliable_detructuring_match::check(cx, local);
     }
 
     fn check_pat(&mut self, cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>) {
-- 
cgit 1.4.1-3-g733a5


From aa3af30dee07a82cd3fcec5732dc575a4571d392 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Mon, 7 Feb 2022 12:57:02 -0500
Subject: Split out `rest_pat_in_fully_bound_struct`

---
 clippy_lints/src/matches/mod.rs                    | 26 +++----------------
 .../src/matches/rest_pat_in_fully_bound_struct.rs  | 29 ++++++++++++++++++++++
 2 files changed, 32 insertions(+), 23 deletions(-)
 create mode 100644 clippy_lints/src/matches/rest_pat_in_fully_bound_struct.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/mod.rs b/clippy_lints/src/matches/mod.rs
index 0adfa424ee1..4429065966d 100644
--- a/clippy_lints/src/matches/mod.rs
+++ b/clippy_lints/src/matches/mod.rs
@@ -1,9 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::{is_wild, meets_msrv, msrvs};
-use if_chain::if_chain;
-use rustc_hir::{Arm, Expr, ExprKind, Local, MatchSource, Pat, PatKind, QPath};
+use rustc_hir::{Arm, Expr, ExprKind, Local, MatchSource, Pat, PatKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty;
 use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 
@@ -18,6 +16,7 @@ mod match_wild_enum;
 mod match_wild_err_arm;
 mod overlapping_arms;
 mod redundant_pattern_match;
+mod rest_pat_in_fully_bound_struct;
 mod single_match;
 
 declare_clippy_lint! {
@@ -640,26 +639,7 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
     }
 
     fn check_pat(&mut self, cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>) {
-        if_chain! {
-            if !pat.span.from_expansion();
-            if let PatKind::Struct(QPath::Resolved(_, path), fields, true) = pat.kind;
-            if let Some(def_id) = path.res.opt_def_id();
-            let ty = cx.tcx.type_of(def_id);
-            if let ty::Adt(def, _) = ty.kind();
-            if def.is_struct() || def.is_union();
-            if fields.len() == def.non_enum_variant().fields.len();
-
-            then {
-                span_lint_and_help(
-                    cx,
-                    REST_PAT_IN_FULLY_BOUND_STRUCTS,
-                    pat.span,
-                    "unnecessary use of `..` pattern in struct binding. All fields were already bound",
-                    None,
-                    "consider removing `..` from this binding",
-                );
-            }
-        }
+        rest_pat_in_fully_bound_struct::check(cx, pat);
     }
 
     extract_msrv_attr!(LateContext);
diff --git a/clippy_lints/src/matches/rest_pat_in_fully_bound_struct.rs b/clippy_lints/src/matches/rest_pat_in_fully_bound_struct.rs
new file mode 100644
index 00000000000..5076239a57c
--- /dev/null
+++ b/clippy_lints/src/matches/rest_pat_in_fully_bound_struct.rs
@@ -0,0 +1,29 @@
+use clippy_utils::diagnostics::span_lint_and_help;
+use rustc_hir::{Pat, PatKind, QPath};
+use rustc_lint::LateContext;
+use rustc_middle::ty;
+
+use super::REST_PAT_IN_FULLY_BOUND_STRUCTS;
+
+pub(crate) fn check(cx: &LateContext<'_>, pat: &Pat<'_>) {
+    if_chain! {
+        if !pat.span.from_expansion();
+        if let PatKind::Struct(QPath::Resolved(_, path), fields, true) = pat.kind;
+        if let Some(def_id) = path.res.opt_def_id();
+        let ty = cx.tcx.type_of(def_id);
+        if let ty::Adt(def, _) = ty.kind();
+        if def.is_struct() || def.is_union();
+        if fields.len() == def.non_enum_variant().fields.len();
+
+        then {
+            span_lint_and_help(
+                cx,
+                REST_PAT_IN_FULLY_BOUND_STRUCTS,
+                pat.span,
+                "unnecessary use of `..` pattern in struct binding. All fields were already bound",
+                None,
+                "consider removing `..` from this binding",
+            );
+        }
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From c65894cf1a3bc6b111305071942f77e8654a7a6a Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Mon, 7 Feb 2022 13:00:19 -0500
Subject: Split out `wild_in_or_pats`

---
 clippy_lints/src/matches/mod.rs             | 26 ++++----------------------
 clippy_lints/src/matches/wild_in_or_pats.rs | 24 ++++++++++++++++++++++++
 2 files changed, 28 insertions(+), 22 deletions(-)
 create mode 100644 clippy_lints/src/matches/wild_in_or_pats.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/mod.rs b/clippy_lints/src/matches/mod.rs
index 4429065966d..b5ee4561f06 100644
--- a/clippy_lints/src/matches/mod.rs
+++ b/clippy_lints/src/matches/mod.rs
@@ -1,6 +1,5 @@
-use clippy_utils::diagnostics::span_lint_and_help;
-use clippy_utils::{is_wild, meets_msrv, msrvs};
-use rustc_hir::{Arm, Expr, ExprKind, Local, MatchSource, Pat, PatKind};
+use clippy_utils::{meets_msrv, msrvs};
+use rustc_hir::{Expr, ExprKind, Local, MatchSource, Pat};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
@@ -18,6 +17,7 @@ mod overlapping_arms;
 mod redundant_pattern_match;
 mod rest_pat_in_fully_bound_struct;
 mod single_match;
+mod wild_in_or_pats;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -621,7 +621,7 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
             match_wild_err_arm::check(cx, ex, arms);
             match_wild_enum::check(cx, ex, arms);
             match_as_ref::check(cx, ex, arms, expr);
-            check_wild_in_or_pats(cx, arms);
+            wild_in_or_pats::check(cx, arms);
 
             if self.infallible_destructuring_match_linted {
                 self.infallible_destructuring_match_linted = false;
@@ -644,21 +644,3 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
 
     extract_msrv_attr!(LateContext);
 }
-
-fn check_wild_in_or_pats(cx: &LateContext<'_>, arms: &[Arm<'_>]) {
-    for arm in arms {
-        if let PatKind::Or(fields) = arm.pat.kind {
-            // look for multiple fields in this arm that contains at least one Wild pattern
-            if fields.len() > 1 && fields.iter().any(is_wild) {
-                span_lint_and_help(
-                    cx,
-                    WILDCARD_IN_OR_PATTERNS,
-                    arm.pat.span,
-                    "wildcard pattern covers any other pattern as it will match anyway",
-                    None,
-                    "consider handling `_` separately",
-                );
-            }
-        }
-    }
-}
diff --git a/clippy_lints/src/matches/wild_in_or_pats.rs b/clippy_lints/src/matches/wild_in_or_pats.rs
new file mode 100644
index 00000000000..459513e65bf
--- /dev/null
+++ b/clippy_lints/src/matches/wild_in_or_pats.rs
@@ -0,0 +1,24 @@
+use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::is_wild;
+use rustc_hir::{Arm, PatKind};
+use rustc_lint::LateContext;
+
+use super::WILDCARD_IN_OR_PATTERNS;
+
+pub(crate) fn check(cx: &LateContext<'_>, arms: &[Arm<'_>]) {
+    for arm in arms {
+        if let PatKind::Or(fields) = arm.pat.kind {
+            // look for multiple fields in this arm that contains at least one Wild pattern
+            if fields.len() > 1 && fields.iter().any(is_wild) {
+                span_lint_and_help(
+                    cx,
+                    WILDCARD_IN_OR_PATTERNS,
+                    arm.pat.span,
+                    "wildcard pattern covers any other pattern as it will match anyway",
+                    None,
+                    "consider handling `_` separately",
+                );
+            }
+        }
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 41d7c7e059b8ae829c7d6480c53a5473d213e0a4 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Fri, 11 Feb 2022 14:45:56 +0000
Subject: Migrate `dbg_macro` to late pass

---
 clippy_lints/src/dbg_macro.rs | 97 +++++++++++++++++++++++--------------------
 clippy_lints/src/lib.rs       |  2 +-
 tests/ui/dbg_macro.rs         | 23 ++++++++++
 tests/ui/dbg_macro.stderr     | 35 +++++++++++++++-
 4 files changed, 110 insertions(+), 47 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/dbg_macro.rs b/clippy_lints/src/dbg_macro.rs
index 5a0b60fdfbc..df1a4128af3 100644
--- a/clippy_lints/src/dbg_macro.rs
+++ b/clippy_lints/src/dbg_macro.rs
@@ -1,11 +1,11 @@
-use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg};
-use clippy_utils::source::snippet_opt;
-use rustc_ast::ast;
-use rustc_ast::tokenstream::TokenStream;
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::macros::root_macro_call_first_node;
+use clippy_utils::source::snippet_with_applicability;
 use rustc_errors::Applicability;
-use rustc_lint::{EarlyContext, EarlyLintPass};
+use rustc_hir::{Expr, ExprKind};
+use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::source_map::Span;
+use rustc_span::sym;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -15,14 +15,6 @@ declare_clippy_lint! {
     /// `dbg!` macro is intended as a debugging tool. It
     /// should not be in version control.
     ///
-    /// ### Known problems
-    /// * The lint level is unaffected by crate attributes. The level can still
-    ///   be set for functions, modules and other items. To change the level for
-    ///   the entire crate, please use command line flags. More information and a
-    ///   configuration example can be found in [clippy#6610].
-    ///
-    /// [clippy#6610]: https://github.com/rust-lang/rust-clippy/issues/6610#issuecomment-977120558
-    ///
     /// ### Example
     /// ```rust,ignore
     /// // Bad
@@ -39,37 +31,52 @@ declare_clippy_lint! {
 
 declare_lint_pass!(DbgMacro => [DBG_MACRO]);
 
-impl EarlyLintPass for DbgMacro {
-    fn check_mac(&mut self, cx: &EarlyContext<'_>, mac: &ast::MacCall) {
-        if mac.path == sym!(dbg) {
-            if let Some(sugg) = tts_span(mac.args.inner_tokens()).and_then(|span| snippet_opt(cx, span)) {
-                span_lint_and_sugg(
-                    cx,
-                    DBG_MACRO,
-                    mac.span(),
-                    "`dbg!` macro is intended as a debugging tool",
-                    "ensure to avoid having uses of it in version control",
-                    sugg,
-                    Applicability::MaybeIncorrect,
-                );
-            } else {
-                span_lint_and_help(
-                    cx,
-                    DBG_MACRO,
-                    mac.span(),
-                    "`dbg!` macro is intended as a debugging tool",
-                    None,
-                    "ensure to avoid having uses of it in version control",
-                );
-            }
+impl LateLintPass<'_> for DbgMacro {
+    fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
+        let Some(macro_call) = root_macro_call_first_node(cx, expr) else { return };
+        if cx.tcx.is_diagnostic_item(sym::dbg_macro, macro_call.def_id) {
+            let mut applicability = Applicability::MachineApplicable;
+            let suggestion = match expr.peel_drop_temps().kind {
+                // dbg!()
+                ExprKind::Block(_, _) => String::new(),
+                // dbg!(1)
+                ExprKind::Match(val, ..) => {
+                    snippet_with_applicability(cx, val.span.source_callsite(), "..", &mut applicability).to_string()
+                },
+                // dbg!(2, 3)
+                ExprKind::Tup(
+                    [
+                        Expr {
+                            kind: ExprKind::Match(first, ..),
+                            ..
+                        },
+                        ..,
+                        Expr {
+                            kind: ExprKind::Match(last, ..),
+                            ..
+                        },
+                    ],
+                ) => {
+                    let snippet = snippet_with_applicability(
+                        cx,
+                        first.span.source_callsite().to(last.span.source_callsite()),
+                        "..",
+                        &mut applicability,
+                    );
+                    format!("({snippet})")
+                },
+                _ => return,
+            };
+
+            span_lint_and_sugg(
+                cx,
+                DBG_MACRO,
+                macro_call.span,
+                "`dbg!` macro is intended as a debugging tool",
+                "ensure to avoid having uses of it in version control",
+                suggestion,
+                applicability,
+            );
         }
     }
 }
-
-// Get span enclosing entire the token stream.
-fn tts_span(tts: TokenStream) -> Option<Span> {
-    let mut cursor = tts.into_trees();
-    let first = cursor.next()?.span();
-    let span = cursor.last().map_or(first, |tree| first.to(tree.span()));
-    Some(span)
-}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 9999cd3f824..3bd7699792a 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -432,7 +432,6 @@ pub fn register_pre_expansion_lints(store: &mut rustc_lint::LintStore, sess: &Se
 
     store.register_pre_expansion_pass(|| Box::new(write::Write::default()));
     store.register_pre_expansion_pass(move || Box::new(attrs::EarlyAttributes { msrv }));
-    store.register_pre_expansion_pass(|| Box::new(dbg_macro::DbgMacro));
 }
 
 #[doc(hidden)]
@@ -864,6 +863,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(move || Box::new(borrow_as_ptr::BorrowAsPtr::new(msrv)));
     store.register_late_pass(move || Box::new(manual_bits::ManualBits::new(msrv)));
     store.register_late_pass(|| Box::new(default_union_representation::DefaultUnionRepresentation));
+    store.register_late_pass(|| Box::new(dbg_macro::DbgMacro));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/tests/ui/dbg_macro.rs b/tests/ui/dbg_macro.rs
index d74e2611ee1..9b03c9b4783 100644
--- a/tests/ui/dbg_macro.rs
+++ b/tests/ui/dbg_macro.rs
@@ -16,4 +16,27 @@ fn main() {
     dbg!(42);
     dbg!(dbg!(dbg!(42)));
     foo(3) + dbg!(factorial(4));
+    dbg!(1, 2, dbg!(3, 4));
+    dbg!(1, 2, 3, 4, 5);
+}
+
+mod issue7274 {
+    trait Thing<'b> {
+        fn foo(&self);
+    }
+
+    macro_rules! define_thing {
+        ($thing:ident, $body:expr) => {
+            impl<'a> Thing<'a> for $thing {
+                fn foo<'b>(&self) {
+                    $body
+                }
+            }
+        };
+    }
+
+    struct MyThing;
+    define_thing!(MyThing, {
+        dbg!(2);
+    });
 }
diff --git a/tests/ui/dbg_macro.stderr b/tests/ui/dbg_macro.stderr
index 0abe953af26..8ee1b328720 100644
--- a/tests/ui/dbg_macro.stderr
+++ b/tests/ui/dbg_macro.stderr
@@ -76,5 +76,38 @@ help: ensure to avoid having uses of it in version control
 LL |     foo(3) + factorial(4);
    |              ~~~~~~~~~~~~
 
-error: aborting due to 7 previous errors
+error: `dbg!` macro is intended as a debugging tool
+  --> $DIR/dbg_macro.rs:19:5
+   |
+LL |     dbg!(1, 2, dbg!(3, 4));
+   |     ^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: ensure to avoid having uses of it in version control
+   |
+LL |     (1, 2, dbg!(3, 4));
+   |     ~~~~~~~~~~~~~~~~~~
+
+error: `dbg!` macro is intended as a debugging tool
+  --> $DIR/dbg_macro.rs:20:5
+   |
+LL |     dbg!(1, 2, 3, 4, 5);
+   |     ^^^^^^^^^^^^^^^^^^^
+   |
+help: ensure to avoid having uses of it in version control
+   |
+LL |     (1, 2, 3, 4, 5);
+   |     ~~~~~~~~~~~~~~~
+
+error: `dbg!` macro is intended as a debugging tool
+  --> $DIR/dbg_macro.rs:40:9
+   |
+LL |         dbg!(2);
+   |         ^^^^^^^
+   |
+help: ensure to avoid having uses of it in version control
+   |
+LL |         2;
+   |         ~
+
+error: aborting due to 10 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 6daa6d5ffe04475c8e54498dc1ebcdb4a884928c Mon Sep 17 00:00:00 2001
From: mi_sawa <mi.sawa.1216+git@gmail.com>
Date: Sat, 12 Feb 2022 02:24:32 +0900
Subject: Optimize redundant_clone

by using a static data structure to track transitive relations.
---
 clippy_lints/src/redundant_clone.rs | 61 ++++++++++++++++++++++---------------
 1 file changed, 36 insertions(+), 25 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/redundant_clone.rs b/clippy_lints/src/redundant_clone.rs
index 3e0e32857f1..60cc8fddcb4 100644
--- a/clippy_lints/src/redundant_clone.rs
+++ b/clippy_lints/src/redundant_clone.rs
@@ -3,7 +3,7 @@ use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::{has_drop, is_copy, is_type_diagnostic_item, walk_ptrs_ty_depth};
 use clippy_utils::{fn_has_unsatisfiable_preds, match_def_path, paths};
 use if_chain::if_chain;
-use rustc_data_structures::{fx::FxHashMap, transitive_relation::TransitiveRelation};
+use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::{def_id, Body, FnDecl, HirId};
@@ -512,7 +512,7 @@ impl<'tcx> GenKillAnalysis<'tcx> for MaybeStorageLive {
 /// For example, `b = &a; c = &a;` will make `b` and (transitively) `c`
 /// possible borrowers of `a`.
 struct PossibleBorrowerVisitor<'a, 'tcx> {
-    possible_borrower: TransitiveRelation<mir::Local>,
+    possible_borrower: TransitiveRelation,
     body: &'a mir::Body<'tcx>,
     cx: &'a LateContext<'tcx>,
     possible_origin: FxHashMap<mir::Local, HybridBitSet<mir::Local>>,
@@ -543,18 +543,10 @@ impl<'a, 'tcx> PossibleBorrowerVisitor<'a, 'tcx> {
                 continue;
             }
 
-            let borrowers = self.possible_borrower.reachable_from(&row);
+            let mut borrowers = self.possible_borrower.reachable_from(row, self.body.local_decls.len());
+            borrowers.remove(mir::Local::from_usize(0));
             if !borrowers.is_empty() {
-                let mut bs = HybridBitSet::new_empty(self.body.local_decls.len());
-                for &c in borrowers {
-                    if c != mir::Local::from_usize(0) {
-                        bs.insert(c);
-                    }
-                }
-
-                if !bs.is_empty() {
-                    map.insert(row, bs);
-                }
+                map.insert(row, borrowers);
             }
         }
 
@@ -644,7 +636,7 @@ impl<'a, 'tcx> mir::visit::Visitor<'tcx> for PossibleBorrowerVisitor<'a, 'tcx> {
 /// For exampel, `_1 = &mut _2` generate _1: {_2,...}
 /// Known Problems: not sure all borrowed are tracked
 struct PossibleOriginVisitor<'a, 'tcx> {
-    possible_origin: TransitiveRelation<mir::Local>,
+    possible_origin: TransitiveRelation,
     body: &'a mir::Body<'tcx>,
 }
 
@@ -663,18 +655,10 @@ impl<'a, 'tcx> PossibleOriginVisitor<'a, 'tcx> {
                 continue;
             }
 
-            let borrowers = self.possible_origin.reachable_from(&row);
+            let mut borrowers = self.possible_origin.reachable_from(row, self.body.local_decls.len());
+            borrowers.remove(mir::Local::from_usize(0));
             if !borrowers.is_empty() {
-                let mut bs = HybridBitSet::new_empty(self.body.local_decls.len());
-                for &c in borrowers {
-                    if c != mir::Local::from_usize(0) {
-                        bs.insert(c);
-                    }
-                }
-
-                if !bs.is_empty() {
-                    map.insert(row, bs);
-                }
+                map.insert(row, borrowers);
             }
         }
         map
@@ -766,3 +750,30 @@ impl PossibleBorrowerMap<'_, '_> {
         self.maybe_live.contains(local)
     }
 }
+
+#[derive(Default)]
+struct TransitiveRelation {
+    relations: FxHashMap<mir::Local, Vec<mir::Local>>,
+}
+impl TransitiveRelation {
+    fn add(&mut self, a: mir::Local, b: mir::Local) {
+        self.relations.entry(a).or_default().push(b);
+    }
+
+    fn reachable_from(&self, a: mir::Local, domain_size: usize) -> HybridBitSet<mir::Local> {
+        let mut seen = HybridBitSet::new_empty(domain_size);
+        seen.insert(a);
+        let mut stack = vec![a];
+        while let Some(u) = stack.pop() {
+            if let Some(edges) = self.relations.get(&u) {
+                for &v in edges {
+                    if seen.insert(v) {
+                        stack.push(v);
+                    }
+                }
+            }
+        }
+        seen.remove(a);
+        seen
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 79644069f0e8a0c6e40da6840053432e2d6a3fd7 Mon Sep 17 00:00:00 2001
From: David Tolnay <dtolnay@gmail.com>
Date: Fri, 11 Feb 2022 19:40:07 -0800
Subject: Downgrade transmute_undefined_repr lint to nursery

---
 clippy_lints/src/lib.register_all.rs         | 1 -
 clippy_lints/src/lib.register_correctness.rs | 1 -
 clippy_lints/src/lib.register_nursery.rs     | 1 +
 clippy_lints/src/transmute/mod.rs            | 2 +-
 4 files changed, 2 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index d93e34e76b4..4721b7f2b47 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -277,7 +277,6 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(transmute::TRANSMUTE_INT_TO_FLOAT),
     LintId::of(transmute::TRANSMUTE_NUM_TO_BYTES),
     LintId::of(transmute::TRANSMUTE_PTR_TO_REF),
-    LintId::of(transmute::TRANSMUTE_UNDEFINED_REPR),
     LintId::of(transmute::UNSOUND_COLLECTION_TRANSMUTE),
     LintId::of(transmute::WRONG_TRANSMUTE),
     LintId::of(transmuting_null::TRANSMUTING_NULL),
diff --git a/clippy_lints/src/lib.register_correctness.rs b/clippy_lints/src/lib.register_correctness.rs
index d013daa8e08..4217fd3a3ea 100644
--- a/clippy_lints/src/lib.register_correctness.rs
+++ b/clippy_lints/src/lib.register_correctness.rs
@@ -58,7 +58,6 @@ store.register_group(true, "clippy::correctness", Some("clippy_correctness"), ve
     LintId::of(size_of_in_element_count::SIZE_OF_IN_ELEMENT_COUNT),
     LintId::of(swap::ALMOST_SWAPPED),
     LintId::of(to_string_in_display::TO_STRING_IN_DISPLAY),
-    LintId::of(transmute::TRANSMUTE_UNDEFINED_REPR),
     LintId::of(transmute::UNSOUND_COLLECTION_TRANSMUTE),
     LintId::of(transmute::WRONG_TRANSMUTE),
     LintId::of(transmuting_null::TRANSMUTING_NULL),
diff --git a/clippy_lints/src/lib.register_nursery.rs b/clippy_lints/src/lib.register_nursery.rs
index a7353790100..8d4dde42bbe 100644
--- a/clippy_lints/src/lib.register_nursery.rs
+++ b/clippy_lints/src/lib.register_nursery.rs
@@ -26,6 +26,7 @@ store.register_group(true, "clippy::nursery", Some("clippy_nursery"), vec![
     LintId::of(strings::STRING_LIT_AS_BYTES),
     LintId::of(suspicious_operation_groupings::SUSPICIOUS_OPERATION_GROUPINGS),
     LintId::of(trailing_empty_array::TRAILING_EMPTY_ARRAY),
+    LintId::of(transmute::TRANSMUTE_UNDEFINED_REPR),
     LintId::of(transmute::USELESS_TRANSMUTE),
     LintId::of(use_self::USE_SELF),
 ])
diff --git a/clippy_lints/src/transmute/mod.rs b/clippy_lints/src/transmute/mod.rs
index 4c320deecc2..5e94ab6d048 100644
--- a/clippy_lints/src/transmute/mod.rs
+++ b/clippy_lints/src/transmute/mod.rs
@@ -376,7 +376,7 @@ declare_clippy_lint! {
     /// ```
     #[clippy::version = "1.60.0"]
     pub TRANSMUTE_UNDEFINED_REPR,
-    correctness,
+    nursery,
     "transmute to or from a type with an undefined representation"
 }
 
-- 
cgit 1.4.1-3-g733a5


From e2dc8ca08029b317771fcdac8979d77505068670 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Sat, 12 Feb 2022 11:44:28 +0000
Subject: Replace a few paths with diagnostic items

---
 clippy_lints/src/derive.rs             |  7 ++++---
 clippy_lints/src/duration_subsec.rs    | 11 +++++------
 clippy_lints/src/infinite_iter.rs      | 11 +++++++----
 clippy_lints/src/minmax.rs             | 15 ++++++---------
 clippy_lints/src/types/borrowed_box.rs |  4 ++--
 clippy_utils/src/paths.rs              |  7 -------
 6 files changed, 24 insertions(+), 31 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/derive.rs b/clippy_lints/src/derive.rs
index 6d3df260ca2..7277e4080c5 100644
--- a/clippy_lints/src/derive.rs
+++ b/clippy_lints/src/derive.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_note, span_lint_and_then};
 use clippy_utils::paths;
 use clippy_utils::ty::{implements_trait, is_copy};
-use clippy_utils::{get_trait_def_id, is_automatically_derived, is_lint_allowed, match_def_path};
+use clippy_utils::{is_automatically_derived, is_lint_allowed, match_def_path};
 use if_chain::if_chain;
 use rustc_hir::intravisit::{walk_expr, walk_fn, walk_item, FnKind, Visitor};
 use rustc_hir::{
@@ -12,6 +12,7 @@ use rustc_middle::hir::nested_filter;
 use rustc_middle::ty::{self, Ty};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
+use rustc_span::sym;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -196,7 +197,7 @@ fn check_hash_peq<'tcx>(
     if_chain! {
         if let Some(peq_trait_def_id) = cx.tcx.lang_items().eq_trait();
         if let Some(def_id) = trait_ref.trait_def_id();
-        if match_def_path(cx, def_id, &paths::HASH);
+        if cx.tcx.is_diagnostic_item(sym::Hash, def_id);
         then {
             // Look for the PartialEq implementations for `ty`
             cx.tcx.for_each_relevant_impl(peq_trait_def_id, ty, |impl_id| {
@@ -247,7 +248,7 @@ fn check_ord_partial_ord<'tcx>(
     ord_is_automatically_derived: bool,
 ) {
     if_chain! {
-        if let Some(ord_trait_def_id) = get_trait_def_id(cx, &paths::ORD);
+        if let Some(ord_trait_def_id) = cx.tcx.get_diagnostic_item(sym::Ord);
         if let Some(partial_ord_trait_def_id) = cx.tcx.lang_items().partial_ord_trait();
         if let Some(def_id) = &trait_ref.trait_def_id();
         if *def_id == ord_trait_def_id;
diff --git a/clippy_lints/src/duration_subsec.rs b/clippy_lints/src/duration_subsec.rs
index 24e32c09f44..09318f74527 100644
--- a/clippy_lints/src/duration_subsec.rs
+++ b/clippy_lints/src/duration_subsec.rs
@@ -1,15 +1,14 @@
+use clippy_utils::consts::{constant, Constant};
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::ty::match_type;
+use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Spanned;
-
-use clippy_utils::consts::{constant, Constant};
-use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::paths;
+use rustc_span::sym;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -46,7 +45,7 @@ impl<'tcx> LateLintPass<'tcx> for DurationSubsec {
         if_chain! {
             if let ExprKind::Binary(Spanned { node: BinOpKind::Div, .. }, left, right) = expr.kind;
             if let ExprKind::MethodCall(method_path, args, _) = left.kind;
-            if match_type(cx, cx.typeck_results().expr_ty(&args[0]).peel_refs(), &paths::DURATION);
+            if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&args[0]).peel_refs(), sym::Duration);
             if let Some((Constant::Int(divisor), _)) = constant(cx, cx.typeck_results(), right);
             then {
                 let suggested_fn = match (method_path.ident.as_str(), divisor) {
diff --git a/clippy_lints/src/infinite_iter.rs b/clippy_lints/src/infinite_iter.rs
index b6badef02f5..b2b9889f5dc 100644
--- a/clippy_lints/src/infinite_iter.rs
+++ b/clippy_lints/src/infinite_iter.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::ty::{implements_trait, is_type_diagnostic_item};
-use clippy_utils::{get_trait_def_id, higher, match_def_path, path_def_id, paths};
+use clippy_utils::{higher, match_def_path, path_def_id, paths};
 use rustc_hir::{BorrowKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -229,9 +229,12 @@ fn complete_infinite_iter(cx: &LateContext<'_>, expr: &Expr<'_>) -> Finiteness {
                 }
             }
             if method.ident.name == sym!(last) && args.len() == 1 {
-                let not_double_ended = get_trait_def_id(cx, &paths::DOUBLE_ENDED_ITERATOR).map_or(false, |id| {
-                    !implements_trait(cx, cx.typeck_results().expr_ty(&args[0]), id, &[])
-                });
+                let not_double_ended = cx
+                    .tcx
+                    .get_diagnostic_item(sym::DoubleEndedIterator)
+                    .map_or(false, |id| {
+                        !implements_trait(cx, cx.typeck_results().expr_ty(&args[0]), id, &[])
+                    });
                 if not_double_ended {
                     return is_infinite(cx, &args[0]);
                 }
diff --git a/clippy_lints/src/minmax.rs b/clippy_lints/src/minmax.rs
index cf9770f5c1f..65d1f440b76 100644
--- a/clippy_lints/src/minmax.rs
+++ b/clippy_lints/src/minmax.rs
@@ -1,10 +1,11 @@
 use clippy_utils::consts::{constant_simple, Constant};
 use clippy_utils::diagnostics::span_lint;
-use clippy_utils::{match_def_path, match_trait_method, paths};
+use clippy_utils::{match_trait_method, paths};
 use if_chain::if_chain;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::sym;
 use std::cmp::Ordering;
 
 declare_clippy_lint! {
@@ -73,14 +74,10 @@ fn min_max<'a>(cx: &LateContext<'_>, expr: &'a Expr<'a>) -> Option<(MinMax, Cons
                 cx.typeck_results()
                     .qpath_res(qpath, path.hir_id)
                     .opt_def_id()
-                    .and_then(|def_id| {
-                        if match_def_path(cx, def_id, &paths::CMP_MIN) {
-                            fetch_const(cx, args, MinMax::Min)
-                        } else if match_def_path(cx, def_id, &paths::CMP_MAX) {
-                            fetch_const(cx, args, MinMax::Max)
-                        } else {
-                            None
-                        }
+                    .and_then(|def_id| match cx.tcx.get_diagnostic_name(def_id) {
+                        Some(sym::cmp_min) => fetch_const(cx, args, MinMax::Min),
+                        Some(sym::cmp_max) => fetch_const(cx, args, MinMax::Max),
+                        _ => None,
                     })
             } else {
                 None
diff --git a/clippy_lints/src/types/borrowed_box.rs b/clippy_lints/src/types/borrowed_box.rs
index 63ad65b8afd..7c06906293b 100644
--- a/clippy_lints/src/types/borrowed_box.rs
+++ b/clippy_lints/src/types/borrowed_box.rs
@@ -1,11 +1,11 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet;
-use clippy_utils::{match_def_path, paths};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{self as hir, GenericArg, GenericBounds, GenericParamKind};
 use rustc_hir::{HirId, Lifetime, MutTy, Mutability, Node, QPath, TyKind};
 use rustc_lint::LateContext;
+use rustc_span::sym;
 
 use super::BORROWED_BOX;
 
@@ -89,7 +89,7 @@ fn is_any_trait(cx: &LateContext<'_>, t: &hir::Ty<'_>) -> bool {
         if let Some(trait_did) = traits[0].trait_ref.trait_def_id();
         // Only Send/Sync can be used as additional traits, so it is enough to
         // check only the first trait.
-        if match_def_path(cx, trait_did, &paths::ANY_TRAIT);
+        if cx.tcx.is_diagnostic_item(sym::Any, trait_did);
         then {
             return true;
         }
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index 288c56e9fd7..b9c5d289924 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -4,7 +4,6 @@
 //! Whenever possible, please consider diagnostic items over hardcoded paths.
 //! See <https://github.com/rust-lang/rust-clippy/issues/5393> for more information.
 
-pub const ANY_TRAIT: [&str; 3] = ["core", "any", "Any"];
 #[cfg(feature = "internal")]
 pub const APPLICABILITY: [&str; 2] = ["rustc_lint_defs", "Applicability"];
 #[cfg(feature = "internal")]
@@ -32,8 +31,6 @@ pub const BTREEMAP_CONTAINS_KEY: [&str; 6] = ["alloc", "collections", "btree", "
 pub const BTREEMAP_ENTRY: [&str; 6] = ["alloc", "collections", "btree", "map", "entry", "Entry"];
 pub const BTREEMAP_INSERT: [&str; 6] = ["alloc", "collections", "btree", "map", "BTreeMap", "insert"];
 pub const CLONE_TRAIT_METHOD: [&str; 4] = ["core", "clone", "Clone", "clone"];
-pub const CMP_MAX: [&str; 3] = ["core", "cmp", "max"];
-pub const CMP_MIN: [&str; 3] = ["core", "cmp", "min"];
 pub const COW: [&str; 3] = ["alloc", "borrow", "Cow"];
 pub const CSTRING_AS_C_STR: [&str; 5] = ["std", "ffi", "c_str", "CString", "as_c_str"];
 pub const DEFAULT_TRAIT_METHOD: [&str; 4] = ["core", "default", "Default", "default"];
@@ -42,9 +39,7 @@ pub const DEREF_MUT_TRAIT_METHOD: [&str; 5] = ["core", "ops", "deref", "DerefMut
 pub const DEREF_TRAIT_METHOD: [&str; 5] = ["core", "ops", "deref", "Deref", "deref"];
 pub const DIR_BUILDER: [&str; 3] = ["std", "fs", "DirBuilder"];
 pub const DISPLAY_TRAIT: [&str; 3] = ["core", "fmt", "Display"];
-pub const DOUBLE_ENDED_ITERATOR: [&str; 4] = ["core", "iter", "traits", "DoubleEndedIterator"];
 pub const DROP: [&str; 3] = ["core", "mem", "drop"];
-pub const DURATION: [&str; 3] = ["core", "time", "Duration"];
 #[cfg(feature = "internal")]
 pub const EARLY_CONTEXT: [&str; 2] = ["rustc_lint", "EarlyContext"];
 #[allow(clippy::invalid_paths)] // `check_path` does not seem to work for macros
@@ -59,7 +54,6 @@ pub const FILE_TYPE: [&str; 3] = ["std", "fs", "FileType"];
 #[allow(clippy::invalid_paths)] // `check_path` does not seem to work for macros
 pub const FORMAT_ARGS_MACRO: [&str; 4] = ["core", "macros", "builtin", "format_args"];
 pub const FROM_FROM: [&str; 4] = ["core", "convert", "From", "from"];
-pub const FROM_ITERATOR: [&str; 5] = ["core", "iter", "traits", "collect", "FromIterator"];
 pub const FROM_ITERATOR_METHOD: [&str; 6] = ["core", "iter", "traits", "collect", "FromIterator", "from_iter"];
 pub const FROM_STR_METHOD: [&str; 5] = ["core", "str", "traits", "FromStr", "from_str"];
 pub const FUTURE_FROM_GENERATOR: [&str; 3] = ["core", "future", "from_generator"];
@@ -67,7 +61,6 @@ pub const FUTURE_FROM_GENERATOR: [&str; 3] = ["core", "future", "from_generator"
 pub const FUTURES_IO_ASYNCREADEXT: [&str; 3] = ["futures_util", "io", "AsyncReadExt"];
 #[allow(clippy::invalid_paths)] // internal lints do not know about all external crates
 pub const FUTURES_IO_ASYNCWRITEEXT: [&str; 3] = ["futures_util", "io", "AsyncWriteExt"];
-pub const HASH: [&str; 3] = ["core", "hash", "Hash"];
 pub const HASHMAP_CONTAINS_KEY: [&str; 6] = ["std", "collections", "hash", "map", "HashMap", "contains_key"];
 pub const HASHMAP_ENTRY: [&str; 5] = ["std", "collections", "hash", "map", "Entry"];
 pub const HASHMAP_INSERT: [&str; 6] = ["std", "collections", "hash", "map", "HashMap", "insert"];
-- 
cgit 1.4.1-3-g733a5


From 4f96ca353ec2f48e02efe592dc9d7ebaa1e66f60 Mon Sep 17 00:00:00 2001
From: Jaeyong Sung <jaeyong0201@gmail.com>
Date: Sun, 13 Feb 2022 02:32:09 +0900
Subject: add only_used_in_recursion lint

- fix code that have variables that is "only used in recursion"
- add test
---
 CHANGELOG.md                                   |   1 +
 clippy_lints/src/lib.register_all.rs           |   1 +
 clippy_lints/src/lib.register_complexity.rs    |   1 +
 clippy_lints/src/lib.register_lints.rs         |   1 +
 clippy_lints/src/lib.rs                        |   2 +
 clippy_lints/src/methods/option_map_or_none.rs |   9 +-
 clippy_lints/src/only_used_in_recursion.rs     | 563 +++++++++++++++++++++++++
 clippy_lints/src/unnecessary_sort_by.rs        |  45 +-
 tests/ui/only_used_in_recursion.rs             |  73 ++++
 tests/ui/only_used_in_recursion.stderr         |  70 +++
 10 files changed, 732 insertions(+), 34 deletions(-)
 create mode 100644 clippy_lints/src/only_used_in_recursion.rs
 create mode 100644 tests/ui/only_used_in_recursion.rs
 create mode 100644 tests/ui/only_used_in_recursion.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index c9adf77c0d6..46f002aeeb3 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3349,6 +3349,7 @@ Released 2018-09-13
 [`not_unsafe_ptr_arg_deref`]: https://rust-lang.github.io/rust-clippy/master/index.html#not_unsafe_ptr_arg_deref
 [`octal_escapes`]: https://rust-lang.github.io/rust-clippy/master/index.html#octal_escapes
 [`ok_expect`]: https://rust-lang.github.io/rust-clippy/master/index.html#ok_expect
+[`only_used_in_recursion`]: https://rust-lang.github.io/rust-clippy/master/index.html#only_used_in_recursion
 [`op_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#op_ref
 [`option_as_ref_deref`]: https://rust-lang.github.io/rust-clippy/master/index.html#option_as_ref_deref
 [`option_env_unwrap`]: https://rust-lang.github.io/rust-clippy/master/index.html#option_env_unwrap
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index d93e34e76b4..7410d965ec1 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -226,6 +226,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(non_expressive_names::JUST_UNDERSCORES_AND_DIGITS),
     LintId::of(non_octal_unix_permissions::NON_OCTAL_UNIX_PERMISSIONS),
     LintId::of(octal_escapes::OCTAL_ESCAPES),
+    LintId::of(only_used_in_recursion::ONLY_USED_IN_RECURSION),
     LintId::of(open_options::NONSENSICAL_OPEN_OPTIONS),
     LintId::of(option_env_unwrap::OPTION_ENV_UNWRAP),
     LintId::of(overflow_check_conditional::OVERFLOW_CHECK_CONDITIONAL),
diff --git a/clippy_lints/src/lib.register_complexity.rs b/clippy_lints/src/lib.register_complexity.rs
index bd5ff613447..0cdf0cd1917 100644
--- a/clippy_lints/src/lib.register_complexity.rs
+++ b/clippy_lints/src/lib.register_complexity.rs
@@ -63,6 +63,7 @@ store.register_group(true, "clippy::complexity", Some("clippy_complexity"), vec!
     LintId::of(neg_cmp_op_on_partial_ord::NEG_CMP_OP_ON_PARTIAL_ORD),
     LintId::of(no_effect::NO_EFFECT),
     LintId::of(no_effect::UNNECESSARY_OPERATION),
+    LintId::of(only_used_in_recursion::ONLY_USED_IN_RECURSION),
     LintId::of(overflow_check_conditional::OVERFLOW_CHECK_CONDITIONAL),
     LintId::of(partialeq_ne_impl::PARTIALEQ_NE_IMPL),
     LintId::of(precedence::PRECEDENCE),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index a80320a578f..431bd622702 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -388,6 +388,7 @@ store.register_lints(&[
     non_send_fields_in_send_ty::NON_SEND_FIELDS_IN_SEND_TY,
     nonstandard_macro_braces::NONSTANDARD_MACRO_BRACES,
     octal_escapes::OCTAL_ESCAPES,
+    only_used_in_recursion::ONLY_USED_IN_RECURSION,
     open_options::NONSENSICAL_OPEN_OPTIONS,
     option_env_unwrap::OPTION_ENV_UNWRAP,
     option_if_let_else::OPTION_IF_LET_ELSE,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 0b07726519e..bd49ad0652c 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -316,6 +316,7 @@ mod non_octal_unix_permissions;
 mod non_send_fields_in_send_ty;
 mod nonstandard_macro_braces;
 mod octal_escapes;
+mod only_used_in_recursion;
 mod open_options;
 mod option_env_unwrap;
 mod option_if_let_else;
@@ -862,6 +863,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(move || Box::new(borrow_as_ptr::BorrowAsPtr::new(msrv)));
     store.register_late_pass(move || Box::new(manual_bits::ManualBits::new(msrv)));
     store.register_late_pass(|| Box::new(default_union_representation::DefaultUnionRepresentation));
+    store.register_late_pass(|| Box::new(only_used_in_recursion::OnlyUsedInRecursion));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/methods/option_map_or_none.rs b/clippy_lints/src/methods/option_map_or_none.rs
index bdf8cea1207..2a5ab6e625c 100644
--- a/clippy_lints/src/methods/option_map_or_none.rs
+++ b/clippy_lints/src/methods/option_map_or_none.rs
@@ -14,10 +14,7 @@ use super::RESULT_MAP_OR_INTO_OPTION;
 
 // The expression inside a closure may or may not have surrounding braces
 // which causes problems when generating a suggestion.
-fn reduce_unit_expression<'a>(
-    cx: &LateContext<'_>,
-    expr: &'a hir::Expr<'_>,
-) -> Option<(&'a hir::Expr<'a>, &'a [hir::Expr<'a>])> {
+fn reduce_unit_expression<'a>(expr: &'a hir::Expr<'_>) -> Option<(&'a hir::Expr<'a>, &'a [hir::Expr<'a>])> {
     match expr.kind {
         hir::ExprKind::Call(func, arg_char) => Some((func, arg_char)),
         hir::ExprKind::Block(block, _) => {
@@ -25,7 +22,7 @@ fn reduce_unit_expression<'a>(
                 (&[], Some(inner_expr)) => {
                     // If block only contains an expression,
                     // reduce `|x| { x + 1 }` to `|x| x + 1`
-                    reduce_unit_expression(cx, inner_expr)
+                    reduce_unit_expression(inner_expr)
                 },
                 _ => None,
             }
@@ -77,7 +74,7 @@ pub(super) fn check<'tcx>(
         if let hir::ExprKind::Closure(_, _, id, span, _) = map_arg.kind;
             let arg_snippet = snippet(cx, span, "..");
             let body = cx.tcx.hir().body(id);
-                if let Some((func, [arg_char])) = reduce_unit_expression(cx, &body.value);
+                if let Some((func, [arg_char])) = reduce_unit_expression(&body.value);
                 if let Some(id) = path_def_id(cx, func).and_then(|ctor_id| cx.tcx.parent(ctor_id));
                 if Some(id) == cx.tcx.lang_items().option_some_variant();
                 then {
diff --git a/clippy_lints/src/only_used_in_recursion.rs b/clippy_lints/src/only_used_in_recursion.rs
new file mode 100644
index 00000000000..ace00333bd1
--- /dev/null
+++ b/clippy_lints/src/only_used_in_recursion.rs
@@ -0,0 +1,563 @@
+use std::collections::VecDeque;
+
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use itertools::{izip, Itertools};
+use rustc_ast::{walk_list, Label, Mutability};
+use rustc_data_structures::fx::{FxHashMap, FxHashSet};
+use rustc_errors::Applicability;
+use rustc_hir::def::Res;
+use rustc_hir::intravisit::{walk_expr, FnKind, Visitor};
+use rustc_hir::{
+    Arm, Block, Body, Expr, ExprKind, Guard, HirId, Let, Local, Pat, PatKind, Path, PathSegment, QPath, Stmt, StmtKind,
+    UnOp,
+};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty;
+use rustc_middle::ty::{Ty, TyCtxt, TypeckResults};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::symbol::kw;
+use rustc_span::symbol::Ident;
+use rustc_span::Span;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for arguments that is only used in recursion with no side-effects.
+    /// The arguments can be involved in calculations and assignments but as long as
+    /// the calculations have no side-effects (function calls or mutating dereference)
+    /// and the assigned variables are also only in recursion, it is useless.
+    ///
+    /// ### Why is this bad?
+    /// The could contain a useless calculation and can make function simpler.
+    ///
+    /// ### Known Issues
+    /// It could not catch the variable that has no side effects but only used in recursion.
+    ///
+    /// ### Example
+    /// ```rust
+    /// fn f(a: usize, b: usize) -> usize {
+    ///     if a == 0 {
+    ///         1
+    ///     } else {
+    ///         f(a - 1, b + 1)
+    ///     }
+    /// }
+    /// # fn main() {
+    /// #     print!("{}", f(1, 1));
+    /// # }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// fn f(a: usize) -> usize {
+    ///     if a == 0 {
+    ///         1
+    ///     } else {
+    ///         f(a - 1)
+    ///     }
+    /// }
+    /// # fn main() {
+    /// #     print!("{}", f(1));
+    /// # }
+    /// ```
+    #[clippy::version = "1.60.0"]
+    pub ONLY_USED_IN_RECURSION,
+    complexity,
+    "default lint description"
+}
+declare_lint_pass!(OnlyUsedInRecursion => [ONLY_USED_IN_RECURSION]);
+
+impl<'tcx> LateLintPass<'tcx> for OnlyUsedInRecursion {
+    fn check_fn(
+        &mut self,
+        cx: &LateContext<'tcx>,
+        kind: FnKind<'tcx>,
+        _: &'tcx rustc_hir::FnDecl<'tcx>,
+        body: &'tcx Body<'tcx>,
+        _: Span,
+        _: HirId,
+    ) {
+        if let FnKind::ItemFn(ident, ..) | FnKind::Method(ident, ..) = kind {
+            let ty_res = cx.typeck_results();
+            let param_span = body
+                .params
+                .iter()
+                .flat_map(|param| {
+                    let mut v = Vec::new();
+                    param.pat.each_binding(|_, hir_id, span, ident| {
+                        v.push((hir_id, span, ident));
+                    });
+                    v
+                })
+                .skip(match kind {
+                    FnKind::Method(..) => 1,
+                    _ => 0,
+                })
+                .filter(|(_, _, ident)| !ident.name.as_str().starts_with('_'))
+                .collect_vec();
+
+            let params = body.params.iter().map(|param| param.pat).collect();
+
+            let mut visitor = SideEffectVisit {
+                graph: FxHashMap::default(),
+                has_side_effect: FxHashSet::default(),
+                ret_vars: Vec::new(),
+                contains_side_effect: false,
+                break_vars: FxHashMap::default(),
+                params,
+                fn_ident: ident,
+                is_method: matches!(kind, FnKind::Method(..)),
+                ty_res,
+                ty_ctx: cx.tcx,
+            };
+
+            visitor.visit_expr(&body.value);
+            let vars = std::mem::take(&mut visitor.ret_vars);
+            visitor.add_side_effect(vars);
+
+            let mut queue = visitor.has_side_effect.iter().copied().collect::<VecDeque<_>>();
+
+            while let Some(id) = queue.pop_front() {
+                if let Some(next) = visitor.graph.get(&id) {
+                    for i in next {
+                        if !visitor.has_side_effect.contains(i) {
+                            visitor.has_side_effect.insert(*i);
+                            queue.push_back(*i);
+                        }
+                    }
+                }
+            }
+
+            for (id, span, ident) in param_span {
+                if !visitor.has_side_effect.contains(&id) {
+                    span_lint_and_sugg(
+                        cx,
+                        ONLY_USED_IN_RECURSION,
+                        span,
+                        "parameter is only used in recursion with no side-effects",
+                        "if this is intentional, prefix with an underscore",
+                        format!("_{}", ident.name.as_str()),
+                        Applicability::MaybeIncorrect,
+                    );
+                }
+            }
+        }
+    }
+}
+
+pub fn is_primitive(ty: Ty<'_>) -> bool {
+    match ty.kind() {
+        ty::Bool | ty::Char | ty::Int(_) | ty::Uint(_) | ty::Float(_) | ty::Str => true,
+        ty::Ref(_, t, _) => is_primitive(t),
+        _ => false,
+    }
+}
+
+pub fn is_array(ty: Ty<'_>) -> bool {
+    match ty.kind() {
+        ty::Array(..) | ty::Slice(..) => true,
+        ty::Ref(_, t, _) => is_array(t),
+        _ => false,
+    }
+}
+
+pub struct SideEffectVisit<'tcx> {
+    graph: FxHashMap<HirId, FxHashSet<HirId>>,
+    has_side_effect: FxHashSet<HirId>,
+    // bool for if the variable was dereferenced from mutable reference
+    ret_vars: Vec<(HirId, bool)>,
+    contains_side_effect: bool,
+    // break label
+    break_vars: FxHashMap<Ident, Vec<(HirId, bool)>>,
+    params: Vec<&'tcx Pat<'tcx>>,
+    fn_ident: Ident,
+    is_method: bool,
+    ty_res: &'tcx TypeckResults<'tcx>,
+    ty_ctx: TyCtxt<'tcx>,
+}
+
+impl<'tcx> Visitor<'tcx> for SideEffectVisit<'tcx> {
+    fn visit_block(&mut self, b: &'tcx Block<'tcx>) {
+        b.stmts.iter().for_each(|stmt| {
+            self.visit_stmt(stmt);
+            self.ret_vars.clear();
+        });
+        walk_list!(self, visit_expr, b.expr);
+    }
+
+    fn visit_stmt(&mut self, s: &'tcx Stmt<'tcx>) {
+        match s.kind {
+            StmtKind::Local(Local {
+                pat, init: Some(init), ..
+            }) => {
+                self.visit_pat_expr(pat, init);
+            },
+            StmtKind::Item(i) => {
+                let item = self.ty_ctx.hir().item(i);
+                self.visit_item(item);
+            },
+            StmtKind::Expr(e) | StmtKind::Semi(e) => self.visit_expr(e),
+            StmtKind::Local(_) => {},
+        }
+    }
+
+    fn visit_expr(&mut self, ex: &'tcx Expr<'tcx>) {
+        debug_assert!(self.ret_vars.is_empty());
+        match ex.kind {
+            ExprKind::Array(exprs) | ExprKind::Tup(exprs) => {
+                self.ret_vars = exprs
+                    .iter()
+                    .flat_map(|expr| {
+                        self.visit_expr(expr);
+                        std::mem::take(&mut self.ret_vars)
+                    })
+                    .collect();
+            },
+            ExprKind::Call(callee, args) => self.visit_fn(callee, args),
+            ExprKind::MethodCall(path, args, _) => self.visit_method_call(path, args),
+            ExprKind::Binary(_, lhs, rhs) => {
+                self.visit_bin_op(lhs, rhs);
+            },
+            ExprKind::Unary(op, expr) => self.visit_un_op(op, expr),
+            ExprKind::Let(Let { pat, init, .. }) => self.visit_pat_expr(pat, init),
+            ExprKind::If(bind, then_expr, else_expr) => {
+                self.visit_if(bind, then_expr, else_expr);
+            },
+            ExprKind::Match(expr, arms, _) => self.visit_match(expr, arms),
+            ExprKind::Closure(_, _, body_id, _, _) => {
+                let body = self.ty_ctx.hir().body(body_id);
+                self.visit_body(body);
+                let vars = std::mem::take(&mut self.ret_vars);
+                self.add_side_effect(vars);
+            },
+            ExprKind::Loop(block, label, _, _) | ExprKind::Block(block, label) => {
+                self.visit_block_label(block, label);
+            },
+            ExprKind::Assign(bind, expr, _) => {
+                self.visit_assign(bind, expr);
+            },
+            ExprKind::AssignOp(_, bind, expr) => {
+                self.visit_assign(bind, expr);
+                self.visit_bin_op(bind, expr);
+            },
+            ExprKind::Field(expr, _) => {
+                self.visit_expr(expr);
+                if matches!(self.ty_res.expr_ty(expr).kind(), ty::Ref(_, _, Mutability::Mut)) {
+                    self.ret_vars.iter_mut().for_each(|(_, b)| *b = true);
+                }
+            },
+            ExprKind::Index(expr, index) => {
+                self.visit_expr(expr);
+                let mut vars = std::mem::take(&mut self.ret_vars);
+                self.visit_expr(index);
+                self.ret_vars.append(&mut vars);
+
+                if !is_array(self.ty_res.expr_ty(expr)) {
+                    self.add_side_effect(self.ret_vars.clone());
+                } else if matches!(self.ty_res.expr_ty(expr).kind(), ty::Ref(_, _, Mutability::Mut)) {
+                    self.ret_vars.iter_mut().for_each(|(_, b)| *b = true);
+                }
+            },
+            ExprKind::Break(dest, Some(expr)) => {
+                self.visit_expr(expr);
+                if let Some(label) = dest.label {
+                    self.break_vars
+                        .entry(label.ident)
+                        .or_insert(Vec::new())
+                        .append(&mut self.ret_vars);
+                }
+                self.contains_side_effect = true;
+            },
+            ExprKind::Ret(Some(expr)) => {
+                self.visit_expr(expr);
+                let vars = std::mem::take(&mut self.ret_vars);
+                self.add_side_effect(vars);
+                self.contains_side_effect = true;
+            },
+            ExprKind::Break(_, None) | ExprKind::Continue(_) | ExprKind::Ret(None) => {
+                self.contains_side_effect = true;
+            },
+            ExprKind::Struct(_, exprs, expr) => {
+                let mut ret_vars = exprs
+                    .iter()
+                    .flat_map(|field| {
+                        self.visit_expr(field.expr);
+                        std::mem::take(&mut self.ret_vars)
+                    })
+                    .collect();
+
+                walk_list!(self, visit_expr, expr);
+                self.ret_vars.append(&mut ret_vars);
+            },
+            _ => walk_expr(self, ex),
+        }
+    }
+
+    fn visit_path(&mut self, path: &'tcx Path<'tcx>, _id: HirId) {
+        if let Res::Local(id) = path.res {
+            self.ret_vars.push((id, false));
+        }
+    }
+}
+
+impl<'tcx> SideEffectVisit<'tcx> {
+    fn visit_assign(&mut self, lhs: &'tcx Expr<'tcx>, rhs: &'tcx Expr<'tcx>) {
+        // Just support array and tuple unwrapping for now.
+        //
+        // ex) `(a, b) = (c, d);`
+        // The graph would look like this:
+        //   a -> c
+        //   b -> d
+        //
+        // This would minimize the connection of the side-effect graph.
+        match (&lhs.kind, &rhs.kind) {
+            (ExprKind::Array(lhs), ExprKind::Array(rhs)) | (ExprKind::Tup(lhs), ExprKind::Tup(rhs)) => {
+                // if not, it is a compile error
+                debug_assert!(lhs.len() == rhs.len());
+                izip!(*lhs, *rhs).for_each(|(lhs, rhs)| self.visit_assign(lhs, rhs));
+            },
+            // in other assigns, we have to connect all each other
+            // because they can be connected somehow
+            _ => {
+                self.visit_expr(lhs);
+                let lhs_vars = std::mem::take(&mut self.ret_vars);
+                self.visit_expr(rhs);
+                let rhs_vars = std::mem::take(&mut self.ret_vars);
+                self.connect_assign(&lhs_vars, &rhs_vars);
+            },
+        }
+    }
+
+    fn visit_block_label(&mut self, block: &'tcx Block<'tcx>, label: Option<Label>) {
+        self.visit_block(block);
+        let _ = label.and_then(|label| {
+            self.break_vars
+                .remove(&label.ident)
+                .map(|mut break_vars| self.ret_vars.append(&mut break_vars))
+        });
+    }
+
+    fn visit_bin_op(&mut self, lhs: &'tcx Expr<'tcx>, rhs: &'tcx Expr<'tcx>) {
+        self.visit_expr(lhs);
+        let mut ret_vars = std::mem::take(&mut self.ret_vars);
+        self.visit_expr(rhs);
+        self.ret_vars.append(&mut ret_vars);
+        if !is_primitive(self.ty_res.expr_ty(lhs)) || !is_primitive(self.ty_res.expr_ty(rhs)) {
+            self.ret_vars.iter().for_each(|id| {
+                self.has_side_effect.insert(id.0);
+            });
+            self.contains_side_effect = true;
+        }
+    }
+
+    fn visit_un_op(&mut self, op: UnOp, expr: &'tcx Expr<'tcx>) {
+        self.visit_expr(expr);
+        let ty = self.ty_res.expr_ty(expr);
+        // dereferencing a reference has no side-effect
+        if !is_primitive(ty) && !matches!((op, ty.kind()), (UnOp::Deref, ty::Ref(..))) {
+            self.add_side_effect(self.ret_vars.clone());
+        }
+
+        if matches!((op, ty.kind()), (UnOp::Deref, ty::Ref(_, _, Mutability::Mut))) {
+            self.ret_vars.iter_mut().for_each(|(_, b)| *b = true);
+        }
+    }
+
+    fn visit_pat_expr(&mut self, pat: &'tcx Pat<'tcx>, expr: &'tcx Expr<'tcx>) {
+        match (&pat.kind, &expr.kind) {
+            (PatKind::Tuple(pats, _), ExprKind::Tup(exprs)) => {
+                self.ret_vars = izip!(*pats, *exprs)
+                    .flat_map(|(pat, expr)| {
+                        self.visit_pat_expr(pat, expr);
+                        std::mem::take(&mut self.ret_vars)
+                    })
+                    .collect();
+            },
+            (PatKind::Slice(front_exprs, _, back_exprs), ExprKind::Array(exprs)) => {
+                let mut vars = izip!(*front_exprs, *exprs)
+                    .flat_map(|(pat, expr)| {
+                        self.visit_pat_expr(pat, expr);
+                        std::mem::take(&mut self.ret_vars)
+                    })
+                    .collect();
+                self.ret_vars = izip!(back_exprs.iter().rev(), exprs.iter().rev())
+                    .flat_map(|(pat, expr)| {
+                        self.visit_pat_expr(pat, expr);
+                        std::mem::take(&mut self.ret_vars)
+                    })
+                    .collect();
+                self.ret_vars.append(&mut vars);
+            },
+            _ => {
+                let mut lhs_vars = Vec::new();
+                pat.each_binding(|_, id, _, _| lhs_vars.push((id, false)));
+                self.visit_expr(expr);
+                let rhs_vars = std::mem::take(&mut self.ret_vars);
+                self.connect_assign(&lhs_vars, &rhs_vars);
+                self.ret_vars = rhs_vars;
+            },
+        }
+    }
+
+    fn visit_fn(&mut self, callee: &'tcx Expr<'tcx>, args: &'tcx [Expr<'tcx>]) {
+        self.visit_expr(callee);
+        let mut ret_vars = std::mem::take(&mut self.ret_vars);
+        self.add_side_effect(ret_vars.clone());
+
+        if_chain! {
+            if !self.is_method;
+            if let ExprKind::Path(QPath::Resolved(_, path)) = callee.kind;
+            if let Res::Def(..) = path.res;
+            if path.segments.len() == 1;
+            let ident = path.segments.last().unwrap().ident;
+            if ident == self.fn_ident;
+            then {
+                izip!(self.params.clone(), args)
+                    .for_each(|(pat, expr)| {
+                        self.visit_pat_expr(pat, expr);
+                        self.ret_vars.clear();
+                    });
+            } else {
+                // This would set arguments used in closure that does not have side-effect.
+                // Closure itself can be detected whether there is a side-effect, but the
+                // value of variable that is holding closure can change.
+                // So, we just check the variables.
+                self.ret_vars = args
+                    .iter()
+                    .flat_map(|expr| {
+                        self.visit_expr(expr);
+                        std::mem::take(&mut self.ret_vars)
+                    })
+                    .collect_vec()
+                    .into_iter()
+                    .map(|id| {
+                        self.has_side_effect.insert(id.0);
+                        id
+                    })
+                    .collect();
+                self.contains_side_effect = true;
+            }
+        }
+
+        self.ret_vars.append(&mut ret_vars);
+    }
+
+    fn visit_method_call(&mut self, path: &'tcx PathSegment<'tcx>, args: &'tcx [Expr<'tcx>]) {
+        if_chain! {
+            if self.is_method;
+            if path.ident == self.fn_ident;
+            if let ExprKind::Path(QPath::Resolved(_, path)) = args.first().unwrap().kind;
+            if let Res::Local(..) = path.res;
+            let ident = path.segments.last().unwrap().ident;
+            if ident.name == kw::SelfLower;
+            then {
+                izip!(self.params.clone(), args.iter())
+                    .for_each(|(pat, expr)| {
+                        self.visit_pat_expr(pat, expr);
+                        self.ret_vars.clear();
+                    });
+            } else {
+                self.ret_vars = args
+                    .iter()
+                    .flat_map(|expr| {
+                        self.visit_expr(expr);
+                        std::mem::take(&mut self.ret_vars)
+                    })
+                    .collect_vec()
+                    .into_iter()
+                    .map(|a| {
+                        self.has_side_effect.insert(a.0);
+                        a
+                    })
+                    .collect();
+                self.contains_side_effect = true;
+            }
+        }
+    }
+
+    fn visit_if(&mut self, bind: &'tcx Expr<'tcx>, then_expr: &'tcx Expr<'tcx>, else_expr: Option<&'tcx Expr<'tcx>>) {
+        let contains_side_effect = self.contains_side_effect;
+        self.contains_side_effect = false;
+        self.visit_expr(bind);
+        let mut vars = std::mem::take(&mut self.ret_vars);
+        self.visit_expr(then_expr);
+        let mut then_vars = std::mem::take(&mut self.ret_vars);
+        walk_list!(self, visit_expr, else_expr);
+        if self.contains_side_effect {
+            self.add_side_effect(vars.clone());
+        }
+        self.contains_side_effect |= contains_side_effect;
+        self.ret_vars.append(&mut vars);
+        self.ret_vars.append(&mut then_vars);
+    }
+
+    fn visit_match(&mut self, expr: &'tcx Expr<'tcx>, arms: &'tcx [Arm<'tcx>]) {
+        self.visit_expr(expr);
+        let mut expr_vars = std::mem::take(&mut self.ret_vars);
+        self.ret_vars = arms
+            .iter()
+            .flat_map(|arm| {
+                let contains_side_effect = self.contains_side_effect;
+                self.contains_side_effect = false;
+                // this would visit `expr` multiple times
+                // but couldn't think of a better way
+                self.visit_pat_expr(arm.pat, expr);
+                let mut vars = std::mem::take(&mut self.ret_vars);
+                let _ = arm.guard.as_ref().map(|guard| {
+                    self.visit_expr(match guard {
+                        Guard::If(expr) | Guard::IfLet(_, expr) => expr,
+                    });
+                    vars.append(&mut self.ret_vars);
+                });
+                self.visit_expr(arm.body);
+                if self.contains_side_effect {
+                    self.add_side_effect(vars.clone());
+                    self.add_side_effect(expr_vars.clone());
+                }
+                self.contains_side_effect |= contains_side_effect;
+                vars.append(&mut self.ret_vars);
+                vars
+            })
+            .collect();
+        self.ret_vars.append(&mut expr_vars);
+    }
+
+    fn connect_assign(&mut self, lhs: &[(HirId, bool)], rhs: &[(HirId, bool)]) {
+        // if mutable dereference is on assignment it can have side-effect
+        // (this can lead to parameter mutable dereference and change the original value)
+        // too hard to detect whether this value is from parameter, so this would all
+        // check mutable dereference assignment to side effect
+        lhs.iter().filter(|(_, b)| *b).for_each(|(id, _)| {
+            self.has_side_effect.insert(*id);
+            self.contains_side_effect = true;
+        });
+
+        // there is no connection
+        if lhs.is_empty() || rhs.is_empty() {
+            return;
+        }
+
+        // by connected rhs in cycle, the connections would decrease
+        // from `n * m` to `n + m`
+        // where `n` and `m` are length of `lhs` and `rhs`.
+
+        // unwrap is possible since rhs is not empty
+        let rhs_first = rhs.first().unwrap();
+        for (id, _) in lhs.iter() {
+            self.graph
+                .entry(*id)
+                .or_insert_with(FxHashSet::default)
+                .insert(rhs_first.0);
+        }
+
+        let rhs = rhs.iter();
+        izip!(rhs.clone().cycle().skip(1), rhs).for_each(|(from, to)| {
+            self.graph.entry(from.0).or_insert_with(FxHashSet::default).insert(to.0);
+        });
+    }
+
+    fn add_side_effect(&mut self, v: Vec<(HirId, bool)>) {
+        for (id, _) in v {
+            self.has_side_effect.insert(id);
+            self.contains_side_effect = true;
+        }
+    }
+}
diff --git a/clippy_lints/src/unnecessary_sort_by.rs b/clippy_lints/src/unnecessary_sort_by.rs
index e6c260ed96a..fbc601becac 100644
--- a/clippy_lints/src/unnecessary_sort_by.rs
+++ b/clippy_lints/src/unnecessary_sort_by.rs
@@ -67,59 +67,51 @@ struct SortByKeyDetection {
 
 /// Detect if the two expressions are mirrored (identical, except one
 /// contains a and the other replaces it with b)
-fn mirrored_exprs(
-    cx: &LateContext<'_>,
-    a_expr: &Expr<'_>,
-    a_ident: &Ident,
-    b_expr: &Expr<'_>,
-    b_ident: &Ident,
-) -> bool {
+fn mirrored_exprs(a_expr: &Expr<'_>, a_ident: &Ident, b_expr: &Expr<'_>, b_ident: &Ident) -> bool {
     match (&a_expr.kind, &b_expr.kind) {
         // Two boxes with mirrored contents
         (ExprKind::Box(left_expr), ExprKind::Box(right_expr)) => {
-            mirrored_exprs(cx, left_expr, a_ident, right_expr, b_ident)
+            mirrored_exprs(left_expr, a_ident, right_expr, b_ident)
         },
         // Two arrays with mirrored contents
         (ExprKind::Array(left_exprs), ExprKind::Array(right_exprs)) => {
-            iter::zip(*left_exprs, *right_exprs).all(|(left, right)| mirrored_exprs(cx, left, a_ident, right, b_ident))
+            iter::zip(*left_exprs, *right_exprs).all(|(left, right)| mirrored_exprs(left, a_ident, right, b_ident))
         },
         // The two exprs are function calls.
         // Check to see that the function itself and its arguments are mirrored
         (ExprKind::Call(left_expr, left_args), ExprKind::Call(right_expr, right_args)) => {
-            mirrored_exprs(cx, left_expr, a_ident, right_expr, b_ident)
-                && iter::zip(*left_args, *right_args)
-                    .all(|(left, right)| mirrored_exprs(cx, left, a_ident, right, b_ident))
+            mirrored_exprs(left_expr, a_ident, right_expr, b_ident)
+                && iter::zip(*left_args, *right_args).all(|(left, right)| mirrored_exprs(left, a_ident, right, b_ident))
         },
         // The two exprs are method calls.
         // Check to see that the function is the same and the arguments are mirrored
         // This is enough because the receiver of the method is listed in the arguments
         (ExprKind::MethodCall(left_segment, left_args, _), ExprKind::MethodCall(right_segment, right_args, _)) => {
             left_segment.ident == right_segment.ident
-                && iter::zip(*left_args, *right_args)
-                    .all(|(left, right)| mirrored_exprs(cx, left, a_ident, right, b_ident))
+                && iter::zip(*left_args, *right_args).all(|(left, right)| mirrored_exprs(left, a_ident, right, b_ident))
         },
         // Two tuples with mirrored contents
         (ExprKind::Tup(left_exprs), ExprKind::Tup(right_exprs)) => {
-            iter::zip(*left_exprs, *right_exprs).all(|(left, right)| mirrored_exprs(cx, left, a_ident, right, b_ident))
+            iter::zip(*left_exprs, *right_exprs).all(|(left, right)| mirrored_exprs(left, a_ident, right, b_ident))
         },
         // Two binary ops, which are the same operation and which have mirrored arguments
         (ExprKind::Binary(left_op, left_left, left_right), ExprKind::Binary(right_op, right_left, right_right)) => {
             left_op.node == right_op.node
-                && mirrored_exprs(cx, left_left, a_ident, right_left, b_ident)
-                && mirrored_exprs(cx, left_right, a_ident, right_right, b_ident)
+                && mirrored_exprs(left_left, a_ident, right_left, b_ident)
+                && mirrored_exprs(left_right, a_ident, right_right, b_ident)
         },
         // Two unary ops, which are the same operation and which have the same argument
         (ExprKind::Unary(left_op, left_expr), ExprKind::Unary(right_op, right_expr)) => {
-            left_op == right_op && mirrored_exprs(cx, left_expr, a_ident, right_expr, b_ident)
+            left_op == right_op && mirrored_exprs(left_expr, a_ident, right_expr, b_ident)
         },
         // The two exprs are literals of some kind
         (ExprKind::Lit(left_lit), ExprKind::Lit(right_lit)) => left_lit.node == right_lit.node,
-        (ExprKind::Cast(left, _), ExprKind::Cast(right, _)) => mirrored_exprs(cx, left, a_ident, right, b_ident),
+        (ExprKind::Cast(left, _), ExprKind::Cast(right, _)) => mirrored_exprs(left, a_ident, right, b_ident),
         (ExprKind::DropTemps(left_block), ExprKind::DropTemps(right_block)) => {
-            mirrored_exprs(cx, left_block, a_ident, right_block, b_ident)
+            mirrored_exprs(left_block, a_ident, right_block, b_ident)
         },
         (ExprKind::Field(left_expr, left_ident), ExprKind::Field(right_expr, right_ident)) => {
-            left_ident.name == right_ident.name && mirrored_exprs(cx, left_expr, a_ident, right_expr, right_ident)
+            left_ident.name == right_ident.name && mirrored_exprs(left_expr, a_ident, right_expr, right_ident)
         },
         // Two paths: either one is a and the other is b, or they're identical to each other
         (
@@ -151,11 +143,9 @@ fn mirrored_exprs(
         (
             ExprKind::AddrOf(left_kind, Mutability::Not, left_expr),
             ExprKind::AddrOf(right_kind, Mutability::Not, right_expr),
-        ) => left_kind == right_kind && mirrored_exprs(cx, left_expr, a_ident, right_expr, b_ident),
-        (_, ExprKind::AddrOf(_, Mutability::Not, right_expr)) => {
-            mirrored_exprs(cx, a_expr, a_ident, right_expr, b_ident)
-        },
-        (ExprKind::AddrOf(_, Mutability::Not, left_expr), _) => mirrored_exprs(cx, left_expr, a_ident, b_expr, b_ident),
+        ) => left_kind == right_kind && mirrored_exprs(left_expr, a_ident, right_expr, b_ident),
+        (_, ExprKind::AddrOf(_, Mutability::Not, right_expr)) => mirrored_exprs(a_expr, a_ident, right_expr, b_ident),
+        (ExprKind::AddrOf(_, Mutability::Not, left_expr), _) => mirrored_exprs(left_expr, a_ident, b_expr, b_ident),
         _ => false,
     }
 }
@@ -176,14 +166,13 @@ fn detect_lint(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<LintTrigger> {
         if method_path.ident.name == sym::cmp;
         then {
             let (closure_body, closure_arg, reverse) = if mirrored_exprs(
-                cx,
                 left_expr,
                 left_ident,
                 right_expr,
                 right_ident
             ) {
                 (Sugg::hir(cx, left_expr, "..").to_string(), left_ident.name.to_string(), false)
-            } else if mirrored_exprs(cx, left_expr, right_ident, right_expr, left_ident) {
+            } else if mirrored_exprs(left_expr, right_ident, right_expr, left_ident) {
                 (Sugg::hir(cx, left_expr, "..").to_string(), right_ident.name.to_string(), true)
             } else {
                 return None;
diff --git a/tests/ui/only_used_in_recursion.rs b/tests/ui/only_used_in_recursion.rs
new file mode 100644
index 00000000000..a0c40eb0826
--- /dev/null
+++ b/tests/ui/only_used_in_recursion.rs
@@ -0,0 +1,73 @@
+#![warn(clippy::only_used_in_recursion)]
+
+fn simple(a: usize, b: usize) -> usize {
+    if a == 0 { 1 } else { simple(a - 1, b) }
+}
+
+fn with_calc(a: usize, b: isize) -> usize {
+    if a == 0 { 1 } else { with_calc(a - 1, -b + 1) }
+}
+
+fn tuple((a, b): (usize, usize)) -> usize {
+    if a == 0 { 1 } else { tuple((a - 1, b + 1)) }
+}
+
+fn let_tuple(a: usize, b: usize) -> usize {
+    let (c, d) = (a, b);
+    if c == 0 { 1 } else { let_tuple(c - 1, d + 1) }
+}
+
+fn array([a, b]: [usize; 2]) -> usize {
+    if a == 0 { 1 } else { array([a - 1, b + 1]) }
+}
+
+fn index(a: usize, mut b: &[usize], c: usize) -> usize {
+    if a == 0 { 1 } else { index(a - 1, b, c + b[0]) }
+}
+
+fn break_(a: usize, mut b: usize, mut c: usize) -> usize {
+    let c = loop {
+        b += 1;
+        c += 1;
+        if c == 10 {
+            break b;
+        }
+    };
+
+    if a == 0 { 1 } else { break_(a - 1, c, c) }
+}
+
+// this has a side effect
+fn mut_ref(a: usize, b: &mut usize) -> usize {
+    *b = 1;
+    if a == 0 { 1 } else { mut_ref(a - 1, b) }
+}
+
+fn mut_ref2(a: usize, b: &mut usize) -> usize {
+    let mut c = *b;
+    if a == 0 { 1 } else { mut_ref2(a - 1, &mut c) }
+}
+
+fn not_primitive(a: usize, b: String) -> usize {
+    if a == 0 { 1 } else { not_primitive(a - 1, b) }
+}
+
+// this doesn't have a side effect,
+// but `String` is not primitive.
+fn not_primitive_op(a: usize, b: String, c: &str) -> usize {
+    if a == 1 { 1 } else { not_primitive_op(a, b + c, c) }
+}
+
+struct A;
+
+impl A {
+    fn method(&self, a: usize, b: usize) -> usize {
+        if a == 0 { 1 } else { self.method(a - 1, b + 1) }
+    }
+}
+
+fn ignore(a: usize, _: usize) -> usize {
+    if a == 1 { 1 } else { ignore(a - 1, 0) }
+}
+
+fn main() {}
diff --git a/tests/ui/only_used_in_recursion.stderr b/tests/ui/only_used_in_recursion.stderr
new file mode 100644
index 00000000000..29d2b403427
--- /dev/null
+++ b/tests/ui/only_used_in_recursion.stderr
@@ -0,0 +1,70 @@
+error: parameter is only used in recursion with no side-effects
+  --> $DIR/only_used_in_recursion.rs:3:21
+   |
+LL | fn simple(a: usize, b: usize) -> usize {
+   |                     ^ help: if this is intentional, prefix with an underscore: `_b`
+   |
+   = note: `-D clippy::only-used-in-recursion` implied by `-D warnings`
+
+error: parameter is only used in recursion with no side-effects
+  --> $DIR/only_used_in_recursion.rs:7:24
+   |
+LL | fn with_calc(a: usize, b: isize) -> usize {
+   |                        ^ help: if this is intentional, prefix with an underscore: `_b`
+
+error: parameter is only used in recursion with no side-effects
+  --> $DIR/only_used_in_recursion.rs:11:14
+   |
+LL | fn tuple((a, b): (usize, usize)) -> usize {
+   |              ^ help: if this is intentional, prefix with an underscore: `_b`
+
+error: parameter is only used in recursion with no side-effects
+  --> $DIR/only_used_in_recursion.rs:15:24
+   |
+LL | fn let_tuple(a: usize, b: usize) -> usize {
+   |                        ^ help: if this is intentional, prefix with an underscore: `_b`
+
+error: parameter is only used in recursion with no side-effects
+  --> $DIR/only_used_in_recursion.rs:20:14
+   |
+LL | fn array([a, b]: [usize; 2]) -> usize {
+   |              ^ help: if this is intentional, prefix with an underscore: `_b`
+
+error: parameter is only used in recursion with no side-effects
+  --> $DIR/only_used_in_recursion.rs:24:20
+   |
+LL | fn index(a: usize, mut b: &[usize], c: usize) -> usize {
+   |                    ^^^^^ help: if this is intentional, prefix with an underscore: `_b`
+
+error: parameter is only used in recursion with no side-effects
+  --> $DIR/only_used_in_recursion.rs:24:37
+   |
+LL | fn index(a: usize, mut b: &[usize], c: usize) -> usize {
+   |                                     ^ help: if this is intentional, prefix with an underscore: `_c`
+
+error: parameter is only used in recursion with no side-effects
+  --> $DIR/only_used_in_recursion.rs:28:21
+   |
+LL | fn break_(a: usize, mut b: usize, mut c: usize) -> usize {
+   |                     ^^^^^ help: if this is intentional, prefix with an underscore: `_b`
+
+error: parameter is only used in recursion with no side-effects
+  --> $DIR/only_used_in_recursion.rs:46:23
+   |
+LL | fn mut_ref2(a: usize, b: &mut usize) -> usize {
+   |                       ^ help: if this is intentional, prefix with an underscore: `_b`
+
+error: parameter is only used in recursion with no side-effects
+  --> $DIR/only_used_in_recursion.rs:51:28
+   |
+LL | fn not_primitive(a: usize, b: String) -> usize {
+   |                            ^ help: if this is intentional, prefix with an underscore: `_b`
+
+error: parameter is only used in recursion with no side-effects
+  --> $DIR/only_used_in_recursion.rs:64:32
+   |
+LL |     fn method(&self, a: usize, b: usize) -> usize {
+   |                                ^ help: if this is intentional, prefix with an underscore: `_b`
+
+error: aborting due to 11 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 8faa938a604895ddb7138e017ac4dcbe354eefba Mon Sep 17 00:00:00 2001
From: Jaeyong Sung <jaeyong0201@gmail.com>
Date: Sun, 13 Feb 2022 03:53:23 +0900
Subject: fix only_used_in_recursion not to lint when unused_variable

---
 clippy_lints/src/only_used_in_recursion.rs | 14 +++++++++++++-
 1 file changed, 13 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/only_used_in_recursion.rs b/clippy_lints/src/only_used_in_recursion.rs
index ace00333bd1..81c40a6a379 100644
--- a/clippy_lints/src/only_used_in_recursion.rs
+++ b/clippy_lints/src/only_used_in_recursion.rs
@@ -126,8 +126,20 @@ impl<'tcx> LateLintPass<'tcx> for OnlyUsedInRecursion {
                 }
             }
 
+            let mut pre_order = FxHashMap::default();
+
+            visitor.graph.iter().for_each(|(_, next)| {
+                next.iter().for_each(|i| {
+                    *pre_order.entry(*i).or_insert(0) += 1;
+                });
+            });
+
             for (id, span, ident) in param_span {
-                if !visitor.has_side_effect.contains(&id) {
+                // if the variable is not used in recursion, it would be marked as unused
+                if !visitor.has_side_effect.contains(&id)
+                    && *pre_order.get(&id).unwrap_or(&0) > 0
+                    && visitor.graph.contains_key(&id)
+                {
                     span_lint_and_sugg(
                         cx,
                         ONLY_USED_IN_RECURSION,
-- 
cgit 1.4.1-3-g733a5


From 124bb03b15d439a2749a0bec0aca008cd3f0664c Mon Sep 17 00:00:00 2001
From: Jaeyong Sung <jaeyong0201@gmail.com>
Date: Sun, 13 Feb 2022 04:35:36 +0900
Subject: changed algorithm

---
 clippy_lints/src/only_used_in_recursion.rs | 87 +++++++++++++++++-------------
 1 file changed, 49 insertions(+), 38 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/only_used_in_recursion.rs b/clippy_lints/src/only_used_in_recursion.rs
index 81c40a6a379..d89a86c9ad1 100644
--- a/clippy_lints/src/only_used_in_recursion.rs
+++ b/clippy_lints/src/only_used_in_recursion.rs
@@ -126,29 +126,36 @@ impl<'tcx> LateLintPass<'tcx> for OnlyUsedInRecursion {
                 }
             }
 
-            let mut pre_order = FxHashMap::default();
-
-            visitor.graph.iter().for_each(|(_, next)| {
-                next.iter().for_each(|i| {
-                    *pre_order.entry(*i).or_insert(0) += 1;
-                });
-            });
-
             for (id, span, ident) in param_span {
                 // if the variable is not used in recursion, it would be marked as unused
-                if !visitor.has_side_effect.contains(&id)
-                    && *pre_order.get(&id).unwrap_or(&0) > 0
-                    && visitor.graph.contains_key(&id)
-                {
-                    span_lint_and_sugg(
-                        cx,
-                        ONLY_USED_IN_RECURSION,
-                        span,
-                        "parameter is only used in recursion with no side-effects",
-                        "if this is intentional, prefix with an underscore",
-                        format!("_{}", ident.name.as_str()),
-                        Applicability::MaybeIncorrect,
-                    );
+                if !visitor.has_side_effect.contains(&id) {
+                    let mut queue = VecDeque::new();
+                    let mut visited = FxHashSet::default();
+
+                    queue.push_back(id);
+
+                    while let Some(id) = queue.pop_front() {
+                        if let Some(next) = visitor.graph.get(&id) {
+                            for i in next {
+                                if !visited.contains(i) {
+                                    visited.insert(id);
+                                    queue.push_back(*i);
+                                }
+                            }
+                        }
+                    }
+
+                    if visited.contains(&id) {
+                        span_lint_and_sugg(
+                            cx,
+                            ONLY_USED_IN_RECURSION,
+                            span,
+                            "parameter is only used in recursion with no side-effects",
+                            "if this is intentional, prefix with an underscore",
+                            format!("_{}", ident.name.as_str()),
+                            Applicability::MaybeIncorrect,
+                        );
+                    }
                 }
             }
         }
@@ -200,7 +207,7 @@ impl<'tcx> Visitor<'tcx> for SideEffectVisit<'tcx> {
             StmtKind::Local(Local {
                 pat, init: Some(init), ..
             }) => {
-                self.visit_pat_expr(pat, init);
+                self.visit_pat_expr(pat, init, false);
             },
             StmtKind::Item(i) => {
                 let item = self.ty_ctx.hir().item(i);
@@ -229,7 +236,7 @@ impl<'tcx> Visitor<'tcx> for SideEffectVisit<'tcx> {
                 self.visit_bin_op(lhs, rhs);
             },
             ExprKind::Unary(op, expr) => self.visit_un_op(op, expr),
-            ExprKind::Let(Let { pat, init, .. }) => self.visit_pat_expr(pat, init),
+            ExprKind::Let(Let { pat, init, .. }) => self.visit_pat_expr(pat, init, false),
             ExprKind::If(bind, then_expr, else_expr) => {
                 self.visit_if(bind, then_expr, else_expr);
             },
@@ -333,7 +340,7 @@ impl<'tcx> SideEffectVisit<'tcx> {
                 let lhs_vars = std::mem::take(&mut self.ret_vars);
                 self.visit_expr(rhs);
                 let rhs_vars = std::mem::take(&mut self.ret_vars);
-                self.connect_assign(&lhs_vars, &rhs_vars);
+                self.connect_assign(&lhs_vars, &rhs_vars, false);
             },
         }
     }
@@ -373,12 +380,12 @@ impl<'tcx> SideEffectVisit<'tcx> {
         }
     }
 
-    fn visit_pat_expr(&mut self, pat: &'tcx Pat<'tcx>, expr: &'tcx Expr<'tcx>) {
+    fn visit_pat_expr(&mut self, pat: &'tcx Pat<'tcx>, expr: &'tcx Expr<'tcx>, connect_self: bool) {
         match (&pat.kind, &expr.kind) {
             (PatKind::Tuple(pats, _), ExprKind::Tup(exprs)) => {
                 self.ret_vars = izip!(*pats, *exprs)
                     .flat_map(|(pat, expr)| {
-                        self.visit_pat_expr(pat, expr);
+                        self.visit_pat_expr(pat, expr, connect_self);
                         std::mem::take(&mut self.ret_vars)
                     })
                     .collect();
@@ -386,13 +393,13 @@ impl<'tcx> SideEffectVisit<'tcx> {
             (PatKind::Slice(front_exprs, _, back_exprs), ExprKind::Array(exprs)) => {
                 let mut vars = izip!(*front_exprs, *exprs)
                     .flat_map(|(pat, expr)| {
-                        self.visit_pat_expr(pat, expr);
+                        self.visit_pat_expr(pat, expr, connect_self);
                         std::mem::take(&mut self.ret_vars)
                     })
                     .collect();
                 self.ret_vars = izip!(back_exprs.iter().rev(), exprs.iter().rev())
                     .flat_map(|(pat, expr)| {
-                        self.visit_pat_expr(pat, expr);
+                        self.visit_pat_expr(pat, expr, connect_self);
                         std::mem::take(&mut self.ret_vars)
                     })
                     .collect();
@@ -403,7 +410,7 @@ impl<'tcx> SideEffectVisit<'tcx> {
                 pat.each_binding(|_, id, _, _| lhs_vars.push((id, false)));
                 self.visit_expr(expr);
                 let rhs_vars = std::mem::take(&mut self.ret_vars);
-                self.connect_assign(&lhs_vars, &rhs_vars);
+                self.connect_assign(&lhs_vars, &rhs_vars, connect_self);
                 self.ret_vars = rhs_vars;
             },
         }
@@ -424,7 +431,7 @@ impl<'tcx> SideEffectVisit<'tcx> {
             then {
                 izip!(self.params.clone(), args)
                     .for_each(|(pat, expr)| {
-                        self.visit_pat_expr(pat, expr);
+                        self.visit_pat_expr(pat, expr, true);
                         self.ret_vars.clear();
                     });
             } else {
@@ -463,7 +470,7 @@ impl<'tcx> SideEffectVisit<'tcx> {
             then {
                 izip!(self.params.clone(), args.iter())
                     .for_each(|(pat, expr)| {
-                        self.visit_pat_expr(pat, expr);
+                        self.visit_pat_expr(pat, expr, true);
                         self.ret_vars.clear();
                     });
             } else {
@@ -511,7 +518,7 @@ impl<'tcx> SideEffectVisit<'tcx> {
                 self.contains_side_effect = false;
                 // this would visit `expr` multiple times
                 // but couldn't think of a better way
-                self.visit_pat_expr(arm.pat, expr);
+                self.visit_pat_expr(arm.pat, expr, false);
                 let mut vars = std::mem::take(&mut self.ret_vars);
                 let _ = arm.guard.as_ref().map(|guard| {
                     self.visit_expr(match guard {
@@ -532,7 +539,7 @@ impl<'tcx> SideEffectVisit<'tcx> {
         self.ret_vars.append(&mut expr_vars);
     }
 
-    fn connect_assign(&mut self, lhs: &[(HirId, bool)], rhs: &[(HirId, bool)]) {
+    fn connect_assign(&mut self, lhs: &[(HirId, bool)], rhs: &[(HirId, bool)], connect_self: bool) {
         // if mutable dereference is on assignment it can have side-effect
         // (this can lead to parameter mutable dereference and change the original value)
         // too hard to detect whether this value is from parameter, so this would all
@@ -554,15 +561,19 @@ impl<'tcx> SideEffectVisit<'tcx> {
         // unwrap is possible since rhs is not empty
         let rhs_first = rhs.first().unwrap();
         for (id, _) in lhs.iter() {
-            self.graph
-                .entry(*id)
-                .or_insert_with(FxHashSet::default)
-                .insert(rhs_first.0);
+            if connect_self || *id != rhs_first.0 {
+                self.graph
+                    .entry(*id)
+                    .or_insert_with(FxHashSet::default)
+                    .insert(rhs_first.0);
+            }
         }
 
         let rhs = rhs.iter();
         izip!(rhs.clone().cycle().skip(1), rhs).for_each(|(from, to)| {
-            self.graph.entry(from.0).or_insert_with(FxHashSet::default).insert(to.0);
+            if connect_self || from.0 != to.0 {
+                self.graph.entry(from.0).or_insert_with(FxHashSet::default).insert(to.0);
+            }
         });
     }
 
-- 
cgit 1.4.1-3-g733a5


From 2b3e7faf8de5a97ea73f14e31dff218de22b6389 Mon Sep 17 00:00:00 2001
From: Jaeyong Sung <jaeyong0201@gmail.com>
Date: Sun, 13 Feb 2022 04:53:30 +0900
Subject: add description

---
 clippy_lints/src/only_used_in_recursion.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/only_used_in_recursion.rs b/clippy_lints/src/only_used_in_recursion.rs
index d89a86c9ad1..b941a2647cc 100644
--- a/clippy_lints/src/only_used_in_recursion.rs
+++ b/clippy_lints/src/only_used_in_recursion.rs
@@ -29,7 +29,7 @@ declare_clippy_lint! {
     /// ### Why is this bad?
     /// The could contain a useless calculation and can make function simpler.
     ///
-    /// ### Known Issues
+    /// ### Known problems
     /// It could not catch the variable that has no side effects but only used in recursion.
     ///
     /// ### Example
@@ -61,7 +61,7 @@ declare_clippy_lint! {
     #[clippy::version = "1.60.0"]
     pub ONLY_USED_IN_RECURSION,
     complexity,
-    "default lint description"
+    "arguments that is only used in recursion can be removed"
 }
 declare_lint_pass!(OnlyUsedInRecursion => [ONLY_USED_IN_RECURSION]);
 
-- 
cgit 1.4.1-3-g733a5


From 2ebe7516a898ddd44c9021b080cbaf079e32121c Mon Sep 17 00:00:00 2001
From: Jaeyong Sung <jaeyong0201@gmail.com>
Date: Sun, 13 Feb 2022 13:32:40 +0900
Subject: add documentation

---
 clippy_lints/src/only_used_in_recursion.rs | 43 +++++++++++++++++++++++++++---
 tests/ui/only_used_in_recursion.stderr     | 22 +++++++--------
 2 files changed, 51 insertions(+), 14 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/only_used_in_recursion.rs b/clippy_lints/src/only_used_in_recursion.rs
index b941a2647cc..b8e0bd8acb3 100644
--- a/clippy_lints/src/only_used_in_recursion.rs
+++ b/clippy_lints/src/only_used_in_recursion.rs
@@ -21,7 +21,7 @@ use rustc_span::Span;
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for arguments that is only used in recursion with no side-effects.
+    /// Checks for arguments that are only used in recursion with no side-effects.
     /// The arguments can be involved in calculations and assignments but as long as
     /// the calculations have no side-effects (function calls or mutating dereference)
     /// and the assigned variables are also only in recursion, it is useless.
@@ -30,7 +30,21 @@ declare_clippy_lint! {
     /// The could contain a useless calculation and can make function simpler.
     ///
     /// ### Known problems
-    /// It could not catch the variable that has no side effects but only used in recursion.
+    /// In some cases, this would not catch all useless arguments.
+    ///
+    /// ```rust
+    /// fn foo(a: usize, b: usize) -> usize {
+    ///     let f = |x| x + 1;
+    ///
+    ///     if a == 0 {
+    ///         1
+    ///     } else {
+    ///         foo(a - 1, f(b))
+    ///     }
+    /// }
+    /// ```
+    ///
+    /// For example, the argument `b` is only used in recursion, but the lint would not catch it.
     ///
     /// ### Example
     /// ```rust
@@ -111,10 +125,12 @@ impl<'tcx> LateLintPass<'tcx> for OnlyUsedInRecursion {
 
             visitor.visit_expr(&body.value);
             let vars = std::mem::take(&mut visitor.ret_vars);
+            // this would set the return variables to side effect
             visitor.add_side_effect(vars);
 
             let mut queue = visitor.has_side_effect.iter().copied().collect::<VecDeque<_>>();
 
+            // a simple BFS to check all the variables that have side effect
             while let Some(id) = queue.pop_front() {
                 if let Some(next) = visitor.graph.get(&id) {
                     for i in next {
@@ -134,6 +150,8 @@ impl<'tcx> LateLintPass<'tcx> for OnlyUsedInRecursion {
 
                     queue.push_back(id);
 
+                    // a simple BFS to check the graph can reach to itself
+                    // if it can't, it means the variable is never used in recursion
                     while let Some(id) = queue.pop_front() {
                         if let Some(next) = visitor.graph.get(&id) {
                             for i in next {
@@ -150,7 +168,7 @@ impl<'tcx> LateLintPass<'tcx> for OnlyUsedInRecursion {
                             cx,
                             ONLY_USED_IN_RECURSION,
                             span,
-                            "parameter is only used in recursion with no side-effects",
+                            "parameter is only used in recursion",
                             "if this is intentional, prefix with an underscore",
                             format!("_{}", ident.name.as_str()),
                             Applicability::MaybeIncorrect,
@@ -178,6 +196,21 @@ pub fn is_array(ty: Ty<'_>) -> bool {
     }
 }
 
+/// This builds the graph of side effect.
+/// The edge `a -> b` means if `a` has side effect, `b` will have side effect.
+///
+/// There are some exmaple in following code:
+/// ```rust, ignore
+/// let b = 1;
+/// let a = b; // a -> b
+/// let (c, d) = (a, b); // c -> b, d -> b
+///
+/// let e = if a == 0 { // e -> a
+///     c // e -> c
+/// } else {
+///     d // e -> d
+/// };
+/// ```
 pub struct SideEffectVisit<'tcx> {
     graph: FxHashMap<HirId, FxHashSet<HirId>>,
     has_side_effect: FxHashSet<HirId>,
@@ -241,6 +274,7 @@ impl<'tcx> Visitor<'tcx> for SideEffectVisit<'tcx> {
                 self.visit_if(bind, then_expr, else_expr);
             },
             ExprKind::Match(expr, arms, _) => self.visit_match(expr, arms),
+            // since analysing the closure is not easy, just set all variables in it to side-effect
             ExprKind::Closure(_, _, body_id, _, _) => {
                 let body = self.ty_ctx.hir().body(body_id);
                 self.visit_body(body);
@@ -359,6 +393,9 @@ impl<'tcx> SideEffectVisit<'tcx> {
         let mut ret_vars = std::mem::take(&mut self.ret_vars);
         self.visit_expr(rhs);
         self.ret_vars.append(&mut ret_vars);
+
+        // the binary operation between non primitive values are overloaded operators
+        // so they can have side-effects
         if !is_primitive(self.ty_res.expr_ty(lhs)) || !is_primitive(self.ty_res.expr_ty(rhs)) {
             self.ret_vars.iter().for_each(|id| {
                 self.has_side_effect.insert(id.0);
diff --git a/tests/ui/only_used_in_recursion.stderr b/tests/ui/only_used_in_recursion.stderr
index 29d2b403427..ed942e06f26 100644
--- a/tests/ui/only_used_in_recursion.stderr
+++ b/tests/ui/only_used_in_recursion.stderr
@@ -1,4 +1,4 @@
-error: parameter is only used in recursion with no side-effects
+error: parameter is only used in recursion
   --> $DIR/only_used_in_recursion.rs:3:21
    |
 LL | fn simple(a: usize, b: usize) -> usize {
@@ -6,61 +6,61 @@ LL | fn simple(a: usize, b: usize) -> usize {
    |
    = note: `-D clippy::only-used-in-recursion` implied by `-D warnings`
 
-error: parameter is only used in recursion with no side-effects
+error: parameter is only used in recursion
   --> $DIR/only_used_in_recursion.rs:7:24
    |
 LL | fn with_calc(a: usize, b: isize) -> usize {
    |                        ^ help: if this is intentional, prefix with an underscore: `_b`
 
-error: parameter is only used in recursion with no side-effects
+error: parameter is only used in recursion
   --> $DIR/only_used_in_recursion.rs:11:14
    |
 LL | fn tuple((a, b): (usize, usize)) -> usize {
    |              ^ help: if this is intentional, prefix with an underscore: `_b`
 
-error: parameter is only used in recursion with no side-effects
+error: parameter is only used in recursion
   --> $DIR/only_used_in_recursion.rs:15:24
    |
 LL | fn let_tuple(a: usize, b: usize) -> usize {
    |                        ^ help: if this is intentional, prefix with an underscore: `_b`
 
-error: parameter is only used in recursion with no side-effects
+error: parameter is only used in recursion
   --> $DIR/only_used_in_recursion.rs:20:14
    |
 LL | fn array([a, b]: [usize; 2]) -> usize {
    |              ^ help: if this is intentional, prefix with an underscore: `_b`
 
-error: parameter is only used in recursion with no side-effects
+error: parameter is only used in recursion
   --> $DIR/only_used_in_recursion.rs:24:20
    |
 LL | fn index(a: usize, mut b: &[usize], c: usize) -> usize {
    |                    ^^^^^ help: if this is intentional, prefix with an underscore: `_b`
 
-error: parameter is only used in recursion with no side-effects
+error: parameter is only used in recursion
   --> $DIR/only_used_in_recursion.rs:24:37
    |
 LL | fn index(a: usize, mut b: &[usize], c: usize) -> usize {
    |                                     ^ help: if this is intentional, prefix with an underscore: `_c`
 
-error: parameter is only used in recursion with no side-effects
+error: parameter is only used in recursion
   --> $DIR/only_used_in_recursion.rs:28:21
    |
 LL | fn break_(a: usize, mut b: usize, mut c: usize) -> usize {
    |                     ^^^^^ help: if this is intentional, prefix with an underscore: `_b`
 
-error: parameter is only used in recursion with no side-effects
+error: parameter is only used in recursion
   --> $DIR/only_used_in_recursion.rs:46:23
    |
 LL | fn mut_ref2(a: usize, b: &mut usize) -> usize {
    |                       ^ help: if this is intentional, prefix with an underscore: `_b`
 
-error: parameter is only used in recursion with no side-effects
+error: parameter is only used in recursion
   --> $DIR/only_used_in_recursion.rs:51:28
    |
 LL | fn not_primitive(a: usize, b: String) -> usize {
    |                            ^ help: if this is intentional, prefix with an underscore: `_b`
 
-error: parameter is only used in recursion with no side-effects
+error: parameter is only used in recursion
   --> $DIR/only_used_in_recursion.rs:64:32
    |
 LL |     fn method(&self, a: usize, b: usize) -> usize {
-- 
cgit 1.4.1-3-g733a5


From 48d310e8698eea1b9c771bdd18042a921f9f45b7 Mon Sep 17 00:00:00 2001
From: Jaeyong Sung <jaeyong0201@gmail.com>
Date: Sun, 13 Feb 2022 13:36:27 +0900
Subject: add documentation

---
 clippy_lints/src/only_used_in_recursion.rs | 6 ++++++
 1 file changed, 6 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/only_used_in_recursion.rs b/clippy_lints/src/only_used_in_recursion.rs
index b8e0bd8acb3..21102e759e4 100644
--- a/clippy_lints/src/only_used_in_recursion.rs
+++ b/clippy_lints/src/only_used_in_recursion.rs
@@ -46,6 +46,12 @@ declare_clippy_lint! {
     ///
     /// For example, the argument `b` is only used in recursion, but the lint would not catch it.
     ///
+    /// List of some examples that can not be caught:
+    /// - binary operation of non-primitive types
+    /// - closure usage
+    /// - some `break` relative operations
+    /// - struct pattern binding
+    ///
     /// ### Example
     /// ```rust
     /// fn f(a: usize, b: usize) -> usize {
-- 
cgit 1.4.1-3-g733a5


From 662df33e976e2143f1ca839425b995f0eebf9c6e Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sun, 13 Feb 2022 13:22:17 -0500
Subject: Fix `transmute_undefined_repr` with single field `#[repr(C)]` structs

---
 clippy_lints/src/lib.register_all.rs                   | 1 +
 clippy_lints/src/lib.register_correctness.rs           | 1 +
 clippy_lints/src/lib.register_nursery.rs               | 1 -
 clippy_lints/src/transmute/mod.rs                      | 5 +++--
 clippy_lints/src/transmute/transmute_undefined_repr.rs | 9 +++++----
 tests/ui/transmute_undefined_repr.rs                   | 4 ++++
 6 files changed, 14 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 4721b7f2b47..d93e34e76b4 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -277,6 +277,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(transmute::TRANSMUTE_INT_TO_FLOAT),
     LintId::of(transmute::TRANSMUTE_NUM_TO_BYTES),
     LintId::of(transmute::TRANSMUTE_PTR_TO_REF),
+    LintId::of(transmute::TRANSMUTE_UNDEFINED_REPR),
     LintId::of(transmute::UNSOUND_COLLECTION_TRANSMUTE),
     LintId::of(transmute::WRONG_TRANSMUTE),
     LintId::of(transmuting_null::TRANSMUTING_NULL),
diff --git a/clippy_lints/src/lib.register_correctness.rs b/clippy_lints/src/lib.register_correctness.rs
index 4217fd3a3ea..d013daa8e08 100644
--- a/clippy_lints/src/lib.register_correctness.rs
+++ b/clippy_lints/src/lib.register_correctness.rs
@@ -58,6 +58,7 @@ store.register_group(true, "clippy::correctness", Some("clippy_correctness"), ve
     LintId::of(size_of_in_element_count::SIZE_OF_IN_ELEMENT_COUNT),
     LintId::of(swap::ALMOST_SWAPPED),
     LintId::of(to_string_in_display::TO_STRING_IN_DISPLAY),
+    LintId::of(transmute::TRANSMUTE_UNDEFINED_REPR),
     LintId::of(transmute::UNSOUND_COLLECTION_TRANSMUTE),
     LintId::of(transmute::WRONG_TRANSMUTE),
     LintId::of(transmuting_null::TRANSMUTING_NULL),
diff --git a/clippy_lints/src/lib.register_nursery.rs b/clippy_lints/src/lib.register_nursery.rs
index 8d4dde42bbe..a7353790100 100644
--- a/clippy_lints/src/lib.register_nursery.rs
+++ b/clippy_lints/src/lib.register_nursery.rs
@@ -26,7 +26,6 @@ store.register_group(true, "clippy::nursery", Some("clippy_nursery"), vec![
     LintId::of(strings::STRING_LIT_AS_BYTES),
     LintId::of(suspicious_operation_groupings::SUSPICIOUS_OPERATION_GROUPINGS),
     LintId::of(trailing_empty_array::TRAILING_EMPTY_ARRAY),
-    LintId::of(transmute::TRANSMUTE_UNDEFINED_REPR),
     LintId::of(transmute::USELESS_TRANSMUTE),
     LintId::of(use_self::USE_SELF),
 ])
diff --git a/clippy_lints/src/transmute/mod.rs b/clippy_lints/src/transmute/mod.rs
index 5e94ab6d048..22a8c53a585 100644
--- a/clippy_lints/src/transmute/mod.rs
+++ b/clippy_lints/src/transmute/mod.rs
@@ -358,7 +358,8 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for transmutes either to or from a type which does not have a defined representation.
+    /// Checks for transmutes between types which do not have a representation defined relative to
+    /// each other.
     ///
     /// ### Why is this bad?
     /// The results of such a transmute are not defined.
@@ -376,7 +377,7 @@ declare_clippy_lint! {
     /// ```
     #[clippy::version = "1.60.0"]
     pub TRANSMUTE_UNDEFINED_REPR,
-    nursery,
+    correctness,
     "transmute to or from a type with an undefined representation"
 }
 
diff --git a/clippy_lints/src/transmute/transmute_undefined_repr.rs b/clippy_lints/src/transmute/transmute_undefined_repr.rs
index c91bc3245e4..89439862f69 100644
--- a/clippy_lints/src/transmute/transmute_undefined_repr.rs
+++ b/clippy_lints/src/transmute/transmute_undefined_repr.rs
@@ -255,9 +255,6 @@ fn reduce_ty<'tcx>(cx: &LateContext<'tcx>, mut ty: Ty<'tcx>) -> ReducedTy<'tcx>
                 ReducedTy::UnorderedFields(ty)
             },
             ty::Adt(def, substs) if def.is_struct() => {
-                if def.repr.inhibit_struct_field_reordering_opt() {
-                    return ReducedTy::OrderedFields(ty);
-                }
                 let mut iter = def
                     .non_enum_variant()
                     .fields
@@ -270,7 +267,11 @@ fn reduce_ty<'tcx>(cx: &LateContext<'tcx>, mut ty: Ty<'tcx>) -> ReducedTy<'tcx>
                     ty = sized_ty;
                     continue;
                 }
-                ReducedTy::UnorderedFields(ty)
+                if def.repr.inhibit_struct_field_reordering_opt() {
+                    ReducedTy::OrderedFields(ty)
+                } else {
+                    ReducedTy::UnorderedFields(ty)
+                }
             },
             ty::Ref(..) | ty::RawPtr(_) => ReducedTy::Ref(ty),
             _ => ReducedTy::Other(ty),
diff --git a/tests/ui/transmute_undefined_repr.rs b/tests/ui/transmute_undefined_repr.rs
index 71539940fbf..f0383a03fbd 100644
--- a/tests/ui/transmute_undefined_repr.rs
+++ b/tests/ui/transmute_undefined_repr.rs
@@ -40,5 +40,9 @@ fn main() {
 
         let _: Ty<[u8; 8]> = core::mem::transmute(value::<Ty2<u32, i32>>()); // Ok, transmute to byte array
         let _: Ty2<u32, i32> = core::mem::transmute(value::<Ty<[u8; 8]>>()); // Ok, transmute from byte array
+
+        // issue #8417
+        let _: Ty2C<Ty2<u32, i32>, ()> = core::mem::transmute(value::<Ty2<u32, i32>>()); // Ok, Ty2 types are the same
+        let _: Ty2<u32, i32> = core::mem::transmute(value::<Ty2C<Ty2<u32, i32>, ()>>()); // Ok, Ty2 types are the same
     }
 }
-- 
cgit 1.4.1-3-g733a5


From eed7e9f61855e05fc03e42ce69da88b3f3a34d5b Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sun, 13 Feb 2022 16:54:33 -0500
Subject: Merge cargo lints

---
 clippy_lints/src/cargo/common_metadata.rs         |  54 ++++++
 clippy_lints/src/cargo/feature_name.rs            |  92 +++++++++
 clippy_lints/src/cargo/mod.rs                     | 221 ++++++++++++++++++++++
 clippy_lints/src/cargo/multiple_crate_versions.rs |  63 ++++++
 clippy_lints/src/cargo/wildcard_dependencies.rs   |  27 +++
 clippy_lints/src/cargo_common_metadata.rs         | 118 ------------
 clippy_lints/src/feature_name.rs                  | 166 ----------------
 clippy_lints/src/lib.register_cargo.rs            |  10 +-
 clippy_lints/src/lib.register_lints.rs            |  10 +-
 clippy_lints/src/lib.rs                           |  16 +-
 clippy_lints/src/multiple_crate_versions.rs       | 101 ----------
 clippy_lints/src/wildcard_dependencies.rs         |  57 ------
 clippy_utils/src/lib.rs                           |  18 --
 13 files changed, 474 insertions(+), 479 deletions(-)
 create mode 100644 clippy_lints/src/cargo/common_metadata.rs
 create mode 100644 clippy_lints/src/cargo/feature_name.rs
 create mode 100644 clippy_lints/src/cargo/mod.rs
 create mode 100644 clippy_lints/src/cargo/multiple_crate_versions.rs
 create mode 100644 clippy_lints/src/cargo/wildcard_dependencies.rs
 delete mode 100644 clippy_lints/src/cargo_common_metadata.rs
 delete mode 100644 clippy_lints/src/feature_name.rs
 delete mode 100644 clippy_lints/src/multiple_crate_versions.rs
 delete mode 100644 clippy_lints/src/wildcard_dependencies.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/cargo/common_metadata.rs b/clippy_lints/src/cargo/common_metadata.rs
new file mode 100644
index 00000000000..e0442dda479
--- /dev/null
+++ b/clippy_lints/src/cargo/common_metadata.rs
@@ -0,0 +1,54 @@
+//! lint on missing cargo common metadata
+
+use cargo_metadata::Metadata;
+use clippy_utils::diagnostics::span_lint;
+use rustc_lint::LateContext;
+use rustc_span::source_map::DUMMY_SP;
+
+use super::CARGO_COMMON_METADATA;
+
+pub(super) fn check(cx: &LateContext<'_>, metadata: &Metadata, ignore_publish: bool) {
+    for package in &metadata.packages {
+        // only run the lint if publish is `None` (`publish = true` or skipped entirely)
+        // or if the vector isn't empty (`publish = ["something"]`)
+        if package.publish.as_ref().filter(|publish| publish.is_empty()).is_none() || ignore_publish {
+            if is_empty_str(&package.description) {
+                missing_warning(cx, package, "package.description");
+            }
+
+            if is_empty_str(&package.license) && is_empty_str(&package.license_file) {
+                missing_warning(cx, package, "either package.license or package.license_file");
+            }
+
+            if is_empty_str(&package.repository) {
+                missing_warning(cx, package, "package.repository");
+            }
+
+            if is_empty_str(&package.readme) {
+                missing_warning(cx, package, "package.readme");
+            }
+
+            if is_empty_vec(&package.keywords) {
+                missing_warning(cx, package, "package.keywords");
+            }
+
+            if is_empty_vec(&package.categories) {
+                missing_warning(cx, package, "package.categories");
+            }
+        }
+    }
+}
+
+fn missing_warning(cx: &LateContext<'_>, package: &cargo_metadata::Package, field: &str) {
+    let message = format!("package `{}` is missing `{}` metadata", package.name, field);
+    span_lint(cx, CARGO_COMMON_METADATA, DUMMY_SP, &message);
+}
+
+fn is_empty_str<T: AsRef<std::ffi::OsStr>>(value: &Option<T>) -> bool {
+    value.as_ref().map_or(true, |s| s.as_ref().is_empty())
+}
+
+fn is_empty_vec(value: &[String]) -> bool {
+    // This works because empty iterators return true
+    value.iter().all(String::is_empty)
+}
diff --git a/clippy_lints/src/cargo/feature_name.rs b/clippy_lints/src/cargo/feature_name.rs
new file mode 100644
index 00000000000..79a469a4258
--- /dev/null
+++ b/clippy_lints/src/cargo/feature_name.rs
@@ -0,0 +1,92 @@
+use cargo_metadata::Metadata;
+use clippy_utils::diagnostics::span_lint_and_help;
+use rustc_lint::LateContext;
+use rustc_span::source_map::DUMMY_SP;
+
+use super::{NEGATIVE_FEATURE_NAMES, REDUNDANT_FEATURE_NAMES};
+
+static PREFIXES: [&str; 8] = ["no-", "no_", "not-", "not_", "use-", "use_", "with-", "with_"];
+static SUFFIXES: [&str; 2] = ["-support", "_support"];
+
+pub(super) fn check(cx: &LateContext<'_>, metadata: &Metadata) {
+    for package in &metadata.packages {
+        let mut features: Vec<&String> = package.features.keys().collect();
+        features.sort();
+        for feature in features {
+            let prefix_opt = {
+                let i = PREFIXES.partition_point(|prefix| prefix < &feature.as_str());
+                if i > 0 && feature.starts_with(PREFIXES[i - 1]) {
+                    Some(PREFIXES[i - 1])
+                } else {
+                    None
+                }
+            };
+            if let Some(prefix) = prefix_opt {
+                lint(cx, feature, prefix, true);
+            }
+
+            let suffix_opt: Option<&str> = {
+                let i = SUFFIXES.partition_point(|suffix| {
+                    suffix.bytes().rev().cmp(feature.bytes().rev()) == std::cmp::Ordering::Less
+                });
+                if i > 0 && feature.ends_with(SUFFIXES[i - 1]) {
+                    Some(SUFFIXES[i - 1])
+                } else {
+                    None
+                }
+            };
+            if let Some(suffix) = suffix_opt {
+                lint(cx, feature, suffix, false);
+            }
+        }
+    }
+}
+
+fn is_negative_prefix(s: &str) -> bool {
+    s.starts_with("no")
+}
+
+fn lint(cx: &LateContext<'_>, feature: &str, substring: &str, is_prefix: bool) {
+    let is_negative = is_prefix && is_negative_prefix(substring);
+    span_lint_and_help(
+        cx,
+        if is_negative {
+            NEGATIVE_FEATURE_NAMES
+        } else {
+            REDUNDANT_FEATURE_NAMES
+        },
+        DUMMY_SP,
+        &format!(
+            "the \"{}\" {} in the feature name \"{}\" is {}",
+            substring,
+            if is_prefix { "prefix" } else { "suffix" },
+            feature,
+            if is_negative { "negative" } else { "redundant" }
+        ),
+        None,
+        &format!(
+            "consider renaming the feature to \"{}\"{}",
+            if is_prefix {
+                feature.strip_prefix(substring)
+            } else {
+                feature.strip_suffix(substring)
+            }
+            .unwrap(),
+            if is_negative {
+                ", but make sure the feature adds functionality"
+            } else {
+                ""
+            }
+        ),
+    );
+}
+
+#[test]
+fn test_prefixes_sorted() {
+    let mut sorted_prefixes = PREFIXES;
+    sorted_prefixes.sort_unstable();
+    assert_eq!(PREFIXES, sorted_prefixes);
+    let mut sorted_suffixes = SUFFIXES;
+    sorted_suffixes.sort_by(|a, b| a.bytes().rev().cmp(b.bytes().rev()));
+    assert_eq!(SUFFIXES, sorted_suffixes);
+}
diff --git a/clippy_lints/src/cargo/mod.rs b/clippy_lints/src/cargo/mod.rs
new file mode 100644
index 00000000000..abe95c6663f
--- /dev/null
+++ b/clippy_lints/src/cargo/mod.rs
@@ -0,0 +1,221 @@
+use cargo_metadata::MetadataCommand;
+use clippy_utils::diagnostics::span_lint;
+use clippy_utils::is_lint_allowed;
+use rustc_hir::hir_id::CRATE_HIR_ID;
+use rustc_lint::{LateContext, LateLintPass, Lint};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::DUMMY_SP;
+
+mod common_metadata;
+mod feature_name;
+mod multiple_crate_versions;
+mod wildcard_dependencies;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks to see if all common metadata is defined in
+    /// `Cargo.toml`. See: https://rust-lang-nursery.github.io/api-guidelines/documentation.html#cargotoml-includes-all-common-metadata-c-metadata
+    ///
+    /// ### Why is this bad?
+    /// It will be more difficult for users to discover the
+    /// purpose of the crate, and key information related to it.
+    ///
+    /// ### Example
+    /// ```toml
+    /// # This `Cargo.toml` is missing a description field:
+    /// [package]
+    /// name = "clippy"
+    /// version = "0.0.212"
+    /// repository = "https://github.com/rust-lang/rust-clippy"
+    /// readme = "README.md"
+    /// license = "MIT OR Apache-2.0"
+    /// keywords = ["clippy", "lint", "plugin"]
+    /// categories = ["development-tools", "development-tools::cargo-plugins"]
+    /// ```
+    ///
+    /// Should include a description field like:
+    ///
+    /// ```toml
+    /// # This `Cargo.toml` includes all common metadata
+    /// [package]
+    /// name = "clippy"
+    /// version = "0.0.212"
+    /// description = "A bunch of helpful lints to avoid common pitfalls in Rust"
+    /// repository = "https://github.com/rust-lang/rust-clippy"
+    /// readme = "README.md"
+    /// license = "MIT OR Apache-2.0"
+    /// keywords = ["clippy", "lint", "plugin"]
+    /// categories = ["development-tools", "development-tools::cargo-plugins"]
+    /// ```
+    #[clippy::version = "1.32.0"]
+    pub CARGO_COMMON_METADATA,
+    cargo,
+    "common metadata is defined in `Cargo.toml`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for feature names with prefix `use-`, `with-` or suffix `-support`
+    ///
+    /// ### Why is this bad?
+    /// These prefixes and suffixes have no significant meaning.
+    ///
+    /// ### Example
+    /// ```toml
+    /// # The `Cargo.toml` with feature name redundancy
+    /// [features]
+    /// default = ["use-abc", "with-def", "ghi-support"]
+    /// use-abc = []  // redundant
+    /// with-def = []   // redundant
+    /// ghi-support = []   // redundant
+    /// ```
+    ///
+    /// Use instead:
+    /// ```toml
+    /// [features]
+    /// default = ["abc", "def", "ghi"]
+    /// abc = []
+    /// def = []
+    /// ghi = []
+    /// ```
+    ///
+    #[clippy::version = "1.57.0"]
+    pub REDUNDANT_FEATURE_NAMES,
+    cargo,
+    "usage of a redundant feature name"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for negative feature names with prefix `no-` or `not-`
+    ///
+    /// ### Why is this bad?
+    /// Features are supposed to be additive, and negatively-named features violate it.
+    ///
+    /// ### Example
+    /// ```toml
+    /// # The `Cargo.toml` with negative feature names
+    /// [features]
+    /// default = []
+    /// no-abc = []
+    /// not-def = []
+    ///
+    /// ```
+    /// Use instead:
+    /// ```toml
+    /// [features]
+    /// default = ["abc", "def"]
+    /// abc = []
+    /// def = []
+    ///
+    /// ```
+    #[clippy::version = "1.57.0"]
+    pub NEGATIVE_FEATURE_NAMES,
+    cargo,
+    "usage of a negative feature name"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks to see if multiple versions of a crate are being
+    /// used.
+    ///
+    /// ### Why is this bad?
+    /// This bloats the size of targets, and can lead to
+    /// confusing error messages when structs or traits are used interchangeably
+    /// between different versions of a crate.
+    ///
+    /// ### Known problems
+    /// Because this can be caused purely by the dependencies
+    /// themselves, it's not always possible to fix this issue.
+    ///
+    /// ### Example
+    /// ```toml
+    /// # This will pull in both winapi v0.3.x and v0.2.x, triggering a warning.
+    /// [dependencies]
+    /// ctrlc = "=3.1.0"
+    /// ansi_term = "=0.11.0"
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub MULTIPLE_CRATE_VERSIONS,
+    cargo,
+    "multiple versions of the same crate being used"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for wildcard dependencies in the `Cargo.toml`.
+    ///
+    /// ### Why is this bad?
+    /// [As the edition guide says](https://rust-lang-nursery.github.io/edition-guide/rust-2018/cargo-and-crates-io/crates-io-disallows-wildcard-dependencies.html),
+    /// it is highly unlikely that you work with any possible version of your dependency,
+    /// and wildcard dependencies would cause unnecessary breakage in the ecosystem.
+    ///
+    /// ### Example
+    /// ```toml
+    /// [dependencies]
+    /// regex = "*"
+    /// ```
+    #[clippy::version = "1.32.0"]
+    pub WILDCARD_DEPENDENCIES,
+    cargo,
+    "wildcard dependencies being used"
+}
+
+pub struct Cargo {
+    pub ignore_publish: bool,
+}
+
+impl_lint_pass!(Cargo => [
+    CARGO_COMMON_METADATA,
+    REDUNDANT_FEATURE_NAMES,
+    NEGATIVE_FEATURE_NAMES,
+    MULTIPLE_CRATE_VERSIONS,
+    WILDCARD_DEPENDENCIES
+]);
+
+impl LateLintPass<'_> for Cargo {
+    fn check_crate(&mut self, cx: &LateContext<'_>) {
+        static NO_DEPS_LINTS: &[&Lint] = &[
+            CARGO_COMMON_METADATA,
+            REDUNDANT_FEATURE_NAMES,
+            NEGATIVE_FEATURE_NAMES,
+            WILDCARD_DEPENDENCIES,
+        ];
+        static WITH_DEPS_LINTS: &[&Lint] = &[MULTIPLE_CRATE_VERSIONS];
+
+        if !NO_DEPS_LINTS
+            .iter()
+            .all(|&lint| is_lint_allowed(cx, lint, CRATE_HIR_ID))
+        {
+            match MetadataCommand::new().no_deps().exec() {
+                Ok(metadata) => {
+                    common_metadata::check(cx, &metadata, self.ignore_publish);
+                    feature_name::check(cx, &metadata);
+                    wildcard_dependencies::check(cx, &metadata);
+                },
+                Err(e) => {
+                    for lint in NO_DEPS_LINTS {
+                        span_lint(cx, lint, DUMMY_SP, &format!("could not read cargo metadata: {}", e));
+                    }
+                },
+            }
+        }
+
+        if !WITH_DEPS_LINTS
+            .iter()
+            .all(|&lint| is_lint_allowed(cx, lint, CRATE_HIR_ID))
+        {
+            match MetadataCommand::new().exec() {
+                Ok(metadata) => {
+                    multiple_crate_versions::check(cx, &metadata);
+                },
+                Err(e) => {
+                    for lint in WITH_DEPS_LINTS {
+                        span_lint(cx, lint, DUMMY_SP, &format!("could not read cargo metadata: {}", e));
+                    }
+                },
+            }
+        }
+    }
+}
diff --git a/clippy_lints/src/cargo/multiple_crate_versions.rs b/clippy_lints/src/cargo/multiple_crate_versions.rs
new file mode 100644
index 00000000000..76fd0819a39
--- /dev/null
+++ b/clippy_lints/src/cargo/multiple_crate_versions.rs
@@ -0,0 +1,63 @@
+//! lint on multiple versions of a crate being used
+
+use cargo_metadata::{DependencyKind, Metadata, Node, Package, PackageId};
+use clippy_utils::diagnostics::span_lint;
+use if_chain::if_chain;
+use itertools::Itertools;
+use rustc_hir::def_id::LOCAL_CRATE;
+use rustc_lint::LateContext;
+use rustc_span::source_map::DUMMY_SP;
+
+use super::MULTIPLE_CRATE_VERSIONS;
+
+pub(super) fn check(cx: &LateContext<'_>, metadata: &Metadata) {
+    let local_name = cx.tcx.crate_name(LOCAL_CRATE);
+    let mut packages = metadata.packages.clone();
+    packages.sort_by(|a, b| a.name.cmp(&b.name));
+
+    if_chain! {
+        if let Some(resolve) = &metadata.resolve;
+        if let Some(local_id) = packages
+            .iter()
+            .find_map(|p| if p.name == local_name.as_str() { Some(&p.id) } else { None });
+        then {
+            for (name, group) in &packages.iter().group_by(|p| p.name.clone()) {
+                let group: Vec<&Package> = group.collect();
+
+                if group.len() <= 1 {
+                    continue;
+                }
+
+                if group.iter().all(|p| is_normal_dep(&resolve.nodes, local_id, &p.id)) {
+                    let mut versions: Vec<_> = group.into_iter().map(|p| &p.version).collect();
+                    versions.sort();
+                    let versions = versions.iter().join(", ");
+
+                    span_lint(
+                        cx,
+                        MULTIPLE_CRATE_VERSIONS,
+                        DUMMY_SP,
+                        &format!("multiple versions for dependency `{}`: {}", name, versions),
+                    );
+                }
+            }
+        }
+    }
+}
+
+fn is_normal_dep(nodes: &[Node], local_id: &PackageId, dep_id: &PackageId) -> bool {
+    fn depends_on(node: &Node, dep_id: &PackageId) -> bool {
+        node.deps.iter().any(|dep| {
+            dep.pkg == *dep_id
+                && dep
+                    .dep_kinds
+                    .iter()
+                    .any(|info| matches!(info.kind, DependencyKind::Normal))
+        })
+    }
+
+    nodes
+        .iter()
+        .filter(|node| depends_on(node, dep_id))
+        .any(|node| node.id == *local_id || is_normal_dep(nodes, local_id, &node.id))
+}
diff --git a/clippy_lints/src/cargo/wildcard_dependencies.rs b/clippy_lints/src/cargo/wildcard_dependencies.rs
new file mode 100644
index 00000000000..7fa6acbf557
--- /dev/null
+++ b/clippy_lints/src/cargo/wildcard_dependencies.rs
@@ -0,0 +1,27 @@
+use cargo_metadata::Metadata;
+use clippy_utils::diagnostics::span_lint;
+use if_chain::if_chain;
+use rustc_lint::LateContext;
+use rustc_span::source_map::DUMMY_SP;
+
+use super::WILDCARD_DEPENDENCIES;
+
+pub(super) fn check(cx: &LateContext<'_>, metadata: &Metadata) {
+    for dep in &metadata.packages[0].dependencies {
+        // VersionReq::any() does not work
+        if_chain! {
+            if let Ok(wildcard_ver) = semver::VersionReq::parse("*");
+            if let Some(ref source) = dep.source;
+            if !source.starts_with("git");
+            if dep.req == wildcard_ver;
+            then {
+                span_lint(
+                    cx,
+                    WILDCARD_DEPENDENCIES,
+                    DUMMY_SP,
+                    &format!("wildcard dependency for `{}`", dep.name),
+                );
+            }
+        }
+    }
+}
diff --git a/clippy_lints/src/cargo_common_metadata.rs b/clippy_lints/src/cargo_common_metadata.rs
deleted file mode 100644
index 23f79fdc682..00000000000
--- a/clippy_lints/src/cargo_common_metadata.rs
+++ /dev/null
@@ -1,118 +0,0 @@
-//! lint on missing cargo common metadata
-
-use clippy_utils::{diagnostics::span_lint, is_lint_allowed};
-use rustc_hir::hir_id::CRATE_HIR_ID;
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::source_map::DUMMY_SP;
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks to see if all common metadata is defined in
-    /// `Cargo.toml`. See: https://rust-lang-nursery.github.io/api-guidelines/documentation.html#cargotoml-includes-all-common-metadata-c-metadata
-    ///
-    /// ### Why is this bad?
-    /// It will be more difficult for users to discover the
-    /// purpose of the crate, and key information related to it.
-    ///
-    /// ### Example
-    /// ```toml
-    /// # This `Cargo.toml` is missing a description field:
-    /// [package]
-    /// name = "clippy"
-    /// version = "0.0.212"
-    /// repository = "https://github.com/rust-lang/rust-clippy"
-    /// readme = "README.md"
-    /// license = "MIT OR Apache-2.0"
-    /// keywords = ["clippy", "lint", "plugin"]
-    /// categories = ["development-tools", "development-tools::cargo-plugins"]
-    /// ```
-    ///
-    /// Should include a description field like:
-    ///
-    /// ```toml
-    /// # This `Cargo.toml` includes all common metadata
-    /// [package]
-    /// name = "clippy"
-    /// version = "0.0.212"
-    /// description = "A bunch of helpful lints to avoid common pitfalls in Rust"
-    /// repository = "https://github.com/rust-lang/rust-clippy"
-    /// readme = "README.md"
-    /// license = "MIT OR Apache-2.0"
-    /// keywords = ["clippy", "lint", "plugin"]
-    /// categories = ["development-tools", "development-tools::cargo-plugins"]
-    /// ```
-    #[clippy::version = "1.32.0"]
-    pub CARGO_COMMON_METADATA,
-    cargo,
-    "common metadata is defined in `Cargo.toml`"
-}
-
-#[derive(Copy, Clone, Debug)]
-pub struct CargoCommonMetadata {
-    ignore_publish: bool,
-}
-
-impl CargoCommonMetadata {
-    pub fn new(ignore_publish: bool) -> Self {
-        Self { ignore_publish }
-    }
-}
-
-impl_lint_pass!(CargoCommonMetadata => [
-    CARGO_COMMON_METADATA
-]);
-
-fn missing_warning(cx: &LateContext<'_>, package: &cargo_metadata::Package, field: &str) {
-    let message = format!("package `{}` is missing `{}` metadata", package.name, field);
-    span_lint(cx, CARGO_COMMON_METADATA, DUMMY_SP, &message);
-}
-
-fn is_empty_str<T: AsRef<std::ffi::OsStr>>(value: &Option<T>) -> bool {
-    value.as_ref().map_or(true, |s| s.as_ref().is_empty())
-}
-
-fn is_empty_vec(value: &[String]) -> bool {
-    // This works because empty iterators return true
-    value.iter().all(String::is_empty)
-}
-
-impl LateLintPass<'_> for CargoCommonMetadata {
-    fn check_crate(&mut self, cx: &LateContext<'_>) {
-        if is_lint_allowed(cx, CARGO_COMMON_METADATA, CRATE_HIR_ID) {
-            return;
-        }
-
-        let metadata = unwrap_cargo_metadata!(cx, CARGO_COMMON_METADATA, false);
-
-        for package in metadata.packages {
-            // only run the lint if publish is `None` (`publish = true` or skipped entirely)
-            // or if the vector isn't empty (`publish = ["something"]`)
-            if package.publish.as_ref().filter(|publish| publish.is_empty()).is_none() || self.ignore_publish {
-                if is_empty_str(&package.description) {
-                    missing_warning(cx, &package, "package.description");
-                }
-
-                if is_empty_str(&package.license) && is_empty_str(&package.license_file) {
-                    missing_warning(cx, &package, "either package.license or package.license_file");
-                }
-
-                if is_empty_str(&package.repository) {
-                    missing_warning(cx, &package, "package.repository");
-                }
-
-                if is_empty_str(&package.readme) {
-                    missing_warning(cx, &package, "package.readme");
-                }
-
-                if is_empty_vec(&package.keywords) {
-                    missing_warning(cx, &package, "package.keywords");
-                }
-
-                if is_empty_vec(&package.categories) {
-                    missing_warning(cx, &package, "package.categories");
-                }
-            }
-        }
-    }
-}
diff --git a/clippy_lints/src/feature_name.rs b/clippy_lints/src/feature_name.rs
deleted file mode 100644
index dc6bef52ddd..00000000000
--- a/clippy_lints/src/feature_name.rs
+++ /dev/null
@@ -1,166 +0,0 @@
-use clippy_utils::diagnostics::span_lint_and_help;
-use clippy_utils::{diagnostics::span_lint, is_lint_allowed};
-use rustc_hir::CRATE_HIR_ID;
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::source_map::DUMMY_SP;
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for feature names with prefix `use-`, `with-` or suffix `-support`
-    ///
-    /// ### Why is this bad?
-    /// These prefixes and suffixes have no significant meaning.
-    ///
-    /// ### Example
-    /// ```toml
-    /// # The `Cargo.toml` with feature name redundancy
-    /// [features]
-    /// default = ["use-abc", "with-def", "ghi-support"]
-    /// use-abc = []  // redundant
-    /// with-def = []   // redundant
-    /// ghi-support = []   // redundant
-    /// ```
-    ///
-    /// Use instead:
-    /// ```toml
-    /// [features]
-    /// default = ["abc", "def", "ghi"]
-    /// abc = []
-    /// def = []
-    /// ghi = []
-    /// ```
-    ///
-    #[clippy::version = "1.57.0"]
-    pub REDUNDANT_FEATURE_NAMES,
-    cargo,
-    "usage of a redundant feature name"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for negative feature names with prefix `no-` or `not-`
-    ///
-    /// ### Why is this bad?
-    /// Features are supposed to be additive, and negatively-named features violate it.
-    ///
-    /// ### Example
-    /// ```toml
-    /// # The `Cargo.toml` with negative feature names
-    /// [features]
-    /// default = []
-    /// no-abc = []
-    /// not-def = []
-    ///
-    /// ```
-    /// Use instead:
-    /// ```toml
-    /// [features]
-    /// default = ["abc", "def"]
-    /// abc = []
-    /// def = []
-    ///
-    /// ```
-    #[clippy::version = "1.57.0"]
-    pub NEGATIVE_FEATURE_NAMES,
-    cargo,
-    "usage of a negative feature name"
-}
-
-declare_lint_pass!(FeatureName => [REDUNDANT_FEATURE_NAMES, NEGATIVE_FEATURE_NAMES]);
-
-static PREFIXES: [&str; 8] = ["no-", "no_", "not-", "not_", "use-", "use_", "with-", "with_"];
-static SUFFIXES: [&str; 2] = ["-support", "_support"];
-
-fn is_negative_prefix(s: &str) -> bool {
-    s.starts_with("no")
-}
-
-fn lint(cx: &LateContext<'_>, feature: &str, substring: &str, is_prefix: bool) {
-    let is_negative = is_prefix && is_negative_prefix(substring);
-    span_lint_and_help(
-        cx,
-        if is_negative {
-            NEGATIVE_FEATURE_NAMES
-        } else {
-            REDUNDANT_FEATURE_NAMES
-        },
-        DUMMY_SP,
-        &format!(
-            "the \"{}\" {} in the feature name \"{}\" is {}",
-            substring,
-            if is_prefix { "prefix" } else { "suffix" },
-            feature,
-            if is_negative { "negative" } else { "redundant" }
-        ),
-        None,
-        &format!(
-            "consider renaming the feature to \"{}\"{}",
-            if is_prefix {
-                feature.strip_prefix(substring)
-            } else {
-                feature.strip_suffix(substring)
-            }
-            .unwrap(),
-            if is_negative {
-                ", but make sure the feature adds functionality"
-            } else {
-                ""
-            }
-        ),
-    );
-}
-
-impl LateLintPass<'_> for FeatureName {
-    fn check_crate(&mut self, cx: &LateContext<'_>) {
-        if is_lint_allowed(cx, REDUNDANT_FEATURE_NAMES, CRATE_HIR_ID)
-            && is_lint_allowed(cx, NEGATIVE_FEATURE_NAMES, CRATE_HIR_ID)
-        {
-            return;
-        }
-
-        let metadata = unwrap_cargo_metadata!(cx, REDUNDANT_FEATURE_NAMES, false);
-
-        for package in metadata.packages {
-            let mut features: Vec<&String> = package.features.keys().collect();
-            features.sort();
-            for feature in features {
-                let prefix_opt = {
-                    let i = PREFIXES.partition_point(|prefix| prefix < &feature.as_str());
-                    if i > 0 && feature.starts_with(PREFIXES[i - 1]) {
-                        Some(PREFIXES[i - 1])
-                    } else {
-                        None
-                    }
-                };
-                if let Some(prefix) = prefix_opt {
-                    lint(cx, feature, prefix, true);
-                }
-
-                let suffix_opt: Option<&str> = {
-                    let i = SUFFIXES.partition_point(|suffix| {
-                        suffix.bytes().rev().cmp(feature.bytes().rev()) == std::cmp::Ordering::Less
-                    });
-                    if i > 0 && feature.ends_with(SUFFIXES[i - 1]) {
-                        Some(SUFFIXES[i - 1])
-                    } else {
-                        None
-                    }
-                };
-                if let Some(suffix) = suffix_opt {
-                    lint(cx, feature, suffix, false);
-                }
-            }
-        }
-    }
-}
-
-#[test]
-fn test_prefixes_sorted() {
-    let mut sorted_prefixes = PREFIXES;
-    sorted_prefixes.sort_unstable();
-    assert_eq!(PREFIXES, sorted_prefixes);
-    let mut sorted_suffixes = SUFFIXES;
-    sorted_suffixes.sort_by(|a, b| a.bytes().rev().cmp(b.bytes().rev()));
-    assert_eq!(SUFFIXES, sorted_suffixes);
-}
diff --git a/clippy_lints/src/lib.register_cargo.rs b/clippy_lints/src/lib.register_cargo.rs
index 1809f2cc7d4..c890523fe5a 100644
--- a/clippy_lints/src/lib.register_cargo.rs
+++ b/clippy_lints/src/lib.register_cargo.rs
@@ -3,9 +3,9 @@
 // Manual edits will be overwritten.
 
 store.register_group(true, "clippy::cargo", Some("clippy_cargo"), vec![
-    LintId::of(cargo_common_metadata::CARGO_COMMON_METADATA),
-    LintId::of(feature_name::NEGATIVE_FEATURE_NAMES),
-    LintId::of(feature_name::REDUNDANT_FEATURE_NAMES),
-    LintId::of(multiple_crate_versions::MULTIPLE_CRATE_VERSIONS),
-    LintId::of(wildcard_dependencies::WILDCARD_DEPENDENCIES),
+    LintId::of(cargo::CARGO_COMMON_METADATA),
+    LintId::of(cargo::MULTIPLE_CRATE_VERSIONS),
+    LintId::of(cargo::NEGATIVE_FEATURE_NAMES),
+    LintId::of(cargo::REDUNDANT_FEATURE_NAMES),
+    LintId::of(cargo::WILDCARD_DEPENDENCIES),
 ])
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index a80320a578f..7a62a99f5ff 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -61,7 +61,11 @@ store.register_lints(&[
     booleans::NONMINIMAL_BOOL,
     borrow_as_ptr::BORROW_AS_PTR,
     bytecount::NAIVE_BYTECOUNT,
-    cargo_common_metadata::CARGO_COMMON_METADATA,
+    cargo::CARGO_COMMON_METADATA,
+    cargo::MULTIPLE_CRATE_VERSIONS,
+    cargo::NEGATIVE_FEATURE_NAMES,
+    cargo::REDUNDANT_FEATURE_NAMES,
+    cargo::WILDCARD_DEPENDENCIES,
     case_sensitive_file_extension_comparisons::CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS,
     casts::CAST_LOSSLESS,
     casts::CAST_POSSIBLE_TRUNCATION,
@@ -139,8 +143,6 @@ store.register_lints(&[
     exit::EXIT,
     explicit_write::EXPLICIT_WRITE,
     fallible_impl_from::FALLIBLE_IMPL_FROM,
-    feature_name::NEGATIVE_FEATURE_NAMES,
-    feature_name::REDUNDANT_FEATURE_NAMES,
     float_equality_without_abs::FLOAT_EQUALITY_WITHOUT_ABS,
     float_literal::EXCESSIVE_PRECISION,
     float_literal::LOSSY_FLOAT_LITERAL,
@@ -353,7 +355,6 @@ store.register_lints(&[
     module_style::MOD_MODULE_FILES,
     module_style::SELF_NAMED_MODULE_FILES,
     modulo_arithmetic::MODULO_ARITHMETIC,
-    multiple_crate_versions::MULTIPLE_CRATE_VERSIONS,
     mut_key::MUTABLE_KEY_TYPE,
     mut_mut::MUT_MUT,
     mut_mutex_lock::MUT_MUTEX_LOCK,
@@ -520,7 +521,6 @@ store.register_lints(&[
     vec_init_then_push::VEC_INIT_THEN_PUSH,
     vec_resize_to_zero::VEC_RESIZE_TO_ZERO,
     verbose_file_reads::VERBOSE_FILE_READS,
-    wildcard_dependencies::WILDCARD_DEPENDENCIES,
     wildcard_imports::ENUM_GLOB_USE,
     wildcard_imports::WILDCARD_IMPORTS,
     write::PRINTLN_EMPTY_STRING,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 3bd7699792a..e78f6187359 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -178,7 +178,7 @@ mod bool_assert_comparison;
 mod booleans;
 mod borrow_as_ptr;
 mod bytecount;
-mod cargo_common_metadata;
+mod cargo;
 mod case_sensitive_file_extension_comparisons;
 mod casts;
 mod checked_conversions;
@@ -220,7 +220,6 @@ mod exhaustive_items;
 mod exit;
 mod explicit_write;
 mod fallible_impl_from;
-mod feature_name;
 mod float_equality_without_abs;
 mod float_literal;
 mod floating_point_arithmetic;
@@ -290,7 +289,6 @@ mod missing_enforced_import_rename;
 mod missing_inline;
 mod module_style;
 mod modulo_arithmetic;
-mod multiple_crate_versions;
 mod mut_key;
 mod mut_mut;
 mod mut_mutex_lock;
@@ -399,7 +397,6 @@ mod vec;
 mod vec_init_then_push;
 mod vec_resize_to_zero;
 mod verbose_file_reads;
-mod wildcard_dependencies;
 mod wildcard_imports;
 mod write;
 mod zero_div_zero;
@@ -724,10 +721,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_early_pass(|| Box::new(redundant_else::RedundantElse));
     store.register_late_pass(|| Box::new(create_dir::CreateDir));
     store.register_early_pass(|| Box::new(needless_arbitrary_self_type::NeedlessArbitrarySelfType));
-    let cargo_ignore_publish = conf.cargo_ignore_publish;
-    store.register_late_pass(move || Box::new(cargo_common_metadata::CargoCommonMetadata::new(cargo_ignore_publish)));
-    store.register_late_pass(|| Box::new(multiple_crate_versions::MultipleCrateVersions));
-    store.register_late_pass(|| Box::new(wildcard_dependencies::WildcardDependencies));
     let literal_representation_lint_fraction_readability = conf.unreadable_literal_lint_fractions;
     store.register_early_pass(move || {
         Box::new(literal_representation::LiteralDigitGrouping::new(
@@ -842,7 +835,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_early_pass(move || Box::new(disallowed_script_idents::DisallowedScriptIdents::new(&scripts)));
     store.register_late_pass(|| Box::new(strlen_on_c_strings::StrlenOnCStrings));
     store.register_late_pass(move || Box::new(self_named_constructors::SelfNamedConstructors));
-    store.register_late_pass(move || Box::new(feature_name::FeatureName));
     store.register_late_pass(move || Box::new(iter_not_returning_iterator::IterNotReturningIterator));
     store.register_late_pass(move || Box::new(manual_assert::ManualAssert));
     let enable_raw_pointer_heuristic_for_send = conf.enable_raw_pointer_heuristic_for_send;
@@ -864,6 +856,12 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(move || Box::new(manual_bits::ManualBits::new(msrv)));
     store.register_late_pass(|| Box::new(default_union_representation::DefaultUnionRepresentation));
     store.register_late_pass(|| Box::new(dbg_macro::DbgMacro));
+    let cargo_ignore_publish = conf.cargo_ignore_publish;
+    store.register_late_pass(move || {
+        Box::new(cargo::Cargo {
+            ignore_publish: cargo_ignore_publish,
+        })
+    });
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/multiple_crate_versions.rs b/clippy_lints/src/multiple_crate_versions.rs
deleted file mode 100644
index 1f9db39cf8c..00000000000
--- a/clippy_lints/src/multiple_crate_versions.rs
+++ /dev/null
@@ -1,101 +0,0 @@
-//! lint on multiple versions of a crate being used
-
-use clippy_utils::diagnostics::span_lint;
-use clippy_utils::is_lint_allowed;
-use rustc_hir::def_id::LOCAL_CRATE;
-use rustc_hir::CRATE_HIR_ID;
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::source_map::DUMMY_SP;
-
-use cargo_metadata::{DependencyKind, Node, Package, PackageId};
-use if_chain::if_chain;
-use itertools::Itertools;
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks to see if multiple versions of a crate are being
-    /// used.
-    ///
-    /// ### Why is this bad?
-    /// This bloats the size of targets, and can lead to
-    /// confusing error messages when structs or traits are used interchangeably
-    /// between different versions of a crate.
-    ///
-    /// ### Known problems
-    /// Because this can be caused purely by the dependencies
-    /// themselves, it's not always possible to fix this issue.
-    ///
-    /// ### Example
-    /// ```toml
-    /// # This will pull in both winapi v0.3.x and v0.2.x, triggering a warning.
-    /// [dependencies]
-    /// ctrlc = "=3.1.0"
-    /// ansi_term = "=0.11.0"
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub MULTIPLE_CRATE_VERSIONS,
-    cargo,
-    "multiple versions of the same crate being used"
-}
-
-declare_lint_pass!(MultipleCrateVersions => [MULTIPLE_CRATE_VERSIONS]);
-
-impl LateLintPass<'_> for MultipleCrateVersions {
-    fn check_crate(&mut self, cx: &LateContext<'_>) {
-        if is_lint_allowed(cx, MULTIPLE_CRATE_VERSIONS, CRATE_HIR_ID) {
-            return;
-        }
-
-        let metadata = unwrap_cargo_metadata!(cx, MULTIPLE_CRATE_VERSIONS, true);
-        let local_name = cx.tcx.crate_name(LOCAL_CRATE);
-        let mut packages = metadata.packages;
-        packages.sort_by(|a, b| a.name.cmp(&b.name));
-
-        if_chain! {
-            if let Some(resolve) = &metadata.resolve;
-            if let Some(local_id) = packages
-                .iter()
-                .find_map(|p| if p.name == local_name.as_str() { Some(&p.id) } else { None });
-            then {
-                for (name, group) in &packages.iter().group_by(|p| p.name.clone()) {
-                    let group: Vec<&Package> = group.collect();
-
-                    if group.len() <= 1 {
-                        continue;
-                    }
-
-                    if group.iter().all(|p| is_normal_dep(&resolve.nodes, local_id, &p.id)) {
-                        let mut versions: Vec<_> = group.into_iter().map(|p| &p.version).collect();
-                        versions.sort();
-                        let versions = versions.iter().join(", ");
-
-                        span_lint(
-                            cx,
-                            MULTIPLE_CRATE_VERSIONS,
-                            DUMMY_SP,
-                            &format!("multiple versions for dependency `{}`: {}", name, versions),
-                        );
-                    }
-                }
-            }
-        }
-    }
-}
-
-fn is_normal_dep(nodes: &[Node], local_id: &PackageId, dep_id: &PackageId) -> bool {
-    fn depends_on(node: &Node, dep_id: &PackageId) -> bool {
-        node.deps.iter().any(|dep| {
-            dep.pkg == *dep_id
-                && dep
-                    .dep_kinds
-                    .iter()
-                    .any(|info| matches!(info.kind, DependencyKind::Normal))
-        })
-    }
-
-    nodes
-        .iter()
-        .filter(|node| depends_on(node, dep_id))
-        .any(|node| node.id == *local_id || is_normal_dep(nodes, local_id, &node.id))
-}
diff --git a/clippy_lints/src/wildcard_dependencies.rs b/clippy_lints/src/wildcard_dependencies.rs
deleted file mode 100644
index 80d7b8a1b6d..00000000000
--- a/clippy_lints/src/wildcard_dependencies.rs
+++ /dev/null
@@ -1,57 +0,0 @@
-use clippy_utils::{diagnostics::span_lint, is_lint_allowed};
-use rustc_hir::hir_id::CRATE_HIR_ID;
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::source_map::DUMMY_SP;
-
-use if_chain::if_chain;
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for wildcard dependencies in the `Cargo.toml`.
-    ///
-    /// ### Why is this bad?
-    /// [As the edition guide says](https://rust-lang-nursery.github.io/edition-guide/rust-2018/cargo-and-crates-io/crates-io-disallows-wildcard-dependencies.html),
-    /// it is highly unlikely that you work with any possible version of your dependency,
-    /// and wildcard dependencies would cause unnecessary breakage in the ecosystem.
-    ///
-    /// ### Example
-    /// ```toml
-    /// [dependencies]
-    /// regex = "*"
-    /// ```
-    #[clippy::version = "1.32.0"]
-    pub WILDCARD_DEPENDENCIES,
-    cargo,
-    "wildcard dependencies being used"
-}
-
-declare_lint_pass!(WildcardDependencies => [WILDCARD_DEPENDENCIES]);
-
-impl LateLintPass<'_> for WildcardDependencies {
-    fn check_crate(&mut self, cx: &LateContext<'_>) {
-        if is_lint_allowed(cx, WILDCARD_DEPENDENCIES, CRATE_HIR_ID) {
-            return;
-        }
-
-        let metadata = unwrap_cargo_metadata!(cx, WILDCARD_DEPENDENCIES, false);
-
-        for dep in &metadata.packages[0].dependencies {
-            // VersionReq::any() does not work
-            if_chain! {
-                if let Ok(wildcard_ver) = semver::VersionReq::parse("*");
-                if let Some(ref source) = dep.source;
-                if !source.starts_with("git");
-                if dep.req == wildcard_ver;
-                then {
-                    span_lint(
-                        cx,
-                        WILDCARD_DEPENDENCIES,
-                        DUMMY_SP,
-                        &format!("wildcard dependency for `{}`", dep.name),
-                    );
-                }
-            }
-        }
-    }
-}
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 42955080c96..73d91550693 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -2042,24 +2042,6 @@ pub fn peel_ref_operators<'hir>(cx: &LateContext<'_>, mut expr: &'hir Expr<'hir>
     expr
 }
 
-#[macro_export]
-macro_rules! unwrap_cargo_metadata {
-    ($cx: ident, $lint: ident, $deps: expr) => {{
-        let mut command = cargo_metadata::MetadataCommand::new();
-        if !$deps {
-            command.no_deps();
-        }
-
-        match command.exec() {
-            Ok(metadata) => metadata,
-            Err(err) => {
-                span_lint($cx, $lint, DUMMY_SP, &format!("could not read cargo metadata: {}", err));
-                return;
-            },
-        }
-    }};
-}
-
 pub fn is_hir_ty_cfg_dependant(cx: &LateContext<'_>, ty: &hir::Ty<'_>) -> bool {
     if let TyKind::Path(QPath::Resolved(_, path)) = ty.kind {
         if let Res::Def(_, def_id) = path.res {
-- 
cgit 1.4.1-3-g733a5


From 78c2e0bfe98bc0490bd97a319104e2bd811c3c91 Mon Sep 17 00:00:00 2001
From: nsunderland1 <sunderland.nicholas@protonmail.com>
Date: Sun, 13 Feb 2022 17:07:14 -0800
Subject: Document `pub` requirement for `new_without_default` lint

---
 clippy_lints/src/new_without_default.rs | 10 +++++-----
 tests/ui/new_without_default.rs         | 16 ++++++++++++++++
 tests/ui/new_without_default.stderr     |  8 ++++----
 3 files changed, 25 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/new_without_default.rs b/clippy_lints/src/new_without_default.rs
index f86af7a7bb6..47121ad84f2 100644
--- a/clippy_lints/src/new_without_default.rs
+++ b/clippy_lints/src/new_without_default.rs
@@ -13,7 +13,7 @@ use rustc_span::sym;
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for types with a `fn new() -> Self` method and no
+    /// Checks for public types with a `pub fn new() -> Self` method and no
     /// implementation of
     /// [`Default`](https://doc.rust-lang.org/std/default/trait.Default.html).
     ///
@@ -24,10 +24,10 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```ignore
-    /// struct Foo(Bar);
+    /// pub struct Foo(Bar);
     ///
     /// impl Foo {
-    ///     fn new() -> Self {
+    ///     pub fn new() -> Self {
     ///         Foo(Bar::new())
     ///     }
     /// }
@@ -36,7 +36,7 @@ declare_clippy_lint! {
     /// To fix the lint, add a `Default` implementation that delegates to `new`:
     ///
     /// ```ignore
-    /// struct Foo(Bar);
+    /// pub struct Foo(Bar);
     ///
     /// impl Default for Foo {
     ///     fn default() -> Self {
@@ -47,7 +47,7 @@ declare_clippy_lint! {
     #[clippy::version = "pre 1.29.0"]
     pub NEW_WITHOUT_DEFAULT,
     style,
-    "`fn new() -> Self` method without `Default` implementation"
+    "`pub fn new() -> Self` method without `Default` implementation"
 }
 
 #[derive(Clone, Default)]
diff --git a/tests/ui/new_without_default.rs b/tests/ui/new_without_default.rs
index 4b2e7444dcf..c76e3b42438 100644
--- a/tests/ui/new_without_default.rs
+++ b/tests/ui/new_without_default.rs
@@ -90,6 +90,22 @@ impl Private {
     } // We don't lint private items
 }
 
+struct PrivateStruct;
+
+impl PrivateStruct {
+    pub fn new() -> PrivateStruct {
+        unimplemented!()
+    } // We don't lint public items on private structs
+}
+
+pub struct PrivateItem;
+
+impl PrivateItem {
+    fn new() -> PrivateItem {
+        unimplemented!()
+    } // We don't lint private items on public structs
+}
+
 struct Const;
 
 impl Const {
diff --git a/tests/ui/new_without_default.stderr b/tests/ui/new_without_default.stderr
index 14ddb66f232..19572dfe8b0 100644
--- a/tests/ui/new_without_default.stderr
+++ b/tests/ui/new_without_default.stderr
@@ -51,7 +51,7 @@ LL + }
    |
 
 error: you should consider adding a `Default` implementation for `NewNotEqualToDerive`
-  --> $DIR/new_without_default.rs:156:5
+  --> $DIR/new_without_default.rs:172:5
    |
 LL | /     pub fn new() -> Self {
 LL | |         NewNotEqualToDerive { foo: 1 }
@@ -68,7 +68,7 @@ LL + }
    |
 
 error: you should consider adding a `Default` implementation for `FooGenerics<T>`
-  --> $DIR/new_without_default.rs:164:5
+  --> $DIR/new_without_default.rs:180:5
    |
 LL | /     pub fn new() -> Self {
 LL | |         Self(Default::default())
@@ -85,7 +85,7 @@ LL + }
    |
 
 error: you should consider adding a `Default` implementation for `BarGenerics<T>`
-  --> $DIR/new_without_default.rs:171:5
+  --> $DIR/new_without_default.rs:187:5
    |
 LL | /     pub fn new() -> Self {
 LL | |         Self(Default::default())
@@ -102,7 +102,7 @@ LL + }
    |
 
 error: you should consider adding a `Default` implementation for `Foo<T>`
-  --> $DIR/new_without_default.rs:182:9
+  --> $DIR/new_without_default.rs:198:9
    |
 LL | /         pub fn new() -> Self {
 LL | |             todo!()
-- 
cgit 1.4.1-3-g733a5


From b162b11abc4c5275b2bf2f2f4679f0b6d72be2cb Mon Sep 17 00:00:00 2001
From: James McMurray <jamesmcm03@gmail.com>
Date: Tue, 28 Dec 2021 19:27:11 +0100
Subject: Add recursive_format_impl lint

The to_string_in_display lint is renamed to recursive_format_impl
A check is added for the use of self formatted with Display or Debug
inside any format string in the same impl
The to_string_in_display check is kept as is - like in the
format_in_format_args lint

For now only Display and Debug are checked
This could also be extended to other Format traits (Binary, etc.)
---
 CHANGELOG.md                                 |   6 +-
 clippy_lints/src/format_args.rs              |  26 +--
 clippy_lints/src/lib.register_all.rs         |   2 +-
 clippy_lints/src/lib.register_correctness.rs |   2 +-
 clippy_lints/src/lib.register_lints.rs       |   2 +-
 clippy_lints/src/lib.rs                      |   5 +-
 clippy_lints/src/recursive_format_impl.rs    | 190 ++++++++++++++++
 clippy_lints/src/to_string_in_display.rs     | 123 ----------
 clippy_utils/src/macros.rs                   |  26 +++
 clippy_utils/src/paths.rs                    |   1 +
 tests/ui/recursive_format_impl.rs            | 321 +++++++++++++++++++++++++++
 tests/ui/recursive_format_impl.stderr        |  91 ++++++++
 tests/ui/rename.fixed                        |   2 +
 tests/ui/rename.rs                           |   2 +
 tests/ui/rename.stderr                       |  74 +++---
 tests/ui/to_string_in_display.rs             |  69 ------
 tests/ui/to_string_in_display.stderr         |  19 --
 17 files changed, 685 insertions(+), 276 deletions(-)
 create mode 100644 clippy_lints/src/recursive_format_impl.rs
 delete mode 100644 clippy_lints/src/to_string_in_display.rs
 create mode 100644 tests/ui/recursive_format_impl.rs
 create mode 100644 tests/ui/recursive_format_impl.stderr
 delete mode 100644 tests/ui/to_string_in_display.rs
 delete mode 100644 tests/ui/to_string_in_display.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index c9adf77c0d6..c3da1d1f69a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1438,7 +1438,7 @@ Released 2020-11-19
 * [`manual_strip`] [#6038](https://github.com/rust-lang/rust-clippy/pull/6038)
 * [`map_err_ignore`] [#5998](https://github.com/rust-lang/rust-clippy/pull/5998)
 * [`rc_buffer`] [#6044](https://github.com/rust-lang/rust-clippy/pull/6044)
-* [`to_string_in_display`] [#5831](https://github.com/rust-lang/rust-clippy/pull/5831)
+* `to_string_in_display` [#5831](https://github.com/rust-lang/rust-clippy/pull/5831)
 * `single_char_push_str` [#5881](https://github.com/rust-lang/rust-clippy/pull/5881)
 
 ### Moves and Deprecations
@@ -1481,7 +1481,7 @@ Released 2020-11-19
   [#5949](https://github.com/rust-lang/rust-clippy/pull/5949)
 * [`doc_markdown`]: allow using "GraphQL" without backticks
   [#5996](https://github.com/rust-lang/rust-clippy/pull/5996)
-* [`to_string_in_display`]: avoid linting when calling `to_string()` on anything that is not `self`
+* `to_string_in_display`: avoid linting when calling `to_string()` on anything that is not `self`
   [#5971](https://github.com/rust-lang/rust-clippy/pull/5971)
 * [`indexing_slicing`] and [`out_of_bounds_indexing`] treat references to arrays as arrays
   [#6034](https://github.com/rust-lang/rust-clippy/pull/6034)
@@ -3385,6 +3385,7 @@ Released 2018-09-13
 [`range_zip_with_len`]: https://rust-lang.github.io/rust-clippy/master/index.html#range_zip_with_len
 [`rc_buffer`]: https://rust-lang.github.io/rust-clippy/master/index.html#rc_buffer
 [`rc_mutex`]: https://rust-lang.github.io/rust-clippy/master/index.html#rc_mutex
+[`recursive_format_impl`]: https://rust-lang.github.io/rust-clippy/master/index.html#recursive_format_impl
 [`redundant_allocation`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_allocation
 [`redundant_clone`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_clone
 [`redundant_closure`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_closure
@@ -3459,7 +3460,6 @@ Released 2018-09-13
 [`tabs_in_doc_comments`]: https://rust-lang.github.io/rust-clippy/master/index.html#tabs_in_doc_comments
 [`temporary_assignment`]: https://rust-lang.github.io/rust-clippy/master/index.html#temporary_assignment
 [`to_digit_is_some`]: https://rust-lang.github.io/rust-clippy/master/index.html#to_digit_is_some
-[`to_string_in_display`]: https://rust-lang.github.io/rust-clippy/master/index.html#to_string_in_display
 [`to_string_in_format_args`]: https://rust-lang.github.io/rust-clippy/master/index.html#to_string_in_format_args
 [`todo`]: https://rust-lang.github.io/rust-clippy/master/index.html#todo
 [`too_many_arguments`]: https://rust-lang.github.io/rust-clippy/master/index.html#too_many_arguments
diff --git a/clippy_lints/src/format_args.rs b/clippy_lints/src/format_args.rs
index 17b0749a4a9..ac3708636de 100644
--- a/clippy_lints/src/format_args.rs
+++ b/clippy_lints/src/format_args.rs
@@ -1,8 +1,8 @@
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
-use clippy_utils::macros::{FormatArgsArg, FormatArgsExpn};
+use clippy_utils::is_diag_trait_item;
+use clippy_utils::macros::{is_format_macro, FormatArgsArg, FormatArgsExpn};
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::implements_trait;
-use clippy_utils::{is_diag_trait_item, match_def_path, paths};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
@@ -65,21 +65,6 @@ declare_clippy_lint! {
 
 declare_lint_pass!(FormatArgs => [FORMAT_IN_FORMAT_ARGS, TO_STRING_IN_FORMAT_ARGS]);
 
-const FORMAT_MACRO_PATHS: &[&[&str]] = &[
-    &paths::FORMAT_ARGS_MACRO,
-    &paths::ASSERT_EQ_MACRO,
-    &paths::ASSERT_MACRO,
-    &paths::ASSERT_NE_MACRO,
-    &paths::EPRINT_MACRO,
-    &paths::EPRINTLN_MACRO,
-    &paths::PRINT_MACRO,
-    &paths::PRINTLN_MACRO,
-    &paths::WRITE_MACRO,
-    &paths::WRITELN_MACRO,
-];
-
-const FORMAT_MACRO_DIAG_ITEMS: &[Symbol] = &[sym::format_macro, sym::std_panic_macro];
-
 impl<'tcx> LateLintPass<'tcx> for FormatArgs {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
         if_chain! {
@@ -87,12 +72,7 @@ impl<'tcx> LateLintPass<'tcx> for FormatArgs {
             let expr_expn_data = expr.span.ctxt().outer_expn_data();
             let outermost_expn_data = outermost_expn_data(expr_expn_data);
             if let Some(macro_def_id) = outermost_expn_data.macro_def_id;
-            if FORMAT_MACRO_PATHS
-                .iter()
-                .any(|path| match_def_path(cx, macro_def_id, path))
-                || FORMAT_MACRO_DIAG_ITEMS
-                    .iter()
-                    .any(|diag_item| cx.tcx.is_diagnostic_item(*diag_item, macro_def_id));
+            if is_format_macro(cx, macro_def_id);
             if let ExpnKind::Macro(_, name) = outermost_expn_data.kind;
             if let Some(args) = format_args.args();
             then {
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index d93e34e76b4..de0ff536907 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -241,6 +241,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(ranges::MANUAL_RANGE_CONTAINS),
     LintId::of(ranges::RANGE_ZIP_WITH_LEN),
     LintId::of(ranges::REVERSED_EMPTY_RANGES),
+    LintId::of(recursive_format_impl::RECURSIVE_FORMAT_IMPL),
     LintId::of(redundant_clone::REDUNDANT_CLONE),
     LintId::of(redundant_closure_call::REDUNDANT_CLOSURE_CALL),
     LintId::of(redundant_field_names::REDUNDANT_FIELD_NAMES),
@@ -267,7 +268,6 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(tabs_in_doc_comments::TABS_IN_DOC_COMMENTS),
     LintId::of(temporary_assignment::TEMPORARY_ASSIGNMENT),
     LintId::of(to_digit_is_some::TO_DIGIT_IS_SOME),
-    LintId::of(to_string_in_display::TO_STRING_IN_DISPLAY),
     LintId::of(transmute::CROSSPOINTER_TRANSMUTE),
     LintId::of(transmute::TRANSMUTES_EXPRESSIBLE_AS_PTR_CASTS),
     LintId::of(transmute::TRANSMUTE_BYTES_TO_STR),
diff --git a/clippy_lints/src/lib.register_correctness.rs b/clippy_lints/src/lib.register_correctness.rs
index d013daa8e08..18fe44282ed 100644
--- a/clippy_lints/src/lib.register_correctness.rs
+++ b/clippy_lints/src/lib.register_correctness.rs
@@ -52,12 +52,12 @@ store.register_group(true, "clippy::correctness", Some("clippy_correctness"), ve
     LintId::of(ptr::INVALID_NULL_PTR_USAGE),
     LintId::of(ptr::MUT_FROM_REF),
     LintId::of(ranges::REVERSED_EMPTY_RANGES),
+    LintId::of(recursive_format_impl::RECURSIVE_FORMAT_IMPL),
     LintId::of(regex::INVALID_REGEX),
     LintId::of(self_assignment::SELF_ASSIGNMENT),
     LintId::of(serde_api::SERDE_API_MISUSE),
     LintId::of(size_of_in_element_count::SIZE_OF_IN_ELEMENT_COUNT),
     LintId::of(swap::ALMOST_SWAPPED),
-    LintId::of(to_string_in_display::TO_STRING_IN_DISPLAY),
     LintId::of(transmute::TRANSMUTE_UNDEFINED_REPR),
     LintId::of(transmute::UNSOUND_COLLECTION_TRANSMUTE),
     LintId::of(transmute::WRONG_TRANSMUTE),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 7a62a99f5ff..97e22e9a1f9 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -416,6 +416,7 @@ store.register_lints(&[
     ranges::RANGE_PLUS_ONE,
     ranges::RANGE_ZIP_WITH_LEN,
     ranges::REVERSED_EMPTY_RANGES,
+    recursive_format_impl::RECURSIVE_FORMAT_IMPL,
     redundant_clone::REDUNDANT_CLONE,
     redundant_closure_call::REDUNDANT_CLOSURE_CALL,
     redundant_else::REDUNDANT_ELSE,
@@ -460,7 +461,6 @@ store.register_lints(&[
     tabs_in_doc_comments::TABS_IN_DOC_COMMENTS,
     temporary_assignment::TEMPORARY_ASSIGNMENT,
     to_digit_is_some::TO_DIGIT_IS_SOME,
-    to_string_in_display::TO_STRING_IN_DISPLAY,
     trailing_empty_array::TRAILING_EMPTY_ARRAY,
     trait_bounds::TRAIT_DUPLICATION_IN_BOUNDS,
     trait_bounds::TYPE_REPETITION_IN_BOUNDS,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index e78f6187359..93b1d178ac2 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -332,6 +332,7 @@ mod ptr_eq;
 mod ptr_offset_with_cast;
 mod question_mark;
 mod ranges;
+mod recursive_format_impl;
 mod redundant_clone;
 mod redundant_closure_call;
 mod redundant_else;
@@ -364,7 +365,6 @@ mod swap;
 mod tabs_in_doc_comments;
 mod temporary_assignment;
 mod to_digit_is_some;
-mod to_string_in_display;
 mod trailing_empty_array;
 mod trait_bounds;
 mod transmute;
@@ -704,7 +704,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(modulo_arithmetic::ModuloArithmetic));
     store.register_early_pass(|| Box::new(reference::DerefAddrOf));
     store.register_early_pass(|| Box::new(double_parens::DoubleParens));
-    store.register_late_pass(|| Box::new(to_string_in_display::ToStringInDisplay::new()));
+    store.register_late_pass(|| Box::new(recursive_format_impl::RecursiveFormatImpl::new()));
     store.register_early_pass(|| Box::new(unsafe_removed_from_name::UnsafeNameRemoval));
     store.register_early_pass(|| Box::new(else_if_without_else::ElseIfWithoutElse));
     store.register_early_pass(|| Box::new(int_plus_one::IntPlusOne));
@@ -938,6 +938,7 @@ pub fn register_renamed(ls: &mut rustc_lint::LintStore) {
     ls.register_renamed("clippy::disallowed_type", "clippy::disallowed_types");
     ls.register_renamed("clippy::disallowed_method", "clippy::disallowed_methods");
     ls.register_renamed("clippy::ref_in_deref", "clippy::needless_borrow");
+    ls.register_renamed("clippy::to_string_in_display", "clippy::recursive_format_impl");
 
     // uplifted lints
     ls.register_renamed("clippy::invalid_ref", "invalid_value");
diff --git a/clippy_lints/src/recursive_format_impl.rs b/clippy_lints/src/recursive_format_impl.rs
new file mode 100644
index 00000000000..5bb9740749b
--- /dev/null
+++ b/clippy_lints/src/recursive_format_impl.rs
@@ -0,0 +1,190 @@
+use clippy_utils::diagnostics::span_lint;
+use clippy_utils::macros::{is_format_macro, root_macro_call_first_node, FormatArgsArg, FormatArgsExpn};
+use clippy_utils::{is_diag_trait_item, path_to_local, peel_ref_operators};
+use if_chain::if_chain;
+use rustc_hir::{Expr, ExprKind, Impl, Item, ItemKind, QPath};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::{sym, symbol::kw, Symbol};
+
+#[derive(Clone, Copy)]
+enum FormatTrait {
+    Debug,
+    Display,
+}
+
+impl FormatTrait {
+    fn name(self) -> Symbol {
+        match self {
+            FormatTrait::Debug => sym::Debug,
+            FormatTrait::Display => sym::Display,
+        }
+    }
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for format trait implementations (e.g. `Display`) with a recursive call to itself
+    /// which uses `self` as a parameter.
+    /// This is typically done indirectly with the `write!` macro or with `to_string()`.
+    ///
+    /// ### Why is this bad?
+    /// This will lead to infinite recursion and a stack overflow.
+    ///
+    /// ### Example
+    ///
+    /// ```rust
+    /// use std::fmt;
+    ///
+    /// struct Structure(i32);
+    /// impl fmt::Display for Structure {
+    ///     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    ///         write!(f, "{}", self.to_string())
+    ///     }
+    /// }
+    ///
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// use std::fmt;
+    ///
+    /// struct Structure(i32);
+    /// impl fmt::Display for Structure {
+    ///     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    ///         write!(f, "{}", self.0)
+    ///     }
+    /// }
+    /// ```
+    #[clippy::version = "1.48.0"]
+    pub RECURSIVE_FORMAT_IMPL,
+    correctness,
+    "Format trait method called while implementing the same Format trait"
+}
+
+#[derive(Default)]
+pub struct RecursiveFormatImpl {
+    // Whether we are inside Display or Debug trait impl - None for neither
+    format_trait_impl: Option<FormatTrait>,
+}
+
+impl RecursiveFormatImpl {
+    pub fn new() -> Self {
+        Self {
+            format_trait_impl: None,
+        }
+    }
+}
+
+impl_lint_pass!(RecursiveFormatImpl => [RECURSIVE_FORMAT_IMPL]);
+
+impl<'tcx> LateLintPass<'tcx> for RecursiveFormatImpl {
+    fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
+        if let Some(format_trait_impl) = is_format_trait_impl(cx, item) {
+            self.format_trait_impl = Some(format_trait_impl);
+        }
+    }
+
+    fn check_item_post(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
+        // Assume no nested Impl of Debug and Display within eachother
+        if is_format_trait_impl(cx, item).is_some() {
+            self.format_trait_impl = None;
+        }
+    }
+
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        match self.format_trait_impl {
+            Some(FormatTrait::Display) => {
+                check_to_string_in_display(cx, expr);
+                check_self_in_format_args(cx, expr, FormatTrait::Display);
+            },
+            Some(FormatTrait::Debug) => {
+                check_self_in_format_args(cx, expr, FormatTrait::Debug);
+            },
+            None => {},
+        }
+    }
+}
+
+fn check_to_string_in_display(cx: &LateContext<'_>, expr: &Expr<'_>) {
+    if_chain! {
+        // Get the hir_id of the object we are calling the method on
+        if let ExprKind::MethodCall(path, [ref self_arg, ..], _) = expr.kind;
+        // Is the method to_string() ?
+        if path.ident.name == sym!(to_string);
+        // Is the method a part of the ToString trait? (i.e. not to_string() implemented
+        // separately)
+        if let Some(expr_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
+        if is_diag_trait_item(cx, expr_def_id, sym::ToString);
+        // Is the method is called on self
+        if let ExprKind::Path(QPath::Resolved(_, path)) = self_arg.kind;
+        if let [segment] = path.segments;
+        if segment.ident.name == kw::SelfLower;
+        then {
+            span_lint(
+                cx,
+                RECURSIVE_FORMAT_IMPL,
+                expr.span,
+                "using `self.to_string` in `fmt::Display` implementation will cause infinite recursion",
+            );
+        }
+    }
+}
+
+fn check_self_in_format_args<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, impl_trait: FormatTrait) {
+    // Check each arg in format calls - do we ever use Display on self (directly or via deref)?
+    if_chain! {
+        if let Some(outer_macro) = root_macro_call_first_node(cx, expr);
+        if let macro_def_id = outer_macro.def_id;
+        if let Some(format_args) = FormatArgsExpn::find_nested(cx, expr, outer_macro.expn);
+        if is_format_macro(cx, macro_def_id);
+        if let Some(args) = format_args.args();
+        then {
+            for arg in args {
+                if arg.format_trait != impl_trait.name() {
+                    continue;
+                }
+                check_format_arg_self(cx, expr, &arg, impl_trait);
+            }
+        }
+    }
+}
+
+fn check_format_arg_self(cx: &LateContext<'_>, expr: &Expr<'_>, arg: &FormatArgsArg<'_>, impl_trait: FormatTrait) {
+    // Handle multiple dereferencing of references e.g. &&self
+    // Handle dereference of &self -> self that is equivalent (i.e. via *self in fmt() impl)
+    // Since the argument to fmt is itself a reference: &self
+    let reference = peel_ref_operators(cx, arg.value);
+    let map = cx.tcx.hir();
+    // Is the reference self?
+    let symbol_ident = impl_trait.name().to_ident_string();
+    if path_to_local(reference).map(|x| map.name(x)) == Some(kw::SelfLower) {
+        span_lint(
+            cx,
+            RECURSIVE_FORMAT_IMPL,
+            expr.span,
+            &format!(
+                "using `self` as `{}` in `impl {}` will cause infinite recursion",
+                &symbol_ident, &symbol_ident
+            ),
+        );
+    }
+}
+
+fn is_format_trait_impl(cx: &LateContext<'_>, item: &Item<'_>) -> Option<FormatTrait> {
+    if_chain! {
+        // Are we at an Impl?
+        if let ItemKind::Impl(Impl { of_trait: Some(trait_ref), .. }) = &item.kind;
+        if let Some(did) = trait_ref.trait_def_id();
+        if let Some(name) = cx.tcx.get_diagnostic_name(did);
+        then {
+            // Is Impl for Debug or Display?
+            match name {
+                sym::Debug => Some(FormatTrait::Debug),
+                sym::Display => Some(FormatTrait::Display),
+                _ => None,
+            }
+        } else {
+            None
+        }
+    }
+}
diff --git a/clippy_lints/src/to_string_in_display.rs b/clippy_lints/src/to_string_in_display.rs
deleted file mode 100644
index 03060d78fc5..00000000000
--- a/clippy_lints/src/to_string_in_display.rs
+++ /dev/null
@@ -1,123 +0,0 @@
-use clippy_utils::diagnostics::span_lint;
-use clippy_utils::{is_diag_trait_item, match_def_path, path_to_local_id, paths};
-use if_chain::if_chain;
-use rustc_hir::{Expr, ExprKind, HirId, Impl, ImplItem, ImplItemKind, Item, ItemKind};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::symbol::sym;
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for uses of `to_string()` in `Display` traits.
-    ///
-    /// ### Why is this bad?
-    /// Usually `to_string` is implemented indirectly
-    /// via `Display`. Hence using it while implementing `Display` would
-    /// lead to infinite recursion.
-    ///
-    /// ### Example
-    ///
-    /// ```rust
-    /// use std::fmt;
-    ///
-    /// struct Structure(i32);
-    /// impl fmt::Display for Structure {
-    ///     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-    ///         write!(f, "{}", self.to_string())
-    ///     }
-    /// }
-    ///
-    /// ```
-    /// Use instead:
-    /// ```rust
-    /// use std::fmt;
-    ///
-    /// struct Structure(i32);
-    /// impl fmt::Display for Structure {
-    ///     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-    ///         write!(f, "{}", self.0)
-    ///     }
-    /// }
-    /// ```
-    #[clippy::version = "1.48.0"]
-    pub TO_STRING_IN_DISPLAY,
-    correctness,
-    "`to_string` method used while implementing `Display` trait"
-}
-
-#[derive(Default)]
-pub struct ToStringInDisplay {
-    in_display_impl: bool,
-    self_hir_id: Option<HirId>,
-}
-
-impl ToStringInDisplay {
-    pub fn new() -> Self {
-        Self {
-            in_display_impl: false,
-            self_hir_id: None,
-        }
-    }
-}
-
-impl_lint_pass!(ToStringInDisplay => [TO_STRING_IN_DISPLAY]);
-
-impl LateLintPass<'_> for ToStringInDisplay {
-    fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
-        if is_display_impl(cx, item) {
-            self.in_display_impl = true;
-        }
-    }
-
-    fn check_item_post(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
-        if is_display_impl(cx, item) {
-            self.in_display_impl = false;
-            self.self_hir_id = None;
-        }
-    }
-
-    fn check_impl_item(&mut self, cx: &LateContext<'_>, impl_item: &ImplItem<'_>) {
-        if_chain! {
-            if self.in_display_impl;
-            if let ImplItemKind::Fn(.., body_id) = &impl_item.kind;
-            let body = cx.tcx.hir().body(*body_id);
-            if !body.params.is_empty();
-            then {
-                let self_param = &body.params[0];
-                self.self_hir_id = Some(self_param.pat.hir_id);
-            }
-        }
-    }
-
-    fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
-        if_chain! {
-            if self.in_display_impl;
-            if let Some(self_hir_id) = self.self_hir_id;
-            if let ExprKind::MethodCall(path, [ref self_arg, ..], _) = expr.kind;
-            if path.ident.name == sym!(to_string);
-            if let Some(expr_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
-            if is_diag_trait_item(cx, expr_def_id, sym::ToString);
-            if path_to_local_id(self_arg, self_hir_id);
-            then {
-                span_lint(
-                    cx,
-                    TO_STRING_IN_DISPLAY,
-                    expr.span,
-                    "using `to_string` in `fmt::Display` implementation might lead to infinite recursion",
-                );
-            }
-        }
-    }
-}
-
-fn is_display_impl(cx: &LateContext<'_>, item: &Item<'_>) -> bool {
-    if_chain! {
-        if let ItemKind::Impl(Impl { of_trait: Some(trait_ref), .. }) = &item.kind;
-        if let Some(did) = trait_ref.trait_def_id();
-        then {
-            match_def_path(cx, did, &paths::DISPLAY_TRAIT)
-        } else {
-            false
-        }
-    }
-}
diff --git a/clippy_utils/src/macros.rs b/clippy_utils/src/macros.rs
index 5a76ac23332..256f884ae19 100644
--- a/clippy_utils/src/macros.rs
+++ b/clippy_utils/src/macros.rs
@@ -1,6 +1,7 @@
 #![allow(clippy::similar_names)] // `expr` and `expn`
 
 use crate::visitors::expr_visitor_no_bodies;
+use crate::{match_def_path, paths};
 
 use arrayvec::ArrayVec;
 use if_chain::if_chain;
@@ -13,6 +14,31 @@ use rustc_span::hygiene::{self, MacroKind, SyntaxContext};
 use rustc_span::{sym, ExpnData, ExpnId, ExpnKind, Span, Symbol};
 use std::ops::ControlFlow;
 
+const FORMAT_MACRO_PATHS: &[&[&str]] = &[
+    &paths::FORMAT_ARGS_MACRO,
+    &paths::ASSERT_EQ_MACRO,
+    &paths::ASSERT_MACRO,
+    &paths::ASSERT_NE_MACRO,
+    &paths::EPRINT_MACRO,
+    &paths::EPRINTLN_MACRO,
+    &paths::PRINT_MACRO,
+    &paths::PRINTLN_MACRO,
+    &paths::WRITE_MACRO,
+    &paths::WRITELN_MACRO,
+];
+
+const FORMAT_MACRO_DIAG_ITEMS: &[Symbol] = &[sym::format_macro, sym::std_panic_macro];
+
+/// Returns true if a given Macro `DefId` is a format macro (e.g. `println!`)
+pub fn is_format_macro(cx: &LateContext<'_>, macro_def_id: DefId) -> bool {
+    FORMAT_MACRO_PATHS
+        .iter()
+        .any(|path| match_def_path(cx, macro_def_id, path))
+        || FORMAT_MACRO_DIAG_ITEMS
+            .iter()
+            .any(|diag_item| cx.tcx.is_diagnostic_item(*diag_item, macro_def_id))
+}
+
 /// A macro call, like `vec![1, 2, 3]`.
 ///
 /// Use `tcx.item_name(macro_call.def_id)` to get the macro name.
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index b9c5d289924..48c0e89e4d2 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -33,6 +33,7 @@ pub const BTREEMAP_INSERT: [&str; 6] = ["alloc", "collections", "btree", "map",
 pub const CLONE_TRAIT_METHOD: [&str; 4] = ["core", "clone", "Clone", "clone"];
 pub const COW: [&str; 3] = ["alloc", "borrow", "Cow"];
 pub const CSTRING_AS_C_STR: [&str; 5] = ["std", "ffi", "c_str", "CString", "as_c_str"];
+pub const DEBUG_TRAIT: [&str; 3] = ["core", "fmt", "Debug"];
 pub const DEFAULT_TRAIT_METHOD: [&str; 4] = ["core", "default", "Default", "default"];
 pub const DEREF_MUT_TRAIT_METHOD: [&str; 5] = ["core", "ops", "deref", "DerefMut", "deref_mut"];
 /// Preferably use the diagnostic item `sym::deref_method` where possible
diff --git a/tests/ui/recursive_format_impl.rs b/tests/ui/recursive_format_impl.rs
new file mode 100644
index 00000000000..9241bf7ed74
--- /dev/null
+++ b/tests/ui/recursive_format_impl.rs
@@ -0,0 +1,321 @@
+#![warn(clippy::recursive_format_impl)]
+#![allow(
+    clippy::inherent_to_string_shadow_display,
+    clippy::to_string_in_format_args,
+    clippy::deref_addrof
+)]
+
+use std::fmt;
+
+struct A;
+impl A {
+    fn fmt(&self) {
+        self.to_string();
+    }
+}
+
+trait B {
+    fn fmt(&self) {}
+}
+
+impl B for A {
+    fn fmt(&self) {
+        self.to_string();
+    }
+}
+
+impl fmt::Display for A {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}", self.to_string())
+    }
+}
+
+fn fmt(a: A) {
+    a.to_string();
+}
+
+struct C;
+
+impl C {
+    // Doesn't trigger if to_string defined separately
+    // i.e. not using ToString trait (from Display)
+    fn to_string(&self) -> String {
+        String::from("I am C")
+    }
+}
+
+impl fmt::Display for C {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}", self.to_string())
+    }
+}
+
+enum D {
+    E(String),
+    F,
+}
+
+impl std::fmt::Display for D {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match &self {
+            Self::E(string) => write!(f, "E {}", string.to_string()),
+            Self::F => write!(f, "F"),
+        }
+    }
+}
+
+// Check for use of self as Display, in Display impl
+// Triggers on direct use of self
+struct G {}
+
+impl std::fmt::Display for G {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self)
+    }
+}
+
+// Triggers on reference to self
+struct H {}
+
+impl std::fmt::Display for H {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", &self)
+    }
+}
+
+impl std::fmt::Debug for H {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{:?}", &self)
+    }
+}
+
+// Triggers on multiple reference to self
+struct H2 {}
+
+impl std::fmt::Display for H2 {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", &&&self)
+    }
+}
+
+// Doesn't trigger on correct deref
+struct I {}
+
+impl std::ops::Deref for I {
+    type Target = str;
+
+    fn deref(&self) -> &Self::Target {
+        "test"
+    }
+}
+
+impl std::fmt::Display for I {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "{}", &**self)
+    }
+}
+
+impl std::fmt::Debug for I {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "{:?}", &**self)
+    }
+}
+
+// Doesn't trigger on multiple correct deref
+struct I2 {}
+
+impl std::ops::Deref for I2 {
+    type Target = str;
+
+    fn deref(&self) -> &Self::Target {
+        "test"
+    }
+}
+
+impl std::fmt::Display for I2 {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "{}", **&&&**self)
+    }
+}
+
+// Doesn't trigger on multiple correct deref
+struct I3 {}
+
+impl std::ops::Deref for I3 {
+    type Target = str;
+
+    fn deref(&self) -> &Self::Target {
+        "test"
+    }
+}
+
+impl std::fmt::Display for I3 {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "{}", &&**&&&**self)
+    }
+}
+
+// Does trigger when deref resolves to self
+struct J {}
+
+impl std::ops::Deref for J {
+    type Target = str;
+
+    fn deref(&self) -> &Self::Target {
+        "test"
+    }
+}
+
+impl std::fmt::Display for J {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "{}", &*self)
+    }
+}
+
+impl std::fmt::Debug for J {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "{:?}", &*self)
+    }
+}
+
+struct J2 {}
+
+impl std::ops::Deref for J2 {
+    type Target = str;
+
+    fn deref(&self) -> &Self::Target {
+        "test"
+    }
+}
+
+impl std::fmt::Display for J2 {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "{}", *self)
+    }
+}
+
+struct J3 {}
+
+impl std::ops::Deref for J3 {
+    type Target = str;
+
+    fn deref(&self) -> &Self::Target {
+        "test"
+    }
+}
+
+impl std::fmt::Display for J3 {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "{}", **&&*self)
+    }
+}
+
+struct J4 {}
+
+impl std::ops::Deref for J4 {
+    type Target = str;
+
+    fn deref(&self) -> &Self::Target {
+        "test"
+    }
+}
+
+impl std::fmt::Display for J4 {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "{}", &&**&&*self)
+    }
+}
+
+// Doesn't trigger on Debug from Display
+struct K {}
+
+impl std::fmt::Debug for K {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "test")
+    }
+}
+
+impl std::fmt::Display for K {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "{:?}", self)
+    }
+}
+
+// Doesn't trigger on Display from Debug
+struct K2 {}
+
+impl std::fmt::Debug for K2 {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "{}", self)
+    }
+}
+
+impl std::fmt::Display for K2 {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "test")
+    }
+}
+
+// Doesn't trigger on struct fields
+struct L {
+    field1: u32,
+    field2: i32,
+}
+
+impl std::fmt::Display for L {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "{},{}", self.field1, self.field2)
+    }
+}
+
+impl std::fmt::Debug for L {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "{:?},{:?}", self.field1, self.field2)
+    }
+}
+
+// Doesn't trigger on nested enum matching
+enum Tree {
+    Leaf,
+    Node(Vec<Tree>),
+}
+
+impl std::fmt::Display for Tree {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            Tree::Leaf => write!(f, "*"),
+            Tree::Node(children) => {
+                write!(f, "(")?;
+                for child in children.iter() {
+                    write!(f, "{},", child)?;
+                }
+                write!(f, ")")
+            },
+        }
+    }
+}
+
+impl std::fmt::Debug for Tree {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            Tree::Leaf => write!(f, "*"),
+            Tree::Node(children) => {
+                write!(f, "(")?;
+                for child in children.iter() {
+                    write!(f, "{:?},", child)?;
+                }
+                write!(f, ")")
+            },
+        }
+    }
+}
+
+fn main() {
+    let a = A;
+    a.to_string();
+    a.fmt();
+    fmt(a);
+
+    let c = C;
+    c.to_string();
+}
diff --git a/tests/ui/recursive_format_impl.stderr b/tests/ui/recursive_format_impl.stderr
new file mode 100644
index 00000000000..6171696ed69
--- /dev/null
+++ b/tests/ui/recursive_format_impl.stderr
@@ -0,0 +1,91 @@
+error: using `self.to_string` in `fmt::Display` implementation will cause infinite recursion
+  --> $DIR/recursive_format_impl.rs:29:25
+   |
+LL |         write!(f, "{}", self.to_string())
+   |                         ^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::recursive-format-impl` implied by `-D warnings`
+
+error: unnecessary use of `to_string`
+  --> $DIR/recursive_format_impl.rs:61:50
+   |
+LL |             Self::E(string) => write!(f, "E {}", string.to_string()),
+   |                                                  ^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::unnecessary-to-owned` implied by `-D warnings`
+   = note: this error originates in the macro `$crate::format_args` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: using `self` as `Display` in `impl Display` will cause infinite recursion
+  --> $DIR/recursive_format_impl.rs:73:9
+   |
+LL |         write!(f, "{}", self)
+   |         ^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: this error originates in the macro `write` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: using `self` as `Display` in `impl Display` will cause infinite recursion
+  --> $DIR/recursive_format_impl.rs:82:9
+   |
+LL |         write!(f, "{}", &self)
+   |         ^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: this error originates in the macro `write` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: using `self` as `Debug` in `impl Debug` will cause infinite recursion
+  --> $DIR/recursive_format_impl.rs:88:9
+   |
+LL |         write!(f, "{:?}", &self)
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: this error originates in the macro `write` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: using `self` as `Display` in `impl Display` will cause infinite recursion
+  --> $DIR/recursive_format_impl.rs:97:9
+   |
+LL |         write!(f, "{}", &&&self)
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: this error originates in the macro `write` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: using `self` as `Display` in `impl Display` will cause infinite recursion
+  --> $DIR/recursive_format_impl.rs:171:9
+   |
+LL |         write!(f, "{}", &*self)
+   |         ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: this error originates in the macro `write` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: using `self` as `Debug` in `impl Debug` will cause infinite recursion
+  --> $DIR/recursive_format_impl.rs:177:9
+   |
+LL |         write!(f, "{:?}", &*self)
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: this error originates in the macro `write` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: using `self` as `Display` in `impl Display` will cause infinite recursion
+  --> $DIR/recursive_format_impl.rs:193:9
+   |
+LL |         write!(f, "{}", *self)
+   |         ^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: this error originates in the macro `write` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: using `self` as `Display` in `impl Display` will cause infinite recursion
+  --> $DIR/recursive_format_impl.rs:209:9
+   |
+LL |         write!(f, "{}", **&&*self)
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: this error originates in the macro `write` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: using `self` as `Display` in `impl Display` will cause infinite recursion
+  --> $DIR/recursive_format_impl.rs:225:9
+   |
+LL |         write!(f, "{}", &&**&&*self)
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: this error originates in the macro `write` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: aborting due to 11 previous errors
+
diff --git a/tests/ui/rename.fixed b/tests/ui/rename.fixed
index 8bddec576ed..24a0c812291 100644
--- a/tests/ui/rename.fixed
+++ b/tests/ui/rename.fixed
@@ -20,6 +20,7 @@
 #![allow(clippy::match_result_ok)]
 #![allow(clippy::disallowed_types)]
 #![allow(clippy::disallowed_methods)]
+#![allow(clippy::recursive_format_impl)]
 // uplifted lints
 #![allow(invalid_value)]
 #![allow(array_into_iter)]
@@ -55,6 +56,7 @@
 #![warn(clippy::disallowed_types)]
 #![warn(clippy::disallowed_methods)]
 #![warn(clippy::needless_borrow)]
+#![warn(clippy::recursive_format_impl)]
 // uplifted lints
 #![warn(invalid_value)]
 #![warn(array_into_iter)]
diff --git a/tests/ui/rename.rs b/tests/ui/rename.rs
index d2010d71d2c..ea64234c680 100644
--- a/tests/ui/rename.rs
+++ b/tests/ui/rename.rs
@@ -20,6 +20,7 @@
 #![allow(clippy::match_result_ok)]
 #![allow(clippy::disallowed_types)]
 #![allow(clippy::disallowed_methods)]
+#![allow(clippy::recursive_format_impl)]
 // uplifted lints
 #![allow(invalid_value)]
 #![allow(array_into_iter)]
@@ -55,6 +56,7 @@
 #![warn(clippy::disallowed_type)]
 #![warn(clippy::disallowed_method)]
 #![warn(clippy::ref_in_deref)]
+#![warn(clippy::to_string_in_display)]
 // uplifted lints
 #![warn(clippy::invalid_ref)]
 #![warn(clippy::into_iter_on_array)]
diff --git a/tests/ui/rename.stderr b/tests/ui/rename.stderr
index 45cb8b786f5..8b132a78384 100644
--- a/tests/ui/rename.stderr
+++ b/tests/ui/rename.stderr
@@ -1,5 +1,5 @@
 error: lint `clippy::stutter` has been renamed to `clippy::module_name_repetitions`
-  --> $DIR/rename.rs:34:9
+  --> $DIR/rename.rs:35:9
    |
 LL | #![warn(clippy::stutter)]
    |         ^^^^^^^^^^^^^^^ help: use the new name: `clippy::module_name_repetitions`
@@ -7,196 +7,202 @@ LL | #![warn(clippy::stutter)]
    = note: `-D renamed-and-removed-lints` implied by `-D warnings`
 
 error: lint `clippy::new_without_default_derive` has been renamed to `clippy::new_without_default`
-  --> $DIR/rename.rs:35:9
+  --> $DIR/rename.rs:36:9
    |
 LL | #![warn(clippy::new_without_default_derive)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::new_without_default`
 
 error: lint `clippy::const_static_lifetime` has been renamed to `clippy::redundant_static_lifetimes`
-  --> $DIR/rename.rs:36:9
+  --> $DIR/rename.rs:37:9
    |
 LL | #![warn(clippy::const_static_lifetime)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::redundant_static_lifetimes`
 
 error: lint `clippy::cyclomatic_complexity` has been renamed to `clippy::cognitive_complexity`
-  --> $DIR/rename.rs:37:9
+  --> $DIR/rename.rs:38:9
    |
 LL | #![warn(clippy::cyclomatic_complexity)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::cognitive_complexity`
 
 error: lint `clippy::option_and_then_some` has been renamed to `clippy::bind_instead_of_map`
-  --> $DIR/rename.rs:38:9
+  --> $DIR/rename.rs:39:9
    |
 LL | #![warn(clippy::option_and_then_some)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::bind_instead_of_map`
 
 error: lint `clippy::box_vec` has been renamed to `clippy::box_collection`
-  --> $DIR/rename.rs:39:9
+  --> $DIR/rename.rs:40:9
    |
 LL | #![warn(clippy::box_vec)]
    |         ^^^^^^^^^^^^^^^ help: use the new name: `clippy::box_collection`
 
 error: lint `clippy::block_in_if_condition_expr` has been renamed to `clippy::blocks_in_if_conditions`
-  --> $DIR/rename.rs:40:9
+  --> $DIR/rename.rs:41:9
    |
 LL | #![warn(clippy::block_in_if_condition_expr)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::blocks_in_if_conditions`
 
 error: lint `clippy::block_in_if_condition_stmt` has been renamed to `clippy::blocks_in_if_conditions`
-  --> $DIR/rename.rs:41:9
+  --> $DIR/rename.rs:42:9
    |
 LL | #![warn(clippy::block_in_if_condition_stmt)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::blocks_in_if_conditions`
 
 error: lint `clippy::option_map_unwrap_or` has been renamed to `clippy::map_unwrap_or`
-  --> $DIR/rename.rs:42:9
+  --> $DIR/rename.rs:43:9
    |
 LL | #![warn(clippy::option_map_unwrap_or)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::map_unwrap_or`
 
 error: lint `clippy::option_map_unwrap_or_else` has been renamed to `clippy::map_unwrap_or`
-  --> $DIR/rename.rs:43:9
+  --> $DIR/rename.rs:44:9
    |
 LL | #![warn(clippy::option_map_unwrap_or_else)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::map_unwrap_or`
 
 error: lint `clippy::result_map_unwrap_or_else` has been renamed to `clippy::map_unwrap_or`
-  --> $DIR/rename.rs:44:9
+  --> $DIR/rename.rs:45:9
    |
 LL | #![warn(clippy::result_map_unwrap_or_else)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::map_unwrap_or`
 
 error: lint `clippy::option_unwrap_used` has been renamed to `clippy::unwrap_used`
-  --> $DIR/rename.rs:45:9
+  --> $DIR/rename.rs:46:9
    |
 LL | #![warn(clippy::option_unwrap_used)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::unwrap_used`
 
 error: lint `clippy::result_unwrap_used` has been renamed to `clippy::unwrap_used`
-  --> $DIR/rename.rs:46:9
+  --> $DIR/rename.rs:47:9
    |
 LL | #![warn(clippy::result_unwrap_used)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::unwrap_used`
 
 error: lint `clippy::option_expect_used` has been renamed to `clippy::expect_used`
-  --> $DIR/rename.rs:47:9
+  --> $DIR/rename.rs:48:9
    |
 LL | #![warn(clippy::option_expect_used)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::expect_used`
 
 error: lint `clippy::result_expect_used` has been renamed to `clippy::expect_used`
-  --> $DIR/rename.rs:48:9
+  --> $DIR/rename.rs:49:9
    |
 LL | #![warn(clippy::result_expect_used)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::expect_used`
 
 error: lint `clippy::for_loop_over_option` has been renamed to `clippy::for_loops_over_fallibles`
-  --> $DIR/rename.rs:49:9
+  --> $DIR/rename.rs:50:9
    |
 LL | #![warn(clippy::for_loop_over_option)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::for_loops_over_fallibles`
 
 error: lint `clippy::for_loop_over_result` has been renamed to `clippy::for_loops_over_fallibles`
-  --> $DIR/rename.rs:50:9
+  --> $DIR/rename.rs:51:9
    |
 LL | #![warn(clippy::for_loop_over_result)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::for_loops_over_fallibles`
 
 error: lint `clippy::identity_conversion` has been renamed to `clippy::useless_conversion`
-  --> $DIR/rename.rs:51:9
+  --> $DIR/rename.rs:52:9
    |
 LL | #![warn(clippy::identity_conversion)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::useless_conversion`
 
 error: lint `clippy::zero_width_space` has been renamed to `clippy::invisible_characters`
-  --> $DIR/rename.rs:52:9
+  --> $DIR/rename.rs:53:9
    |
 LL | #![warn(clippy::zero_width_space)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::invisible_characters`
 
 error: lint `clippy::single_char_push_str` has been renamed to `clippy::single_char_add_str`
-  --> $DIR/rename.rs:53:9
+  --> $DIR/rename.rs:54:9
    |
 LL | #![warn(clippy::single_char_push_str)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::single_char_add_str`
 
 error: lint `clippy::if_let_some_result` has been renamed to `clippy::match_result_ok`
-  --> $DIR/rename.rs:54:9
+  --> $DIR/rename.rs:55:9
    |
 LL | #![warn(clippy::if_let_some_result)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::match_result_ok`
 
 error: lint `clippy::disallowed_type` has been renamed to `clippy::disallowed_types`
-  --> $DIR/rename.rs:55:9
+  --> $DIR/rename.rs:56:9
    |
 LL | #![warn(clippy::disallowed_type)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::disallowed_types`
 
 error: lint `clippy::disallowed_method` has been renamed to `clippy::disallowed_methods`
-  --> $DIR/rename.rs:56:9
+  --> $DIR/rename.rs:57:9
    |
 LL | #![warn(clippy::disallowed_method)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::disallowed_methods`
 
 error: lint `clippy::ref_in_deref` has been renamed to `clippy::needless_borrow`
-  --> $DIR/rename.rs:57:9
+  --> $DIR/rename.rs:58:9
    |
 LL | #![warn(clippy::ref_in_deref)]
    |         ^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::needless_borrow`
 
-error: lint `clippy::invalid_ref` has been renamed to `invalid_value`
+error: lint `clippy::to_string_in_display` has been renamed to `clippy::recursive_format_impl`
   --> $DIR/rename.rs:59:9
    |
+LL | #![warn(clippy::to_string_in_display)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::recursive_format_impl`
+
+error: lint `clippy::invalid_ref` has been renamed to `invalid_value`
+  --> $DIR/rename.rs:61:9
+   |
 LL | #![warn(clippy::invalid_ref)]
    |         ^^^^^^^^^^^^^^^^^^^ help: use the new name: `invalid_value`
 
 error: lint `clippy::into_iter_on_array` has been renamed to `array_into_iter`
-  --> $DIR/rename.rs:60:9
+  --> $DIR/rename.rs:62:9
    |
 LL | #![warn(clippy::into_iter_on_array)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `array_into_iter`
 
 error: lint `clippy::unused_label` has been renamed to `unused_labels`
-  --> $DIR/rename.rs:61:9
+  --> $DIR/rename.rs:63:9
    |
 LL | #![warn(clippy::unused_label)]
    |         ^^^^^^^^^^^^^^^^^^^^ help: use the new name: `unused_labels`
 
 error: lint `clippy::drop_bounds` has been renamed to `drop_bounds`
-  --> $DIR/rename.rs:62:9
+  --> $DIR/rename.rs:64:9
    |
 LL | #![warn(clippy::drop_bounds)]
    |         ^^^^^^^^^^^^^^^^^^^ help: use the new name: `drop_bounds`
 
 error: lint `clippy::temporary_cstring_as_ptr` has been renamed to `temporary_cstring_as_ptr`
-  --> $DIR/rename.rs:63:9
+  --> $DIR/rename.rs:65:9
    |
 LL | #![warn(clippy::temporary_cstring_as_ptr)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `temporary_cstring_as_ptr`
 
 error: lint `clippy::panic_params` has been renamed to `non_fmt_panics`
-  --> $DIR/rename.rs:64:9
+  --> $DIR/rename.rs:66:9
    |
 LL | #![warn(clippy::panic_params)]
    |         ^^^^^^^^^^^^^^^^^^^^ help: use the new name: `non_fmt_panics`
 
 error: lint `clippy::unknown_clippy_lints` has been renamed to `unknown_lints`
-  --> $DIR/rename.rs:65:9
+  --> $DIR/rename.rs:67:9
    |
 LL | #![warn(clippy::unknown_clippy_lints)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `unknown_lints`
 
 error: lint `clippy::invalid_atomic_ordering` has been renamed to `invalid_atomic_ordering`
-  --> $DIR/rename.rs:66:9
+  --> $DIR/rename.rs:68:9
    |
 LL | #![warn(clippy::invalid_atomic_ordering)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `invalid_atomic_ordering`
 
 error: lint `clippy::mem_discriminant_non_enum` has been renamed to `enum_intrinsics_non_enums`
-  --> $DIR/rename.rs:67:9
+  --> $DIR/rename.rs:69:9
    |
 LL | #![warn(clippy::mem_discriminant_non_enum)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `enum_intrinsics_non_enums`
 
-error: aborting due to 33 previous errors
+error: aborting due to 34 previous errors
 
diff --git a/tests/ui/to_string_in_display.rs b/tests/ui/to_string_in_display.rs
deleted file mode 100644
index 3ccdcd1117b..00000000000
--- a/tests/ui/to_string_in_display.rs
+++ /dev/null
@@ -1,69 +0,0 @@
-#![warn(clippy::to_string_in_display)]
-#![allow(clippy::inherent_to_string_shadow_display, clippy::to_string_in_format_args)]
-
-use std::fmt;
-
-struct A;
-impl A {
-    fn fmt(&self) {
-        self.to_string();
-    }
-}
-
-trait B {
-    fn fmt(&self) {}
-}
-
-impl B for A {
-    fn fmt(&self) {
-        self.to_string();
-    }
-}
-
-impl fmt::Display for A {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{}", self.to_string())
-    }
-}
-
-fn fmt(a: A) {
-    a.to_string();
-}
-
-struct C;
-
-impl C {
-    fn to_string(&self) -> String {
-        String::from("I am C")
-    }
-}
-
-impl fmt::Display for C {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{}", self.to_string())
-    }
-}
-
-enum D {
-    E(String),
-    F,
-}
-
-impl std::fmt::Display for D {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match &self {
-            Self::E(string) => write!(f, "E {}", string.to_string()),
-            Self::F => write!(f, "F"),
-        }
-    }
-}
-
-fn main() {
-    let a = A;
-    a.to_string();
-    a.fmt();
-    fmt(a);
-
-    let c = C;
-    c.to_string();
-}
diff --git a/tests/ui/to_string_in_display.stderr b/tests/ui/to_string_in_display.stderr
deleted file mode 100644
index 80189ca1f0a..00000000000
--- a/tests/ui/to_string_in_display.stderr
+++ /dev/null
@@ -1,19 +0,0 @@
-error: using `to_string` in `fmt::Display` implementation might lead to infinite recursion
-  --> $DIR/to_string_in_display.rs:25:25
-   |
-LL |         write!(f, "{}", self.to_string())
-   |                         ^^^^^^^^^^^^^^^^
-   |
-   = note: `-D clippy::to-string-in-display` implied by `-D warnings`
-
-error: unnecessary use of `to_string`
-  --> $DIR/to_string_in_display.rs:55:50
-   |
-LL |             Self::E(string) => write!(f, "E {}", string.to_string()),
-   |                                                  ^^^^^^^^^^^^^^^^^^
-   |
-   = note: `-D clippy::unnecessary-to-owned` implied by `-D warnings`
-   = note: this error originates in the macro `$crate::format_args` (in Nightly builds, run with -Z macro-backtrace for more info)
-
-error: aborting due to 2 previous errors
-
-- 
cgit 1.4.1-3-g733a5


From a135b52102651b0c3f10dbf869a9e7cfae8adbce Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Wed, 16 Feb 2022 23:14:39 -0500
Subject: Don't lint `needless_borrow` in method receiver positions

---
 clippy_lints/src/dereference.rs |  2 +-
 tests/ui/needless_borrow.fixed  |  6 +++---
 tests/ui/needless_borrow.rs     |  6 +++---
 tests/ui/needless_borrow.stderr | 20 +-------------------
 4 files changed, 8 insertions(+), 26 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index 6d0851d804c..fe391198342 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -528,7 +528,7 @@ fn is_auto_reborrow_position(parent: Option<Node<'_>>) -> bool {
 fn is_auto_borrow_position(parent: Option<Node<'_>>, child_id: HirId) -> bool {
     if let Some(Node::Expr(parent)) = parent {
         match parent.kind {
-            ExprKind::MethodCall(_, [self_arg, ..], _) => self_arg.hir_id == child_id,
+            // ExprKind::MethodCall(_, [self_arg, ..], _) => self_arg.hir_id == child_id,
             ExprKind::Field(..) => true,
             ExprKind::Call(f, _) => f.hir_id == child_id,
             _ => false,
diff --git a/tests/ui/needless_borrow.fixed b/tests/ui/needless_borrow.fixed
index b856f1375d3..efeb5cf5b2b 100644
--- a/tests/ui/needless_borrow.fixed
+++ b/tests/ui/needless_borrow.fixed
@@ -64,9 +64,9 @@ fn main() {
     *x = 5;
 
     let s = String::new();
-    let _ = s.len();
-    let _ = s.capacity();
-    let _ = s.capacity();
+    // let _ = (&s).len();
+    // let _ = (&s).capacity();
+    // let _ = (&&s).capacity();
 
     let x = (1, 2);
     let _ = x.0;
diff --git a/tests/ui/needless_borrow.rs b/tests/ui/needless_borrow.rs
index 0bfe222a3dc..3e416a0eb84 100644
--- a/tests/ui/needless_borrow.rs
+++ b/tests/ui/needless_borrow.rs
@@ -64,9 +64,9 @@ fn main() {
     *x = 5;
 
     let s = String::new();
-    let _ = (&s).len();
-    let _ = (&s).capacity();
-    let _ = (&&s).capacity();
+    // let _ = (&s).len();
+    // let _ = (&s).capacity();
+    // let _ = (&&s).capacity();
 
     let x = (1, 2);
     let _ = (&x).0;
diff --git a/tests/ui/needless_borrow.stderr b/tests/ui/needless_borrow.stderr
index b90e8448db0..05591ce4117 100644
--- a/tests/ui/needless_borrow.stderr
+++ b/tests/ui/needless_borrow.stderr
@@ -84,24 +84,6 @@ error: this expression creates a reference which is immediately dereferenced by
 LL |     let y: &mut i32 = &mut &mut x;
    |                       ^^^^^^^^^^^ help: change this to: `x`
 
-error: this expression borrows a value the compiler would automatically borrow
-  --> $DIR/needless_borrow.rs:67:13
-   |
-LL |     let _ = (&s).len();
-   |             ^^^^ help: change this to: `s`
-
-error: this expression borrows a value the compiler would automatically borrow
-  --> $DIR/needless_borrow.rs:68:13
-   |
-LL |     let _ = (&s).capacity();
-   |             ^^^^ help: change this to: `s`
-
-error: this expression creates a reference which is immediately dereferenced by the compiler
-  --> $DIR/needless_borrow.rs:69:13
-   |
-LL |     let _ = (&&s).capacity();
-   |             ^^^^^ help: change this to: `s`
-
 error: this expression borrows a value the compiler would automatically borrow
   --> $DIR/needless_borrow.rs:72:13
    |
@@ -114,5 +96,5 @@ error: this expression borrows a value the compiler would automatically borrow
 LL |     let _ = unsafe { (&*x).0 };
    |                      ^^^^^ help: change this to: `(*x)`
 
-error: aborting due to 19 previous errors
+error: aborting due to 16 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From faeeef3b9cd841b54ece2ff887d608d5bb54f41c Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Mon, 3 Jan 2022 15:25:00 -0500
Subject: Improve `redundant_slicing` lint

* Lint when slicing triggers auto-deref
* Lint when slicing returns the same type as dereferencing
---
 clippy_lints/src/redundant_slicing.rs | 67 +++++++++++++++++++++++++----------
 tests/ui/redundant_slicing.fixed      | 40 +++++++++++++++++++++
 tests/ui/redundant_slicing.rs         | 16 ++++++---
 tests/ui/redundant_slicing.stderr     | 42 +++++++++++++++++-----
 4 files changed, 134 insertions(+), 31 deletions(-)
 create mode 100644 tests/ui/redundant_slicing.fixed

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/redundant_slicing.rs b/clippy_lints/src/redundant_slicing.rs
index cd3aee55655..b492f944dc3 100644
--- a/clippy_lints/src/redundant_slicing.rs
+++ b/clippy_lints/src/redundant_slicing.rs
@@ -1,11 +1,12 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::get_parent_expr;
 use clippy_utils::source::snippet_with_context;
-use clippy_utils::ty::is_type_lang_item;
+use clippy_utils::ty::{is_type_lang_item, peel_mid_ty_refs};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{BorrowKind, Expr, ExprKind, LangItem, Mutability};
 use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::subst::GenericArg;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
@@ -53,25 +54,55 @@ impl<'tcx> LateLintPass<'tcx> for RedundantSlicing {
             if addressee.span.ctxt() == ctxt;
             if let ExprKind::Index(indexed, range) = addressee.kind;
             if is_type_lang_item(cx, cx.typeck_results().expr_ty_adjusted(range), LangItem::RangeFull);
-            if cx.typeck_results().expr_ty(expr) == cx.typeck_results().expr_ty(indexed);
             then {
+                let (expr_ty, expr_ref_count) = peel_mid_ty_refs(cx.typeck_results().expr_ty(expr));
+                let (indexed_ty, indexed_ref_count) = peel_mid_ty_refs(cx.typeck_results().expr_ty(indexed));
                 let mut app = Applicability::MachineApplicable;
-                let snip = snippet_with_context(cx, indexed.span, ctxt, "..", &mut app).0;
 
-                let (reborrow_str, help_str) = if mutability == Mutability::Mut {
-                    // The slice was used to reborrow the mutable reference.
-                    ("&mut *", "reborrow the original value instead")
-                } else if matches!(
-                    get_parent_expr(cx, expr),
-                    Some(Expr {
-                        kind: ExprKind::AddrOf(BorrowKind::Ref, Mutability::Mut, _),
-                        ..
-                    })
-                ) {
-                    // The slice was used to make a temporary reference.
-                    ("&*", "reborrow the original value instead")
+                let (help, sugg) = if expr_ty == indexed_ty {
+                    if expr_ref_count > indexed_ref_count {
+                        return;
+                    }
+
+                    let (reborrow_str, help_str) = if mutability == Mutability::Mut {
+                        // The slice was used to reborrow the mutable reference.
+                        ("&mut *", "reborrow the original value instead")
+                    } else if matches!(
+                        get_parent_expr(cx, expr),
+                        Some(Expr {
+                            kind: ExprKind::AddrOf(BorrowKind::Ref, Mutability::Mut, _),
+                            ..
+                        })
+                    ) {
+                        // The slice was used to make a temporary reference.
+                        ("&*", "reborrow the original value instead")
+                    } else if expr_ref_count != indexed_ref_count {
+                        ("", "dereference the original value instead")
+                    } else {
+                        ("", "use the original value instead")
+                    };
+
+                    let snip = snippet_with_context(cx, indexed.span, ctxt, "..", &mut app).0;
+                    (help_str, format!("{}{}{}", reborrow_str, "*".repeat(indexed_ref_count - expr_ref_count), snip))
+                } else if let Some(target_id) = cx.tcx.lang_items().deref_target() {
+                    if let Ok(deref_ty) = cx.tcx.try_normalize_erasing_regions(
+                        cx.param_env,
+                        cx.tcx.mk_projection(target_id, cx.tcx.mk_substs([GenericArg::from(indexed_ty)].into_iter())),
+                    ) {
+                        if deref_ty == expr_ty {
+                            let snip = snippet_with_context(cx, indexed.span, ctxt, "..", &mut app).0;
+                            (
+                                "dereference the original value instead",
+                                format!("&{}{}*{}", mutability.prefix_str(), "*".repeat(indexed_ref_count), snip),
+                            )
+                        } else {
+                            return;
+                        }
+                    } else {
+                        return;
+                    }
                 } else {
-                    ("", "use the original value instead")
+                    return;
                 };
 
                 span_lint_and_sugg(
@@ -79,8 +110,8 @@ impl<'tcx> LateLintPass<'tcx> for RedundantSlicing {
                     REDUNDANT_SLICING,
                     expr.span,
                     "redundant slicing of the whole range",
-                    help_str,
-                    format!("{}{}", reborrow_str, snip),
+                    help,
+                    sugg,
                     app,
                 );
             }
diff --git a/tests/ui/redundant_slicing.fixed b/tests/ui/redundant_slicing.fixed
new file mode 100644
index 00000000000..9716a48be94
--- /dev/null
+++ b/tests/ui/redundant_slicing.fixed
@@ -0,0 +1,40 @@
+// run-rustfix
+
+#![allow(unused)]
+#![warn(clippy::redundant_slicing)]
+
+fn main() {
+    let slice: &[u32] = &[0];
+    let _ = slice; // Redundant slice
+
+    let v = vec![0];
+    let _ = &*v; // Deref instead of slice
+    let _ = (&*v); // Outer borrow is redundant
+
+    static S: &[u8] = &[0, 1, 2];
+    let err = &mut &*S; // Should reborrow instead of slice
+
+    let mut vec = vec![0];
+    let mut_slice = &mut *vec; // Deref instead of slice
+    let _ = &mut *mut_slice; // Should reborrow instead of slice
+
+    let ref_vec = &vec;
+    let _ = &**ref_vec; // Deref instead of slice
+
+    macro_rules! m {
+        ($e:expr) => {
+            $e
+        };
+    }
+    let _ = slice;
+
+    macro_rules! m2 {
+        ($e:expr) => {
+            &$e[..]
+        };
+    }
+    let _ = m2!(slice); // Don't lint in a macro
+
+    let slice_ref = &slice;
+    let _ = *slice_ref; // Deref instead of slice
+}
diff --git a/tests/ui/redundant_slicing.rs b/tests/ui/redundant_slicing.rs
index 554b6ba36ae..a6902f7619b 100644
--- a/tests/ui/redundant_slicing.rs
+++ b/tests/ui/redundant_slicing.rs
@@ -1,21 +1,26 @@
+// run-rustfix
+
 #![allow(unused)]
 #![warn(clippy::redundant_slicing)]
 
 fn main() {
     let slice: &[u32] = &[0];
-    let _ = &slice[..];
+    let _ = &slice[..]; // Redundant slice
 
     let v = vec![0];
-    let _ = &v[..]; // Changes the type
-    let _ = &(&v[..])[..]; // Outer borrow is redundant
+    let _ = &v[..]; // Deref instead of slice
+    let _ = &(&*v)[..]; // Outer borrow is redundant
 
     static S: &[u8] = &[0, 1, 2];
     let err = &mut &S[..]; // Should reborrow instead of slice
 
     let mut vec = vec![0];
-    let mut_slice = &mut *vec;
+    let mut_slice = &mut vec[..]; // Deref instead of slice
     let _ = &mut mut_slice[..]; // Should reborrow instead of slice
 
+    let ref_vec = &vec;
+    let _ = &ref_vec[..]; // Deref instead of slice
+
     macro_rules! m {
         ($e:expr) => {
             $e
@@ -29,4 +34,7 @@ fn main() {
         };
     }
     let _ = m2!(slice); // Don't lint in a macro
+
+    let slice_ref = &slice;
+    let _ = &slice_ref[..]; // Deref instead of slice
 }
diff --git a/tests/ui/redundant_slicing.stderr b/tests/ui/redundant_slicing.stderr
index bbd10eafbbe..c2a5e9e1914 100644
--- a/tests/ui/redundant_slicing.stderr
+++ b/tests/ui/redundant_slicing.stderr
@@ -1,34 +1,58 @@
 error: redundant slicing of the whole range
-  --> $DIR/redundant_slicing.rs:6:13
+  --> $DIR/redundant_slicing.rs:8:13
    |
-LL |     let _ = &slice[..];
+LL |     let _ = &slice[..]; // Redundant slice
    |             ^^^^^^^^^^ help: use the original value instead: `slice`
    |
    = note: `-D clippy::redundant-slicing` implied by `-D warnings`
 
 error: redundant slicing of the whole range
-  --> $DIR/redundant_slicing.rs:10:13
+  --> $DIR/redundant_slicing.rs:11:13
    |
-LL |     let _ = &(&v[..])[..]; // Outer borrow is redundant
-   |             ^^^^^^^^^^^^^ help: use the original value instead: `(&v[..])`
+LL |     let _ = &v[..]; // Deref instead of slice
+   |             ^^^^^^ help: dereference the original value instead: `&*v`
 
 error: redundant slicing of the whole range
-  --> $DIR/redundant_slicing.rs:13:20
+  --> $DIR/redundant_slicing.rs:12:13
+   |
+LL |     let _ = &(&*v)[..]; // Outer borrow is redundant
+   |             ^^^^^^^^^^ help: use the original value instead: `(&*v)`
+
+error: redundant slicing of the whole range
+  --> $DIR/redundant_slicing.rs:15:20
    |
 LL |     let err = &mut &S[..]; // Should reborrow instead of slice
    |                    ^^^^^^ help: reborrow the original value instead: `&*S`
 
 error: redundant slicing of the whole range
-  --> $DIR/redundant_slicing.rs:17:13
+  --> $DIR/redundant_slicing.rs:18:21
+   |
+LL |     let mut_slice = &mut vec[..]; // Deref instead of slice
+   |                     ^^^^^^^^^^^^ help: dereference the original value instead: `&mut *vec`
+
+error: redundant slicing of the whole range
+  --> $DIR/redundant_slicing.rs:19:13
    |
 LL |     let _ = &mut mut_slice[..]; // Should reborrow instead of slice
    |             ^^^^^^^^^^^^^^^^^^ help: reborrow the original value instead: `&mut *mut_slice`
 
 error: redundant slicing of the whole range
-  --> $DIR/redundant_slicing.rs:24:13
+  --> $DIR/redundant_slicing.rs:22:13
+   |
+LL |     let _ = &ref_vec[..]; // Deref instead of slice
+   |             ^^^^^^^^^^^^ help: dereference the original value instead: `&**ref_vec`
+
+error: redundant slicing of the whole range
+  --> $DIR/redundant_slicing.rs:29:13
    |
 LL |     let _ = &m!(slice)[..];
    |             ^^^^^^^^^^^^^^ help: use the original value instead: `slice`
 
-error: aborting due to 5 previous errors
+error: redundant slicing of the whole range
+  --> $DIR/redundant_slicing.rs:39:13
+   |
+LL |     let _ = &slice_ref[..]; // Deref instead of slice
+   |             ^^^^^^^^^^^^^^ help: dereference the original value instead: `*slice_ref`
+
+error: aborting due to 9 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 4bdc97c4a66eccfc3925cd691121965b08017908 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Mon, 3 Jan 2022 20:35:32 -0500
Subject: Account for auto-borrows and precedence in `redundant_slicing` lint

---
 clippy_lints/src/redundant_slicing.rs | 38 +++++++++++++++++++++++++++--------
 tests/ui/redundant_slicing.fixed      |  6 ++++++
 tests/ui/redundant_slicing.rs         |  6 ++++++
 tests/ui/redundant_slicing.stderr     | 26 +++++++++++++++---------
 4 files changed, 58 insertions(+), 18 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/redundant_slicing.rs b/clippy_lints/src/redundant_slicing.rs
index b492f944dc3..1cc0990b283 100644
--- a/clippy_lints/src/redundant_slicing.rs
+++ b/clippy_lints/src/redundant_slicing.rs
@@ -3,9 +3,11 @@ use clippy_utils::get_parent_expr;
 use clippy_utils::source::snippet_with_context;
 use clippy_utils::ty::{is_type_lang_item, peel_mid_ty_refs};
 use if_chain::if_chain;
+use rustc_ast::util::parser::PREC_PREFIX;
 use rustc_errors::Applicability;
 use rustc_hir::{BorrowKind, Expr, ExprKind, LangItem, Mutability};
 use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::adjustment::{Adjust, AutoBorrow, AutoBorrowMutability};
 use rustc_middle::ty::subst::GenericArg;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
@@ -57,33 +59,51 @@ impl<'tcx> LateLintPass<'tcx> for RedundantSlicing {
             then {
                 let (expr_ty, expr_ref_count) = peel_mid_ty_refs(cx.typeck_results().expr_ty(expr));
                 let (indexed_ty, indexed_ref_count) = peel_mid_ty_refs(cx.typeck_results().expr_ty(indexed));
+                let parent_expr = get_parent_expr(cx, expr);
+                let needs_parens_for_prefix = parent_expr.map_or(false, |parent| {
+                    parent.precedence().order() > PREC_PREFIX
+                });
                 let mut app = Applicability::MachineApplicable;
 
                 let (help, sugg) = if expr_ty == indexed_ty {
                     if expr_ref_count > indexed_ref_count {
+                        // Indexing takes self by reference and can't return a reference to that
+                        // reference as it's a local variable. The only way this could happen is if
+                        // `self` contains a reference to the `Self` type. If this occurs then the
+                        // lint no longer applies as it's essentially a field access, which is not
+                        // redundant.
                         return;
                     }
+                    let deref_count = indexed_ref_count - expr_ref_count;
 
                     let (reborrow_str, help_str) = if mutability == Mutability::Mut {
                         // The slice was used to reborrow the mutable reference.
                         ("&mut *", "reborrow the original value instead")
                     } else if matches!(
-                        get_parent_expr(cx, expr),
+                        parent_expr,
                         Some(Expr {
                             kind: ExprKind::AddrOf(BorrowKind::Ref, Mutability::Mut, _),
                             ..
                         })
-                    ) {
+                    ) || cx.typeck_results().expr_adjustments(expr).first().map_or(false, |a| {
+                        matches!(a.kind, Adjust::Borrow(AutoBorrow::Ref(_, AutoBorrowMutability::Mut { .. })))
+                    }) {
                         // The slice was used to make a temporary reference.
                         ("&*", "reborrow the original value instead")
-                    } else if expr_ref_count != indexed_ref_count {
+                    } else if deref_count != 0 {
                         ("", "dereference the original value instead")
                     } else {
                         ("", "use the original value instead")
                     };
 
                     let snip = snippet_with_context(cx, indexed.span, ctxt, "..", &mut app).0;
-                    (help_str, format!("{}{}{}", reborrow_str, "*".repeat(indexed_ref_count - expr_ref_count), snip))
+                    let sugg = if (deref_count != 0 || !reborrow_str.is_empty()) && needs_parens_for_prefix {
+                        format!("({}{}{})", reborrow_str, "*".repeat(deref_count), snip)
+                    } else {
+                        format!("{}{}{}", reborrow_str, "*".repeat(deref_count), snip)
+                    };
+
+                    (help_str, sugg)
                 } else if let Some(target_id) = cx.tcx.lang_items().deref_target() {
                     if let Ok(deref_ty) = cx.tcx.try_normalize_erasing_regions(
                         cx.param_env,
@@ -91,10 +111,12 @@ impl<'tcx> LateLintPass<'tcx> for RedundantSlicing {
                     ) {
                         if deref_ty == expr_ty {
                             let snip = snippet_with_context(cx, indexed.span, ctxt, "..", &mut app).0;
-                            (
-                                "dereference the original value instead",
-                                format!("&{}{}*{}", mutability.prefix_str(), "*".repeat(indexed_ref_count), snip),
-                            )
+                            let sugg = if needs_parens_for_prefix {
+                                format!("(&{}{}*{})", mutability.prefix_str(), "*".repeat(indexed_ref_count), snip)
+                            } else {
+                                format!("&{}{}*{}", mutability.prefix_str(), "*".repeat(indexed_ref_count), snip)
+                            };
+                            ("dereference the original value instead", sugg)
                         } else {
                             return;
                         }
diff --git a/tests/ui/redundant_slicing.fixed b/tests/ui/redundant_slicing.fixed
index 9716a48be94..98b2adec440 100644
--- a/tests/ui/redundant_slicing.fixed
+++ b/tests/ui/redundant_slicing.fixed
@@ -3,6 +3,8 @@
 #![allow(unused)]
 #![warn(clippy::redundant_slicing)]
 
+use std::io::Read;
+
 fn main() {
     let slice: &[u32] = &[0];
     let _ = slice; // Redundant slice
@@ -37,4 +39,8 @@ fn main() {
 
     let slice_ref = &slice;
     let _ = *slice_ref; // Deref instead of slice
+
+    // Issue #7972
+    let bytes: &[u8] = &[];
+    let _ = (&*bytes).read_to_end(&mut vec![]).unwrap();
 }
diff --git a/tests/ui/redundant_slicing.rs b/tests/ui/redundant_slicing.rs
index a6902f7619b..b84a304ec67 100644
--- a/tests/ui/redundant_slicing.rs
+++ b/tests/ui/redundant_slicing.rs
@@ -3,6 +3,8 @@
 #![allow(unused)]
 #![warn(clippy::redundant_slicing)]
 
+use std::io::Read;
+
 fn main() {
     let slice: &[u32] = &[0];
     let _ = &slice[..]; // Redundant slice
@@ -37,4 +39,8 @@ fn main() {
 
     let slice_ref = &slice;
     let _ = &slice_ref[..]; // Deref instead of slice
+
+    // Issue #7972
+    let bytes: &[u8] = &[];
+    let _ = (&bytes[..]).read_to_end(&mut vec![]).unwrap();
 }
diff --git a/tests/ui/redundant_slicing.stderr b/tests/ui/redundant_slicing.stderr
index c2a5e9e1914..bce35111790 100644
--- a/tests/ui/redundant_slicing.stderr
+++ b/tests/ui/redundant_slicing.stderr
@@ -1,5 +1,5 @@
 error: redundant slicing of the whole range
-  --> $DIR/redundant_slicing.rs:8:13
+  --> $DIR/redundant_slicing.rs:10:13
    |
 LL |     let _ = &slice[..]; // Redundant slice
    |             ^^^^^^^^^^ help: use the original value instead: `slice`
@@ -7,52 +7,58 @@ LL |     let _ = &slice[..]; // Redundant slice
    = note: `-D clippy::redundant-slicing` implied by `-D warnings`
 
 error: redundant slicing of the whole range
-  --> $DIR/redundant_slicing.rs:11:13
+  --> $DIR/redundant_slicing.rs:13:13
    |
 LL |     let _ = &v[..]; // Deref instead of slice
    |             ^^^^^^ help: dereference the original value instead: `&*v`
 
 error: redundant slicing of the whole range
-  --> $DIR/redundant_slicing.rs:12:13
+  --> $DIR/redundant_slicing.rs:14:13
    |
 LL |     let _ = &(&*v)[..]; // Outer borrow is redundant
    |             ^^^^^^^^^^ help: use the original value instead: `(&*v)`
 
 error: redundant slicing of the whole range
-  --> $DIR/redundant_slicing.rs:15:20
+  --> $DIR/redundant_slicing.rs:17:20
    |
 LL |     let err = &mut &S[..]; // Should reborrow instead of slice
    |                    ^^^^^^ help: reborrow the original value instead: `&*S`
 
 error: redundant slicing of the whole range
-  --> $DIR/redundant_slicing.rs:18:21
+  --> $DIR/redundant_slicing.rs:20:21
    |
 LL |     let mut_slice = &mut vec[..]; // Deref instead of slice
    |                     ^^^^^^^^^^^^ help: dereference the original value instead: `&mut *vec`
 
 error: redundant slicing of the whole range
-  --> $DIR/redundant_slicing.rs:19:13
+  --> $DIR/redundant_slicing.rs:21:13
    |
 LL |     let _ = &mut mut_slice[..]; // Should reborrow instead of slice
    |             ^^^^^^^^^^^^^^^^^^ help: reborrow the original value instead: `&mut *mut_slice`
 
 error: redundant slicing of the whole range
-  --> $DIR/redundant_slicing.rs:22:13
+  --> $DIR/redundant_slicing.rs:24:13
    |
 LL |     let _ = &ref_vec[..]; // Deref instead of slice
    |             ^^^^^^^^^^^^ help: dereference the original value instead: `&**ref_vec`
 
 error: redundant slicing of the whole range
-  --> $DIR/redundant_slicing.rs:29:13
+  --> $DIR/redundant_slicing.rs:31:13
    |
 LL |     let _ = &m!(slice)[..];
    |             ^^^^^^^^^^^^^^ help: use the original value instead: `slice`
 
 error: redundant slicing of the whole range
-  --> $DIR/redundant_slicing.rs:39:13
+  --> $DIR/redundant_slicing.rs:41:13
    |
 LL |     let _ = &slice_ref[..]; // Deref instead of slice
    |             ^^^^^^^^^^^^^^ help: dereference the original value instead: `*slice_ref`
 
-error: aborting due to 9 previous errors
+error: redundant slicing of the whole range
+  --> $DIR/redundant_slicing.rs:45:13
+   |
+LL |     let _ = (&bytes[..]).read_to_end(&mut vec![]).unwrap();
+   |             ^^^^^^^^^^^^ help: reborrow the original value instead: `(&*bytes)`
+
+error: aborting due to 10 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 113ac6e15e16efb193985be9c5329a72d55df30b Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Tue, 11 Jan 2022 12:41:15 -0500
Subject: Split off new lint `deref_by_slicing` from `redundant_slicing`

---
 CHANGELOG.md                                 |  1 +
 clippy_lints/src/lib.register_lints.rs       |  1 +
 clippy_lints/src/lib.register_restriction.rs |  1 +
 clippy_lints/src/redundant_slicing.rs        | 36 +++++++++++++++++++++++-----
 tests/ui/deref_by_slicing.fixed              | 16 +++++++++++++
 tests/ui/deref_by_slicing.rs                 | 16 +++++++++++++
 tests/ui/deref_by_slicing.stderr             | 34 ++++++++++++++++++++++++++
 tests/ui/redundant_slicing.fixed             |  8 +++----
 tests/ui/redundant_slicing.rs                |  8 +++----
 tests/ui/redundant_slicing.stderr            | 20 +---------------
 10 files changed, 108 insertions(+), 33 deletions(-)
 create mode 100644 tests/ui/deref_by_slicing.fixed
 create mode 100644 tests/ui/deref_by_slicing.rs
 create mode 100644 tests/ui/deref_by_slicing.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index c9adf77c0d6..ef7139d63bf 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3105,6 +3105,7 @@ Released 2018-09-13
 [`deprecated_cfg_attr`]: https://rust-lang.github.io/rust-clippy/master/index.html#deprecated_cfg_attr
 [`deprecated_semver`]: https://rust-lang.github.io/rust-clippy/master/index.html#deprecated_semver
 [`deref_addrof`]: https://rust-lang.github.io/rust-clippy/master/index.html#deref_addrof
+[`deref_by_slicing`]: https://rust-lang.github.io/rust-clippy/master/index.html#deref_by_slicing
 [`derivable_impls`]: https://rust-lang.github.io/rust-clippy/master/index.html#derivable_impls
 [`derive_hash_xor_eq`]: https://rust-lang.github.io/rust-clippy/master/index.html#derive_hash_xor_eq
 [`derive_ord_xor_partial_ord`]: https://rust-lang.github.io/rust-clippy/master/index.html#derive_ord_xor_partial_ord
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index a80320a578f..2451a5aab09 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -420,6 +420,7 @@ store.register_lints(&[
     redundant_else::REDUNDANT_ELSE,
     redundant_field_names::REDUNDANT_FIELD_NAMES,
     redundant_pub_crate::REDUNDANT_PUB_CRATE,
+    redundant_slicing::DEREF_BY_SLICING,
     redundant_slicing::REDUNDANT_SLICING,
     redundant_static_lifetimes::REDUNDANT_STATIC_LIFETIMES,
     ref_option_ref::REF_OPTION_REF,
diff --git a/clippy_lints/src/lib.register_restriction.rs b/clippy_lints/src/lib.register_restriction.rs
index 5a89fdb05a9..f89f35b885c 100644
--- a/clippy_lints/src/lib.register_restriction.rs
+++ b/clippy_lints/src/lib.register_restriction.rs
@@ -51,6 +51,7 @@ store.register_group(true, "clippy::restriction", Some("clippy_restriction"), ve
     LintId::of(panic_unimplemented::UNIMPLEMENTED),
     LintId::of(panic_unimplemented::UNREACHABLE),
     LintId::of(pattern_type_mismatch::PATTERN_TYPE_MISMATCH),
+    LintId::of(redundant_slicing::DEREF_BY_SLICING),
     LintId::of(same_name_method::SAME_NAME_METHOD),
     LintId::of(shadow::SHADOW_REUSE),
     LintId::of(shadow::SHADOW_SAME),
diff --git a/clippy_lints/src/redundant_slicing.rs b/clippy_lints/src/redundant_slicing.rs
index 1cc0990b283..0de4541b641 100644
--- a/clippy_lints/src/redundant_slicing.rs
+++ b/clippy_lints/src/redundant_slicing.rs
@@ -42,7 +42,31 @@ declare_clippy_lint! {
     "redundant slicing of the whole range of a type"
 }
 
-declare_lint_pass!(RedundantSlicing => [REDUNDANT_SLICING]);
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for slicing expression which are equivalent to dereferencing the
+    /// value.
+    ///
+    /// ### Why is this bad?
+    /// Some people may prefer to dereference rather than slice.
+    ///
+    /// ### Example
+    /// ```rust
+    /// let vec = vec![1, 2, 3];
+    /// let slice = &vec[..];
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// let vec = vec![1, 2, 3];
+    /// let slice = &*vec;
+    /// ```
+    #[clippy::version = "1.60.0"]
+    pub DEREF_BY_SLICING,
+    restriction,
+    "slicing instead of dereferencing"
+}
+
+declare_lint_pass!(RedundantSlicing => [REDUNDANT_SLICING, DEREF_BY_SLICING]);
 
 impl<'tcx> LateLintPass<'tcx> for RedundantSlicing {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
@@ -65,7 +89,7 @@ impl<'tcx> LateLintPass<'tcx> for RedundantSlicing {
                 });
                 let mut app = Applicability::MachineApplicable;
 
-                let (help, sugg) = if expr_ty == indexed_ty {
+                let (lint, msg, help, sugg) = if expr_ty == indexed_ty {
                     if expr_ref_count > indexed_ref_count {
                         // Indexing takes self by reference and can't return a reference to that
                         // reference as it's a local variable. The only way this could happen is if
@@ -103,7 +127,7 @@ impl<'tcx> LateLintPass<'tcx> for RedundantSlicing {
                         format!("{}{}{}", reborrow_str, "*".repeat(deref_count), snip)
                     };
 
-                    (help_str, sugg)
+                    (REDUNDANT_SLICING, "redundant slicing of the whole range", help_str, sugg)
                 } else if let Some(target_id) = cx.tcx.lang_items().deref_target() {
                     if let Ok(deref_ty) = cx.tcx.try_normalize_erasing_regions(
                         cx.param_env,
@@ -116,7 +140,7 @@ impl<'tcx> LateLintPass<'tcx> for RedundantSlicing {
                             } else {
                                 format!("&{}{}*{}", mutability.prefix_str(), "*".repeat(indexed_ref_count), snip)
                             };
-                            ("dereference the original value instead", sugg)
+                            (DEREF_BY_SLICING, "slicing when dereferencing would work", "dereference the original value instead", sugg)
                         } else {
                             return;
                         }
@@ -129,9 +153,9 @@ impl<'tcx> LateLintPass<'tcx> for RedundantSlicing {
 
                 span_lint_and_sugg(
                     cx,
-                    REDUNDANT_SLICING,
+                    lint,
                     expr.span,
-                    "redundant slicing of the whole range",
+                    msg,
                     help,
                     sugg,
                     app,
diff --git a/tests/ui/deref_by_slicing.fixed b/tests/ui/deref_by_slicing.fixed
new file mode 100644
index 00000000000..edb19de0700
--- /dev/null
+++ b/tests/ui/deref_by_slicing.fixed
@@ -0,0 +1,16 @@
+// run-rustfix
+
+#![warn(clippy::deref_by_slicing)]
+
+fn main() {
+    let mut vec = vec![0];
+    let _ = &*vec;
+    let _ = &mut *vec;
+
+    let ref_vec = &mut vec;
+    let _ = &**ref_vec;
+    let _ = &mut **ref_vec;
+
+    let s = String::new();
+    let _ = &*s;
+}
diff --git a/tests/ui/deref_by_slicing.rs b/tests/ui/deref_by_slicing.rs
new file mode 100644
index 00000000000..6d489a44e76
--- /dev/null
+++ b/tests/ui/deref_by_slicing.rs
@@ -0,0 +1,16 @@
+// run-rustfix
+
+#![warn(clippy::deref_by_slicing)]
+
+fn main() {
+    let mut vec = vec![0];
+    let _ = &vec[..];
+    let _ = &mut vec[..];
+
+    let ref_vec = &mut vec;
+    let _ = &ref_vec[..];
+    let _ = &mut ref_vec[..];
+
+    let s = String::new();
+    let _ = &s[..];
+}
diff --git a/tests/ui/deref_by_slicing.stderr b/tests/ui/deref_by_slicing.stderr
new file mode 100644
index 00000000000..89e4ca718b5
--- /dev/null
+++ b/tests/ui/deref_by_slicing.stderr
@@ -0,0 +1,34 @@
+error: slicing when dereferencing would work
+  --> $DIR/deref_by_slicing.rs:7:13
+   |
+LL |     let _ = &vec[..];
+   |             ^^^^^^^^ help: dereference the original value instead: `&*vec`
+   |
+   = note: `-D clippy::deref-by-slicing` implied by `-D warnings`
+
+error: slicing when dereferencing would work
+  --> $DIR/deref_by_slicing.rs:8:13
+   |
+LL |     let _ = &mut vec[..];
+   |             ^^^^^^^^^^^^ help: dereference the original value instead: `&mut *vec`
+
+error: slicing when dereferencing would work
+  --> $DIR/deref_by_slicing.rs:11:13
+   |
+LL |     let _ = &ref_vec[..];
+   |             ^^^^^^^^^^^^ help: dereference the original value instead: `&**ref_vec`
+
+error: slicing when dereferencing would work
+  --> $DIR/deref_by_slicing.rs:12:13
+   |
+LL |     let _ = &mut ref_vec[..];
+   |             ^^^^^^^^^^^^^^^^ help: dereference the original value instead: `&mut **ref_vec`
+
+error: slicing when dereferencing would work
+  --> $DIR/deref_by_slicing.rs:15:13
+   |
+LL |     let _ = &s[..];
+   |             ^^^^^^ help: dereference the original value instead: `&*s`
+
+error: aborting due to 5 previous errors
+
diff --git a/tests/ui/redundant_slicing.fixed b/tests/ui/redundant_slicing.fixed
index 98b2adec440..da3d953375a 100644
--- a/tests/ui/redundant_slicing.fixed
+++ b/tests/ui/redundant_slicing.fixed
@@ -1,6 +1,6 @@
 // run-rustfix
 
-#![allow(unused)]
+#![allow(unused, clippy::deref_by_slicing)]
 #![warn(clippy::redundant_slicing)]
 
 use std::io::Read;
@@ -10,18 +10,18 @@ fn main() {
     let _ = slice; // Redundant slice
 
     let v = vec![0];
-    let _ = &*v; // Deref instead of slice
+    let _ = &v[..]; // Ok, results in `&[_]`
     let _ = (&*v); // Outer borrow is redundant
 
     static S: &[u8] = &[0, 1, 2];
     let err = &mut &*S; // Should reborrow instead of slice
 
     let mut vec = vec![0];
-    let mut_slice = &mut *vec; // Deref instead of slice
+    let mut_slice = &mut vec[..]; // Ok, results in `&mut [_]`
     let _ = &mut *mut_slice; // Should reborrow instead of slice
 
     let ref_vec = &vec;
-    let _ = &**ref_vec; // Deref instead of slice
+    let _ = &ref_vec[..]; // Ok, results in `&[_]`
 
     macro_rules! m {
         ($e:expr) => {
diff --git a/tests/ui/redundant_slicing.rs b/tests/ui/redundant_slicing.rs
index b84a304ec67..125b1d4591c 100644
--- a/tests/ui/redundant_slicing.rs
+++ b/tests/ui/redundant_slicing.rs
@@ -1,6 +1,6 @@
 // run-rustfix
 
-#![allow(unused)]
+#![allow(unused, clippy::deref_by_slicing)]
 #![warn(clippy::redundant_slicing)]
 
 use std::io::Read;
@@ -10,18 +10,18 @@ fn main() {
     let _ = &slice[..]; // Redundant slice
 
     let v = vec![0];
-    let _ = &v[..]; // Deref instead of slice
+    let _ = &v[..]; // Ok, results in `&[_]`
     let _ = &(&*v)[..]; // Outer borrow is redundant
 
     static S: &[u8] = &[0, 1, 2];
     let err = &mut &S[..]; // Should reborrow instead of slice
 
     let mut vec = vec![0];
-    let mut_slice = &mut vec[..]; // Deref instead of slice
+    let mut_slice = &mut vec[..]; // Ok, results in `&mut [_]`
     let _ = &mut mut_slice[..]; // Should reborrow instead of slice
 
     let ref_vec = &vec;
-    let _ = &ref_vec[..]; // Deref instead of slice
+    let _ = &ref_vec[..]; // Ok, results in `&[_]`
 
     macro_rules! m {
         ($e:expr) => {
diff --git a/tests/ui/redundant_slicing.stderr b/tests/ui/redundant_slicing.stderr
index bce35111790..b1c1c28894a 100644
--- a/tests/ui/redundant_slicing.stderr
+++ b/tests/ui/redundant_slicing.stderr
@@ -6,12 +6,6 @@ LL |     let _ = &slice[..]; // Redundant slice
    |
    = note: `-D clippy::redundant-slicing` implied by `-D warnings`
 
-error: redundant slicing of the whole range
-  --> $DIR/redundant_slicing.rs:13:13
-   |
-LL |     let _ = &v[..]; // Deref instead of slice
-   |             ^^^^^^ help: dereference the original value instead: `&*v`
-
 error: redundant slicing of the whole range
   --> $DIR/redundant_slicing.rs:14:13
    |
@@ -24,24 +18,12 @@ error: redundant slicing of the whole range
 LL |     let err = &mut &S[..]; // Should reborrow instead of slice
    |                    ^^^^^^ help: reborrow the original value instead: `&*S`
 
-error: redundant slicing of the whole range
-  --> $DIR/redundant_slicing.rs:20:21
-   |
-LL |     let mut_slice = &mut vec[..]; // Deref instead of slice
-   |                     ^^^^^^^^^^^^ help: dereference the original value instead: `&mut *vec`
-
 error: redundant slicing of the whole range
   --> $DIR/redundant_slicing.rs:21:13
    |
 LL |     let _ = &mut mut_slice[..]; // Should reborrow instead of slice
    |             ^^^^^^^^^^^^^^^^^^ help: reborrow the original value instead: `&mut *mut_slice`
 
-error: redundant slicing of the whole range
-  --> $DIR/redundant_slicing.rs:24:13
-   |
-LL |     let _ = &ref_vec[..]; // Deref instead of slice
-   |             ^^^^^^^^^^^^ help: dereference the original value instead: `&**ref_vec`
-
 error: redundant slicing of the whole range
   --> $DIR/redundant_slicing.rs:31:13
    |
@@ -60,5 +42,5 @@ error: redundant slicing of the whole range
 LL |     let _ = (&bytes[..]).read_to_end(&mut vec![]).unwrap();
    |             ^^^^^^^^^^^^ help: reborrow the original value instead: `(&*bytes)`
 
-error: aborting due to 10 previous errors
+error: aborting due to 7 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 7724d6773d3fe4ac1e57e4e13d67fedbf7cae0ba Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sun, 13 Feb 2022 18:43:19 -0500
Subject: Move some cases from `redundant_slicing` to `deref_by_slicing`

---
 clippy_lints/src/redundant_slicing.rs | 23 ++++++++++++---------
 tests/ui/deref_by_slicing.fixed       | 15 +++++++++++++-
 tests/ui/deref_by_slicing.rs          | 15 +++++++++++++-
 tests/ui/deref_by_slicing.stderr      | 38 ++++++++++++++++++++++++++++-------
 tests/ui/redundant_slicing.fixed      |  8 ++++----
 tests/ui/redundant_slicing.rs         |  8 ++++----
 tests/ui/redundant_slicing.stderr     | 26 +-----------------------
 7 files changed, 81 insertions(+), 52 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/redundant_slicing.rs b/clippy_lints/src/redundant_slicing.rs
index 0de4541b641..25a9072ef6e 100644
--- a/clippy_lints/src/redundant_slicing.rs
+++ b/clippy_lints/src/redundant_slicing.rs
@@ -6,7 +6,7 @@ use if_chain::if_chain;
 use rustc_ast::util::parser::PREC_PREFIX;
 use rustc_errors::Applicability;
 use rustc_hir::{BorrowKind, Expr, ExprKind, LangItem, Mutability};
-use rustc_lint::{LateContext, LateLintPass};
+use rustc_lint::{LateContext, LateLintPass, Lint};
 use rustc_middle::ty::adjustment::{Adjust, AutoBorrow, AutoBorrowMutability};
 use rustc_middle::ty::subst::GenericArg;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -44,7 +44,7 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for slicing expression which are equivalent to dereferencing the
+    /// Checks for slicing expressions which are equivalent to dereferencing the
     /// value.
     ///
     /// ### Why is this bad?
@@ -68,6 +68,9 @@ declare_clippy_lint! {
 
 declare_lint_pass!(RedundantSlicing => [REDUNDANT_SLICING, DEREF_BY_SLICING]);
 
+static REDUNDANT_SLICING_LINT: (&Lint, &str) = (REDUNDANT_SLICING, "redundant slicing of the whole range");
+static DEREF_BY_SLICING_LINT: (&Lint, &str) = (DEREF_BY_SLICING, "slicing when dereferencing would work");
+
 impl<'tcx> LateLintPass<'tcx> for RedundantSlicing {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if expr.span.from_expansion() {
@@ -89,7 +92,7 @@ impl<'tcx> LateLintPass<'tcx> for RedundantSlicing {
                 });
                 let mut app = Applicability::MachineApplicable;
 
-                let (lint, msg, help, sugg) = if expr_ty == indexed_ty {
+                let ((lint, msg), help, sugg) = if expr_ty == indexed_ty {
                     if expr_ref_count > indexed_ref_count {
                         // Indexing takes self by reference and can't return a reference to that
                         // reference as it's a local variable. The only way this could happen is if
@@ -100,9 +103,9 @@ impl<'tcx> LateLintPass<'tcx> for RedundantSlicing {
                     }
                     let deref_count = indexed_ref_count - expr_ref_count;
 
-                    let (reborrow_str, help_str) = if mutability == Mutability::Mut {
+                    let (lint, reborrow_str, help_str) = if mutability == Mutability::Mut {
                         // The slice was used to reborrow the mutable reference.
-                        ("&mut *", "reborrow the original value instead")
+                        (DEREF_BY_SLICING_LINT, "&mut *", "reborrow the original value instead")
                     } else if matches!(
                         parent_expr,
                         Some(Expr {
@@ -113,11 +116,11 @@ impl<'tcx> LateLintPass<'tcx> for RedundantSlicing {
                         matches!(a.kind, Adjust::Borrow(AutoBorrow::Ref(_, AutoBorrowMutability::Mut { .. })))
                     }) {
                         // The slice was used to make a temporary reference.
-                        ("&*", "reborrow the original value instead")
+                        (DEREF_BY_SLICING_LINT, "&*", "reborrow the original value instead")
                     } else if deref_count != 0 {
-                        ("", "dereference the original value instead")
+                        (DEREF_BY_SLICING_LINT, "", "dereference the original value instead")
                     } else {
-                        ("", "use the original value instead")
+                        (REDUNDANT_SLICING_LINT, "", "use the original value instead")
                     };
 
                     let snip = snippet_with_context(cx, indexed.span, ctxt, "..", &mut app).0;
@@ -127,7 +130,7 @@ impl<'tcx> LateLintPass<'tcx> for RedundantSlicing {
                         format!("{}{}{}", reborrow_str, "*".repeat(deref_count), snip)
                     };
 
-                    (REDUNDANT_SLICING, "redundant slicing of the whole range", help_str, sugg)
+                    (lint, help_str, sugg)
                 } else if let Some(target_id) = cx.tcx.lang_items().deref_target() {
                     if let Ok(deref_ty) = cx.tcx.try_normalize_erasing_regions(
                         cx.param_env,
@@ -140,7 +143,7 @@ impl<'tcx> LateLintPass<'tcx> for RedundantSlicing {
                             } else {
                                 format!("&{}{}*{}", mutability.prefix_str(), "*".repeat(indexed_ref_count), snip)
                             };
-                            (DEREF_BY_SLICING, "slicing when dereferencing would work", "dereference the original value instead", sugg)
+                            (DEREF_BY_SLICING_LINT, "dereference the original value instead", sugg)
                         } else {
                             return;
                         }
diff --git a/tests/ui/deref_by_slicing.fixed b/tests/ui/deref_by_slicing.fixed
index edb19de0700..b26276218b7 100644
--- a/tests/ui/deref_by_slicing.fixed
+++ b/tests/ui/deref_by_slicing.fixed
@@ -2,6 +2,8 @@
 
 #![warn(clippy::deref_by_slicing)]
 
+use std::io::Read;
+
 fn main() {
     let mut vec = vec![0];
     let _ = &*vec;
@@ -9,8 +11,19 @@ fn main() {
 
     let ref_vec = &mut vec;
     let _ = &**ref_vec;
-    let _ = &mut **ref_vec;
+    let mut_slice = &mut **ref_vec;
+    let _ = &mut *mut_slice; // Err, re-borrows slice
 
     let s = String::new();
     let _ = &*s;
+
+    static S: &[u8] = &[0, 1, 2];
+    let _ = &mut &*S; // Err, re-borrows slice
+
+    let slice: &[u32] = &[0u32, 1u32];
+    let slice_ref = &slice;
+    let _ = *slice_ref; // Err, derefs slice
+
+    let bytes: &[u8] = &[];
+    let _ = (&*bytes).read_to_end(&mut vec![]).unwrap(); // Err, re-borrows slice
 }
diff --git a/tests/ui/deref_by_slicing.rs b/tests/ui/deref_by_slicing.rs
index 6d489a44e76..6aa1408ba17 100644
--- a/tests/ui/deref_by_slicing.rs
+++ b/tests/ui/deref_by_slicing.rs
@@ -2,6 +2,8 @@
 
 #![warn(clippy::deref_by_slicing)]
 
+use std::io::Read;
+
 fn main() {
     let mut vec = vec![0];
     let _ = &vec[..];
@@ -9,8 +11,19 @@ fn main() {
 
     let ref_vec = &mut vec;
     let _ = &ref_vec[..];
-    let _ = &mut ref_vec[..];
+    let mut_slice = &mut ref_vec[..];
+    let _ = &mut mut_slice[..]; // Err, re-borrows slice
 
     let s = String::new();
     let _ = &s[..];
+
+    static S: &[u8] = &[0, 1, 2];
+    let _ = &mut &S[..]; // Err, re-borrows slice
+
+    let slice: &[u32] = &[0u32, 1u32];
+    let slice_ref = &slice;
+    let _ = &slice_ref[..]; // Err, derefs slice
+
+    let bytes: &[u8] = &[];
+    let _ = (&bytes[..]).read_to_end(&mut vec![]).unwrap(); // Err, re-borrows slice
 }
diff --git a/tests/ui/deref_by_slicing.stderr b/tests/ui/deref_by_slicing.stderr
index 89e4ca718b5..ffd76de378d 100644
--- a/tests/ui/deref_by_slicing.stderr
+++ b/tests/ui/deref_by_slicing.stderr
@@ -1,5 +1,5 @@
 error: slicing when dereferencing would work
-  --> $DIR/deref_by_slicing.rs:7:13
+  --> $DIR/deref_by_slicing.rs:9:13
    |
 LL |     let _ = &vec[..];
    |             ^^^^^^^^ help: dereference the original value instead: `&*vec`
@@ -7,28 +7,52 @@ LL |     let _ = &vec[..];
    = note: `-D clippy::deref-by-slicing` implied by `-D warnings`
 
 error: slicing when dereferencing would work
-  --> $DIR/deref_by_slicing.rs:8:13
+  --> $DIR/deref_by_slicing.rs:10:13
    |
 LL |     let _ = &mut vec[..];
    |             ^^^^^^^^^^^^ help: dereference the original value instead: `&mut *vec`
 
 error: slicing when dereferencing would work
-  --> $DIR/deref_by_slicing.rs:11:13
+  --> $DIR/deref_by_slicing.rs:13:13
    |
 LL |     let _ = &ref_vec[..];
    |             ^^^^^^^^^^^^ help: dereference the original value instead: `&**ref_vec`
 
 error: slicing when dereferencing would work
-  --> $DIR/deref_by_slicing.rs:12:13
+  --> $DIR/deref_by_slicing.rs:14:21
    |
-LL |     let _ = &mut ref_vec[..];
-   |             ^^^^^^^^^^^^^^^^ help: dereference the original value instead: `&mut **ref_vec`
+LL |     let mut_slice = &mut ref_vec[..];
+   |                     ^^^^^^^^^^^^^^^^ help: dereference the original value instead: `&mut **ref_vec`
 
 error: slicing when dereferencing would work
   --> $DIR/deref_by_slicing.rs:15:13
    |
+LL |     let _ = &mut mut_slice[..]; // Err, re-borrows slice
+   |             ^^^^^^^^^^^^^^^^^^ help: reborrow the original value instead: `&mut *mut_slice`
+
+error: slicing when dereferencing would work
+  --> $DIR/deref_by_slicing.rs:18:13
+   |
 LL |     let _ = &s[..];
    |             ^^^^^^ help: dereference the original value instead: `&*s`
 
-error: aborting due to 5 previous errors
+error: slicing when dereferencing would work
+  --> $DIR/deref_by_slicing.rs:21:18
+   |
+LL |     let _ = &mut &S[..]; // Err, re-borrows slice
+   |                  ^^^^^^ help: reborrow the original value instead: `&*S`
+
+error: slicing when dereferencing would work
+  --> $DIR/deref_by_slicing.rs:25:13
+   |
+LL |     let _ = &slice_ref[..]; // Err, derefs slice
+   |             ^^^^^^^^^^^^^^ help: dereference the original value instead: `*slice_ref`
+
+error: slicing when dereferencing would work
+  --> $DIR/deref_by_slicing.rs:28:13
+   |
+LL |     let _ = (&bytes[..]).read_to_end(&mut vec![]).unwrap(); // Err, re-borrows slice
+   |             ^^^^^^^^^^^^ help: reborrow the original value instead: `(&*bytes)`
+
+error: aborting due to 9 previous errors
 
diff --git a/tests/ui/redundant_slicing.fixed b/tests/ui/redundant_slicing.fixed
index da3d953375a..8dd8d309237 100644
--- a/tests/ui/redundant_slicing.fixed
+++ b/tests/ui/redundant_slicing.fixed
@@ -14,11 +14,11 @@ fn main() {
     let _ = (&*v); // Outer borrow is redundant
 
     static S: &[u8] = &[0, 1, 2];
-    let err = &mut &*S; // Should reborrow instead of slice
+    let _ = &mut &S[..]; // Ok, re-borrows slice
 
     let mut vec = vec![0];
     let mut_slice = &mut vec[..]; // Ok, results in `&mut [_]`
-    let _ = &mut *mut_slice; // Should reborrow instead of slice
+    let _ = &mut mut_slice[..]; // Ok, re-borrows slice
 
     let ref_vec = &vec;
     let _ = &ref_vec[..]; // Ok, results in `&[_]`
@@ -38,9 +38,9 @@ fn main() {
     let _ = m2!(slice); // Don't lint in a macro
 
     let slice_ref = &slice;
-    let _ = *slice_ref; // Deref instead of slice
+    let _ = &slice_ref[..]; // Ok, derefs slice
 
     // Issue #7972
     let bytes: &[u8] = &[];
-    let _ = (&*bytes).read_to_end(&mut vec![]).unwrap();
+    let _ = (&bytes[..]).read_to_end(&mut vec![]).unwrap(); // Ok, re-borrows slice
 }
diff --git a/tests/ui/redundant_slicing.rs b/tests/ui/redundant_slicing.rs
index 125b1d4591c..51c16dd8d65 100644
--- a/tests/ui/redundant_slicing.rs
+++ b/tests/ui/redundant_slicing.rs
@@ -14,11 +14,11 @@ fn main() {
     let _ = &(&*v)[..]; // Outer borrow is redundant
 
     static S: &[u8] = &[0, 1, 2];
-    let err = &mut &S[..]; // Should reborrow instead of slice
+    let _ = &mut &S[..]; // Ok, re-borrows slice
 
     let mut vec = vec![0];
     let mut_slice = &mut vec[..]; // Ok, results in `&mut [_]`
-    let _ = &mut mut_slice[..]; // Should reborrow instead of slice
+    let _ = &mut mut_slice[..]; // Ok, re-borrows slice
 
     let ref_vec = &vec;
     let _ = &ref_vec[..]; // Ok, results in `&[_]`
@@ -38,9 +38,9 @@ fn main() {
     let _ = m2!(slice); // Don't lint in a macro
 
     let slice_ref = &slice;
-    let _ = &slice_ref[..]; // Deref instead of slice
+    let _ = &slice_ref[..]; // Ok, derefs slice
 
     // Issue #7972
     let bytes: &[u8] = &[];
-    let _ = (&bytes[..]).read_to_end(&mut vec![]).unwrap();
+    let _ = (&bytes[..]).read_to_end(&mut vec![]).unwrap(); // Ok, re-borrows slice
 }
diff --git a/tests/ui/redundant_slicing.stderr b/tests/ui/redundant_slicing.stderr
index b1c1c28894a..82367143c07 100644
--- a/tests/ui/redundant_slicing.stderr
+++ b/tests/ui/redundant_slicing.stderr
@@ -12,35 +12,11 @@ error: redundant slicing of the whole range
 LL |     let _ = &(&*v)[..]; // Outer borrow is redundant
    |             ^^^^^^^^^^ help: use the original value instead: `(&*v)`
 
-error: redundant slicing of the whole range
-  --> $DIR/redundant_slicing.rs:17:20
-   |
-LL |     let err = &mut &S[..]; // Should reborrow instead of slice
-   |                    ^^^^^^ help: reborrow the original value instead: `&*S`
-
-error: redundant slicing of the whole range
-  --> $DIR/redundant_slicing.rs:21:13
-   |
-LL |     let _ = &mut mut_slice[..]; // Should reborrow instead of slice
-   |             ^^^^^^^^^^^^^^^^^^ help: reborrow the original value instead: `&mut *mut_slice`
-
 error: redundant slicing of the whole range
   --> $DIR/redundant_slicing.rs:31:13
    |
 LL |     let _ = &m!(slice)[..];
    |             ^^^^^^^^^^^^^^ help: use the original value instead: `slice`
 
-error: redundant slicing of the whole range
-  --> $DIR/redundant_slicing.rs:41:13
-   |
-LL |     let _ = &slice_ref[..]; // Deref instead of slice
-   |             ^^^^^^^^^^^^^^ help: dereference the original value instead: `*slice_ref`
-
-error: redundant slicing of the whole range
-  --> $DIR/redundant_slicing.rs:45:13
-   |
-LL |     let _ = (&bytes[..]).read_to_end(&mut vec![]).unwrap();
-   |             ^^^^^^^^^^^^ help: reborrow the original value instead: `(&*bytes)`
-
-error: aborting due to 7 previous errors
+error: aborting due to 3 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 504f3af70ea4cb2ce13f9272babb4e59b61fd88e Mon Sep 17 00:00:00 2001
From: Marcel Hellwig <github@cookiesoft.de>
Date: Mon, 14 Feb 2022 13:22:36 +0100
Subject: Don't lint Default::default if it is the udpate syntax base

An Update Syntax looks like this:

   Foo {
      a: 3,
      ..Default::default()
    }

Don't lint `Default::default` here
---
 clippy_lints/src/default.rs         | 16 +++++++++++++++-
 tests/ui/default_trait_access.fixed | 15 +++++++++++++--
 tests/ui/default_trait_access.rs    | 15 +++++++++++++--
 3 files changed, 41 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/default.rs b/clippy_lints/src/default.rs
index 3070588483c..06e6bf986c2 100644
--- a/clippy_lints/src/default.rs
+++ b/clippy_lints/src/default.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::{span_lint_and_note, span_lint_and_sugg};
 use clippy_utils::source::snippet_with_macro_callsite;
 use clippy_utils::ty::{has_drop, is_copy};
-use clippy_utils::{any_parent_is_automatically_derived, contains_name, match_def_path, paths};
+use clippy_utils::{any_parent_is_automatically_derived, contains_name, get_parent_expr, match_def_path, paths};
 use if_chain::if_chain;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Applicability;
@@ -88,6 +88,7 @@ impl<'tcx> LateLintPass<'tcx> for Default {
             if let ExprKind::Path(ref qpath) = path.kind;
             if let Some(def_id) = cx.qpath_res(qpath, path.hir_id).opt_def_id();
             if match_def_path(cx, def_id, &paths::DEFAULT_TRAIT_METHOD);
+            if !is_update_syntax_base(cx, expr);
             // Detect and ignore <Foo as Default>::default() because these calls do explicitly name the type.
             if let QPath::Resolved(None, _path) = qpath;
             let expr_ty = cx.typeck_results().expr_ty(expr);
@@ -290,3 +291,16 @@ fn field_reassigned_by_stmt<'tcx>(this: &Stmt<'tcx>, binding_name: Symbol) -> Op
         }
     }
 }
+
+/// Returns whether `expr` is the update syntax base: `Foo { a: 1, .. base }`
+fn is_update_syntax_base<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> bool {
+    if_chain! {
+        if let Some(parent) = get_parent_expr(cx, expr);
+        if let ExprKind::Struct(_, _, Some(base)) = parent.kind;
+        then {
+            base.hir_id == expr.hir_id
+        } else {
+            false
+        }
+    }
+}
diff --git a/tests/ui/default_trait_access.fixed b/tests/ui/default_trait_access.fixed
index 9114d8754dc..264dd4efaeb 100644
--- a/tests/ui/default_trait_access.fixed
+++ b/tests/ui/default_trait_access.fixed
@@ -46,9 +46,14 @@ fn main() {
 
     let s19 = <DerivedDefault as Default>::default();
 
+    let s20 = UpdateSyntax {
+        s: "foo",
+        ..Default::default()
+    };
+
     println!(
-        "[{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}] [{:?}] [{:?}] [{:?}] [{:?}] [{:?}] [{:?}] [{:?}] [{:?}] [{:?}], [{:?}]",
-        s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17, s18, s19,
+        "[{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}] [{:?}] [{:?}] [{:?}] [{:?}] [{:?}] [{:?}] [{:?}] [{:?}] [{:?}] [{:?}] [{:?}]",
+        s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17, s18, s19, s20,
     );
 }
 
@@ -86,3 +91,9 @@ struct ArrayDerivedDefault {
 
 #[derive(Debug, Default)]
 struct TupleStructDerivedDefault(String);
+
+#[derive(Debug, Default)]
+struct UpdateSyntax {
+    pub s: &'static str,
+    pub u: u64,
+}
diff --git a/tests/ui/default_trait_access.rs b/tests/ui/default_trait_access.rs
index 8a5f0d6a749..a0930fab8e7 100644
--- a/tests/ui/default_trait_access.rs
+++ b/tests/ui/default_trait_access.rs
@@ -46,9 +46,14 @@ fn main() {
 
     let s19 = <DerivedDefault as Default>::default();
 
+    let s20 = UpdateSyntax {
+        s: "foo",
+        ..Default::default()
+    };
+
     println!(
-        "[{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}] [{:?}] [{:?}] [{:?}] [{:?}] [{:?}] [{:?}] [{:?}] [{:?}] [{:?}], [{:?}]",
-        s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17, s18, s19,
+        "[{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}] [{:?}] [{:?}] [{:?}] [{:?}] [{:?}] [{:?}] [{:?}] [{:?}] [{:?}] [{:?}] [{:?}]",
+        s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17, s18, s19, s20,
     );
 }
 
@@ -86,3 +91,9 @@ struct ArrayDerivedDefault {
 
 #[derive(Debug, Default)]
 struct TupleStructDerivedDefault(String);
+
+#[derive(Debug, Default)]
+struct UpdateSyntax {
+    pub s: &'static str,
+    pub u: u64,
+}
-- 
cgit 1.4.1-3-g733a5


From 9bfcbf4f027fea5096e6a721b1b73fbf057e14cf Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Thu, 17 Feb 2022 10:48:24 -0500
Subject: Remove some redundant checks in various matches lints

---
 clippy_lints/src/matches/match_like_matches.rs     |  45 +++---
 clippy_lints/src/matches/match_same_arms.rs        | 152 ++++++++++-----------
 clippy_lints/src/matches/mod.rs                    |  48 +++----
 .../src/matches/redundant_pattern_match.rs         |  12 +-
 4 files changed, 128 insertions(+), 129 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/match_like_matches.rs b/clippy_lints/src/matches/match_like_matches.rs
index d605b6d73c0..2e1f7646eb4 100644
--- a/clippy_lints/src/matches/match_like_matches.rs
+++ b/clippy_lints/src/matches/match_like_matches.rs
@@ -3,7 +3,7 @@ use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::{higher, is_wild};
 use rustc_ast::{Attribute, LitKind};
 use rustc_errors::Applicability;
-use rustc_hir::{BorrowKind, Expr, ExprKind, Guard, MatchSource, Pat};
+use rustc_hir::{Arm, BorrowKind, Expr, ExprKind, Guard, Pat};
 use rustc_lint::LateContext;
 use rustc_middle::ty;
 use rustc_span::source_map::Spanned;
@@ -11,7 +11,7 @@ use rustc_span::source_map::Spanned;
 use super::MATCH_LIKE_MATCHES_MACRO;
 
 /// Lint a `match` or `if let .. { .. } else { .. }` expr that could be replaced by `matches!`
-pub(crate) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> bool {
+pub(crate) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
     if let Some(higher::IfLet {
         let_pat,
         let_expr,
@@ -19,7 +19,7 @@ pub(crate) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> bool
         if_else: Some(if_else),
     }) = higher::IfLet::hir(cx, expr)
     {
-        return find_matches_sugg(
+        find_matches_sugg(
             cx,
             let_expr,
             IntoIterator::into_iter([(&[][..], Some(let_pat), if_then, None), (&[][..], None, if_else, None)]),
@@ -27,25 +27,28 @@ pub(crate) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> bool
             true,
         );
     }
+}
 
-    if let ExprKind::Match(scrut, arms, MatchSource::Normal) = expr.kind {
-        return find_matches_sugg(
-            cx,
-            scrut,
-            arms.iter().map(|arm| {
-                (
-                    cx.tcx.hir().attrs(arm.hir_id),
-                    Some(arm.pat),
-                    arm.body,
-                    arm.guard.as_ref(),
-                )
-            }),
-            expr,
-            false,
-        );
-    }
-
-    false
+pub(super) fn check_match<'tcx>(
+    cx: &LateContext<'tcx>,
+    e: &'tcx Expr<'_>,
+    scrutinee: &'tcx Expr<'_>,
+    arms: &'tcx [Arm<'tcx>],
+) -> bool {
+    find_matches_sugg(
+        cx,
+        scrutinee,
+        arms.iter().map(|arm| {
+            (
+                cx.tcx.hir().attrs(arm.hir_id),
+                Some(arm.pat),
+                arm.body,
+                arm.guard.as_ref(),
+            )
+        }),
+        e,
+        false,
+    )
 }
 
 /// Lint a `match` or `if let` for replacement by `matches!`
diff --git a/clippy_lints/src/matches/match_same_arms.rs b/clippy_lints/src/matches/match_same_arms.rs
index 271a3868595..d11dda57e6f 100644
--- a/clippy_lints/src/matches/match_same_arms.rs
+++ b/clippy_lints/src/matches/match_same_arms.rs
@@ -1,96 +1,94 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet;
 use clippy_utils::{path_to_local, search_same, SpanlessEq, SpanlessHash};
-use rustc_hir::{Arm, Expr, ExprKind, HirId, HirIdMap, HirIdSet, MatchSource, Pat, PatKind};
+use rustc_hir::{Arm, Expr, HirId, HirIdMap, HirIdSet, Pat, PatKind};
 use rustc_lint::LateContext;
 use std::collections::hash_map::Entry;
 
 use super::MATCH_SAME_ARMS;
 
-pub(crate) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>) {
-    if let ExprKind::Match(_, arms, MatchSource::Normal) = expr.kind {
-        let hash = |&(_, arm): &(usize, &Arm<'_>)| -> u64 {
-            let mut h = SpanlessHash::new(cx);
-            h.hash_expr(arm.body);
-            h.finish()
-        };
+pub(crate) fn check<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>]) {
+    let hash = |&(_, arm): &(usize, &Arm<'_>)| -> u64 {
+        let mut h = SpanlessHash::new(cx);
+        h.hash_expr(arm.body);
+        h.finish()
+    };
 
-        let eq = |&(lindex, lhs): &(usize, &Arm<'_>), &(rindex, rhs): &(usize, &Arm<'_>)| -> bool {
-            let min_index = usize::min(lindex, rindex);
-            let max_index = usize::max(lindex, rindex);
+    let eq = |&(lindex, lhs): &(usize, &Arm<'_>), &(rindex, rhs): &(usize, &Arm<'_>)| -> bool {
+        let min_index = usize::min(lindex, rindex);
+        let max_index = usize::max(lindex, rindex);
 
-            let mut local_map: HirIdMap<HirId> = HirIdMap::default();
-            let eq_fallback = |a: &Expr<'_>, b: &Expr<'_>| {
-                if_chain! {
-                    if let Some(a_id) = path_to_local(a);
-                    if let Some(b_id) = path_to_local(b);
-                    let entry = match local_map.entry(a_id) {
-                        Entry::Vacant(entry) => entry,
-                        // check if using the same bindings as before
-                        Entry::Occupied(entry) => return *entry.get() == b_id,
-                    };
-                    // the names technically don't have to match; this makes the lint more conservative
-                    if cx.tcx.hir().name(a_id) == cx.tcx.hir().name(b_id);
-                    if cx.typeck_results().expr_ty(a) == cx.typeck_results().expr_ty(b);
-                    if pat_contains_local(lhs.pat, a_id);
-                    if pat_contains_local(rhs.pat, b_id);
-                    then {
-                        entry.insert(b_id);
-                        true
-                    } else {
-                        false
-                    }
+        let mut local_map: HirIdMap<HirId> = HirIdMap::default();
+        let eq_fallback = |a: &Expr<'_>, b: &Expr<'_>| {
+            if_chain! {
+                if let Some(a_id) = path_to_local(a);
+                if let Some(b_id) = path_to_local(b);
+                let entry = match local_map.entry(a_id) {
+                    Entry::Vacant(entry) => entry,
+                    // check if using the same bindings as before
+                    Entry::Occupied(entry) => return *entry.get() == b_id,
+                };
+                // the names technically don't have to match; this makes the lint more conservative
+                if cx.tcx.hir().name(a_id) == cx.tcx.hir().name(b_id);
+                if cx.typeck_results().expr_ty(a) == cx.typeck_results().expr_ty(b);
+                if pat_contains_local(lhs.pat, a_id);
+                if pat_contains_local(rhs.pat, b_id);
+                then {
+                    entry.insert(b_id);
+                    true
+                } else {
+                    false
                 }
-            };
-            // Arms with a guard are ignored, those can’t always be merged together
-            // This is also the case for arms in-between each there is an arm with a guard
-            (min_index..=max_index).all(|index| arms[index].guard.is_none())
-                && SpanlessEq::new(cx)
-                    .expr_fallback(eq_fallback)
-                    .eq_expr(lhs.body, rhs.body)
-                // these checks could be removed to allow unused bindings
-                && bindings_eq(lhs.pat, local_map.keys().copied().collect())
-                && bindings_eq(rhs.pat, local_map.values().copied().collect())
+            }
         };
+        // Arms with a guard are ignored, those can’t always be merged together
+        // This is also the case for arms in-between each there is an arm with a guard
+        (min_index..=max_index).all(|index| arms[index].guard.is_none())
+            && SpanlessEq::new(cx)
+                .expr_fallback(eq_fallback)
+                .eq_expr(lhs.body, rhs.body)
+            // these checks could be removed to allow unused bindings
+            && bindings_eq(lhs.pat, local_map.keys().copied().collect())
+            && bindings_eq(rhs.pat, local_map.values().copied().collect())
+    };
 
-        let indexed_arms: Vec<(usize, &Arm<'_>)> = arms.iter().enumerate().collect();
-        for (&(_, i), &(_, j)) in search_same(&indexed_arms, hash, eq) {
-            span_lint_and_then(
-                cx,
-                MATCH_SAME_ARMS,
-                j.body.span,
-                "this `match` has identical arm bodies",
-                |diag| {
-                    diag.span_note(i.body.span, "same as this");
+    let indexed_arms: Vec<(usize, &Arm<'_>)> = arms.iter().enumerate().collect();
+    for (&(_, i), &(_, j)) in search_same(&indexed_arms, hash, eq) {
+        span_lint_and_then(
+            cx,
+            MATCH_SAME_ARMS,
+            j.body.span,
+            "this `match` has identical arm bodies",
+            |diag| {
+                diag.span_note(i.body.span, "same as this");
 
-                    // Note: this does not use `span_suggestion` on purpose:
-                    // there is no clean way
-                    // to remove the other arm. Building a span and suggest to replace it to ""
-                    // makes an even more confusing error message. Also in order not to make up a
-                    // span for the whole pattern, the suggestion is only shown when there is only
-                    // one pattern. The user should know about `|` if they are already using it…
+                // Note: this does not use `span_suggestion` on purpose:
+                // there is no clean way
+                // to remove the other arm. Building a span and suggest to replace it to ""
+                // makes an even more confusing error message. Also in order not to make up a
+                // span for the whole pattern, the suggestion is only shown when there is only
+                // one pattern. The user should know about `|` if they are already using it…
 
-                    let lhs = snippet(cx, i.pat.span, "<pat1>");
-                    let rhs = snippet(cx, j.pat.span, "<pat2>");
+                let lhs = snippet(cx, i.pat.span, "<pat1>");
+                let rhs = snippet(cx, j.pat.span, "<pat2>");
 
-                    if let PatKind::Wild = j.pat.kind {
-                        // if the last arm is _, then i could be integrated into _
-                        // note that i.pat cannot be _, because that would mean that we're
-                        // hiding all the subsequent arms, and rust won't compile
-                        diag.span_note(
-                            i.body.span,
-                            &format!(
-                                "`{}` has the same arm body as the `_` wildcard, consider removing it",
-                                lhs
-                            ),
-                        );
-                    } else {
-                        diag.span_help(i.pat.span, &format!("consider refactoring into `{} | {}`", lhs, rhs,))
-                            .help("...or consider changing the match arm bodies");
-                    }
-                },
-            );
-        }
+                if let PatKind::Wild = j.pat.kind {
+                    // if the last arm is _, then i could be integrated into _
+                    // note that i.pat cannot be _, because that would mean that we're
+                    // hiding all the subsequent arms, and rust won't compile
+                    diag.span_note(
+                        i.body.span,
+                        &format!(
+                            "`{}` has the same arm body as the `_` wildcard, consider removing it",
+                            lhs
+                        ),
+                    );
+                } else {
+                    diag.span_help(i.pat.span, &format!("consider refactoring into `{} | {}`", lhs, rhs,))
+                        .help("...or consider changing the match arm bodies");
+                }
+            },
+        );
     }
 }
 
diff --git a/clippy_lints/src/matches/mod.rs b/clippy_lints/src/matches/mod.rs
index b5ee4561f06..614a824010f 100644
--- a/clippy_lints/src/matches/mod.rs
+++ b/clippy_lints/src/matches/mod.rs
@@ -604,33 +604,35 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
             return;
         }
 
-        redundant_pattern_match::check(cx, expr);
+        if let ExprKind::Match(ex, arms, source) = expr.kind {
+            if source == MatchSource::Normal {
+                if !(meets_msrv(self.msrv.as_ref(), &msrvs::MATCHES_MACRO)
+                    && match_like_matches::check_match(cx, expr, ex, arms))
+                {
+                    match_same_arms::check(cx, arms);
+                }
 
-        if meets_msrv(self.msrv.as_ref(), &msrvs::MATCHES_MACRO) {
-            if !match_like_matches::check(cx, expr) {
-                match_same_arms::check(cx, expr);
-            }
-        } else {
-            match_same_arms::check(cx, expr);
-        }
-
-        if let ExprKind::Match(ex, arms, MatchSource::Normal) = expr.kind {
-            single_match::check(cx, ex, arms, expr);
-            match_bool::check(cx, ex, arms, expr);
-            overlapping_arms::check(cx, ex, arms);
-            match_wild_err_arm::check(cx, ex, arms);
-            match_wild_enum::check(cx, ex, arms);
-            match_as_ref::check(cx, ex, arms, expr);
-            wild_in_or_pats::check(cx, arms);
+                redundant_pattern_match::check_match(cx, expr, ex, arms);
+                single_match::check(cx, ex, arms, expr);
+                match_bool::check(cx, ex, arms, expr);
+                overlapping_arms::check(cx, ex, arms);
+                match_wild_err_arm::check(cx, ex, arms);
+                match_wild_enum::check(cx, ex, arms);
+                match_as_ref::check(cx, ex, arms, expr);
+                wild_in_or_pats::check(cx, arms);
 
-            if self.infallible_destructuring_match_linted {
-                self.infallible_destructuring_match_linted = false;
-            } else {
-                match_single_binding::check(cx, ex, arms, expr);
+                if self.infallible_destructuring_match_linted {
+                    self.infallible_destructuring_match_linted = false;
+                } else {
+                    match_single_binding::check(cx, ex, arms, expr);
+                }
             }
-        }
-        if let ExprKind::Match(ex, arms, _) = expr.kind {
             match_ref_pats::check(cx, ex, arms.iter().map(|el| el.pat), expr);
+        } else {
+            if meets_msrv(self.msrv.as_ref(), &msrvs::MATCHES_MACRO) {
+                match_like_matches::check(cx, expr);
+            }
+            redundant_pattern_match::check(cx, expr);
         }
     }
 
diff --git a/clippy_lints/src/matches/redundant_pattern_match.rs b/clippy_lints/src/matches/redundant_pattern_match.rs
index 61c5fa0872f..c491b2775d8 100644
--- a/clippy_lints/src/matches/redundant_pattern_match.rs
+++ b/clippy_lints/src/matches/redundant_pattern_match.rs
@@ -12,13 +12,13 @@ use rustc_errors::Applicability;
 use rustc_hir::LangItem::{OptionNone, PollPending};
 use rustc_hir::{
     intravisit::{walk_expr, Visitor},
-    Arm, Block, Expr, ExprKind, LangItem, MatchSource, Node, Pat, PatKind, QPath, UnOp,
+    Arm, Block, Expr, ExprKind, LangItem, Node, Pat, PatKind, QPath, UnOp,
 };
 use rustc_lint::LateContext;
 use rustc_middle::ty::{self, subst::GenericArgKind, DefIdTree, Ty};
 use rustc_span::sym;
 
-pub fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
     if let Some(higher::IfLet {
         if_else,
         let_pat,
@@ -27,11 +27,7 @@ pub fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
     }) = higher::IfLet::hir(cx, expr)
     {
         find_sugg_for_if_let(cx, expr, let_pat, let_expr, "if", if_else.is_some());
-    }
-    if let ExprKind::Match(op, arms, MatchSource::Normal) = &expr.kind {
-        find_sugg_for_match(cx, expr, op, arms);
-    }
-    if let Some(higher::WhileLet { let_pat, let_expr, .. }) = higher::WhileLet::hir(expr) {
+    } else if let Some(higher::WhileLet { let_pat, let_expr, .. }) = higher::WhileLet::hir(expr) {
         find_sugg_for_if_let(cx, expr, let_pat, let_expr, "while", false);
     }
 }
@@ -304,7 +300,7 @@ fn find_sugg_for_if_let<'tcx>(
     );
 }
 
-fn find_sugg_for_match<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, op: &Expr<'_>, arms: &[Arm<'_>]) {
+pub(super) fn check_match<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, op: &Expr<'_>, arms: &[Arm<'_>]) {
     if arms.len() == 2 {
         let node_pair = (&arms[0].pat.kind, &arms[1].pat.kind);
 
-- 
cgit 1.4.1-3-g733a5


From cdf9a28006b1216653eac1bdc45a83e436fac9ba Mon Sep 17 00:00:00 2001
From: flip1995 <philipp.krones@embecosm.com>
Date: Sat, 12 Feb 2022 10:23:07 +0100
Subject: Improve lint message of await_holding_*

Improves the message of the lints await_holding_lock and
await_holding_refcell_ref. Now also actually tests RwLock.
---
 clippy_lints/src/await_holding_invalid.rs | 31 ++++++++++-----
 tests/ui/await_holding_lock.rs            | 26 ++++++++++++-
 tests/ui/await_holding_lock.stderr        | 64 +++++++++++++++++++++++--------
 tests/ui/await_holding_refcell_ref.stderr | 30 +++++++++------
 4 files changed, 114 insertions(+), 37 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/await_holding_invalid.rs b/clippy_lints/src/await_holding_invalid.rs
index 1cc3418d474..f7bc8395c82 100644
--- a/clippy_lints/src/await_holding_invalid.rs
+++ b/clippy_lints/src/await_holding_invalid.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_note;
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::{match_def_path, paths};
 use rustc_hir::def_id::DefId;
 use rustc_hir::{AsyncGeneratorKind, Body, BodyId, GeneratorKind};
@@ -118,23 +118,36 @@ fn check_interior_types(cx: &LateContext<'_>, ty_causes: &[GeneratorInteriorType
     for ty_cause in ty_causes {
         if let rustc_middle::ty::Adt(adt, _) = ty_cause.ty.kind() {
             if is_mutex_guard(cx, adt.did) {
-                span_lint_and_note(
+                span_lint_and_then(
                     cx,
                     AWAIT_HOLDING_LOCK,
                     ty_cause.span,
-                    "this MutexGuard is held across an 'await' point. Consider using an async-aware Mutex type or ensuring the MutexGuard is dropped before calling await",
-                    ty_cause.scope_span.or(Some(span)),
-                    "these are all the await points this lock is held through",
+                    "this `MutexGuard` is held across an `await` point",
+                    |diag| {
+                        diag.help(
+                            "consider using an async-aware `Mutex` type or ensuring the \
+                                `MutexGuard` is dropped before calling await",
+                        );
+                        diag.span_note(
+                            ty_cause.scope_span.unwrap_or(span),
+                            "these are all the `await` points this lock is held through",
+                        );
+                    },
                 );
             }
             if is_refcell_ref(cx, adt.did) {
-                span_lint_and_note(
+                span_lint_and_then(
                     cx,
                     AWAIT_HOLDING_REFCELL_REF,
                     ty_cause.span,
-                    "this RefCell Ref is held across an 'await' point. Consider ensuring the Ref is dropped before calling await",
-                    ty_cause.scope_span.or(Some(span)),
-                    "these are all the await points this ref is held through",
+                    "this `RefCell` reference is held across an `await` point",
+                    |diag| {
+                        diag.help("ensure the reference is dropped before calling `await`");
+                        diag.span_note(
+                            ty_cause.scope_span.unwrap_or(span),
+                            "these are all the `await` points this reference is held through",
+                        );
+                    },
                 );
             }
         }
diff --git a/tests/ui/await_holding_lock.rs b/tests/ui/await_holding_lock.rs
index dd6640a387a..f03356d83df 100644
--- a/tests/ui/await_holding_lock.rs
+++ b/tests/ui/await_holding_lock.rs
@@ -1,6 +1,6 @@
 #![warn(clippy::await_holding_lock)]
 
-use std::sync::Mutex;
+use std::sync::{Mutex, RwLock};
 
 async fn bad(x: &Mutex<u32>) -> u32 {
     let guard = x.lock().unwrap();
@@ -17,6 +17,30 @@ async fn good(x: &Mutex<u32>) -> u32 {
     47
 }
 
+pub async fn bad_rw(x: &RwLock<u32>) -> u32 {
+    let guard = x.read().unwrap();
+    baz().await
+}
+
+pub async fn bad_rw_write(x: &RwLock<u32>) -> u32 {
+    let mut guard = x.write().unwrap();
+    baz().await
+}
+
+pub async fn good_rw(x: &RwLock<u32>) -> u32 {
+    {
+        let guard = x.read().unwrap();
+        let y = *guard + 1;
+    }
+    {
+        let mut guard = x.write().unwrap();
+        *guard += 1;
+    }
+    baz().await;
+    let guard = x.read().unwrap();
+    47
+}
+
 async fn baz() -> u32 {
     42
 }
diff --git a/tests/ui/await_holding_lock.stderr b/tests/ui/await_holding_lock.stderr
index ddfb104cdfb..3a501acbb67 100644
--- a/tests/ui/await_holding_lock.stderr
+++ b/tests/ui/await_holding_lock.stderr
@@ -1,11 +1,12 @@
-error: this MutexGuard is held across an 'await' point. Consider using an async-aware Mutex type or ensuring the MutexGuard is dropped before calling await
+error: this `MutexGuard` is held across an `await` point
   --> $DIR/await_holding_lock.rs:6:9
    |
 LL |     let guard = x.lock().unwrap();
    |         ^^^^^
    |
    = note: `-D clippy::await-holding-lock` implied by `-D warnings`
-note: these are all the await points this lock is held through
+   = help: consider using an async-aware `Mutex` type or ensuring the `MutexGuard` is dropped before calling await
+note: these are all the `await` points this lock is held through
   --> $DIR/await_holding_lock.rs:6:5
    |
 LL | /     let guard = x.lock().unwrap();
@@ -13,14 +14,45 @@ LL | |     baz().await
 LL | | }
    | |_^
 
-error: this MutexGuard is held across an 'await' point. Consider using an async-aware Mutex type or ensuring the MutexGuard is dropped before calling await
-  --> $DIR/await_holding_lock.rs:27:9
+error: this `MutexGuard` is held across an `await` point
+  --> $DIR/await_holding_lock.rs:21:9
+   |
+LL |     let guard = x.read().unwrap();
+   |         ^^^^^
+   |
+   = help: consider using an async-aware `Mutex` type or ensuring the `MutexGuard` is dropped before calling await
+note: these are all the `await` points this lock is held through
+  --> $DIR/await_holding_lock.rs:21:5
+   |
+LL | /     let guard = x.read().unwrap();
+LL | |     baz().await
+LL | | }
+   | |_^
+
+error: this `MutexGuard` is held across an `await` point
+  --> $DIR/await_holding_lock.rs:26:9
+   |
+LL |     let mut guard = x.write().unwrap();
+   |         ^^^^^^^^^
+   |
+   = help: consider using an async-aware `Mutex` type or ensuring the `MutexGuard` is dropped before calling await
+note: these are all the `await` points this lock is held through
+  --> $DIR/await_holding_lock.rs:26:5
+   |
+LL | /     let mut guard = x.write().unwrap();
+LL | |     baz().await
+LL | | }
+   | |_^
+
+error: this `MutexGuard` is held across an `await` point
+  --> $DIR/await_holding_lock.rs:51:9
    |
 LL |     let guard = x.lock().unwrap();
    |         ^^^^^
    |
-note: these are all the await points this lock is held through
-  --> $DIR/await_holding_lock.rs:27:5
+   = help: consider using an async-aware `Mutex` type or ensuring the `MutexGuard` is dropped before calling await
+note: these are all the `await` points this lock is held through
+  --> $DIR/await_holding_lock.rs:51:5
    |
 LL | /     let guard = x.lock().unwrap();
 LL | |
@@ -31,33 +63,35 @@ LL | |     first + second + third
 LL | | }
    | |_^
 
-error: this MutexGuard is held across an 'await' point. Consider using an async-aware Mutex type or ensuring the MutexGuard is dropped before calling await
-  --> $DIR/await_holding_lock.rs:40:13
+error: this `MutexGuard` is held across an `await` point
+  --> $DIR/await_holding_lock.rs:64:13
    |
 LL |         let guard = x.lock().unwrap();
    |             ^^^^^
    |
-note: these are all the await points this lock is held through
-  --> $DIR/await_holding_lock.rs:40:9
+   = help: consider using an async-aware `Mutex` type or ensuring the `MutexGuard` is dropped before calling await
+note: these are all the `await` points this lock is held through
+  --> $DIR/await_holding_lock.rs:64:9
    |
 LL | /         let guard = x.lock().unwrap();
 LL | |         baz().await
 LL | |     };
    | |_____^
 
-error: this MutexGuard is held across an 'await' point. Consider using an async-aware Mutex type or ensuring the MutexGuard is dropped before calling await
-  --> $DIR/await_holding_lock.rs:52:13
+error: this `MutexGuard` is held across an `await` point
+  --> $DIR/await_holding_lock.rs:76:13
    |
 LL |         let guard = x.lock().unwrap();
    |             ^^^^^
    |
-note: these are all the await points this lock is held through
-  --> $DIR/await_holding_lock.rs:52:9
+   = help: consider using an async-aware `Mutex` type or ensuring the `MutexGuard` is dropped before calling await
+note: these are all the `await` points this lock is held through
+  --> $DIR/await_holding_lock.rs:76:9
    |
 LL | /         let guard = x.lock().unwrap();
 LL | |         baz().await
 LL | |     }
    | |_____^
 
-error: aborting due to 4 previous errors
+error: aborting due to 6 previous errors
 
diff --git a/tests/ui/await_holding_refcell_ref.stderr b/tests/ui/await_holding_refcell_ref.stderr
index 67cc0032be2..4339fca735d 100644
--- a/tests/ui/await_holding_refcell_ref.stderr
+++ b/tests/ui/await_holding_refcell_ref.stderr
@@ -1,11 +1,12 @@
-error: this RefCell Ref is held across an 'await' point. Consider ensuring the Ref is dropped before calling await
+error: this `RefCell` reference is held across an `await` point
   --> $DIR/await_holding_refcell_ref.rs:6:9
    |
 LL |     let b = x.borrow();
    |         ^
    |
    = note: `-D clippy::await-holding-refcell-ref` implied by `-D warnings`
-note: these are all the await points this ref is held through
+   = help: ensure the reference is dropped before calling `await`
+note: these are all the `await` points this reference is held through
   --> $DIR/await_holding_refcell_ref.rs:6:5
    |
 LL | /     let b = x.borrow();
@@ -13,13 +14,14 @@ LL | |     baz().await
 LL | | }
    | |_^
 
-error: this RefCell Ref is held across an 'await' point. Consider ensuring the Ref is dropped before calling await
+error: this `RefCell` reference is held across an `await` point
   --> $DIR/await_holding_refcell_ref.rs:11:9
    |
 LL |     let b = x.borrow_mut();
    |         ^
    |
-note: these are all the await points this ref is held through
+   = help: ensure the reference is dropped before calling `await`
+note: these are all the `await` points this reference is held through
   --> $DIR/await_holding_refcell_ref.rs:11:5
    |
 LL | /     let b = x.borrow_mut();
@@ -27,13 +29,14 @@ LL | |     baz().await
 LL | | }
    | |_^
 
-error: this RefCell Ref is held across an 'await' point. Consider ensuring the Ref is dropped before calling await
+error: this `RefCell` reference is held across an `await` point
   --> $DIR/await_holding_refcell_ref.rs:32:9
    |
 LL |     let b = x.borrow_mut();
    |         ^
    |
-note: these are all the await points this ref is held through
+   = help: ensure the reference is dropped before calling `await`
+note: these are all the `await` points this reference is held through
   --> $DIR/await_holding_refcell_ref.rs:32:5
    |
 LL | /     let b = x.borrow_mut();
@@ -45,13 +48,14 @@ LL | |     first + second + third
 LL | | }
    | |_^
 
-error: this RefCell Ref is held across an 'await' point. Consider ensuring the Ref is dropped before calling await
+error: this `RefCell` reference is held across an `await` point
   --> $DIR/await_holding_refcell_ref.rs:44:9
    |
 LL |     let b = x.borrow_mut();
    |         ^
    |
-note: these are all the await points this ref is held through
+   = help: ensure the reference is dropped before calling `await`
+note: these are all the `await` points this reference is held through
   --> $DIR/await_holding_refcell_ref.rs:44:5
    |
 LL | /     let b = x.borrow_mut();
@@ -63,13 +67,14 @@ LL | |     first + second + third
 LL | | }
    | |_^
 
-error: this RefCell Ref is held across an 'await' point. Consider ensuring the Ref is dropped before calling await
+error: this `RefCell` reference is held across an `await` point
   --> $DIR/await_holding_refcell_ref.rs:59:13
    |
 LL |         let b = x.borrow_mut();
    |             ^
    |
-note: these are all the await points this ref is held through
+   = help: ensure the reference is dropped before calling `await`
+note: these are all the `await` points this reference is held through
   --> $DIR/await_holding_refcell_ref.rs:59:9
    |
 LL | /         let b = x.borrow_mut();
@@ -77,13 +82,14 @@ LL | |         baz().await
 LL | |     };
    | |_____^
 
-error: this RefCell Ref is held across an 'await' point. Consider ensuring the Ref is dropped before calling await
+error: this `RefCell` reference is held across an `await` point
   --> $DIR/await_holding_refcell_ref.rs:71:13
    |
 LL |         let b = x.borrow_mut();
    |             ^
    |
-note: these are all the await points this ref is held through
+   = help: ensure the reference is dropped before calling `await`
+note: these are all the `await` points this reference is held through
   --> $DIR/await_holding_refcell_ref.rs:71:9
    |
 LL | /         let b = x.borrow_mut();
-- 
cgit 1.4.1-3-g733a5


From ea0ce7bb76bb01741fc3ba2ca32a80c75a380d0f Mon Sep 17 00:00:00 2001
From: flip1995 <philipp.krones@embecosm.com>
Date: Thu, 17 Feb 2022 17:57:39 +0100
Subject: Move await_holding_* lints to suspicious and improve doc

Even though the FP for that the lints were moved to pedantic isn't fixed
yet, running the lintcheck tool over the most popular 279 crates didn't
trigger this lint once. I would say that this lint is valuable enough,
despite the known FP, to be warn-by-default. Especially since a pretty
nice workaround exists.
---
 clippy_lints/src/await_holding_invalid.rs   | 88 ++++++++++++++++++++---------
 clippy_lints/src/lib.register_all.rs        |  2 +
 clippy_lints/src/lib.register_pedantic.rs   |  2 -
 clippy_lints/src/lib.register_suspicious.rs |  2 +
 4 files changed, 64 insertions(+), 30 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/await_holding_invalid.rs b/clippy_lints/src/await_holding_invalid.rs
index f7bc8395c82..f0979840ff8 100644
--- a/clippy_lints/src/await_holding_invalid.rs
+++ b/clippy_lints/src/await_holding_invalid.rs
@@ -9,8 +9,7 @@ use rustc_span::Span;
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for calls to await while holding a
-    /// non-async-aware MutexGuard.
+    /// Checks for calls to await while holding a non-async-aware MutexGuard.
     ///
     /// ### Why is this bad?
     /// The Mutex types found in std::sync and parking_lot
@@ -22,41 +21,57 @@ declare_clippy_lint! {
     /// either by introducing a scope or an explicit call to Drop::drop.
     ///
     /// ### Known problems
-    /// Will report false positive for explicitly dropped guards ([#6446](https://github.com/rust-lang/rust-clippy/issues/6446)).
+    /// Will report false positive for explicitly dropped guards
+    /// ([#6446](https://github.com/rust-lang/rust-clippy/issues/6446)). A workaround for this is
+    /// to wrap the `.lock()` call in a block instead of explicitly dropping the guard.
     ///
     /// ### Example
-    /// ```rust,ignore
-    /// use std::sync::Mutex;
-    ///
+    /// ```rust
+    /// # use std::sync::Mutex;
+    /// # async fn baz() {}
     /// async fn foo(x: &Mutex<u32>) {
-    ///   let guard = x.lock().unwrap();
+    ///   let mut guard = x.lock().unwrap();
     ///   *guard += 1;
-    ///   bar.await;
+    ///   baz().await;
+    /// }
+    ///
+    /// async fn bar(x: &Mutex<u32>) {
+    ///   let mut guard = x.lock().unwrap();
+    ///   *guard += 1;
+    ///   drop(guard); // explicit drop
+    ///   baz().await;
     /// }
     /// ```
     ///
     /// Use instead:
-    /// ```rust,ignore
-    /// use std::sync::Mutex;
-    ///
+    /// ```rust
+    /// # use std::sync::Mutex;
+    /// # async fn baz() {}
     /// async fn foo(x: &Mutex<u32>) {
     ///   {
-    ///     let guard = x.lock().unwrap();
+    ///     let mut guard = x.lock().unwrap();
     ///     *guard += 1;
     ///   }
-    ///   bar.await;
+    ///   baz().await;
+    /// }
+    ///
+    /// async fn bar(x: &Mutex<u32>) {
+    ///   {
+    ///     let mut guard = x.lock().unwrap();
+    ///     *guard += 1;
+    ///   } // guard dropped here at end of scope
+    ///   baz().await;
     /// }
     /// ```
     #[clippy::version = "1.45.0"]
     pub AWAIT_HOLDING_LOCK,
-    pedantic,
-    "Inside an async function, holding a MutexGuard while calling await"
+    suspicious,
+    "inside an async function, holding a `MutexGuard` while calling `await`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for calls to await while holding a
-    /// `RefCell` `Ref` or `RefMut`.
+    /// Checks for calls to await while holding a `RefCell` `Ref` or `RefMut`.
     ///
     /// ### Why is this bad?
     /// `RefCell` refs only check for exclusive mutable access
@@ -64,35 +79,52 @@ declare_clippy_lint! {
     /// risks panics from a mutable ref shared while other refs are outstanding.
     ///
     /// ### Known problems
-    /// Will report false positive for explicitly dropped refs ([#6353](https://github.com/rust-lang/rust-clippy/issues/6353)).
+    /// Will report false positive for explicitly dropped refs
+    /// ([#6353](https://github.com/rust-lang/rust-clippy/issues/6353)). A workaround for this is
+    /// to wrap the `.borrow[_mut]()` call in a block instead of explicitly dropping the ref.
     ///
     /// ### Example
-    /// ```rust,ignore
-    /// use std::cell::RefCell;
-    ///
+    /// ```rust
+    /// # use std::cell::RefCell;
+    /// # async fn baz() {}
     /// async fn foo(x: &RefCell<u32>) {
     ///   let mut y = x.borrow_mut();
     ///   *y += 1;
-    ///   bar.await;
+    ///   baz().await;
+    /// }
+    ///
+    /// async fn bar(x: &RefCell<u32>) {
+    ///   let mut y = x.borrow_mut();
+    ///   *y += 1;
+    ///   drop(y); // explicit drop
+    ///   baz().await;
     /// }
     /// ```
     ///
     /// Use instead:
-    /// ```rust,ignore
-    /// use std::cell::RefCell;
-    ///
+    /// ```rust
+    /// # use std::cell::RefCell;
+    /// # async fn baz() {}
     /// async fn foo(x: &RefCell<u32>) {
     ///   {
     ///      let mut y = x.borrow_mut();
     ///      *y += 1;
     ///   }
-    ///   bar.await;
+    ///   baz().await;
+    /// }
+    ///
+    /// async fn bar(x: &RefCell<u32>) {
+    ///   {
+    ///     let mut y = x.borrow_mut();
+    ///     *y += 1;
+    ///   } // y dropped here at end of scope
+    ///   baz().await;
     /// }
     /// ```
     #[clippy::version = "1.49.0"]
     pub AWAIT_HOLDING_REFCELL_REF,
-    pedantic,
-    "Inside an async function, holding a RefCell ref while calling await"
+    suspicious,
+    "inside an async function, holding a `RefCell` ref while calling `await`"
 }
 
 declare_lint_pass!(AwaitHolding => [AWAIT_HOLDING_LOCK, AWAIT_HOLDING_REFCELL_REF]);
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index de0ff536907..a94f6b528b4 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -14,6 +14,8 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(attrs::DEPRECATED_SEMVER),
     LintId::of(attrs::MISMATCHED_TARGET_OS),
     LintId::of(attrs::USELESS_ATTRIBUTE),
+    LintId::of(await_holding_invalid::AWAIT_HOLDING_LOCK),
+    LintId::of(await_holding_invalid::AWAIT_HOLDING_REFCELL_REF),
     LintId::of(bit_mask::BAD_BIT_MASK),
     LintId::of(bit_mask::INEFFECTIVE_BIT_MASK),
     LintId::of(blacklisted_name::BLACKLISTED_NAME),
diff --git a/clippy_lints/src/lib.register_pedantic.rs b/clippy_lints/src/lib.register_pedantic.rs
index 1292675f4a9..00d30513181 100644
--- a/clippy_lints/src/lib.register_pedantic.rs
+++ b/clippy_lints/src/lib.register_pedantic.rs
@@ -4,8 +4,6 @@
 
 store.register_group(true, "clippy::pedantic", Some("clippy_pedantic"), vec![
     LintId::of(attrs::INLINE_ALWAYS),
-    LintId::of(await_holding_invalid::AWAIT_HOLDING_LOCK),
-    LintId::of(await_holding_invalid::AWAIT_HOLDING_REFCELL_REF),
     LintId::of(bit_mask::VERBOSE_BIT_MASK),
     LintId::of(borrow_as_ptr::BORROW_AS_PTR),
     LintId::of(bytecount::NAIVE_BYTECOUNT),
diff --git a/clippy_lints/src/lib.register_suspicious.rs b/clippy_lints/src/lib.register_suspicious.rs
index 10f8ae4b7f7..da56f800804 100644
--- a/clippy_lints/src/lib.register_suspicious.rs
+++ b/clippy_lints/src/lib.register_suspicious.rs
@@ -5,6 +5,8 @@
 store.register_group(true, "clippy::suspicious", Some("clippy_suspicious"), vec![
     LintId::of(assign_ops::MISREFACTORED_ASSIGN_OP),
     LintId::of(attrs::BLANKET_CLIPPY_RESTRICTION_LINTS),
+    LintId::of(await_holding_invalid::AWAIT_HOLDING_LOCK),
+    LintId::of(await_holding_invalid::AWAIT_HOLDING_REFCELL_REF),
     LintId::of(eval_order_dependence::EVAL_ORDER_DEPENDENCE),
     LintId::of(float_equality_without_abs::FLOAT_EQUALITY_WITHOUT_ABS),
     LintId::of(formatting::SUSPICIOUS_ASSIGNMENT_FORMATTING),
-- 
cgit 1.4.1-3-g733a5


From 8ce2d46cacc8b91f1d252d52cb38f397ee990435 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Thu, 17 Feb 2022 13:43:59 -0500
Subject: Check for `cfg` attrubutes before linting `match` expressions

---
 clippy_lints/src/matches/mod.rs              | 119 ++++++++++++++++++++++-----
 tests/ui/match_as_ref.fixed                  |  10 ++-
 tests/ui/match_as_ref.rs                     |  10 ++-
 tests/ui/match_bool.rs                       |   8 ++
 tests/ui/match_expr_like_matches_macro.fixed |  15 ++++
 tests/ui/match_expr_like_matches_macro.rs    |  15 ++++
 tests/ui/match_same_arms2.rs                 |  10 ++-
 tests/ui/single_match.rs                     |   8 ++
 8 files changed, 171 insertions(+), 24 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/mod.rs b/clippy_lints/src/matches/mod.rs
index 614a824010f..14dd7cb1dac 100644
--- a/clippy_lints/src/matches/mod.rs
+++ b/clippy_lints/src/matches/mod.rs
@@ -1,8 +1,11 @@
+use clippy_utils::source::{snippet_opt, walk_span_to_context};
 use clippy_utils::{meets_msrv, msrvs};
-use rustc_hir::{Expr, ExprKind, Local, MatchSource, Pat};
+use rustc_hir::{Arm, Expr, ExprKind, Local, MatchSource, Pat};
+use rustc_lexer::{tokenize, TokenKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::{Span, SpanData, SyntaxContext};
 
 mod infalliable_detructuring_match;
 mod match_as_ref;
@@ -605,29 +608,33 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
         }
 
         if let ExprKind::Match(ex, arms, source) = expr.kind {
-            if source == MatchSource::Normal {
-                if !(meets_msrv(self.msrv.as_ref(), &msrvs::MATCHES_MACRO)
-                    && match_like_matches::check_match(cx, expr, ex, arms))
-                {
-                    match_same_arms::check(cx, arms);
-                }
+            if !contains_cfg_arm(cx, expr, ex, arms) {
+                if source == MatchSource::Normal {
+                    if !(meets_msrv(self.msrv.as_ref(), &msrvs::MATCHES_MACRO)
+                        && match_like_matches::check_match(cx, expr, ex, arms))
+                    {
+                        match_same_arms::check(cx, arms);
+                    }
+
+                    redundant_pattern_match::check_match(cx, expr, ex, arms);
+                    single_match::check(cx, ex, arms, expr);
+                    match_bool::check(cx, ex, arms, expr);
+                    overlapping_arms::check(cx, ex, arms);
+                    match_wild_enum::check(cx, ex, arms);
+                    match_as_ref::check(cx, ex, arms, expr);
 
-                redundant_pattern_match::check_match(cx, expr, ex, arms);
-                single_match::check(cx, ex, arms, expr);
-                match_bool::check(cx, ex, arms, expr);
-                overlapping_arms::check(cx, ex, arms);
-                match_wild_err_arm::check(cx, ex, arms);
-                match_wild_enum::check(cx, ex, arms);
-                match_as_ref::check(cx, ex, arms, expr);
-                wild_in_or_pats::check(cx, arms);
-
-                if self.infallible_destructuring_match_linted {
-                    self.infallible_destructuring_match_linted = false;
-                } else {
-                    match_single_binding::check(cx, ex, arms, expr);
+                    if self.infallible_destructuring_match_linted {
+                        self.infallible_destructuring_match_linted = false;
+                    } else {
+                        match_single_binding::check(cx, ex, arms, expr);
+                    }
                 }
+                match_ref_pats::check(cx, ex, arms.iter().map(|el| el.pat), expr);
             }
-            match_ref_pats::check(cx, ex, arms.iter().map(|el| el.pat), expr);
+
+            // These don't depend on a relationship between multiple arms
+            match_wild_err_arm::check(cx, ex, arms);
+            wild_in_or_pats::check(cx, arms);
         } else {
             if meets_msrv(self.msrv.as_ref(), &msrvs::MATCHES_MACRO) {
                 match_like_matches::check(cx, expr);
@@ -646,3 +653,73 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
 
     extract_msrv_attr!(LateContext);
 }
+
+/// Checks if there are any arms with a `#[cfg(..)]` attribute.
+fn contains_cfg_arm(cx: &LateContext<'_>, e: &Expr<'_>, scrutinee: &Expr<'_>, arms: &[Arm<'_>]) -> bool {
+    let Some(scrutinee_span) = walk_span_to_context(scrutinee.span, SyntaxContext::root()) else {
+        // Shouldn't happen, but treat this as though a `cfg` attribute were found
+        return true;
+    };
+
+    let start = scrutinee_span.hi();
+    let mut arm_spans = arms.iter().map(|arm| {
+        let data = arm.span.data();
+        (data.ctxt == SyntaxContext::root()).then(|| (data.lo, data.hi))
+    });
+    let end = e.span.hi();
+
+    let found = arm_spans.try_fold(start, |start, range| {
+        let Some((end, next_start)) = range else {
+            // Shouldn't happen, but treat this as though a `cfg` attribute were found
+            return Err(());
+        };
+        let span = SpanData {
+            lo: start,
+            hi: end,
+            ctxt: SyntaxContext::root(),
+            parent: None,
+        }
+        .span();
+        (!span_contains_cfg(cx, span)).then(|| next_start).ok_or(())
+    });
+    match found {
+        Ok(start) => {
+            let span = SpanData {
+                lo: start,
+                hi: end,
+                ctxt: SyntaxContext::root(),
+                parent: None,
+            }
+            .span();
+            span_contains_cfg(cx, span)
+        },
+        Err(()) => true,
+    }
+}
+
+fn span_contains_cfg(cx: &LateContext<'_>, s: Span) -> bool {
+    let Some(snip) = snippet_opt(cx, s) else {
+        // Assume true. This would require either an invalid span, or one which crosses file boundaries.
+        return true;
+    };
+    let mut pos = 0usize;
+    let mut iter = tokenize(&snip).map(|t| {
+        let start = pos;
+        pos += t.len;
+        (t.kind, start..pos)
+    });
+    while iter.any(|(t, _)| matches!(t, TokenKind::Pound)) {
+        let mut iter = iter.by_ref().skip_while(|(t, _)| {
+            matches!(
+                t,
+                TokenKind::Whitespace | TokenKind::LineComment { .. } | TokenKind::BlockComment { .. }
+            )
+        });
+        if matches!(iter.next(), Some((TokenKind::OpenBracket, _)))
+            && matches!(iter.next(), Some((TokenKind::Ident, range)) if &snip[range.clone()] == "cfg")
+        {
+            return true;
+        }
+    }
+    false
+}
diff --git a/tests/ui/match_as_ref.fixed b/tests/ui/match_as_ref.fixed
index c61eb921664..ddfa1e741ad 100644
--- a/tests/ui/match_as_ref.fixed
+++ b/tests/ui/match_as_ref.fixed
@@ -32,4 +32,12 @@ mod issue4437 {
     }
 }
 
-fn main() {}
+fn main() {
+    // Don't lint
+    let _ = match Some(0) {
+        #[cfg(feature = "foo")]
+        Some(ref x) if *x > 50 => None,
+        Some(ref x) => Some(x),
+        None => None,
+    };
+}
diff --git a/tests/ui/match_as_ref.rs b/tests/ui/match_as_ref.rs
index 2fbd0b255fa..025d475ae13 100644
--- a/tests/ui/match_as_ref.rs
+++ b/tests/ui/match_as_ref.rs
@@ -41,4 +41,12 @@ mod issue4437 {
     }
 }
 
-fn main() {}
+fn main() {
+    // Don't lint
+    let _ = match Some(0) {
+        #[cfg(feature = "foo")]
+        Some(ref x) if *x > 50 => None,
+        Some(ref x) => Some(x),
+        None => None,
+    };
+}
diff --git a/tests/ui/match_bool.rs b/tests/ui/match_bool.rs
index 9ed55ca7ae7..bcc999a4942 100644
--- a/tests/ui/match_bool.rs
+++ b/tests/ui/match_bool.rs
@@ -50,6 +50,14 @@ fn match_bool() {
         11..=20 => 2,
         _ => 3,
     };
+
+    // Don't lint
+    let _ = match test {
+        #[cfg(feature = "foo")]
+        true if option == 5 => 10,
+        true => 0,
+        false => 1,
+    };
 }
 
 fn main() {}
diff --git a/tests/ui/match_expr_like_matches_macro.fixed b/tests/ui/match_expr_like_matches_macro.fixed
index c611f76bf96..36f233f3346 100644
--- a/tests/ui/match_expr_like_matches_macro.fixed
+++ b/tests/ui/match_expr_like_matches_macro.fixed
@@ -146,4 +146,19 @@ fn main() {
         let _res = matches!(&val, &Some(ref _a));
         fun(val);
     }
+
+    {
+        enum E {
+            A,
+            B,
+            C,
+        }
+
+        let _ = match E::A {
+            E::B => true,
+            #[cfg(feature = "foo")]
+            E::A => true,
+            _ => false,
+        };
+    }
 }
diff --git a/tests/ui/match_expr_like_matches_macro.rs b/tests/ui/match_expr_like_matches_macro.rs
index 2deeb84e741..750f69fa508 100644
--- a/tests/ui/match_expr_like_matches_macro.rs
+++ b/tests/ui/match_expr_like_matches_macro.rs
@@ -181,4 +181,19 @@ fn main() {
         };
         fun(val);
     }
+
+    {
+        enum E {
+            A,
+            B,
+            C,
+        }
+
+        let _ = match E::A {
+            E::B => true,
+            #[cfg(feature = "foo")]
+            E::A => true,
+            _ => false,
+        };
+    }
 }
diff --git a/tests/ui/match_same_arms2.rs b/tests/ui/match_same_arms2.rs
index da4e3020d5b..67e1d518483 100644
--- a/tests/ui/match_same_arms2.rs
+++ b/tests/ui/match_same_arms2.rs
@@ -166,4 +166,12 @@ fn match_expr_like_matches_macro_priority() {
     };
 }
 
-fn main() {}
+fn main() {
+    let _ = match Some(0) {
+        Some(0) => 0,
+        Some(1) => 1,
+        #[cfg(feature = "foo")]
+        Some(2) => 2,
+        _ => 1,
+    };
+}
diff --git a/tests/ui/single_match.rs b/tests/ui/single_match.rs
index bd371888046..dd148edf529 100644
--- a/tests/ui/single_match.rs
+++ b/tests/ui/single_match.rs
@@ -234,4 +234,12 @@ macro_rules! single_match {
 
 fn main() {
     single_match!(5);
+
+    // Don't lint
+    let _ = match Some(0) {
+        #[cfg(feature = "foo")]
+        Some(10) => 11,
+        Some(x) => x,
+        _ => 0,
+    };
 }
-- 
cgit 1.4.1-3-g733a5


From aaeeed6a598c098c222104dd07996ab17d78aa54 Mon Sep 17 00:00:00 2001
From: Rodrigo Mantini <rodrigo.mantini@gmail.com>
Date: Thu, 17 Feb 2022 01:08:53 +0100
Subject: trigger ptr_as_ptr inside macros

---
 clippy_lints/src/casts/mod.rs     |  5 ++++-
 tests/ui/auxiliary/macro_rules.rs |  7 +++++++
 tests/ui/ptr_as_ptr.fixed         | 15 +++++++++++++++
 tests/ui/ptr_as_ptr.rs            | 15 +++++++++++++++
 tests/ui/ptr_as_ptr.stderr        | 27 +++++++++++++++++++--------
 5 files changed, 60 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index aee1e50b94a..51d47b35454 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -419,6 +419,10 @@ impl_lint_pass!(Casts => [
 
 impl<'tcx> LateLintPass<'tcx> for Casts {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        if !in_external_macro(cx.sess(), expr.span) {
+            ptr_as_ptr::check(cx, expr, &self.msrv);
+        }
+
         if expr.span.from_expansion() {
             return;
         }
@@ -455,7 +459,6 @@ impl<'tcx> LateLintPass<'tcx> for Casts {
         cast_ref_to_mut::check(cx, expr);
         cast_ptr_alignment::check(cx, expr);
         char_lit_as_u8::check(cx, expr);
-        ptr_as_ptr::check(cx, expr, &self.msrv);
     }
 
     extract_msrv_attr!(LateContext);
diff --git a/tests/ui/auxiliary/macro_rules.rs b/tests/ui/auxiliary/macro_rules.rs
index 0251fada9e8..9f283337c7e 100644
--- a/tests/ui/auxiliary/macro_rules.rs
+++ b/tests/ui/auxiliary/macro_rules.rs
@@ -120,3 +120,10 @@ macro_rules! mut_mut {
         let mut_mut_ty: &mut &mut u32 = &mut &mut 1u32;
     };
 }
+
+#[macro_export]
+macro_rules! ptr_as_ptr_cast {
+    ($ptr: ident) => {
+        $ptr as *const i32
+    };
+}
diff --git a/tests/ui/ptr_as_ptr.fixed b/tests/ui/ptr_as_ptr.fixed
index 8346a9454f4..bea6be66a8e 100644
--- a/tests/ui/ptr_as_ptr.fixed
+++ b/tests/ui/ptr_as_ptr.fixed
@@ -1,8 +1,17 @@
 // run-rustfix
+// aux-build:macro_rules.rs
 
 #![warn(clippy::ptr_as_ptr)]
 #![feature(custom_inner_attributes)]
 
+extern crate macro_rules;
+
+macro_rules! cast_it {
+    ($ptr: ident) => {
+        $ptr.cast::<i32>()
+    };
+}
+
 fn main() {
     let ptr: *const u32 = &42_u32;
     let mut_ptr: *mut u32 = &mut 42_u32;
@@ -28,6 +37,12 @@ fn main() {
     // Ensure the lint doesn't produce unnecessary turbofish for inferred types.
     let _: *const i32 = ptr.cast();
     let _: *mut i32 = mut_ptr.cast();
+
+    // Make sure the lint is triggered inside a macro
+    let _ = cast_it!(ptr);
+
+    // Do not lint inside macros from external crates
+    let _ = macro_rules::ptr_as_ptr_cast!(ptr);
 }
 
 fn _msrv_1_37() {
diff --git a/tests/ui/ptr_as_ptr.rs b/tests/ui/ptr_as_ptr.rs
index b68d4bc0aac..ca2616b0069 100644
--- a/tests/ui/ptr_as_ptr.rs
+++ b/tests/ui/ptr_as_ptr.rs
@@ -1,8 +1,17 @@
 // run-rustfix
+// aux-build:macro_rules.rs
 
 #![warn(clippy::ptr_as_ptr)]
 #![feature(custom_inner_attributes)]
 
+extern crate macro_rules;
+
+macro_rules! cast_it {
+    ($ptr: ident) => {
+        $ptr as *const i32
+    };
+}
+
 fn main() {
     let ptr: *const u32 = &42_u32;
     let mut_ptr: *mut u32 = &mut 42_u32;
@@ -28,6 +37,12 @@ fn main() {
     // Ensure the lint doesn't produce unnecessary turbofish for inferred types.
     let _: *const i32 = ptr as *const _;
     let _: *mut i32 = mut_ptr as _;
+
+    // Make sure the lint is triggered inside a macro
+    let _ = cast_it!(ptr);
+
+    // Do not lint inside macros from external crates
+    let _ = macro_rules::ptr_as_ptr_cast!(ptr);
 }
 
 fn _msrv_1_37() {
diff --git a/tests/ui/ptr_as_ptr.stderr b/tests/ui/ptr_as_ptr.stderr
index 854906dc111..c58c55cfd83 100644
--- a/tests/ui/ptr_as_ptr.stderr
+++ b/tests/ui/ptr_as_ptr.stderr
@@ -1,5 +1,5 @@
 error: `as` casting between raw pointers without changing its mutability
-  --> $DIR/ptr_as_ptr.rs:10:13
+  --> $DIR/ptr_as_ptr.rs:19:13
    |
 LL |     let _ = ptr as *const i32;
    |             ^^^^^^^^^^^^^^^^^ help: try `pointer::cast`, a safer alternative: `ptr.cast::<i32>()`
@@ -7,40 +7,51 @@ LL |     let _ = ptr as *const i32;
    = note: `-D clippy::ptr-as-ptr` implied by `-D warnings`
 
 error: `as` casting between raw pointers without changing its mutability
-  --> $DIR/ptr_as_ptr.rs:11:13
+  --> $DIR/ptr_as_ptr.rs:20:13
    |
 LL |     let _ = mut_ptr as *mut i32;
    |             ^^^^^^^^^^^^^^^^^^^ help: try `pointer::cast`, a safer alternative: `mut_ptr.cast::<i32>()`
 
 error: `as` casting between raw pointers without changing its mutability
-  --> $DIR/ptr_as_ptr.rs:16:17
+  --> $DIR/ptr_as_ptr.rs:25:17
    |
 LL |         let _ = *ptr_ptr as *const i32;
    |                 ^^^^^^^^^^^^^^^^^^^^^^ help: try `pointer::cast`, a safer alternative: `(*ptr_ptr).cast::<i32>()`
 
 error: `as` casting between raw pointers without changing its mutability
-  --> $DIR/ptr_as_ptr.rs:29:25
+  --> $DIR/ptr_as_ptr.rs:38:25
    |
 LL |     let _: *const i32 = ptr as *const _;
    |                         ^^^^^^^^^^^^^^^ help: try `pointer::cast`, a safer alternative: `ptr.cast()`
 
 error: `as` casting between raw pointers without changing its mutability
-  --> $DIR/ptr_as_ptr.rs:30:23
+  --> $DIR/ptr_as_ptr.rs:39:23
    |
 LL |     let _: *mut i32 = mut_ptr as _;
    |                       ^^^^^^^^^^^^ help: try `pointer::cast`, a safer alternative: `mut_ptr.cast()`
 
 error: `as` casting between raw pointers without changing its mutability
-  --> $DIR/ptr_as_ptr.rs:48:13
+  --> $DIR/ptr_as_ptr.rs:11:9
+   |
+LL |         $ptr as *const i32
+   |         ^^^^^^^^^^^^^^^^^^ help: try `pointer::cast`, a safer alternative: `$ptr.cast::<i32>()`
+...
+LL |     let _ = cast_it!(ptr);
+   |             ------------- in this macro invocation
+   |
+   = note: this error originates in the macro `cast_it` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: `as` casting between raw pointers without changing its mutability
+  --> $DIR/ptr_as_ptr.rs:63:13
    |
 LL |     let _ = ptr as *const i32;
    |             ^^^^^^^^^^^^^^^^^ help: try `pointer::cast`, a safer alternative: `ptr.cast::<i32>()`
 
 error: `as` casting between raw pointers without changing its mutability
-  --> $DIR/ptr_as_ptr.rs:49:13
+  --> $DIR/ptr_as_ptr.rs:64:13
    |
 LL |     let _ = mut_ptr as *mut i32;
    |             ^^^^^^^^^^^^^^^^^^^ help: try `pointer::cast`, a safer alternative: `mut_ptr.cast::<i32>()`
 
-error: aborting due to 7 previous errors
+error: aborting due to 8 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 8912d659cdc9e1fd787136fe1b52a285f2fc2106 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Thu, 17 Feb 2022 14:16:21 -0500
Subject: Remove hack testing for `cfg` attribute in `match_single_binding`

---
 clippy_lints/src/matches/match_single_binding.rs | 19 +------------------
 tests/ui/match_single_binding.fixed              |  8 +++-----
 tests/ui/match_single_binding.rs                 |  3 ++-
 tests/ui/match_single_binding.stderr             | 11 ++++++++++-
 4 files changed, 16 insertions(+), 25 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/match_single_binding.rs b/clippy_lints/src/matches/match_single_binding.rs
index 8ae19e03f1a..39fe54648fb 100644
--- a/clippy_lints/src/matches/match_single_binding.rs
+++ b/clippy_lints/src/matches/match_single_binding.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::source::{indent_of, snippet_block, snippet_opt, snippet_with_applicability};
+use clippy_utils::source::{indent_of, snippet_block, snippet_with_applicability};
 use clippy_utils::sugg::Sugg;
 use clippy_utils::{get_parent_expr, is_refutable, peel_blocks};
 use rustc_errors::Applicability;
@@ -14,23 +14,6 @@ pub(crate) fn check<'a>(cx: &LateContext<'a>, ex: &Expr<'a>, arms: &[Arm<'_>], e
         return;
     }
 
-    // HACK:
-    // This is a hack to deal with arms that are excluded by macros like `#[cfg]`. It is only used here
-    // to prevent false positives as there is currently no better way to detect if code was excluded by
-    // a macro. See PR #6435
-    if_chain! {
-        if let Some(match_snippet) = snippet_opt(cx, expr.span);
-        if let Some(arm_snippet) = snippet_opt(cx, arms[0].span);
-        if let Some(ex_snippet) = snippet_opt(cx, ex.span);
-        let rest_snippet = match_snippet.replace(&arm_snippet, "").replace(&ex_snippet, "");
-        if rest_snippet.contains("=>");
-        then {
-            // The code it self contains another thick arrow "=>"
-            // -> Either another arm or a comment
-            return;
-        }
-    }
-
     let matched_vars = ex.span;
     let bind_names = arms[0].pat.span;
     let match_body = peel_blocks(arms[0].body);
diff --git a/tests/ui/match_single_binding.fixed b/tests/ui/match_single_binding.fixed
index b4ec525ada0..b8dc8179f7d 100644
--- a/tests/ui/match_single_binding.fixed
+++ b/tests/ui/match_single_binding.fixed
@@ -106,10 +106,8 @@ fn main() {
         0 => println!("Array index start"),
         _ => println!("Not an array index start"),
     }
-    // False negative
+
+    // Lint
     let x = 1;
-    match x {
-        // =>
-        _ => println!("Not an array index start"),
-    }
+    println!("Not an array index start");
 }
diff --git a/tests/ui/match_single_binding.rs b/tests/ui/match_single_binding.rs
index e04c4018b98..fe63dcd63f2 100644
--- a/tests/ui/match_single_binding.rs
+++ b/tests/ui/match_single_binding.rs
@@ -118,7 +118,8 @@ fn main() {
         0 => println!("Array index start"),
         _ => println!("Not an array index start"),
     }
-    // False negative
+
+    // Lint
     let x = 1;
     match x {
         // =>
diff --git a/tests/ui/match_single_binding.stderr b/tests/ui/match_single_binding.stderr
index 291fa77dc2e..d939291f53c 100644
--- a/tests/ui/match_single_binding.stderr
+++ b/tests/ui/match_single_binding.stderr
@@ -167,5 +167,14 @@ LL +             unwrapped
 LL ~         })
    |
 
-error: aborting due to 11 previous errors
+error: this match could be replaced by its body itself
+  --> $DIR/match_single_binding.rs:124:5
+   |
+LL | /     match x {
+LL | |         // =>
+LL | |         _ => println!("Not an array index start"),
+LL | |     }
+   | |_____^ help: consider using the match body instead: `println!("Not an array index start");`
+
+error: aborting due to 12 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 8a466454ab280f0dd405b713c1a3610de234d9ce Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Mon, 31 Jan 2022 15:45:49 -0500
Subject: Lint enum-to-int casts with `cast_possible_truncation`

---
 clippy_lints/src/casts/cast_possible_truncation.rs |  47 +++++++--
 clippy_lints/src/casts/mod.rs                      |   3 +-
 clippy_lints/src/casts/utils.rs                    |  58 ++++++++++-
 tests/ui/cast.rs                                   | 115 +++++++++++++++++++++
 tests/ui/cast.stderr                               |  74 ++++++++-----
 5 files changed, 258 insertions(+), 39 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/cast_possible_truncation.rs b/clippy_lints/src/casts/cast_possible_truncation.rs
index ea74d5acbda..2384e4a3748 100644
--- a/clippy_lints/src/casts/cast_possible_truncation.rs
+++ b/clippy_lints/src/casts/cast_possible_truncation.rs
@@ -2,6 +2,7 @@ use clippy_utils::consts::{constant, Constant};
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::expr_or_init;
 use clippy_utils::ty::is_isize_or_usize;
+use rustc_hir::def::{DefKind, Res};
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::LateContext;
 use rustc_middle::ty::{self, FloatTy, Ty};
@@ -75,8 +76,8 @@ fn apply_reductions(cx: &LateContext<'_>, nbits: u64, expr: &Expr<'_>, signed: b
 }
 
 pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_expr: &Expr<'_>, cast_from: Ty<'_>, cast_to: Ty<'_>) {
-    let msg = match (cast_from.is_integral(), cast_to.is_integral()) {
-        (true, true) => {
+    let msg = match (cast_from.kind(), cast_to.is_integral()) {
+        (ty::Int(_) | ty::Uint(_), true) => {
             let from_nbits = apply_reductions(
                 cx,
                 utils::int_ty_to_nbits(cast_from, cx.tcx),
@@ -108,19 +109,43 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_expr: &Expr<'_>,
             )
         },
 
-        (false, true) => {
-            format!("casting `{}` to `{}` may truncate the value", cast_from, cast_to)
-        },
-
-        (_, _) => {
-            if matches!(cast_from.kind(), &ty::Float(FloatTy::F64))
-                && matches!(cast_to.kind(), &ty::Float(FloatTy::F32))
+        (ty::Adt(def, _), true) if def.is_enum() => {
+            if let ExprKind::Path(p) = &cast_expr.kind
+                && let Res::Def(DefKind::Ctor(..), _) = cx.qpath_res(p, cast_expr.hir_id)
             {
-                "casting `f64` to `f32` may truncate the value".to_string()
+                return
+            }
+
+            let from_nbits = utils::enum_ty_to_nbits(def, cx.tcx);
+            let to_nbits = utils::int_ty_to_nbits(cast_to, cx.tcx);
+
+            let suffix = if is_isize_or_usize(cast_to) {
+                if from_nbits > 32 {
+                    " on targets with 32-bit wide pointers"
+                } else {
+                    return;
+                }
+            } else if to_nbits < from_nbits {
+                ""
             } else {
                 return;
-            }
+            };
+
+            format!(
+                "casting `{}` to `{}` may truncate the value{}",
+                cast_from, cast_to, suffix,
+            )
+        },
+
+        (ty::Float(_), true) => {
+            format!("casting `{}` to `{}` may truncate the value", cast_from, cast_to)
         },
+
+        (ty::Float(FloatTy::F64), false) if matches!(cast_to.kind(), &ty::Float(FloatTy::F32)) => {
+            "casting `f64` to `f32` may truncate the value".to_string()
+        },
+
+        _ => return,
     };
 
     span_lint(cx, CAST_POSSIBLE_TRUNCATION, expr.span, &msg);
diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index 51d47b35454..b8c9f7db994 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -445,13 +445,12 @@ impl<'tcx> LateLintPass<'tcx> for Casts {
             fn_to_numeric_cast_with_truncation::check(cx, expr, cast_expr, cast_from, cast_to);
 
             if cast_to.is_numeric() && !in_external_macro(cx.sess(), expr.span) {
+                cast_possible_truncation::check(cx, expr, cast_expr, cast_from, cast_to);
                 if cast_from.is_numeric() {
-                    cast_possible_truncation::check(cx, expr, cast_expr, cast_from, cast_to);
                     cast_possible_wrap::check(cx, expr, cast_from, cast_to);
                     cast_precision_loss::check(cx, expr, cast_from, cast_to);
                     cast_sign_loss::check(cx, expr, cast_expr, cast_from, cast_to);
                 }
-
                 cast_lossless::check(cx, expr, cast_expr, cast_from, cast_to, &self.msrv);
             }
         }
diff --git a/clippy_lints/src/casts/utils.rs b/clippy_lints/src/casts/utils.rs
index 00fd0b3473b..d41e745d733 100644
--- a/clippy_lints/src/casts/utils.rs
+++ b/clippy_lints/src/casts/utils.rs
@@ -1,4 +1,6 @@
-use rustc_middle::ty::{self, IntTy, Ty, TyCtxt, UintTy};
+use rustc_middle::mir::interpret::{ConstValue, Scalar};
+use rustc_middle::ty::{self, AdtDef, IntTy, Ty, TyCtxt, UintTy, VariantDiscr};
+use rustc_target::abi::Size;
 
 /// Returns the size in bits of an integral type.
 /// Will return 0 if the type is not an int or uint variant
@@ -23,3 +25,57 @@ pub(super) fn int_ty_to_nbits(typ: Ty<'_>, tcx: TyCtxt<'_>) -> u64 {
         _ => 0,
     }
 }
+
+pub(super) fn enum_ty_to_nbits(adt: &AdtDef, tcx: TyCtxt<'_>) -> u64 {
+    let mut explicit = 0i128;
+    let (start, end) = adt
+        .variants
+        .iter()
+        .fold((i128::MAX, i128::MIN), |(start, end), variant| match variant.discr {
+            VariantDiscr::Relative(x) => match explicit.checked_add(i128::from(x)) {
+                Some(x) => (start, end.max(x)),
+                None => (i128::MIN, end),
+            },
+            VariantDiscr::Explicit(id) => {
+                let ty = tcx.type_of(id);
+                if let Ok(ConstValue::Scalar(Scalar::Int(value))) = tcx.const_eval_poly(id) {
+                    #[allow(clippy::cast_possible_truncation, clippy::cast_possible_wrap)]
+                    let value = match (value.size().bytes(), ty.kind()) {
+                        (1, ty::Int(_)) => i128::from(value.assert_bits(Size::from_bytes(1)) as u8 as i8),
+                        (1, ty::Uint(_)) => i128::from(value.assert_bits(Size::from_bytes(1)) as u8),
+                        (2, ty::Int(_)) => i128::from(value.assert_bits(Size::from_bytes(2)) as u16 as i16),
+                        (2, ty::Uint(_)) => i128::from(value.assert_bits(Size::from_bytes(2)) as u16),
+                        (4, ty::Int(_)) => i128::from(value.assert_bits(Size::from_bytes(4)) as u32 as i32),
+                        (4, ty::Uint(_)) => i128::from(value.assert_bits(Size::from_bytes(4)) as u32),
+                        (8, ty::Int(_)) => i128::from(value.assert_bits(Size::from_bytes(8)) as u64 as i64),
+                        (8, ty::Uint(_)) => i128::from(value.assert_bits(Size::from_bytes(8)) as u64),
+                        (16, ty::Int(_)) => value.assert_bits(Size::from_bytes(16)) as i128,
+                        (16, ty::Uint(_)) => match i128::try_from(value.assert_bits(Size::from_bytes(16))) {
+                            Ok(x) => x,
+                            // Requires 128 bits
+                            Err(_) => return (i128::MIN, end),
+                        },
+                        // Shouldn't happen if compilation was successful
+                        _ => return (start, end),
+                    };
+                    explicit = value;
+                    (start.min(value), end.max(value))
+                } else {
+                    // Shouldn't happen if compilation was successful
+                    (start, end)
+                }
+            },
+        });
+
+    if start >= end {
+        0
+    } else {
+        let neg_bits = if start < 0 {
+            128 - (-(start + 1)).leading_zeros() + 1
+        } else {
+            0
+        };
+        let pos_bits = if end > 0 { 128 - end.leading_zeros() } else { 0 };
+        neg_bits.max(pos_bits).into()
+    }
+}
diff --git a/tests/ui/cast.rs b/tests/ui/cast.rs
index ebc1ed5587f..371bf292f74 100644
--- a/tests/ui/cast.rs
+++ b/tests/ui/cast.rs
@@ -1,3 +1,6 @@
+#![feature(repr128)]
+#![allow(incomplete_features)]
+
 #[warn(
     clippy::cast_precision_loss,
     clippy::cast_possible_truncation,
@@ -115,4 +118,116 @@ fn main() {
     }) as u8;
     999999u64.clamp(0, 255) as u8;
     999999u64.clamp(0, 256) as u8; // should still be linted
+
+    #[derive(Clone, Copy)]
+    enum E1 {
+        A,
+        B,
+        C,
+    }
+    impl E1 {
+        fn test(self) {
+            let _ = self as u8; // Don't lint. `0..=2` fits in u8
+        }
+    }
+
+    #[derive(Clone, Copy)]
+    enum E2 {
+        A = 255,
+        B,
+    }
+    impl E2 {
+        fn test(self) {
+            let _ = self as u8;
+            let _ = self as i16; // Don't lint. `255..=256` fits in i16
+        }
+    }
+
+    #[derive(Clone, Copy)]
+    enum E3 {
+        A = -1,
+        B,
+        C = 50,
+    }
+    impl E3 {
+        fn test(self) {
+            let _ = self as i8; // Don't lint. `-1..=50` fits in i8
+        }
+    }
+
+    #[derive(Clone, Copy)]
+    enum E4 {
+        A = -128,
+        B,
+    }
+    impl E4 {
+        fn test(self) {
+            let _ = self as i8; // Don't lint. `-128..=-127` fits in i8
+        }
+    }
+
+    #[derive(Clone, Copy)]
+    enum E5 {
+        A = -129,
+        B = 127,
+    }
+    impl E5 {
+        fn test(self) {
+            let _ = self as i8;
+            let _ = self as i16; // Don't lint. `-129..=127` fits in i16
+        }
+    }
+
+    #[derive(Clone, Copy)]
+    #[repr(u32)]
+    enum E6 {
+        A = u16::MAX as u32,
+        B,
+    }
+    impl E6 {
+        fn test(self) {
+            let _ = self as i16;
+            let _ = Self::A as u16; // Don't lint. `2^16-1` fits in u16
+            let _ = self as u32; // Don't lint. `2^16-1..=2^16` fits in u32
+        }
+    }
+
+    #[derive(Clone, Copy)]
+    #[repr(u64)]
+    enum E7 {
+        A = u32::MAX as u64,
+        B,
+    }
+    impl E7 {
+        fn test(self) {
+            let _ = self as usize;
+            let _ = self as u64; // Don't lint. `2^32-1..=2^32` fits in u64
+        }
+    }
+
+    #[derive(Clone, Copy)]
+    #[repr(i128)]
+    enum E8 {
+        A = i128::MIN,
+        B,
+        C = 0,
+        D = i128::MAX,
+    }
+    impl E8 {
+        fn test(self) {
+            let _ = self as i128; // Don't lint. `-(2^127)..=2^127-1` fits it i128
+        }
+    }
+
+    #[derive(Clone, Copy)]
+    #[repr(u128)]
+    enum E9 {
+        A,
+        B = u128::MAX,
+    }
+    impl E9 {
+        fn test(self) {
+            let _ = self as u128; // Don't lint. `0..=2^128-1` fits in u128
+        }
+    }
 }
diff --git a/tests/ui/cast.stderr b/tests/ui/cast.stderr
index edf8790cf33..0fc66f73981 100644
--- a/tests/ui/cast.stderr
+++ b/tests/ui/cast.stderr
@@ -1,5 +1,5 @@
 error: casting `i32` to `f32` causes a loss of precision (`i32` is 32 bits wide, but `f32`'s mantissa is only 23 bits wide)
-  --> $DIR/cast.rs:11:5
+  --> $DIR/cast.rs:14:5
    |
 LL |     x0 as f32;
    |     ^^^^^^^^^
@@ -7,37 +7,37 @@ LL |     x0 as f32;
    = note: `-D clippy::cast-precision-loss` implied by `-D warnings`
 
 error: casting `i64` to `f32` causes a loss of precision (`i64` is 64 bits wide, but `f32`'s mantissa is only 23 bits wide)
-  --> $DIR/cast.rs:13:5
+  --> $DIR/cast.rs:16:5
    |
 LL |     x1 as f32;
    |     ^^^^^^^^^
 
 error: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
-  --> $DIR/cast.rs:14:5
+  --> $DIR/cast.rs:17:5
    |
 LL |     x1 as f64;
    |     ^^^^^^^^^
 
 error: casting `u32` to `f32` causes a loss of precision (`u32` is 32 bits wide, but `f32`'s mantissa is only 23 bits wide)
-  --> $DIR/cast.rs:16:5
+  --> $DIR/cast.rs:19:5
    |
 LL |     x2 as f32;
    |     ^^^^^^^^^
 
 error: casting `u64` to `f32` causes a loss of precision (`u64` is 64 bits wide, but `f32`'s mantissa is only 23 bits wide)
-  --> $DIR/cast.rs:18:5
+  --> $DIR/cast.rs:21:5
    |
 LL |     x3 as f32;
    |     ^^^^^^^^^
 
 error: casting `u64` to `f64` causes a loss of precision (`u64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
-  --> $DIR/cast.rs:19:5
+  --> $DIR/cast.rs:22:5
    |
 LL |     x3 as f64;
    |     ^^^^^^^^^
 
 error: casting `f32` to `i32` may truncate the value
-  --> $DIR/cast.rs:21:5
+  --> $DIR/cast.rs:24:5
    |
 LL |     1f32 as i32;
    |     ^^^^^^^^^^^
@@ -45,13 +45,13 @@ LL |     1f32 as i32;
    = note: `-D clippy::cast-possible-truncation` implied by `-D warnings`
 
 error: casting `f32` to `u32` may truncate the value
-  --> $DIR/cast.rs:22:5
+  --> $DIR/cast.rs:25:5
    |
 LL |     1f32 as u32;
    |     ^^^^^^^^^^^
 
 error: casting `f32` to `u32` may lose the sign of the value
-  --> $DIR/cast.rs:22:5
+  --> $DIR/cast.rs:25:5
    |
 LL |     1f32 as u32;
    |     ^^^^^^^^^^^
@@ -59,43 +59,43 @@ LL |     1f32 as u32;
    = note: `-D clippy::cast-sign-loss` implied by `-D warnings`
 
 error: casting `f64` to `f32` may truncate the value
-  --> $DIR/cast.rs:23:5
+  --> $DIR/cast.rs:26:5
    |
 LL |     1f64 as f32;
    |     ^^^^^^^^^^^
 
 error: casting `i32` to `i8` may truncate the value
-  --> $DIR/cast.rs:24:5
+  --> $DIR/cast.rs:27:5
    |
 LL |     1i32 as i8;
    |     ^^^^^^^^^^
 
 error: casting `i32` to `u8` may truncate the value
-  --> $DIR/cast.rs:25:5
+  --> $DIR/cast.rs:28:5
    |
 LL |     1i32 as u8;
    |     ^^^^^^^^^^
 
 error: casting `f64` to `isize` may truncate the value
-  --> $DIR/cast.rs:26:5
+  --> $DIR/cast.rs:29:5
    |
 LL |     1f64 as isize;
    |     ^^^^^^^^^^^^^
 
 error: casting `f64` to `usize` may truncate the value
-  --> $DIR/cast.rs:27:5
+  --> $DIR/cast.rs:30:5
    |
 LL |     1f64 as usize;
    |     ^^^^^^^^^^^^^
 
 error: casting `f64` to `usize` may lose the sign of the value
-  --> $DIR/cast.rs:27:5
+  --> $DIR/cast.rs:30:5
    |
 LL |     1f64 as usize;
    |     ^^^^^^^^^^^^^
 
 error: casting `u8` to `i8` may wrap around the value
-  --> $DIR/cast.rs:29:5
+  --> $DIR/cast.rs:32:5
    |
 LL |     1u8 as i8;
    |     ^^^^^^^^^
@@ -103,52 +103,76 @@ LL |     1u8 as i8;
    = note: `-D clippy::cast-possible-wrap` implied by `-D warnings`
 
 error: casting `u16` to `i16` may wrap around the value
-  --> $DIR/cast.rs:30:5
+  --> $DIR/cast.rs:33:5
    |
 LL |     1u16 as i16;
    |     ^^^^^^^^^^^
 
 error: casting `u32` to `i32` may wrap around the value
-  --> $DIR/cast.rs:31:5
+  --> $DIR/cast.rs:34:5
    |
 LL |     1u32 as i32;
    |     ^^^^^^^^^^^
 
 error: casting `u64` to `i64` may wrap around the value
-  --> $DIR/cast.rs:32:5
+  --> $DIR/cast.rs:35:5
    |
 LL |     1u64 as i64;
    |     ^^^^^^^^^^^
 
 error: casting `usize` to `isize` may wrap around the value
-  --> $DIR/cast.rs:33:5
+  --> $DIR/cast.rs:36:5
    |
 LL |     1usize as isize;
    |     ^^^^^^^^^^^^^^^
 
 error: casting `i32` to `u32` may lose the sign of the value
-  --> $DIR/cast.rs:36:5
+  --> $DIR/cast.rs:39:5
    |
 LL |     -1i32 as u32;
    |     ^^^^^^^^^^^^
 
 error: casting `isize` to `usize` may lose the sign of the value
-  --> $DIR/cast.rs:38:5
+  --> $DIR/cast.rs:41:5
    |
 LL |     -1isize as usize;
    |     ^^^^^^^^^^^^^^^^
 
 error: casting `i64` to `i8` may truncate the value
-  --> $DIR/cast.rs:105:5
+  --> $DIR/cast.rs:108:5
    |
 LL |     (-99999999999i64).min(1) as i8; // should be linted because signed
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: casting `u64` to `u8` may truncate the value
-  --> $DIR/cast.rs:117:5
+  --> $DIR/cast.rs:120:5
    |
 LL |     999999u64.clamp(0, 256) as u8; // should still be linted
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 24 previous errors
+error: casting `main::E2` to `u8` may truncate the value
+  --> $DIR/cast.rs:141:21
+   |
+LL |             let _ = self as u8;
+   |                     ^^^^^^^^^^
+
+error: casting `main::E5` to `i8` may truncate the value
+  --> $DIR/cast.rs:176:21
+   |
+LL |             let _ = self as i8;
+   |                     ^^^^^^^^^^
+
+error: casting `main::E6` to `i16` may truncate the value
+  --> $DIR/cast.rs:189:21
+   |
+LL |             let _ = self as i16;
+   |                     ^^^^^^^^^^^
+
+error: casting `main::E7` to `usize` may truncate the value on targets with 32-bit wide pointers
+  --> $DIR/cast.rs:203:21
+   |
+LL |             let _ = self as usize;
+   |                     ^^^^^^^^^^^^^
+
+error: aborting due to 28 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 90bb7a34764b460681dca1efb333ff378478dbd8 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Mon, 31 Jan 2022 21:22:47 -0500
Subject: New lint `cast_enum_truncation`

---
 CHANGELOG.md                                       |  1 +
 clippy_lints/src/casts/cast_possible_truncation.rs | 65 +++++++++++----
 clippy_lints/src/casts/mod.rs                      | 20 +++++
 clippy_lints/src/casts/utils.rs                    | 96 +++++++++++++++-------
 clippy_lints/src/lib.register_all.rs               |  1 +
 clippy_lints/src/lib.register_lints.rs             |  1 +
 clippy_lints/src/lib.register_suspicious.rs        |  1 +
 clippy_lints/src/lib.rs                            |  1 +
 tests/ui/cast.rs                                   | 21 +++++
 tests/ui/cast.stderr                               | 28 ++++++-
 10 files changed, 183 insertions(+), 52 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index f41dcce0e00..1b52a6fcd05 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3068,6 +3068,7 @@ Released 2018-09-13
 [`bytes_nth`]: https://rust-lang.github.io/rust-clippy/master/index.html#bytes_nth
 [`cargo_common_metadata`]: https://rust-lang.github.io/rust-clippy/master/index.html#cargo_common_metadata
 [`case_sensitive_file_extension_comparisons`]: https://rust-lang.github.io/rust-clippy/master/index.html#case_sensitive_file_extension_comparisons
+[`cast_enum_truncation`]: https://rust-lang.github.io/rust-clippy/master/index.html#cast_enum_truncation
 [`cast_lossless`]: https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
 [`cast_possible_truncation`]: https://rust-lang.github.io/rust-clippy/master/index.html#cast_possible_truncation
 [`cast_possible_wrap`]: https://rust-lang.github.io/rust-clippy/master/index.html#cast_possible_wrap
diff --git a/clippy_lints/src/casts/cast_possible_truncation.rs b/clippy_lints/src/casts/cast_possible_truncation.rs
index 2384e4a3748..6c938062c19 100644
--- a/clippy_lints/src/casts/cast_possible_truncation.rs
+++ b/clippy_lints/src/casts/cast_possible_truncation.rs
@@ -2,12 +2,14 @@ use clippy_utils::consts::{constant, Constant};
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::expr_or_init;
 use clippy_utils::ty::is_isize_or_usize;
+use rustc_ast::ast;
+use rustc_attr::IntType;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::LateContext;
-use rustc_middle::ty::{self, FloatTy, Ty};
+use rustc_middle::ty::{self, FloatTy, Ty, VariantDiscr};
 
-use super::{utils, CAST_POSSIBLE_TRUNCATION};
+use super::{utils, CAST_ENUM_TRUNCATION, CAST_POSSIBLE_TRUNCATION};
 
 fn constant_int(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<u128> {
     if let Some((Constant::Int(c), _)) = constant(cx, cx.typeck_results(), expr) {
@@ -110,27 +112,54 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_expr: &Expr<'_>,
         },
 
         (ty::Adt(def, _), true) if def.is_enum() => {
-            if let ExprKind::Path(p) = &cast_expr.kind
-                && let Res::Def(DefKind::Ctor(..), _) = cx.qpath_res(p, cast_expr.hir_id)
+            let (from_nbits, variant) = if let ExprKind::Path(p) = &cast_expr.kind
+                && let Res::Def(DefKind::Ctor(..), id) = cx.qpath_res(p, cast_expr.hir_id)
             {
-                return
-            }
-
-            let from_nbits = utils::enum_ty_to_nbits(def, cx.tcx);
+                let i = def.variant_index_with_ctor_id(id);
+                let variant = &def.variants[i];
+                let nbits: u64 = match variant.discr {
+                    VariantDiscr::Explicit(id) => utils::read_explicit_enum_value(cx.tcx, id).unwrap().nbits(),
+                    VariantDiscr::Relative(x) => {
+                        match def.variants[(i.as_usize() - x as usize).into()].discr {
+                            VariantDiscr::Explicit(id) => {
+                                utils::read_explicit_enum_value(cx.tcx, id).unwrap().add(x).nbits()
+                            }
+                            VariantDiscr::Relative(_) => (32 - x.leading_zeros()).into(),
+                        }
+                    }
+                };
+                (nbits, Some(variant))
+            } else {
+                (utils::enum_ty_to_nbits(def, cx.tcx), None)
+            };
             let to_nbits = utils::int_ty_to_nbits(cast_to, cx.tcx);
 
-            let suffix = if is_isize_or_usize(cast_to) {
-                if from_nbits > 32 {
-                    " on targets with 32-bit wide pointers"
-                } else {
-                    return;
-                }
-            } else if to_nbits < from_nbits {
-                ""
-            } else {
-                return;
+            let cast_from_ptr_size = def.repr.int.map_or(true, |ty| {
+                matches!(
+                    ty,
+                    IntType::SignedInt(ast::IntTy::Isize) | IntType::UnsignedInt(ast::UintTy::Usize)
+                )
+            });
+            let suffix = match (cast_from_ptr_size, is_isize_or_usize(cast_to)) {
+                (false, false) if from_nbits > to_nbits => "",
+                (true, false) if from_nbits > to_nbits => "",
+                (false, true) if from_nbits > 64 => "",
+                (false, true) if from_nbits > 32 => " on targets with 32-bit wide pointers",
+                _ => return,
             };
 
+            if let Some(variant) = variant {
+                span_lint(
+                    cx,
+                    CAST_ENUM_TRUNCATION,
+                    expr.span,
+                    &format!(
+                        "casting `{}::{}` to `{}` will truncate the value{}",
+                        cast_from, variant.name, cast_to, suffix,
+                    ),
+                );
+                return;
+            }
             format!(
                 "casting `{}` to `{}` may truncate the value{}",
                 cast_from, cast_to, suffix,
diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index b8c9f7db994..f2077c569c0 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -390,6 +390,25 @@ declare_clippy_lint! {
     "casting using `as` from and to raw pointers that doesn't change its mutability, where `pointer::cast` could take the place of `as`"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for casts from an enum type to an integral type which will definitely truncate the
+    /// value.
+    ///
+    /// ### Why is this bad?
+    /// The resulting integral value will not match the value of the variant it came from.
+    ///
+    /// ### Example
+    /// ```rust
+    /// enum E { X = 256 };
+    /// let _ = E::X as u8;
+    /// ```
+    #[clippy::version = "1.60.0"]
+    pub CAST_ENUM_TRUNCATION,
+    suspicious,
+    "casts from an enum type to an integral type which will truncate the value"
+}
+
 pub struct Casts {
     msrv: Option<RustcVersion>,
 }
@@ -415,6 +434,7 @@ impl_lint_pass!(Casts => [
     FN_TO_NUMERIC_CAST_WITH_TRUNCATION,
     CHAR_LIT_AS_U8,
     PTR_AS_PTR,
+    CAST_ENUM_TRUNCATION,
 ]);
 
 impl<'tcx> LateLintPass<'tcx> for Casts {
diff --git a/clippy_lints/src/casts/utils.rs b/clippy_lints/src/casts/utils.rs
index d41e745d733..fab0c194b37 100644
--- a/clippy_lints/src/casts/utils.rs
+++ b/clippy_lints/src/casts/utils.rs
@@ -1,5 +1,6 @@
 use rustc_middle::mir::interpret::{ConstValue, Scalar};
 use rustc_middle::ty::{self, AdtDef, IntTy, Ty, TyCtxt, UintTy, VariantDiscr};
+use rustc_span::def_id::DefId;
 use rustc_target::abi::Size;
 
 /// Returns the size in bits of an integral type.
@@ -26,48 +27,83 @@ pub(super) fn int_ty_to_nbits(typ: Ty<'_>, tcx: TyCtxt<'_>) -> u64 {
     }
 }
 
+pub(super) enum EnumValue {
+    Unsigned(u128),
+    Signed(i128),
+}
+impl EnumValue {
+    pub(super) fn add(self, n: u32) -> Self {
+        match self {
+            Self::Unsigned(x) => Self::Unsigned(x + u128::from(n)),
+            Self::Signed(x) => Self::Signed(x + i128::from(n)),
+        }
+    }
+
+    pub(super) fn nbits(self) -> u64 {
+        match self {
+            Self::Unsigned(x) => 128 - x.leading_zeros(),
+            Self::Signed(x) if x < 0 => 128 - (-(x + 1)).leading_zeros() + 1,
+            Self::Signed(x) => 128 - x.leading_zeros(),
+        }
+        .into()
+    }
+}
+
+#[allow(clippy::cast_possible_truncation, clippy::cast_possible_wrap)]
+pub(super) fn read_explicit_enum_value(tcx: TyCtxt<'_>, id: DefId) -> Option<EnumValue> {
+    if let Ok(ConstValue::Scalar(Scalar::Int(value))) = tcx.const_eval_poly(id) {
+        match tcx.type_of(id).kind() {
+            ty::Int(_) => Some(EnumValue::Signed(match value.size().bytes() {
+                1 => i128::from(value.assert_bits(Size::from_bytes(1)) as u8 as i8),
+                2 => i128::from(value.assert_bits(Size::from_bytes(2)) as u16 as i16),
+                4 => i128::from(value.assert_bits(Size::from_bytes(4)) as u32 as i32),
+                8 => i128::from(value.assert_bits(Size::from_bytes(8)) as u64 as i64),
+                16 => value.assert_bits(Size::from_bytes(16)) as i128,
+                _ => return None,
+            })),
+            ty::Uint(_) => Some(EnumValue::Unsigned(match value.size().bytes() {
+                1 => value.assert_bits(Size::from_bytes(1)),
+                2 => value.assert_bits(Size::from_bytes(2)),
+                4 => value.assert_bits(Size::from_bytes(4)),
+                8 => value.assert_bits(Size::from_bytes(8)),
+                16 => value.assert_bits(Size::from_bytes(16)),
+                _ => return None,
+            })),
+            _ => None,
+        }
+    } else {
+        None
+    }
+}
+
 pub(super) fn enum_ty_to_nbits(adt: &AdtDef, tcx: TyCtxt<'_>) -> u64 {
     let mut explicit = 0i128;
     let (start, end) = adt
         .variants
         .iter()
-        .fold((i128::MAX, i128::MIN), |(start, end), variant| match variant.discr {
+        .fold((0, i128::MIN), |(start, end), variant| match variant.discr {
             VariantDiscr::Relative(x) => match explicit.checked_add(i128::from(x)) {
                 Some(x) => (start, end.max(x)),
                 None => (i128::MIN, end),
             },
-            VariantDiscr::Explicit(id) => {
-                let ty = tcx.type_of(id);
-                if let Ok(ConstValue::Scalar(Scalar::Int(value))) = tcx.const_eval_poly(id) {
-                    #[allow(clippy::cast_possible_truncation, clippy::cast_possible_wrap)]
-                    let value = match (value.size().bytes(), ty.kind()) {
-                        (1, ty::Int(_)) => i128::from(value.assert_bits(Size::from_bytes(1)) as u8 as i8),
-                        (1, ty::Uint(_)) => i128::from(value.assert_bits(Size::from_bytes(1)) as u8),
-                        (2, ty::Int(_)) => i128::from(value.assert_bits(Size::from_bytes(2)) as u16 as i16),
-                        (2, ty::Uint(_)) => i128::from(value.assert_bits(Size::from_bytes(2)) as u16),
-                        (4, ty::Int(_)) => i128::from(value.assert_bits(Size::from_bytes(4)) as u32 as i32),
-                        (4, ty::Uint(_)) => i128::from(value.assert_bits(Size::from_bytes(4)) as u32),
-                        (8, ty::Int(_)) => i128::from(value.assert_bits(Size::from_bytes(8)) as u64 as i64),
-                        (8, ty::Uint(_)) => i128::from(value.assert_bits(Size::from_bytes(8)) as u64),
-                        (16, ty::Int(_)) => value.assert_bits(Size::from_bytes(16)) as i128,
-                        (16, ty::Uint(_)) => match i128::try_from(value.assert_bits(Size::from_bytes(16))) {
-                            Ok(x) => x,
-                            // Requires 128 bits
-                            Err(_) => return (i128::MIN, end),
-                        },
-                        // Shouldn't happen if compilation was successful
-                        _ => return (start, end),
-                    };
-                    explicit = value;
-                    (start.min(value), end.max(value))
-                } else {
-                    // Shouldn't happen if compilation was successful
-                    (start, end)
-                }
+            VariantDiscr::Explicit(id) => match read_explicit_enum_value(tcx, id) {
+                Some(EnumValue::Signed(x)) => {
+                    explicit = x;
+                    (start.min(x), end.max(x))
+                },
+                Some(EnumValue::Unsigned(x)) => match i128::try_from(x) {
+                    Ok(x) => {
+                        explicit = x;
+                        (start, end.max(x))
+                    },
+                    Err(_) => (i128::MIN, end),
+                },
+                None => (start, end),
             },
         });
 
-    if start >= end {
+    if start > end {
+        // No variants.
         0
     } else {
         let neg_bits = if start < 0 {
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index a94f6b528b4..c6f8470cd7d 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -23,6 +23,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(bool_assert_comparison::BOOL_ASSERT_COMPARISON),
     LintId::of(booleans::LOGIC_BUG),
     LintId::of(booleans::NONMINIMAL_BOOL),
+    LintId::of(casts::CAST_ENUM_TRUNCATION),
     LintId::of(casts::CAST_REF_TO_MUT),
     LintId::of(casts::CHAR_LIT_AS_U8),
     LintId::of(casts::FN_TO_NUMERIC_CAST),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index df40ca46314..75ef1b0a9d5 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -67,6 +67,7 @@ store.register_lints(&[
     cargo::REDUNDANT_FEATURE_NAMES,
     cargo::WILDCARD_DEPENDENCIES,
     case_sensitive_file_extension_comparisons::CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS,
+    casts::CAST_ENUM_TRUNCATION,
     casts::CAST_LOSSLESS,
     casts::CAST_POSSIBLE_TRUNCATION,
     casts::CAST_POSSIBLE_WRAP,
diff --git a/clippy_lints/src/lib.register_suspicious.rs b/clippy_lints/src/lib.register_suspicious.rs
index da56f800804..6a8859e19d7 100644
--- a/clippy_lints/src/lib.register_suspicious.rs
+++ b/clippy_lints/src/lib.register_suspicious.rs
@@ -7,6 +7,7 @@ store.register_group(true, "clippy::suspicious", Some("clippy_suspicious"), vec!
     LintId::of(attrs::BLANKET_CLIPPY_RESTRICTION_LINTS),
     LintId::of(await_holding_invalid::AWAIT_HOLDING_LOCK),
     LintId::of(await_holding_invalid::AWAIT_HOLDING_REFCELL_REF),
+    LintId::of(casts::CAST_ENUM_TRUNCATION),
     LintId::of(eval_order_dependence::EVAL_ORDER_DEPENDENCE),
     LintId::of(float_equality_without_abs::FLOAT_EQUALITY_WITHOUT_ABS),
     LintId::of(formatting::SUSPICIOUS_ASSIGNMENT_FORMATTING),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 93b1d178ac2..a21a87899aa 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -25,6 +25,7 @@
 // (Currently there is no way to opt into sysroot crates without `extern crate`.)
 extern crate rustc_ast;
 extern crate rustc_ast_pretty;
+extern crate rustc_attr;
 extern crate rustc_data_structures;
 extern crate rustc_driver;
 extern crate rustc_errors;
diff --git a/tests/ui/cast.rs b/tests/ui/cast.rs
index 371bf292f74..2e31ad3172e 100644
--- a/tests/ui/cast.rs
+++ b/tests/ui/cast.rs
@@ -139,7 +139,9 @@ fn main() {
     impl E2 {
         fn test(self) {
             let _ = self as u8;
+            let _ = Self::B as u8;
             let _ = self as i16; // Don't lint. `255..=256` fits in i16
+            let _ = Self::A as u8; // Don't lint.
         }
     }
 
@@ -174,7 +176,9 @@ fn main() {
     impl E5 {
         fn test(self) {
             let _ = self as i8;
+            let _ = Self::A as i8;
             let _ = self as i16; // Don't lint. `-129..=127` fits in i16
+            let _ = Self::B as u8; // Don't lint.
         }
     }
 
@@ -189,6 +193,7 @@ fn main() {
             let _ = self as i16;
             let _ = Self::A as u16; // Don't lint. `2^16-1` fits in u16
             let _ = self as u32; // Don't lint. `2^16-1..=2^16` fits in u32
+            let _ = Self::A as u16; // Don't lint.
         }
     }
 
@@ -201,6 +206,7 @@ fn main() {
     impl E7 {
         fn test(self) {
             let _ = self as usize;
+            let _ = Self::A as usize; // Don't lint.
             let _ = self as u64; // Don't lint. `2^32-1..=2^32` fits in u64
         }
     }
@@ -227,7 +233,22 @@ fn main() {
     }
     impl E9 {
         fn test(self) {
+            let _ = Self::A as u8; // Don't lint.
             let _ = self as u128; // Don't lint. `0..=2^128-1` fits in u128
         }
     }
+
+    #[derive(Clone, Copy)]
+    #[repr(usize)]
+    enum E10 {
+        A,
+        B = u32::MAX as usize,
+    }
+    impl E10 {
+        fn test(self) {
+            let _ = self as u16;
+            let _ = Self::B as u32; // Don't lint.
+            let _ = self as u64; // Don't lint.
+        }
+    }
 }
diff --git a/tests/ui/cast.stderr b/tests/ui/cast.stderr
index 0fc66f73981..7a68c0984f1 100644
--- a/tests/ui/cast.stderr
+++ b/tests/ui/cast.stderr
@@ -156,23 +156,43 @@ error: casting `main::E2` to `u8` may truncate the value
 LL |             let _ = self as u8;
    |                     ^^^^^^^^^^
 
+error: casting `main::E2::B` to `u8` will truncate the value
+  --> $DIR/cast.rs:142:21
+   |
+LL |             let _ = Self::B as u8;
+   |                     ^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::cast-enum-truncation` implied by `-D warnings`
+
 error: casting `main::E5` to `i8` may truncate the value
-  --> $DIR/cast.rs:176:21
+  --> $DIR/cast.rs:178:21
    |
 LL |             let _ = self as i8;
    |                     ^^^^^^^^^^
 
+error: casting `main::E5::A` to `i8` will truncate the value
+  --> $DIR/cast.rs:179:21
+   |
+LL |             let _ = Self::A as i8;
+   |                     ^^^^^^^^^^^^^
+
 error: casting `main::E6` to `i16` may truncate the value
-  --> $DIR/cast.rs:189:21
+  --> $DIR/cast.rs:193:21
    |
 LL |             let _ = self as i16;
    |                     ^^^^^^^^^^^
 
 error: casting `main::E7` to `usize` may truncate the value on targets with 32-bit wide pointers
-  --> $DIR/cast.rs:203:21
+  --> $DIR/cast.rs:208:21
    |
 LL |             let _ = self as usize;
    |                     ^^^^^^^^^^^^^
 
-error: aborting due to 28 previous errors
+error: casting `main::E10` to `u16` may truncate the value
+  --> $DIR/cast.rs:249:21
+   |
+LL |             let _ = self as u16;
+   |                     ^^^^^^^^^^^
+
+error: aborting due to 31 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 88ecdd0804be7c5643eafa4e1960f5e0176903b3 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Fri, 18 Feb 2022 09:10:48 -0500
Subject: Extract some util functions

---
 clippy_lints/src/casts/cast_possible_truncation.rs | 16 ++----
 clippy_lints/src/casts/utils.rs                    | 56 +++-----------------
 clippy_utils/src/ty.rs                             | 59 +++++++++++++++++++++-
 3 files changed, 68 insertions(+), 63 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/cast_possible_truncation.rs b/clippy_lints/src/casts/cast_possible_truncation.rs
index 6c938062c19..9b189ea1ef8 100644
--- a/clippy_lints/src/casts/cast_possible_truncation.rs
+++ b/clippy_lints/src/casts/cast_possible_truncation.rs
@@ -1,13 +1,13 @@
 use clippy_utils::consts::{constant, Constant};
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::expr_or_init;
-use clippy_utils::ty::is_isize_or_usize;
+use clippy_utils::ty::{get_discriminant_value, is_isize_or_usize};
 use rustc_ast::ast;
 use rustc_attr::IntType;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::LateContext;
-use rustc_middle::ty::{self, FloatTy, Ty, VariantDiscr};
+use rustc_middle::ty::{self, FloatTy, Ty};
 
 use super::{utils, CAST_ENUM_TRUNCATION, CAST_POSSIBLE_TRUNCATION};
 
@@ -117,17 +117,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_expr: &Expr<'_>,
             {
                 let i = def.variant_index_with_ctor_id(id);
                 let variant = &def.variants[i];
-                let nbits: u64 = match variant.discr {
-                    VariantDiscr::Explicit(id) => utils::read_explicit_enum_value(cx.tcx, id).unwrap().nbits(),
-                    VariantDiscr::Relative(x) => {
-                        match def.variants[(i.as_usize() - x as usize).into()].discr {
-                            VariantDiscr::Explicit(id) => {
-                                utils::read_explicit_enum_value(cx.tcx, id).unwrap().add(x).nbits()
-                            }
-                            VariantDiscr::Relative(_) => (32 - x.leading_zeros()).into(),
-                        }
-                    }
-                };
+                let nbits = utils::enum_value_nbits(get_discriminant_value(cx.tcx, def, i));
                 (nbits, Some(variant))
             } else {
                 (utils::enum_ty_to_nbits(def, cx.tcx), None)
diff --git a/clippy_lints/src/casts/utils.rs b/clippy_lints/src/casts/utils.rs
index fab0c194b37..bbed766c47a 100644
--- a/clippy_lints/src/casts/utils.rs
+++ b/clippy_lints/src/casts/utils.rs
@@ -1,7 +1,5 @@
-use rustc_middle::mir::interpret::{ConstValue, Scalar};
+use clippy_utils::ty::{read_explicit_enum_value, EnumValue};
 use rustc_middle::ty::{self, AdtDef, IntTy, Ty, TyCtxt, UintTy, VariantDiscr};
-use rustc_span::def_id::DefId;
-use rustc_target::abi::Size;
 
 /// Returns the size in bits of an integral type.
 /// Will return 0 if the type is not an int or uint variant
@@ -27,53 +25,13 @@ pub(super) fn int_ty_to_nbits(typ: Ty<'_>, tcx: TyCtxt<'_>) -> u64 {
     }
 }
 
-pub(super) enum EnumValue {
-    Unsigned(u128),
-    Signed(i128),
-}
-impl EnumValue {
-    pub(super) fn add(self, n: u32) -> Self {
-        match self {
-            Self::Unsigned(x) => Self::Unsigned(x + u128::from(n)),
-            Self::Signed(x) => Self::Signed(x + i128::from(n)),
-        }
-    }
-
-    pub(super) fn nbits(self) -> u64 {
-        match self {
-            Self::Unsigned(x) => 128 - x.leading_zeros(),
-            Self::Signed(x) if x < 0 => 128 - (-(x + 1)).leading_zeros() + 1,
-            Self::Signed(x) => 128 - x.leading_zeros(),
-        }
-        .into()
-    }
-}
-
-#[allow(clippy::cast_possible_truncation, clippy::cast_possible_wrap)]
-pub(super) fn read_explicit_enum_value(tcx: TyCtxt<'_>, id: DefId) -> Option<EnumValue> {
-    if let Ok(ConstValue::Scalar(Scalar::Int(value))) = tcx.const_eval_poly(id) {
-        match tcx.type_of(id).kind() {
-            ty::Int(_) => Some(EnumValue::Signed(match value.size().bytes() {
-                1 => i128::from(value.assert_bits(Size::from_bytes(1)) as u8 as i8),
-                2 => i128::from(value.assert_bits(Size::from_bytes(2)) as u16 as i16),
-                4 => i128::from(value.assert_bits(Size::from_bytes(4)) as u32 as i32),
-                8 => i128::from(value.assert_bits(Size::from_bytes(8)) as u64 as i64),
-                16 => value.assert_bits(Size::from_bytes(16)) as i128,
-                _ => return None,
-            })),
-            ty::Uint(_) => Some(EnumValue::Unsigned(match value.size().bytes() {
-                1 => value.assert_bits(Size::from_bytes(1)),
-                2 => value.assert_bits(Size::from_bytes(2)),
-                4 => value.assert_bits(Size::from_bytes(4)),
-                8 => value.assert_bits(Size::from_bytes(8)),
-                16 => value.assert_bits(Size::from_bytes(16)),
-                _ => return None,
-            })),
-            _ => None,
-        }
-    } else {
-        None
+pub(super) fn enum_value_nbits(value: EnumValue) -> u64 {
+    match value {
+        EnumValue::Unsigned(x) => 128 - x.leading_zeros(),
+        EnumValue::Signed(x) if x < 0 => 128 - (-(x + 1)).leading_zeros() + 1,
+        EnumValue::Signed(x) => 128 - x.leading_zeros(),
     }
+    .into()
 }
 
 pub(super) fn enum_ty_to_nbits(adt: &AdtDef, tcx: TyCtxt<'_>) -> u64 {
diff --git a/clippy_utils/src/ty.rs b/clippy_utils/src/ty.rs
index 958e6d1ec46..7d74b69906d 100644
--- a/clippy_utils/src/ty.rs
+++ b/clippy_utils/src/ty.rs
@@ -10,12 +10,14 @@ use rustc_hir::def_id::DefId;
 use rustc_hir::{Expr, TyKind, Unsafety};
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::LateContext;
+use rustc_middle::mir::interpret::{ConstValue, Scalar};
 use rustc_middle::ty::subst::{GenericArg, GenericArgKind, Subst};
 use rustc_middle::ty::{
-    self, AdtDef, Binder, FnSig, IntTy, Predicate, PredicateKind, Ty, TyCtxt, TypeFoldable, UintTy,
+    self, AdtDef, Binder, FnSig, IntTy, Predicate, PredicateKind, Ty, TyCtxt, TypeFoldable, UintTy, VariantDiscr,
 };
 use rustc_span::symbol::Ident;
 use rustc_span::{sym, Span, Symbol, DUMMY_SP};
+use rustc_target::abi::{Size, VariantIdx};
 use rustc_trait_selection::infer::InferCtxtExt;
 use rustc_trait_selection::traits::query::normalize::AtExt;
 use std::iter;
@@ -515,3 +517,58 @@ pub fn expr_sig<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>) -> Option<ExprFnS
         }
     }
 }
+
+#[derive(Clone, Copy)]
+pub enum EnumValue {
+    Unsigned(u128),
+    Signed(i128),
+}
+impl core::ops::Add<u32> for EnumValue {
+    type Output = Self;
+    fn add(self, n: u32) -> Self::Output {
+        match self {
+            Self::Unsigned(x) => Self::Unsigned(x + u128::from(n)),
+            Self::Signed(x) => Self::Signed(x + i128::from(n)),
+        }
+    }
+}
+
+/// Attempts to read the given constant as though it were an an enum value.
+#[allow(clippy::cast_possible_truncation, clippy::cast_possible_wrap)]
+pub fn read_explicit_enum_value(tcx: TyCtxt<'_>, id: DefId) -> Option<EnumValue> {
+    if let Ok(ConstValue::Scalar(Scalar::Int(value))) = tcx.const_eval_poly(id) {
+        match tcx.type_of(id).kind() {
+            ty::Int(_) => Some(EnumValue::Signed(match value.size().bytes() {
+                1 => i128::from(value.assert_bits(Size::from_bytes(1)) as u8 as i8),
+                2 => i128::from(value.assert_bits(Size::from_bytes(2)) as u16 as i16),
+                4 => i128::from(value.assert_bits(Size::from_bytes(4)) as u32 as i32),
+                8 => i128::from(value.assert_bits(Size::from_bytes(8)) as u64 as i64),
+                16 => value.assert_bits(Size::from_bytes(16)) as i128,
+                _ => return None,
+            })),
+            ty::Uint(_) => Some(EnumValue::Unsigned(match value.size().bytes() {
+                1 => value.assert_bits(Size::from_bytes(1)),
+                2 => value.assert_bits(Size::from_bytes(2)),
+                4 => value.assert_bits(Size::from_bytes(4)),
+                8 => value.assert_bits(Size::from_bytes(8)),
+                16 => value.assert_bits(Size::from_bytes(16)),
+                _ => return None,
+            })),
+            _ => None,
+        }
+    } else {
+        None
+    }
+}
+
+/// Gets the value of the given variant.
+pub fn get_discriminant_value(tcx: TyCtxt<'_>, adt: &'_ AdtDef, i: VariantIdx) -> EnumValue {
+    let variant = &adt.variants[i];
+    match variant.discr {
+        VariantDiscr::Explicit(id) => read_explicit_enum_value(tcx, id).unwrap(),
+        VariantDiscr::Relative(x) => match adt.variants[(i.as_usize() - x as usize).into()].discr {
+            VariantDiscr::Explicit(id) => read_explicit_enum_value(tcx, id).unwrap() + x,
+            VariantDiscr::Relative(_) => EnumValue::Unsigned(x.into()),
+        },
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From c02dff716785721c4c992d03ee816d764fb43402 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Tue, 15 Feb 2022 11:29:02 -0500
Subject: Fix `transmute_undefined_repr` when converting between a pointer and
 a type containing a pointer

---
 .../src/transmute/transmute_undefined_repr.rs      |  3 ++-
 tests/ui/transmute_undefined_repr.rs               | 14 ++++++++++++
 tests/ui/transmute_undefined_repr.stderr           | 26 +++++++++++++++++++---
 3 files changed, 39 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/transmute/transmute_undefined_repr.rs b/clippy_lints/src/transmute/transmute_undefined_repr.rs
index 89439862f69..74ea7a3b893 100644
--- a/clippy_lints/src/transmute/transmute_undefined_repr.rs
+++ b/clippy_lints/src/transmute/transmute_undefined_repr.rs
@@ -273,7 +273,8 @@ fn reduce_ty<'tcx>(cx: &LateContext<'tcx>, mut ty: Ty<'tcx>) -> ReducedTy<'tcx>
                     ReducedTy::UnorderedFields(ty)
                 }
             },
-            ty::Ref(..) | ty::RawPtr(_) => ReducedTy::Ref(ty),
+            ty::Ref(_, ty, _) => ReducedTy::Ref(ty),
+            ty::RawPtr(ty) => ReducedTy::Ref(ty.ty),
             _ => ReducedTy::Other(ty),
         };
     }
diff --git a/tests/ui/transmute_undefined_repr.rs b/tests/ui/transmute_undefined_repr.rs
index f0383a03fbd..0916da819b1 100644
--- a/tests/ui/transmute_undefined_repr.rs
+++ b/tests/ui/transmute_undefined_repr.rs
@@ -44,5 +44,19 @@ fn main() {
         // issue #8417
         let _: Ty2C<Ty2<u32, i32>, ()> = core::mem::transmute(value::<Ty2<u32, i32>>()); // Ok, Ty2 types are the same
         let _: Ty2<u32, i32> = core::mem::transmute(value::<Ty2C<Ty2<u32, i32>, ()>>()); // Ok, Ty2 types are the same
+
+        // Ty2 types are the same
+        let _: &'static mut Ty2<u32, u32> = core::mem::transmute(value::<Box<Ty2<u32, u32>>>()); // Ok
+        // Ty2 types are the same
+        let _: Box<Ty2<u32, u32>> = core::mem::transmute(value::<&'static mut Ty2<u32, u32>>()); // Ok
+        let _: *mut Ty2<u32, u32> = core::mem::transmute(value::<Box<Ty2<u32, u32>>>()); // Ok, Ty2 types are the same
+        let _: Box<Ty2<u32, u32>> = core::mem::transmute(value::<*mut Ty2<u32, u32>>()); // Ok, Ty2 types are the same
+
+        // Different Ty2 instances
+        let _: &'static mut Ty2<u32, f32> = core::mem::transmute(value::<Box<Ty2<u32, u32>>>()); // Lint
+        // Different Ty2 instances
+        let _: Box<Ty2<u32, u32>> = core::mem::transmute(value::<&'static mut Ty2<u32, f32>>()); // Lint
+
+
     }
 }
diff --git a/tests/ui/transmute_undefined_repr.stderr b/tests/ui/transmute_undefined_repr.stderr
index 040c63c7afa..98035305ec0 100644
--- a/tests/ui/transmute_undefined_repr.stderr
+++ b/tests/ui/transmute_undefined_repr.stderr
@@ -28,17 +28,37 @@ LL |         let _: Ty<Ty2<u32, i32>> = core::mem::transmute(value::<Ty2<u32, f3
    |
    = note: two instances of the same generic type (`Ty2`) may have different layouts
 
-error: transmute to `&Ty2<u32, f32>` which has an undefined layout
+error: transmute from `Ty<&Ty2<u32, i32>>` to `&Ty2<u32, f32>`, both of which have an undefined layout
   --> $DIR/transmute_undefined_repr.rs:35:33
    |
 LL |         let _: &Ty2<u32, f32> = core::mem::transmute(value::<Ty<&Ty2<u32, i32>>>()); // Lint, different Ty2 instances
    |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: two instances of the same generic type (`Ty2`) may have different layouts
 
-error: transmute from `&Ty2<u32, f32>` which has an undefined layout
+error: transmute from `&Ty2<u32, f32>` to `Ty<&Ty2<u32, i32>>`, both of which have an undefined layout
   --> $DIR/transmute_undefined_repr.rs:36:37
    |
 LL |         let _: Ty<&Ty2<u32, i32>> = core::mem::transmute(value::<&Ty2<u32, f32>>()); // Lint, different Ty2 instances
    |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: two instances of the same generic type (`Ty2`) may have different layouts
+
+error: transmute from `std::boxed::Box<Ty2<u32, u32>>` to `&mut Ty2<u32, f32>`, both of which have an undefined layout
+  --> $DIR/transmute_undefined_repr.rs:56:45
+   |
+LL |         let _: &'static mut Ty2<u32, f32> = core::mem::transmute(value::<Box<Ty2<u32, u32>>>()); // Lint
+   |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: two instances of the same generic type (`Ty2`) may have different layouts
+
+error: transmute from `&mut Ty2<u32, f32>` to `std::boxed::Box<Ty2<u32, u32>>`, both of which have an undefined layout
+  --> $DIR/transmute_undefined_repr.rs:58:37
+   |
+LL |         let _: Box<Ty2<u32, u32>> = core::mem::transmute(value::<&'static mut Ty2<u32, f32>>()); // Lint
+   |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: two instances of the same generic type (`Ty2`) may have different layouts
 
-error: aborting due to 6 previous errors
+error: aborting due to 8 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 01732b60192ed7f99571090b5b87f61ab8c98e75 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Tue, 15 Feb 2022 11:39:19 -0500
Subject: Add some comments to `transmute_undefined_repr`

---
 clippy_lints/src/transmute/transmute_undefined_repr.rs | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/transmute/transmute_undefined_repr.rs b/clippy_lints/src/transmute/transmute_undefined_repr.rs
index 74ea7a3b893..5b08ad5840a 100644
--- a/clippy_lints/src/transmute/transmute_undefined_repr.rs
+++ b/clippy_lints/src/transmute/transmute_undefined_repr.rs
@@ -189,6 +189,7 @@ enum ReducedTys<'tcx> {
     Other { from_ty: Ty<'tcx>, to_ty: Ty<'tcx> },
 }
 
+/// Remove references so long as both types are references.
 fn reduce_refs<'tcx>(
     cx: &LateContext<'tcx>,
     span: Span,
@@ -227,13 +228,21 @@ fn reduce_refs<'tcx>(
 }
 
 enum ReducedTy<'tcx> {
+    /// The type is a struct containing either zero sized fields, or multiple sized fields with a
+    /// defined order.
     OrderedFields(Ty<'tcx>),
+    /// The type is a struct containing multiple non-zero sized fields with no defined order.
     UnorderedFields(Ty<'tcx>),
+    /// The type is a reference to the contained type.
     Ref(Ty<'tcx>),
-    Other(Ty<'tcx>),
+    /// The type is an array of a primitive integer type. These can be used as storage for a value
+    /// of another type.
     IntArray,
+    /// Any other type.
+    Other(Ty<'tcx>),
 }
 
+/// Reduce structs containing a single non-zero sized field to it's contained type.
 fn reduce_ty<'tcx>(cx: &LateContext<'tcx>, mut ty: Ty<'tcx>) -> ReducedTy<'tcx> {
     loop {
         ty = cx.tcx.try_normalize_erasing_regions(cx.param_env, ty).unwrap_or(ty);
-- 
cgit 1.4.1-3-g733a5


From 447a24588a865142aeaf9153952485d1cd6b9c67 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Tue, 15 Feb 2022 14:51:57 -0500
Subject: Allow various type erasure patterns in `transmute_undefined_repr`

---
 clippy_lints/src/casts/cast_ptr_alignment.rs       | 18 +-----
 .../src/transmute/transmute_undefined_repr.rs      | 17 +++--
 clippy_utils/src/lib.rs                            |  1 +
 clippy_utils/src/ty.rs                             | 14 ++++
 tests/ui/transmute_undefined_repr.rs               | 74 +++++++++++++---------
 tests/ui/transmute_undefined_repr.stderr           | 46 +++++++-------
 6 files changed, 96 insertions(+), 74 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/cast_ptr_alignment.rs b/clippy_lints/src/casts/cast_ptr_alignment.rs
index 079b7ff0675..a4ef1344ab9 100644
--- a/clippy_lints/src/casts/cast_ptr_alignment.rs
+++ b/clippy_lints/src/casts/cast_ptr_alignment.rs
@@ -1,11 +1,11 @@
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::is_hir_ty_cfg_dependant;
+use clippy_utils::ty::is_c_void;
 use if_chain::if_chain;
 use rustc_hir::{Expr, ExprKind, GenericArg};
 use rustc_lint::LateContext;
 use rustc_middle::ty::layout::LayoutOf;
 use rustc_middle::ty::{self, Ty};
-use rustc_span::symbol::sym;
 
 use super::CAST_PTR_ALIGNMENT;
 
@@ -62,19 +62,3 @@ fn lint_cast_ptr_alignment<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, cast_f
         }
     }
 }
-
-/// Check if the given type is either `core::ffi::c_void` or
-/// one of the platform specific `libc::<platform>::c_void` of libc.
-fn is_c_void(cx: &LateContext<'_>, ty: Ty<'_>) -> bool {
-    if let ty::Adt(adt, _) = ty.kind() {
-        let names = cx.get_def_path(adt.did);
-
-        if names.is_empty() {
-            return false;
-        }
-        if names[0] == sym::libc || names[0] == sym::core && *names.last().unwrap() == sym!(c_void) {
-            return true;
-        }
-    }
-    false
-}
diff --git a/clippy_lints/src/transmute/transmute_undefined_repr.rs b/clippy_lints/src/transmute/transmute_undefined_repr.rs
index 5b08ad5840a..74bdace408c 100644
--- a/clippy_lints/src/transmute/transmute_undefined_repr.rs
+++ b/clippy_lints/src/transmute/transmute_undefined_repr.rs
@@ -1,5 +1,6 @@
 use super::TRANSMUTE_UNDEFINED_REPR;
 use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::ty::is_c_void;
 use rustc_hir::Expr;
 use rustc_lint::LateContext;
 use rustc_middle::ty::subst::{GenericArg, Subst};
@@ -100,7 +101,8 @@ pub(super) fn check<'tcx>(
                 from_ty: from_sub_ty,
                 to_ty: to_sub_ty,
             } => match (reduce_ty(cx, from_sub_ty), reduce_ty(cx, to_sub_ty)) {
-                (ReducedTy::IntArray, _) | (_, ReducedTy::IntArray) => return false,
+                (ReducedTy::IntArray | ReducedTy::TypeErasure, _)
+                | (_, ReducedTy::IntArray | ReducedTy::TypeErasure) => return false,
                 (ReducedTy::UnorderedFields(from_ty), ReducedTy::UnorderedFields(to_ty)) if from_ty != to_ty => {
                     span_lint_and_then(
                         cx,
@@ -228,8 +230,10 @@ fn reduce_refs<'tcx>(
 }
 
 enum ReducedTy<'tcx> {
-    /// The type is a struct containing either zero sized fields, or multiple sized fields with a
-    /// defined order.
+    /// The type can be used for type erasure.
+    TypeErasure,
+    /// The type is a struct containing either zero non-zero sized fields, or multiple non-zero
+    /// sized fields with a defined order.
     OrderedFields(Ty<'tcx>),
     /// The type is a struct containing multiple non-zero sized fields with no defined order.
     UnorderedFields(Ty<'tcx>),
@@ -252,6 +256,7 @@ fn reduce_ty<'tcx>(cx: &LateContext<'tcx>, mut ty: Ty<'tcx>) -> ReducedTy<'tcx>
                 ty = sub_ty;
                 continue;
             },
+            ty::Tuple(args) if args.is_empty() => ReducedTy::TypeErasure,
             ty::Tuple(args) => {
                 let mut iter = args.iter().map(GenericArg::expect_ty);
                 let Some(sized_ty) = iter.find(|ty| !is_zero_sized_ty(cx, ty)) else {
@@ -270,7 +275,7 @@ fn reduce_ty<'tcx>(cx: &LateContext<'tcx>, mut ty: Ty<'tcx>) -> ReducedTy<'tcx>
                     .iter()
                     .map(|f| cx.tcx.type_of(f.did).subst(cx.tcx, substs));
                 let Some(sized_ty) = iter.find(|ty| !is_zero_sized_ty(cx, ty)) else {
-                    return ReducedTy::OrderedFields(ty);
+                    return ReducedTy::TypeErasure;
                 };
                 if iter.all(|ty| is_zero_sized_ty(cx, ty)) {
                     ty = sized_ty;
@@ -282,6 +287,10 @@ fn reduce_ty<'tcx>(cx: &LateContext<'tcx>, mut ty: Ty<'tcx>) -> ReducedTy<'tcx>
                     ReducedTy::UnorderedFields(ty)
                 }
             },
+            ty::Adt(def, _) if def.is_enum() && (def.variants.is_empty() || is_c_void(cx, ty)) => {
+                ReducedTy::TypeErasure
+            },
+            ty::Foreign(_) => ReducedTy::TypeErasure,
             ty::Ref(_, ty, _) => ReducedTy::Ref(ty),
             ty::RawPtr(ty) => ReducedTy::Ref(ty.ty),
             _ => ReducedTy::Other(ty),
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 73d91550693..5b37a1de8ed 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -1,6 +1,7 @@
 #![feature(box_patterns)]
 #![feature(control_flow_enum)]
 #![feature(let_else)]
+#![feature(let_chains)]
 #![feature(once_cell)]
 #![feature(rustc_private)]
 #![recursion_limit = "512"]
diff --git a/clippy_utils/src/ty.rs b/clippy_utils/src/ty.rs
index 7d74b69906d..6c9ba64525a 100644
--- a/clippy_utils/src/ty.rs
+++ b/clippy_utils/src/ty.rs
@@ -572,3 +572,17 @@ pub fn get_discriminant_value(tcx: TyCtxt<'_>, adt: &'_ AdtDef, i: VariantIdx) -
         },
     }
 }
+
+/// Check if the given type is either `core::ffi::c_void`, `std::os::raw::c_void`, or one of the
+/// platform specific `libc::<platform>::c_void` types in libc.
+pub fn is_c_void(cx: &LateContext<'_>, ty: Ty<'_>) -> bool {
+    if let ty::Adt(adt, _) = ty.kind()
+        && let &[krate, .., name] = &*cx.get_def_path(adt.did)
+        && let sym::libc | sym::core | sym::std = krate
+        && name.as_str() == "c_void"
+    {
+        true
+    } else {
+        false
+    }
+}
diff --git a/tests/ui/transmute_undefined_repr.rs b/tests/ui/transmute_undefined_repr.rs
index 0916da819b1..c1ee0d98a92 100644
--- a/tests/ui/transmute_undefined_repr.rs
+++ b/tests/ui/transmute_undefined_repr.rs
@@ -1,6 +1,9 @@
 #![warn(clippy::transmute_undefined_repr)]
 #![allow(clippy::unit_arg)]
 
+use core::ffi::c_void;
+use core::mem::transmute;
+
 fn value<T>() -> T {
     unimplemented!()
 }
@@ -14,49 +17,60 @@ struct Ty2C<T, U>(T, U);
 
 fn main() {
     unsafe {
-        let _: () = core::mem::transmute(value::<Empty>());
-        let _: Empty = core::mem::transmute(value::<()>());
+        let _: () = transmute(value::<Empty>());
+        let _: Empty = transmute(value::<()>());
 
-        let _: Ty<u32> = core::mem::transmute(value::<u32>());
-        let _: Ty<u32> = core::mem::transmute(value::<u32>());
+        let _: Ty<u32> = transmute(value::<u32>());
+        let _: Ty<u32> = transmute(value::<u32>());
 
-        let _: Ty2C<u32, i32> = core::mem::transmute(value::<Ty2<u32, i32>>()); // Lint, Ty2 is unordered
-        let _: Ty2<u32, i32> = core::mem::transmute(value::<Ty2C<u32, i32>>()); // Lint, Ty2 is unordered
+        let _: Ty2C<u32, i32> = transmute(value::<Ty2<u32, i32>>()); // Lint, Ty2 is unordered
+        let _: Ty2<u32, i32> = transmute(value::<Ty2C<u32, i32>>()); // Lint, Ty2 is unordered
 
-        let _: Ty2<u32, i32> = core::mem::transmute(value::<Ty<Ty2<u32, i32>>>()); // Ok, Ty2 types are the same
-        let _: Ty<Ty2<u32, i32>> = core::mem::transmute(value::<Ty2<u32, i32>>()); // Ok, Ty2 types are the same
+        let _: Ty2<u32, i32> = transmute(value::<Ty<Ty2<u32, i32>>>()); // Ok, Ty2 types are the same
+        let _: Ty<Ty2<u32, i32>> = transmute(value::<Ty2<u32, i32>>()); // Ok, Ty2 types are the same
 
-        let _: Ty2<u32, f32> = core::mem::transmute(value::<Ty<Ty2<u32, i32>>>()); // Lint, different Ty2 instances
-        let _: Ty<Ty2<u32, i32>> = core::mem::transmute(value::<Ty2<u32, f32>>()); // Lint, different Ty2 instances
+        let _: Ty2<u32, f32> = transmute(value::<Ty<Ty2<u32, i32>>>()); // Lint, different Ty2 instances
+        let _: Ty<Ty2<u32, i32>> = transmute(value::<Ty2<u32, f32>>()); // Lint, different Ty2 instances
 
-        let _: Ty<&()> = core::mem::transmute(value::<&()>());
-        let _: &() = core::mem::transmute(value::<Ty<&()>>());
+        let _: Ty<&()> = transmute(value::<&()>());
+        let _: &() = transmute(value::<Ty<&()>>());
 
-        let _: &Ty2<u32, f32> = core::mem::transmute(value::<Ty<&Ty2<u32, i32>>>()); // Lint, different Ty2 instances
-        let _: Ty<&Ty2<u32, i32>> = core::mem::transmute(value::<&Ty2<u32, f32>>()); // Lint, different Ty2 instances
+        let _: &Ty2<u32, f32> = transmute(value::<Ty<&Ty2<u32, i32>>>()); // Lint, different Ty2 instances
+        let _: Ty<&Ty2<u32, i32>> = transmute(value::<&Ty2<u32, f32>>()); // Lint, different Ty2 instances
 
-        let _: Ty<usize> = core::mem::transmute(value::<&Ty2<u32, i32>>()); // Ok, pointer to usize conversion
-        let _: &Ty2<u32, i32> = core::mem::transmute(value::<Ty<usize>>()); // Ok, pointer to usize conversion
+        let _: Ty<usize> = transmute(value::<&Ty2<u32, i32>>()); // Ok, pointer to usize conversion
+        let _: &Ty2<u32, i32> = transmute(value::<Ty<usize>>()); // Ok, pointer to usize conversion
 
-        let _: Ty<[u8; 8]> = core::mem::transmute(value::<Ty2<u32, i32>>()); // Ok, transmute to byte array
-        let _: Ty2<u32, i32> = core::mem::transmute(value::<Ty<[u8; 8]>>()); // Ok, transmute from byte array
+        let _: Ty<[u8; 8]> = transmute(value::<Ty2<u32, i32>>()); // Ok, transmute to byte array
+        let _: Ty2<u32, i32> = transmute(value::<Ty<[u8; 8]>>()); // Ok, transmute from byte array
 
         // issue #8417
-        let _: Ty2C<Ty2<u32, i32>, ()> = core::mem::transmute(value::<Ty2<u32, i32>>()); // Ok, Ty2 types are the same
-        let _: Ty2<u32, i32> = core::mem::transmute(value::<Ty2C<Ty2<u32, i32>, ()>>()); // Ok, Ty2 types are the same
+        let _: Ty2C<Ty2<u32, i32>, ()> = transmute(value::<Ty2<u32, i32>>()); // Ok, Ty2 types are the same
+        let _: Ty2<u32, i32> = transmute(value::<Ty2C<Ty2<u32, i32>, ()>>()); // Ok, Ty2 types are the same
+
+        let _: &'static mut Ty2<u32, u32> = transmute(value::<Box<Ty2<u32, u32>>>()); // Ok, Ty2 types are the same
+        let _: Box<Ty2<u32, u32>> = transmute(value::<&'static mut Ty2<u32, u32>>()); // Ok, Ty2 types are the same
+        let _: *mut Ty2<u32, u32> = transmute(value::<Box<Ty2<u32, u32>>>()); // Ok, Ty2 types are the same
+        let _: Box<Ty2<u32, u32>> = transmute(value::<*mut Ty2<u32, u32>>()); // Ok, Ty2 types are the same
+
+        let _: &'static mut Ty2<u32, f32> = transmute(value::<Box<Ty2<u32, u32>>>()); // Lint, different Ty2 instances
+        let _: Box<Ty2<u32, u32>> = transmute(value::<&'static mut Ty2<u32, f32>>()); // Lint, different Ty2 instances
 
-        // Ty2 types are the same
-        let _: &'static mut Ty2<u32, u32> = core::mem::transmute(value::<Box<Ty2<u32, u32>>>()); // Ok
-        // Ty2 types are the same
-        let _: Box<Ty2<u32, u32>> = core::mem::transmute(value::<&'static mut Ty2<u32, u32>>()); // Ok
-        let _: *mut Ty2<u32, u32> = core::mem::transmute(value::<Box<Ty2<u32, u32>>>()); // Ok, Ty2 types are the same
-        let _: Box<Ty2<u32, u32>> = core::mem::transmute(value::<*mut Ty2<u32, u32>>()); // Ok, Ty2 types are the same
+        let _: *const () = transmute(value::<Ty<&Ty2<u32, f32>>>()); // Ok, type erasure
+        let _: Ty<&Ty2<u32, f32>> = transmute(value::<*const ()>()); // Ok, reverse type erasure
 
-        // Different Ty2 instances
-        let _: &'static mut Ty2<u32, f32> = core::mem::transmute(value::<Box<Ty2<u32, u32>>>()); // Lint
-        // Different Ty2 instances
-        let _: Box<Ty2<u32, u32>> = core::mem::transmute(value::<&'static mut Ty2<u32, f32>>()); // Lint
+        let _: *const c_void = transmute(value::<Ty<&Ty2<u32, f32>>>()); // Ok, type erasure
+        let _: Ty<&Ty2<u32, f32>> = transmute(value::<*const c_void>()); // Ok, reverse type erasure
 
+        enum Erase {}
+        let _: *const Erase = transmute(value::<Ty<&Ty2<u32, f32>>>()); // Ok, type erasure
+        let _: Ty<&Ty2<u32, f32>> = transmute(value::<*const Erase>()); // Ok, reverse type erasure
 
+        struct Erase2(
+            [u8; 0],
+            core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
+        );
+        let _: *const Erase2 = transmute(value::<Ty<&Ty2<u32, f32>>>()); // Ok, type erasure
+        let _: Ty<&Ty2<u32, f32>> = transmute(value::<*const Erase2>()); // Ok, reverse type erasure
     }
 }
diff --git a/tests/ui/transmute_undefined_repr.stderr b/tests/ui/transmute_undefined_repr.stderr
index 98035305ec0..42d544fc954 100644
--- a/tests/ui/transmute_undefined_repr.stderr
+++ b/tests/ui/transmute_undefined_repr.stderr
@@ -1,62 +1,62 @@
 error: transmute from `Ty2<u32, i32>` which has an undefined layout
-  --> $DIR/transmute_undefined_repr.rs:23:33
+  --> $DIR/transmute_undefined_repr.rs:26:33
    |
-LL |         let _: Ty2C<u32, i32> = core::mem::transmute(value::<Ty2<u32, i32>>()); // Lint, Ty2 is unordered
-   |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |         let _: Ty2C<u32, i32> = transmute(value::<Ty2<u32, i32>>()); // Lint, Ty2 is unordered
+   |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::transmute-undefined-repr` implied by `-D warnings`
 
 error: transmute into `Ty2<u32, i32>` which has an undefined layout
-  --> $DIR/transmute_undefined_repr.rs:24:32
+  --> $DIR/transmute_undefined_repr.rs:27:32
    |
-LL |         let _: Ty2<u32, i32> = core::mem::transmute(value::<Ty2C<u32, i32>>()); // Lint, Ty2 is unordered
-   |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |         let _: Ty2<u32, i32> = transmute(value::<Ty2C<u32, i32>>()); // Lint, Ty2 is unordered
+   |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: transmute from `Ty<Ty2<u32, i32>>` to `Ty2<u32, f32>`, both of which have an undefined layout
-  --> $DIR/transmute_undefined_repr.rs:29:32
+  --> $DIR/transmute_undefined_repr.rs:32:32
    |
-LL |         let _: Ty2<u32, f32> = core::mem::transmute(value::<Ty<Ty2<u32, i32>>>()); // Lint, different Ty2 instances
-   |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |         let _: Ty2<u32, f32> = transmute(value::<Ty<Ty2<u32, i32>>>()); // Lint, different Ty2 instances
+   |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: two instances of the same generic type (`Ty2`) may have different layouts
 
 error: transmute from `Ty2<u32, f32>` to `Ty<Ty2<u32, i32>>`, both of which have an undefined layout
-  --> $DIR/transmute_undefined_repr.rs:30:36
+  --> $DIR/transmute_undefined_repr.rs:33:36
    |
-LL |         let _: Ty<Ty2<u32, i32>> = core::mem::transmute(value::<Ty2<u32, f32>>()); // Lint, different Ty2 instances
-   |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |         let _: Ty<Ty2<u32, i32>> = transmute(value::<Ty2<u32, f32>>()); // Lint, different Ty2 instances
+   |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: two instances of the same generic type (`Ty2`) may have different layouts
 
 error: transmute from `Ty<&Ty2<u32, i32>>` to `&Ty2<u32, f32>`, both of which have an undefined layout
-  --> $DIR/transmute_undefined_repr.rs:35:33
+  --> $DIR/transmute_undefined_repr.rs:38:33
    |
-LL |         let _: &Ty2<u32, f32> = core::mem::transmute(value::<Ty<&Ty2<u32, i32>>>()); // Lint, different Ty2 instances
-   |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |         let _: &Ty2<u32, f32> = transmute(value::<Ty<&Ty2<u32, i32>>>()); // Lint, different Ty2 instances
+   |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: two instances of the same generic type (`Ty2`) may have different layouts
 
 error: transmute from `&Ty2<u32, f32>` to `Ty<&Ty2<u32, i32>>`, both of which have an undefined layout
-  --> $DIR/transmute_undefined_repr.rs:36:37
+  --> $DIR/transmute_undefined_repr.rs:39:37
    |
-LL |         let _: Ty<&Ty2<u32, i32>> = core::mem::transmute(value::<&Ty2<u32, f32>>()); // Lint, different Ty2 instances
-   |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |         let _: Ty<&Ty2<u32, i32>> = transmute(value::<&Ty2<u32, f32>>()); // Lint, different Ty2 instances
+   |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: two instances of the same generic type (`Ty2`) may have different layouts
 
 error: transmute from `std::boxed::Box<Ty2<u32, u32>>` to `&mut Ty2<u32, f32>`, both of which have an undefined layout
   --> $DIR/transmute_undefined_repr.rs:56:45
    |
-LL |         let _: &'static mut Ty2<u32, f32> = core::mem::transmute(value::<Box<Ty2<u32, u32>>>()); // Lint
-   |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |         let _: &'static mut Ty2<u32, f32> = transmute(value::<Box<Ty2<u32, u32>>>()); // Lint, different Ty2 instances
+   |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: two instances of the same generic type (`Ty2`) may have different layouts
 
 error: transmute from `&mut Ty2<u32, f32>` to `std::boxed::Box<Ty2<u32, u32>>`, both of which have an undefined layout
-  --> $DIR/transmute_undefined_repr.rs:58:37
+  --> $DIR/transmute_undefined_repr.rs:57:37
    |
-LL |         let _: Box<Ty2<u32, u32>> = core::mem::transmute(value::<&'static mut Ty2<u32, f32>>()); // Lint
-   |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |         let _: Box<Ty2<u32, u32>> = transmute(value::<&'static mut Ty2<u32, f32>>()); // Lint, different Ty2 instances
+   |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: two instances of the same generic type (`Ty2`) may have different layouts
 
-- 
cgit 1.4.1-3-g733a5


From 7c07022c987a9f90218f70defe48b2ddb0824a84 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Wed, 16 Feb 2022 10:45:49 -0500
Subject: Allow transmuting fat pointers to some types in
 `transmute_undefined_repr`

---
 .../src/transmute/transmute_undefined_repr.rs      | 66 ++++++++++++----------
 tests/ui/transmute_undefined_repr.rs               | 16 +++++-
 2 files changed, 50 insertions(+), 32 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/transmute/transmute_undefined_repr.rs b/clippy_lints/src/transmute/transmute_undefined_repr.rs
index 74bdace408c..2630bc4e9ab 100644
--- a/clippy_lints/src/transmute/transmute_undefined_repr.rs
+++ b/clippy_lints/src/transmute/transmute_undefined_repr.rs
@@ -19,33 +19,39 @@ pub(super) fn check<'tcx>(
 
     while from_ty != to_ty {
         match reduce_refs(cx, e.span, from_ty, to_ty) {
-            ReducedTys::FromFatPtr { unsized_ty, .. } => {
-                span_lint_and_then(
-                    cx,
-                    TRANSMUTE_UNDEFINED_REPR,
-                    e.span,
-                    &format!("transmute from `{}` which has an undefined layout", from_ty_orig),
-                    |diag| {
-                        if from_ty_orig.peel_refs() != unsized_ty {
-                            diag.note(&format!("the contained type `&{}` has an undefined layout", unsized_ty));
-                        }
-                    },
-                );
-                return true;
+            ReducedTys::FromFatPtr { unsized_ty, to_ty } => match reduce_ty(cx, to_ty) {
+                ReducedTy::IntArray | ReducedTy::TypeErasure => break,
+                _ => {
+                    span_lint_and_then(
+                        cx,
+                        TRANSMUTE_UNDEFINED_REPR,
+                        e.span,
+                        &format!("transmute from `{}` which has an undefined layout", from_ty_orig),
+                        |diag| {
+                            if from_ty_orig.peel_refs() != unsized_ty {
+                                diag.note(&format!("the contained type `&{}` has an undefined layout", unsized_ty));
+                            }
+                        },
+                    );
+                    return true;
+                },
             },
-            ReducedTys::ToFatPtr { unsized_ty, .. } => {
-                span_lint_and_then(
-                    cx,
-                    TRANSMUTE_UNDEFINED_REPR,
-                    e.span,
-                    &format!("transmute to `{}` which has an undefined layout", to_ty_orig),
-                    |diag| {
-                        if to_ty_orig.peel_refs() != unsized_ty {
-                            diag.note(&format!("the contained type `&{}` has an undefined layout", unsized_ty));
-                        }
-                    },
-                );
-                return true;
+            ReducedTys::ToFatPtr { unsized_ty, from_ty } => match reduce_ty(cx, from_ty) {
+                ReducedTy::IntArray | ReducedTy::TypeErasure => break,
+                _ => {
+                    span_lint_and_then(
+                        cx,
+                        TRANSMUTE_UNDEFINED_REPR,
+                        e.span,
+                        &format!("transmute to `{}` which has an undefined layout", to_ty_orig),
+                        |diag| {
+                            if to_ty_orig.peel_refs() != unsized_ty {
+                                diag.note(&format!("the contained type `&{}` has an undefined layout", unsized_ty));
+                            }
+                        },
+                    );
+                    return true;
+                },
             },
             ReducedTys::ToPtr {
                 from_ty: from_sub_ty,
@@ -184,8 +190,8 @@ pub(super) fn check<'tcx>(
 }
 
 enum ReducedTys<'tcx> {
-    FromFatPtr { unsized_ty: Ty<'tcx> },
-    ToFatPtr { unsized_ty: Ty<'tcx> },
+    FromFatPtr { unsized_ty: Ty<'tcx>, to_ty: Ty<'tcx> },
+    ToFatPtr { unsized_ty: Ty<'tcx>, from_ty: Ty<'tcx> },
     ToPtr { from_ty: Ty<'tcx>, to_ty: Ty<'tcx> },
     FromPtr { from_ty: Ty<'tcx>, to_ty: Ty<'tcx> },
     Other { from_ty: Ty<'tcx>, to_ty: Ty<'tcx> },
@@ -211,12 +217,12 @@ fn reduce_refs<'tcx>(
             (ty::Ref(_, unsized_ty, _) | ty::RawPtr(TypeAndMut { ty: unsized_ty, .. }), _)
                 if !unsized_ty.is_sized(cx.tcx.at(span), cx.param_env) =>
             {
-                ReducedTys::FromFatPtr { unsized_ty }
+                ReducedTys::FromFatPtr { unsized_ty, to_ty }
             },
             (_, ty::Ref(_, unsized_ty, _) | ty::RawPtr(TypeAndMut { ty: unsized_ty, .. }))
                 if !unsized_ty.is_sized(cx.tcx.at(span), cx.param_env) =>
             {
-                ReducedTys::ToFatPtr { unsized_ty }
+                ReducedTys::ToFatPtr { unsized_ty, from_ty }
             },
             (ty::Ref(_, from_ty, _) | ty::RawPtr(TypeAndMut { ty: from_ty, .. }), _) => {
                 ReducedTys::FromPtr { from_ty, to_ty }
diff --git a/tests/ui/transmute_undefined_repr.rs b/tests/ui/transmute_undefined_repr.rs
index c1ee0d98a92..84dd1ada8c3 100644
--- a/tests/ui/transmute_undefined_repr.rs
+++ b/tests/ui/transmute_undefined_repr.rs
@@ -1,8 +1,8 @@
 #![warn(clippy::transmute_undefined_repr)]
-#![allow(clippy::unit_arg)]
+#![allow(clippy::unit_arg, clippy::transmute_ptr_to_ref)]
 
 use core::ffi::c_void;
-use core::mem::transmute;
+use core::mem::{size_of, transmute};
 
 fn value<T>() -> T {
     unimplemented!()
@@ -72,5 +72,17 @@ fn main() {
         );
         let _: *const Erase2 = transmute(value::<Ty<&Ty2<u32, f32>>>()); // Ok, type erasure
         let _: Ty<&Ty2<u32, f32>> = transmute(value::<*const Erase2>()); // Ok, reverse type erasure
+
+        let _: *const () = transmute(value::<&&[u8]>()); // Ok, type erasure
+        let _: &&[u8] = transmute(value::<*const ()>()); // Ok, reverse type erasure
+
+        let _: *mut c_void = transmute(value::<&mut &[u8]>()); // Ok, type erasure
+        let _: &mut &[u8] = transmute(value::<*mut c_void>()); // Ok, reverse type erasure
+
+        let _: [u8; size_of::<&[u8]>()] = transmute(value::<&[u8]>()); // Ok, transmute to byte array
+        let _: &[u8] = transmute(value::<[u8; size_of::<&[u8]>()]>()); // Ok, transmute from byte array
+
+        let _: [usize; 2] = transmute(value::<&[u8]>()); // Ok, transmute to int array
+        let _: &[u8] = transmute(value::<[usize; 2]>()); // Ok, transmute from int array
     }
 }
-- 
cgit 1.4.1-3-g733a5


From d28d19d74cfc94921efa06dffb1d3752d507f9dd Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Wed, 16 Feb 2022 14:59:04 -0500
Subject: Fix `transmute_undefined_repr` when converting between a fat pointer
 and a type containing a fat pointer

---
 .../src/transmute/transmute_undefined_repr.rs        | 20 ++++++++++++++++++--
 tests/ui/transmute_undefined_repr.rs                 |  3 +++
 2 files changed, 21 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/transmute/transmute_undefined_repr.rs b/clippy_lints/src/transmute/transmute_undefined_repr.rs
index 2630bc4e9ab..b6cc1676b00 100644
--- a/clippy_lints/src/transmute/transmute_undefined_repr.rs
+++ b/clippy_lints/src/transmute/transmute_undefined_repr.rs
@@ -19,8 +19,16 @@ pub(super) fn check<'tcx>(
 
     while from_ty != to_ty {
         match reduce_refs(cx, e.span, from_ty, to_ty) {
-            ReducedTys::FromFatPtr { unsized_ty, to_ty } => match reduce_ty(cx, to_ty) {
+            ReducedTys::FromFatPtr {
+                unsized_ty,
+                to_ty: to_sub_ty,
+            } => match reduce_ty(cx, to_sub_ty) {
                 ReducedTy::IntArray | ReducedTy::TypeErasure => break,
+                ReducedTy::Ref(to_sub_ty) => {
+                    from_ty = unsized_ty;
+                    to_ty = to_sub_ty;
+                    continue;
+                },
                 _ => {
                     span_lint_and_then(
                         cx,
@@ -36,8 +44,16 @@ pub(super) fn check<'tcx>(
                     return true;
                 },
             },
-            ReducedTys::ToFatPtr { unsized_ty, from_ty } => match reduce_ty(cx, from_ty) {
+            ReducedTys::ToFatPtr {
+                unsized_ty,
+                from_ty: from_sub_ty,
+            } => match reduce_ty(cx, from_sub_ty) {
                 ReducedTy::IntArray | ReducedTy::TypeErasure => break,
+                ReducedTy::Ref(from_sub_ty) => {
+                    from_ty = from_sub_ty;
+                    to_ty = unsized_ty;
+                    continue;
+                },
                 _ => {
                     span_lint_and_then(
                         cx,
diff --git a/tests/ui/transmute_undefined_repr.rs b/tests/ui/transmute_undefined_repr.rs
index 84dd1ada8c3..b163d605634 100644
--- a/tests/ui/transmute_undefined_repr.rs
+++ b/tests/ui/transmute_undefined_repr.rs
@@ -84,5 +84,8 @@ fn main() {
 
         let _: [usize; 2] = transmute(value::<&[u8]>()); // Ok, transmute to int array
         let _: &[u8] = transmute(value::<[usize; 2]>()); // Ok, transmute from int array
+
+        let _: *const [u8] = transmute(value::<Box<[u8]>>()); // Ok
+        let _: Box<[u8]> = transmute(value::<*mut [u8]>()); // Ok
     }
 }
-- 
cgit 1.4.1-3-g733a5


From 78345b4d099063e8f34dc4c7bd2a31670df838f7 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Fri, 18 Feb 2022 15:41:46 -0500
Subject: Clarify `cfg` detection process in `matches.rs`

---
 clippy_lints/src/matches/mod.rs | 23 ++++++++++++++++++++++-
 1 file changed, 22 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/mod.rs b/clippy_lints/src/matches/mod.rs
index 14dd7cb1dac..92179eb6f0e 100644
--- a/clippy_lints/src/matches/mod.rs
+++ b/clippy_lints/src/matches/mod.rs
@@ -668,9 +668,27 @@ fn contains_cfg_arm(cx: &LateContext<'_>, e: &Expr<'_>, scrutinee: &Expr<'_>, ar
     });
     let end = e.span.hi();
 
+    // Walk through all the non-code space before each match arm. The space trailing the final arm is
+    // handled after the `try_fold` e.g.
+    //
+    // match foo {
+    // _________^-                      everything between the scrutinee and arm1
+    //|    arm1 => (),
+    //|---^___________^                 everything before arm2
+    //|    #[cfg(feature = "enabled")]
+    //|    arm2 => some_code(),
+    //|---^____________________^        everything before arm3
+    //|    // some comment about arm3
+    //|    arm3 => some_code(),
+    //|---^____________________^        everything after arm3
+    //|    #[cfg(feature = "disabled")]
+    //|    arm4 = some_code(),
+    //|};
+    //|^
     let found = arm_spans.try_fold(start, |start, range| {
         let Some((end, next_start)) = range else {
-            // Shouldn't happen, but treat this as though a `cfg` attribute were found
+            // Shouldn't happen as macros can't expand to match arms, but treat this as though a `cfg` attribute were
+            // found.
             return Err(());
         };
         let span = SpanData {
@@ -697,6 +715,7 @@ fn contains_cfg_arm(cx: &LateContext<'_>, e: &Expr<'_>, scrutinee: &Expr<'_>, ar
     }
 }
 
+/// Checks if the given span contains a `#[cfg(..)]` attribute
 fn span_contains_cfg(cx: &LateContext<'_>, s: Span) -> bool {
     let Some(snip) = snippet_opt(cx, s) else {
         // Assume true. This would require either an invalid span, or one which crosses file boundaries.
@@ -708,6 +727,8 @@ fn span_contains_cfg(cx: &LateContext<'_>, s: Span) -> bool {
         pos += t.len;
         (t.kind, start..pos)
     });
+
+    // Search for the token sequence [`#`, `[`, `cfg`]
     while iter.any(|(t, _)| matches!(t, TokenKind::Pound)) {
         let mut iter = iter.by_ref().skip_while(|(t, _)| {
             matches!(
-- 
cgit 1.4.1-3-g733a5


From fd9dd04972252bc709fc0e477c7b8f6796d3f1e1 Mon Sep 17 00:00:00 2001
From: David Tolnay <dtolnay@gmail.com>
Date: Fri, 11 Feb 2022 19:40:07 -0800
Subject: Transmute_undefined_repr to nursery again

---
 clippy_lints/src/lib.register_all.rs         | 1 -
 clippy_lints/src/lib.register_correctness.rs | 1 -
 clippy_lints/src/lib.register_nursery.rs     | 1 +
 clippy_lints/src/transmute/mod.rs            | 2 +-
 4 files changed, 2 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index c6f8470cd7d..054ef32cddc 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -280,7 +280,6 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(transmute::TRANSMUTE_INT_TO_FLOAT),
     LintId::of(transmute::TRANSMUTE_NUM_TO_BYTES),
     LintId::of(transmute::TRANSMUTE_PTR_TO_REF),
-    LintId::of(transmute::TRANSMUTE_UNDEFINED_REPR),
     LintId::of(transmute::UNSOUND_COLLECTION_TRANSMUTE),
     LintId::of(transmute::WRONG_TRANSMUTE),
     LintId::of(transmuting_null::TRANSMUTING_NULL),
diff --git a/clippy_lints/src/lib.register_correctness.rs b/clippy_lints/src/lib.register_correctness.rs
index 18fe44282ed..f8b75964066 100644
--- a/clippy_lints/src/lib.register_correctness.rs
+++ b/clippy_lints/src/lib.register_correctness.rs
@@ -58,7 +58,6 @@ store.register_group(true, "clippy::correctness", Some("clippy_correctness"), ve
     LintId::of(serde_api::SERDE_API_MISUSE),
     LintId::of(size_of_in_element_count::SIZE_OF_IN_ELEMENT_COUNT),
     LintId::of(swap::ALMOST_SWAPPED),
-    LintId::of(transmute::TRANSMUTE_UNDEFINED_REPR),
     LintId::of(transmute::UNSOUND_COLLECTION_TRANSMUTE),
     LintId::of(transmute::WRONG_TRANSMUTE),
     LintId::of(transmuting_null::TRANSMUTING_NULL),
diff --git a/clippy_lints/src/lib.register_nursery.rs b/clippy_lints/src/lib.register_nursery.rs
index a7353790100..8d4dde42bbe 100644
--- a/clippy_lints/src/lib.register_nursery.rs
+++ b/clippy_lints/src/lib.register_nursery.rs
@@ -26,6 +26,7 @@ store.register_group(true, "clippy::nursery", Some("clippy_nursery"), vec![
     LintId::of(strings::STRING_LIT_AS_BYTES),
     LintId::of(suspicious_operation_groupings::SUSPICIOUS_OPERATION_GROUPINGS),
     LintId::of(trailing_empty_array::TRAILING_EMPTY_ARRAY),
+    LintId::of(transmute::TRANSMUTE_UNDEFINED_REPR),
     LintId::of(transmute::USELESS_TRANSMUTE),
     LintId::of(use_self::USE_SELF),
 ])
diff --git a/clippy_lints/src/transmute/mod.rs b/clippy_lints/src/transmute/mod.rs
index 22a8c53a585..1da3b765904 100644
--- a/clippy_lints/src/transmute/mod.rs
+++ b/clippy_lints/src/transmute/mod.rs
@@ -377,7 +377,7 @@ declare_clippy_lint! {
     /// ```
     #[clippy::version = "1.60.0"]
     pub TRANSMUTE_UNDEFINED_REPR,
-    correctness,
+    nursery,
     "transmute to or from a type with an undefined representation"
 }
 
-- 
cgit 1.4.1-3-g733a5


From e3b5cac3c8d4dcbfd767dc8ba99380ab4ac86a91 Mon Sep 17 00:00:00 2001
From: tamaron <tamaron1203@gmail.com>
Date: Mon, 21 Feb 2022 13:25:53 +0900
Subject: fix

---
 clippy_lints/src/large_enum_variant.rs | 50 ++++++++++++++++------------------
 tests/ui/large_enum_variant.rs         | 24 ++++++++++++++++
 tests/ui/large_enum_variant.stderr     | 18 +++++++++++-
 3 files changed, 64 insertions(+), 28 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/large_enum_variant.rs b/clippy_lints/src/large_enum_variant.rs
index 0191713f60d..d1dc6b775c5 100644
--- a/clippy_lints/src/large_enum_variant.rs
+++ b/clippy_lints/src/large_enum_variant.rs
@@ -84,34 +84,30 @@ impl<'tcx> LateLintPass<'tcx> for LargeEnumVariant {
             if adt.variants.len() <= 1 {
                 return;
             }
-            let mut variants_size: Vec<VariantInfo> = adt
-                .variants
-                .iter()
-                .enumerate()
-                .map(|(i, variant)| {
-                    let mut fields_size = Vec::new();
-                    let size: u64 = variant
-                        .fields
-                        .iter()
-                        .enumerate()
-                        .filter_map(|(i, f)| {
-                            let ty = cx.tcx.type_of(f.did);
-                            // don't count generics by filtering out everything
-                            // that does not have a layout
-                            cx.layout_of(ty).ok().map(|l| {
-                                let size = l.size.bytes();
-                                fields_size.push(FieldInfo { ind: i, size });
-                                size
-                            })
-                        })
-                        .sum();
-                    VariantInfo {
-                        ind: i,
-                        size,
-                        fields_size,
+            let mut variants_size: Vec<VariantInfo> = Vec::new();
+            for (i, variant) in adt.variants.iter().enumerate() {
+                let mut fields_size = Vec::new();
+                for (i, f) in variant.fields.iter().enumerate() {
+                    let ty = cx.tcx.type_of(f.did);
+                    // don't lint variants which have a field of generic type.
+                    match cx.layout_of(ty) {
+                        Ok(l) => {
+                            let fsize = l.size.bytes();
+                            fields_size.push(FieldInfo { ind: i, size: fsize });
+                        },
+                        Err(_) => {
+                            return;
+                        },
                     }
-                })
-                .collect();
+                }
+                let size: u64 = fields_size.iter().map(|info| info.size).sum();
+
+                variants_size.push(VariantInfo {
+                    ind: i,
+                    size,
+                    fields_size,
+                });
+            }
 
             variants_size.sort_by(|a, b| (b.size.cmp(&a.size)));
 
diff --git a/tests/ui/large_enum_variant.rs b/tests/ui/large_enum_variant.rs
index b45cc849eae..cee9e2372c2 100644
--- a/tests/ui/large_enum_variant.rs
+++ b/tests/ui/large_enum_variant.rs
@@ -74,6 +74,30 @@ enum LargeEnum8 {
     ContainingMoreThanOneField([i32; 8000], [i32; 2], [i32; 9500], [i32; 30]),
 }
 
+enum LargeEnum9 {
+    A(Struct<()>),
+    B(Struct2),
+}
+
+enum LargeEnumOk2<T> {
+    A(T),
+    B(Struct2),
+}
+
+enum LargeEnumOk3<T> {
+    A(Struct<T>),
+    B(Struct2),
+}
+
+struct Struct<T> {
+    a: i32,
+    t: T,
+}
+
+struct Struct2 {
+    a: [i32; 8000],
+}
+
 fn main() {
     large_enum_variant!();
 }
diff --git a/tests/ui/large_enum_variant.stderr b/tests/ui/large_enum_variant.stderr
index 899f97ce2e1..cbf2ac972e2 100644
--- a/tests/ui/large_enum_variant.stderr
+++ b/tests/ui/large_enum_variant.stderr
@@ -111,5 +111,21 @@ help: consider boxing the large fields to reduce the total size of the enum
 LL |     ContainingMoreThanOneField(Box<[i32; 8000]>, [i32; 2], Box<[i32; 9500]>, [i32; 30]),
    |                                ~~~~~~~~~~~~~~~~            ~~~~~~~~~~~~~~~~
 
-error: aborting due to 7 previous errors
+error: large size difference between variants
+  --> $DIR/large_enum_variant.rs:79:5
+   |
+LL |     B(Struct2),
+   |     ^^^^^^^^^^ this variant is 32000 bytes
+   |
+note: and the second-largest variant is 4 bytes:
+  --> $DIR/large_enum_variant.rs:78:5
+   |
+LL |     A(Struct<()>),
+   |     ^^^^^^^^^^^^^
+help: consider boxing the large fields to reduce the total size of the enum
+   |
+LL |     B(Box<Struct2>),
+   |       ~~~~~~~~~~~~
+
+error: aborting due to 8 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 7412e6976ec6a582bdec141509f96dfb1d0bcf76 Mon Sep 17 00:00:00 2001
From: Ken Matsui <26405363+ken-matsui@users.noreply.github.com>
Date: Wed, 23 Feb 2022 06:06:09 +0900
Subject: Use the precise namespace for `Reverse`

---
 clippy_lints/src/unnecessary_sort_by.rs |  2 +-
 tests/ui/unnecessary_sort_by.fixed      | 10 ++++------
 tests/ui/unnecessary_sort_by.rs         |  2 --
 tests/ui/unnecessary_sort_by.stderr     | 32 ++++++++++++++++----------------
 4 files changed, 21 insertions(+), 25 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unnecessary_sort_by.rs b/clippy_lints/src/unnecessary_sort_by.rs
index e6c260ed96a..075b5e43cc7 100644
--- a/clippy_lints/src/unnecessary_sort_by.rs
+++ b/clippy_lints/src/unnecessary_sort_by.rs
@@ -239,7 +239,7 @@ impl LateLintPass<'_> for UnnecessarySortBy {
                     if trigger.unstable { "_unstable" } else { "" },
                     trigger.closure_arg,
                     if trigger.reverse {
-                        format!("Reverse({})", trigger.closure_body)
+                        format!("std::cmp::Reverse({})", trigger.closure_body)
                     } else {
                         trigger.closure_body.to_string()
                     },
diff --git a/tests/ui/unnecessary_sort_by.fixed b/tests/ui/unnecessary_sort_by.fixed
index d806d620b17..21e2da474a8 100644
--- a/tests/ui/unnecessary_sort_by.fixed
+++ b/tests/ui/unnecessary_sort_by.fixed
@@ -3,7 +3,6 @@
 #![allow(clippy::stable_sort_primitive)]
 
 use std::cell::Ref;
-use std::cmp::Reverse;
 
 fn unnecessary_sort_by() {
     fn id(x: isize) -> isize {
@@ -18,8 +17,8 @@ fn unnecessary_sort_by() {
     vec.sort_unstable_by_key(|a| id(-a));
     // Reverse examples
     vec.sort_by(|a, b| b.cmp(a)); // not linted to avoid suggesting `Reverse(b)` which would borrow
-    vec.sort_by_key(|b| Reverse((b + 5).abs()));
-    vec.sort_unstable_by_key(|b| Reverse(id(-b)));
+    vec.sort_by_key(|b| std::cmp::Reverse((b + 5).abs()));
+    vec.sort_unstable_by_key(|b| std::cmp::Reverse(id(-b)));
     // Negative examples (shouldn't be changed)
     let c = &7;
     vec.sort_by(|a, b| (b - a).cmp(&(a - b)));
@@ -76,7 +75,6 @@ mod issue_5754 {
 
 // The closure parameter is not dereferenced anymore, so non-Copy types can be linted
 mod issue_6001 {
-    use super::*;
     struct Test(String);
 
     impl Test {
@@ -93,8 +91,8 @@ mod issue_6001 {
         args.sort_by_key(|a| a.name());
         args.sort_unstable_by_key(|a| a.name());
         // Reverse
-        args.sort_by_key(|b| Reverse(b.name()));
-        args.sort_unstable_by_key(|b| Reverse(b.name()));
+        args.sort_by_key(|b| std::cmp::Reverse(b.name()));
+        args.sort_unstable_by_key(|b| std::cmp::Reverse(b.name()));
     }
 }
 
diff --git a/tests/ui/unnecessary_sort_by.rs b/tests/ui/unnecessary_sort_by.rs
index 6ee9c3af455..3365bf6e119 100644
--- a/tests/ui/unnecessary_sort_by.rs
+++ b/tests/ui/unnecessary_sort_by.rs
@@ -3,7 +3,6 @@
 #![allow(clippy::stable_sort_primitive)]
 
 use std::cell::Ref;
-use std::cmp::Reverse;
 
 fn unnecessary_sort_by() {
     fn id(x: isize) -> isize {
@@ -76,7 +75,6 @@ mod issue_5754 {
 
 // The closure parameter is not dereferenced anymore, so non-Copy types can be linted
 mod issue_6001 {
-    use super::*;
     struct Test(String);
 
     impl Test {
diff --git a/tests/ui/unnecessary_sort_by.stderr b/tests/ui/unnecessary_sort_by.stderr
index ca9641e8803..89da5e7ea8b 100644
--- a/tests/ui/unnecessary_sort_by.stderr
+++ b/tests/ui/unnecessary_sort_by.stderr
@@ -1,5 +1,5 @@
 error: use Vec::sort here instead
-  --> $DIR/unnecessary_sort_by.rs:15:5
+  --> $DIR/unnecessary_sort_by.rs:14:5
    |
 LL |     vec.sort_by(|a, b| a.cmp(b));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort()`
@@ -7,70 +7,70 @@ LL |     vec.sort_by(|a, b| a.cmp(b));
    = note: `-D clippy::unnecessary-sort-by` implied by `-D warnings`
 
 error: use Vec::sort here instead
-  --> $DIR/unnecessary_sort_by.rs:16:5
+  --> $DIR/unnecessary_sort_by.rs:15:5
    |
 LL |     vec.sort_unstable_by(|a, b| a.cmp(b));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_unstable()`
 
 error: use Vec::sort_by_key here instead
-  --> $DIR/unnecessary_sort_by.rs:17:5
+  --> $DIR/unnecessary_sort_by.rs:16:5
    |
 LL |     vec.sort_by(|a, b| (a + 5).abs().cmp(&(b + 5).abs()));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_by_key(|a| (a + 5).abs())`
 
 error: use Vec::sort_by_key here instead
-  --> $DIR/unnecessary_sort_by.rs:18:5
+  --> $DIR/unnecessary_sort_by.rs:17:5
    |
 LL |     vec.sort_unstable_by(|a, b| id(-a).cmp(&id(-b)));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_unstable_by_key(|a| id(-a))`
 
 error: use Vec::sort_by_key here instead
-  --> $DIR/unnecessary_sort_by.rs:21:5
+  --> $DIR/unnecessary_sort_by.rs:20:5
    |
 LL |     vec.sort_by(|a, b| (b + 5).abs().cmp(&(a + 5).abs()));
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_by_key(|b| Reverse((b + 5).abs()))`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_by_key(|b| std::cmp::Reverse((b + 5).abs()))`
 
 error: use Vec::sort_by_key here instead
-  --> $DIR/unnecessary_sort_by.rs:22:5
+  --> $DIR/unnecessary_sort_by.rs:21:5
    |
 LL |     vec.sort_unstable_by(|a, b| id(-b).cmp(&id(-a)));
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_unstable_by_key(|b| Reverse(id(-b)))`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_unstable_by_key(|b| std::cmp::Reverse(id(-b)))`
 
 error: use Vec::sort_by_key here instead
-  --> $DIR/unnecessary_sort_by.rs:32:5
+  --> $DIR/unnecessary_sort_by.rs:31:5
    |
 LL |     vec.sort_by(|a, b| (***a).abs().cmp(&(***b).abs()));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_by_key(|a| (***a).abs())`
 
 error: use Vec::sort_by_key here instead
-  --> $DIR/unnecessary_sort_by.rs:33:5
+  --> $DIR/unnecessary_sort_by.rs:32:5
    |
 LL |     vec.sort_unstable_by(|a, b| (***a).abs().cmp(&(***b).abs()));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_unstable_by_key(|a| (***a).abs())`
 
 error: use Vec::sort_by_key here instead
-  --> $DIR/unnecessary_sort_by.rs:93:9
+  --> $DIR/unnecessary_sort_by.rs:91:9
    |
 LL |         args.sort_by(|a, b| a.name().cmp(&b.name()));
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `args.sort_by_key(|a| a.name())`
 
 error: use Vec::sort_by_key here instead
-  --> $DIR/unnecessary_sort_by.rs:94:9
+  --> $DIR/unnecessary_sort_by.rs:92:9
    |
 LL |         args.sort_unstable_by(|a, b| a.name().cmp(&b.name()));
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `args.sort_unstable_by_key(|a| a.name())`
 
 error: use Vec::sort_by_key here instead
-  --> $DIR/unnecessary_sort_by.rs:96:9
+  --> $DIR/unnecessary_sort_by.rs:94:9
    |
 LL |         args.sort_by(|a, b| b.name().cmp(&a.name()));
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `args.sort_by_key(|b| Reverse(b.name()))`
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `args.sort_by_key(|b| std::cmp::Reverse(b.name()))`
 
 error: use Vec::sort_by_key here instead
-  --> $DIR/unnecessary_sort_by.rs:97:9
+  --> $DIR/unnecessary_sort_by.rs:95:9
    |
 LL |         args.sort_unstable_by(|a, b| b.name().cmp(&a.name()));
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `args.sort_unstable_by_key(|b| Reverse(b.name()))`
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `args.sort_unstable_by_key(|b| std::cmp::Reverse(b.name()))`
 
 error: aborting due to 12 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 6d2a04250c430d28748972b1c0a29838b24d28de Mon Sep 17 00:00:00 2001
From: mi_sawa <mi.sawa.1216+git@gmail.com>
Date: Wed, 23 Feb 2022 13:38:48 +0900
Subject: Don't assume DAG

---
 clippy_lints/src/redundant_clone.rs | 2 --
 1 file changed, 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/redundant_clone.rs b/clippy_lints/src/redundant_clone.rs
index 60cc8fddcb4..e6dfdb49e77 100644
--- a/clippy_lints/src/redundant_clone.rs
+++ b/clippy_lints/src/redundant_clone.rs
@@ -762,7 +762,6 @@ impl TransitiveRelation {
 
     fn reachable_from(&self, a: mir::Local, domain_size: usize) -> HybridBitSet<mir::Local> {
         let mut seen = HybridBitSet::new_empty(domain_size);
-        seen.insert(a);
         let mut stack = vec![a];
         while let Some(u) = stack.pop() {
             if let Some(edges) = self.relations.get(&u) {
@@ -773,7 +772,6 @@ impl TransitiveRelation {
                 }
             }
         }
-        seen.remove(a);
         seen
     }
 }
-- 
cgit 1.4.1-3-g733a5


From 382b3f0601ea510e4cb4d0dd6c73310eb79708de Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Wed, 23 Feb 2022 01:04:49 -0500
Subject: Fix counting the number of unchangeable arguments in `ptr_arg`

---
 clippy_lints/src/ptr.rs | 2 +-
 tests/ui/ptr_arg.rs     | 8 ++++++++
 2 files changed, 9 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs
index e0ce1b7db00..2c328195f24 100644
--- a/clippy_lints/src/ptr.rs
+++ b/clippy_lints/src/ptr.rs
@@ -547,7 +547,7 @@ fn check_ptr_arg_usage<'tcx>(cx: &LateContext<'tcx>, body: &'tcx Body<'_>, args:
 
             // Helper function to handle early returns.
             let mut set_skip_flag = || {
-                if result.skip {
+                if !result.skip {
                     self.skip_count += 1;
                 }
                 result.skip = true;
diff --git a/tests/ui/ptr_arg.rs b/tests/ui/ptr_arg.rs
index 00b99da2631..97990fedd51 100644
--- a/tests/ui/ptr_arg.rs
+++ b/tests/ui/ptr_arg.rs
@@ -186,3 +186,11 @@ pub trait Trait {
     fn f(v: &mut Vec<i32>);
     fn f2(v: &mut Vec<i32>) {}
 }
+
+// Issue #8463
+fn two_vecs(a: &mut Vec<u32>, b: &mut Vec<u32>) {
+    a.push(0);
+    a.push(0);
+    a.push(0);
+    b.push(1);
+}
-- 
cgit 1.4.1-3-g733a5


From db62821c03ed89404891499fb0840b0b7dc78e11 Mon Sep 17 00:00:00 2001
From: tamaron <tamaron1203@gmail.com>
Date: Thu, 24 Feb 2022 00:16:24 +0900
Subject: fix

---
 clippy_lints/src/eta_reduction.rs |  8 ++++++++
 tests/ui/eta.fixed                | 19 +++++++++++++++++++
 tests/ui/eta.rs                   | 19 +++++++++++++++++++
 3 files changed, 46 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/eta_reduction.rs b/clippy_lints/src/eta_reduction.rs
index 263bff4873c..687e56e57f4 100644
--- a/clippy_lints/src/eta_reduction.rs
+++ b/clippy_lints/src/eta_reduction.rs
@@ -10,6 +10,7 @@ use rustc_hir::def_id::DefId;
 use rustc_hir::{Expr, ExprKind, Param, PatKind, Unsafety};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::adjustment::{Adjust, Adjustment, AutoBorrow};
+use rustc_middle::ty::binding::BindingMode;
 use rustc_middle::ty::subst::Subst;
 use rustc_middle::ty::{self, ClosureKind, Ty, TypeFoldable};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -169,11 +170,18 @@ fn check_inputs(cx: &LateContext<'_>, params: &[Param<'_>], call_args: &[Expr<'_
     if params.len() != call_args.len() {
         return false;
     }
+    let binding_modes = cx.typeck_results().pat_binding_modes();
     std::iter::zip(params, call_args).all(|(param, arg)| {
         match param.pat.kind {
             PatKind::Binding(_, id, ..) if path_to_local_id(arg, id) => {},
             _ => return false,
         }
+        // checks that parameters are not bound as `ref`
+        //dbg!(binding_modes.get(param.pat.hir_id));
+        if let Some(BindingMode::BindByReference(_)) = binding_modes.get(param.pat.hir_id) {
+            return false;
+        }
+
         match *cx.typeck_results().expr_adjustments(arg) {
             [] => true,
             [
diff --git a/tests/ui/eta.fixed b/tests/ui/eta.fixed
index 618f80cdcf8..5aedbea381f 100644
--- a/tests/ui/eta.fixed
+++ b/tests/ui/eta.fixed
@@ -256,3 +256,22 @@ fn arc_fp() {
     (0..5).map(|n| arc(n));
     Some(4).map(|n| ref_arc(n));
 }
+
+// #8460 Don't replace closures with params bounded as `ref`
+mod bind_by_ref {
+    struct A;
+    struct B;
+
+    impl From<&A> for B {
+        fn from(A: &A) -> Self {
+            B
+        }
+    }
+
+    fn test() {
+        // should not lint
+        Some(A).map(|a| B::from(&a));
+        // should not lint
+        Some(A).map(|ref a| B::from(a));
+    }
+}
diff --git a/tests/ui/eta.rs b/tests/ui/eta.rs
index a759e6eb514..5fdf7fb9771 100644
--- a/tests/ui/eta.rs
+++ b/tests/ui/eta.rs
@@ -256,3 +256,22 @@ fn arc_fp() {
     (0..5).map(|n| arc(n));
     Some(4).map(|n| ref_arc(n));
 }
+
+// #8460 Don't replace closures with params bounded as `ref`
+mod bind_by_ref {
+    struct A;
+    struct B;
+
+    impl From<&A> for B {
+        fn from(A: &A) -> Self {
+            B
+        }
+    }
+
+    fn test() {
+        // should not lint
+        Some(A).map(|a| B::from(&a));
+        // should not lint
+        Some(A).map(|ref a| B::from(a));
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 31b49b0be8e1153da13be71dcc9d6bff888217e2 Mon Sep 17 00:00:00 2001
From: tamaron <tamaron1203@gmail.com>
Date: Thu, 24 Feb 2022 00:25:07 +0900
Subject: fix typo

---
 clippy_lints/src/eta_reduction.rs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/eta_reduction.rs b/clippy_lints/src/eta_reduction.rs
index 687e56e57f4..d23c0c225e1 100644
--- a/clippy_lints/src/eta_reduction.rs
+++ b/clippy_lints/src/eta_reduction.rs
@@ -176,8 +176,7 @@ fn check_inputs(cx: &LateContext<'_>, params: &[Param<'_>], call_args: &[Expr<'_
             PatKind::Binding(_, id, ..) if path_to_local_id(arg, id) => {},
             _ => return false,
         }
-        // checks that parameters are not bound as `ref`
-        //dbg!(binding_modes.get(param.pat.hir_id));
+        // checks that parameters are not bound as `ref` or `ref mut`
         if let Some(BindingMode::BindByReference(_)) = binding_modes.get(param.pat.hir_id) {
             return false;
         }
-- 
cgit 1.4.1-3-g733a5


From 30fb8229e13dadbe9f9968108dd46ebb8d43e56e Mon Sep 17 00:00:00 2001
From: J-ZhengLi <lizhengghengj@gmail.com>
Date: Fri, 25 Feb 2022 18:08:52 +0800
Subject: add tests, add base bone for the new lint

---
 CHANGELOG.md                                 |  1 +
 clippy_lints/src/lib.register_all.rs         |  1 +
 clippy_lints/src/lib.register_correctness.rs |  1 +
 clippy_lints/src/lib.register_lints.rs       |  1 +
 clippy_lints/src/matches/mod.rs              | 47 ++++++++++++++++
 clippy_lints/src/matches/nop_match.rs        | 34 ++++++++++++
 tests/ui/nop_match.fixed                     | 83 ++++++++++++++++++++++++++++
 tests/ui/nop_match.rs                        | 83 ++++++++++++++++++++++++++++
 tests/ui/nop_match.stderr                    |  0
 9 files changed, 251 insertions(+)
 create mode 100644 clippy_lints/src/matches/nop_match.rs
 create mode 100644 tests/ui/nop_match.fixed
 create mode 100644 tests/ui/nop_match.rs
 create mode 100644 tests/ui/nop_match.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 1b52a6fcd05..16fe9454634 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3348,6 +3348,7 @@ Released 2018-09-13
 [`nonminimal_bool`]: https://rust-lang.github.io/rust-clippy/master/index.html#nonminimal_bool
 [`nonsensical_open_options`]: https://rust-lang.github.io/rust-clippy/master/index.html#nonsensical_open_options
 [`nonstandard_macro_braces`]: https://rust-lang.github.io/rust-clippy/master/index.html#nonstandard_macro_braces
+[`nop_match`]: https://rust-lang.github.io/rust-clippy/master/index.html#nop_match
 [`not_unsafe_ptr_arg_deref`]: https://rust-lang.github.io/rust-clippy/master/index.html#not_unsafe_ptr_arg_deref
 [`octal_escapes`]: https://rust-lang.github.io/rust-clippy/master/index.html#octal_escapes
 [`ok_expect`]: https://rust-lang.github.io/rust-clippy/master/index.html#ok_expect
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index c6f8470cd7d..01429bf7ea5 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -134,6 +134,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(matches::MATCH_OVERLAPPING_ARM),
     LintId::of(matches::MATCH_REF_PATS),
     LintId::of(matches::MATCH_SINGLE_BINDING),
+    LintId::of(matches::NOP_MATCH),
     LintId::of(matches::REDUNDANT_PATTERN_MATCHING),
     LintId::of(matches::SINGLE_MATCH),
     LintId::of(matches::WILDCARD_IN_OR_PATTERNS),
diff --git a/clippy_lints/src/lib.register_correctness.rs b/clippy_lints/src/lib.register_correctness.rs
index 18fe44282ed..191fa96bdfd 100644
--- a/clippy_lints/src/lib.register_correctness.rs
+++ b/clippy_lints/src/lib.register_correctness.rs
@@ -37,6 +37,7 @@ store.register_group(true, "clippy::correctness", Some("clippy_correctness"), ve
     LintId::of(loops::NEVER_LOOP),
     LintId::of(loops::WHILE_IMMUTABLE_CONDITION),
     LintId::of(match_str_case_mismatch::MATCH_STR_CASE_MISMATCH),
+    LintId::of(matches::NOP_MATCH),
     LintId::of(mem_replace::MEM_REPLACE_WITH_UNINIT),
     LintId::of(methods::CLONE_DOUBLE_REF),
     LintId::of(methods::ITERATOR_STEP_BY_ZERO),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 75ef1b0a9d5..2977a78f257 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -253,6 +253,7 @@ store.register_lints(&[
     matches::MATCH_SINGLE_BINDING,
     matches::MATCH_WILDCARD_FOR_SINGLE_VARIANTS,
     matches::MATCH_WILD_ERR_ARM,
+    matches::NOP_MATCH,
     matches::REDUNDANT_PATTERN_MATCHING,
     matches::REST_PAT_IN_FULLY_BOUND_STRUCTS,
     matches::SINGLE_MATCH,
diff --git a/clippy_lints/src/matches/mod.rs b/clippy_lints/src/matches/mod.rs
index 92179eb6f0e..48300931dc4 100644
--- a/clippy_lints/src/matches/mod.rs
+++ b/clippy_lints/src/matches/mod.rs
@@ -21,6 +21,7 @@ mod redundant_pattern_match;
 mod rest_pat_in_fully_bound_struct;
 mod single_match;
 mod wild_in_or_pats;
+mod nop_match;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -566,6 +567,49 @@ declare_clippy_lint! {
     "`match` with identical arm bodies"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for unnecessary `match` or match-like `if let` returns for `Option` and `Result` 
+    /// when function signatures are the same.
+    ///
+    /// ### Why is this bad?
+    /// This `match` block does nothing and might not be what the coder intended.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// fn foo() -> Result<(), i32> {
+    ///     match result {
+    ///         Ok(val) => Ok(val),
+    ///         Err(err) => Err(err),
+    ///     }
+    /// }
+    /// 
+    /// fn bar() -> Option<i32> {
+    ///     if let Some(val) = option {
+    ///         Some(val)
+    ///     } else {
+    ///         None
+    ///     }
+    /// }
+    /// ```
+    ///
+    /// Could be replaced as
+    /// 
+    /// ```rust,ignore
+    /// fn foo() -> Result<(), i32> {
+    ///     result
+    /// }
+    /// 
+    /// fn bar() -> Option<i32> {
+    ///     option
+    /// }
+    /// ```
+    #[clippy::version = "1.61.0"]
+    pub NOP_MATCH,
+    correctness,
+    "`match` or match-like `if let` that are unnecessary"
+}
+
 #[derive(Default)]
 pub struct Matches {
     msrv: Option<RustcVersion>,
@@ -599,6 +643,7 @@ impl_lint_pass!(Matches => [
     REDUNDANT_PATTERN_MATCHING,
     MATCH_LIKE_MATCHES_MACRO,
     MATCH_SAME_ARMS,
+    NOP_MATCH,
 ]);
 
 impl<'tcx> LateLintPass<'tcx> for Matches {
@@ -622,6 +667,7 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
                     overlapping_arms::check(cx, ex, arms);
                     match_wild_enum::check(cx, ex, arms);
                     match_as_ref::check(cx, ex, arms, expr);
+                    nop_match::check_match(cx, ex, arms);
 
                     if self.infallible_destructuring_match_linted {
                         self.infallible_destructuring_match_linted = false;
@@ -640,6 +686,7 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
                 match_like_matches::check(cx, expr);
             }
             redundant_pattern_match::check(cx, expr);
+            nop_match::check(cx, expr);
         }
     }
 
diff --git a/clippy_lints/src/matches/nop_match.rs b/clippy_lints/src/matches/nop_match.rs
new file mode 100644
index 00000000000..d995caf6cfd
--- /dev/null
+++ b/clippy_lints/src/matches/nop_match.rs
@@ -0,0 +1,34 @@
+#![allow(unused_variables)]
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use rustc_lint::LateContext;
+use rustc_hir::{Arm, Expr};
+use rustc_errors::Applicability;
+use super::NOP_MATCH;
+
+pub(crate) fn check(cx: &LateContext<'_>, ex: &Expr<'_>) {
+    if false {
+        span_lint_and_sugg(
+            cx,
+            NOP_MATCH,
+            ex.span,
+            "this if-let expression is unnecessary",
+            "replace it with",
+            "".to_string(),
+            Applicability::MachineApplicable,
+        );
+    }
+}
+
+pub(crate) fn check_match(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>]) {
+    if false {
+        span_lint_and_sugg(
+            cx,
+            NOP_MATCH,
+            ex.span,
+            "this match expression is unnecessary",
+            "replace it with",
+            "".to_string(),
+            Applicability::MachineApplicable,
+        );
+    }
+}
\ No newline at end of file
diff --git a/tests/ui/nop_match.fixed b/tests/ui/nop_match.fixed
new file mode 100644
index 00000000000..0e37bb85439
--- /dev/null
+++ b/tests/ui/nop_match.fixed
@@ -0,0 +1,83 @@
+// run-rustfix
+#![warn(clippy::nop_match)]
+#![allow(clippy::manual_map)]
+#![allow(clippy::question_mark)]
+#![allow(dead_code)]
+
+fn option_match() -> Option<i32> {
+    match Some(1) {
+        Some(a) => Some(a),
+        None => None
+    }
+}
+
+fn result_match() -> Result<i32, i32> {
+    match Ok(1) {
+        Ok(a) => Ok(a),
+        Err(err) => Err(err)
+    }
+}
+
+fn option_check() -> Option<i32> {
+    if let Some(a) = Some(1) {
+        Some(a)
+    } else {
+        None
+    }
+}
+
+fn option_check_no_else() -> Option<i32> {
+    if let Some(a) = Some(1) {
+        return Some(a);
+    }
+    None
+}
+
+fn func_ret_err<T>(err: T) -> Result<(), T> {
+    Err(err)
+}
+
+fn result_check_no_else() -> Result<(), i32> {
+    if let Err(e) = func_ret_err(0_i32) {
+        return Err(e);
+    }
+    Ok(())
+}
+
+fn result_check_a() -> Result<(), i32> {
+    if let Err(e) = func_ret_err(0_i32) {
+        Err(e)
+    } else {
+        Ok(())
+    }
+}
+
+// Don't trigger
+fn result_check_b() -> Result<(), i32> {
+    if let Err(e) = Ok(1) {
+        Err(e)
+    } else {
+        Ok(())
+    }
+}
+
+fn result_check_c() -> Result<(), i32> {
+    let example = Ok(());
+    if let Err(e) = example {
+        Err(e)
+    } else {
+        example
+    }
+}
+
+// Don't trigger
+fn result_check_d() -> Result<(), i32> {
+    let example = Ok(1);
+    if let Err(e) = example {
+        Err(e)
+    } else {
+        Ok(())
+    }
+}
+
+fn main() { }
\ No newline at end of file
diff --git a/tests/ui/nop_match.rs b/tests/ui/nop_match.rs
new file mode 100644
index 00000000000..0e37bb85439
--- /dev/null
+++ b/tests/ui/nop_match.rs
@@ -0,0 +1,83 @@
+// run-rustfix
+#![warn(clippy::nop_match)]
+#![allow(clippy::manual_map)]
+#![allow(clippy::question_mark)]
+#![allow(dead_code)]
+
+fn option_match() -> Option<i32> {
+    match Some(1) {
+        Some(a) => Some(a),
+        None => None
+    }
+}
+
+fn result_match() -> Result<i32, i32> {
+    match Ok(1) {
+        Ok(a) => Ok(a),
+        Err(err) => Err(err)
+    }
+}
+
+fn option_check() -> Option<i32> {
+    if let Some(a) = Some(1) {
+        Some(a)
+    } else {
+        None
+    }
+}
+
+fn option_check_no_else() -> Option<i32> {
+    if let Some(a) = Some(1) {
+        return Some(a);
+    }
+    None
+}
+
+fn func_ret_err<T>(err: T) -> Result<(), T> {
+    Err(err)
+}
+
+fn result_check_no_else() -> Result<(), i32> {
+    if let Err(e) = func_ret_err(0_i32) {
+        return Err(e);
+    }
+    Ok(())
+}
+
+fn result_check_a() -> Result<(), i32> {
+    if let Err(e) = func_ret_err(0_i32) {
+        Err(e)
+    } else {
+        Ok(())
+    }
+}
+
+// Don't trigger
+fn result_check_b() -> Result<(), i32> {
+    if let Err(e) = Ok(1) {
+        Err(e)
+    } else {
+        Ok(())
+    }
+}
+
+fn result_check_c() -> Result<(), i32> {
+    let example = Ok(());
+    if let Err(e) = example {
+        Err(e)
+    } else {
+        example
+    }
+}
+
+// Don't trigger
+fn result_check_d() -> Result<(), i32> {
+    let example = Ok(1);
+    if let Err(e) = example {
+        Err(e)
+    } else {
+        Ok(())
+    }
+}
+
+fn main() { }
\ No newline at end of file
diff --git a/tests/ui/nop_match.stderr b/tests/ui/nop_match.stderr
new file mode 100644
index 00000000000..e69de29bb2d
-- 
cgit 1.4.1-3-g733a5


From 862211d540fe54deb46daa661716cb06a74151f8 Mon Sep 17 00:00:00 2001
From: Florian Nagel <florian.nagel@senacor.com>
Date: Fri, 25 Feb 2022 14:36:23 +0100
Subject: Disable ``[`new-without-default`]`` for new() methods that are marked
 with '#[doc(hidden)]'

Fixes issue #8152
---
 clippy_lints/src/new_without_default.rs |  4 ++++
 tests/ui/new_without_default.rs         | 10 ++++++++++
 2 files changed, 14 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/new_without_default.rs b/clippy_lints/src/new_without_default.rs
index 47121ad84f2..b40425bb635 100644
--- a/clippy_lints/src/new_without_default.rs
+++ b/clippy_lints/src/new_without_default.rs
@@ -85,6 +85,10 @@ impl<'tcx> LateLintPass<'tcx> for NewWithoutDefault {
                             // can't be implemented for unsafe new
                             return;
                         }
+                        if clippy_utils::is_doc_hidden(cx.tcx.hir().attrs(id)) {
+                            // shouldn't be implemented when it is hidden in docs
+                            return;
+                        }
                         if impl_item
                             .generics
                             .params
diff --git a/tests/ui/new_without_default.rs b/tests/ui/new_without_default.rs
index c76e3b42438..e94f99c95f4 100644
--- a/tests/ui/new_without_default.rs
+++ b/tests/ui/new_without_default.rs
@@ -201,4 +201,14 @@ pub mod issue7220 {
     }
 }
 
+// see issue #8152
+// This should not create any lints
+pub struct DocHidden;
+impl DocHidden {
+    #[doc(hidden)]
+    pub fn new() -> Self {
+        DocHidden
+    }
+}
+
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 2955db493ef9ceaf4cc9bcd3b83680c0206d001d Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Fri, 25 Feb 2022 15:38:06 +0000
Subject: Replace some more paths with diagnostic items

---
 clippy_lints/src/drop_forget_ref.rs             | 38 +++++++++++++----------
 clippy_lints/src/manual_bits.rs                 |  5 +--
 clippy_lints/src/mem_forget.rs                  |  4 +--
 clippy_lints/src/mem_replace.rs                 |  4 +--
 clippy_lints/src/methods/uninit_assumed_init.rs |  5 +--
 clippy_lints/src/redundant_clone.rs             |  2 +-
 clippy_lints/src/size_of_in_element_count.rs    |  4 +--
 clippy_lints/src/undropped_manually_drops.rs    | 12 +++++---
 clippy_utils/src/macros.rs                      | 41 +++++++++++++------------
 clippy_utils/src/paths.rs                       | 34 --------------------
 10 files changed, 63 insertions(+), 86 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/drop_forget_ref.rs b/clippy_lints/src/drop_forget_ref.rs
index a8f8e3d8a42..5c4b35fd4b9 100644
--- a/clippy_lints/src/drop_forget_ref.rs
+++ b/clippy_lints/src/drop_forget_ref.rs
@@ -1,11 +1,11 @@
 use clippy_utils::diagnostics::span_lint_and_note;
 use clippy_utils::ty::is_copy;
-use clippy_utils::{match_def_path, paths};
 use if_chain::if_chain;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::sym;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -128,14 +128,16 @@ impl<'tcx> LateLintPass<'tcx> for DropForgetRef {
                 let arg_ty = cx.typeck_results().expr_ty(arg);
 
                 if let ty::Ref(..) = arg_ty.kind() {
-                    if match_def_path(cx, def_id, &paths::DROP) {
-                        lint = DROP_REF;
-                        msg = DROP_REF_SUMMARY.to_string();
-                    } else if match_def_path(cx, def_id, &paths::MEM_FORGET) {
-                        lint = FORGET_REF;
-                        msg = FORGET_REF_SUMMARY.to_string();
-                    } else {
-                        return;
+                    match cx.tcx.get_diagnostic_name(def_id) {
+                        Some(sym::mem_drop) => {
+                            lint = DROP_REF;
+                            msg = DROP_REF_SUMMARY.to_string();
+                        },
+                        Some(sym::mem_forget) => {
+                            lint = FORGET_REF;
+                            msg = FORGET_REF_SUMMARY.to_string();
+                        },
+                        _ => return,
                     }
                     span_lint_and_note(cx,
                                        lint,
@@ -144,14 +146,16 @@ impl<'tcx> LateLintPass<'tcx> for DropForgetRef {
                                        Some(arg.span),
                                        &format!("argument has type `{}`", arg_ty));
                 } else if is_copy(cx, arg_ty) {
-                    if match_def_path(cx, def_id, &paths::DROP) {
-                        lint = DROP_COPY;
-                        msg = DROP_COPY_SUMMARY.to_string();
-                    } else if match_def_path(cx, def_id, &paths::MEM_FORGET) {
-                        lint = FORGET_COPY;
-                        msg = FORGET_COPY_SUMMARY.to_string();
-                    } else {
-                        return;
+                    match cx.tcx.get_diagnostic_name(def_id) {
+                        Some(sym::mem_drop) => {
+                            lint = DROP_COPY;
+                            msg = DROP_COPY_SUMMARY.to_string();
+                        },
+                        Some(sym::mem_forget) => {
+                            lint = FORGET_COPY;
+                            msg = FORGET_COPY_SUMMARY.to_string();
+                        },
+                        _ => return,
                     }
                     span_lint_and_note(cx,
                                        lint,
diff --git a/clippy_lints/src/manual_bits.rs b/clippy_lints/src/manual_bits.rs
index 809aa168a7a..dcf44303cf4 100644
--- a/clippy_lints/src/manual_bits.rs
+++ b/clippy_lints/src/manual_bits.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_opt;
-use clippy_utils::{match_def_path, meets_msrv, msrvs, paths};
+use clippy_utils::{meets_msrv, msrvs};
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind, GenericArg, QPath};
@@ -8,6 +8,7 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{self, Ty};
 use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::sym;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -99,7 +100,7 @@ fn get_size_of_ty<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<
         if let Some(GenericArg::Type(real_ty)) = args.args.get(0);
 
         if let Some(def_id) = cx.qpath_res(count_func_qpath, count_func.hir_id).opt_def_id();
-        if match_def_path(cx, def_id, &paths::MEM_SIZE_OF);
+        if cx.tcx.is_diagnostic_item(sym::mem_size_of, def_id);
         then {
             cx.typeck_results().node_substs(count_func.hir_id).types().next().map(|resolved_ty| (real_ty, resolved_ty))
         } else {
diff --git a/clippy_lints/src/mem_forget.rs b/clippy_lints/src/mem_forget.rs
index 5ffcfd4d264..d6c235b5a69 100644
--- a/clippy_lints/src/mem_forget.rs
+++ b/clippy_lints/src/mem_forget.rs
@@ -1,8 +1,8 @@
 use clippy_utils::diagnostics::span_lint;
-use clippy_utils::{match_def_path, paths};
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::sym;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -32,7 +32,7 @@ impl<'tcx> LateLintPass<'tcx> for MemForget {
         if let ExprKind::Call(path_expr, [ref first_arg, ..]) = e.kind {
             if let ExprKind::Path(ref qpath) = path_expr.kind {
                 if let Some(def_id) = cx.qpath_res(qpath, path_expr.hir_id).opt_def_id() {
-                    if match_def_path(cx, def_id, &paths::MEM_FORGET) {
+                    if cx.tcx.is_diagnostic_item(sym::mem_forget, def_id) {
                         let forgot_ty = cx.typeck_results().expr_ty(first_arg);
 
                         if forgot_ty.ty_adt_def().map_or(false, |def| def.has_dtor(cx.tcx)) {
diff --git a/clippy_lints/src/mem_replace.rs b/clippy_lints/src/mem_replace.rs
index a184806d021..054937e3e36 100644
--- a/clippy_lints/src/mem_replace.rs
+++ b/clippy_lints/src/mem_replace.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::{snippet, snippet_with_applicability};
 use clippy_utils::ty::is_non_aggregate_primitive_type;
-use clippy_utils::{is_default_equivalent, is_lang_ctor, match_def_path, meets_msrv, msrvs, paths};
+use clippy_utils::{is_default_equivalent, is_lang_ctor, meets_msrv, msrvs};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::LangItem::OptionNone;
@@ -249,7 +249,7 @@ impl<'tcx> LateLintPass<'tcx> for MemReplace {
             if let ExprKind::Call(func, func_args) = expr.kind;
             if let ExprKind::Path(ref func_qpath) = func.kind;
             if let Some(def_id) = cx.qpath_res(func_qpath, func.hir_id).opt_def_id();
-            if match_def_path(cx, def_id, &paths::MEM_REPLACE);
+            if cx.tcx.is_diagnostic_item(sym::mem_replace, def_id);
             if let [dest, src] = func_args;
             then {
                 check_replace_option_with_none(cx, src, dest, expr.span);
diff --git a/clippy_lints/src/methods/uninit_assumed_init.rs b/clippy_lints/src/methods/uninit_assumed_init.rs
index ce89189bce9..77d21f1d373 100644
--- a/clippy_lints/src/methods/uninit_assumed_init.rs
+++ b/clippy_lints/src/methods/uninit_assumed_init.rs
@@ -1,8 +1,9 @@
 use clippy_utils::diagnostics::span_lint;
-use clippy_utils::{is_expr_path_def_path, paths, ty::is_uninit_value_valid_for_ty};
+use clippy_utils::{is_expr_diagnostic_item, ty::is_uninit_value_valid_for_ty};
 use if_chain::if_chain;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
+use rustc_span::sym;
 
 use super::UNINIT_ASSUMED_INIT;
 
@@ -11,7 +12,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr
     if_chain! {
         if let hir::ExprKind::Call(callee, args) = recv.kind;
         if args.is_empty();
-        if is_expr_path_def_path(cx, callee, &paths::MEM_MAYBEUNINIT_UNINIT);
+        if is_expr_diagnostic_item(cx, callee, sym::maybe_uninit_uninit);
         if !is_uninit_value_valid_for_ty(cx, cx.typeck_results().expr_ty_adjusted(expr));
         then {
             span_lint(
diff --git a/clippy_lints/src/redundant_clone.rs b/clippy_lints/src/redundant_clone.rs
index 3e0e32857f1..b3988973256 100644
--- a/clippy_lints/src/redundant_clone.rs
+++ b/clippy_lints/src/redundant_clone.rs
@@ -135,7 +135,7 @@ impl<'tcx> LateLintPass<'tcx> for RedundantClone {
             }
 
             if let ty::Adt(def, _) = arg_ty.kind() {
-                if match_def_path(cx, def.did, &paths::MEM_MANUALLY_DROP) {
+                if def.is_manually_drop() {
                     continue;
                 }
             }
diff --git a/clippy_lints/src/size_of_in_element_count.rs b/clippy_lints/src/size_of_in_element_count.rs
index f3515ea3c2d..3d7dc49b406 100644
--- a/clippy_lints/src/size_of_in_element_count.rs
+++ b/clippy_lints/src/size_of_in_element_count.rs
@@ -9,6 +9,7 @@ use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{self, Ty, TypeAndMut};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::sym;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -44,8 +45,7 @@ fn get_size_of_ty<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, inverted:
                 if !inverted;
                 if let ExprKind::Path(ref count_func_qpath) = count_func.kind;
                 if let Some(def_id) = cx.qpath_res(count_func_qpath, count_func.hir_id).opt_def_id();
-                if match_def_path(cx, def_id, &paths::MEM_SIZE_OF)
-                    || match_def_path(cx, def_id, &paths::MEM_SIZE_OF_VAL);
+                if matches!(cx.tcx.get_diagnostic_name(def_id), Some(sym::mem_size_of | sym::mem_size_of_val));
                 then {
                     cx.typeck_results().node_substs(count_func.hir_id).types().next()
                 } else {
diff --git a/clippy_lints/src/undropped_manually_drops.rs b/clippy_lints/src/undropped_manually_drops.rs
index 7557e14d11f..db652766705 100644
--- a/clippy_lints/src/undropped_manually_drops.rs
+++ b/clippy_lints/src/undropped_manually_drops.rs
@@ -1,9 +1,10 @@
 use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::path_res;
 use clippy_utils::ty::is_type_lang_item;
-use clippy_utils::{match_function_call, paths};
-use rustc_hir::{lang_items, Expr};
+use rustc_hir::{lang_items, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::sym;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -38,9 +39,12 @@ declare_lint_pass!(UndroppedManuallyDrops => [UNDROPPED_MANUALLY_DROPS]);
 
 impl<'tcx> LateLintPass<'tcx> for UndroppedManuallyDrops {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if let Some([arg_0, ..]) = match_function_call(cx, expr, &paths::DROP) {
+        if_chain! {
+            if let ExprKind::Call(fun, [arg_0, ..]) = expr.kind;
+            if path_res(cx, fun).opt_def_id() == cx.tcx.get_diagnostic_item(sym::mem_drop);
             let ty = cx.typeck_results().expr_ty(arg_0);
-            if is_type_lang_item(cx, ty, lang_items::LangItem::ManuallyDrop) {
+            if is_type_lang_item(cx, ty, lang_items::LangItem::ManuallyDrop);
+            then {
                 span_lint_and_help(
                     cx,
                     UNDROPPED_MANUALLY_DROPS,
diff --git a/clippy_utils/src/macros.rs b/clippy_utils/src/macros.rs
index 256f884ae19..e7d4c5a4952 100644
--- a/clippy_utils/src/macros.rs
+++ b/clippy_utils/src/macros.rs
@@ -1,7 +1,6 @@
 #![allow(clippy::similar_names)] // `expr` and `expn`
 
 use crate::visitors::expr_visitor_no_bodies;
-use crate::{match_def_path, paths};
 
 use arrayvec::ArrayVec;
 use if_chain::if_chain;
@@ -14,29 +13,31 @@ use rustc_span::hygiene::{self, MacroKind, SyntaxContext};
 use rustc_span::{sym, ExpnData, ExpnId, ExpnKind, Span, Symbol};
 use std::ops::ControlFlow;
 
-const FORMAT_MACRO_PATHS: &[&[&str]] = &[
-    &paths::FORMAT_ARGS_MACRO,
-    &paths::ASSERT_EQ_MACRO,
-    &paths::ASSERT_MACRO,
-    &paths::ASSERT_NE_MACRO,
-    &paths::EPRINT_MACRO,
-    &paths::EPRINTLN_MACRO,
-    &paths::PRINT_MACRO,
-    &paths::PRINTLN_MACRO,
-    &paths::WRITE_MACRO,
-    &paths::WRITELN_MACRO,
+const FORMAT_MACRO_DIAG_ITEMS: &[Symbol] = &[
+    sym::assert_eq_macro,
+    sym::assert_macro,
+    sym::assert_ne_macro,
+    sym::debug_assert_eq_macro,
+    sym::debug_assert_macro,
+    sym::debug_assert_ne_macro,
+    sym::eprint_macro,
+    sym::eprintln_macro,
+    sym::format_args_macro,
+    sym::format_macro,
+    sym::print_macro,
+    sym::println_macro,
+    sym::std_panic_macro,
+    sym::write_macro,
+    sym::writeln_macro,
 ];
 
-const FORMAT_MACRO_DIAG_ITEMS: &[Symbol] = &[sym::format_macro, sym::std_panic_macro];
-
 /// Returns true if a given Macro `DefId` is a format macro (e.g. `println!`)
 pub fn is_format_macro(cx: &LateContext<'_>, macro_def_id: DefId) -> bool {
-    FORMAT_MACRO_PATHS
-        .iter()
-        .any(|path| match_def_path(cx, macro_def_id, path))
-        || FORMAT_MACRO_DIAG_ITEMS
-            .iter()
-            .any(|diag_item| cx.tcx.is_diagnostic_item(*diag_item, macro_def_id))
+    if let Some(name) = cx.tcx.get_diagnostic_name(macro_def_id) {
+        FORMAT_MACRO_DIAG_ITEMS.contains(&name)
+    } else {
+        false
+    }
 }
 
 /// A macro call, like `vec![1, 2, 3]`.
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index b54bd3a4fef..2778e30388e 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -16,44 +16,27 @@ pub const APPLICABILITY_VALUES: [[&str; 3]; 4] = [
 #[cfg(feature = "internal")]
 pub const DIAGNOSTIC_BUILDER: [&str; 3] = ["rustc_errors", "diagnostic_builder", "DiagnosticBuilder"];
 pub const ARC_PTR_EQ: [&str; 4] = ["alloc", "sync", "Arc", "ptr_eq"];
-#[allow(clippy::invalid_paths)] // `check_path` does not seem to work for macros
-pub const ASSERT_EQ_MACRO: [&str; 3] = ["core", "macros", "assert_eq"];
-#[allow(clippy::invalid_paths)] // `check_path` does not seem to work for macros
-pub const ASSERT_MACRO: [&str; 4] = ["core", "macros", "builtin", "assert"];
-#[allow(clippy::invalid_paths)] // `check_path` does not seem to work for macros
-pub const ASSERT_NE_MACRO: [&str; 3] = ["core", "macros", "assert_ne"];
 pub const ASMUT_TRAIT: [&str; 3] = ["core", "convert", "AsMut"];
 pub const ASREF_TRAIT: [&str; 3] = ["core", "convert", "AsRef"];
-/// Preferably use the diagnostic item `sym::Borrow` where possible
-pub const BORROW_TRAIT: [&str; 3] = ["core", "borrow", "Borrow"];
-pub const BORROW_MUT_TRAIT: [&str; 3] = ["core", "borrow", "BorrowMut"];
 pub const BTREEMAP_CONTAINS_KEY: [&str; 6] = ["alloc", "collections", "btree", "map", "BTreeMap", "contains_key"];
 pub const BTREEMAP_ENTRY: [&str; 6] = ["alloc", "collections", "btree", "map", "entry", "Entry"];
 pub const BTREEMAP_INSERT: [&str; 6] = ["alloc", "collections", "btree", "map", "BTreeMap", "insert"];
 pub const CLONE_TRAIT_METHOD: [&str; 4] = ["core", "clone", "Clone", "clone"];
 pub const COW: [&str; 3] = ["alloc", "borrow", "Cow"];
 pub const CSTRING_AS_C_STR: [&str; 5] = ["std", "ffi", "c_str", "CString", "as_c_str"];
-pub const DEBUG_TRAIT: [&str; 3] = ["core", "fmt", "Debug"];
 pub const DEFAULT_TRAIT_METHOD: [&str; 4] = ["core", "default", "Default", "default"];
 pub const DEREF_MUT_TRAIT_METHOD: [&str; 5] = ["core", "ops", "deref", "DerefMut", "deref_mut"];
 /// Preferably use the diagnostic item `sym::deref_method` where possible
 pub const DEREF_TRAIT_METHOD: [&str; 5] = ["core", "ops", "deref", "Deref", "deref"];
 pub const DIR_BUILDER: [&str; 3] = ["std", "fs", "DirBuilder"];
 pub const DISPLAY_TRAIT: [&str; 3] = ["core", "fmt", "Display"];
-pub const DROP: [&str; 3] = ["core", "mem", "drop"];
 #[cfg(feature = "internal")]
 pub const EARLY_CONTEXT: [&str; 2] = ["rustc_lint", "EarlyContext"];
-#[allow(clippy::invalid_paths)] // `check_path` does not seem to work for macros
-pub const EPRINT_MACRO: [&str; 3] = ["std", "macros", "eprint"];
-#[allow(clippy::invalid_paths)] // `check_path` does not seem to work for macros
-pub const EPRINTLN_MACRO: [&str; 3] = ["std", "macros", "eprintln"];
 pub const EXIT: [&str; 3] = ["std", "process", "exit"];
 pub const F32_EPSILON: [&str; 4] = ["core", "f32", "<impl f32>", "EPSILON"];
 pub const F64_EPSILON: [&str; 4] = ["core", "f64", "<impl f64>", "EPSILON"];
 pub const FILE: [&str; 3] = ["std", "fs", "File"];
 pub const FILE_TYPE: [&str; 3] = ["std", "fs", "FileType"];
-#[allow(clippy::invalid_paths)] // `check_path` does not seem to work for macros
-pub const FORMAT_ARGS_MACRO: [&str; 4] = ["core", "macros", "builtin", "format_args"];
 pub const FROM_FROM: [&str; 4] = ["core", "convert", "From", "from"];
 pub const FROM_ITERATOR_METHOD: [&str; 6] = ["core", "iter", "traits", "collect", "FromIterator", "from_iter"];
 pub const FROM_STR_METHOD: [&str; 5] = ["core", "str", "traits", "FromStr", "from_str"];
@@ -85,17 +68,8 @@ pub const KW_MODULE: [&str; 3] = ["rustc_span", "symbol", "kw"];
 pub const LATE_CONTEXT: [&str; 2] = ["rustc_lint", "LateContext"];
 #[cfg(feature = "internal")]
 pub const LINT: [&str; 2] = ["rustc_lint_defs", "Lint"];
-pub const MEM_DISCRIMINANT: [&str; 3] = ["core", "mem", "discriminant"];
-pub const MEM_FORGET: [&str; 3] = ["core", "mem", "forget"];
-pub const MEM_MANUALLY_DROP: [&str; 4] = ["core", "mem", "manually_drop", "ManuallyDrop"];
-pub const MEM_MAYBEUNINIT: [&str; 4] = ["core", "mem", "maybe_uninit", "MaybeUninit"];
-pub const MEM_MAYBEUNINIT_UNINIT: [&str; 5] = ["core", "mem", "maybe_uninit", "MaybeUninit", "uninit"];
-pub const MEM_REPLACE: [&str; 3] = ["core", "mem", "replace"];
-pub const MEM_SIZE_OF: [&str; 3] = ["core", "mem", "size_of"];
-pub const MEM_SIZE_OF_VAL: [&str; 3] = ["core", "mem", "size_of_val"];
 pub const MUTEX_GUARD: [&str; 4] = ["std", "sync", "mutex", "MutexGuard"];
 pub const OPEN_OPTIONS: [&str; 3] = ["std", "fs", "OpenOptions"];
-pub const OPS_MODULE: [&str; 2] = ["core", "ops"];
 /// Preferably use the diagnostic item `sym::Option` where possible
 pub const OPTION: [&str; 3] = ["core", "option", "Option"];
 pub const OPTION_NONE: [&str; 4] = ["core", "option", "Option", "None"];
@@ -116,10 +90,6 @@ pub const PERMISSIONS_FROM_MODE: [&str; 6] = ["std", "os", "unix", "fs", "Permis
 pub const POLL: [&str; 4] = ["core", "task", "poll", "Poll"];
 pub const POLL_PENDING: [&str; 5] = ["core", "task", "poll", "Poll", "Pending"];
 pub const POLL_READY: [&str; 5] = ["core", "task", "poll", "Poll", "Ready"];
-#[allow(clippy::invalid_paths)] // `check_path` does not seem to work for macros
-pub const PRINT_MACRO: [&str; 3] = ["std", "macros", "print"];
-#[allow(clippy::invalid_paths)] // `check_path` does not seem to work for macros
-pub const PRINTLN_MACRO: [&str; 3] = ["std", "macros", "println"];
 pub const PTR_COPY: [&str; 3] = ["core", "intrinsics", "copy"];
 pub const PTR_COPY_NONOVERLAPPING: [&str; 3] = ["core", "intrinsics", "copy_nonoverlapping"];
 pub const PTR_EQ: [&str; 3] = ["core", "ptr", "eq"];
@@ -200,8 +170,4 @@ pub const VEC_NEW: [&str; 4] = ["alloc", "vec", "Vec", "new"];
 pub const VEC_RESIZE: [&str; 4] = ["alloc", "vec", "Vec", "resize"];
 pub const WEAK_ARC: [&str; 3] = ["alloc", "sync", "Weak"];
 pub const WEAK_RC: [&str; 3] = ["alloc", "rc", "Weak"];
-#[allow(clippy::invalid_paths)] // `check_path` does not seem to work for macros
-pub const WRITE_MACRO: [&str; 3] = ["core", "macros", "write"];
-#[allow(clippy::invalid_paths)] // `check_path` does not seem to work for macros
-pub const WRITELN_MACRO: [&str; 3] = ["core", "macros", "writeln"];
 pub const PTR_NON_NULL: [&str; 4] = ["core", "ptr", "non_null", "NonNull"];
-- 
cgit 1.4.1-3-g733a5


From bcbb07f4dc3c147b9f4259df7f8c6a8b2bf91729 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Thu, 17 Feb 2022 11:20:47 +0000
Subject: Rename RecursiveFormatImpl to FormatImpl

---
 clippy_lints/src/format_impl.rs              | 189 ++++++++++++++++++++++++++
 clippy_lints/src/lib.register_all.rs         |   2 +-
 clippy_lints/src/lib.register_correctness.rs |   2 +-
 clippy_lints/src/lib.register_lints.rs       |   2 +-
 clippy_lints/src/lib.rs                      |   4 +-
 clippy_lints/src/recursive_format_impl.rs    | 190 ---------------------------
 6 files changed, 194 insertions(+), 195 deletions(-)
 create mode 100644 clippy_lints/src/format_impl.rs
 delete mode 100644 clippy_lints/src/recursive_format_impl.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/format_impl.rs b/clippy_lints/src/format_impl.rs
new file mode 100644
index 00000000000..02b2d721939
--- /dev/null
+++ b/clippy_lints/src/format_impl.rs
@@ -0,0 +1,189 @@
+use clippy_utils::diagnostics::span_lint;
+use clippy_utils::macros::{is_format_macro, root_macro_call_first_node, FormatArgsArg, FormatArgsExpn};
+use clippy_utils::{is_diag_trait_item, path_to_local, peel_ref_operators};
+use if_chain::if_chain;
+use rustc_hir::{Expr, ExprKind, Impl, Item, ItemKind, QPath};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::{sym, symbol::kw, Symbol};
+
+#[derive(Clone, Copy)]
+enum FormatTrait {
+    Debug,
+    Display,
+}
+
+impl FormatTrait {
+    fn name(self) -> Symbol {
+        match self {
+            FormatTrait::Debug => sym::Debug,
+            FormatTrait::Display => sym::Display,
+        }
+    }
+}
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for format trait implementations (e.g. `Display`) with a recursive call to itself
+    /// which uses `self` as a parameter.
+    /// This is typically done indirectly with the `write!` macro or with `to_string()`.
+    ///
+    /// ### Why is this bad?
+    /// This will lead to infinite recursion and a stack overflow.
+    ///
+    /// ### Example
+    ///
+    /// ```rust
+    /// use std::fmt;
+    ///
+    /// struct Structure(i32);
+    /// impl fmt::Display for Structure {
+    ///     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    ///         write!(f, "{}", self.to_string())
+    ///     }
+    /// }
+    ///
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// use std::fmt;
+    ///
+    /// struct Structure(i32);
+    /// impl fmt::Display for Structure {
+    ///     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    ///         write!(f, "{}", self.0)
+    ///     }
+    /// }
+    /// ```
+    #[clippy::version = "1.48.0"]
+    pub RECURSIVE_FORMAT_IMPL,
+    correctness,
+    "Format trait method called while implementing the same Format trait"
+}
+
+#[derive(Default)]
+pub struct FormatImpl {
+    // Whether we are inside Display or Debug trait impl - None for neither
+    format_trait_impl: Option<FormatTrait>,
+}
+
+impl FormatImpl {
+    pub fn new() -> Self {
+        Self {
+            format_trait_impl: None,
+        }
+    }
+}
+
+impl_lint_pass!(FormatImpl => [RECURSIVE_FORMAT_IMPL]);
+
+impl<'tcx> LateLintPass<'tcx> for FormatImpl {
+    fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
+        if let Some(format_trait_impl) = is_format_trait_impl(cx, item) {
+            self.format_trait_impl = Some(format_trait_impl);
+        }
+    }
+
+    fn check_item_post(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
+        // Assume no nested Impl of Debug and Display within eachother
+        if is_format_trait_impl(cx, item).is_some() {
+            self.format_trait_impl = None;
+        }
+    }
+
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        match self.format_trait_impl {
+            Some(FormatTrait::Display) => {
+                check_to_string_in_display(cx, expr);
+                check_self_in_format_args(cx, expr, FormatTrait::Display);
+            },
+            Some(FormatTrait::Debug) => {
+                check_self_in_format_args(cx, expr, FormatTrait::Debug);
+            },
+            None => {},
+        }
+    }
+}
+
+fn check_to_string_in_display(cx: &LateContext<'_>, expr: &Expr<'_>) {
+    if_chain! {
+        // Get the hir_id of the object we are calling the method on
+        if let ExprKind::MethodCall(path, [ref self_arg, ..], _) = expr.kind;
+        // Is the method to_string() ?
+        if path.ident.name == sym!(to_string);
+        // Is the method a part of the ToString trait? (i.e. not to_string() implemented
+        // separately)
+        if let Some(expr_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
+        if is_diag_trait_item(cx, expr_def_id, sym::ToString);
+        // Is the method is called on self
+        if let ExprKind::Path(QPath::Resolved(_, path)) = self_arg.kind;
+        if let [segment] = path.segments;
+        if segment.ident.name == kw::SelfLower;
+        then {
+            span_lint(
+                cx,
+                RECURSIVE_FORMAT_IMPL,
+                expr.span,
+                "using `self.to_string` in `fmt::Display` implementation will cause infinite recursion",
+            );
+        }
+    }
+}
+
+fn check_self_in_format_args<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, impl_trait: FormatTrait) {
+    // Check each arg in format calls - do we ever use Display on self (directly or via deref)?
+    if_chain! {
+        if let Some(outer_macro) = root_macro_call_first_node(cx, expr);
+        if let macro_def_id = outer_macro.def_id;
+        if let Some(format_args) = FormatArgsExpn::find_nested(cx, expr, outer_macro.expn);
+        if is_format_macro(cx, macro_def_id);
+        if let Some(args) = format_args.args();
+        then {
+            for arg in args {
+                if arg.format_trait != impl_trait.name() {
+                    continue;
+                }
+                check_format_arg_self(cx, expr, &arg, impl_trait);
+            }
+        }
+    }
+}
+
+fn check_format_arg_self(cx: &LateContext<'_>, expr: &Expr<'_>, arg: &FormatArgsArg<'_>, impl_trait: FormatTrait) {
+    // Handle multiple dereferencing of references e.g. &&self
+    // Handle dereference of &self -> self that is equivalent (i.e. via *self in fmt() impl)
+    // Since the argument to fmt is itself a reference: &self
+    let reference = peel_ref_operators(cx, arg.value);
+    let map = cx.tcx.hir();
+    // Is the reference self?
+    let symbol_ident = impl_trait.name().to_ident_string();
+    if path_to_local(reference).map(|x| map.name(x)) == Some(kw::SelfLower) {
+        span_lint(
+            cx,
+            RECURSIVE_FORMAT_IMPL,
+            expr.span,
+            &format!(
+                "using `self` as `{}` in `impl {}` will cause infinite recursion",
+                &symbol_ident, &symbol_ident
+            ),
+        );
+    }
+}
+
+fn is_format_trait_impl(cx: &LateContext<'_>, item: &Item<'_>) -> Option<FormatTrait> {
+    if_chain! {
+        // Are we at an Impl?
+        if let ItemKind::Impl(Impl { of_trait: Some(trait_ref), .. }) = &item.kind;
+        if let Some(did) = trait_ref.trait_def_id();
+        if let Some(name) = cx.tcx.get_diagnostic_name(did);
+        then {
+            // Is Impl for Debug or Display?
+            match name {
+                sym::Debug => Some(FormatTrait::Debug),
+                sym::Display => Some(FormatTrait::Display),
+                _ => None,
+            }
+        } else {
+            None
+        }
+    }
+}
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index c6f8470cd7d..b2d9889ba86 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -68,6 +68,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(format::USELESS_FORMAT),
     LintId::of(format_args::FORMAT_IN_FORMAT_ARGS),
     LintId::of(format_args::TO_STRING_IN_FORMAT_ARGS),
+    LintId::of(format_impl::RECURSIVE_FORMAT_IMPL),
     LintId::of(formatting::POSSIBLE_MISSING_COMMA),
     LintId::of(formatting::SUSPICIOUS_ASSIGNMENT_FORMATTING),
     LintId::of(formatting::SUSPICIOUS_ELSE_FORMATTING),
@@ -244,7 +245,6 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(ranges::MANUAL_RANGE_CONTAINS),
     LintId::of(ranges::RANGE_ZIP_WITH_LEN),
     LintId::of(ranges::REVERSED_EMPTY_RANGES),
-    LintId::of(recursive_format_impl::RECURSIVE_FORMAT_IMPL),
     LintId::of(redundant_clone::REDUNDANT_CLONE),
     LintId::of(redundant_closure_call::REDUNDANT_CLOSURE_CALL),
     LintId::of(redundant_field_names::REDUNDANT_FIELD_NAMES),
diff --git a/clippy_lints/src/lib.register_correctness.rs b/clippy_lints/src/lib.register_correctness.rs
index 18fe44282ed..35b1e644a8a 100644
--- a/clippy_lints/src/lib.register_correctness.rs
+++ b/clippy_lints/src/lib.register_correctness.rs
@@ -24,6 +24,7 @@ store.register_group(true, "clippy::correctness", Some("clippy_correctness"), ve
     LintId::of(enum_clike::ENUM_CLIKE_UNPORTABLE_VARIANT),
     LintId::of(eq_op::EQ_OP),
     LintId::of(erasing_op::ERASING_OP),
+    LintId::of(format_impl::RECURSIVE_FORMAT_IMPL),
     LintId::of(formatting::POSSIBLE_MISSING_COMMA),
     LintId::of(functions::NOT_UNSAFE_PTR_ARG_DEREF),
     LintId::of(if_let_mutex::IF_LET_MUTEX),
@@ -52,7 +53,6 @@ store.register_group(true, "clippy::correctness", Some("clippy_correctness"), ve
     LintId::of(ptr::INVALID_NULL_PTR_USAGE),
     LintId::of(ptr::MUT_FROM_REF),
     LintId::of(ranges::REVERSED_EMPTY_RANGES),
-    LintId::of(recursive_format_impl::RECURSIVE_FORMAT_IMPL),
     LintId::of(regex::INVALID_REGEX),
     LintId::of(self_assignment::SELF_ASSIGNMENT),
     LintId::of(serde_api::SERDE_API_MISUSE),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 75ef1b0a9d5..1243fc978b7 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -152,6 +152,7 @@ store.register_lints(&[
     format::USELESS_FORMAT,
     format_args::FORMAT_IN_FORMAT_ARGS,
     format_args::TO_STRING_IN_FORMAT_ARGS,
+    format_impl::RECURSIVE_FORMAT_IMPL,
     formatting::POSSIBLE_MISSING_COMMA,
     formatting::SUSPICIOUS_ASSIGNMENT_FORMATTING,
     formatting::SUSPICIOUS_ELSE_FORMATTING,
@@ -417,7 +418,6 @@ store.register_lints(&[
     ranges::RANGE_PLUS_ONE,
     ranges::RANGE_ZIP_WITH_LEN,
     ranges::REVERSED_EMPTY_RANGES,
-    recursive_format_impl::RECURSIVE_FORMAT_IMPL,
     redundant_clone::REDUNDANT_CLONE,
     redundant_closure_call::REDUNDANT_CLOSURE_CALL,
     redundant_else::REDUNDANT_ELSE,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index a21a87899aa..230e2b2ccdf 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -226,6 +226,7 @@ mod float_literal;
 mod floating_point_arithmetic;
 mod format;
 mod format_args;
+mod format_impl;
 mod formatting;
 mod from_over_into;
 mod from_str_radix_10;
@@ -333,7 +334,6 @@ mod ptr_eq;
 mod ptr_offset_with_cast;
 mod question_mark;
 mod ranges;
-mod recursive_format_impl;
 mod redundant_clone;
 mod redundant_closure_call;
 mod redundant_else;
@@ -705,7 +705,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(modulo_arithmetic::ModuloArithmetic));
     store.register_early_pass(|| Box::new(reference::DerefAddrOf));
     store.register_early_pass(|| Box::new(double_parens::DoubleParens));
-    store.register_late_pass(|| Box::new(recursive_format_impl::RecursiveFormatImpl::new()));
+    store.register_late_pass(|| Box::new(format_impl::FormatImpl::new()));
     store.register_early_pass(|| Box::new(unsafe_removed_from_name::UnsafeNameRemoval));
     store.register_early_pass(|| Box::new(else_if_without_else::ElseIfWithoutElse));
     store.register_early_pass(|| Box::new(int_plus_one::IntPlusOne));
diff --git a/clippy_lints/src/recursive_format_impl.rs b/clippy_lints/src/recursive_format_impl.rs
deleted file mode 100644
index 5bb9740749b..00000000000
--- a/clippy_lints/src/recursive_format_impl.rs
+++ /dev/null
@@ -1,190 +0,0 @@
-use clippy_utils::diagnostics::span_lint;
-use clippy_utils::macros::{is_format_macro, root_macro_call_first_node, FormatArgsArg, FormatArgsExpn};
-use clippy_utils::{is_diag_trait_item, path_to_local, peel_ref_operators};
-use if_chain::if_chain;
-use rustc_hir::{Expr, ExprKind, Impl, Item, ItemKind, QPath};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::{sym, symbol::kw, Symbol};
-
-#[derive(Clone, Copy)]
-enum FormatTrait {
-    Debug,
-    Display,
-}
-
-impl FormatTrait {
-    fn name(self) -> Symbol {
-        match self {
-            FormatTrait::Debug => sym::Debug,
-            FormatTrait::Display => sym::Display,
-        }
-    }
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for format trait implementations (e.g. `Display`) with a recursive call to itself
-    /// which uses `self` as a parameter.
-    /// This is typically done indirectly with the `write!` macro or with `to_string()`.
-    ///
-    /// ### Why is this bad?
-    /// This will lead to infinite recursion and a stack overflow.
-    ///
-    /// ### Example
-    ///
-    /// ```rust
-    /// use std::fmt;
-    ///
-    /// struct Structure(i32);
-    /// impl fmt::Display for Structure {
-    ///     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-    ///         write!(f, "{}", self.to_string())
-    ///     }
-    /// }
-    ///
-    /// ```
-    /// Use instead:
-    /// ```rust
-    /// use std::fmt;
-    ///
-    /// struct Structure(i32);
-    /// impl fmt::Display for Structure {
-    ///     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-    ///         write!(f, "{}", self.0)
-    ///     }
-    /// }
-    /// ```
-    #[clippy::version = "1.48.0"]
-    pub RECURSIVE_FORMAT_IMPL,
-    correctness,
-    "Format trait method called while implementing the same Format trait"
-}
-
-#[derive(Default)]
-pub struct RecursiveFormatImpl {
-    // Whether we are inside Display or Debug trait impl - None for neither
-    format_trait_impl: Option<FormatTrait>,
-}
-
-impl RecursiveFormatImpl {
-    pub fn new() -> Self {
-        Self {
-            format_trait_impl: None,
-        }
-    }
-}
-
-impl_lint_pass!(RecursiveFormatImpl => [RECURSIVE_FORMAT_IMPL]);
-
-impl<'tcx> LateLintPass<'tcx> for RecursiveFormatImpl {
-    fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
-        if let Some(format_trait_impl) = is_format_trait_impl(cx, item) {
-            self.format_trait_impl = Some(format_trait_impl);
-        }
-    }
-
-    fn check_item_post(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
-        // Assume no nested Impl of Debug and Display within eachother
-        if is_format_trait_impl(cx, item).is_some() {
-            self.format_trait_impl = None;
-        }
-    }
-
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        match self.format_trait_impl {
-            Some(FormatTrait::Display) => {
-                check_to_string_in_display(cx, expr);
-                check_self_in_format_args(cx, expr, FormatTrait::Display);
-            },
-            Some(FormatTrait::Debug) => {
-                check_self_in_format_args(cx, expr, FormatTrait::Debug);
-            },
-            None => {},
-        }
-    }
-}
-
-fn check_to_string_in_display(cx: &LateContext<'_>, expr: &Expr<'_>) {
-    if_chain! {
-        // Get the hir_id of the object we are calling the method on
-        if let ExprKind::MethodCall(path, [ref self_arg, ..], _) = expr.kind;
-        // Is the method to_string() ?
-        if path.ident.name == sym!(to_string);
-        // Is the method a part of the ToString trait? (i.e. not to_string() implemented
-        // separately)
-        if let Some(expr_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
-        if is_diag_trait_item(cx, expr_def_id, sym::ToString);
-        // Is the method is called on self
-        if let ExprKind::Path(QPath::Resolved(_, path)) = self_arg.kind;
-        if let [segment] = path.segments;
-        if segment.ident.name == kw::SelfLower;
-        then {
-            span_lint(
-                cx,
-                RECURSIVE_FORMAT_IMPL,
-                expr.span,
-                "using `self.to_string` in `fmt::Display` implementation will cause infinite recursion",
-            );
-        }
-    }
-}
-
-fn check_self_in_format_args<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, impl_trait: FormatTrait) {
-    // Check each arg in format calls - do we ever use Display on self (directly or via deref)?
-    if_chain! {
-        if let Some(outer_macro) = root_macro_call_first_node(cx, expr);
-        if let macro_def_id = outer_macro.def_id;
-        if let Some(format_args) = FormatArgsExpn::find_nested(cx, expr, outer_macro.expn);
-        if is_format_macro(cx, macro_def_id);
-        if let Some(args) = format_args.args();
-        then {
-            for arg in args {
-                if arg.format_trait != impl_trait.name() {
-                    continue;
-                }
-                check_format_arg_self(cx, expr, &arg, impl_trait);
-            }
-        }
-    }
-}
-
-fn check_format_arg_self(cx: &LateContext<'_>, expr: &Expr<'_>, arg: &FormatArgsArg<'_>, impl_trait: FormatTrait) {
-    // Handle multiple dereferencing of references e.g. &&self
-    // Handle dereference of &self -> self that is equivalent (i.e. via *self in fmt() impl)
-    // Since the argument to fmt is itself a reference: &self
-    let reference = peel_ref_operators(cx, arg.value);
-    let map = cx.tcx.hir();
-    // Is the reference self?
-    let symbol_ident = impl_trait.name().to_ident_string();
-    if path_to_local(reference).map(|x| map.name(x)) == Some(kw::SelfLower) {
-        span_lint(
-            cx,
-            RECURSIVE_FORMAT_IMPL,
-            expr.span,
-            &format!(
-                "using `self` as `{}` in `impl {}` will cause infinite recursion",
-                &symbol_ident, &symbol_ident
-            ),
-        );
-    }
-}
-
-fn is_format_trait_impl(cx: &LateContext<'_>, item: &Item<'_>) -> Option<FormatTrait> {
-    if_chain! {
-        // Are we at an Impl?
-        if let ItemKind::Impl(Impl { of_trait: Some(trait_ref), .. }) = &item.kind;
-        if let Some(did) = trait_ref.trait_def_id();
-        if let Some(name) = cx.tcx.get_diagnostic_name(did);
-        then {
-            // Is Impl for Debug or Display?
-            match name {
-                sym::Debug => Some(FormatTrait::Debug),
-                sym::Display => Some(FormatTrait::Display),
-                _ => None,
-            }
-        } else {
-            None
-        }
-    }
-}
-- 
cgit 1.4.1-3-g733a5


From 52f3d61a2a97a84c6aa96b7b4cb80aaff1c5f898 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Thu, 17 Feb 2022 15:33:07 +0000
Subject: Add `print_in_format_impl` lint

---
 CHANGELOG.md                                |   1 +
 clippy_lints/src/format_impl.rs             | 160 +++++++++++++++++++---------
 clippy_lints/src/lib.register_all.rs        |   1 +
 clippy_lints/src/lib.register_lints.rs      |   1 +
 clippy_lints/src/lib.register_suspicious.rs |   1 +
 tests/ui/print_in_format_impl.rs            |  58 ++++++++++
 tests/ui/print_in_format_impl.stderr        |  46 ++++++++
 7 files changed, 220 insertions(+), 48 deletions(-)
 create mode 100644 tests/ui/print_in_format_impl.rs
 create mode 100644 tests/ui/print_in_format_impl.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 1b52a6fcd05..35983b7fb50 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3370,6 +3370,7 @@ Released 2018-09-13
 [`pattern_type_mismatch`]: https://rust-lang.github.io/rust-clippy/master/index.html#pattern_type_mismatch
 [`possible_missing_comma`]: https://rust-lang.github.io/rust-clippy/master/index.html#possible_missing_comma
 [`precedence`]: https://rust-lang.github.io/rust-clippy/master/index.html#precedence
+[`print_in_format_impl`]: https://rust-lang.github.io/rust-clippy/master/index.html#print_in_format_impl
 [`print_literal`]: https://rust-lang.github.io/rust-clippy/master/index.html#print_literal
 [`print_stderr`]: https://rust-lang.github.io/rust-clippy/master/index.html#print_stderr
 [`print_stdout`]: https://rust-lang.github.io/rust-clippy/master/index.html#print_stdout
diff --git a/clippy_lints/src/format_impl.rs b/clippy_lints/src/format_impl.rs
index 02b2d721939..ef8be9e878f 100644
--- a/clippy_lints/src/format_impl.rs
+++ b/clippy_lints/src/format_impl.rs
@@ -1,26 +1,13 @@
-use clippy_utils::diagnostics::span_lint;
+use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg};
 use clippy_utils::macros::{is_format_macro, root_macro_call_first_node, FormatArgsArg, FormatArgsExpn};
-use clippy_utils::{is_diag_trait_item, path_to_local, peel_ref_operators};
+use clippy_utils::{get_parent_as_impl, is_diag_trait_item, path_to_local, peel_ref_operators};
 use if_chain::if_chain;
-use rustc_hir::{Expr, ExprKind, Impl, Item, ItemKind, QPath};
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind, Impl, ImplItem, ImplItemKind, QPath};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::{sym, symbol::kw, Symbol};
 
-#[derive(Clone, Copy)]
-enum FormatTrait {
-    Debug,
-    Display,
-}
-
-impl FormatTrait {
-    fn name(self) -> Symbol {
-        match self {
-            FormatTrait::Debug => sym::Debug,
-            FormatTrait::Display => sym::Display,
-        }
-    }
-}
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for format trait implementations (e.g. `Display`) with a recursive call to itself
@@ -60,6 +47,55 @@ declare_clippy_lint! {
     "Format trait method called while implementing the same Format trait"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for use of `println`, `print`, `eprintln` or `eprint` in an
+    /// implementation of a formatting trait.
+    ///
+    /// ### Why is this bad?
+    /// Using a print macro is likely unintentional since formatting traits
+    /// should write to the `Formatter`, not stdout/stderr.
+    ///
+    /// ### Example
+    /// ```rust
+    /// use std::fmt::{Display, Error, Formatter};
+    ///
+    /// struct S;
+    /// impl Display for S {
+    ///     fn fmt(&self, f: &mut Formatter) -> Result<(), Error> {
+    ///         println!("S");
+    ///
+    ///         Ok(())
+    ///     }
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// use std::fmt::{Display, Error, Formatter};
+    ///
+    /// struct S;
+    /// impl Display for S {
+    ///     fn fmt(&self, f: &mut Formatter) -> Result<(), Error> {
+    ///         writeln!(f, "S");
+    ///
+    ///         Ok(())
+    ///     }
+    /// }
+    /// ```
+    #[clippy::version = "1.61.0"]
+    pub PRINT_IN_FORMAT_IMPL,
+    suspicious,
+    "use of a print macro in a formatting trait impl"
+}
+
+#[derive(Clone, Copy)]
+struct FormatTrait {
+    /// e.g. `sym::Display`
+    name: Symbol,
+    /// `f` in `fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {}`
+    formatter_name: Option<Symbol>,
+}
+
 #[derive(Default)]
 pub struct FormatImpl {
     // Whether we are inside Display or Debug trait impl - None for neither
@@ -74,33 +110,29 @@ impl FormatImpl {
     }
 }
 
-impl_lint_pass!(FormatImpl => [RECURSIVE_FORMAT_IMPL]);
+impl_lint_pass!(FormatImpl => [RECURSIVE_FORMAT_IMPL, PRINT_IN_FORMAT_IMPL]);
 
 impl<'tcx> LateLintPass<'tcx> for FormatImpl {
-    fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
-        if let Some(format_trait_impl) = is_format_trait_impl(cx, item) {
-            self.format_trait_impl = Some(format_trait_impl);
-        }
+    fn check_impl_item(&mut self, cx: &LateContext<'_>, impl_item: &ImplItem<'_>) {
+        self.format_trait_impl = is_format_trait_impl(cx, impl_item);
     }
 
-    fn check_item_post(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
+    fn check_impl_item_post(&mut self, cx: &LateContext<'_>, impl_item: &ImplItem<'_>) {
         // Assume no nested Impl of Debug and Display within eachother
-        if is_format_trait_impl(cx, item).is_some() {
+        if is_format_trait_impl(cx, impl_item).is_some() {
             self.format_trait_impl = None;
         }
     }
 
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        match self.format_trait_impl {
-            Some(FormatTrait::Display) => {
-                check_to_string_in_display(cx, expr);
-                check_self_in_format_args(cx, expr, FormatTrait::Display);
-            },
-            Some(FormatTrait::Debug) => {
-                check_self_in_format_args(cx, expr, FormatTrait::Debug);
-            },
-            None => {},
+        let Some(format_trait_impl) = self.format_trait_impl else { return };
+
+        if format_trait_impl.name == sym::Display {
+            check_to_string_in_display(cx, expr);
         }
+
+        check_self_in_format_args(cx, expr, format_trait_impl);
+        check_print_in_format_impl(cx, expr, format_trait_impl);
     }
 }
 
@@ -139,7 +171,7 @@ fn check_self_in_format_args<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>,
         if let Some(args) = format_args.args();
         then {
             for arg in args {
-                if arg.format_trait != impl_trait.name() {
+                if arg.format_trait != impl_trait.name {
                     continue;
                 }
                 check_format_arg_self(cx, expr, &arg, impl_trait);
@@ -155,33 +187,65 @@ fn check_format_arg_self(cx: &LateContext<'_>, expr: &Expr<'_>, arg: &FormatArgs
     let reference = peel_ref_operators(cx, arg.value);
     let map = cx.tcx.hir();
     // Is the reference self?
-    let symbol_ident = impl_trait.name().to_ident_string();
     if path_to_local(reference).map(|x| map.name(x)) == Some(kw::SelfLower) {
+        let FormatTrait { name, .. } = impl_trait;
         span_lint(
             cx,
             RECURSIVE_FORMAT_IMPL,
             expr.span,
-            &format!(
-                "using `self` as `{}` in `impl {}` will cause infinite recursion",
-                &symbol_ident, &symbol_ident
-            ),
+            &format!("using `self` as `{name}` in `impl {name}` will cause infinite recursion"),
         );
     }
 }
 
-fn is_format_trait_impl(cx: &LateContext<'_>, item: &Item<'_>) -> Option<FormatTrait> {
+fn check_print_in_format_impl(cx: &LateContext<'_>, expr: &Expr<'_>, impl_trait: FormatTrait) {
+    if_chain! {
+        if let Some(macro_call) = root_macro_call_first_node(cx, expr);
+        if let Some(name) = cx.tcx.get_diagnostic_name(macro_call.def_id);
+        then {
+            let replacement = match name {
+                sym::print_macro | sym::eprint_macro => "write",
+                sym::println_macro | sym::eprintln_macro => "writeln",
+                _ => return,
+            };
+
+            let name = name.as_str().strip_suffix("_macro").unwrap();
+
+            span_lint_and_sugg(
+                cx,
+                PRINT_IN_FORMAT_IMPL,
+                macro_call.span,
+                &format!("use of `{}!` in `{}` impl", name, impl_trait.name),
+                "replace with",
+                if let Some(formatter_name) = impl_trait.formatter_name {
+                    format!("{}!({}, ..)", replacement, formatter_name)
+                } else {
+                    format!("{}!(..)", replacement)
+                },
+                Applicability::HasPlaceholders,
+            );
+        }
+    }
+}
+
+fn is_format_trait_impl(cx: &LateContext<'_>, impl_item: &ImplItem<'_>) -> Option<FormatTrait> {
     if_chain! {
-        // Are we at an Impl?
-        if let ItemKind::Impl(Impl { of_trait: Some(trait_ref), .. }) = &item.kind;
+        if impl_item.ident.name == sym::fmt;
+        if let ImplItemKind::Fn(_, body_id) = impl_item.kind;
+        if let Some(Impl { of_trait: Some(trait_ref),..}) = get_parent_as_impl(cx.tcx, impl_item.hir_id());
         if let Some(did) = trait_ref.trait_def_id();
         if let Some(name) = cx.tcx.get_diagnostic_name(did);
+        if matches!(name, sym::Debug | sym::Display);
         then {
-            // Is Impl for Debug or Display?
-            match name {
-                sym::Debug => Some(FormatTrait::Debug),
-                sym::Display => Some(FormatTrait::Display),
-                _ => None,
-            }
+            let body = cx.tcx.hir().body(body_id);
+            let formatter_name = body.params.get(1)
+                .and_then(|param| param.pat.simple_ident())
+                .map(|ident| ident.name);
+
+            Some(FormatTrait {
+                name,
+                formatter_name,
+            })
         } else {
             None
         }
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index b2d9889ba86..f6d467941e3 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -68,6 +68,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(format::USELESS_FORMAT),
     LintId::of(format_args::FORMAT_IN_FORMAT_ARGS),
     LintId::of(format_args::TO_STRING_IN_FORMAT_ARGS),
+    LintId::of(format_impl::PRINT_IN_FORMAT_IMPL),
     LintId::of(format_impl::RECURSIVE_FORMAT_IMPL),
     LintId::of(formatting::POSSIBLE_MISSING_COMMA),
     LintId::of(formatting::SUSPICIOUS_ASSIGNMENT_FORMATTING),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 1243fc978b7..686482671b4 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -152,6 +152,7 @@ store.register_lints(&[
     format::USELESS_FORMAT,
     format_args::FORMAT_IN_FORMAT_ARGS,
     format_args::TO_STRING_IN_FORMAT_ARGS,
+    format_impl::PRINT_IN_FORMAT_IMPL,
     format_impl::RECURSIVE_FORMAT_IMPL,
     formatting::POSSIBLE_MISSING_COMMA,
     formatting::SUSPICIOUS_ASSIGNMENT_FORMATTING,
diff --git a/clippy_lints/src/lib.register_suspicious.rs b/clippy_lints/src/lib.register_suspicious.rs
index 6a8859e19d7..465baa82581 100644
--- a/clippy_lints/src/lib.register_suspicious.rs
+++ b/clippy_lints/src/lib.register_suspicious.rs
@@ -10,6 +10,7 @@ store.register_group(true, "clippy::suspicious", Some("clippy_suspicious"), vec!
     LintId::of(casts::CAST_ENUM_TRUNCATION),
     LintId::of(eval_order_dependence::EVAL_ORDER_DEPENDENCE),
     LintId::of(float_equality_without_abs::FLOAT_EQUALITY_WITHOUT_ABS),
+    LintId::of(format_impl::PRINT_IN_FORMAT_IMPL),
     LintId::of(formatting::SUSPICIOUS_ASSIGNMENT_FORMATTING),
     LintId::of(formatting::SUSPICIOUS_ELSE_FORMATTING),
     LintId::of(formatting::SUSPICIOUS_UNARY_OP_FORMATTING),
diff --git a/tests/ui/print_in_format_impl.rs b/tests/ui/print_in_format_impl.rs
new file mode 100644
index 00000000000..64e88686609
--- /dev/null
+++ b/tests/ui/print_in_format_impl.rs
@@ -0,0 +1,58 @@
+#![allow(unused, clippy::print_literal, clippy::write_literal)]
+#![warn(clippy::print_in_format_impl)]
+use std::fmt::{Debug, Display, Error, Formatter};
+
+macro_rules! indirect {
+    () => {{ println!() }};
+}
+
+macro_rules! nested {
+    ($($tt:tt)*) => {
+        $($tt)*
+    };
+}
+
+struct Foo;
+impl Debug for Foo {
+    fn fmt(&self, f: &mut Formatter) -> Result<(), Error> {
+        static WORKS_WITH_NESTED_ITEMS: bool = true;
+
+        print!("{}", 1);
+        println!("{}", 2);
+        eprint!("{}", 3);
+        eprintln!("{}", 4);
+        nested! {
+            println!("nested");
+        };
+
+        write!(f, "{}", 5);
+        writeln!(f, "{}", 6);
+        indirect!();
+
+        Ok(())
+    }
+}
+
+impl Display for Foo {
+    fn fmt(&self, f: &mut Formatter) -> Result<(), Error> {
+        print!("Display");
+        write!(f, "Display");
+
+        Ok(())
+    }
+}
+
+struct UnnamedFormatter;
+impl Debug for UnnamedFormatter {
+    fn fmt(&self, _: &mut Formatter) -> Result<(), Error> {
+        println!("UnnamedFormatter");
+        Ok(())
+    }
+}
+
+fn main() {
+    print!("outside fmt");
+    println!("outside fmt");
+    eprint!("outside fmt");
+    eprintln!("outside fmt");
+}
diff --git a/tests/ui/print_in_format_impl.stderr b/tests/ui/print_in_format_impl.stderr
new file mode 100644
index 00000000000..63b7179bca7
--- /dev/null
+++ b/tests/ui/print_in_format_impl.stderr
@@ -0,0 +1,46 @@
+error: use of `print!` in `Debug` impl
+  --> $DIR/print_in_format_impl.rs:20:9
+   |
+LL |         print!("{}", 1);
+   |         ^^^^^^^^^^^^^^^ help: replace with: `write!(f, ..)`
+   |
+   = note: `-D clippy::print-in-format-impl` implied by `-D warnings`
+
+error: use of `println!` in `Debug` impl
+  --> $DIR/print_in_format_impl.rs:21:9
+   |
+LL |         println!("{}", 2);
+   |         ^^^^^^^^^^^^^^^^^ help: replace with: `writeln!(f, ..)`
+
+error: use of `eprint!` in `Debug` impl
+  --> $DIR/print_in_format_impl.rs:22:9
+   |
+LL |         eprint!("{}", 3);
+   |         ^^^^^^^^^^^^^^^^ help: replace with: `write!(f, ..)`
+
+error: use of `eprintln!` in `Debug` impl
+  --> $DIR/print_in_format_impl.rs:23:9
+   |
+LL |         eprintln!("{}", 4);
+   |         ^^^^^^^^^^^^^^^^^^ help: replace with: `writeln!(f, ..)`
+
+error: use of `println!` in `Debug` impl
+  --> $DIR/print_in_format_impl.rs:25:13
+   |
+LL |             println!("nested");
+   |             ^^^^^^^^^^^^^^^^^^ help: replace with: `writeln!(f, ..)`
+
+error: use of `print!` in `Display` impl
+  --> $DIR/print_in_format_impl.rs:38:9
+   |
+LL |         print!("Display");
+   |         ^^^^^^^^^^^^^^^^^ help: replace with: `write!(f, ..)`
+
+error: use of `println!` in `Debug` impl
+  --> $DIR/print_in_format_impl.rs:48:9
+   |
+LL |         println!("UnnamedFormatter");
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `writeln!(..)`
+
+error: aborting due to 7 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 914ae1e8490c4d6e34dc090cad30303b95d44bb7 Mon Sep 17 00:00:00 2001
From: Elliot Bobrow <elliotgreybobrow@gmail.com>
Date: Mon, 21 Feb 2022 14:38:22 -0800
Subject: check `use_self` in `pat`

---
 clippy_lints/src/use_self.rs | 19 ++++++++++++++++++-
 tests/ui/use_self.fixed      | 25 ++++++++++++++++++++++++-
 tests/ui/use_self.rs         | 25 ++++++++++++++++++++++++-
 tests/ui/use_self.stderr     | 20 +++++++++++++++++++-
 4 files changed, 85 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/use_self.rs b/clippy_lints/src/use_self.rs
index be20282b3b8..4fa9a8ea2ec 100644
--- a/clippy_lints/src/use_self.rs
+++ b/clippy_lints/src/use_self.rs
@@ -9,7 +9,8 @@ use rustc_hir::{
     def::{CtorOf, DefKind, Res},
     def_id::LocalDefId,
     intravisit::{walk_inf, walk_ty, Visitor},
-    Expr, ExprKind, FnRetTy, FnSig, GenericArg, HirId, Impl, ImplItemKind, Item, ItemKind, Path, QPath, TyKind,
+    Expr, ExprKind, FnRetTy, FnSig, GenericArg, HirId, Impl, ImplItemKind, Item, ItemKind, Pat, PatKind, Path, QPath,
+    TyKind,
 };
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_semver::RustcVersion;
@@ -252,6 +253,22 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
         }
     }
 
+    fn check_pat(&mut self, cx: &LateContext<'_>, pat: &Pat<'_>) {
+        if_chain! {
+            if !pat.span.from_expansion();
+            if meets_msrv(self.msrv.as_ref(), &msrvs::TYPE_ALIAS_ENUM_VARIANTS);
+            if let Some(&StackItem::Check { impl_id, .. }) = self.stack.last();
+            if let PatKind::Path(QPath::Resolved(_, path)) = pat.kind;
+            if !matches!(path.res, Res::SelfTy { .. } | Res::Def(DefKind::TyParam, _));
+            if cx.typeck_results().pat_ty(pat) == cx.tcx.type_of(impl_id);
+            if let [first, ..] = path.segments;
+            if let Some(hir_id) = first.hir_id;
+            then {
+                span_lint(cx, cx.tcx.hir().span(hir_id));
+            }
+        }
+    }
+
     extract_msrv_attr!(LateContext);
 }
 
diff --git a/tests/ui/use_self.fixed b/tests/ui/use_self.fixed
index 4e33e343ce0..9d216f56ae6 100644
--- a/tests/ui/use_self.fixed
+++ b/tests/ui/use_self.fixed
@@ -2,7 +2,7 @@
 // aux-build:proc_macro_derive.rs
 
 #![warn(clippy::use_self)]
-#![allow(dead_code)]
+#![allow(dead_code, unreachable_code)]
 #![allow(
     clippy::should_implement_trait,
     clippy::upper_case_acronyms,
@@ -519,3 +519,26 @@ mod self_is_ty_param {
         }
     }
 }
+
+mod use_self_in_pat {
+    enum Foo {
+        Bar,
+        Baz,
+    }
+
+    impl Foo {
+        fn do_stuff(self) {
+            match self {
+                Self::Bar => unimplemented!(),
+                Self::Baz => unimplemented!(),
+            }
+            match Some(1) {
+                Some(_) => unimplemented!(),
+                None => unimplemented!(),
+            }
+            if let Self::Bar = self {
+                unimplemented!()
+            }
+        }
+    }
+}
diff --git a/tests/ui/use_self.rs b/tests/ui/use_self.rs
index 7b621ff9bca..5f604fe25e4 100644
--- a/tests/ui/use_self.rs
+++ b/tests/ui/use_self.rs
@@ -2,7 +2,7 @@
 // aux-build:proc_macro_derive.rs
 
 #![warn(clippy::use_self)]
-#![allow(dead_code)]
+#![allow(dead_code, unreachable_code)]
 #![allow(
     clippy::should_implement_trait,
     clippy::upper_case_acronyms,
@@ -519,3 +519,26 @@ mod self_is_ty_param {
         }
     }
 }
+
+mod use_self_in_pat {
+    enum Foo {
+        Bar,
+        Baz,
+    }
+
+    impl Foo {
+        fn do_stuff(self) {
+            match self {
+                Foo::Bar => unimplemented!(),
+                Foo::Baz => unimplemented!(),
+            }
+            match Some(1) {
+                Some(_) => unimplemented!(),
+                None => unimplemented!(),
+            }
+            if let Foo::Bar = self {
+                unimplemented!()
+            }
+        }
+    }
+}
diff --git a/tests/ui/use_self.stderr b/tests/ui/use_self.stderr
index ecb78b3f972..34d98618253 100644
--- a/tests/ui/use_self.stderr
+++ b/tests/ui/use_self.stderr
@@ -168,5 +168,23 @@ error: unnecessary structure name repetition
 LL |             S2::new()
    |             ^^ help: use the applicable keyword: `Self`
 
-error: aborting due to 28 previous errors
+error: unnecessary structure name repetition
+  --> $DIR/use_self.rs:532:17
+   |
+LL |                 Foo::Bar => unimplemented!(),
+   |                 ^^^ help: use the applicable keyword: `Self`
+
+error: unnecessary structure name repetition
+  --> $DIR/use_self.rs:533:17
+   |
+LL |                 Foo::Baz => unimplemented!(),
+   |                 ^^^ help: use the applicable keyword: `Self`
+
+error: unnecessary structure name repetition
+  --> $DIR/use_self.rs:539:20
+   |
+LL |             if let Foo::Bar = self {
+   |                    ^^^ help: use the applicable keyword: `Self`
+
+error: aborting due to 31 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From d123ffc6c754b25cc68a67ffab0b5c7707eac6e5 Mon Sep 17 00:00:00 2001
From: "Samuel E. Moelius III" <sam@moeli.us>
Date: Mon, 28 Feb 2022 05:00:36 -0500
Subject: Check `clone_or_copy_needed` in `unnecessary_filter_map::check`

---
 clippy_lints/src/methods/unnecessary_filter_map.rs |  7 +-
 .../src/methods/unnecessary_iter_cloned.rs         | 91 +---------------------
 clippy_lints/src/methods/utils.rs                  | 87 +++++++++++++++++++++
 3 files changed, 95 insertions(+), 90 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/unnecessary_filter_map.rs b/clippy_lints/src/methods/unnecessary_filter_map.rs
index 12ad3d8d690..108e143f337 100644
--- a/clippy_lints/src/methods/unnecessary_filter_map.rs
+++ b/clippy_lints/src/methods/unnecessary_filter_map.rs
@@ -1,4 +1,6 @@
+use super::utils::clone_or_copy_needed;
 use clippy_utils::diagnostics::span_lint;
+use clippy_utils::ty::is_copy;
 use clippy_utils::usage::mutated_variables;
 use clippy_utils::{is_lang_ctor, is_trait_method, path_to_local_id};
 use rustc_hir as hir;
@@ -20,6 +22,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, arg: &hir::Expr<
         let arg_id = body.params[0].pat.hir_id;
         let mutates_arg =
             mutated_variables(&body.value, cx).map_or(true, |used_mutably| used_mutably.contains(&arg_id));
+        let (clone_or_copy_needed, _) = clone_or_copy_needed(cx, body.params[0].pat, &body.value);
 
         let (mut found_mapping, mut found_filtering) = check_expression(cx, arg_id, &body.value);
 
@@ -28,10 +31,10 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, arg: &hir::Expr<
         found_mapping |= return_visitor.found_mapping;
         found_filtering |= return_visitor.found_filtering;
 
+        let in_ty = cx.typeck_results().node_type(body.params[0].hir_id);
         let sugg = if !found_filtering {
             "map"
-        } else if !found_mapping && !mutates_arg {
-            let in_ty = cx.typeck_results().node_type(body.params[0].hir_id);
+        } else if !found_mapping && !mutates_arg && (!clone_or_copy_needed || is_copy(cx, in_ty)) {
             match cx.typeck_results().expr_ty(&body.value).kind() {
                 ty::Adt(adt, subst) if cx.tcx.is_diagnostic_item(sym::Option, adt.did) && in_ty == subst.type_at(0) => {
                     "filter"
diff --git a/clippy_lints/src/methods/unnecessary_iter_cloned.rs b/clippy_lints/src/methods/unnecessary_iter_cloned.rs
index 65e94c5f44a..7a39557ad57 100644
--- a/clippy_lints/src/methods/unnecessary_iter_cloned.rs
+++ b/clippy_lints/src/methods/unnecessary_iter_cloned.rs
@@ -1,14 +1,12 @@
+use super::utils::clone_or_copy_needed;
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::higher::ForLoop;
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::{get_associated_type, get_iterator_item_ty, implements_trait};
-use clippy_utils::{fn_def_id, get_parent_expr, path_to_local_id, usage};
+use clippy_utils::{fn_def_id, get_parent_expr};
 use rustc_errors::Applicability;
-use rustc_hir::intravisit::{walk_expr, Visitor};
-use rustc_hir::{def_id::DefId, BorrowKind, Expr, ExprKind, HirId, LangItem, Mutability, Pat};
+use rustc_hir::{def_id::DefId, Expr, ExprKind, LangItem};
 use rustc_lint::LateContext;
-use rustc_middle::hir::nested_filter;
-use rustc_middle::ty;
 use rustc_span::{sym, Symbol};
 
 use super::UNNECESSARY_TO_OWNED;
@@ -100,89 +98,6 @@ pub fn check_for_loop_iter(
     false
 }
 
-/// The core logic of `check_for_loop_iter` above, this function wraps a use of
-/// `CloneOrCopyVisitor`.
-fn clone_or_copy_needed<'tcx>(
-    cx: &LateContext<'tcx>,
-    pat: &Pat<'tcx>,
-    body: &'tcx Expr<'tcx>,
-) -> (bool, Vec<&'tcx Expr<'tcx>>) {
-    let mut visitor = CloneOrCopyVisitor {
-        cx,
-        binding_hir_ids: pat_bindings(pat),
-        clone_or_copy_needed: false,
-        addr_of_exprs: Vec::new(),
-    };
-    visitor.visit_expr(body);
-    (visitor.clone_or_copy_needed, visitor.addr_of_exprs)
-}
-
-/// Returns a vector of all `HirId`s bound by the pattern.
-fn pat_bindings(pat: &Pat<'_>) -> Vec<HirId> {
-    let mut collector = usage::ParamBindingIdCollector {
-        binding_hir_ids: Vec::new(),
-    };
-    collector.visit_pat(pat);
-    collector.binding_hir_ids
-}
-
-/// `clone_or_copy_needed` will be false when `CloneOrCopyVisitor` is done visiting if the only
-/// operations performed on `binding_hir_ids` are:
-/// * to take non-mutable references to them
-/// * to use them as non-mutable `&self` in method calls
-/// If any of `binding_hir_ids` is used in any other way, then `clone_or_copy_needed` will be true
-/// when `CloneOrCopyVisitor` is done visiting.
-struct CloneOrCopyVisitor<'cx, 'tcx> {
-    cx: &'cx LateContext<'tcx>,
-    binding_hir_ids: Vec<HirId>,
-    clone_or_copy_needed: bool,
-    addr_of_exprs: Vec<&'tcx Expr<'tcx>>,
-}
-
-impl<'cx, 'tcx> Visitor<'tcx> for CloneOrCopyVisitor<'cx, 'tcx> {
-    type NestedFilter = nested_filter::OnlyBodies;
-
-    fn nested_visit_map(&mut self) -> Self::Map {
-        self.cx.tcx.hir()
-    }
-
-    fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) {
-        walk_expr(self, expr);
-        if self.is_binding(expr) {
-            if let Some(parent) = get_parent_expr(self.cx, expr) {
-                match parent.kind {
-                    ExprKind::AddrOf(BorrowKind::Ref, Mutability::Not, _) => {
-                        self.addr_of_exprs.push(parent);
-                        return;
-                    },
-                    ExprKind::MethodCall(_, args, _) => {
-                        if_chain! {
-                            if args.iter().skip(1).all(|arg| !self.is_binding(arg));
-                            if let Some(method_def_id) = self.cx.typeck_results().type_dependent_def_id(parent.hir_id);
-                            let method_ty = self.cx.tcx.type_of(method_def_id);
-                            let self_ty = method_ty.fn_sig(self.cx.tcx).input(0).skip_binder();
-                            if matches!(self_ty.kind(), ty::Ref(_, _, Mutability::Not));
-                            then {
-                                return;
-                            }
-                        }
-                    },
-                    _ => {},
-                }
-            }
-            self.clone_or_copy_needed = true;
-        }
-    }
-}
-
-impl<'cx, 'tcx> CloneOrCopyVisitor<'cx, 'tcx> {
-    fn is_binding(&self, expr: &Expr<'tcx>) -> bool {
-        self.binding_hir_ids
-            .iter()
-            .any(|hir_id| path_to_local_id(expr, *hir_id))
-    }
-}
-
 /// Returns true if the named method is `IntoIterator::into_iter`.
 pub fn is_into_iter(cx: &LateContext<'_>, callee_def_id: DefId) -> bool {
     cx.tcx.lang_items().require(LangItem::IntoIterIntoIter) == Ok(callee_def_id)
diff --git a/clippy_lints/src/methods/utils.rs b/clippy_lints/src/methods/utils.rs
index 63c3273bd68..3015531e843 100644
--- a/clippy_lints/src/methods/utils.rs
+++ b/clippy_lints/src/methods/utils.rs
@@ -1,10 +1,14 @@
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::{get_parent_expr, path_to_local_id, usage};
 use if_chain::if_chain;
 use rustc_ast::ast;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
+use rustc_hir::intravisit::{walk_expr, Visitor};
+use rustc_hir::{BorrowKind, Expr, ExprKind, HirId, Mutability, Pat};
 use rustc_lint::LateContext;
+use rustc_middle::hir::nested_filter;
 use rustc_middle::ty::{self, Ty};
 use rustc_span::symbol::sym;
 
@@ -79,3 +83,86 @@ pub(super) fn get_hint_if_single_char_arg(
         }
     }
 }
+
+/// The core logic of `check_for_loop_iter` in `unnecessary_iter_cloned.rs`, this function wraps a
+/// use of `CloneOrCopyVisitor`.
+pub(super) fn clone_or_copy_needed<'tcx>(
+    cx: &LateContext<'tcx>,
+    pat: &Pat<'tcx>,
+    body: &'tcx Expr<'tcx>,
+) -> (bool, Vec<&'tcx Expr<'tcx>>) {
+    let mut visitor = CloneOrCopyVisitor {
+        cx,
+        binding_hir_ids: pat_bindings(pat),
+        clone_or_copy_needed: false,
+        addr_of_exprs: Vec::new(),
+    };
+    visitor.visit_expr(body);
+    (visitor.clone_or_copy_needed, visitor.addr_of_exprs)
+}
+
+/// Returns a vector of all `HirId`s bound by the pattern.
+fn pat_bindings(pat: &Pat<'_>) -> Vec<HirId> {
+    let mut collector = usage::ParamBindingIdCollector {
+        binding_hir_ids: Vec::new(),
+    };
+    collector.visit_pat(pat);
+    collector.binding_hir_ids
+}
+
+/// `clone_or_copy_needed` will be false when `CloneOrCopyVisitor` is done visiting if the only
+/// operations performed on `binding_hir_ids` are:
+/// * to take non-mutable references to them
+/// * to use them as non-mutable `&self` in method calls
+/// If any of `binding_hir_ids` is used in any other way, then `clone_or_copy_needed` will be true
+/// when `CloneOrCopyVisitor` is done visiting.
+struct CloneOrCopyVisitor<'cx, 'tcx> {
+    cx: &'cx LateContext<'tcx>,
+    binding_hir_ids: Vec<HirId>,
+    clone_or_copy_needed: bool,
+    addr_of_exprs: Vec<&'tcx Expr<'tcx>>,
+}
+
+impl<'cx, 'tcx> Visitor<'tcx> for CloneOrCopyVisitor<'cx, 'tcx> {
+    type NestedFilter = nested_filter::OnlyBodies;
+
+    fn nested_visit_map(&mut self) -> Self::Map {
+        self.cx.tcx.hir()
+    }
+
+    fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) {
+        walk_expr(self, expr);
+        if self.is_binding(expr) {
+            if let Some(parent) = get_parent_expr(self.cx, expr) {
+                match parent.kind {
+                    ExprKind::AddrOf(BorrowKind::Ref, Mutability::Not, _) => {
+                        self.addr_of_exprs.push(parent);
+                        return;
+                    },
+                    ExprKind::MethodCall(_, args, _) => {
+                        if_chain! {
+                            if args.iter().skip(1).all(|arg| !self.is_binding(arg));
+                            if let Some(method_def_id) = self.cx.typeck_results().type_dependent_def_id(parent.hir_id);
+                            let method_ty = self.cx.tcx.type_of(method_def_id);
+                            let self_ty = method_ty.fn_sig(self.cx.tcx).input(0).skip_binder();
+                            if matches!(self_ty.kind(), ty::Ref(_, _, Mutability::Not));
+                            then {
+                                return;
+                            }
+                        }
+                    },
+                    _ => {},
+                }
+            }
+            self.clone_or_copy_needed = true;
+        }
+    }
+}
+
+impl<'cx, 'tcx> CloneOrCopyVisitor<'cx, 'tcx> {
+    fn is_binding(&self, expr: &Expr<'tcx>) -> bool {
+        self.binding_hir_ids
+            .iter()
+            .any(|hir_id| path_to_local_id(expr, *hir_id))
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 35b145389526ffd7b0f7c6df830245e3ea51353b Mon Sep 17 00:00:00 2001
From: dswij <dswijj@gmail.com>
Date: Tue, 1 Mar 2022 12:47:55 +0800
Subject: `map_identity` checks for unneeded `.map_err`

---
 clippy_lints/src/methods/map_identity.rs | 3 ++-
 clippy_lints/src/methods/mod.rs          | 4 ++--
 2 files changed, 4 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/map_identity.rs b/clippy_lints/src/methods/map_identity.rs
index f112b500d3d..862a9578e6f 100644
--- a/clippy_lints/src/methods/map_identity.rs
+++ b/clippy_lints/src/methods/map_identity.rs
@@ -13,6 +13,7 @@ pub(super) fn check(
     expr: &hir::Expr<'_>,
     caller: &hir::Expr<'_>,
     map_arg: &hir::Expr<'_>,
+    name: &str,
     _map_span: Span,
 ) {
     let caller_ty = cx.typeck_results().expr_ty(caller);
@@ -29,7 +30,7 @@ pub(super) fn check(
                 MAP_IDENTITY,
                 sugg_span,
                 "unnecessary map of the identity function",
-                "remove the call to `map`",
+                &format!("remove the call to `{}`", name),
                 String::new(),
                 Applicability::MachineApplicable,
             )
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 3021a40fae1..fd00ac7380d 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -2334,7 +2334,7 @@ fn check_methods<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, msrv: Optio
                     }
                 }
             },
-            ("map", [m_arg]) => {
+            (name @ ("map" | "map_err"), [m_arg]) => {
                 if let Some((name, [recv2, args @ ..], span2)) = method_call(recv) {
                     match (name, args) {
                         ("as_mut", []) => option_as_ref_deref::check(cx, expr, recv2, m_arg, true, msrv),
@@ -2346,7 +2346,7 @@ fn check_methods<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, msrv: Optio
                         _ => {},
                     }
                 }
-                map_identity::check(cx, expr, recv, m_arg, span);
+                map_identity::check(cx, expr, recv, m_arg, name, span);
             },
             ("map_or", [def, map]) => option_map_or_none::check(cx, expr, recv, def, map),
             (name @ "next", args @ []) => {
-- 
cgit 1.4.1-3-g733a5


From bca4ee79718e82f7384b9a6d7649e45bfc3c2598 Mon Sep 17 00:00:00 2001
From: flip1995 <philipp.krones@embecosm.com>
Date: Wed, 19 Jan 2022 17:35:52 +0100
Subject: Implement internal lint for MSRV lints

This internal lint checks if the `extract_msrv_attrs!` macro is used if
a lint has a MSRV. If not, it suggests to add this attribute to the lint
pass implementation.
---
 Cargo.toml                                      |  1 +
 clippy_lints/src/lib.register_internal.rs       |  1 +
 clippy_lints/src/lib.register_lints.rs          |  2 +
 clippy_lints/src/lib.rs                         |  1 +
 clippy_lints/src/utils/internal_lints.rs        | 54 ++++++++++++++++++++++++-
 clippy_utils/src/paths.rs                       |  6 +++
 tests/compile-test.rs                           |  3 ++
 tests/ui-internal/invalid_msrv_attr_impl.fixed  | 40 ++++++++++++++++++
 tests/ui-internal/invalid_msrv_attr_impl.rs     | 38 +++++++++++++++++
 tests/ui-internal/invalid_msrv_attr_impl.stderr | 32 +++++++++++++++
 10 files changed, 177 insertions(+), 1 deletion(-)
 create mode 100644 tests/ui-internal/invalid_msrv_attr_impl.fixed
 create mode 100644 tests/ui-internal/invalid_msrv_attr_impl.rs
 create mode 100644 tests/ui-internal/invalid_msrv_attr_impl.stderr

(limited to 'clippy_lints/src')

diff --git a/Cargo.toml b/Cargo.toml
index 5cc5530f874..4ea70429621 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -50,6 +50,7 @@ syn = { version = "1.0", features = ["full"] }
 futures = "0.3"
 parking_lot = "0.11.2"
 tokio = { version = "1", features = ["io-util"] }
+rustc-semver = "1.1"
 num_cpus = "1.13"
 
 [build-dependencies]
diff --git a/clippy_lints/src/lib.register_internal.rs b/clippy_lints/src/lib.register_internal.rs
index 7d4c7d2adb5..4778f4fdfa7 100644
--- a/clippy_lints/src/lib.register_internal.rs
+++ b/clippy_lints/src/lib.register_internal.rs
@@ -14,6 +14,7 @@ store.register_group(true, "clippy::internal", Some("clippy_internal"), vec![
     LintId::of(utils::internal_lints::LINT_WITHOUT_LINT_PASS),
     LintId::of(utils::internal_lints::MATCH_TYPE_ON_DIAGNOSTIC_ITEM),
     LintId::of(utils::internal_lints::MISSING_CLIPPY_VERSION_ATTRIBUTE),
+    LintId::of(utils::internal_lints::MISSING_MSRV_ATTR_IMPL),
     LintId::of(utils::internal_lints::OUTER_EXPN_EXPN_DATA),
     LintId::of(utils::internal_lints::PRODUCE_ICE),
     LintId::of(utils::internal_lints::UNNECESSARY_SYMBOL_STR),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 686482671b4..f9337114038 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -26,6 +26,8 @@ store.register_lints(&[
     #[cfg(feature = "internal")]
     utils::internal_lints::MISSING_CLIPPY_VERSION_ATTRIBUTE,
     #[cfg(feature = "internal")]
+    utils::internal_lints::MISSING_MSRV_ATTR_IMPL,
+    #[cfg(feature = "internal")]
     utils::internal_lints::OUTER_EXPN_EXPN_DATA,
     #[cfg(feature = "internal")]
     utils::internal_lints::PRODUCE_ICE,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 230e2b2ccdf..24b67c12f06 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -505,6 +505,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         store.register_late_pass(|| Box::new(utils::internal_lints::LintWithoutLintPass::default()));
         store.register_late_pass(|| Box::new(utils::internal_lints::MatchTypeOnDiagItem));
         store.register_late_pass(|| Box::new(utils::internal_lints::OuterExpnDataPass));
+        store.register_late_pass(|| Box::new(utils::internal_lints::MsrvAttrImpl));
     }
 
     store.register_late_pass(|| Box::new(utils::author::Author));
diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs
index 4433d5f5bf1..b3b241392fe 100644
--- a/clippy_lints/src/utils/internal_lints.rs
+++ b/clippy_lints/src/utils/internal_lints.rs
@@ -25,7 +25,7 @@ use rustc_hir::{
 use rustc_lint::{EarlyContext, EarlyLintPass, LateContext, LateLintPass, LintContext};
 use rustc_middle::hir::nested_filter;
 use rustc_middle::mir::interpret::ConstValue;
-use rustc_middle::ty;
+use rustc_middle::ty::{self, subst::GenericArgKind};
 use rustc_semver::RustcVersion;
 use rustc_session::{declare_lint_pass, declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::Spanned;
@@ -337,6 +337,15 @@ declare_clippy_lint! {
     "found clippy lint without `clippy::version` attribute"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Check that the `extract_msrv_attr!` macro is used, when a lint has a MSRV.
+    ///
+    pub MISSING_MSRV_ATTR_IMPL,
+    internal,
+    "checking if all necessary steps were taken when adding a MSRV to a lint"
+}
+
 declare_lint_pass!(ClippyLintsInternal => [CLIPPY_LINTS_INTERNAL]);
 
 impl EarlyLintPass for ClippyLintsInternal {
@@ -1314,3 +1323,46 @@ fn if_chain_local_span(cx: &LateContext<'_>, local: &Local<'_>, if_chain_span: S
         span.parent(),
     )
 }
+
+declare_lint_pass!(MsrvAttrImpl => [MISSING_MSRV_ATTR_IMPL]);
+
+impl LateLintPass<'_> for MsrvAttrImpl {
+    fn check_item(&mut self, cx: &LateContext<'_>, item: &hir::Item<'_>) {
+        if_chain! {
+            if let hir::ItemKind::Impl(hir::Impl {
+                of_trait: Some(lint_pass_trait_ref),
+                self_ty,
+                items,
+                ..
+            }) = &item.kind;
+            if let Some(lint_pass_trait_def_id) = lint_pass_trait_ref.trait_def_id();
+            let is_late_pass = match_def_path(cx, lint_pass_trait_def_id, &paths::LATE_LINT_PASS);
+            if is_late_pass || match_def_path(cx, lint_pass_trait_def_id, &paths::EARLY_LINT_PASS);
+            let self_ty = hir_ty_to_ty(cx.tcx, self_ty);
+            if let ty::Adt(self_ty_def, _) = self_ty.kind();
+            if self_ty_def.is_struct();
+            if self_ty_def.all_fields().any(|f| {
+                cx.tcx
+                    .type_of(f.did)
+                    .walk()
+                    .filter(|t| matches!(t.unpack(), GenericArgKind::Type(_)))
+                    .any(|t| match_type(cx, t.expect_ty(), &paths::RUSTC_VERSION))
+            });
+            if !items.iter().any(|item| item.ident.name == sym!(enter_lint_attrs));
+            then {
+                let context = if is_late_pass { "LateContext" } else { "EarlyContext" };
+                let lint_pass = if is_late_pass { "LateLintPass" } else { "EarlyLintPass" };
+                let span = cx.sess().source_map().span_through_char(item.span, '{');
+                span_lint_and_sugg(
+                    cx,
+                    MISSING_MSRV_ATTR_IMPL,
+                    span,
+                    &format!("`extract_msrv_attr!` macro missing from `{lint_pass}` implementation"),
+                    &format!("add `extract_msrv_attr!({context})` to the `{lint_pass}` implementation"),
+                    format!("{}\n    extract_msrv_attr!({context});", snippet(cx, span, "..")),
+                    Applicability::MachineApplicable,
+                );
+            }
+        }
+    }
+}
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index 2778e30388e..6f56f8d5136 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -32,6 +32,8 @@ pub const DIR_BUILDER: [&str; 3] = ["std", "fs", "DirBuilder"];
 pub const DISPLAY_TRAIT: [&str; 3] = ["core", "fmt", "Display"];
 #[cfg(feature = "internal")]
 pub const EARLY_CONTEXT: [&str; 2] = ["rustc_lint", "EarlyContext"];
+#[cfg(feature = "internal")]
+pub const EARLY_LINT_PASS: [&str; 3] = ["rustc_lint", "passes", "EarlyLintPass"];
 pub const EXIT: [&str; 3] = ["std", "process", "exit"];
 pub const F32_EPSILON: [&str; 4] = ["core", "f32", "<impl f32>", "EPSILON"];
 pub const F64_EPSILON: [&str; 4] = ["core", "f64", "<impl f64>", "EPSILON"];
@@ -67,6 +69,8 @@ pub const KW_MODULE: [&str; 3] = ["rustc_span", "symbol", "kw"];
 #[cfg(feature = "internal")]
 pub const LATE_CONTEXT: [&str; 2] = ["rustc_lint", "LateContext"];
 #[cfg(feature = "internal")]
+pub const LATE_LINT_PASS: [&str; 3] = ["rustc_lint", "passes", "LateLintPass"];
+#[cfg(feature = "internal")]
 pub const LINT: [&str; 2] = ["rustc_lint_defs", "Lint"];
 pub const MUTEX_GUARD: [&str; 4] = ["std", "sync", "mutex", "MutexGuard"];
 pub const OPEN_OPTIONS: [&str; 3] = ["std", "fs", "OpenOptions"];
@@ -126,6 +130,8 @@ pub const REGEX_SET_NEW: [&str; 5] = ["regex", "re_set", "unicode", "RegexSet",
 pub const RESULT: [&str; 3] = ["core", "result", "Result"];
 pub const RESULT_ERR: [&str; 4] = ["core", "result", "Result", "Err"];
 pub const RESULT_OK: [&str; 4] = ["core", "result", "Result", "Ok"];
+#[cfg(feature = "internal")]
+pub const RUSTC_VERSION: [&str; 2] = ["rustc_semver", "RustcVersion"];
 pub const RWLOCK_READ_GUARD: [&str; 4] = ["std", "sync", "rwlock", "RwLockReadGuard"];
 pub const RWLOCK_WRITE_GUARD: [&str; 4] = ["std", "sync", "rwlock", "RwLockWriteGuard"];
 pub const SERDE_DESERIALIZE: [&str; 3] = ["serde", "de", "Deserialize"];
diff --git a/tests/compile-test.rs b/tests/compile-test.rs
index 6bc74bc1e9a..fc441e60802 100644
--- a/tests/compile-test.rs
+++ b/tests/compile-test.rs
@@ -34,6 +34,7 @@ static TEST_DEPENDENCIES: &[&str] = &[
     "syn",
     "tokio",
     "parking_lot",
+    "rustc_semver",
 ];
 
 // Test dependencies may need an `extern crate` here to ensure that they show up
@@ -53,6 +54,8 @@ extern crate parking_lot;
 #[allow(unused_extern_crates)]
 extern crate quote;
 #[allow(unused_extern_crates)]
+extern crate rustc_semver;
+#[allow(unused_extern_crates)]
 extern crate syn;
 #[allow(unused_extern_crates)]
 extern crate tokio;
diff --git a/tests/ui-internal/invalid_msrv_attr_impl.fixed b/tests/ui-internal/invalid_msrv_attr_impl.fixed
new file mode 100644
index 00000000000..900a8fffd40
--- /dev/null
+++ b/tests/ui-internal/invalid_msrv_attr_impl.fixed
@@ -0,0 +1,40 @@
+// run-rustfix
+
+#![deny(clippy::internal)]
+#![allow(clippy::missing_clippy_version_attribute)]
+#![feature(rustc_private)]
+
+extern crate rustc_ast;
+extern crate rustc_hir;
+extern crate rustc_lint;
+extern crate rustc_middle;
+#[macro_use]
+extern crate rustc_session;
+use clippy_utils::extract_msrv_attr;
+use rustc_hir::Expr;
+use rustc_lint::{EarlyContext, EarlyLintPass, LateContext, LateLintPass};
+use rustc_semver::RustcVersion;
+
+declare_lint! {
+    pub TEST_LINT,
+    Warn,
+    ""
+}
+
+struct Pass {
+    msrv: Option<RustcVersion>,
+}
+
+impl_lint_pass!(Pass => [TEST_LINT]);
+
+impl LateLintPass<'_> for Pass {
+    extract_msrv_attr!(LateContext);
+    fn check_expr(&mut self, _: &LateContext<'_>, _: &Expr<'_>) {}
+}
+
+impl EarlyLintPass for Pass {
+    extract_msrv_attr!(EarlyContext);
+    fn check_expr(&mut self, _: &EarlyContext<'_>, _: &rustc_ast::Expr) {}
+}
+
+fn main() {}
diff --git a/tests/ui-internal/invalid_msrv_attr_impl.rs b/tests/ui-internal/invalid_msrv_attr_impl.rs
new file mode 100644
index 00000000000..4bc8164db67
--- /dev/null
+++ b/tests/ui-internal/invalid_msrv_attr_impl.rs
@@ -0,0 +1,38 @@
+// run-rustfix
+
+#![deny(clippy::internal)]
+#![allow(clippy::missing_clippy_version_attribute)]
+#![feature(rustc_private)]
+
+extern crate rustc_ast;
+extern crate rustc_hir;
+extern crate rustc_lint;
+extern crate rustc_middle;
+#[macro_use]
+extern crate rustc_session;
+use clippy_utils::extract_msrv_attr;
+use rustc_hir::Expr;
+use rustc_lint::{EarlyContext, EarlyLintPass, LateContext, LateLintPass};
+use rustc_semver::RustcVersion;
+
+declare_lint! {
+    pub TEST_LINT,
+    Warn,
+    ""
+}
+
+struct Pass {
+    msrv: Option<RustcVersion>,
+}
+
+impl_lint_pass!(Pass => [TEST_LINT]);
+
+impl LateLintPass<'_> for Pass {
+    fn check_expr(&mut self, _: &LateContext<'_>, _: &Expr<'_>) {}
+}
+
+impl EarlyLintPass for Pass {
+    fn check_expr(&mut self, _: &EarlyContext<'_>, _: &rustc_ast::Expr) {}
+}
+
+fn main() {}
diff --git a/tests/ui-internal/invalid_msrv_attr_impl.stderr b/tests/ui-internal/invalid_msrv_attr_impl.stderr
new file mode 100644
index 00000000000..ddc06f0be1b
--- /dev/null
+++ b/tests/ui-internal/invalid_msrv_attr_impl.stderr
@@ -0,0 +1,32 @@
+error: `extract_msrv_attr!` macro missing from `LateLintPass` implementation
+  --> $DIR/invalid_msrv_attr_impl.rs:30:1
+   |
+LL | impl LateLintPass<'_> for Pass {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: the lint level is defined here
+  --> $DIR/invalid_msrv_attr_impl.rs:3:9
+   |
+LL | #![deny(clippy::internal)]
+   |         ^^^^^^^^^^^^^^^^
+   = note: `#[deny(clippy::missing_msrv_attr_impl)]` implied by `#[deny(clippy::internal)]`
+help: add `extract_msrv_attr!(LateContext)` to the `LateLintPass` implementation
+   |
+LL + impl LateLintPass<'_> for Pass {
+LL +     extract_msrv_attr!(LateContext);
+   |
+
+error: `extract_msrv_attr!` macro missing from `EarlyLintPass` implementation
+  --> $DIR/invalid_msrv_attr_impl.rs:34:1
+   |
+LL | impl EarlyLintPass for Pass {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: add `extract_msrv_attr!(EarlyContext)` to the `EarlyLintPass` implementation
+   |
+LL + impl EarlyLintPass for Pass {
+LL +     extract_msrv_attr!(EarlyContext);
+   |
+
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 2a588d810fdce164c24b4de82a195da6709c47d0 Mon Sep 17 00:00:00 2001
From: "Samuel E. Moelius III" <sam@moeli.us>
Date: Mon, 28 Feb 2022 19:17:45 -0500
Subject: Add `unnecessary_find_map` lint

---
 CHANGELOG.md                                       |  1 +
 clippy_lints/src/lib.register_all.rs               |  1 +
 clippy_lints/src/lib.register_complexity.rs        |  1 +
 clippy_lints/src/lib.register_lints.rs             |  1 +
 clippy_lints/src/methods/mod.rs                    | 38 ++++++++++++++++++++--
 clippy_lints/src/methods/unnecessary_filter_map.rs | 38 +++++++++++++---------
 tests/ui/unnecessary_find_map.rs                   | 23 +++++++++++++
 tests/ui/unnecessary_find_map.stderr               | 38 ++++++++++++++++++++++
 8 files changed, 124 insertions(+), 17 deletions(-)
 create mode 100644 tests/ui/unnecessary_find_map.rs
 create mode 100644 tests/ui/unnecessary_find_map.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 35983b7fb50..073d4d46474 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3498,6 +3498,7 @@ Released 2018-09-13
 [`unit_return_expecting_ord`]: https://rust-lang.github.io/rust-clippy/master/index.html#unit_return_expecting_ord
 [`unnecessary_cast`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_cast
 [`unnecessary_filter_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_filter_map
+[`unnecessary_find_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_find_map
 [`unnecessary_fold`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_fold
 [`unnecessary_lazy_evaluations`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_lazy_evaluations
 [`unnecessary_mut_passed`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_mut_passed
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index f6d467941e3..8116f367c16 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -189,6 +189,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(methods::SUSPICIOUS_SPLITN),
     LintId::of(methods::UNINIT_ASSUMED_INIT),
     LintId::of(methods::UNNECESSARY_FILTER_MAP),
+    LintId::of(methods::UNNECESSARY_FIND_MAP),
     LintId::of(methods::UNNECESSARY_FOLD),
     LintId::of(methods::UNNECESSARY_LAZY_EVALUATIONS),
     LintId::of(methods::UNNECESSARY_TO_OWNED),
diff --git a/clippy_lints/src/lib.register_complexity.rs b/clippy_lints/src/lib.register_complexity.rs
index bd5ff613447..5d588ac6649 100644
--- a/clippy_lints/src/lib.register_complexity.rs
+++ b/clippy_lints/src/lib.register_complexity.rs
@@ -49,6 +49,7 @@ store.register_group(true, "clippy::complexity", Some("clippy_complexity"), vec!
     LintId::of(methods::SEARCH_IS_SOME),
     LintId::of(methods::SKIP_WHILE_NEXT),
     LintId::of(methods::UNNECESSARY_FILTER_MAP),
+    LintId::of(methods::UNNECESSARY_FIND_MAP),
     LintId::of(methods::USELESS_ASREF),
     LintId::of(misc::SHORT_CIRCUIT_STATEMENT),
     LintId::of(misc_early::UNNEEDED_WILDCARD_PATTERN),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 686482671b4..04e2557403f 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -323,6 +323,7 @@ store.register_lints(&[
     methods::SUSPICIOUS_SPLITN,
     methods::UNINIT_ASSUMED_INIT,
     methods::UNNECESSARY_FILTER_MAP,
+    methods::UNNECESSARY_FIND_MAP,
     methods::UNNECESSARY_FOLD,
     methods::UNNECESSARY_LAZY_EVALUATIONS,
     methods::UNNECESSARY_TO_OWNED,
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 3021a40fae1..581f4c8b0e2 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1309,7 +1309,7 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for `filter_map` calls which could be replaced by `filter` or `map`.
+    /// Checks for `filter_map` calls that could be replaced by `filter` or `map`.
     /// More specifically it checks if the closure provided is only performing one of the
     /// filter or map operations and suggests the appropriate option.
     ///
@@ -1337,6 +1337,36 @@ declare_clippy_lint! {
     "using `filter_map` when a more succinct alternative exists"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `find_map` calls that could be replaced by `find` or `map`. More
+    /// specifically it checks if the closure provided is only performing one of the
+    /// find or map operations and suggests the appropriate option.
+    ///
+    /// ### Why is this bad?
+    /// Complexity. The intent is also clearer if only a single
+    /// operation is being performed.
+    ///
+    /// ### Example
+    /// ```rust
+    /// let _ = (0..3).find_map(|x| if x > 2 { Some(x) } else { None });
+    ///
+    /// // As there is no transformation of the argument this could be written as:
+    /// let _ = (0..3).find(|&x| x > 2);
+    /// ```
+    ///
+    /// ```rust
+    /// let _ = (0..4).find_map(|x| Some(x + 1));
+    ///
+    /// // As there is no conditional check on the argument this could be written as:
+    /// let _ = (0..4).map(|x| x + 1).next();
+    /// ```
+    #[clippy::version = "1.61.0"]
+    pub UNNECESSARY_FIND_MAP,
+    complexity,
+    "using `find_map` when a more succinct alternative exists"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for `into_iter` calls on references which should be replaced by `iter`
@@ -2020,6 +2050,7 @@ impl_lint_pass!(Methods => [
     USELESS_ASREF,
     UNNECESSARY_FOLD,
     UNNECESSARY_FILTER_MAP,
+    UNNECESSARY_FIND_MAP,
     INTO_ITER_ON_REF,
     SUSPICIOUS_MAP,
     UNINIT_ASSUMED_INIT,
@@ -2305,9 +2336,12 @@ fn check_methods<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, msrv: Optio
                 extend_with_drain::check(cx, expr, recv, arg);
             },
             ("filter_map", [arg]) => {
-                unnecessary_filter_map::check(cx, expr, arg);
+                unnecessary_filter_map::check(cx, expr, arg, name);
                 filter_map_identity::check(cx, expr, arg, span);
             },
+            ("find_map", [arg]) => {
+                unnecessary_filter_map::check(cx, expr, arg, name);
+            },
             ("flat_map", [arg]) => {
                 flat_map_identity::check(cx, expr, arg, span);
                 flat_map_option::check(cx, expr, arg, span);
diff --git a/clippy_lints/src/methods/unnecessary_filter_map.rs b/clippy_lints/src/methods/unnecessary_filter_map.rs
index 108e143f337..9e48cd13b4c 100644
--- a/clippy_lints/src/methods/unnecessary_filter_map.rs
+++ b/clippy_lints/src/methods/unnecessary_filter_map.rs
@@ -11,8 +11,9 @@ use rustc_middle::ty;
 use rustc_span::sym;
 
 use super::UNNECESSARY_FILTER_MAP;
+use super::UNNECESSARY_FIND_MAP;
 
-pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, arg: &hir::Expr<'_>) {
+pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, arg: &hir::Expr<'_>, name: &str) {
     if !is_trait_method(cx, expr, sym::Iterator) {
         return;
     }
@@ -32,23 +33,30 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, arg: &hir::Expr<
         found_filtering |= return_visitor.found_filtering;
 
         let in_ty = cx.typeck_results().node_type(body.params[0].hir_id);
-        let sugg = if !found_filtering {
-            "map"
-        } else if !found_mapping && !mutates_arg && (!clone_or_copy_needed || is_copy(cx, in_ty)) {
-            match cx.typeck_results().expr_ty(&body.value).kind() {
-                ty::Adt(adt, subst) if cx.tcx.is_diagnostic_item(sym::Option, adt.did) && in_ty == subst.type_at(0) => {
-                    "filter"
-                },
-                _ => return,
-            }
-        } else {
-            return;
-        };
+        let sugg =
+            if !found_filtering {
+                if name == "filter_map" { "map" } else { "map(..).next()" }
+            } else if !found_mapping && !mutates_arg && (!clone_or_copy_needed || is_copy(cx, in_ty)) {
+                match cx.typeck_results().expr_ty(&body.value).kind() {
+                    ty::Adt(adt, subst)
+                        if cx.tcx.is_diagnostic_item(sym::Option, adt.did) && in_ty == subst.type_at(0) =>
+                    {
+                        if name == "filter_map" { "filter" } else { "find" }
+                    },
+                    _ => return,
+                }
+            } else {
+                return;
+            };
         span_lint(
             cx,
-            UNNECESSARY_FILTER_MAP,
+            if name == "filter_map" {
+                UNNECESSARY_FILTER_MAP
+            } else {
+                UNNECESSARY_FIND_MAP
+            },
             expr.span,
-            &format!("this `.filter_map` can be written more simply using `.{}`", sugg),
+            &format!("this `.{}` can be written more simply using `.{}`", name, sugg),
         );
     }
 }
diff --git a/tests/ui/unnecessary_find_map.rs b/tests/ui/unnecessary_find_map.rs
new file mode 100644
index 00000000000..a52390861b4
--- /dev/null
+++ b/tests/ui/unnecessary_find_map.rs
@@ -0,0 +1,23 @@
+#![allow(dead_code)]
+
+fn main() {
+    let _ = (0..4).find_map(|x| if x > 1 { Some(x) } else { None });
+    let _ = (0..4).find_map(|x| {
+        if x > 1 {
+            return Some(x);
+        };
+        None
+    });
+    let _ = (0..4).find_map(|x| match x {
+        0 | 1 => None,
+        _ => Some(x),
+    });
+
+    let _ = (0..4).find_map(|x| Some(x + 1));
+
+    let _ = (0..4).find_map(i32::checked_abs);
+}
+
+fn find_map_none_changes_item_type() -> Option<bool> {
+    "".chars().find_map(|_| None)
+}
diff --git a/tests/ui/unnecessary_find_map.stderr b/tests/ui/unnecessary_find_map.stderr
new file mode 100644
index 00000000000..fb33c122fe3
--- /dev/null
+++ b/tests/ui/unnecessary_find_map.stderr
@@ -0,0 +1,38 @@
+error: this `.find_map` can be written more simply using `.find`
+  --> $DIR/unnecessary_find_map.rs:4:13
+   |
+LL |     let _ = (0..4).find_map(|x| if x > 1 { Some(x) } else { None });
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::unnecessary-find-map` implied by `-D warnings`
+
+error: this `.find_map` can be written more simply using `.find`
+  --> $DIR/unnecessary_find_map.rs:5:13
+   |
+LL |       let _ = (0..4).find_map(|x| {
+   |  _____________^
+LL | |         if x > 1 {
+LL | |             return Some(x);
+LL | |         };
+LL | |         None
+LL | |     });
+   | |______^
+
+error: this `.find_map` can be written more simply using `.find`
+  --> $DIR/unnecessary_find_map.rs:11:13
+   |
+LL |       let _ = (0..4).find_map(|x| match x {
+   |  _____________^
+LL | |         0 | 1 => None,
+LL | |         _ => Some(x),
+LL | |     });
+   | |______^
+
+error: this `.find_map` can be written more simply using `.map(..).next()`
+  --> $DIR/unnecessary_find_map.rs:16:13
+   |
+LL |     let _ = (0..4).find_map(|x| Some(x + 1));
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 4 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 9f1080cc6e46bb462fedb1869c4c0f04273b43f8 Mon Sep 17 00:00:00 2001
From: Andre Bogus <bogusandre@gmail.com>
Date: Sun, 26 Dec 2021 10:00:29 +0100
Subject: new lint: `missing-spin-loop`

---
 CHANGELOG.md                                |  1 +
 clippy_lints/src/lib.register_all.rs        |  1 +
 clippy_lints/src/lib.register_lints.rs      |  1 +
 clippy_lints/src/lib.register_perf.rs       |  1 +
 clippy_lints/src/loops/missing_spin_loop.rs | 56 +++++++++++++++++++++++++++++
 clippy_lints/src/loops/mod.rs               | 39 ++++++++++++++++++++
 tests/ui/missing_spin_loop.fixed            | 28 +++++++++++++++
 tests/ui/missing_spin_loop.rs               | 28 +++++++++++++++
 tests/ui/missing_spin_loop.stderr           | 40 +++++++++++++++++++++
 tests/ui/missing_spin_loop_no_std.fixed     | 23 ++++++++++++
 tests/ui/missing_spin_loop_no_std.rs        | 23 ++++++++++++
 tests/ui/missing_spin_loop_no_std.stderr    | 10 ++++++
 12 files changed, 251 insertions(+)
 create mode 100644 clippy_lints/src/loops/missing_spin_loop.rs
 create mode 100644 tests/ui/missing_spin_loop.fixed
 create mode 100644 tests/ui/missing_spin_loop.rs
 create mode 100644 tests/ui/missing_spin_loop.stderr
 create mode 100644 tests/ui/missing_spin_loop_no_std.fixed
 create mode 100644 tests/ui/missing_spin_loop_no_std.rs
 create mode 100644 tests/ui/missing_spin_loop_no_std.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 35983b7fb50..c936e35dc1b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3297,6 +3297,7 @@ Released 2018-09-13
 [`missing_inline_in_public_items`]: https://rust-lang.github.io/rust-clippy/master/index.html#missing_inline_in_public_items
 [`missing_panics_doc`]: https://rust-lang.github.io/rust-clippy/master/index.html#missing_panics_doc
 [`missing_safety_doc`]: https://rust-lang.github.io/rust-clippy/master/index.html#missing_safety_doc
+[`missing_spin_loop`]: https://rust-lang.github.io/rust-clippy/master/index.html#missing_spin_loop
 [`mistyped_literal_suffixes`]: https://rust-lang.github.io/rust-clippy/master/index.html#mistyped_literal_suffixes
 [`mixed_case_hex_literals`]: https://rust-lang.github.io/rust-clippy/master/index.html#mixed_case_hex_literals
 [`mod_module_files`]: https://rust-lang.github.io/rust-clippy/master/index.html#mod_module_files
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index f6d467941e3..a6d9f9d0c22 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -109,6 +109,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(loops::ITER_NEXT_LOOP),
     LintId::of(loops::MANUAL_FLATTEN),
     LintId::of(loops::MANUAL_MEMCPY),
+    LintId::of(loops::MISSING_SPIN_LOOP),
     LintId::of(loops::MUT_RANGE_BOUND),
     LintId::of(loops::NEEDLESS_COLLECT),
     LintId::of(loops::NEEDLESS_RANGE_LOOP),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index f9337114038..59e94029eed 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -221,6 +221,7 @@ store.register_lints(&[
     loops::ITER_NEXT_LOOP,
     loops::MANUAL_FLATTEN,
     loops::MANUAL_MEMCPY,
+    loops::MISSING_SPIN_LOOP,
     loops::MUT_RANGE_BOUND,
     loops::NEEDLESS_COLLECT,
     loops::NEEDLESS_RANGE_LOOP,
diff --git a/clippy_lints/src/lib.register_perf.rs b/clippy_lints/src/lib.register_perf.rs
index c44ef124bfa..f2f5c988d8f 100644
--- a/clippy_lints/src/lib.register_perf.rs
+++ b/clippy_lints/src/lib.register_perf.rs
@@ -10,6 +10,7 @@ store.register_group(true, "clippy::perf", Some("clippy_perf"), vec![
     LintId::of(large_const_arrays::LARGE_CONST_ARRAYS),
     LintId::of(large_enum_variant::LARGE_ENUM_VARIANT),
     LintId::of(loops::MANUAL_MEMCPY),
+    LintId::of(loops::MISSING_SPIN_LOOP),
     LintId::of(loops::NEEDLESS_COLLECT),
     LintId::of(methods::EXPECT_FUN_CALL),
     LintId::of(methods::EXTEND_WITH_DRAIN),
diff --git a/clippy_lints/src/loops/missing_spin_loop.rs b/clippy_lints/src/loops/missing_spin_loop.rs
new file mode 100644
index 00000000000..15cafa0b530
--- /dev/null
+++ b/clippy_lints/src/loops/missing_spin_loop.rs
@@ -0,0 +1,56 @@
+use super::MISSING_SPIN_LOOP;
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::is_no_std_crate;
+use rustc_errors::Applicability;
+use rustc_hir::{Block, Expr, ExprKind};
+use rustc_lint::LateContext;
+use rustc_middle::ty;
+use rustc_span::sym;
+
+fn unpack_cond<'tcx>(cond: &'tcx Expr<'tcx>) -> &'tcx Expr<'tcx> {
+    match &cond.kind {
+        ExprKind::Block(
+            Block {
+                stmts: [],
+                expr: Some(e),
+                ..
+            },
+            _,
+        )
+        | ExprKind::Unary(_, e) => unpack_cond(e),
+        ExprKind::Binary(_, l, r) => {
+            let l = unpack_cond(l);
+            if let ExprKind::MethodCall(..) = l.kind {
+                l
+            } else {
+                unpack_cond(r)
+            }
+        },
+        _ => cond,
+    }
+}
+
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, cond: &'tcx Expr<'_>, body: &'tcx Expr<'_>) {
+    if_chain! {
+        if let ExprKind::Block(Block { stmts: [], expr: None, ..}, _) = body.kind;
+        if let ExprKind::MethodCall(method, [callee, ..], _) = unpack_cond(cond).kind;
+        if [sym::load, sym::compare_exchange, sym::compare_exchange_weak].contains(&method.ident.name);
+        if let ty::Adt(def, _substs) = cx.typeck_results().expr_ty(callee).kind();
+        if cx.tcx.is_diagnostic_item(sym::AtomicBool, def.did);
+        then {
+            span_lint_and_sugg(
+                cx,
+                MISSING_SPIN_LOOP,
+                body.span,
+                "busy-waiting loop should at least have a spin loop hint",
+                "try this",
+                (if is_no_std_crate(cx) {
+                    "{ core::hint::spin_loop() }"
+                } else {
+                    "{ std::hint::spin_loop() }"
+                }).into(),
+                Applicability::MachineApplicable
+            );
+        }
+    }
+}
diff --git a/clippy_lints/src/loops/mod.rs b/clippy_lints/src/loops/mod.rs
index 5bc32acf56e..f029067d367 100644
--- a/clippy_lints/src/loops/mod.rs
+++ b/clippy_lints/src/loops/mod.rs
@@ -7,6 +7,7 @@ mod for_loops_over_fallibles;
 mod iter_next_loop;
 mod manual_flatten;
 mod manual_memcpy;
+mod missing_spin_loop;
 mod mut_range_bound;
 mod needless_collect;
 mod needless_range_loop;
@@ -560,6 +561,42 @@ declare_clippy_lint! {
     "for loops over `Option`s or `Result`s with a single expression can be simplified"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Check for empty spin loops
+    ///
+    /// ### Why is this bad?
+    /// The loop body should have something like `thread::park()` or at least
+    /// `std::hint::spin_loop()` to avoid needlessly burning cycles and conserve
+    /// energy. Perhaps even better use an actual lock, if possible.
+    ///
+    /// ### Known problems
+    /// This lint doesn't currently trigger on `while let` or
+    /// `loop { match .. { .. } }` loops, which would be considered idiomatic in
+    /// combination with e.g. `AtomicBool::compare_exchange_weak`.
+    ///
+    /// ### Example
+    ///
+    /// ```ignore
+    /// use core::sync::atomic::{AtomicBool, Ordering};
+    /// let b = AtomicBool::new(true);
+    /// // give a ref to `b` to another thread,wait for it to become false
+    /// while b.load(Ordering::Acquire) {};
+    /// ```
+    /// Use instead:
+    /// ```rust,no_run
+    ///# use core::sync::atomic::{AtomicBool, Ordering};
+    ///# let b = AtomicBool::new(true);
+    /// while b.load(Ordering::Acquire) {
+    ///     std::hint::spin_loop()
+    /// }
+    /// ```
+    #[clippy::version = "1.59.0"]
+    pub MISSING_SPIN_LOOP,
+    perf,
+    "An empty busy waiting loop"
+}
+
 declare_lint_pass!(Loops => [
     MANUAL_MEMCPY,
     MANUAL_FLATTEN,
@@ -579,6 +616,7 @@ declare_lint_pass!(Loops => [
     WHILE_IMMUTABLE_CONDITION,
     SAME_ITEM_PUSH,
     SINGLE_ELEMENT_LOOP,
+    MISSING_SPIN_LOOP,
 ]);
 
 impl<'tcx> LateLintPass<'tcx> for Loops {
@@ -628,6 +666,7 @@ impl<'tcx> LateLintPass<'tcx> for Loops {
 
         if let Some(higher::While { condition, body }) = higher::While::hir(expr) {
             while_immutable_condition::check(cx, condition, body);
+            missing_spin_loop::check(cx, condition, body);
         }
 
         needless_collect::check(expr, cx);
diff --git a/tests/ui/missing_spin_loop.fixed b/tests/ui/missing_spin_loop.fixed
new file mode 100644
index 00000000000..aa89e04d26e
--- /dev/null
+++ b/tests/ui/missing_spin_loop.fixed
@@ -0,0 +1,28 @@
+// run-rustfix
+#![warn(clippy::missing_spin_loop)]
+#![allow(clippy::bool_comparison)]
+#![allow(unused_braces)]
+
+use core::sync::atomic::{AtomicBool, Ordering};
+
+fn main() {
+    let b = AtomicBool::new(true);
+    // Those should lint
+    while b.load(Ordering::Acquire) { std::hint::spin_loop() }
+
+    while !b.load(Ordering::SeqCst) { std::hint::spin_loop() }
+
+    while b.load(Ordering::Acquire) == false { std::hint::spin_loop() }
+
+    while { true == b.load(Ordering::Acquire) } { std::hint::spin_loop() }
+
+    while b.compare_exchange(true, false, Ordering::Acquire, Ordering::Relaxed) != Ok(true) { std::hint::spin_loop() }
+
+    while Ok(false) != b.compare_exchange(false, true, Ordering::Acquire, Ordering::Relaxed) { std::hint::spin_loop() }
+
+    // This is OK, as the body is not empty
+    while b.load(Ordering::Acquire) {
+        std::hint::spin_loop()
+    }
+    // TODO: also match on loop+match or while let
+}
diff --git a/tests/ui/missing_spin_loop.rs b/tests/ui/missing_spin_loop.rs
new file mode 100644
index 00000000000..88745e47732
--- /dev/null
+++ b/tests/ui/missing_spin_loop.rs
@@ -0,0 +1,28 @@
+// run-rustfix
+#![warn(clippy::missing_spin_loop)]
+#![allow(clippy::bool_comparison)]
+#![allow(unused_braces)]
+
+use core::sync::atomic::{AtomicBool, Ordering};
+
+fn main() {
+    let b = AtomicBool::new(true);
+    // Those should lint
+    while b.load(Ordering::Acquire) {}
+
+    while !b.load(Ordering::SeqCst) {}
+
+    while b.load(Ordering::Acquire) == false {}
+
+    while { true == b.load(Ordering::Acquire) } {}
+
+    while b.compare_exchange(true, false, Ordering::Acquire, Ordering::Relaxed) != Ok(true) {}
+
+    while Ok(false) != b.compare_exchange(false, true, Ordering::Acquire, Ordering::Relaxed) {}
+
+    // This is OK, as the body is not empty
+    while b.load(Ordering::Acquire) {
+        std::hint::spin_loop()
+    }
+    // TODO: also match on loop+match or while let
+}
diff --git a/tests/ui/missing_spin_loop.stderr b/tests/ui/missing_spin_loop.stderr
new file mode 100644
index 00000000000..485da00dc64
--- /dev/null
+++ b/tests/ui/missing_spin_loop.stderr
@@ -0,0 +1,40 @@
+error: busy-waiting loop should at least have a spin loop hint
+  --> $DIR/missing_spin_loop.rs:11:37
+   |
+LL |     while b.load(Ordering::Acquire) {}
+   |                                     ^^ help: try this: `{ std::hint::spin_loop() }`
+   |
+   = note: `-D clippy::missing-spin-loop` implied by `-D warnings`
+
+error: busy-waiting loop should at least have a spin loop hint
+  --> $DIR/missing_spin_loop.rs:13:37
+   |
+LL |     while !b.load(Ordering::SeqCst) {}
+   |                                     ^^ help: try this: `{ std::hint::spin_loop() }`
+
+error: busy-waiting loop should at least have a spin loop hint
+  --> $DIR/missing_spin_loop.rs:15:46
+   |
+LL |     while b.load(Ordering::Acquire) == false {}
+   |                                              ^^ help: try this: `{ std::hint::spin_loop() }`
+
+error: busy-waiting loop should at least have a spin loop hint
+  --> $DIR/missing_spin_loop.rs:17:49
+   |
+LL |     while { true == b.load(Ordering::Acquire) } {}
+   |                                                 ^^ help: try this: `{ std::hint::spin_loop() }`
+
+error: busy-waiting loop should at least have a spin loop hint
+  --> $DIR/missing_spin_loop.rs:19:93
+   |
+LL |     while b.compare_exchange(true, false, Ordering::Acquire, Ordering::Relaxed) != Ok(true) {}
+   |                                                                                             ^^ help: try this: `{ std::hint::spin_loop() }`
+
+error: busy-waiting loop should at least have a spin loop hint
+  --> $DIR/missing_spin_loop.rs:21:94
+   |
+LL |     while Ok(false) != b.compare_exchange(false, true, Ordering::Acquire, Ordering::Relaxed) {}
+   |                                                                                              ^^ help: try this: `{ std::hint::spin_loop() }`
+
+error: aborting due to 6 previous errors
+
diff --git a/tests/ui/missing_spin_loop_no_std.fixed b/tests/ui/missing_spin_loop_no_std.fixed
new file mode 100644
index 00000000000..bb4b4795516
--- /dev/null
+++ b/tests/ui/missing_spin_loop_no_std.fixed
@@ -0,0 +1,23 @@
+// run-rustfix
+#![warn(clippy::missing_spin_loop)]
+#![feature(lang_items, start, libc)]
+#![no_std]
+
+use core::sync::atomic::{AtomicBool, Ordering};
+
+#[start]
+fn main(_argc: isize, _argv: *const *const u8) -> isize {
+    // This should trigger the lint
+    let b = AtomicBool::new(true);
+    // This should lint with `core::hint::spin_loop()`
+    while b.load(Ordering::Acquire) { core::hint::spin_loop() }
+    0
+}
+
+#[panic_handler]
+fn panic(_info: &core::panic::PanicInfo) -> ! {
+    loop {}
+}
+
+#[lang = "eh_personality"]
+extern "C" fn eh_personality() {}
diff --git a/tests/ui/missing_spin_loop_no_std.rs b/tests/ui/missing_spin_loop_no_std.rs
new file mode 100644
index 00000000000..a19bc72baf8
--- /dev/null
+++ b/tests/ui/missing_spin_loop_no_std.rs
@@ -0,0 +1,23 @@
+// run-rustfix
+#![warn(clippy::missing_spin_loop)]
+#![feature(lang_items, start, libc)]
+#![no_std]
+
+use core::sync::atomic::{AtomicBool, Ordering};
+
+#[start]
+fn main(_argc: isize, _argv: *const *const u8) -> isize {
+    // This should trigger the lint
+    let b = AtomicBool::new(true);
+    // This should lint with `core::hint::spin_loop()`
+    while b.load(Ordering::Acquire) {}
+    0
+}
+
+#[panic_handler]
+fn panic(_info: &core::panic::PanicInfo) -> ! {
+    loop {}
+}
+
+#[lang = "eh_personality"]
+extern "C" fn eh_personality() {}
diff --git a/tests/ui/missing_spin_loop_no_std.stderr b/tests/ui/missing_spin_loop_no_std.stderr
new file mode 100644
index 00000000000..2b3b6873c3c
--- /dev/null
+++ b/tests/ui/missing_spin_loop_no_std.stderr
@@ -0,0 +1,10 @@
+error: busy-waiting loop should at least have a spin loop hint
+  --> $DIR/missing_spin_loop_no_std.rs:13:37
+   |
+LL |     while b.load(Ordering::Acquire) {}
+   |                                     ^^ help: try this: `{ core::hint::spin_loop() }`
+   |
+   = note: `-D clippy::missing-spin-loop` implied by `-D warnings`
+
+error: aborting due to previous error
+
-- 
cgit 1.4.1-3-g733a5


From 6cc2eeaa56b6f37f6c44a39e8b137fb22731aedc Mon Sep 17 00:00:00 2001
From: Liu Dingming <liudingming@bytedance.com>
Date: Sun, 13 Feb 2022 03:14:04 +0800
Subject: Suggest `into_iter()` over `drain(..)`

Add doc

Add description

iter_with_drain dogfood

Disable emiting on struct field.

Fix clippy

Add eq_path for SpanlessEq

Fix tests

Better error message

Fix doc test

Fix version

Apply suggestions
---
 CHANGELOG.md                                       |  1 +
 clippy_lints/src/lib.register_all.rs               |  1 +
 clippy_lints/src/lib.register_lints.rs             |  1 +
 clippy_lints/src/lib.register_perf.rs              |  1 +
 clippy_lints/src/methods/iter_with_drain.rs        | 72 ++++++++++++++++++++++
 clippy_lints/src/methods/mod.rs                    | 30 +++++++++
 clippy_lints/src/suspicious_operation_groupings.rs |  8 +--
 .../src/utils/internal_lints/metadata_collector.rs |  6 +-
 clippy_utils/src/hir_utils.rs                      |  6 +-
 tests/ui/extend_with_drain.fixed                   |  4 +-
 tests/ui/extend_with_drain.rs                      |  4 +-
 tests/ui/iter_with_drain.fixed                     | 56 +++++++++++++++++
 tests/ui/iter_with_drain.rs                        | 56 +++++++++++++++++
 tests/ui/iter_with_drain.stderr                    | 40 ++++++++++++
 tests/ui/range_plus_minus_one.fixed                |  2 +-
 tests/ui/range_plus_minus_one.rs                   |  2 +-
 16 files changed, 276 insertions(+), 14 deletions(-)
 create mode 100644 clippy_lints/src/methods/iter_with_drain.rs
 create mode 100644 tests/ui/iter_with_drain.fixed
 create mode 100644 tests/ui/iter_with_drain.rs
 create mode 100644 tests/ui/iter_with_drain.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 1ab879ba9ee..7f18a00a9dd 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3225,6 +3225,7 @@ Released 2018-09-13
 [`iter_nth_zero`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_nth_zero
 [`iter_overeager_cloned`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_overeager_cloned
 [`iter_skip_next`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_skip_next
+[`iter_with_drain`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_with_drain
 [`iterator_step_by_zero`]: https://rust-lang.github.io/rust-clippy/master/index.html#iterator_step_by_zero
 [`just_underscores_and_digits`]: https://rust-lang.github.io/rust-clippy/master/index.html#just_underscores_and_digits
 [`large_const_arrays`]: https://rust-lang.github.io/rust-clippy/master/index.html#large_const_arrays
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 4484f6e1960..f388ae7ce60 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -164,6 +164,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(methods::ITER_NTH_ZERO),
     LintId::of(methods::ITER_OVEREAGER_CLONED),
     LintId::of(methods::ITER_SKIP_NEXT),
+    LintId::of(methods::ITER_WITH_DRAIN),
     LintId::of(methods::MANUAL_FILTER_MAP),
     LintId::of(methods::MANUAL_FIND_MAP),
     LintId::of(methods::MANUAL_SATURATING_ARITHMETIC),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index c34d8f46e09..d248c2a41ee 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -299,6 +299,7 @@ store.register_lints(&[
     methods::ITER_NTH_ZERO,
     methods::ITER_OVEREAGER_CLONED,
     methods::ITER_SKIP_NEXT,
+    methods::ITER_WITH_DRAIN,
     methods::MANUAL_FILTER_MAP,
     methods::MANUAL_FIND_MAP,
     methods::MANUAL_SATURATING_ARITHMETIC,
diff --git a/clippy_lints/src/lib.register_perf.rs b/clippy_lints/src/lib.register_perf.rs
index f2f5c988d8f..6e9c0ee33a1 100644
--- a/clippy_lints/src/lib.register_perf.rs
+++ b/clippy_lints/src/lib.register_perf.rs
@@ -16,6 +16,7 @@ store.register_group(true, "clippy::perf", Some("clippy_perf"), vec![
     LintId::of(methods::EXTEND_WITH_DRAIN),
     LintId::of(methods::ITER_NTH),
     LintId::of(methods::ITER_OVEREAGER_CLONED),
+    LintId::of(methods::ITER_WITH_DRAIN),
     LintId::of(methods::MANUAL_STR_REPEAT),
     LintId::of(methods::OR_FUN_CALL),
     LintId::of(methods::SINGLE_CHAR_PATTERN),
diff --git a/clippy_lints/src/methods/iter_with_drain.rs b/clippy_lints/src/methods/iter_with_drain.rs
new file mode 100644
index 00000000000..958c3773087
--- /dev/null
+++ b/clippy_lints/src/methods/iter_with_drain.rs
@@ -0,0 +1,72 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::is_integer_const;
+use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::{
+    higher::{self, Range},
+    SpanlessEq,
+};
+use rustc_ast::ast::RangeLimits;
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind, QPath};
+use rustc_lint::LateContext;
+use rustc_span::symbol::{sym, Symbol};
+use rustc_span::Span;
+
+use super::ITER_WITH_DRAIN;
+
+const DRAIN_TYPES: &[Symbol] = &[sym::Vec, sym::VecDeque];
+
+pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'_>, span: Span, arg: &Expr<'_>) {
+    let ty = cx.typeck_results().expr_ty(recv).peel_refs();
+    if let Some(drained_type) = DRAIN_TYPES.iter().find(|&&sym| is_type_diagnostic_item(cx, ty, sym)) {
+        // Refuse to emit `into_iter` suggestion on draining struct fields due
+        // to the strong possibility of processing unmovable field.
+        if let ExprKind::Field(..) = recv.kind {
+            return;
+        }
+
+        if let Some(range) = higher::Range::hir(arg) {
+            let left_full = match range {
+                Range { start: Some(start), .. } if is_integer_const(cx, start, 0) => true,
+                Range { start: None, .. } => true,
+                _ => false,
+            };
+            let full = left_full
+                && match range {
+                    Range {
+                        end: Some(end),
+                        limits: RangeLimits::HalfOpen,
+                        ..
+                    } => {
+                        // `x.drain(..x.len())` call
+                        if_chain! {
+                            if let ExprKind::MethodCall(len_path, len_args, _) = end.kind;
+                            if len_path.ident.name == sym::len && len_args.len() == 1;
+                            if let ExprKind::Path(QPath::Resolved(_, drain_path)) = recv.kind;
+                            if let ExprKind::Path(QPath::Resolved(_, len_path)) = len_args[0].kind;
+                            if SpanlessEq::new(cx).eq_path(drain_path, len_path);
+                            then { true }
+                            else { false }
+                        }
+                    },
+                    Range {
+                        end: None,
+                        limits: RangeLimits::HalfOpen,
+                        ..
+                    } => true,
+                    _ => false,
+                };
+            if full {
+                span_lint_and_sugg(
+                    cx,
+                    ITER_WITH_DRAIN,
+                    span.with_hi(expr.span.hi()),
+                    &format!("`drain(..)` used on a `{}`", drained_type),
+                    "try this",
+                    "into_iter()".to_string(),
+                    Applicability::MaybeIncorrect,
+                );
+            }
+        }
+    }
+}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 581f4c8b0e2..5edd22cd14c 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -32,6 +32,7 @@ mod iter_nth;
 mod iter_nth_zero;
 mod iter_overeager_cloned;
 mod iter_skip_next;
+mod iter_with_drain;
 mod iterator_step_by_zero;
 mod manual_saturating_arithmetic;
 mod manual_str_repeat;
@@ -1118,6 +1119,31 @@ declare_clippy_lint! {
     "using `.skip(x).next()` on an iterator"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for use of `.drain(..)` on `Vec` and `VecDeque` for iteration.
+    ///
+    /// ### Why is this bad?
+    /// `.into_iter()` is simpler with better performance.
+    ///
+    /// ### Example
+    /// ```rust
+    /// # use std::collections::HashSet;
+    /// let mut foo = vec![0, 1, 2, 3];
+    /// let bar: HashSet<usize> = foo.drain(..).collect();
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// # use std::collections::HashSet;
+    /// let foo = vec![0, 1, 2, 3];
+    /// let bar: HashSet<usize> = foo.into_iter().collect();
+    /// ```
+    #[clippy::version = "1.61.0"]
+    pub ITER_WITH_DRAIN,
+    perf,
+    "replace `.drain(..)` with `.into_iter()`"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for use of `.get().unwrap()` (or
@@ -2047,6 +2073,7 @@ impl_lint_pass!(Methods => [
     GET_UNWRAP,
     STRING_EXTEND_CHARS,
     ITER_CLONED_COLLECT,
+    ITER_WITH_DRAIN,
     USELESS_ASREF,
     UNNECESSARY_FOLD,
     UNNECESSARY_FILTER_MAP,
@@ -2327,6 +2354,9 @@ fn check_methods<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, msrv: Optio
                 Some(("map", [_, arg], _)) => suspicious_map::check(cx, expr, recv, arg),
                 _ => {},
             },
+            ("drain", [arg]) => {
+                iter_with_drain::check(cx, expr, recv, span, arg);
+            },
             ("expect", [_]) => match method_call(recv) {
                 Some(("ok", [recv], _)) => ok_expect::check(cx, expr, recv),
                 _ => expect_used::check(cx, expr, recv),
diff --git a/clippy_lints/src/suspicious_operation_groupings.rs b/clippy_lints/src/suspicious_operation_groupings.rs
index c3d984fb5ae..940a8428f77 100644
--- a/clippy_lints/src/suspicious_operation_groupings.rs
+++ b/clippy_lints/src/suspicious_operation_groupings.rs
@@ -399,9 +399,9 @@ fn if_statment_binops(kind: &ExprKind) -> Option<Vec<BinaryOp<'_>>> {
 
 fn append_opt_vecs<A>(target_opt: Option<Vec<A>>, source_opt: Option<Vec<A>>) -> Option<Vec<A>> {
     match (target_opt, source_opt) {
-        (Some(mut target), Some(mut source)) => {
+        (Some(mut target), Some(source)) => {
             target.reserve(source.len());
-            for op in source.drain(..) {
+            for op in source {
                 target.push(op);
             }
             Some(target)
@@ -436,9 +436,9 @@ fn chained_binops_helper<'expr>(left_outer: &'expr Expr, right_outer: &'expr Exp
             chained_binops_helper(left_left, left_right),
             chained_binops_helper(right_left, right_right),
         ) {
-            (Some(mut left_ops), Some(mut right_ops)) => {
+            (Some(mut left_ops), Some(right_ops)) => {
                 left_ops.reserve(right_ops.len());
-                for op in right_ops.drain(..) {
+                for op in right_ops {
                     left_ops.push(op);
                 }
                 Some(left_ops)
diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index 56633490eaa..a617422bbeb 100644
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -473,7 +473,7 @@ impl<'hir> LateLintPass<'hir> for MetadataCollector {
     /// ```
     fn check_expr(&mut self, cx: &LateContext<'hir>, expr: &'hir hir::Expr<'_>) {
         if let Some(args) = match_lint_emission(cx, expr) {
-            let mut emission_info = extract_emission_info(cx, args);
+            let emission_info = extract_emission_info(cx, args);
             if emission_info.is_empty() {
                 // See:
                 // - src/misc.rs:734:9
@@ -483,7 +483,7 @@ impl<'hir> LateLintPass<'hir> for MetadataCollector {
                 return;
             }
 
-            for (lint_name, applicability, is_multi_part) in emission_info.drain(..) {
+            for (lint_name, applicability, is_multi_part) in emission_info {
                 let app_info = self.applicability_info.entry(lint_name).or_default();
                 app_info.applicability = applicability;
                 app_info.is_multi_part_suggestion = is_multi_part;
@@ -693,7 +693,7 @@ fn extract_emission_info<'hir>(
     }
 
     lints
-        .drain(..)
+        .into_iter()
         .map(|lint_name| (lint_name, applicability, multi_part))
         .collect()
 }
diff --git a/clippy_utils/src/hir_utils.rs b/clippy_utils/src/hir_utils.rs
index 9654895060f..00594f4d42a 100644
--- a/clippy_utils/src/hir_utils.rs
+++ b/clippy_utils/src/hir_utils.rs
@@ -74,6 +74,10 @@ impl<'a, 'tcx> SpanlessEq<'a, 'tcx> {
         self.inter_expr().eq_expr(left, right)
     }
 
+    pub fn eq_path(&mut self, left: &Path<'_>, right: &Path<'_>) -> bool {
+        self.inter_expr().eq_path(left, right)
+    }
+
     pub fn eq_path_segment(&mut self, left: &PathSegment<'_>, right: &PathSegment<'_>) -> bool {
         self.inter_expr().eq_path_segment(left, right)
     }
@@ -362,7 +366,7 @@ impl HirEqInterExpr<'_, '_, '_> {
         }
     }
 
-    fn eq_path(&mut self, left: &Path<'_>, right: &Path<'_>) -> bool {
+    pub fn eq_path(&mut self, left: &Path<'_>, right: &Path<'_>) -> bool {
         match (left.res, right.res) {
             (Res::Local(l), Res::Local(r)) => l == r || self.locals.get(&l) == Some(&r),
             (Res::Local(_), _) | (_, Res::Local(_)) => false,
diff --git a/tests/ui/extend_with_drain.fixed b/tests/ui/extend_with_drain.fixed
index e863870e7d6..71ebad24c16 100644
--- a/tests/ui/extend_with_drain.fixed
+++ b/tests/ui/extend_with_drain.fixed
@@ -1,11 +1,11 @@
 // run-rustfix
 #![warn(clippy::extend_with_drain)]
+#![allow(clippy::iter_with_drain)]
 use std::collections::BinaryHeap;
 fn main() {
     //gets linted
     let mut vec1 = vec![0u8; 1024];
     let mut vec2: std::vec::Vec<u8> = Vec::new();
-
     vec2.append(&mut vec1);
 
     let mut vec3 = vec![0u8; 1024];
@@ -17,7 +17,7 @@ fn main() {
 
     vec11.append(&mut return_vector());
 
-    //won't get linted it dosen't move the entire content of a vec into another
+    //won't get linted it doesn't move the entire content of a vec into another
     let mut test1 = vec![0u8, 10];
     let mut test2: std::vec::Vec<u8> = Vec::new();
 
diff --git a/tests/ui/extend_with_drain.rs b/tests/ui/extend_with_drain.rs
index dcb36b5951c..e9f011abb0e 100644
--- a/tests/ui/extend_with_drain.rs
+++ b/tests/ui/extend_with_drain.rs
@@ -1,11 +1,11 @@
 // run-rustfix
 #![warn(clippy::extend_with_drain)]
+#![allow(clippy::iter_with_drain)]
 use std::collections::BinaryHeap;
 fn main() {
     //gets linted
     let mut vec1 = vec![0u8; 1024];
     let mut vec2: std::vec::Vec<u8> = Vec::new();
-
     vec2.extend(vec1.drain(..));
 
     let mut vec3 = vec![0u8; 1024];
@@ -17,7 +17,7 @@ fn main() {
 
     vec11.extend(return_vector().drain(..));
 
-    //won't get linted it dosen't move the entire content of a vec into another
+    //won't get linted it doesn't move the entire content of a vec into another
     let mut test1 = vec![0u8, 10];
     let mut test2: std::vec::Vec<u8> = Vec::new();
 
diff --git a/tests/ui/iter_with_drain.fixed b/tests/ui/iter_with_drain.fixed
new file mode 100644
index 00000000000..aea4dba9dd5
--- /dev/null
+++ b/tests/ui/iter_with_drain.fixed
@@ -0,0 +1,56 @@
+// run-rustfix
+// will emits unused mut warnings after fixing
+#![allow(unused_mut)]
+// will emits needless collect warnings after fixing
+#![allow(clippy::needless_collect)]
+#![warn(clippy::iter_with_drain)]
+use std::collections::{BinaryHeap, HashMap, HashSet, VecDeque};
+
+fn full() {
+    let mut a = vec!["aaa".to_string(), "bbb".to_string()];
+    let mut a: BinaryHeap<_> = a.into_iter().collect();
+    let mut a: HashSet<_> = a.drain().collect();
+    let mut a: VecDeque<_> = a.drain().collect();
+    let mut a: Vec<_> = a.into_iter().collect();
+    let mut a: HashMap<_, _> = a.into_iter().map(|x| (x.clone(), x)).collect();
+    let _: Vec<(String, String)> = a.drain().collect();
+}
+
+fn closed() {
+    let mut a = vec!["aaa".to_string(), "bbb".to_string()];
+    let mut a: BinaryHeap<_> = a.into_iter().collect();
+    let mut a: HashSet<_> = a.drain().collect();
+    let mut a: VecDeque<_> = a.drain().collect();
+    let mut a: Vec<_> = a.into_iter().collect();
+    let mut a: HashMap<_, _> = a.into_iter().map(|x| (x.clone(), x)).collect();
+    let _: Vec<(String, String)> = a.drain().collect();
+}
+
+fn should_not_help() {
+    let mut a = vec!["aaa".to_string(), "bbb".to_string()];
+    let mut a: BinaryHeap<_> = a.drain(1..).collect();
+    let mut a: HashSet<_> = a.drain().collect();
+    let mut a: VecDeque<_> = a.drain().collect();
+    let mut a: Vec<_> = a.drain(..a.len() - 1).collect();
+    let mut a: HashMap<_, _> = a.drain(1..a.len() - 1).map(|x| (x.clone(), x)).collect();
+    let _: Vec<(String, String)> = a.drain().collect();
+
+    let mut b = vec!["aaa".to_string(), "bbb".to_string()];
+    let _: Vec<_> = b.drain(0..a.len()).collect();
+}
+
+#[derive(Default)]
+struct Bomb {
+    fire: Vec<u8>,
+}
+
+fn should_not_help_0(bomb: &mut Bomb) {
+    let _: Vec<u8> = bomb.fire.drain(..).collect();
+}
+
+fn main() {
+    full();
+    closed();
+    should_not_help();
+    should_not_help_0(&mut Bomb::default());
+}
diff --git a/tests/ui/iter_with_drain.rs b/tests/ui/iter_with_drain.rs
new file mode 100644
index 00000000000..271878cffb4
--- /dev/null
+++ b/tests/ui/iter_with_drain.rs
@@ -0,0 +1,56 @@
+// run-rustfix
+// will emits unused mut warnings after fixing
+#![allow(unused_mut)]
+// will emits needless collect warnings after fixing
+#![allow(clippy::needless_collect)]
+#![warn(clippy::iter_with_drain)]
+use std::collections::{BinaryHeap, HashMap, HashSet, VecDeque};
+
+fn full() {
+    let mut a = vec!["aaa".to_string(), "bbb".to_string()];
+    let mut a: BinaryHeap<_> = a.drain(..).collect();
+    let mut a: HashSet<_> = a.drain().collect();
+    let mut a: VecDeque<_> = a.drain().collect();
+    let mut a: Vec<_> = a.drain(..).collect();
+    let mut a: HashMap<_, _> = a.drain(..).map(|x| (x.clone(), x)).collect();
+    let _: Vec<(String, String)> = a.drain().collect();
+}
+
+fn closed() {
+    let mut a = vec!["aaa".to_string(), "bbb".to_string()];
+    let mut a: BinaryHeap<_> = a.drain(0..).collect();
+    let mut a: HashSet<_> = a.drain().collect();
+    let mut a: VecDeque<_> = a.drain().collect();
+    let mut a: Vec<_> = a.drain(..a.len()).collect();
+    let mut a: HashMap<_, _> = a.drain(0..a.len()).map(|x| (x.clone(), x)).collect();
+    let _: Vec<(String, String)> = a.drain().collect();
+}
+
+fn should_not_help() {
+    let mut a = vec!["aaa".to_string(), "bbb".to_string()];
+    let mut a: BinaryHeap<_> = a.drain(1..).collect();
+    let mut a: HashSet<_> = a.drain().collect();
+    let mut a: VecDeque<_> = a.drain().collect();
+    let mut a: Vec<_> = a.drain(..a.len() - 1).collect();
+    let mut a: HashMap<_, _> = a.drain(1..a.len() - 1).map(|x| (x.clone(), x)).collect();
+    let _: Vec<(String, String)> = a.drain().collect();
+
+    let mut b = vec!["aaa".to_string(), "bbb".to_string()];
+    let _: Vec<_> = b.drain(0..a.len()).collect();
+}
+
+#[derive(Default)]
+struct Bomb {
+    fire: Vec<u8>,
+}
+
+fn should_not_help_0(bomb: &mut Bomb) {
+    let _: Vec<u8> = bomb.fire.drain(..).collect();
+}
+
+fn main() {
+    full();
+    closed();
+    should_not_help();
+    should_not_help_0(&mut Bomb::default());
+}
diff --git a/tests/ui/iter_with_drain.stderr b/tests/ui/iter_with_drain.stderr
new file mode 100644
index 00000000000..aa394439fa6
--- /dev/null
+++ b/tests/ui/iter_with_drain.stderr
@@ -0,0 +1,40 @@
+error: `drain(..)` used on a `Vec`
+  --> $DIR/iter_with_drain.rs:11:34
+   |
+LL |     let mut a: BinaryHeap<_> = a.drain(..).collect();
+   |                                  ^^^^^^^^^ help: try this: `into_iter()`
+   |
+   = note: `-D clippy::iter-with-drain` implied by `-D warnings`
+
+error: `drain(..)` used on a `VecDeque`
+  --> $DIR/iter_with_drain.rs:14:27
+   |
+LL |     let mut a: Vec<_> = a.drain(..).collect();
+   |                           ^^^^^^^^^ help: try this: `into_iter()`
+
+error: `drain(..)` used on a `Vec`
+  --> $DIR/iter_with_drain.rs:15:34
+   |
+LL |     let mut a: HashMap<_, _> = a.drain(..).map(|x| (x.clone(), x)).collect();
+   |                                  ^^^^^^^^^ help: try this: `into_iter()`
+
+error: `drain(..)` used on a `Vec`
+  --> $DIR/iter_with_drain.rs:21:34
+   |
+LL |     let mut a: BinaryHeap<_> = a.drain(0..).collect();
+   |                                  ^^^^^^^^^^ help: try this: `into_iter()`
+
+error: `drain(..)` used on a `VecDeque`
+  --> $DIR/iter_with_drain.rs:24:27
+   |
+LL |     let mut a: Vec<_> = a.drain(..a.len()).collect();
+   |                           ^^^^^^^^^^^^^^^^ help: try this: `into_iter()`
+
+error: `drain(..)` used on a `Vec`
+  --> $DIR/iter_with_drain.rs:25:34
+   |
+LL |     let mut a: HashMap<_, _> = a.drain(0..a.len()).map(|x| (x.clone(), x)).collect();
+   |                                  ^^^^^^^^^^^^^^^^^ help: try this: `into_iter()`
+
+error: aborting due to 6 previous errors
+
diff --git a/tests/ui/range_plus_minus_one.fixed b/tests/ui/range_plus_minus_one.fixed
index 19b253b0fe2..40d7791df28 100644
--- a/tests/ui/range_plus_minus_one.fixed
+++ b/tests/ui/range_plus_minus_one.fixed
@@ -1,7 +1,7 @@
 // run-rustfix
 
 #![allow(unused_parens)]
-
+#![allow(clippy::iter_with_drain)]
 fn f() -> usize {
     42
 }
diff --git a/tests/ui/range_plus_minus_one.rs b/tests/ui/range_plus_minus_one.rs
index 7d034117547..a8ddd9b5f75 100644
--- a/tests/ui/range_plus_minus_one.rs
+++ b/tests/ui/range_plus_minus_one.rs
@@ -1,7 +1,7 @@
 // run-rustfix
 
 #![allow(unused_parens)]
-
+#![allow(clippy::iter_with_drain)]
 fn f() -> usize {
     42
 }
-- 
cgit 1.4.1-3-g733a5


From 78547b171631f466cb46845fdf2976d66c48ed24 Mon Sep 17 00:00:00 2001
From: Manish Goregaokar <manishsmail@gmail.com>
Date: Wed, 2 Mar 2022 09:54:50 -0800
Subject: comment about transmute_undefined_repr in nursery

---
 clippy_lints/src/transmute/mod.rs | 4 ++++
 1 file changed, 4 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/transmute/mod.rs b/clippy_lints/src/transmute/mod.rs
index 1da3b765904..23cb9d40dfd 100644
--- a/clippy_lints/src/transmute/mod.rs
+++ b/clippy_lints/src/transmute/mod.rs
@@ -364,6 +364,10 @@ declare_clippy_lint! {
     /// ### Why is this bad?
     /// The results of such a transmute are not defined.
     ///
+    /// ### Known problems
+    /// This lint has had multiple problems in the past and was moved to `nursery`. See issue
+    /// [#8496](https://github.com/rust-lang/rust-clippy/issues/8496) for more details.
+    ///
     /// ### Example
     /// ```rust
     /// struct Foo<T>(u32, T);
-- 
cgit 1.4.1-3-g733a5


From 63907234d71d44dc8ade7be37b1e0fefb02390e1 Mon Sep 17 00:00:00 2001
From: Andre Bogus <bogusandre@gmail.com>
Date: Thu, 3 Mar 2022 19:28:05 +0100
Subject: Omit dbg_macro in test code

---
 clippy_lints/src/dbg_macro.rs |  5 +++++
 tests/ui/dbg_macro.rs         |  6 ++++++
 tests/ui/dbg_macro.stderr     | 20 ++++++++++----------
 3 files changed, 21 insertions(+), 10 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/dbg_macro.rs b/clippy_lints/src/dbg_macro.rs
index df1a4128af3..a0e5d302633 100644
--- a/clippy_lints/src/dbg_macro.rs
+++ b/clippy_lints/src/dbg_macro.rs
@@ -1,4 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::is_in_test_function;
 use clippy_utils::macros::root_macro_call_first_node;
 use clippy_utils::source::snippet_with_applicability;
 use rustc_errors::Applicability;
@@ -35,6 +36,10 @@ impl LateLintPass<'_> for DbgMacro {
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
         let Some(macro_call) = root_macro_call_first_node(cx, expr) else { return };
         if cx.tcx.is_diagnostic_item(sym::dbg_macro, macro_call.def_id) {
+            // we make an exception for test code
+            if is_in_test_function(cx.tcx, expr.hir_id) {
+                return;
+            }
             let mut applicability = Applicability::MachineApplicable;
             let suggestion = match expr.peel_drop_temps().kind {
                 // dbg!()
diff --git a/tests/ui/dbg_macro.rs b/tests/ui/dbg_macro.rs
index 9b03c9b4783..baf01174b67 100644
--- a/tests/ui/dbg_macro.rs
+++ b/tests/ui/dbg_macro.rs
@@ -1,3 +1,4 @@
+// compile-flags: --test
 #![warn(clippy::dbg_macro)]
 
 fn foo(n: u32) -> u32 {
@@ -40,3 +41,8 @@ mod issue7274 {
         dbg!(2);
     });
 }
+
+#[test]
+pub fn issue8481() {
+    dbg!(1);
+}
diff --git a/tests/ui/dbg_macro.stderr b/tests/ui/dbg_macro.stderr
index 8ee1b328720..a3e7a7162e5 100644
--- a/tests/ui/dbg_macro.stderr
+++ b/tests/ui/dbg_macro.stderr
@@ -1,5 +1,5 @@
 error: `dbg!` macro is intended as a debugging tool
-  --> $DIR/dbg_macro.rs:4:22
+  --> $DIR/dbg_macro.rs:5:22
    |
 LL |     if let Some(n) = dbg!(n.checked_sub(4)) { n } else { n }
    |                      ^^^^^^^^^^^^^^^^^^^^^^
@@ -11,7 +11,7 @@ LL |     if let Some(n) = n.checked_sub(4) { n } else { n }
    |                      ~~~~~~~~~~~~~~~~
 
 error: `dbg!` macro is intended as a debugging tool
-  --> $DIR/dbg_macro.rs:8:8
+  --> $DIR/dbg_macro.rs:9:8
    |
 LL |     if dbg!(n <= 1) {
    |        ^^^^^^^^^^^^
@@ -22,7 +22,7 @@ LL |     if n <= 1 {
    |        ~~~~~~
 
 error: `dbg!` macro is intended as a debugging tool
-  --> $DIR/dbg_macro.rs:9:9
+  --> $DIR/dbg_macro.rs:10:9
    |
 LL |         dbg!(1)
    |         ^^^^^^^
@@ -33,7 +33,7 @@ LL |         1
    |
 
 error: `dbg!` macro is intended as a debugging tool
-  --> $DIR/dbg_macro.rs:11:9
+  --> $DIR/dbg_macro.rs:12:9
    |
 LL |         dbg!(n * factorial(n - 1))
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -44,7 +44,7 @@ LL |         n * factorial(n - 1)
    |
 
 error: `dbg!` macro is intended as a debugging tool
-  --> $DIR/dbg_macro.rs:16:5
+  --> $DIR/dbg_macro.rs:17:5
    |
 LL |     dbg!(42);
    |     ^^^^^^^^
@@ -55,7 +55,7 @@ LL |     42;
    |     ~~
 
 error: `dbg!` macro is intended as a debugging tool
-  --> $DIR/dbg_macro.rs:17:5
+  --> $DIR/dbg_macro.rs:18:5
    |
 LL |     dbg!(dbg!(dbg!(42)));
    |     ^^^^^^^^^^^^^^^^^^^^
@@ -66,7 +66,7 @@ LL |     dbg!(dbg!(42));
    |     ~~~~~~~~~~~~~~
 
 error: `dbg!` macro is intended as a debugging tool
-  --> $DIR/dbg_macro.rs:18:14
+  --> $DIR/dbg_macro.rs:19:14
    |
 LL |     foo(3) + dbg!(factorial(4));
    |              ^^^^^^^^^^^^^^^^^^
@@ -77,7 +77,7 @@ LL |     foo(3) + factorial(4);
    |              ~~~~~~~~~~~~
 
 error: `dbg!` macro is intended as a debugging tool
-  --> $DIR/dbg_macro.rs:19:5
+  --> $DIR/dbg_macro.rs:20:5
    |
 LL |     dbg!(1, 2, dbg!(3, 4));
    |     ^^^^^^^^^^^^^^^^^^^^^^
@@ -88,7 +88,7 @@ LL |     (1, 2, dbg!(3, 4));
    |     ~~~~~~~~~~~~~~~~~~
 
 error: `dbg!` macro is intended as a debugging tool
-  --> $DIR/dbg_macro.rs:20:5
+  --> $DIR/dbg_macro.rs:21:5
    |
 LL |     dbg!(1, 2, 3, 4, 5);
    |     ^^^^^^^^^^^^^^^^^^^
@@ -99,7 +99,7 @@ LL |     (1, 2, 3, 4, 5);
    |     ~~~~~~~~~~~~~~~
 
 error: `dbg!` macro is intended as a debugging tool
-  --> $DIR/dbg_macro.rs:40:9
+  --> $DIR/dbg_macro.rs:41:9
    |
 LL |         dbg!(2);
    |         ^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From ab6ffb6371b78d1777b90c25a44163562ae53036 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Thu, 3 Mar 2022 23:57:35 +0100
Subject: Add lint to detect `allow` attributes without reason

---
 CHANGELOG.md                                    |  1 +
 clippy_lints/src/attrs.rs                       | 60 ++++++++++++++++++++++++-
 clippy_lints/src/lib.register_lints.rs          |  1 +
 clippy_lints/src/lib.register_restriction.rs    |  1 +
 tests/ui/allow_attributes_without_reason.rs     | 14 ++++++
 tests/ui/allow_attributes_without_reason.stderr | 23 ++++++++++
 6 files changed, 99 insertions(+), 1 deletion(-)
 create mode 100644 tests/ui/allow_attributes_without_reason.rs
 create mode 100644 tests/ui/allow_attributes_without_reason.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 1b52a6fcd05..bcdbc73738a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3042,6 +3042,7 @@ Released 2018-09-13
 <!-- lint disable no-unused-definitions -->
 <!-- begin autogenerated links to lint list -->
 [`absurd_extreme_comparisons`]: https://rust-lang.github.io/rust-clippy/master/index.html#absurd_extreme_comparisons
+[`allow_attributes_without_reason`]: https://rust-lang.github.io/rust-clippy/master/index.html#allow_attributes_without_reason
 [`almost_swapped`]: https://rust-lang.github.io/rust-clippy/master/index.html#almost_swapped
 [`approx_constant`]: https://rust-lang.github.io/rust-clippy/master/index.html#approx_constant
 [`as_conversions`]: https://rust-lang.github.io/rust-clippy/master/index.html#as_conversions
diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs
index a58d12ddd6b..d0b03c0a9c2 100644
--- a/clippy_lints/src/attrs.rs
+++ b/clippy_lints/src/attrs.rs
@@ -255,7 +255,38 @@ declare_clippy_lint! {
     "usage of `cfg(operating_system)` instead of `cfg(target_os = \"operating_system\")`"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for attributes that allow lints without a reason.
+    ///
+    /// (This requires the `lint_reasons` feature)
+    ///
+    /// ### Why is this bad?
+    /// Allowing a lint should always have a reason. This reason should be documented to
+    /// ensure that others understand the reasoning
+    ///
+    /// ### Example
+    /// Bad:
+    /// ```rust
+    /// #![feature(lint_reasons)]
+    ///
+    /// #![allow(clippy::some_lint)]
+    /// ```
+    ///
+    /// Good:
+    /// ```rust
+    /// #![feature(lint_reasons)]
+    ///
+    /// #![allow(clippy::some_lint, reason = "False positive rust-lang/rust-clippy#1002020")]
+    /// ```
+    #[clippy::version = "1.61.0"]
+    pub ALLOW_ATTRIBUTES_WITHOUT_REASON,
+    restriction,
+    "ensures that all `allow` and `expect` attributes have a reason"
+}
+
 declare_lint_pass!(Attributes => [
+    ALLOW_ATTRIBUTES_WITHOUT_REASON,
     INLINE_ALWAYS,
     DEPRECATED_SEMVER,
     USELESS_ATTRIBUTE,
@@ -269,6 +300,9 @@ impl<'tcx> LateLintPass<'tcx> for Attributes {
                 if is_lint_level(ident.name) {
                     check_clippy_lint_names(cx, ident.name, items);
                 }
+                if matches!(ident.name, sym::allow | sym::expect) {
+                    check_lint_reason(cx, ident.name, items, attr);
+                }
                 if items.is_empty() || !attr.has_name(sym::deprecated) {
                     return;
                 }
@@ -404,6 +438,30 @@ fn check_clippy_lint_names(cx: &LateContext<'_>, name: Symbol, items: &[NestedMe
     }
 }
 
+fn check_lint_reason(cx: &LateContext<'_>, name: Symbol, items: &[NestedMetaItem], attr: &'_ Attribute) {
+    // Check for the feature
+    if !cx.tcx.sess.features_untracked().lint_reasons {
+        return;
+    }
+
+    // Check if the reason is present
+    if let Some(item) = items.last().and_then(NestedMetaItem::meta_item)
+        && let MetaItemKind::NameValue(_) = &item.kind
+        && item.path == sym::reason
+    {
+        return;
+    }
+
+    span_lint_and_help(
+        cx,
+        ALLOW_ATTRIBUTES_WITHOUT_REASON,
+        attr.span,
+        &format!("`{}` attribute without specifying a reason", name.as_str()),
+        None,
+        "try adding a reason at the end with `, reason = \"..\"`",
+    );
+}
+
 fn is_relevant_item(cx: &LateContext<'_>, item: &Item<'_>) -> bool {
     if let ItemKind::Fn(_, _, eid) = item.kind {
         is_relevant_expr(cx, cx.tcx.typeck_body(eid), &cx.tcx.hir().body(eid).value)
@@ -659,5 +717,5 @@ fn check_mismatched_target_os(cx: &EarlyContext<'_>, attr: &Attribute) {
 }
 
 fn is_lint_level(symbol: Symbol) -> bool {
-    matches!(symbol, sym::allow | sym::warn | sym::deny | sym::forbid)
+    matches!(symbol, sym::allow | sym::expect | sym::warn | sym::deny | sym::forbid)
 }
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 75ef1b0a9d5..d4c7eba4cba 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -42,6 +42,7 @@ store.register_lints(&[
     assign_ops::ASSIGN_OP_PATTERN,
     assign_ops::MISREFACTORED_ASSIGN_OP,
     async_yields_async::ASYNC_YIELDS_ASYNC,
+    attrs::ALLOW_ATTRIBUTES_WITHOUT_REASON,
     attrs::BLANKET_CLIPPY_RESTRICTION_LINTS,
     attrs::DEPRECATED_CFG_ATTR,
     attrs::DEPRECATED_SEMVER,
diff --git a/clippy_lints/src/lib.register_restriction.rs b/clippy_lints/src/lib.register_restriction.rs
index f89f35b885c..4e30fc38197 100644
--- a/clippy_lints/src/lib.register_restriction.rs
+++ b/clippy_lints/src/lib.register_restriction.rs
@@ -8,6 +8,7 @@ store.register_group(true, "clippy::restriction", Some("clippy_restriction"), ve
     LintId::of(as_conversions::AS_CONVERSIONS),
     LintId::of(asm_syntax::INLINE_ASM_X86_ATT_SYNTAX),
     LintId::of(asm_syntax::INLINE_ASM_X86_INTEL_SYNTAX),
+    LintId::of(attrs::ALLOW_ATTRIBUTES_WITHOUT_REASON),
     LintId::of(casts::FN_TO_NUMERIC_CAST_ANY),
     LintId::of(create_dir::CREATE_DIR),
     LintId::of(dbg_macro::DBG_MACRO),
diff --git a/tests/ui/allow_attributes_without_reason.rs b/tests/ui/allow_attributes_without_reason.rs
new file mode 100644
index 00000000000..1a0d4e88657
--- /dev/null
+++ b/tests/ui/allow_attributes_without_reason.rs
@@ -0,0 +1,14 @@
+#![feature(lint_reasons)]
+#![deny(clippy::allow_attributes_without_reason)]
+
+// These should trigger the lint
+#[allow(dead_code)]
+#[allow(dead_code, deprecated)]
+// These should be fine
+#[allow(dead_code, reason = "This should be allowed")]
+#[warn(dyn_drop, reason = "Warnings can also have reasons")]
+#[warn(deref_nullptr)]
+#[deny(deref_nullptr)]
+#[forbid(deref_nullptr)]
+
+fn main() {}
diff --git a/tests/ui/allow_attributes_without_reason.stderr b/tests/ui/allow_attributes_without_reason.stderr
new file mode 100644
index 00000000000..cd040a144aa
--- /dev/null
+++ b/tests/ui/allow_attributes_without_reason.stderr
@@ -0,0 +1,23 @@
+error: `allow` attribute without specifying a reason
+  --> $DIR/allow_attributes_without_reason.rs:5:1
+   |
+LL | #[allow(dead_code)]
+   | ^^^^^^^^^^^^^^^^^^^
+   |
+note: the lint level is defined here
+  --> $DIR/allow_attributes_without_reason.rs:2:9
+   |
+LL | #![deny(clippy::allow_attributes_without_reason)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   = help: try adding a reason at the end with `, reason = ".."`
+
+error: `allow` attribute without specifying a reason
+  --> $DIR/allow_attributes_without_reason.rs:6:1
+   |
+LL | #[allow(dead_code, deprecated)]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: try adding a reason at the end with `, reason = ".."`
+
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From f932c304bb2b7b4464eca89dde8cbbecec062366 Mon Sep 17 00:00:00 2001
From: asquared31415 <34665709+asquared31415@users.noreply.github.com>
Date: Fri, 18 Feb 2022 05:17:07 -0500
Subject: lint for casting raw pointers to slices with different element sizes

---
 CHANGELOG.md                                       |   1 +
 .../src/casts/cast_slice_different_sizes.rs        | 117 +++++++++++++++++++++
 clippy_lints/src/casts/mod.rs                      |  48 +++++++++
 clippy_lints/src/lib.register_all.rs               |   1 +
 clippy_lints/src/lib.register_correctness.rs       |   1 +
 clippy_lints/src/lib.register_lints.rs             |   1 +
 clippy_utils/src/msrvs.rs                          |   2 +-
 tests/ui/cast_slice_different_sizes.rs             |  39 +++++++
 tests/ui/cast_slice_different_sizes.stderr         |  52 +++++++++
 tests/ui/transmutes_expressible_as_ptr_casts.fixed |   4 +-
 tests/ui/transmutes_expressible_as_ptr_casts.rs    |   4 +-
 .../ui/transmutes_expressible_as_ptr_casts.stderr  |   4 +-
 12 files changed, 267 insertions(+), 7 deletions(-)
 create mode 100644 clippy_lints/src/casts/cast_slice_different_sizes.rs
 create mode 100644 tests/ui/cast_slice_different_sizes.rs
 create mode 100644 tests/ui/cast_slice_different_sizes.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 7f18a00a9dd..c024dbd9a0f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3076,6 +3076,7 @@ Released 2018-09-13
 [`cast_ptr_alignment`]: https://rust-lang.github.io/rust-clippy/master/index.html#cast_ptr_alignment
 [`cast_ref_to_mut`]: https://rust-lang.github.io/rust-clippy/master/index.html#cast_ref_to_mut
 [`cast_sign_loss`]: https://rust-lang.github.io/rust-clippy/master/index.html#cast_sign_loss
+[`cast_slice_different_sizes`]: https://rust-lang.github.io/rust-clippy/master/index.html#cast_slice_different_sizes
 [`char_lit_as_u8`]: https://rust-lang.github.io/rust-clippy/master/index.html#char_lit_as_u8
 [`chars_last_cmp`]: https://rust-lang.github.io/rust-clippy/master/index.html#chars_last_cmp
 [`chars_next_cmp`]: https://rust-lang.github.io/rust-clippy/master/index.html#chars_next_cmp
diff --git a/clippy_lints/src/casts/cast_slice_different_sizes.rs b/clippy_lints/src/casts/cast_slice_different_sizes.rs
new file mode 100644
index 00000000000..3608c1654d5
--- /dev/null
+++ b/clippy_lints/src/casts/cast_slice_different_sizes.rs
@@ -0,0 +1,117 @@
+use clippy_utils::{diagnostics::span_lint_and_then, meets_msrv, msrvs, source::snippet_opt};
+use if_chain::if_chain;
+use rustc_ast::Mutability;
+use rustc_hir::{Expr, ExprKind, Node};
+use rustc_lint::LateContext;
+use rustc_middle::ty::{self, layout::LayoutOf, Ty, TypeAndMut};
+use rustc_semver::RustcVersion;
+
+use super::CAST_SLICE_DIFFERENT_SIZES;
+
+fn is_child_of_cast(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+    let map = cx.tcx.hir();
+    if_chain! {
+        if let Some(parent_id) = map.find_parent_node(expr.hir_id);
+        if let Some(parent) = map.find(parent_id);
+        then {
+            let expr = match parent {
+                Node::Block(block) => {
+                    if let Some(parent_expr) = block.expr {
+                        parent_expr
+                    } else {
+                        return false;
+                    }
+                },
+                Node::Expr(expr) => expr,
+                _ => return false,
+            };
+
+            matches!(expr.kind, ExprKind::Cast(..))
+        } else {
+            false
+        }
+    }
+}
+
+pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, msrv: &Option<RustcVersion>) {
+    // suggestion is invalid if `ptr::slice_from_raw_parts` does not exist
+    if !meets_msrv(msrv.as_ref(), &msrvs::PTR_SLICE_RAW_PARTS) {
+        return;
+    }
+
+    // if this cast is the child of another cast expression then don't emit something for it, the full
+    // chain will be analyzed
+    if is_child_of_cast(cx, expr) {
+        return;
+    }
+
+    if let Some((from_slice_ty, to_slice_ty)) = expr_cast_chain_tys(cx, expr) {
+        if let (Ok(from_layout), Ok(to_layout)) = (cx.layout_of(from_slice_ty.ty), cx.layout_of(to_slice_ty.ty)) {
+            let from_size = from_layout.size.bytes();
+            let to_size = to_layout.size.bytes();
+            if from_size != to_size && from_size != 0 && to_size != 0 {
+                span_lint_and_then(
+                    cx,
+                    CAST_SLICE_DIFFERENT_SIZES,
+                    expr.span,
+                    &format!(
+                        "casting between raw pointers to `[{}]` (element size {}) and `[{}]` (element size {}) does not adjust the count",
+                        from_slice_ty, from_size, to_slice_ty, to_size,
+                    ),
+                    |diag| {
+                        let cast_expr = match expr.kind {
+                            ExprKind::Cast(cast_expr, ..) => cast_expr,
+                            _ => unreachable!("expr should be a cast as checked by expr_cast_chain_tys"),
+                        };
+                        let ptr_snippet = snippet_opt(cx, cast_expr.span).unwrap();
+
+                        let (mutbl_fn_str, mutbl_ptr_str) = match to_slice_ty.mutbl {
+                            Mutability::Mut => ("_mut", "mut"),
+                            Mutability::Not => ("", "const"),
+                        };
+                        let sugg = format!(
+                            "core::ptr::slice_from_raw_parts{mutbl_fn_str}({ptr_snippet} as *{mutbl_ptr_str} {to_slice_ty}, ..)"
+                        );
+
+                        diag.span_suggestion(
+                            expr.span,
+                            &format!("replace with `ptr::slice_from_raw_parts{mutbl_fn_str}`"),
+                            sugg,
+                            rustc_errors::Applicability::HasPlaceholders,
+                        );
+                    },
+                );
+            }
+        }
+    }
+}
+
+/// Returns the type T of the pointed to *const [T] or *mut [T] and the mutability of the slice if
+/// the type is one of those slices
+fn get_raw_slice_ty_mut(ty: Ty<'_>) -> Option<TypeAndMut<'_>> {
+    match ty.kind() {
+        ty::RawPtr(TypeAndMut { ty: slice_ty, mutbl }) => match slice_ty.kind() {
+            ty::Slice(ty) => Some(TypeAndMut { ty: *ty, mutbl: *mutbl }),
+            _ => None,
+        },
+        _ => None,
+    }
+}
+
+/// Returns the pair (original ptr T, final ptr U) if the expression is composed of casts
+/// Returns None if the expr is not a Cast
+fn expr_cast_chain_tys<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>) -> Option<(TypeAndMut<'tcx>, TypeAndMut<'tcx>)> {
+    if let ExprKind::Cast(cast_expr, _cast_to_hir_ty) = expr.peel_blocks().kind {
+        let cast_to = cx.typeck_results().expr_ty(expr);
+        let to_slice_ty = get_raw_slice_ty_mut(cast_to)?;
+        if let Some((inner_from_ty, _inner_to_ty)) = expr_cast_chain_tys(cx, cast_expr) {
+            Some((inner_from_ty, to_slice_ty))
+        } else {
+            let cast_from = cx.typeck_results().expr_ty(cast_expr);
+            let from_slice_ty = get_raw_slice_ty_mut(cast_from)?;
+            Some((from_slice_ty, to_slice_ty))
+        }
+    } else {
+        None
+    }
+}
diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index f2077c569c0..6a0eabd089d 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -5,6 +5,7 @@ mod cast_precision_loss;
 mod cast_ptr_alignment;
 mod cast_ref_to_mut;
 mod cast_sign_loss;
+mod cast_slice_different_sizes;
 mod char_lit_as_u8;
 mod fn_to_numeric_cast;
 mod fn_to_numeric_cast_any;
@@ -409,6 +410,50 @@ declare_clippy_lint! {
     "casts from an enum type to an integral type which will truncate the value"
 }
 
+declare_clippy_lint! {
+    /// Checks for `as` casts between raw pointers to slices with differently sized elements.
+    ///
+    /// ### Why is this bad?
+    /// The produced raw pointer to a slice does not update its length metadata. The produced
+    /// pointer will point to a different number of bytes than the original pointer because the
+    /// length metadata of a raw slice pointer is in elements rather than bytes.
+    /// Producing a slice reference from the raw pointer will either create a slice with
+    /// less data (which can be surprising) or create a slice with more data and cause Undefined Behavior.
+    ///
+    /// ### Example
+    /// // Missing data
+    /// ```rust
+    /// let a = [1_i32, 2, 3, 4];
+    /// let p = &a as *const [i32] as *const [u8];
+    /// unsafe {
+    ///     println!("{:?}", &*p);
+    /// }
+    /// ```
+    /// // Undefined Behavior (note: also potential alignment issues)
+    /// ```rust
+    /// let a = [1_u8, 2, 3, 4];
+    /// let p = &a as *const [u8] as *const [u32];
+    /// unsafe {
+    ///     println!("{:?}", &*p);
+    /// }
+    /// ```
+    /// Instead use `ptr::slice_from_raw_parts` to construct a slice from a data pointer and the correct length
+    /// ```rust
+    /// let a = [1_i32, 2, 3, 4];
+    /// let old_ptr = &a as *const [i32];
+    /// // The data pointer is cast to a pointer to the target `u8` not `[u8]`
+    /// // The length comes from the known length of 4 i32s times the 4 bytes per i32
+    /// let new_ptr = core::ptr::slice_from_raw_parts(old_ptr as *const u8, 16);
+    /// unsafe {
+    ///     println!("{:?}", &*new_ptr);
+    /// }
+    /// ```
+    #[clippy::version = "1.60.0"]
+    pub CAST_SLICE_DIFFERENT_SIZES,
+    correctness,
+    "casting using `as` between raw pointers to slices of types with different sizes"
+}
+
 pub struct Casts {
     msrv: Option<RustcVersion>,
 }
@@ -428,6 +473,7 @@ impl_lint_pass!(Casts => [
     CAST_LOSSLESS,
     CAST_REF_TO_MUT,
     CAST_PTR_ALIGNMENT,
+    CAST_SLICE_DIFFERENT_SIZES,
     UNNECESSARY_CAST,
     FN_TO_NUMERIC_CAST_ANY,
     FN_TO_NUMERIC_CAST,
@@ -478,6 +524,8 @@ impl<'tcx> LateLintPass<'tcx> for Casts {
         cast_ref_to_mut::check(cx, expr);
         cast_ptr_alignment::check(cx, expr);
         char_lit_as_u8::check(cx, expr);
+        ptr_as_ptr::check(cx, expr, &self.msrv);
+        cast_slice_different_sizes::check(cx, expr, &self.msrv);
     }
 
     extract_msrv_attr!(LateContext);
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index f388ae7ce60..f69c4e98719 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -25,6 +25,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(booleans::NONMINIMAL_BOOL),
     LintId::of(casts::CAST_ENUM_TRUNCATION),
     LintId::of(casts::CAST_REF_TO_MUT),
+    LintId::of(casts::CAST_SLICE_DIFFERENT_SIZES),
     LintId::of(casts::CHAR_LIT_AS_U8),
     LintId::of(casts::FN_TO_NUMERIC_CAST),
     LintId::of(casts::FN_TO_NUMERIC_CAST_WITH_TRUNCATION),
diff --git a/clippy_lints/src/lib.register_correctness.rs b/clippy_lints/src/lib.register_correctness.rs
index d7bf91eb692..df63f84463d 100644
--- a/clippy_lints/src/lib.register_correctness.rs
+++ b/clippy_lints/src/lib.register_correctness.rs
@@ -13,6 +13,7 @@ store.register_group(true, "clippy::correctness", Some("clippy_correctness"), ve
     LintId::of(bit_mask::INEFFECTIVE_BIT_MASK),
     LintId::of(booleans::LOGIC_BUG),
     LintId::of(casts::CAST_REF_TO_MUT),
+    LintId::of(casts::CAST_SLICE_DIFFERENT_SIZES),
     LintId::of(copies::IFS_SAME_COND),
     LintId::of(copies::IF_SAME_THEN_ELSE),
     LintId::of(derive::DERIVE_HASH_XOR_EQ),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index d248c2a41ee..89629b41525 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -77,6 +77,7 @@ store.register_lints(&[
     casts::CAST_PTR_ALIGNMENT,
     casts::CAST_REF_TO_MUT,
     casts::CAST_SIGN_LOSS,
+    casts::CAST_SLICE_DIFFERENT_SIZES,
     casts::CHAR_LIT_AS_U8,
     casts::FN_TO_NUMERIC_CAST,
     casts::FN_TO_NUMERIC_CAST_ANY,
diff --git a/clippy_utils/src/msrvs.rs b/clippy_utils/src/msrvs.rs
index a5b409ad96b..fce93153d96 100644
--- a/clippy_utils/src/msrvs.rs
+++ b/clippy_utils/src/msrvs.rs
@@ -20,7 +20,7 @@ msrv_aliases! {
     1,46,0 { CONST_IF_MATCH }
     1,45,0 { STR_STRIP_PREFIX }
     1,43,0 { LOG2_10, LOG10_2 }
-    1,42,0 { MATCHES_MACRO, SLICE_PATTERNS }
+    1,42,0 { MATCHES_MACRO, SLICE_PATTERNS, PTR_SLICE_RAW_PARTS }
     1,41,0 { RE_REBALANCING_COHERENCE, RESULT_MAP_OR_ELSE }
     1,40,0 { MEM_TAKE, NON_EXHAUSTIVE, OPTION_AS_DEREF }
     1,38,0 { POINTER_CAST }
diff --git a/tests/ui/cast_slice_different_sizes.rs b/tests/ui/cast_slice_different_sizes.rs
new file mode 100644
index 00000000000..cfe1cca2eba
--- /dev/null
+++ b/tests/ui/cast_slice_different_sizes.rs
@@ -0,0 +1,39 @@
+fn main() {
+    let x: [i32; 3] = [1_i32, 2, 3];
+    let r_x = &x;
+    // Check casting through multiple bindings
+    // Because it's separate, it does not check the cast back to something of the same size
+    let a = r_x as *const [i32];
+    let b = a as *const [u8];
+    let c = b as *const [u32];
+
+    // loses data
+    let loss = r_x as *const [i32] as *const [u8];
+
+    // Cast back to same size but different type loses no data, just type conversion
+    // This is weird code but there's no reason for this lint specifically to fire *twice* on it
+    let restore = r_x as *const [i32] as *const [u8] as *const [u32];
+
+    // Check casting through blocks is detected
+    let loss_block_1 = { r_x as *const [i32] } as *const [u8];
+    let loss_block_2 = {
+        let _ = ();
+        r_x as *const [i32]
+    } as *const [u8];
+
+    // Check that resores of the same size are detected through blocks
+    let restore_block_1 = { r_x as *const [i32] } as *const [u8] as *const [u32];
+    let restore_block_2 = { ({ r_x as *const [i32] }) as *const [u8] } as *const [u32];
+    let restore_block_3 = {
+        let _ = ();
+        ({
+            let _ = ();
+            r_x as *const [i32]
+        }) as *const [u8]
+    } as *const [u32];
+
+    // Check that the result of a long chain of casts is detected
+    let long_chain_loss = r_x as *const [i32] as *const [u32] as *const [u16] as *const [i8] as *const [u8];
+    let long_chain_restore =
+        r_x as *const [i32] as *const [u32] as *const [u16] as *const [i8] as *const [u8] as *const [u32];
+}
diff --git a/tests/ui/cast_slice_different_sizes.stderr b/tests/ui/cast_slice_different_sizes.stderr
new file mode 100644
index 00000000000..a37cec7cb3b
--- /dev/null
+++ b/tests/ui/cast_slice_different_sizes.stderr
@@ -0,0 +1,52 @@
+error: casting between raw pointers to `[i32]` (element size 4) and `[u8]` (element size 1) does not adjust the count
+  --> $DIR/cast_slice_different_sizes.rs:7:13
+   |
+LL |     let b = a as *const [u8];
+   |             ^^^^^^^^^^^^^^^^ help: replace with `ptr::slice_from_raw_parts`: `core::ptr::slice_from_raw_parts(a as *const u8, ..)`
+   |
+   = note: `#[deny(clippy::cast_slice_different_sizes)]` on by default
+
+error: casting between raw pointers to `[u8]` (element size 1) and `[u32]` (element size 4) does not adjust the count
+  --> $DIR/cast_slice_different_sizes.rs:8:13
+   |
+LL |     let c = b as *const [u32];
+   |             ^^^^^^^^^^^^^^^^^ help: replace with `ptr::slice_from_raw_parts`: `core::ptr::slice_from_raw_parts(b as *const u32, ..)`
+
+error: casting between raw pointers to `[i32]` (element size 4) and `[u8]` (element size 1) does not adjust the count
+  --> $DIR/cast_slice_different_sizes.rs:11:16
+   |
+LL |     let loss = r_x as *const [i32] as *const [u8];
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with `ptr::slice_from_raw_parts`: `core::ptr::slice_from_raw_parts(r_x as *const [i32] as *const u8, ..)`
+
+error: casting between raw pointers to `[i32]` (element size 4) and `[u8]` (element size 1) does not adjust the count
+  --> $DIR/cast_slice_different_sizes.rs:18:24
+   |
+LL |     let loss_block_1 = { r_x as *const [i32] } as *const [u8];
+   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with `ptr::slice_from_raw_parts`: `core::ptr::slice_from_raw_parts({ r_x as *const [i32] } as *const u8, ..)`
+
+error: casting between raw pointers to `[i32]` (element size 4) and `[u8]` (element size 1) does not adjust the count
+  --> $DIR/cast_slice_different_sizes.rs:19:24
+   |
+LL |       let loss_block_2 = {
+   |  ________________________^
+LL | |         let _ = ();
+LL | |         r_x as *const [i32]
+LL | |     } as *const [u8];
+   | |____________________^
+   |
+help: replace with `ptr::slice_from_raw_parts`
+   |
+LL ~     let loss_block_2 = core::ptr::slice_from_raw_parts({
+LL +         let _ = ();
+LL +         r_x as *const [i32]
+LL ~     } as *const u8, ..);
+   |
+
+error: casting between raw pointers to `[i32]` (element size 4) and `[u8]` (element size 1) does not adjust the count
+  --> $DIR/cast_slice_different_sizes.rs:36:27
+   |
+LL |     let long_chain_loss = r_x as *const [i32] as *const [u32] as *const [u16] as *const [i8] as *const [u8];
+   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with `ptr::slice_from_raw_parts`: `core::ptr::slice_from_raw_parts(r_x as *const [i32] as *const [u32] as *const [u16] as *const [i8] as *const u8, ..)`
+
+error: aborting due to 6 previous errors
+
diff --git a/tests/ui/transmutes_expressible_as_ptr_casts.fixed b/tests/ui/transmutes_expressible_as_ptr_casts.fixed
index 9ae0ed0b13f..b425cdd6cbf 100644
--- a/tests/ui/transmutes_expressible_as_ptr_casts.fixed
+++ b/tests/ui/transmutes_expressible_as_ptr_casts.fixed
@@ -25,8 +25,8 @@ fn main() {
     let slice_ptr = &[0, 1, 2, 3] as *const [i32];
 
     // ... or pointer_kind(T) = pointer_kind(U_0); ptr-ptr-cast
-    let _ptr_to_unsized_transmute = unsafe { slice_ptr as *const [u16] };
-    let _ptr_to_unsized = slice_ptr as *const [u16];
+    let _ptr_to_unsized_transmute = unsafe { slice_ptr as *const [u32] };
+    let _ptr_to_unsized = slice_ptr as *const [u32];
     // TODO: We could try testing vtable casts here too, but maybe
     // we should wait until std::raw::TraitObject is stabilized?
 
diff --git a/tests/ui/transmutes_expressible_as_ptr_casts.rs b/tests/ui/transmutes_expressible_as_ptr_casts.rs
index 985cf9a075d..8fd57c59652 100644
--- a/tests/ui/transmutes_expressible_as_ptr_casts.rs
+++ b/tests/ui/transmutes_expressible_as_ptr_casts.rs
@@ -25,8 +25,8 @@ fn main() {
     let slice_ptr = &[0, 1, 2, 3] as *const [i32];
 
     // ... or pointer_kind(T) = pointer_kind(U_0); ptr-ptr-cast
-    let _ptr_to_unsized_transmute = unsafe { transmute::<*const [i32], *const [u16]>(slice_ptr) };
-    let _ptr_to_unsized = slice_ptr as *const [u16];
+    let _ptr_to_unsized_transmute = unsafe { transmute::<*const [i32], *const [u32]>(slice_ptr) };
+    let _ptr_to_unsized = slice_ptr as *const [u32];
     // TODO: We could try testing vtable casts here too, but maybe
     // we should wait until std::raw::TraitObject is stabilized?
 
diff --git a/tests/ui/transmutes_expressible_as_ptr_casts.stderr b/tests/ui/transmutes_expressible_as_ptr_casts.stderr
index e8496a325d6..d9b64a0ed7b 100644
--- a/tests/ui/transmutes_expressible_as_ptr_casts.stderr
+++ b/tests/ui/transmutes_expressible_as_ptr_casts.stderr
@@ -17,8 +17,8 @@ LL |     let _ptr_i8_transmute = unsafe { transmute::<*const i32, *const i8>(ptr
 error: transmute from a pointer to a pointer
   --> $DIR/transmutes_expressible_as_ptr_casts.rs:28:46
    |
-LL |     let _ptr_to_unsized_transmute = unsafe { transmute::<*const [i32], *const [u16]>(slice_ptr) };
-   |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `slice_ptr as *const [u16]`
+LL |     let _ptr_to_unsized_transmute = unsafe { transmute::<*const [i32], *const [u32]>(slice_ptr) };
+   |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `slice_ptr as *const [u32]`
 
 error: transmute from `*const i32` to `usize` which could be expressed as a pointer cast instead
   --> $DIR/transmutes_expressible_as_ptr_casts.rs:34:50
-- 
cgit 1.4.1-3-g733a5


From 2b0f9aba64005f5dc20e250a327078dea3d3930f Mon Sep 17 00:00:00 2001
From: Jaeyong Sung <jaeyong0201@gmail.com>
Date: Sat, 5 Mar 2022 21:39:00 +0900
Subject: don't lint when implementing trait

---
 clippy_lints/src/only_used_in_recursion.rs | 23 +++++++++++++++++++----
 tests/ui/only_used_in_recursion.rs         | 28 ++++++++++++++++++++++++++--
 tests/ui/only_used_in_recursion.stderr     |  6 +++---
 3 files changed, 48 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/only_used_in_recursion.rs b/clippy_lints/src/only_used_in_recursion.rs
index 21102e759e4..bbf3f24566b 100644
--- a/clippy_lints/src/only_used_in_recursion.rs
+++ b/clippy_lints/src/only_used_in_recursion.rs
@@ -6,6 +6,7 @@ use rustc_ast::{walk_list, Label, Mutability};
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_errors::Applicability;
 use rustc_hir::def::Res;
+use rustc_hir::definitions::{DefPathData, DisambiguatedDefPathData};
 use rustc_hir::intravisit::{walk_expr, FnKind, Visitor};
 use rustc_hir::{
     Arm, Block, Body, Expr, ExprKind, Guard, HirId, Let, Local, Pat, PatKind, Path, PathSegment, QPath, Stmt, StmtKind,
@@ -22,13 +23,14 @@ use rustc_span::Span;
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for arguments that are only used in recursion with no side-effects.
+    ///
+    /// ### Why is this bad?
+    /// It could contain a useless calculation and can make function simpler.
+    ///
     /// The arguments can be involved in calculations and assignments but as long as
     /// the calculations have no side-effects (function calls or mutating dereference)
     /// and the assigned variables are also only in recursion, it is useless.
     ///
-    /// ### Why is this bad?
-    /// The could contain a useless calculation and can make function simpler.
-    ///
     /// ### Known problems
     /// In some cases, this would not catch all useless arguments.
     ///
@@ -52,6 +54,8 @@ declare_clippy_lint! {
     /// - some `break` relative operations
     /// - struct pattern binding
     ///
+    /// Also, when you recurse the function name with path segments, it is not possible to detect.
+    ///
     /// ### Example
     /// ```rust
     /// fn f(a: usize, b: usize) -> usize {
@@ -93,9 +97,20 @@ impl<'tcx> LateLintPass<'tcx> for OnlyUsedInRecursion {
         _: &'tcx rustc_hir::FnDecl<'tcx>,
         body: &'tcx Body<'tcx>,
         _: Span,
-        _: HirId,
+        id: HirId,
     ) {
         if let FnKind::ItemFn(ident, ..) | FnKind::Method(ident, ..) = kind {
+            let data = cx.tcx.def_path(cx.tcx.hir().local_def_id(id).to_def_id()).data;
+            if data.len() > 1 {
+                match data.get(data.len() - 2) {
+                    Some(DisambiguatedDefPathData {
+                        data: DefPathData::Impl,
+                        disambiguator,
+                    }) if *disambiguator != 0 => return,
+                    _ => {},
+                }
+            }
+
             let ty_res = cx.typeck_results();
             let param_span = body
                 .params
diff --git a/tests/ui/only_used_in_recursion.rs b/tests/ui/only_used_in_recursion.rs
index a0c40eb0826..799adfd3be2 100644
--- a/tests/ui/only_used_in_recursion.rs
+++ b/tests/ui/only_used_in_recursion.rs
@@ -61,8 +61,28 @@ fn not_primitive_op(a: usize, b: String, c: &str) -> usize {
 struct A;
 
 impl A {
-    fn method(&self, a: usize, b: usize) -> usize {
-        if a == 0 { 1 } else { self.method(a - 1, b + 1) }
+    fn method(a: usize, b: usize) -> usize {
+        if a == 0 { 1 } else { A::method(a - 1, b - 1) }
+    }
+
+    fn method2(&self, a: usize, b: usize) -> usize {
+        if a == 0 { 1 } else { self.method2(a - 1, b + 1) }
+    }
+}
+
+trait B {
+    fn hello(a: usize, b: usize) -> usize;
+
+    fn hello2(&self, a: usize, b: usize) -> usize;
+}
+
+impl B for A {
+    fn hello(a: usize, b: usize) -> usize {
+        if a == 0 { 1 } else { A::hello(a - 1, b + 1) }
+    }
+
+    fn hello2(&self, a: usize, b: usize) -> usize {
+        if a == 0 { 1 } else { self.hello2(a - 1, b + 1) }
     }
 }
 
@@ -70,4 +90,8 @@ fn ignore(a: usize, _: usize) -> usize {
     if a == 1 { 1 } else { ignore(a - 1, 0) }
 }
 
+fn ignore2(a: usize, _b: usize) -> usize {
+    if a == 1 { 1 } else { ignore2(a - 1, _b) }
+}
+
 fn main() {}
diff --git a/tests/ui/only_used_in_recursion.stderr b/tests/ui/only_used_in_recursion.stderr
index ed942e06f26..b2dd99bbe4d 100644
--- a/tests/ui/only_used_in_recursion.stderr
+++ b/tests/ui/only_used_in_recursion.stderr
@@ -61,10 +61,10 @@ LL | fn not_primitive(a: usize, b: String) -> usize {
    |                            ^ help: if this is intentional, prefix with an underscore: `_b`
 
 error: parameter is only used in recursion
-  --> $DIR/only_used_in_recursion.rs:64:32
+  --> $DIR/only_used_in_recursion.rs:68:33
    |
-LL |     fn method(&self, a: usize, b: usize) -> usize {
-   |                                ^ help: if this is intentional, prefix with an underscore: `_b`
+LL |     fn method2(&self, a: usize, b: usize) -> usize {
+   |                                 ^ help: if this is intentional, prefix with an underscore: `_b`
 
 error: aborting due to 11 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From c4a3ccde7816e17e99b489b9b2242b6ba185047c Mon Sep 17 00:00:00 2001
From: Jaeyong Sung <jaeyong0201@gmail.com>
Date: Sat, 5 Mar 2022 21:49:36 +0900
Subject: fix lint errors

---
 clippy_lints/src/only_used_in_recursion.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/only_used_in_recursion.rs b/clippy_lints/src/only_used_in_recursion.rs
index bbf3f24566b..0d7e52e1d62 100644
--- a/clippy_lints/src/only_used_in_recursion.rs
+++ b/clippy_lints/src/only_used_in_recursion.rs
@@ -204,7 +204,7 @@ impl<'tcx> LateLintPass<'tcx> for OnlyUsedInRecursion {
 pub fn is_primitive(ty: Ty<'_>) -> bool {
     match ty.kind() {
         ty::Bool | ty::Char | ty::Int(_) | ty::Uint(_) | ty::Float(_) | ty::Str => true,
-        ty::Ref(_, t, _) => is_primitive(t),
+        ty::Ref(_, t, _) => is_primitive(*t),
         _ => false,
     }
 }
@@ -212,7 +212,7 @@ pub fn is_primitive(ty: Ty<'_>) -> bool {
 pub fn is_array(ty: Ty<'_>) -> bool {
     match ty.kind() {
         ty::Array(..) | ty::Slice(..) => true,
-        ty::Ref(_, t, _) => is_array(t),
+        ty::Ref(_, t, _) => is_array(*t),
         _ => false,
     }
 }
-- 
cgit 1.4.1-3-g733a5


From ce841fe73b1476f6d4ac1495f88a567c501d01a8 Mon Sep 17 00:00:00 2001
From: "Samuel E. Moelius III" <sam@moeli.us>
Date: Sat, 5 Mar 2022 18:35:58 -0500
Subject: Format with `rustfmt_if_chain`

---
 clippy_lints/src/methods/unnecessary_to_owned.rs | 36 +++++++++---------------
 1 file changed, 14 insertions(+), 22 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/unnecessary_to_owned.rs b/clippy_lints/src/methods/unnecessary_to_owned.rs
index 7916fb8e3b4..cc9949b153f 100644
--- a/clippy_lints/src/methods/unnecessary_to_owned.rs
+++ b/clippy_lints/src/methods/unnecessary_to_owned.rs
@@ -114,7 +114,12 @@ fn check_addr_of_expr(
                     parent.span,
                     &format!("unnecessary use of `{}`", method_name),
                     "use",
-                    format!("{:&>width$}{}", "", receiver_snippet, width = n_target_refs - n_receiver_refs),
+                    format!(
+                        "{:&>width$}{}",
+                        "",
+                        receiver_snippet,
+                        width = n_target_refs - n_receiver_refs
+                    ),
                     Applicability::MachineApplicable,
                 );
                 return true;
@@ -182,20 +187,10 @@ fn check_into_iter_call_arg(cx: &LateContext<'_>, expr: &Expr<'_>, method_name:
         if let Some(item_ty) = get_iterator_item_ty(cx, parent_ty);
         if let Some(receiver_snippet) = snippet_opt(cx, receiver.span);
         then {
-            if unnecessary_iter_cloned::check_for_loop_iter(
-                cx,
-                parent,
-                method_name,
-                receiver,
-                true,
-            ) {
+            if unnecessary_iter_cloned::check_for_loop_iter(cx, parent, method_name, receiver, true) {
                 return true;
             }
-            let cloned_or_copied = if is_copy(cx, item_ty) {
-                "copied"
-            } else {
-                "cloned"
-            };
+            let cloned_or_copied = if is_copy(cx, item_ty) { "copied" } else { "cloned" };
             // The next suggestion may be incorrect because the removal of the `to_owned`-like
             // function could cause the iterator to hold a reference to a resource that is used
             // mutably. See https://github.com/rust-lang/rust-clippy/issues/8148.
@@ -243,10 +238,11 @@ fn check_other_call_arg<'tcx>(
         if if trait_predicate.def_id() == deref_trait_id {
             if let [projection_predicate] = projection_predicates[..] {
                 let normalized_ty =
-                    cx.tcx.subst_and_normalize_erasing_regions(call_substs, cx.param_env, projection_predicate.term);
+                    cx.tcx
+                        .subst_and_normalize_erasing_regions(call_substs, cx.param_env, projection_predicate.term);
                 implements_trait(cx, receiver_ty, deref_trait_id, &[])
-                    && get_associated_type(cx, receiver_ty, deref_trait_id,
-                    "Target").map_or(false, |ty| ty::Term::Ty(ty) == normalized_ty)
+                    && get_associated_type(cx, receiver_ty, deref_trait_id, "Target")
+                        .map_or(false, |ty| ty::Term::Ty(ty) == normalized_ty)
             } else {
                 false
             }
@@ -254,7 +250,7 @@ fn check_other_call_arg<'tcx>(
             let composed_substs = compose_substs(
                 cx,
                 &trait_predicate.trait_ref.substs.iter().skip(1).collect::<Vec<_>>()[..],
-                call_substs
+                call_substs,
             );
             implements_trait(cx, receiver_ty, as_ref_trait_id, &composed_substs)
         } else {
@@ -339,11 +335,7 @@ fn get_input_traits_and_projections<'tcx>(
                 if let Some(arg) = substs.iter().next();
                 if let GenericArgKind::Type(arg_ty) = arg.unpack();
                 if arg_ty == input;
-                then {
-                    true
-                } else {
-                    false
-                }
+                then { true } else { false }
             }
         };
         match predicate.kind().skip_binder() {
-- 
cgit 1.4.1-3-g733a5


From 1a95590faf2a81e7b7bae697c2209ba7607f0336 Mon Sep 17 00:00:00 2001
From: "Samuel E. Moelius III" <sam@moeli.us>
Date: Sat, 5 Mar 2022 21:18:44 -0500
Subject: Fix #8507

---
 clippy_lints/src/methods/unnecessary_to_owned.rs | 10 ++++-
 tests/ui/unnecessary_to_owned.fixed              | 48 ++++++++++++++++++++++++
 tests/ui/unnecessary_to_owned.rs                 | 48 ++++++++++++++++++++++++
 tests/ui/unnecessary_to_owned.stderr             |  8 +++-
 4 files changed, 112 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/unnecessary_to_owned.rs b/clippy_lints/src/methods/unnecessary_to_owned.rs
index cc9949b153f..1555758fc4a 100644
--- a/clippy_lints/src/methods/unnecessary_to_owned.rs
+++ b/clippy_lints/src/methods/unnecessary_to_owned.rs
@@ -2,7 +2,9 @@ use super::implicit_clone::is_clone_like;
 use super::unnecessary_iter_cloned::{self, is_into_iter};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_opt;
-use clippy_utils::ty::{get_associated_type, get_iterator_item_ty, implements_trait, is_copy, peel_mid_ty_refs};
+use clippy_utils::ty::{
+    contains_ty, get_associated_type, get_iterator_item_ty, implements_trait, is_copy, peel_mid_ty_refs,
+};
 use clippy_utils::{fn_def_id, get_parent_expr, is_diag_item_method, is_diag_trait_item};
 use rustc_errors::Applicability;
 use rustc_hir::{def_id::DefId, BorrowKind, Expr, ExprKind};
@@ -260,6 +262,12 @@ fn check_other_call_arg<'tcx>(
         // `Target = T`.
         if n_refs > 0 || is_copy(cx, receiver_ty) || trait_predicate.def_id() != deref_trait_id;
         let n_refs = max(n_refs, if is_copy(cx, receiver_ty) { 0 } else { 1 });
+        // If the trait is `AsRef` and the input type variable `T` occurs in the output type, then
+        // `T` must not be instantiated with a reference
+        // (https://github.com/rust-lang/rust-clippy/issues/8507).
+        if (n_refs == 0 && !receiver_ty.is_ref())
+            || trait_predicate.def_id() != as_ref_trait_id
+            || !contains_ty(fn_sig.output(), input);
         if let Some(receiver_snippet) = snippet_opt(cx, receiver.span);
         then {
             span_lint_and_sugg(
diff --git a/tests/ui/unnecessary_to_owned.fixed b/tests/ui/unnecessary_to_owned.fixed
index 720138db137..38ba41ac54e 100644
--- a/tests/ui/unnecessary_to_owned.fixed
+++ b/tests/ui/unnecessary_to_owned.fixed
@@ -212,3 +212,51 @@ fn get_file_path(_file_type: &FileType) -> Result<std::path::PathBuf, std::io::E
 }
 
 fn require_string(_: &String) {}
+
+// https://github.com/rust-lang/rust-clippy/issues/8507
+mod issue_8507 {
+    #![allow(dead_code)]
+
+    struct Opaque<P>(P);
+
+    pub trait Abstracted {}
+
+    impl<P> Abstracted for Opaque<P> {}
+
+    fn build<P>(p: P) -> Opaque<P>
+    where
+        P: AsRef<str>,
+    {
+        Opaque(p)
+    }
+
+    // Should not lint.
+    fn test_str(s: &str) -> Box<dyn Abstracted> {
+        Box::new(build(s.to_string()))
+    }
+
+    // Should not lint.
+    fn test_x(x: super::X) -> Box<dyn Abstracted> {
+        Box::new(build(x))
+    }
+
+    #[derive(Clone, Copy)]
+    struct Y(&'static str);
+
+    impl AsRef<str> for Y {
+        fn as_ref(&self) -> &str {
+            self.0
+        }
+    }
+
+    impl ToString for Y {
+        fn to_string(&self) -> String {
+            self.0.to_string()
+        }
+    }
+
+    // Should lint because Y is copy.
+    fn test_y(y: Y) -> Box<dyn Abstracted> {
+        Box::new(build(y))
+    }
+}
diff --git a/tests/ui/unnecessary_to_owned.rs b/tests/ui/unnecessary_to_owned.rs
index 60b2e718f5d..15fb7ee83e3 100644
--- a/tests/ui/unnecessary_to_owned.rs
+++ b/tests/ui/unnecessary_to_owned.rs
@@ -212,3 +212,51 @@ fn get_file_path(_file_type: &FileType) -> Result<std::path::PathBuf, std::io::E
 }
 
 fn require_string(_: &String) {}
+
+// https://github.com/rust-lang/rust-clippy/issues/8507
+mod issue_8507 {
+    #![allow(dead_code)]
+
+    struct Opaque<P>(P);
+
+    pub trait Abstracted {}
+
+    impl<P> Abstracted for Opaque<P> {}
+
+    fn build<P>(p: P) -> Opaque<P>
+    where
+        P: AsRef<str>,
+    {
+        Opaque(p)
+    }
+
+    // Should not lint.
+    fn test_str(s: &str) -> Box<dyn Abstracted> {
+        Box::new(build(s.to_string()))
+    }
+
+    // Should not lint.
+    fn test_x(x: super::X) -> Box<dyn Abstracted> {
+        Box::new(build(x))
+    }
+
+    #[derive(Clone, Copy)]
+    struct Y(&'static str);
+
+    impl AsRef<str> for Y {
+        fn as_ref(&self) -> &str {
+            self.0
+        }
+    }
+
+    impl ToString for Y {
+        fn to_string(&self) -> String {
+            self.0.to_string()
+        }
+    }
+
+    // Should lint because Y is copy.
+    fn test_y(y: Y) -> Box<dyn Abstracted> {
+        Box::new(build(y.to_string()))
+    }
+}
diff --git a/tests/ui/unnecessary_to_owned.stderr b/tests/ui/unnecessary_to_owned.stderr
index 1dfc65e22e2..c53ce32be77 100644
--- a/tests/ui/unnecessary_to_owned.stderr
+++ b/tests/ui/unnecessary_to_owned.stderr
@@ -491,5 +491,11 @@ LL -         let path = match get_file_path(&t) {
 LL +         let path = match get_file_path(t) {
    | 
 
-error: aborting due to 76 previous errors
+error: unnecessary use of `to_string`
+  --> $DIR/unnecessary_to_owned.rs:260:24
+   |
+LL |         Box::new(build(y.to_string()))
+   |                        ^^^^^^^^^^^^^ help: use: `y`
+
+error: aborting due to 77 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From db3fcf8df7269f9265e4643d4aa81f11d550e06b Mon Sep 17 00:00:00 2001
From: J-ZhengLi <lizheng135@huawei.com>
Date: Mon, 7 Mar 2022 18:12:35 +0800
Subject: add basic code to check nop match blocks modify `manual_map_option`
 uitest because one test case has confliction.

---
 clippy_lints/src/matches/mod.rs       | 10 ++--
 clippy_lints/src/matches/nop_match.rs | 98 ++++++++++++++++++++++++++++++++---
 tests/ui/manual_map_option.fixed      |  1 +
 tests/ui/manual_map_option.rs         |  1 +
 tests/ui/nop_match.fixed              | 71 +++++++++++++------------
 tests/ui/nop_match.rs                 | 77 +++++++++++++++++----------
 tests/ui/nop_match.stderr             | 53 +++++++++++++++++++
 7 files changed, 238 insertions(+), 73 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/mod.rs b/clippy_lints/src/matches/mod.rs
index 48300931dc4..7c29df0dfb4 100644
--- a/clippy_lints/src/matches/mod.rs
+++ b/clippy_lints/src/matches/mod.rs
@@ -16,12 +16,12 @@ mod match_same_arms;
 mod match_single_binding;
 mod match_wild_enum;
 mod match_wild_err_arm;
+mod nop_match;
 mod overlapping_arms;
 mod redundant_pattern_match;
 mod rest_pat_in_fully_bound_struct;
 mod single_match;
 mod wild_in_or_pats;
-mod nop_match;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -569,7 +569,7 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for unnecessary `match` or match-like `if let` returns for `Option` and `Result` 
+    /// Checks for unnecessary `match` or match-like `if let` returns for `Option` and `Result`
     /// when function signatures are the same.
     ///
     /// ### Why is this bad?
@@ -583,7 +583,7 @@ declare_clippy_lint! {
     ///         Err(err) => Err(err),
     ///     }
     /// }
-    /// 
+    ///
     /// fn bar() -> Option<i32> {
     ///     if let Some(val) = option {
     ///         Some(val)
@@ -594,12 +594,12 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Could be replaced as
-    /// 
+    ///
     /// ```rust,ignore
     /// fn foo() -> Result<(), i32> {
     ///     result
     /// }
-    /// 
+    ///
     /// fn bar() -> Option<i32> {
     ///     option
     /// }
diff --git a/clippy_lints/src/matches/nop_match.rs b/clippy_lints/src/matches/nop_match.rs
index d995caf6cfd..a0fff490cfa 100644
--- a/clippy_lints/src/matches/nop_match.rs
+++ b/clippy_lints/src/matches/nop_match.rs
@@ -1,9 +1,11 @@
 #![allow(unused_variables)]
+use super::NOP_MATCH;
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use rustc_lint::LateContext;
-use rustc_hir::{Arm, Expr};
+use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::{eq_expr_value, get_parent_expr};
 use rustc_errors::Applicability;
-use super::NOP_MATCH;
+use rustc_hir::{Arm, BindingAnnotation, Expr, ExprKind, Pat, PatKind, PathSegment, QPath};
+use rustc_lint::LateContext;
 
 pub(crate) fn check(cx: &LateContext<'_>, ex: &Expr<'_>) {
     if false {
@@ -20,15 +22,95 @@ pub(crate) fn check(cx: &LateContext<'_>, ex: &Expr<'_>) {
 }
 
 pub(crate) fn check_match(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>]) {
-    if false {
+    // This is for avoiding collision with `match_single_binding`.
+    if arms.len() < 2 {
+        return;
+    }
+
+    for arm in arms {
+        if let PatKind::Wild = arm.pat.kind {
+            let ret_expr = strip_return(arm.body);
+            if !eq_expr_value(cx, ex, ret_expr) {
+                return;
+            }
+        } else if !pat_same_as_expr(arm.pat, arm.body) {
+            return;
+        }
+    }
+
+    if let Some(match_expr) = get_parent_expr(cx, ex) {
+        let mut applicability = Applicability::MachineApplicable;
         span_lint_and_sugg(
             cx,
             NOP_MATCH,
-            ex.span,
+            match_expr.span,
             "this match expression is unnecessary",
             "replace it with",
-            "".to_string(),
-            Applicability::MachineApplicable,
+            snippet_with_applicability(cx, ex.span, "..", &mut applicability).to_string(),
+            applicability,
         );
     }
-}
\ No newline at end of file
+}
+
+fn strip_return<'hir>(expr: &'hir Expr<'hir>) -> &'hir Expr<'hir> {
+    if let ExprKind::Ret(Some(ret)) = expr.kind {
+        ret
+    } else {
+        expr
+    }
+}
+
+fn pat_same_as_expr(pat: &Pat<'_>, expr: &Expr<'_>) -> bool {
+    let expr = strip_return(expr);
+    match (&pat.kind, &expr.kind) {
+        (
+            PatKind::TupleStruct(QPath::Resolved(_, path), [first_pat, ..], _),
+            ExprKind::Call(call_expr, [first_param, ..]),
+        ) => {
+            if let ExprKind::Path(QPath::Resolved(_, call_path)) = call_expr.kind {
+                if is_identical_segments(path.segments, call_path.segments)
+                    && has_same_non_ref_symbol(first_pat, first_param)
+                {
+                    return true;
+                }
+            }
+        },
+        (PatKind::Path(QPath::Resolved(_, p_path)), ExprKind::Path(QPath::Resolved(_, e_path))) => {
+            return is_identical_segments(p_path.segments, e_path.segments);
+        },
+        (PatKind::Lit(pat_lit_expr), ExprKind::Lit(expr_spanned)) => {
+            if let ExprKind::Lit(pat_spanned) = &pat_lit_expr.kind {
+                return pat_spanned.node == expr_spanned.node;
+            }
+        },
+        _ => {},
+    }
+
+    false
+}
+
+fn is_identical_segments(left_segs: &[PathSegment<'_>], right_segs: &[PathSegment<'_>]) -> bool {
+    if left_segs.len() != right_segs.len() {
+        return false;
+    }
+    for i in 0..left_segs.len() {
+        if left_segs[i].ident.name != right_segs[i].ident.name {
+            return false;
+        }
+    }
+    true
+}
+
+fn has_same_non_ref_symbol(pat: &Pat<'_>, expr: &Expr<'_>) -> bool {
+    if_chain! {
+        if let PatKind::Binding(annot, _, pat_ident, _) = pat.kind;
+        if !matches!(annot, BindingAnnotation::Ref | BindingAnnotation::RefMut);
+        if let ExprKind::Path(QPath::Resolved(_, path)) = expr.kind;
+        if let Some(first_seg) = path.segments.first();
+        then {
+            return pat_ident.name == first_seg.ident.name;
+        }
+    }
+
+    false
+}
diff --git a/tests/ui/manual_map_option.fixed b/tests/ui/manual_map_option.fixed
index 294d79abc04..6f71b5d3d32 100644
--- a/tests/ui/manual_map_option.fixed
+++ b/tests/ui/manual_map_option.fixed
@@ -148,6 +148,7 @@ fn main() {
 
     // #7077
     let s = &String::new();
+    #[allow(clippy::nop_match)]
     let _: Option<&str> = match Some(s) {
         Some(s) => Some(s),
         None => None,
diff --git a/tests/ui/manual_map_option.rs b/tests/ui/manual_map_option.rs
index d11bf5ecb82..f1b79f127a0 100644
--- a/tests/ui/manual_map_option.rs
+++ b/tests/ui/manual_map_option.rs
@@ -214,6 +214,7 @@ fn main() {
 
     // #7077
     let s = &String::new();
+    #[allow(clippy::nop_match)]
     let _: Option<&str> = match Some(s) {
         Some(s) => Some(s),
         None => None,
diff --git a/tests/ui/nop_match.fixed b/tests/ui/nop_match.fixed
index 0e37bb85439..eff03a464ce 100644
--- a/tests/ui/nop_match.fixed
+++ b/tests/ui/nop_match.fixed
@@ -4,26 +4,47 @@
 #![allow(clippy::question_mark)]
 #![allow(dead_code)]
 
-fn option_match() -> Option<i32> {
-    match Some(1) {
-        Some(a) => Some(a),
-        None => None
+fn func_ret_err<T>(err: T) -> Result<(), T> {
+    Err(err)
+}
+
+enum SampleEnum {
+    A,
+    B,
+    C,
+}
+
+fn useless_prim_type_match(x: i32) -> i32 {
+    x
+}
+
+fn useless_custom_type_match(se: SampleEnum) -> SampleEnum {
+    se
+}
+
+// Don't trigger
+fn mingled_custom_type(se: SampleEnum) -> SampleEnum {
+    match se {
+        SampleEnum::A => SampleEnum::B,
+        SampleEnum::B => SampleEnum::C,
+        SampleEnum::C => SampleEnum::A,
     }
 }
 
+fn option_match() -> Option<i32> {
+    Some(1)
+}
+
 fn result_match() -> Result<i32, i32> {
-    match Ok(1) {
-        Ok(a) => Ok(a),
-        Err(err) => Err(err)
-    }
+    Ok(1)
+}
+
+fn result_match_func_call() {
+    let _ = func_ret_err(0_i32);
 }
 
 fn option_check() -> Option<i32> {
-    if let Some(a) = Some(1) {
-        Some(a)
-    } else {
-        None
-    }
+    if let Some(a) = Some(1) { Some(a) } else { None }
 }
 
 fn option_check_no_else() -> Option<i32> {
@@ -33,10 +54,6 @@ fn option_check_no_else() -> Option<i32> {
     None
 }
 
-fn func_ret_err<T>(err: T) -> Result<(), T> {
-    Err(err)
-}
-
 fn result_check_no_else() -> Result<(), i32> {
     if let Err(e) = func_ret_err(0_i32) {
         return Err(e);
@@ -54,30 +71,18 @@ fn result_check_a() -> Result<(), i32> {
 
 // Don't trigger
 fn result_check_b() -> Result<(), i32> {
-    if let Err(e) = Ok(1) {
-        Err(e)
-    } else {
-        Ok(())
-    }
+    if let Err(e) = Ok(1) { Err(e) } else { Ok(()) }
 }
 
 fn result_check_c() -> Result<(), i32> {
     let example = Ok(());
-    if let Err(e) = example {
-        Err(e)
-    } else {
-        example
-    }
+    if let Err(e) = example { Err(e) } else { example }
 }
 
 // Don't trigger
 fn result_check_d() -> Result<(), i32> {
     let example = Ok(1);
-    if let Err(e) = example {
-        Err(e)
-    } else {
-        Ok(())
-    }
+    if let Err(e) = example { Err(e) } else { Ok(()) }
 }
 
-fn main() { }
\ No newline at end of file
+fn main() {}
diff --git a/tests/ui/nop_match.rs b/tests/ui/nop_match.rs
index 0e37bb85439..4c4b47ce9c5 100644
--- a/tests/ui/nop_match.rs
+++ b/tests/ui/nop_match.rs
@@ -4,26 +4,65 @@
 #![allow(clippy::question_mark)]
 #![allow(dead_code)]
 
+fn func_ret_err<T>(err: T) -> Result<(), T> {
+    Err(err)
+}
+
+enum SampleEnum {
+    A,
+    B,
+    C,
+}
+
+fn useless_prim_type_match(x: i32) -> i32 {
+    match x {
+        0 => 0,
+        1 => 1,
+        2 => 2,
+        _ => x,
+    }
+}
+
+fn useless_custom_type_match(se: SampleEnum) -> SampleEnum {
+    match se {
+        SampleEnum::A => SampleEnum::A,
+        SampleEnum::B => SampleEnum::B,
+        SampleEnum::C => SampleEnum::C,
+    }
+}
+
+// Don't trigger
+fn mingled_custom_type(se: SampleEnum) -> SampleEnum {
+    match se {
+        SampleEnum::A => SampleEnum::B,
+        SampleEnum::B => SampleEnum::C,
+        SampleEnum::C => SampleEnum::A,
+    }
+}
+
 fn option_match() -> Option<i32> {
     match Some(1) {
         Some(a) => Some(a),
-        None => None
+        None => None,
     }
 }
 
 fn result_match() -> Result<i32, i32> {
     match Ok(1) {
         Ok(a) => Ok(a),
-        Err(err) => Err(err)
+        Err(err) => Err(err),
     }
 }
 
+fn result_match_func_call() {
+    let _ = match func_ret_err(0_i32) {
+        Ok(a) => Ok(a),
+        Err(err) => Err(err),
+    };
+}
+
 fn option_check() -> Option<i32> {
-    if let Some(a) = Some(1) {
-        Some(a)
-    } else {
-        None
-    }
+    if let Some(a) = Some(1) { Some(a) } else { None }
 }
 
 fn option_check_no_else() -> Option<i32> {
@@ -33,10 +72,6 @@ fn option_check_no_else() -> Option<i32> {
     None
 }
 
-fn func_ret_err<T>(err: T) -> Result<(), T> {
-    Err(err)
-}
-
 fn result_check_no_else() -> Result<(), i32> {
     if let Err(e) = func_ret_err(0_i32) {
         return Err(e);
@@ -54,30 +89,18 @@ fn result_check_a() -> Result<(), i32> {
 
 // Don't trigger
 fn result_check_b() -> Result<(), i32> {
-    if let Err(e) = Ok(1) {
-        Err(e)
-    } else {
-        Ok(())
-    }
+    if let Err(e) = Ok(1) { Err(e) } else { Ok(()) }
 }
 
 fn result_check_c() -> Result<(), i32> {
     let example = Ok(());
-    if let Err(e) = example {
-        Err(e)
-    } else {
-        example
-    }
+    if let Err(e) = example { Err(e) } else { example }
 }
 
 // Don't trigger
 fn result_check_d() -> Result<(), i32> {
     let example = Ok(1);
-    if let Err(e) = example {
-        Err(e)
-    } else {
-        Ok(())
-    }
+    if let Err(e) = example { Err(e) } else { Ok(()) }
 }
 
-fn main() { }
\ No newline at end of file
+fn main() {}
diff --git a/tests/ui/nop_match.stderr b/tests/ui/nop_match.stderr
index e69de29bb2d..bb171295f0f 100644
--- a/tests/ui/nop_match.stderr
+++ b/tests/ui/nop_match.stderr
@@ -0,0 +1,53 @@
+error: this match expression is unnecessary
+  --> $DIR/nop_match.rs:18:5
+   |
+LL | /     match x {
+LL | |         0 => 0,
+LL | |         1 => 1,
+LL | |         2 => 2,
+LL | |         _ => x,
+LL | |     }
+   | |_____^ help: replace it with: `x`
+   |
+   = note: `-D clippy::nop-match` implied by `-D warnings`
+
+error: this match expression is unnecessary
+  --> $DIR/nop_match.rs:27:5
+   |
+LL | /     match se {
+LL | |         SampleEnum::A => SampleEnum::A,
+LL | |         SampleEnum::B => SampleEnum::B,
+LL | |         SampleEnum::C => SampleEnum::C,
+LL | |     }
+   | |_____^ help: replace it with: `se`
+
+error: this match expression is unnecessary
+  --> $DIR/nop_match.rs:44:5
+   |
+LL | /     match Some(1) {
+LL | |         Some(a) => Some(a),
+LL | |         None => None,
+LL | |     }
+   | |_____^ help: replace it with: `Some(1)`
+
+error: this match expression is unnecessary
+  --> $DIR/nop_match.rs:51:5
+   |
+LL | /     match Ok(1) {
+LL | |         Ok(a) => Ok(a),
+LL | |         Err(err) => Err(err),
+LL | |     }
+   | |_____^ help: replace it with: `Ok(1)`
+
+error: this match expression is unnecessary
+  --> $DIR/nop_match.rs:58:13
+   |
+LL |       let _ = match func_ret_err(0_i32) {
+   |  _____________^
+LL | |         Ok(a) => Ok(a),
+LL | |         Err(err) => Err(err),
+LL | |     };
+   | |_____^ help: replace it with: `func_ret_err(0_i32)`
+
+error: aborting due to 5 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 6bfc1120cf7773af46a9f0fa7a9ef47863577c05 Mon Sep 17 00:00:00 2001
From: J-ZhengLi <lizheng135@huawei.com>
Date: Tue, 8 Mar 2022 17:37:53 +0800
Subject: add nop if-let expression check. re-design test cases as some of them
 are not worth the effort to check.

---
 clippy_lints/src/matches/nop_match.rs |  95 ++++++++++++++++++++------
 tests/ui/nop_match.fixed              | 101 +++++++++++-----------------
 tests/ui/nop_match.rs                 | 122 +++++++++++++++-------------------
 tests/ui/nop_match.stderr             |  77 +++++++++++++++------
 4 files changed, 224 insertions(+), 171 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/nop_match.rs b/clippy_lints/src/matches/nop_match.rs
index a0fff490cfa..74e7ca2d5fe 100644
--- a/clippy_lints/src/matches/nop_match.rs
+++ b/clippy_lints/src/matches/nop_match.rs
@@ -1,25 +1,13 @@
-#![allow(unused_variables)]
 use super::NOP_MATCH;
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::{eq_expr_value, get_parent_expr};
+use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::{eq_expr_value, get_parent_expr, higher, is_else_clause, is_lang_ctor, peel_blocks_with_stmt};
 use rustc_errors::Applicability;
-use rustc_hir::{Arm, BindingAnnotation, Expr, ExprKind, Pat, PatKind, PathSegment, QPath};
+use rustc_hir::LangItem::OptionNone;
+use rustc_hir::{Arm, BindingAnnotation, Expr, ExprKind, Pat, PatKind, Path, PathSegment, QPath};
 use rustc_lint::LateContext;
-
-pub(crate) fn check(cx: &LateContext<'_>, ex: &Expr<'_>) {
-    if false {
-        span_lint_and_sugg(
-            cx,
-            NOP_MATCH,
-            ex.span,
-            "this if-let expression is unnecessary",
-            "replace it with",
-            "".to_string(),
-            Applicability::MachineApplicable,
-        );
-    }
-}
+use rustc_span::sym;
 
 pub(crate) fn check_match(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>]) {
     // This is for avoiding collision with `match_single_binding`.
@@ -52,6 +40,70 @@ pub(crate) fn check_match(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>])
     }
 }
 
+/// Check for nop `if let` expression that assembled as unnecessary match
+///
+/// ```rust,ignore
+/// if let Some(a) = option {
+///     Some(a)
+/// } else {
+///     None
+/// }
+/// ```
+/// OR
+/// ```rust,ignore
+/// if let SomeEnum::A = some_enum {
+///     SomeEnum::A
+/// } else if let SomeEnum::B = some_enum {
+///     SomeEnum::B
+/// } else {
+///     some_enum
+/// }
+/// ```
+pub(crate) fn check(cx: &LateContext<'_>, ex: &Expr<'_>) {
+    if_chain! {
+        if let Some(ref if_let) = higher::IfLet::hir(cx, ex);
+        if !is_else_clause(cx.tcx, ex);
+        if check_if_let(cx, if_let);
+        then {
+            let mut applicability = Applicability::MachineApplicable;
+            span_lint_and_sugg(
+                cx,
+                NOP_MATCH,
+                ex.span,
+                "this if-let expression is unnecessary",
+                "replace it with",
+                snippet_with_applicability(cx, if_let.let_expr.span, "..", &mut applicability).to_string(),
+                applicability,
+            );
+        }
+    }
+}
+
+fn check_if_let(cx: &LateContext<'_>, if_let: &higher::IfLet<'_>) -> bool {
+    if let Some(else_block) = if_let.if_else {
+        if !pat_same_as_expr(if_let.let_pat, peel_blocks_with_stmt(if_let.if_then)) {
+            return false;
+        }
+
+        let else_expr = peel_blocks_with_stmt(else_block);
+        // Recurrsively check for each `else if let` phrase,
+        if let Some(ref nested_if_let) = higher::IfLet::hir(cx, else_expr) {
+            return check_if_let(cx, nested_if_let);
+        }
+        let ret = strip_return(else_expr);
+        let let_expr_ty = cx.typeck_results().expr_ty(if_let.let_expr);
+        if is_type_diagnostic_item(cx, let_expr_ty, sym::Option) {
+            if let ExprKind::Path(ref qpath) = ret.kind {
+                return is_lang_ctor(cx, qpath, OptionNone) || eq_expr_value(cx, if_let.let_expr, ret);
+            }
+        } else {
+            return eq_expr_value(cx, if_let.let_expr, ret);
+        }
+        return true;
+    }
+    false
+}
+
 fn strip_return<'hir>(expr: &'hir Expr<'hir>) -> &'hir Expr<'hir> {
     if let ExprKind::Ret(Some(ret)) = expr.kind {
         ret
@@ -68,7 +120,7 @@ fn pat_same_as_expr(pat: &Pat<'_>, expr: &Expr<'_>) -> bool {
             ExprKind::Call(call_expr, [first_param, ..]),
         ) => {
             if let ExprKind::Path(QPath::Resolved(_, call_path)) = call_expr.kind {
-                if is_identical_segments(path.segments, call_path.segments)
+                if has_identical_segments(path.segments, call_path.segments)
                     && has_same_non_ref_symbol(first_pat, first_param)
                 {
                     return true;
@@ -76,7 +128,7 @@ fn pat_same_as_expr(pat: &Pat<'_>, expr: &Expr<'_>) -> bool {
             }
         },
         (PatKind::Path(QPath::Resolved(_, p_path)), ExprKind::Path(QPath::Resolved(_, e_path))) => {
-            return is_identical_segments(p_path.segments, e_path.segments);
+            return has_identical_segments(p_path.segments, e_path.segments);
         },
         (PatKind::Lit(pat_lit_expr), ExprKind::Lit(expr_spanned)) => {
             if let ExprKind::Lit(pat_spanned) = &pat_lit_expr.kind {
@@ -89,7 +141,7 @@ fn pat_same_as_expr(pat: &Pat<'_>, expr: &Expr<'_>) -> bool {
     false
 }
 
-fn is_identical_segments(left_segs: &[PathSegment<'_>], right_segs: &[PathSegment<'_>]) -> bool {
+fn has_identical_segments(left_segs: &[PathSegment<'_>], right_segs: &[PathSegment<'_>]) -> bool {
     if left_segs.len() != right_segs.len() {
         return false;
     }
@@ -105,8 +157,7 @@ fn has_same_non_ref_symbol(pat: &Pat<'_>, expr: &Expr<'_>) -> bool {
     if_chain! {
         if let PatKind::Binding(annot, _, pat_ident, _) = pat.kind;
         if !matches!(annot, BindingAnnotation::Ref | BindingAnnotation::RefMut);
-        if let ExprKind::Path(QPath::Resolved(_, path)) = expr.kind;
-        if let Some(first_seg) = path.segments.first();
+        if let ExprKind::Path(QPath::Resolved(_, Path {segments: [first_seg, ..], .. })) = expr.kind;
         then {
             return pat_ident.name == first_seg.ident.name;
         }
diff --git a/tests/ui/nop_match.fixed b/tests/ui/nop_match.fixed
index eff03a464ce..c8c05b6f4a4 100644
--- a/tests/ui/nop_match.fixed
+++ b/tests/ui/nop_match.fixed
@@ -1,88 +1,67 @@
 // run-rustfix
 #![warn(clippy::nop_match)]
 #![allow(clippy::manual_map)]
-#![allow(clippy::question_mark)]
 #![allow(dead_code)]
 
-fn func_ret_err<T>(err: T) -> Result<(), T> {
-    Err(err)
-}
-
-enum SampleEnum {
+enum Choice {
     A,
     B,
     C,
+    D,
 }
 
-fn useless_prim_type_match(x: i32) -> i32 {
-    x
-}
-
-fn useless_custom_type_match(se: SampleEnum) -> SampleEnum {
-    se
-}
-
-// Don't trigger
-fn mingled_custom_type(se: SampleEnum) -> SampleEnum {
-    match se {
-        SampleEnum::A => SampleEnum::B,
-        SampleEnum::B => SampleEnum::C,
-        SampleEnum::C => SampleEnum::A,
-    }
-}
-
-fn option_match() -> Option<i32> {
-    Some(1)
+fn useless_match(x: i32) {
+    let _: i32 = x;
 }
 
-fn result_match() -> Result<i32, i32> {
-    Ok(1)
+fn custom_type_match(se: Choice) {
+    let _: Choice = se;
+    // Don't trigger
+    let _: Choice = match se {
+        Choice::A => Choice::A,
+        Choice::B => Choice::B,
+        _ => Choice::C,
+    };
+    // Mingled, don't trigger
+    let _: Choice = match se {
+        Choice::A => Choice::B,
+        Choice::B => Choice::C,
+        Choice::C => Choice::D,
+        Choice::D => Choice::A,
+    };
 }
 
-fn result_match_func_call() {
-    let _ = func_ret_err(0_i32);
+fn option_match(x: Option<i32>) {
+    let _: Option<i32> = x;
+    // Don't trigger, this is the case for manual_map_option
+    let _: Option<i32> = match x {
+        Some(a) => Some(-a),
+        None => None,
+    };
 }
 
-fn option_check() -> Option<i32> {
-    if let Some(a) = Some(1) { Some(a) } else { None }
-}
-
-fn option_check_no_else() -> Option<i32> {
-    if let Some(a) = Some(1) {
-        return Some(a);
-    }
-    None
-}
-
-fn result_check_no_else() -> Result<(), i32> {
-    if let Err(e) = func_ret_err(0_i32) {
-        return Err(e);
-    }
-    Ok(())
+fn func_ret_err<T>(err: T) -> Result<i32, T> {
+    Err(err)
 }
 
-fn result_check_a() -> Result<(), i32> {
-    if let Err(e) = func_ret_err(0_i32) {
-        Err(e)
-    } else {
-        Ok(())
-    }
+fn result_match() {
+    let _: Result<i32, i32> = Ok(1);
+    let _: Result<i32, i32> = func_ret_err(0_i32);
 }
 
-// Don't trigger
-fn result_check_b() -> Result<(), i32> {
-    if let Err(e) = Ok(1) { Err(e) } else { Ok(()) }
+fn if_let_option() -> Option<i32> {
+    Some(1)
 }
 
-fn result_check_c() -> Result<(), i32> {
-    let example = Ok(());
-    if let Err(e) = example { Err(e) } else { example }
+fn if_let_result(x: Result<(), i32>) {
+    let _: Result<(), i32> = x;
+    let _: Result<(), i32> = x;
+    // Input type mismatch, don't trigger
+    let _: Result<(), i32> = if let Err(e) = Ok(1) { Err(e) } else { x };
 }
 
-// Don't trigger
-fn result_check_d() -> Result<(), i32> {
-    let example = Ok(1);
-    if let Err(e) = example { Err(e) } else { Ok(()) }
+fn custom_enum_a(x: Choice) -> Choice {
+    x
 }
 
 fn main() {}
diff --git a/tests/ui/nop_match.rs b/tests/ui/nop_match.rs
index 4c4b47ce9c5..978811e28d1 100644
--- a/tests/ui/nop_match.rs
+++ b/tests/ui/nop_match.rs
@@ -1,106 +1,94 @@
 // run-rustfix
 #![warn(clippy::nop_match)]
 #![allow(clippy::manual_map)]
-#![allow(clippy::question_mark)]
 #![allow(dead_code)]
 
-fn func_ret_err<T>(err: T) -> Result<(), T> {
-    Err(err)
-}
-
-enum SampleEnum {
+enum Choice {
     A,
     B,
     C,
+    D,
 }
 
-fn useless_prim_type_match(x: i32) -> i32 {
-    match x {
+fn useless_match(x: i32) {
+    let _: i32 = match x {
         0 => 0,
         1 => 1,
         2 => 2,
         _ => x,
-    }
-}
-
-fn useless_custom_type_match(se: SampleEnum) -> SampleEnum {
-    match se {
-        SampleEnum::A => SampleEnum::A,
-        SampleEnum::B => SampleEnum::B,
-        SampleEnum::C => SampleEnum::C,
-    }
+    };
 }
 
-// Don't trigger
-fn mingled_custom_type(se: SampleEnum) -> SampleEnum {
-    match se {
-        SampleEnum::A => SampleEnum::B,
-        SampleEnum::B => SampleEnum::C,
-        SampleEnum::C => SampleEnum::A,
-    }
+fn custom_type_match(se: Choice) {
+    let _: Choice = match se {
+        Choice::A => Choice::A,
+        Choice::B => Choice::B,
+        Choice::C => Choice::C,
+        Choice::D => Choice::D,
+    };
+    // Don't trigger
+    let _: Choice = match se {
+        Choice::A => Choice::A,
+        Choice::B => Choice::B,
+        _ => Choice::C,
+    };
+    // Mingled, don't trigger
+    let _: Choice = match se {
+        Choice::A => Choice::B,
+        Choice::B => Choice::C,
+        Choice::C => Choice::D,
+        Choice::D => Choice::A,
+    };
 }
 
-fn option_match() -> Option<i32> {
-    match Some(1) {
+fn option_match(x: Option<i32>) {
+    let _: Option<i32> = match x {
         Some(a) => Some(a),
         None => None,
-    }
+    };
+    // Don't trigger, this is the case for manual_map_option
+    let _: Option<i32> = match x {
+        Some(a) => Some(-a),
+        None => None,
+    };
 }
 
-fn result_match() -> Result<i32, i32> {
-    match Ok(1) {
-        Ok(a) => Ok(a),
-        Err(err) => Err(err),
-    }
+fn func_ret_err<T>(err: T) -> Result<i32, T> {
+    Err(err)
 }
 
-fn result_match_func_call() {
-    let _ = match func_ret_err(0_i32) {
+fn result_match() {
+    let _: Result<i32, i32> = match Ok(1) {
         Ok(a) => Ok(a),
         Err(err) => Err(err),
     };
+    let _: Result<i32, i32> = match func_ret_err(0_i32) {
+        Err(err) => Err(err),
+        Ok(a) => Ok(a),
+    };
 }
 
-fn option_check() -> Option<i32> {
+fn if_let_option() -> Option<i32> {
     if let Some(a) = Some(1) { Some(a) } else { None }
 }
 
-fn option_check_no_else() -> Option<i32> {
-    if let Some(a) = Some(1) {
-        return Some(a);
-    }
-    None
-}
-
-fn result_check_no_else() -> Result<(), i32> {
-    if let Err(e) = func_ret_err(0_i32) {
-        return Err(e);
-    }
-    Ok(())
+fn if_let_result(x: Result<(), i32>) {
+    let _: Result<(), i32> = if let Err(e) = x { Err(e) } else { x };
+    let _: Result<(), i32> = if let Ok(val) = x { Ok(val) } else { x };
+    // Input type mismatch, don't trigger
+    let _: Result<(), i32> = if let Err(e) = Ok(1) { Err(e) } else { x };
 }
 
-fn result_check_a() -> Result<(), i32> {
-    if let Err(e) = func_ret_err(0_i32) {
-        Err(e)
+fn custom_enum_a(x: Choice) -> Choice {
+    if let Choice::A = x {
+        Choice::A
+    } else if let Choice::B = x {
+        Choice::B
+    } else if let Choice::C = x {
+        Choice::C
     } else {
-        Ok(())
+        x
     }
 }
 
-// Don't trigger
-fn result_check_b() -> Result<(), i32> {
-    if let Err(e) = Ok(1) { Err(e) } else { Ok(()) }
-}
-
-fn result_check_c() -> Result<(), i32> {
-    let example = Ok(());
-    if let Err(e) = example { Err(e) } else { example }
-}
-
-// Don't trigger
-fn result_check_d() -> Result<(), i32> {
-    let example = Ok(1);
-    if let Err(e) = example { Err(e) } else { Ok(()) }
-}
-
 fn main() {}
diff --git a/tests/ui/nop_match.stderr b/tests/ui/nop_match.stderr
index bb171295f0f..23a1d382a30 100644
--- a/tests/ui/nop_match.stderr
+++ b/tests/ui/nop_match.stderr
@@ -1,53 +1,88 @@
 error: this match expression is unnecessary
-  --> $DIR/nop_match.rs:18:5
+  --> $DIR/nop_match.rs:14:18
    |
-LL | /     match x {
+LL |       let _: i32 = match x {
+   |  __________________^
 LL | |         0 => 0,
 LL | |         1 => 1,
 LL | |         2 => 2,
 LL | |         _ => x,
-LL | |     }
+LL | |     };
    | |_____^ help: replace it with: `x`
    |
    = note: `-D clippy::nop-match` implied by `-D warnings`
 
 error: this match expression is unnecessary
-  --> $DIR/nop_match.rs:27:5
+  --> $DIR/nop_match.rs:23:21
    |
-LL | /     match se {
-LL | |         SampleEnum::A => SampleEnum::A,
-LL | |         SampleEnum::B => SampleEnum::B,
-LL | |         SampleEnum::C => SampleEnum::C,
-LL | |     }
+LL |       let _: Choice = match se {
+   |  _____________________^
+LL | |         Choice::A => Choice::A,
+LL | |         Choice::B => Choice::B,
+LL | |         Choice::C => Choice::C,
+LL | |         Choice::D => Choice::D,
+LL | |     };
    | |_____^ help: replace it with: `se`
 
 error: this match expression is unnecessary
-  --> $DIR/nop_match.rs:44:5
+  --> $DIR/nop_match.rs:45:26
    |
-LL | /     match Some(1) {
+LL |       let _: Option<i32> = match x {
+   |  __________________________^
 LL | |         Some(a) => Some(a),
 LL | |         None => None,
-LL | |     }
-   | |_____^ help: replace it with: `Some(1)`
+LL | |     };
+   | |_____^ help: replace it with: `x`
 
 error: this match expression is unnecessary
-  --> $DIR/nop_match.rs:51:5
+  --> $DIR/nop_match.rs:61:31
    |
-LL | /     match Ok(1) {
+LL |       let _: Result<i32, i32> = match Ok(1) {
+   |  _______________________________^
 LL | |         Ok(a) => Ok(a),
 LL | |         Err(err) => Err(err),
-LL | |     }
+LL | |     };
    | |_____^ help: replace it with: `Ok(1)`
 
 error: this match expression is unnecessary
-  --> $DIR/nop_match.rs:58:13
+  --> $DIR/nop_match.rs:65:31
    |
-LL |       let _ = match func_ret_err(0_i32) {
-   |  _____________^
-LL | |         Ok(a) => Ok(a),
+LL |       let _: Result<i32, i32> = match func_ret_err(0_i32) {
+   |  _______________________________^
 LL | |         Err(err) => Err(err),
+LL | |         Ok(a) => Ok(a),
 LL | |     };
    | |_____^ help: replace it with: `func_ret_err(0_i32)`
 
-error: aborting due to 5 previous errors
+error: this if-let expression is unnecessary
+  --> $DIR/nop_match.rs:72:5
+   |
+LL |     if let Some(a) = Some(1) { Some(a) } else { None }
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `Some(1)`
+
+error: this if-let expression is unnecessary
+  --> $DIR/nop_match.rs:76:30
+   |
+LL |     let _: Result<(), i32> = if let Err(e) = x { Err(e) } else { x };
+   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `x`
+
+error: this if-let expression is unnecessary
+  --> $DIR/nop_match.rs:77:30
+   |
+LL |     let _: Result<(), i32> = if let Ok(val) = x { Ok(val) } else { x };
+   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `x`
+
+error: this if-let expression is unnecessary
+  --> $DIR/nop_match.rs:83:5
+   |
+LL | /     if let Choice::A = x {
+LL | |         Choice::A
+LL | |     } else if let Choice::B = x {
+LL | |         Choice::B
+...  |
+LL | |         x
+LL | |     }
+   | |_____^ help: replace it with: `x`
+
+error: aborting due to 9 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 750204e3e35f8c9fe532b984abe9b4baf74da517 Mon Sep 17 00:00:00 2001
From: J-ZhengLi <lizheng135@huawei.com>
Date: Tue, 8 Mar 2022 18:15:11 +0800
Subject: fix a bug that caused internal test fail

---
 clippy_lints/src/matches/nop_match.rs | 25 ++++++++++++++-----------
 tests/ui/nop_match.fixed              | 13 +++++++++++--
 tests/ui/nop_match.rs                 | 15 ++++++++++++---
 tests/ui/nop_match.stderr             | 23 ++++++++++++-----------
 4 files changed, 49 insertions(+), 27 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/nop_match.rs b/clippy_lints/src/matches/nop_match.rs
index 74e7ca2d5fe..f13ee27df47 100644
--- a/clippy_lints/src/matches/nop_match.rs
+++ b/clippy_lints/src/matches/nop_match.rs
@@ -80,26 +80,29 @@ pub(crate) fn check(cx: &LateContext<'_>, ex: &Expr<'_>) {
 }
 
 fn check_if_let(cx: &LateContext<'_>, if_let: &higher::IfLet<'_>) -> bool {
-    if let Some(else_block) = if_let.if_else {
+    if let Some(if_else) = if_let.if_else {
         if !pat_same_as_expr(if_let.let_pat, peel_blocks_with_stmt(if_let.if_then)) {
             return false;
         }
 
-        let else_expr = peel_blocks_with_stmt(else_block);
         // Recurrsively check for each `else if let` phrase,
-        if let Some(ref nested_if_let) = higher::IfLet::hir(cx, else_expr) {
+        if let Some(ref nested_if_let) = higher::IfLet::hir(cx, if_else) {
             return check_if_let(cx, nested_if_let);
         }
-        let ret = strip_return(else_expr);
-        let let_expr_ty = cx.typeck_results().expr_ty(if_let.let_expr);
-        if is_type_diagnostic_item(cx, let_expr_ty, sym::Option) {
-            if let ExprKind::Path(ref qpath) = ret.kind {
-                return is_lang_ctor(cx, qpath, OptionNone) || eq_expr_value(cx, if_let.let_expr, ret);
+
+        if matches!(if_else.kind, ExprKind::Block(..)) {
+            let else_expr = peel_blocks_with_stmt(if_else);
+            let ret = strip_return(else_expr);
+            let let_expr_ty = cx.typeck_results().expr_ty(if_let.let_expr);
+            if is_type_diagnostic_item(cx, let_expr_ty, sym::Option) {
+                if let ExprKind::Path(ref qpath) = ret.kind {
+                    return is_lang_ctor(cx, qpath, OptionNone) || eq_expr_value(cx, if_let.let_expr, ret);
+                }
+            } else {
+                return eq_expr_value(cx, if_let.let_expr, ret);
             }
-        } else {
-            return eq_expr_value(cx, if_let.let_expr, ret);
+            return true;
         }
-        return true;
     }
     false
 }
diff --git a/tests/ui/nop_match.fixed b/tests/ui/nop_match.fixed
index c8c05b6f4a4..8875323a1bb 100644
--- a/tests/ui/nop_match.fixed
+++ b/tests/ui/nop_match.fixed
@@ -3,6 +3,7 @@
 #![allow(clippy::manual_map)]
 #![allow(dead_code)]
 
+#[derive(Clone, Copy)]
 enum Choice {
     A,
     B,
@@ -60,8 +61,16 @@ fn if_let_result(x: Result<(), i32>) {
     let _: Result<(), i32> = if let Err(e) = Ok(1) { Err(e) } else { x };
 }
 
-fn custom_enum_a(x: Choice) -> Choice {
-    x
+fn if_let_custom_enum(x: Choice) {
+    let _: Choice = x;
+    // Don't trigger
+    let _: Choice = if let Choice::A = x {
+        Choice::A
+    } else if true {
+        Choice::B
+    } else {
+        x
+    };
 }
 
 fn main() {}
diff --git a/tests/ui/nop_match.rs b/tests/ui/nop_match.rs
index 978811e28d1..19469a86022 100644
--- a/tests/ui/nop_match.rs
+++ b/tests/ui/nop_match.rs
@@ -3,6 +3,7 @@
 #![allow(clippy::manual_map)]
 #![allow(dead_code)]
 
+#[derive(Clone, Copy)]
 enum Choice {
     A,
     B,
@@ -79,8 +80,8 @@ fn if_let_result(x: Result<(), i32>) {
     let _: Result<(), i32> = if let Err(e) = Ok(1) { Err(e) } else { x };
 }
 
-fn custom_enum_a(x: Choice) -> Choice {
-    if let Choice::A = x {
+fn if_let_custom_enum(x: Choice) {
+    let _: Choice = if let Choice::A = x {
         Choice::A
     } else if let Choice::B = x {
         Choice::B
@@ -88,7 +89,15 @@ fn custom_enum_a(x: Choice) -> Choice {
         Choice::C
     } else {
         x
-    }
+    };
+    // Don't trigger
+    let _: Choice = if let Choice::A = x {
+        Choice::A
+    } else if true {
+        Choice::B
+    } else {
+        x
+    };
 }
 
 fn main() {}
diff --git a/tests/ui/nop_match.stderr b/tests/ui/nop_match.stderr
index 23a1d382a30..b7a1967bf5f 100644
--- a/tests/ui/nop_match.stderr
+++ b/tests/ui/nop_match.stderr
@@ -1,5 +1,5 @@
 error: this match expression is unnecessary
-  --> $DIR/nop_match.rs:14:18
+  --> $DIR/nop_match.rs:15:18
    |
 LL |       let _: i32 = match x {
    |  __________________^
@@ -13,7 +13,7 @@ LL | |     };
    = note: `-D clippy::nop-match` implied by `-D warnings`
 
 error: this match expression is unnecessary
-  --> $DIR/nop_match.rs:23:21
+  --> $DIR/nop_match.rs:24:21
    |
 LL |       let _: Choice = match se {
    |  _____________________^
@@ -25,7 +25,7 @@ LL | |     };
    | |_____^ help: replace it with: `se`
 
 error: this match expression is unnecessary
-  --> $DIR/nop_match.rs:45:26
+  --> $DIR/nop_match.rs:46:26
    |
 LL |       let _: Option<i32> = match x {
    |  __________________________^
@@ -35,7 +35,7 @@ LL | |     };
    | |_____^ help: replace it with: `x`
 
 error: this match expression is unnecessary
-  --> $DIR/nop_match.rs:61:31
+  --> $DIR/nop_match.rs:62:31
    |
 LL |       let _: Result<i32, i32> = match Ok(1) {
    |  _______________________________^
@@ -45,7 +45,7 @@ LL | |     };
    | |_____^ help: replace it with: `Ok(1)`
 
 error: this match expression is unnecessary
-  --> $DIR/nop_match.rs:65:31
+  --> $DIR/nop_match.rs:66:31
    |
 LL |       let _: Result<i32, i32> = match func_ret_err(0_i32) {
    |  _______________________________^
@@ -55,33 +55,34 @@ LL | |     };
    | |_____^ help: replace it with: `func_ret_err(0_i32)`
 
 error: this if-let expression is unnecessary
-  --> $DIR/nop_match.rs:72:5
+  --> $DIR/nop_match.rs:73:5
    |
 LL |     if let Some(a) = Some(1) { Some(a) } else { None }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `Some(1)`
 
 error: this if-let expression is unnecessary
-  --> $DIR/nop_match.rs:76:30
+  --> $DIR/nop_match.rs:77:30
    |
 LL |     let _: Result<(), i32> = if let Err(e) = x { Err(e) } else { x };
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `x`
 
 error: this if-let expression is unnecessary
-  --> $DIR/nop_match.rs:77:30
+  --> $DIR/nop_match.rs:78:30
    |
 LL |     let _: Result<(), i32> = if let Ok(val) = x { Ok(val) } else { x };
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `x`
 
 error: this if-let expression is unnecessary
-  --> $DIR/nop_match.rs:83:5
+  --> $DIR/nop_match.rs:84:21
    |
-LL | /     if let Choice::A = x {
+LL |       let _: Choice = if let Choice::A = x {
+   |  _____________________^
 LL | |         Choice::A
 LL | |     } else if let Choice::B = x {
 LL | |         Choice::B
 ...  |
 LL | |         x
-LL | |     }
+LL | |     };
    | |_____^ help: replace it with: `x`
 
 error: aborting due to 9 previous errors
-- 
cgit 1.4.1-3-g733a5


From ec9116412ae48f28521d042cdf4244a28f0070a5 Mon Sep 17 00:00:00 2001
From: J-ZhengLi <lizheng135@huawei.com>
Date: Thu, 10 Mar 2022 09:44:25 +0800
Subject: rename lint to `needless_match` and change its lint group to
 "complexity"

---
 CHANGELOG.md                                 |   2 +-
 clippy_lints/src/lib.register_all.rs         |   2 +-
 clippy_lints/src/lib.register_complexity.rs  |   1 +
 clippy_lints/src/lib.register_correctness.rs |   1 -
 clippy_lints/src/lib.register_lints.rs       |   2 +-
 clippy_lints/src/matches/mod.rs              |  12 +-
 clippy_lints/src/matches/needless_match.rs   | 170 +++++++++++++++++++++++++++
 clippy_lints/src/matches/nop_match.rs        | 170 ---------------------------
 tests/ui/manual_map_option.fixed             |   2 +-
 tests/ui/manual_map_option.rs                |   2 +-
 tests/ui/needless_match.fixed                |  76 ++++++++++++
 tests/ui/needless_match.rs                   | 103 ++++++++++++++++
 tests/ui/needless_match.stderr               |  89 ++++++++++++++
 tests/ui/nop_match.fixed                     |  76 ------------
 tests/ui/nop_match.rs                        | 103 ----------------
 tests/ui/nop_match.stderr                    |  89 --------------
 16 files changed, 450 insertions(+), 450 deletions(-)
 create mode 100644 clippy_lints/src/matches/needless_match.rs
 delete mode 100644 clippy_lints/src/matches/nop_match.rs
 create mode 100644 tests/ui/needless_match.fixed
 create mode 100644 tests/ui/needless_match.rs
 create mode 100644 tests/ui/needless_match.stderr
 delete mode 100644 tests/ui/nop_match.fixed
 delete mode 100644 tests/ui/nop_match.rs
 delete mode 100644 tests/ui/nop_match.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 16fe9454634..bc52bf7ce01 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3327,6 +3327,7 @@ Released 2018-09-13
 [`needless_for_each`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_for_each
 [`needless_late_init`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_late_init
 [`needless_lifetimes`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_lifetimes
+[`needless_match`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_match
 [`needless_option_as_deref`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_option_as_deref
 [`needless_pass_by_value`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_pass_by_value
 [`needless_question_mark`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_question_mark
@@ -3348,7 +3349,6 @@ Released 2018-09-13
 [`nonminimal_bool`]: https://rust-lang.github.io/rust-clippy/master/index.html#nonminimal_bool
 [`nonsensical_open_options`]: https://rust-lang.github.io/rust-clippy/master/index.html#nonsensical_open_options
 [`nonstandard_macro_braces`]: https://rust-lang.github.io/rust-clippy/master/index.html#nonstandard_macro_braces
-[`nop_match`]: https://rust-lang.github.io/rust-clippy/master/index.html#nop_match
 [`not_unsafe_ptr_arg_deref`]: https://rust-lang.github.io/rust-clippy/master/index.html#not_unsafe_ptr_arg_deref
 [`octal_escapes`]: https://rust-lang.github.io/rust-clippy/master/index.html#octal_escapes
 [`ok_expect`]: https://rust-lang.github.io/rust-clippy/master/index.html#ok_expect
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 01429bf7ea5..885d1034f21 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -134,7 +134,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(matches::MATCH_OVERLAPPING_ARM),
     LintId::of(matches::MATCH_REF_PATS),
     LintId::of(matches::MATCH_SINGLE_BINDING),
-    LintId::of(matches::NOP_MATCH),
+    LintId::of(matches::NEEDLESS_MATCH),
     LintId::of(matches::REDUNDANT_PATTERN_MATCHING),
     LintId::of(matches::SINGLE_MATCH),
     LintId::of(matches::WILDCARD_IN_OR_PATTERNS),
diff --git a/clippy_lints/src/lib.register_complexity.rs b/clippy_lints/src/lib.register_complexity.rs
index bd5ff613447..88db6c175d6 100644
--- a/clippy_lints/src/lib.register_complexity.rs
+++ b/clippy_lints/src/lib.register_complexity.rs
@@ -30,6 +30,7 @@ store.register_group(true, "clippy::complexity", Some("clippy_complexity"), vec!
     LintId::of(map_unit_fn::RESULT_MAP_UNIT_FN),
     LintId::of(matches::MATCH_AS_REF),
     LintId::of(matches::MATCH_SINGLE_BINDING),
+    LintId::of(matches::NEEDLESS_MATCH),
     LintId::of(matches::WILDCARD_IN_OR_PATTERNS),
     LintId::of(methods::BIND_INSTEAD_OF_MAP),
     LintId::of(methods::CLONE_ON_COPY),
diff --git a/clippy_lints/src/lib.register_correctness.rs b/clippy_lints/src/lib.register_correctness.rs
index 191fa96bdfd..18fe44282ed 100644
--- a/clippy_lints/src/lib.register_correctness.rs
+++ b/clippy_lints/src/lib.register_correctness.rs
@@ -37,7 +37,6 @@ store.register_group(true, "clippy::correctness", Some("clippy_correctness"), ve
     LintId::of(loops::NEVER_LOOP),
     LintId::of(loops::WHILE_IMMUTABLE_CONDITION),
     LintId::of(match_str_case_mismatch::MATCH_STR_CASE_MISMATCH),
-    LintId::of(matches::NOP_MATCH),
     LintId::of(mem_replace::MEM_REPLACE_WITH_UNINIT),
     LintId::of(methods::CLONE_DOUBLE_REF),
     LintId::of(methods::ITERATOR_STEP_BY_ZERO),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 2977a78f257..0d36fe702ef 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -253,7 +253,7 @@ store.register_lints(&[
     matches::MATCH_SINGLE_BINDING,
     matches::MATCH_WILDCARD_FOR_SINGLE_VARIANTS,
     matches::MATCH_WILD_ERR_ARM,
-    matches::NOP_MATCH,
+    matches::NEEDLESS_MATCH,
     matches::REDUNDANT_PATTERN_MATCHING,
     matches::REST_PAT_IN_FULLY_BOUND_STRUCTS,
     matches::SINGLE_MATCH,
diff --git a/clippy_lints/src/matches/mod.rs b/clippy_lints/src/matches/mod.rs
index 7c29df0dfb4..ff85623acf4 100644
--- a/clippy_lints/src/matches/mod.rs
+++ b/clippy_lints/src/matches/mod.rs
@@ -16,7 +16,7 @@ mod match_same_arms;
 mod match_single_binding;
 mod match_wild_enum;
 mod match_wild_err_arm;
-mod nop_match;
+mod needless_match;
 mod overlapping_arms;
 mod redundant_pattern_match;
 mod rest_pat_in_fully_bound_struct;
@@ -605,8 +605,8 @@ declare_clippy_lint! {
     /// }
     /// ```
     #[clippy::version = "1.61.0"]
-    pub NOP_MATCH,
-    correctness,
+    pub NEEDLESS_MATCH,
+    complexity,
     "`match` or match-like `if let` that are unnecessary"
 }
 
@@ -643,7 +643,7 @@ impl_lint_pass!(Matches => [
     REDUNDANT_PATTERN_MATCHING,
     MATCH_LIKE_MATCHES_MACRO,
     MATCH_SAME_ARMS,
-    NOP_MATCH,
+    NEEDLESS_MATCH,
 ]);
 
 impl<'tcx> LateLintPass<'tcx> for Matches {
@@ -667,7 +667,7 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
                     overlapping_arms::check(cx, ex, arms);
                     match_wild_enum::check(cx, ex, arms);
                     match_as_ref::check(cx, ex, arms, expr);
-                    nop_match::check_match(cx, ex, arms);
+                    needless_match::check_match(cx, ex, arms);
 
                     if self.infallible_destructuring_match_linted {
                         self.infallible_destructuring_match_linted = false;
@@ -686,7 +686,7 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
                 match_like_matches::check(cx, expr);
             }
             redundant_pattern_match::check(cx, expr);
-            nop_match::check(cx, expr);
+            needless_match::check(cx, expr);
         }
     }
 
diff --git a/clippy_lints/src/matches/needless_match.rs b/clippy_lints/src/matches/needless_match.rs
new file mode 100644
index 00000000000..8d209c6289c
--- /dev/null
+++ b/clippy_lints/src/matches/needless_match.rs
@@ -0,0 +1,170 @@
+use super::NEEDLESS_MATCH;
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::{eq_expr_value, get_parent_expr, higher, is_else_clause, is_lang_ctor, peel_blocks_with_stmt};
+use rustc_errors::Applicability;
+use rustc_hir::LangItem::OptionNone;
+use rustc_hir::{Arm, BindingAnnotation, Expr, ExprKind, Pat, PatKind, Path, PathSegment, QPath};
+use rustc_lint::LateContext;
+use rustc_span::sym;
+
+pub(crate) fn check_match(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>]) {
+    // This is for avoiding collision with `match_single_binding`.
+    if arms.len() < 2 {
+        return;
+    }
+
+    for arm in arms {
+        if let PatKind::Wild = arm.pat.kind {
+            let ret_expr = strip_return(arm.body);
+            if !eq_expr_value(cx, ex, ret_expr) {
+                return;
+            }
+        } else if !pat_same_as_expr(arm.pat, arm.body) {
+            return;
+        }
+    }
+
+    if let Some(match_expr) = get_parent_expr(cx, ex) {
+        let mut applicability = Applicability::MachineApplicable;
+        span_lint_and_sugg(
+            cx,
+            NEEDLESS_MATCH,
+            match_expr.span,
+            "this match expression is unnecessary",
+            "replace it with",
+            snippet_with_applicability(cx, ex.span, "..", &mut applicability).to_string(),
+            applicability,
+        );
+    }
+}
+
+/// Check for nop `if let` expression that assembled as unnecessary match
+///
+/// ```rust,ignore
+/// if let Some(a) = option {
+///     Some(a)
+/// } else {
+///     None
+/// }
+/// ```
+/// OR
+/// ```rust,ignore
+/// if let SomeEnum::A = some_enum {
+///     SomeEnum::A
+/// } else if let SomeEnum::B = some_enum {
+///     SomeEnum::B
+/// } else {
+///     some_enum
+/// }
+/// ```
+pub(crate) fn check(cx: &LateContext<'_>, ex: &Expr<'_>) {
+    if_chain! {
+        if let Some(ref if_let) = higher::IfLet::hir(cx, ex);
+        if !is_else_clause(cx.tcx, ex);
+        if check_if_let(cx, if_let);
+        then {
+            let mut applicability = Applicability::MachineApplicable;
+            span_lint_and_sugg(
+                cx,
+                NEEDLESS_MATCH,
+                ex.span,
+                "this if-let expression is unnecessary",
+                "replace it with",
+                snippet_with_applicability(cx, if_let.let_expr.span, "..", &mut applicability).to_string(),
+                applicability,
+            );
+        }
+    }
+}
+
+fn check_if_let(cx: &LateContext<'_>, if_let: &higher::IfLet<'_>) -> bool {
+    if let Some(if_else) = if_let.if_else {
+        if !pat_same_as_expr(if_let.let_pat, peel_blocks_with_stmt(if_let.if_then)) {
+            return false;
+        }
+
+        // Recurrsively check for each `else if let` phrase,
+        if let Some(ref nested_if_let) = higher::IfLet::hir(cx, if_else) {
+            return check_if_let(cx, nested_if_let);
+        }
+
+        if matches!(if_else.kind, ExprKind::Block(..)) {
+            let else_expr = peel_blocks_with_stmt(if_else);
+            let ret = strip_return(else_expr);
+            let let_expr_ty = cx.typeck_results().expr_ty(if_let.let_expr);
+            if is_type_diagnostic_item(cx, let_expr_ty, sym::Option) {
+                if let ExprKind::Path(ref qpath) = ret.kind {
+                    return is_lang_ctor(cx, qpath, OptionNone) || eq_expr_value(cx, if_let.let_expr, ret);
+                }
+            } else {
+                return eq_expr_value(cx, if_let.let_expr, ret);
+            }
+            return true;
+        }
+    }
+    false
+}
+
+fn strip_return<'hir>(expr: &'hir Expr<'hir>) -> &'hir Expr<'hir> {
+    if let ExprKind::Ret(Some(ret)) = expr.kind {
+        ret
+    } else {
+        expr
+    }
+}
+
+fn pat_same_as_expr(pat: &Pat<'_>, expr: &Expr<'_>) -> bool {
+    let expr = strip_return(expr);
+    match (&pat.kind, &expr.kind) {
+        (
+            PatKind::TupleStruct(QPath::Resolved(_, path), [first_pat, ..], _),
+            ExprKind::Call(call_expr, [first_param, ..]),
+        ) => {
+            if let ExprKind::Path(QPath::Resolved(_, call_path)) = call_expr.kind {
+                if has_identical_segments(path.segments, call_path.segments)
+                    && has_same_non_ref_symbol(first_pat, first_param)
+                {
+                    return true;
+                }
+            }
+        },
+        (PatKind::Path(QPath::Resolved(_, p_path)), ExprKind::Path(QPath::Resolved(_, e_path))) => {
+            return has_identical_segments(p_path.segments, e_path.segments);
+        },
+        (PatKind::Lit(pat_lit_expr), ExprKind::Lit(expr_spanned)) => {
+            if let ExprKind::Lit(pat_spanned) = &pat_lit_expr.kind {
+                return pat_spanned.node == expr_spanned.node;
+            }
+        },
+        _ => {},
+    }
+
+    false
+}
+
+fn has_identical_segments(left_segs: &[PathSegment<'_>], right_segs: &[PathSegment<'_>]) -> bool {
+    if left_segs.len() != right_segs.len() {
+        return false;
+    }
+    for i in 0..left_segs.len() {
+        if left_segs[i].ident.name != right_segs[i].ident.name {
+            return false;
+        }
+    }
+    true
+}
+
+fn has_same_non_ref_symbol(pat: &Pat<'_>, expr: &Expr<'_>) -> bool {
+    if_chain! {
+        if let PatKind::Binding(annot, _, pat_ident, _) = pat.kind;
+        if !matches!(annot, BindingAnnotation::Ref | BindingAnnotation::RefMut);
+        if let ExprKind::Path(QPath::Resolved(_, Path {segments: [first_seg, ..], .. })) = expr.kind;
+        then {
+            return pat_ident.name == first_seg.ident.name;
+        }
+    }
+
+    false
+}
diff --git a/clippy_lints/src/matches/nop_match.rs b/clippy_lints/src/matches/nop_match.rs
deleted file mode 100644
index f13ee27df47..00000000000
--- a/clippy_lints/src/matches/nop_match.rs
+++ /dev/null
@@ -1,170 +0,0 @@
-use super::NOP_MATCH;
-use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{eq_expr_value, get_parent_expr, higher, is_else_clause, is_lang_ctor, peel_blocks_with_stmt};
-use rustc_errors::Applicability;
-use rustc_hir::LangItem::OptionNone;
-use rustc_hir::{Arm, BindingAnnotation, Expr, ExprKind, Pat, PatKind, Path, PathSegment, QPath};
-use rustc_lint::LateContext;
-use rustc_span::sym;
-
-pub(crate) fn check_match(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>]) {
-    // This is for avoiding collision with `match_single_binding`.
-    if arms.len() < 2 {
-        return;
-    }
-
-    for arm in arms {
-        if let PatKind::Wild = arm.pat.kind {
-            let ret_expr = strip_return(arm.body);
-            if !eq_expr_value(cx, ex, ret_expr) {
-                return;
-            }
-        } else if !pat_same_as_expr(arm.pat, arm.body) {
-            return;
-        }
-    }
-
-    if let Some(match_expr) = get_parent_expr(cx, ex) {
-        let mut applicability = Applicability::MachineApplicable;
-        span_lint_and_sugg(
-            cx,
-            NOP_MATCH,
-            match_expr.span,
-            "this match expression is unnecessary",
-            "replace it with",
-            snippet_with_applicability(cx, ex.span, "..", &mut applicability).to_string(),
-            applicability,
-        );
-    }
-}
-
-/// Check for nop `if let` expression that assembled as unnecessary match
-///
-/// ```rust,ignore
-/// if let Some(a) = option {
-///     Some(a)
-/// } else {
-///     None
-/// }
-/// ```
-/// OR
-/// ```rust,ignore
-/// if let SomeEnum::A = some_enum {
-///     SomeEnum::A
-/// } else if let SomeEnum::B = some_enum {
-///     SomeEnum::B
-/// } else {
-///     some_enum
-/// }
-/// ```
-pub(crate) fn check(cx: &LateContext<'_>, ex: &Expr<'_>) {
-    if_chain! {
-        if let Some(ref if_let) = higher::IfLet::hir(cx, ex);
-        if !is_else_clause(cx.tcx, ex);
-        if check_if_let(cx, if_let);
-        then {
-            let mut applicability = Applicability::MachineApplicable;
-            span_lint_and_sugg(
-                cx,
-                NOP_MATCH,
-                ex.span,
-                "this if-let expression is unnecessary",
-                "replace it with",
-                snippet_with_applicability(cx, if_let.let_expr.span, "..", &mut applicability).to_string(),
-                applicability,
-            );
-        }
-    }
-}
-
-fn check_if_let(cx: &LateContext<'_>, if_let: &higher::IfLet<'_>) -> bool {
-    if let Some(if_else) = if_let.if_else {
-        if !pat_same_as_expr(if_let.let_pat, peel_blocks_with_stmt(if_let.if_then)) {
-            return false;
-        }
-
-        // Recurrsively check for each `else if let` phrase,
-        if let Some(ref nested_if_let) = higher::IfLet::hir(cx, if_else) {
-            return check_if_let(cx, nested_if_let);
-        }
-
-        if matches!(if_else.kind, ExprKind::Block(..)) {
-            let else_expr = peel_blocks_with_stmt(if_else);
-            let ret = strip_return(else_expr);
-            let let_expr_ty = cx.typeck_results().expr_ty(if_let.let_expr);
-            if is_type_diagnostic_item(cx, let_expr_ty, sym::Option) {
-                if let ExprKind::Path(ref qpath) = ret.kind {
-                    return is_lang_ctor(cx, qpath, OptionNone) || eq_expr_value(cx, if_let.let_expr, ret);
-                }
-            } else {
-                return eq_expr_value(cx, if_let.let_expr, ret);
-            }
-            return true;
-        }
-    }
-    false
-}
-
-fn strip_return<'hir>(expr: &'hir Expr<'hir>) -> &'hir Expr<'hir> {
-    if let ExprKind::Ret(Some(ret)) = expr.kind {
-        ret
-    } else {
-        expr
-    }
-}
-
-fn pat_same_as_expr(pat: &Pat<'_>, expr: &Expr<'_>) -> bool {
-    let expr = strip_return(expr);
-    match (&pat.kind, &expr.kind) {
-        (
-            PatKind::TupleStruct(QPath::Resolved(_, path), [first_pat, ..], _),
-            ExprKind::Call(call_expr, [first_param, ..]),
-        ) => {
-            if let ExprKind::Path(QPath::Resolved(_, call_path)) = call_expr.kind {
-                if has_identical_segments(path.segments, call_path.segments)
-                    && has_same_non_ref_symbol(first_pat, first_param)
-                {
-                    return true;
-                }
-            }
-        },
-        (PatKind::Path(QPath::Resolved(_, p_path)), ExprKind::Path(QPath::Resolved(_, e_path))) => {
-            return has_identical_segments(p_path.segments, e_path.segments);
-        },
-        (PatKind::Lit(pat_lit_expr), ExprKind::Lit(expr_spanned)) => {
-            if let ExprKind::Lit(pat_spanned) = &pat_lit_expr.kind {
-                return pat_spanned.node == expr_spanned.node;
-            }
-        },
-        _ => {},
-    }
-
-    false
-}
-
-fn has_identical_segments(left_segs: &[PathSegment<'_>], right_segs: &[PathSegment<'_>]) -> bool {
-    if left_segs.len() != right_segs.len() {
-        return false;
-    }
-    for i in 0..left_segs.len() {
-        if left_segs[i].ident.name != right_segs[i].ident.name {
-            return false;
-        }
-    }
-    true
-}
-
-fn has_same_non_ref_symbol(pat: &Pat<'_>, expr: &Expr<'_>) -> bool {
-    if_chain! {
-        if let PatKind::Binding(annot, _, pat_ident, _) = pat.kind;
-        if !matches!(annot, BindingAnnotation::Ref | BindingAnnotation::RefMut);
-        if let ExprKind::Path(QPath::Resolved(_, Path {segments: [first_seg, ..], .. })) = expr.kind;
-        then {
-            return pat_ident.name == first_seg.ident.name;
-        }
-    }
-
-    false
-}
diff --git a/tests/ui/manual_map_option.fixed b/tests/ui/manual_map_option.fixed
index 6f71b5d3d32..fc6a7abca0e 100644
--- a/tests/ui/manual_map_option.fixed
+++ b/tests/ui/manual_map_option.fixed
@@ -148,7 +148,7 @@ fn main() {
 
     // #7077
     let s = &String::new();
-    #[allow(clippy::nop_match)]
+    #[allow(clippy::needless_match)]
     let _: Option<&str> = match Some(s) {
         Some(s) => Some(s),
         None => None,
diff --git a/tests/ui/manual_map_option.rs b/tests/ui/manual_map_option.rs
index f1b79f127a0..16508270f64 100644
--- a/tests/ui/manual_map_option.rs
+++ b/tests/ui/manual_map_option.rs
@@ -214,7 +214,7 @@ fn main() {
 
     // #7077
     let s = &String::new();
-    #[allow(clippy::nop_match)]
+    #[allow(clippy::needless_match)]
     let _: Option<&str> = match Some(s) {
         Some(s) => Some(s),
         None => None,
diff --git a/tests/ui/needless_match.fixed b/tests/ui/needless_match.fixed
new file mode 100644
index 00000000000..eb6494a4da6
--- /dev/null
+++ b/tests/ui/needless_match.fixed
@@ -0,0 +1,76 @@
+// run-rustfix
+#![warn(clippy::needless_match)]
+#![allow(clippy::manual_map)]
+#![allow(dead_code)]
+
+#[derive(Clone, Copy)]
+enum Choice {
+    A,
+    B,
+    C,
+    D,
+}
+
+fn useless_match(x: i32) {
+    let _: i32 = x;
+}
+
+fn custom_type_match(se: Choice) {
+    let _: Choice = se;
+    // Don't trigger
+    let _: Choice = match se {
+        Choice::A => Choice::A,
+        Choice::B => Choice::B,
+        _ => Choice::C,
+    };
+    // Mingled, don't trigger
+    let _: Choice = match se {
+        Choice::A => Choice::B,
+        Choice::B => Choice::C,
+        Choice::C => Choice::D,
+        Choice::D => Choice::A,
+    };
+}
+
+fn option_match(x: Option<i32>) {
+    let _: Option<i32> = x;
+    // Don't trigger, this is the case for manual_map_option
+    let _: Option<i32> = match x {
+        Some(a) => Some(-a),
+        None => None,
+    };
+}
+
+fn func_ret_err<T>(err: T) -> Result<i32, T> {
+    Err(err)
+}
+
+fn result_match() {
+    let _: Result<i32, i32> = Ok(1);
+    let _: Result<i32, i32> = func_ret_err(0_i32);
+}
+
+fn if_let_option() -> Option<i32> {
+    Some(1)
+}
+
+fn if_let_result(x: Result<(), i32>) {
+    let _: Result<(), i32> = x;
+    let _: Result<(), i32> = x;
+    // Input type mismatch, don't trigger
+    let _: Result<(), i32> = if let Err(e) = Ok(1) { Err(e) } else { x };
+}
+
+fn if_let_custom_enum(x: Choice) {
+    let _: Choice = x;
+    // Don't trigger
+    let _: Choice = if let Choice::A = x {
+        Choice::A
+    } else if true {
+        Choice::B
+    } else {
+        x
+    };
+}
+
+fn main() {}
diff --git a/tests/ui/needless_match.rs b/tests/ui/needless_match.rs
new file mode 100644
index 00000000000..43f1391d67c
--- /dev/null
+++ b/tests/ui/needless_match.rs
@@ -0,0 +1,103 @@
+// run-rustfix
+#![warn(clippy::needless_match)]
+#![allow(clippy::manual_map)]
+#![allow(dead_code)]
+
+#[derive(Clone, Copy)]
+enum Choice {
+    A,
+    B,
+    C,
+    D,
+}
+
+fn useless_match(x: i32) {
+    let _: i32 = match x {
+        0 => 0,
+        1 => 1,
+        2 => 2,
+        _ => x,
+    };
+}
+
+fn custom_type_match(se: Choice) {
+    let _: Choice = match se {
+        Choice::A => Choice::A,
+        Choice::B => Choice::B,
+        Choice::C => Choice::C,
+        Choice::D => Choice::D,
+    };
+    // Don't trigger
+    let _: Choice = match se {
+        Choice::A => Choice::A,
+        Choice::B => Choice::B,
+        _ => Choice::C,
+    };
+    // Mingled, don't trigger
+    let _: Choice = match se {
+        Choice::A => Choice::B,
+        Choice::B => Choice::C,
+        Choice::C => Choice::D,
+        Choice::D => Choice::A,
+    };
+}
+
+fn option_match(x: Option<i32>) {
+    let _: Option<i32> = match x {
+        Some(a) => Some(a),
+        None => None,
+    };
+    // Don't trigger, this is the case for manual_map_option
+    let _: Option<i32> = match x {
+        Some(a) => Some(-a),
+        None => None,
+    };
+}
+
+fn func_ret_err<T>(err: T) -> Result<i32, T> {
+    Err(err)
+}
+
+fn result_match() {
+    let _: Result<i32, i32> = match Ok(1) {
+        Ok(a) => Ok(a),
+        Err(err) => Err(err),
+    };
+    let _: Result<i32, i32> = match func_ret_err(0_i32) {
+        Err(err) => Err(err),
+        Ok(a) => Ok(a),
+    };
+}
+
+fn if_let_option() -> Option<i32> {
+    if let Some(a) = Some(1) { Some(a) } else { None }
+}
+
+fn if_let_result(x: Result<(), i32>) {
+    let _: Result<(), i32> = if let Err(e) = x { Err(e) } else { x };
+    let _: Result<(), i32> = if let Ok(val) = x { Ok(val) } else { x };
+    // Input type mismatch, don't trigger
+    let _: Result<(), i32> = if let Err(e) = Ok(1) { Err(e) } else { x };
+}
+
+fn if_let_custom_enum(x: Choice) {
+    let _: Choice = if let Choice::A = x {
+        Choice::A
+    } else if let Choice::B = x {
+        Choice::B
+    } else if let Choice::C = x {
+        Choice::C
+    } else {
+        x
+    };
+    // Don't trigger
+    let _: Choice = if let Choice::A = x {
+        Choice::A
+    } else if true {
+        Choice::B
+    } else {
+        x
+    };
+}
+
+fn main() {}
diff --git a/tests/ui/needless_match.stderr b/tests/ui/needless_match.stderr
new file mode 100644
index 00000000000..d11d4fd3322
--- /dev/null
+++ b/tests/ui/needless_match.stderr
@@ -0,0 +1,89 @@
+error: this match expression is unnecessary
+  --> $DIR/needless_match.rs:15:18
+   |
+LL |       let _: i32 = match x {
+   |  __________________^
+LL | |         0 => 0,
+LL | |         1 => 1,
+LL | |         2 => 2,
+LL | |         _ => x,
+LL | |     };
+   | |_____^ help: replace it with: `x`
+   |
+   = note: `-D clippy::needless-match` implied by `-D warnings`
+
+error: this match expression is unnecessary
+  --> $DIR/needless_match.rs:24:21
+   |
+LL |       let _: Choice = match se {
+   |  _____________________^
+LL | |         Choice::A => Choice::A,
+LL | |         Choice::B => Choice::B,
+LL | |         Choice::C => Choice::C,
+LL | |         Choice::D => Choice::D,
+LL | |     };
+   | |_____^ help: replace it with: `se`
+
+error: this match expression is unnecessary
+  --> $DIR/needless_match.rs:46:26
+   |
+LL |       let _: Option<i32> = match x {
+   |  __________________________^
+LL | |         Some(a) => Some(a),
+LL | |         None => None,
+LL | |     };
+   | |_____^ help: replace it with: `x`
+
+error: this match expression is unnecessary
+  --> $DIR/needless_match.rs:62:31
+   |
+LL |       let _: Result<i32, i32> = match Ok(1) {
+   |  _______________________________^
+LL | |         Ok(a) => Ok(a),
+LL | |         Err(err) => Err(err),
+LL | |     };
+   | |_____^ help: replace it with: `Ok(1)`
+
+error: this match expression is unnecessary
+  --> $DIR/needless_match.rs:66:31
+   |
+LL |       let _: Result<i32, i32> = match func_ret_err(0_i32) {
+   |  _______________________________^
+LL | |         Err(err) => Err(err),
+LL | |         Ok(a) => Ok(a),
+LL | |     };
+   | |_____^ help: replace it with: `func_ret_err(0_i32)`
+
+error: this if-let expression is unnecessary
+  --> $DIR/needless_match.rs:73:5
+   |
+LL |     if let Some(a) = Some(1) { Some(a) } else { None }
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `Some(1)`
+
+error: this if-let expression is unnecessary
+  --> $DIR/needless_match.rs:77:30
+   |
+LL |     let _: Result<(), i32> = if let Err(e) = x { Err(e) } else { x };
+   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `x`
+
+error: this if-let expression is unnecessary
+  --> $DIR/needless_match.rs:78:30
+   |
+LL |     let _: Result<(), i32> = if let Ok(val) = x { Ok(val) } else { x };
+   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `x`
+
+error: this if-let expression is unnecessary
+  --> $DIR/needless_match.rs:84:21
+   |
+LL |       let _: Choice = if let Choice::A = x {
+   |  _____________________^
+LL | |         Choice::A
+LL | |     } else if let Choice::B = x {
+LL | |         Choice::B
+...  |
+LL | |         x
+LL | |     };
+   | |_____^ help: replace it with: `x`
+
+error: aborting due to 9 previous errors
+
diff --git a/tests/ui/nop_match.fixed b/tests/ui/nop_match.fixed
deleted file mode 100644
index 8875323a1bb..00000000000
--- a/tests/ui/nop_match.fixed
+++ /dev/null
@@ -1,76 +0,0 @@
-// run-rustfix
-#![warn(clippy::nop_match)]
-#![allow(clippy::manual_map)]
-#![allow(dead_code)]
-
-#[derive(Clone, Copy)]
-enum Choice {
-    A,
-    B,
-    C,
-    D,
-}
-
-fn useless_match(x: i32) {
-    let _: i32 = x;
-}
-
-fn custom_type_match(se: Choice) {
-    let _: Choice = se;
-    // Don't trigger
-    let _: Choice = match se {
-        Choice::A => Choice::A,
-        Choice::B => Choice::B,
-        _ => Choice::C,
-    };
-    // Mingled, don't trigger
-    let _: Choice = match se {
-        Choice::A => Choice::B,
-        Choice::B => Choice::C,
-        Choice::C => Choice::D,
-        Choice::D => Choice::A,
-    };
-}
-
-fn option_match(x: Option<i32>) {
-    let _: Option<i32> = x;
-    // Don't trigger, this is the case for manual_map_option
-    let _: Option<i32> = match x {
-        Some(a) => Some(-a),
-        None => None,
-    };
-}
-
-fn func_ret_err<T>(err: T) -> Result<i32, T> {
-    Err(err)
-}
-
-fn result_match() {
-    let _: Result<i32, i32> = Ok(1);
-    let _: Result<i32, i32> = func_ret_err(0_i32);
-}
-
-fn if_let_option() -> Option<i32> {
-    Some(1)
-}
-
-fn if_let_result(x: Result<(), i32>) {
-    let _: Result<(), i32> = x;
-    let _: Result<(), i32> = x;
-    // Input type mismatch, don't trigger
-    let _: Result<(), i32> = if let Err(e) = Ok(1) { Err(e) } else { x };
-}
-
-fn if_let_custom_enum(x: Choice) {
-    let _: Choice = x;
-    // Don't trigger
-    let _: Choice = if let Choice::A = x {
-        Choice::A
-    } else if true {
-        Choice::B
-    } else {
-        x
-    };
-}
-
-fn main() {}
diff --git a/tests/ui/nop_match.rs b/tests/ui/nop_match.rs
deleted file mode 100644
index 19469a86022..00000000000
--- a/tests/ui/nop_match.rs
+++ /dev/null
@@ -1,103 +0,0 @@
-// run-rustfix
-#![warn(clippy::nop_match)]
-#![allow(clippy::manual_map)]
-#![allow(dead_code)]
-
-#[derive(Clone, Copy)]
-enum Choice {
-    A,
-    B,
-    C,
-    D,
-}
-
-fn useless_match(x: i32) {
-    let _: i32 = match x {
-        0 => 0,
-        1 => 1,
-        2 => 2,
-        _ => x,
-    };
-}
-
-fn custom_type_match(se: Choice) {
-    let _: Choice = match se {
-        Choice::A => Choice::A,
-        Choice::B => Choice::B,
-        Choice::C => Choice::C,
-        Choice::D => Choice::D,
-    };
-    // Don't trigger
-    let _: Choice = match se {
-        Choice::A => Choice::A,
-        Choice::B => Choice::B,
-        _ => Choice::C,
-    };
-    // Mingled, don't trigger
-    let _: Choice = match se {
-        Choice::A => Choice::B,
-        Choice::B => Choice::C,
-        Choice::C => Choice::D,
-        Choice::D => Choice::A,
-    };
-}
-
-fn option_match(x: Option<i32>) {
-    let _: Option<i32> = match x {
-        Some(a) => Some(a),
-        None => None,
-    };
-    // Don't trigger, this is the case for manual_map_option
-    let _: Option<i32> = match x {
-        Some(a) => Some(-a),
-        None => None,
-    };
-}
-
-fn func_ret_err<T>(err: T) -> Result<i32, T> {
-    Err(err)
-}
-
-fn result_match() {
-    let _: Result<i32, i32> = match Ok(1) {
-        Ok(a) => Ok(a),
-        Err(err) => Err(err),
-    };
-    let _: Result<i32, i32> = match func_ret_err(0_i32) {
-        Err(err) => Err(err),
-        Ok(a) => Ok(a),
-    };
-}
-
-fn if_let_option() -> Option<i32> {
-    if let Some(a) = Some(1) { Some(a) } else { None }
-}
-
-fn if_let_result(x: Result<(), i32>) {
-    let _: Result<(), i32> = if let Err(e) = x { Err(e) } else { x };
-    let _: Result<(), i32> = if let Ok(val) = x { Ok(val) } else { x };
-    // Input type mismatch, don't trigger
-    let _: Result<(), i32> = if let Err(e) = Ok(1) { Err(e) } else { x };
-}
-
-fn if_let_custom_enum(x: Choice) {
-    let _: Choice = if let Choice::A = x {
-        Choice::A
-    } else if let Choice::B = x {
-        Choice::B
-    } else if let Choice::C = x {
-        Choice::C
-    } else {
-        x
-    };
-    // Don't trigger
-    let _: Choice = if let Choice::A = x {
-        Choice::A
-    } else if true {
-        Choice::B
-    } else {
-        x
-    };
-}
-
-fn main() {}
diff --git a/tests/ui/nop_match.stderr b/tests/ui/nop_match.stderr
deleted file mode 100644
index b7a1967bf5f..00000000000
--- a/tests/ui/nop_match.stderr
+++ /dev/null
@@ -1,89 +0,0 @@
-error: this match expression is unnecessary
-  --> $DIR/nop_match.rs:15:18
-   |
-LL |       let _: i32 = match x {
-   |  __________________^
-LL | |         0 => 0,
-LL | |         1 => 1,
-LL | |         2 => 2,
-LL | |         _ => x,
-LL | |     };
-   | |_____^ help: replace it with: `x`
-   |
-   = note: `-D clippy::nop-match` implied by `-D warnings`
-
-error: this match expression is unnecessary
-  --> $DIR/nop_match.rs:24:21
-   |
-LL |       let _: Choice = match se {
-   |  _____________________^
-LL | |         Choice::A => Choice::A,
-LL | |         Choice::B => Choice::B,
-LL | |         Choice::C => Choice::C,
-LL | |         Choice::D => Choice::D,
-LL | |     };
-   | |_____^ help: replace it with: `se`
-
-error: this match expression is unnecessary
-  --> $DIR/nop_match.rs:46:26
-   |
-LL |       let _: Option<i32> = match x {
-   |  __________________________^
-LL | |         Some(a) => Some(a),
-LL | |         None => None,
-LL | |     };
-   | |_____^ help: replace it with: `x`
-
-error: this match expression is unnecessary
-  --> $DIR/nop_match.rs:62:31
-   |
-LL |       let _: Result<i32, i32> = match Ok(1) {
-   |  _______________________________^
-LL | |         Ok(a) => Ok(a),
-LL | |         Err(err) => Err(err),
-LL | |     };
-   | |_____^ help: replace it with: `Ok(1)`
-
-error: this match expression is unnecessary
-  --> $DIR/nop_match.rs:66:31
-   |
-LL |       let _: Result<i32, i32> = match func_ret_err(0_i32) {
-   |  _______________________________^
-LL | |         Err(err) => Err(err),
-LL | |         Ok(a) => Ok(a),
-LL | |     };
-   | |_____^ help: replace it with: `func_ret_err(0_i32)`
-
-error: this if-let expression is unnecessary
-  --> $DIR/nop_match.rs:73:5
-   |
-LL |     if let Some(a) = Some(1) { Some(a) } else { None }
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `Some(1)`
-
-error: this if-let expression is unnecessary
-  --> $DIR/nop_match.rs:77:30
-   |
-LL |     let _: Result<(), i32> = if let Err(e) = x { Err(e) } else { x };
-   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `x`
-
-error: this if-let expression is unnecessary
-  --> $DIR/nop_match.rs:78:30
-   |
-LL |     let _: Result<(), i32> = if let Ok(val) = x { Ok(val) } else { x };
-   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `x`
-
-error: this if-let expression is unnecessary
-  --> $DIR/nop_match.rs:84:21
-   |
-LL |       let _: Choice = if let Choice::A = x {
-   |  _____________________^
-LL | |         Choice::A
-LL | |     } else if let Choice::B = x {
-LL | |         Choice::B
-...  |
-LL | |         x
-LL | |     };
-   | |_____^ help: replace it with: `x`
-
-error: aborting due to 9 previous errors
-
-- 
cgit 1.4.1-3-g733a5


From 69161c6327aaa77dbc2d3cef34b06148d6715ec4 Mon Sep 17 00:00:00 2001
From: Jaeyong Sung <jaeyong0201@gmail.com>
Date: Thu, 10 Mar 2022 15:46:40 +0900
Subject: fix to lint Self::function

---
 clippy_lints/src/only_used_in_recursion.rs | 96 ++++++++++++++++++------------
 tests/ui/only_used_in_recursion.rs         | 15 +++++
 tests/ui/only_used_in_recursion.stderr     |  8 ++-
 3 files changed, 80 insertions(+), 39 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/only_used_in_recursion.rs b/clippy_lints/src/only_used_in_recursion.rs
index 0d7e52e1d62..7ec110295dc 100644
--- a/clippy_lints/src/only_used_in_recursion.rs
+++ b/clippy_lints/src/only_used_in_recursion.rs
@@ -5,12 +5,13 @@ use itertools::{izip, Itertools};
 use rustc_ast::{walk_list, Label, Mutability};
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_errors::Applicability;
-use rustc_hir::def::Res;
+use rustc_hir::def::{DefKind, Res};
+use rustc_hir::def_id::DefId;
 use rustc_hir::definitions::{DefPathData, DisambiguatedDefPathData};
 use rustc_hir::intravisit::{walk_expr, FnKind, Visitor};
 use rustc_hir::{
-    Arm, Block, Body, Expr, ExprKind, Guard, HirId, Let, Local, Pat, PatKind, Path, PathSegment, QPath, Stmt, StmtKind,
-    UnOp,
+    Arm, Block, Body, Expr, ExprKind, Guard, HirId, ImplicitSelfKind, Let, Local, Pat, PatKind, Path, PathSegment,
+    QPath, Stmt, StmtKind, TyKind, UnOp,
 };
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
@@ -94,13 +95,15 @@ impl<'tcx> LateLintPass<'tcx> for OnlyUsedInRecursion {
         &mut self,
         cx: &LateContext<'tcx>,
         kind: FnKind<'tcx>,
-        _: &'tcx rustc_hir::FnDecl<'tcx>,
+        decl: &'tcx rustc_hir::FnDecl<'tcx>,
         body: &'tcx Body<'tcx>,
         _: Span,
         id: HirId,
     ) {
         if let FnKind::ItemFn(ident, ..) | FnKind::Method(ident, ..) = kind {
-            let data = cx.tcx.def_path(cx.tcx.hir().local_def_id(id).to_def_id()).data;
+            let def_id = id.owner.to_def_id();
+            let data = cx.tcx.def_path(def_id).data;
+
             if data.len() > 1 {
                 match data.get(data.len() - 2) {
                     Some(DisambiguatedDefPathData {
@@ -111,6 +114,8 @@ impl<'tcx> LateLintPass<'tcx> for OnlyUsedInRecursion {
                 }
             }
 
+            let has_self = !matches!(decl.implicit_self, ImplicitSelfKind::None);
+
             let ty_res = cx.typeck_results();
             let param_span = body
                 .params
@@ -122,10 +127,7 @@ impl<'tcx> LateLintPass<'tcx> for OnlyUsedInRecursion {
                     });
                     v
                 })
-                .skip(match kind {
-                    FnKind::Method(..) => 1,
-                    _ => 0,
-                })
+                .skip(if has_self { 1 } else { 0 })
                 .filter(|(_, _, ident)| !ident.name.as_str().starts_with('_'))
                 .collect_vec();
 
@@ -139,7 +141,9 @@ impl<'tcx> LateLintPass<'tcx> for OnlyUsedInRecursion {
                 break_vars: FxHashMap::default(),
                 params,
                 fn_ident: ident,
+                fn_def_id: def_id,
                 is_method: matches!(kind, FnKind::Method(..)),
+                has_self,
                 ty_res,
                 ty_ctx: cx.tcx,
             };
@@ -242,7 +246,9 @@ pub struct SideEffectVisit<'tcx> {
     break_vars: FxHashMap<Ident, Vec<(HirId, bool)>>,
     params: Vec<&'tcx Pat<'tcx>>,
     fn_ident: Ident,
+    fn_def_id: DefId,
     is_method: bool,
+    has_self: bool,
     ty_res: &'tcx TypeckResults<'tcx>,
     ty_ctx: TyCtxt<'tcx>,
 }
@@ -479,41 +485,55 @@ impl<'tcx> SideEffectVisit<'tcx> {
         let mut ret_vars = std::mem::take(&mut self.ret_vars);
         self.add_side_effect(ret_vars.clone());
 
+        let mut is_recursive = false;
+
         if_chain! {
-            if !self.is_method;
+            if !self.has_self;
             if let ExprKind::Path(QPath::Resolved(_, path)) = callee.kind;
-            if let Res::Def(..) = path.res;
-            if path.segments.len() == 1;
-            let ident = path.segments.last().unwrap().ident;
-            if ident == self.fn_ident;
+            if let Res::Def(DefKind::Fn, def_id) = path.res;
+            if self.fn_def_id == def_id;
             then {
-                izip!(self.params.clone(), args)
-                    .for_each(|(pat, expr)| {
-                        self.visit_pat_expr(pat, expr, true);
-                        self.ret_vars.clear();
-                    });
-            } else {
-                // This would set arguments used in closure that does not have side-effect.
-                // Closure itself can be detected whether there is a side-effect, but the
-                // value of variable that is holding closure can change.
-                // So, we just check the variables.
-                self.ret_vars = args
-                    .iter()
-                    .flat_map(|expr| {
-                        self.visit_expr(expr);
-                        std::mem::take(&mut self.ret_vars)
-                    })
-                    .collect_vec()
-                    .into_iter()
-                    .map(|id| {
-                        self.has_side_effect.insert(id.0);
-                        id
-                    })
-                    .collect();
-                self.contains_side_effect = true;
+                is_recursive = true;
+            }
+        }
+
+        if_chain! {
+            if !self.has_self && self.is_method;
+            if let ExprKind::Path(QPath::TypeRelative(ty, segment)) = callee.kind;
+            if segment.ident == self.fn_ident;
+            if let TyKind::Path(QPath::Resolved(_, path)) = ty.kind;
+            if let Res::SelfTy(..) = path.res;
+            then {
+                is_recursive = true;
             }
         }
 
+        if is_recursive {
+            izip!(self.params.clone(), args).for_each(|(pat, expr)| {
+                self.visit_pat_expr(pat, expr, true);
+                self.ret_vars.clear();
+            });
+        } else {
+            // This would set arguments used in closure that does not have side-effect.
+            // Closure itself can be detected whether there is a side-effect, but the
+            // value of variable that is holding closure can change.
+            // So, we just check the variables.
+            self.ret_vars = args
+                .iter()
+                .flat_map(|expr| {
+                    self.visit_expr(expr);
+                    std::mem::take(&mut self.ret_vars)
+                })
+                .collect_vec()
+                .into_iter()
+                .map(|id| {
+                    self.has_side_effect.insert(id.0);
+                    id
+                })
+                .collect();
+            self.contains_side_effect = true;
+        }
+
         self.ret_vars.append(&mut ret_vars);
     }
 
diff --git a/tests/ui/only_used_in_recursion.rs b/tests/ui/only_used_in_recursion.rs
index 0f49fc071bf..5768434f988 100644
--- a/tests/ui/only_used_in_recursion.rs
+++ b/tests/ui/only_used_in_recursion.rs
@@ -104,4 +104,19 @@ fn ignore2(a: usize, _b: usize) -> usize {
     if a == 1 { 1 } else { ignore2(a - 1, _b) }
 }
 
+fn f1(a: u32) -> u32 {
+    a
+}
+
+fn f2(a: u32) -> u32 {
+    f1(a)
+}
+
+fn inner_fn(a: u32) -> u32 {
+    fn inner_fn(a: u32) -> u32 {
+        a
+    }
+    inner_fn(a)
+}
+
 fn main() {}
diff --git a/tests/ui/only_used_in_recursion.stderr b/tests/ui/only_used_in_recursion.stderr
index c24a357cd20..6fe9361bf5f 100644
--- a/tests/ui/only_used_in_recursion.stderr
+++ b/tests/ui/only_used_in_recursion.stderr
@@ -66,11 +66,17 @@ error: parameter is only used in recursion
 LL |     fn method2(&self, a: usize, b: usize) -> usize {
    |                                 ^ help: if this is intentional, prefix with an underscore: `_b`
 
+error: parameter is only used in recursion
+  --> $DIR/only_used_in_recursion.rs:90:24
+   |
+LL |     fn hello(a: usize, b: usize) -> usize {
+   |                        ^ help: if this is intentional, prefix with an underscore: `_b`
+
 error: parameter is only used in recursion
   --> $DIR/only_used_in_recursion.rs:94:32
    |
 LL |     fn hello2(&self, a: usize, b: usize) -> usize {
    |                                ^ help: if this is intentional, prefix with an underscore: `_b`
 
-error: aborting due to 12 previous errors
+error: aborting due to 13 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 086b045822b008c5b4e6eb34bac10bfa8d5a7ea1 Mon Sep 17 00:00:00 2001
From: J-ZhengLi <lizheng135@huawei.com>
Date: Thu, 10 Mar 2022 14:46:58 +0800
Subject: add checking for `x -> x` and `ref x -> x` and related test cases.

---
 clippy_lints/src/matches/needless_match.rs | 29 ++++++++++++++-
 tests/ui/needless_match.fixed              | 11 +++++-
 tests/ui/needless_match.rs                 | 25 +++++++++++--
 tests/ui/needless_match.stderr             | 59 +++++++++++++++++++++++-------
 4 files changed, 105 insertions(+), 19 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/needless_match.rs b/clippy_lints/src/matches/needless_match.rs
index 8d209c6289c..76131d307d7 100644
--- a/clippy_lints/src/matches/needless_match.rs
+++ b/clippy_lints/src/matches/needless_match.rs
@@ -5,7 +5,7 @@ use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::{eq_expr_value, get_parent_expr, higher, is_else_clause, is_lang_ctor, peel_blocks_with_stmt};
 use rustc_errors::Applicability;
 use rustc_hir::LangItem::OptionNone;
-use rustc_hir::{Arm, BindingAnnotation, Expr, ExprKind, Pat, PatKind, Path, PathSegment, QPath};
+use rustc_hir::{Arm, BindingAnnotation, Expr, ExprKind, Pat, PatKind, Path, PathSegment, QPath, UnOp};
 use rustc_lint::LateContext;
 use rustc_span::sym;
 
@@ -107,6 +107,7 @@ fn check_if_let(cx: &LateContext<'_>, if_let: &higher::IfLet<'_>) -> bool {
     false
 }
 
+/// Strip `return` keyword if the expression type is `ExprKind::Ret`.
 fn strip_return<'hir>(expr: &'hir Expr<'hir>) -> &'hir Expr<'hir> {
     if let ExprKind::Ret(Some(ret)) = expr.kind {
         ret
@@ -118,6 +119,7 @@ fn strip_return<'hir>(expr: &'hir Expr<'hir>) -> &'hir Expr<'hir> {
 fn pat_same_as_expr(pat: &Pat<'_>, expr: &Expr<'_>) -> bool {
     let expr = strip_return(expr);
     match (&pat.kind, &expr.kind) {
+        // Example: `Some(val) => Some(val)`
         (
             PatKind::TupleStruct(QPath::Resolved(_, path), [first_pat, ..], _),
             ExprKind::Call(call_expr, [first_param, ..]),
@@ -130,9 +132,34 @@ fn pat_same_as_expr(pat: &Pat<'_>, expr: &Expr<'_>) -> bool {
                 }
             }
         },
+        // Example: `val => val`, or `ref val => *val`
+        (PatKind::Binding(annot, _, pat_ident, _), _) => {
+            let new_expr = if let (
+                BindingAnnotation::Ref | BindingAnnotation::RefMut,
+                ExprKind::Unary(UnOp::Deref, operand_expr),
+            ) = (annot, &expr.kind)
+            {
+                operand_expr
+            } else {
+                expr
+            };
+
+            if let ExprKind::Path(QPath::Resolved(
+                _,
+                Path {
+                    segments: [first_seg, ..],
+                    ..
+                },
+            )) = new_expr.kind
+            {
+                return pat_ident.name == first_seg.ident.name;
+            }
+        },
+        // Example: `Custom::TypeA => Custom::TypeB`, or `None => None`
         (PatKind::Path(QPath::Resolved(_, p_path)), ExprKind::Path(QPath::Resolved(_, e_path))) => {
             return has_identical_segments(p_path.segments, e_path.segments);
         },
+        // Example: `5 => 5`
         (PatKind::Lit(pat_lit_expr), ExprKind::Lit(expr_spanned)) => {
             if let ExprKind::Lit(pat_spanned) = &pat_lit_expr.kind {
                 return pat_spanned.node == expr_spanned.node;
diff --git a/tests/ui/needless_match.fixed b/tests/ui/needless_match.fixed
index eb6494a4da6..ece18ad737f 100644
--- a/tests/ui/needless_match.fixed
+++ b/tests/ui/needless_match.fixed
@@ -11,8 +11,15 @@ enum Choice {
     D,
 }
 
-fn useless_match(x: i32) {
-    let _: i32 = x;
+#[allow(unused_mut)]
+fn useless_match() {
+    let mut i = 10;
+    let _: i32 = i;
+    let _: i32 = i;
+    let mut _i_mut = i;
+
+    let s = "test";
+    let _: &str = s;
 }
 
 fn custom_type_match(se: Choice) {
diff --git a/tests/ui/needless_match.rs b/tests/ui/needless_match.rs
index 43f1391d67c..36649de35a6 100644
--- a/tests/ui/needless_match.rs
+++ b/tests/ui/needless_match.rs
@@ -11,12 +11,31 @@ enum Choice {
     D,
 }
 
-fn useless_match(x: i32) {
-    let _: i32 = match x {
+#[allow(unused_mut)]
+fn useless_match() {
+    let mut i = 10;
+    let _: i32 = match i {
         0 => 0,
         1 => 1,
         2 => 2,
-        _ => x,
+        _ => i,
+    };
+    let _: i32 = match i {
+        0 => 0,
+        1 => 1,
+        ref i => *i,
+    };
+    let mut _i_mut = match i {
+        0 => 0,
+        1 => 1,
+        ref mut i => *i,
+    };
+
+    let s = "test";
+    let _: &str = match s {
+        "a" => "a",
+        "b" => "b",
+        s => s,
     };
 }
 
diff --git a/tests/ui/needless_match.stderr b/tests/ui/needless_match.stderr
index d11d4fd3322..ad1525406ad 100644
--- a/tests/ui/needless_match.stderr
+++ b/tests/ui/needless_match.stderr
@@ -1,19 +1,52 @@
 error: this match expression is unnecessary
-  --> $DIR/needless_match.rs:15:18
+  --> $DIR/needless_match.rs:17:18
    |
-LL |       let _: i32 = match x {
+LL |       let _: i32 = match i {
    |  __________________^
 LL | |         0 => 0,
 LL | |         1 => 1,
 LL | |         2 => 2,
-LL | |         _ => x,
+LL | |         _ => i,
 LL | |     };
-   | |_____^ help: replace it with: `x`
+   | |_____^ help: replace it with: `i`
    |
    = note: `-D clippy::needless-match` implied by `-D warnings`
 
 error: this match expression is unnecessary
-  --> $DIR/needless_match.rs:24:21
+  --> $DIR/needless_match.rs:23:18
+   |
+LL |       let _: i32 = match i {
+   |  __________________^
+LL | |         0 => 0,
+LL | |         1 => 1,
+LL | |         ref i => *i,
+LL | |     };
+   | |_____^ help: replace it with: `i`
+
+error: this match expression is unnecessary
+  --> $DIR/needless_match.rs:28:22
+   |
+LL |       let mut _i_mut = match i {
+   |  ______________________^
+LL | |         0 => 0,
+LL | |         1 => 1,
+LL | |         ref mut i => *i,
+LL | |     };
+   | |_____^ help: replace it with: `i`
+
+error: this match expression is unnecessary
+  --> $DIR/needless_match.rs:35:19
+   |
+LL |       let _: &str = match s {
+   |  ___________________^
+LL | |         "a" => "a",
+LL | |         "b" => "b",
+LL | |         s => s,
+LL | |     };
+   | |_____^ help: replace it with: `s`
+
+error: this match expression is unnecessary
+  --> $DIR/needless_match.rs:43:21
    |
 LL |       let _: Choice = match se {
    |  _____________________^
@@ -25,7 +58,7 @@ LL | |     };
    | |_____^ help: replace it with: `se`
 
 error: this match expression is unnecessary
-  --> $DIR/needless_match.rs:46:26
+  --> $DIR/needless_match.rs:65:26
    |
 LL |       let _: Option<i32> = match x {
    |  __________________________^
@@ -35,7 +68,7 @@ LL | |     };
    | |_____^ help: replace it with: `x`
 
 error: this match expression is unnecessary
-  --> $DIR/needless_match.rs:62:31
+  --> $DIR/needless_match.rs:81:31
    |
 LL |       let _: Result<i32, i32> = match Ok(1) {
    |  _______________________________^
@@ -45,7 +78,7 @@ LL | |     };
    | |_____^ help: replace it with: `Ok(1)`
 
 error: this match expression is unnecessary
-  --> $DIR/needless_match.rs:66:31
+  --> $DIR/needless_match.rs:85:31
    |
 LL |       let _: Result<i32, i32> = match func_ret_err(0_i32) {
    |  _______________________________^
@@ -55,25 +88,25 @@ LL | |     };
    | |_____^ help: replace it with: `func_ret_err(0_i32)`
 
 error: this if-let expression is unnecessary
-  --> $DIR/needless_match.rs:73:5
+  --> $DIR/needless_match.rs:92:5
    |
 LL |     if let Some(a) = Some(1) { Some(a) } else { None }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `Some(1)`
 
 error: this if-let expression is unnecessary
-  --> $DIR/needless_match.rs:77:30
+  --> $DIR/needless_match.rs:96:30
    |
 LL |     let _: Result<(), i32> = if let Err(e) = x { Err(e) } else { x };
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `x`
 
 error: this if-let expression is unnecessary
-  --> $DIR/needless_match.rs:78:30
+  --> $DIR/needless_match.rs:97:30
    |
 LL |     let _: Result<(), i32> = if let Ok(val) = x { Ok(val) } else { x };
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `x`
 
 error: this if-let expression is unnecessary
-  --> $DIR/needless_match.rs:84:21
+  --> $DIR/needless_match.rs:103:21
    |
 LL |       let _: Choice = if let Choice::A = x {
    |  _____________________^
@@ -85,5 +118,5 @@ LL | |         x
 LL | |     };
    | |_____^ help: replace it with: `x`
 
-error: aborting due to 9 previous errors
+error: aborting due to 12 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 52d35dca6a91908c963c207cc93f2cf0f800dcea Mon Sep 17 00:00:00 2001
From: Jaeyong Sung <jaeyong0201@gmail.com>
Date: Thu, 10 Mar 2022 15:53:53 +0900
Subject: fix build error

---
 clippy_lints/src/only_used_in_recursion.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/only_used_in_recursion.rs b/clippy_lints/src/only_used_in_recursion.rs
index 7ec110295dc..2e5e990be44 100644
--- a/clippy_lints/src/only_used_in_recursion.rs
+++ b/clippy_lints/src/only_used_in_recursion.rs
@@ -502,7 +502,7 @@ impl<'tcx> SideEffectVisit<'tcx> {
             if let ExprKind::Path(QPath::TypeRelative(ty, segment)) = callee.kind;
             if segment.ident == self.fn_ident;
             if let TyKind::Path(QPath::Resolved(_, path)) = ty.kind;
-            if let Res::SelfTy(..) = path.res;
+            if let Res::SelfTy{ .. } = path.res;
             then {
                 is_recursive = true;
             }
-- 
cgit 1.4.1-3-g733a5


From 1ad7e7097ae9274d74b16899e25c65d125159bd4 Mon Sep 17 00:00:00 2001
From: Jaeyong Sung <jaeyong0201@gmail.com>
Date: Thu, 10 Mar 2022 16:06:35 +0900
Subject: remove parameters that are only used in recursion

---
 clippy_lints/src/question_mark.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/question_mark.rs b/clippy_lints/src/question_mark.rs
index 6f634ded5fe..899568a933f 100644
--- a/clippy_lints/src/question_mark.rs
+++ b/clippy_lints/src/question_mark.rs
@@ -123,7 +123,7 @@ impl QuestionMark {
     }
 
     fn result_check_and_early_return(cx: &LateContext<'_>, expr: &Expr<'_>, nested_expr: &Expr<'_>) -> bool {
-        Self::is_result(cx, expr) && Self::expression_returns_unmodified_err(cx, nested_expr, expr)
+        Self::is_result(cx, expr) && Self::expression_returns_unmodified_err(nested_expr, expr)
     }
 
     fn option_check_and_early_return(cx: &LateContext<'_>, expr: &Expr<'_>, nested_expr: &Expr<'_>) -> bool {
@@ -156,9 +156,9 @@ impl QuestionMark {
         }
     }
 
-    fn expression_returns_unmodified_err(cx: &LateContext<'_>, expr: &Expr<'_>, cond_expr: &Expr<'_>) -> bool {
+    fn expression_returns_unmodified_err(expr: &Expr<'_>, cond_expr: &Expr<'_>) -> bool {
         match peel_blocks_with_stmt(expr).kind {
-            ExprKind::Ret(Some(ret_expr)) => Self::expression_returns_unmodified_err(cx, ret_expr, cond_expr),
+            ExprKind::Ret(Some(ret_expr)) => Self::expression_returns_unmodified_err(ret_expr, cond_expr),
             ExprKind::Path(_) => path_to_local(expr).is_some() && path_to_local(expr) == path_to_local(cond_expr),
             _ => false,
         }
-- 
cgit 1.4.1-3-g733a5


From a944ccb67745106a434b9708d010a156acda4d21 Mon Sep 17 00:00:00 2001
From: Tianyi Song <42670338+tysg@users.noreply.github.com>
Date: Fri, 11 Mar 2022 11:31:17 +0800
Subject: Check if lhs < rhs in modulos and emit

---
 clippy_lints/src/identity_op.rs                  | 37 +++++++++++++++++-------
 tests/ui/identity_op.rs                          |  6 ++++
 tests/ui/identity_op.stderr                      | 20 ++++++++++++-
 tests/ui/modulo_arithmetic_integral_const.rs     |  7 ++++-
 tests/ui/modulo_arithmetic_integral_const.stderr | 34 +++++++++++-----------
 5 files changed, 75 insertions(+), 29 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/identity_op.rs b/clippy_lints/src/identity_op.rs
index f824f20ca40..0b1ab4dfa5a 100644
--- a/clippy_lints/src/identity_op.rs
+++ b/clippy_lints/src/identity_op.rs
@@ -5,7 +5,7 @@ use rustc_middle::ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
 
-use clippy_utils::consts::{constant_simple, Constant};
+use clippy_utils::consts::{constant_full_int, constant_simple, Constant, FullInt};
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::{clip, unsext};
 
@@ -54,6 +54,7 @@ impl<'tcx> LateLintPass<'tcx> for IdentityOp {
                     check(cx, left, -1, e.span, right.span);
                     check(cx, right, -1, e.span, left.span);
                 },
+                BinOpKind::Rem => check_modulo(cx, left, right, e.span, left.span),
                 _ => (),
             }
         }
@@ -70,6 +71,18 @@ fn is_allowed(cx: &LateContext<'_>, cmp: BinOp, left: &Expr<'_>, right: &Expr<'_
             && constant_simple(cx, cx.typeck_results(), left) == Some(Constant::Int(1)))
 }
 
+fn check_modulo(cx: &LateContext<'_>, left: &Expr<'_>, right: &Expr<'_>, span: Span, arg: Span) {
+    let lhs_const = constant_full_int(cx, cx.typeck_results(), left);
+    let rhs_const = constant_full_int(cx, cx.typeck_results(), right);
+    if match (lhs_const, rhs_const) {
+        (Some(FullInt::S(lv)), Some(FullInt::S(rv))) => lv.abs() < rv,
+        (Some(FullInt::U(lv)), Some(FullInt::U(rv))) => lv < rv,
+        _ => return,
+    } {
+        span_ineffective_operation(cx, span, arg);
+    }
+}
+
 fn check(cx: &LateContext<'_>, e: &Expr<'_>, m: i8, span: Span, arg: Span) {
     if let Some(Constant::Int(v)) = constant_simple(cx, cx.typeck_results(), e).map(Constant::peel_refs) {
         let check = match *cx.typeck_results().expr_ty(e).peel_refs().kind() {
@@ -83,15 +96,19 @@ fn check(cx: &LateContext<'_>, e: &Expr<'_>, m: i8, span: Span, arg: Span) {
             1 => v == 1,
             _ => unreachable!(),
         } {
-            span_lint(
-                cx,
-                IDENTITY_OP,
-                span,
-                &format!(
-                    "the operation is ineffective. Consider reducing it to `{}`",
-                    snippet(cx, arg, "..")
-                ),
-            );
+            span_ineffective_operation(cx, span, arg);
         }
     }
 }
+
+fn span_ineffective_operation(cx: &LateContext<'_>, span: Span, arg: Span) {
+    span_lint(
+        cx,
+        IDENTITY_OP,
+        span,
+        &format!(
+            "the operation is ineffective. Consider reducing it to `{}`",
+            snippet(cx, arg, "..")
+        ),
+    );
+}
diff --git a/tests/ui/identity_op.rs b/tests/ui/identity_op.rs
index 12bbda71f43..5e120947646 100644
--- a/tests/ui/identity_op.rs
+++ b/tests/ui/identity_op.rs
@@ -66,4 +66,10 @@ fn main() {
     let b = a << 0; // no error: non-integer
 
     1 * Meter; // no error: non-integer
+
+    2 % 3;
+    -2 % 3;
+    x + 1 % 3;
+    (x + 1) % 3; // no error
+    4 % 3; // no error
 }
diff --git a/tests/ui/identity_op.stderr b/tests/ui/identity_op.stderr
index 0103cf5457e..cb9757d1158 100644
--- a/tests/ui/identity_op.stderr
+++ b/tests/ui/identity_op.stderr
@@ -78,5 +78,23 @@ error: the operation is ineffective. Consider reducing it to `x`
 LL |     x >> &0;
    |     ^^^^^^^
 
-error: aborting due to 13 previous errors
+error: the operation is ineffective. Consider reducing it to `2`
+  --> $DIR/identity_op.rs:70:5
+   |
+LL |     2 % 3;
+   |     ^^^^^
+
+error: the operation is ineffective. Consider reducing it to `-2`
+  --> $DIR/identity_op.rs:71:5
+   |
+LL |     -2 % 3;
+   |     ^^^^^^
+
+error: the operation is ineffective. Consider reducing it to `1`
+  --> $DIR/identity_op.rs:72:9
+   |
+LL |     x + 1 % 3;
+   |         ^^^^^
+
+error: aborting due to 16 previous errors
 
diff --git a/tests/ui/modulo_arithmetic_integral_const.rs b/tests/ui/modulo_arithmetic_integral_const.rs
index 047a29fa1e3..3ebe46bc5be 100644
--- a/tests/ui/modulo_arithmetic_integral_const.rs
+++ b/tests/ui/modulo_arithmetic_integral_const.rs
@@ -1,5 +1,10 @@
 #![warn(clippy::modulo_arithmetic)]
-#![allow(clippy::no_effect, clippy::unnecessary_operation, clippy::modulo_one)]
+#![allow(
+    clippy::no_effect,
+    clippy::unnecessary_operation,
+    clippy::modulo_one,
+    clippy::identity_op
+)]
 
 fn main() {
     // Lint when both sides are const and of the opposite sign
diff --git a/tests/ui/modulo_arithmetic_integral_const.stderr b/tests/ui/modulo_arithmetic_integral_const.stderr
index 64335f35f0f..11b5f77461b 100644
--- a/tests/ui/modulo_arithmetic_integral_const.stderr
+++ b/tests/ui/modulo_arithmetic_integral_const.stderr
@@ -1,5 +1,5 @@
 error: you are using modulo operator on constants with different signs: `-1 % 2`
-  --> $DIR/modulo_arithmetic_integral_const.rs:6:5
+  --> $DIR/modulo_arithmetic_integral_const.rs:11:5
    |
 LL |     -1 % 2;
    |     ^^^^^^
@@ -9,7 +9,7 @@ LL |     -1 % 2;
    = note: or consider using `rem_euclid` or similar function
 
 error: you are using modulo operator on constants with different signs: `1 % -2`
-  --> $DIR/modulo_arithmetic_integral_const.rs:7:5
+  --> $DIR/modulo_arithmetic_integral_const.rs:12:5
    |
 LL |     1 % -2;
    |     ^^^^^^
@@ -18,7 +18,7 @@ LL |     1 % -2;
    = note: or consider using `rem_euclid` or similar function
 
 error: you are using modulo operator on constants with different signs: `-1 % 3`
-  --> $DIR/modulo_arithmetic_integral_const.rs:8:5
+  --> $DIR/modulo_arithmetic_integral_const.rs:13:5
    |
 LL |     (1 - 2) % (1 + 2);
    |     ^^^^^^^^^^^^^^^^^
@@ -27,7 +27,7 @@ LL |     (1 - 2) % (1 + 2);
    = note: or consider using `rem_euclid` or similar function
 
 error: you are using modulo operator on constants with different signs: `3 % -1`
-  --> $DIR/modulo_arithmetic_integral_const.rs:9:5
+  --> $DIR/modulo_arithmetic_integral_const.rs:14:5
    |
 LL |     (1 + 2) % (1 - 2);
    |     ^^^^^^^^^^^^^^^^^
@@ -36,7 +36,7 @@ LL |     (1 + 2) % (1 - 2);
    = note: or consider using `rem_euclid` or similar function
 
 error: you are using modulo operator on constants with different signs: `-35 % 300000`
-  --> $DIR/modulo_arithmetic_integral_const.rs:10:5
+  --> $DIR/modulo_arithmetic_integral_const.rs:15:5
    |
 LL |     35 * (7 - 4 * 2) % (-500 * -600);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -45,7 +45,7 @@ LL |     35 * (7 - 4 * 2) % (-500 * -600);
    = note: or consider using `rem_euclid` or similar function
 
 error: you are using modulo operator on constants with different signs: `-1 % 2`
-  --> $DIR/modulo_arithmetic_integral_const.rs:12:5
+  --> $DIR/modulo_arithmetic_integral_const.rs:17:5
    |
 LL |     -1i8 % 2i8;
    |     ^^^^^^^^^^
@@ -54,7 +54,7 @@ LL |     -1i8 % 2i8;
    = note: or consider using `rem_euclid` or similar function
 
 error: you are using modulo operator on constants with different signs: `1 % -2`
-  --> $DIR/modulo_arithmetic_integral_const.rs:13:5
+  --> $DIR/modulo_arithmetic_integral_const.rs:18:5
    |
 LL |     1i8 % -2i8;
    |     ^^^^^^^^^^
@@ -63,7 +63,7 @@ LL |     1i8 % -2i8;
    = note: or consider using `rem_euclid` or similar function
 
 error: you are using modulo operator on constants with different signs: `-1 % 2`
-  --> $DIR/modulo_arithmetic_integral_const.rs:14:5
+  --> $DIR/modulo_arithmetic_integral_const.rs:19:5
    |
 LL |     -1i16 % 2i16;
    |     ^^^^^^^^^^^^
@@ -72,7 +72,7 @@ LL |     -1i16 % 2i16;
    = note: or consider using `rem_euclid` or similar function
 
 error: you are using modulo operator on constants with different signs: `1 % -2`
-  --> $DIR/modulo_arithmetic_integral_const.rs:15:5
+  --> $DIR/modulo_arithmetic_integral_const.rs:20:5
    |
 LL |     1i16 % -2i16;
    |     ^^^^^^^^^^^^
@@ -81,7 +81,7 @@ LL |     1i16 % -2i16;
    = note: or consider using `rem_euclid` or similar function
 
 error: you are using modulo operator on constants with different signs: `-1 % 2`
-  --> $DIR/modulo_arithmetic_integral_const.rs:16:5
+  --> $DIR/modulo_arithmetic_integral_const.rs:21:5
    |
 LL |     -1i32 % 2i32;
    |     ^^^^^^^^^^^^
@@ -90,7 +90,7 @@ LL |     -1i32 % 2i32;
    = note: or consider using `rem_euclid` or similar function
 
 error: you are using modulo operator on constants with different signs: `1 % -2`
-  --> $DIR/modulo_arithmetic_integral_const.rs:17:5
+  --> $DIR/modulo_arithmetic_integral_const.rs:22:5
    |
 LL |     1i32 % -2i32;
    |     ^^^^^^^^^^^^
@@ -99,7 +99,7 @@ LL |     1i32 % -2i32;
    = note: or consider using `rem_euclid` or similar function
 
 error: you are using modulo operator on constants with different signs: `-1 % 2`
-  --> $DIR/modulo_arithmetic_integral_const.rs:18:5
+  --> $DIR/modulo_arithmetic_integral_const.rs:23:5
    |
 LL |     -1i64 % 2i64;
    |     ^^^^^^^^^^^^
@@ -108,7 +108,7 @@ LL |     -1i64 % 2i64;
    = note: or consider using `rem_euclid` or similar function
 
 error: you are using modulo operator on constants with different signs: `1 % -2`
-  --> $DIR/modulo_arithmetic_integral_const.rs:19:5
+  --> $DIR/modulo_arithmetic_integral_const.rs:24:5
    |
 LL |     1i64 % -2i64;
    |     ^^^^^^^^^^^^
@@ -117,7 +117,7 @@ LL |     1i64 % -2i64;
    = note: or consider using `rem_euclid` or similar function
 
 error: you are using modulo operator on constants with different signs: `-1 % 2`
-  --> $DIR/modulo_arithmetic_integral_const.rs:20:5
+  --> $DIR/modulo_arithmetic_integral_const.rs:25:5
    |
 LL |     -1i128 % 2i128;
    |     ^^^^^^^^^^^^^^
@@ -126,7 +126,7 @@ LL |     -1i128 % 2i128;
    = note: or consider using `rem_euclid` or similar function
 
 error: you are using modulo operator on constants with different signs: `1 % -2`
-  --> $DIR/modulo_arithmetic_integral_const.rs:21:5
+  --> $DIR/modulo_arithmetic_integral_const.rs:26:5
    |
 LL |     1i128 % -2i128;
    |     ^^^^^^^^^^^^^^
@@ -135,7 +135,7 @@ LL |     1i128 % -2i128;
    = note: or consider using `rem_euclid` or similar function
 
 error: you are using modulo operator on constants with different signs: `-1 % 2`
-  --> $DIR/modulo_arithmetic_integral_const.rs:22:5
+  --> $DIR/modulo_arithmetic_integral_const.rs:27:5
    |
 LL |     -1isize % 2isize;
    |     ^^^^^^^^^^^^^^^^
@@ -144,7 +144,7 @@ LL |     -1isize % 2isize;
    = note: or consider using `rem_euclid` or similar function
 
 error: you are using modulo operator on constants with different signs: `1 % -2`
-  --> $DIR/modulo_arithmetic_integral_const.rs:23:5
+  --> $DIR/modulo_arithmetic_integral_const.rs:28:5
    |
 LL |     1isize % -2isize;
    |     ^^^^^^^^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From 800f66de2bea7672e03ffa2be457ef06d91cce83 Mon Sep 17 00:00:00 2001
From: Jaeyong Sung <jaeyong0201@gmail.com>
Date: Mon, 14 Mar 2022 00:13:57 +0900
Subject: add clearing return vars

---
 clippy_lints/src/only_used_in_recursion.rs | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/only_used_in_recursion.rs b/clippy_lints/src/only_used_in_recursion.rs
index 2e5e990be44..b828d9334ee 100644
--- a/clippy_lints/src/only_used_in_recursion.rs
+++ b/clippy_lints/src/only_used_in_recursion.rs
@@ -268,18 +268,22 @@ impl<'tcx> Visitor<'tcx> for SideEffectVisit<'tcx> {
                 pat, init: Some(init), ..
             }) => {
                 self.visit_pat_expr(pat, init, false);
+                self.ret_vars.clear();
             },
             StmtKind::Item(i) => {
                 let item = self.ty_ctx.hir().item(i);
                 self.visit_item(item);
+                self.ret_vars.clear();
+            },
+            StmtKind::Expr(e) | StmtKind::Semi(e) => {
+                self.visit_expr(e);
+                self.ret_vars.clear();
             },
-            StmtKind::Expr(e) | StmtKind::Semi(e) => self.visit_expr(e),
             StmtKind::Local(_) => {},
         }
     }
 
     fn visit_expr(&mut self, ex: &'tcx Expr<'tcx>) {
-        debug_assert!(self.ret_vars.is_empty());
         match ex.kind {
             ExprKind::Array(exprs) | ExprKind::Tup(exprs) => {
                 self.ret_vars = exprs
-- 
cgit 1.4.1-3-g733a5


From 2ee53723897407ea31a1803af9bbedf98a49f934 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Mon, 14 Mar 2022 22:39:36 +0100
Subject: Allow `single_component_path_imports` for all macros

---
 clippy_lints/src/single_component_path_imports.rs   | 18 +++++++-----------
 tests/ui/single_component_path_imports_macro.fixed  | 20 --------------------
 tests/ui/single_component_path_imports_macro.rs     |  4 ++--
 tests/ui/single_component_path_imports_macro.stderr | 10 ----------
 4 files changed, 9 insertions(+), 43 deletions(-)
 delete mode 100644 tests/ui/single_component_path_imports_macro.fixed
 delete mode 100644 tests/ui/single_component_path_imports_macro.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/single_component_path_imports.rs b/clippy_lints/src/single_component_path_imports.rs
index 961cdb317e7..66b79513032 100644
--- a/clippy_lints/src/single_component_path_imports.rs
+++ b/clippy_lints/src/single_component_path_imports.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg};
-use rustc_ast::{ptr::P, Crate, Item, ItemKind, MacroDef, ModKind, UseTreeKind, VisibilityKind};
+use rustc_ast::{ptr::P, Crate, Item, ItemKind, MacroDef, ModKind, UseTreeKind};
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -76,14 +76,13 @@ fn check_mod(cx: &EarlyContext<'_>, items: &[P<Item>]) {
         );
     }
 
-    for single_use in &single_use_usages {
-        if !imports_reused_with_self.contains(&single_use.0) {
-            let can_suggest = single_use.2;
+    for (name, span, can_suggest) in single_use_usages {
+        if !imports_reused_with_self.contains(&name) {
             if can_suggest {
                 span_lint_and_sugg(
                     cx,
                     SINGLE_COMPONENT_PATH_IMPORTS,
-                    single_use.1,
+                    span,
                     "this import is redundant",
                     "remove it entirely",
                     String::new(),
@@ -93,7 +92,7 @@ fn check_mod(cx: &EarlyContext<'_>, items: &[P<Item>]) {
                 span_lint_and_help(
                     cx,
                     SINGLE_COMPONENT_PATH_IMPORTS,
-                    single_use.1,
+                    span,
                     "this import is redundant",
                     None,
                     "remove this import",
@@ -124,14 +123,11 @@ fn track_uses(
         ItemKind::Use(use_tree) => {
             let segments = &use_tree.prefix.segments;
 
-            let should_report =
-                |name: &Symbol| !macros.contains(name) || matches!(item.vis.kind, VisibilityKind::Inherited);
-
             // keep track of `use some_module;` usages
             if segments.len() == 1 {
                 if let UseTreeKind::Simple(None, _, _) = use_tree.kind {
                     let name = segments[0].ident.name;
-                    if should_report(&name) {
+                    if !macros.contains(&name) {
                         single_use_usages.push((name, item.span, true));
                     }
                 }
@@ -146,7 +142,7 @@ fn track_uses(
                         if segments.len() == 1 {
                             if let UseTreeKind::Simple(None, _, _) = tree.0.kind {
                                 let name = segments[0].ident.name;
-                                if should_report(&name) {
+                                if !macros.contains(&name) {
                                     single_use_usages.push((name, tree.0.span, false));
                                 }
                             }
diff --git a/tests/ui/single_component_path_imports_macro.fixed b/tests/ui/single_component_path_imports_macro.fixed
deleted file mode 100644
index e43f5d381aa..00000000000
--- a/tests/ui/single_component_path_imports_macro.fixed
+++ /dev/null
@@ -1,20 +0,0 @@
-// run-rustfix
-#![warn(clippy::single_component_path_imports)]
-#![allow(unused_imports)]
-
-// #7106: use statements exporting a macro within a crate should not trigger lint
-
-macro_rules! m1 {
-    () => {};
-}
-pub(crate) use m1; // ok
-
-macro_rules! m2 {
-    () => {};
-}
- // fail
-
-fn main() {
-    m1!();
-    m2!();
-}
diff --git a/tests/ui/single_component_path_imports_macro.rs b/tests/ui/single_component_path_imports_macro.rs
index 3c65ca3054c..fda294a6154 100644
--- a/tests/ui/single_component_path_imports_macro.rs
+++ b/tests/ui/single_component_path_imports_macro.rs
@@ -1,8 +1,8 @@
-// run-rustfix
 #![warn(clippy::single_component_path_imports)]
 #![allow(unused_imports)]
 
 // #7106: use statements exporting a macro within a crate should not trigger lint
+// #7923: normal `use` statements of macros should also not trigger the lint
 
 macro_rules! m1 {
     () => {};
@@ -12,7 +12,7 @@ pub(crate) use m1; // ok
 macro_rules! m2 {
     () => {};
 }
-use m2; // fail
+use m2; // ok
 
 fn main() {
     m1!();
diff --git a/tests/ui/single_component_path_imports_macro.stderr b/tests/ui/single_component_path_imports_macro.stderr
deleted file mode 100644
index 37d5176129f..00000000000
--- a/tests/ui/single_component_path_imports_macro.stderr
+++ /dev/null
@@ -1,10 +0,0 @@
-error: this import is redundant
-  --> $DIR/single_component_path_imports_macro.rs:15:1
-   |
-LL | use m2; // fail
-   | ^^^^^^^ help: remove it entirely
-   |
-   = note: `-D clippy::single-component-path-imports` implied by `-D warnings`
-
-error: aborting due to previous error
-
-- 
cgit 1.4.1-3-g733a5


From b981748036e3fbf3ab13a33c7eaab05735f86a4d Mon Sep 17 00:00:00 2001
From: flip1995 <philipp.krones@embecosm.com>
Date: Tue, 15 Mar 2022 09:46:49 +0100
Subject: Move iter_with_drain to nursery

---
 clippy_lints/src/lib.register_all.rs     | 1 -
 clippy_lints/src/lib.register_nursery.rs | 1 +
 clippy_lints/src/lib.register_perf.rs    | 1 -
 clippy_lints/src/methods/mod.rs          | 2 +-
 4 files changed, 2 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 23bca5a0eab..814e898b5b2 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -166,7 +166,6 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(methods::ITER_NTH_ZERO),
     LintId::of(methods::ITER_OVEREAGER_CLONED),
     LintId::of(methods::ITER_SKIP_NEXT),
-    LintId::of(methods::ITER_WITH_DRAIN),
     LintId::of(methods::MANUAL_FILTER_MAP),
     LintId::of(methods::MANUAL_FIND_MAP),
     LintId::of(methods::MANUAL_SATURATING_ARITHMETIC),
diff --git a/clippy_lints/src/lib.register_nursery.rs b/clippy_lints/src/lib.register_nursery.rs
index 8d4dde42bbe..c2fc67afba5 100644
--- a/clippy_lints/src/lib.register_nursery.rs
+++ b/clippy_lints/src/lib.register_nursery.rs
@@ -13,6 +13,7 @@ store.register_group(true, "clippy::nursery", Some("clippy_nursery"), vec![
     LintId::of(future_not_send::FUTURE_NOT_SEND),
     LintId::of(index_refutable_slice::INDEX_REFUTABLE_SLICE),
     LintId::of(let_if_seq::USELESS_LET_IF_SEQ),
+    LintId::of(methods::ITER_WITH_DRAIN),
     LintId::of(missing_const_for_fn::MISSING_CONST_FOR_FN),
     LintId::of(mutable_debug_assertion::DEBUG_ASSERT_WITH_MUT_CALL),
     LintId::of(mutex_atomic::MUTEX_ATOMIC),
diff --git a/clippy_lints/src/lib.register_perf.rs b/clippy_lints/src/lib.register_perf.rs
index 6e9c0ee33a1..f2f5c988d8f 100644
--- a/clippy_lints/src/lib.register_perf.rs
+++ b/clippy_lints/src/lib.register_perf.rs
@@ -16,7 +16,6 @@ store.register_group(true, "clippy::perf", Some("clippy_perf"), vec![
     LintId::of(methods::EXTEND_WITH_DRAIN),
     LintId::of(methods::ITER_NTH),
     LintId::of(methods::ITER_OVEREAGER_CLONED),
-    LintId::of(methods::ITER_WITH_DRAIN),
     LintId::of(methods::MANUAL_STR_REPEAT),
     LintId::of(methods::OR_FUN_CALL),
     LintId::of(methods::SINGLE_CHAR_PATTERN),
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 5edd22cd14c..aa9f86f292c 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1140,7 +1140,7 @@ declare_clippy_lint! {
     /// ```
     #[clippy::version = "1.61.0"]
     pub ITER_WITH_DRAIN,
-    perf,
+    nursery,
     "replace `.drain(..)` with `.into_iter()`"
 }
 
-- 
cgit 1.4.1-3-g733a5


From 6a3dbe4798e3966b80b16373fda75f5e4dd91384 Mon Sep 17 00:00:00 2001
From: dswij <dswijj@gmail.com>
Date: Tue, 15 Mar 2022 21:29:17 +0800
Subject: `unnecessary_lazy_eval` show suggestions on multiline lint

---
 clippy_lints/src/methods/unnecessary_lazy_eval.rs |  26 ++--
 tests/ui/unnecessary_lazy_eval.fixed              |   8 ++
 tests/ui/unnecessary_lazy_eval.rs                 |   8 ++
 tests/ui/unnecessary_lazy_eval.stderr             | 145 +++++++++++++++++-----
 tests/ui/unnecessary_lazy_eval_unfixable.stderr   |  12 +-
 5 files changed, 148 insertions(+), 51 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/unnecessary_lazy_eval.rs b/clippy_lints/src/methods/unnecessary_lazy_eval.rs
index 1e2765263c8..0dd41a4dacf 100644
--- a/clippy_lints/src/methods/unnecessary_lazy_eval.rs
+++ b/clippy_lints/src/methods/unnecessary_lazy_eval.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::{eager_or_lazy, usage};
@@ -48,20 +48,16 @@ pub(super) fn check<'tcx>(
                     Applicability::MaybeIncorrect
                 };
 
-                span_lint_and_sugg(
-                    cx,
-                    UNNECESSARY_LAZY_EVALUATIONS,
-                    expr.span,
-                    msg,
-                    &format!("use `{}` instead", simplify_using),
-                    format!(
-                        "{0}.{1}({2})",
-                        snippet(cx, recv.span, ".."),
-                        simplify_using,
-                        snippet(cx, body_expr.span, ".."),
-                    ),
-                    applicability,
-                );
+                if let hir::ExprKind::MethodCall(_, _, span) = expr.kind {
+                    span_lint_and_then(cx, UNNECESSARY_LAZY_EVALUATIONS, expr.span, msg, |diag| {
+                        diag.span_suggestion(
+                            span,
+                            &format!("use `{}(..)` instead", simplify_using),
+                            format!("{}({})", simplify_using, snippet(cx, body_expr.span, "..")),
+                            applicability,
+                        );
+                    });
+                }
             }
         }
     }
diff --git a/tests/ui/unnecessary_lazy_eval.fixed b/tests/ui/unnecessary_lazy_eval.fixed
index 4ba2a0a5dbc..65fcdc43061 100644
--- a/tests/ui/unnecessary_lazy_eval.fixed
+++ b/tests/ui/unnecessary_lazy_eval.fixed
@@ -115,6 +115,14 @@ fn main() {
     let _: Result<usize, usize> = res.or(Ok(2));
     let _: Result<usize, usize> = res.or(Ok(astronomers_pi));
     let _: Result<usize, usize> = res.or(Ok(ext_str.some_field));
+    let _: Result<usize, usize> = res.
+        // some lines
+        // some lines
+        // some lines
+        // some lines
+        // some lines
+        // some lines
+        or(Ok(ext_str.some_field));
 
     // neither bind_instead_of_map nor unnecessary_lazy_eval applies here
     let _: Result<usize, usize> = res.and_then(|x| Err(x));
diff --git a/tests/ui/unnecessary_lazy_eval.rs b/tests/ui/unnecessary_lazy_eval.rs
index 466915217e4..206080ed69a 100644
--- a/tests/ui/unnecessary_lazy_eval.rs
+++ b/tests/ui/unnecessary_lazy_eval.rs
@@ -115,6 +115,14 @@ fn main() {
     let _: Result<usize, usize> = res.or_else(|_| Ok(2));
     let _: Result<usize, usize> = res.or_else(|_| Ok(astronomers_pi));
     let _: Result<usize, usize> = res.or_else(|_| Ok(ext_str.some_field));
+    let _: Result<usize, usize> = res.
+        // some lines
+        // some lines
+        // some lines
+        // some lines
+        // some lines
+        // some lines
+        or_else(|_| Ok(ext_str.some_field));
 
     // neither bind_instead_of_map nor unnecessary_lazy_eval applies here
     let _: Result<usize, usize> = res.and_then(|x| Err(x));
diff --git a/tests/ui/unnecessary_lazy_eval.stderr b/tests/ui/unnecessary_lazy_eval.stderr
index cc94bd5cd9e..7e4dd7730e7 100644
--- a/tests/ui/unnecessary_lazy_eval.stderr
+++ b/tests/ui/unnecessary_lazy_eval.stderr
@@ -2,7 +2,9 @@ error: unnecessary closure used to substitute value for `Option::None`
   --> $DIR/unnecessary_lazy_eval.rs:35:13
    |
 LL |     let _ = opt.unwrap_or_else(|| 2);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^ help: use `unwrap_or` instead: `opt.unwrap_or(2)`
+   |             ^^^^--------------------
+   |                 |
+   |                 help: use `unwrap_or(..)` instead: `unwrap_or(2)`
    |
    = note: `-D clippy::unnecessary-lazy-evaluations` implied by `-D warnings`
 
@@ -10,187 +12,264 @@ error: unnecessary closure used to substitute value for `Option::None`
   --> $DIR/unnecessary_lazy_eval.rs:36:13
    |
 LL |     let _ = opt.unwrap_or_else(|| astronomers_pi);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `unwrap_or` instead: `opt.unwrap_or(astronomers_pi)`
+   |             ^^^^---------------------------------
+   |                 |
+   |                 help: use `unwrap_or(..)` instead: `unwrap_or(astronomers_pi)`
 
 error: unnecessary closure used to substitute value for `Option::None`
   --> $DIR/unnecessary_lazy_eval.rs:37:13
    |
 LL |     let _ = opt.unwrap_or_else(|| ext_str.some_field);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `unwrap_or` instead: `opt.unwrap_or(ext_str.some_field)`
+   |             ^^^^-------------------------------------
+   |                 |
+   |                 help: use `unwrap_or(..)` instead: `unwrap_or(ext_str.some_field)`
 
 error: unnecessary closure used to substitute value for `Option::None`
   --> $DIR/unnecessary_lazy_eval.rs:39:13
    |
 LL |     let _ = opt.and_then(|_| ext_opt);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `and` instead: `opt.and(ext_opt)`
+   |             ^^^^---------------------
+   |                 |
+   |                 help: use `and(..)` instead: `and(ext_opt)`
 
 error: unnecessary closure used to substitute value for `Option::None`
   --> $DIR/unnecessary_lazy_eval.rs:40:13
    |
 LL |     let _ = opt.or_else(|| ext_opt);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^ help: use `or` instead: `opt.or(ext_opt)`
+   |             ^^^^-------------------
+   |                 |
+   |                 help: use `or(..)` instead: `or(ext_opt)`
 
 error: unnecessary closure used to substitute value for `Option::None`
   --> $DIR/unnecessary_lazy_eval.rs:41:13
    |
 LL |     let _ = opt.or_else(|| None);
-   |             ^^^^^^^^^^^^^^^^^^^^ help: use `or` instead: `opt.or(None)`
+   |             ^^^^----------------
+   |                 |
+   |                 help: use `or(..)` instead: `or(None)`
 
 error: unnecessary closure used to substitute value for `Option::None`
   --> $DIR/unnecessary_lazy_eval.rs:42:13
    |
 LL |     let _ = opt.get_or_insert_with(|| 2);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `get_or_insert` instead: `opt.get_or_insert(2)`
+   |             ^^^^------------------------
+   |                 |
+   |                 help: use `get_or_insert(..)` instead: `get_or_insert(2)`
 
 error: unnecessary closure used to substitute value for `Option::None`
   --> $DIR/unnecessary_lazy_eval.rs:43:13
    |
 LL |     let _ = opt.ok_or_else(|| 2);
-   |             ^^^^^^^^^^^^^^^^^^^^ help: use `ok_or` instead: `opt.ok_or(2)`
+   |             ^^^^----------------
+   |                 |
+   |                 help: use `ok_or(..)` instead: `ok_or(2)`
 
 error: unnecessary closure used to substitute value for `Option::None`
   --> $DIR/unnecessary_lazy_eval.rs:44:13
    |
 LL |     let _ = nested_tuple_opt.unwrap_or_else(|| Some((1, 2)));
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `unwrap_or` instead: `nested_tuple_opt.unwrap_or(Some((1, 2)))`
+   |             ^^^^^^^^^^^^^^^^^-------------------------------
+   |                              |
+   |                              help: use `unwrap_or(..)` instead: `unwrap_or(Some((1, 2)))`
 
 error: unnecessary closure used to substitute value for `Option::None`
   --> $DIR/unnecessary_lazy_eval.rs:47:13
    |
 LL |     let _ = Some(10).unwrap_or_else(|| 2);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `unwrap_or` instead: `Some(10).unwrap_or(2)`
+   |             ^^^^^^^^^--------------------
+   |                      |
+   |                      help: use `unwrap_or(..)` instead: `unwrap_or(2)`
 
 error: unnecessary closure used to substitute value for `Option::None`
   --> $DIR/unnecessary_lazy_eval.rs:48:13
    |
 LL |     let _ = Some(10).and_then(|_| ext_opt);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `and` instead: `Some(10).and(ext_opt)`
+   |             ^^^^^^^^^---------------------
+   |                      |
+   |                      help: use `and(..)` instead: `and(ext_opt)`
 
 error: unnecessary closure used to substitute value for `Option::None`
   --> $DIR/unnecessary_lazy_eval.rs:49:28
    |
 LL |     let _: Option<usize> = None.or_else(|| ext_opt);
-   |                            ^^^^^^^^^^^^^^^^^^^^^^^^ help: use `or` instead: `None.or(ext_opt)`
+   |                            ^^^^^-------------------
+   |                                 |
+   |                                 help: use `or(..)` instead: `or(ext_opt)`
 
 error: unnecessary closure used to substitute value for `Option::None`
   --> $DIR/unnecessary_lazy_eval.rs:50:13
    |
 LL |     let _ = None.get_or_insert_with(|| 2);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `get_or_insert` instead: `None.get_or_insert(2)`
+   |             ^^^^^------------------------
+   |                  |
+   |                  help: use `get_or_insert(..)` instead: `get_or_insert(2)`
 
 error: unnecessary closure used to substitute value for `Option::None`
   --> $DIR/unnecessary_lazy_eval.rs:51:35
    |
 LL |     let _: Result<usize, usize> = None.ok_or_else(|| 2);
-   |                                   ^^^^^^^^^^^^^^^^^^^^^ help: use `ok_or` instead: `None.ok_or(2)`
+   |                                   ^^^^^----------------
+   |                                        |
+   |                                        help: use `ok_or(..)` instead: `ok_or(2)`
 
 error: unnecessary closure used to substitute value for `Option::None`
   --> $DIR/unnecessary_lazy_eval.rs:52:28
    |
 LL |     let _: Option<usize> = None.or_else(|| None);
-   |                            ^^^^^^^^^^^^^^^^^^^^^ help: use `or` instead: `None.or(None)`
+   |                            ^^^^^----------------
+   |                                 |
+   |                                 help: use `or(..)` instead: `or(None)`
 
 error: unnecessary closure used to substitute value for `Option::None`
   --> $DIR/unnecessary_lazy_eval.rs:55:13
    |
 LL |     let _ = deep.0.unwrap_or_else(|| 2);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `unwrap_or` instead: `deep.0.unwrap_or(2)`
+   |             ^^^^^^^--------------------
+   |                    |
+   |                    help: use `unwrap_or(..)` instead: `unwrap_or(2)`
 
 error: unnecessary closure used to substitute value for `Option::None`
   --> $DIR/unnecessary_lazy_eval.rs:56:13
    |
 LL |     let _ = deep.0.and_then(|_| ext_opt);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `and` instead: `deep.0.and(ext_opt)`
+   |             ^^^^^^^---------------------
+   |                    |
+   |                    help: use `and(..)` instead: `and(ext_opt)`
 
 error: unnecessary closure used to substitute value for `Option::None`
   --> $DIR/unnecessary_lazy_eval.rs:57:13
    |
 LL |     let _ = deep.0.or_else(|| None);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^ help: use `or` instead: `deep.0.or(None)`
+   |             ^^^^^^^----------------
+   |                    |
+   |                    help: use `or(..)` instead: `or(None)`
 
 error: unnecessary closure used to substitute value for `Option::None`
   --> $DIR/unnecessary_lazy_eval.rs:58:13
    |
 LL |     let _ = deep.0.get_or_insert_with(|| 2);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `get_or_insert` instead: `deep.0.get_or_insert(2)`
+   |             ^^^^^^^------------------------
+   |                    |
+   |                    help: use `get_or_insert(..)` instead: `get_or_insert(2)`
 
 error: unnecessary closure used to substitute value for `Option::None`
   --> $DIR/unnecessary_lazy_eval.rs:59:13
    |
 LL |     let _ = deep.0.ok_or_else(|| 2);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^ help: use `ok_or` instead: `deep.0.ok_or(2)`
+   |             ^^^^^^^----------------
+   |                    |
+   |                    help: use `ok_or(..)` instead: `ok_or(2)`
 
 error: unnecessary closure used to substitute value for `Option::None`
   --> $DIR/unnecessary_lazy_eval.rs:79:28
    |
 LL |     let _: Option<usize> = None.or_else(|| Some(3));
-   |                            ^^^^^^^^^^^^^^^^^^^^^^^^ help: use `or` instead: `None.or(Some(3))`
+   |                            ^^^^^-------------------
+   |                                 |
+   |                                 help: use `or(..)` instead: `or(Some(3))`
 
 error: unnecessary closure used to substitute value for `Option::None`
   --> $DIR/unnecessary_lazy_eval.rs:80:13
    |
 LL |     let _ = deep.0.or_else(|| Some(3));
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `or` instead: `deep.0.or(Some(3))`
+   |             ^^^^^^^-------------------
+   |                    |
+   |                    help: use `or(..)` instead: `or(Some(3))`
 
 error: unnecessary closure used to substitute value for `Option::None`
   --> $DIR/unnecessary_lazy_eval.rs:81:13
    |
 LL |     let _ = opt.or_else(|| Some(3));
-   |             ^^^^^^^^^^^^^^^^^^^^^^^ help: use `or` instead: `opt.or(Some(3))`
+   |             ^^^^-------------------
+   |                 |
+   |                 help: use `or(..)` instead: `or(Some(3))`
 
 error: unnecessary closure used to substitute value for `Result::Err`
   --> $DIR/unnecessary_lazy_eval.rs:87:13
    |
 LL |     let _ = res2.unwrap_or_else(|_| 2);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `unwrap_or` instead: `res2.unwrap_or(2)`
+   |             ^^^^^---------------------
+   |                  |
+   |                  help: use `unwrap_or(..)` instead: `unwrap_or(2)`
 
 error: unnecessary closure used to substitute value for `Result::Err`
   --> $DIR/unnecessary_lazy_eval.rs:88:13
    |
 LL |     let _ = res2.unwrap_or_else(|_| astronomers_pi);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `unwrap_or` instead: `res2.unwrap_or(astronomers_pi)`
+   |             ^^^^^----------------------------------
+   |                  |
+   |                  help: use `unwrap_or(..)` instead: `unwrap_or(astronomers_pi)`
 
 error: unnecessary closure used to substitute value for `Result::Err`
   --> $DIR/unnecessary_lazy_eval.rs:89:13
    |
 LL |     let _ = res2.unwrap_or_else(|_| ext_str.some_field);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `unwrap_or` instead: `res2.unwrap_or(ext_str.some_field)`
+   |             ^^^^^--------------------------------------
+   |                  |
+   |                  help: use `unwrap_or(..)` instead: `unwrap_or(ext_str.some_field)`
 
 error: unnecessary closure used to substitute value for `Result::Err`
   --> $DIR/unnecessary_lazy_eval.rs:111:35
    |
 LL |     let _: Result<usize, usize> = res.and_then(|_| Err(2));
-   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^ help: use `and` instead: `res.and(Err(2))`
+   |                                   ^^^^--------------------
+   |                                       |
+   |                                       help: use `and(..)` instead: `and(Err(2))`
 
 error: unnecessary closure used to substitute value for `Result::Err`
   --> $DIR/unnecessary_lazy_eval.rs:112:35
    |
 LL |     let _: Result<usize, usize> = res.and_then(|_| Err(astronomers_pi));
-   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `and` instead: `res.and(Err(astronomers_pi))`
+   |                                   ^^^^---------------------------------
+   |                                       |
+   |                                       help: use `and(..)` instead: `and(Err(astronomers_pi))`
 
 error: unnecessary closure used to substitute value for `Result::Err`
   --> $DIR/unnecessary_lazy_eval.rs:113:35
    |
 LL |     let _: Result<usize, usize> = res.and_then(|_| Err(ext_str.some_field));
-   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `and` instead: `res.and(Err(ext_str.some_field))`
+   |                                   ^^^^-------------------------------------
+   |                                       |
+   |                                       help: use `and(..)` instead: `and(Err(ext_str.some_field))`
 
 error: unnecessary closure used to substitute value for `Result::Err`
   --> $DIR/unnecessary_lazy_eval.rs:115:35
    |
 LL |     let _: Result<usize, usize> = res.or_else(|_| Ok(2));
-   |                                   ^^^^^^^^^^^^^^^^^^^^^^ help: use `or` instead: `res.or(Ok(2))`
+   |                                   ^^^^------------------
+   |                                       |
+   |                                       help: use `or(..)` instead: `or(Ok(2))`
 
 error: unnecessary closure used to substitute value for `Result::Err`
   --> $DIR/unnecessary_lazy_eval.rs:116:35
    |
 LL |     let _: Result<usize, usize> = res.or_else(|_| Ok(astronomers_pi));
-   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `or` instead: `res.or(Ok(astronomers_pi))`
+   |                                   ^^^^-------------------------------
+   |                                       |
+   |                                       help: use `or(..)` instead: `or(Ok(astronomers_pi))`
 
 error: unnecessary closure used to substitute value for `Result::Err`
   --> $DIR/unnecessary_lazy_eval.rs:117:35
    |
 LL |     let _: Result<usize, usize> = res.or_else(|_| Ok(ext_str.some_field));
-   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `or` instead: `res.or(Ok(ext_str.some_field))`
+   |                                   ^^^^-----------------------------------
+   |                                       |
+   |                                       help: use `or(..)` instead: `or(Ok(ext_str.some_field))`
 
-error: aborting due to 32 previous errors
+error: unnecessary closure used to substitute value for `Result::Err`
+  --> $DIR/unnecessary_lazy_eval.rs:118:35
+   |
+LL |       let _: Result<usize, usize> = res.
+   |  ___________________________________^
+LL | |         // some lines
+LL | |         // some lines
+LL | |         // some lines
+...  |
+LL | |         // some lines
+LL | |         or_else(|_| Ok(ext_str.some_field));
+   | |_________----------------------------------^
+   |           |
+   |           help: use `or(..)` instead: `or(Ok(ext_str.some_field))`
+
+error: aborting due to 33 previous errors
 
diff --git a/tests/ui/unnecessary_lazy_eval_unfixable.stderr b/tests/ui/unnecessary_lazy_eval_unfixable.stderr
index 75674b0a9d2..20acab6e844 100644
--- a/tests/ui/unnecessary_lazy_eval_unfixable.stderr
+++ b/tests/ui/unnecessary_lazy_eval_unfixable.stderr
@@ -2,7 +2,9 @@ error: unnecessary closure used to substitute value for `Result::Err`
   --> $DIR/unnecessary_lazy_eval_unfixable.rs:12:13
    |
 LL |     let _ = Ok(1).unwrap_or_else(|()| 2);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `unwrap_or` instead: `Ok(1).unwrap_or(2)`
+   |             ^^^^^^----------------------
+   |                   |
+   |                   help: use `unwrap_or(..)` instead: `unwrap_or(2)`
    |
    = note: `-D clippy::unnecessary-lazy-evaluations` implied by `-D warnings`
 
@@ -10,13 +12,17 @@ error: unnecessary closure used to substitute value for `Result::Err`
   --> $DIR/unnecessary_lazy_eval_unfixable.rs:16:13
    |
 LL |     let _ = Ok(1).unwrap_or_else(|e::E| 2);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `unwrap_or` instead: `Ok(1).unwrap_or(2)`
+   |             ^^^^^^------------------------
+   |                   |
+   |                   help: use `unwrap_or(..)` instead: `unwrap_or(2)`
 
 error: unnecessary closure used to substitute value for `Result::Err`
   --> $DIR/unnecessary_lazy_eval_unfixable.rs:17:13
    |
 LL |     let _ = Ok(1).unwrap_or_else(|SomeStruct { .. }| 2);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `unwrap_or` instead: `Ok(1).unwrap_or(2)`
+   |             ^^^^^^-------------------------------------
+   |                   |
+   |                   help: use `unwrap_or(..)` instead: `unwrap_or(2)`
 
 error: aborting due to 3 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 5c1843dbce100715e574d1022651b6796fd99a30 Mon Sep 17 00:00:00 2001
From: Paolo Gentili <pgentili@alma-automotive.it>
Date: Tue, 15 Mar 2022 14:24:07 +0100
Subject: Moved lint to `restriction`

---
 clippy_lints/src/try_err.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/try_err.rs b/clippy_lints/src/try_err.rs
index 80d6f3c6336..e108f7be12e 100644
--- a/clippy_lints/src/try_err.rs
+++ b/clippy_lints/src/try_err.rs
@@ -43,7 +43,7 @@ declare_clippy_lint! {
     /// ```
     #[clippy::version = "1.38.0"]
     pub TRY_ERR,
-    style,
+    restriction,
     "return errors explicitly rather than hiding them behind a `?`"
 }
 
-- 
cgit 1.4.1-3-g733a5


From 65f96e2b53369f6b403b655b2212272c2ae13d42 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sat, 19 Feb 2022 17:56:42 -0500
Subject: Rework `undocumented_unsafe_blocks`

---
 clippy_lints/src/lib.rs                        |   3 +-
 clippy_lints/src/undocumented_unsafe_blocks.rs | 281 ++++++++++---------------
 tests/ui/crashes/ice-7868.stderr               |   6 +-
 tests/ui/undocumented_unsafe_blocks.rs         |  42 +++-
 tests/ui/undocumented_unsafe_blocks.stderr     | 138 +++++-------
 5 files changed, 208 insertions(+), 262 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 504235d0d1e..49fc82c0ac7 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1,5 +1,6 @@
 // error-pattern:cargo-clippy
 
+#![feature(array_windows)]
 #![feature(binary_heap_into_iter_sorted)]
 #![feature(box_patterns)]
 #![feature(control_flow_enum)]
@@ -846,7 +847,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
             enable_raw_pointer_heuristic_for_send,
         ))
     });
-    store.register_late_pass(move || Box::new(undocumented_unsafe_blocks::UndocumentedUnsafeBlocks::default()));
+    store.register_late_pass(move || Box::new(undocumented_unsafe_blocks::UndocumentedUnsafeBlocks));
     store.register_late_pass(|| Box::new(match_str_case_mismatch::MatchStrCaseMismatch));
     store.register_late_pass(move || Box::new(format_args::FormatArgs));
     store.register_late_pass(|| Box::new(trailing_empty_array::TrailingEmptyArray));
diff --git a/clippy_lints/src/undocumented_unsafe_blocks.rs b/clippy_lints/src/undocumented_unsafe_blocks.rs
index e42c6c63ede..59c3d42b353 100644
--- a/clippy_lints/src/undocumented_unsafe_blocks.rs
+++ b/clippy_lints/src/undocumented_unsafe_blocks.rs
@@ -1,16 +1,13 @@
-use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg};
+use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::is_lint_allowed;
-use clippy_utils::source::{indent_of, reindent_multiline, snippet};
-use rustc_errors::Applicability;
-use rustc_hir::intravisit::{walk_expr, Visitor};
-use rustc_hir::{Block, BlockCheckMode, Expr, ExprKind, HirId, Local, UnsafeSource};
-use rustc_lexer::TokenKind;
-use rustc_lint::{LateContext, LateLintPass};
+use clippy_utils::source::walk_span_to_context;
+use rustc_hir::{Block, BlockCheckMode, UnsafeSource};
+use rustc_lexer::{tokenize, TokenKind};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_middle::ty::TyCtxt;
-use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::{BytePos, Span};
-use std::borrow::Cow;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::{BytePos, Pos, SyntaxContext};
+use std::rc::Rc;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -44,179 +41,127 @@ declare_clippy_lint! {
     "creating an unsafe block without explaining why it is safe"
 }
 
-impl_lint_pass!(UndocumentedUnsafeBlocks => [UNDOCUMENTED_UNSAFE_BLOCKS]);
-
-#[derive(Default)]
-pub struct UndocumentedUnsafeBlocks {
-    pub local_level: u32,
-    pub local_span: Option<Span>,
-    // The local was already checked for an overall safety comment
-    // There is no need to continue checking the blocks in the local
-    pub local_checked: bool,
-    // Since we can only check the blocks from expanded macros
-    // We have to omit the suggestion due to the actual definition
-    // Not being available to us
-    pub macro_expansion: bool,
-}
+declare_lint_pass!(UndocumentedUnsafeBlocks => [UNDOCUMENTED_UNSAFE_BLOCKS]);
 
 impl LateLintPass<'_> for UndocumentedUnsafeBlocks {
     fn check_block(&mut self, cx: &LateContext<'_>, block: &'_ Block<'_>) {
-        if_chain! {
-            if !self.local_checked;
-            if !is_lint_allowed(cx, UNDOCUMENTED_UNSAFE_BLOCKS, block.hir_id);
-            if !in_external_macro(cx.tcx.sess, block.span);
-            if let BlockCheckMode::UnsafeBlock(UnsafeSource::UserProvided) = block.rules;
-            if let Some(enclosing_scope_hir_id) = cx.tcx.hir().get_enclosing_scope(block.hir_id);
-            if self.block_has_safety_comment(cx.tcx, enclosing_scope_hir_id, block.span) == Some(false);
-            then {
-                let mut span = block.span;
-
-                if let Some(local_span) = self.local_span {
-                    span = local_span;
-
-                    let result = self.block_has_safety_comment(cx.tcx, enclosing_scope_hir_id, span);
-
-                    if result.unwrap_or(true) {
-                        self.local_checked = true;
-                        return;
-                    }
-                }
-
-                self.lint(cx, span);
-            }
-        }
-    }
-
-    fn check_local(&mut self, cx: &LateContext<'_>, local: &'_ Local<'_>) {
-        if_chain! {
-            if !is_lint_allowed(cx, UNDOCUMENTED_UNSAFE_BLOCKS, local.hir_id);
-            if !in_external_macro(cx.tcx.sess, local.span);
-            if let Some(init) = local.init;
-            then {
-                self.visit_expr(init);
-
-                if self.local_level > 0 {
-                    self.local_span = Some(local.span);
-                }
-            }
-        }
-    }
+        if block.rules == BlockCheckMode::UnsafeBlock(UnsafeSource::UserProvided)
+            && !in_external_macro(cx.tcx.sess, block.span)
+            && !is_lint_allowed(cx, UNDOCUMENTED_UNSAFE_BLOCKS, block.hir_id)
+            && !block_has_safety_comment(cx, block)
+        {
+            let source_map = cx.tcx.sess.source_map();
+            let span = if source_map.is_multiline(block.span) {
+                source_map.span_until_char(block.span, '\n')
+            } else {
+                block.span
+            };
 
-    fn check_block_post(&mut self, _: &LateContext<'_>, _: &'_ Block<'_>) {
-        self.local_level = self.local_level.saturating_sub(1);
-
-        if self.local_level == 0 {
-            self.local_checked = false;
-            self.local_span = None;
+            span_lint_and_help(
+                cx,
+                UNDOCUMENTED_UNSAFE_BLOCKS,
+                span,
+                "unsafe block missing a safety comment",
+                None,
+                "consider adding a safety comment on the preceding line",
+            );
         }
     }
 }
 
-impl<'v> Visitor<'v> for UndocumentedUnsafeBlocks {
-    fn visit_expr(&mut self, ex: &'v Expr<'v>) {
-        match ex.kind {
-            ExprKind::Block(_, _) => self.local_level = self.local_level.saturating_add(1),
-            _ => walk_expr(self, ex),
+/// Checks if the lines immediately preceding the block contain a safety comment.
+fn block_has_safety_comment(cx: &LateContext<'_>, block: &Block<'_>) -> bool {
+    // This intentionally ignores text before the start of a function so something like:
+    // ```
+    //     // SAFETY: reason
+    //     fn foo() { unsafe { .. } }
+    // ```
+    // won't work. This is to avoid dealing with where such a comment should be place relative to
+    // attributes and doc comments.
+
+    let source_map = cx.sess().source_map();
+    let ctxt = block.span.ctxt();
+    if ctxt != SyntaxContext::root() {
+        // From a macro expansion. Get the text from the start of the macro declaration to start of the unsafe block.
+        //     macro_rules! foo { () => { stuff }; (x) => { unsafe { stuff } }; }
+        //     ^--------------------------------------------^
+        if let Ok(unsafe_line) = source_map.lookup_line(block.span.lo())
+            && let Ok(macro_line) = source_map.lookup_line(ctxt.outer_expn_data().def_site.lo())
+            && Rc::ptr_eq(&unsafe_line.sf, &macro_line.sf)
+            && let Some(src) = unsafe_line.sf.src.as_deref()
+        {
+            macro_line.line < unsafe_line.line && text_has_safety_comment(
+                src,
+                &unsafe_line.sf.lines[macro_line.line + 1..=unsafe_line.line],
+                unsafe_line.sf.start_pos.to_usize(),
+            )
+        } else {
+            // Problem getting source text. Pretend a comment was found.
+            true
         }
+    } else if let Ok(unsafe_line) = source_map.lookup_line(block.span.lo())
+        && let Some(body) = cx.enclosing_body
+        && let Some(body_span) = walk_span_to_context(cx.tcx.hir().body(body).value.span, SyntaxContext::root())
+        && let Ok(body_line) = source_map.lookup_line(body_span.lo())
+        && Rc::ptr_eq(&unsafe_line.sf, &body_line.sf)
+        && let Some(src) = unsafe_line.sf.src.as_deref()
+    {
+        // Get the text from the start of function body to the unsafe block.
+        //     fn foo() { some_stuff; unsafe { stuff }; other_stuff; }
+        //              ^-------------^
+        body_line.line < unsafe_line.line && text_has_safety_comment(
+            src,
+            &unsafe_line.sf.lines[body_line.line + 1..=unsafe_line.line],
+            unsafe_line.sf.start_pos.to_usize(),
+        )
+    } else {
+        // Problem getting source text. Pretend a comment was found.
+        true
     }
 }
 
-impl UndocumentedUnsafeBlocks {
-    fn block_has_safety_comment(&mut self, tcx: TyCtxt<'_>, enclosing_hir_id: HirId, block_span: Span) -> Option<bool> {
-        let map = tcx.hir();
-        let source_map = tcx.sess.source_map();
-
-        let enclosing_scope_span = map.opt_span(enclosing_hir_id)?;
-
-        let between_span = if block_span.from_expansion() {
-            self.macro_expansion = true;
-            enclosing_scope_span.with_hi(block_span.hi()).source_callsite()
-        } else {
-            self.macro_expansion = false;
-            enclosing_scope_span.to(block_span).source_callsite()
-        };
-
-        let file_name = source_map.span_to_filename(between_span);
-        let source_file = source_map.get_source_file(&file_name)?;
-
-        let lex_start = (between_span.lo().0 - source_file.start_pos.0 + 1) as usize;
-        let lex_end = (between_span.hi().0 - source_file.start_pos.0) as usize;
-        let src_str = source_file.src.as_ref()?[lex_start..lex_end].to_string();
-
-        let source_start_pos = source_file.start_pos.0 as usize + lex_start;
-
-        let mut pos = 0;
-        let mut comment = false;
-
-        for token in rustc_lexer::tokenize(&src_str) {
-            match token.kind {
-                TokenKind::LineComment { doc_style: None }
-                | TokenKind::BlockComment {
-                    doc_style: None,
-                    terminated: true,
-                } => {
-                    let comment_str = src_str[pos + 2..pos + token.len].to_ascii_uppercase();
-
-                    if comment_str.contains("SAFETY:") {
-                        comment = true;
-                    }
-                },
-                // We need to add all whitespace to `pos` before checking the comment's line number
-                TokenKind::Whitespace => {},
-                _ => {
-                    if comment {
-                        // Get the line number of the "comment" (really wherever the trailing whitespace ended)
-                        let comment_line_num = source_file
-                            .lookup_file_pos(BytePos((source_start_pos + pos).try_into().unwrap()))
-                            .0;
-                        // Find the block/local's line number
-                        let block_line_num = tcx.sess.source_map().lookup_char_pos(block_span.lo()).line;
-
-                        // Check the comment is immediately followed by the block/local
-                        if block_line_num == comment_line_num + 1 || block_line_num == comment_line_num {
-                            return Some(true);
-                        }
-
-                        comment = false;
-                    }
-                },
+/// Checks if the given text has a safety comment for the immediately proceeding line.
+fn text_has_safety_comment(src: &str, line_starts: &[BytePos], offset: usize) -> bool {
+    let mut lines = line_starts
+        .array_windows::<2>()
+        .rev()
+        .map_while(|[start, end]| {
+            src.get(start.to_usize() - offset..end.to_usize() - offset)
+                .map(|text| (start.to_usize(), text.trim_start()))
+        })
+        .filter(|(_, text)| !text.is_empty());
+
+    let Some((line_start, line)) = lines.next() else {
+        return false;
+    };
+    // Check for a sequence of line comments.
+    if line.starts_with("//") {
+        let mut line = line;
+        loop {
+            if line.to_ascii_uppercase().contains("SAFETY:") {
+                return true;
+            }
+            match lines.next() {
+                Some((_, x)) if x.starts_with("//") => line = x,
+                _ => return false,
             }
-
-            pos += token.len;
         }
-
-        Some(false)
     }
-
-    fn lint(&self, cx: &LateContext<'_>, mut span: Span) {
-        let source_map = cx.tcx.sess.source_map();
-
-        if source_map.is_multiline(span) {
-            span = source_map.span_until_char(span, '\n');
+    // No line comments; look for the start of a block comment.
+    // This will only find them if they are at the start of a line.
+    let (mut line_start, mut line) = (line_start, line);
+    loop {
+        if line.starts_with("/*") {
+            let src = src[line_start..line_starts.last().unwrap().to_usize()].trim_start();
+            let mut tokens = tokenize(src);
+            return src[..tokens.next().unwrap().len]
+                .to_ascii_uppercase()
+                .contains("SAFETY:")
+                && tokens.all(|t| t.kind == TokenKind::Whitespace);
         }
-
-        if self.macro_expansion {
-            span_lint_and_help(
-                cx,
-                UNDOCUMENTED_UNSAFE_BLOCKS,
-                span,
-                "unsafe block in macro expansion missing a safety comment",
-                None,
-                "consider adding a safety comment in the macro definition",
-            );
-        } else {
-            let block_indent = indent_of(cx, span);
-            let suggestion = format!("// SAFETY: ...\n{}", snippet(cx, span, ".."));
-
-            span_lint_and_sugg(
-                cx,
-                UNDOCUMENTED_UNSAFE_BLOCKS,
-                span,
-                "unsafe block missing a safety comment",
-                "consider adding a safety comment",
-                reindent_multiline(Cow::Borrowed(&suggestion), true, block_indent).to_string(),
-                Applicability::HasPlaceholders,
-            );
+        match lines.next() {
+            Some(x) => (line_start, line) = x,
+            None => return false,
         }
     }
 }
diff --git a/tests/ui/crashes/ice-7868.stderr b/tests/ui/crashes/ice-7868.stderr
index 111350a6280..1a33e647588 100644
--- a/tests/ui/crashes/ice-7868.stderr
+++ b/tests/ui/crashes/ice-7868.stderr
@@ -5,11 +5,7 @@ LL |     unsafe { 0 };
    |     ^^^^^^^^^^^^
    |
    = note: `-D clippy::undocumented-unsafe-blocks` implied by `-D warnings`
-help: consider adding a safety comment
-   |
-LL ~     // SAFETY: ...
-LL ~     unsafe { 0 };
-   |
+   = help: consider adding a safety comment on the preceding line
 
 error: aborting due to previous error
 
diff --git a/tests/ui/undocumented_unsafe_blocks.rs b/tests/ui/undocumented_unsafe_blocks.rs
index 380303d8152..fcfb49dcdd4 100644
--- a/tests/ui/undocumented_unsafe_blocks.rs
+++ b/tests/ui/undocumented_unsafe_blocks.rs
@@ -89,11 +89,6 @@ fn block_comment_newlines() {
     unsafe {}
 }
 
-#[rustfmt::skip]
-fn inline_block_comment() {
-    /* Safety: */unsafe {}
-}
-
 fn block_comment_with_extras() {
     /* This is a description
      * SAFETY:
@@ -209,6 +204,43 @@ fn local_nest() {
     let _ = [(42, unsafe {}, unsafe {}), (52, unsafe {}, unsafe {})];
 }
 
+fn in_fn_call(x: *const u32) {
+    fn f(x: u32) {}
+
+    // Safety: reason
+    f(unsafe { *x });
+}
+
+fn multi_in_fn_call(x: *const u32) {
+    fn f(x: u32, y: u32) {}
+
+    // Safety: reason
+    f(unsafe { *x }, unsafe { *x });
+}
+
+fn in_multiline_fn_call(x: *const u32) {
+    fn f(x: u32, y: u32) {}
+
+    f(
+        // Safety: reason
+        unsafe { *x },
+        0,
+    );
+}
+
+fn in_macro_call(x: *const u32) {
+    // Safety: reason
+    println!("{}", unsafe { *x });
+}
+
+fn in_multiline_macro_call(x: *const u32) {
+    println!(
+        "{}",
+        // Safety: reason
+        unsafe { *x },
+    );
+}
+
 // Invalid comments
 
 fn no_comment() {
diff --git a/tests/ui/undocumented_unsafe_blocks.stderr b/tests/ui/undocumented_unsafe_blocks.stderr
index f69d0da54e0..4f5c1111c7e 100644
--- a/tests/ui/undocumented_unsafe_blocks.stderr
+++ b/tests/ui/undocumented_unsafe_blocks.stderr
@@ -1,114 +1,102 @@
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:215:5
+  --> $DIR/undocumented_unsafe_blocks.rs:247:5
    |
 LL |     unsafe {}
    |     ^^^^^^^^^
    |
    = note: `-D clippy::undocumented-unsafe-blocks` implied by `-D warnings`
-help: consider adding a safety comment
+   = help: consider adding a safety comment on the preceding line
+
+error: unsafe block missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:251:14
    |
-LL ~     // SAFETY: ...
-LL +     unsafe {}
+LL |     let _ = [unsafe { 14 }, unsafe { 15 }, 42, unsafe { 16 }];
+   |              ^^^^^^^^^^^^^
    |
+   = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:219:5
+  --> $DIR/undocumented_unsafe_blocks.rs:251:29
    |
 LL |     let _ = [unsafe { 14 }, unsafe { 15 }, 42, unsafe { 16 }];
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                             ^^^^^^^^^^^^^
    |
-help: consider adding a safety comment
+   = help: consider adding a safety comment on the preceding line
+
+error: unsafe block missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:251:48
    |
-LL ~     // SAFETY: ...
-LL +     let _ = [unsafe { 14 }, unsafe { 15 }, 42, unsafe { 16 }];
+LL |     let _ = [unsafe { 14 }, unsafe { 15 }, 42, unsafe { 16 }];
+   |                                                ^^^^^^^^^^^^^
    |
+   = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:223:5
+  --> $DIR/undocumented_unsafe_blocks.rs:255:18
    |
 LL |     let _ = (42, unsafe {}, "test", unsafe {});
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                  ^^^^^^^^^
    |
-help: consider adding a safety comment
+   = help: consider adding a safety comment on the preceding line
+
+error: unsafe block missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:255:37
    |
-LL ~     // SAFETY: ...
-LL +     let _ = (42, unsafe {}, "test", unsafe {});
+LL |     let _ = (42, unsafe {}, "test", unsafe {});
+   |                                     ^^^^^^^^^
    |
+   = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:227:5
+  --> $DIR/undocumented_unsafe_blocks.rs:259:14
    |
 LL |     let _ = *unsafe { &42 };
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: consider adding a safety comment
-   |
-LL ~     // SAFETY: ...
-LL +     let _ = *unsafe { &42 };
+   |              ^^^^^^^^^^^^^^
    |
+   = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:232:5
+  --> $DIR/undocumented_unsafe_blocks.rs:264:19
    |
 LL |     let _ = match unsafe {} {
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: consider adding a safety comment
-   |
-LL ~     // SAFETY: ...
-LL +     let _ = match unsafe {} {
+   |                   ^^^^^^^^^
    |
+   = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:238:5
+  --> $DIR/undocumented_unsafe_blocks.rs:270:14
    |
 LL |     let _ = &unsafe {};
-   |     ^^^^^^^^^^^^^^^^^^^
-   |
-help: consider adding a safety comment
-   |
-LL ~     // SAFETY: ...
-LL +     let _ = &unsafe {};
+   |              ^^^^^^^^^
    |
+   = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:242:5
+  --> $DIR/undocumented_unsafe_blocks.rs:274:14
    |
 LL |     let _ = [unsafe {}; 5];
-   |     ^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: consider adding a safety comment
-   |
-LL ~     // SAFETY: ...
-LL +     let _ = [unsafe {}; 5];
+   |              ^^^^^^^^^
    |
+   = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:246:5
+  --> $DIR/undocumented_unsafe_blocks.rs:278:13
    |
 LL |     let _ = unsafe {};
-   |     ^^^^^^^^^^^^^^^^^^
-   |
-help: consider adding a safety comment
-   |
-LL ~     // SAFETY: ...
-LL +     let _ = unsafe {};
+   |             ^^^^^^^^^
    |
+   = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:256:8
+  --> $DIR/undocumented_unsafe_blocks.rs:288:8
    |
 LL |     t!(unsafe {});
    |        ^^^^^^^^^
    |
-help: consider adding a safety comment
-   |
-LL ~     t!(// SAFETY: ...
-LL ~     unsafe {});
-   |
+   = help: consider adding a safety comment on the preceding line
 
-error: unsafe block in macro expansion missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:262:13
+error: unsafe block missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:294:13
    |
 LL |             unsafe {}
    |             ^^^^^^^^^
@@ -116,56 +104,40 @@ LL |             unsafe {}
 LL |     t!();
    |     ---- in this macro invocation
    |
-   = help: consider adding a safety comment in the macro definition
+   = help: consider adding a safety comment on the preceding line
    = note: this error originates in the macro `t` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:270:5
+  --> $DIR/undocumented_unsafe_blocks.rs:302:5
    |
 LL |     unsafe {} // SAFETY:
    |     ^^^^^^^^^
    |
-help: consider adding a safety comment
-   |
-LL ~     // SAFETY: ...
-LL ~     unsafe {} // SAFETY:
-   |
+   = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:274:5
+  --> $DIR/undocumented_unsafe_blocks.rs:306:5
    |
 LL |     unsafe {
    |     ^^^^^^^^
    |
-help: consider adding a safety comment
-   |
-LL ~     // SAFETY: ...
-LL +     unsafe {
-   |
+   = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:284:5
+  --> $DIR/undocumented_unsafe_blocks.rs:316:5
    |
 LL |     unsafe {};
    |     ^^^^^^^^^
    |
-help: consider adding a safety comment
-   |
-LL ~     // SAFETY: ...
-LL ~     unsafe {};
-   |
+   = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:288:20
+  --> $DIR/undocumented_unsafe_blocks.rs:320:20
    |
 LL |     println!("{}", unsafe { String::from_utf8_unchecked(vec![]) });
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-help: consider adding a safety comment
-   |
-LL ~     println!("{}", // SAFETY: ...
-LL ~     unsafe { String::from_utf8_unchecked(vec![]) });
-   |
+   = help: consider adding a safety comment on the preceding line
 
-error: aborting due to 14 previous errors
+error: aborting due to 17 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From a39d64973320468a4b68fe089c9934dc0ef2cf7f Mon Sep 17 00:00:00 2001
From: Paolo Gentili <nellorocca@gmail.com>
Date: Tue, 15 Mar 2022 19:38:40 +0100
Subject: Lint list updated

---
 clippy_lints/src/lib.register_all.rs         | 1 -
 clippy_lints/src/lib.register_restriction.rs | 1 +
 clippy_lints/src/lib.register_style.rs       | 1 -
 3 files changed, 1 insertion(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 814e898b5b2..653d4daa6b6 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -289,7 +289,6 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(transmute::UNSOUND_COLLECTION_TRANSMUTE),
     LintId::of(transmute::WRONG_TRANSMUTE),
     LintId::of(transmuting_null::TRANSMUTING_NULL),
-    LintId::of(try_err::TRY_ERR),
     LintId::of(types::BORROWED_BOX),
     LintId::of(types::BOX_COLLECTION),
     LintId::of(types::REDUNDANT_ALLOCATION),
diff --git a/clippy_lints/src/lib.register_restriction.rs b/clippy_lints/src/lib.register_restriction.rs
index 4e30fc38197..6ab139b2fb6 100644
--- a/clippy_lints/src/lib.register_restriction.rs
+++ b/clippy_lints/src/lib.register_restriction.rs
@@ -62,6 +62,7 @@ store.register_group(true, "clippy::restriction", Some("clippy_restriction"), ve
     LintId::of(strings::STRING_SLICE),
     LintId::of(strings::STRING_TO_STRING),
     LintId::of(strings::STR_TO_STRING),
+    LintId::of(try_err::TRY_ERR),
     LintId::of(types::RC_BUFFER),
     LintId::of(types::RC_MUTEX),
     LintId::of(undocumented_unsafe_blocks::UNDOCUMENTED_UNSAFE_BLOCKS),
diff --git a/clippy_lints/src/lib.register_style.rs b/clippy_lints/src/lib.register_style.rs
index 05211476ff2..dcf399cf956 100644
--- a/clippy_lints/src/lib.register_style.rs
+++ b/clippy_lints/src/lib.register_style.rs
@@ -105,7 +105,6 @@ store.register_group(true, "clippy::style", Some("clippy_style"), vec![
     LintId::of(single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS),
     LintId::of(tabs_in_doc_comments::TABS_IN_DOC_COMMENTS),
     LintId::of(to_digit_is_some::TO_DIGIT_IS_SOME),
-    LintId::of(try_err::TRY_ERR),
     LintId::of(unsafe_removed_from_name::UNSAFE_REMOVED_FROM_NAME),
     LintId::of(unused_unit::UNUSED_UNIT),
     LintId::of(upper_case_acronyms::UPPER_CASE_ACRONYMS),
-- 
cgit 1.4.1-3-g733a5


From 30b333645d1fb7cc4f657ad2e162977db6ee4b8c Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Tue, 15 Mar 2022 16:52:28 -0400
Subject: Don't lint `undocumented_unsafe_blocks` on bad proc-macro spans.

---
 clippy_lints/src/undocumented_unsafe_blocks.rs | 12 +++++++++
 tests/ui/auxiliary/proc_macro_unsafe.rs        | 18 ++++++++++++++
 tests/ui/undocumented_unsafe_blocks.rs         |  8 ++++++
 tests/ui/undocumented_unsafe_blocks.stderr     | 34 +++++++++++++-------------
 4 files changed, 55 insertions(+), 17 deletions(-)
 create mode 100644 tests/ui/auxiliary/proc_macro_unsafe.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/undocumented_unsafe_blocks.rs b/clippy_lints/src/undocumented_unsafe_blocks.rs
index 59c3d42b353..ac13a309e7b 100644
--- a/clippy_lints/src/undocumented_unsafe_blocks.rs
+++ b/clippy_lints/src/undocumented_unsafe_blocks.rs
@@ -48,6 +48,7 @@ impl LateLintPass<'_> for UndocumentedUnsafeBlocks {
         if block.rules == BlockCheckMode::UnsafeBlock(UnsafeSource::UserProvided)
             && !in_external_macro(cx.tcx.sess, block.span)
             && !is_lint_allowed(cx, UNDOCUMENTED_UNSAFE_BLOCKS, block.hir_id)
+            && !is_unsafe_from_proc_macro(cx, block)
             && !block_has_safety_comment(cx, block)
         {
             let source_map = cx.tcx.sess.source_map();
@@ -69,6 +70,17 @@ impl LateLintPass<'_> for UndocumentedUnsafeBlocks {
     }
 }
 
+fn is_unsafe_from_proc_macro(cx: &LateContext<'_>, block: &Block<'_>) -> bool {
+    let source_map = cx.sess().source_map();
+    let file_pos = source_map.lookup_byte_offset(block.span.lo());
+    file_pos
+        .sf
+        .src
+        .as_deref()
+        .and_then(|src| src.get(file_pos.pos.to_usize()..))
+        .map_or(true, |src| !src.starts_with("unsafe"))
+}
+
 /// Checks if the lines immediately preceding the block contain a safety comment.
 fn block_has_safety_comment(cx: &LateContext<'_>, block: &Block<'_>) -> bool {
     // This intentionally ignores text before the start of a function so something like:
diff --git a/tests/ui/auxiliary/proc_macro_unsafe.rs b/tests/ui/auxiliary/proc_macro_unsafe.rs
new file mode 100644
index 00000000000..3c40f77469b
--- /dev/null
+++ b/tests/ui/auxiliary/proc_macro_unsafe.rs
@@ -0,0 +1,18 @@
+// compile-flags: --emit=link
+// no-prefer-dynamic
+
+#![crate_type = "proc-macro"]
+
+extern crate proc_macro;
+
+use proc_macro::{Delimiter, Group, Ident, TokenStream, TokenTree};
+
+#[proc_macro]
+pub fn unsafe_block(input: TokenStream) -> TokenStream {
+    let span = input.into_iter().next().unwrap().span();
+    TokenStream::from_iter([TokenTree::Ident(Ident::new("unsafe", span)), {
+        let mut group = Group::new(Delimiter::Brace, TokenStream::new());
+        group.set_span(span);
+        TokenTree::Group(group)
+    }])
+}
diff --git a/tests/ui/undocumented_unsafe_blocks.rs b/tests/ui/undocumented_unsafe_blocks.rs
index fcfb49dcdd4..80fb198ab53 100644
--- a/tests/ui/undocumented_unsafe_blocks.rs
+++ b/tests/ui/undocumented_unsafe_blocks.rs
@@ -1,5 +1,9 @@
+// aux-build:proc_macro_unsafe.rs
+
 #![warn(clippy::undocumented_unsafe_blocks)]
 
+extern crate proc_macro_unsafe;
+
 // Valid comments
 
 fn nested_local() {
@@ -241,6 +245,10 @@ fn in_multiline_macro_call(x: *const u32) {
     );
 }
 
+fn from_proc_macro() {
+    proc_macro_unsafe::unsafe_block!(token);
+}
+
 // Invalid comments
 
 fn no_comment() {
diff --git a/tests/ui/undocumented_unsafe_blocks.stderr b/tests/ui/undocumented_unsafe_blocks.stderr
index 4f5c1111c7e..746bbe2f141 100644
--- a/tests/ui/undocumented_unsafe_blocks.stderr
+++ b/tests/ui/undocumented_unsafe_blocks.stderr
@@ -1,5 +1,5 @@
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:247:5
+  --> $DIR/undocumented_unsafe_blocks.rs:255:5
    |
 LL |     unsafe {}
    |     ^^^^^^^^^
@@ -8,7 +8,7 @@ LL |     unsafe {}
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:251:14
+  --> $DIR/undocumented_unsafe_blocks.rs:259:14
    |
 LL |     let _ = [unsafe { 14 }, unsafe { 15 }, 42, unsafe { 16 }];
    |              ^^^^^^^^^^^^^
@@ -16,7 +16,7 @@ LL |     let _ = [unsafe { 14 }, unsafe { 15 }, 42, unsafe { 16 }];
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:251:29
+  --> $DIR/undocumented_unsafe_blocks.rs:259:29
    |
 LL |     let _ = [unsafe { 14 }, unsafe { 15 }, 42, unsafe { 16 }];
    |                             ^^^^^^^^^^^^^
@@ -24,7 +24,7 @@ LL |     let _ = [unsafe { 14 }, unsafe { 15 }, 42, unsafe { 16 }];
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:251:48
+  --> $DIR/undocumented_unsafe_blocks.rs:259:48
    |
 LL |     let _ = [unsafe { 14 }, unsafe { 15 }, 42, unsafe { 16 }];
    |                                                ^^^^^^^^^^^^^
@@ -32,7 +32,7 @@ LL |     let _ = [unsafe { 14 }, unsafe { 15 }, 42, unsafe { 16 }];
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:255:18
+  --> $DIR/undocumented_unsafe_blocks.rs:263:18
    |
 LL |     let _ = (42, unsafe {}, "test", unsafe {});
    |                  ^^^^^^^^^
@@ -40,7 +40,7 @@ LL |     let _ = (42, unsafe {}, "test", unsafe {});
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:255:37
+  --> $DIR/undocumented_unsafe_blocks.rs:263:37
    |
 LL |     let _ = (42, unsafe {}, "test", unsafe {});
    |                                     ^^^^^^^^^
@@ -48,7 +48,7 @@ LL |     let _ = (42, unsafe {}, "test", unsafe {});
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:259:14
+  --> $DIR/undocumented_unsafe_blocks.rs:267:14
    |
 LL |     let _ = *unsafe { &42 };
    |              ^^^^^^^^^^^^^^
@@ -56,7 +56,7 @@ LL |     let _ = *unsafe { &42 };
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:264:19
+  --> $DIR/undocumented_unsafe_blocks.rs:272:19
    |
 LL |     let _ = match unsafe {} {
    |                   ^^^^^^^^^
@@ -64,7 +64,7 @@ LL |     let _ = match unsafe {} {
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:270:14
+  --> $DIR/undocumented_unsafe_blocks.rs:278:14
    |
 LL |     let _ = &unsafe {};
    |              ^^^^^^^^^
@@ -72,7 +72,7 @@ LL |     let _ = &unsafe {};
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:274:14
+  --> $DIR/undocumented_unsafe_blocks.rs:282:14
    |
 LL |     let _ = [unsafe {}; 5];
    |              ^^^^^^^^^
@@ -80,7 +80,7 @@ LL |     let _ = [unsafe {}; 5];
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:278:13
+  --> $DIR/undocumented_unsafe_blocks.rs:286:13
    |
 LL |     let _ = unsafe {};
    |             ^^^^^^^^^
@@ -88,7 +88,7 @@ LL |     let _ = unsafe {};
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:288:8
+  --> $DIR/undocumented_unsafe_blocks.rs:296:8
    |
 LL |     t!(unsafe {});
    |        ^^^^^^^^^
@@ -96,7 +96,7 @@ LL |     t!(unsafe {});
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:294:13
+  --> $DIR/undocumented_unsafe_blocks.rs:302:13
    |
 LL |             unsafe {}
    |             ^^^^^^^^^
@@ -108,7 +108,7 @@ LL |     t!();
    = note: this error originates in the macro `t` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:302:5
+  --> $DIR/undocumented_unsafe_blocks.rs:310:5
    |
 LL |     unsafe {} // SAFETY:
    |     ^^^^^^^^^
@@ -116,7 +116,7 @@ LL |     unsafe {} // SAFETY:
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:306:5
+  --> $DIR/undocumented_unsafe_blocks.rs:314:5
    |
 LL |     unsafe {
    |     ^^^^^^^^
@@ -124,7 +124,7 @@ LL |     unsafe {
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:316:5
+  --> $DIR/undocumented_unsafe_blocks.rs:324:5
    |
 LL |     unsafe {};
    |     ^^^^^^^^^
@@ -132,7 +132,7 @@ LL |     unsafe {};
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:320:20
+  --> $DIR/undocumented_unsafe_blocks.rs:328:20
    |
 LL |     println!("{}", unsafe { String::from_utf8_unchecked(vec![]) });
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From fc5cbba1a41fbfe165701d7e1e89bcca235079e6 Mon Sep 17 00:00:00 2001
From: Kisaragi <48310258+KisaragiEffective@users.noreply.github.com>
Date: Wed, 16 Mar 2022 08:50:30 +0900
Subject: fix typo in code-block kind specifier

---
 clippy_lints/src/collapsible_if.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/collapsible_if.rs b/clippy_lints/src/collapsible_if.rs
index f03f34e5a4b..d99547f0106 100644
--- a/clippy_lints/src/collapsible_if.rs
+++ b/clippy_lints/src/collapsible_if.rs
@@ -42,7 +42,7 @@ declare_clippy_lint! {
     ///
     /// Should be written:
     ///
-    /// ```rust.ignore
+    /// ```rust,ignore
     /// if x && y {
     ///     …
     /// }
-- 
cgit 1.4.1-3-g733a5


From 9f95e7622d325ca0f31dccdd42973751772b8522 Mon Sep 17 00:00:00 2001
From: Kisaragi <48310258+KisaragiEffective@users.noreply.github.com>
Date: Wed, 16 Mar 2022 10:19:19 +0900
Subject: fix typo in code-block kind specifier

---
 clippy_lints/src/collapsible_if.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/collapsible_if.rs b/clippy_lints/src/collapsible_if.rs
index d99547f0106..eae2723a7da 100644
--- a/clippy_lints/src/collapsible_if.rs
+++ b/clippy_lints/src/collapsible_if.rs
@@ -76,7 +76,7 @@ declare_clippy_lint! {
     ///
     /// Should be written:
     ///
-    /// ```rust.ignore
+    /// ```rust,ignore
     /// if x {
     ///     …
     /// } else if y {
-- 
cgit 1.4.1-3-g733a5


From e71ac41d44fd2fdffcb94f6000ad2cffad5c61cd Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Tue, 15 Mar 2022 21:51:07 -0400
Subject: Fix `transmute_undefined_repr` for single element tuples

---
 clippy_lints/src/transmute/transmute_undefined_repr.rs | 5 +++--
 tests/ui/transmute_undefined_repr.rs                   | 9 +++++++++
 2 files changed, 12 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/transmute/transmute_undefined_repr.rs b/clippy_lints/src/transmute/transmute_undefined_repr.rs
index 6edff224092..3cd9d208943 100644
--- a/clippy_lints/src/transmute/transmute_undefined_repr.rs
+++ b/clippy_lints/src/transmute/transmute_undefined_repr.rs
@@ -282,10 +282,11 @@ fn reduce_ty<'tcx>(cx: &LateContext<'tcx>, mut ty: Ty<'tcx>) -> ReducedTy<'tcx>
             },
             ty::Tuple(args) if args.is_empty() => ReducedTy::TypeErasure,
             ty::Tuple(args) => {
-                let Some(sized_ty) = args.iter().find(|&ty| !is_zero_sized_ty(cx, ty)) else {
+                let mut iter = args.iter();
+                let Some(sized_ty) = iter.find(|&ty| !is_zero_sized_ty(cx, ty)) else {
                     return ReducedTy::OrderedFields(ty);
                 };
-                if args.iter().all(|ty| is_zero_sized_ty(cx, ty)) {
+                if iter.all(|ty| is_zero_sized_ty(cx, ty)) {
                     ty = sized_ty;
                     continue;
                 }
diff --git a/tests/ui/transmute_undefined_repr.rs b/tests/ui/transmute_undefined_repr.rs
index b163d605634..e7a59dbed95 100644
--- a/tests/ui/transmute_undefined_repr.rs
+++ b/tests/ui/transmute_undefined_repr.rs
@@ -87,5 +87,14 @@ fn main() {
 
         let _: *const [u8] = transmute(value::<Box<[u8]>>()); // Ok
         let _: Box<[u8]> = transmute(value::<*mut [u8]>()); // Ok
+
+        let _: Ty2<u32, u32> = transmute(value::<(Ty2<u32, u32>,)>()); // Ok
+        let _: (Ty2<u32, u32>,) = transmute(value::<Ty2<u32, u32>>()); // Ok
+
+        let _: Ty2<u32, u32> = transmute(value::<(Ty2<u32, u32>, ())>()); // Ok
+        let _: (Ty2<u32, u32>, ()) = transmute(value::<Ty2<u32, u32>>()); // Ok
+
+        let _: Ty2<u32, u32> = transmute(value::<((), Ty2<u32, u32>)>()); // Ok
+        let _: ((), Ty2<u32, u32>) = transmute(value::<Ty2<u32, u32>>()); // Ok
     }
 }
-- 
cgit 1.4.1-3-g733a5


From 442d4ce1c36011a8b12fb3ce9a4d70a7031fc4d5 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Tue, 15 Mar 2022 22:31:07 -0400
Subject: Don't lint fat pointer to `(usize, usize)` conversion in
 `transmute_undefined_repr`

---
 clippy_lints/src/transmute/transmute_undefined_repr.rs | 15 ++++++++++++++-
 tests/ui/transmute_undefined_repr.rs                   |  7 +++++++
 2 files changed, 21 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/transmute/transmute_undefined_repr.rs b/clippy_lints/src/transmute/transmute_undefined_repr.rs
index 3cd9d208943..30059e5ba2b 100644
--- a/clippy_lints/src/transmute/transmute_undefined_repr.rs
+++ b/clippy_lints/src/transmute/transmute_undefined_repr.rs
@@ -4,7 +4,7 @@ use clippy_utils::ty::is_c_void;
 use rustc_hir::Expr;
 use rustc_lint::LateContext;
 use rustc_middle::ty::subst::Subst;
-use rustc_middle::ty::{self, Ty, TypeAndMut};
+use rustc_middle::ty::{self, IntTy, Ty, TypeAndMut, UintTy};
 use rustc_span::Span;
 
 #[allow(clippy::too_many_lines)]
@@ -24,6 +24,7 @@ pub(super) fn check<'tcx>(
                 to_ty: to_sub_ty,
             } => match reduce_ty(cx, to_sub_ty) {
                 ReducedTy::IntArray | ReducedTy::TypeErasure => break,
+                ReducedTy::UnorderedFields(ty) if is_size_pair(ty) => break,
                 ReducedTy::Ref(to_sub_ty) => {
                     from_ty = unsized_ty;
                     to_ty = to_sub_ty;
@@ -49,6 +50,7 @@ pub(super) fn check<'tcx>(
                 from_ty: from_sub_ty,
             } => match reduce_ty(cx, from_sub_ty) {
                 ReducedTy::IntArray | ReducedTy::TypeErasure => break,
+                ReducedTy::UnorderedFields(ty) if is_size_pair(ty) => break,
                 ReducedTy::Ref(from_sub_ty) => {
                     from_ty = from_sub_ty;
                     to_ty = unsized_ty;
@@ -333,3 +335,14 @@ fn is_zero_sized_ty<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
         }
     }
 }
+
+fn is_size_pair(ty: Ty<'_>) -> bool {
+    if let ty::Tuple(tys) = *ty.kind()
+        && let [ty1, ty2] = &**tys
+    {
+        matches!(ty1.kind(), ty::Int(IntTy::Isize) | ty::Uint(UintTy::Usize))
+            && matches!(ty2.kind(), ty::Int(IntTy::Isize) | ty::Uint(UintTy::Usize))
+    } else {
+        false
+    }
+}
diff --git a/tests/ui/transmute_undefined_repr.rs b/tests/ui/transmute_undefined_repr.rs
index e7a59dbed95..13d8cb10e98 100644
--- a/tests/ui/transmute_undefined_repr.rs
+++ b/tests/ui/transmute_undefined_repr.rs
@@ -96,5 +96,12 @@ fn main() {
 
         let _: Ty2<u32, u32> = transmute(value::<((), Ty2<u32, u32>)>()); // Ok
         let _: ((), Ty2<u32, u32>) = transmute(value::<Ty2<u32, u32>>()); // Ok
+
+        let _: (usize, usize) = transmute(value::<&[u8]>()); // Ok
+        let _: &[u8] = transmute(value::<(usize, usize)>()); // Ok
+
+        trait Trait {}
+        let _: (isize, isize) = transmute(value::<&dyn Trait>()); // Ok
+        let _: &dyn Trait = transmute(value::<(isize, isize)>()); // Ok
     }
 }
-- 
cgit 1.4.1-3-g733a5


From 7fd52b5e3ce01fa856ca79693e7d5bdb7633fd03 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Tue, 15 Mar 2022 22:33:26 -0400
Subject: Small simplification to `transmute_undefined_repr`

---
 clippy_lints/src/transmute/transmute_undefined_repr.rs | 12 ++++--------
 1 file changed, 4 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/transmute/transmute_undefined_repr.rs b/clippy_lints/src/transmute/transmute_undefined_repr.rs
index 30059e5ba2b..f0aa3a2fa28 100644
--- a/clippy_lints/src/transmute/transmute_undefined_repr.rs
+++ b/clippy_lints/src/transmute/transmute_undefined_repr.rs
@@ -23,7 +23,7 @@ pub(super) fn check<'tcx>(
                 unsized_ty,
                 to_ty: to_sub_ty,
             } => match reduce_ty(cx, to_sub_ty) {
-                ReducedTy::IntArray | ReducedTy::TypeErasure => break,
+                ReducedTy::TypeErasure => break,
                 ReducedTy::UnorderedFields(ty) if is_size_pair(ty) => break,
                 ReducedTy::Ref(to_sub_ty) => {
                     from_ty = unsized_ty;
@@ -49,7 +49,7 @@ pub(super) fn check<'tcx>(
                 unsized_ty,
                 from_ty: from_sub_ty,
             } => match reduce_ty(cx, from_sub_ty) {
-                ReducedTy::IntArray | ReducedTy::TypeErasure => break,
+                ReducedTy::TypeErasure => break,
                 ReducedTy::UnorderedFields(ty) if is_size_pair(ty) => break,
                 ReducedTy::Ref(from_sub_ty) => {
                     from_ty = from_sub_ty;
@@ -125,8 +125,7 @@ pub(super) fn check<'tcx>(
                 from_ty: from_sub_ty,
                 to_ty: to_sub_ty,
             } => match (reduce_ty(cx, from_sub_ty), reduce_ty(cx, to_sub_ty)) {
-                (ReducedTy::IntArray | ReducedTy::TypeErasure, _)
-                | (_, ReducedTy::IntArray | ReducedTy::TypeErasure) => return false,
+                (ReducedTy::TypeErasure, _) | (_, ReducedTy::TypeErasure) => return false,
                 (ReducedTy::UnorderedFields(from_ty), ReducedTy::UnorderedFields(to_ty)) if from_ty != to_ty => {
                     span_lint_and_then(
                         cx,
@@ -265,9 +264,6 @@ enum ReducedTy<'tcx> {
     UnorderedFields(Ty<'tcx>),
     /// The type is a reference to the contained type.
     Ref(Ty<'tcx>),
-    /// The type is an array of a primitive integer type. These can be used as storage for a value
-    /// of another type.
-    IntArray,
     /// Any other type.
     Other(Ty<'tcx>),
 }
@@ -277,7 +273,7 @@ fn reduce_ty<'tcx>(cx: &LateContext<'tcx>, mut ty: Ty<'tcx>) -> ReducedTy<'tcx>
     loop {
         ty = cx.tcx.try_normalize_erasing_regions(cx.param_env, ty).unwrap_or(ty);
         return match *ty.kind() {
-            ty::Array(sub_ty, _) if matches!(sub_ty.kind(), ty::Int(_) | ty::Uint(_)) => ReducedTy::IntArray,
+            ty::Array(sub_ty, _) if matches!(sub_ty.kind(), ty::Int(_) | ty::Uint(_)) => ReducedTy::TypeErasure,
             ty::Array(sub_ty, _) | ty::Slice(sub_ty) => {
                 ty = sub_ty;
                 continue;
-- 
cgit 1.4.1-3-g733a5


From 911e10562a0274d6baab1064a903f3aefef14070 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Tue, 15 Mar 2022 22:38:15 -0400
Subject: Don't lint `transmute_undefined_repr` on unions.

---
 clippy_lints/src/transmute/transmute_undefined_repr.rs | 2 ++
 tests/ui/transmute_undefined_repr.rs                   | 5 ++++-
 2 files changed, 6 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/transmute/transmute_undefined_repr.rs b/clippy_lints/src/transmute/transmute_undefined_repr.rs
index f0aa3a2fa28..4922c40bcef 100644
--- a/clippy_lints/src/transmute/transmute_undefined_repr.rs
+++ b/clippy_lints/src/transmute/transmute_undefined_repr.rs
@@ -312,6 +312,8 @@ fn reduce_ty<'tcx>(cx: &LateContext<'tcx>, mut ty: Ty<'tcx>) -> ReducedTy<'tcx>
             ty::Adt(def, _) if def.is_enum() && (def.variants().is_empty() || is_c_void(cx, ty)) => {
                 ReducedTy::TypeErasure
             },
+            // TODO: Check if the conversion to or from at least one of a union's fields is valid.
+            ty::Adt(def, _) if def.is_union() => ReducedTy::TypeErasure,
             ty::Foreign(_) => ReducedTy::TypeErasure,
             ty::Ref(_, ty, _) => ReducedTy::Ref(ty),
             ty::RawPtr(ty) => ReducedTy::Ref(ty.ty),
diff --git a/tests/ui/transmute_undefined_repr.rs b/tests/ui/transmute_undefined_repr.rs
index 13d8cb10e98..fabe0e5bc4d 100644
--- a/tests/ui/transmute_undefined_repr.rs
+++ b/tests/ui/transmute_undefined_repr.rs
@@ -2,7 +2,7 @@
 #![allow(clippy::unit_arg, clippy::transmute_ptr_to_ref)]
 
 use core::ffi::c_void;
-use core::mem::{size_of, transmute};
+use core::mem::{size_of, transmute, MaybeUninit};
 
 fn value<T>() -> T {
     unimplemented!()
@@ -103,5 +103,8 @@ fn main() {
         trait Trait {}
         let _: (isize, isize) = transmute(value::<&dyn Trait>()); // Ok
         let _: &dyn Trait = transmute(value::<(isize, isize)>()); // Ok
+
+        let _: MaybeUninit<Ty2<u32, u32>> = transmute(value::<Ty2<u32, u32>>()); // Ok
+        let _: Ty2<u32, u32> = transmute(value::<MaybeUninit<Ty2<u32, u32>>>()); // Ok
     }
 }
-- 
cgit 1.4.1-3-g733a5


From 47c9ed697b4041fca4488922ee5614ad98bfeec2 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Tue, 15 Mar 2022 22:47:18 -0400
Subject: Fix checking transmutes with adjusted types

---
 clippy_lints/src/transmute/mod.rs                   | 3 ++-
 tests/ui/transmute_undefined_repr.rs                | 2 ++
 tests/ui/transmutes_expressible_as_ptr_casts.stderr | 4 ++--
 3 files changed, 6 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/transmute/mod.rs b/clippy_lints/src/transmute/mod.rs
index 23cb9d40dfd..02569bd3a47 100644
--- a/clippy_lints/src/transmute/mod.rs
+++ b/clippy_lints/src/transmute/mod.rs
@@ -415,7 +415,8 @@ impl<'tcx> LateLintPass<'tcx> for Transmute {
                 // And see https://github.com/rust-lang/rust/issues/51911 for dereferencing raw pointers.
                 let const_context = in_constant(cx, e.hir_id);
 
-                let from_ty = cx.typeck_results().expr_ty(arg);
+                let from_ty = cx.typeck_results().expr_ty_adjusted(arg);
+                // Adjustments for `to_ty` happen after the call to `transmute`, so don't use them.
                 let to_ty = cx.typeck_results().expr_ty(e);
 
                 // If useless_transmute is triggered, the other lints can be skipped.
diff --git a/tests/ui/transmute_undefined_repr.rs b/tests/ui/transmute_undefined_repr.rs
index fabe0e5bc4d..7cc03b89fe0 100644
--- a/tests/ui/transmute_undefined_repr.rs
+++ b/tests/ui/transmute_undefined_repr.rs
@@ -106,5 +106,7 @@ fn main() {
 
         let _: MaybeUninit<Ty2<u32, u32>> = transmute(value::<Ty2<u32, u32>>()); // Ok
         let _: Ty2<u32, u32> = transmute(value::<MaybeUninit<Ty2<u32, u32>>>()); // Ok
+
+        let _: Ty<&[u32]> = transmute::<&[u32], _>(value::<&Vec<u32>>()); // Ok
     }
 }
diff --git a/tests/ui/transmutes_expressible_as_ptr_casts.stderr b/tests/ui/transmutes_expressible_as_ptr_casts.stderr
index d9b64a0ed7b..de9418c8d1a 100644
--- a/tests/ui/transmutes_expressible_as_ptr_casts.stderr
+++ b/tests/ui/transmutes_expressible_as_ptr_casts.stderr
@@ -34,13 +34,13 @@ error: transmute from a reference to a pointer
 LL |     let _array_ptr_transmute = unsafe { transmute::<&[i32; 4], *const [i32; 4]>(array_ref) };
    |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `array_ref as *const [i32; 4]`
 
-error: transmute from `fn(usize) -> u8 {main::foo}` to `*const usize` which could be expressed as a pointer cast instead
+error: transmute from `fn(usize) -> u8` to `*const usize` which could be expressed as a pointer cast instead
   --> $DIR/transmutes_expressible_as_ptr_casts.rs:48:41
    |
 LL |     let _usize_ptr_transmute = unsafe { transmute::<fn(usize) -> u8, *const usize>(foo) };
    |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `foo as *const usize`
 
-error: transmute from `fn(usize) -> u8 {main::foo}` to `usize` which could be expressed as a pointer cast instead
+error: transmute from `fn(usize) -> u8` to `usize` which could be expressed as a pointer cast instead
   --> $DIR/transmutes_expressible_as_ptr_casts.rs:52:49
    |
 LL |     let _usize_from_fn_ptr_transmute = unsafe { transmute::<fn(usize) -> u8, usize>(foo) };
-- 
cgit 1.4.1-3-g733a5


From 2909b33a243591cec6a5d6d51dc6e1684809aeac Mon Sep 17 00:00:00 2001
From: J-ZhengLi <lizheng135@huawei.com>
Date: Wed, 16 Mar 2022 16:26:56 +0800
Subject: quick fix of issue#8542 for lint `[needless_match]` remove `ref`/`ref
 mut` check

---
 clippy_lints/src/matches/needless_match.rs |  61 +++++-------
 tests/ui/needless_match.fixed              | 116 +++++++++++++++++-----
 tests/ui/needless_match.rs                 | 148 ++++++++++++++++++++---------
 tests/ui/needless_match.stderr             |  83 ++++++++--------
 4 files changed, 257 insertions(+), 151 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/needless_match.rs b/clippy_lints/src/matches/needless_match.rs
index 76131d307d7..d9544e18b18 100644
--- a/clippy_lints/src/matches/needless_match.rs
+++ b/clippy_lints/src/matches/needless_match.rs
@@ -5,7 +5,7 @@ use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::{eq_expr_value, get_parent_expr, higher, is_else_clause, is_lang_ctor, peel_blocks_with_stmt};
 use rustc_errors::Applicability;
 use rustc_hir::LangItem::OptionNone;
-use rustc_hir::{Arm, BindingAnnotation, Expr, ExprKind, Pat, PatKind, Path, PathSegment, QPath, UnOp};
+use rustc_hir::{Arm, BindingAnnotation, Expr, ExprKind, Pat, PatKind, Path, PathSegment, QPath};
 use rustc_lint::LateContext;
 use rustc_span::sym;
 
@@ -21,7 +21,7 @@ pub(crate) fn check_match(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>])
             if !eq_expr_value(cx, ex, ret_expr) {
                 return;
             }
-        } else if !pat_same_as_expr(arm.pat, arm.body) {
+        } else if !pat_same_as_expr(arm.pat, peel_blocks_with_stmt(arm.body)) {
             return;
         }
     }
@@ -92,6 +92,9 @@ fn check_if_let(cx: &LateContext<'_>, if_let: &higher::IfLet<'_>) -> bool {
 
         if matches!(if_else.kind, ExprKind::Block(..)) {
             let else_expr = peel_blocks_with_stmt(if_else);
+            if matches!(else_expr.kind, ExprKind::Block(..)) {
+                return false;
+            }
             let ret = strip_return(else_expr);
             let let_expr_ty = cx.typeck_results().expr_ty(if_let.let_expr);
             if is_type_diagnostic_item(cx, let_expr_ty, sym::Option) {
@@ -120,40 +123,25 @@ fn pat_same_as_expr(pat: &Pat<'_>, expr: &Expr<'_>) -> bool {
     let expr = strip_return(expr);
     match (&pat.kind, &expr.kind) {
         // Example: `Some(val) => Some(val)`
-        (
-            PatKind::TupleStruct(QPath::Resolved(_, path), [first_pat, ..], _),
-            ExprKind::Call(call_expr, [first_param, ..]),
-        ) => {
+        (PatKind::TupleStruct(QPath::Resolved(_, path), tuple_params, _), ExprKind::Call(call_expr, call_params)) => {
             if let ExprKind::Path(QPath::Resolved(_, call_path)) = call_expr.kind {
-                if has_identical_segments(path.segments, call_path.segments)
-                    && has_same_non_ref_symbol(first_pat, first_param)
-                {
-                    return true;
-                }
+                return has_identical_segments(path.segments, call_path.segments)
+                    && has_same_non_ref_symbols(tuple_params, call_params);
             }
         },
-        // Example: `val => val`, or `ref val => *val`
-        (PatKind::Binding(annot, _, pat_ident, _), _) => {
-            let new_expr = if let (
-                BindingAnnotation::Ref | BindingAnnotation::RefMut,
-                ExprKind::Unary(UnOp::Deref, operand_expr),
-            ) = (annot, &expr.kind)
-            {
-                operand_expr
-            } else {
-                expr
-            };
-
-            if let ExprKind::Path(QPath::Resolved(
+        // Example: `val => val`
+        (
+            PatKind::Binding(annot, _, pat_ident, _),
+            ExprKind::Path(QPath::Resolved(
                 _,
                 Path {
                     segments: [first_seg, ..],
                     ..
                 },
-            )) = new_expr.kind
-            {
-                return pat_ident.name == first_seg.ident.name;
-            }
+            )),
+        ) => {
+            return !matches!(annot, BindingAnnotation::Ref | BindingAnnotation::RefMut)
+                && pat_ident.name == first_seg.ident.name;
         },
         // Example: `Custom::TypeA => Custom::TypeB`, or `None => None`
         (PatKind::Path(QPath::Resolved(_, p_path)), ExprKind::Path(QPath::Resolved(_, e_path))) => {
@@ -183,15 +171,16 @@ fn has_identical_segments(left_segs: &[PathSegment<'_>], right_segs: &[PathSegme
     true
 }
 
-fn has_same_non_ref_symbol(pat: &Pat<'_>, expr: &Expr<'_>) -> bool {
-    if_chain! {
-        if let PatKind::Binding(annot, _, pat_ident, _) = pat.kind;
-        if !matches!(annot, BindingAnnotation::Ref | BindingAnnotation::RefMut);
-        if let ExprKind::Path(QPath::Resolved(_, Path {segments: [first_seg, ..], .. })) = expr.kind;
-        then {
-            return pat_ident.name == first_seg.ident.name;
+fn has_same_non_ref_symbols(pats: &[Pat<'_>], exprs: &[Expr<'_>]) -> bool {
+    if pats.len() != exprs.len() {
+        return false;
+    }
+
+    for i in 0..pats.len() {
+        if !pat_same_as_expr(&pats[i], &exprs[i]) {
+            return false;
         }
     }
 
-    false
+    true
 }
diff --git a/tests/ui/needless_match.fixed b/tests/ui/needless_match.fixed
index ece18ad737f..6a518f83925 100644
--- a/tests/ui/needless_match.fixed
+++ b/tests/ui/needless_match.fixed
@@ -4,38 +4,35 @@
 #![allow(dead_code)]
 
 #[derive(Clone, Copy)]
-enum Choice {
+enum Simple {
     A,
     B,
     C,
     D,
 }
 
-#[allow(unused_mut)]
 fn useless_match() {
-    let mut i = 10;
+    let i = 10;
     let _: i32 = i;
-    let _: i32 = i;
-    let mut _i_mut = i;
-
     let s = "test";
     let _: &str = s;
 }
 
-fn custom_type_match(se: Choice) {
-    let _: Choice = se;
+fn custom_type_match() {
+    let se = Simple::A;
+    let _: Simple = se;
     // Don't trigger
-    let _: Choice = match se {
-        Choice::A => Choice::A,
-        Choice::B => Choice::B,
-        _ => Choice::C,
+    let _: Simple = match se {
+        Simple::A => Simple::A,
+        Simple::B => Simple::B,
+        _ => Simple::C,
     };
     // Mingled, don't trigger
-    let _: Choice = match se {
-        Choice::A => Choice::B,
-        Choice::B => Choice::C,
-        Choice::C => Choice::D,
-        Choice::D => Choice::A,
+    let _: Simple = match se {
+        Simple::A => Simple::B,
+        Simple::B => Simple::C,
+        Simple::C => Simple::D,
+        Simple::D => Simple::A,
     };
 }
 
@@ -55,29 +52,96 @@ fn func_ret_err<T>(err: T) -> Result<i32, T> {
 fn result_match() {
     let _: Result<i32, i32> = Ok(1);
     let _: Result<i32, i32> = func_ret_err(0_i32);
+    // as ref, don't trigger
+    let res = &func_ret_err(0_i32);
+    let _: Result<&i32, &i32> = match *res {
+        Ok(ref x) => Ok(x),
+        Err(ref x) => Err(x),
+    };
 }
 
 fn if_let_option() -> Option<i32> {
     Some(1)
 }
 
-fn if_let_result(x: Result<(), i32>) {
-    let _: Result<(), i32> = x;
-    let _: Result<(), i32> = x;
+fn if_let_result() {
+    let x: Result<i32, i32> = Ok(1);
+    let _: Result<i32, i32> = x;
+    let _: Result<i32, i32> = x;
     // Input type mismatch, don't trigger
-    let _: Result<(), i32> = if let Err(e) = Ok(1) { Err(e) } else { x };
+    let _: Result<i32, i32> = if let Err(e) = Ok(1) { Err(e) } else { x };
 }
 
-fn if_let_custom_enum(x: Choice) {
-    let _: Choice = x;
+fn if_let_custom_enum(x: Simple) {
+    let _: Simple = x;
+
     // Don't trigger
-    let _: Choice = if let Choice::A = x {
-        Choice::A
+    let _: Simple = if let Simple::A = x {
+        Simple::A
     } else if true {
-        Choice::B
+        Simple::B
     } else {
         x
     };
 }
 
+mod issue8542 {
+    #[derive(Clone, Copy)]
+    enum E {
+        VariantA(u8, u8),
+        VariantB(u8, bool),
+    }
+
+    enum Complex {
+        A(u8),
+        B(u8, bool),
+        C(u8, i32, f64),
+        D(E, bool),
+    }
+
+    fn match_test() {
+        let ce = Complex::B(8, false);
+        let aa = 0_u8;
+        let bb = false;
+
+        let _: Complex = ce;
+
+        // Don't trigger
+        let _: Complex = match ce {
+            Complex::A(_) => Complex::A(aa),
+            Complex::B(_, b) => Complex::B(aa, b),
+            Complex::C(_, b, _) => Complex::C(aa, b, 64_f64),
+            Complex::D(e, b) => Complex::D(e, b),
+        };
+
+        // Don't trigger
+        let _: Complex = match ce {
+            Complex::A(a) => Complex::A(a),
+            Complex::B(a, _) => Complex::B(a, bb),
+            Complex::C(a, _, _) => Complex::C(a, 32_i32, 64_f64),
+            _ => ce,
+        };
+    }
+
+    fn if_let_test() {
+        fn do_something() {}
+
+        // Don't trigger
+        let _ = if let Some(a) = Some(1) {
+            Some(a)
+        } else {
+            do_something();
+            None
+        };
+
+        // Don't trigger
+        let _ = if let Some(a) = Some(1) {
+            do_something();
+            Some(a)
+        } else {
+            None
+        };
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/needless_match.rs b/tests/ui/needless_match.rs
index 36649de35a6..ffc6a291a15 100644
--- a/tests/ui/needless_match.rs
+++ b/tests/ui/needless_match.rs
@@ -4,33 +4,21 @@
 #![allow(dead_code)]
 
 #[derive(Clone, Copy)]
-enum Choice {
+enum Simple {
     A,
     B,
     C,
     D,
 }
 
-#[allow(unused_mut)]
 fn useless_match() {
-    let mut i = 10;
+    let i = 10;
     let _: i32 = match i {
         0 => 0,
         1 => 1,
         2 => 2,
         _ => i,
     };
-    let _: i32 = match i {
-        0 => 0,
-        1 => 1,
-        ref i => *i,
-    };
-    let mut _i_mut = match i {
-        0 => 0,
-        1 => 1,
-        ref mut i => *i,
-    };
-
     let s = "test";
     let _: &str = match s {
         "a" => "a",
@@ -39,25 +27,26 @@ fn useless_match() {
     };
 }
 
-fn custom_type_match(se: Choice) {
-    let _: Choice = match se {
-        Choice::A => Choice::A,
-        Choice::B => Choice::B,
-        Choice::C => Choice::C,
-        Choice::D => Choice::D,
+fn custom_type_match() {
+    let se = Simple::A;
+    let _: Simple = match se {
+        Simple::A => Simple::A,
+        Simple::B => Simple::B,
+        Simple::C => Simple::C,
+        Simple::D => Simple::D,
     };
     // Don't trigger
-    let _: Choice = match se {
-        Choice::A => Choice::A,
-        Choice::B => Choice::B,
-        _ => Choice::C,
+    let _: Simple = match se {
+        Simple::A => Simple::A,
+        Simple::B => Simple::B,
+        _ => Simple::C,
     };
     // Mingled, don't trigger
-    let _: Choice = match se {
-        Choice::A => Choice::B,
-        Choice::B => Choice::C,
-        Choice::C => Choice::D,
-        Choice::D => Choice::A,
+    let _: Simple = match se {
+        Simple::A => Simple::B,
+        Simple::B => Simple::C,
+        Simple::C => Simple::D,
+        Simple::D => Simple::A,
     };
 }
 
@@ -86,37 +75,110 @@ fn result_match() {
         Err(err) => Err(err),
         Ok(a) => Ok(a),
     };
+    // as ref, don't trigger
+    let res = &func_ret_err(0_i32);
+    let _: Result<&i32, &i32> = match *res {
+        Ok(ref x) => Ok(x),
+        Err(ref x) => Err(x),
+    };
 }
 
 fn if_let_option() -> Option<i32> {
     if let Some(a) = Some(1) { Some(a) } else { None }
 }
 
-fn if_let_result(x: Result<(), i32>) {
-    let _: Result<(), i32> = if let Err(e) = x { Err(e) } else { x };
-    let _: Result<(), i32> = if let Ok(val) = x { Ok(val) } else { x };
+fn if_let_result() {
+    let x: Result<i32, i32> = Ok(1);
+    let _: Result<i32, i32> = if let Err(e) = x { Err(e) } else { x };
+    let _: Result<i32, i32> = if let Ok(val) = x { Ok(val) } else { x };
     // Input type mismatch, don't trigger
-    let _: Result<(), i32> = if let Err(e) = Ok(1) { Err(e) } else { x };
+    let _: Result<i32, i32> = if let Err(e) = Ok(1) { Err(e) } else { x };
 }
 
-fn if_let_custom_enum(x: Choice) {
-    let _: Choice = if let Choice::A = x {
-        Choice::A
-    } else if let Choice::B = x {
-        Choice::B
-    } else if let Choice::C = x {
-        Choice::C
+fn if_let_custom_enum(x: Simple) {
+    let _: Simple = if let Simple::A = x {
+        Simple::A
+    } else if let Simple::B = x {
+        Simple::B
+    } else if let Simple::C = x {
+        Simple::C
     } else {
         x
     };
+
     // Don't trigger
-    let _: Choice = if let Choice::A = x {
-        Choice::A
+    let _: Simple = if let Simple::A = x {
+        Simple::A
     } else if true {
-        Choice::B
+        Simple::B
     } else {
         x
     };
 }
 
+mod issue8542 {
+    #[derive(Clone, Copy)]
+    enum E {
+        VariantA(u8, u8),
+        VariantB(u8, bool),
+    }
+
+    enum Complex {
+        A(u8),
+        B(u8, bool),
+        C(u8, i32, f64),
+        D(E, bool),
+    }
+
+    fn match_test() {
+        let ce = Complex::B(8, false);
+        let aa = 0_u8;
+        let bb = false;
+
+        let _: Complex = match ce {
+            Complex::A(a) => Complex::A(a),
+            Complex::B(a, b) => Complex::B(a, b),
+            Complex::C(a, b, c) => Complex::C(a, b, c),
+            Complex::D(E::VariantA(ea, eb), b) => Complex::D(E::VariantA(ea, eb), b),
+            Complex::D(E::VariantB(ea, eb), b) => Complex::D(E::VariantB(ea, eb), b),
+        };
+
+        // Don't trigger
+        let _: Complex = match ce {
+            Complex::A(_) => Complex::A(aa),
+            Complex::B(_, b) => Complex::B(aa, b),
+            Complex::C(_, b, _) => Complex::C(aa, b, 64_f64),
+            Complex::D(e, b) => Complex::D(e, b),
+        };
+
+        // Don't trigger
+        let _: Complex = match ce {
+            Complex::A(a) => Complex::A(a),
+            Complex::B(a, _) => Complex::B(a, bb),
+            Complex::C(a, _, _) => Complex::C(a, 32_i32, 64_f64),
+            _ => ce,
+        };
+    }
+
+    fn if_let_test() {
+        fn do_something() {}
+
+        // Don't trigger
+        let _ = if let Some(a) = Some(1) {
+            Some(a)
+        } else {
+            do_something();
+            None
+        };
+
+        // Don't trigger
+        let _ = if let Some(a) = Some(1) {
+            do_something();
+            Some(a)
+        } else {
+            None
+        };
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/needless_match.stderr b/tests/ui/needless_match.stderr
index ad1525406ad..67bd84d6bbc 100644
--- a/tests/ui/needless_match.stderr
+++ b/tests/ui/needless_match.stderr
@@ -1,5 +1,5 @@
 error: this match expression is unnecessary
-  --> $DIR/needless_match.rs:17:18
+  --> $DIR/needless_match.rs:16:18
    |
 LL |       let _: i32 = match i {
    |  __________________^
@@ -13,29 +13,7 @@ LL | |     };
    = note: `-D clippy::needless-match` implied by `-D warnings`
 
 error: this match expression is unnecessary
-  --> $DIR/needless_match.rs:23:18
-   |
-LL |       let _: i32 = match i {
-   |  __________________^
-LL | |         0 => 0,
-LL | |         1 => 1,
-LL | |         ref i => *i,
-LL | |     };
-   | |_____^ help: replace it with: `i`
-
-error: this match expression is unnecessary
-  --> $DIR/needless_match.rs:28:22
-   |
-LL |       let mut _i_mut = match i {
-   |  ______________________^
-LL | |         0 => 0,
-LL | |         1 => 1,
-LL | |         ref mut i => *i,
-LL | |     };
-   | |_____^ help: replace it with: `i`
-
-error: this match expression is unnecessary
-  --> $DIR/needless_match.rs:35:19
+  --> $DIR/needless_match.rs:23:19
    |
 LL |       let _: &str = match s {
    |  ___________________^
@@ -46,19 +24,19 @@ LL | |     };
    | |_____^ help: replace it with: `s`
 
 error: this match expression is unnecessary
-  --> $DIR/needless_match.rs:43:21
+  --> $DIR/needless_match.rs:32:21
    |
-LL |       let _: Choice = match se {
+LL |       let _: Simple = match se {
    |  _____________________^
-LL | |         Choice::A => Choice::A,
-LL | |         Choice::B => Choice::B,
-LL | |         Choice::C => Choice::C,
-LL | |         Choice::D => Choice::D,
+LL | |         Simple::A => Simple::A,
+LL | |         Simple::B => Simple::B,
+LL | |         Simple::C => Simple::C,
+LL | |         Simple::D => Simple::D,
 LL | |     };
    | |_____^ help: replace it with: `se`
 
 error: this match expression is unnecessary
-  --> $DIR/needless_match.rs:65:26
+  --> $DIR/needless_match.rs:54:26
    |
 LL |       let _: Option<i32> = match x {
    |  __________________________^
@@ -68,7 +46,7 @@ LL | |     };
    | |_____^ help: replace it with: `x`
 
 error: this match expression is unnecessary
-  --> $DIR/needless_match.rs:81:31
+  --> $DIR/needless_match.rs:70:31
    |
 LL |       let _: Result<i32, i32> = match Ok(1) {
    |  _______________________________^
@@ -78,7 +56,7 @@ LL | |     };
    | |_____^ help: replace it with: `Ok(1)`
 
 error: this match expression is unnecessary
-  --> $DIR/needless_match.rs:85:31
+  --> $DIR/needless_match.rs:74:31
    |
 LL |       let _: Result<i32, i32> = match func_ret_err(0_i32) {
    |  _______________________________^
@@ -88,35 +66,48 @@ LL | |     };
    | |_____^ help: replace it with: `func_ret_err(0_i32)`
 
 error: this if-let expression is unnecessary
-  --> $DIR/needless_match.rs:92:5
+  --> $DIR/needless_match.rs:87:5
    |
 LL |     if let Some(a) = Some(1) { Some(a) } else { None }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `Some(1)`
 
 error: this if-let expression is unnecessary
-  --> $DIR/needless_match.rs:96:30
+  --> $DIR/needless_match.rs:92:31
    |
-LL |     let _: Result<(), i32> = if let Err(e) = x { Err(e) } else { x };
-   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `x`
+LL |     let _: Result<i32, i32> = if let Err(e) = x { Err(e) } else { x };
+   |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `x`
 
 error: this if-let expression is unnecessary
-  --> $DIR/needless_match.rs:97:30
+  --> $DIR/needless_match.rs:93:31
    |
-LL |     let _: Result<(), i32> = if let Ok(val) = x { Ok(val) } else { x };
-   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `x`
+LL |     let _: Result<i32, i32> = if let Ok(val) = x { Ok(val) } else { x };
+   |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `x`
 
 error: this if-let expression is unnecessary
-  --> $DIR/needless_match.rs:103:21
+  --> $DIR/needless_match.rs:99:21
    |
-LL |       let _: Choice = if let Choice::A = x {
+LL |       let _: Simple = if let Simple::A = x {
    |  _____________________^
-LL | |         Choice::A
-LL | |     } else if let Choice::B = x {
-LL | |         Choice::B
+LL | |         Simple::A
+LL | |     } else if let Simple::B = x {
+LL | |         Simple::B
 ...  |
 LL | |         x
 LL | |     };
    | |_____^ help: replace it with: `x`
 
-error: aborting due to 12 previous errors
+error: this match expression is unnecessary
+  --> $DIR/needless_match.rs:138:26
+   |
+LL |           let _: Complex = match ce {
+   |  __________________________^
+LL | |             Complex::A(a) => Complex::A(a),
+LL | |             Complex::B(a, b) => Complex::B(a, b),
+LL | |             Complex::C(a, b, c) => Complex::C(a, b, c),
+LL | |             Complex::D(E::VariantA(ea, eb), b) => Complex::D(E::VariantA(ea, eb), b),
+LL | |             Complex::D(E::VariantB(ea, eb), b) => Complex::D(E::VariantB(ea, eb), b),
+LL | |         };
+   | |_________^ help: replace it with: `ce`
+
+error: aborting due to 11 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 851e715e5a7ac21007b9491c81916e854fbab22c Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Wed, 16 Mar 2022 12:00:27 -0400
Subject: Don't lint `ptr_arg` on `&mut Cow<_>`

---
 clippy_lints/src/ptr.rs | 2 +-
 tests/ui/ptr_arg.rs     | 7 +++++++
 2 files changed, 8 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs
index 9c776437d7f..ba1997e70e1 100644
--- a/clippy_lints/src/ptr.rs
+++ b/clippy_lints/src/ptr.rs
@@ -436,7 +436,7 @@ fn check_fn_args<'cx, 'tcx: 'cx>(
                             DerefTy::Path,
                             None,
                         ),
-                        Some(sym::Cow) => {
+                        Some(sym::Cow) if mutability == Mutability::Not => {
                             let ty_name = name.args
                                 .and_then(|args| {
                                     args.args.iter().find_map(|a| match a {
diff --git a/tests/ui/ptr_arg.rs b/tests/ui/ptr_arg.rs
index 97990fedd51..03dd938a233 100644
--- a/tests/ui/ptr_arg.rs
+++ b/tests/ui/ptr_arg.rs
@@ -194,3 +194,10 @@ fn two_vecs(a: &mut Vec<u32>, b: &mut Vec<u32>) {
     a.push(0);
     b.push(1);
 }
+
+// Issue #8495
+fn cow_conditional_to_mut(a: &mut Cow<str>) {
+    if a.is_empty() {
+        a.to_mut().push_str("foo");
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 8e5208cbffd5ff43f80097d74a8802aad1d6190b Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Wed, 16 Mar 2022 12:54:32 -0400
Subject: Don't lint `transmute_undefined_repr` when changing the type of
 generic params

---
 .../src/transmute/transmute_undefined_repr.rs      | 64 +++++++++++++++-------
 tests/ui/transmute_undefined_repr.rs               | 32 +++++++++++
 tests/ui/transmute_undefined_repr.stderr           | 34 +++++++++---
 3 files changed, 102 insertions(+), 28 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/transmute/transmute_undefined_repr.rs b/clippy_lints/src/transmute/transmute_undefined_repr.rs
index 4922c40bcef..f5e21267a89 100644
--- a/clippy_lints/src/transmute/transmute_undefined_repr.rs
+++ b/clippy_lints/src/transmute/transmute_undefined_repr.rs
@@ -3,7 +3,7 @@ use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::ty::is_c_void;
 use rustc_hir::Expr;
 use rustc_lint::LateContext;
-use rustc_middle::ty::subst::Subst;
+use rustc_middle::ty::subst::{Subst, SubstsRef};
 use rustc_middle::ty::{self, IntTy, Ty, TypeAndMut, UintTy};
 use rustc_span::Span;
 
@@ -127,6 +127,17 @@ pub(super) fn check<'tcx>(
             } => match (reduce_ty(cx, from_sub_ty), reduce_ty(cx, to_sub_ty)) {
                 (ReducedTy::TypeErasure, _) | (_, ReducedTy::TypeErasure) => return false,
                 (ReducedTy::UnorderedFields(from_ty), ReducedTy::UnorderedFields(to_ty)) if from_ty != to_ty => {
+                    let same_adt_did = if let (ty::Adt(from_def, from_subs), ty::Adt(to_def, to_subs))
+                        = (from_ty.kind(), to_ty.kind())
+                        && from_def == to_def
+                    {
+                        if same_except_params(from_subs, to_subs) {
+                            return false;
+                        }
+                        Some(from_def.did())
+                    } else {
+                        None
+                    };
                     span_lint_and_then(
                         cx,
                         TRANSMUTE_UNDEFINED_REPR,
@@ -136,21 +147,17 @@ pub(super) fn check<'tcx>(
                             from_ty_orig, to_ty_orig
                         ),
                         |diag| {
-                            if_chain! {
-                                if let (Some(from_def), Some(to_def)) = (from_ty.ty_adt_def(), to_ty.ty_adt_def());
-                                if from_def == to_def;
-                                then {
-                                    diag.note(&format!(
-                                        "two instances of the same generic type (`{}`) may have different layouts",
-                                        cx.tcx.item_name(from_def.did())
-                                    ));
-                                } else {
-                                    if from_ty_orig.peel_refs() != from_ty {
-                                        diag.note(&format!("the contained type `{}` has an undefined layout", from_ty));
-                                    }
-                                    if to_ty_orig.peel_refs() != to_ty {
-                                        diag.note(&format!("the contained type `{}` has an undefined layout", to_ty));
-                                    }
+                            if let Some(same_adt_did) = same_adt_did {
+                                diag.note(&format!(
+                                    "two instances of the same generic type (`{}`) may have different layouts",
+                                    cx.tcx.item_name(same_adt_did)
+                                ));
+                            } else {
+                                if from_ty_orig.peel_refs() != from_ty {
+                                    diag.note(&format!("the contained type `{}` has an undefined layout", from_ty));
+                                }
+                                if to_ty_orig.peel_refs() != to_ty {
+                                    diag.note(&format!("the contained type `{}` has an undefined layout", to_ty));
                                 }
                             }
                         },
@@ -197,10 +204,13 @@ pub(super) fn check<'tcx>(
                     continue;
                 },
                 (
-                    ReducedTy::OrderedFields(_) | ReducedTy::Ref(_) | ReducedTy::Other(_),
-                    ReducedTy::OrderedFields(_) | ReducedTy::Ref(_) | ReducedTy::Other(_),
+                    ReducedTy::OrderedFields(_) | ReducedTy::Ref(_) | ReducedTy::Other(_) | ReducedTy::Param,
+                    ReducedTy::OrderedFields(_) | ReducedTy::Ref(_) | ReducedTy::Other(_) | ReducedTy::Param,
                 )
-                | (ReducedTy::UnorderedFields(_), ReducedTy::UnorderedFields(_)) => break,
+                | (
+                    ReducedTy::UnorderedFields(_) | ReducedTy::Param,
+                    ReducedTy::UnorderedFields(_) | ReducedTy::Param,
+                ) => break,
             },
         }
     }
@@ -264,6 +274,8 @@ enum ReducedTy<'tcx> {
     UnorderedFields(Ty<'tcx>),
     /// The type is a reference to the contained type.
     Ref(Ty<'tcx>),
+    /// The type is a generic parameter.
+    Param,
     /// Any other type.
     Other(Ty<'tcx>),
 }
@@ -317,6 +329,7 @@ fn reduce_ty<'tcx>(cx: &LateContext<'tcx>, mut ty: Ty<'tcx>) -> ReducedTy<'tcx>
             ty::Foreign(_) => ReducedTy::TypeErasure,
             ty::Ref(_, ty, _) => ReducedTy::Ref(ty),
             ty::RawPtr(ty) => ReducedTy::Ref(ty.ty),
+            ty::Param(_) => ReducedTy::Param,
             _ => ReducedTy::Other(ty),
         };
     }
@@ -344,3 +357,16 @@ fn is_size_pair(ty: Ty<'_>) -> bool {
         false
     }
 }
+
+fn same_except_params(subs1: SubstsRef<'_>, subs2: SubstsRef<'_>) -> bool {
+    // TODO: check const parameters as well. Currently this will consider `Array<5>` the same as
+    // `Array<6>`
+    for (ty1, ty2) in subs1.types().zip(subs2.types()).filter(|(ty1, ty2)| ty1 != ty2) {
+        match (ty1.kind(), ty2.kind()) {
+            (ty::Param(_), _) | (_, ty::Param(_)) => (),
+            (ty::Adt(adt1, subs1), ty::Adt(adt2, subs2)) if adt1 == adt2 && same_except_params(subs1, subs2) => (),
+            _ => return false,
+        }
+    }
+    true
+}
diff --git a/tests/ui/transmute_undefined_repr.rs b/tests/ui/transmute_undefined_repr.rs
index 7cc03b89fe0..b06ed4a9173 100644
--- a/tests/ui/transmute_undefined_repr.rs
+++ b/tests/ui/transmute_undefined_repr.rs
@@ -1,6 +1,7 @@
 #![warn(clippy::transmute_undefined_repr)]
 #![allow(clippy::unit_arg, clippy::transmute_ptr_to_ref)]
 
+use core::any::TypeId;
 use core::ffi::c_void;
 use core::mem::{size_of, transmute, MaybeUninit};
 
@@ -110,3 +111,34 @@ fn main() {
         let _: Ty<&[u32]> = transmute::<&[u32], _>(value::<&Vec<u32>>()); // Ok
     }
 }
+
+fn _with_generics<T: 'static, U: 'static>() {
+    if TypeId::of::<T>() != TypeId::of::<u32>() || TypeId::of::<T>() != TypeId::of::<U>() {
+        return;
+    }
+    unsafe {
+        let _: &u32 = transmute(value::<&T>()); // Ok
+        let _: &T = transmute(value::<&u32>()); // Ok
+
+        let _: Vec<U> = transmute(value::<Vec<T>>()); // Ok
+        let _: Vec<T> = transmute(value::<Vec<U>>()); // Ok
+
+        let _: Ty<&u32> = transmute(value::<&T>()); // Ok
+        let _: Ty<&T> = transmute(value::<&u32>()); // Ok
+
+        let _: Vec<u32> = transmute(value::<Vec<T>>()); // Ok
+        let _: Vec<T> = transmute(value::<Vec<u32>>()); // Ok
+
+        let _: &Ty2<u32, u32> = transmute(value::<&Ty2<T, U>>()); // Ok
+        let _: &Ty2<T, U> = transmute(value::<&Ty2<u32, u32>>()); // Ok
+
+        let _: Vec<Vec<u32>> = transmute(value::<Vec<Vec<T>>>()); // Ok
+        let _: Vec<Vec<T>> = transmute(value::<Vec<Vec<u32>>>()); // Ok
+
+        let _: Vec<Ty2<T, u32>> = transmute(value::<Vec<Ty2<U, i32>>>()); // Err
+        let _: Vec<Ty2<U, i32>> = transmute(value::<Vec<Ty2<T, u32>>>()); // Err
+
+        let _: *const u32 = transmute(value::<Box<T>>()); // Ok
+        let _: Box<T> = transmute(value::<*const u32>()); // Ok
+    }
+}
diff --git a/tests/ui/transmute_undefined_repr.stderr b/tests/ui/transmute_undefined_repr.stderr
index 42d544fc954..28bfba6c757 100644
--- a/tests/ui/transmute_undefined_repr.stderr
+++ b/tests/ui/transmute_undefined_repr.stderr
@@ -1,5 +1,5 @@
 error: transmute from `Ty2<u32, i32>` which has an undefined layout
-  --> $DIR/transmute_undefined_repr.rs:26:33
+  --> $DIR/transmute_undefined_repr.rs:27:33
    |
 LL |         let _: Ty2C<u32, i32> = transmute(value::<Ty2<u32, i32>>()); // Lint, Ty2 is unordered
    |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -7,13 +7,13 @@ LL |         let _: Ty2C<u32, i32> = transmute(value::<Ty2<u32, i32>>()); // Lin
    = note: `-D clippy::transmute-undefined-repr` implied by `-D warnings`
 
 error: transmute into `Ty2<u32, i32>` which has an undefined layout
-  --> $DIR/transmute_undefined_repr.rs:27:32
+  --> $DIR/transmute_undefined_repr.rs:28:32
    |
 LL |         let _: Ty2<u32, i32> = transmute(value::<Ty2C<u32, i32>>()); // Lint, Ty2 is unordered
    |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: transmute from `Ty<Ty2<u32, i32>>` to `Ty2<u32, f32>`, both of which have an undefined layout
-  --> $DIR/transmute_undefined_repr.rs:32:32
+  --> $DIR/transmute_undefined_repr.rs:33:32
    |
 LL |         let _: Ty2<u32, f32> = transmute(value::<Ty<Ty2<u32, i32>>>()); // Lint, different Ty2 instances
    |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -21,7 +21,7 @@ LL |         let _: Ty2<u32, f32> = transmute(value::<Ty<Ty2<u32, i32>>>()); //
    = note: two instances of the same generic type (`Ty2`) may have different layouts
 
 error: transmute from `Ty2<u32, f32>` to `Ty<Ty2<u32, i32>>`, both of which have an undefined layout
-  --> $DIR/transmute_undefined_repr.rs:33:36
+  --> $DIR/transmute_undefined_repr.rs:34:36
    |
 LL |         let _: Ty<Ty2<u32, i32>> = transmute(value::<Ty2<u32, f32>>()); // Lint, different Ty2 instances
    |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -29,7 +29,7 @@ LL |         let _: Ty<Ty2<u32, i32>> = transmute(value::<Ty2<u32, f32>>()); //
    = note: two instances of the same generic type (`Ty2`) may have different layouts
 
 error: transmute from `Ty<&Ty2<u32, i32>>` to `&Ty2<u32, f32>`, both of which have an undefined layout
-  --> $DIR/transmute_undefined_repr.rs:38:33
+  --> $DIR/transmute_undefined_repr.rs:39:33
    |
 LL |         let _: &Ty2<u32, f32> = transmute(value::<Ty<&Ty2<u32, i32>>>()); // Lint, different Ty2 instances
    |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -37,7 +37,7 @@ LL |         let _: &Ty2<u32, f32> = transmute(value::<Ty<&Ty2<u32, i32>>>()); /
    = note: two instances of the same generic type (`Ty2`) may have different layouts
 
 error: transmute from `&Ty2<u32, f32>` to `Ty<&Ty2<u32, i32>>`, both of which have an undefined layout
-  --> $DIR/transmute_undefined_repr.rs:39:37
+  --> $DIR/transmute_undefined_repr.rs:40:37
    |
 LL |         let _: Ty<&Ty2<u32, i32>> = transmute(value::<&Ty2<u32, f32>>()); // Lint, different Ty2 instances
    |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -45,7 +45,7 @@ LL |         let _: Ty<&Ty2<u32, i32>> = transmute(value::<&Ty2<u32, f32>>()); /
    = note: two instances of the same generic type (`Ty2`) may have different layouts
 
 error: transmute from `std::boxed::Box<Ty2<u32, u32>>` to `&mut Ty2<u32, f32>`, both of which have an undefined layout
-  --> $DIR/transmute_undefined_repr.rs:56:45
+  --> $DIR/transmute_undefined_repr.rs:57:45
    |
 LL |         let _: &'static mut Ty2<u32, f32> = transmute(value::<Box<Ty2<u32, u32>>>()); // Lint, different Ty2 instances
    |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -53,12 +53,28 @@ LL |         let _: &'static mut Ty2<u32, f32> = transmute(value::<Box<Ty2<u32,
    = note: two instances of the same generic type (`Ty2`) may have different layouts
 
 error: transmute from `&mut Ty2<u32, f32>` to `std::boxed::Box<Ty2<u32, u32>>`, both of which have an undefined layout
-  --> $DIR/transmute_undefined_repr.rs:57:37
+  --> $DIR/transmute_undefined_repr.rs:58:37
    |
 LL |         let _: Box<Ty2<u32, u32>> = transmute(value::<&'static mut Ty2<u32, f32>>()); // Lint, different Ty2 instances
    |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: two instances of the same generic type (`Ty2`) may have different layouts
 
-error: aborting due to 8 previous errors
+error: transmute from `std::vec::Vec<Ty2<U, i32>>` to `std::vec::Vec<Ty2<T, u32>>`, both of which have an undefined layout
+  --> $DIR/transmute_undefined_repr.rs:138:35
+   |
+LL |         let _: Vec<Ty2<T, u32>> = transmute(value::<Vec<Ty2<U, i32>>>()); // Err
+   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: two instances of the same generic type (`Vec`) may have different layouts
+
+error: transmute from `std::vec::Vec<Ty2<T, u32>>` to `std::vec::Vec<Ty2<U, i32>>`, both of which have an undefined layout
+  --> $DIR/transmute_undefined_repr.rs:139:35
+   |
+LL |         let _: Vec<Ty2<U, i32>> = transmute(value::<Vec<Ty2<T, u32>>>()); // Err
+   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: two instances of the same generic type (`Vec`) may have different layouts
+
+error: aborting due to 10 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From b37317b028cd0d4b60126e0bcf1402e60018f891 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Thu, 6 Jan 2022 02:54:35 -0500
Subject: Check if there are any overlapping patterns between equal arm bodies
 in `match_same_arm`

---
 clippy_lints/src/matches/match_same_arms.rs | 253 ++++++++++++++++++++++++++--
 tests/ui/match_same_arms2.rs                |  13 ++
 2 files changed, 256 insertions(+), 10 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/match_same_arms.rs b/clippy_lints/src/matches/match_same_arms.rs
index d11dda57e6f..6617cf4e47f 100644
--- a/clippy_lints/src/matches/match_same_arms.rs
+++ b/clippy_lints/src/matches/match_same_arms.rs
@@ -1,19 +1,53 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet;
 use clippy_utils::{path_to_local, search_same, SpanlessEq, SpanlessHash};
-use rustc_hir::{Arm, Expr, HirId, HirIdMap, HirIdSet, Pat, PatKind};
+use rustc_ast::ast::LitKind;
+use rustc_hir::def_id::DefId;
+use rustc_hir::{Arm, Expr, ExprKind, HirId, HirIdMap, HirIdSet, Pat, PatKind, RangeEnd};
 use rustc_lint::LateContext;
+use rustc_span::Symbol;
 use std::collections::hash_map::Entry;
 
 use super::MATCH_SAME_ARMS;
 
-pub(crate) fn check<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>]) {
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>]) {
     let hash = |&(_, arm): &(usize, &Arm<'_>)| -> u64 {
         let mut h = SpanlessHash::new(cx);
         h.hash_expr(arm.body);
         h.finish()
     };
 
+    let resolved_pats: Vec<_> = arms.iter().map(|a| ResolvedPat::from_pat(cx, a.pat)).collect();
+
+    // The furthast forwards a pattern can move without semantic changes
+    let forwards_blocking_idxs: Vec<_> = resolved_pats
+        .iter()
+        .enumerate()
+        .map(|(i, pat)| {
+            resolved_pats[i + 1..]
+                .iter()
+                .enumerate()
+                .find_map(|(j, other)| pat.can_also_match(other).then(|| i + 1 + j))
+                .unwrap_or(resolved_pats.len())
+        })
+        .collect();
+
+    // The furthast backwards a pattern can move without semantic changes
+    let backwards_blocking_idxs: Vec<_> = resolved_pats
+        .iter()
+        .enumerate()
+        .map(|(i, pat)| {
+            resolved_pats[..i]
+                .iter()
+                .enumerate()
+                .rev()
+                .zip(forwards_blocking_idxs[..i].iter().copied().rev())
+                .skip_while(|&(_, forward_block)| forward_block > i)
+                .find_map(|((j, other), forward_block)| (forward_block == i || pat.can_also_match(other)).then(|| j))
+                .unwrap_or(0)
+        })
+        .collect();
+
     let eq = |&(lindex, lhs): &(usize, &Arm<'_>), &(rindex, rhs): &(usize, &Arm<'_>)| -> bool {
         let min_index = usize::min(lindex, rindex);
         let max_index = usize::max(lindex, rindex);
@@ -42,14 +76,16 @@ pub(crate) fn check<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>]) {
             }
         };
         // Arms with a guard are ignored, those can’t always be merged together
-        // This is also the case for arms in-between each there is an arm with a guard
-        (min_index..=max_index).all(|index| arms[index].guard.is_none())
-            && SpanlessEq::new(cx)
-                .expr_fallback(eq_fallback)
-                .eq_expr(lhs.body, rhs.body)
-            // these checks could be removed to allow unused bindings
-            && bindings_eq(lhs.pat, local_map.keys().copied().collect())
-            && bindings_eq(rhs.pat, local_map.values().copied().collect())
+        // If both arms overlap with an arm in between then these can't be merged either.
+        !(backwards_blocking_idxs[max_index] > min_index && forwards_blocking_idxs[min_index] < max_index)
+                && lhs.guard.is_none()
+                && rhs.guard.is_none()
+                && SpanlessEq::new(cx)
+                    .expr_fallback(eq_fallback)
+                    .eq_expr(lhs.body, rhs.body)
+                // these checks could be removed to allow unused bindings
+                && bindings_eq(lhs.pat, local_map.keys().copied().collect())
+                && bindings_eq(rhs.pat, local_map.values().copied().collect())
     };
 
     let indexed_arms: Vec<(usize, &Arm<'_>)> = arms.iter().enumerate().collect();
@@ -92,6 +128,203 @@ pub(crate) fn check<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>]) {
     }
 }
 
+#[derive(Debug)]
+enum ResolvedPat<'hir> {
+    Wild,
+    Struct(Option<DefId>, Vec<(Symbol, ResolvedPat<'hir>)>),
+    Sequence(Option<DefId>, Vec<ResolvedPat<'hir>>, Option<usize>),
+    Or(Vec<ResolvedPat<'hir>>),
+    Path(Option<DefId>),
+    LitStr(Symbol),
+    LitBytes(&'hir [u8]),
+    LitInt(u128),
+    LitBool(bool),
+    Range(PatRange),
+}
+
+#[derive(Debug)]
+struct PatRange {
+    start: u128,
+    end: u128,
+    bounds: RangeEnd,
+}
+impl PatRange {
+    fn contains(&self, x: u128) -> bool {
+        x >= self.start
+            && match self.bounds {
+                RangeEnd::Included => x <= self.end,
+                RangeEnd::Excluded => x < self.end,
+            }
+    }
+
+    fn overlaps(&self, other: &Self) -> bool {
+        !(self.is_empty() || other.is_empty())
+            && match self.bounds {
+                RangeEnd::Included => self.end >= other.start,
+                RangeEnd::Excluded => self.end > other.start,
+            }
+            && match other.bounds {
+                RangeEnd::Included => self.start <= other.end,
+                RangeEnd::Excluded => self.start < other.end,
+            }
+    }
+
+    fn is_empty(&self) -> bool {
+        match self.bounds {
+            RangeEnd::Included => false,
+            RangeEnd::Excluded => self.start == self.end,
+        }
+    }
+}
+
+impl<'hir> ResolvedPat<'hir> {
+    fn from_pat(cx: &LateContext<'_>, pat: &'hir Pat<'_>) -> Self {
+        match pat.kind {
+            PatKind::Wild | PatKind::Binding(.., None) => Self::Wild,
+            PatKind::Binding(.., Some(pat)) | PatKind::Box(pat) | PatKind::Ref(pat, _) => Self::from_pat(cx, pat),
+            PatKind::Struct(ref path, fields, _) => {
+                let mut fields: Vec<_> = fields
+                    .iter()
+                    .map(|f| (f.ident.name, Self::from_pat(cx, f.pat)))
+                    .collect();
+                fields.sort_by_key(|&(name, _)| name);
+                Self::Struct(cx.qpath_res(path, pat.hir_id).opt_def_id(), fields)
+            },
+            PatKind::TupleStruct(ref path, pats, wild_idx) => Self::Sequence(
+                cx.qpath_res(path, pat.hir_id).opt_def_id(),
+                pats.iter().map(|pat| Self::from_pat(cx, pat)).collect(),
+                wild_idx,
+            ),
+            PatKind::Or(pats) => Self::Or(pats.iter().map(|pat| Self::from_pat(cx, pat)).collect()),
+            PatKind::Path(ref path) => Self::Path(cx.qpath_res(path, pat.hir_id).opt_def_id()),
+            PatKind::Tuple(pats, wild_idx) => {
+                Self::Sequence(None, pats.iter().map(|pat| Self::from_pat(cx, pat)).collect(), wild_idx)
+            },
+            PatKind::Lit(e) => match &e.kind {
+                ExprKind::Lit(lit) => match lit.node {
+                    LitKind::Str(sym, _) => Self::LitStr(sym),
+                    LitKind::ByteStr(ref bytes) => Self::LitBytes(&**bytes),
+                    LitKind::Byte(val) => Self::LitInt(val.into()),
+                    LitKind::Char(val) => Self::LitInt(val.into()),
+                    LitKind::Int(val, _) => Self::LitInt(val),
+                    LitKind::Bool(val) => Self::LitBool(val),
+                    LitKind::Float(..) | LitKind::Err(_) => Self::Wild,
+                },
+                _ => Self::Wild,
+            },
+            PatKind::Range(start, end, bounds) => {
+                let start = match start {
+                    None => 0,
+                    Some(e) => match &e.kind {
+                        ExprKind::Lit(lit) => match lit.node {
+                            LitKind::Int(val, _) => val,
+                            LitKind::Char(val) => val.into(),
+                            LitKind::Byte(val) => val.into(),
+                            _ => return Self::Wild,
+                        },
+                        _ => return Self::Wild,
+                    },
+                };
+                let (end, bounds) = match end {
+                    None => (u128::MAX, RangeEnd::Included),
+                    Some(e) => match &e.kind {
+                        ExprKind::Lit(lit) => match lit.node {
+                            LitKind::Int(val, _) => (val, bounds),
+                            LitKind::Char(val) => (val.into(), bounds),
+                            LitKind::Byte(val) => (val.into(), bounds),
+                            _ => return Self::Wild,
+                        },
+                        _ => return Self::Wild,
+                    },
+                };
+                Self::Range(PatRange { start, end, bounds })
+            },
+            PatKind::Slice(pats, wild, pats2) => Self::Sequence(
+                None,
+                pats.iter()
+                    .chain(pats2.iter())
+                    .map(|pat| Self::from_pat(cx, pat))
+                    .collect(),
+                wild.map(|_| pats.len()),
+            ),
+        }
+    }
+
+    /// Checks if two patterns overlap in the values they can match assuming they are for the same
+    /// type.
+    fn can_also_match(&self, other: &Self) -> bool {
+        match (self, other) {
+            (Self::Wild, _) | (_, Self::Wild) => true,
+            (Self::Or(pats), other) | (other, Self::Or(pats)) => pats.iter().any(|pat| pat.can_also_match(other)),
+            (Self::Struct(lpath, lfields), Self::Struct(rpath, rfields)) => {
+                if lpath != rpath {
+                    return false;
+                }
+                let mut rfields = rfields.iter();
+                let mut rfield = match rfields.next() {
+                    Some(x) => x,
+                    None => return true,
+                };
+                'outer: for lfield in lfields {
+                    loop {
+                        if lfield.0 < rfield.0 {
+                            continue 'outer;
+                        } else if lfield.0 > rfield.0 {
+                            rfield = match rfields.next() {
+                                Some(x) => x,
+                                None => return true,
+                            };
+                        } else if !lfield.1.can_also_match(&rfield.1) {
+                            return false;
+                        } else {
+                            rfield = match rfields.next() {
+                                Some(x) => x,
+                                None => return true,
+                            };
+                            continue 'outer;
+                        }
+                    }
+                }
+                true
+            },
+            (Self::Sequence(lpath, lpats, lwild_idx), Self::Sequence(rpath, rpats, rwild_idx)) => {
+                if lpath != rpath {
+                    return false;
+                }
+
+                let (lpats_start, lpats_end) = lwild_idx
+                    .or(*rwild_idx)
+                    .map_or((&**lpats, [].as_slice()), |idx| lpats.split_at(idx));
+                let (rpats_start, rpats_end) = rwild_idx
+                    .or(*lwild_idx)
+                    .map_or((&**rpats, [].as_slice()), |idx| rpats.split_at(idx));
+
+                lpats_start
+                    .iter()
+                    .zip(rpats_start.iter())
+                    .all(|(lpat, rpat)| lpat.can_also_match(rpat))
+                    // `lpats_end` and `rpats_end` lengths may be disjointed, so start from the end and ignore any
+                    // extras.
+                    && lpats_end
+                    .iter()
+                    .rev()
+                    .zip(rpats_end.iter().rev())
+                    .all(|(lpat, rpat)| lpat.can_also_match(rpat))
+            },
+            (Self::Path(x), Self::Path(y)) => x == y,
+            (Self::LitStr(x), Self::LitStr(y)) => x == y,
+            (Self::LitBytes(x), Self::LitBytes(y)) => x == y,
+            (Self::LitInt(x), Self::LitInt(y)) => x == y,
+            (Self::LitBool(x), Self::LitBool(y)) => x == y,
+            (Self::Range(x), Self::Range(y)) => x.overlaps(y),
+            (Self::Range(range), Self::LitInt(x)) | (Self::LitInt(x), Self::Range(range)) => range.contains(*x),
+
+            // Todo: Lit* with Path, Range with Path, LitBytes with Sequence
+            _ => true,
+        }
+    }
+}
+
 fn pat_contains_local(pat: &Pat<'_>, id: HirId) -> bool {
     let mut result = false;
     pat.walk_short(|p| {
diff --git a/tests/ui/match_same_arms2.rs b/tests/ui/match_same_arms2.rs
index 67e1d518483..6dc6c4172ee 100644
--- a/tests/ui/match_same_arms2.rs
+++ b/tests/ui/match_same_arms2.rs
@@ -174,4 +174,17 @@ fn main() {
         Some(2) => 2,
         _ => 1,
     };
+
+    enum Foo {
+        X(u32),
+        Y(u32),
+        Z(u32),
+    }
+
+    let _ = match Foo::X(0) {
+        Foo::X(0) => 1,
+        Foo::X(_) | Foo::Y(_) | Foo::Z(0) => 2,
+        Foo::Z(_) => 1,
+        _ => 0,
+    };
 }
-- 
cgit 1.4.1-3-g733a5


From 5508f461b853345bdfbefe61fb4b7bccb433b302 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Thu, 6 Jan 2022 13:37:37 -0500
Subject: Use `DroplessArena` when allocating `ResolvedPat`s Fix tuple handling
 in `match_same_arms`

---
 clippy_lints/src/doc.rs                     |  15 ++--
 clippy_lints/src/lib.rs                     |   1 +
 clippy_lints/src/matches/match_same_arms.rs | 129 +++++++++++++++++-----------
 3 files changed, 86 insertions(+), 59 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/doc.rs b/clippy_lints/src/doc.rs
index 16173580fd4..703aa458f44 100644
--- a/clippy_lints/src/doc.rs
+++ b/clippy_lints/src/doc.rs
@@ -637,12 +637,6 @@ fn check_code(cx: &LateContext<'_>, text: &str, edition: Edition, span: Span) {
                 loop {
                     match parser.parse_item(ForceCollect::No) {
                         Ok(Some(item)) => match &item.kind {
-                            // Tests with one of these items are ignored
-                            ItemKind::Static(..)
-                            | ItemKind::Const(..)
-                            | ItemKind::ExternCrate(..)
-                            | ItemKind::ForeignMod(..) => return false,
-                            // We found a main function ...
                             ItemKind::Fn(box Fn {
                                 sig, body: Some(block), ..
                             }) if item.ident.name == sym::main => {
@@ -661,8 +655,13 @@ fn check_code(cx: &LateContext<'_>, text: &str, edition: Edition, span: Span) {
                                     return false;
                                 }
                             },
-                            // Another function was found; this case is ignored too
-                            ItemKind::Fn(..) => return false,
+                            // Tests with one of these items are ignored
+                            ItemKind::Static(..)
+                            | ItemKind::Const(..)
+                            | ItemKind::ExternCrate(..)
+                            | ItemKind::ForeignMod(..)
+                            // Another function was found; this case is ignored
+                            | ItemKind::Fn(..) => return false,
                             _ => {},
                         },
                         Ok(None) => break,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 504235d0d1e..f2a07999144 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -23,6 +23,7 @@
 
 // FIXME: switch to something more ergonomic here, once available.
 // (Currently there is no way to opt into sysroot crates without `extern crate`.)
+extern crate rustc_arena;
 extern crate rustc_ast;
 extern crate rustc_ast_pretty;
 extern crate rustc_attr;
diff --git a/clippy_lints/src/matches/match_same_arms.rs b/clippy_lints/src/matches/match_same_arms.rs
index 6617cf4e47f..0afac347d08 100644
--- a/clippy_lints/src/matches/match_same_arms.rs
+++ b/clippy_lints/src/matches/match_same_arms.rs
@@ -1,10 +1,13 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet;
 use clippy_utils::{path_to_local, search_same, SpanlessEq, SpanlessHash};
+use core::iter;
+use rustc_arena::DroplessArena;
 use rustc_ast::ast::LitKind;
 use rustc_hir::def_id::DefId;
 use rustc_hir::{Arm, Expr, ExprKind, HirId, HirIdMap, HirIdSet, Pat, PatKind, RangeEnd};
 use rustc_lint::LateContext;
+use rustc_middle::ty;
 use rustc_span::Symbol;
 use std::collections::hash_map::Entry;
 
@@ -17,7 +20,8 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>]) {
         h.finish()
     };
 
-    let resolved_pats: Vec<_> = arms.iter().map(|a| ResolvedPat::from_pat(cx, a.pat)).collect();
+    let arena = DroplessArena::default();
+    let resolved_pats: Vec<_> = arms.iter().map(|a| ResolvedPat::from_pat(cx, &arena, a.pat)).collect();
 
     // The furthast forwards a pattern can move without semantic changes
     let forwards_blocking_idxs: Vec<_> = resolved_pats
@@ -128,21 +132,22 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>]) {
     }
 }
 
-#[derive(Debug)]
-enum ResolvedPat<'hir> {
+#[derive(Clone, Copy)]
+enum ResolvedPat<'hir, 'arena> {
     Wild,
-    Struct(Option<DefId>, Vec<(Symbol, ResolvedPat<'hir>)>),
-    Sequence(Option<DefId>, Vec<ResolvedPat<'hir>>, Option<usize>),
-    Or(Vec<ResolvedPat<'hir>>),
+    Struct(Option<DefId>, &'arena [(Symbol, Self)]),
+    Tuple(Option<DefId>, &'arena [Self]),
+    Or(&'arena [Self]),
     Path(Option<DefId>),
     LitStr(Symbol),
     LitBytes(&'hir [u8]),
     LitInt(u128),
     LitBool(bool),
     Range(PatRange),
+    Slice(&'arena [Self], &'arena [Self], bool),
 }
 
-#[derive(Debug)]
+#[derive(Clone, Copy)]
 struct PatRange {
     start: u128,
     end: u128,
@@ -177,28 +182,66 @@ impl PatRange {
     }
 }
 
-impl<'hir> ResolvedPat<'hir> {
-    fn from_pat(cx: &LateContext<'_>, pat: &'hir Pat<'_>) -> Self {
+#[allow(clippy::similar_names)]
+impl<'hir, 'arena> ResolvedPat<'hir, 'arena> {
+    #[allow(clippy::too_many_lines)]
+    fn from_pat(cx: &LateContext<'_>, arena: &'arena DroplessArena, pat: &'hir Pat<'_>) -> Self {
         match pat.kind {
             PatKind::Wild | PatKind::Binding(.., None) => Self::Wild,
-            PatKind::Binding(.., Some(pat)) | PatKind::Box(pat) | PatKind::Ref(pat, _) => Self::from_pat(cx, pat),
+            PatKind::Binding(.., Some(pat)) | PatKind::Box(pat) | PatKind::Ref(pat, _) => {
+                Self::from_pat(cx, arena, pat)
+            },
             PatKind::Struct(ref path, fields, _) => {
-                let mut fields: Vec<_> = fields
-                    .iter()
-                    .map(|f| (f.ident.name, Self::from_pat(cx, f.pat)))
-                    .collect();
+                let fields =
+                    arena.alloc_from_iter(fields.iter().map(|f| (f.ident.name, Self::from_pat(cx, arena, f.pat))));
                 fields.sort_by_key(|&(name, _)| name);
                 Self::Struct(cx.qpath_res(path, pat.hir_id).opt_def_id(), fields)
             },
-            PatKind::TupleStruct(ref path, pats, wild_idx) => Self::Sequence(
-                cx.qpath_res(path, pat.hir_id).opt_def_id(),
-                pats.iter().map(|pat| Self::from_pat(cx, pat)).collect(),
-                wild_idx,
-            ),
-            PatKind::Or(pats) => Self::Or(pats.iter().map(|pat| Self::from_pat(cx, pat)).collect()),
+            PatKind::TupleStruct(ref path, pats, wild_idx) => {
+                let adt = match cx.typeck_results().pat_ty(pat).ty_adt_def() {
+                    Some(x) => x,
+                    None => return Self::Wild,
+                };
+                let (var_id, variant) = if adt.is_enum() {
+                    match cx.qpath_res(path, pat.hir_id).opt_def_id() {
+                        Some(x) => (Some(x), adt.variant_with_ctor_id(x)),
+                        None => return Self::Wild,
+                    }
+                } else {
+                    (None, adt.non_enum_variant())
+                };
+                let (front, back) = match wild_idx {
+                    Some(i) => pats.split_at(i),
+                    None => (pats, [].as_slice()),
+                };
+                let pats = arena.alloc_from_iter(
+                    front
+                        .iter()
+                        .map(|pat| Self::from_pat(cx, arena, pat))
+                        .chain(iter::repeat_with(|| Self::Wild).take(variant.fields.len() - pats.len()))
+                        .chain(back.iter().map(|pat| Self::from_pat(cx, arena, pat))),
+                );
+                Self::Tuple(var_id, pats)
+            },
+            PatKind::Or(pats) => Self::Or(arena.alloc_from_iter(pats.iter().map(|pat| Self::from_pat(cx, arena, pat)))),
             PatKind::Path(ref path) => Self::Path(cx.qpath_res(path, pat.hir_id).opt_def_id()),
             PatKind::Tuple(pats, wild_idx) => {
-                Self::Sequence(None, pats.iter().map(|pat| Self::from_pat(cx, pat)).collect(), wild_idx)
+                let field_count = match cx.typeck_results().pat_ty(pat).kind() {
+                    ty::Tuple(subs) => subs.len(),
+                    _ => return Self::Wild,
+                };
+                let (front, back) = match wild_idx {
+                    Some(i) => pats.split_at(i),
+                    None => (pats, [].as_slice()),
+                };
+                let pats = arena.alloc_from_iter(
+                    front
+                        .iter()
+                        .map(|pat| Self::from_pat(cx, arena, pat))
+                        .chain(iter::repeat_with(|| Self::Wild).take(field_count - pats.len()))
+                        .chain(back.iter().map(|pat| Self::from_pat(cx, arena, pat))),
+                );
+                Self::Tuple(None, pats)
             },
             PatKind::Lit(e) => match &e.kind {
                 ExprKind::Lit(lit) => match lit.node {
@@ -239,13 +282,10 @@ impl<'hir> ResolvedPat<'hir> {
                 };
                 Self::Range(PatRange { start, end, bounds })
             },
-            PatKind::Slice(pats, wild, pats2) => Self::Sequence(
-                None,
-                pats.iter()
-                    .chain(pats2.iter())
-                    .map(|pat| Self::from_pat(cx, pat))
-                    .collect(),
-                wild.map(|_| pats.len()),
+            PatKind::Slice(front, wild_pat, back) => Self::Slice(
+                arena.alloc_from_iter(front.iter().map(|pat| Self::from_pat(cx, arena, pat))),
+                arena.alloc_from_iter(back.iter().map(|pat| Self::from_pat(cx, arena, pat))),
+                wild_pat.is_some(),
             ),
         }
     }
@@ -253,9 +293,11 @@ impl<'hir> ResolvedPat<'hir> {
     /// Checks if two patterns overlap in the values they can match assuming they are for the same
     /// type.
     fn can_also_match(&self, other: &Self) -> bool {
-        match (self, other) {
+        match (*self, *other) {
             (Self::Wild, _) | (_, Self::Wild) => true,
-            (Self::Or(pats), other) | (other, Self::Or(pats)) => pats.iter().any(|pat| pat.can_also_match(other)),
+            (Self::Or(pats), ref other) | (ref other, Self::Or(pats)) => {
+                pats.iter().any(|pat| pat.can_also_match(other))
+            },
             (Self::Struct(lpath, lfields), Self::Struct(rpath, rfields)) => {
                 if lpath != rpath {
                     return false;
@@ -287,28 +329,13 @@ impl<'hir> ResolvedPat<'hir> {
                 }
                 true
             },
-            (Self::Sequence(lpath, lpats, lwild_idx), Self::Sequence(rpath, rpats, rwild_idx)) => {
+            (Self::Tuple(lpath, lpats), Self::Tuple(rpath, rpats)) => {
                 if lpath != rpath {
                     return false;
                 }
-
-                let (lpats_start, lpats_end) = lwild_idx
-                    .or(*rwild_idx)
-                    .map_or((&**lpats, [].as_slice()), |idx| lpats.split_at(idx));
-                let (rpats_start, rpats_end) = rwild_idx
-                    .or(*lwild_idx)
-                    .map_or((&**rpats, [].as_slice()), |idx| rpats.split_at(idx));
-
-                lpats_start
-                    .iter()
-                    .zip(rpats_start.iter())
-                    .all(|(lpat, rpat)| lpat.can_also_match(rpat))
-                    // `lpats_end` and `rpats_end` lengths may be disjointed, so start from the end and ignore any
-                    // extras.
-                    && lpats_end
+                lpats
                     .iter()
-                    .rev()
-                    .zip(rpats_end.iter().rev())
+                    .zip(rpats.iter())
                     .all(|(lpat, rpat)| lpat.can_also_match(rpat))
             },
             (Self::Path(x), Self::Path(y)) => x == y,
@@ -316,10 +343,10 @@ impl<'hir> ResolvedPat<'hir> {
             (Self::LitBytes(x), Self::LitBytes(y)) => x == y,
             (Self::LitInt(x), Self::LitInt(y)) => x == y,
             (Self::LitBool(x), Self::LitBool(y)) => x == y,
-            (Self::Range(x), Self::Range(y)) => x.overlaps(y),
-            (Self::Range(range), Self::LitInt(x)) | (Self::LitInt(x), Self::Range(range)) => range.contains(*x),
+            (Self::Range(ref x), Self::Range(ref y)) => x.overlaps(y),
+            (Self::Range(ref range), Self::LitInt(x)) | (Self::LitInt(x), Self::Range(ref range)) => range.contains(x),
 
-            // Todo: Lit* with Path, Range with Path, LitBytes with Sequence
+            // Todo: Lit* with Path, Range with Path, LitBytes with Slice, Slice with Slice
             _ => true,
         }
     }
-- 
cgit 1.4.1-3-g733a5


From 4f8f4b4c82e4647a2464e364ff96cc1dc5cb8e9a Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Thu, 6 Jan 2022 14:54:57 -0500
Subject: Handle slice patterns in `match_same_arms`

---
 clippy_lints/src/matches/match_same_arms.rs | 53 ++++++++++++++++++++---------
 1 file changed, 37 insertions(+), 16 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/match_same_arms.rs b/clippy_lints/src/matches/match_same_arms.rs
index 0afac347d08..39c1f0d0d01 100644
--- a/clippy_lints/src/matches/match_same_arms.rs
+++ b/clippy_lints/src/matches/match_same_arms.rs
@@ -21,27 +21,30 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>]) {
     };
 
     let arena = DroplessArena::default();
-    let resolved_pats: Vec<_> = arms.iter().map(|a| ResolvedPat::from_pat(cx, &arena, a.pat)).collect();
+    let normalized_pats: Vec<_> = arms
+        .iter()
+        .map(|a| NormalizedPat::from_pat(cx, &arena, a.pat))
+        .collect();
 
     // The furthast forwards a pattern can move without semantic changes
-    let forwards_blocking_idxs: Vec<_> = resolved_pats
+    let forwards_blocking_idxs: Vec<_> = normalized_pats
         .iter()
         .enumerate()
         .map(|(i, pat)| {
-            resolved_pats[i + 1..]
+            normalized_pats[i + 1..]
                 .iter()
                 .enumerate()
                 .find_map(|(j, other)| pat.can_also_match(other).then(|| i + 1 + j))
-                .unwrap_or(resolved_pats.len())
+                .unwrap_or(normalized_pats.len())
         })
         .collect();
 
     // The furthast backwards a pattern can move without semantic changes
-    let backwards_blocking_idxs: Vec<_> = resolved_pats
+    let backwards_blocking_idxs: Vec<_> = normalized_pats
         .iter()
         .enumerate()
         .map(|(i, pat)| {
-            resolved_pats[..i]
+            normalized_pats[..i]
                 .iter()
                 .enumerate()
                 .rev()
@@ -133,18 +136,18 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>]) {
 }
 
 #[derive(Clone, Copy)]
-enum ResolvedPat<'hir, 'arena> {
+enum NormalizedPat<'a> {
     Wild,
-    Struct(Option<DefId>, &'arena [(Symbol, Self)]),
-    Tuple(Option<DefId>, &'arena [Self]),
-    Or(&'arena [Self]),
+    Struct(Option<DefId>, &'a [(Symbol, Self)]),
+    Tuple(Option<DefId>, &'a [Self]),
+    Or(&'a [Self]),
     Path(Option<DefId>),
     LitStr(Symbol),
-    LitBytes(&'hir [u8]),
+    LitBytes(&'a [u8]),
     LitInt(u128),
     LitBool(bool),
     Range(PatRange),
-    Slice(&'arena [Self], &'arena [Self], bool),
+    Slice(&'a [Self], Option<&'a [Self]>),
 }
 
 #[derive(Clone, Copy)]
@@ -183,9 +186,9 @@ impl PatRange {
 }
 
 #[allow(clippy::similar_names)]
-impl<'hir, 'arena> ResolvedPat<'hir, 'arena> {
+impl<'a> NormalizedPat<'a> {
     #[allow(clippy::too_many_lines)]
-    fn from_pat(cx: &LateContext<'_>, arena: &'arena DroplessArena, pat: &'hir Pat<'_>) -> Self {
+    fn from_pat(cx: &LateContext<'_>, arena: &'a DroplessArena, pat: &'a Pat<'_>) -> Self {
         match pat.kind {
             PatKind::Wild | PatKind::Binding(.., None) => Self::Wild,
             PatKind::Binding(.., Some(pat)) | PatKind::Box(pat) | PatKind::Ref(pat, _) => {
@@ -284,8 +287,7 @@ impl<'hir, 'arena> ResolvedPat<'hir, 'arena> {
             },
             PatKind::Slice(front, wild_pat, back) => Self::Slice(
                 arena.alloc_from_iter(front.iter().map(|pat| Self::from_pat(cx, arena, pat))),
-                arena.alloc_from_iter(back.iter().map(|pat| Self::from_pat(cx, arena, pat))),
-                wild_pat.is_some(),
+                wild_pat.map(|_| &*arena.alloc_from_iter(back.iter().map(|pat| Self::from_pat(cx, arena, pat)))),
             ),
         }
     }
@@ -345,6 +347,25 @@ impl<'hir, 'arena> ResolvedPat<'hir, 'arena> {
             (Self::LitBool(x), Self::LitBool(y)) => x == y,
             (Self::Range(ref x), Self::Range(ref y)) => x.overlaps(y),
             (Self::Range(ref range), Self::LitInt(x)) | (Self::LitInt(x), Self::Range(ref range)) => range.contains(x),
+            (Self::Slice(lpats, None), Self::Slice(rpats, None)) => {
+                lpats.len() == rpats.len() && lpats.iter().zip(rpats.iter()).all(|(x, y)| x.can_also_match(y))
+            },
+            (Self::Slice(pats, None), Self::Slice(front, Some(back)))
+            | (Self::Slice(front, Some(back)), Self::Slice(pats, None)) => {
+                if pats.len() < front.len() + back.len() {
+                    return false;
+                }
+                pats[..front.len()]
+                    .iter()
+                    .zip(front.iter())
+                    .chain(pats[pats.len() - back.len()..].iter().zip(back.iter()))
+                    .all(|(x, y)| x.can_also_match(y))
+            },
+            (Self::Slice(lfront, Some(lback)), Self::Slice(rfront, Some(rback))) => lfront
+                .iter()
+                .zip(rfront.iter())
+                .chain(lback.iter().rev().zip(rback.iter().rev()))
+                .all(|(x, y)| x.can_also_match(y)),
 
             // Todo: Lit* with Path, Range with Path, LitBytes with Slice, Slice with Slice
             _ => true,
-- 
cgit 1.4.1-3-g733a5


From 08a7157a379ee7f794db386497f5cf1a4ee69fcc Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Fri, 21 Jan 2022 21:30:34 -0500
Subject: Improve message for `match_single_arms`

---
 clippy_lints/src/matches/match_same_arms.rs |  80 +++++-----
 tests/ui/match_same_arms.stderr             | 165 ++++++++++-----------
 tests/ui/match_same_arms2.rs                |  17 +++
 tests/ui/match_same_arms2.stderr            | 221 ++++++++++++++--------------
 4 files changed, 249 insertions(+), 234 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/match_same_arms.rs b/clippy_lints/src/matches/match_same_arms.rs
index 39c1f0d0d01..5202df544f6 100644
--- a/clippy_lints/src/matches/match_same_arms.rs
+++ b/clippy_lints/src/matches/match_same_arms.rs
@@ -4,6 +4,7 @@ use clippy_utils::{path_to_local, search_same, SpanlessEq, SpanlessHash};
 use core::iter;
 use rustc_arena::DroplessArena;
 use rustc_ast::ast::LitKind;
+use rustc_errors::Applicability;
 use rustc_hir::def_id::DefId;
 use rustc_hir::{Arm, Expr, ExprKind, HirId, HirIdMap, HirIdSet, Pat, PatKind, RangeEnd};
 use rustc_lint::LateContext;
@@ -13,6 +14,7 @@ use std::collections::hash_map::Entry;
 
 use super::MATCH_SAME_ARMS;
 
+#[allow(clippy::too_many_lines)]
 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>]) {
     let hash = |&(_, arm): &(usize, &Arm<'_>)| -> u64 {
         let mut h = SpanlessHash::new(cx);
@@ -96,42 +98,52 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>]) {
     };
 
     let indexed_arms: Vec<(usize, &Arm<'_>)> = arms.iter().enumerate().collect();
-    for (&(_, i), &(_, j)) in search_same(&indexed_arms, hash, eq) {
-        span_lint_and_then(
-            cx,
-            MATCH_SAME_ARMS,
-            j.body.span,
-            "this `match` has identical arm bodies",
-            |diag| {
-                diag.span_note(i.body.span, "same as this");
-
-                // Note: this does not use `span_suggestion` on purpose:
-                // there is no clean way
-                // to remove the other arm. Building a span and suggest to replace it to ""
-                // makes an even more confusing error message. Also in order not to make up a
-                // span for the whole pattern, the suggestion is only shown when there is only
-                // one pattern. The user should know about `|` if they are already using it…
+    for (&(i, arm1), &(j, arm2)) in search_same(&indexed_arms, hash, eq) {
+        if matches!(arm2.pat.kind, PatKind::Wild) {
+            span_lint_and_then(
+                cx,
+                MATCH_SAME_ARMS,
+                arm1.span,
+                "this match arm has an identical body to the `_` wildcard arm",
+                |diag| {
+                    diag.span_suggestion(
+                        arm1.span,
+                        "try removing the arm",
+                        String::new(),
+                        Applicability::MaybeIncorrect,
+                    )
+                    .help("or try changing either arm body")
+                    .span_note(arm2.span, "`_` wildcard arm here");
+                },
+            );
+        } else {
+            let back_block = backwards_blocking_idxs[j];
+            let (keep_arm, move_arm) = if back_block < i || (back_block == 0 && forwards_blocking_idxs[i] <= j) {
+                (arm1, arm2)
+            } else {
+                (arm2, arm1)
+            };
 
-                let lhs = snippet(cx, i.pat.span, "<pat1>");
-                let rhs = snippet(cx, j.pat.span, "<pat2>");
+            span_lint_and_then(
+                cx,
+                MATCH_SAME_ARMS,
+                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>");
 
-                if let PatKind::Wild = j.pat.kind {
-                    // if the last arm is _, then i could be integrated into _
-                    // note that i.pat cannot be _, because that would mean that we're
-                    // hiding all the subsequent arms, and rust won't compile
-                    diag.span_note(
-                        i.body.span,
-                        &format!(
-                            "`{}` has the same arm body as the `_` wildcard, consider removing it",
-                            lhs
-                        ),
-                    );
-                } else {
-                    diag.span_help(i.pat.span, &format!("consider refactoring into `{} | {}`", lhs, rhs,))
-                        .help("...or consider changing the match arm bodies");
-                }
-            },
-        );
+                    diag.span_suggestion(
+                        keep_arm.pat.span,
+                        "try merging the arm patterns",
+                        format!("{} | {}", keep_pat_snip, move_pat_snip),
+                        Applicability::MaybeIncorrect,
+                    )
+                    .help("or try changing either arm body")
+                    .span_note(move_arm.span, "other arm here");
+                },
+            );
+        }
     }
 }
 
diff --git a/tests/ui/match_same_arms.stderr b/tests/ui/match_same_arms.stderr
index 7752a8a6ff2..b6d04263b37 100644
--- a/tests/ui/match_same_arms.stderr
+++ b/tests/ui/match_same_arms.stderr
@@ -1,128 +1,121 @@
-error: this `match` has identical arm bodies
-  --> $DIR/match_same_arms.rs:13:14
+error: this match arm has an identical body to the `_` wildcard arm
+  --> $DIR/match_same_arms.rs:11:9
    |
-LL |         _ => 0, //~ ERROR match arms have same body
-   |              ^
+LL |         Abc::A => 0,
+   |         ^^^^^^^^^^^ help: try removing the arm
    |
    = note: `-D clippy::match-same-arms` implied by `-D warnings`
-note: same as this
-  --> $DIR/match_same_arms.rs:11:19
+   = help: or try changing either arm body
+note: `_` wildcard arm here
+  --> $DIR/match_same_arms.rs:13:9
    |
-LL |         Abc::A => 0,
-   |                   ^
-note: `Abc::A` has the same arm body as the `_` wildcard, consider removing it
-  --> $DIR/match_same_arms.rs:11:19
-   |
-LL |         Abc::A => 0,
-   |                   ^
+LL |         _ => 0, //~ ERROR match arms have same body
+   |         ^^^^^^
 
-error: this `match` has identical arm bodies
-  --> $DIR/match_same_arms.rs:18:20
-   |
-LL |         (.., 3) => 42, //~ ERROR match arms have same body
-   |                    ^^
-   |
-note: same as this
-  --> $DIR/match_same_arms.rs:17:23
-   |
-LL |         (1, .., 3) => 42,
-   |                       ^^
-help: consider refactoring into `(1, .., 3) | (.., 3)`
+error: this match arm has an identical body to another arm
   --> $DIR/match_same_arms.rs:17:9
    |
 LL |         (1, .., 3) => 42,
-   |         ^^^^^^^^^^
-   = help: ...or consider changing the match arm bodies
+   |         ----------^^^^^^
+   |         |
+   |         help: try merging the arm patterns: `(1, .., 3) | (.., 3)`
+   |
+   = help: or try changing either arm body
+note: other arm here
+  --> $DIR/match_same_arms.rs:18:9
+   |
+LL |         (.., 3) => 42, //~ ERROR match arms have same body
+   |         ^^^^^^^^^^^^^
 
-error: this `match` has identical arm bodies
-  --> $DIR/match_same_arms.rs:24:15
+error: this match arm has an identical body to another arm
+  --> $DIR/match_same_arms.rs:24:9
    |
 LL |         51 => 1, //~ ERROR match arms have same body
-   |               ^
+   |         --^^^^^
+   |         |
+   |         help: try merging the arm patterns: `51 | 42`
    |
-note: same as this
-  --> $DIR/match_same_arms.rs:23:15
-   |
-LL |         42 => 1,
-   |               ^
-help: consider refactoring into `42 | 51`
+   = help: or try changing either arm body
+note: other arm here
   --> $DIR/match_same_arms.rs:23:9
    |
 LL |         42 => 1,
-   |         ^^
-   = help: ...or consider changing the match arm bodies
+   |         ^^^^^^^
 
-error: this `match` has identical arm bodies
-  --> $DIR/match_same_arms.rs:26:15
-   |
-LL |         52 => 2, //~ ERROR match arms have same body
-   |               ^
-   |
-note: same as this
-  --> $DIR/match_same_arms.rs:25:15
-   |
-LL |         41 => 2,
-   |               ^
-help: consider refactoring into `41 | 52`
+error: this match arm has an identical body to another arm
   --> $DIR/match_same_arms.rs:25:9
    |
 LL |         41 => 2,
-   |         ^^
-   = help: ...or consider changing the match arm bodies
+   |         --^^^^^
+   |         |
+   |         help: try merging the arm patterns: `41 | 52`
+   |
+   = help: or try changing either arm body
+note: other arm here
+  --> $DIR/match_same_arms.rs:26:9
+   |
+LL |         52 => 2, //~ ERROR match arms have same body
+   |         ^^^^^^^
 
-error: this `match` has identical arm bodies
-  --> $DIR/match_same_arms.rs:32:14
+error: this match arm has an identical body to another arm
+  --> $DIR/match_same_arms.rs:32:9
    |
 LL |         2 => 2, //~ ERROR 2nd matched arms have same body
-   |              ^
-   |
-note: same as this
-  --> $DIR/match_same_arms.rs:31:14
+   |         -^^^^^
+   |         |
+   |         help: try merging the arm patterns: `2 | 1`
    |
-LL |         1 => 2,
-   |              ^
-help: consider refactoring into `1 | 2`
+   = help: or try changing either arm body
+note: other arm here
   --> $DIR/match_same_arms.rs:31:9
    |
 LL |         1 => 2,
-   |         ^
-   = help: ...or consider changing the match arm bodies
+   |         ^^^^^^
 
-error: this `match` has identical arm bodies
-  --> $DIR/match_same_arms.rs:33:14
+error: this match arm has an identical body to another arm
+  --> $DIR/match_same_arms.rs:33:9
    |
 LL |         3 => 2, //~ ERROR 3rd matched arms have same body
-   |              ^
-   |
-note: same as this
-  --> $DIR/match_same_arms.rs:31:14
+   |         -^^^^^
+   |         |
+   |         help: try merging the arm patterns: `3 | 1`
    |
-LL |         1 => 2,
-   |              ^
-help: consider refactoring into `1 | 3`
+   = help: or try changing either arm body
+note: other arm here
   --> $DIR/match_same_arms.rs:31:9
    |
 LL |         1 => 2,
-   |         ^
-   = help: ...or consider changing the match arm bodies
+   |         ^^^^^^
 
-error: this `match` has identical arm bodies
-  --> $DIR/match_same_arms.rs:50:55
+error: this match arm has an identical body to another arm
+  --> $DIR/match_same_arms.rs:32:9
    |
-LL |                 CommandInfo::External { name, .. } => name.to_string(),
-   |                                                       ^^^^^^^^^^^^^^^^
+LL |         2 => 2, //~ ERROR 2nd matched arms have same body
+   |         -^^^^^
+   |         |
+   |         help: try merging the arm patterns: `2 | 3`
    |
-note: same as this
-  --> $DIR/match_same_arms.rs:49:54
+   = help: or try changing either arm body
+note: other arm here
+  --> $DIR/match_same_arms.rs:33:9
    |
-LL |                 CommandInfo::BuiltIn { name, .. } => name.to_string(),
-   |                                                      ^^^^^^^^^^^^^^^^
-help: consider refactoring into `CommandInfo::BuiltIn { name, .. } | CommandInfo::External { name, .. }`
+LL |         3 => 2, //~ ERROR 3rd matched arms have same body
+   |         ^^^^^^
+
+error: this match arm has an identical body to another arm
+  --> $DIR/match_same_arms.rs:50: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
   --> $DIR/match_same_arms.rs:49:17
    |
 LL |                 CommandInfo::BuiltIn { name, .. } => name.to_string(),
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   = help: ...or consider changing the match arm bodies
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 7 previous errors
+error: aborting due to 8 previous errors
 
diff --git a/tests/ui/match_same_arms2.rs b/tests/ui/match_same_arms2.rs
index 6dc6c4172ee..fdd88f25529 100644
--- a/tests/ui/match_same_arms2.rs
+++ b/tests/ui/match_same_arms2.rs
@@ -181,10 +181,27 @@ fn main() {
         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) => 1,
+        Foo::X(_) | Foo::Y(_) => 2,
+        Foo::Z(_) => 1,
+        _ => 0,
+    };
+
+    // Suggest moving `Foo::X(0)` down.
+    let _ = match Foo::X(0) {
+        Foo::X(0) => 1,
+        Foo::Y(_) | Foo::Z(0) => 2,
+        Foo::Z(_) => 1,
+        _ => 0,
+    };
 }
diff --git a/tests/ui/match_same_arms2.stderr b/tests/ui/match_same_arms2.stderr
index e1ed12f9370..596cc8432b3 100644
--- a/tests/ui/match_same_arms2.stderr
+++ b/tests/ui/match_same_arms2.stderr
@@ -1,175 +1,138 @@
-error: this `match` has identical arm bodies
-  --> $DIR/match_same_arms2.rs:20:14
+error: this match arm has an identical body to the `_` wildcard arm
+  --> $DIR/match_same_arms2.rs:11:9
    |
-LL |           _ => {
-   |  ______________^
-LL | |             //~ ERROR match arms have same body
+LL | /         42 => {
 LL | |             foo();
 LL | |             let mut a = 42 + [23].len() as i32;
+LL | |             if true {
 ...  |
 LL | |             a
 LL | |         },
-   | |_________^
+   | |_________^ help: try removing the arm
    |
    = note: `-D clippy::match-same-arms` implied by `-D warnings`
-note: same as this
-  --> $DIR/match_same_arms2.rs:11:15
-   |
-LL |           42 => {
-   |  _______________^
-LL | |             foo();
-LL | |             let mut a = 42 + [23].len() as i32;
-LL | |             if true {
-...  |
-LL | |             a
-LL | |         },
-   | |_________^
-note: `42` has the same arm body as the `_` wildcard, consider removing it
-  --> $DIR/match_same_arms2.rs:11:15
+   = help: or try changing either arm body
+note: `_` wildcard arm here
+  --> $DIR/match_same_arms2.rs:20:9
    |
-LL |           42 => {
-   |  _______________^
+LL | /         _ => {
+LL | |             //~ ERROR match arms have same body
 LL | |             foo();
 LL | |             let mut a = 42 + [23].len() as i32;
-LL | |             if true {
 ...  |
 LL | |             a
 LL | |         },
    | |_________^
 
-error: this `match` has identical arm bodies
-  --> $DIR/match_same_arms2.rs:34:15
+error: this match arm has an identical body to another arm
+  --> $DIR/match_same_arms2.rs:34:9
    |
 LL |         51 => foo(), //~ ERROR match arms have same body
-   |               ^^^^^
-   |
-note: same as this
-  --> $DIR/match_same_arms2.rs:33:15
+   |         --^^^^^^^^^
+   |         |
+   |         help: try merging the arm patterns: `51 | 42`
    |
-LL |         42 => foo(),
-   |               ^^^^^
-help: consider refactoring into `42 | 51`
+   = help: or try changing either arm body
+note: other arm here
   --> $DIR/match_same_arms2.rs:33:9
    |
 LL |         42 => foo(),
-   |         ^^
-   = help: ...or consider changing the match arm bodies
+   |         ^^^^^^^^^^^
 
-error: this `match` has identical arm bodies
-  --> $DIR/match_same_arms2.rs:40:17
-   |
-LL |         None => 24, //~ ERROR match arms have same body
-   |                 ^^
-   |
-note: same as this
-  --> $DIR/match_same_arms2.rs:39:20
-   |
-LL |         Some(_) => 24,
-   |                    ^^
-help: consider refactoring into `Some(_) | None`
+error: this match arm has an identical body to another arm
   --> $DIR/match_same_arms2.rs:39:9
    |
 LL |         Some(_) => 24,
-   |         ^^^^^^^
-   = help: ...or consider changing the match arm bodies
-
-error: this `match` has identical arm bodies
-  --> $DIR/match_same_arms2.rs:62:28
+   |         -------^^^^^^
+   |         |
+   |         help: try merging the arm patterns: `Some(_) | None`
    |
-LL |         (None, Some(a)) => bar(a), //~ ERROR match arms have same body
-   |                            ^^^^^^
-   |
-note: same as this
-  --> $DIR/match_same_arms2.rs:61:28
+   = help: or try changing either arm body
+note: other arm here
+  --> $DIR/match_same_arms2.rs:40:9
    |
-LL |         (Some(a), None) => bar(a),
-   |                            ^^^^^^
-help: consider refactoring into `(Some(a), None) | (None, Some(a))`
+LL |         None => 24, //~ ERROR match arms have same body
+   |         ^^^^^^^^^^
+
+error: this match arm has an identical body to another arm
   --> $DIR/match_same_arms2.rs:61:9
    |
 LL |         (Some(a), None) => bar(a),
-   |         ^^^^^^^^^^^^^^^
-   = help: ...or consider changing the match arm bodies
-
-error: this `match` has identical arm bodies
-  --> $DIR/match_same_arms2.rs:68:26
+   |         ---------------^^^^^^^^^^
+   |         |
+   |         help: try merging the arm patterns: `(Some(a), None) | (None, Some(a))`
    |
-LL |         (.., Some(a)) => bar(a), //~ ERROR match arms have same body
-   |                          ^^^^^^
-   |
-note: same as this
-  --> $DIR/match_same_arms2.rs:67:26
+   = help: or try changing either arm body
+note: other arm here
+  --> $DIR/match_same_arms2.rs:62:9
    |
-LL |         (Some(a), ..) => bar(a),
-   |                          ^^^^^^
-help: consider refactoring into `(Some(a), ..) | (.., Some(a))`
+LL |         (None, Some(a)) => bar(a), //~ ERROR match arms have same body
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: this match arm has an identical body to another arm
   --> $DIR/match_same_arms2.rs:67:9
    |
 LL |         (Some(a), ..) => bar(a),
-   |         ^^^^^^^^^^^^^
-   = help: ...or consider changing the match arm bodies
-
-error: this `match` has identical arm bodies
-  --> $DIR/match_same_arms2.rs:102:29
-   |
-LL |         (Ok(_), Some(x)) => println!("ok {}", x),
-   |                             ^^^^^^^^^^^^^^^^^^^^
+   |         -------------^^^^^^^^^^
+   |         |
+   |         help: try merging the arm patterns: `(Some(a), ..) | (.., Some(a))`
    |
-note: same as this
-  --> $DIR/match_same_arms2.rs:101:29
+   = help: or try changing either arm body
+note: other arm here
+  --> $DIR/match_same_arms2.rs:68:9
    |
-LL |         (Ok(x), Some(_)) => println!("ok {}", x),
-   |                             ^^^^^^^^^^^^^^^^^^^^
-help: consider refactoring into `(Ok(x), Some(_)) | (Ok(_), Some(x))`
+LL |         (.., Some(a)) => bar(a), //~ ERROR match arms have same body
+   |         ^^^^^^^^^^^^^^^^^^^^^^^
+
+error: this match arm has an identical body to another arm
   --> $DIR/match_same_arms2.rs:101:9
    |
 LL |         (Ok(x), Some(_)) => println!("ok {}", x),
-   |         ^^^^^^^^^^^^^^^^
-   = help: ...or consider changing the match arm bodies
-   = note: this error originates in the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
+   |         ----------------^^^^^^^^^^^^^^^^^^^^^^^^
+   |         |
+   |         help: try merging the arm patterns: `(Ok(x), Some(_)) | (Ok(_), Some(x))`
+   |
+   = help: or try changing either arm body
+note: other arm here
+  --> $DIR/match_same_arms2.rs:102:9
+   |
+LL |         (Ok(_), Some(x)) => println!("ok {}", x),
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: this `match` has identical arm bodies
-  --> $DIR/match_same_arms2.rs:117:18
+error: this match arm has an identical body to another arm
+  --> $DIR/match_same_arms2.rs:117:9
    |
 LL |         Ok(_) => println!("ok"),
-   |                  ^^^^^^^^^^^^^^
+   |         -----^^^^^^^^^^^^^^^^^^
+   |         |
+   |         help: try merging the arm patterns: `Ok(_) | Ok(3)`
    |
-note: same as this
-  --> $DIR/match_same_arms2.rs:116:18
-   |
-LL |         Ok(3) => println!("ok"),
-   |                  ^^^^^^^^^^^^^^
-help: consider refactoring into `Ok(3) | Ok(_)`
+   = help: or try changing either arm body
+note: other arm here
   --> $DIR/match_same_arms2.rs:116:9
    |
 LL |         Ok(3) => println!("ok"),
-   |         ^^^^^
-   = help: ...or consider changing the match arm bodies
-   = note: this error originates in the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
+   |         ^^^^^^^^^^^^^^^^^^^^^^^
 
-error: this `match` has identical arm bodies
-  --> $DIR/match_same_arms2.rs:144:14
+error: this match arm has an identical body to another arm
+  --> $DIR/match_same_arms2.rs:144:9
    |
 LL |           1 => {
-   |  ______________^
+   |           ^ help: try merging the arm patterns: `1 | 0`
+   |  _________|
+   | |
 LL | |             empty!(0);
 LL | |         },
    | |_________^
    |
-note: same as this
-  --> $DIR/match_same_arms2.rs:141:14
+   = help: or try changing either arm body
+note: other arm here
+  --> $DIR/match_same_arms2.rs:141:9
    |
-LL |           0 => {
-   |  ______________^
+LL | /         0 => {
 LL | |             empty!(0);
 LL | |         },
    | |_________^
-help: consider refactoring into `0 | 1`
-  --> $DIR/match_same_arms2.rs:141:9
-   |
-LL |         0 => {
-   |         ^
-   = help: ...or consider changing the match arm bodies
 
 error: match expression looks like `matches!` macro
   --> $DIR/match_same_arms2.rs:162:16
@@ -184,5 +147,35 @@ LL | |     };
    |
    = note: `-D clippy::match-like-matches-macro` implied by `-D warnings`
 
-error: aborting due to 9 previous errors
+error: this match arm has an identical body to another arm
+  --> $DIR/match_same_arms2.rs:194: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
+  --> $DIR/match_same_arms2.rs:196:9
+   |
+LL |         Foo::Z(_) => 1,
+   |         ^^^^^^^^^^^^^^
+
+error: this match arm has an identical body to another arm
+  --> $DIR/match_same_arms2.rs:204: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
+  --> $DIR/match_same_arms2.rs:202:9
+   |
+LL |         Foo::X(0) => 1,
+   |         ^^^^^^^^^^^^^^
+
+error: aborting due to 11 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 773d20341ad8061df9acca781bab7a0fb38ed684 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Wed, 16 Mar 2022 23:55:38 -0400
Subject: Fix mixed enum variant kinds + code cleanup

---
 clippy_lints/src/matches/match_same_arms.rs | 113 ++++++++++++++++------------
 clippy_lints/src/write.rs                   |   9 ++-
 tests/ui/match_same_arms2.rs                |  23 ++++++
 tests/ui/match_same_arms2.stderr            |  41 ++++++----
 4 files changed, 123 insertions(+), 63 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/match_same_arms.rs b/clippy_lints/src/matches/match_same_arms.rs
index 5202df544f6..b8591fe0db0 100644
--- a/clippy_lints/src/matches/match_same_arms.rs
+++ b/clippy_lints/src/matches/match_same_arms.rs
@@ -1,7 +1,9 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet;
 use clippy_utils::{path_to_local, search_same, SpanlessEq, SpanlessHash};
+use core::cmp::Ordering;
 use core::iter;
+use core::slice;
 use rustc_arena::DroplessArena;
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
@@ -36,7 +38,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>]) {
             normalized_pats[i + 1..]
                 .iter()
                 .enumerate()
-                .find_map(|(j, other)| pat.can_also_match(other).then(|| i + 1 + j))
+                .find_map(|(j, other)| pat.has_overlapping_values(other).then(|| i + 1 + j))
                 .unwrap_or(normalized_pats.len())
         })
         .collect();
@@ -52,7 +54,9 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>]) {
                 .rev()
                 .zip(forwards_blocking_idxs[..i].iter().copied().rev())
                 .skip_while(|&(_, forward_block)| forward_block > i)
-                .find_map(|((j, other), forward_block)| (forward_block == i || pat.can_also_match(other)).then(|| j))
+                .find_map(|((j, other), forward_block)| {
+                    (forward_block == i || pat.has_overlapping_values(other)).then(|| j)
+                })
                 .unwrap_or(0)
         })
         .collect();
@@ -159,6 +163,10 @@ enum NormalizedPat<'a> {
     LitInt(u128),
     LitBool(bool),
     Range(PatRange),
+    /// A slice pattern. If the second value is `None`, then this matches an exact size. Otherwise
+    /// the first value contains everything before the `..` wildcard pattern, and the second value
+    /// contains everything afterwards. Note that either side, or both sides, may contain zero
+    /// patterns.
     Slice(&'a [Self], Option<&'a [Self]>),
 }
 
@@ -178,23 +186,43 @@ impl PatRange {
     }
 
     fn overlaps(&self, other: &Self) -> bool {
-        !(self.is_empty() || other.is_empty())
-            && match self.bounds {
-                RangeEnd::Included => self.end >= other.start,
-                RangeEnd::Excluded => self.end > other.start,
-            }
-            && match other.bounds {
-                RangeEnd::Included => self.start <= other.end,
-                RangeEnd::Excluded => self.start < other.end,
-            }
+        // Note: Empty ranges are impossible, so this is correct even though it would return true if an
+        // empty exclusive range were to reside within an inclusive range.
+        (match self.bounds {
+            RangeEnd::Included => self.end >= other.start,
+            RangeEnd::Excluded => self.end > other.start,
+        } && match other.bounds {
+            RangeEnd::Included => self.start <= other.end,
+            RangeEnd::Excluded => self.start < other.end,
+        })
     }
+}
 
-    fn is_empty(&self) -> bool {
-        match self.bounds {
-            RangeEnd::Included => false,
-            RangeEnd::Excluded => self.start == self.end,
+/// Iterates over the pairs of fields with matching names.
+fn iter_matching_struct_fields<'a>(
+    left: &'a [(Symbol, NormalizedPat<'a>)],
+    right: &'a [(Symbol, NormalizedPat<'a>)],
+) -> impl Iterator<Item = (&'a NormalizedPat<'a>, &'a NormalizedPat<'a>)> + 'a {
+    struct Iter<'a>(
+        slice::Iter<'a, (Symbol, NormalizedPat<'a>)>,
+        slice::Iter<'a, (Symbol, NormalizedPat<'a>)>,
+    );
+    impl<'a> Iterator for Iter<'a> {
+        type Item = (&'a NormalizedPat<'a>, &'a NormalizedPat<'a>);
+        fn next(&mut self) -> Option<Self::Item> {
+            // Note: all the fields in each slice are sorted by symbol value.
+            let mut left = self.0.next()?;
+            let mut right = self.1.next()?;
+            loop {
+                match left.0.cmp(&right.0) {
+                    Ordering::Equal => return Some((&left.1, &right.1)),
+                    Ordering::Less => left = self.0.next()?,
+                    Ordering::Greater => right = self.1.next()?,
+                }
+            }
         }
     }
+    Iter(left.iter(), right.iter())
 }
 
 #[allow(clippy::similar_names)]
@@ -259,6 +287,7 @@ impl<'a> NormalizedPat<'a> {
                 Self::Tuple(None, pats)
             },
             PatKind::Lit(e) => match &e.kind {
+                // TODO: Handle negative integers. They're currently treated as a wild match.
                 ExprKind::Lit(lit) => match lit.node {
                     LitKind::Str(sym, _) => Self::LitStr(sym),
                     LitKind::ByteStr(ref bytes) => Self::LitBytes(&**bytes),
@@ -271,6 +300,7 @@ impl<'a> NormalizedPat<'a> {
                 _ => Self::Wild,
             },
             PatKind::Range(start, end, bounds) => {
+                // TODO: Handle negative integers. They're currently treated as a wild match.
                 let start = match start {
                     None => 0,
                     Some(e) => match &e.kind {
@@ -306,42 +336,17 @@ impl<'a> NormalizedPat<'a> {
 
     /// Checks if two patterns overlap in the values they can match assuming they are for the same
     /// type.
-    fn can_also_match(&self, other: &Self) -> bool {
+    fn has_overlapping_values(&self, other: &Self) -> bool {
         match (*self, *other) {
             (Self::Wild, _) | (_, Self::Wild) => true,
             (Self::Or(pats), ref other) | (ref other, Self::Or(pats)) => {
-                pats.iter().any(|pat| pat.can_also_match(other))
+                pats.iter().any(|pat| pat.has_overlapping_values(other))
             },
             (Self::Struct(lpath, lfields), Self::Struct(rpath, rfields)) => {
                 if lpath != rpath {
                     return false;
                 }
-                let mut rfields = rfields.iter();
-                let mut rfield = match rfields.next() {
-                    Some(x) => x,
-                    None => return true,
-                };
-                'outer: for lfield in lfields {
-                    loop {
-                        if lfield.0 < rfield.0 {
-                            continue 'outer;
-                        } else if lfield.0 > rfield.0 {
-                            rfield = match rfields.next() {
-                                Some(x) => x,
-                                None => return true,
-                            };
-                        } else if !lfield.1.can_also_match(&rfield.1) {
-                            return false;
-                        } else {
-                            rfield = match rfields.next() {
-                                Some(x) => x,
-                                None => return true,
-                            };
-                            continue 'outer;
-                        }
-                    }
-                }
-                true
+                iter_matching_struct_fields(lfields, rfields).all(|(lpat, rpat)| lpat.has_overlapping_values(rpat))
             },
             (Self::Tuple(lpath, lpats), Self::Tuple(rpath, rpats)) => {
                 if lpath != rpath {
@@ -350,7 +355,7 @@ impl<'a> NormalizedPat<'a> {
                 lpats
                     .iter()
                     .zip(rpats.iter())
-                    .all(|(lpat, rpat)| lpat.can_also_match(rpat))
+                    .all(|(lpat, rpat)| lpat.has_overlapping_values(rpat))
             },
             (Self::Path(x), Self::Path(y)) => x == y,
             (Self::LitStr(x), Self::LitStr(y)) => x == y,
@@ -360,10 +365,12 @@ impl<'a> NormalizedPat<'a> {
             (Self::Range(ref x), Self::Range(ref y)) => x.overlaps(y),
             (Self::Range(ref range), Self::LitInt(x)) | (Self::LitInt(x), Self::Range(ref range)) => range.contains(x),
             (Self::Slice(lpats, None), Self::Slice(rpats, None)) => {
-                lpats.len() == rpats.len() && lpats.iter().zip(rpats.iter()).all(|(x, y)| x.can_also_match(y))
+                lpats.len() == rpats.len() && lpats.iter().zip(rpats.iter()).all(|(x, y)| x.has_overlapping_values(y))
             },
             (Self::Slice(pats, None), Self::Slice(front, Some(back)))
             | (Self::Slice(front, Some(back)), Self::Slice(pats, None)) => {
+                // Here `pats` is an exact size match. If the combined lengths of `front` and `back` are greater
+                // then the minium length required will be greater than the length of `pats`.
                 if pats.len() < front.len() + back.len() {
                     return false;
                 }
@@ -371,15 +378,25 @@ impl<'a> NormalizedPat<'a> {
                     .iter()
                     .zip(front.iter())
                     .chain(pats[pats.len() - back.len()..].iter().zip(back.iter()))
-                    .all(|(x, y)| x.can_also_match(y))
+                    .all(|(x, y)| x.has_overlapping_values(y))
             },
             (Self::Slice(lfront, Some(lback)), Self::Slice(rfront, Some(rback))) => lfront
                 .iter()
                 .zip(rfront.iter())
                 .chain(lback.iter().rev().zip(rback.iter().rev()))
-                .all(|(x, y)| x.can_also_match(y)),
+                .all(|(x, y)| x.has_overlapping_values(y)),
+
+            // Enums can mix unit variants with tuple/struct variants. These can never overlap.
+            (Self::Path(_), Self::Tuple(..) | Self::Struct(..))
+            | (Self::Tuple(..) | Self::Struct(..), Self::Path(_)) => false,
+
+            // Tuples can be matched like a struct.
+            (Self::Tuple(x, _), Self::Struct(y, _)) | (Self::Struct(x, _), Self::Tuple(y, _)) => {
+                // TODO: check fields here.
+                x == y
+            },
 
-            // Todo: Lit* with Path, Range with Path, LitBytes with Slice, Slice with Slice
+            // TODO: Lit* with Path, Range with Path, LitBytes with Slice
             _ => true,
         }
     }
diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs
index 532bd810a2e..f3d818cc348 100644
--- a/clippy_lints/src/write.rs
+++ b/clippy_lints/src/write.rs
@@ -581,14 +581,19 @@ impl Write {
             };
 
             let replacement: String = match lit.token.kind {
-                LitKind::Integer | LitKind::Float | LitKind::Err => continue,
                 LitKind::StrRaw(_) | LitKind::ByteStrRaw(_) if matches!(fmtstr.style, StrStyle::Raw(_)) => {
                     lit.token.symbol.as_str().replace('{', "{{").replace('}', "}}")
                 },
                 LitKind::Str | LitKind::ByteStr if matches!(fmtstr.style, StrStyle::Cooked) => {
                     lit.token.symbol.as_str().replace('{', "{{").replace('}', "}}")
                 },
-                LitKind::StrRaw(_) | LitKind::Str | LitKind::ByteStrRaw(_) | LitKind::ByteStr => continue,
+                LitKind::StrRaw(_)
+                | LitKind::Str
+                | LitKind::ByteStrRaw(_)
+                | LitKind::ByteStr
+                | LitKind::Integer
+                | LitKind::Float
+                | LitKind::Err => continue,
                 LitKind::Byte | LitKind::Char => match lit.token.symbol.as_str() {
                     "\"" if matches!(fmtstr.style, StrStyle::Cooked) => "\\\"",
                     "\"" if matches!(fmtstr.style, StrStyle::Raw(0)) => continue,
diff --git a/tests/ui/match_same_arms2.rs b/tests/ui/match_same_arms2.rs
index fdd88f25529..dbfeb4379d5 100644
--- a/tests/ui/match_same_arms2.rs
+++ b/tests/ui/match_same_arms2.rs
@@ -204,4 +204,27 @@ fn main() {
         Foo::Z(_) => 1,
         _ => 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 { x: 0, y: 5, .. }) => 1,
+        Some(Bar { y: 10, z: 0, .. }) => 2,
+        None => 50,
+        Some(Bar { y: 0, x: 5, .. }) => 1,
+        _ => 200,
+    };
 }
diff --git a/tests/ui/match_same_arms2.stderr b/tests/ui/match_same_arms2.stderr
index 596cc8432b3..14a672ba2fe 100644
--- a/tests/ui/match_same_arms2.stderr
+++ b/tests/ui/match_same_arms2.stderr
@@ -40,33 +40,33 @@ LL |         42 => foo(),
    |         ^^^^^^^^^^^
 
 error: this match arm has an identical body to another arm
-  --> $DIR/match_same_arms2.rs:39:9
+  --> $DIR/match_same_arms2.rs:40:9
    |
-LL |         Some(_) => 24,
-   |         -------^^^^^^
+LL |         None => 24, //~ ERROR match arms have same body
+   |         ----^^^^^^
    |         |
-   |         help: try merging the arm patterns: `Some(_) | None`
+   |         help: try merging the arm patterns: `None | Some(_)`
    |
    = help: or try changing either arm body
 note: other arm here
-  --> $DIR/match_same_arms2.rs:40:9
+  --> $DIR/match_same_arms2.rs:39:9
    |
-LL |         None => 24, //~ ERROR match arms have same body
-   |         ^^^^^^^^^^
+LL |         Some(_) => 24,
+   |         ^^^^^^^^^^^^^
 
 error: this match arm has an identical body to another arm
-  --> $DIR/match_same_arms2.rs:61:9
+  --> $DIR/match_same_arms2.rs:62:9
    |
-LL |         (Some(a), None) => bar(a),
+LL |         (None, Some(a)) => bar(a), //~ ERROR match arms have same body
    |         ---------------^^^^^^^^^^
    |         |
-   |         help: try merging the arm patterns: `(Some(a), None) | (None, Some(a))`
+   |         help: try merging the arm patterns: `(None, Some(a)) | (Some(a), None)`
    |
    = help: or try changing either arm body
 note: other arm here
-  --> $DIR/match_same_arms2.rs:62:9
+  --> $DIR/match_same_arms2.rs:61:9
    |
-LL |         (None, Some(a)) => bar(a), //~ ERROR match arms have same body
+LL |         (Some(a), None) => bar(a),
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this match arm has an identical body to another arm
@@ -177,5 +177,20 @@ note: other arm here
 LL |         Foo::X(0) => 1,
    |         ^^^^^^^^^^^^^^
 
-error: aborting due to 11 previous errors
+error: this match arm has an identical body to another arm
+  --> $DIR/match_same_arms2.rs:227: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
+  --> $DIR/match_same_arms2.rs:224:9
+   |
+LL |         Some(Bar { x: 0, y: 5, .. }) => 1,
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 12 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From bd888d435423a47ce3bdbaec6c61a3cb093a7e18 Mon Sep 17 00:00:00 2001
From: dswij <dswijj@gmail.com>
Date: Thu, 17 Mar 2022 14:33:09 +0800
Subject: Add some comments

---
 clippy_lints/src/methods/unnecessary_lazy_eval.rs | 3 +++
 1 file changed, 3 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/unnecessary_lazy_eval.rs b/clippy_lints/src/methods/unnecessary_lazy_eval.rs
index 0dd41a4dacf..2369be70812 100644
--- a/clippy_lints/src/methods/unnecessary_lazy_eval.rs
+++ b/clippy_lints/src/methods/unnecessary_lazy_eval.rs
@@ -48,6 +48,9 @@ pub(super) fn check<'tcx>(
                     Applicability::MaybeIncorrect
                 };
 
+                // This is a duplicate of what's happening in clippy_lints::methods::method_call,
+                // which isn't ideal, We want to get the method call span,
+                // but prefer to avoid changing the signature of the function itself.
                 if let hir::ExprKind::MethodCall(_, _, span) = expr.kind {
                     span_lint_and_then(cx, UNNECESSARY_LAZY_EVALUATIONS, expr.span, msg, |diag| {
                         diag.span_suggestion(
-- 
cgit 1.4.1-3-g733a5


From 4b128624ed44223b7d0b61438b0d02fc91419e43 Mon Sep 17 00:00:00 2001
From: J-ZhengLi <lizheng135@huawei.com>
Date: Thu, 17 Mar 2022 23:06:31 +0800
Subject: fix #8551, add test cases, and some code improvement

---
 clippy_lints/src/matches/mod.rs            |   2 +-
 clippy_lints/src/matches/needless_match.rs | 108 +++++++++++++++++++----------
 tests/ui/needless_match.fixed              |  66 ++++++++++++++----
 tests/ui/needless_match.rs                 |  66 ++++++++++++++----
 tests/ui/needless_match.stderr             |  14 ++--
 5 files changed, 185 insertions(+), 71 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/mod.rs b/clippy_lints/src/matches/mod.rs
index ff85623acf4..e93b494653f 100644
--- a/clippy_lints/src/matches/mod.rs
+++ b/clippy_lints/src/matches/mod.rs
@@ -667,7 +667,7 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
                     overlapping_arms::check(cx, ex, arms);
                     match_wild_enum::check(cx, ex, arms);
                     match_as_ref::check(cx, ex, arms, expr);
-                    needless_match::check_match(cx, ex, arms);
+                    needless_match::check_match(cx, ex, arms, expr);
 
                     if self.infallible_destructuring_match_linted {
                         self.infallible_destructuring_match_linted = false;
diff --git a/clippy_lints/src/matches/needless_match.rs b/clippy_lints/src/matches/needless_match.rs
index d9544e18b18..2830ae1f61d 100644
--- a/clippy_lints/src/matches/needless_match.rs
+++ b/clippy_lints/src/matches/needless_match.rs
@@ -1,37 +1,25 @@
 use super::NEEDLESS_MATCH;
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{eq_expr_value, get_parent_expr, higher, is_else_clause, is_lang_ctor, peel_blocks_with_stmt};
+use clippy_utils::ty::{is_type_diagnostic_item, same_type_and_consts};
+use clippy_utils::{
+    eq_expr_value, get_parent_expr_for_hir, get_parent_node, higher, is_else_clause, is_lang_ctor,
+    peel_blocks_with_stmt,
+};
 use rustc_errors::Applicability;
 use rustc_hir::LangItem::OptionNone;
-use rustc_hir::{Arm, BindingAnnotation, Expr, ExprKind, Pat, PatKind, Path, PathSegment, QPath};
+use rustc_hir::{Arm, BindingAnnotation, Expr, ExprKind, FnRetTy, Node, Pat, PatKind, Path, PathSegment, QPath};
 use rustc_lint::LateContext;
 use rustc_span::sym;
+use rustc_typeck::hir_ty_to_ty;
 
-pub(crate) fn check_match(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>]) {
-    // This is for avoiding collision with `match_single_binding`.
-    if arms.len() < 2 {
-        return;
-    }
-
-    for arm in arms {
-        if let PatKind::Wild = arm.pat.kind {
-            let ret_expr = strip_return(arm.body);
-            if !eq_expr_value(cx, ex, ret_expr) {
-                return;
-            }
-        } else if !pat_same_as_expr(arm.pat, peel_blocks_with_stmt(arm.body)) {
-            return;
-        }
-    }
-
-    if let Some(match_expr) = get_parent_expr(cx, ex) {
+pub(crate) fn check_match(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>], expr: &Expr<'_>) {
+    if arms.len() > 1 && !is_coercion_casting(cx, ex, expr) && check_all_arms(cx, ex, arms) {
         let mut applicability = Applicability::MachineApplicable;
         span_lint_and_sugg(
             cx,
             NEEDLESS_MATCH,
-            match_expr.span,
+            expr.span,
             "this match expression is unnecessary",
             "replace it with",
             snippet_with_applicability(cx, ex.span, "..", &mut applicability).to_string(),
@@ -60,11 +48,8 @@ pub(crate) fn check_match(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>])
 /// }
 /// ```
 pub(crate) fn check(cx: &LateContext<'_>, ex: &Expr<'_>) {
-    if_chain! {
-        if let Some(ref if_let) = higher::IfLet::hir(cx, ex);
-        if !is_else_clause(cx.tcx, ex);
-        if check_if_let(cx, if_let);
-        then {
+    if let Some(ref if_let) = higher::IfLet::hir(cx, ex) {
+        if !is_else_clause(cx.tcx, ex) && !is_coercion_casting(cx, if_let.let_expr, ex) && check_if_let(cx, if_let) {
             let mut applicability = Applicability::MachineApplicable;
             span_lint_and_sugg(
                 cx,
@@ -79,6 +64,19 @@ pub(crate) fn check(cx: &LateContext<'_>, ex: &Expr<'_>) {
     }
 }
 
+fn check_all_arms(cx: &LateContext<'_>, match_expr: &Expr<'_>, arms: &[Arm<'_>]) -> bool {
+    for arm in arms {
+        let arm_expr = peel_blocks_with_stmt(arm.body);
+        if let PatKind::Wild = arm.pat.kind {
+            return eq_expr_value(cx, match_expr, strip_return(arm_expr));
+        } else if !pat_same_as_expr(arm.pat, arm_expr) {
+            return false;
+        }
+    }
+
+    true
+}
+
 fn check_if_let(cx: &LateContext<'_>, if_let: &higher::IfLet<'_>) -> bool {
     if let Some(if_else) = if_let.if_else {
         if !pat_same_as_expr(if_let.let_pat, peel_blocks_with_stmt(if_let.if_then)) {
@@ -101,12 +99,12 @@ fn check_if_let(cx: &LateContext<'_>, if_let: &higher::IfLet<'_>) -> bool {
                 if let ExprKind::Path(ref qpath) = ret.kind {
                     return is_lang_ctor(cx, qpath, OptionNone) || eq_expr_value(cx, if_let.let_expr, ret);
                 }
-            } else {
-                return eq_expr_value(cx, if_let.let_expr, ret);
+                return true;
             }
-            return true;
+            return eq_expr_value(cx, if_let.let_expr, ret);
         }
     }
+
     false
 }
 
@@ -119,14 +117,52 @@ fn strip_return<'hir>(expr: &'hir Expr<'hir>) -> &'hir Expr<'hir> {
     }
 }
 
+/// Manually check for coercion casting by checking if the type of the match operand or let expr
+/// differs with the assigned local variable or the funtion return type.
+fn is_coercion_casting(cx: &LateContext<'_>, match_expr: &Expr<'_>, expr: &Expr<'_>) -> bool {
+    if let Some(p_node) = get_parent_node(cx.tcx, expr.hir_id) {
+        match p_node {
+            // Compare match_expr ty with local in `let local = match match_expr {..}`
+            Node::Local(local) => {
+                let results = cx.typeck_results();
+                return !same_type_and_consts(results.node_type(local.hir_id), results.expr_ty(match_expr));
+            },
+            // compare match_expr ty with RetTy in `fn foo() -> RetTy`
+            Node::Item(..) => {
+                if let Some(fn_decl) = p_node.fn_decl() {
+                    if let FnRetTy::Return(ret_ty) = fn_decl.output {
+                        return !same_type_and_consts(
+                            hir_ty_to_ty(cx.tcx, ret_ty),
+                            cx.typeck_results().expr_ty(match_expr),
+                        );
+                    }
+                }
+            },
+            // check the parent expr for this whole block `{ match match_expr {..} }`
+            Node::Block(block) => {
+                if let Some(block_parent_expr) = get_parent_expr_for_hir(cx, block.hir_id) {
+                    return is_coercion_casting(cx, match_expr, block_parent_expr);
+                }
+            },
+            // recursively call on `if xxx {..}` etc.
+            Node::Expr(p_expr) => {
+                return is_coercion_casting(cx, match_expr, p_expr);
+            },
+            _ => {},
+        }
+    }
+
+    false
+}
+
 fn pat_same_as_expr(pat: &Pat<'_>, expr: &Expr<'_>) -> bool {
     let expr = strip_return(expr);
     match (&pat.kind, &expr.kind) {
         // Example: `Some(val) => Some(val)`
         (PatKind::TupleStruct(QPath::Resolved(_, path), tuple_params, _), ExprKind::Call(call_expr, call_params)) => {
             if let ExprKind::Path(QPath::Resolved(_, call_path)) = call_expr.kind {
-                return has_identical_segments(path.segments, call_path.segments)
-                    && has_same_non_ref_symbols(tuple_params, call_params);
+                return same_segments(path.segments, call_path.segments)
+                    && same_non_ref_symbols(tuple_params, call_params);
             }
         },
         // Example: `val => val`
@@ -145,7 +181,7 @@ fn pat_same_as_expr(pat: &Pat<'_>, expr: &Expr<'_>) -> bool {
         },
         // Example: `Custom::TypeA => Custom::TypeB`, or `None => None`
         (PatKind::Path(QPath::Resolved(_, p_path)), ExprKind::Path(QPath::Resolved(_, e_path))) => {
-            return has_identical_segments(p_path.segments, e_path.segments);
+            return same_segments(p_path.segments, e_path.segments);
         },
         // Example: `5 => 5`
         (PatKind::Lit(pat_lit_expr), ExprKind::Lit(expr_spanned)) => {
@@ -159,19 +195,21 @@ fn pat_same_as_expr(pat: &Pat<'_>, expr: &Expr<'_>) -> bool {
     false
 }
 
-fn has_identical_segments(left_segs: &[PathSegment<'_>], right_segs: &[PathSegment<'_>]) -> bool {
+fn same_segments(left_segs: &[PathSegment<'_>], right_segs: &[PathSegment<'_>]) -> bool {
     if left_segs.len() != right_segs.len() {
         return false;
     }
+
     for i in 0..left_segs.len() {
         if left_segs[i].ident.name != right_segs[i].ident.name {
             return false;
         }
     }
+
     true
 }
 
-fn has_same_non_ref_symbols(pats: &[Pat<'_>], exprs: &[Expr<'_>]) -> bool {
+fn same_non_ref_symbols(pats: &[Pat<'_>], exprs: &[Expr<'_>]) -> bool {
     if pats.len() != exprs.len() {
         return false;
     }
diff --git a/tests/ui/needless_match.fixed b/tests/ui/needless_match.fixed
index 6a518f83925..d55dd589a54 100644
--- a/tests/ui/needless_match.fixed
+++ b/tests/ui/needless_match.fixed
@@ -60,8 +60,26 @@ fn result_match() {
     };
 }
 
-fn if_let_option() -> Option<i32> {
-    Some(1)
+fn if_let_option() {
+    let _ = Some(1);
+
+    fn do_something() {}
+
+    // Don't trigger
+    let _ = if let Some(a) = Some(1) {
+        Some(a)
+    } else {
+        do_something();
+        None
+    };
+
+    // Don't trigger
+    let _ = if let Some(a) = Some(1) {
+        do_something();
+        Some(a)
+    } else {
+        None
+    };
 }
 
 fn if_let_result() {
@@ -122,25 +140,45 @@ mod issue8542 {
             _ => ce,
         };
     }
+}
 
-    fn if_let_test() {
-        fn do_something() {}
+/// Lint triggered when type coercions happen.
+/// Do NOT trigger on any of these.
+mod issue8551 {
+    trait Trait {}
+    struct Struct;
+    impl Trait for Struct {}
+
+    fn optmap(s: Option<&Struct>) -> Option<&dyn Trait> {
+        match s {
+            Some(s) => Some(s),
+            None => None,
+        }
+    }
 
-        // Don't trigger
-        let _ = if let Some(a) = Some(1) {
-            Some(a)
-        } else {
-            do_something();
-            None
+    fn lint_tests() {
+        let option: Option<&Struct> = None;
+        let _: Option<&dyn Trait> = match option {
+            Some(s) => Some(s),
+            None => None,
         };
 
-        // Don't trigger
-        let _ = if let Some(a) = Some(1) {
-            do_something();
-            Some(a)
+        let _: Option<&dyn Trait> = if true {
+            match option {
+                Some(s) => Some(s),
+                None => None,
+            }
         } else {
             None
         };
+
+        let result: Result<&Struct, i32> = Err(0);
+        let _: Result<&dyn Trait, i32> = match result {
+            Ok(s) => Ok(s),
+            Err(e) => Err(e),
+        };
+
+        let _: Option<&dyn Trait> = if let Some(s) = option { Some(s) } else { None };
     }
 }
 
diff --git a/tests/ui/needless_match.rs b/tests/ui/needless_match.rs
index ffc6a291a15..f3c7ee01a47 100644
--- a/tests/ui/needless_match.rs
+++ b/tests/ui/needless_match.rs
@@ -83,8 +83,26 @@ fn result_match() {
     };
 }
 
-fn if_let_option() -> Option<i32> {
-    if let Some(a) = Some(1) { Some(a) } else { None }
+fn if_let_option() {
+    let _ = if let Some(a) = Some(1) { Some(a) } else { None };
+
+    fn do_something() {}
+
+    // Don't trigger
+    let _ = if let Some(a) = Some(1) {
+        Some(a)
+    } else {
+        do_something();
+        None
+    };
+
+    // Don't trigger
+    let _ = if let Some(a) = Some(1) {
+        do_something();
+        Some(a)
+    } else {
+        None
+    };
 }
 
 fn if_let_result() {
@@ -159,25 +177,45 @@ mod issue8542 {
             _ => ce,
         };
     }
+}
 
-    fn if_let_test() {
-        fn do_something() {}
+/// Lint triggered when type coercions happen.
+/// Do NOT trigger on any of these.
+mod issue8551 {
+    trait Trait {}
+    struct Struct;
+    impl Trait for Struct {}
+
+    fn optmap(s: Option<&Struct>) -> Option<&dyn Trait> {
+        match s {
+            Some(s) => Some(s),
+            None => None,
+        }
+    }
 
-        // Don't trigger
-        let _ = if let Some(a) = Some(1) {
-            Some(a)
-        } else {
-            do_something();
-            None
+    fn lint_tests() {
+        let option: Option<&Struct> = None;
+        let _: Option<&dyn Trait> = match option {
+            Some(s) => Some(s),
+            None => None,
         };
 
-        // Don't trigger
-        let _ = if let Some(a) = Some(1) {
-            do_something();
-            Some(a)
+        let _: Option<&dyn Trait> = if true {
+            match option {
+                Some(s) => Some(s),
+                None => None,
+            }
         } else {
             None
         };
+
+        let result: Result<&Struct, i32> = Err(0);
+        let _: Result<&dyn Trait, i32> = match result {
+            Ok(s) => Ok(s),
+            Err(e) => Err(e),
+        };
+
+        let _: Option<&dyn Trait> = if let Some(s) = option { Some(s) } else { None };
     }
 }
 
diff --git a/tests/ui/needless_match.stderr b/tests/ui/needless_match.stderr
index 67bd84d6bbc..34c5226f060 100644
--- a/tests/ui/needless_match.stderr
+++ b/tests/ui/needless_match.stderr
@@ -66,25 +66,25 @@ LL | |     };
    | |_____^ help: replace it with: `func_ret_err(0_i32)`
 
 error: this if-let expression is unnecessary
-  --> $DIR/needless_match.rs:87:5
+  --> $DIR/needless_match.rs:87:13
    |
-LL |     if let Some(a) = Some(1) { Some(a) } else { None }
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `Some(1)`
+LL |     let _ = if let Some(a) = Some(1) { Some(a) } else { None };
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `Some(1)`
 
 error: this if-let expression is unnecessary
-  --> $DIR/needless_match.rs:92:31
+  --> $DIR/needless_match.rs:110:31
    |
 LL |     let _: Result<i32, i32> = if let Err(e) = x { Err(e) } else { x };
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `x`
 
 error: this if-let expression is unnecessary
-  --> $DIR/needless_match.rs:93:31
+  --> $DIR/needless_match.rs:111:31
    |
 LL |     let _: Result<i32, i32> = if let Ok(val) = x { Ok(val) } else { x };
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `x`
 
 error: this if-let expression is unnecessary
-  --> $DIR/needless_match.rs:99:21
+  --> $DIR/needless_match.rs:117:21
    |
 LL |       let _: Simple = if let Simple::A = x {
    |  _____________________^
@@ -97,7 +97,7 @@ LL | |     };
    | |_____^ help: replace it with: `x`
 
 error: this match expression is unnecessary
-  --> $DIR/needless_match.rs:138:26
+  --> $DIR/needless_match.rs:156:26
    |
 LL |           let _: Complex = match ce {
    |  __________________________^
-- 
cgit 1.4.1-3-g733a5


From f49a2c345780abca24d4f5a5f9f821ea961c8fb6 Mon Sep 17 00:00:00 2001
From: Max Baumann <max@bmn.dev>
Date: Thu, 17 Mar 2022 18:57:28 +0100
Subject: feat: add use_unwrap_or

---
 CHANGELOG.md                                |   1 +
 clippy_lints/src/lib.register_all.rs        |   1 +
 clippy_lints/src/lib.register_complexity.rs |   1 +
 clippy_lints/src/lib.register_lints.rs      |   1 +
 clippy_lints/src/lib.rs                     |   2 +
 clippy_lints/src/use_unwrap_or.rs           | 105 ++++++++++++++++++++++++++++
 tests/ui/use_unwrap_or.rs                   |  27 +++++++
 tests/ui/use_unwrap_or.stderr               |  19 +++++
 8 files changed, 157 insertions(+)
 create mode 100644 clippy_lints/src/use_unwrap_or.rs
 create mode 100644 tests/ui/use_unwrap_or.rs
 create mode 100644 tests/ui/use_unwrap_or.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 2bc393d6042..9475c674983 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3538,6 +3538,7 @@ Released 2018-09-13
 [`upper_case_acronyms`]: https://rust-lang.github.io/rust-clippy/master/index.html#upper_case_acronyms
 [`use_debug`]: https://rust-lang.github.io/rust-clippy/master/index.html#use_debug
 [`use_self`]: https://rust-lang.github.io/rust-clippy/master/index.html#use_self
+[`use_unwrap_or`]: https://rust-lang.github.io/rust-clippy/master/index.html#use_unwrap_or
 [`used_underscore_binding`]: https://rust-lang.github.io/rust-clippy/master/index.html#used_underscore_binding
 [`useless_asref`]: https://rust-lang.github.io/rust-clippy/master/index.html#useless_asref
 [`useless_attribute`]: https://rust-lang.github.io/rust-clippy/master/index.html#useless_attribute
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 653d4daa6b6..a42f4cb6d70 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -310,6 +310,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(unwrap::PANICKING_UNWRAP),
     LintId::of(unwrap::UNNECESSARY_UNWRAP),
     LintId::of(upper_case_acronyms::UPPER_CASE_ACRONYMS),
+    LintId::of(use_unwrap_or::USE_UNWRAP_OR),
     LintId::of(useless_conversion::USELESS_CONVERSION),
     LintId::of(vec::USELESS_VEC),
     LintId::of(vec_init_then_push::VEC_INIT_THEN_PUSH),
diff --git a/clippy_lints/src/lib.register_complexity.rs b/clippy_lints/src/lib.register_complexity.rs
index 68d6c6ce5f7..94ff53c2a60 100644
--- a/clippy_lints/src/lib.register_complexity.rs
+++ b/clippy_lints/src/lib.register_complexity.rs
@@ -94,6 +94,7 @@ store.register_group(true, "clippy::complexity", Some("clippy_complexity"), vec!
     LintId::of(unit_types::UNIT_ARG),
     LintId::of(unnecessary_sort_by::UNNECESSARY_SORT_BY),
     LintId::of(unwrap::UNNECESSARY_UNWRAP),
+    LintId::of(use_unwrap_or::USE_UNWRAP_OR),
     LintId::of(useless_conversion::USELESS_CONVERSION),
     LintId::of(zero_div_zero::ZERO_DIVIDED_BY_ZERO),
 ])
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 1a45763a869..d1e13647e7e 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -528,6 +528,7 @@ store.register_lints(&[
     unwrap_in_result::UNWRAP_IN_RESULT,
     upper_case_acronyms::UPPER_CASE_ACRONYMS,
     use_self::USE_SELF,
+    use_unwrap_or::USE_UNWRAP_OR,
     useless_conversion::USELESS_CONVERSION,
     vec::USELESS_VEC,
     vec_init_then_push::VEC_INIT_THEN_PUSH,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 504235d0d1e..9c9e9643bc9 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -394,6 +394,7 @@ mod unwrap;
 mod unwrap_in_result;
 mod upper_case_acronyms;
 mod use_self;
+mod use_unwrap_or;
 mod useless_conversion;
 mod vec;
 mod vec_init_then_push;
@@ -866,6 +867,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
             ignore_publish: cargo_ignore_publish,
         })
     });
+    store.register_late_pass(|| Box::new(use_unwrap_or::UseUnwrapOr));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/use_unwrap_or.rs b/clippy_lints/src/use_unwrap_or.rs
new file mode 100644
index 00000000000..f42e28246d4
--- /dev/null
+++ b/clippy_lints/src/use_unwrap_or.rs
@@ -0,0 +1,105 @@
+use if_chain::if_chain;
+use rustc_hir::*;
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::{Span, sym};
+use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::ty::is_type_diagnostic_item;
+
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `.or(…).unwrap()` calls to Options and Results.
+    ///
+    /// ### Why is this bad?
+    /// You should use `.unwrap_or(…)` instead for clarity.
+    ///
+    /// ### Example
+    /// ```rust
+    /// // Result
+    /// let port = result.or::<Error>(Ok(fallback)).unwrap();
+    ///
+    /// // Option
+    /// let value = option.or(Some(fallback)).unwrap();
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// // Result
+    /// let port = result.unwrap_or(fallback);
+    ///
+    /// // Option
+    /// let value = option.unwrap_or(fallback);
+    /// ```
+    #[clippy::version = "1.61.0"]
+    pub USE_UNWRAP_OR,
+    complexity,
+    "checks for `.or(…).unwrap()` calls to Options and Results."
+}
+declare_lint_pass!(UseUnwrapOr => [USE_UNWRAP_OR]);
+
+impl<'tcx> LateLintPass<'tcx> for UseUnwrapOr {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+
+        // look for x.or().unwrap()
+        if_chain! {
+            if let ExprKind::MethodCall(path, args, unwrap_span) = expr.kind;
+            if path.ident.name.as_str() == "unwrap";
+            if let Some(caller) = args.first();
+            if let ExprKind::MethodCall(caller_path, caller_args, or_span) = caller.kind;
+            if caller_path.ident.name.as_str() == "or";
+            then {
+                let ty = cx.typeck_results().expr_ty(&caller_args[0]); // get type of x (we later check if it's Option or Result)
+                let title;
+                let arg = &caller_args[1]; // the argument or(xyz) is called with
+
+                if is_type_diagnostic_item(&cx, ty, sym::Option) {
+                    title = ".or(Some(…)).unwrap() found";
+                    if !is(arg, "Some") {
+                        return;
+                    }
+
+                } else if is_type_diagnostic_item(&cx, ty, sym::Result) {
+                    title = ".or(Ok(…)).unwrap() found";
+                    if !is(arg, "Ok") {
+                        return;
+                    }
+                } else {
+                    // Someone has implemented a struct with .or(...).unwrap() chaining,
+                    // but it's not an Option or a Result, so bail
+                    return;
+                }
+
+                // span = or_span + unwrap_span
+                let span = Span::new(or_span.lo(), unwrap_span.hi(), or_span.ctxt(), or_span.parent());
+
+                span_lint_and_help(
+                    cx,
+                    USE_UNWRAP_OR,
+                    span,
+                    title,
+                    None,
+                    "use `unwrap_or()` instead"
+                );
+            }
+        }
+    }
+}
+
+/// is expr a Call to name?
+/// name might be "Some", "Ok", "Err", etc.
+fn is<'a>(expr: &Expr<'a>, name: &str) -> bool {
+    if_chain! {
+        if let ExprKind::Call(some_expr, _some_args) = expr.kind;
+        if let ExprKind::Path(path) = &some_expr.kind;
+        if let QPath::Resolved(_, path) = path;
+        if let Some(path_segment) = path.segments.first();
+        if path_segment.ident.name.as_str() == name;
+        then {
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+}
+
diff --git a/tests/ui/use_unwrap_or.rs b/tests/ui/use_unwrap_or.rs
new file mode 100644
index 00000000000..0bfabaae885
--- /dev/null
+++ b/tests/ui/use_unwrap_or.rs
@@ -0,0 +1,27 @@
+#![warn(clippy::use_unwrap_or)]
+
+struct SomeStruct {}
+impl SomeStruct {
+    fn or(self, _: Option<Self>) -> Self { self }
+    fn unwrap(&self){}
+}
+
+fn main() {
+    let option: Option<&str> = None;
+    let _ = option.or(Some("fallback")).unwrap(); // should trigger lint
+
+    let result: Result<&str, &str> = Err("Error");
+    let _ = result.or::<&str>(Ok("fallback")).unwrap(); // should trigger lint
+
+    // Not Option/Result
+    let instance = SomeStruct {};
+    let _ = instance.or(Some(SomeStruct {})).unwrap(); // should not trigger lint
+
+    // None in or
+    let option: Option<&str> = None;
+    let _ = option.or(None).unwrap(); // should not trigger lint
+
+    // Not Err in or
+    let result: Result<&str, &str> = Err("Error");
+    let _ = result.or::<&str>(Err("Other Error")).unwrap(); // should not trigger lint
+}
diff --git a/tests/ui/use_unwrap_or.stderr b/tests/ui/use_unwrap_or.stderr
new file mode 100644
index 00000000000..5bbba41f7ac
--- /dev/null
+++ b/tests/ui/use_unwrap_or.stderr
@@ -0,0 +1,19 @@
+error: .or(Some(…)).unwrap() found
+  --> $DIR/use_unwrap_or.rs:11:20
+   |
+LL |     let _ = option.or(Some("fallback")).unwrap(); // should trigger lint
+   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::use-unwrap-or` implied by `-D warnings`
+   = help: use `unwrap_or()` instead
+
+error: .or(Ok(…)).unwrap() found
+  --> $DIR/use_unwrap_or.rs:14:20
+   |
+LL |     let _ = result.or::<&str>(Ok("fallback")).unwrap(); // should trigger lint
+   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use `unwrap_or()` instead
+
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 3f00f074de3f6debe594e11066864a0da1dfe4af Mon Sep 17 00:00:00 2001
From: Max Baumann <max@bmn.dev>
Date: Thu, 17 Mar 2022 19:13:44 +0100
Subject: fix: fix tests

---
 clippy_lints/src/use_unwrap_or.rs | 22 +++++++++-------------
 tests/ui/use_unwrap_or.rs         |  6 ++++--
 tests/ui/use_unwrap_or.stderr     |  4 ++--
 3 files changed, 15 insertions(+), 17 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/use_unwrap_or.rs b/clippy_lints/src/use_unwrap_or.rs
index f42e28246d4..05369000444 100644
--- a/clippy_lints/src/use_unwrap_or.rs
+++ b/clippy_lints/src/use_unwrap_or.rs
@@ -1,11 +1,10 @@
+use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
-use rustc_hir::*;
+use rustc_hir::{Expr, ExprKind, QPath};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::{Span, sym};
-use clippy_utils::diagnostics::span_lint_and_help;
-use clippy_utils::ty::is_type_diagnostic_item;
-
+use rustc_span::{sym, Span};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -39,7 +38,6 @@ declare_lint_pass!(UseUnwrapOr => [USE_UNWRAP_OR]);
 
 impl<'tcx> LateLintPass<'tcx> for UseUnwrapOr {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-
         // look for x.or().unwrap()
         if_chain! {
             if let ExprKind::MethodCall(path, args, unwrap_span) = expr.kind;
@@ -52,13 +50,13 @@ impl<'tcx> LateLintPass<'tcx> for UseUnwrapOr {
                 let title;
                 let arg = &caller_args[1]; // the argument or(xyz) is called with
 
-                if is_type_diagnostic_item(&cx, ty, sym::Option) {
+                if is_type_diagnostic_item(cx, ty, sym::Option) {
                     title = ".or(Some(…)).unwrap() found";
                     if !is(arg, "Some") {
                         return;
                     }
 
-                } else if is_type_diagnostic_item(&cx, ty, sym::Result) {
+                } else if is_type_diagnostic_item(cx, ty, sym::Result) {
                     title = ".or(Ok(…)).unwrap() found";
                     if !is(arg, "Ok") {
                         return;
@@ -90,16 +88,14 @@ impl<'tcx> LateLintPass<'tcx> for UseUnwrapOr {
 fn is<'a>(expr: &Expr<'a>, name: &str) -> bool {
     if_chain! {
         if let ExprKind::Call(some_expr, _some_args) = expr.kind;
-        if let ExprKind::Path(path) = &some_expr.kind;
-        if let QPath::Resolved(_, path) = path;
+        if let ExprKind::Path(QPath::Resolved(_, path)) = &some_expr.kind;
         if let Some(path_segment) = path.segments.first();
         if path_segment.ident.name.as_str() == name;
         then {
-            return true;
+            true
         }
         else {
-            return false;
+            false
         }
     }
 }
-
diff --git a/tests/ui/use_unwrap_or.rs b/tests/ui/use_unwrap_or.rs
index 0bfabaae885..685fab80206 100644
--- a/tests/ui/use_unwrap_or.rs
+++ b/tests/ui/use_unwrap_or.rs
@@ -2,8 +2,10 @@
 
 struct SomeStruct {}
 impl SomeStruct {
-    fn or(self, _: Option<Self>) -> Self { self }
-    fn unwrap(&self){}
+    fn or(self, _: Option<Self>) -> Self {
+        self
+    }
+    fn unwrap(&self) {}
 }
 
 fn main() {
diff --git a/tests/ui/use_unwrap_or.stderr b/tests/ui/use_unwrap_or.stderr
index 5bbba41f7ac..2e1e920795d 100644
--- a/tests/ui/use_unwrap_or.stderr
+++ b/tests/ui/use_unwrap_or.stderr
@@ -1,5 +1,5 @@
 error: .or(Some(…)).unwrap() found
-  --> $DIR/use_unwrap_or.rs:11:20
+  --> $DIR/use_unwrap_or.rs:13:20
    |
 LL |     let _ = option.or(Some("fallback")).unwrap(); // should trigger lint
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -8,7 +8,7 @@ LL |     let _ = option.or(Some("fallback")).unwrap(); // should trigger lint
    = help: use `unwrap_or()` instead
 
 error: .or(Ok(…)).unwrap() found
-  --> $DIR/use_unwrap_or.rs:14:20
+  --> $DIR/use_unwrap_or.rs:16:20
    |
 LL |     let _ = result.or::<&str>(Ok("fallback")).unwrap(); // should trigger lint
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From 747bb245e7cb131917e7a3828356c14a7316ca70 Mon Sep 17 00:00:00 2001
From: Max Baumann <max@bmn.dev>
Date: Thu, 17 Mar 2022 19:29:59 +0100
Subject: fix: fix broken dogfood tests

---
 clippy_lints/src/use_unwrap_or.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/use_unwrap_or.rs b/clippy_lints/src/use_unwrap_or.rs
index 05369000444..29bdec2cae8 100644
--- a/clippy_lints/src/use_unwrap_or.rs
+++ b/clippy_lints/src/use_unwrap_or.rs
@@ -41,10 +41,10 @@ impl<'tcx> LateLintPass<'tcx> for UseUnwrapOr {
         // look for x.or().unwrap()
         if_chain! {
             if let ExprKind::MethodCall(path, args, unwrap_span) = expr.kind;
-            if path.ident.name.as_str() == "unwrap";
+            if path.ident.name == sym::unwrap;
             if let Some(caller) = args.first();
             if let ExprKind::MethodCall(caller_path, caller_args, or_span) = caller.kind;
-            if caller_path.ident.name.as_str() == "or";
+            if caller_path.ident.name == sym::or;
             then {
                 let ty = cx.typeck_results().expr_ty(&caller_args[0]); // get type of x (we later check if it's Option or Result)
                 let title;
-- 
cgit 1.4.1-3-g733a5


From c22ff6cd6e9dd19b31f85b9464a986023d732944 Mon Sep 17 00:00:00 2001
From: Max Baumann <max@bmn.dev>
Date: Thu, 17 Mar 2022 19:52:07 +0100
Subject: fix: fix clippy_lints

---
 clippy_lints/src/use_unwrap_or.rs | 7 +++++++
 1 file changed, 7 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/use_unwrap_or.rs b/clippy_lints/src/use_unwrap_or.rs
index 29bdec2cae8..e4276551242 100644
--- a/clippy_lints/src/use_unwrap_or.rs
+++ b/clippy_lints/src/use_unwrap_or.rs
@@ -15,18 +15,25 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust
+    /// # let fallback = "fallback";
     /// // Result
+    /// # type Error = &'static str;
+    /// # let result: Result<&str, Error> = Err("error");
     /// let port = result.or::<Error>(Ok(fallback)).unwrap();
     ///
     /// // Option
+    /// # let option: Option<&str> = None;
     /// let value = option.or(Some(fallback)).unwrap();
     /// ```
     /// Use instead:
     /// ```rust
+    /// # let fallback = "fallback";
     /// // Result
+    /// # let result: Result<&str, &str> = Err("error");
     /// let port = result.unwrap_or(fallback);
     ///
     /// // Option
+    /// # let option: Option<&str> = None;
     /// let value = option.unwrap_or(fallback);
     /// ```
     #[clippy::version = "1.61.0"]
-- 
cgit 1.4.1-3-g733a5


From 4493fc7d27449cc751d890de0f3b9390f284bfbb Mon Sep 17 00:00:00 2001
From: Max Baumann <max@bmn.dev>
Date: Fri, 18 Mar 2022 00:23:55 +0100
Subject: refactor: use pattern matching for MethodCall arguments

Co-authored-by: xFrednet <xFrednet@gmail.com>
---
 clippy_lints/src/use_unwrap_or.rs | 20 +++++++-------------
 1 file changed, 7 insertions(+), 13 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/use_unwrap_or.rs b/clippy_lints/src/use_unwrap_or.rs
index e4276551242..bb777b08d8b 100644
--- a/clippy_lints/src/use_unwrap_or.rs
+++ b/clippy_lints/src/use_unwrap_or.rs
@@ -4,7 +4,7 @@ use if_chain::if_chain;
 use rustc_hir::{Expr, ExprKind, QPath};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::{sym, Span};
+use rustc_span::sym;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -47,25 +47,22 @@ impl<'tcx> LateLintPass<'tcx> for UseUnwrapOr {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         // look for x.or().unwrap()
         if_chain! {
-            if let ExprKind::MethodCall(path, args, unwrap_span) = expr.kind;
+            if let ExprKind::MethodCall(path, [unwrap_self], unwrap_span) = expr.kind;
             if path.ident.name == sym::unwrap;
-            if let Some(caller) = args.first();
-            if let ExprKind::MethodCall(caller_path, caller_args, or_span) = caller.kind;
+            if let ExprKind::MethodCall(caller_path, [or_self, or_arg], or_span) = unwrap_self.kind;
             if caller_path.ident.name == sym::or;
             then {
-                let ty = cx.typeck_results().expr_ty(&caller_args[0]); // get type of x (we later check if it's Option or Result)
+                let ty = cx.typeck_results().expr_ty(&or_self); // get type of x (we later check if it's Option or Result)
                 let title;
-                let arg = &caller_args[1]; // the argument or(xyz) is called with
 
                 if is_type_diagnostic_item(cx, ty, sym::Option) {
                     title = ".or(Some(…)).unwrap() found";
-                    if !is(arg, "Some") {
+                    if !is(or_arg, "Some") {
                         return;
                     }
-
                 } else if is_type_diagnostic_item(cx, ty, sym::Result) {
                     title = ".or(Ok(…)).unwrap() found";
-                    if !is(arg, "Ok") {
+                    if !is(or_arg, "Ok") {
                         return;
                     }
                 } else {
@@ -74,13 +71,10 @@ impl<'tcx> LateLintPass<'tcx> for UseUnwrapOr {
                     return;
                 }
 
-                // span = or_span + unwrap_span
-                let span = Span::new(or_span.lo(), unwrap_span.hi(), or_span.ctxt(), or_span.parent());
-
                 span_lint_and_help(
                     cx,
                     USE_UNWRAP_OR,
-                    span,
+                    or_span.to(unwrap_span),
                     title,
                     None,
                     "use `unwrap_or()` instead"
-- 
cgit 1.4.1-3-g733a5


From 17ff85081d969c125b3b0abeb0366d163853ee7a Mon Sep 17 00:00:00 2001
From: Max Baumann <max@bmn.dev>
Date: Fri, 18 Mar 2022 00:34:24 +0100
Subject: feat: rename variable in example

---
 clippy_lints/src/use_unwrap_or.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/use_unwrap_or.rs b/clippy_lints/src/use_unwrap_or.rs
index bb777b08d8b..8dc28231995 100644
--- a/clippy_lints/src/use_unwrap_or.rs
+++ b/clippy_lints/src/use_unwrap_or.rs
@@ -19,7 +19,7 @@ declare_clippy_lint! {
     /// // Result
     /// # type Error = &'static str;
     /// # let result: Result<&str, Error> = Err("error");
-    /// let port = result.or::<Error>(Ok(fallback)).unwrap();
+    /// let value = result.or::<Error>(Ok(fallback)).unwrap();
     ///
     /// // Option
     /// # let option: Option<&str> = None;
@@ -30,7 +30,7 @@ declare_clippy_lint! {
     /// # let fallback = "fallback";
     /// // Result
     /// # let result: Result<&str, &str> = Err("error");
-    /// let port = result.unwrap_or(fallback);
+    /// let value = result.unwrap_or(fallback);
     ///
     /// // Option
     /// # let option: Option<&str> = None;
-- 
cgit 1.4.1-3-g733a5


From 44c62c9aa23e0d8401d9bdc1e2df913cfd035c7e Mon Sep 17 00:00:00 2001
From: Max Baumann <max@bmn.dev>
Date: Fri, 18 Mar 2022 00:51:26 +0100
Subject: feat: add tests and fix existing ones

---
 clippy_lints/src/use_unwrap_or.rs |  8 ++++----
 tests/ui/use_unwrap_or.rs         | 16 ++++++++++++++++
 tests/ui/use_unwrap_or.stderr     |  4 ++--
 3 files changed, 22 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/use_unwrap_or.rs b/clippy_lints/src/use_unwrap_or.rs
index 8dc28231995..3e40014f50f 100644
--- a/clippy_lints/src/use_unwrap_or.rs
+++ b/clippy_lints/src/use_unwrap_or.rs
@@ -47,12 +47,12 @@ impl<'tcx> LateLintPass<'tcx> for UseUnwrapOr {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         // look for x.or().unwrap()
         if_chain! {
-            if let ExprKind::MethodCall(path, [unwrap_self], unwrap_span) = expr.kind;
+            if let ExprKind::MethodCall(path, [unwrap_self], unwrap_span) = &expr.kind;
             if path.ident.name == sym::unwrap;
-            if let ExprKind::MethodCall(caller_path, [or_self, or_arg], or_span) = unwrap_self.kind;
+            if let ExprKind::MethodCall(caller_path, [or_self, or_arg], or_span) = &unwrap_self.kind;
             if caller_path.ident.name == sym::or;
             then {
-                let ty = cx.typeck_results().expr_ty(&or_self); // get type of x (we later check if it's Option or Result)
+                let ty = cx.typeck_results().expr_ty(or_self); // get type of x (we later check if it's Option or Result)
                 let title;
 
                 if is_type_diagnostic_item(cx, ty, sym::Option) {
@@ -74,7 +74,7 @@ impl<'tcx> LateLintPass<'tcx> for UseUnwrapOr {
                 span_lint_and_help(
                     cx,
                     USE_UNWRAP_OR,
-                    or_span.to(unwrap_span),
+                    or_span.to(*unwrap_span),
                     title,
                     None,
                     "use `unwrap_or()` instead"
diff --git a/tests/ui/use_unwrap_or.rs b/tests/ui/use_unwrap_or.rs
index 685fab80206..dd55b33739d 100644
--- a/tests/ui/use_unwrap_or.rs
+++ b/tests/ui/use_unwrap_or.rs
@@ -1,4 +1,5 @@
 #![warn(clippy::use_unwrap_or)]
+#![allow(clippy::map_identity)]
 
 struct SomeStruct {}
 impl SomeStruct {
@@ -8,6 +9,14 @@ impl SomeStruct {
     fn unwrap(&self) {}
 }
 
+struct SomeOtherStruct {}
+impl SomeOtherStruct {
+    fn or(self) -> Self {
+        self
+    }
+    fn unwrap(&self) {}
+}
+
 fn main() {
     let option: Option<&str> = None;
     let _ = option.or(Some("fallback")).unwrap(); // should trigger lint
@@ -19,6 +28,9 @@ fn main() {
     let instance = SomeStruct {};
     let _ = instance.or(Some(SomeStruct {})).unwrap(); // should not trigger lint
 
+    let instance = SomeOtherStruct {};
+    let _ = instance.or().unwrap(); // should not trigger lint and should not panic
+
     // None in or
     let option: Option<&str> = None;
     let _ = option.or(None).unwrap(); // should not trigger lint
@@ -26,4 +38,8 @@ fn main() {
     // Not Err in or
     let result: Result<&str, &str> = Err("Error");
     let _ = result.or::<&str>(Err("Other Error")).unwrap(); // should not trigger lint
+
+    // other function between
+    let option: Option<&str> = None;
+    let _ = option.or(Some("fallback")).map(|v| v).unwrap(); // should not trigger lint
 }
diff --git a/tests/ui/use_unwrap_or.stderr b/tests/ui/use_unwrap_or.stderr
index 2e1e920795d..796778a293d 100644
--- a/tests/ui/use_unwrap_or.stderr
+++ b/tests/ui/use_unwrap_or.stderr
@@ -1,5 +1,5 @@
 error: .or(Some(…)).unwrap() found
-  --> $DIR/use_unwrap_or.rs:13:20
+  --> $DIR/use_unwrap_or.rs:22:20
    |
 LL |     let _ = option.or(Some("fallback")).unwrap(); // should trigger lint
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -8,7 +8,7 @@ LL |     let _ = option.or(Some("fallback")).unwrap(); // should trigger lint
    = help: use `unwrap_or()` instead
 
 error: .or(Ok(…)).unwrap() found
-  --> $DIR/use_unwrap_or.rs:16:20
+  --> $DIR/use_unwrap_or.rs:25:20
    |
 LL |     let _ = result.or::<&str>(Ok("fallback")).unwrap(); // should trigger lint
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From 39329d1d404d38437270acf3cb1337a231367efc Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Thu, 17 Mar 2022 16:04:45 -0400
Subject: Add lint `cast_enum_constructor`

---
 CHANGELOG.md                                    |  1 +
 clippy_lints/src/casts/cast_enum_constructor.rs | 21 +++++++++++++++++++++
 clippy_lints/src/casts/mod.rs                   | 21 +++++++++++++++++++++
 clippy_lints/src/lib.register_all.rs            |  1 +
 clippy_lints/src/lib.register_lints.rs          |  1 +
 clippy_lints/src/lib.register_suspicious.rs     |  1 +
 tests/ui/cast_enum_constructor.rs               | 17 +++++++++++++++++
 tests/ui/cast_enum_constructor.stderr           | 16 ++++++++++++++++
 8 files changed, 79 insertions(+)
 create mode 100644 clippy_lints/src/casts/cast_enum_constructor.rs
 create mode 100644 tests/ui/cast_enum_constructor.rs
 create mode 100644 tests/ui/cast_enum_constructor.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 2bc393d6042..04e072d0abf 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3069,6 +3069,7 @@ Released 2018-09-13
 [`bytes_nth`]: https://rust-lang.github.io/rust-clippy/master/index.html#bytes_nth
 [`cargo_common_metadata`]: https://rust-lang.github.io/rust-clippy/master/index.html#cargo_common_metadata
 [`case_sensitive_file_extension_comparisons`]: https://rust-lang.github.io/rust-clippy/master/index.html#case_sensitive_file_extension_comparisons
+[`cast_enum_constructor`]: https://rust-lang.github.io/rust-clippy/master/index.html#cast_enum_constructor
 [`cast_enum_truncation`]: https://rust-lang.github.io/rust-clippy/master/index.html#cast_enum_truncation
 [`cast_lossless`]: https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
 [`cast_possible_truncation`]: https://rust-lang.github.io/rust-clippy/master/index.html#cast_possible_truncation
diff --git a/clippy_lints/src/casts/cast_enum_constructor.rs b/clippy_lints/src/casts/cast_enum_constructor.rs
new file mode 100644
index 00000000000..1973692e105
--- /dev/null
+++ b/clippy_lints/src/casts/cast_enum_constructor.rs
@@ -0,0 +1,21 @@
+use clippy_utils::diagnostics::span_lint;
+use rustc_hir::def::{CtorKind, CtorOf, DefKind, Res};
+use rustc_hir::{Expr, ExprKind};
+use rustc_lint::LateContext;
+use rustc_middle::ty::{self, Ty};
+
+use super::CAST_ENUM_CONSTRUCTOR;
+
+pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_expr: &Expr<'_>, cast_from: Ty<'_>) {
+    if matches!(cast_from.kind(), ty::FnDef(..))
+        && let ExprKind::Path(path) = &cast_expr.kind
+        && let Res::Def(DefKind::Ctor(CtorOf::Variant, CtorKind::Fn), _) = cx.qpath_res(path, cast_expr.hir_id)
+    {
+        span_lint(
+            cx,
+            CAST_ENUM_CONSTRUCTOR,
+            expr.span,
+            "cast of an enum tuple constructor to an integer",
+        );
+    }
+}
diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index 6a0eabd089d..be59145afa0 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -1,3 +1,4 @@
+mod cast_enum_constructor;
 mod cast_lossless;
 mod cast_possible_truncation;
 mod cast_possible_wrap;
@@ -454,6 +455,24 @@ declare_clippy_lint! {
     "casting using `as` between raw pointers to slices of types with different sizes"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for casts from an enum tuple constructor to an integer.
+    ///
+    /// ### Why is this bad?
+    /// The cast is easily confused with casting a c-like enum value to an integer.
+    ///
+    /// ### Example
+    /// ```rust
+    /// enum E { X(i32) };
+    /// let _ = E::X as usize;
+    /// ```
+    #[clippy::version = "1.61.0"]
+    pub CAST_ENUM_CONSTRUCTOR,
+    suspicious,
+    "casts from an enum tuple constructor to an integer"
+}
+
 pub struct Casts {
     msrv: Option<RustcVersion>,
 }
@@ -481,6 +500,7 @@ impl_lint_pass!(Casts => [
     CHAR_LIT_AS_U8,
     PTR_AS_PTR,
     CAST_ENUM_TRUNCATION,
+    CAST_ENUM_CONSTRUCTOR
 ]);
 
 impl<'tcx> LateLintPass<'tcx> for Casts {
@@ -518,6 +538,7 @@ impl<'tcx> LateLintPass<'tcx> for Casts {
                     cast_sign_loss::check(cx, expr, cast_expr, cast_from, cast_to);
                 }
                 cast_lossless::check(cx, expr, cast_expr, cast_from, cast_to, &self.msrv);
+                cast_enum_constructor::check(cx, expr, cast_expr, cast_from);
             }
         }
 
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 653d4daa6b6..e360757f781 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -23,6 +23,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(bool_assert_comparison::BOOL_ASSERT_COMPARISON),
     LintId::of(booleans::LOGIC_BUG),
     LintId::of(booleans::NONMINIMAL_BOOL),
+    LintId::of(casts::CAST_ENUM_CONSTRUCTOR),
     LintId::of(casts::CAST_ENUM_TRUNCATION),
     LintId::of(casts::CAST_REF_TO_MUT),
     LintId::of(casts::CAST_SLICE_DIFFERENT_SIZES),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 1a45763a869..a1a9ca37c95 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -70,6 +70,7 @@ store.register_lints(&[
     cargo::REDUNDANT_FEATURE_NAMES,
     cargo::WILDCARD_DEPENDENCIES,
     case_sensitive_file_extension_comparisons::CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS,
+    casts::CAST_ENUM_CONSTRUCTOR,
     casts::CAST_ENUM_TRUNCATION,
     casts::CAST_LOSSLESS,
     casts::CAST_POSSIBLE_TRUNCATION,
diff --git a/clippy_lints/src/lib.register_suspicious.rs b/clippy_lints/src/lib.register_suspicious.rs
index 465baa82581..fa3a88e1368 100644
--- a/clippy_lints/src/lib.register_suspicious.rs
+++ b/clippy_lints/src/lib.register_suspicious.rs
@@ -7,6 +7,7 @@ store.register_group(true, "clippy::suspicious", Some("clippy_suspicious"), vec!
     LintId::of(attrs::BLANKET_CLIPPY_RESTRICTION_LINTS),
     LintId::of(await_holding_invalid::AWAIT_HOLDING_LOCK),
     LintId::of(await_holding_invalid::AWAIT_HOLDING_REFCELL_REF),
+    LintId::of(casts::CAST_ENUM_CONSTRUCTOR),
     LintId::of(casts::CAST_ENUM_TRUNCATION),
     LintId::of(eval_order_dependence::EVAL_ORDER_DEPENDENCE),
     LintId::of(float_equality_without_abs::FLOAT_EQUALITY_WITHOUT_ABS),
diff --git a/tests/ui/cast_enum_constructor.rs b/tests/ui/cast_enum_constructor.rs
new file mode 100644
index 00000000000..0193454ad14
--- /dev/null
+++ b/tests/ui/cast_enum_constructor.rs
@@ -0,0 +1,17 @@
+#![warn(clippy::cast_enum_constructor)]
+#![allow(clippy::fn_to_numeric_cast)]
+
+fn main() {
+    enum Foo {
+        Y(u32),
+    }
+
+    enum Bar {
+        X,
+    }
+
+    let _ = Foo::Y as usize;
+    let _ = Foo::Y as isize;
+    let _ = Foo::Y as fn(u32) -> Foo;
+    let _ = Bar::X as usize;
+}
diff --git a/tests/ui/cast_enum_constructor.stderr b/tests/ui/cast_enum_constructor.stderr
new file mode 100644
index 00000000000..710909dd26f
--- /dev/null
+++ b/tests/ui/cast_enum_constructor.stderr
@@ -0,0 +1,16 @@
+error: cast of an enum tuple constructor to an integer
+  --> $DIR/cast_enum_constructor.rs:13:13
+   |
+LL |     let _ = Foo::Y as usize;
+   |             ^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::cast-enum-constructor` implied by `-D warnings`
+
+error: cast of an enum tuple constructor to an integer
+  --> $DIR/cast_enum_constructor.rs:14:13
+   |
+LL |     let _ = Foo::Y as isize;
+   |             ^^^^^^^^^^^^^^^
+
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 05e05eaed7f512bf2a1f7f236fc4b484d4a52aa5 Mon Sep 17 00:00:00 2001
From: Max Baumann <max@bmn.dev>
Date: Fri, 18 Mar 2022 01:04:33 +0100
Subject: refactor: rename lint to or_then_unwrap

---
 CHANGELOG.md                                |   2 +-
 clippy_lints/src/lib.register_all.rs        |   2 +-
 clippy_lints/src/lib.register_complexity.rs |   2 +-
 clippy_lints/src/lib.register_lints.rs      |   2 +-
 clippy_lints/src/lib.rs                     |   4 +-
 clippy_lints/src/or_then_unwrap.rs          | 102 ++++++++++++++++++++++++++++
 clippy_lints/src/use_unwrap_or.rs           | 102 ----------------------------
 tests/ui/or_then_unwrap.rs                  |  45 ++++++++++++
 tests/ui/or_then_unwrap.stderr              |  19 ++++++
 tests/ui/use_unwrap_or.rs                   |  45 ------------
 tests/ui/use_unwrap_or.stderr               |  19 ------
 11 files changed, 172 insertions(+), 172 deletions(-)
 create mode 100644 clippy_lints/src/or_then_unwrap.rs
 delete mode 100644 clippy_lints/src/use_unwrap_or.rs
 create mode 100644 tests/ui/or_then_unwrap.rs
 create mode 100644 tests/ui/or_then_unwrap.stderr
 delete mode 100644 tests/ui/use_unwrap_or.rs
 delete mode 100644 tests/ui/use_unwrap_or.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9475c674983..b45be38bf4d 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3538,7 +3538,7 @@ Released 2018-09-13
 [`upper_case_acronyms`]: https://rust-lang.github.io/rust-clippy/master/index.html#upper_case_acronyms
 [`use_debug`]: https://rust-lang.github.io/rust-clippy/master/index.html#use_debug
 [`use_self`]: https://rust-lang.github.io/rust-clippy/master/index.html#use_self
-[`use_unwrap_or`]: https://rust-lang.github.io/rust-clippy/master/index.html#use_unwrap_or
+[`or_then_unwrap`]: https://rust-lang.github.io/rust-clippy/master/index.html#or_then_unwrap
 [`used_underscore_binding`]: https://rust-lang.github.io/rust-clippy/master/index.html#used_underscore_binding
 [`useless_asref`]: https://rust-lang.github.io/rust-clippy/master/index.html#useless_asref
 [`useless_attribute`]: https://rust-lang.github.io/rust-clippy/master/index.html#useless_attribute
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index a42f4cb6d70..5c3e352d09f 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -310,7 +310,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(unwrap::PANICKING_UNWRAP),
     LintId::of(unwrap::UNNECESSARY_UNWRAP),
     LintId::of(upper_case_acronyms::UPPER_CASE_ACRONYMS),
-    LintId::of(use_unwrap_or::USE_UNWRAP_OR),
+    LintId::of(or_then_unwrap::OR_THEN_UNWRAP),
     LintId::of(useless_conversion::USELESS_CONVERSION),
     LintId::of(vec::USELESS_VEC),
     LintId::of(vec_init_then_push::VEC_INIT_THEN_PUSH),
diff --git a/clippy_lints/src/lib.register_complexity.rs b/clippy_lints/src/lib.register_complexity.rs
index 94ff53c2a60..45ad1520396 100644
--- a/clippy_lints/src/lib.register_complexity.rs
+++ b/clippy_lints/src/lib.register_complexity.rs
@@ -94,7 +94,7 @@ store.register_group(true, "clippy::complexity", Some("clippy_complexity"), vec!
     LintId::of(unit_types::UNIT_ARG),
     LintId::of(unnecessary_sort_by::UNNECESSARY_SORT_BY),
     LintId::of(unwrap::UNNECESSARY_UNWRAP),
-    LintId::of(use_unwrap_or::USE_UNWRAP_OR),
+    LintId::of(or_then_unwrap::OR_THEN_UNWRAP),
     LintId::of(useless_conversion::USELESS_CONVERSION),
     LintId::of(zero_div_zero::ZERO_DIVIDED_BY_ZERO),
 ])
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index d1e13647e7e..aad0c8735ee 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -528,7 +528,7 @@ store.register_lints(&[
     unwrap_in_result::UNWRAP_IN_RESULT,
     upper_case_acronyms::UPPER_CASE_ACRONYMS,
     use_self::USE_SELF,
-    use_unwrap_or::USE_UNWRAP_OR,
+    or_then_unwrap::OR_THEN_UNWRAP,
     useless_conversion::USELESS_CONVERSION,
     vec::USELESS_VEC,
     vec_init_then_push::VEC_INIT_THEN_PUSH,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 9c9e9643bc9..fdab58935ef 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -322,6 +322,7 @@ mod only_used_in_recursion;
 mod open_options;
 mod option_env_unwrap;
 mod option_if_let_else;
+mod or_then_unwrap;
 mod overflow_check_conditional;
 mod panic_in_result_fn;
 mod panic_unimplemented;
@@ -394,7 +395,6 @@ mod unwrap;
 mod unwrap_in_result;
 mod upper_case_acronyms;
 mod use_self;
-mod use_unwrap_or;
 mod useless_conversion;
 mod vec;
 mod vec_init_then_push;
@@ -867,7 +867,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
             ignore_publish: cargo_ignore_publish,
         })
     });
-    store.register_late_pass(|| Box::new(use_unwrap_or::UseUnwrapOr));
+    store.register_late_pass(|| Box::new(or_then_unwrap::OrThenUnwrap));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/or_then_unwrap.rs b/clippy_lints/src/or_then_unwrap.rs
new file mode 100644
index 00000000000..d467fbdfe02
--- /dev/null
+++ b/clippy_lints/src/or_then_unwrap.rs
@@ -0,0 +1,102 @@
+use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::ty::is_type_diagnostic_item;
+use if_chain::if_chain;
+use rustc_hir::{Expr, ExprKind, QPath};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::sym;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `.or(…).unwrap()` calls to Options and Results.
+    ///
+    /// ### Why is this bad?
+    /// You should use `.unwrap_or(…)` instead for clarity.
+    ///
+    /// ### Example
+    /// ```rust
+    /// # let fallback = "fallback";
+    /// // Result
+    /// # type Error = &'static str;
+    /// # let result: Result<&str, Error> = Err("error");
+    /// let value = result.or::<Error>(Ok(fallback)).unwrap();
+    ///
+    /// // Option
+    /// # let option: Option<&str> = None;
+    /// let value = option.or(Some(fallback)).unwrap();
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// # let fallback = "fallback";
+    /// // Result
+    /// # let result: Result<&str, &str> = Err("error");
+    /// let value = result.unwrap_or(fallback);
+    ///
+    /// // Option
+    /// # let option: Option<&str> = None;
+    /// let value = option.unwrap_or(fallback);
+    /// ```
+    #[clippy::version = "1.61.0"]
+    pub OR_THEN_UNWRAP,
+    complexity,
+    "checks for `.or(…).unwrap()` calls to Options and Results."
+}
+declare_lint_pass!(OrThenUnwrap => [OR_THEN_UNWRAP]);
+
+impl<'tcx> LateLintPass<'tcx> for OrThenUnwrap {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        // look for x.or().unwrap()
+        if_chain! {
+            if let ExprKind::MethodCall(path, [unwrap_self], unwrap_span) = &expr.kind;
+            if path.ident.name == sym::unwrap;
+            if let ExprKind::MethodCall(caller_path, [or_self, or_arg], or_span) = &unwrap_self.kind;
+            if caller_path.ident.name == sym::or;
+            then {
+                let ty = cx.typeck_results().expr_ty(or_self); // get type of x (we later check if it's Option or Result)
+                let title;
+
+                if is_type_diagnostic_item(cx, ty, sym::Option) {
+                    title = ".or(Some(…)).unwrap() found";
+                    if !is(or_arg, "Some") {
+                        return;
+                    }
+                } else if is_type_diagnostic_item(cx, ty, sym::Result) {
+                    title = ".or(Ok(…)).unwrap() found";
+                    if !is(or_arg, "Ok") {
+                        return;
+                    }
+                } else {
+                    // Someone has implemented a struct with .or(...).unwrap() chaining,
+                    // but it's not an Option or a Result, so bail
+                    return;
+                }
+
+                span_lint_and_help(
+                    cx,
+                    OR_THEN_UNWRAP,
+                    or_span.to(*unwrap_span),
+                    title,
+                    None,
+                    "use `unwrap_or()` instead"
+                );
+            }
+        }
+    }
+}
+
+/// is expr a Call to name?
+/// name might be "Some", "Ok", "Err", etc.
+fn is<'a>(expr: &Expr<'a>, name: &str) -> bool {
+    if_chain! {
+        if let ExprKind::Call(some_expr, _some_args) = expr.kind;
+        if let ExprKind::Path(QPath::Resolved(_, path)) = &some_expr.kind;
+        if let Some(path_segment) = path.segments.first();
+        if path_segment.ident.name.as_str() == name;
+        then {
+            true
+        }
+        else {
+            false
+        }
+    }
+}
diff --git a/clippy_lints/src/use_unwrap_or.rs b/clippy_lints/src/use_unwrap_or.rs
deleted file mode 100644
index 3e40014f50f..00000000000
--- a/clippy_lints/src/use_unwrap_or.rs
+++ /dev/null
@@ -1,102 +0,0 @@
-use clippy_utils::diagnostics::span_lint_and_help;
-use clippy_utils::ty::is_type_diagnostic_item;
-use if_chain::if_chain;
-use rustc_hir::{Expr, ExprKind, QPath};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::sym;
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for `.or(…).unwrap()` calls to Options and Results.
-    ///
-    /// ### Why is this bad?
-    /// You should use `.unwrap_or(…)` instead for clarity.
-    ///
-    /// ### Example
-    /// ```rust
-    /// # let fallback = "fallback";
-    /// // Result
-    /// # type Error = &'static str;
-    /// # let result: Result<&str, Error> = Err("error");
-    /// let value = result.or::<Error>(Ok(fallback)).unwrap();
-    ///
-    /// // Option
-    /// # let option: Option<&str> = None;
-    /// let value = option.or(Some(fallback)).unwrap();
-    /// ```
-    /// Use instead:
-    /// ```rust
-    /// # let fallback = "fallback";
-    /// // Result
-    /// # let result: Result<&str, &str> = Err("error");
-    /// let value = result.unwrap_or(fallback);
-    ///
-    /// // Option
-    /// # let option: Option<&str> = None;
-    /// let value = option.unwrap_or(fallback);
-    /// ```
-    #[clippy::version = "1.61.0"]
-    pub USE_UNWRAP_OR,
-    complexity,
-    "checks for `.or(…).unwrap()` calls to Options and Results."
-}
-declare_lint_pass!(UseUnwrapOr => [USE_UNWRAP_OR]);
-
-impl<'tcx> LateLintPass<'tcx> for UseUnwrapOr {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        // look for x.or().unwrap()
-        if_chain! {
-            if let ExprKind::MethodCall(path, [unwrap_self], unwrap_span) = &expr.kind;
-            if path.ident.name == sym::unwrap;
-            if let ExprKind::MethodCall(caller_path, [or_self, or_arg], or_span) = &unwrap_self.kind;
-            if caller_path.ident.name == sym::or;
-            then {
-                let ty = cx.typeck_results().expr_ty(or_self); // get type of x (we later check if it's Option or Result)
-                let title;
-
-                if is_type_diagnostic_item(cx, ty, sym::Option) {
-                    title = ".or(Some(…)).unwrap() found";
-                    if !is(or_arg, "Some") {
-                        return;
-                    }
-                } else if is_type_diagnostic_item(cx, ty, sym::Result) {
-                    title = ".or(Ok(…)).unwrap() found";
-                    if !is(or_arg, "Ok") {
-                        return;
-                    }
-                } else {
-                    // Someone has implemented a struct with .or(...).unwrap() chaining,
-                    // but it's not an Option or a Result, so bail
-                    return;
-                }
-
-                span_lint_and_help(
-                    cx,
-                    USE_UNWRAP_OR,
-                    or_span.to(*unwrap_span),
-                    title,
-                    None,
-                    "use `unwrap_or()` instead"
-                );
-            }
-        }
-    }
-}
-
-/// is expr a Call to name?
-/// name might be "Some", "Ok", "Err", etc.
-fn is<'a>(expr: &Expr<'a>, name: &str) -> bool {
-    if_chain! {
-        if let ExprKind::Call(some_expr, _some_args) = expr.kind;
-        if let ExprKind::Path(QPath::Resolved(_, path)) = &some_expr.kind;
-        if let Some(path_segment) = path.segments.first();
-        if path_segment.ident.name.as_str() == name;
-        then {
-            true
-        }
-        else {
-            false
-        }
-    }
-}
diff --git a/tests/ui/or_then_unwrap.rs b/tests/ui/or_then_unwrap.rs
new file mode 100644
index 00000000000..cbc3c387da0
--- /dev/null
+++ b/tests/ui/or_then_unwrap.rs
@@ -0,0 +1,45 @@
+#![warn(clippy::or_then_unwrap)]
+#![allow(clippy::map_identity)]
+
+struct SomeStruct {}
+impl SomeStruct {
+    fn or(self, _: Option<Self>) -> Self {
+        self
+    }
+    fn unwrap(&self) {}
+}
+
+struct SomeOtherStruct {}
+impl SomeOtherStruct {
+    fn or(self) -> Self {
+        self
+    }
+    fn unwrap(&self) {}
+}
+
+fn main() {
+    let option: Option<&str> = None;
+    let _ = option.or(Some("fallback")).unwrap(); // should trigger lint
+
+    let result: Result<&str, &str> = Err("Error");
+    let _ = result.or::<&str>(Ok("fallback")).unwrap(); // should trigger lint
+
+    // Not Option/Result
+    let instance = SomeStruct {};
+    let _ = instance.or(Some(SomeStruct {})).unwrap(); // should not trigger lint
+
+    let instance = SomeOtherStruct {};
+    let _ = instance.or().unwrap(); // should not trigger lint and should not panic
+
+    // None in or
+    let option: Option<&str> = None;
+    let _ = option.or(None).unwrap(); // should not trigger lint
+
+    // Not Err in or
+    let result: Result<&str, &str> = Err("Error");
+    let _ = result.or::<&str>(Err("Other Error")).unwrap(); // should not trigger lint
+
+    // other function between
+    let option: Option<&str> = None;
+    let _ = option.or(Some("fallback")).map(|v| v).unwrap(); // should not trigger lint
+}
diff --git a/tests/ui/or_then_unwrap.stderr b/tests/ui/or_then_unwrap.stderr
new file mode 100644
index 00000000000..fdd718b3580
--- /dev/null
+++ b/tests/ui/or_then_unwrap.stderr
@@ -0,0 +1,19 @@
+error: .or(Some(…)).unwrap() found
+  --> $DIR/or_then_unwrap.rs:22:20
+   |
+LL |     let _ = option.or(Some("fallback")).unwrap(); // should trigger lint
+   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::or-then-unwrap` implied by `-D warnings`
+   = help: use `unwrap_or()` instead
+
+error: .or(Ok(…)).unwrap() found
+  --> $DIR/or_then_unwrap.rs:25:20
+   |
+LL |     let _ = result.or::<&str>(Ok("fallback")).unwrap(); // should trigger lint
+   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use `unwrap_or()` instead
+
+error: aborting due to 2 previous errors
+
diff --git a/tests/ui/use_unwrap_or.rs b/tests/ui/use_unwrap_or.rs
deleted file mode 100644
index dd55b33739d..00000000000
--- a/tests/ui/use_unwrap_or.rs
+++ /dev/null
@@ -1,45 +0,0 @@
-#![warn(clippy::use_unwrap_or)]
-#![allow(clippy::map_identity)]
-
-struct SomeStruct {}
-impl SomeStruct {
-    fn or(self, _: Option<Self>) -> Self {
-        self
-    }
-    fn unwrap(&self) {}
-}
-
-struct SomeOtherStruct {}
-impl SomeOtherStruct {
-    fn or(self) -> Self {
-        self
-    }
-    fn unwrap(&self) {}
-}
-
-fn main() {
-    let option: Option<&str> = None;
-    let _ = option.or(Some("fallback")).unwrap(); // should trigger lint
-
-    let result: Result<&str, &str> = Err("Error");
-    let _ = result.or::<&str>(Ok("fallback")).unwrap(); // should trigger lint
-
-    // Not Option/Result
-    let instance = SomeStruct {};
-    let _ = instance.or(Some(SomeStruct {})).unwrap(); // should not trigger lint
-
-    let instance = SomeOtherStruct {};
-    let _ = instance.or().unwrap(); // should not trigger lint and should not panic
-
-    // None in or
-    let option: Option<&str> = None;
-    let _ = option.or(None).unwrap(); // should not trigger lint
-
-    // Not Err in or
-    let result: Result<&str, &str> = Err("Error");
-    let _ = result.or::<&str>(Err("Other Error")).unwrap(); // should not trigger lint
-
-    // other function between
-    let option: Option<&str> = None;
-    let _ = option.or(Some("fallback")).map(|v| v).unwrap(); // should not trigger lint
-}
diff --git a/tests/ui/use_unwrap_or.stderr b/tests/ui/use_unwrap_or.stderr
deleted file mode 100644
index 796778a293d..00000000000
--- a/tests/ui/use_unwrap_or.stderr
+++ /dev/null
@@ -1,19 +0,0 @@
-error: .or(Some(…)).unwrap() found
-  --> $DIR/use_unwrap_or.rs:22:20
-   |
-LL |     let _ = option.or(Some("fallback")).unwrap(); // should trigger lint
-   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: `-D clippy::use-unwrap-or` implied by `-D warnings`
-   = help: use `unwrap_or()` instead
-
-error: .or(Ok(…)).unwrap() found
-  --> $DIR/use_unwrap_or.rs:25:20
-   |
-LL |     let _ = result.or::<&str>(Ok("fallback")).unwrap(); // should trigger lint
-   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: use `unwrap_or()` instead
-
-error: aborting due to 2 previous errors
-
-- 
cgit 1.4.1-3-g733a5


From 3c4192f3e9d2983c0fa2fc30fa76f63cb62b06fa Mon Sep 17 00:00:00 2001
From: Max Baumann <max@bmn.dev>
Date: Fri, 18 Mar 2022 01:12:39 +0100
Subject: fix: ran update_lints

---
 CHANGELOG.md                                | 2 +-
 clippy_lints/src/lib.register_all.rs        | 2 +-
 clippy_lints/src/lib.register_complexity.rs | 2 +-
 clippy_lints/src/lib.register_lints.rs      | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index b45be38bf4d..ea30b4d2975 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3366,6 +3366,7 @@ Released 2018-09-13
 [`option_map_unit_fn`]: https://rust-lang.github.io/rust-clippy/master/index.html#option_map_unit_fn
 [`option_option`]: https://rust-lang.github.io/rust-clippy/master/index.html#option_option
 [`or_fun_call`]: https://rust-lang.github.io/rust-clippy/master/index.html#or_fun_call
+[`or_then_unwrap`]: https://rust-lang.github.io/rust-clippy/master/index.html#or_then_unwrap
 [`out_of_bounds_indexing`]: https://rust-lang.github.io/rust-clippy/master/index.html#out_of_bounds_indexing
 [`overflow_check_conditional`]: https://rust-lang.github.io/rust-clippy/master/index.html#overflow_check_conditional
 [`panic`]: https://rust-lang.github.io/rust-clippy/master/index.html#panic
@@ -3538,7 +3539,6 @@ Released 2018-09-13
 [`upper_case_acronyms`]: https://rust-lang.github.io/rust-clippy/master/index.html#upper_case_acronyms
 [`use_debug`]: https://rust-lang.github.io/rust-clippy/master/index.html#use_debug
 [`use_self`]: https://rust-lang.github.io/rust-clippy/master/index.html#use_self
-[`or_then_unwrap`]: https://rust-lang.github.io/rust-clippy/master/index.html#or_then_unwrap
 [`used_underscore_binding`]: https://rust-lang.github.io/rust-clippy/master/index.html#used_underscore_binding
 [`useless_asref`]: https://rust-lang.github.io/rust-clippy/master/index.html#useless_asref
 [`useless_attribute`]: https://rust-lang.github.io/rust-clippy/master/index.html#useless_attribute
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 5c3e352d09f..9ff5f26c1fa 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -238,6 +238,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(only_used_in_recursion::ONLY_USED_IN_RECURSION),
     LintId::of(open_options::NONSENSICAL_OPEN_OPTIONS),
     LintId::of(option_env_unwrap::OPTION_ENV_UNWRAP),
+    LintId::of(or_then_unwrap::OR_THEN_UNWRAP),
     LintId::of(overflow_check_conditional::OVERFLOW_CHECK_CONDITIONAL),
     LintId::of(partialeq_ne_impl::PARTIALEQ_NE_IMPL),
     LintId::of(precedence::PRECEDENCE),
@@ -310,7 +311,6 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(unwrap::PANICKING_UNWRAP),
     LintId::of(unwrap::UNNECESSARY_UNWRAP),
     LintId::of(upper_case_acronyms::UPPER_CASE_ACRONYMS),
-    LintId::of(or_then_unwrap::OR_THEN_UNWRAP),
     LintId::of(useless_conversion::USELESS_CONVERSION),
     LintId::of(vec::USELESS_VEC),
     LintId::of(vec_init_then_push::VEC_INIT_THEN_PUSH),
diff --git a/clippy_lints/src/lib.register_complexity.rs b/clippy_lints/src/lib.register_complexity.rs
index 45ad1520396..34d764e810d 100644
--- a/clippy_lints/src/lib.register_complexity.rs
+++ b/clippy_lints/src/lib.register_complexity.rs
@@ -66,6 +66,7 @@ store.register_group(true, "clippy::complexity", Some("clippy_complexity"), vec!
     LintId::of(no_effect::NO_EFFECT),
     LintId::of(no_effect::UNNECESSARY_OPERATION),
     LintId::of(only_used_in_recursion::ONLY_USED_IN_RECURSION),
+    LintId::of(or_then_unwrap::OR_THEN_UNWRAP),
     LintId::of(overflow_check_conditional::OVERFLOW_CHECK_CONDITIONAL),
     LintId::of(partialeq_ne_impl::PARTIALEQ_NE_IMPL),
     LintId::of(precedence::PRECEDENCE),
@@ -94,7 +95,6 @@ store.register_group(true, "clippy::complexity", Some("clippy_complexity"), vec!
     LintId::of(unit_types::UNIT_ARG),
     LintId::of(unnecessary_sort_by::UNNECESSARY_SORT_BY),
     LintId::of(unwrap::UNNECESSARY_UNWRAP),
-    LintId::of(or_then_unwrap::OR_THEN_UNWRAP),
     LintId::of(useless_conversion::USELESS_CONVERSION),
     LintId::of(zero_div_zero::ZERO_DIVIDED_BY_ZERO),
 ])
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index aad0c8735ee..0b6e3c7e7df 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -404,6 +404,7 @@ store.register_lints(&[
     open_options::NONSENSICAL_OPEN_OPTIONS,
     option_env_unwrap::OPTION_ENV_UNWRAP,
     option_if_let_else::OPTION_IF_LET_ELSE,
+    or_then_unwrap::OR_THEN_UNWRAP,
     overflow_check_conditional::OVERFLOW_CHECK_CONDITIONAL,
     panic_in_result_fn::PANIC_IN_RESULT_FN,
     panic_unimplemented::PANIC,
@@ -528,7 +529,6 @@ store.register_lints(&[
     unwrap_in_result::UNWRAP_IN_RESULT,
     upper_case_acronyms::UPPER_CASE_ACRONYMS,
     use_self::USE_SELF,
-    or_then_unwrap::OR_THEN_UNWRAP,
     useless_conversion::USELESS_CONVERSION,
     vec::USELESS_VEC,
     vec_init_then_push::VEC_INIT_THEN_PUSH,
-- 
cgit 1.4.1-3-g733a5


From 34ad33c57aa9db1b0c8473925affef08fadc7b8a Mon Sep 17 00:00:00 2001
From: Max Baumann <max@bmn.dev>
Date: Fri, 18 Mar 2022 21:11:54 +0100
Subject: refactor: move into methods module

---
 clippy_lints/src/lib.register_all.rs        |   2 +-
 clippy_lints/src/lib.register_complexity.rs |   2 +-
 clippy_lints/src/lib.register_lints.rs      |   2 +-
 clippy_lints/src/lib.rs                     |   2 -
 clippy_lints/src/methods/mod.rs             |  41 +++++++++++
 clippy_lints/src/methods/or_then_unwrap.rs  |  68 +++++++++++++++++++
 clippy_lints/src/or_then_unwrap.rs          | 102 ----------------------------
 7 files changed, 112 insertions(+), 107 deletions(-)
 create mode 100644 clippy_lints/src/methods/or_then_unwrap.rs
 delete mode 100644 clippy_lints/src/or_then_unwrap.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 9ff5f26c1fa..033efcb8a89 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -181,6 +181,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(methods::OPTION_FILTER_MAP),
     LintId::of(methods::OPTION_MAP_OR_NONE),
     LintId::of(methods::OR_FUN_CALL),
+    LintId::of(methods::OR_THEN_UNWRAP),
     LintId::of(methods::RESULT_MAP_OR_INTO_OPTION),
     LintId::of(methods::SEARCH_IS_SOME),
     LintId::of(methods::SHOULD_IMPLEMENT_TRAIT),
@@ -238,7 +239,6 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(only_used_in_recursion::ONLY_USED_IN_RECURSION),
     LintId::of(open_options::NONSENSICAL_OPEN_OPTIONS),
     LintId::of(option_env_unwrap::OPTION_ENV_UNWRAP),
-    LintId::of(or_then_unwrap::OR_THEN_UNWRAP),
     LintId::of(overflow_check_conditional::OVERFLOW_CHECK_CONDITIONAL),
     LintId::of(partialeq_ne_impl::PARTIALEQ_NE_IMPL),
     LintId::of(precedence::PRECEDENCE),
diff --git a/clippy_lints/src/lib.register_complexity.rs b/clippy_lints/src/lib.register_complexity.rs
index 34d764e810d..a2ce69065f9 100644
--- a/clippy_lints/src/lib.register_complexity.rs
+++ b/clippy_lints/src/lib.register_complexity.rs
@@ -47,6 +47,7 @@ store.register_group(true, "clippy::complexity", Some("clippy_complexity"), vec!
     LintId::of(methods::NEEDLESS_SPLITN),
     LintId::of(methods::OPTION_AS_REF_DEREF),
     LintId::of(methods::OPTION_FILTER_MAP),
+    LintId::of(methods::OR_THEN_UNWRAP),
     LintId::of(methods::SEARCH_IS_SOME),
     LintId::of(methods::SKIP_WHILE_NEXT),
     LintId::of(methods::UNNECESSARY_FILTER_MAP),
@@ -66,7 +67,6 @@ store.register_group(true, "clippy::complexity", Some("clippy_complexity"), vec!
     LintId::of(no_effect::NO_EFFECT),
     LintId::of(no_effect::UNNECESSARY_OPERATION),
     LintId::of(only_used_in_recursion::ONLY_USED_IN_RECURSION),
-    LintId::of(or_then_unwrap::OR_THEN_UNWRAP),
     LintId::of(overflow_check_conditional::OVERFLOW_CHECK_CONDITIONAL),
     LintId::of(partialeq_ne_impl::PARTIALEQ_NE_IMPL),
     LintId::of(precedence::PRECEDENCE),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 0b6e3c7e7df..ce5a1170504 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -319,6 +319,7 @@ store.register_lints(&[
     methods::OPTION_FILTER_MAP,
     methods::OPTION_MAP_OR_NONE,
     methods::OR_FUN_CALL,
+    methods::OR_THEN_UNWRAP,
     methods::RESULT_MAP_OR_INTO_OPTION,
     methods::SEARCH_IS_SOME,
     methods::SHOULD_IMPLEMENT_TRAIT,
@@ -404,7 +405,6 @@ store.register_lints(&[
     open_options::NONSENSICAL_OPEN_OPTIONS,
     option_env_unwrap::OPTION_ENV_UNWRAP,
     option_if_let_else::OPTION_IF_LET_ELSE,
-    or_then_unwrap::OR_THEN_UNWRAP,
     overflow_check_conditional::OVERFLOW_CHECK_CONDITIONAL,
     panic_in_result_fn::PANIC_IN_RESULT_FN,
     panic_unimplemented::PANIC,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index fdab58935ef..504235d0d1e 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -322,7 +322,6 @@ mod only_used_in_recursion;
 mod open_options;
 mod option_env_unwrap;
 mod option_if_let_else;
-mod or_then_unwrap;
 mod overflow_check_conditional;
 mod panic_in_result_fn;
 mod panic_unimplemented;
@@ -867,7 +866,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
             ignore_publish: cargo_ignore_publish,
         })
     });
-    store.register_late_pass(|| Box::new(or_then_unwrap::OrThenUnwrap));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index aa9f86f292c..1e76428858b 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -45,6 +45,7 @@ mod option_as_ref_deref;
 mod option_map_or_none;
 mod option_map_unwrap_or;
 mod or_fun_call;
+mod or_then_unwrap;
 mod search_is_some;
 mod single_char_add_str;
 mod single_char_insert_string;
@@ -778,6 +779,42 @@ declare_clippy_lint! {
     "using any `*or` method with a function call, which suggests `*or_else`"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `.or(…).unwrap()` calls to Options and Results.
+    ///
+    /// ### Why is this bad?
+    /// You should use `.unwrap_or(…)` instead for clarity.
+    ///
+    /// ### Example
+    /// ```rust
+    /// # let fallback = "fallback";
+    /// // Result
+    /// # type Error = &'static str;
+    /// # let result: Result<&str, Error> = Err("error");
+    /// let value = result.or::<Error>(Ok(fallback)).unwrap();
+    ///
+    /// // Option
+    /// # let option: Option<&str> = None;
+    /// let value = option.or(Some(fallback)).unwrap();
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// # let fallback = "fallback";
+    /// // Result
+    /// # let result: Result<&str, &str> = Err("error");
+    /// let value = result.unwrap_or(fallback);
+    ///
+    /// // Option
+    /// # let option: Option<&str> = None;
+    /// let value = option.unwrap_or(fallback);
+    /// ```
+    #[clippy::version = "1.61.0"]
+    pub OR_THEN_UNWRAP,
+    complexity,
+    "checks for `.or(…).unwrap()` calls to Options and Results."
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for calls to `.expect(&format!(...))`, `.expect(foo(..))`,
@@ -2039,6 +2076,7 @@ impl_lint_pass!(Methods => [
     OPTION_MAP_OR_NONE,
     BIND_INSTEAD_OF_MAP,
     OR_FUN_CALL,
+    OR_THEN_UNWRAP,
     EXPECT_FUN_CALL,
     CHARS_NEXT_CMP,
     CHARS_LAST_CMP,
@@ -2474,6 +2512,9 @@ fn check_methods<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, msrv: Optio
                     Some(("get_mut", [recv, get_arg], _)) => {
                         get_unwrap::check(cx, expr, recv, get_arg, true);
                     },
+                    Some(("or", [recv, or_arg], or_span)) => {
+                        or_then_unwrap::check(cx, expr, recv, or_arg, or_span);
+                    },
                     _ => {},
                 }
                 unwrap_used::check(cx, expr, recv);
diff --git a/clippy_lints/src/methods/or_then_unwrap.rs b/clippy_lints/src/methods/or_then_unwrap.rs
new file mode 100644
index 00000000000..02fa5887f67
--- /dev/null
+++ b/clippy_lints/src/methods/or_then_unwrap.rs
@@ -0,0 +1,68 @@
+use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::ty::is_type_diagnostic_item;
+use if_chain::if_chain;
+use rustc_hir::{Expr, ExprKind, QPath};
+use rustc_lint::LateContext;
+use rustc_span::{sym, Span};
+
+use super::OR_THEN_UNWRAP;
+
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    unwrap_expr: &Expr<'_>,
+    recv: &'tcx Expr<'tcx>,
+    or_arg: &'tcx Expr<'_>,
+    or_span: Span,
+) {
+    let ty = cx.typeck_results().expr_ty(recv); // get type of x (we later check if it's Option or Result)
+    let title;
+
+    if is_type_diagnostic_item(cx, ty, sym::Option) {
+        title = ".or(Some(…)).unwrap() found";
+        if !is(or_arg, "Some") {
+            return;
+        }
+    } else if is_type_diagnostic_item(cx, ty, sym::Result) {
+        title = ".or(Ok(…)).unwrap() found";
+        if !is(or_arg, "Ok") {
+            return;
+        }
+    } else {
+        // Someone has implemented a struct with .or(...).unwrap() chaining,
+        // but it's not an Option or a Result, so bail
+        return;
+    }
+
+    let unwrap_span = if let ExprKind::MethodCall(_, _, span) = unwrap_expr.kind {
+        span
+    } else {
+        // unreachable. but fallback to ident's span ("()" are missing)
+        unwrap_expr.span
+    };
+
+    span_lint_and_help(
+        cx,
+        OR_THEN_UNWRAP,
+        or_span.to(unwrap_span),
+        title,
+        None,
+        "use `unwrap_or()` instead",
+    );
+}
+
+/// is expr a Call to name?
+/// name might be "Some", "Ok", "Err", etc.
+fn is<'a>(expr: &Expr<'a>, name: &str) -> bool {
+    if_chain! {
+        if let ExprKind::Call(some_expr, _some_args) = expr.kind;
+        if let ExprKind::Path(QPath::Resolved(_, path)) = &some_expr.kind;
+        if let Some(path_segment) = path.segments.first();
+        if path_segment.ident.name.as_str() == name;
+        then {
+            true
+        }
+        else {
+            false
+        }
+    }
+}
diff --git a/clippy_lints/src/or_then_unwrap.rs b/clippy_lints/src/or_then_unwrap.rs
deleted file mode 100644
index d467fbdfe02..00000000000
--- a/clippy_lints/src/or_then_unwrap.rs
+++ /dev/null
@@ -1,102 +0,0 @@
-use clippy_utils::diagnostics::span_lint_and_help;
-use clippy_utils::ty::is_type_diagnostic_item;
-use if_chain::if_chain;
-use rustc_hir::{Expr, ExprKind, QPath};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::sym;
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for `.or(…).unwrap()` calls to Options and Results.
-    ///
-    /// ### Why is this bad?
-    /// You should use `.unwrap_or(…)` instead for clarity.
-    ///
-    /// ### Example
-    /// ```rust
-    /// # let fallback = "fallback";
-    /// // Result
-    /// # type Error = &'static str;
-    /// # let result: Result<&str, Error> = Err("error");
-    /// let value = result.or::<Error>(Ok(fallback)).unwrap();
-    ///
-    /// // Option
-    /// # let option: Option<&str> = None;
-    /// let value = option.or(Some(fallback)).unwrap();
-    /// ```
-    /// Use instead:
-    /// ```rust
-    /// # let fallback = "fallback";
-    /// // Result
-    /// # let result: Result<&str, &str> = Err("error");
-    /// let value = result.unwrap_or(fallback);
-    ///
-    /// // Option
-    /// # let option: Option<&str> = None;
-    /// let value = option.unwrap_or(fallback);
-    /// ```
-    #[clippy::version = "1.61.0"]
-    pub OR_THEN_UNWRAP,
-    complexity,
-    "checks for `.or(…).unwrap()` calls to Options and Results."
-}
-declare_lint_pass!(OrThenUnwrap => [OR_THEN_UNWRAP]);
-
-impl<'tcx> LateLintPass<'tcx> for OrThenUnwrap {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        // look for x.or().unwrap()
-        if_chain! {
-            if let ExprKind::MethodCall(path, [unwrap_self], unwrap_span) = &expr.kind;
-            if path.ident.name == sym::unwrap;
-            if let ExprKind::MethodCall(caller_path, [or_self, or_arg], or_span) = &unwrap_self.kind;
-            if caller_path.ident.name == sym::or;
-            then {
-                let ty = cx.typeck_results().expr_ty(or_self); // get type of x (we later check if it's Option or Result)
-                let title;
-
-                if is_type_diagnostic_item(cx, ty, sym::Option) {
-                    title = ".or(Some(…)).unwrap() found";
-                    if !is(or_arg, "Some") {
-                        return;
-                    }
-                } else if is_type_diagnostic_item(cx, ty, sym::Result) {
-                    title = ".or(Ok(…)).unwrap() found";
-                    if !is(or_arg, "Ok") {
-                        return;
-                    }
-                } else {
-                    // Someone has implemented a struct with .or(...).unwrap() chaining,
-                    // but it's not an Option or a Result, so bail
-                    return;
-                }
-
-                span_lint_and_help(
-                    cx,
-                    OR_THEN_UNWRAP,
-                    or_span.to(*unwrap_span),
-                    title,
-                    None,
-                    "use `unwrap_or()` instead"
-                );
-            }
-        }
-    }
-}
-
-/// is expr a Call to name?
-/// name might be "Some", "Ok", "Err", etc.
-fn is<'a>(expr: &Expr<'a>, name: &str) -> bool {
-    if_chain! {
-        if let ExprKind::Call(some_expr, _some_args) = expr.kind;
-        if let ExprKind::Path(QPath::Resolved(_, path)) = &some_expr.kind;
-        if let Some(path_segment) = path.segments.first();
-        if path_segment.ident.name.as_str() == name;
-        then {
-            true
-        }
-        else {
-            false
-        }
-    }
-}
-- 
cgit 1.4.1-3-g733a5


From f00e844a1f3b7e6d8a5d84e90baa37b0cebeac67 Mon Sep 17 00:00:00 2001
From: Max Baumann <max@bmn.dev>
Date: Fri, 18 Mar 2022 22:44:56 +0100
Subject: feat: use span_lint_and_sugg

---
 clippy_lints/src/methods/or_then_unwrap.rs | 10 ++++++----
 tests/ui/or_then_unwrap.stderr             |  7 ++-----
 2 files changed, 8 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/or_then_unwrap.rs b/clippy_lints/src/methods/or_then_unwrap.rs
index 02fa5887f67..578f898da78 100644
--- a/clippy_lints/src/methods/or_then_unwrap.rs
+++ b/clippy_lints/src/methods/or_then_unwrap.rs
@@ -1,6 +1,7 @@
-use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
+use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, QPath};
 use rustc_lint::LateContext;
 use rustc_span::{sym, Span};
@@ -40,13 +41,14 @@ pub(super) fn check<'tcx>(
         unwrap_expr.span
     };
 
-    span_lint_and_help(
+    span_lint_and_sugg(
         cx,
         OR_THEN_UNWRAP,
         or_span.to(unwrap_span),
         title,
-        None,
-        "use `unwrap_or()` instead",
+        "try this",
+        "unwrap_or(...)".into(),
+        Applicability::HasPlaceholders,
     );
 }
 
diff --git a/tests/ui/or_then_unwrap.stderr b/tests/ui/or_then_unwrap.stderr
index fdd718b3580..7eade84bd65 100644
--- a/tests/ui/or_then_unwrap.stderr
+++ b/tests/ui/or_then_unwrap.stderr
@@ -2,18 +2,15 @@ error: .or(Some(…)).unwrap() found
   --> $DIR/or_then_unwrap.rs:22:20
    |
 LL |     let _ = option.or(Some("fallback")).unwrap(); // should trigger lint
-   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or(...)`
    |
    = note: `-D clippy::or-then-unwrap` implied by `-D warnings`
-   = help: use `unwrap_or()` instead
 
 error: .or(Ok(…)).unwrap() found
   --> $DIR/or_then_unwrap.rs:25:20
    |
 LL |     let _ = result.or::<&str>(Ok("fallback")).unwrap(); // should trigger lint
-   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: use `unwrap_or()` instead
+   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or(...)`
 
 error: aborting due to 2 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 895de1f13e78de456d5ecbdca3c87526c4dbbef2 Mon Sep 17 00:00:00 2001
From: Max Baumann <max@bmn.dev>
Date: Fri, 18 Mar 2022 23:18:36 +0100
Subject: feat: make fixable

---
 clippy_lints/src/methods/or_then_unwrap.rs | 30 +++++++++++++------
 tests/ui/or_then_unwrap.fixed              | 48 ++++++++++++++++++++++++++++++
 tests/ui/or_then_unwrap.rs                 |  2 ++
 tests/ui/or_then_unwrap.stderr             |  8 ++---
 4 files changed, 75 insertions(+), 13 deletions(-)
 create mode 100644 tests/ui/or_then_unwrap.fixed

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/or_then_unwrap.rs b/clippy_lints/src/methods/or_then_unwrap.rs
index 578f898da78..4e2dcf67231 100644
--- a/clippy_lints/src/methods/or_then_unwrap.rs
+++ b/clippy_lints/src/methods/or_then_unwrap.rs
@@ -1,4 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
@@ -17,15 +18,20 @@ pub(super) fn check<'tcx>(
 ) {
     let ty = cx.typeck_results().expr_ty(recv); // get type of x (we later check if it's Option or Result)
     let title;
+    let or_arg_content: Span;
 
     if is_type_diagnostic_item(cx, ty, sym::Option) {
         title = ".or(Some(…)).unwrap() found";
-        if !is(or_arg, "Some") {
+        if let Some(content) = get_content_if_is(or_arg, "Some") {
+            or_arg_content = content;
+        } else {
             return;
         }
     } else if is_type_diagnostic_item(cx, ty, sym::Result) {
         title = ".or(Ok(…)).unwrap() found";
-        if !is(or_arg, "Ok") {
+        if let Some(content) = get_content_if_is(or_arg, "Ok") {
+            or_arg_content = content;
+        } else {
             return;
         }
     } else {
@@ -41,30 +47,36 @@ pub(super) fn check<'tcx>(
         unwrap_expr.span
     };
 
+    let mut applicability = Applicability::MachineApplicable;
+    let suggestion = format!(
+        "unwrap_or({})",
+        snippet_with_applicability(cx, or_arg_content, "..", &mut applicability)
+    );
+
     span_lint_and_sugg(
         cx,
         OR_THEN_UNWRAP,
         or_span.to(unwrap_span),
         title,
         "try this",
-        "unwrap_or(...)".into(),
-        Applicability::HasPlaceholders,
+        suggestion,
+        applicability,
     );
 }
 
-/// is expr a Call to name?
+/// is expr a Call to name? if so, return what it's wrapping
 /// name might be "Some", "Ok", "Err", etc.
-fn is<'a>(expr: &Expr<'a>, name: &str) -> bool {
+fn get_content_if_is<'a>(expr: &Expr<'a>, name: &str) -> Option<Span> {
     if_chain! {
-        if let ExprKind::Call(some_expr, _some_args) = expr.kind;
+        if let ExprKind::Call(some_expr, [arg]) = expr.kind;
         if let ExprKind::Path(QPath::Resolved(_, path)) = &some_expr.kind;
         if let Some(path_segment) = path.segments.first();
         if path_segment.ident.name.as_str() == name;
         then {
-            true
+            Some(arg.span)
         }
         else {
-            false
+            None
         }
     }
 }
diff --git a/tests/ui/or_then_unwrap.fixed b/tests/ui/or_then_unwrap.fixed
new file mode 100644
index 00000000000..b1e69ce2d26
--- /dev/null
+++ b/tests/ui/or_then_unwrap.fixed
@@ -0,0 +1,48 @@
+// run-rustfix
+
+#![warn(clippy::or_then_unwrap)]
+#![allow(clippy::map_identity)]
+
+struct SomeStruct {}
+impl SomeStruct {
+    fn or(self, _: Option<Self>) -> Self {
+        self
+    }
+    fn unwrap(&self) {}
+}
+
+struct SomeOtherStruct {}
+impl SomeOtherStruct {
+    fn or(self) -> Self {
+        self
+    }
+    fn unwrap(&self) {}
+}
+
+fn main() {
+    let option: Option<&str> = None;
+    let _ = option.unwrap_or("fallback"); // should trigger lint
+
+    let result: Result<&str, &str> = Err("Error");
+    let _ = result.unwrap_or("fallback"); // should trigger lint
+
+    // Not Option/Result
+    let instance = SomeStruct {};
+    let _ = instance.or(Some(SomeStruct {})).unwrap(); // should not trigger lint
+
+    // or takes no argument
+    let instance = SomeOtherStruct {};
+    let _ = instance.or().unwrap(); // should not trigger lint and should not panic
+
+    // None in or
+    let option: Option<&str> = None;
+    let _ = option.or(None).unwrap(); // should not trigger lint
+
+    // Not Err in or
+    let result: Result<&str, &str> = Err("Error");
+    let _ = result.or::<&str>(Err("Other Error")).unwrap(); // should not trigger lint
+
+    // other function between
+    let option: Option<&str> = None;
+    let _ = option.or(Some("fallback")).map(|v| v).unwrap(); // should not trigger lint
+}
diff --git a/tests/ui/or_then_unwrap.rs b/tests/ui/or_then_unwrap.rs
index 8d7e50ad405..dc66e86be6f 100644
--- a/tests/ui/or_then_unwrap.rs
+++ b/tests/ui/or_then_unwrap.rs
@@ -1,3 +1,5 @@
+// run-rustfix
+
 #![warn(clippy::or_then_unwrap)]
 #![allow(clippy::map_identity)]
 
diff --git a/tests/ui/or_then_unwrap.stderr b/tests/ui/or_then_unwrap.stderr
index 7eade84bd65..301a54530cf 100644
--- a/tests/ui/or_then_unwrap.stderr
+++ b/tests/ui/or_then_unwrap.stderr
@@ -1,16 +1,16 @@
 error: .or(Some(…)).unwrap() found
-  --> $DIR/or_then_unwrap.rs:22:20
+  --> $DIR/or_then_unwrap.rs:24:20
    |
 LL |     let _ = option.or(Some("fallback")).unwrap(); // should trigger lint
-   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or(...)`
+   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or("fallback")`
    |
    = note: `-D clippy::or-then-unwrap` implied by `-D warnings`
 
 error: .or(Ok(…)).unwrap() found
-  --> $DIR/or_then_unwrap.rs:25:20
+  --> $DIR/or_then_unwrap.rs:27:20
    |
 LL |     let _ = result.or::<&str>(Ok("fallback")).unwrap(); // should trigger lint
-   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or(...)`
+   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or("fallback")`
 
 error: aborting due to 2 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 0f83753934b84efb6b3263270f625f0f44c208f2 Mon Sep 17 00:00:00 2001
From: Max Baumann <max@bmn.dev>
Date: Sun, 20 Mar 2022 23:43:17 +0100
Subject: feat: change error message

---
 clippy_lints/src/methods/or_then_unwrap.rs | 4 ++--
 tests/ui/or_then_unwrap.stderr             | 6 +++---
 2 files changed, 5 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/or_then_unwrap.rs b/clippy_lints/src/methods/or_then_unwrap.rs
index 4e2dcf67231..a0f6d80c19b 100644
--- a/clippy_lints/src/methods/or_then_unwrap.rs
+++ b/clippy_lints/src/methods/or_then_unwrap.rs
@@ -21,14 +21,14 @@ pub(super) fn check<'tcx>(
     let or_arg_content: Span;
 
     if is_type_diagnostic_item(cx, ty, sym::Option) {
-        title = ".or(Some(…)).unwrap() found";
+        title = "found `.or(Some(…)).unwrap()`";
         if let Some(content) = get_content_if_is(or_arg, "Some") {
             or_arg_content = content;
         } else {
             return;
         }
     } else if is_type_diagnostic_item(cx, ty, sym::Result) {
-        title = ".or(Ok(…)).unwrap() found";
+        title = "found `.or(Ok(…)).unwrap()`";
         if let Some(content) = get_content_if_is(or_arg, "Ok") {
             or_arg_content = content;
         } else {
diff --git a/tests/ui/or_then_unwrap.stderr b/tests/ui/or_then_unwrap.stderr
index 6b32634defd..da88154c59f 100644
--- a/tests/ui/or_then_unwrap.stderr
+++ b/tests/ui/or_then_unwrap.stderr
@@ -1,4 +1,4 @@
-error: .or(Some(…)).unwrap() found
+error: found `.or(Some(…)).unwrap()`
   --> $DIR/or_then_unwrap.rs:24:20
    |
 LL |     let _ = option.or(Some("fallback")).unwrap(); // should trigger lint
@@ -6,13 +6,13 @@ LL |     let _ = option.or(Some("fallback")).unwrap(); // should trigger lint
    |
    = note: `-D clippy::or-then-unwrap` implied by `-D warnings`
 
-error: .or(Ok(…)).unwrap() found
+error: found `.or(Ok(…)).unwrap()`
   --> $DIR/or_then_unwrap.rs:27:20
    |
 LL |     let _ = result.or::<&str>(Ok("fallback")).unwrap(); // should trigger lint
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or("fallback")`
 
-error: .or(Some(…)).unwrap() found
+error: found `.or(Some(…)).unwrap()`
   --> $DIR/or_then_unwrap.rs:31:31
    |
 LL |     let _ = option.map(|v| v).or(Some("fallback")).unwrap().to_string().chars(); // should trigger lint
-- 
cgit 1.4.1-3-g733a5


From 4580c8a9b7f61d2e9968ae1aaab08cfa2a5eb221 Mon Sep 17 00:00:00 2001
From: Max Baumann <max@bmn.dev>
Date: Sun, 20 Mar 2022 23:54:04 +0100
Subject: refactor: use is_lang_ctor()

---
 clippy_lints/src/methods/or_then_unwrap.rs | 31 ++++++++++++------------------
 1 file changed, 12 insertions(+), 19 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/or_then_unwrap.rs b/clippy_lints/src/methods/or_then_unwrap.rs
index a0f6d80c19b..28b1bfe8fb5 100644
--- a/clippy_lints/src/methods/or_then_unwrap.rs
+++ b/clippy_lints/src/methods/or_then_unwrap.rs
@@ -1,9 +1,8 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::is_type_diagnostic_item;
-use if_chain::if_chain;
+use clippy_utils::{diagnostics::span_lint_and_sugg, is_lang_ctor};
 use rustc_errors::Applicability;
-use rustc_hir::{Expr, ExprKind, QPath};
+use rustc_hir::{lang_items::LangItem, Expr, ExprKind};
 use rustc_lint::LateContext;
 use rustc_span::{sym, Span};
 
@@ -22,14 +21,14 @@ pub(super) fn check<'tcx>(
 
     if is_type_diagnostic_item(cx, ty, sym::Option) {
         title = "found `.or(Some(…)).unwrap()`";
-        if let Some(content) = get_content_if_is(or_arg, "Some") {
+        if let Some(content) = get_content_if_ctor_matches(cx, or_arg, LangItem::OptionSome) {
             or_arg_content = content;
         } else {
             return;
         }
     } else if is_type_diagnostic_item(cx, ty, sym::Result) {
         title = "found `.or(Ok(…)).unwrap()`";
-        if let Some(content) = get_content_if_is(or_arg, "Ok") {
+        if let Some(content) = get_content_if_ctor_matches(cx, or_arg, LangItem::ResultOk) {
             or_arg_content = content;
         } else {
             return;
@@ -64,19 +63,13 @@ pub(super) fn check<'tcx>(
     );
 }
 
-/// is expr a Call to name? if so, return what it's wrapping
-/// name might be "Some", "Ok", "Err", etc.
-fn get_content_if_is<'a>(expr: &Expr<'a>, name: &str) -> Option<Span> {
-    if_chain! {
-        if let ExprKind::Call(some_expr, [arg]) = expr.kind;
-        if let ExprKind::Path(QPath::Resolved(_, path)) = &some_expr.kind;
-        if let Some(path_segment) = path.segments.first();
-        if path_segment.ident.name.as_str() == name;
-        then {
-            Some(arg.span)
-        }
-        else {
-            None
-        }
+fn get_content_if_ctor_matches(cx: &LateContext<'_>, expr: &Expr<'_>, item: LangItem) -> Option<Span> {
+    if let ExprKind::Call(some_expr, [arg]) = expr.kind
+        && let ExprKind::Path(qpath) = &some_expr.kind
+        && is_lang_ctor(cx, qpath, item)
+    {
+        Some(arg.span)
+    } else {
+        None
     }
 }
-- 
cgit 1.4.1-3-g733a5


From 765cce11b10eabe667b42df1a9a878fe38b713ce Mon Sep 17 00:00:00 2001
From: Max Baumann <max@bmn.dev>
Date: Mon, 21 Mar 2022 00:04:37 +0100
Subject: refactor: remove need for MethodCall matching

---
 clippy_lints/src/methods/or_then_unwrap.rs | 9 +--------
 1 file changed, 1 insertion(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/or_then_unwrap.rs b/clippy_lints/src/methods/or_then_unwrap.rs
index 28b1bfe8fb5..be5768c3545 100644
--- a/clippy_lints/src/methods/or_then_unwrap.rs
+++ b/clippy_lints/src/methods/or_then_unwrap.rs
@@ -39,13 +39,6 @@ pub(super) fn check<'tcx>(
         return;
     }
 
-    let unwrap_span = if let ExprKind::MethodCall(_, _, span) = unwrap_expr.kind {
-        span
-    } else {
-        // unreachable. but fallback to ident's span ("()" are missing)
-        unwrap_expr.span
-    };
-
     let mut applicability = Applicability::MachineApplicable;
     let suggestion = format!(
         "unwrap_or({})",
@@ -55,7 +48,7 @@ pub(super) fn check<'tcx>(
     span_lint_and_sugg(
         cx,
         OR_THEN_UNWRAP,
-        or_span.to(unwrap_span),
+        unwrap_expr.span.with_lo(or_span.lo()),
         title,
         "try this",
         suggestion,
-- 
cgit 1.4.1-3-g733a5


From 5b6295d663fe5f2cc825f8a74578b0afab58c560 Mon Sep 17 00:00:00 2001
From: J-ZhengLi <lizheng135@huawei.com>
Date: Mon, 21 Mar 2022 14:11:22 +0800
Subject: allowing [`map_flatten`] to split long suggestions add new function
 `span_lint_and_sugg_` for edges in `clippy_utils::diagnostics`

---
 clippy_lints/src/methods/map_flatten.rs            | 118 +++++++++----------
 clippy_lints/src/methods/mod.rs                    |   2 +-
 .../src/utils/internal_lints/metadata_collector.rs |   3 +-
 clippy_utils/src/diagnostics.rs                    |  86 +++++++++++++-
 tests/ui/map_flatten.fixed                         |  31 -----
 tests/ui/map_flatten.rs                            |  74 +++++++-----
 tests/ui/map_flatten.stderr                        | 125 +++++++++++++++------
 tests/ui/map_flatten_fixable.fixed                 |  31 +++++
 tests/ui/map_flatten_fixable.rs                    |  31 +++++
 tests/ui/map_flatten_fixable.stderr                |  80 +++++++++++++
 10 files changed, 426 insertions(+), 155 deletions(-)
 delete mode 100644 tests/ui/map_flatten.fixed
 create mode 100644 tests/ui/map_flatten_fixable.fixed
 create mode 100644 tests/ui/map_flatten_fixable.rs
 create mode 100644 tests/ui/map_flatten_fixable.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/map_flatten.rs b/clippy_lints/src/methods/map_flatten.rs
index e1212c31cfb..f447940ea3b 100644
--- a/clippy_lints/src/methods/map_flatten.rs
+++ b/clippy_lints/src/methods/map_flatten.rs
@@ -1,83 +1,73 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::diagnostics::span_lint_and_sugg_for_edges;
 use clippy_utils::is_trait_method;
-use clippy_utils::source::snippet;
+use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_errors::Applicability;
-use rustc_hir as hir;
+use rustc_hir::Expr;
 use rustc_lint::LateContext;
 use rustc_middle::ty;
-use rustc_span::symbol::sym;
+use rustc_span::{symbol::sym, Span};
 
 use super::MAP_FLATTEN;
 
 /// lint use of `map().flatten()` for `Iterators` and 'Options'
-pub(super) fn check<'tcx>(
-    cx: &LateContext<'tcx>,
-    expr: &'tcx hir::Expr<'_>,
-    recv: &'tcx hir::Expr<'_>,
-    map_arg: &'tcx hir::Expr<'_>,
-) {
-    // lint if caller of `.map().flatten()` is an Iterator
-    if is_trait_method(cx, expr, sym::Iterator) {
-        let map_closure_ty = cx.typeck_results().expr_ty(map_arg);
-        let is_map_to_option = match map_closure_ty.kind() {
-            ty::Closure(_, _) | ty::FnDef(_, _) | ty::FnPtr(_) => {
-                let map_closure_sig = match map_closure_ty.kind() {
-                    ty::Closure(_, substs) => substs.as_closure().sig(),
-                    _ => map_closure_ty.fn_sig(cx.tcx),
-                };
-                let map_closure_return_ty = cx.tcx.erase_late_bound_regions(map_closure_sig.output());
-                is_type_diagnostic_item(cx, map_closure_return_ty, sym::Option)
-            },
-            _ => false,
-        };
-
-        let method_to_use = if is_map_to_option {
-            // `(...).map(...)` has type `impl Iterator<Item=Option<...>>
-            "filter_map"
-        } else {
-            // `(...).map(...)` has type `impl Iterator<Item=impl Iterator<...>>
-            "flat_map"
-        };
-        let func_snippet = snippet(cx, map_arg.span, "..");
-        let hint = format!(".{0}({1})", method_to_use, func_snippet);
-        span_lint_and_sugg(
+pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'_>, map_arg: &Expr<'_>, map_span: Span) {
+    if let Some((caller_ty_name, method_to_use)) = try_get_caller_ty_name_and_method_name(cx, expr, recv, map_arg) {
+        let mut applicability = Applicability::MachineApplicable;
+        let help_msgs = [
+            &format!("try replacing `map` with `{}`", method_to_use),
+            "and remove the `.flatten()`",
+        ];
+        let closure_snippet = snippet_with_applicability(cx, map_arg.span, "..", &mut applicability);
+        span_lint_and_sugg_for_edges(
             cx,
             MAP_FLATTEN,
-            expr.span.with_lo(recv.span.hi()),
-            "called `map(..).flatten()` on an `Iterator`",
-            &format!("try using `{}` instead", method_to_use),
-            hint,
-            Applicability::MachineApplicable,
+            expr.span.with_lo(map_span.lo()),
+            &format!("called `map(..).flatten()` on `{}`", caller_ty_name),
+            &help_msgs,
+            format!("{}({})", method_to_use, closure_snippet),
+            applicability,
         );
     }
+}
 
-    // lint if caller of `.map().flatten()` is an Option or Result
-    let caller_type = match cx.typeck_results().expr_ty(recv).kind() {
-        ty::Adt(adt, _) => {
+fn try_get_caller_ty_name_and_method_name(
+    cx: &LateContext<'_>,
+    expr: &Expr<'_>,
+    caller_expr: &Expr<'_>,
+    map_arg: &Expr<'_>,
+) -> Option<(&'static str, &'static str)> {
+    if is_trait_method(cx, expr, sym::Iterator) {
+        if is_map_to_option(cx, map_arg) {
+            // `(...).map(...)` has type `impl Iterator<Item=Option<...>>
+            Some(("Iterator", "filter_map"))
+        } else {
+            // `(...).map(...)` has type `impl Iterator<Item=impl Iterator<...>>
+            Some(("Iterator", "flat_map"))
+        }
+    } else {
+        if let ty::Adt(adt, _) = cx.typeck_results().expr_ty(caller_expr).kind() {
             if cx.tcx.is_diagnostic_item(sym::Option, adt.did()) {
-                "Option"
+                return Some(("Option", "and_then"));
             } else if cx.tcx.is_diagnostic_item(sym::Result, adt.did()) {
-                "Result"
-            } else {
-                return;
+                return Some(("Result", "and_then"));
             }
-        },
-        _ => {
-            return;
-        },
-    };
+        }
+        None
+    }
+}
 
-    let func_snippet = snippet(cx, map_arg.span, "..");
-    let hint = format!(".and_then({})", func_snippet);
-    let lint_info = format!("called `map(..).flatten()` on an `{}`", caller_type);
-    span_lint_and_sugg(
-        cx,
-        MAP_FLATTEN,
-        expr.span.with_lo(recv.span.hi()),
-        &lint_info,
-        "try using `and_then` instead",
-        hint,
-        Applicability::MachineApplicable,
-    );
+fn is_map_to_option(cx: &LateContext<'_>, map_arg: &Expr<'_>) -> bool {
+    let map_closure_ty = cx.typeck_results().expr_ty(map_arg);
+    match map_closure_ty.kind() {
+        ty::Closure(_, _) | ty::FnDef(_, _) | ty::FnPtr(_) => {
+            let map_closure_sig = match map_closure_ty.kind() {
+                ty::Closure(_, substs) => substs.as_closure().sig(),
+                _ => map_closure_ty.fn_sig(cx.tcx),
+            };
+            let map_closure_return_ty = cx.tcx.erase_late_bound_regions(map_closure_sig.output());
+            is_type_diagnostic_item(cx, map_closure_return_ty, sym::Option)
+        },
+        _ => false,
+    }
 }
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index aa9f86f292c..822f40179ee 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -2377,7 +2377,7 @@ fn check_methods<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, msrv: Optio
                 flat_map_option::check(cx, expr, arg, span);
             },
             (name @ "flatten", args @ []) => match method_call(recv) {
-                Some(("map", [recv, map_arg], _)) => map_flatten::check(cx, expr, recv, map_arg),
+                Some(("map", [recv, map_arg], map_span)) => map_flatten::check(cx, expr, recv, map_arg, map_span),
                 Some(("cloned", [recv2], _)) => iter_overeager_cloned::check(cx, expr, recv2, name, args),
                 _ => {},
             },
diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index a617422bbeb..b3fad6ce7b6 100644
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -85,7 +85,7 @@ macro_rules! CONFIGURATION_VALUE_TEMPLATE {
     };
 }
 
-const LINT_EMISSION_FUNCTIONS: [&[&str]; 7] = [
+const LINT_EMISSION_FUNCTIONS: [&[&str]; 8] = [
     &["clippy_utils", "diagnostics", "span_lint"],
     &["clippy_utils", "diagnostics", "span_lint_and_help"],
     &["clippy_utils", "diagnostics", "span_lint_and_note"],
@@ -93,6 +93,7 @@ const LINT_EMISSION_FUNCTIONS: [&[&str]; 7] = [
     &["clippy_utils", "diagnostics", "span_lint_and_sugg"],
     &["clippy_utils", "diagnostics", "span_lint_and_then"],
     &["clippy_utils", "diagnostics", "span_lint_hir_and_then"],
+    &["clippy_utils", "diagnostics", "span_lint_and_sugg_for_edges"],
 ];
 const SUGGESTION_DIAGNOSTIC_BUILDER_METHODS: [(&str, bool); 9] = [
     ("span_suggestion", false),
diff --git a/clippy_utils/src/diagnostics.rs b/clippy_utils/src/diagnostics.rs
index a927788e6a4..625a53899df 100644
--- a/clippy_utils/src/diagnostics.rs
+++ b/clippy_utils/src/diagnostics.rs
@@ -8,7 +8,7 @@
 //! Thank you!
 //! ~The `INTERNAL_METADATA_COLLECTOR` lint
 
-use rustc_errors::{Applicability, Diagnostic};
+use rustc_errors::{emitter::MAX_SUGGESTION_HIGHLIGHT_LINES, Applicability, Diagnostic};
 use rustc_hir::HirId;
 use rustc_lint::{LateContext, Lint, LintContext};
 use rustc_span::source_map::{MultiSpan, Span};
@@ -213,6 +213,90 @@ pub fn span_lint_and_sugg<'a, T: LintContext>(
     });
 }
 
+/// Like [`span_lint_and_sugg`] with a focus on the edges. The output will either
+/// emit single span or multispan suggestion depending on the number of its lines.
+///
+/// If the given suggestion string has more lines than the maximum display length defined by
+/// [`MAX_SUGGESTION_HIGHLIGHT_LINES`][`rustc_errors::emitter::MAX_SUGGESTION_HIGHLIGHT_LINES`],
+/// this function will split the suggestion and span to showcase the change for the top and
+/// bottom edge of the code. For normal suggestions, in one display window, the help message
+/// will be combined with a colon.
+///
+/// Multipart suggestions like the one being created here currently cannot be
+/// applied by rustfix (See [rustfix#141](https://github.com/rust-lang/rustfix/issues/141)).
+/// Testing rustfix with this lint emission function might require a file with
+/// suggestions that can be fixed and those that can't. See
+/// [clippy#8520](https://github.com/rust-lang/rust-clippy/pull/8520/files) for
+/// an example and of this.
+///
+/// # Example for a long suggestion
+///
+/// ```text
+/// error: called `map(..).flatten()` on `Option`
+///   --> $DIR/map_flatten.rs:8:10
+///    |
+/// LL |           .map(|x| {
+///    |  __________^
+/// LL | |             if x <= 5 {
+/// LL | |                 Some(x)
+/// LL | |             } else {
+/// ...  |
+/// LL | |         })
+/// LL | |         .flatten();
+///    | |__________________^
+///    |
+///   = note: `-D clippy::map-flatten` implied by `-D warnings`
+/// help: try replacing `map` with `and_then`
+///    |
+/// LL ~         .and_then(|x| {
+/// LL +             if x <= 5 {
+/// LL +                 Some(x)
+///    |
+/// help: and remove the `.flatten()`
+///    |
+/// LL +                 None
+/// LL +             }
+/// LL ~         });
+///    |
+/// ```
+pub fn span_lint_and_sugg_for_edges(
+    cx: &LateContext<'_>,
+    lint: &'static Lint,
+    sp: Span,
+    msg: &str,
+    helps: &[&str; 2],
+    sugg: String,
+    applicability: Applicability,
+) {
+    span_lint_and_then(cx, lint, sp, msg, |diag| {
+        let sugg_lines_count = sugg.lines().count();
+        if sugg_lines_count > MAX_SUGGESTION_HIGHLIGHT_LINES {
+            let sm = cx.sess().source_map();
+            if let (Ok(line_upper), Ok(line_bottom)) = (sm.lookup_line(sp.lo()), sm.lookup_line(sp.hi())) {
+                let split_idx = MAX_SUGGESTION_HIGHLIGHT_LINES / 2;
+                let span_upper = sm.span_until_char(sp.with_hi(line_upper.sf.lines[line_upper.line + split_idx]), '\n');
+                let span_bottom = sp.with_lo(line_bottom.sf.lines[line_bottom.line - split_idx]);
+
+                let sugg_lines_vec = sugg.lines().collect::<Vec<&str>>();
+                let sugg_upper = sugg_lines_vec[..split_idx].join("\n");
+                let sugg_bottom = sugg_lines_vec[sugg_lines_count - split_idx..].join("\n");
+
+                diag.span_suggestion(span_upper, helps[0], sugg_upper, applicability);
+                diag.span_suggestion(span_bottom, helps[1], sugg_bottom, applicability);
+
+                return;
+            }
+        }
+        diag.span_suggestion_with_style(
+            sp,
+            &helps.join(", "),
+            sugg,
+            applicability,
+            rustc_errors::SuggestionStyle::ShowAlways,
+        );
+    });
+}
+
 /// Create a suggestion made from several `span → replacement`.
 ///
 /// Note: in the JSON format (used by `compiletest_rs`), the help message will
diff --git a/tests/ui/map_flatten.fixed b/tests/ui/map_flatten.fixed
deleted file mode 100644
index fec3a95edd6..00000000000
--- a/tests/ui/map_flatten.fixed
+++ /dev/null
@@ -1,31 +0,0 @@
-// run-rustfix
-
-#![warn(clippy::all, clippy::pedantic)]
-#![allow(clippy::let_underscore_drop)]
-#![allow(clippy::missing_docs_in_private_items)]
-#![allow(clippy::map_identity)]
-#![allow(clippy::redundant_closure)]
-#![allow(clippy::unnecessary_wraps)]
-#![feature(result_flattening)]
-
-fn main() {
-    // mapping to Option on Iterator
-    fn option_id(x: i8) -> Option<i8> {
-        Some(x)
-    }
-    let option_id_ref: fn(i8) -> Option<i8> = option_id;
-    let option_id_closure = |x| Some(x);
-    let _: Vec<_> = vec![5_i8; 6].into_iter().filter_map(option_id).collect();
-    let _: Vec<_> = vec![5_i8; 6].into_iter().filter_map(option_id_ref).collect();
-    let _: Vec<_> = vec![5_i8; 6].into_iter().filter_map(option_id_closure).collect();
-    let _: Vec<_> = vec![5_i8; 6].into_iter().filter_map(|x| x.checked_add(1)).collect();
-
-    // mapping to Iterator on Iterator
-    let _: Vec<_> = vec![5_i8; 6].into_iter().flat_map(|x| 0..x).collect();
-
-    // mapping to Option on Option
-    let _: Option<_> = (Some(Some(1))).and_then(|x| x);
-
-    // mapping to Result on Result
-    let _: Result<_, &str> = (Ok(Ok(1))).and_then(|x| x);
-}
diff --git a/tests/ui/map_flatten.rs b/tests/ui/map_flatten.rs
index aa1f76e335a..7d47ee09dc1 100644
--- a/tests/ui/map_flatten.rs
+++ b/tests/ui/map_flatten.rs
@@ -1,31 +1,55 @@
-// run-rustfix
-
-#![warn(clippy::all, clippy::pedantic)]
-#![allow(clippy::let_underscore_drop)]
-#![allow(clippy::missing_docs_in_private_items)]
-#![allow(clippy::map_identity)]
-#![allow(clippy::redundant_closure)]
-#![allow(clippy::unnecessary_wraps)]
+#![warn(clippy::map_flatten)]
 #![feature(result_flattening)]
 
-fn main() {
-    // mapping to Option on Iterator
-    fn option_id(x: i8) -> Option<i8> {
-        Some(x)
-    }
-    let option_id_ref: fn(i8) -> Option<i8> = option_id;
-    let option_id_closure = |x| Some(x);
-    let _: Vec<_> = vec![5_i8; 6].into_iter().map(option_id).flatten().collect();
-    let _: Vec<_> = vec![5_i8; 6].into_iter().map(option_id_ref).flatten().collect();
-    let _: Vec<_> = vec![5_i8; 6].into_iter().map(option_id_closure).flatten().collect();
-    let _: Vec<_> = vec![5_i8; 6].into_iter().map(|x| x.checked_add(1)).flatten().collect();
+// issue #8506, multi-line
+#[rustfmt::skip]
+fn long_span() {
+    let _: Option<i32> = Some(1)
+        .map(|x| {
+            if x <= 5 {
+                Some(x)
+            } else {
+                None
+            }
+        })
+        .flatten();
 
-    // mapping to Iterator on Iterator
-    let _: Vec<_> = vec![5_i8; 6].into_iter().map(|x| 0..x).flatten().collect();
+    let _: Result<i32, i32> = Ok(1)
+        .map(|x| {
+            if x == 1 {
+                Ok(x)
+            } else {
+                Err(0)
+            }
+        })
+        .flatten();
 
-    // mapping to Option on Option
-    let _: Option<_> = (Some(Some(1))).map(|x| x).flatten();
+    let result: Result<i32, i32> = Ok(2);
+    fn do_something() { }
+    let _: Result<i32, i32> = result
+        .map(|res| {
+            if res > 0 {
+                do_something();
+                Ok(res)
+            } else {
+                Err(0)
+            }
+        })
+        .flatten();
+        
+    let _: Vec<_> = vec![5_i8; 6]
+        .into_iter()
+        .map(|some_value| {
+            if some_value > 3 {
+                Some(some_value)
+            } else {
+                None
+            }
+        })
+        .flatten()
+        .collect();
+}
 
-    // mapping to Result on Result
-    let _: Result<_, &str> = (Ok(Ok(1))).map(|x| x).flatten();
+fn main() {
+    long_span();
 }
diff --git a/tests/ui/map_flatten.stderr b/tests/ui/map_flatten.stderr
index bcd2047e6fa..c9c60df838f 100644
--- a/tests/ui/map_flatten.stderr
+++ b/tests/ui/map_flatten.stderr
@@ -1,46 +1,107 @@
-error: called `map(..).flatten()` on an `Iterator`
-  --> $DIR/map_flatten.rs:18:46
+error: called `map(..).flatten()` on `Option`
+  --> $DIR/map_flatten.rs:8:10
    |
-LL |     let _: Vec<_> = vec![5_i8; 6].into_iter().map(option_id).flatten().collect();
-   |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try using `filter_map` instead: `.filter_map(option_id)`
+LL |           .map(|x| {
+   |  __________^
+LL | |             if x <= 5 {
+LL | |                 Some(x)
+LL | |             } else {
+...  |
+LL | |         })
+LL | |         .flatten();
+   | |__________________^
    |
    = note: `-D clippy::map-flatten` implied by `-D warnings`
-
-error: called `map(..).flatten()` on an `Iterator`
-  --> $DIR/map_flatten.rs:19:46
+help: try replacing `map` with `and_then`
    |
-LL |     let _: Vec<_> = vec![5_i8; 6].into_iter().map(option_id_ref).flatten().collect();
-   |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try using `filter_map` instead: `.filter_map(option_id_ref)`
-
-error: called `map(..).flatten()` on an `Iterator`
-  --> $DIR/map_flatten.rs:20:46
+LL ~         .and_then(|x| {
+LL +             if x <= 5 {
+LL +                 Some(x)
    |
-LL |     let _: Vec<_> = vec![5_i8; 6].into_iter().map(option_id_closure).flatten().collect();
-   |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try using `filter_map` instead: `.filter_map(option_id_closure)`
-
-error: called `map(..).flatten()` on an `Iterator`
-  --> $DIR/map_flatten.rs:21:46
+help: and remove the `.flatten()`
+   |
+LL +                 None
+LL +             }
+LL ~         });
    |
-LL |     let _: Vec<_> = vec![5_i8; 6].into_iter().map(|x| x.checked_add(1)).flatten().collect();
-   |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try using `filter_map` instead: `.filter_map(|x| x.checked_add(1))`
 
-error: called `map(..).flatten()` on an `Iterator`
-  --> $DIR/map_flatten.rs:24:46
+error: called `map(..).flatten()` on `Result`
+  --> $DIR/map_flatten.rs:18:10
+   |
+LL |           .map(|x| {
+   |  __________^
+LL | |             if x == 1 {
+LL | |                 Ok(x)
+LL | |             } else {
+...  |
+LL | |         })
+LL | |         .flatten();
+   | |__________________^
+   |
+help: try replacing `map` with `and_then`
+   |
+LL ~         .and_then(|x| {
+LL +             if x == 1 {
+LL +                 Ok(x)
+   |
+help: and remove the `.flatten()`
+   |
+LL +                 Err(0)
+LL +             }
+LL ~         });
    |
-LL |     let _: Vec<_> = vec![5_i8; 6].into_iter().map(|x| 0..x).flatten().collect();
-   |                                              ^^^^^^^^^^^^^^^^^^^^^^^^ help: try using `flat_map` instead: `.flat_map(|x| 0..x)`
 
-error: called `map(..).flatten()` on an `Option`
-  --> $DIR/map_flatten.rs:27:39
+error: called `map(..).flatten()` on `Result`
+  --> $DIR/map_flatten.rs:30:10
+   |
+LL |           .map(|res| {
+   |  __________^
+LL | |             if res > 0 {
+LL | |                 do_something();
+LL | |                 Ok(res)
+...  |
+LL | |         })
+LL | |         .flatten();
+   | |__________________^
+   |
+help: try replacing `map` with `and_then`
+   |
+LL ~         .and_then(|res| {
+LL +             if res > 0 {
+LL +                 do_something();
+   |
+help: and remove the `.flatten()`
+   |
+LL +                 Err(0)
+LL +             }
+LL ~         });
    |
-LL |     let _: Option<_> = (Some(Some(1))).map(|x| x).flatten();
-   |                                       ^^^^^^^^^^^^^^^^^^^^^ help: try using `and_then` instead: `.and_then(|x| x)`
 
-error: called `map(..).flatten()` on an `Result`
-  --> $DIR/map_flatten.rs:30:41
+error: called `map(..).flatten()` on `Iterator`
+  --> $DIR/map_flatten.rs:42:10
+   |
+LL |           .map(|some_value| {
+   |  __________^
+LL | |             if some_value > 3 {
+LL | |                 Some(some_value)
+LL | |             } else {
+...  |
+LL | |         })
+LL | |         .flatten()
+   | |__________________^
+   |
+help: try replacing `map` with `filter_map`
+   |
+LL ~         .filter_map(|some_value| {
+LL +             if some_value > 3 {
+LL +                 Some(some_value)
+   |
+help: and remove the `.flatten()`
+   |
+LL +                 None
+LL +             }
+LL +         })
    |
-LL |     let _: Result<_, &str> = (Ok(Ok(1))).map(|x| x).flatten();
-   |                                         ^^^^^^^^^^^^^^^^^^^^^ help: try using `and_then` instead: `.and_then(|x| x)`
 
-error: aborting due to 7 previous errors
+error: aborting due to 4 previous errors
 
diff --git a/tests/ui/map_flatten_fixable.fixed b/tests/ui/map_flatten_fixable.fixed
new file mode 100644
index 00000000000..fec3a95edd6
--- /dev/null
+++ b/tests/ui/map_flatten_fixable.fixed
@@ -0,0 +1,31 @@
+// run-rustfix
+
+#![warn(clippy::all, clippy::pedantic)]
+#![allow(clippy::let_underscore_drop)]
+#![allow(clippy::missing_docs_in_private_items)]
+#![allow(clippy::map_identity)]
+#![allow(clippy::redundant_closure)]
+#![allow(clippy::unnecessary_wraps)]
+#![feature(result_flattening)]
+
+fn main() {
+    // mapping to Option on Iterator
+    fn option_id(x: i8) -> Option<i8> {
+        Some(x)
+    }
+    let option_id_ref: fn(i8) -> Option<i8> = option_id;
+    let option_id_closure = |x| Some(x);
+    let _: Vec<_> = vec![5_i8; 6].into_iter().filter_map(option_id).collect();
+    let _: Vec<_> = vec![5_i8; 6].into_iter().filter_map(option_id_ref).collect();
+    let _: Vec<_> = vec![5_i8; 6].into_iter().filter_map(option_id_closure).collect();
+    let _: Vec<_> = vec![5_i8; 6].into_iter().filter_map(|x| x.checked_add(1)).collect();
+
+    // mapping to Iterator on Iterator
+    let _: Vec<_> = vec![5_i8; 6].into_iter().flat_map(|x| 0..x).collect();
+
+    // mapping to Option on Option
+    let _: Option<_> = (Some(Some(1))).and_then(|x| x);
+
+    // mapping to Result on Result
+    let _: Result<_, &str> = (Ok(Ok(1))).and_then(|x| x);
+}
diff --git a/tests/ui/map_flatten_fixable.rs b/tests/ui/map_flatten_fixable.rs
new file mode 100644
index 00000000000..aa1f76e335a
--- /dev/null
+++ b/tests/ui/map_flatten_fixable.rs
@@ -0,0 +1,31 @@
+// run-rustfix
+
+#![warn(clippy::all, clippy::pedantic)]
+#![allow(clippy::let_underscore_drop)]
+#![allow(clippy::missing_docs_in_private_items)]
+#![allow(clippy::map_identity)]
+#![allow(clippy::redundant_closure)]
+#![allow(clippy::unnecessary_wraps)]
+#![feature(result_flattening)]
+
+fn main() {
+    // mapping to Option on Iterator
+    fn option_id(x: i8) -> Option<i8> {
+        Some(x)
+    }
+    let option_id_ref: fn(i8) -> Option<i8> = option_id;
+    let option_id_closure = |x| Some(x);
+    let _: Vec<_> = vec![5_i8; 6].into_iter().map(option_id).flatten().collect();
+    let _: Vec<_> = vec![5_i8; 6].into_iter().map(option_id_ref).flatten().collect();
+    let _: Vec<_> = vec![5_i8; 6].into_iter().map(option_id_closure).flatten().collect();
+    let _: Vec<_> = vec![5_i8; 6].into_iter().map(|x| x.checked_add(1)).flatten().collect();
+
+    // mapping to Iterator on Iterator
+    let _: Vec<_> = vec![5_i8; 6].into_iter().map(|x| 0..x).flatten().collect();
+
+    // mapping to Option on Option
+    let _: Option<_> = (Some(Some(1))).map(|x| x).flatten();
+
+    // mapping to Result on Result
+    let _: Result<_, &str> = (Ok(Ok(1))).map(|x| x).flatten();
+}
diff --git a/tests/ui/map_flatten_fixable.stderr b/tests/ui/map_flatten_fixable.stderr
new file mode 100644
index 00000000000..c91c73846b6
--- /dev/null
+++ b/tests/ui/map_flatten_fixable.stderr
@@ -0,0 +1,80 @@
+error: called `map(..).flatten()` on `Iterator`
+  --> $DIR/map_flatten_fixable.rs:18:47
+   |
+LL |     let _: Vec<_> = vec![5_i8; 6].into_iter().map(option_id).flatten().collect();
+   |                                               ^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::map-flatten` implied by `-D warnings`
+help: try replacing `map` with `filter_map`, and remove the `.flatten()`
+   |
+LL |     let _: Vec<_> = vec![5_i8; 6].into_iter().filter_map(option_id).collect();
+   |                                               ~~~~~~~~~~~~~~~~~~~~~
+
+error: called `map(..).flatten()` on `Iterator`
+  --> $DIR/map_flatten_fixable.rs:19:47
+   |
+LL |     let _: Vec<_> = vec![5_i8; 6].into_iter().map(option_id_ref).flatten().collect();
+   |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: try replacing `map` with `filter_map`, and remove the `.flatten()`
+   |
+LL |     let _: Vec<_> = vec![5_i8; 6].into_iter().filter_map(option_id_ref).collect();
+   |                                               ~~~~~~~~~~~~~~~~~~~~~~~~~
+
+error: called `map(..).flatten()` on `Iterator`
+  --> $DIR/map_flatten_fixable.rs:20:47
+   |
+LL |     let _: Vec<_> = vec![5_i8; 6].into_iter().map(option_id_closure).flatten().collect();
+   |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: try replacing `map` with `filter_map`, and remove the `.flatten()`
+   |
+LL |     let _: Vec<_> = vec![5_i8; 6].into_iter().filter_map(option_id_closure).collect();
+   |                                               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+error: called `map(..).flatten()` on `Iterator`
+  --> $DIR/map_flatten_fixable.rs:21:47
+   |
+LL |     let _: Vec<_> = vec![5_i8; 6].into_iter().map(|x| x.checked_add(1)).flatten().collect();
+   |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: try replacing `map` with `filter_map`, and remove the `.flatten()`
+   |
+LL |     let _: Vec<_> = vec![5_i8; 6].into_iter().filter_map(|x| x.checked_add(1)).collect();
+   |                                               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+error: called `map(..).flatten()` on `Iterator`
+  --> $DIR/map_flatten_fixable.rs:24:47
+   |
+LL |     let _: Vec<_> = vec![5_i8; 6].into_iter().map(|x| 0..x).flatten().collect();
+   |                                               ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: try replacing `map` with `flat_map`, and remove the `.flatten()`
+   |
+LL |     let _: Vec<_> = vec![5_i8; 6].into_iter().flat_map(|x| 0..x).collect();
+   |                                               ~~~~~~~~~~~~~~~~~~
+
+error: called `map(..).flatten()` on `Option`
+  --> $DIR/map_flatten_fixable.rs:27:40
+   |
+LL |     let _: Option<_> = (Some(Some(1))).map(|x| x).flatten();
+   |                                        ^^^^^^^^^^^^^^^^^^^^
+   |
+help: try replacing `map` with `and_then`, and remove the `.flatten()`
+   |
+LL |     let _: Option<_> = (Some(Some(1))).and_then(|x| x);
+   |                                        ~~~~~~~~~~~~~~~
+
+error: called `map(..).flatten()` on `Result`
+  --> $DIR/map_flatten_fixable.rs:30:42
+   |
+LL |     let _: Result<_, &str> = (Ok(Ok(1))).map(|x| x).flatten();
+   |                                          ^^^^^^^^^^^^^^^^^^^^
+   |
+help: try replacing `map` with `and_then`, and remove the `.flatten()`
+   |
+LL |     let _: Result<_, &str> = (Ok(Ok(1))).and_then(|x| x);
+   |                                          ~~~~~~~~~~~~~~~
+
+error: aborting due to 7 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 65a26692fd361b794f528ead645d880527ce3de0 Mon Sep 17 00:00:00 2001
From: "Samuel E. Moelius III" <sam@moeli.us>
Date: Wed, 23 Mar 2022 21:08:52 -0400
Subject: Add `crate_in_macro_def` lint

---
 CHANGELOG.md                                 |   1 +
 clippy_lints/src/crate_in_macro_def.rs       | 100 +++++++++++++++++++++++++++
 clippy_lints/src/lib.register_all.rs         |   1 +
 clippy_lints/src/lib.register_correctness.rs |   1 +
 clippy_lints/src/lib.register_lints.rs       |   1 +
 clippy_lints/src/lib.rs                      |   2 +
 clippy_lints/src/utils/conf.rs               |   2 +-
 tests/ui/crate_in_macro_def.fixed            |  29 ++++++++
 tests/ui/crate_in_macro_def.rs               |  29 ++++++++
 tests/ui/crate_in_macro_def.stderr           |  14 ++++
 tests/ui/crate_in_macro_def_allow.rs         |  19 +++++
 tests/ui/crate_in_macro_def_allow.stderr     |   0
 12 files changed, 198 insertions(+), 1 deletion(-)
 create mode 100644 clippy_lints/src/crate_in_macro_def.rs
 create mode 100644 tests/ui/crate_in_macro_def.fixed
 create mode 100644 tests/ui/crate_in_macro_def.rs
 create mode 100644 tests/ui/crate_in_macro_def.stderr
 create mode 100644 tests/ui/crate_in_macro_def_allow.rs
 create mode 100644 tests/ui/crate_in_macro_def_allow.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index dc83de66554..9cede8065ec 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3097,6 +3097,7 @@ Released 2018-09-13
 [`comparison_chain`]: https://rust-lang.github.io/rust-clippy/master/index.html#comparison_chain
 [`comparison_to_empty`]: https://rust-lang.github.io/rust-clippy/master/index.html#comparison_to_empty
 [`copy_iterator`]: https://rust-lang.github.io/rust-clippy/master/index.html#copy_iterator
+[`crate_in_macro_def`]: https://rust-lang.github.io/rust-clippy/master/index.html#crate_in_macro_def
 [`create_dir`]: https://rust-lang.github.io/rust-clippy/master/index.html#create_dir
 [`crosspointer_transmute`]: https://rust-lang.github.io/rust-clippy/master/index.html#crosspointer_transmute
 [`dbg_macro`]: https://rust-lang.github.io/rust-clippy/master/index.html#dbg_macro
diff --git a/clippy_lints/src/crate_in_macro_def.rs b/clippy_lints/src/crate_in_macro_def.rs
new file mode 100644
index 00000000000..9ac6d6d520c
--- /dev/null
+++ b/clippy_lints/src/crate_in_macro_def.rs
@@ -0,0 +1,100 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use rustc_ast::ast::MacroDef;
+use rustc_ast::node_id::NodeId;
+use rustc_ast::token::{Token, TokenKind};
+use rustc_ast::tokenstream::{TokenStream, TokenTree};
+use rustc_errors::Applicability;
+use rustc_lint::{EarlyContext, EarlyLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::Span;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for use of `crate` as opposed to `$crate` in a macro definition.
+    ///
+    /// ### Why is this bad?
+    /// `crate` refers to macro call's crate, whereas `$crate` refers to the macro
+    /// definition's crate. Rarely is the former intended. See:
+    /// https://doc.rust-lang.org/reference/macros-by-example.html#hygiene
+    ///
+    /// ### Example
+    /// ```rust
+    /// macro_rules! print_message {
+    ///     () => {
+    ///         println!("{}", crate::MESSAGE);
+    ///     };
+    /// }
+    /// pub const MESSAGE: &str = "Hello!";
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// macro_rules! print_message {
+    ///     () => {
+    ///         println!("{}", $crate::MESSAGE);
+    ///     };
+    /// }
+    /// pub const MESSAGE: &str = "Hello!";
+    /// ```
+    #[clippy::version = "1.61.0"]
+    pub CRATE_IN_MACRO_DEF,
+    correctness,
+    "using `crate` in a macro definition"
+}
+declare_lint_pass!(CrateInMacroDef => [CRATE_IN_MACRO_DEF]);
+
+impl EarlyLintPass for CrateInMacroDef {
+    fn check_mac_def(&mut self, cx: &EarlyContext<'_>, macro_def: &MacroDef, _: NodeId) {
+        let tts = macro_def.body.inner_tokens();
+        if let Some(span) = contains_unhygienic_crate_reference(&tts) {
+            span_lint_and_sugg(
+                cx,
+                CRATE_IN_MACRO_DEF,
+                span,
+                "reference to the macro call's crate, which is rarely intended",
+                "if reference to the macro definition's crate is intended, use",
+                String::from("$crate"),
+                Applicability::MachineApplicable,
+            );
+        }
+    }
+}
+
+fn contains_unhygienic_crate_reference(tts: &TokenStream) -> Option<Span> {
+    let mut prev_is_dollar = false;
+    let mut cursor = tts.trees();
+    while let Some(curr) = cursor.next() {
+        if_chain! {
+            if !prev_is_dollar;
+            if let Some(span) = is_crate_keyword(&curr);
+            if let Some(next) = cursor.look_ahead(0);
+            if is_token(next, &TokenKind::ModSep);
+            then {
+                return Some(span);
+            }
+        }
+        if let TokenTree::Delimited(_, _, tts) = &curr {
+            let span = contains_unhygienic_crate_reference(tts);
+            if span.is_some() {
+                return span;
+            }
+        }
+        prev_is_dollar = is_token(&curr, &TokenKind::Dollar);
+    }
+    None
+}
+
+fn is_crate_keyword(tt: &TokenTree) -> Option<Span> {
+    if_chain! {
+        if let TokenTree::Token(Token { kind: TokenKind::Ident(symbol, _), span }) = tt;
+        if symbol.as_str() == "crate";
+        then { Some(*span) } else { None }
+    }
+}
+
+fn is_token(tt: &TokenTree, kind: &TokenKind) -> bool {
+    if let TokenTree::Token(Token { kind: other, .. }) = tt {
+        kind == other
+    } else {
+        false
+    }
+}
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 132a4662676..1fb3ca1fd9b 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -37,6 +37,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(comparison_chain::COMPARISON_CHAIN),
     LintId::of(copies::IFS_SAME_COND),
     LintId::of(copies::IF_SAME_THEN_ELSE),
+    LintId::of(crate_in_macro_def::CRATE_IN_MACRO_DEF),
     LintId::of(default::FIELD_REASSIGN_WITH_DEFAULT),
     LintId::of(dereference::NEEDLESS_BORROW),
     LintId::of(derivable_impls::DERIVABLE_IMPLS),
diff --git a/clippy_lints/src/lib.register_correctness.rs b/clippy_lints/src/lib.register_correctness.rs
index df63f84463d..d5cade8fe99 100644
--- a/clippy_lints/src/lib.register_correctness.rs
+++ b/clippy_lints/src/lib.register_correctness.rs
@@ -16,6 +16,7 @@ store.register_group(true, "clippy::correctness", Some("clippy_correctness"), ve
     LintId::of(casts::CAST_SLICE_DIFFERENT_SIZES),
     LintId::of(copies::IFS_SAME_COND),
     LintId::of(copies::IF_SAME_THEN_ELSE),
+    LintId::of(crate_in_macro_def::CRATE_IN_MACRO_DEF),
     LintId::of(derive::DERIVE_HASH_XOR_EQ),
     LintId::of(derive::DERIVE_ORD_XOR_PARTIAL_ORD),
     LintId::of(drop_forget_ref::DROP_COPY),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 65ad64f1901..984939a74b8 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -97,6 +97,7 @@ store.register_lints(&[
     copies::IF_SAME_THEN_ELSE,
     copies::SAME_FUNCTIONS_IN_IF_CONDITION,
     copy_iterator::COPY_ITERATOR,
+    crate_in_macro_def::CRATE_IN_MACRO_DEF,
     create_dir::CREATE_DIR,
     dbg_macro::DBG_MACRO,
     default::DEFAULT_TRAIT_ACCESS,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index f2a07999144..c8b57956b1b 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -190,6 +190,7 @@ mod collapsible_match;
 mod comparison_chain;
 mod copies;
 mod copy_iterator;
+mod crate_in_macro_def;
 mod create_dir;
 mod dbg_macro;
 mod default;
@@ -867,6 +868,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
             ignore_publish: cargo_ignore_publish,
         })
     });
+    store.register_early_pass(|| Box::new(crate_in_macro_def::CrateInMacroDef));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 680b2eb1da7..b1e474f8056 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -123,7 +123,7 @@ macro_rules! define_Conf {
 
         #[cfg(feature = "internal")]
         pub mod metadata {
-            use crate::utils::internal_lints::metadata_collector::ClippyConfiguration;
+            use $crate::utils::internal_lints::metadata_collector::ClippyConfiguration;
 
             macro_rules! wrap_option {
                 () => (None);
diff --git a/tests/ui/crate_in_macro_def.fixed b/tests/ui/crate_in_macro_def.fixed
new file mode 100644
index 00000000000..77b43f43260
--- /dev/null
+++ b/tests/ui/crate_in_macro_def.fixed
@@ -0,0 +1,29 @@
+// run-rustfix
+#![warn(clippy::crate_in_macro_def)]
+
+#[macro_use]
+mod hygienic {
+    macro_rules! print_message_hygienic {
+        () => {
+            println!("{}", $crate::hygienic::MESSAGE);
+        };
+    }
+
+    pub const MESSAGE: &str = "Hello!";
+}
+
+#[macro_use]
+mod unhygienic {
+    macro_rules! print_message_unhygienic {
+        () => {
+            println!("{}", $crate::unhygienic::MESSAGE);
+        };
+    }
+
+    pub const MESSAGE: &str = "Hello!";
+}
+
+fn main() {
+    print_message_hygienic!();
+    print_message_unhygienic!();
+}
diff --git a/tests/ui/crate_in_macro_def.rs b/tests/ui/crate_in_macro_def.rs
new file mode 100644
index 00000000000..d72d4c4009c
--- /dev/null
+++ b/tests/ui/crate_in_macro_def.rs
@@ -0,0 +1,29 @@
+// run-rustfix
+#![warn(clippy::crate_in_macro_def)]
+
+#[macro_use]
+mod hygienic {
+    macro_rules! print_message_hygienic {
+        () => {
+            println!("{}", $crate::hygienic::MESSAGE);
+        };
+    }
+
+    pub const MESSAGE: &str = "Hello!";
+}
+
+#[macro_use]
+mod unhygienic {
+    macro_rules! print_message_unhygienic {
+        () => {
+            println!("{}", crate::unhygienic::MESSAGE);
+        };
+    }
+
+    pub const MESSAGE: &str = "Hello!";
+}
+
+fn main() {
+    print_message_hygienic!();
+    print_message_unhygienic!();
+}
diff --git a/tests/ui/crate_in_macro_def.stderr b/tests/ui/crate_in_macro_def.stderr
new file mode 100644
index 00000000000..3f5e4870ad1
--- /dev/null
+++ b/tests/ui/crate_in_macro_def.stderr
@@ -0,0 +1,14 @@
+error: reference to the macro call's crate, which is rarely intended
+  --> $DIR/crate_in_macro_def.rs:19:28
+   |
+LL |             println!("{}", crate::unhygienic::MESSAGE);
+   |                            ^^^^^
+   |
+   = note: `-D clippy::crate-in-macro-def` implied by `-D warnings`
+help: if reference to the macro definition's crate is intended, use
+   |
+LL |             println!("{}", $crate::unhygienic::MESSAGE);
+   |                            ~~~~~~
+
+error: aborting due to previous error
+
diff --git a/tests/ui/crate_in_macro_def_allow.rs b/tests/ui/crate_in_macro_def_allow.rs
new file mode 100644
index 00000000000..d6b30fd9615
--- /dev/null
+++ b/tests/ui/crate_in_macro_def_allow.rs
@@ -0,0 +1,19 @@
+#![warn(clippy::crate_in_macro_def)]
+
+#[macro_use]
+mod intentional {
+    // For cases where use of `crate` is intentional, applying `allow` to the macro definition
+    // should suppress the lint.
+    #[allow(clippy::crate_in_macro_def)]
+    macro_rules! print_message {
+        () => {
+            println!("{}", crate::CALLER_PROVIDED_MESSAGE);
+        };
+    }
+}
+
+fn main() {
+    print_message!();
+}
+
+pub const CALLER_PROVIDED_MESSAGE: &str = "Hello!";
diff --git a/tests/ui/crate_in_macro_def_allow.stderr b/tests/ui/crate_in_macro_def_allow.stderr
new file mode 100644
index 00000000000..e69de29bb2d
-- 
cgit 1.4.1-3-g733a5


From b60a7fb7b67566c611cfd0de94f76c5596a4915d Mon Sep 17 00:00:00 2001
From: Yoav Lavi <yoav@yoavlavi.com>
Date: Thu, 24 Mar 2022 13:18:18 +0100
Subject: `unnecessary_join` lint

---
 CHANGELOG.md                                 |  1 +
 clippy_lints/src/lib.register_lints.rs       |  1 +
 clippy_lints/src/lib.register_pedantic.rs    |  1 +
 clippy_lints/src/methods/mod.rs              | 36 ++++++++++++++++++++++++
 clippy_lints/src/methods/unnecessary_join.rs | 41 ++++++++++++++++++++++++++++
 tests/ui/unnecessary_join.fixed              | 35 ++++++++++++++++++++++++
 tests/ui/unnecessary_join.rs                 | 37 +++++++++++++++++++++++++
 tests/ui/unnecessary_join.stderr             | 20 ++++++++++++++
 8 files changed, 172 insertions(+)
 create mode 100644 clippy_lints/src/methods/unnecessary_join.rs
 create mode 100644 tests/ui/unnecessary_join.fixed
 create mode 100644 tests/ui/unnecessary_join.rs
 create mode 100644 tests/ui/unnecessary_join.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index dc83de66554..88f71931d92 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3508,6 +3508,7 @@ Released 2018-09-13
 [`unnecessary_filter_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_filter_map
 [`unnecessary_find_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_find_map
 [`unnecessary_fold`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_fold
+[`unnecessary_join`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_join
 [`unnecessary_lazy_evaluations`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_lazy_evaluations
 [`unnecessary_mut_passed`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_mut_passed
 [`unnecessary_operation`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_operation
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 65ad64f1901..21f1ef562b5 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -334,6 +334,7 @@ store.register_lints(&[
     methods::UNNECESSARY_FILTER_MAP,
     methods::UNNECESSARY_FIND_MAP,
     methods::UNNECESSARY_FOLD,
+    methods::UNNECESSARY_JOIN,
     methods::UNNECESSARY_LAZY_EVALUATIONS,
     methods::UNNECESSARY_TO_OWNED,
     methods::UNWRAP_OR_ELSE_DEFAULT,
diff --git a/clippy_lints/src/lib.register_pedantic.rs b/clippy_lints/src/lib.register_pedantic.rs
index 00d30513181..eb6534cb8ca 100644
--- a/clippy_lints/src/lib.register_pedantic.rs
+++ b/clippy_lints/src/lib.register_pedantic.rs
@@ -63,6 +63,7 @@ store.register_group(true, "clippy::pedantic", Some("clippy_pedantic"), vec![
     LintId::of(methods::IMPLICIT_CLONE),
     LintId::of(methods::INEFFICIENT_TO_STRING),
     LintId::of(methods::MAP_UNWRAP_OR),
+    LintId::of(methods::UNNECESSARY_JOIN),
     LintId::of(misc::FLOAT_CMP),
     LintId::of(misc::USED_UNDERSCORE_BINDING),
     LintId::of(mut_mut::MUT_MUT),
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index c586a0444f0..9d4e1fa3994 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -60,6 +60,7 @@ mod uninit_assumed_init;
 mod unnecessary_filter_map;
 mod unnecessary_fold;
 mod unnecessary_iter_cloned;
+mod unnecessary_join;
 mod unnecessary_lazy_eval;
 mod unnecessary_to_owned;
 mod unwrap_or_else_default;
@@ -2049,6 +2050,35 @@ declare_clippy_lint! {
     "unnecessary calls to `to_owned`-like functions"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for use of `.collect::<Vec<String>>().join("")` on iterators.
+    ///
+    /// ### Why is this bad?
+    /// `.collect::<String>()` is more concise and usually more performant
+    ///
+    /// ### Example
+    /// ```rust
+    /// let vector = vec!["hello",  "world"];
+    /// let output = vector.iter().map(|item| item.to_uppercase()).collect::<Vec<String>>().join("");
+    /// println!("{}", output);
+    /// ```
+    /// The correct use would be:
+    /// ```rust
+    /// let vector = vec!["hello",  "world"];
+    /// let output = vector.iter().map(|item| item.to_uppercase()).collect::<String>();
+    /// println!("{}", output);
+    /// ```
+    /// ### Known problems
+    /// While `.collect::<String>()` is more performant in most cases, there are cases where
+    /// using `.collect::<String>()` over `.collect::<Vec<String>>().join("")`
+    /// will prevent loop unrolling and will result in a negative performance impact.
+    #[clippy::version = "1.61.0"]
+    pub UNNECESSARY_JOIN,
+    pedantic,
+    "using `.collect::<Vec<String>>().join(\"\")` on an iterator"
+}
+
 pub struct Methods {
     avoid_breaking_exported_api: bool,
     msrv: Option<RustcVersion>,
@@ -2134,6 +2164,7 @@ impl_lint_pass!(Methods => [
     MANUAL_SPLIT_ONCE,
     NEEDLESS_SPLITN,
     UNNECESSARY_TO_OWNED,
+    UNNECESSARY_JOIN,
 ]);
 
 /// Extracts a method call name, args, and `Span` of the method name.
@@ -2429,6 +2460,11 @@ fn check_methods<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, msrv: Optio
             ("is_file", []) => filetype_is_file::check(cx, expr, recv),
             ("is_none", []) => check_is_some_is_none(cx, expr, recv, false),
             ("is_some", []) => check_is_some_is_none(cx, expr, recv, true),
+            ("join", [join_arg]) => {
+                if let Some(("collect", _, span)) = method_call(recv) {
+                    unnecessary_join::check(cx, expr, recv, join_arg, span);
+                }
+            },
             ("last", args @ []) | ("skip", args @ [_]) => {
                 if let Some((name2, [recv2, args2 @ ..], _span2)) = method_call(recv) {
                     if let ("cloned", []) = (name2, args2) {
diff --git a/clippy_lints/src/methods/unnecessary_join.rs b/clippy_lints/src/methods/unnecessary_join.rs
new file mode 100644
index 00000000000..973b8a7e6bf
--- /dev/null
+++ b/clippy_lints/src/methods/unnecessary_join.rs
@@ -0,0 +1,41 @@
+use clippy_utils::{diagnostics::span_lint_and_sugg, ty::is_type_diagnostic_item};
+use rustc_ast::ast::LitKind;
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind};
+use rustc_lint::LateContext;
+use rustc_middle::ty::{Ref, Slice};
+use rustc_span::{sym, Span};
+
+use super::UNNECESSARY_JOIN;
+
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx Expr<'tcx>,
+    join_self_arg: &'tcx Expr<'tcx>,
+    join_arg: &'tcx Expr<'tcx>,
+    span: Span,
+) {
+    let applicability = Applicability::MachineApplicable;
+    let collect_output_adjusted_type = cx.typeck_results().expr_ty_adjusted(join_self_arg);
+    if_chain! {
+        // the turbofish for collect is ::<Vec<String>>
+        if let Ref(_, ref_type, _) = collect_output_adjusted_type.kind();
+        if let Slice(slice) = ref_type.kind();
+        if is_type_diagnostic_item(cx, *slice, sym::String);
+        // the argument for join is ""
+        if let ExprKind::Lit(spanned) = &join_arg.kind;
+        if let LitKind::Str(symbol, _) = spanned.node;
+        if symbol.is_empty();
+        then {
+            span_lint_and_sugg(
+                cx,
+                UNNECESSARY_JOIN,
+                span.with_hi(expr.span.hi()),
+                r#"called `.collect<Vec<String>>().join("")` on an iterator"#,
+                "try using",
+                "collect::<String>()".to_owned(),
+                applicability,
+            );
+        }
+    }
+}
diff --git a/tests/ui/unnecessary_join.fixed b/tests/ui/unnecessary_join.fixed
new file mode 100644
index 00000000000..7e12c6ae4be
--- /dev/null
+++ b/tests/ui/unnecessary_join.fixed
@@ -0,0 +1,35 @@
+// run-rustfix
+
+#![warn(clippy::unnecessary_join)]
+
+fn main() {
+    // should be linted
+    let vector = vec!["hello", "world"];
+    let output = vector
+        .iter()
+        .map(|item| item.to_uppercase())
+        .collect::<String>();
+    println!("{}", output);
+
+    // should be linted
+    let vector = vec!["hello", "world"];
+    let output = vector
+        .iter()
+        .map(|item| item.to_uppercase())
+        .collect::<String>();
+    println!("{}", output);
+
+    // should not be linted
+    let vector = vec!["hello", "world"];
+    let output = vector
+        .iter()
+        .map(|item| item.to_uppercase())
+        .collect::<Vec<String>>()
+        .join("\n");
+    println!("{}", output);
+
+    // should not be linted
+    let vector = vec!["hello", "world"];
+    let output = vector.iter().map(|item| item.to_uppercase()).collect::<String>();
+    println!("{}", output);
+}
diff --git a/tests/ui/unnecessary_join.rs b/tests/ui/unnecessary_join.rs
new file mode 100644
index 00000000000..0a21656a755
--- /dev/null
+++ b/tests/ui/unnecessary_join.rs
@@ -0,0 +1,37 @@
+// run-rustfix
+
+#![warn(clippy::unnecessary_join)]
+
+fn main() {
+    // should be linted
+    let vector = vec!["hello", "world"];
+    let output = vector
+        .iter()
+        .map(|item| item.to_uppercase())
+        .collect::<Vec<String>>()
+        .join("");
+    println!("{}", output);
+
+    // should be linted
+    let vector = vec!["hello", "world"];
+    let output = vector
+        .iter()
+        .map(|item| item.to_uppercase())
+        .collect::<Vec<_>>()
+        .join("");
+    println!("{}", output);
+
+    // should not be linted
+    let vector = vec!["hello", "world"];
+    let output = vector
+        .iter()
+        .map(|item| item.to_uppercase())
+        .collect::<Vec<String>>()
+        .join("\n");
+    println!("{}", output);
+
+    // should not be linted
+    let vector = vec!["hello", "world"];
+    let output = vector.iter().map(|item| item.to_uppercase()).collect::<String>();
+    println!("{}", output);
+}
diff --git a/tests/ui/unnecessary_join.stderr b/tests/ui/unnecessary_join.stderr
new file mode 100644
index 00000000000..0b14b143aff
--- /dev/null
+++ b/tests/ui/unnecessary_join.stderr
@@ -0,0 +1,20 @@
+error: called `.collect<Vec<String>>().join("")` on an iterator
+  --> $DIR/unnecessary_join.rs:11:10
+   |
+LL |           .collect::<Vec<String>>()
+   |  __________^
+LL | |         .join("");
+   | |_________________^ help: try using: `collect::<String>()`
+   |
+   = note: `-D clippy::unnecessary-join` implied by `-D warnings`
+
+error: called `.collect<Vec<String>>().join("")` on an iterator
+  --> $DIR/unnecessary_join.rs:20:10
+   |
+LL |           .collect::<Vec<_>>()
+   |  __________^
+LL | |         .join("");
+   | |_________________^ help: try using: `collect::<String>()`
+
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 86872059ed143e93f04130578d8b2d1561d5f3a7 Mon Sep 17 00:00:00 2001
From: Samuel Moelius <35515885+smoelius@users.noreply.github.com>
Date: Thu, 24 Mar 2022 08:57:08 -0400
Subject: Typo

---
 clippy_lints/src/crate_in_macro_def.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/crate_in_macro_def.rs b/clippy_lints/src/crate_in_macro_def.rs
index 9ac6d6d520c..de9c7ee5f20 100644
--- a/clippy_lints/src/crate_in_macro_def.rs
+++ b/clippy_lints/src/crate_in_macro_def.rs
@@ -13,7 +13,7 @@ declare_clippy_lint! {
     /// Checks for use of `crate` as opposed to `$crate` in a macro definition.
     ///
     /// ### Why is this bad?
-    /// `crate` refers to macro call's crate, whereas `$crate` refers to the macro
+    /// `crate` refers to the macro call's crate, whereas `$crate` refers to the macro
     /// definition's crate. Rarely is the former intended. See:
     /// https://doc.rust-lang.org/reference/macros-by-example.html#hygiene
     ///
-- 
cgit 1.4.1-3-g733a5


From 610db04222445e2e25c911dda9a0ae7e30df3cd9 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Fri, 25 Mar 2022 20:39:03 +0000
Subject: Provide suggestion context in map_unit_fn

---
 clippy_lints/src/map_unit_fn.rs            | 23 ++++++++++-------------
 tests/ui/option_map_unit_fn_fixable.fixed  |  5 ++++-
 tests/ui/option_map_unit_fn_fixable.rs     |  5 ++++-
 tests/ui/option_map_unit_fn_fixable.stderr | 12 ++++++++++--
 tests/ui/result_map_unit_fn_fixable.fixed  |  2 ++
 tests/ui/result_map_unit_fn_fixable.rs     |  2 ++
 tests/ui/result_map_unit_fn_fixable.stderr | 10 +++++++++-
 7 files changed, 41 insertions(+), 18 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/map_unit_fn.rs b/clippy_lints/src/map_unit_fn.rs
index 0f6ac478432..f552d5c1afa 100644
--- a/clippy_lints/src/map_unit_fn.rs
+++ b/clippy_lints/src/map_unit_fn.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::source::snippet;
+use clippy_utils::source::{snippet, snippet_with_applicability, snippet_with_context};
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::{iter_input_pats, method_chain_args};
 use if_chain::if_chain;
@@ -217,36 +217,33 @@ fn lint_map_unit_fn(cx: &LateContext<'_>, stmt: &hir::Stmt<'_>, expr: &hir::Expr
     let fn_arg = &map_args[1];
 
     if is_unit_function(cx, fn_arg) {
+        let mut applicability = Applicability::MachineApplicable;
         let msg = suggestion_msg("function", map_type);
         let suggestion = format!(
             "if let {0}({binding}) = {1} {{ {2}({binding}) }}",
             variant,
-            snippet(cx, var_arg.span, "_"),
-            snippet(cx, fn_arg.span, "_"),
+            snippet_with_applicability(cx, var_arg.span, "_", &mut applicability),
+            snippet_with_applicability(cx, fn_arg.span, "_", &mut applicability),
             binding = let_binding_name(cx, var_arg)
         );
 
         span_lint_and_then(cx, lint, expr.span, &msg, |diag| {
-            diag.span_suggestion(stmt.span, "try this", suggestion, Applicability::MachineApplicable);
+            diag.span_suggestion(stmt.span, "try this", suggestion, applicability);
         });
     } else if let Some((binding, closure_expr)) = unit_closure(cx, fn_arg) {
         let msg = suggestion_msg("closure", map_type);
 
         span_lint_and_then(cx, lint, expr.span, &msg, |diag| {
             if let Some(reduced_expr_span) = reduce_unit_expression(cx, closure_expr) {
+                let mut applicability = Applicability::MachineApplicable;
                 let suggestion = format!(
                     "if let {0}({1}) = {2} {{ {3} }}",
                     variant,
-                    snippet(cx, binding.pat.span, "_"),
-                    snippet(cx, var_arg.span, "_"),
-                    snippet(cx, reduced_expr_span, "_")
-                );
-                diag.span_suggestion(
-                    stmt.span,
-                    "try this",
-                    suggestion,
-                    Applicability::MachineApplicable, // snippet
+                    snippet_with_applicability(cx, binding.pat.span, "_", &mut applicability),
+                    snippet_with_applicability(cx, var_arg.span, "_", &mut applicability),
+                    snippet_with_context(cx, reduced_expr_span, var_arg.span.ctxt(), "_", &mut applicability).0,
                 );
+                diag.span_suggestion(stmt.span, "try this", suggestion, applicability);
             } else {
                 let suggestion = format!(
                     "if let {0}({1}) = {2} {{ ... }}",
diff --git a/tests/ui/option_map_unit_fn_fixable.fixed b/tests/ui/option_map_unit_fn_fixable.fixed
index 7d29445e66c..1290bd8efeb 100644
--- a/tests/ui/option_map_unit_fn_fixable.fixed
+++ b/tests/ui/option_map_unit_fn_fixable.fixed
@@ -80,6 +80,9 @@ fn option_map_unit_fn() {
 
     if let Some(ref value) = x.field { do_nothing(value + captured) }
 
-    if let Some(a) = option() { do_nothing(a) }}
+    if let Some(a) = option() { do_nothing(a) }
+
+    if let Some(value) = option() { println!("{:?}", value) }
+}
 
 fn main() {}
diff --git a/tests/ui/option_map_unit_fn_fixable.rs b/tests/ui/option_map_unit_fn_fixable.rs
index b6f834f686f..f3e5b62c65b 100644
--- a/tests/ui/option_map_unit_fn_fixable.rs
+++ b/tests/ui/option_map_unit_fn_fixable.rs
@@ -80,6 +80,9 @@ fn option_map_unit_fn() {
 
     x.field.map(|ref value| { do_nothing(value + captured) });
 
-    option().map(do_nothing);}
+    option().map(do_nothing);
+
+    option().map(|value| println!("{:?}", value));
+}
 
 fn main() {}
diff --git a/tests/ui/option_map_unit_fn_fixable.stderr b/tests/ui/option_map_unit_fn_fixable.stderr
index 8abdbcafb6e..ab2a294a060 100644
--- a/tests/ui/option_map_unit_fn_fixable.stderr
+++ b/tests/ui/option_map_unit_fn_fixable.stderr
@@ -139,10 +139,18 @@ LL |     x.field.map(|ref value| { do_nothing(value + captured) });
 error: called `map(f)` on an `Option` value where `f` is a function that returns the unit type `()`
   --> $DIR/option_map_unit_fn_fixable.rs:83:5
    |
-LL |     option().map(do_nothing);}
+LL |     option().map(do_nothing);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^-
    |     |
    |     help: try this: `if let Some(a) = option() { do_nothing(a) }`
 
-error: aborting due to 18 previous errors
+error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
+  --> $DIR/option_map_unit_fn_fixable.rs:85:5
+   |
+LL |     option().map(|value| println!("{:?}", value));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
+   |     |
+   |     help: try this: `if let Some(value) = option() { println!("{:?}", value) }`
+
+error: aborting due to 19 previous errors
 
diff --git a/tests/ui/result_map_unit_fn_fixable.fixed b/tests/ui/result_map_unit_fn_fixable.fixed
index 631042c616b..14c331f67e7 100644
--- a/tests/ui/result_map_unit_fn_fixable.fixed
+++ b/tests/ui/result_map_unit_fn_fixable.fixed
@@ -75,6 +75,8 @@ fn result_map_unit_fn() {
 
 
     if let Ok(ref value) = x.field { do_nothing(value + captured) }
+
+    if let Ok(value) = x.field { println!("{:?}", value) }
 }
 
 fn main() {}
diff --git a/tests/ui/result_map_unit_fn_fixable.rs b/tests/ui/result_map_unit_fn_fixable.rs
index 679eb232626..8b0fca9ece1 100644
--- a/tests/ui/result_map_unit_fn_fixable.rs
+++ b/tests/ui/result_map_unit_fn_fixable.rs
@@ -75,6 +75,8 @@ fn result_map_unit_fn() {
 
 
     x.field.map(|ref value| { do_nothing(value + captured) });
+
+    x.field.map(|value| println!("{:?}", value));
 }
 
 fn main() {}
diff --git a/tests/ui/result_map_unit_fn_fixable.stderr b/tests/ui/result_map_unit_fn_fixable.stderr
index 4f3a8c6b792..782febd5264 100644
--- a/tests/ui/result_map_unit_fn_fixable.stderr
+++ b/tests/ui/result_map_unit_fn_fixable.stderr
@@ -136,5 +136,13 @@ LL |     x.field.map(|ref value| { do_nothing(value + captured) });
    |     |
    |     help: try this: `if let Ok(ref value) = x.field { do_nothing(value + captured) }`
 
-error: aborting due to 17 previous errors
+error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type `()`
+  --> $DIR/result_map_unit_fn_fixable.rs:79:5
+   |
+LL |     x.field.map(|value| println!("{:?}", value));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
+   |     |
+   |     help: try this: `if let Ok(value) = x.field { println!("{:?}", value) }`
+
+error: aborting due to 18 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 21eae8ceb6ff58b592b00cab58cda62a96aad51a Mon Sep 17 00:00:00 2001
From: Peter Jaszkowiak <p.jaszkow@gmail.com>
Date: Fri, 25 Mar 2022 23:05:38 -0600
Subject: fix `indexing_slicing` with const

- should not fire if indexing with a constant block
- should not fire if indexing within a constant context
(const statement or const block)
---
 clippy_lints/src/indexing_slicing.rs   |  8 ++++++++
 tests/ui/indexing_slicing_index.rs     | 24 ++++++++++++++++++++----
 tests/ui/indexing_slicing_index.stderr | 27 ++++++++++++++++++++-------
 3 files changed, 48 insertions(+), 11 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/indexing_slicing.rs b/clippy_lints/src/indexing_slicing.rs
index 9ead4bb27a5..4ba7477add8 100644
--- a/clippy_lints/src/indexing_slicing.rs
+++ b/clippy_lints/src/indexing_slicing.rs
@@ -96,6 +96,10 @@ declare_lint_pass!(IndexingSlicing => [INDEXING_SLICING, OUT_OF_BOUNDS_INDEXING]
 
 impl<'tcx> LateLintPass<'tcx> for IndexingSlicing {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        if cx.tcx.hir().is_inside_const_context(expr.hir_id) {
+            return;
+        }
+
         if let ExprKind::Index(array, index) = &expr.kind {
             let ty = cx.typeck_results().expr_ty(array).peel_refs();
             if let Some(range) = higher::Range::hir(index) {
@@ -151,6 +155,10 @@ impl<'tcx> LateLintPass<'tcx> for IndexingSlicing {
             } else {
                 // Catchall non-range index, i.e., [n] or [n << m]
                 if let ty::Array(..) = ty.kind() {
+                    // Index is a const block.
+                    if let ExprKind::ConstBlock(..) = index.kind {
+                        return;
+                    }
                     // Index is a constant uint.
                     if let Some(..) = constant(cx, cx.typeck_results(), index) {
                         // Let rustc's `const_err` lint handle constant `usize` indexing on arrays.
diff --git a/tests/ui/indexing_slicing_index.rs b/tests/ui/indexing_slicing_index.rs
index ca8ca53c80c..45a430edcb5 100644
--- a/tests/ui/indexing_slicing_index.rs
+++ b/tests/ui/indexing_slicing_index.rs
@@ -1,18 +1,34 @@
+#![feature(inline_const)]
 #![warn(clippy::indexing_slicing)]
 // We also check the out_of_bounds_indexing lint here, because it lints similar things and
 // we want to avoid false positives.
 #![warn(clippy::out_of_bounds_indexing)]
-#![allow(clippy::no_effect, clippy::unnecessary_operation)]
+#![allow(const_err, clippy::no_effect, clippy::unnecessary_operation)]
+
+const ARR: [i32; 2] = [1, 2];
+const REF: &i32 = &ARR[idx()]; // Ok, should not produce stderr.
+const REF_ERR: &i32 = &ARR[idx4()]; // Ok, let rustc handle const contexts.
+
+const fn idx() -> usize {
+    1
+}
+const fn idx4() -> usize {
+    4
+}
 
 fn main() {
     let x = [1, 2, 3, 4];
     let index: usize = 1;
     x[index];
-    x[4]; // Ok, let rustc's `const_err` lint handle `usize` indexing on arrays.
-    x[1 << 3]; // Ok, let rustc's `const_err` lint handle `usize` indexing on arrays.
+    x[4]; // Ok, let rustc's `unconditional_panic` lint handle `usize` indexing on arrays.
+    x[1 << 3]; // Ok, let rustc's `unconditional_panic` lint handle `usize` indexing on arrays.
 
     x[0]; // Ok, should not produce stderr.
     x[3]; // Ok, should not produce stderr.
+    x[const { idx() }]; // Ok, should not produce stderr.
+    x[const { idx4() }]; // Ok, let rustc's `unconditional_panic` lint handle `usize` indexing on arrays.
+    const { &ARR[idx()] }; // Ok, should not produce stderr.
+    const { &ARR[idx4()] }; // Ok, let rustc handle const contexts.
 
     let y = &x;
     y[0]; // Ok, referencing shouldn't affect this lint. See the issue 6021
@@ -25,7 +41,7 @@ fn main() {
 
     const N: usize = 15; // Out of bounds
     const M: usize = 3; // In bounds
-    x[N]; // Ok, let rustc's `const_err` lint handle `usize` indexing on arrays.
+    x[N]; // Ok, let rustc's `unconditional_panic` lint handle `usize` indexing on arrays.
     x[M]; // Ok, should not produce stderr.
     v[N];
     v[M];
diff --git a/tests/ui/indexing_slicing_index.stderr b/tests/ui/indexing_slicing_index.stderr
index 76ecec33484..83a36f407d5 100644
--- a/tests/ui/indexing_slicing_index.stderr
+++ b/tests/ui/indexing_slicing_index.stderr
@@ -1,5 +1,17 @@
+error[E0080]: evaluation of `main::{constant#3}::<&i32>` failed
+  --> $DIR/indexing_slicing_index.rs:31:14
+   |
+LL |     const { &ARR[idx4()] }; // Ok, let rustc handle const contexts.
+   |              ^^^^^^^^^^^ index out of bounds: the length is 2 but the index is 4
+
+error[E0080]: erroneous constant used
+  --> $DIR/indexing_slicing_index.rs:31:5
+   |
+LL |     const { &ARR[idx4()] }; // Ok, let rustc handle const contexts.
+   |     ^^^^^^^^^^^^^^^^^^^^^^ referenced constant has errors
+
 error: indexing may panic
-  --> $DIR/indexing_slicing_index.rs:10:5
+  --> $DIR/indexing_slicing_index.rs:22:5
    |
 LL |     x[index];
    |     ^^^^^^^^
@@ -8,7 +20,7 @@ LL |     x[index];
    = help: consider using `.get(n)` or `.get_mut(n)` instead
 
 error: indexing may panic
-  --> $DIR/indexing_slicing_index.rs:22:5
+  --> $DIR/indexing_slicing_index.rs:38:5
    |
 LL |     v[0];
    |     ^^^^
@@ -16,7 +28,7 @@ LL |     v[0];
    = help: consider using `.get(n)` or `.get_mut(n)` instead
 
 error: indexing may panic
-  --> $DIR/indexing_slicing_index.rs:23:5
+  --> $DIR/indexing_slicing_index.rs:39:5
    |
 LL |     v[10];
    |     ^^^^^
@@ -24,7 +36,7 @@ LL |     v[10];
    = help: consider using `.get(n)` or `.get_mut(n)` instead
 
 error: indexing may panic
-  --> $DIR/indexing_slicing_index.rs:24:5
+  --> $DIR/indexing_slicing_index.rs:40:5
    |
 LL |     v[1 << 3];
    |     ^^^^^^^^^
@@ -32,7 +44,7 @@ LL |     v[1 << 3];
    = help: consider using `.get(n)` or `.get_mut(n)` instead
 
 error: indexing may panic
-  --> $DIR/indexing_slicing_index.rs:30:5
+  --> $DIR/indexing_slicing_index.rs:46:5
    |
 LL |     v[N];
    |     ^^^^
@@ -40,12 +52,13 @@ LL |     v[N];
    = help: consider using `.get(n)` or `.get_mut(n)` instead
 
 error: indexing may panic
-  --> $DIR/indexing_slicing_index.rs:31:5
+  --> $DIR/indexing_slicing_index.rs:47:5
    |
 LL |     v[M];
    |     ^^^^
    |
    = help: consider using `.get(n)` or `.get_mut(n)` instead
 
-error: aborting due to 6 previous errors
+error: aborting due to 8 previous errors
 
+For more information about this error, try `rustc --explain E0080`.
-- 
cgit 1.4.1-3-g733a5


From c687f6575f106b7cd7546b63b7692bad4dee4c5b Mon Sep 17 00:00:00 2001
From: Caio <c410.f3r@gmail.com>
Date: Sat, 26 Mar 2022 15:39:21 -0300
Subject: Do not fire `panic` in a constant environment

---
 clippy_lints/src/panic_unimplemented.rs |  4 ++++
 tests/ui/panicking_macros.rs            | 17 ++++++++++++++++-
 tests/ui/panicking_macros.stderr        | 32 ++++++++++++++++----------------
 3 files changed, 36 insertions(+), 17 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/panic_unimplemented.rs b/clippy_lints/src/panic_unimplemented.rs
index 6ef6b9a20aa..2f3007658ea 100644
--- a/clippy_lints/src/panic_unimplemented.rs
+++ b/clippy_lints/src/panic_unimplemented.rs
@@ -78,6 +78,10 @@ impl<'tcx> LateLintPass<'tcx> for PanicUnimplemented {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         let Some(macro_call) = root_macro_call_first_node(cx, expr) else { return };
         if is_panic(cx, macro_call.def_id) {
+            if cx.tcx.hir().is_inside_const_context(expr.hir_id) {
+                return;
+            }
+
             span_lint(
                 cx,
                 PANIC,
diff --git a/tests/ui/panicking_macros.rs b/tests/ui/panicking_macros.rs
index 73380646462..841fc289b4c 100644
--- a/tests/ui/panicking_macros.rs
+++ b/tests/ui/panicking_macros.rs
@@ -1,8 +1,23 @@
+#![allow(clippy::assertions_on_constants, clippy::eq_op,)]
+#![feature(inline_const)]
 #![warn(clippy::unimplemented, clippy::unreachable, clippy::todo, clippy::panic)]
-#![allow(clippy::assertions_on_constants, clippy::eq_op)]
 
 extern crate core;
 
+const _: () = {
+    if 1 == 0 {
+        panic!("A balanced diet means a cupcake in each hand");
+    }
+};
+
+fn inline_const() {
+    let _ = const {
+        if 1 == 0 {
+            panic!("When nothing goes right, go left")
+        }
+    };
+}
+
 fn panic() {
     let a = 2;
     panic!();
diff --git a/tests/ui/panicking_macros.stderr b/tests/ui/panicking_macros.stderr
index bfd1c7a3801..4ceb6d1440f 100644
--- a/tests/ui/panicking_macros.stderr
+++ b/tests/ui/panicking_macros.stderr
@@ -1,5 +1,5 @@
 error: `panic` should not be present in production code
-  --> $DIR/panicking_macros.rs:8:5
+  --> $DIR/panicking_macros.rs:23:5
    |
 LL |     panic!();
    |     ^^^^^^^^
@@ -7,19 +7,19 @@ LL |     panic!();
    = note: `-D clippy::panic` implied by `-D warnings`
 
 error: `panic` should not be present in production code
-  --> $DIR/panicking_macros.rs:9:5
+  --> $DIR/panicking_macros.rs:24:5
    |
 LL |     panic!("message");
    |     ^^^^^^^^^^^^^^^^^
 
 error: `panic` should not be present in production code
-  --> $DIR/panicking_macros.rs:10:5
+  --> $DIR/panicking_macros.rs:25:5
    |
 LL |     panic!("{} {}", "panic with", "multiple arguments");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: `todo` should not be present in production code
-  --> $DIR/panicking_macros.rs:16:5
+  --> $DIR/panicking_macros.rs:31:5
    |
 LL |     todo!();
    |     ^^^^^^^
@@ -27,19 +27,19 @@ LL |     todo!();
    = note: `-D clippy::todo` implied by `-D warnings`
 
 error: `todo` should not be present in production code
-  --> $DIR/panicking_macros.rs:17:5
+  --> $DIR/panicking_macros.rs:32:5
    |
 LL |     todo!("message");
    |     ^^^^^^^^^^^^^^^^
 
 error: `todo` should not be present in production code
-  --> $DIR/panicking_macros.rs:18:5
+  --> $DIR/panicking_macros.rs:33:5
    |
 LL |     todo!("{} {}", "panic with", "multiple arguments");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: `unimplemented` should not be present in production code
-  --> $DIR/panicking_macros.rs:24:5
+  --> $DIR/panicking_macros.rs:39:5
    |
 LL |     unimplemented!();
    |     ^^^^^^^^^^^^^^^^
@@ -47,19 +47,19 @@ LL |     unimplemented!();
    = note: `-D clippy::unimplemented` implied by `-D warnings`
 
 error: `unimplemented` should not be present in production code
-  --> $DIR/panicking_macros.rs:25:5
+  --> $DIR/panicking_macros.rs:40:5
    |
 LL |     unimplemented!("message");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: `unimplemented` should not be present in production code
-  --> $DIR/panicking_macros.rs:26:5
+  --> $DIR/panicking_macros.rs:41:5
    |
 LL |     unimplemented!("{} {}", "panic with", "multiple arguments");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: usage of the `unreachable!` macro
-  --> $DIR/panicking_macros.rs:32:5
+  --> $DIR/panicking_macros.rs:47:5
    |
 LL |     unreachable!();
    |     ^^^^^^^^^^^^^^
@@ -67,37 +67,37 @@ LL |     unreachable!();
    = note: `-D clippy::unreachable` implied by `-D warnings`
 
 error: usage of the `unreachable!` macro
-  --> $DIR/panicking_macros.rs:33:5
+  --> $DIR/panicking_macros.rs:48:5
    |
 LL |     unreachable!("message");
    |     ^^^^^^^^^^^^^^^^^^^^^^^
 
 error: usage of the `unreachable!` macro
-  --> $DIR/panicking_macros.rs:34:5
+  --> $DIR/panicking_macros.rs:49:5
    |
 LL |     unreachable!("{} {}", "panic with", "multiple arguments");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: `panic` should not be present in production code
-  --> $DIR/panicking_macros.rs:40:5
+  --> $DIR/panicking_macros.rs:55:5
    |
 LL |     panic!();
    |     ^^^^^^^^
 
 error: `todo` should not be present in production code
-  --> $DIR/panicking_macros.rs:41:5
+  --> $DIR/panicking_macros.rs:56:5
    |
 LL |     todo!();
    |     ^^^^^^^
 
 error: `unimplemented` should not be present in production code
-  --> $DIR/panicking_macros.rs:42:5
+  --> $DIR/panicking_macros.rs:57:5
    |
 LL |     unimplemented!();
    |     ^^^^^^^^^^^^^^^^
 
 error: usage of the `unreachable!` macro
-  --> $DIR/panicking_macros.rs:43:5
+  --> $DIR/panicking_macros.rs:58:5
    |
 LL |     unreachable!();
    |     ^^^^^^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From 52b563b28361d49eb455725f319500f7afa362d9 Mon Sep 17 00:00:00 2001
From: Tianyi Song <42670338+tysg@users.noreply.github.com>
Date: Sun, 27 Mar 2022 21:48:15 +0800
Subject: Emit lint when rhs is negative

---
 clippy_lints/src/identity_op.rs |  6 +++---
 tests/ui/identity_op.rs         |  3 +++
 tests/ui/identity_op.stderr     | 16 ++++++++++++++--
 3 files changed, 20 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/identity_op.rs b/clippy_lints/src/identity_op.rs
index 0b1ab4dfa5a..4d6bef89bea 100644
--- a/clippy_lints/src/identity_op.rs
+++ b/clippy_lints/src/identity_op.rs
@@ -54,7 +54,7 @@ impl<'tcx> LateLintPass<'tcx> for IdentityOp {
                     check(cx, left, -1, e.span, right.span);
                     check(cx, right, -1, e.span, left.span);
                 },
-                BinOpKind::Rem => check_modulo(cx, left, right, e.span, left.span),
+                BinOpKind::Rem => check_remainder(cx, left, right, e.span, left.span),
                 _ => (),
             }
         }
@@ -71,11 +71,11 @@ fn is_allowed(cx: &LateContext<'_>, cmp: BinOp, left: &Expr<'_>, right: &Expr<'_
             && constant_simple(cx, cx.typeck_results(), left) == Some(Constant::Int(1)))
 }
 
-fn check_modulo(cx: &LateContext<'_>, left: &Expr<'_>, right: &Expr<'_>, span: Span, arg: Span) {
+fn check_remainder(cx: &LateContext<'_>, left: &Expr<'_>, right: &Expr<'_>, span: Span, arg: Span) {
     let lhs_const = constant_full_int(cx, cx.typeck_results(), left);
     let rhs_const = constant_full_int(cx, cx.typeck_results(), right);
     if match (lhs_const, rhs_const) {
-        (Some(FullInt::S(lv)), Some(FullInt::S(rv))) => lv.abs() < rv,
+        (Some(FullInt::S(lv)), Some(FullInt::S(rv))) => lv.abs() < rv.abs(),
         (Some(FullInt::U(lv)), Some(FullInt::U(rv))) => lv < rv,
         _ => return,
     } {
diff --git a/tests/ui/identity_op.rs b/tests/ui/identity_op.rs
index 5e120947646..edc3fe1aec1 100644
--- a/tests/ui/identity_op.rs
+++ b/tests/ui/identity_op.rs
@@ -69,7 +69,10 @@ fn main() {
 
     2 % 3;
     -2 % 3;
+    2 % -3 + x;
+    -2 % -3 + x;
     x + 1 % 3;
     (x + 1) % 3; // no error
     4 % 3; // no error
+    4 % -3; // no error
 }
diff --git a/tests/ui/identity_op.stderr b/tests/ui/identity_op.stderr
index cb9757d1158..706f01a3dd6 100644
--- a/tests/ui/identity_op.stderr
+++ b/tests/ui/identity_op.stderr
@@ -90,11 +90,23 @@ error: the operation is ineffective. Consider reducing it to `-2`
 LL |     -2 % 3;
    |     ^^^^^^
 
+error: the operation is ineffective. Consider reducing it to `2`
+  --> $DIR/identity_op.rs:72:5
+   |
+LL |     2 % -3 + x;
+   |     ^^^^^^
+
+error: the operation is ineffective. Consider reducing it to `-2`
+  --> $DIR/identity_op.rs:73:5
+   |
+LL |     -2 % -3 + x;
+   |     ^^^^^^^
+
 error: the operation is ineffective. Consider reducing it to `1`
-  --> $DIR/identity_op.rs:72:9
+  --> $DIR/identity_op.rs:74:9
    |
 LL |     x + 1 % 3;
    |         ^^^^^
 
-error: aborting due to 16 previous errors
+error: aborting due to 18 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From ec851b870b59848bdbf531928a7cf38225d3a12e Mon Sep 17 00:00:00 2001
From: Jaic1 <506933131@qq.com>
Date: Mon, 28 Mar 2022 12:09:01 +0800
Subject: First submit

---
 clippy_lints/src/casts/unnecessary_cast.rs | 14 +++++++++++++-
 tests/ui/unnecessary_cast.rs               |  6 ++++++
 tests/ui/unnecessary_cast_fixable.fixed    |  5 +++++
 tests/ui/unnecessary_cast_fixable.rs       |  5 +++++
 4 files changed, 29 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/unnecessary_cast.rs b/clippy_lints/src/casts/unnecessary_cast.rs
index 470c8c7ea26..af56ec11ef8 100644
--- a/clippy_lints/src/casts/unnecessary_cast.rs
+++ b/clippy_lints/src/casts/unnecessary_cast.rs
@@ -4,7 +4,8 @@ use clippy_utils::source::snippet_opt;
 use if_chain::if_chain;
 use rustc_ast::{LitFloatType, LitIntType, LitKind};
 use rustc_errors::Applicability;
-use rustc_hir::{Expr, ExprKind, Lit, UnOp};
+use rustc_hir::def::Res;
+use rustc_hir::{Expr, ExprKind, Lit, QPath, TyKind, UnOp};
 use rustc_lint::{LateContext, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::{self, FloatTy, InferTy, Ty};
@@ -18,6 +19,17 @@ pub(super) fn check(
     cast_from: Ty<'_>,
     cast_to: Ty<'_>,
 ) -> bool {
+    // skip non-primitive type cast
+    if_chain! {
+        if let ExprKind::Cast(_, cast_to) = expr.kind;
+        if let TyKind::Path(QPath::Resolved(_, path)) = &cast_to.kind;
+        if let Res::PrimTy(_) = path.res;
+        then {}
+        else {
+            return false
+        }
+    }
+
     if let Some(lit) = get_numeric_literal(cast_expr) {
         let literal_str = snippet_opt(cx, cast_expr.span).unwrap_or_default();
 
diff --git a/tests/ui/unnecessary_cast.rs b/tests/ui/unnecessary_cast.rs
index b77c19f2ba5..62c3e963686 100644
--- a/tests/ui/unnecessary_cast.rs
+++ b/tests/ui/unnecessary_cast.rs
@@ -30,4 +30,10 @@ fn main() {
 
     // do not lint cast to cfg-dependant type
     1 as std::os::raw::c_char;
+
+    // do not lint cast to alias type
+    1 as I32Alias;
+    &1 as &I32Alias;
 }
+
+type I32Alias = i32;
diff --git a/tests/ui/unnecessary_cast_fixable.fixed b/tests/ui/unnecessary_cast_fixable.fixed
index 3332f49c80c..36800c5340d 100644
--- a/tests/ui/unnecessary_cast_fixable.fixed
+++ b/tests/ui/unnecessary_cast_fixable.fixed
@@ -42,4 +42,9 @@ fn main() {
 
     let _ = -1_i32;
     let _ = -1.0_f32;
+
+    let _ = 1 as I32Alias;
+    let _ = &1 as &I32Alias;
 }
+
+type I32Alias = i32;
diff --git a/tests/ui/unnecessary_cast_fixable.rs b/tests/ui/unnecessary_cast_fixable.rs
index ec01e938779..d4b6bb952ab 100644
--- a/tests/ui/unnecessary_cast_fixable.rs
+++ b/tests/ui/unnecessary_cast_fixable.rs
@@ -42,4 +42,9 @@ fn main() {
 
     let _ = -1 as i32;
     let _ = -1.0 as f32;
+
+    let _ = 1 as I32Alias;
+    let _ = &1 as &I32Alias;
 }
+
+type I32Alias = i32;
-- 
cgit 1.4.1-3-g733a5


From cb307bbfcd123d3bae8f210f2b51eebe68525c27 Mon Sep 17 00:00:00 2001
From: "Samuel E. Moelius III" <sam@moeli.us>
Date: Mon, 28 Mar 2022 04:32:31 -0400
Subject: Address review comments

---
 clippy_lints/src/crate_in_macro_def.rs   | 60 +++++++++++++++++++++++---------
 clippy_lints/src/utils/conf.rs           |  2 +-
 tests/ui/crate_in_macro_def.fixed        | 31 +++++++++++++++--
 tests/ui/crate_in_macro_def.rs           | 31 +++++++++++++++--
 tests/ui/crate_in_macro_def_allow.rs     | 19 ----------
 tests/ui/crate_in_macro_def_allow.stderr |  0
 6 files changed, 102 insertions(+), 41 deletions(-)
 delete mode 100644 tests/ui/crate_in_macro_def_allow.rs
 delete mode 100644 tests/ui/crate_in_macro_def_allow.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/crate_in_macro_def.rs b/clippy_lints/src/crate_in_macro_def.rs
index de9c7ee5f20..21c65f9d6f0 100644
--- a/clippy_lints/src/crate_in_macro_def.rs
+++ b/clippy_lints/src/crate_in_macro_def.rs
@@ -1,24 +1,24 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use rustc_ast::ast::MacroDef;
-use rustc_ast::node_id::NodeId;
+use rustc_ast::ast::{AttrKind, Attribute, Item, ItemKind};
 use rustc_ast::token::{Token, TokenKind};
 use rustc_ast::tokenstream::{TokenStream, TokenTree};
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::Span;
+use rustc_span::{symbol::sym, Span};
 
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for use of `crate` as opposed to `$crate` in a macro definition.
     ///
     /// ### Why is this bad?
-    /// `crate` refers to the macro call's crate, whereas `$crate` refers to the macro
-    /// definition's crate. Rarely is the former intended. See:
+    /// `crate` refers to the macro call's crate, whereas `$crate` refers to the macro definition's
+    /// crate. Rarely is the former intended. See:
     /// https://doc.rust-lang.org/reference/macros-by-example.html#hygiene
     ///
     /// ### Example
     /// ```rust
+    /// #[macro_export]
     /// macro_rules! print_message {
     ///     () => {
     ///         println!("{}", crate::MESSAGE);
@@ -28,6 +28,7 @@ declare_clippy_lint! {
     /// ```
     /// Use instead:
     /// ```rust
+    /// #[macro_export]
     /// macro_rules! print_message {
     ///     () => {
     ///         println!("{}", $crate::MESSAGE);
@@ -35,6 +36,13 @@ declare_clippy_lint! {
     /// }
     /// pub const MESSAGE: &str = "Hello!";
     /// ```
+    ///
+    /// Note that if the use of `crate` is intentional, an `allow` attribute can be applied to the
+    /// macro definition, e.g.:
+    /// ```rust,ignore
+    /// #[allow(clippy::crate_in_macro_def)]
+    /// macro_rules! ok { ... crate::foo ... }
+    /// ```
     #[clippy::version = "1.61.0"]
     pub CRATE_IN_MACRO_DEF,
     correctness,
@@ -43,18 +51,36 @@ declare_clippy_lint! {
 declare_lint_pass!(CrateInMacroDef => [CRATE_IN_MACRO_DEF]);
 
 impl EarlyLintPass for CrateInMacroDef {
-    fn check_mac_def(&mut self, cx: &EarlyContext<'_>, macro_def: &MacroDef, _: NodeId) {
-        let tts = macro_def.body.inner_tokens();
-        if let Some(span) = contains_unhygienic_crate_reference(&tts) {
-            span_lint_and_sugg(
-                cx,
-                CRATE_IN_MACRO_DEF,
-                span,
-                "reference to the macro call's crate, which is rarely intended",
-                "if reference to the macro definition's crate is intended, use",
-                String::from("$crate"),
-                Applicability::MachineApplicable,
-            );
+    fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {
+        if_chain! {
+            if item.attrs.iter().any(is_macro_export);
+            if let ItemKind::MacroDef(macro_def) = &item.kind;
+            let tts = macro_def.body.inner_tokens();
+            if let Some(span) = contains_unhygienic_crate_reference(&tts);
+            then {
+                span_lint_and_sugg(
+                    cx,
+                    CRATE_IN_MACRO_DEF,
+                    span,
+                    "reference to the macro call's crate, which is rarely intended",
+                    "if reference to the macro definition's crate is intended, use",
+                    String::from("$crate"),
+                    Applicability::MachineApplicable,
+                );
+            }
+        }
+    }
+}
+
+fn is_macro_export(attr: &Attribute) -> bool {
+    if_chain! {
+        if let AttrKind::Normal(attr_item, _) = &attr.kind;
+        if let [segment] = attr_item.path.segments.as_slice();
+        if segment.ident.name == sym::macro_export;
+        then {
+            true
+        } else {
+            false
         }
     }
 }
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index b1e474f8056..680b2eb1da7 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -123,7 +123,7 @@ macro_rules! define_Conf {
 
         #[cfg(feature = "internal")]
         pub mod metadata {
-            use $crate::utils::internal_lints::metadata_collector::ClippyConfiguration;
+            use crate::utils::internal_lints::metadata_collector::ClippyConfiguration;
 
             macro_rules! wrap_option {
                 () => (None);
diff --git a/tests/ui/crate_in_macro_def.fixed b/tests/ui/crate_in_macro_def.fixed
index 77b43f43260..9fc594be311 100644
--- a/tests/ui/crate_in_macro_def.fixed
+++ b/tests/ui/crate_in_macro_def.fixed
@@ -1,8 +1,8 @@
 // run-rustfix
 #![warn(clippy::crate_in_macro_def)]
 
-#[macro_use]
 mod hygienic {
+    #[macro_export]
     macro_rules! print_message_hygienic {
         () => {
             println!("{}", $crate::hygienic::MESSAGE);
@@ -12,8 +12,8 @@ mod hygienic {
     pub const MESSAGE: &str = "Hello!";
 }
 
-#[macro_use]
 mod unhygienic {
+    #[macro_export]
     macro_rules! print_message_unhygienic {
         () => {
             println!("{}", $crate::unhygienic::MESSAGE);
@@ -23,7 +23,34 @@ mod unhygienic {
     pub const MESSAGE: &str = "Hello!";
 }
 
+mod unhygienic_intentionally {
+    // For cases where the use of `crate` is intentional, applying `allow` to the macro definition
+    // should suppress the lint.
+    #[allow(clippy::crate_in_macro_def)]
+    #[macro_export]
+    macro_rules! print_message_unhygienic_intentionally {
+        () => {
+            println!("{}", crate::CALLER_PROVIDED_MESSAGE);
+        };
+    }
+}
+
+#[macro_use]
+mod not_exported {
+    macro_rules! print_message_not_exported {
+        () => {
+            println!("{}", crate::not_exported::MESSAGE);
+        };
+    }
+
+    pub const MESSAGE: &str = "Hello!";
+}
+
 fn main() {
     print_message_hygienic!();
     print_message_unhygienic!();
+    print_message_unhygienic_intentionally!();
+    print_message_not_exported!();
 }
+
+pub const CALLER_PROVIDED_MESSAGE: &str = "Hello!";
diff --git a/tests/ui/crate_in_macro_def.rs b/tests/ui/crate_in_macro_def.rs
index d72d4c4009c..ac456108e4a 100644
--- a/tests/ui/crate_in_macro_def.rs
+++ b/tests/ui/crate_in_macro_def.rs
@@ -1,8 +1,8 @@
 // run-rustfix
 #![warn(clippy::crate_in_macro_def)]
 
-#[macro_use]
 mod hygienic {
+    #[macro_export]
     macro_rules! print_message_hygienic {
         () => {
             println!("{}", $crate::hygienic::MESSAGE);
@@ -12,8 +12,8 @@ mod hygienic {
     pub const MESSAGE: &str = "Hello!";
 }
 
-#[macro_use]
 mod unhygienic {
+    #[macro_export]
     macro_rules! print_message_unhygienic {
         () => {
             println!("{}", crate::unhygienic::MESSAGE);
@@ -23,7 +23,34 @@ mod unhygienic {
     pub const MESSAGE: &str = "Hello!";
 }
 
+mod unhygienic_intentionally {
+    // For cases where the use of `crate` is intentional, applying `allow` to the macro definition
+    // should suppress the lint.
+    #[allow(clippy::crate_in_macro_def)]
+    #[macro_export]
+    macro_rules! print_message_unhygienic_intentionally {
+        () => {
+            println!("{}", crate::CALLER_PROVIDED_MESSAGE);
+        };
+    }
+}
+
+#[macro_use]
+mod not_exported {
+    macro_rules! print_message_not_exported {
+        () => {
+            println!("{}", crate::not_exported::MESSAGE);
+        };
+    }
+
+    pub const MESSAGE: &str = "Hello!";
+}
+
 fn main() {
     print_message_hygienic!();
     print_message_unhygienic!();
+    print_message_unhygienic_intentionally!();
+    print_message_not_exported!();
 }
+
+pub const CALLER_PROVIDED_MESSAGE: &str = "Hello!";
diff --git a/tests/ui/crate_in_macro_def_allow.rs b/tests/ui/crate_in_macro_def_allow.rs
deleted file mode 100644
index d6b30fd9615..00000000000
--- a/tests/ui/crate_in_macro_def_allow.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-#![warn(clippy::crate_in_macro_def)]
-
-#[macro_use]
-mod intentional {
-    // For cases where use of `crate` is intentional, applying `allow` to the macro definition
-    // should suppress the lint.
-    #[allow(clippy::crate_in_macro_def)]
-    macro_rules! print_message {
-        () => {
-            println!("{}", crate::CALLER_PROVIDED_MESSAGE);
-        };
-    }
-}
-
-fn main() {
-    print_message!();
-}
-
-pub const CALLER_PROVIDED_MESSAGE: &str = "Hello!";
diff --git a/tests/ui/crate_in_macro_def_allow.stderr b/tests/ui/crate_in_macro_def_allow.stderr
deleted file mode 100644
index e69de29bb2d..00000000000
-- 
cgit 1.4.1-3-g733a5


From 448a26d6960d9a4902db59a57b61ed0586933dfd Mon Sep 17 00:00:00 2001
From: J-ZhengLi <lizheng135@huawei.com>
Date: Tue, 29 Mar 2022 15:23:19 +0800
Subject: improve parent expr check

---
 clippy_lints/src/matches/needless_match.rs | 20 ++++++++------------
 tests/ui/needless_match.fixed              | 12 ++++++++++++
 tests/ui/needless_match.rs                 | 12 ++++++++++++
 3 files changed, 32 insertions(+), 12 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/needless_match.rs b/clippy_lints/src/matches/needless_match.rs
index 2830ae1f61d..3703488632b 100644
--- a/clippy_lints/src/matches/needless_match.rs
+++ b/clippy_lints/src/matches/needless_match.rs
@@ -14,7 +14,7 @@ use rustc_span::sym;
 use rustc_typeck::hir_ty_to_ty;
 
 pub(crate) fn check_match(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>], expr: &Expr<'_>) {
-    if arms.len() > 1 && !is_coercion_casting(cx, ex, expr) && check_all_arms(cx, ex, arms) {
+    if arms.len() > 1 && expr_ty_matches_p_ty(cx, ex, expr) && check_all_arms(cx, ex, arms) {
         let mut applicability = Applicability::MachineApplicable;
         span_lint_and_sugg(
             cx,
@@ -49,7 +49,7 @@ pub(crate) fn check_match(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>],
 /// ```
 pub(crate) fn check(cx: &LateContext<'_>, ex: &Expr<'_>) {
     if let Some(ref if_let) = higher::IfLet::hir(cx, ex) {
-        if !is_else_clause(cx.tcx, ex) && !is_coercion_casting(cx, if_let.let_expr, ex) && check_if_let(cx, if_let) {
+        if !is_else_clause(cx.tcx, ex) && expr_ty_matches_p_ty(cx, if_let.let_expr, ex) && check_if_let(cx, if_let) {
             let mut applicability = Applicability::MachineApplicable;
             span_lint_and_sugg(
                 cx,
@@ -119,39 +119,35 @@ fn strip_return<'hir>(expr: &'hir Expr<'hir>) -> &'hir Expr<'hir> {
 
 /// Manually check for coercion casting by checking if the type of the match operand or let expr
 /// differs with the assigned local variable or the funtion return type.
-fn is_coercion_casting(cx: &LateContext<'_>, match_expr: &Expr<'_>, expr: &Expr<'_>) -> bool {
-    if let Some(p_node) = get_parent_node(cx.tcx, expr.hir_id) {
+fn expr_ty_matches_p_ty(cx: &LateContext<'_>, expr: &Expr<'_>, p_expr: &Expr<'_>) -> bool {
+    if let Some(p_node) = get_parent_node(cx.tcx, p_expr.hir_id) {
         match p_node {
             // Compare match_expr ty with local in `let local = match match_expr {..}`
             Node::Local(local) => {
                 let results = cx.typeck_results();
-                return !same_type_and_consts(results.node_type(local.hir_id), results.expr_ty(match_expr));
+                return same_type_and_consts(results.node_type(local.hir_id), results.expr_ty(expr));
             },
             // compare match_expr ty with RetTy in `fn foo() -> RetTy`
             Node::Item(..) => {
                 if let Some(fn_decl) = p_node.fn_decl() {
                     if let FnRetTy::Return(ret_ty) = fn_decl.output {
-                        return !same_type_and_consts(
-                            hir_ty_to_ty(cx.tcx, ret_ty),
-                            cx.typeck_results().expr_ty(match_expr),
-                        );
+                        return same_type_and_consts(hir_ty_to_ty(cx.tcx, ret_ty), cx.typeck_results().expr_ty(expr));
                     }
                 }
             },
             // check the parent expr for this whole block `{ match match_expr {..} }`
             Node::Block(block) => {
                 if let Some(block_parent_expr) = get_parent_expr_for_hir(cx, block.hir_id) {
-                    return is_coercion_casting(cx, match_expr, block_parent_expr);
+                    return expr_ty_matches_p_ty(cx, expr, block_parent_expr);
                 }
             },
             // recursively call on `if xxx {..}` etc.
             Node::Expr(p_expr) => {
-                return is_coercion_casting(cx, match_expr, p_expr);
+                return expr_ty_matches_p_ty(cx, expr, p_expr);
             },
             _ => {},
         }
     }
-
     false
 }
 
diff --git a/tests/ui/needless_match.fixed b/tests/ui/needless_match.fixed
index d55dd589a54..9ccccaa1725 100644
--- a/tests/ui/needless_match.fixed
+++ b/tests/ui/needless_match.fixed
@@ -182,4 +182,16 @@ mod issue8551 {
     }
 }
 
+trait Tr {
+    fn as_mut(&mut self) -> Result<&mut i32, &mut i32>;
+}
+impl Tr for Result<i32, i32> {
+    fn as_mut(&mut self) -> Result<&mut i32, &mut i32> {
+        match self {
+            Ok(x) => Ok(x),
+            Err(e) => Err(e),
+        }
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/needless_match.rs b/tests/ui/needless_match.rs
index f3c7ee01a47..d210ecff7f1 100644
--- a/tests/ui/needless_match.rs
+++ b/tests/ui/needless_match.rs
@@ -219,4 +219,16 @@ mod issue8551 {
     }
 }
 
+trait Tr {
+    fn as_mut(&mut self) -> Result<&mut i32, &mut i32>;
+}
+impl Tr for Result<i32, i32> {
+    fn as_mut(&mut self) -> Result<&mut i32, &mut i32> {
+        match self {
+            Ok(x) => Ok(x),
+            Err(e) => Err(e),
+        }
+    }
+}
+
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From c22b7b8814e459d985c8ab337d933a4ae4feecea Mon Sep 17 00:00:00 2001
From: Takayuki Nakata <f.seasons017@gmail.com>
Date: Tue, 29 Mar 2022 21:51:37 +0900
Subject: Fix ICE for `iter_overeager_cloned`

---
 clippy_lints/src/methods/iter_overeager_cloned.rs | 16 ++++++++++++----
 tests/ui/iter_overeager_cloned.fixed              |  6 ++++++
 tests/ui/iter_overeager_cloned.rs                 |  6 ++++++
 tests/ui/iter_overeager_cloned.stderr             | 14 +++++++-------
 4 files changed, 31 insertions(+), 11 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/iter_overeager_cloned.rs b/clippy_lints/src/methods/iter_overeager_cloned.rs
index b93f1399eae..54c9ca435a4 100644
--- a/clippy_lints/src/methods/iter_overeager_cloned.rs
+++ b/clippy_lints/src/methods/iter_overeager_cloned.rs
@@ -1,11 +1,12 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet;
-use clippy_utils::ty::{get_iterator_item_ty, is_copy};
+use clippy_utils::ty::{get_iterator_item_ty, implements_trait, is_copy};
 use itertools::Itertools;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
 use rustc_middle::ty;
+use rustc_span::sym;
 use std::ops::Not;
 
 use super::ITER_OVEREAGER_CLONED;
@@ -20,9 +21,16 @@ pub(super) fn check<'tcx>(
     map_arg: &[hir::Expr<'_>],
 ) {
     // Check if it's iterator and get type associated with `Item`.
-    let inner_ty = match get_iterator_item_ty(cx, cx.typeck_results().expr_ty_adjusted(recv)) {
-        Some(ty) => ty,
-        _ => return,
+    let inner_ty = if_chain! {
+        if let Some(iterator_trait_id) = cx.tcx.get_diagnostic_item(sym::Iterator);
+        let recv_ty = cx.typeck_results().expr_ty(recv);
+        if implements_trait(cx, recv_ty, iterator_trait_id, &[]);
+        if let Some(inner_ty) = get_iterator_item_ty(cx, cx.typeck_results().expr_ty_adjusted(recv));
+        then {
+            inner_ty
+        } else {
+            return;
+        }
     };
 
     match inner_ty.kind() {
diff --git a/tests/ui/iter_overeager_cloned.fixed b/tests/ui/iter_overeager_cloned.fixed
index a9041671101..56761ebbcb8 100644
--- a/tests/ui/iter_overeager_cloned.fixed
+++ b/tests/ui/iter_overeager_cloned.fixed
@@ -1,5 +1,6 @@
 // run-rustfix
 #![warn(clippy::iter_overeager_cloned, clippy::redundant_clone, clippy::filter_next)]
+#![allow(dead_code)]
 
 fn main() {
     let vec = vec!["1".to_string(), "2".to_string(), "3".to_string()];
@@ -43,3 +44,8 @@ fn main() {
     // Should probably stay as it is.
     let _ = [0, 1, 2, 3, 4].iter().cloned().take(10);
 }
+
+// #8527
+fn cloned_flatten(x: Option<&Option<String>>) -> Option<String> {
+    x.cloned().flatten()
+}
diff --git a/tests/ui/iter_overeager_cloned.rs b/tests/ui/iter_overeager_cloned.rs
index dd04e33a4b3..98321d889b5 100644
--- a/tests/ui/iter_overeager_cloned.rs
+++ b/tests/ui/iter_overeager_cloned.rs
@@ -1,5 +1,6 @@
 // run-rustfix
 #![warn(clippy::iter_overeager_cloned, clippy::redundant_clone, clippy::filter_next)]
+#![allow(dead_code)]
 
 fn main() {
     let vec = vec!["1".to_string(), "2".to_string(), "3".to_string()];
@@ -45,3 +46,8 @@ fn main() {
     // Should probably stay as it is.
     let _ = [0, 1, 2, 3, 4].iter().cloned().take(10);
 }
+
+// #8527
+fn cloned_flatten(x: Option<&Option<String>>) -> Option<String> {
+    x.cloned().flatten()
+}
diff --git a/tests/ui/iter_overeager_cloned.stderr b/tests/ui/iter_overeager_cloned.stderr
index e36b0e36fbd..0582700fd16 100644
--- a/tests/ui/iter_overeager_cloned.stderr
+++ b/tests/ui/iter_overeager_cloned.stderr
@@ -1,5 +1,5 @@
 error: called `cloned().last()` on an `Iterator`. It may be more efficient to call `last().cloned()` instead
-  --> $DIR/iter_overeager_cloned.rs:7:29
+  --> $DIR/iter_overeager_cloned.rs:8:29
    |
 LL |     let _: Option<String> = vec.iter().cloned().last();
    |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `vec.iter().last().cloned()`
@@ -7,13 +7,13 @@ LL |     let _: Option<String> = vec.iter().cloned().last();
    = note: `-D clippy::iter-overeager-cloned` implied by `-D warnings`
 
 error: called `cloned().next()` on an `Iterator`. It may be more efficient to call `next().cloned()` instead
-  --> $DIR/iter_overeager_cloned.rs:9:29
+  --> $DIR/iter_overeager_cloned.rs:10:29
    |
 LL |     let _: Option<String> = vec.iter().chain(vec.iter()).cloned().next();
    |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `vec.iter().chain(vec.iter()).next().cloned()`
 
 error: called `cloned().count()` on an `Iterator`. It may be more efficient to call `count()` instead
-  --> $DIR/iter_overeager_cloned.rs:11:20
+  --> $DIR/iter_overeager_cloned.rs:12:20
    |
 LL |     let _: usize = vec.iter().filter(|x| x == &"2").cloned().count();
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `vec.iter().filter(|x| x == &"2").count()`
@@ -21,25 +21,25 @@ LL |     let _: usize = vec.iter().filter(|x| x == &"2").cloned().count();
    = note: `-D clippy::redundant-clone` implied by `-D warnings`
 
 error: called `cloned().take(...)` on an `Iterator`. It may be more efficient to call `take(...).cloned()` instead
-  --> $DIR/iter_overeager_cloned.rs:13:21
+  --> $DIR/iter_overeager_cloned.rs:14:21
    |
 LL |     let _: Vec<_> = vec.iter().cloned().take(2).collect();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `vec.iter().take(2).cloned()`
 
 error: called `cloned().skip(...)` on an `Iterator`. It may be more efficient to call `skip(...).cloned()` instead
-  --> $DIR/iter_overeager_cloned.rs:15:21
+  --> $DIR/iter_overeager_cloned.rs:16:21
    |
 LL |     let _: Vec<_> = vec.iter().cloned().skip(2).collect();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `vec.iter().skip(2).cloned()`
 
 error: called `cloned().nth(...)` on an `Iterator`. It may be more efficient to call `nth(...).cloned()` instead
-  --> $DIR/iter_overeager_cloned.rs:17:13
+  --> $DIR/iter_overeager_cloned.rs:18:13
    |
 LL |     let _ = vec.iter().filter(|x| x == &"2").cloned().nth(2);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `vec.iter().filter(|x| x == &"2").nth(2).cloned()`
 
 error: called `cloned().flatten()` on an `Iterator`. It may be more efficient to call `flatten().cloned()` instead
-  --> $DIR/iter_overeager_cloned.rs:19:13
+  --> $DIR/iter_overeager_cloned.rs:20:13
    |
 LL |       let _ = [Some(Some("str".to_string())), Some(Some("str".to_string()))]
    |  _____________^
-- 
cgit 1.4.1-3-g733a5


From 9b304533abac7479f168c0aaa1b6282194f4c128 Mon Sep 17 00:00:00 2001
From: Samuel Moelius <35515885+smoelius@users.noreply.github.com>
Date: Wed, 30 Mar 2022 12:40:16 -0400
Subject: Update clippy_lints/src/crate_in_macro_def.rs

Co-authored-by: llogiq <bogusandre@gmail.com>
---
 clippy_lints/src/crate_in_macro_def.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/crate_in_macro_def.rs b/clippy_lints/src/crate_in_macro_def.rs
index 21c65f9d6f0..844887dcbe5 100644
--- a/clippy_lints/src/crate_in_macro_def.rs
+++ b/clippy_lints/src/crate_in_macro_def.rs
@@ -62,7 +62,7 @@ impl EarlyLintPass for CrateInMacroDef {
                     cx,
                     CRATE_IN_MACRO_DEF,
                     span,
-                    "reference to the macro call's crate, which is rarely intended",
+                    "`crate` references the macro call's crate",
                     "if reference to the macro definition's crate is intended, use",
                     String::from("$crate"),
                     Applicability::MachineApplicable,
-- 
cgit 1.4.1-3-g733a5


From abc221e7f66b495d2ea86ccdb200ee9f29cecaab Mon Sep 17 00:00:00 2001
From: Samuel Moelius <35515885+smoelius@users.noreply.github.com>
Date: Wed, 30 Mar 2022 12:40:25 -0400
Subject: Update clippy_lints/src/crate_in_macro_def.rs

Co-authored-by: llogiq <bogusandre@gmail.com>
---
 clippy_lints/src/crate_in_macro_def.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/crate_in_macro_def.rs b/clippy_lints/src/crate_in_macro_def.rs
index 844887dcbe5..ef2f3df105a 100644
--- a/clippy_lints/src/crate_in_macro_def.rs
+++ b/clippy_lints/src/crate_in_macro_def.rs
@@ -63,7 +63,7 @@ impl EarlyLintPass for CrateInMacroDef {
                     CRATE_IN_MACRO_DEF,
                     span,
                     "`crate` references the macro call's crate",
-                    "if reference to the macro definition's crate is intended, use",
+                    "to reference the macro definition's crate, use",
                     String::from("$crate"),
                     Applicability::MachineApplicable,
                 );
-- 
cgit 1.4.1-3-g733a5


From 75dc406e84122363c94e1faaae37472d23d20c29 Mon Sep 17 00:00:00 2001
From: Samuel Moelius <35515885+smoelius@users.noreply.github.com>
Date: Wed, 30 Mar 2022 12:40:44 -0400
Subject: Update clippy_lints/src/crate_in_macro_def.rs

Co-authored-by: llogiq <bogusandre@gmail.com>
---
 clippy_lints/src/crate_in_macro_def.rs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/crate_in_macro_def.rs b/clippy_lints/src/crate_in_macro_def.rs
index ef2f3df105a..e64c7f127eb 100644
--- a/clippy_lints/src/crate_in_macro_def.rs
+++ b/clippy_lints/src/crate_in_macro_def.rs
@@ -76,9 +76,8 @@ fn is_macro_export(attr: &Attribute) -> bool {
     if_chain! {
         if let AttrKind::Normal(attr_item, _) = &attr.kind;
         if let [segment] = attr_item.path.segments.as_slice();
-        if segment.ident.name == sym::macro_export;
         then {
-            true
+            segment.ident.name == sym::macro_export
         } else {
             false
         }
-- 
cgit 1.4.1-3-g733a5


From d6eb82c0a8d94d21fee110620ee4d0515ac198d3 Mon Sep 17 00:00:00 2001
From: "Samuel E. Moelius III" <sam@moeli.us>
Date: Wed, 30 Mar 2022 12:32:07 -0400
Subject: Move `crate_in_macro_def` to suspicious

---
 clippy_lints/src/crate_in_macro_def.rs       | 2 +-
 clippy_lints/src/lib.register_correctness.rs | 1 -
 clippy_lints/src/lib.register_suspicious.rs  | 1 +
 3 files changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/crate_in_macro_def.rs b/clippy_lints/src/crate_in_macro_def.rs
index e64c7f127eb..fc141b4a6e3 100644
--- a/clippy_lints/src/crate_in_macro_def.rs
+++ b/clippy_lints/src/crate_in_macro_def.rs
@@ -45,7 +45,7 @@ declare_clippy_lint! {
     /// ```
     #[clippy::version = "1.61.0"]
     pub CRATE_IN_MACRO_DEF,
-    correctness,
+    suspicious,
     "using `crate` in a macro definition"
 }
 declare_lint_pass!(CrateInMacroDef => [CRATE_IN_MACRO_DEF]);
diff --git a/clippy_lints/src/lib.register_correctness.rs b/clippy_lints/src/lib.register_correctness.rs
index d5cade8fe99..df63f84463d 100644
--- a/clippy_lints/src/lib.register_correctness.rs
+++ b/clippy_lints/src/lib.register_correctness.rs
@@ -16,7 +16,6 @@ store.register_group(true, "clippy::correctness", Some("clippy_correctness"), ve
     LintId::of(casts::CAST_SLICE_DIFFERENT_SIZES),
     LintId::of(copies::IFS_SAME_COND),
     LintId::of(copies::IF_SAME_THEN_ELSE),
-    LintId::of(crate_in_macro_def::CRATE_IN_MACRO_DEF),
     LintId::of(derive::DERIVE_HASH_XOR_EQ),
     LintId::of(derive::DERIVE_ORD_XOR_PARTIAL_ORD),
     LintId::of(drop_forget_ref::DROP_COPY),
diff --git a/clippy_lints/src/lib.register_suspicious.rs b/clippy_lints/src/lib.register_suspicious.rs
index fa3a88e1368..0707e4f8f3d 100644
--- a/clippy_lints/src/lib.register_suspicious.rs
+++ b/clippy_lints/src/lib.register_suspicious.rs
@@ -9,6 +9,7 @@ store.register_group(true, "clippy::suspicious", Some("clippy_suspicious"), vec!
     LintId::of(await_holding_invalid::AWAIT_HOLDING_REFCELL_REF),
     LintId::of(casts::CAST_ENUM_CONSTRUCTOR),
     LintId::of(casts::CAST_ENUM_TRUNCATION),
+    LintId::of(crate_in_macro_def::CRATE_IN_MACRO_DEF),
     LintId::of(eval_order_dependence::EVAL_ORDER_DEPENDENCE),
     LintId::of(float_equality_without_abs::FLOAT_EQUALITY_WITHOUT_ABS),
     LintId::of(format_impl::PRINT_IN_FORMAT_IMPL),
-- 
cgit 1.4.1-3-g733a5


From 10a6d872d4e42884c4be43a51806ccdd6f8b89b5 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Wed, 30 Mar 2022 18:44:04 +0100
Subject: Handle relative paths in module_files lints

---
 clippy_lints/src/module_style.rs                   | 62 +++++++++-------------
 .../ui-cargo/module_style/fail_mod/src/main.stderr |  8 +--
 .../module_style/fail_no_mod/src/main.stderr       |  4 +-
 3 files changed, 30 insertions(+), 44 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/module_style.rs b/clippy_lints/src/module_style.rs
index b8dfe996880..39c44ad6e2c 100644
--- a/clippy_lints/src/module_style.rs
+++ b/clippy_lints/src/module_style.rs
@@ -1,13 +1,10 @@
-use std::{
-    ffi::OsString,
-    path::{Component, Path},
-};
-
 use rustc_ast::ast;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_lint::{EarlyContext, EarlyLintPass, Level, LintContext};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::{FileName, RealFileName, SourceFile, Span, SyntaxContext};
+use std::ffi::OsStr;
+use std::path::{Component, Path};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -82,11 +79,7 @@ impl EarlyLintPass for ModStyle {
 
         let files = cx.sess().source_map().files();
 
-        let trim_to_src = if let RealFileName::LocalPath(p) = &cx.sess().opts.working_dir {
-            p.to_string_lossy()
-        } else {
-            return;
-        };
+        let RealFileName::LocalPath(trim_to_src) = &cx.sess().opts.working_dir else { return };
 
         // `folder_segments` is all unique folder path segments `path/to/foo.rs` gives
         // `[path, to]` but not foo
@@ -97,26 +90,27 @@ impl EarlyLintPass for ModStyle {
         // `{ foo => path/to/foo.rs, .. }
         let mut file_map = FxHashMap::default();
         for file in files.iter() {
-            match &file.name {
-                FileName::Real(RealFileName::LocalPath(lp))
-                    if lp.to_string_lossy().starts_with(trim_to_src.as_ref()) =>
-                {
-                    let p = lp.to_string_lossy();
-                    let path = Path::new(p.trim_start_matches(trim_to_src.as_ref()));
-                    if let Some(stem) = path.file_stem() {
-                        file_map.insert(stem.to_os_string(), (file, path.to_owned()));
-                    }
-                    process_paths_for_mod_files(path, &mut folder_segments, &mut mod_folders);
-                    check_self_named_mod_exists(cx, path, file);
-                },
-                _ => {},
+            if let FileName::Real(RealFileName::LocalPath(lp)) = &file.name {
+                let path = if lp.is_relative() {
+                    lp
+                } else if let Ok(relative) = lp.strip_prefix(trim_to_src) {
+                    relative
+                } else {
+                    continue;
+                };
+
+                if let Some(stem) = path.file_stem() {
+                    file_map.insert(stem, (file, path));
+                }
+                process_paths_for_mod_files(path, &mut folder_segments, &mut mod_folders);
+                check_self_named_mod_exists(cx, path, file);
             }
         }
 
         for folder in &folder_segments {
             if !mod_folders.contains(folder) {
                 if let Some((file, path)) = file_map.get(folder) {
-                    let mut correct = path.clone();
+                    let mut correct = path.to_path_buf();
                     correct.pop();
                     correct.push(folder);
                     correct.push("mod.rs");
@@ -138,25 +132,17 @@ impl EarlyLintPass for ModStyle {
 
 /// For each `path` we add each folder component to `folder_segments` and if the file name
 /// is `mod.rs` we add it's parent folder to `mod_folders`.
-fn process_paths_for_mod_files(
-    path: &Path,
-    folder_segments: &mut FxHashSet<OsString>,
-    mod_folders: &mut FxHashSet<OsString>,
+fn process_paths_for_mod_files<'a>(
+    path: &'a Path,
+    folder_segments: &mut FxHashSet<&'a OsStr>,
+    mod_folders: &mut FxHashSet<&'a OsStr>,
 ) {
     let mut comp = path.components().rev().peekable();
     let _ = comp.next();
     if path.ends_with("mod.rs") {
-        mod_folders.insert(comp.peek().map(|c| c.as_os_str().to_owned()).unwrap_or_default());
+        mod_folders.insert(comp.peek().map(|c| c.as_os_str()).unwrap_or_default());
     }
-    let folders = comp
-        .filter_map(|c| {
-            if let Component::Normal(s) = c {
-                Some(s.to_os_string())
-            } else {
-                None
-            }
-        })
-        .collect::<Vec<_>>();
+    let folders = comp.filter_map(|c| if let Component::Normal(s) = c { Some(s) } else { None });
     folder_segments.extend(folders);
 }
 
diff --git a/tests/ui-cargo/module_style/fail_mod/src/main.stderr b/tests/ui-cargo/module_style/fail_mod/src/main.stderr
index af4c298b310..e2010e99813 100644
--- a/tests/ui-cargo/module_style/fail_mod/src/main.stderr
+++ b/tests/ui-cargo/module_style/fail_mod/src/main.stderr
@@ -1,19 +1,19 @@
-error: `mod.rs` files are required, found `/bad/inner.rs`
+error: `mod.rs` files are required, found `bad/inner.rs`
   --> $DIR/bad/inner.rs:1:1
    |
 LL | pub mod stuff;
    | ^
    |
    = note: `-D clippy::self-named-module-files` implied by `-D warnings`
-   = help: move `/bad/inner.rs` to `/bad/inner/mod.rs`
+   = help: move `bad/inner.rs` to `bad/inner/mod.rs`
 
-error: `mod.rs` files are required, found `/bad/inner/stuff.rs`
+error: `mod.rs` files are required, found `bad/inner/stuff.rs`
   --> $DIR/bad/inner/stuff.rs:1:1
    |
 LL | pub mod most;
    | ^
    |
-   = help: move `/bad/inner/stuff.rs` to `/bad/inner/stuff/mod.rs`
+   = help: move `bad/inner/stuff.rs` to `bad/inner/stuff/mod.rs`
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui-cargo/module_style/fail_no_mod/src/main.stderr b/tests/ui-cargo/module_style/fail_no_mod/src/main.stderr
index 11e15db7fb9..f9194020938 100644
--- a/tests/ui-cargo/module_style/fail_no_mod/src/main.stderr
+++ b/tests/ui-cargo/module_style/fail_no_mod/src/main.stderr
@@ -1,11 +1,11 @@
-error: `mod.rs` files are not allowed, found `/bad/mod.rs`
+error: `mod.rs` files are not allowed, found `bad/mod.rs`
   --> $DIR/bad/mod.rs:1:1
    |
 LL | pub struct Thing;
    | ^
    |
    = note: `-D clippy::mod-module-files` implied by `-D warnings`
-   = help: move `/bad/mod.rs` to `/bad.rs`
+   = help: move `bad/mod.rs` to `bad.rs`
 
 error: aborting due to previous error
 
-- 
cgit 1.4.1-3-g733a5


From d6f05c6a89e7bbaafc2ca30f845de488cd5a8978 Mon Sep 17 00:00:00 2001
From: SabrinaJewson <sejewson@gmail.com>
Date: Wed, 30 Mar 2022 18:47:50 +0100
Subject: Don't warn int-to-char transmutes in const contexts

---
 clippy_lints/src/transmute/mod.rs                  |  9 ++---
 .../src/transmute/transmute_int_to_char.rs         |  3 +-
 tests/ui/transmute.rs                              |  4 +++
 tests/ui/transmute.stderr                          | 42 +++++++++++-----------
 4 files changed, 32 insertions(+), 26 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/transmute/mod.rs b/clippy_lints/src/transmute/mod.rs
index 02569bd3a47..342f23f030c 100644
--- a/clippy_lints/src/transmute/mod.rs
+++ b/clippy_lints/src/transmute/mod.rs
@@ -410,9 +410,10 @@ impl<'tcx> LateLintPass<'tcx> for Transmute {
             if let Some(def_id) = cx.qpath_res(qpath, path_expr.hir_id).opt_def_id();
             if cx.tcx.is_diagnostic_item(sym::transmute, def_id);
             then {
-                // Avoid suggesting from/to bits and dereferencing raw pointers in const contexts.
-                // See https://github.com/rust-lang/rust/issues/73736 for progress on making them `const fn`.
-                // And see https://github.com/rust-lang/rust/issues/51911 for dereferencing raw pointers.
+                // Avoid suggesting non-const operations in const contexts:
+                // - from/to bits (https://github.com/rust-lang/rust/issues/73736)
+                // - dereferencing raw pointers (https://github.com/rust-lang/rust/issues/51911)
+                // - char conversions (https://github.com/rust-lang/rust/issues/89259)
                 let const_context = in_constant(cx, e.hir_id);
 
                 let from_ty = cx.typeck_results().expr_ty_adjusted(arg);
@@ -427,7 +428,7 @@ impl<'tcx> LateLintPass<'tcx> for Transmute {
                 let linted = wrong_transmute::check(cx, e, from_ty, to_ty)
                     | crosspointer_transmute::check(cx, e, from_ty, to_ty)
                     | transmute_ptr_to_ref::check(cx, e, from_ty, to_ty, arg, qpath)
-                    | transmute_int_to_char::check(cx, e, from_ty, to_ty, arg)
+                    | transmute_int_to_char::check(cx, e, from_ty, to_ty, arg, const_context)
                     | transmute_ref_to_ref::check(cx, e, from_ty, to_ty, arg, const_context)
                     | transmute_ptr_to_ptr::check(cx, e, from_ty, to_ty, arg)
                     | transmute_int_to_bool::check(cx, e, from_ty, to_ty, arg)
diff --git a/clippy_lints/src/transmute/transmute_int_to_char.rs b/clippy_lints/src/transmute/transmute_int_to_char.rs
index 3eb07b68992..9e1823c373b 100644
--- a/clippy_lints/src/transmute/transmute_int_to_char.rs
+++ b/clippy_lints/src/transmute/transmute_int_to_char.rs
@@ -15,9 +15,10 @@ pub(super) fn check<'tcx>(
     from_ty: Ty<'tcx>,
     to_ty: Ty<'tcx>,
     arg: &'tcx Expr<'_>,
+    const_context: bool,
 ) -> bool {
     match (&from_ty.kind(), &to_ty.kind()) {
-        (ty::Int(ty::IntTy::I32) | ty::Uint(ty::UintTy::U32), &ty::Char) => {
+        (ty::Int(ty::IntTy::I32) | ty::Uint(ty::UintTy::U32), &ty::Char) if !const_context => {
             span_lint_and_then(
                 cx,
                 TRANSMUTE_INT_TO_CHAR,
diff --git a/tests/ui/transmute.rs b/tests/ui/transmute.rs
index 9b681a79aae..54f9727d8ea 100644
--- a/tests/ui/transmute.rs
+++ b/tests/ui/transmute.rs
@@ -73,6 +73,10 @@ fn crosspointer() {
 fn int_to_char() {
     let _: char = unsafe { std::mem::transmute(0_u32) };
     let _: char = unsafe { std::mem::transmute(0_i32) };
+
+    // These shouldn't warn
+    const _: char = unsafe { std::mem::transmute(0_u32) };
+    const _: char = unsafe { std::mem::transmute(0_i32) };
 }
 
 #[warn(clippy::transmute_int_to_bool)]
diff --git a/tests/ui/transmute.stderr b/tests/ui/transmute.stderr
index 86537153e32..5c60fc2d511 100644
--- a/tests/ui/transmute.stderr
+++ b/tests/ui/transmute.stderr
@@ -107,7 +107,7 @@ LL |     let _: char = unsafe { std::mem::transmute(0_i32) };
    |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::char::from_u32(0_i32 as u32).unwrap()`
 
 error: transmute from a `u8` to a `bool`
-  --> $DIR/transmute.rs:80:28
+  --> $DIR/transmute.rs:84:28
    |
 LL |     let _: bool = unsafe { std::mem::transmute(0_u8) };
    |                            ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `0_u8 != 0`
@@ -115,7 +115,7 @@ LL |     let _: bool = unsafe { std::mem::transmute(0_u8) };
    = note: `-D clippy::transmute-int-to-bool` implied by `-D warnings`
 
 error: transmute from a `u32` to a `f32`
-  --> $DIR/transmute.rs:86:31
+  --> $DIR/transmute.rs:90:31
    |
 LL |         let _: f32 = unsafe { std::mem::transmute(0_u32) };
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `f32::from_bits(0_u32)`
@@ -123,25 +123,25 @@ LL |         let _: f32 = unsafe { std::mem::transmute(0_u32) };
    = note: `-D clippy::transmute-int-to-float` implied by `-D warnings`
 
 error: transmute from a `i32` to a `f32`
-  --> $DIR/transmute.rs:87:31
+  --> $DIR/transmute.rs:91:31
    |
 LL |         let _: f32 = unsafe { std::mem::transmute(0_i32) };
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `f32::from_bits(0_i32 as u32)`
 
 error: transmute from a `u64` to a `f64`
-  --> $DIR/transmute.rs:88:31
+  --> $DIR/transmute.rs:92:31
    |
 LL |         let _: f64 = unsafe { std::mem::transmute(0_u64) };
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `f64::from_bits(0_u64)`
 
 error: transmute from a `i64` to a `f64`
-  --> $DIR/transmute.rs:89:31
+  --> $DIR/transmute.rs:93:31
    |
 LL |         let _: f64 = unsafe { std::mem::transmute(0_i64) };
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `f64::from_bits(0_i64 as u64)`
 
 error: transmute from a `u8` to a `[u8; 1]`
-  --> $DIR/transmute.rs:109:30
+  --> $DIR/transmute.rs:113:30
    |
 LL |             let _: [u8; 1] = std::mem::transmute(0u8);
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0u8.to_ne_bytes()`
@@ -149,85 +149,85 @@ LL |             let _: [u8; 1] = std::mem::transmute(0u8);
    = note: `-D clippy::transmute-num-to-bytes` implied by `-D warnings`
 
 error: transmute from a `u32` to a `[u8; 4]`
-  --> $DIR/transmute.rs:110:30
+  --> $DIR/transmute.rs:114:30
    |
 LL |             let _: [u8; 4] = std::mem::transmute(0u32);
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0u32.to_ne_bytes()`
 
 error: transmute from a `u128` to a `[u8; 16]`
-  --> $DIR/transmute.rs:111:31
+  --> $DIR/transmute.rs:115:31
    |
 LL |             let _: [u8; 16] = std::mem::transmute(0u128);
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0u128.to_ne_bytes()`
 
 error: transmute from a `i8` to a `[u8; 1]`
-  --> $DIR/transmute.rs:112:30
+  --> $DIR/transmute.rs:116:30
    |
 LL |             let _: [u8; 1] = std::mem::transmute(0i8);
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0i8.to_ne_bytes()`
 
 error: transmute from a `i32` to a `[u8; 4]`
-  --> $DIR/transmute.rs:113:30
+  --> $DIR/transmute.rs:117:30
    |
 LL |             let _: [u8; 4] = std::mem::transmute(0i32);
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0i32.to_ne_bytes()`
 
 error: transmute from a `i128` to a `[u8; 16]`
-  --> $DIR/transmute.rs:114:31
+  --> $DIR/transmute.rs:118:31
    |
 LL |             let _: [u8; 16] = std::mem::transmute(0i128);
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0i128.to_ne_bytes()`
 
 error: transmute from a `f32` to a `[u8; 4]`
-  --> $DIR/transmute.rs:115:30
+  --> $DIR/transmute.rs:119:30
    |
 LL |             let _: [u8; 4] = std::mem::transmute(0.0f32);
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0.0f32.to_ne_bytes()`
 
 error: transmute from a `f64` to a `[u8; 8]`
-  --> $DIR/transmute.rs:116:30
+  --> $DIR/transmute.rs:120:30
    |
 LL |             let _: [u8; 8] = std::mem::transmute(0.0f64);
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0.0f64.to_ne_bytes()`
 
 error: transmute from a `u8` to a `[u8; 1]`
-  --> $DIR/transmute.rs:121:30
+  --> $DIR/transmute.rs:125:30
    |
 LL |             let _: [u8; 1] = std::mem::transmute(0u8);
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0u8.to_ne_bytes()`
 
 error: transmute from a `u32` to a `[u8; 4]`
-  --> $DIR/transmute.rs:122:30
+  --> $DIR/transmute.rs:126:30
    |
 LL |             let _: [u8; 4] = std::mem::transmute(0u32);
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0u32.to_ne_bytes()`
 
 error: transmute from a `u128` to a `[u8; 16]`
-  --> $DIR/transmute.rs:123:31
+  --> $DIR/transmute.rs:127:31
    |
 LL |             let _: [u8; 16] = std::mem::transmute(0u128);
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0u128.to_ne_bytes()`
 
 error: transmute from a `i8` to a `[u8; 1]`
-  --> $DIR/transmute.rs:124:30
+  --> $DIR/transmute.rs:128:30
    |
 LL |             let _: [u8; 1] = std::mem::transmute(0i8);
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0i8.to_ne_bytes()`
 
 error: transmute from a `i32` to a `[u8; 4]`
-  --> $DIR/transmute.rs:125:30
+  --> $DIR/transmute.rs:129:30
    |
 LL |             let _: [u8; 4] = std::mem::transmute(0i32);
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0i32.to_ne_bytes()`
 
 error: transmute from a `i128` to a `[u8; 16]`
-  --> $DIR/transmute.rs:126:31
+  --> $DIR/transmute.rs:130:31
    |
 LL |             let _: [u8; 16] = std::mem::transmute(0i128);
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0i128.to_ne_bytes()`
 
 error: transmute from a `&[u8]` to a `&str`
-  --> $DIR/transmute.rs:134:28
+  --> $DIR/transmute.rs:138:28
    |
 LL |     let _: &str = unsafe { std::mem::transmute(b) };
    |                            ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::str::from_utf8(b).unwrap()`
@@ -235,7 +235,7 @@ LL |     let _: &str = unsafe { std::mem::transmute(b) };
    = note: `-D clippy::transmute-bytes-to-str` implied by `-D warnings`
 
 error: transmute from a `&mut [u8]` to a `&mut str`
-  --> $DIR/transmute.rs:135:32
+  --> $DIR/transmute.rs:139:32
    |
 LL |     let _: &mut str = unsafe { std::mem::transmute(mb) };
    |                                ^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::str::from_utf8_mut(mb).unwrap()`
-- 
cgit 1.4.1-3-g733a5


From 528ada958bf51b6a48430f357f6ae77a9e81c650 Mon Sep 17 00:00:00 2001
From: Max Baumann <max@bmn.dev>
Date: Sun, 27 Mar 2022 14:16:08 +0200
Subject: add unit_like_struct_brackets

---
 CHANGELOG.md                                  |  1 +
 clippy_lints/src/lib.register_all.rs          |  1 +
 clippy_lints/src/lib.register_lints.rs        |  1 +
 clippy_lints/src/lib.register_style.rs        |  1 +
 clippy_lints/src/lib.rs                       |  2 +
 clippy_lints/src/unit_like_struct_brackets.rs | 53 +++++++++++++++++++++++++++
 tests/ui/unit_like_struct_brackets.fixed      | 13 +++++++
 tests/ui/unit_like_struct_brackets.rs         | 13 +++++++
 tests/ui/unit_like_struct_brackets.stderr     | 16 ++++++++
 9 files changed, 101 insertions(+)
 create mode 100644 clippy_lints/src/unit_like_struct_brackets.rs
 create mode 100644 tests/ui/unit_like_struct_brackets.fixed
 create mode 100644 tests/ui/unit_like_struct_brackets.rs
 create mode 100644 tests/ui/unit_like_struct_brackets.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 1d1e081e839..49a44d98813 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3636,6 +3636,7 @@ Released 2018-09-13
 [`unit_arg`]: https://rust-lang.github.io/rust-clippy/master/index.html#unit_arg
 [`unit_cmp`]: https://rust-lang.github.io/rust-clippy/master/index.html#unit_cmp
 [`unit_hash`]: https://rust-lang.github.io/rust-clippy/master/index.html#unit_hash
+[`unit_like_struct_brackets`]: https://rust-lang.github.io/rust-clippy/master/index.html#unit_like_struct_brackets
 [`unit_return_expecting_ord`]: https://rust-lang.github.io/rust-clippy/master/index.html#unit_return_expecting_ord
 [`unnecessary_cast`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_cast
 [`unnecessary_filter_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_filter_map
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 1fb3ca1fd9b..f488aab46ec 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -301,6 +301,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(unicode::INVISIBLE_CHARACTERS),
     LintId::of(uninit_vec::UNINIT_VEC),
     LintId::of(unit_hash::UNIT_HASH),
+    LintId::of(unit_like_struct_brackets::UNIT_LIKE_STRUCT_BRACKETS),
     LintId::of(unit_return_expecting_ord::UNIT_RETURN_EXPECTING_ORD),
     LintId::of(unit_types::UNIT_ARG),
     LintId::of(unit_types::UNIT_CMP),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index e3161795139..a1e6ca76a16 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -512,6 +512,7 @@ store.register_lints(&[
     unicode::UNICODE_NOT_NFC,
     uninit_vec::UNINIT_VEC,
     unit_hash::UNIT_HASH,
+    unit_like_struct_brackets::UNIT_LIKE_STRUCT_BRACKETS,
     unit_return_expecting_ord::UNIT_RETURN_EXPECTING_ORD,
     unit_types::LET_UNIT_VALUE,
     unit_types::UNIT_ARG,
diff --git a/clippy_lints/src/lib.register_style.rs b/clippy_lints/src/lib.register_style.rs
index dcf399cf956..89657cfb784 100644
--- a/clippy_lints/src/lib.register_style.rs
+++ b/clippy_lints/src/lib.register_style.rs
@@ -105,6 +105,7 @@ store.register_group(true, "clippy::style", Some("clippy_style"), vec![
     LintId::of(single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS),
     LintId::of(tabs_in_doc_comments::TABS_IN_DOC_COMMENTS),
     LintId::of(to_digit_is_some::TO_DIGIT_IS_SOME),
+    LintId::of(unit_like_struct_brackets::UNIT_LIKE_STRUCT_BRACKETS),
     LintId::of(unsafe_removed_from_name::UNSAFE_REMOVED_FROM_NAME),
     LintId::of(unused_unit::UNUSED_UNIT),
     LintId::of(upper_case_acronyms::UPPER_CASE_ACRONYMS),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index c8b57956b1b..af8d9b3655c 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -380,6 +380,7 @@ mod undropped_manually_drops;
 mod unicode;
 mod uninit_vec;
 mod unit_hash;
+mod unit_like_struct_brackets;
 mod unit_return_expecting_ord;
 mod unit_types;
 mod unnamed_address;
@@ -869,6 +870,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         })
     });
     store.register_early_pass(|| Box::new(crate_in_macro_def::CrateInMacroDef));
+    store.register_early_pass(|| Box::new(unit_like_struct_brackets::UnitLikeStructBrackets));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/unit_like_struct_brackets.rs b/clippy_lints/src/unit_like_struct_brackets.rs
new file mode 100644
index 00000000000..0eeb765be85
--- /dev/null
+++ b/clippy_lints/src/unit_like_struct_brackets.rs
@@ -0,0 +1,53 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use rustc_ast::ast::*;
+use rustc_errors::Applicability;
+use rustc_lint::{EarlyContext, EarlyLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Finds structs without fields ("unit-like structs") that are declared with brackets.
+    ///
+    /// ### Why is this bad?
+    /// Empty brackets after a struct declaration can be omitted.
+    ///
+    /// ### Example
+    /// ```rust
+    /// struct Cookie {}
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// struct Cookie;
+    /// ```
+    #[clippy::version = "1.61.0"]
+    pub UNIT_LIKE_STRUCT_BRACKETS,
+    style,
+    "finds struct declarations with empty brackets"
+}
+declare_lint_pass!(UnitLikeStructBrackets => [UNIT_LIKE_STRUCT_BRACKETS]);
+
+impl EarlyLintPass for UnitLikeStructBrackets {
+    fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {
+        if let ItemKind::Struct(var_data, _) = &item.kind && has_no_fields(var_data) {
+            let span_after_ident = item.span.with_lo(item.ident.span.hi());
+
+            span_lint_and_sugg(
+                cx,
+                UNIT_LIKE_STRUCT_BRACKETS,
+                span_after_ident,
+                "found empty brackets on struct declaration",
+                "remove the brackets",
+                ";".to_string(),
+                Applicability::MachineApplicable
+            );
+        }
+    }
+}
+
+fn has_no_fields(var_data: &VariantData) -> bool {
+    match var_data {
+        VariantData::Struct(defs, _) => defs.is_empty(),
+        VariantData::Tuple(defs, _) => defs.is_empty(),
+        VariantData::Unit(_) => false,
+    }
+}
diff --git a/tests/ui/unit_like_struct_brackets.fixed b/tests/ui/unit_like_struct_brackets.fixed
new file mode 100644
index 00000000000..a69c310e973
--- /dev/null
+++ b/tests/ui/unit_like_struct_brackets.fixed
@@ -0,0 +1,13 @@
+// run-rustfix
+#![warn(clippy::unit_like_struct_brackets)]
+#![allow(dead_code)]
+
+pub struct MyEmptyStruct;             // should trigger lint
+struct MyEmptyTupleStruct;            // should trigger lint
+
+struct MyStruct {                       // should not trigger lint
+    field: u8,
+}
+struct MyTupleStruct(usize, String);    // should not trigger lint
+
+fn main() {}
diff --git a/tests/ui/unit_like_struct_brackets.rs b/tests/ui/unit_like_struct_brackets.rs
new file mode 100644
index 00000000000..8697a24f1d7
--- /dev/null
+++ b/tests/ui/unit_like_struct_brackets.rs
@@ -0,0 +1,13 @@
+// run-rustfix
+#![warn(clippy::unit_like_struct_brackets)]
+#![allow(dead_code)]
+
+pub struct MyEmptyStruct {}             // should trigger lint
+struct MyEmptyTupleStruct();            // should trigger lint
+
+struct MyStruct {                       // should not trigger lint
+    field: u8,
+}
+struct MyTupleStruct(usize, String);    // should not trigger lint
+
+fn main() {}
diff --git a/tests/ui/unit_like_struct_brackets.stderr b/tests/ui/unit_like_struct_brackets.stderr
new file mode 100644
index 00000000000..146ede19c07
--- /dev/null
+++ b/tests/ui/unit_like_struct_brackets.stderr
@@ -0,0 +1,16 @@
+error: found empty brackets on struct declaration
+  --> $DIR/unit_like_struct_brackets.rs:5:25
+   |
+LL | pub struct MyEmptyStruct {}             // should trigger lint
+   |                         ^^^ help: remove the brackets: `;`
+   |
+   = note: `-D clippy::unit-like-struct-brackets` implied by `-D warnings`
+
+error: found empty brackets on struct declaration
+  --> $DIR/unit_like_struct_brackets.rs:6:26
+   |
+LL | struct MyEmptyTupleStruct();            // should trigger lint
+   |                          ^^^ help: remove the brackets: `;`
+
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 9be3945be740b12c333a68db6fa33b8878acdeb9 Mon Sep 17 00:00:00 2001
From: Max Baumann <max@bmn.dev>
Date: Sun, 27 Mar 2022 14:41:09 +0200
Subject: fix existing clippy tests

---
 clippy_lints/src/use_self.rs                       |  4 ++--
 tests/ui-toml/struct_excessive_bools/test.rs       |  2 +-
 .../case_sensitive_file_extension_comparisons.rs   |  2 +-
 tests/ui/crashes/ice-2774.rs                       |  2 +-
 tests/ui/crashes/ice-6179.rs                       |  2 +-
 tests/ui/crashes/ice-6792.rs                       |  2 +-
 tests/ui/crashes/needless_lifetimes_impl_trait.rs  |  2 +-
 tests/ui/crashes/regressions.rs                    |  2 +-
 tests/ui/default_numeric_fallback_f64.fixed        |  2 +-
 tests/ui/default_numeric_fallback_f64.rs           |  2 +-
 tests/ui/default_numeric_fallback_i32.fixed        |  2 +-
 tests/ui/default_numeric_fallback_i32.rs           |  2 +-
 tests/ui/drop_forget_copy.rs                       |  2 +-
 tests/ui/fn_params_excessive_bools.rs              |  2 +-
 tests/ui/implicit_clone.rs                         |  4 ++--
 tests/ui/iter_nth_zero.fixed                       |  2 +-
 tests/ui/iter_nth_zero.rs                          |  2 +-
 tests/ui/large_types_passed_by_value.rs            |  2 +-
 tests/ui/let_and_return.rs                         |  2 +-
 tests/ui/let_underscore_must_use.rs                |  2 +-
 tests/ui/manual_async_fn.fixed                     |  2 +-
 tests/ui/manual_async_fn.rs                        |  2 +-
 tests/ui/manual_unwrap_or.fixed                    |  2 +-
 tests/ui/manual_unwrap_or.rs                       |  2 +-
 tests/ui/map_unit_fn.rs                            |  2 +-
 tests/ui/min_rust_version_attr.rs                  |  2 +-
 tests/ui/missing_inline.rs                         |  6 +++---
 tests/ui/module_name_repetitions.rs                |  2 +-
 tests/ui/needless_arbitrary_self_type_unfixable.rs |  4 ++--
 tests/ui/needless_lifetimes.rs                     |  2 +-
 tests/ui/no_effect.rs                              |  4 ++--
 tests/ui/or_then_unwrap.fixed                      |  4 ++--
 tests/ui/or_then_unwrap.rs                         |  4 ++--
 tests/ui/ptr_arg.rs                                |  2 +-
 tests/ui/recursive_format_impl.rs                  | 24 +++++++++++-----------
 tests/ui/redundant_allocation.rs                   |  2 +-
 tests/ui/redundant_allocation_fixable.fixed        |  2 +-
 tests/ui/redundant_static_lifetimes.fixed          |  2 +-
 tests/ui/redundant_static_lifetimes.rs             |  2 +-
 tests/ui/same_item_push.rs                         |  2 +-
 tests/ui/trait_duplication_in_bounds.rs            |  4 ++--
 tests/ui/unit_like_struct_brackets.fixed           |  9 ++++----
 tests/ui/unit_like_struct_brackets.rs              |  9 ++++----
 tests/ui/unsafe_derive_deserialize.rs              | 14 ++++++-------
 tests/ui/unsafe_removed_from_name.rs               |  4 ++--
 tests/ui/unused_self.rs                            | 10 ++++-----
 tests/ui/use_self.fixed                            | 22 ++++++++++----------
 tests/ui/use_self.rs                               | 22 ++++++++++----------
 tests/ui/useless_attribute.fixed                   |  2 +-
 tests/ui/useless_attribute.rs                      |  2 +-
 50 files changed, 109 insertions(+), 107 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/use_self.rs b/clippy_lints/src/use_self.rs
index 09d671e1118..f8e1021af0e 100644
--- a/clippy_lints/src/use_self.rs
+++ b/clippy_lints/src/use_self.rs
@@ -34,7 +34,7 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust
-    /// struct Foo {}
+    /// struct Foo;
     /// impl Foo {
     ///     fn new() -> Foo {
     ///         Foo {}
@@ -43,7 +43,7 @@ declare_clippy_lint! {
     /// ```
     /// could be
     /// ```rust
-    /// struct Foo {}
+    /// struct Foo;
     /// impl Foo {
     ///     fn new() -> Self {
     ///         Self {}
diff --git a/tests/ui-toml/struct_excessive_bools/test.rs b/tests/ui-toml/struct_excessive_bools/test.rs
index 242984680e1..32dd80246fa 100644
--- a/tests/ui-toml/struct_excessive_bools/test.rs
+++ b/tests/ui-toml/struct_excessive_bools/test.rs
@@ -4,6 +4,6 @@ struct S {
     a: bool,
 }
 
-struct Foo {}
+struct Foo;
 
 fn main() {}
diff --git a/tests/ui/case_sensitive_file_extension_comparisons.rs b/tests/ui/case_sensitive_file_extension_comparisons.rs
index 68719c2bc6d..0d65071af15 100644
--- a/tests/ui/case_sensitive_file_extension_comparisons.rs
+++ b/tests/ui/case_sensitive_file_extension_comparisons.rs
@@ -2,7 +2,7 @@
 
 use std::string::String;
 
-struct TestStruct {}
+struct TestStruct;
 
 impl TestStruct {
     fn ends_with(self, arg: &str) {}
diff --git a/tests/ui/crashes/ice-2774.rs b/tests/ui/crashes/ice-2774.rs
index d44b0fae820..88cfa1f923c 100644
--- a/tests/ui/crashes/ice-2774.rs
+++ b/tests/ui/crashes/ice-2774.rs
@@ -8,7 +8,7 @@ pub struct Bar {
 }
 
 #[derive(Eq, PartialEq, Debug, Hash)]
-pub struct Foo {}
+pub struct Foo;
 
 #[allow(clippy::implicit_hasher)]
 // This should not cause a "cannot relate bound region" ICE.
diff --git a/tests/ui/crashes/ice-6179.rs b/tests/ui/crashes/ice-6179.rs
index 8d9a1af8ff1..4fe92d356c4 100644
--- a/tests/ui/crashes/ice-6179.rs
+++ b/tests/ui/crashes/ice-6179.rs
@@ -4,7 +4,7 @@
 #![warn(clippy::use_self)]
 #![allow(dead_code)]
 
-struct Foo {}
+struct Foo;
 
 impl Foo {
     fn new() -> Self {
diff --git a/tests/ui/crashes/ice-6792.rs b/tests/ui/crashes/ice-6792.rs
index 0e2ab1a39b8..9cbafc716b5 100644
--- a/tests/ui/crashes/ice-6792.rs
+++ b/tests/ui/crashes/ice-6792.rs
@@ -7,7 +7,7 @@ trait Trait {
     fn broken() -> Self::Ty;
 }
 
-struct Foo {}
+struct Foo;
 
 impl Trait for Foo {
     type Ty = Foo;
diff --git a/tests/ui/crashes/needless_lifetimes_impl_trait.rs b/tests/ui/crashes/needless_lifetimes_impl_trait.rs
index 676564b2445..376ff97ba60 100644
--- a/tests/ui/crashes/needless_lifetimes_impl_trait.rs
+++ b/tests/ui/crashes/needless_lifetimes_impl_trait.rs
@@ -3,7 +3,7 @@
 
 trait Foo {}
 
-struct Bar {}
+struct Bar;
 
 struct Baz<'a> {
     bar: &'a Bar,
diff --git a/tests/ui/crashes/regressions.rs b/tests/ui/crashes/regressions.rs
index a41bcb33b44..6f9d98bbfe7 100644
--- a/tests/ui/crashes/regressions.rs
+++ b/tests/ui/crashes/regressions.rs
@@ -6,6 +6,6 @@ pub fn foo(bar: *const u8) {
 
 // Regression test for https://github.com/rust-lang/rust-clippy/issues/4917
 /// <foo
-struct A {}
+struct A;
 
 fn main() {}
diff --git a/tests/ui/default_numeric_fallback_f64.fixed b/tests/ui/default_numeric_fallback_f64.fixed
index 1b0e7544e79..e0b4a2f6942 100644
--- a/tests/ui/default_numeric_fallback_f64.fixed
+++ b/tests/ui/default_numeric_fallback_f64.fixed
@@ -134,7 +134,7 @@ mod enum_ctor {
 }
 
 mod method_calls {
-    struct StructForMethodCallTest {}
+    struct StructForMethodCallTest;
 
     impl StructForMethodCallTest {
         fn concrete_arg(&self, f: f64) {}
diff --git a/tests/ui/default_numeric_fallback_f64.rs b/tests/ui/default_numeric_fallback_f64.rs
index e9687777bbd..50bbb6eec6c 100644
--- a/tests/ui/default_numeric_fallback_f64.rs
+++ b/tests/ui/default_numeric_fallback_f64.rs
@@ -134,7 +134,7 @@ mod enum_ctor {
 }
 
 mod method_calls {
-    struct StructForMethodCallTest {}
+    struct StructForMethodCallTest;
 
     impl StructForMethodCallTest {
         fn concrete_arg(&self, f: f64) {}
diff --git a/tests/ui/default_numeric_fallback_i32.fixed b/tests/ui/default_numeric_fallback_i32.fixed
index 55c082fcb19..bded9e2c0e8 100644
--- a/tests/ui/default_numeric_fallback_i32.fixed
+++ b/tests/ui/default_numeric_fallback_i32.fixed
@@ -133,7 +133,7 @@ mod enum_ctor {
 }
 
 mod method_calls {
-    struct StructForMethodCallTest {}
+    struct StructForMethodCallTest;
 
     impl StructForMethodCallTest {
         fn concrete_arg(&self, x: i32) {}
diff --git a/tests/ui/default_numeric_fallback_i32.rs b/tests/ui/default_numeric_fallback_i32.rs
index e0a4828ce9f..3fceefa551c 100644
--- a/tests/ui/default_numeric_fallback_i32.rs
+++ b/tests/ui/default_numeric_fallback_i32.rs
@@ -133,7 +133,7 @@ mod enum_ctor {
 }
 
 mod method_calls {
-    struct StructForMethodCallTest {}
+    struct StructForMethodCallTest;
 
     impl StructForMethodCallTest {
         fn concrete_arg(&self, x: i32) {}
diff --git a/tests/ui/drop_forget_copy.rs b/tests/ui/drop_forget_copy.rs
index 9ddd6d64701..7c7a9ecff67 100644
--- a/tests/ui/drop_forget_copy.rs
+++ b/tests/ui/drop_forget_copy.rs
@@ -5,7 +5,7 @@ use std::mem::{drop, forget};
 use std::vec::Vec;
 
 #[derive(Copy, Clone)]
-struct SomeStruct {}
+struct SomeStruct;
 
 struct AnotherStruct {
     x: u8,
diff --git a/tests/ui/fn_params_excessive_bools.rs b/tests/ui/fn_params_excessive_bools.rs
index 1442ee08e75..f805bcc9ba8 100644
--- a/tests/ui/fn_params_excessive_bools.rs
+++ b/tests/ui/fn_params_excessive_bools.rs
@@ -20,7 +20,7 @@ fn h(_: bool, _: bool, _: bool) {}
 fn e(_: S, _: S, _: Box<S>, _: Vec<u32>) {}
 fn t(_: S, _: S, _: Box<S>, _: Vec<u32>, _: bool, _: bool, _: bool, _: bool) {}
 
-struct S {}
+struct S;
 trait Trait {
     fn f(_: bool, _: bool, _: bool, _: bool);
     fn g(_: bool, _: bool, _: bool, _: Vec<u32>);
diff --git a/tests/ui/implicit_clone.rs b/tests/ui/implicit_clone.rs
index 639fecb8927..2549c9f32f9 100644
--- a/tests/ui/implicit_clone.rs
+++ b/tests/ui/implicit_clone.rs
@@ -30,7 +30,7 @@ where
 }
 
 #[derive(Copy, Clone)]
-struct Kitten {}
+struct Kitten;
 impl Kitten {
     // badly named method
     fn to_vec(self) -> Kitten {
@@ -44,7 +44,7 @@ impl Borrow<BorrowedKitten> for Kitten {
     }
 }
 
-struct BorrowedKitten {}
+struct BorrowedKitten;
 impl ToOwned for BorrowedKitten {
     type Owned = Kitten;
     fn to_owned(&self) -> Kitten {
diff --git a/tests/ui/iter_nth_zero.fixed b/tests/ui/iter_nth_zero.fixed
index b54147c94d1..f23671c26e4 100644
--- a/tests/ui/iter_nth_zero.fixed
+++ b/tests/ui/iter_nth_zero.fixed
@@ -3,7 +3,7 @@
 #![warn(clippy::iter_nth_zero)]
 use std::collections::HashSet;
 
-struct Foo {}
+struct Foo;
 
 impl Foo {
     fn nth(&self, index: usize) -> usize {
diff --git a/tests/ui/iter_nth_zero.rs b/tests/ui/iter_nth_zero.rs
index b92c7d18adb..7c968d49845 100644
--- a/tests/ui/iter_nth_zero.rs
+++ b/tests/ui/iter_nth_zero.rs
@@ -3,7 +3,7 @@
 #![warn(clippy::iter_nth_zero)]
 use std::collections::HashSet;
 
-struct Foo {}
+struct Foo;
 
 impl Foo {
     fn nth(&self, index: usize) -> usize {
diff --git a/tests/ui/large_types_passed_by_value.rs b/tests/ui/large_types_passed_by_value.rs
index e4a2e9df4d7..7601b5c66fa 100644
--- a/tests/ui/large_types_passed_by_value.rs
+++ b/tests/ui/large_types_passed_by_value.rs
@@ -37,7 +37,7 @@ pub trait PubLargeTypeDevourer {
     fn devoure_array_in_public(&self, array: [u8; 6666]);
 }
 
-struct S {}
+struct S;
 impl LargeTypeDevourer for S {
     fn devoure_array(&self, array: [u8; 6666]) {
         todo!();
diff --git a/tests/ui/let_and_return.rs b/tests/ui/let_and_return.rs
index e3561863c1e..bb162adc9ad 100644
--- a/tests/ui/let_and_return.rs
+++ b/tests/ui/let_and_return.rs
@@ -88,7 +88,7 @@ mod no_lint_if_stmt_borrows {
             ret
         }
 
-        struct Bar {}
+        struct Bar;
 
         impl Bar {
             fn new() -> Self {
diff --git a/tests/ui/let_underscore_must_use.rs b/tests/ui/let_underscore_must_use.rs
index a842e872a37..1edb77c748b 100644
--- a/tests/ui/let_underscore_must_use.rs
+++ b/tests/ui/let_underscore_must_use.rs
@@ -26,7 +26,7 @@ fn h() -> u32 {
     0
 }
 
-struct S {}
+struct S;
 
 impl S {
     #[must_use]
diff --git a/tests/ui/manual_async_fn.fixed b/tests/ui/manual_async_fn.fixed
index 136cc96be70..b7e46a4a8cc 100644
--- a/tests/ui/manual_async_fn.fixed
+++ b/tests/ui/manual_async_fn.fixed
@@ -38,7 +38,7 @@ async fn already_async() -> impl Future<Output = i32> {
     async { 42 }
 }
 
-struct S {}
+struct S;
 impl S {
     async fn inh_fut() -> i32 {
         // NOTE: this code is here just to check that the indentation is correct in the suggested fix
diff --git a/tests/ui/manual_async_fn.rs b/tests/ui/manual_async_fn.rs
index ddc453ffdb7..b05429da662 100644
--- a/tests/ui/manual_async_fn.rs
+++ b/tests/ui/manual_async_fn.rs
@@ -52,7 +52,7 @@ async fn already_async() -> impl Future<Output = i32> {
     async { 42 }
 }
 
-struct S {}
+struct S;
 impl S {
     fn inh_fut() -> impl Future<Output = i32> {
         async {
diff --git a/tests/ui/manual_unwrap_or.fixed b/tests/ui/manual_unwrap_or.fixed
index 05d6c56f2ac..7d68978216c 100644
--- a/tests/ui/manual_unwrap_or.fixed
+++ b/tests/ui/manual_unwrap_or.fixed
@@ -78,7 +78,7 @@ fn result_unwrap_or() {
     (Ok(1) as Result<i32, &str>).unwrap_or(42);
 
     // method call case, suggestion must not surround Result expr `s.method()` with parentheses
-    struct S {}
+    struct S;
     impl S {
         fn method(self) -> Option<i32> {
             Some(42)
diff --git a/tests/ui/manual_unwrap_or.rs b/tests/ui/manual_unwrap_or.rs
index 09f62c69b71..b937fe6f977 100644
--- a/tests/ui/manual_unwrap_or.rs
+++ b/tests/ui/manual_unwrap_or.rs
@@ -102,7 +102,7 @@ fn result_unwrap_or() {
     };
 
     // method call case, suggestion must not surround Result expr `s.method()` with parentheses
-    struct S {}
+    struct S;
     impl S {
         fn method(self) -> Option<i32> {
             Some(42)
diff --git a/tests/ui/map_unit_fn.rs b/tests/ui/map_unit_fn.rs
index 9a74da4e3b8..e7f07b50f3a 100644
--- a/tests/ui/map_unit_fn.rs
+++ b/tests/ui/map_unit_fn.rs
@@ -1,5 +1,5 @@
 #![allow(unused)]
-struct Mappable {}
+struct Mappable;
 
 impl Mappable {
     pub fn map(&self) {}
diff --git a/tests/ui/min_rust_version_attr.rs b/tests/ui/min_rust_version_attr.rs
index c5f221220ec..72e9bf9eb36 100644
--- a/tests/ui/min_rust_version_attr.rs
+++ b/tests/ui/min_rust_version_attr.rs
@@ -99,7 +99,7 @@ pub fn manual_range_contains() {
 }
 
 pub fn use_self() {
-    struct Foo {}
+    struct Foo;
 
     impl Foo {
         fn new() -> Foo {
diff --git a/tests/ui/missing_inline.rs b/tests/ui/missing_inline.rs
index b73b24b8e0a..07f8e3888c9 100644
--- a/tests/ui/missing_inline.rs
+++ b/tests/ui/missing_inline.rs
@@ -7,8 +7,8 @@
 type Typedef = String;
 pub type PubTypedef = String;
 
-struct Foo {} // ok
-pub struct PubFoo {} // ok
+struct Foo; // ok
+pub struct PubFoo; // ok
 enum FooE {} // ok
 pub enum PubFooE {} // ok
 
@@ -63,4 +63,4 @@ impl PubFoo {
 
 // do not lint this since users cannot control the external code
 #[derive(Debug)]
-pub struct S {}
+pub struct S;
diff --git a/tests/ui/module_name_repetitions.rs b/tests/ui/module_name_repetitions.rs
index f5908cb5701..ebaa77cc283 100644
--- a/tests/ui/module_name_repetitions.rs
+++ b/tests/ui/module_name_repetitions.rs
@@ -7,7 +7,7 @@ mod foo {
     pub fn foo() {}
     pub fn foo_bar() {}
     pub fn bar_foo() {}
-    pub struct FooCake {}
+    pub struct FooCake;
     pub enum CakeFoo {}
     pub struct Foo7Bar;
 
diff --git a/tests/ui/needless_arbitrary_self_type_unfixable.rs b/tests/ui/needless_arbitrary_self_type_unfixable.rs
index ad0d694a217..02b43cce2bd 100644
--- a/tests/ui/needless_arbitrary_self_type_unfixable.rs
+++ b/tests/ui/needless_arbitrary_self_type_unfixable.rs
@@ -14,7 +14,7 @@ mod issue_6089 {
                 fn test(self: &Self);
             }
 
-            struct S1 {}
+            struct S1;
 
             impl T1 for S1 {
                 fn test(self: &Self) {}
@@ -32,7 +32,7 @@ mod issue_6089 {
         fn call_with_mut_self(&mut self);
     }
 
-    struct S2 {}
+    struct S2;
 
     // The method's signature will be expanded to:
     //  fn call_with_mut_self<'life0>(self: &'life0 mut Self) {}
diff --git a/tests/ui/needless_lifetimes.rs b/tests/ui/needless_lifetimes.rs
index f3eafe8e927..1456204ca86 100644
--- a/tests/ui/needless_lifetimes.rs
+++ b/tests/ui/needless_lifetimes.rs
@@ -268,7 +268,7 @@ mod issue4291 {
 
 mod issue2944 {
     trait Foo {}
-    struct Bar {}
+    struct Bar;
     struct Baz<'a> {
         bar: &'a Bar,
     }
diff --git a/tests/ui/no_effect.rs b/tests/ui/no_effect.rs
index 5427c88faf3..0a67fb72044 100644
--- a/tests/ui/no_effect.rs
+++ b/tests/ui/no_effect.rs
@@ -68,7 +68,7 @@ impl FnOnce<(&str,)> for GreetStruct1 {
     }
 }
 
-struct GreetStruct2();
+struct GreetStruct2;
 
 impl FnOnce<(&str,)> for GreetStruct2 {
     type Output = ();
@@ -78,7 +78,7 @@ impl FnOnce<(&str,)> for GreetStruct2 {
     }
 }
 
-struct GreetStruct3 {}
+struct GreetStruct3;
 
 impl FnOnce<(&str,)> for GreetStruct3 {
     type Output = ();
diff --git a/tests/ui/or_then_unwrap.fixed b/tests/ui/or_then_unwrap.fixed
index 27d4b795a5e..6e0d5a87f68 100644
--- a/tests/ui/or_then_unwrap.fixed
+++ b/tests/ui/or_then_unwrap.fixed
@@ -3,7 +3,7 @@
 #![warn(clippy::or_then_unwrap)]
 #![allow(clippy::map_identity)]
 
-struct SomeStruct {}
+struct SomeStruct;
 impl SomeStruct {
     fn or(self, _: Option<Self>) -> Self {
         self
@@ -11,7 +11,7 @@ impl SomeStruct {
     fn unwrap(&self) {}
 }
 
-struct SomeOtherStruct {}
+struct SomeOtherStruct;
 impl SomeOtherStruct {
     fn or(self) -> Self {
         self
diff --git a/tests/ui/or_then_unwrap.rs b/tests/ui/or_then_unwrap.rs
index 0dab5ae2f1c..e406a71d46d 100644
--- a/tests/ui/or_then_unwrap.rs
+++ b/tests/ui/or_then_unwrap.rs
@@ -3,7 +3,7 @@
 #![warn(clippy::or_then_unwrap)]
 #![allow(clippy::map_identity)]
 
-struct SomeStruct {}
+struct SomeStruct;
 impl SomeStruct {
     fn or(self, _: Option<Self>) -> Self {
         self
@@ -11,7 +11,7 @@ impl SomeStruct {
     fn unwrap(&self) {}
 }
 
-struct SomeOtherStruct {}
+struct SomeOtherStruct;
 impl SomeOtherStruct {
     fn or(self) -> Self {
         self
diff --git a/tests/ui/ptr_arg.rs b/tests/ui/ptr_arg.rs
index 03dd938a233..814bbc7af71 100644
--- a/tests/ui/ptr_arg.rs
+++ b/tests/ui/ptr_arg.rs
@@ -112,7 +112,7 @@ mod issue_5644 {
     ) {
     }
 
-    struct S {}
+    struct S;
     impl S {
         fn allowed(
             #[allow(clippy::ptr_arg)] _v: &Vec<u32>,
diff --git a/tests/ui/recursive_format_impl.rs b/tests/ui/recursive_format_impl.rs
index 9241bf7ed74..f72fc77ab99 100644
--- a/tests/ui/recursive_format_impl.rs
+++ b/tests/ui/recursive_format_impl.rs
@@ -66,7 +66,7 @@ impl std::fmt::Display for D {
 
 // Check for use of self as Display, in Display impl
 // Triggers on direct use of self
-struct G {}
+struct G;
 
 impl std::fmt::Display for G {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
@@ -75,7 +75,7 @@ impl std::fmt::Display for G {
 }
 
 // Triggers on reference to self
-struct H {}
+struct H;
 
 impl std::fmt::Display for H {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
@@ -90,7 +90,7 @@ impl std::fmt::Debug for H {
 }
 
 // Triggers on multiple reference to self
-struct H2 {}
+struct H2;
 
 impl std::fmt::Display for H2 {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
@@ -99,7 +99,7 @@ impl std::fmt::Display for H2 {
 }
 
 // Doesn't trigger on correct deref
-struct I {}
+struct I;
 
 impl std::ops::Deref for I {
     type Target = str;
@@ -122,7 +122,7 @@ impl std::fmt::Debug for I {
 }
 
 // Doesn't trigger on multiple correct deref
-struct I2 {}
+struct I2;
 
 impl std::ops::Deref for I2 {
     type Target = str;
@@ -139,7 +139,7 @@ impl std::fmt::Display for I2 {
 }
 
 // Doesn't trigger on multiple correct deref
-struct I3 {}
+struct I3;
 
 impl std::ops::Deref for I3 {
     type Target = str;
@@ -156,7 +156,7 @@ impl std::fmt::Display for I3 {
 }
 
 // Does trigger when deref resolves to self
-struct J {}
+struct J;
 
 impl std::ops::Deref for J {
     type Target = str;
@@ -178,7 +178,7 @@ impl std::fmt::Debug for J {
     }
 }
 
-struct J2 {}
+struct J2;
 
 impl std::ops::Deref for J2 {
     type Target = str;
@@ -194,7 +194,7 @@ impl std::fmt::Display for J2 {
     }
 }
 
-struct J3 {}
+struct J3;
 
 impl std::ops::Deref for J3 {
     type Target = str;
@@ -210,7 +210,7 @@ impl std::fmt::Display for J3 {
     }
 }
 
-struct J4 {}
+struct J4;
 
 impl std::ops::Deref for J4 {
     type Target = str;
@@ -227,7 +227,7 @@ impl std::fmt::Display for J4 {
 }
 
 // Doesn't trigger on Debug from Display
-struct K {}
+struct K;
 
 impl std::fmt::Debug for K {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
@@ -242,7 +242,7 @@ impl std::fmt::Display for K {
 }
 
 // Doesn't trigger on Display from Debug
-struct K2 {}
+struct K2;
 
 impl std::fmt::Debug for K2 {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
diff --git a/tests/ui/redundant_allocation.rs b/tests/ui/redundant_allocation.rs
index 52fbc91e325..80f94e5f3cb 100644
--- a/tests/ui/redundant_allocation.rs
+++ b/tests/ui/redundant_allocation.rs
@@ -3,7 +3,7 @@
 #![allow(clippy::blacklisted_name, unused_variables, dead_code)]
 #![allow(unused_imports)]
 
-pub struct MyStruct {}
+pub struct MyStruct;
 
 pub struct SubT<T> {
     foo: T,
diff --git a/tests/ui/redundant_allocation_fixable.fixed b/tests/ui/redundant_allocation_fixable.fixed
index ef089b25f47..e7ed84731c0 100644
--- a/tests/ui/redundant_allocation_fixable.fixed
+++ b/tests/ui/redundant_allocation_fixable.fixed
@@ -4,7 +4,7 @@
 #![allow(clippy::blacklisted_name, unused_variables, dead_code)]
 #![allow(unused_imports)]
 
-pub struct MyStruct {}
+pub struct MyStruct;
 
 pub struct SubT<T> {
     foo: T,
diff --git a/tests/ui/redundant_static_lifetimes.fixed b/tests/ui/redundant_static_lifetimes.fixed
index 921249606ad..acc8f1e25b6 100644
--- a/tests/ui/redundant_static_lifetimes.fixed
+++ b/tests/ui/redundant_static_lifetimes.fixed
@@ -3,7 +3,7 @@
 #![allow(unused)]
 
 #[derive(Debug)]
-struct Foo {}
+struct Foo;
 
 const VAR_ONE: &str = "Test constant #1"; // ERROR Consider removing 'static.
 
diff --git a/tests/ui/redundant_static_lifetimes.rs b/tests/ui/redundant_static_lifetimes.rs
index 4d4b249d076..f2f0f78659c 100644
--- a/tests/ui/redundant_static_lifetimes.rs
+++ b/tests/ui/redundant_static_lifetimes.rs
@@ -3,7 +3,7 @@
 #![allow(unused)]
 
 #[derive(Debug)]
-struct Foo {}
+struct Foo;
 
 const VAR_ONE: &'static str = "Test constant #1"; // ERROR Consider removing 'static.
 
diff --git a/tests/ui/same_item_push.rs b/tests/ui/same_item_push.rs
index 9d420ec672a..99964f0de07 100644
--- a/tests/ui/same_item_push.rs
+++ b/tests/ui/same_item_push.rs
@@ -120,7 +120,7 @@ fn main() {
     }
     // Fix #5979
     #[derive(Clone)]
-    struct S {}
+    struct S;
 
     trait T {}
     impl T for S {}
diff --git a/tests/ui/trait_duplication_in_bounds.rs b/tests/ui/trait_duplication_in_bounds.rs
index 21de19a2601..f5ca91143af 100644
--- a/tests/ui/trait_duplication_in_bounds.rs
+++ b/tests/ui/trait_duplication_in_bounds.rs
@@ -62,7 +62,7 @@ trait BadTrait: Default + Clone {
 }
 
 #[derive(Default, Clone)]
-struct Life {}
+struct Life;
 
 impl T for Life {
     // this should not warn
@@ -85,7 +85,7 @@ trait Iter: Iterator {
     }
 }
 
-struct Foo {}
+struct Foo;
 
 trait FooIter: Iterator<Item = Foo> {
     fn bar()
diff --git a/tests/ui/unit_like_struct_brackets.fixed b/tests/ui/unit_like_struct_brackets.fixed
index a69c310e973..e6cf4a0c0b4 100644
--- a/tests/ui/unit_like_struct_brackets.fixed
+++ b/tests/ui/unit_like_struct_brackets.fixed
@@ -2,12 +2,13 @@
 #![warn(clippy::unit_like_struct_brackets)]
 #![allow(dead_code)]
 
-pub struct MyEmptyStruct;             // should trigger lint
-struct MyEmptyTupleStruct;            // should trigger lint
+pub struct MyEmptyStruct; // should trigger lint
+struct MyEmptyTupleStruct; // should trigger lint
 
-struct MyStruct {                       // should not trigger lint
+struct MyStruct {
+    // should not trigger lint
     field: u8,
 }
-struct MyTupleStruct(usize, String);    // should not trigger lint
+struct MyTupleStruct(usize, String); // should not trigger lint
 
 fn main() {}
diff --git a/tests/ui/unit_like_struct_brackets.rs b/tests/ui/unit_like_struct_brackets.rs
index 8697a24f1d7..306e4c207d8 100644
--- a/tests/ui/unit_like_struct_brackets.rs
+++ b/tests/ui/unit_like_struct_brackets.rs
@@ -2,12 +2,13 @@
 #![warn(clippy::unit_like_struct_brackets)]
 #![allow(dead_code)]
 
-pub struct MyEmptyStruct {}             // should trigger lint
-struct MyEmptyTupleStruct();            // should trigger lint
+pub struct MyEmptyStruct {} // should trigger lint
+struct MyEmptyTupleStruct(); // should trigger lint
 
-struct MyStruct {                       // should not trigger lint
+struct MyStruct {
+    // should not trigger lint
     field: u8,
 }
-struct MyTupleStruct(usize, String);    // should not trigger lint
+struct MyTupleStruct(usize, String); // should not trigger lint
 
 fn main() {}
diff --git a/tests/ui/unsafe_derive_deserialize.rs b/tests/ui/unsafe_derive_deserialize.rs
index 690d705573d..bafca91917a 100644
--- a/tests/ui/unsafe_derive_deserialize.rs
+++ b/tests/ui/unsafe_derive_deserialize.rs
@@ -6,7 +6,7 @@ extern crate serde;
 use serde::Deserialize;
 
 #[derive(Deserialize)]
-pub struct A {}
+pub struct A;
 impl A {
     pub unsafe fn new(_a: i32, _b: i32) -> Self {
         Self {}
@@ -14,13 +14,13 @@ impl A {
 }
 
 #[derive(Deserialize)]
-pub struct B {}
+pub struct B;
 impl B {
     pub unsafe fn unsafe_method(&self) {}
 }
 
 #[derive(Deserialize)]
-pub struct C {}
+pub struct C;
 impl C {
     pub fn unsafe_block(&self) {
         unsafe {}
@@ -28,7 +28,7 @@ impl C {
 }
 
 #[derive(Deserialize)]
-pub struct D {}
+pub struct D;
 impl D {
     pub fn inner_unsafe_fn(&self) {
         unsafe fn inner() {}
@@ -36,7 +36,7 @@ impl D {
 }
 
 // Does not derive `Deserialize`, should be ignored
-pub struct E {}
+pub struct E;
 impl E {
     pub unsafe fn new(_a: i32, _b: i32) -> Self {
         Self {}
@@ -55,12 +55,12 @@ impl E {
 
 // Does not have methods using `unsafe`, should be ignored
 #[derive(Deserialize)]
-pub struct F {}
+pub struct F;
 
 // Check that we honor the `allow` attribute on the ADT
 #[allow(clippy::unsafe_derive_deserialize)]
 #[derive(Deserialize)]
-pub struct G {}
+pub struct G;
 impl G {
     pub fn unsafe_block(&self) {
         unsafe {}
diff --git a/tests/ui/unsafe_removed_from_name.rs b/tests/ui/unsafe_removed_from_name.rs
index a1f616733bd..cde4e96d668 100644
--- a/tests/ui/unsafe_removed_from_name.rs
+++ b/tests/ui/unsafe_removed_from_name.rs
@@ -14,8 +14,8 @@ use std::cell::UnsafeCell as Dangerunsafe;
 use std::cell::UnsafeCell as Bombsawayunsafe;
 
 mod mod_with_some_unsafe_things {
-    pub struct Safe {}
-    pub struct Unsafe {}
+    pub struct Safe;
+    pub struct Unsafe;
 }
 
 use mod_with_some_unsafe_things::Unsafe as LieAboutModSafety;
diff --git a/tests/ui/unused_self.rs b/tests/ui/unused_self.rs
index 7a4bbdda1ab..08bf58fec7c 100644
--- a/tests/ui/unused_self.rs
+++ b/tests/ui/unused_self.rs
@@ -5,7 +5,7 @@ mod unused_self {
     use std::pin::Pin;
     use std::sync::{Arc, Mutex};
 
-    struct A {}
+    struct A;
 
     impl A {
         fn unused_self_move(self) {}
@@ -27,7 +27,7 @@ mod unused_self {
 }
 
 mod unused_self_allow {
-    struct A {}
+    struct A;
 
     impl A {
         // shouldn't trigger
@@ -35,7 +35,7 @@ mod unused_self_allow {
         fn unused_self_move(self) {}
     }
 
-    struct B {}
+    struct B;
 
     // shouldn't trigger
     #[allow(clippy::unused_self)]
@@ -43,7 +43,7 @@ mod unused_self_allow {
         fn unused_self_move(self) {}
     }
 
-    struct C {}
+    struct C;
 
     #[allow(clippy::unused_self)]
     impl C {
@@ -120,7 +120,7 @@ mod used_self {
 mod not_applicable {
     use std::fmt;
 
-    struct A {}
+    struct A;
 
     impl fmt::Debug for A {
         fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
diff --git a/tests/ui/use_self.fixed b/tests/ui/use_self.fixed
index 9d216f56ae6..3e62ffe74fe 100644
--- a/tests/ui/use_self.fixed
+++ b/tests/ui/use_self.fixed
@@ -16,7 +16,7 @@ extern crate proc_macro_derive;
 fn main() {}
 
 mod use_self {
-    struct Foo {}
+    struct Foo;
 
     impl Foo {
         fn new() -> Self {
@@ -35,7 +35,7 @@ mod use_self {
 }
 
 mod better {
-    struct Foo {}
+    struct Foo;
 
     impl Foo {
         fn new() -> Self {
@@ -123,7 +123,7 @@ mod macros {
         };
     }
 
-    struct Foo {}
+    struct Foo;
 
     impl Foo {
         use_self_expand!(); // Should not lint in local macros
@@ -134,7 +134,7 @@ mod macros {
 }
 
 mod nesting {
-    struct Foo {}
+    struct Foo;
     impl Foo {
         fn foo() {
             #[allow(unused_imports)]
@@ -209,7 +209,7 @@ mod issue3410 {
 #[allow(clippy::no_effect, path_statements)]
 mod rustfix {
     mod nested {
-        pub struct A {}
+        pub struct A;
     }
 
     impl nested::A {
@@ -227,7 +227,7 @@ mod rustfix {
 }
 
 mod issue3567 {
-    struct TestStruct {}
+    struct TestStruct;
     impl TestStruct {
         fn from_something() -> Self {
             Self {}
@@ -248,7 +248,7 @@ mod issue3567 {
 mod paths_created_by_lowering {
     use std::ops::Range;
 
-    struct S {}
+    struct S;
 
     impl S {
         const A: usize = 0;
@@ -382,7 +382,7 @@ mod issue4305 {
 }
 
 mod lint_at_item_level {
-    struct Foo {}
+    struct Foo;
 
     #[allow(clippy::use_self)]
     impl Foo {
@@ -400,7 +400,7 @@ mod lint_at_item_level {
 }
 
 mod lint_at_impl_item_level {
-    struct Foo {}
+    struct Foo;
 
     impl Foo {
         #[allow(clippy::use_self)]
@@ -433,8 +433,8 @@ mod issue4734 {
 mod nested_paths {
     use std::convert::Into;
     mod submod {
-        pub struct B {}
-        pub struct C {}
+        pub struct B;
+        pub struct C;
 
         impl Into<C> for B {
             fn into(self) -> C {
diff --git a/tests/ui/use_self.rs b/tests/ui/use_self.rs
index 5f604fe25e4..da2faddee12 100644
--- a/tests/ui/use_self.rs
+++ b/tests/ui/use_self.rs
@@ -16,7 +16,7 @@ extern crate proc_macro_derive;
 fn main() {}
 
 mod use_self {
-    struct Foo {}
+    struct Foo;
 
     impl Foo {
         fn new() -> Foo {
@@ -35,7 +35,7 @@ mod use_self {
 }
 
 mod better {
-    struct Foo {}
+    struct Foo;
 
     impl Foo {
         fn new() -> Self {
@@ -123,7 +123,7 @@ mod macros {
         };
     }
 
-    struct Foo {}
+    struct Foo;
 
     impl Foo {
         use_self_expand!(); // Should not lint in local macros
@@ -134,7 +134,7 @@ mod macros {
 }
 
 mod nesting {
-    struct Foo {}
+    struct Foo;
     impl Foo {
         fn foo() {
             #[allow(unused_imports)]
@@ -209,7 +209,7 @@ mod issue3410 {
 #[allow(clippy::no_effect, path_statements)]
 mod rustfix {
     mod nested {
-        pub struct A {}
+        pub struct A;
     }
 
     impl nested::A {
@@ -227,7 +227,7 @@ mod rustfix {
 }
 
 mod issue3567 {
-    struct TestStruct {}
+    struct TestStruct;
     impl TestStruct {
         fn from_something() -> Self {
             Self {}
@@ -248,7 +248,7 @@ mod issue3567 {
 mod paths_created_by_lowering {
     use std::ops::Range;
 
-    struct S {}
+    struct S;
 
     impl S {
         const A: usize = 0;
@@ -382,7 +382,7 @@ mod issue4305 {
 }
 
 mod lint_at_item_level {
-    struct Foo {}
+    struct Foo;
 
     #[allow(clippy::use_self)]
     impl Foo {
@@ -400,7 +400,7 @@ mod lint_at_item_level {
 }
 
 mod lint_at_impl_item_level {
-    struct Foo {}
+    struct Foo;
 
     impl Foo {
         #[allow(clippy::use_self)]
@@ -433,8 +433,8 @@ mod issue4734 {
 mod nested_paths {
     use std::convert::Into;
     mod submod {
-        pub struct B {}
-        pub struct C {}
+        pub struct B;
+        pub struct C;
 
         impl Into<C> for B {
             fn into(self) -> C {
diff --git a/tests/ui/useless_attribute.fixed b/tests/ui/useless_attribute.fixed
index a5fcde768f1..ce58a80347b 100644
--- a/tests/ui/useless_attribute.fixed
+++ b/tests/ui/useless_attribute.fixed
@@ -42,7 +42,7 @@ mod a {
     mod b {
         #[allow(dead_code)]
         #[allow(unreachable_pub)]
-        pub struct C {}
+        pub struct C;
     }
 
     #[allow(unreachable_pub)]
diff --git a/tests/ui/useless_attribute.rs b/tests/ui/useless_attribute.rs
index 0396d39e3d5..c82bb9ba07f 100644
--- a/tests/ui/useless_attribute.rs
+++ b/tests/ui/useless_attribute.rs
@@ -42,7 +42,7 @@ mod a {
     mod b {
         #[allow(dead_code)]
         #[allow(unreachable_pub)]
-        pub struct C {}
+        pub struct C;
     }
 
     #[allow(unreachable_pub)]
-- 
cgit 1.4.1-3-g733a5


From 1a5ff38f92971141d2f1d39cd0ddc80188f746de Mon Sep 17 00:00:00 2001
From: Max Baumann <max@bmn.dev>
Date: Sun, 27 Mar 2022 15:33:31 +0200
Subject: fix godfood test

---
 clippy_lints/src/unit_like_struct_brackets.rs | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unit_like_struct_brackets.rs b/clippy_lints/src/unit_like_struct_brackets.rs
index 0eeb765be85..c4623df46bd 100644
--- a/clippy_lints/src/unit_like_struct_brackets.rs
+++ b/clippy_lints/src/unit_like_struct_brackets.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use rustc_ast::ast::*;
+use rustc_ast::ast::{Item, ItemKind, VariantData};
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -46,8 +46,7 @@ impl EarlyLintPass for UnitLikeStructBrackets {
 
 fn has_no_fields(var_data: &VariantData) -> bool {
     match var_data {
-        VariantData::Struct(defs, _) => defs.is_empty(),
-        VariantData::Tuple(defs, _) => defs.is_empty(),
+        VariantData::Struct(defs, _) | VariantData::Tuple(defs, _) => defs.is_empty(),
         VariantData::Unit(_) => false,
     }
 }
-- 
cgit 1.4.1-3-g733a5


From 7192297c2878b22e44ca5bc58f5f7544b33cdf4a Mon Sep 17 00:00:00 2001
From: Max Baumann <max@bmn.dev>
Date: Sun, 27 Mar 2022 19:58:23 +0200
Subject: additional checks for conditionally compiled code

---
 clippy_lints/src/unit_like_struct_brackets.rs | 56 ++++++++++++++++++++++++---
 tests/ui/unit_like_struct_brackets.fixed      | 11 +++++-
 tests/ui/unit_like_struct_brackets.rs         | 11 +++++-
 3 files changed, 70 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unit_like_struct_brackets.rs b/clippy_lints/src/unit_like_struct_brackets.rs
index c4623df46bd..cb6e2a44afb 100644
--- a/clippy_lints/src/unit_like_struct_brackets.rs
+++ b/clippy_lints/src/unit_like_struct_brackets.rs
@@ -1,8 +1,10 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::{diagnostics::span_lint_and_sugg, source::snippet_opt};
 use rustc_ast::ast::{Item, ItemKind, VariantData};
 use rustc_errors::Applicability;
+use rustc_lexer::TokenKind;
 use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::Span;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -28,9 +30,9 @@ declare_lint_pass!(UnitLikeStructBrackets => [UNIT_LIKE_STRUCT_BRACKETS]);
 
 impl EarlyLintPass for UnitLikeStructBrackets {
     fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {
-        if let ItemKind::Struct(var_data, _) = &item.kind && has_no_fields(var_data) {
-            let span_after_ident = item.span.with_lo(item.ident.span.hi());
+        let span_after_ident = item.span.with_lo(item.ident.span.hi());
 
+        if let ItemKind::Struct(var_data, _) = &item.kind && has_no_fields(cx, var_data, span_after_ident) {
             span_lint_and_sugg(
                 cx,
                 UNIT_LIKE_STRUCT_BRACKETS,
@@ -44,9 +46,51 @@ impl EarlyLintPass for UnitLikeStructBrackets {
     }
 }
 
-fn has_no_fields(var_data: &VariantData) -> bool {
+fn has_fields_in_hir(var_data: &VariantData) -> bool {
     match var_data {
-        VariantData::Struct(defs, _) | VariantData::Tuple(defs, _) => defs.is_empty(),
-        VariantData::Unit(_) => false,
+        VariantData::Struct(defs, _) | VariantData::Tuple(defs, _) => !defs.is_empty(),
+        VariantData::Unit(_) => true,
+    }
+}
+
+fn has_no_ident_token(braces_span_str: &str) -> bool {
+    !rustc_lexer::tokenize(braces_span_str).any(|t| t.kind == TokenKind::Ident)
+}
+
+fn has_no_fields(cx: &EarlyContext<'_>, var_data: &VariantData, braces_span: Span) -> bool {
+    if has_fields_in_hir(var_data) {
+        return false;
+    }
+
+    // there might still be field declarations hidden from HIR
+    // (conditionaly compiled code using #[cfg(..)])
+
+    let Some(braces_span_str) = snippet_opt(cx, braces_span) else {
+        return false;
+    };
+
+    has_no_ident_token(braces_span_str.as_ref())
+}
+
+#[cfg(test)]
+mod unit_test {
+    use super::*;
+
+    #[test]
+    fn test_has_no_ident_token() {
+        let input = "{ field: u8 }";
+        assert!(!has_no_ident_token(input));
+
+        let input = "(u8, String);";
+        assert!(!has_no_ident_token(input));
+
+        let input = " {
+                // test = 5
+        }
+        ";
+        assert!(has_no_ident_token(input));
+
+        let input = " ();";
+        assert!(has_no_ident_token(input));
     }
 }
diff --git a/tests/ui/unit_like_struct_brackets.fixed b/tests/ui/unit_like_struct_brackets.fixed
index e6cf4a0c0b4..78764337ec0 100644
--- a/tests/ui/unit_like_struct_brackets.fixed
+++ b/tests/ui/unit_like_struct_brackets.fixed
@@ -5,8 +5,17 @@
 pub struct MyEmptyStruct; // should trigger lint
 struct MyEmptyTupleStruct; // should trigger lint
 
+// should not trigger lint
+struct MyCfgStruct {
+    #[cfg(feature = "thisisneverenabled")]
+    field: u8,
+}
+
+// should not trigger lint
+struct MyCfgTupleStruct(#[cfg(feature = "thisisneverenabled")] u8);
+
+// should not trigger lint
 struct MyStruct {
-    // should not trigger lint
     field: u8,
 }
 struct MyTupleStruct(usize, String); // should not trigger lint
diff --git a/tests/ui/unit_like_struct_brackets.rs b/tests/ui/unit_like_struct_brackets.rs
index 306e4c207d8..c43f97adfe9 100644
--- a/tests/ui/unit_like_struct_brackets.rs
+++ b/tests/ui/unit_like_struct_brackets.rs
@@ -5,8 +5,17 @@
 pub struct MyEmptyStruct {} // should trigger lint
 struct MyEmptyTupleStruct(); // should trigger lint
 
+// should not trigger lint
+struct MyCfgStruct {
+    #[cfg(feature = "thisisneverenabled")]
+    field: u8,
+}
+
+// should not trigger lint
+struct MyCfgTupleStruct(#[cfg(feature = "thisisneverenabled")] u8);
+
+// should not trigger lint
 struct MyStruct {
-    // should not trigger lint
     field: u8,
 }
 struct MyTupleStruct(usize, String); // should not trigger lint
-- 
cgit 1.4.1-3-g733a5


From 33383a418d6e57995a35a08b6b3d74dc010b9189 Mon Sep 17 00:00:00 2001
From: Max Baumann <max@bmn.dev>
Date: Sun, 27 Mar 2022 20:10:10 +0200
Subject: use span_suggestion_hidden

---
 clippy_lints/src/unit_like_struct_brackets.rs | 14 +++++++++-----
 tests/ui/unit_like_struct_brackets.stderr     |  7 +++++--
 2 files changed, 14 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unit_like_struct_brackets.rs b/clippy_lints/src/unit_like_struct_brackets.rs
index cb6e2a44afb..7c93aa57d9b 100644
--- a/clippy_lints/src/unit_like_struct_brackets.rs
+++ b/clippy_lints/src/unit_like_struct_brackets.rs
@@ -1,4 +1,4 @@
-use clippy_utils::{diagnostics::span_lint_and_sugg, source::snippet_opt};
+use clippy_utils::{diagnostics::span_lint_and_then, source::snippet_opt};
 use rustc_ast::ast::{Item, ItemKind, VariantData};
 use rustc_errors::Applicability;
 use rustc_lexer::TokenKind;
@@ -33,14 +33,18 @@ impl EarlyLintPass for UnitLikeStructBrackets {
         let span_after_ident = item.span.with_lo(item.ident.span.hi());
 
         if let ItemKind::Struct(var_data, _) = &item.kind && has_no_fields(cx, var_data, span_after_ident) {
-            span_lint_and_sugg(
+            span_lint_and_then(
                 cx,
                 UNIT_LIKE_STRUCT_BRACKETS,
                 span_after_ident,
                 "found empty brackets on struct declaration",
-                "remove the brackets",
-                ";".to_string(),
-                Applicability::MachineApplicable
+                |diagnostic| {
+                    diagnostic.span_suggestion_hidden(
+                        span_after_ident,
+                        "remove the brackets",
+                        ";".to_string(),
+                        Applicability::MachineApplicable);
+                    },
             );
         }
     }
diff --git a/tests/ui/unit_like_struct_brackets.stderr b/tests/ui/unit_like_struct_brackets.stderr
index 7e7ba11cc71..d3037f5d350 100644
--- a/tests/ui/unit_like_struct_brackets.stderr
+++ b/tests/ui/unit_like_struct_brackets.stderr
@@ -2,15 +2,18 @@ error: found empty brackets on struct declaration
   --> $DIR/unit_like_struct_brackets.rs:5:25
    |
 LL | pub struct MyEmptyStruct {} // should trigger lint
-   |                         ^^^ help: remove the brackets: `;`
+   |                         ^^^
    |
    = note: `-D clippy::unit-like-struct-brackets` implied by `-D warnings`
+   = help: remove the brackets
 
 error: found empty brackets on struct declaration
   --> $DIR/unit_like_struct_brackets.rs:6:26
    |
 LL | struct MyEmptyTupleStruct(); // should trigger lint
-   |                          ^^^ help: remove the brackets: `;`
+   |                          ^^^
+   |
+   = help: remove the brackets
 
 error: aborting due to 2 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 37d5a6264c3ad22f878351267fbbfe47e62cd35b Mon Sep 17 00:00:00 2001
From: Max Baumann <max@bmn.dev>
Date: Mon, 28 Mar 2022 11:18:20 +0200
Subject: changes after review

---
 clippy_lints/src/unit_like_struct_brackets.rs | 21 ++++++++++-----------
 tests/ui/unit_like_struct_brackets.fixed      |  2 ++
 tests/ui/unit_like_struct_brackets.rs         |  2 ++
 3 files changed, 14 insertions(+), 11 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unit_like_struct_brackets.rs b/clippy_lints/src/unit_like_struct_brackets.rs
index 7c93aa57d9b..6269719e696 100644
--- a/clippy_lints/src/unit_like_struct_brackets.rs
+++ b/clippy_lints/src/unit_like_struct_brackets.rs
@@ -21,7 +21,7 @@ declare_clippy_lint! {
     /// ```rust
     /// struct Cookie;
     /// ```
-    #[clippy::version = "1.61.0"]
+    #[clippy::version = "1.62.0"]
     pub UNIT_LIKE_STRUCT_BRACKETS,
     style,
     "finds struct declarations with empty brackets"
@@ -32,7 +32,9 @@ impl EarlyLintPass for UnitLikeStructBrackets {
     fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {
         let span_after_ident = item.span.with_lo(item.ident.span.hi());
 
-        if let ItemKind::Struct(var_data, _) = &item.kind && has_no_fields(cx, var_data, span_after_ident) {
+        if let ItemKind::Struct(var_data, _) = &item.kind
+            && !is_unit_like_struct(var_data)
+            && has_no_fields(cx, var_data, span_after_ident) {
             span_lint_and_then(
                 cx,
                 UNIT_LIKE_STRUCT_BRACKETS,
@@ -50,23 +52,20 @@ impl EarlyLintPass for UnitLikeStructBrackets {
     }
 }
 
-fn has_fields_in_hir(var_data: &VariantData) -> bool {
-    match var_data {
-        VariantData::Struct(defs, _) | VariantData::Tuple(defs, _) => !defs.is_empty(),
-        VariantData::Unit(_) => true,
-    }
-}
-
 fn has_no_ident_token(braces_span_str: &str) -> bool {
     !rustc_lexer::tokenize(braces_span_str).any(|t| t.kind == TokenKind::Ident)
 }
 
+fn is_unit_like_struct(var_data: &VariantData) -> bool {
+    matches!(var_data, VariantData::Unit(_))
+}
+
 fn has_no_fields(cx: &EarlyContext<'_>, var_data: &VariantData, braces_span: Span) -> bool {
-    if has_fields_in_hir(var_data) {
+    if !var_data.fields().is_empty() {
         return false;
     }
 
-    // there might still be field declarations hidden from HIR
+    // there might still be field declarations hidden from the AST
     // (conditionaly compiled code using #[cfg(..)])
 
     let Some(braces_span_str) = snippet_opt(cx, braces_span) else {
diff --git a/tests/ui/unit_like_struct_brackets.fixed b/tests/ui/unit_like_struct_brackets.fixed
index 78764337ec0..2769920c5fe 100644
--- a/tests/ui/unit_like_struct_brackets.fixed
+++ b/tests/ui/unit_like_struct_brackets.fixed
@@ -19,5 +19,7 @@ struct MyStruct {
     field: u8,
 }
 struct MyTupleStruct(usize, String); // should not trigger lint
+struct MySingleTupleStruct(usize); // should not trigger lint
+struct MyUnitLikeStruct; // should not trigger lint
 
 fn main() {}
diff --git a/tests/ui/unit_like_struct_brackets.rs b/tests/ui/unit_like_struct_brackets.rs
index c43f97adfe9..b20f8516bd1 100644
--- a/tests/ui/unit_like_struct_brackets.rs
+++ b/tests/ui/unit_like_struct_brackets.rs
@@ -19,5 +19,7 @@ struct MyStruct {
     field: u8,
 }
 struct MyTupleStruct(usize, String); // should not trigger lint
+struct MySingleTupleStruct(usize); // should not trigger lint
+struct MyUnitLikeStruct; // should not trigger lint
 
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 2953cba1160cb4dd8fe4923a4e9166b3ca6867f1 Mon Sep 17 00:00:00 2001
From: Max Baumann <max@bmn.dev>
Date: Mon, 28 Mar 2022 11:35:43 +0200
Subject: unit_like_struct_brackets -> empty_structs_with_brackets

---
 CHANGELOG.md                                    |  2 +-
 clippy_lints/src/empty_structs_with_brackets.rs | 99 +++++++++++++++++++++++++
 clippy_lints/src/lib.register_all.rs            |  2 +-
 clippy_lints/src/lib.register_lints.rs          |  2 +-
 clippy_lints/src/lib.register_style.rs          |  2 +-
 clippy_lints/src/lib.rs                         |  4 +-
 clippy_lints/src/unit_like_struct_brackets.rs   | 99 -------------------------
 tests/ui/empty_structs_with_brackets.fixed      | 25 +++++++
 tests/ui/empty_structs_with_brackets.rs         | 25 +++++++
 tests/ui/empty_structs_with_brackets.stderr     | 19 +++++
 tests/ui/no_effect.rs                           |  2 +-
 tests/ui/unit_like_struct_brackets.fixed        | 25 -------
 tests/ui/unit_like_struct_brackets.rs           | 25 -------
 tests/ui/unit_like_struct_brackets.stderr       | 19 -----
 14 files changed, 175 insertions(+), 175 deletions(-)
 create mode 100644 clippy_lints/src/empty_structs_with_brackets.rs
 delete mode 100644 clippy_lints/src/unit_like_struct_brackets.rs
 create mode 100644 tests/ui/empty_structs_with_brackets.fixed
 create mode 100644 tests/ui/empty_structs_with_brackets.rs
 create mode 100644 tests/ui/empty_structs_with_brackets.stderr
 delete mode 100644 tests/ui/unit_like_struct_brackets.fixed
 delete mode 100644 tests/ui/unit_like_struct_brackets.rs
 delete mode 100644 tests/ui/unit_like_struct_brackets.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 49a44d98813..0aa6a019762 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3263,6 +3263,7 @@ Released 2018-09-13
 [`empty_enum`]: https://rust-lang.github.io/rust-clippy/master/index.html#empty_enum
 [`empty_line_after_outer_attr`]: https://rust-lang.github.io/rust-clippy/master/index.html#empty_line_after_outer_attr
 [`empty_loop`]: https://rust-lang.github.io/rust-clippy/master/index.html#empty_loop
+[`empty_structs_with_brackets`]: https://rust-lang.github.io/rust-clippy/master/index.html#empty_structs_with_brackets
 [`enum_clike_unportable_variant`]: https://rust-lang.github.io/rust-clippy/master/index.html#enum_clike_unportable_variant
 [`enum_glob_use`]: https://rust-lang.github.io/rust-clippy/master/index.html#enum_glob_use
 [`enum_variant_names`]: https://rust-lang.github.io/rust-clippy/master/index.html#enum_variant_names
@@ -3636,7 +3637,6 @@ Released 2018-09-13
 [`unit_arg`]: https://rust-lang.github.io/rust-clippy/master/index.html#unit_arg
 [`unit_cmp`]: https://rust-lang.github.io/rust-clippy/master/index.html#unit_cmp
 [`unit_hash`]: https://rust-lang.github.io/rust-clippy/master/index.html#unit_hash
-[`unit_like_struct_brackets`]: https://rust-lang.github.io/rust-clippy/master/index.html#unit_like_struct_brackets
 [`unit_return_expecting_ord`]: https://rust-lang.github.io/rust-clippy/master/index.html#unit_return_expecting_ord
 [`unnecessary_cast`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_cast
 [`unnecessary_filter_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_filter_map
diff --git a/clippy_lints/src/empty_structs_with_brackets.rs b/clippy_lints/src/empty_structs_with_brackets.rs
new file mode 100644
index 00000000000..e3f33c1a4a3
--- /dev/null
+++ b/clippy_lints/src/empty_structs_with_brackets.rs
@@ -0,0 +1,99 @@
+use clippy_utils::{diagnostics::span_lint_and_then, source::snippet_opt};
+use rustc_ast::ast::{Item, ItemKind, VariantData};
+use rustc_errors::Applicability;
+use rustc_lexer::TokenKind;
+use rustc_lint::{EarlyContext, EarlyLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::Span;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Finds structs without fields ("unit-like structs") that are declared with brackets.
+    ///
+    /// ### Why is this bad?
+    /// Empty brackets after a struct declaration can be omitted.
+    ///
+    /// ### Example
+    /// ```rust
+    /// struct Cookie {}
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// struct Cookie;
+    /// ```
+    #[clippy::version = "1.62.0"]
+    pub EMPTY_STRUCTS_WITH_BRACKETS,
+    style,
+    "finds struct declarations with empty brackets"
+}
+declare_lint_pass!(EmptyStructsWithBrackets => [EMPTY_STRUCTS_WITH_BRACKETS]);
+
+impl EarlyLintPass for EmptyStructsWithBrackets {
+    fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {
+        let span_after_ident = item.span.with_lo(item.ident.span.hi());
+
+        if let ItemKind::Struct(var_data, _) = &item.kind
+            && !is_unit_like_struct(var_data)
+            && has_no_fields(cx, var_data, span_after_ident) {
+            span_lint_and_then(
+                cx,
+                EMPTY_STRUCTS_WITH_BRACKETS,
+                span_after_ident,
+                "found empty brackets on struct declaration",
+                |diagnostic| {
+                    diagnostic.span_suggestion_hidden(
+                        span_after_ident,
+                        "remove the brackets",
+                        ";".to_string(),
+                        Applicability::MachineApplicable);
+                    },
+            );
+        }
+    }
+}
+
+fn has_no_ident_token(braces_span_str: &str) -> bool {
+    !rustc_lexer::tokenize(braces_span_str).any(|t| t.kind == TokenKind::Ident)
+}
+
+fn is_unit_like_struct(var_data: &VariantData) -> bool {
+    matches!(var_data, VariantData::Unit(_))
+}
+
+fn has_no_fields(cx: &EarlyContext<'_>, var_data: &VariantData, braces_span: Span) -> bool {
+    if !var_data.fields().is_empty() {
+        return false;
+    }
+
+    // there might still be field declarations hidden from the AST
+    // (conditionaly compiled code using #[cfg(..)])
+
+    let Some(braces_span_str) = snippet_opt(cx, braces_span) else {
+        return false;
+    };
+
+    has_no_ident_token(braces_span_str.as_ref())
+}
+
+#[cfg(test)]
+mod unit_test {
+    use super::*;
+
+    #[test]
+    fn test_has_no_ident_token() {
+        let input = "{ field: u8 }";
+        assert!(!has_no_ident_token(input));
+
+        let input = "(u8, String);";
+        assert!(!has_no_ident_token(input));
+
+        let input = " {
+                // test = 5
+        }
+        ";
+        assert!(has_no_ident_token(input));
+
+        let input = " ();";
+        assert!(has_no_ident_token(input));
+    }
+}
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index f488aab46ec..bdad518a3e8 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -54,6 +54,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(drop_forget_ref::FORGET_COPY),
     LintId::of(drop_forget_ref::FORGET_REF),
     LintId::of(duration_subsec::DURATION_SUBSEC),
+    LintId::of(empty_structs_with_brackets::EMPTY_STRUCTS_WITH_BRACKETS),
     LintId::of(entry::MAP_ENTRY),
     LintId::of(enum_clike::ENUM_CLIKE_UNPORTABLE_VARIANT),
     LintId::of(enum_variants::ENUM_VARIANT_NAMES),
@@ -301,7 +302,6 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(unicode::INVISIBLE_CHARACTERS),
     LintId::of(uninit_vec::UNINIT_VEC),
     LintId::of(unit_hash::UNIT_HASH),
-    LintId::of(unit_like_struct_brackets::UNIT_LIKE_STRUCT_BRACKETS),
     LintId::of(unit_return_expecting_ord::UNIT_RETURN_EXPECTING_ORD),
     LintId::of(unit_types::UNIT_ARG),
     LintId::of(unit_types::UNIT_CMP),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index a1e6ca76a16..bba3cae45f5 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -129,6 +129,7 @@ store.register_lints(&[
     duration_subsec::DURATION_SUBSEC,
     else_if_without_else::ELSE_IF_WITHOUT_ELSE,
     empty_enum::EMPTY_ENUM,
+    empty_structs_with_brackets::EMPTY_STRUCTS_WITH_BRACKETS,
     entry::MAP_ENTRY,
     enum_clike::ENUM_CLIKE_UNPORTABLE_VARIANT,
     enum_variants::ENUM_VARIANT_NAMES,
@@ -512,7 +513,6 @@ store.register_lints(&[
     unicode::UNICODE_NOT_NFC,
     uninit_vec::UNINIT_VEC,
     unit_hash::UNIT_HASH,
-    unit_like_struct_brackets::UNIT_LIKE_STRUCT_BRACKETS,
     unit_return_expecting_ord::UNIT_RETURN_EXPECTING_ORD,
     unit_types::LET_UNIT_VALUE,
     unit_types::UNIT_ARG,
diff --git a/clippy_lints/src/lib.register_style.rs b/clippy_lints/src/lib.register_style.rs
index 89657cfb784..b2465d1a0cd 100644
--- a/clippy_lints/src/lib.register_style.rs
+++ b/clippy_lints/src/lib.register_style.rs
@@ -20,6 +20,7 @@ store.register_group(true, "clippy::style", Some("clippy_style"), vec![
     LintId::of(disallowed_types::DISALLOWED_TYPES),
     LintId::of(doc::MISSING_SAFETY_DOC),
     LintId::of(doc::NEEDLESS_DOCTEST_MAIN),
+    LintId::of(empty_structs_with_brackets::EMPTY_STRUCTS_WITH_BRACKETS),
     LintId::of(enum_variants::ENUM_VARIANT_NAMES),
     LintId::of(enum_variants::MODULE_INCEPTION),
     LintId::of(eq_op::OP_REF),
@@ -105,7 +106,6 @@ store.register_group(true, "clippy::style", Some("clippy_style"), vec![
     LintId::of(single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS),
     LintId::of(tabs_in_doc_comments::TABS_IN_DOC_COMMENTS),
     LintId::of(to_digit_is_some::TO_DIGIT_IS_SOME),
-    LintId::of(unit_like_struct_brackets::UNIT_LIKE_STRUCT_BRACKETS),
     LintId::of(unsafe_removed_from_name::UNSAFE_REMOVED_FROM_NAME),
     LintId::of(unused_unit::UNUSED_UNIT),
     LintId::of(upper_case_acronyms::UPPER_CASE_ACRONYMS),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index af8d9b3655c..3138ee9bce5 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -209,6 +209,7 @@ mod drop_forget_ref;
 mod duration_subsec;
 mod else_if_without_else;
 mod empty_enum;
+mod empty_structs_with_brackets;
 mod entry;
 mod enum_clike;
 mod enum_variants;
@@ -380,7 +381,6 @@ mod undropped_manually_drops;
 mod unicode;
 mod uninit_vec;
 mod unit_hash;
-mod unit_like_struct_brackets;
 mod unit_return_expecting_ord;
 mod unit_types;
 mod unnamed_address;
@@ -870,7 +870,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         })
     });
     store.register_early_pass(|| Box::new(crate_in_macro_def::CrateInMacroDef));
-    store.register_early_pass(|| Box::new(unit_like_struct_brackets::UnitLikeStructBrackets));
+    store.register_early_pass(|| Box::new(empty_structs_with_brackets::EmptyStructsWithBrackets));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/unit_like_struct_brackets.rs b/clippy_lints/src/unit_like_struct_brackets.rs
deleted file mode 100644
index 6269719e696..00000000000
--- a/clippy_lints/src/unit_like_struct_brackets.rs
+++ /dev/null
@@ -1,99 +0,0 @@
-use clippy_utils::{diagnostics::span_lint_and_then, source::snippet_opt};
-use rustc_ast::ast::{Item, ItemKind, VariantData};
-use rustc_errors::Applicability;
-use rustc_lexer::TokenKind;
-use rustc_lint::{EarlyContext, EarlyLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::Span;
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Finds structs without fields ("unit-like structs") that are declared with brackets.
-    ///
-    /// ### Why is this bad?
-    /// Empty brackets after a struct declaration can be omitted.
-    ///
-    /// ### Example
-    /// ```rust
-    /// struct Cookie {}
-    /// ```
-    /// Use instead:
-    /// ```rust
-    /// struct Cookie;
-    /// ```
-    #[clippy::version = "1.62.0"]
-    pub UNIT_LIKE_STRUCT_BRACKETS,
-    style,
-    "finds struct declarations with empty brackets"
-}
-declare_lint_pass!(UnitLikeStructBrackets => [UNIT_LIKE_STRUCT_BRACKETS]);
-
-impl EarlyLintPass for UnitLikeStructBrackets {
-    fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {
-        let span_after_ident = item.span.with_lo(item.ident.span.hi());
-
-        if let ItemKind::Struct(var_data, _) = &item.kind
-            && !is_unit_like_struct(var_data)
-            && has_no_fields(cx, var_data, span_after_ident) {
-            span_lint_and_then(
-                cx,
-                UNIT_LIKE_STRUCT_BRACKETS,
-                span_after_ident,
-                "found empty brackets on struct declaration",
-                |diagnostic| {
-                    diagnostic.span_suggestion_hidden(
-                        span_after_ident,
-                        "remove the brackets",
-                        ";".to_string(),
-                        Applicability::MachineApplicable);
-                    },
-            );
-        }
-    }
-}
-
-fn has_no_ident_token(braces_span_str: &str) -> bool {
-    !rustc_lexer::tokenize(braces_span_str).any(|t| t.kind == TokenKind::Ident)
-}
-
-fn is_unit_like_struct(var_data: &VariantData) -> bool {
-    matches!(var_data, VariantData::Unit(_))
-}
-
-fn has_no_fields(cx: &EarlyContext<'_>, var_data: &VariantData, braces_span: Span) -> bool {
-    if !var_data.fields().is_empty() {
-        return false;
-    }
-
-    // there might still be field declarations hidden from the AST
-    // (conditionaly compiled code using #[cfg(..)])
-
-    let Some(braces_span_str) = snippet_opt(cx, braces_span) else {
-        return false;
-    };
-
-    has_no_ident_token(braces_span_str.as_ref())
-}
-
-#[cfg(test)]
-mod unit_test {
-    use super::*;
-
-    #[test]
-    fn test_has_no_ident_token() {
-        let input = "{ field: u8 }";
-        assert!(!has_no_ident_token(input));
-
-        let input = "(u8, String);";
-        assert!(!has_no_ident_token(input));
-
-        let input = " {
-                // test = 5
-        }
-        ";
-        assert!(has_no_ident_token(input));
-
-        let input = " ();";
-        assert!(has_no_ident_token(input));
-    }
-}
diff --git a/tests/ui/empty_structs_with_brackets.fixed b/tests/ui/empty_structs_with_brackets.fixed
new file mode 100644
index 00000000000..80f07603b8d
--- /dev/null
+++ b/tests/ui/empty_structs_with_brackets.fixed
@@ -0,0 +1,25 @@
+// run-rustfix
+#![warn(clippy::empty_structs_with_brackets)]
+#![allow(dead_code)]
+
+pub struct MyEmptyStruct; // should trigger lint
+struct MyEmptyTupleStruct; // should trigger lint
+
+// should not trigger lint
+struct MyCfgStruct {
+    #[cfg(feature = "thisisneverenabled")]
+    field: u8,
+}
+
+// should not trigger lint
+struct MyCfgTupleStruct(#[cfg(feature = "thisisneverenabled")] u8);
+
+// should not trigger lint
+struct MyStruct {
+    field: u8,
+}
+struct MyTupleStruct(usize, String); // should not trigger lint
+struct MySingleTupleStruct(usize); // should not trigger lint
+struct MyUnitLikeStruct; // should not trigger lint
+
+fn main() {}
diff --git a/tests/ui/empty_structs_with_brackets.rs b/tests/ui/empty_structs_with_brackets.rs
new file mode 100644
index 00000000000..1d1ed4c7690
--- /dev/null
+++ b/tests/ui/empty_structs_with_brackets.rs
@@ -0,0 +1,25 @@
+// run-rustfix
+#![warn(clippy::empty_structs_with_brackets)]
+#![allow(dead_code)]
+
+pub struct MyEmptyStruct {} // should trigger lint
+struct MyEmptyTupleStruct(); // should trigger lint
+
+// should not trigger lint
+struct MyCfgStruct {
+    #[cfg(feature = "thisisneverenabled")]
+    field: u8,
+}
+
+// should not trigger lint
+struct MyCfgTupleStruct(#[cfg(feature = "thisisneverenabled")] u8);
+
+// should not trigger lint
+struct MyStruct {
+    field: u8,
+}
+struct MyTupleStruct(usize, String); // should not trigger lint
+struct MySingleTupleStruct(usize); // should not trigger lint
+struct MyUnitLikeStruct; // should not trigger lint
+
+fn main() {}
diff --git a/tests/ui/empty_structs_with_brackets.stderr b/tests/ui/empty_structs_with_brackets.stderr
new file mode 100644
index 00000000000..0308cb5571a
--- /dev/null
+++ b/tests/ui/empty_structs_with_brackets.stderr
@@ -0,0 +1,19 @@
+error: found empty brackets on struct declaration
+  --> $DIR/empty_structs_with_brackets.rs:5:25
+   |
+LL | pub struct MyEmptyStruct {} // should trigger lint
+   |                         ^^^
+   |
+   = note: `-D clippy::empty-structs-with-brackets` implied by `-D warnings`
+   = help: remove the brackets
+
+error: found empty brackets on struct declaration
+  --> $DIR/empty_structs_with_brackets.rs:6:26
+   |
+LL | struct MyEmptyTupleStruct(); // should trigger lint
+   |                          ^^^
+   |
+   = help: remove the brackets
+
+error: aborting due to 2 previous errors
+
diff --git a/tests/ui/no_effect.rs b/tests/ui/no_effect.rs
index 291dab4fb31..0847297ade7 100644
--- a/tests/ui/no_effect.rs
+++ b/tests/ui/no_effect.rs
@@ -68,7 +68,7 @@ impl FnOnce<(&str,)> for GreetStruct1 {
     }
 }
 
-#[allow(clippy::unit_like_struct_brackets)]
+#[allow(clippy::empty_structs_with_brackets)]
 struct GreetStruct2();
 
 impl FnOnce<(&str,)> for GreetStruct2 {
diff --git a/tests/ui/unit_like_struct_brackets.fixed b/tests/ui/unit_like_struct_brackets.fixed
deleted file mode 100644
index 2769920c5fe..00000000000
--- a/tests/ui/unit_like_struct_brackets.fixed
+++ /dev/null
@@ -1,25 +0,0 @@
-// run-rustfix
-#![warn(clippy::unit_like_struct_brackets)]
-#![allow(dead_code)]
-
-pub struct MyEmptyStruct; // should trigger lint
-struct MyEmptyTupleStruct; // should trigger lint
-
-// should not trigger lint
-struct MyCfgStruct {
-    #[cfg(feature = "thisisneverenabled")]
-    field: u8,
-}
-
-// should not trigger lint
-struct MyCfgTupleStruct(#[cfg(feature = "thisisneverenabled")] u8);
-
-// should not trigger lint
-struct MyStruct {
-    field: u8,
-}
-struct MyTupleStruct(usize, String); // should not trigger lint
-struct MySingleTupleStruct(usize); // should not trigger lint
-struct MyUnitLikeStruct; // should not trigger lint
-
-fn main() {}
diff --git a/tests/ui/unit_like_struct_brackets.rs b/tests/ui/unit_like_struct_brackets.rs
deleted file mode 100644
index b20f8516bd1..00000000000
--- a/tests/ui/unit_like_struct_brackets.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-// run-rustfix
-#![warn(clippy::unit_like_struct_brackets)]
-#![allow(dead_code)]
-
-pub struct MyEmptyStruct {} // should trigger lint
-struct MyEmptyTupleStruct(); // should trigger lint
-
-// should not trigger lint
-struct MyCfgStruct {
-    #[cfg(feature = "thisisneverenabled")]
-    field: u8,
-}
-
-// should not trigger lint
-struct MyCfgTupleStruct(#[cfg(feature = "thisisneverenabled")] u8);
-
-// should not trigger lint
-struct MyStruct {
-    field: u8,
-}
-struct MyTupleStruct(usize, String); // should not trigger lint
-struct MySingleTupleStruct(usize); // should not trigger lint
-struct MyUnitLikeStruct; // should not trigger lint
-
-fn main() {}
diff --git a/tests/ui/unit_like_struct_brackets.stderr b/tests/ui/unit_like_struct_brackets.stderr
deleted file mode 100644
index d3037f5d350..00000000000
--- a/tests/ui/unit_like_struct_brackets.stderr
+++ /dev/null
@@ -1,19 +0,0 @@
-error: found empty brackets on struct declaration
-  --> $DIR/unit_like_struct_brackets.rs:5:25
-   |
-LL | pub struct MyEmptyStruct {} // should trigger lint
-   |                         ^^^
-   |
-   = note: `-D clippy::unit-like-struct-brackets` implied by `-D warnings`
-   = help: remove the brackets
-
-error: found empty brackets on struct declaration
-  --> $DIR/unit_like_struct_brackets.rs:6:26
-   |
-LL | struct MyEmptyTupleStruct(); // should trigger lint
-   |                          ^^^
-   |
-   = help: remove the brackets
-
-error: aborting due to 2 previous errors
-
-- 
cgit 1.4.1-3-g733a5


From e552267db33377d913ca1c94c7377b1f5623cbf3 Mon Sep 17 00:00:00 2001
From: Max Baumann <max@bmn.dev>
Date: Mon, 28 Mar 2022 11:45:06 +0200
Subject: style -> pedantic

---
 clippy_lints/src/empty_structs_with_brackets.rs |  2 +-
 clippy_lints/src/lib.register_all.rs            |  1 -
 clippy_lints/src/lib.register_pedantic.rs       |  1 +
 clippy_lints/src/lib.register_style.rs          |  1 -
 tests/ui/no_effect.rs                           |  1 -
 tests/ui/no_effect.stderr                       | 60 ++++++++++++-------------
 6 files changed, 32 insertions(+), 34 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/empty_structs_with_brackets.rs b/clippy_lints/src/empty_structs_with_brackets.rs
index e3f33c1a4a3..0077cc5364f 100644
--- a/clippy_lints/src/empty_structs_with_brackets.rs
+++ b/clippy_lints/src/empty_structs_with_brackets.rs
@@ -23,7 +23,7 @@ declare_clippy_lint! {
     /// ```
     #[clippy::version = "1.62.0"]
     pub EMPTY_STRUCTS_WITH_BRACKETS,
-    style,
+    pedantic,
     "finds struct declarations with empty brackets"
 }
 declare_lint_pass!(EmptyStructsWithBrackets => [EMPTY_STRUCTS_WITH_BRACKETS]);
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index bdad518a3e8..1fb3ca1fd9b 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -54,7 +54,6 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(drop_forget_ref::FORGET_COPY),
     LintId::of(drop_forget_ref::FORGET_REF),
     LintId::of(duration_subsec::DURATION_SUBSEC),
-    LintId::of(empty_structs_with_brackets::EMPTY_STRUCTS_WITH_BRACKETS),
     LintId::of(entry::MAP_ENTRY),
     LintId::of(enum_clike::ENUM_CLIKE_UNPORTABLE_VARIANT),
     LintId::of(enum_variants::ENUM_VARIANT_NAMES),
diff --git a/clippy_lints/src/lib.register_pedantic.rs b/clippy_lints/src/lib.register_pedantic.rs
index eb6534cb8ca..3f0f438568f 100644
--- a/clippy_lints/src/lib.register_pedantic.rs
+++ b/clippy_lints/src/lib.register_pedantic.rs
@@ -27,6 +27,7 @@ store.register_group(true, "clippy::pedantic", Some("clippy_pedantic"), vec![
     LintId::of(doc::MISSING_ERRORS_DOC),
     LintId::of(doc::MISSING_PANICS_DOC),
     LintId::of(empty_enum::EMPTY_ENUM),
+    LintId::of(empty_structs_with_brackets::EMPTY_STRUCTS_WITH_BRACKETS),
     LintId::of(enum_variants::MODULE_NAME_REPETITIONS),
     LintId::of(eta_reduction::REDUNDANT_CLOSURE_FOR_METHOD_CALLS),
     LintId::of(excessive_bools::FN_PARAMS_EXCESSIVE_BOOLS),
diff --git a/clippy_lints/src/lib.register_style.rs b/clippy_lints/src/lib.register_style.rs
index b2465d1a0cd..dcf399cf956 100644
--- a/clippy_lints/src/lib.register_style.rs
+++ b/clippy_lints/src/lib.register_style.rs
@@ -20,7 +20,6 @@ store.register_group(true, "clippy::style", Some("clippy_style"), vec![
     LintId::of(disallowed_types::DISALLOWED_TYPES),
     LintId::of(doc::MISSING_SAFETY_DOC),
     LintId::of(doc::NEEDLESS_DOCTEST_MAIN),
-    LintId::of(empty_structs_with_brackets::EMPTY_STRUCTS_WITH_BRACKETS),
     LintId::of(enum_variants::ENUM_VARIANT_NAMES),
     LintId::of(enum_variants::MODULE_INCEPTION),
     LintId::of(eq_op::OP_REF),
diff --git a/tests/ui/no_effect.rs b/tests/ui/no_effect.rs
index 0847297ade7..7ece66a1ccb 100644
--- a/tests/ui/no_effect.rs
+++ b/tests/ui/no_effect.rs
@@ -68,7 +68,6 @@ impl FnOnce<(&str,)> for GreetStruct1 {
     }
 }
 
-#[allow(clippy::empty_structs_with_brackets)]
 struct GreetStruct2();
 
 impl FnOnce<(&str,)> for GreetStruct2 {
diff --git a/tests/ui/no_effect.stderr b/tests/ui/no_effect.stderr
index ee57e0d26df..06b88bb5bee 100644
--- a/tests/ui/no_effect.stderr
+++ b/tests/ui/no_effect.stderr
@@ -1,5 +1,5 @@
 error: statement with no effect
-  --> $DIR/no_effect.rs:96:5
+  --> $DIR/no_effect.rs:95:5
    |
 LL |     0;
    |     ^^
@@ -7,157 +7,157 @@ LL |     0;
    = note: `-D clippy::no-effect` implied by `-D warnings`
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:97:5
+  --> $DIR/no_effect.rs:96:5
    |
 LL |     s2;
    |     ^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:98:5
+  --> $DIR/no_effect.rs:97:5
    |
 LL |     Unit;
    |     ^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:99:5
+  --> $DIR/no_effect.rs:98:5
    |
 LL |     Tuple(0);
    |     ^^^^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:100:5
+  --> $DIR/no_effect.rs:99:5
    |
 LL |     Struct { field: 0 };
    |     ^^^^^^^^^^^^^^^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:101:5
+  --> $DIR/no_effect.rs:100:5
    |
 LL |     Struct { ..s };
    |     ^^^^^^^^^^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:102:5
+  --> $DIR/no_effect.rs:101:5
    |
 LL |     Union { a: 0 };
    |     ^^^^^^^^^^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:103:5
+  --> $DIR/no_effect.rs:102:5
    |
 LL |     Enum::Tuple(0);
    |     ^^^^^^^^^^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:104:5
+  --> $DIR/no_effect.rs:103:5
    |
 LL |     Enum::Struct { field: 0 };
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:105:5
+  --> $DIR/no_effect.rs:104:5
    |
 LL |     5 + 6;
    |     ^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:106:5
+  --> $DIR/no_effect.rs:105:5
    |
 LL |     *&42;
    |     ^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:107:5
+  --> $DIR/no_effect.rs:106:5
    |
 LL |     &6;
    |     ^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:108:5
+  --> $DIR/no_effect.rs:107:5
    |
 LL |     (5, 6, 7);
    |     ^^^^^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:109:5
+  --> $DIR/no_effect.rs:108:5
    |
 LL |     box 42;
    |     ^^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:110:5
+  --> $DIR/no_effect.rs:109:5
    |
 LL |     ..;
    |     ^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:111:5
+  --> $DIR/no_effect.rs:110:5
    |
 LL |     5..;
    |     ^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:112:5
+  --> $DIR/no_effect.rs:111:5
    |
 LL |     ..5;
    |     ^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:113:5
+  --> $DIR/no_effect.rs:112:5
    |
 LL |     5..6;
    |     ^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:114:5
+  --> $DIR/no_effect.rs:113:5
    |
 LL |     5..=6;
    |     ^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:115:5
+  --> $DIR/no_effect.rs:114:5
    |
 LL |     [42, 55];
    |     ^^^^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:116:5
+  --> $DIR/no_effect.rs:115:5
    |
 LL |     [42, 55][1];
    |     ^^^^^^^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:117:5
+  --> $DIR/no_effect.rs:116:5
    |
 LL |     (42, 55).1;
    |     ^^^^^^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:118:5
+  --> $DIR/no_effect.rs:117:5
    |
 LL |     [42; 55];
    |     ^^^^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:119:5
+  --> $DIR/no_effect.rs:118:5
    |
 LL |     [42; 55][13];
    |     ^^^^^^^^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:121:5
+  --> $DIR/no_effect.rs:120:5
    |
 LL |     || x += 5;
    |     ^^^^^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:123:5
+  --> $DIR/no_effect.rs:122:5
    |
 LL |     FooString { s: s };
    |     ^^^^^^^^^^^^^^^^^^^
 
 error: binding to `_` prefixed variable with no side-effect
-  --> $DIR/no_effect.rs:124:5
+  --> $DIR/no_effect.rs:123:5
    |
 LL |     let _unused = 1;
    |     ^^^^^^^^^^^^^^^^
@@ -165,19 +165,19 @@ LL |     let _unused = 1;
    = note: `-D clippy::no-effect-underscore-binding` implied by `-D warnings`
 
 error: binding to `_` prefixed variable with no side-effect
-  --> $DIR/no_effect.rs:125:5
+  --> $DIR/no_effect.rs:124:5
    |
 LL |     let _penguin = || println!("Some helpful closure");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: binding to `_` prefixed variable with no side-effect
-  --> $DIR/no_effect.rs:126:5
+  --> $DIR/no_effect.rs:125:5
    |
 LL |     let _duck = Struct { field: 0 };
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: binding to `_` prefixed variable with no side-effect
-  --> $DIR/no_effect.rs:127:5
+  --> $DIR/no_effect.rs:126:5
    |
 LL |     let _cat = [2, 4, 6, 8][2];
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From 49a9740b09448ac903a2a1a9b73f09e4ca7fc783 Mon Sep 17 00:00:00 2001
From: Max Baumann <max@bmn.dev>
Date: Wed, 30 Mar 2022 13:08:39 +0200
Subject: update description

Co-authored-by: giraffate <f.seasons017@gmail.com>
---
 clippy_lints/src/empty_structs_with_brackets.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/empty_structs_with_brackets.rs b/clippy_lints/src/empty_structs_with_brackets.rs
index 0077cc5364f..15c06126fd5 100644
--- a/clippy_lints/src/empty_structs_with_brackets.rs
+++ b/clippy_lints/src/empty_structs_with_brackets.rs
@@ -8,7 +8,7 @@ use rustc_span::Span;
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Finds structs without fields ("unit-like structs") that are declared with brackets.
+    /// Finds structs without fields (a so-called "empty struct") that are declared with brackets.
     ///
     /// ### Why is this bad?
     /// Empty brackets after a struct declaration can be omitted.
-- 
cgit 1.4.1-3-g733a5


From 0434b856ac4253364f2f622df41209412442bb75 Mon Sep 17 00:00:00 2001
From: Max Baumann <max@bmn.dev>
Date: Wed, 30 Mar 2022 13:33:10 +0200
Subject: pedantic -> restriction

---
 clippy_lints/src/empty_structs_with_brackets.rs | 2 +-
 clippy_lints/src/lib.register_pedantic.rs       | 1 -
 clippy_lints/src/lib.register_restriction.rs    | 1 +
 3 files changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/empty_structs_with_brackets.rs b/clippy_lints/src/empty_structs_with_brackets.rs
index 15c06126fd5..8f2a0306aa0 100644
--- a/clippy_lints/src/empty_structs_with_brackets.rs
+++ b/clippy_lints/src/empty_structs_with_brackets.rs
@@ -23,7 +23,7 @@ declare_clippy_lint! {
     /// ```
     #[clippy::version = "1.62.0"]
     pub EMPTY_STRUCTS_WITH_BRACKETS,
-    pedantic,
+    restriction,
     "finds struct declarations with empty brackets"
 }
 declare_lint_pass!(EmptyStructsWithBrackets => [EMPTY_STRUCTS_WITH_BRACKETS]);
diff --git a/clippy_lints/src/lib.register_pedantic.rs b/clippy_lints/src/lib.register_pedantic.rs
index 3f0f438568f..eb6534cb8ca 100644
--- a/clippy_lints/src/lib.register_pedantic.rs
+++ b/clippy_lints/src/lib.register_pedantic.rs
@@ -27,7 +27,6 @@ store.register_group(true, "clippy::pedantic", Some("clippy_pedantic"), vec![
     LintId::of(doc::MISSING_ERRORS_DOC),
     LintId::of(doc::MISSING_PANICS_DOC),
     LintId::of(empty_enum::EMPTY_ENUM),
-    LintId::of(empty_structs_with_brackets::EMPTY_STRUCTS_WITH_BRACKETS),
     LintId::of(enum_variants::MODULE_NAME_REPETITIONS),
     LintId::of(eta_reduction::REDUNDANT_CLOSURE_FOR_METHOD_CALLS),
     LintId::of(excessive_bools::FN_PARAMS_EXCESSIVE_BOOLS),
diff --git a/clippy_lints/src/lib.register_restriction.rs b/clippy_lints/src/lib.register_restriction.rs
index 6ab139b2fb6..4802dd877e9 100644
--- a/clippy_lints/src/lib.register_restriction.rs
+++ b/clippy_lints/src/lib.register_restriction.rs
@@ -16,6 +16,7 @@ store.register_group(true, "clippy::restriction", Some("clippy_restriction"), ve
     LintId::of(default_union_representation::DEFAULT_UNION_REPRESENTATION),
     LintId::of(disallowed_script_idents::DISALLOWED_SCRIPT_IDENTS),
     LintId::of(else_if_without_else::ELSE_IF_WITHOUT_ELSE),
+    LintId::of(empty_structs_with_brackets::EMPTY_STRUCTS_WITH_BRACKETS),
     LintId::of(exhaustive_items::EXHAUSTIVE_ENUMS),
     LintId::of(exhaustive_items::EXHAUSTIVE_STRUCTS),
     LintId::of(exit::EXIT),
-- 
cgit 1.4.1-3-g733a5


From 7a80c23f838b832e651a717767c41a2536f3ae42 Mon Sep 17 00:00:00 2001
From: SabrinaJewson <sejewson@gmail.com>
Date: Wed, 30 Mar 2022 19:31:50 +0100
Subject: Suggest from_utf8_unchecked in const contexts

---
 clippy_lints/src/transmute/transmute_ref_to_ref.rs | 12 +++++++-----
 tests/ui/transmute.rs                              |  7 +++++--
 tests/ui/transmute.stderr                          | 16 +++++++++++-----
 3 files changed, 23 insertions(+), 12 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/transmute/transmute_ref_to_ref.rs b/clippy_lints/src/transmute/transmute_ref_to_ref.rs
index 7570bc2a7a8..9c893cacf4f 100644
--- a/clippy_lints/src/transmute/transmute_ref_to_ref.rs
+++ b/clippy_lints/src/transmute/transmute_ref_to_ref.rs
@@ -32,17 +32,19 @@ pub(super) fn check<'tcx>(
                     ""
                 };
 
+                let snippet = snippet(cx, arg.span, "..");
+
                 span_lint_and_sugg(
                     cx,
                     TRANSMUTE_BYTES_TO_STR,
                     e.span,
                     &format!("transmute from a `{}` to a `{}`", from_ty, to_ty),
                     "consider using",
-                    format!(
-                        "std::str::from_utf8{}({}).unwrap()",
-                        postfix,
-                        snippet(cx, arg.span, ".."),
-                    ),
+                    if const_context {
+                        format!("unsafe {{ std::str::from_utf8_unchecked{postfix}({snippet}) }}")
+                    } else {
+                        format!("std::str::from_utf8{postfix}({snippet}).unwrap()")
+                    },
                     Applicability::Unspecified,
                 );
                 triggered = true;
diff --git a/tests/ui/transmute.rs b/tests/ui/transmute.rs
index 54f9727d8ea..5b688ce4d64 100644
--- a/tests/ui/transmute.rs
+++ b/tests/ui/transmute.rs
@@ -134,9 +134,12 @@ mod num_to_bytes {
     }
 }
 
-fn bytes_to_str(b: &[u8], mb: &mut [u8]) {
-    let _: &str = unsafe { std::mem::transmute(b) };
+fn bytes_to_str(mb: &mut [u8]) {
+    const B: &[u8] = b"";
+
+    let _: &str = unsafe { std::mem::transmute(B) };
     let _: &mut str = unsafe { std::mem::transmute(mb) };
+    const _: &str = unsafe { std::mem::transmute(B) };
 }
 
 fn main() {}
diff --git a/tests/ui/transmute.stderr b/tests/ui/transmute.stderr
index 5c60fc2d511..1213d192ae9 100644
--- a/tests/ui/transmute.stderr
+++ b/tests/ui/transmute.stderr
@@ -227,18 +227,24 @@ LL |             let _: [u8; 16] = std::mem::transmute(0i128);
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0i128.to_ne_bytes()`
 
 error: transmute from a `&[u8]` to a `&str`
-  --> $DIR/transmute.rs:138:28
+  --> $DIR/transmute.rs:140:28
    |
-LL |     let _: &str = unsafe { std::mem::transmute(b) };
-   |                            ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::str::from_utf8(b).unwrap()`
+LL |     let _: &str = unsafe { std::mem::transmute(B) };
+   |                            ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::str::from_utf8(B).unwrap()`
    |
    = note: `-D clippy::transmute-bytes-to-str` implied by `-D warnings`
 
 error: transmute from a `&mut [u8]` to a `&mut str`
-  --> $DIR/transmute.rs:139:32
+  --> $DIR/transmute.rs:141:32
    |
 LL |     let _: &mut str = unsafe { std::mem::transmute(mb) };
    |                                ^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::str::from_utf8_mut(mb).unwrap()`
 
-error: aborting due to 38 previous errors
+error: transmute from a `&[u8]` to a `&str`
+  --> $DIR/transmute.rs:142:30
+   |
+LL |     const _: &str = unsafe { std::mem::transmute(B) };
+   |                              ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `unsafe { std::str::from_utf8_unchecked(B) }`
+
+error: aborting due to 39 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 11045f94e267805e90662577ee7486cba5dbcf18 Mon Sep 17 00:00:00 2001
From: SabrinaJewson <sejewson@gmail.com>
Date: Fri, 1 Apr 2022 06:32:22 +0100
Subject: Don't unnecessarily suggest unsafe block

---
 clippy_lints/src/transmute/transmute_ref_to_ref.rs | 2 +-
 tests/ui/transmute.stderr                          | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/transmute/transmute_ref_to_ref.rs b/clippy_lints/src/transmute/transmute_ref_to_ref.rs
index 9c893cacf4f..fe3e88613f4 100644
--- a/clippy_lints/src/transmute/transmute_ref_to_ref.rs
+++ b/clippy_lints/src/transmute/transmute_ref_to_ref.rs
@@ -41,7 +41,7 @@ pub(super) fn check<'tcx>(
                     &format!("transmute from a `{}` to a `{}`", from_ty, to_ty),
                     "consider using",
                     if const_context {
-                        format!("unsafe {{ std::str::from_utf8_unchecked{postfix}({snippet}) }}")
+                        format!("std::str::from_utf8_unchecked{postfix}({snippet})")
                     } else {
                         format!("std::str::from_utf8{postfix}({snippet}).unwrap()")
                     },
diff --git a/tests/ui/transmute.stderr b/tests/ui/transmute.stderr
index 1213d192ae9..72a386e8fa6 100644
--- a/tests/ui/transmute.stderr
+++ b/tests/ui/transmute.stderr
@@ -244,7 +244,7 @@ error: transmute from a `&[u8]` to a `&str`
   --> $DIR/transmute.rs:142:30
    |
 LL |     const _: &str = unsafe { std::mem::transmute(B) };
-   |                              ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `unsafe { std::str::from_utf8_unchecked(B) }`
+   |                              ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::str::from_utf8_unchecked(B)`
 
 error: aborting due to 39 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 3bbb3e33295f4de11efb904192df1a3764d89e8d Mon Sep 17 00:00:00 2001
From: Peter Jaszkowiak <p.jaszkow@gmail.com>
Date: Fri, 1 Apr 2022 00:04:19 -0600
Subject: single_element_loop: handle arrays for Edition2021

also handle `.iter_mut()`, `.into_iter()`,
and wrapping in parens if necessary
---
 clippy_lints/src/loops/single_element_loop.rs | 70 ++++++++++++++++++++++---
 tests/ui/single_element_loop.fixed            | 24 ++++++++-
 tests/ui/single_element_loop.rs               | 20 +++++++-
 tests/ui/single_element_loop.stderr           | 74 +++++++++++++++++++++++++--
 4 files changed, 172 insertions(+), 16 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/single_element_loop.rs b/clippy_lints/src/loops/single_element_loop.rs
index 36ecd83f7d6..a0bd7ad0ac6 100644
--- a/clippy_lints/src/loops/single_element_loop.rs
+++ b/clippy_lints/src/loops/single_element_loop.rs
@@ -2,9 +2,12 @@ use super::SINGLE_ELEMENT_LOOP;
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::{indent_of, snippet_with_applicability};
 use if_chain::if_chain;
+use rustc_ast::util::parser::PREC_PREFIX;
+use rustc_ast::Mutability;
 use rustc_errors::Applicability;
-use rustc_hir::{BorrowKind, Expr, ExprKind, Pat};
+use rustc_hir::{is_range_literal, BorrowKind, Expr, ExprKind, Pat};
 use rustc_lint::LateContext;
+use rustc_span::edition::Edition;
 
 pub(super) fn check<'tcx>(
     cx: &LateContext<'tcx>,
@@ -13,31 +16,84 @@ pub(super) fn check<'tcx>(
     body: &'tcx Expr<'_>,
     expr: &'tcx Expr<'_>,
 ) {
-    let arg_expr = match arg.kind {
-        ExprKind::AddrOf(BorrowKind::Ref, _, ref_arg) => ref_arg,
-        ExprKind::MethodCall(method, [arg], _) if method.ident.name == rustc_span::sym::iter => arg,
+    let (arg_expression, prefix) = match arg.kind {
+        ExprKind::AddrOf(
+            BorrowKind::Ref,
+            Mutability::Not,
+            Expr {
+                kind: ExprKind::Array([arg]),
+                ..
+            },
+        ) => (arg, "&"),
+        ExprKind::AddrOf(
+            BorrowKind::Ref,
+            Mutability::Mut,
+            Expr {
+                kind: ExprKind::Array([arg]),
+                ..
+            },
+        ) => (arg, "&mut "),
+        ExprKind::MethodCall(
+            method,
+            [
+                Expr {
+                    kind: ExprKind::Array([arg]),
+                    ..
+                },
+            ],
+            _,
+        ) if method.ident.name == rustc_span::sym::iter => (arg, "&"),
+        ExprKind::MethodCall(
+            method,
+            [
+                Expr {
+                    kind: ExprKind::Array([arg]),
+                    ..
+                },
+            ],
+            _,
+        ) if method.ident.name.as_str() == "iter_mut" => (arg, "&mut "),
+        ExprKind::MethodCall(
+            method,
+            [
+                Expr {
+                    kind: ExprKind::Array([arg]),
+                    ..
+                },
+            ],
+            _,
+        ) if method.ident.name == rustc_span::sym::into_iter => (arg, ""),
+        // Only check for arrays edition 2021 or later, as this case will trigger a compiler error otherwise.
+        ExprKind::Array([arg]) if cx.tcx.sess.edition() >= Edition::Edition2021 => (arg, ""),
         _ => return,
     };
     if_chain! {
-        if let ExprKind::Array([arg_expression]) = arg_expr.kind;
         if let ExprKind::Block(block, _) = body.kind;
         if !block.stmts.is_empty();
         then {
             let mut applicability = Applicability::MachineApplicable;
             let pat_snip = snippet_with_applicability(cx, pat.span, "..", &mut applicability);
-            let arg_snip = snippet_with_applicability(cx, arg_expression.span, "..", &mut applicability);
+            let mut arg_snip = snippet_with_applicability(cx, arg_expression.span, "..", &mut applicability);
             let mut block_str = snippet_with_applicability(cx, block.span, "..", &mut applicability).into_owned();
             block_str.remove(0);
             block_str.pop();
             let indent = " ".repeat(indent_of(cx, block.stmts[0].span).unwrap_or(0));
 
+            // Reference iterator from `&(mut) []` or `[].iter(_mut)()`.
+            if !prefix.is_empty() && (
+                // Precedence of internal expression is less than or equal to precedence of `&expr`.
+                arg_expression.precedence().order() <= PREC_PREFIX || is_range_literal(arg_expression)
+            ) {
+                arg_snip = format!("({arg_snip})").into();
+            }
+
             span_lint_and_sugg(
                 cx,
                 SINGLE_ELEMENT_LOOP,
                 expr.span,
                 "for loop over a single element",
                 "try",
-                format!("{{\n{}let {} = &{};{}}}", indent, pat_snip, arg_snip, block_str),
+                format!("{{\n{indent}let {pat_snip} = {prefix}{arg_snip};{block_str}}}"),
                 applicability,
             )
         }
diff --git a/tests/ui/single_element_loop.fixed b/tests/ui/single_element_loop.fixed
index c307afffcb8..63d31ff83f9 100644
--- a/tests/ui/single_element_loop.fixed
+++ b/tests/ui/single_element_loop.fixed
@@ -6,11 +6,31 @@ fn main() {
     let item1 = 2;
     {
         let item = &item1;
-        println!("{}", item);
+        dbg!(item);
     }
 
     {
         let item = &item1;
-        println!("{:?}", item);
+        dbg!(item);
+    }
+
+    {
+        let item = &(0..5);
+        dbg!(item);
+    }
+
+    {
+        let item = &mut (0..5);
+        dbg!(item);
+    }
+
+    {
+        let item = 0..5;
+        dbg!(item);
+    }
+
+    {
+        let item = 0..5;
+        dbg!(item);
     }
 }
diff --git a/tests/ui/single_element_loop.rs b/tests/ui/single_element_loop.rs
index 2c0c03b7211..2cda5a329d2 100644
--- a/tests/ui/single_element_loop.rs
+++ b/tests/ui/single_element_loop.rs
@@ -5,10 +5,26 @@
 fn main() {
     let item1 = 2;
     for item in &[item1] {
-        println!("{}", item);
+        dbg!(item);
     }
 
     for item in [item1].iter() {
-        println!("{:?}", item);
+        dbg!(item);
+    }
+
+    for item in &[0..5] {
+        dbg!(item);
+    }
+
+    for item in [0..5].iter_mut() {
+        dbg!(item);
+    }
+
+    for item in [0..5] {
+        dbg!(item);
+    }
+
+    for item in [0..5].into_iter() {
+        dbg!(item);
     }
 }
diff --git a/tests/ui/single_element_loop.stderr b/tests/ui/single_element_loop.stderr
index f52ca8c5a9b..0aeb8da1a2e 100644
--- a/tests/ui/single_element_loop.stderr
+++ b/tests/ui/single_element_loop.stderr
@@ -2,7 +2,7 @@ error: for loop over a single element
   --> $DIR/single_element_loop.rs:7:5
    |
 LL | /     for item in &[item1] {
-LL | |         println!("{}", item);
+LL | |         dbg!(item);
 LL | |     }
    | |_____^
    |
@@ -11,7 +11,7 @@ help: try
    |
 LL ~     {
 LL +         let item = &item1;
-LL +         println!("{}", item);
+LL +         dbg!(item);
 LL +     }
    |
 
@@ -19,7 +19,7 @@ error: for loop over a single element
   --> $DIR/single_element_loop.rs:11:5
    |
 LL | /     for item in [item1].iter() {
-LL | |         println!("{:?}", item);
+LL | |         dbg!(item);
 LL | |     }
    | |_____^
    |
@@ -27,9 +27,73 @@ help: try
    |
 LL ~     {
 LL +         let item = &item1;
-LL +         println!("{:?}", item);
+LL +         dbg!(item);
 LL +     }
    |
 
-error: aborting due to 2 previous errors
+error: for loop over a single element
+  --> $DIR/single_element_loop.rs:15:5
+   |
+LL | /     for item in &[0..5] {
+LL | |         dbg!(item);
+LL | |     }
+   | |_____^
+   |
+help: try
+   |
+LL ~     {
+LL +         let item = &(0..5);
+LL +         dbg!(item);
+LL +     }
+   |
+
+error: for loop over a single element
+  --> $DIR/single_element_loop.rs:19:5
+   |
+LL | /     for item in [0..5].iter_mut() {
+LL | |         dbg!(item);
+LL | |     }
+   | |_____^
+   |
+help: try
+   |
+LL ~     {
+LL +         let item = &mut (0..5);
+LL +         dbg!(item);
+LL +     }
+   |
+
+error: for loop over a single element
+  --> $DIR/single_element_loop.rs:23:5
+   |
+LL | /     for item in [0..5] {
+LL | |         dbg!(item);
+LL | |     }
+   | |_____^
+   |
+help: try
+   |
+LL ~     {
+LL +         let item = 0..5;
+LL +         dbg!(item);
+LL +     }
+   |
+
+error: for loop over a single element
+  --> $DIR/single_element_loop.rs:27:5
+   |
+LL | /     for item in [0..5].into_iter() {
+LL | |         dbg!(item);
+LL | |     }
+   | |_____^
+   |
+help: try
+   |
+LL ~     {
+LL +         let item = 0..5;
+LL +         dbg!(item);
+LL +     }
+   |
+
+error: aborting due to 6 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From c70f1e0f8f3419f67dc31b5bbbc47db1e829128c Mon Sep 17 00:00:00 2001
From: Peter Jaszkowiak <p.jaszkow@gmail.com>
Date: Fri, 1 Apr 2022 22:36:30 -0600
Subject: ignore `&x | &y` in unnested_or_patterns

replacing it with `&(x | y)` is actually more characters
---
 clippy_lints/src/unnested_or_patterns.rs | 12 ++++++----
 tests/ui/unnested_or_patterns.fixed      |  7 ++++--
 tests/ui/unnested_or_patterns.rs         |  7 ++++--
 tests/ui/unnested_or_patterns.stderr     | 40 ++++++++++++++++----------------
 4 files changed, 38 insertions(+), 28 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unnested_or_patterns.rs b/clippy_lints/src/unnested_or_patterns.rs
index 1d4fe9cfd3c..790ffe618d7 100644
--- a/clippy_lints/src/unnested_or_patterns.rs
+++ b/clippy_lints/src/unnested_or_patterns.rs
@@ -5,7 +5,7 @@ use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::{meets_msrv, msrvs, over};
 use rustc_ast::mut_visit::*;
 use rustc_ast::ptr::P;
-use rustc_ast::{self as ast, Pat, PatKind, PatKind::*, DUMMY_NODE_ID};
+use rustc_ast::{self as ast, Mutability, Pat, PatKind, PatKind::*, DUMMY_NODE_ID};
 use rustc_ast_pretty::pprust;
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass};
@@ -230,6 +230,10 @@ fn transform_with_focus_on_idx(alternatives: &mut Vec<P<Pat>>, focus_idx: usize)
         // with which a pattern `C(p_0)` may be formed,
         // which we would want to join with other `C(p_j)`s.
         Ident(.., None) | Lit(_) | Wild | Path(..) | Range(..) | Rest | MacCall(_)
+        // Skip immutable refs, as grouping them saves few characters,
+        // and almost always requires adding parens (increasing noisiness).
+        // In the case of only two patterns, replacement adds net characters.
+        | Ref(_, Mutability::Not)
         // Dealt with elsewhere.
         | Or(_) | Paren(_) => false,
         // Transform `box x | ... | box y` into `box (x | y)`.
@@ -241,10 +245,10 @@ fn transform_with_focus_on_idx(alternatives: &mut Vec<P<Pat>>, focus_idx: usize)
             |k| matches!(k, Box(_)),
             |k| always_pat!(k, Box(p) => p),
         ),
-        // Transform `&m x | ... | &m y` into `&m (x | y)`.
-        Ref(target, m1) => extend_with_matching(
+        // Transform `&mut x | ... | &mut y` into `&mut (x | y)`.
+        Ref(target, Mutability::Mut) => extend_with_matching(
             target, start, alternatives,
-            |k| matches!(k, Ref(_, m2) if m1 == m2), // Mutabilities must match.
+            |k| matches!(k, Ref(_, Mutability::Mut)),
             |k| always_pat!(k, Ref(p, _) => p),
         ),
         // Transform `b @ p0 | ... b @ p1` into `b @ (p0 | p1)`.
diff --git a/tests/ui/unnested_or_patterns.fixed b/tests/ui/unnested_or_patterns.fixed
index 46463a29e9b..c223b5bc711 100644
--- a/tests/ui/unnested_or_patterns.fixed
+++ b/tests/ui/unnested_or_patterns.fixed
@@ -6,10 +6,13 @@
 #![allow(unreachable_patterns, irrefutable_let_patterns, unused_variables)]
 
 fn main() {
+    // Should be ignored by this lint, as nesting requires more characters.
+    if let &0 | &2 = &0 {}
+
     if let box (0 | 2) = Box::new(0) {}
     if let box (0 | 1 | 2 | 3 | 4) = Box::new(0) {}
-    const C0: &u8 = &1;
-    if let &(0 | 2) | C0 = &0 {}
+    const C0: Option<u8> = Some(1);
+    if let Some(1 | 2) | C0 = None {}
     if let &mut (0 | 2) = &mut 0 {}
     if let x @ (0 | 2) = 0 {}
     if let (0, 1 | 2 | 3) = (0, 0) {}
diff --git a/tests/ui/unnested_or_patterns.rs b/tests/ui/unnested_or_patterns.rs
index 8ce0738bfc2..04cd11036e4 100644
--- a/tests/ui/unnested_or_patterns.rs
+++ b/tests/ui/unnested_or_patterns.rs
@@ -6,10 +6,13 @@
 #![allow(unreachable_patterns, irrefutable_let_patterns, unused_variables)]
 
 fn main() {
+    // Should be ignored by this lint, as nesting requires more characters.
+    if let &0 | &2 = &0 {}
+
     if let box 0 | box 2 = Box::new(0) {}
     if let box ((0 | 1)) | box (2 | 3) | box 4 = Box::new(0) {}
-    const C0: &u8 = &1;
-    if let &0 | C0 | &2 = &0 {}
+    const C0: Option<u8> = Some(1);
+    if let Some(1) | C0 | Some(2) = None {}
     if let &mut 0 | &mut 2 = &mut 0 {}
     if let x @ 0 | x @ 2 = 0 {}
     if let (0, 1) | (0, 2) | (0, 3) = (0, 0) {}
diff --git a/tests/ui/unnested_or_patterns.stderr b/tests/ui/unnested_or_patterns.stderr
index de424c3fdb8..453c66cbba8 100644
--- a/tests/ui/unnested_or_patterns.stderr
+++ b/tests/ui/unnested_or_patterns.stderr
@@ -1,5 +1,5 @@
 error: unnested or-patterns
-  --> $DIR/unnested_or_patterns.rs:9:12
+  --> $DIR/unnested_or_patterns.rs:12:12
    |
 LL |     if let box 0 | box 2 = Box::new(0) {}
    |            ^^^^^^^^^^^^^
@@ -11,7 +11,7 @@ LL |     if let box (0 | 2) = Box::new(0) {}
    |            ~~~~~~~~~~~
 
 error: unnested or-patterns
-  --> $DIR/unnested_or_patterns.rs:10:12
+  --> $DIR/unnested_or_patterns.rs:13:12
    |
 LL |     if let box ((0 | 1)) | box (2 | 3) | box 4 = Box::new(0) {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -22,18 +22,18 @@ LL |     if let box (0 | 1 | 2 | 3 | 4) = Box::new(0) {}
    |            ~~~~~~~~~~~~~~~~~~~~~~~
 
 error: unnested or-patterns
-  --> $DIR/unnested_or_patterns.rs:12:12
+  --> $DIR/unnested_or_patterns.rs:15:12
    |
-LL |     if let &0 | C0 | &2 = &0 {}
-   |            ^^^^^^^^^^^^
+LL |     if let Some(1) | C0 | Some(2) = None {}
+   |            ^^^^^^^^^^^^^^^^^^^^^^
    |
 help: nest the patterns
    |
-LL |     if let &(0 | 2) | C0 = &0 {}
-   |            ~~~~~~~~~~~~~
+LL |     if let Some(1 | 2) | C0 = None {}
+   |            ~~~~~~~~~~~~~~~~
 
 error: unnested or-patterns
-  --> $DIR/unnested_or_patterns.rs:13:12
+  --> $DIR/unnested_or_patterns.rs:16:12
    |
 LL |     if let &mut 0 | &mut 2 = &mut 0 {}
    |            ^^^^^^^^^^^^^^^
@@ -44,7 +44,7 @@ LL |     if let &mut (0 | 2) = &mut 0 {}
    |            ~~~~~~~~~~~~
 
 error: unnested or-patterns
-  --> $DIR/unnested_or_patterns.rs:14:12
+  --> $DIR/unnested_or_patterns.rs:17:12
    |
 LL |     if let x @ 0 | x @ 2 = 0 {}
    |            ^^^^^^^^^^^^^
@@ -55,7 +55,7 @@ LL |     if let x @ (0 | 2) = 0 {}
    |            ~~~~~~~~~~~
 
 error: unnested or-patterns
-  --> $DIR/unnested_or_patterns.rs:15:12
+  --> $DIR/unnested_or_patterns.rs:18:12
    |
 LL |     if let (0, 1) | (0, 2) | (0, 3) = (0, 0) {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -66,7 +66,7 @@ LL |     if let (0, 1 | 2 | 3) = (0, 0) {}
    |            ~~~~~~~~~~~~~~
 
 error: unnested or-patterns
-  --> $DIR/unnested_or_patterns.rs:16:12
+  --> $DIR/unnested_or_patterns.rs:19:12
    |
 LL |     if let (1, 0) | (2, 0) | (3, 0) = (0, 0) {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -77,7 +77,7 @@ LL |     if let (1 | 2 | 3, 0) = (0, 0) {}
    |            ~~~~~~~~~~~~~~
 
 error: unnested or-patterns
-  --> $DIR/unnested_or_patterns.rs:17:12
+  --> $DIR/unnested_or_patterns.rs:20:12
    |
 LL |     if let (x, ..) | (x, 1) | (x, 2) = (0, 1) {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -88,7 +88,7 @@ LL |     if let (x, ..) | (x, 1 | 2) = (0, 1) {}
    |            ~~~~~~~~~~~~~~~~~~~~
 
 error: unnested or-patterns
-  --> $DIR/unnested_or_patterns.rs:18:12
+  --> $DIR/unnested_or_patterns.rs:21:12
    |
 LL |     if let [0] | [1] = [0] {}
    |            ^^^^^^^^^
@@ -99,7 +99,7 @@ LL |     if let [0 | 1] = [0] {}
    |            ~~~~~~~
 
 error: unnested or-patterns
-  --> $DIR/unnested_or_patterns.rs:19:12
+  --> $DIR/unnested_or_patterns.rs:22:12
    |
 LL |     if let [x, 0] | [x, 1] = [0, 1] {}
    |            ^^^^^^^^^^^^^^^
@@ -110,7 +110,7 @@ LL |     if let [x, 0 | 1] = [0, 1] {}
    |            ~~~~~~~~~~
 
 error: unnested or-patterns
-  --> $DIR/unnested_or_patterns.rs:20:12
+  --> $DIR/unnested_or_patterns.rs:23:12
    |
 LL |     if let [x, 0] | [x, 1] | [x, 2] = [0, 1] {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -121,7 +121,7 @@ LL |     if let [x, 0 | 1 | 2] = [0, 1] {}
    |            ~~~~~~~~~~~~~~
 
 error: unnested or-patterns
-  --> $DIR/unnested_or_patterns.rs:21:12
+  --> $DIR/unnested_or_patterns.rs:24:12
    |
 LL |     if let [x, ..] | [x, 1] | [x, 2] = [0, 1] {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -132,7 +132,7 @@ LL |     if let [x, ..] | [x, 1 | 2] = [0, 1] {}
    |            ~~~~~~~~~~~~~~~~~~~~
 
 error: unnested or-patterns
-  --> $DIR/unnested_or_patterns.rs:23:12
+  --> $DIR/unnested_or_patterns.rs:26:12
    |
 LL |     if let TS(0, x) | TS(1, x) = TS(0, 0) {}
    |            ^^^^^^^^^^^^^^^^^^^
@@ -143,7 +143,7 @@ LL |     if let TS(0 | 1, x) = TS(0, 0) {}
    |            ~~~~~~~~~~~~
 
 error: unnested or-patterns
-  --> $DIR/unnested_or_patterns.rs:24:12
+  --> $DIR/unnested_or_patterns.rs:27:12
    |
 LL |     if let TS(1, 0) | TS(2, 0) | TS(3, 0) = TS(0, 0) {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -154,7 +154,7 @@ LL |     if let TS(1 | 2 | 3, 0) = TS(0, 0) {}
    |            ~~~~~~~~~~~~~~~~
 
 error: unnested or-patterns
-  --> $DIR/unnested_or_patterns.rs:25:12
+  --> $DIR/unnested_or_patterns.rs:28:12
    |
 LL |     if let TS(x, ..) | TS(x, 1) | TS(x, 2) = TS(0, 0) {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -165,7 +165,7 @@ LL |     if let TS(x, ..) | TS(x, 1 | 2) = TS(0, 0) {}
    |            ~~~~~~~~~~~~~~~~~~~~~~~~
 
 error: unnested or-patterns
-  --> $DIR/unnested_or_patterns.rs:30:12
+  --> $DIR/unnested_or_patterns.rs:33:12
    |
 LL |     if let S { x: 0, y } | S { y, x: 1 } = (S { x: 0, y: 1 }) {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From 17c8bee95a43cf9c39ec766cdaa8c6219f4126dd Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sat, 2 Apr 2022 00:46:45 -0400
Subject: Add a couple of examples to `undocumented_unsafe_blocks`

---
 clippy_lints/src/undocumented_unsafe_blocks.rs | 18 ++++++++++
 tests/ui/undocumented_unsafe_blocks.rs         |  5 +++
 tests/ui/undocumented_unsafe_blocks.stderr     | 46 +++++++++++++++-----------
 3 files changed, 50 insertions(+), 19 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/undocumented_unsafe_blocks.rs b/clippy_lints/src/undocumented_unsafe_blocks.rs
index ac13a309e7b..c0947685fa1 100644
--- a/clippy_lints/src/undocumented_unsafe_blocks.rs
+++ b/clippy_lints/src/undocumented_unsafe_blocks.rs
@@ -15,6 +15,24 @@ declare_clippy_lint! {
     /// explaining why the unsafe operations performed inside
     /// the block are safe.
     ///
+    /// Note the comment must appear on the line(s) preceding the unsafe block
+    /// with nothing appearing in between. The following is ok:
+    /// ```ignore
+    /// foo(
+    ///     // SAFETY:
+    ///     // This is a valid safety comment
+    ///     unsafe { *x }
+    /// )
+    /// ```
+    /// But neither of these are:
+    /// ```ignore
+    /// // SAFETY:
+    /// // This is not a valid safety comment
+    /// foo(
+    ///     /* SAFETY: Neither is this */ unsafe { *x },
+    /// );
+    /// ```
+    ///
     /// ### Why is this bad?
     /// Undocumented unsafe blocks can make it difficult to
     /// read and maintain code, as well as uncover unsoundness
diff --git a/tests/ui/undocumented_unsafe_blocks.rs b/tests/ui/undocumented_unsafe_blocks.rs
index 80fb198ab53..afa337c45f4 100644
--- a/tests/ui/undocumented_unsafe_blocks.rs
+++ b/tests/ui/undocumented_unsafe_blocks.rs
@@ -251,6 +251,11 @@ fn from_proc_macro() {
 
 // Invalid comments
 
+#[rustfmt::skip]
+fn inline_block_comment() {
+    /* Safety: */ unsafe {}
+}
+
 fn no_comment() {
     unsafe {}
 }
diff --git a/tests/ui/undocumented_unsafe_blocks.stderr b/tests/ui/undocumented_unsafe_blocks.stderr
index 746bbe2f141..856a07fd316 100644
--- a/tests/ui/undocumented_unsafe_blocks.stderr
+++ b/tests/ui/undocumented_unsafe_blocks.stderr
@@ -1,14 +1,22 @@
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:255:5
+  --> $DIR/undocumented_unsafe_blocks.rs:256:19
+   |
+LL |     /* Safety: */ unsafe {}
+   |                   ^^^^^^^^^
+   |
+   = note: `-D clippy::undocumented-unsafe-blocks` implied by `-D warnings`
+   = help: consider adding a safety comment on the preceding line
+
+error: unsafe block missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:260:5
    |
 LL |     unsafe {}
    |     ^^^^^^^^^
    |
-   = note: `-D clippy::undocumented-unsafe-blocks` implied by `-D warnings`
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:259:14
+  --> $DIR/undocumented_unsafe_blocks.rs:264:14
    |
 LL |     let _ = [unsafe { 14 }, unsafe { 15 }, 42, unsafe { 16 }];
    |              ^^^^^^^^^^^^^
@@ -16,7 +24,7 @@ LL |     let _ = [unsafe { 14 }, unsafe { 15 }, 42, unsafe { 16 }];
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:259:29
+  --> $DIR/undocumented_unsafe_blocks.rs:264:29
    |
 LL |     let _ = [unsafe { 14 }, unsafe { 15 }, 42, unsafe { 16 }];
    |                             ^^^^^^^^^^^^^
@@ -24,7 +32,7 @@ LL |     let _ = [unsafe { 14 }, unsafe { 15 }, 42, unsafe { 16 }];
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:259:48
+  --> $DIR/undocumented_unsafe_blocks.rs:264:48
    |
 LL |     let _ = [unsafe { 14 }, unsafe { 15 }, 42, unsafe { 16 }];
    |                                                ^^^^^^^^^^^^^
@@ -32,7 +40,7 @@ LL |     let _ = [unsafe { 14 }, unsafe { 15 }, 42, unsafe { 16 }];
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:263:18
+  --> $DIR/undocumented_unsafe_blocks.rs:268:18
    |
 LL |     let _ = (42, unsafe {}, "test", unsafe {});
    |                  ^^^^^^^^^
@@ -40,7 +48,7 @@ LL |     let _ = (42, unsafe {}, "test", unsafe {});
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:263:37
+  --> $DIR/undocumented_unsafe_blocks.rs:268:37
    |
 LL |     let _ = (42, unsafe {}, "test", unsafe {});
    |                                     ^^^^^^^^^
@@ -48,7 +56,7 @@ LL |     let _ = (42, unsafe {}, "test", unsafe {});
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:267:14
+  --> $DIR/undocumented_unsafe_blocks.rs:272:14
    |
 LL |     let _ = *unsafe { &42 };
    |              ^^^^^^^^^^^^^^
@@ -56,7 +64,7 @@ LL |     let _ = *unsafe { &42 };
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:272:19
+  --> $DIR/undocumented_unsafe_blocks.rs:277:19
    |
 LL |     let _ = match unsafe {} {
    |                   ^^^^^^^^^
@@ -64,7 +72,7 @@ LL |     let _ = match unsafe {} {
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:278:14
+  --> $DIR/undocumented_unsafe_blocks.rs:283:14
    |
 LL |     let _ = &unsafe {};
    |              ^^^^^^^^^
@@ -72,7 +80,7 @@ LL |     let _ = &unsafe {};
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:282:14
+  --> $DIR/undocumented_unsafe_blocks.rs:287:14
    |
 LL |     let _ = [unsafe {}; 5];
    |              ^^^^^^^^^
@@ -80,7 +88,7 @@ LL |     let _ = [unsafe {}; 5];
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:286:13
+  --> $DIR/undocumented_unsafe_blocks.rs:291:13
    |
 LL |     let _ = unsafe {};
    |             ^^^^^^^^^
@@ -88,7 +96,7 @@ LL |     let _ = unsafe {};
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:296:8
+  --> $DIR/undocumented_unsafe_blocks.rs:301:8
    |
 LL |     t!(unsafe {});
    |        ^^^^^^^^^
@@ -96,7 +104,7 @@ LL |     t!(unsafe {});
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:302:13
+  --> $DIR/undocumented_unsafe_blocks.rs:307:13
    |
 LL |             unsafe {}
    |             ^^^^^^^^^
@@ -108,7 +116,7 @@ LL |     t!();
    = note: this error originates in the macro `t` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:310:5
+  --> $DIR/undocumented_unsafe_blocks.rs:315:5
    |
 LL |     unsafe {} // SAFETY:
    |     ^^^^^^^^^
@@ -116,7 +124,7 @@ LL |     unsafe {} // SAFETY:
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:314:5
+  --> $DIR/undocumented_unsafe_blocks.rs:319:5
    |
 LL |     unsafe {
    |     ^^^^^^^^
@@ -124,7 +132,7 @@ LL |     unsafe {
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:324:5
+  --> $DIR/undocumented_unsafe_blocks.rs:329:5
    |
 LL |     unsafe {};
    |     ^^^^^^^^^
@@ -132,12 +140,12 @@ LL |     unsafe {};
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:328:20
+  --> $DIR/undocumented_unsafe_blocks.rs:333:20
    |
 LL |     println!("{}", unsafe { String::from_utf8_unchecked(vec![]) });
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: consider adding a safety comment on the preceding line
 
-error: aborting due to 17 previous errors
+error: aborting due to 18 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From d5ef542d376877380fda93ac7c457b5b8ba66833 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sun, 3 Apr 2022 08:51:17 -0400
Subject: Generate renamed lint test

---
 clippy_dev/src/update_lints.rs    | 73 ++++++++++++++++++++++++++++++++++-----
 clippy_lints/src/lib.rs           | 42 +++-------------------
 clippy_lints/src/renamed_lints.rs | 37 ++++++++++++++++++++
 tests/ui/rename.fixed             | 15 ++++----
 tests/ui/rename.rs                | 15 ++++----
 tests/ui/rename.stderr            | 30 ++++++++--------
 6 files changed, 135 insertions(+), 77 deletions(-)
 create mode 100644 clippy_lints/src/renamed_lints.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_dev/src/update_lints.rs b/clippy_dev/src/update_lints.rs
index b010149626c..f15b00ecad1 100644
--- a/clippy_dev/src/update_lints.rs
+++ b/clippy_dev/src/update_lints.rs
@@ -1,7 +1,7 @@
 use core::fmt::Write;
 use itertools::Itertools;
 use rustc_lexer::{tokenize, unescape, LiteralKind, TokenKind};
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 use std::ffi::OsStr;
 use std::fs;
 use std::path::Path;
@@ -32,7 +32,7 @@ pub enum UpdateMode {
 /// Panics if a file path could not read from or then written to
 #[allow(clippy::too_many_lines)]
 pub fn run(update_mode: UpdateMode) {
-    let (lints, deprecated_lints) = gather_all();
+    let (lints, deprecated_lints, renamed_lints) = gather_all();
 
     let internal_lints = Lint::internal_lints(&lints);
     let usable_lints = Lint::usable_lints(&lints);
@@ -110,10 +110,13 @@ pub fn run(update_mode: UpdateMode) {
 
     let content = gen_deprecated_lints_test(&deprecated_lints);
     process_file("tests/ui/deprecated.rs", update_mode, &content);
+
+    let content = gen_renamed_lints_test(&renamed_lints);
+    process_file("tests/ui/rename.rs", update_mode, &content);
 }
 
 pub fn print_lints() {
-    let (lint_list, _) = gather_all();
+    let (lint_list, _, _) = gather_all();
     let usable_lints = Lint::usable_lints(&lint_list);
     let usable_lint_count = usable_lints.len();
     let grouped_by_lint_group = Lint::by_lint_group(usable_lints.into_iter());
@@ -213,6 +216,19 @@ impl DeprecatedLint {
     }
 }
 
+struct RenamedLint {
+    old_name: String,
+    new_name: String,
+}
+impl RenamedLint {
+    fn new(old_name: &str, new_name: &str) -> Self {
+        Self {
+            old_name: remove_line_splices(old_name),
+            new_name: remove_line_splices(new_name),
+        }
+    }
+}
+
 /// Generates the code for registering a group
 fn gen_lint_group_list<'a>(group_name: &str, lints: impl Iterator<Item = &'a Lint>) -> String {
     let mut details: Vec<_> = lints.map(|l| (&l.module, l.name.to_uppercase())).collect();
@@ -288,10 +304,30 @@ fn gen_deprecated_lints_test(lints: &[DeprecatedLint]) -> String {
     res
 }
 
+fn gen_renamed_lints_test(lints: &[RenamedLint]) -> String {
+    let mut seen_lints = HashSet::new();
+    let mut res: String = GENERATED_FILE_COMMENT.into();
+    res.push_str("// run-rustfix\n\n");
+    for lint in lints {
+        if seen_lints.insert(&lint.new_name) {
+            writeln!(res, "#![allow({})]", lint.new_name).unwrap();
+        }
+    }
+    seen_lints.clear();
+    for lint in lints {
+        if seen_lints.insert(&lint.old_name) {
+            writeln!(res, "#![warn({})]", lint.old_name).unwrap();
+        }
+    }
+    res.push_str("\nfn main() {}\n");
+    res
+}
+
 /// Gathers all lints defined in `clippy_lints/src`
-fn gather_all() -> (Vec<Lint>, Vec<DeprecatedLint>) {
+fn gather_all() -> (Vec<Lint>, Vec<DeprecatedLint>, Vec<RenamedLint>) {
     let mut lints = Vec::with_capacity(1000);
     let mut deprecated_lints = Vec::with_capacity(50);
+    let mut renamed_lints = Vec::with_capacity(50);
     let root_path = clippy_project_root().join("clippy_lints/src");
 
     for (rel_path, file) in WalkDir::new(&root_path)
@@ -317,13 +353,13 @@ fn gather_all() -> (Vec<Lint>, Vec<DeprecatedLint>) {
             module.strip_suffix(".rs").unwrap_or(&module)
         };
 
-        if module == "deprecated_lints" {
-            parse_deprecated_contents(&contents, &mut deprecated_lints);
-        } else {
-            parse_contents(&contents, module, &mut lints);
+        match module {
+            "deprecated_lints" => parse_deprecated_contents(&contents, &mut deprecated_lints),
+            "renamed_lints" => parse_renamed_contents(&contents, &mut renamed_lints),
+            _ => parse_contents(&contents, module, &mut lints),
         }
     }
-    (lints, deprecated_lints)
+    (lints, deprecated_lints, renamed_lints)
 }
 
 macro_rules! match_tokens {
@@ -406,6 +442,25 @@ fn parse_deprecated_contents(contents: &str, lints: &mut Vec<DeprecatedLint>) {
     }
 }
 
+fn parse_renamed_contents(contents: &str, lints: &mut Vec<RenamedLint>) {
+    for line in contents.lines() {
+        let mut offset = 0usize;
+        let mut iter = tokenize(line).map(|t| {
+            let range = offset..offset + t.len;
+            offset = range.end;
+            (t.kind, &line[range])
+        });
+        let (old_name, new_name) = match_tokens!(
+            iter,
+            // ("old_name",
+            Whitespace OpenParen Literal{kind: LiteralKind::Str{..},..}(old_name) Comma
+            // "new_name"),
+            Whitespace Literal{kind: LiteralKind::Str{..},..}(new_name) CloseParen Comma
+        );
+        lints.push(RenamedLint::new(old_name, new_name));
+    }
+}
+
 /// Removes the line splices and surrounding quotes from a string literal
 fn remove_line_splices(s: &str) -> String {
     let s = s
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index c8b57956b1b..9812cfde3ec 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -162,6 +162,8 @@ mod deprecated_lints;
 #[cfg_attr(feature = "internal", allow(clippy::missing_clippy_version_attribute))]
 mod utils;
 
+mod renamed_lints;
+
 // begin lints modules, do not remove this comment, it’s used in `update_lints`
 mod absurd_extreme_comparisons;
 mod approx_const;
@@ -920,43 +922,9 @@ fn register_removed_non_tool_lints(store: &mut rustc_lint::LintStore) {
 ///
 /// Used in `./src/driver.rs`.
 pub fn register_renamed(ls: &mut rustc_lint::LintStore) {
-    // NOTE: when renaming a lint, add a corresponding test to tests/ui/rename.rs
-    ls.register_renamed("clippy::stutter", "clippy::module_name_repetitions");
-    ls.register_renamed("clippy::new_without_default_derive", "clippy::new_without_default");
-    ls.register_renamed("clippy::cyclomatic_complexity", "clippy::cognitive_complexity");
-    ls.register_renamed("clippy::const_static_lifetime", "clippy::redundant_static_lifetimes");
-    ls.register_renamed("clippy::option_and_then_some", "clippy::bind_instead_of_map");
-    ls.register_renamed("clippy::box_vec", "clippy::box_collection");
-    ls.register_renamed("clippy::block_in_if_condition_expr", "clippy::blocks_in_if_conditions");
-    ls.register_renamed("clippy::block_in_if_condition_stmt", "clippy::blocks_in_if_conditions");
-    ls.register_renamed("clippy::option_map_unwrap_or", "clippy::map_unwrap_or");
-    ls.register_renamed("clippy::option_map_unwrap_or_else", "clippy::map_unwrap_or");
-    ls.register_renamed("clippy::result_map_unwrap_or_else", "clippy::map_unwrap_or");
-    ls.register_renamed("clippy::option_unwrap_used", "clippy::unwrap_used");
-    ls.register_renamed("clippy::result_unwrap_used", "clippy::unwrap_used");
-    ls.register_renamed("clippy::option_expect_used", "clippy::expect_used");
-    ls.register_renamed("clippy::result_expect_used", "clippy::expect_used");
-    ls.register_renamed("clippy::for_loop_over_option", "clippy::for_loops_over_fallibles");
-    ls.register_renamed("clippy::for_loop_over_result", "clippy::for_loops_over_fallibles");
-    ls.register_renamed("clippy::identity_conversion", "clippy::useless_conversion");
-    ls.register_renamed("clippy::zero_width_space", "clippy::invisible_characters");
-    ls.register_renamed("clippy::single_char_push_str", "clippy::single_char_add_str");
-    ls.register_renamed("clippy::if_let_some_result", "clippy::match_result_ok");
-    ls.register_renamed("clippy::disallowed_type", "clippy::disallowed_types");
-    ls.register_renamed("clippy::disallowed_method", "clippy::disallowed_methods");
-    ls.register_renamed("clippy::ref_in_deref", "clippy::needless_borrow");
-    ls.register_renamed("clippy::to_string_in_display", "clippy::recursive_format_impl");
-
-    // uplifted lints
-    ls.register_renamed("clippy::invalid_ref", "invalid_value");
-    ls.register_renamed("clippy::into_iter_on_array", "array_into_iter");
-    ls.register_renamed("clippy::unused_label", "unused_labels");
-    ls.register_renamed("clippy::drop_bounds", "drop_bounds");
-    ls.register_renamed("clippy::temporary_cstring_as_ptr", "temporary_cstring_as_ptr");
-    ls.register_renamed("clippy::panic_params", "non_fmt_panics");
-    ls.register_renamed("clippy::unknown_clippy_lints", "unknown_lints");
-    ls.register_renamed("clippy::invalid_atomic_ordering", "invalid_atomic_ordering");
-    ls.register_renamed("clippy::mem_discriminant_non_enum", "enum_intrinsics_non_enums");
+    for (old_name, new_name) in renamed_lints::RENAMED_LINTS {
+        ls.register_renamed(old_name, new_name);
+    }
 }
 
 // only exists to let the dogfood integration test works.
diff --git a/clippy_lints/src/renamed_lints.rs b/clippy_lints/src/renamed_lints.rs
new file mode 100644
index 00000000000..e10dc0e1bfe
--- /dev/null
+++ b/clippy_lints/src/renamed_lints.rs
@@ -0,0 +1,37 @@
+pub static RENAMED_LINTS: &[(&str, &str)] = &[
+    ("clippy::stutter", "clippy::module_name_repetitions"),
+    ("clippy::new_without_default_derive", "clippy::new_without_default"),
+    ("clippy::cyclomatic_complexity", "clippy::cognitive_complexity"),
+    ("clippy::const_static_lifetime", "clippy::redundant_static_lifetimes"),
+    ("clippy::option_and_then_some", "clippy::bind_instead_of_map"),
+    ("clippy::box_vec", "clippy::box_collection"),
+    ("clippy::block_in_if_condition_expr", "clippy::blocks_in_if_conditions"),
+    ("clippy::block_in_if_condition_stmt", "clippy::blocks_in_if_conditions"),
+    ("clippy::option_map_unwrap_or", "clippy::map_unwrap_or"),
+    ("clippy::option_map_unwrap_or_else", "clippy::map_unwrap_or"),
+    ("clippy::result_map_unwrap_or_else", "clippy::map_unwrap_or"),
+    ("clippy::option_unwrap_used", "clippy::unwrap_used"),
+    ("clippy::result_unwrap_used", "clippy::unwrap_used"),
+    ("clippy::option_expect_used", "clippy::expect_used"),
+    ("clippy::result_expect_used", "clippy::expect_used"),
+    ("clippy::for_loop_over_option", "clippy::for_loops_over_fallibles"),
+    ("clippy::for_loop_over_result", "clippy::for_loops_over_fallibles"),
+    ("clippy::identity_conversion", "clippy::useless_conversion"),
+    ("clippy::zero_width_space", "clippy::invisible_characters"),
+    ("clippy::single_char_push_str", "clippy::single_char_add_str"),
+    ("clippy::if_let_some_result", "clippy::match_result_ok"),
+    ("clippy::disallowed_type", "clippy::disallowed_types"),
+    ("clippy::disallowed_method", "clippy::disallowed_methods"),
+    ("clippy::ref_in_deref", "clippy::needless_borrow"),
+    ("clippy::to_string_in_display", "clippy::recursive_format_impl"),
+    // uplifted lints
+    ("clippy::invalid_ref", "invalid_value"),
+    ("clippy::into_iter_on_array", "array_into_iter"),
+    ("clippy::unused_label", "unused_labels"),
+    ("clippy::drop_bounds", "drop_bounds"),
+    ("clippy::temporary_cstring_as_ptr", "temporary_cstring_as_ptr"),
+    ("clippy::panic_params", "non_fmt_panics"),
+    ("clippy::unknown_clippy_lints", "unknown_lints"),
+    ("clippy::invalid_atomic_ordering", "invalid_atomic_ordering"),
+    ("clippy::mem_discriminant_non_enum", "enum_intrinsics_non_enums"),
+];
diff --git a/tests/ui/rename.fixed b/tests/ui/rename.fixed
index 24a0c812291..325f63a64dd 100644
--- a/tests/ui/rename.fixed
+++ b/tests/ui/rename.fixed
@@ -1,12 +1,13 @@
-//! Test for Clippy lint renames.
+// This file was generated by `cargo dev update_lints`.
+// Use that command to update this file and do not edit by hand.
+// Manual edits will be overwritten.
+
 // run-rustfix
 
-#![allow(dead_code)]
-// allow the new lint name here, to test if the new name works
 #![allow(clippy::module_name_repetitions)]
 #![allow(clippy::new_without_default)]
-#![allow(clippy::redundant_static_lifetimes)]
 #![allow(clippy::cognitive_complexity)]
+#![allow(clippy::redundant_static_lifetimes)]
 #![allow(clippy::bind_instead_of_map)]
 #![allow(clippy::box_collection)]
 #![allow(clippy::blocks_in_if_conditions)]
@@ -20,8 +21,8 @@
 #![allow(clippy::match_result_ok)]
 #![allow(clippy::disallowed_types)]
 #![allow(clippy::disallowed_methods)]
+#![allow(clippy::needless_borrow)]
 #![allow(clippy::recursive_format_impl)]
-// uplifted lints
 #![allow(invalid_value)]
 #![allow(array_into_iter)]
 #![allow(unused_labels)]
@@ -31,11 +32,10 @@
 #![allow(unknown_lints)]
 #![allow(invalid_atomic_ordering)]
 #![allow(enum_intrinsics_non_enums)]
-// warn for the old lint name here, to test if the renaming worked
 #![warn(clippy::module_name_repetitions)]
 #![warn(clippy::new_without_default)]
-#![warn(clippy::redundant_static_lifetimes)]
 #![warn(clippy::cognitive_complexity)]
+#![warn(clippy::redundant_static_lifetimes)]
 #![warn(clippy::bind_instead_of_map)]
 #![warn(clippy::box_collection)]
 #![warn(clippy::blocks_in_if_conditions)]
@@ -57,7 +57,6 @@
 #![warn(clippy::disallowed_methods)]
 #![warn(clippy::needless_borrow)]
 #![warn(clippy::recursive_format_impl)]
-// uplifted lints
 #![warn(invalid_value)]
 #![warn(array_into_iter)]
 #![warn(unused_labels)]
diff --git a/tests/ui/rename.rs b/tests/ui/rename.rs
index ea64234c680..a21b4a24288 100644
--- a/tests/ui/rename.rs
+++ b/tests/ui/rename.rs
@@ -1,12 +1,13 @@
-//! Test for Clippy lint renames.
+// This file was generated by `cargo dev update_lints`.
+// Use that command to update this file and do not edit by hand.
+// Manual edits will be overwritten.
+
 // run-rustfix
 
-#![allow(dead_code)]
-// allow the new lint name here, to test if the new name works
 #![allow(clippy::module_name_repetitions)]
 #![allow(clippy::new_without_default)]
-#![allow(clippy::redundant_static_lifetimes)]
 #![allow(clippy::cognitive_complexity)]
+#![allow(clippy::redundant_static_lifetimes)]
 #![allow(clippy::bind_instead_of_map)]
 #![allow(clippy::box_collection)]
 #![allow(clippy::blocks_in_if_conditions)]
@@ -20,8 +21,8 @@
 #![allow(clippy::match_result_ok)]
 #![allow(clippy::disallowed_types)]
 #![allow(clippy::disallowed_methods)]
+#![allow(clippy::needless_borrow)]
 #![allow(clippy::recursive_format_impl)]
-// uplifted lints
 #![allow(invalid_value)]
 #![allow(array_into_iter)]
 #![allow(unused_labels)]
@@ -31,11 +32,10 @@
 #![allow(unknown_lints)]
 #![allow(invalid_atomic_ordering)]
 #![allow(enum_intrinsics_non_enums)]
-// warn for the old lint name here, to test if the renaming worked
 #![warn(clippy::stutter)]
 #![warn(clippy::new_without_default_derive)]
-#![warn(clippy::const_static_lifetime)]
 #![warn(clippy::cyclomatic_complexity)]
+#![warn(clippy::const_static_lifetime)]
 #![warn(clippy::option_and_then_some)]
 #![warn(clippy::box_vec)]
 #![warn(clippy::block_in_if_condition_expr)]
@@ -57,7 +57,6 @@
 #![warn(clippy::disallowed_method)]
 #![warn(clippy::ref_in_deref)]
 #![warn(clippy::to_string_in_display)]
-// uplifted lints
 #![warn(clippy::invalid_ref)]
 #![warn(clippy::into_iter_on_array)]
 #![warn(clippy::unused_label)]
diff --git a/tests/ui/rename.stderr b/tests/ui/rename.stderr
index 8b132a78384..54e12d5fae5 100644
--- a/tests/ui/rename.stderr
+++ b/tests/ui/rename.stderr
@@ -12,17 +12,17 @@ error: lint `clippy::new_without_default_derive` has been renamed to `clippy::ne
 LL | #![warn(clippy::new_without_default_derive)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::new_without_default`
 
-error: lint `clippy::const_static_lifetime` has been renamed to `clippy::redundant_static_lifetimes`
+error: lint `clippy::cyclomatic_complexity` has been renamed to `clippy::cognitive_complexity`
   --> $DIR/rename.rs:37:9
    |
-LL | #![warn(clippy::const_static_lifetime)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::redundant_static_lifetimes`
+LL | #![warn(clippy::cyclomatic_complexity)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::cognitive_complexity`
 
-error: lint `clippy::cyclomatic_complexity` has been renamed to `clippy::cognitive_complexity`
+error: lint `clippy::const_static_lifetime` has been renamed to `clippy::redundant_static_lifetimes`
   --> $DIR/rename.rs:38:9
    |
-LL | #![warn(clippy::cyclomatic_complexity)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::cognitive_complexity`
+LL | #![warn(clippy::const_static_lifetime)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::redundant_static_lifetimes`
 
 error: lint `clippy::option_and_then_some` has been renamed to `clippy::bind_instead_of_map`
   --> $DIR/rename.rs:39:9
@@ -151,55 +151,55 @@ LL | #![warn(clippy::to_string_in_display)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::recursive_format_impl`
 
 error: lint `clippy::invalid_ref` has been renamed to `invalid_value`
-  --> $DIR/rename.rs:61:9
+  --> $DIR/rename.rs:60:9
    |
 LL | #![warn(clippy::invalid_ref)]
    |         ^^^^^^^^^^^^^^^^^^^ help: use the new name: `invalid_value`
 
 error: lint `clippy::into_iter_on_array` has been renamed to `array_into_iter`
-  --> $DIR/rename.rs:62:9
+  --> $DIR/rename.rs:61:9
    |
 LL | #![warn(clippy::into_iter_on_array)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `array_into_iter`
 
 error: lint `clippy::unused_label` has been renamed to `unused_labels`
-  --> $DIR/rename.rs:63:9
+  --> $DIR/rename.rs:62:9
    |
 LL | #![warn(clippy::unused_label)]
    |         ^^^^^^^^^^^^^^^^^^^^ help: use the new name: `unused_labels`
 
 error: lint `clippy::drop_bounds` has been renamed to `drop_bounds`
-  --> $DIR/rename.rs:64:9
+  --> $DIR/rename.rs:63:9
    |
 LL | #![warn(clippy::drop_bounds)]
    |         ^^^^^^^^^^^^^^^^^^^ help: use the new name: `drop_bounds`
 
 error: lint `clippy::temporary_cstring_as_ptr` has been renamed to `temporary_cstring_as_ptr`
-  --> $DIR/rename.rs:65:9
+  --> $DIR/rename.rs:64:9
    |
 LL | #![warn(clippy::temporary_cstring_as_ptr)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `temporary_cstring_as_ptr`
 
 error: lint `clippy::panic_params` has been renamed to `non_fmt_panics`
-  --> $DIR/rename.rs:66:9
+  --> $DIR/rename.rs:65:9
    |
 LL | #![warn(clippy::panic_params)]
    |         ^^^^^^^^^^^^^^^^^^^^ help: use the new name: `non_fmt_panics`
 
 error: lint `clippy::unknown_clippy_lints` has been renamed to `unknown_lints`
-  --> $DIR/rename.rs:67:9
+  --> $DIR/rename.rs:66:9
    |
 LL | #![warn(clippy::unknown_clippy_lints)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `unknown_lints`
 
 error: lint `clippy::invalid_atomic_ordering` has been renamed to `invalid_atomic_ordering`
-  --> $DIR/rename.rs:68:9
+  --> $DIR/rename.rs:67:9
    |
 LL | #![warn(clippy::invalid_atomic_ordering)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `invalid_atomic_ordering`
 
 error: lint `clippy::mem_discriminant_non_enum` has been renamed to `enum_intrinsics_non_enums`
-  --> $DIR/rename.rs:69:9
+  --> $DIR/rename.rs:68:9
    |
 LL | #![warn(clippy::mem_discriminant_non_enum)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `enum_intrinsics_non_enums`
-- 
cgit 1.4.1-3-g733a5


From 58833e58a643d1d3d4f2499d6395966245207e3d Mon Sep 17 00:00:00 2001
From: Max Baumann <max@bmn.dev>
Date: Mon, 4 Apr 2022 08:48:49 +0200
Subject: is_unit_like_struct -> has_brackets

---
 clippy_lints/src/empty_structs_with_brackets.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/empty_structs_with_brackets.rs b/clippy_lints/src/empty_structs_with_brackets.rs
index 8f2a0306aa0..fdeac8d8255 100644
--- a/clippy_lints/src/empty_structs_with_brackets.rs
+++ b/clippy_lints/src/empty_structs_with_brackets.rs
@@ -33,7 +33,7 @@ impl EarlyLintPass for EmptyStructsWithBrackets {
         let span_after_ident = item.span.with_lo(item.ident.span.hi());
 
         if let ItemKind::Struct(var_data, _) = &item.kind
-            && !is_unit_like_struct(var_data)
+            && has_brackets(var_data)
             && has_no_fields(cx, var_data, span_after_ident) {
             span_lint_and_then(
                 cx,
@@ -56,8 +56,8 @@ fn has_no_ident_token(braces_span_str: &str) -> bool {
     !rustc_lexer::tokenize(braces_span_str).any(|t| t.kind == TokenKind::Ident)
 }
 
-fn is_unit_like_struct(var_data: &VariantData) -> bool {
-    matches!(var_data, VariantData::Unit(_))
+fn has_brackets(var_data: &VariantData) -> bool {
+    !matches!(var_data, VariantData::Unit(_))
 }
 
 fn has_no_fields(cx: &EarlyContext<'_>, var_data: &VariantData, braces_span: Span) -> bool {
-- 
cgit 1.4.1-3-g733a5


From 5cd711b4f18f674dbdbd794d4ac32a0aeb0ef6f2 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Mon, 4 Apr 2022 11:56:56 -0400
Subject: Add lints `drop_non_drop` and `forget_non_drop`

---
 CHANGELOG.md                                 |   2 +
 clippy_lints/src/drop_forget_ref.rs          | 181 +++++++++++++++++++--------
 clippy_lints/src/lib.register_all.rs         |   4 +-
 clippy_lints/src/lib.register_correctness.rs |   2 +-
 clippy_lints/src/lib.register_lints.rs       |   4 +-
 clippy_lints/src/lib.register_suspicious.rs  |   2 +
 clippy_lints/src/lib.rs                      |   2 -
 clippy_lints/src/undropped_manually_drops.rs |  59 ---------
 tests/ui/drop_forget_copy.stderr             |  12 +-
 tests/ui/drop_non_drop.rs                    |  40 ++++++
 tests/ui/drop_non_drop.stderr                |  27 ++++
 tests/ui/drop_ref.rs                         |   2 +-
 tests/ui/forget_non_drop.rs                  |  27 ++++
 tests/ui/forget_non_drop.stderr              |  27 ++++
 tests/ui/forget_ref.rs                       |   2 +-
 tests/ui/redundant_clone.fixed               |   2 +-
 tests/ui/redundant_clone.rs                  |   2 +-
 17 files changed, 269 insertions(+), 128 deletions(-)
 delete mode 100644 clippy_lints/src/undropped_manually_drops.rs
 create mode 100644 tests/ui/drop_non_drop.rs
 create mode 100644 tests/ui/drop_non_drop.stderr
 create mode 100644 tests/ui/forget_non_drop.rs
 create mode 100644 tests/ui/forget_non_drop.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 1d1e081e839..46907f5c07b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3256,6 +3256,7 @@ Released 2018-09-13
 [`double_neg`]: https://rust-lang.github.io/rust-clippy/master/index.html#double_neg
 [`double_parens`]: https://rust-lang.github.io/rust-clippy/master/index.html#double_parens
 [`drop_copy`]: https://rust-lang.github.io/rust-clippy/master/index.html#drop_copy
+[`drop_non_drop`]: https://rust-lang.github.io/rust-clippy/master/index.html#drop_non_drop
 [`drop_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#drop_ref
 [`duplicate_underscore_argument`]: https://rust-lang.github.io/rust-clippy/master/index.html#duplicate_underscore_argument
 [`duration_subsec`]: https://rust-lang.github.io/rust-clippy/master/index.html#duration_subsec
@@ -3307,6 +3308,7 @@ Released 2018-09-13
 [`for_kv_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#for_kv_map
 [`for_loops_over_fallibles`]: https://rust-lang.github.io/rust-clippy/master/index.html#for_loops_over_fallibles
 [`forget_copy`]: https://rust-lang.github.io/rust-clippy/master/index.html#forget_copy
+[`forget_non_drop`]: https://rust-lang.github.io/rust-clippy/master/index.html#forget_non_drop
 [`forget_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#forget_ref
 [`format_in_format_args`]: https://rust-lang.github.io/rust-clippy/master/index.html#format_in_format_args
 [`from_iter_instead_of_collect`]: https://rust-lang.github.io/rust-clippy/master/index.html#from_iter_instead_of_collect
diff --git a/clippy_lints/src/drop_forget_ref.rs b/clippy_lints/src/drop_forget_ref.rs
index 5c4b35fd4b9..88c54828da8 100644
--- a/clippy_lints/src/drop_forget_ref.rs
+++ b/clippy_lints/src/drop_forget_ref.rs
@@ -1,9 +1,8 @@
-use clippy_utils::diagnostics::span_lint_and_note;
-use clippy_utils::ty::is_copy;
-use if_chain::if_chain;
-use rustc_hir::{Expr, ExprKind};
+use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_note};
+use clippy_utils::is_must_use_func_call;
+use clippy_utils::ty::{is_copy, is_must_use_ty, is_type_lang_item};
+use rustc_hir::{Expr, ExprKind, LangItem};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::sym;
 
@@ -103,6 +102,75 @@ declare_clippy_lint! {
     "calls to `std::mem::forget` with a value that implements Copy"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for calls to `std::mem::drop` with a value that does not implement `Drop`.
+    ///
+    /// ### Why is this bad?
+    /// Calling `std::mem::drop` is no different than dropping such a type. A different value may
+    /// have been intended.
+    ///
+    /// ### Example
+    /// ```rust
+    /// struct Foo;
+    /// let x = Foo;
+    /// std::mem::drop(x);
+    /// ```
+    #[clippy::version = "1.61.0"]
+    pub DROP_NON_DROP,
+    suspicious,
+    "call to `std::mem::drop` with a value which does not implement `Drop`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for calls to `std::mem::forget` with a value that does not implement `Drop`.
+    ///
+    /// ### Why is this bad?
+    /// Calling `std::mem::forget` is no different than dropping such a type. A different value may
+    /// have been intended.
+    ///
+    /// ### Example
+    /// ```rust
+    /// struct Foo;
+    /// let x = Foo;
+    /// std::mem::forget(x);
+    /// ```
+    #[clippy::version = "1.61.0"]
+    pub FORGET_NON_DROP,
+    suspicious,
+    "call to `std::mem::forget` with a value which does not implement `Drop`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Prevents the safe `std::mem::drop` function from being called on `std::mem::ManuallyDrop`.
+    ///
+    /// ### Why is this bad?
+    /// The safe `drop` function does not drop the inner value of a `ManuallyDrop`.
+    ///
+    /// ### Known problems
+    /// Does not catch cases if the user binds `std::mem::drop`
+    /// to a different name and calls it that way.
+    ///
+    /// ### Example
+    /// ```rust
+    /// struct S;
+    /// drop(std::mem::ManuallyDrop::new(S));
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// struct S;
+    /// unsafe {
+    ///     std::mem::ManuallyDrop::drop(&mut std::mem::ManuallyDrop::new(S));
+    /// }
+    /// ```
+    #[clippy::version = "1.49.0"]
+    pub UNDROPPED_MANUALLY_DROPS,
+    correctness,
+    "use of safe `std::mem::drop` function to drop a std::mem::ManuallyDrop, which will not drop the inner value"
+}
+
 const DROP_REF_SUMMARY: &str = "calls to `std::mem::drop` with a reference instead of an owned value. \
                                 Dropping a reference does nothing";
 const FORGET_REF_SUMMARY: &str = "calls to `std::mem::forget` with a reference instead of an owned value. \
@@ -111,60 +179,65 @@ const DROP_COPY_SUMMARY: &str = "calls to `std::mem::drop` with a value that imp
                                  Dropping a copy leaves the original intact";
 const FORGET_COPY_SUMMARY: &str = "calls to `std::mem::forget` with a value that implements `Copy`. \
                                    Forgetting a copy leaves the original intact";
+const DROP_NON_DROP_SUMMARY: &str = "call to `std::mem::drop` with a value that does not implement `Drop`. \
+                                 Dropping such a type only extends it's contained lifetimes";
+const FORGET_NON_DROP_SUMMARY: &str = "call to `std::mem::forget` with a value that does not implement `Drop`. \
+                                   Forgetting such a type is the same as dropping it";
 
-declare_lint_pass!(DropForgetRef => [DROP_REF, FORGET_REF, DROP_COPY, FORGET_COPY]);
+declare_lint_pass!(DropForgetRef => [
+    DROP_REF,
+    FORGET_REF,
+    DROP_COPY,
+    FORGET_COPY,
+    DROP_NON_DROP,
+    FORGET_NON_DROP,
+    UNDROPPED_MANUALLY_DROPS
+]);
 
 impl<'tcx> LateLintPass<'tcx> for DropForgetRef {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if_chain! {
-            if let ExprKind::Call(path, args) = expr.kind;
-            if let ExprKind::Path(ref qpath) = path.kind;
-            if args.len() == 1;
-            if let Some(def_id) = cx.qpath_res(qpath, path.hir_id).opt_def_id();
-            then {
-                let lint;
-                let msg;
-                let arg = &args[0];
-                let arg_ty = cx.typeck_results().expr_ty(arg);
-
-                if let ty::Ref(..) = arg_ty.kind() {
-                    match cx.tcx.get_diagnostic_name(def_id) {
-                        Some(sym::mem_drop) => {
-                            lint = DROP_REF;
-                            msg = DROP_REF_SUMMARY.to_string();
-                        },
-                        Some(sym::mem_forget) => {
-                            lint = FORGET_REF;
-                            msg = FORGET_REF_SUMMARY.to_string();
-                        },
-                        _ => return,
-                    }
-                    span_lint_and_note(cx,
-                                       lint,
-                                       expr.span,
-                                       &msg,
-                                       Some(arg.span),
-                                       &format!("argument has type `{}`", arg_ty));
-                } else if is_copy(cx, arg_ty) {
-                    match cx.tcx.get_diagnostic_name(def_id) {
-                        Some(sym::mem_drop) => {
-                            lint = DROP_COPY;
-                            msg = DROP_COPY_SUMMARY.to_string();
-                        },
-                        Some(sym::mem_forget) => {
-                            lint = FORGET_COPY;
-                            msg = FORGET_COPY_SUMMARY.to_string();
-                        },
-                        _ => return,
-                    }
-                    span_lint_and_note(cx,
-                                       lint,
-                                       expr.span,
-                                       &msg,
-                                       Some(arg.span),
-                                       &format!("argument has type {}", arg_ty));
+        if let ExprKind::Call(path, [arg]) = expr.kind
+            && let ExprKind::Path(ref qpath) = path.kind
+            && let Some(def_id) = cx.qpath_res(qpath, path.hir_id).opt_def_id()
+            && let Some(fn_name) = cx.tcx.get_diagnostic_name(def_id)
+        {
+            let arg_ty = cx.typeck_results().expr_ty(arg);
+            let (lint, msg) = match fn_name {
+                sym::mem_drop if arg_ty.is_ref() => (DROP_REF, DROP_REF_SUMMARY),
+                sym::mem_forget if arg_ty.is_ref() => (FORGET_REF, FORGET_REF_SUMMARY),
+                sym::mem_drop if is_copy(cx, arg_ty) => (DROP_COPY, DROP_COPY_SUMMARY),
+                sym::mem_forget if is_copy(cx, arg_ty) => (FORGET_COPY, FORGET_COPY_SUMMARY),
+                sym::mem_drop if is_type_lang_item(cx, arg_ty, LangItem::ManuallyDrop) => {
+                    span_lint_and_help(
+                        cx,
+                        UNDROPPED_MANUALLY_DROPS,
+                        expr.span,
+                        "the inner value of this ManuallyDrop will not be dropped",
+                        None,
+                        "to drop a `ManuallyDrop<T>`, use std::mem::ManuallyDrop::drop",
+                    );
+                    return;
                 }
-            }
+                sym::mem_drop
+                    if !(arg_ty.needs_drop(cx.tcx, cx.param_env)
+                        || is_must_use_func_call(cx, arg)
+                        || is_must_use_ty(cx, arg_ty)) =>
+                {
+                    (DROP_NON_DROP, DROP_NON_DROP_SUMMARY)
+                },
+                sym::mem_forget if !arg_ty.needs_drop(cx.tcx, cx.param_env) => {
+                    (FORGET_NON_DROP, FORGET_NON_DROP_SUMMARY)
+                },
+                _ => return,
+            };
+            span_lint_and_note(
+                cx,
+                lint,
+                expr.span,
+                msg,
+                Some(arg.span),
+                &format!("argument has type `{}`", arg_ty),
+            );
         }
     }
 }
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 1fb3ca1fd9b..b2f674e9c88 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -50,9 +50,12 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(double_comparison::DOUBLE_COMPARISONS),
     LintId::of(double_parens::DOUBLE_PARENS),
     LintId::of(drop_forget_ref::DROP_COPY),
+    LintId::of(drop_forget_ref::DROP_NON_DROP),
     LintId::of(drop_forget_ref::DROP_REF),
     LintId::of(drop_forget_ref::FORGET_COPY),
+    LintId::of(drop_forget_ref::FORGET_NON_DROP),
     LintId::of(drop_forget_ref::FORGET_REF),
+    LintId::of(drop_forget_ref::UNDROPPED_MANUALLY_DROPS),
     LintId::of(duration_subsec::DURATION_SUBSEC),
     LintId::of(entry::MAP_ENTRY),
     LintId::of(enum_clike::ENUM_CLIKE_UNPORTABLE_VARIANT),
@@ -297,7 +300,6 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(types::REDUNDANT_ALLOCATION),
     LintId::of(types::TYPE_COMPLEXITY),
     LintId::of(types::VEC_BOX),
-    LintId::of(undropped_manually_drops::UNDROPPED_MANUALLY_DROPS),
     LintId::of(unicode::INVISIBLE_CHARACTERS),
     LintId::of(uninit_vec::UNINIT_VEC),
     LintId::of(unit_hash::UNIT_HASH),
diff --git a/clippy_lints/src/lib.register_correctness.rs b/clippy_lints/src/lib.register_correctness.rs
index df63f84463d..6bf2c4bbaed 100644
--- a/clippy_lints/src/lib.register_correctness.rs
+++ b/clippy_lints/src/lib.register_correctness.rs
@@ -22,6 +22,7 @@ store.register_group(true, "clippy::correctness", Some("clippy_correctness"), ve
     LintId::of(drop_forget_ref::DROP_REF),
     LintId::of(drop_forget_ref::FORGET_COPY),
     LintId::of(drop_forget_ref::FORGET_REF),
+    LintId::of(drop_forget_ref::UNDROPPED_MANUALLY_DROPS),
     LintId::of(enum_clike::ENUM_CLIKE_UNPORTABLE_VARIANT),
     LintId::of(eq_op::EQ_OP),
     LintId::of(erasing_op::ERASING_OP),
@@ -62,7 +63,6 @@ store.register_group(true, "clippy::correctness", Some("clippy_correctness"), ve
     LintId::of(transmute::UNSOUND_COLLECTION_TRANSMUTE),
     LintId::of(transmute::WRONG_TRANSMUTE),
     LintId::of(transmuting_null::TRANSMUTING_NULL),
-    LintId::of(undropped_manually_drops::UNDROPPED_MANUALLY_DROPS),
     LintId::of(unicode::INVISIBLE_CHARACTERS),
     LintId::of(uninit_vec::UNINIT_VEC),
     LintId::of(unit_hash::UNIT_HASH),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index e3161795139..8a3c0fb60fa 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -123,9 +123,12 @@ store.register_lints(&[
     double_comparison::DOUBLE_COMPARISONS,
     double_parens::DOUBLE_PARENS,
     drop_forget_ref::DROP_COPY,
+    drop_forget_ref::DROP_NON_DROP,
     drop_forget_ref::DROP_REF,
     drop_forget_ref::FORGET_COPY,
+    drop_forget_ref::FORGET_NON_DROP,
     drop_forget_ref::FORGET_REF,
+    drop_forget_ref::UNDROPPED_MANUALLY_DROPS,
     duration_subsec::DURATION_SUBSEC,
     else_if_without_else::ELSE_IF_WITHOUT_ELSE,
     empty_enum::EMPTY_ENUM,
@@ -506,7 +509,6 @@ store.register_lints(&[
     types::TYPE_COMPLEXITY,
     types::VEC_BOX,
     undocumented_unsafe_blocks::UNDOCUMENTED_UNSAFE_BLOCKS,
-    undropped_manually_drops::UNDROPPED_MANUALLY_DROPS,
     unicode::INVISIBLE_CHARACTERS,
     unicode::NON_ASCII_LITERAL,
     unicode::UNICODE_NOT_NFC,
diff --git a/clippy_lints/src/lib.register_suspicious.rs b/clippy_lints/src/lib.register_suspicious.rs
index 0707e4f8f3d..4c3fbb6c4a8 100644
--- a/clippy_lints/src/lib.register_suspicious.rs
+++ b/clippy_lints/src/lib.register_suspicious.rs
@@ -10,6 +10,8 @@ store.register_group(true, "clippy::suspicious", Some("clippy_suspicious"), vec!
     LintId::of(casts::CAST_ENUM_CONSTRUCTOR),
     LintId::of(casts::CAST_ENUM_TRUNCATION),
     LintId::of(crate_in_macro_def::CRATE_IN_MACRO_DEF),
+    LintId::of(drop_forget_ref::DROP_NON_DROP),
+    LintId::of(drop_forget_ref::FORGET_NON_DROP),
     LintId::of(eval_order_dependence::EVAL_ORDER_DEPENDENCE),
     LintId::of(float_equality_without_abs::FLOAT_EQUALITY_WITHOUT_ABS),
     LintId::of(format_impl::PRINT_IN_FORMAT_IMPL),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index c8b57956b1b..7536539dcdb 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -376,7 +376,6 @@ mod transmuting_null;
 mod try_err;
 mod types;
 mod undocumented_unsafe_blocks;
-mod undropped_manually_drops;
 mod unicode;
 mod uninit_vec;
 mod unit_hash;
@@ -813,7 +812,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(move || Box::new(disallowed_methods::DisallowedMethods::new(disallowed_methods.clone())));
     store.register_early_pass(|| Box::new(asm_syntax::InlineAsmX86AttSyntax));
     store.register_early_pass(|| Box::new(asm_syntax::InlineAsmX86IntelSyntax));
-    store.register_late_pass(|| Box::new(undropped_manually_drops::UndroppedManuallyDrops));
     store.register_late_pass(|| Box::new(strings::StrToString));
     store.register_late_pass(|| Box::new(strings::StringToString));
     store.register_late_pass(|| Box::new(zero_sized_map_values::ZeroSizedMapValues));
diff --git a/clippy_lints/src/undropped_manually_drops.rs b/clippy_lints/src/undropped_manually_drops.rs
deleted file mode 100644
index db652766705..00000000000
--- a/clippy_lints/src/undropped_manually_drops.rs
+++ /dev/null
@@ -1,59 +0,0 @@
-use clippy_utils::diagnostics::span_lint_and_help;
-use clippy_utils::path_res;
-use clippy_utils::ty::is_type_lang_item;
-use rustc_hir::{lang_items, Expr, ExprKind};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::sym;
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Prevents the safe `std::mem::drop` function from being called on `std::mem::ManuallyDrop`.
-    ///
-    /// ### Why is this bad?
-    /// The safe `drop` function does not drop the inner value of a `ManuallyDrop`.
-    ///
-    /// ### Known problems
-    /// Does not catch cases if the user binds `std::mem::drop`
-    /// to a different name and calls it that way.
-    ///
-    /// ### Example
-    /// ```rust
-    /// struct S;
-    /// drop(std::mem::ManuallyDrop::new(S));
-    /// ```
-    /// Use instead:
-    /// ```rust
-    /// struct S;
-    /// unsafe {
-    ///     std::mem::ManuallyDrop::drop(&mut std::mem::ManuallyDrop::new(S));
-    /// }
-    /// ```
-    #[clippy::version = "1.49.0"]
-    pub UNDROPPED_MANUALLY_DROPS,
-    correctness,
-    "use of safe `std::mem::drop` function to drop a std::mem::ManuallyDrop, which will not drop the inner value"
-}
-
-declare_lint_pass!(UndroppedManuallyDrops => [UNDROPPED_MANUALLY_DROPS]);
-
-impl<'tcx> LateLintPass<'tcx> for UndroppedManuallyDrops {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if_chain! {
-            if let ExprKind::Call(fun, [arg_0, ..]) = expr.kind;
-            if path_res(cx, fun).opt_def_id() == cx.tcx.get_diagnostic_item(sym::mem_drop);
-            let ty = cx.typeck_results().expr_ty(arg_0);
-            if is_type_lang_item(cx, ty, lang_items::LangItem::ManuallyDrop);
-            then {
-                span_lint_and_help(
-                    cx,
-                    UNDROPPED_MANUALLY_DROPS,
-                    expr.span,
-                    "the inner value of this ManuallyDrop will not be dropped",
-                    None,
-                    "to drop a `ManuallyDrop<T>`, use std::mem::ManuallyDrop::drop",
-                );
-            }
-        }
-    }
-}
diff --git a/tests/ui/drop_forget_copy.stderr b/tests/ui/drop_forget_copy.stderr
index 01de0be7cae..88228afae89 100644
--- a/tests/ui/drop_forget_copy.stderr
+++ b/tests/ui/drop_forget_copy.stderr
@@ -5,7 +5,7 @@ LL |     drop(s1);
    |     ^^^^^^^^
    |
    = note: `-D clippy::drop-copy` implied by `-D warnings`
-note: argument has type SomeStruct
+note: argument has type `SomeStruct`
   --> $DIR/drop_forget_copy.rs:33:10
    |
 LL |     drop(s1);
@@ -17,7 +17,7 @@ error: calls to `std::mem::drop` with a value that implements `Copy`. Dropping a
 LL |     drop(s2);
    |     ^^^^^^^^
    |
-note: argument has type SomeStruct
+note: argument has type `SomeStruct`
   --> $DIR/drop_forget_copy.rs:34:10
    |
 LL |     drop(s2);
@@ -29,7 +29,7 @@ error: calls to `std::mem::drop` with a value that implements `Copy`. Dropping a
 LL |     drop(s4);
    |     ^^^^^^^^
    |
-note: argument has type SomeStruct
+note: argument has type `SomeStruct`
   --> $DIR/drop_forget_copy.rs:36:10
    |
 LL |     drop(s4);
@@ -42,7 +42,7 @@ LL |     forget(s1);
    |     ^^^^^^^^^^
    |
    = note: `-D clippy::forget-copy` implied by `-D warnings`
-note: argument has type SomeStruct
+note: argument has type `SomeStruct`
   --> $DIR/drop_forget_copy.rs:39:12
    |
 LL |     forget(s1);
@@ -54,7 +54,7 @@ error: calls to `std::mem::forget` with a value that implements `Copy`. Forgetti
 LL |     forget(s2);
    |     ^^^^^^^^^^
    |
-note: argument has type SomeStruct
+note: argument has type `SomeStruct`
   --> $DIR/drop_forget_copy.rs:40:12
    |
 LL |     forget(s2);
@@ -66,7 +66,7 @@ error: calls to `std::mem::forget` with a value that implements `Copy`. Forgetti
 LL |     forget(s4);
    |     ^^^^^^^^^^
    |
-note: argument has type SomeStruct
+note: argument has type `SomeStruct`
   --> $DIR/drop_forget_copy.rs:42:12
    |
 LL |     forget(s4);
diff --git a/tests/ui/drop_non_drop.rs b/tests/ui/drop_non_drop.rs
new file mode 100644
index 00000000000..5a0ebde82c5
--- /dev/null
+++ b/tests/ui/drop_non_drop.rs
@@ -0,0 +1,40 @@
+#![warn(clippy::drop_non_drop)]
+
+use core::mem::drop;
+
+fn make_result<T>(t: T) -> Result<T, ()> {
+    Ok(t)
+}
+
+#[must_use]
+fn must_use<T>(t: T) -> T {
+    t
+}
+
+fn drop_generic<T>(t: T) {
+    // Don't lint
+    drop(t)
+}
+
+fn main() {
+    struct Foo;
+    // Lint
+    drop(Foo);
+    // Don't lint
+    drop(make_result(Foo));
+    // Don't lint
+    drop(must_use(Foo));
+
+    struct Bar;
+    impl Drop for Bar {
+        fn drop(&mut self) {}
+    }
+    // Don't lint
+    drop(Bar);
+
+    struct Baz<T>(T);
+    // Lint
+    drop(Baz(Foo));
+    // Don't lint
+    drop(Baz(Bar));
+}
diff --git a/tests/ui/drop_non_drop.stderr b/tests/ui/drop_non_drop.stderr
new file mode 100644
index 00000000000..f73068901c5
--- /dev/null
+++ b/tests/ui/drop_non_drop.stderr
@@ -0,0 +1,27 @@
+error: call to `std::mem::drop` with a value that does not implement `Drop`. Dropping such a type only extends it's contained lifetimes
+  --> $DIR/drop_non_drop.rs:22:5
+   |
+LL |     drop(Foo);
+   |     ^^^^^^^^^
+   |
+   = note: `-D clippy::drop-non-drop` implied by `-D warnings`
+note: argument has type `main::Foo`
+  --> $DIR/drop_non_drop.rs:22:10
+   |
+LL |     drop(Foo);
+   |          ^^^
+
+error: call to `std::mem::drop` with a value that does not implement `Drop`. Dropping such a type only extends it's contained lifetimes
+  --> $DIR/drop_non_drop.rs:37:5
+   |
+LL |     drop(Baz(Foo));
+   |     ^^^^^^^^^^^^^^
+   |
+note: argument has type `main::Baz<main::Foo>`
+  --> $DIR/drop_non_drop.rs:37:10
+   |
+LL |     drop(Baz(Foo));
+   |          ^^^^^^^^
+
+error: aborting due to 2 previous errors
+
diff --git a/tests/ui/drop_ref.rs b/tests/ui/drop_ref.rs
index e1a15c609fd..7de0b0bbdf9 100644
--- a/tests/ui/drop_ref.rs
+++ b/tests/ui/drop_ref.rs
@@ -1,7 +1,7 @@
 #![warn(clippy::drop_ref)]
 #![allow(clippy::toplevel_ref_arg)]
 #![allow(clippy::map_err_ignore)]
-#![allow(clippy::unnecessary_wraps)]
+#![allow(clippy::unnecessary_wraps, clippy::drop_non_drop)]
 
 use std::mem::drop;
 
diff --git a/tests/ui/forget_non_drop.rs b/tests/ui/forget_non_drop.rs
new file mode 100644
index 00000000000..7580cf95ebf
--- /dev/null
+++ b/tests/ui/forget_non_drop.rs
@@ -0,0 +1,27 @@
+#![warn(clippy::forget_non_drop)]
+
+use core::mem::forget;
+
+fn forget_generic<T>(t: T) {
+    // Don't lint
+    forget(t)
+}
+
+fn main() {
+    struct Foo;
+    // Lint
+    forget(Foo);
+
+    struct Bar;
+    impl Drop for Bar {
+        fn drop(&mut self) {}
+    }
+    // Don't lint
+    forget(Bar);
+
+    struct Baz<T>(T);
+    // Lint
+    forget(Baz(Foo));
+    // Don't lint
+    forget(Baz(Bar));
+}
diff --git a/tests/ui/forget_non_drop.stderr b/tests/ui/forget_non_drop.stderr
new file mode 100644
index 00000000000..03fb00960a4
--- /dev/null
+++ b/tests/ui/forget_non_drop.stderr
@@ -0,0 +1,27 @@
+error: call to `std::mem::forget` with a value that does not implement `Drop`. Forgetting such a type is the same as dropping it
+  --> $DIR/forget_non_drop.rs:13:5
+   |
+LL |     forget(Foo);
+   |     ^^^^^^^^^^^
+   |
+   = note: `-D clippy::forget-non-drop` implied by `-D warnings`
+note: argument has type `main::Foo`
+  --> $DIR/forget_non_drop.rs:13:12
+   |
+LL |     forget(Foo);
+   |            ^^^
+
+error: call to `std::mem::forget` with a value that does not implement `Drop`. Forgetting such a type is the same as dropping it
+  --> $DIR/forget_non_drop.rs:24:5
+   |
+LL |     forget(Baz(Foo));
+   |     ^^^^^^^^^^^^^^^^
+   |
+note: argument has type `main::Baz<main::Foo>`
+  --> $DIR/forget_non_drop.rs:24:12
+   |
+LL |     forget(Baz(Foo));
+   |            ^^^^^^^^
+
+error: aborting due to 2 previous errors
+
diff --git a/tests/ui/forget_ref.rs b/tests/ui/forget_ref.rs
index c49e6756a6c..6c8c4c9c0ed 100644
--- a/tests/ui/forget_ref.rs
+++ b/tests/ui/forget_ref.rs
@@ -1,6 +1,6 @@
 #![warn(clippy::forget_ref)]
 #![allow(clippy::toplevel_ref_arg)]
-#![allow(clippy::unnecessary_wraps)]
+#![allow(clippy::unnecessary_wraps, clippy::forget_non_drop)]
 
 use std::mem::forget;
 
diff --git a/tests/ui/redundant_clone.fixed b/tests/ui/redundant_clone.fixed
index 16b40dcd902..1525f6a93df 100644
--- a/tests/ui/redundant_clone.fixed
+++ b/tests/ui/redundant_clone.fixed
@@ -1,7 +1,7 @@
 // run-rustfix
 // rustfix-only-machine-applicable
 
-#![allow(clippy::implicit_clone)]
+#![allow(clippy::implicit_clone, clippy::drop_non_drop)]
 use std::ffi::OsString;
 use std::path::Path;
 
diff --git a/tests/ui/redundant_clone.rs b/tests/ui/redundant_clone.rs
index bd3d7365229..2f82aefd928 100644
--- a/tests/ui/redundant_clone.rs
+++ b/tests/ui/redundant_clone.rs
@@ -1,7 +1,7 @@
 // run-rustfix
 // rustfix-only-machine-applicable
 
-#![allow(clippy::implicit_clone)]
+#![allow(clippy::implicit_clone, clippy::drop_non_drop)]
 use std::ffi::OsString;
 use std::path::Path;
 
-- 
cgit 1.4.1-3-g733a5


From e4fc15e6467826d1c59219f3963904c776ce7f13 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Mon, 4 Apr 2022 13:54:52 -0400
Subject: Don't lint `cast_ptr_alignment` when used for unaligned reads and
 writes

---
 clippy_lints/src/casts/cast_ptr_alignment.rs | 100 ++++++++++++++++++---------
 clippy_utils/src/paths.rs                    |   2 +
 tests/ui/cast_alignment.rs                   |  14 ++++
 tests/ui/cast_alignment.stderr               |   8 +--
 4 files changed, 86 insertions(+), 38 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/cast_ptr_alignment.rs b/clippy_lints/src/casts/cast_ptr_alignment.rs
index a4ef1344ab9..d476a1a7646 100644
--- a/clippy_lints/src/casts/cast_ptr_alignment.rs
+++ b/clippy_lints/src/casts/cast_ptr_alignment.rs
@@ -1,7 +1,6 @@
 use clippy_utils::diagnostics::span_lint;
-use clippy_utils::is_hir_ty_cfg_dependant;
 use clippy_utils::ty::is_c_void;
-use if_chain::if_chain;
+use clippy_utils::{get_parent_expr, is_hir_ty_cfg_dependant, match_any_def_paths, paths};
 use rustc_hir::{Expr, ExprKind, GenericArg};
 use rustc_lint::LateContext;
 use rustc_middle::ty::layout::LayoutOf;
@@ -20,45 +19,78 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>) {
         );
         lint_cast_ptr_alignment(cx, expr, cast_from, cast_to);
     } else if let ExprKind::MethodCall(method_path, [self_arg, ..], _) = &expr.kind {
-        if_chain! {
-            if method_path.ident.name == sym!(cast);
-            if let Some(generic_args) = method_path.args;
-            if let [GenericArg::Type(cast_to)] = generic_args.args;
+        if method_path.ident.name == sym!(cast)
+            && let Some(generic_args) = method_path.args
+            && let [GenericArg::Type(cast_to)] = generic_args.args
             // There probably is no obvious reason to do this, just to be consistent with `as` cases.
-            if !is_hir_ty_cfg_dependant(cx, cast_to);
-            then {
-                let (cast_from, cast_to) =
-                    (cx.typeck_results().expr_ty(self_arg), cx.typeck_results().expr_ty(expr));
-                lint_cast_ptr_alignment(cx, expr, cast_from, cast_to);
-            }
+            && !is_hir_ty_cfg_dependant(cx, cast_to)
+        {
+            let (cast_from, cast_to) =
+                (cx.typeck_results().expr_ty(self_arg), cx.typeck_results().expr_ty(expr));
+            lint_cast_ptr_alignment(cx, expr, cast_from, cast_to);
         }
     }
 }
 
 fn lint_cast_ptr_alignment<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, cast_from: Ty<'tcx>, cast_to: Ty<'tcx>) {
-    if_chain! {
-        if let ty::RawPtr(from_ptr_ty) = &cast_from.kind();
-        if let ty::RawPtr(to_ptr_ty) = &cast_to.kind();
-        if let Ok(from_layout) = cx.layout_of(from_ptr_ty.ty);
-        if let Ok(to_layout) = cx.layout_of(to_ptr_ty.ty);
-        if from_layout.align.abi < to_layout.align.abi;
+    if let ty::RawPtr(from_ptr_ty) = &cast_from.kind()
+        && let ty::RawPtr(to_ptr_ty) = &cast_to.kind()
+        && let Ok(from_layout) = cx.layout_of(from_ptr_ty.ty)
+        && let Ok(to_layout) = cx.layout_of(to_ptr_ty.ty)
+        && from_layout.align.abi < to_layout.align.abi
         // with c_void, we inherently need to trust the user
-        if !is_c_void(cx, from_ptr_ty.ty);
+        && !is_c_void(cx, from_ptr_ty.ty)
         // when casting from a ZST, we don't know enough to properly lint
-        if !from_layout.is_zst();
-        then {
-            span_lint(
-                cx,
-                CAST_PTR_ALIGNMENT,
-                expr.span,
-                &format!(
-                    "casting from `{}` to a more-strictly-aligned pointer (`{}`) ({} < {} bytes)",
-                    cast_from,
-                    cast_to,
-                    from_layout.align.abi.bytes(),
-                    to_layout.align.abi.bytes(),
-                ),
-            );
-        }
+        && !from_layout.is_zst()
+        && !is_used_as_unaligned(cx, expr)
+    {
+        span_lint(
+            cx,
+            CAST_PTR_ALIGNMENT,
+            expr.span,
+            &format!(
+                "casting from `{}` to a more-strictly-aligned pointer (`{}`) ({} < {} bytes)",
+                cast_from,
+                cast_to,
+                from_layout.align.abi.bytes(),
+                to_layout.align.abi.bytes(),
+            ),
+        );
+    }
+}
+
+fn is_used_as_unaligned(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
+    let Some(parent) = get_parent_expr(cx, e) else {
+        return false;
+    };
+    match parent.kind {
+        ExprKind::MethodCall(name, [self_arg, ..], _) if self_arg.hir_id == e.hir_id => {
+            if matches!(name.ident.as_str(), "read_unaligned" | "write_unaligned")
+                && let Some(def_id) = cx.typeck_results().type_dependent_def_id(parent.hir_id)
+                && let Some(def_id) = cx.tcx.impl_of_method(def_id)
+                && cx.tcx.type_of(def_id).is_unsafe_ptr()
+            {
+                true
+            } else {
+                false
+            }
+        },
+        ExprKind::Call(func, [arg, ..]) if arg.hir_id == e.hir_id => {
+            static PATHS: &[&[&str]] = &[
+                paths::PTR_READ_UNALIGNED.as_slice(),
+                paths::PTR_WRITE_UNALIGNED.as_slice(),
+                paths::PTR_UNALIGNED_VOLATILE_LOAD.as_slice(),
+                paths::PTR_UNALIGNED_VOLATILE_STORE.as_slice(),
+            ];
+            if let ExprKind::Path(path) = &func.kind
+                && let Some(def_id) = cx.qpath_res(path, func.hir_id).opt_def_id()
+                && match_any_def_paths(cx, def_id, PATHS).is_some()
+            {
+                true
+            } else {
+                false
+            }
+        },
+        _ => false,
     }
 }
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index 6f56f8d5136..79e6e92dc0a 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -105,6 +105,8 @@ pub const PTR_READ_UNALIGNED: [&str; 3] = ["core", "ptr", "read_unaligned"];
 pub const PTR_READ_VOLATILE: [&str; 3] = ["core", "ptr", "read_volatile"];
 pub const PTR_REPLACE: [&str; 3] = ["core", "ptr", "replace"];
 pub const PTR_SWAP: [&str; 3] = ["core", "ptr", "swap"];
+pub const PTR_UNALIGNED_VOLATILE_LOAD: [&str; 3] = ["core", "intrinsics", "unaligned_volatile_load"];
+pub const PTR_UNALIGNED_VOLATILE_STORE: [&str; 3] = ["core", "intrinsics", "unaligned_volatile_store"];
 pub const PTR_WRITE: [&str; 3] = ["core", "ptr", "write"];
 pub const PTR_WRITE_BYTES: [&str; 3] = ["core", "intrinsics", "write_bytes"];
 pub const PTR_WRITE_UNALIGNED: [&str; 3] = ["core", "ptr", "write_unaligned"];
diff --git a/tests/ui/cast_alignment.rs b/tests/ui/cast_alignment.rs
index 659591fffbe..e4e7290a30e 100644
--- a/tests/ui/cast_alignment.rs
+++ b/tests/ui/cast_alignment.rs
@@ -1,6 +1,7 @@
 //! Test casts for alignment issues
 
 #![feature(rustc_private)]
+#![feature(core_intrinsics)]
 extern crate libc;
 
 #[warn(clippy::cast_ptr_alignment)]
@@ -34,4 +35,17 @@ fn main() {
     (&1u32 as *const u32 as *const libc::c_void) as *const u32;
     // For ZST, we should trust the user. See #4256
     (&1u32 as *const u32 as *const ()) as *const u32;
+
+    // Issue #2881
+    let mut data = [0u8, 0u8];
+    unsafe {
+        let ptr = &data as *const [u8; 2] as *const u8;
+        let _ = (ptr as *const u16).read_unaligned();
+        let _ = core::ptr::read_unaligned(ptr as *const u16);
+        let _ = core::intrinsics::unaligned_volatile_load(ptr as *const u16);
+        let ptr = &mut data as *mut [u8; 2] as *mut u8;
+        let _ = (ptr as *mut u16).write_unaligned(0);
+        let _ = core::ptr::write_unaligned(ptr as *mut u16, 0);
+        let _ = core::intrinsics::unaligned_volatile_store(ptr as *mut u16, 0);
+    }
 }
diff --git a/tests/ui/cast_alignment.stderr b/tests/ui/cast_alignment.stderr
index aedd3684455..5df2b5b1094 100644
--- a/tests/ui/cast_alignment.stderr
+++ b/tests/ui/cast_alignment.stderr
@@ -1,5 +1,5 @@
 error: casting from `*const u8` to a more-strictly-aligned pointer (`*const u16`) (1 < 2 bytes)
-  --> $DIR/cast_alignment.rs:18:5
+  --> $DIR/cast_alignment.rs:19:5
    |
 LL |     (&1u8 as *const u8) as *const u16;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -7,19 +7,19 @@ LL |     (&1u8 as *const u8) as *const u16;
    = note: `-D clippy::cast-ptr-alignment` implied by `-D warnings`
 
 error: casting from `*mut u8` to a more-strictly-aligned pointer (`*mut u16`) (1 < 2 bytes)
-  --> $DIR/cast_alignment.rs:19:5
+  --> $DIR/cast_alignment.rs:20:5
    |
 LL |     (&mut 1u8 as *mut u8) as *mut u16;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: casting from `*const u8` to a more-strictly-aligned pointer (`*const u16`) (1 < 2 bytes)
-  --> $DIR/cast_alignment.rs:22:5
+  --> $DIR/cast_alignment.rs:23:5
    |
 LL |     (&1u8 as *const u8).cast::<u16>();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: casting from `*mut u8` to a more-strictly-aligned pointer (`*mut u16`) (1 < 2 bytes)
-  --> $DIR/cast_alignment.rs:23:5
+  --> $DIR/cast_alignment.rs:24:5
    |
 LL |     (&mut 1u8 as *mut u8).cast::<u16>();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From 764dd1360f1fb1540778592a36fefe71f713ca83 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Mon, 4 Apr 2022 21:06:53 +0200
Subject: Escape `mod.rs` file mentions to avoid links in our documentation

We can read them if they want to start sponsoring us xD
---
 clippy_lints/src/module_style.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/module_style.rs b/clippy_lints/src/module_style.rs
index 39c44ad6e2c..0a393657267 100644
--- a/clippy_lints/src/module_style.rs
+++ b/clippy_lints/src/module_style.rs
@@ -8,7 +8,7 @@ use std::path::{Component, Path};
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks that module layout uses only self named module files, bans mod.rs files.
+    /// Checks that module layout uses only self named module files, bans `mod.rs` files.
     ///
     /// ### Why is this bad?
     /// Having multiple module layout styles in a project can be confusing.
@@ -37,7 +37,7 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks that module layout uses only mod.rs files.
+    /// Checks that module layout uses only `mod.rs` files.
     ///
     /// ### Why is this bad?
     /// Having multiple module layout styles in a project can be confusing.
-- 
cgit 1.4.1-3-g733a5


From 1582e7bf88175f7362f5bd12ad5835dcdfb58473 Mon Sep 17 00:00:00 2001
From: Akshay <nerdy@peppe.rs>
Date: Tue, 8 Feb 2022 16:51:02 +0530
Subject: fix mispelling in diagnostic message of bytes_nth

---
 clippy_lints/src/methods/bytes_nth.rs | 2 +-
 tests/ui/bytes_nth.stderr             | 6 +++---
 2 files changed, 4 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/bytes_nth.rs b/clippy_lints/src/methods/bytes_nth.rs
index 76eaedea8a0..44857d61fef 100644
--- a/clippy_lints/src/methods/bytes_nth.rs
+++ b/clippy_lints/src/methods/bytes_nth.rs
@@ -22,7 +22,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, recv: &'tcx E
         cx,
         BYTES_NTH,
         expr.span,
-        &format!("called `.byte().nth()` on a `{}`", caller_type),
+        &format!("called `.bytes().nth()` on a `{}`", caller_type),
         "try",
         format!(
             "{}.as_bytes().get({})",
diff --git a/tests/ui/bytes_nth.stderr b/tests/ui/bytes_nth.stderr
index 536decf5e7f..5641d798853 100644
--- a/tests/ui/bytes_nth.stderr
+++ b/tests/ui/bytes_nth.stderr
@@ -1,4 +1,4 @@
-error: called `.byte().nth()` on a `String`
+error: called `.bytes().nth()` on a `String`
   --> $DIR/bytes_nth.rs:8:5
    |
 LL |     s.bytes().nth(3);
@@ -6,13 +6,13 @@ LL |     s.bytes().nth(3);
    |
    = note: `-D clippy::bytes-nth` implied by `-D warnings`
 
-error: called `.byte().nth()` on a `String`
+error: called `.bytes().nth()` on a `String`
   --> $DIR/bytes_nth.rs:9:14
    |
 LL |     let _ = &s.bytes().nth(3);
    |              ^^^^^^^^^^^^^^^^ help: try: `s.as_bytes().get(3)`
 
-error: called `.byte().nth()` on a `str`
+error: called `.bytes().nth()` on a `str`
   --> $DIR/bytes_nth.rs:10:5
    |
 LL |     s[..].bytes().nth(3);
-- 
cgit 1.4.1-3-g733a5


From 41ef4f729f3df237918229ff960c84792dd3231d Mon Sep 17 00:00:00 2001
From: Sabrina Jewson <sejewson@gmail.com>
Date: Wed, 6 Apr 2022 10:14:20 +0100
Subject: Report `from_utf8` suggestion as maybe incorrect

Co-authored-by: Philipp Krones <hello@philkrones.com>
---
 clippy_lints/src/transmute/transmute_ref_to_ref.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/transmute/transmute_ref_to_ref.rs b/clippy_lints/src/transmute/transmute_ref_to_ref.rs
index fe3e88613f4..786e7bfc56f 100644
--- a/clippy_lints/src/transmute/transmute_ref_to_ref.rs
+++ b/clippy_lints/src/transmute/transmute_ref_to_ref.rs
@@ -45,7 +45,7 @@ pub(super) fn check<'tcx>(
                     } else {
                         format!("std::str::from_utf8{postfix}({snippet}).unwrap()")
                     },
-                    Applicability::Unspecified,
+                    Applicability::MaybeIncorrect,
                 );
                 triggered = true;
             } else {
-- 
cgit 1.4.1-3-g733a5


From 85b081b65aa36e0d7cbdfba7cd705517563c0bd4 Mon Sep 17 00:00:00 2001
From: J-ZhengLi <lizheng135@huawei.com>
Date: Wed, 6 Apr 2022 20:44:54 +0800
Subject: code refractor for `[needless_match]`

---
 clippy_lints/src/matches/needless_match.rs | 27 ++++++++-------------------
 1 file changed, 8 insertions(+), 19 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/needless_match.rs b/clippy_lints/src/matches/needless_match.rs
index 3703488632b..2105a03e03a 100644
--- a/clippy_lints/src/matches/needless_match.rs
+++ b/clippy_lints/src/matches/needless_match.rs
@@ -3,12 +3,12 @@ use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::{is_type_diagnostic_item, same_type_and_consts};
 use clippy_utils::{
-    eq_expr_value, get_parent_expr_for_hir, get_parent_node, higher, is_else_clause, is_lang_ctor,
+    eq_expr_value, get_parent_expr_for_hir, get_parent_node, higher, is_else_clause, is_lang_ctor, over,
     peel_blocks_with_stmt,
 };
 use rustc_errors::Applicability;
 use rustc_hir::LangItem::OptionNone;
-use rustc_hir::{Arm, BindingAnnotation, Expr, ExprKind, FnRetTy, Node, Pat, PatKind, Path, PathSegment, QPath};
+use rustc_hir::{Arm, BindingAnnotation, Expr, ExprKind, FnRetTy, Node, Pat, PatKind, Path, QPath};
 use rustc_lint::LateContext;
 use rustc_span::sym;
 use rustc_typeck::hir_ty_to_ty;
@@ -157,8 +157,9 @@ fn pat_same_as_expr(pat: &Pat<'_>, expr: &Expr<'_>) -> bool {
         // Example: `Some(val) => Some(val)`
         (PatKind::TupleStruct(QPath::Resolved(_, path), tuple_params, _), ExprKind::Call(call_expr, call_params)) => {
             if let ExprKind::Path(QPath::Resolved(_, call_path)) = call_expr.kind {
-                return same_segments(path.segments, call_path.segments)
-                    && same_non_ref_symbols(tuple_params, call_params);
+                return over(path.segments, call_path.segments, |pat_seg, call_seg| {
+                    pat_seg.ident.name == call_seg.ident.name
+                }) && same_non_ref_symbols(tuple_params, call_params);
             }
         },
         // Example: `val => val`
@@ -177,7 +178,9 @@ fn pat_same_as_expr(pat: &Pat<'_>, expr: &Expr<'_>) -> bool {
         },
         // Example: `Custom::TypeA => Custom::TypeB`, or `None => None`
         (PatKind::Path(QPath::Resolved(_, p_path)), ExprKind::Path(QPath::Resolved(_, e_path))) => {
-            return same_segments(p_path.segments, e_path.segments);
+            return over(p_path.segments, e_path.segments, |p_seg, e_seg| {
+                p_seg.ident.name == e_seg.ident.name
+            });
         },
         // Example: `5 => 5`
         (PatKind::Lit(pat_lit_expr), ExprKind::Lit(expr_spanned)) => {
@@ -191,20 +194,6 @@ fn pat_same_as_expr(pat: &Pat<'_>, expr: &Expr<'_>) -> bool {
     false
 }
 
-fn same_segments(left_segs: &[PathSegment<'_>], right_segs: &[PathSegment<'_>]) -> bool {
-    if left_segs.len() != right_segs.len() {
-        return false;
-    }
-
-    for i in 0..left_segs.len() {
-        if left_segs[i].ident.name != right_segs[i].ident.name {
-            return false;
-        }
-    }
-
-    true
-}
-
 fn same_non_ref_symbols(pats: &[Pat<'_>], exprs: &[Expr<'_>]) -> bool {
     if pats.len() != exprs.len() {
         return false;
-- 
cgit 1.4.1-3-g733a5


From 1ad6442e919315144c476b522ed9a43579a319e5 Mon Sep 17 00:00:00 2001
From: Yoav Lavi <yoavlavi122@gmail.com>
Date: Wed, 6 Apr 2022 15:59:38 +0200
Subject: update unnecessary_join documentation

---
 clippy_lints/src/methods/mod.rs | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 021337280d1..b5a9af8c3bb 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -2055,7 +2055,7 @@ declare_clippy_lint! {
     /// Checks for use of `.collect::<Vec<String>>().join("")` on iterators.
     ///
     /// ### Why is this bad?
-    /// `.collect::<String>()` is more concise and usually more performant
+    /// `.collect::<String>()` is more concise and might be more performant
     ///
     /// ### Example
     /// ```rust
@@ -2070,9 +2070,12 @@ declare_clippy_lint! {
     /// println!("{}", output);
     /// ```
     /// ### Known problems
-    /// While `.collect::<String>()` is more performant in most cases, there are cases where
+    /// While `.collect::<String>()` is sometimes more performant, there are cases where
     /// using `.collect::<String>()` over `.collect::<Vec<String>>().join("")`
     /// will prevent loop unrolling and will result in a negative performance impact.
+    ///
+    /// Additionlly, differences have been observed between aarch64 and x86_64 assembly output,
+    /// with aarch64 tending to producing faster assembly in more cases when using `.collect::<String>()`
     #[clippy::version = "1.61.0"]
     pub UNNECESSARY_JOIN,
     pedantic,
-- 
cgit 1.4.1-3-g733a5


From 6e20a634e7a87a8c0234397e9fdcd8d8dea4e0f4 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Wed, 6 Apr 2022 09:26:59 -0400
Subject: Don't lint `manual_non_exhaustive` when the enum variant is used

---
 clippy_lints/src/lib.rs                      |   3 +-
 clippy_lints/src/manual_non_exhaustive.rs    | 177 +++++++++++++++++----------
 tests/ui/manual_non_exhaustive.rs            | 137 ---------------------
 tests/ui/manual_non_exhaustive.stderr        | 103 ----------------
 tests/ui/manual_non_exhaustive_enum.rs       |  78 ++++++++++++
 tests/ui/manual_non_exhaustive_enum.stderr   |  41 +++++++
 tests/ui/manual_non_exhaustive_struct.rs     |  74 +++++++++++
 tests/ui/manual_non_exhaustive_struct.stderr |  65 ++++++++++
 8 files changed, 375 insertions(+), 303 deletions(-)
 delete mode 100644 tests/ui/manual_non_exhaustive.rs
 delete mode 100644 tests/ui/manual_non_exhaustive.stderr
 create mode 100644 tests/ui/manual_non_exhaustive_enum.rs
 create mode 100644 tests/ui/manual_non_exhaustive_enum.stderr
 create mode 100644 tests/ui/manual_non_exhaustive_struct.rs
 create mode 100644 tests/ui/manual_non_exhaustive_struct.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 8dab039f24f..b4a70988286 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -575,7 +575,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(move || Box::new(approx_const::ApproxConstant::new(msrv)));
     store.register_late_pass(move || Box::new(methods::Methods::new(avoid_breaking_exported_api, msrv)));
     store.register_late_pass(move || Box::new(matches::Matches::new(msrv)));
-    store.register_early_pass(move || Box::new(manual_non_exhaustive::ManualNonExhaustive::new(msrv)));
+    store.register_early_pass(move || Box::new(manual_non_exhaustive::ManualNonExhaustiveStruct::new(msrv)));
+    store.register_late_pass(move || Box::new(manual_non_exhaustive::ManualNonExhaustiveEnum::new(msrv)));
     store.register_late_pass(move || Box::new(manual_strip::ManualStrip::new(msrv)));
     store.register_early_pass(move || Box::new(redundant_static_lifetimes::RedundantStaticLifetimes::new(msrv)));
     store.register_early_pass(move || Box::new(redundant_field_names::RedundantFieldNames::new(msrv)));
diff --git a/clippy_lints/src/manual_non_exhaustive.rs b/clippy_lints/src/manual_non_exhaustive.rs
index 33d1bb2985f..7b4b8d6bffa 100644
--- a/clippy_lints/src/manual_non_exhaustive.rs
+++ b/clippy_lints/src/manual_non_exhaustive.rs
@@ -1,13 +1,18 @@
 use clippy_utils::attrs::is_doc_hidden;
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet_opt;
-use clippy_utils::{meets_msrv, msrvs};
+use clippy_utils::{is_lint_allowed, meets_msrv, msrvs};
 use if_chain::if_chain;
-use rustc_ast::ast::{FieldDef, Item, ItemKind, Variant, VariantData, VisibilityKind};
+use rustc_ast::ast::{self, FieldDef, VisibilityKind};
+use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Applicability;
-use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
+use rustc_hir::def::{CtorKind, CtorOf, DefKind, Res};
+use rustc_hir::{self as hir, Expr, ExprKind, QPath};
+use rustc_lint::{EarlyContext, EarlyLintPass, LateContext, LateLintPass, LintContext};
+use rustc_middle::ty::DefIdTree;
 use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::def_id::{DefId, LocalDefId};
 use rustc_span::{sym, Span};
 
 declare_clippy_lint! {
@@ -58,55 +63,84 @@ declare_clippy_lint! {
     "manual implementations of the non-exhaustive pattern can be simplified using #[non_exhaustive]"
 }
 
-#[derive(Clone)]
-pub struct ManualNonExhaustive {
+#[allow(clippy::module_name_repetitions)]
+pub struct ManualNonExhaustiveStruct {
     msrv: Option<RustcVersion>,
 }
 
-impl ManualNonExhaustive {
+impl ManualNonExhaustiveStruct {
     #[must_use]
     pub fn new(msrv: Option<RustcVersion>) -> Self {
         Self { msrv }
     }
 }
 
-impl_lint_pass!(ManualNonExhaustive => [MANUAL_NON_EXHAUSTIVE]);
+impl_lint_pass!(ManualNonExhaustiveStruct => [MANUAL_NON_EXHAUSTIVE]);
 
-impl EarlyLintPass for ManualNonExhaustive {
-    fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {
+#[allow(clippy::module_name_repetitions)]
+pub struct ManualNonExhaustiveEnum {
+    msrv: Option<RustcVersion>,
+    constructed_enum_variants: FxHashSet<(DefId, DefId)>,
+    potential_enums: Vec<(LocalDefId, LocalDefId, Span, Span)>,
+}
+
+impl ManualNonExhaustiveEnum {
+    #[must_use]
+    pub fn new(msrv: Option<RustcVersion>) -> Self {
+        Self {
+            msrv,
+            constructed_enum_variants: FxHashSet::default(),
+            potential_enums: Vec::new(),
+        }
+    }
+}
+
+impl_lint_pass!(ManualNonExhaustiveEnum => [MANUAL_NON_EXHAUSTIVE]);
+
+impl EarlyLintPass for ManualNonExhaustiveStruct {
+    fn check_item(&mut self, cx: &EarlyContext<'_>, item: &ast::Item) {
         if !meets_msrv(self.msrv.as_ref(), &msrvs::NON_EXHAUSTIVE) {
             return;
         }
 
-        match &item.kind {
-            ItemKind::Enum(def, _) => {
-                check_manual_non_exhaustive_enum(cx, item, &def.variants);
-            },
-            ItemKind::Struct(variant_data, _) => {
-                if let VariantData::Unit(..) = variant_data {
-                    return;
-                }
-
-                check_manual_non_exhaustive_struct(cx, item, variant_data);
-            },
-            _ => {},
+        if let ast::ItemKind::Struct(variant_data, _) = &item.kind {
+            if let ast::VariantData::Unit(..) = variant_data {
+                return;
+            }
+
+            check_manual_non_exhaustive_struct(cx, item, variant_data);
         }
     }
 
     extract_msrv_attr!(EarlyContext);
 }
 
-fn check_manual_non_exhaustive_enum(cx: &EarlyContext<'_>, item: &Item, variants: &[Variant]) {
-    fn is_non_exhaustive_marker(variant: &Variant) -> bool {
-        matches!(variant.data, VariantData::Unit(_))
-            && variant.ident.as_str().starts_with('_')
-            && is_doc_hidden(&variant.attrs)
+fn check_manual_non_exhaustive_struct(cx: &EarlyContext<'_>, item: &ast::Item, data: &ast::VariantData) {
+    fn is_private(field: &FieldDef) -> bool {
+        matches!(field.vis.kind, VisibilityKind::Inherited)
+    }
+
+    fn is_non_exhaustive_marker(field: &FieldDef) -> bool {
+        is_private(field) && field.ty.kind.is_unit() && field.ident.map_or(true, |n| n.as_str().starts_with('_'))
+    }
+
+    fn find_header_span(cx: &EarlyContext<'_>, item: &ast::Item, data: &ast::VariantData) -> Span {
+        let delimiter = match data {
+            ast::VariantData::Struct(..) => '{',
+            ast::VariantData::Tuple(..) => '(',
+            ast::VariantData::Unit(_) => unreachable!("`VariantData::Unit` is already handled above"),
+        };
+
+        cx.sess().source_map().span_until_char(item.span, delimiter)
     }
 
-    let mut markers = variants.iter().filter(|v| is_non_exhaustive_marker(v));
+    let fields = data.fields();
+    let private_fields = fields.iter().filter(|f| is_private(f)).count();
+    let public_fields = fields.iter().filter(|f| f.vis.kind.is_pub()).count();
+
     if_chain! {
-        if let Some(marker) = markers.next();
-        if markers.count() == 0 && variants.len() > 1;
+        if private_fields == 1 && public_fields >= 1 && public_fields == fields.len() - 1;
+        if let Some(marker) = fields.iter().find(|f| is_non_exhaustive_marker(f));
         then {
             span_lint_and_then(
                 cx,
@@ -116,7 +150,7 @@ fn check_manual_non_exhaustive_enum(cx: &EarlyContext<'_>, item: &Item, variants
                 |diag| {
                     if_chain! {
                         if !item.attrs.iter().any(|attr| attr.has_name(sym::non_exhaustive));
-                        let header_span = cx.sess().source_map().span_until_char(item.span, '{');
+                        let header_span = find_header_span(cx, item, data);
                         if let Some(snippet) = snippet_opt(cx, header_span);
                         then {
                             diag.span_suggestion(
@@ -127,60 +161,79 @@ fn check_manual_non_exhaustive_enum(cx: &EarlyContext<'_>, item: &Item, variants
                             );
                         }
                     }
-                    diag.span_help(marker.span, "remove this variant");
+                    diag.span_help(marker.span, "remove this field");
                 });
         }
     }
 }
 
-fn check_manual_non_exhaustive_struct(cx: &EarlyContext<'_>, item: &Item, data: &VariantData) {
-    fn is_private(field: &FieldDef) -> bool {
-        matches!(field.vis.kind, VisibilityKind::Inherited)
-    }
+impl<'tcx> LateLintPass<'tcx> for ManualNonExhaustiveEnum {
+    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) {
+        if !meets_msrv(self.msrv.as_ref(), &msrvs::NON_EXHAUSTIVE) {
+            return;
+        }
 
-    fn is_non_exhaustive_marker(field: &FieldDef) -> bool {
-        is_private(field) && field.ty.kind.is_unit() && field.ident.map_or(true, |n| n.as_str().starts_with('_'))
+        if let hir::ItemKind::Enum(def, _) = &item.kind
+            && def.variants.len() > 1
+        {
+            let mut iter = def.variants.iter().filter_map(|v| {
+                let id = cx.tcx.hir().local_def_id(v.id);
+                (matches!(v.data, hir::VariantData::Unit(_))
+                    && v.ident.as_str().starts_with('_')
+                    && is_doc_hidden(cx.tcx.get_attrs(id.to_def_id())))
+                .then(|| (id, v.span))
+            });
+            if let Some((id, span)) = iter.next()
+                && iter.next().is_none()
+            {
+                self.potential_enums.push((item.def_id, id, item.span, span));
+            }
+        }
     }
 
-    fn find_header_span(cx: &EarlyContext<'_>, item: &Item, data: &VariantData) -> Span {
-        let delimiter = match data {
-            VariantData::Struct(..) => '{',
-            VariantData::Tuple(..) => '(',
-            VariantData::Unit(_) => unreachable!("`VariantData::Unit` is already handled above"),
-        };
-
-        cx.sess().source_map().span_until_char(item.span, delimiter)
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
+        if let ExprKind::Path(QPath::Resolved(None, p)) = &e.kind
+            && let [.., name] = p.segments
+            && let Res::Def(DefKind::Ctor(CtorOf::Variant, CtorKind::Const), id) = p.res
+            && name.ident.as_str().starts_with('_')
+            && let Some(variant_id) = cx.tcx.parent(id)
+            && let Some(enum_id) = cx.tcx.parent(variant_id)
+        {
+            self.constructed_enum_variants.insert((enum_id, variant_id));
+        }
     }
 
-    let fields = data.fields();
-    let private_fields = fields.iter().filter(|f| is_private(f)).count();
-    let public_fields = fields.iter().filter(|f| f.vis.kind.is_pub()).count();
-
-    if_chain! {
-        if private_fields == 1 && public_fields >= 1 && public_fields == fields.len() - 1;
-        if let Some(marker) = fields.iter().find(|f| is_non_exhaustive_marker(f));
-        then {
+    fn check_crate_post(&mut self, cx: &LateContext<'tcx>) {
+        for &(enum_id, _, enum_span, variant_span) in
+            self.potential_enums.iter().filter(|&&(enum_id, variant_id, _, _)| {
+                !self
+                    .constructed_enum_variants
+                    .contains(&(enum_id.to_def_id(), variant_id.to_def_id()))
+                    && !is_lint_allowed(cx, MANUAL_NON_EXHAUSTIVE, cx.tcx.hir().local_def_id_to_hir_id(enum_id))
+            })
+        {
             span_lint_and_then(
                 cx,
                 MANUAL_NON_EXHAUSTIVE,
-                item.span,
+                enum_span,
                 "this seems like a manual implementation of the non-exhaustive pattern",
                 |diag| {
-                    if_chain! {
-                        if !item.attrs.iter().any(|attr| attr.has_name(sym::non_exhaustive));
-                        let header_span = find_header_span(cx, item, data);
-                        if let Some(snippet) = snippet_opt(cx, header_span);
-                        then {
+                    if !cx.tcx.adt_def(enum_id).is_variant_list_non_exhaustive()
+                        && let header_span = cx.sess().source_map().span_until_char(enum_span, '{')
+                        && let Some(snippet) = snippet_opt(cx, header_span)
+                    {
                             diag.span_suggestion(
                                 header_span,
                                 "add the attribute",
                                 format!("#[non_exhaustive] {}", snippet),
                                 Applicability::Unspecified,
                             );
-                        }
                     }
-                    diag.span_help(marker.span, "remove this field");
-                });
+                    diag.span_help(variant_span, "remove this variant");
+                },
+            );
         }
     }
+
+    extract_msrv_attr!(LateContext);
 }
diff --git a/tests/ui/manual_non_exhaustive.rs b/tests/ui/manual_non_exhaustive.rs
deleted file mode 100644
index 7a788f48520..00000000000
--- a/tests/ui/manual_non_exhaustive.rs
+++ /dev/null
@@ -1,137 +0,0 @@
-#![warn(clippy::manual_non_exhaustive)]
-#![allow(unused)]
-
-mod enums {
-    enum E {
-        A,
-        B,
-        #[doc(hidden)]
-        _C,
-    }
-
-    // user forgot to remove the marker
-    #[non_exhaustive]
-    enum Ep {
-        A,
-        B,
-        #[doc(hidden)]
-        _C,
-    }
-
-    // marker variant does not have doc hidden attribute, should be ignored
-    enum NoDocHidden {
-        A,
-        B,
-        _C,
-    }
-
-    // name of variant with doc hidden does not start with underscore, should be ignored
-    enum NoUnderscore {
-        A,
-        B,
-        #[doc(hidden)]
-        C,
-    }
-
-    // variant with doc hidden is not unit, should be ignored
-    enum NotUnit {
-        A,
-        B,
-        #[doc(hidden)]
-        _C(bool),
-    }
-
-    // variant with doc hidden is the only one, should be ignored
-    enum OnlyMarker {
-        #[doc(hidden)]
-        _A,
-    }
-
-    // variant with multiple markers, should be ignored
-    enum MultipleMarkers {
-        A,
-        #[doc(hidden)]
-        _B,
-        #[doc(hidden)]
-        _C,
-    }
-
-    // already non_exhaustive and no markers, should be ignored
-    #[non_exhaustive]
-    enum NonExhaustive {
-        A,
-        B,
-    }
-}
-
-mod structs {
-    struct S {
-        pub a: i32,
-        pub b: i32,
-        _c: (),
-    }
-
-    // user forgot to remove the private field
-    #[non_exhaustive]
-    struct Sp {
-        pub a: i32,
-        pub b: i32,
-        _c: (),
-    }
-
-    // some other fields are private, should be ignored
-    struct PrivateFields {
-        a: i32,
-        pub b: i32,
-        _c: (),
-    }
-
-    // private field name does not start with underscore, should be ignored
-    struct NoUnderscore {
-        pub a: i32,
-        pub b: i32,
-        c: (),
-    }
-
-    // private field is not unit type, should be ignored
-    struct NotUnit {
-        pub a: i32,
-        pub b: i32,
-        _c: i32,
-    }
-
-    // private field is the only field, should be ignored
-    struct OnlyMarker {
-        _a: (),
-    }
-
-    // already non exhaustive and no private fields, should be ignored
-    #[non_exhaustive]
-    struct NonExhaustive {
-        pub a: i32,
-        pub b: i32,
-    }
-}
-
-mod tuple_structs {
-    struct T(pub i32, pub i32, ());
-
-    // user forgot to remove the private field
-    #[non_exhaustive]
-    struct Tp(pub i32, pub i32, ());
-
-    // some other fields are private, should be ignored
-    struct PrivateFields(pub i32, i32, ());
-
-    // private field is not unit type, should be ignored
-    struct NotUnit(pub i32, pub i32, i32);
-
-    // private field is the only field, should be ignored
-    struct OnlyMarker(());
-
-    // already non exhaustive and no private fields, should be ignored
-    #[non_exhaustive]
-    struct NonExhaustive(pub i32, pub i32);
-}
-
-fn main() {}
diff --git a/tests/ui/manual_non_exhaustive.stderr b/tests/ui/manual_non_exhaustive.stderr
deleted file mode 100644
index 613c5e8ca1d..00000000000
--- a/tests/ui/manual_non_exhaustive.stderr
+++ /dev/null
@@ -1,103 +0,0 @@
-error: this seems like a manual implementation of the non-exhaustive pattern
-  --> $DIR/manual_non_exhaustive.rs:5:5
-   |
-LL |       enum E {
-   |       ^-----
-   |       |
-   |  _____help: add the attribute: `#[non_exhaustive] enum E`
-   | |
-LL | |         A,
-LL | |         B,
-LL | |         #[doc(hidden)]
-LL | |         _C,
-LL | |     }
-   | |_____^
-   |
-   = note: `-D clippy::manual-non-exhaustive` implied by `-D warnings`
-help: remove this variant
-  --> $DIR/manual_non_exhaustive.rs:9:9
-   |
-LL |         _C,
-   |         ^^
-
-error: this seems like a manual implementation of the non-exhaustive pattern
-  --> $DIR/manual_non_exhaustive.rs:14:5
-   |
-LL | /     enum Ep {
-LL | |         A,
-LL | |         B,
-LL | |         #[doc(hidden)]
-LL | |         _C,
-LL | |     }
-   | |_____^
-   |
-help: remove this variant
-  --> $DIR/manual_non_exhaustive.rs:18:9
-   |
-LL |         _C,
-   |         ^^
-
-error: this seems like a manual implementation of the non-exhaustive pattern
-  --> $DIR/manual_non_exhaustive.rs:68:5
-   |
-LL |       struct S {
-   |       ^-------
-   |       |
-   |  _____help: add the attribute: `#[non_exhaustive] struct S`
-   | |
-LL | |         pub a: i32,
-LL | |         pub b: i32,
-LL | |         _c: (),
-LL | |     }
-   | |_____^
-   |
-help: remove this field
-  --> $DIR/manual_non_exhaustive.rs:71:9
-   |
-LL |         _c: (),
-   |         ^^^^^^
-
-error: this seems like a manual implementation of the non-exhaustive pattern
-  --> $DIR/manual_non_exhaustive.rs:76:5
-   |
-LL | /     struct Sp {
-LL | |         pub a: i32,
-LL | |         pub b: i32,
-LL | |         _c: (),
-LL | |     }
-   | |_____^
-   |
-help: remove this field
-  --> $DIR/manual_non_exhaustive.rs:79:9
-   |
-LL |         _c: (),
-   |         ^^^^^^
-
-error: this seems like a manual implementation of the non-exhaustive pattern
-  --> $DIR/manual_non_exhaustive.rs:117:5
-   |
-LL |     struct T(pub i32, pub i32, ());
-   |     --------^^^^^^^^^^^^^^^^^^^^^^^
-   |     |
-   |     help: add the attribute: `#[non_exhaustive] struct T`
-   |
-help: remove this field
-  --> $DIR/manual_non_exhaustive.rs:117:32
-   |
-LL |     struct T(pub i32, pub i32, ());
-   |                                ^^
-
-error: this seems like a manual implementation of the non-exhaustive pattern
-  --> $DIR/manual_non_exhaustive.rs:121:5
-   |
-LL |     struct Tp(pub i32, pub i32, ());
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: remove this field
-  --> $DIR/manual_non_exhaustive.rs:121:33
-   |
-LL |     struct Tp(pub i32, pub i32, ());
-   |                                 ^^
-
-error: aborting due to 6 previous errors
-
diff --git a/tests/ui/manual_non_exhaustive_enum.rs b/tests/ui/manual_non_exhaustive_enum.rs
new file mode 100644
index 00000000000..f23c6d69b4c
--- /dev/null
+++ b/tests/ui/manual_non_exhaustive_enum.rs
@@ -0,0 +1,78 @@
+#![warn(clippy::manual_non_exhaustive)]
+#![allow(unused)]
+
+enum E {
+    A,
+    B,
+    #[doc(hidden)]
+    _C,
+}
+
+// user forgot to remove the marker
+#[non_exhaustive]
+enum Ep {
+    A,
+    B,
+    #[doc(hidden)]
+    _C,
+}
+
+// marker variant does not have doc hidden attribute, should be ignored
+enum NoDocHidden {
+    A,
+    B,
+    _C,
+}
+
+// name of variant with doc hidden does not start with underscore, should be ignored
+enum NoUnderscore {
+    A,
+    B,
+    #[doc(hidden)]
+    C,
+}
+
+// variant with doc hidden is not unit, should be ignored
+enum NotUnit {
+    A,
+    B,
+    #[doc(hidden)]
+    _C(bool),
+}
+
+// variant with doc hidden is the only one, should be ignored
+enum OnlyMarker {
+    #[doc(hidden)]
+    _A,
+}
+
+// variant with multiple markers, should be ignored
+enum MultipleMarkers {
+    A,
+    #[doc(hidden)]
+    _B,
+    #[doc(hidden)]
+    _C,
+}
+
+// already non_exhaustive and no markers, should be ignored
+#[non_exhaustive]
+enum NonExhaustive {
+    A,
+    B,
+}
+
+// marked is used, don't lint
+enum UsedHidden {
+    #[doc(hidden)]
+    _A,
+    B,
+    C,
+}
+fn foo(x: &mut UsedHidden) {
+    if matches!(*x, UsedHidden::B) {
+        *x = UsedHidden::_A;
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/manual_non_exhaustive_enum.stderr b/tests/ui/manual_non_exhaustive_enum.stderr
new file mode 100644
index 00000000000..317a45d2cbd
--- /dev/null
+++ b/tests/ui/manual_non_exhaustive_enum.stderr
@@ -0,0 +1,41 @@
+error: this seems like a manual implementation of the non-exhaustive pattern
+  --> $DIR/manual_non_exhaustive_enum.rs:4:1
+   |
+LL |   enum E {
+   |   ^-----
+   |   |
+   |  _help: add the attribute: `#[non_exhaustive] enum E`
+   | |
+LL | |     A,
+LL | |     B,
+LL | |     #[doc(hidden)]
+LL | |     _C,
+LL | | }
+   | |_^
+   |
+   = note: `-D clippy::manual-non-exhaustive` implied by `-D warnings`
+help: remove this variant
+  --> $DIR/manual_non_exhaustive_enum.rs:8:5
+   |
+LL |     _C,
+   |     ^^
+
+error: this seems like a manual implementation of the non-exhaustive pattern
+  --> $DIR/manual_non_exhaustive_enum.rs:13:1
+   |
+LL | / enum Ep {
+LL | |     A,
+LL | |     B,
+LL | |     #[doc(hidden)]
+LL | |     _C,
+LL | | }
+   | |_^
+   |
+help: remove this variant
+  --> $DIR/manual_non_exhaustive_enum.rs:17:5
+   |
+LL |     _C,
+   |     ^^
+
+error: aborting due to 2 previous errors
+
diff --git a/tests/ui/manual_non_exhaustive_struct.rs b/tests/ui/manual_non_exhaustive_struct.rs
new file mode 100644
index 00000000000..498eee4447b
--- /dev/null
+++ b/tests/ui/manual_non_exhaustive_struct.rs
@@ -0,0 +1,74 @@
+#![warn(clippy::manual_non_exhaustive)]
+#![allow(unused)]
+
+mod structs {
+    struct S {
+        pub a: i32,
+        pub b: i32,
+        _c: (),
+    }
+
+    // user forgot to remove the private field
+    #[non_exhaustive]
+    struct Sp {
+        pub a: i32,
+        pub b: i32,
+        _c: (),
+    }
+
+    // some other fields are private, should be ignored
+    struct PrivateFields {
+        a: i32,
+        pub b: i32,
+        _c: (),
+    }
+
+    // private field name does not start with underscore, should be ignored
+    struct NoUnderscore {
+        pub a: i32,
+        pub b: i32,
+        c: (),
+    }
+
+    // private field is not unit type, should be ignored
+    struct NotUnit {
+        pub a: i32,
+        pub b: i32,
+        _c: i32,
+    }
+
+    // private field is the only field, should be ignored
+    struct OnlyMarker {
+        _a: (),
+    }
+
+    // already non exhaustive and no private fields, should be ignored
+    #[non_exhaustive]
+    struct NonExhaustive {
+        pub a: i32,
+        pub b: i32,
+    }
+}
+
+mod tuple_structs {
+    struct T(pub i32, pub i32, ());
+
+    // user forgot to remove the private field
+    #[non_exhaustive]
+    struct Tp(pub i32, pub i32, ());
+
+    // some other fields are private, should be ignored
+    struct PrivateFields(pub i32, i32, ());
+
+    // private field is not unit type, should be ignored
+    struct NotUnit(pub i32, pub i32, i32);
+
+    // private field is the only field, should be ignored
+    struct OnlyMarker(());
+
+    // already non exhaustive and no private fields, should be ignored
+    #[non_exhaustive]
+    struct NonExhaustive(pub i32, pub i32);
+}
+
+fn main() {}
diff --git a/tests/ui/manual_non_exhaustive_struct.stderr b/tests/ui/manual_non_exhaustive_struct.stderr
new file mode 100644
index 00000000000..e0766c17b75
--- /dev/null
+++ b/tests/ui/manual_non_exhaustive_struct.stderr
@@ -0,0 +1,65 @@
+error: this seems like a manual implementation of the non-exhaustive pattern
+  --> $DIR/manual_non_exhaustive_struct.rs:5:5
+   |
+LL |       struct S {
+   |       ^-------
+   |       |
+   |  _____help: add the attribute: `#[non_exhaustive] struct S`
+   | |
+LL | |         pub a: i32,
+LL | |         pub b: i32,
+LL | |         _c: (),
+LL | |     }
+   | |_____^
+   |
+   = note: `-D clippy::manual-non-exhaustive` implied by `-D warnings`
+help: remove this field
+  --> $DIR/manual_non_exhaustive_struct.rs:8:9
+   |
+LL |         _c: (),
+   |         ^^^^^^
+
+error: this seems like a manual implementation of the non-exhaustive pattern
+  --> $DIR/manual_non_exhaustive_struct.rs:13:5
+   |
+LL | /     struct Sp {
+LL | |         pub a: i32,
+LL | |         pub b: i32,
+LL | |         _c: (),
+LL | |     }
+   | |_____^
+   |
+help: remove this field
+  --> $DIR/manual_non_exhaustive_struct.rs:16:9
+   |
+LL |         _c: (),
+   |         ^^^^^^
+
+error: this seems like a manual implementation of the non-exhaustive pattern
+  --> $DIR/manual_non_exhaustive_struct.rs:54:5
+   |
+LL |     struct T(pub i32, pub i32, ());
+   |     --------^^^^^^^^^^^^^^^^^^^^^^^
+   |     |
+   |     help: add the attribute: `#[non_exhaustive] struct T`
+   |
+help: remove this field
+  --> $DIR/manual_non_exhaustive_struct.rs:54:32
+   |
+LL |     struct T(pub i32, pub i32, ());
+   |                                ^^
+
+error: this seems like a manual implementation of the non-exhaustive pattern
+  --> $DIR/manual_non_exhaustive_struct.rs:58:5
+   |
+LL |     struct Tp(pub i32, pub i32, ());
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove this field
+  --> $DIR/manual_non_exhaustive_struct.rs:58:33
+   |
+LL |     struct Tp(pub i32, pub i32, ());
+   |                                 ^^
+
+error: aborting due to 4 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From b0f8a3155159286af233577aa0f50d933770dc47 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Wed, 6 Apr 2022 09:53:20 -0400
Subject: Cleanup `manual_non_exhaustive`

---
 clippy_lints/src/manual_non_exhaustive.rs | 83 ++++++++++++-------------------
 1 file changed, 32 insertions(+), 51 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_non_exhaustive.rs b/clippy_lints/src/manual_non_exhaustive.rs
index 7b4b8d6bffa..2501dd5bed4 100644
--- a/clippy_lints/src/manual_non_exhaustive.rs
+++ b/clippy_lints/src/manual_non_exhaustive.rs
@@ -2,8 +2,7 @@ use clippy_utils::attrs::is_doc_hidden;
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet_opt;
 use clippy_utils::{is_lint_allowed, meets_msrv, msrvs};
-use if_chain::if_chain;
-use rustc_ast::ast::{self, FieldDef, VisibilityKind};
+use rustc_ast::ast::{self, VisibilityKind};
 use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Applicability;
 use rustc_hir::def::{CtorKind, CtorOf, DefKind, Res};
@@ -104,55 +103,34 @@ impl EarlyLintPass for ManualNonExhaustiveStruct {
         }
 
         if let ast::ItemKind::Struct(variant_data, _) = &item.kind {
-            if let ast::VariantData::Unit(..) = variant_data {
+            let (fields, delimiter) = match variant_data {
+                ast::VariantData::Struct(fields, _) => (&**fields, '{'),
+                ast::VariantData::Tuple(fields, _) => (&**fields, '('),
+                ast::VariantData::Unit(_) => return,
+            };
+            if fields.len() <= 1 {
                 return;
             }
-
-            check_manual_non_exhaustive_struct(cx, item, variant_data);
-        }
-    }
-
-    extract_msrv_attr!(EarlyContext);
-}
-
-fn check_manual_non_exhaustive_struct(cx: &EarlyContext<'_>, item: &ast::Item, data: &ast::VariantData) {
-    fn is_private(field: &FieldDef) -> bool {
-        matches!(field.vis.kind, VisibilityKind::Inherited)
-    }
-
-    fn is_non_exhaustive_marker(field: &FieldDef) -> bool {
-        is_private(field) && field.ty.kind.is_unit() && field.ident.map_or(true, |n| n.as_str().starts_with('_'))
-    }
-
-    fn find_header_span(cx: &EarlyContext<'_>, item: &ast::Item, data: &ast::VariantData) -> Span {
-        let delimiter = match data {
-            ast::VariantData::Struct(..) => '{',
-            ast::VariantData::Tuple(..) => '(',
-            ast::VariantData::Unit(_) => unreachable!("`VariantData::Unit` is already handled above"),
-        };
-
-        cx.sess().source_map().span_until_char(item.span, delimiter)
-    }
-
-    let fields = data.fields();
-    let private_fields = fields.iter().filter(|f| is_private(f)).count();
-    let public_fields = fields.iter().filter(|f| f.vis.kind.is_pub()).count();
-
-    if_chain! {
-        if private_fields == 1 && public_fields >= 1 && public_fields == fields.len() - 1;
-        if let Some(marker) = fields.iter().find(|f| is_non_exhaustive_marker(f));
-        then {
-            span_lint_and_then(
-                cx,
-                MANUAL_NON_EXHAUSTIVE,
-                item.span,
-                "this seems like a manual implementation of the non-exhaustive pattern",
-                |diag| {
-                    if_chain! {
-                        if !item.attrs.iter().any(|attr| attr.has_name(sym::non_exhaustive));
-                        let header_span = find_header_span(cx, item, data);
-                        if let Some(snippet) = snippet_opt(cx, header_span);
-                        then {
+            let mut iter = fields.iter().filter_map(|f| match f.vis.kind {
+                VisibilityKind::Public => None,
+                VisibilityKind::Inherited => Some(Ok(f)),
+                _ => Some(Err(())),
+            });
+            if let Some(Ok(field)) = iter.next()
+                && iter.next().is_none()
+                && field.ty.kind.is_unit()
+                && field.ident.map_or(true, |name| name.as_str().starts_with('_'))
+            {
+                span_lint_and_then(
+                    cx,
+                    MANUAL_NON_EXHAUSTIVE,
+                    item.span,
+                    "this seems like a manual implementation of the non-exhaustive pattern",
+                    |diag| {
+                        if !item.attrs.iter().any(|attr| attr.has_name(sym::non_exhaustive))
+                            && let header_span = cx.sess().source_map().span_until_char(item.span, delimiter)
+                            && let Some(snippet) = snippet_opt(cx, header_span)
+                        {
                             diag.span_suggestion(
                                 header_span,
                                 "add the attribute",
@@ -160,11 +138,14 @@ fn check_manual_non_exhaustive_struct(cx: &EarlyContext<'_>, item: &ast::Item, d
                                 Applicability::Unspecified,
                             );
                         }
+                        diag.span_help(field.span, "remove this field");
                     }
-                    diag.span_help(marker.span, "remove this field");
-                });
+                );
+            }
         }
     }
+
+    extract_msrv_attr!(EarlyContext);
 }
 
 impl<'tcx> LateLintPass<'tcx> for ManualNonExhaustiveEnum {
-- 
cgit 1.4.1-3-g733a5


From ddd3af227329236db174dbfb920b27037e138279 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Wed, 6 Apr 2022 10:56:06 -0400
Subject: Only lint `mut_from_ref` when unsafe code is used

---
 clippy_lints/src/ptr.rs      | 56 +++++++++++++++++++++++---------------------
 clippy_utils/src/visitors.rs | 34 ++++++++++++++++++++++++++-
 tests/ui/mut_from_ref.rs     | 20 +++++++++++-----
 tests/ui/mut_from_ref.stderr | 14 ++++++++++-
 4 files changed, 89 insertions(+), 35 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs
index ba1997e70e1..4ecde8f4958 100644
--- a/clippy_lints/src/ptr.rs
+++ b/clippy_lints/src/ptr.rs
@@ -3,6 +3,7 @@
 use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::expr_sig;
+use clippy_utils::visitors::contains_unsafe_block;
 use clippy_utils::{get_expr_use_or_unification_node, is_lint_allowed, path_def_id, path_to_local, paths};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
@@ -10,9 +11,9 @@ use rustc_hir::def_id::DefId;
 use rustc_hir::hir_id::HirIdMap;
 use rustc_hir::intravisit::{walk_expr, Visitor};
 use rustc_hir::{
-    self as hir, AnonConst, BinOpKind, BindingAnnotation, Body, Expr, ExprKind, FnDecl, FnRetTy, GenericArg,
+    self as hir, AnonConst, BinOpKind, BindingAnnotation, Body, Expr, ExprKind, FnRetTy, FnSig, GenericArg,
     ImplItemKind, ItemKind, Lifetime, LifetimeName, Mutability, Node, Param, ParamName, PatKind, QPath, TraitFn,
-    TraitItem, TraitItemKind, TyKind,
+    TraitItem, TraitItemKind, TyKind, Unsafety,
 };
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::nested_filter;
@@ -145,7 +146,7 @@ impl<'tcx> LateLintPass<'tcx> for Ptr {
                 return;
             }
 
-            check_mut_from_ref(cx, sig.decl);
+            check_mut_from_ref(cx, sig, None);
             for arg in check_fn_args(
                 cx,
                 cx.tcx.fn_sig(item.def_id).skip_binder().inputs(),
@@ -170,10 +171,10 @@ impl<'tcx> LateLintPass<'tcx> for Ptr {
     fn check_body(&mut self, cx: &LateContext<'tcx>, body: &'tcx Body<'_>) {
         let hir = cx.tcx.hir();
         let mut parents = hir.parent_iter(body.value.hir_id);
-        let (item_id, decl, is_trait_item) = match parents.next() {
+        let (item_id, sig, is_trait_item) = match parents.next() {
             Some((_, Node::Item(i))) => {
                 if let ItemKind::Fn(sig, ..) = &i.kind {
-                    (i.def_id, sig.decl, false)
+                    (i.def_id, sig, false)
                 } else {
                     return;
                 }
@@ -185,14 +186,14 @@ impl<'tcx> LateLintPass<'tcx> for Ptr {
                     return;
                 }
                 if let ImplItemKind::Fn(sig, _) = &i.kind {
-                    (i.def_id, sig.decl, false)
+                    (i.def_id, sig, false)
                 } else {
                     return;
                 }
             },
             Some((_, Node::TraitItem(i))) => {
                 if let TraitItemKind::Fn(sig, _) = &i.kind {
-                    (i.def_id, sig.decl, true)
+                    (i.def_id, sig, true)
                 } else {
                     return;
                 }
@@ -200,7 +201,8 @@ impl<'tcx> LateLintPass<'tcx> for Ptr {
             _ => return,
         };
 
-        check_mut_from_ref(cx, decl);
+        check_mut_from_ref(cx, sig, Some(body));
+        let decl = sig.decl;
         let sig = cx.tcx.fn_sig(item_id).skip_binder();
         let lint_args: Vec<_> = check_fn_args(cx, sig.inputs(), decl.inputs, body.params)
             .filter(|arg| !is_trait_item || arg.mutability() == Mutability::Not)
@@ -478,31 +480,31 @@ fn check_fn_args<'cx, 'tcx: 'cx>(
         })
 }
 
-fn check_mut_from_ref(cx: &LateContext<'_>, decl: &FnDecl<'_>) {
-    if let FnRetTy::Return(ty) = decl.output {
-        if let Some((out, Mutability::Mut, _)) = get_rptr_lm(ty) {
-            let mut immutables = vec![];
-            for (_, mutbl, argspan) in decl
-                .inputs
-                .iter()
-                .filter_map(get_rptr_lm)
-                .filter(|&(lt, _, _)| lt.name == out.name)
-            {
-                if mutbl == Mutability::Mut {
-                    return;
-                }
-                immutables.push(argspan);
-            }
-            if immutables.is_empty() {
-                return;
-            }
+fn check_mut_from_ref<'tcx>(cx: &LateContext<'tcx>, sig: &FnSig<'_>, body: Option<&'tcx Body<'_>>) {
+    if let FnRetTy::Return(ty) = sig.decl.output
+        && let Some((out, Mutability::Mut, _)) = get_rptr_lm(ty)
+    {
+        let args: Option<Vec<_>> = sig
+            .decl
+            .inputs
+            .iter()
+            .filter_map(get_rptr_lm)
+            .filter(|&(lt, _, _)| lt.name == out.name)
+            .map(|(_, mutability, span)| (mutability == Mutability::Not).then(|| span))
+            .collect();
+        if let Some(args) = args
+            && !args.is_empty()
+            && body.map_or(true, |body| {
+                sig.header.unsafety == Unsafety::Unsafe || contains_unsafe_block(cx, &body.value)
+            })
+        {
             span_lint_and_then(
                 cx,
                 MUT_FROM_REF,
                 ty.span,
                 "mutable borrow from immutable input(s)",
                 |diag| {
-                    let ms = MultiSpan::from_spans(immutables);
+                    let ms = MultiSpan::from_spans(args);
                     diag.span_note(ms, "immutable borrow here");
                 },
             );
diff --git a/clippy_utils/src/visitors.rs b/clippy_utils/src/visitors.rs
index 40451b17a9c..3db64b25353 100644
--- a/clippy_utils/src/visitors.rs
+++ b/clippy_utils/src/visitors.rs
@@ -3,7 +3,8 @@ use rustc_hir as hir;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::intravisit::{self, walk_block, walk_expr, Visitor};
 use rustc_hir::{
-    Arm, Block, BlockCheckMode, Body, BodyId, Expr, ExprKind, HirId, ItemId, ItemKind, Stmt, UnOp, Unsafety,
+    Arm, Block, BlockCheckMode, Body, BodyId, Expr, ExprKind, HirId, ItemId, ItemKind, Stmt, UnOp, UnsafeSource,
+    Unsafety,
 };
 use rustc_lint::LateContext;
 use rustc_middle::hir::map::Map;
@@ -370,3 +371,34 @@ pub fn is_expr_unsafe<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> bool {
     v.visit_expr(e);
     v.is_unsafe
 }
+
+/// Checks if the given expression contains an unsafe block
+pub fn contains_unsafe_block<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'tcx>) -> bool {
+    struct V<'cx, 'tcx> {
+        cx: &'cx LateContext<'tcx>,
+        found_unsafe: bool,
+    }
+    impl<'tcx> Visitor<'tcx> for V<'_, 'tcx> {
+        type NestedFilter = nested_filter::OnlyBodies;
+        fn nested_visit_map(&mut self) -> Self::Map {
+            self.cx.tcx.hir()
+        }
+
+        fn visit_block(&mut self, b: &'tcx Block<'_>) {
+            if self.found_unsafe {
+                return;
+            }
+            if b.rules == BlockCheckMode::UnsafeBlock(UnsafeSource::UserProvided) {
+                self.found_unsafe = true;
+                return;
+            }
+            walk_block(self, b);
+        }
+    }
+    let mut v = V {
+        cx,
+        found_unsafe: false,
+    };
+    v.visit_expr(e);
+    v.found_unsafe
+}
diff --git a/tests/ui/mut_from_ref.rs b/tests/ui/mut_from_ref.rs
index a9a04c8f56b..370dbd58821 100644
--- a/tests/ui/mut_from_ref.rs
+++ b/tests/ui/mut_from_ref.rs
@@ -5,7 +5,7 @@ struct Foo;
 
 impl Foo {
     fn this_wont_hurt_a_bit(&self) -> &mut Foo {
-        unimplemented!()
+        unsafe { unimplemented!() }
     }
 }
 
@@ -15,29 +15,37 @@ trait Ouch {
 
 impl Ouch for Foo {
     fn ouch(x: &Foo) -> &mut Foo {
-        unimplemented!()
+        unsafe { unimplemented!() }
     }
 }
 
 fn fail(x: &u32) -> &mut u16 {
-    unimplemented!()
+    unsafe { unimplemented!() }
 }
 
 fn fail_lifetime<'a>(x: &'a u32, y: &mut u32) -> &'a mut u32 {
-    unimplemented!()
+    unsafe { unimplemented!() }
 }
 
 fn fail_double<'a, 'b>(x: &'a u32, y: &'a u32, z: &'b mut u32) -> &'a mut u32 {
-    unimplemented!()
+    unsafe { unimplemented!() }
 }
 
 // this is OK, because the result borrows y
 fn works<'a>(x: &u32, y: &'a mut u32) -> &'a mut u32 {
-    unimplemented!()
+    unsafe { unimplemented!() }
 }
 
 // this is also OK, because the result could borrow y
 fn also_works<'a>(x: &'a u32, y: &'a mut u32) -> &'a mut u32 {
+    unsafe { unimplemented!() }
+}
+
+unsafe fn also_broken(x: &u32) -> &mut u32 {
+    unimplemented!()
+}
+
+fn without_unsafe(x: &u32) -> &mut u32 {
     unimplemented!()
 }
 
diff --git a/tests/ui/mut_from_ref.stderr b/tests/ui/mut_from_ref.stderr
index 4787999920b..b76d6a13ffb 100644
--- a/tests/ui/mut_from_ref.stderr
+++ b/tests/ui/mut_from_ref.stderr
@@ -59,5 +59,17 @@ note: immutable borrow here
 LL | fn fail_double<'a, 'b>(x: &'a u32, y: &'a u32, z: &'b mut u32) -> &'a mut u32 {
    |                           ^^^^^^^     ^^^^^^^
 
-error: aborting due to 5 previous errors
+error: mutable borrow from immutable input(s)
+  --> $DIR/mut_from_ref.rs:44:35
+   |
+LL | unsafe fn also_broken(x: &u32) -> &mut u32 {
+   |                                   ^^^^^^^^
+   |
+note: immutable borrow here
+  --> $DIR/mut_from_ref.rs:44:26
+   |
+LL | unsafe fn also_broken(x: &u32) -> &mut u32 {
+   |                          ^^^^
+
+error: aborting due to 6 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From d5e887c6f005347c5c243fe8691e2b7d7d594203 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Wed, 6 Apr 2022 11:57:55 -0400
Subject: Better check size and alignment requirements in
 `unsound_collection_transmute`

---
 clippy_lints/src/transmute/utils.rs | 18 +++++++-----------
 tests/ui/transmute_collection.rs    |  5 ++++-
 2 files changed, 11 insertions(+), 12 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/transmute/utils.rs b/clippy_lints/src/transmute/utils.rs
index f359b606e45..0e07a0b0392 100644
--- a/clippy_lints/src/transmute/utils.rs
+++ b/clippy_lints/src/transmute/utils.rs
@@ -1,10 +1,9 @@
 use clippy_utils::last_path_segment;
 use clippy_utils::source::snippet;
-use clippy_utils::ty::is_normalizable;
 use if_chain::if_chain;
 use rustc_hir::{Expr, GenericArg, QPath, TyKind};
 use rustc_lint::LateContext;
-use rustc_middle::ty::{self, cast::CastKind, Ty};
+use rustc_middle::ty::{cast::CastKind, Ty};
 use rustc_span::DUMMY_SP;
 use rustc_typeck::check::{cast::CastCheck, FnCtxt, Inherited};
 
@@ -34,15 +33,12 @@ pub(super) fn get_type_snippet(cx: &LateContext<'_>, path: &QPath<'_>, to_ref_ty
 // check if the component types of the transmuted collection and the result have different ABI,
 // size or alignment
 pub(super) fn is_layout_incompatible<'tcx>(cx: &LateContext<'tcx>, from: Ty<'tcx>, to: Ty<'tcx>) -> bool {
-    let empty_param_env = ty::ParamEnv::empty();
-    // check if `from` and `to` are normalizable to avoid ICE (#4968)
-    if !(is_normalizable(cx, empty_param_env, from) && is_normalizable(cx, empty_param_env, to)) {
-        return false;
-    }
-    let from_ty_layout = cx.tcx.layout_of(empty_param_env.and(from));
-    let to_ty_layout = cx.tcx.layout_of(empty_param_env.and(to));
-    if let (Ok(from_layout), Ok(to_layout)) = (from_ty_layout, to_ty_layout) {
-        from_layout.size != to_layout.size || from_layout.align != to_layout.align || from_layout.abi != to_layout.abi
+    if let Ok(from) = cx.tcx.try_normalize_erasing_regions(cx.param_env, from)
+        && let Ok(to) = cx.tcx.try_normalize_erasing_regions(cx.param_env, to)
+        && let Ok(from_layout) = cx.tcx.layout_of(cx.param_env.and(from))
+        && let Ok(to_layout) = cx.tcx.layout_of(cx.param_env.and(to))
+    {
+        from_layout.size != to_layout.size || from_layout.align.abi != to_layout.align.abi
     } else {
         // no idea about layout, so don't lint
         false
diff --git a/tests/ui/transmute_collection.rs b/tests/ui/transmute_collection.rs
index cd5a7127791..5a431bee04a 100644
--- a/tests/ui/transmute_collection.rs
+++ b/tests/ui/transmute_collection.rs
@@ -1,7 +1,7 @@
 #![warn(clippy::unsound_collection_transmute)]
 
 use std::collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, VecDeque};
-use std::mem::transmute;
+use std::mem::{transmute, MaybeUninit};
 
 fn main() {
     unsafe {
@@ -43,5 +43,8 @@ fn main() {
         // wrong layout
         let _ = transmute::<_, HashMap<u8, u32>>(HashMap::<u8, [u8; 4]>::new());
         let _ = transmute::<_, HashMap<u32, u32>>(HashMap::<[u8; 4], u32>::new());
+
+        let _ = transmute::<_, Vec<u8>>(Vec::<MaybeUninit<u8>>::new());
+        let _ = transmute::<_, Vec<*mut u32>>(Vec::<Box<u32>>::new());
     }
 }
-- 
cgit 1.4.1-3-g733a5


From cebe575aad4cc24401d676299e31126ea3af26f6 Mon Sep 17 00:00:00 2001
From: InfRandomness <infrandomness@gmail.com>
Date: Tue, 29 Mar 2022 19:19:16 +0200
Subject: Add .err().expect() lint

---
 clippy_lints/src/methods/err_expect.rs | 59 ++++++++++++++++++++++++++++++++++
 clippy_lints/src/methods/mod.rs        | 28 ++++++++++++++++
 clippy_lints/src/utils/conf.rs         |  2 +-
 clippy_utils/src/msrvs.rs              |  2 +-
 tests/ui/err_expect.fixed              | 14 ++++++++
 tests/ui/err_expect.rs                 | 14 ++++++++
 tests/ui/err_expect.stderr             | 10 ++++++
 tests/ui/min_rust_version_attr.rs      |  6 ++++
 tests/ui/min_rust_version_attr.stderr  |  8 ++---
 9 files changed, 137 insertions(+), 6 deletions(-)
 create mode 100644 clippy_lints/src/methods/err_expect.rs
 create mode 100644 tests/ui/err_expect.fixed
 create mode 100644 tests/ui/err_expect.rs
 create mode 100644 tests/ui/err_expect.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/err_expect.rs b/clippy_lints/src/methods/err_expect.rs
new file mode 100644
index 00000000000..887f5c1cb3b
--- /dev/null
+++ b/clippy_lints/src/methods/err_expect.rs
@@ -0,0 +1,59 @@
+use super::ERR_EXPECT;
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::ty::implements_trait;
+use clippy_utils::{meets_msrv, msrvs, ty::is_type_diagnostic_item};
+use rustc_errors::Applicability;
+use rustc_lint::LateContext;
+use rustc_middle::ty;
+use rustc_middle::ty::Ty;
+use rustc_semver::RustcVersion;
+use rustc_span::{sym, Span};
+
+pub(super) fn check(
+    cx: &LateContext<'_>,
+    _expr: &rustc_hir::Expr<'_>,
+    recv: &rustc_hir::Expr<'_>,
+    msrv: Option<&RustcVersion>,
+    expect_span: Span,
+    err_span: Span,
+) {
+    if_chain! {
+        if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(recv), sym::Result);
+        // Test the version to make sure the lint can be showed (expect_err has been introduced in rust 1.17.0 : https://github.com/rust-lang/rust/pull/38982)
+        if meets_msrv(msrv, &msrvs::EXPECT_ERR);
+
+        // Grabs the `Result<T, E>` type
+        let result_type = cx.typeck_results().expr_ty(recv);
+        // Tests if the T type in a `Result<T, E>` is not None
+        if let Some(data_type) = get_data_type(cx, result_type);
+        // Tests if the T type in a `Result<T, E>` implements debug
+        if has_debug_impl(data_type, cx);
+
+        then {
+            span_lint_and_sugg(
+                cx,
+                ERR_EXPECT,
+                err_span.to(expect_span),
+                "called `.err().expect()` on a `Result` value",
+                "try",
+                "expect_err".to_string(),
+                Applicability::MachineApplicable
+        );
+        }
+    };
+}
+
+/// Given a `Result<T, E>` type, return its data (`T`).
+fn get_data_type<'a>(cx: &LateContext<'_>, ty: Ty<'a>) -> Option<Ty<'a>> {
+    match ty.kind() {
+        ty::Adt(_, substs) if is_type_diagnostic_item(cx, ty, sym::Result) => substs.types().next(),
+        _ => None,
+    }
+}
+
+/// Given a type, very if the Debug trait has been impl'd
+fn has_debug_impl<'tcx>(ty: Ty<'tcx>, cx: &LateContext<'tcx>) -> bool {
+    cx.tcx
+        .get_diagnostic_item(sym::Debug)
+        .map_or(false, |debug| implements_trait(cx, ty, debug, &[]))
+}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index b5a9af8c3bb..4475f8eaf59 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -9,6 +9,7 @@ mod chars_next_cmp_with_unwrap;
 mod clone_on_copy;
 mod clone_on_ref_ptr;
 mod cloned_instead_of_copied;
+mod err_expect;
 mod expect_fun_call;
 mod expect_used;
 mod extend_with_drain;
@@ -362,6 +363,29 @@ declare_clippy_lint! {
     "using `ok().expect()`, which gives worse error messages than calling `expect` directly on the Result"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `.err().expect()` calls on the `Result` type.
+    ///
+    /// ### Why is this bad?
+    /// `.expect_err()` can be called directly to avoid the extra type conversion from `ok()`.
+    ///
+    /// ### Example
+    /// ```should_panic
+    /// let x: Result<u32, &str> = Ok(10);
+    /// x.err().expect("Testing err().expect()");
+    /// ```
+    /// Use instead:
+    /// ```should_panic
+    /// let x: Result<u32, &str> = Ok(10);
+    /// x.expect_err("Testing expect_err");
+    /// ```
+    #[clippy::version = "1.61.0"]
+    pub ERR_EXPECT,
+    style,
+    r#"using `.err().expect("")` when `.expect_err("")` can be used"#
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for usages of `_.unwrap_or_else(Default::default)` on `Option` and
@@ -2168,6 +2192,7 @@ impl_lint_pass!(Methods => [
     NEEDLESS_SPLITN,
     UNNECESSARY_TO_OWNED,
     UNNECESSARY_JOIN,
+    ERR_EXPECT,
 ]);
 
 /// Extracts a method call name, args, and `Span` of the method name.
@@ -2431,8 +2456,10 @@ fn check_methods<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, msrv: Optio
             },
             ("expect", [_]) => match method_call(recv) {
                 Some(("ok", [recv], _)) => ok_expect::check(cx, expr, recv),
+                Some(("err", [recv], err_span)) => err_expect::check(cx, expr, recv, msrv, span, err_span),
                 _ => expect_used::check(cx, expr, recv),
             },
+
             ("extend", [arg]) => {
                 string_extend_chars::check(cx, expr, recv, arg);
                 extend_with_drain::check(cx, expr, recv, arg);
@@ -2574,6 +2601,7 @@ fn check_methods<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, msrv: Optio
                     unnecessary_lazy_eval::check(cx, expr, recv, u_arg, "unwrap_or");
                 },
             },
+
             _ => {},
         }
     }
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 680b2eb1da7..0bb818e2079 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -156,7 +156,7 @@ define_Conf! {
     ///
     /// Suppress lints whenever the suggested change would cause breakage for other crates.
     (avoid_breaking_exported_api: bool = true),
-    /// Lint: MANUAL_SPLIT_ONCE, MANUAL_STR_REPEAT, CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR, IF_THEN_SOME_ELSE_NONE, APPROX_CONSTANT, DEPRECATED_CFG_ATTR, INDEX_REFUTABLE_SLICE, MAP_CLONE, BORROW_AS_PTR, MANUAL_BITS.
+    /// Lint: MANUAL_SPLIT_ONCE, MANUAL_STR_REPEAT, CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR, IF_THEN_SOME_ELSE_NONE, APPROX_CONSTANT, DEPRECATED_CFG_ATTR, INDEX_REFUTABLE_SLICE, MAP_CLONE, BORROW_AS_PTR, MANUAL_BITS, EXPECT_ERR.
     ///
     /// The minimum rust version that the project supports
     (msrv: Option<String> = None),
diff --git a/clippy_utils/src/msrvs.rs b/clippy_utils/src/msrvs.rs
index fce93153d96..12191109b8c 100644
--- a/clippy_utils/src/msrvs.rs
+++ b/clippy_utils/src/msrvs.rs
@@ -30,6 +30,6 @@ msrv_aliases! {
     1,34,0 { TRY_FROM }
     1,30,0 { ITERATOR_FIND_MAP, TOOL_ATTRIBUTES }
     1,28,0 { FROM_BOOL }
-    1,17,0 { FIELD_INIT_SHORTHAND, STATIC_IN_CONST }
+    1,17,0 { FIELD_INIT_SHORTHAND, STATIC_IN_CONST, EXPECT_ERR }
     1,16,0 { STR_REPEAT }
 }
diff --git a/tests/ui/err_expect.fixed b/tests/ui/err_expect.fixed
new file mode 100644
index 00000000000..7e18d70bae4
--- /dev/null
+++ b/tests/ui/err_expect.fixed
@@ -0,0 +1,14 @@
+// run-rustfix
+
+struct MyTypeNonDebug;
+
+#[derive(Debug)]
+struct MyTypeDebug;
+
+fn main() {
+    let test_debug: Result<MyTypeDebug, u32> = Ok(MyTypeDebug);
+    test_debug.expect_err("Testing debug type");
+
+    let test_non_debug: Result<MyTypeNonDebug, u32> = Ok(MyTypeNonDebug);
+    test_non_debug.err().expect("Testing non debug type");
+}
diff --git a/tests/ui/err_expect.rs b/tests/ui/err_expect.rs
new file mode 100644
index 00000000000..bf8c3c9fb8c
--- /dev/null
+++ b/tests/ui/err_expect.rs
@@ -0,0 +1,14 @@
+// run-rustfix
+
+struct MyTypeNonDebug;
+
+#[derive(Debug)]
+struct MyTypeDebug;
+
+fn main() {
+    let test_debug: Result<MyTypeDebug, u32> = Ok(MyTypeDebug);
+    test_debug.err().expect("Testing debug type");
+
+    let test_non_debug: Result<MyTypeNonDebug, u32> = Ok(MyTypeNonDebug);
+    test_non_debug.err().expect("Testing non debug type");
+}
diff --git a/tests/ui/err_expect.stderr b/tests/ui/err_expect.stderr
new file mode 100644
index 00000000000..ffd97e00a5c
--- /dev/null
+++ b/tests/ui/err_expect.stderr
@@ -0,0 +1,10 @@
+error: called `.err().expect()` on a `Result` value
+  --> $DIR/err_expect.rs:10:16
+   |
+LL |     test_debug.err().expect("Testing debug type");
+   |                ^^^^^^^^^^^^ help: try: `expect_err`
+   |
+   = note: `-D clippy::err-expect` implied by `-D warnings`
+
+error: aborting due to previous error
+
diff --git a/tests/ui/min_rust_version_attr.rs b/tests/ui/min_rust_version_attr.rs
index 72e9bf9eb36..7666d01ffe1 100644
--- a/tests/ui/min_rust_version_attr.rs
+++ b/tests/ui/min_rust_version_attr.rs
@@ -145,6 +145,11 @@ fn int_from_bool() -> u8 {
     true as u8
 }
 
+fn err_expect() {
+    let x: Result<u32, &str> = Ok(10);
+    x.err().expect("Testing expect_err");
+}
+
 fn main() {
     filter_map_next();
     checked_conversion();
@@ -162,6 +167,7 @@ fn main() {
     missing_const_for_fn();
     unnest_or_patterns();
     int_from_bool();
+    err_expect();
 }
 
 mod just_under_msrv {
diff --git a/tests/ui/min_rust_version_attr.stderr b/tests/ui/min_rust_version_attr.stderr
index 6b3fdb0844b..9ed6308f115 100644
--- a/tests/ui/min_rust_version_attr.stderr
+++ b/tests/ui/min_rust_version_attr.stderr
@@ -1,12 +1,12 @@
 error: stripping a prefix manually
-  --> $DIR/min_rust_version_attr.rs:186:24
+  --> $DIR/min_rust_version_attr.rs:192:24
    |
 LL |             assert_eq!(s["hello, ".len()..].to_uppercase(), "WORLD!");
    |                        ^^^^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::manual-strip` implied by `-D warnings`
 note: the prefix was tested here
-  --> $DIR/min_rust_version_attr.rs:185:9
+  --> $DIR/min_rust_version_attr.rs:191:9
    |
 LL |         if s.starts_with("hello, ") {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -17,13 +17,13 @@ LL ~             assert_eq!(<stripped>.to_uppercase(), "WORLD!");
    |
 
 error: stripping a prefix manually
-  --> $DIR/min_rust_version_attr.rs:198:24
+  --> $DIR/min_rust_version_attr.rs:204:24
    |
 LL |             assert_eq!(s["hello, ".len()..].to_uppercase(), "WORLD!");
    |                        ^^^^^^^^^^^^^^^^^^^^
    |
 note: the prefix was tested here
-  --> $DIR/min_rust_version_attr.rs:197:9
+  --> $DIR/min_rust_version_attr.rs:203:9
    |
 LL |         if s.starts_with("hello, ") {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From a7125b0393c70c3d25feb7e063c312463694a1f6 Mon Sep 17 00:00:00 2001
From: infrandomness <infrandomness@gmail.com>
Date: Wed, 6 Apr 2022 19:24:49 +0200
Subject: Fix mistakes in documentation :

- err() was meant to be employed instead of ok()
- wraps comment
---
 clippy_lints/src/methods/err_expect.rs | 3 ++-
 clippy_lints/src/methods/mod.rs        | 2 +-
 2 files changed, 3 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/err_expect.rs b/clippy_lints/src/methods/err_expect.rs
index 887f5c1cb3b..be9d4ad94fb 100644
--- a/clippy_lints/src/methods/err_expect.rs
+++ b/clippy_lints/src/methods/err_expect.rs
@@ -19,7 +19,8 @@ pub(super) fn check(
 ) {
     if_chain! {
         if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(recv), sym::Result);
-        // Test the version to make sure the lint can be showed (expect_err has been introduced in rust 1.17.0 : https://github.com/rust-lang/rust/pull/38982)
+        // Test the version to make sure the lint can be showed (expect_err has been
+        // introduced in rust 1.17.0 : https://github.com/rust-lang/rust/pull/38982)
         if meets_msrv(msrv, &msrvs::EXPECT_ERR);
 
         // Grabs the `Result<T, E>` type
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 4475f8eaf59..c5c871c9d29 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -368,7 +368,7 @@ declare_clippy_lint! {
     /// Checks for `.err().expect()` calls on the `Result` type.
     ///
     /// ### Why is this bad?
-    /// `.expect_err()` can be called directly to avoid the extra type conversion from `ok()`.
+    /// `.expect_err()` can be called directly to avoid the extra type conversion from `err()`.
     ///
     /// ### Example
     /// ```should_panic
-- 
cgit 1.4.1-3-g733a5


From b0edbca0e6e4ce771bc5ecf54b9b35a824af07aa Mon Sep 17 00:00:00 2001
From: Paolo Borelli <pborelli@gnome.org>
Date: Mon, 4 Apr 2022 18:38:38 +0200
Subject: new lint cast_abs_to_unsigned

Add a lint to detect cast to unsigned for abs() and suggest
unsigned_abs() to avoid panic when called on MIN.
---
 CHANGELOG.md                                   |  1 +
 clippy_lints/src/casts/cast_abs_to_unsigned.rs | 42 ++++++++++++++++++++++++++
 clippy_lints/src/casts/mod.rs                  | 27 ++++++++++++++++-
 clippy_lints/src/lib.register_all.rs           |  1 +
 clippy_lints/src/lib.register_lints.rs         |  1 +
 clippy_lints/src/lib.register_suspicious.rs    |  1 +
 clippy_lints/src/utils/conf.rs                 |  2 +-
 clippy_utils/src/msrvs.rs                      |  2 +-
 tests/ui/cast.rs                               |  2 +-
 tests/ui/cast_abs_to_unsigned.fixed            |  8 +++++
 tests/ui/cast_abs_to_unsigned.rs               |  8 +++++
 tests/ui/cast_abs_to_unsigned.stderr           | 10 ++++++
 tests/ui/min_rust_version_attr.rs              |  6 ++++
 tests/ui/min_rust_version_attr.stderr          |  8 ++---
 14 files changed, 111 insertions(+), 8 deletions(-)
 create mode 100644 clippy_lints/src/casts/cast_abs_to_unsigned.rs
 create mode 100644 tests/ui/cast_abs_to_unsigned.fixed
 create mode 100644 tests/ui/cast_abs_to_unsigned.rs
 create mode 100644 tests/ui/cast_abs_to_unsigned.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 430154ac34d..fd0e58d5116 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3201,6 +3201,7 @@ Released 2018-09-13
 [`bytes_nth`]: https://rust-lang.github.io/rust-clippy/master/index.html#bytes_nth
 [`cargo_common_metadata`]: https://rust-lang.github.io/rust-clippy/master/index.html#cargo_common_metadata
 [`case_sensitive_file_extension_comparisons`]: https://rust-lang.github.io/rust-clippy/master/index.html#case_sensitive_file_extension_comparisons
+[`cast_abs_to_unsigned`]: https://rust-lang.github.io/rust-clippy/master/index.html#cast_abs_to_unsigned
 [`cast_enum_constructor`]: https://rust-lang.github.io/rust-clippy/master/index.html#cast_enum_constructor
 [`cast_enum_truncation`]: https://rust-lang.github.io/rust-clippy/master/index.html#cast_enum_truncation
 [`cast_lossless`]: https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
diff --git a/clippy_lints/src/casts/cast_abs_to_unsigned.rs b/clippy_lints/src/casts/cast_abs_to_unsigned.rs
new file mode 100644
index 00000000000..e9b0f1f672d
--- /dev/null
+++ b/clippy_lints/src/casts/cast_abs_to_unsigned.rs
@@ -0,0 +1,42 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::sugg::Sugg;
+use clippy_utils::{meets_msrv, msrvs};
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind};
+use rustc_lint::LateContext;
+use rustc_middle::ty::Ty;
+use rustc_semver::RustcVersion;
+
+use super::CAST_ABS_TO_UNSIGNED;
+
+pub(super) fn check(
+    cx: &LateContext<'_>,
+    expr: &Expr<'_>,
+    cast_expr: &Expr<'_>,
+    cast_from: Ty<'_>,
+    cast_to: Ty<'_>,
+    msrv: &Option<RustcVersion>,
+) {
+    if_chain! {
+        if meets_msrv(msrv.as_ref(), &msrvs::UNSIGNED_ABS);
+        if cast_from.is_integral();
+        if cast_to.is_integral();
+        if cast_from.is_signed();
+        if !cast_to.is_signed();
+        if let ExprKind::MethodCall(method_path, args, _) = cast_expr.kind;
+        if let method_name = method_path.ident.name.as_str();
+        if method_name == "abs";
+        then {
+            span_lint_and_sugg(
+                cx,
+                CAST_ABS_TO_UNSIGNED,
+                expr.span,
+                &format!("casting the result of `{}::{}()` to {}", cast_from, method_name, cast_to),
+                "replace with",
+                format!("{}.unsigned_abs()", Sugg::hir(cx, &args[0], "..")),
+                Applicability::MachineApplicable,
+            );
+        }
+    }
+}
diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index be59145afa0..55c1f085657 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -1,3 +1,4 @@
+mod cast_abs_to_unsigned;
 mod cast_enum_constructor;
 mod cast_lossless;
 mod cast_possible_truncation;
@@ -473,6 +474,28 @@ declare_clippy_lint! {
     "casts from an enum tuple constructor to an integer"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for uses of the `abs()` method that cast the result to unsigned.
+    ///
+    /// ### Why is this bad?
+    /// The `unsigned_abs()` method avoids panic when called on the MIN value.
+    ///
+    /// ### Example
+    /// ```rust
+    /// let x: i32 = -42;
+    /// let y: u32 = x.abs() as u32;
+    /// ```
+    /// Use instead:
+    /// let x: i32 = -42;
+    /// let y: u32 = x.unsigned_abs();
+    /// ```
+    #[clippy::version = "1.61.0"]
+    pub CAST_ABS_TO_UNSIGNED,
+    suspicious,
+    "casting the result of `abs()` to an unsigned integer can panic"
+}
+
 pub struct Casts {
     msrv: Option<RustcVersion>,
 }
@@ -500,7 +523,8 @@ impl_lint_pass!(Casts => [
     CHAR_LIT_AS_U8,
     PTR_AS_PTR,
     CAST_ENUM_TRUNCATION,
-    CAST_ENUM_CONSTRUCTOR
+    CAST_ENUM_CONSTRUCTOR,
+    CAST_ABS_TO_UNSIGNED
 ]);
 
 impl<'tcx> LateLintPass<'tcx> for Casts {
@@ -536,6 +560,7 @@ impl<'tcx> LateLintPass<'tcx> for Casts {
                     cast_possible_wrap::check(cx, expr, cast_from, cast_to);
                     cast_precision_loss::check(cx, expr, cast_from, cast_to);
                     cast_sign_loss::check(cx, expr, cast_expr, cast_from, cast_to);
+                    cast_abs_to_unsigned::check(cx, expr, cast_expr, cast_from, cast_to, &self.msrv);
                 }
                 cast_lossless::check(cx, expr, cast_expr, cast_from, cast_to, &self.msrv);
                 cast_enum_constructor::check(cx, expr, cast_expr, cast_from);
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index b2f674e9c88..3d092ac87a4 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -23,6 +23,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(bool_assert_comparison::BOOL_ASSERT_COMPARISON),
     LintId::of(booleans::LOGIC_BUG),
     LintId::of(booleans::NONMINIMAL_BOOL),
+    LintId::of(casts::CAST_ABS_TO_UNSIGNED),
     LintId::of(casts::CAST_ENUM_CONSTRUCTOR),
     LintId::of(casts::CAST_ENUM_TRUNCATION),
     LintId::of(casts::CAST_REF_TO_MUT),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index fb6612f5c32..1aa98a6ec98 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -70,6 +70,7 @@ store.register_lints(&[
     cargo::REDUNDANT_FEATURE_NAMES,
     cargo::WILDCARD_DEPENDENCIES,
     case_sensitive_file_extension_comparisons::CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS,
+    casts::CAST_ABS_TO_UNSIGNED,
     casts::CAST_ENUM_CONSTRUCTOR,
     casts::CAST_ENUM_TRUNCATION,
     casts::CAST_LOSSLESS,
diff --git a/clippy_lints/src/lib.register_suspicious.rs b/clippy_lints/src/lib.register_suspicious.rs
index 4c3fbb6c4a8..82f45b5fd58 100644
--- a/clippy_lints/src/lib.register_suspicious.rs
+++ b/clippy_lints/src/lib.register_suspicious.rs
@@ -7,6 +7,7 @@ store.register_group(true, "clippy::suspicious", Some("clippy_suspicious"), vec!
     LintId::of(attrs::BLANKET_CLIPPY_RESTRICTION_LINTS),
     LintId::of(await_holding_invalid::AWAIT_HOLDING_LOCK),
     LintId::of(await_holding_invalid::AWAIT_HOLDING_REFCELL_REF),
+    LintId::of(casts::CAST_ABS_TO_UNSIGNED),
     LintId::of(casts::CAST_ENUM_CONSTRUCTOR),
     LintId::of(casts::CAST_ENUM_TRUNCATION),
     LintId::of(crate_in_macro_def::CRATE_IN_MACRO_DEF),
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 0bb818e2079..e149a201b7a 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -156,7 +156,7 @@ define_Conf! {
     ///
     /// Suppress lints whenever the suggested change would cause breakage for other crates.
     (avoid_breaking_exported_api: bool = true),
-    /// Lint: MANUAL_SPLIT_ONCE, MANUAL_STR_REPEAT, CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR, IF_THEN_SOME_ELSE_NONE, APPROX_CONSTANT, DEPRECATED_CFG_ATTR, INDEX_REFUTABLE_SLICE, MAP_CLONE, BORROW_AS_PTR, MANUAL_BITS, EXPECT_ERR.
+    /// Lint: MANUAL_SPLIT_ONCE, MANUAL_STR_REPEAT, CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR, IF_THEN_SOME_ELSE_NONE, APPROX_CONSTANT, DEPRECATED_CFG_ATTR, INDEX_REFUTABLE_SLICE, MAP_CLONE, BORROW_AS_PTR, MANUAL_BITS, EXPECT_ERR, CAST_ABS_TO_UNSIGNED.
     ///
     /// The minimum rust version that the project supports
     (msrv: Option<String> = None),
diff --git a/clippy_utils/src/msrvs.rs b/clippy_utils/src/msrvs.rs
index 12191109b8c..0424e067202 100644
--- a/clippy_utils/src/msrvs.rs
+++ b/clippy_utils/src/msrvs.rs
@@ -14,7 +14,7 @@ macro_rules! msrv_aliases {
 msrv_aliases! {
     1,53,0 { OR_PATTERNS, MANUAL_BITS }
     1,52,0 { STR_SPLIT_ONCE }
-    1,51,0 { BORROW_AS_PTR }
+    1,51,0 { BORROW_AS_PTR, UNSIGNED_ABS }
     1,50,0 { BOOL_THEN }
     1,47,0 { TAU }
     1,46,0 { CONST_IF_MATCH }
diff --git a/tests/ui/cast.rs b/tests/ui/cast.rs
index 2e31ad3172e..cf85a5ca931 100644
--- a/tests/ui/cast.rs
+++ b/tests/ui/cast.rs
@@ -7,7 +7,7 @@
     clippy::cast_sign_loss,
     clippy::cast_possible_wrap
 )]
-#[allow(clippy::no_effect, clippy::unnecessary_operation)]
+#[allow(clippy::cast_abs_to_unsigned, clippy::no_effect, clippy::unnecessary_operation)]
 fn main() {
     // Test clippy::cast_precision_loss
     let x0 = 1i32;
diff --git a/tests/ui/cast_abs_to_unsigned.fixed b/tests/ui/cast_abs_to_unsigned.fixed
new file mode 100644
index 00000000000..4ec2465be06
--- /dev/null
+++ b/tests/ui/cast_abs_to_unsigned.fixed
@@ -0,0 +1,8 @@
+// run-rustfix
+#![warn(clippy::cast_abs_to_unsigned)]
+
+fn main() {
+    let x: i32 = -42;
+    let y: u32 = x.unsigned_abs();
+    println!("The absolute value of {} is {}", x, y);
+}
diff --git a/tests/ui/cast_abs_to_unsigned.rs b/tests/ui/cast_abs_to_unsigned.rs
new file mode 100644
index 00000000000..59b9c8c3678
--- /dev/null
+++ b/tests/ui/cast_abs_to_unsigned.rs
@@ -0,0 +1,8 @@
+// run-rustfix
+#![warn(clippy::cast_abs_to_unsigned)]
+
+fn main() {
+    let x: i32 = -42;
+    let y: u32 = x.abs() as u32;
+    println!("The absolute value of {} is {}", x, y);
+}
diff --git a/tests/ui/cast_abs_to_unsigned.stderr b/tests/ui/cast_abs_to_unsigned.stderr
new file mode 100644
index 00000000000..eb12857357a
--- /dev/null
+++ b/tests/ui/cast_abs_to_unsigned.stderr
@@ -0,0 +1,10 @@
+error: casting the result of `i32::abs()` to u32
+  --> $DIR/cast_abs_to_unsigned.rs:6:18
+   |
+LL |     let y: u32 = x.abs() as u32;
+   |                  ^^^^^^^^^^^^^^ help: replace with: `x.unsigned_abs()`
+   |
+   = note: `-D clippy::cast-abs-to-unsigned` implied by `-D warnings`
+
+error: aborting due to previous error
+
diff --git a/tests/ui/min_rust_version_attr.rs b/tests/ui/min_rust_version_attr.rs
index 7666d01ffe1..f83c3e0e281 100644
--- a/tests/ui/min_rust_version_attr.rs
+++ b/tests/ui/min_rust_version_attr.rs
@@ -150,6 +150,11 @@ fn err_expect() {
     x.err().expect("Testing expect_err");
 }
 
+fn cast_abs_to_unsigned() {
+    let x: i32 = 10;
+    assert_eq!(10u32, x.abs() as u32);
+}
+
 fn main() {
     filter_map_next();
     checked_conversion();
@@ -168,6 +173,7 @@ fn main() {
     unnest_or_patterns();
     int_from_bool();
     err_expect();
+    cast_abs_to_unsigned();
 }
 
 mod just_under_msrv {
diff --git a/tests/ui/min_rust_version_attr.stderr b/tests/ui/min_rust_version_attr.stderr
index 9ed6308f115..de225eb740d 100644
--- a/tests/ui/min_rust_version_attr.stderr
+++ b/tests/ui/min_rust_version_attr.stderr
@@ -1,12 +1,12 @@
 error: stripping a prefix manually
-  --> $DIR/min_rust_version_attr.rs:192:24
+  --> $DIR/min_rust_version_attr.rs:198:24
    |
 LL |             assert_eq!(s["hello, ".len()..].to_uppercase(), "WORLD!");
    |                        ^^^^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::manual-strip` implied by `-D warnings`
 note: the prefix was tested here
-  --> $DIR/min_rust_version_attr.rs:191:9
+  --> $DIR/min_rust_version_attr.rs:197:9
    |
 LL |         if s.starts_with("hello, ") {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -17,13 +17,13 @@ LL ~             assert_eq!(<stripped>.to_uppercase(), "WORLD!");
    |
 
 error: stripping a prefix manually
-  --> $DIR/min_rust_version_attr.rs:204:24
+  --> $DIR/min_rust_version_attr.rs:210:24
    |
 LL |             assert_eq!(s["hello, ".len()..].to_uppercase(), "WORLD!");
    |                        ^^^^^^^^^^^^^^^^^^^^
    |
 note: the prefix was tested here
-  --> $DIR/min_rust_version_attr.rs:203:9
+  --> $DIR/min_rust_version_attr.rs:209:9
    |
 LL |         if s.starts_with("hello, ") {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From f2bbb5fac0bd21c2ccd06f27c3b99d4f7ed51841 Mon Sep 17 00:00:00 2001
From: Paolo Borelli <pborelli@gnome.org>
Date: Thu, 7 Apr 2022 11:29:02 +0200
Subject: conf: fix lint name in comment

The lint name is ERR_EXPECT, not EXPECT_ERR
---
 clippy_lints/src/utils/conf.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index e149a201b7a..271c3a3dd18 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -156,7 +156,7 @@ define_Conf! {
     ///
     /// Suppress lints whenever the suggested change would cause breakage for other crates.
     (avoid_breaking_exported_api: bool = true),
-    /// Lint: MANUAL_SPLIT_ONCE, MANUAL_STR_REPEAT, CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR, IF_THEN_SOME_ELSE_NONE, APPROX_CONSTANT, DEPRECATED_CFG_ATTR, INDEX_REFUTABLE_SLICE, MAP_CLONE, BORROW_AS_PTR, MANUAL_BITS, EXPECT_ERR, CAST_ABS_TO_UNSIGNED.
+    /// Lint: MANUAL_SPLIT_ONCE, MANUAL_STR_REPEAT, CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR, IF_THEN_SOME_ELSE_NONE, APPROX_CONSTANT, DEPRECATED_CFG_ATTR, INDEX_REFUTABLE_SLICE, MAP_CLONE, BORROW_AS_PTR, MANUAL_BITS, ERR_EXPECT, CAST_ABS_TO_UNSIGNED.
     ///
     /// The minimum rust version that the project supports
     (msrv: Option<String> = None),
-- 
cgit 1.4.1-3-g733a5


From 182b7c38d7a55bb6f9f238085c6bebf7d28367eb Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Wed, 6 Apr 2022 15:35:49 +0100
Subject: Fix `as_deref_mut` false positives in `needless_option_as_deref`

Also moves the lint to the methods directory
---
 clippy_lints/src/lib.register_all.rs               |  2 +-
 clippy_lints/src/lib.register_complexity.rs        |  2 +-
 clippy_lints/src/lib.register_lints.rs             |  2 +-
 clippy_lints/src/lib.rs                            |  2 -
 clippy_lints/src/methods/mod.rs                    | 29 ++++++++++
 .../src/methods/needless_option_as_deref.rs        | 37 ++++++++++++
 clippy_lints/src/needless_option_as_deref.rs       | 65 ----------------------
 tests/ui/needless_option_as_deref.fixed            | 30 +++++++++-
 tests/ui/needless_option_as_deref.rs               | 30 +++++++++-
 tests/ui/needless_option_as_deref.stderr           | 12 +++-
 10 files changed, 136 insertions(+), 75 deletions(-)
 create mode 100644 clippy_lints/src/methods/needless_option_as_deref.rs
 delete mode 100644 clippy_lints/src/needless_option_as_deref.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 1fb3ca1fd9b..341c7e397d3 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -176,6 +176,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(methods::MAP_COLLECT_RESULT_UNIT),
     LintId::of(methods::MAP_FLATTEN),
     LintId::of(methods::MAP_IDENTITY),
+    LintId::of(methods::NEEDLESS_OPTION_AS_DEREF),
     LintId::of(methods::NEEDLESS_SPLITN),
     LintId::of(methods::NEW_RET_NO_SELF),
     LintId::of(methods::OK_EXPECT),
@@ -225,7 +226,6 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(needless_bool::NEEDLESS_BOOL),
     LintId::of(needless_borrowed_ref::NEEDLESS_BORROWED_REFERENCE),
     LintId::of(needless_late_init::NEEDLESS_LATE_INIT),
-    LintId::of(needless_option_as_deref::NEEDLESS_OPTION_AS_DEREF),
     LintId::of(needless_question_mark::NEEDLESS_QUESTION_MARK),
     LintId::of(needless_update::NEEDLESS_UPDATE),
     LintId::of(neg_cmp_op_on_partial_ord::NEG_CMP_OP_ON_PARTIAL_ORD),
diff --git a/clippy_lints/src/lib.register_complexity.rs b/clippy_lints/src/lib.register_complexity.rs
index a2ce69065f9..10369a855ae 100644
--- a/clippy_lints/src/lib.register_complexity.rs
+++ b/clippy_lints/src/lib.register_complexity.rs
@@ -44,6 +44,7 @@ store.register_group(true, "clippy::complexity", Some("clippy_complexity"), vec!
     LintId::of(methods::MANUAL_SPLIT_ONCE),
     LintId::of(methods::MAP_FLATTEN),
     LintId::of(methods::MAP_IDENTITY),
+    LintId::of(methods::NEEDLESS_OPTION_AS_DEREF),
     LintId::of(methods::NEEDLESS_SPLITN),
     LintId::of(methods::OPTION_AS_REF_DEREF),
     LintId::of(methods::OPTION_FILTER_MAP),
@@ -60,7 +61,6 @@ store.register_group(true, "clippy::complexity", Some("clippy_complexity"), vec!
     LintId::of(needless_bool::BOOL_COMPARISON),
     LintId::of(needless_bool::NEEDLESS_BOOL),
     LintId::of(needless_borrowed_ref::NEEDLESS_BORROWED_REFERENCE),
-    LintId::of(needless_option_as_deref::NEEDLESS_OPTION_AS_DEREF),
     LintId::of(needless_question_mark::NEEDLESS_QUESTION_MARK),
     LintId::of(needless_update::NEEDLESS_UPDATE),
     LintId::of(neg_cmp_op_on_partial_ord::NEG_CMP_OP_ON_PARTIAL_ORD),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index bba3cae45f5..e5f5c6cd31c 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -315,6 +315,7 @@ store.register_lints(&[
     methods::MAP_FLATTEN,
     methods::MAP_IDENTITY,
     methods::MAP_UNWRAP_OR,
+    methods::NEEDLESS_OPTION_AS_DEREF,
     methods::NEEDLESS_SPLITN,
     methods::NEW_RET_NO_SELF,
     methods::OK_EXPECT,
@@ -386,7 +387,6 @@ store.register_lints(&[
     needless_continue::NEEDLESS_CONTINUE,
     needless_for_each::NEEDLESS_FOR_EACH,
     needless_late_init::NEEDLESS_LATE_INIT,
-    needless_option_as_deref::NEEDLESS_OPTION_AS_DEREF,
     needless_pass_by_value::NEEDLESS_PASS_BY_VALUE,
     needless_question_mark::NEEDLESS_QUESTION_MARK,
     needless_update::NEEDLESS_UPDATE,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 8dab039f24f..a9a77f5ae04 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -308,7 +308,6 @@ mod needless_borrowed_ref;
 mod needless_continue;
 mod needless_for_each;
 mod needless_late_init;
-mod needless_option_as_deref;
 mod needless_pass_by_value;
 mod needless_question_mark;
 mod needless_update;
@@ -536,7 +535,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(ptr::Ptr));
     store.register_late_pass(|| Box::new(ptr_eq::PtrEq));
     store.register_late_pass(|| Box::new(needless_bool::NeedlessBool));
-    store.register_late_pass(|| Box::new(needless_option_as_deref::OptionNeedlessDeref));
     store.register_late_pass(|| Box::new(needless_bool::BoolComparison));
     store.register_late_pass(|| Box::new(needless_for_each::NeedlessForEach));
     store.register_late_pass(|| Box::new(misc::MiscLints));
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index c5c871c9d29..4a2bcca13b4 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -41,6 +41,7 @@ mod map_collect_result_unit;
 mod map_flatten;
 mod map_identity;
 mod map_unwrap_or;
+mod needless_option_as_deref;
 mod ok_expect;
 mod option_as_ref_deref;
 mod option_map_or_none;
@@ -2106,6 +2107,30 @@ declare_clippy_lint! {
     "using `.collect::<Vec<String>>().join(\"\")` on an iterator"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for no-op uses of `Option::{as_deref, as_deref_mut}`,
+    /// for example, `Option<&T>::as_deref()` returns the same type.
+    ///
+    /// ### Why is this bad?
+    /// Redundant code and improving readability.
+    ///
+    /// ### Example
+    /// ```rust
+    /// let a = Some(&1);
+    /// let b = a.as_deref(); // goes from Option<&i32> to Option<&i32>
+    /// ```
+    /// Could be written as:
+    /// ```rust
+    /// let a = Some(&1);
+    /// let b = a;
+    /// ```
+    #[clippy::version = "1.57.0"]
+    pub NEEDLESS_OPTION_AS_DEREF,
+    complexity,
+    "no-op use of `deref` or `deref_mut` method to `Option`."
+}
+
 pub struct Methods {
     avoid_breaking_exported_api: bool,
     msrv: Option<RustcVersion>,
@@ -2193,6 +2218,7 @@ impl_lint_pass!(Methods => [
     UNNECESSARY_TO_OWNED,
     UNNECESSARY_JOIN,
     ERR_EXPECT,
+    NEEDLESS_OPTION_AS_DEREF,
 ]);
 
 /// Extracts a method call name, args, and `Span` of the method name.
@@ -2425,6 +2451,9 @@ fn check_methods<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, msrv: Optio
                     unnecessary_lazy_eval::check(cx, expr, recv, arg, "and");
                 }
             },
+            ("as_deref" | "as_deref_mut", []) => {
+                needless_option_as_deref::check(cx, expr, recv, name);
+            },
             ("as_mut", []) => useless_asref::check(cx, expr, "as_mut", recv),
             ("as_ref", []) => useless_asref::check(cx, expr, "as_ref", recv),
             ("assume_init", []) => uninit_assumed_init::check(cx, expr, recv),
diff --git a/clippy_lints/src/methods/needless_option_as_deref.rs b/clippy_lints/src/methods/needless_option_as_deref.rs
new file mode 100644
index 00000000000..7030baf19ff
--- /dev/null
+++ b/clippy_lints/src/methods/needless_option_as_deref.rs
@@ -0,0 +1,37 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::path_res;
+use clippy_utils::source::snippet_opt;
+use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::usage::local_used_after_expr;
+use rustc_errors::Applicability;
+use rustc_hir::def::Res;
+use rustc_hir::Expr;
+use rustc_lint::LateContext;
+use rustc_span::sym;
+
+use super::NEEDLESS_OPTION_AS_DEREF;
+
+pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'_>, name: &str) {
+    let typeck = cx.typeck_results();
+    let outer_ty = typeck.expr_ty(expr);
+
+    if is_type_diagnostic_item(cx, outer_ty, sym::Option) && outer_ty == typeck.expr_ty(recv) {
+        if name == "as_deref_mut" && recv.is_syntactic_place_expr() {
+            let Res::Local(binding_id) = path_res(cx, recv) else { return };
+
+            if local_used_after_expr(cx, binding_id, recv) {
+                return;
+            }
+        }
+
+        span_lint_and_sugg(
+            cx,
+            NEEDLESS_OPTION_AS_DEREF,
+            expr.span,
+            "derefed type is same as origin",
+            "try this",
+            snippet_opt(cx, recv.span).unwrap(),
+            Applicability::MachineApplicable,
+        );
+    }
+}
diff --git a/clippy_lints/src/needless_option_as_deref.rs b/clippy_lints/src/needless_option_as_deref.rs
deleted file mode 100644
index 9d3d7d1f24c..00000000000
--- a/clippy_lints/src/needless_option_as_deref.rs
+++ /dev/null
@@ -1,65 +0,0 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::source::snippet_opt;
-use clippy_utils::ty::is_type_diagnostic_item;
-use rustc_errors::Applicability;
-use rustc_hir::{Expr, ExprKind};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::symbol::sym;
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for no-op uses of Option::{as_deref,as_deref_mut},
-    /// for example, `Option<&T>::as_deref()` returns the same type.
-    ///
-    /// ### Why is this bad?
-    /// Redundant code and improving readability.
-    ///
-    /// ### Example
-    /// ```rust
-    /// let a = Some(&1);
-    /// let b = a.as_deref(); // goes from Option<&i32> to Option<&i32>
-    /// ```
-    /// Could be written as:
-    /// ```rust
-    /// let a = Some(&1);
-    /// let b = a;
-    /// ```
-    #[clippy::version = "1.57.0"]
-    pub NEEDLESS_OPTION_AS_DEREF,
-    complexity,
-    "no-op use of `deref` or `deref_mut` method to `Option`."
-}
-
-declare_lint_pass!(OptionNeedlessDeref=> [
-    NEEDLESS_OPTION_AS_DEREF,
-]);
-
-impl<'tcx> LateLintPass<'tcx> for OptionNeedlessDeref {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if expr.span.from_expansion() {
-            return;
-        }
-        let typeck = cx.typeck_results();
-        let outer_ty = typeck.expr_ty(expr);
-
-        if_chain! {
-            if is_type_diagnostic_item(cx,outer_ty,sym::Option);
-            if let ExprKind::MethodCall(path, [sub_expr], _) = expr.kind;
-            let symbol = path.ident.as_str();
-            if symbol == "as_deref" || symbol == "as_deref_mut";
-            if outer_ty == typeck.expr_ty(sub_expr);
-            then{
-                span_lint_and_sugg(
-                    cx,
-                    NEEDLESS_OPTION_AS_DEREF,
-                    expr.span,
-                    "derefed type is same as origin",
-                    "try this",
-                    snippet_opt(cx,sub_expr.span).unwrap(),
-                    Applicability::MachineApplicable
-                );
-            }
-        }
-    }
-}
diff --git a/tests/ui/needless_option_as_deref.fixed b/tests/ui/needless_option_as_deref.fixed
index d721452ae88..c09b07db3dc 100644
--- a/tests/ui/needless_option_as_deref.fixed
+++ b/tests/ui/needless_option_as_deref.fixed
@@ -1,13 +1,41 @@
 // run-rustfix
 
-#[warn(clippy::needless_option_as_deref)]
+#![allow(unused)]
+#![warn(clippy::needless_option_as_deref)]
 
 fn main() {
     // should lint
     let _: Option<&usize> = Some(&1);
     let _: Option<&mut usize> = Some(&mut 1);
 
+    let mut y = 0;
+    let mut x = Some(&mut y);
+    let _ = x;
+
     // should not lint
     let _ = Some(Box::new(1)).as_deref();
     let _ = Some(Box::new(1)).as_deref_mut();
+
+    // #7846
+    let mut i = 0;
+    let mut opt_vec = vec![Some(&mut i)];
+    opt_vec[0].as_deref_mut().unwrap();
+
+    let mut i = 0;
+    let x = &mut Some(&mut i);
+    (*x).as_deref_mut();
+
+    // #8047
+    let mut y = 0;
+    let mut x = Some(&mut y);
+    x.as_deref_mut();
+    dbg!(x);
+}
+
+struct S<'a> {
+    opt: Option<&'a mut usize>,
+}
+
+fn from_field<'a>(s: &'a mut S<'a>) -> Option<&'a mut usize> {
+    s.opt.as_deref_mut()
 }
diff --git a/tests/ui/needless_option_as_deref.rs b/tests/ui/needless_option_as_deref.rs
index bb15512adf6..c3ba27ecccf 100644
--- a/tests/ui/needless_option_as_deref.rs
+++ b/tests/ui/needless_option_as_deref.rs
@@ -1,13 +1,41 @@
 // run-rustfix
 
-#[warn(clippy::needless_option_as_deref)]
+#![allow(unused)]
+#![warn(clippy::needless_option_as_deref)]
 
 fn main() {
     // should lint
     let _: Option<&usize> = Some(&1).as_deref();
     let _: Option<&mut usize> = Some(&mut 1).as_deref_mut();
 
+    let mut y = 0;
+    let mut x = Some(&mut y);
+    let _ = x.as_deref_mut();
+
     // should not lint
     let _ = Some(Box::new(1)).as_deref();
     let _ = Some(Box::new(1)).as_deref_mut();
+
+    // #7846
+    let mut i = 0;
+    let mut opt_vec = vec![Some(&mut i)];
+    opt_vec[0].as_deref_mut().unwrap();
+
+    let mut i = 0;
+    let x = &mut Some(&mut i);
+    (*x).as_deref_mut();
+
+    // #8047
+    let mut y = 0;
+    let mut x = Some(&mut y);
+    x.as_deref_mut();
+    dbg!(x);
+}
+
+struct S<'a> {
+    opt: Option<&'a mut usize>,
+}
+
+fn from_field<'a>(s: &'a mut S<'a>) -> Option<&'a mut usize> {
+    s.opt.as_deref_mut()
 }
diff --git a/tests/ui/needless_option_as_deref.stderr b/tests/ui/needless_option_as_deref.stderr
index 5dd507b4a71..bc07db5b38e 100644
--- a/tests/ui/needless_option_as_deref.stderr
+++ b/tests/ui/needless_option_as_deref.stderr
@@ -1,5 +1,5 @@
 error: derefed type is same as origin
-  --> $DIR/needless_option_as_deref.rs:7:29
+  --> $DIR/needless_option_as_deref.rs:8:29
    |
 LL |     let _: Option<&usize> = Some(&1).as_deref();
    |                             ^^^^^^^^^^^^^^^^^^^ help: try this: `Some(&1)`
@@ -7,10 +7,16 @@ LL |     let _: Option<&usize> = Some(&1).as_deref();
    = note: `-D clippy::needless-option-as-deref` implied by `-D warnings`
 
 error: derefed type is same as origin
-  --> $DIR/needless_option_as_deref.rs:8:33
+  --> $DIR/needless_option_as_deref.rs:9:33
    |
 LL |     let _: Option<&mut usize> = Some(&mut 1).as_deref_mut();
    |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `Some(&mut 1)`
 
-error: aborting due to 2 previous errors
+error: derefed type is same as origin
+  --> $DIR/needless_option_as_deref.rs:13:13
+   |
+LL |     let _ = x.as_deref_mut();
+   |             ^^^^^^^^^^^^^^^^ help: try this: `x`
+
+error: aborting due to 3 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From db1d5dca5071104cbea2f23f5ec133d7bce66c15 Mon Sep 17 00:00:00 2001
From: flip1995 <philipp.krones@embecosm.com>
Date: Thu, 7 Apr 2022 16:24:10 +0100
Subject: Fix internal::INVALID_PATHS lint

---
 clippy_lints/src/utils/internal_lints.rs | 13 +++++++++++--
 1 file changed, 11 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs
index e995dbd76ff..25d74b8c499 100644
--- a/clippy_lints/src/utils/internal_lints.rs
+++ b/clippy_lints/src/utils/internal_lints.rs
@@ -25,7 +25,7 @@ use rustc_hir::{
 use rustc_lint::{EarlyContext, EarlyLintPass, LateContext, LateLintPass, LintContext};
 use rustc_middle::hir::nested_filter;
 use rustc_middle::mir::interpret::ConstValue;
-use rustc_middle::ty::{self, subst::GenericArgKind};
+use rustc_middle::ty::{self, fast_reject::SimplifiedTypeGen, subst::GenericArgKind, FloatTy};
 use rustc_semver::RustcVersion;
 use rustc_session::{declare_lint_pass, declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::Spanned;
@@ -934,7 +934,16 @@ pub fn check_path(cx: &LateContext<'_>, path: &[&str]) -> bool {
     // implementations of native types. Check lang items.
     let path_syms: Vec<_> = path.iter().map(|p| Symbol::intern(p)).collect();
     let lang_items = cx.tcx.lang_items();
-    for item_def_id in lang_items.items().iter().flatten() {
+    // This list isn't complete, but good enough for our current list of paths.
+    let incoherent_impls = [
+        SimplifiedTypeGen::FloatSimplifiedType(FloatTy::F32),
+        SimplifiedTypeGen::FloatSimplifiedType(FloatTy::F64),
+        SimplifiedTypeGen::SliceSimplifiedType,
+        SimplifiedTypeGen::StrSimplifiedType,
+    ]
+    .iter()
+    .flat_map(|&ty| cx.tcx.incoherent_impls(ty));
+    for item_def_id in lang_items.items().iter().flatten().chain(incoherent_impls) {
         let lang_item_path = cx.get_def_path(*item_def_id);
         if path_syms.starts_with(&lang_item_path) {
             if let [item] = &path_syms[lang_item_path.len()..] {
-- 
cgit 1.4.1-3-g733a5


From 6ab4508350add2549b2f4b7b052057992a804128 Mon Sep 17 00:00:00 2001
From: flip1995 <philipp.krones@embecosm.com>
Date: Thu, 7 Apr 2022 18:05:20 +0100
Subject: Allow raw lint descriptions

update_lints now understands raw strings in declare_clippy_lint
descriptions.

Co-authored-by: Alex Macleod <alex@macleod.io>
---
 CHANGELOG.md                           | 1 +
 clippy_dev/src/update_lints.rs         | 5 ++++-
 clippy_lints/src/lib.register_all.rs   | 1 +
 clippy_lints/src/lib.register_lints.rs | 1 +
 clippy_lints/src/lib.register_style.rs | 1 +
 5 files changed, 8 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 918f0b48e50..b4097ea86a5 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3272,6 +3272,7 @@ Released 2018-09-13
 [`eq_op`]: https://rust-lang.github.io/rust-clippy/master/index.html#eq_op
 [`equatable_if_let`]: https://rust-lang.github.io/rust-clippy/master/index.html#equatable_if_let
 [`erasing_op`]: https://rust-lang.github.io/rust-clippy/master/index.html#erasing_op
+[`err_expect`]: https://rust-lang.github.io/rust-clippy/master/index.html#err_expect
 [`eval_order_dependence`]: https://rust-lang.github.io/rust-clippy/master/index.html#eval_order_dependence
 [`excessive_precision`]: https://rust-lang.github.io/rust-clippy/master/index.html#excessive_precision
 [`exhaustive_enums`]: https://rust-lang.github.io/rust-clippy/master/index.html#exhaustive_enums
diff --git a/clippy_dev/src/update_lints.rs b/clippy_dev/src/update_lints.rs
index 4e48b670457..59db51fbfac 100644
--- a/clippy_dev/src/update_lints.rs
+++ b/clippy_dev/src/update_lints.rs
@@ -359,7 +359,7 @@ fn parse_contents(contents: &str, module: &str, lints: &mut Vec<Lint>) {
             // group,
             Ident(group) Comma
             // "description" }
-            Literal{kind: LiteralKind::Str{..}, ..}(desc) CloseBrace
+            Literal{..}(desc) CloseBrace
         );
         lints.push(Lint::new(name, group, desc, module));
     }
@@ -397,6 +397,9 @@ fn parse_deprecated_contents(contents: &str, lints: &mut Vec<DeprecatedLint>) {
 /// Removes the line splices and surrounding quotes from a string literal
 fn remove_line_splices(s: &str) -> String {
     let s = s
+        .strip_prefix('r')
+        .unwrap_or(s)
+        .trim_matches('#')
         .strip_prefix('"')
         .and_then(|s| s.strip_suffix('"'))
         .unwrap_or_else(|| panic!("expected quoted string, found `{}`", s));
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index c95b791f43e..14ca93b5f3c 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -157,6 +157,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(methods::CHARS_NEXT_CMP),
     LintId::of(methods::CLONE_DOUBLE_REF),
     LintId::of(methods::CLONE_ON_COPY),
+    LintId::of(methods::ERR_EXPECT),
     LintId::of(methods::EXPECT_FUN_CALL),
     LintId::of(methods::EXTEND_WITH_DRAIN),
     LintId::of(methods::FILTER_MAP_IDENTITY),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 1c4ccc15e83..532590aaa5a 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -286,6 +286,7 @@ store.register_lints(&[
     methods::CLONE_DOUBLE_REF,
     methods::CLONE_ON_COPY,
     methods::CLONE_ON_REF_PTR,
+    methods::ERR_EXPECT,
     methods::EXPECT_FUN_CALL,
     methods::EXPECT_USED,
     methods::EXTEND_WITH_DRAIN,
diff --git a/clippy_lints/src/lib.register_style.rs b/clippy_lints/src/lib.register_style.rs
index dcf399cf956..3114afac886 100644
--- a/clippy_lints/src/lib.register_style.rs
+++ b/clippy_lints/src/lib.register_style.rs
@@ -59,6 +59,7 @@ store.register_group(true, "clippy::style", Some("clippy_style"), vec![
     LintId::of(methods::BYTES_NTH),
     LintId::of(methods::CHARS_LAST_CMP),
     LintId::of(methods::CHARS_NEXT_CMP),
+    LintId::of(methods::ERR_EXPECT),
     LintId::of(methods::INTO_ITER_ON_REF),
     LintId::of(methods::ITER_CLONED_COLLECT),
     LintId::of(methods::ITER_NEXT_SLICE),
-- 
cgit 1.4.1-3-g733a5


From 06cfeb90c156d70c2318774081b37db809f6d840 Mon Sep 17 00:00:00 2001
From: Peter Jaszkowiak <p.jaszkow@gmail.com>
Date: Sat, 2 Apr 2022 15:01:07 -0600
Subject: New lint `is_digit_ascii_radix`

---
 CHANGELOG.md                                       |  1 +
 .../case_sensitive_file_extension_comparisons.rs   |  4 +-
 clippy_lints/src/doc.rs                            |  2 +-
 clippy_lints/src/lib.register_all.rs               |  1 +
 clippy_lints/src/lib.register_lints.rs             |  1 +
 clippy_lints/src/lib.register_style.rs             |  1 +
 clippy_lints/src/methods/is_digit_ascii_radix.rs   | 50 ++++++++++++++++++++++
 clippy_lints/src/methods/mod.rs                    | 33 ++++++++++++++
 clippy_lints/src/misc_early/mod.rs                 |  2 +-
 clippy_lints/src/non_expressive_names.rs           |  2 +-
 clippy_utils/src/msrvs.rs                          |  1 +
 clippy_utils/src/numeric_literal.rs                |  2 +-
 tests/ui/is_digit_ascii_radix.fixed                | 18 ++++++++
 tests/ui/is_digit_ascii_radix.rs                   | 18 ++++++++
 tests/ui/is_digit_ascii_radix.stderr               | 22 ++++++++++
 tests/ui/to_digit_is_some.fixed                    |  4 +-
 tests/ui/to_digit_is_some.rs                       |  4 +-
 tests/ui/to_digit_is_some.stderr                   |  8 ++--
 18 files changed, 160 insertions(+), 14 deletions(-)
 create mode 100644 clippy_lints/src/methods/is_digit_ascii_radix.rs
 create mode 100644 tests/ui/is_digit_ascii_radix.fixed
 create mode 100644 tests/ui/is_digit_ascii_radix.rs
 create mode 100644 tests/ui/is_digit_ascii_radix.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index b4097ea86a5..c5c93b11327 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3356,6 +3356,7 @@ Released 2018-09-13
 [`invalid_regex`]: https://rust-lang.github.io/rust-clippy/master/index.html#invalid_regex
 [`invalid_upcast_comparisons`]: https://rust-lang.github.io/rust-clippy/master/index.html#invalid_upcast_comparisons
 [`invisible_characters`]: https://rust-lang.github.io/rust-clippy/master/index.html#invisible_characters
+[`is_digit_ascii_radix`]: https://rust-lang.github.io/rust-clippy/master/index.html#is_digit_ascii_radix
 [`items_after_statements`]: https://rust-lang.github.io/rust-clippy/master/index.html#items_after_statements
 [`iter_cloned_collect`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_cloned_collect
 [`iter_count`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_count
diff --git a/clippy_lints/src/case_sensitive_file_extension_comparisons.rs b/clippy_lints/src/case_sensitive_file_extension_comparisons.rs
index df780747a0c..e3e31c5863e 100644
--- a/clippy_lints/src/case_sensitive_file_extension_comparisons.rs
+++ b/clippy_lints/src/case_sensitive_file_extension_comparisons.rs
@@ -43,8 +43,8 @@ fn check_case_sensitive_file_extension_comparison(ctx: &LateContext<'_>, expr: &
         if let ExprKind::Lit(Spanned { node: LitKind::Str(ext_literal, ..), ..}) = extension.kind;
         if (2..=6).contains(&ext_literal.as_str().len());
         if ext_literal.as_str().starts_with('.');
-        if ext_literal.as_str().chars().skip(1).all(|c| c.is_uppercase() || c.is_digit(10))
-            || ext_literal.as_str().chars().skip(1).all(|c| c.is_lowercase() || c.is_digit(10));
+        if ext_literal.as_str().chars().skip(1).all(|c| c.is_uppercase() || c.is_ascii_digit())
+            || ext_literal.as_str().chars().skip(1).all(|c| c.is_lowercase() || c.is_ascii_digit());
         then {
             let mut ty = ctx.typeck_results().expr_ty(obj);
             ty = match ty.kind() {
diff --git a/clippy_lints/src/doc.rs b/clippy_lints/src/doc.rs
index 28d0c75fde6..e72031e4877 100644
--- a/clippy_lints/src/doc.rs
+++ b/clippy_lints/src/doc.rs
@@ -739,7 +739,7 @@ fn check_word(cx: &LateContext<'_>, word: &str, span: Span) {
     /// letters (`Clippy` is ok) and one lower-case letter (`NASA` is ok).
     /// Plurals are also excluded (`IDs` is ok).
     fn is_camel_case(s: &str) -> bool {
-        if s.starts_with(|c: char| c.is_digit(10)) {
+        if s.starts_with(|c: char| c.is_ascii_digit()) {
             return false;
         }
 
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 14ca93b5f3c..aa8e3b535b1 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -165,6 +165,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(methods::FLAT_MAP_IDENTITY),
     LintId::of(methods::INSPECT_FOR_EACH),
     LintId::of(methods::INTO_ITER_ON_REF),
+    LintId::of(methods::IS_DIGIT_ASCII_RADIX),
     LintId::of(methods::ITERATOR_STEP_BY_ZERO),
     LintId::of(methods::ITER_CLONED_COLLECT),
     LintId::of(methods::ITER_COUNT),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 532590aaa5a..7436f31125b 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -302,6 +302,7 @@ store.register_lints(&[
     methods::INEFFICIENT_TO_STRING,
     methods::INSPECT_FOR_EACH,
     methods::INTO_ITER_ON_REF,
+    methods::IS_DIGIT_ASCII_RADIX,
     methods::ITERATOR_STEP_BY_ZERO,
     methods::ITER_CLONED_COLLECT,
     methods::ITER_COUNT,
diff --git a/clippy_lints/src/lib.register_style.rs b/clippy_lints/src/lib.register_style.rs
index 3114afac886..2d98802cb14 100644
--- a/clippy_lints/src/lib.register_style.rs
+++ b/clippy_lints/src/lib.register_style.rs
@@ -61,6 +61,7 @@ store.register_group(true, "clippy::style", Some("clippy_style"), vec![
     LintId::of(methods::CHARS_NEXT_CMP),
     LintId::of(methods::ERR_EXPECT),
     LintId::of(methods::INTO_ITER_ON_REF),
+    LintId::of(methods::IS_DIGIT_ASCII_RADIX),
     LintId::of(methods::ITER_CLONED_COLLECT),
     LintId::of(methods::ITER_NEXT_SLICE),
     LintId::of(methods::ITER_NTH_ZERO),
diff --git a/clippy_lints/src/methods/is_digit_ascii_radix.rs b/clippy_lints/src/methods/is_digit_ascii_radix.rs
new file mode 100644
index 00000000000..ad333df2f2d
--- /dev/null
+++ b/clippy_lints/src/methods/is_digit_ascii_radix.rs
@@ -0,0 +1,50 @@
+//! Lint for `c.is_digit(10)`
+
+use super::IS_DIGIT_ASCII_RADIX;
+use clippy_utils::{
+    consts::constant_full_int, consts::FullInt, diagnostics::span_lint_and_sugg, meets_msrv, msrvs,
+    source::snippet_with_applicability,
+};
+use rustc_errors::Applicability;
+use rustc_hir::Expr;
+use rustc_lint::LateContext;
+use rustc_semver::RustcVersion;
+
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx Expr<'_>,
+    self_arg: &'tcx Expr<'_>,
+    radix: &'tcx Expr<'_>,
+    msrv: Option<&RustcVersion>,
+) {
+    if !meets_msrv(msrv, &msrvs::IS_ASCII_DIGIT) {
+        return;
+    }
+
+    if !cx.typeck_results().expr_ty_adjusted(self_arg).peel_refs().is_char() {
+        return;
+    }
+
+    if let Some(radix_val) = constant_full_int(cx, cx.typeck_results(), radix) {
+        let (num, replacement) = match radix_val {
+            FullInt::S(10) | FullInt::U(10) => (10, "is_ascii_digit"),
+            FullInt::S(16) | FullInt::U(16) => (16, "is_ascii_hexdigit"),
+            _ => return,
+        };
+        let mut applicability = Applicability::MachineApplicable;
+
+        span_lint_and_sugg(
+            cx,
+            IS_DIGIT_ASCII_RADIX,
+            expr.span,
+            &format!("use of `char::is_digit` with literal radix of {}", num),
+            "try",
+            format!(
+                "{}.{}()",
+                snippet_with_applicability(cx, self_arg.span, "..", &mut applicability),
+                replacement
+            ),
+            applicability,
+        );
+    }
+}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 70d021a1668..6a7841a90df 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -26,6 +26,7 @@ mod implicit_clone;
 mod inefficient_to_string;
 mod inspect_for_each;
 mod into_iter_on_ref;
+mod is_digit_ascii_radix;
 mod iter_cloned_collect;
 mod iter_count;
 mod iter_next_slice;
@@ -2131,6 +2132,36 @@ declare_clippy_lint! {
     "no-op use of `deref` or `deref_mut` method to `Option`."
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Finds usages of [`char::is_digit`]
+    /// (https://doc.rust-lang.org/stable/std/primitive.char.html#method.is_digit) that
+    /// can be replaced with [`is_ascii_digit`]
+    /// (https://doc.rust-lang.org/stable/std/primitive.char.html#method.is_ascii_digit) or
+    /// [`is_ascii_hexdigit`]
+    /// (https://doc.rust-lang.org/stable/std/primitive.char.html#method.is_ascii_hexdigit).
+    ///
+    /// ### Why is this bad?
+    /// `is_digit(..)` is slower and requires specifying the radix.
+    ///
+    /// ### Example
+    /// ```rust
+    /// let c: char = '6';
+    /// c.is_digit(10);
+    /// c.is_digit(16);
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// let c: char = '6';
+    /// c.is_ascii_digit();
+    /// c.is_ascii_hexdigit();
+    /// ```
+    #[clippy::version = "1.61.0"]
+    pub IS_DIGIT_ASCII_RADIX,
+    style,
+    "use of `char::is_digit(..)` with literal radix of 10 or 16"
+}
+
 pub struct Methods {
     avoid_breaking_exported_api: bool,
     msrv: Option<RustcVersion>,
@@ -2219,6 +2250,7 @@ impl_lint_pass!(Methods => [
     UNNECESSARY_JOIN,
     ERR_EXPECT,
     NEEDLESS_OPTION_AS_DEREF,
+    IS_DIGIT_ASCII_RADIX,
 ]);
 
 /// Extracts a method call name, args, and `Span` of the method name.
@@ -2516,6 +2548,7 @@ fn check_methods<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, msrv: Optio
             },
             ("get_or_insert_with", [arg]) => unnecessary_lazy_eval::check(cx, expr, recv, arg, "get_or_insert"),
             ("is_file", []) => filetype_is_file::check(cx, expr, recv),
+            ("is_digit", [radix]) => is_digit_ascii_radix::check(cx, expr, recv, radix, msrv),
             ("is_none", []) => check_is_some_is_none(cx, expr, recv, false),
             ("is_some", []) => check_is_some_is_none(cx, expr, recv, true),
             ("join", [join_arg]) => {
diff --git a/clippy_lints/src/misc_early/mod.rs b/clippy_lints/src/misc_early/mod.rs
index d955fad7d41..6860b60acbd 100644
--- a/clippy_lints/src/misc_early/mod.rs
+++ b/clippy_lints/src/misc_early/mod.rs
@@ -361,7 +361,7 @@ impl MiscEarlyLints {
         // See <https://github.com/rust-lang/rust-clippy/issues/4507> for a regression.
         // FIXME: Find a better way to detect those cases.
         let lit_snip = match snippet_opt(cx, lit.span) {
-            Some(snip) if snip.chars().next().map_or(false, |c| c.is_digit(10)) => snip,
+            Some(snip) if snip.chars().next().map_or(false, |c| c.is_ascii_digit()) => snip,
             _ => return,
         };
 
diff --git a/clippy_lints/src/non_expressive_names.rs b/clippy_lints/src/non_expressive_names.rs
index 0d0c88b02c7..e3bc40c4b49 100644
--- a/clippy_lints/src/non_expressive_names.rs
+++ b/clippy_lints/src/non_expressive_names.rs
@@ -197,7 +197,7 @@ impl<'a, 'tcx, 'b> SimilarNamesNameVisitor<'a, 'tcx, 'b> {
         if interned_name.chars().any(char::is_uppercase) {
             return;
         }
-        if interned_name.chars().all(|c| c.is_digit(10) || c == '_') {
+        if interned_name.chars().all(|c| c.is_ascii_digit() || c == '_') {
             span_lint(
                 self.0.cx,
                 JUST_UNDERSCORES_AND_DIGITS,
diff --git a/clippy_utils/src/msrvs.rs b/clippy_utils/src/msrvs.rs
index 0424e067202..134fd1ce505 100644
--- a/clippy_utils/src/msrvs.rs
+++ b/clippy_utils/src/msrvs.rs
@@ -32,4 +32,5 @@ msrv_aliases! {
     1,28,0 { FROM_BOOL }
     1,17,0 { FIELD_INIT_SHORTHAND, STATIC_IN_CONST, EXPECT_ERR }
     1,16,0 { STR_REPEAT }
+    1,24,0 { IS_ASCII_DIGIT }
 }
diff --git a/clippy_utils/src/numeric_literal.rs b/clippy_utils/src/numeric_literal.rs
index 908ff822712..b92d42e8323 100644
--- a/clippy_utils/src/numeric_literal.rs
+++ b/clippy_utils/src/numeric_literal.rs
@@ -57,7 +57,7 @@ impl<'a> NumericLiteral<'a> {
                 .trim_start()
                 .chars()
                 .next()
-                .map_or(false, |c| c.is_digit(10))
+                .map_or(false, |c| c.is_ascii_digit())
         {
             let (unsuffixed, suffix) = split_suffix(src, lit_kind);
             let float = matches!(lit_kind, LitKind::Float(..));
diff --git a/tests/ui/is_digit_ascii_radix.fixed b/tests/ui/is_digit_ascii_radix.fixed
new file mode 100644
index 00000000000..c0ba647d707
--- /dev/null
+++ b/tests/ui/is_digit_ascii_radix.fixed
@@ -0,0 +1,18 @@
+// run-rustfix
+
+#![warn(clippy::is_digit_ascii_radix)]
+
+const TEN: u32 = 10;
+
+fn main() {
+    let c: char = '6';
+
+    // Should trigger the lint.
+    let _ = c.is_ascii_digit();
+    let _ = c.is_ascii_hexdigit();
+    let _ = c.is_ascii_hexdigit();
+
+    // Should not trigger the lint.
+    let _ = c.is_digit(11);
+    let _ = c.is_digit(TEN);
+}
diff --git a/tests/ui/is_digit_ascii_radix.rs b/tests/ui/is_digit_ascii_radix.rs
new file mode 100644
index 00000000000..68e3f3243d9
--- /dev/null
+++ b/tests/ui/is_digit_ascii_radix.rs
@@ -0,0 +1,18 @@
+// run-rustfix
+
+#![warn(clippy::is_digit_ascii_radix)]
+
+const TEN: u32 = 10;
+
+fn main() {
+    let c: char = '6';
+
+    // Should trigger the lint.
+    let _ = c.is_digit(10);
+    let _ = c.is_digit(16);
+    let _ = c.is_digit(0x10);
+
+    // Should not trigger the lint.
+    let _ = c.is_digit(11);
+    let _ = c.is_digit(TEN);
+}
diff --git a/tests/ui/is_digit_ascii_radix.stderr b/tests/ui/is_digit_ascii_radix.stderr
new file mode 100644
index 00000000000..dc5cb2913ae
--- /dev/null
+++ b/tests/ui/is_digit_ascii_radix.stderr
@@ -0,0 +1,22 @@
+error: use of `char::is_digit` with literal radix of 10
+  --> $DIR/is_digit_ascii_radix.rs:11:13
+   |
+LL |     let _ = c.is_digit(10);
+   |             ^^^^^^^^^^^^^^ help: try: `c.is_ascii_digit()`
+   |
+   = note: `-D clippy::is-digit-ascii-radix` implied by `-D warnings`
+
+error: use of `char::is_digit` with literal radix of 16
+  --> $DIR/is_digit_ascii_radix.rs:12:13
+   |
+LL |     let _ = c.is_digit(16);
+   |             ^^^^^^^^^^^^^^ help: try: `c.is_ascii_hexdigit()`
+
+error: use of `char::is_digit` with literal radix of 16
+  --> $DIR/is_digit_ascii_radix.rs:13:13
+   |
+LL |     let _ = c.is_digit(0x10);
+   |             ^^^^^^^^^^^^^^^^ help: try: `c.is_ascii_hexdigit()`
+
+error: aborting due to 3 previous errors
+
diff --git a/tests/ui/to_digit_is_some.fixed b/tests/ui/to_digit_is_some.fixed
index 19184df0bec..3c5e9642714 100644
--- a/tests/ui/to_digit_is_some.fixed
+++ b/tests/ui/to_digit_is_some.fixed
@@ -6,6 +6,6 @@ fn main() {
     let c = 'x';
     let d = &c;
 
-    let _ = d.is_digit(10);
-    let _ = char::is_digit(c, 10);
+    let _ = d.is_digit(8);
+    let _ = char::is_digit(c, 8);
 }
diff --git a/tests/ui/to_digit_is_some.rs b/tests/ui/to_digit_is_some.rs
index 45a6728ebf5..4f247c06cee 100644
--- a/tests/ui/to_digit_is_some.rs
+++ b/tests/ui/to_digit_is_some.rs
@@ -6,6 +6,6 @@ fn main() {
     let c = 'x';
     let d = &c;
 
-    let _ = d.to_digit(10).is_some();
-    let _ = char::to_digit(c, 10).is_some();
+    let _ = d.to_digit(8).is_some();
+    let _ = char::to_digit(c, 8).is_some();
 }
diff --git a/tests/ui/to_digit_is_some.stderr b/tests/ui/to_digit_is_some.stderr
index 177d3ccd3e2..10a1b393a39 100644
--- a/tests/ui/to_digit_is_some.stderr
+++ b/tests/ui/to_digit_is_some.stderr
@@ -1,16 +1,16 @@
 error: use of `.to_digit(..).is_some()`
   --> $DIR/to_digit_is_some.rs:9:13
    |
-LL |     let _ = d.to_digit(10).is_some();
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `d.is_digit(10)`
+LL |     let _ = d.to_digit(8).is_some();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `d.is_digit(8)`
    |
    = note: `-D clippy::to-digit-is-some` implied by `-D warnings`
 
 error: use of `.to_digit(..).is_some()`
   --> $DIR/to_digit_is_some.rs:10:13
    |
-LL |     let _ = char::to_digit(c, 10).is_some();
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `char::is_digit(c, 10)`
+LL |     let _ = char::to_digit(c, 8).is_some();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `char::is_digit(c, 8)`
 
 error: aborting due to 2 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 19054251d350ccc81d4fe803821a7695b4518094 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Fri, 8 Apr 2022 00:36:09 -0400
Subject: Update documentation for `mut_from_ref`

---
 clippy_lints/src/ptr.rs | 25 ++++++++++++++++---------
 1 file changed, 16 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs
index 4ecde8f4958..aa7222266eb 100644
--- a/clippy_lints/src/ptr.rs
+++ b/clippy_lints/src/ptr.rs
@@ -89,19 +89,26 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// This lint checks for functions that take immutable
-    /// references and return mutable ones.
+    /// This lint checks for functions that take immutable references and return
+    /// mutable ones. This will not trigger if no unsafe code exists as there
+    /// are multiple safe functions which will do this transformation
+    ///
+    /// To be on the conservative side, if there's at least one mutable
+    /// reference with the output lifetime, this lint will not trigger.
     ///
     /// ### Why is this bad?
-    /// This is trivially unsound, as one can create two
-    /// mutable references from the same (immutable!) source.
-    /// This [error](https://github.com/rust-lang/rust/issues/39465)
-    /// actually lead to an interim Rust release 1.15.1.
+    /// Creating a mutable reference which can be repeatably derived from an
+    /// immutable reference is unsound as it allows creating multiple live
+    /// mutable references to the same object.
+    ///
+    /// This [error](https://github.com/rust-lang/rust/issues/39465) actually
+    /// lead to an interim Rust release 1.15.1.
     ///
     /// ### Known problems
-    /// To be on the conservative side, if there's at least one
-    /// mutable reference with the output lifetime, this lint will not trigger.
-    /// In practice, this case is unlikely anyway.
+    /// This pattern is used by memory allocators to allow allocating multiple
+    /// objects while returning mutable references to each one. So long as
+    /// different mutable references are returned each time such a function may
+    /// be safe.
     ///
     /// ### Example
     /// ```ignore
-- 
cgit 1.4.1-3-g733a5


From 63f6a79bf87cd5960c069bb45c88646519d096f8 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Fri, 8 Apr 2022 16:51:40 -0400
Subject: Don't lint various match lints when expanded by a proc-macro

---
 clippy_lints/src/matches/mod.rs            |  5 ++++-
 clippy_utils/src/source.rs                 | 19 ++++++++++++++++++
 tests/ui/auxiliary/proc_macro_with_span.rs | 32 ++++++++++++++++++++++++++++++
 tests/ui/single_match_else.rs              | 18 +++++++++++++++--
 tests/ui/single_match_else.stderr          | 11 +++++-----
 5 files changed, 77 insertions(+), 8 deletions(-)
 create mode 100644 tests/ui/auxiliary/proc_macro_with_span.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/mod.rs b/clippy_lints/src/matches/mod.rs
index e93b494653f..854cf06ed81 100644
--- a/clippy_lints/src/matches/mod.rs
+++ b/clippy_lints/src/matches/mod.rs
@@ -1,4 +1,4 @@
-use clippy_utils::source::{snippet_opt, walk_span_to_context};
+use clippy_utils::source::{snippet_opt, span_starts_with, walk_span_to_context};
 use clippy_utils::{meets_msrv, msrvs};
 use rustc_hir::{Arm, Expr, ExprKind, Local, MatchSource, Pat};
 use rustc_lexer::{tokenize, TokenKind};
@@ -653,6 +653,9 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
         }
 
         if let ExprKind::Match(ex, arms, source) = expr.kind {
+            if !span_starts_with(cx, expr.span, "match") {
+                return;
+            }
             if !contains_cfg_arm(cx, expr, ex, arms) {
                 if source == MatchSource::Normal {
                     if !(meets_msrv(self.msrv.as_ref(), &msrvs::MATCHES_MACRO)
diff --git a/clippy_utils/src/source.rs b/clippy_utils/src/source.rs
index dbad607c58e..beed7326803 100644
--- a/clippy_utils/src/source.rs
+++ b/clippy_utils/src/source.rs
@@ -7,9 +7,28 @@ use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LintContext};
 use rustc_span::hygiene;
+use rustc_span::source_map::SourceMap;
 use rustc_span::{BytePos, Pos, Span, SyntaxContext};
 use std::borrow::Cow;
 
+/// Checks if the span starts with the given text. This will return false if the span crosses
+/// multiple files or if source is not available.
+///
+/// This is used to check for proc macros giving unhelpful spans to things.
+pub fn span_starts_with<T: LintContext>(cx: &T, span: Span, text: &str) -> bool {
+    fn helper(sm: &SourceMap, span: Span, text: &str) -> bool {
+        let pos = sm.lookup_byte_offset(span.lo());
+        let Some(ref src) = pos.sf.src else {
+            return false;
+        };
+        let end = span.hi() - pos.sf.start_pos;
+        src.get(pos.pos.0 as usize..end.0 as usize)
+            // Expression spans can include wrapping parenthesis. Remove them first.
+            .map_or(false, |s| s.trim_start_matches('(').starts_with(text))
+    }
+    helper(cx.sess().source_map(), span, text)
+}
+
 /// Like `snippet_block`, but add braces if the expr is not an `ExprKind::Block`.
 /// Also takes an `Option<String>` which can be put inside the braces.
 pub fn expr_block<'a, T: LintContext>(
diff --git a/tests/ui/auxiliary/proc_macro_with_span.rs b/tests/ui/auxiliary/proc_macro_with_span.rs
new file mode 100644
index 00000000000..8ea631f2bbd
--- /dev/null
+++ b/tests/ui/auxiliary/proc_macro_with_span.rs
@@ -0,0 +1,32 @@
+// compile-flags: --emit=link
+// no-prefer-dynamic
+
+#![crate_type = "proc-macro"]
+
+extern crate proc_macro;
+
+use proc_macro::{token_stream::IntoIter, Group, Span, TokenStream, TokenTree};
+
+#[proc_macro]
+pub fn with_span(input: TokenStream) -> TokenStream {
+    let mut iter = input.into_iter();
+    let span = iter.next().unwrap().span();
+    let mut res = TokenStream::new();
+    write_with_span(span, iter, &mut res);
+    res
+}
+
+fn write_with_span(s: Span, input: IntoIter, out: &mut TokenStream) {
+    for mut tt in input {
+        if let TokenTree::Group(g) = tt {
+            let mut stream = TokenStream::new();
+            write_with_span(s, g.stream().into_iter(), &mut stream);
+            let mut group = Group::new(g.delimiter(), stream);
+            group.set_span(s);
+            out.extend([TokenTree::Group(group)]);
+        } else {
+            tt.set_span(s);
+            out.extend([tt]);
+        }
+    }
+}
diff --git a/tests/ui/single_match_else.rs b/tests/ui/single_match_else.rs
index b624a41a29b..82387f3d80b 100644
--- a/tests/ui/single_match_else.rs
+++ b/tests/ui/single_match_else.rs
@@ -1,7 +1,12 @@
+// aux-build: proc_macro_with_span.rs
+
 #![warn(clippy::single_match_else)]
 #![allow(clippy::needless_return)]
 #![allow(clippy::no_effect)]
 
+extern crate proc_macro_with_span;
+use proc_macro_with_span::with_span;
+
 enum ExprNode {
     ExprAddrOf,
     Butterflies,
@@ -11,13 +16,22 @@ enum ExprNode {
 static NODE: ExprNode = ExprNode::Unicorns;
 
 fn unwrap_addr() -> Option<&'static ExprNode> {
-    match ExprNode::Butterflies {
+    let _ = match ExprNode::Butterflies {
         ExprNode::ExprAddrOf => Some(&NODE),
         _ => {
             let x = 5;
             None
         },
-    }
+    };
+
+    // Don't lint
+    with_span!(span match ExprNode::Butterflies {
+        ExprNode::ExprAddrOf => Some(&NODE),
+        _ => {
+            let x = 5;
+            None
+        },
+    })
 }
 
 macro_rules! unwrap_addr {
diff --git a/tests/ui/single_match_else.stderr b/tests/ui/single_match_else.stderr
index 21ea704b62a..7756c6f204e 100644
--- a/tests/ui/single_match_else.stderr
+++ b/tests/ui/single_match_else.stderr
@@ -1,22 +1,23 @@
 error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
-  --> $DIR/single_match_else.rs:14:5
+  --> $DIR/single_match_else.rs:19:13
    |
-LL | /     match ExprNode::Butterflies {
+LL |       let _ = match ExprNode::Butterflies {
+   |  _____________^
 LL | |         ExprNode::ExprAddrOf => Some(&NODE),
 LL | |         _ => {
 LL | |             let x = 5;
 LL | |             None
 LL | |         },
-LL | |     }
+LL | |     };
    | |_____^
    |
    = note: `-D clippy::single-match-else` implied by `-D warnings`
 help: try this
    |
-LL ~     if let ExprNode::ExprAddrOf = ExprNode::Butterflies { Some(&NODE) } else {
+LL ~     let _ = if let ExprNode::ExprAddrOf = ExprNode::Butterflies { Some(&NODE) } else {
 LL +         let x = 5;
 LL +         None
-LL +     }
+LL ~     };
    |
 
 error: aborting due to previous error
-- 
cgit 1.4.1-3-g733a5


From 744b0ff9035298a8f62accf7f48701fa56d2df49 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Fri, 8 Apr 2022 23:15:18 -0400
Subject: Don't lint `iter_with_drain` on references

---
 clippy_lints/src/methods/iter_with_drain.rs | 91 +++++++++++------------------
 tests/ui/iter_with_drain.fixed              |  9 +++
 tests/ui/iter_with_drain.rs                 |  9 +++
 3 files changed, 51 insertions(+), 58 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/iter_with_drain.rs b/clippy_lints/src/methods/iter_with_drain.rs
index 958c3773087..152072e09c7 100644
--- a/clippy_lints/src/methods/iter_with_drain.rs
+++ b/clippy_lints/src/methods/iter_with_drain.rs
@@ -1,72 +1,47 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::higher::Range;
 use clippy_utils::is_integer_const;
-use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{
-    higher::{self, Range},
-    SpanlessEq,
-};
 use rustc_ast::ast::RangeLimits;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, QPath};
 use rustc_lint::LateContext;
-use rustc_span::symbol::{sym, Symbol};
+use rustc_span::symbol::sym;
 use rustc_span::Span;
 
 use super::ITER_WITH_DRAIN;
 
-const DRAIN_TYPES: &[Symbol] = &[sym::Vec, sym::VecDeque];
-
 pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'_>, span: Span, arg: &Expr<'_>) {
-    let ty = cx.typeck_results().expr_ty(recv).peel_refs();
-    if let Some(drained_type) = DRAIN_TYPES.iter().find(|&&sym| is_type_diagnostic_item(cx, ty, sym)) {
-        // Refuse to emit `into_iter` suggestion on draining struct fields due
-        // to the strong possibility of processing unmovable field.
-        if let ExprKind::Field(..) = recv.kind {
-            return;
-        }
+    if !matches!(recv.kind, ExprKind::Field(..))
+        && let Some(adt) = cx.typeck_results().expr_ty(recv).ty_adt_def()
+        && let Some(ty_name) = cx.tcx.get_diagnostic_name(adt.did())
+        && matches!(ty_name, sym::Vec | sym::VecDeque)
+        && let Some(range) = Range::hir(arg)
+        && is_full_range(cx, recv, range)
+    {
+        span_lint_and_sugg(
+            cx,
+            ITER_WITH_DRAIN,
+            span.with_hi(expr.span.hi()),
+            &format!("`drain(..)` used on a `{}`", ty_name),
+            "try this",
+            "into_iter()".to_string(),
+            Applicability::MaybeIncorrect,
+        );
+    };
+}
 
-        if let Some(range) = higher::Range::hir(arg) {
-            let left_full = match range {
-                Range { start: Some(start), .. } if is_integer_const(cx, start, 0) => true,
-                Range { start: None, .. } => true,
-                _ => false,
-            };
-            let full = left_full
-                && match range {
-                    Range {
-                        end: Some(end),
-                        limits: RangeLimits::HalfOpen,
-                        ..
-                    } => {
-                        // `x.drain(..x.len())` call
-                        if_chain! {
-                            if let ExprKind::MethodCall(len_path, len_args, _) = end.kind;
-                            if len_path.ident.name == sym::len && len_args.len() == 1;
-                            if let ExprKind::Path(QPath::Resolved(_, drain_path)) = recv.kind;
-                            if let ExprKind::Path(QPath::Resolved(_, len_path)) = len_args[0].kind;
-                            if SpanlessEq::new(cx).eq_path(drain_path, len_path);
-                            then { true }
-                            else { false }
-                        }
-                    },
-                    Range {
-                        end: None,
-                        limits: RangeLimits::HalfOpen,
-                        ..
-                    } => true,
-                    _ => false,
-                };
-            if full {
-                span_lint_and_sugg(
-                    cx,
-                    ITER_WITH_DRAIN,
-                    span.with_hi(expr.span.hi()),
-                    &format!("`drain(..)` used on a `{}`", drained_type),
-                    "try this",
-                    "into_iter()".to_string(),
-                    Applicability::MaybeIncorrect,
-                );
+fn is_full_range(cx: &LateContext<'_>, container: &Expr<'_>, range: Range<'_>) -> bool {
+    range.start.map_or(true, |e| is_integer_const(cx, e, 0))
+        && range.end.map_or(true, |e| {
+            if range.limits == RangeLimits::HalfOpen
+                && let ExprKind::Path(QPath::Resolved(None, container_path)) = container.kind
+                && let ExprKind::MethodCall(name, [self_arg], _) = e.kind
+                && name.ident.name == sym::len
+                && let ExprKind::Path(QPath::Resolved(None, path)) = self_arg.kind
+            {
+                container_path.res == path.res
+            } else {
+                false
             }
-        }
-    }
+        })
 }
diff --git a/tests/ui/iter_with_drain.fixed b/tests/ui/iter_with_drain.fixed
index aea4dba9dd5..0330d554926 100644
--- a/tests/ui/iter_with_drain.fixed
+++ b/tests/ui/iter_with_drain.fixed
@@ -39,6 +39,15 @@ fn should_not_help() {
     let _: Vec<_> = b.drain(0..a.len()).collect();
 }
 
+fn _closed_range(mut x: Vec<String>) {
+    let _: Vec<String> = x.drain(0..=x.len()).collect();
+}
+
+fn _with_mut(x: &mut Vec<String>, y: &mut VecDeque<String>) {
+    let _: Vec<String> = x.drain(..).collect();
+    let _: Vec<String> = y.drain(..).collect();
+}
+
 #[derive(Default)]
 struct Bomb {
     fire: Vec<u8>,
diff --git a/tests/ui/iter_with_drain.rs b/tests/ui/iter_with_drain.rs
index 271878cffb4..993936fb8de 100644
--- a/tests/ui/iter_with_drain.rs
+++ b/tests/ui/iter_with_drain.rs
@@ -39,6 +39,15 @@ fn should_not_help() {
     let _: Vec<_> = b.drain(0..a.len()).collect();
 }
 
+fn _closed_range(mut x: Vec<String>) {
+    let _: Vec<String> = x.drain(0..=x.len()).collect();
+}
+
+fn _with_mut(x: &mut Vec<String>, y: &mut VecDeque<String>) {
+    let _: Vec<String> = x.drain(..).collect();
+    let _: Vec<String> = y.drain(..).collect();
+}
+
 #[derive(Default)]
 struct Bomb {
     fire: Vec<u8>,
-- 
cgit 1.4.1-3-g733a5


From 1450c989aeb5de1959759b6ed8b7b41c703f9969 Mon Sep 17 00:00:00 2001
From: Andy Kurnia <andykurn@gmail.com>
Date: Sun, 10 Apr 2022 01:07:01 +0800
Subject: fix typo

---
 clippy_lints/src/drop_forget_ref.rs | 2 +-
 tests/ui/drop_non_drop.stderr       | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/drop_forget_ref.rs b/clippy_lints/src/drop_forget_ref.rs
index 88c54828da8..25014bfa1a5 100644
--- a/clippy_lints/src/drop_forget_ref.rs
+++ b/clippy_lints/src/drop_forget_ref.rs
@@ -180,7 +180,7 @@ const DROP_COPY_SUMMARY: &str = "calls to `std::mem::drop` with a value that imp
 const FORGET_COPY_SUMMARY: &str = "calls to `std::mem::forget` with a value that implements `Copy`. \
                                    Forgetting a copy leaves the original intact";
 const DROP_NON_DROP_SUMMARY: &str = "call to `std::mem::drop` with a value that does not implement `Drop`. \
-                                 Dropping such a type only extends it's contained lifetimes";
+                                 Dropping such a type only extends its contained lifetimes";
 const FORGET_NON_DROP_SUMMARY: &str = "call to `std::mem::forget` with a value that does not implement `Drop`. \
                                    Forgetting such a type is the same as dropping it";
 
diff --git a/tests/ui/drop_non_drop.stderr b/tests/ui/drop_non_drop.stderr
index f73068901c5..30121033de7 100644
--- a/tests/ui/drop_non_drop.stderr
+++ b/tests/ui/drop_non_drop.stderr
@@ -1,4 +1,4 @@
-error: call to `std::mem::drop` with a value that does not implement `Drop`. Dropping such a type only extends it's contained lifetimes
+error: call to `std::mem::drop` with a value that does not implement `Drop`. Dropping such a type only extends its contained lifetimes
   --> $DIR/drop_non_drop.rs:22:5
    |
 LL |     drop(Foo);
@@ -11,7 +11,7 @@ note: argument has type `main::Foo`
 LL |     drop(Foo);
    |          ^^^
 
-error: call to `std::mem::drop` with a value that does not implement `Drop`. Dropping such a type only extends it's contained lifetimes
+error: call to `std::mem::drop` with a value that does not implement `Drop`. Dropping such a type only extends its contained lifetimes
   --> $DIR/drop_non_drop.rs:37:5
    |
 LL |     drop(Baz(Foo));
-- 
cgit 1.4.1-3-g733a5


From 5e335a52bc49991f6ffd40030b9948f3390f499d Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Sun, 10 Apr 2022 14:02:58 +0100
Subject: Check for loops/closures in `local_used_after_expr`

---
 clippy_lints/src/eta_reduction.rs       |  5 ++---
 clippy_utils/src/usage.rs               | 33 +++++++++++++++++++++++++++++++--
 tests/ui/eta.fixed                      |  4 ++++
 tests/ui/eta.rs                         |  4 ++++
 tests/ui/eta.stderr                     | 10 ++++++++--
 tests/ui/needless_option_as_deref.fixed | 14 ++++++++++++++
 tests/ui/needless_option_as_deref.rs    | 14 ++++++++++++++
 7 files changed, 77 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/eta_reduction.rs b/clippy_lints/src/eta_reduction.rs
index 845863bd209..c2e32f1d9a2 100644
--- a/clippy_lints/src/eta_reduction.rs
+++ b/clippy_lints/src/eta_reduction.rs
@@ -3,7 +3,7 @@ use clippy_utils::higher::VecArgs;
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::usage::local_used_after_expr;
-use clippy_utils::{get_enclosing_loop_or_closure, higher, path_to_local, path_to_local_id};
+use clippy_utils::{higher, path_to_local, path_to_local_id};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::def_id::DefId;
@@ -125,8 +125,7 @@ impl<'tcx> LateLintPass<'tcx> for EtaReduction {
                         if_chain! {
                             if let ty::Closure(_, substs) = callee_ty.peel_refs().kind();
                             if substs.as_closure().kind() == ClosureKind::FnMut;
-                            if get_enclosing_loop_or_closure(cx.tcx, expr).is_some()
-                                || path_to_local(callee).map_or(false, |l| local_used_after_expr(cx, l, callee));
+                            if path_to_local(callee).map_or(false, |l| local_used_after_expr(cx, l, expr));
 
                             then {
                                 // Mutable closure is used after current expr; we cannot consume it.
diff --git a/clippy_utils/src/usage.rs b/clippy_utils/src/usage.rs
index 405e306359b..4236e3aae2f 100644
--- a/clippy_utils/src/usage.rs
+++ b/clippy_utils/src/usage.rs
@@ -3,7 +3,7 @@ use crate::visitors::{expr_visitor, expr_visitor_no_bodies};
 use rustc_hir as hir;
 use rustc_hir::intravisit::{self, Visitor};
 use rustc_hir::HirIdSet;
-use rustc_hir::{Expr, ExprKind, HirId};
+use rustc_hir::{Expr, ExprKind, HirId, Node};
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::LateContext;
 use rustc_middle::hir::nested_filter;
@@ -169,6 +169,32 @@ pub fn contains_return_break_continue_macro(expression: &Expr<'_>) -> bool {
 
 pub fn local_used_after_expr(cx: &LateContext<'_>, local_id: HirId, after: &Expr<'_>) -> bool {
     let Some(block) = utils::get_enclosing_block(cx, local_id) else { return false };
+
+    // for _ in 1..3 {
+    //    local
+    // }
+    //
+    // let closure = || local;
+    // closure();
+    // closure();
+    let in_loop_or_closure = cx
+        .tcx
+        .hir()
+        .parent_iter(after.hir_id)
+        .take_while(|&(id, _)| id != block.hir_id)
+        .any(|(_, node)| {
+            matches!(
+                node,
+                Node::Expr(Expr {
+                    kind: ExprKind::Loop(..) | ExprKind::Closure(..),
+                    ..
+                })
+            )
+        });
+    if in_loop_or_closure {
+        return true;
+    }
+
     let mut used_after_expr = false;
     let mut past_expr = false;
     expr_visitor(cx, |expr| {
@@ -178,7 +204,10 @@ pub fn local_used_after_expr(cx: &LateContext<'_>, local_id: HirId, after: &Expr
 
         if expr.hir_id == after.hir_id {
             past_expr = true;
-        } else if past_expr && utils::path_to_local_id(expr, local_id) {
+            return false;
+        }
+
+        if past_expr && utils::path_to_local_id(expr, local_id) {
             used_after_expr = true;
         }
         !used_after_expr
diff --git a/tests/ui/eta.fixed b/tests/ui/eta.fixed
index 5aedbea381f..873ed689a5b 100644
--- a/tests/ui/eta.fixed
+++ b/tests/ui/eta.fixed
@@ -211,6 +211,10 @@ fn mutable_closure_in_loop() {
     let mut closure = |n| value += n;
     for _ in 0..5 {
         Some(1).map(&mut closure);
+
+        let mut value = 0;
+        let mut in_loop = |n| value += n;
+        Some(1).map(in_loop);
     }
 }
 
diff --git a/tests/ui/eta.rs b/tests/ui/eta.rs
index 5fdf7fb9771..4cb58eec94c 100644
--- a/tests/ui/eta.rs
+++ b/tests/ui/eta.rs
@@ -211,6 +211,10 @@ fn mutable_closure_in_loop() {
     let mut closure = |n| value += n;
     for _ in 0..5 {
         Some(1).map(|n| closure(n));
+
+        let mut value = 0;
+        let mut in_loop = |n| value += n;
+        Some(1).map(|n| in_loop(n));
     }
 }
 
diff --git a/tests/ui/eta.stderr b/tests/ui/eta.stderr
index cda84982c9b..d1ae889d6f3 100644
--- a/tests/ui/eta.stderr
+++ b/tests/ui/eta.stderr
@@ -117,10 +117,16 @@ LL |         Some(1).map(|n| closure(n));
    |                     ^^^^^^^^^^^^^^ help: replace the closure with the function itself: `&mut closure`
 
 error: redundant closure
-  --> $DIR/eta.rs:232:21
+  --> $DIR/eta.rs:217:21
+   |
+LL |         Some(1).map(|n| in_loop(n));
+   |                     ^^^^^^^^^^^^^^ help: replace the closure with the function itself: `in_loop`
+
+error: redundant closure
+  --> $DIR/eta.rs:236:21
    |
 LL |     map_str_to_path(|s| s.as_ref());
    |                     ^^^^^^^^^^^^^^ help: replace the closure with the method itself: `std::convert::AsRef::as_ref`
 
-error: aborting due to 20 previous errors
+error: aborting due to 21 previous errors
 
diff --git a/tests/ui/needless_option_as_deref.fixed b/tests/ui/needless_option_as_deref.fixed
index c09b07db3dc..acd22c6bb43 100644
--- a/tests/ui/needless_option_as_deref.fixed
+++ b/tests/ui/needless_option_as_deref.fixed
@@ -16,6 +16,20 @@ fn main() {
     let _ = Some(Box::new(1)).as_deref();
     let _ = Some(Box::new(1)).as_deref_mut();
 
+    let mut y = 0;
+    let mut x = Some(&mut y);
+    for _ in 0..3 {
+        let _ = x.as_deref_mut();
+    }
+
+    let mut y = 0;
+    let mut x = Some(&mut y);
+    let mut closure = || {
+        let _ = x.as_deref_mut();
+    };
+    closure();
+    closure();
+
     // #7846
     let mut i = 0;
     let mut opt_vec = vec![Some(&mut i)];
diff --git a/tests/ui/needless_option_as_deref.rs b/tests/ui/needless_option_as_deref.rs
index c3ba27ecccf..61eda5052a2 100644
--- a/tests/ui/needless_option_as_deref.rs
+++ b/tests/ui/needless_option_as_deref.rs
@@ -16,6 +16,20 @@ fn main() {
     let _ = Some(Box::new(1)).as_deref();
     let _ = Some(Box::new(1)).as_deref_mut();
 
+    let mut y = 0;
+    let mut x = Some(&mut y);
+    for _ in 0..3 {
+        let _ = x.as_deref_mut();
+    }
+
+    let mut y = 0;
+    let mut x = Some(&mut y);
+    let mut closure = || {
+        let _ = x.as_deref_mut();
+    };
+    closure();
+    closure();
+
     // #7846
     let mut i = 0;
     let mut opt_vec = vec![Some(&mut i)];
-- 
cgit 1.4.1-3-g733a5


From 6fba89751bfacf59109d37331ec79a8f87ee0aaf Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Mon, 4 Apr 2022 16:30:38 +0100
Subject: Remove overlap between `manual_split_once` and `needless_splitn`

Also fixes some incorrect suggestions for rsplitn
---
 clippy_lints/src/methods/mod.rs        |   7 +-
 clippy_lints/src/methods/str_splitn.rs | 246 ++++++++++-----------------------
 tests/ui/crashes/ice-8250.stderr       |  10 +-
 tests/ui/manual_split_once.fixed       |  21 ++-
 tests/ui/manual_split_once.rs          |  21 ++-
 tests/ui/manual_split_once.stderr      |  86 +++++-------
 tests/ui/needless_splitn.fixed         |  20 +++
 tests/ui/needless_splitn.rs            |  20 +++
 tests/ui/needless_splitn.stderr        |  44 +++++-
 9 files changed, 216 insertions(+), 259 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 021337280d1..7047aa4c69b 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -2516,12 +2516,7 @@ fn check_methods<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, msrv: Optio
             ("splitn" | "rsplitn", [count_arg, pat_arg]) => {
                 if let Some((Constant::Int(count), _)) = constant(cx, cx.typeck_results(), count_arg) {
                     suspicious_splitn::check(cx, name, expr, recv, count);
-                    if count == 2 && meets_msrv(msrv, &msrvs::STR_SPLIT_ONCE) {
-                        str_splitn::check_manual_split_once(cx, name, expr, recv, pat_arg);
-                    }
-                    if count >= 2 {
-                        str_splitn::check_needless_splitn(cx, name, expr, recv, pat_arg, count);
-                    }
+                    str_splitn::check(cx, name, expr, recv, pat_arg, count, msrv);
                 }
             },
             ("splitn_mut" | "rsplitn_mut", [count_arg, _]) => {
diff --git a/clippy_lints/src/methods/str_splitn.rs b/clippy_lints/src/methods/str_splitn.rs
index 8125930b304..6eaa9eb2ef0 100644
--- a/clippy_lints/src/methods/str_splitn.rs
+++ b/clippy_lints/src/methods/str_splitn.rs
@@ -1,36 +1,77 @@
 use clippy_utils::consts::{constant, Constant};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_context;
-use clippy_utils::{is_diag_item_method, match_def_path, paths};
+use clippy_utils::{is_diag_item_method, match_def_path, meets_msrv, msrvs, paths};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, HirId, LangItem, Node, QPath};
 use rustc_lint::LateContext;
-use rustc_middle::ty::{self, adjustment::Adjust};
+use rustc_middle::ty;
+use rustc_semver::RustcVersion;
 use rustc_span::{symbol::sym, Span, SyntaxContext};
 
-use super::MANUAL_SPLIT_ONCE;
+use super::{MANUAL_SPLIT_ONCE, NEEDLESS_SPLITN};
 
-pub(super) fn check_manual_split_once(
+pub(super) fn check(
     cx: &LateContext<'_>,
     method_name: &str,
     expr: &Expr<'_>,
     self_arg: &Expr<'_>,
     pat_arg: &Expr<'_>,
+    count: u128,
+    msrv: Option<&RustcVersion>,
 ) {
-    if !cx.typeck_results().expr_ty_adjusted(self_arg).peel_refs().is_str() {
+    if count < 2 || !cx.typeck_results().expr_ty_adjusted(self_arg).peel_refs().is_str() {
         return;
     }
 
     let ctxt = expr.span.ctxt();
-    let (method_name, msg, reverse) = if method_name == "splitn" {
-        ("split_once", "manual implementation of `split_once`", false)
-    } else {
-        ("rsplit_once", "manual implementation of `rsplit_once`", true)
+    let Some(usage) = parse_iter_usage(cx, ctxt, cx.tcx.hir().parent_iter(expr.hir_id)) else { return };
+
+    let needless = match usage.kind {
+        IterUsageKind::Nth(n) => count > n + 1,
+        IterUsageKind::NextTuple => count > 2,
     };
-    let usage = match parse_iter_usage(cx, ctxt, cx.tcx.hir().parent_iter(expr.hir_id), reverse) {
-        Some(x) => x,
-        None => return,
+
+    if needless {
+        let mut app = Applicability::MachineApplicable;
+        let (r, message) = if method_name == "splitn" {
+            ("", "unnecessary use of `splitn`")
+        } else {
+            ("r", "unnecessary use of `rsplitn`")
+        };
+
+        span_lint_and_sugg(
+            cx,
+            NEEDLESS_SPLITN,
+            expr.span,
+            message,
+            "try this",
+            format!(
+                "{}.{r}split({})",
+                snippet_with_context(cx, self_arg.span, ctxt, "..", &mut app).0,
+                snippet_with_context(cx, pat_arg.span, ctxt, "..", &mut app).0,
+            ),
+            app,
+        );
+    } else if count == 2 && meets_msrv(msrv, &msrvs::STR_SPLIT_ONCE) {
+        check_manual_split_once(cx, method_name, expr, self_arg, pat_arg, &usage);
+    }
+}
+
+fn check_manual_split_once(
+    cx: &LateContext<'_>,
+    method_name: &str,
+    expr: &Expr<'_>,
+    self_arg: &Expr<'_>,
+    pat_arg: &Expr<'_>,
+    usage: &IterUsage,
+) {
+    let ctxt = expr.span.ctxt();
+    let (msg, reverse) = if method_name == "splitn" {
+        ("manual implementation of `split_once`", false)
+    } else {
+        ("manual implementation of `rsplit_once`", true)
     };
 
     let mut app = Applicability::MachineApplicable;
@@ -39,77 +80,36 @@ pub(super) fn check_manual_split_once(
 
     let sugg = match usage.kind {
         IterUsageKind::NextTuple => {
-            format!("{}.{}({})", self_snip, method_name, pat_snip)
-        },
-        IterUsageKind::RNextTuple => format!("{}.{}({}).map(|(x, y)| (y, x))", self_snip, method_name, pat_snip),
-        IterUsageKind::Next | IterUsageKind::Second => {
-            let self_deref = {
-                let adjust = cx.typeck_results().expr_adjustments(self_arg);
-                if adjust.len() < 2 {
-                    String::new()
-                } else if cx.typeck_results().expr_ty(self_arg).is_box()
-                    || adjust
-                        .iter()
-                        .any(|a| matches!(a.kind, Adjust::Deref(Some(_))) || a.target.is_box())
-                {
-                    format!("&{}", "*".repeat(adjust.len().saturating_sub(1)))
-                } else {
-                    "*".repeat(adjust.len().saturating_sub(2))
-                }
-            };
-            if matches!(usage.kind, IterUsageKind::Next) {
-                match usage.unwrap_kind {
-                    Some(UnwrapKind::Unwrap) => {
-                        if reverse {
-                            format!("{}.{}({}).unwrap().0", self_snip, method_name, pat_snip)
-                        } else {
-                            format!(
-                                "{}.{}({}).map_or({}{}, |x| x.0)",
-                                self_snip, method_name, pat_snip, self_deref, &self_snip
-                            )
-                        }
-                    },
-                    Some(UnwrapKind::QuestionMark) => {
-                        format!(
-                            "{}.{}({}).map_or({}{}, |x| x.0)",
-                            self_snip, method_name, pat_snip, self_deref, &self_snip
-                        )
-                    },
-                    None => {
-                        format!(
-                            "Some({}.{}({}).map_or({}{}, |x| x.0))",
-                            &self_snip, method_name, pat_snip, self_deref, &self_snip
-                        )
-                    },
-                }
+            if reverse {
+                format!("{self_snip}.rsplit_once({pat_snip}).map(|(x, y)| (y, x))")
             } else {
-                match usage.unwrap_kind {
-                    Some(UnwrapKind::Unwrap) => {
-                        if reverse {
-                            // In this case, no better suggestion is offered.
-                            return;
-                        }
-                        format!("{}.{}({}).unwrap().1", self_snip, method_name, pat_snip)
-                    },
-                    Some(UnwrapKind::QuestionMark) => {
-                        format!("{}.{}({})?.1", self_snip, method_name, pat_snip)
-                    },
-                    None => {
-                        format!("{}.{}({}).map(|x| x.1)", self_snip, method_name, pat_snip)
-                    },
-                }
+                format!("{self_snip}.split_once({pat_snip})")
             }
         },
+        IterUsageKind::Nth(1) => {
+            let (r, field) = if reverse { ("r", 0) } else { ("", 1) };
+
+            match usage.unwrap_kind {
+                Some(UnwrapKind::Unwrap) => {
+                    format!("{self_snip}.{r}split_once({pat_snip}).unwrap().{field}")
+                },
+                Some(UnwrapKind::QuestionMark) => {
+                    format!("{self_snip}.{r}split_once({pat_snip})?.{field}")
+                },
+                None => {
+                    format!("{self_snip}.{r}split_once({pat_snip}).map(|x| x.{field})")
+                },
+            }
+        },
+        IterUsageKind::Nth(_) => return,
     };
 
     span_lint_and_sugg(cx, MANUAL_SPLIT_ONCE, usage.span, msg, "try this", sugg, app);
 }
 
 enum IterUsageKind {
-    Next,
-    Second,
+    Nth(u128),
     NextTuple,
-    RNextTuple,
 }
 
 enum UnwrapKind {
@@ -128,7 +128,6 @@ fn parse_iter_usage<'tcx>(
     cx: &LateContext<'tcx>,
     ctxt: SyntaxContext,
     mut iter: impl Iterator<Item = (HirId, Node<'tcx>)>,
-    reverse: bool,
 ) -> Option<IterUsage> {
     let (kind, span) = match iter.next() {
         Some((_, Node::Expr(e))) if e.span.ctxt() == ctxt => {
@@ -141,13 +140,7 @@ fn parse_iter_usage<'tcx>(
             let iter_id = cx.tcx.get_diagnostic_item(sym::Iterator)?;
 
             match (name.ident.as_str(), args) {
-                ("next", []) if cx.tcx.trait_of_item(did) == Some(iter_id) => {
-                    if reverse {
-                        (IterUsageKind::Second, e.span)
-                    } else {
-                        (IterUsageKind::Next, e.span)
-                    }
-                },
+                ("next", []) if cx.tcx.trait_of_item(did) == Some(iter_id) => (IterUsageKind::Nth(0), e.span),
                 ("next_tuple", []) => {
                     return if_chain! {
                         if match_def_path(cx, did, &paths::ITERTOOLS_NEXT_TUPLE);
@@ -157,7 +150,7 @@ fn parse_iter_usage<'tcx>(
                         if subs.len() == 2;
                         then {
                             Some(IterUsage {
-                                kind: if reverse { IterUsageKind::RNextTuple } else { IterUsageKind::NextTuple },
+                                kind: IterUsageKind::NextTuple,
                                 span: e.span,
                                 unwrap_kind: None
                             })
@@ -185,11 +178,7 @@ fn parse_iter_usage<'tcx>(
                                 }
                             }
                         };
-                        match if reverse { idx ^ 1 } else { idx } {
-                            0 => (IterUsageKind::Next, span),
-                            1 => (IterUsageKind::Second, span),
-                            _ => return None,
-                        }
+                        (IterUsageKind::Nth(idx), span)
                     } else {
                         return None;
                     }
@@ -238,86 +227,3 @@ fn parse_iter_usage<'tcx>(
         span,
     })
 }
-
-use super::NEEDLESS_SPLITN;
-
-pub(super) fn check_needless_splitn(
-    cx: &LateContext<'_>,
-    method_name: &str,
-    expr: &Expr<'_>,
-    self_arg: &Expr<'_>,
-    pat_arg: &Expr<'_>,
-    count: u128,
-) {
-    if !cx.typeck_results().expr_ty_adjusted(self_arg).peel_refs().is_str() {
-        return;
-    }
-    let ctxt = expr.span.ctxt();
-    let mut app = Applicability::MachineApplicable;
-    let (reverse, message) = if method_name == "splitn" {
-        (false, "unnecessary use of `splitn`")
-    } else {
-        (true, "unnecessary use of `rsplitn`")
-    };
-    if_chain! {
-        if count >= 2;
-        if check_iter(cx, ctxt, cx.tcx.hir().parent_iter(expr.hir_id), count);
-        then {
-            span_lint_and_sugg(
-                cx,
-                NEEDLESS_SPLITN,
-                expr.span,
-                message,
-                "try this",
-                format!(
-                    "{}.{}({})",
-                    snippet_with_context(cx, self_arg.span, ctxt, "..", &mut app).0,
-                    if reverse {"rsplit"} else {"split"},
-                    snippet_with_context(cx, pat_arg.span, ctxt, "..", &mut app).0
-                ),
-                app,
-            );
-        }
-    }
-}
-
-fn check_iter<'tcx>(
-    cx: &LateContext<'tcx>,
-    ctxt: SyntaxContext,
-    mut iter: impl Iterator<Item = (HirId, Node<'tcx>)>,
-    count: u128,
-) -> bool {
-    match iter.next() {
-        Some((_, Node::Expr(e))) if e.span.ctxt() == ctxt => {
-            let (name, args) = if let ExprKind::MethodCall(name, [_, args @ ..], _) = e.kind {
-                (name, args)
-            } else {
-                return false;
-            };
-            if_chain! {
-                if let Some(did) = cx.typeck_results().type_dependent_def_id(e.hir_id);
-                if let Some(iter_id) = cx.tcx.get_diagnostic_item(sym::Iterator);
-                then {
-                    match (name.ident.as_str(), args) {
-                        ("next", []) if cx.tcx.trait_of_item(did) == Some(iter_id) => {
-                            return true;
-                        },
-                        ("next_tuple", []) if count > 2 => {
-                            return true;
-                        },
-                        ("nth", [idx_expr]) if cx.tcx.trait_of_item(did) == Some(iter_id) => {
-                            if let Some((Constant::Int(idx), _)) = constant(cx, cx.typeck_results(), idx_expr) {
-                                if count > idx + 1 {
-                                    return true;
-                                }
-                            }
-                        },
-                        _ =>  return false,
-                    }
-                }
-            }
-        },
-        _ => return false,
-    };
-    false
-}
diff --git a/tests/ui/crashes/ice-8250.stderr b/tests/ui/crashes/ice-8250.stderr
index 04ea4456656..8ed8f3b3a06 100644
--- a/tests/ui/crashes/ice-8250.stderr
+++ b/tests/ui/crashes/ice-8250.stderr
@@ -1,11 +1,3 @@
-error: manual implementation of `split_once`
-  --> $DIR/ice-8250.rs:2:13
-   |
-LL |     let _ = s[1..].splitn(2, '.').next()?;
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `s[1..].split_once('.').map_or(s[1..], |x| x.0)`
-   |
-   = note: `-D clippy::manual-split-once` implied by `-D warnings`
-
 error: unnecessary use of `splitn`
   --> $DIR/ice-8250.rs:2:13
    |
@@ -14,5 +6,5 @@ LL |     let _ = s[1..].splitn(2, '.').next()?;
    |
    = note: `-D clippy::needless-splitn` implied by `-D warnings`
 
-error: aborting due to 2 previous errors
+error: aborting due to previous error
 
diff --git a/tests/ui/manual_split_once.fixed b/tests/ui/manual_split_once.fixed
index d5113df569a..8621ddc7467 100644
--- a/tests/ui/manual_split_once.fixed
+++ b/tests/ui/manual_split_once.fixed
@@ -2,7 +2,7 @@
 
 #![feature(custom_inner_attributes)]
 #![warn(clippy::manual_split_once)]
-#![allow(clippy::iter_skip_next, clippy::iter_nth_zero, clippy::needless_splitn)]
+#![allow(clippy::iter_skip_next, clippy::iter_nth_zero)]
 
 extern crate itertools;
 
@@ -10,27 +10,25 @@ extern crate itertools;
 use itertools::Itertools;
 
 fn main() {
-    let _ = Some("key=value".split_once('=').map_or("key=value", |x| x.0));
     let _ = "key=value".splitn(2, '=').nth(2);
-    let _ = "key=value".split_once('=').map_or("key=value", |x| x.0);
-    let _ = "key=value".split_once('=').map_or("key=value", |x| x.0);
     let _ = "key=value".split_once('=').unwrap().1;
     let _ = "key=value".split_once('=').unwrap().1;
     let (_, _) = "key=value".split_once('=').unwrap();
 
     let s = String::from("key=value");
-    let _ = s.split_once('=').map_or(&*s, |x| x.0);
+    let _ = s.split_once('=').unwrap().1;
 
     let s = Box::<str>::from("key=value");
-    let _ = s.split_once('=').map_or(&*s, |x| x.0);
+    let _ = s.split_once('=').unwrap().1;
 
     let s = &"key=value";
-    let _ = s.split_once('=').map_or(*s, |x| x.0);
+    let _ = s.split_once('=').unwrap().1;
 
     fn _f(s: &str) -> Option<&str> {
-        let _ = s.split_once("key=value").map_or(s, |x| x.0);
-        let _ = s.split_once("key=value")?.1;
-        let _ = s.split_once("key=value")?.1;
+        let _ = s.split_once('=')?.1;
+        let _ = s.split_once('=')?.1;
+        let _ = s.rsplit_once('=')?.0;
+        let _ = s.rsplit_once('=')?.0;
         None
     }
 
@@ -38,10 +36,9 @@ fn main() {
     let _ = [0, 1, 2].splitn(2, |&x| x == 1).nth(1).unwrap();
 
     // `rsplitn` gives the results in the reverse order of `rsplit_once`
-    let _ = "key=value".rsplitn(2, '=').next().unwrap();
     let _ = "key=value".rsplit_once('=').unwrap().0;
-    let _ = "key=value".rsplit_once('=').map(|x| x.1);
     let (_, _) = "key=value".rsplit_once('=').map(|(x, y)| (y, x)).unwrap();
+    let _ = s.rsplit_once('=').map(|x| x.0);
 }
 
 fn _msrv_1_51() {
diff --git a/tests/ui/manual_split_once.rs b/tests/ui/manual_split_once.rs
index 80e02952dbd..c8a1d7b91e5 100644
--- a/tests/ui/manual_split_once.rs
+++ b/tests/ui/manual_split_once.rs
@@ -2,7 +2,7 @@
 
 #![feature(custom_inner_attributes)]
 #![warn(clippy::manual_split_once)]
-#![allow(clippy::iter_skip_next, clippy::iter_nth_zero, clippy::needless_splitn)]
+#![allow(clippy::iter_skip_next, clippy::iter_nth_zero)]
 
 extern crate itertools;
 
@@ -10,27 +10,25 @@ extern crate itertools;
 use itertools::Itertools;
 
 fn main() {
-    let _ = "key=value".splitn(2, '=').next();
     let _ = "key=value".splitn(2, '=').nth(2);
-    let _ = "key=value".splitn(2, '=').next().unwrap();
-    let _ = "key=value".splitn(2, '=').nth(0).unwrap();
     let _ = "key=value".splitn(2, '=').nth(1).unwrap();
     let _ = "key=value".splitn(2, '=').skip(1).next().unwrap();
     let (_, _) = "key=value".splitn(2, '=').next_tuple().unwrap();
 
     let s = String::from("key=value");
-    let _ = s.splitn(2, '=').next().unwrap();
+    let _ = s.splitn(2, '=').nth(1).unwrap();
 
     let s = Box::<str>::from("key=value");
-    let _ = s.splitn(2, '=').nth(0).unwrap();
+    let _ = s.splitn(2, '=').nth(1).unwrap();
 
     let s = &"key=value";
-    let _ = s.splitn(2, '=').skip(0).next().unwrap();
+    let _ = s.splitn(2, '=').skip(1).next().unwrap();
 
     fn _f(s: &str) -> Option<&str> {
-        let _ = s.splitn(2, "key=value").next()?;
-        let _ = s.splitn(2, "key=value").nth(1)?;
-        let _ = s.splitn(2, "key=value").skip(1).next()?;
+        let _ = s.splitn(2, '=').nth(1)?;
+        let _ = s.splitn(2, '=').skip(1).next()?;
+        let _ = s.rsplitn(2, '=').nth(1)?;
+        let _ = s.rsplitn(2, '=').skip(1).next()?;
         None
     }
 
@@ -38,10 +36,9 @@ fn main() {
     let _ = [0, 1, 2].splitn(2, |&x| x == 1).nth(1).unwrap();
 
     // `rsplitn` gives the results in the reverse order of `rsplit_once`
-    let _ = "key=value".rsplitn(2, '=').next().unwrap();
     let _ = "key=value".rsplitn(2, '=').nth(1).unwrap();
-    let _ = "key=value".rsplitn(2, '=').nth(0);
     let (_, _) = "key=value".rsplitn(2, '=').next_tuple().unwrap();
+    let _ = s.rsplitn(2, '=').nth(1);
 }
 
 fn _msrv_1_51() {
diff --git a/tests/ui/manual_split_once.stderr b/tests/ui/manual_split_once.stderr
index af9c7a2d41b..9635e6c5e4b 100644
--- a/tests/ui/manual_split_once.stderr
+++ b/tests/ui/manual_split_once.stderr
@@ -1,100 +1,88 @@
 error: manual implementation of `split_once`
-  --> $DIR/manual_split_once.rs:13:13
+  --> $DIR/manual_split_once.rs:14:13
    |
-LL |     let _ = "key=value".splitn(2, '=').next();
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `Some("key=value".split_once('=').map_or("key=value", |x| x.0))`
+LL |     let _ = "key=value".splitn(2, '=').nth(1).unwrap();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `"key=value".split_once('=').unwrap().1`
    |
    = note: `-D clippy::manual-split-once` implied by `-D warnings`
 
 error: manual implementation of `split_once`
   --> $DIR/manual_split_once.rs:15:13
    |
-LL |     let _ = "key=value".splitn(2, '=').next().unwrap();
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `"key=value".split_once('=').map_or("key=value", |x| x.0)`
-
-error: manual implementation of `split_once`
-  --> $DIR/manual_split_once.rs:16:13
-   |
-LL |     let _ = "key=value".splitn(2, '=').nth(0).unwrap();
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `"key=value".split_once('=').map_or("key=value", |x| x.0)`
-
-error: manual implementation of `split_once`
-  --> $DIR/manual_split_once.rs:17:13
-   |
-LL |     let _ = "key=value".splitn(2, '=').nth(1).unwrap();
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `"key=value".split_once('=').unwrap().1`
-
-error: manual implementation of `split_once`
-  --> $DIR/manual_split_once.rs:18:13
-   |
 LL |     let _ = "key=value".splitn(2, '=').skip(1).next().unwrap();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `"key=value".split_once('=').unwrap().1`
 
 error: manual implementation of `split_once`
-  --> $DIR/manual_split_once.rs:19:18
+  --> $DIR/manual_split_once.rs:16:18
    |
 LL |     let (_, _) = "key=value".splitn(2, '=').next_tuple().unwrap();
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `"key=value".split_once('=')`
 
+error: manual implementation of `split_once`
+  --> $DIR/manual_split_once.rs:19:13
+   |
+LL |     let _ = s.splitn(2, '=').nth(1).unwrap();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `s.split_once('=').unwrap().1`
+
 error: manual implementation of `split_once`
   --> $DIR/manual_split_once.rs:22:13
    |
-LL |     let _ = s.splitn(2, '=').next().unwrap();
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `s.split_once('=').map_or(&*s, |x| x.0)`
+LL |     let _ = s.splitn(2, '=').nth(1).unwrap();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `s.split_once('=').unwrap().1`
 
 error: manual implementation of `split_once`
   --> $DIR/manual_split_once.rs:25:13
    |
-LL |     let _ = s.splitn(2, '=').nth(0).unwrap();
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `s.split_once('=').map_or(&*s, |x| x.0)`
+LL |     let _ = s.splitn(2, '=').skip(1).next().unwrap();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `s.split_once('=').unwrap().1`
 
 error: manual implementation of `split_once`
-  --> $DIR/manual_split_once.rs:28:13
+  --> $DIR/manual_split_once.rs:28:17
    |
-LL |     let _ = s.splitn(2, '=').skip(0).next().unwrap();
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `s.split_once('=').map_or(*s, |x| x.0)`
+LL |         let _ = s.splitn(2, '=').nth(1)?;
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `s.split_once('=')?.1`
 
 error: manual implementation of `split_once`
-  --> $DIR/manual_split_once.rs:31:17
+  --> $DIR/manual_split_once.rs:29:17
    |
-LL |         let _ = s.splitn(2, "key=value").next()?;
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `s.split_once("key=value").map_or(s, |x| x.0)`
+LL |         let _ = s.splitn(2, '=').skip(1).next()?;
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `s.split_once('=')?.1`
 
-error: manual implementation of `split_once`
-  --> $DIR/manual_split_once.rs:32:17
+error: manual implementation of `rsplit_once`
+  --> $DIR/manual_split_once.rs:30:17
    |
-LL |         let _ = s.splitn(2, "key=value").nth(1)?;
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `s.split_once("key=value")?.1`
+LL |         let _ = s.rsplitn(2, '=').nth(1)?;
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `s.rsplit_once('=')?.0`
 
-error: manual implementation of `split_once`
-  --> $DIR/manual_split_once.rs:33:17
+error: manual implementation of `rsplit_once`
+  --> $DIR/manual_split_once.rs:31:17
    |
-LL |         let _ = s.splitn(2, "key=value").skip(1).next()?;
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `s.split_once("key=value")?.1`
+LL |         let _ = s.rsplitn(2, '=').skip(1).next()?;
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `s.rsplit_once('=')?.0`
 
 error: manual implementation of `rsplit_once`
-  --> $DIR/manual_split_once.rs:42:13
+  --> $DIR/manual_split_once.rs:39:13
    |
 LL |     let _ = "key=value".rsplitn(2, '=').nth(1).unwrap();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `"key=value".rsplit_once('=').unwrap().0`
 
 error: manual implementation of `rsplit_once`
-  --> $DIR/manual_split_once.rs:43:13
+  --> $DIR/manual_split_once.rs:40:18
    |
-LL |     let _ = "key=value".rsplitn(2, '=').nth(0);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `"key=value".rsplit_once('=').map(|x| x.1)`
+LL |     let (_, _) = "key=value".rsplitn(2, '=').next_tuple().unwrap();
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `"key=value".rsplit_once('=').map(|(x, y)| (y, x))`
 
 error: manual implementation of `rsplit_once`
-  --> $DIR/manual_split_once.rs:44:18
+  --> $DIR/manual_split_once.rs:41:13
    |
-LL |     let (_, _) = "key=value".rsplitn(2, '=').next_tuple().unwrap();
-   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `"key=value".rsplit_once('=').map(|(x, y)| (y, x))`
+LL |     let _ = s.rsplitn(2, '=').nth(1);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `s.rsplit_once('=').map(|x| x.0)`
 
 error: manual implementation of `split_once`
-  --> $DIR/manual_split_once.rs:55:13
+  --> $DIR/manual_split_once.rs:52:13
    |
 LL |     let _ = "key=value".splitn(2, '=').nth(1).unwrap();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `"key=value".split_once('=').unwrap().1`
 
-error: aborting due to 16 previous errors
+error: aborting due to 14 previous errors
 
diff --git a/tests/ui/needless_splitn.fixed b/tests/ui/needless_splitn.fixed
index f6a4b2f17d3..61f5fc4e679 100644
--- a/tests/ui/needless_splitn.fixed
+++ b/tests/ui/needless_splitn.fixed
@@ -24,4 +24,24 @@ fn main() {
     let _ = str.rsplitn(2, '=').nth(1);
     let (_, _) = str.rsplitn(2, '=').next_tuple().unwrap();
     let (_, _) = str.rsplit('=').next_tuple().unwrap();
+
+    let _ = str.split('=').next();
+    let _ = str.split('=').nth(3);
+    let _ = str.splitn(5, '=').nth(4);
+    let _ = str.splitn(5, '=').nth(5);
+}
+
+fn _question_mark(s: &str) -> Option<()> {
+    let _ = s.split('=').next()?;
+    let _ = s.split('=').nth(0)?;
+    let _ = s.rsplit('=').next()?;
+    let _ = s.rsplit('=').nth(0)?;
+
+    Some(())
+}
+
+fn _test_msrv() {
+    #![clippy::msrv = "1.51"]
+    // `manual_split_once` MSRV shouldn't apply to `needless_splitn`
+    let _ = "key=value".split('=').nth(0).unwrap();
 }
diff --git a/tests/ui/needless_splitn.rs b/tests/ui/needless_splitn.rs
index 6ba32255bb2..71d9a7077fa 100644
--- a/tests/ui/needless_splitn.rs
+++ b/tests/ui/needless_splitn.rs
@@ -24,4 +24,24 @@ fn main() {
     let _ = str.rsplitn(2, '=').nth(1);
     let (_, _) = str.rsplitn(2, '=').next_tuple().unwrap();
     let (_, _) = str.rsplitn(3, '=').next_tuple().unwrap();
+
+    let _ = str.splitn(5, '=').next();
+    let _ = str.splitn(5, '=').nth(3);
+    let _ = str.splitn(5, '=').nth(4);
+    let _ = str.splitn(5, '=').nth(5);
+}
+
+fn _question_mark(s: &str) -> Option<()> {
+    let _ = s.splitn(2, '=').next()?;
+    let _ = s.splitn(2, '=').nth(0)?;
+    let _ = s.rsplitn(2, '=').next()?;
+    let _ = s.rsplitn(2, '=').nth(0)?;
+
+    Some(())
+}
+
+fn _test_msrv() {
+    #![clippy::msrv = "1.51"]
+    // `manual_split_once` MSRV shouldn't apply to `needless_splitn`
+    let _ = "key=value".splitn(2, '=').nth(0).unwrap();
 }
diff --git a/tests/ui/needless_splitn.stderr b/tests/ui/needless_splitn.stderr
index 66de2256554..f112b29e7f2 100644
--- a/tests/ui/needless_splitn.stderr
+++ b/tests/ui/needless_splitn.stderr
@@ -36,5 +36,47 @@ error: unnecessary use of `rsplitn`
 LL |     let (_, _) = str.rsplitn(3, '=').next_tuple().unwrap();
    |                  ^^^^^^^^^^^^^^^^^^^ help: try this: `str.rsplit('=')`
 
-error: aborting due to 6 previous errors
+error: unnecessary use of `splitn`
+  --> $DIR/needless_splitn.rs:28:13
+   |
+LL |     let _ = str.splitn(5, '=').next();
+   |             ^^^^^^^^^^^^^^^^^^ help: try this: `str.split('=')`
+
+error: unnecessary use of `splitn`
+  --> $DIR/needless_splitn.rs:29:13
+   |
+LL |     let _ = str.splitn(5, '=').nth(3);
+   |             ^^^^^^^^^^^^^^^^^^ help: try this: `str.split('=')`
+
+error: unnecessary use of `splitn`
+  --> $DIR/needless_splitn.rs:35:13
+   |
+LL |     let _ = s.splitn(2, '=').next()?;
+   |             ^^^^^^^^^^^^^^^^ help: try this: `s.split('=')`
+
+error: unnecessary use of `splitn`
+  --> $DIR/needless_splitn.rs:36:13
+   |
+LL |     let _ = s.splitn(2, '=').nth(0)?;
+   |             ^^^^^^^^^^^^^^^^ help: try this: `s.split('=')`
+
+error: unnecessary use of `rsplitn`
+  --> $DIR/needless_splitn.rs:37:13
+   |
+LL |     let _ = s.rsplitn(2, '=').next()?;
+   |             ^^^^^^^^^^^^^^^^^ help: try this: `s.rsplit('=')`
+
+error: unnecessary use of `rsplitn`
+  --> $DIR/needless_splitn.rs:38:13
+   |
+LL |     let _ = s.rsplitn(2, '=').nth(0)?;
+   |             ^^^^^^^^^^^^^^^^^ help: try this: `s.rsplit('=')`
+
+error: unnecessary use of `splitn`
+  --> $DIR/needless_splitn.rs:46:13
+   |
+LL |     let _ = "key=value".splitn(2, '=').nth(0).unwrap();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `"key=value".split('=')`
+
+error: aborting due to 13 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From a4d1837f07f65e4c440646799a0730f1d9a5f798 Mon Sep 17 00:00:00 2001
From: Yoav Lavi <yoavlavi122@gmail.com>
Date: Thu, 7 Apr 2022 20:21:47 +0200
Subject: unnecessary_string_new

---
 CHANGELOG.md                                       |  1 +
 clippy_lints/src/lib.register_all.rs               |  1 +
 clippy_lints/src/lib.register_lints.rs             |  1 +
 clippy_lints/src/lib.register_style.rs             |  1 +
 clippy_lints/src/lib.rs                            |  2 +
 clippy_lints/src/unnecessary_owned_empty_string.rs | 81 ++++++++++++++++++++++
 clippy_utils/src/paths.rs                          |  1 +
 tests/ui/unnecessary_owned_empty_string.fixed      | 22 ++++++
 tests/ui/unnecessary_owned_empty_string.rs         | 22 ++++++
 tests/ui/unnecessary_owned_empty_string.stderr     | 16 +++++
 10 files changed, 148 insertions(+)
 create mode 100644 clippy_lints/src/unnecessary_owned_empty_string.rs
 create mode 100644 tests/ui/unnecessary_owned_empty_string.fixed
 create mode 100644 tests/ui/unnecessary_owned_empty_string.rs
 create mode 100644 tests/ui/unnecessary_owned_empty_string.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index b4097ea86a5..e48413dc30c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3650,6 +3650,7 @@ Released 2018-09-13
 [`unnecessary_lazy_evaluations`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_lazy_evaluations
 [`unnecessary_mut_passed`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_mut_passed
 [`unnecessary_operation`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_operation
+[`unnecessary_owned_empty_string`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_owned_empty_string
 [`unnecessary_self_imports`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_self_imports
 [`unnecessary_sort_by`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_sort_by
 [`unnecessary_to_owned`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_to_owned
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 14ca93b5f3c..b601e37a4c8 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -310,6 +310,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(unit_types::UNIT_CMP),
     LintId::of(unnamed_address::FN_ADDRESS_COMPARISONS),
     LintId::of(unnamed_address::VTABLE_ADDRESS_COMPARISONS),
+    LintId::of(unnecessary_owned_empty_string::UNNECESSARY_OWNED_EMPTY_STRING),
     LintId::of(unnecessary_sort_by::UNNECESSARY_SORT_BY),
     LintId::of(unsafe_removed_from_name::UNSAFE_REMOVED_FROM_NAME),
     LintId::of(unused_io_amount::UNUSED_IO_AMOUNT),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 532590aaa5a..0a23e60fd2c 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -523,6 +523,7 @@ store.register_lints(&[
     unit_types::UNIT_CMP,
     unnamed_address::FN_ADDRESS_COMPARISONS,
     unnamed_address::VTABLE_ADDRESS_COMPARISONS,
+    unnecessary_owned_empty_string::UNNECESSARY_OWNED_EMPTY_STRING,
     unnecessary_self_imports::UNNECESSARY_SELF_IMPORTS,
     unnecessary_sort_by::UNNECESSARY_SORT_BY,
     unnecessary_wraps::UNNECESSARY_WRAPS,
diff --git a/clippy_lints/src/lib.register_style.rs b/clippy_lints/src/lib.register_style.rs
index 3114afac886..b014c11f0f4 100644
--- a/clippy_lints/src/lib.register_style.rs
+++ b/clippy_lints/src/lib.register_style.rs
@@ -106,6 +106,7 @@ store.register_group(true, "clippy::style", Some("clippy_style"), vec![
     LintId::of(single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS),
     LintId::of(tabs_in_doc_comments::TABS_IN_DOC_COMMENTS),
     LintId::of(to_digit_is_some::TO_DIGIT_IS_SOME),
+    LintId::of(unnecessary_owned_empty_string::UNNECESSARY_OWNED_EMPTY_STRING),
     LintId::of(unsafe_removed_from_name::UNSAFE_REMOVED_FROM_NAME),
     LintId::of(unused_unit::UNUSED_UNIT),
     LintId::of(upper_case_acronyms::UPPER_CASE_ACRONYMS),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index c9b836f9580..576a6611267 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -383,6 +383,7 @@ mod unit_hash;
 mod unit_return_expecting_ord;
 mod unit_types;
 mod unnamed_address;
+mod unnecessary_owned_empty_string;
 mod unnecessary_self_imports;
 mod unnecessary_sort_by;
 mod unnecessary_wraps;
@@ -868,6 +869,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     });
     store.register_early_pass(|| Box::new(crate_in_macro_def::CrateInMacroDef));
     store.register_early_pass(|| Box::new(empty_structs_with_brackets::EmptyStructsWithBrackets));
+    store.register_late_pass(|| Box::new(unnecessary_owned_empty_string::UnnecessaryOwnedEmptyString));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/unnecessary_owned_empty_string.rs b/clippy_lints/src/unnecessary_owned_empty_string.rs
new file mode 100644
index 00000000000..bb42c7816e7
--- /dev/null
+++ b/clippy_lints/src/unnecessary_owned_empty_string.rs
@@ -0,0 +1,81 @@
+use clippy_utils::{diagnostics::span_lint_and_sugg, ty::is_type_diagnostic_item};
+use clippy_utils::{match_def_path, paths};
+use if_chain::if_chain;
+use rustc_ast::ast::LitKind;
+use rustc_errors::Applicability;
+use rustc_hir::{BorrowKind, Expr, ExprKind, Mutability};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::sym;
+
+declare_clippy_lint! {
+    /// ### What it does
+    ///
+    /// Detects cases of owned empty strings being passed as an argument to a function expecting `&str`
+    ///
+    /// ### Why is this bad?
+    ///
+    /// This results in longer and less readable code
+    ///
+    /// ### Example
+    /// ```rust
+    /// vec!["1", "2", "3"].join(&String::new());
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// vec!["1", "2", "3"].join("");
+    /// ```
+    #[clippy::version = "1.62.0"]
+    pub UNNECESSARY_OWNED_EMPTY_STRING,
+    style,
+    "detects cases of references to owned empty strings being passed as an argument to a function expecting `&str`"
+}
+declare_lint_pass!(UnnecessaryOwnedEmptyString => [UNNECESSARY_OWNED_EMPTY_STRING]);
+
+impl<'tcx> LateLintPass<'tcx> for UnnecessaryOwnedEmptyString {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
+        if_chain! {
+            if let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Not, inner_expr) = expr.kind;
+            if let ExprKind::Call(fun, args) = inner_expr.kind;
+            if let ExprKind::Path(ref qpath) = fun.kind;
+            if let Some(fun_def_id) = cx.qpath_res(qpath, fun.hir_id).opt_def_id();
+            if let ty::Ref(_, inner_str, _) = cx.typeck_results().expr_ty_adjusted(expr).kind();
+            if inner_str.is_str();
+            then {
+                if match_def_path(cx, fun_def_id, &paths::STRING_NEW) {
+                     span_lint_and_sugg(
+                            cx,
+                            UNNECESSARY_OWNED_EMPTY_STRING,
+                            expr.span,
+                            "usage of `&String::new()` for a function expecting a `&str` argument",
+                            "try",
+                            "\"\"".to_owned(),
+                            Applicability::MachineApplicable,
+                        );
+                } else {
+                    if_chain! {
+                        if match_def_path(cx, fun_def_id, &paths::FROM_FROM);
+                        if let [.., last_arg] = args;
+                        if let ExprKind::Lit(spanned) = &last_arg.kind;
+                        if let LitKind::Str(symbol, _) = spanned.node;
+                        if symbol.is_empty();
+                        let inner_expr_type = cx.typeck_results().expr_ty(inner_expr);
+                        if is_type_diagnostic_item(cx, inner_expr_type, sym::String);
+                        then {
+                            span_lint_and_sugg(
+                                cx,
+                                UNNECESSARY_OWNED_EMPTY_STRING,
+                                expr.span,
+                                "usage of `&String::from(\"\")` for a function expecting a `&str` argument",
+                                "try",
+                                "\"\"".to_owned(),
+                                Applicability::MachineApplicable,
+                            );
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index 79e6e92dc0a..deb548daf2d 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -148,6 +148,7 @@ pub const CONVERT_IDENTITY: [&str; 3] = ["core", "convert", "identity"];
 pub const STD_FS_CREATE_DIR: [&str; 3] = ["std", "fs", "create_dir"];
 pub const STRING_AS_MUT_STR: [&str; 4] = ["alloc", "string", "String", "as_mut_str"];
 pub const STRING_AS_STR: [&str; 4] = ["alloc", "string", "String", "as_str"];
+pub const STRING_NEW: [&str; 4] = ["alloc", "string", "String", "new"];
 pub const STR_ENDS_WITH: [&str; 4] = ["core", "str", "<impl str>", "ends_with"];
 pub const STR_FROM_UTF8: [&str; 4] = ["core", "str", "converts", "from_utf8"];
 pub const STR_LEN: [&str; 4] = ["core", "str", "<impl str>", "len"];
diff --git a/tests/ui/unnecessary_owned_empty_string.fixed b/tests/ui/unnecessary_owned_empty_string.fixed
new file mode 100644
index 00000000000..cd69e956fd4
--- /dev/null
+++ b/tests/ui/unnecessary_owned_empty_string.fixed
@@ -0,0 +1,22 @@
+// run-rustfix
+
+#![warn(clippy::unnecessary_owned_empty_string)]
+
+fn ref_str_argument(_value: &str) {}
+
+#[allow(clippy::ptr_arg)]
+fn ref_string_argument(_value: &String) {}
+
+fn main() {
+    // should be linted
+    ref_str_argument("");
+
+    // should be linted
+    ref_str_argument("");
+
+    // should not be linted
+    ref_str_argument("");
+
+    // should not be linted
+    ref_string_argument(&String::new());
+}
diff --git a/tests/ui/unnecessary_owned_empty_string.rs b/tests/ui/unnecessary_owned_empty_string.rs
new file mode 100644
index 00000000000..3fbba156240
--- /dev/null
+++ b/tests/ui/unnecessary_owned_empty_string.rs
@@ -0,0 +1,22 @@
+// run-rustfix
+
+#![warn(clippy::unnecessary_owned_empty_string)]
+
+fn ref_str_argument(_value: &str) {}
+
+#[allow(clippy::ptr_arg)]
+fn ref_string_argument(_value: &String) {}
+
+fn main() {
+    // should be linted
+    ref_str_argument(&String::new());
+
+    // should be linted
+    ref_str_argument(&String::from(""));
+
+    // should not be linted
+    ref_str_argument("");
+
+    // should not be linted
+    ref_string_argument(&String::new());
+}
diff --git a/tests/ui/unnecessary_owned_empty_string.stderr b/tests/ui/unnecessary_owned_empty_string.stderr
new file mode 100644
index 00000000000..c32372290d1
--- /dev/null
+++ b/tests/ui/unnecessary_owned_empty_string.stderr
@@ -0,0 +1,16 @@
+error: usage of `&String::new()` for a function expecting a `&str` argument
+  --> $DIR/unnecessary_owned_empty_string.rs:12:22
+   |
+LL |     ref_str_argument(&String::new());
+   |                      ^^^^^^^^^^^^^^ help: try: `""`
+   |
+   = note: `-D clippy::unnecessary-owned-empty-string` implied by `-D warnings`
+
+error: usage of `&String::from("")` for a function expecting a `&str` argument
+  --> $DIR/unnecessary_owned_empty_string.rs:15:22
+   |
+LL |     ref_str_argument(&String::from(""));
+   |                      ^^^^^^^^^^^^^^^^^ help: try: `""`
+
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 10201370a1509b806b9e2a83ded6b132466291b8 Mon Sep 17 00:00:00 2001
From: Yoav Lavi <yoavlavi122@gmail.com>
Date: Mon, 11 Apr 2022 13:05:42 +0200
Subject: unnecessary_owned_empty_string -> unnecessary_owned_empty_strings

---
 CHANGELOG.md                                       |  2 +-
 clippy_lints/src/lib.register_all.rs               |  2 +-
 clippy_lints/src/lib.register_lints.rs             |  2 +-
 clippy_lints/src/lib.register_style.rs             |  2 +-
 clippy_lints/src/lib.rs                            |  4 +-
 clippy_lints/src/unnecessary_owned_empty_string.rs | 81 ----------------------
 .../src/unnecessary_owned_empty_strings.rs         | 81 ++++++++++++++++++++++
 tests/ui/unnecessary_owned_empty_string.fixed      | 22 ------
 tests/ui/unnecessary_owned_empty_string.rs         | 22 ------
 tests/ui/unnecessary_owned_empty_string.stderr     | 16 -----
 tests/ui/unnecessary_owned_empty_strings.fixed     | 22 ++++++
 tests/ui/unnecessary_owned_empty_strings.rs        | 22 ++++++
 tests/ui/unnecessary_owned_empty_strings.stderr    | 16 +++++
 13 files changed, 147 insertions(+), 147 deletions(-)
 delete mode 100644 clippy_lints/src/unnecessary_owned_empty_string.rs
 create mode 100644 clippy_lints/src/unnecessary_owned_empty_strings.rs
 delete mode 100644 tests/ui/unnecessary_owned_empty_string.fixed
 delete mode 100644 tests/ui/unnecessary_owned_empty_string.rs
 delete mode 100644 tests/ui/unnecessary_owned_empty_string.stderr
 create mode 100644 tests/ui/unnecessary_owned_empty_strings.fixed
 create mode 100644 tests/ui/unnecessary_owned_empty_strings.rs
 create mode 100644 tests/ui/unnecessary_owned_empty_strings.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index e48413dc30c..44a36870108 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3650,7 +3650,7 @@ Released 2018-09-13
 [`unnecessary_lazy_evaluations`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_lazy_evaluations
 [`unnecessary_mut_passed`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_mut_passed
 [`unnecessary_operation`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_operation
-[`unnecessary_owned_empty_string`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_owned_empty_string
+[`unnecessary_owned_empty_strings`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_owned_empty_strings
 [`unnecessary_self_imports`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_self_imports
 [`unnecessary_sort_by`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_sort_by
 [`unnecessary_to_owned`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_to_owned
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index b601e37a4c8..02ba7835639 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -310,7 +310,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(unit_types::UNIT_CMP),
     LintId::of(unnamed_address::FN_ADDRESS_COMPARISONS),
     LintId::of(unnamed_address::VTABLE_ADDRESS_COMPARISONS),
-    LintId::of(unnecessary_owned_empty_string::UNNECESSARY_OWNED_EMPTY_STRING),
+    LintId::of(unnecessary_owned_empty_strings::UNNECESSARY_OWNED_EMPTY_STRINGS),
     LintId::of(unnecessary_sort_by::UNNECESSARY_SORT_BY),
     LintId::of(unsafe_removed_from_name::UNSAFE_REMOVED_FROM_NAME),
     LintId::of(unused_io_amount::UNUSED_IO_AMOUNT),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 0a23e60fd2c..704e79885cf 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -523,7 +523,7 @@ store.register_lints(&[
     unit_types::UNIT_CMP,
     unnamed_address::FN_ADDRESS_COMPARISONS,
     unnamed_address::VTABLE_ADDRESS_COMPARISONS,
-    unnecessary_owned_empty_string::UNNECESSARY_OWNED_EMPTY_STRING,
+    unnecessary_owned_empty_strings::UNNECESSARY_OWNED_EMPTY_STRINGS,
     unnecessary_self_imports::UNNECESSARY_SELF_IMPORTS,
     unnecessary_sort_by::UNNECESSARY_SORT_BY,
     unnecessary_wraps::UNNECESSARY_WRAPS,
diff --git a/clippy_lints/src/lib.register_style.rs b/clippy_lints/src/lib.register_style.rs
index b014c11f0f4..f52fe97ed23 100644
--- a/clippy_lints/src/lib.register_style.rs
+++ b/clippy_lints/src/lib.register_style.rs
@@ -106,7 +106,7 @@ store.register_group(true, "clippy::style", Some("clippy_style"), vec![
     LintId::of(single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS),
     LintId::of(tabs_in_doc_comments::TABS_IN_DOC_COMMENTS),
     LintId::of(to_digit_is_some::TO_DIGIT_IS_SOME),
-    LintId::of(unnecessary_owned_empty_string::UNNECESSARY_OWNED_EMPTY_STRING),
+    LintId::of(unnecessary_owned_empty_strings::UNNECESSARY_OWNED_EMPTY_STRINGS),
     LintId::of(unsafe_removed_from_name::UNSAFE_REMOVED_FROM_NAME),
     LintId::of(unused_unit::UNUSED_UNIT),
     LintId::of(upper_case_acronyms::UPPER_CASE_ACRONYMS),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 576a6611267..74ade422dc8 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -383,7 +383,7 @@ mod unit_hash;
 mod unit_return_expecting_ord;
 mod unit_types;
 mod unnamed_address;
-mod unnecessary_owned_empty_string;
+mod unnecessary_owned_empty_strings;
 mod unnecessary_self_imports;
 mod unnecessary_sort_by;
 mod unnecessary_wraps;
@@ -869,7 +869,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     });
     store.register_early_pass(|| Box::new(crate_in_macro_def::CrateInMacroDef));
     store.register_early_pass(|| Box::new(empty_structs_with_brackets::EmptyStructsWithBrackets));
-    store.register_late_pass(|| Box::new(unnecessary_owned_empty_string::UnnecessaryOwnedEmptyString));
+    store.register_late_pass(|| Box::new(unnecessary_owned_empty_strings::UnnecessaryOwnedEmptyStrings));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/unnecessary_owned_empty_string.rs b/clippy_lints/src/unnecessary_owned_empty_string.rs
deleted file mode 100644
index bb42c7816e7..00000000000
--- a/clippy_lints/src/unnecessary_owned_empty_string.rs
+++ /dev/null
@@ -1,81 +0,0 @@
-use clippy_utils::{diagnostics::span_lint_and_sugg, ty::is_type_diagnostic_item};
-use clippy_utils::{match_def_path, paths};
-use if_chain::if_chain;
-use rustc_ast::ast::LitKind;
-use rustc_errors::Applicability;
-use rustc_hir::{BorrowKind, Expr, ExprKind, Mutability};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::sym;
-
-declare_clippy_lint! {
-    /// ### What it does
-    ///
-    /// Detects cases of owned empty strings being passed as an argument to a function expecting `&str`
-    ///
-    /// ### Why is this bad?
-    ///
-    /// This results in longer and less readable code
-    ///
-    /// ### Example
-    /// ```rust
-    /// vec!["1", "2", "3"].join(&String::new());
-    /// ```
-    /// Use instead:
-    /// ```rust
-    /// vec!["1", "2", "3"].join("");
-    /// ```
-    #[clippy::version = "1.62.0"]
-    pub UNNECESSARY_OWNED_EMPTY_STRING,
-    style,
-    "detects cases of references to owned empty strings being passed as an argument to a function expecting `&str`"
-}
-declare_lint_pass!(UnnecessaryOwnedEmptyString => [UNNECESSARY_OWNED_EMPTY_STRING]);
-
-impl<'tcx> LateLintPass<'tcx> for UnnecessaryOwnedEmptyString {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
-        if_chain! {
-            if let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Not, inner_expr) = expr.kind;
-            if let ExprKind::Call(fun, args) = inner_expr.kind;
-            if let ExprKind::Path(ref qpath) = fun.kind;
-            if let Some(fun_def_id) = cx.qpath_res(qpath, fun.hir_id).opt_def_id();
-            if let ty::Ref(_, inner_str, _) = cx.typeck_results().expr_ty_adjusted(expr).kind();
-            if inner_str.is_str();
-            then {
-                if match_def_path(cx, fun_def_id, &paths::STRING_NEW) {
-                     span_lint_and_sugg(
-                            cx,
-                            UNNECESSARY_OWNED_EMPTY_STRING,
-                            expr.span,
-                            "usage of `&String::new()` for a function expecting a `&str` argument",
-                            "try",
-                            "\"\"".to_owned(),
-                            Applicability::MachineApplicable,
-                        );
-                } else {
-                    if_chain! {
-                        if match_def_path(cx, fun_def_id, &paths::FROM_FROM);
-                        if let [.., last_arg] = args;
-                        if let ExprKind::Lit(spanned) = &last_arg.kind;
-                        if let LitKind::Str(symbol, _) = spanned.node;
-                        if symbol.is_empty();
-                        let inner_expr_type = cx.typeck_results().expr_ty(inner_expr);
-                        if is_type_diagnostic_item(cx, inner_expr_type, sym::String);
-                        then {
-                            span_lint_and_sugg(
-                                cx,
-                                UNNECESSARY_OWNED_EMPTY_STRING,
-                                expr.span,
-                                "usage of `&String::from(\"\")` for a function expecting a `&str` argument",
-                                "try",
-                                "\"\"".to_owned(),
-                                Applicability::MachineApplicable,
-                            );
-                        }
-                    }
-                }
-            }
-        }
-    }
-}
diff --git a/clippy_lints/src/unnecessary_owned_empty_strings.rs b/clippy_lints/src/unnecessary_owned_empty_strings.rs
new file mode 100644
index 00000000000..8a4f4c0ad97
--- /dev/null
+++ b/clippy_lints/src/unnecessary_owned_empty_strings.rs
@@ -0,0 +1,81 @@
+use clippy_utils::{diagnostics::span_lint_and_sugg, ty::is_type_diagnostic_item};
+use clippy_utils::{match_def_path, paths};
+use if_chain::if_chain;
+use rustc_ast::ast::LitKind;
+use rustc_errors::Applicability;
+use rustc_hir::{BorrowKind, Expr, ExprKind, Mutability};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::sym;
+
+declare_clippy_lint! {
+    /// ### What it does
+    ///
+    /// Detects cases of owned empty strings being passed as an argument to a function expecting `&str`
+    ///
+    /// ### Why is this bad?
+    ///
+    /// This results in longer and less readable code
+    ///
+    /// ### Example
+    /// ```rust
+    /// vec!["1", "2", "3"].join(&String::new());
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// vec!["1", "2", "3"].join("");
+    /// ```
+    #[clippy::version = "1.62.0"]
+    pub UNNECESSARY_OWNED_EMPTY_STRINGS,
+    style,
+    "detects cases of references to owned empty strings being passed as an argument to a function expecting `&str`"
+}
+declare_lint_pass!(UnnecessaryOwnedEmptyStrings => [UNNECESSARY_OWNED_EMPTY_STRINGS]);
+
+impl<'tcx> LateLintPass<'tcx> for UnnecessaryOwnedEmptyStrings {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
+        if_chain! {
+            if let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Not, inner_expr) = expr.kind;
+            if let ExprKind::Call(fun, args) = inner_expr.kind;
+            if let ExprKind::Path(ref qpath) = fun.kind;
+            if let Some(fun_def_id) = cx.qpath_res(qpath, fun.hir_id).opt_def_id();
+            if let ty::Ref(_, inner_str, _) = cx.typeck_results().expr_ty_adjusted(expr).kind();
+            if inner_str.is_str();
+            then {
+                if match_def_path(cx, fun_def_id, &paths::STRING_NEW) {
+                     span_lint_and_sugg(
+                            cx,
+                            UNNECESSARY_OWNED_EMPTY_STRINGS,
+                            expr.span,
+                            "usage of `&String::new()` for a function expecting a `&str` argument",
+                            "try",
+                            "\"\"".to_owned(),
+                            Applicability::MachineApplicable,
+                        );
+                } else {
+                    if_chain! {
+                        if match_def_path(cx, fun_def_id, &paths::FROM_FROM);
+                        if let [.., last_arg] = args;
+                        if let ExprKind::Lit(spanned) = &last_arg.kind;
+                        if let LitKind::Str(symbol, _) = spanned.node;
+                        if symbol.is_empty();
+                        let inner_expr_type = cx.typeck_results().expr_ty(inner_expr);
+                        if is_type_diagnostic_item(cx, inner_expr_type, sym::String);
+                        then {
+                            span_lint_and_sugg(
+                                cx,
+                                UNNECESSARY_OWNED_EMPTY_STRINGS,
+                                expr.span,
+                                "usage of `&String::from(\"\")` for a function expecting a `&str` argument",
+                                "try",
+                                "\"\"".to_owned(),
+                                Applicability::MachineApplicable,
+                            );
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/tests/ui/unnecessary_owned_empty_string.fixed b/tests/ui/unnecessary_owned_empty_string.fixed
deleted file mode 100644
index cd69e956fd4..00000000000
--- a/tests/ui/unnecessary_owned_empty_string.fixed
+++ /dev/null
@@ -1,22 +0,0 @@
-// run-rustfix
-
-#![warn(clippy::unnecessary_owned_empty_string)]
-
-fn ref_str_argument(_value: &str) {}
-
-#[allow(clippy::ptr_arg)]
-fn ref_string_argument(_value: &String) {}
-
-fn main() {
-    // should be linted
-    ref_str_argument("");
-
-    // should be linted
-    ref_str_argument("");
-
-    // should not be linted
-    ref_str_argument("");
-
-    // should not be linted
-    ref_string_argument(&String::new());
-}
diff --git a/tests/ui/unnecessary_owned_empty_string.rs b/tests/ui/unnecessary_owned_empty_string.rs
deleted file mode 100644
index 3fbba156240..00000000000
--- a/tests/ui/unnecessary_owned_empty_string.rs
+++ /dev/null
@@ -1,22 +0,0 @@
-// run-rustfix
-
-#![warn(clippy::unnecessary_owned_empty_string)]
-
-fn ref_str_argument(_value: &str) {}
-
-#[allow(clippy::ptr_arg)]
-fn ref_string_argument(_value: &String) {}
-
-fn main() {
-    // should be linted
-    ref_str_argument(&String::new());
-
-    // should be linted
-    ref_str_argument(&String::from(""));
-
-    // should not be linted
-    ref_str_argument("");
-
-    // should not be linted
-    ref_string_argument(&String::new());
-}
diff --git a/tests/ui/unnecessary_owned_empty_string.stderr b/tests/ui/unnecessary_owned_empty_string.stderr
deleted file mode 100644
index c32372290d1..00000000000
--- a/tests/ui/unnecessary_owned_empty_string.stderr
+++ /dev/null
@@ -1,16 +0,0 @@
-error: usage of `&String::new()` for a function expecting a `&str` argument
-  --> $DIR/unnecessary_owned_empty_string.rs:12:22
-   |
-LL |     ref_str_argument(&String::new());
-   |                      ^^^^^^^^^^^^^^ help: try: `""`
-   |
-   = note: `-D clippy::unnecessary-owned-empty-string` implied by `-D warnings`
-
-error: usage of `&String::from("")` for a function expecting a `&str` argument
-  --> $DIR/unnecessary_owned_empty_string.rs:15:22
-   |
-LL |     ref_str_argument(&String::from(""));
-   |                      ^^^^^^^^^^^^^^^^^ help: try: `""`
-
-error: aborting due to 2 previous errors
-
diff --git a/tests/ui/unnecessary_owned_empty_strings.fixed b/tests/ui/unnecessary_owned_empty_strings.fixed
new file mode 100644
index 00000000000..f95f91329a2
--- /dev/null
+++ b/tests/ui/unnecessary_owned_empty_strings.fixed
@@ -0,0 +1,22 @@
+// run-rustfix
+
+#![warn(clippy::unnecessary_owned_empty_strings)]
+
+fn ref_str_argument(_value: &str) {}
+
+#[allow(clippy::ptr_arg)]
+fn ref_string_argument(_value: &String) {}
+
+fn main() {
+    // should be linted
+    ref_str_argument("");
+
+    // should be linted
+    ref_str_argument("");
+
+    // should not be linted
+    ref_str_argument("");
+
+    // should not be linted
+    ref_string_argument(&String::new());
+}
diff --git a/tests/ui/unnecessary_owned_empty_strings.rs b/tests/ui/unnecessary_owned_empty_strings.rs
new file mode 100644
index 00000000000..0cbdc151ed9
--- /dev/null
+++ b/tests/ui/unnecessary_owned_empty_strings.rs
@@ -0,0 +1,22 @@
+// run-rustfix
+
+#![warn(clippy::unnecessary_owned_empty_strings)]
+
+fn ref_str_argument(_value: &str) {}
+
+#[allow(clippy::ptr_arg)]
+fn ref_string_argument(_value: &String) {}
+
+fn main() {
+    // should be linted
+    ref_str_argument(&String::new());
+
+    // should be linted
+    ref_str_argument(&String::from(""));
+
+    // should not be linted
+    ref_str_argument("");
+
+    // should not be linted
+    ref_string_argument(&String::new());
+}
diff --git a/tests/ui/unnecessary_owned_empty_strings.stderr b/tests/ui/unnecessary_owned_empty_strings.stderr
new file mode 100644
index 00000000000..46bc4597b33
--- /dev/null
+++ b/tests/ui/unnecessary_owned_empty_strings.stderr
@@ -0,0 +1,16 @@
+error: usage of `&String::new()` for a function expecting a `&str` argument
+  --> $DIR/unnecessary_owned_empty_strings.rs:12:22
+   |
+LL |     ref_str_argument(&String::new());
+   |                      ^^^^^^^^^^^^^^ help: try: `""`
+   |
+   = note: `-D clippy::unnecessary-owned-empty-strings` implied by `-D warnings`
+
+error: usage of `&String::from("")` for a function expecting a `&str` argument
+  --> $DIR/unnecessary_owned_empty_strings.rs:15:22
+   |
+LL |     ref_str_argument(&String::from(""));
+   |                      ^^^^^^^^^^^^^^^^^ help: try: `""`
+
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From c82dd0f36ebeba506d3722f9def3ec17ab03b528 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Mon, 11 Apr 2022 13:18:27 -0400
Subject: Fix ICE in `undocumented_unsafe_blocks`

---
 clippy_lints/src/undocumented_unsafe_blocks.rs |  7 ++++---
 tests/ui/crashes/auxiliary/ice-8681-aux.rs     |  6 ++++++
 tests/ui/crashes/ice-8681.rs                   | 10 ++++++++++
 3 files changed, 20 insertions(+), 3 deletions(-)
 create mode 100644 tests/ui/crashes/auxiliary/ice-8681-aux.rs
 create mode 100644 tests/ui/crashes/ice-8681.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/undocumented_unsafe_blocks.rs b/clippy_lints/src/undocumented_unsafe_blocks.rs
index c0947685fa1..bc57e9b992c 100644
--- a/clippy_lints/src/undocumented_unsafe_blocks.rs
+++ b/clippy_lints/src/undocumented_unsafe_blocks.rs
@@ -156,8 +156,9 @@ fn text_has_safety_comment(src: &str, line_starts: &[BytePos], offset: usize) ->
         .array_windows::<2>()
         .rev()
         .map_while(|[start, end]| {
-            src.get(start.to_usize() - offset..end.to_usize() - offset)
-                .map(|text| (start.to_usize(), text.trim_start()))
+            let start = start.to_usize() - offset;
+            let end = end.to_usize() - offset;
+            src.get(start..end).map(|text| (start, text.trim_start()))
         })
         .filter(|(_, text)| !text.is_empty());
 
@@ -182,7 +183,7 @@ fn text_has_safety_comment(src: &str, line_starts: &[BytePos], offset: usize) ->
     let (mut line_start, mut line) = (line_start, line);
     loop {
         if line.starts_with("/*") {
-            let src = src[line_start..line_starts.last().unwrap().to_usize()].trim_start();
+            let src = src[line_start..line_starts.last().unwrap().to_usize() - offset].trim_start();
             let mut tokens = tokenize(src);
             return src[..tokens.next().unwrap().len]
                 .to_ascii_uppercase()
diff --git a/tests/ui/crashes/auxiliary/ice-8681-aux.rs b/tests/ui/crashes/auxiliary/ice-8681-aux.rs
new file mode 100644
index 00000000000..95b63151325
--- /dev/null
+++ b/tests/ui/crashes/auxiliary/ice-8681-aux.rs
@@ -0,0 +1,6 @@
+pub fn foo(x: &u32) -> u32 {
+    /* Safety:
+     * This is totally ok.
+     */
+    unsafe { *(x as *const u32) }
+}
diff --git a/tests/ui/crashes/ice-8681.rs b/tests/ui/crashes/ice-8681.rs
new file mode 100644
index 00000000000..ee14f011f63
--- /dev/null
+++ b/tests/ui/crashes/ice-8681.rs
@@ -0,0 +1,10 @@
+// aux-build: ice-8681-aux.rs
+
+#![warn(clippy::undocumented_unsafe_blocks)]
+
+#[path = "auxiliary/ice-8681-aux.rs"]
+mod ice_8681_aux;
+
+fn main() {
+    let _ = ice_8681_aux::foo(&0u32);
+}
-- 
cgit 1.4.1-3-g733a5


From 4a21082da22f6ff48a77f1ded2a6b5f02f31aa78 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Mon, 11 Apr 2022 18:54:44 +0100
Subject: Fix subtraction overflow in `cast_possible_truncation`

---
 clippy_lints/src/casts/cast_possible_truncation.rs | 20 +++++++++-----------
 tests/ui/cast.rs                                   | 14 +++++++++++---
 tests/ui/cast.stderr                               | 14 +++++++++++++-
 3 files changed, 33 insertions(+), 15 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/cast_possible_truncation.rs b/clippy_lints/src/casts/cast_possible_truncation.rs
index 421bd6f53f7..64f87c80f8d 100644
--- a/clippy_lints/src/casts/cast_possible_truncation.rs
+++ b/clippy_lints/src/casts/cast_possible_truncation.rs
@@ -29,21 +29,19 @@ fn apply_reductions(cx: &LateContext<'_>, nbits: u64, expr: &Expr<'_>, signed: b
         ExprKind::Block(block, _) => block.expr.map_or(nbits, |e| apply_reductions(cx, nbits, e, signed)),
         ExprKind::Binary(op, left, right) => match op.node {
             BinOpKind::Div => {
-                apply_reductions(cx, nbits, left, signed)
-                    - (if signed {
-                        0 // let's be conservative here
-                    } else {
-                        // by dividing by 1, we remove 0 bits, etc.
-                        get_constant_bits(cx, right).map_or(0, |b| b.saturating_sub(1))
-                    })
+                apply_reductions(cx, nbits, left, signed).saturating_sub(if signed {
+                    // let's be conservative here
+                    0
+                } else {
+                    // by dividing by 1, we remove 0 bits, etc.
+                    get_constant_bits(cx, right).map_or(0, |b| b.saturating_sub(1))
+                })
             },
             BinOpKind::Rem | BinOpKind::BitAnd => get_constant_bits(cx, right)
                 .unwrap_or(u64::max_value())
                 .min(apply_reductions(cx, nbits, left, signed)),
-            BinOpKind::Shr => {
-                apply_reductions(cx, nbits, left, signed)
-                    - constant_int(cx, right).map_or(0, |s| u64::try_from(s).expect("shift too high"))
-            },
+            BinOpKind::Shr => apply_reductions(cx, nbits, left, signed)
+                .saturating_sub(constant_int(cx, right).map_or(0, |s| u64::try_from(s).expect("shift too high"))),
             _ => nbits,
         },
         ExprKind::MethodCall(method, [left, right], _) => {
diff --git a/tests/ui/cast.rs b/tests/ui/cast.rs
index cf85a5ca931..e6031e9adae 100644
--- a/tests/ui/cast.rs
+++ b/tests/ui/cast.rs
@@ -1,13 +1,13 @@
 #![feature(repr128)]
 #![allow(incomplete_features)]
-
-#[warn(
+#![warn(
     clippy::cast_precision_loss,
     clippy::cast_possible_truncation,
     clippy::cast_sign_loss,
     clippy::cast_possible_wrap
 )]
-#[allow(clippy::cast_abs_to_unsigned, clippy::no_effect, clippy::unnecessary_operation)]
+#![allow(clippy::cast_abs_to_unsigned, clippy::no_effect, clippy::unnecessary_operation)]
+
 fn main() {
     // Test clippy::cast_precision_loss
     let x0 = 1i32;
@@ -252,3 +252,11 @@ fn main() {
         }
     }
 }
+
+fn avoid_subtract_overflow(q: u32) {
+    let c = (q >> 16) as u8;
+    c as usize;
+
+    let c = (q / 1000) as u8;
+    c as usize;
+}
diff --git a/tests/ui/cast.stderr b/tests/ui/cast.stderr
index 7a68c0984f1..0c63b4af308 100644
--- a/tests/ui/cast.stderr
+++ b/tests/ui/cast.stderr
@@ -194,5 +194,17 @@ error: casting `main::E10` to `u16` may truncate the value
 LL |             let _ = self as u16;
    |                     ^^^^^^^^^^^
 
-error: aborting due to 31 previous errors
+error: casting `u32` to `u8` may truncate the value
+  --> $DIR/cast.rs:257:13
+   |
+LL |     let c = (q >> 16) as u8;
+   |             ^^^^^^^^^^^^^^^
+
+error: casting `u32` to `u8` may truncate the value
+  --> $DIR/cast.rs:260:13
+   |
+LL |     let c = (q / 1000) as u8;
+   |             ^^^^^^^^^^^^^^^^
+
+error: aborting due to 33 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 9716a9eff0d68c92fd064b293f0ffbd083645fa5 Mon Sep 17 00:00:00 2001
From: kyoto7250 <50972773+kyoto7250@users.noreply.github.com>
Date: Tue, 12 Apr 2022 04:03:48 +0900
Subject: adding condition for map_clone message

if msrv < 1.36, the message tells , but the suggestion is
---
 clippy_lints/src/map_clone.rs                          | 2 +-
 tests/ui-toml/min_rust_version/min_rust_version.stderr | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/map_clone.rs b/clippy_lints/src/map_clone.rs
index e233300e26a..a03d5d54065 100644
--- a/clippy_lints/src/map_clone.rs
+++ b/clippy_lints/src/map_clone.rs
@@ -143,7 +143,7 @@ fn lint_needless_cloning(cx: &LateContext<'_>, root: Span, receiver: Span) {
 impl MapClone {
     fn lint_explicit_closure(&self, cx: &LateContext<'_>, replace: Span, root: Span, is_copy: bool) {
         let mut applicability = Applicability::MachineApplicable;
-        let message = if is_copy {
+        let message = if is_copy && meets_msrv(self.msrv.as_ref(), &msrvs::ITERATOR_COPIED) {
             "you are using an explicit closure for copying elements"
         } else {
             "you are using an explicit closure for cloning elements"
diff --git a/tests/ui-toml/min_rust_version/min_rust_version.stderr b/tests/ui-toml/min_rust_version/min_rust_version.stderr
index a1e7361c0cb..5dae5af7eb5 100644
--- a/tests/ui-toml/min_rust_version/min_rust_version.stderr
+++ b/tests/ui-toml/min_rust_version/min_rust_version.stderr
@@ -1,4 +1,4 @@
-error: you are using an explicit closure for copying elements
+error: you are using an explicit closure for cloning elements
   --> $DIR/min_rust_version.rs:74:26
    |
 LL |     let _: Option<u64> = Some(&16).map(|b| *b);
-- 
cgit 1.4.1-3-g733a5


From 40224f46c0158ff8bf6657f2272dba9ec2ee96d7 Mon Sep 17 00:00:00 2001
From: kyoto7250 <50972773+kyoto7250@users.noreply.github.com>
Date: Tue, 12 Apr 2022 09:49:00 +0900
Subject: refactor: Put together an if statement

---
 clippy_lints/src/map_clone.rs | 12 ++++--------
 1 file changed, 4 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/map_clone.rs b/clippy_lints/src/map_clone.rs
index a03d5d54065..ceb66947d02 100644
--- a/clippy_lints/src/map_clone.rs
+++ b/clippy_lints/src/map_clone.rs
@@ -143,15 +143,11 @@ fn lint_needless_cloning(cx: &LateContext<'_>, root: Span, receiver: Span) {
 impl MapClone {
     fn lint_explicit_closure(&self, cx: &LateContext<'_>, replace: Span, root: Span, is_copy: bool) {
         let mut applicability = Applicability::MachineApplicable;
-        let message = if is_copy && meets_msrv(self.msrv.as_ref(), &msrvs::ITERATOR_COPIED) {
-            "you are using an explicit closure for copying elements"
-        } else {
-            "you are using an explicit closure for cloning elements"
-        };
-        let sugg_method = if is_copy && meets_msrv(self.msrv.as_ref(), &msrvs::ITERATOR_COPIED) {
-            "copied"
+
+        let (message, sugg_method) = if is_copy && meets_msrv(self.msrv.as_ref(), &msrvs::ITERATOR_COPIED) {
+            ("you are using an explicit closure for copying elements", "copied")
         } else {
-            "cloned"
+            ("you are using an explicit closure for cloning elements", "cloned")
         };
 
         span_lint_and_sugg(
-- 
cgit 1.4.1-3-g733a5


From 739f273739a1e4da98d1222f3316d831ae187bc2 Mon Sep 17 00:00:00 2001
From: "Bruno A. Muciño" <mucinoab@gmail.com>
Date: Mon, 11 Apr 2022 22:47:04 -0500
Subject: Do not apply `rest_pat_in_fully_bound_structs` on `#[non_exhaustive]`
 structs

---
 .../src/matches/rest_pat_in_fully_bound_struct.rs         |  1 +
 tests/ui/rest_pat_in_fully_bound_structs.rs               | 15 +++++++++++++++
 2 files changed, 16 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/rest_pat_in_fully_bound_struct.rs b/clippy_lints/src/matches/rest_pat_in_fully_bound_struct.rs
index 5076239a57c..0aadb482acd 100644
--- a/clippy_lints/src/matches/rest_pat_in_fully_bound_struct.rs
+++ b/clippy_lints/src/matches/rest_pat_in_fully_bound_struct.rs
@@ -14,6 +14,7 @@ pub(crate) fn check(cx: &LateContext<'_>, pat: &Pat<'_>) {
         if let ty::Adt(def, _) = ty.kind();
         if def.is_struct() || def.is_union();
         if fields.len() == def.non_enum_variant().fields.len();
+        if !def.non_enum_variant().is_field_list_non_exhaustive();
 
         then {
             span_lint_and_help(
diff --git a/tests/ui/rest_pat_in_fully_bound_structs.rs b/tests/ui/rest_pat_in_fully_bound_structs.rs
index 38fc9969804..086331af6b5 100644
--- a/tests/ui/rest_pat_in_fully_bound_structs.rs
+++ b/tests/ui/rest_pat_in_fully_bound_structs.rs
@@ -39,4 +39,19 @@ fn main() {
 
     // No lint
     foo!(a_struct);
+
+    #[non_exhaustive]
+    struct B {
+        a: u32,
+        b: u32,
+        c: u64,
+    }
+
+    let b_struct = B { a: 5, b: 42, c: 342 };
+
+    match b_struct {
+        B { a: 5, b: 42, .. } => {},
+        B { a: 0, b: 0, c: 128, .. } => {}, // No Lint
+        _ => {},
+    }
 }
-- 
cgit 1.4.1-3-g733a5


From 214fba7ed4a8e2199d42733cc191b956f0c2b017 Mon Sep 17 00:00:00 2001
From: flip1995 <philipp.krones@embecosm.com>
Date: Tue, 12 Apr 2022 15:27:28 +0200
Subject: Prevent infinite (exponential) recursion in only_used_in_recursion

This simplifies the visitor code a bit and prevents checking expressions
multiple times. I still think this lint should be removed for now,
because its code isn't really tested.
---
 clippy_lints/src/only_used_in_recursion.rs | 47 ++++++++++--------------------
 1 file changed, 16 insertions(+), 31 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/only_used_in_recursion.rs b/clippy_lints/src/only_used_in_recursion.rs
index 8e61f234776..f946fc11192 100644
--- a/clippy_lints/src/only_used_in_recursion.rs
+++ b/clippy_lints/src/only_used_in_recursion.rs
@@ -8,7 +8,7 @@ use rustc_errors::Applicability;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::def_id::DefId;
 use rustc_hir::definitions::{DefPathData, DisambiguatedDefPathData};
-use rustc_hir::intravisit::{walk_expr, FnKind, Visitor};
+use rustc_hir::intravisit::{walk_expr, walk_stmt, FnKind, Visitor};
 use rustc_hir::{
     Arm, Block, Body, Expr, ExprKind, Guard, HirId, ImplicitSelfKind, Let, Local, Pat, PatKind, Path, PathSegment,
     QPath, Stmt, StmtKind, TyKind, UnOp,
@@ -145,7 +145,8 @@ impl<'tcx> LateLintPass<'tcx> for OnlyUsedInRecursion {
                 is_method: matches!(kind, FnKind::Method(..)),
                 has_self,
                 ty_res,
-                ty_ctx: cx.tcx,
+                tcx: cx.tcx,
+                visited_exprs: FxHashSet::default(),
             };
 
             visitor.visit_expr(&body.value);
@@ -206,19 +207,13 @@ impl<'tcx> LateLintPass<'tcx> for OnlyUsedInRecursion {
 }
 
 pub fn is_primitive(ty: Ty<'_>) -> bool {
-    match ty.kind() {
-        ty::Bool | ty::Char | ty::Int(_) | ty::Uint(_) | ty::Float(_) | ty::Str => true,
-        ty::Ref(_, t, _) => is_primitive(*t),
-        _ => false,
-    }
+    let ty = ty.peel_refs();
+    ty.is_primitive() || ty.is_str()
 }
 
 pub fn is_array(ty: Ty<'_>) -> bool {
-    match ty.kind() {
-        ty::Array(..) | ty::Slice(..) => true,
-        ty::Ref(_, t, _) => is_array(*t),
-        _ => false,
-    }
+    let ty = ty.peel_refs();
+    ty.is_array() || ty.is_array_slice()
 }
 
 /// This builds the graph of side effect.
@@ -250,40 +245,30 @@ pub struct SideEffectVisit<'tcx> {
     is_method: bool,
     has_self: bool,
     ty_res: &'tcx TypeckResults<'tcx>,
-    ty_ctx: TyCtxt<'tcx>,
+    tcx: TyCtxt<'tcx>,
+    visited_exprs: FxHashSet<HirId>,
 }
 
 impl<'tcx> Visitor<'tcx> for SideEffectVisit<'tcx> {
-    fn visit_block(&mut self, b: &'tcx Block<'tcx>) {
-        b.stmts.iter().for_each(|stmt| {
-            self.visit_stmt(stmt);
-            self.ret_vars.clear();
-        });
-        walk_list!(self, visit_expr, b.expr);
-    }
-
     fn visit_stmt(&mut self, s: &'tcx Stmt<'tcx>) {
         match s.kind {
             StmtKind::Local(Local {
                 pat, init: Some(init), ..
             }) => {
                 self.visit_pat_expr(pat, init, false);
-                self.ret_vars.clear();
             },
-            StmtKind::Item(i) => {
-                let item = self.ty_ctx.hir().item(i);
-                self.visit_item(item);
-                self.ret_vars.clear();
-            },
-            StmtKind::Expr(e) | StmtKind::Semi(e) => {
-                self.visit_expr(e);
-                self.ret_vars.clear();
+            StmtKind::Item(_) | StmtKind::Expr(_) | StmtKind::Semi(_) => {
+                walk_stmt(self, s);
             },
             StmtKind::Local(_) => {},
         }
+        self.ret_vars.clear();
     }
 
     fn visit_expr(&mut self, ex: &'tcx Expr<'tcx>) {
+        if !self.visited_exprs.insert(ex.hir_id) {
+            return;
+        }
         match ex.kind {
             ExprKind::Array(exprs) | ExprKind::Tup(exprs) => {
                 self.ret_vars = exprs
@@ -307,7 +292,7 @@ impl<'tcx> Visitor<'tcx> for SideEffectVisit<'tcx> {
             ExprKind::Match(expr, arms, _) => self.visit_match(expr, arms),
             // since analysing the closure is not easy, just set all variables in it to side-effect
             ExprKind::Closure(_, _, body_id, _, _) => {
-                let body = self.ty_ctx.hir().body(body_id);
+                let body = self.tcx.hir().body(body_id);
                 self.visit_body(body);
                 let vars = std::mem::take(&mut self.ret_vars);
                 self.add_side_effect(vars);
-- 
cgit 1.4.1-3-g733a5


From dfdc5ad7d8f5d3787406a00bab2d1e049a57d1e2 Mon Sep 17 00:00:00 2001
From: kyoto7250 <50972773+kyoto7250@users.noreply.github.com>
Date: Tue, 12 Apr 2022 22:55:48 +0900
Subject: fix unnecessary_to_owned about msrv

---
 clippy_lints/src/methods/mod.rs                  |   2 +-
 clippy_lints/src/methods/unnecessary_to_owned.rs |  23 ++-
 tests/ui/unnecessary_to_owned.fixed              |  12 ++
 tests/ui/unnecessary_to_owned.rs                 |  12 ++
 tests/ui/unnecessary_to_owned.stderr             | 176 ++++++++++++-----------
 5 files changed, 138 insertions(+), 87 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 56a8782cee4..e2abce86791 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -2254,7 +2254,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
                 single_char_add_str::check(cx, expr, args);
                 into_iter_on_ref::check(cx, expr, method_span, method_call.ident.name, args);
                 single_char_pattern::check(cx, expr, method_call.ident.name, args);
-                unnecessary_to_owned::check(cx, expr, method_call.ident.name, args);
+                unnecessary_to_owned::check(cx, expr, method_call.ident.name, args, self.msrv.as_ref());
             },
             hir::ExprKind::Binary(op, lhs, rhs) if op.node == hir::BinOpKind::Eq || op.node == hir::BinOpKind::Ne => {
                 let mut info = BinaryExprInfo {
diff --git a/clippy_lints/src/methods/unnecessary_to_owned.rs b/clippy_lints/src/methods/unnecessary_to_owned.rs
index 1555758fc4a..02b882e8b55 100644
--- a/clippy_lints/src/methods/unnecessary_to_owned.rs
+++ b/clippy_lints/src/methods/unnecessary_to_owned.rs
@@ -5,6 +5,8 @@ use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::{
     contains_ty, get_associated_type, get_iterator_item_ty, implements_trait, is_copy, peel_mid_ty_refs,
 };
+use clippy_utils::{meets_msrv, msrvs};
+
 use clippy_utils::{fn_def_id, get_parent_expr, is_diag_item_method, is_diag_trait_item};
 use rustc_errors::Applicability;
 use rustc_hir::{def_id::DefId, BorrowKind, Expr, ExprKind};
@@ -13,12 +15,19 @@ use rustc_middle::mir::Mutability;
 use rustc_middle::ty::adjustment::{Adjust, Adjustment, OverloadedDeref};
 use rustc_middle::ty::subst::{GenericArg, GenericArgKind, SubstsRef};
 use rustc_middle::ty::{self, PredicateKind, ProjectionPredicate, TraitPredicate, Ty};
+use rustc_semver::RustcVersion;
 use rustc_span::{sym, Symbol};
 use std::cmp::max;
 
 use super::UNNECESSARY_TO_OWNED;
 
-pub fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, method_name: Symbol, args: &'tcx [Expr<'tcx>]) {
+pub fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx Expr<'tcx>,
+    method_name: Symbol,
+    args: &'tcx [Expr<'tcx>],
+    msrv: Option<&RustcVersion>,
+) {
     if_chain! {
         if let Some(method_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
         if let [receiver] = args;
@@ -33,7 +42,7 @@ pub fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, method_name:
                 if check_addr_of_expr(cx, expr, method_name, method_def_id, receiver) {
                     return;
                 }
-                if check_into_iter_call_arg(cx, expr, method_name, receiver) {
+                if check_into_iter_call_arg(cx, expr, method_name, receiver, msrv) {
                     return;
                 }
                 check_other_call_arg(cx, expr, method_name, receiver);
@@ -178,7 +187,13 @@ fn check_addr_of_expr(
 
 /// Checks whether `expr` is an argument in an `into_iter` call and, if so, determines whether its
 /// call of a `to_owned`-like function is unnecessary.
-fn check_into_iter_call_arg(cx: &LateContext<'_>, expr: &Expr<'_>, method_name: Symbol, receiver: &Expr<'_>) -> bool {
+fn check_into_iter_call_arg(
+    cx: &LateContext<'_>,
+    expr: &Expr<'_>,
+    method_name: Symbol,
+    receiver: &Expr<'_>,
+    msrv: Option<&RustcVersion>,
+) -> bool {
     if_chain! {
         if let Some(parent) = get_parent_expr(cx, expr);
         if let Some(callee_def_id) = fn_def_id(cx, parent);
@@ -192,7 +207,7 @@ fn check_into_iter_call_arg(cx: &LateContext<'_>, expr: &Expr<'_>, method_name:
             if unnecessary_iter_cloned::check_for_loop_iter(cx, parent, method_name, receiver, true) {
                 return true;
             }
-            let cloned_or_copied = if is_copy(cx, item_ty) { "copied" } else { "cloned" };
+            let cloned_or_copied = if is_copy(cx, item_ty) && meets_msrv(msrv, &msrvs::ITERATOR_COPIED) { "copied" } else { "cloned" };
             // The next suggestion may be incorrect because the removal of the `to_owned`-like
             // function could cause the iterator to hold a reference to a resource that is used
             // mutably. See https://github.com/rust-lang/rust-clippy/issues/8148.
diff --git a/tests/ui/unnecessary_to_owned.fixed b/tests/ui/unnecessary_to_owned.fixed
index 38ba41ac54e..7455e22d49b 100644
--- a/tests/ui/unnecessary_to_owned.fixed
+++ b/tests/ui/unnecessary_to_owned.fixed
@@ -2,6 +2,7 @@
 
 #![allow(clippy::ptr_arg)]
 #![warn(clippy::unnecessary_to_owned)]
+#![feature(custom_inner_attributes)]
 
 use std::borrow::Cow;
 use std::ffi::{CStr, CString, OsStr, OsString};
@@ -213,6 +214,17 @@ fn get_file_path(_file_type: &FileType) -> Result<std::path::PathBuf, std::io::E
 
 fn require_string(_: &String) {}
 
+fn _msrv_1_35() {
+    #![clippy::msrv = "1.35"]
+    // `copied` was stabilized in 1.36, so clippy should use `cloned`.
+    let _ = &["x"][..].iter().cloned();
+}
+
+fn _msrv_1_36() {
+    #![clippy::msrv = "1.36"]
+    let _ = &["x"][..].iter().copied();
+}
+
 // https://github.com/rust-lang/rust-clippy/issues/8507
 mod issue_8507 {
     #![allow(dead_code)]
diff --git a/tests/ui/unnecessary_to_owned.rs b/tests/ui/unnecessary_to_owned.rs
index 15fb7ee83e3..bbcd00ad220 100644
--- a/tests/ui/unnecessary_to_owned.rs
+++ b/tests/ui/unnecessary_to_owned.rs
@@ -2,6 +2,7 @@
 
 #![allow(clippy::ptr_arg)]
 #![warn(clippy::unnecessary_to_owned)]
+#![feature(custom_inner_attributes)]
 
 use std::borrow::Cow;
 use std::ffi::{CStr, CString, OsStr, OsString};
@@ -213,6 +214,17 @@ fn get_file_path(_file_type: &FileType) -> Result<std::path::PathBuf, std::io::E
 
 fn require_string(_: &String) {}
 
+fn _msrv_1_35() {
+    #![clippy::msrv = "1.35"]
+    // `copied` was stabilized in 1.36, so clippy should use `cloned`.
+    let _ = &["x"][..].to_vec().into_iter();
+}
+
+fn _msrv_1_36() {
+    #![clippy::msrv = "1.36"]
+    let _ = &["x"][..].to_vec().into_iter();
+}
+
 // https://github.com/rust-lang/rust-clippy/issues/8507
 mod issue_8507 {
     #![allow(dead_code)]
diff --git a/tests/ui/unnecessary_to_owned.stderr b/tests/ui/unnecessary_to_owned.stderr
index c53ce32be77..f9713559e4f 100644
--- a/tests/ui/unnecessary_to_owned.stderr
+++ b/tests/ui/unnecessary_to_owned.stderr
@@ -1,54 +1,54 @@
 error: redundant clone
-  --> $DIR/unnecessary_to_owned.rs:150:64
+  --> $DIR/unnecessary_to_owned.rs:151:64
    |
 LL |     require_c_str(&CString::from_vec_with_nul(vec![0]).unwrap().to_owned());
    |                                                                ^^^^^^^^^^^ help: remove this
    |
    = note: `-D clippy::redundant-clone` implied by `-D warnings`
 note: this value is dropped without further use
-  --> $DIR/unnecessary_to_owned.rs:150:20
+  --> $DIR/unnecessary_to_owned.rs:151:20
    |
 LL |     require_c_str(&CString::from_vec_with_nul(vec![0]).unwrap().to_owned());
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: redundant clone
-  --> $DIR/unnecessary_to_owned.rs:151:40
+  --> $DIR/unnecessary_to_owned.rs:152:40
    |
 LL |     require_os_str(&OsString::from("x").to_os_string());
    |                                        ^^^^^^^^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> $DIR/unnecessary_to_owned.rs:151:21
+  --> $DIR/unnecessary_to_owned.rs:152:21
    |
 LL |     require_os_str(&OsString::from("x").to_os_string());
    |                     ^^^^^^^^^^^^^^^^^^^
 
 error: redundant clone
-  --> $DIR/unnecessary_to_owned.rs:152:48
+  --> $DIR/unnecessary_to_owned.rs:153:48
    |
 LL |     require_path(&std::path::PathBuf::from("x").to_path_buf());
    |                                                ^^^^^^^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> $DIR/unnecessary_to_owned.rs:152:19
+  --> $DIR/unnecessary_to_owned.rs:153:19
    |
 LL |     require_path(&std::path::PathBuf::from("x").to_path_buf());
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: redundant clone
-  --> $DIR/unnecessary_to_owned.rs:153:35
+  --> $DIR/unnecessary_to_owned.rs:154:35
    |
 LL |     require_str(&String::from("x").to_string());
    |                                   ^^^^^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> $DIR/unnecessary_to_owned.rs:153:18
+  --> $DIR/unnecessary_to_owned.rs:154:18
    |
 LL |     require_str(&String::from("x").to_string());
    |                  ^^^^^^^^^^^^^^^^^
 
 error: unnecessary use of `into_owned`
-  --> $DIR/unnecessary_to_owned.rs:59:36
+  --> $DIR/unnecessary_to_owned.rs:60:36
    |
 LL |     require_c_str(&Cow::from(c_str).into_owned());
    |                                    ^^^^^^^^^^^^^ help: remove this
@@ -56,427 +56,427 @@ LL |     require_c_str(&Cow::from(c_str).into_owned());
    = note: `-D clippy::unnecessary-to-owned` implied by `-D warnings`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:60:19
+  --> $DIR/unnecessary_to_owned.rs:61:19
    |
 LL |     require_c_str(&c_str.to_owned());
    |                   ^^^^^^^^^^^^^^^^^ help: use: `c_str`
 
 error: unnecessary use of `to_os_string`
-  --> $DIR/unnecessary_to_owned.rs:62:20
+  --> $DIR/unnecessary_to_owned.rs:63:20
    |
 LL |     require_os_str(&os_str.to_os_string());
    |                    ^^^^^^^^^^^^^^^^^^^^^^ help: use: `os_str`
 
 error: unnecessary use of `into_owned`
-  --> $DIR/unnecessary_to_owned.rs:63:38
+  --> $DIR/unnecessary_to_owned.rs:64:38
    |
 LL |     require_os_str(&Cow::from(os_str).into_owned());
    |                                      ^^^^^^^^^^^^^ help: remove this
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:64:20
+  --> $DIR/unnecessary_to_owned.rs:65:20
    |
 LL |     require_os_str(&os_str.to_owned());
    |                    ^^^^^^^^^^^^^^^^^^ help: use: `os_str`
 
 error: unnecessary use of `to_path_buf`
-  --> $DIR/unnecessary_to_owned.rs:66:18
+  --> $DIR/unnecessary_to_owned.rs:67:18
    |
 LL |     require_path(&path.to_path_buf());
    |                  ^^^^^^^^^^^^^^^^^^^ help: use: `path`
 
 error: unnecessary use of `into_owned`
-  --> $DIR/unnecessary_to_owned.rs:67:34
+  --> $DIR/unnecessary_to_owned.rs:68:34
    |
 LL |     require_path(&Cow::from(path).into_owned());
    |                                  ^^^^^^^^^^^^^ help: remove this
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:68:18
+  --> $DIR/unnecessary_to_owned.rs:69:18
    |
 LL |     require_path(&path.to_owned());
    |                  ^^^^^^^^^^^^^^^^ help: use: `path`
 
 error: unnecessary use of `to_string`
-  --> $DIR/unnecessary_to_owned.rs:70:17
+  --> $DIR/unnecessary_to_owned.rs:71:17
    |
 LL |     require_str(&s.to_string());
    |                 ^^^^^^^^^^^^^^ help: use: `s`
 
 error: unnecessary use of `into_owned`
-  --> $DIR/unnecessary_to_owned.rs:71:30
+  --> $DIR/unnecessary_to_owned.rs:72:30
    |
 LL |     require_str(&Cow::from(s).into_owned());
    |                              ^^^^^^^^^^^^^ help: remove this
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:72:17
+  --> $DIR/unnecessary_to_owned.rs:73:17
    |
 LL |     require_str(&s.to_owned());
    |                 ^^^^^^^^^^^^^ help: use: `s`
 
 error: unnecessary use of `to_string`
-  --> $DIR/unnecessary_to_owned.rs:73:17
+  --> $DIR/unnecessary_to_owned.rs:74:17
    |
 LL |     require_str(&x_ref.to_string());
    |                 ^^^^^^^^^^^^^^^^^^ help: use: `x_ref.as_ref()`
 
 error: unnecessary use of `to_vec`
-  --> $DIR/unnecessary_to_owned.rs:75:19
+  --> $DIR/unnecessary_to_owned.rs:76:19
    |
 LL |     require_slice(&slice.to_vec());
    |                   ^^^^^^^^^^^^^^^ help: use: `slice`
 
 error: unnecessary use of `into_owned`
-  --> $DIR/unnecessary_to_owned.rs:76:36
+  --> $DIR/unnecessary_to_owned.rs:77:36
    |
 LL |     require_slice(&Cow::from(slice).into_owned());
    |                                    ^^^^^^^^^^^^^ help: remove this
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:77:19
+  --> $DIR/unnecessary_to_owned.rs:78:19
    |
 LL |     require_slice(&array.to_owned());
    |                   ^^^^^^^^^^^^^^^^^ help: use: `array.as_ref()`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:78:19
+  --> $DIR/unnecessary_to_owned.rs:79:19
    |
 LL |     require_slice(&array_ref.to_owned());
    |                   ^^^^^^^^^^^^^^^^^^^^^ help: use: `array_ref.as_ref()`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:79:19
+  --> $DIR/unnecessary_to_owned.rs:80:19
    |
 LL |     require_slice(&slice.to_owned());
    |                   ^^^^^^^^^^^^^^^^^ help: use: `slice`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:80:19
+  --> $DIR/unnecessary_to_owned.rs:81:19
    |
 LL |     require_slice(&x_ref.to_owned());
    |                   ^^^^^^^^^^^^^^^^^ help: use: `x_ref`
 
 error: unnecessary use of `into_owned`
-  --> $DIR/unnecessary_to_owned.rs:82:42
+  --> $DIR/unnecessary_to_owned.rs:83:42
    |
 LL |     require_x(&Cow::<X>::Owned(x.clone()).into_owned());
    |                                          ^^^^^^^^^^^^^ help: remove this
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:83:15
+  --> $DIR/unnecessary_to_owned.rs:84:15
    |
 LL |     require_x(&x_ref.to_owned());
    |               ^^^^^^^^^^^^^^^^^ help: use: `x_ref`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:85:25
+  --> $DIR/unnecessary_to_owned.rs:86:25
    |
 LL |     require_deref_c_str(c_str.to_owned());
    |                         ^^^^^^^^^^^^^^^^ help: use: `c_str`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:86:26
+  --> $DIR/unnecessary_to_owned.rs:87:26
    |
 LL |     require_deref_os_str(os_str.to_owned());
    |                          ^^^^^^^^^^^^^^^^^ help: use: `os_str`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:87:24
+  --> $DIR/unnecessary_to_owned.rs:88:24
    |
 LL |     require_deref_path(path.to_owned());
    |                        ^^^^^^^^^^^^^^^ help: use: `path`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:88:23
+  --> $DIR/unnecessary_to_owned.rs:89:23
    |
 LL |     require_deref_str(s.to_owned());
    |                       ^^^^^^^^^^^^ help: use: `s`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:89:25
+  --> $DIR/unnecessary_to_owned.rs:90:25
    |
 LL |     require_deref_slice(slice.to_owned());
    |                         ^^^^^^^^^^^^^^^^ help: use: `slice`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:91:30
+  --> $DIR/unnecessary_to_owned.rs:92:30
    |
 LL |     require_impl_deref_c_str(c_str.to_owned());
    |                              ^^^^^^^^^^^^^^^^ help: use: `c_str`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:92:31
+  --> $DIR/unnecessary_to_owned.rs:93:31
    |
 LL |     require_impl_deref_os_str(os_str.to_owned());
    |                               ^^^^^^^^^^^^^^^^^ help: use: `os_str`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:93:29
+  --> $DIR/unnecessary_to_owned.rs:94:29
    |
 LL |     require_impl_deref_path(path.to_owned());
    |                             ^^^^^^^^^^^^^^^ help: use: `path`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:94:28
+  --> $DIR/unnecessary_to_owned.rs:95:28
    |
 LL |     require_impl_deref_str(s.to_owned());
    |                            ^^^^^^^^^^^^ help: use: `s`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:95:30
+  --> $DIR/unnecessary_to_owned.rs:96:30
    |
 LL |     require_impl_deref_slice(slice.to_owned());
    |                              ^^^^^^^^^^^^^^^^ help: use: `slice`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:97:29
+  --> $DIR/unnecessary_to_owned.rs:98:29
    |
 LL |     require_deref_str_slice(s.to_owned(), slice.to_owned());
    |                             ^^^^^^^^^^^^ help: use: `s`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:97:43
+  --> $DIR/unnecessary_to_owned.rs:98:43
    |
 LL |     require_deref_str_slice(s.to_owned(), slice.to_owned());
    |                                           ^^^^^^^^^^^^^^^^ help: use: `slice`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:98:29
+  --> $DIR/unnecessary_to_owned.rs:99:29
    |
 LL |     require_deref_slice_str(slice.to_owned(), s.to_owned());
    |                             ^^^^^^^^^^^^^^^^ help: use: `slice`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:98:47
+  --> $DIR/unnecessary_to_owned.rs:99:47
    |
 LL |     require_deref_slice_str(slice.to_owned(), s.to_owned());
    |                                               ^^^^^^^^^^^^ help: use: `s`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:100:26
+  --> $DIR/unnecessary_to_owned.rs:101:26
    |
 LL |     require_as_ref_c_str(c_str.to_owned());
    |                          ^^^^^^^^^^^^^^^^ help: use: `c_str`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:101:27
+  --> $DIR/unnecessary_to_owned.rs:102:27
    |
 LL |     require_as_ref_os_str(os_str.to_owned());
    |                           ^^^^^^^^^^^^^^^^^ help: use: `os_str`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:102:25
+  --> $DIR/unnecessary_to_owned.rs:103:25
    |
 LL |     require_as_ref_path(path.to_owned());
    |                         ^^^^^^^^^^^^^^^ help: use: `path`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:103:24
+  --> $DIR/unnecessary_to_owned.rs:104:24
    |
 LL |     require_as_ref_str(s.to_owned());
    |                        ^^^^^^^^^^^^ help: use: `s`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:104:24
+  --> $DIR/unnecessary_to_owned.rs:105:24
    |
 LL |     require_as_ref_str(x.to_owned());
    |                        ^^^^^^^^^^^^ help: use: `&x`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:105:26
+  --> $DIR/unnecessary_to_owned.rs:106:26
    |
 LL |     require_as_ref_slice(array.to_owned());
    |                          ^^^^^^^^^^^^^^^^ help: use: `array`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:106:26
+  --> $DIR/unnecessary_to_owned.rs:107:26
    |
 LL |     require_as_ref_slice(array_ref.to_owned());
    |                          ^^^^^^^^^^^^^^^^^^^^ help: use: `array_ref`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:107:26
+  --> $DIR/unnecessary_to_owned.rs:108:26
    |
 LL |     require_as_ref_slice(slice.to_owned());
    |                          ^^^^^^^^^^^^^^^^ help: use: `slice`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:109:31
+  --> $DIR/unnecessary_to_owned.rs:110:31
    |
 LL |     require_impl_as_ref_c_str(c_str.to_owned());
    |                               ^^^^^^^^^^^^^^^^ help: use: `c_str`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:110:32
+  --> $DIR/unnecessary_to_owned.rs:111:32
    |
 LL |     require_impl_as_ref_os_str(os_str.to_owned());
    |                                ^^^^^^^^^^^^^^^^^ help: use: `os_str`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:111:30
+  --> $DIR/unnecessary_to_owned.rs:112:30
    |
 LL |     require_impl_as_ref_path(path.to_owned());
    |                              ^^^^^^^^^^^^^^^ help: use: `path`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:112:29
+  --> $DIR/unnecessary_to_owned.rs:113:29
    |
 LL |     require_impl_as_ref_str(s.to_owned());
    |                             ^^^^^^^^^^^^ help: use: `s`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:113:29
+  --> $DIR/unnecessary_to_owned.rs:114:29
    |
 LL |     require_impl_as_ref_str(x.to_owned());
    |                             ^^^^^^^^^^^^ help: use: `&x`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:114:31
+  --> $DIR/unnecessary_to_owned.rs:115:31
    |
 LL |     require_impl_as_ref_slice(array.to_owned());
    |                               ^^^^^^^^^^^^^^^^ help: use: `array`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:115:31
+  --> $DIR/unnecessary_to_owned.rs:116:31
    |
 LL |     require_impl_as_ref_slice(array_ref.to_owned());
    |                               ^^^^^^^^^^^^^^^^^^^^ help: use: `array_ref`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:116:31
+  --> $DIR/unnecessary_to_owned.rs:117:31
    |
 LL |     require_impl_as_ref_slice(slice.to_owned());
    |                               ^^^^^^^^^^^^^^^^ help: use: `slice`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:118:30
+  --> $DIR/unnecessary_to_owned.rs:119:30
    |
 LL |     require_as_ref_str_slice(s.to_owned(), array.to_owned());
    |                              ^^^^^^^^^^^^ help: use: `s`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:118:44
+  --> $DIR/unnecessary_to_owned.rs:119:44
    |
 LL |     require_as_ref_str_slice(s.to_owned(), array.to_owned());
    |                                            ^^^^^^^^^^^^^^^^ help: use: `array`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:119:30
+  --> $DIR/unnecessary_to_owned.rs:120:30
    |
 LL |     require_as_ref_str_slice(s.to_owned(), array_ref.to_owned());
    |                              ^^^^^^^^^^^^ help: use: `s`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:119:44
+  --> $DIR/unnecessary_to_owned.rs:120:44
    |
 LL |     require_as_ref_str_slice(s.to_owned(), array_ref.to_owned());
    |                                            ^^^^^^^^^^^^^^^^^^^^ help: use: `array_ref`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:120:30
+  --> $DIR/unnecessary_to_owned.rs:121:30
    |
 LL |     require_as_ref_str_slice(s.to_owned(), slice.to_owned());
    |                              ^^^^^^^^^^^^ help: use: `s`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:120:44
+  --> $DIR/unnecessary_to_owned.rs:121:44
    |
 LL |     require_as_ref_str_slice(s.to_owned(), slice.to_owned());
    |                                            ^^^^^^^^^^^^^^^^ help: use: `slice`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:121:30
+  --> $DIR/unnecessary_to_owned.rs:122:30
    |
 LL |     require_as_ref_slice_str(array.to_owned(), s.to_owned());
    |                              ^^^^^^^^^^^^^^^^ help: use: `array`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:121:48
+  --> $DIR/unnecessary_to_owned.rs:122:48
    |
 LL |     require_as_ref_slice_str(array.to_owned(), s.to_owned());
    |                                                ^^^^^^^^^^^^ help: use: `s`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:122:30
+  --> $DIR/unnecessary_to_owned.rs:123:30
    |
 LL |     require_as_ref_slice_str(array_ref.to_owned(), s.to_owned());
    |                              ^^^^^^^^^^^^^^^^^^^^ help: use: `array_ref`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:122:52
+  --> $DIR/unnecessary_to_owned.rs:123:52
    |
 LL |     require_as_ref_slice_str(array_ref.to_owned(), s.to_owned());
    |                                                    ^^^^^^^^^^^^ help: use: `s`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:123:30
+  --> $DIR/unnecessary_to_owned.rs:124:30
    |
 LL |     require_as_ref_slice_str(slice.to_owned(), s.to_owned());
    |                              ^^^^^^^^^^^^^^^^ help: use: `slice`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:123:48
+  --> $DIR/unnecessary_to_owned.rs:124:48
    |
 LL |     require_as_ref_slice_str(slice.to_owned(), s.to_owned());
    |                                                ^^^^^^^^^^^^ help: use: `s`
 
 error: unnecessary use of `to_string`
-  --> $DIR/unnecessary_to_owned.rs:125:20
+  --> $DIR/unnecessary_to_owned.rs:126:20
    |
 LL |     let _ = x.join(&x_ref.to_string());
    |                    ^^^^^^^^^^^^^^^^^^ help: use: `x_ref`
 
 error: unnecessary use of `to_vec`
-  --> $DIR/unnecessary_to_owned.rs:127:13
+  --> $DIR/unnecessary_to_owned.rs:128:13
    |
 LL |     let _ = slice.to_vec().into_iter();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `slice.iter().copied()`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:128:13
+  --> $DIR/unnecessary_to_owned.rs:129:13
    |
 LL |     let _ = slice.to_owned().into_iter();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `slice.iter().copied()`
 
 error: unnecessary use of `to_vec`
-  --> $DIR/unnecessary_to_owned.rs:129:13
+  --> $DIR/unnecessary_to_owned.rs:130:13
    |
 LL |     let _ = [std::path::PathBuf::new()][..].to_vec().into_iter();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `[std::path::PathBuf::new()][..].iter().cloned()`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:130:13
+  --> $DIR/unnecessary_to_owned.rs:131:13
    |
 LL |     let _ = [std::path::PathBuf::new()][..].to_owned().into_iter();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `[std::path::PathBuf::new()][..].iter().cloned()`
 
 error: unnecessary use of `to_vec`
-  --> $DIR/unnecessary_to_owned.rs:132:13
+  --> $DIR/unnecessary_to_owned.rs:133:13
    |
 LL |     let _ = IntoIterator::into_iter(slice.to_vec());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `slice.iter().copied()`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:133:13
+  --> $DIR/unnecessary_to_owned.rs:134:13
    |
 LL |     let _ = IntoIterator::into_iter(slice.to_owned());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `slice.iter().copied()`
 
 error: unnecessary use of `to_vec`
-  --> $DIR/unnecessary_to_owned.rs:134:13
+  --> $DIR/unnecessary_to_owned.rs:135:13
    |
 LL |     let _ = IntoIterator::into_iter([std::path::PathBuf::new()][..].to_vec());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `[std::path::PathBuf::new()][..].iter().cloned()`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:135:13
+  --> $DIR/unnecessary_to_owned.rs:136:13
    |
 LL |     let _ = IntoIterator::into_iter([std::path::PathBuf::new()][..].to_owned());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `[std::path::PathBuf::new()][..].iter().cloned()`
 
 error: unnecessary use of `to_vec`
-  --> $DIR/unnecessary_to_owned.rs:196:14
+  --> $DIR/unnecessary_to_owned.rs:197:14
    |
 LL |     for t in file_types.to_vec() {
    |              ^^^^^^^^^^^^^^^^^^^
@@ -491,11 +491,23 @@ LL -         let path = match get_file_path(&t) {
 LL +         let path = match get_file_path(t) {
    | 
 
+error: unnecessary use of `to_vec`
+  --> $DIR/unnecessary_to_owned.rs:220:14
+   |
+LL |     let _ = &["x"][..].to_vec().into_iter();
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `["x"][..].iter().cloned()`
+
+error: unnecessary use of `to_vec`
+  --> $DIR/unnecessary_to_owned.rs:225:14
+   |
+LL |     let _ = &["x"][..].to_vec().into_iter();
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `["x"][..].iter().copied()`
+
 error: unnecessary use of `to_string`
-  --> $DIR/unnecessary_to_owned.rs:260:24
+  --> $DIR/unnecessary_to_owned.rs:272:24
    |
 LL |         Box::new(build(y.to_string()))
    |                        ^^^^^^^^^^^^^ help: use: `y`
 
-error: aborting due to 77 previous errors
+error: aborting due to 79 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 66d253f0f219578264ac7cb4e1c10f01dcfe8ad7 Mon Sep 17 00:00:00 2001
From: Yoav Lavi <yoavlavi122@gmail.com>
Date: Tue, 12 Apr 2022 11:09:34 +0200
Subject: pub_use

---
 CHANGELOG.md                                 |  1 +
 clippy_lints/src/lib.register_lints.rs       |  1 +
 clippy_lints/src/lib.register_restriction.rs |  1 +
 clippy_lints/src/lib.rs                      |  2 +
 clippy_lints/src/pub_use.rs                  | 56 ++++++++++++++++++++++++++++
 tests/ui/pub_use.rs                          | 14 +++++++
 tests/ui/pub_use.stderr                      | 11 ++++++
 7 files changed, 86 insertions(+)
 create mode 100644 clippy_lints/src/pub_use.rs
 create mode 100644 tests/ui/pub_use.rs
 create mode 100644 tests/ui/pub_use.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 44a36870108..444c649c84f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3527,6 +3527,7 @@ Released 2018-09-13
 [`ptr_eq`]: https://rust-lang.github.io/rust-clippy/master/index.html#ptr_eq
 [`ptr_offset_with_cast`]: https://rust-lang.github.io/rust-clippy/master/index.html#ptr_offset_with_cast
 [`pub_enum_variant_names`]: https://rust-lang.github.io/rust-clippy/master/index.html#pub_enum_variant_names
+[`pub_use`]: https://rust-lang.github.io/rust-clippy/master/index.html#pub_use
 [`question_mark`]: https://rust-lang.github.io/rust-clippy/master/index.html#question_mark
 [`range_minus_one`]: https://rust-lang.github.io/rust-clippy/master/index.html#range_minus_one
 [`range_plus_one`]: https://rust-lang.github.io/rust-clippy/master/index.html#range_plus_one
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 704e79885cf..4132802c9c6 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -432,6 +432,7 @@ store.register_lints(&[
     ptr::PTR_ARG,
     ptr_eq::PTR_EQ,
     ptr_offset_with_cast::PTR_OFFSET_WITH_CAST,
+    pub_use::PUB_USE,
     question_mark::QUESTION_MARK,
     ranges::MANUAL_RANGE_CONTAINS,
     ranges::RANGE_MINUS_ONE,
diff --git a/clippy_lints/src/lib.register_restriction.rs b/clippy_lints/src/lib.register_restriction.rs
index 4802dd877e9..555a8ad841f 100644
--- a/clippy_lints/src/lib.register_restriction.rs
+++ b/clippy_lints/src/lib.register_restriction.rs
@@ -53,6 +53,7 @@ store.register_group(true, "clippy::restriction", Some("clippy_restriction"), ve
     LintId::of(panic_unimplemented::UNIMPLEMENTED),
     LintId::of(panic_unimplemented::UNREACHABLE),
     LintId::of(pattern_type_mismatch::PATTERN_TYPE_MISMATCH),
+    LintId::of(pub_use::PUB_USE),
     LintId::of(redundant_slicing::DEREF_BY_SLICING),
     LintId::of(same_name_method::SAME_NAME_METHOD),
     LintId::of(shadow::SHADOW_REUSE),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 74ade422dc8..17552873b0a 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -336,6 +336,7 @@ mod precedence;
 mod ptr;
 mod ptr_eq;
 mod ptr_offset_with_cast;
+mod pub_use;
 mod question_mark;
 mod ranges;
 mod redundant_clone;
@@ -870,6 +871,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_early_pass(|| Box::new(crate_in_macro_def::CrateInMacroDef));
     store.register_early_pass(|| Box::new(empty_structs_with_brackets::EmptyStructsWithBrackets));
     store.register_late_pass(|| Box::new(unnecessary_owned_empty_strings::UnnecessaryOwnedEmptyStrings));
+    store.register_early_pass(|| Box::new(pub_use::PubUse));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/pub_use.rs b/clippy_lints/src/pub_use.rs
new file mode 100644
index 00000000000..9d2b0cedb60
--- /dev/null
+++ b/clippy_lints/src/pub_use.rs
@@ -0,0 +1,56 @@
+use clippy_utils::diagnostics::span_lint_and_help;
+use rustc_ast::ast::{Item, ItemKind, VisibilityKind};
+use rustc_lint::{EarlyContext, EarlyLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// ### What it does
+    ///
+    /// Restricts the usage of `pub use ...`
+    ///
+    /// ### Why is this bad?
+    ///
+    /// `pub use` is usually fine, but a project may wish to limit `pub use` instances to prevent
+    /// unintentional exports or to encourage placing exported items directly in public modules
+    ///
+    /// ### Example
+    /// ```rust
+    /// pub mod outer {
+    ///     mod inner {
+    ///         pub struct Test {}
+    ///     }
+    ///     pub use inner::Test;
+    /// }
+    ///
+    /// use outer::Test;
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// pub mod outer {
+    ///     pub struct Test {}
+    /// }
+    ///
+    /// use outer::Test;
+    /// ```
+    #[clippy::version = "1.62.0"]
+    pub PUB_USE,
+    restriction,
+    "restricts the usage of `pub use`"
+}
+declare_lint_pass!(PubUse => [PUB_USE]);
+
+impl EarlyLintPass for PubUse {
+    fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {
+        if let ItemKind::Use(_) = item.kind &&
+            let VisibilityKind::Public = item.vis.kind {
+                span_lint_and_help(
+                    cx,
+                    PUB_USE,
+                    item.span,
+                    "using `pub use`",
+                    None,
+                    "move the exported item to a public module instead",
+                );
+            }
+    }
+}
diff --git a/tests/ui/pub_use.rs b/tests/ui/pub_use.rs
new file mode 100644
index 00000000000..65542bedec7
--- /dev/null
+++ b/tests/ui/pub_use.rs
@@ -0,0 +1,14 @@
+#![warn(clippy::pub_use)]
+#![allow(unused_imports)]
+#![no_main]
+
+pub mod outer {
+    mod inner {
+        pub struct Test {}
+    }
+    // should be linted
+    pub use inner::Test;
+}
+
+// should not be linted
+use std::fmt;
diff --git a/tests/ui/pub_use.stderr b/tests/ui/pub_use.stderr
new file mode 100644
index 00000000000..9ab710df818
--- /dev/null
+++ b/tests/ui/pub_use.stderr
@@ -0,0 +1,11 @@
+error: using `pub use`
+  --> $DIR/pub_use.rs:10:5
+   |
+LL |     pub use inner::Test;
+   |     ^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::pub-use` implied by `-D warnings`
+   = help: move the exported item to a public module instead
+
+error: aborting due to previous error
+
-- 
cgit 1.4.1-3-g733a5


From ba15cdd3c159b5feda929b7af0d929e17a6f5c6d Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Sun, 10 Apr 2022 19:03:16 +0200
Subject: Add `usize` cast to `clippy::manual_bits` suggestion

---
 clippy_lints/src/manual_bits.rs |  46 +++++++++++++--
 tests/ui/manual_bits.fixed      |  69 +++++++++++++---------
 tests/ui/manual_bits.rs         |  13 ++++-
 tests/ui/manual_bits.stderr     | 126 ++++++++++++++++++++++++----------------
 4 files changed, 168 insertions(+), 86 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_bits.rs b/clippy_lints/src/manual_bits.rs
index dcf44303cf4..44ff151ea52 100644
--- a/clippy_lints/src/manual_bits.rs
+++ b/clippy_lints/src/manual_bits.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::source::snippet_opt;
-use clippy_utils::{meets_msrv, msrvs};
+use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::{get_parent_expr, meets_msrv, msrvs};
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind, GenericArg, QPath};
@@ -59,16 +59,19 @@ impl<'tcx> LateLintPass<'tcx> for ManualBits {
             if matches!(resolved_ty.kind(), ty::Int(_) | ty::Uint(_));
             if let ExprKind::Lit(lit) = &other_expr.kind;
             if let LitKind::Int(8, _) = lit.node;
-
             then {
+                let mut app = Applicability::MachineApplicable;
+                let ty_snip = snippet_with_applicability(cx, real_ty.span, "..", &mut app);
+                let sugg = create_sugg(cx, expr, format!("{ty_snip}::BITS"));
+
                 span_lint_and_sugg(
                     cx,
                     MANUAL_BITS,
                     expr.span,
                     "usage of `mem::size_of::<T>()` to obtain the size of `T` in bits",
                     "consider using",
-                    format!("{}::BITS", snippet_opt(cx, real_ty.span).unwrap()),
-                    Applicability::MachineApplicable,
+                    sugg,
+                    app,
                 );
             }
         }
@@ -108,3 +111,36 @@ fn get_size_of_ty<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<
         }
     }
 }
+
+fn create_sugg(cx: &LateContext<'_>, expr: &Expr<'_>, base_sugg: String) -> String {
+    if let Some(parent_expr) = get_parent_expr(cx, expr) {
+        if is_ty_conversion(parent_expr) {
+            return base_sugg;
+        }
+
+        // These expressions have precedence over casts, the suggestion therefore
+        // needs to be wrapped into parentheses
+        match parent_expr.kind {
+            ExprKind::Unary(..) | ExprKind::AddrOf(..) | ExprKind::MethodCall(..) => {
+                return format!("({base_sugg} as usize)");
+            },
+            _ => {},
+        }
+    }
+
+    format!("{base_sugg} as usize")
+}
+
+fn is_ty_conversion(expr: &Expr<'_>) -> bool {
+    if let ExprKind::Cast(..) = expr.kind {
+        true
+    } else if let ExprKind::MethodCall(path, [_], _) = expr.kind
+        && path.ident.name == rustc_span::sym::try_into
+    {
+        // This is only called for `usize` which implements `TryInto`. Therefore,
+        // we don't have to check here if `self` implements the `TryInto` trait.
+        true
+    } else {
+        false
+    }
+}
diff --git a/tests/ui/manual_bits.fixed b/tests/ui/manual_bits.fixed
index 4f1b19b75b8..386360dbdcd 100644
--- a/tests/ui/manual_bits.fixed
+++ b/tests/ui/manual_bits.fixed
@@ -1,38 +1,44 @@
 // run-rustfix
 
 #![warn(clippy::manual_bits)]
-#![allow(clippy::no_effect, path_statements, unused_must_use, clippy::unnecessary_operation)]
+#![allow(
+    clippy::no_effect,
+    clippy::useless_conversion,
+    path_statements,
+    unused_must_use,
+    clippy::unnecessary_operation
+)]
 
 use std::mem::{size_of, size_of_val};
 
 fn main() {
-    i8::BITS;
-    i16::BITS;
-    i32::BITS;
-    i64::BITS;
-    i128::BITS;
-    isize::BITS;
-
-    u8::BITS;
-    u16::BITS;
-    u32::BITS;
-    u64::BITS;
-    u128::BITS;
-    usize::BITS;
-
-    i8::BITS;
-    i16::BITS;
-    i32::BITS;
-    i64::BITS;
-    i128::BITS;
-    isize::BITS;
-
-    u8::BITS;
-    u16::BITS;
-    u32::BITS;
-    u64::BITS;
-    u128::BITS;
-    usize::BITS;
+    i8::BITS as usize;
+    i16::BITS as usize;
+    i32::BITS as usize;
+    i64::BITS as usize;
+    i128::BITS as usize;
+    isize::BITS as usize;
+
+    u8::BITS as usize;
+    u16::BITS as usize;
+    u32::BITS as usize;
+    u64::BITS as usize;
+    u128::BITS as usize;
+    usize::BITS as usize;
+
+    i8::BITS as usize;
+    i16::BITS as usize;
+    i32::BITS as usize;
+    i64::BITS as usize;
+    i128::BITS as usize;
+    isize::BITS as usize;
+
+    u8::BITS as usize;
+    u16::BITS as usize;
+    u32::BITS as usize;
+    u64::BITS as usize;
+    u128::BITS as usize;
+    usize::BITS as usize;
 
     size_of::<usize>() * 4;
     4 * size_of::<usize>();
@@ -42,7 +48,12 @@ fn main() {
     size_of_val(&0u32) * 8;
 
     type Word = u32;
-    Word::BITS;
+    Word::BITS as usize;
     type Bool = bool;
     size_of::<Bool>() * 8;
+
+    let _: u32 = u128::BITS as u32;
+    let _: u32 = u128::BITS.try_into().unwrap();
+    let _ = (u128::BITS as usize).pow(5);
+    let _ = &(u128::BITS as usize);
 }
diff --git a/tests/ui/manual_bits.rs b/tests/ui/manual_bits.rs
index f8a01313e6a..62638f047eb 100644
--- a/tests/ui/manual_bits.rs
+++ b/tests/ui/manual_bits.rs
@@ -1,7 +1,13 @@
 // run-rustfix
 
 #![warn(clippy::manual_bits)]
-#![allow(clippy::no_effect, path_statements, unused_must_use, clippy::unnecessary_operation)]
+#![allow(
+    clippy::no_effect,
+    clippy::useless_conversion,
+    path_statements,
+    unused_must_use,
+    clippy::unnecessary_operation
+)]
 
 use std::mem::{size_of, size_of_val};
 
@@ -45,4 +51,9 @@ fn main() {
     size_of::<Word>() * 8;
     type Bool = bool;
     size_of::<Bool>() * 8;
+
+    let _: u32 = (size_of::<u128>() * 8) as u32;
+    let _: u32 = (size_of::<u128>() * 8).try_into().unwrap();
+    let _ = (size_of::<u128>() * 8).pow(5);
+    let _ = &(size_of::<u128>() * 8);
 }
diff --git a/tests/ui/manual_bits.stderr b/tests/ui/manual_bits.stderr
index c4f5af2dcb0..69c591a203d 100644
--- a/tests/ui/manual_bits.stderr
+++ b/tests/ui/manual_bits.stderr
@@ -1,154 +1,178 @@
 error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
-  --> $DIR/manual_bits.rs:9:5
+  --> $DIR/manual_bits.rs:15:5
    |
 LL |     size_of::<i8>() * 8;
-   |     ^^^^^^^^^^^^^^^^^^^ help: consider using: `i8::BITS`
+   |     ^^^^^^^^^^^^^^^^^^^ help: consider using: `i8::BITS as usize`
    |
    = note: `-D clippy::manual-bits` implied by `-D warnings`
 
 error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
-  --> $DIR/manual_bits.rs:10:5
+  --> $DIR/manual_bits.rs:16:5
    |
 LL |     size_of::<i16>() * 8;
-   |     ^^^^^^^^^^^^^^^^^^^^ help: consider using: `i16::BITS`
+   |     ^^^^^^^^^^^^^^^^^^^^ help: consider using: `i16::BITS as usize`
 
 error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
-  --> $DIR/manual_bits.rs:11:5
+  --> $DIR/manual_bits.rs:17:5
    |
 LL |     size_of::<i32>() * 8;
-   |     ^^^^^^^^^^^^^^^^^^^^ help: consider using: `i32::BITS`
+   |     ^^^^^^^^^^^^^^^^^^^^ help: consider using: `i32::BITS as usize`
 
 error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
-  --> $DIR/manual_bits.rs:12:5
+  --> $DIR/manual_bits.rs:18:5
    |
 LL |     size_of::<i64>() * 8;
-   |     ^^^^^^^^^^^^^^^^^^^^ help: consider using: `i64::BITS`
+   |     ^^^^^^^^^^^^^^^^^^^^ help: consider using: `i64::BITS as usize`
 
 error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
-  --> $DIR/manual_bits.rs:13:5
+  --> $DIR/manual_bits.rs:19:5
    |
 LL |     size_of::<i128>() * 8;
-   |     ^^^^^^^^^^^^^^^^^^^^^ help: consider using: `i128::BITS`
+   |     ^^^^^^^^^^^^^^^^^^^^^ help: consider using: `i128::BITS as usize`
 
 error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
-  --> $DIR/manual_bits.rs:14:5
+  --> $DIR/manual_bits.rs:20:5
    |
 LL |     size_of::<isize>() * 8;
-   |     ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `isize::BITS`
+   |     ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `isize::BITS as usize`
 
 error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
-  --> $DIR/manual_bits.rs:16:5
+  --> $DIR/manual_bits.rs:22:5
    |
 LL |     size_of::<u8>() * 8;
-   |     ^^^^^^^^^^^^^^^^^^^ help: consider using: `u8::BITS`
+   |     ^^^^^^^^^^^^^^^^^^^ help: consider using: `u8::BITS as usize`
 
 error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
-  --> $DIR/manual_bits.rs:17:5
+  --> $DIR/manual_bits.rs:23:5
    |
 LL |     size_of::<u16>() * 8;
-   |     ^^^^^^^^^^^^^^^^^^^^ help: consider using: `u16::BITS`
+   |     ^^^^^^^^^^^^^^^^^^^^ help: consider using: `u16::BITS as usize`
 
 error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
-  --> $DIR/manual_bits.rs:18:5
+  --> $DIR/manual_bits.rs:24:5
    |
 LL |     size_of::<u32>() * 8;
-   |     ^^^^^^^^^^^^^^^^^^^^ help: consider using: `u32::BITS`
+   |     ^^^^^^^^^^^^^^^^^^^^ help: consider using: `u32::BITS as usize`
 
 error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
-  --> $DIR/manual_bits.rs:19:5
+  --> $DIR/manual_bits.rs:25:5
    |
 LL |     size_of::<u64>() * 8;
-   |     ^^^^^^^^^^^^^^^^^^^^ help: consider using: `u64::BITS`
+   |     ^^^^^^^^^^^^^^^^^^^^ help: consider using: `u64::BITS as usize`
 
 error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
-  --> $DIR/manual_bits.rs:20:5
+  --> $DIR/manual_bits.rs:26:5
    |
 LL |     size_of::<u128>() * 8;
-   |     ^^^^^^^^^^^^^^^^^^^^^ help: consider using: `u128::BITS`
+   |     ^^^^^^^^^^^^^^^^^^^^^ help: consider using: `u128::BITS as usize`
 
 error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
-  --> $DIR/manual_bits.rs:21:5
+  --> $DIR/manual_bits.rs:27:5
    |
 LL |     size_of::<usize>() * 8;
-   |     ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `usize::BITS`
+   |     ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `usize::BITS as usize`
 
 error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
-  --> $DIR/manual_bits.rs:23:5
+  --> $DIR/manual_bits.rs:29:5
    |
 LL |     8 * size_of::<i8>();
-   |     ^^^^^^^^^^^^^^^^^^^ help: consider using: `i8::BITS`
+   |     ^^^^^^^^^^^^^^^^^^^ help: consider using: `i8::BITS as usize`
 
 error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
-  --> $DIR/manual_bits.rs:24:5
+  --> $DIR/manual_bits.rs:30:5
    |
 LL |     8 * size_of::<i16>();
-   |     ^^^^^^^^^^^^^^^^^^^^ help: consider using: `i16::BITS`
+   |     ^^^^^^^^^^^^^^^^^^^^ help: consider using: `i16::BITS as usize`
 
 error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
-  --> $DIR/manual_bits.rs:25:5
+  --> $DIR/manual_bits.rs:31:5
    |
 LL |     8 * size_of::<i32>();
-   |     ^^^^^^^^^^^^^^^^^^^^ help: consider using: `i32::BITS`
+   |     ^^^^^^^^^^^^^^^^^^^^ help: consider using: `i32::BITS as usize`
 
 error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
-  --> $DIR/manual_bits.rs:26:5
+  --> $DIR/manual_bits.rs:32:5
    |
 LL |     8 * size_of::<i64>();
-   |     ^^^^^^^^^^^^^^^^^^^^ help: consider using: `i64::BITS`
+   |     ^^^^^^^^^^^^^^^^^^^^ help: consider using: `i64::BITS as usize`
 
 error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
-  --> $DIR/manual_bits.rs:27:5
+  --> $DIR/manual_bits.rs:33:5
    |
 LL |     8 * size_of::<i128>();
-   |     ^^^^^^^^^^^^^^^^^^^^^ help: consider using: `i128::BITS`
+   |     ^^^^^^^^^^^^^^^^^^^^^ help: consider using: `i128::BITS as usize`
 
 error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
-  --> $DIR/manual_bits.rs:28:5
+  --> $DIR/manual_bits.rs:34:5
    |
 LL |     8 * size_of::<isize>();
-   |     ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `isize::BITS`
+   |     ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `isize::BITS as usize`
 
 error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
-  --> $DIR/manual_bits.rs:30:5
+  --> $DIR/manual_bits.rs:36:5
    |
 LL |     8 * size_of::<u8>();
-   |     ^^^^^^^^^^^^^^^^^^^ help: consider using: `u8::BITS`
+   |     ^^^^^^^^^^^^^^^^^^^ help: consider using: `u8::BITS as usize`
 
 error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
-  --> $DIR/manual_bits.rs:31:5
+  --> $DIR/manual_bits.rs:37:5
    |
 LL |     8 * size_of::<u16>();
-   |     ^^^^^^^^^^^^^^^^^^^^ help: consider using: `u16::BITS`
+   |     ^^^^^^^^^^^^^^^^^^^^ help: consider using: `u16::BITS as usize`
 
 error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
-  --> $DIR/manual_bits.rs:32:5
+  --> $DIR/manual_bits.rs:38:5
    |
 LL |     8 * size_of::<u32>();
-   |     ^^^^^^^^^^^^^^^^^^^^ help: consider using: `u32::BITS`
+   |     ^^^^^^^^^^^^^^^^^^^^ help: consider using: `u32::BITS as usize`
 
 error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
-  --> $DIR/manual_bits.rs:33:5
+  --> $DIR/manual_bits.rs:39:5
    |
 LL |     8 * size_of::<u64>();
-   |     ^^^^^^^^^^^^^^^^^^^^ help: consider using: `u64::BITS`
+   |     ^^^^^^^^^^^^^^^^^^^^ help: consider using: `u64::BITS as usize`
 
 error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
-  --> $DIR/manual_bits.rs:34:5
+  --> $DIR/manual_bits.rs:40:5
    |
 LL |     8 * size_of::<u128>();
-   |     ^^^^^^^^^^^^^^^^^^^^^ help: consider using: `u128::BITS`
+   |     ^^^^^^^^^^^^^^^^^^^^^ help: consider using: `u128::BITS as usize`
 
 error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
-  --> $DIR/manual_bits.rs:35:5
+  --> $DIR/manual_bits.rs:41:5
    |
 LL |     8 * size_of::<usize>();
-   |     ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `usize::BITS`
+   |     ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `usize::BITS as usize`
 
 error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
-  --> $DIR/manual_bits.rs:45:5
+  --> $DIR/manual_bits.rs:51:5
    |
 LL |     size_of::<Word>() * 8;
-   |     ^^^^^^^^^^^^^^^^^^^^^ help: consider using: `Word::BITS`
+   |     ^^^^^^^^^^^^^^^^^^^^^ help: consider using: `Word::BITS as usize`
+
+error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
+  --> $DIR/manual_bits.rs:55:18
+   |
+LL |     let _: u32 = (size_of::<u128>() * 8) as u32;
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `u128::BITS`
+
+error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
+  --> $DIR/manual_bits.rs:56:18
+   |
+LL |     let _: u32 = (size_of::<u128>() * 8).try_into().unwrap();
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `u128::BITS`
+
+error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
+  --> $DIR/manual_bits.rs:57:13
+   |
+LL |     let _ = (size_of::<u128>() * 8).pow(5);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(u128::BITS as usize)`
+
+error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
+  --> $DIR/manual_bits.rs:58:14
+   |
+LL |     let _ = &(size_of::<u128>() * 8);
+   |              ^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(u128::BITS as usize)`
 
-error: aborting due to 25 previous errors
+error: aborting due to 29 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 67badbeef6ce5452cc47f2463d7146048ce64625 Mon Sep 17 00:00:00 2001
From: Peter Jaszkowiak <p.jaszkow@gmail.com>
Date: Sun, 3 Apr 2022 21:40:58 -0600
Subject: New lint `format_add_strings`

---
 CHANGELOG.md                                       |  1 +
 clippy_dev/src/new_lint.rs                         |  6 +-
 clippy_dev/src/update_lints.rs                     | 16 +++--
 clippy_lints/src/format_push_string.rs             | 77 ++++++++++++++++++++++
 .../src/inconsistent_struct_constructor.rs         |  3 +-
 clippy_lints/src/lib.register_all.rs               |  1 +
 clippy_lints/src/lib.register_lints.rs             |  1 +
 clippy_lints/src/lib.register_perf.rs              |  1 +
 clippy_lints/src/lib.rs                            |  2 +
 clippy_lints/src/trait_bounds.rs                   |  9 +--
 clippy_utils/src/sugg.rs                           | 10 ++-
 lintcheck/src/main.rs                              | 15 +++--
 tests/ui/format_push_string.rs                     |  7 ++
 tests/ui/format_push_string.stderr                 | 19 ++++++
 tests/ui/identity_op.rs                            |  4 +-
 tests/ui/identity_op.stderr                        | 36 +++++-----
 16 files changed, 163 insertions(+), 45 deletions(-)
 create mode 100644 clippy_lints/src/format_push_string.rs
 create mode 100644 tests/ui/format_push_string.rs
 create mode 100644 tests/ui/format_push_string.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index ef21dbac820..39786c08156 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3314,6 +3314,7 @@ Released 2018-09-13
 [`forget_non_drop`]: https://rust-lang.github.io/rust-clippy/master/index.html#forget_non_drop
 [`forget_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#forget_ref
 [`format_in_format_args`]: https://rust-lang.github.io/rust-clippy/master/index.html#format_in_format_args
+[`format_push_string`]: https://rust-lang.github.io/rust-clippy/master/index.html#format_push_string
 [`from_iter_instead_of_collect`]: https://rust-lang.github.io/rust-clippy/master/index.html#from_iter_instead_of_collect
 [`from_over_into`]: https://rust-lang.github.io/rust-clippy/master/index.html#from_over_into
 [`from_str_radix_10`]: https://rust-lang.github.io/rust-clippy/master/index.html#from_str_radix_10
diff --git a/clippy_dev/src/new_lint.rs b/clippy_dev/src/new_lint.rs
index 7a3fd131761..10f67d301f8 100644
--- a/clippy_dev/src/new_lint.rs
+++ b/clippy_dev/src/new_lint.rs
@@ -1,5 +1,6 @@
 use crate::clippy_project_root;
 use indoc::indoc;
+use std::fmt::Write as _;
 use std::fs::{self, OpenOptions};
 use std::io::prelude::*;
 use std::io::{self, ErrorKind};
@@ -232,7 +233,8 @@ fn get_lint_file_contents(lint: &LintData<'_>, enable_msrv: bool) -> String {
         )
     });
 
-    result.push_str(&format!(
+    let _ = write!(
+        result,
         indoc! {r#"
             declare_clippy_lint! {{
                 /// ### What it does
@@ -256,7 +258,7 @@ fn get_lint_file_contents(lint: &LintData<'_>, enable_msrv: bool) -> String {
         version = version,
         name_upper = name_upper,
         category = category,
-    ));
+    );
 
     result.push_str(&if enable_msrv {
         format!(
diff --git a/clippy_dev/src/update_lints.rs b/clippy_dev/src/update_lints.rs
index 59db51fbfac..d25e42f2468 100644
--- a/clippy_dev/src/update_lints.rs
+++ b/clippy_dev/src/update_lints.rs
@@ -217,12 +217,13 @@ fn gen_lint_group_list<'a>(group_name: &str, lints: impl Iterator<Item = &'a Lin
 
     let mut output = GENERATED_FILE_COMMENT.to_string();
 
-    output.push_str(&format!(
-        "store.register_group(true, \"clippy::{0}\", Some(\"clippy_{0}\"), vec![\n",
+    let _ = writeln!(
+        output,
+        "store.register_group(true, \"clippy::{0}\", Some(\"clippy_{0}\"), vec![",
         group_name
-    ));
+    );
     for (module, name) in details {
-        output.push_str(&format!("    LintId::of({}::{}),\n", module, name));
+        let _ = writeln!(output, "    LintId::of({}::{}),", module, name);
     }
     output.push_str("])\n");
 
@@ -235,7 +236,8 @@ fn gen_deprecated(lints: &[DeprecatedLint]) -> String {
     let mut output = GENERATED_FILE_COMMENT.to_string();
     output.push_str("{\n");
     for lint in lints {
-        output.push_str(&format!(
+        let _ = write!(
+            output,
             concat!(
                 "    store.register_removed(\n",
                 "        \"clippy::{}\",\n",
@@ -243,7 +245,7 @@ fn gen_deprecated(lints: &[DeprecatedLint]) -> String {
                 "    );\n"
             ),
             lint.name, lint.reason,
-        ));
+        );
     }
     output.push_str("}\n");
 
@@ -269,7 +271,7 @@ fn gen_register_lint_list<'a>(
         if !is_public {
             output.push_str("    #[cfg(feature = \"internal\")]\n");
         }
-        output.push_str(&format!("    {}::{},\n", module_name, lint_name));
+        let _ = writeln!(output, "    {}::{},", module_name, lint_name);
     }
     output.push_str("])\n");
 
diff --git a/clippy_lints/src/format_push_string.rs b/clippy_lints/src/format_push_string.rs
new file mode 100644
index 00000000000..ee15ae9f59a
--- /dev/null
+++ b/clippy_lints/src/format_push_string.rs
@@ -0,0 +1,77 @@
+use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::{match_def_path, paths, peel_hir_expr_refs};
+use rustc_hir::{BinOpKind, Expr, ExprKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::sym;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Detects cases where the result of a `format!` call is
+    /// appended to an existing `String`.
+    ///
+    /// ### Why is this bad?
+    /// Introduces an extra, avoidable heap allocation.
+    ///
+    /// ### Example
+    /// ```rust
+    /// let mut s = String::new();
+    /// s += &format!("0x{:X}", 1024);
+    /// s.push_str(&format!("0x{:X}", 1024));
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// use std::fmt::Write as _; // import without risk of name clashing
+    ///
+    /// let mut s = String::new();
+    /// let _ = write!(s, "0x{:X}", 1024);
+    /// ```
+    #[clippy::version = "1.61.0"]
+    pub FORMAT_PUSH_STRING,
+    perf,
+    "`format!(..)` appended to existing `String`"
+}
+declare_lint_pass!(FormatPushString => [FORMAT_PUSH_STRING]);
+
+fn is_string(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
+    is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(e).peel_refs(), sym::String)
+}
+fn is_format(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
+    if let Some(macro_def_id) = e.span.ctxt().outer_expn_data().macro_def_id {
+        cx.tcx.get_diagnostic_name(macro_def_id) == Some(sym::format_macro)
+    } else {
+        false
+    }
+}
+
+impl<'tcx> LateLintPass<'tcx> for FormatPushString {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        let arg = match expr.kind {
+            ExprKind::MethodCall(_, [_, arg], _) => {
+                if let Some(fn_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id) &&
+                match_def_path(cx, fn_def_id, &paths::PUSH_STR) {
+                    arg
+                } else {
+                    return;
+                }
+            }
+            ExprKind::AssignOp(op, left, arg)
+            if op.node == BinOpKind::Add && is_string(cx, left) => {
+                arg
+            },
+            _ => return,
+        };
+        let (arg, _) = peel_hir_expr_refs(arg);
+        if is_format(cx, arg) {
+            span_lint_and_help(
+                cx,
+                FORMAT_PUSH_STRING,
+                expr.span,
+                "`format!(..)` appended to existing `String`",
+                None,
+                "consider using `write!` to avoid the extra allocation",
+            );
+        }
+    }
+}
diff --git a/clippy_lints/src/inconsistent_struct_constructor.rs b/clippy_lints/src/inconsistent_struct_constructor.rs
index c8ec2f45137..14b22d2b50d 100644
--- a/clippy_lints/src/inconsistent_struct_constructor.rs
+++ b/clippy_lints/src/inconsistent_struct_constructor.rs
@@ -7,6 +7,7 @@ use rustc_hir::{self as hir, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::symbol::Symbol;
+use std::fmt::Write as _;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -89,7 +90,7 @@ impl<'tcx> LateLintPass<'tcx> for InconsistentStructConstructor {
                 let mut fields_snippet = String::new();
                 let (last_ident, idents) = ordered_fields.split_last().unwrap();
                 for ident in idents {
-                    fields_snippet.push_str(&format!("{}, ", ident));
+                    let _ = write!(fields_snippet, "{}, ", ident);
                 }
                 fields_snippet.push_str(&last_ident.to_string());
 
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 52c440de9dd..2fa59733365 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -77,6 +77,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(format_args::TO_STRING_IN_FORMAT_ARGS),
     LintId::of(format_impl::PRINT_IN_FORMAT_IMPL),
     LintId::of(format_impl::RECURSIVE_FORMAT_IMPL),
+    LintId::of(format_push_string::FORMAT_PUSH_STRING),
     LintId::of(formatting::POSSIBLE_MISSING_COMMA),
     LintId::of(formatting::SUSPICIOUS_ASSIGNMENT_FORMATTING),
     LintId::of(formatting::SUSPICIOUS_ELSE_FORMATTING),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 9820b7727af..c608f634291 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -165,6 +165,7 @@ store.register_lints(&[
     format_args::TO_STRING_IN_FORMAT_ARGS,
     format_impl::PRINT_IN_FORMAT_IMPL,
     format_impl::RECURSIVE_FORMAT_IMPL,
+    format_push_string::FORMAT_PUSH_STRING,
     formatting::POSSIBLE_MISSING_COMMA,
     formatting::SUSPICIOUS_ASSIGNMENT_FORMATTING,
     formatting::SUSPICIOUS_ELSE_FORMATTING,
diff --git a/clippy_lints/src/lib.register_perf.rs b/clippy_lints/src/lib.register_perf.rs
index f2f5c988d8f..8f361fdad4a 100644
--- a/clippy_lints/src/lib.register_perf.rs
+++ b/clippy_lints/src/lib.register_perf.rs
@@ -7,6 +7,7 @@ store.register_group(true, "clippy::perf", Some("clippy_perf"), vec![
     LintId::of(escape::BOXED_LOCAL),
     LintId::of(format_args::FORMAT_IN_FORMAT_ARGS),
     LintId::of(format_args::TO_STRING_IN_FORMAT_ARGS),
+    LintId::of(format_push_string::FORMAT_PUSH_STRING),
     LintId::of(large_const_arrays::LARGE_CONST_ARRAYS),
     LintId::of(large_enum_variant::LARGE_ENUM_VARIANT),
     LintId::of(loops::MANUAL_MEMCPY),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 604bd44c6c5..88e8a0cc2af 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -231,6 +231,7 @@ mod floating_point_arithmetic;
 mod format;
 mod format_args;
 mod format_impl;
+mod format_push_string;
 mod formatting;
 mod from_over_into;
 mod from_str_radix_10;
@@ -873,6 +874,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_early_pass(|| Box::new(empty_structs_with_brackets::EmptyStructsWithBrackets));
     store.register_late_pass(|| Box::new(unnecessary_owned_empty_strings::UnnecessaryOwnedEmptyStrings));
     store.register_early_pass(|| Box::new(pub_use::PubUse));
+    store.register_late_pass(|| Box::new(format_push_string::FormatPushString));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/trait_bounds.rs b/clippy_lints/src/trait_bounds.rs
index 43e0132a7ec..1551d0ecb74 100644
--- a/clippy_lints/src/trait_bounds.rs
+++ b/clippy_lints/src/trait_bounds.rs
@@ -14,6 +14,7 @@ use rustc_hir::{
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::Span;
+use std::fmt::Write as _;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -184,19 +185,19 @@ impl TraitBounds {
                     for b in v.iter() {
                         if let GenericBound::Trait(ref poly_trait_ref, _) = b {
                             let path = &poly_trait_ref.trait_ref.path;
-                            hint_string.push_str(&format!(
+                            let _ = write!(hint_string,
                                 " {} +",
                                 snippet_with_applicability(cx, path.span, "..", &mut applicability)
-                            ));
+                            );
                         }
                     }
                     for b in p.bounds.iter() {
                         if let GenericBound::Trait(ref poly_trait_ref, _) = b {
                             let path = &poly_trait_ref.trait_ref.path;
-                            hint_string.push_str(&format!(
+                            let _ = write!(hint_string,
                                 " {} +",
                                 snippet_with_applicability(cx, path.span, "..", &mut applicability)
-                            ));
+                            );
                         }
                     }
                     hint_string.truncate(hint_string.len() - 2);
diff --git a/clippy_utils/src/sugg.rs b/clippy_utils/src/sugg.rs
index 1fc9979f3dd..ffd2b5aabcf 100644
--- a/clippy_utils/src/sugg.rs
+++ b/clippy_utils/src/sugg.rs
@@ -18,7 +18,7 @@ use rustc_span::source_map::{BytePos, CharPos, Pos, Span, SyntaxContext};
 use rustc_typeck::expr_use_visitor::{Delegate, ExprUseVisitor, PlaceBase, PlaceWithHirId};
 use std::borrow::Cow;
 use std::convert::TryInto;
-use std::fmt::Display;
+use std::fmt::{Display, Write as _};
 use std::iter;
 use std::ops::{Add, Neg, Not, Sub};
 
@@ -901,7 +901,7 @@ impl<'tcx> Delegate<'tcx> for DerefDelegate<'_, 'tcx> {
             if cmt.place.projections.is_empty() {
                 // handle item without any projection, that needs an explicit borrowing
                 // i.e.: suggest `&x` instead of `x`
-                self.suggestion_start.push_str(&format!("{}&{}", start_snip, ident_str));
+                let _ = write!(self.suggestion_start, "{}&{}", start_snip, ident_str);
             } else {
                 // cases where a parent `Call` or `MethodCall` is using the item
                 // i.e.: suggest `.contains(&x)` for `.find(|x| [1, 2, 3].contains(x)).is_none()`
@@ -916,8 +916,7 @@ impl<'tcx> Delegate<'tcx> for DerefDelegate<'_, 'tcx> {
                         // given expression is the self argument and will be handled completely by the compiler
                         // i.e.: `|x| x.is_something()`
                         ExprKind::MethodCall(_, [self_expr, ..], _) if self_expr.hir_id == cmt.hir_id => {
-                            self.suggestion_start
-                                .push_str(&format!("{}{}", start_snip, ident_str_with_proj));
+                            let _ = write!(self.suggestion_start, "{}{}", start_snip, ident_str_with_proj);
                             self.next_pos = span.hi();
                             return;
                         },
@@ -1025,8 +1024,7 @@ impl<'tcx> Delegate<'tcx> for DerefDelegate<'_, 'tcx> {
                     }
                 }
 
-                self.suggestion_start
-                    .push_str(&format!("{}{}", start_snip, replacement_str));
+                let _ = write!(self.suggestion_start, "{}{}", start_snip, replacement_str);
             }
             self.next_pos = span.hi();
         }
diff --git a/lintcheck/src/main.rs b/lintcheck/src/main.rs
index 9af8dcc7726..16cf728e3cb 100644
--- a/lintcheck/src/main.rs
+++ b/lintcheck/src/main.rs
@@ -8,6 +8,7 @@
 #![allow(clippy::collapsible_else_if)]
 
 use std::ffi::OsStr;
+use std::fmt::Write as _;
 use std::process::Command;
 use std::sync::atomic::{AtomicUsize, Ordering};
 use std::{collections::HashMap, io::ErrorKind};
@@ -110,11 +111,12 @@ impl ClippyWarning {
             let lint = format!("`{}`", self.linttype);
 
             let mut output = String::from("| ");
-            output.push_str(&format!(
+            let _ = write!(
+                output,
                 "[`{}`](../target/lintcheck/sources/{}#L{})",
                 file_with_pos, file, self.line
-            ));
-            output.push_str(&format!(r#" | {:<50} | "{}" |"#, lint, self.message));
+            );
+            let _ = write!(output, r#" | {:<50} | "{}" |"#, lint, self.message);
             output.push('\n');
             output
         } else {
@@ -835,10 +837,11 @@ pub fn main() {
         text.push_str("| file | lint | message |\n");
         text.push_str("| --- | --- | --- |\n");
     }
-    text.push_str(&format!("{}", all_msgs.join("")));
+    write!(text, "{}", all_msgs.join(""));
     text.push_str("\n\n### ICEs:\n");
-    ices.iter()
-        .for_each(|(cratename, msg)| text.push_str(&format!("{}: '{}'", cratename, msg)));
+    for (cratename, msg) in ices.iter() {
+        let _ = write!(text, "{}: '{}'", cratename, msg);
+    }
 
     println!("Writing logs to {}", config.lintcheck_results_path.display());
     std::fs::create_dir_all(config.lintcheck_results_path.parent().unwrap()).unwrap();
diff --git a/tests/ui/format_push_string.rs b/tests/ui/format_push_string.rs
new file mode 100644
index 00000000000..4db13d650eb
--- /dev/null
+++ b/tests/ui/format_push_string.rs
@@ -0,0 +1,7 @@
+#![warn(clippy::format_push_string)]
+
+fn main() {
+    let mut string = String::new();
+    string += &format!("{:?}", 1234);
+    string.push_str(&format!("{:?}", 5678));
+}
diff --git a/tests/ui/format_push_string.stderr b/tests/ui/format_push_string.stderr
new file mode 100644
index 00000000000..953784bcc06
--- /dev/null
+++ b/tests/ui/format_push_string.stderr
@@ -0,0 +1,19 @@
+error: `format!(..)` appended to existing `String`
+  --> $DIR/format_push_string.rs:5:5
+   |
+LL |     string += &format!("{:?}", 1234);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::format-push-string` implied by `-D warnings`
+   = help: consider using `write!` to avoid the extra allocation
+
+error: `format!(..)` appended to existing `String`
+  --> $DIR/format_push_string.rs:6:5
+   |
+LL |     string.push_str(&format!("{:?}", 5678));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using `write!` to avoid the extra allocation
+
+error: aborting due to 2 previous errors
+
diff --git a/tests/ui/identity_op.rs b/tests/ui/identity_op.rs
index edc3fe1aec1..9d39d769635 100644
--- a/tests/ui/identity_op.rs
+++ b/tests/ui/identity_op.rs
@@ -1,3 +1,5 @@
+use std::fmt::Write as _;
+
 const ONE: i64 = 1;
 const NEG_ONE: i64 = -1;
 const ZERO: i64 = 0;
@@ -7,7 +9,7 @@ struct A(String);
 impl std::ops::Shl<i32> for A {
     type Output = A;
     fn shl(mut self, other: i32) -> Self {
-        self.0.push_str(&format!("{}", other));
+        let _ = write!(self.0, "{}", other);
         self
     }
 }
diff --git a/tests/ui/identity_op.stderr b/tests/ui/identity_op.stderr
index 706f01a3dd6..e3c156b5429 100644
--- a/tests/ui/identity_op.stderr
+++ b/tests/ui/identity_op.stderr
@@ -1,5 +1,5 @@
 error: the operation is ineffective. Consider reducing it to `x`
-  --> $DIR/identity_op.rs:37:5
+  --> $DIR/identity_op.rs:39:5
    |
 LL |     x + 0;
    |     ^^^^^
@@ -7,103 +7,103 @@ LL |     x + 0;
    = note: `-D clippy::identity-op` implied by `-D warnings`
 
 error: the operation is ineffective. Consider reducing it to `x`
-  --> $DIR/identity_op.rs:38:5
+  --> $DIR/identity_op.rs:40:5
    |
 LL |     x + (1 - 1);
    |     ^^^^^^^^^^^
 
 error: the operation is ineffective. Consider reducing it to `x`
-  --> $DIR/identity_op.rs:40:5
+  --> $DIR/identity_op.rs:42:5
    |
 LL |     0 + x;
    |     ^^^^^
 
 error: the operation is ineffective. Consider reducing it to `x`
-  --> $DIR/identity_op.rs:43:5
+  --> $DIR/identity_op.rs:45:5
    |
 LL |     x | (0);
    |     ^^^^^^^
 
 error: the operation is ineffective. Consider reducing it to `x`
-  --> $DIR/identity_op.rs:46:5
+  --> $DIR/identity_op.rs:48:5
    |
 LL |     x * 1;
    |     ^^^^^
 
 error: the operation is ineffective. Consider reducing it to `x`
-  --> $DIR/identity_op.rs:47:5
+  --> $DIR/identity_op.rs:49:5
    |
 LL |     1 * x;
    |     ^^^^^
 
 error: the operation is ineffective. Consider reducing it to `x`
-  --> $DIR/identity_op.rs:53:5
+  --> $DIR/identity_op.rs:55:5
    |
 LL |     -1 & x;
    |     ^^^^^^
 
 error: the operation is ineffective. Consider reducing it to `u`
-  --> $DIR/identity_op.rs:56:5
+  --> $DIR/identity_op.rs:58:5
    |
 LL |     u & 255;
    |     ^^^^^^^
 
 error: the operation is ineffective. Consider reducing it to `42`
-  --> $DIR/identity_op.rs:59:5
+  --> $DIR/identity_op.rs:61:5
    |
 LL |     42 << 0;
    |     ^^^^^^^
 
 error: the operation is ineffective. Consider reducing it to `1`
-  --> $DIR/identity_op.rs:60:5
+  --> $DIR/identity_op.rs:62:5
    |
 LL |     1 >> 0;
    |     ^^^^^^
 
 error: the operation is ineffective. Consider reducing it to `42`
-  --> $DIR/identity_op.rs:61:5
+  --> $DIR/identity_op.rs:63:5
    |
 LL |     42 >> 0;
    |     ^^^^^^^
 
 error: the operation is ineffective. Consider reducing it to `&x`
-  --> $DIR/identity_op.rs:62:5
+  --> $DIR/identity_op.rs:64:5
    |
 LL |     &x >> 0;
    |     ^^^^^^^
 
 error: the operation is ineffective. Consider reducing it to `x`
-  --> $DIR/identity_op.rs:63:5
+  --> $DIR/identity_op.rs:65:5
    |
 LL |     x >> &0;
    |     ^^^^^^^
 
 error: the operation is ineffective. Consider reducing it to `2`
-  --> $DIR/identity_op.rs:70:5
+  --> $DIR/identity_op.rs:72:5
    |
 LL |     2 % 3;
    |     ^^^^^
 
 error: the operation is ineffective. Consider reducing it to `-2`
-  --> $DIR/identity_op.rs:71:5
+  --> $DIR/identity_op.rs:73:5
    |
 LL |     -2 % 3;
    |     ^^^^^^
 
 error: the operation is ineffective. Consider reducing it to `2`
-  --> $DIR/identity_op.rs:72:5
+  --> $DIR/identity_op.rs:74:5
    |
 LL |     2 % -3 + x;
    |     ^^^^^^
 
 error: the operation is ineffective. Consider reducing it to `-2`
-  --> $DIR/identity_op.rs:73:5
+  --> $DIR/identity_op.rs:75:5
    |
 LL |     -2 % -3 + x;
    |     ^^^^^^^
 
 error: the operation is ineffective. Consider reducing it to `1`
-  --> $DIR/identity_op.rs:74:9
+  --> $DIR/identity_op.rs:76:9
    |
 LL |     x + 1 % 3;
    |         ^^^^^
-- 
cgit 1.4.1-3-g733a5


From 3bd0ac7a8d21b5b2c4e64dc39abf99c75af12916 Mon Sep 17 00:00:00 2001
From: Fridtjof Stoldt <xFrednet@gmail.com>
Date: Thu, 14 Apr 2022 07:02:59 +0200
Subject: Update lint description  of `clippy::manual_bits` to include the `as
 usize` cast

---
 clippy_lints/src/manual_bits.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_bits.rs b/clippy_lints/src/manual_bits.rs
index 44ff151ea52..ac3d9447b6b 100644
--- a/clippy_lints/src/manual_bits.rs
+++ b/clippy_lints/src/manual_bits.rs
@@ -24,7 +24,7 @@ declare_clippy_lint! {
     /// ```
     /// Use instead:
     /// ```rust
-    /// usize::BITS;
+    /// usize::BITS as usize;
     /// ```
     #[clippy::version = "1.60.0"]
     pub MANUAL_BITS,
-- 
cgit 1.4.1-3-g733a5


From 262b35ea2c4dd9a16c28bf40cb5c124f664ce96c Mon Sep 17 00:00:00 2001
From: infrandomness <infrandomness@gmail.com>
Date: Fri, 8 Apr 2022 20:07:19 +0200
Subject: Introduce option_take_on_temporary lints

This lint checks if Option::take() is used on a temporary value (a value
that is not of type &mut Option and that is not a Place expression) to
suggest omitting take()
---
 CHANGELOG.md                                     |  1 +
 clippy_lints/src/lib.register_all.rs             |  1 +
 clippy_lints/src/lib.register_complexity.rs      |  1 +
 clippy_lints/src/lib.register_lints.rs           |  1 +
 clippy_lints/src/lib.register_suspicious.rs      |  1 +
 clippy_lints/src/methods/mod.rs                  | 21 +++++++++++++++++++++
 clippy_lints/src/methods/needless_option_take.rs | 23 +++++++++++++++++++++++
 tests/ui/needless_option_take.fixed              | 15 +++++++++++++++
 tests/ui/needless_option_take.rs                 |  5 +++++
 tests/ui/needless_option_take.stderr             | 10 ++++++++++
 10 files changed, 79 insertions(+)
 create mode 100644 clippy_lints/src/methods/needless_option_take.rs
 create mode 100644 tests/ui/needless_option_take.fixed
 create mode 100644 tests/ui/needless_option_take.rs
 create mode 100644 tests/ui/needless_option_take.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 858547c84c1..d4096ca89df 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3473,6 +3473,7 @@ Released 2018-09-13
 [`needless_lifetimes`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_lifetimes
 [`needless_match`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_match
 [`needless_option_as_deref`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_option_as_deref
+[`needless_option_take`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_option_take
 [`needless_pass_by_value`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_pass_by_value
 [`needless_question_mark`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_question_mark
 [`needless_range_loop`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_range_loop
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 52c440de9dd..84e3176c003 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -183,6 +183,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(methods::MAP_FLATTEN),
     LintId::of(methods::MAP_IDENTITY),
     LintId::of(methods::NEEDLESS_OPTION_AS_DEREF),
+    LintId::of(methods::NEEDLESS_OPTION_TAKE),
     LintId::of(methods::NEEDLESS_SPLITN),
     LintId::of(methods::NEW_RET_NO_SELF),
     LintId::of(methods::OK_EXPECT),
diff --git a/clippy_lints/src/lib.register_complexity.rs b/clippy_lints/src/lib.register_complexity.rs
index 10369a855ae..2f6ebd445eb 100644
--- a/clippy_lints/src/lib.register_complexity.rs
+++ b/clippy_lints/src/lib.register_complexity.rs
@@ -45,6 +45,7 @@ store.register_group(true, "clippy::complexity", Some("clippy_complexity"), vec!
     LintId::of(methods::MAP_FLATTEN),
     LintId::of(methods::MAP_IDENTITY),
     LintId::of(methods::NEEDLESS_OPTION_AS_DEREF),
+    LintId::of(methods::NEEDLESS_OPTION_TAKE),
     LintId::of(methods::NEEDLESS_SPLITN),
     LintId::of(methods::OPTION_AS_REF_DEREF),
     LintId::of(methods::OPTION_FILTER_MAP),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index cfaa6871b50..aa9435f3b59 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -322,6 +322,7 @@ store.register_lints(&[
     methods::MAP_IDENTITY,
     methods::MAP_UNWRAP_OR,
     methods::NEEDLESS_OPTION_AS_DEREF,
+    methods::NEEDLESS_OPTION_TAKE,
     methods::NEEDLESS_SPLITN,
     methods::NEW_RET_NO_SELF,
     methods::OK_EXPECT,
diff --git a/clippy_lints/src/lib.register_suspicious.rs b/clippy_lints/src/lib.register_suspicious.rs
index 82f45b5fd58..6588ca4a4a7 100644
--- a/clippy_lints/src/lib.register_suspicious.rs
+++ b/clippy_lints/src/lib.register_suspicious.rs
@@ -22,6 +22,7 @@ store.register_group(true, "clippy::suspicious", Some("clippy_suspicious"), vec!
     LintId::of(loops::EMPTY_LOOP),
     LintId::of(loops::FOR_LOOPS_OVER_FALLIBLES),
     LintId::of(loops::MUT_RANGE_BOUND),
+    LintId::of(methods::OPTION_TAKE_ON_TEMPORARY),
     LintId::of(methods::SUSPICIOUS_MAP),
     LintId::of(mut_key::MUTABLE_KEY_TYPE),
     LintId::of(octal_escapes::OCTAL_ESCAPES),
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 82f4769a699..3d4c193691a 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -43,6 +43,7 @@ mod map_flatten;
 mod map_identity;
 mod map_unwrap_or;
 mod needless_option_as_deref;
+mod needless_option_take;
 mod ok_expect;
 mod option_as_ref_deref;
 mod option_map_or_none;
@@ -2162,6 +2163,24 @@ declare_clippy_lint! {
     "use of `char::is_digit(..)` with literal radix of 10 or 16"
 }
 
+declare_clippy_lint! {
+    ///
+    /// ### Why is this bad?
+    ///
+    /// ### Example
+    /// ```rust
+    /// // example code where clippy issues a warning
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// // example code which does not raise clippy warning
+    /// ```
+    #[clippy::version = "1.61.0"]
+    pub NEEDLESS_OPTION_TAKE,
+    suspicious,
+    "using `.as_ref().take()` on a temporary value"
+}
+
 pub struct Methods {
     avoid_breaking_exported_api: bool,
     msrv: Option<RustcVersion>,
@@ -2251,6 +2270,7 @@ impl_lint_pass!(Methods => [
     ERR_EXPECT,
     NEEDLESS_OPTION_AS_DEREF,
     IS_DIGIT_ASCII_RADIX,
+    NEEDLESS_OPTION_TAKE,
 ]);
 
 /// Extracts a method call name, args, and `Span` of the method name.
@@ -2623,6 +2643,7 @@ fn check_methods<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, msrv: Optio
                     }
                 }
             },
+            ("take", []) => needless_option_take::check(cx, expr, recv),
             ("to_os_string" | "to_owned" | "to_path_buf" | "to_vec", []) => {
                 implicit_clone::check(cx, name, expr, recv);
             },
diff --git a/clippy_lints/src/methods/needless_option_take.rs b/clippy_lints/src/methods/needless_option_take.rs
new file mode 100644
index 00000000000..b3696273e1d
--- /dev/null
+++ b/clippy_lints/src/methods/needless_option_take.rs
@@ -0,0 +1,23 @@
+use clippy_utils::diagnostics::span_lint;
+use clippy_utils::ty::is_type_diagnostic_item;
+use rustc_hir::Expr;
+use rustc_lint::LateContext;
+use rustc_span::sym::Result as sym_result;
+
+use super::NEEDLESS_OPTION_TAKE;
+
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, recv: &'tcx Expr<'_>) {
+    if_chain! {
+        if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(recv), sym_result);
+        let result_type = cx.typeck_results().expr_ty(recv);
+
+        then {
+            span_lint(
+                cx,
+                NEEDLESS_OPTION_TAKE,
+                expr.span,
+                "Format test"
+            );
+        }
+    };
+}
diff --git a/tests/ui/needless_option_take.fixed b/tests/ui/needless_option_take.fixed
new file mode 100644
index 00000000000..29691e81666
--- /dev/null
+++ b/tests/ui/needless_option_take.fixed
@@ -0,0 +1,15 @@
+// run-rustfix
+
+fn main() {
+    println!("Testing non erroneous option_take_on_temporary");
+    let mut option = Some(1);
+    let _ = Box::new(move || option.take().unwrap());
+
+    println!("Testing non erroneous option_take_on_temporary");
+    let x = Some(3);
+    x.as_ref();
+
+    println!("Testing erroneous option_take_on_temporary");
+    let x = Some(3);
+    x.as_ref();
+}
diff --git a/tests/ui/needless_option_take.rs b/tests/ui/needless_option_take.rs
new file mode 100644
index 00000000000..2b32b9467f5
--- /dev/null
+++ b/tests/ui/needless_option_take.rs
@@ -0,0 +1,5 @@
+fn main() {
+    println!("Testing option_take_on_temporary");
+    let x = Some(3);
+    let y = x.as_ref().take();
+}
diff --git a/tests/ui/needless_option_take.stderr b/tests/ui/needless_option_take.stderr
new file mode 100644
index 00000000000..cb3bf015b36
--- /dev/null
+++ b/tests/ui/needless_option_take.stderr
@@ -0,0 +1,10 @@
+error: called `Option::take()` on a temporary value
+  --> $DIR/needless_option_take.rs:14:5
+   |
+LL |     x.as_ref().take();
+   |     ^^^^^^^^^^^^^^^^^ help: try: `x.as_ref()`
+   |
+   = note: `-D clippy::needless-option-take` implied by `-D warnings`
+
+error: aborting due to previous error
+
-- 
cgit 1.4.1-3-g733a5


From ee9281d7a241c448f6bcbbb6cb8bdf8b17251a92 Mon Sep 17 00:00:00 2001
From: infrandomness <infrandomness@gmail.com>
Date: Fri, 8 Apr 2022 21:27:01 +0200
Subject: Implement checks to the expression

The implemented checks are for checking if the expression is either of
type `Option` and isn't a syntactical place
---
 clippy_lints/src/methods/needless_option_take.rs | 21 ++++++++++++++-------
 1 file changed, 14 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/needless_option_take.rs b/clippy_lints/src/methods/needless_option_take.rs
index b3696273e1d..27ef9009328 100644
--- a/clippy_lints/src/methods/needless_option_take.rs
+++ b/clippy_lints/src/methods/needless_option_take.rs
@@ -2,15 +2,17 @@ use clippy_utils::diagnostics::span_lint;
 use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_hir::Expr;
 use rustc_lint::LateContext;
-use rustc_span::sym::Result as sym_result;
+use rustc_span::sym;
 
 use super::NEEDLESS_OPTION_TAKE;
 
-pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, recv: &'tcx Expr<'_>) {
-    if_chain! {
-        if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(recv), sym_result);
-        let result_type = cx.typeck_results().expr_ty(recv);
-
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, _recv: &'tcx Expr<'_>) {
+    // Checks if expression type is equal to sym::Option and if the expr is not a syntactic place
+    if is_expr_option(cx, expr) && !expr.is_syntactic_place_expr() {
+        span_lint(cx, OPTION_TAKE_ON_TEMPORARY, expr.span, "Format test");
+    }
+    /*    if_chain! {
+        is_expr_option(cx, expr);
         then {
             span_lint(
                 cx,
@@ -19,5 +21,10 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, recv: &'
                 "Format test"
             );
         }
-    };
+    };*/
+}
+
+fn is_expr_option(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+    let expr_type = cx.typeck_results().expr_ty(expr);
+    is_type_diagnostic_item(cx, expr_type, sym::Option)
 }
-- 
cgit 1.4.1-3-g733a5


From f8f144117da48b52f2c65292402dedcb1c59d9c1 Mon Sep 17 00:00:00 2001
From: infrandomness <infrandomness@gmail.com>
Date: Fri, 8 Apr 2022 21:54:44 +0200
Subject: Swap span_lint for span_lint_and_sugg

This implements a machine applicable suggestion to any matched usage of
`.as_ref().take()``
---
 clippy_lints/src/methods/needless_option_take.rs | 31 +++++++++++++-----------
 tests/ui/needless_option_take.rs                 |  2 ++
 tests/ui/option_take_on_temporary.fixed          |  7 ++++++
 3 files changed, 26 insertions(+), 14 deletions(-)
 create mode 100644 tests/ui/option_take_on_temporary.fixed

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/needless_option_take.rs b/clippy_lints/src/methods/needless_option_take.rs
index 27ef9009328..57a43ff606a 100644
--- a/clippy_lints/src/methods/needless_option_take.rs
+++ b/clippy_lints/src/methods/needless_option_take.rs
@@ -1,27 +1,30 @@
-use clippy_utils::diagnostics::span_lint;
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::is_type_diagnostic_item;
+use rustc_errors::Applicability;
 use rustc_hir::Expr;
 use rustc_lint::LateContext;
 use rustc_span::sym;
 
 use super::NEEDLESS_OPTION_TAKE;
 
-pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, _recv: &'tcx Expr<'_>) {
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, recv: &'tcx Expr<'_>) {
     // Checks if expression type is equal to sym::Option and if the expr is not a syntactic place
     if is_expr_option(cx, expr) && !expr.is_syntactic_place_expr() {
-        span_lint(cx, OPTION_TAKE_ON_TEMPORARY, expr.span, "Format test");
+        let mut applicability = Applicability::MachineApplicable;
+        span_lint_and_sugg(
+            cx,
+            NEEDLESS_OPTION_TAKE,
+            expr.span,
+            "Called `Option::take()` on a temporary value",
+            "try",
+            format!(
+                "{}",
+                snippet_with_applicability(cx, recv.span, "..", &mut applicability)
+            ),
+            applicability,
+        );
     }
-    /*    if_chain! {
-        is_expr_option(cx, expr);
-        then {
-            span_lint(
-                cx,
-                NEEDLESS_OPTION_TAKE,
-                expr.span,
-                "Format test"
-            );
-        }
-    };*/
 }
 
 fn is_expr_option(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
diff --git a/tests/ui/needless_option_take.rs b/tests/ui/needless_option_take.rs
index 2b32b9467f5..eb57ffeab45 100644
--- a/tests/ui/needless_option_take.rs
+++ b/tests/ui/needless_option_take.rs
@@ -1,3 +1,5 @@
+// run-rustfix
+
 fn main() {
     println!("Testing option_take_on_temporary");
     let x = Some(3);
diff --git a/tests/ui/option_take_on_temporary.fixed b/tests/ui/option_take_on_temporary.fixed
new file mode 100644
index 00000000000..9b4ca5a4ad1
--- /dev/null
+++ b/tests/ui/option_take_on_temporary.fixed
@@ -0,0 +1,7 @@
+// run-rustfix
+
+fn main() {
+    println!("Testing option_take_on_temporary");
+    let x = Some(3);
+    let y = x.as_ref();
+}
-- 
cgit 1.4.1-3-g733a5


From cf83e18106160382cd86cc8b35add250373491b6 Mon Sep 17 00:00:00 2001
From: infrandomness <infrandomness@gmail.com>
Date: Fri, 8 Apr 2022 21:59:59 +0200
Subject: Swap the category of the lint

This changes the lint from the suspicious category to the complexity category
---
 clippy_lints/src/lib.register_suspicious.rs | 1 -
 clippy_lints/src/methods/mod.rs             | 2 +-
 2 files changed, 1 insertion(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.register_suspicious.rs b/clippy_lints/src/lib.register_suspicious.rs
index 6588ca4a4a7..82f45b5fd58 100644
--- a/clippy_lints/src/lib.register_suspicious.rs
+++ b/clippy_lints/src/lib.register_suspicious.rs
@@ -22,7 +22,6 @@ store.register_group(true, "clippy::suspicious", Some("clippy_suspicious"), vec!
     LintId::of(loops::EMPTY_LOOP),
     LintId::of(loops::FOR_LOOPS_OVER_FALLIBLES),
     LintId::of(loops::MUT_RANGE_BOUND),
-    LintId::of(methods::OPTION_TAKE_ON_TEMPORARY),
     LintId::of(methods::SUSPICIOUS_MAP),
     LintId::of(mut_key::MUTABLE_KEY_TYPE),
     LintId::of(octal_escapes::OCTAL_ESCAPES),
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 3d4c193691a..36844b3609b 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -2177,7 +2177,7 @@ declare_clippy_lint! {
     /// ```
     #[clippy::version = "1.61.0"]
     pub NEEDLESS_OPTION_TAKE,
-    suspicious,
+    complexity,
     "using `.as_ref().take()` on a temporary value"
 }
 
-- 
cgit 1.4.1-3-g733a5


From b52bc9b96bb3b22b4ab4a793e3706e7a9b718952 Mon Sep 17 00:00:00 2001
From: infrandomness <infrandomness@gmail.com>
Date: Sun, 10 Apr 2022 10:59:43 +0200
Subject: Swap type checked expression

Instead of type checking the entire expression (causing a false
positive), only type check for a subset of the expression (the receiver of
the matched function: `take()`)
---
 clippy_lints/src/methods/needless_option_take.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/needless_option_take.rs b/clippy_lints/src/methods/needless_option_take.rs
index 57a43ff606a..297d83e9e37 100644
--- a/clippy_lints/src/methods/needless_option_take.rs
+++ b/clippy_lints/src/methods/needless_option_take.rs
@@ -10,7 +10,7 @@ use super::NEEDLESS_OPTION_TAKE;
 
 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, recv: &'tcx Expr<'_>) {
     // Checks if expression type is equal to sym::Option and if the expr is not a syntactic place
-    if is_expr_option(cx, expr) && !expr.is_syntactic_place_expr() {
+    if is_expr_option(cx, recv) && !recv.is_syntactic_place_expr() {
         let mut applicability = Applicability::MachineApplicable;
         span_lint_and_sugg(
             cx,
-- 
cgit 1.4.1-3-g733a5


From 76268c0d5590ca06129722fed4afb306a847caab Mon Sep 17 00:00:00 2001
From: infrandomness <infrandomness@gmail.com>
Date: Sun, 10 Apr 2022 23:42:33 +0200
Subject: Introduce new lint check

This checks if the expression has one of `core`, `option`, `Option` or
`as_ref` in its path, this avoids false positives
---
 clippy_lints/src/methods/needless_option_take.rs | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/needless_option_take.rs b/clippy_lints/src/methods/needless_option_take.rs
index 297d83e9e37..5596515637e 100644
--- a/clippy_lints/src/methods/needless_option_take.rs
+++ b/clippy_lints/src/methods/needless_option_take.rs
@@ -1,4 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::match_def_path;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_errors::Applicability;
@@ -10,7 +11,7 @@ use super::NEEDLESS_OPTION_TAKE;
 
 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, recv: &'tcx Expr<'_>) {
     // Checks if expression type is equal to sym::Option and if the expr is not a syntactic place
-    if is_expr_option(cx, recv) && !recv.is_syntactic_place_expr() {
+    if !recv.is_syntactic_place_expr() && is_expr_option(cx, recv) && has_expr_as_ref_path(cx, recv) {
         let mut applicability = Applicability::MachineApplicable;
         span_lint_and_sugg(
             cx,
@@ -31,3 +32,10 @@ fn is_expr_option(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
     let expr_type = cx.typeck_results().expr_ty(expr);
     is_type_diagnostic_item(cx, expr_type, sym::Option)
 }
+
+fn has_expr_as_ref_path(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+    if let Some(ref_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id) {
+        return match_def_path(cx, ref_id, &["core", "option", "Option", "as_ref"]);
+    }
+    false
+}
-- 
cgit 1.4.1-3-g733a5


From 822993675ff45d5b4b2f0a310c65d4abd1aef20a Mon Sep 17 00:00:00 2001
From: infrandomness <infrandomness@gmail.com>
Date: Mon, 11 Apr 2022 17:15:53 +0200
Subject: Modify lint description

---
 clippy_lints/src/methods/needless_option_take.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/needless_option_take.rs b/clippy_lints/src/methods/needless_option_take.rs
index 5596515637e..829c118d291 100644
--- a/clippy_lints/src/methods/needless_option_take.rs
+++ b/clippy_lints/src/methods/needless_option_take.rs
@@ -17,7 +17,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, recv: &'
             cx,
             NEEDLESS_OPTION_TAKE,
             expr.span,
-            "Called `Option::take()` on a temporary value",
+            "called `Option::take()` on a temporary value",
             "try",
             format!(
                 "{}",
-- 
cgit 1.4.1-3-g733a5


From 2903b56f177b2b23db62d6bf2d500837d704fb4e Mon Sep 17 00:00:00 2001
From: infrandomness <infrandomness@gmail.com>
Date: Tue, 12 Apr 2022 19:34:55 +0200
Subject: Add tests and docs

This adds test to make sure correct behavior of lint
- The first test's option variable is not a temporary variable
- The second test does not make usage of `take()`
- The third test makes usage of `take()` and uses a temporary variable
---
 clippy_lints/src/methods/mod.rs         |  6 ++++--
 tests/ui/needless_option_take.rs        | 10 +++++++++-
 tests/ui/option_take_on_temporary.fixed | 10 +++++++++-
 3 files changed, 22 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 36844b3609b..48fa30ba929 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -2169,11 +2169,13 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust
-    /// // example code where clippy issues a warning
+    /// let x = Some(3);
+    /// x.as_ref().take();
     /// ```
     /// Use instead:
     /// ```rust
-    /// // example code which does not raise clippy warning
+    /// let x = Some(3);
+    /// x.as_ref();
     /// ```
     #[clippy::version = "1.61.0"]
     pub NEEDLESS_OPTION_TAKE,
diff --git a/tests/ui/needless_option_take.rs b/tests/ui/needless_option_take.rs
index 27cc9a2e61e..9f4109eb463 100644
--- a/tests/ui/needless_option_take.rs
+++ b/tests/ui/needless_option_take.rs
@@ -1,7 +1,15 @@
 // run-rustfix
 
 fn main() {
-    println!("Testing option_take_on_temporary");
+    println!("Testing non erroneous option_take_on_temporary");
+    let mut option = Some(1);
+    let _ = Box::new(move || option.take().unwrap());
+
+    println!("Testing non erroneous option_take_on_temporary");
+    let x = Some(3);
+    x.as_ref();
+
+    println!("Testing erroneous option_take_on_temporary");
     let x = Some(3);
     x.as_ref().take();
 }
diff --git a/tests/ui/option_take_on_temporary.fixed b/tests/ui/option_take_on_temporary.fixed
index 7e293076682..29691e81666 100644
--- a/tests/ui/option_take_on_temporary.fixed
+++ b/tests/ui/option_take_on_temporary.fixed
@@ -1,7 +1,15 @@
 // run-rustfix
 
 fn main() {
-    println!("Testing option_take_on_temporary");
+    println!("Testing non erroneous option_take_on_temporary");
+    let mut option = Some(1);
+    let _ = Box::new(move || option.take().unwrap());
+
+    println!("Testing non erroneous option_take_on_temporary");
+    let x = Some(3);
+    x.as_ref();
+
+    println!("Testing erroneous option_take_on_temporary");
     let x = Some(3);
     x.as_ref();
 }
-- 
cgit 1.4.1-3-g733a5


From d68ac9ccce85b88de5f9f7eed169ef301bdaae3f Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Thu, 17 Mar 2022 19:44:12 -0400
Subject: Don't lint `let_unit_value` when needed for type inferenece

---
 clippy_lints/src/unit_types/let_unit_value.rs | 72 +++++++++++++++++++++++++--
 tests/ui/let_unit.fixed                       | 27 ++++++++++
 tests/ui/let_unit.rs                          | 27 ++++++++++
 tests/ui/let_unit.stderr                      | 42 +++++++++++++++-
 4 files changed, 162 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unit_types/let_unit_value.rs b/clippy_lints/src/unit_types/let_unit_value.rs
index b25a6e3375b..39352b3ee47 100644
--- a/clippy_lints/src/unit_types/let_unit_value.rs
+++ b/clippy_lints/src/unit_types/let_unit_value.rs
@@ -1,18 +1,38 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet_with_macro_callsite;
+use core::ops::ControlFlow;
 use rustc_errors::Applicability;
-use rustc_hir::{Stmt, StmtKind};
+use rustc_hir::{Expr, ExprKind, PatKind, Stmt, StmtKind};
 use rustc_lint::{LateContext, LintContext};
 use rustc_middle::lint::in_external_macro;
+use rustc_middle::ty::{self, Ty, TypeFoldable, TypeVisitor};
 
 use super::LET_UNIT_VALUE;
 
 pub(super) fn check(cx: &LateContext<'_>, stmt: &Stmt<'_>) {
-    if let StmtKind::Local(local) = stmt.kind {
-        if cx.typeck_results().pat_ty(local.pat).is_unit() {
-            if in_external_macro(cx.sess(), stmt.span) || local.pat.span.from_expansion() {
-                return;
+    if let StmtKind::Local(local) = stmt.kind
+        && !local.pat.span.from_expansion()
+        && !in_external_macro(cx.sess(), stmt.span)
+        && cx.typeck_results().pat_ty(local.pat).is_unit()
+    {
+        if local.init.map_or(false, |e| needs_inferred_result_ty(cx, e)) {
+            if !matches!(local.pat.kind, PatKind::Wild) {
+                span_lint_and_then(
+                    cx,
+                    LET_UNIT_VALUE,
+                    stmt.span,
+                    "this let-binding has unit value",
+                    |diag| {
+                            diag.span_suggestion(
+                                local.pat.span,
+                                "use a wild (`_`) binding",
+                                "_".into(),
+                                Applicability::MaybeIncorrect, // snippet
+                            );
+                    },
+                );
             }
+        } else {
             span_lint_and_then(
                 cx,
                 LET_UNIT_VALUE,
@@ -33,3 +53,45 @@ pub(super) fn check(cx: &LateContext<'_>, stmt: &Stmt<'_>) {
         }
     }
 }
+
+fn needs_inferred_result_ty(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
+    let id = match e.kind {
+        ExprKind::Call(
+            Expr {
+                kind: ExprKind::Path(ref path),
+                hir_id,
+                ..
+            },
+            _,
+        ) => cx.qpath_res(path, *hir_id).opt_def_id(),
+        ExprKind::MethodCall(..) => cx.typeck_results().type_dependent_def_id(e.hir_id),
+        _ => return false,
+    };
+    if let Some(id) = id
+        && let sig = cx.tcx.fn_sig(id).skip_binder()
+        && let ty::Param(output_ty) = *sig.output().kind()
+    {
+        sig.inputs().iter().all(|&ty| !ty_contains_param(ty, output_ty.index))
+    } else {
+        false
+    }
+}
+
+fn ty_contains_param(ty: Ty<'_>, index: u32) -> bool {
+    struct Visitor(u32);
+    impl<'tcx> TypeVisitor<'tcx> for Visitor {
+        type BreakTy = ();
+        fn visit_ty(&mut self, ty: Ty<'tcx>) -> ControlFlow<Self::BreakTy> {
+            if let ty::Param(ty) = *ty.kind() {
+                if ty.index == self.0 {
+                    ControlFlow::BREAK
+                } else {
+                    ControlFlow::CONTINUE
+                }
+            } else {
+                ty.super_visit_with(self)
+            }
+        }
+    }
+    ty.visit_with(&mut Visitor(index)).is_break()
+}
diff --git a/tests/ui/let_unit.fixed b/tests/ui/let_unit.fixed
index f398edc23cb..5fee742b192 100644
--- a/tests/ui/let_unit.fixed
+++ b/tests/ui/let_unit.fixed
@@ -61,3 +61,30 @@ fn multiline_sugg() {
 
 #[derive(Copy, Clone)]
 pub struct ContainsUnit(()); // should be fine
+
+fn _returns_generic() {
+    fn f<T>() -> T {
+        unimplemented!()
+    }
+    fn f2<T, U>(_: T) -> U {
+        unimplemented!()
+    }
+    fn f3<T>(x: T) -> T {
+        x
+    }
+    fn f4<T>(mut x: Vec<T>) -> T {
+        x.pop().unwrap()
+    }
+
+    let _: () = f(); // Ok
+    let _: () = f(); // Lint.
+
+    let _: () = f2(0i32); // Ok
+    let _: () = f2(0i32); // Lint.
+
+    f3(()); // Lint
+    f3(()); // Lint
+
+    f4(vec![()]); // Lint
+    f4(vec![()]); // Lint
+}
diff --git a/tests/ui/let_unit.rs b/tests/ui/let_unit.rs
index af5b1fb2ac7..505e4a7d8fd 100644
--- a/tests/ui/let_unit.rs
+++ b/tests/ui/let_unit.rs
@@ -61,3 +61,30 @@ fn multiline_sugg() {
 
 #[derive(Copy, Clone)]
 pub struct ContainsUnit(()); // should be fine
+
+fn _returns_generic() {
+    fn f<T>() -> T {
+        unimplemented!()
+    }
+    fn f2<T, U>(_: T) -> U {
+        unimplemented!()
+    }
+    fn f3<T>(x: T) -> T {
+        x
+    }
+    fn f4<T>(mut x: Vec<T>) -> T {
+        x.pop().unwrap()
+    }
+
+    let _: () = f(); // Ok
+    let x: () = f(); // Lint.
+
+    let _: () = f2(0i32); // Ok
+    let x: () = f2(0i32); // Lint.
+
+    let _: () = f3(()); // Lint
+    let x: () = f3(()); // Lint
+
+    let _: () = f4(vec![()]); // Lint
+    let x: () = f4(vec![()]); // Lint
+}
diff --git a/tests/ui/let_unit.stderr b/tests/ui/let_unit.stderr
index f2600c6c228..c4a766bb974 100644
--- a/tests/ui/let_unit.stderr
+++ b/tests/ui/let_unit.stderr
@@ -34,5 +34,45 @@ LL +         .map(|_| ())
 LL +         .next()
  ...
 
-error: aborting due to 3 previous errors
+error: this let-binding has unit value
+  --> $DIR/let_unit.rs:80:5
+   |
+LL |     let x: () = f(); // Lint.
+   |     ^^^^-^^^^^^^^^^^
+   |         |
+   |         help: use a wild (`_`) binding: `_`
+
+error: this let-binding has unit value
+  --> $DIR/let_unit.rs:83:5
+   |
+LL |     let x: () = f2(0i32); // Lint.
+   |     ^^^^-^^^^^^^^^^^^^^^^
+   |         |
+   |         help: use a wild (`_`) binding: `_`
+
+error: this let-binding has unit value
+  --> $DIR/let_unit.rs:85:5
+   |
+LL |     let _: () = f3(()); // Lint
+   |     ^^^^^^^^^^^^^^^^^^^ help: omit the `let` binding: `f3(());`
+
+error: this let-binding has unit value
+  --> $DIR/let_unit.rs:86:5
+   |
+LL |     let x: () = f3(()); // Lint
+   |     ^^^^^^^^^^^^^^^^^^^ help: omit the `let` binding: `f3(());`
+
+error: this let-binding has unit value
+  --> $DIR/let_unit.rs:88:5
+   |
+LL |     let _: () = f4(vec![()]); // Lint
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^ help: omit the `let` binding: `f4(vec![()]);`
+
+error: this let-binding has unit value
+  --> $DIR/let_unit.rs:89:5
+   |
+LL |     let x: () = f4(vec![()]); // Lint
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^ help: omit the `let` binding: `f4(vec![()]);`
+
+error: aborting due to 9 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 48bcc1d95f07eaf03f72f98011e78cb8630798a4 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Thu, 17 Mar 2022 19:53:28 -0400
Subject: Move `let_unit_value` back into `style`

---
 clippy_lints/src/lib.register_all.rs             |  1 +
 clippy_lints/src/lib.register_pedantic.rs        |  1 -
 clippy_lints/src/lib.register_style.rs           |  1 +
 clippy_lints/src/unit_types/mod.rs               |  2 +-
 tests/ui-internal/interning_defined_symbol.fixed |  2 +-
 tests/ui-internal/interning_defined_symbol.rs    |  2 +-
 tests/ui-toml/functions_maxlines/test.rs         |  1 +
 tests/ui-toml/functions_maxlines/test.stderr     |  8 +--
 tests/ui/cast_slice_different_sizes.rs           |  2 +
 tests/ui/cast_slice_different_sizes.stderr       | 12 ++--
 tests/ui/crashes/ice-5944.rs                     |  1 +
 tests/ui/default_numeric_fallback_f64.fixed      | 15 ++--
 tests/ui/default_numeric_fallback_f64.rs         | 15 ++--
 tests/ui/default_numeric_fallback_f64.stderr     | 46 ++++++-------
 tests/ui/default_numeric_fallback_i32.fixed      | 13 ++--
 tests/ui/default_numeric_fallback_i32.rs         | 13 ++--
 tests/ui/default_numeric_fallback_i32.stderr     | 50 +++++++-------
 tests/ui/doc_unsafe.rs                           |  2 +
 tests/ui/doc_unsafe.stderr                       | 12 ++--
 tests/ui/iter_overeager_cloned.fixed             |  2 +-
 tests/ui/iter_overeager_cloned.rs                |  2 +-
 tests/ui/let_underscore_drop.rs                  |  1 +
 tests/ui/let_underscore_drop.stderr              |  6 +-
 tests/ui/needless_for_each_fixable.fixed         |  7 +-
 tests/ui/needless_for_each_fixable.rs            |  7 +-
 tests/ui/needless_for_each_fixable.stderr        | 16 ++---
 tests/ui/needless_late_init.rs                   |  1 +
 tests/ui/needless_late_init.stderr               | 18 ++---
 tests/ui/non_expressive_names.rs                 |  2 +-
 tests/ui/option_if_let_else.fixed                |  7 +-
 tests/ui/option_if_let_else.rs                   |  7 +-
 tests/ui/option_if_let_else.stderr               | 30 ++++----
 tests/ui/shadow.rs                               |  1 +
 tests/ui/shadow.stderr                           | 88 ++++++++++++------------
 tests/ui/similar_names.rs                        |  3 +-
 tests/ui/similar_names.stderr                    | 28 ++++----
 tests/ui/single_char_lifetime_names.rs           |  1 +
 tests/ui/single_char_lifetime_names.stderr       | 10 +--
 tests/ui/suspicious_else_formatting.rs           |  2 +-
 tests/ui/undocumented_unsafe_blocks.rs           |  1 +
 tests/ui/undocumented_unsafe_blocks.stderr       | 36 +++++-----
 tests/ui/uninit.rs                               |  1 +
 tests/ui/uninit.stderr                           |  6 +-
 tests/ui/unit_arg.rs                             |  3 +-
 tests/ui/unit_arg.stderr                         | 20 +++---
 tests/ui/unit_hash.rs                            |  1 +
 tests/ui/unit_hash.stderr                        |  6 +-
 tests/ui/wildcard_imports.fixed                  |  3 +-
 tests/ui/wildcard_imports.rs                     |  3 +-
 tests/ui/wildcard_imports.stderr                 | 42 +++++------
 50 files changed, 303 insertions(+), 257 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 2fa59733365..097064ae26f 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -308,6 +308,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(uninit_vec::UNINIT_VEC),
     LintId::of(unit_hash::UNIT_HASH),
     LintId::of(unit_return_expecting_ord::UNIT_RETURN_EXPECTING_ORD),
+    LintId::of(unit_types::LET_UNIT_VALUE),
     LintId::of(unit_types::UNIT_ARG),
     LintId::of(unit_types::UNIT_CMP),
     LintId::of(unnamed_address::FN_ADDRESS_COMPARISONS),
diff --git a/clippy_lints/src/lib.register_pedantic.rs b/clippy_lints/src/lib.register_pedantic.rs
index eb6534cb8ca..96cdc4577d5 100644
--- a/clippy_lints/src/lib.register_pedantic.rs
+++ b/clippy_lints/src/lib.register_pedantic.rs
@@ -89,7 +89,6 @@ store.register_group(true, "clippy::pedantic", Some("clippy_pedantic"), vec![
     LintId::of(types::LINKEDLIST),
     LintId::of(types::OPTION_OPTION),
     LintId::of(unicode::UNICODE_NOT_NFC),
-    LintId::of(unit_types::LET_UNIT_VALUE),
     LintId::of(unnecessary_wraps::UNNECESSARY_WRAPS),
     LintId::of(unnested_or_patterns::UNNESTED_OR_PATTERNS),
     LintId::of(unused_async::UNUSED_ASYNC),
diff --git a/clippy_lints/src/lib.register_style.rs b/clippy_lints/src/lib.register_style.rs
index d6e4390fde1..5a85a9e209e 100644
--- a/clippy_lints/src/lib.register_style.rs
+++ b/clippy_lints/src/lib.register_style.rs
@@ -107,6 +107,7 @@ store.register_group(true, "clippy::style", Some("clippy_style"), vec![
     LintId::of(single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS),
     LintId::of(tabs_in_doc_comments::TABS_IN_DOC_COMMENTS),
     LintId::of(to_digit_is_some::TO_DIGIT_IS_SOME),
+    LintId::of(unit_types::LET_UNIT_VALUE),
     LintId::of(unnecessary_owned_empty_strings::UNNECESSARY_OWNED_EMPTY_STRINGS),
     LintId::of(unsafe_removed_from_name::UNSAFE_REMOVED_FROM_NAME),
     LintId::of(unused_unit::UNUSED_UNIT),
diff --git a/clippy_lints/src/unit_types/mod.rs b/clippy_lints/src/unit_types/mod.rs
index d9f5b53b413..a9e2073dec2 100644
--- a/clippy_lints/src/unit_types/mod.rs
+++ b/clippy_lints/src/unit_types/mod.rs
@@ -23,7 +23,7 @@ declare_clippy_lint! {
     /// ```
     #[clippy::version = "pre 1.29.0"]
     pub LET_UNIT_VALUE,
-    pedantic,
+    style,
     "creating a `let` binding to a value of unit type, which usually can't be used afterwards"
 }
 
diff --git a/tests/ui-internal/interning_defined_symbol.fixed b/tests/ui-internal/interning_defined_symbol.fixed
index 6b7fd6efe39..eaea218e128 100644
--- a/tests/ui-internal/interning_defined_symbol.fixed
+++ b/tests/ui-internal/interning_defined_symbol.fixed
@@ -1,6 +1,6 @@
 // run-rustfix
 #![deny(clippy::internal)]
-#![allow(clippy::missing_clippy_version_attribute)]
+#![allow(clippy::missing_clippy_version_attribute, clippy::let_unit_value)]
 #![feature(rustc_private)]
 
 extern crate rustc_span;
diff --git a/tests/ui-internal/interning_defined_symbol.rs b/tests/ui-internal/interning_defined_symbol.rs
index 98d7d7adad1..7efebb8fae4 100644
--- a/tests/ui-internal/interning_defined_symbol.rs
+++ b/tests/ui-internal/interning_defined_symbol.rs
@@ -1,6 +1,6 @@
 // run-rustfix
 #![deny(clippy::internal)]
-#![allow(clippy::missing_clippy_version_attribute)]
+#![allow(clippy::missing_clippy_version_attribute, clippy::let_unit_value)]
 #![feature(rustc_private)]
 
 extern crate rustc_span;
diff --git a/tests/ui-toml/functions_maxlines/test.rs b/tests/ui-toml/functions_maxlines/test.rs
index e678c896fd3..4ac0378544c 100644
--- a/tests/ui-toml/functions_maxlines/test.rs
+++ b/tests/ui-toml/functions_maxlines/test.rs
@@ -1,4 +1,5 @@
 #![warn(clippy::too_many_lines)]
+#![allow(clippy::let_unit_value)]
 
 // This function should be considered one line.
 fn many_comments_but_one_line_of_code() {
diff --git a/tests/ui-toml/functions_maxlines/test.stderr b/tests/ui-toml/functions_maxlines/test.stderr
index d736bf89973..dc255bdcaba 100644
--- a/tests/ui-toml/functions_maxlines/test.stderr
+++ b/tests/ui-toml/functions_maxlines/test.stderr
@@ -1,5 +1,5 @@
 error: this function has too many lines (2/1)
-  --> $DIR/test.rs:18:1
+  --> $DIR/test.rs:19:1
    |
 LL | / fn too_many_lines() {
 LL | |     println!("This is bad.");
@@ -10,7 +10,7 @@ LL | | }
    = note: `-D clippy::too-many-lines` implied by `-D warnings`
 
 error: this function has too many lines (4/1)
-  --> $DIR/test.rs:24:1
+  --> $DIR/test.rs:25:1
    |
 LL | / async fn async_too_many_lines() {
 LL | |     println!("This is bad.");
@@ -19,7 +19,7 @@ LL | | }
    | |_^
 
 error: this function has too many lines (4/1)
-  --> $DIR/test.rs:30:1
+  --> $DIR/test.rs:31:1
    |
 LL | / fn closure_too_many_lines() {
 LL | |     let _ = {
@@ -30,7 +30,7 @@ LL | | }
    | |_^
 
 error: this function has too many lines (2/1)
-  --> $DIR/test.rs:52:1
+  --> $DIR/test.rs:53:1
    |
 LL | / fn comment_before_code() {
 LL | |     let _ = "test";
diff --git a/tests/ui/cast_slice_different_sizes.rs b/tests/ui/cast_slice_different_sizes.rs
index cfe1cca2eba..57270fcf52b 100644
--- a/tests/ui/cast_slice_different_sizes.rs
+++ b/tests/ui/cast_slice_different_sizes.rs
@@ -1,3 +1,5 @@
+#![allow(clippy::let_unit_value)]
+
 fn main() {
     let x: [i32; 3] = [1_i32, 2, 3];
     let r_x = &x;
diff --git a/tests/ui/cast_slice_different_sizes.stderr b/tests/ui/cast_slice_different_sizes.stderr
index a37cec7cb3b..993e93c2bf3 100644
--- a/tests/ui/cast_slice_different_sizes.stderr
+++ b/tests/ui/cast_slice_different_sizes.stderr
@@ -1,5 +1,5 @@
 error: casting between raw pointers to `[i32]` (element size 4) and `[u8]` (element size 1) does not adjust the count
-  --> $DIR/cast_slice_different_sizes.rs:7:13
+  --> $DIR/cast_slice_different_sizes.rs:9:13
    |
 LL |     let b = a as *const [u8];
    |             ^^^^^^^^^^^^^^^^ help: replace with `ptr::slice_from_raw_parts`: `core::ptr::slice_from_raw_parts(a as *const u8, ..)`
@@ -7,25 +7,25 @@ LL |     let b = a as *const [u8];
    = note: `#[deny(clippy::cast_slice_different_sizes)]` on by default
 
 error: casting between raw pointers to `[u8]` (element size 1) and `[u32]` (element size 4) does not adjust the count
-  --> $DIR/cast_slice_different_sizes.rs:8:13
+  --> $DIR/cast_slice_different_sizes.rs:10:13
    |
 LL |     let c = b as *const [u32];
    |             ^^^^^^^^^^^^^^^^^ help: replace with `ptr::slice_from_raw_parts`: `core::ptr::slice_from_raw_parts(b as *const u32, ..)`
 
 error: casting between raw pointers to `[i32]` (element size 4) and `[u8]` (element size 1) does not adjust the count
-  --> $DIR/cast_slice_different_sizes.rs:11:16
+  --> $DIR/cast_slice_different_sizes.rs:13:16
    |
 LL |     let loss = r_x as *const [i32] as *const [u8];
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with `ptr::slice_from_raw_parts`: `core::ptr::slice_from_raw_parts(r_x as *const [i32] as *const u8, ..)`
 
 error: casting between raw pointers to `[i32]` (element size 4) and `[u8]` (element size 1) does not adjust the count
-  --> $DIR/cast_slice_different_sizes.rs:18:24
+  --> $DIR/cast_slice_different_sizes.rs:20:24
    |
 LL |     let loss_block_1 = { r_x as *const [i32] } as *const [u8];
    |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with `ptr::slice_from_raw_parts`: `core::ptr::slice_from_raw_parts({ r_x as *const [i32] } as *const u8, ..)`
 
 error: casting between raw pointers to `[i32]` (element size 4) and `[u8]` (element size 1) does not adjust the count
-  --> $DIR/cast_slice_different_sizes.rs:19:24
+  --> $DIR/cast_slice_different_sizes.rs:21:24
    |
 LL |       let loss_block_2 = {
    |  ________________________^
@@ -43,7 +43,7 @@ LL ~     } as *const u8, ..);
    |
 
 error: casting between raw pointers to `[i32]` (element size 4) and `[u8]` (element size 1) does not adjust the count
-  --> $DIR/cast_slice_different_sizes.rs:36:27
+  --> $DIR/cast_slice_different_sizes.rs:38:27
    |
 LL |     let long_chain_loss = r_x as *const [i32] as *const [u32] as *const [u16] as *const [i8] as *const [u8];
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with `ptr::slice_from_raw_parts`: `core::ptr::slice_from_raw_parts(r_x as *const [i32] as *const [u32] as *const [u16] as *const [i8] as *const u8, ..)`
diff --git a/tests/ui/crashes/ice-5944.rs b/tests/ui/crashes/ice-5944.rs
index 5caf29c6197..ce46bc1acc1 100644
--- a/tests/ui/crashes/ice-5944.rs
+++ b/tests/ui/crashes/ice-5944.rs
@@ -1,4 +1,5 @@
 #![warn(clippy::repeat_once)]
+#![allow(clippy::let_unit_value)]
 
 trait Repeat {
     fn repeat(&self) {}
diff --git a/tests/ui/default_numeric_fallback_f64.fixed b/tests/ui/default_numeric_fallback_f64.fixed
index e0b4a2f6942..a28bff76755 100644
--- a/tests/ui/default_numeric_fallback_f64.fixed
+++ b/tests/ui/default_numeric_fallback_f64.fixed
@@ -2,12 +2,15 @@
 // aux-build:macro_rules.rs
 
 #![warn(clippy::default_numeric_fallback)]
-#![allow(unused)]
-#![allow(clippy::never_loop)]
-#![allow(clippy::no_effect)]
-#![allow(clippy::unnecessary_operation)]
-#![allow(clippy::branches_sharing_code)]
-#![allow(clippy::match_single_binding)]
+#![allow(
+    unused,
+    clippy::never_loop,
+    clippy::no_effect,
+    clippy::unnecessary_operation,
+    clippy::branches_sharing_code,
+    clippy::match_single_binding,
+    clippy::let_unit_value
+)]
 
 #[macro_use]
 extern crate macro_rules;
diff --git a/tests/ui/default_numeric_fallback_f64.rs b/tests/ui/default_numeric_fallback_f64.rs
index 50bbb6eec6c..b48435cc7b2 100644
--- a/tests/ui/default_numeric_fallback_f64.rs
+++ b/tests/ui/default_numeric_fallback_f64.rs
@@ -2,12 +2,15 @@
 // aux-build:macro_rules.rs
 
 #![warn(clippy::default_numeric_fallback)]
-#![allow(unused)]
-#![allow(clippy::never_loop)]
-#![allow(clippy::no_effect)]
-#![allow(clippy::unnecessary_operation)]
-#![allow(clippy::branches_sharing_code)]
-#![allow(clippy::match_single_binding)]
+#![allow(
+    unused,
+    clippy::never_loop,
+    clippy::no_effect,
+    clippy::unnecessary_operation,
+    clippy::branches_sharing_code,
+    clippy::match_single_binding,
+    clippy::let_unit_value
+)]
 
 #[macro_use]
 extern crate macro_rules;
diff --git a/tests/ui/default_numeric_fallback_f64.stderr b/tests/ui/default_numeric_fallback_f64.stderr
index f8a2407b693..f8b6c7746ed 100644
--- a/tests/ui/default_numeric_fallback_f64.stderr
+++ b/tests/ui/default_numeric_fallback_f64.stderr
@@ -1,5 +1,5 @@
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_f64.rs:18:17
+  --> $DIR/default_numeric_fallback_f64.rs:21:17
    |
 LL |         let x = 0.12;
    |                 ^^^^ help: consider adding suffix: `0.12_f64`
@@ -7,133 +7,133 @@ LL |         let x = 0.12;
    = note: `-D clippy::default-numeric-fallback` implied by `-D warnings`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_f64.rs:19:18
+  --> $DIR/default_numeric_fallback_f64.rs:22:18
    |
 LL |         let x = [1., 2., 3.];
    |                  ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_f64.rs:19:22
+  --> $DIR/default_numeric_fallback_f64.rs:22:22
    |
 LL |         let x = [1., 2., 3.];
    |                      ^^ help: consider adding suffix: `2.0_f64`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_f64.rs:19:26
+  --> $DIR/default_numeric_fallback_f64.rs:22:26
    |
 LL |         let x = [1., 2., 3.];
    |                          ^^ help: consider adding suffix: `3.0_f64`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_f64.rs:20:28
+  --> $DIR/default_numeric_fallback_f64.rs:23:28
    |
 LL |         let x = if true { (1., 2.) } else { (3., 4.) };
    |                            ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_f64.rs:20:32
+  --> $DIR/default_numeric_fallback_f64.rs:23:32
    |
 LL |         let x = if true { (1., 2.) } else { (3., 4.) };
    |                                ^^ help: consider adding suffix: `2.0_f64`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_f64.rs:20:46
+  --> $DIR/default_numeric_fallback_f64.rs:23:46
    |
 LL |         let x = if true { (1., 2.) } else { (3., 4.) };
    |                                              ^^ help: consider adding suffix: `3.0_f64`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_f64.rs:20:50
+  --> $DIR/default_numeric_fallback_f64.rs:23:50
    |
 LL |         let x = if true { (1., 2.) } else { (3., 4.) };
    |                                                  ^^ help: consider adding suffix: `4.0_f64`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_f64.rs:21:23
+  --> $DIR/default_numeric_fallback_f64.rs:24:23
    |
 LL |         let x = match 1. {
    |                       ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_f64.rs:22:18
+  --> $DIR/default_numeric_fallback_f64.rs:25:18
    |
 LL |             _ => 1.,
    |                  ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_f64.rs:40:21
+  --> $DIR/default_numeric_fallback_f64.rs:43:21
    |
 LL |             let y = 1.;
    |                     ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_f64.rs:48:21
+  --> $DIR/default_numeric_fallback_f64.rs:51:21
    |
 LL |             let y = 1.;
    |                     ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_f64.rs:54:21
+  --> $DIR/default_numeric_fallback_f64.rs:57:21
    |
 LL |             let y = 1.;
    |                     ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_f64.rs:66:9
+  --> $DIR/default_numeric_fallback_f64.rs:69:9
    |
 LL |         1.
    |         ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_f64.rs:72:27
+  --> $DIR/default_numeric_fallback_f64.rs:75:27
    |
 LL |         let f = || -> _ { 1. };
    |                           ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_f64.rs:76:29
+  --> $DIR/default_numeric_fallback_f64.rs:79:29
    |
 LL |         let f = || -> f64 { 1. };
    |                             ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_f64.rs:90:21
+  --> $DIR/default_numeric_fallback_f64.rs:93:21
    |
 LL |         generic_arg(1.);
    |                     ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_f64.rs:93:32
+  --> $DIR/default_numeric_fallback_f64.rs:96:32
    |
 LL |         let x: _ = generic_arg(1.);
    |                                ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_f64.rs:111:28
+  --> $DIR/default_numeric_fallback_f64.rs:114:28
    |
 LL |         GenericStruct { x: 1. };
    |                            ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_f64.rs:114:36
+  --> $DIR/default_numeric_fallback_f64.rs:117:36
    |
 LL |         let _ = GenericStruct { x: 1. };
    |                                    ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_f64.rs:132:24
+  --> $DIR/default_numeric_fallback_f64.rs:135:24
    |
 LL |         GenericEnum::X(1.);
    |                        ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_f64.rs:152:23
+  --> $DIR/default_numeric_fallback_f64.rs:155:23
    |
 LL |         s.generic_arg(1.);
    |                       ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_f64.rs:159:21
+  --> $DIR/default_numeric_fallback_f64.rs:162:21
    |
 LL |             let x = 22.;
    |                     ^^^ help: consider adding suffix: `22.0_f64`
diff --git a/tests/ui/default_numeric_fallback_i32.fixed b/tests/ui/default_numeric_fallback_i32.fixed
index bded9e2c0e8..fa85d278c8f 100644
--- a/tests/ui/default_numeric_fallback_i32.fixed
+++ b/tests/ui/default_numeric_fallback_i32.fixed
@@ -2,11 +2,14 @@
 // aux-build:macro_rules.rs
 
 #![warn(clippy::default_numeric_fallback)]
-#![allow(unused)]
-#![allow(clippy::never_loop)]
-#![allow(clippy::no_effect)]
-#![allow(clippy::unnecessary_operation)]
-#![allow(clippy::branches_sharing_code)]
+#![allow(
+    unused,
+    clippy::never_loop,
+    clippy::no_effect,
+    clippy::unnecessary_operation,
+    clippy::branches_sharing_code,
+    clippy::let_unit_value
+)]
 
 #[macro_use]
 extern crate macro_rules;
diff --git a/tests/ui/default_numeric_fallback_i32.rs b/tests/ui/default_numeric_fallback_i32.rs
index 3fceefa551c..71acccd702b 100644
--- a/tests/ui/default_numeric_fallback_i32.rs
+++ b/tests/ui/default_numeric_fallback_i32.rs
@@ -2,11 +2,14 @@
 // aux-build:macro_rules.rs
 
 #![warn(clippy::default_numeric_fallback)]
-#![allow(unused)]
-#![allow(clippy::never_loop)]
-#![allow(clippy::no_effect)]
-#![allow(clippy::unnecessary_operation)]
-#![allow(clippy::branches_sharing_code)]
+#![allow(
+    unused,
+    clippy::never_loop,
+    clippy::no_effect,
+    clippy::unnecessary_operation,
+    clippy::branches_sharing_code,
+    clippy::let_unit_value
+)]
 
 #[macro_use]
 extern crate macro_rules;
diff --git a/tests/ui/default_numeric_fallback_i32.stderr b/tests/ui/default_numeric_fallback_i32.stderr
index 6f9e124704b..3cc84ff1132 100644
--- a/tests/ui/default_numeric_fallback_i32.stderr
+++ b/tests/ui/default_numeric_fallback_i32.stderr
@@ -1,5 +1,5 @@
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:17:17
+  --> $DIR/default_numeric_fallback_i32.rs:20:17
    |
 LL |         let x = 22;
    |                 ^^ help: consider adding suffix: `22_i32`
@@ -7,145 +7,145 @@ LL |         let x = 22;
    = note: `-D clippy::default-numeric-fallback` implied by `-D warnings`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:18:18
+  --> $DIR/default_numeric_fallback_i32.rs:21:18
    |
 LL |         let x = [1, 2, 3];
    |                  ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:18:21
+  --> $DIR/default_numeric_fallback_i32.rs:21:21
    |
 LL |         let x = [1, 2, 3];
    |                     ^ help: consider adding suffix: `2_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:18:24
+  --> $DIR/default_numeric_fallback_i32.rs:21:24
    |
 LL |         let x = [1, 2, 3];
    |                        ^ help: consider adding suffix: `3_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:19:28
+  --> $DIR/default_numeric_fallback_i32.rs:22:28
    |
 LL |         let x = if true { (1, 2) } else { (3, 4) };
    |                            ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:19:31
+  --> $DIR/default_numeric_fallback_i32.rs:22:31
    |
 LL |         let x = if true { (1, 2) } else { (3, 4) };
    |                               ^ help: consider adding suffix: `2_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:19:44
+  --> $DIR/default_numeric_fallback_i32.rs:22:44
    |
 LL |         let x = if true { (1, 2) } else { (3, 4) };
    |                                            ^ help: consider adding suffix: `3_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:19:47
+  --> $DIR/default_numeric_fallback_i32.rs:22:47
    |
 LL |         let x = if true { (1, 2) } else { (3, 4) };
    |                                               ^ help: consider adding suffix: `4_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:20:23
+  --> $DIR/default_numeric_fallback_i32.rs:23:23
    |
 LL |         let x = match 1 {
    |                       ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:21:13
+  --> $DIR/default_numeric_fallback_i32.rs:24:13
    |
 LL |             1 => 1,
    |             ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:21:18
+  --> $DIR/default_numeric_fallback_i32.rs:24:18
    |
 LL |             1 => 1,
    |                  ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:22:18
+  --> $DIR/default_numeric_fallback_i32.rs:25:18
    |
 LL |             _ => 2,
    |                  ^ help: consider adding suffix: `2_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:39:21
+  --> $DIR/default_numeric_fallback_i32.rs:42:21
    |
 LL |             let y = 1;
    |                     ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:47:21
+  --> $DIR/default_numeric_fallback_i32.rs:50:21
    |
 LL |             let y = 1;
    |                     ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:53:21
+  --> $DIR/default_numeric_fallback_i32.rs:56:21
    |
 LL |             let y = 1;
    |                     ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:65:9
+  --> $DIR/default_numeric_fallback_i32.rs:68:9
    |
 LL |         1
    |         ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:71:27
+  --> $DIR/default_numeric_fallback_i32.rs:74:27
    |
 LL |         let f = || -> _ { 1 };
    |                           ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:75:29
+  --> $DIR/default_numeric_fallback_i32.rs:78:29
    |
 LL |         let f = || -> i32 { 1 };
    |                             ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:89:21
+  --> $DIR/default_numeric_fallback_i32.rs:92:21
    |
 LL |         generic_arg(1);
    |                     ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:92:32
+  --> $DIR/default_numeric_fallback_i32.rs:95:32
    |
 LL |         let x: _ = generic_arg(1);
    |                                ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:110:28
+  --> $DIR/default_numeric_fallback_i32.rs:113:28
    |
 LL |         GenericStruct { x: 1 };
    |                            ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:113:36
+  --> $DIR/default_numeric_fallback_i32.rs:116:36
    |
 LL |         let _ = GenericStruct { x: 1 };
    |                                    ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:131:24
+  --> $DIR/default_numeric_fallback_i32.rs:134:24
    |
 LL |         GenericEnum::X(1);
    |                        ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:151:23
+  --> $DIR/default_numeric_fallback_i32.rs:154:23
    |
 LL |         s.generic_arg(1);
    |                       ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:158:21
+  --> $DIR/default_numeric_fallback_i32.rs:161:21
    |
 LL |             let x = 22;
    |                     ^^ help: consider adding suffix: `22_i32`
diff --git a/tests/ui/doc_unsafe.rs b/tests/ui/doc_unsafe.rs
index 4464a21b3b6..b91f7aa0dd8 100644
--- a/tests/ui/doc_unsafe.rs
+++ b/tests/ui/doc_unsafe.rs
@@ -1,5 +1,7 @@
 // aux-build:doc_unsafe_macros.rs
 
+#![allow(clippy::let_unit_value)]
+
 #[macro_use]
 extern crate doc_unsafe_macros;
 
diff --git a/tests/ui/doc_unsafe.stderr b/tests/ui/doc_unsafe.stderr
index d68b8a0c67b..904b88eaef6 100644
--- a/tests/ui/doc_unsafe.stderr
+++ b/tests/ui/doc_unsafe.stderr
@@ -1,5 +1,5 @@
 error: unsafe function's docs miss `# Safety` section
-  --> $DIR/doc_unsafe.rs:7:1
+  --> $DIR/doc_unsafe.rs:9:1
    |
 LL | / pub unsafe fn destroy_the_planet() {
 LL | |     unimplemented!();
@@ -9,7 +9,7 @@ LL | | }
    = note: `-D clippy::missing-safety-doc` implied by `-D warnings`
 
 error: unsafe function's docs miss `# Safety` section
-  --> $DIR/doc_unsafe.rs:30:5
+  --> $DIR/doc_unsafe.rs:32:5
    |
 LL | /     pub unsafe fn republished() {
 LL | |         unimplemented!();
@@ -17,13 +17,13 @@ LL | |     }
    | |_____^
 
 error: unsafe function's docs miss `# Safety` section
-  --> $DIR/doc_unsafe.rs:38:5
+  --> $DIR/doc_unsafe.rs:40:5
    |
 LL |     unsafe fn woefully_underdocumented(self);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: docs for unsafe trait missing `# Safety` section
-  --> $DIR/doc_unsafe.rs:44:1
+  --> $DIR/doc_unsafe.rs:46:1
    |
 LL | / pub unsafe trait UnsafeTrait {
 LL | |     fn method();
@@ -31,7 +31,7 @@ LL | | }
    | |_^
 
 error: unsafe function's docs miss `# Safety` section
-  --> $DIR/doc_unsafe.rs:74:5
+  --> $DIR/doc_unsafe.rs:76:5
    |
 LL | /     pub unsafe fn more_undocumented_unsafe() -> Self {
 LL | |         unimplemented!();
@@ -39,7 +39,7 @@ LL | |     }
    | |_____^
 
 error: unsafe function's docs miss `# Safety` section
-  --> $DIR/doc_unsafe.rs:90:9
+  --> $DIR/doc_unsafe.rs:92:9
    |
 LL | /         pub unsafe fn whee() {
 LL | |             unimplemented!()
diff --git a/tests/ui/iter_overeager_cloned.fixed b/tests/ui/iter_overeager_cloned.fixed
index 56761ebbcb8..7c2b05d837b 100644
--- a/tests/ui/iter_overeager_cloned.fixed
+++ b/tests/ui/iter_overeager_cloned.fixed
@@ -1,6 +1,6 @@
 // run-rustfix
 #![warn(clippy::iter_overeager_cloned, clippy::redundant_clone, clippy::filter_next)]
-#![allow(dead_code)]
+#![allow(dead_code, clippy::let_unit_value)]
 
 fn main() {
     let vec = vec!["1".to_string(), "2".to_string(), "3".to_string()];
diff --git a/tests/ui/iter_overeager_cloned.rs b/tests/ui/iter_overeager_cloned.rs
index 98321d889b5..f2d0b155d2c 100644
--- a/tests/ui/iter_overeager_cloned.rs
+++ b/tests/ui/iter_overeager_cloned.rs
@@ -1,6 +1,6 @@
 // run-rustfix
 #![warn(clippy::iter_overeager_cloned, clippy::redundant_clone, clippy::filter_next)]
-#![allow(dead_code)]
+#![allow(dead_code, clippy::let_unit_value)]
 
 fn main() {
     let vec = vec!["1".to_string(), "2".to_string(), "3".to_string()];
diff --git a/tests/ui/let_underscore_drop.rs b/tests/ui/let_underscore_drop.rs
index 50744f81c3c..11b50492ab2 100644
--- a/tests/ui/let_underscore_drop.rs
+++ b/tests/ui/let_underscore_drop.rs
@@ -1,4 +1,5 @@
 #![warn(clippy::let_underscore_drop)]
+#![allow(clippy::let_unit_value)]
 
 struct Droppable;
 
diff --git a/tests/ui/let_underscore_drop.stderr b/tests/ui/let_underscore_drop.stderr
index 66069e0c5e1..ee7bbe995f1 100644
--- a/tests/ui/let_underscore_drop.stderr
+++ b/tests/ui/let_underscore_drop.stderr
@@ -1,5 +1,5 @@
 error: non-binding `let` on a type that implements `Drop`
-  --> $DIR/let_underscore_drop.rs:16:5
+  --> $DIR/let_underscore_drop.rs:17:5
    |
 LL |     let _ = Box::new(());
    |     ^^^^^^^^^^^^^^^^^^^^^
@@ -8,7 +8,7 @@ LL |     let _ = Box::new(());
    = help: consider using an underscore-prefixed named binding or dropping explicitly with `std::mem::drop`
 
 error: non-binding `let` on a type that implements `Drop`
-  --> $DIR/let_underscore_drop.rs:17:5
+  --> $DIR/let_underscore_drop.rs:18:5
    |
 LL |     let _ = Droppable;
    |     ^^^^^^^^^^^^^^^^^^
@@ -16,7 +16,7 @@ LL |     let _ = Droppable;
    = help: consider using an underscore-prefixed named binding or dropping explicitly with `std::mem::drop`
 
 error: non-binding `let` on a type that implements `Drop`
-  --> $DIR/let_underscore_drop.rs:18:5
+  --> $DIR/let_underscore_drop.rs:19:5
    |
 LL |     let _ = Some(Droppable);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/needless_for_each_fixable.fixed b/tests/ui/needless_for_each_fixable.fixed
index f00f9ee4c33..c1685f7b6d7 100644
--- a/tests/ui/needless_for_each_fixable.fixed
+++ b/tests/ui/needless_for_each_fixable.fixed
@@ -1,6 +1,11 @@
 // run-rustfix
 #![warn(clippy::needless_for_each)]
-#![allow(unused, clippy::needless_return, clippy::match_single_binding)]
+#![allow(
+    unused,
+    clippy::needless_return,
+    clippy::match_single_binding,
+    clippy::let_unit_value
+)]
 
 use std::collections::HashMap;
 
diff --git a/tests/ui/needless_for_each_fixable.rs b/tests/ui/needless_for_each_fixable.rs
index 1bd400d348b..ad17b0956fa 100644
--- a/tests/ui/needless_for_each_fixable.rs
+++ b/tests/ui/needless_for_each_fixable.rs
@@ -1,6 +1,11 @@
 // run-rustfix
 #![warn(clippy::needless_for_each)]
-#![allow(unused, clippy::needless_return, clippy::match_single_binding)]
+#![allow(
+    unused,
+    clippy::needless_return,
+    clippy::match_single_binding,
+    clippy::let_unit_value
+)]
 
 use std::collections::HashMap;
 
diff --git a/tests/ui/needless_for_each_fixable.stderr b/tests/ui/needless_for_each_fixable.stderr
index 6487e57266c..08e995851d7 100644
--- a/tests/ui/needless_for_each_fixable.stderr
+++ b/tests/ui/needless_for_each_fixable.stderr
@@ -1,5 +1,5 @@
 error: needless use of `for_each`
-  --> $DIR/needless_for_each_fixable.rs:10:5
+  --> $DIR/needless_for_each_fixable.rs:15:5
    |
 LL | /     v.iter().for_each(|elem| {
 LL | |         acc += elem;
@@ -15,7 +15,7 @@ LL +     }
    |
 
 error: needless use of `for_each`
-  --> $DIR/needless_for_each_fixable.rs:13:5
+  --> $DIR/needless_for_each_fixable.rs:18:5
    |
 LL | /     v.into_iter().for_each(|elem| {
 LL | |         acc += elem;
@@ -30,7 +30,7 @@ LL +     }
    |
 
 error: needless use of `for_each`
-  --> $DIR/needless_for_each_fixable.rs:17:5
+  --> $DIR/needless_for_each_fixable.rs:22:5
    |
 LL | /     [1, 2, 3].iter().for_each(|elem| {
 LL | |         acc += elem;
@@ -45,7 +45,7 @@ LL +     }
    |
 
 error: needless use of `for_each`
-  --> $DIR/needless_for_each_fixable.rs:22:5
+  --> $DIR/needless_for_each_fixable.rs:27:5
    |
 LL | /     hash_map.iter().for_each(|(k, v)| {
 LL | |         acc += k + v;
@@ -60,7 +60,7 @@ LL +     }
    |
 
 error: needless use of `for_each`
-  --> $DIR/needless_for_each_fixable.rs:25:5
+  --> $DIR/needless_for_each_fixable.rs:30:5
    |
 LL | /     hash_map.iter_mut().for_each(|(k, v)| {
 LL | |         acc += *k + *v;
@@ -75,7 +75,7 @@ LL +     }
    |
 
 error: needless use of `for_each`
-  --> $DIR/needless_for_each_fixable.rs:28:5
+  --> $DIR/needless_for_each_fixable.rs:33:5
    |
 LL | /     hash_map.keys().for_each(|k| {
 LL | |         acc += k;
@@ -90,7 +90,7 @@ LL +     }
    |
 
 error: needless use of `for_each`
-  --> $DIR/needless_for_each_fixable.rs:31:5
+  --> $DIR/needless_for_each_fixable.rs:36:5
    |
 LL | /     hash_map.values().for_each(|v| {
 LL | |         acc += v;
@@ -105,7 +105,7 @@ LL +     }
    |
 
 error: needless use of `for_each`
-  --> $DIR/needless_for_each_fixable.rs:38:5
+  --> $DIR/needless_for_each_fixable.rs:43:5
    |
 LL | /     my_vec().iter().for_each(|elem| {
 LL | |         acc += elem;
diff --git a/tests/ui/needless_late_init.rs b/tests/ui/needless_late_init.rs
index 89e012c066f..3cfbfb6033b 100644
--- a/tests/ui/needless_late_init.rs
+++ b/tests/ui/needless_late_init.rs
@@ -1,4 +1,5 @@
 #![allow(unused)]
+#![allow(clippy::let_unit_value)]
 
 fn main() {
     let a;
diff --git a/tests/ui/needless_late_init.stderr b/tests/ui/needless_late_init.stderr
index ef79e635d2a..9ef8bb23df6 100644
--- a/tests/ui/needless_late_init.stderr
+++ b/tests/ui/needless_late_init.stderr
@@ -1,5 +1,5 @@
 error: unneeded late initalization
-  --> $DIR/needless_late_init.rs:4:5
+  --> $DIR/needless_late_init.rs:5:5
    |
 LL |     let a;
    |     ^^^^^^
@@ -21,7 +21,7 @@ LL |     };
    |      +
 
 error: unneeded late initalization
-  --> $DIR/needless_late_init.rs:13:5
+  --> $DIR/needless_late_init.rs:14:5
    |
 LL |     let b;
    |     ^^^^^^
@@ -42,7 +42,7 @@ LL |     };
    |      +
 
 error: unneeded late initalization
-  --> $DIR/needless_late_init.rs:20:5
+  --> $DIR/needless_late_init.rs:21:5
    |
 LL |     let c;
    |     ^^^^^^
@@ -63,7 +63,7 @@ LL |     };
    |      +
 
 error: unneeded late initalization
-  --> $DIR/needless_late_init.rs:27:5
+  --> $DIR/needless_late_init.rs:28:5
    |
 LL |     let d;
    |     ^^^^^^
@@ -84,7 +84,7 @@ LL |     };
    |      +
 
 error: unneeded late initalization
-  --> $DIR/needless_late_init.rs:35:5
+  --> $DIR/needless_late_init.rs:36:5
    |
 LL |     let e;
    |     ^^^^^^
@@ -105,7 +105,7 @@ LL |     };
    |      +
 
 error: unneeded late initalization
-  --> $DIR/needless_late_init.rs:42:5
+  --> $DIR/needless_late_init.rs:43:5
    |
 LL |     let f;
    |     ^^^^^^
@@ -121,7 +121,7 @@ LL +         1 => "three",
    | 
 
 error: unneeded late initalization
-  --> $DIR/needless_late_init.rs:48:5
+  --> $DIR/needless_late_init.rs:49:5
    |
 LL |     let g: usize;
    |     ^^^^^^^^^^^^^
@@ -141,7 +141,7 @@ LL |     };
    |      +
 
 error: unneeded late initalization
-  --> $DIR/needless_late_init.rs:63:5
+  --> $DIR/needless_late_init.rs:64:5
    |
 LL |     let a;
    |     ^^^^^^
@@ -162,7 +162,7 @@ LL |     };
    |      +
 
 error: unneeded late initalization
-  --> $DIR/needless_late_init.rs:80:5
+  --> $DIR/needless_late_init.rs:81:5
    |
 LL |     let a;
    |     ^^^^^^
diff --git a/tests/ui/non_expressive_names.rs b/tests/ui/non_expressive_names.rs
index 9937005d68d..583096ac054 100644
--- a/tests/ui/non_expressive_names.rs
+++ b/tests/ui/non_expressive_names.rs
@@ -1,5 +1,5 @@
 #![warn(clippy::all)]
-#![allow(unused, clippy::println_empty_string, non_snake_case)]
+#![allow(unused, clippy::println_empty_string, non_snake_case, clippy::let_unit_value)]
 
 #[derive(Clone, Debug)]
 enum MaybeInst {
diff --git a/tests/ui/option_if_let_else.fixed b/tests/ui/option_if_let_else.fixed
index 7790c816481..e12e13a57f1 100644
--- a/tests/ui/option_if_let_else.fixed
+++ b/tests/ui/option_if_let_else.fixed
@@ -1,6 +1,11 @@
 // run-rustfix
 #![warn(clippy::option_if_let_else)]
-#![allow(clippy::redundant_closure, clippy::ref_option_ref, clippy::equatable_if_let)]
+#![allow(
+    clippy::redundant_closure,
+    clippy::ref_option_ref,
+    clippy::equatable_if_let,
+    clippy::let_unit_value
+)]
 
 fn bad1(string: Option<&str>) -> (bool, &str) {
     string.map_or((false, "hello"), |x| (true, x))
diff --git a/tests/ui/option_if_let_else.rs b/tests/ui/option_if_let_else.rs
index 3d9f76ee4a6..b5206fc26a9 100644
--- a/tests/ui/option_if_let_else.rs
+++ b/tests/ui/option_if_let_else.rs
@@ -1,6 +1,11 @@
 // run-rustfix
 #![warn(clippy::option_if_let_else)]
-#![allow(clippy::redundant_closure, clippy::ref_option_ref, clippy::equatable_if_let)]
+#![allow(
+    clippy::redundant_closure,
+    clippy::ref_option_ref,
+    clippy::equatable_if_let,
+    clippy::let_unit_value
+)]
 
 fn bad1(string: Option<&str>) -> (bool, &str) {
     if let Some(x) = string {
diff --git a/tests/ui/option_if_let_else.stderr b/tests/ui/option_if_let_else.stderr
index 546131ceb5b..40aef977b98 100644
--- a/tests/ui/option_if_let_else.stderr
+++ b/tests/ui/option_if_let_else.stderr
@@ -1,5 +1,5 @@
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:6:5
+  --> $DIR/option_if_let_else.rs:11:5
    |
 LL | /     if let Some(x) = string {
 LL | |         (true, x)
@@ -11,19 +11,19 @@ LL | |     }
    = note: `-D clippy::option-if-let-else` implied by `-D warnings`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:24:13
+  --> $DIR/option_if_let_else.rs:29:13
    |
 LL |     let _ = if let Some(s) = *string { s.len() } else { 0 };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `string.map_or(0, |s| s.len())`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:25:13
+  --> $DIR/option_if_let_else.rs:30:13
    |
 LL |     let _ = if let Some(s) = &num { s } else { &0 };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `num.as_ref().map_or(&0, |s| s)`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:26:13
+  --> $DIR/option_if_let_else.rs:31:13
    |
 LL |       let _ = if let Some(s) = &mut num {
    |  _____________^
@@ -43,13 +43,13 @@ LL ~     });
    |
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:32:13
+  --> $DIR/option_if_let_else.rs:37:13
    |
 LL |     let _ = if let Some(ref s) = num { s } else { &0 };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `num.as_ref().map_or(&0, |s| s)`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:33:13
+  --> $DIR/option_if_let_else.rs:38:13
    |
 LL |       let _ = if let Some(mut s) = num {
    |  _____________^
@@ -69,7 +69,7 @@ LL ~     });
    |
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:39:13
+  --> $DIR/option_if_let_else.rs:44:13
    |
 LL |       let _ = if let Some(ref mut s) = num {
    |  _____________^
@@ -89,7 +89,7 @@ LL ~     });
    |
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:48:5
+  --> $DIR/option_if_let_else.rs:53:5
    |
 LL | /     if let Some(x) = arg {
 LL | |         let y = x * x;
@@ -108,7 +108,7 @@ LL +     })
    |
 
 error: use Option::map_or_else instead of an if let/else
-  --> $DIR/option_if_let_else.rs:61:13
+  --> $DIR/option_if_let_else.rs:66:13
    |
 LL |       let _ = if let Some(x) = arg {
    |  _____________^
@@ -120,7 +120,7 @@ LL | |     };
    | |_____^ help: try: `arg.map_or_else(|| side_effect(), |x| x)`
 
 error: use Option::map_or_else instead of an if let/else
-  --> $DIR/option_if_let_else.rs:70:13
+  --> $DIR/option_if_let_else.rs:75:13
    |
 LL |       let _ = if let Some(x) = arg {
    |  _____________^
@@ -143,7 +143,7 @@ LL ~     }, |x| x * x * x * x);
    |
 
 error: use Option::map_or_else instead of an if let/else
-  --> $DIR/option_if_let_else.rs:103:13
+  --> $DIR/option_if_let_else.rs:108:13
    |
 LL | /             if let Some(idx) = s.find('.') {
 LL | |                 vec![s[..idx].to_string(), s[idx..].to_string()]
@@ -153,13 +153,13 @@ LL | |             }
    | |_____________^ help: try: `s.find('.').map_or_else(|| vec![s.to_string()], |idx| vec![s[..idx].to_string(), s[idx..].to_string()])`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:127:13
+  --> $DIR/option_if_let_else.rs:132:13
    |
 LL |     let _ = if let Some(x) = optional { x + 2 } else { 5 };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `optional.map_or(5, |x| x + 2)`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:136:13
+  --> $DIR/option_if_let_else.rs:141:13
    |
 LL |       let _ = if let Some(x) = Some(0) {
    |  _____________^
@@ -181,13 +181,13 @@ LL ~         });
    |
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:164:13
+  --> $DIR/option_if_let_else.rs:169:13
    |
 LL |     let _ = if let Some(x) = Some(0) { s.len() + x } else { s.len() };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Some(0).map_or(s.len(), |x| s.len() + x)`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:168:13
+  --> $DIR/option_if_let_else.rs:173:13
    |
 LL |       let _ = if let Some(x) = Some(0) {
    |  _____________^
diff --git a/tests/ui/shadow.rs b/tests/ui/shadow.rs
index 0321f8c4cdf..a394ef8f25c 100644
--- a/tests/ui/shadow.rs
+++ b/tests/ui/shadow.rs
@@ -1,4 +1,5 @@
 #![warn(clippy::shadow_same, clippy::shadow_reuse, clippy::shadow_unrelated)]
+#![allow(clippy::let_unit_value)]
 
 fn shadow_same() {
     let x = 1;
diff --git a/tests/ui/shadow.stderr b/tests/ui/shadow.stderr
index f8b9221d555..3bd41d06260 100644
--- a/tests/ui/shadow.stderr
+++ b/tests/ui/shadow.stderr
@@ -1,266 +1,266 @@
 error: `x` is shadowed by itself in `x`
-  --> $DIR/shadow.rs:5:9
+  --> $DIR/shadow.rs:6:9
    |
 LL |     let x = x;
    |         ^
    |
    = note: `-D clippy::shadow-same` implied by `-D warnings`
 note: previous binding is here
-  --> $DIR/shadow.rs:4:9
+  --> $DIR/shadow.rs:5:9
    |
 LL |     let x = 1;
    |         ^
 
 error: `mut x` is shadowed by itself in `&x`
-  --> $DIR/shadow.rs:6:13
+  --> $DIR/shadow.rs:7:13
    |
 LL |     let mut x = &x;
    |             ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:5:9
+  --> $DIR/shadow.rs:6:9
    |
 LL |     let x = x;
    |         ^
 
 error: `x` is shadowed by itself in `&mut x`
-  --> $DIR/shadow.rs:7:9
+  --> $DIR/shadow.rs:8:9
    |
 LL |     let x = &mut x;
    |         ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:6:9
+  --> $DIR/shadow.rs:7:9
    |
 LL |     let mut x = &x;
    |         ^^^^^
 
 error: `x` is shadowed by itself in `*x`
-  --> $DIR/shadow.rs:8:9
+  --> $DIR/shadow.rs:9:9
    |
 LL |     let x = *x;
    |         ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:7:9
+  --> $DIR/shadow.rs:8:9
    |
 LL |     let x = &mut x;
    |         ^
 
 error: `x` is shadowed
-  --> $DIR/shadow.rs:13:9
+  --> $DIR/shadow.rs:14:9
    |
 LL |     let x = x.0;
    |         ^
    |
    = note: `-D clippy::shadow-reuse` implied by `-D warnings`
 note: previous binding is here
-  --> $DIR/shadow.rs:12:9
+  --> $DIR/shadow.rs:13:9
    |
 LL |     let x = ([[0]], ());
    |         ^
 
 error: `x` is shadowed
-  --> $DIR/shadow.rs:14:9
+  --> $DIR/shadow.rs:15:9
    |
 LL |     let x = x[0];
    |         ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:13:9
+  --> $DIR/shadow.rs:14:9
    |
 LL |     let x = x.0;
    |         ^
 
 error: `x` is shadowed
-  --> $DIR/shadow.rs:15:10
+  --> $DIR/shadow.rs:16:10
    |
 LL |     let [x] = x;
    |          ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:14:9
+  --> $DIR/shadow.rs:15:9
    |
 LL |     let x = x[0];
    |         ^
 
 error: `x` is shadowed
-  --> $DIR/shadow.rs:16:9
+  --> $DIR/shadow.rs:17:9
    |
 LL |     let x = Some(x);
    |         ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:15:10
+  --> $DIR/shadow.rs:16:10
    |
 LL |     let [x] = x;
    |          ^
 
 error: `x` is shadowed
-  --> $DIR/shadow.rs:17:9
+  --> $DIR/shadow.rs:18:9
    |
 LL |     let x = foo(x);
    |         ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:16:9
+  --> $DIR/shadow.rs:17:9
    |
 LL |     let x = Some(x);
    |         ^
 
 error: `x` is shadowed
-  --> $DIR/shadow.rs:18:9
+  --> $DIR/shadow.rs:19:9
    |
 LL |     let x = || x;
    |         ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:17:9
+  --> $DIR/shadow.rs:18:9
    |
 LL |     let x = foo(x);
    |         ^
 
 error: `x` is shadowed
-  --> $DIR/shadow.rs:19:9
+  --> $DIR/shadow.rs:20:9
    |
 LL |     let x = Some(1).map(|_| x)?;
    |         ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:18:9
+  --> $DIR/shadow.rs:19:9
    |
 LL |     let x = || x;
    |         ^
 
 error: `y` is shadowed
-  --> $DIR/shadow.rs:21:9
+  --> $DIR/shadow.rs:22:9
    |
 LL |     let y = match y {
    |         ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:20:9
+  --> $DIR/shadow.rs:21:9
    |
 LL |     let y = 1;
    |         ^
 
 error: `x` shadows a previous, unrelated binding
-  --> $DIR/shadow.rs:30:9
+  --> $DIR/shadow.rs:31:9
    |
 LL |     let x = 2;
    |         ^
    |
    = note: `-D clippy::shadow-unrelated` implied by `-D warnings`
 note: previous binding is here
-  --> $DIR/shadow.rs:29:9
+  --> $DIR/shadow.rs:30:9
    |
 LL |     let x = 1;
    |         ^
 
 error: `x` shadows a previous, unrelated binding
-  --> $DIR/shadow.rs:35:13
+  --> $DIR/shadow.rs:36:13
    |
 LL |         let x = 1;
    |             ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:34:10
+  --> $DIR/shadow.rs:35:10
    |
 LL |     fn f(x: u32) {
    |          ^
 
 error: `x` shadows a previous, unrelated binding
-  --> $DIR/shadow.rs:40:14
+  --> $DIR/shadow.rs:41:14
    |
 LL |         Some(x) => {
    |              ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:37:9
+  --> $DIR/shadow.rs:38:9
    |
 LL |     let x = 1;
    |         ^
 
 error: `x` shadows a previous, unrelated binding
-  --> $DIR/shadow.rs:41:17
+  --> $DIR/shadow.rs:42:17
    |
 LL |             let x = 1;
    |                 ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:40:14
+  --> $DIR/shadow.rs:41:14
    |
 LL |         Some(x) => {
    |              ^
 
 error: `x` shadows a previous, unrelated binding
-  --> $DIR/shadow.rs:45:17
+  --> $DIR/shadow.rs:46:17
    |
 LL |     if let Some(x) = Some(1) {}
    |                 ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:37:9
+  --> $DIR/shadow.rs:38:9
    |
 LL |     let x = 1;
    |         ^
 
 error: `x` shadows a previous, unrelated binding
-  --> $DIR/shadow.rs:46:20
+  --> $DIR/shadow.rs:47:20
    |
 LL |     while let Some(x) = Some(1) {}
    |                    ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:37:9
+  --> $DIR/shadow.rs:38:9
    |
 LL |     let x = 1;
    |         ^
 
 error: `x` shadows a previous, unrelated binding
-  --> $DIR/shadow.rs:47:15
+  --> $DIR/shadow.rs:48:15
    |
 LL |     let _ = |[x]: [u32; 1]| {
    |               ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:37:9
+  --> $DIR/shadow.rs:38:9
    |
 LL |     let x = 1;
    |         ^
 
 error: `x` shadows a previous, unrelated binding
-  --> $DIR/shadow.rs:48:13
+  --> $DIR/shadow.rs:49:13
    |
 LL |         let x = 1;
    |             ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:47:15
+  --> $DIR/shadow.rs:48:15
    |
 LL |     let _ = |[x]: [u32; 1]| {
    |               ^
 
 error: `y` is shadowed
-  --> $DIR/shadow.rs:51:17
+  --> $DIR/shadow.rs:52:17
    |
 LL |     if let Some(y) = y {}
    |                 ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:50:9
+  --> $DIR/shadow.rs:51:9
    |
 LL |     let y = Some(1);
    |         ^
 
 error: `_b` shadows a previous, unrelated binding
-  --> $DIR/shadow.rs:87:9
+  --> $DIR/shadow.rs:88:9
    |
 LL |     let _b = _a;
    |         ^^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:86:28
+  --> $DIR/shadow.rs:87:28
    |
 LL | pub async fn foo2(_a: i32, _b: i64) {
    |                            ^^
diff --git a/tests/ui/similar_names.rs b/tests/ui/similar_names.rs
index 76f6ce9ee6b..c21225d153b 100644
--- a/tests/ui/similar_names.rs
+++ b/tests/ui/similar_names.rs
@@ -3,7 +3,8 @@
     unused,
     clippy::println_empty_string,
     clippy::empty_loop,
-    clippy::diverging_sub_expression
+    clippy::diverging_sub_expression,
+    clippy::let_unit_value
 )]
 
 struct Foo {
diff --git a/tests/ui/similar_names.stderr b/tests/ui/similar_names.stderr
index faf572b0c6b..6e772693897 100644
--- a/tests/ui/similar_names.stderr
+++ b/tests/ui/similar_names.stderr
@@ -1,84 +1,84 @@
 error: binding's name is too similar to existing binding
-  --> $DIR/similar_names.rs:20:9
+  --> $DIR/similar_names.rs:21:9
    |
 LL |     let bpple: i32;
    |         ^^^^^
    |
    = note: `-D clippy::similar-names` implied by `-D warnings`
 note: existing binding defined here
-  --> $DIR/similar_names.rs:18:9
+  --> $DIR/similar_names.rs:19:9
    |
 LL |     let apple: i32;
    |         ^^^^^
 
 error: binding's name is too similar to existing binding
-  --> $DIR/similar_names.rs:22:9
+  --> $DIR/similar_names.rs:23:9
    |
 LL |     let cpple: i32;
    |         ^^^^^
    |
 note: existing binding defined here
-  --> $DIR/similar_names.rs:18:9
+  --> $DIR/similar_names.rs:19:9
    |
 LL |     let apple: i32;
    |         ^^^^^
 
 error: binding's name is too similar to existing binding
-  --> $DIR/similar_names.rs:46:9
+  --> $DIR/similar_names.rs:47:9
    |
 LL |     let bluby: i32;
    |         ^^^^^
    |
 note: existing binding defined here
-  --> $DIR/similar_names.rs:45:9
+  --> $DIR/similar_names.rs:46:9
    |
 LL |     let blubx: i32;
    |         ^^^^^
 
 error: binding's name is too similar to existing binding
-  --> $DIR/similar_names.rs:50:9
+  --> $DIR/similar_names.rs:51:9
    |
 LL |     let coke: i32;
    |         ^^^^
    |
 note: existing binding defined here
-  --> $DIR/similar_names.rs:48:9
+  --> $DIR/similar_names.rs:49:9
    |
 LL |     let cake: i32;
    |         ^^^^
 
 error: binding's name is too similar to existing binding
-  --> $DIR/similar_names.rs:68:9
+  --> $DIR/similar_names.rs:69:9
    |
 LL |     let xyzeabc: i32;
    |         ^^^^^^^
    |
 note: existing binding defined here
-  --> $DIR/similar_names.rs:66:9
+  --> $DIR/similar_names.rs:67:9
    |
 LL |     let xyz1abc: i32;
    |         ^^^^^^^
 
 error: binding's name is too similar to existing binding
-  --> $DIR/similar_names.rs:72:9
+  --> $DIR/similar_names.rs:73:9
    |
 LL |     let parsee: i32;
    |         ^^^^^^
    |
 note: existing binding defined here
-  --> $DIR/similar_names.rs:70:9
+  --> $DIR/similar_names.rs:71:9
    |
 LL |     let parser: i32;
    |         ^^^^^^
 
 error: binding's name is too similar to existing binding
-  --> $DIR/similar_names.rs:93:16
+  --> $DIR/similar_names.rs:94:16
    |
 LL |         bpple: sprang,
    |                ^^^^^^
    |
 note: existing binding defined here
-  --> $DIR/similar_names.rs:92:16
+  --> $DIR/similar_names.rs:93:16
    |
 LL |         apple: spring,
    |                ^^^^^^
diff --git a/tests/ui/single_char_lifetime_names.rs b/tests/ui/single_char_lifetime_names.rs
index 261d8bc7260..69c5b236f7c 100644
--- a/tests/ui/single_char_lifetime_names.rs
+++ b/tests/ui/single_char_lifetime_names.rs
@@ -1,4 +1,5 @@
 #![warn(clippy::single_char_lifetime_names)]
+#![allow(clippy::let_unit_value)]
 
 // Lifetimes should only be linted when they're introduced
 struct DiagnosticCtx<'a, 'b>
diff --git a/tests/ui/single_char_lifetime_names.stderr b/tests/ui/single_char_lifetime_names.stderr
index 013b64f46a8..1438b3999db 100644
--- a/tests/ui/single_char_lifetime_names.stderr
+++ b/tests/ui/single_char_lifetime_names.stderr
@@ -1,5 +1,5 @@
 error: single-character lifetime names are likely uninformative
-  --> $DIR/single_char_lifetime_names.rs:4:22
+  --> $DIR/single_char_lifetime_names.rs:5:22
    |
 LL | struct DiagnosticCtx<'a, 'b>
    |                      ^^
@@ -8,7 +8,7 @@ LL | struct DiagnosticCtx<'a, 'b>
    = help: use a more informative name
 
 error: single-character lifetime names are likely uninformative
-  --> $DIR/single_char_lifetime_names.rs:4:26
+  --> $DIR/single_char_lifetime_names.rs:5:26
    |
 LL | struct DiagnosticCtx<'a, 'b>
    |                          ^^
@@ -16,7 +16,7 @@ LL | struct DiagnosticCtx<'a, 'b>
    = help: use a more informative name
 
 error: single-character lifetime names are likely uninformative
-  --> $DIR/single_char_lifetime_names.rs:13:6
+  --> $DIR/single_char_lifetime_names.rs:14:6
    |
 LL | impl<'a, 'b> DiagnosticCtx<'a, 'b> {
    |      ^^
@@ -24,7 +24,7 @@ LL | impl<'a, 'b> DiagnosticCtx<'a, 'b> {
    = help: use a more informative name
 
 error: single-character lifetime names are likely uninformative
-  --> $DIR/single_char_lifetime_names.rs:13:10
+  --> $DIR/single_char_lifetime_names.rs:14:10
    |
 LL | impl<'a, 'b> DiagnosticCtx<'a, 'b> {
    |          ^^
@@ -32,7 +32,7 @@ LL | impl<'a, 'b> DiagnosticCtx<'a, 'b> {
    = help: use a more informative name
 
 error: single-character lifetime names are likely uninformative
-  --> $DIR/single_char_lifetime_names.rs:33:15
+  --> $DIR/single_char_lifetime_names.rs:34:15
    |
 LL | fn split_once<'a>(base: &'a str, other: &'_ str) -> (&'a str, Option<&'a str>) {
    |               ^^
diff --git a/tests/ui/suspicious_else_formatting.rs b/tests/ui/suspicious_else_formatting.rs
index fcd827a91c7..21753e5dc6a 100644
--- a/tests/ui/suspicious_else_formatting.rs
+++ b/tests/ui/suspicious_else_formatting.rs
@@ -1,7 +1,7 @@
 // aux-build:proc_macro_suspicious_else_formatting.rs
 
 #![warn(clippy::suspicious_else_formatting)]
-#![allow(clippy::if_same_then_else)]
+#![allow(clippy::if_same_then_else, clippy::let_unit_value)]
 
 extern crate proc_macro_suspicious_else_formatting;
 use proc_macro_suspicious_else_formatting::DeriveBadSpan;
diff --git a/tests/ui/undocumented_unsafe_blocks.rs b/tests/ui/undocumented_unsafe_blocks.rs
index afa337c45f4..7be15b0b2dd 100644
--- a/tests/ui/undocumented_unsafe_blocks.rs
+++ b/tests/ui/undocumented_unsafe_blocks.rs
@@ -1,6 +1,7 @@
 // aux-build:proc_macro_unsafe.rs
 
 #![warn(clippy::undocumented_unsafe_blocks)]
+#![allow(clippy::let_unit_value)]
 
 extern crate proc_macro_unsafe;
 
diff --git a/tests/ui/undocumented_unsafe_blocks.stderr b/tests/ui/undocumented_unsafe_blocks.stderr
index 856a07fd316..87d445bd7b8 100644
--- a/tests/ui/undocumented_unsafe_blocks.stderr
+++ b/tests/ui/undocumented_unsafe_blocks.stderr
@@ -1,5 +1,5 @@
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:256:19
+  --> $DIR/undocumented_unsafe_blocks.rs:257:19
    |
 LL |     /* Safety: */ unsafe {}
    |                   ^^^^^^^^^
@@ -8,7 +8,7 @@ LL |     /* Safety: */ unsafe {}
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:260:5
+  --> $DIR/undocumented_unsafe_blocks.rs:261:5
    |
 LL |     unsafe {}
    |     ^^^^^^^^^
@@ -16,7 +16,7 @@ LL |     unsafe {}
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:264:14
+  --> $DIR/undocumented_unsafe_blocks.rs:265:14
    |
 LL |     let _ = [unsafe { 14 }, unsafe { 15 }, 42, unsafe { 16 }];
    |              ^^^^^^^^^^^^^
@@ -24,7 +24,7 @@ LL |     let _ = [unsafe { 14 }, unsafe { 15 }, 42, unsafe { 16 }];
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:264:29
+  --> $DIR/undocumented_unsafe_blocks.rs:265:29
    |
 LL |     let _ = [unsafe { 14 }, unsafe { 15 }, 42, unsafe { 16 }];
    |                             ^^^^^^^^^^^^^
@@ -32,7 +32,7 @@ LL |     let _ = [unsafe { 14 }, unsafe { 15 }, 42, unsafe { 16 }];
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:264:48
+  --> $DIR/undocumented_unsafe_blocks.rs:265:48
    |
 LL |     let _ = [unsafe { 14 }, unsafe { 15 }, 42, unsafe { 16 }];
    |                                                ^^^^^^^^^^^^^
@@ -40,7 +40,7 @@ LL |     let _ = [unsafe { 14 }, unsafe { 15 }, 42, unsafe { 16 }];
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:268:18
+  --> $DIR/undocumented_unsafe_blocks.rs:269:18
    |
 LL |     let _ = (42, unsafe {}, "test", unsafe {});
    |                  ^^^^^^^^^
@@ -48,7 +48,7 @@ LL |     let _ = (42, unsafe {}, "test", unsafe {});
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:268:37
+  --> $DIR/undocumented_unsafe_blocks.rs:269:37
    |
 LL |     let _ = (42, unsafe {}, "test", unsafe {});
    |                                     ^^^^^^^^^
@@ -56,7 +56,7 @@ LL |     let _ = (42, unsafe {}, "test", unsafe {});
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:272:14
+  --> $DIR/undocumented_unsafe_blocks.rs:273:14
    |
 LL |     let _ = *unsafe { &42 };
    |              ^^^^^^^^^^^^^^
@@ -64,7 +64,7 @@ LL |     let _ = *unsafe { &42 };
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:277:19
+  --> $DIR/undocumented_unsafe_blocks.rs:278:19
    |
 LL |     let _ = match unsafe {} {
    |                   ^^^^^^^^^
@@ -72,7 +72,7 @@ LL |     let _ = match unsafe {} {
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:283:14
+  --> $DIR/undocumented_unsafe_blocks.rs:284:14
    |
 LL |     let _ = &unsafe {};
    |              ^^^^^^^^^
@@ -80,7 +80,7 @@ LL |     let _ = &unsafe {};
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:287:14
+  --> $DIR/undocumented_unsafe_blocks.rs:288:14
    |
 LL |     let _ = [unsafe {}; 5];
    |              ^^^^^^^^^
@@ -88,7 +88,7 @@ LL |     let _ = [unsafe {}; 5];
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:291:13
+  --> $DIR/undocumented_unsafe_blocks.rs:292:13
    |
 LL |     let _ = unsafe {};
    |             ^^^^^^^^^
@@ -96,7 +96,7 @@ LL |     let _ = unsafe {};
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:301:8
+  --> $DIR/undocumented_unsafe_blocks.rs:302:8
    |
 LL |     t!(unsafe {});
    |        ^^^^^^^^^
@@ -104,7 +104,7 @@ LL |     t!(unsafe {});
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:307:13
+  --> $DIR/undocumented_unsafe_blocks.rs:308:13
    |
 LL |             unsafe {}
    |             ^^^^^^^^^
@@ -116,7 +116,7 @@ LL |     t!();
    = note: this error originates in the macro `t` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:315:5
+  --> $DIR/undocumented_unsafe_blocks.rs:316:5
    |
 LL |     unsafe {} // SAFETY:
    |     ^^^^^^^^^
@@ -124,7 +124,7 @@ LL |     unsafe {} // SAFETY:
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:319:5
+  --> $DIR/undocumented_unsafe_blocks.rs:320:5
    |
 LL |     unsafe {
    |     ^^^^^^^^
@@ -132,7 +132,7 @@ LL |     unsafe {
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:329:5
+  --> $DIR/undocumented_unsafe_blocks.rs:330:5
    |
 LL |     unsafe {};
    |     ^^^^^^^^^
@@ -140,7 +140,7 @@ LL |     unsafe {};
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:333:20
+  --> $DIR/undocumented_unsafe_blocks.rs:334:20
    |
 LL |     println!("{}", unsafe { String::from_utf8_unchecked(vec![]) });
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/uninit.rs b/tests/ui/uninit.rs
index 1ed3883c1f0..dac5ce272c0 100644
--- a/tests/ui/uninit.rs
+++ b/tests/ui/uninit.rs
@@ -1,4 +1,5 @@
 #![feature(stmt_expr_attributes)]
+#![allow(clippy::let_unit_value)]
 
 use std::mem::{self, MaybeUninit};
 
diff --git a/tests/ui/uninit.stderr b/tests/ui/uninit.stderr
index 85b64a8419a..15ef2349489 100644
--- a/tests/ui/uninit.stderr
+++ b/tests/ui/uninit.stderr
@@ -1,5 +1,5 @@
 error: this call for this type may be undefined behavior
-  --> $DIR/uninit.rs:6:29
+  --> $DIR/uninit.rs:7:29
    |
 LL |     let _: usize = unsafe { MaybeUninit::uninit().assume_init() };
    |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -7,13 +7,13 @@ LL |     let _: usize = unsafe { MaybeUninit::uninit().assume_init() };
    = note: `#[deny(clippy::uninit_assumed_init)]` on by default
 
 error: this call for this type may be undefined behavior
-  --> $DIR/uninit.rs:9:31
+  --> $DIR/uninit.rs:10:31
    |
 LL |     let _: [u8; 0] = unsafe { MaybeUninit::uninit().assume_init() };
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this call for this type may be undefined behavior
-  --> $DIR/uninit.rs:24:29
+  --> $DIR/uninit.rs:25:29
    |
 LL |     let _: usize = unsafe { mem::MaybeUninit::uninit().assume_init() };
    |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/unit_arg.rs b/tests/ui/unit_arg.rs
index 535683729f6..38be87bddf1 100644
--- a/tests/ui/unit_arg.rs
+++ b/tests/ui/unit_arg.rs
@@ -7,7 +7,8 @@
     clippy::unnecessary_wraps,
     clippy::or_fun_call,
     clippy::needless_question_mark,
-    clippy::self_named_constructors
+    clippy::self_named_constructors,
+    clippy::let_unit_value
 )]
 
 use std::fmt::Debug;
diff --git a/tests/ui/unit_arg.stderr b/tests/ui/unit_arg.stderr
index 5cfb367a7be..394dee29dc9 100644
--- a/tests/ui/unit_arg.stderr
+++ b/tests/ui/unit_arg.stderr
@@ -1,5 +1,5 @@
 error: passing a unit value to a function
-  --> $DIR/unit_arg.rs:56:5
+  --> $DIR/unit_arg.rs:57:5
    |
 LL | /     foo({
 LL | |         1;
@@ -20,7 +20,7 @@ LL ~     foo(());
    |
 
 error: passing a unit value to a function
-  --> $DIR/unit_arg.rs:59:5
+  --> $DIR/unit_arg.rs:60:5
    |
 LL |     foo(foo(1));
    |     ^^^^^^^^^^^
@@ -32,7 +32,7 @@ LL ~     foo(());
    |
 
 error: passing a unit value to a function
-  --> $DIR/unit_arg.rs:60:5
+  --> $DIR/unit_arg.rs:61:5
    |
 LL | /     foo({
 LL | |         foo(1);
@@ -54,7 +54,7 @@ LL ~     foo(());
    |
 
 error: passing a unit value to a function
-  --> $DIR/unit_arg.rs:65:5
+  --> $DIR/unit_arg.rs:66:5
    |
 LL | /     b.bar({
 LL | |         1;
@@ -74,7 +74,7 @@ LL ~     b.bar(());
    |
 
 error: passing unit values to a function
-  --> $DIR/unit_arg.rs:68:5
+  --> $DIR/unit_arg.rs:69:5
    |
 LL |     taking_multiple_units(foo(0), foo(1));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -87,7 +87,7 @@ LL ~     taking_multiple_units((), ());
    |
 
 error: passing unit values to a function
-  --> $DIR/unit_arg.rs:69:5
+  --> $DIR/unit_arg.rs:70:5
    |
 LL | /     taking_multiple_units(foo(0), {
 LL | |         foo(1);
@@ -110,7 +110,7 @@ LL ~     taking_multiple_units((), ());
    |
 
 error: passing unit values to a function
-  --> $DIR/unit_arg.rs:73:5
+  --> $DIR/unit_arg.rs:74:5
    |
 LL | /     taking_multiple_units(
 LL | |         {
@@ -140,7 +140,7 @@ LL +         foo(2);
  ...
 
 error: passing a unit value to a function
-  --> $DIR/unit_arg.rs:84:13
+  --> $DIR/unit_arg.rs:85:13
    |
 LL |     None.or(Some(foo(2)));
    |             ^^^^^^^^^^^^
@@ -154,7 +154,7 @@ LL ~     });
    |
 
 error: passing a unit value to a function
-  --> $DIR/unit_arg.rs:87:5
+  --> $DIR/unit_arg.rs:88:5
    |
 LL |     foo(foo(()));
    |     ^^^^^^^^^^^^
@@ -166,7 +166,7 @@ LL ~     foo(());
    |
 
 error: passing a unit value to a function
-  --> $DIR/unit_arg.rs:124:5
+  --> $DIR/unit_arg.rs:125:5
    |
 LL |     Some(foo(1))
    |     ^^^^^^^^^^^^
diff --git a/tests/ui/unit_hash.rs b/tests/ui/unit_hash.rs
index 989916c239b..43eb54eff47 100644
--- a/tests/ui/unit_hash.rs
+++ b/tests/ui/unit_hash.rs
@@ -1,4 +1,5 @@
 #![warn(clippy::unit_hash)]
+#![allow(clippy::let_unit_value)]
 
 use std::collections::hash_map::DefaultHasher;
 use std::hash::Hash;
diff --git a/tests/ui/unit_hash.stderr b/tests/ui/unit_hash.stderr
index da276296e02..050fa55a12b 100644
--- a/tests/ui/unit_hash.stderr
+++ b/tests/ui/unit_hash.stderr
@@ -1,5 +1,5 @@
 error: this call to `hash` on the unit type will do nothing
-  --> $DIR/unit_hash.rs:18:23
+  --> $DIR/unit_hash.rs:19:23
    |
 LL |         Foo::Empty => ().hash(&mut state),
    |                       ^^^^^^^^^^^^^^^^^^^ help: remove the call to `hash` or consider using: `0_u8.hash(&mut state)`
@@ -8,7 +8,7 @@ LL |         Foo::Empty => ().hash(&mut state),
    = note: the implementation of `Hash` for `()` is a no-op
 
 error: this call to `hash` on the unit type will do nothing
-  --> $DIR/unit_hash.rs:23:5
+  --> $DIR/unit_hash.rs:24:5
    |
 LL |     res.hash(&mut state);
    |     ^^^^^^^^^^^^^^^^^^^^ help: remove the call to `hash` or consider using: `0_u8.hash(&mut state)`
@@ -16,7 +16,7 @@ LL |     res.hash(&mut state);
    = note: the implementation of `Hash` for `()` is a no-op
 
 error: this call to `hash` on the unit type will do nothing
-  --> $DIR/unit_hash.rs:26:5
+  --> $DIR/unit_hash.rs:27:5
    |
 LL |     do_nothing().hash(&mut state);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove the call to `hash` or consider using: `0_u8.hash(&mut state)`
diff --git a/tests/ui/wildcard_imports.fixed b/tests/ui/wildcard_imports.fixed
index 8402c33a4cd..b6f47ae906b 100644
--- a/tests/ui/wildcard_imports.fixed
+++ b/tests/ui/wildcard_imports.fixed
@@ -8,8 +8,7 @@
 // FIXME: We should likely add another edition 2021 test case for this lint
 
 #![warn(clippy::wildcard_imports)]
-#![allow(unused)]
-#![allow(clippy::unnecessary_wraps)]
+#![allow(unused, clippy::unnecessary_wraps, clippy::let_unit_value)]
 #![warn(unused_imports)]
 
 extern crate wildcard_imports_helper;
diff --git a/tests/ui/wildcard_imports.rs b/tests/ui/wildcard_imports.rs
index faaeaade9b0..eb404b7a3de 100644
--- a/tests/ui/wildcard_imports.rs
+++ b/tests/ui/wildcard_imports.rs
@@ -8,8 +8,7 @@
 // FIXME: We should likely add another edition 2021 test case for this lint
 
 #![warn(clippy::wildcard_imports)]
-#![allow(unused)]
-#![allow(clippy::unnecessary_wraps)]
+#![allow(unused, clippy::unnecessary_wraps, clippy::let_unit_value)]
 #![warn(unused_imports)]
 
 extern crate wildcard_imports_helper;
diff --git a/tests/ui/wildcard_imports.stderr b/tests/ui/wildcard_imports.stderr
index 7534a65ec9b..626c1754fc8 100644
--- a/tests/ui/wildcard_imports.stderr
+++ b/tests/ui/wildcard_imports.stderr
@@ -1,5 +1,5 @@
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:17:5
+  --> $DIR/wildcard_imports.rs:16:5
    |
 LL | use crate::fn_mod::*;
    |     ^^^^^^^^^^^^^^^^ help: try: `crate::fn_mod::foo`
@@ -7,85 +7,85 @@ LL | use crate::fn_mod::*;
    = note: `-D clippy::wildcard-imports` implied by `-D warnings`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:18:5
+  --> $DIR/wildcard_imports.rs:17:5
    |
 LL | use crate::mod_mod::*;
    |     ^^^^^^^^^^^^^^^^^ help: try: `crate::mod_mod::inner_mod`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:19:5
+  --> $DIR/wildcard_imports.rs:18:5
    |
 LL | use crate::multi_fn_mod::*;
    |     ^^^^^^^^^^^^^^^^^^^^^^ help: try: `crate::multi_fn_mod::{multi_bar, multi_foo, multi_inner_mod}`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:21:5
+  --> $DIR/wildcard_imports.rs:20:5
    |
 LL | use crate::struct_mod::*;
    |     ^^^^^^^^^^^^^^^^^^^^ help: try: `crate::struct_mod::{A, inner_struct_mod}`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:25:5
+  --> $DIR/wildcard_imports.rs:24:5
    |
 LL | use wildcard_imports_helper::inner::inner_for_self_import::*;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `wildcard_imports_helper::inner::inner_for_self_import::inner_extern_bar`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:26:5
+  --> $DIR/wildcard_imports.rs:25:5
    |
 LL | use wildcard_imports_helper::*;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `wildcard_imports_helper::{ExternA, extern_foo}`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:97:13
+  --> $DIR/wildcard_imports.rs:96:13
    |
 LL |         use crate::fn_mod::*;
    |             ^^^^^^^^^^^^^^^^ help: try: `crate::fn_mod::foo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:103:75
+  --> $DIR/wildcard_imports.rs:102:75
    |
 LL |         use wildcard_imports_helper::inner::inner_for_self_import::{self, *};
    |                                                                           ^ help: try: `inner_extern_foo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:104:13
+  --> $DIR/wildcard_imports.rs:103:13
    |
 LL |         use wildcard_imports_helper::*;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `wildcard_imports_helper::{ExternA, extern_foo}`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:115:20
+  --> $DIR/wildcard_imports.rs:114:20
    |
 LL |         use self::{inner::*, inner2::*};
    |                    ^^^^^^^^ help: try: `inner::inner_foo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:115:30
+  --> $DIR/wildcard_imports.rs:114:30
    |
 LL |         use self::{inner::*, inner2::*};
    |                              ^^^^^^^^^ help: try: `inner2::inner_bar`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:122:13
+  --> $DIR/wildcard_imports.rs:121:13
    |
 LL |         use wildcard_imports_helper::*;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `wildcard_imports_helper::{ExternExportedEnum, ExternExportedStruct, extern_exported}`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:151:9
+  --> $DIR/wildcard_imports.rs:150:9
    |
 LL |     use crate::in_fn_test::*;
    |         ^^^^^^^^^^^^^^^^^^^^ help: try: `crate::in_fn_test::{ExportedEnum, ExportedStruct, exported}`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:160:9
+  --> $DIR/wildcard_imports.rs:159:9
    |
 LL |     use crate:: in_fn_test::  * ;
    |         ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `crate:: in_fn_test::exported`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:161:9
+  --> $DIR/wildcard_imports.rs:160:9
    |
 LL |       use crate:: fn_mod::
    |  _________^
@@ -93,37 +93,37 @@ LL | |         *;
    | |_________^ help: try: `crate:: fn_mod::foo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:172:13
+  --> $DIR/wildcard_imports.rs:171:13
    |
 LL |         use super::*;
    |             ^^^^^^^^ help: try: `super::foofoo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:207:17
+  --> $DIR/wildcard_imports.rs:206:17
    |
 LL |             use super::*;
    |                 ^^^^^^^^ help: try: `super::insidefoo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:215:13
+  --> $DIR/wildcard_imports.rs:214:13
    |
 LL |         use super_imports::*;
    |             ^^^^^^^^^^^^^^^^ help: try: `super_imports::foofoo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:224:17
+  --> $DIR/wildcard_imports.rs:223:17
    |
 LL |             use super::super::*;
    |                 ^^^^^^^^^^^^^^^ help: try: `super::super::foofoo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:233:13
+  --> $DIR/wildcard_imports.rs:232:13
    |
 LL |         use super::super::super_imports::*;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `super::super::super_imports::foofoo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:241:13
+  --> $DIR/wildcard_imports.rs:240:13
    |
 LL |         use super::*;
    |             ^^^^^^^^ help: try: `super::foofoo`
-- 
cgit 1.4.1-3-g733a5


From 70f7c624e442c3049d440cd20f8d77b66580105c Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Mon, 4 Apr 2022 21:54:34 -0400
Subject: Allow more complex expressions in `let_unit_value`

---
 clippy_lints/src/unit_types/let_unit_value.rs | 10 +++++++-
 clippy_utils/src/visitors.rs                  | 34 +++++++++++++++++++++++++++
 tests/ui/cast_alignment.rs                    |  6 ++---
 tests/ui/let_unit.fixed                       | 25 ++++++++++++++++++++
 tests/ui/let_unit.rs                          | 25 ++++++++++++++++++++
 tests/ui/let_unit.stderr                      | 31 +++++++++++++++++++++++-
 tests/ui/or_then_unwrap.fixed                 |  2 +-
 tests/ui/or_then_unwrap.rs                    |  2 +-
 tests/ui/panicking_macros.rs                  |  2 +-
 9 files changed, 129 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unit_types/let_unit_value.rs b/clippy_lints/src/unit_types/let_unit_value.rs
index 39352b3ee47..96858fc7f27 100644
--- a/clippy_lints/src/unit_types/let_unit_value.rs
+++ b/clippy_lints/src/unit_types/let_unit_value.rs
@@ -1,5 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet_with_macro_callsite;
+use clippy_utils::visitors::for_each_value_source;
 use core::ops::ControlFlow;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, PatKind, Stmt, StmtKind};
@@ -11,11 +12,18 @@ use super::LET_UNIT_VALUE;
 
 pub(super) fn check(cx: &LateContext<'_>, stmt: &Stmt<'_>) {
     if let StmtKind::Local(local) = stmt.kind
+        && let Some(init) = local.init
         && !local.pat.span.from_expansion()
         && !in_external_macro(cx.sess(), stmt.span)
         && cx.typeck_results().pat_ty(local.pat).is_unit()
     {
-        if local.init.map_or(false, |e| needs_inferred_result_ty(cx, e)) {
+        let needs_inferred = for_each_value_source(init, &mut |e| if needs_inferred_result_ty(cx, e) {
+            ControlFlow::Continue(())
+        } else {
+            ControlFlow::Break(())
+        }).is_continue();
+
+        if needs_inferred {
             if !matches!(local.pat.kind, PatKind::Wild) {
                 span_lint_and_then(
                     cx,
diff --git a/clippy_utils/src/visitors.rs b/clippy_utils/src/visitors.rs
index 3db64b25353..c00bc2bd213 100644
--- a/clippy_utils/src/visitors.rs
+++ b/clippy_utils/src/visitors.rs
@@ -1,4 +1,5 @@
 use crate::path_to_local_id;
+use core::ops::ControlFlow;
 use rustc_hir as hir;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::intravisit::{self, walk_block, walk_expr, Visitor};
@@ -402,3 +403,36 @@ pub fn contains_unsafe_block<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'tcx>)
     v.visit_expr(e);
     v.found_unsafe
 }
+
+/// Runs the given function for each sub-expression producing the final value consumed by the parent
+/// of the give expression.
+///
+/// e.g. for the following expression
+/// ```rust,ignore
+/// if foo {
+///     f(0)
+/// } else {
+///     1 + 1
+/// }
+/// ```
+/// this will pass both `f(0)` and `1+1` to the given function.
+pub fn for_each_value_source<'tcx, B>(
+    e: &'tcx Expr<'tcx>,
+    f: &mut impl FnMut(&'tcx Expr<'tcx>) -> ControlFlow<B>,
+) -> ControlFlow<B> {
+    match e.kind {
+        ExprKind::Block(Block { expr: Some(e), .. }, _) => for_each_value_source(e, f),
+        ExprKind::Match(_, arms, _) => {
+            for arm in arms {
+                for_each_value_source(arm.body, f)?;
+            }
+            ControlFlow::Continue(())
+        },
+        ExprKind::If(_, if_expr, Some(else_expr)) => {
+            for_each_value_source(if_expr, f)?;
+            for_each_value_source(else_expr, f)
+        },
+        ExprKind::DropTemps(e) => for_each_value_source(e, f),
+        _ => f(e),
+    }
+}
diff --git a/tests/ui/cast_alignment.rs b/tests/ui/cast_alignment.rs
index e4e7290a30e..95bb883df1b 100644
--- a/tests/ui/cast_alignment.rs
+++ b/tests/ui/cast_alignment.rs
@@ -44,8 +44,8 @@ fn main() {
         let _ = core::ptr::read_unaligned(ptr as *const u16);
         let _ = core::intrinsics::unaligned_volatile_load(ptr as *const u16);
         let ptr = &mut data as *mut [u8; 2] as *mut u8;
-        let _ = (ptr as *mut u16).write_unaligned(0);
-        let _ = core::ptr::write_unaligned(ptr as *mut u16, 0);
-        let _ = core::intrinsics::unaligned_volatile_store(ptr as *mut u16, 0);
+        (ptr as *mut u16).write_unaligned(0);
+        core::ptr::write_unaligned(ptr as *mut u16, 0);
+        core::intrinsics::unaligned_volatile_store(ptr as *mut u16, 0);
     }
 }
diff --git a/tests/ui/let_unit.fixed b/tests/ui/let_unit.fixed
index 5fee742b192..e72b7462325 100644
--- a/tests/ui/let_unit.fixed
+++ b/tests/ui/let_unit.fixed
@@ -87,4 +87,29 @@ fn _returns_generic() {
 
     f4(vec![()]); // Lint
     f4(vec![()]); // Lint
+
+    // Ok
+    let _: () = {
+        let x = 5;
+        f2(x)
+    };
+
+    let _: () = if true { f() } else { f2(0) }; // Ok
+    let _: () = if true { f() } else { f2(0) }; // Lint
+
+    // Ok
+    let _: () = match Some(0) {
+        None => f2(1),
+        Some(0) => f(),
+        Some(1) => f2(3),
+        Some(_) => f2('x'),
+    };
+
+    // Lint
+    match Some(0) {
+        None => f2(1),
+        Some(0) => f(),
+        Some(1) => f2(3),
+        Some(_) => (),
+    };
 }
diff --git a/tests/ui/let_unit.rs b/tests/ui/let_unit.rs
index 505e4a7d8fd..47ee0a76724 100644
--- a/tests/ui/let_unit.rs
+++ b/tests/ui/let_unit.rs
@@ -87,4 +87,29 @@ fn _returns_generic() {
 
     let _: () = f4(vec![()]); // Lint
     let x: () = f4(vec![()]); // Lint
+
+    // Ok
+    let _: () = {
+        let x = 5;
+        f2(x)
+    };
+
+    let _: () = if true { f() } else { f2(0) }; // Ok
+    let x: () = if true { f() } else { f2(0) }; // Lint
+
+    // Ok
+    let _: () = match Some(0) {
+        None => f2(1),
+        Some(0) => f(),
+        Some(1) => f2(3),
+        Some(_) => f2('x'),
+    };
+
+    // Lint
+    let _: () = match Some(0) {
+        None => f2(1),
+        Some(0) => f(),
+        Some(1) => f2(3),
+        Some(_) => (),
+    };
 }
diff --git a/tests/ui/let_unit.stderr b/tests/ui/let_unit.stderr
index c4a766bb974..13ec11a6d33 100644
--- a/tests/ui/let_unit.stderr
+++ b/tests/ui/let_unit.stderr
@@ -74,5 +74,34 @@ error: this let-binding has unit value
 LL |     let x: () = f4(vec![()]); // Lint
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^ help: omit the `let` binding: `f4(vec![()]);`
 
-error: aborting due to 9 previous errors
+error: this let-binding has unit value
+  --> $DIR/let_unit.rs:98:5
+   |
+LL |     let x: () = if true { f() } else { f2(0) }; // Lint
+   |     ^^^^-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |         |
+   |         help: use a wild (`_`) binding: `_`
+
+error: this let-binding has unit value
+  --> $DIR/let_unit.rs:109:5
+   |
+LL | /     let _: () = match Some(0) {
+LL | |         None => f2(1),
+LL | |         Some(0) => f(),
+LL | |         Some(1) => f2(3),
+LL | |         Some(_) => (),
+LL | |     };
+   | |______^
+   |
+help: omit the `let` binding
+   |
+LL ~     match Some(0) {
+LL +         None => f2(1),
+LL +         Some(0) => f(),
+LL +         Some(1) => f2(3),
+LL +         Some(_) => (),
+LL +     };
+   |
+
+error: aborting due to 11 previous errors
 
diff --git a/tests/ui/or_then_unwrap.fixed b/tests/ui/or_then_unwrap.fixed
index 6e0d5a87f68..844cc4b7a09 100644
--- a/tests/ui/or_then_unwrap.fixed
+++ b/tests/ui/or_then_unwrap.fixed
@@ -1,7 +1,7 @@
 // run-rustfix
 
 #![warn(clippy::or_then_unwrap)]
-#![allow(clippy::map_identity)]
+#![allow(clippy::map_identity, clippy::let_unit_value)]
 
 struct SomeStruct;
 impl SomeStruct {
diff --git a/tests/ui/or_then_unwrap.rs b/tests/ui/or_then_unwrap.rs
index e406a71d46d..1528ef9be96 100644
--- a/tests/ui/or_then_unwrap.rs
+++ b/tests/ui/or_then_unwrap.rs
@@ -1,7 +1,7 @@
 // run-rustfix
 
 #![warn(clippy::or_then_unwrap)]
-#![allow(clippy::map_identity)]
+#![allow(clippy::map_identity, clippy::let_unit_value)]
 
 struct SomeStruct;
 impl SomeStruct {
diff --git a/tests/ui/panicking_macros.rs b/tests/ui/panicking_macros.rs
index 12a0c776ae2..041ef17fa68 100644
--- a/tests/ui/panicking_macros.rs
+++ b/tests/ui/panicking_macros.rs
@@ -1,4 +1,4 @@
-#![allow(clippy::assertions_on_constants, clippy::eq_op)]
+#![allow(clippy::assertions_on_constants, clippy::eq_op, clippy::let_unit_value)]
 #![feature(inline_const)]
 #![warn(clippy::unimplemented, clippy::unreachable, clippy::todo, clippy::panic)]
 
-- 
cgit 1.4.1-3-g733a5


From b592cc659b5891606846ae9333d0d373c4a25dea Mon Sep 17 00:00:00 2001
From: Jeong YunWon <jeong@youknowone.org>
Date: Fri, 15 Apr 2022 19:33:16 +0900
Subject: Fix typo in comment

---
 clippy_lints/src/matches/needless_match.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/needless_match.rs b/clippy_lints/src/matches/needless_match.rs
index 2105a03e03a..d6c8e472552 100644
--- a/clippy_lints/src/matches/needless_match.rs
+++ b/clippy_lints/src/matches/needless_match.rs
@@ -83,7 +83,7 @@ fn check_if_let(cx: &LateContext<'_>, if_let: &higher::IfLet<'_>) -> bool {
             return false;
         }
 
-        // Recurrsively check for each `else if let` phrase,
+        // Recursively check for each `else if let` phrase,
         if let Some(ref nested_if_let) = higher::IfLet::hir(cx, if_else) {
             return check_if_let(cx, nested_if_let);
         }
-- 
cgit 1.4.1-3-g733a5


From d1a78f3ea5c17ab5fd7239942242dfcd12c4545f Mon Sep 17 00:00:00 2001
From: dlup <93457935+lupd@users.noreply.github.com>
Date: Fri, 15 Apr 2022 16:34:44 -0400
Subject: Fix formatting of `cast_abs_to_unsigned` docs

---
 clippy_lints/src/casts/mod.rs | 1 +
 1 file changed, 1 insertion(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index 55c1f085657..ee6be230617 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -487,6 +487,7 @@ declare_clippy_lint! {
     /// let y: u32 = x.abs() as u32;
     /// ```
     /// Use instead:
+    /// ```rust
     /// let x: i32 = -42;
     /// let y: u32 = x.unsigned_abs();
     /// ```
-- 
cgit 1.4.1-3-g733a5


From 29ef80c78a0f9c58607944e50d3240eee2b7cdc7 Mon Sep 17 00:00:00 2001
From: whodi <whodi@pop-os.localdomain>
Date: Fri, 15 Apr 2022 14:25:55 -0400
Subject: adding spell checking

---
 .github/ISSUE_TEMPLATE/blank_issue.yml                      | 2 +-
 .github/ISSUE_TEMPLATE/false_negative.yml                   | 2 +-
 .github/ISSUE_TEMPLATE/false_positive.yml                   | 2 +-
 .github/workflows/clippy.yml                                | 4 ++--
 clippy_dev/src/setup/git_hook.rs                            | 2 +-
 clippy_dev/src/setup/mod.rs                                 | 4 ++--
 clippy_lints/src/casts/mod.rs                               | 2 +-
 clippy_lints/src/empty_structs_with_brackets.rs             | 2 +-
 clippy_lints/src/index_refutable_slice.rs                   | 2 +-
 clippy_lints/src/match_result_ok.rs                         | 4 ++--
 clippy_lints/src/matches/match_same_arms.rs                 | 4 ++--
 clippy_lints/src/matches/mod.rs                             | 4 ++--
 clippy_lints/src/matches/needless_match.rs                  | 2 +-
 clippy_lints/src/methods/mod.rs                             | 4 ++--
 clippy_lints/src/missing_inline.rs                          | 2 +-
 clippy_lints/src/needless_bitwise_bool.rs                   | 4 ++--
 clippy_lints/src/needless_late_init.rs                      | 6 +++---
 clippy_lints/src/octal_escapes.rs                           | 2 +-
 clippy_lints/src/option_if_let_else.rs                      | 8 ++++----
 clippy_lints/src/suspicious_operation_groupings.rs          | 2 +-
 clippy_lints/src/transmute/utils.rs                         | 2 +-
 clippy_lints/src/types/mod.rs                               | 2 +-
 clippy_lints/src/unnested_or_patterns.rs                    | 2 +-
 clippy_lints/src/use_self.rs                                | 2 +-
 clippy_lints/src/utils/author.rs                            | 2 +-
 clippy_lints/src/utils/internal_lints.rs                    | 4 ++--
 clippy_lints/src/utils/internal_lints/metadata_collector.rs | 6 +++---
 clippy_utils/src/macros.rs                                  | 2 +-
 clippy_utils/src/source.rs                                  | 2 +-
 tests/lint_message_convention.rs                            | 2 +-
 tests/ui/auxiliary/proc_macro_derive.rs                     | 2 +-
 31 files changed, 46 insertions(+), 46 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/.github/ISSUE_TEMPLATE/blank_issue.yml b/.github/ISSUE_TEMPLATE/blank_issue.yml
index d610e8c7bc4..89884bfc859 100644
--- a/.github/ISSUE_TEMPLATE/blank_issue.yml
+++ b/.github/ISSUE_TEMPLATE/blank_issue.yml
@@ -9,7 +9,7 @@ body:
     attributes:
       label: Description
       description: >
-        Please provide a discription of the issue, along with any information
+        Please provide a description of the issue, along with any information
         you feel relevant to replicate it.
     validations:
       required: true
diff --git a/.github/ISSUE_TEMPLATE/false_negative.yml b/.github/ISSUE_TEMPLATE/false_negative.yml
index 9357ccc4f4e..25e436d30b9 100644
--- a/.github/ISSUE_TEMPLATE/false_negative.yml
+++ b/.github/ISSUE_TEMPLATE/false_negative.yml
@@ -23,7 +23,7 @@ body:
     id: reproducer
     attributes:
       label: Reproducer
-      description: Please provide the code and steps to repoduce the bug
+      description: Please provide the code and steps to reproduce the bug
       value: |
         I tried this code:
 
diff --git a/.github/ISSUE_TEMPLATE/false_positive.yml b/.github/ISSUE_TEMPLATE/false_positive.yml
index b7dd400ee73..561b65c93a7 100644
--- a/.github/ISSUE_TEMPLATE/false_positive.yml
+++ b/.github/ISSUE_TEMPLATE/false_positive.yml
@@ -24,7 +24,7 @@ body:
     attributes:
       label: Reproducer
       description: >
-        Please provide the code and steps to repoduce the bug together with the
+        Please provide the code and steps to reproduce the bug together with the
         output from Clippy.
       value: |
         I tried this code:
diff --git a/.github/workflows/clippy.yml b/.github/workflows/clippy.yml
index cd83bc9642b..4292949a02d 100644
--- a/.github/workflows/clippy.yml
+++ b/.github/workflows/clippy.yml
@@ -6,14 +6,14 @@ on:
     branches-ignore:
       - auto
       - try
-    # Don't run Clippy tests, when only textfiles were modified
+    # Don't run Clippy tests, when only text files were modified
     paths-ignore:
     - 'COPYRIGHT'
     - 'LICENSE-*'
     - '**.md'
     - '**.txt'
   pull_request:
-    # Don't run Clippy tests, when only textfiles were modified
+    # Don't run Clippy tests, when only text files were modified
     paths-ignore:
     - 'COPYRIGHT'
     - 'LICENSE-*'
diff --git a/clippy_dev/src/setup/git_hook.rs b/clippy_dev/src/setup/git_hook.rs
index 3fbb77d5923..ad4b96f7ff3 100644
--- a/clippy_dev/src/setup/git_hook.rs
+++ b/clippy_dev/src/setup/git_hook.rs
@@ -18,7 +18,7 @@ pub fn install_hook(force_override: bool) {
 
     // So a little bit of a funny story. Git on unix requires the pre-commit file
     // to have the `execute` permission to be set. The Rust functions for modifying
-    // these flags doesn't seem to work when executed with normal user permissions.
+    // these flags doesn't seem to work when executed with normal user permissions. 
     //
     // However, there is a little hack that is also being used by Rust itself in their
     // setup script. Git saves the `execute` flag when syncing files. This means
diff --git a/clippy_dev/src/setup/mod.rs b/clippy_dev/src/setup/mod.rs
index a1e4dd103b8..f691ae4fa45 100644
--- a/clippy_dev/src/setup/mod.rs
+++ b/clippy_dev/src/setup/mod.rs
@@ -7,7 +7,7 @@ use std::path::Path;
 const CLIPPY_DEV_DIR: &str = "clippy_dev";
 
 /// This function verifies that the tool is being executed in the clippy directory.
-/// This is useful to ensure that setups only modify Clippys resources. The verification
+/// This is useful to ensure that setups only modify Clippy's resources. The verification
 /// is done by checking that `clippy_dev` is a sub directory of the current directory.
 ///
 /// It will print an error message and return `false` if the directory could not be
@@ -17,7 +17,7 @@ fn verify_inside_clippy_dir() -> bool {
     if path.exists() && path.is_dir() {
         true
     } else {
-        eprintln!("error: unable to verify that the working directory is clippys directory");
+        eprintln!("error: unable to verify that the working directory is clippy's directory");
         false
     }
 }
diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index 55c1f085657..f05315a7d0c 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -270,7 +270,7 @@ declare_clippy_lint! {
     ///
     /// ### Why is this bad?
     /// Casting a function pointer to an integer can have surprising results and can occur
-    /// accidentally if parantheses are omitted from a function call. If you aren't doing anything
+    /// accidentally if parentheses are omitted from a function call. If you aren't doing anything
     /// low-level with function pointers then you can opt-out of casting functions to integers in
     /// order to avoid mistakes. Alternatively, you can use this lint to audit all uses of function
     /// pointer casts in your code.
diff --git a/clippy_lints/src/empty_structs_with_brackets.rs b/clippy_lints/src/empty_structs_with_brackets.rs
index fdeac8d8255..8430e7b4c82 100644
--- a/clippy_lints/src/empty_structs_with_brackets.rs
+++ b/clippy_lints/src/empty_structs_with_brackets.rs
@@ -66,7 +66,7 @@ fn has_no_fields(cx: &EarlyContext<'_>, var_data: &VariantData, braces_span: Spa
     }
 
     // there might still be field declarations hidden from the AST
-    // (conditionaly compiled code using #[cfg(..)])
+    // (conditionally compiled code using #[cfg(..)])
 
     let Some(braces_span_str) = snippet_opt(cx, braces_span) else {
         return false;
diff --git a/clippy_lints/src/index_refutable_slice.rs b/clippy_lints/src/index_refutable_slice.rs
index 6b62748ffef..8a84513b779 100644
--- a/clippy_lints/src/index_refutable_slice.rs
+++ b/clippy_lints/src/index_refutable_slice.rs
@@ -116,7 +116,7 @@ fn find_slice_values(cx: &LateContext<'_>, pat: &hir::Pat<'_>) -> FxIndexMap<hir
             let bound_ty = cx.typeck_results().node_type(pat.hir_id);
             if let ty::Slice(inner_ty) | ty::Array(inner_ty, _) = bound_ty.peel_refs().kind() {
                 // The values need to use the `ref` keyword if they can't be copied.
-                // This will need to be adjusted if the lint want to support multable access in the future
+                // This will need to be adjusted if the lint want to support mutable access in the future
                 let src_is_ref = bound_ty.is_ref() && binding != hir::BindingAnnotation::Ref;
                 let needs_ref = !(src_is_ref || is_copy(cx, *inner_ty));
 
diff --git a/clippy_lints/src/match_result_ok.rs b/clippy_lints/src/match_result_ok.rs
index 77a4917ec58..3349b85f134 100644
--- a/clippy_lints/src/match_result_ok.rs
+++ b/clippy_lints/src/match_result_ok.rs
@@ -24,7 +24,7 @@ declare_clippy_lint! {
     ///     vec.push(value)
     /// }
     ///
-    /// if let Some(valie) = iter.next().ok() {
+    /// if let Some(value) = iter.next().ok() {
     ///     vec.push(value)
     /// }
     /// ```
@@ -60,7 +60,7 @@ impl<'tcx> LateLintPass<'tcx> for MatchResultOk {
         if_chain! {
             if let ExprKind::MethodCall(ok_path, [ref result_types_0, ..], _) = let_expr.kind; //check is expr.ok() has type Result<T,E>.ok(, _)
             if let PatKind::TupleStruct(QPath::Resolved(_, x), y, _)  = let_pat.kind; //get operation
-            if method_chain_args(let_expr, &["ok"]).is_some(); //test to see if using ok() methoduse std::marker::Sized;
+            if method_chain_args(let_expr, &["ok"]).is_some(); //test to see if using ok() method use std::marker::Sized;
             if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(result_types_0), sym::Result);
             if rustc_hir_pretty::to_string(rustc_hir_pretty::NO_ANN, |s| s.print_path(x, false)) == "Some";
 
diff --git a/clippy_lints/src/matches/match_same_arms.rs b/clippy_lints/src/matches/match_same_arms.rs
index b8591fe0db0..9b7344fb8b0 100644
--- a/clippy_lints/src/matches/match_same_arms.rs
+++ b/clippy_lints/src/matches/match_same_arms.rs
@@ -30,7 +30,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>]) {
         .map(|a| NormalizedPat::from_pat(cx, &arena, a.pat))
         .collect();
 
-    // The furthast forwards a pattern can move without semantic changes
+    // The furthest forwards a pattern can move without semantic changes
     let forwards_blocking_idxs: Vec<_> = normalized_pats
         .iter()
         .enumerate()
@@ -43,7 +43,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>]) {
         })
         .collect();
 
-    // The furthast backwards a pattern can move without semantic changes
+    // The furthest backwards a pattern can move without semantic changes
     let backwards_blocking_idxs: Vec<_> = normalized_pats
         .iter()
         .enumerate()
diff --git a/clippy_lints/src/matches/mod.rs b/clippy_lints/src/matches/mod.rs
index 854cf06ed81..401ecef460c 100644
--- a/clippy_lints/src/matches/mod.rs
+++ b/clippy_lints/src/matches/mod.rs
@@ -7,7 +7,7 @@ use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::{Span, SpanData, SyntaxContext};
 
-mod infalliable_detructuring_match;
+mod infallible_destructuring_match;
 mod match_as_ref;
 mod match_bool;
 mod match_like_matches;
@@ -694,7 +694,7 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
     }
 
     fn check_local(&mut self, cx: &LateContext<'tcx>, local: &'tcx Local<'_>) {
-        self.infallible_destructuring_match_linted |= infalliable_detructuring_match::check(cx, local);
+        self.infallible_destructuring_match_linted |= infallible_destructuring_match::check(cx, local);
     }
 
     fn check_pat(&mut self, cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>) {
diff --git a/clippy_lints/src/matches/needless_match.rs b/clippy_lints/src/matches/needless_match.rs
index d6c8e472552..0abe6ddda65 100644
--- a/clippy_lints/src/matches/needless_match.rs
+++ b/clippy_lints/src/matches/needless_match.rs
@@ -118,7 +118,7 @@ fn strip_return<'hir>(expr: &'hir Expr<'hir>) -> &'hir Expr<'hir> {
 }
 
 /// Manually check for coercion casting by checking if the type of the match operand or let expr
-/// differs with the assigned local variable or the funtion return type.
+/// differs with the assigned local variable or the function return type.
 fn expr_ty_matches_p_ty(cx: &LateContext<'_>, expr: &Expr<'_>, p_expr: &Expr<'_>) -> bool {
     if let Some(p_node) = get_parent_node(cx.tcx, p_expr.hir_id) {
         match p_node {
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index f1a74220e68..70a2aaf78a0 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1266,7 +1266,7 @@ declare_clippy_lint! {
     #[clippy::version = "1.55.0"]
     pub EXTEND_WITH_DRAIN,
     perf,
-    "using vec.append(&mut vec) to move the full range of a vecor to another"
+    "using vec.append(&mut vec) to move the full range of a vector to another"
 }
 
 declare_clippy_lint! {
@@ -2100,7 +2100,7 @@ declare_clippy_lint! {
     /// using `.collect::<String>()` over `.collect::<Vec<String>>().join("")`
     /// will prevent loop unrolling and will result in a negative performance impact.
     ///
-    /// Additionlly, differences have been observed between aarch64 and x86_64 assembly output,
+    /// Additionally, differences have been observed between aarch64 and x86_64 assembly output,
     /// with aarch64 tending to producing faster assembly in more cases when using `.collect::<String>()`
     #[clippy::version = "1.61.0"]
     pub UNNECESSARY_JOIN,
diff --git a/clippy_lints/src/missing_inline.rs b/clippy_lints/src/missing_inline.rs
index ac2f16b49e3..6e6ad1ebbce 100644
--- a/clippy_lints/src/missing_inline.rs
+++ b/clippy_lints/src/missing_inline.rs
@@ -44,7 +44,7 @@ declare_clippy_lint! {
     /// pub struct PubBaz;
     /// impl PubBaz {
     ///    fn private() {} // ok
-    ///    pub fn not_ptrivate() {} // missing #[inline]
+    ///    pub fn not_private() {} // missing #[inline]
     /// }
     ///
     /// impl Bar for PubBaz {
diff --git a/clippy_lints/src/needless_bitwise_bool.rs b/clippy_lints/src/needless_bitwise_bool.rs
index a8a8d174a82..95395e2e136 100644
--- a/clippy_lints/src/needless_bitwise_bool.rs
+++ b/clippy_lints/src/needless_bitwise_bool.rs
@@ -53,7 +53,7 @@ fn is_bitwise_operation(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
     false
 }
 
-fn suggession_snippet(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<String> {
+fn suggesstion_snippet(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<String> {
     if let ExprKind::Binary(ref op, left, right) = expr.kind {
         if let (Some(l_snippet), Some(r_snippet)) = (snippet_opt(cx, left.span), snippet_opt(cx, right.span)) {
             let op_snippet = match op.node {
@@ -75,7 +75,7 @@ impl LateLintPass<'_> for NeedlessBitwiseBool {
                 expr.span,
                 "use of bitwise operator instead of lazy operator between booleans",
                 |diag| {
-                    if let Some(sugg) = suggession_snippet(cx, expr) {
+                    if let Some(sugg) = suggesstion_snippet(cx, expr) {
                         diag.span_suggestion(expr.span, "try", sugg, Applicability::MachineApplicable);
                     }
                 },
diff --git a/clippy_lints/src/needless_late_init.rs b/clippy_lints/src/needless_late_init.rs
index 9957afcbf04..bbcf7e9e378 100644
--- a/clippy_lints/src/needless_late_init.rs
+++ b/clippy_lints/src/needless_late_init.rs
@@ -240,7 +240,7 @@ fn check<'tcx>(
                 cx,
                 NEEDLESS_LATE_INIT,
                 local_stmt.span,
-                "unneeded late initalization",
+                "unneeded late initialization",
                 |diag| {
                     diag.tool_only_span_suggestion(
                         local_stmt.span,
@@ -265,7 +265,7 @@ fn check<'tcx>(
                 cx,
                 NEEDLESS_LATE_INIT,
                 local_stmt.span,
-                "unneeded late initalization",
+                "unneeded late initialization",
                 |diag| {
                     diag.tool_only_span_suggestion(local_stmt.span, "remove the local", String::new(), applicability);
 
@@ -296,7 +296,7 @@ fn check<'tcx>(
                 cx,
                 NEEDLESS_LATE_INIT,
                 local_stmt.span,
-                "unneeded late initalization",
+                "unneeded late initialization",
                 |diag| {
                     diag.tool_only_span_suggestion(local_stmt.span, "remove the local", String::new(), applicability);
 
diff --git a/clippy_lints/src/octal_escapes.rs b/clippy_lints/src/octal_escapes.rs
index c19cea66104..e8532db4f71 100644
--- a/clippy_lints/src/octal_escapes.rs
+++ b/clippy_lints/src/octal_escapes.rs
@@ -25,7 +25,7 @@ declare_clippy_lint! {
     ///
     /// ### Known problems
     /// The actual meaning can be the intended one. `\x00` can be used in these
-    /// cases to be unambigious.
+    /// cases to be unambiguous.
     ///
     /// The lint does not trigger for format strings in `print!()`, `write!()`
     /// and friends since the string is already preprocessed when Clippy lints
diff --git a/clippy_lints/src/option_if_let_else.rs b/clippy_lints/src/option_if_let_else.rs
index c9f807f2aa3..ea5a8f0858b 100644
--- a/clippy_lints/src/option_if_let_else.rs
+++ b/clippy_lints/src/option_if_let_else.rs
@@ -78,7 +78,7 @@ fn is_result_ok(cx: &LateContext<'_>, expr: &'_ Expr<'_>) -> bool {
 
 /// A struct containing information about occurrences of the
 /// `if let Some(..) = .. else` construct that this lint detects.
-struct OptionIfLetElseOccurence {
+struct OptionIfLetElseOccurrence {
     option: String,
     method_sugg: String,
     some_expr: String,
@@ -100,9 +100,9 @@ fn format_option_in_sugg(cx: &LateContext<'_>, cond_expr: &Expr<'_>, as_ref: boo
 }
 
 /// If this expression is the option if let/else construct we're detecting, then
-/// this function returns an `OptionIfLetElseOccurence` struct with details if
+/// this function returns an `OptionIfLetElseOccurrence` struct with details if
 /// this construct is found, or None if this construct is not found.
-fn detect_option_if_let_else<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>) -> Option<OptionIfLetElseOccurence> {
+fn detect_option_if_let_else<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>) -> Option<OptionIfLetElseOccurrence> {
     if_chain! {
         if !expr.span.from_expansion(); // Don't lint macros, because it behaves weirdly
         if !in_constant(cx, expr.hir_id);
@@ -154,7 +154,7 @@ fn detect_option_if_let_else<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>) ->
                     }
                 }
             }
-            Some(OptionIfLetElseOccurence {
+            Some(OptionIfLetElseOccurrence {
                 option: format_option_in_sugg(cx, cond_expr, as_ref, as_mut),
                 method_sugg: method_sugg.to_string(),
                 some_expr: format!("|{}{}| {}", capture_mut, capture_name, Sugg::hir_with_macro_callsite(cx, some_body, "..")),
diff --git a/clippy_lints/src/suspicious_operation_groupings.rs b/clippy_lints/src/suspicious_operation_groupings.rs
index b5dd27ff80d..c4c1aa11004 100644
--- a/clippy_lints/src/suspicious_operation_groupings.rs
+++ b/clippy_lints/src/suspicious_operation_groupings.rs
@@ -550,7 +550,7 @@ fn ident_difference_expr_with_base_location(
     // IdentIter, then the output of this function will be almost always be correct
     // in practice.
     //
-    // If it turns out that problematic cases are more prelavent than we assume,
+    // If it turns out that problematic cases are more prevalent than we assume,
     // then we should be able to change this function to do the correct traversal,
     // without needing to change the rest of the code.
 
diff --git a/clippy_lints/src/transmute/utils.rs b/clippy_lints/src/transmute/utils.rs
index 0e07a0b0392..0cbf5ccefa6 100644
--- a/clippy_lints/src/transmute/utils.rs
+++ b/clippy_lints/src/transmute/utils.rs
@@ -87,7 +87,7 @@ fn check_cast<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>, from_ty: Ty<'tcx>
             let res = check.do_check(&fn_ctxt);
 
             // do_check's documentation says that it might return Ok and create
-            // errors in the fcx instead of returing Err in some cases. Those cases
+            // errors in the fcx instead of returning Err in some cases. Those cases
             // should be filtered out before getting here.
             assert!(
                 !fn_ctxt.errors_reported_since_creation(),
diff --git a/clippy_lints/src/types/mod.rs b/clippy_lints/src/types/mod.rs
index 67cc8913318..b1b2addb9a1 100644
--- a/clippy_lints/src/types/mod.rs
+++ b/clippy_lints/src/types/mod.rs
@@ -432,7 +432,7 @@ impl Types {
     fn check_fn_decl(&mut self, cx: &LateContext<'_>, decl: &FnDecl<'_>, context: CheckTyContext) {
         // Ignore functions in trait implementations as they are usually forced by the trait definition.
         //
-        // FIXME: idially we would like to warn *if the compicated type can be simplified*, but it's hard to
+        // FIXME: ideally we would like to warn *if the complicated type can be simplified*, but it's hard to
         // check.
         if context.is_in_trait_impl {
             return;
diff --git a/clippy_lints/src/unnested_or_patterns.rs b/clippy_lints/src/unnested_or_patterns.rs
index 790ffe618d7..ae431aac83b 100644
--- a/clippy_lints/src/unnested_or_patterns.rs
+++ b/clippy_lints/src/unnested_or_patterns.rs
@@ -25,7 +25,7 @@ declare_clippy_lint! {
     /// *disjunctive normal form (DNF)* into *conjunctive normal form (CNF)*.
     ///
     /// ### Why is this bad?
-    /// In the example above, `Some` is repeated, which unncessarily complicates the pattern.
+    /// In the example above, `Some` is repeated, which unnecessarily complicates the pattern.
     ///
     /// ### Example
     /// ```rust
diff --git a/clippy_lints/src/use_self.rs b/clippy_lints/src/use_self.rs
index f8e1021af0e..138f8bccb3f 100644
--- a/clippy_lints/src/use_self.rs
+++ b/clippy_lints/src/use_self.rs
@@ -30,7 +30,7 @@ declare_clippy_lint! {
     ///
     /// ### Known problems
     /// - Unaddressed false negative in fn bodies of trait implementations
-    /// - False positive with assotiated types in traits (#4140)
+    /// - False positive with associated types in traits (#4140)
     ///
     /// ### Example
     /// ```rust
diff --git a/clippy_lints/src/utils/author.rs b/clippy_lints/src/utils/author.rs
index d23c85c033b..ff5be825b78 100644
--- a/clippy_lints/src/utils/author.rs
+++ b/clippy_lints/src/utils/author.rs
@@ -70,7 +70,7 @@ macro_rules! bind {
     };
 }
 
-/// Transforms the given `Option<T>` varibles into `OptionPat<Binding<T>>`.
+/// Transforms the given `Option<T>` variables into `OptionPat<Binding<T>>`.
 /// This displays as `Some($name)` or `None` when printed. The name of the inner binding
 /// is set to the name of the variable passed to the macro.
 macro_rules! opt_bind {
diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs
index 25d74b8c499..0e8f40e9210 100644
--- a/clippy_lints/src/utils/internal_lints.rs
+++ b/clippy_lints/src/utils/internal_lints.rs
@@ -292,7 +292,7 @@ declare_clippy_lint! {
     /// Checks for unnecessary conversion from Symbol to a string.
     ///
     /// ### Why is this bad?
-    /// It's faster use symbols directly intead of strings.
+    /// It's faster use symbols directly instead of strings.
     ///
     /// ### Example
     /// Bad:
@@ -823,7 +823,7 @@ fn suggest_note(
         cx,
         COLLAPSIBLE_SPAN_LINT_CALLS,
         expr.span,
-        "this call is collspible",
+        "this call is collapsible",
         "collapse into",
         format!(
             "span_lint_and_note({}, {}, {}, {}, {}, {})",
diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index ca03b8010dd..526bb2f7e06 100644
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -117,7 +117,7 @@ const APPLICABILITY_NAME_INDEX: usize = 2;
 /// This applicability will be set for unresolved applicability values.
 const APPLICABILITY_UNRESOLVED_STR: &str = "Unresolved";
 /// The version that will be displayed if none has been defined
-const VERION_DEFAULT_STR: &str = "Unknown";
+const VERSION_DEFAULT_STR: &str = "Unknown";
 
 declare_clippy_lint! {
     /// ### What it does
@@ -571,7 +571,7 @@ fn extract_attr_docs(cx: &LateContext<'_>, item: &Item<'_>) -> Option<String> {
 
 fn get_lint_version(cx: &LateContext<'_>, item: &Item<'_>) -> String {
     extract_clippy_version_value(cx, item).map_or_else(
-        || VERION_DEFAULT_STR.to_string(),
+        || VERSION_DEFAULT_STR.to_string(),
         |version| version.as_str().to_string(),
     )
 }
@@ -872,7 +872,7 @@ impl<'a, 'hir> IsMultiSpanScanner<'a, 'hir> {
         self.suggestion_count += 2;
     }
 
-    /// Checks if the suggestions include multiple spanns
+    /// Checks if the suggestions include multiple spans
     fn is_multi_part(&self) -> bool {
         self.suggestion_count > 1
     }
diff --git a/clippy_utils/src/macros.rs b/clippy_utils/src/macros.rs
index e7d4c5a4952..a268e339bb1 100644
--- a/clippy_utils/src/macros.rs
+++ b/clippy_utils/src/macros.rs
@@ -367,7 +367,7 @@ impl<'tcx> FormatArgsExpn<'tcx> {
         expr_visitor_no_bodies(|e| {
             // if we're still inside of the macro definition...
             if e.span.ctxt() == expr.span.ctxt() {
-                // ArgumnetV1::new_<format_trait>(<value>)
+                // ArgumentV1::new_<format_trait>(<value>)
                 if_chain! {
                     if let ExprKind::Call(callee, [val]) = e.kind;
                     if let ExprKind::Path(QPath::TypeRelative(ty, seg)) = callee.kind;
diff --git a/clippy_utils/src/source.rs b/clippy_utils/src/source.rs
index beed7326803..c69a3d8d2a1 100644
--- a/clippy_utils/src/source.rs
+++ b/clippy_utils/src/source.rs
@@ -108,7 +108,7 @@ pub fn is_present_in_source<T: LintContext>(cx: &T, span: Span) -> bool {
     true
 }
 
-/// Returns the positon just before rarrow
+/// Returns the position just before rarrow
 ///
 /// ```rust,ignore
 /// fn into(self) -> () {}
diff --git a/tests/lint_message_convention.rs b/tests/lint_message_convention.rs
index dc82ba891fb..dd1d4412036 100644
--- a/tests/lint_message_convention.rs
+++ b/tests/lint_message_convention.rs
@@ -66,7 +66,7 @@ fn lint_message_convention() {
 
     // make sure that lint messages:
     // * are not capitalized
-    // * don't have puncuation at the end of the last sentence
+    // * don't have punctuation at the end of the last sentence
 
     // these directories have interesting tests
     let test_dirs = ["ui", "ui-cargo", "ui-internal", "ui-toml"]
diff --git a/tests/ui/auxiliary/proc_macro_derive.rs b/tests/ui/auxiliary/proc_macro_derive.rs
index 4b7b7fec78f..ed7b17651e6 100644
--- a/tests/ui/auxiliary/proc_macro_derive.rs
+++ b/tests/ui/auxiliary/proc_macro_derive.rs
@@ -13,7 +13,7 @@ use proc_macro::{quote, TokenStream};
 
 #[proc_macro_derive(DeriveSomething)]
 pub fn derive(_: TokenStream) -> TokenStream {
-    // Shound not trigger `used_underscore_binding`
+    // Should not trigger `used_underscore_binding`
     let _inside_derive = 1;
     assert_eq!(_inside_derive, _inside_derive);
 
-- 
cgit 1.4.1-3-g733a5


From fb1934b63ff692870e9793ea60624d3ab2736d05 Mon Sep 17 00:00:00 2001
From: whodi <whodi@pop-os.localdomain>
Date: Fri, 15 Apr 2022 14:33:53 -0400
Subject: infallible <> infalliable in filename

---
 .../src/matches/infalliable_detructuring_match.rs  | 44 ----------------------
 .../src/matches/infallible_detructuring_match.rs   | 44 ++++++++++++++++++++++
 2 files changed, 44 insertions(+), 44 deletions(-)
 delete mode 100644 clippy_lints/src/matches/infalliable_detructuring_match.rs
 create mode 100644 clippy_lints/src/matches/infallible_detructuring_match.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/infalliable_detructuring_match.rs b/clippy_lints/src/matches/infalliable_detructuring_match.rs
deleted file mode 100644
index 2472acb6f6e..00000000000
--- a/clippy_lints/src/matches/infalliable_detructuring_match.rs
+++ /dev/null
@@ -1,44 +0,0 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::{path_to_local_id, peel_blocks, strip_pat_refs};
-use rustc_errors::Applicability;
-use rustc_hir::{ExprKind, Local, MatchSource, PatKind, QPath};
-use rustc_lint::LateContext;
-
-use super::INFALLIBLE_DESTRUCTURING_MATCH;
-
-pub(crate) fn check(cx: &LateContext<'_>, local: &Local<'_>) -> bool {
-    if_chain! {
-        if !local.span.from_expansion();
-        if let Some(expr) = local.init;
-        if let ExprKind::Match(target, arms, MatchSource::Normal) = expr.kind;
-        if arms.len() == 1 && arms[0].guard.is_none();
-        if let PatKind::TupleStruct(
-            QPath::Resolved(None, variant_name), args, _) = arms[0].pat.kind;
-        if args.len() == 1;
-        if let PatKind::Binding(_, arg, ..) = strip_pat_refs(&args[0]).kind;
-        let body = peel_blocks(arms[0].body);
-        if path_to_local_id(body, arg);
-
-        then {
-            let mut applicability = Applicability::MachineApplicable;
-            span_lint_and_sugg(
-                cx,
-                INFALLIBLE_DESTRUCTURING_MATCH,
-                local.span,
-                "you seem to be trying to use `match` to destructure a single infallible pattern. \
-                Consider using `let`",
-                "try this",
-                format!(
-                    "let {}({}) = {};",
-                    snippet_with_applicability(cx, variant_name.span, "..", &mut applicability),
-                    snippet_with_applicability(cx, local.pat.span, "..", &mut applicability),
-                    snippet_with_applicability(cx, target.span, "..", &mut applicability),
-                ),
-                applicability,
-            );
-            return true;
-        }
-    }
-    false
-}
diff --git a/clippy_lints/src/matches/infallible_detructuring_match.rs b/clippy_lints/src/matches/infallible_detructuring_match.rs
new file mode 100644
index 00000000000..2472acb6f6e
--- /dev/null
+++ b/clippy_lints/src/matches/infallible_detructuring_match.rs
@@ -0,0 +1,44 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::{path_to_local_id, peel_blocks, strip_pat_refs};
+use rustc_errors::Applicability;
+use rustc_hir::{ExprKind, Local, MatchSource, PatKind, QPath};
+use rustc_lint::LateContext;
+
+use super::INFALLIBLE_DESTRUCTURING_MATCH;
+
+pub(crate) fn check(cx: &LateContext<'_>, local: &Local<'_>) -> bool {
+    if_chain! {
+        if !local.span.from_expansion();
+        if let Some(expr) = local.init;
+        if let ExprKind::Match(target, arms, MatchSource::Normal) = expr.kind;
+        if arms.len() == 1 && arms[0].guard.is_none();
+        if let PatKind::TupleStruct(
+            QPath::Resolved(None, variant_name), args, _) = arms[0].pat.kind;
+        if args.len() == 1;
+        if let PatKind::Binding(_, arg, ..) = strip_pat_refs(&args[0]).kind;
+        let body = peel_blocks(arms[0].body);
+        if path_to_local_id(body, arg);
+
+        then {
+            let mut applicability = Applicability::MachineApplicable;
+            span_lint_and_sugg(
+                cx,
+                INFALLIBLE_DESTRUCTURING_MATCH,
+                local.span,
+                "you seem to be trying to use `match` to destructure a single infallible pattern. \
+                Consider using `let`",
+                "try this",
+                format!(
+                    "let {}({}) = {};",
+                    snippet_with_applicability(cx, variant_name.span, "..", &mut applicability),
+                    snippet_with_applicability(cx, local.pat.span, "..", &mut applicability),
+                    snippet_with_applicability(cx, target.span, "..", &mut applicability),
+                ),
+                applicability,
+            );
+            return true;
+        }
+    }
+    false
+}
-- 
cgit 1.4.1-3-g733a5


From 2be7ad5b39b182e7e2ce6cbe2c49a259288cd464 Mon Sep 17 00:00:00 2001
From: whodi <whodi@pop-os.localdomain>
Date: Fri, 15 Apr 2022 15:00:44 -0400
Subject: initialization misspell

---
 clippy_dev/src/setup/git_hook.rs                   |  2 +-
 .../src/matches/infallible_destructuring_match.rs  | 44 ++++++++++++++++++++++
 .../src/matches/infallible_detructuring_match.rs   | 44 ----------------------
 clippy_lints/src/types/mod.rs                      |  4 +-
 tests/ui/needless_late_init.stderr                 | 18 ++++-----
 tests/ui/needless_late_init_fixable.stderr         | 12 +++---
 6 files changed, 62 insertions(+), 62 deletions(-)
 create mode 100644 clippy_lints/src/matches/infallible_destructuring_match.rs
 delete mode 100644 clippy_lints/src/matches/infallible_detructuring_match.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_dev/src/setup/git_hook.rs b/clippy_dev/src/setup/git_hook.rs
index ad4b96f7ff3..3fbb77d5923 100644
--- a/clippy_dev/src/setup/git_hook.rs
+++ b/clippy_dev/src/setup/git_hook.rs
@@ -18,7 +18,7 @@ pub fn install_hook(force_override: bool) {
 
     // So a little bit of a funny story. Git on unix requires the pre-commit file
     // to have the `execute` permission to be set. The Rust functions for modifying
-    // these flags doesn't seem to work when executed with normal user permissions. 
+    // these flags doesn't seem to work when executed with normal user permissions.
     //
     // However, there is a little hack that is also being used by Rust itself in their
     // setup script. Git saves the `execute` flag when syncing files. This means
diff --git a/clippy_lints/src/matches/infallible_destructuring_match.rs b/clippy_lints/src/matches/infallible_destructuring_match.rs
new file mode 100644
index 00000000000..2472acb6f6e
--- /dev/null
+++ b/clippy_lints/src/matches/infallible_destructuring_match.rs
@@ -0,0 +1,44 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::{path_to_local_id, peel_blocks, strip_pat_refs};
+use rustc_errors::Applicability;
+use rustc_hir::{ExprKind, Local, MatchSource, PatKind, QPath};
+use rustc_lint::LateContext;
+
+use super::INFALLIBLE_DESTRUCTURING_MATCH;
+
+pub(crate) fn check(cx: &LateContext<'_>, local: &Local<'_>) -> bool {
+    if_chain! {
+        if !local.span.from_expansion();
+        if let Some(expr) = local.init;
+        if let ExprKind::Match(target, arms, MatchSource::Normal) = expr.kind;
+        if arms.len() == 1 && arms[0].guard.is_none();
+        if let PatKind::TupleStruct(
+            QPath::Resolved(None, variant_name), args, _) = arms[0].pat.kind;
+        if args.len() == 1;
+        if let PatKind::Binding(_, arg, ..) = strip_pat_refs(&args[0]).kind;
+        let body = peel_blocks(arms[0].body);
+        if path_to_local_id(body, arg);
+
+        then {
+            let mut applicability = Applicability::MachineApplicable;
+            span_lint_and_sugg(
+                cx,
+                INFALLIBLE_DESTRUCTURING_MATCH,
+                local.span,
+                "you seem to be trying to use `match` to destructure a single infallible pattern. \
+                Consider using `let`",
+                "try this",
+                format!(
+                    "let {}({}) = {};",
+                    snippet_with_applicability(cx, variant_name.span, "..", &mut applicability),
+                    snippet_with_applicability(cx, local.pat.span, "..", &mut applicability),
+                    snippet_with_applicability(cx, target.span, "..", &mut applicability),
+                ),
+                applicability,
+            );
+            return true;
+        }
+    }
+    false
+}
diff --git a/clippy_lints/src/matches/infallible_detructuring_match.rs b/clippy_lints/src/matches/infallible_detructuring_match.rs
deleted file mode 100644
index 2472acb6f6e..00000000000
--- a/clippy_lints/src/matches/infallible_detructuring_match.rs
+++ /dev/null
@@ -1,44 +0,0 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::{path_to_local_id, peel_blocks, strip_pat_refs};
-use rustc_errors::Applicability;
-use rustc_hir::{ExprKind, Local, MatchSource, PatKind, QPath};
-use rustc_lint::LateContext;
-
-use super::INFALLIBLE_DESTRUCTURING_MATCH;
-
-pub(crate) fn check(cx: &LateContext<'_>, local: &Local<'_>) -> bool {
-    if_chain! {
-        if !local.span.from_expansion();
-        if let Some(expr) = local.init;
-        if let ExprKind::Match(target, arms, MatchSource::Normal) = expr.kind;
-        if arms.len() == 1 && arms[0].guard.is_none();
-        if let PatKind::TupleStruct(
-            QPath::Resolved(None, variant_name), args, _) = arms[0].pat.kind;
-        if args.len() == 1;
-        if let PatKind::Binding(_, arg, ..) = strip_pat_refs(&args[0]).kind;
-        let body = peel_blocks(arms[0].body);
-        if path_to_local_id(body, arg);
-
-        then {
-            let mut applicability = Applicability::MachineApplicable;
-            span_lint_and_sugg(
-                cx,
-                INFALLIBLE_DESTRUCTURING_MATCH,
-                local.span,
-                "you seem to be trying to use `match` to destructure a single infallible pattern. \
-                Consider using `let`",
-                "try this",
-                format!(
-                    "let {}({}) = {};",
-                    snippet_with_applicability(cx, variant_name.span, "..", &mut applicability),
-                    snippet_with_applicability(cx, local.pat.span, "..", &mut applicability),
-                    snippet_with_applicability(cx, target.span, "..", &mut applicability),
-                ),
-                applicability,
-            );
-            return true;
-        }
-    }
-    false
-}
diff --git a/clippy_lints/src/types/mod.rs b/clippy_lints/src/types/mod.rs
index b1b2addb9a1..353a6f6b899 100644
--- a/clippy_lints/src/types/mod.rs
+++ b/clippy_lints/src/types/mod.rs
@@ -432,8 +432,8 @@ impl Types {
     fn check_fn_decl(&mut self, cx: &LateContext<'_>, decl: &FnDecl<'_>, context: CheckTyContext) {
         // Ignore functions in trait implementations as they are usually forced by the trait definition.
         //
-        // FIXME: ideally we would like to warn *if the complicated type can be simplified*, but it's hard to
-        // check.
+        // FIXME: ideally we would like to warn *if the complicated type can be simplified*, but it's hard
+        // to check.
         if context.is_in_trait_impl {
             return;
         }
diff --git a/tests/ui/needless_late_init.stderr b/tests/ui/needless_late_init.stderr
index 9ef8bb23df6..124fe5592c3 100644
--- a/tests/ui/needless_late_init.stderr
+++ b/tests/ui/needless_late_init.stderr
@@ -1,4 +1,4 @@
-error: unneeded late initalization
+error: unneeded late initialization
   --> $DIR/needless_late_init.rs:5:5
    |
 LL |     let a;
@@ -20,7 +20,7 @@ help: add a semicolon after the `match` expression
 LL |     };
    |      +
 
-error: unneeded late initalization
+error: unneeded late initialization
   --> $DIR/needless_late_init.rs:14:5
    |
 LL |     let b;
@@ -41,7 +41,7 @@ help: add a semicolon after the `if` expression
 LL |     };
    |      +
 
-error: unneeded late initalization
+error: unneeded late initialization
   --> $DIR/needless_late_init.rs:21:5
    |
 LL |     let c;
@@ -62,7 +62,7 @@ help: add a semicolon after the `if` expression
 LL |     };
    |      +
 
-error: unneeded late initalization
+error: unneeded late initialization
   --> $DIR/needless_late_init.rs:28:5
    |
 LL |     let d;
@@ -83,7 +83,7 @@ help: add a semicolon after the `if` expression
 LL |     };
    |      +
 
-error: unneeded late initalization
+error: unneeded late initialization
   --> $DIR/needless_late_init.rs:36:5
    |
 LL |     let e;
@@ -104,7 +104,7 @@ help: add a semicolon after the `if` expression
 LL |     };
    |      +
 
-error: unneeded late initalization
+error: unneeded late initialization
   --> $DIR/needless_late_init.rs:43:5
    |
 LL |     let f;
@@ -120,7 +120,7 @@ LL -         1 => f = "three",
 LL +         1 => "three",
    | 
 
-error: unneeded late initalization
+error: unneeded late initialization
   --> $DIR/needless_late_init.rs:49:5
    |
 LL |     let g: usize;
@@ -140,7 +140,7 @@ help: add a semicolon after the `if` expression
 LL |     };
    |      +
 
-error: unneeded late initalization
+error: unneeded late initialization
   --> $DIR/needless_late_init.rs:64:5
    |
 LL |     let a;
@@ -161,7 +161,7 @@ help: add a semicolon after the `match` expression
 LL |     };
    |      +
 
-error: unneeded late initalization
+error: unneeded late initialization
   --> $DIR/needless_late_init.rs:81:5
    |
 LL |     let a;
diff --git a/tests/ui/needless_late_init_fixable.stderr b/tests/ui/needless_late_init_fixable.stderr
index 3f3d4f5286b..34dccc2cec8 100644
--- a/tests/ui/needless_late_init_fixable.stderr
+++ b/tests/ui/needless_late_init_fixable.stderr
@@ -1,4 +1,4 @@
-error: unneeded late initalization
+error: unneeded late initialization
   --> $DIR/needless_late_init_fixable.rs:6:5
    |
 LL |     let a;
@@ -10,7 +10,7 @@ help: declare `a` here
 LL |     let a = "zero";
    |     ~~~~~
 
-error: unneeded late initalization
+error: unneeded late initialization
   --> $DIR/needless_late_init_fixable.rs:9:5
    |
 LL |     let b;
@@ -21,7 +21,7 @@ help: declare `b` here
 LL |     let b = 1;
    |     ~~~~~
 
-error: unneeded late initalization
+error: unneeded late initialization
   --> $DIR/needless_late_init_fixable.rs:10:5
    |
 LL |     let c;
@@ -32,7 +32,7 @@ help: declare `c` here
 LL |     let c = 2;
    |     ~~~~~
 
-error: unneeded late initalization
+error: unneeded late initialization
   --> $DIR/needless_late_init_fixable.rs:14:5
    |
 LL |     let d: usize;
@@ -43,7 +43,7 @@ help: declare `d` here
 LL |     let d: usize = 1;
    |     ~~~~~~~~~~~~
 
-error: unneeded late initalization
+error: unneeded late initialization
   --> $DIR/needless_late_init_fixable.rs:17:5
    |
 LL |     let mut e;
@@ -54,7 +54,7 @@ help: declare `e` here
 LL |     let mut e = 1;
    |     ~~~~~~~~~
 
-error: unneeded late initalization
+error: unneeded late initialization
   --> $DIR/needless_late_init_fixable.rs:21:5
    |
 LL |     let h;
-- 
cgit 1.4.1-3-g733a5


From 4844325faf392beb47c6e6d3231dfbba55f926c2 Mon Sep 17 00:00:00 2001
From: Lily Mara <lilymara@onesignal.com>
Date: Thu, 14 Apr 2022 16:52:10 -0700
Subject: Add `await_holding_invalid_type` lint

changelog: [`await_holding_invalid_type`]

This lint allows users to create a denylist of types which are not allowed to be
held across await points. This is essentially a re-implementation of the
language-level [`must_not_suspend`
lint](https://github.com/rust-lang/rust/issues/83310). That lint has a lot of
work still to be done before it will reach Rust stable, and in the meantime
there are a lot of types which can trip up developers if they are used
improperly.
---
 CHANGELOG.md                                       |   1 +
 Cargo.toml                                         |   1 +
 clippy_lints/src/await_holding_invalid.rs          | 165 ++++++++++++++++-----
 clippy_lints/src/lib.register_all.rs               |   1 +
 clippy_lints/src/lib.register_lints.rs             |   1 +
 clippy_lints/src/lib.register_suspicious.rs        |   1 +
 clippy_lints/src/lib.rs                            |   7 +-
 clippy_lints/src/utils/conf.rs                     |   2 +
 tests/compile-test.rs                              |   4 +
 .../await_holding_invalid_type.rs                  |  41 +++++
 .../await_holding_invalid_type.stderr              |  25 ++++
 .../ui-toml/await_holding_invalid_type/clippy.toml |   4 +
 .../toml_unknown_key/conf_unknown_key.stderr       |   2 +-
 13 files changed, 215 insertions(+), 40 deletions(-)
 create mode 100644 tests/ui-toml/await_holding_invalid_type/await_holding_invalid_type.rs
 create mode 100644 tests/ui-toml/await_holding_invalid_type/await_holding_invalid_type.stderr
 create mode 100644 tests/ui-toml/await_holding_invalid_type/clippy.toml

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 39786c08156..7aa4884d103 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3182,6 +3182,7 @@ Released 2018-09-13
 [`assign_op_pattern`]: https://rust-lang.github.io/rust-clippy/master/index.html#assign_op_pattern
 [`assign_ops`]: https://rust-lang.github.io/rust-clippy/master/index.html#assign_ops
 [`async_yields_async`]: https://rust-lang.github.io/rust-clippy/master/index.html#async_yields_async
+[`await_holding_invalid_type`]: https://rust-lang.github.io/rust-clippy/master/index.html#await_holding_invalid_type
 [`await_holding_lock`]: https://rust-lang.github.io/rust-clippy/master/index.html#await_holding_lock
 [`await_holding_refcell_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#await_holding_refcell_ref
 [`bad_bit_mask`]: https://rust-lang.github.io/rust-clippy/master/index.html#bad_bit_mask
diff --git a/Cargo.toml b/Cargo.toml
index dd6518d5241..1fb532deb9b 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -50,6 +50,7 @@ futures = "0.3"
 parking_lot = "0.11.2"
 tokio = { version = "1", features = ["io-util"] }
 rustc-semver = "1.1"
+tracing = "0.1"
 
 [build-dependencies]
 rustc_tools_util = { version = "0.2", path = "rustc_tools_util" }
diff --git a/clippy_lints/src/await_holding_invalid.rs b/clippy_lints/src/await_holding_invalid.rs
index 4592ca72748..36b4f7faa19 100644
--- a/clippy_lints/src/await_holding_invalid.rs
+++ b/clippy_lints/src/await_holding_invalid.rs
@@ -1,12 +1,15 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::{match_def_path, paths};
+use rustc_data_structures::fx::FxHashMap;
 use rustc_hir::def_id::DefId;
-use rustc_hir::{AsyncGeneratorKind, Body, BodyId, GeneratorKind};
+use rustc_hir::{def::Res, AsyncGeneratorKind, Body, BodyId, GeneratorKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::GeneratorInteriorTypeCause;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::Span;
 
+use crate::utils::conf::DisallowedType;
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for calls to await while holding a non-async-aware MutexGuard.
@@ -127,9 +130,73 @@ declare_clippy_lint! {
     "inside an async function, holding a `RefCell` ref while calling `await`"
 }
 
-declare_lint_pass!(AwaitHolding => [AWAIT_HOLDING_LOCK, AWAIT_HOLDING_REFCELL_REF]);
+declare_clippy_lint! {
+    /// ### What it does
+    /// Allows users to configure types which should not be held across `await`
+    /// suspension points.
+    ///
+    /// ### Why is this bad?
+    /// There are some types which are perfectly "safe" to be used concurrently
+    /// from a memory access perspective but will cause bugs at runtime if they
+    /// are held in such a way.
+    ///
+    /// ### Known problems
+    ///
+    /// ### Example
+    ///
+    /// The `tracing` library has types which should not be held across `await`
+    /// points.
+    ///
+    /// ```toml
+    /// await-holding-invalid-types = [
+    ///   "tracing::span::Entered",
+    ///   "tracing::span::EnteredSpan",
+    /// ]
+    /// ```
+    ///
+    /// ```rust
+    /// # async fn baz() {}
+    /// async fn foo() {
+    ///   let _entered = tracing::info_span!("baz").entered();
+    ///   baz().await;
+    /// }
+    /// ```
+    #[clippy::version = "1.49.0"]
+    pub AWAIT_HOLDING_INVALID_TYPE,
+    suspicious,
+    "inside an async function, holding a type across an await point which is not safe to be held across an await point"
+}
+
+impl_lint_pass!(AwaitHolding => [AWAIT_HOLDING_LOCK, AWAIT_HOLDING_REFCELL_REF, AWAIT_HOLDING_INVALID_TYPE]);
+
+#[derive(Debug)]
+pub struct AwaitHolding {
+    conf_invalid_types: Vec<DisallowedType>,
+    def_ids: FxHashMap<DefId, DisallowedType>,
+}
+
+impl AwaitHolding {
+    pub(crate) fn new(conf_invalid_types: Vec<DisallowedType>) -> Self {
+        Self {
+            conf_invalid_types,
+            def_ids: FxHashMap::default(),
+        }
+    }
+}
 
 impl LateLintPass<'_> for AwaitHolding {
+    fn check_crate(&mut self, cx: &LateContext<'_>) {
+        for conf in &self.conf_invalid_types {
+            let path = match conf {
+                DisallowedType::Simple(path) | DisallowedType::WithReason { path, .. } => path,
+            };
+            let segs: Vec<_> = path.split("::").collect();
+            if let Res::Def(_, id) = clippy_utils::def_path_res(cx, &segs) {
+                self.def_ids.insert(id, conf.clone());
+            }
+        }
+    }
+
     fn check_body(&mut self, cx: &LateContext<'_>, body: &'_ Body<'_>) {
         use AsyncGeneratorKind::{Block, Closure, Fn};
         if let Some(GeneratorKind::Async(Block | Closure | Fn)) = body.generator_kind {
@@ -137,7 +204,7 @@ impl LateLintPass<'_> for AwaitHolding {
                 hir_id: body.value.hir_id,
             };
             let typeck_results = cx.tcx.typeck_body(body_id);
-            check_interior_types(
+            self.check_interior_types(
                 cx,
                 typeck_results.generator_interior_types.as_ref().skip_binder(),
                 body.value.span,
@@ -146,46 +213,68 @@ impl LateLintPass<'_> for AwaitHolding {
     }
 }
 
-fn check_interior_types(cx: &LateContext<'_>, ty_causes: &[GeneratorInteriorTypeCause<'_>], span: Span) {
-    for ty_cause in ty_causes {
-        if let rustc_middle::ty::Adt(adt, _) = ty_cause.ty.kind() {
-            if is_mutex_guard(cx, adt.did()) {
-                span_lint_and_then(
-                    cx,
-                    AWAIT_HOLDING_LOCK,
-                    ty_cause.span,
-                    "this `MutexGuard` is held across an `await` point",
-                    |diag| {
-                        diag.help(
-                            "consider using an async-aware `Mutex` type or ensuring the \
+impl AwaitHolding {
+    fn check_interior_types(&self, cx: &LateContext<'_>, ty_causes: &[GeneratorInteriorTypeCause<'_>], span: Span) {
+        for ty_cause in ty_causes {
+            if let rustc_middle::ty::Adt(adt, _) = ty_cause.ty.kind() {
+                if is_mutex_guard(cx, adt.did()) {
+                    span_lint_and_then(
+                        cx,
+                        AWAIT_HOLDING_LOCK,
+                        ty_cause.span,
+                        "this `MutexGuard` is held across an `await` point",
+                        |diag| {
+                            diag.help(
+                                "consider using an async-aware `Mutex` type or ensuring the \
                                 `MutexGuard` is dropped before calling await",
-                        );
-                        diag.span_note(
-                            ty_cause.scope_span.unwrap_or(span),
-                            "these are all the `await` points this lock is held through",
-                        );
-                    },
-                );
-            }
-            if is_refcell_ref(cx, adt.did()) {
-                span_lint_and_then(
-                    cx,
-                    AWAIT_HOLDING_REFCELL_REF,
-                    ty_cause.span,
-                    "this `RefCell` reference is held across an `await` point",
-                    |diag| {
-                        diag.help("ensure the reference is dropped before calling `await`");
-                        diag.span_note(
-                            ty_cause.scope_span.unwrap_or(span),
-                            "these are all the `await` points this reference is held through",
-                        );
-                    },
-                );
+                            );
+                            diag.span_note(
+                                ty_cause.scope_span.unwrap_or(span),
+                                "these are all the `await` points this lock is held through",
+                            );
+                        },
+                    );
+                } else if is_refcell_ref(cx, adt.did()) {
+                    span_lint_and_then(
+                        cx,
+                        AWAIT_HOLDING_REFCELL_REF,
+                        ty_cause.span,
+                        "this `RefCell` reference is held across an `await` point",
+                        |diag| {
+                            diag.help("ensure the reference is dropped before calling `await`");
+                            diag.span_note(
+                                ty_cause.scope_span.unwrap_or(span),
+                                "these are all the `await` points this reference is held through",
+                            );
+                        },
+                    );
+                } else if let Some(disallowed) = self.def_ids.get(&adt.did()) {
+                    emit_invalid_type(cx, ty_cause.span, disallowed);
+                }
             }
         }
     }
 }
 
+fn emit_invalid_type(cx: &LateContext<'_>, span: Span, disallowed: &DisallowedType) {
+    let (type_name, reason) = match disallowed {
+        DisallowedType::Simple(path) => (path, &None),
+        DisallowedType::WithReason { path, reason } => (path, reason),
+    };
+
+    span_lint_and_then(
+        cx,
+        AWAIT_HOLDING_INVALID_TYPE,
+        span,
+        &format!("`{type_name}` may not be held across an `await` point according to config",),
+        |diag| {
+            if let Some(reason) = reason {
+                diag.note(format!("{reason} (according to clippy.toml)"));
+            }
+        },
+    );
+}
+
 fn is_mutex_guard(cx: &LateContext<'_>, def_id: DefId) -> bool {
     match_def_path(cx, def_id, &paths::MUTEX_GUARD)
         || match_def_path(cx, def_id, &paths::RWLOCK_READ_GUARD)
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 2fa59733365..be57e1038fd 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -14,6 +14,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(attrs::DEPRECATED_SEMVER),
     LintId::of(attrs::MISMATCHED_TARGET_OS),
     LintId::of(attrs::USELESS_ATTRIBUTE),
+    LintId::of(await_holding_invalid::AWAIT_HOLDING_INVALID_TYPE),
     LintId::of(await_holding_invalid::AWAIT_HOLDING_LOCK),
     LintId::of(await_holding_invalid::AWAIT_HOLDING_REFCELL_REF),
     LintId::of(bit_mask::BAD_BIT_MASK),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index c608f634291..8a97233dc5d 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -52,6 +52,7 @@ store.register_lints(&[
     attrs::INLINE_ALWAYS,
     attrs::MISMATCHED_TARGET_OS,
     attrs::USELESS_ATTRIBUTE,
+    await_holding_invalid::AWAIT_HOLDING_INVALID_TYPE,
     await_holding_invalid::AWAIT_HOLDING_LOCK,
     await_holding_invalid::AWAIT_HOLDING_REFCELL_REF,
     bit_mask::BAD_BIT_MASK,
diff --git a/clippy_lints/src/lib.register_suspicious.rs b/clippy_lints/src/lib.register_suspicious.rs
index 82f45b5fd58..7a881bfe399 100644
--- a/clippy_lints/src/lib.register_suspicious.rs
+++ b/clippy_lints/src/lib.register_suspicious.rs
@@ -5,6 +5,7 @@
 store.register_group(true, "clippy::suspicious", Some("clippy_suspicious"), vec![
     LintId::of(assign_ops::MISREFACTORED_ASSIGN_OP),
     LintId::of(attrs::BLANKET_CLIPPY_RESTRICTION_LINTS),
+    LintId::of(await_holding_invalid::AWAIT_HOLDING_INVALID_TYPE),
     LintId::of(await_holding_invalid::AWAIT_HOLDING_LOCK),
     LintId::of(await_holding_invalid::AWAIT_HOLDING_REFCELL_REF),
     LintId::of(casts::CAST_ABS_TO_UNSIGNED),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 88e8a0cc2af..e31f71fe5da 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -515,7 +515,12 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     }
 
     store.register_late_pass(|| Box::new(utils::author::Author));
-    store.register_late_pass(|| Box::new(await_holding_invalid::AwaitHolding));
+    let await_holding_invalid_types = conf.await_holding_invalid_types.clone();
+    store.register_late_pass(move || {
+        Box::new(await_holding_invalid::AwaitHolding::new(
+            await_holding_invalid_types.clone(),
+        ))
+    });
     store.register_late_pass(|| Box::new(serde_api::SerdeApi));
     let vec_box_size_threshold = conf.vec_box_size_threshold;
     let type_complexity_threshold = conf.type_complexity_threshold;
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 271c3a3dd18..e6abe499b43 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -310,6 +310,8 @@ define_Conf! {
     /// the slice pattern that is suggested. If more elements would be necessary, the lint is suppressed.
     /// For example, `[_, _, _, e, ..]` is a slice pattern with 4 elements.
     (max_suggested_slice_pattern_length: u64 = 3),
+    /// Lint: AWAIT_HOLDING_INVALID_TYPE
+    (await_holding_invalid_types: Vec<crate::utils::conf::DisallowedType> = Vec::new()),
 }
 
 /// Search for the configuration file.
diff --git a/tests/compile-test.rs b/tests/compile-test.rs
index c9710e3db8e..f437553bca1 100644
--- a/tests/compile-test.rs
+++ b/tests/compile-test.rs
@@ -35,6 +35,7 @@ static TEST_DEPENDENCIES: &[&str] = &[
     "tokio",
     "parking_lot",
     "rustc_semver",
+    "tracing",
 ];
 
 // Test dependencies may need an `extern crate` here to ensure that they show up
@@ -59,6 +60,9 @@ extern crate rustc_semver;
 extern crate syn;
 #[allow(unused_extern_crates)]
 extern crate tokio;
+#[allow(unused_extern_crates, unused_imports)]
+#[macro_use]
+extern crate tracing;
 
 /// Produces a string with an `--extern` flag for all UI test crate
 /// dependencies.
diff --git a/tests/ui-toml/await_holding_invalid_type/await_holding_invalid_type.rs b/tests/ui-toml/await_holding_invalid_type/await_holding_invalid_type.rs
new file mode 100644
index 00000000000..fbef5c4564b
--- /dev/null
+++ b/tests/ui-toml/await_holding_invalid_type/await_holding_invalid_type.rs
@@ -0,0 +1,41 @@
+#![warn(clippy::await_holding_invalid_type)]
+use std::net::Ipv4Addr;
+
+async fn bad() -> u32 {
+    let _x = String::from("hello");
+    baz().await
+}
+
+async fn bad_reason() -> u32 {
+    let _x = Ipv4Addr::new(127, 0, 0, 1);
+    baz().await
+}
+
+async fn good() -> u32 {
+    {
+        let _x = String::from("hi!");
+        let _y = Ipv4Addr::new(127, 0, 0, 1);
+    }
+    baz().await;
+    let _x = String::from("hi!");
+    47
+}
+
+async fn baz() -> u32 {
+    42
+}
+
+#[allow(clippy::manual_async_fn)]
+fn block_bad() -> impl std::future::Future<Output = u32> {
+    async move {
+        let _x = String::from("hi!");
+        baz().await
+    }
+}
+
+fn main() {
+    good();
+    bad();
+    bad_reason();
+    block_bad();
+}
diff --git a/tests/ui-toml/await_holding_invalid_type/await_holding_invalid_type.stderr b/tests/ui-toml/await_holding_invalid_type/await_holding_invalid_type.stderr
new file mode 100644
index 00000000000..eebdd624d24
--- /dev/null
+++ b/tests/ui-toml/await_holding_invalid_type/await_holding_invalid_type.stderr
@@ -0,0 +1,25 @@
+error: `std::string::String` may not be held across an `await` point according to config
+  --> $DIR/await_holding_invalid_type.rs:5:9
+   |
+LL |     let _x = String::from("hello");
+   |         ^^
+   |
+   = note: `-D clippy::await-holding-invalid-type` implied by `-D warnings`
+   = note: strings are bad (according to clippy.toml)
+
+error: `std::net::Ipv4Addr` may not be held across an `await` point according to config
+  --> $DIR/await_holding_invalid_type.rs:10:9
+   |
+LL |     let _x = Ipv4Addr::new(127, 0, 0, 1);
+   |         ^^
+
+error: `std::string::String` may not be held across an `await` point according to config
+  --> $DIR/await_holding_invalid_type.rs:31:13
+   |
+LL |         let _x = String::from("hi!");
+   |             ^^
+   |
+   = note: strings are bad (according to clippy.toml)
+
+error: aborting due to 3 previous errors
+
diff --git a/tests/ui-toml/await_holding_invalid_type/clippy.toml b/tests/ui-toml/await_holding_invalid_type/clippy.toml
new file mode 100644
index 00000000000..79990096b84
--- /dev/null
+++ b/tests/ui-toml/await_holding_invalid_type/clippy.toml
@@ -0,0 +1,4 @@
+await-holding-invalid-types = [
+    { path = "std::string::String", reason = "strings are bad" },
+    "std::net::Ipv4Addr",
+]
diff --git a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
index 00ddbd608a7..f60afb8d4e3 100644
--- a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
+++ b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
@@ -1,4 +1,4 @@
-error: error reading Clippy's configuration file `$DIR/clippy.toml`: unknown field `foobar`, expected one of `avoid-breaking-exported-api`, `msrv`, `blacklisted-names`, `cognitive-complexity-threshold`, `cyclomatic-complexity-threshold`, `doc-valid-idents`, `too-many-arguments-threshold`, `type-complexity-threshold`, `single-char-binding-names-threshold`, `too-large-for-stack`, `enum-variant-name-threshold`, `enum-variant-size-threshold`, `verbose-bit-mask-threshold`, `literal-representation-threshold`, `trivial-copy-size-limit`, `pass-by-value-size-limit`, `too-many-lines-threshold`, `array-size-threshold`, `vec-box-size-threshold`, `max-trait-bounds`, `max-struct-bools`, `max-fn-params-bools`, `warn-on-all-wildcard-imports`, `disallowed-methods`, `disallowed-types`, `unreadable-literal-lint-fractions`, `upper-case-acronyms-aggressive`, `cargo-ignore-publish`, `standard-macro-braces`, `enforced-import-renames`, `allowed-scripts`, `enable-raw-pointer-heuristic-for-send`, `max-suggested-slice-pattern-length`, `third-party` at line 5 column 1
+error: error reading Clippy's configuration file `$DIR/clippy.toml`: unknown field `foobar`, expected one of `avoid-breaking-exported-api`, `msrv`, `blacklisted-names`, `cognitive-complexity-threshold`, `cyclomatic-complexity-threshold`, `doc-valid-idents`, `too-many-arguments-threshold`, `type-complexity-threshold`, `single-char-binding-names-threshold`, `too-large-for-stack`, `enum-variant-name-threshold`, `enum-variant-size-threshold`, `verbose-bit-mask-threshold`, `literal-representation-threshold`, `trivial-copy-size-limit`, `pass-by-value-size-limit`, `too-many-lines-threshold`, `array-size-threshold`, `vec-box-size-threshold`, `max-trait-bounds`, `max-struct-bools`, `max-fn-params-bools`, `warn-on-all-wildcard-imports`, `disallowed-methods`, `disallowed-types`, `unreadable-literal-lint-fractions`, `upper-case-acronyms-aggressive`, `cargo-ignore-publish`, `standard-macro-braces`, `enforced-import-renames`, `allowed-scripts`, `enable-raw-pointer-heuristic-for-send`, `max-suggested-slice-pattern-length`, `await-holding-invalid-types`, `third-party` at line 5 column 1
 
 error: aborting due to previous error
 
-- 
cgit 1.4.1-3-g733a5


From 534419282e94e618054815e643932f6f39e48000 Mon Sep 17 00:00:00 2001
From: Lily Mara <lilymara@onesignal.com>
Date: Fri, 15 Apr 2022 14:54:19 -0700
Subject: fixup! Add `await_holding_invalid_type` lint

---
 clippy_lints/src/await_holding_invalid.rs | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/await_holding_invalid.rs b/clippy_lints/src/await_holding_invalid.rs
index 36b4f7faa19..51dd5f4937a 100644
--- a/clippy_lints/src/await_holding_invalid.rs
+++ b/clippy_lints/src/await_holding_invalid.rs
@@ -144,21 +144,21 @@ declare_clippy_lint! {
     ///
     /// ### Example
     ///
-    /// The `tracing` library has types which should not be held across `await`
-    /// points.
+    /// Strings are, of course, safe to hold across await points. This example
+    /// exists only to show how this lint might be configured for third-party
+    /// crates.
     ///
     /// ```toml
     /// await-holding-invalid-types = [
-    ///   "tracing::span::Entered",
-    ///   "tracing::span::EnteredSpan",
+    ///   "std::string::String",
     /// ]
     /// ```
     ///
     /// ```rust
     /// # async fn baz() {}
     /// async fn foo() {
-    ///   let _entered = tracing::info_span!("baz").entered();
-    ///   baz().await;
+    ///   let _x = String::from("hello!");
+    ///   baz().await; // Lint violation
     /// }
     /// ```
     #[clippy::version = "1.49.0"]
-- 
cgit 1.4.1-3-g733a5


From ccedc64e3abc53795106d2fba027f59c06905eb4 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Fri, 15 Apr 2022 11:37:58 +0200
Subject: Add `#[clippy::print_hir]` attribute for debugging

---
 clippy_lints/src/lib.rs                            |   2 +-
 clippy_lints/src/utils/dump_hir.rs                 |  55 ++
 clippy_lints/src/utils/inspector.rs                | 555 ---------------------
 .../src/utils/internal_lints/metadata_collector.rs |   2 +-
 clippy_lints/src/utils/mod.rs                      |   2 +-
 doc/adding_lints.md                                |  14 +
 6 files changed, 72 insertions(+), 558 deletions(-)
 create mode 100644 clippy_lints/src/utils/dump_hir.rs
 delete mode 100644 clippy_lints/src/utils/inspector.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 604bd44c6c5..c5d02ca278e 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -501,7 +501,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     {
         store.register_early_pass(|| Box::new(utils::internal_lints::ClippyLintsInternal));
         store.register_early_pass(|| Box::new(utils::internal_lints::ProduceIce));
-        store.register_late_pass(|| Box::new(utils::inspector::DeepCodeInspector));
         store.register_late_pass(|| Box::new(utils::internal_lints::CollapsibleCalls));
         store.register_late_pass(|| Box::new(utils::internal_lints::CompilerLintFunctions::new()));
         store.register_late_pass(|| Box::new(utils::internal_lints::IfChainStyle));
@@ -513,6 +512,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         store.register_late_pass(|| Box::new(utils::internal_lints::MsrvAttrImpl));
     }
 
+    store.register_late_pass(|| Box::new(utils::dump_hir::DumpHir));
     store.register_late_pass(|| Box::new(utils::author::Author));
     store.register_late_pass(|| Box::new(await_holding_invalid::AwaitHolding));
     store.register_late_pass(|| Box::new(serde_api::SerdeApi));
diff --git a/clippy_lints/src/utils/dump_hir.rs b/clippy_lints/src/utils/dump_hir.rs
new file mode 100644
index 00000000000..01efc527a8c
--- /dev/null
+++ b/clippy_lints/src/utils/dump_hir.rs
@@ -0,0 +1,55 @@
+use clippy_utils::get_attr;
+use rustc_hir as hir;
+use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// It formats the attached node with `{:#?}` and writes the result to the
+    /// standard output. This is intended for debugging.
+    ///
+    /// ### Examples
+    /// ```rs
+    /// #[clippy::dump]
+    /// use std::mem;
+    ///
+    /// #[clippy::dump]
+    /// fn foo(input: u32) -> u64 {
+    ///     input as u64
+    /// }
+    /// ```
+    pub DUMP_HIR,
+    internal_warn,
+    "helper to dump info about code"
+}
+
+declare_lint_pass!(DumpHir => [DUMP_HIR]);
+
+impl<'tcx> LateLintPass<'tcx> for DumpHir {
+    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) {
+        if has_attr(cx, item.hir_id()) {
+            println!("{item:#?}");
+        }
+    }
+
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
+        if has_attr(cx, expr.hir_id) {
+            println!("{expr:#?}");
+        }
+    }
+
+    fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx hir::Stmt<'_>) {
+        match stmt.kind {
+            hir::StmtKind::Expr(e) | hir::StmtKind::Semi(e) if has_attr(cx, e.hir_id) => return,
+            _ => {},
+        }
+        if has_attr(cx, stmt.hir_id) {
+            println!("{stmt:#?}");
+        }
+    }
+}
+
+fn has_attr(cx: &LateContext<'_>, hir_id: hir::HirId) -> bool {
+    let attrs = cx.tcx.hir().attrs(hir_id);
+    get_attr(cx.sess(), attrs, "dump").count() > 0
+}
diff --git a/clippy_lints/src/utils/inspector.rs b/clippy_lints/src/utils/inspector.rs
deleted file mode 100644
index dc48ea3f4f9..00000000000
--- a/clippy_lints/src/utils/inspector.rs
+++ /dev/null
@@ -1,555 +0,0 @@
-//! checks for attributes
-
-use clippy_utils::get_attr;
-use rustc_ast::ast::{Attribute, InlineAsmTemplatePiece};
-use rustc_hir as hir;
-use rustc_lint::{LateContext, LateLintPass, LintContext};
-use rustc_session::Session;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Dumps every ast/hir node which has the `#[clippy::dump]`
-    /// attribute
-    ///
-    /// ### Example
-    /// ```rust,ignore
-    /// #[clippy::dump]
-    /// extern crate foo;
-    /// ```
-    ///
-    /// prints
-    ///
-    /// ```text
-    /// item `foo`
-    /// visibility inherited from outer item
-    /// extern crate dylib source: "/path/to/foo.so"
-    /// ```
-    pub DEEP_CODE_INSPECTION,
-    internal_warn,
-    "helper to dump info about code"
-}
-
-declare_lint_pass!(DeepCodeInspector => [DEEP_CODE_INSPECTION]);
-
-impl<'tcx> LateLintPass<'tcx> for DeepCodeInspector {
-    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) {
-        if !has_attr(cx.sess(), cx.tcx.hir().attrs(item.hir_id())) {
-            return;
-        }
-        print_item(cx, item);
-    }
-
-    fn check_impl_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::ImplItem<'_>) {
-        if !has_attr(cx.sess(), cx.tcx.hir().attrs(item.hir_id())) {
-            return;
-        }
-        println!("impl item `{}`", item.ident.name);
-        match item.vis.node {
-            hir::VisibilityKind::Public => println!("public"),
-            hir::VisibilityKind::Crate(_) => println!("visible crate wide"),
-            hir::VisibilityKind::Restricted { path, .. } => println!(
-                "visible in module `{}`",
-                rustc_hir_pretty::to_string(rustc_hir_pretty::NO_ANN, |s| s.print_path(path, false))
-            ),
-            hir::VisibilityKind::Inherited => println!("visibility inherited from outer item"),
-        }
-        match item.kind {
-            hir::ImplItemKind::Const(_, body_id) => {
-                println!("associated constant");
-                print_expr(cx, &cx.tcx.hir().body(body_id).value, 1);
-            },
-            hir::ImplItemKind::Fn(..) => println!("method"),
-            hir::ImplItemKind::TyAlias(_) => println!("associated type"),
-        }
-    }
-
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
-        if !has_attr(cx.sess(), cx.tcx.hir().attrs(expr.hir_id)) {
-            return;
-        }
-        print_expr(cx, expr, 0);
-    }
-
-    fn check_arm(&mut self, cx: &LateContext<'tcx>, arm: &'tcx hir::Arm<'_>) {
-        if !has_attr(cx.sess(), cx.tcx.hir().attrs(arm.hir_id)) {
-            return;
-        }
-        print_pat(cx, arm.pat, 1);
-        if let Some(ref guard) = arm.guard {
-            println!("guard:");
-            print_guard(cx, guard, 1);
-        }
-        println!("body:");
-        print_expr(cx, arm.body, 1);
-    }
-
-    fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx hir::Stmt<'_>) {
-        if !has_attr(cx.sess(), cx.tcx.hir().attrs(stmt.hir_id)) {
-            return;
-        }
-        match stmt.kind {
-            hir::StmtKind::Local(local) => {
-                println!("local variable of type {}", cx.typeck_results().node_type(local.hir_id));
-                println!("pattern:");
-                print_pat(cx, local.pat, 0);
-                if let Some(e) = local.init {
-                    println!("init expression:");
-                    print_expr(cx, e, 0);
-                }
-            },
-            hir::StmtKind::Item(_) => println!("item decl"),
-            hir::StmtKind::Expr(e) | hir::StmtKind::Semi(e) => print_expr(cx, e, 0),
-        }
-    }
-}
-
-fn has_attr(sess: &Session, attrs: &[Attribute]) -> bool {
-    get_attr(sess, attrs, "dump").count() > 0
-}
-
-#[allow(clippy::similar_names)]
-#[allow(clippy::too_many_lines)]
-fn print_expr(cx: &LateContext<'_>, expr: &hir::Expr<'_>, indent: usize) {
-    let ind = "  ".repeat(indent);
-    println!("{}+", ind);
-    println!("{}ty: {}", ind, cx.typeck_results().expr_ty(expr));
-    println!(
-        "{}adjustments: {:?}",
-        ind,
-        cx.typeck_results().adjustments().get(expr.hir_id)
-    );
-    match expr.kind {
-        hir::ExprKind::Box(e) => {
-            println!("{}Box", ind);
-            print_expr(cx, e, indent + 1);
-        },
-        hir::ExprKind::Array(v) => {
-            println!("{}Array", ind);
-            for e in v {
-                print_expr(cx, e, indent + 1);
-            }
-        },
-        hir::ExprKind::Call(func, args) => {
-            println!("{}Call", ind);
-            println!("{}function:", ind);
-            print_expr(cx, func, indent + 1);
-            println!("{}arguments:", ind);
-            for arg in args {
-                print_expr(cx, arg, indent + 1);
-            }
-        },
-        hir::ExprKind::Let(hir::Let { pat, init, ty, .. }) => {
-            print_pat(cx, pat, indent + 1);
-            if let Some(ty) = ty {
-                println!("{}  type annotation: {:?}", ind, ty);
-            }
-            print_expr(cx, init, indent + 1);
-        },
-        hir::ExprKind::MethodCall(path, args, _) => {
-            println!("{}MethodCall", ind);
-            println!("{}method name: {}", ind, path.ident.name);
-            for arg in args {
-                print_expr(cx, arg, indent + 1);
-            }
-        },
-        hir::ExprKind::Tup(v) => {
-            println!("{}Tup", ind);
-            for e in v {
-                print_expr(cx, e, indent + 1);
-            }
-        },
-        hir::ExprKind::Binary(op, lhs, rhs) => {
-            println!("{}Binary", ind);
-            println!("{}op: {:?}", ind, op.node);
-            println!("{}lhs:", ind);
-            print_expr(cx, lhs, indent + 1);
-            println!("{}rhs:", ind);
-            print_expr(cx, rhs, indent + 1);
-        },
-        hir::ExprKind::Unary(op, inner) => {
-            println!("{}Unary", ind);
-            println!("{}op: {:?}", ind, op);
-            print_expr(cx, inner, indent + 1);
-        },
-        hir::ExprKind::Lit(ref lit) => {
-            println!("{}Lit", ind);
-            println!("{}{:?}", ind, lit);
-        },
-        hir::ExprKind::Cast(e, target) => {
-            println!("{}Cast", ind);
-            print_expr(cx, e, indent + 1);
-            println!("{}target type: {:?}", ind, target);
-        },
-        hir::ExprKind::Type(e, target) => {
-            println!("{}Type", ind);
-            print_expr(cx, e, indent + 1);
-            println!("{}target type: {:?}", ind, target);
-        },
-        hir::ExprKind::Loop(..) => {
-            println!("{}Loop", ind);
-        },
-        hir::ExprKind::If(cond, _, ref else_opt) => {
-            println!("{}If", ind);
-            println!("{}condition:", ind);
-            print_expr(cx, cond, indent + 1);
-            if let Some(els) = *else_opt {
-                println!("{}else:", ind);
-                print_expr(cx, els, indent + 1);
-            }
-        },
-        hir::ExprKind::Match(cond, _, ref source) => {
-            println!("{}Match", ind);
-            println!("{}condition:", ind);
-            print_expr(cx, cond, indent + 1);
-            println!("{}source: {:?}", ind, source);
-        },
-        hir::ExprKind::Closure(ref clause, _, _, _, _) => {
-            println!("{}Closure", ind);
-            println!("{}clause: {:?}", ind, clause);
-        },
-        hir::ExprKind::Yield(sub, _) => {
-            println!("{}Yield", ind);
-            print_expr(cx, sub, indent + 1);
-        },
-        hir::ExprKind::Block(_, _) => {
-            println!("{}Block", ind);
-        },
-        hir::ExprKind::Assign(lhs, rhs, _) => {
-            println!("{}Assign", ind);
-            println!("{}lhs:", ind);
-            print_expr(cx, lhs, indent + 1);
-            println!("{}rhs:", ind);
-            print_expr(cx, rhs, indent + 1);
-        },
-        hir::ExprKind::AssignOp(ref binop, lhs, rhs) => {
-            println!("{}AssignOp", ind);
-            println!("{}op: {:?}", ind, binop.node);
-            println!("{}lhs:", ind);
-            print_expr(cx, lhs, indent + 1);
-            println!("{}rhs:", ind);
-            print_expr(cx, rhs, indent + 1);
-        },
-        hir::ExprKind::Field(e, ident) => {
-            println!("{}Field", ind);
-            println!("{}field name: {}", ind, ident.name);
-            println!("{}struct expr:", ind);
-            print_expr(cx, e, indent + 1);
-        },
-        hir::ExprKind::Index(arr, idx) => {
-            println!("{}Index", ind);
-            println!("{}array expr:", ind);
-            print_expr(cx, arr, indent + 1);
-            println!("{}index expr:", ind);
-            print_expr(cx, idx, indent + 1);
-        },
-        hir::ExprKind::Path(hir::QPath::Resolved(ref ty, path)) => {
-            println!("{}Resolved Path, {:?}", ind, ty);
-            println!("{}path: {:?}", ind, path);
-        },
-        hir::ExprKind::Path(hir::QPath::TypeRelative(ty, seg)) => {
-            println!("{}Relative Path, {:?}", ind, ty);
-            println!("{}seg: {:?}", ind, seg);
-        },
-        hir::ExprKind::Path(hir::QPath::LangItem(lang_item, ..)) => {
-            println!("{}Lang Item Path, {:?}", ind, lang_item.name());
-        },
-        hir::ExprKind::AddrOf(kind, ref muta, e) => {
-            println!("{}AddrOf", ind);
-            println!("kind: {:?}", kind);
-            println!("mutability: {:?}", muta);
-            print_expr(cx, e, indent + 1);
-        },
-        hir::ExprKind::Break(_, ref e) => {
-            println!("{}Break", ind);
-            if let Some(e) = *e {
-                print_expr(cx, e, indent + 1);
-            }
-        },
-        hir::ExprKind::Continue(_) => println!("{}Again", ind),
-        hir::ExprKind::Ret(ref e) => {
-            println!("{}Ret", ind);
-            if let Some(e) = *e {
-                print_expr(cx, e, indent + 1);
-            }
-        },
-        hir::ExprKind::InlineAsm(asm) => {
-            println!("{}InlineAsm", ind);
-            println!("{}template: {}", ind, InlineAsmTemplatePiece::to_string(asm.template));
-            println!("{}options: {:?}", ind, asm.options);
-            println!("{}operands:", ind);
-            for (op, _op_sp) in asm.operands {
-                match op {
-                    hir::InlineAsmOperand::In { expr, .. }
-                    | hir::InlineAsmOperand::InOut { expr, .. }
-                    | hir::InlineAsmOperand::Sym { expr } => print_expr(cx, expr, indent + 1),
-                    hir::InlineAsmOperand::Out { expr, .. } => {
-                        if let Some(expr) = expr {
-                            print_expr(cx, expr, indent + 1);
-                        }
-                    },
-                    hir::InlineAsmOperand::SplitInOut { in_expr, out_expr, .. } => {
-                        print_expr(cx, in_expr, indent + 1);
-                        if let Some(out_expr) = out_expr {
-                            print_expr(cx, out_expr, indent + 1);
-                        }
-                    },
-                    hir::InlineAsmOperand::Const { anon_const } => {
-                        println!("{}anon_const:", ind);
-                        print_expr(cx, &cx.tcx.hir().body(anon_const.body).value, indent + 1);
-                    },
-                }
-            }
-        },
-        hir::ExprKind::Struct(path, fields, ref base) => {
-            println!("{}Struct", ind);
-            println!("{}path: {:?}", ind, path);
-            for field in fields {
-                println!("{}field \"{}\":", ind, field.ident.name);
-                print_expr(cx, field.expr, indent + 1);
-            }
-            if let Some(base) = *base {
-                println!("{}base:", ind);
-                print_expr(cx, base, indent + 1);
-            }
-        },
-        hir::ExprKind::ConstBlock(ref anon_const) => {
-            println!("{}ConstBlock", ind);
-            println!("{}anon_const:", ind);
-            print_expr(cx, &cx.tcx.hir().body(anon_const.body).value, indent + 1);
-        },
-        hir::ExprKind::Repeat(val, length) => {
-            println!("{}Repeat", ind);
-            println!("{}value:", ind);
-            print_expr(cx, val, indent + 1);
-            println!("{}repeat count:", ind);
-            match length {
-                hir::ArrayLen::Infer(_, _) => println!("{}repeat count: _", ind),
-                hir::ArrayLen::Body(anon_const) => {
-                    print_expr(cx, &cx.tcx.hir().body(anon_const.body).value, indent + 1);
-                },
-            }
-        },
-        hir::ExprKind::Err => {
-            println!("{}Err", ind);
-        },
-        hir::ExprKind::DropTemps(e) => {
-            println!("{}DropTemps", ind);
-            print_expr(cx, e, indent + 1);
-        },
-    }
-}
-
-fn print_item(cx: &LateContext<'_>, item: &hir::Item<'_>) {
-    let did = item.def_id;
-    println!("item `{}`", item.ident.name);
-    match item.vis.node {
-        hir::VisibilityKind::Public => println!("public"),
-        hir::VisibilityKind::Crate(_) => println!("visible crate wide"),
-        hir::VisibilityKind::Restricted { path, .. } => println!(
-            "visible in module `{}`",
-            rustc_hir_pretty::to_string(rustc_hir_pretty::NO_ANN, |s| s.print_path(path, false))
-        ),
-        hir::VisibilityKind::Inherited => println!("visibility inherited from outer item"),
-    }
-    match item.kind {
-        hir::ItemKind::ExternCrate(ref _renamed_from) => {
-            if let Some(crate_id) = cx.tcx.extern_mod_stmt_cnum(did) {
-                let source = cx.tcx.used_crate_source(crate_id);
-                if let Some(ref src) = source.dylib {
-                    println!("extern crate dylib source: {:?}", src.0);
-                }
-                if let Some(ref src) = source.rlib {
-                    println!("extern crate rlib source: {:?}", src.0);
-                }
-            } else {
-                println!("weird extern crate without a crate id");
-            }
-        },
-        hir::ItemKind::Use(path, ref kind) => println!("{:?}, {:?}", path, kind),
-        hir::ItemKind::Static(..) => println!("static item of type {:#?}", cx.tcx.type_of(did)),
-        hir::ItemKind::Const(..) => println!("const item of type {:#?}", cx.tcx.type_of(did)),
-        hir::ItemKind::Fn(..) => {
-            let item_ty = cx.tcx.type_of(did);
-            println!("function of type {:#?}", item_ty);
-        },
-        hir::ItemKind::Macro(ref macro_def, _) => {
-            if macro_def.macro_rules {
-                println!("macro introduced by `macro_rules!`");
-            } else {
-                println!("macro introduced by `macro`");
-            }
-        },
-        hir::ItemKind::Mod(..) => println!("module"),
-        hir::ItemKind::ForeignMod { abi, .. } => println!("foreign module with abi: {}", abi),
-        hir::ItemKind::GlobalAsm(asm) => println!("global asm: {:?}", asm),
-        hir::ItemKind::TyAlias(..) => {
-            println!("type alias for {:?}", cx.tcx.type_of(did));
-        },
-        hir::ItemKind::OpaqueTy(..) => {
-            println!("existential type with real type {:?}", cx.tcx.type_of(did));
-        },
-        hir::ItemKind::Enum(..) => {
-            println!("enum definition of type {:?}", cx.tcx.type_of(did));
-        },
-        hir::ItemKind::Struct(..) => {
-            println!("struct definition of type {:?}", cx.tcx.type_of(did));
-        },
-        hir::ItemKind::Union(..) => {
-            println!("union definition of type {:?}", cx.tcx.type_of(did));
-        },
-        hir::ItemKind::Trait(..) => {
-            println!("trait decl");
-            if cx.tcx.trait_is_auto(did.to_def_id()) {
-                println!("trait is auto");
-            } else {
-                println!("trait is not auto");
-            }
-        },
-        hir::ItemKind::TraitAlias(..) => {
-            println!("trait alias");
-        },
-        hir::ItemKind::Impl(hir::Impl {
-            of_trait: Some(ref _trait_ref),
-            ..
-        }) => {
-            println!("trait impl");
-        },
-        hir::ItemKind::Impl(hir::Impl { of_trait: None, .. }) => {
-            println!("impl");
-        },
-    }
-}
-
-#[allow(clippy::similar_names)]
-#[allow(clippy::too_many_lines)]
-fn print_pat(cx: &LateContext<'_>, pat: &hir::Pat<'_>, indent: usize) {
-    let ind = "  ".repeat(indent);
-    println!("{}+", ind);
-    match pat.kind {
-        hir::PatKind::Wild => println!("{}Wild", ind),
-        hir::PatKind::Binding(ref mode, .., ident, ref inner) => {
-            println!("{}Binding", ind);
-            println!("{}mode: {:?}", ind, mode);
-            println!("{}name: {}", ind, ident.name);
-            if let Some(inner) = *inner {
-                println!("{}inner:", ind);
-                print_pat(cx, inner, indent + 1);
-            }
-        },
-        hir::PatKind::Or(fields) => {
-            println!("{}Or", ind);
-            for field in fields {
-                print_pat(cx, field, indent + 1);
-            }
-        },
-        hir::PatKind::Struct(ref path, fields, ignore) => {
-            println!("{}Struct", ind);
-            println!(
-                "{}name: {}",
-                ind,
-                rustc_hir_pretty::to_string(rustc_hir_pretty::NO_ANN, |s| s.print_qpath(path, false))
-            );
-            println!("{}ignore leftover fields: {}", ind, ignore);
-            println!("{}fields:", ind);
-            for field in fields {
-                println!("{}  field name: {}", ind, field.ident.name);
-                if field.is_shorthand {
-                    println!("{}  in shorthand notation", ind);
-                }
-                print_pat(cx, field.pat, indent + 1);
-            }
-        },
-        hir::PatKind::TupleStruct(ref path, fields, opt_dots_position) => {
-            println!("{}TupleStruct", ind);
-            println!(
-                "{}path: {}",
-                ind,
-                rustc_hir_pretty::to_string(rustc_hir_pretty::NO_ANN, |s| s.print_qpath(path, false))
-            );
-            if let Some(dot_position) = opt_dots_position {
-                println!("{}dot position: {}", ind, dot_position);
-            }
-            for field in fields {
-                print_pat(cx, field, indent + 1);
-            }
-        },
-        hir::PatKind::Path(hir::QPath::Resolved(ref ty, path)) => {
-            println!("{}Resolved Path, {:?}", ind, ty);
-            println!("{}path: {:?}", ind, path);
-        },
-        hir::PatKind::Path(hir::QPath::TypeRelative(ty, seg)) => {
-            println!("{}Relative Path, {:?}", ind, ty);
-            println!("{}seg: {:?}", ind, seg);
-        },
-        hir::PatKind::Path(hir::QPath::LangItem(lang_item, ..)) => {
-            println!("{}Lang Item Path, {:?}", ind, lang_item.name());
-        },
-        hir::PatKind::Tuple(pats, opt_dots_position) => {
-            println!("{}Tuple", ind);
-            if let Some(dot_position) = opt_dots_position {
-                println!("{}dot position: {}", ind, dot_position);
-            }
-            for field in pats {
-                print_pat(cx, field, indent + 1);
-            }
-        },
-        hir::PatKind::Box(inner) => {
-            println!("{}Box", ind);
-            print_pat(cx, inner, indent + 1);
-        },
-        hir::PatKind::Ref(inner, ref muta) => {
-            println!("{}Ref", ind);
-            println!("{}mutability: {:?}", ind, muta);
-            print_pat(cx, inner, indent + 1);
-        },
-        hir::PatKind::Lit(e) => {
-            println!("{}Lit", ind);
-            print_expr(cx, e, indent + 1);
-        },
-        hir::PatKind::Range(ref l, ref r, ref range_end) => {
-            println!("{}Range", ind);
-            if let Some(expr) = l {
-                print_expr(cx, expr, indent + 1);
-            }
-            if let Some(expr) = r {
-                print_expr(cx, expr, indent + 1);
-            }
-            match *range_end {
-                hir::RangeEnd::Included => println!("{} end included", ind),
-                hir::RangeEnd::Excluded => println!("{} end excluded", ind),
-            }
-        },
-        hir::PatKind::Slice(first_pats, ref range, last_pats) => {
-            println!("{}Slice [a, b, ..i, y, z]", ind);
-            println!("[a, b]:");
-            for pat in first_pats {
-                print_pat(cx, pat, indent + 1);
-            }
-            println!("i:");
-            if let Some(pat) = *range {
-                print_pat(cx, pat, indent + 1);
-            }
-            println!("[y, z]:");
-            for pat in last_pats {
-                print_pat(cx, pat, indent + 1);
-            }
-        },
-    }
-}
-
-fn print_guard(cx: &LateContext<'_>, guard: &hir::Guard<'_>, indent: usize) {
-    let ind = "  ".repeat(indent);
-    println!("{}+", ind);
-    match guard {
-        hir::Guard::If(expr) => {
-            println!("{}If", ind);
-            print_expr(cx, expr, indent + 1);
-        },
-        hir::Guard::IfLet(pat, expr) => {
-            println!("{}IfLet", ind);
-            print_pat(cx, pat, indent + 1);
-            print_expr(cx, expr, indent + 1);
-        },
-    }
-}
diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index ca03b8010dd..9c75f786479 100644
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -33,7 +33,7 @@ use std::path::Path;
 /// This is the output file of the lint collector.
 const OUTPUT_FILE: &str = "../util/gh-pages/lints.json";
 /// These lints are excluded from the export.
-const BLACK_LISTED_LINTS: [&str; 3] = ["lint_author", "deep_code_inspection", "internal_metadata_collector"];
+const BLACK_LISTED_LINTS: &[&str] = &["lint_author", "dump_hir", "internal_metadata_collector"];
 /// These groups will be ignored by the lint group matcher. This is useful for collections like
 /// `clippy::all`
 const IGNORED_LINT_GROUPS: [&str; 1] = ["clippy::all"];
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index dc385ebacba..787e9fd982c 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -1,5 +1,5 @@
 pub mod author;
 pub mod conf;
-pub mod inspector;
+pub mod dump_hir;
 #[cfg(feature = "internal")]
 pub mod internal_lints;
diff --git a/doc/adding_lints.md b/doc/adding_lints.md
index cf16a1d5d3d..307cf2f3a90 100644
--- a/doc/adding_lints.md
+++ b/doc/adding_lints.md
@@ -22,6 +22,7 @@ because that's clearly a non-descriptive name.
   - [Adding the lint logic](#adding-the-lint-logic)
   - [Specifying the lint's minimum supported Rust version (MSRV)](#specifying-the-lints-minimum-supported-rust-version-msrv)
   - [Author lint](#author-lint)
+  - [Print HIR lint](#print-hir-lint)
   - [Documentation](#documentation)
   - [Running rustfmt](#running-rustfmt)
   - [Debugging](#debugging)
@@ -484,6 +485,19 @@ you are implementing your lint.
 
 [author_example]: https://play.rust-lang.org/?version=nightly&mode=debug&edition=2018&gist=9a12cb60e5c6ad4e3003ac6d5e63cf55
 
+## Print HIR lint
+
+To implement a lint, it's helpful to first understand the internal representation
+that rustc uses. Clippy has the `#[clippy::dump]` attribute that prints the
+[_High-Level Intermediate Representation (HIR)_] of the item, statement, or 
+expression that the attribute is attached to. To attach the attribute to expressions
+you often need to enable `#![feature(stmt_expr_attributes)]`.
+
+[Here][print_hir_example] you can find an example, just select _Tools_ and run _Clippy_.
+
+[_High-Level Intermediate Representation (HIR)_]: https://rustc-dev-guide.rust-lang.org/hir.html
+[print_hir_example]: https://play.rust-lang.org/?version=nightly&mode=debug&edition=2021&gist=daf14db3a7f39ca467cd1b86c34b9afb
+
 ## Documentation
 
 The final thing before submitting our PR is to add some documentation to our
-- 
cgit 1.4.1-3-g733a5


From b94e24e95feaab72c622da3af48eff60ef85ec25 Mon Sep 17 00:00:00 2001
From: Jeong YunWon <jeong@youknowone.org>
Date: Fri, 15 Apr 2022 19:33:24 +0900
Subject: Fix needless_match false positive for if-let

when the else block doesn't match to given expr
---
 clippy_lints/src/matches/needless_match.rs |  2 +-
 tests/ui/needless_match.fixed              | 12 ++++++++++++
 tests/ui/needless_match.rs                 | 12 ++++++++++++
 tests/ui/needless_match.stderr             |  8 ++++----
 4 files changed, 29 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/needless_match.rs b/clippy_lints/src/matches/needless_match.rs
index 0abe6ddda65..f920ad4651f 100644
--- a/clippy_lints/src/matches/needless_match.rs
+++ b/clippy_lints/src/matches/needless_match.rs
@@ -99,7 +99,7 @@ fn check_if_let(cx: &LateContext<'_>, if_let: &higher::IfLet<'_>) -> bool {
                 if let ExprKind::Path(ref qpath) = ret.kind {
                     return is_lang_ctor(cx, qpath, OptionNone) || eq_expr_value(cx, if_let.let_expr, ret);
                 }
-                return true;
+                return false;
             }
             return eq_expr_value(cx, if_let.let_expr, ret);
         }
diff --git a/tests/ui/needless_match.fixed b/tests/ui/needless_match.fixed
index 9ccccaa1725..b997e5316cf 100644
--- a/tests/ui/needless_match.fixed
+++ b/tests/ui/needless_match.fixed
@@ -80,6 +80,18 @@ fn if_let_option() {
     } else {
         None
     };
+
+    // Don't trigger
+    let _ = if let Some(a) = Some(1) { Some(a) } else { Some(2) };
+}
+
+fn if_let_option_result() -> Result<(), ()> {
+    fn f(x: i32) -> Result<Option<i32>, ()> {
+        Ok(Some(x))
+    }
+    // Don't trigger
+    let _ = if let Some(v) = f(1)? { Some(v) } else { f(2)? };
+    Ok(())
 }
 
 fn if_let_result() {
diff --git a/tests/ui/needless_match.rs b/tests/ui/needless_match.rs
index d210ecff7f1..90482775a1e 100644
--- a/tests/ui/needless_match.rs
+++ b/tests/ui/needless_match.rs
@@ -103,6 +103,18 @@ fn if_let_option() {
     } else {
         None
     };
+
+    // Don't trigger
+    let _ = if let Some(a) = Some(1) { Some(a) } else { Some(2) };
+}
+
+fn if_let_option_result() -> Result<(), ()> {
+    fn f(x: i32) -> Result<Option<i32>, ()> {
+        Ok(Some(x))
+    }
+    // Don't trigger
+    let _ = if let Some(v) = f(1)? { Some(v) } else { f(2)? };
+    Ok(())
 }
 
 fn if_let_result() {
diff --git a/tests/ui/needless_match.stderr b/tests/ui/needless_match.stderr
index 34c5226f060..2d679631c6f 100644
--- a/tests/ui/needless_match.stderr
+++ b/tests/ui/needless_match.stderr
@@ -72,19 +72,19 @@ LL |     let _ = if let Some(a) = Some(1) { Some(a) } else { None };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `Some(1)`
 
 error: this if-let expression is unnecessary
-  --> $DIR/needless_match.rs:110:31
+  --> $DIR/needless_match.rs:122:31
    |
 LL |     let _: Result<i32, i32> = if let Err(e) = x { Err(e) } else { x };
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `x`
 
 error: this if-let expression is unnecessary
-  --> $DIR/needless_match.rs:111:31
+  --> $DIR/needless_match.rs:123:31
    |
 LL |     let _: Result<i32, i32> = if let Ok(val) = x { Ok(val) } else { x };
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `x`
 
 error: this if-let expression is unnecessary
-  --> $DIR/needless_match.rs:117:21
+  --> $DIR/needless_match.rs:129:21
    |
 LL |       let _: Simple = if let Simple::A = x {
    |  _____________________^
@@ -97,7 +97,7 @@ LL | |     };
    | |_____^ help: replace it with: `x`
 
 error: this match expression is unnecessary
-  --> $DIR/needless_match.rs:156:26
+  --> $DIR/needless_match.rs:168:26
    |
 LL |           let _: Complex = match ce {
    |  __________________________^
-- 
cgit 1.4.1-3-g733a5


From 7a4d07105f58fdee2ee1d72826bfaa177b07fdb2 Mon Sep 17 00:00:00 2001
From: bing <tanbinghwang@gmail.com>
Date: Mon, 18 Apr 2022 14:42:24 +0800
Subject: Less authoritative stable_sort_primitive message

---
 clippy_lints/src/stable_sort_primitive.rs |  4 ++--
 tests/ui/stable_sort_primitive.stderr     | 14 +++++++-------
 2 files changed, 9 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/stable_sort_primitive.rs b/clippy_lints/src/stable_sort_primitive.rs
index bcd28b42978..a285323dc6e 100644
--- a/clippy_lints/src/stable_sort_primitive.rs
+++ b/clippy_lints/src/stable_sort_primitive.rs
@@ -30,7 +30,7 @@ declare_clippy_lint! {
     /// ```
     #[clippy::version = "1.47.0"]
     pub STABLE_SORT_PRIMITIVE,
-    perf,
+    pedantic,
     "use of sort() when sort_unstable() is equivalent"
 }
 
@@ -126,7 +126,7 @@ impl LateLintPass<'_> for StableSortPrimitive {
                         Applicability::MachineApplicable,
                     );
                     diag.note(
-                        "an unstable sort would perform faster without any observable difference for this data type",
+                        "an unstable sort typically performs faster without any observable difference for this data type",
                     );
                 },
             );
diff --git a/tests/ui/stable_sort_primitive.stderr b/tests/ui/stable_sort_primitive.stderr
index b8d22ed2504..c35e0c22ae8 100644
--- a/tests/ui/stable_sort_primitive.stderr
+++ b/tests/ui/stable_sort_primitive.stderr
@@ -5,7 +5,7 @@ LL |     vec.sort();
    |     ^^^^^^^^^^ help: try: `vec.sort_unstable()`
    |
    = note: `-D clippy::stable-sort-primitive` implied by `-D warnings`
-   = note: an unstable sort would perform faster without any observable difference for this data type
+   = note: an unstable sort typically performs faster without any observable difference for this data type
 
 error: used `sort` on primitive type `bool`
   --> $DIR/stable_sort_primitive.rs:9:5
@@ -13,7 +13,7 @@ error: used `sort` on primitive type `bool`
 LL |     vec.sort();
    |     ^^^^^^^^^^ help: try: `vec.sort_unstable()`
    |
-   = note: an unstable sort would perform faster without any observable difference for this data type
+   = note: an unstable sort typically performs faster without any observable difference for this data type
 
 error: used `sort` on primitive type `char`
   --> $DIR/stable_sort_primitive.rs:11:5
@@ -21,7 +21,7 @@ error: used `sort` on primitive type `char`
 LL |     vec.sort();
    |     ^^^^^^^^^^ help: try: `vec.sort_unstable()`
    |
-   = note: an unstable sort would perform faster without any observable difference for this data type
+   = note: an unstable sort typically performs faster without any observable difference for this data type
 
 error: used `sort` on primitive type `str`
   --> $DIR/stable_sort_primitive.rs:13:5
@@ -29,7 +29,7 @@ error: used `sort` on primitive type `str`
 LL |     vec.sort();
    |     ^^^^^^^^^^ help: try: `vec.sort_unstable()`
    |
-   = note: an unstable sort would perform faster without any observable difference for this data type
+   = note: an unstable sort typically performs faster without any observable difference for this data type
 
 error: used `sort` on primitive type `tuple`
   --> $DIR/stable_sort_primitive.rs:15:5
@@ -37,7 +37,7 @@ error: used `sort` on primitive type `tuple`
 LL |     vec.sort();
    |     ^^^^^^^^^^ help: try: `vec.sort_unstable()`
    |
-   = note: an unstable sort would perform faster without any observable difference for this data type
+   = note: an unstable sort typically performs faster without any observable difference for this data type
 
 error: used `sort` on primitive type `array`
   --> $DIR/stable_sort_primitive.rs:17:5
@@ -45,7 +45,7 @@ error: used `sort` on primitive type `array`
 LL |     vec.sort();
    |     ^^^^^^^^^^ help: try: `vec.sort_unstable()`
    |
-   = note: an unstable sort would perform faster without any observable difference for this data type
+   = note: an unstable sort typically performs faster without any observable difference for this data type
 
 error: used `sort` on primitive type `i32`
   --> $DIR/stable_sort_primitive.rs:19:5
@@ -53,7 +53,7 @@ error: used `sort` on primitive type `i32`
 LL |     arr.sort();
    |     ^^^^^^^^^^ help: try: `arr.sort_unstable()`
    |
-   = note: an unstable sort would perform faster without any observable difference for this data type
+   = note: an unstable sort typically performs faster without any observable difference for this data type
 
 error: aborting due to 7 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 7a73e09e35900703d2d58353f30358cfeb1cb4ea Mon Sep 17 00:00:00 2001
From: bing <tanbinghwang@gmail.com>
Date: Mon, 18 Apr 2022 14:48:34 +0800
Subject: Update lints

---
 clippy_lints/src/lib.register_all.rs      | 1 -
 clippy_lints/src/lib.register_pedantic.rs | 1 +
 clippy_lints/src/lib.register_perf.rs     | 1 -
 3 files changed, 1 insertion(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index d091503c4dd..8608b8a9372 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -278,7 +278,6 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS),
     LintId::of(size_of_in_element_count::SIZE_OF_IN_ELEMENT_COUNT),
     LintId::of(slow_vector_initialization::SLOW_VECTOR_INITIALIZATION),
-    LintId::of(stable_sort_primitive::STABLE_SORT_PRIMITIVE),
     LintId::of(strings::STRING_FROM_UTF8_AS_BYTES),
     LintId::of(strlen_on_c_strings::STRLEN_ON_C_STRINGS),
     LintId::of(suspicious_trait_impl::SUSPICIOUS_ARITHMETIC_IMPL),
diff --git a/clippy_lints/src/lib.register_pedantic.rs b/clippy_lints/src/lib.register_pedantic.rs
index 96cdc4577d5..63232fd4113 100644
--- a/clippy_lints/src/lib.register_pedantic.rs
+++ b/clippy_lints/src/lib.register_pedantic.rs
@@ -82,6 +82,7 @@ store.register_group(true, "clippy::pedantic", Some("clippy_pedantic"), vec![
     LintId::of(ref_option_ref::REF_OPTION_REF),
     LintId::of(return_self_not_must_use::RETURN_SELF_NOT_MUST_USE),
     LintId::of(semicolon_if_nothing_returned::SEMICOLON_IF_NOTHING_RETURNED),
+    LintId::of(stable_sort_primitive::STABLE_SORT_PRIMITIVE),
     LintId::of(strings::STRING_ADD_ASSIGN),
     LintId::of(trait_bounds::TRAIT_DUPLICATION_IN_BOUNDS),
     LintId::of(trait_bounds::TYPE_REPETITION_IN_BOUNDS),
diff --git a/clippy_lints/src/lib.register_perf.rs b/clippy_lints/src/lib.register_perf.rs
index 8f361fdad4a..82431863e6c 100644
--- a/clippy_lints/src/lib.register_perf.rs
+++ b/clippy_lints/src/lib.register_perf.rs
@@ -24,7 +24,6 @@ store.register_group(true, "clippy::perf", Some("clippy_perf"), vec![
     LintId::of(misc::CMP_OWNED),
     LintId::of(redundant_clone::REDUNDANT_CLONE),
     LintId::of(slow_vector_initialization::SLOW_VECTOR_INITIALIZATION),
-    LintId::of(stable_sort_primitive::STABLE_SORT_PRIMITIVE),
     LintId::of(types::BOX_COLLECTION),
     LintId::of(types::REDUNDANT_ALLOCATION),
     LintId::of(vec::USELESS_VEC),
-- 
cgit 1.4.1-3-g733a5


From 6d0baf2b16c709284868c3e3b0809cc336bc6243 Mon Sep 17 00:00:00 2001
From: Lily Mara <54288692+lilymara-onesignal@users.noreply.github.com>
Date: Mon, 18 Apr 2022 10:31:57 -0700
Subject: Update clippy_lints/src/await_holding_invalid.rs

Co-authored-by: llogiq <bogusandre@gmail.com>
---
 clippy_lints/src/await_holding_invalid.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/await_holding_invalid.rs b/clippy_lints/src/await_holding_invalid.rs
index 51dd5f4937a..8f2b67176ec 100644
--- a/clippy_lints/src/await_holding_invalid.rs
+++ b/clippy_lints/src/await_holding_invalid.rs
@@ -164,7 +164,7 @@ declare_clippy_lint! {
     #[clippy::version = "1.49.0"]
     pub AWAIT_HOLDING_INVALID_TYPE,
     suspicious,
-    "inside an async function, holding a type across an await point which is not safe to be held across an await point"
+    "holding a type across an await point which is not allowed to be held as per the configuration"
 }
 
 impl_lint_pass!(AwaitHolding => [AWAIT_HOLDING_LOCK, AWAIT_HOLDING_REFCELL_REF, AWAIT_HOLDING_INVALID_TYPE]);
-- 
cgit 1.4.1-3-g733a5


From 228ce783bc75b778272958c3a4d3b8b990a74401 Mon Sep 17 00:00:00 2001
From: Lily Mara <54288692+lilymara-onesignal@users.noreply.github.com>
Date: Mon, 18 Apr 2022 10:32:03 -0700
Subject: Update clippy_lints/src/await_holding_invalid.rs

Co-authored-by: llogiq <bogusandre@gmail.com>
---
 clippy_lints/src/await_holding_invalid.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/await_holding_invalid.rs b/clippy_lints/src/await_holding_invalid.rs
index 8f2b67176ec..24c9f49d9f8 100644
--- a/clippy_lints/src/await_holding_invalid.rs
+++ b/clippy_lints/src/await_holding_invalid.rs
@@ -266,7 +266,7 @@ fn emit_invalid_type(cx: &LateContext<'_>, span: Span, disallowed: &DisallowedTy
         cx,
         AWAIT_HOLDING_INVALID_TYPE,
         span,
-        &format!("`{type_name}` may not be held across an `await` point according to config",),
+        &format!("`{type_name}` may not be held across an `await` point per `clippy.toml`",),
         |diag| {
             if let Some(reason) = reason {
                 diag.note(format!("{reason} (according to clippy.toml)"));
-- 
cgit 1.4.1-3-g733a5


From ee3ebb35f4f077176657b11d2b05b37f23742baf Mon Sep 17 00:00:00 2001
From: Lily Mara <54288692+lilymara-onesignal@users.noreply.github.com>
Date: Mon, 18 Apr 2022 10:32:11 -0700
Subject: Update clippy_lints/src/await_holding_invalid.rs

Co-authored-by: llogiq <bogusandre@gmail.com>
---
 clippy_lints/src/await_holding_invalid.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/await_holding_invalid.rs b/clippy_lints/src/await_holding_invalid.rs
index 24c9f49d9f8..be905f67ec8 100644
--- a/clippy_lints/src/await_holding_invalid.rs
+++ b/clippy_lints/src/await_holding_invalid.rs
@@ -269,7 +269,7 @@ fn emit_invalid_type(cx: &LateContext<'_>, span: Span, disallowed: &DisallowedTy
         &format!("`{type_name}` may not be held across an `await` point per `clippy.toml`",),
         |diag| {
             if let Some(reason) = reason {
-                diag.note(format!("{reason} (according to clippy.toml)"));
+                diag.note(reason.clone());
             }
         },
     );
-- 
cgit 1.4.1-3-g733a5


From a511072c2cb29f4a30fbd357c7e4b6771b9f6a29 Mon Sep 17 00:00:00 2001
From: Lily Mara <lilymara@onesignal.com>
Date: Mon, 18 Apr 2022 10:34:17 -0700
Subject: fixup! Add `await_holding_invalid_type` lint

---
 clippy_lints/src/await_holding_invalid.rs | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/await_holding_invalid.rs b/clippy_lints/src/await_holding_invalid.rs
index be905f67ec8..5659651c842 100644
--- a/clippy_lints/src/await_holding_invalid.rs
+++ b/clippy_lints/src/await_holding_invalid.rs
@@ -144,20 +144,17 @@ declare_clippy_lint! {
     ///
     /// ### Example
     ///
-    /// Strings are, of course, safe to hold across await points. This example
-    /// exists only to show how this lint might be configured for third-party
-    /// crates.
-    ///
     /// ```toml
     /// await-holding-invalid-types = [
-    ///   "std::string::String",
+    ///   "CustomLockType",
     /// ]
     /// ```
     ///
     /// ```rust
     /// # async fn baz() {}
+    /// struct CustomLockType;
     /// async fn foo() {
-    ///   let _x = String::from("hello!");
+    ///   let _x = CustomLockType;
     ///   baz().await; // Lint violation
     /// }
     /// ```
-- 
cgit 1.4.1-3-g733a5


From 7e26edce65df4e89be23aa22bcb3d3a2db723bf7 Mon Sep 17 00:00:00 2001
From: Lily Mara <lilymara@onesignal.com>
Date: Mon, 18 Apr 2022 11:16:35 -0700
Subject: fixup! Add `await_holding_invalid_type` lint

---
 clippy_lints/src/await_holding_invalid.rs                      |  5 +++++
 .../await_holding_invalid_type.stderr                          | 10 +++++-----
 2 files changed, 10 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/await_holding_invalid.rs b/clippy_lints/src/await_holding_invalid.rs
index 5659651c842..022f82ebf51 100644
--- a/clippy_lints/src/await_holding_invalid.rs
+++ b/clippy_lints/src/await_holding_invalid.rs
@@ -146,15 +146,20 @@ declare_clippy_lint! {
     ///
     /// ```toml
     /// await-holding-invalid-types = [
+    ///   # You can specify a type name
     ///   "CustomLockType",
+    ///   # You can (optionally) specify a reason
+    ///   { type = "OtherCustomLockType", reason = "Relies on a thread local" }
     /// ]
     /// ```
     ///
     /// ```rust
     /// # async fn baz() {}
     /// struct CustomLockType;
+    /// struct OtherCustomLockType;
     /// async fn foo() {
     ///   let _x = CustomLockType;
+    ///   let _y = CustomLockType;
     ///   baz().await; // Lint violation
     /// }
     /// ```
diff --git a/tests/ui-toml/await_holding_invalid_type/await_holding_invalid_type.stderr b/tests/ui-toml/await_holding_invalid_type/await_holding_invalid_type.stderr
index eebdd624d24..62c45b54634 100644
--- a/tests/ui-toml/await_holding_invalid_type/await_holding_invalid_type.stderr
+++ b/tests/ui-toml/await_holding_invalid_type/await_holding_invalid_type.stderr
@@ -1,25 +1,25 @@
-error: `std::string::String` may not be held across an `await` point according to config
+error: `std::string::String` may not be held across an `await` point per `clippy.toml`
   --> $DIR/await_holding_invalid_type.rs:5:9
    |
 LL |     let _x = String::from("hello");
    |         ^^
    |
    = note: `-D clippy::await-holding-invalid-type` implied by `-D warnings`
-   = note: strings are bad (according to clippy.toml)
+   = note: strings are bad
 
-error: `std::net::Ipv4Addr` may not be held across an `await` point according to config
+error: `std::net::Ipv4Addr` may not be held across an `await` point per `clippy.toml`
   --> $DIR/await_holding_invalid_type.rs:10:9
    |
 LL |     let _x = Ipv4Addr::new(127, 0, 0, 1);
    |         ^^
 
-error: `std::string::String` may not be held across an `await` point according to config
+error: `std::string::String` may not be held across an `await` point per `clippy.toml`
   --> $DIR/await_holding_invalid_type.rs:31:13
    |
 LL |         let _x = String::from("hi!");
    |             ^^
    |
-   = note: strings are bad (according to clippy.toml)
+   = note: strings are bad
 
 error: aborting due to 3 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 8eccbbed68bbc4ad8c5f0ab17d905359e88e30fa Mon Sep 17 00:00:00 2001
From: Lily Mara <lilymara@onesignal.com>
Date: Mon, 18 Apr 2022 11:30:59 -0700
Subject: fixup! Add `await_holding_invalid_type` lint

---
 clippy_lints/src/await_holding_invalid.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/await_holding_invalid.rs b/clippy_lints/src/await_holding_invalid.rs
index 022f82ebf51..5c29afb947b 100644
--- a/clippy_lints/src/await_holding_invalid.rs
+++ b/clippy_lints/src/await_holding_invalid.rs
@@ -159,7 +159,7 @@ declare_clippy_lint! {
     /// struct OtherCustomLockType;
     /// async fn foo() {
     ///   let _x = CustomLockType;
-    ///   let _y = CustomLockType;
+    ///   let _y = OtherCustomLockType;
     ///   baz().await; // Lint violation
     /// }
     /// ```
-- 
cgit 1.4.1-3-g733a5


From 05086858c4058400053e67d53d647ffa43945530 Mon Sep 17 00:00:00 2001
From: Lily Mara <lilymara@onesignal.com>
Date: Mon, 18 Apr 2022 11:32:28 -0700
Subject: fixup! Add `await_holding_invalid_type` lint

---
 clippy_lints/src/await_holding_invalid.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/await_holding_invalid.rs b/clippy_lints/src/await_holding_invalid.rs
index 5c29afb947b..5b7c4591504 100644
--- a/clippy_lints/src/await_holding_invalid.rs
+++ b/clippy_lints/src/await_holding_invalid.rs
@@ -149,7 +149,7 @@ declare_clippy_lint! {
     ///   # You can specify a type name
     ///   "CustomLockType",
     ///   # You can (optionally) specify a reason
-    ///   { type = "OtherCustomLockType", reason = "Relies on a thread local" }
+    ///   { path = "OtherCustomLockType", reason = "Relies on a thread local" }
     /// ]
     /// ```
     ///
-- 
cgit 1.4.1-3-g733a5


From df1ec91d952aa39646f38775a51834205fb75bef Mon Sep 17 00:00:00 2001
From: Chase Ruskin <c.ruskin@ufl.edu>
Date: Sun, 30 Jan 2022 19:16:10 -0500
Subject: adds lint logic and test for bytes_count_to_len

formats code with

fixes single match clippy error to replace with if let

swaps ident.name.as_str to ident.name == sym for count fn
---
 CHANGELOG.md                                |  1 +
 clippy_lints/src/bytes_count_to_len.rs      | 54 +++++++++++++++++++++++++++++
 clippy_lints/src/lib.register_all.rs        |  1 +
 clippy_lints/src/lib.register_complexity.rs |  1 +
 clippy_lints/src/lib.register_lints.rs      |  1 +
 clippy_lints/src/lib.rs                     |  2 ++
 tests/ui/bytes_count_to_len.rs              | 15 ++++++++
 tests/ui/bytes_count_to_len.stderr          | 19 ++++++++++
 8 files changed, 94 insertions(+)
 create mode 100644 clippy_lints/src/bytes_count_to_len.rs
 create mode 100644 tests/ui/bytes_count_to_len.rs
 create mode 100644 tests/ui/bytes_count_to_len.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 811dce481d5..5de598a3204 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3299,6 +3299,7 @@ Released 2018-09-13
 [`boxed_local`]: https://rust-lang.github.io/rust-clippy/master/index.html#boxed_local
 [`branches_sharing_code`]: https://rust-lang.github.io/rust-clippy/master/index.html#branches_sharing_code
 [`builtin_type_shadow`]: https://rust-lang.github.io/rust-clippy/master/index.html#builtin_type_shadow
+[`bytes_count_to_len`]: https://rust-lang.github.io/rust-clippy/master/index.html#bytes_count_to_len
 [`bytes_nth`]: https://rust-lang.github.io/rust-clippy/master/index.html#bytes_nth
 [`cargo_common_metadata`]: https://rust-lang.github.io/rust-clippy/master/index.html#cargo_common_metadata
 [`case_sensitive_file_extension_comparisons`]: https://rust-lang.github.io/rust-clippy/master/index.html#case_sensitive_file_extension_comparisons
diff --git a/clippy_lints/src/bytes_count_to_len.rs b/clippy_lints/src/bytes_count_to_len.rs
new file mode 100644
index 00000000000..799d3783f74
--- /dev/null
+++ b/clippy_lints/src/bytes_count_to_len.rs
@@ -0,0 +1,54 @@
+use clippy_utils::diagnostics::span_lint_and_note;
+use if_chain::if_chain;
+use rustc_hir as hir;
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// It checks for `str::bytes().count()` and suggests replacing it with
+    /// `str::len()`.
+    ///
+    /// ### Why is this bad?
+    /// `str::bytes().count()` is longer and may not be as performant as using
+    /// `str::len()`.
+    ///
+    /// ### Example
+    /// ```rust
+    /// "hello".bytes().count();
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// "hello".len();
+    /// ```
+    #[clippy::version = "1.60.0"]
+    pub BYTES_COUNT_TO_LEN,
+    complexity,
+    "Using bytest().count() when len() performs the same functionality"
+}
+
+declare_lint_pass!(BytesCountToLen => [BYTES_COUNT_TO_LEN]);
+
+impl<'tcx> LateLintPass<'tcx> for BytesCountToLen {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
+        if_chain! {
+            //check for method call called "count"
+            if let hir::ExprKind::MethodCall(count_path, count_args, _) = &expr.kind;
+            if count_path.ident.name == rustc_span::sym::count;
+            if let [bytes_expr] = &**count_args;
+            //check for method call called "bytes" that was linked to "count"
+            if let hir::ExprKind::MethodCall(bytes_path, _, _) = &bytes_expr.kind;
+            if bytes_path.ident.name.as_str() == "bytes";
+            then {
+                span_lint_and_note(
+                    cx,
+                    BYTES_COUNT_TO_LEN,
+                    expr.span,
+                    "using long and hard to read `.bytes().count()`",
+                    None,
+                    "`.len()` achieves same functionality"
+                );
+            }
+        };
+    }
+}
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 097064ae26f..0294b9866ac 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -23,6 +23,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(bool_assert_comparison::BOOL_ASSERT_COMPARISON),
     LintId::of(booleans::LOGIC_BUG),
     LintId::of(booleans::NONMINIMAL_BOOL),
+    LintId::of(bytes_count_to_len::BYTES_COUNT_TO_LEN),
     LintId::of(casts::CAST_ABS_TO_UNSIGNED),
     LintId::of(casts::CAST_ENUM_CONSTRUCTOR),
     LintId::of(casts::CAST_ENUM_TRUNCATION),
diff --git a/clippy_lints/src/lib.register_complexity.rs b/clippy_lints/src/lib.register_complexity.rs
index 10369a855ae..cd637b199fe 100644
--- a/clippy_lints/src/lib.register_complexity.rs
+++ b/clippy_lints/src/lib.register_complexity.rs
@@ -5,6 +5,7 @@
 store.register_group(true, "clippy::complexity", Some("clippy_complexity"), vec![
     LintId::of(attrs::DEPRECATED_CFG_ATTR),
     LintId::of(booleans::NONMINIMAL_BOOL),
+    LintId::of(bytes_count_to_len::BYTES_COUNT_TO_LEN),
     LintId::of(casts::CHAR_LIT_AS_U8),
     LintId::of(casts::UNNECESSARY_CAST),
     LintId::of(derivable_impls::DERIVABLE_IMPLS),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index c608f634291..590fc502738 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -64,6 +64,7 @@ store.register_lints(&[
     booleans::NONMINIMAL_BOOL,
     borrow_as_ptr::BORROW_AS_PTR,
     bytecount::NAIVE_BYTECOUNT,
+    bytes_count_to_len::BYTES_COUNT_TO_LEN,
     cargo::CARGO_COMMON_METADATA,
     cargo::MULTIPLE_CRATE_VERSIONS,
     cargo::NEGATIVE_FEATURE_NAMES,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 88e8a0cc2af..9a9ba4f1779 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -181,6 +181,7 @@ mod bool_assert_comparison;
 mod booleans;
 mod borrow_as_ptr;
 mod bytecount;
+mod bytes_count_to_len;
 mod cargo;
 mod case_sensitive_file_extension_comparisons;
 mod casts;
@@ -875,6 +876,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(unnecessary_owned_empty_strings::UnnecessaryOwnedEmptyStrings));
     store.register_early_pass(|| Box::new(pub_use::PubUse));
     store.register_late_pass(|| Box::new(format_push_string::FormatPushString));
+    store.register_late_pass(|| Box::new(bytes_count_to_len::BytesCountToLen));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/tests/ui/bytes_count_to_len.rs b/tests/ui/bytes_count_to_len.rs
new file mode 100644
index 00000000000..b2dd2bfeeed
--- /dev/null
+++ b/tests/ui/bytes_count_to_len.rs
@@ -0,0 +1,15 @@
+#![warn(clippy::bytes_count_to_len)]
+
+fn main() {
+    let s1 = String::from("world");
+
+    //test warning against a string literal
+    "hello".bytes().count();
+
+    //test warning against a string variable
+    s1.bytes().count();
+
+    //make sure using count() normally doesn't trigger warning
+    let vector = [0, 1, 2];
+    let size = vector.iter().count();
+}
diff --git a/tests/ui/bytes_count_to_len.stderr b/tests/ui/bytes_count_to_len.stderr
new file mode 100644
index 00000000000..ddd08ee824c
--- /dev/null
+++ b/tests/ui/bytes_count_to_len.stderr
@@ -0,0 +1,19 @@
+error: using long and hard to read `.bytes().count()`
+  --> $DIR/bytes_count_to_len.rs:7:5
+   |
+LL |     "hello".bytes().count();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::bytes-count-to-len` implied by `-D warnings`
+   = note: `.len()` achieves same functionality
+
+error: using long and hard to read `.bytes().count()`
+  --> $DIR/bytes_count_to_len.rs:10:5
+   |
+LL |     s1.bytes().count();
+   |     ^^^^^^^^^^^^^^^^^^
+   |
+   = note: `.len()` achieves same functionality
+
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From f19387d2371de497552fbf465acf9438084fe77b Mon Sep 17 00:00:00 2001
From: kyoto7250 <50972773+kyoto7250@users.noreply.github.com>
Date: Sat, 16 Apr 2022 17:53:22 +0900
Subject: add checking type

adding test patterns

cargo dev bless

fix comment

add ;

delete :

fix suggestion code

and update stderr in tests.

use match_def_path when checking method name
---
 clippy_lints/src/bytes_count_to_len.rs | 42 +++++++++++++++++++++++-----------
 clippy_utils/src/paths.rs              |  2 ++
 tests/ui/bytes_count_to_len.fixed      | 34 +++++++++++++++++++++++++++
 tests/ui/bytes_count_to_len.rs         | 33 ++++++++++++++++++++------
 tests/ui/bytes_count_to_len.stderr     | 27 ++++++++++++++--------
 5 files changed, 109 insertions(+), 29 deletions(-)
 create mode 100644 tests/ui/bytes_count_to_len.fixed

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/bytes_count_to_len.rs b/clippy_lints/src/bytes_count_to_len.rs
index 799d3783f74..d70dbf5b239 100644
--- a/clippy_lints/src/bytes_count_to_len.rs
+++ b/clippy_lints/src/bytes_count_to_len.rs
@@ -1,8 +1,14 @@
-use clippy_utils::diagnostics::span_lint_and_note;
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::{match_def_path, paths};
 use if_chain::if_chain;
+use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::sym;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -16,15 +22,17 @@ declare_clippy_lint! {
     /// ### Example
     /// ```rust
     /// "hello".bytes().count();
+    /// String::from("hello").bytes().count();
     /// ```
     /// Use instead:
     /// ```rust
     /// "hello".len();
+    /// String::from("hello").len();
     /// ```
-    #[clippy::version = "1.60.0"]
+    #[clippy::version = "1.62.0"]
     pub BYTES_COUNT_TO_LEN,
     complexity,
-    "Using bytest().count() when len() performs the same functionality"
+    "Using `bytes().count()` when `len()` performs the same functionality"
 }
 
 declare_lint_pass!(BytesCountToLen => [BYTES_COUNT_TO_LEN]);
@@ -32,21 +40,29 @@ declare_lint_pass!(BytesCountToLen => [BYTES_COUNT_TO_LEN]);
 impl<'tcx> LateLintPass<'tcx> for BytesCountToLen {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
         if_chain! {
-            //check for method call called "count"
-            if let hir::ExprKind::MethodCall(count_path, count_args, _) = &expr.kind;
-            if count_path.ident.name == rustc_span::sym::count;
-            if let [bytes_expr] = &**count_args;
-            //check for method call called "bytes" that was linked to "count"
-            if let hir::ExprKind::MethodCall(bytes_path, _, _) = &bytes_expr.kind;
-            if bytes_path.ident.name.as_str() == "bytes";
+            if let hir::ExprKind::MethodCall(_, expr_args, _) = &expr.kind;
+            if let Some(expr_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
+            if match_def_path(cx, expr_def_id, &paths::ITER_COUNT);
+
+            if let [bytes_expr] = &**expr_args;
+            if let hir::ExprKind::MethodCall(_, bytes_args, _) = &bytes_expr.kind;
+            if let Some(bytes_def_id) = cx.typeck_results().type_dependent_def_id(bytes_expr.hir_id);
+            if match_def_path(cx, bytes_def_id, &paths::STR_BYTES);
+
+            if let [str_expr] = &**bytes_args;
+            let ty = cx.typeck_results().expr_ty(str_expr).peel_refs();
+
+            if is_type_diagnostic_item(cx, ty, sym::String) || ty.kind() == &ty::Str;
             then {
-                span_lint_and_note(
+                let mut applicability = Applicability::MachineApplicable;
+                span_lint_and_sugg(
                     cx,
                     BYTES_COUNT_TO_LEN,
                     expr.span,
                     "using long and hard to read `.bytes().count()`",
-                    None,
-                    "`.len()` achieves same functionality"
+                    "consider calling `.len()` instead",
+                    format!("{}.len()", snippet_with_applicability(cx, str_expr.span, "..", &mut applicability)),
+                    applicability
                 );
             }
         };
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index deb548daf2d..4291a5e2299 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -61,6 +61,7 @@ pub const IO_READ: [&str; 3] = ["std", "io", "Read"];
 pub const IO_WRITE: [&str; 3] = ["std", "io", "Write"];
 pub const IPADDR_V4: [&str; 5] = ["std", "net", "ip", "IpAddr", "V4"];
 pub const IPADDR_V6: [&str; 5] = ["std", "net", "ip", "IpAddr", "V6"];
+pub const ITER_COUNT: [&str; 6] = ["core", "iter", "traits", "iterator", "Iterator", "count"];
 pub const ITER_REPEAT: [&str; 5] = ["core", "iter", "sources", "repeat", "repeat"];
 #[allow(clippy::invalid_paths)] // internal lints do not know about all external crates
 pub const ITERTOOLS_NEXT_TUPLE: [&str; 3] = ["itertools", "Itertools", "next_tuple"];
@@ -149,6 +150,7 @@ pub const STD_FS_CREATE_DIR: [&str; 3] = ["std", "fs", "create_dir"];
 pub const STRING_AS_MUT_STR: [&str; 4] = ["alloc", "string", "String", "as_mut_str"];
 pub const STRING_AS_STR: [&str; 4] = ["alloc", "string", "String", "as_str"];
 pub const STRING_NEW: [&str; 4] = ["alloc", "string", "String", "new"];
+pub const STR_BYTES: [&str; 4] = ["core", "str", "<impl str>", "bytes"];
 pub const STR_ENDS_WITH: [&str; 4] = ["core", "str", "<impl str>", "ends_with"];
 pub const STR_FROM_UTF8: [&str; 4] = ["core", "str", "converts", "from_utf8"];
 pub const STR_LEN: [&str; 4] = ["core", "str", "<impl str>", "len"];
diff --git a/tests/ui/bytes_count_to_len.fixed b/tests/ui/bytes_count_to_len.fixed
new file mode 100644
index 00000000000..860642363b5
--- /dev/null
+++ b/tests/ui/bytes_count_to_len.fixed
@@ -0,0 +1,34 @@
+// run-rustfix
+#![warn(clippy::bytes_count_to_len)]
+use std::fs::File;
+use std::io::Read;
+
+fn main() {
+    // should fix, because type is String
+    let _ = String::from("foo").len();
+
+    let s1 = String::from("foo");
+    let _ = s1.len();
+
+    // should fix, because type is &str
+    let _ = "foo".len();
+
+    let s2 = "foo";
+    let _ = s2.len();
+
+    // make sure using count() normally doesn't trigger warning
+    let vector = [0, 1, 2];
+    let _ = vector.iter().count();
+
+    // The type is slice, so should not fix
+    let _ = &[1, 2, 3].bytes().count();
+
+    let bytes: &[u8] = &[1, 2, 3];
+    bytes.bytes().count();
+
+    // The type is File, so should not fix
+    let _ = File::open("foobar").unwrap().bytes().count();
+
+    let f = File::open("foobar").unwrap();
+    let _ = f.bytes().count();
+}
diff --git a/tests/ui/bytes_count_to_len.rs b/tests/ui/bytes_count_to_len.rs
index b2dd2bfeeed..162730c2842 100644
--- a/tests/ui/bytes_count_to_len.rs
+++ b/tests/ui/bytes_count_to_len.rs
@@ -1,15 +1,34 @@
+// run-rustfix
 #![warn(clippy::bytes_count_to_len)]
+use std::fs::File;
+use std::io::Read;
 
 fn main() {
-    let s1 = String::from("world");
+    // should fix, because type is String
+    let _ = String::from("foo").bytes().count();
 
-    //test warning against a string literal
-    "hello".bytes().count();
+    let s1 = String::from("foo");
+    let _ = s1.bytes().count();
 
-    //test warning against a string variable
-    s1.bytes().count();
+    // should fix, because type is &str
+    let _ = "foo".bytes().count();
 
-    //make sure using count() normally doesn't trigger warning
+    let s2 = "foo";
+    let _ = s2.bytes().count();
+
+    // make sure using count() normally doesn't trigger warning
     let vector = [0, 1, 2];
-    let size = vector.iter().count();
+    let _ = vector.iter().count();
+
+    // The type is slice, so should not fix
+    let _ = &[1, 2, 3].bytes().count();
+
+    let bytes: &[u8] = &[1, 2, 3];
+    bytes.bytes().count();
+
+    // The type is File, so should not fix
+    let _ = File::open("foobar").unwrap().bytes().count();
+
+    let f = File::open("foobar").unwrap();
+    let _ = f.bytes().count();
 }
diff --git a/tests/ui/bytes_count_to_len.stderr b/tests/ui/bytes_count_to_len.stderr
index ddd08ee824c..224deb77987 100644
--- a/tests/ui/bytes_count_to_len.stderr
+++ b/tests/ui/bytes_count_to_len.stderr
@@ -1,19 +1,28 @@
 error: using long and hard to read `.bytes().count()`
-  --> $DIR/bytes_count_to_len.rs:7:5
+  --> $DIR/bytes_count_to_len.rs:8:13
    |
-LL |     "hello".bytes().count();
-   |     ^^^^^^^^^^^^^^^^^^^^^^^
+LL |     let _ = String::from("foo").bytes().count();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.len()` instead: `String::from("foo").len()`
    |
    = note: `-D clippy::bytes-count-to-len` implied by `-D warnings`
-   = note: `.len()` achieves same functionality
 
 error: using long and hard to read `.bytes().count()`
-  --> $DIR/bytes_count_to_len.rs:10:5
+  --> $DIR/bytes_count_to_len.rs:11:13
    |
-LL |     s1.bytes().count();
-   |     ^^^^^^^^^^^^^^^^^^
+LL |     let _ = s1.bytes().count();
+   |             ^^^^^^^^^^^^^^^^^^ help: consider calling `.len()` instead: `s1.len()`
+
+error: using long and hard to read `.bytes().count()`
+  --> $DIR/bytes_count_to_len.rs:14:13
+   |
+LL |     let _ = "foo".bytes().count();
+   |             ^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.len()` instead: `"foo".len()`
+
+error: using long and hard to read `.bytes().count()`
+  --> $DIR/bytes_count_to_len.rs:17:13
    |
-   = note: `.len()` achieves same functionality
+LL |     let _ = s2.bytes().count();
+   |             ^^^^^^^^^^^^^^^^^^ help: consider calling `.len()` instead: `s2.len()`
 
-error: aborting due to 2 previous errors
+error: aborting due to 4 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From c922bb9443993df9f32ebf25bed76195cfab11f2 Mon Sep 17 00:00:00 2001
From: asquared31415 <34665709+asquared31415@users.noreply.github.com>
Date: Mon, 18 Apr 2022 22:19:34 -0400
Subject: fix ICE

---
 .../src/casts/cast_slice_different_sizes.rs        |  2 +-
 tests/ui/cast_slice_different_sizes.rs             | 31 +++++++++++++
 tests/ui/cast_slice_different_sizes.stderr         | 53 +++++++++++++++++++++-
 3 files changed, 84 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/cast_slice_different_sizes.rs b/clippy_lints/src/casts/cast_slice_different_sizes.rs
index 3608c1654d5..ff03f416d0b 100644
--- a/clippy_lints/src/casts/cast_slice_different_sizes.rs
+++ b/clippy_lints/src/casts/cast_slice_different_sizes.rs
@@ -59,7 +59,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, msrv: &Option<RustcVe
                         from_slice_ty, from_size, to_slice_ty, to_size,
                     ),
                     |diag| {
-                        let cast_expr = match expr.kind {
+                        let cast_expr = match expr.peel_blocks().kind {
                             ExprKind::Cast(cast_expr, ..) => cast_expr,
                             _ => unreachable!("expr should be a cast as checked by expr_cast_chain_tys"),
                         };
diff --git a/tests/ui/cast_slice_different_sizes.rs b/tests/ui/cast_slice_different_sizes.rs
index 57270fcf52b..7ec137cc5b2 100644
--- a/tests/ui/cast_slice_different_sizes.rs
+++ b/tests/ui/cast_slice_different_sizes.rs
@@ -39,3 +39,34 @@ fn main() {
     let long_chain_restore =
         r_x as *const [i32] as *const [u32] as *const [u16] as *const [i8] as *const [u8] as *const [u32];
 }
+
+// foo and foo2 should not fire, they're the same size
+fn foo(x: *mut [u8]) -> *mut [u8] {
+    x as *mut [u8]
+}
+
+fn foo2(x: *mut [u8]) -> *mut [u8] {
+    x as *mut _
+}
+
+// Test that casts as part of function returns work
+fn bar(x: *mut [u16]) -> *mut [u8] {
+    x as *mut [u8]
+}
+
+fn uwu(x: *mut [u16]) -> *mut [u8] {
+    x as *mut _
+}
+
+fn bar2(x: *mut [u16]) -> *mut [u8] {
+    x as _
+}
+
+// function returns plus blocks
+fn blocks(x: *mut [u16]) -> *mut [u8] {
+    ({ x }) as _
+}
+
+fn more_blocks(x: *mut [u16]) -> *mut [u8] {
+    { ({ x }) as _ }
+}
diff --git a/tests/ui/cast_slice_different_sizes.stderr b/tests/ui/cast_slice_different_sizes.stderr
index 993e93c2bf3..0e018b62e60 100644
--- a/tests/ui/cast_slice_different_sizes.stderr
+++ b/tests/ui/cast_slice_different_sizes.stderr
@@ -48,5 +48,56 @@ error: casting between raw pointers to `[i32]` (element size 4) and `[u8]` (elem
 LL |     let long_chain_loss = r_x as *const [i32] as *const [u32] as *const [u16] as *const [i8] as *const [u8];
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with `ptr::slice_from_raw_parts`: `core::ptr::slice_from_raw_parts(r_x as *const [i32] as *const [u32] as *const [u16] as *const [i8] as *const u8, ..)`
 
-error: aborting due to 6 previous errors
+error: casting between raw pointers to `[mut u16]` (element size 2) and `[mut u8]` (element size 1) does not adjust the count
+  --> $DIR/cast_slice_different_sizes.rs:53:36
+   |
+LL |   fn bar(x: *mut [u16]) -> *mut [u8] {
+   |  ____________________________________^
+LL | |     x as *mut [u8]
+LL | | }
+   | |_^ help: replace with `ptr::slice_from_raw_parts_mut`: `core::ptr::slice_from_raw_parts_mut(x as *mut mut u8, ..)`
+
+error: casting between raw pointers to `[mut u16]` (element size 2) and `[mut u8]` (element size 1) does not adjust the count
+  --> $DIR/cast_slice_different_sizes.rs:57:36
+   |
+LL |   fn uwu(x: *mut [u16]) -> *mut [u8] {
+   |  ____________________________________^
+LL | |     x as *mut _
+LL | | }
+   | |_^ help: replace with `ptr::slice_from_raw_parts_mut`: `core::ptr::slice_from_raw_parts_mut(x as *mut mut u8, ..)`
+
+error: casting between raw pointers to `[mut u16]` (element size 2) and `[mut u8]` (element size 1) does not adjust the count
+  --> $DIR/cast_slice_different_sizes.rs:61:37
+   |
+LL |   fn bar2(x: *mut [u16]) -> *mut [u8] {
+   |  _____________________________________^
+LL | |     x as _
+LL | | }
+   | |_^ help: replace with `ptr::slice_from_raw_parts_mut`: `core::ptr::slice_from_raw_parts_mut(x as *mut mut u8, ..)`
+
+error: casting between raw pointers to `[mut u16]` (element size 2) and `[mut u8]` (element size 1) does not adjust the count
+  --> $DIR/cast_slice_different_sizes.rs:66:39
+   |
+LL |   fn blocks(x: *mut [u16]) -> *mut [u8] {
+   |  _______________________________________^
+LL | |     ({ x }) as _
+LL | | }
+   | |_^ help: replace with `ptr::slice_from_raw_parts_mut`: `core::ptr::slice_from_raw_parts_mut(({ x }) as *mut mut u8, ..)`
+
+error: casting between raw pointers to `[mut u16]` (element size 2) and `[mut u8]` (element size 1) does not adjust the count
+  --> $DIR/cast_slice_different_sizes.rs:70:44
+   |
+LL |   fn more_blocks(x: *mut [u16]) -> *mut [u8] {
+   |  ____________________________________________^
+LL | |     { ({ x }) as _ }
+LL | | }
+   | |_^ help: replace with `ptr::slice_from_raw_parts_mut`: `core::ptr::slice_from_raw_parts_mut(({ x }) as *mut mut u8, ..)`
+
+error: casting between raw pointers to `[mut u16]` (element size 2) and `[mut u8]` (element size 1) does not adjust the count
+  --> $DIR/cast_slice_different_sizes.rs:71:5
+   |
+LL |     { ({ x }) as _ }
+   |     ^^^^^^^^^^^^^^^^ help: replace with `ptr::slice_from_raw_parts_mut`: `core::ptr::slice_from_raw_parts_mut(({ x }) as *mut mut u8, ..)`
+
+error: aborting due to 12 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 1b6b802b99a1c0ce575bb80eca6d8f53db20af0a Mon Sep 17 00:00:00 2001
From: bing <tanbinghwang@gmail.com>
Date: Wed, 20 Apr 2022 23:11:54 +0800
Subject: Better documentation wording and add known problems section

---
 clippy_lints/src/stable_sort_primitive.rs | 16 +++++++++++++---
 1 file changed, 13 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/stable_sort_primitive.rs b/clippy_lints/src/stable_sort_primitive.rs
index a285323dc6e..a6c685df721 100644
--- a/clippy_lints/src/stable_sort_primitive.rs
+++ b/clippy_lints/src/stable_sort_primitive.rs
@@ -9,15 +9,25 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 declare_clippy_lint! {
     /// ### What it does
     /// When sorting primitive values (integers, bools, chars, as well
-    /// as arrays, slices, and tuples of such items), it is better to
+    /// as arrays, slices, and tuples of such items), it is typically better to
     /// use an unstable sort than a stable sort.
     ///
     /// ### Why is this bad?
-    /// Using a stable sort consumes more memory and cpu cycles. Because
-    /// values which compare equal are identical, preserving their
+    /// Typically, using a stable sort consumes more memory and cpu cycles.
+    /// Because values which compare equal are identical, preserving their
     /// relative order (the guarantee that a stable sort provides) means
     /// nothing, while the extra costs still apply.
     ///
+    /// ### Known problems
+    ///
+    /// As pointed out in
+    /// [issue #8241](https://github.com/rust-lang/rust-clippy/issues/8241),
+    /// a stable sort can instead be significantly faster for certain scenarios
+    /// (eg. when a sorted vector is extended with new data and resorted).
+    ///
+    /// For more information and benchmarking results, please refer to the
+    /// issue linked above.
+    ///
     /// ### Example
     /// ```rust
     /// let mut vec = vec![2, 1, 3];
-- 
cgit 1.4.1-3-g733a5


From 8de3fb159dcf412d4692bd862b7b3d348810ecd0 Mon Sep 17 00:00:00 2001
From: Gryffon Bellish <owenbellish@gmail.com>
Date: Fri, 25 Mar 2022 15:31:52 -0400
Subject: Add empty_drop lint

---
 CHANGELOG.md                                 |  1 +
 clippy_lints/src/empty_drop.rs               | 65 ++++++++++++++++++++++++++++
 clippy_lints/src/lib.register_lints.rs       |  1 +
 clippy_lints/src/lib.register_restriction.rs |  1 +
 clippy_lints/src/lib.rs                      |  2 +
 tests/ui/empty_drop.fixed                    | 24 ++++++++++
 tests/ui/empty_drop.rs                       | 30 +++++++++++++
 tests/ui/empty_drop.stderr                   | 22 ++++++++++
 8 files changed, 146 insertions(+)
 create mode 100644 clippy_lints/src/empty_drop.rs
 create mode 100644 tests/ui/empty_drop.fixed
 create mode 100644 tests/ui/empty_drop.rs
 create mode 100644 tests/ui/empty_drop.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index dba4ab50cf2..2948c24fb3b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3365,6 +3365,7 @@ Released 2018-09-13
 [`duplicate_underscore_argument`]: https://rust-lang.github.io/rust-clippy/master/index.html#duplicate_underscore_argument
 [`duration_subsec`]: https://rust-lang.github.io/rust-clippy/master/index.html#duration_subsec
 [`else_if_without_else`]: https://rust-lang.github.io/rust-clippy/master/index.html#else_if_without_else
+[`empty_drop`]: https://rust-lang.github.io/rust-clippy/master/index.html#empty_drop
 [`empty_enum`]: https://rust-lang.github.io/rust-clippy/master/index.html#empty_enum
 [`empty_line_after_outer_attr`]: https://rust-lang.github.io/rust-clippy/master/index.html#empty_line_after_outer_attr
 [`empty_loop`]: https://rust-lang.github.io/rust-clippy/master/index.html#empty_loop
diff --git a/clippy_lints/src/empty_drop.rs b/clippy_lints/src/empty_drop.rs
new file mode 100644
index 00000000000..325ae2356c1
--- /dev/null
+++ b/clippy_lints/src/empty_drop.rs
@@ -0,0 +1,65 @@
+use clippy_utils::{diagnostics::span_lint_and_sugg, peel_blocks};
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir::{Body, ExprKind, Impl, ImplItemKind, Item, ItemKind, Node};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for empty `Drop` implementations.
+    ///
+    /// ### Why is this bad?
+    /// Empty `Drop` implementations have no effect when dropping an instance of the type. They are
+    /// most likely useless. However, an empty `Drop` implementation prevents a type from being
+    /// destructured, which might be the intention behind adding the implementation as a marker.
+    ///
+    /// ### Example
+    /// ```rust
+    /// struct S;
+    ///
+    /// impl Drop for S {
+    ///     fn drop(&mut self) {}
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// struct S;
+    /// ```
+    #[clippy::version = "1.61.0"]
+    pub EMPTY_DROP,
+    restriction,
+    "empty `Drop` implementations"
+}
+declare_lint_pass!(EmptyDrop => [EMPTY_DROP]);
+
+impl LateLintPass<'_> for EmptyDrop {
+    fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
+        if_chain! {
+            if let ItemKind::Impl(Impl {
+                of_trait: Some(ref trait_ref),
+                items: [child],
+                ..
+            }) = item.kind;
+            if trait_ref.trait_def_id() == cx.tcx.lang_items().drop_trait();
+            if let impl_item_hir = child.id.hir_id();
+            if let Some(Node::ImplItem(impl_item)) = cx.tcx.hir().find(impl_item_hir);
+            if let ImplItemKind::Fn(_, b) = &impl_item.kind;
+            if let Body { value: func_expr, .. } = cx.tcx.hir().body(*b);
+            let func_expr = peel_blocks(func_expr);
+            if let ExprKind::Block(block, _) = func_expr.kind;
+            if block.stmts.is_empty() && block.expr.is_none();
+            then {
+                span_lint_and_sugg(
+                    cx,
+                    EMPTY_DROP,
+                    item.span,
+                    "empty drop implementation",
+                    "try removing this impl",
+                    String::new(),
+                    Applicability::MaybeIncorrect
+                );
+            }
+        }
+    }
+}
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 3541c9328c0..8507531c8d3 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -134,6 +134,7 @@ store.register_lints(&[
     drop_forget_ref::UNDROPPED_MANUALLY_DROPS,
     duration_subsec::DURATION_SUBSEC,
     else_if_without_else::ELSE_IF_WITHOUT_ELSE,
+    empty_drop::EMPTY_DROP,
     empty_enum::EMPTY_ENUM,
     empty_structs_with_brackets::EMPTY_STRUCTS_WITH_BRACKETS,
     entry::MAP_ENTRY,
diff --git a/clippy_lints/src/lib.register_restriction.rs b/clippy_lints/src/lib.register_restriction.rs
index 555a8ad841f..46c79c56a47 100644
--- a/clippy_lints/src/lib.register_restriction.rs
+++ b/clippy_lints/src/lib.register_restriction.rs
@@ -16,6 +16,7 @@ store.register_group(true, "clippy::restriction", Some("clippy_restriction"), ve
     LintId::of(default_union_representation::DEFAULT_UNION_REPRESENTATION),
     LintId::of(disallowed_script_idents::DISALLOWED_SCRIPT_IDENTS),
     LintId::of(else_if_without_else::ELSE_IF_WITHOUT_ELSE),
+    LintId::of(empty_drop::EMPTY_DROP),
     LintId::of(empty_structs_with_brackets::EMPTY_STRUCTS_WITH_BRACKETS),
     LintId::of(exhaustive_items::EXHAUSTIVE_ENUMS),
     LintId::of(exhaustive_items::EXHAUSTIVE_STRUCTS),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index c1783a3f764..335467bf9d2 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -210,6 +210,7 @@ mod double_parens;
 mod drop_forget_ref;
 mod duration_subsec;
 mod else_if_without_else;
+mod empty_drop;
 mod empty_enum;
 mod empty_structs_with_brackets;
 mod entry;
@@ -822,6 +823,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(move || Box::new(disallowed_methods::DisallowedMethods::new(disallowed_methods.clone())));
     store.register_early_pass(|| Box::new(asm_syntax::InlineAsmX86AttSyntax));
     store.register_early_pass(|| Box::new(asm_syntax::InlineAsmX86IntelSyntax));
+    store.register_late_pass(|| Box::new(empty_drop::EmptyDrop));
     store.register_late_pass(|| Box::new(strings::StrToString));
     store.register_late_pass(|| Box::new(strings::StringToString));
     store.register_late_pass(|| Box::new(zero_sized_map_values::ZeroSizedMapValues));
diff --git a/tests/ui/empty_drop.fixed b/tests/ui/empty_drop.fixed
new file mode 100644
index 00000000000..2e1b768461a
--- /dev/null
+++ b/tests/ui/empty_drop.fixed
@@ -0,0 +1,24 @@
+// run-rustfix
+#![warn(clippy::empty_drop)]
+#![allow(unused)]
+
+// should cause an error
+struct Foo;
+
+
+
+// shouldn't cause an error
+struct Bar;
+
+impl Drop for Bar {
+    fn drop(&mut self) {
+        println!("dropping bar!");
+    }
+}
+
+// should error
+struct Baz;
+
+
+
+fn main() {}
diff --git a/tests/ui/empty_drop.rs b/tests/ui/empty_drop.rs
new file mode 100644
index 00000000000..75232b0334d
--- /dev/null
+++ b/tests/ui/empty_drop.rs
@@ -0,0 +1,30 @@
+// run-rustfix
+#![warn(clippy::empty_drop)]
+#![allow(unused)]
+
+// should cause an error
+struct Foo;
+
+impl Drop for Foo {
+    fn drop(&mut self) {}
+}
+
+// shouldn't cause an error
+struct Bar;
+
+impl Drop for Bar {
+    fn drop(&mut self) {
+        println!("dropping bar!");
+    }
+}
+
+// should error
+struct Baz;
+
+impl Drop for Baz {
+    fn drop(&mut self) {
+        {}
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/empty_drop.stderr b/tests/ui/empty_drop.stderr
new file mode 100644
index 00000000000..70f7880d036
--- /dev/null
+++ b/tests/ui/empty_drop.stderr
@@ -0,0 +1,22 @@
+error: empty drop implementation
+  --> $DIR/empty_drop.rs:8:1
+   |
+LL | / impl Drop for Foo {
+LL | |     fn drop(&mut self) {}
+LL | | }
+   | |_^ help: try removing this impl
+   |
+   = note: `-D clippy::empty-drop` implied by `-D warnings`
+
+error: empty drop implementation
+  --> $DIR/empty_drop.rs:24:1
+   |
+LL | / impl Drop for Baz {
+LL | |     fn drop(&mut self) {
+LL | |         {}
+LL | |     }
+LL | | }
+   | |_^ help: try removing this impl
+
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 4424aa444c2b24c3728e3f09d85bd9b69f57a48d Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Mon, 18 Apr 2022 13:28:23 +0100
Subject: `manual_split_once`: lint manual iteration of `SplitN`

---
 clippy_lints/src/methods/mod.rs        |  22 +++-
 clippy_lints/src/methods/str_splitn.rs | 223 ++++++++++++++++++++++++++++-----
 tests/ui/manual_split_once.fixed       |  96 +++++++++++++-
 tests/ui/manual_split_once.rs          |  96 +++++++++++++-
 tests/ui/manual_split_once.stderr      | 129 ++++++++++++++++++-
 5 files changed, 527 insertions(+), 39 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 23266739645..7a1bf36489a 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -2009,13 +2009,27 @@ declare_clippy_lint! {
     /// ### Example
     /// ```rust,ignore
     /// // Bad
-    ///  let (key, value) = _.splitn(2, '=').next_tuple()?;
-    ///  let value = _.splitn(2, '=').nth(1)?;
+    /// let s = "key=value=add";
+    /// let (key, value) = s.splitn(2, '=').next_tuple()?;
+    /// let value = s.splitn(2, '=').nth(1)?;
     ///
+    /// let mut parts = s.splitn(2, '=');
+    /// let key = parts.next()?;
+    /// let value = parts.next()?;
+    /// ```
+    /// Use instead:
+    /// ```rust,ignore
     /// // Good
-    /// let (key, value) = _.split_once('=')?;
-    /// let value = _.split_once('=')?.1;
+    /// let s = "key=value=add";
+    /// let (key, value) = s.split_once('=')?;
+    /// let value = s.split_once('=')?.1;
+    ///
+    /// let (key, value) = s.split_once('=')?;
     /// ```
+    ///
+    /// ### Limitations
+    /// The multiple statement variant currently only detects `iter.next()?`/`iter.next().unwrap()`
+    /// in two separate `let` statements that immediately follow the `splitn()`
     #[clippy::version = "1.57.0"]
     pub MANUAL_SPLIT_ONCE,
     complexity,
diff --git a/clippy_lints/src/methods/str_splitn.rs b/clippy_lints/src/methods/str_splitn.rs
index 6eaa9eb2ef0..52891eeed06 100644
--- a/clippy_lints/src/methods/str_splitn.rs
+++ b/clippy_lints/src/methods/str_splitn.rs
@@ -1,14 +1,19 @@
 use clippy_utils::consts::{constant, Constant};
-use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::snippet_with_context;
-use clippy_utils::{is_diag_item_method, match_def_path, meets_msrv, msrvs, paths};
+use clippy_utils::usage::local_used_after_expr;
+use clippy_utils::visitors::expr_visitor;
+use clippy_utils::{is_diag_item_method, match_def_path, meets_msrv, msrvs, path_to_local_id, paths};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
-use rustc_hir::{Expr, ExprKind, HirId, LangItem, Node, QPath};
+use rustc_hir::intravisit::Visitor;
+use rustc_hir::{
+    BindingAnnotation, Expr, ExprKind, HirId, LangItem, Local, MatchSource, Node, Pat, PatKind, QPath, Stmt, StmtKind,
+};
 use rustc_lint::LateContext;
 use rustc_middle::ty;
 use rustc_semver::RustcVersion;
-use rustc_span::{symbol::sym, Span, SyntaxContext};
+use rustc_span::{sym, Span, Symbol, SyntaxContext};
 
 use super::{MANUAL_SPLIT_ONCE, NEEDLESS_SPLITN};
 
@@ -25,40 +30,41 @@ pub(super) fn check(
         return;
     }
 
-    let ctxt = expr.span.ctxt();
-    let Some(usage) = parse_iter_usage(cx, ctxt, cx.tcx.hir().parent_iter(expr.hir_id)) else { return };
-
-    let needless = match usage.kind {
+    let needless = |usage_kind| match usage_kind {
         IterUsageKind::Nth(n) => count > n + 1,
         IterUsageKind::NextTuple => count > 2,
     };
+    let manual = count == 2 && meets_msrv(msrv, &msrvs::STR_SPLIT_ONCE);
 
-    if needless {
-        let mut app = Applicability::MachineApplicable;
-        let (r, message) = if method_name == "splitn" {
-            ("", "unnecessary use of `splitn`")
-        } else {
-            ("r", "unnecessary use of `rsplitn`")
-        };
-
-        span_lint_and_sugg(
-            cx,
-            NEEDLESS_SPLITN,
-            expr.span,
-            message,
-            "try this",
-            format!(
-                "{}.{r}split({})",
-                snippet_with_context(cx, self_arg.span, ctxt, "..", &mut app).0,
-                snippet_with_context(cx, pat_arg.span, ctxt, "..", &mut app).0,
-            ),
-            app,
-        );
-    } else if count == 2 && meets_msrv(msrv, &msrvs::STR_SPLIT_ONCE) {
-        check_manual_split_once(cx, method_name, expr, self_arg, pat_arg, &usage);
+    match parse_iter_usage(cx, expr.span.ctxt(), cx.tcx.hir().parent_iter(expr.hir_id)) {
+        Some(usage) if needless(usage.kind) => lint_needless(cx, method_name, expr, self_arg, pat_arg),
+        Some(usage) if manual => check_manual_split_once(cx, method_name, expr, self_arg, pat_arg, &usage),
+        None if manual => {
+            check_manual_split_once_indirect(cx, method_name, expr, self_arg, pat_arg);
+        },
+        _ => {},
     }
 }
 
+fn lint_needless(cx: &LateContext<'_>, method_name: &str, expr: &Expr<'_>, self_arg: &Expr<'_>, pat_arg: &Expr<'_>) {
+    let mut app = Applicability::MachineApplicable;
+    let r = if method_name == "splitn" { "" } else { "r" };
+
+    span_lint_and_sugg(
+        cx,
+        NEEDLESS_SPLITN,
+        expr.span,
+        &format!("unnecessary use of `{r}splitn`"),
+        "try this",
+        format!(
+            "{}.{r}split({})",
+            snippet_with_context(cx, self_arg.span, expr.span.ctxt(), "..", &mut app).0,
+            snippet_with_context(cx, pat_arg.span, expr.span.ctxt(), "..", &mut app).0,
+        ),
+        app,
+    );
+}
+
 fn check_manual_split_once(
     cx: &LateContext<'_>,
     method_name: &str,
@@ -107,16 +113,171 @@ fn check_manual_split_once(
     span_lint_and_sugg(cx, MANUAL_SPLIT_ONCE, usage.span, msg, "try this", sugg, app);
 }
 
+/// checks for
+///
+/// ```
+/// let mut iter = "a.b.c".splitn(2, '.');
+/// let a = iter.next();
+/// let b = iter.next();
+/// ```
+fn check_manual_split_once_indirect(
+    cx: &LateContext<'_>,
+    method_name: &str,
+    expr: &Expr<'_>,
+    self_arg: &Expr<'_>,
+    pat_arg: &Expr<'_>,
+) -> Option<()> {
+    let ctxt = expr.span.ctxt();
+    let mut parents = cx.tcx.hir().parent_iter(expr.hir_id);
+    if let (_, Node::Local(local)) = parents.next()?
+        && let PatKind::Binding(BindingAnnotation::Mutable, iter_binding_id, iter_ident, None) = local.pat.kind
+        && let (iter_stmt_id, Node::Stmt(_)) = parents.next()?
+        && let (_, Node::Block(enclosing_block)) = parents.next()?
+
+        && let mut stmts = enclosing_block
+            .stmts
+            .iter()
+            .skip_while(|stmt| stmt.hir_id != iter_stmt_id)
+            .skip(1)
+
+        && let first = indirect_usage(cx, stmts.next()?, iter_binding_id, ctxt)?
+        && let second = indirect_usage(cx, stmts.next()?, iter_binding_id, ctxt)?
+        && first.unwrap_kind == second.unwrap_kind
+        && first.name != second.name
+        && !local_used_after_expr(cx, iter_binding_id, second.init_expr)
+    {
+        let (r, lhs, rhs) = if method_name == "splitn" {
+            ("", first.name, second.name)
+        } else {
+            ("r", second.name, first.name)
+        };
+        let msg = format!("manual implementation of `{r}split_once`");
+
+        let mut app = Applicability::MachineApplicable;
+        let self_snip = snippet_with_context(cx, self_arg.span, ctxt, "..", &mut app).0;
+        let pat_snip = snippet_with_context(cx, pat_arg.span, ctxt, "..", &mut app).0;
+
+        span_lint_and_then(cx, MANUAL_SPLIT_ONCE, local.span, &msg, |diag| {
+            diag.span_label(first.span, "first usage here");
+            diag.span_label(second.span, "second usage here");
+
+            let unwrap = match first.unwrap_kind {
+                UnwrapKind::Unwrap => ".unwrap()",
+                UnwrapKind::QuestionMark => "?",
+            };
+            diag.span_suggestion_verbose(
+                local.span,
+                &format!("try `{r}split_once`"),
+                format!("let ({lhs}, {rhs}) = {self_snip}.{r}split_once({pat_snip}){unwrap};"),
+                app,
+            );
+
+            let remove_msg = format!("remove the `{iter_ident}` usages");
+            diag.span_suggestion(
+                first.span,
+                &remove_msg,
+                String::new(),
+                app,
+            );
+            diag.span_suggestion(
+                second.span,
+                &remove_msg,
+                String::new(),
+                app,
+            );
+        });
+    }
+
+    Some(())
+}
+
+#[derive(Debug)]
+struct IndirectUsage<'a> {
+    name: Symbol,
+    span: Span,
+    init_expr: &'a Expr<'a>,
+    unwrap_kind: UnwrapKind,
+}
+
+/// returns `Some(IndirectUsage)` for e.g.
+///
+/// ```ignore
+/// let name = binding.next()?;
+/// let name = binding.next().unwrap();
+/// ```
+fn indirect_usage<'tcx>(
+    cx: &LateContext<'tcx>,
+    stmt: &Stmt<'tcx>,
+    binding: HirId,
+    ctxt: SyntaxContext,
+) -> Option<IndirectUsage<'tcx>> {
+    if let StmtKind::Local(Local {
+        pat:
+            Pat {
+                kind: PatKind::Binding(BindingAnnotation::Unannotated, _, ident, None),
+                ..
+            },
+        init: Some(init_expr),
+        hir_id: local_hir_id,
+        ..
+    }) = stmt.kind
+    {
+        let mut path_to_binding = None;
+        expr_visitor(cx, |expr| {
+            if path_to_local_id(expr, binding) {
+                path_to_binding = Some(expr);
+            }
+
+            path_to_binding.is_none()
+        })
+        .visit_expr(init_expr);
+
+        let mut parents = cx.tcx.hir().parent_iter(path_to_binding?.hir_id);
+        let iter_usage = parse_iter_usage(cx, ctxt, &mut parents)?;
+
+        let (parent_id, _) = parents.find(|(_, node)| {
+            !matches!(
+                node,
+                Node::Expr(Expr {
+                    kind: ExprKind::Match(.., MatchSource::TryDesugar),
+                    ..
+                })
+            )
+        })?;
+
+        if let IterUsage {
+            kind: IterUsageKind::Nth(0),
+            unwrap_kind: Some(unwrap_kind),
+            ..
+        } = iter_usage
+        {
+            if parent_id == *local_hir_id {
+                return Some(IndirectUsage {
+                    name: ident.name,
+                    span: stmt.span,
+                    init_expr,
+                    unwrap_kind,
+                });
+            }
+        }
+    }
+
+    None
+}
+
+#[derive(Debug, Clone, Copy)]
 enum IterUsageKind {
     Nth(u128),
     NextTuple,
 }
 
+#[derive(Debug, PartialEq)]
 enum UnwrapKind {
     Unwrap,
     QuestionMark,
 }
 
+#[derive(Debug)]
 struct IterUsage {
     kind: IterUsageKind,
     unwrap_kind: Option<UnwrapKind>,
diff --git a/tests/ui/manual_split_once.fixed b/tests/ui/manual_split_once.fixed
index bffc7b9b631..c7ca770434a 100644
--- a/tests/ui/manual_split_once.fixed
+++ b/tests/ui/manual_split_once.fixed
@@ -2,7 +2,7 @@
 
 #![feature(custom_inner_attributes)]
 #![warn(clippy::manual_split_once)]
-#![allow(clippy::iter_skip_next, clippy::iter_nth_zero)]
+#![allow(unused, clippy::iter_skip_next, clippy::iter_nth_zero)]
 
 extern crate itertools;
 
@@ -41,13 +41,107 @@ fn main() {
     let _ = s.rsplit_once('=').map(|x| x.0);
 }
 
+fn indirect() -> Option<()> {
+    let (l, r) = "a.b.c".split_once('.').unwrap();
+    
+    
+
+    let (l, r) = "a.b.c".split_once('.')?;
+    
+    
+
+    let (l, r) = "a.b.c".rsplit_once('.').unwrap();
+    
+    
+
+    let (l, r) = "a.b.c".rsplit_once('.')?;
+    
+    
+
+    // could lint, currently doesn't
+
+    let mut iter = "a.b.c".splitn(2, '.');
+    let other = 1;
+    let l = iter.next()?;
+    let r = iter.next()?;
+
+    let mut iter = "a.b.c".splitn(2, '.');
+    let mut mut_binding = iter.next()?;
+    let r = iter.next()?;
+
+    let mut iter = "a.b.c".splitn(2, '.');
+    let tuple = (iter.next()?, iter.next()?);
+
+    // should not lint
+
+    let mut missing_unwrap = "a.b.c".splitn(2, '.');
+    let l = missing_unwrap.next();
+    let r = missing_unwrap.next();
+
+    let mut mixed_unrap = "a.b.c".splitn(2, '.');
+    let unwrap = mixed_unrap.next().unwrap();
+    let question_mark = mixed_unrap.next()?;
+
+    let mut iter = "a.b.c".splitn(2, '.');
+    let same_name = iter.next()?;
+    let same_name = iter.next()?;
+
+    let mut iter = "a.b.c".splitn(2, '.');
+    let shadows_existing = "d";
+    let shadows_existing = iter.next()?;
+    let r = iter.next()?;
+
+    let mut iter = "a.b.c".splitn(2, '.');
+    let becomes_shadowed = iter.next()?;
+    let becomes_shadowed = "d";
+    let r = iter.next()?;
+
+    let mut iter = "a.b.c".splitn(2, '.');
+    let l = iter.next()?;
+    let r = iter.next()?;
+    let third_usage = iter.next()?;
+
+    let mut n_three = "a.b.c".splitn(3, '.');
+    let l = n_three.next()?;
+    let r = n_three.next()?;
+
+    let mut iter = "a.b.c".splitn(2, '.');
+    {
+        let in_block = iter.next()?;
+    }
+    let r = iter.next()?;
+
+    let mut lacks_binding = "a.b.c".splitn(2, '.');
+    let _ = lacks_binding.next()?;
+    let r = lacks_binding.next()?;
+
+    let mut mapped = "a.b.c".splitn(2, '.').map(|_| "~");
+    let l = iter.next()?;
+    let r = iter.next()?;
+
+    let mut assigned = "";
+    let mut iter = "a.b.c".splitn(2, '.');
+    let l = iter.next()?;
+    assigned = iter.next()?;
+
+    None
+}
+
 fn _msrv_1_51() {
     #![clippy::msrv = "1.51"]
     // `str::split_once` was stabilized in 1.52. Do not lint this
     let _ = "key=value".splitn(2, '=').nth(1).unwrap();
+
+    let mut iter = "a.b.c".splitn(2, '.');
+    let a = iter.next().unwrap();
+    let b = iter.next().unwrap();
 }
 
 fn _msrv_1_52() {
     #![clippy::msrv = "1.52"]
     let _ = "key=value".split_once('=').unwrap().1;
+
+    let (a, b) = "a.b.c".split_once('.').unwrap();
+    
+    
 }
diff --git a/tests/ui/manual_split_once.rs b/tests/ui/manual_split_once.rs
index 147be7c7ab1..ee2848a251e 100644
--- a/tests/ui/manual_split_once.rs
+++ b/tests/ui/manual_split_once.rs
@@ -2,7 +2,7 @@
 
 #![feature(custom_inner_attributes)]
 #![warn(clippy::manual_split_once)]
-#![allow(clippy::iter_skip_next, clippy::iter_nth_zero)]
+#![allow(unused, clippy::iter_skip_next, clippy::iter_nth_zero)]
 
 extern crate itertools;
 
@@ -41,13 +41,107 @@ fn main() {
     let _ = s.rsplitn(2, '=').nth(1);
 }
 
+fn indirect() -> Option<()> {
+    let mut iter = "a.b.c".splitn(2, '.');
+    let l = iter.next().unwrap();
+    let r = iter.next().unwrap();
+
+    let mut iter = "a.b.c".splitn(2, '.');
+    let l = iter.next()?;
+    let r = iter.next()?;
+
+    let mut iter = "a.b.c".rsplitn(2, '.');
+    let r = iter.next().unwrap();
+    let l = iter.next().unwrap();
+
+    let mut iter = "a.b.c".rsplitn(2, '.');
+    let r = iter.next()?;
+    let l = iter.next()?;
+
+    // could lint, currently doesn't
+
+    let mut iter = "a.b.c".splitn(2, '.');
+    let other = 1;
+    let l = iter.next()?;
+    let r = iter.next()?;
+
+    let mut iter = "a.b.c".splitn(2, '.');
+    let mut mut_binding = iter.next()?;
+    let r = iter.next()?;
+
+    let mut iter = "a.b.c".splitn(2, '.');
+    let tuple = (iter.next()?, iter.next()?);
+
+    // should not lint
+
+    let mut missing_unwrap = "a.b.c".splitn(2, '.');
+    let l = missing_unwrap.next();
+    let r = missing_unwrap.next();
+
+    let mut mixed_unrap = "a.b.c".splitn(2, '.');
+    let unwrap = mixed_unrap.next().unwrap();
+    let question_mark = mixed_unrap.next()?;
+
+    let mut iter = "a.b.c".splitn(2, '.');
+    let same_name = iter.next()?;
+    let same_name = iter.next()?;
+
+    let mut iter = "a.b.c".splitn(2, '.');
+    let shadows_existing = "d";
+    let shadows_existing = iter.next()?;
+    let r = iter.next()?;
+
+    let mut iter = "a.b.c".splitn(2, '.');
+    let becomes_shadowed = iter.next()?;
+    let becomes_shadowed = "d";
+    let r = iter.next()?;
+
+    let mut iter = "a.b.c".splitn(2, '.');
+    let l = iter.next()?;
+    let r = iter.next()?;
+    let third_usage = iter.next()?;
+
+    let mut n_three = "a.b.c".splitn(3, '.');
+    let l = n_three.next()?;
+    let r = n_three.next()?;
+
+    let mut iter = "a.b.c".splitn(2, '.');
+    {
+        let in_block = iter.next()?;
+    }
+    let r = iter.next()?;
+
+    let mut lacks_binding = "a.b.c".splitn(2, '.');
+    let _ = lacks_binding.next()?;
+    let r = lacks_binding.next()?;
+
+    let mut mapped = "a.b.c".splitn(2, '.').map(|_| "~");
+    let l = iter.next()?;
+    let r = iter.next()?;
+
+    let mut assigned = "";
+    let mut iter = "a.b.c".splitn(2, '.');
+    let l = iter.next()?;
+    assigned = iter.next()?;
+
+    None
+}
+
 fn _msrv_1_51() {
     #![clippy::msrv = "1.51"]
     // `str::split_once` was stabilized in 1.52. Do not lint this
     let _ = "key=value".splitn(2, '=').nth(1).unwrap();
+
+    let mut iter = "a.b.c".splitn(2, '.');
+    let a = iter.next().unwrap();
+    let b = iter.next().unwrap();
 }
 
 fn _msrv_1_52() {
     #![clippy::msrv = "1.52"]
     let _ = "key=value".splitn(2, '=').nth(1).unwrap();
+
+    let mut iter = "a.b.c".splitn(2, '.');
+    let a = iter.next().unwrap();
+    let b = iter.next().unwrap();
 }
diff --git a/tests/ui/manual_split_once.stderr b/tests/ui/manual_split_once.stderr
index 9635e6c5e4b..2563a6904b7 100644
--- a/tests/ui/manual_split_once.stderr
+++ b/tests/ui/manual_split_once.stderr
@@ -79,10 +79,135 @@ LL |     let _ = s.rsplitn(2, '=').nth(1);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `s.rsplit_once('=').map(|x| x.0)`
 
 error: manual implementation of `split_once`
-  --> $DIR/manual_split_once.rs:52:13
+  --> $DIR/manual_split_once.rs:45:5
+   |
+LL |     let mut iter = "a.b.c".splitn(2, '.');
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |     let l = iter.next().unwrap();
+   |     ----------------------------- first usage here
+LL |     let r = iter.next().unwrap();
+   |     ----------------------------- second usage here
+   |
+help: try `split_once`
+   |
+LL |     let (l, r) = "a.b.c".split_once('.').unwrap();
+   |
+help: remove the `iter` usages
+   |
+LL -     let l = iter.next().unwrap();
+LL +     
+   | 
+help: remove the `iter` usages
+   |
+LL -     let r = iter.next().unwrap();
+LL +     
+   | 
+
+error: manual implementation of `split_once`
+  --> $DIR/manual_split_once.rs:49:5
+   |
+LL |     let mut iter = "a.b.c".splitn(2, '.');
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |     let l = iter.next()?;
+   |     --------------------- first usage here
+LL |     let r = iter.next()?;
+   |     --------------------- second usage here
+   |
+help: try `split_once`
+   |
+LL |     let (l, r) = "a.b.c".split_once('.')?;
+   |
+help: remove the `iter` usages
+   |
+LL -     let l = iter.next()?;
+LL +     
+   | 
+help: remove the `iter` usages
+   |
+LL -     let r = iter.next()?;
+LL +     
+   | 
+
+error: manual implementation of `rsplit_once`
+  --> $DIR/manual_split_once.rs:53:5
+   |
+LL |     let mut iter = "a.b.c".rsplitn(2, '.');
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |     let r = iter.next().unwrap();
+   |     ----------------------------- first usage here
+LL |     let l = iter.next().unwrap();
+   |     ----------------------------- second usage here
+   |
+help: try `rsplit_once`
+   |
+LL |     let (l, r) = "a.b.c".rsplit_once('.').unwrap();
+   |
+help: remove the `iter` usages
+   |
+LL -     let r = iter.next().unwrap();
+LL +     
+   | 
+help: remove the `iter` usages
+   |
+LL -     let l = iter.next().unwrap();
+LL +     
+   | 
+
+error: manual implementation of `rsplit_once`
+  --> $DIR/manual_split_once.rs:57:5
+   |
+LL |     let mut iter = "a.b.c".rsplitn(2, '.');
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |     let r = iter.next()?;
+   |     --------------------- first usage here
+LL |     let l = iter.next()?;
+   |     --------------------- second usage here
+   |
+help: try `rsplit_once`
+   |
+LL |     let (l, r) = "a.b.c".rsplit_once('.')?;
+   |
+help: remove the `iter` usages
+   |
+LL -     let r = iter.next()?;
+LL +     
+   | 
+help: remove the `iter` usages
+   |
+LL -     let l = iter.next()?;
+LL +     
+   | 
+
+error: manual implementation of `split_once`
+  --> $DIR/manual_split_once.rs:142:13
    |
 LL |     let _ = "key=value".splitn(2, '=').nth(1).unwrap();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `"key=value".split_once('=').unwrap().1`
 
-error: aborting due to 14 previous errors
+error: manual implementation of `split_once`
+  --> $DIR/manual_split_once.rs:144:5
+   |
+LL |     let mut iter = "a.b.c".splitn(2, '.');
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |     let a = iter.next().unwrap();
+   |     ----------------------------- first usage here
+LL |     let b = iter.next().unwrap();
+   |     ----------------------------- second usage here
+   |
+help: try `split_once`
+   |
+LL |     let (a, b) = "a.b.c".split_once('.').unwrap();
+   |
+help: remove the `iter` usages
+   |
+LL -     let a = iter.next().unwrap();
+LL +     
+   | 
+help: remove the `iter` usages
+   |
+LL -     let b = iter.next().unwrap();
+LL +     
+   | 
+
+error: aborting due to 19 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 14667d147417546cee9f4c8ae8aa78f71e371e6c Mon Sep 17 00:00:00 2001
From: Serial <69764315+Serial-ATA@users.noreply.github.com>
Date: Thu, 21 Apr 2022 13:42:55 -0400
Subject: Fix missing whitespace in `collapsible_else_if` suggestion

---
 clippy_lints/src/collapsible_if.rs  | 18 ++++++++++++++----
 tests/ui/collapsible_else_if.fixed  |  7 +++++++
 tests/ui/collapsible_else_if.rs     |  9 +++++++++
 tests/ui/collapsible_else_if.stderr | 11 ++++++++++-
 4 files changed, 40 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/collapsible_if.rs b/clippy_lints/src/collapsible_if.rs
index eae2723a7da..3227e6e86af 100644
--- a/clippy_lints/src/collapsible_if.rs
+++ b/clippy_lints/src/collapsible_if.rs
@@ -13,13 +13,14 @@
 //! This lint is **warn** by default
 
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
-use clippy_utils::source::{snippet_block, snippet_block_with_applicability};
+use clippy_utils::source::{snippet, snippet_block, snippet_block_with_applicability};
 use clippy_utils::sugg::Sugg;
 use if_chain::if_chain;
 use rustc_ast::ast;
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::Span;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -102,7 +103,7 @@ impl EarlyLintPass for CollapsibleIf {
 fn check_if(cx: &EarlyContext<'_>, expr: &ast::Expr) {
     if let ast::ExprKind::If(check, then, else_) = &expr.kind {
         if let Some(else_) = else_ {
-            check_collapsible_maybe_if_let(cx, else_);
+            check_collapsible_maybe_if_let(cx, then.span, else_);
         } else if let ast::ExprKind::Let(..) = check.kind {
             // Prevent triggering on `if let a = b { if c { .. } }`.
         } else {
@@ -119,7 +120,7 @@ fn block_starts_with_comment(cx: &EarlyContext<'_>, expr: &ast::Block) -> bool {
     trimmed_block_text.starts_with("//") || trimmed_block_text.starts_with("/*")
 }
 
-fn check_collapsible_maybe_if_let(cx: &EarlyContext<'_>, else_: &ast::Expr) {
+fn check_collapsible_maybe_if_let(cx: &EarlyContext<'_>, then_span: Span, else_: &ast::Expr) {
     if_chain! {
         if let ast::ExprKind::Block(ref block, _) = else_.kind;
         if !block_starts_with_comment(cx, block);
@@ -128,6 +129,11 @@ fn check_collapsible_maybe_if_let(cx: &EarlyContext<'_>, else_: &ast::Expr) {
         if !else_.span.from_expansion();
         if let ast::ExprKind::If(..) = else_.kind;
         then {
+            // Prevent "elseif"
+            // Check that the "else" is followed by whitespace
+            let up_to_else = then_span.between(block.span);
+            let requires_space = if let Some(c) = snippet(cx, up_to_else, "..").chars().last() { !c.is_whitespace() } else { false };
+
             let mut applicability = Applicability::MachineApplicable;
             span_lint_and_sugg(
                 cx,
@@ -135,7 +141,11 @@ fn check_collapsible_maybe_if_let(cx: &EarlyContext<'_>, else_: &ast::Expr) {
                 block.span,
                 "this `else { if .. }` block can be collapsed",
                 "collapse nested if block",
-                snippet_block_with_applicability(cx, else_.span, "..", Some(block.span), &mut applicability).into_owned(),
+                format!(
+                    "{}{}",
+                    if requires_space { " " } else { "" },
+                    snippet_block_with_applicability(cx, else_.span, "..", Some(block.span), &mut applicability)
+                ),
                 applicability,
             );
         }
diff --git a/tests/ui/collapsible_else_if.fixed b/tests/ui/collapsible_else_if.fixed
index bb6c4c0703d..d6a5a785067 100644
--- a/tests/ui/collapsible_else_if.fixed
+++ b/tests/ui/collapsible_else_if.fixed
@@ -75,3 +75,10 @@ fn main() {
         }
     }
 }
+
+#[rustfmt::skip]
+#[allow(dead_code)]
+fn issue_7318() {
+    if true { println!("I've been resolved!")
+    }else if false {}
+}
diff --git a/tests/ui/collapsible_else_if.rs b/tests/ui/collapsible_else_if.rs
index 6d4f688db8c..4399fc8b2bd 100644
--- a/tests/ui/collapsible_else_if.rs
+++ b/tests/ui/collapsible_else_if.rs
@@ -89,3 +89,12 @@ fn main() {
         }
     }
 }
+
+#[rustfmt::skip]
+#[allow(dead_code)]
+fn issue_7318() {
+    if true { println!("I've been resolved!")
+    }else{
+        if false {}
+    }
+}
diff --git a/tests/ui/collapsible_else_if.stderr b/tests/ui/collapsible_else_if.stderr
index 6970f660979..45b2094c994 100644
--- a/tests/ui/collapsible_else_if.stderr
+++ b/tests/ui/collapsible_else_if.stderr
@@ -150,5 +150,14 @@ LL +         println!("!")
 LL +     }
    |
 
-error: aborting due to 7 previous errors
+error: this `else { if .. }` block can be collapsed
+  --> $DIR/collapsible_else_if.rs:97:10
+   |
+LL |       }else{
+   |  __________^
+LL | |         if false {}
+LL | |     }
+   | |_____^ help: collapse nested if block: `if false {}`
+
+error: aborting due to 8 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From f20e890a4b53848771f2041312cd52d31fb015bc Mon Sep 17 00:00:00 2001
From: Serial <69764315+Serial-ATA@users.noreply.github.com>
Date: Fri, 22 Apr 2022 18:03:23 -0400
Subject: Add macro export exemption to `redundant_pub_crate`

---
 clippy_lints/src/redundant_pub_crate.rs | 19 +++++++++++++++++--
 tests/ui/redundant_pub_crate.fixed      | 10 ++++++++++
 tests/ui/redundant_pub_crate.rs         | 10 ++++++++++
 3 files changed, 37 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/redundant_pub_crate.rs b/clippy_lints/src/redundant_pub_crate.rs
index 2cee3c14d7f..3e6086d56f0 100644
--- a/clippy_lints/src/redundant_pub_crate.rs
+++ b/clippy_lints/src/redundant_pub_crate.rs
@@ -1,8 +1,10 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use rustc_errors::Applicability;
+use rustc_hir::def::{DefKind, Res};
 use rustc_hir::{Item, ItemKind, VisibilityKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::hygiene::MacroKind;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -41,8 +43,11 @@ impl_lint_pass!(RedundantPubCrate => [REDUNDANT_PUB_CRATE]);
 
 impl<'tcx> LateLintPass<'tcx> for RedundantPubCrate {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
-        if let VisibilityKind::Crate { .. } = item.vis.node {
-            if !cx.access_levels.is_exported(item.def_id) && self.is_exported.last() == Some(&false) {
+        if_chain! {
+            if let VisibilityKind::Crate { .. } = item.vis.node;
+            if !cx.access_levels.is_exported(item.def_id) && self.is_exported.last() == Some(&false);
+            if is_not_macro_export(item);
+            then {
                 let span = item.span.with_hi(item.ident.span.hi());
                 let descr = cx.tcx.def_kind(item.def_id).descr(item.def_id.to_def_id());
                 span_lint_and_then(
@@ -73,3 +78,13 @@ impl<'tcx> LateLintPass<'tcx> for RedundantPubCrate {
         }
     }
 }
+
+fn is_not_macro_export<'tcx>(item: &'tcx Item<'tcx>) -> bool {
+    if let ItemKind::Use(path, _) = item.kind {
+        if let Res::Def(DefKind::Macro(MacroKind::Bang), _) = path.res {
+            return false;
+        }
+    }
+
+    true
+}
diff --git a/tests/ui/redundant_pub_crate.fixed b/tests/ui/redundant_pub_crate.fixed
index 25f2fd061b8..106947de68c 100644
--- a/tests/ui/redundant_pub_crate.fixed
+++ b/tests/ui/redundant_pub_crate.fixed
@@ -104,4 +104,14 @@ mod m4 {
 
 pub use m4::*;
 
+mod issue_8732 {
+    #[allow(unused_macros)]
+    macro_rules! some_macro {
+        () => {};
+    }
+
+    #[allow(unused_imports)]
+    pub(crate) use some_macro; // ok: macro exports are exempt
+}
+
 fn main() {}
diff --git a/tests/ui/redundant_pub_crate.rs b/tests/ui/redundant_pub_crate.rs
index 616286b4f39..f96cfd31843 100644
--- a/tests/ui/redundant_pub_crate.rs
+++ b/tests/ui/redundant_pub_crate.rs
@@ -104,4 +104,14 @@ mod m4 {
 
 pub use m4::*;
 
+mod issue_8732 {
+    #[allow(unused_macros)]
+    macro_rules! some_macro {
+        () => {};
+    }
+
+    #[allow(unused_imports)]
+    pub(crate) use some_macro; // ok: macro exports are exempt
+}
+
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From b35c04f7dc8febef216b17209d030bd239c19f2c Mon Sep 17 00:00:00 2001
From: "Samuel E. Moelius III" <sam@moeli.us>
Date: Fri, 22 Apr 2022 20:05:18 -0400
Subject: Extend `extra_unused_lifetimes` to handle impl lifetimes

---
 clippy_lints/src/lifetimes.rs          | 65 ++++++++++++++++++++++++++++++----
 tests/ui/crashes/ice-2865.rs           |  2 +-
 tests/ui/crashes/ice-3151.rs           |  2 +-
 tests/ui/extra_unused_lifetimes.rs     | 16 +++++++++
 tests/ui/extra_unused_lifetimes.stderr | 20 ++++++++++-
 tests/ui/impl.rs                       |  2 +-
 tests/ui/new_without_default.rs        |  2 +-
 7 files changed, 97 insertions(+), 12 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lifetimes.rs b/clippy_lints/src/lifetimes.rs
index b09c23f31e9..ec74b8606d9 100644
--- a/clippy_lints/src/lifetimes.rs
+++ b/clippy_lints/src/lifetimes.rs
@@ -1,16 +1,19 @@
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::trait_ref_of_method;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
+use rustc_hir::intravisit::nested_filter::{self as hir_nested_filter, NestedFilter};
 use rustc_hir::intravisit::{
-    walk_fn_decl, walk_generic_param, walk_generics, walk_item, walk_param_bound, walk_poly_trait_ref, walk_ty, Visitor,
+    walk_fn_decl, walk_generic_param, walk_generics, walk_impl_item_ref, walk_item, walk_param_bound,
+    walk_poly_trait_ref, walk_trait_ref, walk_ty, Visitor,
 };
 use rustc_hir::FnRetTy::Return;
 use rustc_hir::{
-    BareFnTy, BodyId, FnDecl, GenericArg, GenericBound, GenericParam, GenericParamKind, Generics, ImplItem,
+    BareFnTy, BodyId, FnDecl, GenericArg, GenericBound, GenericParam, GenericParamKind, Generics, Impl, ImplItem,
     ImplItemKind, Item, ItemKind, LangItem, Lifetime, LifetimeName, ParamName, PolyTraitRef, TraitBoundModifier,
     TraitFn, TraitItem, TraitItemKind, Ty, TyKind, WhereClause, WherePredicate,
 };
 use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::hir::nested_filter as mir_nested_filter;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
 use rustc_span::symbol::{kw, Ident, Symbol};
@@ -84,6 +87,8 @@ impl<'tcx> LateLintPass<'tcx> for Lifetimes {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
         if let ItemKind::Fn(ref sig, ref generics, id) = item.kind {
             check_fn_inner(cx, sig.decl, Some(id), None, generics, item.span, true);
+        } else if let ItemKind::Impl(ref impl_) = item.kind {
+            report_extra_impl_lifetimes(cx, impl_);
         }
     }
 
@@ -194,8 +199,7 @@ fn explicit_self_type<'tcx>(cx: &LateContext<'tcx>, func: &FnDecl<'tcx>, ident:
             visitor.visit_ty(self_ty);
 
             !visitor.all_lts().is_empty()
-        }
-        else {
+        } else {
             false
         }
     }
@@ -481,11 +485,29 @@ fn has_where_lifetimes<'tcx>(cx: &LateContext<'tcx>, where_clause: &'tcx WhereCl
     false
 }
 
-struct LifetimeChecker {
+struct LifetimeChecker<'cx, 'tcx, F> {
+    cx: &'cx LateContext<'tcx>,
     map: FxHashMap<Symbol, Span>,
+    phantom: std::marker::PhantomData<F>,
 }
 
-impl<'tcx> Visitor<'tcx> for LifetimeChecker {
+impl<'cx, 'tcx, F> LifetimeChecker<'cx, 'tcx, F> {
+    fn new(cx: &'cx LateContext<'tcx>, map: FxHashMap<Symbol, Span>) -> LifetimeChecker<'cx, 'tcx, F> {
+        Self {
+            cx,
+            map,
+            phantom: std::marker::PhantomData,
+        }
+    }
+}
+
+impl<'cx, 'tcx, F> Visitor<'tcx> for LifetimeChecker<'cx, 'tcx, F>
+where
+    F: NestedFilter<'tcx>,
+{
+    type Map = rustc_middle::hir::map::Map<'tcx>;
+    type NestedFilter = F;
+
     // for lifetimes as parameters of generics
     fn visit_lifetime(&mut self, lifetime: &'tcx Lifetime) {
         self.map.remove(&lifetime.name.ident().name);
@@ -501,6 +523,10 @@ impl<'tcx> Visitor<'tcx> for LifetimeChecker {
             walk_generic_param(self, param);
         }
     }
+
+    fn nested_visit_map(&mut self) -> Self::Map {
+        self.cx.tcx.hir()
+    }
 }
 
 fn report_extra_lifetimes<'tcx>(cx: &LateContext<'tcx>, func: &'tcx FnDecl<'_>, generics: &'tcx Generics<'_>) {
@@ -512,7 +538,7 @@ fn report_extra_lifetimes<'tcx>(cx: &LateContext<'tcx>, func: &'tcx FnDecl<'_>,
             _ => None,
         })
         .collect();
-    let mut checker = LifetimeChecker { map: hs };
+    let mut checker = LifetimeChecker::<hir_nested_filter::None>::new(cx, hs);
 
     walk_generics(&mut checker, generics);
     walk_fn_decl(&mut checker, func);
@@ -527,6 +553,31 @@ fn report_extra_lifetimes<'tcx>(cx: &LateContext<'tcx>, func: &'tcx FnDecl<'_>,
     }
 }
 
+fn report_extra_impl_lifetimes<'tcx>(cx: &LateContext<'tcx>, impl_: &'tcx Impl<'_>) {
+    let hs = impl_
+        .generics
+        .params
+        .iter()
+        .filter_map(|par| match par.kind {
+            GenericParamKind::Lifetime { .. } => Some((par.name.ident().name, par.span)),
+            _ => None,
+        })
+        .collect();
+    let mut checker = LifetimeChecker::<mir_nested_filter::All>::new(cx, hs);
+
+    if let Some(ref trait_ref) = impl_.of_trait {
+        walk_trait_ref(&mut checker, trait_ref);
+    }
+    walk_ty(&mut checker, impl_.self_ty);
+    for item in impl_.items {
+        walk_impl_item_ref(&mut checker, item);
+    }
+
+    for &v in checker.map.values() {
+        span_lint(cx, EXTRA_UNUSED_LIFETIMES, v, "this lifetime isn't used in the impl");
+    }
+}
+
 struct BodyLifetimeChecker {
     lifetimes_used_in_body: bool,
 }
diff --git a/tests/ui/crashes/ice-2865.rs b/tests/ui/crashes/ice-2865.rs
index 6b1ceb50569..c6298139601 100644
--- a/tests/ui/crashes/ice-2865.rs
+++ b/tests/ui/crashes/ice-2865.rs
@@ -1,4 +1,4 @@
-#[allow(dead_code)]
+#![allow(dead_code, clippy::extra_unused_lifetimes)]
 
 /// Test for https://github.com/rust-lang/rust-clippy/issues/2865
 
diff --git a/tests/ui/crashes/ice-3151.rs b/tests/ui/crashes/ice-3151.rs
index fef4d7db84d..268ba86fc7a 100644
--- a/tests/ui/crashes/ice-3151.rs
+++ b/tests/ui/crashes/ice-3151.rs
@@ -1,4 +1,4 @@
-/// Test for https://github.com/rust-lang/rust-clippy/issues/2865
+/// Test for https://github.com/rust-lang/rust-clippy/issues/3151
 
 #[derive(Clone)]
 pub struct HashMap<V, S> {
diff --git a/tests/ui/extra_unused_lifetimes.rs b/tests/ui/extra_unused_lifetimes.rs
index 150acfbfee7..69dc2f7965e 100644
--- a/tests/ui/extra_unused_lifetimes.rs
+++ b/tests/ui/extra_unused_lifetimes.rs
@@ -72,4 +72,20 @@ mod issue4291 {
     }
 }
 
+mod issue6437 {
+    pub struct Scalar;
+
+    impl<'a> std::ops::AddAssign<&Scalar> for &mut Scalar {
+        fn add_assign(&mut self, _rhs: &Scalar) {
+            unimplemented!();
+        }
+    }
+
+    impl<'b> Scalar {
+        pub fn something<'c>() -> Self {
+            Self
+        }
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/extra_unused_lifetimes.stderr b/tests/ui/extra_unused_lifetimes.stderr
index ebdb8e74952..68f02c7ad0f 100644
--- a/tests/ui/extra_unused_lifetimes.stderr
+++ b/tests/ui/extra_unused_lifetimes.stderr
@@ -24,5 +24,23 @@ error: this lifetime isn't used in the function definition
 LL |         fn unused_lt<'a>(x: u8) {}
    |                      ^^
 
-error: aborting due to 4 previous errors
+error: this lifetime isn't used in the impl
+  --> $DIR/extra_unused_lifetimes.rs:78:10
+   |
+LL |     impl<'a> std::ops::AddAssign<&Scalar> for &mut Scalar {
+   |          ^^
+
+error: this lifetime isn't used in the impl
+  --> $DIR/extra_unused_lifetimes.rs:84:10
+   |
+LL |     impl<'b> Scalar {
+   |          ^^
+
+error: this lifetime isn't used in the function definition
+  --> $DIR/extra_unused_lifetimes.rs:85:26
+   |
+LL |         pub fn something<'c>() -> Self {
+   |                          ^^
+
+error: aborting due to 7 previous errors
 
diff --git a/tests/ui/impl.rs b/tests/ui/impl.rs
index 39443775015..aea52a852f9 100644
--- a/tests/ui/impl.rs
+++ b/tests/ui/impl.rs
@@ -1,4 +1,4 @@
-#![allow(dead_code)]
+#![allow(dead_code, clippy::extra_unused_lifetimes)]
 #![warn(clippy::multiple_inherent_impl)]
 
 struct MyStruct;
diff --git a/tests/ui/new_without_default.rs b/tests/ui/new_without_default.rs
index e94f99c95f4..538927b1805 100644
--- a/tests/ui/new_without_default.rs
+++ b/tests/ui/new_without_default.rs
@@ -1,4 +1,4 @@
-#![allow(dead_code, clippy::missing_safety_doc)]
+#![allow(dead_code, clippy::missing_safety_doc, clippy::extra_unused_lifetimes)]
 #![warn(clippy::new_without_default)]
 
 pub struct Foo;
-- 
cgit 1.4.1-3-g733a5


From 0c164bbfdbe92e4a3732fc4d318e4eb85c843a1f Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Sat, 23 Apr 2022 12:23:18 +0100
Subject: ignore `redundant_pub_crate` in `useless_attribute`

---
 clippy_lints/src/attrs.rs         | 13 ++++++-------
 tests/ui/useless_attribute.fixed  |  6 ++++++
 tests/ui/useless_attribute.rs     |  6 ++++++
 tests/ui/useless_attribute.stderr |  2 +-
 4 files changed, 19 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs
index d0b03c0a9c2..e880876218e 100644
--- a/clippy_lints/src/attrs.rs
+++ b/clippy_lints/src/attrs.rs
@@ -335,9 +335,6 @@ impl<'tcx> LateLintPass<'tcx> for Attributes {
                     }
                     if let Some(lint_list) = &attr.meta_item_list() {
                         if attr.ident().map_or(false, |ident| is_lint_level(ident.name)) {
-                            // permit `unused_imports`, `deprecated`, `unreachable_pub`,
-                            // `clippy::wildcard_imports`, and `clippy::enum_glob_use` for `use` items
-                            // and `unused_imports` for `extern crate` items with `macro_use`
                             for lint in lint_list {
                                 match item.kind {
                                     ItemKind::Use(..) => {
@@ -345,10 +342,12 @@ impl<'tcx> LateLintPass<'tcx> for Attributes {
                                             || is_word(lint, sym::deprecated)
                                             || is_word(lint, sym!(unreachable_pub))
                                             || is_word(lint, sym!(unused))
-                                            || extract_clippy_lint(lint)
-                                                .map_or(false, |s| s.as_str() == "wildcard_imports")
-                                            || extract_clippy_lint(lint)
-                                                .map_or(false, |s| s.as_str() == "enum_glob_use")
+                                            || extract_clippy_lint(lint).map_or(false, |s| {
+                                                matches!(
+                                                    s.as_str(),
+                                                    "wildcard_imports" | "enum_glob_use" | "redundant_pub_crate",
+                                                )
+                                            })
                                         {
                                             return;
                                         }
diff --git a/tests/ui/useless_attribute.fixed b/tests/ui/useless_attribute.fixed
index ce58a80347b..c23231a99e9 100644
--- a/tests/ui/useless_attribute.fixed
+++ b/tests/ui/useless_attribute.fixed
@@ -57,6 +57,12 @@ pub use std::io::prelude::*;
 #[allow(clippy::enum_glob_use)]
 pub use std::cmp::Ordering::*;
 
+// don't lint on clippy::redundant_pub_crate
+mod c {
+    #[allow(clippy::redundant_pub_crate)]
+    pub(crate) struct S;
+}
+
 fn test_indented_attr() {
     #![allow(clippy::almost_swapped)]
     use std::collections::HashSet;
diff --git a/tests/ui/useless_attribute.rs b/tests/ui/useless_attribute.rs
index c82bb9ba07f..7a7b198ea60 100644
--- a/tests/ui/useless_attribute.rs
+++ b/tests/ui/useless_attribute.rs
@@ -57,6 +57,12 @@ pub use std::io::prelude::*;
 #[allow(clippy::enum_glob_use)]
 pub use std::cmp::Ordering::*;
 
+// don't lint on clippy::redundant_pub_crate
+mod c {
+    #[allow(clippy::redundant_pub_crate)]
+    pub(crate) struct S;
+}
+
 fn test_indented_attr() {
     #[allow(clippy::almost_swapped)]
     use std::collections::HashSet;
diff --git a/tests/ui/useless_attribute.stderr b/tests/ui/useless_attribute.stderr
index d0194e4bbbe..255d2876355 100644
--- a/tests/ui/useless_attribute.stderr
+++ b/tests/ui/useless_attribute.stderr
@@ -13,7 +13,7 @@ LL | #[cfg_attr(feature = "cargo-clippy", allow(dead_code))]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: if you just forgot a `!`, use: `#![cfg_attr(feature = "cargo-clippy", allow(dead_code)`
 
 error: useless lint attribute
-  --> $DIR/useless_attribute.rs:61:5
+  --> $DIR/useless_attribute.rs:67:5
    |
 LL |     #[allow(clippy::almost_swapped)]
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: if you just forgot a `!`, use: `#![allow(clippy::almost_swapped)]`
-- 
cgit 1.4.1-3-g733a5


From 51db157fb4c44212fec54d61af19f80bd4335286 Mon Sep 17 00:00:00 2001
From: tamaron <tamaron1203@gmail.com>
Date: Sat, 23 Apr 2022 22:45:26 +0900
Subject: fix

---
 clippy_lints/src/methods/mod.rs                   | 18 +++++++++---------
 clippy_lints/src/methods/wrong_self_convention.rs |  2 +-
 tests/ui/wrong_self_convention.rs                 |  5 -----
 tests/ui/wrong_self_convention.stderr             | 18 +++++-------------
 tests/ui/wrong_self_convention2.rs                | 10 ++++++++++
 5 files changed, 25 insertions(+), 28 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 7a1bf36489a..f3be71f6b8b 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -296,15 +296,15 @@ declare_clippy_lint! {
     /// Checks for methods with certain name prefixes and which
     /// doesn't match how self is taken. The actual rules are:
     ///
-    /// |Prefix |Postfix     |`self` taken           | `self` type  |
-    /// |-------|------------|-----------------------|--------------|
-    /// |`as_`  | none       |`&self` or `&mut self` | any          |
-    /// |`from_`| none       | none                  | any          |
-    /// |`into_`| none       |`self`                 | any          |
-    /// |`is_`  | none       |`&self` or none        | any          |
-    /// |`to_`  | `_mut`     |`&mut self`            | any          |
-    /// |`to_`  | not `_mut` |`self`                 | `Copy`       |
-    /// |`to_`  | not `_mut` |`&self`                | not `Copy`   |
+    /// |Prefix |Postfix     |`self` taken                   | `self` type  |
+    /// |-------|------------|-------------------------------|--------------|
+    /// |`as_`  | none       |`&self` or `&mut self`         | any          |
+    /// |`from_`| none       | none                          | any          |
+    /// |`into_`| none       |`self`                         | any          |
+    /// |`is_`  | none       |`&mut self` or `&self` or none | any          |
+    /// |`to_`  | `_mut`     |`&mut self`                    | any          |
+    /// |`to_`  | not `_mut` |`self`                         | `Copy`       |
+    /// |`to_`  | not `_mut` |`&self`                        | not `Copy`   |
     ///
     /// Note: Clippy doesn't trigger methods with `to_` prefix in:
     /// - Traits definition.
diff --git a/clippy_lints/src/methods/wrong_self_convention.rs b/clippy_lints/src/methods/wrong_self_convention.rs
index aecfea9c141..4b368d3ffae 100644
--- a/clippy_lints/src/methods/wrong_self_convention.rs
+++ b/clippy_lints/src/methods/wrong_self_convention.rs
@@ -14,7 +14,7 @@ const CONVENTIONS: [(&[Convention], &[SelfKind]); 9] = [
     (&[Convention::StartsWith("as_")], &[SelfKind::Ref, SelfKind::RefMut]),
     (&[Convention::StartsWith("from_")], &[SelfKind::No]),
     (&[Convention::StartsWith("into_")], &[SelfKind::Value]),
-    (&[Convention::StartsWith("is_")], &[SelfKind::Ref, SelfKind::No]),
+    (&[Convention::StartsWith("is_")], &[SelfKind::RefMut, SelfKind::Ref, SelfKind::No]),
     (&[Convention::Eq("to_mut")], &[SelfKind::RefMut]),
     (&[Convention::StartsWith("to_"), Convention::EndsWith("_mut")], &[SelfKind::RefMut]),
 
diff --git a/tests/ui/wrong_self_convention.rs b/tests/ui/wrong_self_convention.rs
index f8fee4b3ab2..e3cc90ee222 100644
--- a/tests/ui/wrong_self_convention.rs
+++ b/tests/ui/wrong_self_convention.rs
@@ -193,11 +193,6 @@ pub mod issue8142 {
     struct S;
 
     impl S {
-        // Should lint: is_ methods should only take &self, or no self at all.
-        fn is_still_buggy(&mut self) -> bool {
-            false
-        }
-
         // Should not lint: "no self at all" is allowed.
         fn is_forty_two(x: u32) -> bool {
             x == 42
diff --git a/tests/ui/wrong_self_convention.stderr b/tests/ui/wrong_self_convention.stderr
index 5493a99572e..2e7ee51d7e1 100644
--- a/tests/ui/wrong_self_convention.stderr
+++ b/tests/ui/wrong_self_convention.stderr
@@ -31,7 +31,7 @@ LL |     fn into_i32(&self) {}
    |
    = help: consider choosing a less ambiguous name
 
-error: methods called `is_*` usually take `self` by reference or no `self`
+error: methods called `is_*` usually take `self` by mutable reference or `self` by reference or no `self`
   --> $DIR/wrong_self_convention.rs:38:15
    |
 LL |     fn is_i32(self) {}
@@ -71,7 +71,7 @@ LL |     pub fn into_i64(&self) {}
    |
    = help: consider choosing a less ambiguous name
 
-error: methods called `is_*` usually take `self` by reference or no `self`
+error: methods called `is_*` usually take `self` by mutable reference or `self` by reference or no `self`
   --> $DIR/wrong_self_convention.rs:46:19
    |
 LL |     pub fn is_i64(self) {}
@@ -111,7 +111,7 @@ LL |         fn into_i32_ref(&self) {}
    |
    = help: consider choosing a less ambiguous name
 
-error: methods called `is_*` usually take `self` by reference or no `self`
+error: methods called `is_*` usually take `self` by mutable reference or `self` by reference or no `self`
   --> $DIR/wrong_self_convention.rs:98:19
    |
 LL |         fn is_i32(self) {}
@@ -143,7 +143,7 @@ LL |         fn into_i32_ref(&self);
    |
    = help: consider choosing a less ambiguous name
 
-error: methods called `is_*` usually take `self` by reference or no `self`
+error: methods called `is_*` usually take `self` by mutable reference or `self` by reference or no `self`
   --> $DIR/wrong_self_convention.rs:122:19
    |
 LL |         fn is_i32(self);
@@ -191,13 +191,5 @@ LL |         fn to_u64(self) -> u64 {
    |
    = help: consider choosing a less ambiguous name
 
-error: methods called `is_*` usually take `self` by reference or no `self`
-  --> $DIR/wrong_self_convention.rs:197:27
-   |
-LL |         fn is_still_buggy(&mut self) -> bool {
-   |                           ^^^^^^^^^
-   |
-   = help: consider choosing a less ambiguous name
-
-error: aborting due to 25 previous errors
+error: aborting due to 24 previous errors
 
diff --git a/tests/ui/wrong_self_convention2.rs b/tests/ui/wrong_self_convention2.rs
index a8fe8331133..0dcf4743e8b 100644
--- a/tests/ui/wrong_self_convention2.rs
+++ b/tests/ui/wrong_self_convention2.rs
@@ -104,3 +104,13 @@ mod issue4546 {
         pub fn to_other_thingy(self: Pin<&Self>) {}
     }
 }
+
+mod issue_8480_8513 {
+    struct Cat(String);
+
+    impl Cat {
+        fn is_animal(&mut self) -> bool {
+            todo!();
+        }
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From af9dfa36921a66116e2cbd4a2aeb8f8f7e0082e9 Mon Sep 17 00:00:00 2001
From: asquared31415 <34665709+asquared31415@users.noreply.github.com>
Date: Sat, 23 Apr 2022 12:49:40 -0400
Subject: fix ICE by using a type to return the info we want and also fix some
 bugs in displaying an extra mut when a TypeAndMut was wrong

---
 .../src/casts/cast_slice_different_sizes.rs        | 109 +++++++++++++--------
 tests/ui/cast_slice_different_sizes.rs             |  10 ++
 tests/ui/cast_slice_different_sizes.stderr         |  50 +++++++---
 3 files changed, 113 insertions(+), 56 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/cast_slice_different_sizes.rs b/clippy_lints/src/casts/cast_slice_different_sizes.rs
index ff03f416d0b..893af60db2c 100644
--- a/clippy_lints/src/casts/cast_slice_different_sizes.rs
+++ b/clippy_lints/src/casts/cast_slice_different_sizes.rs
@@ -8,31 +8,6 @@ use rustc_semver::RustcVersion;
 
 use super::CAST_SLICE_DIFFERENT_SIZES;
 
-fn is_child_of_cast(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-    let map = cx.tcx.hir();
-    if_chain! {
-        if let Some(parent_id) = map.find_parent_node(expr.hir_id);
-        if let Some(parent) = map.find(parent_id);
-        then {
-            let expr = match parent {
-                Node::Block(block) => {
-                    if let Some(parent_expr) = block.expr {
-                        parent_expr
-                    } else {
-                        return false;
-                    }
-                },
-                Node::Expr(expr) => expr,
-                _ => return false,
-            };
-
-            matches!(expr.kind, ExprKind::Cast(..))
-        } else {
-            false
-        }
-    }
-}
-
 pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, msrv: &Option<RustcVersion>) {
     // suggestion is invalid if `ptr::slice_from_raw_parts` does not exist
     if !meets_msrv(msrv.as_ref(), &msrvs::PTR_SLICE_RAW_PARTS) {
@@ -45,8 +20,13 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, msrv: &Option<RustcVe
         return;
     }
 
-    if let Some((from_slice_ty, to_slice_ty)) = expr_cast_chain_tys(cx, expr) {
-        if let (Ok(from_layout), Ok(to_layout)) = (cx.layout_of(from_slice_ty.ty), cx.layout_of(to_slice_ty.ty)) {
+    if let Some(CastChainInfo {
+        left_cast,
+        start_ty,
+        end_ty,
+    }) = expr_cast_chain_tys(cx, expr)
+    {
+        if let (Ok(from_layout), Ok(to_layout)) = (cx.layout_of(start_ty.ty), cx.layout_of(end_ty.ty)) {
             let from_size = from_layout.size.bytes();
             let to_size = to_layout.size.bytes();
             if from_size != to_size && from_size != 0 && to_size != 0 {
@@ -56,21 +36,20 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, msrv: &Option<RustcVe
                     expr.span,
                     &format!(
                         "casting between raw pointers to `[{}]` (element size {}) and `[{}]` (element size {}) does not adjust the count",
-                        from_slice_ty, from_size, to_slice_ty, to_size,
+                        start_ty.ty, from_size, end_ty.ty, to_size,
                     ),
                     |diag| {
-                        let cast_expr = match expr.peel_blocks().kind {
-                            ExprKind::Cast(cast_expr, ..) => cast_expr,
-                            _ => unreachable!("expr should be a cast as checked by expr_cast_chain_tys"),
-                        };
-                        let ptr_snippet = snippet_opt(cx, cast_expr.span).unwrap();
+                        let ptr_snippet = snippet_opt(cx, left_cast.span).unwrap();
 
-                        let (mutbl_fn_str, mutbl_ptr_str) = match to_slice_ty.mutbl {
+                        let (mutbl_fn_str, mutbl_ptr_str) = match end_ty.mutbl {
                             Mutability::Mut => ("_mut", "mut"),
                             Mutability::Not => ("", "const"),
                         };
                         let sugg = format!(
-                            "core::ptr::slice_from_raw_parts{mutbl_fn_str}({ptr_snippet} as *{mutbl_ptr_str} {to_slice_ty}, ..)"
+                            "core::ptr::slice_from_raw_parts{mutbl_fn_str}({ptr_snippet} as *{mutbl_ptr_str} {}, ..)",
+                            // get just the ty from the TypeAndMut so that the printed type isn't something like `mut
+                            // T`, extract just the `T`
+                            end_ty.ty
                         );
 
                         diag.span_suggestion(
@@ -86,6 +65,31 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, msrv: &Option<RustcVe
     }
 }
 
+fn is_child_of_cast(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+    let map = cx.tcx.hir();
+    if_chain! {
+        if let Some(parent_id) = map.find_parent_node(expr.hir_id);
+        if let Some(parent) = map.find(parent_id);
+        then {
+            let expr = match parent {
+                Node::Block(block) => {
+                    if let Some(parent_expr) = block.expr {
+                        parent_expr
+                    } else {
+                        return false;
+                    }
+                },
+                Node::Expr(expr) => expr,
+                _ => return false,
+            };
+
+            matches!(expr.kind, ExprKind::Cast(..))
+        } else {
+            false
+        }
+    }
+}
+
 /// Returns the type T of the pointed to *const [T] or *mut [T] and the mutability of the slice if
 /// the type is one of those slices
 fn get_raw_slice_ty_mut(ty: Ty<'_>) -> Option<TypeAndMut<'_>> {
@@ -98,18 +102,43 @@ fn get_raw_slice_ty_mut(ty: Ty<'_>) -> Option<TypeAndMut<'_>> {
     }
 }
 
-/// Returns the pair (original ptr T, final ptr U) if the expression is composed of casts
+struct CastChainInfo<'expr, 'tcx> {
+    /// The left most part of the cast chain, or in other words, the first cast in the chain
+    /// Used for diagnostics
+    left_cast: &'expr Expr<'expr>,
+    /// The starting type of the cast chain
+    start_ty: TypeAndMut<'tcx>,
+    /// The final type of the cast chain
+    end_ty: TypeAndMut<'tcx>,
+}
+
+// FIXME(asquared31415): unbounded recursion linear with the number of casts in an expression
+/// Returns a `CastChainInfo` with the left-most cast in the chain and the original ptr T and final
+/// ptr U if the expression is composed of casts.
 /// Returns None if the expr is not a Cast
-fn expr_cast_chain_tys<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>) -> Option<(TypeAndMut<'tcx>, TypeAndMut<'tcx>)> {
+fn expr_cast_chain_tys<'tcx, 'expr>(cx: &LateContext<'tcx>, expr: &Expr<'expr>) -> Option<CastChainInfo<'expr, 'tcx>> {
     if let ExprKind::Cast(cast_expr, _cast_to_hir_ty) = expr.peel_blocks().kind {
         let cast_to = cx.typeck_results().expr_ty(expr);
         let to_slice_ty = get_raw_slice_ty_mut(cast_to)?;
-        if let Some((inner_from_ty, _inner_to_ty)) = expr_cast_chain_tys(cx, cast_expr) {
-            Some((inner_from_ty, to_slice_ty))
+        if let Some(CastChainInfo {
+            left_cast,
+            start_ty,
+            end_ty: _,
+        }) = expr_cast_chain_tys(cx, cast_expr)
+        {
+            Some(CastChainInfo {
+                left_cast,
+                start_ty,
+                end_ty: to_slice_ty,
+            })
         } else {
             let cast_from = cx.typeck_results().expr_ty(cast_expr);
             let from_slice_ty = get_raw_slice_ty_mut(cast_from)?;
-            Some((from_slice_ty, to_slice_ty))
+            Some(CastChainInfo {
+                left_cast: cast_expr,
+                start_ty: from_slice_ty,
+                end_ty: to_slice_ty,
+            })
         }
     } else {
         None
diff --git a/tests/ui/cast_slice_different_sizes.rs b/tests/ui/cast_slice_different_sizes.rs
index 7ec137cc5b2..24d7eb28a19 100644
--- a/tests/ui/cast_slice_different_sizes.rs
+++ b/tests/ui/cast_slice_different_sizes.rs
@@ -62,6 +62,16 @@ fn bar2(x: *mut [u16]) -> *mut [u8] {
     x as _
 }
 
+// constify
+fn bar3(x: *mut [u16]) -> *const [u8] {
+    x as _
+}
+
+// unconstify
+fn bar4(x: *const [u16]) -> *mut [u8] {
+    x as _
+}
+
 // function returns plus blocks
 fn blocks(x: *mut [u16]) -> *mut [u8] {
     ({ x }) as _
diff --git a/tests/ui/cast_slice_different_sizes.stderr b/tests/ui/cast_slice_different_sizes.stderr
index 0e018b62e60..40721dcd05d 100644
--- a/tests/ui/cast_slice_different_sizes.stderr
+++ b/tests/ui/cast_slice_different_sizes.stderr
@@ -46,58 +46,76 @@ error: casting between raw pointers to `[i32]` (element size 4) and `[u8]` (elem
   --> $DIR/cast_slice_different_sizes.rs:38:27
    |
 LL |     let long_chain_loss = r_x as *const [i32] as *const [u32] as *const [u16] as *const [i8] as *const [u8];
-   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with `ptr::slice_from_raw_parts`: `core::ptr::slice_from_raw_parts(r_x as *const [i32] as *const [u32] as *const [u16] as *const [i8] as *const u8, ..)`
+   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with `ptr::slice_from_raw_parts`: `core::ptr::slice_from_raw_parts(r_x as *const [i32] as *const u8, ..)`
 
-error: casting between raw pointers to `[mut u16]` (element size 2) and `[mut u8]` (element size 1) does not adjust the count
+error: casting between raw pointers to `[u16]` (element size 2) and `[u8]` (element size 1) does not adjust the count
   --> $DIR/cast_slice_different_sizes.rs:53:36
    |
 LL |   fn bar(x: *mut [u16]) -> *mut [u8] {
    |  ____________________________________^
 LL | |     x as *mut [u8]
 LL | | }
-   | |_^ help: replace with `ptr::slice_from_raw_parts_mut`: `core::ptr::slice_from_raw_parts_mut(x as *mut mut u8, ..)`
+   | |_^ help: replace with `ptr::slice_from_raw_parts_mut`: `core::ptr::slice_from_raw_parts_mut(x as *mut u8, ..)`
 
-error: casting between raw pointers to `[mut u16]` (element size 2) and `[mut u8]` (element size 1) does not adjust the count
+error: casting between raw pointers to `[u16]` (element size 2) and `[u8]` (element size 1) does not adjust the count
   --> $DIR/cast_slice_different_sizes.rs:57:36
    |
 LL |   fn uwu(x: *mut [u16]) -> *mut [u8] {
    |  ____________________________________^
 LL | |     x as *mut _
 LL | | }
-   | |_^ help: replace with `ptr::slice_from_raw_parts_mut`: `core::ptr::slice_from_raw_parts_mut(x as *mut mut u8, ..)`
+   | |_^ help: replace with `ptr::slice_from_raw_parts_mut`: `core::ptr::slice_from_raw_parts_mut(x as *mut u8, ..)`
 
-error: casting between raw pointers to `[mut u16]` (element size 2) and `[mut u8]` (element size 1) does not adjust the count
+error: casting between raw pointers to `[u16]` (element size 2) and `[u8]` (element size 1) does not adjust the count
   --> $DIR/cast_slice_different_sizes.rs:61:37
    |
 LL |   fn bar2(x: *mut [u16]) -> *mut [u8] {
    |  _____________________________________^
 LL | |     x as _
 LL | | }
-   | |_^ help: replace with `ptr::slice_from_raw_parts_mut`: `core::ptr::slice_from_raw_parts_mut(x as *mut mut u8, ..)`
+   | |_^ help: replace with `ptr::slice_from_raw_parts_mut`: `core::ptr::slice_from_raw_parts_mut(x as *mut u8, ..)`
 
-error: casting between raw pointers to `[mut u16]` (element size 2) and `[mut u8]` (element size 1) does not adjust the count
+error: casting between raw pointers to `[u16]` (element size 2) and `[u8]` (element size 1) does not adjust the count
   --> $DIR/cast_slice_different_sizes.rs:66:39
    |
+LL |   fn bar3(x: *mut [u16]) -> *const [u8] {
+   |  _______________________________________^
+LL | |     x as _
+LL | | }
+   | |_^ help: replace with `ptr::slice_from_raw_parts`: `core::ptr::slice_from_raw_parts(x as *const u8, ..)`
+
+error: casting between raw pointers to `[u16]` (element size 2) and `[u8]` (element size 1) does not adjust the count
+  --> $DIR/cast_slice_different_sizes.rs:71:39
+   |
+LL |   fn bar4(x: *const [u16]) -> *mut [u8] {
+   |  _______________________________________^
+LL | |     x as _
+LL | | }
+   | |_^ help: replace with `ptr::slice_from_raw_parts_mut`: `core::ptr::slice_from_raw_parts_mut(x as *mut u8, ..)`
+
+error: casting between raw pointers to `[u16]` (element size 2) and `[u8]` (element size 1) does not adjust the count
+  --> $DIR/cast_slice_different_sizes.rs:76:39
+   |
 LL |   fn blocks(x: *mut [u16]) -> *mut [u8] {
    |  _______________________________________^
 LL | |     ({ x }) as _
 LL | | }
-   | |_^ help: replace with `ptr::slice_from_raw_parts_mut`: `core::ptr::slice_from_raw_parts_mut(({ x }) as *mut mut u8, ..)`
+   | |_^ help: replace with `ptr::slice_from_raw_parts_mut`: `core::ptr::slice_from_raw_parts_mut(({ x }) as *mut u8, ..)`
 
-error: casting between raw pointers to `[mut u16]` (element size 2) and `[mut u8]` (element size 1) does not adjust the count
-  --> $DIR/cast_slice_different_sizes.rs:70:44
+error: casting between raw pointers to `[u16]` (element size 2) and `[u8]` (element size 1) does not adjust the count
+  --> $DIR/cast_slice_different_sizes.rs:80:44
    |
 LL |   fn more_blocks(x: *mut [u16]) -> *mut [u8] {
    |  ____________________________________________^
 LL | |     { ({ x }) as _ }
 LL | | }
-   | |_^ help: replace with `ptr::slice_from_raw_parts_mut`: `core::ptr::slice_from_raw_parts_mut(({ x }) as *mut mut u8, ..)`
+   | |_^ help: replace with `ptr::slice_from_raw_parts_mut`: `core::ptr::slice_from_raw_parts_mut(({ x }) as *mut u8, ..)`
 
-error: casting between raw pointers to `[mut u16]` (element size 2) and `[mut u8]` (element size 1) does not adjust the count
-  --> $DIR/cast_slice_different_sizes.rs:71:5
+error: casting between raw pointers to `[u16]` (element size 2) and `[u8]` (element size 1) does not adjust the count
+  --> $DIR/cast_slice_different_sizes.rs:81:5
    |
 LL |     { ({ x }) as _ }
-   |     ^^^^^^^^^^^^^^^^ help: replace with `ptr::slice_from_raw_parts_mut`: `core::ptr::slice_from_raw_parts_mut(({ x }) as *mut mut u8, ..)`
+   |     ^^^^^^^^^^^^^^^^ help: replace with `ptr::slice_from_raw_parts_mut`: `core::ptr::slice_from_raw_parts_mut(({ x }) as *mut u8, ..)`
 
-error: aborting due to 12 previous errors
+error: aborting due to 14 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From b3de32ba3cc2985c4e1d890732548a99fd55bba0 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sun, 3 Apr 2022 20:28:47 -0400
Subject: Add `rename_lint` command

---
 clippy_dev/Cargo.toml             |   1 +
 clippy_dev/src/lib.rs             |   1 +
 clippy_dev/src/main.rs            |  33 +++-
 clippy_dev/src/update_lints.rs    | 308 +++++++++++++++++++++++++++++++++++---
 clippy_lints/src/renamed_lints.rs |  50 ++++---
 tests/ui/rename.fixed             |  84 +++++------
 tests/ui/rename.rs                |  84 +++++------
 tests/ui/rename.stderr            | 180 +++++++++++-----------
 8 files changed, 523 insertions(+), 218 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_dev/Cargo.toml b/clippy_dev/Cargo.toml
index 1f2d8adecee..7bca17dc0fd 100644
--- a/clippy_dev/Cargo.toml
+++ b/clippy_dev/Cargo.toml
@@ -4,6 +4,7 @@ version = "0.0.1"
 edition = "2021"
 
 [dependencies]
+aho-corasick = "0.7"
 clap = "2.33"
 indoc = "1.0"
 itertools = "0.10.1"
diff --git a/clippy_dev/src/lib.rs b/clippy_dev/src/lib.rs
index 414b403827d..c4bb0b97e25 100644
--- a/clippy_dev/src/lib.rs
+++ b/clippy_dev/src/lib.rs
@@ -1,3 +1,4 @@
+#![feature(let_chains)]
 #![feature(let_else)]
 #![feature(once_cell)]
 #![feature(rustc_private)]
diff --git a/clippy_dev/src/main.rs b/clippy_dev/src/main.rs
index 30a241c8ba1..b30f67e6959 100644
--- a/clippy_dev/src/main.rs
+++ b/clippy_dev/src/main.rs
@@ -18,9 +18,9 @@ fn main() {
             if matches.is_present("print-only") {
                 update_lints::print_lints();
             } else if matches.is_present("check") {
-                update_lints::run(update_lints::UpdateMode::Check);
+                update_lints::update(update_lints::UpdateMode::Check);
             } else {
-                update_lints::run(update_lints::UpdateMode::Change);
+                update_lints::update(update_lints::UpdateMode::Change);
             }
         },
         ("new_lint", Some(matches)) => {
@@ -30,7 +30,7 @@ fn main() {
                 matches.value_of("category"),
                 matches.is_present("msrv"),
             ) {
-                Ok(_) => update_lints::run(update_lints::UpdateMode::Change),
+                Ok(_) => update_lints::update(update_lints::UpdateMode::Change),
                 Err(e) => eprintln!("Unable to create lint: {}", e),
             }
         },
@@ -59,6 +59,12 @@ fn main() {
             let filename = matches.value_of("filename").unwrap();
             lint::run(filename);
         },
+        ("rename_lint", Some(matches)) => {
+            let old_name = matches.value_of("old_name").unwrap();
+            let new_name = matches.value_of("new_name").unwrap_or(old_name);
+            let uplift = matches.is_present("uplift");
+            update_lints::rename(old_name, new_name, uplift);
+        },
         _ => {},
     }
 }
@@ -232,5 +238,26 @@ fn get_clap_config<'a>() -> ArgMatches<'a> {
                         .help("The path to a file to lint"),
                 ),
         )
+        .subcommand(
+            SubCommand::with_name("rename_lint")
+                .about("Renames the given lint")
+                .arg(
+                    Arg::with_name("old_name")
+                        .index(1)
+                        .required(true)
+                        .help("The name of the lint to rename"),
+                )
+                .arg(
+                    Arg::with_name("new_name")
+                        .index(2)
+                        .required_unless("uplift")
+                        .help("The new name of the lint"),
+                )
+                .arg(
+                    Arg::with_name("uplift")
+                        .long("uplift")
+                        .help("This lint will be uplifted into rustc"),
+                ),
+        )
         .get_matches()
 }
diff --git a/clippy_dev/src/update_lints.rs b/clippy_dev/src/update_lints.rs
index f15b00ecad1..bbce3875e1d 100644
--- a/clippy_dev/src/update_lints.rs
+++ b/clippy_dev/src/update_lints.rs
@@ -1,11 +1,13 @@
-use core::fmt::Write;
+use aho_corasick::AhoCorasickBuilder;
+use core::fmt::Write as _;
 use itertools::Itertools;
 use rustc_lexer::{tokenize, unescape, LiteralKind, TokenKind};
 use std::collections::{HashMap, HashSet};
 use std::ffi::OsStr;
 use std::fs;
-use std::path::Path;
-use walkdir::WalkDir;
+use std::io::{self, Read as _, Seek as _, Write as _};
+use std::path::{Path, PathBuf};
+use walkdir::{DirEntry, WalkDir};
 
 use crate::clippy_project_root;
 
@@ -30,12 +32,19 @@ pub enum UpdateMode {
 /// # Panics
 ///
 /// Panics if a file path could not read from or then written to
-#[allow(clippy::too_many_lines)]
-pub fn run(update_mode: UpdateMode) {
+pub fn update(update_mode: UpdateMode) {
     let (lints, deprecated_lints, renamed_lints) = gather_all();
+    generate_lint_files(update_mode, &lints, &deprecated_lints, &renamed_lints);
+}
 
-    let internal_lints = Lint::internal_lints(&lints);
-    let usable_lints = Lint::usable_lints(&lints);
+fn generate_lint_files(
+    update_mode: UpdateMode,
+    lints: &[Lint],
+    deprecated_lints: &[DeprecatedLint],
+    renamed_lints: &[RenamedLint],
+) {
+    let internal_lints = Lint::internal_lints(lints);
+    let usable_lints = Lint::usable_lints(lints);
     let mut sorted_usable_lints = usable_lints.clone();
     sorted_usable_lints.sort_by_key(|lint| lint.name.clone());
 
@@ -87,7 +96,7 @@ pub fn run(update_mode: UpdateMode) {
     process_file(
         "clippy_lints/src/lib.deprecated.rs",
         update_mode,
-        &gen_deprecated(&deprecated_lints),
+        &gen_deprecated(deprecated_lints),
     );
 
     let all_group_lints = usable_lints.iter().filter(|l| {
@@ -108,10 +117,10 @@ pub fn run(update_mode: UpdateMode) {
         );
     }
 
-    let content = gen_deprecated_lints_test(&deprecated_lints);
+    let content = gen_deprecated_lints_test(deprecated_lints);
     process_file("tests/ui/deprecated.rs", update_mode, &content);
 
-    let content = gen_renamed_lints_test(&renamed_lints);
+    let content = gen_renamed_lints_test(renamed_lints);
     process_file("tests/ui/rename.rs", update_mode, &content);
 }
 
@@ -134,6 +143,209 @@ pub fn print_lints() {
     println!("there are {} lints", usable_lint_count);
 }
 
+/// Runs the `rename_lint` command.
+///
+/// This does the following:
+/// * Adds an entry to `renamed_lints.rs`.
+/// * Renames all lint attributes to the new name (e.g. `#[allow(clippy::lint_name)]`).
+/// * Renames the lint struct to the new name.
+/// * Renames the module containing the lint struct to the new name if it shares a name with the
+///   lint.
+///
+/// # Panics
+/// Panics for the following conditions:
+/// * If a file path could not read from or then written to
+/// * If either lint name has a prefix
+/// * If `old_name` doesn't name an existing lint.
+/// * If `old_name` names a deprecated or renamed lint.
+#[allow(clippy::too_many_lines)]
+pub fn rename(old_name: &str, new_name: &str, uplift: bool) {
+    if let Some((prefix, _)) = old_name.split_once("::") {
+        panic!("`{}` should not contain the `{}` prefix", old_name, prefix);
+    }
+    if let Some((prefix, _)) = new_name.split_once("::") {
+        panic!("`{}` should not contain the `{}` prefix", new_name, prefix);
+    }
+
+    let (mut lints, deprecated_lints, mut renamed_lints) = gather_all();
+    let mut old_lint_index = None;
+    let mut found_new_name = false;
+    for (i, lint) in lints.iter().enumerate() {
+        if lint.name == old_name {
+            old_lint_index = Some(i);
+        } else if lint.name == new_name {
+            found_new_name = true;
+        }
+    }
+    let old_lint_index = old_lint_index.unwrap_or_else(|| panic!("could not find lint `{}`", old_name));
+
+    let lint = RenamedLint {
+        old_name: format!("clippy::{}", old_name),
+        new_name: if uplift {
+            new_name.into()
+        } else {
+            format!("clippy::{}", new_name)
+        },
+    };
+
+    // Renamed lints and deprecated lints shouldn't have been found in the lint list, but check just in
+    // case.
+    assert!(
+        !renamed_lints.iter().any(|l| lint.old_name == l.old_name),
+        "`{}` has already been renamed",
+        old_name
+    );
+    assert!(
+        !deprecated_lints.iter().any(|l| lint.old_name == l.name),
+        "`{}` has already been deprecated",
+        old_name
+    );
+
+    // Update all lint level attributes. (`clippy::lint_name`)
+    for file in WalkDir::new(clippy_project_root())
+        .into_iter()
+        .map(Result::unwrap)
+        .filter(|f| {
+            let name = f.path().file_name();
+            let ext = f.path().extension();
+            (ext == Some(OsStr::new("rs")) || ext == Some(OsStr::new("fixed")))
+                && name != Some(OsStr::new("rename.rs"))
+                && name != Some(OsStr::new("renamed_lints.rs"))
+        })
+    {
+        rewrite_file(file.path(), |s| {
+            replace_ident_like(s, &[(&lint.old_name, &lint.new_name)])
+        });
+    }
+
+    renamed_lints.push(lint);
+    renamed_lints.sort_by(|lhs, rhs| {
+        lhs.new_name
+            .starts_with("clippy::")
+            .cmp(&rhs.new_name.starts_with("clippy::"))
+            .reverse()
+            .then_with(|| lhs.old_name.cmp(&rhs.old_name))
+    });
+
+    write_file(
+        Path::new("clippy_lints/src/renamed_lints.rs"),
+        &gen_renamed_lints_list(&renamed_lints),
+    );
+
+    if uplift {
+        write_file(Path::new("tests/ui/rename.rs"), &gen_renamed_lints_test(&renamed_lints));
+        println!(
+            "`{}` has be uplifted. All the code inside `clippy_lints` related to it needs to be removed manually.",
+            old_name
+        );
+    } else if found_new_name {
+        write_file(Path::new("tests/ui/rename.rs"), &gen_renamed_lints_test(&renamed_lints));
+        println!(
+            "`{}` is already defined. The old linting code inside `clippy_lints` needs to be updated/removed manually.",
+            new_name
+        );
+    } else {
+        // Rename the lint struct and source files sharing a name with the lint.
+        let lint = &mut lints[old_lint_index];
+        let old_name_upper = old_name.to_uppercase();
+        let new_name_upper = new_name.to_uppercase();
+        lint.name = new_name.into();
+
+        // Rename test files. only rename `.stderr` and `.fixed` files if the new test name doesn't exist.
+        if try_rename_file(
+            Path::new(&format!("tests/ui/{}.rs", old_name)),
+            Path::new(&format!("tests/ui/{}.rs", new_name)),
+        ) {
+            try_rename_file(
+                Path::new(&format!("tests/ui/{}.stderr", old_name)),
+                Path::new(&format!("tests/ui/{}.stderr", new_name)),
+            );
+            try_rename_file(
+                Path::new(&format!("tests/ui/{}.fixed", old_name)),
+                Path::new(&format!("tests/ui/{}.fixed", new_name)),
+            );
+        }
+
+        // Try to rename the file containing the lint if the file name matches the lint's name.
+        let replacements;
+        let replacements = if lint.module == old_name
+            && try_rename_file(
+                Path::new(&format!("clippy_lints/src/{}.rs", old_name)),
+                Path::new(&format!("clippy_lints/src/{}.rs", new_name)),
+            ) {
+            // Edit the module name in the lint list. Note there could be multiple lints.
+            for lint in lints.iter_mut().filter(|l| l.module == old_name) {
+                lint.module = new_name.into();
+            }
+            replacements = [(&*old_name_upper, &*new_name_upper), (old_name, new_name)];
+            replacements.as_slice()
+        } else if !lint.module.contains("::")
+            // Catch cases like `methods/lint_name.rs` where the lint is stored in `methods/mod.rs`
+            && try_rename_file(
+                Path::new(&format!("clippy_lints/src/{}/{}.rs", lint.module, old_name)),
+                Path::new(&format!("clippy_lints/src/{}/{}.rs", lint.module, new_name)),
+            )
+        {
+            // Edit the module name in the lint list. Note there could be multiple lints, or none.
+            let renamed_mod = format!("{}::{}", lint.module, old_name);
+            for lint in lints.iter_mut().filter(|l| l.module == renamed_mod) {
+                lint.module = format!("{}::{}", lint.module, new_name);
+            }
+            replacements = [(&*old_name_upper, &*new_name_upper), (old_name, new_name)];
+            replacements.as_slice()
+        } else {
+            replacements = [(&*old_name_upper, &*new_name_upper), ("", "")];
+            &replacements[0..1]
+        };
+
+        // Don't change `clippy_utils/src/renamed_lints.rs` here as it would try to edit the lint being
+        // renamed.
+        for (_, file) in clippy_lints_src_files().filter(|(rel_path, _)| rel_path != OsStr::new("renamed_lints.rs")) {
+            rewrite_file(file.path(), |s| replace_ident_like(s, replacements));
+        }
+
+        generate_lint_files(UpdateMode::Change, &lints, &deprecated_lints, &renamed_lints);
+        println!("{} has been successfully renamed", old_name);
+    }
+
+    println!("note: `cargo uitest` still needs to be run to update the test results");
+}
+
+/// Replace substrings if they aren't bordered by identifier characters. Returns `None` if there
+/// were no replacements.
+fn replace_ident_like(contents: &str, replacements: &[(&str, &str)]) -> Option<String> {
+    fn is_ident_char(c: u8) -> bool {
+        matches!(c, b'a'..=b'z' | b'A'..=b'Z' | b'0'..=b'9' | b'_')
+    }
+
+    let searcher = AhoCorasickBuilder::new()
+        .dfa(true)
+        .match_kind(aho_corasick::MatchKind::LeftmostLongest)
+        .build_with_size::<u16, _, _>(replacements.iter().map(|&(x, _)| x.as_bytes()))
+        .unwrap();
+
+    let mut result = String::with_capacity(contents.len() + 1024);
+    let mut pos = 0;
+    let mut edited = false;
+    for m in searcher.find_iter(contents) {
+        let (old, new) = replacements[m.pattern()];
+        result.push_str(&contents[pos..m.start()]);
+        result.push_str(
+            if !is_ident_char(contents.as_bytes().get(m.start().wrapping_sub(1)).copied().unwrap_or(0))
+                && !is_ident_char(contents.as_bytes().get(m.end()).copied().unwrap_or(0))
+            {
+                edited = true;
+                new
+            } else {
+                old
+            },
+        );
+        pos = m.end();
+    }
+    result.push_str(&contents[pos..]);
+    edited.then(|| result)
+}
+
 fn round_to_fifty(count: usize) -> usize {
     count / 50 * 50
 }
@@ -323,19 +535,27 @@ fn gen_renamed_lints_test(lints: &[RenamedLint]) -> String {
     res
 }
 
+fn gen_renamed_lints_list(lints: &[RenamedLint]) -> String {
+    const HEADER: &str = "\
+        // This file is managed by `cargo dev rename_lint`. Prefer using that when possible.\n\n\
+        #[rustfmt::skip]\n\
+        pub static RENAMED_LINTS: &[(&str, &str)] = &[\n";
+
+    let mut res = String::from(HEADER);
+    for lint in lints {
+        writeln!(res, "    (\"{}\", \"{}\"),", lint.old_name, lint.new_name).unwrap();
+    }
+    res.push_str("];\n");
+    res
+}
+
 /// Gathers all lints defined in `clippy_lints/src`
 fn gather_all() -> (Vec<Lint>, Vec<DeprecatedLint>, Vec<RenamedLint>) {
     let mut lints = Vec::with_capacity(1000);
     let mut deprecated_lints = Vec::with_capacity(50);
     let mut renamed_lints = Vec::with_capacity(50);
-    let root_path = clippy_project_root().join("clippy_lints/src");
 
-    for (rel_path, file) in WalkDir::new(&root_path)
-        .into_iter()
-        .map(Result::unwrap)
-        .filter(|f| f.path().extension() == Some(OsStr::new("rs")))
-        .map(|f| (f.path().strip_prefix(&root_path).unwrap().to_path_buf(), f))
-    {
+    for (rel_path, file) in clippy_lints_src_files() {
         let path = file.path();
         let contents =
             fs::read_to_string(path).unwrap_or_else(|e| panic!("Cannot read from `{}`: {}", path.display(), e));
@@ -362,6 +582,14 @@ fn gather_all() -> (Vec<Lint>, Vec<DeprecatedLint>, Vec<RenamedLint>) {
     (lints, deprecated_lints, renamed_lints)
 }
 
+fn clippy_lints_src_files() -> impl Iterator<Item = (PathBuf, DirEntry)> {
+    let root_path = clippy_project_root().join("clippy_lints/src");
+    let iter = WalkDir::new(&root_path).into_iter();
+    iter.map(Result::unwrap)
+        .filter(|f| f.path().extension() == Some(OsStr::new("rs")))
+        .map(move |f| (f.path().strip_prefix(&root_path).unwrap().to_path_buf(), f))
+}
+
 macro_rules! match_tokens {
     ($iter:ident, $($token:ident $({$($fields:tt)*})? $(($capture:ident))?)*) => {
          {
@@ -526,6 +754,52 @@ fn replace_region_in_text<'a>(
     Ok(res)
 }
 
+fn try_rename_file(old_name: &Path, new_name: &Path) -> bool {
+    match fs::OpenOptions::new().create_new(true).write(true).open(new_name) {
+        Ok(file) => drop(file),
+        Err(e) if matches!(e.kind(), io::ErrorKind::AlreadyExists | io::ErrorKind::NotFound) => return false,
+        Err(e) => panic_file(e, new_name, "create"),
+    };
+    match fs::rename(old_name, new_name) {
+        Ok(()) => true,
+        Err(e) => {
+            drop(fs::remove_file(new_name));
+            if e.kind() == io::ErrorKind::NotFound {
+                false
+            } else {
+                panic_file(e, old_name, "rename");
+            }
+        },
+    }
+}
+
+#[allow(clippy::needless_pass_by_value)]
+fn panic_file(error: io::Error, name: &Path, action: &str) -> ! {
+    panic!("failed to {} file `{}`: {}", action, name.display(), error)
+}
+
+fn rewrite_file(path: &Path, f: impl FnOnce(&str) -> Option<String>) {
+    let mut file = fs::OpenOptions::new()
+        .write(true)
+        .read(true)
+        .open(path)
+        .unwrap_or_else(|e| panic_file(e, path, "open"));
+    let mut buf = String::new();
+    file.read_to_string(&mut buf)
+        .unwrap_or_else(|e| panic_file(e, path, "read"));
+    if let Some(new_contents) = f(&buf) {
+        file.rewind().unwrap_or_else(|e| panic_file(e, path, "write"));
+        file.write_all(new_contents.as_bytes())
+            .unwrap_or_else(|e| panic_file(e, path, "write"));
+        file.set_len(new_contents.len() as u64)
+            .unwrap_or_else(|e| panic_file(e, path, "write"));
+    }
+}
+
+fn write_file(path: &Path, contents: &str) {
+    fs::write(path, contents).unwrap_or_else(|e| panic_file(e, path, "write"));
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/clippy_lints/src/renamed_lints.rs b/clippy_lints/src/renamed_lints.rs
index e10dc0e1bfe..bfc03116fe2 100644
--- a/clippy_lints/src/renamed_lints.rs
+++ b/clippy_lints/src/renamed_lints.rs
@@ -1,37 +1,39 @@
+// This file is managed by `cargo dev rename_lint`. Prefer using that when possible.
+
+#[rustfmt::skip]
 pub static RENAMED_LINTS: &[(&str, &str)] = &[
-    ("clippy::stutter", "clippy::module_name_repetitions"),
-    ("clippy::new_without_default_derive", "clippy::new_without_default"),
-    ("clippy::cyclomatic_complexity", "clippy::cognitive_complexity"),
-    ("clippy::const_static_lifetime", "clippy::redundant_static_lifetimes"),
-    ("clippy::option_and_then_some", "clippy::bind_instead_of_map"),
-    ("clippy::box_vec", "clippy::box_collection"),
     ("clippy::block_in_if_condition_expr", "clippy::blocks_in_if_conditions"),
     ("clippy::block_in_if_condition_stmt", "clippy::blocks_in_if_conditions"),
-    ("clippy::option_map_unwrap_or", "clippy::map_unwrap_or"),
-    ("clippy::option_map_unwrap_or_else", "clippy::map_unwrap_or"),
-    ("clippy::result_map_unwrap_or_else", "clippy::map_unwrap_or"),
-    ("clippy::option_unwrap_used", "clippy::unwrap_used"),
-    ("clippy::result_unwrap_used", "clippy::unwrap_used"),
-    ("clippy::option_expect_used", "clippy::expect_used"),
-    ("clippy::result_expect_used", "clippy::expect_used"),
+    ("clippy::box_vec", "clippy::box_collection"),
+    ("clippy::const_static_lifetime", "clippy::redundant_static_lifetimes"),
+    ("clippy::cyclomatic_complexity", "clippy::cognitive_complexity"),
+    ("clippy::disallowed_method", "clippy::disallowed_methods"),
+    ("clippy::disallowed_type", "clippy::disallowed_types"),
     ("clippy::for_loop_over_option", "clippy::for_loops_over_fallibles"),
     ("clippy::for_loop_over_result", "clippy::for_loops_over_fallibles"),
     ("clippy::identity_conversion", "clippy::useless_conversion"),
-    ("clippy::zero_width_space", "clippy::invisible_characters"),
-    ("clippy::single_char_push_str", "clippy::single_char_add_str"),
     ("clippy::if_let_some_result", "clippy::match_result_ok"),
-    ("clippy::disallowed_type", "clippy::disallowed_types"),
-    ("clippy::disallowed_method", "clippy::disallowed_methods"),
+    ("clippy::new_without_default_derive", "clippy::new_without_default"),
+    ("clippy::option_and_then_some", "clippy::bind_instead_of_map"),
+    ("clippy::option_expect_used", "clippy::expect_used"),
+    ("clippy::option_map_unwrap_or", "clippy::map_unwrap_or"),
+    ("clippy::option_map_unwrap_or_else", "clippy::map_unwrap_or"),
+    ("clippy::option_unwrap_used", "clippy::unwrap_used"),
     ("clippy::ref_in_deref", "clippy::needless_borrow"),
+    ("clippy::result_expect_used", "clippy::expect_used"),
+    ("clippy::result_map_unwrap_or_else", "clippy::map_unwrap_or"),
+    ("clippy::result_unwrap_used", "clippy::unwrap_used"),
+    ("clippy::single_char_push_str", "clippy::single_char_add_str"),
+    ("clippy::stutter", "clippy::module_name_repetitions"),
     ("clippy::to_string_in_display", "clippy::recursive_format_impl"),
-    // uplifted lints
-    ("clippy::invalid_ref", "invalid_value"),
-    ("clippy::into_iter_on_array", "array_into_iter"),
-    ("clippy::unused_label", "unused_labels"),
+    ("clippy::zero_width_space", "clippy::invisible_characters"),
     ("clippy::drop_bounds", "drop_bounds"),
-    ("clippy::temporary_cstring_as_ptr", "temporary_cstring_as_ptr"),
-    ("clippy::panic_params", "non_fmt_panics"),
-    ("clippy::unknown_clippy_lints", "unknown_lints"),
+    ("clippy::into_iter_on_array", "array_into_iter"),
     ("clippy::invalid_atomic_ordering", "invalid_atomic_ordering"),
+    ("clippy::invalid_ref", "invalid_value"),
     ("clippy::mem_discriminant_non_enum", "enum_intrinsics_non_enums"),
+    ("clippy::panic_params", "non_fmt_panics"),
+    ("clippy::temporary_cstring_as_ptr", "temporary_cstring_as_ptr"),
+    ("clippy::unknown_clippy_lints", "unknown_lints"),
+    ("clippy::unused_label", "unused_labels"),
 ];
diff --git a/tests/ui/rename.fixed b/tests/ui/rename.fixed
index 325f63a64dd..9c4079ad6d3 100644
--- a/tests/ui/rename.fixed
+++ b/tests/ui/rename.fixed
@@ -4,67 +4,67 @@
 
 // run-rustfix
 
-#![allow(clippy::module_name_repetitions)]
-#![allow(clippy::new_without_default)]
-#![allow(clippy::cognitive_complexity)]
-#![allow(clippy::redundant_static_lifetimes)]
-#![allow(clippy::bind_instead_of_map)]
-#![allow(clippy::box_collection)]
 #![allow(clippy::blocks_in_if_conditions)]
-#![allow(clippy::map_unwrap_or)]
-#![allow(clippy::unwrap_used)]
-#![allow(clippy::expect_used)]
+#![allow(clippy::box_collection)]
+#![allow(clippy::redundant_static_lifetimes)]
+#![allow(clippy::cognitive_complexity)]
+#![allow(clippy::disallowed_methods)]
+#![allow(clippy::disallowed_types)]
 #![allow(clippy::for_loops_over_fallibles)]
 #![allow(clippy::useless_conversion)]
-#![allow(clippy::invisible_characters)]
-#![allow(clippy::single_char_add_str)]
 #![allow(clippy::match_result_ok)]
-#![allow(clippy::disallowed_types)]
-#![allow(clippy::disallowed_methods)]
+#![allow(clippy::new_without_default)]
+#![allow(clippy::bind_instead_of_map)]
+#![allow(clippy::expect_used)]
+#![allow(clippy::map_unwrap_or)]
+#![allow(clippy::unwrap_used)]
 #![allow(clippy::needless_borrow)]
+#![allow(clippy::single_char_add_str)]
+#![allow(clippy::module_name_repetitions)]
 #![allow(clippy::recursive_format_impl)]
-#![allow(invalid_value)]
-#![allow(array_into_iter)]
-#![allow(unused_labels)]
+#![allow(clippy::invisible_characters)]
 #![allow(drop_bounds)]
-#![allow(temporary_cstring_as_ptr)]
-#![allow(non_fmt_panics)]
-#![allow(unknown_lints)]
+#![allow(array_into_iter)]
 #![allow(invalid_atomic_ordering)]
+#![allow(invalid_value)]
 #![allow(enum_intrinsics_non_enums)]
-#![warn(clippy::module_name_repetitions)]
-#![warn(clippy::new_without_default)]
-#![warn(clippy::cognitive_complexity)]
-#![warn(clippy::redundant_static_lifetimes)]
-#![warn(clippy::bind_instead_of_map)]
-#![warn(clippy::box_collection)]
+#![allow(non_fmt_panics)]
+#![allow(temporary_cstring_as_ptr)]
+#![allow(unknown_lints)]
+#![allow(unused_labels)]
 #![warn(clippy::blocks_in_if_conditions)]
 #![warn(clippy::blocks_in_if_conditions)]
-#![warn(clippy::map_unwrap_or)]
-#![warn(clippy::map_unwrap_or)]
-#![warn(clippy::map_unwrap_or)]
-#![warn(clippy::unwrap_used)]
-#![warn(clippy::unwrap_used)]
-#![warn(clippy::expect_used)]
-#![warn(clippy::expect_used)]
+#![warn(clippy::box_collection)]
+#![warn(clippy::redundant_static_lifetimes)]
+#![warn(clippy::cognitive_complexity)]
+#![warn(clippy::disallowed_methods)]
+#![warn(clippy::disallowed_types)]
 #![warn(clippy::for_loops_over_fallibles)]
 #![warn(clippy::for_loops_over_fallibles)]
 #![warn(clippy::useless_conversion)]
-#![warn(clippy::invisible_characters)]
-#![warn(clippy::single_char_add_str)]
 #![warn(clippy::match_result_ok)]
-#![warn(clippy::disallowed_types)]
-#![warn(clippy::disallowed_methods)]
+#![warn(clippy::new_without_default)]
+#![warn(clippy::bind_instead_of_map)]
+#![warn(clippy::expect_used)]
+#![warn(clippy::map_unwrap_or)]
+#![warn(clippy::map_unwrap_or)]
+#![warn(clippy::unwrap_used)]
 #![warn(clippy::needless_borrow)]
+#![warn(clippy::expect_used)]
+#![warn(clippy::map_unwrap_or)]
+#![warn(clippy::unwrap_used)]
+#![warn(clippy::single_char_add_str)]
+#![warn(clippy::module_name_repetitions)]
 #![warn(clippy::recursive_format_impl)]
-#![warn(invalid_value)]
-#![warn(array_into_iter)]
-#![warn(unused_labels)]
+#![warn(clippy::invisible_characters)]
 #![warn(drop_bounds)]
-#![warn(temporary_cstring_as_ptr)]
-#![warn(non_fmt_panics)]
-#![warn(unknown_lints)]
+#![warn(array_into_iter)]
 #![warn(invalid_atomic_ordering)]
+#![warn(invalid_value)]
 #![warn(enum_intrinsics_non_enums)]
+#![warn(non_fmt_panics)]
+#![warn(temporary_cstring_as_ptr)]
+#![warn(unknown_lints)]
+#![warn(unused_labels)]
 
 fn main() {}
diff --git a/tests/ui/rename.rs b/tests/ui/rename.rs
index a21b4a24288..e83e66b7fbd 100644
--- a/tests/ui/rename.rs
+++ b/tests/ui/rename.rs
@@ -4,67 +4,67 @@
 
 // run-rustfix
 
-#![allow(clippy::module_name_repetitions)]
-#![allow(clippy::new_without_default)]
-#![allow(clippy::cognitive_complexity)]
-#![allow(clippy::redundant_static_lifetimes)]
-#![allow(clippy::bind_instead_of_map)]
-#![allow(clippy::box_collection)]
 #![allow(clippy::blocks_in_if_conditions)]
-#![allow(clippy::map_unwrap_or)]
-#![allow(clippy::unwrap_used)]
-#![allow(clippy::expect_used)]
+#![allow(clippy::box_collection)]
+#![allow(clippy::redundant_static_lifetimes)]
+#![allow(clippy::cognitive_complexity)]
+#![allow(clippy::disallowed_methods)]
+#![allow(clippy::disallowed_types)]
 #![allow(clippy::for_loops_over_fallibles)]
 #![allow(clippy::useless_conversion)]
-#![allow(clippy::invisible_characters)]
-#![allow(clippy::single_char_add_str)]
 #![allow(clippy::match_result_ok)]
-#![allow(clippy::disallowed_types)]
-#![allow(clippy::disallowed_methods)]
+#![allow(clippy::new_without_default)]
+#![allow(clippy::bind_instead_of_map)]
+#![allow(clippy::expect_used)]
+#![allow(clippy::map_unwrap_or)]
+#![allow(clippy::unwrap_used)]
 #![allow(clippy::needless_borrow)]
+#![allow(clippy::single_char_add_str)]
+#![allow(clippy::module_name_repetitions)]
 #![allow(clippy::recursive_format_impl)]
-#![allow(invalid_value)]
-#![allow(array_into_iter)]
-#![allow(unused_labels)]
+#![allow(clippy::invisible_characters)]
 #![allow(drop_bounds)]
-#![allow(temporary_cstring_as_ptr)]
-#![allow(non_fmt_panics)]
-#![allow(unknown_lints)]
+#![allow(array_into_iter)]
 #![allow(invalid_atomic_ordering)]
+#![allow(invalid_value)]
 #![allow(enum_intrinsics_non_enums)]
-#![warn(clippy::stutter)]
-#![warn(clippy::new_without_default_derive)]
-#![warn(clippy::cyclomatic_complexity)]
-#![warn(clippy::const_static_lifetime)]
-#![warn(clippy::option_and_then_some)]
-#![warn(clippy::box_vec)]
+#![allow(non_fmt_panics)]
+#![allow(temporary_cstring_as_ptr)]
+#![allow(unknown_lints)]
+#![allow(unused_labels)]
 #![warn(clippy::block_in_if_condition_expr)]
 #![warn(clippy::block_in_if_condition_stmt)]
-#![warn(clippy::option_map_unwrap_or)]
-#![warn(clippy::option_map_unwrap_or_else)]
-#![warn(clippy::result_map_unwrap_or_else)]
-#![warn(clippy::option_unwrap_used)]
-#![warn(clippy::result_unwrap_used)]
-#![warn(clippy::option_expect_used)]
-#![warn(clippy::result_expect_used)]
+#![warn(clippy::box_vec)]
+#![warn(clippy::const_static_lifetime)]
+#![warn(clippy::cyclomatic_complexity)]
+#![warn(clippy::disallowed_method)]
+#![warn(clippy::disallowed_type)]
 #![warn(clippy::for_loop_over_option)]
 #![warn(clippy::for_loop_over_result)]
 #![warn(clippy::identity_conversion)]
-#![warn(clippy::zero_width_space)]
-#![warn(clippy::single_char_push_str)]
 #![warn(clippy::if_let_some_result)]
-#![warn(clippy::disallowed_type)]
-#![warn(clippy::disallowed_method)]
+#![warn(clippy::new_without_default_derive)]
+#![warn(clippy::option_and_then_some)]
+#![warn(clippy::option_expect_used)]
+#![warn(clippy::option_map_unwrap_or)]
+#![warn(clippy::option_map_unwrap_or_else)]
+#![warn(clippy::option_unwrap_used)]
 #![warn(clippy::ref_in_deref)]
+#![warn(clippy::result_expect_used)]
+#![warn(clippy::result_map_unwrap_or_else)]
+#![warn(clippy::result_unwrap_used)]
+#![warn(clippy::single_char_push_str)]
+#![warn(clippy::stutter)]
 #![warn(clippy::to_string_in_display)]
-#![warn(clippy::invalid_ref)]
-#![warn(clippy::into_iter_on_array)]
-#![warn(clippy::unused_label)]
+#![warn(clippy::zero_width_space)]
 #![warn(clippy::drop_bounds)]
-#![warn(clippy::temporary_cstring_as_ptr)]
-#![warn(clippy::panic_params)]
-#![warn(clippy::unknown_clippy_lints)]
+#![warn(clippy::into_iter_on_array)]
 #![warn(clippy::invalid_atomic_ordering)]
+#![warn(clippy::invalid_ref)]
 #![warn(clippy::mem_discriminant_non_enum)]
+#![warn(clippy::panic_params)]
+#![warn(clippy::temporary_cstring_as_ptr)]
+#![warn(clippy::unknown_clippy_lints)]
+#![warn(clippy::unused_label)]
 
 fn main() {}
diff --git a/tests/ui/rename.stderr b/tests/ui/rename.stderr
index 54e12d5fae5..f811b10d017 100644
--- a/tests/ui/rename.stderr
+++ b/tests/ui/rename.stderr
@@ -1,22 +1,22 @@
-error: lint `clippy::stutter` has been renamed to `clippy::module_name_repetitions`
+error: lint `clippy::block_in_if_condition_expr` has been renamed to `clippy::blocks_in_if_conditions`
   --> $DIR/rename.rs:35:9
    |
-LL | #![warn(clippy::stutter)]
-   |         ^^^^^^^^^^^^^^^ help: use the new name: `clippy::module_name_repetitions`
+LL | #![warn(clippy::block_in_if_condition_expr)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::blocks_in_if_conditions`
    |
    = note: `-D renamed-and-removed-lints` implied by `-D warnings`
 
-error: lint `clippy::new_without_default_derive` has been renamed to `clippy::new_without_default`
+error: lint `clippy::block_in_if_condition_stmt` has been renamed to `clippy::blocks_in_if_conditions`
   --> $DIR/rename.rs:36:9
    |
-LL | #![warn(clippy::new_without_default_derive)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::new_without_default`
+LL | #![warn(clippy::block_in_if_condition_stmt)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::blocks_in_if_conditions`
 
-error: lint `clippy::cyclomatic_complexity` has been renamed to `clippy::cognitive_complexity`
+error: lint `clippy::box_vec` has been renamed to `clippy::box_collection`
   --> $DIR/rename.rs:37:9
    |
-LL | #![warn(clippy::cyclomatic_complexity)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::cognitive_complexity`
+LL | #![warn(clippy::box_vec)]
+   |         ^^^^^^^^^^^^^^^ help: use the new name: `clippy::box_collection`
 
 error: lint `clippy::const_static_lifetime` has been renamed to `clippy::redundant_static_lifetimes`
   --> $DIR/rename.rs:38:9
@@ -24,59 +24,59 @@ error: lint `clippy::const_static_lifetime` has been renamed to `clippy::redunda
 LL | #![warn(clippy::const_static_lifetime)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::redundant_static_lifetimes`
 
-error: lint `clippy::option_and_then_some` has been renamed to `clippy::bind_instead_of_map`
+error: lint `clippy::cyclomatic_complexity` has been renamed to `clippy::cognitive_complexity`
   --> $DIR/rename.rs:39:9
    |
-LL | #![warn(clippy::option_and_then_some)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::bind_instead_of_map`
+LL | #![warn(clippy::cyclomatic_complexity)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::cognitive_complexity`
 
-error: lint `clippy::box_vec` has been renamed to `clippy::box_collection`
+error: lint `clippy::disallowed_method` has been renamed to `clippy::disallowed_methods`
   --> $DIR/rename.rs:40:9
    |
-LL | #![warn(clippy::box_vec)]
-   |         ^^^^^^^^^^^^^^^ help: use the new name: `clippy::box_collection`
+LL | #![warn(clippy::disallowed_method)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::disallowed_methods`
 
-error: lint `clippy::block_in_if_condition_expr` has been renamed to `clippy::blocks_in_if_conditions`
+error: lint `clippy::disallowed_type` has been renamed to `clippy::disallowed_types`
   --> $DIR/rename.rs:41:9
    |
-LL | #![warn(clippy::block_in_if_condition_expr)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::blocks_in_if_conditions`
+LL | #![warn(clippy::disallowed_type)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::disallowed_types`
 
-error: lint `clippy::block_in_if_condition_stmt` has been renamed to `clippy::blocks_in_if_conditions`
+error: lint `clippy::for_loop_over_option` has been renamed to `clippy::for_loops_over_fallibles`
   --> $DIR/rename.rs:42:9
    |
-LL | #![warn(clippy::block_in_if_condition_stmt)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::blocks_in_if_conditions`
+LL | #![warn(clippy::for_loop_over_option)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::for_loops_over_fallibles`
 
-error: lint `clippy::option_map_unwrap_or` has been renamed to `clippy::map_unwrap_or`
+error: lint `clippy::for_loop_over_result` has been renamed to `clippy::for_loops_over_fallibles`
   --> $DIR/rename.rs:43:9
    |
-LL | #![warn(clippy::option_map_unwrap_or)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::map_unwrap_or`
+LL | #![warn(clippy::for_loop_over_result)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::for_loops_over_fallibles`
 
-error: lint `clippy::option_map_unwrap_or_else` has been renamed to `clippy::map_unwrap_or`
+error: lint `clippy::identity_conversion` has been renamed to `clippy::useless_conversion`
   --> $DIR/rename.rs:44:9
    |
-LL | #![warn(clippy::option_map_unwrap_or_else)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::map_unwrap_or`
+LL | #![warn(clippy::identity_conversion)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::useless_conversion`
 
-error: lint `clippy::result_map_unwrap_or_else` has been renamed to `clippy::map_unwrap_or`
+error: lint `clippy::if_let_some_result` has been renamed to `clippy::match_result_ok`
   --> $DIR/rename.rs:45:9
    |
-LL | #![warn(clippy::result_map_unwrap_or_else)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::map_unwrap_or`
+LL | #![warn(clippy::if_let_some_result)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::match_result_ok`
 
-error: lint `clippy::option_unwrap_used` has been renamed to `clippy::unwrap_used`
+error: lint `clippy::new_without_default_derive` has been renamed to `clippy::new_without_default`
   --> $DIR/rename.rs:46:9
    |
-LL | #![warn(clippy::option_unwrap_used)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::unwrap_used`
+LL | #![warn(clippy::new_without_default_derive)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::new_without_default`
 
-error: lint `clippy::result_unwrap_used` has been renamed to `clippy::unwrap_used`
+error: lint `clippy::option_and_then_some` has been renamed to `clippy::bind_instead_of_map`
   --> $DIR/rename.rs:47:9
    |
-LL | #![warn(clippy::result_unwrap_used)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::unwrap_used`
+LL | #![warn(clippy::option_and_then_some)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::bind_instead_of_map`
 
 error: lint `clippy::option_expect_used` has been renamed to `clippy::expect_used`
   --> $DIR/rename.rs:48:9
@@ -84,77 +84,77 @@ error: lint `clippy::option_expect_used` has been renamed to `clippy::expect_use
 LL | #![warn(clippy::option_expect_used)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::expect_used`
 
-error: lint `clippy::result_expect_used` has been renamed to `clippy::expect_used`
+error: lint `clippy::option_map_unwrap_or` has been renamed to `clippy::map_unwrap_or`
   --> $DIR/rename.rs:49:9
    |
-LL | #![warn(clippy::result_expect_used)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::expect_used`
+LL | #![warn(clippy::option_map_unwrap_or)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::map_unwrap_or`
 
-error: lint `clippy::for_loop_over_option` has been renamed to `clippy::for_loops_over_fallibles`
+error: lint `clippy::option_map_unwrap_or_else` has been renamed to `clippy::map_unwrap_or`
   --> $DIR/rename.rs:50:9
    |
-LL | #![warn(clippy::for_loop_over_option)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::for_loops_over_fallibles`
+LL | #![warn(clippy::option_map_unwrap_or_else)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::map_unwrap_or`
 
-error: lint `clippy::for_loop_over_result` has been renamed to `clippy::for_loops_over_fallibles`
+error: lint `clippy::option_unwrap_used` has been renamed to `clippy::unwrap_used`
   --> $DIR/rename.rs:51:9
    |
-LL | #![warn(clippy::for_loop_over_result)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::for_loops_over_fallibles`
+LL | #![warn(clippy::option_unwrap_used)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::unwrap_used`
 
-error: lint `clippy::identity_conversion` has been renamed to `clippy::useless_conversion`
+error: lint `clippy::ref_in_deref` has been renamed to `clippy::needless_borrow`
   --> $DIR/rename.rs:52:9
    |
-LL | #![warn(clippy::identity_conversion)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::useless_conversion`
+LL | #![warn(clippy::ref_in_deref)]
+   |         ^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::needless_borrow`
 
-error: lint `clippy::zero_width_space` has been renamed to `clippy::invisible_characters`
+error: lint `clippy::result_expect_used` has been renamed to `clippy::expect_used`
   --> $DIR/rename.rs:53:9
    |
-LL | #![warn(clippy::zero_width_space)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::invisible_characters`
+LL | #![warn(clippy::result_expect_used)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::expect_used`
 
-error: lint `clippy::single_char_push_str` has been renamed to `clippy::single_char_add_str`
+error: lint `clippy::result_map_unwrap_or_else` has been renamed to `clippy::map_unwrap_or`
   --> $DIR/rename.rs:54:9
    |
-LL | #![warn(clippy::single_char_push_str)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::single_char_add_str`
+LL | #![warn(clippy::result_map_unwrap_or_else)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::map_unwrap_or`
 
-error: lint `clippy::if_let_some_result` has been renamed to `clippy::match_result_ok`
+error: lint `clippy::result_unwrap_used` has been renamed to `clippy::unwrap_used`
   --> $DIR/rename.rs:55:9
    |
-LL | #![warn(clippy::if_let_some_result)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::match_result_ok`
+LL | #![warn(clippy::result_unwrap_used)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::unwrap_used`
 
-error: lint `clippy::disallowed_type` has been renamed to `clippy::disallowed_types`
+error: lint `clippy::single_char_push_str` has been renamed to `clippy::single_char_add_str`
   --> $DIR/rename.rs:56:9
    |
-LL | #![warn(clippy::disallowed_type)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::disallowed_types`
+LL | #![warn(clippy::single_char_push_str)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::single_char_add_str`
 
-error: lint `clippy::disallowed_method` has been renamed to `clippy::disallowed_methods`
+error: lint `clippy::stutter` has been renamed to `clippy::module_name_repetitions`
   --> $DIR/rename.rs:57:9
    |
-LL | #![warn(clippy::disallowed_method)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::disallowed_methods`
+LL | #![warn(clippy::stutter)]
+   |         ^^^^^^^^^^^^^^^ help: use the new name: `clippy::module_name_repetitions`
 
-error: lint `clippy::ref_in_deref` has been renamed to `clippy::needless_borrow`
+error: lint `clippy::to_string_in_display` has been renamed to `clippy::recursive_format_impl`
   --> $DIR/rename.rs:58:9
    |
-LL | #![warn(clippy::ref_in_deref)]
-   |         ^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::needless_borrow`
+LL | #![warn(clippy::to_string_in_display)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::recursive_format_impl`
 
-error: lint `clippy::to_string_in_display` has been renamed to `clippy::recursive_format_impl`
+error: lint `clippy::zero_width_space` has been renamed to `clippy::invisible_characters`
   --> $DIR/rename.rs:59:9
    |
-LL | #![warn(clippy::to_string_in_display)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::recursive_format_impl`
+LL | #![warn(clippy::zero_width_space)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::invisible_characters`
 
-error: lint `clippy::invalid_ref` has been renamed to `invalid_value`
+error: lint `clippy::drop_bounds` has been renamed to `drop_bounds`
   --> $DIR/rename.rs:60:9
    |
-LL | #![warn(clippy::invalid_ref)]
-   |         ^^^^^^^^^^^^^^^^^^^ help: use the new name: `invalid_value`
+LL | #![warn(clippy::drop_bounds)]
+   |         ^^^^^^^^^^^^^^^^^^^ help: use the new name: `drop_bounds`
 
 error: lint `clippy::into_iter_on_array` has been renamed to `array_into_iter`
   --> $DIR/rename.rs:61:9
@@ -162,23 +162,23 @@ error: lint `clippy::into_iter_on_array` has been renamed to `array_into_iter`
 LL | #![warn(clippy::into_iter_on_array)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `array_into_iter`
 
-error: lint `clippy::unused_label` has been renamed to `unused_labels`
+error: lint `clippy::invalid_atomic_ordering` has been renamed to `invalid_atomic_ordering`
   --> $DIR/rename.rs:62:9
    |
-LL | #![warn(clippy::unused_label)]
-   |         ^^^^^^^^^^^^^^^^^^^^ help: use the new name: `unused_labels`
+LL | #![warn(clippy::invalid_atomic_ordering)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `invalid_atomic_ordering`
 
-error: lint `clippy::drop_bounds` has been renamed to `drop_bounds`
+error: lint `clippy::invalid_ref` has been renamed to `invalid_value`
   --> $DIR/rename.rs:63:9
    |
-LL | #![warn(clippy::drop_bounds)]
-   |         ^^^^^^^^^^^^^^^^^^^ help: use the new name: `drop_bounds`
+LL | #![warn(clippy::invalid_ref)]
+   |         ^^^^^^^^^^^^^^^^^^^ help: use the new name: `invalid_value`
 
-error: lint `clippy::temporary_cstring_as_ptr` has been renamed to `temporary_cstring_as_ptr`
+error: lint `clippy::mem_discriminant_non_enum` has been renamed to `enum_intrinsics_non_enums`
   --> $DIR/rename.rs:64:9
    |
-LL | #![warn(clippy::temporary_cstring_as_ptr)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `temporary_cstring_as_ptr`
+LL | #![warn(clippy::mem_discriminant_non_enum)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `enum_intrinsics_non_enums`
 
 error: lint `clippy::panic_params` has been renamed to `non_fmt_panics`
   --> $DIR/rename.rs:65:9
@@ -186,23 +186,23 @@ error: lint `clippy::panic_params` has been renamed to `non_fmt_panics`
 LL | #![warn(clippy::panic_params)]
    |         ^^^^^^^^^^^^^^^^^^^^ help: use the new name: `non_fmt_panics`
 
-error: lint `clippy::unknown_clippy_lints` has been renamed to `unknown_lints`
+error: lint `clippy::temporary_cstring_as_ptr` has been renamed to `temporary_cstring_as_ptr`
   --> $DIR/rename.rs:66:9
    |
-LL | #![warn(clippy::unknown_clippy_lints)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `unknown_lints`
+LL | #![warn(clippy::temporary_cstring_as_ptr)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `temporary_cstring_as_ptr`
 
-error: lint `clippy::invalid_atomic_ordering` has been renamed to `invalid_atomic_ordering`
+error: lint `clippy::unknown_clippy_lints` has been renamed to `unknown_lints`
   --> $DIR/rename.rs:67:9
    |
-LL | #![warn(clippy::invalid_atomic_ordering)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `invalid_atomic_ordering`
+LL | #![warn(clippy::unknown_clippy_lints)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `unknown_lints`
 
-error: lint `clippy::mem_discriminant_non_enum` has been renamed to `enum_intrinsics_non_enums`
+error: lint `clippy::unused_label` has been renamed to `unused_labels`
   --> $DIR/rename.rs:68:9
    |
-LL | #![warn(clippy::mem_discriminant_non_enum)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `enum_intrinsics_non_enums`
+LL | #![warn(clippy::unused_label)]
+   |         ^^^^^^^^^^^^^^^^^^^^ help: use the new name: `unused_labels`
 
 error: aborting due to 34 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From f2902494614643509685c3bf974287ac9844b2fd Mon Sep 17 00:00:00 2001
From: goth-turtle <93494392+goth-turtle@users.noreply.github.com>
Date: Sat, 23 Apr 2022 22:20:50 +0200
Subject: mistyped_literal_suffixes: improve suggestions for integer types

Instead of just always suggesting signed suffixes regardless of size
of the value, it now suggests an unsigned suffix when the value wouldn't
fit into the corresponding signed type, and ignores the literal entirely
if it is too big for the unsigned type as well.
---
 clippy_lints/src/literal_representation.rs | 50 ++++++++++++++++++++-------
 tests/ui/mistyped_literal_suffix.fixed     | 12 ++++++-
 tests/ui/mistyped_literal_suffix.rs        | 12 ++++++-
 tests/ui/mistyped_literal_suffix.stderr    | 54 +++++++++++++++++++++++-------
 4 files changed, 101 insertions(+), 27 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/literal_representation.rs b/clippy_lints/src/literal_representation.rs
index b7430f49229..362d45991bb 100644
--- a/clippy_lints/src/literal_representation.rs
+++ b/clippy_lints/src/literal_representation.rs
@@ -42,17 +42,12 @@ declare_clippy_lint! {
     /// This is most probably a typo
     ///
     /// ### Known problems
-    /// - Recommends a signed suffix, even though the number might be too big and an unsigned
-    ///   suffix is required
+    /// - Does not match on integers too large to fit in the corresponding unsigned type
     /// - Does not match on `_127` since that is a valid grouping for decimal and octal numbers
     ///
     /// ### Example
-    /// ```rust
-    /// // Probably mistyped
-    /// 2_32;
-    ///
-    /// // Good
-    /// 2_i32;
+    /// `2_32` => `2_i32`
+    /// `250_8 => `250_u8`
     /// ```
     #[clippy::version = "1.30.0"]
     pub MISTYPED_LITERAL_SUFFIXES,
@@ -310,18 +305,47 @@ impl LiteralDigitGrouping {
             return true;
         }
 
-        let (part, mistyped_suffixes, missing_char) = if let Some((_, exponent)) = &mut num_lit.exponent {
-            (exponent, &["32", "64"][..], 'f')
+        let (part, mistyped_suffixes, is_float) = if let Some((_, exponent)) = &mut num_lit.exponent {
+            (exponent, &["32", "64"][..], true)
         } else if num_lit.fraction.is_some() {
-            (&mut num_lit.integer, &["32", "64"][..], 'f')
+            (&mut num_lit.integer, &["32", "64"][..], true)
         } else {
-            (&mut num_lit.integer, &["8", "16", "32", "64"][..], 'i')
+            (&mut num_lit.integer, &["8", "16", "32", "64"][..], false)
         };
 
         let mut split = part.rsplit('_');
         let last_group = split.next().expect("At least one group");
         if split.next().is_some() && mistyped_suffixes.contains(&last_group) {
-            *part = &part[..part.len() - last_group.len()];
+            let main_part = &part[..part.len() - last_group.len()];
+            let missing_char;
+            if is_float {
+                missing_char = 'f';
+            } else {
+                let radix = match num_lit.radix {
+                    Radix::Binary => 2,
+                    Radix::Octal => 8,
+                    Radix::Decimal => 10,
+                    Radix::Hexadecimal => 16,
+                };
+                if let Ok(int) = u64::from_str_radix(&main_part.replace('_', ""), radix) {
+                    missing_char = match (last_group, int) {
+                        ("8", i) if i8::try_from(i).is_ok() => 'i',
+                        ("16", i) if i16::try_from(i).is_ok() => 'i',
+                        ("32", i) if i32::try_from(i).is_ok() => 'i',
+                        ("64", i) if i64::try_from(i).is_ok() => 'i',
+                        ("8", u) if u8::try_from(u).is_ok() => 'u',
+                        ("16", u) if u16::try_from(u).is_ok() => 'u',
+                        ("32", u) if u32::try_from(u).is_ok() => 'u',
+                        ("64", _) => 'u',
+                        _ => {
+                            return true;
+                        },
+                    }
+                } else {
+                    return true;
+                }
+            }
+            *part = main_part;
             let mut sugg = num_lit.format();
             sugg.push('_');
             sugg.push(missing_char);
diff --git a/tests/ui/mistyped_literal_suffix.fixed b/tests/ui/mistyped_literal_suffix.fixed
index 5d57638af43..a59384e0725 100644
--- a/tests/ui/mistyped_literal_suffix.fixed
+++ b/tests/ui/mistyped_literal_suffix.fixed
@@ -5,7 +5,8 @@
     unused_variables,
     overflowing_literals,
     clippy::excessive_precision,
-    clippy::inconsistent_digit_grouping
+    clippy::inconsistent_digit_grouping,
+    clippy::unusual_byte_groupings
 )]
 
 fn main() {
@@ -25,5 +26,14 @@ fn main() {
     let fail28 = 241_251_235E723_f64;
     let ok29 = 42279.911_32;
 
+    // testing that the suggestion actually fits in its type
+    let fail30 = 127_i8; // should be i8
+    let fail31 = 240_u8; // should be u8
+    let ok32 = 360_8; // doesnt fit in either, should be ignored
+    let fail33 = 0x1234_i16;
+    let fail34 = 0xABCD_u16;
+    let ok35 = 0x12345_16;
+    let fail36 = 0xFFFF_FFFF_FFFF_FFFF_u64; // u64
+
     let _ = 1.123_45E1_f32;
 }
diff --git a/tests/ui/mistyped_literal_suffix.rs b/tests/ui/mistyped_literal_suffix.rs
index 12171452885..01e425f9f1d 100644
--- a/tests/ui/mistyped_literal_suffix.rs
+++ b/tests/ui/mistyped_literal_suffix.rs
@@ -5,7 +5,8 @@
     unused_variables,
     overflowing_literals,
     clippy::excessive_precision,
-    clippy::inconsistent_digit_grouping
+    clippy::inconsistent_digit_grouping,
+    clippy::unusual_byte_groupings
 )]
 
 fn main() {
@@ -25,5 +26,14 @@ fn main() {
     let fail28 = 241251235E723_64;
     let ok29 = 42279.911_32;
 
+    // testing that the suggestion actually fits in its type
+    let fail30 = 127_8; // should be i8
+    let fail31 = 240_8; // should be u8
+    let ok32 = 360_8; // doesnt fit in either, should be ignored
+    let fail33 = 0x1234_16;
+    let fail34 = 0xABCD_16;
+    let ok35 = 0x12345_16;
+    let fail36 = 0xFFFF_FFFF_FFFF_FFFF_64; // u64
+
     let _ = 1.12345E1_32;
 }
diff --git a/tests/ui/mistyped_literal_suffix.stderr b/tests/ui/mistyped_literal_suffix.stderr
index d24543c26e4..6fcd1f2f180 100644
--- a/tests/ui/mistyped_literal_suffix.stderr
+++ b/tests/ui/mistyped_literal_suffix.stderr
@@ -1,5 +1,5 @@
 error: mistyped literal suffix
-  --> $DIR/mistyped_literal_suffix.rs:12:18
+  --> $DIR/mistyped_literal_suffix.rs:13:18
    |
 LL |     let fail14 = 2_32;
    |                  ^^^^ help: did you mean to write: `2_i32`
@@ -7,64 +7,94 @@ LL |     let fail14 = 2_32;
    = note: `#[deny(clippy::mistyped_literal_suffixes)]` on by default
 
 error: mistyped literal suffix
-  --> $DIR/mistyped_literal_suffix.rs:13:18
+  --> $DIR/mistyped_literal_suffix.rs:14:18
    |
 LL |     let fail15 = 4_64;
    |                  ^^^^ help: did you mean to write: `4_i64`
 
 error: mistyped literal suffix
-  --> $DIR/mistyped_literal_suffix.rs:14:18
+  --> $DIR/mistyped_literal_suffix.rs:15:18
    |
 LL |     let fail16 = 7_8; //
    |                  ^^^ help: did you mean to write: `7_i8`
 
 error: mistyped literal suffix
-  --> $DIR/mistyped_literal_suffix.rs:15:18
+  --> $DIR/mistyped_literal_suffix.rs:16:18
    |
 LL |     let fail17 = 23_16; //
    |                  ^^^^^ help: did you mean to write: `23_i16`
 
 error: mistyped literal suffix
-  --> $DIR/mistyped_literal_suffix.rs:18:18
+  --> $DIR/mistyped_literal_suffix.rs:19:18
    |
 LL |     let fail20 = 2__8; //
    |                  ^^^^ help: did you mean to write: `2_i8`
 
 error: mistyped literal suffix
-  --> $DIR/mistyped_literal_suffix.rs:19:18
+  --> $DIR/mistyped_literal_suffix.rs:20:18
    |
 LL |     let fail21 = 4___16; //
    |                  ^^^^^^ help: did you mean to write: `4_i16`
 
 error: mistyped literal suffix
-  --> $DIR/mistyped_literal_suffix.rs:22:18
+  --> $DIR/mistyped_literal_suffix.rs:23:18
    |
 LL |     let fail25 = 1E2_32;
    |                  ^^^^^^ help: did you mean to write: `1E2_f32`
 
 error: mistyped literal suffix
-  --> $DIR/mistyped_literal_suffix.rs:23:18
+  --> $DIR/mistyped_literal_suffix.rs:24:18
    |
 LL |     let fail26 = 43E7_64;
    |                  ^^^^^^^ help: did you mean to write: `43E7_f64`
 
 error: mistyped literal suffix
-  --> $DIR/mistyped_literal_suffix.rs:24:18
+  --> $DIR/mistyped_literal_suffix.rs:25:18
    |
 LL |     let fail27 = 243E17_32;
    |                  ^^^^^^^^^ help: did you mean to write: `243E17_f32`
 
 error: mistyped literal suffix
-  --> $DIR/mistyped_literal_suffix.rs:25:18
+  --> $DIR/mistyped_literal_suffix.rs:26:18
    |
 LL |     let fail28 = 241251235E723_64;
    |                  ^^^^^^^^^^^^^^^^ help: did you mean to write: `241_251_235E723_f64`
 
 error: mistyped literal suffix
-  --> $DIR/mistyped_literal_suffix.rs:28:13
+  --> $DIR/mistyped_literal_suffix.rs:30:18
+   |
+LL |     let fail30 = 127_8; // should be i8
+   |                  ^^^^^ help: did you mean to write: `127_i8`
+
+error: mistyped literal suffix
+  --> $DIR/mistyped_literal_suffix.rs:31:18
+   |
+LL |     let fail31 = 240_8; // should be u8
+   |                  ^^^^^ help: did you mean to write: `240_u8`
+
+error: mistyped literal suffix
+  --> $DIR/mistyped_literal_suffix.rs:33:18
+   |
+LL |     let fail33 = 0x1234_16;
+   |                  ^^^^^^^^^ help: did you mean to write: `0x1234_i16`
+
+error: mistyped literal suffix
+  --> $DIR/mistyped_literal_suffix.rs:34:18
+   |
+LL |     let fail34 = 0xABCD_16;
+   |                  ^^^^^^^^^ help: did you mean to write: `0xABCD_u16`
+
+error: mistyped literal suffix
+  --> $DIR/mistyped_literal_suffix.rs:36:18
+   |
+LL |     let fail36 = 0xFFFF_FFFF_FFFF_FFFF_64; // u64
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^ help: did you mean to write: `0xFFFF_FFFF_FFFF_FFFF_u64`
+
+error: mistyped literal suffix
+  --> $DIR/mistyped_literal_suffix.rs:38:13
    |
 LL |     let _ = 1.12345E1_32;
    |             ^^^^^^^^^^^^ help: did you mean to write: `1.123_45E1_f32`
 
-error: aborting due to 11 previous errors
+error: aborting due to 16 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From b4a50e9ee5adda55ad68b0dc637433fa0936e10e Mon Sep 17 00:00:00 2001
From: goth-turtle <93494392+goth-turtle@users.noreply.github.com>
Date: Sun, 24 Apr 2022 15:06:48 +0200
Subject: mistyped_literal_suffixes: ignore floats without exponent

Previously this lint would only look at the integer part of floating
point literals without an exponent, giving wrong suggestions like:

```
  |
8 |     let _ = 123_32.123;
  |             ^^^^^^^^^^ help: did you mean to write: `123.123_f32`
  |
```

Instead, it now ignores these literals.
Fixes #6129
---
 clippy_lints/src/literal_representation.rs | 2 +-
 tests/ui/mistyped_literal_suffix.fixed     | 4 ++++
 tests/ui/mistyped_literal_suffix.rs        | 4 ++++
 tests/ui/mistyped_literal_suffix.stderr    | 2 +-
 4 files changed, 10 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/literal_representation.rs b/clippy_lints/src/literal_representation.rs
index 362d45991bb..269d3c62eaf 100644
--- a/clippy_lints/src/literal_representation.rs
+++ b/clippy_lints/src/literal_representation.rs
@@ -308,7 +308,7 @@ impl LiteralDigitGrouping {
         let (part, mistyped_suffixes, is_float) = if let Some((_, exponent)) = &mut num_lit.exponent {
             (exponent, &["32", "64"][..], true)
         } else if num_lit.fraction.is_some() {
-            (&mut num_lit.integer, &["32", "64"][..], true)
+            return true;
         } else {
             (&mut num_lit.integer, &["8", "16", "32", "64"][..], false)
         };
diff --git a/tests/ui/mistyped_literal_suffix.fixed b/tests/ui/mistyped_literal_suffix.fixed
index a59384e0725..a7b36d53cd2 100644
--- a/tests/ui/mistyped_literal_suffix.fixed
+++ b/tests/ui/mistyped_literal_suffix.fixed
@@ -35,5 +35,9 @@ fn main() {
     let ok35 = 0x12345_16;
     let fail36 = 0xFFFF_FFFF_FFFF_FFFF_u64; // u64
 
+    // issue #6129
+    let ok37 = 123_32.123;
+    let ok38 = 124_64.0;
+
     let _ = 1.123_45E1_f32;
 }
diff --git a/tests/ui/mistyped_literal_suffix.rs b/tests/ui/mistyped_literal_suffix.rs
index 01e425f9f1d..c97b31965c7 100644
--- a/tests/ui/mistyped_literal_suffix.rs
+++ b/tests/ui/mistyped_literal_suffix.rs
@@ -35,5 +35,9 @@ fn main() {
     let ok35 = 0x12345_16;
     let fail36 = 0xFFFF_FFFF_FFFF_FFFF_64; // u64
 
+    // issue #6129
+    let ok37 = 123_32.123;
+    let ok38 = 124_64.0;
+
     let _ = 1.12345E1_32;
 }
diff --git a/tests/ui/mistyped_literal_suffix.stderr b/tests/ui/mistyped_literal_suffix.stderr
index 6fcd1f2f180..fb761d9bde4 100644
--- a/tests/ui/mistyped_literal_suffix.stderr
+++ b/tests/ui/mistyped_literal_suffix.stderr
@@ -91,7 +91,7 @@ LL |     let fail36 = 0xFFFF_FFFF_FFFF_FFFF_64; // u64
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^ help: did you mean to write: `0xFFFF_FFFF_FFFF_FFFF_u64`
 
 error: mistyped literal suffix
-  --> $DIR/mistyped_literal_suffix.rs:38:13
+  --> $DIR/mistyped_literal_suffix.rs:42:13
    |
 LL |     let _ = 1.12345E1_32;
    |             ^^^^^^^^^^^^ help: did you mean to write: `1.123_45E1_f32`
-- 
cgit 1.4.1-3-g733a5


From a85dc87c4cb0640915a3d5a5a318c2901ff839d3 Mon Sep 17 00:00:00 2001
From: Serial <69764315+Serial-ATA@users.noreply.github.com>
Date: Thu, 21 Apr 2022 11:01:18 -0400
Subject: Add `large_include_file` lint

---
 CHANGELOG.md                                       |  1 +
 clippy_lints/src/large_include_file.rs             | 86 ++++++++++++++++++++++
 clippy_lints/src/lib.register_lints.rs             |  1 +
 clippy_lints/src/lib.register_restriction.rs       |  1 +
 clippy_lints/src/lib.rs                            |  3 +
 clippy_lints/src/utils/conf.rs                     |  4 +
 tests/ui-toml/large_include_file/clippy.toml       |  1 +
 .../large_include_file/large_include_file.rs       | 16 ++++
 .../large_include_file/large_include_file.stderr   | 21 ++++++
 tests/ui-toml/large_include_file/too_big.txt       |  1 +
 .../toml_unknown_key/conf_unknown_key.stderr       |  2 +-
 11 files changed, 136 insertions(+), 1 deletion(-)
 create mode 100644 clippy_lints/src/large_include_file.rs
 create mode 100644 tests/ui-toml/large_include_file/clippy.toml
 create mode 100644 tests/ui-toml/large_include_file/large_include_file.rs
 create mode 100644 tests/ui-toml/large_include_file/large_include_file.stderr
 create mode 100644 tests/ui-toml/large_include_file/too_big.txt

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 2948c24fb3b..c88ead99fa6 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3478,6 +3478,7 @@ Released 2018-09-13
 [`large_const_arrays`]: https://rust-lang.github.io/rust-clippy/master/index.html#large_const_arrays
 [`large_digit_groups`]: https://rust-lang.github.io/rust-clippy/master/index.html#large_digit_groups
 [`large_enum_variant`]: https://rust-lang.github.io/rust-clippy/master/index.html#large_enum_variant
+[`large_include_file`]: https://rust-lang.github.io/rust-clippy/master/index.html#large_include_file
 [`large_stack_arrays`]: https://rust-lang.github.io/rust-clippy/master/index.html#large_stack_arrays
 [`large_types_passed_by_value`]: https://rust-lang.github.io/rust-clippy/master/index.html#large_types_passed_by_value
 [`len_without_is_empty`]: https://rust-lang.github.io/rust-clippy/master/index.html#len_without_is_empty
diff --git a/clippy_lints/src/large_include_file.rs b/clippy_lints/src/large_include_file.rs
new file mode 100644
index 00000000000..5ed275726c5
--- /dev/null
+++ b/clippy_lints/src/large_include_file.rs
@@ -0,0 +1,86 @@
+use clippy_utils::diagnostics::span_lint_and_note;
+use clippy_utils::is_lint_allowed;
+use clippy_utils::macros::root_macro_call_first_node;
+use rustc_ast::LitKind;
+use rustc_hir::Expr;
+use rustc_hir::ExprKind;
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::sym;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for the inclusion of large files via `include_bytes!()`
+    /// and `include_str!()`
+    ///
+    /// ### Why is this bad?
+    /// Including large files can increase the size of the binary
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// let included_str = include_str!("very_large_file.txt");
+    /// let included_bytes = include_bytes!("very_large_file.txt);
+    /// ```
+    ///
+    /// Instead, you can load the file at runtime:
+    /// ```rust,ignore
+    /// use std::fs;
+    ///
+    /// let string = fs::read_to_string("very_large_file.txt")?;
+    /// let bytes = fs::read("very_large_file.txt")?;
+    /// ```
+    #[clippy::version = "1.62.0"]
+    pub LARGE_INCLUDE_FILE,
+    restriction,
+    "including a large file"
+}
+
+pub struct LargeIncludeFile {
+    max_file_size: u64,
+}
+
+impl LargeIncludeFile {
+    #[must_use]
+    pub fn new(max_file_size: u64) -> Self {
+        Self { max_file_size }
+    }
+}
+
+impl_lint_pass!(LargeIncludeFile => [LARGE_INCLUDE_FILE]);
+
+impl LateLintPass<'_> for LargeIncludeFile {
+    fn check_expr(&mut self, cx: &LateContext<'_>, expr: &'_ Expr<'_>) {
+        if_chain! {
+            if let Some(macro_call) = root_macro_call_first_node(cx, expr);
+            if !is_lint_allowed(cx, LARGE_INCLUDE_FILE, expr.hir_id);
+            if cx.tcx.is_diagnostic_item(sym::include_bytes_macro, macro_call.def_id)
+            || cx.tcx.is_diagnostic_item(sym::include_str_macro, macro_call.def_id);
+            if let ExprKind::Lit(lit) = &expr.kind;
+            then {
+                let len = match &lit.node {
+                    // include_bytes
+                    LitKind::ByteStr(bstr) => bstr.len(),
+                    // include_str
+                    LitKind::Str(sym, _) => sym.as_str().len(),
+                    _ => return,
+                };
+
+                if len as u64 <= self.max_file_size {
+                    return;
+                }
+
+                span_lint_and_note(
+                    cx,
+                    LARGE_INCLUDE_FILE,
+                    expr.span,
+                    "attempted to include a large file",
+                    None,
+                    &format!(
+                        "the configuration allows a maximum size of {} bytes",
+                        self.max_file_size
+                    ),
+                );
+            }
+        }
+    }
+}
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 8507531c8d3..e3624316027 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -209,6 +209,7 @@ store.register_lints(&[
     iter_not_returning_iterator::ITER_NOT_RETURNING_ITERATOR,
     large_const_arrays::LARGE_CONST_ARRAYS,
     large_enum_variant::LARGE_ENUM_VARIANT,
+    large_include_file::LARGE_INCLUDE_FILE,
     large_stack_arrays::LARGE_STACK_ARRAYS,
     len_zero::COMPARISON_TO_EMPTY,
     len_zero::LEN_WITHOUT_IS_EMPTY,
diff --git a/clippy_lints/src/lib.register_restriction.rs b/clippy_lints/src/lib.register_restriction.rs
index 46c79c56a47..77ec6c83ba4 100644
--- a/clippy_lints/src/lib.register_restriction.rs
+++ b/clippy_lints/src/lib.register_restriction.rs
@@ -27,6 +27,7 @@ store.register_group(true, "clippy::restriction", Some("clippy_restriction"), ve
     LintId::of(indexing_slicing::INDEXING_SLICING),
     LintId::of(inherent_impl::MULTIPLE_INHERENT_IMPL),
     LintId::of(integer_division::INTEGER_DIVISION),
+    LintId::of(large_include_file::LARGE_INCLUDE_FILE),
     LintId::of(let_underscore::LET_UNDERSCORE_MUST_USE),
     LintId::of(literal_representation::DECIMAL_LITERAL_REPRESENTATION),
     LintId::of(map_err_ignore::MAP_ERR_IGNORE),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 335467bf9d2..57d48e17627 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -262,6 +262,7 @@ mod items_after_statements;
 mod iter_not_returning_iterator;
 mod large_const_arrays;
 mod large_enum_variant;
+mod large_include_file;
 mod large_stack_arrays;
 mod len_zero;
 mod let_if_seq;
@@ -884,6 +885,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_early_pass(|| Box::new(pub_use::PubUse));
     store.register_late_pass(|| Box::new(format_push_string::FormatPushString));
     store.register_late_pass(|| Box::new(bytes_count_to_len::BytesCountToLen));
+    let max_include_file_size = conf.max_include_file_size;
+    store.register_late_pass(move || Box::new(large_include_file::LargeIncludeFile::new(max_include_file_size)));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index e6abe499b43..74b0168a179 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -312,6 +312,10 @@ define_Conf! {
     (max_suggested_slice_pattern_length: u64 = 3),
     /// Lint: AWAIT_HOLDING_INVALID_TYPE
     (await_holding_invalid_types: Vec<crate::utils::conf::DisallowedType> = Vec::new()),
+    /// Lint: LARGE_INCLUDE_FILE.
+    ///
+    /// The maximum size of a file included via `include_bytes!()` or `include_str!()`, in bytes
+    (max_include_file_size: u64 = 1_000_000),
 }
 
 /// Search for the configuration file.
diff --git a/tests/ui-toml/large_include_file/clippy.toml b/tests/ui-toml/large_include_file/clippy.toml
new file mode 100644
index 00000000000..ea34bf9fbe0
--- /dev/null
+++ b/tests/ui-toml/large_include_file/clippy.toml
@@ -0,0 +1 @@
+max-include-file-size = 600
diff --git a/tests/ui-toml/large_include_file/large_include_file.rs b/tests/ui-toml/large_include_file/large_include_file.rs
new file mode 100644
index 00000000000..f3dbb6ad1cf
--- /dev/null
+++ b/tests/ui-toml/large_include_file/large_include_file.rs
@@ -0,0 +1,16 @@
+#![warn(clippy::large_include_file)]
+
+// Good
+const GOOD_INCLUDE_BYTES: &[u8; 581] = include_bytes!("large_include_file.rs");
+const GOOD_INCLUDE_STR: &str = include_str!("large_include_file.rs");
+
+#[allow(clippy::large_include_file)]
+const ALLOWED_TOO_BIG_INCLUDE_BYTES: &[u8; 654] = include_bytes!("too_big.txt");
+#[allow(clippy::large_include_file)]
+const ALLOWED_TOO_BIG_INCLUDE_STR: &str = include_str!("too_big.txt");
+
+// Bad
+const TOO_BIG_INCLUDE_BYTES: &[u8; 654] = include_bytes!("too_big.txt");
+const TOO_BIG_INCLUDE_STR: &str = include_str!("too_big.txt");
+
+fn main() {}
diff --git a/tests/ui-toml/large_include_file/large_include_file.stderr b/tests/ui-toml/large_include_file/large_include_file.stderr
new file mode 100644
index 00000000000..6a685a58318
--- /dev/null
+++ b/tests/ui-toml/large_include_file/large_include_file.stderr
@@ -0,0 +1,21 @@
+error: attempted to include a large file
+  --> $DIR/large_include_file.rs:13:43
+   |
+LL | const TOO_BIG_INCLUDE_BYTES: &[u8; 654] = include_bytes!("too_big.txt");
+   |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::large-include-file` implied by `-D warnings`
+   = note: the configuration allows a maximum size of 600 bytes
+   = note: this error originates in the macro `include_bytes` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: attempted to include a large file
+  --> $DIR/large_include_file.rs:14:35
+   |
+LL | const TOO_BIG_INCLUDE_STR: &str = include_str!("too_big.txt");
+   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: the configuration allows a maximum size of 600 bytes
+   = note: this error originates in the macro `include_str` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: aborting due to 2 previous errors
+
diff --git a/tests/ui-toml/large_include_file/too_big.txt b/tests/ui-toml/large_include_file/too_big.txt
new file mode 100644
index 00000000000..9829c46bc00
--- /dev/null
+++ b/tests/ui-toml/large_include_file/too_big.txt
@@ -0,0 +1 @@
+Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Maecenas accumsan lacus vel facilisis volutpat. Etiam dignissim diam quis enim lobortis scelerisque fermentum dui faucibus. Tellus id interdum velit laoreet id donec ultrices. Est ultricies integer quis auctor elit sed vulputate. Erat velit scelerisque in dictum non consectetur a erat nam. Sed blandit libero volutpat sed. Tortor condimentum lacinia quis vel eros. Enim ut tellus elementum sagittis vitae et leo duis. Congue mauris rhoncus aenean vel elit scelerisque. Id consectetur purus ut faucibus pulvinar elementum integer.
\ No newline at end of file
diff --git a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
index f60afb8d4e3..8701809b4da 100644
--- a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
+++ b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
@@ -1,4 +1,4 @@
-error: error reading Clippy's configuration file `$DIR/clippy.toml`: unknown field `foobar`, expected one of `avoid-breaking-exported-api`, `msrv`, `blacklisted-names`, `cognitive-complexity-threshold`, `cyclomatic-complexity-threshold`, `doc-valid-idents`, `too-many-arguments-threshold`, `type-complexity-threshold`, `single-char-binding-names-threshold`, `too-large-for-stack`, `enum-variant-name-threshold`, `enum-variant-size-threshold`, `verbose-bit-mask-threshold`, `literal-representation-threshold`, `trivial-copy-size-limit`, `pass-by-value-size-limit`, `too-many-lines-threshold`, `array-size-threshold`, `vec-box-size-threshold`, `max-trait-bounds`, `max-struct-bools`, `max-fn-params-bools`, `warn-on-all-wildcard-imports`, `disallowed-methods`, `disallowed-types`, `unreadable-literal-lint-fractions`, `upper-case-acronyms-aggressive`, `cargo-ignore-publish`, `standard-macro-braces`, `enforced-import-renames`, `allowed-scripts`, `enable-raw-pointer-heuristic-for-send`, `max-suggested-slice-pattern-length`, `await-holding-invalid-types`, `third-party` at line 5 column 1
+error: error reading Clippy's configuration file `$DIR/clippy.toml`: unknown field `foobar`, expected one of `avoid-breaking-exported-api`, `msrv`, `blacklisted-names`, `cognitive-complexity-threshold`, `cyclomatic-complexity-threshold`, `doc-valid-idents`, `too-many-arguments-threshold`, `type-complexity-threshold`, `single-char-binding-names-threshold`, `too-large-for-stack`, `enum-variant-name-threshold`, `enum-variant-size-threshold`, `verbose-bit-mask-threshold`, `literal-representation-threshold`, `trivial-copy-size-limit`, `pass-by-value-size-limit`, `too-many-lines-threshold`, `array-size-threshold`, `vec-box-size-threshold`, `max-trait-bounds`, `max-struct-bools`, `max-fn-params-bools`, `warn-on-all-wildcard-imports`, `disallowed-methods`, `disallowed-types`, `unreadable-literal-lint-fractions`, `upper-case-acronyms-aggressive`, `cargo-ignore-publish`, `standard-macro-braces`, `enforced-import-renames`, `allowed-scripts`, `enable-raw-pointer-heuristic-for-send`, `max-suggested-slice-pattern-length`, `await-holding-invalid-types`, `max-include-file-size`, `third-party` at line 5 column 1
 
 error: aborting due to previous error
 
-- 
cgit 1.4.1-3-g733a5


From cf99f504fde3cab40e4b961281e53bbe18858829 Mon Sep 17 00:00:00 2001
From: asquared31415 <34665709+asquared31415@users.noreply.github.com>
Date: Sun, 24 Apr 2022 19:41:43 -0400
Subject: remove extra lifetime

---
 clippy_lints/src/casts/cast_slice_different_sizes.rs | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/cast_slice_different_sizes.rs b/clippy_lints/src/casts/cast_slice_different_sizes.rs
index 893af60db2c..16c9e49ff11 100644
--- a/clippy_lints/src/casts/cast_slice_different_sizes.rs
+++ b/clippy_lints/src/casts/cast_slice_different_sizes.rs
@@ -8,7 +8,7 @@ use rustc_semver::RustcVersion;
 
 use super::CAST_SLICE_DIFFERENT_SIZES;
 
-pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, msrv: &Option<RustcVersion>) {
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>, msrv: &Option<RustcVersion>) {
     // suggestion is invalid if `ptr::slice_from_raw_parts` does not exist
     if !meets_msrv(msrv.as_ref(), &msrvs::PTR_SLICE_RAW_PARTS) {
         return;
@@ -102,21 +102,20 @@ fn get_raw_slice_ty_mut(ty: Ty<'_>) -> Option<TypeAndMut<'_>> {
     }
 }
 
-struct CastChainInfo<'expr, 'tcx> {
+struct CastChainInfo<'tcx> {
     /// The left most part of the cast chain, or in other words, the first cast in the chain
     /// Used for diagnostics
-    left_cast: &'expr Expr<'expr>,
+    left_cast: &'tcx Expr<'tcx>,
     /// The starting type of the cast chain
     start_ty: TypeAndMut<'tcx>,
     /// The final type of the cast chain
     end_ty: TypeAndMut<'tcx>,
 }
 
-// FIXME(asquared31415): unbounded recursion linear with the number of casts in an expression
 /// Returns a `CastChainInfo` with the left-most cast in the chain and the original ptr T and final
 /// ptr U if the expression is composed of casts.
 /// Returns None if the expr is not a Cast
-fn expr_cast_chain_tys<'tcx, 'expr>(cx: &LateContext<'tcx>, expr: &Expr<'expr>) -> Option<CastChainInfo<'expr, 'tcx>> {
+fn expr_cast_chain_tys<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>) -> Option<CastChainInfo<'tcx>> {
     if let ExprKind::Cast(cast_expr, _cast_to_hir_ty) = expr.peel_blocks().kind {
         let cast_to = cx.typeck_results().expr_ty(expr);
         let to_slice_ty = get_raw_slice_ty_mut(cast_to)?;
-- 
cgit 1.4.1-3-g733a5


From e6fa163fad15963be686d2bad121f44c8a407d90 Mon Sep 17 00:00:00 2001
From: "Samuel E. Moelius III" <sam@moeli.us>
Date: Mon, 25 Apr 2022 05:20:08 -0400
Subject: Fix false positives

---
 clippy_lints/src/lifetimes.rs      |  1 +
 tests/ui/extra_unused_lifetimes.rs | 26 ++++++++++++++++++++++++++
 2 files changed, 27 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lifetimes.rs b/clippy_lints/src/lifetimes.rs
index ec74b8606d9..b7bf5f05f7c 100644
--- a/clippy_lints/src/lifetimes.rs
+++ b/clippy_lints/src/lifetimes.rs
@@ -565,6 +565,7 @@ fn report_extra_impl_lifetimes<'tcx>(cx: &LateContext<'tcx>, impl_: &'tcx Impl<'
         .collect();
     let mut checker = LifetimeChecker::<mir_nested_filter::All>::new(cx, hs);
 
+    walk_generics(&mut checker, &impl_.generics);
     if let Some(ref trait_ref) = impl_.of_trait {
         walk_trait_ref(&mut checker, trait_ref);
     }
diff --git a/tests/ui/extra_unused_lifetimes.rs b/tests/ui/extra_unused_lifetimes.rs
index 69dc2f7965e..f76127a7105 100644
--- a/tests/ui/extra_unused_lifetimes.rs
+++ b/tests/ui/extra_unused_lifetimes.rs
@@ -88,4 +88,30 @@ mod issue6437 {
     }
 }
 
+// https://github.com/rust-lang/rust-clippy/pull/8737#pullrequestreview-951268213
+mod first_case {
+    use serde::de::Visitor;
+    pub trait Expected {
+        fn fmt(&self, formatter: &mut std::fmt::Formatter);
+    }
+
+    impl<'de, T> Expected for T
+    where
+        T: Visitor<'de>,
+    {
+        fn fmt(&self, formatter: &mut std::fmt::Formatter) {}
+    }
+}
+
+// https://github.com/rust-lang/rust-clippy/pull/8737#pullrequestreview-951268213
+mod second_case {
+    pub trait Source {
+        fn hey();
+    }
+
+    impl<'a, T: Source + ?Sized + 'a> Source for Box<T> {
+        fn hey() {}
+    }
+}
+
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From c22bb06bc02c81c132ef2dbb5513b6faac09688c Mon Sep 17 00:00:00 2001
From: "Samuel E. Moelius III" <sam@moeli.us>
Date: Mon, 25 Apr 2022 09:23:59 -0400
Subject: Fix naming

---
 clippy_lints/src/lifetimes.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lifetimes.rs b/clippy_lints/src/lifetimes.rs
index b7bf5f05f7c..54b80bf3b27 100644
--- a/clippy_lints/src/lifetimes.rs
+++ b/clippy_lints/src/lifetimes.rs
@@ -13,7 +13,7 @@ use rustc_hir::{
     TraitFn, TraitItem, TraitItemKind, Ty, TyKind, WhereClause, WherePredicate,
 };
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::hir::nested_filter as mir_nested_filter;
+use rustc_middle::hir::nested_filter as middle_nested_filter;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
 use rustc_span::symbol::{kw, Ident, Symbol};
@@ -563,7 +563,7 @@ fn report_extra_impl_lifetimes<'tcx>(cx: &LateContext<'tcx>, impl_: &'tcx Impl<'
             _ => None,
         })
         .collect();
-    let mut checker = LifetimeChecker::<mir_nested_filter::All>::new(cx, hs);
+    let mut checker = LifetimeChecker::<middle_nested_filter::All>::new(cx, hs);
 
     walk_generics(&mut checker, &impl_.generics);
     if let Some(ref trait_ref) = impl_.of_trait {
-- 
cgit 1.4.1-3-g733a5


From 1d1fecff0fbb727919067a1a6a5d28d30c693cd3 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Fri, 1 Apr 2022 18:23:47 +0100
Subject: `needless_late_init`: ignore `if let`, `let mut` and significant
 drops

---
 .../src/matches/redundant_pattern_match.rs         | 66 ++-----------------
 clippy_lints/src/needless_late_init.rs             | 40 ++++++++++--
 clippy_utils/src/ty.rs                             | 71 ++++++++++++++++++++-
 tests/ui/needless_late_init.rs                     | 74 ++++++++++++++++++----
 tests/ui/needless_late_init.stderr                 | 72 ++++++++++++---------
 tests/ui/needless_late_init_fixable.fixed          |  8 +--
 tests/ui/needless_late_init_fixable.rs             | 10 +--
 tests/ui/needless_late_init_fixable.stderr         | 19 ++----
 8 files changed, 221 insertions(+), 139 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/redundant_pattern_match.rs b/clippy_lints/src/matches/redundant_pattern_match.rs
index 777ec9b75bc..a34ed58c9c3 100644
--- a/clippy_lints/src/matches/redundant_pattern_match.rs
+++ b/clippy_lints/src/matches/redundant_pattern_match.rs
@@ -2,17 +2,16 @@ use super::REDUNDANT_PATTERN_MATCHING;
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet;
 use clippy_utils::sugg::Sugg;
-use clippy_utils::ty::{implements_trait, is_type_diagnostic_item, is_type_lang_item, match_type};
+use clippy_utils::ty::needs_ordered_drop;
 use clippy_utils::{higher, match_def_path};
 use clippy_utils::{is_lang_ctor, is_trait_method, paths};
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
-use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Applicability;
 use rustc_hir::LangItem::{OptionNone, PollPending};
 use rustc_hir::{
     intravisit::{walk_expr, Visitor},
-    Arm, Block, Expr, ExprKind, LangItem, Node, Pat, PatKind, QPath, UnOp,
+    Arm, Block, Expr, ExprKind, Node, Pat, PatKind, QPath, UnOp,
 };
 use rustc_lint::LateContext;
 use rustc_middle::ty::{self, subst::GenericArgKind, DefIdTree, Ty};
@@ -32,59 +31,6 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
     }
 }
 
-/// Checks if the drop order for a type matters. Some std types implement drop solely to
-/// deallocate memory. For these types, and composites containing them, changing the drop order
-/// won't result in any observable side effects.
-fn type_needs_ordered_drop<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
-    type_needs_ordered_drop_inner(cx, ty, &mut FxHashSet::default())
-}
-
-fn type_needs_ordered_drop_inner<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>, seen: &mut FxHashSet<Ty<'tcx>>) -> bool {
-    if !seen.insert(ty) {
-        return false;
-    }
-    if !ty.needs_drop(cx.tcx, cx.param_env) {
-        false
-    } else if !cx
-        .tcx
-        .lang_items()
-        .drop_trait()
-        .map_or(false, |id| implements_trait(cx, ty, id, &[]))
-    {
-        // This type doesn't implement drop, so no side effects here.
-        // Check if any component type has any.
-        match ty.kind() {
-            ty::Tuple(fields) => fields.iter().any(|ty| type_needs_ordered_drop_inner(cx, ty, seen)),
-            ty::Array(ty, _) => type_needs_ordered_drop_inner(cx, *ty, seen),
-            ty::Adt(adt, subs) => adt
-                .all_fields()
-                .map(|f| f.ty(cx.tcx, subs))
-                .any(|ty| type_needs_ordered_drop_inner(cx, ty, seen)),
-            _ => true,
-        }
-    }
-    // Check for std types which implement drop, but only for memory allocation.
-    else if is_type_diagnostic_item(cx, ty, sym::Vec)
-        || is_type_lang_item(cx, ty, LangItem::OwnedBox)
-        || is_type_diagnostic_item(cx, ty, sym::Rc)
-        || is_type_diagnostic_item(cx, ty, sym::Arc)
-        || is_type_diagnostic_item(cx, ty, sym::cstring_type)
-        || is_type_diagnostic_item(cx, ty, sym::BTreeMap)
-        || is_type_diagnostic_item(cx, ty, sym::LinkedList)
-        || match_type(cx, ty, &paths::WEAK_RC)
-        || match_type(cx, ty, &paths::WEAK_ARC)
-    {
-        // Check all of the generic arguments.
-        if let ty::Adt(_, subs) = ty.kind() {
-            subs.types().any(|ty| type_needs_ordered_drop_inner(cx, ty, seen))
-        } else {
-            true
-        }
-    } else {
-        true
-    }
-}
-
 // Extract the generic arguments out of a type
 fn try_get_generic_ty(ty: Ty<'_>, index: usize) -> Option<Ty<'_>> {
     if_chain! {
@@ -115,7 +61,7 @@ fn temporaries_need_ordered_drop<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<
                 // e.g. In `(String::new(), 0).1` the string is a temporary value.
                 ExprKind::AddrOf(_, _, expr) | ExprKind::Field(expr, _) => {
                     if !matches!(expr.kind, ExprKind::Path(_)) {
-                        if type_needs_ordered_drop(self.cx, self.cx.typeck_results().expr_ty(expr)) {
+                        if needs_ordered_drop(self.cx, self.cx.typeck_results().expr_ty(expr)) {
                             self.res = true;
                         } else {
                             self.visit_expr(expr);
@@ -126,7 +72,7 @@ fn temporaries_need_ordered_drop<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<
                 // e.g. In `(vec![0])[0]` the vector is a temporary value.
                 ExprKind::Index(base, index) => {
                     if !matches!(base.kind, ExprKind::Path(_)) {
-                        if type_needs_ordered_drop(self.cx, self.cx.typeck_results().expr_ty(base)) {
+                        if needs_ordered_drop(self.cx, self.cx.typeck_results().expr_ty(base)) {
                             self.res = true;
                         } else {
                             self.visit_expr(base);
@@ -143,7 +89,7 @@ fn temporaries_need_ordered_drop<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<
                             .typeck_results()
                             .type_dependent_def_id(expr.hir_id)
                             .map_or(false, |id| self.cx.tcx.fn_sig(id).skip_binder().inputs()[0].is_ref());
-                        if self_by_ref && type_needs_ordered_drop(self.cx, self.cx.typeck_results().expr_ty(self_arg)) {
+                        if self_by_ref && needs_ordered_drop(self.cx, self.cx.typeck_results().expr_ty(self_arg)) {
                             self.res = true;
                         } else {
                             self.visit_expr(self_arg);
@@ -243,7 +189,7 @@ fn find_sugg_for_if_let<'tcx>(
     // scrutinee would be, so they have to be considered as well.
     // e.g. in `if let Some(x) = foo.lock().unwrap().baz.as_ref() { .. }` the lock will be held
     // for the duration if body.
-    let needs_drop = type_needs_ordered_drop(cx, check_ty) || temporaries_need_ordered_drop(cx, let_expr);
+    let needs_drop = needs_ordered_drop(cx, check_ty) || temporaries_need_ordered_drop(cx, let_expr);
 
     // check that `while_let_on_iterator` lint does not trigger
     if_chain! {
diff --git a/clippy_lints/src/needless_late_init.rs b/clippy_lints/src/needless_late_init.rs
index bbcf7e9e378..a863a7990ca 100644
--- a/clippy_lints/src/needless_late_init.rs
+++ b/clippy_lints/src/needless_late_init.rs
@@ -1,10 +1,14 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::path_to_local;
 use clippy_utils::source::snippet_opt;
-use clippy_utils::visitors::{expr_visitor, is_local_used};
+use clippy_utils::ty::needs_ordered_drop;
+use clippy_utils::visitors::{expr_visitor, expr_visitor_no_bodies, is_local_used};
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::Visitor;
-use rustc_hir::{Block, Expr, ExprKind, HirId, Local, LocalSource, MatchSource, Node, Pat, PatKind, Stmt, StmtKind};
+use rustc_hir::{
+    BindingAnnotation, Block, Expr, ExprKind, HirId, Local, LocalSource, MatchSource, Node, Pat, PatKind, Stmt,
+    StmtKind,
+};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::Span;
@@ -73,6 +77,31 @@ fn contains_assign_expr<'tcx>(cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'tcx>) ->
     seen
 }
 
+fn contains_let(cond: &Expr<'_>) -> bool {
+    let mut seen = false;
+    expr_visitor_no_bodies(|expr| {
+        if let ExprKind::Let(_) = expr.kind {
+            seen = true;
+        }
+
+        !seen
+    })
+    .visit_expr(cond);
+
+    seen
+}
+
+fn stmt_needs_ordered_drop(cx: &LateContext<'_>, stmt: &Stmt<'_>) -> bool {
+    let StmtKind::Local(local) = stmt.kind else { return false };
+    !local.pat.walk_short(|pat| {
+        if let PatKind::Binding(.., None) = pat.kind {
+            !needs_ordered_drop(cx, cx.typeck_results().pat_ty(pat))
+        } else {
+            true
+        }
+    })
+}
+
 #[derive(Debug)]
 struct LocalAssign {
     lhs_id: HirId,
@@ -187,11 +216,14 @@ fn first_usage<'tcx>(
     local_stmt_id: HirId,
     block: &'tcx Block<'tcx>,
 ) -> Option<Usage<'tcx>> {
+    let significant_drop = needs_ordered_drop(cx, cx.typeck_results().node_type(binding_id));
+
     block
         .stmts
         .iter()
         .skip_while(|stmt| stmt.hir_id != local_stmt_id)
         .skip(1)
+        .take_while(|stmt| !significant_drop || !stmt_needs_ordered_drop(cx, stmt))
         .find(|&stmt| is_local_used(cx, stmt, binding_id))
         .and_then(|stmt| match stmt.kind {
             StmtKind::Expr(expr) => Some(Usage {
@@ -258,7 +290,7 @@ fn check<'tcx>(
                 },
             );
         },
-        ExprKind::If(_, then_expr, Some(else_expr)) => {
+        ExprKind::If(cond, then_expr, Some(else_expr)) if !contains_let(cond) => {
             let (applicability, suggestions) = assignment_suggestions(cx, binding_id, [then_expr, else_expr])?;
 
             span_lint_and_then(
@@ -338,7 +370,7 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessLateInit {
             if let Local {
                 init: None,
                 pat: &Pat {
-                    kind: PatKind::Binding(_, binding_id, _, None),
+                    kind: PatKind::Binding(BindingAnnotation::Unannotated, binding_id, _, None),
                     ..
                 },
                 source: LocalSource::Normal,
diff --git a/clippy_utils/src/ty.rs b/clippy_utils/src/ty.rs
index e3fc76f4e1a..901e3e5390c 100644
--- a/clippy_utils/src/ty.rs
+++ b/clippy_utils/src/ty.rs
@@ -3,11 +3,11 @@
 #![allow(clippy::module_name_repetitions)]
 
 use rustc_ast::ast::Mutability;
-use rustc_data_structures::fx::FxHashMap;
+use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_hir as hir;
 use rustc_hir::def::{CtorKind, DefKind, Res};
 use rustc_hir::def_id::DefId;
-use rustc_hir::{Expr, TyKind, Unsafety};
+use rustc_hir::{Expr, LangItem, TyKind, Unsafety};
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::LateContext;
 use rustc_middle::mir::interpret::{ConstValue, Scalar};
@@ -22,7 +22,7 @@ use rustc_trait_selection::infer::InferCtxtExt;
 use rustc_trait_selection::traits::query::normalize::AtExt;
 use std::iter;
 
-use crate::{match_def_path, must_use_attr, path_res};
+use crate::{match_def_path, must_use_attr, path_res, paths};
 
 // Checks if the given type implements copy.
 pub fn is_copy<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
@@ -83,6 +83,20 @@ pub fn get_associated_type<'tcx>(
         })
 }
 
+/// Get the diagnostic name of a type, e.g. `sym::HashMap`. To check if a type
+/// implements a trait marked with a diagnostic item use [`implements_trait`].
+///
+/// For a further exploitation what diagnostic items are see [diagnostic items] in
+/// rustc-dev-guide.
+///
+/// [Diagnostic Items]: https://rustc-dev-guide.rust-lang.org/diagnostics/diagnostic-items.html
+pub fn get_type_diagnostic_name(cx: &LateContext<'_>, ty: Ty<'_>) -> Option<Symbol> {
+    match ty.kind() {
+        ty::Adt(adt, _) => cx.tcx.get_diagnostic_name(adt.did()),
+        _ => None,
+    }
+}
+
 /// Returns true if ty has `iter` or `iter_mut` methods
 pub fn has_iter_method(cx: &LateContext<'_>, probably_ref_ty: Ty<'_>) -> Option<Symbol> {
     // FIXME: instead of this hard-coded list, we should check if `<adt>::iter`
@@ -319,6 +333,57 @@ pub fn match_type(cx: &LateContext<'_>, ty: Ty<'_>, path: &[&str]) -> bool {
     }
 }
 
+/// Checks if the drop order for a type matters. Some std types implement drop solely to
+/// deallocate memory. For these types, and composites containing them, changing the drop order
+/// won't result in any observable side effects.
+pub fn needs_ordered_drop<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
+    fn needs_ordered_drop_inner<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>, seen: &mut FxHashSet<Ty<'tcx>>) -> bool {
+        if !seen.insert(ty) {
+            return false;
+        }
+        if !ty.has_significant_drop(cx.tcx, cx.param_env) {
+            false
+        }
+        // Check for std types which implement drop, but only for memory allocation.
+        else if is_type_lang_item(cx, ty, LangItem::OwnedBox)
+            || matches!(
+                get_type_diagnostic_name(cx, ty),
+                Some(sym::HashSet | sym::Rc | sym::Arc | sym::cstring_type)
+            )
+            || match_type(cx, ty, &paths::WEAK_RC)
+            || match_type(cx, ty, &paths::WEAK_ARC)
+        {
+            // Check all of the generic arguments.
+            if let ty::Adt(_, subs) = ty.kind() {
+                subs.types().any(|ty| needs_ordered_drop_inner(cx, ty, seen))
+            } else {
+                true
+            }
+        } else if !cx
+            .tcx
+            .lang_items()
+            .drop_trait()
+            .map_or(false, |id| implements_trait(cx, ty, id, &[]))
+        {
+            // This type doesn't implement drop, so no side effects here.
+            // Check if any component type has any.
+            match ty.kind() {
+                ty::Tuple(fields) => fields.iter().any(|ty| needs_ordered_drop_inner(cx, ty, seen)),
+                ty::Array(ty, _) => needs_ordered_drop_inner(cx, *ty, seen),
+                ty::Adt(adt, subs) => adt
+                    .all_fields()
+                    .map(|f| f.ty(cx.tcx, subs))
+                    .any(|ty| needs_ordered_drop_inner(cx, ty, seen)),
+                _ => true,
+            }
+        } else {
+            true
+        }
+    }
+
+    needs_ordered_drop_inner(cx, ty, &mut FxHashSet::default())
+}
+
 /// Peels off all references on the type. Returns the underlying type and the number of references
 /// removed.
 pub fn peel_mid_ty_refs(ty: Ty<'_>) -> (Ty<'_>, usize) {
diff --git a/tests/ui/needless_late_init.rs b/tests/ui/needless_late_init.rs
index 3cfbfb6033b..54e66b391b8 100644
--- a/tests/ui/needless_late_init.rs
+++ b/tests/ui/needless_late_init.rs
@@ -1,5 +1,15 @@
-#![allow(unused)]
-#![allow(clippy::let_unit_value)]
+#![feature(let_chains)]
+#![allow(unused, clippy::nonminimal_bool, clippy::let_unit_value)]
+
+use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
+use std::rc::Rc;
+
+struct SignificantDrop;
+impl std::ops::Drop for SignificantDrop {
+    fn drop(&mut self) {
+        println!("dropped");
+    }
+}
 
 fn main() {
     let a;
@@ -18,13 +28,6 @@ fn main() {
         b = "five"
     }
 
-    let c;
-    if let Some(n) = Some(5) {
-        c = n;
-    } else {
-        c = -50;
-    }
-
     let d;
     if true {
         let temp = 5;
@@ -37,7 +40,7 @@ fn main() {
     if true {
         e = format!("{} {}", a, b);
     } else {
-        e = format!("{}", c);
+        e = format!("{}", n);
     }
 
     let f;
@@ -53,7 +56,27 @@ fn main() {
         panic!();
     }
 
-    println!("{}", a);
+    // Drop order only matters if both are significant
+    let x;
+    let y = SignificantDrop;
+    x = 1;
+
+    let x;
+    let y = 1;
+    x = SignificantDrop;
+
+    let x;
+    // types that should be considered insignificant
+    let y = 1;
+    let y = "2";
+    let y = String::new();
+    let y = vec![3.0];
+    let y = HashMap::<usize, usize>::new();
+    let y = BTreeMap::<usize, usize>::new();
+    let y = HashSet::<usize>::new();
+    let y = BTreeSet::<usize>::new();
+    let y = Box::new(4);
+    x = SignificantDrop;
 }
 
 async fn in_async() -> &'static str {
@@ -177,5 +200,32 @@ fn does_not_lint() {
     }
     in_macro!();
 
-    println!("{}", x);
+    // ignore if-lets - https://github.com/rust-lang/rust-clippy/issues/8613
+    let x;
+    if let Some(n) = Some("v") {
+        x = 1;
+    } else {
+        x = 2;
+    }
+
+    let x;
+    if true && let Some(n) = Some("let chains too") {
+        x = 1;
+    } else {
+        x = 2;
+    }
+
+    // ignore mut bindings
+    // https://github.com/shepmaster/twox-hash/blob/b169c16d86eb8ea4a296b0acb9d00ca7e3c3005f/src/sixty_four.rs#L88-L93
+    // https://github.com/dtolnay/thiserror/blob/21c26903e29cb92ba1a7ff11e82ae2001646b60d/tests/test_generics.rs#L91-L100
+    let mut x: usize;
+    x = 1;
+    x = 2;
+    x = 3;
+
+    // should not move the declaration if `x` has a significant drop, and there
+    // is another binding with a significant drop between it and the first usage
+    let x;
+    let y = SignificantDrop;
+    x = SignificantDrop;
 }
diff --git a/tests/ui/needless_late_init.stderr b/tests/ui/needless_late_init.stderr
index 124fe5592c3..015c173561a 100644
--- a/tests/ui/needless_late_init.stderr
+++ b/tests/ui/needless_late_init.stderr
@@ -1,5 +1,5 @@
 error: unneeded late initialization
-  --> $DIR/needless_late_init.rs:5:5
+  --> $DIR/needless_late_init.rs:15:5
    |
 LL |     let a;
    |     ^^^^^^
@@ -21,7 +21,7 @@ LL |     };
    |      +
 
 error: unneeded late initialization
-  --> $DIR/needless_late_init.rs:14:5
+  --> $DIR/needless_late_init.rs:24:5
    |
 LL |     let b;
    |     ^^^^^^
@@ -42,28 +42,7 @@ LL |     };
    |      +
 
 error: unneeded late initialization
-  --> $DIR/needless_late_init.rs:21:5
-   |
-LL |     let c;
-   |     ^^^^^^
-   |
-help: declare `c` here
-   |
-LL |     let c = if let Some(n) = Some(5) {
-   |     +++++++
-help: remove the assignments from the branches
-   |
-LL ~         n
-LL |     } else {
-LL ~         -50
-   |
-help: add a semicolon after the `if` expression
-   |
-LL |     };
-   |      +
-
-error: unneeded late initialization
-  --> $DIR/needless_late_init.rs:28:5
+  --> $DIR/needless_late_init.rs:31:5
    |
 LL |     let d;
    |     ^^^^^^
@@ -84,7 +63,7 @@ LL |     };
    |      +
 
 error: unneeded late initialization
-  --> $DIR/needless_late_init.rs:36:5
+  --> $DIR/needless_late_init.rs:39:5
    |
 LL |     let e;
    |     ^^^^^^
@@ -97,7 +76,7 @@ help: remove the assignments from the branches
    |
 LL ~         format!("{} {}", a, b)
 LL |     } else {
-LL ~         format!("{}", c)
+LL ~         format!("{}", n)
    |
 help: add a semicolon after the `if` expression
    |
@@ -105,7 +84,7 @@ LL |     };
    |      +
 
 error: unneeded late initialization
-  --> $DIR/needless_late_init.rs:43:5
+  --> $DIR/needless_late_init.rs:46:5
    |
 LL |     let f;
    |     ^^^^^^
@@ -121,7 +100,7 @@ LL +         1 => "three",
    | 
 
 error: unneeded late initialization
-  --> $DIR/needless_late_init.rs:49:5
+  --> $DIR/needless_late_init.rs:52:5
    |
 LL |     let g: usize;
    |     ^^^^^^^^^^^^^
@@ -140,9 +119,42 @@ help: add a semicolon after the `if` expression
 LL |     };
    |      +
 
+error: unneeded late initialization
+  --> $DIR/needless_late_init.rs:60:5
+   |
+LL |     let x;
+   |     ^^^^^^
+   |
+help: declare `x` here
+   |
+LL |     let x = 1;
+   |     ~~~~~
+
 error: unneeded late initialization
   --> $DIR/needless_late_init.rs:64:5
    |
+LL |     let x;
+   |     ^^^^^^
+   |
+help: declare `x` here
+   |
+LL |     let x = SignificantDrop;
+   |     ~~~~~
+
+error: unneeded late initialization
+  --> $DIR/needless_late_init.rs:68:5
+   |
+LL |     let x;
+   |     ^^^^^^
+   |
+help: declare `x` here
+   |
+LL |     let x = SignificantDrop;
+   |     ~~~~~
+
+error: unneeded late initialization
+  --> $DIR/needless_late_init.rs:87:5
+   |
 LL |     let a;
    |     ^^^^^^
    |
@@ -162,7 +174,7 @@ LL |     };
    |      +
 
 error: unneeded late initialization
-  --> $DIR/needless_late_init.rs:81:5
+  --> $DIR/needless_late_init.rs:104:5
    |
 LL |     let a;
    |     ^^^^^^
@@ -182,5 +194,5 @@ help: add a semicolon after the `match` expression
 LL |     };
    |      +
 
-error: aborting due to 9 previous errors
+error: aborting due to 11 previous errors
 
diff --git a/tests/ui/needless_late_init_fixable.fixed b/tests/ui/needless_late_init_fixable.fixed
index b516f9d86b7..724477e8691 100644
--- a/tests/ui/needless_late_init_fixable.fixed
+++ b/tests/ui/needless_late_init_fixable.fixed
@@ -15,11 +15,5 @@ fn main() {
     let d: usize = 1;
 
     
-    let mut e = 1;
-    e = 2;
-
-    
-    let h = format!("{}", e);
-
-    println!("{}", a);
+    let e = format!("{}", d);
 }
diff --git a/tests/ui/needless_late_init_fixable.rs b/tests/ui/needless_late_init_fixable.rs
index 75a4bc916de..3e6bd363672 100644
--- a/tests/ui/needless_late_init_fixable.rs
+++ b/tests/ui/needless_late_init_fixable.rs
@@ -14,12 +14,6 @@ fn main() {
     let d: usize;
     d = 1;
 
-    let mut e;
-    e = 1;
-    e = 2;
-
-    let h;
-    h = format!("{}", e);
-
-    println!("{}", a);
+    let e;
+    e = format!("{}", d);
 }
diff --git a/tests/ui/needless_late_init_fixable.stderr b/tests/ui/needless_late_init_fixable.stderr
index 34dccc2cec8..c97cd93fd2f 100644
--- a/tests/ui/needless_late_init_fixable.stderr
+++ b/tests/ui/needless_late_init_fixable.stderr
@@ -46,24 +46,13 @@ LL |     let d: usize = 1;
 error: unneeded late initialization
   --> $DIR/needless_late_init_fixable.rs:17:5
    |
-LL |     let mut e;
-   |     ^^^^^^^^^^
-   |
-help: declare `e` here
-   |
-LL |     let mut e = 1;
-   |     ~~~~~~~~~
-
-error: unneeded late initialization
-  --> $DIR/needless_late_init_fixable.rs:21:5
-   |
-LL |     let h;
+LL |     let e;
    |     ^^^^^^
    |
-help: declare `h` here
+help: declare `e` here
    |
-LL |     let h = format!("{}", e);
+LL |     let e = format!("{}", d);
    |     ~~~~~
 
-error: aborting due to 6 previous errors
+error: aborting due to 5 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 948af01633337b3ab57f0db84d49128c5dbc417b Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Thu, 14 Apr 2022 15:13:10 -0400
Subject: Don't lint `vec_init_then_push` when further extended

---
 clippy_lints/src/vec_init_then_push.rs | 181 ++++++++++++++++++++++-----------
 clippy_utils/src/higher.rs             |  19 ++--
 clippy_utils/src/visitors.rs           |  60 ++++++++++-
 tests/ui/vec_init_then_push.rs         |  42 ++++++++
 tests/ui/vec_init_then_push.stderr     |  24 ++++-
 5 files changed, 255 insertions(+), 71 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/vec_init_then_push.rs b/clippy_lints/src/vec_init_then_push.rs
index fbf2b3e081b..5a5dfcfdc8a 100644
--- a/clippy_lints/src/vec_init_then_push.rs
+++ b/clippy_lints/src/vec_init_then_push.rs
@@ -1,14 +1,18 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::higher::{get_vec_init_kind, VecInitKind};
 use clippy_utils::source::snippet;
-use clippy_utils::{path_to_local, path_to_local_id};
-use if_chain::if_chain;
+use clippy_utils::visitors::for_each_local_use_after_expr;
+use clippy_utils::{get_parent_expr, path_to_local_id};
+use core::ops::ControlFlow;
 use rustc_errors::Applicability;
-use rustc_hir::{BindingAnnotation, Block, Expr, ExprKind, HirId, Local, PatKind, Stmt, StmtKind};
+use rustc_hir::def::Res;
+use rustc_hir::{
+    BindingAnnotation, Block, Expr, ExprKind, HirId, Local, Mutability, PatKind, QPath, Stmt, StmtKind, UnOp,
+};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::Span;
+use rustc_span::{Span, Symbol};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -43,26 +47,86 @@ pub struct VecInitThenPush {
 struct VecPushSearcher {
     local_id: HirId,
     init: VecInitKind,
-    lhs_is_local: bool,
-    lhs_span: Span,
+    lhs_is_let: bool,
+    let_ty_span: Option<Span>,
+    name: Symbol,
     err_span: Span,
-    found: u64,
+    found: u128,
+    last_push_expr: HirId,
 }
 impl VecPushSearcher {
     fn display_err(&self, cx: &LateContext<'_>) {
-        match self.init {
+        let min_pushes_for_extension = match self.init {
             _ if self.found == 0 => return,
-            VecInitKind::WithLiteralCapacity(x) if x > self.found => return,
+            VecInitKind::WithConstCapacity(x) if x > self.found => return,
+            VecInitKind::WithConstCapacity(x) => x,
             VecInitKind::WithExprCapacity(_) => return,
-            _ => (),
+            _ => 3,
         };
 
-        let mut s = if self.lhs_is_local {
+        let mut needs_mut = false;
+        let res = for_each_local_use_after_expr(cx, self.local_id, self.last_push_expr, |e| {
+            let Some(parent) = get_parent_expr(cx, e) else {
+                return ControlFlow::Continue(())
+            };
+            let adjusted_ty = cx.typeck_results().expr_ty_adjusted(e);
+            let adjusted_mut = adjusted_ty.ref_mutability().unwrap_or(Mutability::Not);
+            needs_mut |= adjusted_mut == Mutability::Mut;
+            match parent.kind {
+                ExprKind::AddrOf(_, Mutability::Mut, _) => {
+                    needs_mut = true;
+                    return ControlFlow::Break(true);
+                },
+                ExprKind::Unary(UnOp::Deref, _) | ExprKind::Index(..) if !needs_mut => {
+                    let mut last_place = parent;
+                    while let Some(parent) = get_parent_expr(cx, parent) {
+                        if matches!(parent.kind, ExprKind::Unary(UnOp::Deref, _) | ExprKind::Field(..))
+                            || matches!(parent.kind, ExprKind::Index(e, _) if e.hir_id == last_place.hir_id)
+                        {
+                            last_place = parent;
+                        } else {
+                            break;
+                        }
+                    }
+                    needs_mut |= cx.typeck_results().expr_ty_adjusted(last_place).ref_mutability()
+                        == Some(Mutability::Mut)
+                        || get_parent_expr(cx, last_place)
+                            .map_or(false, |e| matches!(e.kind, ExprKind::AddrOf(_, Mutability::Mut, _)));
+                },
+                ExprKind::MethodCall(_, [recv, ..], _)
+                    if recv.hir_id == e.hir_id
+                        && adjusted_mut == Mutability::Mut
+                        && !adjusted_ty.peel_refs().is_slice() =>
+                {
+                    return ControlFlow::Break(true);
+                },
+                ExprKind::Assign(lhs, ..) if e.hir_id == lhs.hir_id => {
+                    needs_mut = true;
+                    return ControlFlow::Break(false);
+                },
+                _ => (),
+            }
+            ControlFlow::Continue(())
+        });
+
+        // Avoid allocating small `Vec`s when they'll be extended right after.
+        if res == ControlFlow::Break(true) && self.found <= min_pushes_for_extension {
+            return;
+        }
+
+        let mut s = if self.lhs_is_let {
             String::from("let ")
         } else {
             String::new()
         };
-        s.push_str(&snippet(cx, self.lhs_span, ".."));
+        if needs_mut {
+            s.push_str("mut ");
+        }
+        s.push_str(self.name.as_str());
+        if let Some(span) = self.let_ty_span {
+            s.push_str(": ");
+            s.push_str(&snippet(cx, span, "_"));
+        }
         s.push_str(" = vec![..];");
 
         span_lint_and_sugg(
@@ -83,60 +147,63 @@ impl<'tcx> LateLintPass<'tcx> for VecInitThenPush {
     }
 
     fn check_local(&mut self, cx: &LateContext<'tcx>, local: &'tcx Local<'tcx>) {
-        if_chain! {
-            if !in_external_macro(cx.sess(), local.span);
-            if let Some(init) = local.init;
-            if let PatKind::Binding(BindingAnnotation::Mutable, id, _, None) = local.pat.kind;
-            if let Some(init_kind) = get_vec_init_kind(cx, init);
-            then {
-                self.searcher = Some(VecPushSearcher {
-                        local_id: id,
-                        init: init_kind,
-                        lhs_is_local: true,
-                        lhs_span: local.ty.map_or(local.pat.span, |t| local.pat.span.to(t.span)),
-                        err_span: local.span,
-                        found: 0,
-                    });
-            }
+        if let Some(init_expr) = local.init
+            && let PatKind::Binding(BindingAnnotation::Mutable, id, name, None) = local.pat.kind
+            && !in_external_macro(cx.sess(), local.span)
+            && let Some(init) = get_vec_init_kind(cx, init_expr)
+            && !matches!(init, VecInitKind::WithExprCapacity(_))
+        {
+            self.searcher = Some(VecPushSearcher {
+                local_id: id,
+                init,
+                lhs_is_let: true,
+                name: name.name,
+                let_ty_span: local.ty.map(|ty| ty.span),
+                err_span: local.span,
+                found: 0,
+                last_push_expr: init_expr.hir_id,
+            });
         }
     }
 
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if_chain! {
-            if self.searcher.is_none();
-            if !in_external_macro(cx.sess(), expr.span);
-            if let ExprKind::Assign(left, right, _) = expr.kind;
-            if let Some(id) = path_to_local(left);
-            if let Some(init_kind) = get_vec_init_kind(cx, right);
-            then {
-                self.searcher = Some(VecPushSearcher {
-                    local_id: id,
-                    init: init_kind,
-                    lhs_is_local: false,
-                    lhs_span: left.span,
-                    err_span: expr.span,
-                    found: 0,
-                });
-            }
+        if self.searcher.is_none()
+            && let ExprKind::Assign(left, right, _) = expr.kind
+            && let ExprKind::Path(QPath::Resolved(None, path)) = left.kind
+            && let [name] = &path.segments
+            && let Res::Local(id) = path.res
+            && !in_external_macro(cx.sess(), expr.span)
+            && let Some(init) = get_vec_init_kind(cx, right)
+            && !matches!(init, VecInitKind::WithExprCapacity(_))
+        {
+            self.searcher = Some(VecPushSearcher {
+                local_id: id,
+                init,
+                lhs_is_let: false,
+                let_ty_span: None,
+                name: name.ident.name,
+                err_span: expr.span,
+                found: 0,
+                last_push_expr: expr.hir_id,
+            });
         }
     }
 
     fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) {
         if let Some(searcher) = self.searcher.take() {
-            if_chain! {
-                if let StmtKind::Expr(expr) | StmtKind::Semi(expr) = stmt.kind;
-                if let ExprKind::MethodCall(path, [self_arg, _], _) = expr.kind;
-                if path_to_local_id(self_arg, searcher.local_id);
-                if path.ident.name.as_str() == "push";
-                then {
-                    self.searcher = Some(VecPushSearcher {
-                        found: searcher.found + 1,
-                        err_span: searcher.err_span.to(stmt.span),
-                        .. searcher
-                    });
-                } else {
-                    searcher.display_err(cx);
-                }
+            if let StmtKind::Expr(expr) | StmtKind::Semi(expr) = stmt.kind
+                && let ExprKind::MethodCall(name, [self_arg, _], _) = expr.kind
+                && path_to_local_id(self_arg, searcher.local_id)
+                && name.ident.as_str() == "push"
+            {
+                self.searcher = Some(VecPushSearcher {
+                    found: searcher.found + 1,
+                    err_span: searcher.err_span.to(stmt.span),
+                    last_push_expr: expr.hir_id,
+                    .. searcher
+                });
+            } else {
+                searcher.display_err(cx);
             }
         }
     }
diff --git a/clippy_utils/src/higher.rs b/clippy_utils/src/higher.rs
index 2095fc966c5..1e0fc789af2 100644
--- a/clippy_utils/src/higher.rs
+++ b/clippy_utils/src/higher.rs
@@ -2,10 +2,11 @@
 
 #![deny(clippy::missing_docs_in_private_items)]
 
+use crate::consts::{constant_simple, Constant};
 use crate::ty::is_type_diagnostic_item;
 use crate::{is_expn_of, match_def_path, paths};
 use if_chain::if_chain;
-use rustc_ast::ast::{self, LitKind};
+use rustc_ast::ast;
 use rustc_hir as hir;
 use rustc_hir::{Arm, Block, Expr, ExprKind, HirId, LoopSource, MatchSource, Node, Pat, QPath};
 use rustc_lint::LateContext;
@@ -431,7 +432,7 @@ pub enum VecInitKind {
     /// `Vec::default()` or `Default::default()`
     Default,
     /// `Vec::with_capacity(123)`
-    WithLiteralCapacity(u64),
+    WithConstCapacity(u128),
     /// `Vec::with_capacity(slice.len())`
     WithExprCapacity(HirId),
 }
@@ -449,15 +450,11 @@ pub fn get_vec_init_kind<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -
                     return Some(VecInitKind::Default);
                 } else if name.ident.name.as_str() == "with_capacity" {
                     let arg = args.get(0)?;
-                    if_chain! {
-                        if let ExprKind::Lit(lit) = &arg.kind;
-                        if let LitKind::Int(num, _) = lit.node;
-                        then {
-                            return Some(VecInitKind::WithLiteralCapacity(num.try_into().ok()?));
-                        }
-                    }
-                    return Some(VecInitKind::WithExprCapacity(arg.hir_id));
-                }
+                    return match constant_simple(cx, cx.typeck_results(), arg) {
+                        Some(Constant::Int(num)) => Some(VecInitKind::WithConstCapacity(num)),
+                        _ => Some(VecInitKind::WithExprCapacity(arg.hir_id)),
+                    };
+                };
             },
             ExprKind::Path(QPath::Resolved(_, path))
                 if match_def_path(cx, path.res.opt_def_id()?, &paths::DEFAULT_TRAIT_METHOD)
diff --git a/clippy_utils/src/visitors.rs b/clippy_utils/src/visitors.rs
index c00bc2bd213..b6c8f1d516e 100644
--- a/clippy_utils/src/visitors.rs
+++ b/clippy_utils/src/visitors.rs
@@ -1,4 +1,4 @@
-use crate::path_to_local_id;
+use crate::{get_enclosing_block, path_to_local_id};
 use core::ops::ControlFlow;
 use rustc_hir as hir;
 use rustc_hir::def::{DefKind, Res};
@@ -436,3 +436,61 @@ pub fn for_each_value_source<'tcx, B>(
         _ => f(e),
     }
 }
+
+/// Runs the given function for each path expression referencing the given local which occur after
+/// the given expression.
+pub fn for_each_local_use_after_expr<'tcx, B>(
+    cx: &LateContext<'tcx>,
+    local_id: HirId,
+    expr_id: HirId,
+    f: impl FnMut(&'tcx Expr<'tcx>) -> ControlFlow<B>,
+) -> ControlFlow<B> {
+    struct V<'cx, 'tcx, F, B> {
+        cx: &'cx LateContext<'tcx>,
+        local_id: HirId,
+        expr_id: HirId,
+        found: bool,
+        res: ControlFlow<B>,
+        f: F,
+    }
+    impl<'cx, 'tcx, F: FnMut(&'tcx Expr<'tcx>) -> ControlFlow<B>, B> Visitor<'tcx> for V<'cx, 'tcx, F, B> {
+        type NestedFilter = nested_filter::OnlyBodies;
+        fn nested_visit_map(&mut self) -> Self::Map {
+            self.cx.tcx.hir()
+        }
+
+        fn visit_expr(&mut self, e: &'tcx Expr<'tcx>) {
+            if !self.found {
+                if e.hir_id == self.expr_id {
+                    self.found = true;
+                } else {
+                    walk_expr(self, e);
+                }
+                return;
+            }
+            if self.res.is_break() {
+                return;
+            }
+            if path_to_local_id(e, self.local_id) {
+                self.res = (self.f)(e);
+            } else {
+                walk_expr(self, e);
+            }
+        }
+    }
+
+    if let Some(b) = get_enclosing_block(cx, local_id) {
+        let mut v = V {
+            cx,
+            local_id,
+            expr_id,
+            found: false,
+            res: ControlFlow::Continue(()),
+            f,
+        };
+        v.visit_block(b);
+        v.res
+    } else {
+        ControlFlow::Continue(())
+    }
+}
diff --git a/tests/ui/vec_init_then_push.rs b/tests/ui/vec_init_then_push.rs
index 5099aad83bc..768ea3e668a 100644
--- a/tests/ui/vec_init_then_push.rs
+++ b/tests/ui/vec_init_then_push.rs
@@ -44,3 +44,45 @@ pub fn no_lint() -> Vec<i32> {
         }
     }
 }
+
+fn _from_iter(items: impl Iterator<Item = u32>) -> Vec<u32> {
+    let mut v = Vec::new();
+    v.push(0);
+    v.push(1);
+    v.extend(items);
+    v
+}
+
+fn _cond_push(x: bool) -> Vec<u32> {
+    let mut v = Vec::new();
+    v.push(0);
+    if x {
+        v.push(1);
+    }
+    v.push(2);
+    v
+}
+
+fn _push_then_edit(x: u32) -> Vec<u32> {
+    let mut v = Vec::new();
+    v.push(x);
+    v.push(1);
+    v[0] = v[1] + 5;
+    v
+}
+
+fn _cond_push_with_large_start(x: bool) -> Vec<u32> {
+    let mut v = Vec::new();
+    v.push(0);
+    v.push(1);
+    v.push(0);
+    v.push(1);
+    v.push(0);
+    v.push(0);
+    v.push(1);
+    v.push(0);
+    if x {
+        v.push(1);
+    }
+    v
+}
diff --git a/tests/ui/vec_init_then_push.stderr b/tests/ui/vec_init_then_push.stderr
index 9ec3e10e624..362c9603bbf 100644
--- a/tests/ui/vec_init_then_push.stderr
+++ b/tests/ui/vec_init_then_push.stderr
@@ -3,7 +3,7 @@ error: calls to `push` immediately after creation
    |
 LL | /     let mut def_err: Vec<u32> = Default::default();
 LL | |     def_err.push(0);
-   | |____________________^ help: consider using the `vec![]` macro: `let mut def_err: Vec<u32> = vec![..];`
+   | |____________________^ help: consider using the `vec![]` macro: `let def_err: Vec<u32> = vec![..];`
    |
    = note: `-D clippy::vec-init-then-push` implied by `-D warnings`
 
@@ -30,5 +30,25 @@ LL | /     new_err = Vec::new();
 LL | |     new_err.push(0);
    | |____________________^ help: consider using the `vec![]` macro: `new_err = vec![..];`
 
-error: aborting due to 4 previous errors
+error: calls to `push` immediately after creation
+  --> $DIR/vec_init_then_push.rs:67:5
+   |
+LL | /     let mut v = Vec::new();
+LL | |     v.push(x);
+LL | |     v.push(1);
+   | |______________^ help: consider using the `vec![]` macro: `let mut v = vec![..];`
+
+error: calls to `push` immediately after creation
+  --> $DIR/vec_init_then_push.rs:75:5
+   |
+LL | /     let mut v = Vec::new();
+LL | |     v.push(0);
+LL | |     v.push(1);
+LL | |     v.push(0);
+...  |
+LL | |     v.push(1);
+LL | |     v.push(0);
+   | |______________^ help: consider using the `vec![]` macro: `let mut v = vec![..];`
+
+error: aborting due to 6 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 33bf9e9a54697bcdaba30291f2d4e357ee84777f Mon Sep 17 00:00:00 2001
From: dswij <dswijj@gmail.com>
Date: Wed, 23 Feb 2022 23:04:06 +0800
Subject: `redundant_closure` ignore coerced closure

---
 clippy_lints/src/eta_reduction.rs |  4 +++-
 tests/ui/eta.fixed                | 16 ++++++++++++++--
 tests/ui/eta.rs                   | 12 ++++++++++++
 tests/ui/eta.stderr               | 14 +-------------
 4 files changed, 30 insertions(+), 16 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/eta_reduction.rs b/clippy_lints/src/eta_reduction.rs
index c2e32f1d9a2..1b19868e4c7 100644
--- a/clippy_lints/src/eta_reduction.rs
+++ b/clippy_lints/src/eta_reduction.rs
@@ -3,7 +3,7 @@ use clippy_utils::higher::VecArgs;
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::usage::local_used_after_expr;
-use clippy_utils::{higher, path_to_local, path_to_local_id};
+use clippy_utils::{higher, is_adjusted, path_to_local, path_to_local_id};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::def_id::DefId;
@@ -103,6 +103,7 @@ impl<'tcx> LateLintPass<'tcx> for EtaReduction {
         let closure_ty = cx.typeck_results().expr_ty(expr);
 
         if_chain!(
+            if !is_adjusted(cx, &body.value);
             if let ExprKind::Call(callee, args) = body.value.kind;
             if let ExprKind::Path(_) = callee.kind;
             if check_inputs(cx, body.params, args);
@@ -144,6 +145,7 @@ impl<'tcx> LateLintPass<'tcx> for EtaReduction {
         );
 
         if_chain!(
+            if !is_adjusted(cx, &body.value);
             if let ExprKind::MethodCall(path, args, _) = body.value.kind;
             if check_inputs(cx, body.params, args);
             let method_def_id = cx.typeck_results().type_dependent_def_id(body.value.hir_id).unwrap();
diff --git a/tests/ui/eta.fixed b/tests/ui/eta.fixed
index 873ed689a5b..6c2272f4dff 100644
--- a/tests/ui/eta.fixed
+++ b/tests/ui/eta.fixed
@@ -37,7 +37,7 @@ fn main() {
     }
 
     // See #815
-    let e = Some(1u8).map(divergent);
+    let e = Some(1u8).map(|a| divergent(a));
     let e = Some(1u8).map(generic);
     let e = Some(1u8).map(generic);
     // See #515
@@ -233,7 +233,7 @@ fn late_bound_lifetimes() {
     {
     }
     map_str(|s| take_asref_path(s));
-    map_str_to_path(std::convert::AsRef::as_ref);
+    map_str_to_path(|s| s.as_ref());
 }
 
 mod type_param_bound {
@@ -279,3 +279,15 @@ mod bind_by_ref {
         Some(A).map(|ref a| B::from(a));
     }
 }
+
+// #7812 False positive on coerced closure
+fn coerced_closure() {
+    fn function_returning_unit<F: FnMut(i32)>(f: F) {}
+    function_returning_unit(|x| std::process::exit(x));
+
+    fn arr() -> &'static [u8; 0] {
+        &[]
+    }
+    fn slice_fn(_: impl FnOnce() -> &'static [u8]) {}
+    slice_fn(|| arr());
+}
diff --git a/tests/ui/eta.rs b/tests/ui/eta.rs
index 4cb58eec94c..a1a9c0dfbf3 100644
--- a/tests/ui/eta.rs
+++ b/tests/ui/eta.rs
@@ -279,3 +279,15 @@ mod bind_by_ref {
         Some(A).map(|ref a| B::from(a));
     }
 }
+
+// #7812 False positive on coerced closure
+fn coerced_closure() {
+    fn function_returning_unit<F: FnMut(i32)>(f: F) {}
+    function_returning_unit(|x| std::process::exit(x));
+
+    fn arr() -> &'static [u8; 0] {
+        &[]
+    }
+    fn slice_fn(_: impl FnOnce() -> &'static [u8]) {}
+    slice_fn(|| arr());
+}
diff --git a/tests/ui/eta.stderr b/tests/ui/eta.stderr
index d1ae889d6f3..bf2e97e744a 100644
--- a/tests/ui/eta.stderr
+++ b/tests/ui/eta.stderr
@@ -24,12 +24,6 @@ error: redundant closure
 LL |     all(&[1, 2, 3], &&2, |x, y| below(x, y)); //is adjusted
    |                          ^^^^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `below`
 
-error: redundant closure
-  --> $DIR/eta.rs:40:27
-   |
-LL |     let e = Some(1u8).map(|a| divergent(a));
-   |                           ^^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `divergent`
-
 error: redundant closure
   --> $DIR/eta.rs:41:27
    |
@@ -122,11 +116,5 @@ error: redundant closure
 LL |         Some(1).map(|n| in_loop(n));
    |                     ^^^^^^^^^^^^^^ help: replace the closure with the function itself: `in_loop`
 
-error: redundant closure
-  --> $DIR/eta.rs:236:21
-   |
-LL |     map_str_to_path(|s| s.as_ref());
-   |                     ^^^^^^^^^^^^^^ help: replace the closure with the method itself: `std::convert::AsRef::as_ref`
-
-error: aborting due to 21 previous errors
+error: aborting due to 19 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 8f8fc9f71752e8df80152a402b992bdd819be7f3 Mon Sep 17 00:00:00 2001
From: asquared31415 <34665709+asquared31415@users.noreply.github.com>
Date: Thu, 28 Apr 2022 21:27:32 -0400
Subject: use non-panicking snippet, use struct update syntax and add comment

---
 clippy_lints/src/casts/cast_slice_different_sizes.rs | 18 ++++++++----------
 1 file changed, 8 insertions(+), 10 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/cast_slice_different_sizes.rs b/clippy_lints/src/casts/cast_slice_different_sizes.rs
index 16c9e49ff11..2238668abca 100644
--- a/clippy_lints/src/casts/cast_slice_different_sizes.rs
+++ b/clippy_lints/src/casts/cast_slice_different_sizes.rs
@@ -1,4 +1,4 @@
-use clippy_utils::{diagnostics::span_lint_and_then, meets_msrv, msrvs, source::snippet_opt};
+use clippy_utils::{diagnostics::span_lint_and_then, meets_msrv, msrvs, source};
 use if_chain::if_chain;
 use rustc_ast::Mutability;
 use rustc_hir::{Expr, ExprKind, Node};
@@ -39,7 +39,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>, msrv: &Opti
                         start_ty.ty, from_size, end_ty.ty, to_size,
                     ),
                     |diag| {
-                        let ptr_snippet = snippet_opt(cx, left_cast.span).unwrap();
+                        let ptr_snippet = source::snippet(cx, left_cast.span, "..");
 
                         let (mutbl_fn_str, mutbl_ptr_str) = match end_ty.mutbl {
                             Mutability::Mut => ("_mut", "mut"),
@@ -119,16 +119,14 @@ fn expr_cast_chain_tys<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>) -> Optio
     if let ExprKind::Cast(cast_expr, _cast_to_hir_ty) = expr.peel_blocks().kind {
         let cast_to = cx.typeck_results().expr_ty(expr);
         let to_slice_ty = get_raw_slice_ty_mut(cast_to)?;
-        if let Some(CastChainInfo {
-            left_cast,
-            start_ty,
-            end_ty: _,
-        }) = expr_cast_chain_tys(cx, cast_expr)
-        {
+
+        // If the expression that makes up the source of this cast is itself a cast, recursively
+        // call `expr_cast_chain_tys` and update the end type with the final tartet type.
+        // Otherwise, this cast is not immediately nested, just construct the info for this cast
+        if let Some(prev_info) = expr_cast_chain_tys(cx, cast_expr) {
             Some(CastChainInfo {
-                left_cast,
-                start_ty,
                 end_ty: to_slice_ty,
+                ..prev_info
             })
         } else {
             let cast_from = cx.typeck_results().expr_ty(cast_expr);
-- 
cgit 1.4.1-3-g733a5


From d10296910f36cf51187b1b5183a3a628422dd757 Mon Sep 17 00:00:00 2001
From: Ariel Uy <ariel.b.uy@gmail.com>
Date: Thu, 28 Apr 2022 20:54:58 -0700
Subject: Support negative ints in manual_range_contains

Fixes issue where ranges containing ints with different signs would be
incorrect due to comparing as unsigned.
---
 clippy_lints/src/ranges.rs     | 17 +++++++++++------
 clippy_utils/src/consts.rs     | 10 ++++------
 tests/ui/range_contains.fixed  |  8 +++++++-
 tests/ui/range_contains.rs     |  8 +++++++-
 tests/ui/range_contains.stderr | 14 +++++++++++++-
 5 files changed, 42 insertions(+), 15 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/ranges.rs b/clippy_lints/src/ranges.rs
index e213c208794..043299333b1 100644
--- a/clippy_lints/src/ranges.rs
+++ b/clippy_lints/src/ranges.rs
@@ -219,15 +219,17 @@ fn check_possible_range_contains(cx: &LateContext<'_>, op: BinOpKind, l: &Expr<'
         _ => return,
     };
     // value, name, order (higher/lower), inclusiveness
-    if let (Some((lval, lid, name_span, lval_span, lord, linc)), Some((rval, rid, _, rval_span, rord, rinc))) =
-        (check_range_bounds(cx, l), check_range_bounds(cx, r))
+    if let (
+        Some((lval, lexpr, lid, name_span, lval_span, lord, linc)),
+        Some((rval, _, rid, _, rval_span, rord, rinc)),
+    ) = (check_range_bounds(cx, l), check_range_bounds(cx, r))
     {
         // we only lint comparisons on the same name and with different
         // direction
         if lid != rid || lord == rord {
             return;
         }
-        let ord = Constant::partial_cmp(cx.tcx, cx.typeck_results().expr_ty(l), &lval, &rval);
+        let ord = Constant::partial_cmp(cx.tcx, cx.typeck_results().expr_ty(lexpr), &lval, &rval);
         if combine_and && ord == Some(rord) {
             // order lower bound and upper bound
             let (l_span, u_span, l_inc, u_inc) = if rord == Ordering::Less {
@@ -292,7 +294,10 @@ fn check_possible_range_contains(cx: &LateContext<'_>, op: BinOpKind, l: &Expr<'
     }
 }
 
-fn check_range_bounds(cx: &LateContext<'_>, ex: &Expr<'_>) -> Option<(Constant, HirId, Span, Span, Ordering, bool)> {
+fn check_range_bounds<'a>(
+    cx: &'a LateContext<'_>,
+    ex: &'a Expr<'_>,
+) -> Option<(Constant, &'a Expr<'a>, HirId, Span, Span, Ordering, bool)> {
     if let ExprKind::Binary(ref op, l, r) = ex.kind {
         let (inclusive, ordering) = match op.node {
             BinOpKind::Gt => (false, Ordering::Greater),
@@ -303,11 +308,11 @@ fn check_range_bounds(cx: &LateContext<'_>, ex: &Expr<'_>) -> Option<(Constant,
         };
         if let Some(id) = path_to_local(l) {
             if let Some((c, _)) = constant(cx, cx.typeck_results(), r) {
-                return Some((c, id, l.span, r.span, ordering, inclusive));
+                return Some((c, r, id, l.span, r.span, ordering, inclusive));
             }
         } else if let Some(id) = path_to_local(r) {
             if let Some((c, _)) = constant(cx, cx.typeck_results(), l) {
-                return Some((c, id, r.span, l.span, ordering.reverse(), inclusive));
+                return Some((c, l, id, r.span, l.span, ordering.reverse(), inclusive));
             }
         }
     }
diff --git a/clippy_utils/src/consts.rs b/clippy_utils/src/consts.rs
index 0e916ca8164..3d34eaa916e 100644
--- a/clippy_utils/src/consts.rs
+++ b/clippy_utils/src/consts.rs
@@ -130,12 +130,10 @@ impl Constant {
         match (left, right) {
             (&Self::Str(ref ls), &Self::Str(ref rs)) => Some(ls.cmp(rs)),
             (&Self::Char(ref l), &Self::Char(ref r)) => Some(l.cmp(r)),
-            (&Self::Int(l), &Self::Int(r)) => {
-                if let ty::Int(int_ty) = *cmp_type.kind() {
-                    Some(sext(tcx, l, int_ty).cmp(&sext(tcx, r, int_ty)))
-                } else {
-                    Some(l.cmp(&r))
-                }
+            (&Self::Int(l), &Self::Int(r)) => match *cmp_type.kind() {
+                ty::Int(int_ty) => Some(sext(tcx, l, int_ty).cmp(&sext(tcx, r, int_ty))),
+                ty::Uint(_) => Some(l.cmp(&r)),
+                _ => bug!("Not an int type"),
             },
             (&Self::F64(l), &Self::F64(r)) => l.partial_cmp(&r),
             (&Self::F32(l), &Self::F32(r)) => l.partial_cmp(&r),
diff --git a/tests/ui/range_contains.fixed b/tests/ui/range_contains.fixed
index 47c974e614b..f4977199711 100644
--- a/tests/ui/range_contains.fixed
+++ b/tests/ui/range_contains.fixed
@@ -6,7 +6,7 @@
 #[allow(clippy::short_circuit_statement)]
 #[allow(clippy::unnecessary_operation)]
 fn main() {
-    let x = 9_u32;
+    let x = 9_i32;
 
     // order shouldn't matter
     (8..12).contains(&x);
@@ -43,6 +43,12 @@ fn main() {
     let y = 3.;
     (0. ..1.).contains(&y);
     !(0. ..=1.).contains(&y);
+
+    // handle negatives #8721
+    (-10..=10).contains(&x);
+    x >= 10 && x <= -10;
+    (-3. ..=3.).contains(&y);
+    y >= 3. && y <= -3.;
 }
 
 // Fix #6373
diff --git a/tests/ui/range_contains.rs b/tests/ui/range_contains.rs
index 835deced5e4..9e2180b0c99 100644
--- a/tests/ui/range_contains.rs
+++ b/tests/ui/range_contains.rs
@@ -6,7 +6,7 @@
 #[allow(clippy::short_circuit_statement)]
 #[allow(clippy::unnecessary_operation)]
 fn main() {
-    let x = 9_u32;
+    let x = 9_i32;
 
     // order shouldn't matter
     x >= 8 && x < 12;
@@ -43,6 +43,12 @@ fn main() {
     let y = 3.;
     y >= 0. && y < 1.;
     y < 0. || y > 1.;
+
+    // handle negatives #8721
+    x >= -10 && x <= 10;
+    x >= 10 && x <= -10;
+    y >= -3. && y <= 3.;
+    y >= 3. && y <= -3.;
 }
 
 // Fix #6373
diff --git a/tests/ui/range_contains.stderr b/tests/ui/range_contains.stderr
index bc79f1bca84..1817ee1715d 100644
--- a/tests/ui/range_contains.stderr
+++ b/tests/ui/range_contains.stderr
@@ -84,5 +84,17 @@ error: manual `!RangeInclusive::contains` implementation
 LL |     y < 0. || y > 1.;
    |     ^^^^^^^^^^^^^^^^ help: use: `!(0. ..=1.).contains(&y)`
 
-error: aborting due to 14 previous errors
+error: manual `RangeInclusive::contains` implementation
+  --> $DIR/range_contains.rs:48:5
+   |
+LL |     x >= -10 && x <= 10;
+   |     ^^^^^^^^^^^^^^^^^^^ help: use: `(-10..=10).contains(&x)`
+
+error: manual `RangeInclusive::contains` implementation
+  --> $DIR/range_contains.rs:50:5
+   |
+LL |     y >= -3. && y <= 3.;
+   |     ^^^^^^^^^^^^^^^^^^^ help: use: `(-3. ..=3.).contains(&y)`
+
+error: aborting due to 16 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 959ed524cef3dde4bf006d3f363d9f8cf6f0005e Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Sat, 30 Apr 2022 19:16:19 +0200
Subject: Add missing quite in `large_include_file` example

---
 clippy_lints/src/large_include_file.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/large_include_file.rs b/clippy_lints/src/large_include_file.rs
index 5ed275726c5..8bef13c682d 100644
--- a/clippy_lints/src/large_include_file.rs
+++ b/clippy_lints/src/large_include_file.rs
@@ -19,7 +19,7 @@ declare_clippy_lint! {
     /// ### Example
     /// ```rust,ignore
     /// let included_str = include_str!("very_large_file.txt");
-    /// let included_bytes = include_bytes!("very_large_file.txt);
+    /// let included_bytes = include_bytes!("very_large_file.txt");
     /// ```
     ///
     /// Instead, you can load the file at runtime:
-- 
cgit 1.4.1-3-g733a5


From 6ad810f94eec6b49af026d44c70066284120612d Mon Sep 17 00:00:00 2001
From: tamaron <tamaron1203@gmail.com>
Date: Fri, 22 Apr 2022 10:39:38 +0900
Subject: improve identity_op

fix

Update identity_op.rs

ok

update without_loop_counters test

chore

fix

chore

remove visitor and leftmost

fix

add document
---
 clippy_lints/src/identity_op.rs | 82 +++++++++++++++++++++++++-----------
 tests/ui/identity_op.rs         | 30 ++++++++++++++
 tests/ui/identity_op.stderr     | 92 ++++++++++++++++++++++++++++++++++++++++-
 3 files changed, 180 insertions(+), 24 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/identity_op.rs b/clippy_lints/src/identity_op.rs
index 4d6bef89bea..40cc5cd4bcf 100644
--- a/clippy_lints/src/identity_op.rs
+++ b/clippy_lints/src/identity_op.rs
@@ -1,3 +1,4 @@
+use clippy_utils::get_parent_expr;
 use clippy_utils::source::snippet;
 use rustc_hir::{BinOp, BinOpKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
@@ -22,6 +23,11 @@ declare_clippy_lint! {
     /// # let x = 1;
     /// x / 1 + 0 * 1 - 0 | 0;
     /// ```
+    ///
+    /// ### Known problems
+    /// False negatives: `f(0 + if b { 1 } else { 2 } + 3);` is reducible to
+    /// `f(if b { 1 } else { 2 } + 3);`. But the lint doesn't trigger for the code.
+    /// See [#8724](https://github.com/rust-lang/rust-clippy/issues/8724)
     #[clippy::version = "pre 1.29.0"]
     pub IDENTITY_OP,
     complexity,
@@ -31,36 +37,66 @@ declare_clippy_lint! {
 declare_lint_pass!(IdentityOp => [IDENTITY_OP]);
 
 impl<'tcx> LateLintPass<'tcx> for IdentityOp {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
-        if e.span.from_expansion() {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        if expr.span.from_expansion() {
             return;
         }
-        if let ExprKind::Binary(cmp, left, right) = e.kind {
-            if is_allowed(cx, cmp, left, right) {
-                return;
-            }
-            match cmp.node {
-                BinOpKind::Add | BinOpKind::BitOr | BinOpKind::BitXor => {
-                    check(cx, left, 0, e.span, right.span);
-                    check(cx, right, 0, e.span, left.span);
-                },
-                BinOpKind::Shl | BinOpKind::Shr | BinOpKind::Sub => check(cx, right, 0, e.span, left.span),
-                BinOpKind::Mul => {
-                    check(cx, left, 1, e.span, right.span);
-                    check(cx, right, 1, e.span, left.span);
-                },
-                BinOpKind::Div => check(cx, right, 1, e.span, left.span),
-                BinOpKind::BitAnd => {
-                    check(cx, left, -1, e.span, right.span);
-                    check(cx, right, -1, e.span, left.span);
-                },
-                BinOpKind::Rem => check_remainder(cx, left, right, e.span, left.span),
-                _ => (),
+        if let ExprKind::Binary(cmp, left, right) = &expr.kind {
+            if !is_allowed(cx, *cmp, left, right) {
+                match cmp.node {
+                    BinOpKind::Add | BinOpKind::BitOr | BinOpKind::BitXor => {
+                        if reducible_to_right(cx, expr, right) {
+                            check(cx, left, 0, expr.span, right.span);
+                        }
+                        check(cx, right, 0, expr.span, left.span);
+                    },
+                    BinOpKind::Shl | BinOpKind::Shr | BinOpKind::Sub => {
+                        check(cx, right, 0, expr.span, left.span);
+                    },
+                    BinOpKind::Mul => {
+                        if reducible_to_right(cx, expr, right) {
+                            check(cx, left, 1, expr.span, right.span);
+                        }
+                        check(cx, right, 1, expr.span, left.span);
+                    },
+                    BinOpKind::Div => check(cx, right, 1, expr.span, left.span),
+                    BinOpKind::BitAnd => {
+                        if reducible_to_right(cx, expr, right) {
+                            check(cx, left, -1, expr.span, right.span);
+                        }
+                        check(cx, right, -1, expr.span, left.span);
+                    },
+                    BinOpKind::Rem => {
+                        // Don't call reducible_to_right because N % N is always reducible to 1
+                        check_remainder(cx, left, right, expr.span, left.span);
+                    },
+                    _ => (),
+                }
             }
         }
     }
 }
 
+/// Checks if `left op ..right` can be actually reduced to `right`
+/// e.g. `0 + if b { 1 } else { 2 } + if b { 3 } else { 4 }`
+/// cannot be reduced to `if b { 1 } else { 2 } +  if b { 3 } else { 4 }`
+/// See #8724
+fn reducible_to_right(cx: &LateContext<'_>, binary: &Expr<'_>, right: &Expr<'_>) -> bool {
+    if let ExprKind::If(..) | ExprKind::Match(..) | ExprKind::Block(..) | ExprKind::Loop(..) = right.kind {
+        is_toplevel_binary(cx, binary)
+    } else {
+        true
+    }
+}
+
+fn is_toplevel_binary(cx: &LateContext<'_>, must_be_binary: &Expr<'_>) -> bool {
+    if let Some(parent) = get_parent_expr(cx, must_be_binary) && let ExprKind::Binary(..) = &parent.kind {
+        false
+    } else {
+        true
+    }
+}
+
 fn is_allowed(cx: &LateContext<'_>, cmp: BinOp, left: &Expr<'_>, right: &Expr<'_>) -> bool {
     // This lint applies to integers
     !cx.typeck_results().expr_ty(left).peel_refs().is_integral()
diff --git a/tests/ui/identity_op.rs b/tests/ui/identity_op.rs
index 9d39d769635..fec54d00ccb 100644
--- a/tests/ui/identity_op.rs
+++ b/tests/ui/identity_op.rs
@@ -77,4 +77,34 @@ fn main() {
     (x + 1) % 3; // no error
     4 % 3; // no error
     4 % -3; // no error
+
+    // See #8724
+    let a = 0;
+    let b = true;
+    0 + if b { 1 } else { 2 };
+    0 + if b { 1 } else { 2 } + if b { 3 } else { 4 }; // no error
+    0 + match a { 0 => 10, _ => 20 };
+    0 + match a { 0 => 10, _ => 20 } + match a { 0 => 30, _ => 40 }; // no error
+    0 + if b { 1 } else { 2 } + match a { 0 => 30, _ => 40 }; // no error
+    0 + match a { 0 => 10, _ => 20 } + if b { 3 } else { 4 }; // no error
+    
+    0 + if b { 0 + 1 } else { 2 };
+    0 + match a { 0 =>  0 + 10, _ => 20 };
+    0 + if b { 0 + 1 } else { 2 } + match a { 0 => 0 + 30, _ => 40 };
+
+    let _ = 0 + if 0 + 1 > 0 { 1 } else { 2 } + if 0 + 1 > 0 { 3 } else { 4 };
+    let _ = 0 + match 0 + 1 { 0 => 10, _ => 20 } + match 0 + 1  { 0 => 30, _ => 40 };
+
+    0 + if b { 1 } else { 2 } + if b { 3 } else { 4 } + 0;
+    
+    0 + { a } + 3; // no error
+    0 + loop { let mut c = 0; if c == 10 { break c; } c += 1; } + { a * 2 }; // no error
+    
+    fn f(_: i32) {
+        todo!();
+    }
+    f(1 * a + { 8 * 5 });
+    f(0 + if b { 1 } else { 2 } + 3); // no error
+    const _: i32 = { 2 * 4 } + 0 + 3;
+    const _: i32 = 0 + { 1 + 2 * 3 } + 3; // no error
 }
diff --git a/tests/ui/identity_op.stderr b/tests/ui/identity_op.stderr
index e3c156b5429..d8cb65839cb 100644
--- a/tests/ui/identity_op.stderr
+++ b/tests/ui/identity_op.stderr
@@ -108,5 +108,95 @@ error: the operation is ineffective. Consider reducing it to `1`
 LL |     x + 1 % 3;
    |         ^^^^^
 
-error: aborting due to 18 previous errors
+error: the operation is ineffective. Consider reducing it to `if b { 1 } else { 2 }`
+  --> $DIR/identity_op.rs:84:5
+   |
+LL |     0 + if b { 1 } else { 2 };
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: the operation is ineffective. Consider reducing it to `match a { 0 => 10, _ => 20 }`
+  --> $DIR/identity_op.rs:86:5
+   |
+LL |     0 + match a { 0 => 10, _ => 20 };
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: the operation is ineffective. Consider reducing it to `if b { 0 + 1 } else { 2 }`
+  --> $DIR/identity_op.rs:91:5
+   |
+LL |     0 + if b { 0 + 1 } else { 2 };
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: the operation is ineffective. Consider reducing it to `1`
+  --> $DIR/identity_op.rs:91:16
+   |
+LL |     0 + if b { 0 + 1 } else { 2 };
+   |                ^^^^^
+
+error: the operation is ineffective. Consider reducing it to `match a { 0 =>  0 + 10, _ => 20 }`
+  --> $DIR/identity_op.rs:92:5
+   |
+LL |     0 + match a { 0 =>  0 + 10, _ => 20 };
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: the operation is ineffective. Consider reducing it to `10`
+  --> $DIR/identity_op.rs:92:25
+   |
+LL |     0 + match a { 0 =>  0 + 10, _ => 20 };
+   |                         ^^^^^^
+
+error: the operation is ineffective. Consider reducing it to `1`
+  --> $DIR/identity_op.rs:93:16
+   |
+LL |     0 + if b { 0 + 1 } else { 2 } + match a { 0 => 0 + 30, _ => 40 };
+   |                ^^^^^
+
+error: the operation is ineffective. Consider reducing it to `30`
+  --> $DIR/identity_op.rs:93:52
+   |
+LL |     0 + if b { 0 + 1 } else { 2 } + match a { 0 => 0 + 30, _ => 40 };
+   |                                                    ^^^^^^
+
+error: the operation is ineffective. Consider reducing it to `1`
+  --> $DIR/identity_op.rs:95:20
+   |
+LL |     let _ = 0 + if 0 + 1 > 0 { 1 } else { 2 } + if 0 + 1 > 0 { 3 } else { 4 };
+   |                    ^^^^^
+
+error: the operation is ineffective. Consider reducing it to `1`
+  --> $DIR/identity_op.rs:95:52
+   |
+LL |     let _ = 0 + if 0 + 1 > 0 { 1 } else { 2 } + if 0 + 1 > 0 { 3 } else { 4 };
+   |                                                    ^^^^^
+
+error: the operation is ineffective. Consider reducing it to `1`
+  --> $DIR/identity_op.rs:96:23
+   |
+LL |     let _ = 0 + match 0 + 1 { 0 => 10, _ => 20 } + match 0 + 1  { 0 => 30, _ => 40 };
+   |                       ^^^^^
+
+error: the operation is ineffective. Consider reducing it to `1`
+  --> $DIR/identity_op.rs:96:58
+   |
+LL |     let _ = 0 + match 0 + 1 { 0 => 10, _ => 20 } + match 0 + 1  { 0 => 30, _ => 40 };
+   |                                                          ^^^^^
+
+error: the operation is ineffective. Consider reducing it to `0 + if b { 1 } else { 2 } + if b { 3 } else { 4 }`
+  --> $DIR/identity_op.rs:98:5
+   |
+LL |     0 + if b { 1 } else { 2 } + if b { 3 } else { 4 } + 0;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: the operation is ineffective. Consider reducing it to `a`
+  --> $DIR/identity_op.rs:106:7
+   |
+LL |     f(1 * a + { 8 * 5 });
+   |       ^^^^^
+
+error: the operation is ineffective. Consider reducing it to `{ 2 * 4 }`
+  --> $DIR/identity_op.rs:108:20
+   |
+LL |     const _: i32 = { 2 * 4 } + 0 + 3;
+   |                    ^^^^^^^^^^^^^
+
+error: aborting due to 33 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 6ff77b96f11143cf63f3522e4ffee4568b72330c Mon Sep 17 00:00:00 2001
From: Dan Gohman <dev@sunfishcode.online>
Date: Mon, 2 May 2022 13:46:29 -0700
Subject: Fix `cast_lossless` to avoid warning on `usize` to `f64` conversion.

Previously, the `cast_lossless` lint would issue a warning on code that
converted a `usize` value to `f64`, on 32-bit targets.

`usize` to `f64` is a lossless cast on 32-bit targets, however there is
no corresponding `f64::from` that takes a `usize`, so `cast_lossless`'s
suggested replacement does not compile.

This PR disables the lint in the case of casting from `usize` or `isize`.

Fixes #3689.

changelog: [`cast_lossless`] no longer gives wrong suggestion on usize->f64
---
 clippy_lints/src/casts/cast_lossless.rs |  2 +-
 tests/ui/cast_size_32bit.stderr         | 14 --------------
 2 files changed, 1 insertion(+), 15 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/cast_lossless.rs b/clippy_lints/src/casts/cast_lossless.rs
index 4a95bed1148..7717c1e9e31 100644
--- a/clippy_lints/src/casts/cast_lossless.rs
+++ b/clippy_lints/src/casts/cast_lossless.rs
@@ -93,7 +93,7 @@ fn should_lint(
             } else {
                 64
             };
-            from_nbits < to_nbits
+            !is_isize_or_usize(cast_from) && from_nbits < to_nbits
         },
         (false, true) if matches!(cast_from.kind(), ty::Bool) && meets_msrv(msrv.as_ref(), &msrvs::FROM_BOOL) => true,
         (_, _) => {
diff --git a/tests/ui/cast_size_32bit.stderr b/tests/ui/cast_size_32bit.stderr
index 140676a5ffc..7125f741c15 100644
--- a/tests/ui/cast_size_32bit.stderr
+++ b/tests/ui/cast_size_32bit.stderr
@@ -14,26 +14,12 @@ LL |     x0 as f64;
    |
    = note: `-D clippy::cast-precision-loss` implied by `-D warnings`
 
-error: casting `isize` to `f64` may become silently lossy if you later change the type
-  --> $DIR/cast_size_32bit.rs:15:5
-   |
-LL |     x0 as f64;
-   |     ^^^^^^^^^ help: try: `f64::from(x0)`
-   |
-   = note: `-D clippy::cast-lossless` implied by `-D warnings`
-
 error: casting `usize` to `f64` causes a loss of precision on targets with 64-bit wide pointers (`usize` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
   --> $DIR/cast_size_32bit.rs:16:5
    |
 LL |     x1 as f64;
    |     ^^^^^^^^^
 
-error: casting `usize` to `f64` may become silently lossy if you later change the type
-  --> $DIR/cast_size_32bit.rs:16:5
-   |
-LL |     x1 as f64;
-   |     ^^^^^^^^^ help: try: `f64::from(x1)`
-
 error: casting `isize` to `f32` causes a loss of precision (`isize` is 32 or 64 bits wide, but `f32`'s mantissa is only 23 bits wide)
   --> $DIR/cast_size_32bit.rs:17:5
    |
-- 
cgit 1.4.1-3-g733a5


From f505cc9f7265eee332984f30516852e24d6e8385 Mon Sep 17 00:00:00 2001
From: binggh <binggh@proton.me>
Date: Tue, 3 May 2022 17:51:23 +0800
Subject: Easier readability for needless_late_init

---
 clippy_lints/src/needless_late_init.rs | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/needless_late_init.rs b/clippy_lints/src/needless_late_init.rs
index a863a7990ca..b70871b38be 100644
--- a/clippy_lints/src/needless_late_init.rs
+++ b/clippy_lints/src/needless_late_init.rs
@@ -3,7 +3,7 @@ use clippy_utils::path_to_local;
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::needs_ordered_drop;
 use clippy_utils::visitors::{expr_visitor, expr_visitor_no_bodies, is_local_used};
-use rustc_errors::Applicability;
+use rustc_errors::{Applicability, MultiSpan};
 use rustc_hir::intravisit::Visitor;
 use rustc_hir::{
     BindingAnnotation, Block, Expr, ExprKind, HirId, Local, LocalSource, MatchSource, Node, Pat, PatKind, Stmt,
@@ -267,11 +267,14 @@ fn check<'tcx>(
     match usage.expr.kind {
         ExprKind::Assign(..) => {
             let assign = LocalAssign::new(cx, usage.expr, binding_id)?;
+            let mut msg_span = MultiSpan::from_spans(vec![local_stmt.span, assign.span]);
+            msg_span.push_span_label(local_stmt.span, "created here");
+            msg_span.push_span_label(assign.span, "initialised here");
 
             span_lint_and_then(
                 cx,
                 NEEDLESS_LATE_INIT,
-                local_stmt.span,
+                msg_span,
                 "unneeded late initialization",
                 |diag| {
                     diag.tool_only_span_suggestion(
@@ -365,7 +368,6 @@ fn check<'tcx>(
 impl<'tcx> LateLintPass<'tcx> for NeedlessLateInit {
     fn check_local(&mut self, cx: &LateContext<'tcx>, local: &'tcx Local<'tcx>) {
         let mut parents = cx.tcx.hir().parent_iter(local.hir_id);
-
         if_chain! {
             if let Local {
                 init: None,
-- 
cgit 1.4.1-3-g733a5


From d53293d52ac69d238b86a8ec8690e446e7ec789a Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Tue, 3 May 2022 13:39:38 +0100
Subject: Ignore type aliases in `init_numbered_fields`

---
 clippy_lints/src/init_numbered_fields.rs | 2 ++
 tests/ui/numbered_fields.fixed           | 5 +++++
 tests/ui/numbered_fields.rs              | 5 +++++
 3 files changed, 12 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/init_numbered_fields.rs b/clippy_lints/src/init_numbered_fields.rs
index 9284e002409..7e1548531f1 100644
--- a/clippy_lints/src/init_numbered_fields.rs
+++ b/clippy_lints/src/init_numbered_fields.rs
@@ -1,6 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use rustc_errors::Applicability;
+use rustc_hir::def::{DefKind, Res};
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -49,6 +50,7 @@ impl<'tcx> LateLintPass<'tcx> for NumberedFields {
                 && fields
                     .iter()
                     .all(|f| f.ident.as_str().as_bytes().iter().all(u8::is_ascii_digit))
+                && !matches!(cx.qpath_res(path, e.hir_id), Res::Def(DefKind::TyAlias, ..))
             {
                 let expr_spans = fields
                     .iter()
diff --git a/tests/ui/numbered_fields.fixed b/tests/ui/numbered_fields.fixed
index 1da97e96879..3710b3e9c81 100644
--- a/tests/ui/numbered_fields.fixed
+++ b/tests/ui/numbered_fields.fixed
@@ -30,4 +30,9 @@ fn main() {
 
     // Ok because it's in macro
     let _ = tuple_struct_init!();
+
+    type Alias = TupleStruct;
+
+    // Aliases can't be tuple constructed #8638
+    let _ = Alias { 0: 0, 1: 1, 2: 2 };
 }
diff --git a/tests/ui/numbered_fields.rs b/tests/ui/numbered_fields.rs
index 08ec405a560..2af84bc0642 100644
--- a/tests/ui/numbered_fields.rs
+++ b/tests/ui/numbered_fields.rs
@@ -38,4 +38,9 @@ fn main() {
 
     // Ok because it's in macro
     let _ = tuple_struct_init!();
+
+    type Alias = TupleStruct;
+
+    // Aliases can't be tuple constructed #8638
+    let _ = Alias { 0: 0, 1: 1, 2: 2 };
 }
-- 
cgit 1.4.1-3-g733a5


From 1834f326c4a2b732c7c62bf7b00efca8af3b290a Mon Sep 17 00:00:00 2001
From: flip1995 <philipp.krones@embecosm.com>
Date: Tue, 3 May 2022 16:41:12 +0100
Subject: Move only_used_in_recursion to nursery

---
 clippy_lints/src/lib.register_all.rs        | 1 -
 clippy_lints/src/lib.register_complexity.rs | 1 -
 clippy_lints/src/lib.register_nursery.rs    | 1 +
 clippy_lints/src/only_used_in_recursion.rs  | 9 ++++++++-
 4 files changed, 9 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 1cccfdb24c2..325e74a1778 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -248,7 +248,6 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(non_expressive_names::JUST_UNDERSCORES_AND_DIGITS),
     LintId::of(non_octal_unix_permissions::NON_OCTAL_UNIX_PERMISSIONS),
     LintId::of(octal_escapes::OCTAL_ESCAPES),
-    LintId::of(only_used_in_recursion::ONLY_USED_IN_RECURSION),
     LintId::of(open_options::NONSENSICAL_OPEN_OPTIONS),
     LintId::of(option_env_unwrap::OPTION_ENV_UNWRAP),
     LintId::of(overflow_check_conditional::OVERFLOW_CHECK_CONDITIONAL),
diff --git a/clippy_lints/src/lib.register_complexity.rs b/clippy_lints/src/lib.register_complexity.rs
index df646ff5c5f..6f3c433af31 100644
--- a/clippy_lints/src/lib.register_complexity.rs
+++ b/clippy_lints/src/lib.register_complexity.rs
@@ -68,7 +68,6 @@ store.register_group(true, "clippy::complexity", Some("clippy_complexity"), vec!
     LintId::of(neg_cmp_op_on_partial_ord::NEG_CMP_OP_ON_PARTIAL_ORD),
     LintId::of(no_effect::NO_EFFECT),
     LintId::of(no_effect::UNNECESSARY_OPERATION),
-    LintId::of(only_used_in_recursion::ONLY_USED_IN_RECURSION),
     LintId::of(overflow_check_conditional::OVERFLOW_CHECK_CONDITIONAL),
     LintId::of(partialeq_ne_impl::PARTIALEQ_NE_IMPL),
     LintId::of(precedence::PRECEDENCE),
diff --git a/clippy_lints/src/lib.register_nursery.rs b/clippy_lints/src/lib.register_nursery.rs
index c2fc67afba5..18904a94538 100644
--- a/clippy_lints/src/lib.register_nursery.rs
+++ b/clippy_lints/src/lib.register_nursery.rs
@@ -20,6 +20,7 @@ store.register_group(true, "clippy::nursery", Some("clippy_nursery"), vec![
     LintId::of(mutex_atomic::MUTEX_INTEGER),
     LintId::of(non_send_fields_in_send_ty::NON_SEND_FIELDS_IN_SEND_TY),
     LintId::of(nonstandard_macro_braces::NONSTANDARD_MACRO_BRACES),
+    LintId::of(only_used_in_recursion::ONLY_USED_IN_RECURSION),
     LintId::of(option_if_let_else::OPTION_IF_LET_ELSE),
     LintId::of(path_buf_push_overwrite::PATH_BUF_PUSH_OVERWRITE),
     LintId::of(redundant_pub_crate::REDUNDANT_PUB_CRATE),
diff --git a/clippy_lints/src/only_used_in_recursion.rs b/clippy_lints/src/only_used_in_recursion.rs
index f946fc11192..beb812793f8 100644
--- a/clippy_lints/src/only_used_in_recursion.rs
+++ b/clippy_lints/src/only_used_in_recursion.rs
@@ -1,6 +1,7 @@
 use std::collections::VecDeque;
 
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::is_lint_allowed;
 use itertools::{izip, Itertools};
 use rustc_ast::{walk_list, Label, Mutability};
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
@@ -33,6 +34,9 @@ declare_clippy_lint! {
     /// and the assigned variables are also only in recursion, it is useless.
     ///
     /// ### Known problems
+    /// Too many code paths in the linting code are currently untested and prone to produce false
+    /// positives or are prone to have performance implications.
+    ///
     /// In some cases, this would not catch all useless arguments.
     ///
     /// ```rust
@@ -85,7 +89,7 @@ declare_clippy_lint! {
     /// ```
     #[clippy::version = "1.60.0"]
     pub ONLY_USED_IN_RECURSION,
-    complexity,
+    nursery,
     "arguments that is only used in recursion can be removed"
 }
 declare_lint_pass!(OnlyUsedInRecursion => [ONLY_USED_IN_RECURSION]);
@@ -100,6 +104,9 @@ impl<'tcx> LateLintPass<'tcx> for OnlyUsedInRecursion {
         _: Span,
         id: HirId,
     ) {
+        if is_lint_allowed(cx, ONLY_USED_IN_RECURSION, id) {
+            return;
+        }
         if let FnKind::ItemFn(ident, ..) | FnKind::Method(ident, ..) = kind {
             let def_id = id.owner.to_def_id();
             let data = cx.tcx.def_path(def_id).data;
-- 
cgit 1.4.1-3-g733a5


From fea177fafe44c6ea950b71d812102167dfefd6b6 Mon Sep 17 00:00:00 2001
From: Max Baumann <max@bmn.dev>
Date: Tue, 22 Mar 2022 21:15:09 +0100
Subject: add trim_split_whitespace

---
 CHANGELOG.md                           |  1 +
 clippy_lints/src/lib.register_all.rs   |  1 +
 clippy_lints/src/lib.register_lints.rs |  1 +
 clippy_lints/src/lib.register_style.rs |  1 +
 clippy_lints/src/lib.rs                |  1 +
 clippy_lints/src/strings.rs            | 56 +++++++++++++++++++++
 tests/ui/trim_split_whitespace.fixed   | 91 ++++++++++++++++++++++++++++++++++
 tests/ui/trim_split_whitespace.rs      | 91 ++++++++++++++++++++++++++++++++++
 tests/ui/trim_split_whitespace.stderr  | 52 +++++++++++++++++++
 9 files changed, 295 insertions(+)
 create mode 100644 tests/ui/trim_split_whitespace.fixed
 create mode 100644 tests/ui/trim_split_whitespace.rs
 create mode 100644 tests/ui/trim_split_whitespace.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index c88ead99fa6..751f9fccd88 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3736,6 +3736,7 @@ Released 2018-09-13
 [`transmute_undefined_repr`]: https://rust-lang.github.io/rust-clippy/master/index.html#transmute_undefined_repr
 [`transmutes_expressible_as_ptr_casts`]: https://rust-lang.github.io/rust-clippy/master/index.html#transmutes_expressible_as_ptr_casts
 [`transmuting_null`]: https://rust-lang.github.io/rust-clippy/master/index.html#transmuting_null
+[`trim_split_whitespace`]: https://rust-lang.github.io/rust-clippy/master/index.html#trim_split_whitespace
 [`trivial_regex`]: https://rust-lang.github.io/rust-clippy/master/index.html#trivial_regex
 [`trivially_copy_pass_by_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#trivially_copy_pass_by_ref
 [`try_err`]: https://rust-lang.github.io/rust-clippy/master/index.html#try_err
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 1cccfdb24c2..a49f8656ba3 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -281,6 +281,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(size_of_in_element_count::SIZE_OF_IN_ELEMENT_COUNT),
     LintId::of(slow_vector_initialization::SLOW_VECTOR_INITIALIZATION),
     LintId::of(strings::STRING_FROM_UTF8_AS_BYTES),
+    LintId::of(strings::TRIM_SPLIT_WHITESPACE),
     LintId::of(strlen_on_c_strings::STRLEN_ON_C_STRINGS),
     LintId::of(suspicious_trait_impl::SUSPICIOUS_ARITHMETIC_IMPL),
     LintId::of(suspicious_trait_impl::SUSPICIOUS_OP_ASSIGN_IMPL),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index e3624316027..5768edc5018 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -482,6 +482,7 @@ store.register_lints(&[
     strings::STRING_SLICE,
     strings::STRING_TO_STRING,
     strings::STR_TO_STRING,
+    strings::TRIM_SPLIT_WHITESPACE,
     strlen_on_c_strings::STRLEN_ON_C_STRINGS,
     suspicious_operation_groupings::SUSPICIOUS_OPERATION_GROUPINGS,
     suspicious_trait_impl::SUSPICIOUS_ARITHMETIC_IMPL,
diff --git a/clippy_lints/src/lib.register_style.rs b/clippy_lints/src/lib.register_style.rs
index 5a85a9e209e..d183c0449cd 100644
--- a/clippy_lints/src/lib.register_style.rs
+++ b/clippy_lints/src/lib.register_style.rs
@@ -105,6 +105,7 @@ store.register_group(true, "clippy::style", Some("clippy_style"), vec![
     LintId::of(returns::NEEDLESS_RETURN),
     LintId::of(self_named_constructors::SELF_NAMED_CONSTRUCTORS),
     LintId::of(single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS),
+    LintId::of(strings::TRIM_SPLIT_WHITESPACE),
     LintId::of(tabs_in_doc_comments::TABS_IN_DOC_COMMENTS),
     LintId::of(to_digit_is_some::TO_DIGIT_IS_SOME),
     LintId::of(unit_types::LET_UNIT_VALUE),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 57d48e17627..caf48194ad4 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -887,6 +887,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(bytes_count_to_len::BytesCountToLen));
     let max_include_file_size = conf.max_include_file_size;
     store.register_late_pass(move || Box::new(large_include_file::LargeIncludeFile::new(max_include_file_size)));
+    store.register_late_pass(|| Box::new(strings::TrimSplitWhitespace));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/strings.rs b/clippy_lints/src/strings.rs
index 3573f632a36..7c196ccaa8c 100644
--- a/clippy_lints/src/strings.rs
+++ b/clippy_lints/src/strings.rs
@@ -5,6 +5,7 @@ use clippy_utils::{get_parent_expr, is_lint_allowed, match_function_call, method
 use clippy_utils::{peel_blocks, SpanlessEq};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
+use rustc_hir::def_id::DefId;
 use rustc_hir::{BinOpKind, BorrowKind, Expr, ExprKind, LangItem, QPath};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
@@ -451,3 +452,58 @@ impl<'tcx> LateLintPass<'tcx> for StringToString {
         }
     }
 }
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Warns about calling `str::trim` (or variants) before `str::split_whitespace`.
+    ///
+    /// ### Why is this bad?
+    /// `split_whitespace` already ignores leading and trailing whitespace.
+    ///
+    /// ### Example
+    /// ```rust
+    /// " A B C ".trim().split_whitespace();
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// " A B C ".split_whitespace();
+    /// ```
+    #[clippy::version = "1.62.0"]
+    pub TRIM_SPLIT_WHITESPACE,
+    style,
+    "using `str::trim()` or alike before `str::split_whitespace`"
+}
+declare_lint_pass!(TrimSplitWhitespace => [TRIM_SPLIT_WHITESPACE]);
+
+impl<'tcx> LateLintPass<'tcx> for TrimSplitWhitespace {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &Expr<'_>) {
+        let tyckres = cx.typeck_results();
+        if_chain! {
+            if let ExprKind::MethodCall(path, [split_recv], split_ws_span) = expr.kind;
+            if path.ident.name == sym!(split_whitespace);
+            if let Some(split_ws_def_id) = tyckres.type_dependent_def_id(expr.hir_id);
+            if cx.tcx.is_diagnostic_item(sym::str_split_whitespace, split_ws_def_id);
+            if let ExprKind::MethodCall(path, [_trim_recv], trim_span) = split_recv.kind;
+            if let trim_fn_name @ ("trim" | "trim_start" | "trim_end") = path.ident.name.as_str();
+            if let Some(trim_def_id) = tyckres.type_dependent_def_id(split_recv.hir_id);
+            if is_one_of_trim_diagnostic_items(cx, trim_def_id);
+            then {
+                span_lint_and_sugg(
+                    cx,
+                    TRIM_SPLIT_WHITESPACE,
+                    trim_span.with_hi(split_ws_span.lo()),
+                    &format!("found call to `str::{}` before `str::split_whitespace`", trim_fn_name),
+                    &format!("remove `{}()`", trim_fn_name),
+                    String::new(),
+                    Applicability::MachineApplicable,
+                );
+            }
+        }
+    }
+}
+
+fn is_one_of_trim_diagnostic_items(cx: &LateContext<'_>, trim_def_id: DefId) -> bool {
+    cx.tcx.is_diagnostic_item(sym::str_trim, trim_def_id)
+        || cx.tcx.is_diagnostic_item(sym::str_trim_start, trim_def_id)
+        || cx.tcx.is_diagnostic_item(sym::str_trim_end, trim_def_id)
+}
diff --git a/tests/ui/trim_split_whitespace.fixed b/tests/ui/trim_split_whitespace.fixed
new file mode 100644
index 00000000000..e4d352f7367
--- /dev/null
+++ b/tests/ui/trim_split_whitespace.fixed
@@ -0,0 +1,91 @@
+// run-rustfix
+#![warn(clippy::trim_split_whitespace)]
+#![allow(clippy::let_unit_value)]
+
+struct Custom;
+impl Custom {
+    fn trim(self) -> Self {
+        self
+    }
+    fn split_whitespace(self) {}
+}
+
+struct DerefStr(&'static str);
+impl std::ops::Deref for DerefStr {
+    type Target = str;
+    fn deref(&self) -> &Self::Target {
+        self.0
+    }
+}
+
+struct DerefStrAndCustom(&'static str);
+impl std::ops::Deref for DerefStrAndCustom {
+    type Target = str;
+    fn deref(&self) -> &Self::Target {
+        self.0
+    }
+}
+impl DerefStrAndCustom {
+    fn trim(self) -> Self {
+        self
+    }
+    fn split_whitespace(self) {}
+}
+
+struct DerefStrAndCustomSplit(&'static str);
+impl std::ops::Deref for DerefStrAndCustomSplit {
+    type Target = str;
+    fn deref(&self) -> &Self::Target {
+        self.0
+    }
+}
+impl DerefStrAndCustomSplit {
+    #[allow(dead_code)]
+    fn split_whitespace(self) {}
+}
+
+struct DerefStrAndCustomTrim(&'static str);
+impl std::ops::Deref for DerefStrAndCustomTrim {
+    type Target = str;
+    fn deref(&self) -> &Self::Target {
+        self.0
+    }
+}
+impl DerefStrAndCustomTrim {
+    fn trim(self) -> Self {
+        self
+    }
+}
+
+fn main() {
+    // &str
+    let _ = " A B C ".split_whitespace(); // should trigger lint
+    let _ = " A B C ".split_whitespace(); // should trigger lint
+    let _ = " A B C ".split_whitespace(); // should trigger lint
+
+    // String
+    let _ = (" A B C ").to_string().split_whitespace(); // should trigger lint
+    let _ = (" A B C ").to_string().split_whitespace(); // should trigger lint
+    let _ = (" A B C ").to_string().split_whitespace(); // should trigger lint
+
+    // Custom
+    let _ = Custom.trim().split_whitespace(); // should not trigger lint
+
+    // Deref<Target=str>
+    let s = DerefStr(" A B C ");
+    let _ = s.split_whitespace(); // should trigger lint
+
+    // Deref<Target=str> + custom impl
+    let s = DerefStrAndCustom(" A B C ");
+    let _ = s.trim().split_whitespace(); // should not trigger lint
+
+    // Deref<Target=str> + only custom split_ws() impl
+    let s = DerefStrAndCustomSplit(" A B C ");
+    let _ = s.split_whitespace(); // should trigger lint
+    // Expl: trim() is called on str (deref) and returns &str.
+    //       Thus split_ws() is called on str as well and the custom impl on S is unused
+
+    // Deref<Target=str> + only custom trim() impl
+    let s = DerefStrAndCustomTrim(" A B C ");
+    let _ = s.trim().split_whitespace(); // should not trigger lint
+}
diff --git a/tests/ui/trim_split_whitespace.rs b/tests/ui/trim_split_whitespace.rs
new file mode 100644
index 00000000000..f98451a9837
--- /dev/null
+++ b/tests/ui/trim_split_whitespace.rs
@@ -0,0 +1,91 @@
+// run-rustfix
+#![warn(clippy::trim_split_whitespace)]
+#![allow(clippy::let_unit_value)]
+
+struct Custom;
+impl Custom {
+    fn trim(self) -> Self {
+        self
+    }
+    fn split_whitespace(self) {}
+}
+
+struct DerefStr(&'static str);
+impl std::ops::Deref for DerefStr {
+    type Target = str;
+    fn deref(&self) -> &Self::Target {
+        self.0
+    }
+}
+
+struct DerefStrAndCustom(&'static str);
+impl std::ops::Deref for DerefStrAndCustom {
+    type Target = str;
+    fn deref(&self) -> &Self::Target {
+        self.0
+    }
+}
+impl DerefStrAndCustom {
+    fn trim(self) -> Self {
+        self
+    }
+    fn split_whitespace(self) {}
+}
+
+struct DerefStrAndCustomSplit(&'static str);
+impl std::ops::Deref for DerefStrAndCustomSplit {
+    type Target = str;
+    fn deref(&self) -> &Self::Target {
+        self.0
+    }
+}
+impl DerefStrAndCustomSplit {
+    #[allow(dead_code)]
+    fn split_whitespace(self) {}
+}
+
+struct DerefStrAndCustomTrim(&'static str);
+impl std::ops::Deref for DerefStrAndCustomTrim {
+    type Target = str;
+    fn deref(&self) -> &Self::Target {
+        self.0
+    }
+}
+impl DerefStrAndCustomTrim {
+    fn trim(self) -> Self {
+        self
+    }
+}
+
+fn main() {
+    // &str
+    let _ = " A B C ".trim().split_whitespace(); // should trigger lint
+    let _ = " A B C ".trim_start().split_whitespace(); // should trigger lint
+    let _ = " A B C ".trim_end().split_whitespace(); // should trigger lint
+
+    // String
+    let _ = (" A B C ").to_string().trim().split_whitespace(); // should trigger lint
+    let _ = (" A B C ").to_string().trim_start().split_whitespace(); // should trigger lint
+    let _ = (" A B C ").to_string().trim_end().split_whitespace(); // should trigger lint
+
+    // Custom
+    let _ = Custom.trim().split_whitespace(); // should not trigger lint
+
+    // Deref<Target=str>
+    let s = DerefStr(" A B C ");
+    let _ = s.trim().split_whitespace(); // should trigger lint
+
+    // Deref<Target=str> + custom impl
+    let s = DerefStrAndCustom(" A B C ");
+    let _ = s.trim().split_whitespace(); // should not trigger lint
+
+    // Deref<Target=str> + only custom split_ws() impl
+    let s = DerefStrAndCustomSplit(" A B C ");
+    let _ = s.trim().split_whitespace(); // should trigger lint
+    // Expl: trim() is called on str (deref) and returns &str.
+    //       Thus split_ws() is called on str as well and the custom impl on S is unused
+
+    // Deref<Target=str> + only custom trim() impl
+    let s = DerefStrAndCustomTrim(" A B C ");
+    let _ = s.trim().split_whitespace(); // should not trigger lint
+}
diff --git a/tests/ui/trim_split_whitespace.stderr b/tests/ui/trim_split_whitespace.stderr
new file mode 100644
index 00000000000..5ae7849e27d
--- /dev/null
+++ b/tests/ui/trim_split_whitespace.stderr
@@ -0,0 +1,52 @@
+error: found call to `str::trim` before `str::split_whitespace`
+  --> $DIR/trim_split_whitespace.rs:62:23
+   |
+LL |     let _ = " A B C ".trim().split_whitespace(); // should trigger lint
+   |                       ^^^^^^^ help: remove `trim()`
+   |
+   = note: `-D clippy::trim-split-whitespace` implied by `-D warnings`
+
+error: found call to `str::trim_start` before `str::split_whitespace`
+  --> $DIR/trim_split_whitespace.rs:63:23
+   |
+LL |     let _ = " A B C ".trim_start().split_whitespace(); // should trigger lint
+   |                       ^^^^^^^^^^^^^ help: remove `trim_start()`
+
+error: found call to `str::trim_end` before `str::split_whitespace`
+  --> $DIR/trim_split_whitespace.rs:64:23
+   |
+LL |     let _ = " A B C ".trim_end().split_whitespace(); // should trigger lint
+   |                       ^^^^^^^^^^^ help: remove `trim_end()`
+
+error: found call to `str::trim` before `str::split_whitespace`
+  --> $DIR/trim_split_whitespace.rs:67:37
+   |
+LL |     let _ = (" A B C ").to_string().trim().split_whitespace(); // should trigger lint
+   |                                     ^^^^^^^ help: remove `trim()`
+
+error: found call to `str::trim_start` before `str::split_whitespace`
+  --> $DIR/trim_split_whitespace.rs:68:37
+   |
+LL |     let _ = (" A B C ").to_string().trim_start().split_whitespace(); // should trigger lint
+   |                                     ^^^^^^^^^^^^^ help: remove `trim_start()`
+
+error: found call to `str::trim_end` before `str::split_whitespace`
+  --> $DIR/trim_split_whitespace.rs:69:37
+   |
+LL |     let _ = (" A B C ").to_string().trim_end().split_whitespace(); // should trigger lint
+   |                                     ^^^^^^^^^^^ help: remove `trim_end()`
+
+error: found call to `str::trim` before `str::split_whitespace`
+  --> $DIR/trim_split_whitespace.rs:76:15
+   |
+LL |     let _ = s.trim().split_whitespace(); // should trigger lint
+   |               ^^^^^^^ help: remove `trim()`
+
+error: found call to `str::trim` before `str::split_whitespace`
+  --> $DIR/trim_split_whitespace.rs:84:15
+   |
+LL |     let _ = s.trim().split_whitespace(); // should trigger lint
+   |               ^^^^^^^ help: remove `trim()`
+
+error: aborting due to 8 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From ee8fae3f5d4aac2bcbea8936e39d3027aade8e32 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Wed, 4 May 2022 18:13:06 +0100
Subject: identity_op: add parenthesis to suggestions where required

---
 clippy_lints/src/identity_op.rs | 125 +++++++++++--------
 tests/ui/identity_op.fixed      | 119 ++++++++++++++++++
 tests/ui/identity_op.rs         |  63 +++++-----
 tests/ui/identity_op.stderr     | 260 +++++++++++++++++++++++-----------------
 tests/ui/modulo_one.rs          |   2 +-
 tests/ui/modulo_one.stderr      |  10 +-
 6 files changed, 377 insertions(+), 202 deletions(-)
 create mode 100644 tests/ui/identity_op.fixed

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/identity_op.rs b/clippy_lints/src/identity_op.rs
index 40cc5cd4bcf..419ea5a6811 100644
--- a/clippy_lints/src/identity_op.rs
+++ b/clippy_lints/src/identity_op.rs
@@ -1,15 +1,14 @@
-use clippy_utils::get_parent_expr;
-use clippy_utils::source::snippet;
-use rustc_hir::{BinOp, BinOpKind, Expr, ExprKind};
+use clippy_utils::consts::{constant_full_int, constant_simple, Constant, FullInt};
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::{clip, unsext};
+use rustc_errors::Applicability;
+use rustc_hir::{BinOp, BinOpKind, Expr, ExprKind, Node};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
 
-use clippy_utils::consts::{constant_full_int, constant_simple, Constant, FullInt};
-use clippy_utils::diagnostics::span_lint;
-use clippy_utils::{clip, unsext};
-
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for identity operations, e.g., `x + 0`.
@@ -23,11 +22,6 @@ declare_clippy_lint! {
     /// # let x = 1;
     /// x / 1 + 0 * 1 - 0 | 0;
     /// ```
-    ///
-    /// ### Known problems
-    /// False negatives: `f(0 + if b { 1 } else { 2 } + 3);` is reducible to
-    /// `f(if b { 1 } else { 2 } + 3);`. But the lint doesn't trigger for the code.
-    /// See [#8724](https://github.com/rust-lang/rust-clippy/issues/8724)
     #[clippy::version = "pre 1.29.0"]
     pub IDENTITY_OP,
     complexity,
@@ -45,31 +39,22 @@ impl<'tcx> LateLintPass<'tcx> for IdentityOp {
             if !is_allowed(cx, *cmp, left, right) {
                 match cmp.node {
                     BinOpKind::Add | BinOpKind::BitOr | BinOpKind::BitXor => {
-                        if reducible_to_right(cx, expr, right) {
-                            check(cx, left, 0, expr.span, right.span);
-                        }
-                        check(cx, right, 0, expr.span, left.span);
+                        check(cx, left, 0, expr.span, right.span, needs_parenthesis(cx, expr, right));
+                        check(cx, right, 0, expr.span, left.span, Parens::Unneeded);
                     },
                     BinOpKind::Shl | BinOpKind::Shr | BinOpKind::Sub => {
-                        check(cx, right, 0, expr.span, left.span);
+                        check(cx, right, 0, expr.span, left.span, Parens::Unneeded);
                     },
                     BinOpKind::Mul => {
-                        if reducible_to_right(cx, expr, right) {
-                            check(cx, left, 1, expr.span, right.span);
-                        }
-                        check(cx, right, 1, expr.span, left.span);
+                        check(cx, left, 1, expr.span, right.span, needs_parenthesis(cx, expr, right));
+                        check(cx, right, 1, expr.span, left.span, Parens::Unneeded);
                     },
-                    BinOpKind::Div => check(cx, right, 1, expr.span, left.span),
+                    BinOpKind::Div => check(cx, right, 1, expr.span, left.span, Parens::Unneeded),
                     BinOpKind::BitAnd => {
-                        if reducible_to_right(cx, expr, right) {
-                            check(cx, left, -1, expr.span, right.span);
-                        }
-                        check(cx, right, -1, expr.span, left.span);
-                    },
-                    BinOpKind::Rem => {
-                        // Don't call reducible_to_right because N % N is always reducible to 1
-                        check_remainder(cx, left, right, expr.span, left.span);
+                        check(cx, left, -1, expr.span, right.span, needs_parenthesis(cx, expr, right));
+                        check(cx, right, -1, expr.span, left.span, Parens::Unneeded);
                     },
+                    BinOpKind::Rem => check_remainder(cx, left, right, expr.span, left.span),
                     _ => (),
                 }
             }
@@ -77,24 +62,50 @@ impl<'tcx> LateLintPass<'tcx> for IdentityOp {
     }
 }
 
-/// Checks if `left op ..right` can be actually reduced to `right`
-/// e.g. `0 + if b { 1 } else { 2 } + if b { 3 } else { 4 }`
-/// cannot be reduced to `if b { 1 } else { 2 } +  if b { 3 } else { 4 }`
+#[derive(Copy, Clone)]
+enum Parens {
+    Needed,
+    Unneeded,
+}
+
+/// Checks if `left op right` needs parenthesis when reduced to `right`
+/// e.g. `0 + if b { 1 } else { 2 } + if b { 3 } else { 4 }` cannot be reduced
+/// to `if b { 1 } else { 2 } + if b { 3 } else { 4 }` where the `if` could be
+/// interpreted as a statement
+///
 /// See #8724
-fn reducible_to_right(cx: &LateContext<'_>, binary: &Expr<'_>, right: &Expr<'_>) -> bool {
-    if let ExprKind::If(..) | ExprKind::Match(..) | ExprKind::Block(..) | ExprKind::Loop(..) = right.kind {
-        is_toplevel_binary(cx, binary)
-    } else {
-        true
+fn needs_parenthesis(cx: &LateContext<'_>, binary: &Expr<'_>, right: &Expr<'_>) -> Parens {
+    match right.kind {
+        ExprKind::Binary(_, lhs, _) | ExprKind::Cast(lhs, _) => {
+            // ensure we're checking against the leftmost expression of `right`
+            //
+            //     ~~~ `lhs`
+            // 0 + {4} * 2
+            //     ~~~~~~~ `right`
+            return needs_parenthesis(cx, binary, lhs);
+        },
+        ExprKind::If(..) | ExprKind::Match(..) | ExprKind::Block(..) | ExprKind::Loop(..) => {},
+        _ => return Parens::Unneeded,
     }
-}
 
-fn is_toplevel_binary(cx: &LateContext<'_>, must_be_binary: &Expr<'_>) -> bool {
-    if let Some(parent) = get_parent_expr(cx, must_be_binary) && let ExprKind::Binary(..) = &parent.kind {
-        false
-    } else {
-        true
+    let mut prev_id = binary.hir_id;
+    for (_, node) in cx.tcx.hir().parent_iter(binary.hir_id) {
+        if let Node::Expr(expr) = node
+            && let ExprKind::Binary(_, lhs, _) | ExprKind::Cast(lhs, _) = expr.kind
+            && lhs.hir_id == prev_id
+        {
+            // keep going until we find a node that encompasses left of `binary`
+            prev_id = expr.hir_id;
+            continue;
+        }
+
+        match node {
+            Node::Block(_) | Node::Stmt(_) => break,
+            _ => return Parens::Unneeded,
+        };
     }
+
+    Parens::Needed
 }
 
 fn is_allowed(cx: &LateContext<'_>, cmp: BinOp, left: &Expr<'_>, right: &Expr<'_>) -> bool {
@@ -115,11 +126,11 @@ fn check_remainder(cx: &LateContext<'_>, left: &Expr<'_>, right: &Expr<'_>, span
         (Some(FullInt::U(lv)), Some(FullInt::U(rv))) => lv < rv,
         _ => return,
     } {
-        span_ineffective_operation(cx, span, arg);
+        span_ineffective_operation(cx, span, arg, Parens::Unneeded);
     }
 }
 
-fn check(cx: &LateContext<'_>, e: &Expr<'_>, m: i8, span: Span, arg: Span) {
+fn check(cx: &LateContext<'_>, e: &Expr<'_>, m: i8, span: Span, arg: Span, parens: Parens) {
     if let Some(Constant::Int(v)) = constant_simple(cx, cx.typeck_results(), e).map(Constant::peel_refs) {
         let check = match *cx.typeck_results().expr_ty(e).peel_refs().kind() {
             ty::Int(ity) => unsext(cx.tcx, -1_i128, ity),
@@ -132,19 +143,27 @@ fn check(cx: &LateContext<'_>, e: &Expr<'_>, m: i8, span: Span, arg: Span) {
             1 => v == 1,
             _ => unreachable!(),
         } {
-            span_ineffective_operation(cx, span, arg);
+            span_ineffective_operation(cx, span, arg, parens);
         }
     }
 }
 
-fn span_ineffective_operation(cx: &LateContext<'_>, span: Span, arg: Span) {
-    span_lint(
+fn span_ineffective_operation(cx: &LateContext<'_>, span: Span, arg: Span, parens: Parens) {
+    let mut applicability = Applicability::MachineApplicable;
+    let expr_snippet = snippet_with_applicability(cx, arg, "..", &mut applicability);
+
+    let suggestion = match parens {
+        Parens::Needed => format!("({expr_snippet})"),
+        Parens::Unneeded => expr_snippet.into_owned(),
+    };
+
+    span_lint_and_sugg(
         cx,
         IDENTITY_OP,
         span,
-        &format!(
-            "the operation is ineffective. Consider reducing it to `{}`",
-            snippet(cx, arg, "..")
-        ),
+        "this operation has no effect",
+        "consider reducing it to",
+        suggestion,
+        applicability,
     );
 }
diff --git a/tests/ui/identity_op.fixed b/tests/ui/identity_op.fixed
new file mode 100644
index 00000000000..5f9cebe212a
--- /dev/null
+++ b/tests/ui/identity_op.fixed
@@ -0,0 +1,119 @@
+// run-rustfix
+
+#![warn(clippy::identity_op)]
+#![allow(
+    clippy::eq_op,
+    clippy::no_effect,
+    clippy::unnecessary_operation,
+    clippy::op_ref,
+    clippy::double_parens,
+    unused
+)]
+
+use std::fmt::Write as _;
+
+const ONE: i64 = 1;
+const NEG_ONE: i64 = -1;
+const ZERO: i64 = 0;
+
+struct A(String);
+
+impl std::ops::Shl<i32> for A {
+    type Output = A;
+    fn shl(mut self, other: i32) -> Self {
+        let _ = write!(self.0, "{}", other);
+        self
+    }
+}
+
+struct Length(u8);
+struct Meter;
+
+impl core::ops::Mul<Meter> for u8 {
+    type Output = Length;
+    fn mul(self, _: Meter) -> Length {
+        Length(self)
+    }
+}
+
+#[rustfmt::skip]
+fn main() {
+    let x = 0;
+
+    x;
+    x;
+    x + 1;
+    x;
+    1 + x;
+    x - ZERO; //no error, as we skip lookups (for now)
+    x;
+    ((ZERO)) | x; //no error, as we skip lookups (for now)
+
+    x;
+    x;
+    x / ONE; //no error, as we skip lookups (for now)
+
+    x / 2; //no false positive
+
+    x & NEG_ONE; //no error, as we skip lookups (for now)
+    x;
+
+    let u: u8 = 0;
+    u;
+
+    1 << 0; // no error, this case is allowed, see issue 3430
+    42;
+    1;
+    42;
+    &x;
+    x;
+
+    let mut a = A("".into());
+    let b = a << 0; // no error: non-integer
+
+    1 * Meter; // no error: non-integer
+
+    2;
+    -2;
+    2 + x;
+    -2 + x;
+    x + 1;
+    (x + 1) % 3; // no error
+    4 % 3; // no error
+    4 % -3; // no error
+
+    // See #8724
+    let a = 0;
+    let b = true;
+    (if b { 1 } else { 2 });
+    (if b { 1 } else { 2 }) + if b { 3 } else { 4 };
+    (match a { 0 => 10, _ => 20 });
+    (match a { 0 => 10, _ => 20 }) + match a { 0 => 30, _ => 40 };
+    (if b { 1 } else { 2 }) + match a { 0 => 30, _ => 40 };
+    (match a { 0 => 10, _ => 20 }) + if b { 3 } else { 4 };
+    (if b { 1 } else { 2 });
+
+    ({ a }) + 3;
+    ({ a } * 2);
+    (loop { let mut c = 0; if c == 10 { break c; } c += 1; }) + { a * 2 };
+
+    fn f(_: i32) {
+        todo!();
+    }
+    f(a + { 8 * 5 });
+    f(if b { 1 } else { 2 } + 3);
+    const _: i32 = { 2 * 4 } + 3;
+    const _: i32 = { 1 + 2 * 3 } + 3;
+
+    a as usize;
+    let _ = a as usize;
+    ({ a } as usize);
+
+    2 * { a };
+    (({ a } + 4));
+    1;
+}
+
+pub fn decide(a: bool, b: bool) -> u32 {
+    (if a { 1 } else { 2 }) + if b { 3 } else { 5 }
+}
diff --git a/tests/ui/identity_op.rs b/tests/ui/identity_op.rs
index fec54d00ccb..ca799c9cfac 100644
--- a/tests/ui/identity_op.rs
+++ b/tests/ui/identity_op.rs
@@ -1,3 +1,15 @@
+// run-rustfix
+
+#![warn(clippy::identity_op)]
+#![allow(
+    clippy::eq_op,
+    clippy::no_effect,
+    clippy::unnecessary_operation,
+    clippy::op_ref,
+    clippy::double_parens,
+    unused
+)]
+
 use std::fmt::Write as _;
 
 const ONE: i64 = 1;
@@ -24,14 +36,6 @@ impl core::ops::Mul<Meter> for u8 {
     }
 }
 
-#[allow(
-    clippy::eq_op,
-    clippy::no_effect,
-    clippy::unnecessary_operation,
-    clippy::op_ref,
-    clippy::double_parens
-)]
-#[warn(clippy::identity_op)]
 #[rustfmt::skip]
 fn main() {
     let x = 0;
@@ -82,29 +86,34 @@ fn main() {
     let a = 0;
     let b = true;
     0 + if b { 1 } else { 2 };
-    0 + if b { 1 } else { 2 } + if b { 3 } else { 4 }; // no error
+    0 + if b { 1 } else { 2 } + if b { 3 } else { 4 };
     0 + match a { 0 => 10, _ => 20 };
-    0 + match a { 0 => 10, _ => 20 } + match a { 0 => 30, _ => 40 }; // no error
-    0 + if b { 1 } else { 2 } + match a { 0 => 30, _ => 40 }; // no error
-    0 + match a { 0 => 10, _ => 20 } + if b { 3 } else { 4 }; // no error
-    
-    0 + if b { 0 + 1 } else { 2 };
-    0 + match a { 0 =>  0 + 10, _ => 20 };
-    0 + if b { 0 + 1 } else { 2 } + match a { 0 => 0 + 30, _ => 40 };
-
-    let _ = 0 + if 0 + 1 > 0 { 1 } else { 2 } + if 0 + 1 > 0 { 3 } else { 4 };
-    let _ = 0 + match 0 + 1 { 0 => 10, _ => 20 } + match 0 + 1  { 0 => 30, _ => 40 };
-
-    0 + if b { 1 } else { 2 } + if b { 3 } else { 4 } + 0;
-    
-    0 + { a } + 3; // no error
-    0 + loop { let mut c = 0; if c == 10 { break c; } c += 1; } + { a * 2 }; // no error
-    
+    0 + match a { 0 => 10, _ => 20 } + match a { 0 => 30, _ => 40 };
+    0 + if b { 1 } else { 2 } + match a { 0 => 30, _ => 40 };
+    0 + match a { 0 => 10, _ => 20 } + if b { 3 } else { 4 };
+    (if b { 1 } else { 2 }) + 0;
+
+    0 + { a } + 3;
+    0 + { a } * 2;
+    0 + loop { let mut c = 0; if c == 10 { break c; } c += 1; } + { a * 2 };
+
     fn f(_: i32) {
         todo!();
     }
     f(1 * a + { 8 * 5 });
-    f(0 + if b { 1 } else { 2 } + 3); // no error
+    f(0 + if b { 1 } else { 2 } + 3);
     const _: i32 = { 2 * 4 } + 0 + 3;
-    const _: i32 = 0 + { 1 + 2 * 3 } + 3; // no error
+    const _: i32 = 0 + { 1 + 2 * 3 } + 3;
+
+    0 + a as usize;
+    let _ = 0 + a as usize;
+    0 + { a } as usize;
+
+    2 * (0 + { a });
+    1 * ({ a } + 4);
+    1 * 1;
+}
+
+pub fn decide(a: bool, b: bool) -> u32 {
+    0 + if a { 1 } else { 2 } + if b { 3 } else { 5 }
 }
diff --git a/tests/ui/identity_op.stderr b/tests/ui/identity_op.stderr
index d8cb65839cb..1a104a20b84 100644
--- a/tests/ui/identity_op.stderr
+++ b/tests/ui/identity_op.stderr
@@ -1,202 +1,238 @@
-error: the operation is ineffective. Consider reducing it to `x`
-  --> $DIR/identity_op.rs:39:5
+error: this operation has no effect
+  --> $DIR/identity_op.rs:43:5
    |
 LL |     x + 0;
-   |     ^^^^^
+   |     ^^^^^ help: consider reducing it to: `x`
    |
    = note: `-D clippy::identity-op` implied by `-D warnings`
 
-error: the operation is ineffective. Consider reducing it to `x`
-  --> $DIR/identity_op.rs:40:5
+error: this operation has no effect
+  --> $DIR/identity_op.rs:44:5
    |
 LL |     x + (1 - 1);
-   |     ^^^^^^^^^^^
+   |     ^^^^^^^^^^^ help: consider reducing it to: `x`
 
-error: the operation is ineffective. Consider reducing it to `x`
-  --> $DIR/identity_op.rs:42:5
+error: this operation has no effect
+  --> $DIR/identity_op.rs:46:5
    |
 LL |     0 + x;
-   |     ^^^^^
+   |     ^^^^^ help: consider reducing it to: `x`
 
-error: the operation is ineffective. Consider reducing it to `x`
-  --> $DIR/identity_op.rs:45:5
+error: this operation has no effect
+  --> $DIR/identity_op.rs:49:5
    |
 LL |     x | (0);
-   |     ^^^^^^^
+   |     ^^^^^^^ help: consider reducing it to: `x`
 
-error: the operation is ineffective. Consider reducing it to `x`
-  --> $DIR/identity_op.rs:48:5
+error: this operation has no effect
+  --> $DIR/identity_op.rs:52:5
    |
 LL |     x * 1;
-   |     ^^^^^
+   |     ^^^^^ help: consider reducing it to: `x`
 
-error: the operation is ineffective. Consider reducing it to `x`
-  --> $DIR/identity_op.rs:49:5
+error: this operation has no effect
+  --> $DIR/identity_op.rs:53:5
    |
 LL |     1 * x;
-   |     ^^^^^
+   |     ^^^^^ help: consider reducing it to: `x`
 
-error: the operation is ineffective. Consider reducing it to `x`
-  --> $DIR/identity_op.rs:55:5
+error: this operation has no effect
+  --> $DIR/identity_op.rs:59:5
    |
 LL |     -1 & x;
-   |     ^^^^^^
+   |     ^^^^^^ help: consider reducing it to: `x`
 
-error: the operation is ineffective. Consider reducing it to `u`
-  --> $DIR/identity_op.rs:58:5
+error: this operation has no effect
+  --> $DIR/identity_op.rs:62:5
    |
 LL |     u & 255;
-   |     ^^^^^^^
+   |     ^^^^^^^ help: consider reducing it to: `u`
 
-error: the operation is ineffective. Consider reducing it to `42`
-  --> $DIR/identity_op.rs:61:5
+error: this operation has no effect
+  --> $DIR/identity_op.rs:65:5
    |
 LL |     42 << 0;
-   |     ^^^^^^^
+   |     ^^^^^^^ help: consider reducing it to: `42`
 
-error: the operation is ineffective. Consider reducing it to `1`
-  --> $DIR/identity_op.rs:62:5
+error: this operation has no effect
+  --> $DIR/identity_op.rs:66:5
    |
 LL |     1 >> 0;
-   |     ^^^^^^
+   |     ^^^^^^ help: consider reducing it to: `1`
 
-error: the operation is ineffective. Consider reducing it to `42`
-  --> $DIR/identity_op.rs:63:5
+error: this operation has no effect
+  --> $DIR/identity_op.rs:67:5
    |
 LL |     42 >> 0;
-   |     ^^^^^^^
+   |     ^^^^^^^ help: consider reducing it to: `42`
 
-error: the operation is ineffective. Consider reducing it to `&x`
-  --> $DIR/identity_op.rs:64:5
+error: this operation has no effect
+  --> $DIR/identity_op.rs:68:5
    |
 LL |     &x >> 0;
-   |     ^^^^^^^
+   |     ^^^^^^^ help: consider reducing it to: `&x`
 
-error: the operation is ineffective. Consider reducing it to `x`
-  --> $DIR/identity_op.rs:65:5
+error: this operation has no effect
+  --> $DIR/identity_op.rs:69:5
    |
 LL |     x >> &0;
-   |     ^^^^^^^
+   |     ^^^^^^^ help: consider reducing it to: `x`
 
-error: the operation is ineffective. Consider reducing it to `2`
-  --> $DIR/identity_op.rs:72:5
+error: this operation has no effect
+  --> $DIR/identity_op.rs:76:5
    |
 LL |     2 % 3;
-   |     ^^^^^
+   |     ^^^^^ help: consider reducing it to: `2`
 
-error: the operation is ineffective. Consider reducing it to `-2`
-  --> $DIR/identity_op.rs:73:5
+error: this operation has no effect
+  --> $DIR/identity_op.rs:77:5
    |
 LL |     -2 % 3;
-   |     ^^^^^^
+   |     ^^^^^^ help: consider reducing it to: `-2`
 
-error: the operation is ineffective. Consider reducing it to `2`
-  --> $DIR/identity_op.rs:74:5
+error: this operation has no effect
+  --> $DIR/identity_op.rs:78:5
    |
 LL |     2 % -3 + x;
-   |     ^^^^^^
+   |     ^^^^^^ help: consider reducing it to: `2`
 
-error: the operation is ineffective. Consider reducing it to `-2`
-  --> $DIR/identity_op.rs:75:5
+error: this operation has no effect
+  --> $DIR/identity_op.rs:79:5
    |
 LL |     -2 % -3 + x;
-   |     ^^^^^^^
+   |     ^^^^^^^ help: consider reducing it to: `-2`
 
-error: the operation is ineffective. Consider reducing it to `1`
-  --> $DIR/identity_op.rs:76:9
+error: this operation has no effect
+  --> $DIR/identity_op.rs:80:9
    |
 LL |     x + 1 % 3;
-   |         ^^^^^
+   |         ^^^^^ help: consider reducing it to: `1`
 
-error: the operation is ineffective. Consider reducing it to `if b { 1 } else { 2 }`
-  --> $DIR/identity_op.rs:84:5
+error: this operation has no effect
+  --> $DIR/identity_op.rs:88:5
    |
 LL |     0 + if b { 1 } else { 2 };
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider reducing it to: `(if b { 1 } else { 2 })`
 
-error: the operation is ineffective. Consider reducing it to `match a { 0 => 10, _ => 20 }`
-  --> $DIR/identity_op.rs:86:5
+error: this operation has no effect
+  --> $DIR/identity_op.rs:89:5
+   |
+LL |     0 + if b { 1 } else { 2 } + if b { 3 } else { 4 };
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider reducing it to: `(if b { 1 } else { 2 })`
+
+error: this operation has no effect
+  --> $DIR/identity_op.rs:90:5
    |
 LL |     0 + match a { 0 => 10, _ => 20 };
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider reducing it to: `(match a { 0 => 10, _ => 20 })`
 
-error: the operation is ineffective. Consider reducing it to `if b { 0 + 1 } else { 2 }`
+error: this operation has no effect
   --> $DIR/identity_op.rs:91:5
    |
-LL |     0 + if b { 0 + 1 } else { 2 };
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |     0 + match a { 0 => 10, _ => 20 } + match a { 0 => 30, _ => 40 };
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider reducing it to: `(match a { 0 => 10, _ => 20 })`
 
-error: the operation is ineffective. Consider reducing it to `1`
-  --> $DIR/identity_op.rs:91:16
+error: this operation has no effect
+  --> $DIR/identity_op.rs:92:5
    |
-LL |     0 + if b { 0 + 1 } else { 2 };
-   |                ^^^^^
+LL |     0 + if b { 1 } else { 2 } + match a { 0 => 30, _ => 40 };
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider reducing it to: `(if b { 1 } else { 2 })`
 
-error: the operation is ineffective. Consider reducing it to `match a { 0 =>  0 + 10, _ => 20 }`
-  --> $DIR/identity_op.rs:92:5
+error: this operation has no effect
+  --> $DIR/identity_op.rs:93:5
+   |
+LL |     0 + match a { 0 => 10, _ => 20 } + if b { 3 } else { 4 };
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider reducing it to: `(match a { 0 => 10, _ => 20 })`
+
+error: this operation has no effect
+  --> $DIR/identity_op.rs:94:5
+   |
+LL |     (if b { 1 } else { 2 }) + 0;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider reducing it to: `(if b { 1 } else { 2 })`
+
+error: this operation has no effect
+  --> $DIR/identity_op.rs:96:5
    |
-LL |     0 + match a { 0 =>  0 + 10, _ => 20 };
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |     0 + { a } + 3;
+   |     ^^^^^^^^^ help: consider reducing it to: `({ a })`
 
-error: the operation is ineffective. Consider reducing it to `10`
-  --> $DIR/identity_op.rs:92:25
+error: this operation has no effect
+  --> $DIR/identity_op.rs:97:5
    |
-LL |     0 + match a { 0 =>  0 + 10, _ => 20 };
-   |                         ^^^^^^
+LL |     0 + { a } * 2;
+   |     ^^^^^^^^^^^^^ help: consider reducing it to: `({ a } * 2)`
 
-error: the operation is ineffective. Consider reducing it to `1`
-  --> $DIR/identity_op.rs:93:16
+error: this operation has no effect
+  --> $DIR/identity_op.rs:98:5
    |
-LL |     0 + if b { 0 + 1 } else { 2 } + match a { 0 => 0 + 30, _ => 40 };
-   |                ^^^^^
+LL |     0 + loop { let mut c = 0; if c == 10 { break c; } c += 1; } + { a * 2 };
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider reducing it to: `(loop { let mut c = 0; if c == 10 { break c; } c += 1; })`
 
-error: the operation is ineffective. Consider reducing it to `30`
-  --> $DIR/identity_op.rs:93:52
+error: this operation has no effect
+  --> $DIR/identity_op.rs:103:7
    |
-LL |     0 + if b { 0 + 1 } else { 2 } + match a { 0 => 0 + 30, _ => 40 };
-   |                                                    ^^^^^^
+LL |     f(1 * a + { 8 * 5 });
+   |       ^^^^^ help: consider reducing it to: `a`
 
-error: the operation is ineffective. Consider reducing it to `1`
-  --> $DIR/identity_op.rs:95:20
+error: this operation has no effect
+  --> $DIR/identity_op.rs:104:7
    |
-LL |     let _ = 0 + if 0 + 1 > 0 { 1 } else { 2 } + if 0 + 1 > 0 { 3 } else { 4 };
-   |                    ^^^^^
+LL |     f(0 + if b { 1 } else { 2 } + 3);
+   |       ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider reducing it to: `if b { 1 } else { 2 }`
 
-error: the operation is ineffective. Consider reducing it to `1`
-  --> $DIR/identity_op.rs:95:52
+error: this operation has no effect
+  --> $DIR/identity_op.rs:105:20
    |
-LL |     let _ = 0 + if 0 + 1 > 0 { 1 } else { 2 } + if 0 + 1 > 0 { 3 } else { 4 };
-   |                                                    ^^^^^
+LL |     const _: i32 = { 2 * 4 } + 0 + 3;
+   |                    ^^^^^^^^^^^^^ help: consider reducing it to: `{ 2 * 4 }`
 
-error: the operation is ineffective. Consider reducing it to `1`
-  --> $DIR/identity_op.rs:96:23
+error: this operation has no effect
+  --> $DIR/identity_op.rs:106:20
    |
-LL |     let _ = 0 + match 0 + 1 { 0 => 10, _ => 20 } + match 0 + 1  { 0 => 30, _ => 40 };
-   |                       ^^^^^
+LL |     const _: i32 = 0 + { 1 + 2 * 3 } + 3;
+   |                    ^^^^^^^^^^^^^^^^^ help: consider reducing it to: `{ 1 + 2 * 3 }`
 
-error: the operation is ineffective. Consider reducing it to `1`
-  --> $DIR/identity_op.rs:96:58
+error: this operation has no effect
+  --> $DIR/identity_op.rs:108:5
    |
-LL |     let _ = 0 + match 0 + 1 { 0 => 10, _ => 20 } + match 0 + 1  { 0 => 30, _ => 40 };
-   |                                                          ^^^^^
+LL |     0 + a as usize;
+   |     ^^^^^^^^^^^^^^ help: consider reducing it to: `a as usize`
 
-error: the operation is ineffective. Consider reducing it to `0 + if b { 1 } else { 2 } + if b { 3 } else { 4 }`
-  --> $DIR/identity_op.rs:98:5
+error: this operation has no effect
+  --> $DIR/identity_op.rs:109:13
    |
-LL |     0 + if b { 1 } else { 2 } + if b { 3 } else { 4 } + 0;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |     let _ = 0 + a as usize;
+   |             ^^^^^^^^^^^^^^ help: consider reducing it to: `a as usize`
 
-error: the operation is ineffective. Consider reducing it to `a`
-  --> $DIR/identity_op.rs:106:7
+error: this operation has no effect
+  --> $DIR/identity_op.rs:110:5
    |
-LL |     f(1 * a + { 8 * 5 });
-   |       ^^^^^
+LL |     0 + { a } as usize;
+   |     ^^^^^^^^^^^^^^^^^^ help: consider reducing it to: `({ a } as usize)`
 
-error: the operation is ineffective. Consider reducing it to `{ 2 * 4 }`
-  --> $DIR/identity_op.rs:108:20
+error: this operation has no effect
+  --> $DIR/identity_op.rs:112:9
    |
-LL |     const _: i32 = { 2 * 4 } + 0 + 3;
-   |                    ^^^^^^^^^^^^^
+LL |     2 * (0 + { a });
+   |         ^^^^^^^^^^^ help: consider reducing it to: `{ a }`
+
+error: this operation has no effect
+  --> $DIR/identity_op.rs:113:5
+   |
+LL |     1 * ({ a } + 4);
+   |     ^^^^^^^^^^^^^^^ help: consider reducing it to: `(({ a } + 4))`
+
+error: this operation has no effect
+  --> $DIR/identity_op.rs:114:5
+   |
+LL |     1 * 1;
+   |     ^^^^^ help: consider reducing it to: `1`
+
+error: this operation has no effect
+  --> $DIR/identity_op.rs:118:5
+   |
+LL |     0 + if a { 1 } else { 2 } + if b { 3 } else { 5 }
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider reducing it to: `(if a { 1 } else { 2 })`
 
-error: aborting due to 33 previous errors
+error: aborting due to 39 previous errors
 
diff --git a/tests/ui/modulo_one.rs b/tests/ui/modulo_one.rs
index 678a312f66e..adff08e5d1e 100644
--- a/tests/ui/modulo_one.rs
+++ b/tests/ui/modulo_one.rs
@@ -1,5 +1,5 @@
 #![warn(clippy::modulo_one)]
-#![allow(clippy::no_effect, clippy::unnecessary_operation)]
+#![allow(clippy::no_effect, clippy::unnecessary_operation, clippy::identity_op)]
 
 static STATIC_ONE: usize = 2 - 1;
 static STATIC_NEG_ONE: i64 = 1 - 2;
diff --git a/tests/ui/modulo_one.stderr b/tests/ui/modulo_one.stderr
index 03f460897fc..04ecdef5e99 100644
--- a/tests/ui/modulo_one.stderr
+++ b/tests/ui/modulo_one.stderr
@@ -38,14 +38,6 @@ error: any number modulo -1 will panic/overflow or result in 0
 LL |     i32::MIN % (-1); // also caught by rustc
    |     ^^^^^^^^^^^^^^^
 
-error: the operation is ineffective. Consider reducing it to `1`
-  --> $DIR/modulo_one.rs:13:22
-   |
-LL |     const ONE: u32 = 1 * 1;
-   |                      ^^^^^
-   |
-   = note: `-D clippy::identity-op` implied by `-D warnings`
-
 error: any number modulo 1 will be 0
   --> $DIR/modulo_one.rs:17:5
    |
@@ -64,5 +56,5 @@ error: any number modulo -1 will panic/overflow or result in 0
 LL |     INT_MIN % NEG_ONE; // also caught by rustc
    |     ^^^^^^^^^^^^^^^^^
 
-error: aborting due to 10 previous errors
+error: aborting due to 9 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From bb01aca86f66954b80798213711e8eadc4b26902 Mon Sep 17 00:00:00 2001
From: flip1995 <philipp.krones@embecosm.com>
Date: Thu, 5 May 2022 13:32:31 +0100
Subject: HACK: Move buggy lints to nursery

Those lints are trait_duplication_in_bounds and
type_repetition_in_bounds. I don't think those can be fixed on the
Clippy side alone, but need changes in the compiler. So let's move them
to nursery to get the sync through and then fix them on the rustc side.

Also adds a regression test that has to be fixed before they can be
moved back to pedantic.
---
 clippy_lints/src/lib.register_nursery.rs    |  2 ++
 clippy_lints/src/lib.register_pedantic.rs   |  2 --
 clippy_lints/src/trait_bounds.rs            |  4 ++--
 tests/ui/trait_duplication_in_bounds.rs     |  3 +++
 tests/ui/trait_duplication_in_bounds.stderr | 10 +++++++++-
 tests/ui/type_repetition_in_bounds.rs       |  3 +++
 tests/ui/type_repetition_in_bounds.stderr   | 10 +++++++++-
 7 files changed, 28 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.register_nursery.rs b/clippy_lints/src/lib.register_nursery.rs
index 18904a94538..ec187563b3f 100644
--- a/clippy_lints/src/lib.register_nursery.rs
+++ b/clippy_lints/src/lib.register_nursery.rs
@@ -28,6 +28,8 @@ store.register_group(true, "clippy::nursery", Some("clippy_nursery"), vec![
     LintId::of(strings::STRING_LIT_AS_BYTES),
     LintId::of(suspicious_operation_groupings::SUSPICIOUS_OPERATION_GROUPINGS),
     LintId::of(trailing_empty_array::TRAILING_EMPTY_ARRAY),
+    LintId::of(trait_bounds::TRAIT_DUPLICATION_IN_BOUNDS),
+    LintId::of(trait_bounds::TYPE_REPETITION_IN_BOUNDS),
     LintId::of(transmute::TRANSMUTE_UNDEFINED_REPR),
     LintId::of(transmute::USELESS_TRANSMUTE),
     LintId::of(use_self::USE_SELF),
diff --git a/clippy_lints/src/lib.register_pedantic.rs b/clippy_lints/src/lib.register_pedantic.rs
index 63232fd4113..2ee2c6e3358 100644
--- a/clippy_lints/src/lib.register_pedantic.rs
+++ b/clippy_lints/src/lib.register_pedantic.rs
@@ -84,8 +84,6 @@ store.register_group(true, "clippy::pedantic", Some("clippy_pedantic"), vec![
     LintId::of(semicolon_if_nothing_returned::SEMICOLON_IF_NOTHING_RETURNED),
     LintId::of(stable_sort_primitive::STABLE_SORT_PRIMITIVE),
     LintId::of(strings::STRING_ADD_ASSIGN),
-    LintId::of(trait_bounds::TRAIT_DUPLICATION_IN_BOUNDS),
-    LintId::of(trait_bounds::TYPE_REPETITION_IN_BOUNDS),
     LintId::of(transmute::TRANSMUTE_PTR_TO_PTR),
     LintId::of(types::LINKEDLIST),
     LintId::of(types::OPTION_OPTION),
diff --git a/clippy_lints/src/trait_bounds.rs b/clippy_lints/src/trait_bounds.rs
index c0aca2d517c..78e388a49af 100644
--- a/clippy_lints/src/trait_bounds.rs
+++ b/clippy_lints/src/trait_bounds.rs
@@ -35,7 +35,7 @@ declare_clippy_lint! {
     /// ```
     #[clippy::version = "1.38.0"]
     pub TYPE_REPETITION_IN_BOUNDS,
-    pedantic,
+    nursery,
     "Types are repeated unnecessary in trait bounds use `+` instead of using `T: _, T: _`"
 }
 
@@ -65,7 +65,7 @@ declare_clippy_lint! {
     /// ```
     #[clippy::version = "1.47.0"]
     pub TRAIT_DUPLICATION_IN_BOUNDS,
-    pedantic,
+    nursery,
     "Check if the same trait bounds are specified twice during a function declaration"
 }
 
diff --git a/tests/ui/trait_duplication_in_bounds.rs b/tests/ui/trait_duplication_in_bounds.rs
index f5ca91143af..a21d4c5d637 100644
--- a/tests/ui/trait_duplication_in_bounds.rs
+++ b/tests/ui/trait_duplication_in_bounds.rs
@@ -95,4 +95,7 @@ trait FooIter: Iterator<Item = Foo> {
     }
 }
 
+// This should not lint
+fn impl_trait(_: impl AsRef<str>, _: impl AsRef<str>) {}
+
 fn main() {}
diff --git a/tests/ui/trait_duplication_in_bounds.stderr b/tests/ui/trait_duplication_in_bounds.stderr
index 6f8c8e47dfb..d0a4cfb8837 100644
--- a/tests/ui/trait_duplication_in_bounds.stderr
+++ b/tests/ui/trait_duplication_in_bounds.stderr
@@ -67,5 +67,13 @@ LL |         Self: Iterator<Item = Foo>,
    |
    = help: consider removing this trait bound
 
-error: aborting due to 8 previous errors
+error: this trait bound is already specified in the where clause
+  --> $DIR/trait_duplication_in_bounds.rs:99:23
+   |
+LL | fn impl_trait(_: impl AsRef<str>, _: impl AsRef<str>) {}
+   |                       ^^^^^^^^^^
+   |
+   = help: consider removing this trait bound
+
+error: aborting due to 9 previous errors
 
diff --git a/tests/ui/type_repetition_in_bounds.rs b/tests/ui/type_repetition_in_bounds.rs
index fc740ee11d6..d11432f9046 100644
--- a/tests/ui/type_repetition_in_bounds.rs
+++ b/tests/ui/type_repetition_in_bounds.rs
@@ -79,4 +79,7 @@ where
     u: U,
 }
 
+// This should not lint
+fn impl_trait(_: impl AsRef<str>, _: impl AsRef<str>) {}
+
 fn main() {}
diff --git a/tests/ui/type_repetition_in_bounds.stderr b/tests/ui/type_repetition_in_bounds.stderr
index 148c19c7d07..abc25e59496 100644
--- a/tests/ui/type_repetition_in_bounds.stderr
+++ b/tests/ui/type_repetition_in_bounds.stderr
@@ -19,5 +19,13 @@ LL |     Self: Copy + Default + Ord,
    |
    = help: consider combining the bounds: `Self: Clone + Copy + Default + Ord`
 
-error: aborting due to 2 previous errors
+error: this type has already been used as a bound predicate
+  --> $DIR/type_repetition_in_bounds.rs:83:43
+   |
+LL | fn impl_trait(_: impl AsRef<str>, _: impl AsRef<str>) {}
+   |                                           ^^^^^^^^^^
+   |
+   = help: consider combining the bounds: `impl AsRef<str>: AsRef<str> + AsRef<str>`
+
+error: aborting due to 3 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 006282964f1e741a58c72d8e12f872bf5c227af9 Mon Sep 17 00:00:00 2001
From: flip1995 <philipp.krones@embecosm.com>
Date: Thu, 5 May 2022 14:10:06 +0100
Subject: Fix ICE in EarlyAttribtues lints

---
 clippy_lints/src/attrs.rs         |  6 +++++-
 tests/ui/crashes/ice-96721.rs     | 10 ++++++++++
 tests/ui/crashes/ice-96721.stderr |  8 ++++++++
 3 files changed, 23 insertions(+), 1 deletion(-)
 create mode 100644 tests/ui/crashes/ice-96721.rs
 create mode 100644 tests/ui/crashes/ice-96721.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs
index e880876218e..8b0e11cb802 100644
--- a/clippy_lints/src/attrs.rs
+++ b/clippy_lints/src/attrs.rs
@@ -6,7 +6,7 @@ use clippy_utils::msrvs;
 use clippy_utils::source::{first_line_of_span, is_present_in_source, snippet_opt, without_block_comments};
 use clippy_utils::{extract_msrv_attr, meets_msrv};
 use if_chain::if_chain;
-use rustc_ast::{AttrKind, AttrStyle, Attribute, Lit, LitKind, MetaItemKind, NestedMetaItem};
+use rustc_ast::{AttrKind, AttrStyle, Attribute, Lit, LitKind, MacArgs, MacArgsEq, MetaItemKind, NestedMetaItem};
 use rustc_errors::Applicability;
 use rustc_hir::{
     Block, Expr, ExprKind, ImplItem, ImplItemKind, Item, ItemKind, StmtKind, TraitFn, TraitItem, TraitItemKind,
@@ -593,6 +593,10 @@ fn check_empty_line_after_outer_attr(cx: &EarlyContext<'_>, item: &rustc_ast::It
         };
 
         if attr.style == AttrStyle::Outer {
+            if let MacArgs::Eq(_, MacArgsEq::Ast(expr)) = &attr_item.args
+                && !matches!(expr.kind, rustc_ast::ExprKind::Lit(..)) {
+                return;
+            }
             if attr_item.args.inner_tokens().is_empty() || !is_present_in_source(cx, attr.span) {
                 return;
             }
diff --git a/tests/ui/crashes/ice-96721.rs b/tests/ui/crashes/ice-96721.rs
new file mode 100644
index 00000000000..4b3fb764010
--- /dev/null
+++ b/tests/ui/crashes/ice-96721.rs
@@ -0,0 +1,10 @@
+macro_rules! foo {
+    () => {
+        "bar.rs"
+    };
+}
+
+#[path = foo!()] //~ ERROR malformed `path` attribute
+mod abc {}
+
+fn main() {}
diff --git a/tests/ui/crashes/ice-96721.stderr b/tests/ui/crashes/ice-96721.stderr
new file mode 100644
index 00000000000..78c567b8e77
--- /dev/null
+++ b/tests/ui/crashes/ice-96721.stderr
@@ -0,0 +1,8 @@
+error: malformed `path` attribute input
+  --> $DIR/ice-96721.rs:7:1
+   |
+LL | #[path = foo!()] //~ ERROR malformed `path` attribute
+   | ^^^^^^^^^^^^^^^^ help: must be of the form: `#[path = "file"]`
+
+error: aborting due to previous error
+
-- 
cgit 1.4.1-3-g733a5


From 6881a5a9703ff9f700c649105599324fe182ecc5 Mon Sep 17 00:00:00 2001
From: Federico Martinez <fedemartinezdev@gmail.com>
Date: Thu, 5 May 2022 18:50:34 +0200
Subject: Added missing `### What it does`

Adds the missing line to cast-slice-different-sizes lint documentation
/closes 8781
---
 clippy_lints/src/casts/mod.rs | 1 +
 1 file changed, 1 insertion(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index b58252dcb94..9c3ebbe035b 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -413,6 +413,7 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
+    /// ### What it does
     /// Checks for `as` casts between raw pointers to slices with differently sized elements.
     ///
     /// ### Why is this bad?
-- 
cgit 1.4.1-3-g733a5


From 17bea3137b0b30b524c318e5773ff827442958b9 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Thu, 5 May 2022 13:24:38 -0400
Subject: Revert hack fixing #2475 added in commit
 034c81b76145a0514916f34713671b16f26988df. It's no longer needed.

---
 clippy_lints/src/attrs.rs | 21 +++++----------------
 1 file changed, 5 insertions(+), 16 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs
index 8b0e11cb802..30dde2f0ef0 100644
--- a/clippy_lints/src/attrs.rs
+++ b/clippy_lints/src/attrs.rs
@@ -6,7 +6,7 @@ use clippy_utils::msrvs;
 use clippy_utils::source::{first_line_of_span, is_present_in_source, snippet_opt, without_block_comments};
 use clippy_utils::{extract_msrv_attr, meets_msrv};
 use if_chain::if_chain;
-use rustc_ast::{AttrKind, AttrStyle, Attribute, Lit, LitKind, MacArgs, MacArgsEq, MetaItemKind, NestedMetaItem};
+use rustc_ast::{AttrKind, AttrStyle, Attribute, Lit, LitKind, MetaItemKind, NestedMetaItem};
 use rustc_errors::Applicability;
 use rustc_hir::{
     Block, Expr, ExprKind, ImplItem, ImplItemKind, Item, ItemKind, StmtKind, TraitFn, TraitItem, TraitItemKind,
@@ -586,21 +586,10 @@ impl EarlyLintPass for EarlyAttributes {
 
 fn check_empty_line_after_outer_attr(cx: &EarlyContext<'_>, item: &rustc_ast::Item) {
     for attr in &item.attrs {
-        let attr_item = if let AttrKind::Normal(ref attr, _) = attr.kind {
-            attr
-        } else {
-            return;
-        };
-
-        if attr.style == AttrStyle::Outer {
-            if let MacArgs::Eq(_, MacArgsEq::Ast(expr)) = &attr_item.args
-                && !matches!(expr.kind, rustc_ast::ExprKind::Lit(..)) {
-                return;
-            }
-            if attr_item.args.inner_tokens().is_empty() || !is_present_in_source(cx, attr.span) {
-                return;
-            }
-
+        if matches!(attr.kind, AttrKind::Normal(..))
+            && attr.style == AttrStyle::Outer
+            && is_present_in_source(cx, attr.span)
+        {
             let begin_of_attr_to_item = Span::new(attr.span.lo(), item.span.lo(), item.span.ctxt(), item.span.parent());
             let end_of_attr_to_item = Span::new(attr.span.hi(), item.span.lo(), item.span.ctxt(), item.span.parent());
 
-- 
cgit 1.4.1-3-g733a5


From 2aa63c95bd1590d5286bc79358397608e8d91fa4 Mon Sep 17 00:00:00 2001
From: Ariel Uy <ariel.b.uy@gmail.com>
Date: Thu, 5 May 2022 21:13:17 -0700
Subject: Create RangeBounds struct

For check_range_bounds return type.
---
 clippy_lints/src/ranges.rs | 76 +++++++++++++++++++++++++++++++---------------
 1 file changed, 52 insertions(+), 24 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/ranges.rs b/clippy_lints/src/ranges.rs
index 043299333b1..f26f3650cb3 100644
--- a/clippy_lints/src/ranges.rs
+++ b/clippy_lints/src/ranges.rs
@@ -207,7 +207,13 @@ impl<'tcx> LateLintPass<'tcx> for Ranges {
     extract_msrv_attr!(LateContext);
 }
 
-fn check_possible_range_contains(cx: &LateContext<'_>, op: BinOpKind, l: &Expr<'_>, r: &Expr<'_>, expr: &Expr<'_>) {
+fn check_possible_range_contains(
+    cx: &LateContext<'_>,
+    op: BinOpKind,
+    left: &Expr<'_>,
+    right: &Expr<'_>,
+    expr: &Expr<'_>,
+) {
     if in_constant(cx, expr.hir_id) {
         return;
     }
@@ -219,23 +225,19 @@ fn check_possible_range_contains(cx: &LateContext<'_>, op: BinOpKind, l: &Expr<'
         _ => return,
     };
     // value, name, order (higher/lower), inclusiveness
-    if let (
-        Some((lval, lexpr, lid, name_span, lval_span, lord, linc)),
-        Some((rval, _, rid, _, rval_span, rord, rinc)),
-    ) = (check_range_bounds(cx, l), check_range_bounds(cx, r))
-    {
+    if let (Some(l), Some(r)) = (check_range_bounds(cx, left), check_range_bounds(cx, right)) {
         // we only lint comparisons on the same name and with different
         // direction
-        if lid != rid || lord == rord {
+        if l.id != r.id || l.ord == r.ord {
             return;
         }
-        let ord = Constant::partial_cmp(cx.tcx, cx.typeck_results().expr_ty(lexpr), &lval, &rval);
-        if combine_and && ord == Some(rord) {
+        let ord = Constant::partial_cmp(cx.tcx, cx.typeck_results().expr_ty(l.expr), &l.val, &r.val);
+        if combine_and && ord == Some(r.ord) {
             // order lower bound and upper bound
-            let (l_span, u_span, l_inc, u_inc) = if rord == Ordering::Less {
-                (lval_span, rval_span, linc, rinc)
+            let (l_span, u_span, l_inc, u_inc) = if r.ord == Ordering::Less {
+                (l.val_span, r.val_span, l.inc, r.inc)
             } else {
-                (rval_span, lval_span, rinc, linc)
+                (r.val_span, l.val_span, r.inc, l.inc)
             };
             // we only lint inclusive lower bounds
             if !l_inc {
@@ -247,7 +249,7 @@ fn check_possible_range_contains(cx: &LateContext<'_>, op: BinOpKind, l: &Expr<'
                 ("Range", "..")
             };
             let mut applicability = Applicability::MachineApplicable;
-            let name = snippet_with_applicability(cx, name_span, "_", &mut applicability);
+            let name = snippet_with_applicability(cx, l.name_span, "_", &mut applicability);
             let lo = snippet_with_applicability(cx, l_span, "_", &mut applicability);
             let hi = snippet_with_applicability(cx, u_span, "_", &mut applicability);
             let space = if lo.ends_with('.') { " " } else { "" };
@@ -260,13 +262,13 @@ fn check_possible_range_contains(cx: &LateContext<'_>, op: BinOpKind, l: &Expr<'
                 format!("({}{}{}{}).contains(&{})", lo, space, range_op, hi, name),
                 applicability,
             );
-        } else if !combine_and && ord == Some(lord) {
+        } else if !combine_and && ord == Some(l.ord) {
             // `!_.contains(_)`
             // order lower bound and upper bound
-            let (l_span, u_span, l_inc, u_inc) = if lord == Ordering::Less {
-                (lval_span, rval_span, linc, rinc)
+            let (l_span, u_span, l_inc, u_inc) = if l.ord == Ordering::Less {
+                (l.val_span, r.val_span, l.inc, r.inc)
             } else {
-                (rval_span, lval_span, rinc, linc)
+                (r.val_span, l.val_span, r.inc, l.inc)
             };
             if l_inc {
                 return;
@@ -277,7 +279,7 @@ fn check_possible_range_contains(cx: &LateContext<'_>, op: BinOpKind, l: &Expr<'
                 ("RangeInclusive", "..=")
             };
             let mut applicability = Applicability::MachineApplicable;
-            let name = snippet_with_applicability(cx, name_span, "_", &mut applicability);
+            let name = snippet_with_applicability(cx, l.name_span, "_", &mut applicability);
             let lo = snippet_with_applicability(cx, l_span, "_", &mut applicability);
             let hi = snippet_with_applicability(cx, u_span, "_", &mut applicability);
             let space = if lo.ends_with('.') { " " } else { "" };
@@ -294,10 +296,20 @@ fn check_possible_range_contains(cx: &LateContext<'_>, op: BinOpKind, l: &Expr<'
     }
 }
 
-fn check_range_bounds<'a>(
-    cx: &'a LateContext<'_>,
-    ex: &'a Expr<'_>,
-) -> Option<(Constant, &'a Expr<'a>, HirId, Span, Span, Ordering, bool)> {
+struct RangeBounds<'a> {
+    val: Constant,
+    expr: &'a Expr<'a>,
+    id: HirId,
+    name_span: Span,
+    val_span: Span,
+    ord: Ordering,
+    inc: bool,
+}
+
+// Takes a binary expression such as x <= 2 as input
+// Breaks apart into various pieces, such as the value of the number,
+// hir id of the variable, and direction/inclusiveness of the operator
+fn check_range_bounds<'a>(cx: &'a LateContext<'_>, ex: &'a Expr<'_>) -> Option<RangeBounds<'a>> {
     if let ExprKind::Binary(ref op, l, r) = ex.kind {
         let (inclusive, ordering) = match op.node {
             BinOpKind::Gt => (false, Ordering::Greater),
@@ -308,11 +320,27 @@ fn check_range_bounds<'a>(
         };
         if let Some(id) = path_to_local(l) {
             if let Some((c, _)) = constant(cx, cx.typeck_results(), r) {
-                return Some((c, r, id, l.span, r.span, ordering, inclusive));
+                return Some(RangeBounds {
+                    val: c,
+                    expr: r,
+                    id,
+                    name_span: l.span,
+                    val_span: r.span,
+                    ord: ordering,
+                    inc: inclusive,
+                });
             }
         } else if let Some(id) = path_to_local(r) {
             if let Some((c, _)) = constant(cx, cx.typeck_results(), l) {
-                return Some((c, l, id, r.span, l.span, ordering.reverse(), inclusive));
+                return Some(RangeBounds {
+                    val: c,
+                    expr: l,
+                    id,
+                    name_span: r.span,
+                    val_span: l.span,
+                    ord: ordering.reverse(),
+                    inc: inclusive,
+                });
             }
         }
     }
-- 
cgit 1.4.1-3-g733a5


From 91a822c16228c57bf57961271ecb2d0d28112fa4 Mon Sep 17 00:00:00 2001
From: "Samuel E. Moelius III" <sam@moeli.us>
Date: Thu, 5 May 2022 21:39:54 -0400
Subject: Address `unnecessary_to_owned` false positive

---
 clippy_lints/src/methods/unnecessary_to_owned.rs | 38 +++++++++------
 tests/ui/recursive_format_impl.stderr            | 11 +----
 tests/ui/unnecessary_to_owned.fixed              | 61 +++++++++++++++++++++++-
 tests/ui/unnecessary_to_owned.rs                 | 61 +++++++++++++++++++++++-
 tests/ui/unnecessary_to_owned.stderr             | 34 ++++++-------
 5 files changed, 160 insertions(+), 45 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/unnecessary_to_owned.rs b/clippy_lints/src/methods/unnecessary_to_owned.rs
index 02b882e8b55..1f426979c4a 100644
--- a/clippy_lints/src/methods/unnecessary_to_owned.rs
+++ b/clippy_lints/src/methods/unnecessary_to_owned.rs
@@ -65,13 +65,12 @@ fn check_addr_of_expr(
         if let Some(parent) = get_parent_expr(cx, expr);
         if let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Not, _) = parent.kind;
         let adjustments = cx.typeck_results().expr_adjustments(parent).iter().collect::<Vec<_>>();
-        if let Some(target_ty) = match adjustments[..]
-        {
+        if let
             // For matching uses of `Cow::from`
             [
                 Adjustment {
                     kind: Adjust::Deref(None),
-                    ..
+                    target: referent_ty,
                 },
                 Adjustment {
                     kind: Adjust::Borrow(_),
@@ -82,7 +81,7 @@ fn check_addr_of_expr(
             | [
                 Adjustment {
                     kind: Adjust::Deref(None),
-                    ..
+                    target: referent_ty,
                 },
                 Adjustment {
                     kind: Adjust::Borrow(_),
@@ -97,7 +96,7 @@ fn check_addr_of_expr(
             | [
                 Adjustment {
                     kind: Adjust::Deref(None),
-                    ..
+                    target: referent_ty,
                 },
                 Adjustment {
                     kind: Adjust::Deref(Some(OverloadedDeref { .. })),
@@ -107,17 +106,24 @@ fn check_addr_of_expr(
                     kind: Adjust::Borrow(_),
                     target: target_ty,
                 },
-            ] => Some(target_ty),
-            _ => None,
-        };
+            ] = adjustments[..];
         let receiver_ty = cx.typeck_results().expr_ty(receiver);
-        // Only flag cases where the receiver is copyable or the method is `Cow::into_owned`. This
-        // restriction is to ensure there is not overlap between `redundant_clone` and this lint.
-        if is_copy(cx, receiver_ty) || is_cow_into_owned(cx, method_name, method_def_id);
+        let (target_ty, n_target_refs) = peel_mid_ty_refs(*target_ty);
+        let (receiver_ty, n_receiver_refs) = peel_mid_ty_refs(receiver_ty);
+        // Only flag cases satisfying at least one of the following three conditions:
+        // * the referent and receiver types are distinct
+        // * the referent/receiver type is a copyable array
+        // * the method is `Cow::into_owned`
+        // This restriction is to ensure there is no overlap between `redundant_clone` and this
+        // lint. It also avoids the following false positive:
+        //  https://github.com/rust-lang/rust-clippy/issues/8759
+        //   Arrays are a bit of a corner case. Non-copyable arrays are handled by
+        // `redundant_clone`, but copyable arrays are not.
+        if *referent_ty != receiver_ty
+            || (matches!(referent_ty.kind(), ty::Array(..)) && is_copy(cx, *referent_ty))
+            || is_cow_into_owned(cx, method_name, method_def_id);
         if let Some(receiver_snippet) = snippet_opt(cx, receiver.span);
         then {
-            let (target_ty, n_target_refs) = peel_mid_ty_refs(*target_ty);
-            let (receiver_ty, n_receiver_refs) = peel_mid_ty_refs(receiver_ty);
             if receiver_ty == target_ty && n_target_refs >= n_receiver_refs {
                 span_lint_and_sugg(
                     cx,
@@ -207,7 +213,11 @@ fn check_into_iter_call_arg(
             if unnecessary_iter_cloned::check_for_loop_iter(cx, parent, method_name, receiver, true) {
                 return true;
             }
-            let cloned_or_copied = if is_copy(cx, item_ty) && meets_msrv(msrv, &msrvs::ITERATOR_COPIED) { "copied" } else { "cloned" };
+            let cloned_or_copied = if is_copy(cx, item_ty) && meets_msrv(msrv, &msrvs::ITERATOR_COPIED) {
+                "copied"
+            } else {
+                "cloned"
+            };
             // The next suggestion may be incorrect because the removal of the `to_owned`-like
             // function could cause the iterator to hold a reference to a resource that is used
             // mutably. See https://github.com/rust-lang/rust-clippy/issues/8148.
diff --git a/tests/ui/recursive_format_impl.stderr b/tests/ui/recursive_format_impl.stderr
index 6171696ed69..1a717ac92d8 100644
--- a/tests/ui/recursive_format_impl.stderr
+++ b/tests/ui/recursive_format_impl.stderr
@@ -6,15 +6,6 @@ LL |         write!(f, "{}", self.to_string())
    |
    = note: `-D clippy::recursive-format-impl` implied by `-D warnings`
 
-error: unnecessary use of `to_string`
-  --> $DIR/recursive_format_impl.rs:61:50
-   |
-LL |             Self::E(string) => write!(f, "E {}", string.to_string()),
-   |                                                  ^^^^^^^^^^^^^^^^^^
-   |
-   = note: `-D clippy::unnecessary-to-owned` implied by `-D warnings`
-   = note: this error originates in the macro `$crate::format_args` (in Nightly builds, run with -Z macro-backtrace for more info)
-
 error: using `self` as `Display` in `impl Display` will cause infinite recursion
   --> $DIR/recursive_format_impl.rs:73:9
    |
@@ -87,5 +78,5 @@ LL |         write!(f, "{}", &&**&&*self)
    |
    = note: this error originates in the macro `write` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to 11 previous errors
+error: aborting due to 10 previous errors
 
diff --git a/tests/ui/unnecessary_to_owned.fixed b/tests/ui/unnecessary_to_owned.fixed
index 7455e22d49b..f4f76cd3dd4 100644
--- a/tests/ui/unnecessary_to_owned.fixed
+++ b/tests/ui/unnecessary_to_owned.fixed
@@ -78,10 +78,10 @@ fn main() {
     require_slice(array.as_ref());
     require_slice(array_ref.as_ref());
     require_slice(slice);
-    require_slice(x_ref);
+    require_slice(&x_ref.to_owned()); // No longer flagged because of #8759.
 
     require_x(&Cow::<X>::Owned(x.clone()));
-    require_x(x_ref);
+    require_x(&x_ref.to_owned()); // No longer flagged because of #8759.
 
     require_deref_c_str(c_str);
     require_deref_os_str(os_str);
@@ -152,6 +152,7 @@ fn main() {
     require_os_str(&OsString::from("x"));
     require_path(&std::path::PathBuf::from("x"));
     require_str(&String::from("x"));
+    require_slice(&[String::from("x")]);
 }
 
 fn require_c_str(_: &CStr) {}
@@ -272,3 +273,59 @@ mod issue_8507 {
         Box::new(build(y))
     }
 }
+
+// https://github.com/rust-lang/rust-clippy/issues/8759
+mod issue_8759 {
+    #![allow(dead_code)]
+
+    #[derive(Default)]
+    struct View {}
+
+    impl std::borrow::ToOwned for View {
+        type Owned = View;
+        fn to_owned(&self) -> Self::Owned {
+            View {}
+        }
+    }
+
+    #[derive(Default)]
+    struct RenderWindow {
+        default_view: View,
+    }
+
+    impl RenderWindow {
+        fn default_view(&self) -> &View {
+            &self.default_view
+        }
+        fn set_view(&mut self, _view: &View) {}
+    }
+
+    fn main() {
+        let mut rw = RenderWindow::default();
+        rw.set_view(&rw.default_view().to_owned());
+    }
+}
+
+mod issue_8759_variant {
+    #![allow(dead_code)]
+
+    #[derive(Clone, Default)]
+    struct View {}
+
+    #[derive(Default)]
+    struct RenderWindow {
+        default_view: View,
+    }
+
+    impl RenderWindow {
+        fn default_view(&self) -> &View {
+            &self.default_view
+        }
+        fn set_view(&mut self, _view: &View) {}
+    }
+
+    fn main() {
+        let mut rw = RenderWindow::default();
+        rw.set_view(&rw.default_view().to_owned());
+    }
+}
diff --git a/tests/ui/unnecessary_to_owned.rs b/tests/ui/unnecessary_to_owned.rs
index bbcd00ad220..fe09a489ab0 100644
--- a/tests/ui/unnecessary_to_owned.rs
+++ b/tests/ui/unnecessary_to_owned.rs
@@ -78,10 +78,10 @@ fn main() {
     require_slice(&array.to_owned());
     require_slice(&array_ref.to_owned());
     require_slice(&slice.to_owned());
-    require_slice(&x_ref.to_owned());
+    require_slice(&x_ref.to_owned()); // No longer flagged because of #8759.
 
     require_x(&Cow::<X>::Owned(x.clone()).into_owned());
-    require_x(&x_ref.to_owned());
+    require_x(&x_ref.to_owned()); // No longer flagged because of #8759.
 
     require_deref_c_str(c_str.to_owned());
     require_deref_os_str(os_str.to_owned());
@@ -152,6 +152,7 @@ fn main() {
     require_os_str(&OsString::from("x").to_os_string());
     require_path(&std::path::PathBuf::from("x").to_path_buf());
     require_str(&String::from("x").to_string());
+    require_slice(&[String::from("x")].to_owned());
 }
 
 fn require_c_str(_: &CStr) {}
@@ -272,3 +273,59 @@ mod issue_8507 {
         Box::new(build(y.to_string()))
     }
 }
+
+// https://github.com/rust-lang/rust-clippy/issues/8759
+mod issue_8759 {
+    #![allow(dead_code)]
+
+    #[derive(Default)]
+    struct View {}
+
+    impl std::borrow::ToOwned for View {
+        type Owned = View;
+        fn to_owned(&self) -> Self::Owned {
+            View {}
+        }
+    }
+
+    #[derive(Default)]
+    struct RenderWindow {
+        default_view: View,
+    }
+
+    impl RenderWindow {
+        fn default_view(&self) -> &View {
+            &self.default_view
+        }
+        fn set_view(&mut self, _view: &View) {}
+    }
+
+    fn main() {
+        let mut rw = RenderWindow::default();
+        rw.set_view(&rw.default_view().to_owned());
+    }
+}
+
+mod issue_8759_variant {
+    #![allow(dead_code)]
+
+    #[derive(Clone, Default)]
+    struct View {}
+
+    #[derive(Default)]
+    struct RenderWindow {
+        default_view: View,
+    }
+
+    impl RenderWindow {
+        fn default_view(&self) -> &View {
+            &self.default_view
+        }
+        fn set_view(&mut self, _view: &View) {}
+    }
+
+    fn main() {
+        let mut rw = RenderWindow::default();
+        rw.set_view(&rw.default_view().to_owned());
+    }
+}
diff --git a/tests/ui/unnecessary_to_owned.stderr b/tests/ui/unnecessary_to_owned.stderr
index f9713559e4f..af7e7b41fb0 100644
--- a/tests/ui/unnecessary_to_owned.stderr
+++ b/tests/ui/unnecessary_to_owned.stderr
@@ -47,6 +47,18 @@ note: this value is dropped without further use
 LL |     require_str(&String::from("x").to_string());
    |                  ^^^^^^^^^^^^^^^^^
 
+error: redundant clone
+  --> $DIR/unnecessary_to_owned.rs:155:39
+   |
+LL |     require_slice(&[String::from("x")].to_owned());
+   |                                       ^^^^^^^^^^^ help: remove this
+   |
+note: this value is dropped without further use
+  --> $DIR/unnecessary_to_owned.rs:155:20
+   |
+LL |     require_slice(&[String::from("x")].to_owned());
+   |                    ^^^^^^^^^^^^^^^^^^^
+
 error: unnecessary use of `into_owned`
   --> $DIR/unnecessary_to_owned.rs:60:36
    |
@@ -151,24 +163,12 @@ error: unnecessary use of `to_owned`
 LL |     require_slice(&slice.to_owned());
    |                   ^^^^^^^^^^^^^^^^^ help: use: `slice`
 
-error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:81:19
-   |
-LL |     require_slice(&x_ref.to_owned());
-   |                   ^^^^^^^^^^^^^^^^^ help: use: `x_ref`
-
 error: unnecessary use of `into_owned`
   --> $DIR/unnecessary_to_owned.rs:83:42
    |
 LL |     require_x(&Cow::<X>::Owned(x.clone()).into_owned());
    |                                          ^^^^^^^^^^^^^ help: remove this
 
-error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:84:15
-   |
-LL |     require_x(&x_ref.to_owned());
-   |               ^^^^^^^^^^^^^^^^^ help: use: `x_ref`
-
 error: unnecessary use of `to_owned`
   --> $DIR/unnecessary_to_owned.rs:86:25
    |
@@ -476,7 +476,7 @@ LL |     let _ = IntoIterator::into_iter([std::path::PathBuf::new()][..].to_owne
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `[std::path::PathBuf::new()][..].iter().cloned()`
 
 error: unnecessary use of `to_vec`
-  --> $DIR/unnecessary_to_owned.rs:197:14
+  --> $DIR/unnecessary_to_owned.rs:198:14
    |
 LL |     for t in file_types.to_vec() {
    |              ^^^^^^^^^^^^^^^^^^^
@@ -492,22 +492,22 @@ LL +         let path = match get_file_path(t) {
    | 
 
 error: unnecessary use of `to_vec`
-  --> $DIR/unnecessary_to_owned.rs:220:14
+  --> $DIR/unnecessary_to_owned.rs:221:14
    |
 LL |     let _ = &["x"][..].to_vec().into_iter();
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `["x"][..].iter().cloned()`
 
 error: unnecessary use of `to_vec`
-  --> $DIR/unnecessary_to_owned.rs:225:14
+  --> $DIR/unnecessary_to_owned.rs:226:14
    |
 LL |     let _ = &["x"][..].to_vec().into_iter();
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `["x"][..].iter().copied()`
 
 error: unnecessary use of `to_string`
-  --> $DIR/unnecessary_to_owned.rs:272:24
+  --> $DIR/unnecessary_to_owned.rs:273:24
    |
 LL |         Box::new(build(y.to_string()))
    |                        ^^^^^^^^^^^^^ help: use: `y`
 
-error: aborting due to 79 previous errors
+error: aborting due to 78 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 5d0ca74c753d72bf5b6dcfa532001cdd07aa0365 Mon Sep 17 00:00:00 2001
From: tamaron <tamaron1203@gmail.com>
Date: Fri, 29 Apr 2022 18:34:58 +0900
Subject: Resolved conflicts

---
 clippy_lints/src/undocumented_unsafe_blocks.rs |  64 +++++++++++++++-
 tests/ui/undocumented_unsafe_blocks.rs         | 101 ++++++++++++++++++++++++-
 tests/ui/undocumented_unsafe_blocks.stderr     |  50 +++++++++++-
 3 files changed, 212 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/undocumented_unsafe_blocks.rs b/clippy_lints/src/undocumented_unsafe_blocks.rs
index 465d8a914fb..63652dba398 100644
--- a/clippy_lints/src/undocumented_unsafe_blocks.rs
+++ b/clippy_lints/src/undocumented_unsafe_blocks.rs
@@ -2,12 +2,14 @@ use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::is_lint_allowed;
 use clippy_utils::source::walk_span_to_context;
 use rustc_data_structures::sync::Lrc;
+use rustc_hir as hir;
 use rustc_hir::{Block, BlockCheckMode, UnsafeSource};
 use rustc_lexer::{tokenize, TokenKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::{BytePos, Pos, SyntaxContext};
+use rustc_span::{BytePos, Pos, Span, SyntaxContext};
+use std::rc::Rc;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -86,6 +88,66 @@ impl LateLintPass<'_> for UndocumentedUnsafeBlocks {
             );
         }
     }
+
+    fn check_mod(&mut self, cx: &LateContext<'_>, module: &'_ hir::Mod<'_>, mod_span: Span, hir_id: hir::HirId) {
+        let source_map = cx.sess().source_map();
+        let mut item_and_spans: Vec<(&hir::Item<'_>, Span)> = Vec::new(); // (start, end, item)
+
+        // Collect all items and their spans
+        for item_id in module.item_ids {
+            let item = cx.tcx.hir().item(*item_id);
+            item_and_spans.push((item, item.span));
+        }
+        // Sort items by start position
+        item_and_spans.sort_by_key(|e| e.1.lo());
+
+        for (idx, (item, item_span)) in item_and_spans.iter().enumerate() {
+            if let hir::ItemKind::Impl(imple) = &item.kind
+                && imple.unsafety == hir::Unsafety::Unsafe
+                && !item_span.from_expansion()
+                && !is_lint_allowed(cx, UNDOCUMENTED_UNSAFE_BLOCKS, hir_id)
+            {
+                // Checks if the lines immediately preceding the impl contain a safety comment.
+                let impl_has_safety_comment = {
+                    let span_before_impl = if idx == 0 {
+                        // mod A { /* comment */ unsafe impl T {} }
+                        // ^--------------------^
+                        todo!();
+                        //mod_span.until(module.spans)
+                    } else {
+                        // unsafe impl S {} /* comment */ unsafe impl T {}
+                        //                 ^-------------^
+                        item_and_spans[idx - 1].1.between(*item_span)
+                    };
+
+                    if let Ok(start) = source_map.lookup_line(span_before_impl.lo())
+                        && let Ok(end) = source_map.lookup_line(span_before_impl.hi())
+                        && let Some(src) = start.sf.src.as_deref()
+                    {
+                        start.line < end.line && text_has_safety_comment(
+                            src,
+                            &start.sf.lines[start.line + 1 ..= end.line],
+                            start.sf.start_pos.to_usize()
+                        )
+                    } else {
+                        // Problem getting source text. Pretend a comment was found.
+                        true
+                    }
+                };
+
+                if !impl_has_safety_comment {
+                    span_lint_and_help(
+                        cx,
+                        UNDOCUMENTED_UNSAFE_BLOCKS,
+                        *item_span,
+                        "unsafe impl missing a safety comment",
+                        None,
+                        "consider adding a safety comment on the preceding line",
+                    );
+                }
+            }
+        }
+    }
 }
 
 fn is_unsafe_from_proc_macro(cx: &LateContext<'_>, block: &Block<'_>) -> bool {
diff --git a/tests/ui/undocumented_unsafe_blocks.rs b/tests/ui/undocumented_unsafe_blocks.rs
index 7be15b0b2dd..3044a92cbd0 100644
--- a/tests/ui/undocumented_unsafe_blocks.rs
+++ b/tests/ui/undocumented_unsafe_blocks.rs
@@ -1,7 +1,7 @@
 // aux-build:proc_macro_unsafe.rs
 
 #![warn(clippy::undocumented_unsafe_blocks)]
-#![allow(clippy::let_unit_value)]
+#![allow(clippy::let_unit_value, clippy::missing_safety_doc)]
 
 extern crate proc_macro_unsafe;
 
@@ -334,4 +334,103 @@ pub fn print_binary_tree() {
     println!("{}", unsafe { String::from_utf8_unchecked(vec![]) });
 }
 
+mod unsafe_impl_smoke_test {
+    unsafe trait A {}
+
+    // error: no safety comment
+    unsafe impl A for () {}
+
+    // Safety: ok
+    unsafe impl A for (i32) {}
+
+    mod sub_mod {
+        // error: also works for the first item
+        unsafe impl B for (u32) {}
+        unsafe trait B {}
+    }
+
+    #[rustfmt::skip]
+    mod sub_mod2 {
+        // 
+        // SAFETY: ok
+        // 
+
+        unsafe impl B for (u32) {}
+        unsafe trait B {}
+    }
+}
+
+mod unsafe_impl_from_macro {
+    unsafe trait T {}
+
+    macro_rules! unsafe_impl {
+        ($t:ty) => {
+            unsafe impl T for $t {}
+        };
+    }
+    // ok: from macro expanision
+    unsafe_impl!(());
+    // ok: from macro expansion
+    unsafe_impl!(i32);
+}
+
+#[rustfmt::skip]
+mod unsafe_impl_valid_comment {
+    unsafe trait SaFety {}
+    // SaFety:
+    unsafe impl SaFety for () {}
+
+    unsafe trait MultiLineComment {}
+    // The following impl is safe
+    // ...
+    // Safety: reason
+    unsafe impl MultiLineComment for () {}
+
+    unsafe trait NoAscii {}
+    // 安全 SAFETY: 以下のコードは安全です
+    unsafe impl NoAscii for () {}
+
+    unsafe trait InlineAndPrecedingComment {}
+    // SAFETY:
+    /* comment */ unsafe impl InlineAndPrecedingComment for () {}
+
+    unsafe trait BuriedSafety {}
+    // Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor
+    // incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation
+    // ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in
+    // reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint
+    // occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est
+    // laborum. Safety:
+    // Tellus elementum sagittis vitae et leo duis ut diam quam. Sit amet nulla facilisi
+    // morbi tempus iaculis urna. Amet luctus venenatis lectus magna. At quis risus sed vulputate odio
+    // ut. Luctus venenatis lectus magna fringilla urna. Tortor id aliquet lectus proin nibh nisl
+    // condimentum id venenatis. Vulputate dignissim suspendisse in est ante in nibh mauris cursus.
+    unsafe impl BuriedSafety for () {}
+
+    unsafe trait MultiLineBlockComment {}
+    /* This is a description
+     * Safety: */
+    unsafe impl MultiLineBlockComment for () {}
+}
+
+#[rustfmt::skip]
+mod unsafe_impl_invalid_comment {
+    unsafe trait NoComment {}
+
+    unsafe impl NoComment for () {}
+
+    unsafe trait InlineComment {}
+
+    /* SAFETY: */ unsafe impl InlineComment for () {}
+
+    unsafe trait TrailingComment {}
+
+    unsafe impl TrailingComment for () {} // SAFETY:
+
+    unsafe trait Interference {}
+    // SAFETY:
+    const BIG_NUMBER: i32 = 1000000;
+    unsafe impl Interference for () {}
+}
+
 fn main() {}
diff --git a/tests/ui/undocumented_unsafe_blocks.stderr b/tests/ui/undocumented_unsafe_blocks.stderr
index 87d445bd7b8..80d68a03808 100644
--- a/tests/ui/undocumented_unsafe_blocks.stderr
+++ b/tests/ui/undocumented_unsafe_blocks.stderr
@@ -147,5 +147,53 @@ LL |     println!("{}", unsafe { String::from_utf8_unchecked(vec![]) });
    |
    = help: consider adding a safety comment on the preceding line
 
-error: aborting due to 18 previous errors
+error: unsafe impl missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:341:5
+   |
+LL |     unsafe impl A for () {}
+   |     ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: unsafe impl missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:348:9
+   |
+LL |         unsafe impl B for (u32) {}
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: unsafe impl missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:420:5
+   |
+LL |     unsafe impl NoComment for () {}
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: unsafe impl missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:424:19
+   |
+LL |     /* SAFETY: */ unsafe impl InlineComment for () {}
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: unsafe impl missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:428:5
+   |
+LL |     unsafe impl TrailingComment for () {} // SAFETY:
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: unsafe impl missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:433:5
+   |
+LL |     unsafe impl Interference for () {}
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: aborting due to 24 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 8d8588941ea4dfcbd67b4682ef40d7b409df63e6 Mon Sep 17 00:00:00 2001
From: tamaron <tamaron1203@gmail.com>
Date: Sat, 7 May 2022 18:18:57 +0900
Subject: fix

---
 clippy_lints/src/undocumented_unsafe_blocks.rs | 216 +++++++++++++++----------
 tests/ui/undocumented_unsafe_blocks.rs         |  17 +-
 tests/ui/undocumented_unsafe_blocks.stderr     |  22 ++-
 3 files changed, 161 insertions(+), 94 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/undocumented_unsafe_blocks.rs b/clippy_lints/src/undocumented_unsafe_blocks.rs
index 63652dba398..09efb12f5da 100644
--- a/clippy_lints/src/undocumented_unsafe_blocks.rs
+++ b/clippy_lints/src/undocumented_unsafe_blocks.rs
@@ -1,19 +1,18 @@
 use clippy_utils::diagnostics::span_lint_and_help;
-use clippy_utils::is_lint_allowed;
 use clippy_utils::source::walk_span_to_context;
+use clippy_utils::{get_parent_node, is_lint_allowed};
 use rustc_data_structures::sync::Lrc;
 use rustc_hir as hir;
-use rustc_hir::{Block, BlockCheckMode, UnsafeSource};
+use rustc_hir::{Block, BlockCheckMode, ItemKind, Node, UnsafeSource};
 use rustc_lexer::{tokenize, TokenKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::{BytePos, Pos, Span, SyntaxContext};
-use std::rc::Rc;
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for `unsafe` blocks without a `// SAFETY: ` comment
+    /// Checks for `unsafe` blocks and impls without a `// SAFETY: ` comment
     /// explaining why the unsafe operations performed inside
     /// the block are safe.
     ///
@@ -36,7 +35,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// ### Why is this bad?
-    /// Undocumented unsafe blocks can make it difficult to
+    /// Undocumented unsafe blocks and impls can make it difficult to
     /// read and maintain code, as well as uncover unsoundness
     /// and bugs.
     ///
@@ -68,7 +67,7 @@ impl LateLintPass<'_> for UndocumentedUnsafeBlocks {
         if block.rules == BlockCheckMode::UnsafeBlock(UnsafeSource::UserProvided)
             && !in_external_macro(cx.tcx.sess, block.span)
             && !is_lint_allowed(cx, UNDOCUMENTED_UNSAFE_BLOCKS, block.hir_id)
-            && !is_unsafe_from_proc_macro(cx, block)
+            && !is_unsafe_from_proc_macro(cx, block.span)
             && !block_has_safety_comment(cx, block)
         {
             let source_map = cx.tcx.sess.source_map();
@@ -89,70 +88,36 @@ impl LateLintPass<'_> for UndocumentedUnsafeBlocks {
         }
     }
 
-    fn check_mod(&mut self, cx: &LateContext<'_>, module: &'_ hir::Mod<'_>, mod_span: Span, hir_id: hir::HirId) {
-        let source_map = cx.sess().source_map();
-        let mut item_and_spans: Vec<(&hir::Item<'_>, Span)> = Vec::new(); // (start, end, item)
-
-        // Collect all items and their spans
-        for item_id in module.item_ids {
-            let item = cx.tcx.hir().item(*item_id);
-            item_and_spans.push((item, item.span));
-        }
-        // Sort items by start position
-        item_and_spans.sort_by_key(|e| e.1.lo());
-
-        for (idx, (item, item_span)) in item_and_spans.iter().enumerate() {
-            if let hir::ItemKind::Impl(imple) = &item.kind
-                && imple.unsafety == hir::Unsafety::Unsafe
-                && !item_span.from_expansion()
-                && !is_lint_allowed(cx, UNDOCUMENTED_UNSAFE_BLOCKS, hir_id)
-            {
-                // Checks if the lines immediately preceding the impl contain a safety comment.
-                let impl_has_safety_comment = {
-                    let span_before_impl = if idx == 0 {
-                        // mod A { /* comment */ unsafe impl T {} }
-                        // ^--------------------^
-                        todo!();
-                        //mod_span.until(module.spans)
-                    } else {
-                        // unsafe impl S {} /* comment */ unsafe impl T {}
-                        //                 ^-------------^
-                        item_and_spans[idx - 1].1.between(*item_span)
-                    };
-
-                    if let Ok(start) = source_map.lookup_line(span_before_impl.lo())
-                        && let Ok(end) = source_map.lookup_line(span_before_impl.hi())
-                        && let Some(src) = start.sf.src.as_deref()
-                    {
-                        start.line < end.line && text_has_safety_comment(
-                            src,
-                            &start.sf.lines[start.line + 1 ..= end.line],
-                            start.sf.start_pos.to_usize()
-                        )
-                    } else {
-                        // Problem getting source text. Pretend a comment was found.
-                        true
-                    }
-                };
+    fn check_item(&mut self, cx: &LateContext<'_>, item: &hir::Item<'_>) {
+        if let hir::ItemKind::Impl(imple) = item.kind
+            && imple.unsafety == hir::Unsafety::Unsafe
+            && !in_external_macro(cx.tcx.sess, item.span)
+            && !is_lint_allowed(cx, UNDOCUMENTED_UNSAFE_BLOCKS, item.hir_id())
+            && !is_unsafe_from_proc_macro(cx, item.span)
+            && !item_has_safety_comment(cx, item)
+        {
+            let source_map = cx.tcx.sess.source_map();
+            let span = if source_map.is_multiline(item.span) {
+                source_map.span_until_char(item.span, '\n')
+            } else {
+                item.span
+            };
 
-                if !impl_has_safety_comment {
-                    span_lint_and_help(
-                        cx,
-                        UNDOCUMENTED_UNSAFE_BLOCKS,
-                        *item_span,
-                        "unsafe impl missing a safety comment",
-                        None,
-                        "consider adding a safety comment on the preceding line",
-                    );
-                }
-            }
+            span_lint_and_help(
+                cx,
+                UNDOCUMENTED_UNSAFE_BLOCKS,
+                span,
+                "unsafe impl missing a safety comment",
+                None,
+                "consider adding a safety comment on the preceding line",
+            );
         }
     }
 }
 
-fn is_unsafe_from_proc_macro(cx: &LateContext<'_>, block: &Block<'_>) -> bool {
+fn is_unsafe_from_proc_macro(cx: &LateContext<'_>, span: Span) -> bool {
     let source_map = cx.sess().source_map();
-    let file_pos = source_map.lookup_byte_offset(block.span.lo());
+    let file_pos = source_map.lookup_byte_offset(span.lo());
     file_pos
         .sf
         .src
@@ -162,7 +127,7 @@ fn is_unsafe_from_proc_macro(cx: &LateContext<'_>, block: &Block<'_>) -> bool {
 }
 
 /// Checks if the lines immediately preceding the block contain a safety comment.
-fn block_has_safety_comment(cx: &LateContext<'_>, block: &Block<'_>) -> bool {
+fn block_has_safety_comment(cx: &LateContext<'_>, block: &hir::Block<'_>) -> bool {
     // This intentionally ignores text before the start of a function so something like:
     // ```
     //     // SAFETY: reason
@@ -171,13 +136,85 @@ fn block_has_safety_comment(cx: &LateContext<'_>, block: &Block<'_>) -> bool {
     // won't work. This is to avoid dealing with where such a comment should be place relative to
     // attributes and doc comments.
 
+    span_from_macro_expansion_has_safety_comment(cx, block.span) || span_in_body_has_safety_comment(cx, block.span)
+}
+
+/// Checks if the lines immediately preceding the item contain a safety comment.
+fn item_has_safety_comment(cx: &LateContext<'_>, item: &hir::Item<'_>) -> bool {
+    if span_from_macro_expansion_has_safety_comment(cx, item.span) || span_in_body_has_safety_comment(cx, item.span) {
+        return true;
+    }
+
+    if item.span.ctxt() == SyntaxContext::root() {
+        if let Some(parent_node) = get_parent_node(cx.tcx, item.hir_id()) {
+            let mut span_before_item = None;
+            let mut hi = false;
+            if let Node::Item(parent_item) = parent_node {
+                if let ItemKind::Mod(parent_mod) = &parent_item.kind {
+                    for (idx, item_id) in parent_mod.item_ids.iter().enumerate() {
+                        if *item_id == item.item_id() {
+                            if idx == 0 {
+                                // mod A { /* comment */ unsafe impl T {} ... }
+                                // ^------------------------------------------^ gets this span
+                                // ^---------------------^ finally checks the text in this range
+                                hi = false;
+                                span_before_item = Some(parent_item.span);
+                            } else {
+                                let prev_item = cx.tcx.hir().item(parent_mod.item_ids[idx - 1]);
+                                // some_item /* comment */ unsafe impl T {}
+                                // ^-------^ gets this span
+                                //         ^---------------^ finally checks the text in this range
+                                hi = true;
+                                span_before_item = Some(prev_item.span);
+                            }
+                            break;
+                        }
+                    }
+                }
+            }
+            let span_before_item = span_before_item.unwrap();
+
+            let source_map = cx.sess().source_map();
+            if let Some(item_span) = walk_span_to_context(item.span, SyntaxContext::root())
+                && let Some(span_before_item) = walk_span_to_context(span_before_item, SyntaxContext::root())
+                && let Ok(unsafe_line) = source_map.lookup_line(item_span.lo())
+                && let Ok(line_before_unsafe) = source_map.lookup_line(if hi {
+                    span_before_item.hi()
+                } else {
+                    span_before_item.lo()
+                })
+                && Lrc::ptr_eq(&unsafe_line.sf, &line_before_unsafe.sf)
+                && let Some(src) = unsafe_line.sf.src.as_deref()
+            {
+                line_before_unsafe.line < unsafe_line.line && text_has_safety_comment(
+                    src,
+                    &unsafe_line.sf.lines[line_before_unsafe.line + 1..=unsafe_line.line],
+                    unsafe_line.sf.start_pos.to_usize(),
+                )
+            } else {
+                // Problem getting source text. Pretend a comment was found.
+                true
+            }
+        } else {
+            // No parent node. Pretend a comment was found.
+            true
+        }
+    } else {
+        false
+    }
+}
+
+fn span_from_macro_expansion_has_safety_comment(cx: &LateContext<'_>, span: Span) -> bool {
     let source_map = cx.sess().source_map();
-    let ctxt = block.span.ctxt();
-    if ctxt != SyntaxContext::root() {
-        // From a macro expansion. Get the text from the start of the macro declaration to start of the unsafe block.
+    let ctxt = span.ctxt();
+    if ctxt == SyntaxContext::root() {
+        false
+    } else {
+        // From a macro expansion. Get the text from the start of the macro declaration to start of the
+        // unsafe block.
         //     macro_rules! foo { () => { stuff }; (x) => { unsafe { stuff } }; }
         //     ^--------------------------------------------^
-        if let Ok(unsafe_line) = source_map.lookup_line(block.span.lo())
+        if let Ok(unsafe_line) = source_map.lookup_line(span.lo())
             && let Ok(macro_line) = source_map.lookup_line(ctxt.outer_expn_data().def_site.lo())
             && Lrc::ptr_eq(&unsafe_line.sf, &macro_line.sf)
             && let Some(src) = unsafe_line.sf.src.as_deref()
@@ -191,24 +228,35 @@ fn block_has_safety_comment(cx: &LateContext<'_>, block: &Block<'_>) -> bool {
             // Problem getting source text. Pretend a comment was found.
             true
         }
-    } else if let Ok(unsafe_line) = source_map.lookup_line(block.span.lo())
+    }
+}
+
+fn span_in_body_has_safety_comment(cx: &LateContext<'_>, span: Span) -> bool {
+    let source_map = cx.sess().source_map();
+    let ctxt = span.ctxt();
+    if ctxt == SyntaxContext::root()
         && let Some(body) = cx.enclosing_body
-        && let Some(body_span) = walk_span_to_context(cx.tcx.hir().body(body).value.span, SyntaxContext::root())
-        && let Ok(body_line) = source_map.lookup_line(body_span.lo())
-        && Lrc::ptr_eq(&unsafe_line.sf, &body_line.sf)
-        && let Some(src) = unsafe_line.sf.src.as_deref()
     {
-        // Get the text from the start of function body to the unsafe block.
-        //     fn foo() { some_stuff; unsafe { stuff }; other_stuff; }
-        //              ^-------------^
-        body_line.line < unsafe_line.line && text_has_safety_comment(
-            src,
-            &unsafe_line.sf.lines[body_line.line + 1..=unsafe_line.line],
-            unsafe_line.sf.start_pos.to_usize(),
-        )
+        if let Ok(unsafe_line) = source_map.lookup_line(span.lo())
+            && let Some(body_span) = walk_span_to_context(cx.tcx.hir().body(body).value.span, SyntaxContext::root())
+            && let Ok(body_line) = source_map.lookup_line(body_span.lo())
+            && Lrc::ptr_eq(&unsafe_line.sf, &body_line.sf)
+            && let Some(src) = unsafe_line.sf.src.as_deref()
+        {
+            // Get the text from the start of function body to the unsafe block.
+            //     fn foo() { some_stuff; unsafe { stuff }; other_stuff; }
+            //              ^-------------^
+            body_line.line < unsafe_line.line && text_has_safety_comment(
+                src,
+                &unsafe_line.sf.lines[body_line.line + 1..=unsafe_line.line],
+                unsafe_line.sf.start_pos.to_usize(),
+            )
+        } else {
+            // Problem getting source text. Pretend a comment was found.
+            true
+        }
     } else {
-        // Problem getting source text. Pretend a comment was found.
-        true
+        false
     }
 }
 
diff --git a/tests/ui/undocumented_unsafe_blocks.rs b/tests/ui/undocumented_unsafe_blocks.rs
index 3044a92cbd0..fd64c60384d 100644
--- a/tests/ui/undocumented_unsafe_blocks.rs
+++ b/tests/ui/undocumented_unsafe_blocks.rs
@@ -363,15 +363,22 @@ mod unsafe_impl_smoke_test {
 mod unsafe_impl_from_macro {
     unsafe trait T {}
 
-    macro_rules! unsafe_impl {
+    macro_rules! no_safety_comment {
         ($t:ty) => {
             unsafe impl T for $t {}
         };
     }
-    // ok: from macro expanision
-    unsafe_impl!(());
-    // ok: from macro expansion
-    unsafe_impl!(i32);
+    // error
+    no_safety_comment!(());
+
+    macro_rules! with_safety_comment {
+        ($t:ty) => {
+            // SAFETY:
+            unsafe impl T for $t {}
+        };
+    }
+    // ok
+    with_safety_comment!((i32));
 }
 
 #[rustfmt::skip]
diff --git a/tests/ui/undocumented_unsafe_blocks.stderr b/tests/ui/undocumented_unsafe_blocks.stderr
index 80d68a03808..3a1f647b06d 100644
--- a/tests/ui/undocumented_unsafe_blocks.stderr
+++ b/tests/ui/undocumented_unsafe_blocks.stderr
@@ -164,7 +164,19 @@ LL |         unsafe impl B for (u32) {}
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe impl missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:420:5
+  --> $DIR/undocumented_unsafe_blocks.rs:368:13
+   |
+LL |             unsafe impl T for $t {}
+   |             ^^^^^^^^^^^^^^^^^^^^^^^
+...
+LL |     no_safety_comment!(());
+   |     ---------------------- in this macro invocation
+   |
+   = help: consider adding a safety comment on the preceding line
+   = note: this error originates in the macro `no_safety_comment` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: unsafe impl missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:427:5
    |
 LL |     unsafe impl NoComment for () {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -172,7 +184,7 @@ LL |     unsafe impl NoComment for () {}
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe impl missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:424:19
+  --> $DIR/undocumented_unsafe_blocks.rs:431:19
    |
 LL |     /* SAFETY: */ unsafe impl InlineComment for () {}
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -180,7 +192,7 @@ LL |     /* SAFETY: */ unsafe impl InlineComment for () {}
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe impl missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:428:5
+  --> $DIR/undocumented_unsafe_blocks.rs:435:5
    |
 LL |     unsafe impl TrailingComment for () {} // SAFETY:
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -188,12 +200,12 @@ LL |     unsafe impl TrailingComment for () {} // SAFETY:
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe impl missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:433:5
+  --> $DIR/undocumented_unsafe_blocks.rs:440:5
    |
 LL |     unsafe impl Interference for () {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: consider adding a safety comment on the preceding line
 
-error: aborting due to 24 previous errors
+error: aborting due to 25 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 03960ebab26a1b1d2d43540f47aca6670bdc1e54 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Sat, 7 May 2022 16:49:19 +0200
Subject: Replace `#[allow]` with `#[expect]` in Clippy

---
 clippy_lints/src/booleans.rs                       |  6 +++---
 clippy_lints/src/cognitive_complexity.rs           |  4 ++--
 clippy_lints/src/default.rs                        |  2 +-
 clippy_lints/src/default_numeric_fallback.rs       |  1 -
 clippy_lints/src/dereference.rs                    |  4 ++--
 clippy_lints/src/doc.rs                            |  6 +++---
 clippy_lints/src/double_comparison.rs              |  2 +-
 clippy_lints/src/entry.rs                          |  4 ++--
 clippy_lints/src/enum_clike.rs                     |  2 +-
 clippy_lints/src/enum_variants.rs                  |  2 +-
 clippy_lints/src/eq_op.rs                          |  3 +--
 clippy_lints/src/floating_point_arithmetic.rs      |  2 +-
 clippy_lints/src/implicit_hasher.rs                |  2 +-
 clippy_lints/src/implicit_return.rs                |  4 ++--
 clippy_lints/src/int_plus_one.rs                   |  2 +-
 clippy_lints/src/lib.rs                            |  3 ++-
 clippy_lints/src/literal_representation.rs         |  3 +--
 clippy_lints/src/loops/mod.rs                      |  1 -
 clippy_lints/src/loops/needless_range_loop.rs      |  2 +-
 clippy_lints/src/loops/while_let_on_iterator.rs    |  2 +-
 clippy_lints/src/macro_use.rs                      |  3 +--
 clippy_lints/src/manual_map.rs                     |  2 +-
 clippy_lints/src/manual_non_exhaustive.rs          |  4 ++--
 clippy_lints/src/matches/match_same_arms.rs        |  6 +++---
 clippy_lints/src/matches/match_single_binding.rs   |  2 +-
 clippy_lints/src/matches/match_wild_enum.rs        |  3 +--
 .../src/matches/redundant_pattern_match.rs         |  2 +-
 clippy_lints/src/misc.rs                           |  2 +-
 clippy_lints/src/needless_pass_by_value.rs         |  2 +-
 clippy_lints/src/neg_multiply.rs                   |  1 -
 clippy_lints/src/new_without_default.rs            |  1 -
 clippy_lints/src/non_expressive_names.rs           |  2 +-
 clippy_lints/src/pass_by_ref_or_value.rs           |  2 +-
 clippy_lints/src/pattern_type_mismatch.rs          |  1 -
 clippy_lints/src/ptr.rs                            |  2 +-
 clippy_lints/src/redundant_clone.rs                |  2 +-
 clippy_lints/src/reference.rs                      |  5 ++---
 clippy_lints/src/regex.rs                          |  1 -
 clippy_lints/src/uninit_vec.rs                     |  2 +-
 clippy_lints/src/unused_unit.rs                    |  2 +-
 clippy_lints/src/useless_conversion.rs             |  2 +-
 clippy_lints/src/vec.rs                            |  5 ++---
 clippy_lints/src/write.rs                          |  3 ---
 clippy_utils/src/ast_utils.rs                      |  2 +-
 clippy_utils/src/attrs.rs                          |  1 -
 clippy_utils/src/consts.rs                         |  2 +-
 clippy_utils/src/eager_or_lazy.rs                  |  2 +-
 clippy_utils/src/hir_utils.rs                      |  8 +++-----
 clippy_utils/src/lib.rs                            |  6 +++---
 clippy_utils/src/paths.rs                          | 22 +++++++++++-----------
 clippy_utils/src/source.rs                         |  2 +-
 clippy_utils/src/sugg.rs                           |  4 +---
 clippy_utils/src/ty.rs                             |  2 +-
 clippy_utils/src/usage.rs                          |  1 -
 54 files changed, 73 insertions(+), 93 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/booleans.rs b/clippy_lints/src/booleans.rs
index f7449c8dc72..0adb6327164 100644
--- a/clippy_lints/src/booleans.rs
+++ b/clippy_lints/src/booleans.rs
@@ -137,7 +137,7 @@ impl<'a, 'tcx, 'v> Hir2Qmm<'a, 'tcx, 'v> {
         }
         for (n, expr) in self.terminals.iter().enumerate() {
             if eq_expr_value(self.cx, e, expr) {
-                #[allow(clippy::cast_possible_truncation)]
+                #[expect(clippy::cast_possible_truncation)]
                 return Ok(Bool::Term(n as u8));
             }
 
@@ -149,7 +149,7 @@ impl<'a, 'tcx, 'v> Hir2Qmm<'a, 'tcx, 'v> {
                 if eq_expr_value(self.cx, e_lhs, expr_lhs);
                 if eq_expr_value(self.cx, e_rhs, expr_rhs);
                 then {
-                    #[allow(clippy::cast_possible_truncation)]
+                    #[expect(clippy::cast_possible_truncation)]
                     return Ok(Bool::Not(Box::new(Bool::Term(n as u8))));
                 }
             }
@@ -157,7 +157,7 @@ impl<'a, 'tcx, 'v> Hir2Qmm<'a, 'tcx, 'v> {
         let n = self.terminals.len();
         self.terminals.push(e);
         if n < 32 {
-            #[allow(clippy::cast_possible_truncation)]
+            #[expect(clippy::cast_possible_truncation)]
             Ok(Bool::Term(n as u8))
         } else {
             Err("too many literals".to_owned())
diff --git a/clippy_lints/src/cognitive_complexity.rs b/clippy_lints/src/cognitive_complexity.rs
index 2bf7f868905..317c4bfb322 100644
--- a/clippy_lints/src/cognitive_complexity.rs
+++ b/clippy_lints/src/cognitive_complexity.rs
@@ -48,7 +48,7 @@ impl CognitiveComplexity {
 impl_lint_pass!(CognitiveComplexity => [COGNITIVE_COMPLEXITY]);
 
 impl CognitiveComplexity {
-    #[allow(clippy::cast_possible_truncation)]
+    #[expect(clippy::cast_possible_truncation)]
     fn check<'tcx>(
         &mut self,
         cx: &LateContext<'tcx>,
@@ -70,7 +70,7 @@ impl CognitiveComplexity {
         let ret_adjust = if is_type_diagnostic_item(cx, ret_ty, sym::Result) {
             returns
         } else {
-            #[allow(clippy::integer_division)]
+            #[expect(clippy::integer_division)]
             (returns / 2)
         };
 
diff --git a/clippy_lints/src/default.rs b/clippy_lints/src/default.rs
index f7e4bc24321..243dfd3a461 100644
--- a/clippy_lints/src/default.rs
+++ b/clippy_lints/src/default.rs
@@ -110,7 +110,7 @@ impl<'tcx> LateLintPass<'tcx> for Default {
         }
     }
 
-    #[allow(clippy::too_many_lines)]
+    #[expect(clippy::too_many_lines)]
     fn check_block(&mut self, cx: &LateContext<'tcx>, block: &Block<'tcx>) {
         // start from the `let mut _ = _::default();` and look at all the following
         // statements, see if they re-assign the fields of the binding
diff --git a/clippy_lints/src/default_numeric_fallback.rs b/clippy_lints/src/default_numeric_fallback.rs
index f3996e5b44d..3d9f9ed41ce 100644
--- a/clippy_lints/src/default_numeric_fallback.rs
+++ b/clippy_lints/src/default_numeric_fallback.rs
@@ -116,7 +116,6 @@ impl<'a, 'tcx> NumericFallbackVisitor<'a, 'tcx> {
 }
 
 impl<'a, 'tcx> Visitor<'tcx> for NumericFallbackVisitor<'a, 'tcx> {
-    #[allow(clippy::too_many_lines)]
     fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
         match &expr.kind {
             ExprKind::Call(func, args) => {
diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index fe391198342..ea4c0207bb0 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -168,7 +168,7 @@ struct RefPat {
 }
 
 impl<'tcx> LateLintPass<'tcx> for Dereferencing {
-    #[allow(clippy::too_many_lines)]
+    #[expect(clippy::too_many_lines)]
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         // Skip path expressions from deref calls. e.g. `Deref::deref(e)`
         if Some(expr.hir_id) == self.skip_expr.take() {
@@ -580,7 +580,7 @@ fn find_adjustments<'tcx>(
     }
 }
 
-#[allow(clippy::needless_pass_by_value)]
+#[expect(clippy::needless_pass_by_value)]
 fn report(cx: &LateContext<'_>, expr: &Expr<'_>, state: State, data: StateData) {
     match state {
         State::DerefMethod {
diff --git a/clippy_lints/src/doc.rs b/clippy_lints/src/doc.rs
index b3fd8af4730..aaec88f50c7 100644
--- a/clippy_lints/src/doc.rs
+++ b/clippy_lints/src/doc.rs
@@ -198,7 +198,7 @@ declare_clippy_lint! {
     "presence of `fn main() {` in code examples"
 }
 
-#[allow(clippy::module_name_repetitions)]
+#[expect(clippy::module_name_repetitions)]
 #[derive(Clone)]
 pub struct DocMarkdown {
     valid_idents: FxHashSet<String>,
@@ -373,7 +373,7 @@ fn lint_for_missing_headers<'tcx>(
 /// `rustc_ast::parse::lexer::comments::strip_doc_comment_decoration` because we
 /// need to keep track of
 /// the spans but this function is inspired from the later.
-#[allow(clippy::cast_possible_truncation)]
+#[expect(clippy::cast_possible_truncation)]
 #[must_use]
 pub fn strip_doc_comment_decoration(doc: &str, comment_kind: CommentKind, span: Span) -> (String, Vec<(usize, Span)>) {
     // one-line comments lose their prefix
@@ -428,7 +428,7 @@ fn check_attrs<'a>(cx: &LateContext<'_>, valid_idents: &FxHashSet<String>, attrs
     /// We don't want the parser to choke on intra doc links. Since we don't
     /// actually care about rendering them, just pretend that all broken links are
     /// point to a fake address.
-    #[allow(clippy::unnecessary_wraps)] // we're following a type signature
+    #[expect(clippy::unnecessary_wraps)] // we're following a type signature
     fn fake_broken_link_callback<'a>(_: BrokenLink<'_>) -> Option<(CowStr<'a>, CowStr<'a>)> {
         Some(("fake".into(), "fake".into()))
     }
diff --git a/clippy_lints/src/double_comparison.rs b/clippy_lints/src/double_comparison.rs
index 176092e5b28..be95375789d 100644
--- a/clippy_lints/src/double_comparison.rs
+++ b/clippy_lints/src/double_comparison.rs
@@ -40,7 +40,7 @@ declare_clippy_lint! {
 declare_lint_pass!(DoubleComparisons => [DOUBLE_COMPARISONS]);
 
 impl<'tcx> DoubleComparisons {
-    #[allow(clippy::similar_names)]
+    #[expect(clippy::similar_names)]
     fn check_binop(cx: &LateContext<'tcx>, op: BinOpKind, lhs: &'tcx Expr<'_>, rhs: &'tcx Expr<'_>, span: Span) {
         let (lkind, llhs, lrhs, rkind, rlhs, rrhs) = match (&lhs.kind, &rhs.kind) {
             (ExprKind::Binary(lb, llhs, lrhs), ExprKind::Binary(rb, rlhs, rrhs)) => {
diff --git a/clippy_lints/src/entry.rs b/clippy_lints/src/entry.rs
index 1ae2e20c1e0..6c5ed5dca2d 100644
--- a/clippy_lints/src/entry.rs
+++ b/clippy_lints/src/entry.rs
@@ -63,7 +63,7 @@ declare_clippy_lint! {
 declare_lint_pass!(HashMapPass => [MAP_ENTRY]);
 
 impl<'tcx> LateLintPass<'tcx> for HashMapPass {
-    #[allow(clippy::too_many_lines)]
+    #[expect(clippy::too_many_lines)]
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         let (cond_expr, then_expr, else_expr) = match higher::If::hir(expr) {
             Some(higher::If { cond, then, r#else }) => (cond, then, r#else),
@@ -319,7 +319,7 @@ struct Insertion<'tcx> {
 ///   `or_insert_with`.
 /// * Determine if there's any sub-expression that can't be placed in a closure.
 /// * Determine if there's only a single insert statement. `or_insert` can be used in this case.
-#[allow(clippy::struct_excessive_bools)]
+#[expect(clippy::struct_excessive_bools)]
 struct InsertSearcher<'cx, 'tcx> {
     cx: &'cx LateContext<'tcx>,
     /// The map expression used in the contains call.
diff --git a/clippy_lints/src/enum_clike.rs b/clippy_lints/src/enum_clike.rs
index e2a5430da08..43b405c9a8e 100644
--- a/clippy_lints/src/enum_clike.rs
+++ b/clippy_lints/src/enum_clike.rs
@@ -37,7 +37,7 @@ declare_clippy_lint! {
 declare_lint_pass!(UnportableVariant => [ENUM_CLIKE_UNPORTABLE_VARIANT]);
 
 impl<'tcx> LateLintPass<'tcx> for UnportableVariant {
-    #[allow(clippy::cast_possible_truncation, clippy::cast_possible_wrap, clippy::cast_sign_loss)]
+    #[expect(clippy::cast_possible_wrap)]
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
         if cx.tcx.data_layout.pointer_size.bits() != 64 {
             return;
diff --git a/clippy_lints/src/enum_variants.rs b/clippy_lints/src/enum_variants.rs
index 346d03ca556..e029b8e8537 100644
--- a/clippy_lints/src/enum_variants.rs
+++ b/clippy_lints/src/enum_variants.rs
@@ -240,7 +240,7 @@ impl LateLintPass<'_> for EnumVariantNames {
         assert!(last.is_some());
     }
 
-    #[allow(clippy::similar_names)]
+    #[expect(clippy::similar_names)]
     fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
         let item_name = item.ident.name.as_str();
         let item_camel = to_camel_case(item_name);
diff --git a/clippy_lints/src/eq_op.rs b/clippy_lints/src/eq_op.rs
index 51c811b304c..afb5d32f953 100644
--- a/clippy_lints/src/eq_op.rs
+++ b/clippy_lints/src/eq_op.rs
@@ -72,7 +72,7 @@ declare_clippy_lint! {
 declare_lint_pass!(EqOp => [EQ_OP, OP_REF]);
 
 impl<'tcx> LateLintPass<'tcx> for EqOp {
-    #[allow(clippy::similar_names, clippy::too_many_lines)]
+    #[expect(clippy::similar_names, clippy::too_many_lines)]
     fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
         if_chain! {
             if let Some((macro_call, macro_name)) = first_node_macro_backtrace(cx, e).find_map(|macro_call| {
@@ -138,7 +138,6 @@ impl<'tcx> LateLintPass<'tcx> for EqOp {
                 },
             };
             if let Some(trait_id) = trait_id {
-                #[allow(clippy::match_same_arms)]
                 match (&left.kind, &right.kind) {
                     // do not suggest to dereference literals
                     (&ExprKind::Lit(..), _) | (_, &ExprKind::Lit(..)) => {},
diff --git a/clippy_lints/src/floating_point_arithmetic.rs b/clippy_lints/src/floating_point_arithmetic.rs
index 79ce53f7a5f..42503c26de1 100644
--- a/clippy_lints/src/floating_point_arithmetic.rs
+++ b/clippy_lints/src/floating_point_arithmetic.rs
@@ -215,7 +215,7 @@ fn check_ln1p(cx: &LateContext<'_>, expr: &Expr<'_>, args: &[Expr<'_>]) {
 // converted to an integer without loss of precision. For now we only check
 // ranges [-16777215, 16777216) for type f32 as whole number floats outside
 // this range are lossy and ambiguous.
-#[allow(clippy::cast_possible_truncation)]
+#[expect(clippy::cast_possible_truncation)]
 fn get_integer_from_float_constant(value: &Constant) -> Option<i32> {
     match value {
         F32(num) if num.fract() == 0.0 => {
diff --git a/clippy_lints/src/implicit_hasher.rs b/clippy_lints/src/implicit_hasher.rs
index feb1b1014b1..4f9680f60fe 100644
--- a/clippy_lints/src/implicit_hasher.rs
+++ b/clippy_lints/src/implicit_hasher.rs
@@ -62,7 +62,7 @@ declare_clippy_lint! {
 declare_lint_pass!(ImplicitHasher => [IMPLICIT_HASHER]);
 
 impl<'tcx> LateLintPass<'tcx> for ImplicitHasher {
-    #[allow(clippy::cast_possible_truncation, clippy::too_many_lines)]
+    #[expect(clippy::cast_possible_truncation, clippy::too_many_lines)]
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
         use rustc_span::BytePos;
 
diff --git a/clippy_lints/src/implicit_return.rs b/clippy_lints/src/implicit_return.rs
index d650d6e9a85..647947d5d30 100644
--- a/clippy_lints/src/implicit_return.rs
+++ b/clippy_lints/src/implicit_return.rs
@@ -164,7 +164,7 @@ fn lint_implicit_returns(
             })
             .visit_block(block);
             if add_return {
-                #[allow(clippy::option_if_let_else)]
+                #[expect(clippy::option_if_let_else)]
                 if let Some(span) = call_site_span {
                     lint_return(cx, span);
                     LintLocation::Parent
@@ -196,7 +196,7 @@ fn lint_implicit_returns(
 
         _ =>
         {
-            #[allow(clippy::option_if_let_else)]
+            #[expect(clippy::option_if_let_else)]
             if let Some(span) = call_site_span {
                 lint_return(cx, span);
                 LintLocation::Parent
diff --git a/clippy_lints/src/int_plus_one.rs b/clippy_lints/src/int_plus_one.rs
index 3716d36ad88..8db7b307ddb 100644
--- a/clippy_lints/src/int_plus_one.rs
+++ b/clippy_lints/src/int_plus_one.rs
@@ -52,7 +52,7 @@ enum Side {
 }
 
 impl IntPlusOne {
-    #[allow(clippy::cast_sign_loss)]
+    #[expect(clippy::cast_sign_loss)]
     fn check_lit(lit: &Lit, target_value: i128) -> bool {
         if let LitKind::Int(value, ..) = lit.kind {
             return value == (target_value as u128);
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 3bb821a1482..092c981140e 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -8,6 +8,7 @@
 #![feature(iter_intersperse)]
 #![feature(let_chains)]
 #![feature(let_else)]
+#![feature(lint_reasons)]
 #![feature(once_cell)]
 #![feature(rustc_private)]
 #![feature(stmt_expr_attributes)]
@@ -472,7 +473,7 @@ pub fn read_conf(sess: &Session) -> Conf {
 /// Register all lints and lint groups with the rustc plugin registry
 ///
 /// Used in `./src/driver.rs`.
-#[allow(clippy::too_many_lines)]
+#[expect(clippy::too_many_lines)]
 pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf: &Conf) {
     register_removed_non_tool_lints(store);
 
diff --git a/clippy_lints/src/literal_representation.rs b/clippy_lints/src/literal_representation.rs
index 269d3c62eaf..9998712b852 100644
--- a/clippy_lints/src/literal_representation.rs
+++ b/clippy_lints/src/literal_representation.rs
@@ -204,7 +204,6 @@ impl WarningType {
     }
 }
 
-#[allow(clippy::module_name_repetitions)]
 #[derive(Copy, Clone)]
 pub struct LiteralDigitGrouping {
     lint_fraction_readability: bool,
@@ -432,7 +431,7 @@ impl LiteralDigitGrouping {
     }
 }
 
-#[allow(clippy::module_name_repetitions)]
+#[expect(clippy::module_name_repetitions)]
 #[derive(Copy, Clone)]
 pub struct DecimalLiteralRepresentation {
     threshold: u64,
diff --git a/clippy_lints/src/loops/mod.rs b/clippy_lints/src/loops/mod.rs
index f029067d367..75d771f992a 100644
--- a/clippy_lints/src/loops/mod.rs
+++ b/clippy_lints/src/loops/mod.rs
@@ -620,7 +620,6 @@ declare_lint_pass!(Loops => [
 ]);
 
 impl<'tcx> LateLintPass<'tcx> for Loops {
-    #[allow(clippy::too_many_lines)]
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         let for_loop = higher::ForLoop::hir(expr);
         if let Some(higher::ForLoop {
diff --git a/clippy_lints/src/loops/needless_range_loop.rs b/clippy_lints/src/loops/needless_range_loop.rs
index 6ed141fa4a5..09f9c05b4fc 100644
--- a/clippy_lints/src/loops/needless_range_loop.rs
+++ b/clippy_lints/src/loops/needless_range_loop.rs
@@ -19,7 +19,7 @@ use std::mem;
 
 /// Checks for looping over a range and then indexing a sequence with it.
 /// The iteratee must be a range literal.
-#[allow(clippy::too_many_lines)]
+#[expect(clippy::too_many_lines)]
 pub(super) fn check<'tcx>(
     cx: &LateContext<'tcx>,
     pat: &'tcx Pat<'_>,
diff --git a/clippy_lints/src/loops/while_let_on_iterator.rs b/clippy_lints/src/loops/while_let_on_iterator.rs
index 20a8294a0d1..82760607ba2 100644
--- a/clippy_lints/src/loops/while_let_on_iterator.rs
+++ b/clippy_lints/src/loops/while_let_on_iterator.rs
@@ -239,7 +239,7 @@ fn uses_iter<'tcx>(cx: &LateContext<'tcx>, iter_expr: &IterExpr, container: &'tc
     v.uses_iter
 }
 
-#[allow(clippy::too_many_lines)]
+#[expect(clippy::too_many_lines)]
 fn needs_mutable_borrow(cx: &LateContext<'_>, iter_expr: &IterExpr, loop_expr: &Expr<'_>) -> bool {
     struct AfterLoopVisitor<'a, 'b, 'tcx> {
         cx: &'a LateContext<'tcx>,
diff --git a/clippy_lints/src/macro_use.rs b/clippy_lints/src/macro_use.rs
index 76c5cfadc2c..da806918be0 100644
--- a/clippy_lints/src/macro_use.rs
+++ b/clippy_lints/src/macro_use.rs
@@ -49,7 +49,7 @@ impl MacroRefData {
 }
 
 #[derive(Default)]
-#[allow(clippy::module_name_repetitions)]
+#[expect(clippy::module_name_repetitions)]
 pub struct MacroUseImports {
     /// the actual import path used and the span of the attribute above it.
     imports: Vec<(String, Span)>,
@@ -135,7 +135,6 @@ impl<'tcx> LateLintPass<'tcx> for MacroUseImports {
             self.push_unique_macro_pat_ty(cx, ty.span);
         }
     }
-    #[allow(clippy::too_many_lines)]
     fn check_crate_post(&mut self, cx: &LateContext<'_>) {
         let mut used = FxHashMap::default();
         let mut check_dup = vec![];
diff --git a/clippy_lints/src/manual_map.rs b/clippy_lints/src/manual_map.rs
index 8475e367b09..230ae029ed9 100644
--- a/clippy_lints/src/manual_map.rs
+++ b/clippy_lints/src/manual_map.rs
@@ -46,7 +46,7 @@ declare_clippy_lint! {
 declare_lint_pass!(ManualMap => [MANUAL_MAP]);
 
 impl<'tcx> LateLintPass<'tcx> for ManualMap {
-    #[allow(clippy::too_many_lines)]
+    #[expect(clippy::too_many_lines)]
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         let (scrutinee, then_pat, then_body, else_pat, else_body) = match IfLetOrMatch::parse(cx, expr) {
             Some(IfLetOrMatch::IfLet(scrutinee, pat, body, Some(r#else))) => (scrutinee, pat, body, None, r#else),
diff --git a/clippy_lints/src/manual_non_exhaustive.rs b/clippy_lints/src/manual_non_exhaustive.rs
index b8d620d8171..004e36ae13c 100644
--- a/clippy_lints/src/manual_non_exhaustive.rs
+++ b/clippy_lints/src/manual_non_exhaustive.rs
@@ -62,7 +62,7 @@ declare_clippy_lint! {
     "manual implementations of the non-exhaustive pattern can be simplified using #[non_exhaustive]"
 }
 
-#[allow(clippy::module_name_repetitions)]
+#[expect(clippy::module_name_repetitions)]
 pub struct ManualNonExhaustiveStruct {
     msrv: Option<RustcVersion>,
 }
@@ -76,7 +76,7 @@ impl ManualNonExhaustiveStruct {
 
 impl_lint_pass!(ManualNonExhaustiveStruct => [MANUAL_NON_EXHAUSTIVE]);
 
-#[allow(clippy::module_name_repetitions)]
+#[expect(clippy::module_name_repetitions)]
 pub struct ManualNonExhaustiveEnum {
     msrv: Option<RustcVersion>,
     constructed_enum_variants: FxHashSet<(DefId, DefId)>,
diff --git a/clippy_lints/src/matches/match_same_arms.rs b/clippy_lints/src/matches/match_same_arms.rs
index 9b7344fb8b0..a96a7fe55f3 100644
--- a/clippy_lints/src/matches/match_same_arms.rs
+++ b/clippy_lints/src/matches/match_same_arms.rs
@@ -16,7 +16,7 @@ use std::collections::hash_map::Entry;
 
 use super::MATCH_SAME_ARMS;
 
-#[allow(clippy::too_many_lines)]
+#[expect(clippy::too_many_lines)]
 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>]) {
     let hash = |&(_, arm): &(usize, &Arm<'_>)| -> u64 {
         let mut h = SpanlessHash::new(cx);
@@ -225,9 +225,9 @@ fn iter_matching_struct_fields<'a>(
     Iter(left.iter(), right.iter())
 }
 
-#[allow(clippy::similar_names)]
+#[expect(clippy::similar_names)]
 impl<'a> NormalizedPat<'a> {
-    #[allow(clippy::too_many_lines)]
+    #[expect(clippy::too_many_lines)]
     fn from_pat(cx: &LateContext<'_>, arena: &'a DroplessArena, pat: &'a Pat<'_>) -> Self {
         match pat.kind {
             PatKind::Wild | PatKind::Binding(.., None) => Self::Wild,
diff --git a/clippy_lints/src/matches/match_single_binding.rs b/clippy_lints/src/matches/match_single_binding.rs
index 39fe54648fb..028e8c297fb 100644
--- a/clippy_lints/src/matches/match_single_binding.rs
+++ b/clippy_lints/src/matches/match_single_binding.rs
@@ -8,7 +8,7 @@ use rustc_lint::LateContext;
 
 use super::MATCH_SINGLE_BINDING;
 
-#[allow(clippy::too_many_lines)]
+#[expect(clippy::too_many_lines)]
 pub(crate) fn check<'a>(cx: &LateContext<'a>, ex: &Expr<'a>, arms: &[Arm<'_>], expr: &Expr<'_>) {
     if expr.span.from_expansion() || arms.len() != 1 || is_refutable(cx, arms[0].pat) {
         return;
diff --git a/clippy_lints/src/matches/match_wild_enum.rs b/clippy_lints/src/matches/match_wild_enum.rs
index 93bf0dc62e0..a3a26d9c3e1 100644
--- a/clippy_lints/src/matches/match_wild_enum.rs
+++ b/clippy_lints/src/matches/match_wild_enum.rs
@@ -10,7 +10,7 @@ use rustc_span::sym;
 
 use super::{MATCH_WILDCARD_FOR_SINGLE_VARIANTS, WILDCARD_ENUM_MATCH_ARM};
 
-#[allow(clippy::too_many_lines)]
+#[expect(clippy::too_many_lines)]
 pub(crate) fn check(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>]) {
     let ty = cx.typeck_results().expr_ty(ex).peel_refs();
     let adt_def = match ty.kind() {
@@ -56,7 +56,6 @@ pub(crate) fn check(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>]) {
         recurse_or_patterns(arm.pat, |pat| {
             let path = match &peel_hir_pat_refs(pat).0.kind {
                 PatKind::Path(path) => {
-                    #[allow(clippy::match_same_arms)]
                     let id = match cx.qpath_res(path, pat.hir_id) {
                         Res::Def(
                             DefKind::Const | DefKind::ConstParam | DefKind::AnonConst | DefKind::InlineConst,
diff --git a/clippy_lints/src/matches/redundant_pattern_match.rs b/clippy_lints/src/matches/redundant_pattern_match.rs
index 37b67647efe..1a8b9d15f37 100644
--- a/clippy_lints/src/matches/redundant_pattern_match.rs
+++ b/clippy_lints/src/matches/redundant_pattern_match.rs
@@ -340,7 +340,7 @@ pub(super) fn check_match<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, op
     }
 }
 
-#[allow(clippy::too_many_arguments)]
+#[expect(clippy::too_many_arguments)]
 fn find_good_method_for_match<'a>(
     cx: &LateContext<'_>,
     arms: &[Arm<'_>],
diff --git a/clippy_lints/src/misc.rs b/clippy_lints/src/misc.rs
index ac82dd306a5..2566a3c1f86 100644
--- a/clippy_lints/src/misc.rs
+++ b/clippy_lints/src/misc.rs
@@ -548,7 +548,7 @@ fn is_array(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
     matches!(&cx.typeck_results().expr_ty(expr).peel_refs().kind(), ty::Array(_, _))
 }
 
-#[allow(clippy::too_many_lines)]
+#[expect(clippy::too_many_lines)]
 fn check_to_owned(cx: &LateContext<'_>, expr: &Expr<'_>, other: &Expr<'_>, left: bool) {
     #[derive(Default)]
     struct EqImpl {
diff --git a/clippy_lints/src/needless_pass_by_value.rs b/clippy_lints/src/needless_pass_by_value.rs
index 4034079a90c..38960103d5e 100644
--- a/clippy_lints/src/needless_pass_by_value.rs
+++ b/clippy_lints/src/needless_pass_by_value.rs
@@ -70,7 +70,7 @@ macro_rules! need {
 }
 
 impl<'tcx> LateLintPass<'tcx> for NeedlessPassByValue {
-    #[allow(clippy::too_many_lines)]
+    #[expect(clippy::too_many_lines)]
     fn check_fn(
         &mut self,
         cx: &LateContext<'tcx>,
diff --git a/clippy_lints/src/neg_multiply.rs b/clippy_lints/src/neg_multiply.rs
index 6ba9ba0753d..707f3b2181a 100644
--- a/clippy_lints/src/neg_multiply.rs
+++ b/clippy_lints/src/neg_multiply.rs
@@ -34,7 +34,6 @@ declare_clippy_lint! {
 
 declare_lint_pass!(NegMultiply => [NEG_MULTIPLY]);
 
-#[allow(clippy::match_same_arms)]
 impl<'tcx> LateLintPass<'tcx> for NegMultiply {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
         if let ExprKind::Binary(ref op, left, right) = e.kind {
diff --git a/clippy_lints/src/new_without_default.rs b/clippy_lints/src/new_without_default.rs
index 2f733f221d5..6e7627639eb 100644
--- a/clippy_lints/src/new_without_default.rs
+++ b/clippy_lints/src/new_without_default.rs
@@ -58,7 +58,6 @@ pub struct NewWithoutDefault {
 impl_lint_pass!(NewWithoutDefault => [NEW_WITHOUT_DEFAULT]);
 
 impl<'tcx> LateLintPass<'tcx> for NewWithoutDefault {
-    #[allow(clippy::too_many_lines)]
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) {
         if let hir::ItemKind::Impl(hir::Impl {
             of_trait: None,
diff --git a/clippy_lints/src/non_expressive_names.rs b/clippy_lints/src/non_expressive_names.rs
index e3bc40c4b49..7f6b535c7b1 100644
--- a/clippy_lints/src/non_expressive_names.rs
+++ b/clippy_lints/src/non_expressive_names.rs
@@ -191,7 +191,7 @@ impl<'a, 'tcx, 'b> SimilarNamesNameVisitor<'a, 'tcx, 'b> {
         }
     }
 
-    #[allow(clippy::too_many_lines)]
+    #[expect(clippy::too_many_lines)]
     fn check_ident(&mut self, ident: Ident) {
         let interned_name = ident.name.as_str();
         if interned_name.chars().any(char::is_uppercase) {
diff --git a/clippy_lints/src/pass_by_ref_or_value.rs b/clippy_lints/src/pass_by_ref_or_value.rs
index 9af3059a37f..c5b8b8103a1 100644
--- a/clippy_lints/src/pass_by_ref_or_value.rs
+++ b/clippy_lints/src/pass_by_ref_or_value.rs
@@ -124,7 +124,7 @@ impl<'tcx> PassByRefOrValue {
             // Cap the calculated bit width at 32-bits to reduce
             // portability problems between 32 and 64-bit targets
             let bit_width = cmp::min(bit_width, 32);
-            #[allow(clippy::integer_division)]
+            #[expect(clippy::integer_division)]
             let byte_width = bit_width / 8;
             // Use a limit of 2 times the register byte width
             byte_width * 2
diff --git a/clippy_lints/src/pattern_type_mismatch.rs b/clippy_lints/src/pattern_type_mismatch.rs
index be319ee110d..a4d265111f9 100644
--- a/clippy_lints/src/pattern_type_mismatch.rs
+++ b/clippy_lints/src/pattern_type_mismatch.rs
@@ -163,7 +163,6 @@ enum Level {
     Lower,
 }
 
-#[allow(rustc::usage_of_ty_tykind)]
 fn find_first_mismatch<'tcx>(cx: &LateContext<'tcx>, pat: &Pat<'_>) -> Option<(Span, Mutability, Level)> {
     let mut result = None;
     pat.walk(|p| {
diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs
index c35eeeac67a..86460c1b27e 100644
--- a/clippy_lints/src/ptr.rs
+++ b/clippy_lints/src/ptr.rs
@@ -514,7 +514,7 @@ fn check_mut_from_ref<'tcx>(cx: &LateContext<'tcx>, sig: &FnSig<'_>, body: Optio
     }
 }
 
-#[allow(clippy::too_many_lines)]
+#[expect(clippy::too_many_lines)]
 fn check_ptr_arg_usage<'tcx>(cx: &LateContext<'tcx>, body: &'tcx Body<'_>, args: &[PtrArg<'tcx>]) -> Vec<PtrArgResult> {
     struct V<'cx, 'tcx> {
         cx: &'cx LateContext<'tcx>,
diff --git a/clippy_lints/src/redundant_clone.rs b/clippy_lints/src/redundant_clone.rs
index 1507c75ff61..954e702a1f8 100644
--- a/clippy_lints/src/redundant_clone.rs
+++ b/clippy_lints/src/redundant_clone.rs
@@ -71,7 +71,7 @@ declare_clippy_lint! {
 declare_lint_pass!(RedundantClone => [REDUNDANT_CLONE]);
 
 impl<'tcx> LateLintPass<'tcx> for RedundantClone {
-    #[allow(clippy::too_many_lines)]
+    #[expect(clippy::too_many_lines)]
     fn check_fn(
         &mut self,
         cx: &LateContext<'tcx>,
diff --git a/clippy_lints/src/reference.rs b/clippy_lints/src/reference.rs
index 811a7bb9c15..f789cec6d6a 100644
--- a/clippy_lints/src/reference.rs
+++ b/clippy_lints/src/reference.rs
@@ -54,13 +54,12 @@ impl EarlyLintPass for DerefAddrOf {
             then {
                 let mut applicability = Applicability::MachineApplicable;
                 let sugg = if e.span.from_expansion() {
-                    #[allow(clippy::option_if_let_else)]
                     if let Some(macro_source) = snippet_opt(cx, e.span) {
                         // Remove leading whitespace from the given span
                         // e.g: ` $visitor` turns into `$visitor`
                         let trim_leading_whitespaces = |span| {
                             snippet_opt(cx, span).and_then(|snip| {
-                                #[allow(clippy::cast_possible_truncation)]
+                                #[expect(clippy::cast_possible_truncation)]
                                 snip.find(|c: char| !c.is_whitespace()).map(|pos| {
                                     span.lo() + BytePos(pos as u32)
                                 })
@@ -68,7 +67,7 @@ impl EarlyLintPass for DerefAddrOf {
                         };
 
                         let mut generate_snippet = |pattern: &str| {
-                            #[allow(clippy::cast_possible_truncation)]
+                            #[expect(clippy::cast_possible_truncation)]
                             macro_source.rfind(pattern).map(|pattern_pos| {
                                 let rpos = pattern_pos + pattern.len();
                                 let span_after_ref = e.span.with_lo(BytePos(e.span.lo().0 + rpos as u32));
diff --git a/clippy_lints/src/regex.rs b/clippy_lints/src/regex.rs
index a92097e1d24..78ca7622f4a 100644
--- a/clippy_lints/src/regex.rs
+++ b/clippy_lints/src/regex.rs
@@ -79,7 +79,6 @@ impl<'tcx> LateLintPass<'tcx> for Regex {
     }
 }
 
-#[allow(clippy::cast_possible_truncation)] // truncation very unlikely here
 #[must_use]
 fn str_span(base: Span, c: regex_syntax::ast::Span, offset: u8) -> Span {
     let offset = u32::from(offset);
diff --git a/clippy_lints/src/uninit_vec.rs b/clippy_lints/src/uninit_vec.rs
index 6d909c34690..9f4c5555f11 100644
--- a/clippy_lints/src/uninit_vec.rs
+++ b/clippy_lints/src/uninit_vec.rs
@@ -98,7 +98,7 @@ fn handle_uninit_vec_pair<'tcx>(
                 // Check T of Vec<T>
                 if !is_uninit_value_valid_for_ty(cx, substs.type_at(0)) {
                     // FIXME: #7698, false positive of the internal lints
-                    #[allow(clippy::collapsible_span_lint_calls)]
+                    #[expect(clippy::collapsible_span_lint_calls)]
                     span_lint_and_then(
                         cx,
                         UNINIT_VEC,
diff --git a/clippy_lints/src/unused_unit.rs b/clippy_lints/src/unused_unit.rs
index bfd17a68749..52585e59566 100644
--- a/clippy_lints/src/unused_unit.rs
+++ b/clippy_lints/src/unused_unit.rs
@@ -130,7 +130,7 @@ fn lint_unneeded_unit_return(cx: &EarlyContext<'_>, ty: &ast::Ty, span: Span) {
         snippet_opt(cx, span.with_hi(ty.span.hi())).map_or((ty.span, Applicability::MaybeIncorrect), |fn_source| {
             position_before_rarrow(&fn_source).map_or((ty.span, Applicability::MaybeIncorrect), |rpos| {
                 (
-                    #[allow(clippy::cast_possible_truncation)]
+                    #[expect(clippy::cast_possible_truncation)]
                     ty.span.with_lo(BytePos(span.lo().0 + rpos as u32)),
                     Applicability::MachineApplicable,
                 )
diff --git a/clippy_lints/src/useless_conversion.rs b/clippy_lints/src/useless_conversion.rs
index abd8a362370..4a3b5383c89 100644
--- a/clippy_lints/src/useless_conversion.rs
+++ b/clippy_lints/src/useless_conversion.rs
@@ -41,7 +41,7 @@ pub struct UselessConversion {
 
 impl_lint_pass!(UselessConversion => [USELESS_CONVERSION]);
 
-#[allow(clippy::too_many_lines)]
+#[expect(clippy::too_many_lines)]
 impl<'tcx> LateLintPass<'tcx> for UselessConversion {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
         if e.span.from_expansion() {
diff --git a/clippy_lints/src/vec.rs b/clippy_lints/src/vec.rs
index 79e7410c3a8..ba1ff65479d 100644
--- a/clippy_lints/src/vec.rs
+++ b/clippy_lints/src/vec.rs
@@ -12,7 +12,7 @@ use rustc_middle::ty::{self, Ty};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::Span;
 
-#[allow(clippy::module_name_repetitions)]
+#[expect(clippy::module_name_repetitions)]
 #[derive(Copy, Clone)]
 pub struct UselessVec {
     pub too_large_for_stack: u64,
@@ -83,7 +83,7 @@ impl UselessVec {
         let snippet = match *vec_args {
             higher::VecArgs::Repeat(elem, len) => {
                 if let Some((Constant::Int(len_constant), _)) = constant(cx, cx.typeck_results(), len) {
-                    #[allow(clippy::cast_possible_truncation)]
+                    #[expect(clippy::cast_possible_truncation)]
                     if len_constant as u64 * size_of(cx, elem) > self.too_large_for_stack {
                         return;
                     }
@@ -110,7 +110,6 @@ impl UselessVec {
             },
             higher::VecArgs::Vec(args) => {
                 if let Some(last) = args.iter().last() {
-                    #[allow(clippy::cast_possible_truncation)]
                     if args.len() as u64 * size_of(cx, last) > self.too_large_for_stack {
                         return;
                     }
diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs
index 54b93a20a05..d2493c055a5 100644
--- a/clippy_lints/src/write.rs
+++ b/clippy_lints/src/write.rs
@@ -342,8 +342,6 @@ impl EarlyLintPass for Write {
             if let (Some(fmt_str), expr) = self.check_tts(cx, mac.args.inner_tokens(), true) {
                 if fmt_str.symbol == kw::Empty {
                     let mut applicability = Applicability::MachineApplicable;
-                    // FIXME: remove this `#[allow(...)]` once the issue #5822 gets fixed
-                    #[allow(clippy::option_if_let_else)]
                     let suggestion = if let Some(e) = expr {
                         snippet_with_applicability(cx, e.span, "v", &mut applicability)
                     } else {
@@ -528,7 +526,6 @@ impl Write {
     /// ```rust,ignore
     /// (Some("string to write: {}"), Some(buf))
     /// ```
-    #[allow(clippy::too_many_lines)]
     fn check_tts<'a>(&self, cx: &EarlyContext<'a>, tts: TokenStream, is_write: bool) -> (Option<StrLit>, Option<Expr>) {
         let mut parser = parser::Parser::new(&cx.sess().parse_sess, tts, false, None);
         let expr = if is_write {
diff --git a/clippy_utils/src/ast_utils.rs b/clippy_utils/src/ast_utils.rs
index 7919800483f..b379f8c06c6 100644
--- a/clippy_utils/src/ast_utils.rs
+++ b/clippy_utils/src/ast_utils.rs
@@ -242,7 +242,7 @@ pub fn eq_item<K>(l: &Item<K>, r: &Item<K>, mut eq_kind: impl FnMut(&K, &K) -> b
     eq_id(l.ident, r.ident) && over(&l.attrs, &r.attrs, eq_attr) && eq_vis(&l.vis, &r.vis) && eq_kind(&l.kind, &r.kind)
 }
 
-#[allow(clippy::too_many_lines)] // Just a big match statement
+#[expect(clippy::too_many_lines)] // Just a big match statement
 pub fn eq_item_kind(l: &ItemKind, r: &ItemKind) -> bool {
     use ItemKind::*;
     match (l, r) {
diff --git a/clippy_utils/src/attrs.rs b/clippy_utils/src/attrs.rs
index 25a84d16650..5bbc2b5b0eb 100644
--- a/clippy_utils/src/attrs.rs
+++ b/clippy_utils/src/attrs.rs
@@ -5,7 +5,6 @@ use rustc_span::sym;
 use std::str::FromStr;
 
 /// Deprecation status of attributes known by Clippy.
-#[allow(dead_code)]
 pub enum DeprecationStatus {
     /// Attribute is deprecated
     Deprecated,
diff --git a/clippy_utils/src/consts.rs b/clippy_utils/src/consts.rs
index 9785c0a75fb..720dfe72237 100644
--- a/clippy_utils/src/consts.rs
+++ b/clippy_utils/src/consts.rs
@@ -350,7 +350,7 @@ impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
         }
     }
 
-    #[allow(clippy::cast_possible_wrap)]
+    #[expect(clippy::cast_possible_wrap)]
     fn constant_not(&self, o: &Constant, ty: Ty<'_>) -> Option<Constant> {
         use self::Constant::{Bool, Int};
         match *o {
diff --git a/clippy_utils/src/eager_or_lazy.rs b/clippy_utils/src/eager_or_lazy.rs
index a6ef6d79fc0..1a784b6cdda 100644
--- a/clippy_utils/src/eager_or_lazy.rs
+++ b/clippy_utils/src/eager_or_lazy.rs
@@ -96,7 +96,7 @@ fn fn_eagerness<'tcx>(
     }
 }
 
-#[allow(clippy::too_many_lines)]
+#[expect(clippy::too_many_lines)]
 fn expr_eagerness<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> EagernessSuggestion {
     struct V<'cx, 'tcx> {
         cx: &'cx LateContext<'tcx>,
diff --git a/clippy_utils/src/hir_utils.rs b/clippy_utils/src/hir_utils.rs
index f4da625f1e3..951e630080f 100644
--- a/clippy_utils/src/hir_utils.rs
+++ b/clippy_utils/src/hir_utils.rs
@@ -64,7 +64,6 @@ impl<'a, 'tcx> SpanlessEq<'a, 'tcx> {
         }
     }
 
-    #[allow(dead_code)]
     pub fn eq_block(&mut self, left: &Block<'_>, right: &Block<'_>) -> bool {
         self.inter_expr().eq_block(left, right)
     }
@@ -194,7 +193,7 @@ impl HirEqInterExpr<'_, '_, '_> {
         res
     }
 
-    #[allow(clippy::similar_names)]
+    #[expect(clippy::similar_names)]
     pub fn eq_expr(&mut self, left: &Expr<'_>, right: &Expr<'_>) -> bool {
         if !self.inner.allow_side_effects && left.span.ctxt() != right.span.ctxt() {
             return false;
@@ -359,7 +358,7 @@ impl HirEqInterExpr<'_, '_, '_> {
         }
     }
 
-    #[allow(clippy::similar_names)]
+    #[expect(clippy::similar_names)]
     fn eq_qpath(&mut self, left: &QPath<'_>, right: &QPath<'_>) -> bool {
         match (left, right) {
             (&QPath::Resolved(ref lty, lpath), &QPath::Resolved(ref rty, rpath)) => {
@@ -405,7 +404,6 @@ impl HirEqInterExpr<'_, '_, '_> {
         left.ident.name == right.ident.name && both(&left.args, &right.args, |l, r| self.eq_path_parameters(l, r))
     }
 
-    #[allow(clippy::similar_names)]
     pub fn eq_ty(&mut self, left: &Ty<'_>, right: &Ty<'_>) -> bool {
         match (&left.kind, &right.kind) {
             (&TyKind::Slice(l_vec), &TyKind::Slice(r_vec)) => self.eq_ty(l_vec, r_vec),
@@ -560,7 +558,7 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> {
         std::mem::discriminant(&b.rules).hash(&mut self.s);
     }
 
-    #[allow(clippy::too_many_lines)]
+    #[expect(clippy::too_many_lines)]
     pub fn hash_expr(&mut self, e: &Expr<'_>) {
         let simple_const = self
             .maybe_typeck_results
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 7d46952d971..b25e9d1a6c5 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -2,6 +2,7 @@
 #![feature(control_flow_enum)]
 #![feature(let_else)]
 #![feature(let_chains)]
+#![feature(lint_reasons)]
 #![feature(once_cell)]
 #![feature(rustc_private)]
 #![recursion_limit = "512"]
@@ -35,7 +36,6 @@ extern crate rustc_typeck;
 #[macro_use]
 pub mod sym_helper;
 
-#[allow(clippy::module_name_repetitions)]
 pub mod ast_utils;
 pub mod attrs;
 pub mod comparisons;
@@ -1561,14 +1561,14 @@ pub fn int_bits(tcx: TyCtxt<'_>, ity: rustc_ty::IntTy) -> u64 {
     Integer::from_int_ty(&tcx, ity).size().bits()
 }
 
-#[allow(clippy::cast_possible_wrap)]
+#[expect(clippy::cast_possible_wrap)]
 /// Turn a constant int byte representation into an i128
 pub fn sext(tcx: TyCtxt<'_>, u: u128, ity: rustc_ty::IntTy) -> i128 {
     let amt = 128 - int_bits(tcx, ity);
     ((u as i128) << amt) >> amt
 }
 
-#[allow(clippy::cast_sign_loss)]
+#[expect(clippy::cast_sign_loss)]
 /// clip unused bytes
 pub fn unsext(tcx: TyCtxt<'_>, u: i128, ity: rustc_ty::IntTy) -> u128 {
     let amt = 128 - int_bits(tcx, ity);
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index 60971fb716d..9b9cbff2d14 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -43,9 +43,9 @@ pub const FROM_FROM: [&str; 4] = ["core", "convert", "From", "from"];
 pub const FROM_ITERATOR_METHOD: [&str; 6] = ["core", "iter", "traits", "collect", "FromIterator", "from_iter"];
 pub const FROM_STR_METHOD: [&str; 5] = ["core", "str", "traits", "FromStr", "from_str"];
 pub const FUTURE_FROM_GENERATOR: [&str; 3] = ["core", "future", "from_generator"];
-#[allow(clippy::invalid_paths)] // internal lints do not know about all external crates
+#[expect(clippy::invalid_paths)] // internal lints do not know about all external crates
 pub const FUTURES_IO_ASYNCREADEXT: [&str; 3] = ["futures_util", "io", "AsyncReadExt"];
-#[allow(clippy::invalid_paths)] // internal lints do not know about all external crates
+#[expect(clippy::invalid_paths)] // internal lints do not know about all external crates
 pub const FUTURES_IO_ASYNCWRITEEXT: [&str; 3] = ["futures_util", "io", "AsyncWriteExt"];
 pub const HASHMAP_CONTAINS_KEY: [&str; 6] = ["std", "collections", "hash", "map", "HashMap", "contains_key"];
 pub const HASHMAP_ENTRY: [&str; 5] = ["std", "collections", "hash", "map", "Entry"];
@@ -63,7 +63,7 @@ pub const IPADDR_V4: [&str; 5] = ["std", "net", "ip", "IpAddr", "V4"];
 pub const IPADDR_V6: [&str; 5] = ["std", "net", "ip", "IpAddr", "V6"];
 pub const ITER_COUNT: [&str; 6] = ["core", "iter", "traits", "iterator", "Iterator", "count"];
 pub const ITER_REPEAT: [&str; 5] = ["core", "iter", "sources", "repeat", "repeat"];
-#[allow(clippy::invalid_paths)] // internal lints do not know about all external crates
+#[expect(clippy::invalid_paths)] // internal lints do not know about all external crates
 pub const ITERTOOLS_NEXT_TUPLE: [&str; 3] = ["itertools", "Itertools", "next_tuple"];
 #[cfg(feature = "internal")]
 pub const KW_MODULE: [&str; 3] = ["rustc_span", "symbol", "kw"];
@@ -117,17 +117,17 @@ pub const RANGE_ARGUMENT_TRAIT: [&str; 3] = ["core", "ops", "RangeBounds"];
 pub const RC_PTR_EQ: [&str; 4] = ["alloc", "rc", "Rc", "ptr_eq"];
 pub const REFCELL_REF: [&str; 3] = ["core", "cell", "Ref"];
 pub const REFCELL_REFMUT: [&str; 3] = ["core", "cell", "RefMut"];
-#[allow(clippy::invalid_paths)] // internal lints do not know about all external crates
+#[expect(clippy::invalid_paths)] // internal lints do not know about all external crates
 pub const REGEX_BUILDER_NEW: [&str; 5] = ["regex", "re_builder", "unicode", "RegexBuilder", "new"];
-#[allow(clippy::invalid_paths)] // internal lints do not know about all external crates
+#[expect(clippy::invalid_paths)] // internal lints do not know about all external crates
 pub const REGEX_BYTES_BUILDER_NEW: [&str; 5] = ["regex", "re_builder", "bytes", "RegexBuilder", "new"];
-#[allow(clippy::invalid_paths)] // internal lints do not know about all external crates
+#[expect(clippy::invalid_paths)] // internal lints do not know about all external crates
 pub const REGEX_BYTES_NEW: [&str; 4] = ["regex", "re_bytes", "Regex", "new"];
-#[allow(clippy::invalid_paths)] // internal lints do not know about all external crates
+#[expect(clippy::invalid_paths)] // internal lints do not know about all external crates
 pub const REGEX_BYTES_SET_NEW: [&str; 5] = ["regex", "re_set", "bytes", "RegexSet", "new"];
-#[allow(clippy::invalid_paths)] // internal lints do not know about all external crates
+#[expect(clippy::invalid_paths)] // internal lints do not know about all external crates
 pub const REGEX_NEW: [&str; 4] = ["regex", "re_unicode", "Regex", "new"];
-#[allow(clippy::invalid_paths)] // internal lints do not know about all external crates
+#[expect(clippy::invalid_paths)] // internal lints do not know about all external crates
 pub const REGEX_SET_NEW: [&str; 5] = ["regex", "re_set", "unicode", "RegexSet", "new"];
 /// Preferably use the diagnostic item `sym::Result` where possible
 pub const RESULT: [&str; 3] = ["core", "result", "Result"];
@@ -169,9 +169,9 @@ pub const SYM_MODULE: [&str; 3] = ["rustc_span", "symbol", "sym"];
 pub const SYNTAX_CONTEXT: [&str; 3] = ["rustc_span", "hygiene", "SyntaxContext"];
 pub const TO_OWNED_METHOD: [&str; 4] = ["alloc", "borrow", "ToOwned", "to_owned"];
 pub const TO_STRING_METHOD: [&str; 4] = ["alloc", "string", "ToString", "to_string"];
-#[allow(clippy::invalid_paths)] // internal lints do not know about all external crates
+#[expect(clippy::invalid_paths)] // internal lints do not know about all external crates
 pub const TOKIO_IO_ASYNCREADEXT: [&str; 5] = ["tokio", "io", "util", "async_read_ext", "AsyncReadExt"];
-#[allow(clippy::invalid_paths)] // internal lints do not know about all external crates
+#[expect(clippy::invalid_paths)] // internal lints do not know about all external crates
 pub const TOKIO_IO_ASYNCWRITEEXT: [&str; 5] = ["tokio", "io", "util", "async_write_ext", "AsyncWriteExt"];
 pub const TRY_FROM: [&str; 4] = ["core", "convert", "TryFrom", "try_from"];
 pub const VEC_AS_MUT_SLICE: [&str; 4] = ["alloc", "vec", "Vec", "as_mut_slice"];
diff --git a/clippy_utils/src/source.rs b/clippy_utils/src/source.rs
index c69a3d8d2a1..04ef2f57447 100644
--- a/clippy_utils/src/source.rs
+++ b/clippy_utils/src/source.rs
@@ -137,7 +137,7 @@ pub fn position_before_rarrow(s: &str) -> Option<usize> {
 }
 
 /// Reindent a multiline string with possibility of ignoring the first line.
-#[allow(clippy::needless_pass_by_value)]
+#[expect(clippy::needless_pass_by_value)]
 pub fn reindent_multiline(s: Cow<'_, str>, ignore_first: bool, indent: Option<usize>) -> Cow<'_, str> {
     let s_space = reindent_multiline_inner(&s, ignore_first, indent, ' ');
     let s_tab = reindent_multiline_inner(&s_space, ignore_first, indent, '\t');
diff --git a/clippy_utils/src/sugg.rs b/clippy_utils/src/sugg.rs
index 18915553e61..855d3657dd4 100644
--- a/clippy_utils/src/sugg.rs
+++ b/clippy_utils/src/sugg.rs
@@ -50,7 +50,7 @@ impl Display for Sugg<'_> {
     }
 }
 
-#[allow(clippy::wrong_self_convention)] // ok, because of the function `as_ty` method
+#[expect(clippy::wrong_self_convention)] // ok, because of the function `as_ty` method
 impl<'a> Sugg<'a> {
     /// Prepare a suggestion from an expression.
     pub fn hir_opt(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> Option<Self> {
@@ -318,7 +318,6 @@ impl<'a> Sugg<'a> {
 
     /// Convenience method to create the `<lhs>..<rhs>` or `<lhs>...<rhs>`
     /// suggestion.
-    #[allow(dead_code)]
     pub fn range(self, end: &Self, limit: ast::RangeLimits) -> Sugg<'static> {
         match limit {
             ast::RangeLimits::HalfOpen => make_assoc(AssocOp::DotDot, &self, end),
@@ -886,7 +885,6 @@ impl<'tcx> DerefDelegate<'_, 'tcx> {
 impl<'tcx> Delegate<'tcx> for DerefDelegate<'_, 'tcx> {
     fn consume(&mut self, _: &PlaceWithHirId<'tcx>, _: HirId) {}
 
-    #[allow(clippy::too_many_lines)]
     fn borrow(&mut self, cmt: &PlaceWithHirId<'tcx>, _: HirId, _: ty::BorrowKind) {
         if let PlaceBase::Local(id) = cmt.place.base {
             let map = self.cx.tcx.hir();
diff --git a/clippy_utils/src/ty.rs b/clippy_utils/src/ty.rs
index 901e3e5390c..5767a573a27 100644
--- a/clippy_utils/src/ty.rs
+++ b/clippy_utils/src/ty.rs
@@ -603,7 +603,7 @@ impl core::ops::Add<u32> for EnumValue {
 }
 
 /// Attempts to read the given constant as though it were an an enum value.
-#[allow(clippy::cast_possible_truncation, clippy::cast_possible_wrap)]
+#[expect(clippy::cast_possible_truncation, clippy::cast_possible_wrap)]
 pub fn read_explicit_enum_value(tcx: TyCtxt<'_>, id: DefId) -> Option<EnumValue> {
     if let Ok(ConstValue::Scalar(Scalar::Int(value))) = tcx.const_eval_poly(id) {
         match tcx.type_of(id).kind() {
diff --git a/clippy_utils/src/usage.rs b/clippy_utils/src/usage.rs
index 4236e3aae2f..abba9b00558 100644
--- a/clippy_utils/src/usage.rs
+++ b/clippy_utils/src/usage.rs
@@ -44,7 +44,6 @@ struct MutVarsDelegate {
 }
 
 impl<'tcx> MutVarsDelegate {
-    #[allow(clippy::similar_names)]
     fn update(&mut self, cat: &PlaceWithHirId<'tcx>) {
         match cat.place.base {
             PlaceBase::Local(id) => {
-- 
cgit 1.4.1-3-g733a5


From bdfea1c095d0a98e759eeb680d34d2d6da51132c Mon Sep 17 00:00:00 2001
From: "Samuel E. Moelius III" <sam@moeli.us>
Date: Sun, 8 May 2022 07:13:14 -0400
Subject: Pass msrvs by copy

---
 clippy_lints/src/approx_const.rs                     |  4 +---
 clippy_lints/src/attrs.rs                            |  2 +-
 clippy_lints/src/borrow_as_ptr.rs                    |  2 +-
 clippy_lints/src/casts/cast_abs_to_unsigned.rs       |  4 ++--
 clippy_lints/src/casts/cast_lossless.rs              |  6 +++---
 clippy_lints/src/casts/cast_slice_different_sizes.rs |  4 ++--
 clippy_lints/src/casts/mod.rs                        | 10 +++++-----
 clippy_lints/src/casts/ptr_as_ptr.rs                 |  4 ++--
 clippy_lints/src/checked_conversions.rs              |  2 +-
 clippy_lints/src/from_over_into.rs                   |  2 +-
 clippy_lints/src/if_then_some_else_none.rs           |  2 +-
 clippy_lints/src/index_refutable_slice.rs            |  2 +-
 clippy_lints/src/manual_bits.rs                      |  2 +-
 clippy_lints/src/manual_non_exhaustive.rs            |  4 ++--
 clippy_lints/src/manual_strip.rs                     |  2 +-
 clippy_lints/src/map_clone.rs                        |  2 +-
 clippy_lints/src/matches/mod.rs                      |  4 ++--
 clippy_lints/src/mem_replace.rs                      |  2 +-
 clippy_lints/src/methods/cloned_instead_of_copied.rs |  6 +++---
 clippy_lints/src/methods/err_expect.rs               |  4 ++--
 clippy_lints/src/methods/filter_map_next.rs          |  4 ++--
 clippy_lints/src/methods/is_digit_ascii_radix.rs     |  4 ++--
 clippy_lints/src/methods/map_unwrap_or.rs            |  4 ++--
 clippy_lints/src/methods/mod.rs                      |  8 ++++----
 clippy_lints/src/methods/option_as_ref_deref.rs      |  4 ++--
 clippy_lints/src/methods/str_splitn.rs               |  4 ++--
 clippy_lints/src/methods/unnecessary_to_owned.rs     |  6 +++---
 clippy_lints/src/missing_const_for_fn.rs             |  4 ++--
 clippy_lints/src/ranges.rs                           |  2 +-
 clippy_lints/src/redundant_field_names.rs            |  2 +-
 clippy_lints/src/redundant_static_lifetimes.rs       |  2 +-
 clippy_lints/src/unnested_or_patterns.rs             |  8 ++++----
 clippy_lints/src/use_self.rs                         |  6 +++---
 clippy_utils/src/lib.rs                              |  4 ++--
 clippy_utils/src/qualify_min_const_fn.rs             |  8 ++++----
 doc/adding_lints.md                                  |  2 +-
 36 files changed, 70 insertions(+), 72 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/approx_const.rs b/clippy_lints/src/approx_const.rs
index e109ee0009e..da1b646f477 100644
--- a/clippy_lints/src/approx_const.rs
+++ b/clippy_lints/src/approx_const.rs
@@ -87,9 +87,7 @@ impl ApproxConstant {
         let s = s.as_str();
         if s.parse::<f64>().is_ok() {
             for &(constant, name, min_digits, msrv) in &KNOWN_CONSTS {
-                if is_approx_const(constant, s, min_digits)
-                    && msrv.as_ref().map_or(true, |msrv| meets_msrv(self.msrv.as_ref(), msrv))
-                {
+                if is_approx_const(constant, s, min_digits) && msrv.map_or(true, |msrv| meets_msrv(self.msrv, msrv)) {
                     span_lint_and_help(
                         cx,
                         APPROX_CONSTANT,
diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs
index 30dde2f0ef0..3de91f3d24a 100644
--- a/clippy_lints/src/attrs.rs
+++ b/clippy_lints/src/attrs.rs
@@ -613,7 +613,7 @@ fn check_empty_line_after_outer_attr(cx: &EarlyContext<'_>, item: &rustc_ast::It
 
 fn check_deprecated_cfg_attr(cx: &EarlyContext<'_>, attr: &Attribute, msrv: Option<RustcVersion>) {
     if_chain! {
-        if meets_msrv(msrv.as_ref(), &msrvs::TOOL_ATTRIBUTES);
+        if meets_msrv(msrv, msrvs::TOOL_ATTRIBUTES);
         // check cfg_attr
         if attr.has_name(sym::cfg_attr);
         if let Some(items) = attr.meta_item_list();
diff --git a/clippy_lints/src/borrow_as_ptr.rs b/clippy_lints/src/borrow_as_ptr.rs
index 9f8eb488c29..0993adbae2e 100644
--- a/clippy_lints/src/borrow_as_ptr.rs
+++ b/clippy_lints/src/borrow_as_ptr.rs
@@ -57,7 +57,7 @@ impl BorrowAsPtr {
 
 impl<'tcx> LateLintPass<'tcx> for BorrowAsPtr {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if !meets_msrv(self.msrv.as_ref(), &msrvs::BORROW_AS_PTR) {
+        if !meets_msrv(self.msrv, msrvs::BORROW_AS_PTR) {
             return;
         }
 
diff --git a/clippy_lints/src/casts/cast_abs_to_unsigned.rs b/clippy_lints/src/casts/cast_abs_to_unsigned.rs
index e9b0f1f672d..6bac6bf83f8 100644
--- a/clippy_lints/src/casts/cast_abs_to_unsigned.rs
+++ b/clippy_lints/src/casts/cast_abs_to_unsigned.rs
@@ -16,10 +16,10 @@ pub(super) fn check(
     cast_expr: &Expr<'_>,
     cast_from: Ty<'_>,
     cast_to: Ty<'_>,
-    msrv: &Option<RustcVersion>,
+    msrv: Option<RustcVersion>,
 ) {
     if_chain! {
-        if meets_msrv(msrv.as_ref(), &msrvs::UNSIGNED_ABS);
+        if meets_msrv(msrv, msrvs::UNSIGNED_ABS);
         if cast_from.is_integral();
         if cast_to.is_integral();
         if cast_from.is_signed();
diff --git a/clippy_lints/src/casts/cast_lossless.rs b/clippy_lints/src/casts/cast_lossless.rs
index 7717c1e9e31..938458e30ca 100644
--- a/clippy_lints/src/casts/cast_lossless.rs
+++ b/clippy_lints/src/casts/cast_lossless.rs
@@ -16,7 +16,7 @@ pub(super) fn check(
     cast_op: &Expr<'_>,
     cast_from: Ty<'_>,
     cast_to: Ty<'_>,
-    msrv: &Option<RustcVersion>,
+    msrv: Option<RustcVersion>,
 ) {
     if !should_lint(cx, expr, cast_from, cast_to, msrv) {
         return;
@@ -68,7 +68,7 @@ fn should_lint(
     expr: &Expr<'_>,
     cast_from: Ty<'_>,
     cast_to: Ty<'_>,
-    msrv: &Option<RustcVersion>,
+    msrv: Option<RustcVersion>,
 ) -> bool {
     // Do not suggest using From in consts/statics until it is valid to do so (see #2267).
     if in_constant(cx, expr.hir_id) {
@@ -95,7 +95,7 @@ fn should_lint(
             };
             !is_isize_or_usize(cast_from) && from_nbits < to_nbits
         },
-        (false, true) if matches!(cast_from.kind(), ty::Bool) && meets_msrv(msrv.as_ref(), &msrvs::FROM_BOOL) => true,
+        (false, true) if matches!(cast_from.kind(), ty::Bool) && meets_msrv(msrv, msrvs::FROM_BOOL) => true,
         (_, _) => {
             matches!(cast_from.kind(), ty::Float(FloatTy::F32)) && matches!(cast_to.kind(), ty::Float(FloatTy::F64))
         },
diff --git a/clippy_lints/src/casts/cast_slice_different_sizes.rs b/clippy_lints/src/casts/cast_slice_different_sizes.rs
index 2238668abca..bb09a6708a0 100644
--- a/clippy_lints/src/casts/cast_slice_different_sizes.rs
+++ b/clippy_lints/src/casts/cast_slice_different_sizes.rs
@@ -8,9 +8,9 @@ use rustc_semver::RustcVersion;
 
 use super::CAST_SLICE_DIFFERENT_SIZES;
 
-pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>, msrv: &Option<RustcVersion>) {
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>, msrv: Option<RustcVersion>) {
     // suggestion is invalid if `ptr::slice_from_raw_parts` does not exist
-    if !meets_msrv(msrv.as_ref(), &msrvs::PTR_SLICE_RAW_PARTS) {
+    if !meets_msrv(msrv, msrvs::PTR_SLICE_RAW_PARTS) {
         return;
     }
 
diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index 9c3ebbe035b..108e119c104 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -532,7 +532,7 @@ impl_lint_pass!(Casts => [
 impl<'tcx> LateLintPass<'tcx> for Casts {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if !in_external_macro(cx.sess(), expr.span) {
-            ptr_as_ptr::check(cx, expr, &self.msrv);
+            ptr_as_ptr::check(cx, expr, self.msrv);
         }
 
         if expr.span.from_expansion() {
@@ -562,9 +562,9 @@ impl<'tcx> LateLintPass<'tcx> for Casts {
                     cast_possible_wrap::check(cx, expr, cast_from, cast_to);
                     cast_precision_loss::check(cx, expr, cast_from, cast_to);
                     cast_sign_loss::check(cx, expr, cast_expr, cast_from, cast_to);
-                    cast_abs_to_unsigned::check(cx, expr, cast_expr, cast_from, cast_to, &self.msrv);
+                    cast_abs_to_unsigned::check(cx, expr, cast_expr, cast_from, cast_to, self.msrv);
                 }
-                cast_lossless::check(cx, expr, cast_expr, cast_from, cast_to, &self.msrv);
+                cast_lossless::check(cx, expr, cast_expr, cast_from, cast_to, self.msrv);
                 cast_enum_constructor::check(cx, expr, cast_expr, cast_from);
             }
         }
@@ -572,8 +572,8 @@ impl<'tcx> LateLintPass<'tcx> for Casts {
         cast_ref_to_mut::check(cx, expr);
         cast_ptr_alignment::check(cx, expr);
         char_lit_as_u8::check(cx, expr);
-        ptr_as_ptr::check(cx, expr, &self.msrv);
-        cast_slice_different_sizes::check(cx, expr, &self.msrv);
+        ptr_as_ptr::check(cx, expr, self.msrv);
+        cast_slice_different_sizes::check(cx, expr, self.msrv);
     }
 
     extract_msrv_attr!(LateContext);
diff --git a/clippy_lints/src/casts/ptr_as_ptr.rs b/clippy_lints/src/casts/ptr_as_ptr.rs
index fb04f93fbcf..46d45d09661 100644
--- a/clippy_lints/src/casts/ptr_as_ptr.rs
+++ b/clippy_lints/src/casts/ptr_as_ptr.rs
@@ -12,8 +12,8 @@ use rustc_semver::RustcVersion;
 
 use super::PTR_AS_PTR;
 
-pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, msrv: &Option<RustcVersion>) {
-    if !meets_msrv(msrv.as_ref(), &msrvs::POINTER_CAST) {
+pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, msrv: Option<RustcVersion>) {
+    if !meets_msrv(msrv, msrvs::POINTER_CAST) {
         return;
     }
 
diff --git a/clippy_lints/src/checked_conversions.rs b/clippy_lints/src/checked_conversions.rs
index 31cc3698592..e23428e216d 100644
--- a/clippy_lints/src/checked_conversions.rs
+++ b/clippy_lints/src/checked_conversions.rs
@@ -57,7 +57,7 @@ impl_lint_pass!(CheckedConversions => [CHECKED_CONVERSIONS]);
 
 impl<'tcx> LateLintPass<'tcx> for CheckedConversions {
     fn check_expr(&mut self, cx: &LateContext<'_>, item: &Expr<'_>) {
-        if !meets_msrv(self.msrv.as_ref(), &msrvs::TRY_FROM) {
+        if !meets_msrv(self.msrv, msrvs::TRY_FROM) {
             return;
         }
 
diff --git a/clippy_lints/src/from_over_into.rs b/clippy_lints/src/from_over_into.rs
index c2f52605151..5d25c1d0634 100644
--- a/clippy_lints/src/from_over_into.rs
+++ b/clippy_lints/src/from_over_into.rs
@@ -55,7 +55,7 @@ impl_lint_pass!(FromOverInto => [FROM_OVER_INTO]);
 
 impl<'tcx> LateLintPass<'tcx> for FromOverInto {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) {
-        if !meets_msrv(self.msrv.as_ref(), &msrvs::RE_REBALANCING_COHERENCE) {
+        if !meets_msrv(self.msrv, msrvs::RE_REBALANCING_COHERENCE) {
             return;
         }
 
diff --git a/clippy_lints/src/if_then_some_else_none.rs b/clippy_lints/src/if_then_some_else_none.rs
index 9525c163ece..b8d227855d9 100644
--- a/clippy_lints/src/if_then_some_else_none.rs
+++ b/clippy_lints/src/if_then_some_else_none.rs
@@ -57,7 +57,7 @@ impl_lint_pass!(IfThenSomeElseNone => [IF_THEN_SOME_ELSE_NONE]);
 
 impl<'tcx> LateLintPass<'tcx> for IfThenSomeElseNone {
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &'tcx Expr<'_>) {
-        if !meets_msrv(self.msrv.as_ref(), &msrvs::BOOL_THEN) {
+        if !meets_msrv(self.msrv, msrvs::BOOL_THEN) {
             return;
         }
 
diff --git a/clippy_lints/src/index_refutable_slice.rs b/clippy_lints/src/index_refutable_slice.rs
index 8a84513b779..07b0604f78d 100644
--- a/clippy_lints/src/index_refutable_slice.rs
+++ b/clippy_lints/src/index_refutable_slice.rs
@@ -75,7 +75,7 @@ impl<'tcx> LateLintPass<'tcx> for IndexRefutableSlice {
             if !expr.span.from_expansion() || is_expn_of(expr.span, "if_chain").is_some();
             if let Some(IfLet {let_pat, if_then, ..}) = IfLet::hir(cx, expr);
             if !is_lint_allowed(cx, INDEX_REFUTABLE_SLICE, expr.hir_id);
-            if meets_msrv(self.msrv.as_ref(), &msrvs::SLICE_PATTERNS);
+            if meets_msrv(self.msrv, msrvs::SLICE_PATTERNS);
 
             let found_slices = find_slice_values(cx, let_pat);
             if !found_slices.is_empty();
diff --git a/clippy_lints/src/manual_bits.rs b/clippy_lints/src/manual_bits.rs
index ac3d9447b6b..60bbcde4f1d 100644
--- a/clippy_lints/src/manual_bits.rs
+++ b/clippy_lints/src/manual_bits.rs
@@ -48,7 +48,7 @@ impl_lint_pass!(ManualBits => [MANUAL_BITS]);
 
 impl<'tcx> LateLintPass<'tcx> for ManualBits {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if !meets_msrv(self.msrv.as_ref(), &msrvs::MANUAL_BITS) {
+        if !meets_msrv(self.msrv, msrvs::MANUAL_BITS) {
             return;
         }
 
diff --git a/clippy_lints/src/manual_non_exhaustive.rs b/clippy_lints/src/manual_non_exhaustive.rs
index b8d620d8171..14f39067299 100644
--- a/clippy_lints/src/manual_non_exhaustive.rs
+++ b/clippy_lints/src/manual_non_exhaustive.rs
@@ -98,7 +98,7 @@ impl_lint_pass!(ManualNonExhaustiveEnum => [MANUAL_NON_EXHAUSTIVE]);
 
 impl EarlyLintPass for ManualNonExhaustiveStruct {
     fn check_item(&mut self, cx: &EarlyContext<'_>, item: &ast::Item) {
-        if !meets_msrv(self.msrv.as_ref(), &msrvs::NON_EXHAUSTIVE) {
+        if !meets_msrv(self.msrv, msrvs::NON_EXHAUSTIVE) {
             return;
         }
 
@@ -150,7 +150,7 @@ impl EarlyLintPass for ManualNonExhaustiveStruct {
 
 impl<'tcx> LateLintPass<'tcx> for ManualNonExhaustiveEnum {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) {
-        if !meets_msrv(self.msrv.as_ref(), &msrvs::NON_EXHAUSTIVE) {
+        if !meets_msrv(self.msrv, msrvs::NON_EXHAUSTIVE) {
             return;
         }
 
diff --git a/clippy_lints/src/manual_strip.rs b/clippy_lints/src/manual_strip.rs
index aacabf303a7..dfb3efc4e28 100644
--- a/clippy_lints/src/manual_strip.rs
+++ b/clippy_lints/src/manual_strip.rs
@@ -68,7 +68,7 @@ enum StripKind {
 
 impl<'tcx> LateLintPass<'tcx> for ManualStrip {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if !meets_msrv(self.msrv.as_ref(), &msrvs::STR_STRIP_PREFIX) {
+        if !meets_msrv(self.msrv, msrvs::STR_STRIP_PREFIX) {
             return;
         }
 
diff --git a/clippy_lints/src/map_clone.rs b/clippy_lints/src/map_clone.rs
index ceb66947d02..a13d191375b 100644
--- a/clippy_lints/src/map_clone.rs
+++ b/clippy_lints/src/map_clone.rs
@@ -144,7 +144,7 @@ impl MapClone {
     fn lint_explicit_closure(&self, cx: &LateContext<'_>, replace: Span, root: Span, is_copy: bool) {
         let mut applicability = Applicability::MachineApplicable;
 
-        let (message, sugg_method) = if is_copy && meets_msrv(self.msrv.as_ref(), &msrvs::ITERATOR_COPIED) {
+        let (message, sugg_method) = if is_copy && meets_msrv(self.msrv, msrvs::ITERATOR_COPIED) {
             ("you are using an explicit closure for copying elements", "copied")
         } else {
             ("you are using an explicit closure for cloning elements", "cloned")
diff --git a/clippy_lints/src/matches/mod.rs b/clippy_lints/src/matches/mod.rs
index 401ecef460c..3d8391bce2b 100644
--- a/clippy_lints/src/matches/mod.rs
+++ b/clippy_lints/src/matches/mod.rs
@@ -658,7 +658,7 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
             }
             if !contains_cfg_arm(cx, expr, ex, arms) {
                 if source == MatchSource::Normal {
-                    if !(meets_msrv(self.msrv.as_ref(), &msrvs::MATCHES_MACRO)
+                    if !(meets_msrv(self.msrv, msrvs::MATCHES_MACRO)
                         && match_like_matches::check_match(cx, expr, ex, arms))
                     {
                         match_same_arms::check(cx, arms);
@@ -685,7 +685,7 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
             match_wild_err_arm::check(cx, ex, arms);
             wild_in_or_pats::check(cx, arms);
         } else {
-            if meets_msrv(self.msrv.as_ref(), &msrvs::MATCHES_MACRO) {
+            if meets_msrv(self.msrv, msrvs::MATCHES_MACRO) {
                 match_like_matches::check(cx, expr);
             }
             redundant_pattern_match::check(cx, expr);
diff --git a/clippy_lints/src/mem_replace.rs b/clippy_lints/src/mem_replace.rs
index 054937e3e36..41073d40f3d 100644
--- a/clippy_lints/src/mem_replace.rs
+++ b/clippy_lints/src/mem_replace.rs
@@ -254,7 +254,7 @@ impl<'tcx> LateLintPass<'tcx> for MemReplace {
             then {
                 check_replace_option_with_none(cx, src, dest, expr.span);
                 check_replace_with_uninit(cx, src, dest, expr.span);
-                if meets_msrv(self.msrv.as_ref(), &msrvs::MEM_TAKE) {
+                if meets_msrv(self.msrv, msrvs::MEM_TAKE) {
                     check_replace_with_default(cx, src, dest, expr.span);
                 }
             }
diff --git a/clippy_lints/src/methods/cloned_instead_of_copied.rs b/clippy_lints/src/methods/cloned_instead_of_copied.rs
index 6d30bb5a278..e9aeab2d5b6 100644
--- a/clippy_lints/src/methods/cloned_instead_of_copied.rs
+++ b/clippy_lints/src/methods/cloned_instead_of_copied.rs
@@ -10,16 +10,16 @@ use rustc_span::{sym, Span};
 
 use super::CLONED_INSTEAD_OF_COPIED;
 
-pub fn check(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'_>, span: Span, msrv: Option<&RustcVersion>) {
+pub fn check(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'_>, span: Span, msrv: Option<RustcVersion>) {
     let recv_ty = cx.typeck_results().expr_ty_adjusted(recv);
     let inner_ty = match recv_ty.kind() {
         // `Option<T>` -> `T`
         ty::Adt(adt, subst)
-            if cx.tcx.is_diagnostic_item(sym::Option, adt.did()) && meets_msrv(msrv, &msrvs::OPTION_COPIED) =>
+            if cx.tcx.is_diagnostic_item(sym::Option, adt.did()) && meets_msrv(msrv, msrvs::OPTION_COPIED) =>
         {
             subst.type_at(0)
         },
-        _ if is_trait_method(cx, expr, sym::Iterator) && meets_msrv(msrv, &msrvs::ITERATOR_COPIED) => {
+        _ if is_trait_method(cx, expr, sym::Iterator) && meets_msrv(msrv, msrvs::ITERATOR_COPIED) => {
             match get_iterator_item_ty(cx, recv_ty) {
                 // <T as Iterator>::Item
                 Some(ty) => ty,
diff --git a/clippy_lints/src/methods/err_expect.rs b/clippy_lints/src/methods/err_expect.rs
index be9d4ad94fb..570a1b87358 100644
--- a/clippy_lints/src/methods/err_expect.rs
+++ b/clippy_lints/src/methods/err_expect.rs
@@ -13,7 +13,7 @@ pub(super) fn check(
     cx: &LateContext<'_>,
     _expr: &rustc_hir::Expr<'_>,
     recv: &rustc_hir::Expr<'_>,
-    msrv: Option<&RustcVersion>,
+    msrv: Option<RustcVersion>,
     expect_span: Span,
     err_span: Span,
 ) {
@@ -21,7 +21,7 @@ pub(super) fn check(
         if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(recv), sym::Result);
         // Test the version to make sure the lint can be showed (expect_err has been
         // introduced in rust 1.17.0 : https://github.com/rust-lang/rust/pull/38982)
-        if meets_msrv(msrv, &msrvs::EXPECT_ERR);
+        if meets_msrv(msrv, msrvs::EXPECT_ERR);
 
         // Grabs the `Result<T, E>` type
         let result_type = cx.typeck_results().expr_ty(recv);
diff --git a/clippy_lints/src/methods/filter_map_next.rs b/clippy_lints/src/methods/filter_map_next.rs
index f0d69a1f42e..38ec4d8e3ab 100644
--- a/clippy_lints/src/methods/filter_map_next.rs
+++ b/clippy_lints/src/methods/filter_map_next.rs
@@ -14,10 +14,10 @@ pub(super) fn check<'tcx>(
     expr: &'tcx hir::Expr<'_>,
     recv: &'tcx hir::Expr<'_>,
     arg: &'tcx hir::Expr<'_>,
-    msrv: Option<&RustcVersion>,
+    msrv: Option<RustcVersion>,
 ) {
     if is_trait_method(cx, expr, sym::Iterator) {
-        if !meets_msrv(msrv, &msrvs::ITERATOR_FIND_MAP) {
+        if !meets_msrv(msrv, msrvs::ITERATOR_FIND_MAP) {
             return;
         }
 
diff --git a/clippy_lints/src/methods/is_digit_ascii_radix.rs b/clippy_lints/src/methods/is_digit_ascii_radix.rs
index ad333df2f2d..aa176dcc8b4 100644
--- a/clippy_lints/src/methods/is_digit_ascii_radix.rs
+++ b/clippy_lints/src/methods/is_digit_ascii_radix.rs
@@ -15,9 +15,9 @@ pub(super) fn check<'tcx>(
     expr: &'tcx Expr<'_>,
     self_arg: &'tcx Expr<'_>,
     radix: &'tcx Expr<'_>,
-    msrv: Option<&RustcVersion>,
+    msrv: Option<RustcVersion>,
 ) {
-    if !meets_msrv(msrv, &msrvs::IS_ASCII_DIGIT) {
+    if !meets_msrv(msrv, msrvs::IS_ASCII_DIGIT) {
         return;
     }
 
diff --git a/clippy_lints/src/methods/map_unwrap_or.rs b/clippy_lints/src/methods/map_unwrap_or.rs
index 9ec84e76519..4a8e7ce4ddb 100644
--- a/clippy_lints/src/methods/map_unwrap_or.rs
+++ b/clippy_lints/src/methods/map_unwrap_or.rs
@@ -19,13 +19,13 @@ pub(super) fn check<'tcx>(
     recv: &'tcx hir::Expr<'_>,
     map_arg: &'tcx hir::Expr<'_>,
     unwrap_arg: &'tcx hir::Expr<'_>,
-    msrv: Option<&RustcVersion>,
+    msrv: Option<RustcVersion>,
 ) -> bool {
     // lint if the caller of `map()` is an `Option`
     let is_option = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(recv), sym::Option);
     let is_result = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(recv), sym::Result);
 
-    if is_result && !meets_msrv(msrv, &msrvs::RESULT_MAP_OR_ELSE) {
+    if is_result && !meets_msrv(msrv, msrvs::RESULT_MAP_OR_ELSE) {
         return false;
     }
 
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index f3be71f6b8b..5b073f6f3b8 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -2306,7 +2306,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             return;
         }
 
-        check_methods(cx, expr, self.msrv.as_ref());
+        check_methods(cx, expr, self.msrv);
 
         match expr.kind {
             hir::ExprKind::Call(func, args) => {
@@ -2322,7 +2322,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
                 single_char_add_str::check(cx, expr, args);
                 into_iter_on_ref::check(cx, expr, method_span, method_call.ident.name, args);
                 single_char_pattern::check(cx, expr, method_call.ident.name, args);
-                unnecessary_to_owned::check(cx, expr, method_call.ident.name, args, self.msrv.as_ref());
+                unnecessary_to_owned::check(cx, expr, method_call.ident.name, args, self.msrv);
             },
             hir::ExprKind::Binary(op, lhs, rhs) if op.node == hir::BinOpKind::Eq || op.node == hir::BinOpKind::Ne => {
                 let mut info = BinaryExprInfo {
@@ -2506,7 +2506,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
 }
 
 #[allow(clippy::too_many_lines)]
-fn check_methods<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, msrv: Option<&RustcVersion>) {
+fn check_methods<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, msrv: Option<RustcVersion>) {
     if let Some((name, [recv, args @ ..], span)) = method_call(expr) {
         match (name, args) {
             ("add" | "offset" | "sub" | "wrapping_offset" | "wrapping_add" | "wrapping_sub", [_arg]) => {
@@ -2534,7 +2534,7 @@ fn check_methods<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, msrv: Optio
                     map_collect_result_unit::check(cx, expr, m_recv, m_arg, recv);
                 },
                 Some(("take", [take_self_arg, take_arg], _)) => {
-                    if meets_msrv(msrv, &msrvs::STR_REPEAT) {
+                    if meets_msrv(msrv, msrvs::STR_REPEAT) {
                         manual_str_repeat::check(cx, expr, recv, take_self_arg, take_arg);
                     }
                 },
diff --git a/clippy_lints/src/methods/option_as_ref_deref.rs b/clippy_lints/src/methods/option_as_ref_deref.rs
index ba2d2914315..b50a173d835 100644
--- a/clippy_lints/src/methods/option_as_ref_deref.rs
+++ b/clippy_lints/src/methods/option_as_ref_deref.rs
@@ -19,9 +19,9 @@ pub(super) fn check<'tcx>(
     as_ref_recv: &hir::Expr<'_>,
     map_arg: &hir::Expr<'_>,
     is_mut: bool,
-    msrv: Option<&RustcVersion>,
+    msrv: Option<RustcVersion>,
 ) {
-    if !meets_msrv(msrv, &msrvs::OPTION_AS_DEREF) {
+    if !meets_msrv(msrv, msrvs::OPTION_AS_DEREF) {
         return;
     }
 
diff --git a/clippy_lints/src/methods/str_splitn.rs b/clippy_lints/src/methods/str_splitn.rs
index 52891eeed06..fc375763542 100644
--- a/clippy_lints/src/methods/str_splitn.rs
+++ b/clippy_lints/src/methods/str_splitn.rs
@@ -24,7 +24,7 @@ pub(super) fn check(
     self_arg: &Expr<'_>,
     pat_arg: &Expr<'_>,
     count: u128,
-    msrv: Option<&RustcVersion>,
+    msrv: Option<RustcVersion>,
 ) {
     if count < 2 || !cx.typeck_results().expr_ty_adjusted(self_arg).peel_refs().is_str() {
         return;
@@ -34,7 +34,7 @@ pub(super) fn check(
         IterUsageKind::Nth(n) => count > n + 1,
         IterUsageKind::NextTuple => count > 2,
     };
-    let manual = count == 2 && meets_msrv(msrv, &msrvs::STR_SPLIT_ONCE);
+    let manual = count == 2 && meets_msrv(msrv, msrvs::STR_SPLIT_ONCE);
 
     match parse_iter_usage(cx, expr.span.ctxt(), cx.tcx.hir().parent_iter(expr.hir_id)) {
         Some(usage) if needless(usage.kind) => lint_needless(cx, method_name, expr, self_arg, pat_arg),
diff --git a/clippy_lints/src/methods/unnecessary_to_owned.rs b/clippy_lints/src/methods/unnecessary_to_owned.rs
index 1f426979c4a..97c4feb3122 100644
--- a/clippy_lints/src/methods/unnecessary_to_owned.rs
+++ b/clippy_lints/src/methods/unnecessary_to_owned.rs
@@ -26,7 +26,7 @@ pub fn check<'tcx>(
     expr: &'tcx Expr<'tcx>,
     method_name: Symbol,
     args: &'tcx [Expr<'tcx>],
-    msrv: Option<&RustcVersion>,
+    msrv: Option<RustcVersion>,
 ) {
     if_chain! {
         if let Some(method_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
@@ -198,7 +198,7 @@ fn check_into_iter_call_arg(
     expr: &Expr<'_>,
     method_name: Symbol,
     receiver: &Expr<'_>,
-    msrv: Option<&RustcVersion>,
+    msrv: Option<RustcVersion>,
 ) -> bool {
     if_chain! {
         if let Some(parent) = get_parent_expr(cx, expr);
@@ -213,7 +213,7 @@ fn check_into_iter_call_arg(
             if unnecessary_iter_cloned::check_for_loop_iter(cx, parent, method_name, receiver, true) {
                 return true;
             }
-            let cloned_or_copied = if is_copy(cx, item_ty) && meets_msrv(msrv, &msrvs::ITERATOR_COPIED) {
+            let cloned_or_copied = if is_copy(cx, item_ty) && meets_msrv(msrv, msrvs::ITERATOR_COPIED) {
                 "copied"
             } else {
                 "cloned"
diff --git a/clippy_lints/src/missing_const_for_fn.rs b/clippy_lints/src/missing_const_for_fn.rs
index 06209bfe7b0..16d65966c10 100644
--- a/clippy_lints/src/missing_const_for_fn.rs
+++ b/clippy_lints/src/missing_const_for_fn.rs
@@ -93,7 +93,7 @@ impl<'tcx> LateLintPass<'tcx> for MissingConstForFn {
         span: Span,
         hir_id: HirId,
     ) {
-        if !meets_msrv(self.msrv.as_ref(), &msrvs::CONST_IF_MATCH) {
+        if !meets_msrv(self.msrv, msrvs::CONST_IF_MATCH) {
             return;
         }
 
@@ -146,7 +146,7 @@ impl<'tcx> LateLintPass<'tcx> for MissingConstForFn {
 
         let mir = cx.tcx.optimized_mir(def_id);
 
-        if let Err((span, err)) = is_min_const_fn(cx.tcx, mir, self.msrv.as_ref()) {
+        if let Err((span, err)) = is_min_const_fn(cx.tcx, mir, self.msrv) {
             if cx.tcx.is_const_fn_raw(def_id.to_def_id()) {
                 cx.tcx.sess.span_err(span, err.as_ref());
             }
diff --git a/clippy_lints/src/ranges.rs b/clippy_lints/src/ranges.rs
index f26f3650cb3..a47dc26f603 100644
--- a/clippy_lints/src/ranges.rs
+++ b/clippy_lints/src/ranges.rs
@@ -193,7 +193,7 @@ impl<'tcx> LateLintPass<'tcx> for Ranges {
                 check_range_zip_with_len(cx, path, args, expr.span);
             },
             ExprKind::Binary(ref op, l, r) => {
-                if meets_msrv(self.msrv.as_ref(), &msrvs::RANGE_CONTAINS) {
+                if meets_msrv(self.msrv, msrvs::RANGE_CONTAINS) {
                     check_possible_range_contains(cx, op.node, l, r, expr);
                 }
             },
diff --git a/clippy_lints/src/redundant_field_names.rs b/clippy_lints/src/redundant_field_names.rs
index 40a62fd6d20..40b03068f6c 100644
--- a/clippy_lints/src/redundant_field_names.rs
+++ b/clippy_lints/src/redundant_field_names.rs
@@ -51,7 +51,7 @@ impl_lint_pass!(RedundantFieldNames => [REDUNDANT_FIELD_NAMES]);
 
 impl EarlyLintPass for RedundantFieldNames {
     fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
-        if !meets_msrv(self.msrv.as_ref(), &msrvs::FIELD_INIT_SHORTHAND) {
+        if !meets_msrv(self.msrv, msrvs::FIELD_INIT_SHORTHAND) {
             return;
         }
 
diff --git a/clippy_lints/src/redundant_static_lifetimes.rs b/clippy_lints/src/redundant_static_lifetimes.rs
index ea5064217ab..2d26c49252f 100644
--- a/clippy_lints/src/redundant_static_lifetimes.rs
+++ b/clippy_lints/src/redundant_static_lifetimes.rs
@@ -99,7 +99,7 @@ impl RedundantStaticLifetimes {
 
 impl EarlyLintPass for RedundantStaticLifetimes {
     fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {
-        if !meets_msrv(self.msrv.as_ref(), &msrvs::STATIC_IN_CONST) {
+        if !meets_msrv(self.msrv, msrvs::STATIC_IN_CONST) {
             return;
         }
 
diff --git a/clippy_lints/src/unnested_or_patterns.rs b/clippy_lints/src/unnested_or_patterns.rs
index ae431aac83b..04e2f301bfd 100644
--- a/clippy_lints/src/unnested_or_patterns.rs
+++ b/clippy_lints/src/unnested_or_patterns.rs
@@ -61,13 +61,13 @@ impl_lint_pass!(UnnestedOrPatterns => [UNNESTED_OR_PATTERNS]);
 
 impl EarlyLintPass for UnnestedOrPatterns {
     fn check_arm(&mut self, cx: &EarlyContext<'_>, a: &ast::Arm) {
-        if meets_msrv(self.msrv.as_ref(), &msrvs::OR_PATTERNS) {
+        if meets_msrv(self.msrv, msrvs::OR_PATTERNS) {
             lint_unnested_or_patterns(cx, &a.pat);
         }
     }
 
     fn check_expr(&mut self, cx: &EarlyContext<'_>, e: &ast::Expr) {
-        if meets_msrv(self.msrv.as_ref(), &msrvs::OR_PATTERNS) {
+        if meets_msrv(self.msrv, msrvs::OR_PATTERNS) {
             if let ast::ExprKind::Let(pat, _, _) = &e.kind {
                 lint_unnested_or_patterns(cx, pat);
             }
@@ -75,13 +75,13 @@ impl EarlyLintPass for UnnestedOrPatterns {
     }
 
     fn check_param(&mut self, cx: &EarlyContext<'_>, p: &ast::Param) {
-        if meets_msrv(self.msrv.as_ref(), &msrvs::OR_PATTERNS) {
+        if meets_msrv(self.msrv, msrvs::OR_PATTERNS) {
             lint_unnested_or_patterns(cx, &p.pat);
         }
     }
 
     fn check_local(&mut self, cx: &EarlyContext<'_>, l: &ast::Local) {
-        if meets_msrv(self.msrv.as_ref(), &msrvs::OR_PATTERNS) {
+        if meets_msrv(self.msrv, msrvs::OR_PATTERNS) {
             lint_unnested_or_patterns(cx, &l.pat);
         }
     }
diff --git a/clippy_lints/src/use_self.rs b/clippy_lints/src/use_self.rs
index 138f8bccb3f..66f7748e9e0 100644
--- a/clippy_lints/src/use_self.rs
+++ b/clippy_lints/src/use_self.rs
@@ -198,7 +198,7 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
     fn check_ty(&mut self, cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>) {
         if_chain! {
             if !hir_ty.span.from_expansion();
-            if meets_msrv(self.msrv.as_ref(), &msrvs::TYPE_ALIAS_ENUM_VARIANTS);
+            if meets_msrv(self.msrv, msrvs::TYPE_ALIAS_ENUM_VARIANTS);
             if let Some(&StackItem::Check {
                 impl_id,
                 in_body,
@@ -225,7 +225,7 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
         if_chain! {
             if !expr.span.from_expansion();
-            if meets_msrv(self.msrv.as_ref(), &msrvs::TYPE_ALIAS_ENUM_VARIANTS);
+            if meets_msrv(self.msrv, msrvs::TYPE_ALIAS_ENUM_VARIANTS);
             if let Some(&StackItem::Check { impl_id, .. }) = self.stack.last();
             if cx.typeck_results().expr_ty(expr) == cx.tcx.type_of(impl_id);
             then {} else { return; }
@@ -256,7 +256,7 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
     fn check_pat(&mut self, cx: &LateContext<'_>, pat: &Pat<'_>) {
         if_chain! {
             if !pat.span.from_expansion();
-            if meets_msrv(self.msrv.as_ref(), &msrvs::TYPE_ALIAS_ENUM_VARIANTS);
+            if meets_msrv(self.msrv, msrvs::TYPE_ALIAS_ENUM_VARIANTS);
             if let Some(&StackItem::Check { impl_id, .. }) = self.stack.last();
             if let PatKind::Path(QPath::Resolved(_, path)) = pat.kind;
             if !matches!(path.res, Res::SelfTy { .. } | Res::Def(DefKind::TyParam, _));
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 7d46952d971..ed511004ea0 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -117,8 +117,8 @@ pub fn parse_msrv(msrv: &str, sess: Option<&Session>, span: Option<Span>) -> Opt
     None
 }
 
-pub fn meets_msrv(msrv: Option<&RustcVersion>, lint_msrv: &RustcVersion) -> bool {
-    msrv.map_or(true, |msrv| msrv.meets(*lint_msrv))
+pub fn meets_msrv(msrv: Option<RustcVersion>, lint_msrv: RustcVersion) -> bool {
+    msrv.map_or(true, |msrv| msrv.meets(lint_msrv))
 }
 
 #[macro_export]
diff --git a/clippy_utils/src/qualify_min_const_fn.rs b/clippy_utils/src/qualify_min_const_fn.rs
index 75808b1b174..6a8ed4e7bd7 100644
--- a/clippy_utils/src/qualify_min_const_fn.rs
+++ b/clippy_utils/src/qualify_min_const_fn.rs
@@ -19,7 +19,7 @@ use std::borrow::Cow;
 
 type McfResult = Result<(), (Span, Cow<'static, str>)>;
 
-pub fn is_min_const_fn<'a, 'tcx>(tcx: TyCtxt<'tcx>, body: &'a Body<'tcx>, msrv: Option<&RustcVersion>) -> McfResult {
+pub fn is_min_const_fn<'a, 'tcx>(tcx: TyCtxt<'tcx>, body: &'a Body<'tcx>, msrv: Option<RustcVersion>) -> McfResult {
     let def_id = body.source.def_id();
     let mut current = def_id;
     loop {
@@ -269,7 +269,7 @@ fn check_terminator<'a, 'tcx>(
     tcx: TyCtxt<'tcx>,
     body: &'a Body<'tcx>,
     terminator: &Terminator<'tcx>,
-    msrv: Option<&RustcVersion>,
+    msrv: Option<RustcVersion>,
 ) -> McfResult {
     let span = terminator.source_info.span;
     match &terminator.kind {
@@ -353,7 +353,7 @@ fn check_terminator<'a, 'tcx>(
     }
 }
 
-fn is_const_fn(tcx: TyCtxt<'_>, def_id: DefId, msrv: Option<&RustcVersion>) -> bool {
+fn is_const_fn(tcx: TyCtxt<'_>, def_id: DefId, msrv: Option<RustcVersion>) -> bool {
     tcx.is_const_fn(def_id)
         && tcx.lookup_const_stability(def_id).map_or(true, |const_stab| {
             if let rustc_attr::StabilityLevel::Stable { since } = const_stab.level {
@@ -362,7 +362,7 @@ fn is_const_fn(tcx: TyCtxt<'_>, def_id: DefId, msrv: Option<&RustcVersion>) -> b
                 // as a part of an unimplemented MSRV check https://github.com/rust-lang/rust/issues/65262.
                 crate::meets_msrv(
                     msrv,
-                    &RustcVersion::parse(since.as_str())
+                    RustcVersion::parse(since.as_str())
                         .expect("`rustc_attr::StabilityLevel::Stable::since` is ill-formatted"),
                 )
             } else {
diff --git a/doc/adding_lints.md b/doc/adding_lints.md
index 307cf2f3a90..5607e2264a6 100644
--- a/doc/adding_lints.md
+++ b/doc/adding_lints.md
@@ -432,7 +432,7 @@ The project's MSRV can then be matched against the feature MSRV in the LintPass
 using the `meets_msrv` utility function.
 
 ``` rust
-if !meets_msrv(self.msrv.as_ref(), &msrvs::STR_STRIP_PREFIX) {
+if !meets_msrv(self.msrv, msrvs::STR_STRIP_PREFIX) {
     return;
 }
 ```
-- 
cgit 1.4.1-3-g733a5


From 597f61bbe3a861c3d77b784cc701e6a975fbe842 Mon Sep 17 00:00:00 2001
From: "Samuel E. Moelius III" <sam@moeli.us>
Date: Sun, 8 May 2022 06:44:58 -0400
Subject: Optionally allow `expect` and `unwrap` in tests

---
 clippy_lints/src/lib.rs                            |  11 +-
 clippy_lints/src/methods/expect_used.rs            |   7 +-
 clippy_lints/src/methods/mod.rs                    | 368 +++++++++++----------
 clippy_lints/src/methods/unwrap_used.rs            |   7 +-
 clippy_lints/src/utils/conf.rs                     |   8 +
 tests/ui-toml/expect_used/clippy.toml              |   1 +
 tests/ui-toml/expect_used/expect_used.rs           |  29 ++
 tests/ui-toml/expect_used/expect_used.stderr       |  19 ++
 .../toml_unknown_key/conf_unknown_key.stderr       |   2 +-
 tests/ui-toml/unwrap_used/clippy.toml              |   1 +
 tests/ui-toml/unwrap_used/unwrap_used.rs           |  74 +++++
 tests/ui-toml/unwrap_used/unwrap_used.stderr       | 197 +++++++++++
 12 files changed, 543 insertions(+), 181 deletions(-)
 create mode 100644 tests/ui-toml/expect_used/clippy.toml
 create mode 100644 tests/ui-toml/expect_used/expect_used.rs
 create mode 100644 tests/ui-toml/expect_used/expect_used.stderr
 create mode 100644 tests/ui-toml/unwrap_used/clippy.toml
 create mode 100644 tests/ui-toml/unwrap_used/unwrap_used.rs
 create mode 100644 tests/ui-toml/unwrap_used/unwrap_used.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 3bb821a1482..6970757b56d 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -582,8 +582,17 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     });
 
     let avoid_breaking_exported_api = conf.avoid_breaking_exported_api;
+    let allow_expect_in_tests = conf.allow_expect_in_tests;
+    let allow_unwrap_in_tests = conf.allow_unwrap_in_tests;
     store.register_late_pass(move || Box::new(approx_const::ApproxConstant::new(msrv)));
-    store.register_late_pass(move || Box::new(methods::Methods::new(avoid_breaking_exported_api, msrv)));
+    store.register_late_pass(move || {
+        Box::new(methods::Methods::new(
+            avoid_breaking_exported_api,
+            msrv,
+            allow_expect_in_tests,
+            allow_unwrap_in_tests,
+        ))
+    });
     store.register_late_pass(move || Box::new(matches::Matches::new(msrv)));
     store.register_early_pass(move || Box::new(manual_non_exhaustive::ManualNonExhaustiveStruct::new(msrv)));
     store.register_late_pass(move || Box::new(manual_non_exhaustive::ManualNonExhaustiveEnum::new(msrv)));
diff --git a/clippy_lints/src/methods/expect_used.rs b/clippy_lints/src/methods/expect_used.rs
index 55be513c5bb..fbc3348f185 100644
--- a/clippy_lints/src/methods/expect_used.rs
+++ b/clippy_lints/src/methods/expect_used.rs
@@ -1,4 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::is_in_test_function;
 use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
@@ -7,7 +8,7 @@ use rustc_span::sym;
 use super::EXPECT_USED;
 
 /// lint use of `expect()` for `Option`s and `Result`s
-pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr<'_>) {
+pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr<'_>, allow_expect_in_tests: bool) {
     let obj_ty = cx.typeck_results().expr_ty(recv).peel_refs();
 
     let mess = if is_type_diagnostic_item(cx, obj_ty, sym::Option) {
@@ -18,6 +19,10 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr
         None
     };
 
+    if allow_expect_in_tests && is_in_test_function(cx.tcx, expr.hir_id) {
+        return;
+    }
+
     if let Some((lint, kind, none_value)) = mess {
         span_lint_and_help(
             cx,
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 5b073f6f3b8..e452614ce17 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -2200,14 +2200,23 @@ declare_clippy_lint! {
 pub struct Methods {
     avoid_breaking_exported_api: bool,
     msrv: Option<RustcVersion>,
+    allow_expect_in_tests: bool,
+    allow_unwrap_in_tests: bool,
 }
 
 impl Methods {
     #[must_use]
-    pub fn new(avoid_breaking_exported_api: bool, msrv: Option<RustcVersion>) -> Self {
+    pub fn new(
+        avoid_breaking_exported_api: bool,
+        msrv: Option<RustcVersion>,
+        allow_expect_in_tests: bool,
+        allow_unwrap_in_tests: bool,
+    ) -> Self {
         Self {
             avoid_breaking_exported_api,
             msrv,
+            allow_expect_in_tests,
+            allow_unwrap_in_tests,
         }
     }
 }
@@ -2306,7 +2315,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             return;
         }
 
-        check_methods(cx, expr, self.msrv);
+        self.check_methods(cx, expr);
 
         match expr.kind {
             hir::ExprKind::Call(func, args) => {
@@ -2505,196 +2514,201 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
     extract_msrv_attr!(LateContext);
 }
 
-#[allow(clippy::too_many_lines)]
-fn check_methods<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, msrv: Option<RustcVersion>) {
-    if let Some((name, [recv, args @ ..], span)) = method_call(expr) {
-        match (name, args) {
-            ("add" | "offset" | "sub" | "wrapping_offset" | "wrapping_add" | "wrapping_sub", [_arg]) => {
-                zst_offset::check(cx, expr, recv);
-            },
-            ("and_then", [arg]) => {
-                let biom_option_linted = bind_instead_of_map::OptionAndThenSome::check(cx, expr, recv, arg);
-                let biom_result_linted = bind_instead_of_map::ResultAndThenOk::check(cx, expr, recv, arg);
-                if !biom_option_linted && !biom_result_linted {
-                    unnecessary_lazy_eval::check(cx, expr, recv, arg, "and");
-                }
-            },
-            ("as_deref" | "as_deref_mut", []) => {
-                needless_option_as_deref::check(cx, expr, recv, name);
-            },
-            ("as_mut", []) => useless_asref::check(cx, expr, "as_mut", recv),
-            ("as_ref", []) => useless_asref::check(cx, expr, "as_ref", recv),
-            ("assume_init", []) => uninit_assumed_init::check(cx, expr, recv),
-            ("cloned", []) => cloned_instead_of_copied::check(cx, expr, recv, span, msrv),
-            ("collect", []) => match method_call(recv) {
-                Some((name @ ("cloned" | "copied"), [recv2], _)) => {
-                    iter_cloned_collect::check(cx, name, expr, recv2);
+impl Methods {
+    #[allow(clippy::too_many_lines)]
+    fn check_methods<'tcx>(&self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        if let Some((name, [recv, args @ ..], span)) = method_call(expr) {
+            match (name, args) {
+                ("add" | "offset" | "sub" | "wrapping_offset" | "wrapping_add" | "wrapping_sub", [_arg]) => {
+                    zst_offset::check(cx, expr, recv);
+                },
+                ("and_then", [arg]) => {
+                    let biom_option_linted = bind_instead_of_map::OptionAndThenSome::check(cx, expr, recv, arg);
+                    let biom_result_linted = bind_instead_of_map::ResultAndThenOk::check(cx, expr, recv, arg);
+                    if !biom_option_linted && !biom_result_linted {
+                        unnecessary_lazy_eval::check(cx, expr, recv, arg, "and");
+                    }
+                },
+                ("as_deref" | "as_deref_mut", []) => {
+                    needless_option_as_deref::check(cx, expr, recv, name);
+                },
+                ("as_mut", []) => useless_asref::check(cx, expr, "as_mut", recv),
+                ("as_ref", []) => useless_asref::check(cx, expr, "as_ref", recv),
+                ("assume_init", []) => uninit_assumed_init::check(cx, expr, recv),
+                ("cloned", []) => cloned_instead_of_copied::check(cx, expr, recv, span, self.msrv),
+                ("collect", []) => match method_call(recv) {
+                    Some((name @ ("cloned" | "copied"), [recv2], _)) => {
+                        iter_cloned_collect::check(cx, name, expr, recv2);
+                    },
+                    Some(("map", [m_recv, m_arg], _)) => {
+                        map_collect_result_unit::check(cx, expr, m_recv, m_arg, recv);
+                    },
+                    Some(("take", [take_self_arg, take_arg], _)) => {
+                        if meets_msrv(self.msrv, msrvs::STR_REPEAT) {
+                            manual_str_repeat::check(cx, expr, recv, take_self_arg, take_arg);
+                        }
+                    },
+                    _ => {},
+                },
+                (name @ "count", args @ []) => match method_call(recv) {
+                    Some(("cloned", [recv2], _)) => iter_overeager_cloned::check(cx, expr, recv2, name, args),
+                    Some((name2 @ ("into_iter" | "iter" | "iter_mut"), [recv2], _)) => {
+                        iter_count::check(cx, expr, recv2, name2);
+                    },
+                    Some(("map", [_, arg], _)) => suspicious_map::check(cx, expr, recv, arg),
+                    _ => {},
+                },
+                ("drain", [arg]) => {
+                    iter_with_drain::check(cx, expr, recv, span, arg);
+                },
+                ("expect", [_]) => match method_call(recv) {
+                    Some(("ok", [recv], _)) => ok_expect::check(cx, expr, recv),
+                    Some(("err", [recv], err_span)) => err_expect::check(cx, expr, recv, self.msrv, span, err_span),
+                    _ => expect_used::check(cx, expr, recv, self.allow_expect_in_tests),
+                },
+                ("extend", [arg]) => {
+                    string_extend_chars::check(cx, expr, recv, arg);
+                    extend_with_drain::check(cx, expr, recv, arg);
+                },
+                ("filter_map", [arg]) => {
+                    unnecessary_filter_map::check(cx, expr, arg, name);
+                    filter_map_identity::check(cx, expr, arg, span);
+                },
+                ("find_map", [arg]) => {
+                    unnecessary_filter_map::check(cx, expr, arg, name);
                 },
-                Some(("map", [m_recv, m_arg], _)) => {
-                    map_collect_result_unit::check(cx, expr, m_recv, m_arg, recv);
+                ("flat_map", [arg]) => {
+                    flat_map_identity::check(cx, expr, arg, span);
+                    flat_map_option::check(cx, expr, arg, span);
                 },
-                Some(("take", [take_self_arg, take_arg], _)) => {
-                    if meets_msrv(msrv, msrvs::STR_REPEAT) {
-                        manual_str_repeat::check(cx, expr, recv, take_self_arg, take_arg);
+                (name @ "flatten", args @ []) => match method_call(recv) {
+                    Some(("map", [recv, map_arg], map_span)) => map_flatten::check(cx, expr, recv, map_arg, map_span),
+                    Some(("cloned", [recv2], _)) => iter_overeager_cloned::check(cx, expr, recv2, name, args),
+                    _ => {},
+                },
+                ("fold", [init, acc]) => unnecessary_fold::check(cx, expr, init, acc, span),
+                ("for_each", [_]) => {
+                    if let Some(("inspect", [_, _], span2)) = method_call(recv) {
+                        inspect_for_each::check(cx, expr, span2);
                     }
                 },
-                _ => {},
-            },
-            (name @ "count", args @ []) => match method_call(recv) {
-                Some(("cloned", [recv2], _)) => iter_overeager_cloned::check(cx, expr, recv2, name, args),
-                Some((name2 @ ("into_iter" | "iter" | "iter_mut"), [recv2], _)) => {
-                    iter_count::check(cx, expr, recv2, name2);
+                ("get_or_insert_with", [arg]) => unnecessary_lazy_eval::check(cx, expr, recv, arg, "get_or_insert"),
+                ("is_file", []) => filetype_is_file::check(cx, expr, recv),
+                ("is_digit", [radix]) => is_digit_ascii_radix::check(cx, expr, recv, radix, self.msrv),
+                ("is_none", []) => check_is_some_is_none(cx, expr, recv, false),
+                ("is_some", []) => check_is_some_is_none(cx, expr, recv, true),
+                ("join", [join_arg]) => {
+                    if let Some(("collect", _, span)) = method_call(recv) {
+                        unnecessary_join::check(cx, expr, recv, join_arg, span);
+                    }
                 },
-                Some(("map", [_, arg], _)) => suspicious_map::check(cx, expr, recv, arg),
-                _ => {},
-            },
-            ("drain", [arg]) => {
-                iter_with_drain::check(cx, expr, recv, span, arg);
-            },
-            ("expect", [_]) => match method_call(recv) {
-                Some(("ok", [recv], _)) => ok_expect::check(cx, expr, recv),
-                Some(("err", [recv], err_span)) => err_expect::check(cx, expr, recv, msrv, span, err_span),
-                _ => expect_used::check(cx, expr, recv),
-            },
-            ("extend", [arg]) => {
-                string_extend_chars::check(cx, expr, recv, arg);
-                extend_with_drain::check(cx, expr, recv, arg);
-            },
-            ("filter_map", [arg]) => {
-                unnecessary_filter_map::check(cx, expr, arg, name);
-                filter_map_identity::check(cx, expr, arg, span);
-            },
-            ("find_map", [arg]) => {
-                unnecessary_filter_map::check(cx, expr, arg, name);
-            },
-            ("flat_map", [arg]) => {
-                flat_map_identity::check(cx, expr, arg, span);
-                flat_map_option::check(cx, expr, arg, span);
-            },
-            (name @ "flatten", args @ []) => match method_call(recv) {
-                Some(("map", [recv, map_arg], map_span)) => map_flatten::check(cx, expr, recv, map_arg, map_span),
-                Some(("cloned", [recv2], _)) => iter_overeager_cloned::check(cx, expr, recv2, name, args),
-                _ => {},
-            },
-            ("fold", [init, acc]) => unnecessary_fold::check(cx, expr, init, acc, span),
-            ("for_each", [_]) => {
-                if let Some(("inspect", [_, _], span2)) = method_call(recv) {
-                    inspect_for_each::check(cx, expr, span2);
-                }
-            },
-            ("get_or_insert_with", [arg]) => unnecessary_lazy_eval::check(cx, expr, recv, arg, "get_or_insert"),
-            ("is_file", []) => filetype_is_file::check(cx, expr, recv),
-            ("is_digit", [radix]) => is_digit_ascii_radix::check(cx, expr, recv, radix, msrv),
-            ("is_none", []) => check_is_some_is_none(cx, expr, recv, false),
-            ("is_some", []) => check_is_some_is_none(cx, expr, recv, true),
-            ("join", [join_arg]) => {
-                if let Some(("collect", _, span)) = method_call(recv) {
-                    unnecessary_join::check(cx, expr, recv, join_arg, span);
-                }
-            },
-            ("last", args @ []) | ("skip", args @ [_]) => {
-                if let Some((name2, [recv2, args2 @ ..], _span2)) = method_call(recv) {
-                    if let ("cloned", []) = (name2, args2) {
-                        iter_overeager_cloned::check(cx, expr, recv2, name, args);
+                ("last", args @ []) | ("skip", args @ [_]) => {
+                    if let Some((name2, [recv2, args2 @ ..], _span2)) = method_call(recv) {
+                        if let ("cloned", []) = (name2, args2) {
+                            iter_overeager_cloned::check(cx, expr, recv2, name, args);
+                        }
                     }
-                }
-            },
-            (name @ ("map" | "map_err"), [m_arg]) => {
-                if let Some((name, [recv2, args @ ..], span2)) = method_call(recv) {
-                    match (name, args) {
-                        ("as_mut", []) => option_as_ref_deref::check(cx, expr, recv2, m_arg, true, msrv),
-                        ("as_ref", []) => option_as_ref_deref::check(cx, expr, recv2, m_arg, false, msrv),
-                        ("filter", [f_arg]) => {
-                            filter_map::check(cx, expr, recv2, f_arg, span2, recv, m_arg, span, false);
-                        },
-                        ("find", [f_arg]) => filter_map::check(cx, expr, recv2, f_arg, span2, recv, m_arg, span, true),
-                        _ => {},
+                },
+                (name @ ("map" | "map_err"), [m_arg]) => {
+                    if let Some((name, [recv2, args @ ..], span2)) = method_call(recv) {
+                        match (name, args) {
+                            ("as_mut", []) => option_as_ref_deref::check(cx, expr, recv2, m_arg, true, self.msrv),
+                            ("as_ref", []) => option_as_ref_deref::check(cx, expr, recv2, m_arg, false, self.msrv),
+                            ("filter", [f_arg]) => {
+                                filter_map::check(cx, expr, recv2, f_arg, span2, recv, m_arg, span, false);
+                            },
+                            ("find", [f_arg]) => {
+                                filter_map::check(cx, expr, recv2, f_arg, span2, recv, m_arg, span, true);
+                            },
+                            _ => {},
+                        }
                     }
-                }
-                map_identity::check(cx, expr, recv, m_arg, name, span);
-            },
-            ("map_or", [def, map]) => option_map_or_none::check(cx, expr, recv, def, map),
-            (name @ "next", args @ []) => {
-                if let Some((name2, [recv2, args2 @ ..], _)) = method_call(recv) {
-                    match (name2, args2) {
-                        ("cloned", []) => iter_overeager_cloned::check(cx, expr, recv2, name, args),
-                        ("filter", [arg]) => filter_next::check(cx, expr, recv2, arg),
-                        ("filter_map", [arg]) => filter_map_next::check(cx, expr, recv2, arg, msrv),
-                        ("iter", []) => iter_next_slice::check(cx, expr, recv2),
-                        ("skip", [arg]) => iter_skip_next::check(cx, expr, recv2, arg),
-                        ("skip_while", [_]) => skip_while_next::check(cx, expr),
-                        _ => {},
+                    map_identity::check(cx, expr, recv, m_arg, name, span);
+                },
+                ("map_or", [def, map]) => option_map_or_none::check(cx, expr, recv, def, map),
+                (name @ "next", args @ []) => {
+                    if let Some((name2, [recv2, args2 @ ..], _)) = method_call(recv) {
+                        match (name2, args2) {
+                            ("cloned", []) => iter_overeager_cloned::check(cx, expr, recv2, name, args),
+                            ("filter", [arg]) => filter_next::check(cx, expr, recv2, arg),
+                            ("filter_map", [arg]) => filter_map_next::check(cx, expr, recv2, arg, self.msrv),
+                            ("iter", []) => iter_next_slice::check(cx, expr, recv2),
+                            ("skip", [arg]) => iter_skip_next::check(cx, expr, recv2, arg),
+                            ("skip_while", [_]) => skip_while_next::check(cx, expr),
+                            _ => {},
+                        }
                     }
-                }
-            },
-            ("nth", args @ [n_arg]) => match method_call(recv) {
-                Some(("bytes", [recv2], _)) => bytes_nth::check(cx, expr, recv2, n_arg),
-                Some(("cloned", [recv2], _)) => iter_overeager_cloned::check(cx, expr, recv2, name, args),
-                Some(("iter", [recv2], _)) => iter_nth::check(cx, expr, recv2, recv, n_arg, false),
-                Some(("iter_mut", [recv2], _)) => iter_nth::check(cx, expr, recv2, recv, n_arg, true),
-                _ => iter_nth_zero::check(cx, expr, recv, n_arg),
-            },
-            ("ok_or_else", [arg]) => unnecessary_lazy_eval::check(cx, expr, recv, arg, "ok_or"),
-            ("or_else", [arg]) => {
-                if !bind_instead_of_map::ResultOrElseErrInfo::check(cx, expr, recv, arg) {
-                    unnecessary_lazy_eval::check(cx, expr, recv, arg, "or");
-                }
-            },
-            ("splitn" | "rsplitn", [count_arg, pat_arg]) => {
-                if let Some((Constant::Int(count), _)) = constant(cx, cx.typeck_results(), count_arg) {
-                    suspicious_splitn::check(cx, name, expr, recv, count);
-                    str_splitn::check(cx, name, expr, recv, pat_arg, count, msrv);
-                }
-            },
-            ("splitn_mut" | "rsplitn_mut", [count_arg, _]) => {
-                if let Some((Constant::Int(count), _)) = constant(cx, cx.typeck_results(), count_arg) {
-                    suspicious_splitn::check(cx, name, expr, recv, count);
-                }
-            },
-            ("step_by", [arg]) => iterator_step_by_zero::check(cx, expr, arg),
-            ("take", args @ [_arg]) => {
-                if let Some((name2, [recv2, args2 @ ..], _span2)) = method_call(recv) {
-                    if let ("cloned", []) = (name2, args2) {
-                        iter_overeager_cloned::check(cx, expr, recv2, name, args);
+                },
+                ("nth", args @ [n_arg]) => match method_call(recv) {
+                    Some(("bytes", [recv2], _)) => bytes_nth::check(cx, expr, recv2, n_arg),
+                    Some(("cloned", [recv2], _)) => iter_overeager_cloned::check(cx, expr, recv2, name, args),
+                    Some(("iter", [recv2], _)) => iter_nth::check(cx, expr, recv2, recv, n_arg, false),
+                    Some(("iter_mut", [recv2], _)) => iter_nth::check(cx, expr, recv2, recv, n_arg, true),
+                    _ => iter_nth_zero::check(cx, expr, recv, n_arg),
+                },
+                ("ok_or_else", [arg]) => unnecessary_lazy_eval::check(cx, expr, recv, arg, "ok_or"),
+                ("or_else", [arg]) => {
+                    if !bind_instead_of_map::ResultOrElseErrInfo::check(cx, expr, recv, arg) {
+                        unnecessary_lazy_eval::check(cx, expr, recv, arg, "or");
                     }
-                }
-            },
-            ("take", []) => needless_option_take::check(cx, expr, recv),
-            ("to_os_string" | "to_owned" | "to_path_buf" | "to_vec", []) => {
-                implicit_clone::check(cx, name, expr, recv);
-            },
-            ("unwrap", []) => {
-                match method_call(recv) {
-                    Some(("get", [recv, get_arg], _)) => {
-                        get_unwrap::check(cx, expr, recv, get_arg, false);
-                    },
-                    Some(("get_mut", [recv, get_arg], _)) => {
-                        get_unwrap::check(cx, expr, recv, get_arg, true);
+                },
+                ("splitn" | "rsplitn", [count_arg, pat_arg]) => {
+                    if let Some((Constant::Int(count), _)) = constant(cx, cx.typeck_results(), count_arg) {
+                        suspicious_splitn::check(cx, name, expr, recv, count);
+                        str_splitn::check(cx, name, expr, recv, pat_arg, count, self.msrv);
+                    }
+                },
+                ("splitn_mut" | "rsplitn_mut", [count_arg, _]) => {
+                    if let Some((Constant::Int(count), _)) = constant(cx, cx.typeck_results(), count_arg) {
+                        suspicious_splitn::check(cx, name, expr, recv, count);
+                    }
+                },
+                ("step_by", [arg]) => iterator_step_by_zero::check(cx, expr, arg),
+                ("take", args @ [_arg]) => {
+                    if let Some((name2, [recv2, args2 @ ..], _span2)) = method_call(recv) {
+                        if let ("cloned", []) = (name2, args2) {
+                            iter_overeager_cloned::check(cx, expr, recv2, name, args);
+                        }
+                    }
+                },
+                ("take", []) => needless_option_take::check(cx, expr, recv),
+                ("to_os_string" | "to_owned" | "to_path_buf" | "to_vec", []) => {
+                    implicit_clone::check(cx, name, expr, recv);
+                },
+                ("unwrap", []) => {
+                    match method_call(recv) {
+                        Some(("get", [recv, get_arg], _)) => {
+                            get_unwrap::check(cx, expr, recv, get_arg, false);
+                        },
+                        Some(("get_mut", [recv, get_arg], _)) => {
+                            get_unwrap::check(cx, expr, recv, get_arg, true);
+                        },
+                        Some(("or", [recv, or_arg], or_span)) => {
+                            or_then_unwrap::check(cx, expr, recv, or_arg, or_span);
+                        },
+                        _ => {},
+                    }
+                    unwrap_used::check(cx, expr, recv, self.allow_unwrap_in_tests);
+                },
+                ("unwrap_or", [u_arg]) => match method_call(recv) {
+                    Some((arith @ ("checked_add" | "checked_sub" | "checked_mul"), [lhs, rhs], _)) => {
+                        manual_saturating_arithmetic::check(cx, expr, lhs, rhs, u_arg, &arith["checked_".len()..]);
                     },
-                    Some(("or", [recv, or_arg], or_span)) => {
-                        or_then_unwrap::check(cx, expr, recv, or_arg, or_span);
+                    Some(("map", [m_recv, m_arg], span)) => {
+                        option_map_unwrap_or::check(cx, expr, m_recv, m_arg, recv, u_arg, span);
                     },
                     _ => {},
-                }
-                unwrap_used::check(cx, expr, recv);
-            },
-            ("unwrap_or", [u_arg]) => match method_call(recv) {
-                Some((arith @ ("checked_add" | "checked_sub" | "checked_mul"), [lhs, rhs], _)) => {
-                    manual_saturating_arithmetic::check(cx, expr, lhs, rhs, u_arg, &arith["checked_".len()..]);
                 },
-                Some(("map", [m_recv, m_arg], span)) => {
-                    option_map_unwrap_or::check(cx, expr, m_recv, m_arg, recv, u_arg, span);
+                ("unwrap_or_else", [u_arg]) => match method_call(recv) {
+                    Some(("map", [recv, map_arg], _))
+                        if map_unwrap_or::check(cx, expr, recv, map_arg, u_arg, self.msrv) => {},
+                    _ => {
+                        unwrap_or_else_default::check(cx, expr, recv, u_arg);
+                        unnecessary_lazy_eval::check(cx, expr, recv, u_arg, "unwrap_or");
+                    },
                 },
                 _ => {},
-            },
-            ("unwrap_or_else", [u_arg]) => match method_call(recv) {
-                Some(("map", [recv, map_arg], _)) if map_unwrap_or::check(cx, expr, recv, map_arg, u_arg, msrv) => {},
-                _ => {
-                    unwrap_or_else_default::check(cx, expr, recv, u_arg);
-                    unnecessary_lazy_eval::check(cx, expr, recv, u_arg, "unwrap_or");
-                },
-            },
-            _ => {},
+            }
         }
     }
 }
diff --git a/clippy_lints/src/methods/unwrap_used.rs b/clippy_lints/src/methods/unwrap_used.rs
index 44676d78c60..5c761014927 100644
--- a/clippy_lints/src/methods/unwrap_used.rs
+++ b/clippy_lints/src/methods/unwrap_used.rs
@@ -1,4 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::is_in_test_function;
 use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
@@ -7,7 +8,7 @@ use rustc_span::sym;
 use super::UNWRAP_USED;
 
 /// lint use of `unwrap()` for `Option`s and `Result`s
-pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr<'_>) {
+pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr<'_>, allow_unwrap_in_tests: bool) {
     let obj_ty = cx.typeck_results().expr_ty(recv).peel_refs();
 
     let mess = if is_type_diagnostic_item(cx, obj_ty, sym::Option) {
@@ -18,6 +19,10 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr
         None
     };
 
+    if allow_unwrap_in_tests && is_in_test_function(cx.tcx, expr.hir_id) {
+        return;
+    }
+
     if let Some((lint, kind, none_value)) = mess {
         span_lint_and_help(
             cx,
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 74b0168a179..bdcd76d153f 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -316,6 +316,14 @@ define_Conf! {
     ///
     /// The maximum size of a file included via `include_bytes!()` or `include_str!()`, in bytes
     (max_include_file_size: u64 = 1_000_000),
+    /// Lint: EXPECT_USED.
+    ///
+    /// Whether `expect` should be allowed in test functions
+    (allow_expect_in_tests: bool = false),
+    /// Lint: UNWRAP_USED.
+    ///
+    /// Whether `unwrap` should be allowed in test functions
+    (allow_unwrap_in_tests: bool = false),
 }
 
 /// Search for the configuration file.
diff --git a/tests/ui-toml/expect_used/clippy.toml b/tests/ui-toml/expect_used/clippy.toml
new file mode 100644
index 00000000000..6933b816419
--- /dev/null
+++ b/tests/ui-toml/expect_used/clippy.toml
@@ -0,0 +1 @@
+allow-expect-in-tests = true
diff --git a/tests/ui-toml/expect_used/expect_used.rs b/tests/ui-toml/expect_used/expect_used.rs
new file mode 100644
index 00000000000..22dcd3ae9d6
--- /dev/null
+++ b/tests/ui-toml/expect_used/expect_used.rs
@@ -0,0 +1,29 @@
+// compile-flags: --test
+#![warn(clippy::expect_used)]
+
+fn expect_option() {
+    let opt = Some(0);
+    let _ = opt.expect("");
+}
+
+fn expect_result() {
+    let res: Result<u8, ()> = Ok(0);
+    let _ = res.expect("");
+}
+
+fn main() {
+    expect_option();
+    expect_result();
+}
+
+#[test]
+fn test_expect_option() {
+    let opt = Some(0);
+    let _ = opt.expect("");
+}
+
+#[test]
+fn test_expect_result() {
+    let res: Result<u8, ()> = Ok(0);
+    let _ = res.expect("");
+}
diff --git a/tests/ui-toml/expect_used/expect_used.stderr b/tests/ui-toml/expect_used/expect_used.stderr
new file mode 100644
index 00000000000..9cb2199ed21
--- /dev/null
+++ b/tests/ui-toml/expect_used/expect_used.stderr
@@ -0,0 +1,19 @@
+error: used `expect()` on `an Option` value
+  --> $DIR/expect_used.rs:6:13
+   |
+LL |     let _ = opt.expect("");
+   |             ^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::expect-used` implied by `-D warnings`
+   = help: if this value is an `None`, it will panic
+
+error: used `expect()` on `a Result` value
+  --> $DIR/expect_used.rs:11:13
+   |
+LL |     let _ = res.expect("");
+   |             ^^^^^^^^^^^^^^
+   |
+   = help: if this value is an `Err`, it will panic
+
+error: aborting due to 2 previous errors
+
diff --git a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
index 8701809b4da..65277dd03e8 100644
--- a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
+++ b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
@@ -1,4 +1,4 @@
-error: error reading Clippy's configuration file `$DIR/clippy.toml`: unknown field `foobar`, expected one of `avoid-breaking-exported-api`, `msrv`, `blacklisted-names`, `cognitive-complexity-threshold`, `cyclomatic-complexity-threshold`, `doc-valid-idents`, `too-many-arguments-threshold`, `type-complexity-threshold`, `single-char-binding-names-threshold`, `too-large-for-stack`, `enum-variant-name-threshold`, `enum-variant-size-threshold`, `verbose-bit-mask-threshold`, `literal-representation-threshold`, `trivial-copy-size-limit`, `pass-by-value-size-limit`, `too-many-lines-threshold`, `array-size-threshold`, `vec-box-size-threshold`, `max-trait-bounds`, `max-struct-bools`, `max-fn-params-bools`, `warn-on-all-wildcard-imports`, `disallowed-methods`, `disallowed-types`, `unreadable-literal-lint-fractions`, `upper-case-acronyms-aggressive`, `cargo-ignore-publish`, `standard-macro-braces`, `enforced-import-renames`, `allowed-scripts`, `enable-raw-pointer-heuristic-for-send`, `max-suggested-slice-pattern-length`, `await-holding-invalid-types`, `max-include-file-size`, `third-party` at line 5 column 1
+error: error reading Clippy's configuration file `$DIR/clippy.toml`: unknown field `foobar`, expected one of `avoid-breaking-exported-api`, `msrv`, `blacklisted-names`, `cognitive-complexity-threshold`, `cyclomatic-complexity-threshold`, `doc-valid-idents`, `too-many-arguments-threshold`, `type-complexity-threshold`, `single-char-binding-names-threshold`, `too-large-for-stack`, `enum-variant-name-threshold`, `enum-variant-size-threshold`, `verbose-bit-mask-threshold`, `literal-representation-threshold`, `trivial-copy-size-limit`, `pass-by-value-size-limit`, `too-many-lines-threshold`, `array-size-threshold`, `vec-box-size-threshold`, `max-trait-bounds`, `max-struct-bools`, `max-fn-params-bools`, `warn-on-all-wildcard-imports`, `disallowed-methods`, `disallowed-types`, `unreadable-literal-lint-fractions`, `upper-case-acronyms-aggressive`, `cargo-ignore-publish`, `standard-macro-braces`, `enforced-import-renames`, `allowed-scripts`, `enable-raw-pointer-heuristic-for-send`, `max-suggested-slice-pattern-length`, `await-holding-invalid-types`, `max-include-file-size`, `allow-expect-in-tests`, `allow-unwrap-in-tests`, `third-party` at line 5 column 1
 
 error: aborting due to previous error
 
diff --git a/tests/ui-toml/unwrap_used/clippy.toml b/tests/ui-toml/unwrap_used/clippy.toml
new file mode 100644
index 00000000000..154626ef4e8
--- /dev/null
+++ b/tests/ui-toml/unwrap_used/clippy.toml
@@ -0,0 +1 @@
+allow-unwrap-in-tests = true
diff --git a/tests/ui-toml/unwrap_used/unwrap_used.rs b/tests/ui-toml/unwrap_used/unwrap_used.rs
new file mode 100644
index 00000000000..a639de07971
--- /dev/null
+++ b/tests/ui-toml/unwrap_used/unwrap_used.rs
@@ -0,0 +1,74 @@
+// compile-flags: --test
+
+#![allow(unused_mut, clippy::from_iter_instead_of_collect)]
+#![warn(clippy::unwrap_used)]
+#![deny(clippy::get_unwrap)]
+
+use std::collections::BTreeMap;
+use std::collections::HashMap;
+use std::collections::VecDeque;
+use std::iter::FromIterator;
+
+struct GetFalsePositive {
+    arr: [u32; 3],
+}
+
+impl GetFalsePositive {
+    fn get(&self, pos: usize) -> Option<&u32> {
+        self.arr.get(pos)
+    }
+    fn get_mut(&mut self, pos: usize) -> Option<&mut u32> {
+        self.arr.get_mut(pos)
+    }
+}
+
+fn main() {
+    let mut boxed_slice: Box<[u8]> = Box::new([0, 1, 2, 3]);
+    let mut some_slice = &mut [0, 1, 2, 3];
+    let mut some_vec = vec![0, 1, 2, 3];
+    let mut some_vecdeque: VecDeque<_> = some_vec.iter().cloned().collect();
+    let mut some_hashmap: HashMap<u8, char> = HashMap::from_iter(vec![(1, 'a'), (2, 'b')]);
+    let mut some_btreemap: BTreeMap<u8, char> = BTreeMap::from_iter(vec![(1, 'a'), (2, 'b')]);
+    let mut false_positive = GetFalsePositive { arr: [0, 1, 2] };
+
+    {
+        // Test `get().unwrap()`
+        let _ = boxed_slice.get(1).unwrap();
+        let _ = some_slice.get(0).unwrap();
+        let _ = some_vec.get(0).unwrap();
+        let _ = some_vecdeque.get(0).unwrap();
+        let _ = some_hashmap.get(&1).unwrap();
+        let _ = some_btreemap.get(&1).unwrap();
+        #[allow(clippy::unwrap_used)]
+        let _ = false_positive.get(0).unwrap();
+        // Test with deref
+        let _: u8 = *boxed_slice.get(1).unwrap();
+    }
+
+    {
+        // Test `get_mut().unwrap()`
+        *boxed_slice.get_mut(0).unwrap() = 1;
+        *some_slice.get_mut(0).unwrap() = 1;
+        *some_vec.get_mut(0).unwrap() = 1;
+        *some_vecdeque.get_mut(0).unwrap() = 1;
+        // Check false positives
+        #[allow(clippy::unwrap_used)]
+        {
+            *some_hashmap.get_mut(&1).unwrap() = 'b';
+            *some_btreemap.get_mut(&1).unwrap() = 'b';
+            *false_positive.get_mut(0).unwrap() = 1;
+        }
+    }
+
+    {
+        // Test `get().unwrap().foo()` and `get_mut().unwrap().bar()`
+        let _ = some_vec.get(0..1).unwrap().to_vec();
+        let _ = some_vec.get_mut(0..1).unwrap().to_vec();
+    }
+}
+
+#[test]
+fn test() {
+    let boxed_slice: Box<[u8]> = Box::new([0, 1, 2, 3]);
+    let _ = boxed_slice.get(1).unwrap();
+}
diff --git a/tests/ui-toml/unwrap_used/unwrap_used.stderr b/tests/ui-toml/unwrap_used/unwrap_used.stderr
new file mode 100644
index 00000000000..6c3adc5395f
--- /dev/null
+++ b/tests/ui-toml/unwrap_used/unwrap_used.stderr
@@ -0,0 +1,197 @@
+error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more concise
+  --> $DIR/unwrap_used.rs:36:17
+   |
+LL |         let _ = boxed_slice.get(1).unwrap();
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&boxed_slice[1]`
+   |
+note: the lint level is defined here
+  --> $DIR/unwrap_used.rs:5:9
+   |
+LL | #![deny(clippy::get_unwrap)]
+   |         ^^^^^^^^^^^^^^^^^^
+
+error: used `unwrap()` on `an Option` value
+  --> $DIR/unwrap_used.rs:36:17
+   |
+LL |         let _ = boxed_slice.get(1).unwrap();
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::unwrap-used` implied by `-D warnings`
+   = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
+
+error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more concise
+  --> $DIR/unwrap_used.rs:37:17
+   |
+LL |         let _ = some_slice.get(0).unwrap();
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&some_slice[0]`
+
+error: used `unwrap()` on `an Option` value
+  --> $DIR/unwrap_used.rs:37:17
+   |
+LL |         let _ = some_slice.get(0).unwrap();
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
+
+error: called `.get().unwrap()` on a Vec. Using `[]` is more clear and more concise
+  --> $DIR/unwrap_used.rs:38:17
+   |
+LL |         let _ = some_vec.get(0).unwrap();
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&some_vec[0]`
+
+error: used `unwrap()` on `an Option` value
+  --> $DIR/unwrap_used.rs:38:17
+   |
+LL |         let _ = some_vec.get(0).unwrap();
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
+
+error: called `.get().unwrap()` on a VecDeque. Using `[]` is more clear and more concise
+  --> $DIR/unwrap_used.rs:39:17
+   |
+LL |         let _ = some_vecdeque.get(0).unwrap();
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&some_vecdeque[0]`
+
+error: used `unwrap()` on `an Option` value
+  --> $DIR/unwrap_used.rs:39:17
+   |
+LL |         let _ = some_vecdeque.get(0).unwrap();
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
+
+error: called `.get().unwrap()` on a HashMap. Using `[]` is more clear and more concise
+  --> $DIR/unwrap_used.rs:40:17
+   |
+LL |         let _ = some_hashmap.get(&1).unwrap();
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&some_hashmap[&1]`
+
+error: used `unwrap()` on `an Option` value
+  --> $DIR/unwrap_used.rs:40:17
+   |
+LL |         let _ = some_hashmap.get(&1).unwrap();
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
+
+error: called `.get().unwrap()` on a BTreeMap. Using `[]` is more clear and more concise
+  --> $DIR/unwrap_used.rs:41:17
+   |
+LL |         let _ = some_btreemap.get(&1).unwrap();
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&some_btreemap[&1]`
+
+error: used `unwrap()` on `an Option` value
+  --> $DIR/unwrap_used.rs:41:17
+   |
+LL |         let _ = some_btreemap.get(&1).unwrap();
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
+
+error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more concise
+  --> $DIR/unwrap_used.rs:45:21
+   |
+LL |         let _: u8 = *boxed_slice.get(1).unwrap();
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `boxed_slice[1]`
+
+error: used `unwrap()` on `an Option` value
+  --> $DIR/unwrap_used.rs:45:22
+   |
+LL |         let _: u8 = *boxed_slice.get(1).unwrap();
+   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
+
+error: called `.get_mut().unwrap()` on a slice. Using `[]` is more clear and more concise
+  --> $DIR/unwrap_used.rs:50:9
+   |
+LL |         *boxed_slice.get_mut(0).unwrap() = 1;
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `boxed_slice[0]`
+
+error: used `unwrap()` on `an Option` value
+  --> $DIR/unwrap_used.rs:50:10
+   |
+LL |         *boxed_slice.get_mut(0).unwrap() = 1;
+   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
+
+error: called `.get_mut().unwrap()` on a slice. Using `[]` is more clear and more concise
+  --> $DIR/unwrap_used.rs:51:9
+   |
+LL |         *some_slice.get_mut(0).unwrap() = 1;
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `some_slice[0]`
+
+error: used `unwrap()` on `an Option` value
+  --> $DIR/unwrap_used.rs:51:10
+   |
+LL |         *some_slice.get_mut(0).unwrap() = 1;
+   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
+
+error: called `.get_mut().unwrap()` on a Vec. Using `[]` is more clear and more concise
+  --> $DIR/unwrap_used.rs:52:9
+   |
+LL |         *some_vec.get_mut(0).unwrap() = 1;
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `some_vec[0]`
+
+error: used `unwrap()` on `an Option` value
+  --> $DIR/unwrap_used.rs:52:10
+   |
+LL |         *some_vec.get_mut(0).unwrap() = 1;
+   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
+
+error: called `.get_mut().unwrap()` on a VecDeque. Using `[]` is more clear and more concise
+  --> $DIR/unwrap_used.rs:53:9
+   |
+LL |         *some_vecdeque.get_mut(0).unwrap() = 1;
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `some_vecdeque[0]`
+
+error: used `unwrap()` on `an Option` value
+  --> $DIR/unwrap_used.rs:53:10
+   |
+LL |         *some_vecdeque.get_mut(0).unwrap() = 1;
+   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
+
+error: called `.get().unwrap()` on a Vec. Using `[]` is more clear and more concise
+  --> $DIR/unwrap_used.rs:65:17
+   |
+LL |         let _ = some_vec.get(0..1).unwrap().to_vec();
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `some_vec[0..1]`
+
+error: used `unwrap()` on `an Option` value
+  --> $DIR/unwrap_used.rs:65:17
+   |
+LL |         let _ = some_vec.get(0..1).unwrap().to_vec();
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
+
+error: called `.get_mut().unwrap()` on a Vec. Using `[]` is more clear and more concise
+  --> $DIR/unwrap_used.rs:66:17
+   |
+LL |         let _ = some_vec.get_mut(0..1).unwrap().to_vec();
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `some_vec[0..1]`
+
+error: used `unwrap()` on `an Option` value
+  --> $DIR/unwrap_used.rs:66:17
+   |
+LL |         let _ = some_vec.get_mut(0..1).unwrap().to_vec();
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
+
+error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more concise
+  --> $DIR/unwrap_used.rs:73:13
+   |
+LL |     let _ = boxed_slice.get(1).unwrap();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&boxed_slice[1]`
+
+error: aborting due to 27 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 5e4f0922911536f80d9591180fa604229ac13939 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Mon, 9 May 2022 14:06:46 +0100
Subject: use let chains in bit_mask.rs

---
 clippy_lints/src/bit_mask.rs | 40 ++++++++++++++++++++--------------------
 1 file changed, 20 insertions(+), 20 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/bit_mask.rs b/clippy_lints/src/bit_mask.rs
index ca4af66cad1..dc7e400fdc2 100644
--- a/clippy_lints/src/bit_mask.rs
+++ b/clippy_lints/src/bit_mask.rs
@@ -1,7 +1,6 @@
 use clippy_utils::consts::{constant, Constant};
 use clippy_utils::diagnostics::{span_lint, span_lint_and_then};
 use clippy_utils::sugg::Sugg;
-use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind};
@@ -130,23 +129,24 @@ impl<'tcx> LateLintPass<'tcx> for BitMask {
                 }
             }
         }
-        if_chain! {
-            if let ExprKind::Binary(op, left, right) = &e.kind;
-            if BinOpKind::Eq == op.node;
-            if let ExprKind::Binary(op1, left1, right1) = &left.kind;
-            if BinOpKind::BitAnd == op1.node;
-            if let ExprKind::Lit(lit) = &right1.kind;
-            if let LitKind::Int(n, _) = lit.node;
-            if let ExprKind::Lit(lit1) = &right.kind;
-            if let LitKind::Int(0, _) = lit1.node;
-            if n.leading_zeros() == n.count_zeros();
-            if n > u128::from(self.verbose_bit_mask_threshold);
-            then {
-                span_lint_and_then(cx,
-                                   VERBOSE_BIT_MASK,
-                                   e.span,
-                                   "bit mask could be simplified with a call to `trailing_zeros`",
-                                   |diag| {
+
+        if let ExprKind::Binary(op, left, right) = &e.kind
+            && BinOpKind::Eq == op.node
+            && let ExprKind::Binary(op1, left1, right1) = &left.kind
+            && BinOpKind::BitAnd == op1.node
+            && let ExprKind::Lit(lit) = &right1.kind
+            && let LitKind::Int(n, _) = lit.node
+            && let ExprKind::Lit(lit1) = &right.kind
+            && let LitKind::Int(0, _) = lit1.node
+            && n.leading_zeros() == n.count_zeros()
+            && n > u128::from(self.verbose_bit_mask_threshold)
+        {
+            span_lint_and_then(
+                cx,
+                VERBOSE_BIT_MASK,
+                e.span,
+                "bit mask could be simplified with a call to `trailing_zeros`",
+                |diag| {
                     let sugg = Sugg::hir(cx, left1, "...").maybe_par();
                     diag.span_suggestion(
                         e.span,
@@ -154,8 +154,8 @@ impl<'tcx> LateLintPass<'tcx> for BitMask {
                         format!("{}.trailing_zeros() >= {}", sugg, n.count_ones()),
                         Applicability::MaybeIncorrect,
                     );
-                });
-            }
+                },
+            );
         }
     }
 }
-- 
cgit 1.4.1-3-g733a5


From 0f1544f15ed774f25388c0420997e52a56d19d06 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Mon, 9 May 2022 11:41:25 -0400
Subject: Reduce unnecessary work in `cmp_owned`

---
 clippy_lints/src/misc.rs | 46 ++++++++++++++++++++++------------------------
 1 file changed, 22 insertions(+), 24 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/misc.rs b/clippy_lints/src/misc.rs
index ac82dd306a5..18a98fc6f84 100644
--- a/clippy_lints/src/misc.rs
+++ b/clippy_lints/src/misc.rs
@@ -20,8 +20,8 @@ use rustc_span::symbol::sym;
 use clippy_utils::consts::{constant, Constant};
 use clippy_utils::sugg::Sugg;
 use clippy_utils::{
-    get_item_name, get_parent_expr, in_constant, is_diag_trait_item, is_integer_const, iter_input_pats,
-    last_path_segment, match_any_def_paths, path_def_id, paths, unsext, SpanlessEq,
+    get_item_name, get_parent_expr, in_constant, is_integer_const, iter_input_pats, last_path_segment,
+    match_any_def_paths, path_def_id, paths, unsext, SpanlessEq,
 };
 
 declare_clippy_lint! {
@@ -569,33 +569,30 @@ fn check_to_owned(cx: &LateContext<'_>, expr: &Expr<'_>, other: &Expr<'_>, left:
         })
     }
 
-    let (arg_ty, snip) = match expr.kind {
-        ExprKind::MethodCall(.., args, _) if args.len() == 1 => {
-            if_chain!(
-                if let Some(expr_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
-                if is_diag_trait_item(cx, expr_def_id, sym::ToString)
-                    || is_diag_trait_item(cx, expr_def_id, sym::ToOwned);
-                then {
-                    (cx.typeck_results().expr_ty(&args[0]), snippet(cx, args[0].span, ".."))
-                } else {
-                    return;
-                }
-            )
+    let typeck = cx.typeck_results();
+    let (arg, arg_span) = match expr.kind {
+        ExprKind::MethodCall(.., [arg], _)
+            if typeck
+                .type_dependent_def_id(expr.hir_id)
+                .and_then(|id| cx.tcx.trait_of_item(id))
+                .map_or(false, |id| {
+                    matches!(cx.tcx.get_diagnostic_name(id), Some(sym::ToString | sym::ToOwned))
+                }) =>
+        {
+            (arg, arg.span)
         },
-        ExprKind::Call(path, [arg]) => {
+        ExprKind::Call(path, [arg])
             if path_def_id(cx, path)
                 .and_then(|id| match_any_def_paths(cx, id, &[&paths::FROM_STR_METHOD, &paths::FROM_FROM]))
-                .is_some()
-            {
-                (cx.typeck_results().expr_ty(arg), snippet(cx, arg.span, ".."))
-            } else {
-                return;
-            }
+                .is_some() =>
+        {
+            (arg, arg.span)
         },
         _ => return,
     };
 
-    let other_ty = cx.typeck_results().expr_ty(other);
+    let arg_ty = typeck.expr_ty(arg);
+    let other_ty = typeck.expr_ty(other);
 
     let without_deref = symmetric_partial_eq(cx, arg_ty, other_ty).unwrap_or_default();
     let with_deref = arg_ty
@@ -627,13 +624,14 @@ fn check_to_owned(cx: &LateContext<'_>, expr: &Expr<'_>, other: &Expr<'_>, left:
                 return;
             }
 
+            let arg_snip = snippet(cx, arg_span, "..");
             let expr_snip;
             let eq_impl;
             if with_deref.is_implemented() {
-                expr_snip = format!("*{}", snip);
+                expr_snip = format!("*{}", arg_snip);
                 eq_impl = with_deref;
             } else {
-                expr_snip = snip.to_string();
+                expr_snip = arg_snip.to_string();
                 eq_impl = without_deref;
             };
 
-- 
cgit 1.4.1-3-g733a5


From 993b4016db6684eeac1d5e9e986d18bd7f2fe1a3 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Mon, 9 May 2022 12:29:31 -0400
Subject: Don't lint `cmp_owned` when `From::from` results in a copy type.

---
 clippy_lints/src/misc.rs                     |  8 ++++++--
 tests/ui/cmp_owned/without_suggestion.rs     | 22 ++++++++++++++++++++++
 tests/ui/cmp_owned/without_suggestion.stderr |  2 +-
 3 files changed, 29 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/misc.rs b/clippy_lints/src/misc.rs
index 18a98fc6f84..27a15b106fb 100644
--- a/clippy_lints/src/misc.rs
+++ b/clippy_lints/src/misc.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg, span_lint_and_then, span_lint_hir_and_then};
 use clippy_utils::source::{snippet, snippet_opt};
-use clippy_utils::ty::implements_trait;
+use clippy_utils::ty::{implements_trait, is_copy};
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
@@ -584,7 +584,11 @@ fn check_to_owned(cx: &LateContext<'_>, expr: &Expr<'_>, other: &Expr<'_>, left:
         ExprKind::Call(path, [arg])
             if path_def_id(cx, path)
                 .and_then(|id| match_any_def_paths(cx, id, &[&paths::FROM_STR_METHOD, &paths::FROM_FROM]))
-                .is_some() =>
+                .map_or(false, |idx| match idx {
+                    0 => true,
+                    1 => !is_copy(cx, typeck.expr_ty(expr)),
+                    _ => false,
+                }) =>
         {
             (arg, arg.span)
         },
diff --git a/tests/ui/cmp_owned/without_suggestion.rs b/tests/ui/cmp_owned/without_suggestion.rs
index f44a3901fb4..ae0862257eb 100644
--- a/tests/ui/cmp_owned/without_suggestion.rs
+++ b/tests/ui/cmp_owned/without_suggestion.rs
@@ -9,6 +9,10 @@ fn main() {
     let x = &&Baz;
     let y = &Baz;
     y.to_owned() == **x;
+
+    let x = 0u32;
+    let y = U32Wrapper(x);
+    let _ = U32Wrapper::from(x) == y;
 }
 
 struct Foo;
@@ -51,3 +55,21 @@ impl std::borrow::Borrow<Foo> for Bar {
         &FOO
     }
 }
+
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+struct U32Wrapper(u32);
+impl From<u32> for U32Wrapper {
+    fn from(x: u32) -> Self {
+        Self(x)
+    }
+}
+impl PartialEq<u32> for U32Wrapper {
+    fn eq(&self, other: &u32) -> bool {
+        self.0 == *other
+    }
+}
+impl PartialEq<U32Wrapper> for u32 {
+    fn eq(&self, other: &U32Wrapper) -> bool {
+        *self == other.0
+    }
+}
diff --git a/tests/ui/cmp_owned/without_suggestion.stderr b/tests/ui/cmp_owned/without_suggestion.stderr
index 2ea3d8fac0d..d2dd14d8edb 100644
--- a/tests/ui/cmp_owned/without_suggestion.stderr
+++ b/tests/ui/cmp_owned/without_suggestion.stderr
@@ -13,7 +13,7 @@ LL |     y.to_owned() == **x;
    |     ^^^^^^^^^^^^^^^^^^^ try implementing the comparison without allocating
 
 error: this creates an owned instance just for comparison
-  --> $DIR/without_suggestion.rs:18:9
+  --> $DIR/without_suggestion.rs:22:9
    |
 LL |         self.to_owned() == *other
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^ try implementing the comparison without allocating
-- 
cgit 1.4.1-3-g733a5


From fe84ff336055412f0df8a2e625eaf46c6701e574 Mon Sep 17 00:00:00 2001
From: nsunderland1 <sunderland.nicholas@protonmail.com>
Date: Fri, 6 May 2022 00:10:11 -0700
Subject: New lint: [`derive_partial_eq_without_eq`]

---
 CHANGELOG.md                                   |  1 +
 clippy_dev/src/update_lints.rs                 |  6 +-
 clippy_lints/src/checked_conversions.rs        |  2 +-
 clippy_lints/src/derive.rs                     | 72 ++++++++++++++++++-
 clippy_lints/src/lib.register_all.rs           |  1 +
 clippy_lints/src/lib.register_lints.rs         |  1 +
 clippy_lints/src/lib.register_style.rs         |  1 +
 clippy_lints/src/loops/utils.rs                |  2 +-
 clippy_lints/src/methods/mod.rs                |  2 +-
 clippy_lints/src/methods/str_splitn.rs         |  2 +-
 clippy_utils/src/numeric_literal.rs            |  2 +-
 tests/ui/absurd-extreme-comparisons.rs         |  2 +-
 tests/ui/assign_ops2.rs                        |  2 +-
 tests/ui/cmp_owned/asymmetric_partial_eq.fixed |  2 +-
 tests/ui/cmp_owned/asymmetric_partial_eq.rs    |  2 +-
 tests/ui/cmp_owned/with_suggestion.fixed       |  4 +-
 tests/ui/cmp_owned/with_suggestion.rs          |  4 +-
 tests/ui/cmp_owned/without_suggestion.rs       |  4 +-
 tests/ui/crashes/ice-6254.rs                   |  1 +
 tests/ui/crashes/ice-6254.stderr               |  2 +-
 tests/ui/derive_hash_xor_eq.rs                 |  2 +
 tests/ui/derive_hash_xor_eq.stderr             | 16 ++---
 tests/ui/derive_partial_eq_without_eq.fixed    | 98 ++++++++++++++++++++++++++
 tests/ui/derive_partial_eq_without_eq.rs       | 98 ++++++++++++++++++++++++++
 tests/ui/derive_partial_eq_without_eq.stderr   | 46 ++++++++++++
 tests/ui/equatable_if_let.fixed                |  2 +-
 tests/ui/equatable_if_let.rs                   |  2 +-
 tests/ui/unit_cmp.rs                           |  6 +-
 tests/ui/unit_cmp.stderr                       | 12 ++--
 29 files changed, 359 insertions(+), 38 deletions(-)
 create mode 100644 tests/ui/derive_partial_eq_without_eq.fixed
 create mode 100644 tests/ui/derive_partial_eq_without_eq.rs
 create mode 100644 tests/ui/derive_partial_eq_without_eq.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 751f9fccd88..0608c360d30 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3350,6 +3350,7 @@ Released 2018-09-13
 [`derivable_impls`]: https://rust-lang.github.io/rust-clippy/master/index.html#derivable_impls
 [`derive_hash_xor_eq`]: https://rust-lang.github.io/rust-clippy/master/index.html#derive_hash_xor_eq
 [`derive_ord_xor_partial_ord`]: https://rust-lang.github.io/rust-clippy/master/index.html#derive_ord_xor_partial_ord
+[`derive_partial_eq_without_eq`]: https://rust-lang.github.io/rust-clippy/master/index.html#derive_partial_eq_without_eq
 [`disallowed_methods`]: https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_methods
 [`disallowed_script_idents`]: https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_script_idents
 [`disallowed_types`]: https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_types
diff --git a/clippy_dev/src/update_lints.rs b/clippy_dev/src/update_lints.rs
index 1a6a4336da2..e9cc4f29943 100644
--- a/clippy_dev/src/update_lints.rs
+++ b/clippy_dev/src/update_lints.rs
@@ -17,7 +17,7 @@ const GENERATED_FILE_COMMENT: &str = "// This file was generated by `cargo dev u
 
 const DOCS_LINK: &str = "https://rust-lang.github.io/rust-clippy/master/index.html";
 
-#[derive(Clone, Copy, PartialEq)]
+#[derive(Clone, Copy, PartialEq, Eq)]
 pub enum UpdateMode {
     Check,
     Change,
@@ -372,7 +372,7 @@ fn exit_with_failure() {
 }
 
 /// Lint data parsed from the Clippy source code.
-#[derive(Clone, PartialEq, Debug)]
+#[derive(Clone, PartialEq, Eq, Debug)]
 struct Lint {
     name: String,
     group: String,
@@ -414,7 +414,7 @@ impl Lint {
     }
 }
 
-#[derive(Clone, PartialEq, Debug)]
+#[derive(Clone, PartialEq, Eq, Debug)]
 struct DeprecatedLint {
     name: String,
     reason: String,
diff --git a/clippy_lints/src/checked_conversions.rs b/clippy_lints/src/checked_conversions.rs
index e23428e216d..28c77ea40ef 100644
--- a/clippy_lints/src/checked_conversions.rs
+++ b/clippy_lints/src/checked_conversions.rs
@@ -123,7 +123,7 @@ struct Conversion<'a> {
 }
 
 /// The kind of conversion that is checked
-#[derive(Copy, Clone, Debug, PartialEq)]
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
 enum ConversionType {
     SignedToUnsigned,
     SignedToSigned,
diff --git a/clippy_lints/src/derive.rs b/clippy_lints/src/derive.rs
index 557e101494e..a4757ebd8c7 100644
--- a/clippy_lints/src/derive.rs
+++ b/clippy_lints/src/derive.rs
@@ -1,8 +1,9 @@
-use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_note, span_lint_and_then};
+use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_note, span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::paths;
 use clippy_utils::ty::{implements_trait, is_copy};
 use clippy_utils::{is_automatically_derived, is_lint_allowed, match_def_path};
 use if_chain::if_chain;
+use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_expr, walk_fn, walk_item, FnKind, Visitor};
 use rustc_hir::{
     BlockCheckMode, BodyId, Expr, ExprKind, FnDecl, HirId, Impl, Item, ItemKind, TraitRef, UnsafeSource, Unsafety,
@@ -156,11 +157,44 @@ declare_clippy_lint! {
     "deriving `serde::Deserialize` on a type that has methods using `unsafe`"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for types that derive `PartialEq` and could implement `Eq`.
+    ///
+    /// ### Why is this bad?
+    /// If a type `T` derives `PartialEq` and all of its members implement `Eq`,
+    /// then `T` can always implement `Eq`. Implementing `Eq` allows `T` to be used
+    /// in APIs that require `Eq` types. It also allows structs containing `T` to derive
+    /// `Eq` themselves.
+    ///
+    /// ### Example
+    /// ```rust
+    /// #[derive(PartialEq)]
+    /// struct Foo {
+    ///     i_am_eq: i32,
+    ///     i_am_eq_too: Vec<String>,
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// #[derive(PartialEq, Eq)]
+    /// struct Foo {
+    ///     i_am_eq: i32,
+    ///     i_am_eq_too: Vec<String>,
+    /// }
+    /// ```
+    #[clippy::version = "1.62.0"]
+    pub DERIVE_PARTIAL_EQ_WITHOUT_EQ,
+    style,
+    "deriving `PartialEq` on a type that can implement `Eq`, without implementing `Eq`"
+}
+
 declare_lint_pass!(Derive => [
     EXPL_IMPL_CLONE_ON_COPY,
     DERIVE_HASH_XOR_EQ,
     DERIVE_ORD_XOR_PARTIAL_ORD,
-    UNSAFE_DERIVE_DESERIALIZE
+    UNSAFE_DERIVE_DESERIALIZE,
+    DERIVE_PARTIAL_EQ_WITHOUT_EQ
 ]);
 
 impl<'tcx> LateLintPass<'tcx> for Derive {
@@ -179,6 +213,7 @@ impl<'tcx> LateLintPass<'tcx> for Derive {
 
             if is_automatically_derived {
                 check_unsafe_derive_deserialize(cx, item, trait_ref, ty);
+                check_partial_eq_without_eq(cx, item.span, trait_ref, ty);
             } else {
                 check_copy_clone(cx, item, trait_ref, ty);
             }
@@ -419,3 +454,36 @@ impl<'tcx> Visitor<'tcx> for UnsafeVisitor<'_, 'tcx> {
         self.cx.tcx.hir()
     }
 }
+
+/// Implementation of the `DERIVE_PARTIAL_EQ_WITHOUT_EQ` lint.
+fn check_partial_eq_without_eq<'tcx>(cx: &LateContext<'tcx>, span: Span, trait_ref: &TraitRef<'_>, ty: Ty<'tcx>) {
+    if_chain! {
+        if let ty::Adt(adt, substs) = ty.kind();
+        if let Some(eq_trait_def_id) = cx.tcx.get_diagnostic_item(sym::Eq);
+        if let Some(def_id) = trait_ref.trait_def_id();
+        if cx.tcx.is_diagnostic_item(sym::PartialEq, def_id);
+        if !implements_trait(cx, ty, eq_trait_def_id, substs);
+        then {
+            // If all of our fields implement `Eq`, we can implement `Eq` too
+            for variant in adt.variants() {
+                for field in &variant.fields {
+                    let ty = field.ty(cx.tcx, substs);
+
+                    if !implements_trait(cx, ty, eq_trait_def_id, substs) {
+                        return;
+                    }
+                }
+            }
+
+            span_lint_and_sugg(
+                cx,
+                DERIVE_PARTIAL_EQ_WITHOUT_EQ,
+                span.ctxt().outer_expn_data().call_site,
+                "you are deriving `PartialEq` and can implement `Eq`",
+                "consider deriving `Eq` as well",
+                "PartialEq, Eq".to_string(),
+                Applicability::MachineApplicable,
+            )
+        }
+    }
+}
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index e68718f9fdf..0f43b320f76 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -46,6 +46,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(derivable_impls::DERIVABLE_IMPLS),
     LintId::of(derive::DERIVE_HASH_XOR_EQ),
     LintId::of(derive::DERIVE_ORD_XOR_PARTIAL_ORD),
+    LintId::of(derive::DERIVE_PARTIAL_EQ_WITHOUT_EQ),
     LintId::of(disallowed_methods::DISALLOWED_METHODS),
     LintId::of(disallowed_types::DISALLOWED_TYPES),
     LintId::of(doc::MISSING_SAFETY_DOC),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 5768edc5018..4e302b10a0f 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -113,6 +113,7 @@ store.register_lints(&[
     derivable_impls::DERIVABLE_IMPLS,
     derive::DERIVE_HASH_XOR_EQ,
     derive::DERIVE_ORD_XOR_PARTIAL_ORD,
+    derive::DERIVE_PARTIAL_EQ_WITHOUT_EQ,
     derive::EXPL_IMPL_CLONE_ON_COPY,
     derive::UNSAFE_DERIVE_DESERIALIZE,
     disallowed_methods::DISALLOWED_METHODS,
diff --git a/clippy_lints/src/lib.register_style.rs b/clippy_lints/src/lib.register_style.rs
index d183c0449cd..62f26d821a0 100644
--- a/clippy_lints/src/lib.register_style.rs
+++ b/clippy_lints/src/lib.register_style.rs
@@ -16,6 +16,7 @@ store.register_group(true, "clippy::style", Some("clippy_style"), vec![
     LintId::of(comparison_chain::COMPARISON_CHAIN),
     LintId::of(default::FIELD_REASSIGN_WITH_DEFAULT),
     LintId::of(dereference::NEEDLESS_BORROW),
+    LintId::of(derive::DERIVE_PARTIAL_EQ_WITHOUT_EQ),
     LintId::of(disallowed_methods::DISALLOWED_METHODS),
     LintId::of(disallowed_types::DISALLOWED_TYPES),
     LintId::of(doc::MISSING_SAFETY_DOC),
diff --git a/clippy_lints/src/loops/utils.rs b/clippy_lints/src/loops/utils.rs
index 772d251b620..4801a84eb92 100644
--- a/clippy_lints/src/loops/utils.rs
+++ b/clippy_lints/src/loops/utils.rs
@@ -13,7 +13,7 @@ use rustc_span::symbol::{sym, Symbol};
 use rustc_typeck::hir_ty_to_ty;
 use std::iter::Iterator;
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Eq)]
 enum IncrementVisitorVarState {
     Initial,  // Not examined yet
     IncrOnce, // Incremented exactly once, may be a loop counter
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index e452614ce17..cfeee4d0c70 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -2835,7 +2835,7 @@ const TRAIT_METHODS: [ShouldImplTraitCase; 30] = [
     ShouldImplTraitCase::new("std::ops::Sub", "sub",  2,  FN_HEADER,  SelfKind::Value,  OutType::Any, true),
 ];
 
-#[derive(Clone, Copy, PartialEq, Debug)]
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
 enum SelfKind {
     Value,
     Ref,
diff --git a/clippy_lints/src/methods/str_splitn.rs b/clippy_lints/src/methods/str_splitn.rs
index fc375763542..90651a6ba04 100644
--- a/clippy_lints/src/methods/str_splitn.rs
+++ b/clippy_lints/src/methods/str_splitn.rs
@@ -271,7 +271,7 @@ enum IterUsageKind {
     NextTuple,
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Eq)]
 enum UnwrapKind {
     Unwrap,
     QuestionMark,
diff --git a/clippy_utils/src/numeric_literal.rs b/clippy_utils/src/numeric_literal.rs
index b92d42e8323..3fb5415ce02 100644
--- a/clippy_utils/src/numeric_literal.rs
+++ b/clippy_utils/src/numeric_literal.rs
@@ -1,7 +1,7 @@
 use rustc_ast::ast::{Lit, LitFloatType, LitIntType, LitKind};
 use std::iter;
 
-#[derive(Debug, PartialEq, Copy, Clone)]
+#[derive(Debug, PartialEq, Eq, Copy, Clone)]
 pub enum Radix {
     Binary,
     Octal,
diff --git a/tests/ui/absurd-extreme-comparisons.rs b/tests/ui/absurd-extreme-comparisons.rs
index d205b383d1f..f682b280c1b 100644
--- a/tests/ui/absurd-extreme-comparisons.rs
+++ b/tests/ui/absurd-extreme-comparisons.rs
@@ -37,7 +37,7 @@ fn main() {
 
 use std::cmp::{Ordering, PartialEq, PartialOrd};
 
-#[derive(PartialEq, PartialOrd)]
+#[derive(PartialEq, Eq, PartialOrd)]
 pub struct U(u64);
 
 impl PartialEq<u32> for U {
diff --git a/tests/ui/assign_ops2.rs b/tests/ui/assign_ops2.rs
index 4703a8c7777..f6d3a8fa3f0 100644
--- a/tests/ui/assign_ops2.rs
+++ b/tests/ui/assign_ops2.rs
@@ -24,7 +24,7 @@ fn main() {
 
 use std::ops::{Mul, MulAssign};
 
-#[derive(Copy, Clone, Debug, PartialEq)]
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
 pub struct Wrap(i64);
 
 impl Mul<i64> for Wrap {
diff --git a/tests/ui/cmp_owned/asymmetric_partial_eq.fixed b/tests/ui/cmp_owned/asymmetric_partial_eq.fixed
index 3305ac9bf8b..abd059c2308 100644
--- a/tests/ui/cmp_owned/asymmetric_partial_eq.fixed
+++ b/tests/ui/cmp_owned/asymmetric_partial_eq.fixed
@@ -1,5 +1,5 @@
 // run-rustfix
-#![allow(unused, clippy::redundant_clone)] // See #5700
+#![allow(unused, clippy::redundant_clone, clippy::derive_partial_eq_without_eq)] // See #5700
 
 // Define the types in each module to avoid trait impls leaking between modules.
 macro_rules! impl_types {
diff --git a/tests/ui/cmp_owned/asymmetric_partial_eq.rs b/tests/ui/cmp_owned/asymmetric_partial_eq.rs
index 88bc2f51dd6..020ef5f840b 100644
--- a/tests/ui/cmp_owned/asymmetric_partial_eq.rs
+++ b/tests/ui/cmp_owned/asymmetric_partial_eq.rs
@@ -1,5 +1,5 @@
 // run-rustfix
-#![allow(unused, clippy::redundant_clone)] // See #5700
+#![allow(unused, clippy::redundant_clone, clippy::derive_partial_eq_without_eq)] // See #5700
 
 // Define the types in each module to avoid trait impls leaking between modules.
 macro_rules! impl_types {
diff --git a/tests/ui/cmp_owned/with_suggestion.fixed b/tests/ui/cmp_owned/with_suggestion.fixed
index 05fb96339e3..b28c4378e33 100644
--- a/tests/ui/cmp_owned/with_suggestion.fixed
+++ b/tests/ui/cmp_owned/with_suggestion.fixed
@@ -45,7 +45,7 @@ impl ToOwned for Foo {
     }
 }
 
-#[derive(PartialEq)]
+#[derive(PartialEq, Eq)]
 struct Bar;
 
 impl PartialEq<Foo> for Bar {
@@ -61,7 +61,7 @@ impl std::borrow::Borrow<Foo> for Bar {
     }
 }
 
-#[derive(PartialEq)]
+#[derive(PartialEq, Eq)]
 struct Baz;
 
 impl ToOwned for Baz {
diff --git a/tests/ui/cmp_owned/with_suggestion.rs b/tests/ui/cmp_owned/with_suggestion.rs
index 0a02825ed82..c1089010fe1 100644
--- a/tests/ui/cmp_owned/with_suggestion.rs
+++ b/tests/ui/cmp_owned/with_suggestion.rs
@@ -45,7 +45,7 @@ impl ToOwned for Foo {
     }
 }
 
-#[derive(PartialEq)]
+#[derive(PartialEq, Eq)]
 struct Bar;
 
 impl PartialEq<Foo> for Bar {
@@ -61,7 +61,7 @@ impl std::borrow::Borrow<Foo> for Bar {
     }
 }
 
-#[derive(PartialEq)]
+#[derive(PartialEq, Eq)]
 struct Baz;
 
 impl ToOwned for Baz {
diff --git a/tests/ui/cmp_owned/without_suggestion.rs b/tests/ui/cmp_owned/without_suggestion.rs
index f44a3901fb4..738d082339a 100644
--- a/tests/ui/cmp_owned/without_suggestion.rs
+++ b/tests/ui/cmp_owned/without_suggestion.rs
@@ -26,7 +26,7 @@ impl ToOwned for Foo {
     }
 }
 
-#[derive(PartialEq)]
+#[derive(PartialEq, Eq)]
 struct Baz;
 
 impl ToOwned for Baz {
@@ -36,7 +36,7 @@ impl ToOwned for Baz {
     }
 }
 
-#[derive(PartialEq)]
+#[derive(PartialEq, Eq)]
 struct Bar;
 
 impl PartialEq<Foo> for Bar {
diff --git a/tests/ui/crashes/ice-6254.rs b/tests/ui/crashes/ice-6254.rs
index c19eca43884..a2a60a16915 100644
--- a/tests/ui/crashes/ice-6254.rs
+++ b/tests/ui/crashes/ice-6254.rs
@@ -2,6 +2,7 @@
 // panicked at 'assertion failed: rows.iter().all(|r| r.len() == v.len())',
 // compiler/rustc_mir_build/src/thir/pattern/_match.rs:2030:5
 
+#[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(PartialEq)]
 struct Foo(i32);
 const FOO_REF_REF: &&Foo = &&Foo(42);
diff --git a/tests/ui/crashes/ice-6254.stderr b/tests/ui/crashes/ice-6254.stderr
index 95ebf23d818..f37ab2e9b0c 100644
--- a/tests/ui/crashes/ice-6254.stderr
+++ b/tests/ui/crashes/ice-6254.stderr
@@ -1,5 +1,5 @@
 error: to use a constant of type `Foo` in a pattern, `Foo` must be annotated with `#[derive(PartialEq, Eq)]`
-  --> $DIR/ice-6254.rs:12:9
+  --> $DIR/ice-6254.rs:13:9
    |
 LL |         FOO_REF_REF => {},
    |         ^^^^^^^^^^^
diff --git a/tests/ui/derive_hash_xor_eq.rs b/tests/ui/derive_hash_xor_eq.rs
index 10abe22d53e..813ddc56646 100644
--- a/tests/ui/derive_hash_xor_eq.rs
+++ b/tests/ui/derive_hash_xor_eq.rs
@@ -1,3 +1,5 @@
+#![allow(clippy::derive_partial_eq_without_eq)]
+
 #[derive(PartialEq, Hash)]
 struct Foo;
 
diff --git a/tests/ui/derive_hash_xor_eq.stderr b/tests/ui/derive_hash_xor_eq.stderr
index b383072ca4d..e5184bd1407 100644
--- a/tests/ui/derive_hash_xor_eq.stderr
+++ b/tests/ui/derive_hash_xor_eq.stderr
@@ -1,12 +1,12 @@
 error: you are deriving `Hash` but have implemented `PartialEq` explicitly
-  --> $DIR/derive_hash_xor_eq.rs:10:10
+  --> $DIR/derive_hash_xor_eq.rs:12:10
    |
 LL | #[derive(Hash)]
    |          ^^^^
    |
    = note: `#[deny(clippy::derive_hash_xor_eq)]` on by default
 note: `PartialEq` implemented here
-  --> $DIR/derive_hash_xor_eq.rs:13:1
+  --> $DIR/derive_hash_xor_eq.rs:15:1
    |
 LL | / impl PartialEq for Bar {
 LL | |     fn eq(&self, _: &Bar) -> bool {
@@ -17,13 +17,13 @@ LL | | }
    = note: this error originates in the derive macro `Hash` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: you are deriving `Hash` but have implemented `PartialEq` explicitly
-  --> $DIR/derive_hash_xor_eq.rs:19:10
+  --> $DIR/derive_hash_xor_eq.rs:21:10
    |
 LL | #[derive(Hash)]
    |          ^^^^
    |
 note: `PartialEq` implemented here
-  --> $DIR/derive_hash_xor_eq.rs:22:1
+  --> $DIR/derive_hash_xor_eq.rs:24:1
    |
 LL | / impl PartialEq<Baz> for Baz {
 LL | |     fn eq(&self, _: &Baz) -> bool {
@@ -34,7 +34,7 @@ LL | | }
    = note: this error originates in the derive macro `Hash` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: you are implementing `Hash` explicitly but have derived `PartialEq`
-  --> $DIR/derive_hash_xor_eq.rs:31:1
+  --> $DIR/derive_hash_xor_eq.rs:33:1
    |
 LL | / impl std::hash::Hash for Bah {
 LL | |     fn hash<H: std::hash::Hasher>(&self, _: &mut H) {}
@@ -42,14 +42,14 @@ LL | | }
    | |_^
    |
 note: `PartialEq` implemented here
-  --> $DIR/derive_hash_xor_eq.rs:28:10
+  --> $DIR/derive_hash_xor_eq.rs:30:10
    |
 LL | #[derive(PartialEq)]
    |          ^^^^^^^^^
    = note: this error originates in the derive macro `PartialEq` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: you are implementing `Hash` explicitly but have derived `PartialEq`
-  --> $DIR/derive_hash_xor_eq.rs:49:5
+  --> $DIR/derive_hash_xor_eq.rs:51:5
    |
 LL | /     impl Hash for Foo3 {
 LL | |         fn hash<H: std::hash::Hasher>(&self, _: &mut H) {}
@@ -57,7 +57,7 @@ LL | |     }
    | |_____^
    |
 note: `PartialEq` implemented here
-  --> $DIR/derive_hash_xor_eq.rs:46:14
+  --> $DIR/derive_hash_xor_eq.rs:48:14
    |
 LL |     #[derive(PartialEq)]
    |              ^^^^^^^^^
diff --git a/tests/ui/derive_partial_eq_without_eq.fixed b/tests/ui/derive_partial_eq_without_eq.fixed
new file mode 100644
index 00000000000..7d4d1b3b649
--- /dev/null
+++ b/tests/ui/derive_partial_eq_without_eq.fixed
@@ -0,0 +1,98 @@
+// run-rustfix
+
+#![allow(unused)]
+#![warn(clippy::derive_partial_eq_without_eq)]
+
+// Don't warn on structs that aren't PartialEq
+struct NotPartialEq {
+    foo: u32,
+    bar: String,
+}
+
+// Eq can be derived but is missing
+#[derive(Debug, PartialEq, Eq)]
+struct MissingEq {
+    foo: u32,
+    bar: String,
+}
+
+// Eq is derived
+#[derive(PartialEq, Eq)]
+struct NotMissingEq {
+    foo: u32,
+    bar: String,
+}
+
+// Eq is manually implemented
+#[derive(PartialEq)]
+struct ManualEqImpl {
+    foo: u32,
+    bar: String,
+}
+
+impl Eq for ManualEqImpl {}
+
+// Cannot be Eq because f32 isn't Eq
+#[derive(PartialEq)]
+struct CannotBeEq {
+    foo: u32,
+    bar: f32,
+}
+
+// Don't warn if PartialEq is manually implemented
+struct ManualPartialEqImpl {
+    foo: u32,
+    bar: String,
+}
+
+impl PartialEq for ManualPartialEqImpl {
+    fn eq(&self, other: &Self) -> bool {
+        self.foo == other.foo && self.bar == other.bar
+    }
+}
+
+// Generic fields should be properly checked for Eq-ness
+#[derive(PartialEq)]
+struct GenericNotEq<T: Eq, U: PartialEq> {
+    foo: T,
+    bar: U,
+}
+
+#[derive(PartialEq, Eq)]
+struct GenericEq<T: Eq, U: Eq> {
+    foo: T,
+    bar: U,
+}
+
+#[derive(PartialEq, Eq)]
+struct TupleStruct(u32);
+
+#[derive(PartialEq, Eq)]
+struct GenericTupleStruct<T: Eq>(T);
+
+#[derive(PartialEq)]
+struct TupleStructNotEq(f32);
+
+#[derive(PartialEq, Eq)]
+enum Enum {
+    Foo(u32),
+    Bar { a: String, b: () },
+}
+
+#[derive(PartialEq, Eq)]
+enum GenericEnum<T: Eq, U: Eq, V: Eq> {
+    Foo(T),
+    Bar { a: U, b: V },
+}
+
+#[derive(PartialEq)]
+enum EnumNotEq {
+    Foo(u32),
+    Bar { a: String, b: f32 },
+}
+
+// Ensure that rustfix works properly when `PartialEq` has other derives on either side
+#[derive(Debug, PartialEq, Eq, Clone)]
+struct RustFixWithOtherDerives;
+
+fn main() {}
diff --git a/tests/ui/derive_partial_eq_without_eq.rs b/tests/ui/derive_partial_eq_without_eq.rs
new file mode 100644
index 00000000000..ab4e1df1ca4
--- /dev/null
+++ b/tests/ui/derive_partial_eq_without_eq.rs
@@ -0,0 +1,98 @@
+// run-rustfix
+
+#![allow(unused)]
+#![warn(clippy::derive_partial_eq_without_eq)]
+
+// Don't warn on structs that aren't PartialEq
+struct NotPartialEq {
+    foo: u32,
+    bar: String,
+}
+
+// Eq can be derived but is missing
+#[derive(Debug, PartialEq)]
+struct MissingEq {
+    foo: u32,
+    bar: String,
+}
+
+// Eq is derived
+#[derive(PartialEq, Eq)]
+struct NotMissingEq {
+    foo: u32,
+    bar: String,
+}
+
+// Eq is manually implemented
+#[derive(PartialEq)]
+struct ManualEqImpl {
+    foo: u32,
+    bar: String,
+}
+
+impl Eq for ManualEqImpl {}
+
+// Cannot be Eq because f32 isn't Eq
+#[derive(PartialEq)]
+struct CannotBeEq {
+    foo: u32,
+    bar: f32,
+}
+
+// Don't warn if PartialEq is manually implemented
+struct ManualPartialEqImpl {
+    foo: u32,
+    bar: String,
+}
+
+impl PartialEq for ManualPartialEqImpl {
+    fn eq(&self, other: &Self) -> bool {
+        self.foo == other.foo && self.bar == other.bar
+    }
+}
+
+// Generic fields should be properly checked for Eq-ness
+#[derive(PartialEq)]
+struct GenericNotEq<T: Eq, U: PartialEq> {
+    foo: T,
+    bar: U,
+}
+
+#[derive(PartialEq)]
+struct GenericEq<T: Eq, U: Eq> {
+    foo: T,
+    bar: U,
+}
+
+#[derive(PartialEq)]
+struct TupleStruct(u32);
+
+#[derive(PartialEq)]
+struct GenericTupleStruct<T: Eq>(T);
+
+#[derive(PartialEq)]
+struct TupleStructNotEq(f32);
+
+#[derive(PartialEq)]
+enum Enum {
+    Foo(u32),
+    Bar { a: String, b: () },
+}
+
+#[derive(PartialEq)]
+enum GenericEnum<T: Eq, U: Eq, V: Eq> {
+    Foo(T),
+    Bar { a: U, b: V },
+}
+
+#[derive(PartialEq)]
+enum EnumNotEq {
+    Foo(u32),
+    Bar { a: String, b: f32 },
+}
+
+// Ensure that rustfix works properly when `PartialEq` has other derives on either side
+#[derive(Debug, PartialEq, Clone)]
+struct RustFixWithOtherDerives;
+
+fn main() {}
diff --git a/tests/ui/derive_partial_eq_without_eq.stderr b/tests/ui/derive_partial_eq_without_eq.stderr
new file mode 100644
index 00000000000..bf55165890a
--- /dev/null
+++ b/tests/ui/derive_partial_eq_without_eq.stderr
@@ -0,0 +1,46 @@
+error: you are deriving `PartialEq` and can implement `Eq`
+  --> $DIR/derive_partial_eq_without_eq.rs:13:17
+   |
+LL | #[derive(Debug, PartialEq)]
+   |                 ^^^^^^^^^ help: consider deriving `Eq` as well: `PartialEq, Eq`
+   |
+   = note: `-D clippy::derive-partial-eq-without-eq` implied by `-D warnings`
+
+error: you are deriving `PartialEq` and can implement `Eq`
+  --> $DIR/derive_partial_eq_without_eq.rs:61:10
+   |
+LL | #[derive(PartialEq)]
+   |          ^^^^^^^^^ help: consider deriving `Eq` as well: `PartialEq, Eq`
+
+error: you are deriving `PartialEq` and can implement `Eq`
+  --> $DIR/derive_partial_eq_without_eq.rs:67:10
+   |
+LL | #[derive(PartialEq)]
+   |          ^^^^^^^^^ help: consider deriving `Eq` as well: `PartialEq, Eq`
+
+error: you are deriving `PartialEq` and can implement `Eq`
+  --> $DIR/derive_partial_eq_without_eq.rs:70:10
+   |
+LL | #[derive(PartialEq)]
+   |          ^^^^^^^^^ help: consider deriving `Eq` as well: `PartialEq, Eq`
+
+error: you are deriving `PartialEq` and can implement `Eq`
+  --> $DIR/derive_partial_eq_without_eq.rs:76:10
+   |
+LL | #[derive(PartialEq)]
+   |          ^^^^^^^^^ help: consider deriving `Eq` as well: `PartialEq, Eq`
+
+error: you are deriving `PartialEq` and can implement `Eq`
+  --> $DIR/derive_partial_eq_without_eq.rs:82:10
+   |
+LL | #[derive(PartialEq)]
+   |          ^^^^^^^^^ help: consider deriving `Eq` as well: `PartialEq, Eq`
+
+error: you are deriving `PartialEq` and can implement `Eq`
+  --> $DIR/derive_partial_eq_without_eq.rs:95:17
+   |
+LL | #[derive(Debug, PartialEq, Clone)]
+   |                 ^^^^^^^^^ help: consider deriving `Eq` as well: `PartialEq, Eq`
+
+error: aborting due to 7 previous errors
+
diff --git a/tests/ui/equatable_if_let.fixed b/tests/ui/equatable_if_let.fixed
index 88918d9671e..47bf25e409b 100644
--- a/tests/ui/equatable_if_let.fixed
+++ b/tests/ui/equatable_if_let.fixed
@@ -1,6 +1,6 @@
 // run-rustfix
 
-#![allow(unused_variables, dead_code)]
+#![allow(unused_variables, dead_code, clippy::derive_partial_eq_without_eq)]
 #![warn(clippy::equatable_if_let)]
 
 use std::cmp::Ordering;
diff --git a/tests/ui/equatable_if_let.rs b/tests/ui/equatable_if_let.rs
index 9a7ab75ef45..d498bca2455 100644
--- a/tests/ui/equatable_if_let.rs
+++ b/tests/ui/equatable_if_let.rs
@@ -1,6 +1,6 @@
 // run-rustfix
 
-#![allow(unused_variables, dead_code)]
+#![allow(unused_variables, dead_code, clippy::derive_partial_eq_without_eq)]
 #![warn(clippy::equatable_if_let)]
 
 use std::cmp::Ordering;
diff --git a/tests/ui/unit_cmp.rs b/tests/ui/unit_cmp.rs
index 8d3a4eed82e..3d271104361 100644
--- a/tests/ui/unit_cmp.rs
+++ b/tests/ui/unit_cmp.rs
@@ -1,5 +1,9 @@
 #![warn(clippy::unit_cmp)]
-#![allow(clippy::no_effect, clippy::unnecessary_operation)]
+#![allow(
+    clippy::no_effect,
+    clippy::unnecessary_operation,
+    clippy::derive_partial_eq_without_eq
+)]
 
 #[derive(PartialEq)]
 pub struct ContainsUnit(()); // should be fine
diff --git a/tests/ui/unit_cmp.stderr b/tests/ui/unit_cmp.stderr
index 824506a4257..41cf19ae685 100644
--- a/tests/ui/unit_cmp.stderr
+++ b/tests/ui/unit_cmp.stderr
@@ -1,5 +1,5 @@
 error: ==-comparison of unit values detected. This will always be true
-  --> $DIR/unit_cmp.rs:12:8
+  --> $DIR/unit_cmp.rs:16:8
    |
 LL |       if {
    |  ________^
@@ -12,7 +12,7 @@ LL | |     } {}
    = note: `-D clippy::unit-cmp` implied by `-D warnings`
 
 error: >-comparison of unit values detected. This will always be false
-  --> $DIR/unit_cmp.rs:18:8
+  --> $DIR/unit_cmp.rs:22:8
    |
 LL |       if {
    |  ________^
@@ -23,7 +23,7 @@ LL | |     } {}
    | |_____^
 
 error: `assert_eq` of unit values detected. This will always succeed
-  --> $DIR/unit_cmp.rs:24:5
+  --> $DIR/unit_cmp.rs:28:5
    |
 LL | /     assert_eq!(
 LL | |         {
@@ -35,7 +35,7 @@ LL | |     );
    | |_____^
 
 error: `debug_assert_eq` of unit values detected. This will always succeed
-  --> $DIR/unit_cmp.rs:32:5
+  --> $DIR/unit_cmp.rs:36:5
    |
 LL | /     debug_assert_eq!(
 LL | |         {
@@ -47,7 +47,7 @@ LL | |     );
    | |_____^
 
 error: `assert_ne` of unit values detected. This will always fail
-  --> $DIR/unit_cmp.rs:41:5
+  --> $DIR/unit_cmp.rs:45:5
    |
 LL | /     assert_ne!(
 LL | |         {
@@ -59,7 +59,7 @@ LL | |     );
    | |_____^
 
 error: `debug_assert_ne` of unit values detected. This will always fail
-  --> $DIR/unit_cmp.rs:49:5
+  --> $DIR/unit_cmp.rs:53:5
    |
 LL | /     debug_assert_ne!(
 LL | |         {
-- 
cgit 1.4.1-3-g733a5


From feb6d8cf30ffe4341d2bd41c35554a85951e4440 Mon Sep 17 00:00:00 2001
From: yonip23 <yoni@tabnine.com>
Date: Sun, 8 May 2022 22:20:25 +0300
Subject: introduce rc_clone_in_vec_init lint

---
 CHANGELOG.md                                |  1 +
 clippy_lints/src/lib.register_all.rs        |  1 +
 clippy_lints/src/lib.register_lints.rs      |  1 +
 clippy_lints/src/lib.register_suspicious.rs |  1 +
 clippy_lints/src/lib.rs                     |  2 +
 clippy_lints/src/rc_clone_in_vec_init.rs    | 90 +++++++++++++++++++++++++++++
 tests/ui/rc_clone_in_vec_init/arc.rs        | 49 ++++++++++++++++
 tests/ui/rc_clone_in_vec_init/arc.stderr    | 30 ++++++++++
 tests/ui/rc_clone_in_vec_init/rc.rs         | 50 ++++++++++++++++
 tests/ui/rc_clone_in_vec_init/rc.stderr     | 30 ++++++++++
 10 files changed, 255 insertions(+)
 create mode 100644 clippy_lints/src/rc_clone_in_vec_init.rs
 create mode 100644 tests/ui/rc_clone_in_vec_init/arc.rs
 create mode 100644 tests/ui/rc_clone_in_vec_init/arc.stderr
 create mode 100644 tests/ui/rc_clone_in_vec_init/rc.rs
 create mode 100644 tests/ui/rc_clone_in_vec_init/rc.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 751f9fccd88..3a274ae1d9c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3642,6 +3642,7 @@ Released 2018-09-13
 [`range_step_by_zero`]: https://rust-lang.github.io/rust-clippy/master/index.html#range_step_by_zero
 [`range_zip_with_len`]: https://rust-lang.github.io/rust-clippy/master/index.html#range_zip_with_len
 [`rc_buffer`]: https://rust-lang.github.io/rust-clippy/master/index.html#rc_buffer
+[`rc_clone_in_vec_init`]: https://rust-lang.github.io/rust-clippy/master/index.html#rc_clone_in_vec_init
 [`rc_mutex`]: https://rust-lang.github.io/rust-clippy/master/index.html#rc_mutex
 [`recursive_format_impl`]: https://rust-lang.github.io/rust-clippy/master/index.html#recursive_format_impl
 [`redundant_allocation`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_allocation
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index e68718f9fdf..b608ef9c693 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -263,6 +263,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(ranges::MANUAL_RANGE_CONTAINS),
     LintId::of(ranges::RANGE_ZIP_WITH_LEN),
     LintId::of(ranges::REVERSED_EMPTY_RANGES),
+    LintId::of(rc_clone_in_vec_init::RC_CLONE_IN_VEC_INIT),
     LintId::of(redundant_clone::REDUNDANT_CLONE),
     LintId::of(redundant_closure_call::REDUNDANT_CLOSURE_CALL),
     LintId::of(redundant_field_names::REDUNDANT_FIELD_NAMES),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 5768edc5018..9224d9d5113 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -446,6 +446,7 @@ store.register_lints(&[
     ranges::RANGE_PLUS_ONE,
     ranges::RANGE_ZIP_WITH_LEN,
     ranges::REVERSED_EMPTY_RANGES,
+    rc_clone_in_vec_init::RC_CLONE_IN_VEC_INIT,
     redundant_clone::REDUNDANT_CLONE,
     redundant_closure_call::REDUNDANT_CLOSURE_CALL,
     redundant_else::REDUNDANT_ELSE,
diff --git a/clippy_lints/src/lib.register_suspicious.rs b/clippy_lints/src/lib.register_suspicious.rs
index 7a881bfe399..940bf7ace5e 100644
--- a/clippy_lints/src/lib.register_suspicious.rs
+++ b/clippy_lints/src/lib.register_suspicious.rs
@@ -26,6 +26,7 @@ store.register_group(true, "clippy::suspicious", Some("clippy_suspicious"), vec!
     LintId::of(methods::SUSPICIOUS_MAP),
     LintId::of(mut_key::MUTABLE_KEY_TYPE),
     LintId::of(octal_escapes::OCTAL_ESCAPES),
+    LintId::of(rc_clone_in_vec_init::RC_CLONE_IN_VEC_INIT),
     LintId::of(suspicious_trait_impl::SUSPICIOUS_ARITHMETIC_IMPL),
     LintId::of(suspicious_trait_impl::SUSPICIOUS_OP_ASSIGN_IMPL),
 ])
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 3bb821a1482..3c3cb51c8e3 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -345,6 +345,7 @@ mod ptr_offset_with_cast;
 mod pub_use;
 mod question_mark;
 mod ranges;
+mod rc_clone_in_vec_init;
 mod redundant_clone;
 mod redundant_closure_call;
 mod redundant_else;
@@ -890,6 +891,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     let max_include_file_size = conf.max_include_file_size;
     store.register_late_pass(move || Box::new(large_include_file::LargeIncludeFile::new(max_include_file_size)));
     store.register_late_pass(|| Box::new(strings::TrimSplitWhitespace));
+    store.register_late_pass(|| Box::new(rc_clone_in_vec_init::RcCloneInVecInit));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/rc_clone_in_vec_init.rs b/clippy_lints/src/rc_clone_in_vec_init.rs
new file mode 100644
index 00000000000..6391890b043
--- /dev/null
+++ b/clippy_lints/src/rc_clone_in_vec_init.rs
@@ -0,0 +1,90 @@
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::higher::VecArgs;
+use clippy_utils::last_path_segment;
+use clippy_utils::macros::{root_macro_call_first_node, MacroCall};
+use rustc_hir::{Expr, ExprKind, QPath, TyKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::{sym, Symbol};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `Arc::new` or `Rc::new` in `vec![elem; len]`
+    ///
+    /// ### Why is this bad?
+    /// This will create `elem` once and clone it `len` times - doing so with `Arc` or `Rc`
+    /// is a bit misleading, as it will create references to the same pointer, rather
+    /// than different instances.
+    ///
+    /// ### Example
+    /// ```rust
+    /// let v = vec![std::sync::Arc::new("some data".to_string()); 100];
+    /// // or
+    /// let v = vec![std::rc::Rc::new("some data".to_string()); 100];
+    /// ```
+    /// Use instead:
+    /// ```rust
+    ///
+    /// // Initialize each value separately:
+    /// let mut data = Vec::with_capacity(100);
+    /// for _ in 0..100 {
+    ///     data.push(std::rc::Rc::new("some data".to_string()));
+    /// }
+    ///
+    /// // Or if you want clones of the same reference,
+    /// // Create the reference beforehand to clarify that
+    /// // it should be cloned for each value
+    /// let data = std::rc::Rc::new("some data".to_string());
+    /// let v = vec![data; 100];
+    /// ```
+    #[clippy::version = "1.62.0"]
+    pub RC_CLONE_IN_VEC_INIT,
+    suspicious,
+    "initializing `Arc` or `Rc` in `vec![elem; len]`"
+}
+declare_lint_pass!(RcCloneInVecInit => [RC_CLONE_IN_VEC_INIT]);
+
+impl LateLintPass<'_> for RcCloneInVecInit {
+    fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
+        let Some(macro_call) = root_macro_call_first_node(cx, expr) else { return; };
+        let Some(VecArgs::Repeat(elem, _)) = VecArgs::hir(cx, expr) else { return; };
+        let Some(symbol) = new_reference_call(cx, elem) else { return; };
+
+        emit_lint(cx, symbol, &macro_call);
+    }
+}
+
+fn emit_lint(cx: &LateContext<'_>, symbol: Symbol, macro_call: &MacroCall) {
+    let symbol_name = symbol.as_str();
+
+    span_lint_and_then(
+        cx,
+        RC_CLONE_IN_VEC_INIT,
+        macro_call.span,
+        &format!("calling `{symbol_name}::new` in `vec![elem; len]`"),
+        |diag| {
+            diag.note(format!("each element will point to the same `{symbol_name}` instance"));
+            diag.help(format!(
+                "if this is intentional, consider extracting the `{symbol_name}` initialization to a variable"
+            ));
+            diag.help("or if not, initialize each element individually");
+        },
+    );
+}
+
+/// Checks whether the given `expr` is a call to `Arc::new` or `Rc::new`
+fn new_reference_call(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<Symbol> {
+    if_chain! {
+        if let ExprKind::Call(func, _args) = expr.kind;
+        if let ExprKind::Path(ref func_path @ QPath::TypeRelative(ty, _)) = func.kind;
+        if let TyKind::Path(ref ty_path) = ty.kind;
+        if let Some(def_id) = cx.qpath_res(ty_path, ty.hir_id).opt_def_id();
+        if last_path_segment(func_path).ident.name == sym::new;
+
+        then {
+            return cx.tcx.get_diagnostic_name(def_id).filter(|symbol| symbol == &sym::Arc || symbol == &sym::Rc);
+        }
+    }
+
+    None
+}
diff --git a/tests/ui/rc_clone_in_vec_init/arc.rs b/tests/ui/rc_clone_in_vec_init/arc.rs
new file mode 100644
index 00000000000..9f4e27dfa62
--- /dev/null
+++ b/tests/ui/rc_clone_in_vec_init/arc.rs
@@ -0,0 +1,49 @@
+#![warn(clippy::rc_clone_in_vec_init)]
+use std::sync::{Arc, Mutex};
+
+fn main() {}
+
+fn should_warn_simple_case() {
+    let v = vec![Arc::new("x".to_string()); 2];
+}
+
+fn should_warn_complex_case() {
+    let v = vec![
+        std::sync::Arc::new(Mutex::new({
+            let x = 1;
+            dbg!(x);
+            x
+        }));
+        2
+    ];
+}
+
+fn should_not_warn_custom_arc() {
+    #[derive(Clone)]
+    struct Arc;
+
+    impl Arc {
+        fn new() -> Self {
+            Arc
+        }
+    }
+
+    let v = vec![Arc::new(); 2];
+}
+
+fn should_not_warn_vec_from_elem_but_not_arc() {
+    let v = vec![String::new(); 2];
+    let v1 = vec![1; 2];
+    let v2 = vec![
+        Box::new(std::sync::Arc::new({
+            let y = 3;
+            dbg!(y);
+            y
+        }));
+        2
+    ];
+}
+
+fn should_not_warn_vec_macro_but_not_from_elem() {
+    let v = vec![Arc::new("x".to_string())];
+}
diff --git a/tests/ui/rc_clone_in_vec_init/arc.stderr b/tests/ui/rc_clone_in_vec_init/arc.stderr
new file mode 100644
index 00000000000..19e4727cb98
--- /dev/null
+++ b/tests/ui/rc_clone_in_vec_init/arc.stderr
@@ -0,0 +1,30 @@
+error: calling `Arc::new` in `vec![elem; len]`
+  --> $DIR/arc.rs:7:13
+   |
+LL |     let v = vec![Arc::new("x".to_string()); 2];
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::rc-clone-in-vec-init` implied by `-D warnings`
+   = note: each element will point to the same `Arc` instance
+   = help: if this is intentional, consider extracting the `Arc` initialization to a variable
+   = help: or if not, initialize each element individually
+
+error: calling `Arc::new` in `vec![elem; len]`
+  --> $DIR/arc.rs:11:13
+   |
+LL |       let v = vec![
+   |  _____________^
+LL | |         std::sync::Arc::new(Mutex::new({
+LL | |             let x = 1;
+LL | |             dbg!(x);
+...  |
+LL | |         2
+LL | |     ];
+   | |_____^
+   |
+   = note: each element will point to the same `Arc` instance
+   = help: if this is intentional, consider extracting the `Arc` initialization to a variable
+   = help: or if not, initialize each element individually
+
+error: aborting due to 2 previous errors
+
diff --git a/tests/ui/rc_clone_in_vec_init/rc.rs b/tests/ui/rc_clone_in_vec_init/rc.rs
new file mode 100644
index 00000000000..5e2834aa902
--- /dev/null
+++ b/tests/ui/rc_clone_in_vec_init/rc.rs
@@ -0,0 +1,50 @@
+#![warn(clippy::rc_clone_in_vec_init)]
+use std::rc::Rc;
+use std::sync::Mutex;
+
+fn main() {}
+
+fn should_warn_simple_case() {
+    let v = vec![Rc::new("x".to_string()); 2];
+}
+
+fn should_warn_complex_case() {
+    let v = vec![
+        std::rc::Rc::new(Mutex::new({
+            let x = 1;
+            dbg!(x);
+            x
+        }));
+        2
+    ];
+}
+
+fn should_not_warn_custom_arc() {
+    #[derive(Clone)]
+    struct Rc;
+
+    impl Rc {
+        fn new() -> Self {
+            Rc
+        }
+    }
+
+    let v = vec![Rc::new(); 2];
+}
+
+fn should_not_warn_vec_from_elem_but_not_rc() {
+    let v = vec![String::new(); 2];
+    let v1 = vec![1; 2];
+    let v2 = vec![
+        Box::new(std::rc::Rc::new({
+            let y = 3;
+            dbg!(y);
+            y
+        }));
+        2
+    ];
+}
+
+fn should_not_warn_vec_macro_but_not_from_elem() {
+    let v = vec![Rc::new("x".to_string())];
+}
diff --git a/tests/ui/rc_clone_in_vec_init/rc.stderr b/tests/ui/rc_clone_in_vec_init/rc.stderr
new file mode 100644
index 00000000000..50ffcca9676
--- /dev/null
+++ b/tests/ui/rc_clone_in_vec_init/rc.stderr
@@ -0,0 +1,30 @@
+error: calling `Rc::new` in `vec![elem; len]`
+  --> $DIR/rc.rs:8:13
+   |
+LL |     let v = vec![Rc::new("x".to_string()); 2];
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::rc-clone-in-vec-init` implied by `-D warnings`
+   = note: each element will point to the same `Rc` instance
+   = help: if this is intentional, consider extracting the `Rc` initialization to a variable
+   = help: or if not, initialize each element individually
+
+error: calling `Rc::new` in `vec![elem; len]`
+  --> $DIR/rc.rs:12:13
+   |
+LL |       let v = vec![
+   |  _____________^
+LL | |         std::rc::Rc::new(Mutex::new({
+LL | |             let x = 1;
+LL | |             dbg!(x);
+...  |
+LL | |         2
+LL | |     ];
+   | |_____^
+   |
+   = note: each element will point to the same `Rc` instance
+   = help: if this is intentional, consider extracting the `Rc` initialization to a variable
+   = help: or if not, initialize each element individually
+
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From aaf87c3871c16d087aac4d09acdb15a5d6331acd Mon Sep 17 00:00:00 2001
From: tamaron <tamaron1203@gmail.com>
Date: Tue, 10 May 2022 23:08:18 +0900
Subject: fix

---
 clippy_lints/src/undocumented_unsafe_blocks.rs | 101 ++++++++++++++++---------
 tests/ui/undocumented_unsafe_blocks.rs         |  49 +++++++++++-
 tests/ui/undocumented_unsafe_blocks.stderr     |  68 +++++++++++++++--
 3 files changed, 176 insertions(+), 42 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/undocumented_unsafe_blocks.rs b/clippy_lints/src/undocumented_unsafe_blocks.rs
index 09efb12f5da..1992f61bdb4 100644
--- a/clippy_lints/src/undocumented_unsafe_blocks.rs
+++ b/clippy_lints/src/undocumented_unsafe_blocks.rs
@@ -140,6 +140,7 @@ fn block_has_safety_comment(cx: &LateContext<'_>, block: &hir::Block<'_>) -> boo
 }
 
 /// Checks if the lines immediately preceding the item contain a safety comment.
+#[allow(clippy::collapsible_match)]
 fn item_has_safety_comment(cx: &LateContext<'_>, item: &hir::Item<'_>) -> bool {
     if span_from_macro_expansion_has_safety_comment(cx, item.span) || span_in_body_has_safety_comment(cx, item.span) {
         return true;
@@ -147,48 +148,51 @@ fn item_has_safety_comment(cx: &LateContext<'_>, item: &hir::Item<'_>) -> bool {
 
     if item.span.ctxt() == SyntaxContext::root() {
         if let Some(parent_node) = get_parent_node(cx.tcx, item.hir_id()) {
-            let mut span_before_item = None;
-            let mut hi = false;
-            if let Node::Item(parent_item) = parent_node {
-                if let ItemKind::Mod(parent_mod) = &parent_item.kind {
-                    for (idx, item_id) in parent_mod.item_ids.iter().enumerate() {
-                        if *item_id == item.item_id() {
-                            if idx == 0 {
-                                // mod A { /* comment */ unsafe impl T {} ... }
-                                // ^------------------------------------------^ gets this span
-                                // ^---------------------^ finally checks the text in this range
-                                hi = false;
-                                span_before_item = Some(parent_item.span);
-                            } else {
-                                let prev_item = cx.tcx.hir().item(parent_mod.item_ids[idx - 1]);
-                                // some_item /* comment */ unsafe impl T {}
-                                // ^-------^ gets this span
-                                //         ^---------------^ finally checks the text in this range
-                                hi = true;
-                                span_before_item = Some(prev_item.span);
-                            }
-                            break;
+            let comment_start;
+            match parent_node {
+                Node::Crate(parent_mod) => {
+                    comment_start = comment_start_before_impl_in_mod(cx, parent_mod, parent_mod.spans.inner_span, item);
+                },
+                Node::Item(parent_item) => {
+                    if let ItemKind::Mod(parent_mod) = &parent_item.kind {
+                        comment_start = comment_start_before_impl_in_mod(cx, parent_mod, parent_item.span, item);
+                    } else {
+                        // Doesn't support impls in this position. Pretend a comment was found.
+                        return true;
+                    }
+                },
+                Node::Stmt(stmt) => {
+                    if let Some(stmt_parent) = get_parent_node(cx.tcx, stmt.hir_id) {
+                        match stmt_parent {
+                            Node::Block(block) => {
+                                comment_start = walk_span_to_context(block.span, SyntaxContext::root()).map(Span::lo);
+                            },
+                            _ => {
+                                // Doesn't support impls in this position. Pretend a comment was found.
+                                return true;
+                            },
                         }
+                    } else {
+                        // Doesn't support impls in this position. Pretend a comment was found.
+                        return true;
                     }
-                }
+                },
+                _ => {
+                    // Doesn't support impls in this position. Pretend a comment was found.
+                    return true;
+                },
             }
-            let span_before_item = span_before_item.unwrap();
 
             let source_map = cx.sess().source_map();
-            if let Some(item_span) = walk_span_to_context(item.span, SyntaxContext::root())
-                && let Some(span_before_item) = walk_span_to_context(span_before_item, SyntaxContext::root())
-                && let Ok(unsafe_line) = source_map.lookup_line(item_span.lo())
-                && let Ok(line_before_unsafe) = source_map.lookup_line(if hi {
-                    span_before_item.hi()
-                } else {
-                    span_before_item.lo()
-                })
-                && Lrc::ptr_eq(&unsafe_line.sf, &line_before_unsafe.sf)
+            if let Some(comment_start) = comment_start
+                && let Ok(unsafe_line) = source_map.lookup_line(item.span.lo())
+                && let Ok(comment_start_line) = source_map.lookup_line(comment_start)
+                && Lrc::ptr_eq(&unsafe_line.sf, &comment_start_line.sf)
                 && let Some(src) = unsafe_line.sf.src.as_deref()
             {
-                line_before_unsafe.line < unsafe_line.line && text_has_safety_comment(
+                comment_start_line.line < unsafe_line.line && text_has_safety_comment(
                     src,
-                    &unsafe_line.sf.lines[line_before_unsafe.line + 1..=unsafe_line.line],
+                    &unsafe_line.sf.lines[comment_start_line.line + 1..=unsafe_line.line],
                     unsafe_line.sf.start_pos.to_usize(),
                 )
             } else {
@@ -204,6 +208,35 @@ fn item_has_safety_comment(cx: &LateContext<'_>, item: &hir::Item<'_>) -> bool {
     }
 }
 
+fn comment_start_before_impl_in_mod(
+    cx: &LateContext<'_>,
+    parent_mod: &hir::Mod<'_>,
+    parent_mod_span: Span,
+    imple: &hir::Item<'_>,
+) -> Option<BytePos> {
+    parent_mod.item_ids.iter().enumerate().find_map(|(idx, item_id)| {
+        if *item_id == imple.item_id() {
+            if idx == 0 {
+                // mod A { /* comment */ unsafe impl T {} ... }
+                // ^------------------------------------------^ returns the start of this span
+                //       ^---------------^ finally checks comments in this range
+                if let Some(sp) = walk_span_to_context(parent_mod_span, SyntaxContext::root()) {
+                    return Some(sp.lo());
+                }
+            } else {
+                // some_item /* comment */ unsafe impl T {}
+                // ^-------^ returns the end of this span
+                //         ^---------------^ finally checks comments in this range
+                let prev_item = cx.tcx.hir().item(parent_mod.item_ids[idx - 1]);
+                if let Some(sp) = walk_span_to_context(prev_item.span, SyntaxContext::root()) {
+                    return Some(sp.hi());
+                }
+            }
+        }
+        None
+    })
+}
+
 fn span_from_macro_expansion_has_safety_comment(cx: &LateContext<'_>, span: Span) -> bool {
     let source_map = cx.sess().source_map();
     let ctxt = span.ctxt();
diff --git a/tests/ui/undocumented_unsafe_blocks.rs b/tests/ui/undocumented_unsafe_blocks.rs
index fd64c60384d..33b6a82f9d2 100644
--- a/tests/ui/undocumented_unsafe_blocks.rs
+++ b/tests/ui/undocumented_unsafe_blocks.rs
@@ -344,7 +344,7 @@ mod unsafe_impl_smoke_test {
     unsafe impl A for (i32) {}
 
     mod sub_mod {
-        // error: also works for the first item
+        // error:
         unsafe impl B for (u32) {}
         unsafe trait B {}
     }
@@ -363,24 +363,51 @@ mod unsafe_impl_smoke_test {
 mod unsafe_impl_from_macro {
     unsafe trait T {}
 
+    // error
     macro_rules! no_safety_comment {
         ($t:ty) => {
             unsafe impl T for $t {}
         };
     }
-    // error
+
+    // ok
     no_safety_comment!(());
 
+    // ok
     macro_rules! with_safety_comment {
         ($t:ty) => {
             // SAFETY:
             unsafe impl T for $t {}
         };
     }
+
     // ok
     with_safety_comment!((i32));
 }
 
+mod unsafe_impl_macro_and_not_macro {
+    unsafe trait T {}
+
+    // error
+    macro_rules! no_safety_comment {
+        ($t:ty) => {
+            unsafe impl T for $t {}
+        };
+    }
+
+    // ok
+    no_safety_comment!(());
+
+    // error
+    unsafe impl T for (i32) {}
+
+    // ok
+    no_safety_comment!(u32);
+
+    // error
+    unsafe impl T for (bool) {}
+}
+
 #[rustfmt::skip]
 mod unsafe_impl_valid_comment {
     unsafe trait SaFety {}
@@ -440,4 +467,22 @@ mod unsafe_impl_invalid_comment {
     unsafe impl Interference for () {}
 }
 
+unsafe trait ImplInFn {}
+
+fn impl_in_fn() {
+    // error
+    unsafe impl ImplInFn for () {}
+
+    // SAFETY: ok
+    unsafe impl ImplInFn for (i32) {}
+}
+
+unsafe trait CrateRoot {}
+
+// error
+unsafe impl CrateRoot for () {}
+
+// SAFETY: ok
+unsafe impl CrateRoot for (i32) {}
+
 fn main() {}
diff --git a/tests/ui/undocumented_unsafe_blocks.stderr b/tests/ui/undocumented_unsafe_blocks.stderr
index 3a1f647b06d..b79949e9d06 100644
--- a/tests/ui/undocumented_unsafe_blocks.stderr
+++ b/tests/ui/undocumented_unsafe_blocks.stderr
@@ -164,7 +164,7 @@ LL |         unsafe impl B for (u32) {}
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe impl missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:368:13
+  --> $DIR/undocumented_unsafe_blocks.rs:369:13
    |
 LL |             unsafe impl T for $t {}
    |             ^^^^^^^^^^^^^^^^^^^^^^^
@@ -176,7 +176,47 @@ LL |     no_safety_comment!(());
    = note: this error originates in the macro `no_safety_comment` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: unsafe impl missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:427:5
+  --> $DIR/undocumented_unsafe_blocks.rs:394:13
+   |
+LL |             unsafe impl T for $t {}
+   |             ^^^^^^^^^^^^^^^^^^^^^^^
+...
+LL |     no_safety_comment!(());
+   |     ---------------------- in this macro invocation
+   |
+   = help: consider adding a safety comment on the preceding line
+   = note: this error originates in the macro `no_safety_comment` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: unsafe impl missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:402:5
+   |
+LL |     unsafe impl T for (i32) {}
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: unsafe impl missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:394:13
+   |
+LL |             unsafe impl T for $t {}
+   |             ^^^^^^^^^^^^^^^^^^^^^^^
+...
+LL |     no_safety_comment!(u32);
+   |     ----------------------- in this macro invocation
+   |
+   = help: consider adding a safety comment on the preceding line
+   = note: this error originates in the macro `no_safety_comment` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: unsafe impl missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:408:5
+   |
+LL |     unsafe impl T for (bool) {}
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: unsafe impl missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:454:5
    |
 LL |     unsafe impl NoComment for () {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -184,7 +224,7 @@ LL |     unsafe impl NoComment for () {}
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe impl missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:431:19
+  --> $DIR/undocumented_unsafe_blocks.rs:458:19
    |
 LL |     /* SAFETY: */ unsafe impl InlineComment for () {}
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -192,7 +232,7 @@ LL |     /* SAFETY: */ unsafe impl InlineComment for () {}
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe impl missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:435:5
+  --> $DIR/undocumented_unsafe_blocks.rs:462:5
    |
 LL |     unsafe impl TrailingComment for () {} // SAFETY:
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -200,12 +240,28 @@ LL |     unsafe impl TrailingComment for () {} // SAFETY:
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe impl missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:440:5
+  --> $DIR/undocumented_unsafe_blocks.rs:467:5
    |
 LL |     unsafe impl Interference for () {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: consider adding a safety comment on the preceding line
 
-error: aborting due to 25 previous errors
+error: unsafe impl missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:474:5
+   |
+LL |     unsafe impl ImplInFn for () {}
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: unsafe impl missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:483:1
+   |
+LL | unsafe impl CrateRoot for () {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: aborting due to 31 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 1926217b86d0894dd5f1dc2c9c41aaed4282fd6c Mon Sep 17 00:00:00 2001
From: tamaron <tamaron1203@gmail.com>
Date: Wed, 11 May 2022 00:27:12 +0900
Subject: chore

---
 clippy_lints/src/undocumented_unsafe_blocks.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/undocumented_unsafe_blocks.rs b/clippy_lints/src/undocumented_unsafe_blocks.rs
index 1992f61bdb4..bde7613b48e 100644
--- a/clippy_lints/src/undocumented_unsafe_blocks.rs
+++ b/clippy_lints/src/undocumented_unsafe_blocks.rs
@@ -219,7 +219,7 @@ fn comment_start_before_impl_in_mod(
             if idx == 0 {
                 // mod A { /* comment */ unsafe impl T {} ... }
                 // ^------------------------------------------^ returns the start of this span
-                //       ^---------------^ finally checks comments in this range
+                // ^---------------------^ finally checks comments in this range
                 if let Some(sp) = walk_span_to_context(parent_mod_span, SyntaxContext::root()) {
                     return Some(sp.lo());
                 }
-- 
cgit 1.4.1-3-g733a5


From 631b4ee7a26e4e68469a607376005eb4064b3e6f Mon Sep 17 00:00:00 2001
From: Evan Typanski <evantypanski@gmail.com>
Date: Tue, 10 May 2022 14:21:51 -0400
Subject: Fix redundant_allocation warning for Rc<Box<str>>

---
 clippy_lints/src/types/redundant_allocation.rs | 22 +++++++++++++++++++---
 tests/ui/redundant_allocation.rs               | 18 ++++++++++++++++++
 tests/ui/redundant_allocation.stderr           | 11 ++++++++++-
 3 files changed, 47 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types/redundant_allocation.rs b/clippy_lints/src/types/redundant_allocation.rs
index 10d2ae2eb1d..5fdf1731495 100644
--- a/clippy_lints/src/types/redundant_allocation.rs
+++ b/clippy_lints/src/types/redundant_allocation.rs
@@ -2,7 +2,7 @@ use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::{snippet, snippet_with_applicability};
 use clippy_utils::{path_def_id, qpath_generic_tys};
 use rustc_errors::Applicability;
-use rustc_hir::{self as hir, def_id::DefId, QPath, TyKind};
+use rustc_hir::{self as hir, def, def_id::DefId, PrimTy, QPath, TyKind};
 use rustc_lint::LateContext;
 use rustc_span::symbol::sym;
 
@@ -54,8 +54,7 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_
     };
     let inner_span = match qpath_generic_tys(inner_qpath).next() {
         Some(ty) => {
-            // Box<Box<dyn T>> is smaller than Box<dyn T> because of wide pointers
-            if matches!(ty.kind, TyKind::TraitObject(..)) {
+            if alloc_makes_pointer_thin(cx, ty) {
                 return false;
             }
             ty.span
@@ -110,3 +109,20 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_
     }
     true
 }
+
+/// Returns `true` if the allocation would make `hir_ty` go from fat to thin.
+fn alloc_makes_pointer_thin(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>) -> bool {
+    match &hir_ty.kind {
+        TyKind::TraitObject(..) => true,
+        TyKind::Path(ty_qpath) => {
+            let ty_res = cx.qpath_res(ty_qpath, hir_ty.hir_id);
+            if let def::Res::PrimTy(prim_ty) = ty_res {
+                if matches!(prim_ty, PrimTy::Str) {
+                    return true;
+                }
+            }
+            false
+        },
+        _ => false,
+    }
+}
diff --git a/tests/ui/redundant_allocation.rs b/tests/ui/redundant_allocation.rs
index 80f94e5f3cb..b830a3771d5 100644
--- a/tests/ui/redundant_allocation.rs
+++ b/tests/ui/redundant_allocation.rs
@@ -97,4 +97,22 @@ mod box_dyn {
     pub fn test_rc_box(_: Rc<Box<Box<dyn T>>>) {}
 }
 
+// https://github.com/rust-lang/rust-clippy/issues/8604
+mod box_str {
+    use std::boxed::Box;
+    use std::rc::Rc;
+    use std::sync::Arc;
+
+    struct S {
+        a: Box<Box<str>>,
+        b: Rc<Box<str>>,
+        c: Arc<Box<str>>,
+    }
+
+    pub fn test_box(_: Box<Box<str>>) {}
+    pub fn test_rc(_: Rc<Box<str>>) {}
+    pub fn test_arc(_: Arc<Box<str>>) {}
+    pub fn test_rc_box(_: Rc<Box<Box<str>>>) {}
+}
+
 fn main() {}
diff --git a/tests/ui/redundant_allocation.stderr b/tests/ui/redundant_allocation.stderr
index c3b10e5f5e6..ae213cb8975 100644
--- a/tests/ui/redundant_allocation.stderr
+++ b/tests/ui/redundant_allocation.stderr
@@ -143,5 +143,14 @@ LL |     pub fn test_rc_box(_: Rc<Box<Box<dyn T>>>) {}
    = note: `Box<Box<dyn T>>` is already on the heap, `Rc<Box<Box<dyn T>>>` makes an extra allocation
    = help: consider using just `Rc<Box<dyn T>>` or `Box<Box<dyn T>>`
 
-error: aborting due to 16 previous errors
+error: usage of `Rc<Box<Box<str>>>`
+  --> $DIR/redundant_allocation.rs:115:27
+   |
+LL |     pub fn test_rc_box(_: Rc<Box<Box<str>>>) {}
+   |                           ^^^^^^^^^^^^^^^^^
+   |
+   = note: `Box<Box<str>>` is already on the heap, `Rc<Box<Box<str>>>` makes an extra allocation
+   = help: consider using just `Rc<Box<str>>` or `Box<Box<str>>`
+
+error: aborting due to 17 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From f3e01c4f6a12ad1bd70813875ed84dbe8c830df7 Mon Sep 17 00:00:00 2001
From: yonip23 <yoni@tabnine.com>
Date: Wed, 11 May 2022 00:46:20 +0300
Subject: add suggestions to rc_clone_in_vec_init

---
 clippy_lints/src/rc_clone_in_vec_init.rs | 102 ++++++++++++++++++++++++++++---
 tests/ui/rc_clone_in_vec_init/arc.stderr |  34 +++++++++--
 tests/ui/rc_clone_in_vec_init/rc.stderr  |  34 +++++++++--
 3 files changed, 152 insertions(+), 18 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/rc_clone_in_vec_init.rs b/clippy_lints/src/rc_clone_in_vec_init.rs
index 6391890b043..aa575d7e68b 100644
--- a/clippy_lints/src/rc_clone_in_vec_init.rs
+++ b/clippy_lints/src/rc_clone_in_vec_init.rs
@@ -1,11 +1,13 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::higher::VecArgs;
 use clippy_utils::last_path_segment;
-use clippy_utils::macros::{root_macro_call_first_node, MacroCall};
+use clippy_utils::macros::root_macro_call_first_node;
+use clippy_utils::source::{indent_of, snippet};
+use rustc_errors::{Applicability, Diagnostic};
 use rustc_hir::{Expr, ExprKind, QPath, TyKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::{sym, Symbol};
+use rustc_span::{sym, Span, Symbol};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -47,27 +49,107 @@ declare_lint_pass!(RcCloneInVecInit => [RC_CLONE_IN_VEC_INIT]);
 impl LateLintPass<'_> for RcCloneInVecInit {
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
         let Some(macro_call) = root_macro_call_first_node(cx, expr) else { return; };
-        let Some(VecArgs::Repeat(elem, _)) = VecArgs::hir(cx, expr) else { return; };
+        let Some(VecArgs::Repeat(elem, len)) = VecArgs::hir(cx, expr) else { return; };
         let Some(symbol) = new_reference_call(cx, elem) else { return; };
+        let lint_span = macro_call.span;
+        let symbol_name = symbol.as_str();
+        let len_snippet = snippet(cx, len.span, "..");
+        let elem_snippet = elem_snippet(cx, elem, symbol_name);
+        let indentation = indent_of(cx, lint_span).unwrap_or(0);
+        let lint_suggestions =
+            construct_lint_suggestions(lint_span, symbol_name, &elem_snippet, len_snippet.as_ref(), indentation);
 
-        emit_lint(cx, symbol, &macro_call);
+        emit_lint(cx, symbol, lint_span, &lint_suggestions);
     }
 }
 
-fn emit_lint(cx: &LateContext<'_>, symbol: Symbol, macro_call: &MacroCall) {
+struct LintSuggestion {
+    span: Span,
+    message: String,
+    suggestion: String,
+    applicability: Applicability,
+}
+
+impl LintSuggestion {
+    fn span_suggestion(&self, diag: &mut Diagnostic) {
+        diag.span_suggestion(self.span, &self.message, &self.suggestion, self.applicability);
+    }
+}
+
+fn construct_lint_suggestions(
+    span: Span,
+    symbol_name: &str,
+    elem_snippet: &str,
+    len_snippet: &str,
+    indentation: usize,
+) -> Vec<LintSuggestion> {
+    let indentation = " ".repeat(indentation);
+    let loop_init_suggestion = loop_init_suggestion(elem_snippet, len_snippet, &indentation);
+    let extract_suggestion = extract_suggestion(elem_snippet, len_snippet, &indentation);
+
+    vec![
+        LintSuggestion {
+            span,
+            message: format!("consider initializing each `{symbol_name}` element individually"),
+            suggestion: loop_init_suggestion,
+            applicability: Applicability::Unspecified,
+        },
+        LintSuggestion {
+            span,
+            message: format!(
+                "or if this is intentional, consider extracting the `{symbol_name}` initialization to a variable"
+            ),
+            suggestion: extract_suggestion,
+            applicability: Applicability::Unspecified,
+        },
+    ]
+}
+
+fn elem_snippet(cx: &LateContext<'_>, elem: &Expr<'_>, symbol_name: &str) -> String {
+    let mut elem_snippet = snippet(cx, elem.span, "..").to_string();
+    if elem_snippet.contains('\n') {
+        let reference_initialization = format!("{symbol_name}::new");
+        // This string must be found in `elem_snippet`, otherwise we won't be constructing the snippet in
+        // the first place.
+        let reference_initialization_end =
+            elem_snippet.find(&reference_initialization).unwrap() + reference_initialization.len();
+        elem_snippet.replace_range(reference_initialization_end.., "..");
+    }
+    elem_snippet
+}
+
+fn loop_init_suggestion(elem: &str, len: &str, indent: &str) -> String {
+    format!(
+        r#"{{
+{indent}{indent}let mut v = Vec::with_capacity({len});
+{indent}{indent}(0..{len}).for_each(|_| v.push({elem}));
+{indent}{indent}v
+{indent}}}"#
+    )
+}
+
+fn extract_suggestion(elem: &str, len: &str, indent: &str) -> String {
+    format!(
+        "{{
+{indent}{indent}let data = {elem};
+{indent}{indent}vec![data; {len}]
+{indent}}}"
+    )
+}
+
+fn emit_lint(cx: &LateContext<'_>, symbol: Symbol, lint_span: Span, lint_suggestions: &[LintSuggestion]) {
     let symbol_name = symbol.as_str();
 
     span_lint_and_then(
         cx,
         RC_CLONE_IN_VEC_INIT,
-        macro_call.span,
+        lint_span,
         &format!("calling `{symbol_name}::new` in `vec![elem; len]`"),
         |diag| {
             diag.note(format!("each element will point to the same `{symbol_name}` instance"));
-            diag.help(format!(
-                "if this is intentional, consider extracting the `{symbol_name}` initialization to a variable"
-            ));
-            diag.help("or if not, initialize each element individually");
+            lint_suggestions
+                .iter()
+                .for_each(|suggestion| suggestion.span_suggestion(diag));
         },
     );
 }
diff --git a/tests/ui/rc_clone_in_vec_init/arc.stderr b/tests/ui/rc_clone_in_vec_init/arc.stderr
index 19e4727cb98..3de96c6f175 100644
--- a/tests/ui/rc_clone_in_vec_init/arc.stderr
+++ b/tests/ui/rc_clone_in_vec_init/arc.stderr
@@ -6,8 +6,21 @@ LL |     let v = vec![Arc::new("x".to_string()); 2];
    |
    = note: `-D clippy::rc-clone-in-vec-init` implied by `-D warnings`
    = note: each element will point to the same `Arc` instance
-   = help: if this is intentional, consider extracting the `Arc` initialization to a variable
-   = help: or if not, initialize each element individually
+help: consider initializing each `Arc` element individually
+   |
+LL ~     let v = {
+LL +         let mut v = Vec::with_capacity(2);
+LL +         (0..2).for_each(|_| v.push(Arc::new("x".to_string())));
+LL +         v
+LL ~     };
+   |
+help: or if this is intentional, consider extracting the `Arc` initialization to a variable
+   |
+LL ~     let v = {
+LL +         let data = Arc::new("x".to_string());
+LL +         vec![data; 2]
+LL ~     };
+   |
 
 error: calling `Arc::new` in `vec![elem; len]`
   --> $DIR/arc.rs:11:13
@@ -23,8 +36,21 @@ LL | |     ];
    | |_____^
    |
    = note: each element will point to the same `Arc` instance
-   = help: if this is intentional, consider extracting the `Arc` initialization to a variable
-   = help: or if not, initialize each element individually
+help: consider initializing each `Arc` element individually
+   |
+LL ~     let v = {
+LL +         let mut v = Vec::with_capacity(2);
+LL +         (0..2).for_each(|_| v.push(std::sync::Arc::new..));
+LL +         v
+LL ~     };
+   |
+help: or if this is intentional, consider extracting the `Arc` initialization to a variable
+   |
+LL ~     let v = {
+LL +         let data = std::sync::Arc::new..;
+LL +         vec![data; 2]
+LL ~     };
+   |
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/rc_clone_in_vec_init/rc.stderr b/tests/ui/rc_clone_in_vec_init/rc.stderr
index 50ffcca9676..e05f024cf9d 100644
--- a/tests/ui/rc_clone_in_vec_init/rc.stderr
+++ b/tests/ui/rc_clone_in_vec_init/rc.stderr
@@ -6,8 +6,21 @@ LL |     let v = vec![Rc::new("x".to_string()); 2];
    |
    = note: `-D clippy::rc-clone-in-vec-init` implied by `-D warnings`
    = note: each element will point to the same `Rc` instance
-   = help: if this is intentional, consider extracting the `Rc` initialization to a variable
-   = help: or if not, initialize each element individually
+help: consider initializing each `Rc` element individually
+   |
+LL ~     let v = {
+LL +         let mut v = Vec::with_capacity(2);
+LL +         (0..2).for_each(|_| v.push(Rc::new("x".to_string())));
+LL +         v
+LL ~     };
+   |
+help: or if this is intentional, consider extracting the `Rc` initialization to a variable
+   |
+LL ~     let v = {
+LL +         let data = Rc::new("x".to_string());
+LL +         vec![data; 2]
+LL ~     };
+   |
 
 error: calling `Rc::new` in `vec![elem; len]`
   --> $DIR/rc.rs:12:13
@@ -23,8 +36,21 @@ LL | |     ];
    | |_____^
    |
    = note: each element will point to the same `Rc` instance
-   = help: if this is intentional, consider extracting the `Rc` initialization to a variable
-   = help: or if not, initialize each element individually
+help: consider initializing each `Rc` element individually
+   |
+LL ~     let v = {
+LL +         let mut v = Vec::with_capacity(2);
+LL +         (0..2).for_each(|_| v.push(std::rc::Rc::new..));
+LL +         v
+LL ~     };
+   |
+help: or if this is intentional, consider extracting the `Rc` initialization to a variable
+   |
+LL ~     let v = {
+LL +         let data = std::rc::Rc::new..;
+LL +         vec![data; 2]
+LL ~     };
+   |
 
 error: aborting due to 2 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 554dc41ceac0f4a625fc344e9248e7e1dae11378 Mon Sep 17 00:00:00 2001
From: Serial <69764315+Serial-ATA@users.noreply.github.com>
Date: Wed, 20 Apr 2022 10:14:11 -0400
Subject: Fix `match_single_binding` for assign expressions

---
 clippy_lints/src/matches/match_single_binding.rs | 173 ++++++++++++++++-------
 tests/ui/match_single_binding.fixed              |  13 ++
 tests/ui/match_single_binding.rs                 |  14 ++
 tests/ui/match_single_binding.stderr             |  38 +++--
 tests/ui/match_single_binding2.stderr            |   4 +-
 5 files changed, 178 insertions(+), 64 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/match_single_binding.rs b/clippy_lints/src/matches/match_single_binding.rs
index 028e8c297fb..a59711d4cac 100644
--- a/clippy_lints/src/matches/match_single_binding.rs
+++ b/clippy_lints/src/matches/match_single_binding.rs
@@ -1,15 +1,22 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::source::{indent_of, snippet_block, snippet_with_applicability};
+use clippy_utils::macros::HirNode;
+use clippy_utils::source::{indent_of, snippet, snippet_block, snippet_with_applicability};
 use clippy_utils::sugg::Sugg;
 use clippy_utils::{get_parent_expr, is_refutable, peel_blocks};
 use rustc_errors::Applicability;
-use rustc_hir::{Arm, Expr, ExprKind, Local, Node, PatKind};
+use rustc_hir::{Arm, Expr, ExprKind, Node, PatKind};
 use rustc_lint::LateContext;
+use rustc_span::Span;
 
 use super::MATCH_SINGLE_BINDING;
 
+enum AssignmentExpr {
+    Assign { span: Span, match_span: Span },
+    Local { span: Span, pat_span: Span },
+}
+
 #[expect(clippy::too_many_lines)]
-pub(crate) fn check<'a>(cx: &LateContext<'a>, ex: &Expr<'a>, arms: &[Arm<'_>], expr: &Expr<'_>) {
+pub(crate) fn check<'a>(cx: &LateContext<'a>, ex: &Expr<'a>, arms: &[Arm<'_>], expr: &Expr<'a>) {
     if expr.span.from_expansion() || arms.len() != 1 || is_refutable(cx, arms[0].pat) {
         return;
     }
@@ -42,61 +49,59 @@ pub(crate) fn check<'a>(cx: &LateContext<'a>, ex: &Expr<'a>, arms: &[Arm<'_>], e
     let mut applicability = Applicability::MaybeIncorrect;
     match arms[0].pat.kind {
         PatKind::Binding(..) | PatKind::Tuple(_, _) | PatKind::Struct(..) => {
-            // If this match is in a local (`let`) stmt
-            let (target_span, sugg) = if let Some(parent_let_node) = opt_parent_let(cx, ex) {
-                (
-                    parent_let_node.span,
+            let (target_span, sugg) = match opt_parent_assign_span(cx, ex) {
+                Some(AssignmentExpr::Assign { span, match_span }) => {
+                    let sugg = sugg_with_curlies(
+                        cx,
+                        (ex, expr),
+                        (bind_names, matched_vars),
+                        &*snippet_body,
+                        &mut applicability,
+                        Some(span),
+                    );
+
+                    span_lint_and_sugg(
+                        cx,
+                        MATCH_SINGLE_BINDING,
+                        span.to(match_span),
+                        "this assignment could be simplified",
+                        "consider removing the `match` expression",
+                        sugg,
+                        applicability,
+                    );
+
+                    return;
+                },
+                Some(AssignmentExpr::Local { span, pat_span }) => (
+                    span,
                     format!(
                         "let {} = {};\n{}let {} = {};",
                         snippet_with_applicability(cx, bind_names, "..", &mut applicability),
                         snippet_with_applicability(cx, matched_vars, "..", &mut applicability),
                         " ".repeat(indent_of(cx, expr.span).unwrap_or(0)),
-                        snippet_with_applicability(cx, parent_let_node.pat.span, "..", &mut applicability),
+                        snippet_with_applicability(cx, pat_span, "..", &mut applicability),
                         snippet_body
                     ),
-                )
-            } else {
-                // If we are in closure, we need curly braces around suggestion
-                let mut indent = " ".repeat(indent_of(cx, ex.span).unwrap_or(0));
-                let (mut cbrace_start, mut cbrace_end) = ("".to_string(), "".to_string());
-                if let Some(parent_expr) = get_parent_expr(cx, expr) {
-                    if let ExprKind::Closure(..) = parent_expr.kind {
-                        cbrace_end = format!("\n{}}}", indent);
-                        // Fix body indent due to the closure
-                        indent = " ".repeat(indent_of(cx, bind_names).unwrap_or(0));
-                        cbrace_start = format!("{{\n{}", indent);
-                    }
-                }
-                // If the parent is already an arm, and the body is another match statement,
-                // we need curly braces around suggestion
-                let parent_node_id = cx.tcx.hir().get_parent_node(expr.hir_id);
-                if let Node::Arm(arm) = &cx.tcx.hir().get(parent_node_id) {
-                    if let ExprKind::Match(..) = arm.body.kind {
-                        cbrace_end = format!("\n{}}}", indent);
-                        // Fix body indent due to the match
-                        indent = " ".repeat(indent_of(cx, bind_names).unwrap_or(0));
-                        cbrace_start = format!("{{\n{}", indent);
-                    }
-                }
-                (
-                    expr.span,
-                    format!(
-                        "{}let {} = {};\n{}{}{}",
-                        cbrace_start,
-                        snippet_with_applicability(cx, bind_names, "..", &mut applicability),
-                        snippet_with_applicability(cx, matched_vars, "..", &mut applicability),
-                        indent,
-                        snippet_body,
-                        cbrace_end
-                    ),
-                )
+                ),
+                None => {
+                    let sugg = sugg_with_curlies(
+                        cx,
+                        (ex, expr),
+                        (bind_names, matched_vars),
+                        &*snippet_body,
+                        &mut applicability,
+                        None,
+                    );
+                    (expr.span, sugg)
+                },
             };
+
             span_lint_and_sugg(
                 cx,
                 MATCH_SINGLE_BINDING,
                 target_span,
                 "this match could be written as a `let` statement",
-                "consider using `let` statement",
+                "consider using a `let` statement",
                 sugg,
                 applicability,
             );
@@ -110,6 +115,7 @@ pub(crate) fn check<'a>(cx: &LateContext<'a>, ex: &Expr<'a>, arms: &[Arm<'_>], e
                     indent,
                     snippet_body
                 );
+
                 span_lint_and_sugg(
                     cx,
                     MATCH_SINGLE_BINDING,
@@ -135,15 +141,76 @@ pub(crate) fn check<'a>(cx: &LateContext<'a>, ex: &Expr<'a>, arms: &[Arm<'_>], e
     }
 }
 
-/// Returns true if the `ex` match expression is in a local (`let`) statement
-fn opt_parent_let<'a>(cx: &LateContext<'a>, ex: &Expr<'a>) -> Option<&'a Local<'a>> {
+/// Returns true if the `ex` match expression is in a local (`let`) or assign expression
+fn opt_parent_assign_span<'a>(cx: &LateContext<'a>, ex: &Expr<'a>) -> Option<AssignmentExpr> {
     let map = &cx.tcx.hir();
-    if_chain! {
-        if let Some(Node::Expr(parent_arm_expr)) = map.find(map.get_parent_node(ex.hir_id));
-        if let Some(Node::Local(parent_let_expr)) = map.find(map.get_parent_node(parent_arm_expr.hir_id));
-        then {
-            return Some(parent_let_expr);
-        }
+
+    if let Some(Node::Expr(parent_arm_expr)) = map.find(map.get_parent_node(ex.hir_id)) {
+        return match map.find(map.get_parent_node(parent_arm_expr.hir_id)) {
+            Some(Node::Local(parent_let_expr)) => Some(AssignmentExpr::Local {
+                span: parent_let_expr.span,
+                pat_span: parent_let_expr.pat.span(),
+            }),
+            Some(Node::Expr(Expr {
+                kind: ExprKind::Assign(parent_assign_expr, match_expr, _),
+                ..
+            })) => Some(AssignmentExpr::Assign {
+                span: parent_assign_expr.span,
+                match_span: match_expr.span,
+            }),
+            _ => None,
+        };
     }
+
     None
 }
+
+fn sugg_with_curlies<'a>(
+    cx: &LateContext<'a>,
+    (ex, match_expr): (&Expr<'a>, &Expr<'a>),
+    (bind_names, matched_vars): (Span, Span),
+    snippet_body: &str,
+    applicability: &mut Applicability,
+    assignment: Option<Span>,
+) -> String {
+    let mut indent = " ".repeat(indent_of(cx, ex.span).unwrap_or(0));
+
+    let (mut cbrace_start, mut cbrace_end) = (String::new(), String::new());
+    if let Some(parent_expr) = get_parent_expr(cx, match_expr) {
+        if let ExprKind::Closure(..) = parent_expr.kind {
+            cbrace_end = format!("\n{}}}", indent);
+            // Fix body indent due to the closure
+            indent = " ".repeat(indent_of(cx, bind_names).unwrap_or(0));
+            cbrace_start = format!("{{\n{}", indent);
+        }
+    }
+
+    // If the parent is already an arm, and the body is another match statement,
+    // we need curly braces around suggestion
+    let parent_node_id = cx.tcx.hir().get_parent_node(match_expr.hir_id);
+    if let Node::Arm(arm) = &cx.tcx.hir().get(parent_node_id) {
+        if let ExprKind::Match(..) = arm.body.kind {
+            cbrace_end = format!("\n{}}}", indent);
+            // Fix body indent due to the match
+            indent = " ".repeat(indent_of(cx, bind_names).unwrap_or(0));
+            cbrace_start = format!("{{\n{}", indent);
+        }
+    }
+
+    let assignment_str = assignment.map_or_else(String::new, |span| {
+        let mut s = snippet(cx, span, "..").to_string();
+        s.push_str(" = ");
+        s
+    });
+
+    format!(
+        "{}let {} = {};\n{}{}{}{}",
+        cbrace_start,
+        snippet_with_applicability(cx, bind_names, "..", applicability),
+        snippet_with_applicability(cx, matched_vars, "..", applicability),
+        indent,
+        assignment_str,
+        snippet_body,
+        cbrace_end
+    )
+}
diff --git a/tests/ui/match_single_binding.fixed b/tests/ui/match_single_binding.fixed
index b8dc8179f7d..de46e6cff55 100644
--- a/tests/ui/match_single_binding.fixed
+++ b/tests/ui/match_single_binding.fixed
@@ -111,3 +111,16 @@ fn main() {
     let x = 1;
     println!("Not an array index start");
 }
+
+#[allow(dead_code)]
+fn issue_8723() {
+    let (mut val, idx) = ("a b", 1);
+
+    let (pre, suf) = val.split_at(idx);
+    val = {
+        println!("{}", pre);
+        suf
+    };
+
+    let _ = val;
+}
diff --git a/tests/ui/match_single_binding.rs b/tests/ui/match_single_binding.rs
index fe63dcd63f2..eea64fcb292 100644
--- a/tests/ui/match_single_binding.rs
+++ b/tests/ui/match_single_binding.rs
@@ -126,3 +126,17 @@ fn main() {
         _ => println!("Not an array index start"),
     }
 }
+
+#[allow(dead_code)]
+fn issue_8723() {
+    let (mut val, idx) = ("a b", 1);
+
+    val = match val.split_at(idx) {
+        (pre, suf) => {
+            println!("{}", pre);
+            suf
+        },
+    };
+
+    let _ = val;
+}
diff --git a/tests/ui/match_single_binding.stderr b/tests/ui/match_single_binding.stderr
index d939291f53c..5d4e7314b21 100644
--- a/tests/ui/match_single_binding.stderr
+++ b/tests/ui/match_single_binding.stderr
@@ -9,7 +9,7 @@ LL | |     }
    | |_____^
    |
    = note: `-D clippy::match-single-binding` implied by `-D warnings`
-help: consider using `let` statement
+help: consider using a `let` statement
    |
 LL ~     let (x, y, z) = (a, b, c);
 LL +     {
@@ -25,7 +25,7 @@ LL | |         (x, y, z) => println!("{} {} {}", x, y, z),
 LL | |     }
    | |_____^
    |
-help: consider using `let` statement
+help: consider using a `let` statement
    |
 LL ~     let (x, y, z) = (a, b, c);
 LL +     println!("{} {} {}", x, y, z);
@@ -88,7 +88,7 @@ LL | |         Point { x, y } => println!("Coords: ({}, {})", x, y),
 LL | |     }
    | |_____^
    |
-help: consider using `let` statement
+help: consider using a `let` statement
    |
 LL ~     let Point { x, y } = p;
 LL +     println!("Coords: ({}, {})", x, y);
@@ -102,7 +102,7 @@ LL | |         Point { x: x1, y: y1 } => println!("Coords: ({}, {})", x1, y1),
 LL | |     }
    | |_____^
    |
-help: consider using `let` statement
+help: consider using a `let` statement
    |
 LL ~     let Point { x: x1, y: y1 } = p;
 LL +     println!("Coords: ({}, {})", x1, y1);
@@ -116,7 +116,7 @@ LL | |         ref r => println!("Got a reference to {}", r),
 LL | |     }
    | |_____^
    |
-help: consider using `let` statement
+help: consider using a `let` statement
    |
 LL ~     let ref r = x;
 LL +     println!("Got a reference to {}", r);
@@ -130,7 +130,7 @@ LL | |         ref mut mr => println!("Got a mutable reference to {}", mr),
 LL | |     }
    | |_____^
    |
-help: consider using `let` statement
+help: consider using a `let` statement
    |
 LL ~     let ref mut mr = x;
 LL +     println!("Got a mutable reference to {}", mr);
@@ -144,7 +144,7 @@ LL | |         Point { x, y } => x * y,
 LL | |     };
    | |______^
    |
-help: consider using `let` statement
+help: consider using a `let` statement
    |
 LL ~     let Point { x, y } = coords();
 LL +     let product = x * y;
@@ -159,7 +159,7 @@ LL | |             unwrapped => unwrapped,
 LL | |         })
    | |_________^
    |
-help: consider using `let` statement
+help: consider using a `let` statement
    |
 LL ~         .map(|i| {
 LL +             let unwrapped = i.unwrap();
@@ -176,5 +176,25 @@ LL | |         _ => println!("Not an array index start"),
 LL | |     }
    | |_____^ help: consider using the match body instead: `println!("Not an array index start");`
 
-error: aborting due to 12 previous errors
+error: this assignment could be simplified
+  --> $DIR/match_single_binding.rs:134:5
+   |
+LL | /     val = match val.split_at(idx) {
+LL | |         (pre, suf) => {
+LL | |             println!("{}", pre);
+LL | |             suf
+LL | |         },
+LL | |     };
+   | |_____^
+   |
+help: consider removing the `match` expression
+   |
+LL ~     let (pre, suf) = val.split_at(idx);
+LL +     val = {
+LL +         println!("{}", pre);
+LL +         suf
+LL ~     };
+   |
+
+error: aborting due to 13 previous errors
 
diff --git a/tests/ui/match_single_binding2.stderr b/tests/ui/match_single_binding2.stderr
index d3493319466..22bf7d8be4a 100644
--- a/tests/ui/match_single_binding2.stderr
+++ b/tests/ui/match_single_binding2.stderr
@@ -8,7 +8,7 @@ LL | |             },
    | |_____________^
    |
    = note: `-D clippy::match-single-binding` implied by `-D warnings`
-help: consider using `let` statement
+help: consider using a `let` statement
    |
 LL ~             Some((iter, _item)) => {
 LL +                 let (min, max) = iter.size_hint();
@@ -24,7 +24,7 @@ LL | |                 (a, b) => println!("a {:?} and b {:?}", a, b),
 LL | |             }
    | |_____________^
    |
-help: consider using `let` statement
+help: consider using a `let` statement
    |
 LL ~             let (a, b) = get_tup();
 LL +             println!("a {:?} and b {:?}", a, b);
-- 
cgit 1.4.1-3-g733a5


From ae0216d55700274166a853cee1daba59196d4bff Mon Sep 17 00:00:00 2001
From: Koichi ITO <koic.ito@gmail.com>
Date: Wed, 11 May 2022 01:03:52 +0900
Subject: Use the traits added to the Rust 2021 Edition prelude

Follow up https://github.com/rust-lang/rust/pull/96861.

This PR uses the traits added to the Rust 2021 Edition prelude.

> The `TryInto`, `TryFrom` and `FromIterator` traits are now part of the prelude.

https://doc.rust-lang.org/edition-guide/rust-2021/prelude.html
---
 clippy_lints/src/checked_conversions.rs            |  1 -
 clippy_lints/src/enum_clike.rs                     |  1 -
 clippy_lints/src/excessive_bools.rs                |  2 -
 clippy_lints/src/fallible_impl_from.rs             |  1 -
 clippy_lints/src/index_refutable_slice.rs          |  1 -
 clippy_lints/src/methods/mod.rs                    |  2 -
 clippy_lints/src/redundant_clone.rs                |  1 -
 clippy_lints/src/regex.rs                          |  1 -
 clippy_lints/src/tabs_in_doc_comments.rs           |  1 -
 clippy_utils/src/consts.rs                         |  1 -
 clippy_utils/src/sugg.rs                           |  1 -
 tests/ui-toml/unwrap_used/unwrap_used.rs           |  1 -
 tests/ui-toml/unwrap_used/unwrap_used.stderr       | 54 +++++++++++-----------
 .../proc_macro_suspicious_else_formatting.rs       |  1 -
 tests/ui/checked_conversions.fixed                 |  2 -
 tests/ui/checked_conversions.rs                    |  2 -
 tests/ui/checked_conversions.stderr                | 32 ++++++-------
 tests/ui/crashes/auxiliary/proc_macro_crash.rs     |  1 -
 tests/ui/from_iter_instead_of_collect.fixed        |  1 -
 tests/ui/from_iter_instead_of_collect.rs           |  1 -
 tests/ui/from_iter_instead_of_collect.stderr       | 30 ++++++------
 tests/ui/get_unwrap.fixed                          |  1 -
 tests/ui/get_unwrap.rs                             |  1 -
 tests/ui/get_unwrap.stderr                         | 52 ++++++++++-----------
 tests/ui/infinite_iter.rs                          |  1 -
 tests/ui/infinite_iter.stderr                      |  2 +-
 tests/ui/manual_str_repeat.fixed                   |  2 +-
 tests/ui/manual_str_repeat.rs                      |  2 +-
 tests/ui/map_err.rs                                |  1 -
 tests/ui/map_err.stderr                            |  2 +-
 tests/ui/methods.rs                                |  1 -
 tests/ui/methods.stderr                            |  4 +-
 tests/ui/useless_conversion_try.rs                 |  2 -
 tests/ui/useless_conversion_try.stderr             | 18 ++++----
 34 files changed, 99 insertions(+), 128 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/checked_conversions.rs b/clippy_lints/src/checked_conversions.rs
index 28c77ea40ef..7eeaaa01921 100644
--- a/clippy_lints/src/checked_conversions.rs
+++ b/clippy_lints/src/checked_conversions.rs
@@ -30,7 +30,6 @@ declare_clippy_lint! {
     /// Could be written:
     ///
     /// ```rust
-    /// # use std::convert::TryFrom;
     /// # let foo = 1;
     /// # let _ =
     /// i32::try_from(foo).is_ok()
diff --git a/clippy_lints/src/enum_clike.rs b/clippy_lints/src/enum_clike.rs
index 43b405c9a8e..10be245b362 100644
--- a/clippy_lints/src/enum_clike.rs
+++ b/clippy_lints/src/enum_clike.rs
@@ -8,7 +8,6 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::util::IntTypeExt;
 use rustc_middle::ty::{self, IntTy, UintTy};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use std::convert::TryFrom;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/excessive_bools.rs b/clippy_lints/src/excessive_bools.rs
index 245a4fc12fd..7a81fb37e84 100644
--- a/clippy_lints/src/excessive_bools.rs
+++ b/clippy_lints/src/excessive_bools.rs
@@ -4,8 +4,6 @@ use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::{sym, Span};
 
-use std::convert::TryInto;
-
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for excessive
diff --git a/clippy_lints/src/fallible_impl_from.rs b/clippy_lints/src/fallible_impl_from.rs
index 088d9996516..9f868df3ad0 100644
--- a/clippy_lints/src/fallible_impl_from.rs
+++ b/clippy_lints/src/fallible_impl_from.rs
@@ -32,7 +32,6 @@ declare_clippy_lint! {
     /// // Good
     /// struct Foo(i32);
     ///
-    /// use std::convert::TryFrom;
     /// impl TryFrom<String> for Foo {
     ///     type Error = ();
     ///     fn try_from(s: String) -> Result<Self, Self::Error> {
diff --git a/clippy_lints/src/index_refutable_slice.rs b/clippy_lints/src/index_refutable_slice.rs
index 07b0604f78d..9ce5b8e17a9 100644
--- a/clippy_lints/src/index_refutable_slice.rs
+++ b/clippy_lints/src/index_refutable_slice.rs
@@ -14,7 +14,6 @@ use rustc_middle::ty;
 use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::{symbol::Ident, Span};
-use std::convert::TryInto;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index cfeee4d0c70..3e07961fcb3 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1776,8 +1776,6 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust
-    /// use std::iter::FromIterator;
-    ///
     /// let five_fives = std::iter::repeat(5).take(5);
     ///
     /// let v = Vec::from_iter(five_fives);
diff --git a/clippy_lints/src/redundant_clone.rs b/clippy_lints/src/redundant_clone.rs
index 954e702a1f8..9904617353f 100644
--- a/clippy_lints/src/redundant_clone.rs
+++ b/clippy_lints/src/redundant_clone.rs
@@ -19,7 +19,6 @@ use rustc_mir_dataflow::{Analysis, AnalysisDomain, CallReturnPlaces, GenKill, Ge
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::{BytePos, Span};
 use rustc_span::sym;
-use std::convert::TryFrom;
 use std::ops::ControlFlow;
 
 macro_rules! unwrap_or_continue {
diff --git a/clippy_lints/src/regex.rs b/clippy_lints/src/regex.rs
index 78ca7622f4a..67129299e2f 100644
--- a/clippy_lints/src/regex.rs
+++ b/clippy_lints/src/regex.rs
@@ -7,7 +7,6 @@ use rustc_hir::{BorrowKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::{BytePos, Span};
-use std::convert::TryFrom;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/tabs_in_doc_comments.rs b/clippy_lints/src/tabs_in_doc_comments.rs
index 15543b6a262..e223aea297f 100644
--- a/clippy_lints/src/tabs_in_doc_comments.rs
+++ b/clippy_lints/src/tabs_in_doc_comments.rs
@@ -4,7 +4,6 @@ use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::{BytePos, Span};
-use std::convert::TryFrom;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_utils/src/consts.rs b/clippy_utils/src/consts.rs
index 720dfe72237..75fab624fda 100644
--- a/clippy_utils/src/consts.rs
+++ b/clippy_utils/src/consts.rs
@@ -13,7 +13,6 @@ use rustc_middle::ty::{self, FloatTy, ScalarInt, Ty, TyCtxt};
 use rustc_middle::{bug, span_bug};
 use rustc_span::symbol::Symbol;
 use std::cmp::Ordering::{self, Equal};
-use std::convert::TryInto;
 use std::hash::{Hash, Hasher};
 use std::iter;
 
diff --git a/clippy_utils/src/sugg.rs b/clippy_utils/src/sugg.rs
index 855d3657dd4..1de73a80ad2 100644
--- a/clippy_utils/src/sugg.rs
+++ b/clippy_utils/src/sugg.rs
@@ -17,7 +17,6 @@ use rustc_middle::ty;
 use rustc_span::source_map::{BytePos, CharPos, Pos, Span, SyntaxContext};
 use rustc_typeck::expr_use_visitor::{Delegate, ExprUseVisitor, PlaceBase, PlaceWithHirId};
 use std::borrow::Cow;
-use std::convert::TryInto;
 use std::fmt::{Display, Write as _};
 use std::iter;
 use std::ops::{Add, Neg, Not, Sub};
diff --git a/tests/ui-toml/unwrap_used/unwrap_used.rs b/tests/ui-toml/unwrap_used/unwrap_used.rs
index a639de07971..74d0d7c2650 100644
--- a/tests/ui-toml/unwrap_used/unwrap_used.rs
+++ b/tests/ui-toml/unwrap_used/unwrap_used.rs
@@ -7,7 +7,6 @@
 use std::collections::BTreeMap;
 use std::collections::HashMap;
 use std::collections::VecDeque;
-use std::iter::FromIterator;
 
 struct GetFalsePositive {
     arr: [u32; 3],
diff --git a/tests/ui-toml/unwrap_used/unwrap_used.stderr b/tests/ui-toml/unwrap_used/unwrap_used.stderr
index 6c3adc5395f..6bcfa0a8b56 100644
--- a/tests/ui-toml/unwrap_used/unwrap_used.stderr
+++ b/tests/ui-toml/unwrap_used/unwrap_used.stderr
@@ -1,5 +1,5 @@
 error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more concise
-  --> $DIR/unwrap_used.rs:36:17
+  --> $DIR/unwrap_used.rs:35:17
    |
 LL |         let _ = boxed_slice.get(1).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&boxed_slice[1]`
@@ -11,7 +11,7 @@ LL | #![deny(clippy::get_unwrap)]
    |         ^^^^^^^^^^^^^^^^^^
 
 error: used `unwrap()` on `an Option` value
-  --> $DIR/unwrap_used.rs:36:17
+  --> $DIR/unwrap_used.rs:35:17
    |
 LL |         let _ = boxed_slice.get(1).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -20,13 +20,13 @@ LL |         let _ = boxed_slice.get(1).unwrap();
    = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
 
 error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more concise
-  --> $DIR/unwrap_used.rs:37:17
+  --> $DIR/unwrap_used.rs:36:17
    |
 LL |         let _ = some_slice.get(0).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&some_slice[0]`
 
 error: used `unwrap()` on `an Option` value
-  --> $DIR/unwrap_used.rs:37:17
+  --> $DIR/unwrap_used.rs:36:17
    |
 LL |         let _ = some_slice.get(0).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -34,13 +34,13 @@ LL |         let _ = some_slice.get(0).unwrap();
    = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
 
 error: called `.get().unwrap()` on a Vec. Using `[]` is more clear and more concise
-  --> $DIR/unwrap_used.rs:38:17
+  --> $DIR/unwrap_used.rs:37:17
    |
 LL |         let _ = some_vec.get(0).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&some_vec[0]`
 
 error: used `unwrap()` on `an Option` value
-  --> $DIR/unwrap_used.rs:38:17
+  --> $DIR/unwrap_used.rs:37:17
    |
 LL |         let _ = some_vec.get(0).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -48,13 +48,13 @@ LL |         let _ = some_vec.get(0).unwrap();
    = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
 
 error: called `.get().unwrap()` on a VecDeque. Using `[]` is more clear and more concise
-  --> $DIR/unwrap_used.rs:39:17
+  --> $DIR/unwrap_used.rs:38:17
    |
 LL |         let _ = some_vecdeque.get(0).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&some_vecdeque[0]`
 
 error: used `unwrap()` on `an Option` value
-  --> $DIR/unwrap_used.rs:39:17
+  --> $DIR/unwrap_used.rs:38:17
    |
 LL |         let _ = some_vecdeque.get(0).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -62,13 +62,13 @@ LL |         let _ = some_vecdeque.get(0).unwrap();
    = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
 
 error: called `.get().unwrap()` on a HashMap. Using `[]` is more clear and more concise
-  --> $DIR/unwrap_used.rs:40:17
+  --> $DIR/unwrap_used.rs:39:17
    |
 LL |         let _ = some_hashmap.get(&1).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&some_hashmap[&1]`
 
 error: used `unwrap()` on `an Option` value
-  --> $DIR/unwrap_used.rs:40:17
+  --> $DIR/unwrap_used.rs:39:17
    |
 LL |         let _ = some_hashmap.get(&1).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -76,13 +76,13 @@ LL |         let _ = some_hashmap.get(&1).unwrap();
    = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
 
 error: called `.get().unwrap()` on a BTreeMap. Using `[]` is more clear and more concise
-  --> $DIR/unwrap_used.rs:41:17
+  --> $DIR/unwrap_used.rs:40:17
    |
 LL |         let _ = some_btreemap.get(&1).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&some_btreemap[&1]`
 
 error: used `unwrap()` on `an Option` value
-  --> $DIR/unwrap_used.rs:41:17
+  --> $DIR/unwrap_used.rs:40:17
    |
 LL |         let _ = some_btreemap.get(&1).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -90,13 +90,13 @@ LL |         let _ = some_btreemap.get(&1).unwrap();
    = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
 
 error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more concise
-  --> $DIR/unwrap_used.rs:45:21
+  --> $DIR/unwrap_used.rs:44:21
    |
 LL |         let _: u8 = *boxed_slice.get(1).unwrap();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `boxed_slice[1]`
 
 error: used `unwrap()` on `an Option` value
-  --> $DIR/unwrap_used.rs:45:22
+  --> $DIR/unwrap_used.rs:44:22
    |
 LL |         let _: u8 = *boxed_slice.get(1).unwrap();
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -104,13 +104,13 @@ LL |         let _: u8 = *boxed_slice.get(1).unwrap();
    = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
 
 error: called `.get_mut().unwrap()` on a slice. Using `[]` is more clear and more concise
-  --> $DIR/unwrap_used.rs:50:9
+  --> $DIR/unwrap_used.rs:49:9
    |
 LL |         *boxed_slice.get_mut(0).unwrap() = 1;
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `boxed_slice[0]`
 
 error: used `unwrap()` on `an Option` value
-  --> $DIR/unwrap_used.rs:50:10
+  --> $DIR/unwrap_used.rs:49:10
    |
 LL |         *boxed_slice.get_mut(0).unwrap() = 1;
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -118,13 +118,13 @@ LL |         *boxed_slice.get_mut(0).unwrap() = 1;
    = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
 
 error: called `.get_mut().unwrap()` on a slice. Using `[]` is more clear and more concise
-  --> $DIR/unwrap_used.rs:51:9
+  --> $DIR/unwrap_used.rs:50:9
    |
 LL |         *some_slice.get_mut(0).unwrap() = 1;
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `some_slice[0]`
 
 error: used `unwrap()` on `an Option` value
-  --> $DIR/unwrap_used.rs:51:10
+  --> $DIR/unwrap_used.rs:50:10
    |
 LL |         *some_slice.get_mut(0).unwrap() = 1;
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -132,13 +132,13 @@ LL |         *some_slice.get_mut(0).unwrap() = 1;
    = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
 
 error: called `.get_mut().unwrap()` on a Vec. Using `[]` is more clear and more concise
-  --> $DIR/unwrap_used.rs:52:9
+  --> $DIR/unwrap_used.rs:51:9
    |
 LL |         *some_vec.get_mut(0).unwrap() = 1;
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `some_vec[0]`
 
 error: used `unwrap()` on `an Option` value
-  --> $DIR/unwrap_used.rs:52:10
+  --> $DIR/unwrap_used.rs:51:10
    |
 LL |         *some_vec.get_mut(0).unwrap() = 1;
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -146,13 +146,13 @@ LL |         *some_vec.get_mut(0).unwrap() = 1;
    = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
 
 error: called `.get_mut().unwrap()` on a VecDeque. Using `[]` is more clear and more concise
-  --> $DIR/unwrap_used.rs:53:9
+  --> $DIR/unwrap_used.rs:52:9
    |
 LL |         *some_vecdeque.get_mut(0).unwrap() = 1;
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `some_vecdeque[0]`
 
 error: used `unwrap()` on `an Option` value
-  --> $DIR/unwrap_used.rs:53:10
+  --> $DIR/unwrap_used.rs:52:10
    |
 LL |         *some_vecdeque.get_mut(0).unwrap() = 1;
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -160,13 +160,13 @@ LL |         *some_vecdeque.get_mut(0).unwrap() = 1;
    = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
 
 error: called `.get().unwrap()` on a Vec. Using `[]` is more clear and more concise
-  --> $DIR/unwrap_used.rs:65:17
+  --> $DIR/unwrap_used.rs:64:17
    |
 LL |         let _ = some_vec.get(0..1).unwrap().to_vec();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `some_vec[0..1]`
 
 error: used `unwrap()` on `an Option` value
-  --> $DIR/unwrap_used.rs:65:17
+  --> $DIR/unwrap_used.rs:64:17
    |
 LL |         let _ = some_vec.get(0..1).unwrap().to_vec();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -174,13 +174,13 @@ LL |         let _ = some_vec.get(0..1).unwrap().to_vec();
    = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
 
 error: called `.get_mut().unwrap()` on a Vec. Using `[]` is more clear and more concise
-  --> $DIR/unwrap_used.rs:66:17
+  --> $DIR/unwrap_used.rs:65:17
    |
 LL |         let _ = some_vec.get_mut(0..1).unwrap().to_vec();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `some_vec[0..1]`
 
 error: used `unwrap()` on `an Option` value
-  --> $DIR/unwrap_used.rs:66:17
+  --> $DIR/unwrap_used.rs:65:17
    |
 LL |         let _ = some_vec.get_mut(0..1).unwrap().to_vec();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -188,7 +188,7 @@ LL |         let _ = some_vec.get_mut(0..1).unwrap().to_vec();
    = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
 
 error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more concise
-  --> $DIR/unwrap_used.rs:73:13
+  --> $DIR/unwrap_used.rs:72:13
    |
 LL |     let _ = boxed_slice.get(1).unwrap();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&boxed_slice[1]`
diff --git a/tests/ui/auxiliary/proc_macro_suspicious_else_formatting.rs b/tests/ui/auxiliary/proc_macro_suspicious_else_formatting.rs
index 26c88489b03..a2ef0fe827c 100644
--- a/tests/ui/auxiliary/proc_macro_suspicious_else_formatting.rs
+++ b/tests/ui/auxiliary/proc_macro_suspicious_else_formatting.rs
@@ -5,7 +5,6 @@
 
 extern crate proc_macro;
 use proc_macro::{token_stream, Delimiter, Group, Ident, Span, TokenStream, TokenTree};
-use std::iter::FromIterator;
 
 fn read_ident(iter: &mut token_stream::IntoIter) -> Ident {
     match iter.next() {
diff --git a/tests/ui/checked_conversions.fixed b/tests/ui/checked_conversions.fixed
index 12290db3dcf..0983d393b56 100644
--- a/tests/ui/checked_conversions.fixed
+++ b/tests/ui/checked_conversions.fixed
@@ -7,8 +7,6 @@
 )]
 #![warn(clippy::checked_conversions)]
 
-use std::convert::TryFrom;
-
 // Positive tests
 
 // Signed to unsigned
diff --git a/tests/ui/checked_conversions.rs b/tests/ui/checked_conversions.rs
index 895a301e821..7d26ace47fd 100644
--- a/tests/ui/checked_conversions.rs
+++ b/tests/ui/checked_conversions.rs
@@ -7,8 +7,6 @@
 )]
 #![warn(clippy::checked_conversions)]
 
-use std::convert::TryFrom;
-
 // Positive tests
 
 // Signed to unsigned
diff --git a/tests/ui/checked_conversions.stderr b/tests/ui/checked_conversions.stderr
index 18518def0ac..2e518040561 100644
--- a/tests/ui/checked_conversions.stderr
+++ b/tests/ui/checked_conversions.stderr
@@ -1,5 +1,5 @@
 error: checked cast can be simplified
-  --> $DIR/checked_conversions.rs:17:13
+  --> $DIR/checked_conversions.rs:15:13
    |
 LL |     let _ = value <= (u32::max_value() as i64) && value >= 0;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u32::try_from(value).is_ok()`
@@ -7,91 +7,91 @@ LL |     let _ = value <= (u32::max_value() as i64) && value >= 0;
    = note: `-D clippy::checked-conversions` implied by `-D warnings`
 
 error: checked cast can be simplified
-  --> $DIR/checked_conversions.rs:18:13
+  --> $DIR/checked_conversions.rs:16:13
    |
 LL |     let _ = value <= (u32::MAX as i64) && value >= 0;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u32::try_from(value).is_ok()`
 
 error: checked cast can be simplified
-  --> $DIR/checked_conversions.rs:22:13
+  --> $DIR/checked_conversions.rs:20:13
    |
 LL |     let _ = value <= i64::from(u16::max_value()) && value >= 0;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u16::try_from(value).is_ok()`
 
 error: checked cast can be simplified
-  --> $DIR/checked_conversions.rs:23:13
+  --> $DIR/checked_conversions.rs:21:13
    |
 LL |     let _ = value <= i64::from(u16::MAX) && value >= 0;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u16::try_from(value).is_ok()`
 
 error: checked cast can be simplified
-  --> $DIR/checked_conversions.rs:27:13
+  --> $DIR/checked_conversions.rs:25:13
    |
 LL |     let _ = value <= (u8::max_value() as isize) && value >= 0;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u8::try_from(value).is_ok()`
 
 error: checked cast can be simplified
-  --> $DIR/checked_conversions.rs:28:13
+  --> $DIR/checked_conversions.rs:26:13
    |
 LL |     let _ = value <= (u8::MAX as isize) && value >= 0;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u8::try_from(value).is_ok()`
 
 error: checked cast can be simplified
-  --> $DIR/checked_conversions.rs:34:13
+  --> $DIR/checked_conversions.rs:32:13
    |
 LL |     let _ = value <= (i32::max_value() as i64) && value >= (i32::min_value() as i64);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `i32::try_from(value).is_ok()`
 
 error: checked cast can be simplified
-  --> $DIR/checked_conversions.rs:35:13
+  --> $DIR/checked_conversions.rs:33:13
    |
 LL |     let _ = value <= (i32::MAX as i64) && value >= (i32::MIN as i64);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `i32::try_from(value).is_ok()`
 
 error: checked cast can be simplified
-  --> $DIR/checked_conversions.rs:39:13
+  --> $DIR/checked_conversions.rs:37:13
    |
 LL |     let _ = value <= i64::from(i16::max_value()) && value >= i64::from(i16::min_value());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `i16::try_from(value).is_ok()`
 
 error: checked cast can be simplified
-  --> $DIR/checked_conversions.rs:40:13
+  --> $DIR/checked_conversions.rs:38:13
    |
 LL |     let _ = value <= i64::from(i16::MAX) && value >= i64::from(i16::MIN);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `i16::try_from(value).is_ok()`
 
 error: checked cast can be simplified
-  --> $DIR/checked_conversions.rs:46:13
+  --> $DIR/checked_conversions.rs:44:13
    |
 LL |     let _ = value <= i32::max_value() as u32;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `i32::try_from(value).is_ok()`
 
 error: checked cast can be simplified
-  --> $DIR/checked_conversions.rs:47:13
+  --> $DIR/checked_conversions.rs:45:13
    |
 LL |     let _ = value <= i32::MAX as u32;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `i32::try_from(value).is_ok()`
 
 error: checked cast can be simplified
-  --> $DIR/checked_conversions.rs:51:13
+  --> $DIR/checked_conversions.rs:49:13
    |
 LL |     let _ = value <= isize::max_value() as usize && value as i32 == 5;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `isize::try_from(value).is_ok()`
 
 error: checked cast can be simplified
-  --> $DIR/checked_conversions.rs:52:13
+  --> $DIR/checked_conversions.rs:50:13
    |
 LL |     let _ = value <= isize::MAX as usize && value as i32 == 5;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `isize::try_from(value).is_ok()`
 
 error: checked cast can be simplified
-  --> $DIR/checked_conversions.rs:56:13
+  --> $DIR/checked_conversions.rs:54:13
    |
 LL |     let _ = value <= u16::max_value() as u32 && value as i32 == 5;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u16::try_from(value).is_ok()`
 
 error: checked cast can be simplified
-  --> $DIR/checked_conversions.rs:57:13
+  --> $DIR/checked_conversions.rs:55:13
    |
 LL |     let _ = value <= u16::MAX as u32 && value as i32 == 5;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u16::try_from(value).is_ok()`
diff --git a/tests/ui/crashes/auxiliary/proc_macro_crash.rs b/tests/ui/crashes/auxiliary/proc_macro_crash.rs
index ed8e7a708a5..5ff2af7cd82 100644
--- a/tests/ui/crashes/auxiliary/proc_macro_crash.rs
+++ b/tests/ui/crashes/auxiliary/proc_macro_crash.rs
@@ -12,7 +12,6 @@
 extern crate proc_macro;
 
 use proc_macro::{Delimiter, Group, Ident, Span, TokenStream, TokenTree};
-use std::iter::FromIterator;
 
 #[proc_macro]
 pub fn macro_test(input_stream: TokenStream) -> TokenStream {
diff --git a/tests/ui/from_iter_instead_of_collect.fixed b/tests/ui/from_iter_instead_of_collect.fixed
index 12db43b5343..403c3b3e443 100644
--- a/tests/ui/from_iter_instead_of_collect.fixed
+++ b/tests/ui/from_iter_instead_of_collect.fixed
@@ -4,7 +4,6 @@
 #![allow(unused_imports)]
 
 use std::collections::{BTreeMap, BTreeSet, HashMap, VecDeque};
-use std::iter::FromIterator;
 
 struct Foo(Vec<bool>);
 
diff --git a/tests/ui/from_iter_instead_of_collect.rs b/tests/ui/from_iter_instead_of_collect.rs
index f5ec190e0cd..fefc7b01a65 100644
--- a/tests/ui/from_iter_instead_of_collect.rs
+++ b/tests/ui/from_iter_instead_of_collect.rs
@@ -4,7 +4,6 @@
 #![allow(unused_imports)]
 
 use std::collections::{BTreeMap, BTreeSet, HashMap, VecDeque};
-use std::iter::FromIterator;
 
 struct Foo(Vec<bool>);
 
diff --git a/tests/ui/from_iter_instead_of_collect.stderr b/tests/ui/from_iter_instead_of_collect.stderr
index 8f08ac8c3ff..8aa3c3c01f8 100644
--- a/tests/ui/from_iter_instead_of_collect.stderr
+++ b/tests/ui/from_iter_instead_of_collect.stderr
@@ -1,5 +1,5 @@
 error: usage of `FromIterator::from_iter`
-  --> $DIR/from_iter_instead_of_collect.rs:19:9
+  --> $DIR/from_iter_instead_of_collect.rs:18:9
    |
 LL |         <Self as FromIterator<bool>>::from_iter(iter.into_iter().copied())
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `iter.into_iter().copied().collect::<Self>()`
@@ -7,85 +7,85 @@ LL |         <Self as FromIterator<bool>>::from_iter(iter.into_iter().copied())
    = note: `-D clippy::from-iter-instead-of-collect` implied by `-D warnings`
 
 error: usage of `FromIterator::from_iter`
-  --> $DIR/from_iter_instead_of_collect.rs:25:13
+  --> $DIR/from_iter_instead_of_collect.rs:24:13
    |
 LL |     let _ = Vec::from_iter(iter_expr);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `iter_expr.collect::<Vec<_>>()`
 
 error: usage of `FromIterator::from_iter`
-  --> $DIR/from_iter_instead_of_collect.rs:27:13
+  --> $DIR/from_iter_instead_of_collect.rs:26:13
    |
 LL |     let _ = HashMap::<usize, &i8>::from_iter(vec![5, 5, 5, 5].iter().enumerate());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `vec![5, 5, 5, 5].iter().enumerate().collect::<HashMap<usize, &i8>>()`
 
 error: usage of `FromIterator::from_iter`
-  --> $DIR/from_iter_instead_of_collect.rs:32:19
+  --> $DIR/from_iter_instead_of_collect.rs:31:19
    |
 LL |     assert_eq!(a, Vec::from_iter(0..3));
    |                   ^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `(0..3).collect::<Vec<_>>()`
 
 error: usage of `FromIterator::from_iter`
-  --> $DIR/from_iter_instead_of_collect.rs:33:19
+  --> $DIR/from_iter_instead_of_collect.rs:32:19
    |
 LL |     assert_eq!(a, Vec::<i32>::from_iter(0..3));
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `(0..3).collect::<Vec<i32>>()`
 
 error: usage of `FromIterator::from_iter`
-  --> $DIR/from_iter_instead_of_collect.rs:35:17
+  --> $DIR/from_iter_instead_of_collect.rs:34:17
    |
 LL |     let mut b = VecDeque::from_iter(0..3);
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `(0..3).collect::<VecDeque<_>>()`
 
 error: usage of `FromIterator::from_iter`
-  --> $DIR/from_iter_instead_of_collect.rs:38:17
+  --> $DIR/from_iter_instead_of_collect.rs:37:17
    |
 LL |     let mut b = VecDeque::<i32>::from_iter(0..3);
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `(0..3).collect::<VecDeque<i32>>()`
 
 error: usage of `FromIterator::from_iter`
-  --> $DIR/from_iter_instead_of_collect.rs:43:21
+  --> $DIR/from_iter_instead_of_collect.rs:42:21
    |
 LL |         let mut b = collections::VecDeque::<i32>::from_iter(0..3);
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `(0..3).collect::<collections::VecDeque<i32>>()`
 
 error: usage of `FromIterator::from_iter`
-  --> $DIR/from_iter_instead_of_collect.rs:48:14
+  --> $DIR/from_iter_instead_of_collect.rs:47:14
    |
 LL |     let bm = BTreeMap::from_iter(values.iter().cloned());
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `values.iter().cloned().collect::<BTreeMap<_, _>>()`
 
 error: usage of `FromIterator::from_iter`
-  --> $DIR/from_iter_instead_of_collect.rs:49:19
+  --> $DIR/from_iter_instead_of_collect.rs:48:19
    |
 LL |     let mut bar = BTreeMap::from_iter(bm.range(0..2));
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `bm.range(0..2).collect::<BTreeMap<_, _>>()`
 
 error: usage of `FromIterator::from_iter`
-  --> $DIR/from_iter_instead_of_collect.rs:52:19
+  --> $DIR/from_iter_instead_of_collect.rs:51:19
    |
 LL |     let mut bts = BTreeSet::from_iter(0..3);
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `(0..3).collect::<BTreeSet<_>>()`
 
 error: usage of `FromIterator::from_iter`
-  --> $DIR/from_iter_instead_of_collect.rs:56:17
+  --> $DIR/from_iter_instead_of_collect.rs:55:17
    |
 LL |         let _ = collections::BTreeSet::from_iter(0..3);
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `(0..3).collect::<collections::BTreeSet<_>>()`
 
 error: usage of `FromIterator::from_iter`
-  --> $DIR/from_iter_instead_of_collect.rs:57:17
+  --> $DIR/from_iter_instead_of_collect.rs:56:17
    |
 LL |         let _ = collections::BTreeSet::<u32>::from_iter(0..3);
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `(0..3).collect::<collections::BTreeSet<u32>>()`
 
 error: usage of `FromIterator::from_iter`
-  --> $DIR/from_iter_instead_of_collect.rs:60:15
+  --> $DIR/from_iter_instead_of_collect.rs:59:15
    |
 LL |     for _i in Vec::from_iter([1, 2, 3].iter()) {}
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `[1, 2, 3].iter().collect::<Vec<_>>()`
 
 error: usage of `FromIterator::from_iter`
-  --> $DIR/from_iter_instead_of_collect.rs:61:15
+  --> $DIR/from_iter_instead_of_collect.rs:60:15
    |
 LL |     for _i in Vec::<&i32>::from_iter([1, 2, 3].iter()) {}
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `[1, 2, 3].iter().collect::<Vec<&i32>>()`
diff --git a/tests/ui/get_unwrap.fixed b/tests/ui/get_unwrap.fixed
index c3a36dcabd1..8f165d67589 100644
--- a/tests/ui/get_unwrap.fixed
+++ b/tests/ui/get_unwrap.fixed
@@ -7,7 +7,6 @@
 use std::collections::BTreeMap;
 use std::collections::HashMap;
 use std::collections::VecDeque;
-use std::iter::FromIterator;
 
 struct GetFalsePositive {
     arr: [u32; 3],
diff --git a/tests/ui/get_unwrap.rs b/tests/ui/get_unwrap.rs
index d77a202aa39..786749daa74 100644
--- a/tests/ui/get_unwrap.rs
+++ b/tests/ui/get_unwrap.rs
@@ -7,7 +7,6 @@
 use std::collections::BTreeMap;
 use std::collections::HashMap;
 use std::collections::VecDeque;
-use std::iter::FromIterator;
 
 struct GetFalsePositive {
     arr: [u32; 3],
diff --git a/tests/ui/get_unwrap.stderr b/tests/ui/get_unwrap.stderr
index cb5f44fbd59..ea8fec52735 100644
--- a/tests/ui/get_unwrap.stderr
+++ b/tests/ui/get_unwrap.stderr
@@ -1,5 +1,5 @@
 error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more concise
-  --> $DIR/get_unwrap.rs:36:17
+  --> $DIR/get_unwrap.rs:35:17
    |
 LL |         let _ = boxed_slice.get(1).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&boxed_slice[1]`
@@ -11,7 +11,7 @@ LL | #![deny(clippy::get_unwrap)]
    |         ^^^^^^^^^^^^^^^^^^
 
 error: used `unwrap()` on `an Option` value
-  --> $DIR/get_unwrap.rs:36:17
+  --> $DIR/get_unwrap.rs:35:17
    |
 LL |         let _ = boxed_slice.get(1).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -20,13 +20,13 @@ LL |         let _ = boxed_slice.get(1).unwrap();
    = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
 
 error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more concise
-  --> $DIR/get_unwrap.rs:37:17
+  --> $DIR/get_unwrap.rs:36:17
    |
 LL |         let _ = some_slice.get(0).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&some_slice[0]`
 
 error: used `unwrap()` on `an Option` value
-  --> $DIR/get_unwrap.rs:37:17
+  --> $DIR/get_unwrap.rs:36:17
    |
 LL |         let _ = some_slice.get(0).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -34,13 +34,13 @@ LL |         let _ = some_slice.get(0).unwrap();
    = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
 
 error: called `.get().unwrap()` on a Vec. Using `[]` is more clear and more concise
-  --> $DIR/get_unwrap.rs:38:17
+  --> $DIR/get_unwrap.rs:37:17
    |
 LL |         let _ = some_vec.get(0).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&some_vec[0]`
 
 error: used `unwrap()` on `an Option` value
-  --> $DIR/get_unwrap.rs:38:17
+  --> $DIR/get_unwrap.rs:37:17
    |
 LL |         let _ = some_vec.get(0).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -48,13 +48,13 @@ LL |         let _ = some_vec.get(0).unwrap();
    = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
 
 error: called `.get().unwrap()` on a VecDeque. Using `[]` is more clear and more concise
-  --> $DIR/get_unwrap.rs:39:17
+  --> $DIR/get_unwrap.rs:38:17
    |
 LL |         let _ = some_vecdeque.get(0).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&some_vecdeque[0]`
 
 error: used `unwrap()` on `an Option` value
-  --> $DIR/get_unwrap.rs:39:17
+  --> $DIR/get_unwrap.rs:38:17
    |
 LL |         let _ = some_vecdeque.get(0).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -62,13 +62,13 @@ LL |         let _ = some_vecdeque.get(0).unwrap();
    = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
 
 error: called `.get().unwrap()` on a HashMap. Using `[]` is more clear and more concise
-  --> $DIR/get_unwrap.rs:40:17
+  --> $DIR/get_unwrap.rs:39:17
    |
 LL |         let _ = some_hashmap.get(&1).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&some_hashmap[&1]`
 
 error: used `unwrap()` on `an Option` value
-  --> $DIR/get_unwrap.rs:40:17
+  --> $DIR/get_unwrap.rs:39:17
    |
 LL |         let _ = some_hashmap.get(&1).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -76,13 +76,13 @@ LL |         let _ = some_hashmap.get(&1).unwrap();
    = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
 
 error: called `.get().unwrap()` on a BTreeMap. Using `[]` is more clear and more concise
-  --> $DIR/get_unwrap.rs:41:17
+  --> $DIR/get_unwrap.rs:40:17
    |
 LL |         let _ = some_btreemap.get(&1).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&some_btreemap[&1]`
 
 error: used `unwrap()` on `an Option` value
-  --> $DIR/get_unwrap.rs:41:17
+  --> $DIR/get_unwrap.rs:40:17
    |
 LL |         let _ = some_btreemap.get(&1).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -90,13 +90,13 @@ LL |         let _ = some_btreemap.get(&1).unwrap();
    = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
 
 error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more concise
-  --> $DIR/get_unwrap.rs:45:21
+  --> $DIR/get_unwrap.rs:44:21
    |
 LL |         let _: u8 = *boxed_slice.get(1).unwrap();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `boxed_slice[1]`
 
 error: used `unwrap()` on `an Option` value
-  --> $DIR/get_unwrap.rs:45:22
+  --> $DIR/get_unwrap.rs:44:22
    |
 LL |         let _: u8 = *boxed_slice.get(1).unwrap();
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -104,13 +104,13 @@ LL |         let _: u8 = *boxed_slice.get(1).unwrap();
    = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
 
 error: called `.get_mut().unwrap()` on a slice. Using `[]` is more clear and more concise
-  --> $DIR/get_unwrap.rs:50:9
+  --> $DIR/get_unwrap.rs:49:9
    |
 LL |         *boxed_slice.get_mut(0).unwrap() = 1;
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `boxed_slice[0]`
 
 error: used `unwrap()` on `an Option` value
-  --> $DIR/get_unwrap.rs:50:10
+  --> $DIR/get_unwrap.rs:49:10
    |
 LL |         *boxed_slice.get_mut(0).unwrap() = 1;
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -118,13 +118,13 @@ LL |         *boxed_slice.get_mut(0).unwrap() = 1;
    = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
 
 error: called `.get_mut().unwrap()` on a slice. Using `[]` is more clear and more concise
-  --> $DIR/get_unwrap.rs:51:9
+  --> $DIR/get_unwrap.rs:50:9
    |
 LL |         *some_slice.get_mut(0).unwrap() = 1;
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `some_slice[0]`
 
 error: used `unwrap()` on `an Option` value
-  --> $DIR/get_unwrap.rs:51:10
+  --> $DIR/get_unwrap.rs:50:10
    |
 LL |         *some_slice.get_mut(0).unwrap() = 1;
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -132,13 +132,13 @@ LL |         *some_slice.get_mut(0).unwrap() = 1;
    = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
 
 error: called `.get_mut().unwrap()` on a Vec. Using `[]` is more clear and more concise
-  --> $DIR/get_unwrap.rs:52:9
+  --> $DIR/get_unwrap.rs:51:9
    |
 LL |         *some_vec.get_mut(0).unwrap() = 1;
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `some_vec[0]`
 
 error: used `unwrap()` on `an Option` value
-  --> $DIR/get_unwrap.rs:52:10
+  --> $DIR/get_unwrap.rs:51:10
    |
 LL |         *some_vec.get_mut(0).unwrap() = 1;
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -146,13 +146,13 @@ LL |         *some_vec.get_mut(0).unwrap() = 1;
    = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
 
 error: called `.get_mut().unwrap()` on a VecDeque. Using `[]` is more clear and more concise
-  --> $DIR/get_unwrap.rs:53:9
+  --> $DIR/get_unwrap.rs:52:9
    |
 LL |         *some_vecdeque.get_mut(0).unwrap() = 1;
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `some_vecdeque[0]`
 
 error: used `unwrap()` on `an Option` value
-  --> $DIR/get_unwrap.rs:53:10
+  --> $DIR/get_unwrap.rs:52:10
    |
 LL |         *some_vecdeque.get_mut(0).unwrap() = 1;
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -160,13 +160,13 @@ LL |         *some_vecdeque.get_mut(0).unwrap() = 1;
    = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
 
 error: called `.get().unwrap()` on a Vec. Using `[]` is more clear and more concise
-  --> $DIR/get_unwrap.rs:65:17
+  --> $DIR/get_unwrap.rs:64:17
    |
 LL |         let _ = some_vec.get(0..1).unwrap().to_vec();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `some_vec[0..1]`
 
 error: used `unwrap()` on `an Option` value
-  --> $DIR/get_unwrap.rs:65:17
+  --> $DIR/get_unwrap.rs:64:17
    |
 LL |         let _ = some_vec.get(0..1).unwrap().to_vec();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -174,13 +174,13 @@ LL |         let _ = some_vec.get(0..1).unwrap().to_vec();
    = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
 
 error: called `.get_mut().unwrap()` on a Vec. Using `[]` is more clear and more concise
-  --> $DIR/get_unwrap.rs:66:17
+  --> $DIR/get_unwrap.rs:65:17
    |
 LL |         let _ = some_vec.get_mut(0..1).unwrap().to_vec();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `some_vec[0..1]`
 
 error: used `unwrap()` on `an Option` value
-  --> $DIR/get_unwrap.rs:66:17
+  --> $DIR/get_unwrap.rs:65:17
    |
 LL |         let _ = some_vec.get_mut(0..1).unwrap().to_vec();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/infinite_iter.rs b/tests/ui/infinite_iter.rs
index 1fe68897765..a1e5fad0c62 100644
--- a/tests/ui/infinite_iter.rs
+++ b/tests/ui/infinite_iter.rs
@@ -51,7 +51,6 @@ fn main() {
 
 mod finite_collect {
     use std::collections::HashSet;
-    use std::iter::FromIterator;
 
     struct C;
     impl FromIterator<i32> for C {
diff --git a/tests/ui/infinite_iter.stderr b/tests/ui/infinite_iter.stderr
index 5f5e7ac9f25..ba277e36339 100644
--- a/tests/ui/infinite_iter.stderr
+++ b/tests/ui/infinite_iter.stderr
@@ -98,7 +98,7 @@ LL |     (0..).all(|x| x == 24); // maybe infinite iter
    |     ^^^^^^^^^^^^^^^^^^^^^^
 
 error: infinite iteration detected
-  --> $DIR/infinite_iter.rs:64:31
+  --> $DIR/infinite_iter.rs:63:31
    |
 LL |         let _: HashSet<i32> = (0..).collect(); // Infinite iter
    |                               ^^^^^^^^^^^^^^^
diff --git a/tests/ui/manual_str_repeat.fixed b/tests/ui/manual_str_repeat.fixed
index dc140257f32..0704ba2f933 100644
--- a/tests/ui/manual_str_repeat.fixed
+++ b/tests/ui/manual_str_repeat.fixed
@@ -4,7 +4,7 @@
 #![warn(clippy::manual_str_repeat)]
 
 use std::borrow::Cow;
-use std::iter::{repeat, FromIterator};
+use std::iter::repeat;
 
 fn main() {
     let _: String = "test".repeat(10);
diff --git a/tests/ui/manual_str_repeat.rs b/tests/ui/manual_str_repeat.rs
index 0d69c989b2e..f522be439aa 100644
--- a/tests/ui/manual_str_repeat.rs
+++ b/tests/ui/manual_str_repeat.rs
@@ -4,7 +4,7 @@
 #![warn(clippy::manual_str_repeat)]
 
 use std::borrow::Cow;
-use std::iter::{repeat, FromIterator};
+use std::iter::repeat;
 
 fn main() {
     let _: String = std::iter::repeat("test").take(10).collect();
diff --git a/tests/ui/map_err.rs b/tests/ui/map_err.rs
index 00e037843f8..bb35ab1a14e 100644
--- a/tests/ui/map_err.rs
+++ b/tests/ui/map_err.rs
@@ -1,6 +1,5 @@
 #![warn(clippy::map_err_ignore)]
 #![allow(clippy::unnecessary_wraps)]
-use std::convert::TryFrom;
 use std::error::Error;
 use std::fmt;
 
diff --git a/tests/ui/map_err.stderr b/tests/ui/map_err.stderr
index 37e87e64de2..c035840521e 100644
--- a/tests/ui/map_err.stderr
+++ b/tests/ui/map_err.stderr
@@ -1,5 +1,5 @@
 error: `map_err(|_|...` wildcard pattern discards the original error
-  --> $DIR/map_err.rs:23:32
+  --> $DIR/map_err.rs:22:32
    |
 LL |     println!("{:?}", x.map_err(|_| Errors::Ignored));
    |                                ^^^
diff --git a/tests/ui/methods.rs b/tests/ui/methods.rs
index 977ce54327b..9805097084d 100644
--- a/tests/ui/methods.rs
+++ b/tests/ui/methods.rs
@@ -26,7 +26,6 @@ use std::collections::BTreeMap;
 use std::collections::HashMap;
 use std::collections::HashSet;
 use std::collections::VecDeque;
-use std::iter::FromIterator;
 use std::ops::Mul;
 use std::rc::{self, Rc};
 use std::sync::{self, Arc};
diff --git a/tests/ui/methods.stderr b/tests/ui/methods.stderr
index b63672dd6fd..6be38b24fbd 100644
--- a/tests/ui/methods.stderr
+++ b/tests/ui/methods.stderr
@@ -1,5 +1,5 @@
 error: methods called `new` usually return `Self`
-  --> $DIR/methods.rs:104:5
+  --> $DIR/methods.rs:103:5
    |
 LL | /     fn new() -> i32 {
 LL | |         0
@@ -9,7 +9,7 @@ LL | |     }
    = note: `-D clippy::new-ret-no-self` implied by `-D warnings`
 
 error: called `filter(..).next()` on an `Iterator`. This is more succinctly expressed by calling `.find(..)` instead
-  --> $DIR/methods.rs:125:13
+  --> $DIR/methods.rs:124:13
    |
 LL |       let _ = v.iter().filter(|&x| {
    |  _____________^
diff --git a/tests/ui/useless_conversion_try.rs b/tests/ui/useless_conversion_try.rs
index 3787ea99144..39f54c27bee 100644
--- a/tests/ui/useless_conversion_try.rs
+++ b/tests/ui/useless_conversion_try.rs
@@ -1,7 +1,5 @@
 #![deny(clippy::useless_conversion)]
 
-use std::convert::{TryFrom, TryInto};
-
 fn test_generic<T: Copy>(val: T) -> T {
     let _ = T::try_from(val).unwrap();
     val.try_into().unwrap()
diff --git a/tests/ui/useless_conversion_try.stderr b/tests/ui/useless_conversion_try.stderr
index 2e0d9129bfb..b691c13f7db 100644
--- a/tests/ui/useless_conversion_try.stderr
+++ b/tests/ui/useless_conversion_try.stderr
@@ -1,5 +1,5 @@
 error: useless conversion to the same type: `T`
-  --> $DIR/useless_conversion_try.rs:6:13
+  --> $DIR/useless_conversion_try.rs:4:13
    |
 LL |     let _ = T::try_from(val).unwrap();
    |             ^^^^^^^^^^^^^^^^
@@ -12,7 +12,7 @@ LL | #![deny(clippy::useless_conversion)]
    = help: consider removing `T::try_from()`
 
 error: useless conversion to the same type: `T`
-  --> $DIR/useless_conversion_try.rs:7:5
+  --> $DIR/useless_conversion_try.rs:5:5
    |
 LL |     val.try_into().unwrap()
    |     ^^^^^^^^^^^^^^
@@ -20,7 +20,7 @@ LL |     val.try_into().unwrap()
    = help: consider removing `.try_into()`
 
 error: useless conversion to the same type: `std::string::String`
-  --> $DIR/useless_conversion_try.rs:29:21
+  --> $DIR/useless_conversion_try.rs:27:21
    |
 LL |     let _: String = "foo".to_string().try_into().unwrap();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -28,7 +28,7 @@ LL |     let _: String = "foo".to_string().try_into().unwrap();
    = help: consider removing `.try_into()`
 
 error: useless conversion to the same type: `std::string::String`
-  --> $DIR/useless_conversion_try.rs:30:21
+  --> $DIR/useless_conversion_try.rs:28:21
    |
 LL |     let _: String = TryFrom::try_from("foo".to_string()).unwrap();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -36,7 +36,7 @@ LL |     let _: String = TryFrom::try_from("foo".to_string()).unwrap();
    = help: consider removing `TryFrom::try_from()`
 
 error: useless conversion to the same type: `std::string::String`
-  --> $DIR/useless_conversion_try.rs:31:13
+  --> $DIR/useless_conversion_try.rs:29:13
    |
 LL |     let _ = String::try_from("foo".to_string()).unwrap();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -44,7 +44,7 @@ LL |     let _ = String::try_from("foo".to_string()).unwrap();
    = help: consider removing `String::try_from()`
 
 error: useless conversion to the same type: `std::string::String`
-  --> $DIR/useless_conversion_try.rs:32:13
+  --> $DIR/useless_conversion_try.rs:30:13
    |
 LL |     let _ = String::try_from(format!("A: {:04}", 123)).unwrap();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -52,7 +52,7 @@ LL |     let _ = String::try_from(format!("A: {:04}", 123)).unwrap();
    = help: consider removing `String::try_from()`
 
 error: useless conversion to the same type: `std::string::String`
-  --> $DIR/useless_conversion_try.rs:33:21
+  --> $DIR/useless_conversion_try.rs:31:21
    |
 LL |     let _: String = format!("Hello {}", "world").try_into().unwrap();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -60,7 +60,7 @@ LL |     let _: String = format!("Hello {}", "world").try_into().unwrap();
    = help: consider removing `.try_into()`
 
 error: useless conversion to the same type: `std::string::String`
-  --> $DIR/useless_conversion_try.rs:34:21
+  --> $DIR/useless_conversion_try.rs:32:21
    |
 LL |     let _: String = "".to_owned().try_into().unwrap();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -68,7 +68,7 @@ LL |     let _: String = "".to_owned().try_into().unwrap();
    = help: consider removing `.try_into()`
 
 error: useless conversion to the same type: `std::string::String`
-  --> $DIR/useless_conversion_try.rs:35:27
+  --> $DIR/useless_conversion_try.rs:33:27
    |
 LL |     let _: String = match String::from("_").try_into() {
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From 344888a5820c2ae2d7c88ecf14bcaffb60ca2bc5 Mon Sep 17 00:00:00 2001
From: yonip23 <yoni@tabnine.com>
Date: Wed, 11 May 2022 23:11:52 +0300
Subject: fix review comments

---
 clippy_lints/src/rc_clone_in_vec_init.rs | 72 ++++++++++++++------------------
 tests/ui/rc_clone_in_vec_init/arc.rs     |  9 ++++
 tests/ui/rc_clone_in_vec_init/arc.stderr | 36 ++++++++++++++--
 tests/ui/rc_clone_in_vec_init/rc.rs      |  9 ++++
 tests/ui/rc_clone_in_vec_init/rc.stderr  | 36 ++++++++++++++--
 5 files changed, 115 insertions(+), 47 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/rc_clone_in_vec_init.rs b/clippy_lints/src/rc_clone_in_vec_init.rs
index aa575d7e68b..7a7a3f558ca 100644
--- a/clippy_lints/src/rc_clone_in_vec_init.rs
+++ b/clippy_lints/src/rc_clone_in_vec_init.rs
@@ -3,7 +3,7 @@ use clippy_utils::higher::VecArgs;
 use clippy_utils::last_path_segment;
 use clippy_utils::macros::root_macro_call_first_node;
 use clippy_utils::source::{indent_of, snippet};
-use rustc_errors::{Applicability, Diagnostic};
+use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, QPath, TyKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -51,70 +51,53 @@ impl LateLintPass<'_> for RcCloneInVecInit {
         let Some(macro_call) = root_macro_call_first_node(cx, expr) else { return; };
         let Some(VecArgs::Repeat(elem, len)) = VecArgs::hir(cx, expr) else { return; };
         let Some(symbol) = new_reference_call(cx, elem) else { return; };
-        let lint_span = macro_call.span;
-        let symbol_name = symbol.as_str();
-        let len_snippet = snippet(cx, len.span, "..");
-        let elem_snippet = elem_snippet(cx, elem, symbol_name);
-        let indentation = indent_of(cx, lint_span).unwrap_or(0);
-        let lint_suggestions =
-            construct_lint_suggestions(lint_span, symbol_name, &elem_snippet, len_snippet.as_ref(), indentation);
-
-        emit_lint(cx, symbol, lint_span, &lint_suggestions);
+
+        emit_lint(cx, symbol, macro_call.span, elem, len);
     }
 }
 
 struct LintSuggestion {
-    span: Span,
     message: String,
-    suggestion: String,
-    applicability: Applicability,
-}
-
-impl LintSuggestion {
-    fn span_suggestion(&self, diag: &mut Diagnostic) {
-        diag.span_suggestion(self.span, &self.message, &self.suggestion, self.applicability);
-    }
+    snippet: String,
 }
 
 fn construct_lint_suggestions(
+    cx: &LateContext<'_>,
     span: Span,
     symbol_name: &str,
-    elem_snippet: &str,
-    len_snippet: &str,
-    indentation: usize,
+    elem: &Expr<'_>,
+    len: &Expr<'_>,
 ) -> Vec<LintSuggestion> {
+    let len_snippet = snippet(cx, len.span, "..");
+    let elem_snippet = elem_snippet(cx, elem, symbol_name);
+    let indentation = indent_of(cx, span).unwrap_or(0);
     let indentation = " ".repeat(indentation);
-    let loop_init_suggestion = loop_init_suggestion(elem_snippet, len_snippet, &indentation);
-    let extract_suggestion = extract_suggestion(elem_snippet, len_snippet, &indentation);
+    let loop_init_suggestion = loop_init_suggestion(&elem_snippet, len_snippet.as_ref(), &indentation);
+    let extract_suggestion = extract_suggestion(&elem_snippet, len_snippet.as_ref(), &indentation);
 
     vec![
         LintSuggestion {
-            span,
             message: format!("consider initializing each `{symbol_name}` element individually"),
-            suggestion: loop_init_suggestion,
-            applicability: Applicability::Unspecified,
+            snippet: loop_init_suggestion,
         },
         LintSuggestion {
-            span,
             message: format!(
                 "or if this is intentional, consider extracting the `{symbol_name}` initialization to a variable"
             ),
-            suggestion: extract_suggestion,
-            applicability: Applicability::Unspecified,
+            snippet: extract_suggestion,
         },
     ]
 }
 
 fn elem_snippet(cx: &LateContext<'_>, elem: &Expr<'_>, symbol_name: &str) -> String {
-    let mut elem_snippet = snippet(cx, elem.span, "..").to_string();
+    let elem_snippet = snippet(cx, elem.span, "..").to_string();
     if elem_snippet.contains('\n') {
-        let reference_initialization = format!("{symbol_name}::new");
-        // This string must be found in `elem_snippet`, otherwise we won't be constructing the snippet in
-        // the first place.
-        let reference_initialization_end =
-            elem_snippet.find(&reference_initialization).unwrap() + reference_initialization.len();
-        elem_snippet.replace_range(reference_initialization_end.., "..");
+        let reference_creation = format!("{symbol_name}::new");
+        let (code_until_reference_creation, _right) = elem_snippet.split_once(&reference_creation).unwrap();
+
+        return format!("{code_until_reference_creation}{reference_creation}(..)");
     }
+
     elem_snippet
 }
 
@@ -137,7 +120,7 @@ fn extract_suggestion(elem: &str, len: &str, indent: &str) -> String {
     )
 }
 
-fn emit_lint(cx: &LateContext<'_>, symbol: Symbol, lint_span: Span, lint_suggestions: &[LintSuggestion]) {
+fn emit_lint(cx: &LateContext<'_>, symbol: Symbol, lint_span: Span, elem: &Expr<'_>, len: &Expr<'_>) {
     let symbol_name = symbol.as_str();
 
     span_lint_and_then(
@@ -146,10 +129,17 @@ fn emit_lint(cx: &LateContext<'_>, symbol: Symbol, lint_span: Span, lint_suggest
         lint_span,
         &format!("calling `{symbol_name}::new` in `vec![elem; len]`"),
         |diag| {
+            let suggestions = construct_lint_suggestions(cx, lint_span, symbol_name, elem, len);
+
             diag.note(format!("each element will point to the same `{symbol_name}` instance"));
-            lint_suggestions
-                .iter()
-                .for_each(|suggestion| suggestion.span_suggestion(diag));
+            suggestions.iter().for_each(|suggestion| {
+                diag.span_suggestion(
+                    lint_span,
+                    &suggestion.message,
+                    &suggestion.snippet,
+                    Applicability::Unspecified,
+                );
+            });
         },
     );
 }
diff --git a/tests/ui/rc_clone_in_vec_init/arc.rs b/tests/ui/rc_clone_in_vec_init/arc.rs
index 9f4e27dfa62..bef2c67a1a5 100644
--- a/tests/ui/rc_clone_in_vec_init/arc.rs
+++ b/tests/ui/rc_clone_in_vec_init/arc.rs
@@ -16,6 +16,15 @@ fn should_warn_complex_case() {
         }));
         2
     ];
+
+    let v1 = vec![
+        Arc::new(Mutex::new({
+            let x = 1;
+            dbg!(x);
+            x
+        }));
+        2
+    ];
 }
 
 fn should_not_warn_custom_arc() {
diff --git a/tests/ui/rc_clone_in_vec_init/arc.stderr b/tests/ui/rc_clone_in_vec_init/arc.stderr
index 3de96c6f175..387580c2431 100644
--- a/tests/ui/rc_clone_in_vec_init/arc.stderr
+++ b/tests/ui/rc_clone_in_vec_init/arc.stderr
@@ -40,17 +40,47 @@ help: consider initializing each `Arc` element individually
    |
 LL ~     let v = {
 LL +         let mut v = Vec::with_capacity(2);
-LL +         (0..2).for_each(|_| v.push(std::sync::Arc::new..));
+LL +         (0..2).for_each(|_| v.push(std::sync::Arc::new(..)));
 LL +         v
 LL ~     };
    |
 help: or if this is intentional, consider extracting the `Arc` initialization to a variable
    |
 LL ~     let v = {
-LL +         let data = std::sync::Arc::new..;
+LL +         let data = std::sync::Arc::new(..);
 LL +         vec![data; 2]
 LL ~     };
    |
 
-error: aborting due to 2 previous errors
+error: calling `Arc::new` in `vec![elem; len]`
+  --> $DIR/arc.rs:20:14
+   |
+LL |       let v1 = vec![
+   |  ______________^
+LL | |         Arc::new(Mutex::new({
+LL | |             let x = 1;
+LL | |             dbg!(x);
+...  |
+LL | |         2
+LL | |     ];
+   | |_____^
+   |
+   = note: each element will point to the same `Arc` instance
+help: consider initializing each `Arc` element individually
+   |
+LL ~     let v1 = {
+LL +         let mut v = Vec::with_capacity(2);
+LL +         (0..2).for_each(|_| v.push(Arc::new(..)));
+LL +         v
+LL ~     };
+   |
+help: or if this is intentional, consider extracting the `Arc` initialization to a variable
+   |
+LL ~     let v1 = {
+LL +         let data = Arc::new(..);
+LL +         vec![data; 2]
+LL ~     };
+   |
+
+error: aborting due to 3 previous errors
 
diff --git a/tests/ui/rc_clone_in_vec_init/rc.rs b/tests/ui/rc_clone_in_vec_init/rc.rs
index 5e2834aa902..79c23cafa2c 100644
--- a/tests/ui/rc_clone_in_vec_init/rc.rs
+++ b/tests/ui/rc_clone_in_vec_init/rc.rs
@@ -17,6 +17,15 @@ fn should_warn_complex_case() {
         }));
         2
     ];
+
+    let v1 = vec![
+        Rc::new(Mutex::new({
+            let x = 1;
+            dbg!(x);
+            x
+        }));
+        2
+    ];
 }
 
 fn should_not_warn_custom_arc() {
diff --git a/tests/ui/rc_clone_in_vec_init/rc.stderr b/tests/ui/rc_clone_in_vec_init/rc.stderr
index e05f024cf9d..4ce53eecbbd 100644
--- a/tests/ui/rc_clone_in_vec_init/rc.stderr
+++ b/tests/ui/rc_clone_in_vec_init/rc.stderr
@@ -40,17 +40,47 @@ help: consider initializing each `Rc` element individually
    |
 LL ~     let v = {
 LL +         let mut v = Vec::with_capacity(2);
-LL +         (0..2).for_each(|_| v.push(std::rc::Rc::new..));
+LL +         (0..2).for_each(|_| v.push(std::rc::Rc::new(..)));
 LL +         v
 LL ~     };
    |
 help: or if this is intentional, consider extracting the `Rc` initialization to a variable
    |
 LL ~     let v = {
-LL +         let data = std::rc::Rc::new..;
+LL +         let data = std::rc::Rc::new(..);
 LL +         vec![data; 2]
 LL ~     };
    |
 
-error: aborting due to 2 previous errors
+error: calling `Rc::new` in `vec![elem; len]`
+  --> $DIR/rc.rs:21:14
+   |
+LL |       let v1 = vec![
+   |  ______________^
+LL | |         Rc::new(Mutex::new({
+LL | |             let x = 1;
+LL | |             dbg!(x);
+...  |
+LL | |         2
+LL | |     ];
+   | |_____^
+   |
+   = note: each element will point to the same `Rc` instance
+help: consider initializing each `Rc` element individually
+   |
+LL ~     let v1 = {
+LL +         let mut v = Vec::with_capacity(2);
+LL +         (0..2).for_each(|_| v.push(Rc::new(..)));
+LL +         v
+LL ~     };
+   |
+help: or if this is intentional, consider extracting the `Rc` initialization to a variable
+   |
+LL ~     let v1 = {
+LL +         let data = Rc::new(..);
+LL +         vec![data; 2]
+LL ~     };
+   |
+
+error: aborting due to 3 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From a791205e76fe9619f90d4869ab54e4213847b8fe Mon Sep 17 00:00:00 2001
From: yonip23 <yoni@tabnine.com>
Date: Wed, 11 May 2022 23:16:49 +0300
Subject: fix clippy warning

---
 clippy_lints/src/rc_clone_in_vec_init.rs | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/rc_clone_in_vec_init.rs b/clippy_lints/src/rc_clone_in_vec_init.rs
index 7a7a3f558ca..ee119e8c4a4 100644
--- a/clippy_lints/src/rc_clone_in_vec_init.rs
+++ b/clippy_lints/src/rc_clone_in_vec_init.rs
@@ -92,6 +92,8 @@ fn construct_lint_suggestions(
 fn elem_snippet(cx: &LateContext<'_>, elem: &Expr<'_>, symbol_name: &str) -> String {
     let elem_snippet = snippet(cx, elem.span, "..").to_string();
     if elem_snippet.contains('\n') {
+        // This string must be found in `elem_snippet`, otherwise we won't be constructing
+        // the snippet in the first place.
         let reference_creation = format!("{symbol_name}::new");
         let (code_until_reference_creation, _right) = elem_snippet.split_once(&reference_creation).unwrap();
 
@@ -132,14 +134,14 @@ fn emit_lint(cx: &LateContext<'_>, symbol: Symbol, lint_span: Span, elem: &Expr<
             let suggestions = construct_lint_suggestions(cx, lint_span, symbol_name, elem, len);
 
             diag.note(format!("each element will point to the same `{symbol_name}` instance"));
-            suggestions.iter().for_each(|suggestion| {
+            for suggestion in suggestions {
                 diag.span_suggestion(
                     lint_span,
                     &suggestion.message,
                     &suggestion.snippet,
                     Applicability::Unspecified,
                 );
-            });
+            }
         },
     );
 }
-- 
cgit 1.4.1-3-g733a5


From 9e66f2d05844fb6e6972f347629bd77e08fee8d4 Mon Sep 17 00:00:00 2001
From: tamaron <tamaron1203@gmail.com>
Date: Thu, 12 May 2022 12:33:05 +0900
Subject: fix

---
 clippy_lints/src/undocumented_unsafe_blocks.rs | 17 +++++++----------
 1 file changed, 7 insertions(+), 10 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/undocumented_unsafe_blocks.rs b/clippy_lints/src/undocumented_unsafe_blocks.rs
index bde7613b48e..5a8677f90be 100644
--- a/clippy_lints/src/undocumented_unsafe_blocks.rs
+++ b/clippy_lints/src/undocumented_unsafe_blocks.rs
@@ -142,20 +142,19 @@ fn block_has_safety_comment(cx: &LateContext<'_>, block: &hir::Block<'_>) -> boo
 /// Checks if the lines immediately preceding the item contain a safety comment.
 #[allow(clippy::collapsible_match)]
 fn item_has_safety_comment(cx: &LateContext<'_>, item: &hir::Item<'_>) -> bool {
-    if span_from_macro_expansion_has_safety_comment(cx, item.span) || span_in_body_has_safety_comment(cx, item.span) {
+    if span_from_macro_expansion_has_safety_comment(cx, item.span) {
         return true;
     }
 
     if item.span.ctxt() == SyntaxContext::root() {
         if let Some(parent_node) = get_parent_node(cx.tcx, item.hir_id()) {
-            let comment_start;
-            match parent_node {
+            let comment_start = match parent_node {
                 Node::Crate(parent_mod) => {
-                    comment_start = comment_start_before_impl_in_mod(cx, parent_mod, parent_mod.spans.inner_span, item);
+                    comment_start_before_impl_in_mod(cx, parent_mod, parent_mod.spans.inner_span, item)
                 },
                 Node::Item(parent_item) => {
                     if let ItemKind::Mod(parent_mod) = &parent_item.kind {
-                        comment_start = comment_start_before_impl_in_mod(cx, parent_mod, parent_item.span, item);
+                        comment_start_before_impl_in_mod(cx, parent_mod, parent_item.span, item)
                     } else {
                         // Doesn't support impls in this position. Pretend a comment was found.
                         return true;
@@ -164,16 +163,14 @@ fn item_has_safety_comment(cx: &LateContext<'_>, item: &hir::Item<'_>) -> bool {
                 Node::Stmt(stmt) => {
                     if let Some(stmt_parent) = get_parent_node(cx.tcx, stmt.hir_id) {
                         match stmt_parent {
-                            Node::Block(block) => {
-                                comment_start = walk_span_to_context(block.span, SyntaxContext::root()).map(Span::lo);
-                            },
+                            Node::Block(block) => walk_span_to_context(block.span, SyntaxContext::root()).map(Span::lo),
                             _ => {
                                 // Doesn't support impls in this position. Pretend a comment was found.
                                 return true;
                             },
                         }
                     } else {
-                        // Doesn't support impls in this position. Pretend a comment was found.
+                        // Problem getting the parent node. Pretend a comment was found.
                         return true;
                     }
                 },
@@ -181,7 +178,7 @@ fn item_has_safety_comment(cx: &LateContext<'_>, item: &hir::Item<'_>) -> bool {
                     // Doesn't support impls in this position. Pretend a comment was found.
                     return true;
                 },
-            }
+            };
 
             let source_map = cx.sess().source_map();
             if let Some(comment_start) = comment_start
-- 
cgit 1.4.1-3-g733a5


From dc23b5d661f828ddace3ccc65c5a53b0f43c1dd4 Mon Sep 17 00:00:00 2001
From: yonip23 <yoni@tabnine.com>
Date: Thu, 12 May 2022 10:06:15 +0300
Subject: fix indentation + test

---
 clippy_lints/src/rc_clone_in_vec_init.rs | 10 +++++-----
 tests/ui/rc_clone_in_vec_init/arc.rs     | 10 ++++++++++
 tests/ui/rc_clone_in_vec_init/arc.stderr | 29 ++++++++++++++++++++++++++---
 tests/ui/rc_clone_in_vec_init/rc.rs      | 10 ++++++++++
 tests/ui/rc_clone_in_vec_init/rc.stderr  | 29 ++++++++++++++++++++++++++---
 5 files changed, 77 insertions(+), 11 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/rc_clone_in_vec_init.rs b/clippy_lints/src/rc_clone_in_vec_init.rs
index ee119e8c4a4..ca12509bdc7 100644
--- a/clippy_lints/src/rc_clone_in_vec_init.rs
+++ b/clippy_lints/src/rc_clone_in_vec_init.rs
@@ -106,9 +106,9 @@ fn elem_snippet(cx: &LateContext<'_>, elem: &Expr<'_>, symbol_name: &str) -> Str
 fn loop_init_suggestion(elem: &str, len: &str, indent: &str) -> String {
     format!(
         r#"{{
-{indent}{indent}let mut v = Vec::with_capacity({len});
-{indent}{indent}(0..{len}).for_each(|_| v.push({elem}));
-{indent}{indent}v
+{indent}    let mut v = Vec::with_capacity({len});
+{indent}    (0..{len}).for_each(|_| v.push({elem}));
+{indent}    v
 {indent}}}"#
     )
 }
@@ -116,8 +116,8 @@ fn loop_init_suggestion(elem: &str, len: &str, indent: &str) -> String {
 fn extract_suggestion(elem: &str, len: &str, indent: &str) -> String {
     format!(
         "{{
-{indent}{indent}let data = {elem};
-{indent}{indent}vec![data; {len}]
+{indent}    let data = {elem};
+{indent}    vec![data; {len}]
 {indent}}}"
     )
 }
diff --git a/tests/ui/rc_clone_in_vec_init/arc.rs b/tests/ui/rc_clone_in_vec_init/arc.rs
index bef2c67a1a5..384060e6eae 100644
--- a/tests/ui/rc_clone_in_vec_init/arc.rs
+++ b/tests/ui/rc_clone_in_vec_init/arc.rs
@@ -7,6 +7,16 @@ fn should_warn_simple_case() {
     let v = vec![Arc::new("x".to_string()); 2];
 }
 
+fn should_warn_simple_case_with_big_indentation() {
+    if true {
+        let k = 1;
+        dbg!(k);
+        if true {
+            let v = vec![Arc::new("x".to_string()); 2];
+        }
+    }
+}
+
 fn should_warn_complex_case() {
     let v = vec![
         std::sync::Arc::new(Mutex::new({
diff --git a/tests/ui/rc_clone_in_vec_init/arc.stderr b/tests/ui/rc_clone_in_vec_init/arc.stderr
index 387580c2431..ce84186c8e3 100644
--- a/tests/ui/rc_clone_in_vec_init/arc.stderr
+++ b/tests/ui/rc_clone_in_vec_init/arc.stderr
@@ -23,7 +23,30 @@ LL ~     };
    |
 
 error: calling `Arc::new` in `vec![elem; len]`
-  --> $DIR/arc.rs:11:13
+  --> $DIR/arc.rs:15:21
+   |
+LL |             let v = vec![Arc::new("x".to_string()); 2];
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: each element will point to the same `Arc` instance
+help: consider initializing each `Arc` element individually
+   |
+LL ~             let v = {
+LL +                 let mut v = Vec::with_capacity(2);
+LL +                 (0..2).for_each(|_| v.push(Arc::new("x".to_string())));
+LL +                 v
+LL ~             };
+   |
+help: or if this is intentional, consider extracting the `Arc` initialization to a variable
+   |
+LL ~             let v = {
+LL +                 let data = Arc::new("x".to_string());
+LL +                 vec![data; 2]
+LL ~             };
+   |
+
+error: calling `Arc::new` in `vec![elem; len]`
+  --> $DIR/arc.rs:21:13
    |
 LL |       let v = vec![
    |  _____________^
@@ -53,7 +76,7 @@ LL ~     };
    |
 
 error: calling `Arc::new` in `vec![elem; len]`
-  --> $DIR/arc.rs:20:14
+  --> $DIR/arc.rs:30:14
    |
 LL |       let v1 = vec![
    |  ______________^
@@ -82,5 +105,5 @@ LL +         vec![data; 2]
 LL ~     };
    |
 
-error: aborting due to 3 previous errors
+error: aborting due to 4 previous errors
 
diff --git a/tests/ui/rc_clone_in_vec_init/rc.rs b/tests/ui/rc_clone_in_vec_init/rc.rs
index 79c23cafa2c..0394457fe17 100644
--- a/tests/ui/rc_clone_in_vec_init/rc.rs
+++ b/tests/ui/rc_clone_in_vec_init/rc.rs
@@ -8,6 +8,16 @@ fn should_warn_simple_case() {
     let v = vec![Rc::new("x".to_string()); 2];
 }
 
+fn should_warn_simple_case_with_big_indentation() {
+    if true {
+        let k = 1;
+        dbg!(k);
+        if true {
+            let v = vec![Rc::new("x".to_string()); 2];
+        }
+    }
+}
+
 fn should_warn_complex_case() {
     let v = vec![
         std::rc::Rc::new(Mutex::new({
diff --git a/tests/ui/rc_clone_in_vec_init/rc.stderr b/tests/ui/rc_clone_in_vec_init/rc.stderr
index 4ce53eecbbd..0f5cc0cf98f 100644
--- a/tests/ui/rc_clone_in_vec_init/rc.stderr
+++ b/tests/ui/rc_clone_in_vec_init/rc.stderr
@@ -23,7 +23,30 @@ LL ~     };
    |
 
 error: calling `Rc::new` in `vec![elem; len]`
-  --> $DIR/rc.rs:12:13
+  --> $DIR/rc.rs:16:21
+   |
+LL |             let v = vec![Rc::new("x".to_string()); 2];
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: each element will point to the same `Rc` instance
+help: consider initializing each `Rc` element individually
+   |
+LL ~             let v = {
+LL +                 let mut v = Vec::with_capacity(2);
+LL +                 (0..2).for_each(|_| v.push(Rc::new("x".to_string())));
+LL +                 v
+LL ~             };
+   |
+help: or if this is intentional, consider extracting the `Rc` initialization to a variable
+   |
+LL ~             let v = {
+LL +                 let data = Rc::new("x".to_string());
+LL +                 vec![data; 2]
+LL ~             };
+   |
+
+error: calling `Rc::new` in `vec![elem; len]`
+  --> $DIR/rc.rs:22:13
    |
 LL |       let v = vec![
    |  _____________^
@@ -53,7 +76,7 @@ LL ~     };
    |
 
 error: calling `Rc::new` in `vec![elem; len]`
-  --> $DIR/rc.rs:21:14
+  --> $DIR/rc.rs:31:14
    |
 LL |       let v1 = vec![
    |  ______________^
@@ -82,5 +105,5 @@ LL +         vec![data; 2]
 LL ~     };
    |
 
-error: aborting due to 3 previous errors
+error: aborting due to 4 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 0def44a1c15e624a6e51206048895021f5b1ee92 Mon Sep 17 00:00:00 2001
From: Evan Typanski <evantypanski@gmail.com>
Date: Thu, 12 May 2022 19:06:23 -0400
Subject: Catch other thinning allocations using Ty

---
 clippy_lints/src/types/redundant_allocation.rs | 23 +++--------------
 tests/ui/redundant_allocation.rs               | 27 ++++++++++++++++----
 tests/ui/redundant_allocation.stderr           | 35 +++++++++++++++++++++++---
 3 files changed, 57 insertions(+), 28 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types/redundant_allocation.rs b/clippy_lints/src/types/redundant_allocation.rs
index 5fdf1731495..6c231fa2510 100644
--- a/clippy_lints/src/types/redundant_allocation.rs
+++ b/clippy_lints/src/types/redundant_allocation.rs
@@ -2,9 +2,10 @@ use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::{snippet, snippet_with_applicability};
 use clippy_utils::{path_def_id, qpath_generic_tys};
 use rustc_errors::Applicability;
-use rustc_hir::{self as hir, def, def_id::DefId, PrimTy, QPath, TyKind};
+use rustc_hir::{self as hir, def_id::DefId, QPath, TyKind};
 use rustc_lint::LateContext;
 use rustc_span::symbol::sym;
+use rustc_typeck::hir_ty_to_ty;
 
 use super::{utils, REDUNDANT_ALLOCATION};
 
@@ -54,7 +55,8 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_
     };
     let inner_span = match qpath_generic_tys(inner_qpath).next() {
         Some(ty) => {
-            if alloc_makes_pointer_thin(cx, ty) {
+            // Reallocation of a fat pointer causes it to become thin
+            if !hir_ty_to_ty(cx.tcx, ty).is_sized(cx.tcx.at(ty.span), cx.param_env) {
                 return false;
             }
             ty.span
@@ -109,20 +111,3 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_
     }
     true
 }
-
-/// Returns `true` if the allocation would make `hir_ty` go from fat to thin.
-fn alloc_makes_pointer_thin(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>) -> bool {
-    match &hir_ty.kind {
-        TyKind::TraitObject(..) => true,
-        TyKind::Path(ty_qpath) => {
-            let ty_res = cx.qpath_res(ty_qpath, hir_ty.hir_id);
-            if let def::Res::PrimTy(prim_ty) = ty_res {
-                if matches!(prim_ty, PrimTy::Str) {
-                    return true;
-                }
-            }
-            false
-        },
-        _ => false,
-    }
-}
diff --git a/tests/ui/redundant_allocation.rs b/tests/ui/redundant_allocation.rs
index b830a3771d5..cf7d8c6e349 100644
--- a/tests/ui/redundant_allocation.rs
+++ b/tests/ui/redundant_allocation.rs
@@ -98,21 +98,38 @@ mod box_dyn {
 }
 
 // https://github.com/rust-lang/rust-clippy/issues/8604
-mod box_str {
+mod box_fat_ptr {
     use std::boxed::Box;
+    use std::path::Path;
     use std::rc::Rc;
     use std::sync::Arc;
 
+    pub struct DynSized {
+        foo: [usize],
+    }
+
     struct S {
         a: Box<Box<str>>,
         b: Rc<Box<str>>,
         c: Arc<Box<str>>,
+
+        e: Box<Box<[usize]>>,
+        f: Box<Box<Path>>,
+        g: Box<Box<DynSized>>,
     }
 
-    pub fn test_box(_: Box<Box<str>>) {}
-    pub fn test_rc(_: Rc<Box<str>>) {}
-    pub fn test_arc(_: Arc<Box<str>>) {}
-    pub fn test_rc_box(_: Rc<Box<Box<str>>>) {}
+    pub fn test_box_str(_: Box<Box<str>>) {}
+    pub fn test_rc_str(_: Rc<Box<str>>) {}
+    pub fn test_arc_str(_: Arc<Box<str>>) {}
+
+    pub fn test_box_slice(_: Box<Box<[usize]>>) {}
+    pub fn test_box_path(_: Box<Box<Path>>) {}
+    pub fn test_box_custom(_: Box<Box<DynSized>>) {}
+
+    pub fn test_rc_box_str(_: Rc<Box<Box<str>>>) {}
+    pub fn test_rc_box_slice(_: Rc<Box<Box<[usize]>>>) {}
+    pub fn test_rc_box_path(_: Rc<Box<Box<Path>>>) {}
+    pub fn test_rc_box_custom(_: Rc<Box<Box<DynSized>>>) {}
 }
 
 fn main() {}
diff --git a/tests/ui/redundant_allocation.stderr b/tests/ui/redundant_allocation.stderr
index ae213cb8975..fab1b069fcb 100644
--- a/tests/ui/redundant_allocation.stderr
+++ b/tests/ui/redundant_allocation.stderr
@@ -144,13 +144,40 @@ LL |     pub fn test_rc_box(_: Rc<Box<Box<dyn T>>>) {}
    = help: consider using just `Rc<Box<dyn T>>` or `Box<Box<dyn T>>`
 
 error: usage of `Rc<Box<Box<str>>>`
-  --> $DIR/redundant_allocation.rs:115:27
+  --> $DIR/redundant_allocation.rs:129:31
    |
-LL |     pub fn test_rc_box(_: Rc<Box<Box<str>>>) {}
-   |                           ^^^^^^^^^^^^^^^^^
+LL |     pub fn test_rc_box_str(_: Rc<Box<Box<str>>>) {}
+   |                               ^^^^^^^^^^^^^^^^^
    |
    = note: `Box<Box<str>>` is already on the heap, `Rc<Box<Box<str>>>` makes an extra allocation
    = help: consider using just `Rc<Box<str>>` or `Box<Box<str>>`
 
-error: aborting due to 17 previous errors
+error: usage of `Rc<Box<Box<[usize]>>>`
+  --> $DIR/redundant_allocation.rs:130:33
+   |
+LL |     pub fn test_rc_box_slice(_: Rc<Box<Box<[usize]>>>) {}
+   |                                 ^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `Box<Box<[usize]>>` is already on the heap, `Rc<Box<Box<[usize]>>>` makes an extra allocation
+   = help: consider using just `Rc<Box<[usize]>>` or `Box<Box<[usize]>>`
+
+error: usage of `Rc<Box<Box<Path>>>`
+  --> $DIR/redundant_allocation.rs:131:32
+   |
+LL |     pub fn test_rc_box_path(_: Rc<Box<Box<Path>>>) {}
+   |                                ^^^^^^^^^^^^^^^^^^
+   |
+   = note: `Box<Box<Path>>` is already on the heap, `Rc<Box<Box<Path>>>` makes an extra allocation
+   = help: consider using just `Rc<Box<Path>>` or `Box<Box<Path>>`
+
+error: usage of `Rc<Box<Box<DynSized>>>`
+  --> $DIR/redundant_allocation.rs:132:34
+   |
+LL |     pub fn test_rc_box_custom(_: Rc<Box<Box<DynSized>>>) {}
+   |                                  ^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `Box<Box<DynSized>>` is already on the heap, `Rc<Box<Box<DynSized>>>` makes an extra allocation
+   = help: consider using just `Rc<Box<DynSized>>` or `Box<Box<DynSized>>`
+
+error: aborting due to 20 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From ed3744b957d318f7b22b1a2d53b867f7da42746d Mon Sep 17 00:00:00 2001
From: yonip23 <yoni@tabnine.com>
Date: Fri, 13 May 2022 02:20:28 +0300
Subject: inline construct_lint_suggestions

---
 clippy_lints/src/rc_clone_in_vec_init.rs | 61 ++++++++++----------------------
 1 file changed, 19 insertions(+), 42 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/rc_clone_in_vec_init.rs b/clippy_lints/src/rc_clone_in_vec_init.rs
index ca12509bdc7..110f58f3734 100644
--- a/clippy_lints/src/rc_clone_in_vec_init.rs
+++ b/clippy_lints/src/rc_clone_in_vec_init.rs
@@ -56,39 +56,6 @@ impl LateLintPass<'_> for RcCloneInVecInit {
     }
 }
 
-struct LintSuggestion {
-    message: String,
-    snippet: String,
-}
-
-fn construct_lint_suggestions(
-    cx: &LateContext<'_>,
-    span: Span,
-    symbol_name: &str,
-    elem: &Expr<'_>,
-    len: &Expr<'_>,
-) -> Vec<LintSuggestion> {
-    let len_snippet = snippet(cx, len.span, "..");
-    let elem_snippet = elem_snippet(cx, elem, symbol_name);
-    let indentation = indent_of(cx, span).unwrap_or(0);
-    let indentation = " ".repeat(indentation);
-    let loop_init_suggestion = loop_init_suggestion(&elem_snippet, len_snippet.as_ref(), &indentation);
-    let extract_suggestion = extract_suggestion(&elem_snippet, len_snippet.as_ref(), &indentation);
-
-    vec![
-        LintSuggestion {
-            message: format!("consider initializing each `{symbol_name}` element individually"),
-            snippet: loop_init_suggestion,
-        },
-        LintSuggestion {
-            message: format!(
-                "or if this is intentional, consider extracting the `{symbol_name}` initialization to a variable"
-            ),
-            snippet: extract_suggestion,
-        },
-    ]
-}
-
 fn elem_snippet(cx: &LateContext<'_>, elem: &Expr<'_>, symbol_name: &str) -> String {
     let elem_snippet = snippet(cx, elem.span, "..").to_string();
     if elem_snippet.contains('\n') {
@@ -131,17 +98,27 @@ fn emit_lint(cx: &LateContext<'_>, symbol: Symbol, lint_span: Span, elem: &Expr<
         lint_span,
         &format!("calling `{symbol_name}::new` in `vec![elem; len]`"),
         |diag| {
-            let suggestions = construct_lint_suggestions(cx, lint_span, symbol_name, elem, len);
+            let len_snippet = snippet(cx, len.span, "..");
+            let elem_snippet = elem_snippet(cx, elem, symbol_name);
+            let indentation = " ".repeat(indent_of(cx, lint_span).unwrap_or(0));
+            let loop_init_suggestion = loop_init_suggestion(&elem_snippet, len_snippet.as_ref(), &indentation);
+            let extract_suggestion = extract_suggestion(&elem_snippet, len_snippet.as_ref(), &indentation);
 
             diag.note(format!("each element will point to the same `{symbol_name}` instance"));
-            for suggestion in suggestions {
-                diag.span_suggestion(
-                    lint_span,
-                    &suggestion.message,
-                    &suggestion.snippet,
-                    Applicability::Unspecified,
-                );
-            }
+            diag.span_suggestion(
+                lint_span,
+                format!("consider initializing each `{symbol_name}` element individually"),
+                loop_init_suggestion,
+                Applicability::Unspecified,
+            );
+            diag.span_suggestion(
+                lint_span,
+                format!(
+                    "or if this is intentional, consider extracting the `{symbol_name}` initialization to a variable"
+                ),
+                extract_suggestion,
+                Applicability::Unspecified,
+            );
         },
     );
 }
-- 
cgit 1.4.1-3-g733a5


From 4e5f69cc869f734d39f74a5b0d9250eb5fc101ce Mon Sep 17 00:00:00 2001
From: ydah <13041216+ydah@users.noreply.github.com>
Date: Fri, 13 May 2022 14:20:25 +0900
Subject: Tweak some words improved representation

This PR has implemented improved representation.

- Use "lib" instead of "lifb"
- Use "triggered" instead of "triggere"
- Use "blacklisted_name" instead of "blackisted_name"
- Use "stabilization" instead of "stabilisation"
- Use "behavior" instead of "behaviour"
- Use "target" instead of "tartet"
- Use "checked_add" instead of "chcked_add"
- Use "anti-pattern" instead of "antipattern"
- Use "suggestion" instead of "suggesttion"
- Use "example" instead of "exampel"
- Use "Cheat Sheet" instead of "Cheatsheet"
---
 clippy_dev/src/main.rs                               | 2 +-
 clippy_dev/src/new_lint.rs                           | 4 ++--
 clippy_lints/src/assign_ops.rs                       | 2 +-
 clippy_lints/src/casts/cast_slice_different_sizes.rs | 2 +-
 clippy_lints/src/casts/mod.rs                        | 2 +-
 clippy_lints/src/default_union_representation.rs     | 4 ++--
 clippy_lints/src/derive.rs                           | 4 ++--
 clippy_lints/src/main_recursion.rs                   | 2 +-
 clippy_lints/src/methods/mod.rs                      | 2 +-
 clippy_lints/src/mutable_debug_assertion.rs          | 2 +-
 clippy_lints/src/needless_bitwise_bool.rs            | 4 ++--
 clippy_lints/src/pass_by_ref_or_value.rs             | 2 +-
 clippy_lints/src/redundant_clone.rs                  | 2 +-
 clippy_lints/src/transmute/mod.rs                    | 4 ++--
 doc/adding_lints.md                                  | 4 ++--
 tests/ui/blacklisted_name.rs                         | 4 ++--
 16 files changed, 23 insertions(+), 23 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_dev/src/main.rs b/clippy_dev/src/main.rs
index dcfaabbc204..d5cd7ca96c0 100644
--- a/clippy_dev/src/main.rs
+++ b/clippy_dev/src/main.rs
@@ -124,7 +124,7 @@ fn get_clap_config<'a>() -> ArgMatches<'a> {
                  * the lint count in README.md is correct\n \
                  * the changelog contains markdown link references at the bottom\n \
                  * all lint groups include the correct lints\n \
-                 * lint modules in `clippy_lints/*` are visible in `src/lifb.rs` via `pub mod`\n \
+                 * lint modules in `clippy_lints/*` are visible in `src/lib.rs` via `pub mod`\n \
                  * all lints are registered in the lint store",
                 )
                 .arg(Arg::with_name("print-only").long("print-only").help(
diff --git a/clippy_dev/src/new_lint.rs b/clippy_dev/src/new_lint.rs
index 10f67d301f8..07d19638788 100644
--- a/clippy_dev/src/new_lint.rs
+++ b/clippy_dev/src/new_lint.rs
@@ -133,7 +133,7 @@ fn to_camel_case(name: &str) -> String {
         .collect()
 }
 
-fn get_stabilisation_version() -> String {
+fn get_stabilization_version() -> String {
     fn parse_manifest(contents: &str) -> Option<String> {
         let version = contents
             .lines()
@@ -199,7 +199,7 @@ fn get_lint_file_contents(lint: &LintData<'_>, enable_msrv: bool) -> String {
         },
     };
 
-    let version = get_stabilisation_version();
+    let version = get_stabilization_version();
     let lint_name = lint.name;
     let category = lint.category;
     let name_camel = to_camel_case(lint.name);
diff --git a/clippy_lints/src/assign_ops.rs b/clippy_lints/src/assign_ops.rs
index 12c1bddf79d..4c2d3366483 100644
--- a/clippy_lints/src/assign_ops.rs
+++ b/clippy_lints/src/assign_ops.rs
@@ -50,7 +50,7 @@ declare_clippy_lint! {
     /// ### Known problems
     /// Clippy cannot know for sure if `a op= a op b` should have
     /// been `a = a op a op b` or `a = a op b`/`a op= b`. Therefore, it suggests both.
-    /// If `a op= a op b` is really the correct behaviour it should be
+    /// If `a op= a op b` is really the correct behavior it should be
     /// written as `a = a op a op b` as it's less confusing.
     ///
     /// ### Example
diff --git a/clippy_lints/src/casts/cast_slice_different_sizes.rs b/clippy_lints/src/casts/cast_slice_different_sizes.rs
index bb09a6708a0..027c660ce3b 100644
--- a/clippy_lints/src/casts/cast_slice_different_sizes.rs
+++ b/clippy_lints/src/casts/cast_slice_different_sizes.rs
@@ -121,7 +121,7 @@ fn expr_cast_chain_tys<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>) -> Optio
         let to_slice_ty = get_raw_slice_ty_mut(cast_to)?;
 
         // If the expression that makes up the source of this cast is itself a cast, recursively
-        // call `expr_cast_chain_tys` and update the end type with the final tartet type.
+        // call `expr_cast_chain_tys` and update the end type with the final target type.
         // Otherwise, this cast is not immediately nested, just construct the info for this cast
         if let Some(prev_info) = expr_cast_chain_tys(cx, cast_expr) {
             Some(CastChainInfo {
diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index 108e119c104..daf3b7b4ce4 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -306,7 +306,7 @@ declare_clippy_lint! {
     /// Checks for casts of `&T` to `&mut T` anywhere in the code.
     ///
     /// ### Why is this bad?
-    /// It’s basically guaranteed to be undefined behaviour.
+    /// It’s basically guaranteed to be undefined behavior.
     /// `UnsafeCell` is the only way to obtain aliasable data that is considered
     /// mutable.
     ///
diff --git a/clippy_lints/src/default_union_representation.rs b/clippy_lints/src/default_union_representation.rs
index 9b5da0bd8a6..d559ad423df 100644
--- a/clippy_lints/src/default_union_representation.rs
+++ b/clippy_lints/src/default_union_representation.rs
@@ -25,7 +25,7 @@ declare_clippy_lint! {
     ///
     /// fn main() {
     ///     let _x: u32 = unsafe {
-    ///         Foo { a: 0_i32 }.b // Undefined behaviour: `b` is allowed to be padding
+    ///         Foo { a: 0_i32 }.b // Undefined behavior: `b` is allowed to be padding
     ///     };
     /// }
     /// ```
@@ -39,7 +39,7 @@ declare_clippy_lint! {
     ///
     /// fn main() {
     ///     let _x: u32 = unsafe {
-    ///         Foo { a: 0_i32 }.b // Now defined behaviour, this is just an i32 -> u32 transmute
+    ///         Foo { a: 0_i32 }.b // Now defined behavior, this is just an i32 -> u32 transmute
     ///     };
     /// }
     /// ```
diff --git a/clippy_lints/src/derive.rs b/clippy_lints/src/derive.rs
index a4757ebd8c7..fbbc5bf78a5 100644
--- a/clippy_lints/src/derive.rs
+++ b/clippy_lints/src/derive.rs
@@ -102,8 +102,8 @@ declare_clippy_lint! {
     /// types.
     ///
     /// ### Why is this bad?
-    /// To avoid surprising behaviour, these traits should
-    /// agree and the behaviour of `Copy` cannot be overridden. In almost all
+    /// To avoid surprising behavior, these traits should
+    /// agree and the behavior of `Copy` cannot be overridden. In almost all
     /// situations a `Copy` type should have a `Clone` implementation that does
     /// nothing more than copy the object, which is what `#[derive(Copy, Clone)]`
     /// gets you.
diff --git a/clippy_lints/src/main_recursion.rs b/clippy_lints/src/main_recursion.rs
index fad8fa467d4..20333c150e3 100644
--- a/clippy_lints/src/main_recursion.rs
+++ b/clippy_lints/src/main_recursion.rs
@@ -12,7 +12,7 @@ declare_clippy_lint! {
     ///
     /// ### Why is this bad?
     /// Apart from special setups (which we could detect following attributes like #![no_std]),
-    /// recursing into main() seems like an unintuitive antipattern we should be able to detect.
+    /// recursing into main() seems like an unintuitive anti-pattern we should be able to detect.
     ///
     /// ### Example
     /// ```no_run
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 3e07961fcb3..35fc452ed7c 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1563,7 +1563,7 @@ declare_clippy_lint! {
     #[clippy::version = "1.39.0"]
     pub MANUAL_SATURATING_ARITHMETIC,
     style,
-    "`.chcked_add/sub(x).unwrap_or(MAX/MIN)`"
+    "`.checked_add/sub(x).unwrap_or(MAX/MIN)`"
 }
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/mutable_debug_assertion.rs b/clippy_lints/src/mutable_debug_assertion.rs
index 4ba68c8eacd..8dba60f3a58 100644
--- a/clippy_lints/src/mutable_debug_assertion.rs
+++ b/clippy_lints/src/mutable_debug_assertion.rs
@@ -16,7 +16,7 @@ declare_clippy_lint! {
     /// ### Why is this bad?
     /// In release builds `debug_assert!` macros are optimized out by the
     /// compiler.
-    /// Therefore mutating something in a `debug_assert!` macro results in different behaviour
+    /// Therefore mutating something in a `debug_assert!` macro results in different behavior
     /// between a release and debug build.
     ///
     /// ### Example
diff --git a/clippy_lints/src/needless_bitwise_bool.rs b/clippy_lints/src/needless_bitwise_bool.rs
index 95395e2e136..623d22bc9bd 100644
--- a/clippy_lints/src/needless_bitwise_bool.rs
+++ b/clippy_lints/src/needless_bitwise_bool.rs
@@ -53,7 +53,7 @@ fn is_bitwise_operation(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
     false
 }
 
-fn suggesstion_snippet(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<String> {
+fn suggestion_snippet(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<String> {
     if let ExprKind::Binary(ref op, left, right) = expr.kind {
         if let (Some(l_snippet), Some(r_snippet)) = (snippet_opt(cx, left.span), snippet_opt(cx, right.span)) {
             let op_snippet = match op.node {
@@ -75,7 +75,7 @@ impl LateLintPass<'_> for NeedlessBitwiseBool {
                 expr.span,
                 "use of bitwise operator instead of lazy operator between booleans",
                 |diag| {
-                    if let Some(sugg) = suggesstion_snippet(cx, expr) {
+                    if let Some(sugg) = suggestion_snippet(cx, expr) {
                         diag.span_suggestion(expr.span, "try", sugg, Applicability::MachineApplicable);
                     }
                 },
diff --git a/clippy_lints/src/pass_by_ref_or_value.rs b/clippy_lints/src/pass_by_ref_or_value.rs
index c5b8b8103a1..e3ded716341 100644
--- a/clippy_lints/src/pass_by_ref_or_value.rs
+++ b/clippy_lints/src/pass_by_ref_or_value.rs
@@ -52,7 +52,7 @@ declare_clippy_lint! {
     /// to a function that needs the memory address. For further details, refer to
     /// [this issue](https://github.com/rust-lang/rust-clippy/issues/5953)
     /// that explains a real case in which this false positive
-    /// led to an **undefined behaviour** introduced with unsafe code.
+    /// led to an **undefined behavior** introduced with unsafe code.
     ///
     /// ### Example
     ///
diff --git a/clippy_lints/src/redundant_clone.rs b/clippy_lints/src/redundant_clone.rs
index 9904617353f..b19f9aff611 100644
--- a/clippy_lints/src/redundant_clone.rs
+++ b/clippy_lints/src/redundant_clone.rs
@@ -632,7 +632,7 @@ impl<'a, 'tcx> mir::visit::Visitor<'tcx> for PossibleBorrowerVisitor<'a, 'tcx> {
 }
 
 /// Collect possible borrowed for every `&mut` local.
-/// For exampel, `_1 = &mut _2` generate _1: {_2,...}
+/// For example, `_1 = &mut _2` generate _1: {_2,...}
 /// Known Problems: not sure all borrowed are tracked
 struct PossibleOriginVisitor<'a, 'tcx> {
     possible_origin: TransitiveRelation,
diff --git a/clippy_lints/src/transmute/mod.rs b/clippy_lints/src/transmute/mod.rs
index 342f23f030c..d2a040beb0c 100644
--- a/clippy_lints/src/transmute/mod.rs
+++ b/clippy_lints/src/transmute/mod.rs
@@ -27,7 +27,7 @@ declare_clippy_lint! {
     /// architecture.
     ///
     /// ### Why is this bad?
-    /// It's basically guaranteed to be undefined behaviour.
+    /// It's basically guaranteed to be undefined behavior.
     ///
     /// ### Known problems
     /// When accessing C, users might want to store pointer
@@ -40,7 +40,7 @@ declare_clippy_lint! {
     #[clippy::version = "pre 1.29.0"]
     pub WRONG_TRANSMUTE,
     correctness,
-    "transmutes that are confusing at best, undefined behaviour at worst and always useless"
+    "transmutes that are confusing at best, undefined behavior at worst and always useless"
 }
 
 // FIXME: Move this to `complexity` again, after #5343 is fixed
diff --git a/doc/adding_lints.md b/doc/adding_lints.md
index 4dc94d9f5a5..e8f0c338fd5 100644
--- a/doc/adding_lints.md
+++ b/doc/adding_lints.md
@@ -28,7 +28,7 @@ because that's clearly a non-descriptive name.
   - [Debugging](#debugging)
   - [PR Checklist](#pr-checklist)
   - [Adding configuration to a lint](#adding-configuration-to-a-lint)
-  - [Cheatsheet](#cheatsheet)
+  - [Cheat Sheet](#cheat-sheet)
 
 ## Setup
 
@@ -649,7 +649,7 @@ in the following steps:
         with the configuration value and a rust file that should be linted by Clippy. The test can
         otherwise be written as usual.
 
-## Cheatsheet
+## Cheat Sheet
 
 Here are some pointers to things you are likely going to need for every lint:
 
diff --git a/tests/ui/blacklisted_name.rs b/tests/ui/blacklisted_name.rs
index 57d7139fef5..27df732a088 100644
--- a/tests/ui/blacklisted_name.rs
+++ b/tests/ui/blacklisted_name.rs
@@ -46,10 +46,10 @@ fn issue_1647_ref_mut() {
 
 mod tests {
     fn issue_7305() {
-        // `blackisted_name` lint should not be triggered inside of the test code.
+        // `blacklisted_name` lint should not be triggered inside of the test code.
         let foo = 0;
 
-        // Check that even in nested functions warning is still not triggere.
+        // Check that even in nested functions warning is still not triggered.
         fn nested() {
             let foo = 0;
         }
-- 
cgit 1.4.1-3-g733a5


From ad7338e5659f5711e08502906147e22b44e41a3e Mon Sep 17 00:00:00 2001
From: Evan Typanski <evantypanski@gmail.com>
Date: Fri, 13 May 2022 05:55:50 -0400
Subject: Comment why `hir_ty_to_ty` is safe in `check_ty`

---
 clippy_lints/src/types/redundant_allocation.rs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types/redundant_allocation.rs b/clippy_lints/src/types/redundant_allocation.rs
index 6c231fa2510..a1312fcda0b 100644
--- a/clippy_lints/src/types/redundant_allocation.rs
+++ b/clippy_lints/src/types/redundant_allocation.rs
@@ -55,7 +55,9 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_
     };
     let inner_span = match qpath_generic_tys(inner_qpath).next() {
         Some(ty) => {
-            // Reallocation of a fat pointer causes it to become thin
+            // Reallocation of a fat pointer causes it to become thin. `hir_ty_to_ty` is safe to use
+            // here because `mod.rs` guarantees this lint is only run on types outside of bodies and
+            // is not run on locals.
             if !hir_ty_to_ty(cx.tcx, ty).is_sized(cx.tcx.at(ty.span), cx.param_env) {
                 return false;
             }
-- 
cgit 1.4.1-3-g733a5


From 1f79a442e561521d0efae15da3da8acf17b580c2 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Sat, 14 May 2022 19:35:16 +0100
Subject: Add `duplicate_mod` lint

---
 CHANGELOG.md                                       |   1 +
 clippy_lints/src/duplicate_mod.rs                  | 102 +++++++++++++++++++++
 clippy_lints/src/lib.register_all.rs               |   1 +
 clippy_lints/src/lib.register_lints.rs             |   1 +
 clippy_lints/src/lib.register_suspicious.rs        |   1 +
 clippy_lints/src/lib.rs                            |   2 +
 clippy_utils/src/diagnostics.rs                    |   2 +-
 tests/ui-cargo/duplicate_mod/fail/Cargo.toml       |   5 +
 tests/ui-cargo/duplicate_mod/fail/src/a.rs         |   1 +
 tests/ui-cargo/duplicate_mod/fail/src/b.rs         |   1 +
 tests/ui-cargo/duplicate_mod/fail/src/c.rs         |   1 +
 .../duplicate_mod/fail/src/from_other_module.rs    |   1 +
 tests/ui-cargo/duplicate_mod/fail/src/main.rs      |  16 ++++
 tests/ui-cargo/duplicate_mod/fail/src/main.stderr  |  42 +++++++++
 .../duplicate_mod/fail/src/other_module/mod.rs     |   2 +
 15 files changed, 178 insertions(+), 1 deletion(-)
 create mode 100644 clippy_lints/src/duplicate_mod.rs
 create mode 100644 tests/ui-cargo/duplicate_mod/fail/Cargo.toml
 create mode 100644 tests/ui-cargo/duplicate_mod/fail/src/a.rs
 create mode 100644 tests/ui-cargo/duplicate_mod/fail/src/b.rs
 create mode 100644 tests/ui-cargo/duplicate_mod/fail/src/c.rs
 create mode 100644 tests/ui-cargo/duplicate_mod/fail/src/from_other_module.rs
 create mode 100644 tests/ui-cargo/duplicate_mod/fail/src/main.rs
 create mode 100644 tests/ui-cargo/duplicate_mod/fail/src/main.stderr
 create mode 100644 tests/ui-cargo/duplicate_mod/fail/src/other_module/mod.rs

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 47aaae9c198..e5988a19c14 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3363,6 +3363,7 @@ Released 2018-09-13
 [`drop_copy`]: https://rust-lang.github.io/rust-clippy/master/index.html#drop_copy
 [`drop_non_drop`]: https://rust-lang.github.io/rust-clippy/master/index.html#drop_non_drop
 [`drop_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#drop_ref
+[`duplicate_mod`]: https://rust-lang.github.io/rust-clippy/master/index.html#duplicate_mod
 [`duplicate_underscore_argument`]: https://rust-lang.github.io/rust-clippy/master/index.html#duplicate_underscore_argument
 [`duration_subsec`]: https://rust-lang.github.io/rust-clippy/master/index.html#duration_subsec
 [`else_if_without_else`]: https://rust-lang.github.io/rust-clippy/master/index.html#else_if_without_else
diff --git a/clippy_lints/src/duplicate_mod.rs b/clippy_lints/src/duplicate_mod.rs
new file mode 100644
index 00000000000..c6c7b959d4f
--- /dev/null
+++ b/clippy_lints/src/duplicate_mod.rs
@@ -0,0 +1,102 @@
+use clippy_utils::diagnostics::span_lint_and_help;
+use rustc_ast::ast::{Crate, Inline, Item, ItemKind, ModKind};
+use rustc_errors::MultiSpan;
+use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::{FileName, Span};
+use std::collections::BTreeMap;
+use std::path::PathBuf;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for files that are included as modules multiple times.
+    ///
+    /// ### Why is this bad?
+    /// Loading a file as a module more than once causes it to be compiled
+    /// multiple times, taking longer and putting duplicate content into the
+    /// module tree.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// // lib.rs
+    /// mod a;
+    /// mod b;
+    /// ```
+    /// ```rust,ignore
+    /// // a.rs
+    /// #[path = "./b.rs"]
+    /// mod b;
+    /// ```
+    ///
+    /// Use instead:
+    ///
+    /// ```rust,ignore
+    /// // lib.rs
+    /// mod a;
+    /// mod b;
+    /// ```
+    /// ```rust,ignore
+    /// // a.rs
+    /// use crate::b;
+    /// ```
+    #[clippy::version = "1.62.0"]
+    pub DUPLICATE_MOD,
+    suspicious,
+    "file loaded as module multiple times"
+}
+
+#[derive(PartialOrd, Ord, PartialEq, Eq)]
+struct Modules {
+    local_path: PathBuf,
+    spans: Vec<Span>,
+}
+
+#[derive(Default)]
+pub struct DuplicateMod {
+    /// map from the canonicalized path to `Modules`, `BTreeMap` to make the
+    /// order deterministic for tests
+    modules: BTreeMap<PathBuf, Modules>,
+}
+
+impl_lint_pass!(DuplicateMod => [DUPLICATE_MOD]);
+
+impl EarlyLintPass for DuplicateMod {
+    fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {
+        if let ItemKind::Mod(_, ModKind::Loaded(_, Inline::No, mod_spans)) = &item.kind
+            && let FileName::Real(real) = cx.sess().source_map().span_to_filename(mod_spans.inner_span)
+            && let Some(local_path) = real.into_local_path()
+            && let Ok(absolute_path) = local_path.canonicalize()
+        {
+            let modules = self.modules.entry(absolute_path).or_insert(Modules {
+                local_path,
+                spans: Vec::new(),
+            });
+            modules.spans.push(item.span_with_attributes());
+        }
+    }
+
+    fn check_crate_post(&mut self, cx: &EarlyContext<'_>, _: &Crate) {
+        for Modules { local_path, spans } in self.modules.values() {
+            if spans.len() < 2 {
+                continue;
+            }
+
+            let mut multi_span = MultiSpan::from_spans(spans.clone());
+            let (&first, duplicates) = spans.split_first().unwrap();
+
+            multi_span.push_span_label(first, "first loaded here");
+            for &duplicate in duplicates {
+                multi_span.push_span_label(duplicate, "loaded again here");
+            }
+
+            span_lint_and_help(
+                cx,
+                DUPLICATE_MOD,
+                multi_span,
+                &format!("file is loaded as a module multiple times: `{}`", local_path.display()),
+                None,
+                "replace all but one `mod` item with `use` items",
+            );
+        }
+    }
+}
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index fca5e109509..78653d932c4 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -60,6 +60,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(drop_forget_ref::FORGET_NON_DROP),
     LintId::of(drop_forget_ref::FORGET_REF),
     LintId::of(drop_forget_ref::UNDROPPED_MANUALLY_DROPS),
+    LintId::of(duplicate_mod::DUPLICATE_MOD),
     LintId::of(duration_subsec::DURATION_SUBSEC),
     LintId::of(entry::MAP_ENTRY),
     LintId::of(enum_clike::ENUM_CLIKE_UNPORTABLE_VARIANT),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 7489f53fd3c..155de0a0b08 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -133,6 +133,7 @@ store.register_lints(&[
     drop_forget_ref::FORGET_NON_DROP,
     drop_forget_ref::FORGET_REF,
     drop_forget_ref::UNDROPPED_MANUALLY_DROPS,
+    duplicate_mod::DUPLICATE_MOD,
     duration_subsec::DURATION_SUBSEC,
     else_if_without_else::ELSE_IF_WITHOUT_ELSE,
     empty_drop::EMPTY_DROP,
diff --git a/clippy_lints/src/lib.register_suspicious.rs b/clippy_lints/src/lib.register_suspicious.rs
index 940bf7ace5e..5df2dd34368 100644
--- a/clippy_lints/src/lib.register_suspicious.rs
+++ b/clippy_lints/src/lib.register_suspicious.rs
@@ -14,6 +14,7 @@ store.register_group(true, "clippy::suspicious", Some("clippy_suspicious"), vec!
     LintId::of(crate_in_macro_def::CRATE_IN_MACRO_DEF),
     LintId::of(drop_forget_ref::DROP_NON_DROP),
     LintId::of(drop_forget_ref::FORGET_NON_DROP),
+    LintId::of(duplicate_mod::DUPLICATE_MOD),
     LintId::of(eval_order_dependence::EVAL_ORDER_DEPENDENCE),
     LintId::of(float_equality_without_abs::FLOAT_EQUALITY_WITHOUT_ABS),
     LintId::of(format_impl::PRINT_IN_FORMAT_IMPL),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 1c502ef1d44..27cb5bf7087 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -211,6 +211,7 @@ mod doc;
 mod double_comparison;
 mod double_parens;
 mod drop_forget_ref;
+mod duplicate_mod;
 mod duration_subsec;
 mod else_if_without_else;
 mod empty_drop;
@@ -902,6 +903,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(move || Box::new(large_include_file::LargeIncludeFile::new(max_include_file_size)));
     store.register_late_pass(|| Box::new(strings::TrimSplitWhitespace));
     store.register_late_pass(|| Box::new(rc_clone_in_vec_init::RcCloneInVecInit));
+    store.register_early_pass(|| Box::new(duplicate_mod::DuplicateMod::default()));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_utils/src/diagnostics.rs b/clippy_utils/src/diagnostics.rs
index 68b5151a648..04afe5ac373 100644
--- a/clippy_utils/src/diagnostics.rs
+++ b/clippy_utils/src/diagnostics.rs
@@ -77,7 +77,7 @@ pub fn span_lint<T: LintContext>(cx: &T, lint: &'static Lint, sp: impl Into<Mult
 pub fn span_lint_and_help<'a, T: LintContext>(
     cx: &'a T,
     lint: &'static Lint,
-    span: Span,
+    span: impl Into<MultiSpan>,
     msg: &str,
     help_span: Option<Span>,
     help: &str,
diff --git a/tests/ui-cargo/duplicate_mod/fail/Cargo.toml b/tests/ui-cargo/duplicate_mod/fail/Cargo.toml
new file mode 100644
index 00000000000..bf3c817de1c
--- /dev/null
+++ b/tests/ui-cargo/duplicate_mod/fail/Cargo.toml
@@ -0,0 +1,5 @@
+[package]
+name = "duplicate_mod"
+edition = "2021"
+publish = false
+version = "0.1.0"
diff --git a/tests/ui-cargo/duplicate_mod/fail/src/a.rs b/tests/ui-cargo/duplicate_mod/fail/src/a.rs
new file mode 100644
index 00000000000..8b137891791
--- /dev/null
+++ b/tests/ui-cargo/duplicate_mod/fail/src/a.rs
@@ -0,0 +1 @@
+
diff --git a/tests/ui-cargo/duplicate_mod/fail/src/b.rs b/tests/ui-cargo/duplicate_mod/fail/src/b.rs
new file mode 100644
index 00000000000..8b137891791
--- /dev/null
+++ b/tests/ui-cargo/duplicate_mod/fail/src/b.rs
@@ -0,0 +1 @@
+
diff --git a/tests/ui-cargo/duplicate_mod/fail/src/c.rs b/tests/ui-cargo/duplicate_mod/fail/src/c.rs
new file mode 100644
index 00000000000..8b137891791
--- /dev/null
+++ b/tests/ui-cargo/duplicate_mod/fail/src/c.rs
@@ -0,0 +1 @@
+
diff --git a/tests/ui-cargo/duplicate_mod/fail/src/from_other_module.rs b/tests/ui-cargo/duplicate_mod/fail/src/from_other_module.rs
new file mode 100644
index 00000000000..8b137891791
--- /dev/null
+++ b/tests/ui-cargo/duplicate_mod/fail/src/from_other_module.rs
@@ -0,0 +1 @@
+
diff --git a/tests/ui-cargo/duplicate_mod/fail/src/main.rs b/tests/ui-cargo/duplicate_mod/fail/src/main.rs
new file mode 100644
index 00000000000..79b343da247
--- /dev/null
+++ b/tests/ui-cargo/duplicate_mod/fail/src/main.rs
@@ -0,0 +1,16 @@
+mod a;
+
+mod b;
+#[path = "b.rs"]
+mod b2;
+
+mod c;
+#[path = "c.rs"]
+mod c2;
+#[path = "c.rs"]
+mod c3;
+
+mod from_other_module;
+mod other_module;
+
+fn main() {}
diff --git a/tests/ui-cargo/duplicate_mod/fail/src/main.stderr b/tests/ui-cargo/duplicate_mod/fail/src/main.stderr
new file mode 100644
index 00000000000..00d7739c8a2
--- /dev/null
+++ b/tests/ui-cargo/duplicate_mod/fail/src/main.stderr
@@ -0,0 +1,42 @@
+error: file is loaded as a module multiple times: `$DIR/b.rs`
+  --> $DIR/main.rs:3:1
+   |
+LL |   mod b;
+   |   ^^^^^^ first loaded here
+LL | / #[path = "b.rs"]
+LL | | mod b2;
+   | |_______^ loaded again here
+   |
+   = note: `-D clippy::duplicate-mod` implied by `-D warnings`
+   = help: replace all but one `mod` item with `use` items
+
+error: file is loaded as a module multiple times: `$DIR/c.rs`
+  --> $DIR/main.rs:7:1
+   |
+LL |   mod c;
+   |   ^^^^^^ first loaded here
+LL | / #[path = "c.rs"]
+LL | | mod c2;
+   | |_______^ loaded again here
+LL | / #[path = "c.rs"]
+LL | | mod c3;
+   | |_______^ loaded again here
+   |
+   = help: replace all but one `mod` item with `use` items
+
+error: file is loaded as a module multiple times: `$DIR/from_other_module.rs`
+  --> $DIR/main.rs:13:1
+   |
+LL |   mod from_other_module;
+   |   ^^^^^^^^^^^^^^^^^^^^^^ first loaded here
+   |
+  ::: $DIR/other_module/mod.rs:1:1
+   |
+LL | / #[path = "../from_other_module.rs"]
+LL | | mod m;
+   | |______^ loaded again here
+   |
+   = help: replace all but one `mod` item with `use` items
+
+error: aborting due to 3 previous errors
+
diff --git a/tests/ui-cargo/duplicate_mod/fail/src/other_module/mod.rs b/tests/ui-cargo/duplicate_mod/fail/src/other_module/mod.rs
new file mode 100644
index 00000000000..36ce7286ade
--- /dev/null
+++ b/tests/ui-cargo/duplicate_mod/fail/src/other_module/mod.rs
@@ -0,0 +1,2 @@
+#[path = "../from_other_module.rs"]
+mod m;
-- 
cgit 1.4.1-3-g733a5


From 50eada16f7c4ae711aa7e9233ce836c6618c0c4b Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Tue, 3 May 2022 10:56:59 -0400
Subject: Rename `eval_order_dependence` to `mixed_read_write_in_expression`

---
 CHANGELOG.md                                       |   2 +-
 clippy_lints/src/eval_order_dependence.rs          | 348 ---------------------
 clippy_lints/src/lib.register_all.rs               |   4 +-
 clippy_lints/src/lib.register_complexity.rs        |   2 +-
 clippy_lints/src/lib.register_lints.rs             |   4 +-
 clippy_lints/src/lib.register_suspicious.rs        |   2 +-
 clippy_lints/src/lib.rs                            |   4 +-
 clippy_lints/src/mixed_read_write_in_expression.rs | 348 +++++++++++++++++++++
 clippy_lints/src/renamed_lints.rs                  |   1 +
 tests/ui/branches_sharing_code/shared_at_top.rs    |   2 +-
 tests/ui/branches_sharing_code/valid_if_blocks.rs  |   2 +-
 tests/ui/eval_order_dependence.rs                  | 112 -------
 tests/ui/eval_order_dependence.stderr              |  51 ---
 tests/ui/mixed_read_write_in_expression.rs         | 112 +++++++
 tests/ui/mixed_read_write_in_expression.stderr     |  51 +++
 tests/ui/rename.fixed                              |   2 +
 tests/ui/rename.rs                                 |   2 +
 tests/ui/rename.stderr                             |  76 ++---
 tests/ui/self_assignment.rs                        |   2 +-
 19 files changed, 569 insertions(+), 558 deletions(-)
 delete mode 100644 clippy_lints/src/eval_order_dependence.rs
 create mode 100644 clippy_lints/src/mixed_read_write_in_expression.rs
 delete mode 100644 tests/ui/eval_order_dependence.rs
 delete mode 100644 tests/ui/eval_order_dependence.stderr
 create mode 100644 tests/ui/mixed_read_write_in_expression.rs
 create mode 100644 tests/ui/mixed_read_write_in_expression.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index e5988a19c14..4cb7d414534 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3379,7 +3379,6 @@ Released 2018-09-13
 [`equatable_if_let`]: https://rust-lang.github.io/rust-clippy/master/index.html#equatable_if_let
 [`erasing_op`]: https://rust-lang.github.io/rust-clippy/master/index.html#erasing_op
 [`err_expect`]: https://rust-lang.github.io/rust-clippy/master/index.html#err_expect
-[`eval_order_dependence`]: https://rust-lang.github.io/rust-clippy/master/index.html#eval_order_dependence
 [`excessive_precision`]: https://rust-lang.github.io/rust-clippy/master/index.html#excessive_precision
 [`exhaustive_enums`]: https://rust-lang.github.io/rust-clippy/master/index.html#exhaustive_enums
 [`exhaustive_structs`]: https://rust-lang.github.io/rust-clippy/master/index.html#exhaustive_structs
@@ -3551,6 +3550,7 @@ Released 2018-09-13
 [`missing_spin_loop`]: https://rust-lang.github.io/rust-clippy/master/index.html#missing_spin_loop
 [`mistyped_literal_suffixes`]: https://rust-lang.github.io/rust-clippy/master/index.html#mistyped_literal_suffixes
 [`mixed_case_hex_literals`]: https://rust-lang.github.io/rust-clippy/master/index.html#mixed_case_hex_literals
+[`mixed_read_write_in_expression`]: https://rust-lang.github.io/rust-clippy/master/index.html#mixed_read_write_in_expression
 [`mod_module_files`]: https://rust-lang.github.io/rust-clippy/master/index.html#mod_module_files
 [`module_inception`]: https://rust-lang.github.io/rust-clippy/master/index.html#module_inception
 [`module_name_repetitions`]: https://rust-lang.github.io/rust-clippy/master/index.html#module_name_repetitions
diff --git a/clippy_lints/src/eval_order_dependence.rs b/clippy_lints/src/eval_order_dependence.rs
deleted file mode 100644
index 65599a0587d..00000000000
--- a/clippy_lints/src/eval_order_dependence.rs
+++ /dev/null
@@ -1,348 +0,0 @@
-use clippy_utils::diagnostics::{span_lint, span_lint_and_note};
-use clippy_utils::{get_parent_expr, path_to_local, path_to_local_id};
-use if_chain::if_chain;
-use rustc_hir::intravisit::{walk_expr, Visitor};
-use rustc_hir::{BinOpKind, Block, Expr, ExprKind, Guard, HirId, Local, Node, Stmt, StmtKind};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for a read and a write to the same variable where
-    /// whether the read occurs before or after the write depends on the evaluation
-    /// order of sub-expressions.
-    ///
-    /// ### Why is this bad?
-    /// It is often confusing to read. As described [here](https://doc.rust-lang.org/reference/expressions.html?highlight=subexpression#evaluation-order-of-operands),
-    /// the operands of these expressions are evaluated before applying the effects of the expression.
-    ///
-    /// ### Known problems
-    /// Code which intentionally depends on the evaluation
-    /// order, or which is correct for any evaluation order.
-    ///
-    /// ### Example
-    /// ```rust
-    /// let mut x = 0;
-    ///
-    /// // Bad
-    /// let a = {
-    ///     x = 1;
-    ///     1
-    /// } + x;
-    /// // Unclear whether a is 1 or 2.
-    ///
-    /// // Good
-    /// let tmp = {
-    ///     x = 1;
-    ///     1
-    /// };
-    /// let a = tmp + x;
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub EVAL_ORDER_DEPENDENCE,
-    suspicious,
-    "whether a variable read occurs before a write depends on sub-expression evaluation order"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for diverging calls that are not match arms or
-    /// statements.
-    ///
-    /// ### Why is this bad?
-    /// It is often confusing to read. In addition, the
-    /// sub-expression evaluation order for Rust is not well documented.
-    ///
-    /// ### Known problems
-    /// Someone might want to use `some_bool || panic!()` as a
-    /// shorthand.
-    ///
-    /// ### Example
-    /// ```rust,no_run
-    /// # fn b() -> bool { true }
-    /// # fn c() -> bool { true }
-    /// let a = b() || panic!() || c();
-    /// // `c()` is dead, `panic!()` is only called if `b()` returns `false`
-    /// let x = (a, b, c, panic!());
-    /// // can simply be replaced by `panic!()`
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub DIVERGING_SUB_EXPRESSION,
-    complexity,
-    "whether an expression contains a diverging sub expression"
-}
-
-declare_lint_pass!(EvalOrderDependence => [EVAL_ORDER_DEPENDENCE, DIVERGING_SUB_EXPRESSION]);
-
-impl<'tcx> LateLintPass<'tcx> for EvalOrderDependence {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        // Find a write to a local variable.
-        let var = if_chain! {
-            if let ExprKind::Assign(lhs, ..) | ExprKind::AssignOp(_, lhs, _) = expr.kind;
-            if let Some(var) = path_to_local(lhs);
-            if expr.span.desugaring_kind().is_none();
-            then { var } else { return; }
-        };
-        let mut visitor = ReadVisitor {
-            cx,
-            var,
-            write_expr: expr,
-            last_expr: expr,
-        };
-        check_for_unsequenced_reads(&mut visitor);
-    }
-    fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) {
-        match stmt.kind {
-            StmtKind::Local(local) => {
-                if let Local { init: Some(e), .. } = local {
-                    DivergenceVisitor { cx }.visit_expr(e);
-                }
-            },
-            StmtKind::Expr(e) | StmtKind::Semi(e) => DivergenceVisitor { cx }.maybe_walk_expr(e),
-            StmtKind::Item(..) => {},
-        }
-    }
-}
-
-struct DivergenceVisitor<'a, 'tcx> {
-    cx: &'a LateContext<'tcx>,
-}
-
-impl<'a, 'tcx> DivergenceVisitor<'a, 'tcx> {
-    fn maybe_walk_expr(&mut self, e: &'tcx Expr<'_>) {
-        match e.kind {
-            ExprKind::Closure(..) => {},
-            ExprKind::Match(e, arms, _) => {
-                self.visit_expr(e);
-                for arm in arms {
-                    if let Some(Guard::If(if_expr)) = arm.guard {
-                        self.visit_expr(if_expr);
-                    }
-                    // make sure top level arm expressions aren't linted
-                    self.maybe_walk_expr(&*arm.body);
-                }
-            },
-            _ => walk_expr(self, e),
-        }
-    }
-    fn report_diverging_sub_expr(&mut self, e: &Expr<'_>) {
-        span_lint(self.cx, DIVERGING_SUB_EXPRESSION, e.span, "sub-expression diverges");
-    }
-}
-
-impl<'a, 'tcx> Visitor<'tcx> for DivergenceVisitor<'a, 'tcx> {
-    fn visit_expr(&mut self, e: &'tcx Expr<'_>) {
-        match e.kind {
-            ExprKind::Continue(_) | ExprKind::Break(_, _) | ExprKind::Ret(_) => self.report_diverging_sub_expr(e),
-            ExprKind::Call(func, _) => {
-                let typ = self.cx.typeck_results().expr_ty(func);
-                match typ.kind() {
-                    ty::FnDef(..) | ty::FnPtr(_) => {
-                        let sig = typ.fn_sig(self.cx.tcx);
-                        if self.cx.tcx.erase_late_bound_regions(sig).output().kind() == &ty::Never {
-                            self.report_diverging_sub_expr(e);
-                        }
-                    },
-                    _ => {},
-                }
-            },
-            ExprKind::MethodCall(..) => {
-                let borrowed_table = self.cx.typeck_results();
-                if borrowed_table.expr_ty(e).is_never() {
-                    self.report_diverging_sub_expr(e);
-                }
-            },
-            _ => {
-                // do not lint expressions referencing objects of type `!`, as that required a
-                // diverging expression
-                // to begin with
-            },
-        }
-        self.maybe_walk_expr(e);
-    }
-    fn visit_block(&mut self, _: &'tcx Block<'_>) {
-        // don't continue over blocks, LateLintPass already does that
-    }
-}
-
-/// Walks up the AST from the given write expression (`vis.write_expr`) looking
-/// for reads to the same variable that are unsequenced relative to the write.
-///
-/// This means reads for which there is a common ancestor between the read and
-/// the write such that
-///
-/// * evaluating the ancestor necessarily evaluates both the read and the write (for example, `&x`
-///   and `|| x = 1` don't necessarily evaluate `x`), and
-///
-/// * which one is evaluated first depends on the order of sub-expression evaluation. Blocks, `if`s,
-///   loops, `match`es, and the short-circuiting logical operators are considered to have a defined
-///   evaluation order.
-///
-/// When such a read is found, the lint is triggered.
-fn check_for_unsequenced_reads(vis: &mut ReadVisitor<'_, '_>) {
-    let map = &vis.cx.tcx.hir();
-    let mut cur_id = vis.write_expr.hir_id;
-    loop {
-        let parent_id = map.get_parent_node(cur_id);
-        if parent_id == cur_id {
-            break;
-        }
-        let parent_node = match map.find(parent_id) {
-            Some(parent) => parent,
-            None => break,
-        };
-
-        let stop_early = match parent_node {
-            Node::Expr(expr) => check_expr(vis, expr),
-            Node::Stmt(stmt) => check_stmt(vis, stmt),
-            Node::Item(_) => {
-                // We reached the top of the function, stop.
-                break;
-            },
-            _ => StopEarly::KeepGoing,
-        };
-        match stop_early {
-            StopEarly::Stop => break,
-            StopEarly::KeepGoing => {},
-        }
-
-        cur_id = parent_id;
-    }
-}
-
-/// Whether to stop early for the loop in `check_for_unsequenced_reads`. (If
-/// `check_expr` weren't an independent function, this would be unnecessary and
-/// we could just use `break`).
-enum StopEarly {
-    KeepGoing,
-    Stop,
-}
-
-fn check_expr<'a, 'tcx>(vis: &mut ReadVisitor<'a, 'tcx>, expr: &'tcx Expr<'_>) -> StopEarly {
-    if expr.hir_id == vis.last_expr.hir_id {
-        return StopEarly::KeepGoing;
-    }
-
-    match expr.kind {
-        ExprKind::Array(_)
-        | ExprKind::Tup(_)
-        | ExprKind::MethodCall(..)
-        | ExprKind::Call(_, _)
-        | ExprKind::Assign(..)
-        | ExprKind::Index(_, _)
-        | ExprKind::Repeat(_, _)
-        | ExprKind::Struct(_, _, _) => {
-            walk_expr(vis, expr);
-        },
-        ExprKind::Binary(op, _, _) | ExprKind::AssignOp(op, _, _) => {
-            if op.node == BinOpKind::And || op.node == BinOpKind::Or {
-                // x && y and x || y always evaluate x first, so these are
-                // strictly sequenced.
-            } else {
-                walk_expr(vis, expr);
-            }
-        },
-        ExprKind::Closure(_, _, _, _, _) => {
-            // Either
-            //
-            // * `var` is defined in the closure body, in which case we've reached the top of the enclosing
-            //   function and can stop, or
-            //
-            // * `var` is captured by the closure, in which case, because evaluating a closure does not evaluate
-            //   its body, we don't necessarily have a write, so we need to stop to avoid generating false
-            //   positives.
-            //
-            // This is also the only place we need to stop early (grrr).
-            return StopEarly::Stop;
-        },
-        // All other expressions either have only one child or strictly
-        // sequence the evaluation order of their sub-expressions.
-        _ => {},
-    }
-
-    vis.last_expr = expr;
-
-    StopEarly::KeepGoing
-}
-
-fn check_stmt<'a, 'tcx>(vis: &mut ReadVisitor<'a, 'tcx>, stmt: &'tcx Stmt<'_>) -> StopEarly {
-    match stmt.kind {
-        StmtKind::Expr(expr) | StmtKind::Semi(expr) => check_expr(vis, expr),
-        // If the declaration is of a local variable, check its initializer
-        // expression if it has one. Otherwise, keep going.
-        StmtKind::Local(local) => local
-            .init
-            .as_ref()
-            .map_or(StopEarly::KeepGoing, |expr| check_expr(vis, expr)),
-        StmtKind::Item(..) => StopEarly::KeepGoing,
-    }
-}
-
-/// A visitor that looks for reads from a variable.
-struct ReadVisitor<'a, 'tcx> {
-    cx: &'a LateContext<'tcx>,
-    /// The ID of the variable we're looking for.
-    var: HirId,
-    /// The expressions where the write to the variable occurred (for reporting
-    /// in the lint).
-    write_expr: &'tcx Expr<'tcx>,
-    /// The last (highest in the AST) expression we've checked, so we know not
-    /// to recheck it.
-    last_expr: &'tcx Expr<'tcx>,
-}
-
-impl<'a, 'tcx> Visitor<'tcx> for ReadVisitor<'a, 'tcx> {
-    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
-        if expr.hir_id == self.last_expr.hir_id {
-            return;
-        }
-
-        if path_to_local_id(expr, self.var) {
-            // Check that this is a read, not a write.
-            if !is_in_assignment_position(self.cx, expr) {
-                span_lint_and_note(
-                    self.cx,
-                    EVAL_ORDER_DEPENDENCE,
-                    expr.span,
-                    &format!("unsequenced read of `{}`", self.cx.tcx.hir().name(self.var)),
-                    Some(self.write_expr.span),
-                    "whether read occurs before this write depends on evaluation order",
-                );
-            }
-        }
-        match expr.kind {
-            // We're about to descend a closure. Since we don't know when (or
-            // if) the closure will be evaluated, any reads in it might not
-            // occur here (or ever). Like above, bail to avoid false positives.
-            ExprKind::Closure(_, _, _, _, _) |
-
-            // We want to avoid a false positive when a variable name occurs
-            // only to have its address taken, so we stop here. Technically,
-            // this misses some weird cases, eg.
-            //
-            // ```rust
-            // let mut x = 0;
-            // let a = foo(&{x = 1; x}, x);
-            // ```
-            //
-            // TODO: fix this
-            ExprKind::AddrOf(_, _, _) => {
-                return;
-            }
-            _ => {}
-        }
-
-        walk_expr(self, expr);
-    }
-}
-
-/// Returns `true` if `expr` is the LHS of an assignment, like `expr = ...`.
-fn is_in_assignment_position(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-    if let Some(parent) = get_parent_expr(cx, expr) {
-        if let ExprKind::Assign(lhs, ..) = parent.kind {
-            return lhs.hir_id == expr.hir_id;
-        }
-    }
-    false
-}
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 78653d932c4..a85cfe5cfbd 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -71,8 +71,6 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(erasing_op::ERASING_OP),
     LintId::of(escape::BOXED_LOCAL),
     LintId::of(eta_reduction::REDUNDANT_CLOSURE),
-    LintId::of(eval_order_dependence::DIVERGING_SUB_EXPRESSION),
-    LintId::of(eval_order_dependence::EVAL_ORDER_DEPENDENCE),
     LintId::of(explicit_write::EXPLICIT_WRITE),
     LintId::of(float_equality_without_abs::FLOAT_EQUALITY_WITHOUT_ABS),
     LintId::of(float_literal::EXCESSIVE_PRECISION),
@@ -230,6 +228,8 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(misc_early::REDUNDANT_PATTERN),
     LintId::of(misc_early::UNNEEDED_WILDCARD_PATTERN),
     LintId::of(misc_early::ZERO_PREFIXED_LITERAL),
+    LintId::of(mixed_read_write_in_expression::DIVERGING_SUB_EXPRESSION),
+    LintId::of(mixed_read_write_in_expression::MIXED_READ_WRITE_IN_EXPRESSION),
     LintId::of(mut_key::MUTABLE_KEY_TYPE),
     LintId::of(mut_mutex_lock::MUT_MUTEX_LOCK),
     LintId::of(mut_reference::UNNECESSARY_MUT_PASSED),
diff --git a/clippy_lints/src/lib.register_complexity.rs b/clippy_lints/src/lib.register_complexity.rs
index 6f3c433af31..b15c979d0c7 100644
--- a/clippy_lints/src/lib.register_complexity.rs
+++ b/clippy_lints/src/lib.register_complexity.rs
@@ -12,7 +12,6 @@ store.register_group(true, "clippy::complexity", Some("clippy_complexity"), vec!
     LintId::of(double_comparison::DOUBLE_COMPARISONS),
     LintId::of(double_parens::DOUBLE_PARENS),
     LintId::of(duration_subsec::DURATION_SUBSEC),
-    LintId::of(eval_order_dependence::DIVERGING_SUB_EXPRESSION),
     LintId::of(explicit_write::EXPLICIT_WRITE),
     LintId::of(format::USELESS_FORMAT),
     LintId::of(functions::TOO_MANY_ARGUMENTS),
@@ -59,6 +58,7 @@ store.register_group(true, "clippy::complexity", Some("clippy_complexity"), vec!
     LintId::of(misc::SHORT_CIRCUIT_STATEMENT),
     LintId::of(misc_early::UNNEEDED_WILDCARD_PATTERN),
     LintId::of(misc_early::ZERO_PREFIXED_LITERAL),
+    LintId::of(mixed_read_write_in_expression::DIVERGING_SUB_EXPRESSION),
     LintId::of(needless_arbitrary_self_type::NEEDLESS_ARBITRARY_SELF_TYPE),
     LintId::of(needless_bool::BOOL_COMPARISON),
     LintId::of(needless_bool::NEEDLESS_BOOL),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 155de0a0b08..05008bc58ca 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -151,8 +151,6 @@ store.register_lints(&[
     escape::BOXED_LOCAL,
     eta_reduction::REDUNDANT_CLOSURE,
     eta_reduction::REDUNDANT_CLOSURE_FOR_METHOD_CALLS,
-    eval_order_dependence::DIVERGING_SUB_EXPRESSION,
-    eval_order_dependence::EVAL_ORDER_DEPENDENCE,
     excessive_bools::FN_PARAMS_EXCESSIVE_BOOLS,
     excessive_bools::STRUCT_EXCESSIVE_BOOLS,
     exhaustive_items::EXHAUSTIVE_ENUMS,
@@ -383,6 +381,8 @@ store.register_lints(&[
     missing_doc::MISSING_DOCS_IN_PRIVATE_ITEMS,
     missing_enforced_import_rename::MISSING_ENFORCED_IMPORT_RENAMES,
     missing_inline::MISSING_INLINE_IN_PUBLIC_ITEMS,
+    mixed_read_write_in_expression::DIVERGING_SUB_EXPRESSION,
+    mixed_read_write_in_expression::MIXED_READ_WRITE_IN_EXPRESSION,
     module_style::MOD_MODULE_FILES,
     module_style::SELF_NAMED_MODULE_FILES,
     modulo_arithmetic::MODULO_ARITHMETIC,
diff --git a/clippy_lints/src/lib.register_suspicious.rs b/clippy_lints/src/lib.register_suspicious.rs
index 5df2dd34368..239679ceb23 100644
--- a/clippy_lints/src/lib.register_suspicious.rs
+++ b/clippy_lints/src/lib.register_suspicious.rs
@@ -15,7 +15,6 @@ store.register_group(true, "clippy::suspicious", Some("clippy_suspicious"), vec!
     LintId::of(drop_forget_ref::DROP_NON_DROP),
     LintId::of(drop_forget_ref::FORGET_NON_DROP),
     LintId::of(duplicate_mod::DUPLICATE_MOD),
-    LintId::of(eval_order_dependence::EVAL_ORDER_DEPENDENCE),
     LintId::of(float_equality_without_abs::FLOAT_EQUALITY_WITHOUT_ABS),
     LintId::of(format_impl::PRINT_IN_FORMAT_IMPL),
     LintId::of(formatting::SUSPICIOUS_ASSIGNMENT_FORMATTING),
@@ -25,6 +24,7 @@ store.register_group(true, "clippy::suspicious", Some("clippy_suspicious"), vec!
     LintId::of(loops::FOR_LOOPS_OVER_FALLIBLES),
     LintId::of(loops::MUT_RANGE_BOUND),
     LintId::of(methods::SUSPICIOUS_MAP),
+    LintId::of(mixed_read_write_in_expression::MIXED_READ_WRITE_IN_EXPRESSION),
     LintId::of(mut_key::MUTABLE_KEY_TYPE),
     LintId::of(octal_escapes::OCTAL_ESCAPES),
     LintId::of(rc_clone_in_vec_init::RC_CLONE_IN_VEC_INIT),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 27cb5bf7087..dfd1c8afe1f 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -225,7 +225,6 @@ mod equatable_if_let;
 mod erasing_op;
 mod escape;
 mod eta_reduction;
-mod eval_order_dependence;
 mod excessive_bools;
 mod exhaustive_items;
 mod exit;
@@ -301,6 +300,7 @@ mod missing_const_for_fn;
 mod missing_doc;
 mod missing_enforced_import_rename;
 mod missing_inline;
+mod mixed_read_write_in_expression;
 mod module_style;
 mod modulo_arithmetic;
 mod mut_key;
@@ -680,7 +680,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(arithmetic::Arithmetic::default()));
     store.register_late_pass(|| Box::new(assign_ops::AssignOps));
     store.register_late_pass(|| Box::new(let_if_seq::LetIfSeq));
-    store.register_late_pass(|| Box::new(eval_order_dependence::EvalOrderDependence));
+    store.register_late_pass(|| Box::new(mixed_read_write_in_expression::EvalOrderDependence));
     store.register_late_pass(|| Box::new(missing_doc::MissingDoc::new()));
     store.register_late_pass(|| Box::new(missing_inline::MissingInline));
     store.register_late_pass(move || Box::new(exhaustive_items::ExhaustiveItems));
diff --git a/clippy_lints/src/mixed_read_write_in_expression.rs b/clippy_lints/src/mixed_read_write_in_expression.rs
new file mode 100644
index 00000000000..a14679dbfac
--- /dev/null
+++ b/clippy_lints/src/mixed_read_write_in_expression.rs
@@ -0,0 +1,348 @@
+use clippy_utils::diagnostics::{span_lint, span_lint_and_note};
+use clippy_utils::{get_parent_expr, path_to_local, path_to_local_id};
+use if_chain::if_chain;
+use rustc_hir::intravisit::{walk_expr, Visitor};
+use rustc_hir::{BinOpKind, Block, Expr, ExprKind, Guard, HirId, Local, Node, Stmt, StmtKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for a read and a write to the same variable where
+    /// whether the read occurs before or after the write depends on the evaluation
+    /// order of sub-expressions.
+    ///
+    /// ### Why is this bad?
+    /// It is often confusing to read. As described [here](https://doc.rust-lang.org/reference/expressions.html?highlight=subexpression#evaluation-order-of-operands),
+    /// the operands of these expressions are evaluated before applying the effects of the expression.
+    ///
+    /// ### Known problems
+    /// Code which intentionally depends on the evaluation
+    /// order, or which is correct for any evaluation order.
+    ///
+    /// ### Example
+    /// ```rust
+    /// let mut x = 0;
+    ///
+    /// // Bad
+    /// let a = {
+    ///     x = 1;
+    ///     1
+    /// } + x;
+    /// // Unclear whether a is 1 or 2.
+    ///
+    /// // Good
+    /// let tmp = {
+    ///     x = 1;
+    ///     1
+    /// };
+    /// let a = tmp + x;
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub MIXED_READ_WRITE_IN_EXPRESSION,
+    suspicious,
+    "whether a variable read occurs before a write depends on sub-expression evaluation order"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for diverging calls that are not match arms or
+    /// statements.
+    ///
+    /// ### Why is this bad?
+    /// It is often confusing to read. In addition, the
+    /// sub-expression evaluation order for Rust is not well documented.
+    ///
+    /// ### Known problems
+    /// Someone might want to use `some_bool || panic!()` as a
+    /// shorthand.
+    ///
+    /// ### Example
+    /// ```rust,no_run
+    /// # fn b() -> bool { true }
+    /// # fn c() -> bool { true }
+    /// let a = b() || panic!() || c();
+    /// // `c()` is dead, `panic!()` is only called if `b()` returns `false`
+    /// let x = (a, b, c, panic!());
+    /// // can simply be replaced by `panic!()`
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub DIVERGING_SUB_EXPRESSION,
+    complexity,
+    "whether an expression contains a diverging sub expression"
+}
+
+declare_lint_pass!(EvalOrderDependence => [MIXED_READ_WRITE_IN_EXPRESSION, DIVERGING_SUB_EXPRESSION]);
+
+impl<'tcx> LateLintPass<'tcx> for EvalOrderDependence {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        // Find a write to a local variable.
+        let var = if_chain! {
+            if let ExprKind::Assign(lhs, ..) | ExprKind::AssignOp(_, lhs, _) = expr.kind;
+            if let Some(var) = path_to_local(lhs);
+            if expr.span.desugaring_kind().is_none();
+            then { var } else { return; }
+        };
+        let mut visitor = ReadVisitor {
+            cx,
+            var,
+            write_expr: expr,
+            last_expr: expr,
+        };
+        check_for_unsequenced_reads(&mut visitor);
+    }
+    fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) {
+        match stmt.kind {
+            StmtKind::Local(local) => {
+                if let Local { init: Some(e), .. } = local {
+                    DivergenceVisitor { cx }.visit_expr(e);
+                }
+            },
+            StmtKind::Expr(e) | StmtKind::Semi(e) => DivergenceVisitor { cx }.maybe_walk_expr(e),
+            StmtKind::Item(..) => {},
+        }
+    }
+}
+
+struct DivergenceVisitor<'a, 'tcx> {
+    cx: &'a LateContext<'tcx>,
+}
+
+impl<'a, 'tcx> DivergenceVisitor<'a, 'tcx> {
+    fn maybe_walk_expr(&mut self, e: &'tcx Expr<'_>) {
+        match e.kind {
+            ExprKind::Closure(..) => {},
+            ExprKind::Match(e, arms, _) => {
+                self.visit_expr(e);
+                for arm in arms {
+                    if let Some(Guard::If(if_expr)) = arm.guard {
+                        self.visit_expr(if_expr);
+                    }
+                    // make sure top level arm expressions aren't linted
+                    self.maybe_walk_expr(&*arm.body);
+                }
+            },
+            _ => walk_expr(self, e),
+        }
+    }
+    fn report_diverging_sub_expr(&mut self, e: &Expr<'_>) {
+        span_lint(self.cx, DIVERGING_SUB_EXPRESSION, e.span, "sub-expression diverges");
+    }
+}
+
+impl<'a, 'tcx> Visitor<'tcx> for DivergenceVisitor<'a, 'tcx> {
+    fn visit_expr(&mut self, e: &'tcx Expr<'_>) {
+        match e.kind {
+            ExprKind::Continue(_) | ExprKind::Break(_, _) | ExprKind::Ret(_) => self.report_diverging_sub_expr(e),
+            ExprKind::Call(func, _) => {
+                let typ = self.cx.typeck_results().expr_ty(func);
+                match typ.kind() {
+                    ty::FnDef(..) | ty::FnPtr(_) => {
+                        let sig = typ.fn_sig(self.cx.tcx);
+                        if self.cx.tcx.erase_late_bound_regions(sig).output().kind() == &ty::Never {
+                            self.report_diverging_sub_expr(e);
+                        }
+                    },
+                    _ => {},
+                }
+            },
+            ExprKind::MethodCall(..) => {
+                let borrowed_table = self.cx.typeck_results();
+                if borrowed_table.expr_ty(e).is_never() {
+                    self.report_diverging_sub_expr(e);
+                }
+            },
+            _ => {
+                // do not lint expressions referencing objects of type `!`, as that required a
+                // diverging expression
+                // to begin with
+            },
+        }
+        self.maybe_walk_expr(e);
+    }
+    fn visit_block(&mut self, _: &'tcx Block<'_>) {
+        // don't continue over blocks, LateLintPass already does that
+    }
+}
+
+/// Walks up the AST from the given write expression (`vis.write_expr`) looking
+/// for reads to the same variable that are unsequenced relative to the write.
+///
+/// This means reads for which there is a common ancestor between the read and
+/// the write such that
+///
+/// * evaluating the ancestor necessarily evaluates both the read and the write (for example, `&x`
+///   and `|| x = 1` don't necessarily evaluate `x`), and
+///
+/// * which one is evaluated first depends on the order of sub-expression evaluation. Blocks, `if`s,
+///   loops, `match`es, and the short-circuiting logical operators are considered to have a defined
+///   evaluation order.
+///
+/// When such a read is found, the lint is triggered.
+fn check_for_unsequenced_reads(vis: &mut ReadVisitor<'_, '_>) {
+    let map = &vis.cx.tcx.hir();
+    let mut cur_id = vis.write_expr.hir_id;
+    loop {
+        let parent_id = map.get_parent_node(cur_id);
+        if parent_id == cur_id {
+            break;
+        }
+        let parent_node = match map.find(parent_id) {
+            Some(parent) => parent,
+            None => break,
+        };
+
+        let stop_early = match parent_node {
+            Node::Expr(expr) => check_expr(vis, expr),
+            Node::Stmt(stmt) => check_stmt(vis, stmt),
+            Node::Item(_) => {
+                // We reached the top of the function, stop.
+                break;
+            },
+            _ => StopEarly::KeepGoing,
+        };
+        match stop_early {
+            StopEarly::Stop => break,
+            StopEarly::KeepGoing => {},
+        }
+
+        cur_id = parent_id;
+    }
+}
+
+/// Whether to stop early for the loop in `check_for_unsequenced_reads`. (If
+/// `check_expr` weren't an independent function, this would be unnecessary and
+/// we could just use `break`).
+enum StopEarly {
+    KeepGoing,
+    Stop,
+}
+
+fn check_expr<'a, 'tcx>(vis: &mut ReadVisitor<'a, 'tcx>, expr: &'tcx Expr<'_>) -> StopEarly {
+    if expr.hir_id == vis.last_expr.hir_id {
+        return StopEarly::KeepGoing;
+    }
+
+    match expr.kind {
+        ExprKind::Array(_)
+        | ExprKind::Tup(_)
+        | ExprKind::MethodCall(..)
+        | ExprKind::Call(_, _)
+        | ExprKind::Assign(..)
+        | ExprKind::Index(_, _)
+        | ExprKind::Repeat(_, _)
+        | ExprKind::Struct(_, _, _) => {
+            walk_expr(vis, expr);
+        },
+        ExprKind::Binary(op, _, _) | ExprKind::AssignOp(op, _, _) => {
+            if op.node == BinOpKind::And || op.node == BinOpKind::Or {
+                // x && y and x || y always evaluate x first, so these are
+                // strictly sequenced.
+            } else {
+                walk_expr(vis, expr);
+            }
+        },
+        ExprKind::Closure(_, _, _, _, _) => {
+            // Either
+            //
+            // * `var` is defined in the closure body, in which case we've reached the top of the enclosing
+            //   function and can stop, or
+            //
+            // * `var` is captured by the closure, in which case, because evaluating a closure does not evaluate
+            //   its body, we don't necessarily have a write, so we need to stop to avoid generating false
+            //   positives.
+            //
+            // This is also the only place we need to stop early (grrr).
+            return StopEarly::Stop;
+        },
+        // All other expressions either have only one child or strictly
+        // sequence the evaluation order of their sub-expressions.
+        _ => {},
+    }
+
+    vis.last_expr = expr;
+
+    StopEarly::KeepGoing
+}
+
+fn check_stmt<'a, 'tcx>(vis: &mut ReadVisitor<'a, 'tcx>, stmt: &'tcx Stmt<'_>) -> StopEarly {
+    match stmt.kind {
+        StmtKind::Expr(expr) | StmtKind::Semi(expr) => check_expr(vis, expr),
+        // If the declaration is of a local variable, check its initializer
+        // expression if it has one. Otherwise, keep going.
+        StmtKind::Local(local) => local
+            .init
+            .as_ref()
+            .map_or(StopEarly::KeepGoing, |expr| check_expr(vis, expr)),
+        StmtKind::Item(..) => StopEarly::KeepGoing,
+    }
+}
+
+/// A visitor that looks for reads from a variable.
+struct ReadVisitor<'a, 'tcx> {
+    cx: &'a LateContext<'tcx>,
+    /// The ID of the variable we're looking for.
+    var: HirId,
+    /// The expressions where the write to the variable occurred (for reporting
+    /// in the lint).
+    write_expr: &'tcx Expr<'tcx>,
+    /// The last (highest in the AST) expression we've checked, so we know not
+    /// to recheck it.
+    last_expr: &'tcx Expr<'tcx>,
+}
+
+impl<'a, 'tcx> Visitor<'tcx> for ReadVisitor<'a, 'tcx> {
+    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
+        if expr.hir_id == self.last_expr.hir_id {
+            return;
+        }
+
+        if path_to_local_id(expr, self.var) {
+            // Check that this is a read, not a write.
+            if !is_in_assignment_position(self.cx, expr) {
+                span_lint_and_note(
+                    self.cx,
+                    MIXED_READ_WRITE_IN_EXPRESSION,
+                    expr.span,
+                    &format!("unsequenced read of `{}`", self.cx.tcx.hir().name(self.var)),
+                    Some(self.write_expr.span),
+                    "whether read occurs before this write depends on evaluation order",
+                );
+            }
+        }
+        match expr.kind {
+            // We're about to descend a closure. Since we don't know when (or
+            // if) the closure will be evaluated, any reads in it might not
+            // occur here (or ever). Like above, bail to avoid false positives.
+            ExprKind::Closure(_, _, _, _, _) |
+
+            // We want to avoid a false positive when a variable name occurs
+            // only to have its address taken, so we stop here. Technically,
+            // this misses some weird cases, eg.
+            //
+            // ```rust
+            // let mut x = 0;
+            // let a = foo(&{x = 1; x}, x);
+            // ```
+            //
+            // TODO: fix this
+            ExprKind::AddrOf(_, _, _) => {
+                return;
+            }
+            _ => {}
+        }
+
+        walk_expr(self, expr);
+    }
+}
+
+/// Returns `true` if `expr` is the LHS of an assignment, like `expr = ...`.
+fn is_in_assignment_position(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+    if let Some(parent) = get_parent_expr(cx, expr) {
+        if let ExprKind::Assign(lhs, ..) = parent.kind {
+            return lhs.hir_id == expr.hir_id;
+        }
+    }
+    false
+}
diff --git a/clippy_lints/src/renamed_lints.rs b/clippy_lints/src/renamed_lints.rs
index bfc03116fe2..ba03ef93721 100644
--- a/clippy_lints/src/renamed_lints.rs
+++ b/clippy_lints/src/renamed_lints.rs
@@ -9,6 +9,7 @@ pub static RENAMED_LINTS: &[(&str, &str)] = &[
     ("clippy::cyclomatic_complexity", "clippy::cognitive_complexity"),
     ("clippy::disallowed_method", "clippy::disallowed_methods"),
     ("clippy::disallowed_type", "clippy::disallowed_types"),
+    ("clippy::eval_order_dependence", "clippy::mixed_read_write_in_expression"),
     ("clippy::for_loop_over_option", "clippy::for_loops_over_fallibles"),
     ("clippy::for_loop_over_result", "clippy::for_loops_over_fallibles"),
     ("clippy::identity_conversion", "clippy::useless_conversion"),
diff --git a/tests/ui/branches_sharing_code/shared_at_top.rs b/tests/ui/branches_sharing_code/shared_at_top.rs
index 51a46481399..bdeb0a39558 100644
--- a/tests/ui/branches_sharing_code/shared_at_top.rs
+++ b/tests/ui/branches_sharing_code/shared_at_top.rs
@@ -1,4 +1,4 @@
-#![allow(dead_code, clippy::eval_order_dependence)]
+#![allow(dead_code, clippy::mixed_read_write_in_expression)]
 #![deny(clippy::if_same_then_else, clippy::branches_sharing_code)]
 
 // This tests the branches_sharing_code lint at the start of blocks
diff --git a/tests/ui/branches_sharing_code/valid_if_blocks.rs b/tests/ui/branches_sharing_code/valid_if_blocks.rs
index 0c70e3748ec..a26141be237 100644
--- a/tests/ui/branches_sharing_code/valid_if_blocks.rs
+++ b/tests/ui/branches_sharing_code/valid_if_blocks.rs
@@ -1,4 +1,4 @@
-#![allow(dead_code, clippy::eval_order_dependence)]
+#![allow(dead_code, clippy::mixed_read_write_in_expression)]
 #![deny(clippy::if_same_then_else, clippy::branches_sharing_code)]
 
 // This tests valid if blocks that shouldn't trigger the lint
diff --git a/tests/ui/eval_order_dependence.rs b/tests/ui/eval_order_dependence.rs
deleted file mode 100644
index aad78319d48..00000000000
--- a/tests/ui/eval_order_dependence.rs
+++ /dev/null
@@ -1,112 +0,0 @@
-#[warn(clippy::eval_order_dependence)]
-#[allow(
-    unused_assignments,
-    unused_variables,
-    clippy::no_effect,
-    dead_code,
-    clippy::blacklisted_name
-)]
-fn main() {
-    let mut x = 0;
-    let a = {
-        x = 1;
-        1
-    } + x;
-
-    // Example from iss#277
-    x += {
-        x = 20;
-        2
-    };
-
-    // Does it work in weird places?
-    // ...in the base for a struct expression?
-    struct Foo {
-        a: i32,
-        b: i32,
-    };
-    let base = Foo { a: 4, b: 5 };
-    let foo = Foo {
-        a: x,
-        ..{
-            x = 6;
-            base
-        }
-    };
-    // ...inside a closure?
-    let closure = || {
-        let mut x = 0;
-        x += {
-            x = 20;
-            2
-        };
-    };
-    // ...not across a closure?
-    let mut y = 0;
-    let b = (y, || y = 1);
-
-    // && and || evaluate left-to-right.
-    let a = {
-        x = 1;
-        true
-    } && (x == 3);
-    let a = {
-        x = 1;
-        true
-    } || (x == 3);
-
-    // Make sure we don't get confused by alpha conversion.
-    let a = {
-        let mut x = 1;
-        x = 2;
-        1
-    } + x;
-
-    // No warning if we don't read the variable...
-    x = {
-        x = 20;
-        2
-    };
-    // ...if the assignment is in a closure...
-    let b = {
-        || {
-            x = 1;
-        };
-        1
-    } + x;
-    // ... or the access is under an address.
-    let b = (
-        {
-            let p = &x;
-            1
-        },
-        {
-            x = 1;
-            x
-        },
-    );
-
-    // Limitation: l-values other than simple variables don't trigger
-    // the warning.
-    let mut tup = (0, 0);
-    let c = {
-        tup.0 = 1;
-        1
-    } + tup.0;
-    // Limitation: you can get away with a read under address-of.
-    let mut z = 0;
-    let b = (
-        &{
-            z = x;
-            x
-        },
-        {
-            x = 3;
-            x
-        },
-    );
-}
-
-async fn issue_6925() {
-    let _ = vec![async { true }.await, async { false }.await];
-}
diff --git a/tests/ui/eval_order_dependence.stderr b/tests/ui/eval_order_dependence.stderr
deleted file mode 100644
index 7c6265a0879..00000000000
--- a/tests/ui/eval_order_dependence.stderr
+++ /dev/null
@@ -1,51 +0,0 @@
-error: unsequenced read of `x`
-  --> $DIR/eval_order_dependence.rs:14:9
-   |
-LL |     } + x;
-   |         ^
-   |
-   = note: `-D clippy::eval-order-dependence` implied by `-D warnings`
-note: whether read occurs before this write depends on evaluation order
-  --> $DIR/eval_order_dependence.rs:12:9
-   |
-LL |         x = 1;
-   |         ^^^^^
-
-error: unsequenced read of `x`
-  --> $DIR/eval_order_dependence.rs:17:5
-   |
-LL |     x += {
-   |     ^
-   |
-note: whether read occurs before this write depends on evaluation order
-  --> $DIR/eval_order_dependence.rs:18:9
-   |
-LL |         x = 20;
-   |         ^^^^^^
-
-error: unsequenced read of `x`
-  --> $DIR/eval_order_dependence.rs:30:12
-   |
-LL |         a: x,
-   |            ^
-   |
-note: whether read occurs before this write depends on evaluation order
-  --> $DIR/eval_order_dependence.rs:32:13
-   |
-LL |             x = 6;
-   |             ^^^^^
-
-error: unsequenced read of `x`
-  --> $DIR/eval_order_dependence.rs:39:9
-   |
-LL |         x += {
-   |         ^
-   |
-note: whether read occurs before this write depends on evaluation order
-  --> $DIR/eval_order_dependence.rs:40:13
-   |
-LL |             x = 20;
-   |             ^^^^^^
-
-error: aborting due to 4 previous errors
-
diff --git a/tests/ui/mixed_read_write_in_expression.rs b/tests/ui/mixed_read_write_in_expression.rs
new file mode 100644
index 00000000000..7640057ab6e
--- /dev/null
+++ b/tests/ui/mixed_read_write_in_expression.rs
@@ -0,0 +1,112 @@
+#[warn(clippy::mixed_read_write_in_expression)]
+#[allow(
+    unused_assignments,
+    unused_variables,
+    clippy::no_effect,
+    dead_code,
+    clippy::blacklisted_name
+)]
+fn main() {
+    let mut x = 0;
+    let a = {
+        x = 1;
+        1
+    } + x;
+
+    // Example from iss#277
+    x += {
+        x = 20;
+        2
+    };
+
+    // Does it work in weird places?
+    // ...in the base for a struct expression?
+    struct Foo {
+        a: i32,
+        b: i32,
+    };
+    let base = Foo { a: 4, b: 5 };
+    let foo = Foo {
+        a: x,
+        ..{
+            x = 6;
+            base
+        }
+    };
+    // ...inside a closure?
+    let closure = || {
+        let mut x = 0;
+        x += {
+            x = 20;
+            2
+        };
+    };
+    // ...not across a closure?
+    let mut y = 0;
+    let b = (y, || y = 1);
+
+    // && and || evaluate left-to-right.
+    let a = {
+        x = 1;
+        true
+    } && (x == 3);
+    let a = {
+        x = 1;
+        true
+    } || (x == 3);
+
+    // Make sure we don't get confused by alpha conversion.
+    let a = {
+        let mut x = 1;
+        x = 2;
+        1
+    } + x;
+
+    // No warning if we don't read the variable...
+    x = {
+        x = 20;
+        2
+    };
+    // ...if the assignment is in a closure...
+    let b = {
+        || {
+            x = 1;
+        };
+        1
+    } + x;
+    // ... or the access is under an address.
+    let b = (
+        {
+            let p = &x;
+            1
+        },
+        {
+            x = 1;
+            x
+        },
+    );
+
+    // Limitation: l-values other than simple variables don't trigger
+    // the warning.
+    let mut tup = (0, 0);
+    let c = {
+        tup.0 = 1;
+        1
+    } + tup.0;
+    // Limitation: you can get away with a read under address-of.
+    let mut z = 0;
+    let b = (
+        &{
+            z = x;
+            x
+        },
+        {
+            x = 3;
+            x
+        },
+    );
+}
+
+async fn issue_6925() {
+    let _ = vec![async { true }.await, async { false }.await];
+}
diff --git a/tests/ui/mixed_read_write_in_expression.stderr b/tests/ui/mixed_read_write_in_expression.stderr
new file mode 100644
index 00000000000..2e951cdbcbf
--- /dev/null
+++ b/tests/ui/mixed_read_write_in_expression.stderr
@@ -0,0 +1,51 @@
+error: unsequenced read of `x`
+  --> $DIR/mixed_read_write_in_expression.rs:14:9
+   |
+LL |     } + x;
+   |         ^
+   |
+   = note: `-D clippy::mixed-read-write-in-expression` implied by `-D warnings`
+note: whether read occurs before this write depends on evaluation order
+  --> $DIR/mixed_read_write_in_expression.rs:12:9
+   |
+LL |         x = 1;
+   |         ^^^^^
+
+error: unsequenced read of `x`
+  --> $DIR/mixed_read_write_in_expression.rs:17:5
+   |
+LL |     x += {
+   |     ^
+   |
+note: whether read occurs before this write depends on evaluation order
+  --> $DIR/mixed_read_write_in_expression.rs:18:9
+   |
+LL |         x = 20;
+   |         ^^^^^^
+
+error: unsequenced read of `x`
+  --> $DIR/mixed_read_write_in_expression.rs:30:12
+   |
+LL |         a: x,
+   |            ^
+   |
+note: whether read occurs before this write depends on evaluation order
+  --> $DIR/mixed_read_write_in_expression.rs:32:13
+   |
+LL |             x = 6;
+   |             ^^^^^
+
+error: unsequenced read of `x`
+  --> $DIR/mixed_read_write_in_expression.rs:39:9
+   |
+LL |         x += {
+   |         ^
+   |
+note: whether read occurs before this write depends on evaluation order
+  --> $DIR/mixed_read_write_in_expression.rs:40:13
+   |
+LL |             x = 20;
+   |             ^^^^^^
+
+error: aborting due to 4 previous errors
+
diff --git a/tests/ui/rename.fixed b/tests/ui/rename.fixed
index 9c4079ad6d3..53288be9404 100644
--- a/tests/ui/rename.fixed
+++ b/tests/ui/rename.fixed
@@ -10,6 +10,7 @@
 #![allow(clippy::cognitive_complexity)]
 #![allow(clippy::disallowed_methods)]
 #![allow(clippy::disallowed_types)]
+#![allow(clippy::mixed_read_write_in_expression)]
 #![allow(clippy::for_loops_over_fallibles)]
 #![allow(clippy::useless_conversion)]
 #![allow(clippy::match_result_ok)]
@@ -39,6 +40,7 @@
 #![warn(clippy::cognitive_complexity)]
 #![warn(clippy::disallowed_methods)]
 #![warn(clippy::disallowed_types)]
+#![warn(clippy::mixed_read_write_in_expression)]
 #![warn(clippy::for_loops_over_fallibles)]
 #![warn(clippy::for_loops_over_fallibles)]
 #![warn(clippy::useless_conversion)]
diff --git a/tests/ui/rename.rs b/tests/ui/rename.rs
index e83e66b7fbd..539f34f847a 100644
--- a/tests/ui/rename.rs
+++ b/tests/ui/rename.rs
@@ -10,6 +10,7 @@
 #![allow(clippy::cognitive_complexity)]
 #![allow(clippy::disallowed_methods)]
 #![allow(clippy::disallowed_types)]
+#![allow(clippy::mixed_read_write_in_expression)]
 #![allow(clippy::for_loops_over_fallibles)]
 #![allow(clippy::useless_conversion)]
 #![allow(clippy::match_result_ok)]
@@ -39,6 +40,7 @@
 #![warn(clippy::cyclomatic_complexity)]
 #![warn(clippy::disallowed_method)]
 #![warn(clippy::disallowed_type)]
+#![warn(clippy::eval_order_dependence)]
 #![warn(clippy::for_loop_over_option)]
 #![warn(clippy::for_loop_over_result)]
 #![warn(clippy::identity_conversion)]
diff --git a/tests/ui/rename.stderr b/tests/ui/rename.stderr
index f811b10d017..8ea46b580a8 100644
--- a/tests/ui/rename.stderr
+++ b/tests/ui/rename.stderr
@@ -1,5 +1,5 @@
 error: lint `clippy::block_in_if_condition_expr` has been renamed to `clippy::blocks_in_if_conditions`
-  --> $DIR/rename.rs:35:9
+  --> $DIR/rename.rs:36:9
    |
 LL | #![warn(clippy::block_in_if_condition_expr)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::blocks_in_if_conditions`
@@ -7,202 +7,208 @@ LL | #![warn(clippy::block_in_if_condition_expr)]
    = note: `-D renamed-and-removed-lints` implied by `-D warnings`
 
 error: lint `clippy::block_in_if_condition_stmt` has been renamed to `clippy::blocks_in_if_conditions`
-  --> $DIR/rename.rs:36:9
+  --> $DIR/rename.rs:37:9
    |
 LL | #![warn(clippy::block_in_if_condition_stmt)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::blocks_in_if_conditions`
 
 error: lint `clippy::box_vec` has been renamed to `clippy::box_collection`
-  --> $DIR/rename.rs:37:9
+  --> $DIR/rename.rs:38:9
    |
 LL | #![warn(clippy::box_vec)]
    |         ^^^^^^^^^^^^^^^ help: use the new name: `clippy::box_collection`
 
 error: lint `clippy::const_static_lifetime` has been renamed to `clippy::redundant_static_lifetimes`
-  --> $DIR/rename.rs:38:9
+  --> $DIR/rename.rs:39:9
    |
 LL | #![warn(clippy::const_static_lifetime)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::redundant_static_lifetimes`
 
 error: lint `clippy::cyclomatic_complexity` has been renamed to `clippy::cognitive_complexity`
-  --> $DIR/rename.rs:39:9
+  --> $DIR/rename.rs:40:9
    |
 LL | #![warn(clippy::cyclomatic_complexity)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::cognitive_complexity`
 
 error: lint `clippy::disallowed_method` has been renamed to `clippy::disallowed_methods`
-  --> $DIR/rename.rs:40:9
+  --> $DIR/rename.rs:41:9
    |
 LL | #![warn(clippy::disallowed_method)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::disallowed_methods`
 
 error: lint `clippy::disallowed_type` has been renamed to `clippy::disallowed_types`
-  --> $DIR/rename.rs:41:9
+  --> $DIR/rename.rs:42:9
    |
 LL | #![warn(clippy::disallowed_type)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::disallowed_types`
 
+error: lint `clippy::eval_order_dependence` has been renamed to `clippy::mixed_read_write_in_expression`
+  --> $DIR/rename.rs:43:9
+   |
+LL | #![warn(clippy::eval_order_dependence)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::mixed_read_write_in_expression`
+
 error: lint `clippy::for_loop_over_option` has been renamed to `clippy::for_loops_over_fallibles`
-  --> $DIR/rename.rs:42:9
+  --> $DIR/rename.rs:44:9
    |
 LL | #![warn(clippy::for_loop_over_option)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::for_loops_over_fallibles`
 
 error: lint `clippy::for_loop_over_result` has been renamed to `clippy::for_loops_over_fallibles`
-  --> $DIR/rename.rs:43:9
+  --> $DIR/rename.rs:45:9
    |
 LL | #![warn(clippy::for_loop_over_result)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::for_loops_over_fallibles`
 
 error: lint `clippy::identity_conversion` has been renamed to `clippy::useless_conversion`
-  --> $DIR/rename.rs:44:9
+  --> $DIR/rename.rs:46:9
    |
 LL | #![warn(clippy::identity_conversion)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::useless_conversion`
 
 error: lint `clippy::if_let_some_result` has been renamed to `clippy::match_result_ok`
-  --> $DIR/rename.rs:45:9
+  --> $DIR/rename.rs:47:9
    |
 LL | #![warn(clippy::if_let_some_result)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::match_result_ok`
 
 error: lint `clippy::new_without_default_derive` has been renamed to `clippy::new_without_default`
-  --> $DIR/rename.rs:46:9
+  --> $DIR/rename.rs:48:9
    |
 LL | #![warn(clippy::new_without_default_derive)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::new_without_default`
 
 error: lint `clippy::option_and_then_some` has been renamed to `clippy::bind_instead_of_map`
-  --> $DIR/rename.rs:47:9
+  --> $DIR/rename.rs:49:9
    |
 LL | #![warn(clippy::option_and_then_some)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::bind_instead_of_map`
 
 error: lint `clippy::option_expect_used` has been renamed to `clippy::expect_used`
-  --> $DIR/rename.rs:48:9
+  --> $DIR/rename.rs:50:9
    |
 LL | #![warn(clippy::option_expect_used)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::expect_used`
 
 error: lint `clippy::option_map_unwrap_or` has been renamed to `clippy::map_unwrap_or`
-  --> $DIR/rename.rs:49:9
+  --> $DIR/rename.rs:51:9
    |
 LL | #![warn(clippy::option_map_unwrap_or)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::map_unwrap_or`
 
 error: lint `clippy::option_map_unwrap_or_else` has been renamed to `clippy::map_unwrap_or`
-  --> $DIR/rename.rs:50:9
+  --> $DIR/rename.rs:52:9
    |
 LL | #![warn(clippy::option_map_unwrap_or_else)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::map_unwrap_or`
 
 error: lint `clippy::option_unwrap_used` has been renamed to `clippy::unwrap_used`
-  --> $DIR/rename.rs:51:9
+  --> $DIR/rename.rs:53:9
    |
 LL | #![warn(clippy::option_unwrap_used)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::unwrap_used`
 
 error: lint `clippy::ref_in_deref` has been renamed to `clippy::needless_borrow`
-  --> $DIR/rename.rs:52:9
+  --> $DIR/rename.rs:54:9
    |
 LL | #![warn(clippy::ref_in_deref)]
    |         ^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::needless_borrow`
 
 error: lint `clippy::result_expect_used` has been renamed to `clippy::expect_used`
-  --> $DIR/rename.rs:53:9
+  --> $DIR/rename.rs:55:9
    |
 LL | #![warn(clippy::result_expect_used)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::expect_used`
 
 error: lint `clippy::result_map_unwrap_or_else` has been renamed to `clippy::map_unwrap_or`
-  --> $DIR/rename.rs:54:9
+  --> $DIR/rename.rs:56:9
    |
 LL | #![warn(clippy::result_map_unwrap_or_else)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::map_unwrap_or`
 
 error: lint `clippy::result_unwrap_used` has been renamed to `clippy::unwrap_used`
-  --> $DIR/rename.rs:55:9
+  --> $DIR/rename.rs:57:9
    |
 LL | #![warn(clippy::result_unwrap_used)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::unwrap_used`
 
 error: lint `clippy::single_char_push_str` has been renamed to `clippy::single_char_add_str`
-  --> $DIR/rename.rs:56:9
+  --> $DIR/rename.rs:58:9
    |
 LL | #![warn(clippy::single_char_push_str)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::single_char_add_str`
 
 error: lint `clippy::stutter` has been renamed to `clippy::module_name_repetitions`
-  --> $DIR/rename.rs:57:9
+  --> $DIR/rename.rs:59:9
    |
 LL | #![warn(clippy::stutter)]
    |         ^^^^^^^^^^^^^^^ help: use the new name: `clippy::module_name_repetitions`
 
 error: lint `clippy::to_string_in_display` has been renamed to `clippy::recursive_format_impl`
-  --> $DIR/rename.rs:58:9
+  --> $DIR/rename.rs:60:9
    |
 LL | #![warn(clippy::to_string_in_display)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::recursive_format_impl`
 
 error: lint `clippy::zero_width_space` has been renamed to `clippy::invisible_characters`
-  --> $DIR/rename.rs:59:9
+  --> $DIR/rename.rs:61:9
    |
 LL | #![warn(clippy::zero_width_space)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::invisible_characters`
 
 error: lint `clippy::drop_bounds` has been renamed to `drop_bounds`
-  --> $DIR/rename.rs:60:9
+  --> $DIR/rename.rs:62:9
    |
 LL | #![warn(clippy::drop_bounds)]
    |         ^^^^^^^^^^^^^^^^^^^ help: use the new name: `drop_bounds`
 
 error: lint `clippy::into_iter_on_array` has been renamed to `array_into_iter`
-  --> $DIR/rename.rs:61:9
+  --> $DIR/rename.rs:63:9
    |
 LL | #![warn(clippy::into_iter_on_array)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `array_into_iter`
 
 error: lint `clippy::invalid_atomic_ordering` has been renamed to `invalid_atomic_ordering`
-  --> $DIR/rename.rs:62:9
+  --> $DIR/rename.rs:64:9
    |
 LL | #![warn(clippy::invalid_atomic_ordering)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `invalid_atomic_ordering`
 
 error: lint `clippy::invalid_ref` has been renamed to `invalid_value`
-  --> $DIR/rename.rs:63:9
+  --> $DIR/rename.rs:65:9
    |
 LL | #![warn(clippy::invalid_ref)]
    |         ^^^^^^^^^^^^^^^^^^^ help: use the new name: `invalid_value`
 
 error: lint `clippy::mem_discriminant_non_enum` has been renamed to `enum_intrinsics_non_enums`
-  --> $DIR/rename.rs:64:9
+  --> $DIR/rename.rs:66:9
    |
 LL | #![warn(clippy::mem_discriminant_non_enum)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `enum_intrinsics_non_enums`
 
 error: lint `clippy::panic_params` has been renamed to `non_fmt_panics`
-  --> $DIR/rename.rs:65:9
+  --> $DIR/rename.rs:67:9
    |
 LL | #![warn(clippy::panic_params)]
    |         ^^^^^^^^^^^^^^^^^^^^ help: use the new name: `non_fmt_panics`
 
 error: lint `clippy::temporary_cstring_as_ptr` has been renamed to `temporary_cstring_as_ptr`
-  --> $DIR/rename.rs:66:9
+  --> $DIR/rename.rs:68:9
    |
 LL | #![warn(clippy::temporary_cstring_as_ptr)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `temporary_cstring_as_ptr`
 
 error: lint `clippy::unknown_clippy_lints` has been renamed to `unknown_lints`
-  --> $DIR/rename.rs:67:9
+  --> $DIR/rename.rs:69:9
    |
 LL | #![warn(clippy::unknown_clippy_lints)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `unknown_lints`
 
 error: lint `clippy::unused_label` has been renamed to `unused_labels`
-  --> $DIR/rename.rs:68:9
+  --> $DIR/rename.rs:70:9
    |
 LL | #![warn(clippy::unused_label)]
    |         ^^^^^^^^^^^^^^^^^^^^ help: use the new name: `unused_labels`
 
-error: aborting due to 34 previous errors
+error: aborting due to 35 previous errors
 
diff --git a/tests/ui/self_assignment.rs b/tests/ui/self_assignment.rs
index a7cbb9cd78b..ef647622910 100644
--- a/tests/ui/self_assignment.rs
+++ b/tests/ui/self_assignment.rs
@@ -39,7 +39,7 @@ pub fn negatives_not_equal(mut a: usize, b: &mut usize, mut s: S) {
     t.0 = t.1;
 }
 
-#[allow(clippy::eval_order_dependence)]
+#[allow(clippy::mixed_read_write_in_expression)]
 pub fn negatives_side_effects() {
     let mut v = vec![1, 2, 3, 4, 5];
     let mut i = 0;
-- 
cgit 1.4.1-3-g733a5


From 4fd296824282a6f4fc3a2634a56c4a34f86c3097 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Tue, 3 May 2022 10:58:53 -0400
Subject: Move `mixed_read_write_in_expression` into `restriction`

---
 clippy_lints/src/lib.register_all.rs               | 1 -
 clippy_lints/src/lib.register_restriction.rs       | 1 +
 clippy_lints/src/lib.register_suspicious.rs        | 1 -
 clippy_lints/src/mixed_read_write_in_expression.rs | 2 +-
 4 files changed, 2 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index a85cfe5cfbd..48ceeb43ee7 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -229,7 +229,6 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(misc_early::UNNEEDED_WILDCARD_PATTERN),
     LintId::of(misc_early::ZERO_PREFIXED_LITERAL),
     LintId::of(mixed_read_write_in_expression::DIVERGING_SUB_EXPRESSION),
-    LintId::of(mixed_read_write_in_expression::MIXED_READ_WRITE_IN_EXPRESSION),
     LintId::of(mut_key::MUTABLE_KEY_TYPE),
     LintId::of(mut_mutex_lock::MUT_MUTEX_LOCK),
     LintId::of(mut_reference::UNNECESSARY_MUT_PASSED),
diff --git a/clippy_lints/src/lib.register_restriction.rs b/clippy_lints/src/lib.register_restriction.rs
index 77ec6c83ba4..a6d3a06dc16 100644
--- a/clippy_lints/src/lib.register_restriction.rs
+++ b/clippy_lints/src/lib.register_restriction.rs
@@ -46,6 +46,7 @@ store.register_group(true, "clippy::restriction", Some("clippy_restriction"), ve
     LintId::of(missing_doc::MISSING_DOCS_IN_PRIVATE_ITEMS),
     LintId::of(missing_enforced_import_rename::MISSING_ENFORCED_IMPORT_RENAMES),
     LintId::of(missing_inline::MISSING_INLINE_IN_PUBLIC_ITEMS),
+    LintId::of(mixed_read_write_in_expression::MIXED_READ_WRITE_IN_EXPRESSION),
     LintId::of(module_style::MOD_MODULE_FILES),
     LintId::of(module_style::SELF_NAMED_MODULE_FILES),
     LintId::of(modulo_arithmetic::MODULO_ARITHMETIC),
diff --git a/clippy_lints/src/lib.register_suspicious.rs b/clippy_lints/src/lib.register_suspicious.rs
index 239679ceb23..338a6a28bc9 100644
--- a/clippy_lints/src/lib.register_suspicious.rs
+++ b/clippy_lints/src/lib.register_suspicious.rs
@@ -24,7 +24,6 @@ store.register_group(true, "clippy::suspicious", Some("clippy_suspicious"), vec!
     LintId::of(loops::FOR_LOOPS_OVER_FALLIBLES),
     LintId::of(loops::MUT_RANGE_BOUND),
     LintId::of(methods::SUSPICIOUS_MAP),
-    LintId::of(mixed_read_write_in_expression::MIXED_READ_WRITE_IN_EXPRESSION),
     LintId::of(mut_key::MUTABLE_KEY_TYPE),
     LintId::of(octal_escapes::OCTAL_ESCAPES),
     LintId::of(rc_clone_in_vec_init::RC_CLONE_IN_VEC_INIT),
diff --git a/clippy_lints/src/mixed_read_write_in_expression.rs b/clippy_lints/src/mixed_read_write_in_expression.rs
index a14679dbfac..405fc23e8de 100644
--- a/clippy_lints/src/mixed_read_write_in_expression.rs
+++ b/clippy_lints/src/mixed_read_write_in_expression.rs
@@ -41,7 +41,7 @@ declare_clippy_lint! {
     /// ```
     #[clippy::version = "pre 1.29.0"]
     pub MIXED_READ_WRITE_IN_EXPRESSION,
-    suspicious,
+    restriction,
     "whether a variable read occurs before a write depends on sub-expression evaluation order"
 }
 
-- 
cgit 1.4.1-3-g733a5


From f1574cc1319cbf4cd915568f0dc165815de93caf Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sun, 24 Apr 2022 09:46:17 -0400
Subject: Update `vec_init_then_push` docs

---
 clippy_lints/src/vec_init_then_push.rs | 13 +++++++++++--
 tests/ui/vec_init_then_push.rs         | 20 +++++++++++++++++++-
 tests/ui/vec_init_then_push.stderr     | 18 +++++++++++++++---
 3 files changed, 45 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/vec_init_then_push.rs b/clippy_lints/src/vec_init_then_push.rs
index 5a5dfcfdc8a..35db45e2b0c 100644
--- a/clippy_lints/src/vec_init_then_push.rs
+++ b/clippy_lints/src/vec_init_then_push.rs
@@ -18,6 +18,13 @@ declare_clippy_lint! {
     /// ### What it does
     /// Checks for calls to `push` immediately after creating a new `Vec`.
     ///
+    /// If the `Vec` is created using `with_capacity` this will only lint if the capacity is a
+    /// constant and the number of pushes is greater than or equal to the initial capacity.
+    ///
+    /// If the `Vec` is extended after the initial sequence of pushes and it was default initialized
+    /// then this will only lint after there were at least four pushes. This number may change in
+    /// the future.
+    ///
     /// ### Why is this bad?
     /// The `vec![]` macro is both more performant and easier to read than
     /// multiple `push` calls.
@@ -56,7 +63,7 @@ struct VecPushSearcher {
 }
 impl VecPushSearcher {
     fn display_err(&self, cx: &LateContext<'_>) {
-        let min_pushes_for_extension = match self.init {
+        let required_pushes_before_extension = match self.init {
             _ if self.found == 0 => return,
             VecInitKind::WithConstCapacity(x) if x > self.found => return,
             VecInitKind::WithConstCapacity(x) => x,
@@ -98,6 +105,8 @@ impl VecPushSearcher {
                         && adjusted_mut == Mutability::Mut
                         && !adjusted_ty.peel_refs().is_slice() =>
                 {
+                    // No need to set `needs_mut` to true. The receiver will be either explicitly borrowed, or it will
+                    // be implicitly borrowed via an adjustment. Both of these cases are already handled by this point.
                     return ControlFlow::Break(true);
                 },
                 ExprKind::Assign(lhs, ..) if e.hir_id == lhs.hir_id => {
@@ -110,7 +119,7 @@ impl VecPushSearcher {
         });
 
         // Avoid allocating small `Vec`s when they'll be extended right after.
-        if res == ControlFlow::Break(true) && self.found <= min_pushes_for_extension {
+        if res == ControlFlow::Break(true) && self.found <= required_pushes_before_extension {
             return;
         }
 
diff --git a/tests/ui/vec_init_then_push.rs b/tests/ui/vec_init_then_push.rs
index 768ea3e668a..531745424a7 100644
--- a/tests/ui/vec_init_then_push.rs
+++ b/tests/ui/vec_init_then_push.rs
@@ -29,6 +29,12 @@ fn main() {
         // no lint
         vec.push(1);
     }
+
+    let mut vec = Vec::with_capacity(5);
+    vec.push(1);
+    vec.push(2);
+    vec.push(3);
+    vec.push(4);
 }
 
 pub fn no_lint() -> Vec<i32> {
@@ -84,5 +90,17 @@ fn _cond_push_with_large_start(x: bool) -> Vec<u32> {
     if x {
         v.push(1);
     }
-    v
+
+    let mut v2 = Vec::new();
+    v2.push(0);
+    v2.push(1);
+    v2.push(0);
+    v2.push(1);
+    v2.push(0);
+    v2.push(0);
+    v2.push(1);
+    v2.push(0);
+    v2.extend(&v);
+
+    v2
 }
diff --git a/tests/ui/vec_init_then_push.stderr b/tests/ui/vec_init_then_push.stderr
index 362c9603bbf..50b029fc337 100644
--- a/tests/ui/vec_init_then_push.stderr
+++ b/tests/ui/vec_init_then_push.stderr
@@ -31,7 +31,7 @@ LL | |     new_err.push(0);
    | |____________________^ help: consider using the `vec![]` macro: `new_err = vec![..];`
 
 error: calls to `push` immediately after creation
-  --> $DIR/vec_init_then_push.rs:67:5
+  --> $DIR/vec_init_then_push.rs:73:5
    |
 LL | /     let mut v = Vec::new();
 LL | |     v.push(x);
@@ -39,7 +39,7 @@ LL | |     v.push(1);
    | |______________^ help: consider using the `vec![]` macro: `let mut v = vec![..];`
 
 error: calls to `push` immediately after creation
-  --> $DIR/vec_init_then_push.rs:75:5
+  --> $DIR/vec_init_then_push.rs:81:5
    |
 LL | /     let mut v = Vec::new();
 LL | |     v.push(0);
@@ -50,5 +50,17 @@ LL | |     v.push(1);
 LL | |     v.push(0);
    | |______________^ help: consider using the `vec![]` macro: `let mut v = vec![..];`
 
-error: aborting due to 6 previous errors
+error: calls to `push` immediately after creation
+  --> $DIR/vec_init_then_push.rs:94:5
+   |
+LL | /     let mut v2 = Vec::new();
+LL | |     v2.push(0);
+LL | |     v2.push(1);
+LL | |     v2.push(0);
+...  |
+LL | |     v2.push(1);
+LL | |     v2.push(0);
+   | |_______________^ help: consider using the `vec![]` macro: `let mut v2 = vec![..];`
+
+error: aborting due to 7 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From c649d4e8a7c4aa951cdf0d4db4bf71fb2f52eee7 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Mon, 16 May 2022 10:00:32 -0400
Subject: Fix ICE in `let_unit_value` when calling a static or const callable
 type

---
 clippy_lints/src/unit_types/let_unit_value.rs | 17 +++++++++++------
 tests/ui/crashes/ice-8821.rs                  |  8 ++++++++
 tests/ui/crashes/ice-8821.stderr              | 10 ++++++++++
 3 files changed, 29 insertions(+), 6 deletions(-)
 create mode 100644 tests/ui/crashes/ice-8821.rs
 create mode 100644 tests/ui/crashes/ice-8821.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unit_types/let_unit_value.rs b/clippy_lints/src/unit_types/let_unit_value.rs
index f3f1f53aac5..d86002c926e 100644
--- a/clippy_lints/src/unit_types/let_unit_value.rs
+++ b/clippy_lints/src/unit_types/let_unit_value.rs
@@ -3,6 +3,7 @@ use clippy_utils::source::snippet_with_macro_callsite;
 use clippy_utils::visitors::for_each_value_source;
 use core::ops::ControlFlow;
 use rustc_errors::Applicability;
+use rustc_hir::def::{DefKind, Res};
 use rustc_hir::{Expr, ExprKind, PatKind, Stmt, StmtKind};
 use rustc_lint::{LateContext, LintContext};
 use rustc_middle::lint::in_external_macro;
@@ -71,14 +72,18 @@ fn needs_inferred_result_ty(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
                 ..
             },
             _,
-        ) => cx.qpath_res(path, *hir_id).opt_def_id(),
-        ExprKind::MethodCall(..) => cx.typeck_results().type_dependent_def_id(e.hir_id),
+        ) => match cx.qpath_res(path, *hir_id) {
+            Res::Def(DefKind::AssocFn | DefKind::Fn, id) => id,
+            _ => return false,
+        },
+        ExprKind::MethodCall(..) => match cx.typeck_results().type_dependent_def_id(e.hir_id) {
+            Some(id) => id,
+            None => return false,
+        },
         _ => return false,
     };
-    if let Some(id) = id
-        && let sig = cx.tcx.fn_sig(id).skip_binder()
-        && let ty::Param(output_ty) = *sig.output().kind()
-    {
+    let sig = cx.tcx.fn_sig(id).skip_binder();
+    if let ty::Param(output_ty) = *sig.output().kind() {
         sig.inputs().iter().all(|&ty| !ty_contains_param(ty, output_ty.index))
     } else {
         false
diff --git a/tests/ui/crashes/ice-8821.rs b/tests/ui/crashes/ice-8821.rs
new file mode 100644
index 00000000000..fb87b79aeed
--- /dev/null
+++ b/tests/ui/crashes/ice-8821.rs
@@ -0,0 +1,8 @@
+#![warn(clippy::let_unit_value)]
+
+fn f() {}
+static FN: fn() = f;
+
+fn main() {
+    let _: () = FN();
+}
diff --git a/tests/ui/crashes/ice-8821.stderr b/tests/ui/crashes/ice-8821.stderr
new file mode 100644
index 00000000000..486096e0a06
--- /dev/null
+++ b/tests/ui/crashes/ice-8821.stderr
@@ -0,0 +1,10 @@
+error: this let-binding has unit value
+  --> $DIR/ice-8821.rs:7:5
+   |
+LL |     let _: () = FN();
+   |     ^^^^^^^^^^^^^^^^^ help: omit the `let` binding: `FN();`
+   |
+   = note: `-D clippy::let-unit-value` implied by `-D warnings`
+
+error: aborting due to previous error
+
-- 
cgit 1.4.1-3-g733a5


From 430575b61a95fc559f5021e246c04c3468acd1d6 Mon Sep 17 00:00:00 2001
From: Elliot Bobrow <elliotgreybobrow@gmail.com>
Date: Wed, 6 Apr 2022 09:28:49 -0700
Subject: add `manual_find` lint for function return case

---
 CHANGELOG.md                                |   1 +
 clippy_lints/src/lib.register_all.rs        |   1 +
 clippy_lints/src/lib.register_complexity.rs |   1 +
 clippy_lints/src/lib.register_lints.rs      |   1 +
 clippy_lints/src/loops/manual_find.rs       | 158 ++++++++++++++++++
 clippy_lints/src/loops/mod.rs               |  34 ++++
 clippy_lints/src/non_expressive_names.rs    |  10 +-
 tests/ui/manual_find.rs                     |  22 +++
 tests/ui/manual_find.stderr                 |  29 ++++
 tests/ui/manual_find_fixable.fixed          | 182 +++++++++++++++++++++
 tests/ui/manual_find_fixable.rs             | 242 ++++++++++++++++++++++++++++
 tests/ui/manual_find_fixable.stderr         | 142 ++++++++++++++++
 tests/ui/while_let_on_iterator.fixed        |   3 +-
 tests/ui/while_let_on_iterator.rs           |   3 +-
 tests/ui/while_let_on_iterator.stderr       |  46 +++---
 15 files changed, 844 insertions(+), 31 deletions(-)
 create mode 100644 clippy_lints/src/loops/manual_find.rs
 create mode 100644 tests/ui/manual_find.rs
 create mode 100644 tests/ui/manual_find.stderr
 create mode 100644 tests/ui/manual_find_fixable.fixed
 create mode 100644 tests/ui/manual_find_fixable.rs
 create mode 100644 tests/ui/manual_find_fixable.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index fd288285532..0011f50da20 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3384,6 +3384,7 @@ Released 2018-09-13
 [`manual_async_fn`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_async_fn
 [`manual_bits`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_bits
 [`manual_filter_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_filter_map
+[`manual_find`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_find
 [`manual_find_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_find_map
 [`manual_flatten`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_flatten
 [`manual_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_map
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 132a4662676..844008254a8 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -109,6 +109,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(loops::FOR_KV_MAP),
     LintId::of(loops::FOR_LOOPS_OVER_FALLIBLES),
     LintId::of(loops::ITER_NEXT_LOOP),
+    LintId::of(loops::MANUAL_FIND),
     LintId::of(loops::MANUAL_FLATTEN),
     LintId::of(loops::MANUAL_MEMCPY),
     LintId::of(loops::MISSING_SPIN_LOOP),
diff --git a/clippy_lints/src/lib.register_complexity.rs b/clippy_lints/src/lib.register_complexity.rs
index a2ce69065f9..64f5b2df004 100644
--- a/clippy_lints/src/lib.register_complexity.rs
+++ b/clippy_lints/src/lib.register_complexity.rs
@@ -21,6 +21,7 @@ store.register_group(true, "clippy::complexity", Some("clippy_complexity"), vec!
     LintId::of(lifetimes::EXTRA_UNUSED_LIFETIMES),
     LintId::of(lifetimes::NEEDLESS_LIFETIMES),
     LintId::of(loops::EXPLICIT_COUNTER_LOOP),
+    LintId::of(loops::MANUAL_FIND),
     LintId::of(loops::MANUAL_FLATTEN),
     LintId::of(loops::SINGLE_ELEMENT_LOOP),
     LintId::of(loops::WHILE_LET_LOOP),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 21f1ef562b5..d5ddb95d25f 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -222,6 +222,7 @@ store.register_lints(&[
     loops::FOR_KV_MAP,
     loops::FOR_LOOPS_OVER_FALLIBLES,
     loops::ITER_NEXT_LOOP,
+    loops::MANUAL_FIND,
     loops::MANUAL_FLATTEN,
     loops::MANUAL_MEMCPY,
     loops::MISSING_SPIN_LOOP,
diff --git a/clippy_lints/src/loops/manual_find.rs b/clippy_lints/src/loops/manual_find.rs
new file mode 100644
index 00000000000..33736d6d4e6
--- /dev/null
+++ b/clippy_lints/src/loops/manual_find.rs
@@ -0,0 +1,158 @@
+use super::utils::make_iterator_snippet;
+use super::MANUAL_FIND;
+use clippy_utils::{
+    diagnostics::span_lint_and_then, higher, is_lang_ctor, path_res, peel_blocks_with_stmt,
+    source::snippet_with_applicability, ty::implements_trait,
+};
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir::{
+    def::Res, lang_items::LangItem, BindingAnnotation, Block, Expr, ExprKind, HirId, Node, Pat, PatKind, Stmt, StmtKind,
+};
+use rustc_lint::LateContext;
+use rustc_span::source_map::Span;
+
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    pat: &'tcx Pat<'_>,
+    arg: &'tcx Expr<'_>,
+    body: &'tcx Expr<'_>,
+    span: Span,
+    expr: &'tcx Expr<'_>,
+) {
+    let inner_expr = peel_blocks_with_stmt(body);
+    // Check for the specific case that the result is returned and optimize suggestion for that (more
+    // cases can be added later)
+    if_chain! {
+        if let Some(higher::If { cond, then, r#else: None, }) = higher::If::hir(inner_expr);
+        if let Some(binding_id) = get_binding(pat);
+        if let ExprKind::Block(block, _) = then.kind;
+        if let [stmt] = block.stmts;
+        if let StmtKind::Semi(semi) = stmt.kind;
+        if let ExprKind::Ret(Some(ret_value)) = semi.kind;
+        if let ExprKind::Call(Expr { kind: ExprKind::Path(ctor), .. }, [inner_ret]) = ret_value.kind;
+        if is_lang_ctor(cx, ctor, LangItem::OptionSome);
+        if path_res(cx, inner_ret) == Res::Local(binding_id);
+        if let Some((last_stmt, last_ret)) = last_stmt_and_ret(cx, expr);
+        then {
+            let mut applicability = Applicability::MachineApplicable;
+            let mut snippet = make_iterator_snippet(cx, arg, &mut applicability);
+            // Checks if `pat` is a single reference to a binding (`&x`)
+            let is_ref_to_binding =
+                matches!(pat.kind, PatKind::Ref(inner, _) if matches!(inner.kind, PatKind::Binding(..)));
+            // If `pat` is not a binding or a reference to a binding (`x` or `&x`)
+            // we need to map it to the binding returned by the function (i.e. `.map(|(x, _)| x)`)
+            if !(matches!(pat.kind, PatKind::Binding(..)) || is_ref_to_binding) {
+                snippet.push_str(
+                    &format!(
+                        ".map(|{}| {})",
+                        snippet_with_applicability(cx, pat.span, "..", &mut applicability),
+                        snippet_with_applicability(cx, inner_ret.span, "..", &mut applicability),
+                    )[..],
+                );
+            }
+            let ty = cx.typeck_results().expr_ty(inner_ret);
+            if cx.tcx.lang_items().copy_trait().map_or(false, |id| implements_trait(cx, ty, id, &[])) {
+                snippet.push_str(
+                    &format!(
+                        ".find(|{}{}| {})",
+                        "&".repeat(1 + usize::from(is_ref_to_binding)),
+                        snippet_with_applicability(cx, inner_ret.span, "..", &mut applicability),
+                        snippet_with_applicability(cx, cond.span, "..", &mut applicability),
+                    )[..],
+                );
+                if is_ref_to_binding {
+                    snippet.push_str(".copied()");
+                }
+            } else {
+                applicability = Applicability::MaybeIncorrect;
+                snippet.push_str(
+                    &format!(
+                        ".find(|{}| {})",
+                        snippet_with_applicability(cx, inner_ret.span, "..", &mut applicability),
+                        snippet_with_applicability(cx, cond.span, "..", &mut applicability),
+                    )[..],
+                );
+            }
+            // Extends to `last_stmt` to include semicolon in case of `return None;`
+            let lint_span = span.to(last_stmt.span).to(last_ret.span);
+            span_lint_and_then(
+                cx,
+                MANUAL_FIND,
+                lint_span,
+                "manual implementation of `Iterator::find`",
+                |diag| {
+                    if applicability == Applicability::MaybeIncorrect {
+                        diag.note("you may need to dereference some variables");
+                    }
+                    diag.span_suggestion(
+                        lint_span,
+                        "replace with an iterator",
+                        snippet,
+                        applicability,
+                    );
+                },
+            );
+        }
+    }
+}
+
+fn get_binding(pat: &Pat<'_>) -> Option<HirId> {
+    let mut hir_id = None;
+    let mut count = 0;
+    pat.each_binding(|annotation, id, _, _| {
+        count += 1;
+        if count > 1 {
+            hir_id = None;
+            return;
+        }
+        if let BindingAnnotation::Unannotated = annotation {
+            hir_id = Some(id);
+        }
+    });
+    hir_id
+}
+
+// Returns the last statement and last return if function fits format for lint
+fn last_stmt_and_ret<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx Expr<'_>,
+) -> Option<(&'tcx Stmt<'tcx>, &'tcx Expr<'tcx>)> {
+    // Returns last non-return statement and the last return
+    fn extract<'tcx>(block: &Block<'tcx>) -> Option<(&'tcx Stmt<'tcx>, &'tcx Expr<'tcx>)> {
+        if let [.., last_stmt] = block.stmts {
+            if let Some(ret) = block.expr {
+                return Some((last_stmt, ret));
+            }
+            if_chain! {
+                if let [.., snd_last, _] = block.stmts;
+                if let StmtKind::Semi(last_expr) = last_stmt.kind;
+                if let ExprKind::Ret(Some(ret)) = last_expr.kind;
+                then {
+                    return Some((snd_last, ret));
+                }
+            }
+        }
+        None
+    }
+    let mut parent_iter = cx.tcx.hir().parent_iter(expr.hir_id);
+    if_chain! {
+        // This should be the loop
+        if let Some((node_hir, Node::Stmt(..))) = parent_iter.next();
+        // This should be the funciton body
+        if let Some((_, Node::Block(block))) = parent_iter.next();
+        if let Some((last_stmt, last_ret)) = extract(block);
+        if last_stmt.hir_id == node_hir;
+        if let ExprKind::Path(path) = &last_ret.kind;
+        if is_lang_ctor(cx, path, LangItem::OptionNone);
+        if let Some((_, Node::Expr(_block))) = parent_iter.next();
+        // This includes the function header
+        if let Some((_, func)) = parent_iter.next();
+        if func.fn_kind().is_some();
+        then {
+            Some((block.stmts.last().unwrap(), last_ret))
+        } else {
+            None
+        }
+    }
+}
diff --git a/clippy_lints/src/loops/mod.rs b/clippy_lints/src/loops/mod.rs
index f029067d367..2f5d176b2de 100644
--- a/clippy_lints/src/loops/mod.rs
+++ b/clippy_lints/src/loops/mod.rs
@@ -5,6 +5,7 @@ mod explicit_iter_loop;
 mod for_kv_map;
 mod for_loops_over_fallibles;
 mod iter_next_loop;
+mod manual_find;
 mod manual_flatten;
 mod manual_memcpy;
 mod missing_spin_loop;
@@ -597,6 +598,37 @@ declare_clippy_lint! {
     "An empty busy waiting loop"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Check for manual implementations of Iterator::find
+    ///
+    /// ### Why is this bad?
+    /// It doesn't affect performance, but using `find` is shorter and easier to read.
+    ///
+    /// ### Example
+    ///
+    /// ```rust
+    /// fn example(arr: Vec<i32>) -> Option<i32> {
+    ///     for el in arr {
+    ///         if el == 1 {
+    ///             return Some(el);
+    ///         }
+    ///     }
+    ///     None
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// fn example(arr: Vec<i32>) -> Option<i32> {
+    ///     arr.into_iter().find(|&el| el == 1)
+    /// }
+    /// ```
+    #[clippy::version = "1.61.0"]
+    pub MANUAL_FIND,
+    complexity,
+    "manual implementation of `Iterator::find`"
+}
+
 declare_lint_pass!(Loops => [
     MANUAL_MEMCPY,
     MANUAL_FLATTEN,
@@ -617,6 +649,7 @@ declare_lint_pass!(Loops => [
     SAME_ITEM_PUSH,
     SINGLE_ELEMENT_LOOP,
     MISSING_SPIN_LOOP,
+    MANUAL_FIND,
 ]);
 
 impl<'tcx> LateLintPass<'tcx> for Loops {
@@ -692,6 +725,7 @@ fn check_for_loop<'tcx>(
     single_element_loop::check(cx, pat, arg, body, expr);
     same_item_push::check(cx, pat, arg, body, expr);
     manual_flatten::check(cx, pat, arg, body, span);
+    manual_find::check(cx, pat, arg, body, span, expr);
 }
 
 fn check_for_loop_arg(cx: &LateContext<'_>, pat: &Pat<'_>, arg: &Expr<'_>) {
diff --git a/clippy_lints/src/non_expressive_names.rs b/clippy_lints/src/non_expressive_names.rs
index 0d0c88b02c7..4a3edbb9d37 100644
--- a/clippy_lints/src/non_expressive_names.rs
+++ b/clippy_lints/src/non_expressive_names.rs
@@ -159,12 +159,10 @@ impl<'a, 'tcx, 'b> Visitor<'tcx> for SimilarNamesNameVisitor<'a, 'tcx, 'b> {
 
 #[must_use]
 fn get_exemptions(interned_name: &str) -> Option<&'static [&'static str]> {
-    for &list in ALLOWED_TO_BE_SIMILAR {
-        if allowed_to_be_similar(interned_name, list) {
-            return Some(list);
-        }
-    }
-    None
+    ALLOWED_TO_BE_SIMILAR
+        .iter()
+        .find(|&&list| allowed_to_be_similar(interned_name, list))
+        .copied()
 }
 
 #[must_use]
diff --git a/tests/ui/manual_find.rs b/tests/ui/manual_find.rs
new file mode 100644
index 00000000000..257fe045f78
--- /dev/null
+++ b/tests/ui/manual_find.rs
@@ -0,0 +1,22 @@
+#![allow(unused)]
+#![warn(clippy::manual_find)]
+
+fn vec_string(strings: Vec<String>) -> Option<String> {
+    for s in strings {
+        if s == String::new() {
+            return Some(s);
+        }
+    }
+    None
+}
+
+fn tuple(arr: Vec<(String, i32)>) -> Option<String> {
+    for (s, _) in arr {
+        if s == String::new() {
+            return Some(s);
+        }
+    }
+    None
+}
+
+fn main() {}
diff --git a/tests/ui/manual_find.stderr b/tests/ui/manual_find.stderr
new file mode 100644
index 00000000000..da0fd4aaef7
--- /dev/null
+++ b/tests/ui/manual_find.stderr
@@ -0,0 +1,29 @@
+error: manual implementation of `Iterator::find`
+  --> $DIR/manual_find.rs:5:5
+   |
+LL | /     for s in strings {
+LL | |         if s == String::new() {
+LL | |             return Some(s);
+LL | |         }
+LL | |     }
+LL | |     None
+   | |________^ help: replace with an iterator: `strings.into_iter().find(|s| s == String::new())`
+   |
+   = note: `-D clippy::manual-find` implied by `-D warnings`
+   = note: you may need to dereference some variables
+
+error: manual implementation of `Iterator::find`
+  --> $DIR/manual_find.rs:14:5
+   |
+LL | /     for (s, _) in arr {
+LL | |         if s == String::new() {
+LL | |             return Some(s);
+LL | |         }
+LL | |     }
+LL | |     None
+   | |________^ help: replace with an iterator: `arr.into_iter().map(|(s, _)| s).find(|s| s == String::new())`
+   |
+   = note: you may need to dereference some variables
+
+error: aborting due to 2 previous errors
+
diff --git a/tests/ui/manual_find_fixable.fixed b/tests/ui/manual_find_fixable.fixed
new file mode 100644
index 00000000000..36d1644c22b
--- /dev/null
+++ b/tests/ui/manual_find_fixable.fixed
@@ -0,0 +1,182 @@
+// run-rustfix
+
+#![allow(unused, clippy::needless_return)]
+#![warn(clippy::manual_find)]
+
+use std::collections::HashMap;
+
+const ARRAY: &[u32; 5] = &[2, 7, 1, 9, 3];
+
+fn lookup(n: u32) -> Option<u32> {
+    ARRAY.iter().find(|&&v| v == n).copied()
+}
+
+fn with_pat(arr: Vec<(u32, u32)>) -> Option<u32> {
+    arr.into_iter().map(|(a, _)| a).find(|&a| a % 2 == 0)
+}
+
+struct Data {
+    name: String,
+    is_true: bool,
+}
+fn with_struct(arr: Vec<Data>) -> Option<Data> {
+    arr.into_iter().find(|el| el.name.len() == 10)
+}
+
+struct Tuple(usize, usize);
+fn with_tuple_struct(arr: Vec<Tuple>) -> Option<usize> {
+    arr.into_iter().map(|Tuple(a, _)| a).find(|&a| a >= 3)
+}
+
+struct A;
+impl A {
+    fn should_keep(&self) -> bool {
+        true
+    }
+}
+fn with_method_call(arr: Vec<A>) -> Option<A> {
+    arr.into_iter().find(|el| el.should_keep())
+}
+
+fn with_closure(arr: Vec<u32>) -> Option<u32> {
+    let f = |el: u32| -> u32 { el + 10 };
+    arr.into_iter().find(|&el| f(el) == 20)
+}
+
+fn with_closure2(arr: HashMap<String, i32>) -> Option<i32> {
+    let f = |el: i32| -> bool { el == 10 };
+    arr.values().find(|&&el| f(el)).copied()
+}
+
+fn with_bool(arr: Vec<Data>) -> Option<Data> {
+    arr.into_iter().find(|el| el.is_true)
+}
+
+fn with_side_effects(arr: Vec<u32>) -> Option<u32> {
+    for v in arr {
+        if v == 1 {
+            println!("side effect");
+            return Some(v);
+        }
+    }
+    None
+}
+
+fn with_else(arr: Vec<u32>) -> Option<u32> {
+    for el in arr {
+        if el % 2 == 0 {
+            return Some(el);
+        } else {
+            println!("{}", el);
+        }
+    }
+    None
+}
+
+fn tuple_with_ref(v: [(u8, &u8); 3]) -> Option<u8> {
+    v.into_iter().map(|(_, &x)| x).find(|&x| x > 10)
+}
+
+fn ref_to_tuple_with_ref(v: &[(u8, &u8)]) -> Option<u8> {
+    v.iter().map(|&(_, &x)| x).find(|&x| x > 10)
+}
+
+fn explicit_ret(arr: Vec<i32>) -> Option<i32> {
+    arr.into_iter().find(|&x| x >= 5)
+}
+
+fn plus_one(a: i32) -> Option<i32> {
+    Some(a + 1)
+}
+fn fn_instead_of_some(a: &[i32]) -> Option<i32> {
+    for &x in a {
+        if x == 1 {
+            return plus_one(x);
+        }
+    }
+    None
+}
+
+fn for_in_condition(a: &[i32], b: bool) -> Option<i32> {
+    if b {
+        for &x in a {
+            if x == 1 {
+                return Some(x);
+            }
+        }
+    }
+    None
+}
+
+fn intermediate_statements(a: &[i32]) -> Option<i32> {
+    for &x in a {
+        if x == 1 {
+            return Some(x);
+        }
+    }
+
+    println!("side effect");
+
+    None
+}
+
+fn mixed_binding_modes(arr: Vec<(i32, String)>) -> Option<i32> {
+    for (x, mut s) in arr {
+        if x == 1 && s.as_mut_str().len() == 2 {
+            return Some(x);
+        }
+    }
+    None
+}
+
+fn as_closure() {
+    #[rustfmt::skip]
+    let f = |arr: Vec<i32>| -> Option<i32> {
+        arr.into_iter().find(|&x| x < 1)
+    };
+}
+
+fn in_block(a: &[i32]) -> Option<i32> {
+    let should_be_none = {
+        for &x in a {
+            if x == 1 {
+                return Some(x);
+            }
+        }
+        None
+    };
+
+    assert!(should_be_none.is_none());
+
+    should_be_none
+}
+
+// Not handled yet
+fn mut_binding(v: Vec<String>) -> Option<String> {
+    for mut s in v {
+        if s.as_mut_str().len() > 1 {
+            return Some(s);
+        }
+    }
+    None
+}
+
+fn subpattern(v: Vec<[u32; 32]>) -> Option<[u32; 32]> {
+    for a @ [first, ..] in v {
+        if a[12] == first {
+            return Some(a);
+        }
+    }
+    None
+}
+
+fn two_bindings(v: Vec<(u8, u8)>) -> Option<u8> {
+    for (a, n) in v {
+        if a == n {
+            return Some(a);
+        }
+    }
+    None
+}
+
+fn main() {}
diff --git a/tests/ui/manual_find_fixable.rs b/tests/ui/manual_find_fixable.rs
new file mode 100644
index 00000000000..ed277ddaa72
--- /dev/null
+++ b/tests/ui/manual_find_fixable.rs
@@ -0,0 +1,242 @@
+// run-rustfix
+
+#![allow(unused, clippy::needless_return)]
+#![warn(clippy::manual_find)]
+
+use std::collections::HashMap;
+
+const ARRAY: &[u32; 5] = &[2, 7, 1, 9, 3];
+
+fn lookup(n: u32) -> Option<u32> {
+    for &v in ARRAY {
+        if v == n {
+            return Some(v);
+        }
+    }
+    None
+}
+
+fn with_pat(arr: Vec<(u32, u32)>) -> Option<u32> {
+    for (a, _) in arr {
+        if a % 2 == 0 {
+            return Some(a);
+        }
+    }
+    None
+}
+
+struct Data {
+    name: String,
+    is_true: bool,
+}
+fn with_struct(arr: Vec<Data>) -> Option<Data> {
+    for el in arr {
+        if el.name.len() == 10 {
+            return Some(el);
+        }
+    }
+    None
+}
+
+struct Tuple(usize, usize);
+fn with_tuple_struct(arr: Vec<Tuple>) -> Option<usize> {
+    for Tuple(a, _) in arr {
+        if a >= 3 {
+            return Some(a);
+        }
+    }
+    None
+}
+
+struct A;
+impl A {
+    fn should_keep(&self) -> bool {
+        true
+    }
+}
+fn with_method_call(arr: Vec<A>) -> Option<A> {
+    for el in arr {
+        if el.should_keep() {
+            return Some(el);
+        }
+    }
+    None
+}
+
+fn with_closure(arr: Vec<u32>) -> Option<u32> {
+    let f = |el: u32| -> u32 { el + 10 };
+    for el in arr {
+        if f(el) == 20 {
+            return Some(el);
+        }
+    }
+    None
+}
+
+fn with_closure2(arr: HashMap<String, i32>) -> Option<i32> {
+    let f = |el: i32| -> bool { el == 10 };
+    for &el in arr.values() {
+        if f(el) {
+            return Some(el);
+        }
+    }
+    None
+}
+
+fn with_bool(arr: Vec<Data>) -> Option<Data> {
+    for el in arr {
+        if el.is_true {
+            return Some(el);
+        }
+    }
+    None
+}
+
+fn with_side_effects(arr: Vec<u32>) -> Option<u32> {
+    for v in arr {
+        if v == 1 {
+            println!("side effect");
+            return Some(v);
+        }
+    }
+    None
+}
+
+fn with_else(arr: Vec<u32>) -> Option<u32> {
+    for el in arr {
+        if el % 2 == 0 {
+            return Some(el);
+        } else {
+            println!("{}", el);
+        }
+    }
+    None
+}
+
+fn tuple_with_ref(v: [(u8, &u8); 3]) -> Option<u8> {
+    for (_, &x) in v {
+        if x > 10 {
+            return Some(x);
+        }
+    }
+    None
+}
+
+fn ref_to_tuple_with_ref(v: &[(u8, &u8)]) -> Option<u8> {
+    for &(_, &x) in v {
+        if x > 10 {
+            return Some(x);
+        }
+    }
+    None
+}
+
+fn explicit_ret(arr: Vec<i32>) -> Option<i32> {
+    for x in arr {
+        if x >= 5 {
+            return Some(x);
+        }
+    }
+    return None;
+}
+
+fn plus_one(a: i32) -> Option<i32> {
+    Some(a + 1)
+}
+fn fn_instead_of_some(a: &[i32]) -> Option<i32> {
+    for &x in a {
+        if x == 1 {
+            return plus_one(x);
+        }
+    }
+    None
+}
+
+fn for_in_condition(a: &[i32], b: bool) -> Option<i32> {
+    if b {
+        for &x in a {
+            if x == 1 {
+                return Some(x);
+            }
+        }
+    }
+    None
+}
+
+fn intermediate_statements(a: &[i32]) -> Option<i32> {
+    for &x in a {
+        if x == 1 {
+            return Some(x);
+        }
+    }
+
+    println!("side effect");
+
+    None
+}
+
+fn mixed_binding_modes(arr: Vec<(i32, String)>) -> Option<i32> {
+    for (x, mut s) in arr {
+        if x == 1 && s.as_mut_str().len() == 2 {
+            return Some(x);
+        }
+    }
+    None
+}
+
+fn as_closure() {
+    #[rustfmt::skip]
+    let f = |arr: Vec<i32>| -> Option<i32> {
+        for x in arr {
+            if x < 1 {
+                return Some(x);
+            }
+        }
+        None
+    };
+}
+
+fn in_block(a: &[i32]) -> Option<i32> {
+    let should_be_none = {
+        for &x in a {
+            if x == 1 {
+                return Some(x);
+            }
+        }
+        None
+    };
+
+    assert!(should_be_none.is_none());
+
+    should_be_none
+}
+
+// Not handled yet
+fn mut_binding(v: Vec<String>) -> Option<String> {
+    for mut s in v {
+        if s.as_mut_str().len() > 1 {
+            return Some(s);
+        }
+    }
+    None
+}
+
+fn subpattern(v: Vec<[u32; 32]>) -> Option<[u32; 32]> {
+    for a @ [first, ..] in v {
+        if a[12] == first {
+            return Some(a);
+        }
+    }
+    None
+}
+
+fn two_bindings(v: Vec<(u8, u8)>) -> Option<u8> {
+    for (a, n) in v {
+        if a == n {
+            return Some(a);
+        }
+    }
+    None
+}
+
+fn main() {}
diff --git a/tests/ui/manual_find_fixable.stderr b/tests/ui/manual_find_fixable.stderr
new file mode 100644
index 00000000000..dbc4ff69a74
--- /dev/null
+++ b/tests/ui/manual_find_fixable.stderr
@@ -0,0 +1,142 @@
+error: manual implementation of `Iterator::find`
+  --> $DIR/manual_find_fixable.rs:11:5
+   |
+LL | /     for &v in ARRAY {
+LL | |         if v == n {
+LL | |             return Some(v);
+LL | |         }
+LL | |     }
+LL | |     None
+   | |________^ help: replace with an iterator: `ARRAY.iter().find(|&&v| v == n).copied()`
+   |
+   = note: `-D clippy::manual-find` implied by `-D warnings`
+
+error: manual implementation of `Iterator::find`
+  --> $DIR/manual_find_fixable.rs:20:5
+   |
+LL | /     for (a, _) in arr {
+LL | |         if a % 2 == 0 {
+LL | |             return Some(a);
+LL | |         }
+LL | |     }
+LL | |     None
+   | |________^ help: replace with an iterator: `arr.into_iter().map(|(a, _)| a).find(|&a| a % 2 == 0)`
+
+error: manual implementation of `Iterator::find`
+  --> $DIR/manual_find_fixable.rs:33:5
+   |
+LL | /     for el in arr {
+LL | |         if el.name.len() == 10 {
+LL | |             return Some(el);
+LL | |         }
+LL | |     }
+LL | |     None
+   | |________^ help: replace with an iterator: `arr.into_iter().find(|el| el.name.len() == 10)`
+   |
+   = note: you may need to dereference some variables
+
+error: manual implementation of `Iterator::find`
+  --> $DIR/manual_find_fixable.rs:43:5
+   |
+LL | /     for Tuple(a, _) in arr {
+LL | |         if a >= 3 {
+LL | |             return Some(a);
+LL | |         }
+LL | |     }
+LL | |     None
+   | |________^ help: replace with an iterator: `arr.into_iter().map(|Tuple(a, _)| a).find(|&a| a >= 3)`
+
+error: manual implementation of `Iterator::find`
+  --> $DIR/manual_find_fixable.rs:58:5
+   |
+LL | /     for el in arr {
+LL | |         if el.should_keep() {
+LL | |             return Some(el);
+LL | |         }
+LL | |     }
+LL | |     None
+   | |________^ help: replace with an iterator: `arr.into_iter().find(|el| el.should_keep())`
+   |
+   = note: you may need to dereference some variables
+
+error: manual implementation of `Iterator::find`
+  --> $DIR/manual_find_fixable.rs:68:5
+   |
+LL | /     for el in arr {
+LL | |         if f(el) == 20 {
+LL | |             return Some(el);
+LL | |         }
+LL | |     }
+LL | |     None
+   | |________^ help: replace with an iterator: `arr.into_iter().find(|&el| f(el) == 20)`
+
+error: manual implementation of `Iterator::find`
+  --> $DIR/manual_find_fixable.rs:78:5
+   |
+LL | /     for &el in arr.values() {
+LL | |         if f(el) {
+LL | |             return Some(el);
+LL | |         }
+LL | |     }
+LL | |     None
+   | |________^ help: replace with an iterator: `arr.values().find(|&&el| f(el)).copied()`
+
+error: manual implementation of `Iterator::find`
+  --> $DIR/manual_find_fixable.rs:87:5
+   |
+LL | /     for el in arr {
+LL | |         if el.is_true {
+LL | |             return Some(el);
+LL | |         }
+LL | |     }
+LL | |     None
+   | |________^ help: replace with an iterator: `arr.into_iter().find(|el| el.is_true)`
+   |
+   = note: you may need to dereference some variables
+
+error: manual implementation of `Iterator::find`
+  --> $DIR/manual_find_fixable.rs:117:5
+   |
+LL | /     for (_, &x) in v {
+LL | |         if x > 10 {
+LL | |             return Some(x);
+LL | |         }
+LL | |     }
+LL | |     None
+   | |________^ help: replace with an iterator: `v.into_iter().map(|(_, &x)| x).find(|&x| x > 10)`
+
+error: manual implementation of `Iterator::find`
+  --> $DIR/manual_find_fixable.rs:126:5
+   |
+LL | /     for &(_, &x) in v {
+LL | |         if x > 10 {
+LL | |             return Some(x);
+LL | |         }
+LL | |     }
+LL | |     None
+   | |________^ help: replace with an iterator: `v.iter().map(|&(_, &x)| x).find(|&x| x > 10)`
+
+error: manual implementation of `Iterator::find`
+  --> $DIR/manual_find_fixable.rs:135:5
+   |
+LL | /     for x in arr {
+LL | |         if x >= 5 {
+LL | |             return Some(x);
+LL | |         }
+LL | |     }
+LL | |     return None;
+   | |________________^ help: replace with an iterator: `arr.into_iter().find(|&x| x >= 5)`
+
+error: manual implementation of `Iterator::find`
+  --> $DIR/manual_find_fixable.rs:190:9
+   |
+LL | /         for x in arr {
+LL | |             if x < 1 {
+LL | |                 return Some(x);
+LL | |             }
+LL | |         }
+LL | |         None
+   | |____________^ help: replace with an iterator: `arr.into_iter().find(|&x| x < 1)`
+
+error: aborting due to 12 previous errors
+
diff --git a/tests/ui/while_let_on_iterator.fixed b/tests/ui/while_let_on_iterator.fixed
index cb8892a3f00..e9ff64431e1 100644
--- a/tests/ui/while_let_on_iterator.fixed
+++ b/tests/ui/while_let_on_iterator.fixed
@@ -6,7 +6,8 @@
     unreachable_code,
     unused_mut,
     dead_code,
-    clippy::equatable_if_let
+    clippy::equatable_if_let,
+    clippy::manual_find
 )]
 
 fn base() {
diff --git a/tests/ui/while_let_on_iterator.rs b/tests/ui/while_let_on_iterator.rs
index d9157184495..03da39526b2 100644
--- a/tests/ui/while_let_on_iterator.rs
+++ b/tests/ui/while_let_on_iterator.rs
@@ -6,7 +6,8 @@
     unreachable_code,
     unused_mut,
     dead_code,
-    clippy::equatable_if_let
+    clippy::equatable_if_let,
+    clippy::manual_find
 )]
 
 fn base() {
diff --git a/tests/ui/while_let_on_iterator.stderr b/tests/ui/while_let_on_iterator.stderr
index fb2b0f2467c..42859243855 100644
--- a/tests/ui/while_let_on_iterator.stderr
+++ b/tests/ui/while_let_on_iterator.stderr
@@ -1,5 +1,5 @@
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:14:5
+  --> $DIR/while_let_on_iterator.rs:15:5
    |
 LL |     while let Option::Some(x) = iter.next() {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for x in iter`
@@ -7,85 +7,85 @@ LL |     while let Option::Some(x) = iter.next() {
    = note: `-D clippy::while-let-on-iterator` implied by `-D warnings`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:19:5
+  --> $DIR/while_let_on_iterator.rs:20:5
    |
 LL |     while let Some(x) = iter.next() {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for x in iter`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:24:5
+  --> $DIR/while_let_on_iterator.rs:25:5
    |
 LL |     while let Some(_) = iter.next() {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for _ in iter`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:100:9
+  --> $DIR/while_let_on_iterator.rs:101:9
    |
 LL |         while let Some([..]) = it.next() {}
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for [..] in it`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:107:9
+  --> $DIR/while_let_on_iterator.rs:108:9
    |
 LL |         while let Some([_x]) = it.next() {}
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for [_x] in it`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:120:9
+  --> $DIR/while_let_on_iterator.rs:121:9
    |
 LL |         while let Some(x @ [_]) = it.next() {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for x @ [_] in it`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:140:9
+  --> $DIR/while_let_on_iterator.rs:141:9
    |
 LL |         while let Some(_) = y.next() {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for _ in y`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:197:9
+  --> $DIR/while_let_on_iterator.rs:198:9
    |
 LL |         while let Some(m) = it.next() {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for m in it.by_ref()`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:208:5
+  --> $DIR/while_let_on_iterator.rs:209:5
    |
 LL |     while let Some(n) = it.next() {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for n in it`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:210:9
+  --> $DIR/while_let_on_iterator.rs:211:9
    |
 LL |         while let Some(m) = it.next() {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for m in it`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:219:9
+  --> $DIR/while_let_on_iterator.rs:220:9
    |
 LL |         while let Some(m) = it.next() {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for m in it`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:228:9
+  --> $DIR/while_let_on_iterator.rs:229:9
    |
 LL |         while let Some(m) = it.next() {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for m in it.by_ref()`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:245:9
+  --> $DIR/while_let_on_iterator.rs:246:9
    |
 LL |         while let Some(m) = it.next() {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for m in it.by_ref()`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:260:13
+  --> $DIR/while_let_on_iterator.rs:261:13
    |
 LL |             while let Some(i) = self.0.next() {
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for i in self.0.by_ref()`
 
 error: manual `!RangeInclusive::contains` implementation
-  --> $DIR/while_let_on_iterator.rs:261:20
+  --> $DIR/while_let_on_iterator.rs:262:20
    |
 LL |                 if i < 3 || i > 7 {
    |                    ^^^^^^^^^^^^^^ help: use: `!(3..=7).contains(&i)`
@@ -93,49 +93,49 @@ LL |                 if i < 3 || i > 7 {
    = note: `-D clippy::manual-range-contains` implied by `-D warnings`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:292:13
+  --> $DIR/while_let_on_iterator.rs:293:13
    |
 LL |             while let Some(i) = self.0.0.0.next() {
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for i in self.0.0.0.by_ref()`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:321:5
+  --> $DIR/while_let_on_iterator.rs:322:5
    |
 LL |     while let Some(n) = it.next() {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for n in it.by_ref()`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:333:9
+  --> $DIR/while_let_on_iterator.rs:334:9
    |
 LL |         while let Some(x) = it.next() {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for x in it.by_ref()`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:347:5
+  --> $DIR/while_let_on_iterator.rs:348:5
    |
 LL |     while let Some(x) = it.next() {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for x in it.by_ref()`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:358:5
+  --> $DIR/while_let_on_iterator.rs:359:5
    |
 LL |     while let Some(x) = it.0.next() {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for x in it.0.by_ref()`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:393:5
+  --> $DIR/while_let_on_iterator.rs:394:5
    |
 LL |     while let Some(x) = s.x.next() {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for x in s.x.by_ref()`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:400:5
+  --> $DIR/while_let_on_iterator.rs:401:5
    |
 LL |     while let Some(x) = x[0].next() {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for x in x[0].by_ref()`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:407:5
+  --> $DIR/while_let_on_iterator.rs:408:5
    |
 LL |     while let Some(..) = it.next() {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for _ in it`
-- 
cgit 1.4.1-3-g733a5


From b4c3f0f79b686035b94b8ca3535ff9274f7ef4d6 Mon Sep 17 00:00:00 2001
From: tamaron <tamaron1203@gmail.com>
Date: Wed, 18 May 2022 00:37:12 +0900
Subject: fix

---
 clippy_lints/src/dbg_macro.rs |  4 ++--
 clippy_utils/src/lib.rs       | 20 ++++++++++++++++++++
 tests/ui/dbg_macro.rs         | 12 ++++++++++++
 3 files changed, 34 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/dbg_macro.rs b/clippy_lints/src/dbg_macro.rs
index a0e5d302633..f99d793c201 100644
--- a/clippy_lints/src/dbg_macro.rs
+++ b/clippy_lints/src/dbg_macro.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::is_in_test_function;
 use clippy_utils::macros::root_macro_call_first_node;
 use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::{is_in_cfg_test, is_in_test_function};
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
@@ -37,7 +37,7 @@ impl LateLintPass<'_> for DbgMacro {
         let Some(macro_call) = root_macro_call_first_node(cx, expr) else { return };
         if cx.tcx.is_diagnostic_item(sym::dbg_macro, macro_call.def_id) {
             // we make an exception for test code
-            if is_in_test_function(cx.tcx, expr.hir_id) {
+            if is_in_test_function(cx.tcx, expr.hir_id) || is_in_cfg_test(cx.tcx, expr.hir_id) {
                 return;
             }
             let mut applicability = Applicability::MachineApplicable;
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 25596168d11..b3ecc4255a9 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -2146,6 +2146,26 @@ pub fn is_in_test_function(tcx: TyCtxt<'_>, id: hir::HirId) -> bool {
     })
 }
 
+/// Checks if the item containing the given `HirId` has `#[cfg(test)]` attribute applied
+///
+/// Note: Add `// compile-flags: --test` to UI tests with a `#[cfg(test)]` function
+pub fn is_in_cfg_test(tcx: TyCtxt<'_>, id: hir::HirId) -> bool {
+    fn is_cfg_test(attr: &Attribute) -> bool {
+        if attr.has_name(sym::cfg)
+            && let Some(items) = attr.meta_item_list()
+            && items.len() == 1
+            && items[0].has_name(sym::test)
+        {
+            true
+        } else {
+            false
+        }
+    }
+    tcx.hir()
+        .parent_iter(id)
+        .any(|(parent_id, _)| tcx.hir().attrs(parent_id).iter().any(is_cfg_test))
+}
+
 /// Checks whether item either has `test` attribute applied, or
 /// is a module with `test` in its name.
 ///
diff --git a/tests/ui/dbg_macro.rs b/tests/ui/dbg_macro.rs
index baf01174b67..25294e8c766 100644
--- a/tests/ui/dbg_macro.rs
+++ b/tests/ui/dbg_macro.rs
@@ -46,3 +46,15 @@ mod issue7274 {
 pub fn issue8481() {
     dbg!(1);
 }
+
+#[cfg(test)]
+fn foo2() {
+    dbg!(1);
+}
+
+#[cfg(test)]
+mod mod1 {
+    fn func() {
+        dbg!(1);
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 564725775bd200de131b96f4d93a36bd64508e72 Mon Sep 17 00:00:00 2001
From: "Samuel E. Moelius III" <sam@moeli.us>
Date: Thu, 12 May 2022 12:31:17 -0400
Subject: Improve "unknown field" error messages

---
 Cargo.toml                                         |   1 +
 clippy_lints/src/lib.rs                            |   4 +-
 clippy_lints/src/utils/conf.rs                     | 129 +++++++++++++++++++--
 src/main.rs                                        |   4 +
 .../toml_unknown_key/conf_unknown_key.stderr       |  41 ++++++-
 5 files changed, 169 insertions(+), 10 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/Cargo.toml b/Cargo.toml
index dd6518d5241..03e6bf03afe 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -25,6 +25,7 @@ clippy_lints = { path = "clippy_lints" }
 semver = "1.0"
 rustc_tools_util = { path = "rustc_tools_util" }
 tempfile = { version = "3.2", optional = true }
+termize = "0.1"
 
 [dev-dependencies]
 compiletest_rs = { version = "0.7.1", features = ["tmp"] }
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 1c502ef1d44..44c42d03e60 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -418,7 +418,7 @@ mod zero_sized_map_values;
 // end lints modules, do not remove this comment, it’s used in `update_lints`
 
 pub use crate::utils::conf::Conf;
-use crate::utils::conf::TryConf;
+use crate::utils::conf::{format_error, TryConf};
 
 /// Register all pre expansion lints
 ///
@@ -463,7 +463,7 @@ pub fn read_conf(sess: &Session) -> Conf {
         sess.struct_err(&format!(
             "error reading Clippy's configuration file `{}`: {}",
             file_name.display(),
-            error
+            format_error(error)
         ))
         .emit();
     }
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index bdcd76d153f..cd4d16fe95f 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -6,7 +6,8 @@ use serde::de::{Deserializer, IgnoredAny, IntoDeserializer, MapAccess, Visitor};
 use serde::Deserialize;
 use std::error::Error;
 use std::path::{Path, PathBuf};
-use std::{env, fmt, fs, io};
+use std::str::FromStr;
+use std::{cmp, env, fmt, fs, io, iter};
 
 /// Holds information used by `MISSING_ENFORCED_IMPORT_RENAMES` lint.
 #[derive(Clone, Debug, Deserialize)]
@@ -43,18 +44,33 @@ pub enum DisallowedType {
 #[derive(Default)]
 pub struct TryConf {
     pub conf: Conf,
-    pub errors: Vec<String>,
+    pub errors: Vec<Box<dyn Error>>,
 }
 
 impl TryConf {
-    fn from_error(error: impl Error) -> Self {
+    fn from_error(error: impl Error + 'static) -> Self {
         Self {
             conf: Conf::default(),
-            errors: vec![error.to_string()],
+            errors: vec![Box::new(error)],
         }
     }
 }
 
+#[derive(Debug)]
+struct ConfError(String);
+
+impl fmt::Display for ConfError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        <String as fmt::Display>::fmt(&self.0, f)
+    }
+}
+
+impl Error for ConfError {}
+
+fn conf_error(s: String) -> Box<dyn Error> {
+    Box::new(ConfError(s))
+}
+
 macro_rules! define_Conf {
     ($(
         $(#[doc = $doc:literal])+
@@ -103,11 +119,11 @@ macro_rules! define_Conf {
                 while let Some(name) = map.next_key::<&str>()? {
                     match Field::deserialize(name.into_deserializer())? {
                         $(Field::$name => {
-                            $(errors.push(format!("deprecated field `{}`. {}", name, $dep));)?
+                            $(errors.push(conf_error(format!("deprecated field `{}`. {}", name, $dep)));)?
                             match map.next_value() {
-                                Err(e) => errors.push(e.to_string()),
+                                Err(e) => errors.push(conf_error(e.to_string())),
                                 Ok(value) => match $name {
-                                    Some(_) => errors.push(format!("duplicate field `{}`", name)),
+                                    Some(_) => errors.push(conf_error(format!("duplicate field `{}`", name))),
                                     None => $name = Some(value),
                                 }
                             }
@@ -383,3 +399,102 @@ pub fn read(path: &Path) -> TryConf {
     };
     toml::from_str(&content).unwrap_or_else(TryConf::from_error)
 }
+
+const SEPARATOR_WIDTH: usize = 4;
+
+// Check whether the error is "unknown field" and, if so, list the available fields sorted and at
+// least one per line, more if `CLIPPY_TERMINAL_WIDTH` is set and allows it.
+pub fn format_error(error: Box<dyn Error>) -> String {
+    let s = error.to_string();
+
+    if_chain! {
+        if error.downcast::<toml::de::Error>().is_ok();
+        if let Some((prefix, mut fields, suffix)) = parse_unknown_field_message(&s);
+        then {
+            use fmt::Write;
+
+            fields.sort_unstable();
+
+            let (rows, column_widths) = calculate_dimensions(&fields);
+
+            let mut msg = String::from(prefix);
+            for row in 0..rows {
+                write!(msg, "\n").unwrap();
+                for (column, column_width) in column_widths.iter().copied().enumerate() {
+                    let index = column * rows + row;
+                    let field = fields.get(index).copied().unwrap_or_default();
+                    write!(
+                        msg,
+                        "{:separator_width$}{:field_width$}",
+                        " ",
+                        field,
+                        separator_width = SEPARATOR_WIDTH,
+                        field_width = column_width
+                    )
+                    .unwrap();
+                }
+            }
+            write!(msg, "\n{}", suffix).unwrap();
+            msg
+        } else {
+            s
+        }
+    }
+}
+
+// `parse_unknown_field_message` will become unnecessary if
+// https://github.com/alexcrichton/toml-rs/pull/364 is merged.
+fn parse_unknown_field_message(s: &str) -> Option<(&str, Vec<&str>, &str)> {
+    // An "unknown field" message has the following form:
+    //   unknown field `UNKNOWN`, expected one of `FIELD0`, `FIELD1`, ..., `FIELDN` at line X column Y
+    //                                           ^^      ^^^^                     ^^
+    if_chain! {
+        if s.starts_with("unknown field");
+        let slices = s.split("`, `").collect::<Vec<_>>();
+        let n = slices.len();
+        if n >= 2;
+        if let Some((prefix, first_field)) = slices[0].rsplit_once(" `");
+        if let Some((last_field, suffix)) = slices[n - 1].split_once("` ");
+        then {
+            let fields = iter::once(first_field)
+                .chain(slices[1..n - 1].iter().copied())
+                .chain(iter::once(last_field))
+                .collect::<Vec<_>>();
+            Some((prefix, fields, suffix))
+        } else {
+            None
+        }
+    }
+}
+
+fn calculate_dimensions(fields: &[&str]) -> (usize, Vec<usize>) {
+    let columns = env::var("CLIPPY_TERMINAL_WIDTH")
+        .ok()
+        .and_then(|s| <usize as FromStr>::from_str(&s).ok())
+        .map_or(1, |terminal_width| {
+            let max_field_width = fields.iter().map(|field| field.len()).max().unwrap();
+            cmp::max(1, terminal_width / (SEPARATOR_WIDTH + max_field_width))
+        });
+
+    let rows = (fields.len() + (columns - 1)) / columns;
+
+    let column_widths = (0..columns)
+        .map(|column| {
+            if column < columns - 1 {
+                (0..rows)
+                    .map(|row| {
+                        let index = column * rows + row;
+                        let field = fields.get(index).copied().unwrap_or_default();
+                        field.len()
+                    })
+                    .max()
+                    .unwrap()
+            } else {
+                // Avoid adding extra space to the last column.
+                0
+            }
+        })
+        .collect::<Vec<_>>();
+
+    (rows, column_widths)
+}
diff --git a/src/main.rs b/src/main.rs
index 240e233420f..9ee4a40cbf2 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -123,8 +123,12 @@ impl ClippyCmd {
             .map(|arg| format!("{}__CLIPPY_HACKERY__", arg))
             .collect();
 
+        // Currently, `CLIPPY_TERMINAL_WIDTH` is used only to format "unknown field" error messages.
+        let terminal_width = termize::dimensions().map_or(0, |(w, _)| w);
+
         cmd.env("RUSTC_WORKSPACE_WRAPPER", Self::path())
             .env("CLIPPY_ARGS", clippy_args)
+            .env("CLIPPY_TERMINAL_WIDTH", terminal_width.to_string())
             .arg(self.cargo_subcommand)
             .args(&self.args);
 
diff --git a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
index 65277dd03e8..92838aa57df 100644
--- a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
+++ b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
@@ -1,4 +1,43 @@
-error: error reading Clippy's configuration file `$DIR/clippy.toml`: unknown field `foobar`, expected one of `avoid-breaking-exported-api`, `msrv`, `blacklisted-names`, `cognitive-complexity-threshold`, `cyclomatic-complexity-threshold`, `doc-valid-idents`, `too-many-arguments-threshold`, `type-complexity-threshold`, `single-char-binding-names-threshold`, `too-large-for-stack`, `enum-variant-name-threshold`, `enum-variant-size-threshold`, `verbose-bit-mask-threshold`, `literal-representation-threshold`, `trivial-copy-size-limit`, `pass-by-value-size-limit`, `too-many-lines-threshold`, `array-size-threshold`, `vec-box-size-threshold`, `max-trait-bounds`, `max-struct-bools`, `max-fn-params-bools`, `warn-on-all-wildcard-imports`, `disallowed-methods`, `disallowed-types`, `unreadable-literal-lint-fractions`, `upper-case-acronyms-aggressive`, `cargo-ignore-publish`, `standard-macro-braces`, `enforced-import-renames`, `allowed-scripts`, `enable-raw-pointer-heuristic-for-send`, `max-suggested-slice-pattern-length`, `await-holding-invalid-types`, `max-include-file-size`, `allow-expect-in-tests`, `allow-unwrap-in-tests`, `third-party` at line 5 column 1
+error: error reading Clippy's configuration file `$DIR/clippy.toml`: unknown field `foobar`, expected one of
+           allow-expect-in-tests
+           allow-unwrap-in-tests
+           allowed-scripts
+           array-size-threshold
+           avoid-breaking-exported-api
+           await-holding-invalid-types
+           blacklisted-names
+           cargo-ignore-publish
+           cognitive-complexity-threshold
+           cyclomatic-complexity-threshold
+           disallowed-methods
+           disallowed-types
+           doc-valid-idents
+           enable-raw-pointer-heuristic-for-send
+           enforced-import-renames
+           enum-variant-name-threshold
+           enum-variant-size-threshold
+           literal-representation-threshold
+           max-fn-params-bools
+           max-include-file-size
+           max-struct-bools
+           max-suggested-slice-pattern-length
+           max-trait-bounds
+           msrv
+           pass-by-value-size-limit
+           single-char-binding-names-threshold
+           standard-macro-braces
+           third-party
+           too-large-for-stack
+           too-many-arguments-threshold
+           too-many-lines-threshold
+           trivial-copy-size-limit
+           type-complexity-threshold
+           unreadable-literal-lint-fractions
+           upper-case-acronyms-aggressive
+           vec-box-size-threshold
+           verbose-bit-mask-threshold
+           warn-on-all-wildcard-imports
+       at line 5 column 1
 
 error: aborting due to previous error
 
-- 
cgit 1.4.1-3-g733a5


From 944e1bbca32429965b374fc053c32e582060117a Mon Sep 17 00:00:00 2001
From: Serial <69764315+Serial-ATA@users.noreply.github.com>
Date: Thu, 19 May 2022 10:10:55 -0400
Subject: Remove code block from `pub_enum_variant_names`

---
 clippy_lints/src/deprecated_lints.rs | 1 -
 1 file changed, 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/deprecated_lints.rs b/clippy_lints/src/deprecated_lints.rs
index bba27576c89..5d5ea0f49c8 100644
--- a/clippy_lints/src/deprecated_lints.rs
+++ b/clippy_lints/src/deprecated_lints.rs
@@ -194,7 +194,6 @@ declare_deprecated_lint! {
     /// ### Deprecation reason
     /// The `avoid_breaking_exported_api` config option was added, which
     /// enables the `enum_variant_names` lint for public items.
-    /// ```
     #[clippy::version = "1.54.0"]
     pub PUB_ENUM_VARIANT_NAMES,
     "set the `avoid-breaking-exported-api` config option to `false` to enable the `enum_variant_names` lint for public items"
-- 
cgit 1.4.1-3-g733a5


From 5730fd49fa0379141ca78c59f5514c206ed8e53f Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Fri, 20 May 2022 12:39:15 +0000
Subject: Lint indirect usages in `disallowed_methods`

---
 clippy_lints/src/disallowed_methods.rs               | 14 +++++++++++---
 .../conf_disallowed_methods.rs                       |  6 ++++++
 .../conf_disallowed_methods.stderr                   | 20 +++++++++++++++++++-
 3 files changed, 36 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/disallowed_methods.rs b/clippy_lints/src/disallowed_methods.rs
index 4c12202c84a..53973ab792a 100644
--- a/clippy_lints/src/disallowed_methods.rs
+++ b/clippy_lints/src/disallowed_methods.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::fn_def_id;
+use clippy_utils::{fn_def_id, get_parent_expr, path_def_id};
 
-use rustc_hir::{def::Res, def_id::DefIdMap, Expr};
+use rustc_hir::{def::Res, def_id::DefIdMap, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 
@@ -84,7 +84,15 @@ impl<'tcx> LateLintPass<'tcx> for DisallowedMethods {
     }
 
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        let def_id = match fn_def_id(cx, expr) {
+        let uncalled_path = if let Some(parent) = get_parent_expr(cx, expr)
+            && let ExprKind::Call(receiver, _) = parent.kind
+            && receiver.hir_id == expr.hir_id
+        {
+            None
+        } else {
+            path_def_id(cx, expr)
+        };
+        let def_id = match uncalled_path.or_else(|| fn_def_id(cx, expr)) {
             Some(def_id) => def_id,
             None => return,
         };
diff --git a/tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.rs b/tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.rs
index 338b3b5b28f..3397fa1ec69 100644
--- a/tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.rs
+++ b/tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.rs
@@ -14,4 +14,10 @@ fn main() {
 
     let _ = 2.0f32.clamp(3.0f32, 4.0f32);
     let _ = 2.0f64.clamp(3.0f64, 4.0f64);
+
+    let indirect: fn(&str) -> Result<Regex, regex::Error> = Regex::new;
+    let re = indirect(".").unwrap();
+
+    let in_call = Box::new(f32::clamp);
+    let in_method_call = ["^", "$"].into_iter().map(Regex::new);
 }
diff --git a/tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.stderr b/tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.stderr
index 5533676aea2..5cbb567546c 100644
--- a/tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.stderr
+++ b/tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.stderr
@@ -32,5 +32,23 @@ error: use of a disallowed method `f32::clamp`
 LL |     let _ = 2.0f32.clamp(3.0f32, 4.0f32);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 5 previous errors
+error: use of a disallowed method `regex::Regex::new`
+  --> $DIR/conf_disallowed_methods.rs:18:61
+   |
+LL |     let indirect: fn(&str) -> Result<Regex, regex::Error> = Regex::new;
+   |                                                             ^^^^^^^^^^
+
+error: use of a disallowed method `f32::clamp`
+  --> $DIR/conf_disallowed_methods.rs:21:28
+   |
+LL |     let in_call = Box::new(f32::clamp);
+   |                            ^^^^^^^^^^
+
+error: use of a disallowed method `regex::Regex::new`
+  --> $DIR/conf_disallowed_methods.rs:22:53
+   |
+LL |     let in_method_call = ["^", "$"].into_iter().map(Regex::new);
+   |                                                     ^^^^^^^^^^
+
+error: aborting due to 8 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 5b72632c98a6e45dfe2c1aaddad1b05f5259a914 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Fri, 20 May 2022 21:03:24 +0200
Subject: move  to sus and fix dogfood

---
 clippy_lints/src/lib.register_all.rs              |  1 +
 clippy_lints/src/lib.register_nursery.rs          |  1 -
 clippy_lints/src/lib.register_suspicious.rs       |  1 +
 clippy_lints/src/significant_drop_in_scrutinee.rs | 26 +++++++++++------------
 4 files changed, 14 insertions(+), 15 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 48ceeb43ee7..be5c478900f 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -278,6 +278,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(self_assignment::SELF_ASSIGNMENT),
     LintId::of(self_named_constructors::SELF_NAMED_CONSTRUCTORS),
     LintId::of(serde_api::SERDE_API_MISUSE),
+    LintId::of(significant_drop_in_scrutinee::SIGNIFICANT_DROP_IN_SCRUTINEE),
     LintId::of(single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS),
     LintId::of(size_of_in_element_count::SIZE_OF_IN_ELEMENT_COUNT),
     LintId::of(slow_vector_initialization::SLOW_VECTOR_INITIALIZATION),
diff --git a/clippy_lints/src/lib.register_nursery.rs b/clippy_lints/src/lib.register_nursery.rs
index d43c7e03533..ec187563b3f 100644
--- a/clippy_lints/src/lib.register_nursery.rs
+++ b/clippy_lints/src/lib.register_nursery.rs
@@ -25,7 +25,6 @@ store.register_group(true, "clippy::nursery", Some("clippy_nursery"), vec![
     LintId::of(path_buf_push_overwrite::PATH_BUF_PUSH_OVERWRITE),
     LintId::of(redundant_pub_crate::REDUNDANT_PUB_CRATE),
     LintId::of(regex::TRIVIAL_REGEX),
-    LintId::of(significant_drop_in_scrutinee::SIGNIFICANT_DROP_IN_SCRUTINEE),
     LintId::of(strings::STRING_LIT_AS_BYTES),
     LintId::of(suspicious_operation_groupings::SUSPICIOUS_OPERATION_GROUPINGS),
     LintId::of(trailing_empty_array::TRAILING_EMPTY_ARRAY),
diff --git a/clippy_lints/src/lib.register_suspicious.rs b/clippy_lints/src/lib.register_suspicious.rs
index 338a6a28bc9..2de49f1624a 100644
--- a/clippy_lints/src/lib.register_suspicious.rs
+++ b/clippy_lints/src/lib.register_suspicious.rs
@@ -27,6 +27,7 @@ store.register_group(true, "clippy::suspicious", Some("clippy_suspicious"), vec!
     LintId::of(mut_key::MUTABLE_KEY_TYPE),
     LintId::of(octal_escapes::OCTAL_ESCAPES),
     LintId::of(rc_clone_in_vec_init::RC_CLONE_IN_VEC_INIT),
+    LintId::of(significant_drop_in_scrutinee::SIGNIFICANT_DROP_IN_SCRUTINEE),
     LintId::of(suspicious_trait_impl::SUSPICIOUS_ARITHMETIC_IMPL),
     LintId::of(suspicious_trait_impl::SUSPICIOUS_OP_ASSIGN_IMPL),
 ])
diff --git a/clippy_lints/src/significant_drop_in_scrutinee.rs b/clippy_lints/src/significant_drop_in_scrutinee.rs
index f300acf0fb2..4cebfd7a93f 100644
--- a/clippy_lints/src/significant_drop_in_scrutinee.rs
+++ b/clippy_lints/src/significant_drop_in_scrutinee.rs
@@ -83,7 +83,7 @@ declare_clippy_lint! {
     /// ```
     #[clippy::version = "1.60.0"]
     pub SIGNIFICANT_DROP_IN_SCRUTINEE,
-    nursery,
+    suspicious,
     "warns when a temporary of a type with a drop with a significant side-effect might have a surprising lifetime"
 }
 
@@ -99,7 +99,7 @@ impl<'tcx> LateLintPass<'tcx> for SignificantDropInScrutinee {
                     found.found_span,
                     "temporary with significant drop in match scrutinee",
                     |diag| set_diagnostic(diag, cx, expr, found),
-                )
+                );
             }
         }
     }
@@ -148,8 +148,8 @@ fn set_diagnostic<'tcx>(diag: &mut Diagnostic, cx: &LateContext<'tcx>, expr: &'t
     );
 }
 
-/// If the expression is an ExprKind::Match, check if the scrutinee has a significant drop that may
-/// have a surprising lifetime.
+/// If the expression is an `ExprKind::Match`, check if the scrutinee has a significant drop that
+/// may have a surprising lifetime.
 fn has_significant_drop_in_scrutinee<'tcx, 'a>(
     cx: &'a LateContext<'tcx>,
     expr: &'tcx Expr<'tcx>,
@@ -171,6 +171,7 @@ struct SigDropHelper<'a, 'tcx> {
     special_handling_for_binary_op: bool,
 }
 
+#[expect(clippy::enum_variant_names)]
 #[derive(Debug, PartialEq, Eq, Clone, Copy)]
 enum LintSuggestion {
     MoveOnly,
@@ -213,7 +214,7 @@ impl<'a, 'tcx> SigDropHelper<'a, 'tcx> {
     }
 
     /// This will try to set the current suggestion (so it can be moved into the suggestions vec
-    /// later). If allow_move_and_clone is false, the suggestion *won't* be set -- this gives us
+    /// later). If `allow_move_and_clone` is false, the suggestion *won't* be set -- this gives us
     /// an opportunity to look for another type in the chain that will be trivially copyable.
     /// However, if we are at the the end of the chain, we want to accept whatever is there. (The
     /// suggestion won't actually be output, but the diagnostic message will be output, so the user
@@ -313,10 +314,10 @@ impl<'a, 'tcx> SigDropHelper<'a, 'tcx> {
                 }
                 false
             },
-            rustc_middle::ty::Array(ty, _) => self.has_sig_drop_attr(cx, *ty),
-            rustc_middle::ty::RawPtr(TypeAndMut { ty, .. }) => self.has_sig_drop_attr(cx, *ty),
-            rustc_middle::ty::Ref(_, ty, _) => self.has_sig_drop_attr(cx, *ty),
-            rustc_middle::ty::Slice(ty) => self.has_sig_drop_attr(cx, *ty),
+            rustc_middle::ty::Array(ty, _)
+            | rustc_middle::ty::RawPtr(TypeAndMut { ty, .. })
+            | rustc_middle::ty::Ref(_, ty, _)
+            | rustc_middle::ty::Slice(ty) => self.has_sig_drop_attr(cx, *ty),
             _ => false,
         }
     }
@@ -332,15 +333,12 @@ impl<'a, 'tcx> Visitor<'tcx> for SigDropHelper<'a, 'tcx> {
 
         match ex.kind {
             ExprKind::MethodCall(_, [ref expr, ..], _) => {
-                self.visit_expr(expr)
+                self.visit_expr(expr);
             }
             ExprKind::Binary(_, left, right) => {
                 self.visit_exprs_for_binary_ops(left, right, false, ex.span);
             }
-            ExprKind::Assign(left, right, _) => {
-                self.visit_exprs_for_binary_ops(left, right, true, ex.span);
-            }
-            ExprKind::AssignOp(_, left, right) => {
+            ExprKind::Assign(left, right, _) | ExprKind::AssignOp(_, left, right) => {
                 self.visit_exprs_for_binary_ops(left, right, true, ex.span);
             }
             ExprKind::Tup(exprs) => {
-- 
cgit 1.4.1-3-g733a5


From 7842dbc4f5af4818c89d830607383bfe349cd7e7 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Fri, 20 May 2022 23:32:09 +0200
Subject: Remove duplicated code and ignore deadlock test

---
 clippy_dev/src/main.rs                            | 21 ---------------------
 clippy_lints/src/significant_drop_in_scrutinee.rs |  2 +-
 2 files changed, 1 insertion(+), 22 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_dev/src/main.rs b/clippy_dev/src/main.rs
index 8dd2b7f9534..d5cd7ca96c0 100644
--- a/clippy_dev/src/main.rs
+++ b/clippy_dev/src/main.rs
@@ -319,26 +319,5 @@ fn get_clap_config<'a>() -> ArgMatches<'a> {
                         .help("This lint will be uplifted into rustc"),
                 ),
         )
-        .subcommand(
-            SubCommand::with_name("rename_lint")
-                .about("Renames the given lint")
-                .arg(
-                    Arg::with_name("old_name")
-                        .index(1)
-                        .required(true)
-                        .help("The name of the lint to rename"),
-                )
-                .arg(
-                    Arg::with_name("new_name")
-                        .index(2)
-                        .required_unless("uplift")
-                        .help("The new name of the lint"),
-                )
-                .arg(
-                    Arg::with_name("uplift")
-                        .long("uplift")
-                        .help("This lint will be uplifted into rustc"),
-                ),
-        )
         .get_matches()
 }
diff --git a/clippy_lints/src/significant_drop_in_scrutinee.rs b/clippy_lints/src/significant_drop_in_scrutinee.rs
index 4cebfd7a93f..424b361a905 100644
--- a/clippy_lints/src/significant_drop_in_scrutinee.rs
+++ b/clippy_lints/src/significant_drop_in_scrutinee.rs
@@ -29,7 +29,7 @@ declare_clippy_lint! {
     /// the match block and thus will not unlock.
     ///
     /// ### Example
-    /// ```rust
+    /// ```rust.ignore
     /// # use std::sync::Mutex;
     ///
     /// # struct State {}
-- 
cgit 1.4.1-3-g733a5


From 855849034c15330f146376ae7073c38cbacb00b2 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Fri, 20 May 2022 20:33:31 +0000
Subject: get_last_with_len: lint VecDeque and any deref to slice

previously only vecs were supported
---
 clippy_lints/src/get_last_with_len.rs         | 107 --------------------------
 clippy_lints/src/lib.register_all.rs          |   2 +-
 clippy_lints/src/lib.register_complexity.rs   |   2 +-
 clippy_lints/src/lib.register_lints.rs        |   2 +-
 clippy_lints/src/lib.rs                       |   2 -
 clippy_lints/src/methods/get_last_with_len.rs |  55 +++++++++++++
 clippy_lints/src/methods/mod.rs               |  35 +++++++++
 tests/ui/get_last_with_len.fixed              |  28 +++++--
 tests/ui/get_last_with_len.rs                 |  28 +++++--
 tests/ui/get_last_with_len.stderr             |  36 ++++++++-
 10 files changed, 172 insertions(+), 125 deletions(-)
 delete mode 100644 clippy_lints/src/get_last_with_len.rs
 create mode 100644 clippy_lints/src/methods/get_last_with_len.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/get_last_with_len.rs b/clippy_lints/src/get_last_with_len.rs
deleted file mode 100644
index df29d9308e7..00000000000
--- a/clippy_lints/src/get_last_with_len.rs
+++ /dev/null
@@ -1,107 +0,0 @@
-//! lint on using `x.get(x.len() - 1)` instead of `x.last()`
-
-use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::SpanlessEq;
-use if_chain::if_chain;
-use rustc_ast::ast::LitKind;
-use rustc_errors::Applicability;
-use rustc_hir::{BinOpKind, Expr, ExprKind};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::source_map::Spanned;
-use rustc_span::sym;
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for using `x.get(x.len() - 1)` instead of
-    /// `x.last()`.
-    ///
-    /// ### Why is this bad?
-    /// Using `x.last()` is easier to read and has the same
-    /// result.
-    ///
-    /// Note that using `x[x.len() - 1]` is semantically different from
-    /// `x.last()`.  Indexing into the array will panic on out-of-bounds
-    /// accesses, while `x.get()` and `x.last()` will return `None`.
-    ///
-    /// There is another lint (get_unwrap) that covers the case of using
-    /// `x.get(index).unwrap()` instead of `x[index]`.
-    ///
-    /// ### Example
-    /// ```rust
-    /// // Bad
-    /// let x = vec![2, 3, 5];
-    /// let last_element = x.get(x.len() - 1);
-    ///
-    /// // Good
-    /// let x = vec![2, 3, 5];
-    /// let last_element = x.last();
-    /// ```
-    #[clippy::version = "1.37.0"]
-    pub GET_LAST_WITH_LEN,
-    complexity,
-    "Using `x.get(x.len() - 1)` when `x.last()` is correct and simpler"
-}
-
-declare_lint_pass!(GetLastWithLen => [GET_LAST_WITH_LEN]);
-
-impl<'tcx> LateLintPass<'tcx> for GetLastWithLen {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if_chain! {
-            // Is a method call
-            if let ExprKind::MethodCall(path, args, _) = expr.kind;
-
-            // Method name is "get"
-            if path.ident.name == sym!(get);
-
-            // Argument 0 (the struct we're calling the method on) is a vector
-            if let Some(struct_calling_on) = args.get(0);
-            let struct_ty = cx.typeck_results().expr_ty(struct_calling_on);
-            if is_type_diagnostic_item(cx, struct_ty, sym::Vec);
-
-            // Argument to "get" is a subtraction
-            if let Some(get_index_arg) = args.get(1);
-            if let ExprKind::Binary(
-                Spanned {
-                    node: BinOpKind::Sub,
-                    ..
-                },
-                lhs,
-                rhs,
-            ) = &get_index_arg.kind;
-
-            // LHS of subtraction is "x.len()"
-            if let ExprKind::MethodCall(arg_lhs_path, lhs_args, _) = &lhs.kind;
-            if arg_lhs_path.ident.name == sym::len;
-            if let Some(arg_lhs_struct) = lhs_args.get(0);
-
-            // The two vectors referenced (x in x.get(...) and in x.len())
-            if SpanlessEq::new(cx).eq_expr(struct_calling_on, arg_lhs_struct);
-
-            // RHS of subtraction is 1
-            if let ExprKind::Lit(rhs_lit) = &rhs.kind;
-            if let LitKind::Int(1, ..) = rhs_lit.node;
-
-            then {
-                let mut applicability = Applicability::MachineApplicable;
-                let vec_name = snippet_with_applicability(
-                    cx,
-                    struct_calling_on.span, "vec",
-                    &mut applicability,
-                );
-
-                span_lint_and_sugg(
-                    cx,
-                    GET_LAST_WITH_LEN,
-                    expr.span,
-                    &format!("accessing last element with `{0}.get({0}.len() - 1)`", vec_name),
-                    "try",
-                    format!("{}.last()", vec_name),
-                    applicability,
-                );
-            }
-        }
-    }
-}
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index be5c478900f..87279de05c0 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -91,7 +91,6 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(functions::NOT_UNSAFE_PTR_ARG_DEREF),
     LintId::of(functions::RESULT_UNIT_ERR),
     LintId::of(functions::TOO_MANY_ARGUMENTS),
-    LintId::of(get_last_with_len::GET_LAST_WITH_LEN),
     LintId::of(identity_op::IDENTITY_OP),
     LintId::of(if_let_mutex::IF_LET_MUTEX),
     LintId::of(indexing_slicing::OUT_OF_BOUNDS_INDEXING),
@@ -166,6 +165,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(methods::FILTER_MAP_IDENTITY),
     LintId::of(methods::FILTER_NEXT),
     LintId::of(methods::FLAT_MAP_IDENTITY),
+    LintId::of(methods::GET_LAST_WITH_LEN),
     LintId::of(methods::INSPECT_FOR_EACH),
     LintId::of(methods::INTO_ITER_ON_REF),
     LintId::of(methods::IS_DIGIT_ASCII_RADIX),
diff --git a/clippy_lints/src/lib.register_complexity.rs b/clippy_lints/src/lib.register_complexity.rs
index b15c979d0c7..d5dfcd10a66 100644
--- a/clippy_lints/src/lib.register_complexity.rs
+++ b/clippy_lints/src/lib.register_complexity.rs
@@ -15,7 +15,6 @@ store.register_group(true, "clippy::complexity", Some("clippy_complexity"), vec!
     LintId::of(explicit_write::EXPLICIT_WRITE),
     LintId::of(format::USELESS_FORMAT),
     LintId::of(functions::TOO_MANY_ARGUMENTS),
-    LintId::of(get_last_with_len::GET_LAST_WITH_LEN),
     LintId::of(identity_op::IDENTITY_OP),
     LintId::of(int_plus_one::INT_PLUS_ONE),
     LintId::of(lifetimes::EXTRA_UNUSED_LIFETIMES),
@@ -37,6 +36,7 @@ store.register_group(true, "clippy::complexity", Some("clippy_complexity"), vec!
     LintId::of(methods::FILTER_MAP_IDENTITY),
     LintId::of(methods::FILTER_NEXT),
     LintId::of(methods::FLAT_MAP_IDENTITY),
+    LintId::of(methods::GET_LAST_WITH_LEN),
     LintId::of(methods::INSPECT_FOR_EACH),
     LintId::of(methods::ITER_COUNT),
     LintId::of(methods::MANUAL_FILTER_MAP),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 5552ea8aa80..527ff3485f2 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -183,7 +183,6 @@ store.register_lints(&[
     functions::TOO_MANY_ARGUMENTS,
     functions::TOO_MANY_LINES,
     future_not_send::FUTURE_NOT_SEND,
-    get_last_with_len::GET_LAST_WITH_LEN,
     identity_op::IDENTITY_OP,
     if_let_mutex::IF_LET_MUTEX,
     if_not_else::IF_NOT_ELSE,
@@ -302,6 +301,7 @@ store.register_lints(&[
     methods::FLAT_MAP_IDENTITY,
     methods::FLAT_MAP_OPTION,
     methods::FROM_ITER_INSTEAD_OF_COLLECT,
+    methods::GET_LAST_WITH_LEN,
     methods::GET_UNWRAP,
     methods::IMPLICIT_CLONE,
     methods::INEFFICIENT_TO_STRING,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 4ac834f7240..2f8533723ef 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -242,7 +242,6 @@ mod from_over_into;
 mod from_str_radix_10;
 mod functions;
 mod future_not_send;
-mod get_last_with_len;
 mod identity_op;
 mod if_let_mutex;
 mod if_not_else;
@@ -652,7 +651,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(strings::StringLitAsBytes));
     store.register_late_pass(|| Box::new(derive::Derive));
     store.register_late_pass(|| Box::new(derivable_impls::DerivableImpls));
-    store.register_late_pass(|| Box::new(get_last_with_len::GetLastWithLen));
     store.register_late_pass(|| Box::new(drop_forget_ref::DropForgetRef));
     store.register_late_pass(|| Box::new(empty_enum::EmptyEnum));
     store.register_late_pass(|| Box::new(absurd_extreme_comparisons::AbsurdExtremeComparisons));
diff --git a/clippy_lints/src/methods/get_last_with_len.rs b/clippy_lints/src/methods/get_last_with_len.rs
new file mode 100644
index 00000000000..23368238ef5
--- /dev/null
+++ b/clippy_lints/src/methods/get_last_with_len.rs
@@ -0,0 +1,55 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::SpanlessEq;
+use rustc_ast::LitKind;
+use rustc_errors::Applicability;
+use rustc_hir::{BinOpKind, Expr, ExprKind};
+use rustc_lint::LateContext;
+use rustc_middle::ty;
+use rustc_span::source_map::Spanned;
+use rustc_span::sym;
+
+use super::GET_LAST_WITH_LEN;
+
+pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'_>, arg: &Expr<'_>) {
+    // Argument to "get" is a subtraction
+    if let ExprKind::Binary(
+        Spanned {
+            node: BinOpKind::Sub, ..
+        },
+        lhs,
+        rhs,
+    ) = arg.kind
+
+        // LHS of subtraction is "x.len()"
+        && let ExprKind::MethodCall(lhs_path, [lhs_recv], _) = &lhs.kind
+        && lhs_path.ident.name == sym::len
+
+        // RHS of subtraction is 1
+        && let ExprKind::Lit(rhs_lit) = &rhs.kind
+        && let LitKind::Int(1, ..) = rhs_lit.node
+
+        // check that recv == lhs_recv `recv.get(lhs_recv.len() - 1)`
+        && SpanlessEq::new(cx).eq_expr(recv, lhs_recv)
+        && !recv.can_have_side_effects()
+    {
+        let method = match cx.typeck_results().expr_ty_adjusted(recv).peel_refs().kind() {
+            ty::Adt(def, _) if cx.tcx.is_diagnostic_item(sym::VecDeque, def.did()) => "back",
+            ty::Slice(_) => "last",
+            _ => return,
+        };
+
+        let mut applicability = Applicability::MachineApplicable;
+        let recv_snippet = snippet_with_applicability(cx, recv.span, "_", &mut applicability);
+
+        span_lint_and_sugg(
+            cx,
+            GET_LAST_WITH_LEN,
+            expr.span,
+            &format!("accessing last element with `{recv_snippet}.get({recv_snippet}.len() - 1)`"),
+            "try",
+            format!("{recv_snippet}.{method}()"),
+            applicability,
+        );
+    }
+}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 35fc452ed7c..8e89f43e207 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -21,6 +21,7 @@ mod filter_next;
 mod flat_map_identity;
 mod flat_map_option;
 mod from_iter_instead_of_collect;
+mod get_last_with_len;
 mod get_unwrap;
 mod implicit_clone;
 mod inefficient_to_string;
@@ -1209,6 +1210,38 @@ declare_clippy_lint! {
     "replace `.drain(..)` with `.into_iter()`"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for using `x.get(x.len() - 1)` instead of
+    /// `x.last()`.
+    ///
+    /// ### Why is this bad?
+    /// Using `x.last()` is easier to read and has the same
+    /// result.
+    ///
+    /// Note that using `x[x.len() - 1]` is semantically different from
+    /// `x.last()`.  Indexing into the array will panic on out-of-bounds
+    /// accesses, while `x.get()` and `x.last()` will return `None`.
+    ///
+    /// There is another lint (get_unwrap) that covers the case of using
+    /// `x.get(index).unwrap()` instead of `x[index]`.
+    ///
+    /// ### Example
+    /// ```rust
+    /// // Bad
+    /// let x = vec![2, 3, 5];
+    /// let last_element = x.get(x.len() - 1);
+    ///
+    /// // Good
+    /// let x = vec![2, 3, 5];
+    /// let last_element = x.last();
+    /// ```
+    #[clippy::version = "1.37.0"]
+    pub GET_LAST_WITH_LEN,
+    complexity,
+    "Using `x.get(x.len() - 1)` when `x.last()` is correct and simpler"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for use of `.get().unwrap()` (or
@@ -2264,6 +2297,7 @@ impl_lint_pass!(Methods => [
     BYTES_NTH,
     ITER_SKIP_NEXT,
     GET_UNWRAP,
+    GET_LAST_WITH_LEN,
     STRING_EXTEND_CHARS,
     ITER_CLONED_COLLECT,
     ITER_WITH_DRAIN,
@@ -2590,6 +2624,7 @@ impl Methods {
                         inspect_for_each::check(cx, expr, span2);
                     }
                 },
+                ("get", [arg]) => get_last_with_len::check(cx, expr, recv, arg),
                 ("get_or_insert_with", [arg]) => unnecessary_lazy_eval::check(cx, expr, recv, arg, "get_or_insert"),
                 ("is_file", []) => filetype_is_file::check(cx, expr, recv),
                 ("is_digit", [radix]) => is_digit_ascii_radix::check(cx, expr, recv, radix, self.msrv),
diff --git a/tests/ui/get_last_with_len.fixed b/tests/ui/get_last_with_len.fixed
index c8b363f9c38..1e90b37687a 100644
--- a/tests/ui/get_last_with_len.fixed
+++ b/tests/ui/get_last_with_len.fixed
@@ -1,10 +1,13 @@
 // run-rustfix
 
 #![warn(clippy::get_last_with_len)]
+#![allow(unused)]
+
+use std::collections::VecDeque;
 
 fn dont_use_last() {
     let x = vec![2, 3, 5];
-    let _ = x.last(); // ~ERROR Use x.last()
+    let _ = x.last();
 }
 
 fn indexing_two_from_end() {
@@ -23,9 +26,24 @@ fn use_last_with_different_vec_length() {
     let _ = x.get(y.len() - 1);
 }
 
+struct S {
+    field: Vec<usize>,
+}
+
+fn in_field(s: &S) {
+    let _ = s.field.last();
+}
+
 fn main() {
-    dont_use_last();
-    indexing_two_from_end();
-    index_into_last();
-    use_last_with_different_vec_length();
+    let slice = &[1, 2, 3];
+    let _ = slice.last();
+
+    let array = [4, 5, 6];
+    let _ = array.last();
+
+    let deq = VecDeque::from([7, 8, 9]);
+    let _ = deq.back();
+
+    let nested = [[1]];
+    let _ = nested[0].last();
 }
diff --git a/tests/ui/get_last_with_len.rs b/tests/ui/get_last_with_len.rs
index bf9cb2d7e0c..d63a731bd52 100644
--- a/tests/ui/get_last_with_len.rs
+++ b/tests/ui/get_last_with_len.rs
@@ -1,10 +1,13 @@
 // run-rustfix
 
 #![warn(clippy::get_last_with_len)]
+#![allow(unused)]
+
+use std::collections::VecDeque;
 
 fn dont_use_last() {
     let x = vec![2, 3, 5];
-    let _ = x.get(x.len() - 1); // ~ERROR Use x.last()
+    let _ = x.get(x.len() - 1);
 }
 
 fn indexing_two_from_end() {
@@ -23,9 +26,24 @@ fn use_last_with_different_vec_length() {
     let _ = x.get(y.len() - 1);
 }
 
+struct S {
+    field: Vec<usize>,
+}
+
+fn in_field(s: &S) {
+    let _ = s.field.get(s.field.len() - 1);
+}
+
 fn main() {
-    dont_use_last();
-    indexing_two_from_end();
-    index_into_last();
-    use_last_with_different_vec_length();
+    let slice = &[1, 2, 3];
+    let _ = slice.get(slice.len() - 1);
+
+    let array = [4, 5, 6];
+    let _ = array.get(array.len() - 1);
+
+    let deq = VecDeque::from([7, 8, 9]);
+    let _ = deq.get(deq.len() - 1);
+
+    let nested = [[1]];
+    let _ = nested[0].get(nested[0].len() - 1);
 }
diff --git a/tests/ui/get_last_with_len.stderr b/tests/ui/get_last_with_len.stderr
index 55baf87384a..ac8dd6c2e41 100644
--- a/tests/ui/get_last_with_len.stderr
+++ b/tests/ui/get_last_with_len.stderr
@@ -1,10 +1,40 @@
 error: accessing last element with `x.get(x.len() - 1)`
-  --> $DIR/get_last_with_len.rs:7:13
+  --> $DIR/get_last_with_len.rs:10:13
    |
-LL |     let _ = x.get(x.len() - 1); // ~ERROR Use x.last()
+LL |     let _ = x.get(x.len() - 1);
    |             ^^^^^^^^^^^^^^^^^^ help: try: `x.last()`
    |
    = note: `-D clippy::get-last-with-len` implied by `-D warnings`
 
-error: aborting due to previous error
+error: accessing last element with `s.field.get(s.field.len() - 1)`
+  --> $DIR/get_last_with_len.rs:34:13
+   |
+LL |     let _ = s.field.get(s.field.len() - 1);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `s.field.last()`
+
+error: accessing last element with `slice.get(slice.len() - 1)`
+  --> $DIR/get_last_with_len.rs:39:13
+   |
+LL |     let _ = slice.get(slice.len() - 1);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `slice.last()`
+
+error: accessing last element with `array.get(array.len() - 1)`
+  --> $DIR/get_last_with_len.rs:42:13
+   |
+LL |     let _ = array.get(array.len() - 1);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `array.last()`
+
+error: accessing last element with `deq.get(deq.len() - 1)`
+  --> $DIR/get_last_with_len.rs:45:13
+   |
+LL |     let _ = deq.get(deq.len() - 1);
+   |             ^^^^^^^^^^^^^^^^^^^^^^ help: try: `deq.back()`
+
+error: accessing last element with `nested[0].get(nested[0].len() - 1)`
+  --> $DIR/get_last_with_len.rs:48:13
+   |
+LL |     let _ = nested[0].get(nested[0].len() - 1);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `nested[0].last()`
+
+error: aborting due to 6 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 5cf07c6d29829714b929ecc32c6bbcb976cf0adb Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sun, 22 May 2022 12:19:10 -0400
Subject: Set correct `ParamEnv` for `derive_partial_eq_without_eq`

---
 clippy_lints/src/derive.rs                  | 47 +++++++++++++++++++++++------
 clippy_utils/src/ty.rs                      | 22 +++++++++++---
 tests/ui/derive_partial_eq_without_eq.fixed |  6 ++++
 tests/ui/derive_partial_eq_without_eq.rs    |  6 ++++
 4 files changed, 67 insertions(+), 14 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/derive.rs b/clippy_lints/src/derive.rs
index fe99f4a8d55..99347ebadc6 100644
--- a/clippy_lints/src/derive.rs
+++ b/clippy_lints/src/derive.rs
@@ -1,16 +1,17 @@
 use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_note, span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::paths;
-use clippy_utils::ty::{implements_trait, is_copy};
+use clippy_utils::ty::{implements_trait, implements_trait_with_env, is_copy};
 use clippy_utils::{is_lint_allowed, match_def_path};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_expr, walk_fn, walk_item, FnKind, Visitor};
 use rustc_hir::{
-    BlockCheckMode, BodyId, Expr, ExprKind, FnDecl, HirId, Impl, Item, ItemKind, TraitRef, UnsafeSource, Unsafety,
+    self as hir, BlockCheckMode, BodyId, Expr, ExprKind, FnDecl, HirId, Impl, Item, ItemKind, UnsafeSource, Unsafety,
 };
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::nested_filter;
-use rustc_middle::ty::{self, Ty};
+use rustc_middle::ty::subst::GenericArg;
+use rustc_middle::ty::{self, BoundConstness, ImplPolarity, ParamEnv, PredicateKind, TraitPredicate, TraitRef, Ty};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
 use rustc_span::sym;
@@ -224,7 +225,7 @@ impl<'tcx> LateLintPass<'tcx> for Derive {
 fn check_hash_peq<'tcx>(
     cx: &LateContext<'tcx>,
     span: Span,
-    trait_ref: &TraitRef<'_>,
+    trait_ref: &hir::TraitRef<'_>,
     ty: Ty<'tcx>,
     hash_is_automatically_derived: bool,
 ) {
@@ -277,7 +278,7 @@ fn check_hash_peq<'tcx>(
 fn check_ord_partial_ord<'tcx>(
     cx: &LateContext<'tcx>,
     span: Span,
-    trait_ref: &TraitRef<'_>,
+    trait_ref: &hir::TraitRef<'_>,
     ty: Ty<'tcx>,
     ord_is_automatically_derived: bool,
 ) {
@@ -328,7 +329,7 @@ fn check_ord_partial_ord<'tcx>(
 }
 
 /// Implementation of the `EXPL_IMPL_CLONE_ON_COPY` lint.
-fn check_copy_clone<'tcx>(cx: &LateContext<'tcx>, item: &Item<'_>, trait_ref: &TraitRef<'_>, ty: Ty<'tcx>) {
+fn check_copy_clone<'tcx>(cx: &LateContext<'tcx>, item: &Item<'_>, trait_ref: &hir::TraitRef<'_>, ty: Ty<'tcx>) {
     let clone_id = match cx.tcx.lang_items().clone_trait() {
         Some(id) if trait_ref.trait_def_id() == Some(id) => id,
         _ => return,
@@ -378,7 +379,7 @@ fn check_copy_clone<'tcx>(cx: &LateContext<'tcx>, item: &Item<'_>, trait_ref: &T
 fn check_unsafe_derive_deserialize<'tcx>(
     cx: &LateContext<'tcx>,
     item: &Item<'_>,
-    trait_ref: &TraitRef<'_>,
+    trait_ref: &hir::TraitRef<'_>,
     ty: Ty<'tcx>,
 ) {
     fn has_unsafe<'tcx>(cx: &LateContext<'tcx>, item: &'tcx Item<'_>) -> bool {
@@ -455,13 +456,41 @@ impl<'tcx> Visitor<'tcx> for UnsafeVisitor<'_, 'tcx> {
 }
 
 /// Implementation of the `DERIVE_PARTIAL_EQ_WITHOUT_EQ` lint.
-fn check_partial_eq_without_eq<'tcx>(cx: &LateContext<'tcx>, span: Span, trait_ref: &TraitRef<'_>, ty: Ty<'tcx>) {
+fn check_partial_eq_without_eq<'tcx>(cx: &LateContext<'tcx>, span: Span, trait_ref: &hir::TraitRef<'_>, ty: Ty<'tcx>) {
     if_chain! {
         if let ty::Adt(adt, substs) = ty.kind();
         if let Some(eq_trait_def_id) = cx.tcx.get_diagnostic_item(sym::Eq);
+        if let Some(peq_trait_def_id) = cx.tcx.get_diagnostic_item(sym::PartialEq);
         if let Some(def_id) = trait_ref.trait_def_id();
         if cx.tcx.is_diagnostic_item(sym::PartialEq, def_id);
-        if !implements_trait(cx, ty, eq_trait_def_id, substs);
+        // New `ParamEnv` replacing `T: PartialEq` with `T: Eq`
+        let param_env = ParamEnv::new(
+            cx.tcx.mk_predicates(cx.param_env.caller_bounds().iter().map(|p| {
+                let kind = p.kind();
+                match kind.skip_binder() {
+                    PredicateKind::Trait(p)
+                        if p.trait_ref.def_id == peq_trait_def_id
+                            && p.trait_ref.substs.get(0) == p.trait_ref.substs.get(1)
+                            && matches!(p.trait_ref.self_ty().kind(), ty::Param(_))
+                            && p.constness == BoundConstness::NotConst
+                            && p.polarity == ImplPolarity::Positive =>
+                    {
+                        cx.tcx.mk_predicate(kind.rebind(PredicateKind::Trait(TraitPredicate {
+                            trait_ref: TraitRef::new(
+                                eq_trait_def_id,
+                                cx.tcx.mk_substs([GenericArg::from(p.trait_ref.self_ty())].into_iter()),
+                            ),
+                            constness: BoundConstness::NotConst,
+                            polarity: ImplPolarity::Positive,
+                        })))
+                    },
+                    _ => p,
+                }
+            })),
+            cx.param_env.reveal(),
+            cx.param_env.constness(),
+        );
+        if !implements_trait_with_env(cx.tcx, param_env, ty, eq_trait_def_id, substs);
         then {
             // If all of our fields implement `Eq`, we can implement `Eq` too
             for variant in adt.variants() {
diff --git a/clippy_utils/src/ty.rs b/clippy_utils/src/ty.rs
index 07d3d280763..203f33d3529 100644
--- a/clippy_utils/src/ty.rs
+++ b/clippy_utils/src/ty.rs
@@ -13,7 +13,8 @@ use rustc_lint::LateContext;
 use rustc_middle::mir::interpret::{ConstValue, Scalar};
 use rustc_middle::ty::subst::{GenericArg, GenericArgKind, Subst};
 use rustc_middle::ty::{
-    self, AdtDef, Binder, FnSig, IntTy, Predicate, PredicateKind, Ty, TyCtxt, TypeFoldable, UintTy, VariantDiscr,
+    self, AdtDef, Binder, FnSig, IntTy, ParamEnv, Predicate, PredicateKind, Ty, TyCtxt, TypeFoldable, UintTy,
+    VariantDiscr,
 };
 use rustc_span::symbol::Ident;
 use rustc_span::{sym, Span, Symbol, DUMMY_SP};
@@ -151,18 +152,29 @@ pub fn implements_trait<'tcx>(
     ty: Ty<'tcx>,
     trait_id: DefId,
     ty_params: &[GenericArg<'tcx>],
+) -> bool {
+    implements_trait_with_env(cx.tcx, cx.param_env, ty, trait_id, ty_params)
+}
+
+/// Same as `implements_trait` but allows using a `ParamEnv` different from the lint context.
+pub fn implements_trait_with_env<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    param_env: ParamEnv<'tcx>,
+    ty: Ty<'tcx>,
+    trait_id: DefId,
+    ty_params: &[GenericArg<'tcx>],
 ) -> bool {
     // Clippy shouldn't have infer types
     assert!(!ty.needs_infer());
 
-    let ty = cx.tcx.erase_regions(ty);
+    let ty = tcx.erase_regions(ty);
     if ty.has_escaping_bound_vars() {
         return false;
     }
-    let ty_params = cx.tcx.mk_substs(ty_params.iter());
-    cx.tcx.infer_ctxt().enter(|infcx| {
+    let ty_params = tcx.mk_substs(ty_params.iter());
+    tcx.infer_ctxt().enter(|infcx| {
         infcx
-            .type_implements_trait(trait_id, ty, ty_params, cx.param_env)
+            .type_implements_trait(trait_id, ty, ty_params, param_env)
             .must_apply_modulo_regions()
     })
 }
diff --git a/tests/ui/derive_partial_eq_without_eq.fixed b/tests/ui/derive_partial_eq_without_eq.fixed
index 7d4d1b3b649..012780258fc 100644
--- a/tests/ui/derive_partial_eq_without_eq.fixed
+++ b/tests/ui/derive_partial_eq_without_eq.fixed
@@ -95,4 +95,10 @@ enum EnumNotEq {
 #[derive(Debug, PartialEq, Eq, Clone)]
 struct RustFixWithOtherDerives;
 
+#[derive(PartialEq)]
+struct Generic<T>(T);
+
+#[derive(PartialEq, Eq)]
+struct GenericPhantom<T>(core::marker::PhantomData<T>);
+
 fn main() {}
diff --git a/tests/ui/derive_partial_eq_without_eq.rs b/tests/ui/derive_partial_eq_without_eq.rs
index ab4e1df1ca4..fc8285b0c6b 100644
--- a/tests/ui/derive_partial_eq_without_eq.rs
+++ b/tests/ui/derive_partial_eq_without_eq.rs
@@ -95,4 +95,10 @@ enum EnumNotEq {
 #[derive(Debug, PartialEq, Clone)]
 struct RustFixWithOtherDerives;
 
+#[derive(PartialEq)]
+struct Generic<T>(T);
+
+#[derive(PartialEq, Eq)]
+struct GenericPhantom<T>(core::marker::PhantomData<T>);
+
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From a342f52f9169af747f81b27505e5759511db4667 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Mon, 23 May 2022 12:19:25 +0000
Subject: cast_abs_to_unsigned: do not remove cast if it's required

---
 clippy_lints/src/casts/cast_abs_to_unsigned.rs | 46 +++++++------
 tests/ui/cast_abs_to_unsigned.fixed            | 21 ++++++
 tests/ui/cast_abs_to_unsigned.rs               | 21 ++++++
 tests/ui/cast_abs_to_unsigned.stderr           | 92 +++++++++++++++++++++++++-
 4 files changed, 157 insertions(+), 23 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/cast_abs_to_unsigned.rs b/clippy_lints/src/casts/cast_abs_to_unsigned.rs
index 6bac6bf83f8..64ea326b75a 100644
--- a/clippy_lints/src/casts/cast_abs_to_unsigned.rs
+++ b/clippy_lints/src/casts/cast_abs_to_unsigned.rs
@@ -1,11 +1,10 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::sugg::Sugg;
 use clippy_utils::{meets_msrv, msrvs};
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::LateContext;
-use rustc_middle::ty::Ty;
+use rustc_middle::ty::{self, Ty};
 use rustc_semver::RustcVersion;
 
 use super::CAST_ABS_TO_UNSIGNED;
@@ -18,25 +17,28 @@ pub(super) fn check(
     cast_to: Ty<'_>,
     msrv: Option<RustcVersion>,
 ) {
-    if_chain! {
-        if meets_msrv(msrv, msrvs::UNSIGNED_ABS);
-        if cast_from.is_integral();
-        if cast_to.is_integral();
-        if cast_from.is_signed();
-        if !cast_to.is_signed();
-        if let ExprKind::MethodCall(method_path, args, _) = cast_expr.kind;
-        if let method_name = method_path.ident.name.as_str();
-        if method_name == "abs";
-        then {
-            span_lint_and_sugg(
-                cx,
-                CAST_ABS_TO_UNSIGNED,
-                expr.span,
-                &format!("casting the result of `{}::{}()` to {}", cast_from, method_name, cast_to),
-                "replace with",
-                format!("{}.unsigned_abs()", Sugg::hir(cx, &args[0], "..")),
-                Applicability::MachineApplicable,
-            );
-        }
+    if meets_msrv(msrv, msrvs::UNSIGNED_ABS)
+        && let ty::Int(from) = cast_from.kind()
+        && let ty::Uint(to) = cast_to.kind()
+        && let ExprKind::MethodCall(method_path, args, _) = cast_expr.kind
+        && method_path.ident.name.as_str() == "abs"
+    {
+        let span = if from.bit_width() == to.bit_width() {
+            expr.span
+        } else {
+            // if the result of `.unsigned_abs` would be a different type, keep the cast
+            // e.g. `i64 -> usize`, `i16 -> u8`
+            cast_expr.span
+        };
+
+        span_lint_and_sugg(
+            cx,
+            CAST_ABS_TO_UNSIGNED,
+            span,
+            &format!("casting the result of `{cast_from}::abs()` to {cast_to}"),
+            "replace with",
+            format!("{}.unsigned_abs()", Sugg::hir(cx, &args[0], "..")),
+            Applicability::MachineApplicable,
+        );
     }
 }
diff --git a/tests/ui/cast_abs_to_unsigned.fixed b/tests/ui/cast_abs_to_unsigned.fixed
index 4ec2465be06..a68b32b097e 100644
--- a/tests/ui/cast_abs_to_unsigned.fixed
+++ b/tests/ui/cast_abs_to_unsigned.fixed
@@ -5,4 +5,25 @@ fn main() {
     let x: i32 = -42;
     let y: u32 = x.unsigned_abs();
     println!("The absolute value of {} is {}", x, y);
+
+    let a: i32 = -3;
+    let _: usize = a.unsigned_abs() as usize;
+    let _: usize = a.unsigned_abs() as _;
+    let _ = a.unsigned_abs() as usize;
+
+    let a: i64 = -3;
+    let _ = a.unsigned_abs() as usize;
+    let _ = a.unsigned_abs() as u8;
+    let _ = a.unsigned_abs() as u16;
+    let _ = a.unsigned_abs() as u32;
+    let _ = a.unsigned_abs();
+    let _ = a.unsigned_abs() as u128;
+
+    let a: isize = -3;
+    let _ = a.unsigned_abs();
+    let _ = a.unsigned_abs() as u8;
+    let _ = a.unsigned_abs() as u16;
+    let _ = a.unsigned_abs() as u32;
+    let _ = a.unsigned_abs() as u64;
+    let _ = a.unsigned_abs() as u128;
 }
diff --git a/tests/ui/cast_abs_to_unsigned.rs b/tests/ui/cast_abs_to_unsigned.rs
index 59b9c8c3678..110fbc6c2df 100644
--- a/tests/ui/cast_abs_to_unsigned.rs
+++ b/tests/ui/cast_abs_to_unsigned.rs
@@ -5,4 +5,25 @@ fn main() {
     let x: i32 = -42;
     let y: u32 = x.abs() as u32;
     println!("The absolute value of {} is {}", x, y);
+
+    let a: i32 = -3;
+    let _: usize = a.abs() as usize;
+    let _: usize = a.abs() as _;
+    let _ = a.abs() as usize;
+
+    let a: i64 = -3;
+    let _ = a.abs() as usize;
+    let _ = a.abs() as u8;
+    let _ = a.abs() as u16;
+    let _ = a.abs() as u32;
+    let _ = a.abs() as u64;
+    let _ = a.abs() as u128;
+
+    let a: isize = -3;
+    let _ = a.abs() as usize;
+    let _ = a.abs() as u8;
+    let _ = a.abs() as u16;
+    let _ = a.abs() as u32;
+    let _ = a.abs() as u64;
+    let _ = a.abs() as u128;
 }
diff --git a/tests/ui/cast_abs_to_unsigned.stderr b/tests/ui/cast_abs_to_unsigned.stderr
index eb12857357a..02c24e10659 100644
--- a/tests/ui/cast_abs_to_unsigned.stderr
+++ b/tests/ui/cast_abs_to_unsigned.stderr
@@ -6,5 +6,95 @@ LL |     let y: u32 = x.abs() as u32;
    |
    = note: `-D clippy::cast-abs-to-unsigned` implied by `-D warnings`
 
-error: aborting due to previous error
+error: casting the result of `i32::abs()` to usize
+  --> $DIR/cast_abs_to_unsigned.rs:10:20
+   |
+LL |     let _: usize = a.abs() as usize;
+   |                    ^^^^^^^ help: replace with: `a.unsigned_abs()`
+
+error: casting the result of `i32::abs()` to usize
+  --> $DIR/cast_abs_to_unsigned.rs:11:20
+   |
+LL |     let _: usize = a.abs() as _;
+   |                    ^^^^^^^ help: replace with: `a.unsigned_abs()`
+
+error: casting the result of `i32::abs()` to usize
+  --> $DIR/cast_abs_to_unsigned.rs:12:13
+   |
+LL |     let _ = a.abs() as usize;
+   |             ^^^^^^^ help: replace with: `a.unsigned_abs()`
+
+error: casting the result of `i64::abs()` to usize
+  --> $DIR/cast_abs_to_unsigned.rs:15:13
+   |
+LL |     let _ = a.abs() as usize;
+   |             ^^^^^^^ help: replace with: `a.unsigned_abs()`
+
+error: casting the result of `i64::abs()` to u8
+  --> $DIR/cast_abs_to_unsigned.rs:16:13
+   |
+LL |     let _ = a.abs() as u8;
+   |             ^^^^^^^ help: replace with: `a.unsigned_abs()`
+
+error: casting the result of `i64::abs()` to u16
+  --> $DIR/cast_abs_to_unsigned.rs:17:13
+   |
+LL |     let _ = a.abs() as u16;
+   |             ^^^^^^^ help: replace with: `a.unsigned_abs()`
+
+error: casting the result of `i64::abs()` to u32
+  --> $DIR/cast_abs_to_unsigned.rs:18:13
+   |
+LL |     let _ = a.abs() as u32;
+   |             ^^^^^^^ help: replace with: `a.unsigned_abs()`
+
+error: casting the result of `i64::abs()` to u64
+  --> $DIR/cast_abs_to_unsigned.rs:19:13
+   |
+LL |     let _ = a.abs() as u64;
+   |             ^^^^^^^^^^^^^^ help: replace with: `a.unsigned_abs()`
+
+error: casting the result of `i64::abs()` to u128
+  --> $DIR/cast_abs_to_unsigned.rs:20:13
+   |
+LL |     let _ = a.abs() as u128;
+   |             ^^^^^^^ help: replace with: `a.unsigned_abs()`
+
+error: casting the result of `isize::abs()` to usize
+  --> $DIR/cast_abs_to_unsigned.rs:23:13
+   |
+LL |     let _ = a.abs() as usize;
+   |             ^^^^^^^^^^^^^^^^ help: replace with: `a.unsigned_abs()`
+
+error: casting the result of `isize::abs()` to u8
+  --> $DIR/cast_abs_to_unsigned.rs:24:13
+   |
+LL |     let _ = a.abs() as u8;
+   |             ^^^^^^^ help: replace with: `a.unsigned_abs()`
+
+error: casting the result of `isize::abs()` to u16
+  --> $DIR/cast_abs_to_unsigned.rs:25:13
+   |
+LL |     let _ = a.abs() as u16;
+   |             ^^^^^^^ help: replace with: `a.unsigned_abs()`
+
+error: casting the result of `isize::abs()` to u32
+  --> $DIR/cast_abs_to_unsigned.rs:26:13
+   |
+LL |     let _ = a.abs() as u32;
+   |             ^^^^^^^ help: replace with: `a.unsigned_abs()`
+
+error: casting the result of `isize::abs()` to u64
+  --> $DIR/cast_abs_to_unsigned.rs:27:13
+   |
+LL |     let _ = a.abs() as u64;
+   |             ^^^^^^^ help: replace with: `a.unsigned_abs()`
+
+error: casting the result of `isize::abs()` to u128
+  --> $DIR/cast_abs_to_unsigned.rs:28:13
+   |
+LL |     let _ = a.abs() as u128;
+   |             ^^^^^^^ help: replace with: `a.unsigned_abs()`
+
+error: aborting due to 16 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From ea62347a5a4b952b416dddc8053a495c9238e7d7 Mon Sep 17 00:00:00 2001
From: Federico Guerinoni <guerinoni.federico@gmail.com>
Date: Mon, 25 Apr 2022 16:12:48 +0200
Subject: New lint `no_effect_replace`

Closes #1595

changelog: Add no_effect_replace lint.
---
 CHANGELOG.md                                  |  1 +
 clippy_lints/src/lib.register_all.rs          |  1 +
 clippy_lints/src/lib.register_lints.rs        |  1 +
 clippy_lints/src/lib.register_suspicious.rs   |  1 +
 clippy_lints/src/methods/mod.rs               | 23 ++++++++++++
 clippy_lints/src/methods/no_effect_replace.rs | 47 ++++++++++++++++++++++++
 tests/ui/no_effect_replace.rs                 | 51 ++++++++++++++++++++++++++
 tests/ui/no_effect_replace.stderr             | 52 +++++++++++++++++++++++++++
 8 files changed, 177 insertions(+)
 create mode 100644 clippy_lints/src/methods/no_effect_replace.rs
 create mode 100644 tests/ui/no_effect_replace.rs
 create mode 100644 tests/ui/no_effect_replace.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 47aaae9c198..4b62ccbf8bc 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3594,6 +3594,7 @@ Released 2018-09-13
 [`new_ret_no_self`]: https://rust-lang.github.io/rust-clippy/master/index.html#new_ret_no_self
 [`new_without_default`]: https://rust-lang.github.io/rust-clippy/master/index.html#new_without_default
 [`no_effect`]: https://rust-lang.github.io/rust-clippy/master/index.html#no_effect
+[`no_effect_replace`]: https://rust-lang.github.io/rust-clippy/master/index.html#no_effect_replace
 [`no_effect_underscore_binding`]: https://rust-lang.github.io/rust-clippy/master/index.html#no_effect_underscore_binding
 [`non_ascii_literal`]: https://rust-lang.github.io/rust-clippy/master/index.html#non_ascii_literal
 [`non_octal_unix_permissions`]: https://rust-lang.github.io/rust-clippy/master/index.html#non_octal_unix_permissions
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index fca5e109509..2d0dca87b10 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -190,6 +190,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(methods::NEEDLESS_OPTION_TAKE),
     LintId::of(methods::NEEDLESS_SPLITN),
     LintId::of(methods::NEW_RET_NO_SELF),
+    LintId::of(methods::NO_EFFECT_REPLACE),
     LintId::of(methods::OK_EXPECT),
     LintId::of(methods::OPTION_AS_REF_DEREF),
     LintId::of(methods::OPTION_FILTER_MAP),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 7489f53fd3c..5d6360838ec 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -331,6 +331,7 @@ store.register_lints(&[
     methods::NEEDLESS_OPTION_TAKE,
     methods::NEEDLESS_SPLITN,
     methods::NEW_RET_NO_SELF,
+    methods::NO_EFFECT_REPLACE,
     methods::OK_EXPECT,
     methods::OPTION_AS_REF_DEREF,
     methods::OPTION_FILTER_MAP,
diff --git a/clippy_lints/src/lib.register_suspicious.rs b/clippy_lints/src/lib.register_suspicious.rs
index 940bf7ace5e..7e1ba5336c6 100644
--- a/clippy_lints/src/lib.register_suspicious.rs
+++ b/clippy_lints/src/lib.register_suspicious.rs
@@ -23,6 +23,7 @@ store.register_group(true, "clippy::suspicious", Some("clippy_suspicious"), vec!
     LintId::of(loops::EMPTY_LOOP),
     LintId::of(loops::FOR_LOOPS_OVER_FALLIBLES),
     LintId::of(loops::MUT_RANGE_BOUND),
+    LintId::of(methods::NO_EFFECT_REPLACE),
     LintId::of(methods::SUSPICIOUS_MAP),
     LintId::of(mut_key::MUTABLE_KEY_TYPE),
     LintId::of(octal_escapes::OCTAL_ESCAPES),
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index cfeee4d0c70..5102fa17a67 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -44,6 +44,7 @@ mod map_identity;
 mod map_unwrap_or;
 mod needless_option_as_deref;
 mod needless_option_take;
+mod no_effect_replace;
 mod ok_expect;
 mod option_as_ref_deref;
 mod option_map_or_none;
@@ -2197,6 +2198,24 @@ declare_clippy_lint! {
     "using `.as_ref().take()` on a temporary value"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `replace` statements which have no effect.
+    ///
+    /// ### Why is this bad?
+    /// It's either a mistake or confusing.
+    ///
+    /// ### Example
+    /// ```rust
+    /// "1234".replace("12", "12");
+    /// "1234".replacen("12", "12", 1);
+    /// ```
+    #[clippy::version = "1.62.0"]
+    pub NO_EFFECT_REPLACE,
+    suspicious,
+    "replace with no effect"
+}
+
 pub struct Methods {
     avoid_breaking_exported_api: bool,
     msrv: Option<RustcVersion>,
@@ -2296,6 +2315,7 @@ impl_lint_pass!(Methods => [
     NEEDLESS_OPTION_AS_DEREF,
     IS_DIGIT_ASCII_RADIX,
     NEEDLESS_OPTION_TAKE,
+    NO_EFFECT_REPLACE,
 ]);
 
 /// Extracts a method call name, args, and `Span` of the method name.
@@ -2707,6 +2727,9 @@ impl Methods {
                         unnecessary_lazy_eval::check(cx, expr, recv, u_arg, "unwrap_or");
                     },
                 },
+                ("replace" | "replacen", [arg1, arg2] | [arg1, arg2, _]) => {
+                    no_effect_replace::check(cx, expr, arg1, arg2);
+                },
                 _ => {},
             }
         }
diff --git a/clippy_lints/src/methods/no_effect_replace.rs b/clippy_lints/src/methods/no_effect_replace.rs
new file mode 100644
index 00000000000..a76341855b6
--- /dev/null
+++ b/clippy_lints/src/methods/no_effect_replace.rs
@@ -0,0 +1,47 @@
+use clippy_utils::diagnostics::span_lint;
+use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::SpanlessEq;
+use if_chain::if_chain;
+use rustc_ast::LitKind;
+use rustc_hir::ExprKind;
+use rustc_lint::LateContext;
+use rustc_span::sym;
+
+use super::NO_EFFECT_REPLACE;
+
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx rustc_hir::Expr<'_>,
+    arg1: &'tcx rustc_hir::Expr<'_>,
+    arg2: &'tcx rustc_hir::Expr<'_>,
+) {
+    let ty = cx.typeck_results().expr_ty(expr).peel_refs();
+    if !(ty.is_str() || is_type_diagnostic_item(cx, ty, sym::String)) {
+        return;
+    }
+
+    if_chain! {
+        if let ExprKind::Lit(spanned) = &arg1.kind;
+        if let Some(param1) = lit_string_value(&spanned.node);
+
+        if let ExprKind::Lit(spanned) = &arg2.kind;
+        if let LitKind::Str(param2, _) = &spanned.node;
+        if param1 == param2.as_str();
+
+        then {
+            span_lint(cx, NO_EFFECT_REPLACE, expr.span, "replacing text with itself");
+        }
+    }
+
+    if SpanlessEq::new(cx).eq_expr(arg1, arg2) {
+        span_lint(cx, NO_EFFECT_REPLACE, expr.span, "replacing text with itself");
+    }
+}
+
+fn lit_string_value(node: &LitKind) -> Option<String> {
+    match node {
+        LitKind::Char(value) => Some(value.to_string()),
+        LitKind::Str(value, _) => Some(value.as_str().to_owned()),
+        _ => None,
+    }
+}
diff --git a/tests/ui/no_effect_replace.rs b/tests/ui/no_effect_replace.rs
new file mode 100644
index 00000000000..ad17d53f789
--- /dev/null
+++ b/tests/ui/no_effect_replace.rs
@@ -0,0 +1,51 @@
+#![warn(clippy::no_effect_replace)]
+
+fn main() {
+    let _ = "12345".replace('1', "1");
+    let _ = "12345".replace("12", "12");
+    let _ = String::new().replace("12", "12");
+
+    let _ = "12345".replacen('1', "1", 1);
+    let _ = "12345".replacen("12", "12", 1);
+    let _ = String::new().replacen("12", "12", 1);
+
+    let _ = "12345".replace("12", "22");
+    let _ = "12345".replacen("12", "22", 1);
+
+    let mut x = X::default();
+    let _ = "hello".replace(&x.f(), &x.f());
+    let _ = "hello".replace(&x.f(), &x.ff());
+
+    let _ = "hello".replace(&y(), &y());
+    let _ = "hello".replace(&y(), &z());
+
+    let _ = Replaceme.replace("a", "a");
+}
+
+#[derive(Default)]
+struct X {}
+
+impl X {
+    fn f(&mut self) -> String {
+        "he".to_string()
+    }
+
+    fn ff(&mut self) -> String {
+        "hh".to_string()
+    }
+}
+
+fn y() -> String {
+    "he".to_string()
+}
+
+fn z() -> String {
+    "hh".to_string()
+}
+
+struct Replaceme;
+impl Replaceme {
+    pub fn replace(&mut self, a: &str, b: &str) -> Self {
+        Self
+    }
+}
diff --git a/tests/ui/no_effect_replace.stderr b/tests/ui/no_effect_replace.stderr
new file mode 100644
index 00000000000..53a28aa73b7
--- /dev/null
+++ b/tests/ui/no_effect_replace.stderr
@@ -0,0 +1,52 @@
+error: replacing text with itself
+  --> $DIR/no_effect_replace.rs:4:13
+   |
+LL |     let _ = "12345".replace('1', "1");
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::no-effect-replace` implied by `-D warnings`
+
+error: replacing text with itself
+  --> $DIR/no_effect_replace.rs:5:13
+   |
+LL |     let _ = "12345".replace("12", "12");
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: replacing text with itself
+  --> $DIR/no_effect_replace.rs:6:13
+   |
+LL |     let _ = String::new().replace("12", "12");
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: replacing text with itself
+  --> $DIR/no_effect_replace.rs:8:13
+   |
+LL |     let _ = "12345".replacen('1', "1", 1);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: replacing text with itself
+  --> $DIR/no_effect_replace.rs:9:13
+   |
+LL |     let _ = "12345".replacen("12", "12", 1);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: replacing text with itself
+  --> $DIR/no_effect_replace.rs:10:13
+   |
+LL |     let _ = String::new().replacen("12", "12", 1);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: replacing text with itself
+  --> $DIR/no_effect_replace.rs:16:13
+   |
+LL |     let _ = "hello".replace(&x.f(), &x.f());
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: replacing text with itself
+  --> $DIR/no_effect_replace.rs:19:13
+   |
+LL |     let _ = "hello".replace(&y(), &y());
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 8 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 78f7e3745fe59db1e6309b1e42ea25df3317ee36 Mon Sep 17 00:00:00 2001
From: Evan Typanski <evan.typanski@microfocus.com>
Date: Tue, 24 May 2022 11:50:12 -0400
Subject: Fix `manual_range_contains` with equal precedence

---
 clippy_lints/src/ranges.rs     | 13 +++++++++++--
 tests/ui/range_contains.fixed  |  5 +++++
 tests/ui/range_contains.rs     |  5 +++++
 tests/ui/range_contains.stderr | 26 +++++++++++++++++++++++++-
 4 files changed, 46 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/ranges.rs b/clippy_lints/src/ranges.rs
index a47dc26f603..416d6de55c8 100644
--- a/clippy_lints/src/ranges.rs
+++ b/clippy_lints/src/ranges.rs
@@ -194,7 +194,7 @@ impl<'tcx> LateLintPass<'tcx> for Ranges {
             },
             ExprKind::Binary(ref op, l, r) => {
                 if meets_msrv(self.msrv, msrvs::RANGE_CONTAINS) {
-                    check_possible_range_contains(cx, op.node, l, r, expr);
+                    check_possible_range_contains(cx, op.node, l, r, expr, expr.span);
                 }
             },
             _ => {},
@@ -213,12 +213,12 @@ fn check_possible_range_contains(
     left: &Expr<'_>,
     right: &Expr<'_>,
     expr: &Expr<'_>,
+    span: Span,
 ) {
     if in_constant(cx, expr.hir_id) {
         return;
     }
 
-    let span = expr.span;
     let combine_and = match op {
         BinOpKind::And | BinOpKind::BitAnd => true,
         BinOpKind::Or | BinOpKind::BitOr => false,
@@ -294,6 +294,15 @@ fn check_possible_range_contains(
             );
         }
     }
+
+    // If the LHS is the same operator, we have to recurse to get the "real" RHS, since they have
+    // the same operator precedence.
+    if let ExprKind::Binary(ref lhs_op, _left, new_lhs) = left.kind {
+        if op == lhs_op.node {
+            let new_span = Span::new(new_lhs.span.lo(), right.span.hi(), expr.span.ctxt(), expr.span.parent());
+            check_possible_range_contains(cx, op, new_lhs, right, expr, new_span);
+        }
+    }
 }
 
 struct RangeBounds<'a> {
diff --git a/tests/ui/range_contains.fixed b/tests/ui/range_contains.fixed
index f4977199711..fd4dcf39f2f 100644
--- a/tests/ui/range_contains.fixed
+++ b/tests/ui/range_contains.fixed
@@ -49,6 +49,11 @@ fn main() {
     x >= 10 && x <= -10;
     (-3. ..=3.).contains(&y);
     y >= 3. && y <= -3.;
+
+    // Fix #8745
+    let z = 42;
+    (0..=10).contains(&x) && (0..=10).contains(&z);
+    !(0..10).contains(&x) || !(0..10).contains(&z);
 }
 
 // Fix #6373
diff --git a/tests/ui/range_contains.rs b/tests/ui/range_contains.rs
index 9e2180b0c99..b848e2e1671 100644
--- a/tests/ui/range_contains.rs
+++ b/tests/ui/range_contains.rs
@@ -49,6 +49,11 @@ fn main() {
     x >= 10 && x <= -10;
     y >= -3. && y <= 3.;
     y >= 3. && y <= -3.;
+
+    // Fix #8745
+    let z = 42;
+    (x >= 0) && (x <= 10) && (z >= 0) && (z <= 10);
+    (x < 0) || (x >= 10) || (z < 0) || (z >= 10);
 }
 
 // Fix #6373
diff --git a/tests/ui/range_contains.stderr b/tests/ui/range_contains.stderr
index 1817ee1715d..936859db5a1 100644
--- a/tests/ui/range_contains.stderr
+++ b/tests/ui/range_contains.stderr
@@ -96,5 +96,29 @@ error: manual `RangeInclusive::contains` implementation
 LL |     y >= -3. && y <= 3.;
    |     ^^^^^^^^^^^^^^^^^^^ help: use: `(-3. ..=3.).contains(&y)`
 
-error: aborting due to 16 previous errors
+error: manual `RangeInclusive::contains` implementation
+  --> $DIR/range_contains.rs:55:30
+   |
+LL |     (x >= 0) && (x <= 10) && (z >= 0) && (z <= 10);
+   |                              ^^^^^^^^^^^^^^^^^^^^^ help: use: `(0..=10).contains(&z)`
+
+error: manual `RangeInclusive::contains` implementation
+  --> $DIR/range_contains.rs:55:5
+   |
+LL |     (x >= 0) && (x <= 10) && (z >= 0) && (z <= 10);
+   |     ^^^^^^^^^^^^^^^^^^^^^ help: use: `(0..=10).contains(&x)`
+
+error: manual `!Range::contains` implementation
+  --> $DIR/range_contains.rs:56:29
+   |
+LL |     (x < 0) || (x >= 10) || (z < 0) || (z >= 10);
+   |                             ^^^^^^^^^^^^^^^^^^^^ help: use: `!(0..10).contains(&z)`
+
+error: manual `!Range::contains` implementation
+  --> $DIR/range_contains.rs:56:5
+   |
+LL |     (x < 0) || (x >= 10) || (z < 0) || (z >= 10);
+   |     ^^^^^^^^^^^^^^^^^^^^ help: use: `!(0..10).contains(&x)`
+
+error: aborting due to 20 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 257f09776a9c68ac903d1f23b80c414b70de1185 Mon Sep 17 00:00:00 2001
From: Evan Typanski <evan.typanski@microfocus.com>
Date: Tue, 24 May 2022 14:09:56 -0400
Subject: Fix issue with mismatched parens in suggestion

---
 clippy_lints/src/ranges.rs    | 13 +++++++++----
 tests/ui/range_contains.fixed |  2 ++
 tests/ui/range_contains.rs    |  2 ++
 3 files changed, 13 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/ranges.rs b/clippy_lints/src/ranges.rs
index 416d6de55c8..584b561dcf0 100644
--- a/clippy_lints/src/ranges.rs
+++ b/clippy_lints/src/ranges.rs
@@ -296,10 +296,15 @@ fn check_possible_range_contains(
     }
 
     // If the LHS is the same operator, we have to recurse to get the "real" RHS, since they have
-    // the same operator precedence.
-    if let ExprKind::Binary(ref lhs_op, _left, new_lhs) = left.kind {
-        if op == lhs_op.node {
-            let new_span = Span::new(new_lhs.span.lo(), right.span.hi(), expr.span.ctxt(), expr.span.parent());
+    // the same operator precedence
+    if_chain! {
+        if let ExprKind::Binary(ref lhs_op, _left, new_lhs) = left.kind;
+        if op == lhs_op.node;
+        let new_span = Span::new(new_lhs.span.lo(), right.span.hi(), expr.span.ctxt(), expr.span.parent());
+        if let Some(snip) = &snippet_opt(cx, new_span);
+        // Do not continue if we have mismatched number of parens, otherwise the suggestion is wrong
+        if snip.matches('(').count() == snip.matches(')').count();
+        then {
             check_possible_range_contains(cx, op, new_lhs, right, expr, new_span);
         }
     }
diff --git a/tests/ui/range_contains.fixed b/tests/ui/range_contains.fixed
index fd4dcf39f2f..85d021b2f25 100644
--- a/tests/ui/range_contains.fixed
+++ b/tests/ui/range_contains.fixed
@@ -54,6 +54,8 @@ fn main() {
     let z = 42;
     (0..=10).contains(&x) && (0..=10).contains(&z);
     !(0..10).contains(&x) || !(0..10).contains(&z);
+    // Make sure operators in parens don't give a breaking suggestion
+    ((x % 2 == 0) || (x < 0)) || (x >= 10);
 }
 
 // Fix #6373
diff --git a/tests/ui/range_contains.rs b/tests/ui/range_contains.rs
index b848e2e1671..9a7a75dc132 100644
--- a/tests/ui/range_contains.rs
+++ b/tests/ui/range_contains.rs
@@ -54,6 +54,8 @@ fn main() {
     let z = 42;
     (x >= 0) && (x <= 10) && (z >= 0) && (z <= 10);
     (x < 0) || (x >= 10) || (z < 0) || (z >= 10);
+    // Make sure operators in parens don't give a breaking suggestion
+    ((x % 2 == 0) || (x < 0)) || (x >= 10);
 }
 
 // Fix #6373
-- 
cgit 1.4.1-3-g733a5


From 1dd026698d4f6c5848fb88d48b2d4248846bb41c Mon Sep 17 00:00:00 2001
From: kyoto7250 <50972773+kyoto7250@users.noreply.github.com>
Date: Tue, 24 May 2022 18:54:49 +0900
Subject: feat(lint): impl lint about use first() instead of get(0)

---
 CHANGELOG.md                           |  1 +
 clippy_lints/src/get_first.rs          | 72 ++++++++++++++++++++++++++++++++++
 clippy_lints/src/lib.register_all.rs   |  1 +
 clippy_lints/src/lib.register_lints.rs |  1 +
 clippy_lints/src/lib.register_style.rs |  1 +
 clippy_lints/src/lib.rs                |  2 +
 clippy_utils/src/paths.rs              |  1 +
 tests/ui/get_first.fixed               | 42 ++++++++++++++++++++
 tests/ui/get_first.rs                  | 42 ++++++++++++++++++++
 tests/ui/get_first.stderr              | 22 +++++++++++
 10 files changed, 185 insertions(+)
 create mode 100644 clippy_lints/src/get_first.rs
 create mode 100644 tests/ui/get_first.fixed
 create mode 100644 tests/ui/get_first.rs
 create mode 100644 tests/ui/get_first.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index f4a362e6c19..0f6295a45f3 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3435,6 +3435,7 @@ Released 2018-09-13
 [`from_over_into`]: https://rust-lang.github.io/rust-clippy/master/index.html#from_over_into
 [`from_str_radix_10`]: https://rust-lang.github.io/rust-clippy/master/index.html#from_str_radix_10
 [`future_not_send`]: https://rust-lang.github.io/rust-clippy/master/index.html#future_not_send
+[`get_first`]: https://rust-lang.github.io/rust-clippy/master/index.html#get_first
 [`get_last_with_len`]: https://rust-lang.github.io/rust-clippy/master/index.html#get_last_with_len
 [`get_unwrap`]: https://rust-lang.github.io/rust-clippy/master/index.html#get_unwrap
 [`identity_conversion`]: https://rust-lang.github.io/rust-clippy/master/index.html#identity_conversion
diff --git a/clippy_lints/src/get_first.rs b/clippy_lints/src/get_first.rs
new file mode 100644
index 00000000000..0f26c19c49e
--- /dev/null
+++ b/clippy_lints/src/get_first.rs
@@ -0,0 +1,72 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::{is_slice_of_primitives, match_def_path, paths};
+use if_chain::if_chain;
+use rustc_ast::LitKind;
+use rustc_errors::Applicability;
+use rustc_hir as hir;
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::source_map::Spanned;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for using `x.get(0)` instead of
+    /// `x.first()`.
+    ///
+    /// ### Why is this bad?
+    /// Using `x.first()` is easier to read and has the same
+    /// result.
+    ///
+    /// ### Example
+    /// ```rust
+    /// // Bad
+    /// let x = vec![2, 3, 5];
+    /// let first_element = x.get(0);
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// // Good
+    /// let x = vec![2, 3, 5];
+    /// let first_element = x.first();
+    /// ```
+    #[clippy::version = "1.63.0"]
+    pub GET_FIRST,
+    style,
+    "Using `x.get(0)` when `x.first()` is simpler"
+}
+declare_lint_pass!(GetFirst => [GET_FIRST]);
+
+impl<'tcx> LateLintPass<'tcx> for GetFirst {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
+        if_chain! {
+            if let hir::ExprKind::MethodCall(_, expr_args, _) = &expr.kind;
+            if let Some(expr_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
+            if match_def_path(cx, expr_def_id, &paths::SLICE_GET) && expr_args.len() == 2;
+
+            if let Some(struct_calling_on) = expr_args.get(0);
+            if let Some(_) = is_slice_of_primitives(cx, struct_calling_on);
+
+            if let Some(method_arg) = expr_args.get(1);
+            if let hir::ExprKind::Lit(Spanned { node: LitKind::Int(0, _), .. }) = method_arg.kind;
+
+            then {
+                let mut applicability = Applicability::MachineApplicable;
+                let slice_name = snippet_with_applicability(
+                    cx,
+                    struct_calling_on.span, "..",
+                    &mut applicability,
+                );
+                span_lint_and_sugg(
+                    cx,
+                    GET_FIRST,
+                    expr.span,
+                    &format!("accessing first element with `{0}.get(0)`", slice_name),
+                    "try",
+                    format!("{}.first()", slice_name),
+                    applicability,
+                );
+            }
+        }
+    }
+}
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 5aba6040b8c..a028b41db77 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -91,6 +91,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(functions::NOT_UNSAFE_PTR_ARG_DEREF),
     LintId::of(functions::RESULT_UNIT_ERR),
     LintId::of(functions::TOO_MANY_ARGUMENTS),
+    LintId::of(get_first::GET_FIRST),
     LintId::of(identity_op::IDENTITY_OP),
     LintId::of(if_let_mutex::IF_LET_MUTEX),
     LintId::of(indexing_slicing::OUT_OF_BOUNDS_INDEXING),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index fea34fe66f4..570d736518b 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -183,6 +183,7 @@ store.register_lints(&[
     functions::TOO_MANY_ARGUMENTS,
     functions::TOO_MANY_LINES,
     future_not_send::FUTURE_NOT_SEND,
+    get_first::GET_FIRST,
     identity_op::IDENTITY_OP,
     if_let_mutex::IF_LET_MUTEX,
     if_not_else::IF_NOT_ELSE,
diff --git a/clippy_lints/src/lib.register_style.rs b/clippy_lints/src/lib.register_style.rs
index 62f26d821a0..ea2e1082458 100644
--- a/clippy_lints/src/lib.register_style.rs
+++ b/clippy_lints/src/lib.register_style.rs
@@ -31,6 +31,7 @@ store.register_group(true, "clippy::style", Some("clippy_style"), vec![
     LintId::of(functions::DOUBLE_MUST_USE),
     LintId::of(functions::MUST_USE_UNIT),
     LintId::of(functions::RESULT_UNIT_ERR),
+    LintId::of(get_first::GET_FIRST),
     LintId::of(inherent_to_string::INHERENT_TO_STRING),
     LintId::of(init_numbered_fields::INIT_NUMBERED_FIELDS),
     LintId::of(len_zero::COMPARISON_TO_EMPTY),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 2f8533723ef..5f636e5114b 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -242,6 +242,7 @@ mod from_over_into;
 mod from_str_radix_10;
 mod functions;
 mod future_not_send;
+mod get_first;
 mod identity_op;
 mod if_let_mutex;
 mod if_not_else;
@@ -904,6 +905,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(strings::TrimSplitWhitespace));
     store.register_late_pass(|| Box::new(rc_clone_in_vec_init::RcCloneInVecInit));
     store.register_early_pass(|| Box::new(duplicate_mod::DuplicateMod::default()));
+    store.register_late_pass(|| Box::new(get_first::GetFirst));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index 9b9cbff2d14..0064694ff92 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -141,6 +141,7 @@ pub const SERDE_DESERIALIZE: [&str; 3] = ["serde", "de", "Deserialize"];
 pub const SERDE_DE_VISITOR: [&str; 3] = ["serde", "de", "Visitor"];
 pub const SLICE_FROM_RAW_PARTS: [&str; 4] = ["core", "slice", "raw", "from_raw_parts"];
 pub const SLICE_FROM_RAW_PARTS_MUT: [&str; 4] = ["core", "slice", "raw", "from_raw_parts_mut"];
+pub const SLICE_GET: [&str; 4] = ["core", "slice", "<impl [T]>", "get"];
 pub const SLICE_INTO_VEC: [&str; 4] = ["alloc", "slice", "<impl [T]>", "into_vec"];
 pub const SLICE_ITER: [&str; 4] = ["core", "slice", "iter", "Iter"];
 pub const STDERR: [&str; 4] = ["std", "io", "stdio", "stderr"];
diff --git a/tests/ui/get_first.fixed b/tests/ui/get_first.fixed
new file mode 100644
index 00000000000..def58afa4fb
--- /dev/null
+++ b/tests/ui/get_first.fixed
@@ -0,0 +1,42 @@
+// run-rustfix
+#![warn(clippy::get_first)]
+use std::collections::BTreeMap;
+use std::collections::HashMap;
+use std::collections::VecDeque;
+
+struct Bar {
+    arr: [u32; 3],
+}
+
+impl Bar {
+    fn get(&self, pos: usize) -> Option<&u32> {
+        self.arr.get(pos)
+    }
+}
+
+fn main() {
+    let x = vec![2, 3, 5];
+    let _ = x.first(); // Use x.first()
+    let _ = x.get(1);
+    let _ = x[0];
+
+    let y = [2, 3, 5];
+    let _ = y.first(); // Use y.first()
+    let _ = y.get(1);
+    let _ = y[0];
+
+    let z = &[2, 3, 5];
+    let _ = z.first(); // Use z.first()
+    let _ = z.get(1);
+    let _ = z[0];
+
+    let vecdeque: VecDeque<_> = x.iter().cloned().collect();
+    let hashmap: HashMap<u8, char> = HashMap::from_iter(vec![(0, 'a'), (1, 'b')]);
+    let btreemap: BTreeMap<u8, char> = BTreeMap::from_iter(vec![(0, 'a'), (1, 'b')]);
+    let _ = vecdeque.get(0); // Do not lint, because VecDeque is not slice.
+    let _ = hashmap.get(&0); // Do not lint, because HashMap is not slice.
+    let _ = btreemap.get(&0); // Do not lint, because BTreeMap is not slice.
+
+    let bar = Bar { arr: [0, 1, 2] };
+    let _ = bar.get(0); // Do not lint, because Bar is struct.
+}
diff --git a/tests/ui/get_first.rs b/tests/ui/get_first.rs
new file mode 100644
index 00000000000..85a381854cd
--- /dev/null
+++ b/tests/ui/get_first.rs
@@ -0,0 +1,42 @@
+// run-rustfix
+#![warn(clippy::get_first)]
+use std::collections::BTreeMap;
+use std::collections::HashMap;
+use std::collections::VecDeque;
+
+struct Bar {
+    arr: [u32; 3],
+}
+
+impl Bar {
+    fn get(&self, pos: usize) -> Option<&u32> {
+        self.arr.get(pos)
+    }
+}
+
+fn main() {
+    let x = vec![2, 3, 5];
+    let _ = x.get(0); // Use x.first()
+    let _ = x.get(1);
+    let _ = x[0];
+
+    let y = [2, 3, 5];
+    let _ = y.get(0); // Use y.first()
+    let _ = y.get(1);
+    let _ = y[0];
+
+    let z = &[2, 3, 5];
+    let _ = z.get(0); // Use z.first()
+    let _ = z.get(1);
+    let _ = z[0];
+
+    let vecdeque: VecDeque<_> = x.iter().cloned().collect();
+    let hashmap: HashMap<u8, char> = HashMap::from_iter(vec![(0, 'a'), (1, 'b')]);
+    let btreemap: BTreeMap<u8, char> = BTreeMap::from_iter(vec![(0, 'a'), (1, 'b')]);
+    let _ = vecdeque.get(0); // Do not lint, because VecDeque is not slice.
+    let _ = hashmap.get(&0); // Do not lint, because HashMap is not slice.
+    let _ = btreemap.get(&0); // Do not lint, because BTreeMap is not slice.
+
+    let bar = Bar { arr: [0, 1, 2] };
+    let _ = bar.get(0); // Do not lint, because Bar is struct.
+}
diff --git a/tests/ui/get_first.stderr b/tests/ui/get_first.stderr
new file mode 100644
index 00000000000..466beff9c92
--- /dev/null
+++ b/tests/ui/get_first.stderr
@@ -0,0 +1,22 @@
+error: accessing first element with `x.get(0)`
+  --> $DIR/get_first.rs:19:13
+   |
+LL |     let _ = x.get(0); // Use x.first()
+   |             ^^^^^^^^ help: try: `x.first()`
+   |
+   = note: `-D clippy::get-first` implied by `-D warnings`
+
+error: accessing first element with `y.get(0)`
+  --> $DIR/get_first.rs:24:13
+   |
+LL |     let _ = y.get(0); // Use y.first()
+   |             ^^^^^^^^ help: try: `y.first()`
+
+error: accessing first element with `z.get(0)`
+  --> $DIR/get_first.rs:29:13
+   |
+LL |     let _ = z.get(0); // Use z.first()
+   |             ^^^^^^^^ help: try: `z.first()`
+
+error: aborting due to 3 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From b531eb1a7aca3357d2d5fce97f3f07d2a6956bfe Mon Sep 17 00:00:00 2001
From: kyoto7250 <50972773+kyoto7250@users.noreply.github.com>
Date: Tue, 24 May 2022 18:55:39 +0900
Subject: suggest first() instead of get(0)

---
 clippy_lints/src/methods/iter_next_slice.rs | 9 +++++++--
 tests/ui/iter_next_slice.fixed              | 8 ++++----
 tests/ui/iter_next_slice.rs                 | 4 ++--
 tests/ui/iter_next_slice.stderr             | 4 ++--
 4 files changed, 15 insertions(+), 10 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/iter_next_slice.rs b/clippy_lints/src/methods/iter_next_slice.rs
index d053ff56756..b8d1dabe007 100644
--- a/clippy_lints/src/methods/iter_next_slice.rs
+++ b/clippy_lints/src/methods/iter_next_slice.rs
@@ -34,13 +34,18 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, cal
             if let ast::LitKind::Int(start_idx, _) = start_lit.node;
             then {
                 let mut applicability = Applicability::MachineApplicable;
+                let suggest = if start_idx == 0 {
+                    format!("{}.first()", snippet_with_applicability(cx, caller_var.span, "..", &mut applicability))
+                } else {
+                    format!("{}.get({})", snippet_with_applicability(cx, caller_var.span, "..", &mut applicability), start_idx)
+                };
                 span_lint_and_sugg(
                     cx,
                     ITER_NEXT_SLICE,
                     expr.span,
                     "using `.iter().next()` on a Slice without end index",
                     "try calling",
-                    format!("{}.get({})", snippet_with_applicability(cx, caller_var.span, "..", &mut applicability), start_idx),
+                    suggest,
                     applicability,
                 );
             }
@@ -55,7 +60,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, cal
             "using `.iter().next()` on an array",
             "try calling",
             format!(
-                "{}.get(0)",
+                "{}.first()",
                 snippet_with_applicability(cx, caller_expr.span, "..", &mut applicability)
             ),
             applicability,
diff --git a/tests/ui/iter_next_slice.fixed b/tests/ui/iter_next_slice.fixed
index 11ffc8edb14..f612d26aaab 100644
--- a/tests/ui/iter_next_slice.fixed
+++ b/tests/ui/iter_next_slice.fixed
@@ -6,8 +6,8 @@ fn main() {
     let s = [1, 2, 3];
     let v = vec![1, 2, 3];
 
-    let _ = s.get(0);
-    // Should be replaced by s.get(0)
+    let _ = s.first();
+    // Should be replaced by s.first()
 
     let _ = s.get(2);
     // Should be replaced by s.get(2)
@@ -15,8 +15,8 @@ fn main() {
     let _ = v.get(5);
     // Should be replaced by v.get(5)
 
-    let _ = v.get(0);
-    // Should be replaced by v.get(0)
+    let _ = v.first();
+    // Should be replaced by v.first()
 
     let o = Some(5);
     o.iter().next();
diff --git a/tests/ui/iter_next_slice.rs b/tests/ui/iter_next_slice.rs
index e0d3aabd54a..5195f1c8667 100644
--- a/tests/ui/iter_next_slice.rs
+++ b/tests/ui/iter_next_slice.rs
@@ -7,7 +7,7 @@ fn main() {
     let v = vec![1, 2, 3];
 
     let _ = s.iter().next();
-    // Should be replaced by s.get(0)
+    // Should be replaced by s.first()
 
     let _ = s[2..].iter().next();
     // Should be replaced by s.get(2)
@@ -16,7 +16,7 @@ fn main() {
     // Should be replaced by v.get(5)
 
     let _ = v.iter().next();
-    // Should be replaced by v.get(0)
+    // Should be replaced by v.first()
 
     let o = Some(5);
     o.iter().next();
diff --git a/tests/ui/iter_next_slice.stderr b/tests/ui/iter_next_slice.stderr
index a78d2c2d5e8..d8b89061ff8 100644
--- a/tests/ui/iter_next_slice.stderr
+++ b/tests/ui/iter_next_slice.stderr
@@ -2,7 +2,7 @@ error: using `.iter().next()` on an array
   --> $DIR/iter_next_slice.rs:9:13
    |
 LL |     let _ = s.iter().next();
-   |             ^^^^^^^^^^^^^^^ help: try calling: `s.get(0)`
+   |             ^^^^^^^^^^^^^^^ help: try calling: `s.first()`
    |
    = note: `-D clippy::iter-next-slice` implied by `-D warnings`
 
@@ -22,7 +22,7 @@ error: using `.iter().next()` on an array
   --> $DIR/iter_next_slice.rs:18:13
    |
 LL |     let _ = v.iter().next();
-   |             ^^^^^^^^^^^^^^^ help: try calling: `v.get(0)`
+   |             ^^^^^^^^^^^^^^^ help: try calling: `v.first()`
 
 error: aborting due to 4 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From d0f93c12a2a6f0d693507ff6325fed62720e616b Mon Sep 17 00:00:00 2001
From: kyoto7250 <50972773+kyoto7250@users.noreply.github.com>
Date: Wed, 25 May 2022 09:11:29 +0900
Subject: refactor: get the required variables with MethodCall

---
 clippy_lints/src/get_first.rs | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/get_first.rs b/clippy_lints/src/get_first.rs
index 0f26c19c49e..0748ab45252 100644
--- a/clippy_lints/src/get_first.rs
+++ b/clippy_lints/src/get_first.rs
@@ -40,14 +40,11 @@ declare_lint_pass!(GetFirst => [GET_FIRST]);
 impl<'tcx> LateLintPass<'tcx> for GetFirst {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
         if_chain! {
-            if let hir::ExprKind::MethodCall(_, expr_args, _) = &expr.kind;
+            if let hir::ExprKind::MethodCall(_, [struct_calling_on, method_arg], _) = &expr.kind;
             if let Some(expr_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
-            if match_def_path(cx, expr_def_id, &paths::SLICE_GET) && expr_args.len() == 2;
+            if match_def_path(cx, expr_def_id, &paths::SLICE_GET);
 
-            if let Some(struct_calling_on) = expr_args.get(0);
             if let Some(_) = is_slice_of_primitives(cx, struct_calling_on);
-
-            if let Some(method_arg) = expr_args.get(1);
             if let hir::ExprKind::Lit(Spanned { node: LitKind::Int(0, _), .. }) = method_arg.kind;
 
             then {
-- 
cgit 1.4.1-3-g733a5


From d8a281ef735be327dceace003b36e14616023126 Mon Sep 17 00:00:00 2001
From: Micha White <botahamec@outlook.com>
Date: Sat, 21 May 2022 17:02:00 -0400
Subject: Added an unused_rounding lint

---
 CHANGELOG.md                             |  1 +
 clippy_lints/src/lib.register_lints.rs   |  1 +
 clippy_lints/src/lib.register_nursery.rs |  1 +
 clippy_lints/src/lib.rs                  |  2 +
 clippy_lints/src/unused_rounding.rs      | 69 ++++++++++++++++++++++++++++++++
 tests/ui/unused_rounding.fixed           |  8 ++++
 tests/ui/unused_rounding.rs              |  8 ++++
 tests/ui/unused_rounding.stderr          | 22 ++++++++++
 8 files changed, 112 insertions(+)
 create mode 100644 clippy_lints/src/unused_rounding.rs
 create mode 100644 tests/ui/unused_rounding.fixed
 create mode 100644 tests/ui/unused_rounding.rs
 create mode 100644 tests/ui/unused_rounding.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 0f6295a45f3..137fd793e75 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3821,6 +3821,7 @@ Released 2018-09-13
 [`unused_collect`]: https://rust-lang.github.io/rust-clippy/master/index.html#unused_collect
 [`unused_io_amount`]: https://rust-lang.github.io/rust-clippy/master/index.html#unused_io_amount
 [`unused_label`]: https://rust-lang.github.io/rust-clippy/master/index.html#unused_label
+[`unused_rounding`]: https://rust-lang.github.io/rust-clippy/master/index.html#unused_rounding
 [`unused_self`]: https://rust-lang.github.io/rust-clippy/master/index.html#unused_self
 [`unused_unit`]: https://rust-lang.github.io/rust-clippy/master/index.html#unused_unit
 [`unusual_byte_groupings`]: https://rust-lang.github.io/rust-clippy/master/index.html#unusual_byte_groupings
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 570d736518b..02171a0909e 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -546,6 +546,7 @@ store.register_lints(&[
     unsafe_removed_from_name::UNSAFE_REMOVED_FROM_NAME,
     unused_async::UNUSED_ASYNC,
     unused_io_amount::UNUSED_IO_AMOUNT,
+    unused_rounding::UNUSED_ROUNDING,
     unused_self::UNUSED_SELF,
     unused_unit::UNUSED_UNIT,
     unwrap::PANICKING_UNWRAP,
diff --git a/clippy_lints/src/lib.register_nursery.rs b/clippy_lints/src/lib.register_nursery.rs
index ec187563b3f..10808af363d 100644
--- a/clippy_lints/src/lib.register_nursery.rs
+++ b/clippy_lints/src/lib.register_nursery.rs
@@ -32,5 +32,6 @@ store.register_group(true, "clippy::nursery", Some("clippy_nursery"), vec![
     LintId::of(trait_bounds::TYPE_REPETITION_IN_BOUNDS),
     LintId::of(transmute::TRANSMUTE_UNDEFINED_REPR),
     LintId::of(transmute::USELESS_TRANSMUTE),
+    LintId::of(unused_rounding::UNUSED_ROUNDING),
     LintId::of(use_self::USE_SELF),
 ])
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 5f636e5114b..09435b06d0a 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -402,6 +402,7 @@ mod unnested_or_patterns;
 mod unsafe_removed_from_name;
 mod unused_async;
 mod unused_io_amount;
+mod unused_rounding;
 mod unused_self;
 mod unused_unit;
 mod unwrap;
@@ -906,6 +907,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(rc_clone_in_vec_init::RcCloneInVecInit));
     store.register_early_pass(|| Box::new(duplicate_mod::DuplicateMod::default()));
     store.register_late_pass(|| Box::new(get_first::GetFirst));
+    store.register_early_pass(|| Box::new(unused_rounding::UnusedRounding));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/unused_rounding.rs b/clippy_lints/src/unused_rounding.rs
new file mode 100644
index 00000000000..7706a338eb2
--- /dev/null
+++ b/clippy_lints/src/unused_rounding.rs
@@ -0,0 +1,69 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use rustc_ast::ast::{Expr, ExprKind, LitFloatType, LitKind};
+use rustc_errors::Applicability;
+use rustc_lint::{EarlyContext, EarlyLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// ### What it does
+    ///
+    /// Detects cases where a whole-number literal float is being rounded, using
+    /// the `floor`, `ceil`, or `round` methods.
+    ///
+    /// ### Why is this bad?
+    ///
+    /// This is unnecessary and confusing to the reader. Doing this is probably a mistake.
+    ///
+    /// ### Example
+    /// ```rust
+    /// let x = 1f32.ceil();
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// let x = 1f32;
+    /// ```
+    #[clippy::version = "1.62.0"]
+    pub UNUSED_ROUNDING,
+    nursery,
+    "Rounding a whole number literal, which is useless"
+}
+declare_lint_pass!(UnusedRounding => [UNUSED_ROUNDING]);
+
+fn is_useless_rounding(expr: &Expr) -> Option<(&str, String)> {
+    if let ExprKind::MethodCall(name_ident, args, _) = &expr.kind
+        && let method_name = name_ident.ident.name.as_str()
+        && (method_name == "ceil" || method_name == "round" || method_name == "floor")
+        && !args.is_empty()
+        && let ExprKind::Lit(spanned) = &args[0].kind
+        && let LitKind::Float(symbol, ty) = spanned.kind {
+            let f = symbol.as_str().parse::<f64>().unwrap();
+            let f_str = symbol.to_string() + if let LitFloatType::Suffixed(ty) = ty {
+                ty.name_str()
+            } else {
+                ""
+            };
+            if f.fract() < f64::EPSILON {
+                Some((method_name, f_str))
+            } else {
+                None
+            }
+        } else {
+            None
+        }
+}
+
+impl EarlyLintPass for UnusedRounding {
+    fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
+        if let Some((method_name, float)) = is_useless_rounding(expr) {
+            span_lint_and_sugg(
+                cx,
+                UNUSED_ROUNDING,
+                expr.span,
+                &format!("used the `{}` method with a whole number float", method_name),
+                &format!("remove the `{}` method call", method_name),
+                float,
+                Applicability::MachineApplicable,
+            );
+        }
+    }
+}
diff --git a/tests/ui/unused_rounding.fixed b/tests/ui/unused_rounding.fixed
new file mode 100644
index 00000000000..a1cb80413d2
--- /dev/null
+++ b/tests/ui/unused_rounding.fixed
@@ -0,0 +1,8 @@
+// run-rustfix
+#![warn(clippy::unused_rounding)]
+
+fn main() {
+    let _ = 1f32;
+    let _ = 1.0f64;
+    let _ = 1.00f32;
+}
diff --git a/tests/ui/unused_rounding.rs b/tests/ui/unused_rounding.rs
new file mode 100644
index 00000000000..90af8f19dd9
--- /dev/null
+++ b/tests/ui/unused_rounding.rs
@@ -0,0 +1,8 @@
+// run-rustfix
+#![warn(clippy::unused_rounding)]
+
+fn main() {
+    let _ = 1f32.ceil();
+    let _ = 1.0f64.floor();
+    let _ = 1.00f32.round();
+}
diff --git a/tests/ui/unused_rounding.stderr b/tests/ui/unused_rounding.stderr
new file mode 100644
index 00000000000..6cfb02e0402
--- /dev/null
+++ b/tests/ui/unused_rounding.stderr
@@ -0,0 +1,22 @@
+error: used the `ceil` method with a whole number float
+  --> $DIR/unused_rounding.rs:5:13
+   |
+LL |     let _ = 1f32.ceil();
+   |             ^^^^^^^^^^^ help: remove the `ceil` method call: `1f32`
+   |
+   = note: `-D clippy::unused-rounding` implied by `-D warnings`
+
+error: used the `floor` method with a whole number float
+  --> $DIR/unused_rounding.rs:6:13
+   |
+LL |     let _ = 1.0f64.floor();
+   |             ^^^^^^^^^^^^^^ help: remove the `floor` method call: `1.0f64`
+
+error: used the `round` method with a whole number float
+  --> $DIR/unused_rounding.rs:7:13
+   |
+LL |     let _ = 1.00f32.round();
+   |             ^^^^^^^^^^^^^^^ help: remove the `round` method call: `1.00f32`
+
+error: aborting due to 3 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 4de301e394d99b391de6e449e4dbf44d771d0486 Mon Sep 17 00:00:00 2001
From: Micha White <botahamec@outlook.com>
Date: Sun, 22 May 2022 17:21:04 -0400
Subject: Fixed the test to not use an epsilon

---
 clippy_lints/src/unused_rounding.rs | 2 +-
 tests/ui/unused_rounding.fixed      | 1 +
 tests/ui/unused_rounding.rs         | 1 +
 3 files changed, 3 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unused_rounding.rs b/clippy_lints/src/unused_rounding.rs
index 7706a338eb2..3ee5d7a32a3 100644
--- a/clippy_lints/src/unused_rounding.rs
+++ b/clippy_lints/src/unused_rounding.rs
@@ -42,7 +42,7 @@ fn is_useless_rounding(expr: &Expr) -> Option<(&str, String)> {
             } else {
                 ""
             };
-            if f.fract() < f64::EPSILON {
+            if f.fract() == 0.0 {
                 Some((method_name, f_str))
             } else {
                 None
diff --git a/tests/ui/unused_rounding.fixed b/tests/ui/unused_rounding.fixed
index a1cb80413d2..54f85806ac3 100644
--- a/tests/ui/unused_rounding.fixed
+++ b/tests/ui/unused_rounding.fixed
@@ -5,4 +5,5 @@ fn main() {
     let _ = 1f32;
     let _ = 1.0f64;
     let _ = 1.00f32;
+    let _ = 2e-54f64.floor();
 }
diff --git a/tests/ui/unused_rounding.rs b/tests/ui/unused_rounding.rs
index 90af8f19dd9..8d007bc4a1d 100644
--- a/tests/ui/unused_rounding.rs
+++ b/tests/ui/unused_rounding.rs
@@ -5,4 +5,5 @@ fn main() {
     let _ = 1f32.ceil();
     let _ = 1.0f64.floor();
     let _ = 1.00f32.round();
+    let _ = 2e-54f64.floor();
 }
-- 
cgit 1.4.1-3-g733a5


From f489954e3e6c7b15fd243d33bdd9eabdf90161b6 Mon Sep 17 00:00:00 2001
From: Micha White <botahamec@outlook.com>
Date: Sun, 22 May 2022 17:22:10 -0400
Subject: Changed the lint description

---
 clippy_lints/src/unused_rounding.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unused_rounding.rs b/clippy_lints/src/unused_rounding.rs
index 3ee5d7a32a3..306afe44148 100644
--- a/clippy_lints/src/unused_rounding.rs
+++ b/clippy_lints/src/unused_rounding.rs
@@ -25,7 +25,7 @@ declare_clippy_lint! {
     #[clippy::version = "1.62.0"]
     pub UNUSED_ROUNDING,
     nursery,
-    "Rounding a whole number literal, which is useless"
+    "Uselessly rounding a whole number floating-point literal"
 }
 declare_lint_pass!(UnusedRounding => [UNUSED_ROUNDING]);
 
-- 
cgit 1.4.1-3-g733a5


From 45be175eeba9b8cc39417cd09216d88a544c4830 Mon Sep 17 00:00:00 2001
From: Serial <69764315+Serial-ATA@users.noreply.github.com>
Date: Thu, 19 May 2022 10:49:32 -0400
Subject: Collect renamed lints

---
 .../src/utils/internal_lints/metadata_collector.rs | 55 ++++++++++++++++++++--
 1 file changed, 52 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index 8c1910b3b2a..7c6263db0de 100644
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -7,6 +7,7 @@
 //! during any comparison or mapping. (Please take care of this, it's not fun to spend time on such
 //! a simple mistake)
 
+use crate::renamed_lints::RENAMED_LINTS;
 use crate::utils::internal_lints::{extract_clippy_version_value, is_lint_ref_type};
 
 use clippy_utils::diagnostics::span_lint;
@@ -26,6 +27,7 @@ use rustc_span::{sym, Loc, Span, Symbol};
 use serde::{ser::SerializeStruct, Serialize, Serializer};
 use std::collections::BinaryHeap;
 use std::fmt;
+use std::fmt::Write as _;
 use std::fs::{self, OpenOptions};
 use std::io::prelude::*;
 use std::path::Path;
@@ -85,6 +87,21 @@ macro_rules! CONFIGURATION_VALUE_TEMPLATE {
     };
 }
 
+macro_rules! RENAMES_SECTION_TEMPLATE {
+    () => {
+        r#"
+### Past names
+
+{names}
+"#
+    };
+}
+macro_rules! RENAME_VALUE_TEMPLATE {
+    () => {
+        "* `{name}`\n"
+    };
+}
+
 const LINT_EMISSION_FUNCTIONS: [&[&str]; 8] = [
     &["clippy_utils", "diagnostics", "span_lint"],
     &["clippy_utils", "diagnostics", "span_lint_and_help"],
@@ -198,9 +215,10 @@ impl Drop for MetadataCollector {
 
         // Mapping the final data
         let mut lints = std::mem::take(&mut self.lints).into_sorted_vec();
-        lints
-            .iter_mut()
-            .for_each(|x| x.applicability = Some(applicability_info.remove(&x.id).unwrap_or_default()));
+        collect_renames(&mut lints);
+        for x in &mut lints {
+            x.applicability = Some(applicability_info.remove(&x.id).unwrap_or_default());
+        }
 
         // Outputting
         if Path::new(OUTPUT_FILE).exists() {
@@ -643,6 +661,37 @@ fn is_deprecated_lint(cx: &LateContext<'_>, ty: &hir::Ty<'_>) -> bool {
     false
 }
 
+fn collect_renames(lints: &mut Vec<LintMetadata>) {
+    for lint in lints {
+        let mut collected = String::new();
+        let mut names = vec![lint.id.clone()];
+
+        loop {
+            if let Some(lint_name) = names.pop() {
+                for (k, v) in RENAMED_LINTS {
+                    if_chain! {
+                        if let Some(name) = v.strip_prefix(CLIPPY_LINT_GROUP_PREFIX);
+                        if name == lint_name;
+                        if let Some(past_name) = k.strip_prefix(CLIPPY_LINT_GROUP_PREFIX);
+                        then {
+                            write!(collected, RENAME_VALUE_TEMPLATE!(), name = past_name).unwrap();
+                            names.push(past_name.to_string());
+                        }
+                    }
+                }
+
+                continue;
+            }
+
+            break;
+        }
+
+        if !collected.is_empty() {
+            write!(&mut lint.docs, RENAMES_SECTION_TEMPLATE!(), names = collected).unwrap();
+        }
+    }
+}
+
 // ==================================================================
 // Lint emission
 // ==================================================================
-- 
cgit 1.4.1-3-g733a5


From 1c573c7f1849ecbef1818d862115bd512dcb9cdb Mon Sep 17 00:00:00 2001
From: Serial <69764315+Serial-ATA@users.noreply.github.com>
Date: Wed, 25 May 2022 17:37:57 -0400
Subject: Remove newlines in [`match_str_case_mismatch`] example

---
 clippy_lints/src/match_str_case_mismatch.rs | 2 --
 1 file changed, 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/match_str_case_mismatch.rs b/clippy_lints/src/match_str_case_mismatch.rs
index 85aec93670b..d97a878825a 100644
--- a/clippy_lints/src/match_str_case_mismatch.rs
+++ b/clippy_lints/src/match_str_case_mismatch.rs
@@ -21,7 +21,6 @@ declare_clippy_lint! {
     /// ### Example
     /// ```rust
     /// # let text = "Foo";
-    ///
     /// match &*text.to_ascii_lowercase() {
     ///     "foo" => {},
     ///     "Bar" => {},
@@ -31,7 +30,6 @@ declare_clippy_lint! {
     /// Use instead:
     /// ```rust
     /// # let text = "Foo";
-    ///
     /// match &*text.to_ascii_lowercase() {
     ///     "foo" => {},
     ///     "bar" => {},
-- 
cgit 1.4.1-3-g733a5


From 9ee211af9fb04802a23be3557c606d833e288d82 Mon Sep 17 00:00:00 2001
From: "Samuel E. Moelius III" <sam@moeli.us>
Date: Wed, 25 May 2022 19:22:44 -0400
Subject: Fix `empty_line_after_outer_attribute` false positive

---
 Cargo.toml                                       |  1 +
 clippy_lints/src/attrs.rs                        | 23 ++++++++++++++++++-----
 tests/compile-test.rs                            |  8 ++++++--
 tests/ui/empty_line_after_outer_attribute.rs     | 10 ++++++++++
 tests/ui/empty_line_after_outer_attribute.stderr | 12 ++++++------
 5 files changed, 41 insertions(+), 13 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/Cargo.toml b/Cargo.toml
index 3c8b758d53d..d23d681df00 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -40,6 +40,7 @@ filetime = "0.2"
 rustc-workspace-hack = "1.0"
 
 # UI test dependencies
+clap = { version = "3.1", features = ["derive"] }
 clippy_utils = { path = "clippy_utils" }
 derive-new = "0.5"
 if_chain = "1.0"
diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs
index 3de91f3d24a..7105ce4b292 100644
--- a/clippy_lints/src/attrs.rs
+++ b/clippy_lints/src/attrs.rs
@@ -585,15 +585,21 @@ impl EarlyLintPass for EarlyAttributes {
 }
 
 fn check_empty_line_after_outer_attr(cx: &EarlyContext<'_>, item: &rustc_ast::Item) {
-    for attr in &item.attrs {
+    let mut iter = item.attrs.iter().peekable();
+    while let Some(attr) = iter.next() {
         if matches!(attr.kind, AttrKind::Normal(..))
             && attr.style == AttrStyle::Outer
             && is_present_in_source(cx, attr.span)
         {
             let begin_of_attr_to_item = Span::new(attr.span.lo(), item.span.lo(), item.span.ctxt(), item.span.parent());
-            let end_of_attr_to_item = Span::new(attr.span.hi(), item.span.lo(), item.span.ctxt(), item.span.parent());
+            let end_of_attr_to_next_attr_or_item = Span::new(
+                attr.span.hi(),
+                iter.peek().map_or(item.span.lo(), |next_attr| next_attr.span.lo()),
+                item.span.ctxt(),
+                item.span.parent(),
+            );
 
-            if let Some(snippet) = snippet_opt(cx, end_of_attr_to_item) {
+            if let Some(snippet) = snippet_opt(cx, end_of_attr_to_next_attr_or_item) {
                 let lines = snippet.split('\n').collect::<Vec<_>>();
                 let lines = without_block_comments(lines);
 
@@ -623,8 +629,15 @@ fn check_deprecated_cfg_attr(cx: &EarlyContext<'_>, attr: &Attribute, msrv: Opti
         if feature_item.has_name(sym::rustfmt);
         // check for `rustfmt_skip` and `rustfmt::skip`
         if let Some(skip_item) = &items[1].meta_item();
-        if skip_item.has_name(sym!(rustfmt_skip)) ||
-            skip_item.path.segments.last().expect("empty path in attribute").ident.name == sym::skip;
+        if skip_item.has_name(sym!(rustfmt_skip))
+            || skip_item
+                .path
+                .segments
+                .last()
+                .expect("empty path in attribute")
+                .ident
+                .name
+                == sym::skip;
         // Only lint outer attributes, because custom inner attributes are unstable
         // Tracking issue: https://github.com/rust-lang/rust/issues/54726
         if attr.style == AttrStyle::Outer;
diff --git a/tests/compile-test.rs b/tests/compile-test.rs
index c9710e3db8e..18099c45fee 100644
--- a/tests/compile-test.rs
+++ b/tests/compile-test.rs
@@ -22,6 +22,7 @@ const RUN_INTERNAL_TESTS: bool = cfg!(feature = "internal");
 
 /// All crates used in UI tests are listed here
 static TEST_DEPENDENCIES: &[&str] = &[
+    "clap",
     "clippy_utils",
     "derive_new",
     "futures",
@@ -40,6 +41,8 @@ static TEST_DEPENDENCIES: &[&str] = &[
 // Test dependencies may need an `extern crate` here to ensure that they show up
 // in the depinfo file (otherwise cargo thinks they are unused)
 #[allow(unused_extern_crates)]
+extern crate clap;
+#[allow(unused_extern_crates)]
 extern crate clippy_utils;
 #[allow(unused_extern_crates)]
 extern crate derive_new;
@@ -109,8 +112,9 @@ static EXTERN_FLAGS: SyncLazy<String> = SyncLazy::new(|| {
         not_found.is_empty(),
         "dependencies not found in depinfo: {:?}\n\
         help: Make sure the `-Z binary-dep-depinfo` rust flag is enabled\n\
-        help: Try adding to dev-dependencies in Cargo.toml",
-        not_found
+        help: Try adding to dev-dependencies in Cargo.toml\n\
+        help: Be sure to also add `extern crate ...;` to tests/compile-test.rs",
+        not_found,
     );
     crates
         .into_iter()
diff --git a/tests/ui/empty_line_after_outer_attribute.rs b/tests/ui/empty_line_after_outer_attribute.rs
index 3e92bca986a..d15c84d7438 100644
--- a/tests/ui/empty_line_after_outer_attribute.rs
+++ b/tests/ui/empty_line_after_outer_attribute.rs
@@ -4,6 +4,9 @@
 #![feature(custom_inner_attributes)]
 #![rustfmt::skip]
 
+#[macro_use]
+extern crate clap;
+
 #[macro_use]
 extern crate proc_macro_attr;
 
@@ -110,4 +113,11 @@ pub trait Bazz {
     }
 }
 
+#[derive(clap::Parser)]
+#[clap(after_help = "This ia a help message.
+
+You're welcome.
+")]
+pub struct Args;
+
 fn main() {}
diff --git a/tests/ui/empty_line_after_outer_attribute.stderr b/tests/ui/empty_line_after_outer_attribute.stderr
index 594fca44a32..acc3edef9b9 100644
--- a/tests/ui/empty_line_after_outer_attribute.stderr
+++ b/tests/ui/empty_line_after_outer_attribute.stderr
@@ -1,5 +1,5 @@
 error: found an empty line after an outer attribute. Perhaps you forgot to add a `!` to make it an inner attribute?
-  --> $DIR/empty_line_after_outer_attribute.rs:11:1
+  --> $DIR/empty_line_after_outer_attribute.rs:14:1
    |
 LL | / #[crate_type = "lib"]
 LL | |
@@ -10,7 +10,7 @@ LL | | fn with_one_newline_and_comment() { assert!(true) }
    = note: `-D clippy::empty-line-after-outer-attr` implied by `-D warnings`
 
 error: found an empty line after an outer attribute. Perhaps you forgot to add a `!` to make it an inner attribute?
-  --> $DIR/empty_line_after_outer_attribute.rs:23:1
+  --> $DIR/empty_line_after_outer_attribute.rs:26:1
    |
 LL | / #[crate_type = "lib"]
 LL | |
@@ -18,7 +18,7 @@ LL | | fn with_one_newline() { assert!(true) }
    | |_
 
 error: found an empty line after an outer attribute. Perhaps you forgot to add a `!` to make it an inner attribute?
-  --> $DIR/empty_line_after_outer_attribute.rs:28:1
+  --> $DIR/empty_line_after_outer_attribute.rs:31:1
    |
 LL | / #[crate_type = "lib"]
 LL | |
@@ -27,7 +27,7 @@ LL | | fn with_two_newlines() { assert!(true) }
    | |_
 
 error: found an empty line after an outer attribute. Perhaps you forgot to add a `!` to make it an inner attribute?
-  --> $DIR/empty_line_after_outer_attribute.rs:35:1
+  --> $DIR/empty_line_after_outer_attribute.rs:38:1
    |
 LL | / #[crate_type = "lib"]
 LL | |
@@ -35,7 +35,7 @@ LL | | enum Baz {
    | |_
 
 error: found an empty line after an outer attribute. Perhaps you forgot to add a `!` to make it an inner attribute?
-  --> $DIR/empty_line_after_outer_attribute.rs:43:1
+  --> $DIR/empty_line_after_outer_attribute.rs:46:1
    |
 LL | / #[crate_type = "lib"]
 LL | |
@@ -43,7 +43,7 @@ LL | | struct Foo {
    | |_
 
 error: found an empty line after an outer attribute. Perhaps you forgot to add a `!` to make it an inner attribute?
-  --> $DIR/empty_line_after_outer_attribute.rs:51:1
+  --> $DIR/empty_line_after_outer_attribute.rs:54:1
    |
 LL | / #[crate_type = "lib"]
 LL | |
-- 
cgit 1.4.1-3-g733a5


From ea06a414f1379e4470a5766b6587e610341081b7 Mon Sep 17 00:00:00 2001
From: tamaron <tamaron1203@gmail.com>
Date: Fri, 27 May 2022 01:30:44 +0900
Subject: fix

---
 clippy_lints/src/dbg_macro.rs                      |  21 ++++-
 clippy_lints/src/lib.rs                            |   3 +-
 clippy_lints/src/utils/conf.rs                     |   4 +
 tests/ui-toml/dbg_macro/clippy.toml                |   1 +
 tests/ui-toml/dbg_macro/dbg_macro.rs               |  39 ++++++++
 tests/ui-toml/dbg_macro/dbg_macro.stderr           | 102 +++++++++++++++++++++
 .../toml_unknown_key/conf_unknown_key.stderr       |   1 +
 tests/ui/dbg_macro.stderr                          |  35 ++++++-
 8 files changed, 200 insertions(+), 6 deletions(-)
 create mode 100644 tests/ui-toml/dbg_macro/clippy.toml
 create mode 100644 tests/ui-toml/dbg_macro/dbg_macro.rs
 create mode 100644 tests/ui-toml/dbg_macro/dbg_macro.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/dbg_macro.rs b/clippy_lints/src/dbg_macro.rs
index f99d793c201..17deccf8c39 100644
--- a/clippy_lints/src/dbg_macro.rs
+++ b/clippy_lints/src/dbg_macro.rs
@@ -5,7 +5,7 @@ use clippy_utils::{is_in_cfg_test, is_in_test_function};
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::sym;
 
 declare_clippy_lint! {
@@ -30,14 +30,27 @@ declare_clippy_lint! {
     "`dbg!` macro is intended as a debugging tool"
 }
 
-declare_lint_pass!(DbgMacro => [DBG_MACRO]);
+#[derive(Copy, Clone)]
+pub struct DbgMacro {
+    allow_dbg_in_tests: bool,
+}
+
+impl_lint_pass!(DbgMacro => [DBG_MACRO]);
+
+impl DbgMacro {
+    pub fn new(allow_dbg_in_tests: bool) -> Self {
+        DbgMacro { allow_dbg_in_tests }
+    }
+}
 
 impl LateLintPass<'_> for DbgMacro {
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
         let Some(macro_call) = root_macro_call_first_node(cx, expr) else { return };
         if cx.tcx.is_diagnostic_item(sym::dbg_macro, macro_call.def_id) {
-            // we make an exception for test code
-            if is_in_test_function(cx.tcx, expr.hir_id) || is_in_cfg_test(cx.tcx, expr.hir_id) {
+            // allows `dbg!` in test code if allow-dbg-in-test is set to true in clippy.toml
+            if self.allow_dbg_in_tests
+                && (is_in_test_function(cx.tcx, expr.hir_id) || is_in_cfg_test(cx.tcx, expr.hir_id))
+            {
                 return;
             }
             let mut applicability = Applicability::MachineApplicable;
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 09435b06d0a..ffbf9a65917 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -888,7 +888,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(default_union_representation::DefaultUnionRepresentation));
     store.register_late_pass(|| Box::new(only_used_in_recursion::OnlyUsedInRecursion));
     store.register_late_pass(|| Box::new(significant_drop_in_scrutinee::SignificantDropInScrutinee));
-    store.register_late_pass(|| Box::new(dbg_macro::DbgMacro));
+    let allow_dbg_in_tests = conf.allow_dbg_in_tests;
+    store.register_late_pass(move || Box::new(dbg_macro::DbgMacro::new(allow_dbg_in_tests)));
     let cargo_ignore_publish = conf.cargo_ignore_publish;
     store.register_late_pass(move || {
         Box::new(cargo::Cargo {
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index cd4d16fe95f..b5c5d35135f 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -340,6 +340,10 @@ define_Conf! {
     ///
     /// Whether `unwrap` should be allowed in test functions
     (allow_unwrap_in_tests: bool = false),
+    /// Lint: DBG_MACRO.
+    ///
+    /// Whether `dbg!` should be allowed in test functions
+    (allow_dbg_in_tests: bool = false),
 }
 
 /// Search for the configuration file.
diff --git a/tests/ui-toml/dbg_macro/clippy.toml b/tests/ui-toml/dbg_macro/clippy.toml
new file mode 100644
index 00000000000..4296655a040
--- /dev/null
+++ b/tests/ui-toml/dbg_macro/clippy.toml
@@ -0,0 +1 @@
+allow-dbg-in-tests = true
diff --git a/tests/ui-toml/dbg_macro/dbg_macro.rs b/tests/ui-toml/dbg_macro/dbg_macro.rs
new file mode 100644
index 00000000000..5d9ce18f631
--- /dev/null
+++ b/tests/ui-toml/dbg_macro/dbg_macro.rs
@@ -0,0 +1,39 @@
+// compile-flags: --test
+#![warn(clippy::dbg_macro)]
+
+fn foo(n: u32) -> u32 {
+    if let Some(n) = dbg!(n.checked_sub(4)) { n } else { n }
+}
+
+fn factorial(n: u32) -> u32 {
+    if dbg!(n <= 1) {
+        dbg!(1)
+    } else {
+        dbg!(n * factorial(n - 1))
+    }
+}
+
+fn main() {
+    dbg!(42);
+    dbg!(dbg!(dbg!(42)));
+    foo(3) + dbg!(factorial(4));
+    dbg!(1, 2, dbg!(3, 4));
+    dbg!(1, 2, 3, 4, 5);
+}
+
+#[test]
+pub fn issue8481() {
+    dbg!(1);
+}
+
+#[cfg(test)]
+fn foo2() {
+    dbg!(1);
+}
+
+#[cfg(test)]
+mod mod1 {
+    fn func() {
+        dbg!(1);
+    }
+}
diff --git a/tests/ui-toml/dbg_macro/dbg_macro.stderr b/tests/ui-toml/dbg_macro/dbg_macro.stderr
new file mode 100644
index 00000000000..46efb86dcfc
--- /dev/null
+++ b/tests/ui-toml/dbg_macro/dbg_macro.stderr
@@ -0,0 +1,102 @@
+error: `dbg!` macro is intended as a debugging tool
+  --> $DIR/dbg_macro.rs:5:22
+   |
+LL |     if let Some(n) = dbg!(n.checked_sub(4)) { n } else { n }
+   |                      ^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::dbg-macro` implied by `-D warnings`
+help: ensure to avoid having uses of it in version control
+   |
+LL |     if let Some(n) = n.checked_sub(4) { n } else { n }
+   |                      ~~~~~~~~~~~~~~~~
+
+error: `dbg!` macro is intended as a debugging tool
+  --> $DIR/dbg_macro.rs:9:8
+   |
+LL |     if dbg!(n <= 1) {
+   |        ^^^^^^^^^^^^
+   |
+help: ensure to avoid having uses of it in version control
+   |
+LL |     if n <= 1 {
+   |        ~~~~~~
+
+error: `dbg!` macro is intended as a debugging tool
+  --> $DIR/dbg_macro.rs:10:9
+   |
+LL |         dbg!(1)
+   |         ^^^^^^^
+   |
+help: ensure to avoid having uses of it in version control
+   |
+LL |         1
+   |
+
+error: `dbg!` macro is intended as a debugging tool
+  --> $DIR/dbg_macro.rs:12:9
+   |
+LL |         dbg!(n * factorial(n - 1))
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: ensure to avoid having uses of it in version control
+   |
+LL |         n * factorial(n - 1)
+   |
+
+error: `dbg!` macro is intended as a debugging tool
+  --> $DIR/dbg_macro.rs:17:5
+   |
+LL |     dbg!(42);
+   |     ^^^^^^^^
+   |
+help: ensure to avoid having uses of it in version control
+   |
+LL |     42;
+   |     ~~
+
+error: `dbg!` macro is intended as a debugging tool
+  --> $DIR/dbg_macro.rs:18:5
+   |
+LL |     dbg!(dbg!(dbg!(42)));
+   |     ^^^^^^^^^^^^^^^^^^^^
+   |
+help: ensure to avoid having uses of it in version control
+   |
+LL |     dbg!(dbg!(42));
+   |     ~~~~~~~~~~~~~~
+
+error: `dbg!` macro is intended as a debugging tool
+  --> $DIR/dbg_macro.rs:19:14
+   |
+LL |     foo(3) + dbg!(factorial(4));
+   |              ^^^^^^^^^^^^^^^^^^
+   |
+help: ensure to avoid having uses of it in version control
+   |
+LL |     foo(3) + factorial(4);
+   |              ~~~~~~~~~~~~
+
+error: `dbg!` macro is intended as a debugging tool
+  --> $DIR/dbg_macro.rs:20:5
+   |
+LL |     dbg!(1, 2, dbg!(3, 4));
+   |     ^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: ensure to avoid having uses of it in version control
+   |
+LL |     (1, 2, dbg!(3, 4));
+   |     ~~~~~~~~~~~~~~~~~~
+
+error: `dbg!` macro is intended as a debugging tool
+  --> $DIR/dbg_macro.rs:21:5
+   |
+LL |     dbg!(1, 2, 3, 4, 5);
+   |     ^^^^^^^^^^^^^^^^^^^
+   |
+help: ensure to avoid having uses of it in version control
+   |
+LL |     (1, 2, 3, 4, 5);
+   |     ~~~~~~~~~~~~~~~
+
+error: aborting due to 9 previous errors
+
diff --git a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
index 92838aa57df..1d87fd91a25 100644
--- a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
+++ b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
@@ -1,4 +1,5 @@
 error: error reading Clippy's configuration file `$DIR/clippy.toml`: unknown field `foobar`, expected one of
+           allow-dbg-in-tests
            allow-expect-in-tests
            allow-unwrap-in-tests
            allowed-scripts
diff --git a/tests/ui/dbg_macro.stderr b/tests/ui/dbg_macro.stderr
index a3e7a7162e5..e6a65b46d97 100644
--- a/tests/ui/dbg_macro.stderr
+++ b/tests/ui/dbg_macro.stderr
@@ -109,5 +109,38 @@ help: ensure to avoid having uses of it in version control
 LL |         2;
    |         ~
 
-error: aborting due to 10 previous errors
+error: `dbg!` macro is intended as a debugging tool
+  --> $DIR/dbg_macro.rs:47:5
+   |
+LL |     dbg!(1);
+   |     ^^^^^^^
+   |
+help: ensure to avoid having uses of it in version control
+   |
+LL |     1;
+   |     ~
+
+error: `dbg!` macro is intended as a debugging tool
+  --> $DIR/dbg_macro.rs:52:5
+   |
+LL |     dbg!(1);
+   |     ^^^^^^^
+   |
+help: ensure to avoid having uses of it in version control
+   |
+LL |     1;
+   |     ~
+
+error: `dbg!` macro is intended as a debugging tool
+  --> $DIR/dbg_macro.rs:58:9
+   |
+LL |         dbg!(1);
+   |         ^^^^^^^
+   |
+help: ensure to avoid having uses of it in version control
+   |
+LL |         1;
+   |         ~
+
+error: aborting due to 13 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 7975d41a915b7e2c0b5ce2e2ca47ab31b96d978a Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Thu, 26 May 2022 13:57:05 -0400
Subject: Rework `branches_sharing_code`

---
 clippy_lints/src/copies.rs                         | 675 +++++++++------------
 clippy_utils/src/hir_utils.rs                      |  14 +-
 clippy_utils/src/lib.rs                            |   4 +-
 tests/ui/branches_sharing_code/false_positives.rs  |  15 +-
 .../branches_sharing_code/shared_at_bottom.stderr  |  28 +-
 .../ui/branches_sharing_code/shared_at_top.stderr  |  18 +-
 .../shared_at_top_and_bottom.stderr                |  48 +-
 7 files changed, 355 insertions(+), 447 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/copies.rs b/clippy_lints/src/copies.rs
index e6a0162fd02..b18eba1156a 100644
--- a/clippy_lints/src/copies.rs
+++ b/clippy_lints/src/copies.rs
@@ -1,18 +1,18 @@
 use clippy_utils::diagnostics::{span_lint_and_note, span_lint_and_then};
 use clippy_utils::source::{first_line_of_span, indent_of, reindent_multiline, snippet, snippet_opt};
 use clippy_utils::{
-    both, count_eq, eq_expr_value, get_enclosing_block, get_parent_expr, if_sequence, is_else_clause, is_lint_allowed,
-    search_same, ContainsName, SpanlessEq, SpanlessHash,
+    eq_expr_value, get_enclosing_block, hash_expr, hash_stmt, if_sequence, is_else_clause, is_lint_allowed,
+    search_same, ContainsName, HirEqInterExpr, SpanlessEq,
 };
-use if_chain::if_chain;
-use rustc_data_structures::fx::FxHashSet;
-use rustc_errors::{Applicability, Diagnostic};
-use rustc_hir::intravisit::{self, Visitor};
-use rustc_hir::{Block, Expr, ExprKind, HirId};
-use rustc_lint::{LateContext, LateLintPass, LintContext};
-use rustc_middle::hir::nested_filter;
+use core::iter;
+use rustc_errors::Applicability;
+use rustc_hir::intravisit;
+use rustc_hir::{BinOpKind, Block, Expr, ExprKind, HirId, Stmt, StmtKind};
+use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::{source_map::Span, symbol::Symbol, BytePos};
+use rustc_span::hygiene::walk_chain;
+use rustc_span::source_map::SourceMap;
+use rustc_span::{BytePos, Span, Symbol};
 use std::borrow::Cow;
 
 declare_clippy_lint! {
@@ -165,243 +165,315 @@ declare_lint_pass!(CopyAndPaste => [
 
 impl<'tcx> LateLintPass<'tcx> for CopyAndPaste {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if !expr.span.from_expansion() {
-            if let ExprKind::If(_, _, _) = expr.kind {
-                // skip ifs directly in else, it will be checked in the parent if
-                if let Some(&Expr {
-                    kind: ExprKind::If(_, _, Some(else_expr)),
-                    ..
-                }) = get_parent_expr(cx, expr)
-                {
-                    if else_expr.hir_id == expr.hir_id {
-                        return;
-                    }
-                }
-
-                let (conds, blocks) = if_sequence(expr);
-                // Conditions
-                lint_same_cond(cx, &conds);
-                lint_same_fns_in_if_cond(cx, &conds);
-                // Block duplication
-                lint_same_then_else(cx, &conds, &blocks, conds.len() == blocks.len(), expr);
+        if !expr.span.from_expansion() && matches!(expr.kind, ExprKind::If(..)) && !is_else_clause(cx.tcx, expr) {
+            let (conds, blocks) = if_sequence(expr);
+            lint_same_cond(cx, &conds);
+            lint_same_fns_in_if_cond(cx, &conds);
+            let all_same =
+                !is_lint_allowed(cx, IF_SAME_THEN_ELSE, expr.hir_id) && lint_if_same_then_else(cx, &conds, &blocks);
+            if !all_same && conds.len() != blocks.len() {
+                lint_branches_sharing_code(cx, &conds, &blocks, expr);
             }
         }
     }
 }
 
-/// Implementation of `BRANCHES_SHARING_CODE` and `IF_SAME_THEN_ELSE` if the blocks are equal.
-fn lint_same_then_else<'tcx>(
+/// Checks if the given expression is a let chain.
+fn contains_let(e: &Expr<'_>) -> bool {
+    match e.kind {
+        ExprKind::Let(..) => true,
+        ExprKind::Binary(op, lhs, rhs) if op.node == BinOpKind::And => {
+            matches!(lhs.kind, ExprKind::Let(..)) || contains_let(rhs)
+        },
+        _ => false,
+    }
+}
+
+fn lint_if_same_then_else(cx: &LateContext<'_>, conds: &[&Expr<'_>], blocks: &[&Block<'_>]) -> bool {
+    let mut eq = SpanlessEq::new(cx);
+    blocks
+        .array_windows::<2>()
+        .enumerate()
+        .fold(true, |all_eq, (i, &[lhs, rhs])| {
+            if eq.eq_block(lhs, rhs) && !contains_let(conds[i]) && conds.get(i + 1).map_or(true, |e| !contains_let(e)) {
+                span_lint_and_note(
+                    cx,
+                    IF_SAME_THEN_ELSE,
+                    lhs.span,
+                    "this `if` has identical blocks",
+                    Some(rhs.span),
+                    "same as this",
+                );
+                all_eq
+            } else {
+                false
+            }
+        })
+}
+
+fn lint_branches_sharing_code<'tcx>(
     cx: &LateContext<'tcx>,
     conds: &[&'tcx Expr<'_>],
     blocks: &[&Block<'tcx>],
-    has_conditional_else: bool,
     expr: &'tcx Expr<'_>,
 ) {
     // We only lint ifs with multiple blocks
-    if blocks.len() < 2 || is_else_clause(cx.tcx, expr) {
-        return;
-    }
-
-    // Check if each block has shared code
-    let has_expr = blocks[0].expr.is_some();
-
-    let (start_eq, mut end_eq, expr_eq) = if let Some(block_eq) = scan_block_for_eq(cx, conds, blocks) {
-        (block_eq.start_eq, block_eq.end_eq, block_eq.expr_eq)
-    } else {
+    let &[first_block, ref blocks @ ..] = blocks else {
         return;
     };
-
-    // BRANCHES_SHARING_CODE prerequisites
-    if has_conditional_else || (start_eq == 0 && end_eq == 0 && (has_expr && !expr_eq)) {
+    let &[.., last_block] = blocks else {
         return;
-    }
-
-    // Only the start is the same
-    if start_eq != 0 && end_eq == 0 && (!has_expr || !expr_eq) {
-        let block = blocks[0];
-        let start_stmts = block.stmts.split_at(start_eq).0;
-
-        let mut start_walker = UsedValueFinderVisitor::new(cx);
-        for stmt in start_stmts {
-            intravisit::walk_stmt(&mut start_walker, stmt);
-        }
+    };
 
-        emit_branches_sharing_code_lint(
-            cx,
-            start_eq,
-            0,
-            false,
-            check_for_warn_of_moved_symbol(cx, &start_walker.def_symbols, expr),
-            blocks,
-            expr,
-        );
-    } else if end_eq != 0 || (has_expr && expr_eq) {
-        let block = blocks[blocks.len() - 1];
-        let (start_stmts, block_stmts) = block.stmts.split_at(start_eq);
-        let (block_stmts, end_stmts) = block_stmts.split_at(block_stmts.len() - end_eq);
+    let res = scan_block_for_eq(cx, conds, first_block, blocks);
+    let sm = cx.tcx.sess.source_map();
+    let start_suggestion = res.start_span(first_block, sm).map(|span| {
+        let first_line_span = first_line_of_span(cx, expr.span);
+        let replace_span = first_line_span.with_hi(span.hi());
+        let cond_span = first_line_span.until(first_block.span);
+        let cond_snippet = reindent_multiline(snippet(cx, cond_span, "_"), false, None);
+        let cond_indent = indent_of(cx, cond_span);
+        let moved_snippet = reindent_multiline(snippet(cx, span, "_"), true, None);
+        let suggestion = moved_snippet.to_string() + "\n" + &cond_snippet + "{";
+        let suggestion = reindent_multiline(Cow::Borrowed(&suggestion), true, cond_indent);
+        (replace_span, suggestion.to_string())
+    });
+    let end_suggestion = res.end_span(last_block, sm).map(|span| {
+        let moved_snipped = reindent_multiline(snippet(cx, span, "_"), true, None);
+        let indent = indent_of(cx, expr.span.shrink_to_hi());
+        let suggestion = "}\n".to_string() + &moved_snipped;
+        let suggestion = reindent_multiline(Cow::Borrowed(&suggestion), true, indent);
 
-        // Scan start
-        let mut start_walker = UsedValueFinderVisitor::new(cx);
-        for stmt in start_stmts {
-            intravisit::walk_stmt(&mut start_walker, stmt);
+        let span = span.with_hi(last_block.span.hi());
+        // Improve formatting if the inner block has indention (i.e. normal Rust formatting)
+        let test_span = Span::new(span.lo() - BytePos(4), span.lo(), span.ctxt(), span.parent());
+        let span = if snippet_opt(cx, test_span).map_or(false, |snip| snip == "    ") {
+            span.with_lo(test_span.lo())
+        } else {
+            span
+        };
+        (span, suggestion.to_string())
+    });
+
+    let (span, msg, end_span) = match (&start_suggestion, &end_suggestion) {
+        (&Some((span, _)), &Some((end_span, _))) => (
+            span,
+            "all if blocks contain the same code at both the start and the end",
+            Some(end_span),
+        ),
+        (&Some((span, _)), None) => (span, "all if blocks contain the same code at the start", None),
+        (None, &Some((span, _))) => (span, "all if blocks contain the same code at the end", None),
+        (None, None) => return,
+    };
+    span_lint_and_then(cx, BRANCHES_SHARING_CODE, span, msg, |diag| {
+        if let Some(span) = end_span {
+            diag.span_note(span, "this code is shared at the end");
         }
-        let mut moved_syms = start_walker.def_symbols;
-
-        // Scan block
-        let mut block_walker = UsedValueFinderVisitor::new(cx);
-        for stmt in block_stmts {
-            intravisit::walk_stmt(&mut block_walker, stmt);
+        if let Some((span, sugg)) = start_suggestion {
+            diag.span_suggestion(
+                span,
+                "consider moving these statements before the if",
+                sugg,
+                Applicability::Unspecified,
+            );
         }
-        let mut block_defs = block_walker.defs;
-
-        // Scan moved stmts
-        let mut moved_start: Option<usize> = None;
-        let mut end_walker = UsedValueFinderVisitor::new(cx);
-        for (index, stmt) in end_stmts.iter().enumerate() {
-            intravisit::walk_stmt(&mut end_walker, stmt);
-
-            for value in &end_walker.uses {
-                // Well we can't move this and all prev statements. So reset
-                if block_defs.contains(value) {
-                    moved_start = Some(index + 1);
-                    end_walker.defs.drain().for_each(|x| {
-                        block_defs.insert(x);
-                    });
-
-                    end_walker.def_symbols.clear();
-                }
+        if let Some((span, sugg)) = end_suggestion {
+            diag.span_suggestion(
+                span,
+                "consider moving these statements after the if",
+                sugg,
+                Applicability::Unspecified,
+            );
+            if !cx.typeck_results().expr_ty(expr).is_unit() {
+                diag.note("the end suggestion probably needs some adjustments to use the expression result correctly");
             }
-
-            end_walker.uses.clear();
         }
-
-        if let Some(moved_start) = moved_start {
-            end_eq -= moved_start;
+        if check_for_warn_of_moved_symbol(cx, &res.moved_locals, expr) {
+            diag.warn("some moved values might need to be renamed to avoid wrong references");
         }
+    });
+}
 
-        let end_linable = block.expr.map_or_else(
-            || end_eq != 0,
-            |expr| {
-                intravisit::walk_expr(&mut end_walker, expr);
-                end_walker.uses.iter().any(|x| !block_defs.contains(x))
-            },
-        );
-
-        if end_linable {
-            end_walker.def_symbols.drain().for_each(|x| {
-                moved_syms.insert(x);
-            });
+struct BlockEq {
+    /// The end of the range of equal stmts at the start.
+    start_end_eq: usize,
+    /// The start of the range of equal stmts at the end.
+    end_begin_eq: Option<usize>,
+    /// The name and id of every local which can be moved at the beginning and the end.
+    moved_locals: Vec<(HirId, Symbol)>,
+}
+impl BlockEq {
+    fn start_span(&self, b: &Block<'_>, sm: &SourceMap) -> Option<Span> {
+        match &b.stmts[..self.start_end_eq] {
+            [first, .., last] => Some(sm.stmt_span(first.span, b.span).to(sm.stmt_span(last.span, b.span))),
+            [s] => Some(sm.stmt_span(s.span, b.span)),
+            [] => None,
         }
+    }
 
-        emit_branches_sharing_code_lint(
-            cx,
-            start_eq,
-            end_eq,
-            end_linable,
-            check_for_warn_of_moved_symbol(cx, &moved_syms, expr),
-            blocks,
-            expr,
-        );
+    fn end_span(&self, b: &Block<'_>, sm: &SourceMap) -> Option<Span> {
+        match (&b.stmts[b.stmts.len() - self.end_begin_eq?..], b.expr) {
+            ([first, .., last], None) => Some(sm.stmt_span(first.span, b.span).to(sm.stmt_span(last.span, b.span))),
+            ([first, ..], Some(last)) => Some(sm.stmt_span(first.span, b.span).to(sm.stmt_span(last.span, b.span))),
+            ([s], None) => Some(sm.stmt_span(s.span, b.span)),
+            ([], Some(e)) => Some(walk_chain(e.span, b.span.ctxt())),
+            ([], None) => None,
+        }
     }
 }
 
-struct BlockEqual {
-    /// The amount statements that are equal from the start
-    start_eq: usize,
-    /// The amount statements that are equal from the end
-    end_eq: usize,
-    ///  An indication if the block expressions are the same. This will also be true if both are
-    /// `None`
-    expr_eq: bool,
+/// If the statement is a local, checks if the bound names match the expected list of names.
+fn eq_binding_names(s: &Stmt<'_>, names: &[(HirId, Symbol)]) -> bool {
+    if let StmtKind::Local(l) = s.kind {
+        let mut i = 0usize;
+        let mut res = true;
+        l.pat.each_binding_or_first(&mut |_, _, _, name| {
+            if names.get(i).map_or(false, |&(_, n)| n == name.name) {
+                i += 1;
+            } else {
+                res = false;
+            }
+        });
+        res && i == names.len()
+    } else {
+        false
+    }
 }
 
-/// This function can also trigger the `IF_SAME_THEN_ELSE` in which case it'll return `None` to
-/// abort any further processing and avoid duplicate lint triggers.
-fn scan_block_for_eq(cx: &LateContext<'_>, conds: &[&Expr<'_>], blocks: &[&Block<'_>]) -> Option<BlockEqual> {
-    let mut start_eq = usize::MAX;
-    let mut end_eq = usize::MAX;
-    let mut expr_eq = true;
-    let mut iter = blocks.windows(2).enumerate();
-    while let Some((i, &[block0, block1])) = iter.next() {
-        let l_stmts = block0.stmts;
-        let r_stmts = block1.stmts;
-
-        // `SpanlessEq` now keeps track of the locals and is therefore context sensitive clippy#6752.
-        // The comparison therefore needs to be done in a way that builds the correct context.
-        let mut evaluator = SpanlessEq::new(cx);
-        let mut evaluator = evaluator.inter_expr();
-
-        let current_start_eq = count_eq(&mut l_stmts.iter(), &mut r_stmts.iter(), |l, r| evaluator.eq_stmt(l, r));
+/// Checks if the given statement should be considered equal to the statement in the same position
+/// for each block.
+fn eq_stmts(
+    stmt: &Stmt<'_>,
+    blocks: &[&Block<'_>],
+    get_stmt: impl for<'a> Fn(&'a Block<'a>) -> Option<&'a Stmt<'a>>,
+    eq: &mut HirEqInterExpr<'_, '_, '_>,
+    moved_bindings: &mut Vec<(HirId, Symbol)>,
+) -> bool {
+    (if let StmtKind::Local(l) = stmt.kind {
+        let old_count = moved_bindings.len();
+        l.pat.each_binding_or_first(&mut |_, id, _, name| {
+            moved_bindings.push((id, name.name));
+        });
+        let new_bindings = &moved_bindings[old_count..];
+        blocks
+            .iter()
+            .all(|b| get_stmt(b).map_or(false, |s| eq_binding_names(s, new_bindings)))
+    } else {
+        true
+    }) && blocks
+        .iter()
+        .all(|b| get_stmt(b).map_or(false, |s| eq.eq_stmt(s, stmt)))
+}
 
-        let current_end_eq = {
-            // We skip the middle statements which can't be equal
-            let end_comparison_count = l_stmts.len().min(r_stmts.len()) - current_start_eq;
-            let it1 = l_stmts.iter().skip(l_stmts.len() - end_comparison_count);
-            let it2 = r_stmts.iter().skip(r_stmts.len() - end_comparison_count);
-            it1.zip(it2)
-                .fold(0, |acc, (l, r)| if evaluator.eq_stmt(l, r) { acc + 1 } else { 0 })
+fn scan_block_for_eq(cx: &LateContext<'_>, _conds: &[&Expr<'_>], block: &Block<'_>, blocks: &[&Block<'_>]) -> BlockEq {
+    let mut eq = SpanlessEq::new(cx);
+    let mut eq = eq.inter_expr();
+    let mut moved_locals = Vec::new();
+
+    let start_end_eq = block
+        .stmts
+        .iter()
+        .enumerate()
+        .find(|&(i, stmt)| !eq_stmts(stmt, blocks, |b| b.stmts.get(i), &mut eq, &mut moved_locals))
+        .map_or(block.stmts.len(), |(i, _)| i);
+
+    // Walk backwards through the final expression/statements so long as their hashes are equal. Note
+    // `SpanlessHash` treats all local references as equal allowing locals declared earlier in the block
+    // to match those in other blocks. e.g. If each block ends with the following the hash value will be
+    // the same even though each `x` binding will have a different `HirId`:
+    //     let x = foo();
+    //     x + 50
+    let expr_hash_eq = if let Some(e) = block.expr {
+        let hash = hash_expr(cx, e);
+        blocks
+            .iter()
+            .all(|b| b.expr.map_or(false, |e| hash_expr(cx, e) == hash))
+    } else {
+        blocks.iter().all(|b| b.expr.is_none())
+    };
+    if !expr_hash_eq {
+        return BlockEq {
+            start_end_eq,
+            end_begin_eq: None,
+            moved_locals,
         };
-        let block_expr_eq = both(&block0.expr, &block1.expr, |l, r| evaluator.eq_expr(l, r));
-
-        // IF_SAME_THEN_ELSE
-        if_chain! {
-            if block_expr_eq;
-            if l_stmts.len() == r_stmts.len();
-            if l_stmts.len() == current_start_eq;
-            // `conds` may have one last item than `blocks`.
-            // Any `i` from `blocks.windows(2)` will exist in `conds`, but `i+1` may not exist on the last iteration.
-            if !matches!(conds[i].kind, ExprKind::Let(..));
-            if !matches!(conds.get(i + 1).map(|e| &e.kind), Some(ExprKind::Let(..)));
-            if !is_lint_allowed(cx, IF_SAME_THEN_ELSE, block0.hir_id);
-            if !is_lint_allowed(cx, IF_SAME_THEN_ELSE, block1.hir_id);
-            then {
-                span_lint_and_note(
-                    cx,
-                    IF_SAME_THEN_ELSE,
-                    block0.span,
-                    "this `if` has identical blocks",
-                    Some(block1.span),
-                    "same as this",
-                );
-
-                return None;
+    }
+    let end_search_start = block.stmts[start_end_eq..]
+        .iter()
+        .rev()
+        .enumerate()
+        .find(|&(offset, stmt)| {
+            let hash = hash_stmt(cx, stmt);
+            blocks.iter().any(|b| {
+                b.stmts
+                    // the bounds check will catch the underflow
+                    .get(b.stmts.len().wrapping_sub(offset + 1))
+                    .map_or(true, |s| hash != hash_stmt(cx, s))
+            })
+        })
+        .map_or(block.stmts.len() - start_end_eq, |(i, _)| i);
+
+    let moved_locals_at_start = moved_locals.len();
+    let mut i = end_search_start;
+    let end_begin_eq = block.stmts[block.stmts.len() - end_search_start..]
+        .iter()
+        .zip(iter::repeat_with(move || {
+            let x = i;
+            i -= 1;
+            x
+        }))
+        .fold(end_search_start, |init, (stmt, offset)| {
+            if eq_stmts(
+                stmt,
+                blocks,
+                |b| b.stmts.get(b.stmts.len() - offset),
+                &mut eq,
+                &mut moved_locals,
+            ) {
+                init
+            } else {
+                // Clear out all locals seen at the end so far. None of them can be moved.
+                let stmts = &blocks[0].stmts;
+                for stmt in &stmts[stmts.len() - init..=stmts.len() - offset] {
+                    if let StmtKind::Local(l) = stmt.kind {
+                        l.pat.each_binding_or_first(&mut |_, id, _, _| {
+                            eq.locals.remove(&id);
+                        });
+                    }
+                }
+                moved_locals.truncate(moved_locals_at_start);
+                offset - 1
+            }
+        });
+    if let Some(e) = block.expr {
+        for block in blocks {
+            if block.expr.map_or(false, |expr| !eq.eq_expr(expr, e)) {
+                moved_locals.truncate(moved_locals_at_start);
+                return BlockEq {
+                    start_end_eq,
+                    end_begin_eq: None,
+                    moved_locals,
+                };
             }
         }
-
-        start_eq = start_eq.min(current_start_eq);
-        end_eq = end_eq.min(current_end_eq);
-        expr_eq &= block_expr_eq;
-    }
-
-    if !expr_eq {
-        end_eq = 0;
     }
 
-    // Check if the regions are overlapping. Set `end_eq` to prevent the overlap
-    let min_block_size = blocks.iter().map(|x| x.stmts.len()).min().unwrap();
-    if (start_eq + end_eq) > min_block_size {
-        end_eq = min_block_size - start_eq;
+    BlockEq {
+        start_end_eq,
+        end_begin_eq: Some(end_begin_eq),
+        moved_locals,
     }
-
-    Some(BlockEqual {
-        start_eq,
-        end_eq,
-        expr_eq,
-    })
 }
 
-fn check_for_warn_of_moved_symbol(cx: &LateContext<'_>, symbols: &FxHashSet<Symbol>, if_expr: &Expr<'_>) -> bool {
+fn check_for_warn_of_moved_symbol(cx: &LateContext<'_>, symbols: &[(HirId, Symbol)], if_expr: &Expr<'_>) -> bool {
     get_enclosing_block(cx, if_expr.hir_id).map_or(false, |block| {
         let ignore_span = block.span.shrink_to_lo().to(if_expr.span);
 
         symbols
             .iter()
-            .filter(|sym| !sym.as_str().starts_with('_'))
-            .any(move |sym| {
-                let mut walker = ContainsName {
-                    name: *sym,
-                    result: false,
-                };
+            .filter(|&&(_, name)| !name.as_str().starts_with('_'))
+            .any(|&(_, name)| {
+                let mut walker = ContainsName { name, result: false };
 
                 // Scan block
                 block
@@ -419,194 +491,9 @@ fn check_for_warn_of_moved_symbol(cx: &LateContext<'_>, symbols: &FxHashSet<Symb
     })
 }
 
-fn emit_branches_sharing_code_lint(
-    cx: &LateContext<'_>,
-    start_stmts: usize,
-    end_stmts: usize,
-    lint_end: bool,
-    warn_about_moved_symbol: bool,
-    blocks: &[&Block<'_>],
-    if_expr: &Expr<'_>,
-) {
-    if start_stmts == 0 && !lint_end {
-        return;
-    }
-
-    // (help, span, suggestion)
-    let mut suggestions: Vec<(&str, Span, String)> = vec![];
-    let mut add_expr_note = false;
-
-    // Construct suggestions
-    let sm = cx.sess().source_map();
-    if start_stmts > 0 {
-        let block = blocks[0];
-        let span_start = first_line_of_span(cx, if_expr.span).shrink_to_lo();
-        let span_end = sm.stmt_span(block.stmts[start_stmts - 1].span, block.span);
-
-        let cond_span = first_line_of_span(cx, if_expr.span).until(block.span);
-        let cond_snippet = reindent_multiline(snippet(cx, cond_span, "_"), false, None);
-        let cond_indent = indent_of(cx, cond_span);
-        let moved_span = block.stmts[0].span.source_callsite().to(span_end);
-        let moved_snippet = reindent_multiline(snippet(cx, moved_span, "_"), true, None);
-        let suggestion = moved_snippet.to_string() + "\n" + &cond_snippet + "{";
-        let suggestion = reindent_multiline(Cow::Borrowed(&suggestion), true, cond_indent);
-
-        let span = span_start.to(span_end);
-        suggestions.push(("start", span, suggestion.to_string()));
-    }
-
-    if lint_end {
-        let block = blocks[blocks.len() - 1];
-        let span_end = block.span.shrink_to_hi();
-
-        let moved_start = if end_stmts == 0 && block.expr.is_some() {
-            block.expr.unwrap().span.source_callsite()
-        } else {
-            sm.stmt_span(block.stmts[block.stmts.len() - end_stmts].span, block.span)
-        };
-        let moved_end = block.expr.map_or_else(
-            || sm.stmt_span(block.stmts[block.stmts.len() - 1].span, block.span),
-            |expr| expr.span.source_callsite(),
-        );
-
-        let moved_span = moved_start.to(moved_end);
-        let moved_snipped = reindent_multiline(snippet(cx, moved_span, "_"), true, None);
-        let indent = indent_of(cx, if_expr.span.shrink_to_hi());
-        let suggestion = "}\n".to_string() + &moved_snipped;
-        let suggestion = reindent_multiline(Cow::Borrowed(&suggestion), true, indent);
-
-        let mut span = moved_start.to(span_end);
-        // Improve formatting if the inner block has indention (i.e. normal Rust formatting)
-        let test_span = Span::new(span.lo() - BytePos(4), span.lo(), span.ctxt(), span.parent());
-        if snippet_opt(cx, test_span)
-            .map(|snip| snip == "    ")
-            .unwrap_or_default()
-        {
-            span = span.with_lo(test_span.lo());
-        }
-
-        suggestions.push(("end", span, suggestion.to_string()));
-        add_expr_note = !cx.typeck_results().expr_ty(if_expr).is_unit();
-    }
-
-    let add_optional_msgs = |diag: &mut Diagnostic| {
-        if add_expr_note {
-            diag.note("The end suggestion probably needs some adjustments to use the expression result correctly");
-        }
-
-        if warn_about_moved_symbol {
-            diag.warn("Some moved values might need to be renamed to avoid wrong references");
-        }
-    };
-
-    // Emit lint
-    if suggestions.len() == 1 {
-        let (place_str, span, sugg) = suggestions.pop().unwrap();
-        let msg = format!("all if blocks contain the same code at the {}", place_str);
-        let help = format!("consider moving the {} statements out like this", place_str);
-        span_lint_and_then(cx, BRANCHES_SHARING_CODE, span, msg.as_str(), |diag| {
-            diag.span_suggestion(span, help.as_str(), sugg, Applicability::Unspecified);
-
-            add_optional_msgs(diag);
-        });
-    } else if suggestions.len() == 2 {
-        let (_, end_span, end_sugg) = suggestions.pop().unwrap();
-        let (_, start_span, start_sugg) = suggestions.pop().unwrap();
-        span_lint_and_then(
-            cx,
-            BRANCHES_SHARING_CODE,
-            start_span,
-            "all if blocks contain the same code at the start and the end. Here at the start",
-            move |diag| {
-                diag.span_note(end_span, "and here at the end");
-
-                diag.span_suggestion(
-                    start_span,
-                    "consider moving the start statements out like this",
-                    start_sugg,
-                    Applicability::Unspecified,
-                );
-
-                diag.span_suggestion(
-                    end_span,
-                    "and consider moving the end statements out like this",
-                    end_sugg,
-                    Applicability::Unspecified,
-                );
-
-                add_optional_msgs(diag);
-            },
-        );
-    }
-}
-
-/// This visitor collects `HirId`s and Symbols of defined symbols and `HirId`s of used values.
-struct UsedValueFinderVisitor<'a, 'tcx> {
-    cx: &'a LateContext<'tcx>,
-
-    /// The `HirId`s of defined values in the scanned statements
-    defs: FxHashSet<HirId>,
-
-    /// The Symbols of the defined symbols in the scanned statements
-    def_symbols: FxHashSet<Symbol>,
-
-    /// The `HirId`s of the used values
-    uses: FxHashSet<HirId>,
-}
-
-impl<'a, 'tcx> UsedValueFinderVisitor<'a, 'tcx> {
-    fn new(cx: &'a LateContext<'tcx>) -> Self {
-        UsedValueFinderVisitor {
-            cx,
-            defs: FxHashSet::default(),
-            def_symbols: FxHashSet::default(),
-            uses: FxHashSet::default(),
-        }
-    }
-}
-
-impl<'a, 'tcx> Visitor<'tcx> for UsedValueFinderVisitor<'a, 'tcx> {
-    type NestedFilter = nested_filter::All;
-
-    fn nested_visit_map(&mut self) -> Self::Map {
-        self.cx.tcx.hir()
-    }
-
-    fn visit_local(&mut self, l: &'tcx rustc_hir::Local<'tcx>) {
-        let local_id = l.pat.hir_id;
-        self.defs.insert(local_id);
-
-        if let Some(sym) = l.pat.simple_ident() {
-            self.def_symbols.insert(sym.name);
-        }
-
-        if let Some(expr) = l.init {
-            intravisit::walk_expr(self, expr);
-        }
-    }
-
-    fn visit_qpath(&mut self, qpath: &'tcx rustc_hir::QPath<'tcx>, id: HirId, _span: rustc_span::Span) {
-        if let rustc_hir::QPath::Resolved(_, path) = *qpath {
-            if path.segments.len() == 1 {
-                if let rustc_hir::def::Res::Local(var) = self.cx.qpath_res(qpath, id) {
-                    self.uses.insert(var);
-                }
-            }
-        }
-    }
-}
-
 /// Implementation of `IFS_SAME_COND`.
 fn lint_same_cond(cx: &LateContext<'_>, conds: &[&Expr<'_>]) {
-    let hash: &dyn Fn(&&Expr<'_>) -> u64 = &|expr| -> u64 {
-        let mut h = SpanlessHash::new(cx);
-        h.hash_expr(expr);
-        h.finish()
-    };
-
-    let eq: &dyn Fn(&&Expr<'_>, &&Expr<'_>) -> bool = &|&lhs, &rhs| -> bool { eq_expr_value(cx, lhs, rhs) };
-
-    for (i, j) in search_same(conds, hash, eq) {
+    for (i, j) in search_same(conds, |e| hash_expr(cx, e), |lhs, rhs| eq_expr_value(cx, lhs, rhs)) {
         span_lint_and_note(
             cx,
             IFS_SAME_COND,
@@ -620,12 +507,6 @@ fn lint_same_cond(cx: &LateContext<'_>, conds: &[&Expr<'_>]) {
 
 /// Implementation of `SAME_FUNCTIONS_IN_IF_CONDITION`.
 fn lint_same_fns_in_if_cond(cx: &LateContext<'_>, conds: &[&Expr<'_>]) {
-    let hash: &dyn Fn(&&Expr<'_>) -> u64 = &|expr| -> u64 {
-        let mut h = SpanlessHash::new(cx);
-        h.hash_expr(expr);
-        h.finish()
-    };
-
     let eq: &dyn Fn(&&Expr<'_>, &&Expr<'_>) -> bool = &|&lhs, &rhs| -> bool {
         // Do not lint if any expr originates from a macro
         if lhs.span.from_expansion() || rhs.span.from_expansion() {
@@ -638,7 +519,7 @@ fn lint_same_fns_in_if_cond(cx: &LateContext<'_>, conds: &[&Expr<'_>]) {
         SpanlessEq::new(cx).eq_expr(lhs, rhs)
     };
 
-    for (i, j) in search_same(conds, hash, eq) {
+    for (i, j) in search_same(conds, |e| hash_expr(cx, e), eq) {
         span_lint_and_note(
             cx,
             SAME_FUNCTIONS_IN_IF_CONDITION,
diff --git a/clippy_utils/src/hir_utils.rs b/clippy_utils/src/hir_utils.rs
index c440793b90e..16c5c728dba 100644
--- a/clippy_utils/src/hir_utils.rs
+++ b/clippy_utils/src/hir_utils.rs
@@ -91,7 +91,7 @@ pub struct HirEqInterExpr<'a, 'b, 'tcx> {
     // When binding are declared, the binding ID in the left expression is mapped to the one on the
     // right. For example, when comparing `{ let x = 1; x + 2 }` and `{ let y = 1; y + 2 }`,
     // these blocks are considered equal since `x` is mapped to `y`.
-    locals: HirIdMap<HirId>,
+    pub locals: HirIdMap<HirId>,
 }
 
 impl HirEqInterExpr<'_, '_, '_> {
@@ -998,3 +998,15 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> {
         }
     }
 }
+
+pub fn hash_stmt(cx: &LateContext<'_>, s: &Stmt<'_>) -> u64 {
+    let mut h = SpanlessHash::new(cx);
+    h.hash_stmt(s);
+    h.finish()
+}
+
+pub fn hash_expr(cx: &LateContext<'_>, e: &Expr<'_>) -> u64 {
+    let mut h = SpanlessHash::new(cx);
+    h.hash_expr(e);
+    h.finish()
+}
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index adb37cc9d75..bcaa9571a05 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -58,7 +58,9 @@ pub mod usage;
 pub mod visitors;
 
 pub use self::attrs::*;
-pub use self::hir_utils::{both, count_eq, eq_expr_value, over, SpanlessEq, SpanlessHash};
+pub use self::hir_utils::{
+    both, count_eq, eq_expr_value, hash_expr, hash_stmt, over, HirEqInterExpr, SpanlessEq, SpanlessHash,
+};
 
 use std::collections::hash_map::Entry;
 use std::hash::BuildHasherDefault;
diff --git a/tests/ui/branches_sharing_code/false_positives.rs b/tests/ui/branches_sharing_code/false_positives.rs
index 7f42df46341..06448200951 100644
--- a/tests/ui/branches_sharing_code/false_positives.rs
+++ b/tests/ui/branches_sharing_code/false_positives.rs
@@ -25,4 +25,17 @@ impl FooBar {
     fn baz(&mut self) {}
 }
 
-fn main() {}
+fn foo(x: u32, y: u32) -> u32 {
+    x / y
+}
+
+fn main() {
+    let x = (1, 2);
+    let _ = if true {
+        let (x, y) = x;
+        foo(x, y)
+    } else {
+        let (y, x) = x;
+        foo(x, y)
+    };
+}
diff --git a/tests/ui/branches_sharing_code/shared_at_bottom.stderr b/tests/ui/branches_sharing_code/shared_at_bottom.stderr
index e3c1bbee994..5e1a68d216e 100644
--- a/tests/ui/branches_sharing_code/shared_at_bottom.stderr
+++ b/tests/ui/branches_sharing_code/shared_at_bottom.stderr
@@ -12,8 +12,8 @@ note: the lint level is defined here
    |
 LL | #![deny(clippy::if_same_then_else, clippy::branches_sharing_code)]
    |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   = note: The end suggestion probably needs some adjustments to use the expression result correctly
-help: consider moving the end statements out like this
+   = note: the end suggestion probably needs some adjustments to use the expression result correctly
+help: consider moving these statements after the if
    |
 LL ~     }
 LL +     let result = false;
@@ -28,7 +28,7 @@ LL | /         println!("Same end of block");
 LL | |     }
    | |_____^
    |
-help: consider moving the end statements out like this
+help: consider moving these statements after the if
    |
 LL ~     }
 LL +     println!("Same end of block");
@@ -44,7 +44,7 @@ LL | |         );
 LL | |     }
    | |_____^
    |
-help: consider moving the end statements out like this
+help: consider moving these statements after the if
    |
 LL ~     }
 LL +     println!(
@@ -60,7 +60,7 @@ LL | /             println!("Hello World");
 LL | |         }
    | |_________^
    |
-help: consider moving the end statements out like this
+help: consider moving these statements after the if
    |
 LL ~         }
 LL +         println!("Hello World");
@@ -75,8 +75,8 @@ LL | |         // I'm expecting a note about this
 LL | |     }
    | |_____^
    |
-   = warning: Some moved values might need to be renamed to avoid wrong references
-help: consider moving the end statements out like this
+   = warning: some moved values might need to be renamed to avoid wrong references
+help: consider moving these statements after the if
    |
 LL ~     }
 LL +     let later_used_value = "A string value";
@@ -91,8 +91,8 @@ LL | |         println!("This is the new simple_example: {}", simple_examples);
 LL | |     }
    | |_____^
    |
-   = warning: Some moved values might need to be renamed to avoid wrong references
-help: consider moving the end statements out like this
+   = warning: some moved values might need to be renamed to avoid wrong references
+help: consider moving these statements after the if
    |
 LL ~     }
 LL +     let simple_examples = "I now identify as a &str :)";
@@ -106,8 +106,8 @@ LL | /         x << 2
 LL | |     };
    | |_____^
    |
-   = note: The end suggestion probably needs some adjustments to use the expression result correctly
-help: consider moving the end statements out like this
+   = note: the end suggestion probably needs some adjustments to use the expression result correctly
+help: consider moving these statements after the if
    |
 LL ~     }
 LL ~     x << 2;
@@ -120,8 +120,8 @@ LL | /         x * 4
 LL | |     }
    | |_____^
    |
-   = note: The end suggestion probably needs some adjustments to use the expression result correctly
-help: consider moving the end statements out like this
+   = note: the end suggestion probably needs some adjustments to use the expression result correctly
+help: consider moving these statements after the if
    |
 LL ~     }
 LL +     x * 4
@@ -133,7 +133,7 @@ error: all if blocks contain the same code at the end
 LL |     if x == 17 { b = 1; a = 0x99; } else { a = 0x99; }
    |                                            ^^^^^^^^^^^
    |
-help: consider moving the end statements out like this
+help: consider moving these statements after the if
    |
 LL ~     if x == 17 { b = 1; a = 0x99; } else { }
 LL +     a = 0x99;
diff --git a/tests/ui/branches_sharing_code/shared_at_top.stderr b/tests/ui/branches_sharing_code/shared_at_top.stderr
index 8d78fa5de7e..d890b12ecbb 100644
--- a/tests/ui/branches_sharing_code/shared_at_top.stderr
+++ b/tests/ui/branches_sharing_code/shared_at_top.stderr
@@ -10,7 +10,7 @@ note: the lint level is defined here
    |
 LL | #![deny(clippy::if_same_then_else, clippy::branches_sharing_code)]
    |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-help: consider moving the start statements out like this
+help: consider moving these statements before the if
    |
 LL ~     println!("Hello World!");
 LL +     if true {
@@ -25,8 +25,8 @@ LL | |         println!("The value y was set to: `{}`", y);
 LL | |         let _z = y;
    | |___________________^
    |
-   = warning: Some moved values might need to be renamed to avoid wrong references
-help: consider moving the start statements out like this
+   = warning: some moved values might need to be renamed to avoid wrong references
+help: consider moving these statements before the if
    |
 LL ~     let y = 9;
 LL +     println!("The value y was set to: `{}`", y);
@@ -41,7 +41,7 @@ LL | /     let _ = if x == 7 {
 LL | |         let y = 16;
    | |___________________^
    |
-help: consider moving the start statements out like this
+help: consider moving these statements before the if
    |
 LL ~     let y = 16;
 LL +     let _ = if x == 7 {
@@ -55,8 +55,8 @@ LL | |         let used_value_name = "Different type";
 LL | |         println!("Str: {}", used_value_name);
    | |_____________________________________________^
    |
-   = warning: Some moved values might need to be renamed to avoid wrong references
-help: consider moving the start statements out like this
+   = warning: some moved values might need to be renamed to avoid wrong references
+help: consider moving these statements before the if
    |
 LL ~     let used_value_name = "Different type";
 LL +     println!("Str: {}", used_value_name);
@@ -71,8 +71,8 @@ LL | |         let can_be_overridden = "Move me";
 LL | |         println!("I'm also moveable");
    | |______________________________________^
    |
-   = warning: Some moved values might need to be renamed to avoid wrong references
-help: consider moving the start statements out like this
+   = warning: some moved values might need to be renamed to avoid wrong references
+help: consider moving these statements before the if
    |
 LL ~     let can_be_overridden = "Move me";
 LL +     println!("I'm also moveable");
@@ -87,7 +87,7 @@ LL | |         println!("This should trigger the `SHARED_CODE_IN_IF_BLOCKS` lint
 LL | |         println!("Because `IF_SAME_THEN_ELSE` is allowed here");
    | |________________________________________________________________^
    |
-help: consider moving the start statements out like this
+help: consider moving these statements before the if
    |
 LL ~     println!("This should trigger the `SHARED_CODE_IN_IF_BLOCKS` lint.");
 LL +     println!("Because `IF_SAME_THEN_ELSE` is allowed here");
diff --git a/tests/ui/branches_sharing_code/shared_at_top_and_bottom.stderr b/tests/ui/branches_sharing_code/shared_at_top_and_bottom.stderr
index 1db2343d3fe..11843cc03d8 100644
--- a/tests/ui/branches_sharing_code/shared_at_top_and_bottom.stderr
+++ b/tests/ui/branches_sharing_code/shared_at_top_and_bottom.stderr
@@ -1,4 +1,4 @@
-error: all if blocks contain the same code at the start and the end. Here at the start
+error: all if blocks contain the same code at both the start and the end
   --> $DIR/shared_at_top_and_bottom.rs:16:5
    |
 LL | /     if x == 7 {
@@ -12,26 +12,26 @@ note: the lint level is defined here
    |
 LL | #![deny(clippy::if_same_then_else, clippy::branches_sharing_code)]
    |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-note: and here at the end
+note: this code is shared at the end
   --> $DIR/shared_at_top_and_bottom.rs:28:5
    |
 LL | /         let _u = 9;
 LL | |     }
    | |_____^
-help: consider moving the start statements out like this
+help: consider moving these statements before the if
    |
 LL ~     let t = 7;
 LL +     let _overlap_start = t * 2;
 LL +     let _overlap_end = 2 * t;
 LL +     if x == 7 {
    |
-help: and consider moving the end statements out like this
+help: consider moving these statements after the if
    |
 LL ~     }
 LL +     let _u = 9;
    |
 
-error: all if blocks contain the same code at the start and the end. Here at the start
+error: all if blocks contain the same code at both the start and the end
   --> $DIR/shared_at_top_and_bottom.rs:32:5
    |
 LL | /     if x == 99 {
@@ -40,29 +40,29 @@ LL | |         let _overlap_start = r;
 LL | |         let _overlap_middle = r * r;
    | |____________________________________^
    |
-note: and here at the end
+note: this code is shared at the end
   --> $DIR/shared_at_top_and_bottom.rs:43:5
    |
 LL | /         let _overlap_end = r * r * r;
 LL | |         let z = "end";
 LL | |     }
    | |_____^
-   = warning: Some moved values might need to be renamed to avoid wrong references
-help: consider moving the start statements out like this
+   = warning: some moved values might need to be renamed to avoid wrong references
+help: consider moving these statements before the if
    |
 LL ~     let r = 7;
 LL +     let _overlap_start = r;
 LL +     let _overlap_middle = r * r;
 LL +     if x == 99 {
    |
-help: and consider moving the end statements out like this
+help: consider moving these statements after the if
    |
 LL ~     }
 LL +     let _overlap_end = r * r * r;
 LL +     let z = "end";
    |
 
-error: all if blocks contain the same code at the start and the end. Here at the start
+error: all if blocks contain the same code at both the start and the end
   --> $DIR/shared_at_top_and_bottom.rs:61:5
    |
 LL | /     if (x > 7 && y < 13) || (x + y) % 2 == 1 {
@@ -71,7 +71,7 @@ LL | |         let b = 0xffff00ff;
 LL | |         let e_id = gen_id(a, b);
    | |________________________________^
    |
-note: and here at the end
+note: this code is shared at the end
   --> $DIR/shared_at_top_and_bottom.rs:81:5
    |
 LL | /         let pack = DataPack {
@@ -82,15 +82,15 @@ LL | |         };
 LL | |         process_data(pack);
 LL | |     }
    | |_____^
-   = warning: Some moved values might need to be renamed to avoid wrong references
-help: consider moving the start statements out like this
+   = warning: some moved values might need to be renamed to avoid wrong references
+help: consider moving these statements before the if
    |
 LL ~     let a = 0xcafe;
 LL +     let b = 0xffff00ff;
 LL +     let e_id = gen_id(a, b);
 LL +     if (x > 7 && y < 13) || (x + y) % 2 == 1 {
    |
-help: and consider moving the end statements out like this
+help: consider moving these statements after the if
    |
 LL ~     }
 LL +     let pack = DataPack {
@@ -100,51 +100,51 @@ LL +         some_data: vec![0x12, 0x34, 0x56, 0x78, 0x90],
 LL +     };
  ...
 
-error: all if blocks contain the same code at the start and the end. Here at the start
+error: all if blocks contain the same code at both the start and the end
   --> $DIR/shared_at_top_and_bottom.rs:94:5
    |
 LL | /     let _ = if x == 7 {
 LL | |         let _ = 19;
    | |___________________^
    |
-note: and here at the end
+note: this code is shared at the end
   --> $DIR/shared_at_top_and_bottom.rs:103:5
    |
 LL | /         x << 2
 LL | |     };
    | |_____^
-   = note: The end suggestion probably needs some adjustments to use the expression result correctly
-help: consider moving the start statements out like this
+   = note: the end suggestion probably needs some adjustments to use the expression result correctly
+help: consider moving these statements before the if
    |
 LL ~     let _ = 19;
 LL +     let _ = if x == 7 {
    |
-help: and consider moving the end statements out like this
+help: consider moving these statements after the if
    |
 LL ~     }
 LL ~     x << 2;
    |
 
-error: all if blocks contain the same code at the start and the end. Here at the start
+error: all if blocks contain the same code at both the start and the end
   --> $DIR/shared_at_top_and_bottom.rs:106:5
    |
 LL | /     if x == 9 {
 LL | |         let _ = 17;
    | |___________________^
    |
-note: and here at the end
+note: this code is shared at the end
   --> $DIR/shared_at_top_and_bottom.rs:115:5
    |
 LL | /         x * 4
 LL | |     }
    | |_____^
-   = note: The end suggestion probably needs some adjustments to use the expression result correctly
-help: consider moving the start statements out like this
+   = note: the end suggestion probably needs some adjustments to use the expression result correctly
+help: consider moving these statements before the if
    |
 LL ~     let _ = 17;
 LL +     if x == 9 {
    |
-help: and consider moving the end statements out like this
+help: consider moving these statements after the if
    |
 LL ~     }
 LL +     x * 4
-- 
cgit 1.4.1-3-g733a5


From fc28f6acc8ad5e1b6bd8c8963eef28ac02df59d2 Mon Sep 17 00:00:00 2001
From: Serial <69764315+Serial-ATA@users.noreply.github.com>
Date: Tue, 24 May 2022 21:56:44 -0400
Subject: Support `Weak` in [`rc_clone_in_vec_init`]

---
 clippy_lints/src/rc_clone_in_vec_init.rs  |  56 ++++-----
 tests/ui/rc_clone_in_vec_init/arc.stderr  |  16 +--
 tests/ui/rc_clone_in_vec_init/rc.stderr   |  16 +--
 tests/ui/rc_clone_in_vec_init/weak.rs     |  83 ++++++++++++
 tests/ui/rc_clone_in_vec_init/weak.stderr | 201 ++++++++++++++++++++++++++++++
 5 files changed, 327 insertions(+), 45 deletions(-)
 create mode 100644 tests/ui/rc_clone_in_vec_init/weak.rs
 create mode 100644 tests/ui/rc_clone_in_vec_init/weak.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/rc_clone_in_vec_init.rs b/clippy_lints/src/rc_clone_in_vec_init.rs
index 110f58f3734..8db8c4e9b78 100644
--- a/clippy_lints/src/rc_clone_in_vec_init.rs
+++ b/clippy_lints/src/rc_clone_in_vec_init.rs
@@ -2,7 +2,9 @@ use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::higher::VecArgs;
 use clippy_utils::last_path_segment;
 use clippy_utils::macros::root_macro_call_first_node;
+use clippy_utils::paths;
 use clippy_utils::source::{indent_of, snippet};
+use clippy_utils::ty::match_type;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, QPath, TyKind};
 use rustc_lint::{LateContext, LateLintPass};
@@ -11,10 +13,11 @@ use rustc_span::{sym, Span, Symbol};
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for `Arc::new` or `Rc::new` in `vec![elem; len]`
+    /// Checks for reference-counted pointers (`Arc`, `Rc`, `rc::Weak`, and `sync::Weak`)
+    /// in `vec![elem; len]`
     ///
     /// ### Why is this bad?
-    /// This will create `elem` once and clone it `len` times - doing so with `Arc` or `Rc`
+    /// This will create `elem` once and clone it `len` times - doing so with `Arc`/`Rc`/`Weak`
     /// is a bit misleading, as it will create references to the same pointer, rather
     /// than different instances.
     ///
@@ -26,7 +29,6 @@ declare_clippy_lint! {
     /// ```
     /// Use instead:
     /// ```rust
-    ///
     /// // Initialize each value separately:
     /// let mut data = Vec::with_capacity(100);
     /// for _ in 0..100 {
@@ -42,7 +44,7 @@ declare_clippy_lint! {
     #[clippy::version = "1.62.0"]
     pub RC_CLONE_IN_VEC_INIT,
     suspicious,
-    "initializing `Arc` or `Rc` in `vec![elem; len]`"
+    "initializing reference-counted pointer in `vec![elem; len]`"
 }
 declare_lint_pass!(RcCloneInVecInit => [RC_CLONE_IN_VEC_INIT]);
 
@@ -50,26 +52,12 @@ impl LateLintPass<'_> for RcCloneInVecInit {
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
         let Some(macro_call) = root_macro_call_first_node(cx, expr) else { return; };
         let Some(VecArgs::Repeat(elem, len)) = VecArgs::hir(cx, expr) else { return; };
-        let Some(symbol) = new_reference_call(cx, elem) else { return; };
+        let Some((symbol, func_span)) = ref_init(cx, elem) else { return; };
 
-        emit_lint(cx, symbol, macro_call.span, elem, len);
+        emit_lint(cx, symbol, macro_call.span, elem, len, func_span);
     }
 }
 
-fn elem_snippet(cx: &LateContext<'_>, elem: &Expr<'_>, symbol_name: &str) -> String {
-    let elem_snippet = snippet(cx, elem.span, "..").to_string();
-    if elem_snippet.contains('\n') {
-        // This string must be found in `elem_snippet`, otherwise we won't be constructing
-        // the snippet in the first place.
-        let reference_creation = format!("{symbol_name}::new");
-        let (code_until_reference_creation, _right) = elem_snippet.split_once(&reference_creation).unwrap();
-
-        return format!("{code_until_reference_creation}{reference_creation}(..)");
-    }
-
-    elem_snippet
-}
-
 fn loop_init_suggestion(elem: &str, len: &str, indent: &str) -> String {
     format!(
         r#"{{
@@ -89,17 +77,17 @@ fn extract_suggestion(elem: &str, len: &str, indent: &str) -> String {
     )
 }
 
-fn emit_lint(cx: &LateContext<'_>, symbol: Symbol, lint_span: Span, elem: &Expr<'_>, len: &Expr<'_>) {
+fn emit_lint(cx: &LateContext<'_>, symbol: Symbol, lint_span: Span, elem: &Expr<'_>, len: &Expr<'_>, func_span: Span) {
     let symbol_name = symbol.as_str();
 
     span_lint_and_then(
         cx,
         RC_CLONE_IN_VEC_INIT,
         lint_span,
-        &format!("calling `{symbol_name}::new` in `vec![elem; len]`"),
+        "initializing a reference-counted pointer in `vec![elem; len]`",
         |diag| {
             let len_snippet = snippet(cx, len.span, "..");
-            let elem_snippet = elem_snippet(cx, elem, symbol_name);
+            let elem_snippet = format!("{}(..)", snippet(cx, elem.span.with_hi(func_span.hi()), ".."));
             let indentation = " ".repeat(indent_of(cx, lint_span).unwrap_or(0));
             let loop_init_suggestion = loop_init_suggestion(&elem_snippet, len_snippet.as_ref(), &indentation);
             let extract_suggestion = extract_suggestion(&elem_snippet, len_snippet.as_ref(), &indentation);
@@ -109,7 +97,7 @@ fn emit_lint(cx: &LateContext<'_>, symbol: Symbol, lint_span: Span, elem: &Expr<
                 lint_span,
                 format!("consider initializing each `{symbol_name}` element individually"),
                 loop_init_suggestion,
-                Applicability::Unspecified,
+                Applicability::HasPlaceholders,
             );
             diag.span_suggestion(
                 lint_span,
@@ -117,23 +105,33 @@ fn emit_lint(cx: &LateContext<'_>, symbol: Symbol, lint_span: Span, elem: &Expr<
                     "or if this is intentional, consider extracting the `{symbol_name}` initialization to a variable"
                 ),
                 extract_suggestion,
-                Applicability::Unspecified,
+                Applicability::HasPlaceholders,
             );
         },
     );
 }
 
-/// Checks whether the given `expr` is a call to `Arc::new` or `Rc::new`
-fn new_reference_call(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<Symbol> {
+/// Checks whether the given `expr` is a call to `Arc::new`, `Rc::new`, or evaluates to a `Weak`
+fn ref_init(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<(Symbol, Span)> {
     if_chain! {
         if let ExprKind::Call(func, _args) = expr.kind;
         if let ExprKind::Path(ref func_path @ QPath::TypeRelative(ty, _)) = func.kind;
         if let TyKind::Path(ref ty_path) = ty.kind;
         if let Some(def_id) = cx.qpath_res(ty_path, ty.hir_id).opt_def_id();
-        if last_path_segment(func_path).ident.name == sym::new;
 
         then {
-            return cx.tcx.get_diagnostic_name(def_id).filter(|symbol| symbol == &sym::Arc || symbol == &sym::Rc);
+            if last_path_segment(func_path).ident.name == sym::new
+                && let Some(symbol) = cx
+                    .tcx
+                    .get_diagnostic_name(def_id)
+                    .filter(|symbol| symbol == &sym::Arc || symbol == &sym::Rc) {
+                return Some((symbol, func.span));
+            }
+
+            let ty_path = cx.typeck_results().expr_ty(expr);
+            if match_type(cx, ty_path, &paths::WEAK_RC) || match_type(cx, ty_path, &paths::WEAK_ARC) {
+                return Some((Symbol::intern("Weak"), func.span));
+            }
         }
     }
 
diff --git a/tests/ui/rc_clone_in_vec_init/arc.stderr b/tests/ui/rc_clone_in_vec_init/arc.stderr
index ce84186c8e3..cd7d91e1206 100644
--- a/tests/ui/rc_clone_in_vec_init/arc.stderr
+++ b/tests/ui/rc_clone_in_vec_init/arc.stderr
@@ -1,4 +1,4 @@
-error: calling `Arc::new` in `vec![elem; len]`
+error: initializing a reference-counted pointer in `vec![elem; len]`
   --> $DIR/arc.rs:7:13
    |
 LL |     let v = vec![Arc::new("x".to_string()); 2];
@@ -10,19 +10,19 @@ help: consider initializing each `Arc` element individually
    |
 LL ~     let v = {
 LL +         let mut v = Vec::with_capacity(2);
-LL +         (0..2).for_each(|_| v.push(Arc::new("x".to_string())));
+LL +         (0..2).for_each(|_| v.push(Arc::new(..)));
 LL +         v
 LL ~     };
    |
 help: or if this is intentional, consider extracting the `Arc` initialization to a variable
    |
 LL ~     let v = {
-LL +         let data = Arc::new("x".to_string());
+LL +         let data = Arc::new(..);
 LL +         vec![data; 2]
 LL ~     };
    |
 
-error: calling `Arc::new` in `vec![elem; len]`
+error: initializing a reference-counted pointer in `vec![elem; len]`
   --> $DIR/arc.rs:15:21
    |
 LL |             let v = vec![Arc::new("x".to_string()); 2];
@@ -33,19 +33,19 @@ help: consider initializing each `Arc` element individually
    |
 LL ~             let v = {
 LL +                 let mut v = Vec::with_capacity(2);
-LL +                 (0..2).for_each(|_| v.push(Arc::new("x".to_string())));
+LL +                 (0..2).for_each(|_| v.push(Arc::new(..)));
 LL +                 v
 LL ~             };
    |
 help: or if this is intentional, consider extracting the `Arc` initialization to a variable
    |
 LL ~             let v = {
-LL +                 let data = Arc::new("x".to_string());
+LL +                 let data = Arc::new(..);
 LL +                 vec![data; 2]
 LL ~             };
    |
 
-error: calling `Arc::new` in `vec![elem; len]`
+error: initializing a reference-counted pointer in `vec![elem; len]`
   --> $DIR/arc.rs:21:13
    |
 LL |       let v = vec![
@@ -75,7 +75,7 @@ LL +         vec![data; 2]
 LL ~     };
    |
 
-error: calling `Arc::new` in `vec![elem; len]`
+error: initializing a reference-counted pointer in `vec![elem; len]`
   --> $DIR/arc.rs:30:14
    |
 LL |       let v1 = vec![
diff --git a/tests/ui/rc_clone_in_vec_init/rc.stderr b/tests/ui/rc_clone_in_vec_init/rc.stderr
index 0f5cc0cf98f..fe861afe054 100644
--- a/tests/ui/rc_clone_in_vec_init/rc.stderr
+++ b/tests/ui/rc_clone_in_vec_init/rc.stderr
@@ -1,4 +1,4 @@
-error: calling `Rc::new` in `vec![elem; len]`
+error: initializing a reference-counted pointer in `vec![elem; len]`
   --> $DIR/rc.rs:8:13
    |
 LL |     let v = vec![Rc::new("x".to_string()); 2];
@@ -10,19 +10,19 @@ help: consider initializing each `Rc` element individually
    |
 LL ~     let v = {
 LL +         let mut v = Vec::with_capacity(2);
-LL +         (0..2).for_each(|_| v.push(Rc::new("x".to_string())));
+LL +         (0..2).for_each(|_| v.push(Rc::new(..)));
 LL +         v
 LL ~     };
    |
 help: or if this is intentional, consider extracting the `Rc` initialization to a variable
    |
 LL ~     let v = {
-LL +         let data = Rc::new("x".to_string());
+LL +         let data = Rc::new(..);
 LL +         vec![data; 2]
 LL ~     };
    |
 
-error: calling `Rc::new` in `vec![elem; len]`
+error: initializing a reference-counted pointer in `vec![elem; len]`
   --> $DIR/rc.rs:16:21
    |
 LL |             let v = vec![Rc::new("x".to_string()); 2];
@@ -33,19 +33,19 @@ help: consider initializing each `Rc` element individually
    |
 LL ~             let v = {
 LL +                 let mut v = Vec::with_capacity(2);
-LL +                 (0..2).for_each(|_| v.push(Rc::new("x".to_string())));
+LL +                 (0..2).for_each(|_| v.push(Rc::new(..)));
 LL +                 v
 LL ~             };
    |
 help: or if this is intentional, consider extracting the `Rc` initialization to a variable
    |
 LL ~             let v = {
-LL +                 let data = Rc::new("x".to_string());
+LL +                 let data = Rc::new(..);
 LL +                 vec![data; 2]
 LL ~             };
    |
 
-error: calling `Rc::new` in `vec![elem; len]`
+error: initializing a reference-counted pointer in `vec![elem; len]`
   --> $DIR/rc.rs:22:13
    |
 LL |       let v = vec![
@@ -75,7 +75,7 @@ LL +         vec![data; 2]
 LL ~     };
    |
 
-error: calling `Rc::new` in `vec![elem; len]`
+error: initializing a reference-counted pointer in `vec![elem; len]`
   --> $DIR/rc.rs:31:14
    |
 LL |       let v1 = vec![
diff --git a/tests/ui/rc_clone_in_vec_init/weak.rs b/tests/ui/rc_clone_in_vec_init/weak.rs
new file mode 100644
index 00000000000..693c9b553c5
--- /dev/null
+++ b/tests/ui/rc_clone_in_vec_init/weak.rs
@@ -0,0 +1,83 @@
+#![warn(clippy::rc_clone_in_vec_init)]
+use std::rc::{Rc, Weak as UnSyncWeak};
+use std::sync::{Arc, Mutex, Weak as SyncWeak};
+
+fn main() {}
+
+fn should_warn_simple_case() {
+    let v = vec![SyncWeak::<u32>::new(); 2];
+    let v2 = vec![UnSyncWeak::<u32>::new(); 2];
+
+    let v = vec![Rc::downgrade(&Rc::new("x".to_string())); 2];
+    let v = vec![Arc::downgrade(&Arc::new("x".to_string())); 2];
+}
+
+fn should_warn_simple_case_with_big_indentation() {
+    if true {
+        let k = 1;
+        dbg!(k);
+        if true {
+            let v = vec![Arc::downgrade(&Arc::new("x".to_string())); 2];
+            let v2 = vec![Rc::downgrade(&Rc::new("x".to_string())); 2];
+        }
+    }
+}
+
+fn should_warn_complex_case() {
+    let v = vec![
+        Arc::downgrade(&Arc::new(Mutex::new({
+            let x = 1;
+            dbg!(x);
+            x
+        })));
+        2
+    ];
+
+    let v1 = vec![
+        Rc::downgrade(&Rc::new(Mutex::new({
+            let x = 1;
+            dbg!(x);
+            x
+        })));
+        2
+    ];
+}
+
+fn should_not_warn_custom_weak() {
+    #[derive(Clone)]
+    struct Weak;
+
+    impl Weak {
+        fn new() -> Self {
+            Weak
+        }
+    }
+
+    let v = vec![Weak::new(); 2];
+}
+
+fn should_not_warn_vec_from_elem_but_not_weak() {
+    let v = vec![String::new(); 2];
+    let v1 = vec![1; 2];
+    let v2 = vec![
+        Box::new(Arc::downgrade(&Arc::new({
+            let y = 3;
+            dbg!(y);
+            y
+        })));
+        2
+    ];
+    let v3 = vec![
+        Box::new(Rc::downgrade(&Rc::new({
+            let y = 3;
+            dbg!(y);
+            y
+        })));
+        2
+    ];
+}
+
+fn should_not_warn_vec_macro_but_not_from_elem() {
+    let v = vec![Arc::downgrade(&Arc::new("x".to_string()))];
+    let v = vec![Rc::downgrade(&Rc::new("x".to_string()))];
+}
diff --git a/tests/ui/rc_clone_in_vec_init/weak.stderr b/tests/ui/rc_clone_in_vec_init/weak.stderr
new file mode 100644
index 00000000000..4a21946ccdf
--- /dev/null
+++ b/tests/ui/rc_clone_in_vec_init/weak.stderr
@@ -0,0 +1,201 @@
+error: initializing a reference-counted pointer in `vec![elem; len]`
+  --> $DIR/weak.rs:8:13
+   |
+LL |     let v = vec![SyncWeak::<u32>::new(); 2];
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::rc-clone-in-vec-init` implied by `-D warnings`
+   = note: each element will point to the same `Weak` instance
+help: consider initializing each `Weak` element individually
+   |
+LL ~     let v = {
+LL +         let mut v = Vec::with_capacity(2);
+LL +         (0..2).for_each(|_| v.push(SyncWeak::<u32>::new(..)));
+LL +         v
+LL ~     };
+   |
+help: or if this is intentional, consider extracting the `Weak` initialization to a variable
+   |
+LL ~     let v = {
+LL +         let data = SyncWeak::<u32>::new(..);
+LL +         vec![data; 2]
+LL ~     };
+   |
+
+error: initializing a reference-counted pointer in `vec![elem; len]`
+  --> $DIR/weak.rs:9:14
+   |
+LL |     let v2 = vec![UnSyncWeak::<u32>::new(); 2];
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: each element will point to the same `Weak` instance
+help: consider initializing each `Weak` element individually
+   |
+LL ~     let v2 = {
+LL +         let mut v = Vec::with_capacity(2);
+LL +         (0..2).for_each(|_| v.push(UnSyncWeak::<u32>::new(..)));
+LL +         v
+LL ~     };
+   |
+help: or if this is intentional, consider extracting the `Weak` initialization to a variable
+   |
+LL ~     let v2 = {
+LL +         let data = UnSyncWeak::<u32>::new(..);
+LL +         vec![data; 2]
+LL ~     };
+   |
+
+error: initializing a reference-counted pointer in `vec![elem; len]`
+  --> $DIR/weak.rs:11:13
+   |
+LL |     let v = vec![Rc::downgrade(&Rc::new("x".to_string())); 2];
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: each element will point to the same `Weak` instance
+help: consider initializing each `Weak` element individually
+   |
+LL ~     let v = {
+LL +         let mut v = Vec::with_capacity(2);
+LL +         (0..2).for_each(|_| v.push(Rc::downgrade(..)));
+LL +         v
+LL ~     };
+   |
+help: or if this is intentional, consider extracting the `Weak` initialization to a variable
+   |
+LL ~     let v = {
+LL +         let data = Rc::downgrade(..);
+LL +         vec![data; 2]
+LL ~     };
+   |
+
+error: initializing a reference-counted pointer in `vec![elem; len]`
+  --> $DIR/weak.rs:12:13
+   |
+LL |     let v = vec![Arc::downgrade(&Arc::new("x".to_string())); 2];
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: each element will point to the same `Weak` instance
+help: consider initializing each `Weak` element individually
+   |
+LL ~     let v = {
+LL +         let mut v = Vec::with_capacity(2);
+LL +         (0..2).for_each(|_| v.push(Arc::downgrade(..)));
+LL +         v
+LL ~     };
+   |
+help: or if this is intentional, consider extracting the `Weak` initialization to a variable
+   |
+LL ~     let v = {
+LL +         let data = Arc::downgrade(..);
+LL +         vec![data; 2]
+LL ~     };
+   |
+
+error: initializing a reference-counted pointer in `vec![elem; len]`
+  --> $DIR/weak.rs:20:21
+   |
+LL |             let v = vec![Arc::downgrade(&Arc::new("x".to_string())); 2];
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: each element will point to the same `Weak` instance
+help: consider initializing each `Weak` element individually
+   |
+LL ~             let v = {
+LL +                 let mut v = Vec::with_capacity(2);
+LL +                 (0..2).for_each(|_| v.push(Arc::downgrade(..)));
+LL +                 v
+LL ~             };
+   |
+help: or if this is intentional, consider extracting the `Weak` initialization to a variable
+   |
+LL ~             let v = {
+LL +                 let data = Arc::downgrade(..);
+LL +                 vec![data; 2]
+LL ~             };
+   |
+
+error: initializing a reference-counted pointer in `vec![elem; len]`
+  --> $DIR/weak.rs:21:22
+   |
+LL |             let v2 = vec![Rc::downgrade(&Rc::new("x".to_string())); 2];
+   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: each element will point to the same `Weak` instance
+help: consider initializing each `Weak` element individually
+   |
+LL ~             let v2 = {
+LL +                 let mut v = Vec::with_capacity(2);
+LL +                 (0..2).for_each(|_| v.push(Rc::downgrade(..)));
+LL +                 v
+LL ~             };
+   |
+help: or if this is intentional, consider extracting the `Weak` initialization to a variable
+   |
+LL ~             let v2 = {
+LL +                 let data = Rc::downgrade(..);
+LL +                 vec![data; 2]
+LL ~             };
+   |
+
+error: initializing a reference-counted pointer in `vec![elem; len]`
+  --> $DIR/weak.rs:27:13
+   |
+LL |       let v = vec![
+   |  _____________^
+LL | |         Arc::downgrade(&Arc::new(Mutex::new({
+LL | |             let x = 1;
+LL | |             dbg!(x);
+...  |
+LL | |         2
+LL | |     ];
+   | |_____^
+   |
+   = note: each element will point to the same `Weak` instance
+help: consider initializing each `Weak` element individually
+   |
+LL ~     let v = {
+LL +         let mut v = Vec::with_capacity(2);
+LL +         (0..2).for_each(|_| v.push(Arc::downgrade(..)));
+LL +         v
+LL ~     };
+   |
+help: or if this is intentional, consider extracting the `Weak` initialization to a variable
+   |
+LL ~     let v = {
+LL +         let data = Arc::downgrade(..);
+LL +         vec![data; 2]
+LL ~     };
+   |
+
+error: initializing a reference-counted pointer in `vec![elem; len]`
+  --> $DIR/weak.rs:36:14
+   |
+LL |       let v1 = vec![
+   |  ______________^
+LL | |         Rc::downgrade(&Rc::new(Mutex::new({
+LL | |             let x = 1;
+LL | |             dbg!(x);
+...  |
+LL | |         2
+LL | |     ];
+   | |_____^
+   |
+   = note: each element will point to the same `Weak` instance
+help: consider initializing each `Weak` element individually
+   |
+LL ~     let v1 = {
+LL +         let mut v = Vec::with_capacity(2);
+LL +         (0..2).for_each(|_| v.push(Rc::downgrade(..)));
+LL +         v
+LL ~     };
+   |
+help: or if this is intentional, consider extracting the `Weak` initialization to a variable
+   |
+LL ~     let v1 = {
+LL +         let data = Rc::downgrade(..);
+LL +         vec![data; 2]
+LL ~     };
+   |
+
+error: aborting due to 8 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From e33d87d4a0a188aa03d7d07700dbf296cf76581a Mon Sep 17 00:00:00 2001
From: Preston From <prestonfrom@gmail.com>
Date: Tue, 24 May 2022 01:06:33 -0600
Subject: When setting suggestion, add suggestion for MoveAndClone for non-ref

When trying to set the current suggestion, if the type of the expression
is not a reference and it is not trivially pure clone copy, we should still
trigger and emit a lint message. Since this fix may require cloning an
expensive-to-clone type, do not attempt to offer a suggested fix.

This change means that matches generated from TryDesugar and AwaitDesugar
would normally trigger a lint, but they are out of scope for this lint,
so we will explicitly ignore matches with sources of TryDesugar or
AwaitDesugar.

changelog: Update for [`significant_drop_in_scrutinee`] to correctly
emit lint messages for cases where the type is not a reference and
not trivially pure clone copy.
---
 clippy_lints/src/significant_drop_in_scrutinee.rs | 107 ++++++++++++----------
 clippy_utils/src/lib.rs                           |   3 +-
 tests/ui/significant_drop_in_scrutinee.rs         |  39 ++++++++
 tests/ui/significant_drop_in_scrutinee.stderr     |  60 +++++++-----
 4 files changed, 134 insertions(+), 75 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/significant_drop_in_scrutinee.rs b/clippy_lints/src/significant_drop_in_scrutinee.rs
index 424b361a905..6b45b6d4452 100644
--- a/clippy_lints/src/significant_drop_in_scrutinee.rs
+++ b/clippy_lints/src/significant_drop_in_scrutinee.rs
@@ -4,7 +4,7 @@ use clippy_utils::get_attr;
 use clippy_utils::source::{indent_of, snippet};
 use rustc_errors::{Applicability, Diagnostic};
 use rustc_hir::intravisit::{walk_expr, Visitor};
-use rustc_hir::{Expr, ExprKind};
+use rustc_hir::{Expr, ExprKind, MatchSource};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::ty::subst::GenericArgKind;
 use rustc_middle::ty::{Ty, TypeAndMut};
@@ -154,9 +154,17 @@ fn has_significant_drop_in_scrutinee<'tcx, 'a>(
     cx: &'a LateContext<'tcx>,
     expr: &'tcx Expr<'tcx>,
 ) -> Option<Vec<FoundSigDrop>> {
-    let mut helper = SigDropHelper::new(cx);
     match expr.kind {
-        ExprKind::Match(match_expr, _, _) => helper.find_sig_drop(match_expr),
+        ExprKind::Match(match_expr, _, source) => {
+            match source {
+                MatchSource::Normal | MatchSource::ForLoopDesugar => {
+                    let mut helper = SigDropHelper::new(cx);
+                    helper.find_sig_drop(match_expr)
+                },
+                // MatchSource of TryDesugar or AwaitDesugar is out of scope for this lint
+                MatchSource::TryDesugar | MatchSource::AwaitDesugar => None,
+            }
+        },
         _ => None,
     }
 }
@@ -213,6 +221,19 @@ impl<'a, 'tcx> SigDropHelper<'a, 'tcx> {
         self.sig_drop_spans.take()
     }
 
+    fn replace_current_sig_drop(
+        &mut self,
+        found_span: Span,
+        is_unit_return_val: bool,
+        lint_suggestion: LintSuggestion,
+    ) {
+        self.current_sig_drop.replace(FoundSigDrop {
+            found_span,
+            is_unit_return_val,
+            lint_suggestion,
+        });
+    }
+
     /// This will try to set the current suggestion (so it can be moved into the suggestions vec
     /// later). If `allow_move_and_clone` is false, the suggestion *won't* be set -- this gives us
     /// an opportunity to look for another type in the chain that will be trivially copyable.
@@ -229,25 +250,15 @@ impl<'a, 'tcx> SigDropHelper<'a, 'tcx> {
             // but let's avoid any chance of an ICE
             if let Some(TypeAndMut { ty, .. }) = ty.builtin_deref(true) {
                 if ty.is_trivially_pure_clone_copy() {
-                    self.current_sig_drop.replace(FoundSigDrop {
-                        found_span: expr.span,
-                        is_unit_return_val: false,
-                        lint_suggestion: LintSuggestion::MoveAndDerefToCopy,
-                    });
+                    self.replace_current_sig_drop(expr.span, false, LintSuggestion::MoveAndDerefToCopy);
                 } else if allow_move_and_clone {
-                    self.current_sig_drop.replace(FoundSigDrop {
-                        found_span: expr.span,
-                        is_unit_return_val: false,
-                        lint_suggestion: LintSuggestion::MoveAndClone,
-                    });
+                    self.replace_current_sig_drop(expr.span, false, LintSuggestion::MoveAndClone);
                 }
             }
         } else if ty.is_trivially_pure_clone_copy() {
-            self.current_sig_drop.replace(FoundSigDrop {
-                found_span: expr.span,
-                is_unit_return_val: false,
-                lint_suggestion: LintSuggestion::MoveOnly,
-            });
+            self.replace_current_sig_drop(expr.span, false, LintSuggestion::MoveOnly);
+        } else if allow_move_and_clone {
+            self.replace_current_sig_drop(expr.span, false, LintSuggestion::MoveAndClone);
         }
     }
 
@@ -279,11 +290,7 @@ impl<'a, 'tcx> SigDropHelper<'a, 'tcx> {
         // If either side had a significant drop, suggest moving the entire scrutinee to avoid
         // unnecessary copies and to simplify cases where both sides have significant drops.
         if self.has_significant_drop {
-            self.current_sig_drop.replace(FoundSigDrop {
-                found_span: span,
-                is_unit_return_val,
-                lint_suggestion: LintSuggestion::MoveOnly,
-            });
+            self.replace_current_sig_drop(span, is_unit_return_val, LintSuggestion::MoveOnly);
         }
 
         self.special_handling_for_binary_op = false;
@@ -363,34 +370,34 @@ impl<'a, 'tcx> Visitor<'tcx> for SigDropHelper<'a, 'tcx> {
                 }
             }
             ExprKind::Box(..) |
-                ExprKind::Array(..) |
-                ExprKind::Call(..) |
-                ExprKind::Unary(..) |
-                ExprKind::If(..) |
-                ExprKind::Match(..) |
-                ExprKind::Field(..) |
-                ExprKind::Index(..) |
-                ExprKind::Ret(..) |
-                ExprKind::Repeat(..) |
-                ExprKind::Yield(..) |
-                ExprKind::MethodCall(..) => walk_expr(self, ex),
+            ExprKind::Array(..) |
+            ExprKind::Call(..) |
+            ExprKind::Unary(..) |
+            ExprKind::If(..) |
+            ExprKind::Match(..) |
+            ExprKind::Field(..) |
+            ExprKind::Index(..) |
+            ExprKind::Ret(..) |
+            ExprKind::Repeat(..) |
+            ExprKind::Yield(..) |
+            ExprKind::MethodCall(..) => walk_expr(self, ex),
             ExprKind::AddrOf(_, _, _) |
-                ExprKind::Block(_, _) |
-                ExprKind::Break(_, _) |
-                ExprKind::Cast(_, _) |
-                // Don't want to check the closure itself, only invocation, which is covered by MethodCall
-                ExprKind::Closure(_, _, _, _, _) |
-                ExprKind::ConstBlock(_) |
-                ExprKind::Continue(_) |
-                ExprKind::DropTemps(_) |
-                ExprKind::Err |
-                ExprKind::InlineAsm(_) |
-                ExprKind::Let(_) |
-                ExprKind::Lit(_) |
-                ExprKind::Loop(_, _, _, _) |
-                ExprKind::Path(_) |
-                ExprKind::Struct(_, _, _) |
-                ExprKind::Type(_, _) => {
+            ExprKind::Block(_, _) |
+            ExprKind::Break(_, _) |
+            ExprKind::Cast(_, _) |
+            // Don't want to check the closure itself, only invocation, which is covered by MethodCall
+            ExprKind::Closure(_, _, _, _, _) |
+            ExprKind::ConstBlock(_) |
+            ExprKind::Continue(_) |
+            ExprKind::DropTemps(_) |
+            ExprKind::Err |
+            ExprKind::InlineAsm(_) |
+            ExprKind::Let(_) |
+            ExprKind::Lit(_) |
+            ExprKind::Loop(_, _, _, _) |
+            ExprKind::Path(_) |
+            ExprKind::Struct(_, _, _) |
+            ExprKind::Type(_, _) => {
                 return;
             }
         }
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index adb37cc9d75..0d61231ada7 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -2073,7 +2073,8 @@ static TEST_ITEM_NAMES_CACHE: SyncOnceCell<Mutex<FxHashMap<LocalDefId, Vec<Symbo
 fn with_test_item_names<'tcx>(tcx: TyCtxt<'tcx>, module: LocalDefId, f: impl Fn(&[Symbol]) -> bool) -> bool {
     let cache = TEST_ITEM_NAMES_CACHE.get_or_init(|| Mutex::new(FxHashMap::default()));
     let mut map: MutexGuard<'_, FxHashMap<LocalDefId, Vec<Symbol>>> = cache.lock().unwrap();
-    match map.entry(module) {
+    let value = map.entry(module);
+    match value {
         Entry::Occupied(entry) => f(entry.get()),
         Entry::Vacant(entry) => {
             let mut names = Vec::new();
diff --git a/tests/ui/significant_drop_in_scrutinee.rs b/tests/ui/significant_drop_in_scrutinee.rs
index f83a6dd0eb2..4347610f393 100644
--- a/tests/ui/significant_drop_in_scrutinee.rs
+++ b/tests/ui/significant_drop_in_scrutinee.rs
@@ -7,8 +7,10 @@
 #![allow(unused_assignments)]
 #![allow(dead_code)]
 
+use std::num::ParseIntError;
 use std::ops::Deref;
 use std::sync::atomic::{AtomicU64, Ordering};
+use std::sync::RwLock;
 use std::sync::{Mutex, MutexGuard};
 
 struct State {}
@@ -552,4 +554,41 @@ fn should_not_cause_stack_overflow() {
     }
 }
 
+fn should_not_produce_lint_for_try_desugar() -> Result<u64, ParseIntError> {
+    // TryDesugar (i.e. using `?` for a Result type) will turn into a match but is out of scope
+    // for this lint
+    let rwlock = RwLock::new("1".to_string());
+    let result = rwlock.read().unwrap().parse::<u64>()?;
+    println!("{}", result);
+    rwlock.write().unwrap().push('2');
+    Ok(result)
+}
+
+struct ResultReturner {
+    s: String,
+}
+
+impl ResultReturner {
+    fn to_number(&self) -> Result<i64, ParseIntError> {
+        self.s.parse::<i64>()
+    }
+}
+
+fn should_trigger_lint_for_non_ref_move_and_clone_suggestion() {
+    let rwlock = RwLock::<ResultReturner>::new(ResultReturner { s: "1".to_string() });
+    match rwlock.read().unwrap().to_number() {
+        Ok(n) => println!("Converted to number: {}", n),
+        Err(e) => println!("Could not convert {} to number", e),
+    };
+}
+
+fn should_trigger_lint_for_read_write_lock_for_loop() {
+    // For-in loops desugar to match expressions and are prone to the type of deadlock this lint is
+    // designed to look for.
+    let rwlock = RwLock::<Vec<String>>::new(vec!["1".to_string()]);
+    for s in rwlock.read().unwrap().iter() {
+        println!("{}", s);
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/significant_drop_in_scrutinee.stderr b/tests/ui/significant_drop_in_scrutinee.stderr
index af160564985..77942325244 100644
--- a/tests/ui/significant_drop_in_scrutinee.stderr
+++ b/tests/ui/significant_drop_in_scrutinee.stderr
@@ -1,5 +1,5 @@
 error: temporary with significant drop in match scrutinee
-  --> $DIR/significant_drop_in_scrutinee.rs:57:11
+  --> $DIR/significant_drop_in_scrutinee.rs:59:11
    |
 LL |     match mutex.lock().unwrap().foo() {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -12,7 +12,7 @@ LL ~     match value {
    |
 
 error: temporary with significant drop in match scrutinee
-  --> $DIR/significant_drop_in_scrutinee.rs:130:11
+  --> $DIR/significant_drop_in_scrutinee.rs:132:11
    |
 LL |     match s.lock_m().get_the_value() {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -24,7 +24,7 @@ LL ~     match value {
    |
 
 error: temporary with significant drop in match scrutinee
-  --> $DIR/significant_drop_in_scrutinee.rs:151:11
+  --> $DIR/significant_drop_in_scrutinee.rs:153:11
    |
 LL |     match s.lock_m_m().get_the_value() {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -36,7 +36,7 @@ LL ~     match value {
    |
 
 error: temporary with significant drop in match scrutinee
-  --> $DIR/significant_drop_in_scrutinee.rs:199:11
+  --> $DIR/significant_drop_in_scrutinee.rs:201:11
    |
 LL |     match counter.temp_increment().len() {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -48,7 +48,7 @@ LL ~     match value {
    |
 
 error: temporary with significant drop in match scrutinee
-  --> $DIR/significant_drop_in_scrutinee.rs:222:16
+  --> $DIR/significant_drop_in_scrutinee.rs:224:16
    |
 LL |         match (mutex1.lock().unwrap().s.len(), true) {
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -60,7 +60,7 @@ LL ~         match (value, true) {
    |
 
 error: temporary with significant drop in match scrutinee
-  --> $DIR/significant_drop_in_scrutinee.rs:231:22
+  --> $DIR/significant_drop_in_scrutinee.rs:233:22
    |
 LL |         match (true, mutex1.lock().unwrap().s.len(), true) {
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -72,7 +72,7 @@ LL ~         match (true, value, true) {
    |
 
 error: temporary with significant drop in match scrutinee
-  --> $DIR/significant_drop_in_scrutinee.rs:241:16
+  --> $DIR/significant_drop_in_scrutinee.rs:243:16
    |
 LL |         match (mutex1.lock().unwrap().s.len(), true, mutex2.lock().unwrap().s.len()) {
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -84,7 +84,7 @@ LL ~         match (value, true, mutex2.lock().unwrap().s.len()) {
    |
 
 error: temporary with significant drop in match scrutinee
-  --> $DIR/significant_drop_in_scrutinee.rs:241:54
+  --> $DIR/significant_drop_in_scrutinee.rs:243:54
    |
 LL |         match (mutex1.lock().unwrap().s.len(), true, mutex2.lock().unwrap().s.len()) {
    |                                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -96,19 +96,19 @@ LL ~         match (mutex1.lock().unwrap().s.len(), true, value) {
    |
 
 error: temporary with significant drop in match scrutinee
-  --> $DIR/significant_drop_in_scrutinee.rs:252:15
+  --> $DIR/significant_drop_in_scrutinee.rs:254:15
    |
 LL |         match mutex3.lock().unwrap().s.as_str() {
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: temporary with significant drop in match scrutinee
-  --> $DIR/significant_drop_in_scrutinee.rs:262:22
+  --> $DIR/significant_drop_in_scrutinee.rs:264:22
    |
 LL |         match (true, mutex3.lock().unwrap().s.as_str()) {
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: temporary with significant drop in match scrutinee
-  --> $DIR/significant_drop_in_scrutinee.rs:281:11
+  --> $DIR/significant_drop_in_scrutinee.rs:283:11
    |
 LL |     match mutex.lock().unwrap().s.len() > 1 {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -120,7 +120,7 @@ LL ~     match value {
    |
 
 error: temporary with significant drop in match scrutinee
-  --> $DIR/significant_drop_in_scrutinee.rs:288:11
+  --> $DIR/significant_drop_in_scrutinee.rs:290:11
    |
 LL |     match 1 < mutex.lock().unwrap().s.len() {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -132,7 +132,7 @@ LL ~     match value {
    |
 
 error: temporary with significant drop in match scrutinee
-  --> $DIR/significant_drop_in_scrutinee.rs:306:11
+  --> $DIR/significant_drop_in_scrutinee.rs:308:11
    |
 LL |     match mutex1.lock().unwrap().s.len() < mutex2.lock().unwrap().s.len() {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -144,7 +144,7 @@ LL ~     match value {
    |
 
 error: temporary with significant drop in match scrutinee
-  --> $DIR/significant_drop_in_scrutinee.rs:317:11
+  --> $DIR/significant_drop_in_scrutinee.rs:319:11
    |
 LL |     match mutex1.lock().unwrap().s.len() >= mutex2.lock().unwrap().s.len() {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -156,7 +156,7 @@ LL ~     match value {
    |
 
 error: temporary with significant drop in match scrutinee
-  --> $DIR/significant_drop_in_scrutinee.rs:352:11
+  --> $DIR/significant_drop_in_scrutinee.rs:354:11
    |
 LL |     match get_mutex_guard().s.len() > 1 {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -168,7 +168,7 @@ LL ~     match value {
    |
 
 error: temporary with significant drop in match scrutinee
-  --> $DIR/significant_drop_in_scrutinee.rs:369:11
+  --> $DIR/significant_drop_in_scrutinee.rs:371:11
    |
 LL |       match match i {
    |  ___________^
@@ -191,7 +191,7 @@ LL +     .len()
  ...
 
 error: temporary with significant drop in match scrutinee
-  --> $DIR/significant_drop_in_scrutinee.rs:395:11
+  --> $DIR/significant_drop_in_scrutinee.rs:397:11
    |
 LL |       match if i > 1 {
    |  ___________^
@@ -214,7 +214,7 @@ LL +     .s
  ...
 
 error: temporary with significant drop in match scrutinee
-  --> $DIR/significant_drop_in_scrutinee.rs:449:11
+  --> $DIR/significant_drop_in_scrutinee.rs:451:11
    |
 LL |     match s.lock().deref().deref() {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -226,13 +226,13 @@ LL ~     match value {
    |
 
 error: temporary with significant drop in match scrutinee
-  --> $DIR/significant_drop_in_scrutinee.rs:477:11
+  --> $DIR/significant_drop_in_scrutinee.rs:479:11
    |
 LL |     match s.lock().deref().deref() {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: temporary with significant drop in match scrutinee
-  --> $DIR/significant_drop_in_scrutinee.rs:496:11
+  --> $DIR/significant_drop_in_scrutinee.rs:498:11
    |
 LL |     match mutex.lock().unwrap().i = i {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -244,7 +244,7 @@ LL ~     match () {
    |
 
 error: temporary with significant drop in match scrutinee
-  --> $DIR/significant_drop_in_scrutinee.rs:502:11
+  --> $DIR/significant_drop_in_scrutinee.rs:504:11
    |
 LL |     match i = mutex.lock().unwrap().i {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -256,7 +256,7 @@ LL ~     match () {
    |
 
 error: temporary with significant drop in match scrutinee
-  --> $DIR/significant_drop_in_scrutinee.rs:508:11
+  --> $DIR/significant_drop_in_scrutinee.rs:510:11
    |
 LL |     match mutex.lock().unwrap().i += 1 {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -268,7 +268,7 @@ LL ~     match () {
    |
 
 error: temporary with significant drop in match scrutinee
-  --> $DIR/significant_drop_in_scrutinee.rs:514:11
+  --> $DIR/significant_drop_in_scrutinee.rs:516:11
    |
 LL |     match i += mutex.lock().unwrap().i {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -279,5 +279,17 @@ LL ~     i += mutex.lock().unwrap().i;
 LL ~     match () {
    |
 
-error: aborting due to 23 previous errors
+error: temporary with significant drop in match scrutinee
+  --> $DIR/significant_drop_in_scrutinee.rs:579:11
+   |
+LL |     match rwlock.read().unwrap().to_number() {
+   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: temporary with significant drop in match scrutinee
+  --> $DIR/significant_drop_in_scrutinee.rs:589:14
+   |
+LL |     for s in rwlock.read().unwrap().iter() {
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 25 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 4fc0ee6260d686efc128e44b7b0d0e3d820fff20 Mon Sep 17 00:00:00 2001
From: Caio <c410.f3r@gmail.com>
Date: Fri, 27 May 2022 18:53:02 -0300
Subject: [1/N] Implement Arithmetic lint

---
 clippy_lints/src/arithmetic.rs               | 170 ---------------------------
 clippy_lints/src/lib.register_lints.rs       |   4 +-
 clippy_lints/src/lib.register_restriction.rs |   4 +-
 clippy_lints/src/lib.rs                      |   4 +-
 clippy_lints/src/numeric_arithmetic.rs       | 170 +++++++++++++++++++++++++++
 5 files changed, 176 insertions(+), 176 deletions(-)
 delete mode 100644 clippy_lints/src/arithmetic.rs
 create mode 100644 clippy_lints/src/numeric_arithmetic.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/arithmetic.rs b/clippy_lints/src/arithmetic.rs
deleted file mode 100644
index c5948707c81..00000000000
--- a/clippy_lints/src/arithmetic.rs
+++ /dev/null
@@ -1,170 +0,0 @@
-use clippy_utils::consts::constant_simple;
-use clippy_utils::diagnostics::span_lint;
-use rustc_hir as hir;
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::source_map::Span;
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for integer arithmetic operations which could overflow or panic.
-    ///
-    /// Specifically, checks for any operators (`+`, `-`, `*`, `<<`, etc) which are capable
-    /// of overflowing according to the [Rust
-    /// Reference](https://doc.rust-lang.org/reference/expressions/operator-expr.html#overflow),
-    /// or which can panic (`/`, `%`). No bounds analysis or sophisticated reasoning is
-    /// attempted.
-    ///
-    /// ### Why is this bad?
-    /// Integer overflow will trigger a panic in debug builds or will wrap in
-    /// release mode. Division by zero will cause a panic in either mode. In some applications one
-    /// wants explicitly checked, wrapping or saturating arithmetic.
-    ///
-    /// ### Example
-    /// ```rust
-    /// # let a = 0;
-    /// a + 1;
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub INTEGER_ARITHMETIC,
-    restriction,
-    "any integer arithmetic expression which could overflow or panic"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for float arithmetic.
-    ///
-    /// ### Why is this bad?
-    /// For some embedded systems or kernel development, it
-    /// can be useful to rule out floating-point numbers.
-    ///
-    /// ### Example
-    /// ```rust
-    /// # let a = 0.0;
-    /// a + 1.0;
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub FLOAT_ARITHMETIC,
-    restriction,
-    "any floating-point arithmetic statement"
-}
-
-#[derive(Copy, Clone, Default)]
-pub struct Arithmetic {
-    expr_span: Option<Span>,
-    /// This field is used to check whether expressions are constants, such as in enum discriminants
-    /// and consts
-    const_span: Option<Span>,
-}
-
-impl_lint_pass!(Arithmetic => [INTEGER_ARITHMETIC, FLOAT_ARITHMETIC]);
-
-impl<'tcx> LateLintPass<'tcx> for Arithmetic {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
-        if self.expr_span.is_some() {
-            return;
-        }
-
-        if let Some(span) = self.const_span {
-            if span.contains(expr.span) {
-                return;
-            }
-        }
-        match &expr.kind {
-            hir::ExprKind::Binary(op, l, r) | hir::ExprKind::AssignOp(op, l, r) => {
-                match op.node {
-                    hir::BinOpKind::And
-                    | hir::BinOpKind::Or
-                    | hir::BinOpKind::BitAnd
-                    | hir::BinOpKind::BitOr
-                    | hir::BinOpKind::BitXor
-                    | hir::BinOpKind::Eq
-                    | hir::BinOpKind::Lt
-                    | hir::BinOpKind::Le
-                    | hir::BinOpKind::Ne
-                    | hir::BinOpKind::Ge
-                    | hir::BinOpKind::Gt => return,
-                    _ => (),
-                }
-
-                let (l_ty, r_ty) = (cx.typeck_results().expr_ty(l), cx.typeck_results().expr_ty(r));
-                if l_ty.peel_refs().is_integral() && r_ty.peel_refs().is_integral() {
-                    match op.node {
-                        hir::BinOpKind::Div | hir::BinOpKind::Rem => match &r.kind {
-                            hir::ExprKind::Lit(_lit) => (),
-                            hir::ExprKind::Unary(hir::UnOp::Neg, expr) => {
-                                if let hir::ExprKind::Lit(lit) = &expr.kind {
-                                    if let rustc_ast::ast::LitKind::Int(1, _) = lit.node {
-                                        span_lint(cx, INTEGER_ARITHMETIC, expr.span, "integer arithmetic detected");
-                                        self.expr_span = Some(expr.span);
-                                    }
-                                }
-                            },
-                            _ => {
-                                span_lint(cx, INTEGER_ARITHMETIC, expr.span, "integer arithmetic detected");
-                                self.expr_span = Some(expr.span);
-                            },
-                        },
-                        _ => {
-                            span_lint(cx, INTEGER_ARITHMETIC, expr.span, "integer arithmetic detected");
-                            self.expr_span = Some(expr.span);
-                        },
-                    }
-                } else if r_ty.peel_refs().is_floating_point() && r_ty.peel_refs().is_floating_point() {
-                    span_lint(cx, FLOAT_ARITHMETIC, expr.span, "floating-point arithmetic detected");
-                    self.expr_span = Some(expr.span);
-                }
-            },
-            hir::ExprKind::Unary(hir::UnOp::Neg, arg) => {
-                let ty = cx.typeck_results().expr_ty(arg);
-                if constant_simple(cx, cx.typeck_results(), expr).is_none() {
-                    if ty.is_integral() {
-                        span_lint(cx, INTEGER_ARITHMETIC, expr.span, "integer arithmetic detected");
-                        self.expr_span = Some(expr.span);
-                    } else if ty.is_floating_point() {
-                        span_lint(cx, FLOAT_ARITHMETIC, expr.span, "floating-point arithmetic detected");
-                        self.expr_span = Some(expr.span);
-                    }
-                }
-            },
-            _ => (),
-        }
-    }
-
-    fn check_expr_post(&mut self, _: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
-        if Some(expr.span) == self.expr_span {
-            self.expr_span = None;
-        }
-    }
-
-    fn check_body(&mut self, cx: &LateContext<'_>, body: &hir::Body<'_>) {
-        let body_owner = cx.tcx.hir().body_owner_def_id(body.id());
-
-        match cx.tcx.hir().body_owner_kind(body_owner) {
-            hir::BodyOwnerKind::Static(_) | hir::BodyOwnerKind::Const => {
-                let body_span = cx.tcx.def_span(body_owner);
-
-                if let Some(span) = self.const_span {
-                    if span.contains(body_span) {
-                        return;
-                    }
-                }
-                self.const_span = Some(body_span);
-            },
-            hir::BodyOwnerKind::Fn | hir::BodyOwnerKind::Closure => (),
-        }
-    }
-
-    fn check_body_post(&mut self, cx: &LateContext<'_>, body: &hir::Body<'_>) {
-        let body_owner = cx.tcx.hir().body_owner(body.id());
-        let body_span = cx.tcx.hir().span(body_owner);
-
-        if let Some(span) = self.const_span {
-            if span.contains(body_span) {
-                return;
-            }
-        }
-        self.const_span = None;
-    }
-}
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 02171a0909e..1fc0a76803d 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -35,8 +35,6 @@ store.register_lints(&[
     utils::internal_lints::UNNECESSARY_SYMBOL_STR,
     absurd_extreme_comparisons::ABSURD_EXTREME_COMPARISONS,
     approx_const::APPROX_CONSTANT,
-    arithmetic::FLOAT_ARITHMETIC,
-    arithmetic::INTEGER_ARITHMETIC,
     as_conversions::AS_CONVERSIONS,
     asm_syntax::INLINE_ASM_X86_ATT_SYNTAX,
     asm_syntax::INLINE_ASM_X86_INTEL_SYNTAX,
@@ -420,6 +418,8 @@ store.register_lints(&[
     non_octal_unix_permissions::NON_OCTAL_UNIX_PERMISSIONS,
     non_send_fields_in_send_ty::NON_SEND_FIELDS_IN_SEND_TY,
     nonstandard_macro_braces::NONSTANDARD_MACRO_BRACES,
+    numeric_arithmetic::FLOAT_ARITHMETIC,
+    numeric_arithmetic::INTEGER_ARITHMETIC,
     octal_escapes::OCTAL_ESCAPES,
     only_used_in_recursion::ONLY_USED_IN_RECURSION,
     open_options::NONSENSICAL_OPEN_OPTIONS,
diff --git a/clippy_lints/src/lib.register_restriction.rs b/clippy_lints/src/lib.register_restriction.rs
index a6d3a06dc16..304b595541a 100644
--- a/clippy_lints/src/lib.register_restriction.rs
+++ b/clippy_lints/src/lib.register_restriction.rs
@@ -3,8 +3,6 @@
 // Manual edits will be overwritten.
 
 store.register_group(true, "clippy::restriction", Some("clippy_restriction"), vec![
-    LintId::of(arithmetic::FLOAT_ARITHMETIC),
-    LintId::of(arithmetic::INTEGER_ARITHMETIC),
     LintId::of(as_conversions::AS_CONVERSIONS),
     LintId::of(asm_syntax::INLINE_ASM_X86_ATT_SYNTAX),
     LintId::of(asm_syntax::INLINE_ASM_X86_INTEL_SYNTAX),
@@ -50,6 +48,8 @@ store.register_group(true, "clippy::restriction", Some("clippy_restriction"), ve
     LintId::of(module_style::MOD_MODULE_FILES),
     LintId::of(module_style::SELF_NAMED_MODULE_FILES),
     LintId::of(modulo_arithmetic::MODULO_ARITHMETIC),
+    LintId::of(numeric_arithmetic::FLOAT_ARITHMETIC),
+    LintId::of(numeric_arithmetic::INTEGER_ARITHMETIC),
     LintId::of(panic_in_result_fn::PANIC_IN_RESULT_FN),
     LintId::of(panic_unimplemented::PANIC),
     LintId::of(panic_unimplemented::TODO),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index ffbf9a65917..94fca8983ea 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -169,7 +169,6 @@ mod renamed_lints;
 // begin lints modules, do not remove this comment, it’s used in `update_lints`
 mod absurd_extreme_comparisons;
 mod approx_const;
-mod arithmetic;
 mod as_conversions;
 mod asm_syntax;
 mod assertions_on_constants;
@@ -328,6 +327,7 @@ mod non_expressive_names;
 mod non_octal_unix_permissions;
 mod non_send_fields_in_send_ty;
 mod nonstandard_macro_braces;
+mod numeric_arithmetic;
 mod octal_escapes;
 mod only_used_in_recursion;
 mod open_options;
@@ -678,7 +678,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(move || Box::new(doc::DocMarkdown::new(doc_valid_idents.clone())));
     store.register_late_pass(|| Box::new(neg_multiply::NegMultiply));
     store.register_late_pass(|| Box::new(mem_forget::MemForget));
-    store.register_late_pass(|| Box::new(arithmetic::Arithmetic::default()));
+    store.register_late_pass(|| Box::new(numeric_arithmetic::NumericArithmetic::default()));
     store.register_late_pass(|| Box::new(assign_ops::AssignOps));
     store.register_late_pass(|| Box::new(let_if_seq::LetIfSeq));
     store.register_late_pass(|| Box::new(mixed_read_write_in_expression::EvalOrderDependence));
diff --git a/clippy_lints/src/numeric_arithmetic.rs b/clippy_lints/src/numeric_arithmetic.rs
new file mode 100644
index 00000000000..5c4de338149
--- /dev/null
+++ b/clippy_lints/src/numeric_arithmetic.rs
@@ -0,0 +1,170 @@
+use clippy_utils::consts::constant_simple;
+use clippy_utils::diagnostics::span_lint;
+use rustc_hir as hir;
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::source_map::Span;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for integer arithmetic operations which could overflow or panic.
+    ///
+    /// Specifically, checks for any operators (`+`, `-`, `*`, `<<`, etc) which are capable
+    /// of overflowing according to the [Rust
+    /// Reference](https://doc.rust-lang.org/reference/expressions/operator-expr.html#overflow),
+    /// or which can panic (`/`, `%`). No bounds analysis or sophisticated reasoning is
+    /// attempted.
+    ///
+    /// ### Why is this bad?
+    /// Integer overflow will trigger a panic in debug builds or will wrap in
+    /// release mode. Division by zero will cause a panic in either mode. In some applications one
+    /// wants explicitly checked, wrapping or saturating arithmetic.
+    ///
+    /// ### Example
+    /// ```rust
+    /// # let a = 0;
+    /// a + 1;
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub INTEGER_ARITHMETIC,
+    restriction,
+    "any integer arithmetic expression which could overflow or panic"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for float arithmetic.
+    ///
+    /// ### Why is this bad?
+    /// For some embedded systems or kernel development, it
+    /// can be useful to rule out floating-point numbers.
+    ///
+    /// ### Example
+    /// ```rust
+    /// # let a = 0.0;
+    /// a + 1.0;
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub FLOAT_ARITHMETIC,
+    restriction,
+    "any floating-point arithmetic statement"
+}
+
+#[derive(Copy, Clone, Default)]
+pub struct NumericArithmetic {
+    expr_span: Option<Span>,
+    /// This field is used to check whether expressions are constants, such as in enum discriminants
+    /// and consts
+    const_span: Option<Span>,
+}
+
+impl_lint_pass!(NumericArithmetic => [INTEGER_ARITHMETIC, FLOAT_ARITHMETIC]);
+
+impl<'tcx> LateLintPass<'tcx> for NumericArithmetic {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
+        if self.expr_span.is_some() {
+            return;
+        }
+
+        if let Some(span) = self.const_span {
+            if span.contains(expr.span) {
+                return;
+            }
+        }
+        match &expr.kind {
+            hir::ExprKind::Binary(op, l, r) | hir::ExprKind::AssignOp(op, l, r) => {
+                match op.node {
+                    hir::BinOpKind::And
+                    | hir::BinOpKind::Or
+                    | hir::BinOpKind::BitAnd
+                    | hir::BinOpKind::BitOr
+                    | hir::BinOpKind::BitXor
+                    | hir::BinOpKind::Eq
+                    | hir::BinOpKind::Lt
+                    | hir::BinOpKind::Le
+                    | hir::BinOpKind::Ne
+                    | hir::BinOpKind::Ge
+                    | hir::BinOpKind::Gt => return,
+                    _ => (),
+                }
+
+                let (l_ty, r_ty) = (cx.typeck_results().expr_ty(l), cx.typeck_results().expr_ty(r));
+                if l_ty.peel_refs().is_integral() && r_ty.peel_refs().is_integral() {
+                    match op.node {
+                        hir::BinOpKind::Div | hir::BinOpKind::Rem => match &r.kind {
+                            hir::ExprKind::Lit(_lit) => (),
+                            hir::ExprKind::Unary(hir::UnOp::Neg, expr) => {
+                                if let hir::ExprKind::Lit(lit) = &expr.kind {
+                                    if let rustc_ast::ast::LitKind::Int(1, _) = lit.node {
+                                        span_lint(cx, INTEGER_ARITHMETIC, expr.span, "integer arithmetic detected");
+                                        self.expr_span = Some(expr.span);
+                                    }
+                                }
+                            },
+                            _ => {
+                                span_lint(cx, INTEGER_ARITHMETIC, expr.span, "integer arithmetic detected");
+                                self.expr_span = Some(expr.span);
+                            },
+                        },
+                        _ => {
+                            span_lint(cx, INTEGER_ARITHMETIC, expr.span, "integer arithmetic detected");
+                            self.expr_span = Some(expr.span);
+                        },
+                    }
+                } else if r_ty.peel_refs().is_floating_point() && r_ty.peel_refs().is_floating_point() {
+                    span_lint(cx, FLOAT_ARITHMETIC, expr.span, "floating-point arithmetic detected");
+                    self.expr_span = Some(expr.span);
+                }
+            },
+            hir::ExprKind::Unary(hir::UnOp::Neg, arg) => {
+                let ty = cx.typeck_results().expr_ty(arg);
+                if constant_simple(cx, cx.typeck_results(), expr).is_none() {
+                    if ty.is_integral() {
+                        span_lint(cx, INTEGER_ARITHMETIC, expr.span, "integer arithmetic detected");
+                        self.expr_span = Some(expr.span);
+                    } else if ty.is_floating_point() {
+                        span_lint(cx, FLOAT_ARITHMETIC, expr.span, "floating-point arithmetic detected");
+                        self.expr_span = Some(expr.span);
+                    }
+                }
+            },
+            _ => (),
+        }
+    }
+
+    fn check_expr_post(&mut self, _: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
+        if Some(expr.span) == self.expr_span {
+            self.expr_span = None;
+        }
+    }
+
+    fn check_body(&mut self, cx: &LateContext<'_>, body: &hir::Body<'_>) {
+        let body_owner = cx.tcx.hir().body_owner_def_id(body.id());
+
+        match cx.tcx.hir().body_owner_kind(body_owner) {
+            hir::BodyOwnerKind::Static(_) | hir::BodyOwnerKind::Const => {
+                let body_span = cx.tcx.def_span(body_owner);
+
+                if let Some(span) = self.const_span {
+                    if span.contains(body_span) {
+                        return;
+                    }
+                }
+                self.const_span = Some(body_span);
+            },
+            hir::BodyOwnerKind::Fn | hir::BodyOwnerKind::Closure => (),
+        }
+    }
+
+    fn check_body_post(&mut self, cx: &LateContext<'_>, body: &hir::Body<'_>) {
+        let body_owner = cx.tcx.hir().body_owner(body.id());
+        let body_span = cx.tcx.hir().span(body_owner);
+
+        if let Some(span) = self.const_span {
+            if span.contains(body_span) {
+                return;
+            }
+        }
+        self.const_span = None;
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 19f94d52b336a8535c6df1670ed6eb56c08acb55 Mon Sep 17 00:00:00 2001
From: Andre Bogus <bogusandre@gmail.com>
Date: Sat, 28 May 2022 01:36:05 +0200
Subject: remove `large_enum_variant` suggestion for `Copy` types

---
 clippy_lints/src/large_enum_variant.rs | 66 ++++++++++++++++++----------------
 tests/ui/large_enum_variant.rs         | 18 ++++++++++
 tests/ui/large_enum_variant.stderr     | 46 +++++++++++++++++++++++-
 3 files changed, 99 insertions(+), 31 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/large_enum_variant.rs b/clippy_lints/src/large_enum_variant.rs
index 0f3889a2936..34b7cf67db1 100644
--- a/clippy_lints/src/large_enum_variant.rs
+++ b/clippy_lints/src/large_enum_variant.rs
@@ -1,7 +1,7 @@
 //! lint when there is a large size difference between variants on an enum
 
-use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::{diagnostics::span_lint_and_then, ty::is_copy};
 use rustc_errors::Applicability;
 use rustc_hir::{Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
@@ -132,37 +132,43 @@ impl<'tcx> LateLintPass<'tcx> for LargeEnumVariant {
                         let fields = def.variants[variants_size[0].ind].data.fields();
                         variants_size[0].fields_size.sort_by(|a, b| (a.size.cmp(&b.size)));
                         let mut applicability = Applicability::MaybeIncorrect;
-                        let sugg: Vec<(Span, String)> = variants_size[0]
-                            .fields_size
-                            .iter()
-                            .rev()
-                            .map_while(|val| {
-                                if difference > self.maximum_size_difference_allowed {
-                                    difference = difference.saturating_sub(val.size);
-                                    Some((
-                                        fields[val.ind].ty.span,
-                                        format!(
-                                            "Box<{}>",
-                                            snippet_with_applicability(
-                                                cx,
-                                                fields[val.ind].ty.span,
-                                                "..",
-                                                &mut applicability
-                                            )
-                                            .into_owned()
-                                        ),
-                                    ))
-                                } else {
-                                    None
-                                }
-                            })
-                            .collect();
+                        if is_copy(cx, ty) {
+                            diag.span_note(
+                                item.ident.span,
+                                "boxing a variant would require the type no longer be `Copy`",
+                            );
+                        } else {
+                            let sugg: Vec<(Span, String)> = variants_size[0]
+                                .fields_size
+                                .iter()
+                                .rev()
+                                .map_while(|val| {
+                                    if difference > self.maximum_size_difference_allowed {
+                                        difference = difference.saturating_sub(val.size);
+                                        Some((
+                                            fields[val.ind].ty.span,
+                                            format!(
+                                                "Box<{}>",
+                                                snippet_with_applicability(
+                                                    cx,
+                                                    fields[val.ind].ty.span,
+                                                    "..",
+                                                    &mut applicability
+                                                )
+                                                .into_owned()
+                                            ),
+                                        ))
+                                    } else {
+                                        None
+                                    }
+                                })
+                                .collect();
 
-                        if !sugg.is_empty() {
-                            diag.multipart_suggestion(help_text, sugg, Applicability::MaybeIncorrect);
-                            return;
+                            if !sugg.is_empty() {
+                                diag.multipart_suggestion(help_text, sugg, Applicability::MaybeIncorrect);
+                                return;
+                            }
                         }
-
                         diag.span_help(def.variants[variants_size[0].ind].span, help_text);
                     },
                 );
diff --git a/tests/ui/large_enum_variant.rs b/tests/ui/large_enum_variant.rs
index cee9e2372c2..42563383fed 100644
--- a/tests/ui/large_enum_variant.rs
+++ b/tests/ui/large_enum_variant.rs
@@ -98,6 +98,24 @@ struct Struct2 {
     a: [i32; 8000],
 }
 
+#[derive(Copy, Clone)]
+enum CopyableLargeEnum {
+    A(bool),
+    B([u128; 4000]),
+}
+
+enum ManuallyCopyLargeEnum {
+    A(bool),
+    B([u128; 4000]),
+}
+
+impl Clone for ManuallyCopyLargeEnum {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+impl Copy for ManuallyCopyLargeEnum {}
+
 fn main() {
     large_enum_variant!();
 }
diff --git a/tests/ui/large_enum_variant.stderr b/tests/ui/large_enum_variant.stderr
index cbf2ac972e2..397d263ae9f 100644
--- a/tests/ui/large_enum_variant.stderr
+++ b/tests/ui/large_enum_variant.stderr
@@ -127,5 +127,49 @@ help: consider boxing the large fields to reduce the total size of the enum
 LL |     B(Box<Struct2>),
    |       ~~~~~~~~~~~~
 
-error: aborting due to 8 previous errors
+error: large size difference between variants
+  --> $DIR/large_enum_variant.rs:104:5
+   |
+LL |     B([u128; 4000]),
+   |     ^^^^^^^^^^^^^^^ this variant is 64000 bytes
+   |
+note: and the second-largest variant is 1 bytes:
+  --> $DIR/large_enum_variant.rs:103:5
+   |
+LL |     A(bool),
+   |     ^^^^^^^
+note: boxing a variant would require the type no longer be `Copy`
+  --> $DIR/large_enum_variant.rs:102:6
+   |
+LL | enum CopyableLargeEnum {
+   |      ^^^^^^^^^^^^^^^^^
+help: consider boxing the large fields to reduce the total size of the enum
+  --> $DIR/large_enum_variant.rs:104:5
+   |
+LL |     B([u128; 4000]),
+   |     ^^^^^^^^^^^^^^^
+
+error: large size difference between variants
+  --> $DIR/large_enum_variant.rs:109:5
+   |
+LL |     B([u128; 4000]),
+   |     ^^^^^^^^^^^^^^^ this variant is 64000 bytes
+   |
+note: and the second-largest variant is 1 bytes:
+  --> $DIR/large_enum_variant.rs:108:5
+   |
+LL |     A(bool),
+   |     ^^^^^^^
+note: boxing a variant would require the type no longer be `Copy`
+  --> $DIR/large_enum_variant.rs:107:6
+   |
+LL | enum ManuallyCopyLargeEnum {
+   |      ^^^^^^^^^^^^^^^^^^^^^
+help: consider boxing the large fields to reduce the total size of the enum
+  --> $DIR/large_enum_variant.rs:109:5
+   |
+LL |     B([u128; 4000]),
+   |     ^^^^^^^^^^^^^^^
+
+error: aborting due to 10 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 6fd2c6de90423ff6096da4005229df3b2110629d Mon Sep 17 00:00:00 2001
From: kyoto7250 <50972773+kyoto7250@users.noreply.github.com>
Date: Sat, 28 May 2022 14:33:06 +0900
Subject: fix(lint): check const context

https://github.com/rust-lang/rust-clippy/issues/8898
---
 clippy_lints/src/checked_conversions.rs | 3 ++-
 tests/ui/checked_conversions.fixed      | 5 +++++
 tests/ui/checked_conversions.rs         | 5 +++++
 3 files changed, 12 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/checked_conversions.rs b/clippy_lints/src/checked_conversions.rs
index 7eeaaa01921..df3485533b3 100644
--- a/clippy_lints/src/checked_conversions.rs
+++ b/clippy_lints/src/checked_conversions.rs
@@ -2,7 +2,7 @@
 
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::{meets_msrv, msrvs, SpanlessEq};
+use clippy_utils::{in_constant, meets_msrv, msrvs, SpanlessEq};
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
@@ -61,6 +61,7 @@ impl<'tcx> LateLintPass<'tcx> for CheckedConversions {
         }
 
         let result = if_chain! {
+            if !in_constant(cx, item.hir_id);
             if !in_external_macro(cx.sess(), item.span);
             if let ExprKind::Binary(op, left, right) = &item.kind;
 
diff --git a/tests/ui/checked_conversions.fixed b/tests/ui/checked_conversions.fixed
index 0983d393b56..cb7100bc9ef 100644
--- a/tests/ui/checked_conversions.fixed
+++ b/tests/ui/checked_conversions.fixed
@@ -71,4 +71,9 @@ pub fn i8_to_u8(value: i8) {
     let _ = value >= 0;
 }
 
+// Do not lint
+pub const fn issue_8898(i: u32) -> bool {
+    i <= i32::MAX as u32
+}
+
 fn main() {}
diff --git a/tests/ui/checked_conversions.rs b/tests/ui/checked_conversions.rs
index 7d26ace47fd..ed4e0692388 100644
--- a/tests/ui/checked_conversions.rs
+++ b/tests/ui/checked_conversions.rs
@@ -71,4 +71,9 @@ pub fn i8_to_u8(value: i8) {
     let _ = value >= 0;
 }
 
+// Do not lint
+pub const fn issue_8898(i: u32) -> bool {
+    i <= i32::MAX as u32
+}
+
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From cfd0f5592b681957a6bcdc33d90cc82a9a76ceff Mon Sep 17 00:00:00 2001
From: Serial <69764315+Serial-ATA@users.noreply.github.com>
Date: Sat, 28 May 2022 09:22:59 -0400
Subject: Make docs more consistent

---
 clippy_lints/src/approx_const.rs              |  2 +-
 clippy_lints/src/as_conversions.rs            |  2 +-
 clippy_lints/src/assign_ops.rs                | 10 +++++++--
 clippy_lints/src/attrs.rs                     | 32 ++++++++++++++-------------
 clippy_lints/src/blocks_in_if_conditions.rs   |  2 +-
 clippy_lints/src/booleans.rs                  | 19 ++++++++++++----
 clippy_lints/src/bytecount.rs                 |  8 ++++++-
 clippy_lints/src/cognitive_complexity.rs      |  2 +-
 clippy_lints/src/collapsible_if.rs            |  2 +-
 clippy_lints/src/comparison_chain.rs          |  2 +-
 clippy_lints/src/copies.rs                    |  2 +-
 clippy_lints/src/derivable_impls.rs           |  2 +-
 clippy_lints/src/double_comparison.rs         |  2 +-
 clippy_lints/src/duration_subsec.rs           | 18 ++++++++-------
 clippy_lints/src/else_if_without_else.rs      |  2 +-
 clippy_lints/src/empty_enum.rs                |  3 +--
 clippy_lints/src/entry.rs                     |  2 +-
 clippy_lints/src/enum_variants.rs             |  2 +-
 clippy_lints/src/equatable_if_let.rs          |  2 +-
 clippy_lints/src/escape.rs                    |  6 +++--
 clippy_lints/src/excessive_bools.rs           |  3 +--
 clippy_lints/src/explicit_write.rs            | 10 ++++++++-
 clippy_lints/src/fallible_impl_from.rs        |  3 +--
 clippy_lints/src/float_literal.rs             |  5 +++--
 clippy_lints/src/floating_point_arithmetic.rs |  3 +--
 clippy_lints/src/format.rs                    |  7 +++---
 clippy_lints/src/formatting.rs                | 16 +++++++++-----
 clippy_lints/src/loops/mod.rs                 |  2 +-
 clippy_lints/src/methods/mod.rs               |  6 ++---
 29 files changed, 109 insertions(+), 68 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/approx_const.rs b/clippy_lints/src/approx_const.rs
index da1b646f477..159f3b0cd01 100644
--- a/clippy_lints/src/approx_const.rs
+++ b/clippy_lints/src/approx_const.rs
@@ -28,7 +28,7 @@ declare_clippy_lint! {
     /// let x = 3.14;
     /// let y = 1_f64 / x;
     /// ```
-    /// Use predefined constants instead:
+    /// Use instead:
     /// ```rust
     /// let x = std::f32::consts::PI;
     /// let y = std::f64::consts::FRAC_1_PI;
diff --git a/clippy_lints/src/as_conversions.rs b/clippy_lints/src/as_conversions.rs
index 88b91d58907..5fa8934c71b 100644
--- a/clippy_lints/src/as_conversions.rs
+++ b/clippy_lints/src/as_conversions.rs
@@ -29,7 +29,7 @@ declare_clippy_lint! {
     /// f(a as u16);
     /// ```
     ///
-    /// Usually better represents the semantics you expect:
+    /// Use instead:
     /// ```rust,ignore
     /// f(a.try_into()?);
     /// ```
diff --git a/clippy_lints/src/assign_ops.rs b/clippy_lints/src/assign_ops.rs
index 4c2d3366483..f81da2d4223 100644
--- a/clippy_lints/src/assign_ops.rs
+++ b/clippy_lints/src/assign_ops.rs
@@ -27,10 +27,16 @@ declare_clippy_lint! {
     /// let mut a = 5;
     /// let b = 0;
     /// // ...
-    /// // Bad
+    ///
     /// a = a + b;
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust
+    /// let mut a = 5;
+    /// let b = 0;
+    /// // ...
     ///
-    /// // Good
     /// a += b;
     /// ```
     #[clippy::version = "pre 1.29.0"]
diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs
index 7105ce4b292..79a5b670fc8 100644
--- a/clippy_lints/src/attrs.rs
+++ b/clippy_lints/src/attrs.rs
@@ -89,13 +89,14 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```ignore
-    /// // Bad
     /// #[deny(dead_code)]
     /// extern crate foo;
     /// #[forbid(dead_code)]
     /// use foo::bar;
+    /// ```
     ///
-    /// // Ok
+    /// Use instead:
+    /// ```rust,ignore
     /// #[allow(unused_imports)]
     /// use foo::baz;
     /// #[allow(unused_imports)]
@@ -146,15 +147,19 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust
+    /// #[allow(dead_code)]
+    ///
+    /// fn not_quite_good_code() { }
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust
     /// // Good (as inner attribute)
     /// #![allow(dead_code)]
     ///
     /// fn this_is_fine() { }
     ///
-    /// // Bad
-    /// #[allow(dead_code)]
-    ///
-    /// fn not_quite_good_code() { }
+    /// // or
     ///
     /// // Good (as outer attribute)
     /// #[allow(dead_code)]
@@ -175,12 +180,11 @@ declare_clippy_lint! {
     /// These lints should only be enabled on a lint-by-lint basis and with careful consideration.
     ///
     /// ### Example
-    /// Bad:
     /// ```rust
     /// #![deny(clippy::restriction)]
     /// ```
     ///
-    /// Good:
+    /// Use instead:
     /// ```rust
     /// #![deny(clippy::as_conversions)]
     /// ```
@@ -205,13 +209,12 @@ declare_clippy_lint! {
     /// [#3123](https://github.com/rust-lang/rust-clippy/pull/3123#issuecomment-422321765)
     ///
     /// ### Example
-    /// Bad:
     /// ```rust
     /// #[cfg_attr(rustfmt, rustfmt_skip)]
     /// fn main() { }
     /// ```
     ///
-    /// Good:
+    /// Use instead:
     /// ```rust
     /// #[rustfmt::skip]
     /// fn main() { }
@@ -231,19 +234,19 @@ declare_clippy_lint! {
     /// by the conditional compilation engine.
     ///
     /// ### Example
-    /// Bad:
     /// ```rust
     /// #[cfg(linux)]
     /// fn conditional() { }
     /// ```
     ///
-    /// Good:
+    /// Use instead:
     /// ```rust
     /// #[cfg(target_os = "linux")]
     /// fn conditional() { }
     /// ```
     ///
-    /// Or:
+    /// or
+    ///
     /// ```rust
     /// #[cfg(unix)]
     /// fn conditional() { }
@@ -266,14 +269,13 @@ declare_clippy_lint! {
     /// ensure that others understand the reasoning
     ///
     /// ### Example
-    /// Bad:
     /// ```rust
     /// #![feature(lint_reasons)]
     ///
     /// #![allow(clippy::some_lint)]
     /// ```
     ///
-    /// Good:
+    /// Use instead:
     /// ```rust
     /// #![feature(lint_reasons)]
     ///
diff --git a/clippy_lints/src/blocks_in_if_conditions.rs b/clippy_lints/src/blocks_in_if_conditions.rs
index 4c4dd85d518..86e28ea7f7a 100644
--- a/clippy_lints/src/blocks_in_if_conditions.rs
+++ b/clippy_lints/src/blocks_in_if_conditions.rs
@@ -29,7 +29,7 @@ declare_clippy_lint! {
     /// if true { /* ... */ }
     /// ```
     ///
-    /// // or
+    /// or
     ///
     /// ```rust
     /// # fn somefunc() -> bool { true };
diff --git a/clippy_lints/src/booleans.rs b/clippy_lints/src/booleans.rs
index 0adb6327164..e4e122ba6eb 100644
--- a/clippy_lints/src/booleans.rs
+++ b/clippy_lints/src/booleans.rs
@@ -27,8 +27,14 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```ignore
-    /// if a && true  // should be: if a
-    /// if !(a == b)  // should be: if a != b
+    /// if a && true {}
+    /// if !(a == b) {}
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust,ignore
+    /// if a {}
+    /// if a != b {}
     /// ```
     #[clippy::version = "pre 1.29.0"]
     pub NONMINIMAL_BOOL,
@@ -48,10 +54,15 @@ declare_clippy_lint! {
     /// Ignores short circuiting behavior.
     ///
     /// ### Example
-    /// ```ignore
+    /// ```rust,ignore
+    /// // The `b` is unnecessary, the expression is equivalent to `if a`.
     /// if a && b || a { ... }
     /// ```
-    /// The `b` is unnecessary, the expression is equivalent to `if a`.
+    ///
+    /// Use instead:
+    /// ```rust,ignore
+    /// if a {}
+    /// ```
     #[clippy::version = "pre 1.29.0"]
     pub LOGIC_BUG,
     correctness,
diff --git a/clippy_lints/src/bytecount.rs b/clippy_lints/src/bytecount.rs
index 02d97bf43df..bfdbaf2413a 100644
--- a/clippy_lints/src/bytecount.rs
+++ b/clippy_lints/src/bytecount.rs
@@ -28,7 +28,13 @@ declare_clippy_lint! {
     /// ### Example
     /// ```rust
     /// # let vec = vec![1_u8];
-    /// &vec.iter().filter(|x| **x == 0u8).count(); // use bytecount::count instead
+    /// let count = vec.iter().filter(|x| **x == 0u8).count();
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust,ignore
+    /// # let vec = vec![1_u8];
+    /// let count = bytecount::count(&vec, 0u8);
     /// ```
     #[clippy::version = "pre 1.29.0"]
     pub NAIVE_BYTECOUNT,
diff --git a/clippy_lints/src/cognitive_complexity.rs b/clippy_lints/src/cognitive_complexity.rs
index 317c4bfb322..33c44f8b2db 100644
--- a/clippy_lints/src/cognitive_complexity.rs
+++ b/clippy_lints/src/cognitive_complexity.rs
@@ -25,7 +25,7 @@ declare_clippy_lint! {
     /// complexity.
     ///
     /// ### Example
-    /// No. You'll see it when you get the warning.
+    /// You'll see it when you get the warning.
     #[clippy::version = "1.35.0"]
     pub COGNITIVE_COMPLEXITY,
     nursery,
diff --git a/clippy_lints/src/collapsible_if.rs b/clippy_lints/src/collapsible_if.rs
index 3227e6e86af..3eceb848822 100644
--- a/clippy_lints/src/collapsible_if.rs
+++ b/clippy_lints/src/collapsible_if.rs
@@ -41,7 +41,7 @@ declare_clippy_lint! {
     ///
     /// ```
     ///
-    /// Should be written:
+    /// Use instead:
     ///
     /// ```rust,ignore
     /// if x && y {
diff --git a/clippy_lints/src/comparison_chain.rs b/clippy_lints/src/comparison_chain.rs
index 399d11472b0..913e081af3b 100644
--- a/clippy_lints/src/comparison_chain.rs
+++ b/clippy_lints/src/comparison_chain.rs
@@ -34,7 +34,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     ///
-    /// Could be written:
+    /// Use instead:
     ///
     /// ```rust,ignore
     /// use std::cmp::Ordering;
diff --git a/clippy_lints/src/copies.rs b/clippy_lints/src/copies.rs
index e6a0162fd02..1e9a1153011 100644
--- a/clippy_lints/src/copies.rs
+++ b/clippy_lints/src/copies.rs
@@ -141,7 +141,7 @@ declare_clippy_lint! {
     /// };
     /// ```
     ///
-    /// Could be written as:
+    /// Use instead:
     /// ```ignore
     /// println!("Hello World");
     /// let foo = if … {
diff --git a/clippy_lints/src/derivable_impls.rs b/clippy_lints/src/derivable_impls.rs
index 34a5f8444de..e98691fd5bb 100644
--- a/clippy_lints/src/derivable_impls.rs
+++ b/clippy_lints/src/derivable_impls.rs
@@ -21,7 +21,7 @@ declare_clippy_lint! {
     ///     bar: bool
     /// }
     ///
-    /// impl std::default::Default for Foo {
+    /// impl Default for Foo {
     ///     fn default() -> Self {
     ///         Self {
     ///             bar: false
diff --git a/clippy_lints/src/double_comparison.rs b/clippy_lints/src/double_comparison.rs
index be95375789d..ee0440e52ff 100644
--- a/clippy_lints/src/double_comparison.rs
+++ b/clippy_lints/src/double_comparison.rs
@@ -24,7 +24,7 @@ declare_clippy_lint! {
     /// if x == y || x < y {}
     /// ```
     ///
-    /// Could be written as:
+    /// Use instead:
     ///
     /// ```rust
     /// # let x = 1;
diff --git a/clippy_lints/src/duration_subsec.rs b/clippy_lints/src/duration_subsec.rs
index 09318f74527..d85ace3a279 100644
--- a/clippy_lints/src/duration_subsec.rs
+++ b/clippy_lints/src/duration_subsec.rs
@@ -22,15 +22,17 @@ declare_clippy_lint! {
     /// ### Example
     /// ```rust
     /// # use std::time::Duration;
-    /// let dur = Duration::new(5, 0);
-    ///
-    /// // Bad
-    /// let _micros = dur.subsec_nanos() / 1_000;
-    /// let _millis = dur.subsec_nanos() / 1_000_000;
+    /// # let duration = Duration::new(5, 0);
+    /// let micros = duration.subsec_nanos() / 1_000;
+    /// let millis = duration.subsec_nanos() / 1_000_000;
+    /// ```
     ///
-    /// // Good
-    /// let _micros = dur.subsec_micros();
-    /// let _millis = dur.subsec_millis();
+    /// Use instead:
+    /// ```rust
+    /// # use std::time::Duration;
+    /// # let duration = Duration::new(5, 0);
+    /// let micros = duration.subsec_micros();
+    /// let millis = duration.subsec_millis();
     /// ```
     #[clippy::version = "pre 1.29.0"]
     pub DURATION_SUBSEC,
diff --git a/clippy_lints/src/else_if_without_else.rs b/clippy_lints/src/else_if_without_else.rs
index 0b9f54231c5..bf4488570ea 100644
--- a/clippy_lints/src/else_if_without_else.rs
+++ b/clippy_lints/src/else_if_without_else.rs
@@ -26,7 +26,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     ///
-    /// Could be written:
+    /// Use instead:
     ///
     /// ```rust
     /// # fn a() {}
diff --git a/clippy_lints/src/empty_enum.rs b/clippy_lints/src/empty_enum.rs
index b5d6b3c7524..bbebc024414 100644
--- a/clippy_lints/src/empty_enum.rs
+++ b/clippy_lints/src/empty_enum.rs
@@ -23,12 +23,11 @@ declare_clippy_lint! {
     ///
     ///
     /// ### Example
-    /// Bad:
     /// ```rust
     /// enum Test {}
     /// ```
     ///
-    /// Good:
+    /// Use instead:
     /// ```rust
     /// #![feature(never_type)]
     ///
diff --git a/clippy_lints/src/entry.rs b/clippy_lints/src/entry.rs
index c5a987842c3..27743a0ebec 100644
--- a/clippy_lints/src/entry.rs
+++ b/clippy_lints/src/entry.rs
@@ -46,7 +46,7 @@ declare_clippy_lint! {
     ///     map.insert(k, v);
     /// }
     /// ```
-    /// can both be rewritten as:
+    /// Use instead:
     /// ```rust
     /// # use std::collections::HashMap;
     /// # let mut map = HashMap::new();
diff --git a/clippy_lints/src/enum_variants.rs b/clippy_lints/src/enum_variants.rs
index e029b8e8537..263a5b573c9 100644
--- a/clippy_lints/src/enum_variants.rs
+++ b/clippy_lints/src/enum_variants.rs
@@ -32,7 +32,7 @@ declare_clippy_lint! {
     ///     BattenbergCake,
     /// }
     /// ```
-    /// Could be written as:
+    /// Use instead:
     /// ```rust
     /// enum Cake {
     ///     BlackForest,
diff --git a/clippy_lints/src/equatable_if_let.rs b/clippy_lints/src/equatable_if_let.rs
index cf47e581ccb..ef1216358dd 100644
--- a/clippy_lints/src/equatable_if_let.rs
+++ b/clippy_lints/src/equatable_if_let.rs
@@ -26,7 +26,7 @@ declare_clippy_lint! {
     ///     do_thing();
     /// }
     /// ```
-    /// Should be written
+    /// Use instead:
     /// ```rust,ignore
     /// if x == Some(2) {
     ///     do_thing();
diff --git a/clippy_lints/src/escape.rs b/clippy_lints/src/escape.rs
index af591dd71aa..b0854ed9bbb 100644
--- a/clippy_lints/src/escape.rs
+++ b/clippy_lints/src/escape.rs
@@ -31,12 +31,14 @@ declare_clippy_lint! {
     /// ### Example
     /// ```rust
     /// # fn foo(bar: usize) {}
-    /// // Bad
     /// let x = Box::new(1);
     /// foo(*x);
     /// println!("{}", *x);
+    /// ```
     ///
-    /// // Good
+    /// Use instead:
+    /// ```rust
+    /// # fn foo(bar: usize) {}
     /// let x = 1;
     /// foo(x);
     /// println!("{}", x);
diff --git a/clippy_lints/src/excessive_bools.rs b/clippy_lints/src/excessive_bools.rs
index 7a81fb37e84..a2af10e2ba5 100644
--- a/clippy_lints/src/excessive_bools.rs
+++ b/clippy_lints/src/excessive_bools.rs
@@ -18,7 +18,6 @@ declare_clippy_lint! {
     /// readability and API.
     ///
     /// ### Example
-    /// Bad:
     /// ```rust
     /// struct S {
     ///     is_pending: bool,
@@ -27,7 +26,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     ///
-    /// Good:
+    /// Use instead:
     /// ```rust
     /// enum S {
     ///     Pending,
diff --git a/clippy_lints/src/explicit_write.rs b/clippy_lints/src/explicit_write.rs
index 3e2217c28da..6b9805efbcf 100644
--- a/clippy_lints/src/explicit_write.rs
+++ b/clippy_lints/src/explicit_write.rs
@@ -21,8 +21,16 @@ declare_clippy_lint! {
     /// ```rust
     /// # use std::io::Write;
     /// # let bar = "furchtbar";
-    /// // this would be clearer as `eprintln!("foo: {:?}", bar);`
     /// writeln!(&mut std::io::stderr(), "foo: {:?}", bar).unwrap();
+    /// writeln!(&mut std::io::stdout(), "foo: {:?}", bar).unwrap();
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust
+    /// # use std::io::Write;
+    /// # let bar = "furchtbar";
+    /// eprintln!("foo: {:?}", bar);
+    /// println!("foo: {:?}", bar);
     /// ```
     #[clippy::version = "pre 1.29.0"]
     pub EXPLICIT_WRITE,
diff --git a/clippy_lints/src/fallible_impl_from.rs b/clippy_lints/src/fallible_impl_from.rs
index 9f868df3ad0..b88e53aeca6 100644
--- a/clippy_lints/src/fallible_impl_from.rs
+++ b/clippy_lints/src/fallible_impl_from.rs
@@ -20,7 +20,6 @@ declare_clippy_lint! {
     /// ```rust
     /// struct Foo(i32);
     ///
-    /// // Bad
     /// impl From<String> for Foo {
     ///     fn from(s: String) -> Self {
     ///         Foo(s.parse().unwrap())
@@ -28,8 +27,8 @@ declare_clippy_lint! {
     /// }
     /// ```
     ///
+    /// Use instead:
     /// ```rust
-    /// // Good
     /// struct Foo(i32);
     ///
     /// impl TryFrom<String> for Foo {
diff --git a/clippy_lints/src/float_literal.rs b/clippy_lints/src/float_literal.rs
index 7a4397a7b74..f850ea31f4d 100644
--- a/clippy_lints/src/float_literal.rs
+++ b/clippy_lints/src/float_literal.rs
@@ -19,11 +19,12 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust
-    /// // Bad
     /// let v: f32 = 0.123_456_789_9;
     /// println!("{}", v); //  0.123_456_789
+    /// ```
     ///
-    /// // Good
+    /// Use instead:
+    /// ```rust
     /// let v: f64 = 0.123_456_789_9;
     /// println!("{}", v); //  0.123_456_789_9
     /// ```
diff --git a/clippy_lints/src/floating_point_arithmetic.rs b/clippy_lints/src/floating_point_arithmetic.rs
index 42503c26de1..df9b41d2c98 100644
--- a/clippy_lints/src/floating_point_arithmetic.rs
+++ b/clippy_lints/src/floating_point_arithmetic.rs
@@ -35,8 +35,7 @@ declare_clippy_lint! {
     /// let _ = a.exp() - 1.0;
     /// ```
     ///
-    /// is better expressed as
-    ///
+    /// Use instead:
     /// ```rust
     /// let a = 3f32;
     /// let _ = a.cbrt();
diff --git a/clippy_lints/src/format.rs b/clippy_lints/src/format.rs
index 64c41b56587..3084c70589f 100644
--- a/clippy_lints/src/format.rs
+++ b/clippy_lints/src/format.rs
@@ -25,12 +25,13 @@ declare_clippy_lint! {
     ///
     /// ### Examples
     /// ```rust
-    ///
-    /// // Bad
     /// let foo = "foo";
     /// format!("{}", foo);
+    /// ```
     ///
-    /// // Good
+    /// Use instead:
+    /// ```rust
+    /// let foo = "foo";
     /// foo.to_owned();
     /// ```
     #[clippy::version = "pre 1.29.0"]
diff --git a/clippy_lints/src/formatting.rs b/clippy_lints/src/formatting.rs
index 57964b8d48e..db0166da57f 100644
--- a/clippy_lints/src/formatting.rs
+++ b/clippy_lints/src/formatting.rs
@@ -36,12 +36,18 @@ declare_clippy_lint! {
     /// This is either a typo in the binary operator or confusing.
     ///
     /// ### Example
-    /// ```rust,ignore
-    /// if foo <- 30 { // this should be `foo < -30` but looks like a different operator
-    /// }
+    /// ```rust
+    /// # let foo = true;
+    /// # let bar = false;
+    /// // &&! looks like a different operator
+    /// if foo &&! bar {}
+    /// ```
     ///
-    /// if foo &&! bar { // this should be `foo && !bar` but looks like a different operator
-    /// }
+    /// Use instead:
+    /// ```rust
+    /// # let foo = true;
+    /// # let bar = false;
+    /// if foo && !bar {}
     /// ```
     #[clippy::version = "1.40.0"]
     pub SUSPICIOUS_UNARY_OP_FORMATTING,
diff --git a/clippy_lints/src/loops/mod.rs b/clippy_lints/src/loops/mod.rs
index 75d771f992a..417248e31ae 100644
--- a/clippy_lints/src/loops/mod.rs
+++ b/clippy_lints/src/loops/mod.rs
@@ -192,7 +192,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     ///
-    /// // or
+    /// or
     ///
     /// ```rust
     /// # let res: Result<i32, std::io::Error> = Ok(1);
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index b820b740930..eb1bce8c7d2 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -203,7 +203,7 @@ declare_clippy_lint! {
     /// opt.expect("more helpful message");
     /// ```
     ///
-    /// // or
+    /// or
     ///
     /// ```rust
     /// # let res: Result<usize, ()> = Ok(1);
@@ -245,7 +245,7 @@ declare_clippy_lint! {
     /// opt?;
     /// ```
     ///
-    /// // or
+    /// or
     ///
     /// ```rust
     /// # let res: Result<usize, ()> = Ok(1);
@@ -440,7 +440,7 @@ declare_clippy_lint! {
     /// x.map_or(0, |a| a + 1);
     /// ```
     ///
-    /// // or
+    /// or
     ///
     /// ```rust
     /// # let x: Result<usize, ()> = Ok(1);
-- 
cgit 1.4.1-3-g733a5


From 722f7d28c3daf2d568a3af77a62c489fb6a1aea2 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Sun, 29 May 2022 18:28:34 +0000
Subject: needless_late_init: fix ICE when all branches return the never type

---
 clippy_lints/src/needless_late_init.rs |  13 +--
 tests/ui/needless_late_init.fixed      |  47 ++++++----
 tests/ui/needless_late_init.rs         |  47 ++++++----
 tests/ui/needless_late_init.stderr     | 158 ++++++++++++++++-----------------
 4 files changed, 148 insertions(+), 117 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/needless_late_init.rs b/clippy_lints/src/needless_late_init.rs
index b70871b38be..26c694a71fe 100644
--- a/clippy_lints/src/needless_late_init.rs
+++ b/clippy_lints/src/needless_late_init.rs
@@ -194,14 +194,15 @@ fn assignment_suggestions<'tcx>(
         }))
         .collect::<Option<Vec<(Span, String)>>>()?;
 
-    let applicability = if suggestions.len() > 1 {
+    match suggestions.len() {
+        // All of `exprs` are never types
+        // https://github.com/rust-lang/rust-clippy/issues/8911
+        0 => None,
+        1 => Some((Applicability::MachineApplicable, suggestions)),
         // multiple suggestions don't work with rustfix in multipart_suggest
         // https://github.com/rust-lang/rustfix/issues/141
-        Applicability::Unspecified
-    } else {
-        Applicability::MachineApplicable
-    };
-    Some((applicability, suggestions))
+        _ => Some((Applicability::Unspecified, suggestions)),
+    }
 }
 
 struct Usage<'tcx> {
diff --git a/tests/ui/needless_late_init.fixed b/tests/ui/needless_late_init.fixed
index 63ae6e389f3..fee8e3030b8 100644
--- a/tests/ui/needless_late_init.fixed
+++ b/tests/ui/needless_late_init.fixed
@@ -3,6 +3,7 @@
 #![allow(
     unused,
     clippy::assign_op_pattern,
+    clippy::blocks_in_if_conditions,
     clippy::let_and_return,
     clippy::let_unit_value,
     clippy::nonminimal_bool
@@ -18,6 +19,22 @@ impl std::ops::Drop for SignificantDrop {
     }
 }
 
+fn simple() {
+    
+    let a = "zero";
+
+    
+    
+    let b = 1;
+    let c = 2;
+
+    
+    let d: usize = 1;
+
+    
+    let e = format!("{}", d);
+}
+
 fn main() {
     
     let n = 1;
@@ -237,22 +254,20 @@ fn does_not_lint() {
     x = SignificantDrop;
 }
 
-mod fixable {
-    #![allow(dead_code)]
-
-    fn main() {
-        
-        let a = "zero";
-
-        
-        
-        let b = 1;
-        let c = 2;
-
-        
-        let d: usize = 1;
+#[rustfmt::skip]
+fn issue8911() -> u32 {
+    let x;
+    match 1 {
+        _ if { x = 1; false } => return 1,
+        _ => return 2,
+    }
 
-        
-        let e = format!("{}", d);
+    let x;
+    if { x = 1; true } {
+        return 1;
+    } else {
+        return 2;
     }
+
+    3
 }
diff --git a/tests/ui/needless_late_init.rs b/tests/ui/needless_late_init.rs
index 89a85c8e053..402d9f9ef7f 100644
--- a/tests/ui/needless_late_init.rs
+++ b/tests/ui/needless_late_init.rs
@@ -3,6 +3,7 @@
 #![allow(
     unused,
     clippy::assign_op_pattern,
+    clippy::blocks_in_if_conditions,
     clippy::let_and_return,
     clippy::let_unit_value,
     clippy::nonminimal_bool
@@ -18,6 +19,22 @@ impl std::ops::Drop for SignificantDrop {
     }
 }
 
+fn simple() {
+    let a;
+    a = "zero";
+
+    let b;
+    let c;
+    b = 1;
+    c = 2;
+
+    let d: usize;
+    d = 1;
+
+    let e;
+    e = format!("{}", d);
+}
+
 fn main() {
     let a;
     let n = 1;
@@ -237,22 +254,20 @@ fn does_not_lint() {
     x = SignificantDrop;
 }
 
-mod fixable {
-    #![allow(dead_code)]
-
-    fn main() {
-        let a;
-        a = "zero";
-
-        let b;
-        let c;
-        b = 1;
-        c = 2;
-
-        let d: usize;
-        d = 1;
+#[rustfmt::skip]
+fn issue8911() -> u32 {
+    let x;
+    match 1 {
+        _ if { x = 1; false } => return 1,
+        _ => return 2,
+    }
 
-        let e;
-        e = format!("{}", d);
+    let x;
+    if { x = 1; true } {
+        return 1;
+    } else {
+        return 2;
     }
+
+    3
 }
diff --git a/tests/ui/needless_late_init.stderr b/tests/ui/needless_late_init.stderr
index d17666e03ed..f320b5b9cbb 100644
--- a/tests/ui/needless_late_init.stderr
+++ b/tests/ui/needless_late_init.stderr
@@ -1,12 +1,79 @@
 error: unneeded late initialization
-  --> $DIR/needless_late_init.rs:22:5
+  --> $DIR/needless_late_init.rs:23:5
    |
 LL |     let a;
-   |     ^^^^^^
+   |     ^^^^^^ created here
+LL |     a = "zero";
+   |     ^^^^^^^^^^ initialised here
    |
    = note: `-D clippy::needless-late-init` implied by `-D warnings`
 help: declare `a` here
    |
+LL |     let a = "zero";
+   |     ~~~~~
+
+error: unneeded late initialization
+  --> $DIR/needless_late_init.rs:26:5
+   |
+LL |     let b;
+   |     ^^^^^^ created here
+LL |     let c;
+LL |     b = 1;
+   |     ^^^^^ initialised here
+   |
+help: declare `b` here
+   |
+LL |     let b = 1;
+   |     ~~~~~
+
+error: unneeded late initialization
+  --> $DIR/needless_late_init.rs:27:5
+   |
+LL |     let c;
+   |     ^^^^^^ created here
+LL |     b = 1;
+LL |     c = 2;
+   |     ^^^^^ initialised here
+   |
+help: declare `c` here
+   |
+LL |     let c = 2;
+   |     ~~~~~
+
+error: unneeded late initialization
+  --> $DIR/needless_late_init.rs:31:5
+   |
+LL |     let d: usize;
+   |     ^^^^^^^^^^^^^ created here
+LL |     d = 1;
+   |     ^^^^^ initialised here
+   |
+help: declare `d` here
+   |
+LL |     let d: usize = 1;
+   |     ~~~~~~~~~~~~
+
+error: unneeded late initialization
+  --> $DIR/needless_late_init.rs:34:5
+   |
+LL |     let e;
+   |     ^^^^^^ created here
+LL |     e = format!("{}", d);
+   |     ^^^^^^^^^^^^^^^^^^^^ initialised here
+   |
+help: declare `e` here
+   |
+LL |     let e = format!("{}", d);
+   |     ~~~~~
+
+error: unneeded late initialization
+  --> $DIR/needless_late_init.rs:39:5
+   |
+LL |     let a;
+   |     ^^^^^^
+   |
+help: declare `a` here
+   |
 LL |     let a = match n {
    |     +++++++
 help: remove the assignments from the `match` arms
@@ -21,7 +88,7 @@ LL |     };
    |      +
 
 error: unneeded late initialization
-  --> $DIR/needless_late_init.rs:31:5
+  --> $DIR/needless_late_init.rs:48:5
    |
 LL |     let b;
    |     ^^^^^^
@@ -42,7 +109,7 @@ LL |     };
    |      +
 
 error: unneeded late initialization
-  --> $DIR/needless_late_init.rs:38:5
+  --> $DIR/needless_late_init.rs:55:5
    |
 LL |     let d;
    |     ^^^^^^
@@ -63,7 +130,7 @@ LL |     };
    |      +
 
 error: unneeded late initialization
-  --> $DIR/needless_late_init.rs:46:5
+  --> $DIR/needless_late_init.rs:63:5
    |
 LL |     let e;
    |     ^^^^^^
@@ -84,7 +151,7 @@ LL |     };
    |      +
 
 error: unneeded late initialization
-  --> $DIR/needless_late_init.rs:53:5
+  --> $DIR/needless_late_init.rs:70:5
    |
 LL |     let f;
    |     ^^^^^^
@@ -100,7 +167,7 @@ LL +         1 => "three",
    | 
 
 error: unneeded late initialization
-  --> $DIR/needless_late_init.rs:59:5
+  --> $DIR/needless_late_init.rs:76:5
    |
 LL |     let g: usize;
    |     ^^^^^^^^^^^^^
@@ -120,7 +187,7 @@ LL |     };
    |      +
 
 error: unneeded late initialization
-  --> $DIR/needless_late_init.rs:67:5
+  --> $DIR/needless_late_init.rs:84:5
    |
 LL |     let x;
    |     ^^^^^^ created here
@@ -134,7 +201,7 @@ LL |     let x = 1;
    |     ~~~~~
 
 error: unneeded late initialization
-  --> $DIR/needless_late_init.rs:71:5
+  --> $DIR/needless_late_init.rs:88:5
    |
 LL |     let x;
    |     ^^^^^^ created here
@@ -148,7 +215,7 @@ LL |     let x = SignificantDrop;
    |     ~~~~~
 
 error: unneeded late initialization
-  --> $DIR/needless_late_init.rs:75:5
+  --> $DIR/needless_late_init.rs:92:5
    |
 LL |     let x;
    |     ^^^^^^ created here
@@ -162,7 +229,7 @@ LL |     let x = SignificantDrop;
    |     ~~~~~
 
 error: unneeded late initialization
-  --> $DIR/needless_late_init.rs:94:5
+  --> $DIR/needless_late_init.rs:111:5
    |
 LL |     let a;
    |     ^^^^^^
@@ -183,7 +250,7 @@ LL |     };
    |      +
 
 error: unneeded late initialization
-  --> $DIR/needless_late_init.rs:111:5
+  --> $DIR/needless_late_init.rs:128:5
    |
 LL |     let a;
    |     ^^^^^^
@@ -203,72 +270,5 @@ help: add a semicolon after the `match` expression
 LL |     };
    |      +
 
-error: unneeded late initialization
-  --> $DIR/needless_late_init.rs:244:9
-   |
-LL |         let a;
-   |         ^^^^^^ created here
-LL |         a = "zero";
-   |         ^^^^^^^^^^ initialised here
-   |
-help: declare `a` here
-   |
-LL |         let a = "zero";
-   |         ~~~~~
-
-error: unneeded late initialization
-  --> $DIR/needless_late_init.rs:247:9
-   |
-LL |         let b;
-   |         ^^^^^^ created here
-LL |         let c;
-LL |         b = 1;
-   |         ^^^^^ initialised here
-   |
-help: declare `b` here
-   |
-LL |         let b = 1;
-   |         ~~~~~
-
-error: unneeded late initialization
-  --> $DIR/needless_late_init.rs:248:9
-   |
-LL |         let c;
-   |         ^^^^^^ created here
-LL |         b = 1;
-LL |         c = 2;
-   |         ^^^^^ initialised here
-   |
-help: declare `c` here
-   |
-LL |         let c = 2;
-   |         ~~~~~
-
-error: unneeded late initialization
-  --> $DIR/needless_late_init.rs:252:9
-   |
-LL |         let d: usize;
-   |         ^^^^^^^^^^^^^ created here
-LL |         d = 1;
-   |         ^^^^^ initialised here
-   |
-help: declare `d` here
-   |
-LL |         let d: usize = 1;
-   |         ~~~~~~~~~~~~
-
-error: unneeded late initialization
-  --> $DIR/needless_late_init.rs:255:9
-   |
-LL |         let e;
-   |         ^^^^^^ created here
-LL |         e = format!("{}", d);
-   |         ^^^^^^^^^^^^^^^^^^^^ initialised here
-   |
-help: declare `e` here
-   |
-LL |         let e = format!("{}", d);
-   |         ~~~~~
-
 error: aborting due to 16 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From c5410150eb5563ed1f0529bf16e0524846a8979d Mon Sep 17 00:00:00 2001
From: lyj <sjtu5140809011@gmail.com>
Date: Sun, 29 May 2022 09:57:15 +0800
Subject: needless_deref

---
 CHANGELOG.md                                       |   1 +
 clippy_lints/src/borrow_deref_ref.rs               | 118 +++++++++++++++++++++
 clippy_lints/src/checked_conversions.rs            |   4 +-
 clippy_lints/src/let_if_seq.rs                     |   2 +-
 clippy_lints/src/lib.register_all.rs               |   1 +
 clippy_lints/src/lib.register_complexity.rs        |   1 +
 clippy_lints/src/lib.register_lints.rs             |   1 +
 clippy_lints/src/lib.rs                            |   2 +
 clippy_lints/src/loops/never_loop.rs               |   2 +-
 clippy_lints/src/matches/match_bool.rs             |   4 +-
 clippy_lints/src/methods/unnecessary_to_owned.rs   |   2 +-
 clippy_lints/src/mixed_read_write_in_expression.rs |   2 +-
 clippy_lints/src/mut_key.rs                        |   2 +-
 clippy_lints/src/panic_in_result_fn.rs             |   2 +-
 clippy_lints/src/pass_by_ref_or_value.rs           |   2 +-
 clippy_lints/src/redundant_clone.rs                |   6 +-
 clippy_lints/src/redundant_static_lifetimes.rs     |   9 +-
 clippy_lints/src/size_of_in_element_count.rs       |   2 +-
 clippy_lints/src/utils/internal_lints.rs           |   8 +-
 .../src/utils/internal_lints/metadata_collector.rs |   3 +-
 clippy_utils/src/consts.rs                         |   2 +-
 clippy_utils/src/higher.rs                         |   2 +-
 clippy_utils/src/hir_utils.rs                      |   6 +-
 clippy_utils/src/lib.rs                            |   4 +-
 tests/ui-internal/unnecessary_symbol_str.fixed     |   1 +
 tests/ui-internal/unnecessary_symbol_str.rs        |   1 +
 tests/ui-internal/unnecessary_symbol_str.stderr    |  10 +-
 tests/ui/borrow_deref_ref.rs                       |  58 ++++++++++
 tests/ui/borrow_deref_ref.stderr                   |  37 +++++++
 tests/ui/collapsible_match2.rs                     |   2 +-
 tests/ui/collapsible_match2.stderr                 |   4 +-
 tests/ui/deref_by_slicing.fixed                    |   1 +
 tests/ui/deref_by_slicing.rs                       |   1 +
 tests/ui/deref_by_slicing.stderr                   |  18 ++--
 tests/ui/explicit_deref_methods.fixed              |   7 +-
 tests/ui/explicit_deref_methods.rs                 |   7 +-
 tests/ui/explicit_deref_methods.stderr             |  24 ++---
 tests/ui/forget_ref.rs                             |   1 +
 tests/ui/forget_ref.stderr                         |  36 +++----
 tests/ui/recursive_format_impl.rs                  |   3 +-
 tests/ui/recursive_format_impl.stderr              |  20 ++--
 41 files changed, 325 insertions(+), 94 deletions(-)
 create mode 100644 clippy_lints/src/borrow_deref_ref.rs
 create mode 100644 tests/ui/borrow_deref_ref.rs
 create mode 100644 tests/ui/borrow_deref_ref.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 3aaa79a1719..ece80343622 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3296,6 +3296,7 @@ Released 2018-09-13
 [`bool_assert_comparison`]: https://rust-lang.github.io/rust-clippy/master/index.html#bool_assert_comparison
 [`bool_comparison`]: https://rust-lang.github.io/rust-clippy/master/index.html#bool_comparison
 [`borrow_as_ptr`]: https://rust-lang.github.io/rust-clippy/master/index.html#borrow_as_ptr
+[`borrow_deref_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#borrow_deref_ref
 [`borrow_interior_mutable_const`]: https://rust-lang.github.io/rust-clippy/master/index.html#borrow_interior_mutable_const
 [`borrowed_box`]: https://rust-lang.github.io/rust-clippy/master/index.html#borrowed_box
 [`box_collection`]: https://rust-lang.github.io/rust-clippy/master/index.html#box_collection
diff --git a/clippy_lints/src/borrow_deref_ref.rs b/clippy_lints/src/borrow_deref_ref.rs
new file mode 100644
index 00000000000..ec2f31cf673
--- /dev/null
+++ b/clippy_lints/src/borrow_deref_ref.rs
@@ -0,0 +1,118 @@
+use crate::reference::DEREF_ADDROF;
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::source::snippet_opt;
+use clippy_utils::ty::implements_trait;
+use clippy_utils::{get_parent_expr, is_lint_allowed};
+use rustc_errors::Applicability;
+use rustc_hir::{ExprKind, UnOp};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::mir::Mutability;
+use rustc_middle::ty;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `&*(&T)`.
+    ///
+    /// ### Why is this bad?
+    /// Dereferencing and then borrowing a reference value has no effect in most cases.
+    ///
+    /// ### Known problems
+    /// false negative on such code:
+    /// ```
+    /// let x = &12;
+    /// let addr_x = &x as *const _ as usize;
+    /// let addr_y = &&*x as *const _ as usize; // assert ok now, and lint triggerd.
+    ///                                         // But if we fix it, assert will fail.
+    /// assert_ne!(addr_x, addr_y);
+    /// ```
+    ///
+    /// ### Example
+    /// ```rust
+    /// let s = &String::new();
+    ///
+    /// // Bad
+    /// let a: &String = &* s;
+    /// foo(&*s);
+    ///
+    /// // Good
+    /// let a: &String = s;
+    /// foo(&**s);
+    ///
+    /// fn foo(_: &str){ }
+    /// ```
+    #[clippy::version = "1.59.0"]
+    pub BORROW_DEREF_REF,
+    complexity,
+    "deref on an immutable reference returns the same type as itself"
+}
+
+declare_lint_pass!(BorrowDerefRef => [BORROW_DEREF_REF]);
+
+impl LateLintPass<'_> for BorrowDerefRef {
+    fn check_expr(&mut self, cx: &LateContext<'_>, e: &rustc_hir::Expr<'_>) {
+        if_chain! {
+            if !e.span.from_expansion();
+            if let ExprKind::AddrOf(_, Mutability::Not, addrof_target) = e.kind;
+            if !addrof_target.span.from_expansion();
+            if let ExprKind::Unary(UnOp::Deref, deref_target) = addrof_target.kind;
+            if !deref_target.span.from_expansion();
+            if !matches!(deref_target.kind, ExprKind::Unary(UnOp::Deref, ..) );
+            let ref_ty = cx.typeck_results().expr_ty(deref_target);
+            if let ty::Ref(_, inner_ty, Mutability::Not) = ref_ty.kind();
+            then{
+
+                if let Some(parent_expr) = get_parent_expr(cx, e){
+                    if matches!(parent_expr.kind, ExprKind::Unary(UnOp::Deref, ..)) &&
+                       !is_lint_allowed(cx, DEREF_ADDROF, parent_expr.hir_id) {
+                        return;
+                    }
+
+                    // modification to `&mut &*x` is different from `&mut x`
+                    if matches!(deref_target.kind, ExprKind::Path(..)
+                                             | ExprKind::Field(..)
+                                             | ExprKind::Index(..)
+                                             | ExprKind::Unary(UnOp::Deref, ..))
+                     && matches!(parent_expr.kind, ExprKind::AddrOf(_, Mutability::Mut, _)) {
+                       return;
+                    }
+                }
+
+                span_lint_and_then(
+                    cx,
+                    BORROW_DEREF_REF,
+                    e.span,
+                    "deref on an immutable reference",
+                    |diag| {
+                        diag.span_suggestion(
+                            e.span,
+                            "if you would like to reborrow, try removing `&*`",
+                            snippet_opt(cx, deref_target.span).unwrap(),
+                            Applicability::MachineApplicable
+                        );
+
+                        // has deref trait -> give 2 help
+                        // doesn't have deref trait -> give 1 help
+                        if let Some(deref_trait_id) = cx.tcx.lang_items().deref_trait(){
+                            if !implements_trait(cx, *inner_ty, deref_trait_id, &[]) {
+                                return;
+                            }
+                        }
+
+                        diag.span_suggestion(
+                            e.span,
+                            "if you would like to deref, try using `&**`",
+                            format!(
+                                "&**{}",
+                                &snippet_opt(cx, deref_target.span).unwrap(),
+                             ),
+                            Applicability::MaybeIncorrect
+                        );
+
+                    }
+                );
+
+            }
+        }
+    }
+}
diff --git a/clippy_lints/src/checked_conversions.rs b/clippy_lints/src/checked_conversions.rs
index 7eeaaa01921..1010340c712 100644
--- a/clippy_lints/src/checked_conversions.rs
+++ b/clippy_lints/src/checked_conversions.rs
@@ -318,7 +318,7 @@ fn get_implementing_type<'a>(path: &QPath<'_>, candidates: &'a [&str], function:
         if let QPath::TypeRelative(ty, path) = &path;
         if path.ident.name.as_str() == function;
         if let TyKind::Path(QPath::Resolved(None, tp)) = &ty.kind;
-        if let [int] = &*tp.segments;
+        if let [int] = tp.segments;
         then {
             let name = int.ident.name.as_str();
             candidates.iter().find(|c| &name == *c).copied()
@@ -332,7 +332,7 @@ fn get_implementing_type<'a>(path: &QPath<'_>, candidates: &'a [&str], function:
 fn int_ty_to_sym<'tcx>(path: &QPath<'_>) -> Option<&'tcx str> {
     if_chain! {
         if let QPath::Resolved(_, path) = *path;
-        if let [ty] = &*path.segments;
+        if let [ty] = path.segments;
         then {
             let name = ty.ident.name.as_str();
             INTS.iter().find(|c| &name == *c).copied()
diff --git a/clippy_lints/src/let_if_seq.rs b/clippy_lints/src/let_if_seq.rs
index db09d00d730..56bbbbbc819 100644
--- a/clippy_lints/src/let_if_seq.rs
+++ b/clippy_lints/src/let_if_seq.rs
@@ -68,7 +68,7 @@ impl<'tcx> LateLintPass<'tcx> for LetIfSeq {
                 if let hir::ExprKind::If(hir::Expr { kind: hir::ExprKind::DropTemps(cond), ..}, then, else_) = if_.kind;
                 if !is_local_used(cx, *cond, canonical_id);
                 if let hir::ExprKind::Block(then, _) = then.kind;
-                if let Some(value) = check_assign(cx, canonical_id, &*then);
+                if let Some(value) = check_assign(cx, canonical_id, then);
                 if !is_local_used(cx, value, canonical_id);
                 then {
                     let span = stmt.span.to(if_.span);
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index a028b41db77..de43d4be1b3 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -24,6 +24,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(bool_assert_comparison::BOOL_ASSERT_COMPARISON),
     LintId::of(booleans::LOGIC_BUG),
     LintId::of(booleans::NONMINIMAL_BOOL),
+    LintId::of(borrow_deref_ref::BORROW_DEREF_REF),
     LintId::of(bytes_count_to_len::BYTES_COUNT_TO_LEN),
     LintId::of(casts::CAST_ABS_TO_UNSIGNED),
     LintId::of(casts::CAST_ENUM_CONSTRUCTOR),
diff --git a/clippy_lints/src/lib.register_complexity.rs b/clippy_lints/src/lib.register_complexity.rs
index d5dfcd10a66..67ddae45bc0 100644
--- a/clippy_lints/src/lib.register_complexity.rs
+++ b/clippy_lints/src/lib.register_complexity.rs
@@ -5,6 +5,7 @@
 store.register_group(true, "clippy::complexity", Some("clippy_complexity"), vec![
     LintId::of(attrs::DEPRECATED_CFG_ATTR),
     LintId::of(booleans::NONMINIMAL_BOOL),
+    LintId::of(borrow_deref_ref::BORROW_DEREF_REF),
     LintId::of(bytes_count_to_len::BYTES_COUNT_TO_LEN),
     LintId::of(casts::CHAR_LIT_AS_U8),
     LintId::of(casts::UNNECESSARY_CAST),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 1f2132cf620..42a17eb12ce 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -64,6 +64,7 @@ store.register_lints(&[
     booleans::LOGIC_BUG,
     booleans::NONMINIMAL_BOOL,
     borrow_as_ptr::BORROW_AS_PTR,
+    borrow_deref_ref::BORROW_DEREF_REF,
     bytecount::NAIVE_BYTECOUNT,
     bytes_count_to_len::BYTES_COUNT_TO_LEN,
     cargo::CARGO_COMMON_METADATA,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index d611600cf71..ca5e62ff431 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -183,6 +183,7 @@ mod blocks_in_if_conditions;
 mod bool_assert_comparison;
 mod booleans;
 mod borrow_as_ptr;
+mod borrow_deref_ref;
 mod bytecount;
 mod bytes_count_to_len;
 mod cargo;
@@ -638,6 +639,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(mutex_atomic::Mutex));
     store.register_late_pass(|| Box::new(needless_update::NeedlessUpdate));
     store.register_late_pass(|| Box::new(needless_borrowed_ref::NeedlessBorrowedRef));
+    store.register_late_pass(|| Box::new(borrow_deref_ref::BorrowDerefRef));
     store.register_late_pass(|| Box::new(no_effect::NoEffect));
     store.register_late_pass(|| Box::new(temporary_assignment::TemporaryAssignment));
     store.register_late_pass(|| Box::new(transmute::Transmute));
diff --git a/clippy_lints/src/loops/never_loop.rs b/clippy_lints/src/loops/never_loop.rs
index 70a118d6b35..c025f5972d5 100644
--- a/clippy_lints/src/loops/never_loop.rs
+++ b/clippy_lints/src/loops/never_loop.rs
@@ -146,7 +146,7 @@ fn never_loop_expr(expr: &Expr<'_>, main_loop_id: HirId) -> NeverLoopResult {
             if arms.is_empty() {
                 e
             } else {
-                let arms = never_loop_expr_branch(&mut arms.iter().map(|a| &*a.body), main_loop_id);
+                let arms = never_loop_expr_branch(&mut arms.iter().map(|a| a.body), main_loop_id);
                 combine_seq(e, arms)
             }
         },
diff --git a/clippy_lints/src/matches/match_bool.rs b/clippy_lints/src/matches/match_bool.rs
index 90c50b994d2..1c216e13570 100644
--- a/clippy_lints/src/matches/match_bool.rs
+++ b/clippy_lints/src/matches/match_bool.rs
@@ -24,8 +24,8 @@ pub(crate) fn check(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>], expr:
                     let exprs = if let PatKind::Lit(arm_bool) = arms[0].pat.kind {
                         if let ExprKind::Lit(ref lit) = arm_bool.kind {
                             match lit.node {
-                                LitKind::Bool(true) => Some((&*arms[0].body, &*arms[1].body)),
-                                LitKind::Bool(false) => Some((&*arms[1].body, &*arms[0].body)),
+                                LitKind::Bool(true) => Some((arms[0].body, arms[1].body)),
+                                LitKind::Bool(false) => Some((arms[1].body, arms[0].body)),
                                 _ => None,
                             }
                         } else {
diff --git a/clippy_lints/src/methods/unnecessary_to_owned.rs b/clippy_lints/src/methods/unnecessary_to_owned.rs
index 97c4feb3122..b4c6bfb31ed 100644
--- a/clippy_lints/src/methods/unnecessary_to_owned.rs
+++ b/clippy_lints/src/methods/unnecessary_to_owned.rs
@@ -415,7 +415,7 @@ fn is_cloned_or_copied(cx: &LateContext<'_>, method_name: Symbol, method_def_id:
 /// Returns true if the named method can be used to convert the receiver to its "owned"
 /// representation.
 fn is_to_owned_like(cx: &LateContext<'_>, method_name: Symbol, method_def_id: DefId) -> bool {
-    is_clone_like(cx, &*method_name.as_str(), method_def_id)
+    is_clone_like(cx, method_name.as_str(), method_def_id)
         || is_cow_into_owned(cx, method_name, method_def_id)
         || is_to_string(cx, method_name, method_def_id)
 }
diff --git a/clippy_lints/src/mixed_read_write_in_expression.rs b/clippy_lints/src/mixed_read_write_in_expression.rs
index 405fc23e8de..024bd076071 100644
--- a/clippy_lints/src/mixed_read_write_in_expression.rs
+++ b/clippy_lints/src/mixed_read_write_in_expression.rs
@@ -120,7 +120,7 @@ impl<'a, 'tcx> DivergenceVisitor<'a, 'tcx> {
                         self.visit_expr(if_expr);
                     }
                     // make sure top level arm expressions aren't linted
-                    self.maybe_walk_expr(&*arm.body);
+                    self.maybe_walk_expr(arm.body);
                 }
             },
             _ => walk_expr(self, e),
diff --git a/clippy_lints/src/mut_key.rs b/clippy_lints/src/mut_key.rs
index cba54e14212..7e2531c7ca5 100644
--- a/clippy_lints/src/mut_key.rs
+++ b/clippy_lints/src/mut_key.rs
@@ -105,7 +105,7 @@ impl<'tcx> LateLintPass<'tcx> for MutableKeyType {
         if let hir::PatKind::Wild = local.pat.kind {
             return;
         }
-        check_ty(cx, local.span, cx.typeck_results().pat_ty(&*local.pat));
+        check_ty(cx, local.span, cx.typeck_results().pat_ty(local.pat));
     }
 }
 
diff --git a/clippy_lints/src/panic_in_result_fn.rs b/clippy_lints/src/panic_in_result_fn.rs
index b7a56970b33..21acf003d92 100644
--- a/clippy_lints/src/panic_in_result_fn.rs
+++ b/clippy_lints/src/panic_in_result_fn.rs
@@ -61,7 +61,7 @@ fn lint_impl_body<'tcx>(cx: &LateContext<'tcx>, impl_span: Span, body: &'tcx hir
     expr_visitor_no_bodies(|expr| {
         let Some(macro_call) = root_macro_call_first_node(cx, expr) else { return true };
         if matches!(
-            &*cx.tcx.item_name(macro_call.def_id).as_str(),
+            cx.tcx.item_name(macro_call.def_id).as_str(),
             "unimplemented" | "unreachable" | "panic" | "todo" | "assert" | "assert_eq" | "assert_ne"
         ) {
             panics.push(macro_call.span);
diff --git a/clippy_lints/src/pass_by_ref_or_value.rs b/clippy_lints/src/pass_by_ref_or_value.rs
index e3ded716341..5a93431f25a 100644
--- a/clippy_lints/src/pass_by_ref_or_value.rs
+++ b/clippy_lints/src/pass_by_ref_or_value.rs
@@ -233,7 +233,7 @@ impl<'tcx> LateLintPass<'tcx> for PassByRefOrValue {
         }
 
         if let hir::TraitItemKind::Fn(method_sig, _) = &item.kind {
-            self.check_poly_fn(cx, item.def_id, &*method_sig.decl, None);
+            self.check_poly_fn(cx, item.def_id, method_sig.decl, None);
         }
     }
 
diff --git a/clippy_lints/src/redundant_clone.rs b/clippy_lints/src/redundant_clone.rs
index 0004b8afdd3..f7a6fbac166 100644
--- a/clippy_lints/src/redundant_clone.rs
+++ b/clippy_lints/src/redundant_clone.rs
@@ -288,8 +288,8 @@ fn is_call_with_ref_arg<'tcx>(
         if let mir::TerminatorKind::Call { func, args, destination, .. } = kind;
         if args.len() == 1;
         if let mir::Operand::Move(mir::Place { local, .. }) = &args[0];
-        if let ty::FnDef(def_id, _) = *func.ty(&*mir, cx.tcx).kind();
-        if let (inner_ty, 1) = walk_ptrs_ty_depth(args[0].ty(&*mir, cx.tcx));
+        if let ty::FnDef(def_id, _) = *func.ty(mir, cx.tcx).kind();
+        if let (inner_ty, 1) = walk_ptrs_ty_depth(args[0].ty(mir, cx.tcx));
         if !is_copy(cx, inner_ty);
         then {
             Some((def_id, *local, inner_ty, destination.as_ref().map(|(dest, _)| dest)?.as_local()?))
@@ -318,7 +318,7 @@ fn find_stmt_assigns_to<'tcx>(
         None
     })?;
 
-    match (by_ref, &*rvalue) {
+    match (by_ref, rvalue) {
         (true, mir::Rvalue::Ref(_, _, place)) | (false, mir::Rvalue::Use(mir::Operand::Copy(place))) => {
             Some(base_local_and_movability(cx, mir, *place))
         },
diff --git a/clippy_lints/src/redundant_static_lifetimes.rs b/clippy_lints/src/redundant_static_lifetimes.rs
index 2d26c49252f..0825f00f421 100644
--- a/clippy_lints/src/redundant_static_lifetimes.rs
+++ b/clippy_lints/src/redundant_static_lifetimes.rs
@@ -51,12 +51,12 @@ impl RedundantStaticLifetimes {
     fn visit_type(&mut self, ty: &Ty, cx: &EarlyContext<'_>, reason: &str) {
         match ty.kind {
             // Be careful of nested structures (arrays and tuples)
-            TyKind::Array(ref ty, _) => {
-                self.visit_type(&*ty, cx, reason);
+            TyKind::Array(ref ty, _) | TyKind::Slice(ref ty) => {
+                self.visit_type(ty, cx, reason);
             },
             TyKind::Tup(ref tup) => {
                 for tup_ty in tup {
-                    self.visit_type(&*tup_ty, cx, reason);
+                    self.visit_type(tup_ty, cx, reason);
                 }
             },
             // This is what we are looking for !
@@ -89,9 +89,6 @@ impl RedundantStaticLifetimes {
                 }
                 self.visit_type(&*borrow_type.ty, cx, reason);
             },
-            TyKind::Slice(ref ty) => {
-                self.visit_type(ty, cx, reason);
-            },
             _ => {},
         }
     }
diff --git a/clippy_lints/src/size_of_in_element_count.rs b/clippy_lints/src/size_of_in_element_count.rs
index 3d7dc49b406..bfb9f0d01e1 100644
--- a/clippy_lints/src/size_of_in_element_count.rs
+++ b/clippy_lints/src/size_of_in_element_count.rs
@@ -110,7 +110,7 @@ fn get_pointee_ty_and_count_expr<'tcx>(
         // Find calls to copy_{from,to}{,_nonoverlapping} and write_bytes methods
         if let ExprKind::MethodCall(method_path, [ptr_self, .., count], _) = expr.kind;
         let method_ident = method_path.ident.as_str();
-        if METHODS.iter().any(|m| *m == &*method_ident);
+        if METHODS.iter().any(|m| *m == method_ident);
 
         // Get the pointee type
         if let ty::RawPtr(TypeAndMut { ty: pointee_ty, .. }) =
diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs
index 0e8f40e9210..60f98876994 100644
--- a/clippy_lints/src/utils/internal_lints.rs
+++ b/clippy_lints/src/utils/internal_lints.rs
@@ -422,7 +422,7 @@ impl<'tcx> LateLintPass<'tcx> for LintWithoutLintPass {
             }
         } else if let Some(macro_call) = root_macro_call_first_node(cx, item) {
             if !matches!(
-                &*cx.tcx.item_name(macro_call.def_id).as_str(),
+                cx.tcx.item_name(macro_call.def_id).as_str(),
                 "impl_lint_pass" | "declare_lint_pass"
             ) {
                 return;
@@ -504,7 +504,7 @@ fn check_invalid_clippy_version_attribute(cx: &LateContext<'_>, item: &'_ Item<'
             return;
         }
 
-        if RustcVersion::parse(&*value.as_str()).is_err() {
+        if RustcVersion::parse(value.as_str()).is_err() {
             span_lint_and_help(
                 cx,
                 INVALID_CLIPPY_VERSION_ATTRIBUTE,
@@ -595,7 +595,7 @@ impl<'tcx> LateLintPass<'tcx> for CompilerLintFunctions {
         if_chain! {
             if let ExprKind::MethodCall(path, [self_arg, ..], _) = &expr.kind;
             let fn_name = path.ident;
-            if let Some(sugg) = self.map.get(&*fn_name.as_str());
+            if let Some(sugg) = self.map.get(fn_name.as_str());
             let ty = cx.typeck_results().expr_ty(self_arg).peel_refs();
             if match_type(cx, ty, &paths::EARLY_CONTEXT)
                 || match_type(cx, ty, &paths::LATE_CONTEXT);
@@ -679,7 +679,7 @@ impl<'tcx> LateLintPass<'tcx> for CollapsibleCalls {
             then {
                 let and_then_snippets = get_and_then_snippets(cx, and_then_args);
                 let mut sle = SpanlessEq::new(cx).deny_side_effects();
-                match &*ps.ident.as_str() {
+                match ps.ident.as_str() {
                     "span_suggestion" if sle.eq_expr(&and_then_args[2], &span_call_args[1]) => {
                         suggest_suggestion(cx, expr, &and_then_snippets, &span_suggestion_snippets(cx, span_call_args));
                     },
diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index 8c1910b3b2a..53579ccb4c2 100644
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -527,12 +527,11 @@ fn extract_attr_docs_or_lint(cx: &LateContext<'_>, item: &Item<'_>) -> Option<St
 fn extract_attr_docs(cx: &LateContext<'_>, item: &Item<'_>) -> Option<String> {
     let attrs = cx.tcx.hir().attrs(item.hir_id());
     let mut lines = attrs.iter().filter_map(ast::Attribute::doc_str);
-    let mut docs = String::from(&*lines.next()?.as_str());
+    let mut docs = String::from(lines.next()?.as_str());
     let mut in_code_block = false;
     let mut is_code_block_rust = false;
     for line in lines {
         let line = line.as_str();
-        let line = &*line;
 
         // Rustdoc hides code lines starting with `# ` and this removes them from Clippy's lint list :)
         if is_code_block_rust && line.trim_start().starts_with("# ") {
diff --git a/clippy_utils/src/consts.rs b/clippy_utils/src/consts.rs
index 9f162a117b2..d487868cafe 100644
--- a/clippy_utils/src/consts.rs
+++ b/clippy_utils/src/consts.rs
@@ -478,7 +478,7 @@ impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
     fn ifthenelse(&mut self, cond: &Expr<'_>, then: &Expr<'_>, otherwise: Option<&Expr<'_>>) -> Option<Constant> {
         if let Some(Constant::Bool(b)) = self.expr(cond) {
             if b {
-                self.expr(&*then)
+                self.expr(then)
             } else {
                 otherwise.as_ref().and_then(|expr| self.expr(expr))
             }
diff --git a/clippy_utils/src/higher.rs b/clippy_utils/src/higher.rs
index 1e0fc789af2..4604ae5c2c7 100644
--- a/clippy_utils/src/higher.rs
+++ b/clippy_utils/src/higher.rs
@@ -35,7 +35,7 @@ impl<'tcx> ForLoop<'tcx> {
             if let hir::ExprKind::Match(iterexpr, [arm], hir::MatchSource::ForLoopDesugar) = e.kind;
             if let hir::ExprKind::Call(_, [arg]) = iterexpr.kind;
             if let hir::ExprKind::Loop(block, ..) = arm.body.kind;
-            if let [stmt] = &*block.stmts;
+            if let [stmt] = block.stmts;
             if let hir::StmtKind::Expr(e) = stmt.kind;
             if let hir::ExprKind::Match(_, [_, some_arm], _) = e.kind;
             if let hir::PatKind::Struct(_, [field], _) = some_arm.pat.kind;
diff --git a/clippy_utils/src/hir_utils.rs b/clippy_utils/src/hir_utils.rs
index c440793b90e..cbd0a257cfb 100644
--- a/clippy_utils/src/hir_utils.rs
+++ b/clippy_utils/src/hir_utils.rs
@@ -411,10 +411,10 @@ impl HirEqInterExpr<'_, '_, '_> {
             (&TyKind::Slice(l_vec), &TyKind::Slice(r_vec)) => self.eq_ty(l_vec, r_vec),
             (&TyKind::Array(lt, ll), &TyKind::Array(rt, rl)) => self.eq_ty(lt, rt) && self.eq_array_length(ll, rl),
             (&TyKind::Ptr(ref l_mut), &TyKind::Ptr(ref r_mut)) => {
-                l_mut.mutbl == r_mut.mutbl && self.eq_ty(&*l_mut.ty, &*r_mut.ty)
+                l_mut.mutbl == r_mut.mutbl && self.eq_ty(l_mut.ty, r_mut.ty)
             },
             (&TyKind::Rptr(_, ref l_rmut), &TyKind::Rptr(_, ref r_rmut)) => {
-                l_rmut.mutbl == r_rmut.mutbl && self.eq_ty(&*l_rmut.ty, &*r_rmut.ty)
+                l_rmut.mutbl == r_rmut.mutbl && self.eq_ty(l_rmut.ty, r_rmut.ty)
             },
             (&TyKind::Path(ref l), &TyKind::Path(ref r)) => self.eq_qpath(l, r),
             (&TyKind::Tup(l), &TyKind::Tup(r)) => over(l, r, |l, r| self.eq_ty(l, r)),
@@ -608,7 +608,7 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> {
                     self.hash_name(i.ident.name);
                 }
                 if let Some(j) = *j {
-                    self.hash_expr(&*j);
+                    self.hash_expr(j);
                 }
             },
             ExprKind::Box(e) | ExprKind::DropTemps(e) | ExprKind::Yield(e, _) => {
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index b8a80d4adc3..1ca7cf5c177 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -1443,7 +1443,7 @@ pub fn is_refutable(cx: &LateContext<'_>, pat: &Pat<'_>) -> bool {
         },
         PatKind::Tuple(pats, _) => are_refutable(cx, pats),
         PatKind::Struct(ref qpath, fields, _) => {
-            is_enum_variant(cx, qpath, pat.hir_id) || are_refutable(cx, fields.iter().map(|field| &*field.pat))
+            is_enum_variant(cx, qpath, pat.hir_id) || are_refutable(cx, fields.iter().map(|field| field.pat))
         },
         PatKind::TupleStruct(ref qpath, pats, _) => is_enum_variant(cx, qpath, pat.hir_id) || are_refutable(cx, pats),
         PatKind::Slice(head, middle, tail) => {
@@ -1658,7 +1658,7 @@ pub fn if_sequence<'tcx>(mut expr: &'tcx Expr<'tcx>) -> (Vec<&'tcx Expr<'tcx>>,
     let mut blocks: Vec<&Block<'_>> = Vec::new();
 
     while let Some(higher::IfOrIfLet { cond, then, r#else }) = higher::IfOrIfLet::hir(expr) {
-        conds.push(&*cond);
+        conds.push(cond);
         if let ExprKind::Block(block, _) = then.kind {
             blocks.push(block);
         } else {
diff --git a/tests/ui-internal/unnecessary_symbol_str.fixed b/tests/ui-internal/unnecessary_symbol_str.fixed
index 4f5336663a8..6033d06e4f6 100644
--- a/tests/ui-internal/unnecessary_symbol_str.fixed
+++ b/tests/ui-internal/unnecessary_symbol_str.fixed
@@ -2,6 +2,7 @@
 #![feature(rustc_private)]
 #![deny(clippy::internal)]
 #![allow(
+    clippy::borrow_deref_ref,
     clippy::unnecessary_operation,
     unused_must_use,
     clippy::missing_clippy_version_attribute
diff --git a/tests/ui-internal/unnecessary_symbol_str.rs b/tests/ui-internal/unnecessary_symbol_str.rs
index 894aa1d3bc6..1bb5d55f0b6 100644
--- a/tests/ui-internal/unnecessary_symbol_str.rs
+++ b/tests/ui-internal/unnecessary_symbol_str.rs
@@ -2,6 +2,7 @@
 #![feature(rustc_private)]
 #![deny(clippy::internal)]
 #![allow(
+    clippy::borrow_deref_ref,
     clippy::unnecessary_operation,
     unused_must_use,
     clippy::missing_clippy_version_attribute
diff --git a/tests/ui-internal/unnecessary_symbol_str.stderr b/tests/ui-internal/unnecessary_symbol_str.stderr
index 75367bf4bc5..a1f507f331d 100644
--- a/tests/ui-internal/unnecessary_symbol_str.stderr
+++ b/tests/ui-internal/unnecessary_symbol_str.stderr
@@ -1,5 +1,5 @@
 error: unnecessary `Symbol` to string conversion
-  --> $DIR/unnecessary_symbol_str.rs:15:5
+  --> $DIR/unnecessary_symbol_str.rs:16:5
    |
 LL |     Symbol::intern("foo").as_str() == "clippy";
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Symbol::intern("foo") == rustc_span::sym::clippy`
@@ -12,25 +12,25 @@ LL | #![deny(clippy::internal)]
    = note: `#[deny(clippy::unnecessary_symbol_str)]` implied by `#[deny(clippy::internal)]`
 
 error: unnecessary `Symbol` to string conversion
-  --> $DIR/unnecessary_symbol_str.rs:16:5
+  --> $DIR/unnecessary_symbol_str.rs:17:5
    |
 LL |     Symbol::intern("foo").to_string() == "self";
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Symbol::intern("foo") == rustc_span::symbol::kw::SelfLower`
 
 error: unnecessary `Symbol` to string conversion
-  --> $DIR/unnecessary_symbol_str.rs:17:5
+  --> $DIR/unnecessary_symbol_str.rs:18:5
    |
 LL |     Symbol::intern("foo").to_ident_string() != "Self";
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Symbol::intern("foo") != rustc_span::symbol::kw::SelfUpper`
 
 error: unnecessary `Symbol` to string conversion
-  --> $DIR/unnecessary_symbol_str.rs:18:5
+  --> $DIR/unnecessary_symbol_str.rs:19:5
    |
 LL |     &*Ident::empty().as_str() == "clippy";
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Ident::empty().name == rustc_span::sym::clippy`
 
 error: unnecessary `Symbol` to string conversion
-  --> $DIR/unnecessary_symbol_str.rs:19:5
+  --> $DIR/unnecessary_symbol_str.rs:20:5
    |
 LL |     "clippy" == Ident::empty().to_string();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `rustc_span::sym::clippy == Ident::empty().name`
diff --git a/tests/ui/borrow_deref_ref.rs b/tests/ui/borrow_deref_ref.rs
new file mode 100644
index 00000000000..c8a2c397ff6
--- /dev/null
+++ b/tests/ui/borrow_deref_ref.rs
@@ -0,0 +1,58 @@
+fn main() {}
+
+mod should_lint {
+    fn foo() {
+        let a = &12;
+        let b = &*a;
+
+        let s = &String::new();
+        let x: &str = &*s;
+
+        let b = &mut &*bar(&12);
+    }
+
+    fn bar(x: &u32) -> &u32 {
+        x
+    }
+}
+
+// this mod explains why we should not lint `&mut &* (&T)`
+mod should_not_lint1 {
+    fn foo(x: &mut &u32) {
+        *x = &1;
+    }
+
+    fn main() {
+        let mut x = &0;
+        foo(&mut &*x); // should not lint
+        assert_eq!(*x, 0);
+
+        foo(&mut x);
+        assert_eq!(*x, 1);
+    }
+}
+
+// similar to should_not_lint1
+mod should_not_lint2 {
+    struct S<'a> {
+        a: &'a u32,
+        b: u32,
+    }
+
+    fn main() {
+        let s = S { a: &1, b: 1 };
+        let x = &mut &*s.a;
+        *x = &2;
+    }
+}
+
+// this mod explains why we should not lint `& &* (&T)`
+mod false_negative {
+    fn foo() {
+        let x = &12;
+        let addr_x = &x as *const _ as usize;
+        let addr_y = &&*x as *const _ as usize; // assert ok
+        // let addr_y = &x as *const _ as usize; // assert fail
+        assert_ne!(addr_x, addr_y);
+    }
+}
diff --git a/tests/ui/borrow_deref_ref.stderr b/tests/ui/borrow_deref_ref.stderr
new file mode 100644
index 00000000000..b550b928519
--- /dev/null
+++ b/tests/ui/borrow_deref_ref.stderr
@@ -0,0 +1,37 @@
+error: deref on an immutable reference
+  --> $DIR/borrow_deref_ref.rs:6:17
+   |
+LL |         let b = &*a;
+   |                 ^^^ help: if you would like to reborrow, try removing `&*`: `a`
+   |
+   = note: `-D clippy::borrow-deref-ref` implied by `-D warnings`
+
+error: deref on an immutable reference
+  --> $DIR/borrow_deref_ref.rs:9:23
+   |
+LL |         let x: &str = &*s;
+   |                       ^^^
+   |
+help: if you would like to reborrow, try removing `&*`
+   |
+LL |         let x: &str = s;
+   |                       ~
+help: if you would like to deref, try using `&**`
+   |
+LL |         let x: &str = &**s;
+   |                       ~~~~
+
+error: deref on an immutable reference
+  --> $DIR/borrow_deref_ref.rs:11:22
+   |
+LL |         let b = &mut &*bar(&12);
+   |                      ^^^^^^^^^^ help: if you would like to reborrow, try removing `&*`: `bar(&12)`
+
+error: deref on an immutable reference
+  --> $DIR/borrow_deref_ref.rs:54:23
+   |
+LL |         let addr_y = &&*x as *const _ as usize; // assert ok
+   |                       ^^^ help: if you would like to reborrow, try removing `&*`: `x`
+
+error: aborting due to 4 previous errors
+
diff --git a/tests/ui/collapsible_match2.rs b/tests/ui/collapsible_match2.rs
index 542e6948427..c8fb0a39e95 100644
--- a/tests/ui/collapsible_match2.rs
+++ b/tests/ui/collapsible_match2.rs
@@ -57,7 +57,7 @@ fn lint_cases(opt_opt: Option<Option<u32>>, res_opt: Result<Option<u32>, String>
 
     // ref pattern and deref
     match Some(&[1]) {
-        Some(ref s) => match &*s {
+        Some(ref s) => match s {
             [n] => foo(n),
             _ => (),
         },
diff --git a/tests/ui/collapsible_match2.stderr b/tests/ui/collapsible_match2.stderr
index 46b645aea13..fe64e469379 100644
--- a/tests/ui/collapsible_match2.stderr
+++ b/tests/ui/collapsible_match2.stderr
@@ -78,7 +78,7 @@ LL |             [n] => foo(n),
 error: this `match` can be collapsed into the outer `match`
   --> $DIR/collapsible_match2.rs:60:24
    |
-LL |           Some(ref s) => match &*s {
+LL |           Some(ref s) => match s {
    |  ________________________^
 LL | |             [n] => foo(n),
 LL | |             _ => (),
@@ -88,7 +88,7 @@ LL | |         },
 help: the outer pattern can be modified to include the inner pattern
   --> $DIR/collapsible_match2.rs:60:14
    |
-LL |         Some(ref s) => match &*s {
+LL |         Some(ref s) => match s {
    |              ^^^^^ replace this binding
 LL |             [n] => foo(n),
    |             ^^^ with this pattern
diff --git a/tests/ui/deref_by_slicing.fixed b/tests/ui/deref_by_slicing.fixed
index b26276218b7..257393e56ff 100644
--- a/tests/ui/deref_by_slicing.fixed
+++ b/tests/ui/deref_by_slicing.fixed
@@ -1,6 +1,7 @@
 // run-rustfix
 
 #![warn(clippy::deref_by_slicing)]
+#![allow(clippy::borrow_deref_ref)]
 
 use std::io::Read;
 
diff --git a/tests/ui/deref_by_slicing.rs b/tests/ui/deref_by_slicing.rs
index 6aa1408ba17..e288046f927 100644
--- a/tests/ui/deref_by_slicing.rs
+++ b/tests/ui/deref_by_slicing.rs
@@ -1,6 +1,7 @@
 // run-rustfix
 
 #![warn(clippy::deref_by_slicing)]
+#![allow(clippy::borrow_deref_ref)]
 
 use std::io::Read;
 
diff --git a/tests/ui/deref_by_slicing.stderr b/tests/ui/deref_by_slicing.stderr
index ffd76de378d..8f042ef47eb 100644
--- a/tests/ui/deref_by_slicing.stderr
+++ b/tests/ui/deref_by_slicing.stderr
@@ -1,5 +1,5 @@
 error: slicing when dereferencing would work
-  --> $DIR/deref_by_slicing.rs:9:13
+  --> $DIR/deref_by_slicing.rs:10:13
    |
 LL |     let _ = &vec[..];
    |             ^^^^^^^^ help: dereference the original value instead: `&*vec`
@@ -7,49 +7,49 @@ LL |     let _ = &vec[..];
    = note: `-D clippy::deref-by-slicing` implied by `-D warnings`
 
 error: slicing when dereferencing would work
-  --> $DIR/deref_by_slicing.rs:10:13
+  --> $DIR/deref_by_slicing.rs:11:13
    |
 LL |     let _ = &mut vec[..];
    |             ^^^^^^^^^^^^ help: dereference the original value instead: `&mut *vec`
 
 error: slicing when dereferencing would work
-  --> $DIR/deref_by_slicing.rs:13:13
+  --> $DIR/deref_by_slicing.rs:14:13
    |
 LL |     let _ = &ref_vec[..];
    |             ^^^^^^^^^^^^ help: dereference the original value instead: `&**ref_vec`
 
 error: slicing when dereferencing would work
-  --> $DIR/deref_by_slicing.rs:14:21
+  --> $DIR/deref_by_slicing.rs:15:21
    |
 LL |     let mut_slice = &mut ref_vec[..];
    |                     ^^^^^^^^^^^^^^^^ help: dereference the original value instead: `&mut **ref_vec`
 
 error: slicing when dereferencing would work
-  --> $DIR/deref_by_slicing.rs:15:13
+  --> $DIR/deref_by_slicing.rs:16:13
    |
 LL |     let _ = &mut mut_slice[..]; // Err, re-borrows slice
    |             ^^^^^^^^^^^^^^^^^^ help: reborrow the original value instead: `&mut *mut_slice`
 
 error: slicing when dereferencing would work
-  --> $DIR/deref_by_slicing.rs:18:13
+  --> $DIR/deref_by_slicing.rs:19:13
    |
 LL |     let _ = &s[..];
    |             ^^^^^^ help: dereference the original value instead: `&*s`
 
 error: slicing when dereferencing would work
-  --> $DIR/deref_by_slicing.rs:21:18
+  --> $DIR/deref_by_slicing.rs:22:18
    |
 LL |     let _ = &mut &S[..]; // Err, re-borrows slice
    |                  ^^^^^^ help: reborrow the original value instead: `&*S`
 
 error: slicing when dereferencing would work
-  --> $DIR/deref_by_slicing.rs:25:13
+  --> $DIR/deref_by_slicing.rs:26:13
    |
 LL |     let _ = &slice_ref[..]; // Err, derefs slice
    |             ^^^^^^^^^^^^^^ help: dereference the original value instead: `*slice_ref`
 
 error: slicing when dereferencing would work
-  --> $DIR/deref_by_slicing.rs:28:13
+  --> $DIR/deref_by_slicing.rs:29:13
    |
 LL |     let _ = (&bytes[..]).read_to_end(&mut vec![]).unwrap(); // Err, re-borrows slice
    |             ^^^^^^^^^^^^ help: reborrow the original value instead: `(&*bytes)`
diff --git a/tests/ui/explicit_deref_methods.fixed b/tests/ui/explicit_deref_methods.fixed
index 3de2a51ffa5..92f27e68549 100644
--- a/tests/ui/explicit_deref_methods.fixed
+++ b/tests/ui/explicit_deref_methods.fixed
@@ -1,6 +1,11 @@
 // run-rustfix
 
-#![allow(unused_variables, clippy::clone_double_ref, clippy::needless_borrow)]
+#![allow(
+    unused_variables,
+    clippy::clone_double_ref,
+    clippy::needless_borrow,
+    clippy::borrow_deref_ref
+)]
 #![warn(clippy::explicit_deref_methods)]
 
 use std::ops::{Deref, DerefMut};
diff --git a/tests/ui/explicit_deref_methods.rs b/tests/ui/explicit_deref_methods.rs
index a08d7596422..d118607f992 100644
--- a/tests/ui/explicit_deref_methods.rs
+++ b/tests/ui/explicit_deref_methods.rs
@@ -1,6 +1,11 @@
 // run-rustfix
 
-#![allow(unused_variables, clippy::clone_double_ref, clippy::needless_borrow)]
+#![allow(
+    unused_variables,
+    clippy::clone_double_ref,
+    clippy::needless_borrow,
+    clippy::borrow_deref_ref
+)]
 #![warn(clippy::explicit_deref_methods)]
 
 use std::ops::{Deref, DerefMut};
diff --git a/tests/ui/explicit_deref_methods.stderr b/tests/ui/explicit_deref_methods.stderr
index 8035d77d18d..8e8b358972b 100644
--- a/tests/ui/explicit_deref_methods.stderr
+++ b/tests/ui/explicit_deref_methods.stderr
@@ -1,5 +1,5 @@
 error: explicit `deref` method call
-  --> $DIR/explicit_deref_methods.rs:30:19
+  --> $DIR/explicit_deref_methods.rs:35:19
    |
 LL |     let b: &str = a.deref();
    |                   ^^^^^^^^^ help: try this: `&*a`
@@ -7,67 +7,67 @@ LL |     let b: &str = a.deref();
    = note: `-D clippy::explicit-deref-methods` implied by `-D warnings`
 
 error: explicit `deref_mut` method call
-  --> $DIR/explicit_deref_methods.rs:32:23
+  --> $DIR/explicit_deref_methods.rs:37:23
    |
 LL |     let b: &mut str = a.deref_mut();
    |                       ^^^^^^^^^^^^^ help: try this: `&mut **a`
 
 error: explicit `deref` method call
-  --> $DIR/explicit_deref_methods.rs:35:39
+  --> $DIR/explicit_deref_methods.rs:40:39
    |
 LL |     let b: String = format!("{}, {}", a.deref(), a.deref());
    |                                       ^^^^^^^^^ help: try this: `&*a`
 
 error: explicit `deref` method call
-  --> $DIR/explicit_deref_methods.rs:35:50
+  --> $DIR/explicit_deref_methods.rs:40:50
    |
 LL |     let b: String = format!("{}, {}", a.deref(), a.deref());
    |                                                  ^^^^^^^^^ help: try this: `&*a`
 
 error: explicit `deref` method call
-  --> $DIR/explicit_deref_methods.rs:37:20
+  --> $DIR/explicit_deref_methods.rs:42:20
    |
 LL |     println!("{}", a.deref());
    |                    ^^^^^^^^^ help: try this: `&*a`
 
 error: explicit `deref` method call
-  --> $DIR/explicit_deref_methods.rs:40:11
+  --> $DIR/explicit_deref_methods.rs:45:11
    |
 LL |     match a.deref() {
    |           ^^^^^^^^^ help: try this: `&*a`
 
 error: explicit `deref` method call
-  --> $DIR/explicit_deref_methods.rs:44:28
+  --> $DIR/explicit_deref_methods.rs:49:28
    |
 LL |     let b: String = concat(a.deref());
    |                            ^^^^^^^^^ help: try this: `&*a`
 
 error: explicit `deref` method call
-  --> $DIR/explicit_deref_methods.rs:46:13
+  --> $DIR/explicit_deref_methods.rs:51:13
    |
 LL |     let b = just_return(a).deref();
    |             ^^^^^^^^^^^^^^^^^^^^^^ help: try this: `just_return(a)`
 
 error: explicit `deref` method call
-  --> $DIR/explicit_deref_methods.rs:48:28
+  --> $DIR/explicit_deref_methods.rs:53:28
    |
 LL |     let b: String = concat(just_return(a).deref());
    |                            ^^^^^^^^^^^^^^^^^^^^^^ help: try this: `just_return(a)`
 
 error: explicit `deref` method call
-  --> $DIR/explicit_deref_methods.rs:50:19
+  --> $DIR/explicit_deref_methods.rs:55:19
    |
 LL |     let b: &str = a.deref().deref();
    |                   ^^^^^^^^^^^^^^^^^ help: try this: `&**a`
 
 error: explicit `deref` method call
-  --> $DIR/explicit_deref_methods.rs:53:13
+  --> $DIR/explicit_deref_methods.rs:58:13
    |
 LL |     let b = opt_a.unwrap().deref();
    |             ^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&*opt_a.unwrap()`
 
 error: explicit `deref` method call
-  --> $DIR/explicit_deref_methods.rs:79:31
+  --> $DIR/explicit_deref_methods.rs:84:31
    |
 LL |     let b: &str = expr_deref!(a.deref());
    |                               ^^^^^^^^^ help: try this: `&*a`
diff --git a/tests/ui/forget_ref.rs b/tests/ui/forget_ref.rs
index 6c8c4c9c0ed..031b415f56f 100644
--- a/tests/ui/forget_ref.rs
+++ b/tests/ui/forget_ref.rs
@@ -1,6 +1,7 @@
 #![warn(clippy::forget_ref)]
 #![allow(clippy::toplevel_ref_arg)]
 #![allow(clippy::unnecessary_wraps, clippy::forget_non_drop)]
+#![allow(clippy::borrow_deref_ref)]
 
 use std::mem::forget;
 
diff --git a/tests/ui/forget_ref.stderr b/tests/ui/forget_ref.stderr
index 73409388ed1..df5cd8cacdb 100644
--- a/tests/ui/forget_ref.stderr
+++ b/tests/ui/forget_ref.stderr
@@ -1,108 +1,108 @@
 error: calls to `std::mem::forget` with a reference instead of an owned value. Forgetting a reference does nothing
-  --> $DIR/forget_ref.rs:10:5
+  --> $DIR/forget_ref.rs:11:5
    |
 LL |     forget(&SomeStruct);
    |     ^^^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::forget-ref` implied by `-D warnings`
 note: argument has type `&SomeStruct`
-  --> $DIR/forget_ref.rs:10:12
+  --> $DIR/forget_ref.rs:11:12
    |
 LL |     forget(&SomeStruct);
    |            ^^^^^^^^^^^
 
 error: calls to `std::mem::forget` with a reference instead of an owned value. Forgetting a reference does nothing
-  --> $DIR/forget_ref.rs:13:5
+  --> $DIR/forget_ref.rs:14:5
    |
 LL |     forget(&owned);
    |     ^^^^^^^^^^^^^^
    |
 note: argument has type `&SomeStruct`
-  --> $DIR/forget_ref.rs:13:12
+  --> $DIR/forget_ref.rs:14:12
    |
 LL |     forget(&owned);
    |            ^^^^^^
 
 error: calls to `std::mem::forget` with a reference instead of an owned value. Forgetting a reference does nothing
-  --> $DIR/forget_ref.rs:14:5
+  --> $DIR/forget_ref.rs:15:5
    |
 LL |     forget(&&owned);
    |     ^^^^^^^^^^^^^^^
    |
 note: argument has type `&&SomeStruct`
-  --> $DIR/forget_ref.rs:14:12
+  --> $DIR/forget_ref.rs:15:12
    |
 LL |     forget(&&owned);
    |            ^^^^^^^
 
 error: calls to `std::mem::forget` with a reference instead of an owned value. Forgetting a reference does nothing
-  --> $DIR/forget_ref.rs:15:5
+  --> $DIR/forget_ref.rs:16:5
    |
 LL |     forget(&mut owned);
    |     ^^^^^^^^^^^^^^^^^^
    |
 note: argument has type `&mut SomeStruct`
-  --> $DIR/forget_ref.rs:15:12
+  --> $DIR/forget_ref.rs:16:12
    |
 LL |     forget(&mut owned);
    |            ^^^^^^^^^^
 
 error: calls to `std::mem::forget` with a reference instead of an owned value. Forgetting a reference does nothing
-  --> $DIR/forget_ref.rs:19:5
+  --> $DIR/forget_ref.rs:20:5
    |
 LL |     forget(&*reference1);
    |     ^^^^^^^^^^^^^^^^^^^^
    |
 note: argument has type `&SomeStruct`
-  --> $DIR/forget_ref.rs:19:12
+  --> $DIR/forget_ref.rs:20:12
    |
 LL |     forget(&*reference1);
    |            ^^^^^^^^^^^^
 
 error: calls to `std::mem::forget` with a reference instead of an owned value. Forgetting a reference does nothing
-  --> $DIR/forget_ref.rs:22:5
+  --> $DIR/forget_ref.rs:23:5
    |
 LL |     forget(reference2);
    |     ^^^^^^^^^^^^^^^^^^
    |
 note: argument has type `&mut SomeStruct`
-  --> $DIR/forget_ref.rs:22:12
+  --> $DIR/forget_ref.rs:23:12
    |
 LL |     forget(reference2);
    |            ^^^^^^^^^^
 
 error: calls to `std::mem::forget` with a reference instead of an owned value. Forgetting a reference does nothing
-  --> $DIR/forget_ref.rs:25:5
+  --> $DIR/forget_ref.rs:26:5
    |
 LL |     forget(reference3);
    |     ^^^^^^^^^^^^^^^^^^
    |
 note: argument has type `&SomeStruct`
-  --> $DIR/forget_ref.rs:25:12
+  --> $DIR/forget_ref.rs:26:12
    |
 LL |     forget(reference3);
    |            ^^^^^^^^^^
 
 error: calls to `std::mem::forget` with a reference instead of an owned value. Forgetting a reference does nothing
-  --> $DIR/forget_ref.rs:30:5
+  --> $DIR/forget_ref.rs:31:5
    |
 LL |     forget(&val);
    |     ^^^^^^^^^^^^
    |
 note: argument has type `&T`
-  --> $DIR/forget_ref.rs:30:12
+  --> $DIR/forget_ref.rs:31:12
    |
 LL |     forget(&val);
    |            ^^^^
 
 error: calls to `std::mem::forget` with a reference instead of an owned value. Forgetting a reference does nothing
-  --> $DIR/forget_ref.rs:38:5
+  --> $DIR/forget_ref.rs:39:5
    |
 LL |     std::mem::forget(&SomeStruct);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: argument has type `&SomeStruct`
-  --> $DIR/forget_ref.rs:38:22
+  --> $DIR/forget_ref.rs:39:22
    |
 LL |     std::mem::forget(&SomeStruct);
    |                      ^^^^^^^^^^^
diff --git a/tests/ui/recursive_format_impl.rs b/tests/ui/recursive_format_impl.rs
index f72fc77ab99..cb6ba36b14c 100644
--- a/tests/ui/recursive_format_impl.rs
+++ b/tests/ui/recursive_format_impl.rs
@@ -2,7 +2,8 @@
 #![allow(
     clippy::inherent_to_string_shadow_display,
     clippy::to_string_in_format_args,
-    clippy::deref_addrof
+    clippy::deref_addrof,
+    clippy::borrow_deref_ref
 )]
 
 use std::fmt;
diff --git a/tests/ui/recursive_format_impl.stderr b/tests/ui/recursive_format_impl.stderr
index 1a717ac92d8..84ce69df566 100644
--- a/tests/ui/recursive_format_impl.stderr
+++ b/tests/ui/recursive_format_impl.stderr
@@ -1,5 +1,5 @@
 error: using `self.to_string` in `fmt::Display` implementation will cause infinite recursion
-  --> $DIR/recursive_format_impl.rs:29:25
+  --> $DIR/recursive_format_impl.rs:30:25
    |
 LL |         write!(f, "{}", self.to_string())
    |                         ^^^^^^^^^^^^^^^^
@@ -7,7 +7,7 @@ LL |         write!(f, "{}", self.to_string())
    = note: `-D clippy::recursive-format-impl` implied by `-D warnings`
 
 error: using `self` as `Display` in `impl Display` will cause infinite recursion
-  --> $DIR/recursive_format_impl.rs:73:9
+  --> $DIR/recursive_format_impl.rs:74:9
    |
 LL |         write!(f, "{}", self)
    |         ^^^^^^^^^^^^^^^^^^^^^
@@ -15,7 +15,7 @@ LL |         write!(f, "{}", self)
    = note: this error originates in the macro `write` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: using `self` as `Display` in `impl Display` will cause infinite recursion
-  --> $DIR/recursive_format_impl.rs:82:9
+  --> $DIR/recursive_format_impl.rs:83:9
    |
 LL |         write!(f, "{}", &self)
    |         ^^^^^^^^^^^^^^^^^^^^^^
@@ -23,7 +23,7 @@ LL |         write!(f, "{}", &self)
    = note: this error originates in the macro `write` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: using `self` as `Debug` in `impl Debug` will cause infinite recursion
-  --> $DIR/recursive_format_impl.rs:88:9
+  --> $DIR/recursive_format_impl.rs:89:9
    |
 LL |         write!(f, "{:?}", &self)
    |         ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -31,7 +31,7 @@ LL |         write!(f, "{:?}", &self)
    = note: this error originates in the macro `write` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: using `self` as `Display` in `impl Display` will cause infinite recursion
-  --> $DIR/recursive_format_impl.rs:97:9
+  --> $DIR/recursive_format_impl.rs:98:9
    |
 LL |         write!(f, "{}", &&&self)
    |         ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -39,7 +39,7 @@ LL |         write!(f, "{}", &&&self)
    = note: this error originates in the macro `write` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: using `self` as `Display` in `impl Display` will cause infinite recursion
-  --> $DIR/recursive_format_impl.rs:171:9
+  --> $DIR/recursive_format_impl.rs:172:9
    |
 LL |         write!(f, "{}", &*self)
    |         ^^^^^^^^^^^^^^^^^^^^^^^
@@ -47,7 +47,7 @@ LL |         write!(f, "{}", &*self)
    = note: this error originates in the macro `write` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: using `self` as `Debug` in `impl Debug` will cause infinite recursion
-  --> $DIR/recursive_format_impl.rs:177:9
+  --> $DIR/recursive_format_impl.rs:178:9
    |
 LL |         write!(f, "{:?}", &*self)
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -55,7 +55,7 @@ LL |         write!(f, "{:?}", &*self)
    = note: this error originates in the macro `write` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: using `self` as `Display` in `impl Display` will cause infinite recursion
-  --> $DIR/recursive_format_impl.rs:193:9
+  --> $DIR/recursive_format_impl.rs:194:9
    |
 LL |         write!(f, "{}", *self)
    |         ^^^^^^^^^^^^^^^^^^^^^^
@@ -63,7 +63,7 @@ LL |         write!(f, "{}", *self)
    = note: this error originates in the macro `write` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: using `self` as `Display` in `impl Display` will cause infinite recursion
-  --> $DIR/recursive_format_impl.rs:209:9
+  --> $DIR/recursive_format_impl.rs:210:9
    |
 LL |         write!(f, "{}", **&&*self)
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -71,7 +71,7 @@ LL |         write!(f, "{}", **&&*self)
    = note: this error originates in the macro `write` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: using `self` as `Display` in `impl Display` will cause infinite recursion
-  --> $DIR/recursive_format_impl.rs:225:9
+  --> $DIR/recursive_format_impl.rs:226:9
    |
 LL |         write!(f, "{}", &&**&&*self)
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From 2aa45693039c2a5c235125e065c68c5e155fbaf1 Mon Sep 17 00:00:00 2001
From: Micha White <botahamec@outlook.com>
Date: Thu, 26 May 2022 12:52:43 -0400
Subject: Triggered the lint on tuple struct and struct patterns

---
 clippy_lints/src/use_self.rs | 18 ++++++++----
 tests/ui/use_self.fixed      | 66 ++++++++++++++++++++++++++++++++++++++++++++
 tests/ui/use_self.rs         | 66 ++++++++++++++++++++++++++++++++++++++++++++
 tests/ui/use_self.stderr     | 62 ++++++++++++++++++++++++++++++++++++++++-
 4 files changed, 206 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/use_self.rs b/clippy_lints/src/use_self.rs
index 66f7748e9e0..486ea5e5ccf 100644
--- a/clippy_lints/src/use_self.rs
+++ b/clippy_lints/src/use_self.rs
@@ -258,13 +258,21 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
             if !pat.span.from_expansion();
             if meets_msrv(self.msrv, msrvs::TYPE_ALIAS_ENUM_VARIANTS);
             if let Some(&StackItem::Check { impl_id, .. }) = self.stack.last();
-            if let PatKind::Path(QPath::Resolved(_, path)) = pat.kind;
-            if !matches!(path.res, Res::SelfTy { .. } | Res::Def(DefKind::TyParam, _));
+            // get the path from the pattern
+            if let PatKind::Path(QPath::Resolved(_, path))
+                 | PatKind::TupleStruct(QPath::Resolved(_, path), _, _)
+                 | PatKind::Struct(QPath::Resolved(_, path), _, _) = pat.kind;
             if cx.typeck_results().pat_ty(pat) == cx.tcx.type_of(impl_id);
-            if let [first, ..] = path.segments;
-            if let Some(hir_id) = first.hir_id;
             then {
-                span_lint(cx, cx.tcx.hir().span(hir_id));
+                match path.res {
+                    Res::Def(DefKind::Ctor(ctor_of, _), ..) => match ctor_of {
+                            CtorOf::Variant => lint_path_to_variant(cx, path),
+                            CtorOf::Struct => span_lint(cx, path.span),
+                    },
+                    Res::Def(DefKind::Variant, ..) => lint_path_to_variant(cx, path),
+                    Res::Def(DefKind::Struct, ..) => span_lint(cx, path.span),
+                    _ => ()
+                }
             }
         }
     }
diff --git a/tests/ui/use_self.fixed b/tests/ui/use_self.fixed
index 3e62ffe74fe..4f80aaecc90 100644
--- a/tests/ui/use_self.fixed
+++ b/tests/ui/use_self.fixed
@@ -542,3 +542,69 @@ mod use_self_in_pat {
         }
     }
 }
+
+mod issue8845 {
+    pub enum Something {
+        Num(u8),
+        TupleNums(u8, u8),
+        StructNums { one: u8, two: u8 },
+    }
+
+    struct Foo(u8);
+
+    struct Bar {
+        x: u8,
+        y: usize,
+    }
+
+    impl Something {
+        fn get_value(&self) -> u8 {
+            match self {
+                Self::Num(n) => *n,
+                Self::TupleNums(n, _m) => *n,
+                Self::StructNums { one, two: _ } => *one,
+            }
+        }
+
+        fn use_crate(&self) -> u8 {
+            match self {
+                Self::Num(n) => *n,
+                Self::TupleNums(n, _m) => *n,
+                Self::StructNums { one, two: _ } => *one,
+            }
+        }
+
+        fn imported_values(&self) -> u8 {
+            use Something::*;
+            match self {
+                Num(n) => *n,
+                TupleNums(n, _m) => *n,
+                StructNums { one, two: _ } => *one,
+            }
+        }
+    }
+
+    impl Foo {
+        fn get_value(&self) -> u8 {
+            let Self(x) = self;
+            *x
+        }
+
+        fn use_crate(&self) -> u8 {
+            let Self(x) = self;
+            *x
+        }
+    }
+
+    impl Bar {
+        fn get_value(&self) -> u8 {
+            let Self { x, .. } = self;
+            *x
+        }
+
+        fn use_crate(&self) -> u8 {
+            let Self { x, .. } = self;
+            *x
+        }
+    }
+}
diff --git a/tests/ui/use_self.rs b/tests/ui/use_self.rs
index da2faddee12..52da72db53c 100644
--- a/tests/ui/use_self.rs
+++ b/tests/ui/use_self.rs
@@ -542,3 +542,69 @@ mod use_self_in_pat {
         }
     }
 }
+
+mod issue8845 {
+    pub enum Something {
+        Num(u8),
+        TupleNums(u8, u8),
+        StructNums { one: u8, two: u8 },
+    }
+
+    struct Foo(u8);
+
+    struct Bar {
+        x: u8,
+        y: usize,
+    }
+
+    impl Something {
+        fn get_value(&self) -> u8 {
+            match self {
+                Something::Num(n) => *n,
+                Something::TupleNums(n, _m) => *n,
+                Something::StructNums { one, two: _ } => *one,
+            }
+        }
+
+        fn use_crate(&self) -> u8 {
+            match self {
+                crate::issue8845::Something::Num(n) => *n,
+                crate::issue8845::Something::TupleNums(n, _m) => *n,
+                crate::issue8845::Something::StructNums { one, two: _ } => *one,
+            }
+        }
+
+        fn imported_values(&self) -> u8 {
+            use Something::*;
+            match self {
+                Num(n) => *n,
+                TupleNums(n, _m) => *n,
+                StructNums { one, two: _ } => *one,
+            }
+        }
+    }
+
+    impl Foo {
+        fn get_value(&self) -> u8 {
+            let Foo(x) = self;
+            *x
+        }
+
+        fn use_crate(&self) -> u8 {
+            let crate::issue8845::Foo(x) = self;
+            *x
+        }
+    }
+
+    impl Bar {
+        fn get_value(&self) -> u8 {
+            let Bar { x, .. } = self;
+            *x
+        }
+
+        fn use_crate(&self) -> u8 {
+            let crate::issue8845::Bar { x, .. } = self;
+            *x
+        }
+    }
+}
diff --git a/tests/ui/use_self.stderr b/tests/ui/use_self.stderr
index 34d98618253..f06bb959b3b 100644
--- a/tests/ui/use_self.stderr
+++ b/tests/ui/use_self.stderr
@@ -186,5 +186,65 @@ error: unnecessary structure name repetition
 LL |             if let Foo::Bar = self {
    |                    ^^^ help: use the applicable keyword: `Self`
 
-error: aborting due to 31 previous errors
+error: unnecessary structure name repetition
+  --> $DIR/use_self.rs:563:17
+   |
+LL |                 Something::Num(n) => *n,
+   |                 ^^^^^^^^^ help: use the applicable keyword: `Self`
+
+error: unnecessary structure name repetition
+  --> $DIR/use_self.rs:564:17
+   |
+LL |                 Something::TupleNums(n, _m) => *n,
+   |                 ^^^^^^^^^ help: use the applicable keyword: `Self`
+
+error: unnecessary structure name repetition
+  --> $DIR/use_self.rs:565:17
+   |
+LL |                 Something::StructNums { one, two: _ } => *one,
+   |                 ^^^^^^^^^ help: use the applicable keyword: `Self`
+
+error: unnecessary structure name repetition
+  --> $DIR/use_self.rs:571:17
+   |
+LL |                 crate::issue8845::Something::Num(n) => *n,
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the applicable keyword: `Self`
+
+error: unnecessary structure name repetition
+  --> $DIR/use_self.rs:572:17
+   |
+LL |                 crate::issue8845::Something::TupleNums(n, _m) => *n,
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the applicable keyword: `Self`
+
+error: unnecessary structure name repetition
+  --> $DIR/use_self.rs:573:17
+   |
+LL |                 crate::issue8845::Something::StructNums { one, two: _ } => *one,
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the applicable keyword: `Self`
+
+error: unnecessary structure name repetition
+  --> $DIR/use_self.rs:589:17
+   |
+LL |             let Foo(x) = self;
+   |                 ^^^ help: use the applicable keyword: `Self`
+
+error: unnecessary structure name repetition
+  --> $DIR/use_self.rs:594:17
+   |
+LL |             let crate::issue8845::Foo(x) = self;
+   |                 ^^^^^^^^^^^^^^^^^^^^^ help: use the applicable keyword: `Self`
+
+error: unnecessary structure name repetition
+  --> $DIR/use_self.rs:601:17
+   |
+LL |             let Bar { x, .. } = self;
+   |                 ^^^ help: use the applicable keyword: `Self`
+
+error: unnecessary structure name repetition
+  --> $DIR/use_self.rs:606:17
+   |
+LL |             let crate::issue8845::Bar { x, .. } = self;
+   |                 ^^^^^^^^^^^^^^^^^^^^^ help: use the applicable keyword: `Self`
+
+error: aborting due to 41 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 0a7f19b547032eea7c923f6c49f5addc14717c00 Mon Sep 17 00:00:00 2001
From: InfRandomness <43730933+InfRandomness@users.noreply.github.com>
Date: Sun, 29 May 2022 20:00:11 +0000
Subject: Fix #8748

---
 clippy_lints/src/shadow.rs | 10 +++++++---
 tests/ui/shadow.rs         |  7 +++++++
 2 files changed, 14 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/shadow.rs b/clippy_lints/src/shadow.rs
index 1ab7f52110c..4f74c1e44c2 100644
--- a/clippy_lints/src/shadow.rs
+++ b/clippy_lints/src/shadow.rs
@@ -160,9 +160,13 @@ impl<'tcx> LateLintPass<'tcx> for Shadow {
 
 fn is_shadow(cx: &LateContext<'_>, owner: LocalDefId, first: ItemLocalId, second: ItemLocalId) -> bool {
     let scope_tree = cx.tcx.region_scope_tree(owner.to_def_id());
-    let first_scope = scope_tree.var_scope(first).unwrap();
-    let second_scope = scope_tree.var_scope(second).unwrap();
-    scope_tree.is_subscope_of(second_scope, first_scope)
+    if let Some(first_scope) = scope_tree.var_scope(first) {
+        if let Some(second_scope) = scope_tree.var_scope(second) {
+            return scope_tree.is_subscope_of(second_scope, first_scope);
+        }
+    }
+
+    false
 }
 
 fn lint_shadow(cx: &LateContext<'_>, pat: &Pat<'_>, shadowed: HirId, span: Span) {
diff --git a/tests/ui/shadow.rs b/tests/ui/shadow.rs
index a394ef8f25c..1fa9fc749a9 100644
--- a/tests/ui/shadow.rs
+++ b/tests/ui/shadow.rs
@@ -88,4 +88,11 @@ pub async fn foo2(_a: i32, _b: i64) {
     let _b = _a;
 }
 
+fn ice_8748() {
+    let _ = [0; {
+        let x = 1;
+        if let Some(x) = Some(1) { x } else { 1 }
+    }];
+}
+
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From eb2908b4ea8fd63623f994780d2928f32af84d71 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Mon, 30 May 2022 22:07:49 -0400
Subject: Add lint `almost_complete_letter_range`

---
 CHANGELOG.md                                     |   1 +
 clippy_lints/src/almost_complete_letter_range.rs | 100 +++++++++++++++++++++++
 clippy_lints/src/lib.register_all.rs             |   1 +
 clippy_lints/src/lib.register_lints.rs           |   1 +
 clippy_lints/src/lib.register_suspicious.rs      |   1 +
 clippy_lints/src/lib.rs                          |   2 +
 clippy_utils/src/msrvs.rs                        |   1 +
 clippy_utils/src/source.rs                       |  23 +++++-
 tests/ui/almost_complete_letter_range.fixed      |  66 +++++++++++++++
 tests/ui/almost_complete_letter_range.rs         |  66 +++++++++++++++
 tests/ui/almost_complete_letter_range.stderr     | 100 +++++++++++++++++++++++
 11 files changed, 361 insertions(+), 1 deletion(-)
 create mode 100644 clippy_lints/src/almost_complete_letter_range.rs
 create mode 100644 tests/ui/almost_complete_letter_range.fixed
 create mode 100644 tests/ui/almost_complete_letter_range.rs
 create mode 100644 tests/ui/almost_complete_letter_range.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 3aaa79a1719..67ca4cf708a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3276,6 +3276,7 @@ Released 2018-09-13
 <!-- begin autogenerated links to lint list -->
 [`absurd_extreme_comparisons`]: https://rust-lang.github.io/rust-clippy/master/index.html#absurd_extreme_comparisons
 [`allow_attributes_without_reason`]: https://rust-lang.github.io/rust-clippy/master/index.html#allow_attributes_without_reason
+[`almost_complete_letter_range`]: https://rust-lang.github.io/rust-clippy/master/index.html#almost_complete_letter_range
 [`almost_swapped`]: https://rust-lang.github.io/rust-clippy/master/index.html#almost_swapped
 [`approx_constant`]: https://rust-lang.github.io/rust-clippy/master/index.html#approx_constant
 [`as_conversions`]: https://rust-lang.github.io/rust-clippy/master/index.html#as_conversions
diff --git a/clippy_lints/src/almost_complete_letter_range.rs b/clippy_lints/src/almost_complete_letter_range.rs
new file mode 100644
index 00000000000..b364a370efa
--- /dev/null
+++ b/clippy_lints/src/almost_complete_letter_range.rs
@@ -0,0 +1,100 @@
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::source::{trim_span, walk_span_to_context};
+use clippy_utils::{meets_msrv, msrvs};
+use rustc_ast::ast::{Expr, ExprKind, LitKind, Pat, PatKind, RangeEnd, RangeLimits};
+use rustc_errors::Applicability;
+use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
+use rustc_semver::RustcVersion;
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::Span;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for ranges which almost include the entire range of letters from 'a' to 'z', but
+    /// don't because they're a half open range.
+    ///
+    /// ### Why is this bad?
+    /// This (`'a'..'z'`) is almost certainly a typo meant to include all letters.
+    ///
+    /// ### Example
+    /// ```rust
+    /// let _ = 'a'..'z';
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// let _ = 'a'..='z';
+    /// ```
+    #[clippy::version = "1.63.0"]
+    pub ALMOST_COMPLETE_LETTER_RANGE,
+    suspicious,
+    "almost complete letter range"
+}
+impl_lint_pass!(AlmostCompleteLetterRange => [ALMOST_COMPLETE_LETTER_RANGE]);
+
+pub struct AlmostCompleteLetterRange {
+    msrv: Option<RustcVersion>,
+}
+impl AlmostCompleteLetterRange {
+    pub fn new(msrv: Option<RustcVersion>) -> Self {
+        Self { msrv }
+    }
+}
+impl EarlyLintPass for AlmostCompleteLetterRange {
+    fn check_expr(&mut self, cx: &EarlyContext<'_>, e: &Expr) {
+        if let ExprKind::Range(Some(start), Some(end), RangeLimits::HalfOpen) = &e.kind {
+            let ctxt = e.span.ctxt();
+            let sugg = if let Some(start) = walk_span_to_context(start.span, ctxt)
+                && let Some(end) = walk_span_to_context(end.span, ctxt)
+                && meets_msrv(self.msrv, msrvs::RANGE_INCLUSIVE)
+            {
+                Some((trim_span(cx.sess().source_map(), start.between(end)), "..="))
+            } else {
+                None
+            };
+            check_range(cx, e.span, start, end, sugg);
+        }
+    }
+
+    fn check_pat(&mut self, cx: &EarlyContext<'_>, p: &Pat) {
+        if let PatKind::Range(Some(start), Some(end), kind) = &p.kind
+            && matches!(kind.node, RangeEnd::Excluded)
+        {
+            let sugg = if meets_msrv(self.msrv, msrvs::RANGE_INCLUSIVE) {
+                "..="
+            } else {
+                "..."
+            };
+            check_range(cx, p.span, start, end, Some((kind.span, sugg)));
+        }
+    }
+
+    extract_msrv_attr!(EarlyContext);
+}
+
+fn check_range(cx: &EarlyContext<'_>, span: Span, start: &Expr, end: &Expr, sugg: Option<(Span, &str)>) {
+    if let ExprKind::Lit(start_lit) = &start.peel_parens().kind
+        && let ExprKind::Lit(end_lit) = &end.peel_parens().kind
+        && matches!(
+            (&start_lit.kind, &end_lit.kind),
+            (LitKind::Byte(b'a') | LitKind::Char('a'), LitKind::Byte(b'z') | LitKind::Char('z'))
+            | (LitKind::Byte(b'A') | LitKind::Char('A'), LitKind::Byte(b'Z') | LitKind::Char('Z'))
+        )
+    {
+        span_lint_and_then(
+            cx,
+            ALMOST_COMPLETE_LETTER_RANGE,
+            span,
+            "almost complete ascii letter range",
+            |diag| {
+                if let Some((span, sugg)) = sugg {
+                    diag.span_suggestion(
+                        span,
+                        "use an inclusive range",
+                        sugg.to_owned(),
+                        Applicability::MaybeIncorrect,
+                    );
+                }
+            }
+        );
+    }
+}
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index a028b41db77..d4f8d676c22 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -4,6 +4,7 @@
 
 store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(absurd_extreme_comparisons::ABSURD_EXTREME_COMPARISONS),
+    LintId::of(almost_complete_letter_range::ALMOST_COMPLETE_LETTER_RANGE),
     LintId::of(approx_const::APPROX_CONSTANT),
     LintId::of(assertions_on_constants::ASSERTIONS_ON_CONSTANTS),
     LintId::of(assign_ops::ASSIGN_OP_PATTERN),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 1f2132cf620..b76eaae377e 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -34,6 +34,7 @@ store.register_lints(&[
     #[cfg(feature = "internal")]
     utils::internal_lints::UNNECESSARY_SYMBOL_STR,
     absurd_extreme_comparisons::ABSURD_EXTREME_COMPARISONS,
+    almost_complete_letter_range::ALMOST_COMPLETE_LETTER_RANGE,
     approx_const::APPROX_CONSTANT,
     arithmetic::FLOAT_ARITHMETIC,
     arithmetic::INTEGER_ARITHMETIC,
diff --git a/clippy_lints/src/lib.register_suspicious.rs b/clippy_lints/src/lib.register_suspicious.rs
index 20bf5a245b1..3d6d2d8951c 100644
--- a/clippy_lints/src/lib.register_suspicious.rs
+++ b/clippy_lints/src/lib.register_suspicious.rs
@@ -3,6 +3,7 @@
 // Manual edits will be overwritten.
 
 store.register_group(true, "clippy::suspicious", Some("clippy_suspicious"), vec![
+    LintId::of(almost_complete_letter_range::ALMOST_COMPLETE_LETTER_RANGE),
     LintId::of(assign_ops::MISREFACTORED_ASSIGN_OP),
     LintId::of(attrs::BLANKET_CLIPPY_RESTRICTION_LINTS),
     LintId::of(await_holding_invalid::AWAIT_HOLDING_INVALID_TYPE),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index d611600cf71..67ae2053f5a 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -168,6 +168,7 @@ mod renamed_lints;
 
 // begin lints modules, do not remove this comment, it’s used in `update_lints`
 mod absurd_extreme_comparisons;
+mod almost_complete_letter_range;
 mod approx_const;
 mod arithmetic;
 mod as_conversions;
@@ -911,6 +912,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_early_pass(|| Box::new(duplicate_mod::DuplicateMod::default()));
     store.register_late_pass(|| Box::new(get_first::GetFirst));
     store.register_early_pass(|| Box::new(unused_rounding::UnusedRounding));
+    store.register_early_pass(move || Box::new(almost_complete_letter_range::AlmostCompleteLetterRange::new(msrv)));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_utils/src/msrvs.rs b/clippy_utils/src/msrvs.rs
index 134fd1ce505..b9ec2c19fdd 100644
--- a/clippy_utils/src/msrvs.rs
+++ b/clippy_utils/src/msrvs.rs
@@ -30,6 +30,7 @@ msrv_aliases! {
     1,34,0 { TRY_FROM }
     1,30,0 { ITERATOR_FIND_MAP, TOOL_ATTRIBUTES }
     1,28,0 { FROM_BOOL }
+    1,26,0 { RANGE_INCLUSIVE }
     1,17,0 { FIELD_INIT_SHORTHAND, STATIC_IN_CONST, EXPECT_ERR }
     1,16,0 { STR_REPEAT }
     1,24,0 { IS_ASCII_DIGIT }
diff --git a/clippy_utils/src/source.rs b/clippy_utils/src/source.rs
index 04ef2f57447..f88a92fb11c 100644
--- a/clippy_utils/src/source.rs
+++ b/clippy_utils/src/source.rs
@@ -8,7 +8,7 @@ use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LintContext};
 use rustc_span::hygiene;
 use rustc_span::source_map::SourceMap;
-use rustc_span::{BytePos, Pos, Span, SyntaxContext};
+use rustc_span::{BytePos, Pos, Span, SpanData, SyntaxContext};
 use std::borrow::Cow;
 
 /// Checks if the span starts with the given text. This will return false if the span crosses
@@ -389,6 +389,27 @@ pub fn without_block_comments(lines: Vec<&str>) -> Vec<&str> {
     without
 }
 
+/// Trims the whitespace from the start and the end of the span.
+pub fn trim_span(sm: &SourceMap, span: Span) -> Span {
+    let data = span.data();
+    let sf: &_ = &sm.lookup_source_file(data.lo);
+    let Some(src) = sf.src.as_deref() else {
+        return span;
+    };
+    let Some(snip) = &src.get((data.lo - sf.start_pos).to_usize()..(data.hi - sf.start_pos).to_usize()) else {
+        return span;
+    };
+    let trim_start = snip.len() - snip.trim_start().len();
+    let trim_end = snip.len() - snip.trim_end().len();
+    SpanData {
+        lo: data.lo + BytePos::from_usize(trim_start),
+        hi: data.hi - BytePos::from_usize(trim_end),
+        ctxt: data.ctxt,
+        parent: data.parent,
+    }
+    .span()
+}
+
 #[cfg(test)]
 mod test {
     use super::{reindent_multiline, without_block_comments};
diff --git a/tests/ui/almost_complete_letter_range.fixed b/tests/ui/almost_complete_letter_range.fixed
new file mode 100644
index 00000000000..39f8f0c2949
--- /dev/null
+++ b/tests/ui/almost_complete_letter_range.fixed
@@ -0,0 +1,66 @@
+// run-rustfix
+// edition:2018
+
+#![feature(custom_inner_attributes)]
+#![feature(exclusive_range_pattern)]
+#![feature(stmt_expr_attributes)]
+#![warn(clippy::almost_complete_letter_range)]
+#![allow(ellipsis_inclusive_range_patterns)]
+
+macro_rules! a {
+    () => {
+        'a'
+    };
+}
+
+fn main() {
+    #[rustfmt::skip]
+    {
+        let _ = ('a') ..='z';
+        let _ = 'A' ..= ('Z');
+    }
+
+    let _ = 'b'..'z';
+    let _ = 'B'..'Z';
+
+    let _ = (b'a')..=(b'z');
+    let _ = b'A'..=b'Z';
+
+    let _ = b'b'..b'z';
+    let _ = b'B'..b'Z';
+
+    let _ = a!()..='z';
+
+    let _ = match 0u8 {
+        b'a'..=b'z' if true => 1,
+        b'A'..=b'Z' if true => 2,
+        b'b'..b'z' => 3,
+        b'B'..b'Z' => 4,
+        _ => 5,
+    };
+
+    let _ = match 'x' {
+        'a'..='z' if true => 1,
+        'A'..='Z' if true => 2,
+        'b'..'z' => 3,
+        'B'..'Z' => 4,
+        _ => 5,
+    };
+}
+
+fn _under_msrv() {
+    #![clippy::msrv = "1.25"]
+    let _ = match 'a' {
+        'a'...'z' => 1,
+        _ => 2,
+    };
+}
+
+fn _meets_msrv() {
+    #![clippy::msrv = "1.26"]
+    let _ = 'a'..='z';
+    let _ = match 'a' {
+        'a'..='z' => 1,
+        _ => 2,
+    };
+}
diff --git a/tests/ui/almost_complete_letter_range.rs b/tests/ui/almost_complete_letter_range.rs
new file mode 100644
index 00000000000..3dc02199257
--- /dev/null
+++ b/tests/ui/almost_complete_letter_range.rs
@@ -0,0 +1,66 @@
+// run-rustfix
+// edition:2018
+
+#![feature(custom_inner_attributes)]
+#![feature(exclusive_range_pattern)]
+#![feature(stmt_expr_attributes)]
+#![warn(clippy::almost_complete_letter_range)]
+#![allow(ellipsis_inclusive_range_patterns)]
+
+macro_rules! a {
+    () => {
+        'a'
+    };
+}
+
+fn main() {
+    #[rustfmt::skip]
+    {
+        let _ = ('a') ..'z';
+        let _ = 'A' .. ('Z');
+    }
+
+    let _ = 'b'..'z';
+    let _ = 'B'..'Z';
+
+    let _ = (b'a')..(b'z');
+    let _ = b'A'..b'Z';
+
+    let _ = b'b'..b'z';
+    let _ = b'B'..b'Z';
+
+    let _ = a!()..'z';
+
+    let _ = match 0u8 {
+        b'a'..b'z' if true => 1,
+        b'A'..b'Z' if true => 2,
+        b'b'..b'z' => 3,
+        b'B'..b'Z' => 4,
+        _ => 5,
+    };
+
+    let _ = match 'x' {
+        'a'..'z' if true => 1,
+        'A'..'Z' if true => 2,
+        'b'..'z' => 3,
+        'B'..'Z' => 4,
+        _ => 5,
+    };
+}
+
+fn _under_msrv() {
+    #![clippy::msrv = "1.25"]
+    let _ = match 'a' {
+        'a'..'z' => 1,
+        _ => 2,
+    };
+}
+
+fn _meets_msrv() {
+    #![clippy::msrv = "1.26"]
+    let _ = 'a'..'z';
+    let _ = match 'a' {
+        'a'..'z' => 1,
+        _ => 2,
+    };
+}
diff --git a/tests/ui/almost_complete_letter_range.stderr b/tests/ui/almost_complete_letter_range.stderr
new file mode 100644
index 00000000000..74980ec1a92
--- /dev/null
+++ b/tests/ui/almost_complete_letter_range.stderr
@@ -0,0 +1,100 @@
+error: almost complete ascii letter range
+  --> $DIR/almost_complete_letter_range.rs:19:17
+   |
+LL |         let _ = ('a') ..'z';
+   |                 ^^^^^^--^^^
+   |                       |
+   |                       help: use an inclusive range: `..=`
+   |
+   = note: `-D clippy::almost-complete-letter-range` implied by `-D warnings`
+
+error: almost complete ascii letter range
+  --> $DIR/almost_complete_letter_range.rs:20:17
+   |
+LL |         let _ = 'A' .. ('Z');
+   |                 ^^^^--^^^^^^
+   |                     |
+   |                     help: use an inclusive range: `..=`
+
+error: almost complete ascii letter range
+  --> $DIR/almost_complete_letter_range.rs:26:13
+   |
+LL |     let _ = (b'a')..(b'z');
+   |             ^^^^^^--^^^^^^
+   |                   |
+   |                   help: use an inclusive range: `..=`
+
+error: almost complete ascii letter range
+  --> $DIR/almost_complete_letter_range.rs:27:13
+   |
+LL |     let _ = b'A'..b'Z';
+   |             ^^^^--^^^^
+   |                 |
+   |                 help: use an inclusive range: `..=`
+
+error: almost complete ascii letter range
+  --> $DIR/almost_complete_letter_range.rs:32:13
+   |
+LL |     let _ = a!()..'z';
+   |             ^^^^--^^^
+   |                 |
+   |                 help: use an inclusive range: `..=`
+
+error: almost complete ascii letter range
+  --> $DIR/almost_complete_letter_range.rs:35:9
+   |
+LL |         b'a'..b'z' if true => 1,
+   |         ^^^^--^^^^
+   |             |
+   |             help: use an inclusive range: `..=`
+
+error: almost complete ascii letter range
+  --> $DIR/almost_complete_letter_range.rs:36:9
+   |
+LL |         b'A'..b'Z' if true => 2,
+   |         ^^^^--^^^^
+   |             |
+   |             help: use an inclusive range: `..=`
+
+error: almost complete ascii letter range
+  --> $DIR/almost_complete_letter_range.rs:43:9
+   |
+LL |         'a'..'z' if true => 1,
+   |         ^^^--^^^
+   |            |
+   |            help: use an inclusive range: `..=`
+
+error: almost complete ascii letter range
+  --> $DIR/almost_complete_letter_range.rs:44:9
+   |
+LL |         'A'..'Z' if true => 2,
+   |         ^^^--^^^
+   |            |
+   |            help: use an inclusive range: `..=`
+
+error: almost complete ascii letter range
+  --> $DIR/almost_complete_letter_range.rs:54:9
+   |
+LL |         'a'..'z' => 1,
+   |         ^^^--^^^
+   |            |
+   |            help: use an inclusive range: `...`
+
+error: almost complete ascii letter range
+  --> $DIR/almost_complete_letter_range.rs:61:13
+   |
+LL |     let _ = 'a'..'z';
+   |             ^^^--^^^
+   |                |
+   |                help: use an inclusive range: `..=`
+
+error: almost complete ascii letter range
+  --> $DIR/almost_complete_letter_range.rs:63:9
+   |
+LL |         'a'..'z' => 1,
+   |         ^^^--^^^
+   |            |
+   |            help: use an inclusive range: `..=`
+
+error: aborting due to 12 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 9c9cca3e6672784f6b71b2113d27e2f7f707f650 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Fri, 18 Mar 2022 00:58:03 -0400
Subject: Don't lint `useless_transmute` on types with erased regions

---
 clippy_lints/src/transmute/useless_transmute.rs | 47 ++++++-------
 tests/ui/transmute.rs                           | 19 +++++-
 tests/ui/transmute.stderr                       | 88 ++++++++++++-------------
 3 files changed, 84 insertions(+), 70 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/transmute/useless_transmute.rs b/clippy_lints/src/transmute/useless_transmute.rs
index 3cc3d40a143..a0d104e2390 100644
--- a/clippy_lints/src/transmute/useless_transmute.rs
+++ b/clippy_lints/src/transmute/useless_transmute.rs
@@ -4,7 +4,7 @@ use clippy_utils::sugg;
 use rustc_errors::Applicability;
 use rustc_hir::Expr;
 use rustc_lint::LateContext;
-use rustc_middle::ty::{self, Ty};
+use rustc_middle::ty::{self, Ty, TypeFoldable};
 
 /// Checks for `useless_transmute` lint.
 /// Returns `true` if it's triggered, otherwise returns `false`.
@@ -16,7 +16,7 @@ pub(super) fn check<'tcx>(
     arg: &'tcx Expr<'_>,
 ) -> bool {
     match (&from_ty.kind(), &to_ty.kind()) {
-        _ if from_ty == to_ty => {
+        _ if from_ty == to_ty && !from_ty.has_erased_regions() => {
             span_lint(
                 cx,
                 USELESS_TRANSMUTE,
@@ -26,28 +26,31 @@ pub(super) fn check<'tcx>(
             true
         },
         (ty::Ref(_, rty, rty_mutbl), ty::RawPtr(ptr_ty)) => {
-            span_lint_and_then(
-                cx,
-                USELESS_TRANSMUTE,
-                e.span,
-                "transmute from a reference to a pointer",
-                |diag| {
-                    if let Some(arg) = sugg::Sugg::hir_opt(cx, arg) {
-                        let rty_and_mut = ty::TypeAndMut {
-                            ty: *rty,
-                            mutbl: *rty_mutbl,
-                        };
+            // No way to give the correct suggestion here. Avoid linting for now.
+            if !rty.has_erased_regions() {
+                span_lint_and_then(
+                    cx,
+                    USELESS_TRANSMUTE,
+                    e.span,
+                    "transmute from a reference to a pointer",
+                    |diag| {
+                        if let Some(arg) = sugg::Sugg::hir_opt(cx, arg) {
+                            let rty_and_mut = ty::TypeAndMut {
+                                ty: *rty,
+                                mutbl: *rty_mutbl,
+                            };
 
-                        let sugg = if *ptr_ty == rty_and_mut {
-                            arg.as_ty(to_ty)
-                        } else {
-                            arg.as_ty(cx.tcx.mk_ptr(rty_and_mut)).as_ty(to_ty)
-                        };
+                            let sugg = if *ptr_ty == rty_and_mut {
+                                arg.as_ty(to_ty)
+                            } else {
+                                arg.as_ty(cx.tcx.mk_ptr(rty_and_mut)).as_ty(to_ty)
+                            };
 
-                        diag.span_suggestion(e.span, "try", sugg.to_string(), Applicability::Unspecified);
-                    }
-                },
-            );
+                            diag.span_suggestion(e.span, "try", sugg.to_string(), Applicability::Unspecified);
+                        }
+                    },
+                );
+            }
             true
         },
         (ty::Int(_) | ty::Uint(_), ty::RawPtr(_)) => {
diff --git a/tests/ui/transmute.rs b/tests/ui/transmute.rs
index 5b688ce4d64..001c910239a 100644
--- a/tests/ui/transmute.rs
+++ b/tests/ui/transmute.rs
@@ -16,7 +16,8 @@ fn my_vec() -> MyVec<i32> {
 #[allow(clippy::needless_lifetimes, clippy::transmute_ptr_to_ptr)]
 #[warn(clippy::useless_transmute)]
 unsafe fn _generic<'a, T, U: 'a>(t: &'a T) {
-    let _: &'a T = core::intrinsics::transmute(t);
+    // FIXME: should lint
+    // let _: &'a T = core::intrinsics::transmute(t);
 
     let _: &'a U = core::intrinsics::transmute(t);
 
@@ -48,6 +49,22 @@ fn useless() {
 
         let _ = (1 + 1_usize) as *const usize;
     }
+
+    unsafe fn _f<'a, 'b>(x: &'a u32) -> &'b u32 {
+        std::mem::transmute(x)
+    }
+
+    unsafe fn _f2<'a, 'b>(x: *const (dyn Iterator<Item = u32> + 'a)) -> *const (dyn Iterator<Item = u32> + 'b) {
+        std::mem::transmute(x)
+    }
+
+    unsafe fn _f3<'a, 'b>(x: fn(&'a u32)) -> fn(&'b u32) {
+        std::mem::transmute(x)
+    }
+
+    unsafe fn _f4<'a, 'b>(x: std::borrow::Cow<'a, str>) -> std::borrow::Cow<'b, str> {
+        std::mem::transmute(x)
+    }
 }
 
 struct Usize(usize);
diff --git a/tests/ui/transmute.stderr b/tests/ui/transmute.stderr
index 72a386e8fa6..008b4a981d7 100644
--- a/tests/ui/transmute.stderr
+++ b/tests/ui/transmute.stderr
@@ -1,73 +1,67 @@
-error: transmute from a type (`&T`) to itself
-  --> $DIR/transmute.rs:19:20
-   |
-LL |     let _: &'a T = core::intrinsics::transmute(t);
-   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: `-D clippy::useless-transmute` implied by `-D warnings`
-
 error: transmute from a reference to a pointer
-  --> $DIR/transmute.rs:23:23
+  --> $DIR/transmute.rs:24:23
    |
 LL |     let _: *const T = core::intrinsics::transmute(t);
    |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `t as *const T`
+   |
+   = note: `-D clippy::useless-transmute` implied by `-D warnings`
 
 error: transmute from a reference to a pointer
-  --> $DIR/transmute.rs:25:21
+  --> $DIR/transmute.rs:26:21
    |
 LL |     let _: *mut T = core::intrinsics::transmute(t);
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `t as *const T as *mut T`
 
 error: transmute from a reference to a pointer
-  --> $DIR/transmute.rs:27:23
+  --> $DIR/transmute.rs:28:23
    |
 LL |     let _: *const U = core::intrinsics::transmute(t);
    |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `t as *const T as *const U`
 
 error: transmute from a type (`std::vec::Vec<i32>`) to itself
-  --> $DIR/transmute.rs:33:27
+  --> $DIR/transmute.rs:34:27
    |
 LL |         let _: Vec<i32> = core::intrinsics::transmute(my_vec());
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: transmute from a type (`std::vec::Vec<i32>`) to itself
-  --> $DIR/transmute.rs:35:27
+  --> $DIR/transmute.rs:36:27
    |
 LL |         let _: Vec<i32> = core::mem::transmute(my_vec());
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: transmute from a type (`std::vec::Vec<i32>`) to itself
-  --> $DIR/transmute.rs:37:27
+  --> $DIR/transmute.rs:38:27
    |
 LL |         let _: Vec<i32> = std::intrinsics::transmute(my_vec());
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: transmute from a type (`std::vec::Vec<i32>`) to itself
-  --> $DIR/transmute.rs:39:27
+  --> $DIR/transmute.rs:40:27
    |
 LL |         let _: Vec<i32> = std::mem::transmute(my_vec());
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: transmute from a type (`std::vec::Vec<i32>`) to itself
-  --> $DIR/transmute.rs:41:27
+  --> $DIR/transmute.rs:42:27
    |
 LL |         let _: Vec<i32> = my_transmute(my_vec());
    |                           ^^^^^^^^^^^^^^^^^^^^^^
 
 error: transmute from an integer to a pointer
-  --> $DIR/transmute.rs:43:31
+  --> $DIR/transmute.rs:44:31
    |
 LL |         let _: *const usize = std::mem::transmute(5_isize);
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `5_isize as *const usize`
 
 error: transmute from an integer to a pointer
-  --> $DIR/transmute.rs:47:31
+  --> $DIR/transmute.rs:48:31
    |
 LL |         let _: *const usize = std::mem::transmute(1 + 1usize);
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `(1 + 1usize) as *const usize`
 
 error: transmute from a type (`*const Usize`) to the type that it points to (`Usize`)
-  --> $DIR/transmute.rs:62:24
+  --> $DIR/transmute.rs:79:24
    |
 LL |         let _: Usize = core::intrinsics::transmute(int_const_ptr);
    |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -75,25 +69,25 @@ LL |         let _: Usize = core::intrinsics::transmute(int_const_ptr);
    = note: `-D clippy::crosspointer-transmute` implied by `-D warnings`
 
 error: transmute from a type (`*mut Usize`) to the type that it points to (`Usize`)
-  --> $DIR/transmute.rs:64:24
+  --> $DIR/transmute.rs:81:24
    |
 LL |         let _: Usize = core::intrinsics::transmute(int_mut_ptr);
    |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: transmute from a type (`Usize`) to a pointer to that type (`*const Usize`)
-  --> $DIR/transmute.rs:66:31
+  --> $DIR/transmute.rs:83:31
    |
 LL |         let _: *const Usize = core::intrinsics::transmute(my_int());
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: transmute from a type (`Usize`) to a pointer to that type (`*mut Usize`)
-  --> $DIR/transmute.rs:68:29
+  --> $DIR/transmute.rs:85:29
    |
 LL |         let _: *mut Usize = core::intrinsics::transmute(my_int());
    |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: transmute from a `u32` to a `char`
-  --> $DIR/transmute.rs:74:28
+  --> $DIR/transmute.rs:91:28
    |
 LL |     let _: char = unsafe { std::mem::transmute(0_u32) };
    |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::char::from_u32(0_u32).unwrap()`
@@ -101,13 +95,13 @@ LL |     let _: char = unsafe { std::mem::transmute(0_u32) };
    = note: `-D clippy::transmute-int-to-char` implied by `-D warnings`
 
 error: transmute from a `i32` to a `char`
-  --> $DIR/transmute.rs:75:28
+  --> $DIR/transmute.rs:92:28
    |
 LL |     let _: char = unsafe { std::mem::transmute(0_i32) };
    |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::char::from_u32(0_i32 as u32).unwrap()`
 
 error: transmute from a `u8` to a `bool`
-  --> $DIR/transmute.rs:84:28
+  --> $DIR/transmute.rs:101:28
    |
 LL |     let _: bool = unsafe { std::mem::transmute(0_u8) };
    |                            ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `0_u8 != 0`
@@ -115,7 +109,7 @@ LL |     let _: bool = unsafe { std::mem::transmute(0_u8) };
    = note: `-D clippy::transmute-int-to-bool` implied by `-D warnings`
 
 error: transmute from a `u32` to a `f32`
-  --> $DIR/transmute.rs:90:31
+  --> $DIR/transmute.rs:107:31
    |
 LL |         let _: f32 = unsafe { std::mem::transmute(0_u32) };
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `f32::from_bits(0_u32)`
@@ -123,25 +117,25 @@ LL |         let _: f32 = unsafe { std::mem::transmute(0_u32) };
    = note: `-D clippy::transmute-int-to-float` implied by `-D warnings`
 
 error: transmute from a `i32` to a `f32`
-  --> $DIR/transmute.rs:91:31
+  --> $DIR/transmute.rs:108:31
    |
 LL |         let _: f32 = unsafe { std::mem::transmute(0_i32) };
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `f32::from_bits(0_i32 as u32)`
 
 error: transmute from a `u64` to a `f64`
-  --> $DIR/transmute.rs:92:31
+  --> $DIR/transmute.rs:109:31
    |
 LL |         let _: f64 = unsafe { std::mem::transmute(0_u64) };
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `f64::from_bits(0_u64)`
 
 error: transmute from a `i64` to a `f64`
-  --> $DIR/transmute.rs:93:31
+  --> $DIR/transmute.rs:110:31
    |
 LL |         let _: f64 = unsafe { std::mem::transmute(0_i64) };
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `f64::from_bits(0_i64 as u64)`
 
 error: transmute from a `u8` to a `[u8; 1]`
-  --> $DIR/transmute.rs:113:30
+  --> $DIR/transmute.rs:130:30
    |
 LL |             let _: [u8; 1] = std::mem::transmute(0u8);
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0u8.to_ne_bytes()`
@@ -149,85 +143,85 @@ LL |             let _: [u8; 1] = std::mem::transmute(0u8);
    = note: `-D clippy::transmute-num-to-bytes` implied by `-D warnings`
 
 error: transmute from a `u32` to a `[u8; 4]`
-  --> $DIR/transmute.rs:114:30
+  --> $DIR/transmute.rs:131:30
    |
 LL |             let _: [u8; 4] = std::mem::transmute(0u32);
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0u32.to_ne_bytes()`
 
 error: transmute from a `u128` to a `[u8; 16]`
-  --> $DIR/transmute.rs:115:31
+  --> $DIR/transmute.rs:132:31
    |
 LL |             let _: [u8; 16] = std::mem::transmute(0u128);
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0u128.to_ne_bytes()`
 
 error: transmute from a `i8` to a `[u8; 1]`
-  --> $DIR/transmute.rs:116:30
+  --> $DIR/transmute.rs:133:30
    |
 LL |             let _: [u8; 1] = std::mem::transmute(0i8);
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0i8.to_ne_bytes()`
 
 error: transmute from a `i32` to a `[u8; 4]`
-  --> $DIR/transmute.rs:117:30
+  --> $DIR/transmute.rs:134:30
    |
 LL |             let _: [u8; 4] = std::mem::transmute(0i32);
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0i32.to_ne_bytes()`
 
 error: transmute from a `i128` to a `[u8; 16]`
-  --> $DIR/transmute.rs:118:31
+  --> $DIR/transmute.rs:135:31
    |
 LL |             let _: [u8; 16] = std::mem::transmute(0i128);
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0i128.to_ne_bytes()`
 
 error: transmute from a `f32` to a `[u8; 4]`
-  --> $DIR/transmute.rs:119:30
+  --> $DIR/transmute.rs:136:30
    |
 LL |             let _: [u8; 4] = std::mem::transmute(0.0f32);
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0.0f32.to_ne_bytes()`
 
 error: transmute from a `f64` to a `[u8; 8]`
-  --> $DIR/transmute.rs:120:30
+  --> $DIR/transmute.rs:137:30
    |
 LL |             let _: [u8; 8] = std::mem::transmute(0.0f64);
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0.0f64.to_ne_bytes()`
 
 error: transmute from a `u8` to a `[u8; 1]`
-  --> $DIR/transmute.rs:125:30
+  --> $DIR/transmute.rs:142:30
    |
 LL |             let _: [u8; 1] = std::mem::transmute(0u8);
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0u8.to_ne_bytes()`
 
 error: transmute from a `u32` to a `[u8; 4]`
-  --> $DIR/transmute.rs:126:30
+  --> $DIR/transmute.rs:143:30
    |
 LL |             let _: [u8; 4] = std::mem::transmute(0u32);
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0u32.to_ne_bytes()`
 
 error: transmute from a `u128` to a `[u8; 16]`
-  --> $DIR/transmute.rs:127:31
+  --> $DIR/transmute.rs:144:31
    |
 LL |             let _: [u8; 16] = std::mem::transmute(0u128);
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0u128.to_ne_bytes()`
 
 error: transmute from a `i8` to a `[u8; 1]`
-  --> $DIR/transmute.rs:128:30
+  --> $DIR/transmute.rs:145:30
    |
 LL |             let _: [u8; 1] = std::mem::transmute(0i8);
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0i8.to_ne_bytes()`
 
 error: transmute from a `i32` to a `[u8; 4]`
-  --> $DIR/transmute.rs:129:30
+  --> $DIR/transmute.rs:146:30
    |
 LL |             let _: [u8; 4] = std::mem::transmute(0i32);
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0i32.to_ne_bytes()`
 
 error: transmute from a `i128` to a `[u8; 16]`
-  --> $DIR/transmute.rs:130:31
+  --> $DIR/transmute.rs:147:31
    |
 LL |             let _: [u8; 16] = std::mem::transmute(0i128);
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0i128.to_ne_bytes()`
 
 error: transmute from a `&[u8]` to a `&str`
-  --> $DIR/transmute.rs:140:28
+  --> $DIR/transmute.rs:157:28
    |
 LL |     let _: &str = unsafe { std::mem::transmute(B) };
    |                            ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::str::from_utf8(B).unwrap()`
@@ -235,16 +229,16 @@ LL |     let _: &str = unsafe { std::mem::transmute(B) };
    = note: `-D clippy::transmute-bytes-to-str` implied by `-D warnings`
 
 error: transmute from a `&mut [u8]` to a `&mut str`
-  --> $DIR/transmute.rs:141:32
+  --> $DIR/transmute.rs:158:32
    |
 LL |     let _: &mut str = unsafe { std::mem::transmute(mb) };
    |                                ^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::str::from_utf8_mut(mb).unwrap()`
 
 error: transmute from a `&[u8]` to a `&str`
-  --> $DIR/transmute.rs:142:30
+  --> $DIR/transmute.rs:159:30
    |
 LL |     const _: &str = unsafe { std::mem::transmute(B) };
    |                              ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::str::from_utf8_unchecked(B)`
 
-error: aborting due to 39 previous errors
+error: aborting due to 38 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 0c6ebf1c6abd86c92c063e03fa38de247eae8782 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Fri, 18 Mar 2022 00:59:48 -0400
Subject: Move `useless_transmute` back to `complexity`

---
 clippy_lints/src/lib.register_all.rs        | 1 +
 clippy_lints/src/lib.register_complexity.rs | 1 +
 clippy_lints/src/lib.register_nursery.rs    | 1 -
 clippy_lints/src/transmute/mod.rs           | 2 +-
 tests/ui/transmute_undefined_repr.rs        | 2 +-
 5 files changed, 4 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index d4f8d676c22..8567b6b8a7e 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -305,6 +305,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(transmute::TRANSMUTE_NUM_TO_BYTES),
     LintId::of(transmute::TRANSMUTE_PTR_TO_REF),
     LintId::of(transmute::UNSOUND_COLLECTION_TRANSMUTE),
+    LintId::of(transmute::USELESS_TRANSMUTE),
     LintId::of(transmute::WRONG_TRANSMUTE),
     LintId::of(transmuting_null::TRANSMUTING_NULL),
     LintId::of(types::BORROWED_BOX),
diff --git a/clippy_lints/src/lib.register_complexity.rs b/clippy_lints/src/lib.register_complexity.rs
index d5dfcd10a66..fe8637faf97 100644
--- a/clippy_lints/src/lib.register_complexity.rs
+++ b/clippy_lints/src/lib.register_complexity.rs
@@ -90,6 +90,7 @@ store.register_group(true, "clippy::complexity", Some("clippy_complexity"), vec!
     LintId::of(transmute::TRANSMUTE_INT_TO_FLOAT),
     LintId::of(transmute::TRANSMUTE_NUM_TO_BYTES),
     LintId::of(transmute::TRANSMUTE_PTR_TO_REF),
+    LintId::of(transmute::USELESS_TRANSMUTE),
     LintId::of(types::BORROWED_BOX),
     LintId::of(types::TYPE_COMPLEXITY),
     LintId::of(types::VEC_BOX),
diff --git a/clippy_lints/src/lib.register_nursery.rs b/clippy_lints/src/lib.register_nursery.rs
index 10808af363d..f961952991f 100644
--- a/clippy_lints/src/lib.register_nursery.rs
+++ b/clippy_lints/src/lib.register_nursery.rs
@@ -31,7 +31,6 @@ store.register_group(true, "clippy::nursery", Some("clippy_nursery"), vec![
     LintId::of(trait_bounds::TRAIT_DUPLICATION_IN_BOUNDS),
     LintId::of(trait_bounds::TYPE_REPETITION_IN_BOUNDS),
     LintId::of(transmute::TRANSMUTE_UNDEFINED_REPR),
-    LintId::of(transmute::USELESS_TRANSMUTE),
     LintId::of(unused_rounding::UNUSED_ROUNDING),
     LintId::of(use_self::USE_SELF),
 ])
diff --git a/clippy_lints/src/transmute/mod.rs b/clippy_lints/src/transmute/mod.rs
index d2a040beb0c..cbe1406728b 100644
--- a/clippy_lints/src/transmute/mod.rs
+++ b/clippy_lints/src/transmute/mod.rs
@@ -59,7 +59,7 @@ declare_clippy_lint! {
     /// ```
     #[clippy::version = "pre 1.29.0"]
     pub USELESS_TRANSMUTE,
-    nursery,
+    complexity,
     "transmutes that have the same to and from types or could be a cast/coercion"
 }
 
diff --git a/tests/ui/transmute_undefined_repr.rs b/tests/ui/transmute_undefined_repr.rs
index b06ed4a9173..ebcaa7a84cf 100644
--- a/tests/ui/transmute_undefined_repr.rs
+++ b/tests/ui/transmute_undefined_repr.rs
@@ -1,5 +1,5 @@
 #![warn(clippy::transmute_undefined_repr)]
-#![allow(clippy::unit_arg, clippy::transmute_ptr_to_ref)]
+#![allow(clippy::unit_arg, clippy::transmute_ptr_to_ref, clippy::useless_transmute)]
 
 use core::any::TypeId;
 use core::ffi::c_void;
-- 
cgit 1.4.1-3-g733a5


From ca78e2428e25524831231263c579e390f7dbd1e3 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Mon, 30 May 2022 12:36:05 -0400
Subject: Add lint `swap_ptr_to_ref`

---
 CHANGELOG.md                                |  1 +
 clippy_lints/src/lib.register_all.rs        |  1 +
 clippy_lints/src/lib.register_lints.rs      |  1 +
 clippy_lints/src/lib.register_suspicious.rs |  1 +
 clippy_lints/src/lib.rs                     |  2 +
 clippy_lints/src/swap_ptr_to_ref.rs         | 80 +++++++++++++++++++++++++++++
 clippy_utils/src/paths.rs                   |  1 +
 tests/ui/swap_ptr_to_ref.fixed              | 24 +++++++++
 tests/ui/swap_ptr_to_ref.rs                 | 24 +++++++++
 tests/ui/swap_ptr_to_ref.stderr             | 28 ++++++++++
 tests/ui/swap_ptr_to_ref_unfixable.rs       | 18 +++++++
 tests/ui/swap_ptr_to_ref_unfixable.stderr   | 22 ++++++++
 12 files changed, 203 insertions(+)
 create mode 100644 clippy_lints/src/swap_ptr_to_ref.rs
 create mode 100644 tests/ui/swap_ptr_to_ref.fixed
 create mode 100644 tests/ui/swap_ptr_to_ref.rs
 create mode 100644 tests/ui/swap_ptr_to_ref.stderr
 create mode 100644 tests/ui/swap_ptr_to_ref_unfixable.rs
 create mode 100644 tests/ui/swap_ptr_to_ref_unfixable.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 67ca4cf708a..731d5cac333 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3753,6 +3753,7 @@ Released 2018-09-13
 [`suspicious_operation_groupings`]: https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_operation_groupings
 [`suspicious_splitn`]: https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_splitn
 [`suspicious_unary_op_formatting`]: https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_unary_op_formatting
+[`swap_ptr_to_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#swap_ptr_to_ref
 [`tabs_in_doc_comments`]: https://rust-lang.github.io/rust-clippy/master/index.html#tabs_in_doc_comments
 [`temporary_assignment`]: https://rust-lang.github.io/rust-clippy/master/index.html#temporary_assignment
 [`temporary_cstring_as_ptr`]: https://rust-lang.github.io/rust-clippy/master/index.html#temporary_cstring_as_ptr
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 8567b6b8a7e..58f8ea7b997 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -292,6 +292,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(suspicious_trait_impl::SUSPICIOUS_OP_ASSIGN_IMPL),
     LintId::of(swap::ALMOST_SWAPPED),
     LintId::of(swap::MANUAL_SWAP),
+    LintId::of(swap_ptr_to_ref::SWAP_PTR_TO_REF),
     LintId::of(tabs_in_doc_comments::TABS_IN_DOC_COMMENTS),
     LintId::of(temporary_assignment::TEMPORARY_ASSIGNMENT),
     LintId::of(to_digit_is_some::TO_DIGIT_IS_SOME),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index b76eaae377e..e04d9f4fb90 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -497,6 +497,7 @@ store.register_lints(&[
     suspicious_trait_impl::SUSPICIOUS_OP_ASSIGN_IMPL,
     swap::ALMOST_SWAPPED,
     swap::MANUAL_SWAP,
+    swap_ptr_to_ref::SWAP_PTR_TO_REF,
     tabs_in_doc_comments::TABS_IN_DOC_COMMENTS,
     temporary_assignment::TEMPORARY_ASSIGNMENT,
     to_digit_is_some::TO_DIGIT_IS_SOME,
diff --git a/clippy_lints/src/lib.register_suspicious.rs b/clippy_lints/src/lib.register_suspicious.rs
index 3d6d2d8951c..43ced5070f1 100644
--- a/clippy_lints/src/lib.register_suspicious.rs
+++ b/clippy_lints/src/lib.register_suspicious.rs
@@ -32,4 +32,5 @@ store.register_group(true, "clippy::suspicious", Some("clippy_suspicious"), vec!
     LintId::of(significant_drop_in_scrutinee::SIGNIFICANT_DROP_IN_SCRUTINEE),
     LintId::of(suspicious_trait_impl::SUSPICIOUS_ARITHMETIC_IMPL),
     LintId::of(suspicious_trait_impl::SUSPICIOUS_OP_ASSIGN_IMPL),
+    LintId::of(swap_ptr_to_ref::SWAP_PTR_TO_REF),
 ])
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 67ae2053f5a..81a231cbebe 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -380,6 +380,7 @@ mod strlen_on_c_strings;
 mod suspicious_operation_groupings;
 mod suspicious_trait_impl;
 mod swap;
+mod swap_ptr_to_ref;
 mod tabs_in_doc_comments;
 mod temporary_assignment;
 mod to_digit_is_some;
@@ -913,6 +914,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(get_first::GetFirst));
     store.register_early_pass(|| Box::new(unused_rounding::UnusedRounding));
     store.register_early_pass(move || Box::new(almost_complete_letter_range::AlmostCompleteLetterRange::new(msrv)));
+    store.register_late_pass(|| Box::new(swap_ptr_to_ref::SwapPtrToRef));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/swap_ptr_to_ref.rs b/clippy_lints/src/swap_ptr_to_ref.rs
new file mode 100644
index 00000000000..75d3b040c96
--- /dev/null
+++ b/clippy_lints/src/swap_ptr_to_ref.rs
@@ -0,0 +1,80 @@
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::source::snippet_with_context;
+use clippy_utils::{match_def_path, path_def_id, paths};
+use rustc_errors::Applicability;
+use rustc_hir::{BorrowKind, Expr, ExprKind, Mutability, UnOp};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::{Span, SyntaxContext};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for calls to `core::mem::swap` where either parameter is derived from a pointer
+    ///
+    /// ### Why is this bad?
+    /// When at least one parameter to `swap` is derived from a pointer it may overlap with the
+    /// other. This would then lead to undefined behavior.
+    ///
+    /// ### Example
+    /// ```rust
+    /// unsafe fn swap(x: &[*mut u32], y: &[*mut u32]) {
+    ///     for (&x, &y) in x.iter().zip(y) {
+    ///         core::mem::swap(&mut *x, &mut *y);
+    ///     }
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// unsafe fn swap(x: &[*mut u32], y: &[*mut u32]) {
+    ///     for (&x, &y) in x.iter().zip(y) {
+    ///         core::ptr::swap(x, y);
+    ///     }
+    /// }
+    /// ```
+    #[clippy::version = "1.63.0"]
+    pub SWAP_PTR_TO_REF,
+    suspicious,
+    "call to `mem::swap` using pointer derived references"
+}
+declare_lint_pass!(SwapPtrToRef => [SWAP_PTR_TO_REF]);
+
+impl LateLintPass<'_> for SwapPtrToRef {
+    fn check_expr(&mut self, cx: &LateContext<'_>, e: &Expr<'_>) {
+        if let ExprKind::Call(fn_expr, [arg1, arg2]) = e.kind
+            && let Some(fn_id) = path_def_id(cx, fn_expr)
+            && match_def_path(cx, fn_id, &paths::MEM_SWAP)
+            && let ctxt = e.span.ctxt()
+            && let (from_ptr1, arg1_span) = is_ptr_to_ref(cx, arg1, ctxt)
+            && let (from_ptr2, arg2_span) = is_ptr_to_ref(cx, arg2, ctxt)
+            && (from_ptr1 || from_ptr2)
+        {
+            span_lint_and_then(
+                cx,
+                SWAP_PTR_TO_REF,
+                e.span,
+                "call to `core::mem::swap` with a parameter derived from a raw pointer",
+                |diag| {
+                    if !((from_ptr1 && arg1_span.is_none()) || (from_ptr2 && arg2_span.is_none())) {
+                        let mut app = Applicability::MachineApplicable;
+                        let snip1 = snippet_with_context(cx, arg1_span.unwrap_or(arg1.span), ctxt, "..", &mut app).0;
+                        let snip2 = snippet_with_context(cx, arg2_span.unwrap_or(arg2.span), ctxt, "..", &mut app).0;
+                        diag.span_suggestion(e.span, "use ptr::swap", format!("core::ptr::swap({}, {})", snip1, snip2), app);
+                    }
+                }
+            );
+        }
+    }
+}
+
+/// Checks if the expression converts a mutable pointer to a mutable reference. If it is, also
+/// returns the span of the pointer expression if it's suitable for making a suggestion.
+fn is_ptr_to_ref(cx: &LateContext<'_>, e: &Expr<'_>, ctxt: SyntaxContext) -> (bool, Option<Span>) {
+    if let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Mut, borrowed_expr) = e.kind
+        && let ExprKind::Unary(UnOp::Deref, derefed_expr) = borrowed_expr.kind
+        && cx.typeck_results().expr_ty(derefed_expr).is_unsafe_ptr()
+    {
+        (true, (borrowed_expr.span.ctxt() == ctxt || derefed_expr.span.ctxt() == ctxt).then(|| derefed_expr.span))
+    } else {
+        (false, None)
+    }
+}
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index 0064694ff92..89789c3d851 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -73,6 +73,7 @@ pub const LATE_CONTEXT: [&str; 2] = ["rustc_lint", "LateContext"];
 pub const LATE_LINT_PASS: [&str; 3] = ["rustc_lint", "passes", "LateLintPass"];
 #[cfg(feature = "internal")]
 pub const LINT: [&str; 2] = ["rustc_lint_defs", "Lint"];
+pub const MEM_SWAP: [&str; 3] = ["core", "mem", "swap"];
 pub const MUTEX_GUARD: [&str; 4] = ["std", "sync", "mutex", "MutexGuard"];
 pub const OPEN_OPTIONS: [&str; 3] = ["std", "fs", "OpenOptions"];
 /// Preferably use the diagnostic item `sym::Option` where possible
diff --git a/tests/ui/swap_ptr_to_ref.fixed b/tests/ui/swap_ptr_to_ref.fixed
new file mode 100644
index 00000000000..596b6ee919b
--- /dev/null
+++ b/tests/ui/swap_ptr_to_ref.fixed
@@ -0,0 +1,24 @@
+// run-rustfix
+
+#![warn(clippy::swap_ptr_to_ref)]
+
+use core::ptr::addr_of_mut;
+
+fn main() {
+    let mut x = 0u32;
+    let y: *mut _ = &mut x;
+    let z: *mut _ = &mut x;
+
+    unsafe {
+        core::ptr::swap(y, z);
+        core::ptr::swap(y, &mut x);
+        core::ptr::swap(&mut x, y);
+        core::ptr::swap(addr_of_mut!(x), addr_of_mut!(x));
+    }
+
+    let y = &mut x;
+    let mut z = 0u32;
+    let z = &mut z;
+
+    core::mem::swap(y, z);
+}
diff --git a/tests/ui/swap_ptr_to_ref.rs b/tests/ui/swap_ptr_to_ref.rs
new file mode 100644
index 00000000000..282f571211d
--- /dev/null
+++ b/tests/ui/swap_ptr_to_ref.rs
@@ -0,0 +1,24 @@
+// run-rustfix
+
+#![warn(clippy::swap_ptr_to_ref)]
+
+use core::ptr::addr_of_mut;
+
+fn main() {
+    let mut x = 0u32;
+    let y: *mut _ = &mut x;
+    let z: *mut _ = &mut x;
+
+    unsafe {
+        core::mem::swap(&mut *y, &mut *z);
+        core::mem::swap(&mut *y, &mut x);
+        core::mem::swap(&mut x, &mut *y);
+        core::mem::swap(&mut *addr_of_mut!(x), &mut *addr_of_mut!(x));
+    }
+
+    let y = &mut x;
+    let mut z = 0u32;
+    let z = &mut z;
+
+    core::mem::swap(y, z);
+}
diff --git a/tests/ui/swap_ptr_to_ref.stderr b/tests/ui/swap_ptr_to_ref.stderr
new file mode 100644
index 00000000000..401ce070869
--- /dev/null
+++ b/tests/ui/swap_ptr_to_ref.stderr
@@ -0,0 +1,28 @@
+error: call to `core::mem::swap` with a parameter derived from a raw pointer
+  --> $DIR/swap_ptr_to_ref.rs:13:9
+   |
+LL |         core::mem::swap(&mut *y, &mut *z);
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use ptr::swap: `core::ptr::swap(y, z)`
+   |
+   = note: `-D clippy::swap-ptr-to-ref` implied by `-D warnings`
+
+error: call to `core::mem::swap` with a parameter derived from a raw pointer
+  --> $DIR/swap_ptr_to_ref.rs:14:9
+   |
+LL |         core::mem::swap(&mut *y, &mut x);
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use ptr::swap: `core::ptr::swap(y, &mut x)`
+
+error: call to `core::mem::swap` with a parameter derived from a raw pointer
+  --> $DIR/swap_ptr_to_ref.rs:15:9
+   |
+LL |         core::mem::swap(&mut x, &mut *y);
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use ptr::swap: `core::ptr::swap(&mut x, y)`
+
+error: call to `core::mem::swap` with a parameter derived from a raw pointer
+  --> $DIR/swap_ptr_to_ref.rs:16:9
+   |
+LL |         core::mem::swap(&mut *addr_of_mut!(x), &mut *addr_of_mut!(x));
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use ptr::swap: `core::ptr::swap(addr_of_mut!(x), addr_of_mut!(x))`
+
+error: aborting due to 4 previous errors
+
diff --git a/tests/ui/swap_ptr_to_ref_unfixable.rs b/tests/ui/swap_ptr_to_ref_unfixable.rs
new file mode 100644
index 00000000000..66ea7c6529b
--- /dev/null
+++ b/tests/ui/swap_ptr_to_ref_unfixable.rs
@@ -0,0 +1,18 @@
+#![warn(clippy::swap_ptr_to_ref)]
+
+macro_rules! addr_of_mut_to_ref {
+    ($e:expr) => {
+        &mut *core::ptr::addr_of_mut!($e)
+    };
+}
+
+fn main() {
+    let mut x = 0u32;
+    let y: *mut _ = &mut x;
+
+    unsafe {
+        core::mem::swap(addr_of_mut_to_ref!(x), &mut *y);
+        core::mem::swap(&mut *y, addr_of_mut_to_ref!(x));
+        core::mem::swap(addr_of_mut_to_ref!(x), addr_of_mut_to_ref!(x));
+    }
+}
diff --git a/tests/ui/swap_ptr_to_ref_unfixable.stderr b/tests/ui/swap_ptr_to_ref_unfixable.stderr
new file mode 100644
index 00000000000..c261205d556
--- /dev/null
+++ b/tests/ui/swap_ptr_to_ref_unfixable.stderr
@@ -0,0 +1,22 @@
+error: call to `core::mem::swap` with a parameter derived from a raw pointer
+  --> $DIR/swap_ptr_to_ref_unfixable.rs:14:9
+   |
+LL |         core::mem::swap(addr_of_mut_to_ref!(x), &mut *y);
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::swap-ptr-to-ref` implied by `-D warnings`
+
+error: call to `core::mem::swap` with a parameter derived from a raw pointer
+  --> $DIR/swap_ptr_to_ref_unfixable.rs:15:9
+   |
+LL |         core::mem::swap(&mut *y, addr_of_mut_to_ref!(x));
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: call to `core::mem::swap` with a parameter derived from a raw pointer
+  --> $DIR/swap_ptr_to_ref_unfixable.rs:16:9
+   |
+LL |         core::mem::swap(addr_of_mut_to_ref!(x), addr_of_mut_to_ref!(x));
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 3 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From b20f95c1a1780934367a019a6adba4ec74895716 Mon Sep 17 00:00:00 2001
From: Serial <69764315+Serial-ATA@users.noreply.github.com>
Date: Wed, 1 Jun 2022 18:36:02 -0400
Subject: Combine doc examples

---
 clippy_lints/src/as_conversions.rs          |  7 +-
 clippy_lints/src/attrs.rs                   |  6 +-
 clippy_lints/src/blocks_in_if_conditions.rs | 12 ++--
 clippy_lints/src/double_parens.rs           | 14 ++--
 clippy_lints/src/eq_op.rs                   |  6 +-
 clippy_lints/src/loops/mod.rs               | 15 ++---
 clippy_lints/src/methods/mod.rs             | 99 ++++++++++++-----------------
 clippy_lints/src/minmax.rs                  |  8 +--
 clippy_lints/src/misc.rs                    | 14 ++--
 clippy_lints/src/mutable_debug_assertion.rs |  7 +-
 clippy_lints/src/trait_bounds.rs            | 10 +--
 11 files changed, 88 insertions(+), 110 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/as_conversions.rs b/clippy_lints/src/as_conversions.rs
index 5fa8934c71b..6e5c8f44581 100644
--- a/clippy_lints/src/as_conversions.rs
+++ b/clippy_lints/src/as_conversions.rs
@@ -32,12 +32,11 @@ declare_clippy_lint! {
     /// Use instead:
     /// ```rust,ignore
     /// f(a.try_into()?);
-    /// ```
-    /// or
-    /// ```rust,ignore
+    ///
+    /// // or
+    ///
     /// f(a.try_into().expect("Unexpected u16 overflow in f"));
     /// ```
-    ///
     #[clippy::version = "1.41.0"]
     pub AS_CONVERSIONS,
     restriction,
diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs
index 79a5b670fc8..770cb6a3d7b 100644
--- a/clippy_lints/src/attrs.rs
+++ b/clippy_lints/src/attrs.rs
@@ -241,13 +241,13 @@ declare_clippy_lint! {
     ///
     /// Use instead:
     /// ```rust
+    /// # mod hidden {
     /// #[cfg(target_os = "linux")]
     /// fn conditional() { }
-    /// ```
+    /// # }
     ///
-    /// or
+    /// // or
     ///
-    /// ```rust
     /// #[cfg(unix)]
     /// fn conditional() { }
     /// ```
diff --git a/clippy_lints/src/blocks_in_if_conditions.rs b/clippy_lints/src/blocks_in_if_conditions.rs
index 86e28ea7f7a..5bd7a342389 100644
--- a/clippy_lints/src/blocks_in_if_conditions.rs
+++ b/clippy_lints/src/blocks_in_if_conditions.rs
@@ -22,21 +22,17 @@ declare_clippy_lint! {
     ///
     /// ### Examples
     /// ```rust
-    /// // Bad
+    /// # fn somefunc() -> bool { true };
     /// if { true } { /* ... */ }
     ///
-    /// // Good
-    /// if true { /* ... */ }
+    /// if { let x = somefunc(); x } { /* ... */ }
     /// ```
     ///
-    /// or
-    ///
+    /// Use instead:
     /// ```rust
     /// # fn somefunc() -> bool { true };
-    /// // Bad
-    /// if { let x = somefunc(); x } { /* ... */ }
+    /// if true { /* ... */ }
     ///
-    /// // Good
     /// let res = { let x = somefunc(); x };
     /// if res { /* ... */ }
     /// ```
diff --git a/clippy_lints/src/double_parens.rs b/clippy_lints/src/double_parens.rs
index e10f740d24a..a33ef5ce6e3 100644
--- a/clippy_lints/src/double_parens.rs
+++ b/clippy_lints/src/double_parens.rs
@@ -13,23 +13,21 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust
-    /// // Bad
     /// fn simple_double_parens() -> i32 {
     ///     ((0))
     /// }
     ///
-    /// // Good
+    /// # fn foo(bar: usize) {}
+    /// foo((0));
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust
     /// fn simple_no_parens() -> i32 {
     ///     0
     /// }
     ///
-    /// // or
-    ///
     /// # fn foo(bar: usize) {}
-    /// // Bad
-    /// foo((0));
-    ///
-    /// // Good
     /// foo(0);
     /// ```
     #[clippy::version = "pre 1.29.0"]
diff --git a/clippy_lints/src/eq_op.rs b/clippy_lints/src/eq_op.rs
index afb5d32f953..c3176d987c6 100644
--- a/clippy_lints/src/eq_op.rs
+++ b/clippy_lints/src/eq_op.rs
@@ -30,9 +30,9 @@ declare_clippy_lint! {
     /// ```rust
     /// # let x = 1;
     /// if x + 1 == x + 1 {}
-    /// ```
-    /// or
-    /// ```rust
+    ///
+    /// // or
+    ///
     /// # let a = 3;
     /// # let b = 4;
     /// assert_eq!(a, a);
diff --git a/clippy_lints/src/loops/mod.rs b/clippy_lints/src/loops/mod.rs
index 417248e31ae..d61be78895f 100644
--- a/clippy_lints/src/loops/mod.rs
+++ b/clippy_lints/src/loops/mod.rs
@@ -180,29 +180,24 @@ declare_clippy_lint! {
     /// ### Example
     /// ```rust
     /// # let opt = Some(1);
-    ///
-    /// // Bad
+    /// # let res: Result<i32, std::io::Error> = Ok(1);
     /// for x in opt {
     ///     // ..
     /// }
     ///
-    /// // Good
-    /// if let Some(x) = opt {
+    /// for x in &res {
     ///     // ..
     /// }
     /// ```
     ///
-    /// or
-    ///
+    /// Use instead:
     /// ```rust
+    /// # let opt = Some(1);
     /// # let res: Result<i32, std::io::Error> = Ok(1);
-    ///
-    /// // Bad
-    /// for x in &res {
+    /// if let Some(x) = opt {
     ///     // ..
     /// }
     ///
-    /// // Good
     /// if let Ok(x) = res {
     ///     // ..
     /// }
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index eb1bce8c7d2..08c89ceb796 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -194,25 +194,18 @@ declare_clippy_lint! {
     ///
     /// ### Examples
     /// ```rust
-    /// # let opt = Some(1);
-    ///
-    /// // Bad
-    /// opt.unwrap();
-    ///
-    /// // Good
-    /// opt.expect("more helpful message");
+    /// # let option = Some(1);
+    /// # let result: Result<usize, ()> = Ok(1);
+    /// option.unwrap();
+    /// result.unwrap();
     /// ```
     ///
-    /// or
-    ///
+    /// Use instead:
     /// ```rust
-    /// # let res: Result<usize, ()> = Ok(1);
-    ///
-    /// // Bad
-    /// res.unwrap();
-    ///
-    /// // Good
-    /// res.expect("more helpful message");
+    /// # let option = Some(1);
+    /// # let result: Result<usize, ()> = Ok(1);
+    /// option.expect("more helpful message");
+    /// result.expect("more helpful message");
     /// ```
     #[clippy::version = "1.45.0"]
     pub UNWRAP_USED,
@@ -235,27 +228,21 @@ declare_clippy_lint! {
     ///
     /// ### Examples
     /// ```rust,ignore
-    /// # let opt = Some(1);
-    ///
-    /// // Bad
-    /// opt.expect("one");
-    ///
-    /// // Good
-    /// let opt = Some(1);
-    /// opt?;
+    /// # let option = Some(1);
+    /// # let result: Result<usize, ()> = Ok(1);
+    /// option.expect("one");
+    /// result.expect("one");
     /// ```
     ///
-    /// or
-    ///
-    /// ```rust
-    /// # let res: Result<usize, ()> = Ok(1);
+    /// Use instead:
+    /// ```rust,ignore
+    /// # let option = Some(1);
+    /// # let result: Result<usize, ()> = Ok(1);
+    /// option?;
     ///
-    /// // Bad
-    /// res.expect("one");
+    /// // or
     ///
-    /// // Good
-    /// res?;
-    /// # Ok::<(), ()>(())
+    /// result?;
     /// ```
     #[clippy::version = "1.45.0"]
     pub EXPECT_USED,
@@ -431,26 +418,20 @@ declare_clippy_lint! {
     ///
     /// ### Examples
     /// ```rust
-    /// # let x = Some(1);
-    ///
-    /// // Bad
-    /// x.map(|a| a + 1).unwrap_or(0);
-    ///
-    /// // Good
-    /// x.map_or(0, |a| a + 1);
+    /// # let option = Some(1);
+    /// # let result: Result<usize, ()> = Ok(1);
+    /// # fn some_function(foo: ()) -> usize { 1 }
+    /// option.map(|a| a + 1).unwrap_or(0);
+    /// result.map(|a| a + 1).unwrap_or_else(some_function);
     /// ```
     ///
-    /// or
-    ///
+    /// Use instead:
     /// ```rust
-    /// # let x: Result<usize, ()> = Ok(1);
+    /// # let option = Some(1);
+    /// # let result: Result<usize, ()> = Ok(1);
     /// # fn some_function(foo: ()) -> usize { 1 }
-    ///
-    /// // Bad
-    /// x.map(|a| a + 1).unwrap_or_else(some_function);
-    ///
-    /// // Good
-    /// x.map_or_else(some_function, |a| a + 1);
+    /// option.map_or(0, |a| a + 1);
+    /// result.map_or_else(some_function, |a| a + 1);
     /// ```
     #[clippy::version = "1.45.0"]
     pub MAP_UNWRAP_OR,
@@ -793,13 +774,14 @@ declare_clippy_lint! {
     /// # let foo = Some(String::new());
     /// foo.unwrap_or(String::new());
     /// ```
-    /// this can instead be written:
+    ///
+    /// Use instead:
     /// ```rust
     /// # let foo = Some(String::new());
     /// foo.unwrap_or_else(String::new);
-    /// ```
-    /// or
-    /// ```rust
+    ///
+    /// // or
+    ///
     /// # let foo = Some(String::new());
     /// foo.unwrap_or_default();
     /// ```
@@ -863,15 +845,14 @@ declare_clippy_lint! {
     /// # let err_code = "418";
     /// # let err_msg = "I'm a teapot";
     /// foo.expect(&format!("Err {}: {}", err_code, err_msg));
-    /// ```
-    /// or
-    /// ```rust
+    ///
+    /// // or
+    ///
     /// # let foo = Some(String::new());
-    /// # let err_code = "418";
-    /// # let err_msg = "I'm a teapot";
     /// foo.expect(format!("Err {}: {}", err_code, err_msg).as_str());
     /// ```
-    /// this can instead be written:
+    ///
+    /// Use instead:
     /// ```rust
     /// # let foo = Some(String::new());
     /// # let err_code = "418";
diff --git a/clippy_lints/src/minmax.rs b/clippy_lints/src/minmax.rs
index 65d1f440b76..a081cde8572 100644
--- a/clippy_lints/src/minmax.rs
+++ b/clippy_lints/src/minmax.rs
@@ -18,11 +18,11 @@ declare_clippy_lint! {
     /// the least it hurts readability of the code.
     ///
     /// ### Example
-    /// ```ignore
+    /// ```rust,ignore
     /// min(0, max(100, x))
-    /// ```
-    /// or
-    /// ```ignore
+    ///
+    /// // or
+    ///
     /// x.max(100).min(0)
     /// ```
     /// It will always be equal to `0`. Probably the author meant to clamp the value
diff --git a/clippy_lints/src/misc.rs b/clippy_lints/src/misc.rs
index 7fdc28c5a06..55665699453 100644
--- a/clippy_lints/src/misc.rs
+++ b/clippy_lints/src/misc.rs
@@ -103,11 +103,14 @@ declare_clippy_lint! {
     /// let x = 1.2331f64;
     /// let y = 1.2332f64;
     ///
-    /// // Bad
     /// if y == 1.23f64 { }
     /// if y != x {} // where both are floats
+    /// ```
     ///
-    /// // Good
+    /// Use instead:
+    /// ```rust
+    /// # let x = 1.2331f64;
+    /// # let y = 1.2332f64;
     /// let error_margin = f64::EPSILON; // Use an epsilon for comparison
     /// // Or, if Rust <= 1.42, use `std::f64::EPSILON` constant instead.
     /// // let error_margin = std::f64::EPSILON;
@@ -258,10 +261,13 @@ declare_clippy_lint! {
     /// let x: f64 = 1.0;
     /// const ONE: f64 = 1.00;
     ///
-    /// // Bad
     /// if x == ONE { } // where both are floats
+    /// ```
     ///
-    /// // Good
+    /// Use instead:
+    /// ```rust
+    /// # let x: f64 = 1.0;
+    /// # const ONE: f64 = 1.00;
     /// let error_margin = f64::EPSILON; // Use an epsilon for comparison
     /// // Or, if Rust <= 1.42, use `std::f64::EPSILON` constant instead.
     /// // let error_margin = std::f64::EPSILON;
diff --git a/clippy_lints/src/mutable_debug_assertion.rs b/clippy_lints/src/mutable_debug_assertion.rs
index 8dba60f3a58..321db08dfe8 100644
--- a/clippy_lints/src/mutable_debug_assertion.rs
+++ b/clippy_lints/src/mutable_debug_assertion.rs
@@ -22,9 +22,12 @@ declare_clippy_lint! {
     /// ### Example
     /// ```rust,ignore
     /// debug_assert_eq!(vec![3].pop(), Some(3));
+    ///
     /// // or
-    /// fn take_a_mut_parameter(_: &mut u32) -> bool { unimplemented!() }
-    /// debug_assert!(take_a_mut_parameter(&mut 5));
+    ///
+    /// # let mut x = 5;
+    /// # fn takes_a_mut_parameter(_: &mut u32) -> bool { unimplemented!() }
+    /// debug_assert!(takes_a_mut_parameter(&mut x));
     /// ```
     #[clippy::version = "1.40.0"]
     pub DEBUG_ASSERT_WITH_MUT_CALL,
diff --git a/clippy_lints/src/trait_bounds.rs b/clippy_lints/src/trait_bounds.rs
index 6c60fb4b8e0..b91be0eb4be 100644
--- a/clippy_lints/src/trait_bounds.rs
+++ b/clippy_lints/src/trait_bounds.rs
@@ -54,14 +54,14 @@ declare_clippy_lint! {
     /// fn func<T: Clone + Default>(arg: T) where T: Clone + Default {}
     /// ```
     ///
-    /// Could be written as:
-    ///
+    /// Use instead:
     /// ```rust
+    /// # mod hidden {
     /// fn func<T: Clone + Default>(arg: T) {}
-    /// ```
-    /// or
+    /// # }
+    ///
+    /// // or
     ///
-    /// ```rust
     /// fn func<T>(arg: T) where T: Clone + Default {}
     /// ```
     #[clippy::version = "1.47.0"]
-- 
cgit 1.4.1-3-g733a5


From 007fae10ed8c8fa51b396bcc02071fe792f2c288 Mon Sep 17 00:00:00 2001
From: kyoto7250 <50972773+kyoto7250@users.noreply.github.com>
Date: Thu, 2 Jun 2022 00:57:08 +0900
Subject: fix(manual_find_map and manual_filter_map): check clone method

---
 clippy_lints/src/methods/filter_map.rs | 10 +++++++++-
 tests/ui/manual_filter_map.fixed       | 22 ++++++++++++++++++++++
 tests/ui/manual_filter_map.rs          | 23 +++++++++++++++++++++++
 tests/ui/manual_filter_map.stderr      | 16 +++++++++++++++-
 tests/ui/manual_find_map.fixed         | 20 ++++++++++++++++++++
 tests/ui/manual_find_map.rs            | 20 ++++++++++++++++++++
 tests/ui/manual_find_map.stderr        | 14 +++++++++++++-
 7 files changed, 122 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/filter_map.rs b/clippy_lints/src/methods/filter_map.rs
index 558cb6bd64e..04ca295dc69 100644
--- a/clippy_lints/src/methods/filter_map.rs
+++ b/clippy_lints/src/methods/filter_map.rs
@@ -155,7 +155,15 @@ pub(super) fn check<'tcx>(
                 }
                 false
             };
-            if SpanlessEq::new(cx).expr_fallback(eq_fallback).eq_expr(filter_arg, map_arg);
+
+            if match map_arg.kind {
+                ExprKind::MethodCall(clone, [original_arg], _) => {
+                    clone.ident.name == sym::clone
+                        && SpanlessEq::new(cx).expr_fallback(eq_fallback).eq_expr(filter_arg, original_arg)
+                },
+                _ => SpanlessEq::new(cx).expr_fallback(eq_fallback).eq_expr(filter_arg, map_arg)
+            };
+
             then {
                 let span = filter_span.with_hi(expr.span.hi());
                 let (filter_name, lint) = if is_find {
diff --git a/tests/ui/manual_filter_map.fixed b/tests/ui/manual_filter_map.fixed
index fc8f58f8ea5..c88a4f43de2 100644
--- a/tests/ui/manual_filter_map.fixed
+++ b/tests/ui/manual_filter_map.fixed
@@ -35,3 +35,25 @@ fn to_opt<T>(_: T) -> Option<T> {
 fn to_res<T>(_: T) -> Result<T, ()> {
     unimplemented!()
 }
+
+struct OptionFoo {
+    field: Option<String>,
+}
+
+struct ResultFoo {
+    field: Result<String, ()>,
+}
+
+fn issue_8920() {
+    let vec = vec![OptionFoo {
+        field: Some(String::from("str")),
+    }];
+    let _ = vec
+        .iter()
+        .filter_map(|f| f.field.clone());
+
+    let vec = vec![ResultFoo {
+        field: Ok(String::from("str")),
+    }];
+    let _ = vec.iter().filter_map(|f| f.field.clone().ok());
+}
diff --git a/tests/ui/manual_filter_map.rs b/tests/ui/manual_filter_map.rs
index 3af4bbee3bf..bb859ebe315 100644
--- a/tests/ui/manual_filter_map.rs
+++ b/tests/ui/manual_filter_map.rs
@@ -35,3 +35,26 @@ fn to_opt<T>(_: T) -> Option<T> {
 fn to_res<T>(_: T) -> Result<T, ()> {
     unimplemented!()
 }
+
+struct OptionFoo {
+    field: Option<String>,
+}
+
+struct ResultFoo {
+    field: Result<String, ()>,
+}
+
+fn issue_8920() {
+    let vec = vec![OptionFoo {
+        field: Some(String::from("str")),
+    }];
+    let _ = vec
+        .iter()
+        .filter(|f| f.field.is_some())
+        .map(|f| f.field.clone().unwrap());
+
+    let vec = vec![ResultFoo {
+        field: Ok(String::from("str")),
+    }];
+    let _ = vec.iter().filter(|f| f.field.is_ok()).map(|f| f.field.clone().unwrap());
+}
diff --git a/tests/ui/manual_filter_map.stderr b/tests/ui/manual_filter_map.stderr
index 4d4e2d5c12f..a78343e882f 100644
--- a/tests/ui/manual_filter_map.stderr
+++ b/tests/ui/manual_filter_map.stderr
@@ -18,5 +18,19 @@ error: `filter(..).map(..)` can be simplified as `filter_map(..)`
 LL |     let _ = (0..).filter(|&n| to_res(n).is_ok()).map(|a| to_res(a).unwrap_or(1));
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `filter_map(|a| to_res(a).ok())`
 
-error: aborting due to 3 previous errors
+error: `filter(..).map(..)` can be simplified as `filter_map(..)`
+  --> $DIR/manual_filter_map.rs:53:10
+   |
+LL |           .filter(|f| f.field.is_some())
+   |  __________^
+LL | |         .map(|f| f.field.clone().unwrap());
+   | |__________________________________________^ help: try: `filter_map(|f| f.field.clone())`
+
+error: `filter(..).map(..)` can be simplified as `filter_map(..)`
+  --> $DIR/manual_filter_map.rs:59:24
+   |
+LL |     let _ = vec.iter().filter(|f| f.field.is_ok()).map(|f| f.field.clone().unwrap());
+   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `filter_map(|f| f.field.clone().ok())`
+
+error: aborting due to 5 previous errors
 
diff --git a/tests/ui/manual_find_map.fixed b/tests/ui/manual_find_map.fixed
index 95e97c4fd1f..d78d72d8e8f 100644
--- a/tests/ui/manual_find_map.fixed
+++ b/tests/ui/manual_find_map.fixed
@@ -35,3 +35,23 @@ fn to_opt<T>(_: T) -> Option<T> {
 fn to_res<T>(_: T) -> Result<T, ()> {
     unimplemented!()
 }
+
+struct OptionFoo {
+    field: Option<String>,
+}
+
+struct ResultFoo {
+    field: Result<String, ()>,
+}
+
+fn issue_8920() {
+    let vec = vec![OptionFoo {
+        field: Some(String::from("str")),
+    }];
+    let _ = vec.iter().find_map(|f| f.field.clone());
+
+    let vec = vec![ResultFoo {
+        field: Ok(String::from("str")),
+    }];
+    let _ = vec.iter().find_map(|f| f.field.clone().ok());
+}
diff --git a/tests/ui/manual_find_map.rs b/tests/ui/manual_find_map.rs
index cd3c82e3b25..74e8e52ed16 100644
--- a/tests/ui/manual_find_map.rs
+++ b/tests/ui/manual_find_map.rs
@@ -35,3 +35,23 @@ fn to_opt<T>(_: T) -> Option<T> {
 fn to_res<T>(_: T) -> Result<T, ()> {
     unimplemented!()
 }
+
+struct OptionFoo {
+    field: Option<String>,
+}
+
+struct ResultFoo {
+    field: Result<String, ()>,
+}
+
+fn issue_8920() {
+    let vec = vec![OptionFoo {
+        field: Some(String::from("str")),
+    }];
+    let _ = vec.iter().find(|f| f.field.is_some()).map(|f| f.field.clone().unwrap());
+
+    let vec = vec![ResultFoo {
+        field: Ok(String::from("str")),
+    }];
+    let _ = vec.iter().find(|f| f.field.is_ok()).map(|f| f.field.clone().unwrap());
+}
diff --git a/tests/ui/manual_find_map.stderr b/tests/ui/manual_find_map.stderr
index 9e7f798df45..0b1465a8422 100644
--- a/tests/ui/manual_find_map.stderr
+++ b/tests/ui/manual_find_map.stderr
@@ -18,5 +18,17 @@ error: `find(..).map(..)` can be simplified as `find_map(..)`
 LL |     let _ = (0..).find(|&n| to_res(n).is_ok()).map(|a| to_res(a).unwrap_or(1));
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|a| to_res(a).ok())`
 
-error: aborting due to 3 previous errors
+error: `find(..).map(..)` can be simplified as `find_map(..)`
+  --> $DIR/manual_find_map.rs:51:24
+   |
+LL |     let _ = vec.iter().find(|f| f.field.is_some()).map(|f| f.field.clone().unwrap());
+   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|f| f.field.clone())`
+
+error: `find(..).map(..)` can be simplified as `find_map(..)`
+  --> $DIR/manual_find_map.rs:56:24
+   |
+LL |     let _ = vec.iter().find(|f| f.field.is_ok()).map(|f| f.field.clone().unwrap());
+   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|f| f.field.clone().ok())`
+
+error: aborting due to 5 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From bc5a8e9537d30858fede92347e3842d4d4f8a803 Mon Sep 17 00:00:00 2001
From: Preston From <prestonfrom@gmail.com>
Date: Thu, 2 Jun 2022 02:23:42 -0600
Subject: Lint message correctly identifies match vs for loop

---
 clippy_lints/src/significant_drop_in_scrutinee.rs | 23 +++++++++++++----------
 tests/ui/significant_drop_in_scrutinee.stderr     |  2 +-
 2 files changed, 14 insertions(+), 11 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/significant_drop_in_scrutinee.rs b/clippy_lints/src/significant_drop_in_scrutinee.rs
index 6b45b6d4452..2f7819cb470 100644
--- a/clippy_lints/src/significant_drop_in_scrutinee.rs
+++ b/clippy_lints/src/significant_drop_in_scrutinee.rs
@@ -91,15 +91,11 @@ declare_lint_pass!(SignificantDropInScrutinee => [SIGNIFICANT_DROP_IN_SCRUTINEE]
 
 impl<'tcx> LateLintPass<'tcx> for SignificantDropInScrutinee {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
-        if let Some(suggestions) = has_significant_drop_in_scrutinee(cx, expr) {
+        if let Some((suggestions, message)) = has_significant_drop_in_scrutinee(cx, expr) {
             for found in suggestions {
-                span_lint_and_then(
-                    cx,
-                    SIGNIFICANT_DROP_IN_SCRUTINEE,
-                    found.found_span,
-                    "temporary with significant drop in match scrutinee",
-                    |diag| set_diagnostic(diag, cx, expr, found),
-                );
+                span_lint_and_then(cx, SIGNIFICANT_DROP_IN_SCRUTINEE, found.found_span, message, |diag| {
+                    set_diagnostic(diag, cx, expr, found);
+                });
             }
         }
     }
@@ -153,13 +149,20 @@ fn set_diagnostic<'tcx>(diag: &mut Diagnostic, cx: &LateContext<'tcx>, expr: &'t
 fn has_significant_drop_in_scrutinee<'tcx, 'a>(
     cx: &'a LateContext<'tcx>,
     expr: &'tcx Expr<'tcx>,
-) -> Option<Vec<FoundSigDrop>> {
+) -> Option<(Vec<FoundSigDrop>, &'static str)> {
     match expr.kind {
         ExprKind::Match(match_expr, _, source) => {
             match source {
                 MatchSource::Normal | MatchSource::ForLoopDesugar => {
                     let mut helper = SigDropHelper::new(cx);
-                    helper.find_sig_drop(match_expr)
+                    helper.find_sig_drop(match_expr).map(|drops| {
+                        let message = if source == MatchSource::Normal {
+                            "temporary with significant drop in match scrutinee"
+                        } else {
+                            "temporary with significant drop in for loop"
+                        };
+                        (drops, message)
+                    })
                 },
                 // MatchSource of TryDesugar or AwaitDesugar is out of scope for this lint
                 MatchSource::TryDesugar | MatchSource::AwaitDesugar => None,
diff --git a/tests/ui/significant_drop_in_scrutinee.stderr b/tests/ui/significant_drop_in_scrutinee.stderr
index 77942325244..303f3c1df03 100644
--- a/tests/ui/significant_drop_in_scrutinee.stderr
+++ b/tests/ui/significant_drop_in_scrutinee.stderr
@@ -285,7 +285,7 @@ error: temporary with significant drop in match scrutinee
 LL |     match rwlock.read().unwrap().to_number() {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: temporary with significant drop in match scrutinee
+error: temporary with significant drop in for loop
   --> $DIR/significant_drop_in_scrutinee.rs:589:14
    |
 LL |     for s in rwlock.read().unwrap().iter() {
-- 
cgit 1.4.1-3-g733a5


From 756caf79e64598886551325dbf9ab7eccee03328 Mon Sep 17 00:00:00 2001
From: Andre Bogus <bogusandre@gmail.com>
Date: Tue, 31 May 2022 09:23:17 +0200
Subject: account for generics

---
 clippy_lints/src/large_enum_variant.rs | 24 ++++++++++++++++++++++--
 tests/ui/large_enum_variant.rs         | 14 ++++++++++++++
 tests/ui/large_enum_variant.stderr     | 24 +++++++++++++++++++++++-
 3 files changed, 59 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/large_enum_variant.rs b/clippy_lints/src/large_enum_variant.rs
index 34b7cf67db1..63ac092dfaf 100644
--- a/clippy_lints/src/large_enum_variant.rs
+++ b/clippy_lints/src/large_enum_variant.rs
@@ -7,6 +7,7 @@ use rustc_hir::{Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::layout::LayoutOf;
+use rustc_middle::ty::{Adt, Ty};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::Span;
 
@@ -26,6 +27,15 @@ declare_clippy_lint! {
     /// the overhead is negligible and the boxing is counter-productive. Always
     /// measure the change this lint suggests.
     ///
+    /// For types that implement `Copy`, the suggestion to `Box` a variant's
+    /// data would require removing the trait impl. The types can of course
+    /// still be `Clone`, but that is worse ergonomically. Depending on the
+    /// use case it may be possible to store the large data in an auxillary
+    /// structure (e.g. Arena or ECS).
+    ///
+    /// The lint will ignore generic types if the layout depends on the
+    /// generics, even if the size difference will be large anyway.
+    ///
     /// ### Example
     /// ```rust
     /// // Bad
@@ -74,7 +84,7 @@ struct VariantInfo {
 impl_lint_pass!(LargeEnumVariant => [LARGE_ENUM_VARIANT]);
 
 impl<'tcx> LateLintPass<'tcx> for LargeEnumVariant {
-    fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
+    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &Item<'tcx>) {
         if in_external_macro(cx.tcx.sess, item.span) {
             return;
         }
@@ -132,7 +142,7 @@ impl<'tcx> LateLintPass<'tcx> for LargeEnumVariant {
                         let fields = def.variants[variants_size[0].ind].data.fields();
                         variants_size[0].fields_size.sort_by(|a, b| (a.size.cmp(&b.size)));
                         let mut applicability = Applicability::MaybeIncorrect;
-                        if is_copy(cx, ty) {
+                        if is_copy(cx, ty) || maybe_copy(cx, ty) {
                             diag.span_note(
                                 item.ident.span,
                                 "boxing a variant would require the type no longer be `Copy`",
@@ -176,3 +186,13 @@ impl<'tcx> LateLintPass<'tcx> for LargeEnumVariant {
         }
     }
 }
+
+fn maybe_copy<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
+    if let Adt(_def, substs) = ty.kind()
+        && substs.types().next().is_some()
+        && let Some(copy_trait) = cx.tcx.lang_items().copy_trait()
+    {
+        return cx.tcx.non_blanket_impls_for_ty(copy_trait, ty).next().is_some();
+    }
+    false
+}
diff --git a/tests/ui/large_enum_variant.rs b/tests/ui/large_enum_variant.rs
index 42563383fed..23152a13322 100644
--- a/tests/ui/large_enum_variant.rs
+++ b/tests/ui/large_enum_variant.rs
@@ -114,8 +114,22 @@ impl Clone for ManuallyCopyLargeEnum {
         *self
     }
 }
+
 impl Copy for ManuallyCopyLargeEnum {}
 
+enum SomeGenericPossiblyCopyEnum<T> {
+    A(bool, std::marker::PhantomData<T>),
+    B([u64; 4000]),
+}
+
+impl<T: Copy> Clone for SomeGenericPossiblyCopyEnum<T> {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+
+impl<T: Copy> Copy for SomeGenericPossiblyCopyEnum<T> {}
+
 fn main() {
     large_enum_variant!();
 }
diff --git a/tests/ui/large_enum_variant.stderr b/tests/ui/large_enum_variant.stderr
index 397d263ae9f..0248327262d 100644
--- a/tests/ui/large_enum_variant.stderr
+++ b/tests/ui/large_enum_variant.stderr
@@ -171,5 +171,27 @@ help: consider boxing the large fields to reduce the total size of the enum
 LL |     B([u128; 4000]),
    |     ^^^^^^^^^^^^^^^
 
-error: aborting due to 10 previous errors
+error: large size difference between variants
+  --> $DIR/large_enum_variant.rs:122:5
+   |
+LL |     B([u64; 4000]),
+   |     ^^^^^^^^^^^^^^ this variant is 32000 bytes
+   |
+note: and the second-largest variant is 1 bytes:
+  --> $DIR/large_enum_variant.rs:121:5
+   |
+LL |     A(bool, std::marker::PhantomData<T>),
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+note: boxing a variant would require the type no longer be `Copy`
+  --> $DIR/large_enum_variant.rs:120:6
+   |
+LL | enum SomeGenericPossiblyCopyEnum<T> {
+   |      ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+help: consider boxing the large fields to reduce the total size of the enum
+  --> $DIR/large_enum_variant.rs:122:5
+   |
+LL |     B([u64; 4000]),
+   |     ^^^^^^^^^^^^^^
+
+error: aborting due to 11 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From b885035ef7c5d9e4824944e2c50035afdb2fd2f5 Mon Sep 17 00:00:00 2001
From: dswij <dswijj@gmail.com>
Date: Thu, 2 Jun 2022 20:16:46 +0800
Subject: `needless_return` checks for macro expr in return stmts

---
 clippy_lints/src/returns.rs     | 14 +++++---------
 tests/ui/needless_return.fixed  | 10 ++++++++--
 tests/ui/needless_return.rs     |  6 ++++++
 tests/ui/needless_return.stderr | 20 +++++++++++++++++++-
 4 files changed, 38 insertions(+), 12 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
index 8068fa22d9c..e525eba53e2 100644
--- a/clippy_lints/src/returns.rs
+++ b/clippy_lints/src/returns.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
-use clippy_utils::source::snippet_opt;
+use clippy_utils::source::{snippet_opt, snippet_with_context};
 use clippy_utils::{fn_def_id, path_to_local_id};
 use if_chain::if_chain;
 use rustc_ast::ast::Attribute;
@@ -226,14 +226,10 @@ fn emit_return_lint(cx: &LateContext<'_>, ret_span: Span, inner_span: Option<Spa
     }
     match inner_span {
         Some(inner_span) => {
-            if in_external_macro(cx.tcx.sess, inner_span) || inner_span.from_expansion() {
-                return;
-            }
-
+            let mut applicability = Applicability::MachineApplicable;
             span_lint_and_then(cx, NEEDLESS_RETURN, ret_span, "unneeded `return` statement", |diag| {
-                if let Some(snippet) = snippet_opt(cx, inner_span) {
-                    diag.span_suggestion(ret_span, "remove `return`", snippet, Applicability::MachineApplicable);
-                }
+                let (snippet, _) = snippet_with_context(cx, inner_span, ret_span.ctxt(), "..", &mut applicability);
+                diag.span_suggestion(ret_span, "remove `return`", snippet, applicability);
             });
         },
         None => match replacement {
@@ -287,7 +283,7 @@ struct BorrowVisitor<'a, 'tcx> {
 
 impl<'tcx> Visitor<'tcx> for BorrowVisitor<'_, 'tcx> {
     fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
-        if self.borrows {
+        if self.borrows || expr.span.from_expansion() {
             return;
         }
 
diff --git a/tests/ui/needless_return.fixed b/tests/ui/needless_return.fixed
index 603d438d558..7c828430b78 100644
--- a/tests/ui/needless_return.fixed
+++ b/tests/ui/needless_return.fixed
@@ -53,7 +53,7 @@ fn test_closure() {
 }
 
 fn test_macro_call() -> i32 {
-    return the_answer!();
+    the_answer!()
 }
 
 fn test_void_fun() {
@@ -175,7 +175,7 @@ async fn async_test_closure() {
 }
 
 async fn async_test_macro_call() -> i32 {
-    return the_answer!();
+    the_answer!()
 }
 
 async fn async_test_void_fun() {
@@ -223,4 +223,10 @@ fn let_else() {
     let Some(1) = Some(1) else { return };
 }
 
+fn needless_return_macro() -> String {
+    let _ = "foo";
+    let _ = "bar";
+    format!("Hello {}", "world!")
+}
+
 fn main() {}
diff --git a/tests/ui/needless_return.rs b/tests/ui/needless_return.rs
index c6c8cb9ec15..fe82af00e67 100644
--- a/tests/ui/needless_return.rs
+++ b/tests/ui/needless_return.rs
@@ -223,4 +223,10 @@ fn let_else() {
     let Some(1) = Some(1) else { return };
 }
 
+fn needless_return_macro() -> String {
+    let _ = "foo";
+    let _ = "bar";
+    return format!("Hello {}", "world!");
+}
+
 fn main() {}
diff --git a/tests/ui/needless_return.stderr b/tests/ui/needless_return.stderr
index 5bc787c56a6..4c8be47b025 100644
--- a/tests/ui/needless_return.stderr
+++ b/tests/ui/needless_return.stderr
@@ -48,6 +48,12 @@ error: unneeded `return` statement
 LL |     let _ = || return true;
    |                ^^^^^^^^^^^ help: remove `return`: `true`
 
+error: unneeded `return` statement
+  --> $DIR/needless_return.rs:56:5
+   |
+LL |     return the_answer!();
+   |     ^^^^^^^^^^^^^^^^^^^^^ help: remove `return`: `the_answer!()`
+
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:60:5
    |
@@ -168,6 +174,12 @@ error: unneeded `return` statement
 LL |     let _ = || return true;
    |                ^^^^^^^^^^^ help: remove `return`: `true`
 
+error: unneeded `return` statement
+  --> $DIR/needless_return.rs:178:5
+   |
+LL |     return the_answer!();
+   |     ^^^^^^^^^^^^^^^^^^^^^ help: remove `return`: `the_answer!()`
+
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:182:5
    |
@@ -204,5 +216,11 @@ error: unneeded `return` statement
 LL |         return String::new();
    |         ^^^^^^^^^^^^^^^^^^^^^ help: remove `return`: `String::new()`
 
-error: aborting due to 34 previous errors
+error: unneeded `return` statement
+  --> $DIR/needless_return.rs:229:5
+   |
+LL |     return format!("Hello {}", "world!");
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove `return`: `format!("Hello {}", "world!")`
+
+error: aborting due to 37 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 678dcdd2be649e83eb1ce766f3ba141030f69e49 Mon Sep 17 00:00:00 2001
From: dswij <dswijj@gmail.com>
Date: Thu, 2 Jun 2022 20:17:00 +0800
Subject: Apply `needless_return` suggestions

---
 clippy_lints/src/methods/option_map_or_none.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/option_map_or_none.rs b/clippy_lints/src/methods/option_map_or_none.rs
index 76bc9466ed8..8989db54f6c 100644
--- a/clippy_lints/src/methods/option_map_or_none.rs
+++ b/clippy_lints/src/methods/option_map_or_none.rs
@@ -97,7 +97,7 @@ pub(super) fn check<'tcx>(
         let func_snippet = snippet(cx, map_arg.span, "..");
         let msg = "called `map_or(None, ..)` on an `Option` value. This can be done more directly by calling \
                        `and_then(..)` instead";
-        return span_lint_and_sugg(
+        span_lint_and_sugg(
             cx,
             OPTION_MAP_OR_NONE,
             expr.span,
@@ -110,7 +110,7 @@ pub(super) fn check<'tcx>(
         let msg = "called `map_or(None, Some)` on a `Result` value. This can be done more directly by calling \
                        `ok()` instead";
         let self_snippet = snippet(cx, recv.span, "..");
-        return span_lint_and_sugg(
+        span_lint_and_sugg(
             cx,
             RESULT_MAP_OR_INTO_OPTION,
             expr.span,
-- 
cgit 1.4.1-3-g733a5


From 58cd01c2fcda07f97efcd908b50e5256cf084593 Mon Sep 17 00:00:00 2001
From: Ariel Uy <ariel.b.uy@gmail.com>
Date: Fri, 13 May 2022 23:48:52 -0700
Subject: Add new lint mismatching_type_param_order

Add new lint for checking if type parameters are consistent between type
definitions and impl blocks.
---
 CHANGELOG.md                                     |   1 +
 clippy_lints/src/lib.register_lints.rs           |   1 +
 clippy_lints/src/lib.register_pedantic.rs        |   1 +
 clippy_lints/src/lib.rs                          |   2 +
 clippy_lints/src/mismatching_type_param_order.rs | 116 +++++++++++++++++++++++
 tests/ui/mismatching_type_param_order.rs         |  60 ++++++++++++
 tests/ui/mismatching_type_param_order.stderr     |  83 ++++++++++++++++
 7 files changed, 264 insertions(+)
 create mode 100644 clippy_lints/src/mismatching_type_param_order.rs
 create mode 100644 tests/ui/mismatching_type_param_order.rs
 create mode 100644 tests/ui/mismatching_type_param_order.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 1c7ebfdf035..0a44ffdd3d4 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3560,6 +3560,7 @@ Released 2018-09-13
 [`min_max`]: https://rust-lang.github.io/rust-clippy/master/index.html#min_max
 [`misaligned_transmute`]: https://rust-lang.github.io/rust-clippy/master/index.html#misaligned_transmute
 [`mismatched_target_os`]: https://rust-lang.github.io/rust-clippy/master/index.html#mismatched_target_os
+[`mismatching_type_param_order`]: https://rust-lang.github.io/rust-clippy/master/index.html#mismatching_type_param_order
 [`misrefactored_assign_op`]: https://rust-lang.github.io/rust-clippy/master/index.html#misrefactored_assign_op
 [`missing_const_for_fn`]: https://rust-lang.github.io/rust-clippy/master/index.html#missing_const_for_fn
 [`missing_docs_in_private_items`]: https://rust-lang.github.io/rust-clippy/master/index.html#missing_docs_in_private_items
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index ea8040a319b..29bfc660d29 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -380,6 +380,7 @@ store.register_lints(&[
     misc_early::UNNEEDED_WILDCARD_PATTERN,
     misc_early::UNSEPARATED_LITERAL_SUFFIX,
     misc_early::ZERO_PREFIXED_LITERAL,
+    mismatching_type_param_order::MISMATCHING_TYPE_PARAM_ORDER,
     missing_const_for_fn::MISSING_CONST_FOR_FN,
     missing_doc::MISSING_DOCS_IN_PRIVATE_ITEMS,
     missing_enforced_import_rename::MISSING_ENFORCED_IMPORT_RENAMES,
diff --git a/clippy_lints/src/lib.register_pedantic.rs b/clippy_lints/src/lib.register_pedantic.rs
index 5684972b8be..2e47a287d5c 100644
--- a/clippy_lints/src/lib.register_pedantic.rs
+++ b/clippy_lints/src/lib.register_pedantic.rs
@@ -67,6 +67,7 @@ store.register_group(true, "clippy::pedantic", Some("clippy_pedantic"), vec![
     LintId::of(methods::UNNECESSARY_JOIN),
     LintId::of(misc::FLOAT_CMP),
     LintId::of(misc::USED_UNDERSCORE_BINDING),
+    LintId::of(mismatching_type_param_order::MISMATCHING_TYPE_PARAM_ORDER),
     LintId::of(mut_mut::MUT_MUT),
     LintId::of(needless_bitwise_bool::NEEDLESS_BITWISE_BOOL),
     LintId::of(needless_continue::NEEDLESS_CONTINUE),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 89b65ce5469..6c3d7594f5c 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -298,6 +298,7 @@ mod methods;
 mod minmax;
 mod misc;
 mod misc_early;
+mod mismatching_type_param_order;
 mod missing_const_for_fn;
 mod missing_doc;
 mod missing_enforced_import_rename;
@@ -917,6 +918,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_early_pass(|| Box::new(unused_rounding::UnusedRounding));
     store.register_early_pass(move || Box::new(almost_complete_letter_range::AlmostCompleteLetterRange::new(msrv)));
     store.register_late_pass(|| Box::new(swap_ptr_to_ref::SwapPtrToRef));
+    store.register_late_pass(|| Box::new(mismatching_type_param_order::TypeParamMismatch));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/mismatching_type_param_order.rs b/clippy_lints/src/mismatching_type_param_order.rs
new file mode 100644
index 00000000000..d466d54a6ba
--- /dev/null
+++ b/clippy_lints/src/mismatching_type_param_order.rs
@@ -0,0 +1,116 @@
+use clippy_utils::diagnostics::span_lint_and_help;
+use rustc_data_structures::fx::FxHashMap;
+use rustc_hir::def::{DefKind, Res};
+use rustc_hir::{GenericArg, Item, ItemKind, QPath, Ty, TyKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::GenericParamDefKind;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for type parameters which are positioned inconsistently between
+    /// a type definition and impl block. Specifically, a paramater in an impl
+    /// block which has the same name as a parameter in the type def, but is in
+    /// a different place.
+    ///
+    /// ### Why is this bad?
+    /// Type parameters are determined by their position rather than name.
+    /// Naming type parameters inconsistently may cause you to refer to the
+    /// wrong type parameter.
+    ///
+    /// ### Example
+    /// ```rust
+    /// struct Foo<A, B> {
+    ///     x: A,
+    ///     y: B,
+    /// }
+    /// // inside the impl, B refers to Foo::A
+    /// impl<B, A> Foo<B, A> {}
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// struct Foo<A, B> {
+    ///     x: A,
+    ///     y: B,
+    /// }
+    /// impl<A, B> Foo<A, B> {}
+    /// ```
+    #[clippy::version = "1.62.0"]
+    pub MISMATCHING_TYPE_PARAM_ORDER,
+    pedantic,
+    "type parameter positioned inconsistently between type def and impl block"
+}
+declare_lint_pass!(TypeParamMismatch => [MISMATCHING_TYPE_PARAM_ORDER]);
+
+impl<'tcx> LateLintPass<'tcx> for TypeParamMismatch {
+    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
+        if_chain! {
+            if !item.span.from_expansion();
+            if let ItemKind::Impl(imp) = &item.kind;
+            if let TyKind::Path(QPath::Resolved(_, path)) = &imp.self_ty.kind;
+            if let Some(segment) = path.segments.iter().next();
+            if let Some(generic_args) = segment.args;
+            if !generic_args.args.is_empty();
+            then {
+                // get the name and span of the generic parameters in the Impl
+                let impl_params = generic_args.args.iter()
+                .filter_map(|p|
+                    match p {
+                        GenericArg::Type(Ty {kind: TyKind::Path(QPath::Resolved(_, path)), ..}) =>
+                            Some((path.segments[0].ident.to_string(), path.span)),
+                        _ => None,
+                    }
+                );
+
+                // find the type that the Impl is for
+                // only lint on struct/enum/union for now
+                let defid = match path.res {
+                    Res::Def(DefKind::Struct | DefKind::Enum | DefKind::Union, defid) => defid,
+                    _ => return,
+                };
+
+                // get the names of the generic parameters in the type
+                let type_params = &cx.tcx.generics_of(defid).params;
+                let type_param_names: Vec<_> = type_params.iter()
+                .filter_map(|p|
+                    match p.kind {
+                        GenericParamDefKind::Type {..} => Some(p.name.to_string()),
+                        _ => None,
+                    }
+                ).collect();
+                // hashmap of name -> index for mismatch_param_name
+                let type_param_names_hashmap: FxHashMap<&String, usize> =
+                    type_param_names.iter().enumerate().map(|(i, param)| (param, i)).collect();
+
+                let type_name = segment.ident;
+                for (i, (impl_param_name, impl_param_span)) in impl_params.enumerate() {
+                    if mismatch_param_name(i, &impl_param_name, &type_param_names_hashmap) {
+                        let msg = format!("`{}` has a similarly named generic type parameter `{}` in its declaration, but in a different order",
+                                          type_name, impl_param_name);
+                        let help = format!("try `{}`, or a name that does not conflict with `{}`'s generic params",
+                                           type_param_names[i], type_name);
+                        span_lint_and_help(
+                            cx,
+                            MISMATCHING_TYPE_PARAM_ORDER,
+                            impl_param_span,
+                            &msg,
+                            None,
+                            &help
+                        );
+                    }
+                }
+            }
+        }
+    }
+}
+
+// Checks if impl_param_name is the same as one of type_param_names,
+// and is in a different position
+fn mismatch_param_name(i: usize, impl_param_name: &String, type_param_names: &FxHashMap<&String, usize>) -> bool {
+    if let Some(j) = type_param_names.get(impl_param_name) {
+        if i != *j {
+            return true;
+        }
+    }
+    false
+}
diff --git a/tests/ui/mismatching_type_param_order.rs b/tests/ui/mismatching_type_param_order.rs
new file mode 100644
index 00000000000..8f286c9304c
--- /dev/null
+++ b/tests/ui/mismatching_type_param_order.rs
@@ -0,0 +1,60 @@
+#![warn(clippy::mismatching_type_param_order)]
+#![allow(clippy::blacklisted_name)]
+
+fn main() {
+    struct Foo<A, B> {
+        x: A,
+        y: B,
+    }
+
+    // lint on both params
+    impl<B, A> Foo<B, A> {}
+
+    // lint on the 2nd param
+    impl<C, A> Foo<C, A> {}
+
+    // should not lint
+    impl<A, B> Foo<A, B> {}
+
+    struct FooLifetime<'l, 'm, A, B> {
+        x: &'l A,
+        y: &'m B,
+    }
+
+    // should not lint on lifetimes
+    impl<'m, 'l, B, A> FooLifetime<'m, 'l, B, A> {}
+
+    struct Bar {
+        x: i32,
+    }
+
+    // should not lint
+    impl Bar {}
+
+    // also works for enums
+    enum FooEnum<A, B, C> {
+        X(A),
+        Y(B),
+        Z(C),
+    }
+
+    impl<C, A, B> FooEnum<C, A, B> {}
+
+    // also works for unions
+    union FooUnion<A: Copy, B>
+    where
+        B: Copy,
+    {
+        x: A,
+        y: B,
+    }
+
+    impl<B: Copy, A> FooUnion<B, A> where A: Copy {}
+
+    impl<A, B> FooUnion<A, B>
+    where
+        A: Copy,
+        B: Copy,
+    {
+    }
+}
diff --git a/tests/ui/mismatching_type_param_order.stderr b/tests/ui/mismatching_type_param_order.stderr
new file mode 100644
index 00000000000..cb720256c50
--- /dev/null
+++ b/tests/ui/mismatching_type_param_order.stderr
@@ -0,0 +1,83 @@
+error: `Foo` has a similarly named generic type parameter `B` in its declaration, but in a different order
+  --> $DIR/mismatching_type_param_order.rs:11:20
+   |
+LL |     impl<B, A> Foo<B, A> {}
+   |                    ^
+   |
+   = note: `-D clippy::mismatching-type-param-order` implied by `-D warnings`
+   = help: try `A`, or a name that does not conflict with `Foo`'s generic params
+
+error: `Foo` has a similarly named generic type parameter `A` in its declaration, but in a different order
+  --> $DIR/mismatching_type_param_order.rs:11:23
+   |
+LL |     impl<B, A> Foo<B, A> {}
+   |                       ^
+   |
+   = help: try `B`, or a name that does not conflict with `Foo`'s generic params
+
+error: `Foo` has a similarly named generic type parameter `A` in its declaration, but in a different order
+  --> $DIR/mismatching_type_param_order.rs:14:23
+   |
+LL |     impl<C, A> Foo<C, A> {}
+   |                       ^
+   |
+   = help: try `B`, or a name that does not conflict with `Foo`'s generic params
+
+error: `FooLifetime` has a similarly named generic type parameter `B` in its declaration, but in a different order
+  --> $DIR/mismatching_type_param_order.rs:25:44
+   |
+LL |     impl<'m, 'l, B, A> FooLifetime<'m, 'l, B, A> {}
+   |                                            ^
+   |
+   = help: try `A`, or a name that does not conflict with `FooLifetime`'s generic params
+
+error: `FooLifetime` has a similarly named generic type parameter `A` in its declaration, but in a different order
+  --> $DIR/mismatching_type_param_order.rs:25:47
+   |
+LL |     impl<'m, 'l, B, A> FooLifetime<'m, 'l, B, A> {}
+   |                                               ^
+   |
+   = help: try `B`, or a name that does not conflict with `FooLifetime`'s generic params
+
+error: `FooEnum` has a similarly named generic type parameter `C` in its declaration, but in a different order
+  --> $DIR/mismatching_type_param_order.rs:41:27
+   |
+LL |     impl<C, A, B> FooEnum<C, A, B> {}
+   |                           ^
+   |
+   = help: try `A`, or a name that does not conflict with `FooEnum`'s generic params
+
+error: `FooEnum` has a similarly named generic type parameter `A` in its declaration, but in a different order
+  --> $DIR/mismatching_type_param_order.rs:41:30
+   |
+LL |     impl<C, A, B> FooEnum<C, A, B> {}
+   |                              ^
+   |
+   = help: try `B`, or a name that does not conflict with `FooEnum`'s generic params
+
+error: `FooEnum` has a similarly named generic type parameter `B` in its declaration, but in a different order
+  --> $DIR/mismatching_type_param_order.rs:41:33
+   |
+LL |     impl<C, A, B> FooEnum<C, A, B> {}
+   |                                 ^
+   |
+   = help: try `C`, or a name that does not conflict with `FooEnum`'s generic params
+
+error: `FooUnion` has a similarly named generic type parameter `B` in its declaration, but in a different order
+  --> $DIR/mismatching_type_param_order.rs:52:31
+   |
+LL |     impl<B: Copy, A> FooUnion<B, A> where A: Copy {}
+   |                               ^
+   |
+   = help: try `A`, or a name that does not conflict with `FooUnion`'s generic params
+
+error: `FooUnion` has a similarly named generic type parameter `A` in its declaration, but in a different order
+  --> $DIR/mismatching_type_param_order.rs:52:34
+   |
+LL |     impl<B: Copy, A> FooUnion<B, A> where A: Copy {}
+   |                                  ^
+   |
+   = help: try `B`, or a name that does not conflict with `FooUnion`'s generic params
+
+error: aborting due to 10 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 64fe4e32db8c593d625a44063fca1755bba493ee Mon Sep 17 00:00:00 2001
From: DevAccentor <dev.accentor@gmail.com>
Date: Fri, 3 Jun 2022 15:59:26 +0200
Subject: add as_underscore lint

---
 CHANGELOG.md                                 |  1 +
 clippy_lints/src/as_underscore.rs            | 74 ++++++++++++++++++++++++++++
 clippy_lints/src/lib.register_lints.rs       |  1 +
 clippy_lints/src/lib.register_restriction.rs |  1 +
 clippy_lints/src/lib.rs                      |  2 +
 tests/ui/as_underscore.fixed                 | 13 +++++
 tests/ui/as_underscore.rs                    | 13 +++++
 tests/ui/as_underscore.stderr                | 20 ++++++++
 8 files changed, 125 insertions(+)
 create mode 100644 clippy_lints/src/as_underscore.rs
 create mode 100644 tests/ui/as_underscore.fixed
 create mode 100644 tests/ui/as_underscore.rs
 create mode 100644 tests/ui/as_underscore.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 0a44ffdd3d4..6ef338b819d 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3280,6 +3280,7 @@ Released 2018-09-13
 [`almost_swapped`]: https://rust-lang.github.io/rust-clippy/master/index.html#almost_swapped
 [`approx_constant`]: https://rust-lang.github.io/rust-clippy/master/index.html#approx_constant
 [`as_conversions`]: https://rust-lang.github.io/rust-clippy/master/index.html#as_conversions
+[`as_underscore`]: https://rust-lang.github.io/rust-clippy/master/index.html#as_underscore
 [`assertions_on_constants`]: https://rust-lang.github.io/rust-clippy/master/index.html#assertions_on_constants
 [`assign_op_pattern`]: https://rust-lang.github.io/rust-clippy/master/index.html#assign_op_pattern
 [`assign_ops`]: https://rust-lang.github.io/rust-clippy/master/index.html#assign_ops
diff --git a/clippy_lints/src/as_underscore.rs b/clippy_lints/src/as_underscore.rs
new file mode 100644
index 00000000000..464be4218dd
--- /dev/null
+++ b/clippy_lints/src/as_underscore.rs
@@ -0,0 +1,74 @@
+use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_then};
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind, TyKind};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_middle::lint::in_external_macro;
+use rustc_middle::ty;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Check for the usage of `as _` conversion using inferred type.
+    ///
+    /// ### Why is this bad?
+    /// The conversion might include lossy conversion and dangerous cast that might go
+    /// undetected du to the type being inferred.
+    ///
+    /// The lint is allowed by default as using `_` is less wordy than always specifying the type.
+    ///
+    /// ### Example
+    /// ```rust
+    /// fn foo(n: usize) {}
+    /// let n: u16 = 256;
+    /// foo(n as _);
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// fn foo(n: usize) {}
+    /// let n: u16 = 256;
+    /// foo(n as usize);
+    /// ```
+    #[clippy::version = "1.63.0"]
+    pub AS_UNDERSCORE,
+    restriction,
+    "detects `as _` conversion"
+}
+declare_lint_pass!(AsUnderscore => [AS_UNDERSCORE]);
+
+impl<'tcx> LateLintPass<'tcx> for AsUnderscore {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &Expr<'tcx>) {
+        if in_external_macro(cx.sess(), expr.span) {
+            return;
+        }
+
+        if let ExprKind::Cast(_, ty) = expr.kind && let TyKind::Infer = ty.kind {
+
+            let ty_resolved = cx.typeck_results().expr_ty(expr);
+            if let ty::Error(_) = ty_resolved.kind() {
+                span_lint_and_help(
+                    cx,
+                AS_UNDERSCORE,
+                expr.span,
+                "using `as _` conversion",
+                None,
+                "consider giving the type explicitly",
+                );
+            } else {
+            span_lint_and_then(
+                cx,
+                AS_UNDERSCORE,
+                expr.span,
+                "using `as _` conversion",
+                |diag| {
+                    diag.span_suggestion(
+                        ty.span,
+                        "consider giving the type explicitly",
+                        format!("{}", ty_resolved),
+                        Applicability::MachineApplicable,
+                    );
+            }
+            );
+        }
+        }
+    }
+}
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 29bfc660d29..f2e0083dea6 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -37,6 +37,7 @@ store.register_lints(&[
     almost_complete_letter_range::ALMOST_COMPLETE_LETTER_RANGE,
     approx_const::APPROX_CONSTANT,
     as_conversions::AS_CONVERSIONS,
+    as_underscore::AS_UNDERSCORE,
     asm_syntax::INLINE_ASM_X86_ATT_SYNTAX,
     asm_syntax::INLINE_ASM_X86_INTEL_SYNTAX,
     assertions_on_constants::ASSERTIONS_ON_CONSTANTS,
diff --git a/clippy_lints/src/lib.register_restriction.rs b/clippy_lints/src/lib.register_restriction.rs
index 304b595541a..aaa83402ccc 100644
--- a/clippy_lints/src/lib.register_restriction.rs
+++ b/clippy_lints/src/lib.register_restriction.rs
@@ -4,6 +4,7 @@
 
 store.register_group(true, "clippy::restriction", Some("clippy_restriction"), vec![
     LintId::of(as_conversions::AS_CONVERSIONS),
+    LintId::of(as_underscore::AS_UNDERSCORE),
     LintId::of(asm_syntax::INLINE_ASM_X86_ATT_SYNTAX),
     LintId::of(asm_syntax::INLINE_ASM_X86_INTEL_SYNTAX),
     LintId::of(attrs::ALLOW_ATTRIBUTES_WITHOUT_REASON),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 6c3d7594f5c..235a998f753 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -171,6 +171,7 @@ mod absurd_extreme_comparisons;
 mod almost_complete_letter_range;
 mod approx_const;
 mod as_conversions;
+mod as_underscore;
 mod asm_syntax;
 mod assertions_on_constants;
 mod assign_ops;
@@ -919,6 +920,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_early_pass(move || Box::new(almost_complete_letter_range::AlmostCompleteLetterRange::new(msrv)));
     store.register_late_pass(|| Box::new(swap_ptr_to_ref::SwapPtrToRef));
     store.register_late_pass(|| Box::new(mismatching_type_param_order::TypeParamMismatch));
+    store.register_late_pass(|| Box::new(as_underscore::AsUnderscore));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/tests/ui/as_underscore.fixed b/tests/ui/as_underscore.fixed
new file mode 100644
index 00000000000..948f6d8e6b1
--- /dev/null
+++ b/tests/ui/as_underscore.fixed
@@ -0,0 +1,13 @@
+// run-rustfix
+
+#![warn(clippy::as_underscore)]
+
+fn foo(_n: usize) {}
+
+fn main() {
+    let n: u16 = 256;
+    foo(n as usize);
+
+    let n = 0_u128;
+    let _n: u8 = n as u8;
+}
diff --git a/tests/ui/as_underscore.rs b/tests/ui/as_underscore.rs
new file mode 100644
index 00000000000..97785ed08a8
--- /dev/null
+++ b/tests/ui/as_underscore.rs
@@ -0,0 +1,13 @@
+// run-rustfix
+
+#![warn(clippy::as_underscore)]
+
+fn foo(_n: usize) {}
+
+fn main() {
+    let n: u16 = 256;
+    foo(n as _);
+
+    let n = 0_u128;
+    let _n: u8 = n as _;
+}
diff --git a/tests/ui/as_underscore.stderr b/tests/ui/as_underscore.stderr
new file mode 100644
index 00000000000..d7cd58d965a
--- /dev/null
+++ b/tests/ui/as_underscore.stderr
@@ -0,0 +1,20 @@
+error: using `as _` conversion
+  --> $DIR/as_underscore.rs:9:9
+   |
+LL |     foo(n as _);
+   |         ^^^^^-
+   |              |
+   |              help: consider giving the type explicitly: `usize`
+   |
+   = note: `-D clippy::as-underscore` implied by `-D warnings`
+
+error: using `as _` conversion
+  --> $DIR/as_underscore.rs:12:18
+   |
+LL |     let _n: u8 = n as _;
+   |                  ^^^^^-
+   |                       |
+   |                       help: consider giving the type explicitly: `u8`
+
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 81e44502ac2e86258dbc880bdf702eab0030c4fb Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Fri, 3 Jun 2022 12:14:24 -0400
Subject: Merge `CollapsibleMatch` into `Matches` lint pass

---
 clippy_lints/src/collapsible_match.rs              | 183 ---------------------
 clippy_lints/src/lib.register_all.rs               |   2 +-
 clippy_lints/src/lib.register_lints.rs             |   2 +-
 clippy_lints/src/lib.register_style.rs             |   2 +-
 clippy_lints/src/lib.rs                            |   2 -
 clippy_lints/src/matches/collapsible_match.rs      | 143 ++++++++++++++++
 clippy_lints/src/matches/match_like_matches.rs     |  34 ++--
 clippy_lints/src/matches/mod.rs                    |  90 ++++++++--
 clippy_lints/src/matches/needless_match.rs         |  30 ++--
 .../src/matches/redundant_pattern_match.rs         |  20 ++-
 10 files changed, 267 insertions(+), 241 deletions(-)
 delete mode 100644 clippy_lints/src/collapsible_match.rs
 create mode 100644 clippy_lints/src/matches/collapsible_match.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/collapsible_match.rs b/clippy_lints/src/collapsible_match.rs
deleted file mode 100644
index ec55009f347..00000000000
--- a/clippy_lints/src/collapsible_match.rs
+++ /dev/null
@@ -1,183 +0,0 @@
-use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::higher::IfLetOrMatch;
-use clippy_utils::visitors::is_local_used;
-use clippy_utils::{is_lang_ctor, is_unit_expr, path_to_local, peel_blocks_with_stmt, peel_ref_operators, SpanlessEq};
-use if_chain::if_chain;
-use rustc_errors::MultiSpan;
-use rustc_hir::LangItem::OptionNone;
-use rustc_hir::{Arm, Expr, Guard, HirId, Let, Pat, PatKind};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::Span;
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Finds nested `match` or `if let` expressions where the patterns may be "collapsed" together
-    /// without adding any branches.
-    ///
-    /// Note that this lint is not intended to find _all_ cases where nested match patterns can be merged, but only
-    /// cases where merging would most likely make the code more readable.
-    ///
-    /// ### Why is this bad?
-    /// It is unnecessarily verbose and complex.
-    ///
-    /// ### Example
-    /// ```rust
-    /// fn func(opt: Option<Result<u64, String>>) {
-    ///     let n = match opt {
-    ///         Some(n) => match n {
-    ///             Ok(n) => n,
-    ///             _ => return,
-    ///         }
-    ///         None => return,
-    ///     };
-    /// }
-    /// ```
-    /// Use instead:
-    /// ```rust
-    /// fn func(opt: Option<Result<u64, String>>) {
-    ///     let n = match opt {
-    ///         Some(Ok(n)) => n,
-    ///         _ => return,
-    ///     };
-    /// }
-    /// ```
-    #[clippy::version = "1.50.0"]
-    pub COLLAPSIBLE_MATCH,
-    style,
-    "Nested `match` or `if let` expressions where the patterns may be \"collapsed\" together."
-}
-
-declare_lint_pass!(CollapsibleMatch => [COLLAPSIBLE_MATCH]);
-
-impl<'tcx> LateLintPass<'tcx> for CollapsibleMatch {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &Expr<'tcx>) {
-        match IfLetOrMatch::parse(cx, expr) {
-            Some(IfLetOrMatch::Match(_, arms, _)) => {
-                if let Some(els_arm) = arms.iter().rfind(|arm| arm_is_wild_like(cx, arm)) {
-                    for arm in arms {
-                        check_arm(cx, true, arm.pat, arm.body, arm.guard.as_ref(), Some(els_arm.body));
-                    }
-                }
-            },
-            Some(IfLetOrMatch::IfLet(_, pat, body, els)) => {
-                check_arm(cx, false, pat, body, None, els);
-            },
-            None => {},
-        }
-    }
-}
-
-fn check_arm<'tcx>(
-    cx: &LateContext<'tcx>,
-    outer_is_match: bool,
-    outer_pat: &'tcx Pat<'tcx>,
-    outer_then_body: &'tcx Expr<'tcx>,
-    outer_guard: Option<&'tcx Guard<'tcx>>,
-    outer_else_body: Option<&'tcx Expr<'tcx>>,
-) {
-    let inner_expr = peel_blocks_with_stmt(outer_then_body);
-    if_chain! {
-        if let Some(inner) = IfLetOrMatch::parse(cx, inner_expr);
-        if let Some((inner_scrutinee, inner_then_pat, inner_else_body)) = match inner {
-            IfLetOrMatch::IfLet(scrutinee, pat, _, els) => Some((scrutinee, pat, els)),
-            IfLetOrMatch::Match(scrutinee, arms, ..) => if_chain! {
-                // if there are more than two arms, collapsing would be non-trivial
-                if arms.len() == 2 && arms.iter().all(|a| a.guard.is_none());
-                // one of the arms must be "wild-like"
-                if let Some(wild_idx) = arms.iter().rposition(|a| arm_is_wild_like(cx, a));
-                then {
-                    let (then, els) = (&arms[1 - wild_idx], &arms[wild_idx]);
-                    Some((scrutinee, then.pat, Some(els.body)))
-                } else {
-                    None
-                }
-            },
-        };
-        if outer_pat.span.ctxt() == inner_scrutinee.span.ctxt();
-        // match expression must be a local binding
-        // match <local> { .. }
-        if let Some(binding_id) = path_to_local(peel_ref_operators(cx, inner_scrutinee));
-        if !pat_contains_or(inner_then_pat);
-        // the binding must come from the pattern of the containing match arm
-        // ..<local>.. => match <local> { .. }
-        if let Some(binding_span) = find_pat_binding(outer_pat, binding_id);
-        // the "else" branches must be equal
-        if match (outer_else_body, inner_else_body) {
-            (None, None) => true,
-            (None, Some(e)) | (Some(e), None) => is_unit_expr(e),
-            (Some(a), Some(b)) => SpanlessEq::new(cx).eq_expr(a, b),
-        };
-        // the binding must not be used in the if guard
-        if outer_guard.map_or(
-            true,
-            |(Guard::If(e) | Guard::IfLet(Let { init: e, .. }))| !is_local_used(cx, *e, binding_id)
-        );
-        // ...or anywhere in the inner expression
-        if match inner {
-            IfLetOrMatch::IfLet(_, _, body, els) => {
-                !is_local_used(cx, body, binding_id) && els.map_or(true, |e| !is_local_used(cx, e, binding_id))
-            },
-            IfLetOrMatch::Match(_, arms, ..) => !arms.iter().any(|arm| is_local_used(cx, arm, binding_id)),
-        };
-        then {
-            let msg = format!(
-                "this `{}` can be collapsed into the outer `{}`",
-                if matches!(inner, IfLetOrMatch::Match(..)) { "match" } else { "if let" },
-                if outer_is_match { "match" } else { "if let" },
-            );
-            span_lint_and_then(
-                cx,
-                COLLAPSIBLE_MATCH,
-                inner_expr.span,
-                &msg,
-                |diag| {
-                    let mut help_span = MultiSpan::from_spans(vec![binding_span, inner_then_pat.span]);
-                    help_span.push_span_label(binding_span, "replace this binding");
-                    help_span.push_span_label(inner_then_pat.span, "with this pattern");
-                    diag.span_help(help_span, "the outer pattern can be modified to include the inner pattern");
-                },
-            );
-        }
-    }
-}
-
-/// A "wild-like" arm has a wild (`_`) or `None` pattern and no guard. Such arms can be "collapsed"
-/// into a single wild arm without any significant loss in semantics or readability.
-fn arm_is_wild_like(cx: &LateContext<'_>, arm: &Arm<'_>) -> bool {
-    if arm.guard.is_some() {
-        return false;
-    }
-    match arm.pat.kind {
-        PatKind::Binding(..) | PatKind::Wild => true,
-        PatKind::Path(ref qpath) => is_lang_ctor(cx, qpath, OptionNone),
-        _ => false,
-    }
-}
-
-fn find_pat_binding(pat: &Pat<'_>, hir_id: HirId) -> Option<Span> {
-    let mut span = None;
-    pat.walk_short(|p| match &p.kind {
-        // ignore OR patterns
-        PatKind::Or(_) => false,
-        PatKind::Binding(_bm, _, _ident, _) => {
-            let found = p.hir_id == hir_id;
-            if found {
-                span = Some(p.span);
-            }
-            !found
-        },
-        _ => true,
-    });
-    span
-}
-
-fn pat_contains_or(pat: &Pat<'_>) -> bool {
-    let mut result = false;
-    pat.walk(|p| {
-        let is_or = matches!(p.kind, PatKind::Or(_));
-        result |= is_or;
-        !is_or
-    });
-    result
-}
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 51b3babef7f..b1da36a0d40 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -38,7 +38,6 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(casts::UNNECESSARY_CAST),
     LintId::of(collapsible_if::COLLAPSIBLE_ELSE_IF),
     LintId::of(collapsible_if::COLLAPSIBLE_IF),
-    LintId::of(collapsible_match::COLLAPSIBLE_MATCH),
     LintId::of(comparison_chain::COMPARISON_CHAIN),
     LintId::of(copies::IFS_SAME_COND),
     LintId::of(copies::IF_SAME_THEN_ELSE),
@@ -143,6 +142,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(map_unit_fn::RESULT_MAP_UNIT_FN),
     LintId::of(match_result_ok::MATCH_RESULT_OK),
     LintId::of(match_str_case_mismatch::MATCH_STR_CASE_MISMATCH),
+    LintId::of(matches::COLLAPSIBLE_MATCH),
     LintId::of(matches::INFALLIBLE_DESTRUCTURING_MATCH),
     LintId::of(matches::MATCH_AS_REF),
     LintId::of(matches::MATCH_LIKE_MATCHES_MACRO),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 29bfc660d29..58e18b710ea 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -93,7 +93,6 @@ store.register_lints(&[
     cognitive_complexity::COGNITIVE_COMPLEXITY,
     collapsible_if::COLLAPSIBLE_ELSE_IF,
     collapsible_if::COLLAPSIBLE_IF,
-    collapsible_match::COLLAPSIBLE_MATCH,
     comparison_chain::COMPARISON_CHAIN,
     copies::BRANCHES_SHARING_CODE,
     copies::IFS_SAME_COND,
@@ -263,6 +262,7 @@ store.register_lints(&[
     match_on_vec_items::MATCH_ON_VEC_ITEMS,
     match_result_ok::MATCH_RESULT_OK,
     match_str_case_mismatch::MATCH_STR_CASE_MISMATCH,
+    matches::COLLAPSIBLE_MATCH,
     matches::INFALLIBLE_DESTRUCTURING_MATCH,
     matches::MATCH_AS_REF,
     matches::MATCH_BOOL,
diff --git a/clippy_lints/src/lib.register_style.rs b/clippy_lints/src/lib.register_style.rs
index ea2e1082458..07e90b8b656 100644
--- a/clippy_lints/src/lib.register_style.rs
+++ b/clippy_lints/src/lib.register_style.rs
@@ -12,7 +12,6 @@ store.register_group(true, "clippy::style", Some("clippy_style"), vec![
     LintId::of(casts::FN_TO_NUMERIC_CAST_WITH_TRUNCATION),
     LintId::of(collapsible_if::COLLAPSIBLE_ELSE_IF),
     LintId::of(collapsible_if::COLLAPSIBLE_IF),
-    LintId::of(collapsible_match::COLLAPSIBLE_MATCH),
     LintId::of(comparison_chain::COMPARISON_CHAIN),
     LintId::of(default::FIELD_REASSIGN_WITH_DEFAULT),
     LintId::of(dereference::NEEDLESS_BORROW),
@@ -50,6 +49,7 @@ store.register_group(true, "clippy::style", Some("clippy_style"), vec![
     LintId::of(manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE),
     LintId::of(map_clone::MAP_CLONE),
     LintId::of(match_result_ok::MATCH_RESULT_OK),
+    LintId::of(matches::COLLAPSIBLE_MATCH),
     LintId::of(matches::INFALLIBLE_DESTRUCTURING_MATCH),
     LintId::of(matches::MATCH_LIKE_MATCHES_MACRO),
     LintId::of(matches::MATCH_OVERLAPPING_ARM),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 6c3d7594f5c..6e16d470ac8 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -192,7 +192,6 @@ mod casts;
 mod checked_conversions;
 mod cognitive_complexity;
 mod collapsible_if;
-mod collapsible_match;
 mod comparison_chain;
 mod copies;
 mod copy_iterator;
@@ -568,7 +567,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(len_zero::LenZero));
     store.register_late_pass(|| Box::new(attrs::Attributes));
     store.register_late_pass(|| Box::new(blocks_in_if_conditions::BlocksInIfConditions));
-    store.register_late_pass(|| Box::new(collapsible_match::CollapsibleMatch));
     store.register_late_pass(|| Box::new(unicode::Unicode));
     store.register_late_pass(|| Box::new(uninit_vec::UninitVec));
     store.register_late_pass(|| Box::new(unit_hash::UnitHash));
diff --git a/clippy_lints/src/matches/collapsible_match.rs b/clippy_lints/src/matches/collapsible_match.rs
new file mode 100644
index 00000000000..07021f1bcad
--- /dev/null
+++ b/clippy_lints/src/matches/collapsible_match.rs
@@ -0,0 +1,143 @@
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::higher::IfLetOrMatch;
+use clippy_utils::visitors::is_local_used;
+use clippy_utils::{is_lang_ctor, is_unit_expr, path_to_local, peel_blocks_with_stmt, peel_ref_operators, SpanlessEq};
+use if_chain::if_chain;
+use rustc_errors::MultiSpan;
+use rustc_hir::LangItem::OptionNone;
+use rustc_hir::{Arm, Expr, Guard, HirId, Let, Pat, PatKind};
+use rustc_lint::LateContext;
+use rustc_span::Span;
+
+use super::COLLAPSIBLE_MATCH;
+
+pub(super) fn check_match<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>]) {
+    if let Some(els_arm) = arms.iter().rfind(|arm| arm_is_wild_like(cx, arm)) {
+        for arm in arms {
+            check_arm(cx, true, arm.pat, arm.body, arm.guard.as_ref(), Some(els_arm.body));
+        }
+    }
+}
+
+pub(super) fn check_if_let<'tcx>(
+    cx: &LateContext<'tcx>,
+    pat: &'tcx Pat<'_>,
+    body: &'tcx Expr<'_>,
+    else_expr: Option<&'tcx Expr<'_>>,
+) {
+    check_arm(cx, false, pat, body, None, else_expr);
+}
+
+fn check_arm<'tcx>(
+    cx: &LateContext<'tcx>,
+    outer_is_match: bool,
+    outer_pat: &'tcx Pat<'tcx>,
+    outer_then_body: &'tcx Expr<'tcx>,
+    outer_guard: Option<&'tcx Guard<'tcx>>,
+    outer_else_body: Option<&'tcx Expr<'tcx>>,
+) {
+    let inner_expr = peel_blocks_with_stmt(outer_then_body);
+    if_chain! {
+        if let Some(inner) = IfLetOrMatch::parse(cx, inner_expr);
+        if let Some((inner_scrutinee, inner_then_pat, inner_else_body)) = match inner {
+            IfLetOrMatch::IfLet(scrutinee, pat, _, els) => Some((scrutinee, pat, els)),
+            IfLetOrMatch::Match(scrutinee, arms, ..) => if_chain! {
+                // if there are more than two arms, collapsing would be non-trivial
+                if arms.len() == 2 && arms.iter().all(|a| a.guard.is_none());
+                // one of the arms must be "wild-like"
+                if let Some(wild_idx) = arms.iter().rposition(|a| arm_is_wild_like(cx, a));
+                then {
+                    let (then, els) = (&arms[1 - wild_idx], &arms[wild_idx]);
+                    Some((scrutinee, then.pat, Some(els.body)))
+                } else {
+                    None
+                }
+            },
+        };
+        if outer_pat.span.ctxt() == inner_scrutinee.span.ctxt();
+        // match expression must be a local binding
+        // match <local> { .. }
+        if let Some(binding_id) = path_to_local(peel_ref_operators(cx, inner_scrutinee));
+        if !pat_contains_or(inner_then_pat);
+        // the binding must come from the pattern of the containing match arm
+        // ..<local>.. => match <local> { .. }
+        if let Some(binding_span) = find_pat_binding(outer_pat, binding_id);
+        // the "else" branches must be equal
+        if match (outer_else_body, inner_else_body) {
+            (None, None) => true,
+            (None, Some(e)) | (Some(e), None) => is_unit_expr(e),
+            (Some(a), Some(b)) => SpanlessEq::new(cx).eq_expr(a, b),
+        };
+        // the binding must not be used in the if guard
+        if outer_guard.map_or(
+            true,
+            |(Guard::If(e) | Guard::IfLet(Let { init: e, .. }))| !is_local_used(cx, *e, binding_id)
+        );
+        // ...or anywhere in the inner expression
+        if match inner {
+            IfLetOrMatch::IfLet(_, _, body, els) => {
+                !is_local_used(cx, body, binding_id) && els.map_or(true, |e| !is_local_used(cx, e, binding_id))
+            },
+            IfLetOrMatch::Match(_, arms, ..) => !arms.iter().any(|arm| is_local_used(cx, arm, binding_id)),
+        };
+        then {
+            let msg = format!(
+                "this `{}` can be collapsed into the outer `{}`",
+                if matches!(inner, IfLetOrMatch::Match(..)) { "match" } else { "if let" },
+                if outer_is_match { "match" } else { "if let" },
+            );
+            span_lint_and_then(
+                cx,
+                COLLAPSIBLE_MATCH,
+                inner_expr.span,
+                &msg,
+                |diag| {
+                    let mut help_span = MultiSpan::from_spans(vec![binding_span, inner_then_pat.span]);
+                    help_span.push_span_label(binding_span, "replace this binding");
+                    help_span.push_span_label(inner_then_pat.span, "with this pattern");
+                    diag.span_help(help_span, "the outer pattern can be modified to include the inner pattern");
+                },
+            );
+        }
+    }
+}
+
+/// A "wild-like" arm has a wild (`_`) or `None` pattern and no guard. Such arms can be "collapsed"
+/// into a single wild arm without any significant loss in semantics or readability.
+fn arm_is_wild_like(cx: &LateContext<'_>, arm: &Arm<'_>) -> bool {
+    if arm.guard.is_some() {
+        return false;
+    }
+    match arm.pat.kind {
+        PatKind::Binding(..) | PatKind::Wild => true,
+        PatKind::Path(ref qpath) => is_lang_ctor(cx, qpath, OptionNone),
+        _ => false,
+    }
+}
+
+fn find_pat_binding(pat: &Pat<'_>, hir_id: HirId) -> Option<Span> {
+    let mut span = None;
+    pat.walk_short(|p| match &p.kind {
+        // ignore OR patterns
+        PatKind::Or(_) => false,
+        PatKind::Binding(_bm, _, _ident, _) => {
+            let found = p.hir_id == hir_id;
+            if found {
+                span = Some(p.span);
+            }
+            !found
+        },
+        _ => true,
+    });
+    span
+}
+
+fn pat_contains_or(pat: &Pat<'_>) -> bool {
+    let mut result = false;
+    pat.walk(|p| {
+        let is_or = matches!(p.kind, PatKind::Or(_));
+        result |= is_or;
+        !is_or
+    });
+    result
+}
diff --git a/clippy_lints/src/matches/match_like_matches.rs b/clippy_lints/src/matches/match_like_matches.rs
index 2e1f7646eb4..a68eec842ab 100644
--- a/clippy_lints/src/matches/match_like_matches.rs
+++ b/clippy_lints/src/matches/match_like_matches.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::is_wild;
 use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::{higher, is_wild};
 use rustc_ast::{Attribute, LitKind};
 use rustc_errors::Applicability;
 use rustc_hir::{Arm, BorrowKind, Expr, ExprKind, Guard, Pat};
@@ -11,22 +11,24 @@ use rustc_span::source_map::Spanned;
 use super::MATCH_LIKE_MATCHES_MACRO;
 
 /// Lint a `match` or `if let .. { .. } else { .. }` expr that could be replaced by `matches!`
-pub(crate) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-    if let Some(higher::IfLet {
-        let_pat,
+pub(crate) fn check_if_let<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx Expr<'_>,
+    let_pat: &'tcx Pat<'_>,
+    let_expr: &'tcx Expr<'_>,
+    then_expr: &'tcx Expr<'_>,
+    else_expr: &'tcx Expr<'_>,
+) {
+    find_matches_sugg(
+        cx,
         let_expr,
-        if_then,
-        if_else: Some(if_else),
-    }) = higher::IfLet::hir(cx, expr)
-    {
-        find_matches_sugg(
-            cx,
-            let_expr,
-            IntoIterator::into_iter([(&[][..], Some(let_pat), if_then, None), (&[][..], None, if_else, None)]),
-            expr,
-            true,
-        );
-    }
+        IntoIterator::into_iter([
+            (&[][..], Some(let_pat), then_expr, None),
+            (&[][..], None, else_expr, None),
+        ]),
+        expr,
+        true,
+    );
 }
 
 pub(super) fn check_match<'tcx>(
diff --git a/clippy_lints/src/matches/mod.rs b/clippy_lints/src/matches/mod.rs
index 3d8391bce2b..4a77fb8c31b 100644
--- a/clippy_lints/src/matches/mod.rs
+++ b/clippy_lints/src/matches/mod.rs
@@ -1,12 +1,14 @@
 use clippy_utils::source::{snippet_opt, span_starts_with, walk_span_to_context};
-use clippy_utils::{meets_msrv, msrvs};
+use clippy_utils::{higher, meets_msrv, msrvs};
 use rustc_hir::{Arm, Expr, ExprKind, Local, MatchSource, Pat};
 use rustc_lexer::{tokenize, TokenKind};
-use rustc_lint::{LateContext, LateLintPass};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_middle::lint::in_external_macro;
 use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::{Span, SpanData, SyntaxContext};
 
+mod collapsible_match;
 mod infallible_destructuring_match;
 mod match_as_ref;
 mod match_bool;
@@ -610,6 +612,44 @@ declare_clippy_lint! {
     "`match` or match-like `if let` that are unnecessary"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Finds nested `match` or `if let` expressions where the patterns may be "collapsed" together
+    /// without adding any branches.
+    ///
+    /// Note that this lint is not intended to find _all_ cases where nested match patterns can be merged, but only
+    /// cases where merging would most likely make the code more readable.
+    ///
+    /// ### Why is this bad?
+    /// It is unnecessarily verbose and complex.
+    ///
+    /// ### Example
+    /// ```rust
+    /// fn func(opt: Option<Result<u64, String>>) {
+    ///     let n = match opt {
+    ///         Some(n) => match n {
+    ///             Ok(n) => n,
+    ///             _ => return,
+    ///         }
+    ///         None => return,
+    ///     };
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// fn func(opt: Option<Result<u64, String>>) {
+    ///     let n = match opt {
+    ///         Some(Ok(n)) => n,
+    ///         _ => return,
+    ///     };
+    /// }
+    /// ```
+    #[clippy::version = "1.50.0"]
+    pub COLLAPSIBLE_MATCH,
+    style,
+    "Nested `match` or `if let` expressions where the patterns may be \"collapsed\" together."
+}
+
 #[derive(Default)]
 pub struct Matches {
     msrv: Option<RustcVersion>,
@@ -644,19 +684,29 @@ impl_lint_pass!(Matches => [
     MATCH_LIKE_MATCHES_MACRO,
     MATCH_SAME_ARMS,
     NEEDLESS_MATCH,
+    COLLAPSIBLE_MATCH,
 ]);
 
 impl<'tcx> LateLintPass<'tcx> for Matches {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if expr.span.from_expansion() {
+        if in_external_macro(cx.sess(), expr.span) {
             return;
         }
+        let from_expansion = expr.span.from_expansion();
 
         if let ExprKind::Match(ex, arms, source) = expr.kind {
             if !span_starts_with(cx, expr.span, "match") {
                 return;
             }
-            if !contains_cfg_arm(cx, expr, ex, arms) {
+
+            collapsible_match::check_match(cx, arms);
+            if !from_expansion {
+                // These don't depend on a relationship between multiple arms
+                match_wild_err_arm::check(cx, ex, arms);
+                wild_in_or_pats::check(cx, arms);
+            }
+
+            if !from_expansion && !contains_cfg_arm(cx, expr, ex, arms) {
                 if source == MatchSource::Normal {
                     if !(meets_msrv(self.msrv, msrvs::MATCHES_MACRO)
                         && match_like_matches::check_match(cx, expr, ex, arms))
@@ -680,16 +730,32 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
                 }
                 match_ref_pats::check(cx, ex, arms.iter().map(|el| el.pat), expr);
             }
-
-            // These don't depend on a relationship between multiple arms
-            match_wild_err_arm::check(cx, ex, arms);
-            wild_in_or_pats::check(cx, arms);
-        } else {
-            if meets_msrv(self.msrv, msrvs::MATCHES_MACRO) {
-                match_like_matches::check(cx, expr);
+        } else if let Some(if_let) = higher::IfLet::hir(cx, expr) {
+            collapsible_match::check_if_let(cx, if_let.let_pat, if_let.if_then, if_let.if_else);
+            if !from_expansion {
+                if let Some(else_expr) = if_let.if_else {
+                    if meets_msrv(self.msrv, msrvs::MATCHES_MACRO) {
+                        match_like_matches::check_if_let(
+                            cx,
+                            expr,
+                            if_let.let_pat,
+                            if_let.let_expr,
+                            if_let.if_then,
+                            else_expr,
+                        );
+                    }
+                }
+                redundant_pattern_match::check_if_let(
+                    cx,
+                    expr,
+                    if_let.let_pat,
+                    if_let.let_expr,
+                    if_let.if_else.is_some(),
+                );
+                needless_match::check_if_let(cx, expr, &if_let);
             }
+        } else if !from_expansion {
             redundant_pattern_match::check(cx, expr);
-            needless_match::check(cx, expr);
         }
     }
 
diff --git a/clippy_lints/src/matches/needless_match.rs b/clippy_lints/src/matches/needless_match.rs
index f920ad4651f..fa19cddd35e 100644
--- a/clippy_lints/src/matches/needless_match.rs
+++ b/clippy_lints/src/matches/needless_match.rs
@@ -47,20 +47,18 @@ pub(crate) fn check_match(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>],
 ///     some_enum
 /// }
 /// ```
-pub(crate) fn check(cx: &LateContext<'_>, ex: &Expr<'_>) {
-    if let Some(ref if_let) = higher::IfLet::hir(cx, ex) {
-        if !is_else_clause(cx.tcx, ex) && expr_ty_matches_p_ty(cx, if_let.let_expr, ex) && check_if_let(cx, if_let) {
-            let mut applicability = Applicability::MachineApplicable;
-            span_lint_and_sugg(
-                cx,
-                NEEDLESS_MATCH,
-                ex.span,
-                "this if-let expression is unnecessary",
-                "replace it with",
-                snippet_with_applicability(cx, if_let.let_expr.span, "..", &mut applicability).to_string(),
-                applicability,
-            );
-        }
+pub(crate) fn check_if_let<'tcx>(cx: &LateContext<'tcx>, ex: &Expr<'_>, if_let: &higher::IfLet<'tcx>) {
+    if !is_else_clause(cx.tcx, ex) && expr_ty_matches_p_ty(cx, if_let.let_expr, ex) && check_if_let_inner(cx, if_let) {
+        let mut applicability = Applicability::MachineApplicable;
+        span_lint_and_sugg(
+            cx,
+            NEEDLESS_MATCH,
+            ex.span,
+            "this if-let expression is unnecessary",
+            "replace it with",
+            snippet_with_applicability(cx, if_let.let_expr.span, "..", &mut applicability).to_string(),
+            applicability,
+        );
     }
 }
 
@@ -77,7 +75,7 @@ fn check_all_arms(cx: &LateContext<'_>, match_expr: &Expr<'_>, arms: &[Arm<'_>])
     true
 }
 
-fn check_if_let(cx: &LateContext<'_>, if_let: &higher::IfLet<'_>) -> bool {
+fn check_if_let_inner(cx: &LateContext<'_>, if_let: &higher::IfLet<'_>) -> bool {
     if let Some(if_else) = if_let.if_else {
         if !pat_same_as_expr(if_let.let_pat, peel_blocks_with_stmt(if_let.if_then)) {
             return false;
@@ -85,7 +83,7 @@ fn check_if_let(cx: &LateContext<'_>, if_let: &higher::IfLet<'_>) -> bool {
 
         // Recursively check for each `else if let` phrase,
         if let Some(ref nested_if_let) = higher::IfLet::hir(cx, if_else) {
-            return check_if_let(cx, nested_if_let);
+            return check_if_let_inner(cx, nested_if_let);
         }
 
         if matches!(if_else.kind, ExprKind::Block(..)) {
diff --git a/clippy_lints/src/matches/redundant_pattern_match.rs b/clippy_lints/src/matches/redundant_pattern_match.rs
index 1a8b9d15f37..095cd43ea13 100644
--- a/clippy_lints/src/matches/redundant_pattern_match.rs
+++ b/clippy_lints/src/matches/redundant_pattern_match.rs
@@ -18,19 +18,21 @@ use rustc_middle::ty::{self, subst::GenericArgKind, DefIdTree, Ty};
 use rustc_span::sym;
 
 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-    if let Some(higher::IfLet {
-        if_else,
-        let_pat,
-        let_expr,
-        ..
-    }) = higher::IfLet::hir(cx, expr)
-    {
-        find_sugg_for_if_let(cx, expr, let_pat, let_expr, "if", if_else.is_some());
-    } else if let Some(higher::WhileLet { let_pat, let_expr, .. }) = higher::WhileLet::hir(expr) {
+    if let Some(higher::WhileLet { let_pat, let_expr, .. }) = higher::WhileLet::hir(expr) {
         find_sugg_for_if_let(cx, expr, let_pat, let_expr, "while", false);
     }
 }
 
+pub(super) fn check_if_let<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx Expr<'_>,
+    pat: &'tcx Pat<'_>,
+    scrutinee: &'tcx Expr<'_>,
+    has_else: bool,
+) {
+    find_sugg_for_if_let(cx, expr, pat, scrutinee, "if", has_else);
+}
+
 // Extract the generic arguments out of a type
 fn try_get_generic_ty(ty: Ty<'_>, index: usize) -> Option<Ty<'_>> {
     if_chain! {
-- 
cgit 1.4.1-3-g733a5


From b337f9e62e8e8adee47684757c1ad101067beae2 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Fri, 3 Jun 2022 12:29:54 -0400
Subject: Merge `ManualUnwrapOr` into `Matches` lint pass

---
 clippy_lints/src/lib.register_all.rs         |   2 +-
 clippy_lints/src/lib.register_complexity.rs  |   2 +-
 clippy_lints/src/lib.register_lints.rs       |   2 +-
 clippy_lints/src/lib.rs                      |   2 -
 clippy_lints/src/manual_unwrap_or.rs         | 123 ---------------------------
 clippy_lints/src/matches/manual_unwrap_or.rs |  83 ++++++++++++++++++
 clippy_lints/src/matches/mod.rs              |  35 +++++++-
 7 files changed, 120 insertions(+), 129 deletions(-)
 delete mode 100644 clippy_lints/src/manual_unwrap_or.rs
 create mode 100644 clippy_lints/src/matches/manual_unwrap_or.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index b1da36a0d40..46af1d8fb09 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -136,7 +136,6 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(manual_map::MANUAL_MAP),
     LintId::of(manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE),
     LintId::of(manual_strip::MANUAL_STRIP),
-    LintId::of(manual_unwrap_or::MANUAL_UNWRAP_OR),
     LintId::of(map_clone::MAP_CLONE),
     LintId::of(map_unit_fn::OPTION_MAP_UNIT_FN),
     LintId::of(map_unit_fn::RESULT_MAP_UNIT_FN),
@@ -144,6 +143,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(match_str_case_mismatch::MATCH_STR_CASE_MISMATCH),
     LintId::of(matches::COLLAPSIBLE_MATCH),
     LintId::of(matches::INFALLIBLE_DESTRUCTURING_MATCH),
+    LintId::of(matches::MANUAL_UNWRAP_OR),
     LintId::of(matches::MATCH_AS_REF),
     LintId::of(matches::MATCH_LIKE_MATCHES_MACRO),
     LintId::of(matches::MATCH_OVERLAPPING_ARM),
diff --git a/clippy_lints/src/lib.register_complexity.rs b/clippy_lints/src/lib.register_complexity.rs
index 29b38a01b7e..4f1c3673f85 100644
--- a/clippy_lints/src/lib.register_complexity.rs
+++ b/clippy_lints/src/lib.register_complexity.rs
@@ -25,9 +25,9 @@ store.register_group(true, "clippy::complexity", Some("clippy_complexity"), vec!
     LintId::of(loops::SINGLE_ELEMENT_LOOP),
     LintId::of(loops::WHILE_LET_LOOP),
     LintId::of(manual_strip::MANUAL_STRIP),
-    LintId::of(manual_unwrap_or::MANUAL_UNWRAP_OR),
     LintId::of(map_unit_fn::OPTION_MAP_UNIT_FN),
     LintId::of(map_unit_fn::RESULT_MAP_UNIT_FN),
+    LintId::of(matches::MANUAL_UNWRAP_OR),
     LintId::of(matches::MATCH_AS_REF),
     LintId::of(matches::MATCH_SINGLE_BINDING),
     LintId::of(matches::NEEDLESS_MATCH),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 58e18b710ea..cb52000fa55 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -254,7 +254,6 @@ store.register_lints(&[
     manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE,
     manual_ok_or::MANUAL_OK_OR,
     manual_strip::MANUAL_STRIP,
-    manual_unwrap_or::MANUAL_UNWRAP_OR,
     map_clone::MAP_CLONE,
     map_err_ignore::MAP_ERR_IGNORE,
     map_unit_fn::OPTION_MAP_UNIT_FN,
@@ -264,6 +263,7 @@ store.register_lints(&[
     match_str_case_mismatch::MATCH_STR_CASE_MISMATCH,
     matches::COLLAPSIBLE_MATCH,
     matches::INFALLIBLE_DESTRUCTURING_MATCH,
+    matches::MANUAL_UNWRAP_OR,
     matches::MATCH_AS_REF,
     matches::MATCH_BOOL,
     matches::MATCH_LIKE_MATCHES_MACRO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 6e16d470ac8..3fdd0db8187 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -283,7 +283,6 @@ mod manual_map;
 mod manual_non_exhaustive;
 mod manual_ok_or;
 mod manual_strip;
-mod manual_unwrap_or;
 mod map_clone;
 mod map_err_ignore;
 mod map_unit_fn;
@@ -834,7 +833,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(repeat_once::RepeatOnce));
     store.register_late_pass(|| Box::new(unwrap_in_result::UnwrapInResult));
     store.register_late_pass(|| Box::new(self_assignment::SelfAssignment));
-    store.register_late_pass(|| Box::new(manual_unwrap_or::ManualUnwrapOr));
     store.register_late_pass(|| Box::new(manual_ok_or::ManualOkOr));
     store.register_late_pass(|| Box::new(float_equality_without_abs::FloatEqualityWithoutAbs));
     store.register_late_pass(|| Box::new(semicolon_if_nothing_returned::SemicolonIfNothingReturned));
diff --git a/clippy_lints/src/manual_unwrap_or.rs b/clippy_lints/src/manual_unwrap_or.rs
deleted file mode 100644
index b3a91d9f18f..00000000000
--- a/clippy_lints/src/manual_unwrap_or.rs
+++ /dev/null
@@ -1,123 +0,0 @@
-use clippy_utils::consts::constant_simple;
-use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::source::{indent_of, reindent_multiline, snippet_opt};
-use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::usage::contains_return_break_continue_macro;
-use clippy_utils::{in_constant, is_lang_ctor, path_to_local_id, sugg};
-use if_chain::if_chain;
-use rustc_errors::Applicability;
-use rustc_hir::LangItem::{OptionNone, OptionSome, ResultErr, ResultOk};
-use rustc_hir::{Arm, Expr, ExprKind, PatKind};
-use rustc_lint::LintContext;
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::lint::in_external_macro;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::sym;
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Finds patterns that reimplement `Option::unwrap_or` or `Result::unwrap_or`.
-    ///
-    /// ### Why is this bad?
-    /// Concise code helps focusing on behavior instead of boilerplate.
-    ///
-    /// ### Example
-    /// ```rust
-    /// let foo: Option<i32> = None;
-    /// match foo {
-    ///     Some(v) => v,
-    ///     None => 1,
-    /// };
-    /// ```
-    ///
-    /// Use instead:
-    /// ```rust
-    /// let foo: Option<i32> = None;
-    /// foo.unwrap_or(1);
-    /// ```
-    #[clippy::version = "1.49.0"]
-    pub MANUAL_UNWRAP_OR,
-    complexity,
-    "finds patterns that can be encoded more concisely with `Option::unwrap_or` or `Result::unwrap_or`"
-}
-
-declare_lint_pass!(ManualUnwrapOr => [MANUAL_UNWRAP_OR]);
-
-impl<'tcx> LateLintPass<'tcx> for ManualUnwrapOr {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
-        if in_external_macro(cx.sess(), expr.span) || in_constant(cx, expr.hir_id) {
-            return;
-        }
-        lint_manual_unwrap_or(cx, expr);
-    }
-}
-
-fn lint_manual_unwrap_or<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
-    fn applicable_or_arm<'a>(cx: &LateContext<'_>, arms: &'a [Arm<'a>]) -> Option<&'a Arm<'a>> {
-        if_chain! {
-            if arms.len() == 2;
-            if arms.iter().all(|arm| arm.guard.is_none());
-            if let Some((idx, or_arm)) = arms.iter().enumerate().find(|(_, arm)| {
-                match arm.pat.kind {
-                    PatKind::Path(ref qpath) => is_lang_ctor(cx, qpath, OptionNone),
-                    PatKind::TupleStruct(ref qpath, [pat], _) =>
-                        matches!(pat.kind, PatKind::Wild) && is_lang_ctor(cx, qpath, ResultErr),
-                    _ => false,
-                }
-            });
-            let unwrap_arm = &arms[1 - idx];
-            if let PatKind::TupleStruct(ref qpath, [unwrap_pat], _) = unwrap_arm.pat.kind;
-            if is_lang_ctor(cx, qpath, OptionSome) || is_lang_ctor(cx, qpath, ResultOk);
-            if let PatKind::Binding(_, binding_hir_id, ..) = unwrap_pat.kind;
-            if path_to_local_id(unwrap_arm.body, binding_hir_id);
-            if cx.typeck_results().expr_adjustments(unwrap_arm.body).is_empty();
-            if !contains_return_break_continue_macro(or_arm.body);
-            then {
-                Some(or_arm)
-            } else {
-                None
-            }
-        }
-    }
-
-    if_chain! {
-        if let ExprKind::Match(scrutinee, match_arms, _) = expr.kind;
-        let ty = cx.typeck_results().expr_ty(scrutinee);
-        if let Some(ty_name) = if is_type_diagnostic_item(cx, ty, sym::Option) {
-            Some("Option")
-        } else if is_type_diagnostic_item(cx, ty, sym::Result) {
-            Some("Result")
-        } else {
-            None
-        };
-        if let Some(or_arm) = applicable_or_arm(cx, match_arms);
-        if let Some(or_body_snippet) = snippet_opt(cx, or_arm.body.span);
-        if let Some(indent) = indent_of(cx, expr.span);
-        if constant_simple(cx, cx.typeck_results(), or_arm.body).is_some();
-        then {
-            let reindented_or_body =
-                reindent_multiline(or_body_snippet.into(), true, Some(indent));
-
-            let suggestion = if scrutinee.span.from_expansion() {
-                    // we don't want parentheses around macro, e.g. `(some_macro!()).unwrap_or(0)`
-                    sugg::Sugg::hir_with_macro_callsite(cx, scrutinee, "..")
-                }
-                else {
-                    sugg::Sugg::hir(cx, scrutinee, "..").maybe_par()
-                };
-
-            span_lint_and_sugg(
-                cx,
-                MANUAL_UNWRAP_OR, expr.span,
-                &format!("this pattern reimplements `{}::unwrap_or`", ty_name),
-                "replace with",
-                format!(
-                    "{}.unwrap_or({})",
-                    suggestion,
-                    reindented_or_body,
-                ),
-                Applicability::MachineApplicable,
-            );
-        }
-    }
-}
diff --git a/clippy_lints/src/matches/manual_unwrap_or.rs b/clippy_lints/src/matches/manual_unwrap_or.rs
new file mode 100644
index 00000000000..e1111c80f2f
--- /dev/null
+++ b/clippy_lints/src/matches/manual_unwrap_or.rs
@@ -0,0 +1,83 @@
+use clippy_utils::consts::constant_simple;
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::{indent_of, reindent_multiline, snippet_opt};
+use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::usage::contains_return_break_continue_macro;
+use clippy_utils::{is_lang_ctor, path_to_local_id, sugg};
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir::LangItem::{OptionNone, OptionSome, ResultErr, ResultOk};
+use rustc_hir::{Arm, Expr, PatKind};
+use rustc_lint::LateContext;
+use rustc_span::sym;
+
+use super::MANUAL_UNWRAP_OR;
+
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>, scrutinee: &'tcx Expr<'_>, arms: &'tcx [Arm<'_>]) {
+    let ty = cx.typeck_results().expr_ty(scrutinee);
+    if_chain! {
+        if let Some(ty_name) = if is_type_diagnostic_item(cx, ty, sym::Option) {
+            Some("Option")
+        } else if is_type_diagnostic_item(cx, ty, sym::Result) {
+            Some("Result")
+        } else {
+            None
+        };
+        if let Some(or_arm) = applicable_or_arm(cx, arms);
+        if let Some(or_body_snippet) = snippet_opt(cx, or_arm.body.span);
+        if let Some(indent) = indent_of(cx, expr.span);
+        if constant_simple(cx, cx.typeck_results(), or_arm.body).is_some();
+        then {
+            let reindented_or_body =
+                reindent_multiline(or_body_snippet.into(), true, Some(indent));
+
+            let suggestion = if scrutinee.span.from_expansion() {
+                    // we don't want parentheses around macro, e.g. `(some_macro!()).unwrap_or(0)`
+                    sugg::Sugg::hir_with_macro_callsite(cx, scrutinee, "..")
+                }
+                else {
+                    sugg::Sugg::hir(cx, scrutinee, "..").maybe_par()
+                };
+
+            span_lint_and_sugg(
+                cx,
+                MANUAL_UNWRAP_OR, expr.span,
+                &format!("this pattern reimplements `{}::unwrap_or`", ty_name),
+                "replace with",
+                format!(
+                    "{}.unwrap_or({})",
+                    suggestion,
+                    reindented_or_body,
+                ),
+                Applicability::MachineApplicable,
+            );
+        }
+    }
+}
+
+fn applicable_or_arm<'a>(cx: &LateContext<'_>, arms: &'a [Arm<'a>]) -> Option<&'a Arm<'a>> {
+    if_chain! {
+        if arms.len() == 2;
+        if arms.iter().all(|arm| arm.guard.is_none());
+        if let Some((idx, or_arm)) = arms.iter().enumerate().find(|(_, arm)| {
+            match arm.pat.kind {
+                PatKind::Path(ref qpath) => is_lang_ctor(cx, qpath, OptionNone),
+                PatKind::TupleStruct(ref qpath, [pat], _) =>
+                    matches!(pat.kind, PatKind::Wild) && is_lang_ctor(cx, qpath, ResultErr),
+                _ => false,
+            }
+        });
+        let unwrap_arm = &arms[1 - idx];
+        if let PatKind::TupleStruct(ref qpath, [unwrap_pat], _) = unwrap_arm.pat.kind;
+        if is_lang_ctor(cx, qpath, OptionSome) || is_lang_ctor(cx, qpath, ResultOk);
+        if let PatKind::Binding(_, binding_hir_id, ..) = unwrap_pat.kind;
+        if path_to_local_id(unwrap_arm.body, binding_hir_id);
+        if cx.typeck_results().expr_adjustments(unwrap_arm.body).is_empty();
+        if !contains_return_break_continue_macro(or_arm.body);
+        then {
+            Some(or_arm)
+        } else {
+            None
+        }
+    }
+}
diff --git a/clippy_lints/src/matches/mod.rs b/clippy_lints/src/matches/mod.rs
index 4a77fb8c31b..ade47b1ed88 100644
--- a/clippy_lints/src/matches/mod.rs
+++ b/clippy_lints/src/matches/mod.rs
@@ -1,5 +1,5 @@
 use clippy_utils::source::{snippet_opt, span_starts_with, walk_span_to_context};
-use clippy_utils::{higher, meets_msrv, msrvs};
+use clippy_utils::{higher, in_constant, meets_msrv, msrvs};
 use rustc_hir::{Arm, Expr, ExprKind, Local, MatchSource, Pat};
 use rustc_lexer::{tokenize, TokenKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
@@ -10,6 +10,7 @@ use rustc_span::{Span, SpanData, SyntaxContext};
 
 mod collapsible_match;
 mod infallible_destructuring_match;
+mod manual_unwrap_or;
 mod match_as_ref;
 mod match_bool;
 mod match_like_matches;
@@ -650,6 +651,33 @@ declare_clippy_lint! {
     "Nested `match` or `if let` expressions where the patterns may be \"collapsed\" together."
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Finds patterns that reimplement `Option::unwrap_or` or `Result::unwrap_or`.
+    ///
+    /// ### Why is this bad?
+    /// Concise code helps focusing on behavior instead of boilerplate.
+    ///
+    /// ### Example
+    /// ```rust
+    /// let foo: Option<i32> = None;
+    /// match foo {
+    ///     Some(v) => v,
+    ///     None => 1,
+    /// };
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust
+    /// let foo: Option<i32> = None;
+    /// foo.unwrap_or(1);
+    /// ```
+    #[clippy::version = "1.49.0"]
+    pub MANUAL_UNWRAP_OR,
+    complexity,
+    "finds patterns that can be encoded more concisely with `Option::unwrap_or` or `Result::unwrap_or`"
+}
+
 #[derive(Default)]
 pub struct Matches {
     msrv: Option<RustcVersion>,
@@ -685,6 +713,7 @@ impl_lint_pass!(Matches => [
     MATCH_SAME_ARMS,
     NEEDLESS_MATCH,
     COLLAPSIBLE_MATCH,
+    MANUAL_UNWRAP_OR,
 ]);
 
 impl<'tcx> LateLintPass<'tcx> for Matches {
@@ -722,6 +751,10 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
                     match_as_ref::check(cx, ex, arms, expr);
                     needless_match::check_match(cx, ex, arms, expr);
 
+                    if !in_constant(cx, expr.hir_id) {
+                        manual_unwrap_or::check(cx, expr, ex, arms);
+                    }
+
                     if self.infallible_destructuring_match_linted {
                         self.infallible_destructuring_match_linted = false;
                     } else {
-- 
cgit 1.4.1-3-g733a5


From 3d8d7341509e4868c91fa7fe24703e69c21a9869 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Fri, 3 Jun 2022 13:10:57 -0400
Subject: Move `MatchOnVecItems` into `Matches` lint pass

---
 clippy_lints/src/lib.register_lints.rs         |   2 +-
 clippy_lints/src/lib.register_pedantic.rs      |   2 +-
 clippy_lints/src/lib.rs                        |   2 -
 clippy_lints/src/match_on_vec_items.rs         | 104 -------------------------
 clippy_lints/src/matches/match_on_vec_items.rs |  61 +++++++++++++++
 clippy_lints/src/matches/mod.rs                |  40 ++++++++++
 6 files changed, 103 insertions(+), 108 deletions(-)
 delete mode 100644 clippy_lints/src/match_on_vec_items.rs
 create mode 100644 clippy_lints/src/matches/match_on_vec_items.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index cb52000fa55..fb44df57de6 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -258,7 +258,6 @@ store.register_lints(&[
     map_err_ignore::MAP_ERR_IGNORE,
     map_unit_fn::OPTION_MAP_UNIT_FN,
     map_unit_fn::RESULT_MAP_UNIT_FN,
-    match_on_vec_items::MATCH_ON_VEC_ITEMS,
     match_result_ok::MATCH_RESULT_OK,
     match_str_case_mismatch::MATCH_STR_CASE_MISMATCH,
     matches::COLLAPSIBLE_MATCH,
@@ -267,6 +266,7 @@ store.register_lints(&[
     matches::MATCH_AS_REF,
     matches::MATCH_BOOL,
     matches::MATCH_LIKE_MATCHES_MACRO,
+    matches::MATCH_ON_VEC_ITEMS,
     matches::MATCH_OVERLAPPING_ARM,
     matches::MATCH_REF_PATS,
     matches::MATCH_SAME_ARMS,
diff --git a/clippy_lints/src/lib.register_pedantic.rs b/clippy_lints/src/lib.register_pedantic.rs
index 2e47a287d5c..a8b6c5a5d63 100644
--- a/clippy_lints/src/lib.register_pedantic.rs
+++ b/clippy_lints/src/lib.register_pedantic.rs
@@ -51,8 +51,8 @@ store.register_group(true, "clippy::pedantic", Some("clippy_pedantic"), vec![
     LintId::of(macro_use::MACRO_USE_IMPORTS),
     LintId::of(manual_assert::MANUAL_ASSERT),
     LintId::of(manual_ok_or::MANUAL_OK_OR),
-    LintId::of(match_on_vec_items::MATCH_ON_VEC_ITEMS),
     LintId::of(matches::MATCH_BOOL),
+    LintId::of(matches::MATCH_ON_VEC_ITEMS),
     LintId::of(matches::MATCH_SAME_ARMS),
     LintId::of(matches::MATCH_WILDCARD_FOR_SINGLE_VARIANTS),
     LintId::of(matches::MATCH_WILD_ERR_ARM),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 3fdd0db8187..50b67918fc0 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -286,7 +286,6 @@ mod manual_strip;
 mod map_clone;
 mod map_err_ignore;
 mod map_unit_fn;
-mod match_on_vec_items;
 mod match_result_ok;
 mod match_str_case_mismatch;
 mod matches;
@@ -815,7 +814,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(if_not_else::IfNotElse));
     store.register_late_pass(|| Box::new(equatable_if_let::PatternEquality));
     store.register_late_pass(|| Box::new(mut_mutex_lock::MutMutexLock));
-    store.register_late_pass(|| Box::new(match_on_vec_items::MatchOnVecItems));
     store.register_late_pass(|| Box::new(manual_async_fn::ManualAsyncFn));
     store.register_late_pass(|| Box::new(vec_resize_to_zero::VecResizeToZero));
     store.register_late_pass(|| Box::new(panic_in_result_fn::PanicInResultFn));
diff --git a/clippy_lints/src/match_on_vec_items.rs b/clippy_lints/src/match_on_vec_items.rs
deleted file mode 100644
index 583b577ffe2..00000000000
--- a/clippy_lints/src/match_on_vec_items.rs
+++ /dev/null
@@ -1,104 +0,0 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::source::snippet;
-use clippy_utils::ty::{is_type_diagnostic_item, is_type_lang_item};
-use if_chain::if_chain;
-use rustc_errors::Applicability;
-use rustc_hir::{Expr, ExprKind, LangItem, MatchSource};
-use rustc_lint::{LateContext, LateLintPass, LintContext};
-use rustc_middle::lint::in_external_macro;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::sym;
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for `match vec[idx]` or `match vec[n..m]`.
-    ///
-    /// ### Why is this bad?
-    /// This can panic at runtime.
-    ///
-    /// ### Example
-    /// ```rust, no_run
-    /// let arr = vec![0, 1, 2, 3];
-    /// let idx = 1;
-    ///
-    /// // Bad
-    /// match arr[idx] {
-    ///     0 => println!("{}", 0),
-    ///     1 => println!("{}", 3),
-    ///     _ => {},
-    /// }
-    /// ```
-    /// Use instead:
-    /// ```rust, no_run
-    /// let arr = vec![0, 1, 2, 3];
-    /// let idx = 1;
-    ///
-    /// // Good
-    /// match arr.get(idx) {
-    ///     Some(0) => println!("{}", 0),
-    ///     Some(1) => println!("{}", 3),
-    ///     _ => {},
-    /// }
-    /// ```
-    #[clippy::version = "1.45.0"]
-    pub MATCH_ON_VEC_ITEMS,
-    pedantic,
-    "matching on vector elements can panic"
-}
-
-declare_lint_pass!(MatchOnVecItems => [MATCH_ON_VEC_ITEMS]);
-
-impl<'tcx> LateLintPass<'tcx> for MatchOnVecItems {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
-        if_chain! {
-            if !in_external_macro(cx.sess(), expr.span);
-            if let ExprKind::Match(match_expr, _, MatchSource::Normal) = expr.kind;
-            if let Some(idx_expr) = is_vec_indexing(cx, match_expr);
-            if let ExprKind::Index(vec, idx) = idx_expr.kind;
-
-            then {
-                // FIXME: could be improved to suggest surrounding every pattern with Some(_),
-                // but only when `or_patterns` are stabilized.
-                span_lint_and_sugg(
-                    cx,
-                    MATCH_ON_VEC_ITEMS,
-                    match_expr.span,
-                    "indexing into a vector may panic",
-                    "try this",
-                    format!(
-                        "{}.get({})",
-                        snippet(cx, vec.span, ".."),
-                        snippet(cx, idx.span, "..")
-                    ),
-                    Applicability::MaybeIncorrect
-                );
-            }
-        }
-    }
-}
-
-fn is_vec_indexing<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> Option<&'tcx Expr<'tcx>> {
-    if_chain! {
-        if let ExprKind::Index(array, index) = expr.kind;
-        if is_vector(cx, array);
-        if !is_full_range(cx, index);
-
-        then {
-            return Some(expr);
-        }
-    }
-
-    None
-}
-
-fn is_vector(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-    let ty = cx.typeck_results().expr_ty(expr);
-    let ty = ty.peel_refs();
-    is_type_diagnostic_item(cx, ty, sym::Vec)
-}
-
-fn is_full_range(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-    let ty = cx.typeck_results().expr_ty(expr);
-    let ty = ty.peel_refs();
-    is_type_lang_item(cx, ty, LangItem::RangeFull)
-}
diff --git a/clippy_lints/src/matches/match_on_vec_items.rs b/clippy_lints/src/matches/match_on_vec_items.rs
new file mode 100644
index 00000000000..2917f85c45f
--- /dev/null
+++ b/clippy_lints/src/matches/match_on_vec_items.rs
@@ -0,0 +1,61 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet;
+use clippy_utils::ty::{is_type_diagnostic_item, is_type_lang_item};
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind, LangItem};
+use rustc_lint::LateContext;
+use rustc_span::sym;
+
+use super::MATCH_ON_VEC_ITEMS;
+
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, scrutinee: &'tcx Expr<'_>) {
+    if_chain! {
+        if let Some(idx_expr) = is_vec_indexing(cx, scrutinee);
+        if let ExprKind::Index(vec, idx) = idx_expr.kind;
+
+        then {
+            // FIXME: could be improved to suggest surrounding every pattern with Some(_),
+            // but only when `or_patterns` are stabilized.
+            span_lint_and_sugg(
+                cx,
+                MATCH_ON_VEC_ITEMS,
+                scrutinee.span,
+                "indexing into a vector may panic",
+                "try this",
+                format!(
+                    "{}.get({})",
+                    snippet(cx, vec.span, ".."),
+                    snippet(cx, idx.span, "..")
+                ),
+                Applicability::MaybeIncorrect
+            );
+        }
+    }
+}
+
+fn is_vec_indexing<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> Option<&'tcx Expr<'tcx>> {
+    if_chain! {
+        if let ExprKind::Index(array, index) = expr.kind;
+        if is_vector(cx, array);
+        if !is_full_range(cx, index);
+
+        then {
+            return Some(expr);
+        }
+    }
+
+    None
+}
+
+fn is_vector(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+    let ty = cx.typeck_results().expr_ty(expr);
+    let ty = ty.peel_refs();
+    is_type_diagnostic_item(cx, ty, sym::Vec)
+}
+
+fn is_full_range(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+    let ty = cx.typeck_results().expr_ty(expr);
+    let ty = ty.peel_refs();
+    is_type_lang_item(cx, ty, LangItem::RangeFull)
+}
diff --git a/clippy_lints/src/matches/mod.rs b/clippy_lints/src/matches/mod.rs
index ade47b1ed88..7fb449028e7 100644
--- a/clippy_lints/src/matches/mod.rs
+++ b/clippy_lints/src/matches/mod.rs
@@ -14,6 +14,7 @@ mod manual_unwrap_or;
 mod match_as_ref;
 mod match_bool;
 mod match_like_matches;
+mod match_on_vec_items;
 mod match_ref_pats;
 mod match_same_arms;
 mod match_single_binding;
@@ -678,6 +679,43 @@ declare_clippy_lint! {
     "finds patterns that can be encoded more concisely with `Option::unwrap_or` or `Result::unwrap_or`"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `match vec[idx]` or `match vec[n..m]`.
+    ///
+    /// ### Why is this bad?
+    /// This can panic at runtime.
+    ///
+    /// ### Example
+    /// ```rust, no_run
+    /// let arr = vec![0, 1, 2, 3];
+    /// let idx = 1;
+    ///
+    /// // Bad
+    /// match arr[idx] {
+    ///     0 => println!("{}", 0),
+    ///     1 => println!("{}", 3),
+    ///     _ => {},
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust, no_run
+    /// let arr = vec![0, 1, 2, 3];
+    /// let idx = 1;
+    ///
+    /// // Good
+    /// match arr.get(idx) {
+    ///     Some(0) => println!("{}", 0),
+    ///     Some(1) => println!("{}", 3),
+    ///     _ => {},
+    /// }
+    /// ```
+    #[clippy::version = "1.45.0"]
+    pub MATCH_ON_VEC_ITEMS,
+    pedantic,
+    "matching on vector elements can panic"
+}
+
 #[derive(Default)]
 pub struct Matches {
     msrv: Option<RustcVersion>,
@@ -714,6 +752,7 @@ impl_lint_pass!(Matches => [
     NEEDLESS_MATCH,
     COLLAPSIBLE_MATCH,
     MANUAL_UNWRAP_OR,
+    MATCH_ON_VEC_ITEMS,
 ]);
 
 impl<'tcx> LateLintPass<'tcx> for Matches {
@@ -750,6 +789,7 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
                     match_wild_enum::check(cx, ex, arms);
                     match_as_ref::check(cx, ex, arms, expr);
                     needless_match::check_match(cx, ex, arms, expr);
+                    match_on_vec_items::check(cx, ex);
 
                     if !in_constant(cx, expr.hir_id) {
                         manual_unwrap_or::check(cx, expr, ex, arms);
-- 
cgit 1.4.1-3-g733a5


From 8c8a52eeeb9ca47575200eacd1ab86bf46e8dc15 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Fri, 3 Jun 2022 13:16:02 -0400
Subject: Move `MatchStrCaseMismatch` into `Matches` lint pass

---
 clippy_lints/src/lib.register_all.rs               |   2 +-
 clippy_lints/src/lib.register_correctness.rs       |   2 +-
 clippy_lints/src/lib.register_lints.rs             |   2 +-
 clippy_lints/src/lib.rs                            |   2 -
 clippy_lints/src/match_str_case_mismatch.rs        | 162 ---------------------
 .../src/matches/match_str_case_mismatch.rs         | 125 ++++++++++++++++
 clippy_lints/src/matches/mod.rs                    |  34 +++++
 7 files changed, 162 insertions(+), 167 deletions(-)
 delete mode 100644 clippy_lints/src/match_str_case_mismatch.rs
 create mode 100644 clippy_lints/src/matches/match_str_case_mismatch.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 46af1d8fb09..15e744229a1 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -140,7 +140,6 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(map_unit_fn::OPTION_MAP_UNIT_FN),
     LintId::of(map_unit_fn::RESULT_MAP_UNIT_FN),
     LintId::of(match_result_ok::MATCH_RESULT_OK),
-    LintId::of(match_str_case_mismatch::MATCH_STR_CASE_MISMATCH),
     LintId::of(matches::COLLAPSIBLE_MATCH),
     LintId::of(matches::INFALLIBLE_DESTRUCTURING_MATCH),
     LintId::of(matches::MANUAL_UNWRAP_OR),
@@ -149,6 +148,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(matches::MATCH_OVERLAPPING_ARM),
     LintId::of(matches::MATCH_REF_PATS),
     LintId::of(matches::MATCH_SINGLE_BINDING),
+    LintId::of(matches::MATCH_STR_CASE_MISMATCH),
     LintId::of(matches::NEEDLESS_MATCH),
     LintId::of(matches::REDUNDANT_PATTERN_MATCHING),
     LintId::of(matches::SINGLE_MATCH),
diff --git a/clippy_lints/src/lib.register_correctness.rs b/clippy_lints/src/lib.register_correctness.rs
index 6bf2c4bbaed..50cdd0af923 100644
--- a/clippy_lints/src/lib.register_correctness.rs
+++ b/clippy_lints/src/lib.register_correctness.rs
@@ -39,7 +39,7 @@ store.register_group(true, "clippy::correctness", Some("clippy_correctness"), ve
     LintId::of(loops::ITER_NEXT_LOOP),
     LintId::of(loops::NEVER_LOOP),
     LintId::of(loops::WHILE_IMMUTABLE_CONDITION),
-    LintId::of(match_str_case_mismatch::MATCH_STR_CASE_MISMATCH),
+    LintId::of(matches::MATCH_STR_CASE_MISMATCH),
     LintId::of(mem_replace::MEM_REPLACE_WITH_UNINIT),
     LintId::of(methods::CLONE_DOUBLE_REF),
     LintId::of(methods::ITERATOR_STEP_BY_ZERO),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index fb44df57de6..59ba295a887 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -259,7 +259,6 @@ store.register_lints(&[
     map_unit_fn::OPTION_MAP_UNIT_FN,
     map_unit_fn::RESULT_MAP_UNIT_FN,
     match_result_ok::MATCH_RESULT_OK,
-    match_str_case_mismatch::MATCH_STR_CASE_MISMATCH,
     matches::COLLAPSIBLE_MATCH,
     matches::INFALLIBLE_DESTRUCTURING_MATCH,
     matches::MANUAL_UNWRAP_OR,
@@ -271,6 +270,7 @@ store.register_lints(&[
     matches::MATCH_REF_PATS,
     matches::MATCH_SAME_ARMS,
     matches::MATCH_SINGLE_BINDING,
+    matches::MATCH_STR_CASE_MISMATCH,
     matches::MATCH_WILDCARD_FOR_SINGLE_VARIANTS,
     matches::MATCH_WILD_ERR_ARM,
     matches::NEEDLESS_MATCH,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 50b67918fc0..7335b4a35c8 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -287,7 +287,6 @@ mod map_clone;
 mod map_err_ignore;
 mod map_unit_fn;
 mod match_result_ok;
-mod match_str_case_mismatch;
 mod matches;
 mod mem_forget;
 mod mem_replace;
@@ -875,7 +874,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         ))
     });
     store.register_late_pass(move || Box::new(undocumented_unsafe_blocks::UndocumentedUnsafeBlocks));
-    store.register_late_pass(|| Box::new(match_str_case_mismatch::MatchStrCaseMismatch));
     store.register_late_pass(move || Box::new(format_args::FormatArgs));
     store.register_late_pass(|| Box::new(trailing_empty_array::TrailingEmptyArray));
     store.register_early_pass(|| Box::new(octal_escapes::OctalEscapes));
diff --git a/clippy_lints/src/match_str_case_mismatch.rs b/clippy_lints/src/match_str_case_mismatch.rs
deleted file mode 100644
index d97a878825a..00000000000
--- a/clippy_lints/src/match_str_case_mismatch.rs
+++ /dev/null
@@ -1,162 +0,0 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::ty::is_type_diagnostic_item;
-use rustc_ast::ast::LitKind;
-use rustc_errors::Applicability;
-use rustc_hir::intravisit::{walk_expr, Visitor};
-use rustc_hir::{Arm, Expr, ExprKind, MatchSource, PatKind};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::lint::in_external_macro;
-use rustc_middle::ty;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::symbol::Symbol;
-use rustc_span::{sym, Span};
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for `match` expressions modifying the case of a string with non-compliant arms
-    ///
-    /// ### Why is this bad?
-    /// The arm is unreachable, which is likely a mistake
-    ///
-    /// ### Example
-    /// ```rust
-    /// # let text = "Foo";
-    /// match &*text.to_ascii_lowercase() {
-    ///     "foo" => {},
-    ///     "Bar" => {},
-    ///     _ => {},
-    /// }
-    /// ```
-    /// Use instead:
-    /// ```rust
-    /// # let text = "Foo";
-    /// match &*text.to_ascii_lowercase() {
-    ///     "foo" => {},
-    ///     "bar" => {},
-    ///     _ => {},
-    /// }
-    /// ```
-    #[clippy::version = "1.58.0"]
-    pub MATCH_STR_CASE_MISMATCH,
-    correctness,
-    "creation of a case altering match expression with non-compliant arms"
-}
-
-declare_lint_pass!(MatchStrCaseMismatch => [MATCH_STR_CASE_MISMATCH]);
-
-#[derive(Debug)]
-enum CaseMethod {
-    LowerCase,
-    AsciiLowerCase,
-    UpperCase,
-    AsciiUppercase,
-}
-
-impl<'tcx> LateLintPass<'tcx> for MatchStrCaseMismatch {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if_chain! {
-            if !in_external_macro(cx.tcx.sess, expr.span);
-            if let ExprKind::Match(match_expr, arms, MatchSource::Normal) = expr.kind;
-            if let ty::Ref(_, ty, _) = cx.typeck_results().expr_ty(match_expr).kind();
-            if let ty::Str = ty.kind();
-            then {
-                let mut visitor = MatchExprVisitor {
-                    cx,
-                    case_method: None,
-                };
-
-                visitor.visit_expr(match_expr);
-
-                if let Some(case_method) = visitor.case_method {
-                    if let Some((bad_case_span, bad_case_sym)) = verify_case(&case_method, arms) {
-                        lint(cx, &case_method, bad_case_span, bad_case_sym.as_str());
-                    }
-                }
-            }
-        }
-    }
-}
-
-struct MatchExprVisitor<'a, 'tcx> {
-    cx: &'a LateContext<'tcx>,
-    case_method: Option<CaseMethod>,
-}
-
-impl<'a, 'tcx> Visitor<'tcx> for MatchExprVisitor<'a, 'tcx> {
-    fn visit_expr(&mut self, ex: &'tcx Expr<'_>) {
-        match ex.kind {
-            ExprKind::MethodCall(segment, [receiver], _) if self.case_altered(segment.ident.as_str(), receiver) => {},
-            _ => walk_expr(self, ex),
-        }
-    }
-}
-
-impl<'a, 'tcx> MatchExprVisitor<'a, 'tcx> {
-    fn case_altered(&mut self, segment_ident: &str, receiver: &Expr<'_>) -> bool {
-        if let Some(case_method) = get_case_method(segment_ident) {
-            let ty = self.cx.typeck_results().expr_ty(receiver).peel_refs();
-
-            if is_type_diagnostic_item(self.cx, ty, sym::String) || ty.kind() == &ty::Str {
-                self.case_method = Some(case_method);
-                return true;
-            }
-        }
-
-        false
-    }
-}
-
-fn get_case_method(segment_ident_str: &str) -> Option<CaseMethod> {
-    match segment_ident_str {
-        "to_lowercase" => Some(CaseMethod::LowerCase),
-        "to_ascii_lowercase" => Some(CaseMethod::AsciiLowerCase),
-        "to_uppercase" => Some(CaseMethod::UpperCase),
-        "to_ascii_uppercase" => Some(CaseMethod::AsciiUppercase),
-        _ => None,
-    }
-}
-
-fn verify_case<'a>(case_method: &'a CaseMethod, arms: &'a [Arm<'_>]) -> Option<(Span, Symbol)> {
-    let case_check = match case_method {
-        CaseMethod::LowerCase => |input: &str| -> bool { input.chars().all(|c| c.to_lowercase().next() == Some(c)) },
-        CaseMethod::AsciiLowerCase => |input: &str| -> bool { !input.chars().any(|c| c.is_ascii_uppercase()) },
-        CaseMethod::UpperCase => |input: &str| -> bool { input.chars().all(|c| c.to_uppercase().next() == Some(c)) },
-        CaseMethod::AsciiUppercase => |input: &str| -> bool { !input.chars().any(|c| c.is_ascii_lowercase()) },
-    };
-
-    for arm in arms {
-        if_chain! {
-            if let PatKind::Lit(Expr {
-                                kind: ExprKind::Lit(lit),
-                                ..
-                            }) = arm.pat.kind;
-            if let LitKind::Str(symbol, _) = lit.node;
-            let input = symbol.as_str();
-            if !case_check(input);
-            then {
-                return Some((lit.span, symbol));
-            }
-        }
-    }
-
-    None
-}
-
-fn lint(cx: &LateContext<'_>, case_method: &CaseMethod, bad_case_span: Span, bad_case_str: &str) {
-    let (method_str, suggestion) = match case_method {
-        CaseMethod::LowerCase => ("to_lowercase", bad_case_str.to_lowercase()),
-        CaseMethod::AsciiLowerCase => ("to_ascii_lowercase", bad_case_str.to_ascii_lowercase()),
-        CaseMethod::UpperCase => ("to_uppercase", bad_case_str.to_uppercase()),
-        CaseMethod::AsciiUppercase => ("to_ascii_uppercase", bad_case_str.to_ascii_uppercase()),
-    };
-
-    span_lint_and_sugg(
-        cx,
-        MATCH_STR_CASE_MISMATCH,
-        bad_case_span,
-        "this `match` arm has a differing case than its expression",
-        &*format!("consider changing the case of this arm to respect `{}`", method_str),
-        format!("\"{}\"", suggestion),
-        Applicability::MachineApplicable,
-    );
-}
diff --git a/clippy_lints/src/matches/match_str_case_mismatch.rs b/clippy_lints/src/matches/match_str_case_mismatch.rs
new file mode 100644
index 00000000000..8302ce426e5
--- /dev/null
+++ b/clippy_lints/src/matches/match_str_case_mismatch.rs
@@ -0,0 +1,125 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::ty::is_type_diagnostic_item;
+use rustc_ast::ast::LitKind;
+use rustc_errors::Applicability;
+use rustc_hir::intravisit::{walk_expr, Visitor};
+use rustc_hir::{Arm, Expr, ExprKind, PatKind};
+use rustc_lint::LateContext;
+use rustc_middle::ty;
+use rustc_span::symbol::Symbol;
+use rustc_span::{sym, Span};
+
+use super::MATCH_STR_CASE_MISMATCH;
+
+#[derive(Debug)]
+enum CaseMethod {
+    LowerCase,
+    AsciiLowerCase,
+    UpperCase,
+    AsciiUppercase,
+}
+
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, scrutinee: &'tcx Expr<'_>, arms: &'tcx [Arm<'_>]) {
+    if_chain! {
+        if let ty::Ref(_, ty, _) = cx.typeck_results().expr_ty(scrutinee).kind();
+        if let ty::Str = ty.kind();
+        then {
+            let mut visitor = MatchExprVisitor {
+                cx,
+                case_method: None,
+            };
+
+            visitor.visit_expr(scrutinee);
+
+            if let Some(case_method) = visitor.case_method {
+                if let Some((bad_case_span, bad_case_sym)) = verify_case(&case_method, arms) {
+                    lint(cx, &case_method, bad_case_span, bad_case_sym.as_str());
+                }
+            }
+        }
+    }
+}
+
+struct MatchExprVisitor<'a, 'tcx> {
+    cx: &'a LateContext<'tcx>,
+    case_method: Option<CaseMethod>,
+}
+
+impl<'a, 'tcx> Visitor<'tcx> for MatchExprVisitor<'a, 'tcx> {
+    fn visit_expr(&mut self, ex: &'tcx Expr<'_>) {
+        match ex.kind {
+            ExprKind::MethodCall(segment, [receiver], _) if self.case_altered(segment.ident.as_str(), receiver) => {},
+            _ => walk_expr(self, ex),
+        }
+    }
+}
+
+impl<'a, 'tcx> MatchExprVisitor<'a, 'tcx> {
+    fn case_altered(&mut self, segment_ident: &str, receiver: &Expr<'_>) -> bool {
+        if let Some(case_method) = get_case_method(segment_ident) {
+            let ty = self.cx.typeck_results().expr_ty(receiver).peel_refs();
+
+            if is_type_diagnostic_item(self.cx, ty, sym::String) || ty.kind() == &ty::Str {
+                self.case_method = Some(case_method);
+                return true;
+            }
+        }
+
+        false
+    }
+}
+
+fn get_case_method(segment_ident_str: &str) -> Option<CaseMethod> {
+    match segment_ident_str {
+        "to_lowercase" => Some(CaseMethod::LowerCase),
+        "to_ascii_lowercase" => Some(CaseMethod::AsciiLowerCase),
+        "to_uppercase" => Some(CaseMethod::UpperCase),
+        "to_ascii_uppercase" => Some(CaseMethod::AsciiUppercase),
+        _ => None,
+    }
+}
+
+fn verify_case<'a>(case_method: &'a CaseMethod, arms: &'a [Arm<'_>]) -> Option<(Span, Symbol)> {
+    let case_check = match case_method {
+        CaseMethod::LowerCase => |input: &str| -> bool { input.chars().all(|c| c.to_lowercase().next() == Some(c)) },
+        CaseMethod::AsciiLowerCase => |input: &str| -> bool { !input.chars().any(|c| c.is_ascii_uppercase()) },
+        CaseMethod::UpperCase => |input: &str| -> bool { input.chars().all(|c| c.to_uppercase().next() == Some(c)) },
+        CaseMethod::AsciiUppercase => |input: &str| -> bool { !input.chars().any(|c| c.is_ascii_lowercase()) },
+    };
+
+    for arm in arms {
+        if_chain! {
+            if let PatKind::Lit(Expr {
+                                kind: ExprKind::Lit(lit),
+                                ..
+                            }) = arm.pat.kind;
+            if let LitKind::Str(symbol, _) = lit.node;
+            let input = symbol.as_str();
+            if !case_check(input);
+            then {
+                return Some((lit.span, symbol));
+            }
+        }
+    }
+
+    None
+}
+
+fn lint(cx: &LateContext<'_>, case_method: &CaseMethod, bad_case_span: Span, bad_case_str: &str) {
+    let (method_str, suggestion) = match case_method {
+        CaseMethod::LowerCase => ("to_lowercase", bad_case_str.to_lowercase()),
+        CaseMethod::AsciiLowerCase => ("to_ascii_lowercase", bad_case_str.to_ascii_lowercase()),
+        CaseMethod::UpperCase => ("to_uppercase", bad_case_str.to_uppercase()),
+        CaseMethod::AsciiUppercase => ("to_ascii_uppercase", bad_case_str.to_ascii_uppercase()),
+    };
+
+    span_lint_and_sugg(
+        cx,
+        MATCH_STR_CASE_MISMATCH,
+        bad_case_span,
+        "this `match` arm has a differing case than its expression",
+        &*format!("consider changing the case of this arm to respect `{}`", method_str),
+        format!("\"{}\"", suggestion),
+        Applicability::MachineApplicable,
+    );
+}
diff --git a/clippy_lints/src/matches/mod.rs b/clippy_lints/src/matches/mod.rs
index 7fb449028e7..a58c71ca5f8 100644
--- a/clippy_lints/src/matches/mod.rs
+++ b/clippy_lints/src/matches/mod.rs
@@ -18,6 +18,7 @@ mod match_on_vec_items;
 mod match_ref_pats;
 mod match_same_arms;
 mod match_single_binding;
+mod match_str_case_mismatch;
 mod match_wild_enum;
 mod match_wild_err_arm;
 mod needless_match;
@@ -716,6 +717,37 @@ declare_clippy_lint! {
     "matching on vector elements can panic"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `match` expressions modifying the case of a string with non-compliant arms
+    ///
+    /// ### Why is this bad?
+    /// The arm is unreachable, which is likely a mistake
+    ///
+    /// ### Example
+    /// ```rust
+    /// # let text = "Foo";
+    /// match &*text.to_ascii_lowercase() {
+    ///     "foo" => {},
+    ///     "Bar" => {},
+    ///     _ => {},
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// # let text = "Foo";
+    /// match &*text.to_ascii_lowercase() {
+    ///     "foo" => {},
+    ///     "bar" => {},
+    ///     _ => {},
+    /// }
+    /// ```
+    #[clippy::version = "1.58.0"]
+    pub MATCH_STR_CASE_MISMATCH,
+    correctness,
+    "creation of a case altering match expression with non-compliant arms"
+}
+
 #[derive(Default)]
 pub struct Matches {
     msrv: Option<RustcVersion>,
@@ -753,6 +785,7 @@ impl_lint_pass!(Matches => [
     COLLAPSIBLE_MATCH,
     MANUAL_UNWRAP_OR,
     MATCH_ON_VEC_ITEMS,
+    MATCH_STR_CASE_MISMATCH,
 ]);
 
 impl<'tcx> LateLintPass<'tcx> for Matches {
@@ -790,6 +823,7 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
                     match_as_ref::check(cx, ex, arms, expr);
                     needless_match::check_match(cx, ex, arms, expr);
                     match_on_vec_items::check(cx, ex);
+                    match_str_case_mismatch::check(cx, ex, arms);
 
                     if !in_constant(cx, expr.hir_id) {
                         manual_unwrap_or::check(cx, expr, ex, arms);
-- 
cgit 1.4.1-3-g733a5


From dbc7753fb2b5e1af5c00f3c1e246cfd594611c75 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Fri, 3 Jun 2022 13:35:10 -0400
Subject: Merge `SignificantDropInScrutinee` into `Matches` lint pass

---
 clippy_lints/src/lib.register_all.rs               |   2 +-
 clippy_lints/src/lib.register_lints.rs             |   2 +-
 clippy_lints/src/lib.register_suspicious.rs        |   2 +-
 clippy_lints/src/lib.rs                            |   2 -
 clippy_lints/src/matches/mod.rs                    |  83 +++-
 .../src/matches/significant_drop_in_scrutinee.rs   | 332 ++++++++++++++++
 clippy_lints/src/significant_drop_in_scrutinee.rs  | 416 ---------------------
 7 files changed, 417 insertions(+), 422 deletions(-)
 create mode 100644 clippy_lints/src/matches/significant_drop_in_scrutinee.rs
 delete mode 100644 clippy_lints/src/significant_drop_in_scrutinee.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 15e744229a1..435c0829a67 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -151,6 +151,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(matches::MATCH_STR_CASE_MISMATCH),
     LintId::of(matches::NEEDLESS_MATCH),
     LintId::of(matches::REDUNDANT_PATTERN_MATCHING),
+    LintId::of(matches::SIGNIFICANT_DROP_IN_SCRUTINEE),
     LintId::of(matches::SINGLE_MATCH),
     LintId::of(matches::WILDCARD_IN_OR_PATTERNS),
     LintId::of(mem_replace::MEM_REPLACE_OPTION_WITH_NONE),
@@ -282,7 +283,6 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(self_assignment::SELF_ASSIGNMENT),
     LintId::of(self_named_constructors::SELF_NAMED_CONSTRUCTORS),
     LintId::of(serde_api::SERDE_API_MISUSE),
-    LintId::of(significant_drop_in_scrutinee::SIGNIFICANT_DROP_IN_SCRUTINEE),
     LintId::of(single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS),
     LintId::of(size_of_in_element_count::SIZE_OF_IN_ELEMENT_COUNT),
     LintId::of(slow_vector_initialization::SLOW_VECTOR_INITIALIZATION),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 59ba295a887..7fc6ff8a2fb 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -276,6 +276,7 @@ store.register_lints(&[
     matches::NEEDLESS_MATCH,
     matches::REDUNDANT_PATTERN_MATCHING,
     matches::REST_PAT_IN_FULLY_BOUND_STRUCTS,
+    matches::SIGNIFICANT_DROP_IN_SCRUTINEE,
     matches::SINGLE_MATCH,
     matches::SINGLE_MATCH_ELSE,
     matches::WILDCARD_ENUM_MATCH_ARM,
@@ -479,7 +480,6 @@ store.register_lints(&[
     shadow::SHADOW_REUSE,
     shadow::SHADOW_SAME,
     shadow::SHADOW_UNRELATED,
-    significant_drop_in_scrutinee::SIGNIFICANT_DROP_IN_SCRUTINEE,
     single_char_lifetime_names::SINGLE_CHAR_LIFETIME_NAMES,
     single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS,
     size_of_in_element_count::SIZE_OF_IN_ELEMENT_COUNT,
diff --git a/clippy_lints/src/lib.register_suspicious.rs b/clippy_lints/src/lib.register_suspicious.rs
index 43ced5070f1..7b13713c36e 100644
--- a/clippy_lints/src/lib.register_suspicious.rs
+++ b/clippy_lints/src/lib.register_suspicious.rs
@@ -24,12 +24,12 @@ store.register_group(true, "clippy::suspicious", Some("clippy_suspicious"), vec!
     LintId::of(loops::EMPTY_LOOP),
     LintId::of(loops::FOR_LOOPS_OVER_FALLIBLES),
     LintId::of(loops::MUT_RANGE_BOUND),
+    LintId::of(matches::SIGNIFICANT_DROP_IN_SCRUTINEE),
     LintId::of(methods::NO_EFFECT_REPLACE),
     LintId::of(methods::SUSPICIOUS_MAP),
     LintId::of(mut_key::MUTABLE_KEY_TYPE),
     LintId::of(octal_escapes::OCTAL_ESCAPES),
     LintId::of(rc_clone_in_vec_init::RC_CLONE_IN_VEC_INIT),
-    LintId::of(significant_drop_in_scrutinee::SIGNIFICANT_DROP_IN_SCRUTINEE),
     LintId::of(suspicious_trait_impl::SUSPICIOUS_ARITHMETIC_IMPL),
     LintId::of(suspicious_trait_impl::SUSPICIOUS_OP_ASSIGN_IMPL),
     LintId::of(swap_ptr_to_ref::SWAP_PTR_TO_REF),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 7335b4a35c8..742409d758b 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -367,7 +367,6 @@ mod self_named_constructors;
 mod semicolon_if_nothing_returned;
 mod serde_api;
 mod shadow;
-mod significant_drop_in_scrutinee;
 mod single_char_lifetime_names;
 mod single_component_path_imports;
 mod size_of_in_element_count;
@@ -886,7 +885,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(default_union_representation::DefaultUnionRepresentation));
     store.register_early_pass(|| Box::new(doc_link_with_quotes::DocLinkWithQuotes));
     store.register_late_pass(|| Box::new(only_used_in_recursion::OnlyUsedInRecursion));
-    store.register_late_pass(|| Box::new(significant_drop_in_scrutinee::SignificantDropInScrutinee));
     let allow_dbg_in_tests = conf.allow_dbg_in_tests;
     store.register_late_pass(move || Box::new(dbg_macro::DbgMacro::new(allow_dbg_in_tests)));
     let cargo_ignore_publish = conf.cargo_ignore_publish;
diff --git a/clippy_lints/src/matches/mod.rs b/clippy_lints/src/matches/mod.rs
index a58c71ca5f8..3c0dc8041d8 100644
--- a/clippy_lints/src/matches/mod.rs
+++ b/clippy_lints/src/matches/mod.rs
@@ -25,6 +25,7 @@ mod needless_match;
 mod overlapping_arms;
 mod redundant_pattern_match;
 mod rest_pat_in_fully_bound_struct;
+mod significant_drop_in_scrutinee;
 mod single_match;
 mod wild_in_or_pats;
 
@@ -748,6 +749,82 @@ declare_clippy_lint! {
     "creation of a case altering match expression with non-compliant arms"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Check for temporaries returned from function calls in a match scrutinee that have the
+    /// `clippy::has_significant_drop` attribute.
+    ///
+    /// ### Why is this bad?
+    /// The `clippy::has_significant_drop` attribute can be added to types whose Drop impls have
+    /// an important side-effect, such as unlocking a mutex, making it important for users to be
+    /// able to accurately understand their lifetimes. When a temporary is returned in a function
+    /// call in a match scrutinee, its lifetime lasts until the end of the match block, which may
+    /// be surprising.
+    ///
+    /// For `Mutex`es this can lead to a deadlock. This happens when the match scrutinee uses a
+    /// function call that returns a `MutexGuard` and then tries to lock again in one of the match
+    /// arms. In that case the `MutexGuard` in the scrutinee will not be dropped until the end of
+    /// the match block and thus will not unlock.
+    ///
+    /// ### Example
+    /// ```rust.ignore
+    /// # use std::sync::Mutex;
+    ///
+    /// # struct State {}
+    ///
+    /// # impl State {
+    /// #     fn foo(&self) -> bool {
+    /// #         true
+    /// #     }
+    ///
+    /// #     fn bar(&self) {}
+    /// # }
+    ///
+    ///
+    /// let mutex = Mutex::new(State {});
+    ///
+    /// match mutex.lock().unwrap().foo() {
+    ///     true => {
+    ///         mutex.lock().unwrap().bar(); // Deadlock!
+    ///     }
+    ///     false => {}
+    /// };
+    ///
+    /// println!("All done!");
+    ///
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// # use std::sync::Mutex;
+    ///
+    /// # struct State {}
+    ///
+    /// # impl State {
+    /// #     fn foo(&self) -> bool {
+    /// #         true
+    /// #     }
+    ///
+    /// #     fn bar(&self) {}
+    /// # }
+    ///
+    /// let mutex = Mutex::new(State {});
+    ///
+    /// let is_foo = mutex.lock().unwrap().foo();
+    /// match is_foo {
+    ///     true => {
+    ///         mutex.lock().unwrap().bar();
+    ///     }
+    ///     false => {}
+    /// };
+    ///
+    /// println!("All done!");
+    /// ```
+    #[clippy::version = "1.60.0"]
+    pub SIGNIFICANT_DROP_IN_SCRUTINEE,
+    suspicious,
+    "warns when a temporary of a type with a drop with a significant side-effect might have a surprising lifetime"
+}
+
 #[derive(Default)]
 pub struct Matches {
     msrv: Option<RustcVersion>,
@@ -786,6 +863,7 @@ impl_lint_pass!(Matches => [
     MANUAL_UNWRAP_OR,
     MATCH_ON_VEC_ITEMS,
     MATCH_STR_CASE_MISMATCH,
+    SIGNIFICANT_DROP_IN_SCRUTINEE,
 ]);
 
 impl<'tcx> LateLintPass<'tcx> for Matches {
@@ -796,9 +874,12 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
         let from_expansion = expr.span.from_expansion();
 
         if let ExprKind::Match(ex, arms, source) = expr.kind {
-            if !span_starts_with(cx, expr.span, "match") {
+            if source == MatchSource::Normal && !span_starts_with(cx, expr.span, "match") {
                 return;
             }
+            if matches!(source, MatchSource::Normal | MatchSource::ForLoopDesugar) {
+                significant_drop_in_scrutinee::check(cx, expr, ex, source);
+            }
 
             collapsible_match::check_match(cx, arms);
             if !from_expansion {
diff --git a/clippy_lints/src/matches/significant_drop_in_scrutinee.rs b/clippy_lints/src/matches/significant_drop_in_scrutinee.rs
new file mode 100644
index 00000000000..a211dc18f9e
--- /dev/null
+++ b/clippy_lints/src/matches/significant_drop_in_scrutinee.rs
@@ -0,0 +1,332 @@
+use crate::FxHashSet;
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::get_attr;
+use clippy_utils::source::{indent_of, snippet};
+use rustc_errors::{Applicability, Diagnostic};
+use rustc_hir::intravisit::{walk_expr, Visitor};
+use rustc_hir::{Expr, ExprKind, MatchSource};
+use rustc_lint::{LateContext, LintContext};
+use rustc_middle::ty::subst::GenericArgKind;
+use rustc_middle::ty::{Ty, TypeAndMut};
+use rustc_span::Span;
+
+use super::SIGNIFICANT_DROP_IN_SCRUTINEE;
+
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx Expr<'tcx>,
+    scrutinee: &'tcx Expr<'_>,
+    source: MatchSource,
+) {
+    if let Some((suggestions, message)) = has_significant_drop_in_scrutinee(cx, scrutinee, source) {
+        for found in suggestions {
+            span_lint_and_then(cx, SIGNIFICANT_DROP_IN_SCRUTINEE, found.found_span, message, |diag| {
+                set_diagnostic(diag, cx, expr, found);
+            });
+        }
+    }
+}
+
+fn set_diagnostic<'tcx>(diag: &mut Diagnostic, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, found: FoundSigDrop) {
+    if found.lint_suggestion == LintSuggestion::MoveAndClone {
+        // If our suggestion is to move and clone, then we want to leave it to the user to
+        // decide how to address this lint, since it may be that cloning is inappropriate.
+        // Therefore, we won't to emit a suggestion.
+        return;
+    }
+
+    let original = snippet(cx, found.found_span, "..");
+    let trailing_indent = " ".repeat(indent_of(cx, found.found_span).unwrap_or(0));
+
+    let replacement = if found.lint_suggestion == LintSuggestion::MoveAndDerefToCopy {
+        format!("let value = *{};\n{}", original, trailing_indent)
+    } else if found.is_unit_return_val {
+        // If the return value of the expression to be moved is unit, then we don't need to
+        // capture the result in a temporary -- we can just replace it completely with `()`.
+        format!("{};\n{}", original, trailing_indent)
+    } else {
+        format!("let value = {};\n{}", original, trailing_indent)
+    };
+
+    let suggestion_message = if found.lint_suggestion == LintSuggestion::MoveOnly {
+        "try moving the temporary above the match"
+    } else {
+        "try moving the temporary above the match and create a copy"
+    };
+
+    let scrutinee_replacement = if found.is_unit_return_val {
+        "()".to_owned()
+    } else {
+        "value".to_owned()
+    };
+
+    diag.multipart_suggestion(
+        suggestion_message,
+        vec![
+            (expr.span.shrink_to_lo(), replacement),
+            (found.found_span, scrutinee_replacement),
+        ],
+        Applicability::MaybeIncorrect,
+    );
+}
+
+/// If the expression is an `ExprKind::Match`, check if the scrutinee has a significant drop that
+/// may have a surprising lifetime.
+fn has_significant_drop_in_scrutinee<'tcx, 'a>(
+    cx: &'a LateContext<'tcx>,
+    scrutinee: &'tcx Expr<'tcx>,
+    source: MatchSource,
+) -> Option<(Vec<FoundSigDrop>, &'static str)> {
+    let mut helper = SigDropHelper::new(cx);
+    helper.find_sig_drop(scrutinee).map(|drops| {
+        let message = if source == MatchSource::Normal {
+            "temporary with significant drop in match scrutinee"
+        } else {
+            "temporary with significant drop in for loop"
+        };
+        (drops, message)
+    })
+}
+
+struct SigDropHelper<'a, 'tcx> {
+    cx: &'a LateContext<'tcx>,
+    is_chain_end: bool,
+    seen_types: FxHashSet<Ty<'tcx>>,
+    has_significant_drop: bool,
+    current_sig_drop: Option<FoundSigDrop>,
+    sig_drop_spans: Option<Vec<FoundSigDrop>>,
+    special_handling_for_binary_op: bool,
+}
+
+#[expect(clippy::enum_variant_names)]
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+enum LintSuggestion {
+    MoveOnly,
+    MoveAndDerefToCopy,
+    MoveAndClone,
+}
+
+#[derive(Clone, Copy)]
+struct FoundSigDrop {
+    found_span: Span,
+    is_unit_return_val: bool,
+    lint_suggestion: LintSuggestion,
+}
+
+impl<'a, 'tcx> SigDropHelper<'a, 'tcx> {
+    fn new(cx: &'a LateContext<'tcx>) -> SigDropHelper<'a, 'tcx> {
+        SigDropHelper {
+            cx,
+            is_chain_end: true,
+            seen_types: FxHashSet::default(),
+            has_significant_drop: false,
+            current_sig_drop: None,
+            sig_drop_spans: None,
+            special_handling_for_binary_op: false,
+        }
+    }
+
+    fn find_sig_drop(&mut self, match_expr: &'tcx Expr<'_>) -> Option<Vec<FoundSigDrop>> {
+        self.visit_expr(match_expr);
+
+        // If sig drop spans is empty but we found a significant drop, it means that we didn't find
+        // a type that was trivially copyable as we moved up the chain after finding a significant
+        // drop, so move the entire scrutinee.
+        if self.has_significant_drop && self.sig_drop_spans.is_none() {
+            self.try_setting_current_suggestion(match_expr, true);
+            self.move_current_suggestion();
+        }
+
+        self.sig_drop_spans.take()
+    }
+
+    fn replace_current_sig_drop(
+        &mut self,
+        found_span: Span,
+        is_unit_return_val: bool,
+        lint_suggestion: LintSuggestion,
+    ) {
+        self.current_sig_drop.replace(FoundSigDrop {
+            found_span,
+            is_unit_return_val,
+            lint_suggestion,
+        });
+    }
+
+    /// This will try to set the current suggestion (so it can be moved into the suggestions vec
+    /// later). If `allow_move_and_clone` is false, the suggestion *won't* be set -- this gives us
+    /// an opportunity to look for another type in the chain that will be trivially copyable.
+    /// However, if we are at the the end of the chain, we want to accept whatever is there. (The
+    /// suggestion won't actually be output, but the diagnostic message will be output, so the user
+    /// can determine the best way to handle the lint.)
+    fn try_setting_current_suggestion(&mut self, expr: &'tcx Expr<'_>, allow_move_and_clone: bool) {
+        if self.current_sig_drop.is_some() {
+            return;
+        }
+        let ty = self.get_type(expr);
+        if ty.is_ref() {
+            // We checked that the type was ref, so builtin_deref will return Some TypeAndMut,
+            // but let's avoid any chance of an ICE
+            if let Some(TypeAndMut { ty, .. }) = ty.builtin_deref(true) {
+                if ty.is_trivially_pure_clone_copy() {
+                    self.replace_current_sig_drop(expr.span, false, LintSuggestion::MoveAndDerefToCopy);
+                } else if allow_move_and_clone {
+                    self.replace_current_sig_drop(expr.span, false, LintSuggestion::MoveAndClone);
+                }
+            }
+        } else if ty.is_trivially_pure_clone_copy() {
+            self.replace_current_sig_drop(expr.span, false, LintSuggestion::MoveOnly);
+        } else if allow_move_and_clone {
+            self.replace_current_sig_drop(expr.span, false, LintSuggestion::MoveAndClone);
+        }
+    }
+
+    fn move_current_suggestion(&mut self) {
+        if let Some(current) = self.current_sig_drop.take() {
+            self.sig_drop_spans.get_or_insert_with(Vec::new).push(current);
+        }
+    }
+
+    fn get_type(&self, ex: &'tcx Expr<'_>) -> Ty<'tcx> {
+        self.cx.typeck_results().expr_ty(ex)
+    }
+
+    fn has_seen_type(&mut self, ty: Ty<'tcx>) -> bool {
+        !self.seen_types.insert(ty)
+    }
+
+    fn visit_exprs_for_binary_ops(
+        &mut self,
+        left: &'tcx Expr<'_>,
+        right: &'tcx Expr<'_>,
+        is_unit_return_val: bool,
+        span: Span,
+    ) {
+        self.special_handling_for_binary_op = true;
+        self.visit_expr(left);
+        self.visit_expr(right);
+
+        // If either side had a significant drop, suggest moving the entire scrutinee to avoid
+        // unnecessary copies and to simplify cases where both sides have significant drops.
+        if self.has_significant_drop {
+            self.replace_current_sig_drop(span, is_unit_return_val, LintSuggestion::MoveOnly);
+        }
+
+        self.special_handling_for_binary_op = false;
+    }
+
+    fn has_sig_drop_attr(&mut self, cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
+        if let Some(adt) = ty.ty_adt_def() {
+            if get_attr(cx.sess(), cx.tcx.get_attrs_unchecked(adt.did()), "has_significant_drop").count() > 0 {
+                return true;
+            }
+        }
+
+        match ty.kind() {
+            rustc_middle::ty::Adt(a, b) => {
+                for f in a.all_fields() {
+                    let ty = f.ty(cx.tcx, b);
+                    if !self.has_seen_type(ty) && self.has_sig_drop_attr(cx, ty) {
+                        return true;
+                    }
+                }
+
+                for generic_arg in b.iter() {
+                    if let GenericArgKind::Type(ty) = generic_arg.unpack() {
+                        if self.has_sig_drop_attr(cx, ty) {
+                            return true;
+                        }
+                    }
+                }
+                false
+            },
+            rustc_middle::ty::Array(ty, _)
+            | rustc_middle::ty::RawPtr(TypeAndMut { ty, .. })
+            | rustc_middle::ty::Ref(_, ty, _)
+            | rustc_middle::ty::Slice(ty) => self.has_sig_drop_attr(cx, *ty),
+            _ => false,
+        }
+    }
+}
+
+impl<'a, 'tcx> Visitor<'tcx> for SigDropHelper<'a, 'tcx> {
+    fn visit_expr(&mut self, ex: &'tcx Expr<'_>) {
+        if !self.is_chain_end && self.has_sig_drop_attr(self.cx, self.get_type(ex)) {
+            self.has_significant_drop = true;
+            return;
+        }
+        self.is_chain_end = false;
+
+        match ex.kind {
+            ExprKind::MethodCall(_, [ref expr, ..], _) => {
+                self.visit_expr(expr);
+            }
+            ExprKind::Binary(_, left, right) => {
+                self.visit_exprs_for_binary_ops(left, right, false, ex.span);
+            }
+            ExprKind::Assign(left, right, _) | ExprKind::AssignOp(_, left, right) => {
+                self.visit_exprs_for_binary_ops(left, right, true, ex.span);
+            }
+            ExprKind::Tup(exprs) => {
+                for expr in exprs {
+                    self.visit_expr(expr);
+                    if self.has_significant_drop {
+                        // We may have not have set current_sig_drop if all the suggestions were
+                        // MoveAndClone, so add this tuple item's full expression in that case.
+                        if self.current_sig_drop.is_none() {
+                            self.try_setting_current_suggestion(expr, true);
+                        }
+
+                        // Now we are guaranteed to have something, so add it to the final vec.
+                        self.move_current_suggestion();
+                    }
+                    // Reset `has_significant_drop` after each tuple expression so we can look for
+                    // additional cases.
+                    self.has_significant_drop = false;
+                }
+                if self.sig_drop_spans.is_some() {
+                    self.has_significant_drop = true;
+                }
+            }
+            ExprKind::Box(..) |
+            ExprKind::Array(..) |
+            ExprKind::Call(..) |
+            ExprKind::Unary(..) |
+            ExprKind::If(..) |
+            ExprKind::Match(..) |
+            ExprKind::Field(..) |
+            ExprKind::Index(..) |
+            ExprKind::Ret(..) |
+            ExprKind::Repeat(..) |
+            ExprKind::Yield(..) |
+            ExprKind::MethodCall(..) => walk_expr(self, ex),
+            ExprKind::AddrOf(_, _, _) |
+            ExprKind::Block(_, _) |
+            ExprKind::Break(_, _) |
+            ExprKind::Cast(_, _) |
+            // Don't want to check the closure itself, only invocation, which is covered by MethodCall
+            ExprKind::Closure(_, _, _, _, _) |
+            ExprKind::ConstBlock(_) |
+            ExprKind::Continue(_) |
+            ExprKind::DropTemps(_) |
+            ExprKind::Err |
+            ExprKind::InlineAsm(_) |
+            ExprKind::Let(_) |
+            ExprKind::Lit(_) |
+            ExprKind::Loop(_, _, _, _) |
+            ExprKind::Path(_) |
+            ExprKind::Struct(_, _, _) |
+            ExprKind::Type(_, _) => {
+                return;
+            }
+        }
+
+        // Once a significant temporary has been found, we need to go back up at least 1 level to
+        // find the span to extract for replacement, so the temporary gets dropped. However, for
+        // binary ops, we want to move the whole scrutinee so we avoid unnecessary copies and to
+        // simplify cases where both sides have significant drops.
+        if self.has_significant_drop && !self.special_handling_for_binary_op {
+            self.try_setting_current_suggestion(ex, false);
+        }
+    }
+}
diff --git a/clippy_lints/src/significant_drop_in_scrutinee.rs b/clippy_lints/src/significant_drop_in_scrutinee.rs
deleted file mode 100644
index 2f7819cb470..00000000000
--- a/clippy_lints/src/significant_drop_in_scrutinee.rs
+++ /dev/null
@@ -1,416 +0,0 @@
-use crate::FxHashSet;
-use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::get_attr;
-use clippy_utils::source::{indent_of, snippet};
-use rustc_errors::{Applicability, Diagnostic};
-use rustc_hir::intravisit::{walk_expr, Visitor};
-use rustc_hir::{Expr, ExprKind, MatchSource};
-use rustc_lint::{LateContext, LateLintPass, LintContext};
-use rustc_middle::ty::subst::GenericArgKind;
-use rustc_middle::ty::{Ty, TypeAndMut};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::Span;
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Check for temporaries returned from function calls in a match scrutinee that have the
-    /// `clippy::has_significant_drop` attribute.
-    ///
-    /// ### Why is this bad?
-    /// The `clippy::has_significant_drop` attribute can be added to types whose Drop impls have
-    /// an important side-effect, such as unlocking a mutex, making it important for users to be
-    /// able to accurately understand their lifetimes. When a temporary is returned in a function
-    /// call in a match scrutinee, its lifetime lasts until the end of the match block, which may
-    /// be surprising.
-    ///
-    /// For `Mutex`es this can lead to a deadlock. This happens when the match scrutinee uses a
-    /// function call that returns a `MutexGuard` and then tries to lock again in one of the match
-    /// arms. In that case the `MutexGuard` in the scrutinee will not be dropped until the end of
-    /// the match block and thus will not unlock.
-    ///
-    /// ### Example
-    /// ```rust.ignore
-    /// # use std::sync::Mutex;
-    ///
-    /// # struct State {}
-    ///
-    /// # impl State {
-    /// #     fn foo(&self) -> bool {
-    /// #         true
-    /// #     }
-    ///
-    /// #     fn bar(&self) {}
-    /// # }
-    ///
-    ///
-    /// let mutex = Mutex::new(State {});
-    ///
-    /// match mutex.lock().unwrap().foo() {
-    ///     true => {
-    ///         mutex.lock().unwrap().bar(); // Deadlock!
-    ///     }
-    ///     false => {}
-    /// };
-    ///
-    /// println!("All done!");
-    ///
-    /// ```
-    /// Use instead:
-    /// ```rust
-    /// # use std::sync::Mutex;
-    ///
-    /// # struct State {}
-    ///
-    /// # impl State {
-    /// #     fn foo(&self) -> bool {
-    /// #         true
-    /// #     }
-    ///
-    /// #     fn bar(&self) {}
-    /// # }
-    ///
-    /// let mutex = Mutex::new(State {});
-    ///
-    /// let is_foo = mutex.lock().unwrap().foo();
-    /// match is_foo {
-    ///     true => {
-    ///         mutex.lock().unwrap().bar();
-    ///     }
-    ///     false => {}
-    /// };
-    ///
-    /// println!("All done!");
-    /// ```
-    #[clippy::version = "1.60.0"]
-    pub SIGNIFICANT_DROP_IN_SCRUTINEE,
-    suspicious,
-    "warns when a temporary of a type with a drop with a significant side-effect might have a surprising lifetime"
-}
-
-declare_lint_pass!(SignificantDropInScrutinee => [SIGNIFICANT_DROP_IN_SCRUTINEE]);
-
-impl<'tcx> LateLintPass<'tcx> for SignificantDropInScrutinee {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
-        if let Some((suggestions, message)) = has_significant_drop_in_scrutinee(cx, expr) {
-            for found in suggestions {
-                span_lint_and_then(cx, SIGNIFICANT_DROP_IN_SCRUTINEE, found.found_span, message, |diag| {
-                    set_diagnostic(diag, cx, expr, found);
-                });
-            }
-        }
-    }
-}
-
-fn set_diagnostic<'tcx>(diag: &mut Diagnostic, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, found: FoundSigDrop) {
-    if found.lint_suggestion == LintSuggestion::MoveAndClone {
-        // If our suggestion is to move and clone, then we want to leave it to the user to
-        // decide how to address this lint, since it may be that cloning is inappropriate.
-        // Therefore, we won't to emit a suggestion.
-        return;
-    }
-
-    let original = snippet(cx, found.found_span, "..");
-    let trailing_indent = " ".repeat(indent_of(cx, found.found_span).unwrap_or(0));
-
-    let replacement = if found.lint_suggestion == LintSuggestion::MoveAndDerefToCopy {
-        format!("let value = *{};\n{}", original, trailing_indent)
-    } else if found.is_unit_return_val {
-        // If the return value of the expression to be moved is unit, then we don't need to
-        // capture the result in a temporary -- we can just replace it completely with `()`.
-        format!("{};\n{}", original, trailing_indent)
-    } else {
-        format!("let value = {};\n{}", original, trailing_indent)
-    };
-
-    let suggestion_message = if found.lint_suggestion == LintSuggestion::MoveOnly {
-        "try moving the temporary above the match"
-    } else {
-        "try moving the temporary above the match and create a copy"
-    };
-
-    let scrutinee_replacement = if found.is_unit_return_val {
-        "()".to_owned()
-    } else {
-        "value".to_owned()
-    };
-
-    diag.multipart_suggestion(
-        suggestion_message,
-        vec![
-            (expr.span.shrink_to_lo(), replacement),
-            (found.found_span, scrutinee_replacement),
-        ],
-        Applicability::MaybeIncorrect,
-    );
-}
-
-/// If the expression is an `ExprKind::Match`, check if the scrutinee has a significant drop that
-/// may have a surprising lifetime.
-fn has_significant_drop_in_scrutinee<'tcx, 'a>(
-    cx: &'a LateContext<'tcx>,
-    expr: &'tcx Expr<'tcx>,
-) -> Option<(Vec<FoundSigDrop>, &'static str)> {
-    match expr.kind {
-        ExprKind::Match(match_expr, _, source) => {
-            match source {
-                MatchSource::Normal | MatchSource::ForLoopDesugar => {
-                    let mut helper = SigDropHelper::new(cx);
-                    helper.find_sig_drop(match_expr).map(|drops| {
-                        let message = if source == MatchSource::Normal {
-                            "temporary with significant drop in match scrutinee"
-                        } else {
-                            "temporary with significant drop in for loop"
-                        };
-                        (drops, message)
-                    })
-                },
-                // MatchSource of TryDesugar or AwaitDesugar is out of scope for this lint
-                MatchSource::TryDesugar | MatchSource::AwaitDesugar => None,
-            }
-        },
-        _ => None,
-    }
-}
-
-struct SigDropHelper<'a, 'tcx> {
-    cx: &'a LateContext<'tcx>,
-    is_chain_end: bool,
-    seen_types: FxHashSet<Ty<'tcx>>,
-    has_significant_drop: bool,
-    current_sig_drop: Option<FoundSigDrop>,
-    sig_drop_spans: Option<Vec<FoundSigDrop>>,
-    special_handling_for_binary_op: bool,
-}
-
-#[expect(clippy::enum_variant_names)]
-#[derive(Debug, PartialEq, Eq, Clone, Copy)]
-enum LintSuggestion {
-    MoveOnly,
-    MoveAndDerefToCopy,
-    MoveAndClone,
-}
-
-#[derive(Clone, Copy)]
-struct FoundSigDrop {
-    found_span: Span,
-    is_unit_return_val: bool,
-    lint_suggestion: LintSuggestion,
-}
-
-impl<'a, 'tcx> SigDropHelper<'a, 'tcx> {
-    fn new(cx: &'a LateContext<'tcx>) -> SigDropHelper<'a, 'tcx> {
-        SigDropHelper {
-            cx,
-            is_chain_end: true,
-            seen_types: FxHashSet::default(),
-            has_significant_drop: false,
-            current_sig_drop: None,
-            sig_drop_spans: None,
-            special_handling_for_binary_op: false,
-        }
-    }
-
-    fn find_sig_drop(&mut self, match_expr: &'tcx Expr<'_>) -> Option<Vec<FoundSigDrop>> {
-        self.visit_expr(match_expr);
-
-        // If sig drop spans is empty but we found a significant drop, it means that we didn't find
-        // a type that was trivially copyable as we moved up the chain after finding a significant
-        // drop, so move the entire scrutinee.
-        if self.has_significant_drop && self.sig_drop_spans.is_none() {
-            self.try_setting_current_suggestion(match_expr, true);
-            self.move_current_suggestion();
-        }
-
-        self.sig_drop_spans.take()
-    }
-
-    fn replace_current_sig_drop(
-        &mut self,
-        found_span: Span,
-        is_unit_return_val: bool,
-        lint_suggestion: LintSuggestion,
-    ) {
-        self.current_sig_drop.replace(FoundSigDrop {
-            found_span,
-            is_unit_return_val,
-            lint_suggestion,
-        });
-    }
-
-    /// This will try to set the current suggestion (so it can be moved into the suggestions vec
-    /// later). If `allow_move_and_clone` is false, the suggestion *won't* be set -- this gives us
-    /// an opportunity to look for another type in the chain that will be trivially copyable.
-    /// However, if we are at the the end of the chain, we want to accept whatever is there. (The
-    /// suggestion won't actually be output, but the diagnostic message will be output, so the user
-    /// can determine the best way to handle the lint.)
-    fn try_setting_current_suggestion(&mut self, expr: &'tcx Expr<'_>, allow_move_and_clone: bool) {
-        if self.current_sig_drop.is_some() {
-            return;
-        }
-        let ty = self.get_type(expr);
-        if ty.is_ref() {
-            // We checked that the type was ref, so builtin_deref will return Some TypeAndMut,
-            // but let's avoid any chance of an ICE
-            if let Some(TypeAndMut { ty, .. }) = ty.builtin_deref(true) {
-                if ty.is_trivially_pure_clone_copy() {
-                    self.replace_current_sig_drop(expr.span, false, LintSuggestion::MoveAndDerefToCopy);
-                } else if allow_move_and_clone {
-                    self.replace_current_sig_drop(expr.span, false, LintSuggestion::MoveAndClone);
-                }
-            }
-        } else if ty.is_trivially_pure_clone_copy() {
-            self.replace_current_sig_drop(expr.span, false, LintSuggestion::MoveOnly);
-        } else if allow_move_and_clone {
-            self.replace_current_sig_drop(expr.span, false, LintSuggestion::MoveAndClone);
-        }
-    }
-
-    fn move_current_suggestion(&mut self) {
-        if let Some(current) = self.current_sig_drop.take() {
-            self.sig_drop_spans.get_or_insert_with(Vec::new).push(current);
-        }
-    }
-
-    fn get_type(&self, ex: &'tcx Expr<'_>) -> Ty<'tcx> {
-        self.cx.typeck_results().expr_ty(ex)
-    }
-
-    fn has_seen_type(&mut self, ty: Ty<'tcx>) -> bool {
-        !self.seen_types.insert(ty)
-    }
-
-    fn visit_exprs_for_binary_ops(
-        &mut self,
-        left: &'tcx Expr<'_>,
-        right: &'tcx Expr<'_>,
-        is_unit_return_val: bool,
-        span: Span,
-    ) {
-        self.special_handling_for_binary_op = true;
-        self.visit_expr(left);
-        self.visit_expr(right);
-
-        // If either side had a significant drop, suggest moving the entire scrutinee to avoid
-        // unnecessary copies and to simplify cases where both sides have significant drops.
-        if self.has_significant_drop {
-            self.replace_current_sig_drop(span, is_unit_return_val, LintSuggestion::MoveOnly);
-        }
-
-        self.special_handling_for_binary_op = false;
-    }
-
-    fn has_sig_drop_attr(&mut self, cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
-        if let Some(adt) = ty.ty_adt_def() {
-            if get_attr(cx.sess(), cx.tcx.get_attrs_unchecked(adt.did()), "has_significant_drop").count() > 0 {
-                return true;
-            }
-        }
-
-        match ty.kind() {
-            rustc_middle::ty::Adt(a, b) => {
-                for f in a.all_fields() {
-                    let ty = f.ty(cx.tcx, b);
-                    if !self.has_seen_type(ty) && self.has_sig_drop_attr(cx, ty) {
-                        return true;
-                    }
-                }
-
-                for generic_arg in b.iter() {
-                    if let GenericArgKind::Type(ty) = generic_arg.unpack() {
-                        if self.has_sig_drop_attr(cx, ty) {
-                            return true;
-                        }
-                    }
-                }
-                false
-            },
-            rustc_middle::ty::Array(ty, _)
-            | rustc_middle::ty::RawPtr(TypeAndMut { ty, .. })
-            | rustc_middle::ty::Ref(_, ty, _)
-            | rustc_middle::ty::Slice(ty) => self.has_sig_drop_attr(cx, *ty),
-            _ => false,
-        }
-    }
-}
-
-impl<'a, 'tcx> Visitor<'tcx> for SigDropHelper<'a, 'tcx> {
-    fn visit_expr(&mut self, ex: &'tcx Expr<'_>) {
-        if !self.is_chain_end && self.has_sig_drop_attr(self.cx, self.get_type(ex)) {
-            self.has_significant_drop = true;
-            return;
-        }
-        self.is_chain_end = false;
-
-        match ex.kind {
-            ExprKind::MethodCall(_, [ref expr, ..], _) => {
-                self.visit_expr(expr);
-            }
-            ExprKind::Binary(_, left, right) => {
-                self.visit_exprs_for_binary_ops(left, right, false, ex.span);
-            }
-            ExprKind::Assign(left, right, _) | ExprKind::AssignOp(_, left, right) => {
-                self.visit_exprs_for_binary_ops(left, right, true, ex.span);
-            }
-            ExprKind::Tup(exprs) => {
-                for expr in exprs {
-                    self.visit_expr(expr);
-                    if self.has_significant_drop {
-                        // We may have not have set current_sig_drop if all the suggestions were
-                        // MoveAndClone, so add this tuple item's full expression in that case.
-                        if self.current_sig_drop.is_none() {
-                            self.try_setting_current_suggestion(expr, true);
-                        }
-
-                        // Now we are guaranteed to have something, so add it to the final vec.
-                        self.move_current_suggestion();
-                    }
-                    // Reset `has_significant_drop` after each tuple expression so we can look for
-                    // additional cases.
-                    self.has_significant_drop = false;
-                }
-                if self.sig_drop_spans.is_some() {
-                    self.has_significant_drop = true;
-                }
-            }
-            ExprKind::Box(..) |
-            ExprKind::Array(..) |
-            ExprKind::Call(..) |
-            ExprKind::Unary(..) |
-            ExprKind::If(..) |
-            ExprKind::Match(..) |
-            ExprKind::Field(..) |
-            ExprKind::Index(..) |
-            ExprKind::Ret(..) |
-            ExprKind::Repeat(..) |
-            ExprKind::Yield(..) |
-            ExprKind::MethodCall(..) => walk_expr(self, ex),
-            ExprKind::AddrOf(_, _, _) |
-            ExprKind::Block(_, _) |
-            ExprKind::Break(_, _) |
-            ExprKind::Cast(_, _) |
-            // Don't want to check the closure itself, only invocation, which is covered by MethodCall
-            ExprKind::Closure(_, _, _, _, _) |
-            ExprKind::ConstBlock(_) |
-            ExprKind::Continue(_) |
-            ExprKind::DropTemps(_) |
-            ExprKind::Err |
-            ExprKind::InlineAsm(_) |
-            ExprKind::Let(_) |
-            ExprKind::Lit(_) |
-            ExprKind::Loop(_, _, _, _) |
-            ExprKind::Path(_) |
-            ExprKind::Struct(_, _, _) |
-            ExprKind::Type(_, _) => {
-                return;
-            }
-        }
-
-        // Once a significant temporary has been found, we need to go back up at least 1 level to
-        // find the span to extract for replacement, so the temporary gets dropped. However, for
-        // binary ops, we want to move the whole scrutinee so we avoid unnecessary copies and to
-        // simplify cases where both sides have significant drops.
-        if self.has_significant_drop && !self.special_handling_for_binary_op {
-            self.try_setting_current_suggestion(ex, false);
-        }
-    }
-}
-- 
cgit 1.4.1-3-g733a5


From 67cb5ec29f0e1adb55f945a8acea20c47f586c56 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Fri, 3 Jun 2022 14:31:36 -0400
Subject: Move `TryErr` into `Matches` lint pass

---
 clippy_lints/src/lib.register_lints.rs       |   2 +-
 clippy_lints/src/lib.register_restriction.rs |   2 +-
 clippy_lints/src/lib.rs                      |   2 -
 clippy_lints/src/matches/mod.rs              |  41 ++++++
 clippy_lints/src/matches/try_err.rs          | 145 +++++++++++++++++++++
 clippy_lints/src/try_err.rs                  | 186 ---------------------------
 6 files changed, 188 insertions(+), 190 deletions(-)
 create mode 100644 clippy_lints/src/matches/try_err.rs
 delete mode 100644 clippy_lints/src/try_err.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 7fc6ff8a2fb..c8cebca89d5 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -279,6 +279,7 @@ store.register_lints(&[
     matches::SIGNIFICANT_DROP_IN_SCRUTINEE,
     matches::SINGLE_MATCH,
     matches::SINGLE_MATCH_ELSE,
+    matches::TRY_ERR,
     matches::WILDCARD_ENUM_MATCH_ARM,
     matches::WILDCARD_IN_OR_PATTERNS,
     mem_forget::MEM_FORGET,
@@ -521,7 +522,6 @@ store.register_lints(&[
     transmute::USELESS_TRANSMUTE,
     transmute::WRONG_TRANSMUTE,
     transmuting_null::TRANSMUTING_NULL,
-    try_err::TRY_ERR,
     types::BORROWED_BOX,
     types::BOX_COLLECTION,
     types::LINKEDLIST,
diff --git a/clippy_lints/src/lib.register_restriction.rs b/clippy_lints/src/lib.register_restriction.rs
index 304b595541a..942a53459fd 100644
--- a/clippy_lints/src/lib.register_restriction.rs
+++ b/clippy_lints/src/lib.register_restriction.rs
@@ -30,6 +30,7 @@ store.register_group(true, "clippy::restriction", Some("clippy_restriction"), ve
     LintId::of(literal_representation::DECIMAL_LITERAL_REPRESENTATION),
     LintId::of(map_err_ignore::MAP_ERR_IGNORE),
     LintId::of(matches::REST_PAT_IN_FULLY_BOUND_STRUCTS),
+    LintId::of(matches::TRY_ERR),
     LintId::of(matches::WILDCARD_ENUM_MATCH_ARM),
     LintId::of(mem_forget::MEM_FORGET),
     LintId::of(methods::CLONE_ON_REF_PTR),
@@ -67,7 +68,6 @@ store.register_group(true, "clippy::restriction", Some("clippy_restriction"), ve
     LintId::of(strings::STRING_SLICE),
     LintId::of(strings::STRING_TO_STRING),
     LintId::of(strings::STR_TO_STRING),
-    LintId::of(try_err::TRY_ERR),
     LintId::of(types::RC_BUFFER),
     LintId::of(types::RC_MUTEX),
     LintId::of(undocumented_unsafe_blocks::UNDOCUMENTED_UNSAFE_BLOCKS),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 742409d758b..d9941d75f78 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -385,7 +385,6 @@ mod trailing_empty_array;
 mod trait_bounds;
 mod transmute;
 mod transmuting_null;
-mod try_err;
 mod types;
 mod undocumented_unsafe_blocks;
 mod unicode;
@@ -700,7 +699,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     );
     store.register_late_pass(move || Box::new(pass_by_ref_or_value));
     store.register_late_pass(|| Box::new(ref_option_ref::RefOptionRef));
-    store.register_late_pass(|| Box::new(try_err::TryErr));
     store.register_late_pass(|| Box::new(bytecount::ByteCount));
     store.register_late_pass(|| Box::new(infinite_iter::InfiniteIter));
     store.register_late_pass(|| Box::new(inline_fn_without_body::InlineFnWithoutBody));
diff --git a/clippy_lints/src/matches/mod.rs b/clippy_lints/src/matches/mod.rs
index 3c0dc8041d8..fee7471f17d 100644
--- a/clippy_lints/src/matches/mod.rs
+++ b/clippy_lints/src/matches/mod.rs
@@ -27,6 +27,7 @@ mod redundant_pattern_match;
 mod rest_pat_in_fully_bound_struct;
 mod significant_drop_in_scrutinee;
 mod single_match;
+mod try_err;
 mod wild_in_or_pats;
 
 declare_clippy_lint! {
@@ -825,6 +826,41 @@ declare_clippy_lint! {
     "warns when a temporary of a type with a drop with a significant side-effect might have a surprising lifetime"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usages of `Err(x)?`.
+    ///
+    /// ### Why is this bad?
+    /// The `?` operator is designed to allow calls that
+    /// can fail to be easily chained. For example, `foo()?.bar()` or
+    /// `foo(bar()?)`. Because `Err(x)?` can't be used that way (it will
+    /// always return), it is more clear to write `return Err(x)`.
+    ///
+    /// ### Example
+    /// ```rust
+    /// fn foo(fail: bool) -> Result<i32, String> {
+    ///     if fail {
+    ///       Err("failed")?;
+    ///     }
+    ///     Ok(0)
+    /// }
+    /// ```
+    /// Could be written:
+    ///
+    /// ```rust
+    /// fn foo(fail: bool) -> Result<i32, String> {
+    ///     if fail {
+    ///       return Err("failed".into());
+    ///     }
+    ///     Ok(0)
+    /// }
+    /// ```
+    #[clippy::version = "1.38.0"]
+    pub TRY_ERR,
+    restriction,
+    "return errors explicitly rather than hiding them behind a `?`"
+}
+
 #[derive(Default)]
 pub struct Matches {
     msrv: Option<RustcVersion>,
@@ -864,6 +900,7 @@ impl_lint_pass!(Matches => [
     MATCH_ON_VEC_ITEMS,
     MATCH_STR_CASE_MISMATCH,
     SIGNIFICANT_DROP_IN_SCRUTINEE,
+    TRY_ERR,
 ]);
 
 impl<'tcx> LateLintPass<'tcx> for Matches {
@@ -888,6 +925,10 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
                 wild_in_or_pats::check(cx, arms);
             }
 
+            if source == MatchSource::TryDesugar {
+                try_err::check(cx, expr, ex);
+            }
+
             if !from_expansion && !contains_cfg_arm(cx, expr, ex, arms) {
                 if source == MatchSource::Normal {
                     if !(meets_msrv(self.msrv, msrvs::MATCHES_MACRO)
diff --git a/clippy_lints/src/matches/try_err.rs b/clippy_lints/src/matches/try_err.rs
new file mode 100644
index 00000000000..0491a0679f3
--- /dev/null
+++ b/clippy_lints/src/matches/try_err.rs
@@ -0,0 +1,145 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::{get_parent_expr, is_lang_ctor, match_def_path, paths};
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir::LangItem::ResultErr;
+use rustc_hir::{Expr, ExprKind, LangItem, MatchSource, QPath};
+use rustc_lint::LateContext;
+use rustc_middle::ty::{self, Ty};
+use rustc_span::{hygiene, sym};
+
+use super::TRY_ERR;
+
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, scrutinee: &'tcx Expr<'_>) {
+    // Looks for a structure like this:
+    // match ::std::ops::Try::into_result(Err(5)) {
+    //     ::std::result::Result::Err(err) =>
+    //         #[allow(unreachable_code)]
+    //         return ::std::ops::Try::from_error(::std::convert::From::from(err)),
+    //     ::std::result::Result::Ok(val) =>
+    //         #[allow(unreachable_code)]
+    //         val,
+    // };
+    if_chain! {
+        if let ExprKind::Call(match_fun, try_args) = scrutinee.kind;
+        if let ExprKind::Path(ref match_fun_path) = match_fun.kind;
+        if matches!(match_fun_path, QPath::LangItem(LangItem::TryTraitBranch, ..));
+        if let Some(try_arg) = try_args.get(0);
+        if let ExprKind::Call(err_fun, err_args) = try_arg.kind;
+        if let Some(err_arg) = err_args.get(0);
+        if let ExprKind::Path(ref err_fun_path) = err_fun.kind;
+        if is_lang_ctor(cx, err_fun_path, ResultErr);
+        if let Some(return_ty) = find_return_type(cx, &expr.kind);
+        then {
+            let prefix;
+            let suffix;
+            let err_ty;
+
+            if let Some(ty) = result_error_type(cx, return_ty) {
+                prefix = "Err(";
+                suffix = ")";
+                err_ty = ty;
+            } else if let Some(ty) = poll_result_error_type(cx, return_ty) {
+                prefix = "Poll::Ready(Err(";
+                suffix = "))";
+                err_ty = ty;
+            } else if let Some(ty) = poll_option_result_error_type(cx, return_ty) {
+                prefix = "Poll::Ready(Some(Err(";
+                suffix = ")))";
+                err_ty = ty;
+            } else {
+                return;
+            };
+
+            let expr_err_ty = cx.typeck_results().expr_ty(err_arg);
+            let span = hygiene::walk_chain(err_arg.span, try_arg.span.ctxt());
+            let mut applicability = Applicability::MachineApplicable;
+            let origin_snippet = snippet_with_applicability(cx, span, "_", &mut applicability);
+            let ret_prefix = if get_parent_expr(cx, expr).map_or(false, |e| matches!(e.kind, ExprKind::Ret(_))) {
+                "" // already returns
+            } else {
+                "return "
+            };
+            let suggestion = if err_ty == expr_err_ty {
+                format!("{}{}{}{}", ret_prefix, prefix, origin_snippet, suffix)
+            } else {
+                format!("{}{}{}.into(){}", ret_prefix, prefix, origin_snippet, suffix)
+            };
+
+            span_lint_and_sugg(
+                cx,
+                TRY_ERR,
+                expr.span,
+                "returning an `Err(_)` with the `?` operator",
+                "try this",
+                suggestion,
+                applicability,
+            );
+        }
+    }
+}
+
+/// Finds function return type by examining return expressions in match arms.
+fn find_return_type<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx ExprKind<'_>) -> Option<Ty<'tcx>> {
+    if let ExprKind::Match(_, arms, MatchSource::TryDesugar) = expr {
+        for arm in arms.iter() {
+            if let ExprKind::Ret(Some(ret)) = arm.body.kind {
+                return Some(cx.typeck_results().expr_ty(ret));
+            }
+        }
+    }
+    None
+}
+
+/// Extracts the error type from Result<T, E>.
+fn result_error_type<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Option<Ty<'tcx>> {
+    if_chain! {
+        if let ty::Adt(_, subst) = ty.kind();
+        if is_type_diagnostic_item(cx, ty, sym::Result);
+        then {
+            Some(subst.type_at(1))
+        } else {
+            None
+        }
+    }
+}
+
+/// Extracts the error type from Poll<Result<T, E>>.
+fn poll_result_error_type<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Option<Ty<'tcx>> {
+    if_chain! {
+        if let ty::Adt(def, subst) = ty.kind();
+        if match_def_path(cx, def.did(), &paths::POLL);
+        let ready_ty = subst.type_at(0);
+
+        if let ty::Adt(ready_def, ready_subst) = ready_ty.kind();
+        if cx.tcx.is_diagnostic_item(sym::Result, ready_def.did());
+        then {
+            Some(ready_subst.type_at(1))
+        } else {
+            None
+        }
+    }
+}
+
+/// Extracts the error type from Poll<Option<Result<T, E>>>.
+fn poll_option_result_error_type<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Option<Ty<'tcx>> {
+    if_chain! {
+        if let ty::Adt(def, subst) = ty.kind();
+        if match_def_path(cx, def.did(), &paths::POLL);
+        let ready_ty = subst.type_at(0);
+
+        if let ty::Adt(ready_def, ready_subst) = ready_ty.kind();
+        if cx.tcx.is_diagnostic_item(sym::Option, ready_def.did());
+        let some_ty = ready_subst.type_at(0);
+
+        if let ty::Adt(some_def, some_subst) = some_ty.kind();
+        if cx.tcx.is_diagnostic_item(sym::Result, some_def.did());
+        then {
+            Some(some_subst.type_at(1))
+        } else {
+            None
+        }
+    }
+}
diff --git a/clippy_lints/src/try_err.rs b/clippy_lints/src/try_err.rs
deleted file mode 100644
index e108f7be12e..00000000000
--- a/clippy_lints/src/try_err.rs
+++ /dev/null
@@ -1,186 +0,0 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{get_parent_expr, is_lang_ctor, match_def_path, paths};
-use if_chain::if_chain;
-use rustc_errors::Applicability;
-use rustc_hir::LangItem::ResultErr;
-use rustc_hir::{Expr, ExprKind, LangItem, MatchSource, QPath};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::lint::in_external_macro;
-use rustc_middle::ty::{self, Ty};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::{hygiene, sym};
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for usages of `Err(x)?`.
-    ///
-    /// ### Why is this bad?
-    /// The `?` operator is designed to allow calls that
-    /// can fail to be easily chained. For example, `foo()?.bar()` or
-    /// `foo(bar()?)`. Because `Err(x)?` can't be used that way (it will
-    /// always return), it is more clear to write `return Err(x)`.
-    ///
-    /// ### Example
-    /// ```rust
-    /// fn foo(fail: bool) -> Result<i32, String> {
-    ///     if fail {
-    ///       Err("failed")?;
-    ///     }
-    ///     Ok(0)
-    /// }
-    /// ```
-    /// Could be written:
-    ///
-    /// ```rust
-    /// fn foo(fail: bool) -> Result<i32, String> {
-    ///     if fail {
-    ///       return Err("failed".into());
-    ///     }
-    ///     Ok(0)
-    /// }
-    /// ```
-    #[clippy::version = "1.38.0"]
-    pub TRY_ERR,
-    restriction,
-    "return errors explicitly rather than hiding them behind a `?`"
-}
-
-declare_lint_pass!(TryErr => [TRY_ERR]);
-
-impl<'tcx> LateLintPass<'tcx> for TryErr {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        // Looks for a structure like this:
-        // match ::std::ops::Try::into_result(Err(5)) {
-        //     ::std::result::Result::Err(err) =>
-        //         #[allow(unreachable_code)]
-        //         return ::std::ops::Try::from_error(::std::convert::From::from(err)),
-        //     ::std::result::Result::Ok(val) =>
-        //         #[allow(unreachable_code)]
-        //         val,
-        // };
-        if_chain! {
-            if !in_external_macro(cx.tcx.sess, expr.span);
-            if let ExprKind::Match(match_arg, _, MatchSource::TryDesugar) = expr.kind;
-            if let ExprKind::Call(match_fun, try_args) = match_arg.kind;
-            if let ExprKind::Path(ref match_fun_path) = match_fun.kind;
-            if matches!(match_fun_path, QPath::LangItem(LangItem::TryTraitBranch, ..));
-            if let Some(try_arg) = try_args.get(0);
-            if let ExprKind::Call(err_fun, err_args) = try_arg.kind;
-            if let Some(err_arg) = err_args.get(0);
-            if let ExprKind::Path(ref err_fun_path) = err_fun.kind;
-            if is_lang_ctor(cx, err_fun_path, ResultErr);
-            if let Some(return_ty) = find_return_type(cx, &expr.kind);
-            then {
-                let prefix;
-                let suffix;
-                let err_ty;
-
-                if let Some(ty) = result_error_type(cx, return_ty) {
-                    prefix = "Err(";
-                    suffix = ")";
-                    err_ty = ty;
-                } else if let Some(ty) = poll_result_error_type(cx, return_ty) {
-                    prefix = "Poll::Ready(Err(";
-                    suffix = "))";
-                    err_ty = ty;
-                } else if let Some(ty) = poll_option_result_error_type(cx, return_ty) {
-                    prefix = "Poll::Ready(Some(Err(";
-                    suffix = ")))";
-                    err_ty = ty;
-                } else {
-                    return;
-                };
-
-                let expr_err_ty = cx.typeck_results().expr_ty(err_arg);
-                let span = hygiene::walk_chain(err_arg.span, try_arg.span.ctxt());
-                let mut applicability = Applicability::MachineApplicable;
-                let origin_snippet = snippet_with_applicability(cx, span, "_", &mut applicability);
-                let ret_prefix = if get_parent_expr(cx, expr).map_or(false, |e| matches!(e.kind, ExprKind::Ret(_))) {
-                    "" // already returns
-                } else {
-                    "return "
-                };
-                let suggestion = if err_ty == expr_err_ty {
-                    format!("{}{}{}{}", ret_prefix, prefix, origin_snippet, suffix)
-                } else {
-                    format!("{}{}{}.into(){}", ret_prefix, prefix, origin_snippet, suffix)
-                };
-
-                span_lint_and_sugg(
-                    cx,
-                    TRY_ERR,
-                    expr.span,
-                    "returning an `Err(_)` with the `?` operator",
-                    "try this",
-                    suggestion,
-                    applicability,
-                );
-            }
-        }
-    }
-}
-
-/// Finds function return type by examining return expressions in match arms.
-fn find_return_type<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx ExprKind<'_>) -> Option<Ty<'tcx>> {
-    if let ExprKind::Match(_, arms, MatchSource::TryDesugar) = expr {
-        for arm in arms.iter() {
-            if let ExprKind::Ret(Some(ret)) = arm.body.kind {
-                return Some(cx.typeck_results().expr_ty(ret));
-            }
-        }
-    }
-    None
-}
-
-/// Extracts the error type from Result<T, E>.
-fn result_error_type<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Option<Ty<'tcx>> {
-    if_chain! {
-        if let ty::Adt(_, subst) = ty.kind();
-        if is_type_diagnostic_item(cx, ty, sym::Result);
-        then {
-            Some(subst.type_at(1))
-        } else {
-            None
-        }
-    }
-}
-
-/// Extracts the error type from Poll<Result<T, E>>.
-fn poll_result_error_type<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Option<Ty<'tcx>> {
-    if_chain! {
-        if let ty::Adt(def, subst) = ty.kind();
-        if match_def_path(cx, def.did(), &paths::POLL);
-        let ready_ty = subst.type_at(0);
-
-        if let ty::Adt(ready_def, ready_subst) = ready_ty.kind();
-        if cx.tcx.is_diagnostic_item(sym::Result, ready_def.did());
-        then {
-            Some(ready_subst.type_at(1))
-        } else {
-            None
-        }
-    }
-}
-
-/// Extracts the error type from Poll<Option<Result<T, E>>>.
-fn poll_option_result_error_type<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Option<Ty<'tcx>> {
-    if_chain! {
-        if let ty::Adt(def, subst) = ty.kind();
-        if match_def_path(cx, def.did(), &paths::POLL);
-        let ready_ty = subst.type_at(0);
-
-        if let ty::Adt(ready_def, ready_subst) = ready_ty.kind();
-        if cx.tcx.is_diagnostic_item(sym::Option, ready_def.did());
-        let some_ty = ready_subst.type_at(0);
-
-        if let ty::Adt(some_def, some_subst) = some_ty.kind();
-        if cx.tcx.is_diagnostic_item(sym::Result, some_def.did());
-        then {
-            Some(some_subst.type_at(1))
-        } else {
-            None
-        }
-    }
-}
-- 
cgit 1.4.1-3-g733a5


From 68c411ff943c71cd86d18a0b50f23b8da9d78181 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Fri, 3 Jun 2022 19:01:44 -0400
Subject: Move `ManualMap` into `Matches` lint pass

---
 clippy_lints/src/lib.register_all.rs   |   2 +-
 clippy_lints/src/lib.register_lints.rs |   2 +-
 clippy_lints/src/lib.register_style.rs |   2 +-
 clippy_lints/src/lib.rs                |   2 -
 clippy_lints/src/manual_map.rs         | 316 ---------------------------------
 clippy_lints/src/matches/manual_map.rs | 306 +++++++++++++++++++++++++++++++
 clippy_lints/src/matches/mod.rs        |  30 ++++
 7 files changed, 339 insertions(+), 321 deletions(-)
 delete mode 100644 clippy_lints/src/manual_map.rs
 create mode 100644 clippy_lints/src/matches/manual_map.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 435c0829a67..d4ec046d0bb 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -133,7 +133,6 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(main_recursion::MAIN_RECURSION),
     LintId::of(manual_async_fn::MANUAL_ASYNC_FN),
     LintId::of(manual_bits::MANUAL_BITS),
-    LintId::of(manual_map::MANUAL_MAP),
     LintId::of(manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE),
     LintId::of(manual_strip::MANUAL_STRIP),
     LintId::of(map_clone::MAP_CLONE),
@@ -142,6 +141,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(match_result_ok::MATCH_RESULT_OK),
     LintId::of(matches::COLLAPSIBLE_MATCH),
     LintId::of(matches::INFALLIBLE_DESTRUCTURING_MATCH),
+    LintId::of(matches::MANUAL_MAP),
     LintId::of(matches::MANUAL_UNWRAP_OR),
     LintId::of(matches::MATCH_AS_REF),
     LintId::of(matches::MATCH_LIKE_MATCHES_MACRO),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index c8cebca89d5..4cf38e8ab15 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -250,7 +250,6 @@ store.register_lints(&[
     manual_assert::MANUAL_ASSERT,
     manual_async_fn::MANUAL_ASYNC_FN,
     manual_bits::MANUAL_BITS,
-    manual_map::MANUAL_MAP,
     manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE,
     manual_ok_or::MANUAL_OK_OR,
     manual_strip::MANUAL_STRIP,
@@ -261,6 +260,7 @@ store.register_lints(&[
     match_result_ok::MATCH_RESULT_OK,
     matches::COLLAPSIBLE_MATCH,
     matches::INFALLIBLE_DESTRUCTURING_MATCH,
+    matches::MANUAL_MAP,
     matches::MANUAL_UNWRAP_OR,
     matches::MATCH_AS_REF,
     matches::MATCH_BOOL,
diff --git a/clippy_lints/src/lib.register_style.rs b/clippy_lints/src/lib.register_style.rs
index 07e90b8b656..35575351784 100644
--- a/clippy_lints/src/lib.register_style.rs
+++ b/clippy_lints/src/lib.register_style.rs
@@ -45,12 +45,12 @@ store.register_group(true, "clippy::style", Some("clippy_style"), vec![
     LintId::of(main_recursion::MAIN_RECURSION),
     LintId::of(manual_async_fn::MANUAL_ASYNC_FN),
     LintId::of(manual_bits::MANUAL_BITS),
-    LintId::of(manual_map::MANUAL_MAP),
     LintId::of(manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE),
     LintId::of(map_clone::MAP_CLONE),
     LintId::of(match_result_ok::MATCH_RESULT_OK),
     LintId::of(matches::COLLAPSIBLE_MATCH),
     LintId::of(matches::INFALLIBLE_DESTRUCTURING_MATCH),
+    LintId::of(matches::MANUAL_MAP),
     LintId::of(matches::MATCH_LIKE_MATCHES_MACRO),
     LintId::of(matches::MATCH_OVERLAPPING_ARM),
     LintId::of(matches::MATCH_REF_PATS),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index d9941d75f78..c924bfe2ad6 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -279,7 +279,6 @@ mod main_recursion;
 mod manual_assert;
 mod manual_async_fn;
 mod manual_bits;
-mod manual_map;
 mod manual_non_exhaustive;
 mod manual_ok_or;
 mod manual_strip;
@@ -845,7 +844,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     });
     store.register_late_pass(|| Box::new(redundant_slicing::RedundantSlicing));
     store.register_late_pass(|| Box::new(from_str_radix_10::FromStrRadix10));
-    store.register_late_pass(|| Box::new(manual_map::ManualMap));
     store.register_late_pass(move || Box::new(if_then_some_else_none::IfThenSomeElseNone::new(msrv)));
     store.register_late_pass(|| Box::new(bool_assert_comparison::BoolAssertComparison));
     store.register_early_pass(move || Box::new(module_style::ModStyle));
diff --git a/clippy_lints/src/manual_map.rs b/clippy_lints/src/manual_map.rs
deleted file mode 100644
index 230ae029ed9..00000000000
--- a/clippy_lints/src/manual_map.rs
+++ /dev/null
@@ -1,316 +0,0 @@
-use crate::{map_unit_fn::OPTION_MAP_UNIT_FN, matches::MATCH_AS_REF};
-use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::higher::IfLetOrMatch;
-use clippy_utils::source::{snippet_with_applicability, snippet_with_context};
-use clippy_utils::ty::{is_type_diagnostic_item, peel_mid_ty_refs_is_mutable, type_is_unsafe_function};
-use clippy_utils::{
-    can_move_expr_to_closure, in_constant, is_else_clause, is_lang_ctor, is_lint_allowed, path_to_local_id,
-    peel_blocks, peel_hir_expr_refs, peel_hir_expr_while, CaptureKind,
-};
-use rustc_ast::util::parser::PREC_POSTFIX;
-use rustc_errors::Applicability;
-use rustc_hir::LangItem::{OptionNone, OptionSome};
-use rustc_hir::{
-    def::Res, Arm, BindingAnnotation, Block, BlockCheckMode, Expr, ExprKind, HirId, Mutability, Pat, PatKind, Path,
-    QPath, UnsafeSource,
-};
-use rustc_lint::{LateContext, LateLintPass, LintContext};
-use rustc_middle::lint::in_external_macro;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::{sym, SyntaxContext};
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for usages of `match` which could be implemented using `map`
-    ///
-    /// ### Why is this bad?
-    /// Using the `map` method is clearer and more concise.
-    ///
-    /// ### Example
-    /// ```rust
-    /// match Some(0) {
-    ///     Some(x) => Some(x + 1),
-    ///     None => None,
-    /// };
-    /// ```
-    /// Use instead:
-    /// ```rust
-    /// Some(0).map(|x| x + 1);
-    /// ```
-    #[clippy::version = "1.52.0"]
-    pub MANUAL_MAP,
-    style,
-    "reimplementation of `map`"
-}
-
-declare_lint_pass!(ManualMap => [MANUAL_MAP]);
-
-impl<'tcx> LateLintPass<'tcx> for ManualMap {
-    #[expect(clippy::too_many_lines)]
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        let (scrutinee, then_pat, then_body, else_pat, else_body) = match IfLetOrMatch::parse(cx, expr) {
-            Some(IfLetOrMatch::IfLet(scrutinee, pat, body, Some(r#else))) => (scrutinee, pat, body, None, r#else),
-            Some(IfLetOrMatch::Match(
-                scrutinee,
-                [arm1 @ Arm { guard: None, .. }, arm2 @ Arm { guard: None, .. }],
-                _,
-            )) => (scrutinee, arm1.pat, arm1.body, Some(arm2.pat), arm2.body),
-            _ => return,
-        };
-        if in_external_macro(cx.sess(), expr.span) || in_constant(cx, expr.hir_id) {
-            return;
-        }
-
-        let (scrutinee_ty, ty_ref_count, ty_mutability) =
-            peel_mid_ty_refs_is_mutable(cx.typeck_results().expr_ty(scrutinee));
-        if !(is_type_diagnostic_item(cx, scrutinee_ty, sym::Option)
-            && is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(expr), sym::Option))
-        {
-            return;
-        }
-
-        let expr_ctxt = expr.span.ctxt();
-        let (some_expr, some_pat, pat_ref_count, is_wild_none) = match (
-            try_parse_pattern(cx, then_pat, expr_ctxt),
-            else_pat.map_or(Some(OptionPat::Wild), |p| try_parse_pattern(cx, p, expr_ctxt)),
-        ) {
-            (Some(OptionPat::Wild), Some(OptionPat::Some { pattern, ref_count })) if is_none_expr(cx, then_body) => {
-                (else_body, pattern, ref_count, true)
-            },
-            (Some(OptionPat::None), Some(OptionPat::Some { pattern, ref_count })) if is_none_expr(cx, then_body) => {
-                (else_body, pattern, ref_count, false)
-            },
-            (Some(OptionPat::Some { pattern, ref_count }), Some(OptionPat::Wild)) if is_none_expr(cx, else_body) => {
-                (then_body, pattern, ref_count, true)
-            },
-            (Some(OptionPat::Some { pattern, ref_count }), Some(OptionPat::None)) if is_none_expr(cx, else_body) => {
-                (then_body, pattern, ref_count, false)
-            },
-            _ => return,
-        };
-
-        // Top level or patterns aren't allowed in closures.
-        if matches!(some_pat.kind, PatKind::Or(_)) {
-            return;
-        }
-
-        let some_expr = match get_some_expr(cx, some_expr, false, expr_ctxt) {
-            Some(expr) => expr,
-            None => return,
-        };
-
-        // These two lints will go back and forth with each other.
-        if cx.typeck_results().expr_ty(some_expr.expr) == cx.tcx.types.unit
-            && !is_lint_allowed(cx, OPTION_MAP_UNIT_FN, expr.hir_id)
-        {
-            return;
-        }
-
-        // `map` won't perform any adjustments.
-        if !cx.typeck_results().expr_adjustments(some_expr.expr).is_empty() {
-            return;
-        }
-
-        // Determine which binding mode to use.
-        let explicit_ref = some_pat.contains_explicit_ref_binding();
-        let binding_ref = explicit_ref.or_else(|| (ty_ref_count != pat_ref_count).then(|| ty_mutability));
-
-        let as_ref_str = match binding_ref {
-            Some(Mutability::Mut) => ".as_mut()",
-            Some(Mutability::Not) => ".as_ref()",
-            None => "",
-        };
-
-        match can_move_expr_to_closure(cx, some_expr.expr) {
-            Some(captures) => {
-                // Check if captures the closure will need conflict with borrows made in the scrutinee.
-                // TODO: check all the references made in the scrutinee expression. This will require interacting
-                // with the borrow checker. Currently only `<local>[.<field>]*` is checked for.
-                if let Some(binding_ref_mutability) = binding_ref {
-                    let e = peel_hir_expr_while(scrutinee, |e| match e.kind {
-                        ExprKind::Field(e, _) | ExprKind::AddrOf(_, _, e) => Some(e),
-                        _ => None,
-                    });
-                    if let ExprKind::Path(QPath::Resolved(None, Path { res: Res::Local(l), .. })) = e.kind {
-                        match captures.get(l) {
-                            Some(CaptureKind::Value | CaptureKind::Ref(Mutability::Mut)) => return,
-                            Some(CaptureKind::Ref(Mutability::Not)) if binding_ref_mutability == Mutability::Mut => {
-                                return;
-                            },
-                            Some(CaptureKind::Ref(Mutability::Not)) | None => (),
-                        }
-                    }
-                }
-            },
-            None => return,
-        };
-
-        let mut app = Applicability::MachineApplicable;
-
-        // Remove address-of expressions from the scrutinee. Either `as_ref` will be called, or
-        // it's being passed by value.
-        let scrutinee = peel_hir_expr_refs(scrutinee).0;
-        let (scrutinee_str, _) = snippet_with_context(cx, scrutinee.span, expr_ctxt, "..", &mut app);
-        let scrutinee_str =
-            if scrutinee.span.ctxt() == expr.span.ctxt() && scrutinee.precedence().order() < PREC_POSTFIX {
-                format!("({})", scrutinee_str)
-            } else {
-                scrutinee_str.into()
-            };
-
-        let body_str = if let PatKind::Binding(annotation, id, some_binding, None) = some_pat.kind {
-            if_chain! {
-                if !some_expr.needs_unsafe_block;
-                if let Some(func) = can_pass_as_func(cx, id, some_expr.expr);
-                if func.span.ctxt() == some_expr.expr.span.ctxt();
-                then {
-                    snippet_with_applicability(cx, func.span, "..", &mut app).into_owned()
-                } else {
-                    if path_to_local_id(some_expr.expr, id)
-                        && !is_lint_allowed(cx, MATCH_AS_REF, expr.hir_id)
-                        && binding_ref.is_some()
-                    {
-                        return;
-                    }
-
-                    // `ref` and `ref mut` annotations were handled earlier.
-                    let annotation = if matches!(annotation, BindingAnnotation::Mutable) {
-                        "mut "
-                    } else {
-                        ""
-                    };
-                    let expr_snip = snippet_with_context(cx, some_expr.expr.span, expr_ctxt, "..", &mut app).0;
-                    if some_expr.needs_unsafe_block {
-                        format!("|{}{}| unsafe {{ {} }}", annotation, some_binding, expr_snip)
-                    } else {
-                        format!("|{}{}| {}", annotation, some_binding, expr_snip)
-                    }
-                }
-            }
-        } else if !is_wild_none && explicit_ref.is_none() {
-            // TODO: handle explicit reference annotations.
-            let pat_snip = snippet_with_context(cx, some_pat.span, expr_ctxt, "..", &mut app).0;
-            let expr_snip = snippet_with_context(cx, some_expr.expr.span, expr_ctxt, "..", &mut app).0;
-            if some_expr.needs_unsafe_block {
-                format!("|{}| unsafe {{ {} }}", pat_snip, expr_snip)
-            } else {
-                format!("|{}| {}", pat_snip, expr_snip)
-            }
-        } else {
-            // Refutable bindings and mixed reference annotations can't be handled by `map`.
-            return;
-        };
-
-        span_lint_and_sugg(
-            cx,
-            MANUAL_MAP,
-            expr.span,
-            "manual implementation of `Option::map`",
-            "try this",
-            if else_pat.is_none() && is_else_clause(cx.tcx, expr) {
-                format!("{{ {}{}.map({}) }}", scrutinee_str, as_ref_str, body_str)
-            } else {
-                format!("{}{}.map({})", scrutinee_str, as_ref_str, body_str)
-            },
-            app,
-        );
-    }
-}
-
-// Checks whether the expression could be passed as a function, or whether a closure is needed.
-// Returns the function to be passed to `map` if it exists.
-fn can_pass_as_func<'tcx>(cx: &LateContext<'tcx>, binding: HirId, expr: &'tcx Expr<'_>) -> Option<&'tcx Expr<'tcx>> {
-    match expr.kind {
-        ExprKind::Call(func, [arg])
-            if path_to_local_id(arg, binding)
-                && cx.typeck_results().expr_adjustments(arg).is_empty()
-                && !type_is_unsafe_function(cx, cx.typeck_results().expr_ty(func).peel_refs()) =>
-        {
-            Some(func)
-        },
-        _ => None,
-    }
-}
-
-enum OptionPat<'a> {
-    Wild,
-    None,
-    Some {
-        // The pattern contained in the `Some` tuple.
-        pattern: &'a Pat<'a>,
-        // The number of references before the `Some` tuple.
-        // e.g. `&&Some(_)` has a ref count of 2.
-        ref_count: usize,
-    },
-}
-
-struct SomeExpr<'tcx> {
-    expr: &'tcx Expr<'tcx>,
-    needs_unsafe_block: bool,
-}
-
-// Try to parse into a recognized `Option` pattern.
-// i.e. `_`, `None`, `Some(..)`, or a reference to any of those.
-fn try_parse_pattern<'tcx>(cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>, ctxt: SyntaxContext) -> Option<OptionPat<'tcx>> {
-    fn f<'tcx>(
-        cx: &LateContext<'tcx>,
-        pat: &'tcx Pat<'_>,
-        ref_count: usize,
-        ctxt: SyntaxContext,
-    ) -> Option<OptionPat<'tcx>> {
-        match pat.kind {
-            PatKind::Wild => Some(OptionPat::Wild),
-            PatKind::Ref(pat, _) => f(cx, pat, ref_count + 1, ctxt),
-            PatKind::Path(ref qpath) if is_lang_ctor(cx, qpath, OptionNone) => Some(OptionPat::None),
-            PatKind::TupleStruct(ref qpath, [pattern], _)
-                if is_lang_ctor(cx, qpath, OptionSome) && pat.span.ctxt() == ctxt =>
-            {
-                Some(OptionPat::Some { pattern, ref_count })
-            },
-            _ => None,
-        }
-    }
-    f(cx, pat, 0, ctxt)
-}
-
-// Checks for an expression wrapped by the `Some` constructor. Returns the contained expression.
-fn get_some_expr<'tcx>(
-    cx: &LateContext<'tcx>,
-    expr: &'tcx Expr<'_>,
-    needs_unsafe_block: bool,
-    ctxt: SyntaxContext,
-) -> Option<SomeExpr<'tcx>> {
-    // TODO: Allow more complex expressions.
-    match expr.kind {
-        ExprKind::Call(
-            Expr {
-                kind: ExprKind::Path(ref qpath),
-                ..
-            },
-            [arg],
-        ) if ctxt == expr.span.ctxt() && is_lang_ctor(cx, qpath, OptionSome) => Some(SomeExpr {
-            expr: arg,
-            needs_unsafe_block,
-        }),
-        ExprKind::Block(
-            Block {
-                stmts: [],
-                expr: Some(expr),
-                rules,
-                ..
-            },
-            _,
-        ) => get_some_expr(
-            cx,
-            expr,
-            needs_unsafe_block || *rules == BlockCheckMode::UnsafeBlock(UnsafeSource::UserProvided),
-            ctxt,
-        ),
-        _ => None,
-    }
-}
-
-// Checks for the `None` value.
-fn is_none_expr(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-    matches!(peel_blocks(expr).kind, ExprKind::Path(ref qpath) if is_lang_ctor(cx, qpath, OptionNone))
-}
diff --git a/clippy_lints/src/matches/manual_map.rs b/clippy_lints/src/matches/manual_map.rs
new file mode 100644
index 00000000000..542905a2d76
--- /dev/null
+++ b/clippy_lints/src/matches/manual_map.rs
@@ -0,0 +1,306 @@
+use crate::{map_unit_fn::OPTION_MAP_UNIT_FN, matches::MATCH_AS_REF};
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::{snippet_with_applicability, snippet_with_context};
+use clippy_utils::ty::{is_type_diagnostic_item, peel_mid_ty_refs_is_mutable, type_is_unsafe_function};
+use clippy_utils::{
+    can_move_expr_to_closure, is_else_clause, is_lang_ctor, is_lint_allowed, path_to_local_id, peel_blocks,
+    peel_hir_expr_refs, peel_hir_expr_while, CaptureKind,
+};
+use rustc_ast::util::parser::PREC_POSTFIX;
+use rustc_errors::Applicability;
+use rustc_hir::LangItem::{OptionNone, OptionSome};
+use rustc_hir::{
+    def::Res, Arm, BindingAnnotation, Block, BlockCheckMode, Expr, ExprKind, HirId, Mutability, Pat, PatKind, Path,
+    QPath, UnsafeSource,
+};
+use rustc_lint::LateContext;
+use rustc_span::{sym, SyntaxContext};
+
+use super::MANUAL_MAP;
+
+pub(super) fn check_match<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx Expr<'_>,
+    scrutinee: &'tcx Expr<'_>,
+    arms: &'tcx [Arm<'_>],
+) {
+    if let [arm1, arm2] = arms
+        && arm1.guard.is_none()
+        && arm2.guard.is_none()
+    {
+        check(cx, expr, scrutinee, arm1.pat, arm1.body, Some(arm2.pat), arm2.body);
+    }
+}
+
+pub(super) fn check_if_let<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx Expr<'_>,
+    let_pat: &'tcx Pat<'_>,
+    let_expr: &'tcx Expr<'_>,
+    then_expr: &'tcx Expr<'_>,
+    else_expr: &'tcx Expr<'_>,
+) {
+    check(cx, expr, let_expr, let_pat, then_expr, None, else_expr);
+}
+
+#[expect(clippy::too_many_lines)]
+fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx Expr<'_>,
+    scrutinee: &'tcx Expr<'_>,
+    then_pat: &'tcx Pat<'_>,
+    then_body: &'tcx Expr<'_>,
+    else_pat: Option<&'tcx Pat<'_>>,
+    else_body: &'tcx Expr<'_>,
+) {
+    let (scrutinee_ty, ty_ref_count, ty_mutability) =
+        peel_mid_ty_refs_is_mutable(cx.typeck_results().expr_ty(scrutinee));
+    if !(is_type_diagnostic_item(cx, scrutinee_ty, sym::Option)
+        && is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(expr), sym::Option))
+    {
+        return;
+    }
+
+    let expr_ctxt = expr.span.ctxt();
+    let (some_expr, some_pat, pat_ref_count, is_wild_none) = match (
+        try_parse_pattern(cx, then_pat, expr_ctxt),
+        else_pat.map_or(Some(OptionPat::Wild), |p| try_parse_pattern(cx, p, expr_ctxt)),
+    ) {
+        (Some(OptionPat::Wild), Some(OptionPat::Some { pattern, ref_count })) if is_none_expr(cx, then_body) => {
+            (else_body, pattern, ref_count, true)
+        },
+        (Some(OptionPat::None), Some(OptionPat::Some { pattern, ref_count })) if is_none_expr(cx, then_body) => {
+            (else_body, pattern, ref_count, false)
+        },
+        (Some(OptionPat::Some { pattern, ref_count }), Some(OptionPat::Wild)) if is_none_expr(cx, else_body) => {
+            (then_body, pattern, ref_count, true)
+        },
+        (Some(OptionPat::Some { pattern, ref_count }), Some(OptionPat::None)) if is_none_expr(cx, else_body) => {
+            (then_body, pattern, ref_count, false)
+        },
+        _ => return,
+    };
+
+    // Top level or patterns aren't allowed in closures.
+    if matches!(some_pat.kind, PatKind::Or(_)) {
+        return;
+    }
+
+    let some_expr = match get_some_expr(cx, some_expr, false, expr_ctxt) {
+        Some(expr) => expr,
+        None => return,
+    };
+
+    // These two lints will go back and forth with each other.
+    if cx.typeck_results().expr_ty(some_expr.expr) == cx.tcx.types.unit
+        && !is_lint_allowed(cx, OPTION_MAP_UNIT_FN, expr.hir_id)
+    {
+        return;
+    }
+
+    // `map` won't perform any adjustments.
+    if !cx.typeck_results().expr_adjustments(some_expr.expr).is_empty() {
+        return;
+    }
+
+    // Determine which binding mode to use.
+    let explicit_ref = some_pat.contains_explicit_ref_binding();
+    let binding_ref = explicit_ref.or_else(|| (ty_ref_count != pat_ref_count).then(|| ty_mutability));
+
+    let as_ref_str = match binding_ref {
+        Some(Mutability::Mut) => ".as_mut()",
+        Some(Mutability::Not) => ".as_ref()",
+        None => "",
+    };
+
+    match can_move_expr_to_closure(cx, some_expr.expr) {
+        Some(captures) => {
+            // Check if captures the closure will need conflict with borrows made in the scrutinee.
+            // TODO: check all the references made in the scrutinee expression. This will require interacting
+            // with the borrow checker. Currently only `<local>[.<field>]*` is checked for.
+            if let Some(binding_ref_mutability) = binding_ref {
+                let e = peel_hir_expr_while(scrutinee, |e| match e.kind {
+                    ExprKind::Field(e, _) | ExprKind::AddrOf(_, _, e) => Some(e),
+                    _ => None,
+                });
+                if let ExprKind::Path(QPath::Resolved(None, Path { res: Res::Local(l), .. })) = e.kind {
+                    match captures.get(l) {
+                        Some(CaptureKind::Value | CaptureKind::Ref(Mutability::Mut)) => return,
+                        Some(CaptureKind::Ref(Mutability::Not)) if binding_ref_mutability == Mutability::Mut => {
+                            return;
+                        },
+                        Some(CaptureKind::Ref(Mutability::Not)) | None => (),
+                    }
+                }
+            }
+        },
+        None => return,
+    };
+
+    let mut app = Applicability::MachineApplicable;
+
+    // Remove address-of expressions from the scrutinee. Either `as_ref` will be called, or
+    // it's being passed by value.
+    let scrutinee = peel_hir_expr_refs(scrutinee).0;
+    let (scrutinee_str, _) = snippet_with_context(cx, scrutinee.span, expr_ctxt, "..", &mut app);
+    let scrutinee_str = if scrutinee.span.ctxt() == expr.span.ctxt() && scrutinee.precedence().order() < PREC_POSTFIX {
+        format!("({})", scrutinee_str)
+    } else {
+        scrutinee_str.into()
+    };
+
+    let body_str = if let PatKind::Binding(annotation, id, some_binding, None) = some_pat.kind {
+        if_chain! {
+            if !some_expr.needs_unsafe_block;
+            if let Some(func) = can_pass_as_func(cx, id, some_expr.expr);
+            if func.span.ctxt() == some_expr.expr.span.ctxt();
+            then {
+                snippet_with_applicability(cx, func.span, "..", &mut app).into_owned()
+            } else {
+                if path_to_local_id(some_expr.expr, id)
+                    && !is_lint_allowed(cx, MATCH_AS_REF, expr.hir_id)
+                    && binding_ref.is_some()
+                {
+                    return;
+                }
+
+                // `ref` and `ref mut` annotations were handled earlier.
+                let annotation = if matches!(annotation, BindingAnnotation::Mutable) {
+                    "mut "
+                } else {
+                    ""
+                };
+                let expr_snip = snippet_with_context(cx, some_expr.expr.span, expr_ctxt, "..", &mut app).0;
+                if some_expr.needs_unsafe_block {
+                    format!("|{}{}| unsafe {{ {} }}", annotation, some_binding, expr_snip)
+                } else {
+                    format!("|{}{}| {}", annotation, some_binding, expr_snip)
+                }
+            }
+        }
+    } else if !is_wild_none && explicit_ref.is_none() {
+        // TODO: handle explicit reference annotations.
+        let pat_snip = snippet_with_context(cx, some_pat.span, expr_ctxt, "..", &mut app).0;
+        let expr_snip = snippet_with_context(cx, some_expr.expr.span, expr_ctxt, "..", &mut app).0;
+        if some_expr.needs_unsafe_block {
+            format!("|{}| unsafe {{ {} }}", pat_snip, expr_snip)
+        } else {
+            format!("|{}| {}", pat_snip, expr_snip)
+        }
+    } else {
+        // Refutable bindings and mixed reference annotations can't be handled by `map`.
+        return;
+    };
+
+    span_lint_and_sugg(
+        cx,
+        MANUAL_MAP,
+        expr.span,
+        "manual implementation of `Option::map`",
+        "try this",
+        if else_pat.is_none() && is_else_clause(cx.tcx, expr) {
+            format!("{{ {}{}.map({}) }}", scrutinee_str, as_ref_str, body_str)
+        } else {
+            format!("{}{}.map({})", scrutinee_str, as_ref_str, body_str)
+        },
+        app,
+    );
+}
+
+// Checks whether the expression could be passed as a function, or whether a closure is needed.
+// Returns the function to be passed to `map` if it exists.
+fn can_pass_as_func<'tcx>(cx: &LateContext<'tcx>, binding: HirId, expr: &'tcx Expr<'_>) -> Option<&'tcx Expr<'tcx>> {
+    match expr.kind {
+        ExprKind::Call(func, [arg])
+            if path_to_local_id(arg, binding)
+                && cx.typeck_results().expr_adjustments(arg).is_empty()
+                && !type_is_unsafe_function(cx, cx.typeck_results().expr_ty(func).peel_refs()) =>
+        {
+            Some(func)
+        },
+        _ => None,
+    }
+}
+
+enum OptionPat<'a> {
+    Wild,
+    None,
+    Some {
+        // The pattern contained in the `Some` tuple.
+        pattern: &'a Pat<'a>,
+        // The number of references before the `Some` tuple.
+        // e.g. `&&Some(_)` has a ref count of 2.
+        ref_count: usize,
+    },
+}
+
+struct SomeExpr<'tcx> {
+    expr: &'tcx Expr<'tcx>,
+    needs_unsafe_block: bool,
+}
+
+// Try to parse into a recognized `Option` pattern.
+// i.e. `_`, `None`, `Some(..)`, or a reference to any of those.
+fn try_parse_pattern<'tcx>(cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>, ctxt: SyntaxContext) -> Option<OptionPat<'tcx>> {
+    fn f<'tcx>(
+        cx: &LateContext<'tcx>,
+        pat: &'tcx Pat<'_>,
+        ref_count: usize,
+        ctxt: SyntaxContext,
+    ) -> Option<OptionPat<'tcx>> {
+        match pat.kind {
+            PatKind::Wild => Some(OptionPat::Wild),
+            PatKind::Ref(pat, _) => f(cx, pat, ref_count + 1, ctxt),
+            PatKind::Path(ref qpath) if is_lang_ctor(cx, qpath, OptionNone) => Some(OptionPat::None),
+            PatKind::TupleStruct(ref qpath, [pattern], _)
+                if is_lang_ctor(cx, qpath, OptionSome) && pat.span.ctxt() == ctxt =>
+            {
+                Some(OptionPat::Some { pattern, ref_count })
+            },
+            _ => None,
+        }
+    }
+    f(cx, pat, 0, ctxt)
+}
+
+// Checks for an expression wrapped by the `Some` constructor. Returns the contained expression.
+fn get_some_expr<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx Expr<'_>,
+    needs_unsafe_block: bool,
+    ctxt: SyntaxContext,
+) -> Option<SomeExpr<'tcx>> {
+    // TODO: Allow more complex expressions.
+    match expr.kind {
+        ExprKind::Call(
+            Expr {
+                kind: ExprKind::Path(ref qpath),
+                ..
+            },
+            [arg],
+        ) if ctxt == expr.span.ctxt() && is_lang_ctor(cx, qpath, OptionSome) => Some(SomeExpr {
+            expr: arg,
+            needs_unsafe_block,
+        }),
+        ExprKind::Block(
+            Block {
+                stmts: [],
+                expr: Some(expr),
+                rules,
+                ..
+            },
+            _,
+        ) => get_some_expr(
+            cx,
+            expr,
+            needs_unsafe_block || *rules == BlockCheckMode::UnsafeBlock(UnsafeSource::UserProvided),
+            ctxt,
+        ),
+        _ => None,
+    }
+}
+
+// Checks for the `None` value.
+fn is_none_expr(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+    matches!(peel_blocks(expr).kind, ExprKind::Path(ref qpath) if is_lang_ctor(cx, qpath, OptionNone))
+}
diff --git a/clippy_lints/src/matches/mod.rs b/clippy_lints/src/matches/mod.rs
index fee7471f17d..d1e42f39e47 100644
--- a/clippy_lints/src/matches/mod.rs
+++ b/clippy_lints/src/matches/mod.rs
@@ -10,6 +10,7 @@ use rustc_span::{Span, SpanData, SyntaxContext};
 
 mod collapsible_match;
 mod infallible_destructuring_match;
+mod manual_map;
 mod manual_unwrap_or;
 mod match_as_ref;
 mod match_bool;
@@ -861,6 +862,30 @@ declare_clippy_lint! {
     "return errors explicitly rather than hiding them behind a `?`"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usages of `match` which could be implemented using `map`
+    ///
+    /// ### Why is this bad?
+    /// Using the `map` method is clearer and more concise.
+    ///
+    /// ### Example
+    /// ```rust
+    /// match Some(0) {
+    ///     Some(x) => Some(x + 1),
+    ///     None => None,
+    /// };
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// Some(0).map(|x| x + 1);
+    /// ```
+    #[clippy::version = "1.52.0"]
+    pub MANUAL_MAP,
+    style,
+    "reimplementation of `map`"
+}
+
 #[derive(Default)]
 pub struct Matches {
     msrv: Option<RustcVersion>,
@@ -901,6 +926,7 @@ impl_lint_pass!(Matches => [
     MATCH_STR_CASE_MISMATCH,
     SIGNIFICANT_DROP_IN_SCRUTINEE,
     TRY_ERR,
+    MANUAL_MAP,
 ]);
 
 impl<'tcx> LateLintPass<'tcx> for Matches {
@@ -949,6 +975,7 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
 
                     if !in_constant(cx, expr.hir_id) {
                         manual_unwrap_or::check(cx, expr, ex, arms);
+                        manual_map::check_match(cx, expr, ex, arms);
                     }
 
                     if self.infallible_destructuring_match_linted {
@@ -973,6 +1000,9 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
                             else_expr,
                         );
                     }
+                    if !in_constant(cx, expr.hir_id) {
+                        manual_map::check_if_let(cx, expr, if_let.let_pat, if_let.let_expr, if_let.if_then, else_expr);
+                    }
                 }
                 redundant_pattern_match::check_if_let(
                     cx,
-- 
cgit 1.4.1-3-g733a5


From 990f8bf5a6354d98a7e0b628f9f1b810644c3ad8 Mon Sep 17 00:00:00 2001
From: kyoto7250 <50972773+kyoto7250@users.noreply.github.com>
Date: Sat, 4 Jun 2022 16:55:33 +0900
Subject: refactor: Add some methods

---
 clippy_lints/src/methods/filter_map.rs | 19 ++++++++++++---
 tests/ui/manual_filter_map.fixed       | 22 +++++++++++++++++-
 tests/ui/manual_filter_map.rs          | 27 +++++++++++++++++++++-
 tests/ui/manual_filter_map.stderr      | 42 +++++++++++++++++++++++++++++++++-
 tests/ui/manual_find_map.fixed         | 20 +++++++++++++++-
 tests/ui/manual_find_map.rs            | 24 ++++++++++++++++++-
 tests/ui/manual_find_map.stderr        | 40 +++++++++++++++++++++++++++++++-
 7 files changed, 185 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/filter_map.rs b/clippy_lints/src/methods/filter_map.rs
index 04ca295dc69..6cabe74fdef 100644
--- a/clippy_lints/src/methods/filter_map.rs
+++ b/clippy_lints/src/methods/filter_map.rs
@@ -6,7 +6,7 @@ use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_hir::def::Res;
-use rustc_hir::{Expr, ExprKind, PatKind, QPath, UnOp};
+use rustc_hir::{Expr, ExprKind, PatKind, PathSegment, QPath, UnOp};
 use rustc_lint::LateContext;
 use rustc_span::source_map::Span;
 use rustc_span::symbol::{sym, Symbol};
@@ -157,8 +157,8 @@ pub(super) fn check<'tcx>(
             };
 
             if match map_arg.kind {
-                ExprKind::MethodCall(clone, [original_arg], _) => {
-                    clone.ident.name == sym::clone
+                ExprKind::MethodCall(method, [original_arg], _) => {
+                    acceptable_methods(method)
                         && SpanlessEq::new(cx).expr_fallback(eq_fallback).eq_expr(filter_arg, original_arg)
                 },
                 _ => SpanlessEq::new(cx).expr_fallback(eq_fallback).eq_expr(filter_arg, map_arg)
@@ -179,3 +179,16 @@ pub(super) fn check<'tcx>(
             }
     }
 }
+
+fn acceptable_methods(method: &PathSegment<'_>) -> bool {
+    let methods: [Symbol; 6] = [
+        sym::clone,
+        sym::as_ref,
+        sym!(as_deref),
+        sym!(as_mut),
+        sym!(as_deref_mut),
+        sym!(to_owned),
+    ];
+
+    methods.contains(&method.ident.name)
+}
diff --git a/tests/ui/manual_filter_map.fixed b/tests/ui/manual_filter_map.fixed
index c88a4f43de2..9de7040000a 100644
--- a/tests/ui/manual_filter_map.fixed
+++ b/tests/ui/manual_filter_map.fixed
@@ -52,8 +52,28 @@ fn issue_8920() {
         .iter()
         .filter_map(|f| f.field.clone());
 
-    let vec = vec![ResultFoo {
+    let mut vec = vec![ResultFoo {
         field: Ok(String::from("str")),
     }];
     let _ = vec.iter().filter_map(|f| f.field.clone().ok());
+
+    let _ = vec
+        .iter()
+        .filter_map(|f| f.field.as_ref().ok());
+
+    let _ = vec
+        .iter()
+        .filter_map(|f| f.field.as_deref().ok());
+
+    let _ = vec
+        .iter_mut()
+        .filter_map(|f| f.field.as_mut().ok());
+
+    let _ = vec
+        .iter_mut()
+        .filter_map(|f| f.field.as_deref_mut().ok());
+
+    let _ = vec
+        .iter()
+        .filter_map(|f| f.field.to_owned().ok());
 }
diff --git a/tests/ui/manual_filter_map.rs b/tests/ui/manual_filter_map.rs
index bb859ebe315..6766078d694 100644
--- a/tests/ui/manual_filter_map.rs
+++ b/tests/ui/manual_filter_map.rs
@@ -53,8 +53,33 @@ fn issue_8920() {
         .filter(|f| f.field.is_some())
         .map(|f| f.field.clone().unwrap());
 
-    let vec = vec![ResultFoo {
+    let mut vec = vec![ResultFoo {
         field: Ok(String::from("str")),
     }];
     let _ = vec.iter().filter(|f| f.field.is_ok()).map(|f| f.field.clone().unwrap());
+
+    let _ = vec
+        .iter()
+        .filter(|f| f.field.is_ok())
+        .map(|f| f.field.as_ref().unwrap());
+
+    let _ = vec
+        .iter()
+        .filter(|f| f.field.is_ok())
+        .map(|f| f.field.as_deref().unwrap());
+
+    let _ = vec
+        .iter_mut()
+        .filter(|f| f.field.is_ok())
+        .map(|f| f.field.as_mut().unwrap());
+
+    let _ = vec
+        .iter_mut()
+        .filter(|f| f.field.is_ok())
+        .map(|f| f.field.as_deref_mut().unwrap());
+
+    let _ = vec
+        .iter()
+        .filter(|f| f.field.is_ok())
+        .map(|f| f.field.to_owned().unwrap());
 }
diff --git a/tests/ui/manual_filter_map.stderr b/tests/ui/manual_filter_map.stderr
index a78343e882f..5e67ca348fa 100644
--- a/tests/ui/manual_filter_map.stderr
+++ b/tests/ui/manual_filter_map.stderr
@@ -32,5 +32,45 @@ error: `filter(..).map(..)` can be simplified as `filter_map(..)`
 LL |     let _ = vec.iter().filter(|f| f.field.is_ok()).map(|f| f.field.clone().unwrap());
    |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `filter_map(|f| f.field.clone().ok())`
 
-error: aborting due to 5 previous errors
+error: `filter(..).map(..)` can be simplified as `filter_map(..)`
+  --> $DIR/manual_filter_map.rs:63:10
+   |
+LL |           .filter(|f| f.field.is_ok())
+   |  __________^
+LL | |         .map(|f| f.field.as_ref().unwrap());
+   | |___________________________________________^ help: try: `filter_map(|f| f.field.as_ref().ok())`
+
+error: `filter(..).map(..)` can be simplified as `filter_map(..)`
+  --> $DIR/manual_filter_map.rs:68:10
+   |
+LL |           .filter(|f| f.field.is_ok())
+   |  __________^
+LL | |         .map(|f| f.field.as_deref().unwrap());
+   | |_____________________________________________^ help: try: `filter_map(|f| f.field.as_deref().ok())`
+
+error: `filter(..).map(..)` can be simplified as `filter_map(..)`
+  --> $DIR/manual_filter_map.rs:73:10
+   |
+LL |           .filter(|f| f.field.is_ok())
+   |  __________^
+LL | |         .map(|f| f.field.as_mut().unwrap());
+   | |___________________________________________^ help: try: `filter_map(|f| f.field.as_mut().ok())`
+
+error: `filter(..).map(..)` can be simplified as `filter_map(..)`
+  --> $DIR/manual_filter_map.rs:78:10
+   |
+LL |           .filter(|f| f.field.is_ok())
+   |  __________^
+LL | |         .map(|f| f.field.as_deref_mut().unwrap());
+   | |_________________________________________________^ help: try: `filter_map(|f| f.field.as_deref_mut().ok())`
+
+error: `filter(..).map(..)` can be simplified as `filter_map(..)`
+  --> $DIR/manual_filter_map.rs:83:10
+   |
+LL |           .filter(|f| f.field.is_ok())
+   |  __________^
+LL | |         .map(|f| f.field.to_owned().unwrap());
+   | |_____________________________________________^ help: try: `filter_map(|f| f.field.to_owned().ok())`
+
+error: aborting due to 10 previous errors
 
diff --git a/tests/ui/manual_find_map.fixed b/tests/ui/manual_find_map.fixed
index d78d72d8e8f..e7b5081ea59 100644
--- a/tests/ui/manual_find_map.fixed
+++ b/tests/ui/manual_find_map.fixed
@@ -50,8 +50,26 @@ fn issue_8920() {
     }];
     let _ = vec.iter().find_map(|f| f.field.clone());
 
-    let vec = vec![ResultFoo {
+    let mut vec = vec![ResultFoo {
         field: Ok(String::from("str")),
     }];
     let _ = vec.iter().find_map(|f| f.field.clone().ok());
+
+    let _ = vec.iter().find_map(|f| f.field.as_ref().ok());
+
+    let _ = vec
+        .iter()
+        .find_map(|f| f.field.as_deref().ok());
+
+    let _ = vec
+        .iter_mut()
+        .find_map(|f| f.field.as_mut().ok());
+
+    let _ = vec
+        .iter_mut()
+        .find_map(|f| f.field.as_deref_mut().ok());
+
+    let _ = vec
+        .iter()
+        .find_map(|f| f.field.to_owned().ok());
 }
diff --git a/tests/ui/manual_find_map.rs b/tests/ui/manual_find_map.rs
index 74e8e52ed16..46badbb9a18 100644
--- a/tests/ui/manual_find_map.rs
+++ b/tests/ui/manual_find_map.rs
@@ -50,8 +50,30 @@ fn issue_8920() {
     }];
     let _ = vec.iter().find(|f| f.field.is_some()).map(|f| f.field.clone().unwrap());
 
-    let vec = vec![ResultFoo {
+    let mut vec = vec![ResultFoo {
         field: Ok(String::from("str")),
     }];
     let _ = vec.iter().find(|f| f.field.is_ok()).map(|f| f.field.clone().unwrap());
+
+    let _ = vec.iter().find(|f| f.field.is_ok()).map(|f| f.field.as_ref().unwrap());
+
+    let _ = vec
+        .iter()
+        .find(|f| f.field.is_ok())
+        .map(|f| f.field.as_deref().unwrap());
+
+    let _ = vec
+        .iter_mut()
+        .find(|f| f.field.is_ok())
+        .map(|f| f.field.as_mut().unwrap());
+
+    let _ = vec
+        .iter_mut()
+        .find(|f| f.field.is_ok())
+        .map(|f| f.field.as_deref_mut().unwrap());
+
+    let _ = vec
+        .iter()
+        .find(|f| f.field.is_ok())
+        .map(|f| f.field.to_owned().unwrap());
 }
diff --git a/tests/ui/manual_find_map.stderr b/tests/ui/manual_find_map.stderr
index 0b1465a8422..2b6955a17df 100644
--- a/tests/ui/manual_find_map.stderr
+++ b/tests/ui/manual_find_map.stderr
@@ -30,5 +30,43 @@ error: `find(..).map(..)` can be simplified as `find_map(..)`
 LL |     let _ = vec.iter().find(|f| f.field.is_ok()).map(|f| f.field.clone().unwrap());
    |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|f| f.field.clone().ok())`
 
-error: aborting due to 5 previous errors
+error: `find(..).map(..)` can be simplified as `find_map(..)`
+  --> $DIR/manual_find_map.rs:58:24
+   |
+LL |     let _ = vec.iter().find(|f| f.field.is_ok()).map(|f| f.field.as_ref().unwrap());
+   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|f| f.field.as_ref().ok())`
+
+error: `find(..).map(..)` can be simplified as `find_map(..)`
+  --> $DIR/manual_find_map.rs:62:10
+   |
+LL |           .find(|f| f.field.is_ok())
+   |  __________^
+LL | |         .map(|f| f.field.as_deref().unwrap());
+   | |_____________________________________________^ help: try: `find_map(|f| f.field.as_deref().ok())`
+
+error: `find(..).map(..)` can be simplified as `find_map(..)`
+  --> $DIR/manual_find_map.rs:67:10
+   |
+LL |           .find(|f| f.field.is_ok())
+   |  __________^
+LL | |         .map(|f| f.field.as_mut().unwrap());
+   | |___________________________________________^ help: try: `find_map(|f| f.field.as_mut().ok())`
+
+error: `find(..).map(..)` can be simplified as `find_map(..)`
+  --> $DIR/manual_find_map.rs:72:10
+   |
+LL |           .find(|f| f.field.is_ok())
+   |  __________^
+LL | |         .map(|f| f.field.as_deref_mut().unwrap());
+   | |_________________________________________________^ help: try: `find_map(|f| f.field.as_deref_mut().ok())`
+
+error: `find(..).map(..)` can be simplified as `find_map(..)`
+  --> $DIR/manual_find_map.rs:77:10
+   |
+LL |           .find(|f| f.field.is_ok())
+   |  __________^
+LL | |         .map(|f| f.field.to_owned().unwrap());
+   | |_____________________________________________^ help: try: `find_map(|f| f.field.to_owned().ok())`
+
+error: aborting due to 10 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 5a49918f36adc9fb176a9be59b6fc2afd46c3572 Mon Sep 17 00:00:00 2001
From: DevAccentor <dev.accentor@gmail.com>
Date: Sat, 4 Jun 2022 11:03:11 +0200
Subject: improve for_loops_over_fallibles to detect the usage of iter,
 iter_mut and into_iterator

---
 clippy_lints/src/loops/for_loops_over_fallibles.rs | 40 +++++++++++++++------
 clippy_lints/src/loops/mod.rs                      | 12 +++++--
 tests/ui/for_loops_over_fallibles.rs               | 17 ++++++++-
 tests/ui/for_loops_over_fallibles.stderr           | 40 ++++++++++++++++-----
 tests/ui/manual_map_option.fixed                   |  1 +
 tests/ui/manual_map_option.rs                      |  1 +
 tests/ui/manual_map_option.stderr                  | 42 +++++++++++-----------
 7 files changed, 110 insertions(+), 43 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/for_loops_over_fallibles.rs b/clippy_lints/src/loops/for_loops_over_fallibles.rs
index 90530ebf003..77de90fd7b9 100644
--- a/clippy_lints/src/loops/for_loops_over_fallibles.rs
+++ b/clippy_lints/src/loops/for_loops_over_fallibles.rs
@@ -7,9 +7,22 @@ use rustc_lint::LateContext;
 use rustc_span::symbol::sym;
 
 /// Checks for `for` loops over `Option`s and `Result`s.
-pub(super) fn check(cx: &LateContext<'_>, pat: &Pat<'_>, arg: &Expr<'_>) {
+pub(super) fn check(cx: &LateContext<'_>, pat: &Pat<'_>, arg: &Expr<'_>, method_name: Option<&str>) {
     let ty = cx.typeck_results().expr_ty(arg);
     if is_type_diagnostic_item(cx, ty, sym::Option) {
+        let help_string = if let Some(method_name) = method_name {
+            format!(
+                "consider replacing `for {0} in {1}.{method_name}()` with `if let Some({0}) = {1}`",
+                snippet(cx, pat.span, "_"),
+                snippet(cx, arg.span, "_")
+            )
+        } else {
+            format!(
+                "consider replacing `for {0} in {1}` with `if let Some({0}) = {1}`",
+                snippet(cx, pat.span, "_"),
+                snippet(cx, arg.span, "_")
+            )
+        };
         span_lint_and_help(
             cx,
             FOR_LOOPS_OVER_FALLIBLES,
@@ -20,13 +33,22 @@ pub(super) fn check(cx: &LateContext<'_>, pat: &Pat<'_>, arg: &Expr<'_>) {
                 snippet(cx, arg.span, "_")
             ),
             None,
-            &format!(
-                "consider replacing `for {0} in {1}` with `if let Some({0}) = {1}`",
-                snippet(cx, pat.span, "_"),
-                snippet(cx, arg.span, "_")
-            ),
+            &help_string,
         );
     } else if is_type_diagnostic_item(cx, ty, sym::Result) {
+        let help_string = if let Some(method_name) = method_name {
+            format!(
+                "consider replacing `for {0} in {1}.{method_name}()` with `if let Ok({0}) = {1}`",
+                snippet(cx, pat.span, "_"),
+                snippet(cx, arg.span, "_")
+            )
+        } else {
+            format!(
+                "consider replacing `for {0} in {1}` with `if let Ok({0}) = {1}`",
+                snippet(cx, pat.span, "_"),
+                snippet(cx, arg.span, "_")
+            )
+        };
         span_lint_and_help(
             cx,
             FOR_LOOPS_OVER_FALLIBLES,
@@ -37,11 +59,7 @@ pub(super) fn check(cx: &LateContext<'_>, pat: &Pat<'_>, arg: &Expr<'_>) {
                 snippet(cx, arg.span, "_")
             ),
             None,
-            &format!(
-                "consider replacing `for {0} in {1}` with `if let Ok({0}) = {1}`",
-                snippet(cx, pat.span, "_"),
-                snippet(cx, arg.span, "_")
-            ),
+            &help_string,
         );
     }
 }
diff --git a/clippy_lints/src/loops/mod.rs b/clippy_lints/src/loops/mod.rs
index d61be78895f..e32b228e104 100644
--- a/clippy_lints/src/loops/mod.rs
+++ b/clippy_lints/src/loops/mod.rs
@@ -188,6 +188,10 @@ declare_clippy_lint! {
     /// for x in &res {
     ///     // ..
     /// }
+    ///
+    /// for x in res.iter() {
+    ///     // ..
+    /// }
     /// ```
     ///
     /// Use instead:
@@ -695,10 +699,14 @@ fn check_for_loop_arg(cx: &LateContext<'_>, pat: &Pat<'_>, arg: &Expr<'_>) {
         let method_name = method.ident.as_str();
         // check for looping over x.iter() or x.iter_mut(), could use &x or &mut x
         match method_name {
-            "iter" | "iter_mut" => explicit_iter_loop::check(cx, self_arg, arg, method_name),
+            "iter" | "iter_mut" => {
+                explicit_iter_loop::check(cx, self_arg, arg, method_name);
+                for_loops_over_fallibles::check(cx, pat, self_arg, Some(method_name));
+            },
             "into_iter" => {
                 explicit_iter_loop::check(cx, self_arg, arg, method_name);
                 explicit_into_iter_loop::check(cx, self_arg, arg);
+                for_loops_over_fallibles::check(cx, pat, self_arg, Some(method_name));
             },
             "next" => {
                 next_loop_linted = iter_next_loop::check(cx, arg);
@@ -708,6 +716,6 @@ fn check_for_loop_arg(cx: &LateContext<'_>, pat: &Pat<'_>, arg: &Expr<'_>) {
     }
 
     if !next_loop_linted {
-        for_loops_over_fallibles::check(cx, pat, arg);
+        for_loops_over_fallibles::check(cx, pat, arg, None);
     }
 }
diff --git a/tests/ui/for_loops_over_fallibles.rs b/tests/ui/for_loops_over_fallibles.rs
index 1b9dde87cd5..bde78a9fd4a 100644
--- a/tests/ui/for_loops_over_fallibles.rs
+++ b/tests/ui/for_loops_over_fallibles.rs
@@ -2,7 +2,7 @@
 
 fn for_loops_over_fallibles() {
     let option = Some(1);
-    let result = option.ok_or("x not found");
+    let mut result = option.ok_or("x not found");
     let v = vec![0, 1, 2];
 
     // check over an `Option`
@@ -10,11 +10,26 @@ fn for_loops_over_fallibles() {
         println!("{}", x);
     }
 
+    // check over an `Option`
+    for x in option.iter() {
+        println!("{}", x);
+    }
+
     // check over a `Result`
     for x in result {
         println!("{}", x);
     }
 
+    // check over a `Result`
+    for x in result.into_iter() {
+        println!("{}", x);
+    }
+
+    // check over a `Result`
+    for x in result.iter_mut() {
+        println!("{}", x);
+    }
+
     for x in option.ok_or("x not found") {
         println!("{}", x);
     }
diff --git a/tests/ui/for_loops_over_fallibles.stderr b/tests/ui/for_loops_over_fallibles.stderr
index 52b94875aec..635e08182d5 100644
--- a/tests/ui/for_loops_over_fallibles.stderr
+++ b/tests/ui/for_loops_over_fallibles.stderr
@@ -7,16 +7,40 @@ LL |     for x in option {
    = note: `-D clippy::for-loops-over-fallibles` implied by `-D warnings`
    = help: consider replacing `for x in option` with `if let Some(x) = option`
 
-error: for loop over `result`, which is a `Result`. This is more readably written as an `if let` statement
+error: for loop over `option`, which is an `Option`. This is more readably written as an `if let` statement
   --> $DIR/for_loops_over_fallibles.rs:14:14
    |
+LL |     for x in option.iter() {
+   |              ^^^^^^
+   |
+   = help: consider replacing `for x in option.iter()` with `if let Some(x) = option`
+
+error: for loop over `result`, which is a `Result`. This is more readably written as an `if let` statement
+  --> $DIR/for_loops_over_fallibles.rs:19:14
+   |
 LL |     for x in result {
    |              ^^^^^^
    |
    = help: consider replacing `for x in result` with `if let Ok(x) = result`
 
+error: for loop over `result`, which is a `Result`. This is more readably written as an `if let` statement
+  --> $DIR/for_loops_over_fallibles.rs:24:14
+   |
+LL |     for x in result.into_iter() {
+   |              ^^^^^^
+   |
+   = help: consider replacing `for x in result.into_iter()` with `if let Ok(x) = result`
+
+error: for loop over `result`, which is a `Result`. This is more readably written as an `if let` statement
+  --> $DIR/for_loops_over_fallibles.rs:29:14
+   |
+LL |     for x in result.iter_mut() {
+   |              ^^^^^^
+   |
+   = help: consider replacing `for x in result.iter_mut()` with `if let Ok(x) = result`
+
 error: for loop over `option.ok_or("x not found")`, which is a `Result`. This is more readably written as an `if let` statement
-  --> $DIR/for_loops_over_fallibles.rs:18:14
+  --> $DIR/for_loops_over_fallibles.rs:33:14
    |
 LL |     for x in option.ok_or("x not found") {
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -24,7 +48,7 @@ LL |     for x in option.ok_or("x not found") {
    = help: consider replacing `for x in option.ok_or("x not found")` with `if let Ok(x) = option.ok_or("x not found")`
 
 error: you are iterating over `Iterator::next()` which is an Option; this will compile but is probably not what you want
-  --> $DIR/for_loops_over_fallibles.rs:24:14
+  --> $DIR/for_loops_over_fallibles.rs:39:14
    |
 LL |     for x in v.iter().next() {
    |              ^^^^^^^^^^^^^^^
@@ -32,7 +56,7 @@ LL |     for x in v.iter().next() {
    = note: `#[deny(clippy::iter_next_loop)]` on by default
 
 error: for loop over `v.iter().next().and(Some(0))`, which is an `Option`. This is more readably written as an `if let` statement
-  --> $DIR/for_loops_over_fallibles.rs:29:14
+  --> $DIR/for_loops_over_fallibles.rs:44:14
    |
 LL |     for x in v.iter().next().and(Some(0)) {
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -40,7 +64,7 @@ LL |     for x in v.iter().next().and(Some(0)) {
    = help: consider replacing `for x in v.iter().next().and(Some(0))` with `if let Some(x) = v.iter().next().and(Some(0))`
 
 error: for loop over `v.iter().next().ok_or("x not found")`, which is a `Result`. This is more readably written as an `if let` statement
-  --> $DIR/for_loops_over_fallibles.rs:33:14
+  --> $DIR/for_loops_over_fallibles.rs:48:14
    |
 LL |     for x in v.iter().next().ok_or("x not found") {
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -48,7 +72,7 @@ LL |     for x in v.iter().next().ok_or("x not found") {
    = help: consider replacing `for x in v.iter().next().ok_or("x not found")` with `if let Ok(x) = v.iter().next().ok_or("x not found")`
 
 error: this loop never actually loops
-  --> $DIR/for_loops_over_fallibles.rs:45:5
+  --> $DIR/for_loops_over_fallibles.rs:60:5
    |
 LL | /     while let Some(x) = option {
 LL | |         println!("{}", x);
@@ -59,7 +83,7 @@ LL | |     }
    = note: `#[deny(clippy::never_loop)]` on by default
 
 error: this loop never actually loops
-  --> $DIR/for_loops_over_fallibles.rs:51:5
+  --> $DIR/for_loops_over_fallibles.rs:66:5
    |
 LL | /     while let Ok(x) = result {
 LL | |         println!("{}", x);
@@ -67,5 +91,5 @@ LL | |         break;
 LL | |     }
    | |_____^
 
-error: aborting due to 8 previous errors
+error: aborting due to 11 previous errors
 
diff --git a/tests/ui/manual_map_option.fixed b/tests/ui/manual_map_option.fixed
index fc6a7abca0e..a59da4ae10b 100644
--- a/tests/ui/manual_map_option.fixed
+++ b/tests/ui/manual_map_option.fixed
@@ -7,6 +7,7 @@
     clippy::unit_arg,
     clippy::match_ref_pats,
     clippy::redundant_pattern_matching,
+    clippy::for_loops_over_fallibles,
     dead_code
 )]
 
diff --git a/tests/ui/manual_map_option.rs b/tests/ui/manual_map_option.rs
index 16508270f64..0bdbefa51e8 100644
--- a/tests/ui/manual_map_option.rs
+++ b/tests/ui/manual_map_option.rs
@@ -7,6 +7,7 @@
     clippy::unit_arg,
     clippy::match_ref_pats,
     clippy::redundant_pattern_matching,
+    clippy::for_loops_over_fallibles,
     dead_code
 )]
 
diff --git a/tests/ui/manual_map_option.stderr b/tests/ui/manual_map_option.stderr
index 0036b8151de..cdc2c0e62a9 100644
--- a/tests/ui/manual_map_option.stderr
+++ b/tests/ui/manual_map_option.stderr
@@ -1,5 +1,5 @@
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:14:5
+  --> $DIR/manual_map_option.rs:15:5
    |
 LL | /     match Some(0) {
 LL | |         Some(_) => Some(2),
@@ -10,7 +10,7 @@ LL | |     };
    = note: `-D clippy::manual-map` implied by `-D warnings`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:19:5
+  --> $DIR/manual_map_option.rs:20:5
    |
 LL | /     match Some(0) {
 LL | |         Some(x) => Some(x + 1),
@@ -19,7 +19,7 @@ LL | |     };
    | |_____^ help: try this: `Some(0).map(|x| x + 1)`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:24:5
+  --> $DIR/manual_map_option.rs:25:5
    |
 LL | /     match Some("") {
 LL | |         Some(x) => Some(x.is_empty()),
@@ -28,7 +28,7 @@ LL | |     };
    | |_____^ help: try this: `Some("").map(|x| x.is_empty())`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:29:5
+  --> $DIR/manual_map_option.rs:30:5
    |
 LL | /     if let Some(x) = Some(0) {
 LL | |         Some(!x)
@@ -38,7 +38,7 @@ LL | |     };
    | |_____^ help: try this: `Some(0).map(|x| !x)`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:36:5
+  --> $DIR/manual_map_option.rs:37:5
    |
 LL | /     match Some(0) {
 LL | |         Some(x) => { Some(std::convert::identity(x)) }
@@ -47,7 +47,7 @@ LL | |     };
    | |_____^ help: try this: `Some(0).map(std::convert::identity)`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:41:5
+  --> $DIR/manual_map_option.rs:42:5
    |
 LL | /     match Some(&String::new()) {
 LL | |         Some(x) => Some(str::len(x)),
@@ -56,7 +56,7 @@ LL | |     };
    | |_____^ help: try this: `Some(&String::new()).map(|x| str::len(x))`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:51:5
+  --> $DIR/manual_map_option.rs:52:5
    |
 LL | /     match &Some([0, 1]) {
 LL | |         Some(x) => Some(x[0]),
@@ -65,7 +65,7 @@ LL | |     };
    | |_____^ help: try this: `Some([0, 1]).as_ref().map(|x| x[0])`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:56:5
+  --> $DIR/manual_map_option.rs:57:5
    |
 LL | /     match &Some(0) {
 LL | |         &Some(x) => Some(x * 2),
@@ -74,7 +74,7 @@ LL | |     };
    | |_____^ help: try this: `Some(0).map(|x| x * 2)`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:61:5
+  --> $DIR/manual_map_option.rs:62:5
    |
 LL | /     match Some(String::new()) {
 LL | |         Some(ref x) => Some(x.is_empty()),
@@ -83,7 +83,7 @@ LL | |     };
    | |_____^ help: try this: `Some(String::new()).as_ref().map(|x| x.is_empty())`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:66:5
+  --> $DIR/manual_map_option.rs:67:5
    |
 LL | /     match &&Some(String::new()) {
 LL | |         Some(x) => Some(x.len()),
@@ -92,7 +92,7 @@ LL | |     };
    | |_____^ help: try this: `Some(String::new()).as_ref().map(|x| x.len())`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:71:5
+  --> $DIR/manual_map_option.rs:72:5
    |
 LL | /     match &&Some(0) {
 LL | |         &&Some(x) => Some(x + x),
@@ -101,7 +101,7 @@ LL | |     };
    | |_____^ help: try this: `Some(0).map(|x| x + x)`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:84:9
+  --> $DIR/manual_map_option.rs:85:9
    |
 LL | /         match &mut Some(String::new()) {
 LL | |             Some(x) => Some(x.push_str("")),
@@ -110,7 +110,7 @@ LL | |         };
    | |_________^ help: try this: `Some(String::new()).as_mut().map(|x| x.push_str(""))`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:90:5
+  --> $DIR/manual_map_option.rs:91:5
    |
 LL | /     match &mut Some(String::new()) {
 LL | |         Some(ref x) => Some(x.len()),
@@ -119,7 +119,7 @@ LL | |     };
    | |_____^ help: try this: `Some(String::new()).as_ref().map(|x| x.len())`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:95:5
+  --> $DIR/manual_map_option.rs:96:5
    |
 LL | /     match &mut &Some(String::new()) {
 LL | |         Some(x) => Some(x.is_empty()),
@@ -128,7 +128,7 @@ LL | |     };
    | |_____^ help: try this: `Some(String::new()).as_ref().map(|x| x.is_empty())`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:100:5
+  --> $DIR/manual_map_option.rs:101:5
    |
 LL | /     match Some((0, 1, 2)) {
 LL | |         Some((x, y, z)) => Some(x + y + z),
@@ -137,7 +137,7 @@ LL | |     };
    | |_____^ help: try this: `Some((0, 1, 2)).map(|(x, y, z)| x + y + z)`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:105:5
+  --> $DIR/manual_map_option.rs:106:5
    |
 LL | /     match Some([1, 2, 3]) {
 LL | |         Some([first, ..]) => Some(first),
@@ -146,7 +146,7 @@ LL | |     };
    | |_____^ help: try this: `Some([1, 2, 3]).map(|[first, ..]| first)`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:110:5
+  --> $DIR/manual_map_option.rs:111:5
    |
 LL | /     match &Some((String::new(), "test")) {
 LL | |         Some((x, y)) => Some((y, x)),
@@ -155,7 +155,7 @@ LL | |     };
    | |_____^ help: try this: `Some((String::new(), "test")).as_ref().map(|(x, y)| (y, x))`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:168:5
+  --> $DIR/manual_map_option.rs:169:5
    |
 LL | /     match Some(0) {
 LL | |         Some(x) => Some(vec![x]),
@@ -164,7 +164,7 @@ LL | |     };
    | |_____^ help: try this: `Some(0).map(|x| vec![x])`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:173:5
+  --> $DIR/manual_map_option.rs:174:5
    |
 LL | /     match option_env!("") {
 LL | |         Some(x) => Some(String::from(x)),
@@ -173,7 +173,7 @@ LL | |     };
    | |_____^ help: try this: `option_env!("").map(String::from)`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:193:12
+  --> $DIR/manual_map_option.rs:194:12
    |
 LL |       } else if let Some(x) = Some(0) {
    |  ____________^
@@ -184,7 +184,7 @@ LL | |     };
    | |_____^ help: try this: `{ Some(0).map(|x| x + 1) }`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:201:12
+  --> $DIR/manual_map_option.rs:202:12
    |
 LL |       } else if let Some(x) = Some(0) {
    |  ____________^
-- 
cgit 1.4.1-3-g733a5


From 42cf98553a72f4b6cdac2c4c6378121d30f3bf5f Mon Sep 17 00:00:00 2001
From: kyoto7250 <50972773+kyoto7250@users.noreply.github.com>
Date: Sat, 4 Jun 2022 21:20:41 +0900
Subject: refactor: check copied and cloned

---
 clippy_lints/src/methods/filter_map.rs |  4 +-
 tests/ui/manual_filter_map.fixed       | 44 +++++++++++---------
 tests/ui/manual_filter_map.rs          | 59 ++++++++++++++++-----------
 tests/ui/manual_filter_map.stderr      | 74 +++++++++++++++++++++-------------
 tests/ui/manual_find_map.fixed         | 48 +++++++++++++---------
 tests/ui/manual_find_map.rs            | 61 ++++++++++++++++++----------
 tests/ui/manual_find_map.stderr        | 74 ++++++++++++++++++++++------------
 7 files changed, 227 insertions(+), 137 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/filter_map.rs b/clippy_lints/src/methods/filter_map.rs
index 6cabe74fdef..7127d8242d8 100644
--- a/clippy_lints/src/methods/filter_map.rs
+++ b/clippy_lints/src/methods/filter_map.rs
@@ -181,9 +181,11 @@ pub(super) fn check<'tcx>(
 }
 
 fn acceptable_methods(method: &PathSegment<'_>) -> bool {
-    let methods: [Symbol; 6] = [
+    let methods: [Symbol; 8] = [
         sym::clone,
         sym::as_ref,
+        sym!(copied),
+        sym!(cloned),
         sym!(as_deref),
         sym!(as_mut),
         sym!(as_deref_mut),
diff --git a/tests/ui/manual_filter_map.fixed b/tests/ui/manual_filter_map.fixed
index 9de7040000a..de0d8614889 100644
--- a/tests/ui/manual_filter_map.fixed
+++ b/tests/ui/manual_filter_map.fixed
@@ -36,44 +36,52 @@ fn to_res<T>(_: T) -> Result<T, ()> {
     unimplemented!()
 }
 
-struct OptionFoo {
-    field: Option<String>,
-}
-
-struct ResultFoo {
-    field: Result<String, ()>,
+struct Issue8920<'a> {
+    option_field: Option<String>,
+    result_field: Result<String, ()>,
+    ref_field: Option<&'a usize>,
 }
 
 fn issue_8920() {
-    let vec = vec![OptionFoo {
-        field: Some(String::from("str")),
+    let mut vec = vec![Issue8920 {
+        option_field: Some(String::from("str")),
+        result_field: Ok(String::from("str")),
+        ref_field: Some(&1),
     }];
+
     let _ = vec
         .iter()
-        .filter_map(|f| f.field.clone());
+        .filter_map(|f| f.option_field.clone());
 
-    let mut vec = vec![ResultFoo {
-        field: Ok(String::from("str")),
-    }];
-    let _ = vec.iter().filter_map(|f| f.field.clone().ok());
+    let _ = vec
+        .iter()
+        .filter_map(|f| f.ref_field.cloned());
+
+    let _ = vec
+        .iter()
+        .filter_map(|f| f.ref_field.copied());
+
+    let _ = vec
+        .iter()
+        .filter_map(|f| f.result_field.clone().ok());
 
     let _ = vec
         .iter()
-        .filter_map(|f| f.field.as_ref().ok());
+        .filter_map(|f| f.result_field.as_ref().ok());
 
     let _ = vec
         .iter()
-        .filter_map(|f| f.field.as_deref().ok());
+        .filter_map(|f| f.result_field.as_deref().ok());
 
     let _ = vec
         .iter_mut()
-        .filter_map(|f| f.field.as_mut().ok());
+        .filter_map(|f| f.result_field.as_mut().ok());
 
     let _ = vec
         .iter_mut()
-        .filter_map(|f| f.field.as_deref_mut().ok());
+        .filter_map(|f| f.result_field.as_deref_mut().ok());
 
     let _ = vec
         .iter()
-        .filter_map(|f| f.field.to_owned().ok());
+        .filter_map(|f| f.result_field.to_owned().ok());
 }
diff --git a/tests/ui/manual_filter_map.rs b/tests/ui/manual_filter_map.rs
index 6766078d694..bd6516f038b 100644
--- a/tests/ui/manual_filter_map.rs
+++ b/tests/ui/manual_filter_map.rs
@@ -36,50 +36,61 @@ fn to_res<T>(_: T) -> Result<T, ()> {
     unimplemented!()
 }
 
-struct OptionFoo {
-    field: Option<String>,
-}
-
-struct ResultFoo {
-    field: Result<String, ()>,
+struct Issue8920<'a> {
+    option_field: Option<String>,
+    result_field: Result<String, ()>,
+    ref_field: Option<&'a usize>,
 }
 
 fn issue_8920() {
-    let vec = vec![OptionFoo {
-        field: Some(String::from("str")),
+    let mut vec = vec![Issue8920 {
+        option_field: Some(String::from("str")),
+        result_field: Ok(String::from("str")),
+        ref_field: Some(&1),
     }];
+
     let _ = vec
         .iter()
-        .filter(|f| f.field.is_some())
-        .map(|f| f.field.clone().unwrap());
+        .filter(|f| f.option_field.is_some())
+        .map(|f| f.option_field.clone().unwrap());
 
-    let mut vec = vec![ResultFoo {
-        field: Ok(String::from("str")),
-    }];
-    let _ = vec.iter().filter(|f| f.field.is_ok()).map(|f| f.field.clone().unwrap());
+    let _ = vec
+        .iter()
+        .filter(|f| f.ref_field.is_some())
+        .map(|f| f.ref_field.cloned().unwrap());
+
+    let _ = vec
+        .iter()
+        .filter(|f| f.ref_field.is_some())
+        .map(|f| f.ref_field.copied().unwrap());
+
+    let _ = vec
+        .iter()
+        .filter(|f| f.result_field.is_ok())
+        .map(|f| f.result_field.clone().unwrap());
 
     let _ = vec
         .iter()
-        .filter(|f| f.field.is_ok())
-        .map(|f| f.field.as_ref().unwrap());
+        .filter(|f| f.result_field.is_ok())
+        .map(|f| f.result_field.as_ref().unwrap());
 
     let _ = vec
         .iter()
-        .filter(|f| f.field.is_ok())
-        .map(|f| f.field.as_deref().unwrap());
+        .filter(|f| f.result_field.is_ok())
+        .map(|f| f.result_field.as_deref().unwrap());
 
     let _ = vec
         .iter_mut()
-        .filter(|f| f.field.is_ok())
-        .map(|f| f.field.as_mut().unwrap());
+        .filter(|f| f.result_field.is_ok())
+        .map(|f| f.result_field.as_mut().unwrap());
 
     let _ = vec
         .iter_mut()
-        .filter(|f| f.field.is_ok())
-        .map(|f| f.field.as_deref_mut().unwrap());
+        .filter(|f| f.result_field.is_ok())
+        .map(|f| f.result_field.as_deref_mut().unwrap());
 
     let _ = vec
         .iter()
-        .filter(|f| f.field.is_ok())
-        .map(|f| f.field.to_owned().unwrap());
+        .filter(|f| f.result_field.is_ok())
+        .map(|f| f.result_field.to_owned().unwrap());
 }
diff --git a/tests/ui/manual_filter_map.stderr b/tests/ui/manual_filter_map.stderr
index 5e67ca348fa..465f1b19110 100644
--- a/tests/ui/manual_filter_map.stderr
+++ b/tests/ui/manual_filter_map.stderr
@@ -19,58 +19,76 @@ LL |     let _ = (0..).filter(|&n| to_res(n).is_ok()).map(|a| to_res(a).unwrap_o
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `filter_map(|a| to_res(a).ok())`
 
 error: `filter(..).map(..)` can be simplified as `filter_map(..)`
-  --> $DIR/manual_filter_map.rs:53:10
+  --> $DIR/manual_filter_map.rs:54:10
    |
-LL |           .filter(|f| f.field.is_some())
+LL |           .filter(|f| f.option_field.is_some())
    |  __________^
-LL | |         .map(|f| f.field.clone().unwrap());
-   | |__________________________________________^ help: try: `filter_map(|f| f.field.clone())`
+LL | |         .map(|f| f.option_field.clone().unwrap());
+   | |_________________________________________________^ help: try: `filter_map(|f| f.option_field.clone())`
 
 error: `filter(..).map(..)` can be simplified as `filter_map(..)`
-  --> $DIR/manual_filter_map.rs:59:24
+  --> $DIR/manual_filter_map.rs:59:10
    |
-LL |     let _ = vec.iter().filter(|f| f.field.is_ok()).map(|f| f.field.clone().unwrap());
-   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `filter_map(|f| f.field.clone().ok())`
+LL |           .filter(|f| f.ref_field.is_some())
+   |  __________^
+LL | |         .map(|f| f.ref_field.cloned().unwrap());
+   | |_______________________________________________^ help: try: `filter_map(|f| f.ref_field.cloned())`
+
+error: `filter(..).map(..)` can be simplified as `filter_map(..)`
+  --> $DIR/manual_filter_map.rs:64:10
+   |
+LL |           .filter(|f| f.ref_field.is_some())
+   |  __________^
+LL | |         .map(|f| f.ref_field.copied().unwrap());
+   | |_______________________________________________^ help: try: `filter_map(|f| f.ref_field.copied())`
+
+error: `filter(..).map(..)` can be simplified as `filter_map(..)`
+  --> $DIR/manual_filter_map.rs:69:10
+   |
+LL |           .filter(|f| f.result_field.is_ok())
+   |  __________^
+LL | |         .map(|f| f.result_field.clone().unwrap());
+   | |_________________________________________________^ help: try: `filter_map(|f| f.result_field.clone().ok())`
 
 error: `filter(..).map(..)` can be simplified as `filter_map(..)`
-  --> $DIR/manual_filter_map.rs:63:10
+  --> $DIR/manual_filter_map.rs:74:10
    |
-LL |           .filter(|f| f.field.is_ok())
+LL |           .filter(|f| f.result_field.is_ok())
    |  __________^
-LL | |         .map(|f| f.field.as_ref().unwrap());
-   | |___________________________________________^ help: try: `filter_map(|f| f.field.as_ref().ok())`
+LL | |         .map(|f| f.result_field.as_ref().unwrap());
+   | |__________________________________________________^ help: try: `filter_map(|f| f.result_field.as_ref().ok())`
 
 error: `filter(..).map(..)` can be simplified as `filter_map(..)`
-  --> $DIR/manual_filter_map.rs:68:10
+  --> $DIR/manual_filter_map.rs:79:10
    |
-LL |           .filter(|f| f.field.is_ok())
+LL |           .filter(|f| f.result_field.is_ok())
    |  __________^
-LL | |         .map(|f| f.field.as_deref().unwrap());
-   | |_____________________________________________^ help: try: `filter_map(|f| f.field.as_deref().ok())`
+LL | |         .map(|f| f.result_field.as_deref().unwrap());
+   | |____________________________________________________^ help: try: `filter_map(|f| f.result_field.as_deref().ok())`
 
 error: `filter(..).map(..)` can be simplified as `filter_map(..)`
-  --> $DIR/manual_filter_map.rs:73:10
+  --> $DIR/manual_filter_map.rs:84:10
    |
-LL |           .filter(|f| f.field.is_ok())
+LL |           .filter(|f| f.result_field.is_ok())
    |  __________^
-LL | |         .map(|f| f.field.as_mut().unwrap());
-   | |___________________________________________^ help: try: `filter_map(|f| f.field.as_mut().ok())`
+LL | |         .map(|f| f.result_field.as_mut().unwrap());
+   | |__________________________________________________^ help: try: `filter_map(|f| f.result_field.as_mut().ok())`
 
 error: `filter(..).map(..)` can be simplified as `filter_map(..)`
-  --> $DIR/manual_filter_map.rs:78:10
+  --> $DIR/manual_filter_map.rs:89:10
    |
-LL |           .filter(|f| f.field.is_ok())
+LL |           .filter(|f| f.result_field.is_ok())
    |  __________^
-LL | |         .map(|f| f.field.as_deref_mut().unwrap());
-   | |_________________________________________________^ help: try: `filter_map(|f| f.field.as_deref_mut().ok())`
+LL | |         .map(|f| f.result_field.as_deref_mut().unwrap());
+   | |________________________________________________________^ help: try: `filter_map(|f| f.result_field.as_deref_mut().ok())`
 
 error: `filter(..).map(..)` can be simplified as `filter_map(..)`
-  --> $DIR/manual_filter_map.rs:83:10
+  --> $DIR/manual_filter_map.rs:94:10
    |
-LL |           .filter(|f| f.field.is_ok())
+LL |           .filter(|f| f.result_field.is_ok())
    |  __________^
-LL | |         .map(|f| f.field.to_owned().unwrap());
-   | |_____________________________________________^ help: try: `filter_map(|f| f.field.to_owned().ok())`
+LL | |         .map(|f| f.result_field.to_owned().unwrap());
+   | |____________________________________________________^ help: try: `filter_map(|f| f.result_field.to_owned().ok())`
 
-error: aborting due to 10 previous errors
+error: aborting due to 12 previous errors
 
diff --git a/tests/ui/manual_find_map.fixed b/tests/ui/manual_find_map.fixed
index e7b5081ea59..d69b6c1dcf3 100644
--- a/tests/ui/manual_find_map.fixed
+++ b/tests/ui/manual_find_map.fixed
@@ -36,40 +36,52 @@ fn to_res<T>(_: T) -> Result<T, ()> {
     unimplemented!()
 }
 
-struct OptionFoo {
-    field: Option<String>,
-}
-
-struct ResultFoo {
-    field: Result<String, ()>,
+struct Issue8920<'a> {
+    option_field: Option<String>,
+    result_field: Result<String, ()>,
+    ref_field: Option<&'a usize>,
 }
 
 fn issue_8920() {
-    let vec = vec![OptionFoo {
-        field: Some(String::from("str")),
+    let mut vec = vec![Issue8920 {
+        option_field: Some(String::from("str")),
+        result_field: Ok(String::from("str")),
+        ref_field: Some(&1),
     }];
-    let _ = vec.iter().find_map(|f| f.field.clone());
 
-    let mut vec = vec![ResultFoo {
-        field: Ok(String::from("str")),
-    }];
-    let _ = vec.iter().find_map(|f| f.field.clone().ok());
+    let _ = vec
+        .iter()
+        .find_map(|f| f.option_field.clone());
+
+    let _ = vec
+        .iter()
+        .find_map(|f| f.ref_field.cloned());
 
-    let _ = vec.iter().find_map(|f| f.field.as_ref().ok());
+    let _ = vec
+        .iter()
+        .find_map(|f| f.ref_field.copied());
+
+    let _ = vec
+        .iter()
+        .find_map(|f| f.result_field.clone().ok());
+
+    let _ = vec
+        .iter()
+        .find_map(|f| f.result_field.as_ref().ok());
 
     let _ = vec
         .iter()
-        .find_map(|f| f.field.as_deref().ok());
+        .find_map(|f| f.result_field.as_deref().ok());
 
     let _ = vec
         .iter_mut()
-        .find_map(|f| f.field.as_mut().ok());
+        .find_map(|f| f.result_field.as_mut().ok());
 
     let _ = vec
         .iter_mut()
-        .find_map(|f| f.field.as_deref_mut().ok());
+        .find_map(|f| f.result_field.as_deref_mut().ok());
 
     let _ = vec
         .iter()
-        .find_map(|f| f.field.to_owned().ok());
+        .find_map(|f| f.result_field.to_owned().ok());
 }
diff --git a/tests/ui/manual_find_map.rs b/tests/ui/manual_find_map.rs
index 46badbb9a18..1c4e18e31c8 100644
--- a/tests/ui/manual_find_map.rs
+++ b/tests/ui/manual_find_map.rs
@@ -36,44 +36,61 @@ fn to_res<T>(_: T) -> Result<T, ()> {
     unimplemented!()
 }
 
-struct OptionFoo {
-    field: Option<String>,
-}
-
-struct ResultFoo {
-    field: Result<String, ()>,
+struct Issue8920<'a> {
+    option_field: Option<String>,
+    result_field: Result<String, ()>,
+    ref_field: Option<&'a usize>,
 }
 
 fn issue_8920() {
-    let vec = vec![OptionFoo {
-        field: Some(String::from("str")),
+    let mut vec = vec![Issue8920 {
+        option_field: Some(String::from("str")),
+        result_field: Ok(String::from("str")),
+        ref_field: Some(&1),
     }];
-    let _ = vec.iter().find(|f| f.field.is_some()).map(|f| f.field.clone().unwrap());
 
-    let mut vec = vec![ResultFoo {
-        field: Ok(String::from("str")),
-    }];
-    let _ = vec.iter().find(|f| f.field.is_ok()).map(|f| f.field.clone().unwrap());
+    let _ = vec
+        .iter()
+        .find(|f| f.option_field.is_some())
+        .map(|f| f.option_field.clone().unwrap());
+
+    let _ = vec
+        .iter()
+        .find(|f| f.ref_field.is_some())
+        .map(|f| f.ref_field.cloned().unwrap());
 
-    let _ = vec.iter().find(|f| f.field.is_ok()).map(|f| f.field.as_ref().unwrap());
+    let _ = vec
+        .iter()
+        .find(|f| f.ref_field.is_some())
+        .map(|f| f.ref_field.copied().unwrap());
+
+    let _ = vec
+        .iter()
+        .find(|f| f.result_field.is_ok())
+        .map(|f| f.result_field.clone().unwrap());
+
+    let _ = vec
+        .iter()
+        .find(|f| f.result_field.is_ok())
+        .map(|f| f.result_field.as_ref().unwrap());
 
     let _ = vec
         .iter()
-        .find(|f| f.field.is_ok())
-        .map(|f| f.field.as_deref().unwrap());
+        .find(|f| f.result_field.is_ok())
+        .map(|f| f.result_field.as_deref().unwrap());
 
     let _ = vec
         .iter_mut()
-        .find(|f| f.field.is_ok())
-        .map(|f| f.field.as_mut().unwrap());
+        .find(|f| f.result_field.is_ok())
+        .map(|f| f.result_field.as_mut().unwrap());
 
     let _ = vec
         .iter_mut()
-        .find(|f| f.field.is_ok())
-        .map(|f| f.field.as_deref_mut().unwrap());
+        .find(|f| f.result_field.is_ok())
+        .map(|f| f.result_field.as_deref_mut().unwrap());
 
     let _ = vec
         .iter()
-        .find(|f| f.field.is_ok())
-        .map(|f| f.field.to_owned().unwrap());
+        .find(|f| f.result_field.is_ok())
+        .map(|f| f.result_field.to_owned().unwrap());
 }
diff --git a/tests/ui/manual_find_map.stderr b/tests/ui/manual_find_map.stderr
index 2b6955a17df..9dea42b7686 100644
--- a/tests/ui/manual_find_map.stderr
+++ b/tests/ui/manual_find_map.stderr
@@ -19,54 +19,76 @@ LL |     let _ = (0..).find(|&n| to_res(n).is_ok()).map(|a| to_res(a).unwrap_or(
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|a| to_res(a).ok())`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> $DIR/manual_find_map.rs:51:24
+  --> $DIR/manual_find_map.rs:54:10
    |
-LL |     let _ = vec.iter().find(|f| f.field.is_some()).map(|f| f.field.clone().unwrap());
-   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|f| f.field.clone())`
+LL |           .find(|f| f.option_field.is_some())
+   |  __________^
+LL | |         .map(|f| f.option_field.clone().unwrap());
+   | |_________________________________________________^ help: try: `find_map(|f| f.option_field.clone())`
+
+error: `find(..).map(..)` can be simplified as `find_map(..)`
+  --> $DIR/manual_find_map.rs:59:10
+   |
+LL |           .find(|f| f.ref_field.is_some())
+   |  __________^
+LL | |         .map(|f| f.ref_field.cloned().unwrap());
+   | |_______________________________________________^ help: try: `find_map(|f| f.ref_field.cloned())`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> $DIR/manual_find_map.rs:56:24
+  --> $DIR/manual_find_map.rs:64:10
    |
-LL |     let _ = vec.iter().find(|f| f.field.is_ok()).map(|f| f.field.clone().unwrap());
-   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|f| f.field.clone().ok())`
+LL |           .find(|f| f.ref_field.is_some())
+   |  __________^
+LL | |         .map(|f| f.ref_field.copied().unwrap());
+   | |_______________________________________________^ help: try: `find_map(|f| f.ref_field.copied())`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> $DIR/manual_find_map.rs:58:24
+  --> $DIR/manual_find_map.rs:69:10
    |
-LL |     let _ = vec.iter().find(|f| f.field.is_ok()).map(|f| f.field.as_ref().unwrap());
-   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|f| f.field.as_ref().ok())`
+LL |           .find(|f| f.result_field.is_ok())
+   |  __________^
+LL | |         .map(|f| f.result_field.clone().unwrap());
+   | |_________________________________________________^ help: try: `find_map(|f| f.result_field.clone().ok())`
+
+error: `find(..).map(..)` can be simplified as `find_map(..)`
+  --> $DIR/manual_find_map.rs:74:10
+   |
+LL |           .find(|f| f.result_field.is_ok())
+   |  __________^
+LL | |         .map(|f| f.result_field.as_ref().unwrap());
+   | |__________________________________________________^ help: try: `find_map(|f| f.result_field.as_ref().ok())`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> $DIR/manual_find_map.rs:62:10
+  --> $DIR/manual_find_map.rs:79:10
    |
-LL |           .find(|f| f.field.is_ok())
+LL |           .find(|f| f.result_field.is_ok())
    |  __________^
-LL | |         .map(|f| f.field.as_deref().unwrap());
-   | |_____________________________________________^ help: try: `find_map(|f| f.field.as_deref().ok())`
+LL | |         .map(|f| f.result_field.as_deref().unwrap());
+   | |____________________________________________________^ help: try: `find_map(|f| f.result_field.as_deref().ok())`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> $DIR/manual_find_map.rs:67:10
+  --> $DIR/manual_find_map.rs:84:10
    |
-LL |           .find(|f| f.field.is_ok())
+LL |           .find(|f| f.result_field.is_ok())
    |  __________^
-LL | |         .map(|f| f.field.as_mut().unwrap());
-   | |___________________________________________^ help: try: `find_map(|f| f.field.as_mut().ok())`
+LL | |         .map(|f| f.result_field.as_mut().unwrap());
+   | |__________________________________________________^ help: try: `find_map(|f| f.result_field.as_mut().ok())`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> $DIR/manual_find_map.rs:72:10
+  --> $DIR/manual_find_map.rs:89:10
    |
-LL |           .find(|f| f.field.is_ok())
+LL |           .find(|f| f.result_field.is_ok())
    |  __________^
-LL | |         .map(|f| f.field.as_deref_mut().unwrap());
-   | |_________________________________________________^ help: try: `find_map(|f| f.field.as_deref_mut().ok())`
+LL | |         .map(|f| f.result_field.as_deref_mut().unwrap());
+   | |________________________________________________________^ help: try: `find_map(|f| f.result_field.as_deref_mut().ok())`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> $DIR/manual_find_map.rs:77:10
+  --> $DIR/manual_find_map.rs:94:10
    |
-LL |           .find(|f| f.field.is_ok())
+LL |           .find(|f| f.result_field.is_ok())
    |  __________^
-LL | |         .map(|f| f.field.to_owned().unwrap());
-   | |_____________________________________________^ help: try: `find_map(|f| f.field.to_owned().ok())`
+LL | |         .map(|f| f.result_field.to_owned().unwrap());
+   | |____________________________________________________^ help: try: `find_map(|f| f.result_field.to_owned().ok())`
 
-error: aborting due to 10 previous errors
+error: aborting due to 12 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From c31b4a9d21c9a5af7fcd2ee7cf1fbec0589b9954 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Sat, 4 Jun 2022 14:35:44 +0200
Subject: List configuration values can now be extended instead of replaced

---
 clippy_lints/src/utils/conf.rs                     | 74 +++++++++++++++-------
 .../blacklisted_names_append/blacklisted_names.rs  | 10 +++
 .../blacklisted_names.stderr                       | 16 +++++
 tests/ui-toml/blacklisted_names_append/clippy.toml |  1 +
 .../blacklisted_names_replace/blacklisted_names.rs | 10 +++
 .../blacklisted_names.stderr                       | 10 +++
 .../ui-toml/blacklisted_names_replace/clippy.toml  |  1 +
 tests/ui-toml/doc_valid_idents_append/clippy.toml  |  1 +
 .../doc_valid_idents_append/doc_markdown.rs        | 12 ++++
 .../doc_valid_idents_append/doc_markdown.stderr    | 14 ++++
 tests/ui-toml/doc_valid_idents_replace/clippy.toml |  1 +
 .../doc_valid_idents_replace/doc_markdown.rs       | 12 ++++
 .../doc_valid_idents_replace/doc_markdown.stderr   | 36 +++++++++++
 13 files changed, 174 insertions(+), 24 deletions(-)
 create mode 100644 tests/ui-toml/blacklisted_names_append/blacklisted_names.rs
 create mode 100644 tests/ui-toml/blacklisted_names_append/blacklisted_names.stderr
 create mode 100644 tests/ui-toml/blacklisted_names_append/clippy.toml
 create mode 100644 tests/ui-toml/blacklisted_names_replace/blacklisted_names.rs
 create mode 100644 tests/ui-toml/blacklisted_names_replace/blacklisted_names.stderr
 create mode 100644 tests/ui-toml/blacklisted_names_replace/clippy.toml
 create mode 100644 tests/ui-toml/doc_valid_idents_append/clippy.toml
 create mode 100644 tests/ui-toml/doc_valid_idents_append/doc_markdown.rs
 create mode 100644 tests/ui-toml/doc_valid_idents_append/doc_markdown.stderr
 create mode 100644 tests/ui-toml/doc_valid_idents_replace/clippy.toml
 create mode 100644 tests/ui-toml/doc_valid_idents_replace/doc_markdown.rs
 create mode 100644 tests/ui-toml/doc_valid_idents_replace/doc_markdown.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index b5c5d35135f..38e5c5e5b73 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -9,6 +9,29 @@ use std::path::{Path, PathBuf};
 use std::str::FromStr;
 use std::{cmp, env, fmt, fs, io, iter};
 
+#[rustfmt::skip]
+const DEFAULT_DOC_VALID_IDENTS: &[&str] = &[
+    "KiB", "MiB", "GiB", "TiB", "PiB", "EiB",
+    "DirectX",
+    "ECMAScript",
+    "GPLv2", "GPLv3",
+    "GitHub", "GitLab",
+    "IPv4", "IPv6",
+    "ClojureScript", "CoffeeScript", "JavaScript", "PureScript", "TypeScript",
+    "NaN", "NaNs",
+    "OAuth", "GraphQL",
+    "OCaml",
+    "OpenGL", "OpenMP", "OpenSSH", "OpenSSL", "OpenStreetMap", "OpenDNS",
+    "WebGL",
+    "TensorFlow",
+    "TrueType",
+    "iOS", "macOS", "FreeBSD",
+    "TeX", "LaTeX", "BibTeX", "BibLaTeX",
+    "MinGW",
+    "CamelCase",
+];
+const DEFAULT_BLACKLISTED_NAMES: &[&str] = &["foo", "baz", "quux"];
+
 /// Holds information used by `MISSING_ENFORCED_IMPORT_RENAMES` lint.
 #[derive(Clone, Debug, Deserialize)]
 pub struct Rename {
@@ -178,8 +201,10 @@ define_Conf! {
     (msrv: Option<String> = None),
     /// Lint: BLACKLISTED_NAME.
     ///
-    /// The list of blacklisted names to lint about. NB: `bar` is not here since it has legitimate uses
-    (blacklisted_names: Vec<String> = ["foo", "baz", "quux"].iter().map(ToString::to_string).collect()),
+    /// The list of blacklisted names to lint about. NB: `bar` is not here since it has legitimate uses. The value
+    /// `".."` can be used as part of the list to indicate, that the configured values should be appended to the
+    /// default configuration of Clippy. By default any configuraction will replace the default value.
+    (blacklisted_names: Vec<String> = super::DEFAULT_BLACKLISTED_NAMES.iter().map(ToString::to_string).collect()),
     /// Lint: COGNITIVE_COMPLEXITY.
     ///
     /// The maximum cognitive complexity a function can have
@@ -191,27 +216,14 @@ define_Conf! {
     (cyclomatic_complexity_threshold: Option<u64> = None),
     /// Lint: DOC_MARKDOWN.
     ///
-    /// The list of words this lint should not consider as identifiers needing ticks
-    (doc_valid_idents: Vec<String> = [
-        "KiB", "MiB", "GiB", "TiB", "PiB", "EiB",
-        "DirectX",
-        "ECMAScript",
-        "GPLv2", "GPLv3",
-        "GitHub", "GitLab",
-        "IPv4", "IPv6",
-        "ClojureScript", "CoffeeScript", "JavaScript", "PureScript", "TypeScript",
-        "NaN", "NaNs",
-        "OAuth", "GraphQL",
-        "OCaml",
-        "OpenGL", "OpenMP", "OpenSSH", "OpenSSL", "OpenStreetMap", "OpenDNS",
-        "WebGL",
-        "TensorFlow",
-        "TrueType",
-        "iOS", "macOS", "FreeBSD",
-        "TeX", "LaTeX", "BibTeX", "BibLaTeX",
-        "MinGW",
-        "CamelCase",
-    ].iter().map(ToString::to_string).collect()),
+    /// The list of words this lint should not consider as identifiers needing ticks. The value
+    /// `".."` can be used as part of the list to indicate, that the configured values should be appended to the
+    /// default configuration of Clippy. By default any configuraction will replace the default value. For example:
+    /// * `doc-valid-idents = ["ClipPy"]` would replace the default list with `["ClipPy"]`.
+    /// * `doc-valid-idents = ["ClipPy", ".."]` would append `ClipPy` to the default list.
+    ///
+    /// Default list:
+    (doc_valid_idents: Vec<String> = super::DEFAULT_DOC_VALID_IDENTS.iter().map(ToString::to_string).collect()),
     /// Lint: TOO_MANY_ARGUMENTS.
     ///
     /// The maximum number of argument a function or method can have
@@ -401,7 +413,21 @@ pub fn read(path: &Path) -> TryConf {
         Err(e) => return TryConf::from_error(e),
         Ok(content) => content,
     };
-    toml::from_str(&content).unwrap_or_else(TryConf::from_error)
+    match toml::from_str::<TryConf>(&content) {
+        Ok(mut conf) => {
+            extend_vec_if_indicator_present(&mut conf.conf.doc_valid_idents, DEFAULT_DOC_VALID_IDENTS);
+            extend_vec_if_indicator_present(&mut conf.conf.blacklisted_names, DEFAULT_BLACKLISTED_NAMES);
+
+            conf
+        },
+        Err(e) => TryConf::from_error(e),
+    }
+}
+
+fn extend_vec_if_indicator_present(vec: &mut Vec<String>, default: &[&str]) {
+    if vec.contains(&"..".to_string()) {
+        vec.extend(default.iter().map(ToString::to_string));
+    }
 }
 
 const SEPARATOR_WIDTH: usize = 4;
diff --git a/tests/ui-toml/blacklisted_names_append/blacklisted_names.rs b/tests/ui-toml/blacklisted_names_append/blacklisted_names.rs
new file mode 100644
index 00000000000..fb2395cf90b
--- /dev/null
+++ b/tests/ui-toml/blacklisted_names_append/blacklisted_names.rs
@@ -0,0 +1,10 @@
+#[warn(clippy::blacklisted_name)]
+
+fn main() {
+    // `foo` is part of the default configuration
+    let foo = "bar";
+    // `ducks` was unrightfully blacklisted
+    let ducks = ["quack", "quack"];
+    // `fox` is okay
+    let fox = ["what", "does", "the", "fox", "say", "?"];
+}
diff --git a/tests/ui-toml/blacklisted_names_append/blacklisted_names.stderr b/tests/ui-toml/blacklisted_names_append/blacklisted_names.stderr
new file mode 100644
index 00000000000..9169bb0e866
--- /dev/null
+++ b/tests/ui-toml/blacklisted_names_append/blacklisted_names.stderr
@@ -0,0 +1,16 @@
+error: use of a blacklisted/placeholder name `foo`
+  --> $DIR/blacklisted_names.rs:5:9
+   |
+LL |     let foo = "bar";
+   |         ^^^
+   |
+   = note: `-D clippy::blacklisted-name` implied by `-D warnings`
+
+error: use of a blacklisted/placeholder name `ducks`
+  --> $DIR/blacklisted_names.rs:7:9
+   |
+LL |     let ducks = ["quack", "quack"];
+   |         ^^^^^
+
+error: aborting due to 2 previous errors
+
diff --git a/tests/ui-toml/blacklisted_names_append/clippy.toml b/tests/ui-toml/blacklisted_names_append/clippy.toml
new file mode 100644
index 00000000000..0e052ef50f0
--- /dev/null
+++ b/tests/ui-toml/blacklisted_names_append/clippy.toml
@@ -0,0 +1 @@
+blacklisted-names = ["ducks", ".."]
diff --git a/tests/ui-toml/blacklisted_names_replace/blacklisted_names.rs b/tests/ui-toml/blacklisted_names_replace/blacklisted_names.rs
new file mode 100644
index 00000000000..fb2395cf90b
--- /dev/null
+++ b/tests/ui-toml/blacklisted_names_replace/blacklisted_names.rs
@@ -0,0 +1,10 @@
+#[warn(clippy::blacklisted_name)]
+
+fn main() {
+    // `foo` is part of the default configuration
+    let foo = "bar";
+    // `ducks` was unrightfully blacklisted
+    let ducks = ["quack", "quack"];
+    // `fox` is okay
+    let fox = ["what", "does", "the", "fox", "say", "?"];
+}
diff --git a/tests/ui-toml/blacklisted_names_replace/blacklisted_names.stderr b/tests/ui-toml/blacklisted_names_replace/blacklisted_names.stderr
new file mode 100644
index 00000000000..ec6f7f084f2
--- /dev/null
+++ b/tests/ui-toml/blacklisted_names_replace/blacklisted_names.stderr
@@ -0,0 +1,10 @@
+error: use of a blacklisted/placeholder name `ducks`
+  --> $DIR/blacklisted_names.rs:7:9
+   |
+LL |     let ducks = ["quack", "quack"];
+   |         ^^^^^
+   |
+   = note: `-D clippy::blacklisted-name` implied by `-D warnings`
+
+error: aborting due to previous error
+
diff --git a/tests/ui-toml/blacklisted_names_replace/clippy.toml b/tests/ui-toml/blacklisted_names_replace/clippy.toml
new file mode 100644
index 00000000000..4582f1c0667
--- /dev/null
+++ b/tests/ui-toml/blacklisted_names_replace/clippy.toml
@@ -0,0 +1 @@
+blacklisted-names = ["ducks"]
diff --git a/tests/ui-toml/doc_valid_idents_append/clippy.toml b/tests/ui-toml/doc_valid_idents_append/clippy.toml
new file mode 100644
index 00000000000..daf3276854b
--- /dev/null
+++ b/tests/ui-toml/doc_valid_idents_append/clippy.toml
@@ -0,0 +1 @@
+doc-valid-idents = ["ClipPy", ".."]
diff --git a/tests/ui-toml/doc_valid_idents_append/doc_markdown.rs b/tests/ui-toml/doc_valid_idents_append/doc_markdown.rs
new file mode 100644
index 00000000000..327a592e9ca
--- /dev/null
+++ b/tests/ui-toml/doc_valid_idents_append/doc_markdown.rs
@@ -0,0 +1,12 @@
+#![warn(clippy::doc_markdown)]
+
+/// This is a special interface for ClipPy which doesn't require backticks
+fn allowed_name() {}
+
+/// OAuth and LaTeX are inside Clippy's default list.
+fn default_name() {}
+
+/// TestItemThingyOfCoolness might sound cool but is not on the list and should be linted.
+fn unknown_name() {}
+
+fn main() {}
diff --git a/tests/ui-toml/doc_valid_idents_append/doc_markdown.stderr b/tests/ui-toml/doc_valid_idents_append/doc_markdown.stderr
new file mode 100644
index 00000000000..0f767c9b855
--- /dev/null
+++ b/tests/ui-toml/doc_valid_idents_append/doc_markdown.stderr
@@ -0,0 +1,14 @@
+error: item in documentation is missing backticks
+  --> $DIR/doc_markdown.rs:9:5
+   |
+LL | /// TestItemThingyOfCoolness might sound cool but is not on the list and should be linted.
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::doc-markdown` implied by `-D warnings`
+help: try
+   |
+LL | /// `TestItemThingyOfCoolness` might sound cool but is not on the list and should be linted.
+   |     ~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+error: aborting due to previous error
+
diff --git a/tests/ui-toml/doc_valid_idents_replace/clippy.toml b/tests/ui-toml/doc_valid_idents_replace/clippy.toml
new file mode 100644
index 00000000000..70bc477b08c
--- /dev/null
+++ b/tests/ui-toml/doc_valid_idents_replace/clippy.toml
@@ -0,0 +1 @@
+doc-valid-idents = ["ClipPy"]
diff --git a/tests/ui-toml/doc_valid_idents_replace/doc_markdown.rs b/tests/ui-toml/doc_valid_idents_replace/doc_markdown.rs
new file mode 100644
index 00000000000..327a592e9ca
--- /dev/null
+++ b/tests/ui-toml/doc_valid_idents_replace/doc_markdown.rs
@@ -0,0 +1,12 @@
+#![warn(clippy::doc_markdown)]
+
+/// This is a special interface for ClipPy which doesn't require backticks
+fn allowed_name() {}
+
+/// OAuth and LaTeX are inside Clippy's default list.
+fn default_name() {}
+
+/// TestItemThingyOfCoolness might sound cool but is not on the list and should be linted.
+fn unknown_name() {}
+
+fn main() {}
diff --git a/tests/ui-toml/doc_valid_idents_replace/doc_markdown.stderr b/tests/ui-toml/doc_valid_idents_replace/doc_markdown.stderr
new file mode 100644
index 00000000000..e0613eb863b
--- /dev/null
+++ b/tests/ui-toml/doc_valid_idents_replace/doc_markdown.stderr
@@ -0,0 +1,36 @@
+error: item in documentation is missing backticks
+  --> $DIR/doc_markdown.rs:6:5
+   |
+LL | /// OAuth and LaTeX are inside Clippy's default list.
+   |     ^^^^^
+   |
+   = note: `-D clippy::doc-markdown` implied by `-D warnings`
+help: try
+   |
+LL | /// `OAuth` and LaTeX are inside Clippy's default list.
+   |     ~~~~~~~
+
+error: item in documentation is missing backticks
+  --> $DIR/doc_markdown.rs:6:15
+   |
+LL | /// OAuth and LaTeX are inside Clippy's default list.
+   |               ^^^^^
+   |
+help: try
+   |
+LL | /// OAuth and `LaTeX` are inside Clippy's default list.
+   |               ~~~~~~~
+
+error: item in documentation is missing backticks
+  --> $DIR/doc_markdown.rs:9:5
+   |
+LL | /// TestItemThingyOfCoolness might sound cool but is not on the list and should be linted.
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: try
+   |
+LL | /// `TestItemThingyOfCoolness` might sound cool but is not on the list and should be linted.
+   |     ~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+error: aborting due to 3 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From a0821fbd756147a2018aed5ed2deb16ba481cd59 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sat, 4 Jun 2022 17:28:23 -0400
Subject: Don't lint `derive_partial_eq_without_eq` on private types

---
 clippy_lints/src/derive.rs                   |  5 ++-
 tests/ui/derive_partial_eq_without_eq.fixed  | 56 +++++++++++++++++++---------
 tests/ui/derive_partial_eq_without_eq.rs     | 56 +++++++++++++++++++---------
 tests/ui/derive_partial_eq_without_eq.stderr | 14 ++++++-
 4 files changed, 95 insertions(+), 36 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/derive.rs b/clippy_lints/src/derive.rs
index 99347ebadc6..a98060fe9a6 100644
--- a/clippy_lints/src/derive.rs
+++ b/clippy_lints/src/derive.rs
@@ -11,7 +11,9 @@ use rustc_hir::{
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::nested_filter;
 use rustc_middle::ty::subst::GenericArg;
-use rustc_middle::ty::{self, BoundConstness, ImplPolarity, ParamEnv, PredicateKind, TraitPredicate, TraitRef, Ty};
+use rustc_middle::ty::{
+    self, BoundConstness, ImplPolarity, ParamEnv, PredicateKind, TraitPredicate, TraitRef, Ty, Visibility,
+};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
 use rustc_span::sym;
@@ -459,6 +461,7 @@ impl<'tcx> Visitor<'tcx> for UnsafeVisitor<'_, 'tcx> {
 fn check_partial_eq_without_eq<'tcx>(cx: &LateContext<'tcx>, span: Span, trait_ref: &hir::TraitRef<'_>, ty: Ty<'tcx>) {
     if_chain! {
         if let ty::Adt(adt, substs) = ty.kind();
+        if cx.tcx.visibility(adt.did()) == Visibility::Public;
         if let Some(eq_trait_def_id) = cx.tcx.get_diagnostic_item(sym::Eq);
         if let Some(peq_trait_def_id) = cx.tcx.get_diagnostic_item(sym::PartialEq);
         if let Some(def_id) = trait_ref.trait_def_id();
diff --git a/tests/ui/derive_partial_eq_without_eq.fixed b/tests/ui/derive_partial_eq_without_eq.fixed
index 012780258fc..25e7050d08e 100644
--- a/tests/ui/derive_partial_eq_without_eq.fixed
+++ b/tests/ui/derive_partial_eq_without_eq.fixed
@@ -4,28 +4,28 @@
 #![warn(clippy::derive_partial_eq_without_eq)]
 
 // Don't warn on structs that aren't PartialEq
-struct NotPartialEq {
+pub struct NotPartialEq {
     foo: u32,
     bar: String,
 }
 
 // Eq can be derived but is missing
 #[derive(Debug, PartialEq, Eq)]
-struct MissingEq {
+pub struct MissingEq {
     foo: u32,
     bar: String,
 }
 
 // Eq is derived
 #[derive(PartialEq, Eq)]
-struct NotMissingEq {
+pub struct NotMissingEq {
     foo: u32,
     bar: String,
 }
 
 // Eq is manually implemented
 #[derive(PartialEq)]
-struct ManualEqImpl {
+pub struct ManualEqImpl {
     foo: u32,
     bar: String,
 }
@@ -34,13 +34,13 @@ impl Eq for ManualEqImpl {}
 
 // Cannot be Eq because f32 isn't Eq
 #[derive(PartialEq)]
-struct CannotBeEq {
+pub struct CannotBeEq {
     foo: u32,
     bar: f32,
 }
 
 // Don't warn if PartialEq is manually implemented
-struct ManualPartialEqImpl {
+pub struct ManualPartialEqImpl {
     foo: u32,
     bar: String,
 }
@@ -53,52 +53,74 @@ impl PartialEq for ManualPartialEqImpl {
 
 // Generic fields should be properly checked for Eq-ness
 #[derive(PartialEq)]
-struct GenericNotEq<T: Eq, U: PartialEq> {
+pub struct GenericNotEq<T: Eq, U: PartialEq> {
     foo: T,
     bar: U,
 }
 
 #[derive(PartialEq, Eq)]
-struct GenericEq<T: Eq, U: Eq> {
+pub struct GenericEq<T: Eq, U: Eq> {
     foo: T,
     bar: U,
 }
 
 #[derive(PartialEq, Eq)]
-struct TupleStruct(u32);
+pub struct TupleStruct(u32);
 
 #[derive(PartialEq, Eq)]
-struct GenericTupleStruct<T: Eq>(T);
+pub struct GenericTupleStruct<T: Eq>(T);
 
 #[derive(PartialEq)]
-struct TupleStructNotEq(f32);
+pub struct TupleStructNotEq(f32);
 
 #[derive(PartialEq, Eq)]
-enum Enum {
+pub enum Enum {
     Foo(u32),
     Bar { a: String, b: () },
 }
 
 #[derive(PartialEq, Eq)]
-enum GenericEnum<T: Eq, U: Eq, V: Eq> {
+pub enum GenericEnum<T: Eq, U: Eq, V: Eq> {
     Foo(T),
     Bar { a: U, b: V },
 }
 
 #[derive(PartialEq)]
-enum EnumNotEq {
+pub enum EnumNotEq {
     Foo(u32),
     Bar { a: String, b: f32 },
 }
 
 // Ensure that rustfix works properly when `PartialEq` has other derives on either side
 #[derive(Debug, PartialEq, Eq, Clone)]
-struct RustFixWithOtherDerives;
+pub struct RustFixWithOtherDerives;
 
 #[derive(PartialEq)]
-struct Generic<T>(T);
+pub struct Generic<T>(T);
 
 #[derive(PartialEq, Eq)]
-struct GenericPhantom<T>(core::marker::PhantomData<T>);
+pub struct GenericPhantom<T>(core::marker::PhantomData<T>);
+
+mod _hidden {
+    #[derive(PartialEq, Eq)]
+    pub struct Reexported;
+
+    #[derive(PartialEq, Eq)]
+    pub struct InPubFn;
+
+    #[derive(PartialEq)]
+    pub(crate) struct PubCrate;
+
+    #[derive(PartialEq)]
+    pub(super) struct PubSuper;
+}
+
+pub use _hidden::Reexported;
+pub fn _from_mod() -> _hidden::InPubFn {
+    _hidden::InPubFn
+}
+
+#[derive(PartialEq)]
+struct InternalTy;
 
 fn main() {}
diff --git a/tests/ui/derive_partial_eq_without_eq.rs b/tests/ui/derive_partial_eq_without_eq.rs
index fc8285b0c6b..88d6fbd1af7 100644
--- a/tests/ui/derive_partial_eq_without_eq.rs
+++ b/tests/ui/derive_partial_eq_without_eq.rs
@@ -4,28 +4,28 @@
 #![warn(clippy::derive_partial_eq_without_eq)]
 
 // Don't warn on structs that aren't PartialEq
-struct NotPartialEq {
+pub struct NotPartialEq {
     foo: u32,
     bar: String,
 }
 
 // Eq can be derived but is missing
 #[derive(Debug, PartialEq)]
-struct MissingEq {
+pub struct MissingEq {
     foo: u32,
     bar: String,
 }
 
 // Eq is derived
 #[derive(PartialEq, Eq)]
-struct NotMissingEq {
+pub struct NotMissingEq {
     foo: u32,
     bar: String,
 }
 
 // Eq is manually implemented
 #[derive(PartialEq)]
-struct ManualEqImpl {
+pub struct ManualEqImpl {
     foo: u32,
     bar: String,
 }
@@ -34,13 +34,13 @@ impl Eq for ManualEqImpl {}
 
 // Cannot be Eq because f32 isn't Eq
 #[derive(PartialEq)]
-struct CannotBeEq {
+pub struct CannotBeEq {
     foo: u32,
     bar: f32,
 }
 
 // Don't warn if PartialEq is manually implemented
-struct ManualPartialEqImpl {
+pub struct ManualPartialEqImpl {
     foo: u32,
     bar: String,
 }
@@ -53,52 +53,74 @@ impl PartialEq for ManualPartialEqImpl {
 
 // Generic fields should be properly checked for Eq-ness
 #[derive(PartialEq)]
-struct GenericNotEq<T: Eq, U: PartialEq> {
+pub struct GenericNotEq<T: Eq, U: PartialEq> {
     foo: T,
     bar: U,
 }
 
 #[derive(PartialEq)]
-struct GenericEq<T: Eq, U: Eq> {
+pub struct GenericEq<T: Eq, U: Eq> {
     foo: T,
     bar: U,
 }
 
 #[derive(PartialEq)]
-struct TupleStruct(u32);
+pub struct TupleStruct(u32);
 
 #[derive(PartialEq)]
-struct GenericTupleStruct<T: Eq>(T);
+pub struct GenericTupleStruct<T: Eq>(T);
 
 #[derive(PartialEq)]
-struct TupleStructNotEq(f32);
+pub struct TupleStructNotEq(f32);
 
 #[derive(PartialEq)]
-enum Enum {
+pub enum Enum {
     Foo(u32),
     Bar { a: String, b: () },
 }
 
 #[derive(PartialEq)]
-enum GenericEnum<T: Eq, U: Eq, V: Eq> {
+pub enum GenericEnum<T: Eq, U: Eq, V: Eq> {
     Foo(T),
     Bar { a: U, b: V },
 }
 
 #[derive(PartialEq)]
-enum EnumNotEq {
+pub enum EnumNotEq {
     Foo(u32),
     Bar { a: String, b: f32 },
 }
 
 // Ensure that rustfix works properly when `PartialEq` has other derives on either side
 #[derive(Debug, PartialEq, Clone)]
-struct RustFixWithOtherDerives;
+pub struct RustFixWithOtherDerives;
 
 #[derive(PartialEq)]
-struct Generic<T>(T);
+pub struct Generic<T>(T);
 
 #[derive(PartialEq, Eq)]
-struct GenericPhantom<T>(core::marker::PhantomData<T>);
+pub struct GenericPhantom<T>(core::marker::PhantomData<T>);
+
+mod _hidden {
+    #[derive(PartialEq)]
+    pub struct Reexported;
+
+    #[derive(PartialEq)]
+    pub struct InPubFn;
+
+    #[derive(PartialEq)]
+    pub(crate) struct PubCrate;
+
+    #[derive(PartialEq)]
+    pub(super) struct PubSuper;
+}
+
+pub use _hidden::Reexported;
+pub fn _from_mod() -> _hidden::InPubFn {
+    _hidden::InPubFn
+}
+
+#[derive(PartialEq)]
+struct InternalTy;
 
 fn main() {}
diff --git a/tests/ui/derive_partial_eq_without_eq.stderr b/tests/ui/derive_partial_eq_without_eq.stderr
index bf55165890a..b762efc4744 100644
--- a/tests/ui/derive_partial_eq_without_eq.stderr
+++ b/tests/ui/derive_partial_eq_without_eq.stderr
@@ -42,5 +42,17 @@ error: you are deriving `PartialEq` and can implement `Eq`
 LL | #[derive(Debug, PartialEq, Clone)]
    |                 ^^^^^^^^^ help: consider deriving `Eq` as well: `PartialEq, Eq`
 
-error: aborting due to 7 previous errors
+error: you are deriving `PartialEq` and can implement `Eq`
+  --> $DIR/derive_partial_eq_without_eq.rs:105:14
+   |
+LL |     #[derive(PartialEq)]
+   |              ^^^^^^^^^ help: consider deriving `Eq` as well: `PartialEq, Eq`
+
+error: you are deriving `PartialEq` and can implement `Eq`
+  --> $DIR/derive_partial_eq_without_eq.rs:108:14
+   |
+LL |     #[derive(PartialEq)]
+   |              ^^^^^^^^^ help: consider deriving `Eq` as well: `PartialEq, Eq`
+
+error: aborting due to 9 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 648dbebfb116e028ff77cb539634bfc1fcc7b256 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sat, 4 Jun 2022 20:21:56 -0400
Subject: Actually get the correct `ParamEnv` in `derive_partial_eq_without_eq`

---
 clippy_lints/src/derive.rs                   | 94 +++++++++++++++-------------
 tests/ui/derive_partial_eq_without_eq.fixed  |  4 +-
 tests/ui/derive_partial_eq_without_eq.stderr | 14 ++++-
 3 files changed, 66 insertions(+), 46 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/derive.rs b/clippy_lints/src/derive.rs
index a98060fe9a6..28f218a8e34 100644
--- a/clippy_lints/src/derive.rs
+++ b/clippy_lints/src/derive.rs
@@ -4,15 +4,18 @@ use clippy_utils::ty::{implements_trait, implements_trait_with_env, is_copy};
 use clippy_utils::{is_lint_allowed, match_def_path};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
+use rustc_hir::def_id::DefId;
 use rustc_hir::intravisit::{walk_expr, walk_fn, walk_item, FnKind, Visitor};
 use rustc_hir::{
-    self as hir, BlockCheckMode, BodyId, Expr, ExprKind, FnDecl, HirId, Impl, Item, ItemKind, UnsafeSource, Unsafety,
+    self as hir, BlockCheckMode, BodyId, Constness, Expr, ExprKind, FnDecl, HirId, Impl, Item, ItemKind, UnsafeSource,
+    Unsafety,
 };
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::nested_filter;
-use rustc_middle::ty::subst::GenericArg;
+use rustc_middle::traits::Reveal;
 use rustc_middle::ty::{
-    self, BoundConstness, ImplPolarity, ParamEnv, PredicateKind, TraitPredicate, TraitRef, Ty, Visibility,
+    self, Binder, BoundConstness, GenericParamDefKind, ImplPolarity, ParamEnv, PredicateKind, TraitPredicate, TraitRef,
+    Ty, TyCtxt, Visibility,
 };
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
@@ -463,49 +466,16 @@ fn check_partial_eq_without_eq<'tcx>(cx: &LateContext<'tcx>, span: Span, trait_r
         if let ty::Adt(adt, substs) = ty.kind();
         if cx.tcx.visibility(adt.did()) == Visibility::Public;
         if let Some(eq_trait_def_id) = cx.tcx.get_diagnostic_item(sym::Eq);
-        if let Some(peq_trait_def_id) = cx.tcx.get_diagnostic_item(sym::PartialEq);
         if let Some(def_id) = trait_ref.trait_def_id();
         if cx.tcx.is_diagnostic_item(sym::PartialEq, def_id);
-        // New `ParamEnv` replacing `T: PartialEq` with `T: Eq`
-        let param_env = ParamEnv::new(
-            cx.tcx.mk_predicates(cx.param_env.caller_bounds().iter().map(|p| {
-                let kind = p.kind();
-                match kind.skip_binder() {
-                    PredicateKind::Trait(p)
-                        if p.trait_ref.def_id == peq_trait_def_id
-                            && p.trait_ref.substs.get(0) == p.trait_ref.substs.get(1)
-                            && matches!(p.trait_ref.self_ty().kind(), ty::Param(_))
-                            && p.constness == BoundConstness::NotConst
-                            && p.polarity == ImplPolarity::Positive =>
-                    {
-                        cx.tcx.mk_predicate(kind.rebind(PredicateKind::Trait(TraitPredicate {
-                            trait_ref: TraitRef::new(
-                                eq_trait_def_id,
-                                cx.tcx.mk_substs([GenericArg::from(p.trait_ref.self_ty())].into_iter()),
-                            ),
-                            constness: BoundConstness::NotConst,
-                            polarity: ImplPolarity::Positive,
-                        })))
-                    },
-                    _ => p,
-                }
-            })),
-            cx.param_env.reveal(),
-            cx.param_env.constness(),
-        );
-        if !implements_trait_with_env(cx.tcx, param_env, ty, eq_trait_def_id, substs);
+        let param_env = param_env_for_derived_eq(cx.tcx, adt.did(), eq_trait_def_id);
+        if !implements_trait_with_env(cx.tcx, param_env, ty, eq_trait_def_id, &[]);
+        // If all of our fields implement `Eq`, we can implement `Eq` too
+        if adt
+            .all_fields()
+            .map(|f| f.ty(cx.tcx, substs))
+            .all(|ty| implements_trait_with_env(cx.tcx, param_env, ty, eq_trait_def_id, &[]));
         then {
-            // If all of our fields implement `Eq`, we can implement `Eq` too
-            for variant in adt.variants() {
-                for field in &variant.fields {
-                    let ty = field.ty(cx.tcx, substs);
-
-                    if !implements_trait(cx, ty, eq_trait_def_id, substs) {
-                        return;
-                    }
-                }
-            }
-
             span_lint_and_sugg(
                 cx,
                 DERIVE_PARTIAL_EQ_WITHOUT_EQ,
@@ -518,3 +488,41 @@ fn check_partial_eq_without_eq<'tcx>(cx: &LateContext<'tcx>, span: Span, trait_r
         }
     }
 }
+
+/// Creates the `ParamEnv` used for the give type's derived `Eq` impl.
+fn param_env_for_derived_eq(tcx: TyCtxt<'_>, did: DefId, eq_trait_id: DefId) -> ParamEnv<'_> {
+    // Initial map from generic index to param def.
+    // Vec<(param_def, needs_eq)>
+    let mut params = tcx
+        .generics_of(did)
+        .params
+        .iter()
+        .map(|p| (p, matches!(p.kind, GenericParamDefKind::Type { .. })))
+        .collect::<Vec<_>>();
+
+    let ty_predicates = tcx.predicates_of(did).predicates;
+    for (p, _) in ty_predicates {
+        if let PredicateKind::Trait(p) = p.kind().skip_binder()
+            && p.trait_ref.def_id == eq_trait_id
+            && let ty::Param(self_ty) = p.trait_ref.self_ty().kind()
+            && p.constness == BoundConstness::NotConst
+        {
+            // Flag types which already have an `Eq` bound.
+            params[self_ty.index as usize].1 = false;
+        }
+    }
+
+    ParamEnv::new(
+        tcx.mk_predicates(ty_predicates.iter().map(|&(p, _)| p).chain(
+            params.iter().filter(|&&(_, needs_eq)| needs_eq).map(|&(param, _)| {
+                tcx.mk_predicate(Binder::dummy(PredicateKind::Trait(TraitPredicate {
+                    trait_ref: TraitRef::new(eq_trait_id, tcx.mk_substs([tcx.mk_param_from_def(param)].into_iter())),
+                    constness: BoundConstness::NotConst,
+                    polarity: ImplPolarity::Positive,
+                })))
+            }),
+        )),
+        Reveal::UserFacing,
+        Constness::NotConst,
+    )
+}
diff --git a/tests/ui/derive_partial_eq_without_eq.fixed b/tests/ui/derive_partial_eq_without_eq.fixed
index 25e7050d08e..bbbe467590f 100644
--- a/tests/ui/derive_partial_eq_without_eq.fixed
+++ b/tests/ui/derive_partial_eq_without_eq.fixed
@@ -52,7 +52,7 @@ impl PartialEq for ManualPartialEqImpl {
 }
 
 // Generic fields should be properly checked for Eq-ness
-#[derive(PartialEq)]
+#[derive(PartialEq, Eq)]
 pub struct GenericNotEq<T: Eq, U: PartialEq> {
     foo: T,
     bar: U,
@@ -95,7 +95,7 @@ pub enum EnumNotEq {
 #[derive(Debug, PartialEq, Eq, Clone)]
 pub struct RustFixWithOtherDerives;
 
-#[derive(PartialEq)]
+#[derive(PartialEq, Eq)]
 pub struct Generic<T>(T);
 
 #[derive(PartialEq, Eq)]
diff --git a/tests/ui/derive_partial_eq_without_eq.stderr b/tests/ui/derive_partial_eq_without_eq.stderr
index b762efc4744..794c5dab844 100644
--- a/tests/ui/derive_partial_eq_without_eq.stderr
+++ b/tests/ui/derive_partial_eq_without_eq.stderr
@@ -6,6 +6,12 @@ LL | #[derive(Debug, PartialEq)]
    |
    = note: `-D clippy::derive-partial-eq-without-eq` implied by `-D warnings`
 
+error: you are deriving `PartialEq` and can implement `Eq`
+  --> $DIR/derive_partial_eq_without_eq.rs:55:10
+   |
+LL | #[derive(PartialEq)]
+   |          ^^^^^^^^^ help: consider deriving `Eq` as well: `PartialEq, Eq`
+
 error: you are deriving `PartialEq` and can implement `Eq`
   --> $DIR/derive_partial_eq_without_eq.rs:61:10
    |
@@ -42,6 +48,12 @@ error: you are deriving `PartialEq` and can implement `Eq`
 LL | #[derive(Debug, PartialEq, Clone)]
    |                 ^^^^^^^^^ help: consider deriving `Eq` as well: `PartialEq, Eq`
 
+error: you are deriving `PartialEq` and can implement `Eq`
+  --> $DIR/derive_partial_eq_without_eq.rs:98:10
+   |
+LL | #[derive(PartialEq)]
+   |          ^^^^^^^^^ help: consider deriving `Eq` as well: `PartialEq, Eq`
+
 error: you are deriving `PartialEq` and can implement `Eq`
   --> $DIR/derive_partial_eq_without_eq.rs:105:14
    |
@@ -54,5 +66,5 @@ error: you are deriving `PartialEq` and can implement `Eq`
 LL |     #[derive(PartialEq)]
    |              ^^^^^^^^^ help: consider deriving `Eq` as well: `PartialEq, Eq`
 
-error: aborting due to 9 previous errors
+error: aborting due to 11 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 94e321a6ff9a224f690b355fd4298caf6342e883 Mon Sep 17 00:00:00 2001
From: Michael Wright <mikerite@lavabit.com>
Date: Sun, 5 Jun 2022 07:14:31 +0200
Subject: needless_late_init refactoring

Remove duplication in creating suggestions by first mapping assignments
to spans and then suggestions.
---
 clippy_lints/src/needless_late_init.rs | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/needless_late_init.rs b/clippy_lints/src/needless_late_init.rs
index 26c694a71fe..9c4e2ef6712 100644
--- a/clippy_lints/src/needless_late_init.rs
+++ b/clippy_lints/src/needless_late_init.rs
@@ -185,13 +185,13 @@ fn assignment_suggestions<'tcx>(
 
     let suggestions = assignments
         .iter()
-        .map(|assignment| Some((assignment.span.until(assignment.rhs_span), String::new())))
-        .chain(assignments.iter().map(|assignment| {
-            Some((
-                assignment.rhs_span.shrink_to_hi().with_hi(assignment.span.hi()),
-                String::new(),
-            ))
-        }))
+        .map(|assignment| assignment.span.until(assignment.rhs_span))
+        .chain(
+            assignments
+                .iter()
+                .map(|assignment| assignment.rhs_span.shrink_to_hi().with_hi(assignment.span.hi())),
+        )
+        .map(|span| Some((span, String::new())))
         .collect::<Option<Vec<(Span, String)>>>()?;
 
     match suggestions.len() {
-- 
cgit 1.4.1-3-g733a5


From 2a1a80d80cdc75ed0bb9f35744591089b8a89f31 Mon Sep 17 00:00:00 2001
From: Michael Wright <mikerite@lavabit.com>
Date: Sun, 5 Jun 2022 07:22:45 +0200
Subject: needless_late_init refactoring

Simplify the creation of suggestions by using `flat_map` instead of
`chain`. Note that the order of the suggestions is not important.
---
 clippy_lints/src/needless_late_init.rs | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/needless_late_init.rs b/clippy_lints/src/needless_late_init.rs
index 9c4e2ef6712..5e97c606e21 100644
--- a/clippy_lints/src/needless_late_init.rs
+++ b/clippy_lints/src/needless_late_init.rs
@@ -185,12 +185,12 @@ fn assignment_suggestions<'tcx>(
 
     let suggestions = assignments
         .iter()
-        .map(|assignment| assignment.span.until(assignment.rhs_span))
-        .chain(
-            assignments
-                .iter()
-                .map(|assignment| assignment.rhs_span.shrink_to_hi().with_hi(assignment.span.hi())),
-        )
+        .flat_map(|assignment| {
+            [
+                assignment.span.until(assignment.rhs_span),
+                assignment.rhs_span.shrink_to_hi().with_hi(assignment.span.hi()),
+            ]
+        })
         .map(|span| Some((span, String::new())))
         .collect::<Option<Vec<(Span, String)>>>()?;
 
-- 
cgit 1.4.1-3-g733a5


From a2de34720d984669499e981b640cde050c2a4dfa Mon Sep 17 00:00:00 2001
From: Michael Wright <mikerite@lavabit.com>
Date: Sun, 5 Jun 2022 07:28:28 +0200
Subject: needless_late_init refactoring

Remove the unneeded wrapping and unwrapping in suggestion creation.
Collecting to Option<Vec<_>> only returns None if one of the elements is
None and that is never the case here.
---
 clippy_lints/src/needless_late_init.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/needless_late_init.rs b/clippy_lints/src/needless_late_init.rs
index 5e97c606e21..4154c71b428 100644
--- a/clippy_lints/src/needless_late_init.rs
+++ b/clippy_lints/src/needless_late_init.rs
@@ -191,8 +191,8 @@ fn assignment_suggestions<'tcx>(
                 assignment.rhs_span.shrink_to_hi().with_hi(assignment.span.hi()),
             ]
         })
-        .map(|span| Some((span, String::new())))
-        .collect::<Option<Vec<(Span, String)>>>()?;
+        .map(|span| (span, String::new()))
+        .collect::<Vec<(Span, String)>>();
 
     match suggestions.len() {
         // All of `exprs` are never types
-- 
cgit 1.4.1-3-g733a5


From 5a70d88af5ff96897b7ddfd01d13e039a86c775c Mon Sep 17 00:00:00 2001
From: DevAccentor <dev.accentor@gmail.com>
Date: Sun, 5 Jun 2022 11:01:54 +0200
Subject: add vec.capacity() to slow_vec_initialization

---
 clippy_lints/src/slow_vector_initialization.rs | 39 ++++++++++++++------------
 tests/ui/slow_vector_initialization.rs         |  6 ++++
 tests/ui/slow_vector_initialization.stderr     | 28 ++++++++++++++----
 3 files changed, 49 insertions(+), 24 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/slow_vector_initialization.rs b/clippy_lints/src/slow_vector_initialization.rs
index b4ad5dcbe3e..e5b30937d16 100644
--- a/clippy_lints/src/slow_vector_initialization.rs
+++ b/clippy_lints/src/slow_vector_initialization.rs
@@ -28,6 +28,9 @@ declare_clippy_lint! {
     /// let mut vec1 = Vec::with_capacity(len);
     /// vec1.resize(len, 0);
     ///
+    /// let mut vec1 = Vec::with_capacity(len);
+    /// vec1.resize(vec1.capacity(), 0);
+    ///
     /// let mut vec2 = Vec::with_capacity(len);
     /// vec2.extend(repeat(0).take(len));
     ///
@@ -210,23 +213,20 @@ impl<'a, 'tcx> VectorInitializationVisitor<'a, 'tcx> {
 
     /// Checks if the given expression is resizing a vector with 0
     fn search_slow_resize_filling(&mut self, expr: &'tcx Expr<'_>) {
-        if_chain! {
-            if self.initialization_found;
-            if let ExprKind::MethodCall(path, [self_arg, len_arg, fill_arg], _) = expr.kind;
-            if path_to_local_id(self_arg, self.vec_alloc.local_id);
-            if path.ident.name == sym!(resize);
-
+        if self.initialization_found
+            && let ExprKind::MethodCall(path, [self_arg, len_arg, fill_arg], _) = expr.kind
+            && path_to_local_id(self_arg, self.vec_alloc.local_id)
+            && path.ident.name == sym!(resize)
             // Check that is filled with 0
-            if let ExprKind::Lit(ref lit) = fill_arg.kind;
-            if let LitKind::Int(0, _) = lit.node;
-
-            // Check that len expression is equals to `with_capacity` expression
-            if SpanlessEq::new(self.cx).eq_expr(len_arg, self.vec_alloc.len_expr);
-
-            then {
-                self.slow_expression = Some(InitializationType::Resize(expr));
+            && let ExprKind::Lit(ref lit) = fill_arg.kind
+            && let LitKind::Int(0, _) = lit.node {
+                // Check that len expression is equals to `with_capacity` expression
+                if SpanlessEq::new(self.cx).eq_expr(len_arg, self.vec_alloc.len_expr) {
+                    self.slow_expression = Some(InitializationType::Resize(expr));
+                } else if let ExprKind::MethodCall(path, _, _) = len_arg.kind && path.ident.as_str() == "capacity" {
+                    self.slow_expression = Some(InitializationType::Resize(expr));
+                }
             }
-        }
     }
 
     /// Returns `true` if give expression is `repeat(0).take(...)`
@@ -239,12 +239,15 @@ impl<'a, 'tcx> VectorInitializationVisitor<'a, 'tcx> {
             if let Some(repeat_expr) = take_args.get(0);
             if self.is_repeat_zero(repeat_expr);
 
-            // Check that len expression is equals to `with_capacity` expression
             if let Some(len_arg) = take_args.get(1);
-            if SpanlessEq::new(self.cx).eq_expr(len_arg, self.vec_alloc.len_expr);
 
             then {
-                return true;
+                // Check that len expression is equals to `with_capacity` expression
+                if SpanlessEq::new(self.cx).eq_expr(len_arg, self.vec_alloc.len_expr) {
+                    return true;
+                } else if let ExprKind::MethodCall(path, _, _) = len_arg.kind && path.ident.as_str() == "capacity" {
+                    return true;
+                }
             }
         }
 
diff --git a/tests/ui/slow_vector_initialization.rs b/tests/ui/slow_vector_initialization.rs
index 7e3d357ae50..16be9f6d203 100644
--- a/tests/ui/slow_vector_initialization.rs
+++ b/tests/ui/slow_vector_initialization.rs
@@ -19,6 +19,9 @@ fn extend_vector() {
     // Extend with mismatching expression should not be warned
     let mut vec3 = Vec::with_capacity(24322);
     vec3.extend(repeat(0).take(2));
+
+    let mut vec4 = Vec::with_capacity(len);
+    vec4.extend(repeat(0).take(vec4.capacity()));
 }
 
 fn mixed_extend_resize_vector() {
@@ -48,6 +51,9 @@ fn resize_vector() {
     let mut vec3 = Vec::with_capacity(len - 10);
     vec3.resize(len - 10, 0);
 
+    let mut vec4 = Vec::with_capacity(len);
+    vec4.resize(vec4.capacity(), 0);
+
     // Reinitialization should be warned
     vec1 = Vec::with_capacity(10);
     vec1.resize(10, 0);
diff --git a/tests/ui/slow_vector_initialization.stderr b/tests/ui/slow_vector_initialization.stderr
index 5d2788ec260..cb3ce3e95a7 100644
--- a/tests/ui/slow_vector_initialization.stderr
+++ b/tests/ui/slow_vector_initialization.stderr
@@ -17,7 +17,15 @@ LL |     vec2.extend(repeat(0).take(len - 10));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: slow zero-filling initialization
-  --> $DIR/slow_vector_initialization.rs:31:5
+  --> $DIR/slow_vector_initialization.rs:24:5
+   |
+LL |     let mut vec4 = Vec::with_capacity(len);
+   |                    ----------------------- help: consider replace allocation with: `vec![0; len]`
+LL |     vec4.extend(repeat(0).take(vec4.capacity()));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: slow zero-filling initialization
+  --> $DIR/slow_vector_initialization.rs:34:5
    |
 LL |     let mut resized_vec = Vec::with_capacity(30);
    |                           ---------------------- help: consider replace allocation with: `vec![0; 30]`
@@ -25,7 +33,7 @@ LL |     resized_vec.resize(30, 0);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: slow zero-filling initialization
-  --> $DIR/slow_vector_initialization.rs:34:5
+  --> $DIR/slow_vector_initialization.rs:37:5
    |
 LL |     let mut extend_vec = Vec::with_capacity(30);
    |                          ---------------------- help: consider replace allocation with: `vec![0; 30]`
@@ -33,7 +41,7 @@ LL |     extend_vec.extend(repeat(0).take(30));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: slow zero-filling initialization
-  --> $DIR/slow_vector_initialization.rs:41:5
+  --> $DIR/slow_vector_initialization.rs:44:5
    |
 LL |     let mut vec1 = Vec::with_capacity(len);
    |                    ----------------------- help: consider replace allocation with: `vec![0; len]`
@@ -41,7 +49,7 @@ LL |     vec1.resize(len, 0);
    |     ^^^^^^^^^^^^^^^^^^^
 
 error: slow zero-filling initialization
-  --> $DIR/slow_vector_initialization.rs:49:5
+  --> $DIR/slow_vector_initialization.rs:52:5
    |
 LL |     let mut vec3 = Vec::with_capacity(len - 10);
    |                    ---------------------------- help: consider replace allocation with: `vec![0; len - 10]`
@@ -49,12 +57,20 @@ LL |     vec3.resize(len - 10, 0);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: slow zero-filling initialization
-  --> $DIR/slow_vector_initialization.rs:53:5
+  --> $DIR/slow_vector_initialization.rs:55:5
+   |
+LL |     let mut vec4 = Vec::with_capacity(len);
+   |                    ----------------------- help: consider replace allocation with: `vec![0; len]`
+LL |     vec4.resize(vec4.capacity(), 0);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: slow zero-filling initialization
+  --> $DIR/slow_vector_initialization.rs:59:5
    |
 LL |     vec1 = Vec::with_capacity(10);
    |            ---------------------- help: consider replace allocation with: `vec![0; 10]`
 LL |     vec1.resize(10, 0);
    |     ^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 7 previous errors
+error: aborting due to 9 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 9aeed6b9bfea42e4a580ad6e7289b4fc72b4365c Mon Sep 17 00:00:00 2001
From: Serial <69764315+Serial-ATA@users.noreply.github.com>
Date: Sun, 5 Jun 2022 15:24:41 -0400
Subject: Improve lint doc consistency

---
 clippy_lints/src/assertions_on_constants.rs        |   3 -
 clippy_lints/src/async_yields_async.rs             |   1 +
 clippy_lints/src/await_holding_invalid.rs          |   2 -
 clippy_lints/src/bool_assert_comparison.rs         |   5 +-
 clippy_lints/src/borrow_deref_ref.rs               |  13 +-
 clippy_lints/src/casts/mod.rs                      |  46 +++--
 clippy_lints/src/comparison_chain.rs               |   1 -
 clippy_lints/src/dbg_macro.rs                      |   5 +-
 clippy_lints/src/default.rs                        |  11 +-
 clippy_lints/src/dereference.rs                    |  16 +-
 clippy_lints/src/derivable_impls.rs                |   4 +-
 clippy_lints/src/enum_variants.rs                  |   3 +-
 clippy_lints/src/eq_op.rs                          |  10 +-
 clippy_lints/src/eta_reduction.rs                  |   8 +-
 clippy_lints/src/excessive_bools.rs                |   3 +-
 clippy_lints/src/float_literal.rs                  |   5 +-
 clippy_lints/src/functions/mod.rs                  |   5 +-
 clippy_lints/src/get_first.rs                      |   3 +-
 clippy_lints/src/implicit_saturating_sub.rs        |  14 +-
 clippy_lints/src/indexing_slicing.rs               |  45 ++---
 clippy_lints/src/infinite_iter.rs                  |   1 +
 clippy_lints/src/inherent_to_string.rs             |  12 +-
 clippy_lints/src/int_plus_one.rs                   |   3 +-
 clippy_lints/src/integer_division.rs               |   5 +-
 clippy_lints/src/items_after_statements.rs         |   3 +-
 clippy_lints/src/large_const_arrays.rs             |   5 +-
 clippy_lints/src/large_enum_variant.rs             |   4 +-
 clippy_lints/src/let_underscore.rs                 |  24 +--
 clippy_lints/src/lib.rs                            |   5 +-
 clippy_lints/src/lifetimes.rs                      |  12 +-
 clippy_lints/src/literal_representation.rs         |  28 ++-
 clippy_lints/src/loops/mod.rs                      |  20 +-
 clippy_lints/src/matches/mod.rs                    |  68 ++++---
 clippy_lints/src/methods/mod.rs                    | 207 +++++++++++++--------
 clippy_lints/src/misc.rs                           |  30 +--
 clippy_lints/src/misc_early/mod.rs                 |  71 ++++---
 clippy_lints/src/mixed_read_write_in_expression.rs |   6 +-
 clippy_lints/src/mut_reference.rs                  |  15 +-
 clippy_lints/src/mutex_atomic.rs                   |  11 +-
 clippy_lints/src/needless_bool.rs                  |  12 +-
 clippy_lints/src/needless_borrowed_ref.rs          |   9 +-
 clippy_lints/src/needless_update.rs                |   7 +-
 clippy_lints/src/neg_cmp_op_on_partial_ord.rs      |  14 +-
 clippy_lints/src/neg_multiply.rs                   |   9 +-
 clippy_lints/src/non_copy_const.rs                 |  14 +-
 clippy_lints/src/octal_escapes.rs                  |   5 +-
 clippy_lints/src/pass_by_ref_or_value.rs           |  12 +-
 clippy_lints/src/ptr.rs                            |  22 ++-
 clippy_lints/src/ranges.rs                         |  43 +++--
 clippy_lints/src/redundant_closure_call.rs         |  11 +-
 clippy_lints/src/reference.rs                      |   5 +-
 clippy_lints/src/return_self_not_must_use.rs       |  14 +-
 clippy_lints/src/shadow.rs                         |  15 +-
 clippy_lints/src/slow_vector_initialization.rs     |   7 +-
 clippy_lints/src/strings.rs                        |  18 +-
 clippy_lints/src/trait_bounds.rs                   |   3 +-
 clippy_lints/src/unicode.rs                        |   3 +-
 clippy_lints/src/unused_async.rs                   |   5 +-
 clippy_lints/src/useless_conversion.rs             |   5 +-
 clippy_lints/src/utils/internal_lints.rs           |  22 +--
 clippy_lints/src/vec.rs                            |   8 +-
 clippy_lints/src/wildcard_imports.rs               |  14 +-
 clippy_lints/src/write.rs                          |  33 +++-
 clippy_lints/src/zero_div_zero.rs                  |   5 +-
 64 files changed, 621 insertions(+), 427 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/assertions_on_constants.rs b/clippy_lints/src/assertions_on_constants.rs
index c82837746bd..2705ffffdcb 100644
--- a/clippy_lints/src/assertions_on_constants.rs
+++ b/clippy_lints/src/assertions_on_constants.rs
@@ -14,9 +14,6 @@ declare_clippy_lint! {
     /// Will be optimized out by the compiler or should probably be replaced by a
     /// `panic!()` or `unreachable!()`
     ///
-    /// ### Known problems
-    /// None
-    ///
     /// ### Example
     /// ```rust,ignore
     /// assert!(false)
diff --git a/clippy_lints/src/async_yields_async.rs b/clippy_lints/src/async_yields_async.rs
index 0619490e73c..aef21bfc36c 100644
--- a/clippy_lints/src/async_yields_async.rs
+++ b/clippy_lints/src/async_yields_async.rs
@@ -24,6 +24,7 @@ declare_clippy_lint! {
     ///   };
     /// }
     /// ```
+    ///
     /// Use instead:
     /// ```rust
     /// async fn foo() {}
diff --git a/clippy_lints/src/await_holding_invalid.rs b/clippy_lints/src/await_holding_invalid.rs
index 5b7c4591504..eee5f90d178 100644
--- a/clippy_lints/src/await_holding_invalid.rs
+++ b/clippy_lints/src/await_holding_invalid.rs
@@ -140,8 +140,6 @@ declare_clippy_lint! {
     /// from a memory access perspective but will cause bugs at runtime if they
     /// are held in such a way.
     ///
-    /// ### Known problems
-    ///
     /// ### Example
     ///
     /// ```toml
diff --git a/clippy_lints/src/bool_assert_comparison.rs b/clippy_lints/src/bool_assert_comparison.rs
index c50e214be28..95abe8aa59f 100644
--- a/clippy_lints/src/bool_assert_comparison.rs
+++ b/clippy_lints/src/bool_assert_comparison.rs
@@ -17,11 +17,12 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust
-    /// // Bad
     /// assert_eq!("a".is_empty(), false);
     /// assert_ne!("a".is_empty(), true);
+    /// ```
     ///
-    /// // Good
+    /// Use instead:
+    /// ```rust
     /// assert!(!"a".is_empty());
     /// ```
     #[clippy::version = "1.53.0"]
diff --git a/clippy_lints/src/borrow_deref_ref.rs b/clippy_lints/src/borrow_deref_ref.rs
index ec2f31cf673..1582ec9ee5c 100644
--- a/clippy_lints/src/borrow_deref_ref.rs
+++ b/clippy_lints/src/borrow_deref_ref.rs
@@ -18,7 +18,7 @@ declare_clippy_lint! {
     /// Dereferencing and then borrowing a reference value has no effect in most cases.
     ///
     /// ### Known problems
-    /// false negative on such code:
+    /// False negative on such code:
     /// ```
     /// let x = &12;
     /// let addr_x = &x as *const _ as usize;
@@ -29,17 +29,20 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust
+    /// fn foo(_x: &str) {}
+    ///
     /// let s = &String::new();
     ///
-    /// // Bad
     /// let a: &String = &* s;
     /// foo(&*s);
+    /// ```
     ///
-    /// // Good
+    /// Use instead:
+    /// ```rust
+    /// # fn foo(_x: &str) {}
+    /// # let s = &String::new();
     /// let a: &String = s;
     /// foo(&**s);
-    ///
-    /// fn foo(_: &str){ }
     /// ```
     #[clippy::version = "1.59.0"]
     pub BORROW_DEREF_REF,
diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index daf3b7b4ce4..fe8e372b6f5 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -219,13 +219,16 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust
-    /// // Bad
     /// fn fun() -> i32 { 1 }
-    /// let a = fun as i64;
+    /// # let _ =
+    /// fun as i64;
+    /// ```
     ///
-    /// // Good
-    /// fn fun2() -> i32 { 1 }
-    /// let a = fun2 as usize;
+    /// Use instead:
+    /// ```rust
+    /// # fn fun() -> i32 { 1 }
+    /// # let _ =
+    /// fun as usize;
     /// ```
     #[clippy::version = "pre 1.29.0"]
     pub FN_TO_NUMERIC_CAST,
@@ -245,17 +248,20 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust
-    /// // Bad
     /// fn fn1() -> i16 {
     ///     1
     /// };
-    /// let _ = fn1 as i32;
+    /// # let _ =
+    /// fn1 as i32;
+    /// ```
     ///
-    /// // Better: Cast to usize first, then comment with the reason for the truncation
-    /// fn fn2() -> i16 {
+    /// Use instead:
+    /// ```rust
+    /// // Cast to usize first, then comment with the reason for the truncation
+    /// fn fn1() -> i16 {
     ///     1
     /// };
-    /// let fn_ptr = fn2 as usize;
+    /// let fn_ptr = fn1 as usize;
     /// let fn_ptr_truncated = fn_ptr as i32;
     /// ```
     #[clippy::version = "pre 1.29.0"]
@@ -277,23 +283,31 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust
-    /// // Bad: fn1 is cast as `usize`
+    /// // fn1 is cast as `usize`
     /// fn fn1() -> u16 {
     ///     1
     /// };
-    /// let _ = fn1 as usize;
+    /// # let _ =
+    /// fn1 as usize;
+    /// ```
     ///
-    /// // Good: maybe you intended to call the function?
+    /// Use instead:
+    /// ```rust
+    /// // maybe you intended to call the function?
     /// fn fn2() -> u16 {
     ///     1
     /// };
-    /// let _ = fn2() as usize;
+    /// # let _ =
+    /// fn2() as usize;
+    ///
+    /// // or
     ///
-    /// // Good: maybe you intended to cast it to a function type?
+    /// // maybe you intended to cast it to a function type?
     /// fn fn3() -> u16 {
     ///     1
     /// }
-    /// let _ = fn3 as fn() -> u16;
+    /// # let _ =
+    /// fn3 as fn() -> u16;
     /// ```
     #[clippy::version = "1.58.0"]
     pub FN_TO_NUMERIC_CAST_ANY,
diff --git a/clippy_lints/src/comparison_chain.rs b/clippy_lints/src/comparison_chain.rs
index 913e081af3b..a05b41eb3ab 100644
--- a/clippy_lints/src/comparison_chain.rs
+++ b/clippy_lints/src/comparison_chain.rs
@@ -35,7 +35,6 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    ///
     /// ```rust,ignore
     /// use std::cmp::Ordering;
     /// # fn a() {}
diff --git a/clippy_lints/src/dbg_macro.rs b/clippy_lints/src/dbg_macro.rs
index 17deccf8c39..fe9f4f9ae3c 100644
--- a/clippy_lints/src/dbg_macro.rs
+++ b/clippy_lints/src/dbg_macro.rs
@@ -18,10 +18,11 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust,ignore
-    /// // Bad
     /// dbg!(true)
+    /// ```
     ///
-    /// // Good
+    /// Use instead:
+    /// ```rust,ignore
     /// true
     /// ```
     #[clippy::version = "1.34.0"]
diff --git a/clippy_lints/src/default.rs b/clippy_lints/src/default.rs
index 243dfd3a461..d99a1aa2969 100644
--- a/clippy_lints/src/default.rs
+++ b/clippy_lints/src/default.rs
@@ -18,15 +18,16 @@ declare_clippy_lint! {
     /// Checks for literal calls to `Default::default()`.
     ///
     /// ### Why is this bad?
-    /// It's more clear to the reader to use the name of the type whose default is
-    /// being gotten than the generic `Default`.
+    /// It's easier for the reader if the name of the type is used, rather than the
+    /// generic `Default`.
     ///
     /// ### Example
     /// ```rust
-    /// // Bad
     /// let s: String = Default::default();
+    /// ```
     ///
-    /// // Good
+    /// Use instead:
+    /// ```rust
     /// let s = String::default();
     /// ```
     #[clippy::version = "pre 1.29.0"]
@@ -47,13 +48,13 @@ declare_clippy_lint! {
     /// Assignments to patterns that are of tuple type are not linted.
     ///
     /// ### Example
-    /// Bad:
     /// ```
     /// # #[derive(Default)]
     /// # struct A { i: i32 }
     /// let mut a: A = Default::default();
     /// a.i = 42;
     /// ```
+    ///
     /// Use instead:
     /// ```
     /// # #[derive(Default)]
diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index 8288f7a8b9b..dee83e60d7e 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -30,13 +30,14 @@ declare_clippy_lint! {
     /// let a: &mut String = &mut String::from("foo");
     /// let b: &str = a.deref();
     /// ```
-    /// Could be written as:
+    ///
+    /// Use instead:
     /// ```rust
     /// let a: &mut String = &mut String::from("foo");
     /// let b = &*a;
     /// ```
     ///
-    /// This lint excludes
+    /// This lint excludes:
     /// ```rust,ignore
     /// let _ = d.unwrap().deref();
     /// ```
@@ -59,11 +60,13 @@ declare_clippy_lint! {
     /// ```rust
     /// fn fun(_a: &i32) {}
     ///
-    /// // Bad
     /// let x: &i32 = &&&&&&5;
     /// fun(&x);
+    /// ```
     ///
-    /// // Good
+    /// Use instead:
+    /// ```rust
+    /// # fn fun(_a: &i32) {}
     /// let x: &i32 = &5;
     /// fun(x);
     /// ```
@@ -82,13 +85,14 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust
-    /// // Bad
     /// let x = Some("");
     /// if let Some(ref x) = x {
     ///     // use `x` here
     /// }
+    /// ```
     ///
-    /// // Good
+    /// Use instead:
+    /// ```rust
     /// let x = Some("");
     /// if let Some(x) = x {
     ///     // use `&x` here
diff --git a/clippy_lints/src/derivable_impls.rs b/clippy_lints/src/derivable_impls.rs
index e98691fd5bb..4d7f4076d7b 100644
--- a/clippy_lints/src/derivable_impls.rs
+++ b/clippy_lints/src/derivable_impls.rs
@@ -30,8 +30,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     ///
-    /// Could be written as:
-    ///
+    /// Use instead:
     /// ```rust
     /// #[derive(Default)]
     /// struct Foo {
@@ -45,7 +44,6 @@ declare_clippy_lint! {
     /// specialized than what derive will produce. This lint can't detect the manual `impl`
     /// has exactly equal bounds, and therefore this lint is disabled for types with
     /// generic parameters.
-    ///
     #[clippy::version = "1.57.0"]
     pub DERIVABLE_IMPLS,
     complexity,
diff --git a/clippy_lints/src/enum_variants.rs b/clippy_lints/src/enum_variants.rs
index 263a5b573c9..23b75104570 100644
--- a/clippy_lints/src/enum_variants.rs
+++ b/clippy_lints/src/enum_variants.rs
@@ -60,7 +60,8 @@ declare_clippy_lint! {
     ///     struct BlackForestCake;
     /// }
     /// ```
-    /// Could be written as:
+    ///
+    /// Use instead:
     /// ```rust
     /// mod cake {
     ///     struct BlackForest;
diff --git a/clippy_lints/src/eq_op.rs b/clippy_lints/src/eq_op.rs
index c3176d987c6..2f4c90d07cf 100644
--- a/clippy_lints/src/eq_op.rs
+++ b/clippy_lints/src/eq_op.rs
@@ -52,15 +52,13 @@ declare_clippy_lint! {
     /// ### Why is this bad?
     /// It is more idiomatic to dereference the other argument.
     ///
-    /// ### Known problems
-    /// None
-    ///
     /// ### Example
-    /// ```ignore
-    /// // Bad
+    /// ```rust,ignore
     /// &x == y
+    /// ```
     ///
-    /// // Good
+    /// Use instead:
+    /// ```rust,ignore
     /// x == *y
     /// ```
     #[clippy::version = "pre 1.29.0"]
diff --git a/clippy_lints/src/eta_reduction.rs b/clippy_lints/src/eta_reduction.rs
index 530d6d4de35..aa537aa90ec 100644
--- a/clippy_lints/src/eta_reduction.rs
+++ b/clippy_lints/src/eta_reduction.rs
@@ -34,14 +34,14 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust,ignore
-    /// // Bad
     /// xs.map(|x| foo(x))
+    /// ```
     ///
-    /// // Good
+    /// Use instead:
+    /// ```rust,ignore
+    /// // where `foo(_)` is a plain function that takes the exact argument type of `x`.
     /// xs.map(foo)
     /// ```
-    /// where `foo(_)` is a plain function that takes the exact argument type of
-    /// `x`.
     #[clippy::version = "pre 1.29.0"]
     pub REDUNDANT_CLOSURE,
     style,
diff --git a/clippy_lints/src/excessive_bools.rs b/clippy_lints/src/excessive_bools.rs
index a2af10e2ba5..f7a92bc0795 100644
--- a/clippy_lints/src/excessive_bools.rs
+++ b/clippy_lints/src/excessive_bools.rs
@@ -54,12 +54,11 @@ declare_clippy_lint! {
     /// API easier to use.
     ///
     /// ### Example
-    /// Bad:
     /// ```rust,ignore
     /// fn f(is_round: bool, is_hot: bool) { ... }
     /// ```
     ///
-    /// Good:
+    /// Use instead:
     /// ```rust,ignore
     /// enum Shape {
     ///     Round,
diff --git a/clippy_lints/src/float_literal.rs b/clippy_lints/src/float_literal.rs
index f850ea31f4d..f2e07980963 100644
--- a/clippy_lints/src/float_literal.rs
+++ b/clippy_lints/src/float_literal.rs
@@ -45,10 +45,11 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust
-    /// // Bad
     /// let _: f32 = 16_777_217.0; // 16_777_216.0
+    /// ```
     ///
-    /// // Good
+    /// Use instead:
+    /// ```rust
     /// let _: f32 = 16_777_216.0;
     /// let _: f64 = 16_777_217.0;
     /// ```
diff --git a/clippy_lints/src/functions/mod.rs b/clippy_lints/src/functions/mod.rs
index ad031cbc09d..73261fb8a44 100644
--- a/clippy_lints/src/functions/mod.rs
+++ b/clippy_lints/src/functions/mod.rs
@@ -76,12 +76,13 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust,ignore
-    /// // Bad
     /// pub fn foo(x: *const u8) {
     ///     println!("{}", unsafe { *x });
     /// }
+    /// ```
     ///
-    /// // Good
+    /// Use instead:
+    /// ```rust,ignore
     /// pub unsafe fn foo(x: *const u8) {
     ///     println!("{}", unsafe { *x });
     /// }
diff --git a/clippy_lints/src/get_first.rs b/clippy_lints/src/get_first.rs
index 0748ab45252..529f7babaa5 100644
--- a/clippy_lints/src/get_first.rs
+++ b/clippy_lints/src/get_first.rs
@@ -20,13 +20,12 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust
-    /// // Bad
     /// let x = vec![2, 3, 5];
     /// let first_element = x.get(0);
     /// ```
+    ///
     /// Use instead:
     /// ```rust
-    /// // Good
     /// let x = vec![2, 3, 5];
     /// let first_element = x.first();
     /// ```
diff --git a/clippy_lints/src/implicit_saturating_sub.rs b/clippy_lints/src/implicit_saturating_sub.rs
index ae4158662d4..9d858e0c212 100644
--- a/clippy_lints/src/implicit_saturating_sub.rs
+++ b/clippy_lints/src/implicit_saturating_sub.rs
@@ -16,17 +16,15 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust
-    /// let end: u32 = 10;
-    /// let start: u32 = 5;
-    ///
-    /// let mut i: u32 = end - start;
-    ///
-    /// // Bad
+    /// # let mut i: u32 = 0;
     /// if i != 0 {
     ///     i -= 1;
     /// }
+    /// ```
     ///
-    /// // Good
+    /// Use instead:
+    /// ```rust
+    /// # let mut i: u32 = 0;
     /// i = i.saturating_sub(1);
     /// ```
     #[clippy::version = "1.44.0"]
@@ -48,7 +46,7 @@ impl<'tcx> LateLintPass<'tcx> for ImplicitSaturatingSub {
             // Check if the conditional expression is a binary operation
             if let ExprKind::Binary(ref cond_op, cond_left, cond_right) = cond.kind;
 
-            // Ensure that the binary operator is >, != and <
+            // Ensure that the binary operator is >, !=, or <
             if BinOpKind::Ne == cond_op.node || BinOpKind::Gt == cond_op.node || BinOpKind::Lt == cond_op.node;
 
             // Check if assign operation is done
diff --git a/clippy_lints/src/indexing_slicing.rs b/clippy_lints/src/indexing_slicing.rs
index 4ba7477add8..301686612a1 100644
--- a/clippy_lints/src/indexing_slicing.rs
+++ b/clippy_lints/src/indexing_slicing.rs
@@ -17,19 +17,20 @@ declare_clippy_lint! {
     /// ### Why is this bad?
     /// This will always panic at runtime.
     ///
-    /// ### Known problems
-    /// Hopefully none.
-    ///
     /// ### Example
-    /// ```no_run
+    /// ```rust,no_run
     /// # #![allow(const_err)]
     /// let x = [1, 2, 3, 4];
     ///
-    /// // Bad
     /// x[9];
     /// &x[2..9];
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust
+    /// # let x = [1, 2, 3, 4];
+    /// // Index within bounds
     ///
-    /// // Good
     /// x[0];
     /// x[3];
     /// ```
@@ -49,42 +50,34 @@ declare_clippy_lint! {
     /// Indexing and slicing can panic at runtime and there are
     /// safe alternatives.
     ///
-    /// ### Known problems
-    /// Hopefully none.
-    ///
     /// ### Example
     /// ```rust,no_run
     /// // Vector
     /// let x = vec![0; 5];
     ///
-    /// // Bad
     /// x[2];
     /// &x[2..100];
-    /// &x[2..];
-    /// &x[..100];
-    ///
-    /// // Good
-    /// x.get(2);
-    /// x.get(2..100);
-    /// x.get(2..);
-    /// x.get(..100);
     ///
     /// // Array
     /// let y = [0, 1, 2, 3];
     ///
-    /// // Bad
     /// &y[10..100];
     /// &y[10..];
-    /// &y[..100];
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust
+    /// # let x = vec![0; 5];
+    /// # let y = [0, 1, 2, 3];
+    /// # let _ =
+    /// x.get(2);
+    /// # let _ =
+    /// x.get(2..100);
     ///
-    /// // Good
-    /// &y[2..];
-    /// &y[..2];
-    /// &y[0..3];
+    /// # let _ =
     /// y.get(10);
+    /// # let _ =
     /// y.get(10..100);
-    /// y.get(10..);
-    /// y.get(..100);
     /// ```
     #[clippy::version = "pre 1.29.0"]
     pub INDEXING_SLICING,
diff --git a/clippy_lints/src/infinite_iter.rs b/clippy_lints/src/infinite_iter.rs
index b2b9889f5dc..fc8e473dd9e 100644
--- a/clippy_lints/src/infinite_iter.rs
+++ b/clippy_lints/src/infinite_iter.rs
@@ -41,6 +41,7 @@ declare_clippy_lint! {
     /// ### Example
     /// ```rust
     /// let infinite_iter = 0..;
+    /// # let _ =
     /// [0..].iter().zip(infinite_iter.take_while(|x| *x > 5));
     /// ```
     #[clippy::version = "pre 1.29.0"]
diff --git a/clippy_lints/src/inherent_to_string.rs b/clippy_lints/src/inherent_to_string.rs
index 55c04a1186f..39f68a8a1b4 100644
--- a/clippy_lints/src/inherent_to_string.rs
+++ b/clippy_lints/src/inherent_to_string.rs
@@ -14,12 +14,8 @@ declare_clippy_lint! {
     /// ### Why is this bad?
     /// This method is also implicitly defined if a type implements the `Display` trait. As the functionality of `Display` is much more versatile, it should be preferred.
     ///
-    /// ### Known problems
-    /// None
-    ///
     /// ### Example
     /// ```rust
-    /// // Bad
     /// pub struct A;
     ///
     /// impl A {
@@ -29,8 +25,8 @@ declare_clippy_lint! {
     /// }
     /// ```
     ///
+    /// Use instead:
     /// ```rust
-    /// // Good
     /// use std::fmt;
     ///
     /// pub struct A;
@@ -54,12 +50,8 @@ declare_clippy_lint! {
     /// ### Why is this bad?
     /// This method is also implicitly defined if a type implements the `Display` trait. The less versatile inherent method will then shadow the implementation introduced by `Display`.
     ///
-    /// ### Known problems
-    /// None
-    ///
     /// ### Example
     /// ```rust
-    /// // Bad
     /// use std::fmt;
     ///
     /// pub struct A;
@@ -77,8 +69,8 @@ declare_clippy_lint! {
     /// }
     /// ```
     ///
+    /// Use instead:
     /// ```rust
-    /// // Good
     /// use std::fmt;
     ///
     /// pub struct A;
diff --git a/clippy_lints/src/int_plus_one.rs b/clippy_lints/src/int_plus_one.rs
index 8db7b307ddb..9a944def3eb 100644
--- a/clippy_lints/src/int_plus_one.rs
+++ b/clippy_lints/src/int_plus_one.rs
@@ -21,8 +21,7 @@ declare_clippy_lint! {
     /// if x >= y + 1 {}
     /// ```
     ///
-    /// Could be written as:
-    ///
+    /// Use instead:
     /// ```rust
     /// # let x = 1;
     /// # let y = 1;
diff --git a/clippy_lints/src/integer_division.rs b/clippy_lints/src/integer_division.rs
index fa786205678..3effba56826 100644
--- a/clippy_lints/src/integer_division.rs
+++ b/clippy_lints/src/integer_division.rs
@@ -15,11 +15,12 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust
-    /// // Bad
     /// let x = 3 / 2;
     /// println!("{}", x);
+    /// ```
     ///
-    /// // Good
+    /// Use instead:
+    /// ```rust
     /// let x = 3f32 / 2f32;
     /// println!("{}", x);
     /// ```
diff --git a/clippy_lints/src/items_after_statements.rs b/clippy_lints/src/items_after_statements.rs
index cdefe627efd..46d439b4497 100644
--- a/clippy_lints/src/items_after_statements.rs
+++ b/clippy_lints/src/items_after_statements.rs
@@ -17,7 +17,6 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust
-    /// // Bad
     /// fn foo() {
     ///     println!("cake");
     /// }
@@ -31,8 +30,8 @@ declare_clippy_lint! {
     /// }
     /// ```
     ///
+    /// Use instead:
     /// ```rust
-    /// // Good
     /// fn foo() {
     ///     println!("cake");
     /// }
diff --git a/clippy_lints/src/large_const_arrays.rs b/clippy_lints/src/large_const_arrays.rs
index 27db6388136..0b972bc3916 100644
--- a/clippy_lints/src/large_const_arrays.rs
+++ b/clippy_lints/src/large_const_arrays.rs
@@ -21,10 +21,11 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust,ignore
-    /// // Bad
     /// pub const a = [0u32; 1_000_000];
+    /// ```
     ///
-    /// // Good
+    /// Use instead:
+    /// ```rust.ignore
     /// pub static a = [0u32; 1_000_000];
     /// ```
     #[clippy::version = "1.44.0"]
diff --git a/clippy_lints/src/large_enum_variant.rs b/clippy_lints/src/large_enum_variant.rs
index 63ac092dfaf..9be057bcf90 100644
--- a/clippy_lints/src/large_enum_variant.rs
+++ b/clippy_lints/src/large_enum_variant.rs
@@ -38,12 +38,14 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust
-    /// // Bad
     /// enum Test {
     ///     A(i32),
     ///     B([i32; 8000]),
     /// }
+    /// ```
     ///
+    /// Use instead:
+    /// ```rust
     /// // Possibly better
     /// enum Test2 {
     ///     A(i32),
diff --git a/clippy_lints/src/let_underscore.rs b/clippy_lints/src/let_underscore.rs
index cb1ef01f5ba..26c540e2223 100644
--- a/clippy_lints/src/let_underscore.rs
+++ b/clippy_lints/src/let_underscore.rs
@@ -45,13 +45,11 @@ declare_clippy_lint! {
     /// `std::mem::drop` conveys your intention better and is less error-prone.
     ///
     /// ### Example
-    ///
-    /// Bad:
     /// ```rust,ignore
     /// let _ = mutex.lock();
     /// ```
     ///
-    /// Good:
+    /// Use instead:
     /// ```rust,ignore
     /// let _lock = mutex.lock();
     /// ```
@@ -75,24 +73,20 @@ declare_clippy_lint! {
     /// better and is less error-prone.
     ///
     /// ### Example
-    ///
-    /// Bad:
-    /// ```rust,ignore
-    /// struct Droppable;
-    /// impl Drop for Droppable {
-    ///     fn drop(&mut self) {}
-    /// }
+    /// ```rust
+    /// # struct DroppableItem;
     /// {
-    ///     let _ = Droppable;
-    ///     //               ^ dropped here
+    ///     let _ = DroppableItem;
+    ///     //                   ^ dropped here
     ///     /* more code */
     /// }
     /// ```
     ///
-    /// Good:
-    /// ```rust,ignore
+    /// Use instead:
+    /// ```rust
+    /// # struct DroppableItem;
     /// {
-    ///     let _droppable = Droppable;
+    ///     let _droppable = DroppableItem;
     ///     /* more code */
     ///     // dropped at end of scope
     /// }
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index ee0416fc0ff..85f7ff149d1 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -88,10 +88,11 @@ use rustc_session::Session;
 ///     ///
 ///     /// ### Example
 ///     /// ```rust
-///     /// // Bad
 ///     /// Insert a short example of code that triggers the lint
+///     /// ```
 ///     ///
-///     /// // Good
+///     /// Use instead:
+///     /// ```rust
 ///     /// Insert a short example of improved code that doesn't trigger the lint
 ///     /// ```
 ///     pub LINT_NAME,
diff --git a/clippy_lints/src/lifetimes.rs b/clippy_lints/src/lifetimes.rs
index 070c7e59142..93f5663312f 100644
--- a/clippy_lints/src/lifetimes.rs
+++ b/clippy_lints/src/lifetimes.rs
@@ -36,12 +36,14 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust
-    /// // Bad: unnecessary lifetime annotations
+    /// // Unnecessary lifetime annotations
     /// fn in_and_out<'a>(x: &'a u8, y: u8) -> &'a u8 {
     ///     x
     /// }
+    /// ```
     ///
-    /// // Good
+    /// Use instead:
+    /// ```rust
     /// fn elided(x: &u8, y: u8) -> &u8 {
     ///     x
     /// }
@@ -65,12 +67,14 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust
-    /// // Bad: unnecessary lifetimes
+    /// // unnecessary lifetimes
     /// fn unused_lifetime<'a>(x: u8) {
     ///     // ..
     /// }
+    /// ```
     ///
-    /// // Good
+    /// Use instead:
+    /// ```rust
     /// fn no_lifetime(x: u8) {
     ///     // ...
     /// }
diff --git a/clippy_lints/src/literal_representation.rs b/clippy_lints/src/literal_representation.rs
index 9998712b852..cbd084c4168 100644
--- a/clippy_lints/src/literal_representation.rs
+++ b/clippy_lints/src/literal_representation.rs
@@ -22,11 +22,16 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust
-    /// // Bad
-    /// let x: u64 = 61864918973511;
+    /// # let _: u64 =
+    /// 61864918973511
+    /// # ;
+    /// ```
     ///
-    /// // Good
-    /// let x: u64 = 61_864_918_973_511;
+    /// Use instead:
+    /// ```rust
+    /// # let _: u64 =
+    /// 61_864_918_973_511
+    /// # ;
     /// ```
     #[clippy::version = "pre 1.29.0"]
     pub UNREADABLE_LITERAL,
@@ -66,11 +71,16 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust
-    /// // Bad
-    /// let x: u64 = 618_64_9189_73_511;
+    /// # let _: u64 =
+    /// 618_64_9189_73_511
+    /// # ;
+    /// ```
     ///
-    /// // Good
-    /// let x: u64 = 61_864_918_973_511;
+    /// Use instead:
+    /// ```rust
+    /// # let _: u64 =
+    /// 61_864_918_973_511
+    /// # ;
     /// ```
     #[clippy::version = "pre 1.29.0"]
     pub INCONSISTENT_DIGIT_GROUPING,
@@ -125,9 +135,11 @@ declare_clippy_lint! {
     /// readable than a decimal representation.
     ///
     /// ### Example
+    /// ```text
     /// `255` => `0xFF`
     /// `65_535` => `0xFFFF`
     /// `4_042_322_160` => `0xF0F0_F0F0`
+    /// ```
     #[clippy::version = "pre 1.29.0"]
     pub DECIMAL_LITERAL_REPRESENTATION,
     restriction,
diff --git a/clippy_lints/src/loops/mod.rs b/clippy_lints/src/loops/mod.rs
index e32b228e104..acf974c586a 100644
--- a/clippy_lints/src/loops/mod.rs
+++ b/clippy_lints/src/loops/mod.rs
@@ -42,7 +42,8 @@ declare_clippy_lint! {
     ///     dst[i + 64] = src[i];
     /// }
     /// ```
-    /// Could be written as:
+    ///
+    /// Use instead:
     /// ```rust
     /// # let src = vec![1];
     /// # let mut dst = vec![0; 65];
@@ -70,7 +71,8 @@ declare_clippy_lint! {
     ///     println!("{}", vec[i]);
     /// }
     /// ```
-    /// Could be written as:
+    ///
+    /// Use instead:
     /// ```rust
     /// let vec = vec!['a', 'b', 'c'];
     /// for i in vec {
@@ -103,7 +105,8 @@ declare_clippy_lint! {
     ///     // ..
     /// }
     /// ```
-    /// can be rewritten to
+    ///
+    /// Use instead:
     /// ```rust
     /// # let y = vec![1];
     /// for x in &y {
@@ -286,7 +289,8 @@ declare_clippy_lint! {
     ///     i += 1;
     /// }
     /// ```
-    /// Could be written as
+    ///
+    /// Use instead:
     /// ```rust
     /// # let v = vec![1];
     /// # fn bar(bar: usize, baz: usize) {}
@@ -473,7 +477,7 @@ declare_clippy_lint! {
     ///
     /// ### Why is this bad?
     /// This kind of operation can be expressed more succinctly with
-    /// `vec![item;SIZE]` or `vec.resize(NEW_SIZE, item)` and using these alternatives may also
+    /// `vec![item; SIZE]` or `vec.resize(NEW_SIZE, item)` and using these alternatives may also
     /// have better performance.
     ///
     /// ### Example
@@ -488,7 +492,8 @@ declare_clippy_lint! {
     ///     vec.push(item2);
     /// }
     /// ```
-    /// could be written as
+    ///
+    /// Use instead:
     /// ```rust
     /// let item1 = 2;
     /// let item2 = 3;
@@ -516,7 +521,8 @@ declare_clippy_lint! {
     ///     println!("{}", item);
     /// }
     /// ```
-    /// could be written as
+    ///
+    /// Use instead:
     /// ```rust
     /// let item1 = 2;
     /// let item = &item1;
diff --git a/clippy_lints/src/matches/mod.rs b/clippy_lints/src/matches/mod.rs
index d1e42f39e47..3e765173fb9 100644
--- a/clippy_lints/src/matches/mod.rs
+++ b/clippy_lints/src/matches/mod.rs
@@ -43,13 +43,16 @@ declare_clippy_lint! {
     /// ```rust
     /// # fn bar(stool: &str) {}
     /// # let x = Some("abc");
-    /// // Bad
     /// match x {
     ///     Some(ref foo) => bar(foo),
     ///     _ => (),
     /// }
+    /// ```
     ///
-    /// // Good
+    /// Use instead:
+    /// ```rust
+    /// # fn bar(stool: &str) {}
+    /// # let x = Some("abc");
     /// if let Some(ref foo) = x {
     ///     bar(foo);
     /// }
@@ -114,14 +117,15 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust,ignore
-    /// // Bad
     /// match x {
     ///     &A(ref y) => foo(y),
     ///     &B => bar(),
     ///     _ => frob(&x),
     /// }
+    /// ```
     ///
-    /// // Good
+    /// Use instead:
+    /// ```rust,ignore
     /// match *x {
     ///     A(ref y) => foo(y),
     ///     B => bar(),
@@ -227,13 +231,16 @@ declare_clippy_lint! {
     /// ```rust
     /// let x: Option<()> = None;
     ///
-    /// // Bad
     /// let r: Option<&()> = match x {
     ///     None => None,
     ///     Some(ref v) => Some(v),
     /// };
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust
+    /// let x: Option<()> = None;
     ///
-    /// // Good
     /// let r: Option<&()> = x.as_ref();
     /// ```
     #[clippy::version = "pre 1.29.0"]
@@ -257,13 +264,16 @@ declare_clippy_lint! {
     /// ```rust
     /// # enum Foo { A(usize), B(usize) }
     /// # let x = Foo::B(1);
-    /// // Bad
     /// match x {
     ///     Foo::A(_) => {},
     ///     _ => {},
     /// }
+    /// ```
     ///
-    /// // Good
+    /// Use instead:
+    /// ```rust
+    /// # enum Foo { A(usize), B(usize) }
+    /// # let x = Foo::B(1);
     /// match x {
     ///     Foo::A(_) => {},
     ///     Foo::B(_) => {},
@@ -290,14 +300,17 @@ declare_clippy_lint! {
     /// ```rust
     /// # enum Foo { A, B, C }
     /// # let x = Foo::B;
-    /// // Bad
     /// match x {
     ///     Foo::A => {},
     ///     Foo::B => {},
     ///     _ => {},
     /// }
+    /// ```
     ///
-    /// // Good
+    /// Use instead:
+    /// ```rust
+    /// # enum Foo { A, B, C }
+    /// # let x = Foo::B;
     /// match x {
     ///     Foo::A => {},
     ///     Foo::B => {},
@@ -320,14 +333,17 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust
-    /// // Bad
-    /// match "foo" {
+    /// # let s = "foo";
+    /// match s {
     ///     "a" => {},
     ///     "bar" | _ => {},
     /// }
+    /// ```
     ///
-    /// // Good
-    /// match "foo" {
+    /// Use instead:
+    /// ```rust
+    /// # let s = "foo";
+    /// match s {
     ///     "a" => {},
     ///     _ => {},
     /// }
@@ -389,15 +405,17 @@ declare_clippy_lint! {
     /// ```rust
     /// # let a = 1;
     /// # let b = 2;
-    ///
-    /// // Bad
     /// match (a, b) {
     ///     (c, d) => {
     ///         // useless match
     ///     }
     /// }
+    /// ```
     ///
-    /// // Good
+    /// Use instead:
+    /// ```rust
+    /// # let a = 1;
+    /// # let b = 2;
     /// let (c, d) = (a, b);
     /// ```
     #[clippy::version = "1.43.0"]
@@ -419,13 +437,16 @@ declare_clippy_lint! {
     /// # struct A { a: i32 }
     /// let a = A { a: 5 };
     ///
-    /// // Bad
     /// match a {
     ///     A { a: 5, .. } => {},
     ///     _ => {},
     /// }
+    /// ```
     ///
-    /// // Good
+    /// Use instead:
+    /// ```rust
+    /// # struct A { a: i32 }
+    /// # let a = A { a: 5 };
     /// match a {
     ///     A { a: 5 } => {},
     ///     _ => {},
@@ -509,7 +530,6 @@ declare_clippy_lint! {
     /// ```rust
     /// let x = Some(5);
     ///
-    /// // Bad
     /// let a = match x {
     ///     Some(0) => true,
     ///     _ => false,
@@ -520,8 +540,11 @@ declare_clippy_lint! {
     /// } else {
     ///     false
     /// };
+    /// ```
     ///
-    /// // Good
+    /// Use instead:
+    /// ```rust
+    /// let x = Some(5);
     /// let a = matches!(x, Some(0));
     /// ```
     #[clippy::version = "1.47.0"]
@@ -695,19 +718,18 @@ declare_clippy_lint! {
     /// let arr = vec![0, 1, 2, 3];
     /// let idx = 1;
     ///
-    /// // Bad
     /// match arr[idx] {
     ///     0 => println!("{}", 0),
     ///     1 => println!("{}", 3),
     ///     _ => {},
     /// }
     /// ```
+    ///
     /// Use instead:
     /// ```rust, no_run
     /// let arr = vec![0, 1, 2, 3];
     /// let idx = 1;
     ///
-    /// // Good
     /// match arr.get(idx) {
     ///     Some(0) => println!("{}", 0),
     ///     Some(1) => println!("{}", 3),
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 7308e74c323..9d78f0a9fc1 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -124,27 +124,27 @@ declare_clippy_lint! {
     /// It's often inefficient to clone all elements of an iterator, when eventually, only some
     /// of them will be consumed.
     ///
+    /// ### Known Problems
+    /// This `lint` removes the side of effect of cloning items in the iterator.
+    /// A code that relies on that side-effect could fail.
+    ///
     /// ### Examples
     /// ```rust
     /// # let vec = vec!["string".to_string()];
-    ///
-    /// // Bad
+    /// # let _ =
     /// vec.iter().cloned().take(10);
-    ///
-    /// // Good
-    /// vec.iter().take(10).cloned();
-    ///
-    /// // Bad
+    /// # let _ =
     /// vec.iter().cloned().last();
+    /// ```
     ///
-    /// // Good
+    /// Use instead:
+    /// ```rust
+    /// # let vec = vec!["string".to_string()];
+    /// # let _ =
+    /// vec.iter().take(10).cloned();
+    /// # let _ =
     /// vec.iter().last().cloned();
-    ///
     /// ```
-    /// ### Known Problems
-    /// This `lint` removes the side of effect of cloning items in the iterator.
-    /// A code that relies on that side-effect could fail.
-    ///
     #[clippy::version = "1.59.0"]
     pub ITER_OVEREAGER_CLONED,
     perf,
@@ -342,11 +342,12 @@ declare_clippy_lint! {
     /// ### Example
     /// ```rust
     /// # let x = Ok::<_, ()>(());
-    ///
-    /// // Bad
     /// x.ok().expect("why did I do this again?");
+    /// ```
     ///
-    /// // Good
+    /// Use instead:
+    /// ```rust
+    /// # let x = Ok::<_, ()>(());
     /// x.expect("why did I do this again?");
     /// ```
     #[clippy::version = "pre 1.29.0"]
@@ -390,12 +391,13 @@ declare_clippy_lint! {
     /// ### Examples
     /// ```rust
     /// # let x = Some(1);
-    ///
-    /// // Bad
     /// x.unwrap_or_else(Default::default);
     /// x.unwrap_or_else(u32::default);
+    /// ```
     ///
-    /// // Good
+    /// Use instead:
+    /// ```rust
+    /// # let x = Some(1);
     /// x.unwrap_or_default();
     /// ```
     #[clippy::version = "1.56.0"]
@@ -453,11 +455,12 @@ declare_clippy_lint! {
     /// ### Example
     /// ```rust
     /// # let opt = Some(1);
-    ///
-    /// // Bad
     /// opt.map_or(None, |a| Some(a + 1));
+    /// ```
     ///
-    /// // Good
+    /// Use instead:
+    /// ```rust
+    /// # let opt = Some(1);
     /// opt.and_then(|a| Some(a + 1));
     /// ```
     #[clippy::version = "pre 1.29.0"]
@@ -475,13 +478,12 @@ declare_clippy_lint! {
     /// `_.ok()`.
     ///
     /// ### Example
-    /// Bad:
     /// ```rust
     /// # let r: Result<u32, &str> = Ok(1);
     /// assert_eq!(Some(1), r.map_or(None, Some));
     /// ```
     ///
-    /// Good:
+    /// Use instead:
     /// ```rust
     /// # let r: Result<u32, &str> = Ok(1);
     /// assert_eq!(Some(1), r.ok());
@@ -538,7 +540,8 @@ declare_clippy_lint! {
     /// # let vec = vec![1];
     /// vec.iter().filter(|x| **x == 0).next();
     /// ```
-    /// Could be written as
+    ///
+    /// Use instead:
     /// ```rust
     /// # let vec = vec![1];
     /// vec.iter().find(|x| **x == 0);
@@ -562,7 +565,8 @@ declare_clippy_lint! {
     /// # let vec = vec![1];
     /// vec.iter().skip_while(|x| **x == 0).next();
     /// ```
-    /// Could be written as
+    ///
+    /// Use instead:
     /// ```rust
     /// # let vec = vec![1];
     /// vec.iter().find(|x| **x != 0);
@@ -586,11 +590,16 @@ declare_clippy_lint! {
     /// let vec = vec![vec![1]];
     /// let opt = Some(5);
     ///
-    /// // Bad
+    /// # let _ =
     /// vec.iter().map(|x| x.iter()).flatten();
     /// opt.map(|x| Some(x * 2)).flatten();
+    /// ```
     ///
-    /// // Good
+    /// Use instead:
+    /// ```rust
+    /// # let vec = vec![vec![1]];
+    /// # let opt = Some(5);
+    /// # let _ =
     /// vec.iter().flat_map(|x| x.iter());
     /// opt.and_then(|x| Some(x * 2));
     /// ```
@@ -610,15 +619,16 @@ declare_clippy_lint! {
     /// less performant.
     ///
      /// ### Example
-    /// Bad:
     /// ```rust
+    /// # let  _ =
     /// (0_i32..10)
     ///     .filter(|n| n.checked_add(1).is_some())
     ///     .map(|n| n.checked_add(1).unwrap());
     /// ```
     ///
-    /// Good:
+    /// Use instead:
     /// ```rust
+    /// # let _ =
     /// (0_i32..10).filter_map(|n| n.checked_add(1));
     /// ```
     #[clippy::version = "1.51.0"]
@@ -637,14 +647,13 @@ declare_clippy_lint! {
     /// less performant.
     ///
      /// ### Example
-    /// Bad:
     /// ```rust
     /// (0_i32..10)
     ///     .find(|n| n.checked_add(1).is_some())
     ///     .map(|n| n.checked_add(1).unwrap());
     /// ```
     ///
-    /// Good:
+    /// Use instead:
     /// ```rust
     /// (0_i32..10).find_map(|n| n.checked_add(1));
     /// ```
@@ -713,16 +722,20 @@ declare_clippy_lint! {
     /// ### Example
     /// ```rust
     /// let vec = vec![1];
+    /// # let _ =
     /// vec.iter().find(|x| **x == 0).is_some();
     ///
-    /// let _ = "hello world".find("world").is_none();
+    /// # let _ =
+    /// "hello world".find("world").is_none();
     /// ```
-    /// Could be written as
+    ///
+    /// Use instead:
     /// ```rust
     /// let vec = vec![1];
     /// vec.iter().any(|x| *x == 0);
     ///
-    /// let _ = !"hello world".contains("world");
+    /// # let _ =
+    /// !"hello world".contains("world");
     /// ```
     #[clippy::version = "pre 1.29.0"]
     pub SEARCH_IS_SOME,
@@ -744,7 +757,8 @@ declare_clippy_lint! {
     /// let name = "foo";
     /// if name.chars().next() == Some('_') {};
     /// ```
-    /// Could be written as
+    ///
+    /// Use instead:
     /// ```rust
     /// let name = "foo";
     /// if name.starts_with('_') {};
@@ -899,10 +913,13 @@ declare_clippy_lint! {
     /// # use std::rc::Rc;
     /// let x = Rc::new(1);
     ///
-    /// // Bad
     /// x.clone();
+    /// ```
     ///
-    /// // Good
+    /// Use instead:
+    /// ```rust
+    /// # use std::rc::Rc;
+    /// # let x = Rc::new(1);
     /// Rc::clone(&x);
     /// ```
     #[clippy::version = "pre 1.29.0"]
@@ -1034,11 +1051,13 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust,ignore
-    /// // Bad
     /// _.split("x");
+    /// ```
     ///
-    /// // Good
+    /// Use instead:
+    /// ```rust,ignore
     /// _.split('x');
+    /// ```
     #[clippy::version = "pre 1.29.0"]
     pub SINGLE_CHAR_PATTERN,
     perf,
@@ -1099,12 +1118,14 @@ declare_clippy_lint! {
     /// ### Example
     /// ```rust
     /// # use std::collections::HashSet;
-    /// // Bad
     /// # let mut s = HashSet::new();
     /// # s.insert(1);
     /// let x = s.iter().nth(0);
+    /// ```
     ///
-    /// // Good
+    /// Use instead:
+    /// ```rust
+    /// # use std::collections::HashSet;
     /// # let mut s = HashSet::new();
     /// # s.insert(1);
     /// let x = s.iter().next();
@@ -1210,11 +1231,12 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust
-    /// // Bad
     /// let x = vec![2, 3, 5];
     /// let last_element = x.get(x.len() - 1);
+    /// ```
     ///
-    /// // Good
+    /// Use instead:
+    /// ```rust
     /// let x = vec![2, 3, 5];
     /// let last_element = x.last();
     /// ```
@@ -1273,10 +1295,14 @@ declare_clippy_lint! {
     /// let mut a = vec![1, 2, 3];
     /// let mut b = vec![4, 5, 6];
     ///
-    /// // Bad
     /// a.extend(b.drain(..));
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust
+    /// let mut a = vec![1, 2, 3];
+    /// let mut b = vec![4, 5, 6];
     ///
-    /// // Good
     /// a.append(&mut b);
     /// ```
     #[clippy::version = "1.55.0"]
@@ -1351,11 +1377,12 @@ declare_clippy_lint! {
     /// ### Example
     /// ```rust
     /// # let name = "_";
-    ///
-    /// // Bad
     /// name.chars().last() == Some('_') || name.chars().next_back() == Some('-');
+    /// ```
     ///
-    /// // Good
+    /// Use instead:
+    /// ```rust
+    /// # let name = "_";
     /// name.ends_with('_') || name.ends_with('-');
     /// ```
     #[clippy::version = "pre 1.29.0"]
@@ -1401,11 +1428,14 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust
-    /// let _ = (0..3).fold(false, |acc, x| acc || x > 2);
+    /// # let _ =
+    /// (0..3).fold(false, |acc, x| acc || x > 2);
     /// ```
-    /// This could be written as:
+    ///
+    /// Use instead:
     /// ```rust
-    /// let _ = (0..3).any(|x| x > 2);
+    /// # let _ =
+    /// (0..3).any(|x| x > 2);
     /// ```
     #[clippy::version = "pre 1.29.0"]
     pub UNNECESSARY_FOLD,
@@ -1485,11 +1515,14 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust
-    /// // Bad
-    /// let _ = (&vec![3, 4, 5]).into_iter();
+    /// # let _ =
+    /// (&vec![3, 4, 5]).into_iter();
+    /// ```
     ///
-    /// // Good
-    /// let _ = (&vec![3, 4, 5]).iter();
+    /// Use instead:
+    /// ```rust
+    /// # let _ =
+    /// (&vec![3, 4, 5]).iter();
     /// ```
     #[clippy::version = "1.32.0"]
     pub INTO_ITER_ON_REF,
@@ -1704,13 +1737,14 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust
-    /// let mut string = String::new();
+    /// # let mut string = String::new();
     /// string.insert_str(0, "R");
     /// string.push_str("R");
     /// ```
-    /// Could be written as
+    ///
+    /// Use instead:
     /// ```rust
-    /// let mut string = String::new();
+    /// # let mut string = String::new();
     /// string.insert(0, 'R');
     /// string.push('R');
     /// ```
@@ -1897,11 +1931,14 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust
-    /// // Bad
-    /// let _ = "Hello".bytes().nth(3);
+    /// # let _ =
+    /// "Hello".bytes().nth(3);
+    /// ```
     ///
-    /// // Good
-    /// let _ = "Hello".as_bytes().get(3);
+    /// Use instead:
+    /// ```rust
+    /// # let _ =
+    /// "Hello".as_bytes().get(3);
     /// ```
     #[clippy::version = "1.52.0"]
     pub BYTES_NTH,
@@ -1945,15 +1982,20 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust
-    /// // Bad
     /// let some_vec = vec![0, 1, 2, 3];
-    /// let _ = some_vec.iter().count();
-    /// let _ = &some_vec[..].iter().count();
+    /// # let _ =
+    /// some_vec.iter().count();
+    /// # let _ =
+    /// &some_vec[..].iter().count();
+    /// ```
     ///
-    /// // Good
+    /// Use instead:
+    /// ```rust
     /// let some_vec = vec![0, 1, 2, 3];
-    /// let _ = some_vec.len();
-    /// let _ = &some_vec[..].len();
+    /// # let _ =
+    /// some_vec.len();
+    /// # let _ =
+    /// &some_vec[..].len();
     /// ```
     #[clippy::version = "1.52.0"]
     pub ITER_COUNT,
@@ -1973,16 +2015,17 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust
-    /// // Bad
-    /// let s = "";
+    /// # let s = "";
     /// for x in s.splitn(1, ":") {
-    ///     // use x
+    ///     // ..
     /// }
+    /// ```
     ///
-    /// // Good
-    /// let s = "";
+    /// Use instead:
+    /// ```rust
+    /// # let s = "";
     /// for x in s.splitn(2, ":") {
-    ///     // use x
+    ///     // ..
     /// }
     /// ```
     #[clippy::version = "1.54.0"]
@@ -2000,10 +2043,11 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust
-    /// // Bad
     /// let x: String = std::iter::repeat('x').take(10).collect();
+    /// ```
     ///
-    /// // Good
+    /// Use instead:
+    /// ```rust
     /// let x: String = "x".repeat(10);
     /// ```
     #[clippy::version = "1.54.0"]
@@ -2021,7 +2065,6 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust,ignore
-    /// // Bad
     /// let s = "key=value=add";
     /// let (key, value) = s.splitn(2, '=').next_tuple()?;
     /// let value = s.splitn(2, '=').nth(1)?;
@@ -2030,9 +2073,9 @@ declare_clippy_lint! {
     /// let key = parts.next()?;
     /// let value = parts.next()?;
     /// ```
+    ///
     /// Use instead:
     /// ```rust,ignore
-    /// // Good
     /// let s = "key=value=add";
     /// let (key, value) = s.split_once('=')?;
     /// let value = s.split_once('=')?.1;
@@ -2057,13 +2100,12 @@ declare_clippy_lint! {
     /// that both functions return a lazy iterator.
     /// ### Example
     /// ```rust
-    /// // Bad
     /// let str = "key=value=add";
     /// let _ = str.splitn(3, '=').next().unwrap();
     /// ```
+    ///
     /// Use instead:
     /// ```rust
-    /// // Good
     /// let str = "key=value=add";
     /// let _ = str.split('=').next().unwrap();
     /// ```
@@ -2149,7 +2191,8 @@ declare_clippy_lint! {
     /// let a = Some(&1);
     /// let b = a.as_deref(); // goes from Option<&i32> to Option<&i32>
     /// ```
-    /// Could be written as:
+    ///
+    /// Use instead:
     /// ```rust
     /// let a = Some(&1);
     /// let b = a;
diff --git a/clippy_lints/src/misc.rs b/clippy_lints/src/misc.rs
index 55665699453..01bf871198a 100644
--- a/clippy_lints/src/misc.rs
+++ b/clippy_lints/src/misc.rs
@@ -45,16 +45,13 @@ declare_clippy_lint! {
     /// dereferences, e.g., changing `*x` to `x` within the function.
     ///
     /// ### Example
-    /// ```rust,ignore
-    /// // Bad
-    /// fn foo(ref x: u8) -> bool {
-    ///     true
-    /// }
+    /// ```rust
+    /// fn foo(ref _x: u8) {}
+    /// ```
     ///
-    /// // Good
-    /// fn foo(x: &u8) -> bool {
-    ///     true
-    /// }
+    /// Use instead:
+    /// ```rust
+    /// fn foo(_x: &u8) {}
     /// ```
     #[clippy::version = "pre 1.29.0"]
     pub TOPLEVEL_REF_ARG,
@@ -73,11 +70,12 @@ declare_clippy_lint! {
     /// ### Example
     /// ```rust
     /// # let x = 1.0;
-    ///
-    /// // Bad
     /// if x == f32::NAN { }
+    /// ```
     ///
-    /// // Good
+    /// Use instead:
+    /// ```rust
+    /// # let x = 1.0f32;
     /// if x.is_nan() { }
     /// ```
     #[clippy::version = "pre 1.29.0"]
@@ -139,7 +137,8 @@ declare_clippy_lint! {
     /// # let y = String::from("foo");
     /// if x.to_owned() == y {}
     /// ```
-    /// Could be written as
+    ///
+    /// Use instead:
     /// ```rust
     /// # let x = "foo";
     /// # let y = String::from("foo");
@@ -232,10 +231,11 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust
-    /// // Bad
     /// let a = 0 as *const u32;
+    /// ```
     ///
-    /// // Good
+    /// Use instead:
+    /// ```rust
     /// let a = std::ptr::null::<u32>();
     /// ```
     #[clippy::version = "pre 1.29.0"]
diff --git a/clippy_lints/src/misc_early/mod.rs b/clippy_lints/src/misc_early/mod.rs
index 6860b60acbd..704918c0b97 100644
--- a/clippy_lints/src/misc_early/mod.rs
+++ b/clippy_lints/src/misc_early/mod.rs
@@ -34,13 +34,21 @@ declare_clippy_lint! {
     /// # }
     /// let f = Foo { a: 0, b: 0, c: 0 };
     ///
-    /// // Bad
     /// match f {
     ///     Foo { a: _, b: 0, .. } => {},
     ///     Foo { a: _, b: _, c: _ } => {},
     /// }
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust
+    /// # struct Foo {
+    /// #     a: i32,
+    /// #     b: i32,
+    /// #     c: i32,
+    /// # }
+    /// let f = Foo { a: 0, b: 0, c: 0 };
     ///
-    /// // Good
     /// match f {
     ///     Foo { b: 0, .. } => {},
     ///     Foo { .. } => {},
@@ -62,10 +70,11 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust
-    /// // Bad
     /// fn foo(a: i32, _a: i32) {}
+    /// ```
     ///
-    /// // Good
+    /// Use instead:
+    /// ```rust
     /// fn bar(a: i32, _b: i32) {}
     /// ```
     #[clippy::version = "pre 1.29.0"]
@@ -103,11 +112,16 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust
-    /// // Bad
-    /// let y = 0x1a9BAcD;
+    /// # let _ =
+    /// 0x1a9BAcD
+    /// # ;
+    /// ```
     ///
-    /// // Good
-    /// let y = 0x1A9BACD;
+    /// Use instead:
+    /// ```rust
+    /// # let _ =
+    /// 0x1A9BACD
+    /// # ;
     /// ```
     #[clippy::version = "pre 1.29.0"]
     pub MIXED_CASE_HEX_LITERALS,
@@ -127,11 +141,16 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust
-    /// // Bad
-    /// let y = 123832i32;
+    /// # let _ =
+    /// 123832i32
+    /// # ;
+    /// ```
     ///
-    /// // Good
-    /// let y = 123832_i32;
+    /// Use instead:
+    /// ```rust
+    /// # let _ =
+    /// 123832_i32
+    /// # ;
     /// ```
     #[clippy::version = "pre 1.29.0"]
     pub UNSEPARATED_LITERAL_SUFFIX,
@@ -150,11 +169,16 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust
-    /// // Bad
-    /// let y = 123832_i32;
+    /// # let _ =
+    /// 123832_i32
+    /// # ;
+    /// ```
     ///
-    /// // Good
-    /// let y = 123832i32;
+    /// Use instead:
+    /// ```rust
+    /// # let _ =
+    /// 123832i32
+    /// # ;
     /// ```
     #[clippy::version = "1.58.0"]
     pub SEPARATED_LITERAL_SUFFIX,
@@ -234,14 +258,15 @@ declare_clippy_lint! {
     /// ### Example
     /// ```rust
     /// # let v = Some("abc");
-    ///
-    /// // Bad
     /// match v {
     ///     Some(x) => (),
     ///     y @ _ => (),
     /// }
+    /// ```
     ///
-    /// // Good
+    /// Use instead:
+    /// ```rust
+    /// # let v = Some("abc");
     /// match v {
     ///     Some(x) => (),
     ///     y => (),
@@ -262,6 +287,7 @@ declare_clippy_lint! {
     /// means there are 0 or more elements left. This can make a difference
     /// when refactoring, but shouldn't result in errors in the refactored code,
     /// since the wildcard pattern isn't used anyway.
+    ///
     /// ### Why is this bad?
     /// The wildcard pattern is unneeded as the rest pattern
     /// can match that element as well.
@@ -270,13 +296,16 @@ declare_clippy_lint! {
     /// ```rust
     /// # struct TupleStruct(u32, u32, u32);
     /// # let t = TupleStruct(1, 2, 3);
-    /// // Bad
     /// match t {
     ///     TupleStruct(0, .., _) => (),
     ///     _ => (),
     /// }
+    /// ```
     ///
-    /// // Good
+    /// Use instead:
+    /// ```rust
+    /// # struct TupleStruct(u32, u32, u32);
+    /// # let t = TupleStruct(1, 2, 3);
     /// match t {
     ///     TupleStruct(0, ..) => (),
     ///     _ => (),
diff --git a/clippy_lints/src/mixed_read_write_in_expression.rs b/clippy_lints/src/mixed_read_write_in_expression.rs
index 024bd076071..1ad07125b54 100644
--- a/clippy_lints/src/mixed_read_write_in_expression.rs
+++ b/clippy_lints/src/mixed_read_write_in_expression.rs
@@ -25,14 +25,16 @@ declare_clippy_lint! {
     /// ```rust
     /// let mut x = 0;
     ///
-    /// // Bad
     /// let a = {
     ///     x = 1;
     ///     1
     /// } + x;
     /// // Unclear whether a is 1 or 2.
+    /// ```
     ///
-    /// // Good
+    /// Use instead:
+    /// ```rust
+    /// # let mut x = 0;
     /// let tmp = {
     ///     x = 1;
     ///     1
diff --git a/clippy_lints/src/mut_reference.rs b/clippy_lints/src/mut_reference.rs
index 9d8f8999ce4..f434a655f8a 100644
--- a/clippy_lints/src/mut_reference.rs
+++ b/clippy_lints/src/mut_reference.rs
@@ -16,12 +16,17 @@ declare_clippy_lint! {
     /// the value. Also the code misleads about the intent of the call site.
     ///
     /// ### Example
-    /// ```ignore
-    /// // Bad
-    /// my_vec.push(&mut value)
+    /// ```rust
+    /// # let mut vec = Vec::new();
+    /// # let mut value = 5;
+    /// vec.push(&mut value);
+    /// ```
     ///
-    /// // Good
-    /// my_vec.push(&value)
+    /// Use instead:
+    /// ```rust
+    /// # let mut vec = Vec::new();
+    /// # let value = 5;
+    /// vec.push(&value);
     /// ```
     #[clippy::version = "pre 1.29.0"]
     pub UNNECESSARY_MUT_PASSED,
diff --git a/clippy_lints/src/mutex_atomic.rs b/clippy_lints/src/mutex_atomic.rs
index 73823779e49..a98577093ed 100644
--- a/clippy_lints/src/mutex_atomic.rs
+++ b/clippy_lints/src/mutex_atomic.rs
@@ -27,12 +27,13 @@ declare_clippy_lint! {
     /// ### Example
     /// ```rust
     /// # let y = true;
-    ///
-    /// // Bad
     /// # use std::sync::Mutex;
     /// let x = Mutex::new(&y);
+    /// ```
     ///
-    /// // Good
+    /// Use instead:
+    /// ```rust
+    /// # let y = true;
     /// # use std::sync::atomic::AtomicBool;
     /// let x = AtomicBool::new(y);
     /// ```
@@ -60,8 +61,10 @@ declare_clippy_lint! {
     /// ```rust
     /// # use std::sync::Mutex;
     /// let x = Mutex::new(0usize);
+    /// ```
     ///
-    /// // Good
+    /// Use instead:
+    /// ```rust
     /// # use std::sync::atomic::AtomicUsize;
     /// let x = AtomicUsize::new(0usize);
     /// ```
diff --git a/clippy_lints/src/needless_bool.rs b/clippy_lints/src/needless_bool.rs
index 778d49cb4b6..33638fe3734 100644
--- a/clippy_lints/src/needless_bool.rs
+++ b/clippy_lints/src/needless_bool.rs
@@ -30,16 +30,22 @@ declare_clippy_lint! {
     /// shorter code.
     ///
     /// ### Example
-    /// ```rust,ignore
+    /// ```rust
+    /// # let x = true;
     /// if x {
     ///     false
+    /// # ;
     /// } else {
     ///     true
+    /// # ;
     /// }
     /// ```
-    /// Could be written as
-    /// ```rust,ignore
+    ///
+    /// Use instead:
+    /// ```rust
+    /// # let x = true;
     /// !x
+    /// # ;
     /// ```
     #[clippy::version = "pre 1.29.0"]
     pub NEEDLESS_BOOL,
diff --git a/clippy_lints/src/needless_borrowed_ref.rs b/clippy_lints/src/needless_borrowed_ref.rs
index 0fcc419e722..55da6e0f0a3 100644
--- a/clippy_lints/src/needless_borrowed_ref.rs
+++ b/clippy_lints/src/needless_borrowed_ref.rs
@@ -27,16 +27,17 @@ declare_clippy_lint! {
     /// ```
     ///
     /// ### Example
-    /// Bad:
     /// ```rust
     /// let mut v = Vec::<String>::new();
-    /// let _ = v.iter_mut().filter(|&ref a| a.is_empty());
+    /// # let _ =
+    /// v.iter_mut().filter(|&ref a| a.is_empty());
     /// ```
     ///
-    /// Good:
+    /// Use instead:
     /// ```rust
     /// let mut v = Vec::<String>::new();
-    /// let _ = v.iter_mut().filter(|a| a.is_empty());
+    /// # let _ =
+    /// v.iter_mut().filter(|a| a.is_empty());
     /// ```
     #[clippy::version = "pre 1.29.0"]
     pub NEEDLESS_BORROWED_REFERENCE,
diff --git a/clippy_lints/src/needless_update.rs b/clippy_lints/src/needless_update.rs
index c87c174ef73..0bd29d1776b 100644
--- a/clippy_lints/src/needless_update.rs
+++ b/clippy_lints/src/needless_update.rs
@@ -24,16 +24,17 @@ declare_clippy_lint! {
     /// #     z: i32,
     /// # }
     /// # let zero_point = Point { x: 0, y: 0, z: 0 };
-    ///
-    /// // Bad
     /// Point {
     ///     x: 1,
     ///     y: 1,
     ///     z: 1,
     ///     ..zero_point
     /// };
+    /// ```
     ///
-    /// // Ok
+    /// Use instead:
+    /// ```rust,ignore
+    /// // Missing field `z`
     /// Point {
     ///     x: 1,
     ///     y: 1,
diff --git a/clippy_lints/src/neg_cmp_op_on_partial_ord.rs b/clippy_lints/src/neg_cmp_op_on_partial_ord.rs
index efe31a15441..a7e0e35787c 100644
--- a/clippy_lints/src/neg_cmp_op_on_partial_ord.rs
+++ b/clippy_lints/src/neg_cmp_op_on_partial_ord.rs
@@ -19,17 +19,17 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust
-    /// use std::cmp::Ordering;
-    ///
-    /// // Bad
     /// let a = 1.0;
     /// let b = f64::NAN;
     ///
-    /// let _not_less_or_equal = !(a <= b);
+    /// let not_less_or_equal = !(a <= b);
+    /// ```
     ///
-    /// // Good
-    /// let a = 1.0;
-    /// let b = f64::NAN;
+    /// Use instead:
+    /// ```rust
+    /// use std::cmp::Ordering;
+    /// # let a = 1.0;
+    /// # let b = f64::NAN;
     ///
     /// let _not_less_or_equal = match a.partial_cmp(&b) {
     ///     None | Some(Ordering::Greater) => true,
diff --git a/clippy_lints/src/neg_multiply.rs b/clippy_lints/src/neg_multiply.rs
index 707f3b2181a..ce6bb38b7c0 100644
--- a/clippy_lints/src/neg_multiply.rs
+++ b/clippy_lints/src/neg_multiply.rs
@@ -19,12 +19,13 @@ declare_clippy_lint! {
     /// This only catches integers (for now).
     ///
     /// ### Example
-    /// ```ignore
-    /// // Bad
+    /// ```rust,ignore
     /// let a = x * -1;
+    /// ```
     ///
-    /// // Good
-    /// let b = -x;
+    /// Use instead:
+    /// ```rust,ignore
+    /// let a = -x;
     /// ```
     #[clippy::version = "pre 1.29.0"]
     pub NEG_MULTIPLY,
diff --git a/clippy_lints/src/non_copy_const.rs b/clippy_lints/src/non_copy_const.rs
index 8db41ba6ee2..b727105f670 100644
--- a/clippy_lints/src/non_copy_const.rs
+++ b/clippy_lints/src/non_copy_const.rs
@@ -58,12 +58,14 @@ declare_clippy_lint! {
     /// ```rust
     /// use std::sync::atomic::{AtomicUsize, Ordering::SeqCst};
     ///
-    /// // Bad.
     /// const CONST_ATOM: AtomicUsize = AtomicUsize::new(12);
     /// CONST_ATOM.store(6, SeqCst); // the content of the atomic is unchanged
     /// assert_eq!(CONST_ATOM.load(SeqCst), 12); // because the CONST_ATOM in these lines are distinct
+    /// ```
     ///
-    /// // Good.
+    /// Use instead:
+    /// ```rust
+    /// # use std::sync::atomic::{AtomicUsize, Ordering::SeqCst};
     /// static STATIC_ATOM: AtomicUsize = AtomicUsize::new(15);
     /// STATIC_ATOM.store(9, SeqCst);
     /// assert_eq!(STATIC_ATOM.load(SeqCst), 9); // use a `static` item to refer to the same instance
@@ -104,11 +106,15 @@ declare_clippy_lint! {
     /// use std::sync::atomic::{AtomicUsize, Ordering::SeqCst};
     /// const CONST_ATOM: AtomicUsize = AtomicUsize::new(12);
     ///
-    /// // Bad.
     /// CONST_ATOM.store(6, SeqCst); // the content of the atomic is unchanged
     /// assert_eq!(CONST_ATOM.load(SeqCst), 12); // because the CONST_ATOM in these lines are distinct
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust
+    /// use std::sync::atomic::{AtomicUsize, Ordering::SeqCst};
+    /// const CONST_ATOM: AtomicUsize = AtomicUsize::new(12);
     ///
-    /// // Good.
     /// static STATIC_ATOM: AtomicUsize = CONST_ATOM;
     /// STATIC_ATOM.store(9, SeqCst);
     /// assert_eq!(STATIC_ATOM.load(SeqCst), 9); // use a `static` item to refer to the same instance
diff --git a/clippy_lints/src/octal_escapes.rs b/clippy_lints/src/octal_escapes.rs
index e8532db4f71..c8854539677 100644
--- a/clippy_lints/src/octal_escapes.rs
+++ b/clippy_lints/src/octal_escapes.rs
@@ -33,11 +33,12 @@ declare_clippy_lint! {
     ///
     /// # Example
     /// ```rust
-    /// // Bad
     /// let one = "\033[1m Bold? \033[0m";  // \033 intended as escape
     /// let two = "\033\0";                 // \033 intended as null-3-3
+    /// ```
     ///
-    /// // Good
+    /// Use instead:
+    /// ```rust
     /// let one = "\x1b[1mWill this be bold?\x1b[0m";
     /// let two = "\x0033\x00";
     /// ```
diff --git a/clippy_lints/src/pass_by_ref_or_value.rs b/clippy_lints/src/pass_by_ref_or_value.rs
index 5a93431f25a..05ab62786f4 100644
--- a/clippy_lints/src/pass_by_ref_or_value.rs
+++ b/clippy_lints/src/pass_by_ref_or_value.rs
@@ -57,12 +57,11 @@ declare_clippy_lint! {
     /// ### Example
     ///
     /// ```rust
-    /// // Bad
     /// fn foo(v: &u32) {}
     /// ```
     ///
+    /// Use instead:
     /// ```rust
-    /// // Better
     /// fn foo(v: u32) {}
     /// ```
     #[clippy::version = "pre 1.29.0"]
@@ -89,14 +88,13 @@ declare_clippy_lint! {
     /// #[derive(Clone, Copy)]
     /// struct TooLarge([u8; 2048]);
     ///
-    /// // Bad
     /// fn foo(v: TooLarge) {}
     /// ```
-    /// ```rust
-    /// #[derive(Clone, Copy)]
-    /// struct TooLarge([u8; 2048]);
     ///
-    /// // Good
+    /// Use instead:
+    /// ```rust
+    /// # #[derive(Clone, Copy)]
+    /// # struct TooLarge([u8; 2048]);
     /// fn foo(v: &TooLarge) {}
     /// ```
     #[clippy::version = "1.49.0"]
diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs
index 0b96f6ff683..b06eba13d2f 100644
--- a/clippy_lints/src/ptr.rs
+++ b/clippy_lints/src/ptr.rs
@@ -48,10 +48,11 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```ignore
-    /// // Bad
     /// fn foo(&Vec<u32>) { .. }
+    /// ```
     ///
-    /// // Good
+    /// Use instead:
+    /// ```ignore
     /// fn foo(&[u32]) { .. }
     /// ```
     #[clippy::version = "pre 1.29.0"]
@@ -70,15 +71,18 @@ declare_clippy_lint! {
     /// method instead
     ///
     /// ### Example
-    /// ```ignore
-    /// // Bad
+    /// ```rust,ignore
+    /// use std::ptr;
+    ///
     /// if x == ptr::null {
-    ///     ..
+    ///     // ..
     /// }
+    /// ```
     ///
-    /// // Good
+    /// Use instead:
+    /// ```rust,ignore
     /// if x.is_null() {
-    ///     ..
+    ///     // ..
     /// }
     /// ```
     #[clippy::version = "pre 1.29.0"]
@@ -129,12 +133,12 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```ignore
-    /// // Bad. Undefined behavior
+    /// // Undefined behavior
     /// unsafe { std::slice::from_raw_parts(ptr::null(), 0); }
     /// ```
     ///
+    /// Use instead:
     /// ```ignore
-    /// // Good
     /// unsafe { std::slice::from_raw_parts(NonNull::dangling().as_ptr(), 0); }
     /// ```
     #[clippy::version = "1.53.0"]
diff --git a/clippy_lints/src/ranges.rs b/clippy_lints/src/ranges.rs
index 584b561dcf0..be7eae02687 100644
--- a/clippy_lints/src/ranges.rs
+++ b/clippy_lints/src/ranges.rs
@@ -27,11 +27,14 @@ declare_clippy_lint! {
     /// ### Example
     /// ```rust
     /// # let x = vec![1];
+    /// # let _ =
     /// x.iter().zip(0..x.len());
     /// ```
-    /// Could be written as
+    ///
+    /// Use instead:
     /// ```rust
     /// # let x = vec![1];
+    /// # let _ =
     /// x.iter().enumerate();
     /// ```
     #[clippy::version = "pre 1.29.0"]
@@ -65,12 +68,21 @@ declare_clippy_lint! {
     /// ([#3307](https://github.com/rust-lang/rust-clippy/issues/3307)).
     ///
     /// ### Example
-    /// ```rust,ignore
-    /// for x..(y+1) { .. }
+    /// ```rust
+    /// # let x = 0;
+    /// # let y = 1;
+    /// for i in x..(y+1) {
+    ///     // ..
+    /// }
     /// ```
-    /// Could be written as
-    /// ```rust,ignore
-    /// for x..=y { .. }
+    ///
+    /// Use instead:
+    /// ```rust
+    /// # let x = 0;
+    /// # let y = 1;
+    /// for i in x..=y {
+    ///     // ..
+    /// }
     /// ```
     #[clippy::version = "pre 1.29.0"]
     pub RANGE_PLUS_ONE,
@@ -94,12 +106,21 @@ declare_clippy_lint! {
     /// ([#3307](https://github.com/rust-lang/rust-clippy/issues/3307)).
     ///
     /// ### Example
-    /// ```rust,ignore
-    /// for x..=(y-1) { .. }
+    /// ```rust
+    /// # let x = 0;
+    /// # let y = 1;
+    /// for i in x..=(y-1) {
+    ///     // ..
+    /// }
     /// ```
-    /// Could be written as
-    /// ```rust,ignore
-    /// for x..y { .. }
+    ///
+    /// Use instead:
+    /// ```rust
+    /// # let x = 0;
+    /// # let y = 1;
+    /// for i in x..y {
+    ///     // ..
+    /// }
     /// ```
     #[clippy::version = "pre 1.29.0"]
     pub RANGE_MINUS_ONE,
diff --git a/clippy_lints/src/redundant_closure_call.rs b/clippy_lints/src/redundant_closure_call.rs
index 5a25008e95e..3aa18557d91 100644
--- a/clippy_lints/src/redundant_closure_call.rs
+++ b/clippy_lints/src/redundant_closure_call.rs
@@ -23,12 +23,13 @@ declare_clippy_lint! {
     /// complexity.
     ///
     /// ### Example
-    /// ```rust,ignore
-    /// // Bad
-    /// let a = (|| 42)()
+    /// ```rust
+    /// let a = (|| 42)();
+    /// ```
     ///
-    /// // Good
-    /// let a = 42
+    /// Use instead:
+    /// ```rust
+    /// let a = 42;
     /// ```
     #[clippy::version = "pre 1.29.0"]
     pub REDUNDANT_CLOSURE_CALL,
diff --git a/clippy_lints/src/reference.rs b/clippy_lints/src/reference.rs
index f789cec6d6a..a642e2da3ba 100644
--- a/clippy_lints/src/reference.rs
+++ b/clippy_lints/src/reference.rs
@@ -21,11 +21,12 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust,ignore
-    /// // Bad
     /// let a = f(*&mut b);
     /// let c = *&d;
+    /// ```
     ///
-    /// // Good
+    /// Use instead:
+    /// ```rust,ignore
     /// let a = f(b);
     /// let c = d;
     /// ```
diff --git a/clippy_lints/src/return_self_not_must_use.rs b/clippy_lints/src/return_self_not_must_use.rs
index 91e5e1e8b28..60be6bd335f 100644
--- a/clippy_lints/src/return_self_not_must_use.rs
+++ b/clippy_lints/src/return_self_not_must_use.rs
@@ -26,19 +26,20 @@ declare_clippy_lint! {
     /// if it was added on constructors for example.
     ///
     /// ### Example
-    /// Missing attribute
     /// ```rust
     /// pub struct Bar;
     /// impl Bar {
-    ///     // Bad
+    ///     // Missing attribute
     ///     pub fn bar(&self) -> Self {
     ///         Self
     ///     }
     /// }
     /// ```
     ///
-    /// It's better to have the `#[must_use]` attribute on the method like this:
+    /// Use instead:
     /// ```rust
+    /// # {
+    /// // It's better to have the `#[must_use]` attribute on the method like this:
     /// pub struct Bar;
     /// impl Bar {
     ///     #[must_use]
@@ -46,10 +47,10 @@ declare_clippy_lint! {
     ///         Self
     ///     }
     /// }
-    /// ```
+    /// # }
     ///
-    /// Or on the type definition like this:
-    /// ```rust
+    /// # {
+    /// // Or on the type definition like this:
     /// #[must_use]
     /// pub struct Bar;
     /// impl Bar {
@@ -57,6 +58,7 @@ declare_clippy_lint! {
     ///         Self
     ///     }
     /// }
+    /// # }
     /// ```
     #[clippy::version = "1.59.0"]
     pub RETURN_SELF_NOT_MUST_USE,
diff --git a/clippy_lints/src/shadow.rs b/clippy_lints/src/shadow.rs
index 4f74c1e44c2..bf318c055da 100644
--- a/clippy_lints/src/shadow.rs
+++ b/clippy_lints/src/shadow.rs
@@ -23,10 +23,12 @@ declare_clippy_lint! {
     /// ### Example
     /// ```rust
     /// # let x = 1;
-    /// // Bad
     /// let x = &x;
+    /// ```
     ///
-    /// // Good
+    /// Use instead:
+    /// ```rust
+    /// # let x = 1;
     /// let y = &x; // use different variable name
     /// ```
     #[clippy::version = "pre 1.29.0"]
@@ -79,11 +81,14 @@ declare_clippy_lint! {
     /// # let y = 1;
     /// # let z = 2;
     /// let x = y;
-    ///
-    /// // Bad
     /// let x = z; // shadows the earlier binding
+    /// ```
     ///
-    /// // Good
+    /// Use instead:
+    /// ```rust
+    /// # let y = 1;
+    /// # let z = 2;
+    /// let x = y;
     /// let w = z; // use different variable name
     /// ```
     #[clippy::version = "pre 1.29.0"]
diff --git a/clippy_lints/src/slow_vector_initialization.rs b/clippy_lints/src/slow_vector_initialization.rs
index b4ad5dcbe3e..975a0a06e38 100644
--- a/clippy_lints/src/slow_vector_initialization.rs
+++ b/clippy_lints/src/slow_vector_initialization.rs
@@ -23,15 +23,16 @@ declare_clippy_lint! {
     /// ```rust
     /// # use core::iter::repeat;
     /// # let len = 4;
-    ///
-    /// // Bad
     /// let mut vec1 = Vec::with_capacity(len);
     /// vec1.resize(len, 0);
     ///
     /// let mut vec2 = Vec::with_capacity(len);
     /// vec2.extend(repeat(0).take(len));
+    /// ```
     ///
-    /// // Good
+    /// Use instead:
+    /// ```rust
+    /// # let len = 4;
     /// let mut vec1 = vec![0; len];
     /// let mut vec2 = vec![0; len];
     /// ```
diff --git a/clippy_lints/src/strings.rs b/clippy_lints/src/strings.rs
index 7c196ccaa8c..9ea2de001e2 100644
--- a/clippy_lints/src/strings.rs
+++ b/clippy_lints/src/strings.rs
@@ -99,11 +99,12 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust
-    /// // Bad
-    /// let bs = "a byte string".as_bytes();
+    /// let bstr = "a byte string".as_bytes();
+    /// ```
     ///
-    /// // Good
-    /// let bs = b"a byte string";
+    /// Use instead:
+    /// ```rust
+    /// let bstr = b"a byte string";
     /// ```
     #[clippy::version = "pre 1.29.0"]
     pub STRING_LIT_AS_BYTES,
@@ -223,11 +224,14 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust
-    /// let _ = std::str::from_utf8(&"Hello World!".as_bytes()[6..11]).unwrap();
+    /// # let _ =
+    /// std::str::from_utf8(&"Hello World!".as_bytes()[6..11]).unwrap();
     /// ```
-    /// could be written as
+    ///
+    /// Use instead:
     /// ```rust
-    /// let _ = &"Hello World!"[6..11];
+    /// # let _ =
+    /// &"Hello World!"[6..11];
     /// ```
     #[clippy::version = "1.50.0"]
     pub STRING_FROM_UTF8_AS_BYTES,
diff --git a/clippy_lints/src/trait_bounds.rs b/clippy_lints/src/trait_bounds.rs
index b91be0eb4be..71957572f2e 100644
--- a/clippy_lints/src/trait_bounds.rs
+++ b/clippy_lints/src/trait_bounds.rs
@@ -29,8 +29,7 @@ declare_clippy_lint! {
     /// pub fn foo<T>(t: T) where T: Copy, T: Clone {}
     /// ```
     ///
-    /// Could be written as:
-    ///
+    /// Use instead:
     /// ```rust
     /// pub fn foo<T>(t: T) where T: Copy + Clone {}
     /// ```
diff --git a/clippy_lints/src/unicode.rs b/clippy_lints/src/unicode.rs
index afd7be89a4e..cc64d17be05 100644
--- a/clippy_lints/src/unicode.rs
+++ b/clippy_lints/src/unicode.rs
@@ -41,7 +41,8 @@ declare_clippy_lint! {
     /// ```rust
     /// let x = String::from("€");
     /// ```
-    /// Could be written as:
+    ///
+    /// Use instead:
     /// ```rust
     /// let x = String::from("\u{20ac}");
     /// ```
diff --git a/clippy_lints/src/unused_async.rs b/clippy_lints/src/unused_async.rs
index 41333bb2add..c8ec4442ab1 100644
--- a/clippy_lints/src/unused_async.rs
+++ b/clippy_lints/src/unused_async.rs
@@ -17,13 +17,14 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust
-    /// // Bad
     /// async fn get_random_number() -> i64 {
     ///     4 // Chosen by fair dice roll. Guaranteed to be random.
     /// }
     /// let number_future = get_random_number();
+    /// ```
     ///
-    /// // Good
+    /// Use instead:
+    /// ```rust
     /// fn get_random_number_improved() -> i64 {
     ///     4 // Chosen by fair dice roll. Guaranteed to be random.
     /// }
diff --git a/clippy_lints/src/useless_conversion.rs b/clippy_lints/src/useless_conversion.rs
index 4a3b5383c89..fe29bf29d0c 100644
--- a/clippy_lints/src/useless_conversion.rs
+++ b/clippy_lints/src/useless_conversion.rs
@@ -21,11 +21,12 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust
-    /// // Bad
     /// // format!() returns a `String`
     /// let s: String = format!("hello").into();
+    /// ```
     ///
-    /// // Good
+    /// Use instead:
+    /// ```rust
     /// let s: String = format!("hello");
     /// ```
     #[clippy::version = "1.45.0"]
diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs
index 60f98876994..17323e4d0ef 100644
--- a/clippy_lints/src/utils/internal_lints.rs
+++ b/clippy_lints/src/utils/internal_lints.rs
@@ -89,12 +89,11 @@ declare_clippy_lint! {
     /// warning/error messages.
     ///
     /// ### Example
-    /// Bad:
     /// ```rust,ignore
     /// cx.span_lint(LINT_NAME, "message");
     /// ```
     ///
-    /// Good:
+    /// Use instead:
     /// ```rust,ignore
     /// utils::span_lint(cx, LINT_NAME, "message");
     /// ```
@@ -112,12 +111,11 @@ declare_clippy_lint! {
     /// `cx.outer_expn_data()` is faster and more concise.
     ///
     /// ### Example
-    /// Bad:
     /// ```rust,ignore
     /// expr.span.ctxt().outer().expn_data()
     /// ```
     ///
-    /// Good:
+    /// Use instead:
     /// ```rust,ignore
     /// expr.span.ctxt().outer_expn_data()
     /// ```
@@ -135,7 +133,6 @@ declare_clippy_lint! {
     /// ICE in large quantities can damage your teeth
     ///
     /// ### Example
-    /// Bad:
     /// ```rust,ignore
     /// 🍦🍦🍦🍦🍦
     /// ```
@@ -153,12 +150,11 @@ declare_clippy_lint! {
     /// Indicates that the lint is not finished.
     ///
     /// ### Example
-    /// Bad:
     /// ```rust,ignore
     /// declare_lint! { pub COOL_LINT, nursery, "default lint description" }
     /// ```
     ///
-    /// Good:
+    /// Use instead:
     /// ```rust,ignore
     /// declare_lint! { pub COOL_LINT, nursery, "a great new lint" }
     /// ```
@@ -183,7 +179,6 @@ declare_clippy_lint! {
     /// convenient, readable and less error prone.
     ///
     /// ### Example
-    /// Bad:
     /// ```rust,ignore
     /// span_lint_and_then(cx, TEST_LINT, expr.span, lint_msg, |diag| {
     ///     diag.span_suggestion(
@@ -207,7 +202,7 @@ declare_clippy_lint! {
     /// });
     /// ```
     ///
-    /// Good:
+    /// Use instead:
     /// ```rust,ignore
     /// span_lint_and_sugg(
     ///     cx,
@@ -237,12 +232,11 @@ declare_clippy_lint! {
     /// `utils::is_type_diagnostic_item()` does not require hardcoded paths.
     ///
     /// ### Example
-    /// Bad:
     /// ```rust,ignore
     /// utils::match_type(cx, ty, &paths::VEC)
     /// ```
     ///
-    /// Good:
+    /// Use instead:
     /// ```rust,ignore
     /// utils::is_type_diagnostic_item(cx, ty, sym::Vec)
     /// ```
@@ -273,12 +267,11 @@ declare_clippy_lint! {
     /// It's faster and easier to use the symbol constant.
     ///
     /// ### Example
-    /// Bad:
     /// ```rust,ignore
     /// let _ = sym!(f32);
     /// ```
     ///
-    /// Good:
+    /// Use instead:
     /// ```rust,ignore
     /// let _ = sym::f32;
     /// ```
@@ -295,12 +288,11 @@ declare_clippy_lint! {
     /// It's faster use symbols directly instead of strings.
     ///
     /// ### Example
-    /// Bad:
     /// ```rust,ignore
     /// symbol.as_str() == "clippy";
     /// ```
     ///
-    /// Good:
+    /// Use instead:
     /// ```rust,ignore
     /// symbol == sym::clippy;
     /// ```
diff --git a/clippy_lints/src/vec.rs b/clippy_lints/src/vec.rs
index ba1ff65479d..297a80e5767 100644
--- a/clippy_lints/src/vec.rs
+++ b/clippy_lints/src/vec.rs
@@ -28,12 +28,14 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust
-    /// # fn foo(my_vec: &[u8]) {}
+    /// fn foo(_x: &[u8]) {}
     ///
-    /// // Bad
     /// foo(&vec![1, 2]);
+    /// ```
     ///
-    /// // Good
+    /// Use instead:
+    /// ```rust
+    /// # fn foo(_x: &[u8]) {}
     /// foo(&[1, 2]);
     /// ```
     #[clippy::version = "pre 1.29.0"]
diff --git a/clippy_lints/src/wildcard_imports.rs b/clippy_lints/src/wildcard_imports.rs
index 2f74eaf3cf5..5418eca382d 100644
--- a/clippy_lints/src/wildcard_imports.rs
+++ b/clippy_lints/src/wildcard_imports.rs
@@ -26,13 +26,18 @@ declare_clippy_lint! {
     /// still around.
     ///
     /// ### Example
-    /// ```rust,ignore
-    /// // Bad
+    /// ```rust
     /// use std::cmp::Ordering::*;
+    ///
+    /// # fn foo(_: std::cmp::Ordering) {}
     /// foo(Less);
+    /// ```
     ///
-    /// // Good
+    /// Use instead:
+    /// ```rust
     /// use std::cmp::Ordering;
+    ///
+    /// # fn foo(_: Ordering) {}
     /// foo(Ordering::Less)
     /// ```
     #[clippy::version = "pre 1.29.0"]
@@ -76,14 +81,13 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust,ignore
-    /// // Bad
     /// use crate1::*;
     ///
     /// foo();
     /// ```
     ///
+    /// Use instead:
     /// ```rust,ignore
-    /// // Good
     /// use crate1::foo;
     ///
     /// foo();
diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs
index d2493c055a5..bb74f2a7f0f 100644
--- a/clippy_lints/src/write.rs
+++ b/clippy_lints/src/write.rs
@@ -25,10 +25,11 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust
-    /// // Bad
     /// println!("");
+    /// ```
     ///
-    /// // Good
+    /// Use instead:
+    /// ```rust
     /// println!();
     /// ```
     #[clippy::version = "pre 1.29.0"]
@@ -177,10 +178,15 @@ declare_clippy_lint! {
     /// ```rust
     /// # use std::fmt::Write;
     /// # let mut buf = String::new();
-    /// // Bad
+    /// # let _ =
     /// writeln!(buf, "");
+    /// ```
     ///
-    /// // Good
+    /// Use instead:
+    /// ```rust
+    /// # use std::fmt::Write;
+    /// # let mut buf = String::new();
+    /// # let _ =
     /// writeln!(buf);
     /// ```
     #[clippy::version = "pre 1.29.0"]
@@ -204,10 +210,16 @@ declare_clippy_lint! {
     /// # use std::fmt::Write;
     /// # let mut buf = String::new();
     /// # let name = "World";
-    /// // Bad
+    /// # let _ =
     /// write!(buf, "Hello {}!\n", name);
+    /// ```
     ///
-    /// // Good
+    /// Use instead:
+    /// ```rust
+    /// # use std::fmt::Write;
+    /// # let mut buf = String::new();
+    /// # let name = "World";
+    /// # let _ =
     /// writeln!(buf, "Hello {}!", name);
     /// ```
     #[clippy::version = "pre 1.29.0"]
@@ -233,10 +245,15 @@ declare_clippy_lint! {
     /// ```rust
     /// # use std::fmt::Write;
     /// # let mut buf = String::new();
-    /// // Bad
+    /// # let _ =
     /// writeln!(buf, "{}", "foo");
+    /// ```
     ///
-    /// // Good
+    /// Use instead:
+    /// ```rust
+    /// # use std::fmt::Write;
+    /// # let mut buf = String::new();
+    /// # let _ =
     /// writeln!(buf, "foo");
     /// ```
     #[clippy::version = "pre 1.29.0"]
diff --git a/clippy_lints/src/zero_div_zero.rs b/clippy_lints/src/zero_div_zero.rs
index 641681185a2..50d3c079fe6 100644
--- a/clippy_lints/src/zero_div_zero.rs
+++ b/clippy_lints/src/zero_div_zero.rs
@@ -14,10 +14,11 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust
-    /// // Bad
     /// let nan = 0.0f32 / 0.0;
+    /// ```
     ///
-    /// // Good
+    /// Use instead:
+    /// ```rust
     /// let nan = f32::NAN;
     /// ```
     #[clippy::version = "pre 1.29.0"]
-- 
cgit 1.4.1-3-g733a5


From 0902f3ca8192a352ab4db24bf4e04bc083792a3c Mon Sep 17 00:00:00 2001
From: Serial <69764315+Serial-ATA@users.noreply.github.com>
Date: Sun, 5 Jun 2022 16:06:47 -0400
Subject: Make [`create_dir`] example ignored

---
 clippy_lints/src/create_dir.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/create_dir.rs b/clippy_lints/src/create_dir.rs
index 6bc4054a5ab..18d34370a7b 100644
--- a/clippy_lints/src/create_dir.rs
+++ b/clippy_lints/src/create_dir.rs
@@ -15,12 +15,12 @@ declare_clippy_lint! {
     /// Sometimes `std::fs::create_dir` is mistakenly chosen over `std::fs::create_dir_all`.
     ///
     /// ### Example
-    ///
-    /// ```rust
+    /// ```rust,ignore
     /// std::fs::create_dir("foo");
     /// ```
+    ///
     /// Use instead:
-    /// ```rust
+    /// ```rust,ignore
     /// std::fs::create_dir_all("foo");
     /// ```
     #[clippy::version = "1.48.0"]
-- 
cgit 1.4.1-3-g733a5


From ba43f0aee9c32bad8a3d9fabfd0f442122403aaf Mon Sep 17 00:00:00 2001
From: Dennis Luxen <info@project-osrm.org>
Date: Fri, 3 Jun 2022 16:12:26 +0200
Subject: Add new lint [`needless_braces_on_range_literal`]

---
 CHANGELOG.md                                       |  1 +
 clippy_lints/src/lib.register_all.rs               |  1 +
 clippy_lints/src/lib.register_lints.rs             |  1 +
 clippy_lints/src/lib.register_style.rs             |  1 +
 clippy_lints/src/lib.rs                            |  2 +
 .../src/needless_braces_on_range_literal.rs        | 67 ++++++++++++++++++++++
 tests/ui/almost_complete_letter_range.fixed        |  1 +
 tests/ui/almost_complete_letter_range.rs           |  1 +
 tests/ui/almost_complete_letter_range.stderr       | 24 ++++----
 tests/ui/needless_braces_on_range_literal.fixed    |  9 +++
 tests/ui/needless_braces_on_range_literal.rs       |  9 +++
 tests/ui/needless_braces_on_range_literal.stderr   | 16 ++++++
 12 files changed, 121 insertions(+), 12 deletions(-)
 create mode 100644 clippy_lints/src/needless_braces_on_range_literal.rs
 create mode 100644 tests/ui/needless_braces_on_range_literal.fixed
 create mode 100644 tests/ui/needless_braces_on_range_literal.rs
 create mode 100644 tests/ui/needless_braces_on_range_literal.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 6ef338b819d..ce5fa64c0d1 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3596,6 +3596,7 @@ Released 2018-09-13
 [`needless_bool`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_bool
 [`needless_borrow`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow
 [`needless_borrowed_reference`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrowed_reference
+[`needless_braces_on_range_literal`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_braces_on_range_literal
 [`needless_collect`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_collect
 [`needless_continue`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_continue
 [`needless_doctest_main`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_doctest_main
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index d4ec046d0bb..68c6a33403b 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -241,6 +241,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(needless_bool::BOOL_COMPARISON),
     LintId::of(needless_bool::NEEDLESS_BOOL),
     LintId::of(needless_borrowed_ref::NEEDLESS_BORROWED_REFERENCE),
+    LintId::of(needless_braces_on_range_literal::NEEDLESS_BRACES_ON_RANGE_LITERAL),
     LintId::of(needless_late_init::NEEDLESS_LATE_INIT),
     LintId::of(needless_question_mark::NEEDLESS_QUESTION_MARK),
     LintId::of(needless_update::NEEDLESS_UPDATE),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index b927ba3b17c..01d7d404cf6 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -405,6 +405,7 @@ store.register_lints(&[
     needless_bool::BOOL_COMPARISON,
     needless_bool::NEEDLESS_BOOL,
     needless_borrowed_ref::NEEDLESS_BORROWED_REFERENCE,
+    needless_braces_on_range_literal::NEEDLESS_BRACES_ON_RANGE_LITERAL,
     needless_continue::NEEDLESS_CONTINUE,
     needless_for_each::NEEDLESS_FOR_EACH,
     needless_late_init::NEEDLESS_LATE_INIT,
diff --git a/clippy_lints/src/lib.register_style.rs b/clippy_lints/src/lib.register_style.rs
index 35575351784..f5d89e67fb6 100644
--- a/clippy_lints/src/lib.register_style.rs
+++ b/clippy_lints/src/lib.register_style.rs
@@ -90,6 +90,7 @@ store.register_group(true, "clippy::style", Some("clippy_style"), vec![
     LintId::of(misc_early::REDUNDANT_PATTERN),
     LintId::of(mut_mutex_lock::MUT_MUTEX_LOCK),
     LintId::of(mut_reference::UNNECESSARY_MUT_PASSED),
+    LintId::of(needless_braces_on_range_literal::NEEDLESS_BRACES_ON_RANGE_LITERAL),
     LintId::of(needless_late_init::NEEDLESS_LATE_INIT),
     LintId::of(neg_multiply::NEG_MULTIPLY),
     LintId::of(new_without_default::NEW_WITHOUT_DEFAULT),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index ee0416fc0ff..d43dbc06e8e 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -312,6 +312,7 @@ mod needless_arbitrary_self_type;
 mod needless_bitwise_bool;
 mod needless_bool;
 mod needless_borrowed_ref;
+mod needless_braces_on_range_literal;
 mod needless_continue;
 mod needless_for_each;
 mod needless_late_init;
@@ -746,6 +747,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_early_pass(|| Box::new(collapsible_if::CollapsibleIf));
     store.register_early_pass(|| Box::new(items_after_statements::ItemsAfterStatements));
     store.register_early_pass(|| Box::new(precedence::Precedence));
+    store.register_early_pass(|| Box::new(needless_braces_on_range_literal::NeedlessBracesOnRangeLiteral));
     store.register_early_pass(|| Box::new(needless_continue::NeedlessContinue));
     store.register_early_pass(|| Box::new(redundant_else::RedundantElse));
     store.register_late_pass(|| Box::new(create_dir::CreateDir));
diff --git a/clippy_lints/src/needless_braces_on_range_literal.rs b/clippy_lints/src/needless_braces_on_range_literal.rs
new file mode 100644
index 00000000000..031008c5092
--- /dev/null
+++ b/clippy_lints/src/needless_braces_on_range_literal.rs
@@ -0,0 +1,67 @@
+//! Checks for braces on literals in range statements
+//!
+//! For example, the lint would catch
+//!
+//! ```rust
+//! for i in (0)..10 {
+//!   println!("{i}");
+//! }
+//! ```
+//!
+//! And suggest this:
+//!
+//! ```rust
+//! for i in 0..10 {
+//!   println!("{i}");
+//! }
+//! ```
+//!
+//! This lint is **warn** by default.
+
+use clippy_utils::{diagnostics::span_lint_and_then, source::snippet_opt};
+use rustc_ast::ast::{Expr, ExprKind};
+use rustc_errors::Applicability;
+use rustc_lint::{EarlyContext, EarlyLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+  /// ### What it does
+  /// The lint checks for braces on literals in range statements that are
+  /// superflous.
+  ///
+  /// ### Why is this bad?
+  /// Having superflous braces makes the code less legible as the impose an
+  /// overhead when reading.
+
+  #[clippy::version = "1.63.0"]
+  pub NEEDLESS_BRACES_ON_RANGE_LITERAL,
+  style,
+  "needless braces on range literal can be removed"
+}
+
+declare_lint_pass!(NeedlessBracesOnRangeLiteral => [NEEDLESS_BRACES_ON_RANGE_LITERAL]);
+
+fn check_for_braces(cx: &EarlyContext<'_>, e: &Expr) {
+    if_chain! {
+      if let ExprKind::Paren(ref start_statement) = &e.kind;
+    if let ExprKind::Lit(ref literal) = start_statement.kind;
+    then {
+      span_lint_and_then(cx, NEEDLESS_BRACES_ON_RANGE_LITERAL, e.span,
+        "needless braces on range literal can be removed",
+        |diag| {
+                if let Some(suggestion) = snippet_opt(cx, literal.span) {
+                  diag.span_suggestion(e.span, "try", suggestion, Applicability::MachineApplicable);
+              }
+        });
+    }
+    }
+}
+
+impl EarlyLintPass for NeedlessBracesOnRangeLiteral {
+    fn check_expr(&mut self, cx: &EarlyContext<'_>, e: &Expr) {
+        if let ExprKind::Range(Some(start), Some(end), _) = &e.kind {
+            check_for_braces(cx, start);
+            check_for_braces(cx, end);
+        }
+    }
+}
diff --git a/tests/ui/almost_complete_letter_range.fixed b/tests/ui/almost_complete_letter_range.fixed
index 39f8f0c2949..d2d1bdb969d 100644
--- a/tests/ui/almost_complete_letter_range.fixed
+++ b/tests/ui/almost_complete_letter_range.fixed
@@ -6,6 +6,7 @@
 #![feature(stmt_expr_attributes)]
 #![warn(clippy::almost_complete_letter_range)]
 #![allow(ellipsis_inclusive_range_patterns)]
+#![allow(clippy::needless_braces_on_range_literal)]
 
 macro_rules! a {
     () => {
diff --git a/tests/ui/almost_complete_letter_range.rs b/tests/ui/almost_complete_letter_range.rs
index 3dc02199257..28965df0805 100644
--- a/tests/ui/almost_complete_letter_range.rs
+++ b/tests/ui/almost_complete_letter_range.rs
@@ -6,6 +6,7 @@
 #![feature(stmt_expr_attributes)]
 #![warn(clippy::almost_complete_letter_range)]
 #![allow(ellipsis_inclusive_range_patterns)]
+#![allow(clippy::needless_braces_on_range_literal)]
 
 macro_rules! a {
     () => {
diff --git a/tests/ui/almost_complete_letter_range.stderr b/tests/ui/almost_complete_letter_range.stderr
index 74980ec1a92..5b5dc40ee54 100644
--- a/tests/ui/almost_complete_letter_range.stderr
+++ b/tests/ui/almost_complete_letter_range.stderr
@@ -1,5 +1,5 @@
 error: almost complete ascii letter range
-  --> $DIR/almost_complete_letter_range.rs:19:17
+  --> $DIR/almost_complete_letter_range.rs:20:17
    |
 LL |         let _ = ('a') ..'z';
    |                 ^^^^^^--^^^
@@ -9,7 +9,7 @@ LL |         let _ = ('a') ..'z';
    = note: `-D clippy::almost-complete-letter-range` implied by `-D warnings`
 
 error: almost complete ascii letter range
-  --> $DIR/almost_complete_letter_range.rs:20:17
+  --> $DIR/almost_complete_letter_range.rs:21:17
    |
 LL |         let _ = 'A' .. ('Z');
    |                 ^^^^--^^^^^^
@@ -17,7 +17,7 @@ LL |         let _ = 'A' .. ('Z');
    |                     help: use an inclusive range: `..=`
 
 error: almost complete ascii letter range
-  --> $DIR/almost_complete_letter_range.rs:26:13
+  --> $DIR/almost_complete_letter_range.rs:27:13
    |
 LL |     let _ = (b'a')..(b'z');
    |             ^^^^^^--^^^^^^
@@ -25,7 +25,7 @@ LL |     let _ = (b'a')..(b'z');
    |                   help: use an inclusive range: `..=`
 
 error: almost complete ascii letter range
-  --> $DIR/almost_complete_letter_range.rs:27:13
+  --> $DIR/almost_complete_letter_range.rs:28:13
    |
 LL |     let _ = b'A'..b'Z';
    |             ^^^^--^^^^
@@ -33,7 +33,7 @@ LL |     let _ = b'A'..b'Z';
    |                 help: use an inclusive range: `..=`
 
 error: almost complete ascii letter range
-  --> $DIR/almost_complete_letter_range.rs:32:13
+  --> $DIR/almost_complete_letter_range.rs:33:13
    |
 LL |     let _ = a!()..'z';
    |             ^^^^--^^^
@@ -41,7 +41,7 @@ LL |     let _ = a!()..'z';
    |                 help: use an inclusive range: `..=`
 
 error: almost complete ascii letter range
-  --> $DIR/almost_complete_letter_range.rs:35:9
+  --> $DIR/almost_complete_letter_range.rs:36:9
    |
 LL |         b'a'..b'z' if true => 1,
    |         ^^^^--^^^^
@@ -49,7 +49,7 @@ LL |         b'a'..b'z' if true => 1,
    |             help: use an inclusive range: `..=`
 
 error: almost complete ascii letter range
-  --> $DIR/almost_complete_letter_range.rs:36:9
+  --> $DIR/almost_complete_letter_range.rs:37:9
    |
 LL |         b'A'..b'Z' if true => 2,
    |         ^^^^--^^^^
@@ -57,7 +57,7 @@ LL |         b'A'..b'Z' if true => 2,
    |             help: use an inclusive range: `..=`
 
 error: almost complete ascii letter range
-  --> $DIR/almost_complete_letter_range.rs:43:9
+  --> $DIR/almost_complete_letter_range.rs:44:9
    |
 LL |         'a'..'z' if true => 1,
    |         ^^^--^^^
@@ -65,7 +65,7 @@ LL |         'a'..'z' if true => 1,
    |            help: use an inclusive range: `..=`
 
 error: almost complete ascii letter range
-  --> $DIR/almost_complete_letter_range.rs:44:9
+  --> $DIR/almost_complete_letter_range.rs:45:9
    |
 LL |         'A'..'Z' if true => 2,
    |         ^^^--^^^
@@ -73,7 +73,7 @@ LL |         'A'..'Z' if true => 2,
    |            help: use an inclusive range: `..=`
 
 error: almost complete ascii letter range
-  --> $DIR/almost_complete_letter_range.rs:54:9
+  --> $DIR/almost_complete_letter_range.rs:55:9
    |
 LL |         'a'..'z' => 1,
    |         ^^^--^^^
@@ -81,7 +81,7 @@ LL |         'a'..'z' => 1,
    |            help: use an inclusive range: `...`
 
 error: almost complete ascii letter range
-  --> $DIR/almost_complete_letter_range.rs:61:13
+  --> $DIR/almost_complete_letter_range.rs:62:13
    |
 LL |     let _ = 'a'..'z';
    |             ^^^--^^^
@@ -89,7 +89,7 @@ LL |     let _ = 'a'..'z';
    |                help: use an inclusive range: `..=`
 
 error: almost complete ascii letter range
-  --> $DIR/almost_complete_letter_range.rs:63:9
+  --> $DIR/almost_complete_letter_range.rs:64:9
    |
 LL |         'a'..'z' => 1,
    |         ^^^--^^^
diff --git a/tests/ui/needless_braces_on_range_literal.fixed b/tests/ui/needless_braces_on_range_literal.fixed
new file mode 100644
index 00000000000..a6cf610005c
--- /dev/null
+++ b/tests/ui/needless_braces_on_range_literal.fixed
@@ -0,0 +1,9 @@
+// run-rustfix
+// edition:2018
+
+#![warn(clippy::needless_braces_on_range_literal)]
+#![allow(clippy::almost_complete_letter_range)]
+
+fn main() {
+    let _ = 'a'..='z';
+}
diff --git a/tests/ui/needless_braces_on_range_literal.rs b/tests/ui/needless_braces_on_range_literal.rs
new file mode 100644
index 00000000000..7c24a4eb494
--- /dev/null
+++ b/tests/ui/needless_braces_on_range_literal.rs
@@ -0,0 +1,9 @@
+// run-rustfix
+// edition:2018
+
+#![warn(clippy::needless_braces_on_range_literal)]
+#![allow(clippy::almost_complete_letter_range)]
+
+fn main() {
+    let _ = ('a')..=('z');
+}
diff --git a/tests/ui/needless_braces_on_range_literal.stderr b/tests/ui/needless_braces_on_range_literal.stderr
new file mode 100644
index 00000000000..581488d19fa
--- /dev/null
+++ b/tests/ui/needless_braces_on_range_literal.stderr
@@ -0,0 +1,16 @@
+error: needless braces on range literal can be removed
+  --> $DIR/needless_braces_on_range_literal.rs:8:13
+   |
+LL |     let _ = ('a')..=('z');
+   |             ^^^^^ help: try: `'a'`
+   |
+   = note: `-D clippy::needless-braces-on-range-literal` implied by `-D warnings`
+
+error: needless braces on range literal can be removed
+  --> $DIR/needless_braces_on_range_literal.rs:8:21
+   |
+LL |     let _ = ('a')..=('z');
+   |                     ^^^^^ help: try: `'z'`
+
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 3058cb941cd8d81c01b74e4b28b4f4ca606fb20b Mon Sep 17 00:00:00 2001
From: Dennis Luxen <ich@dennisluxen.de>
Date: Sat, 4 Jun 2022 19:12:32 +0200
Subject: Update clippy_lints/src/needless_braces_on_range_literal.rs

Co-authored-by: Alex <69764315+Serial-ATA@users.noreply.github.com>
---
 clippy_lints/src/needless_braces_on_range_literal.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/needless_braces_on_range_literal.rs b/clippy_lints/src/needless_braces_on_range_literal.rs
index 031008c5092..b351dfe2005 100644
--- a/clippy_lints/src/needless_braces_on_range_literal.rs
+++ b/clippy_lints/src/needless_braces_on_range_literal.rs
@@ -8,7 +8,7 @@
 //! }
 //! ```
 //!
-//! And suggest this:
+//! Use instead:
 //!
 //! ```rust
 //! for i in 0..10 {
-- 
cgit 1.4.1-3-g733a5


From 8bc1be17d633ea5c41d0c8abe24a4a3c6a150740 Mon Sep 17 00:00:00 2001
From: Dennis Luxen <ich@dennisluxen.de>
Date: Sat, 4 Jun 2022 21:45:19 +0200
Subject: Update clippy_lints/src/needless_braces_on_range_literal.rs

Co-authored-by: Alex <69764315+Serial-ATA@users.noreply.github.com>
---
 clippy_lints/src/needless_braces_on_range_literal.rs | 1 -
 1 file changed, 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/needless_braces_on_range_literal.rs b/clippy_lints/src/needless_braces_on_range_literal.rs
index b351dfe2005..c96f50122f6 100644
--- a/clippy_lints/src/needless_braces_on_range_literal.rs
+++ b/clippy_lints/src/needless_braces_on_range_literal.rs
@@ -16,7 +16,6 @@
 //! }
 //! ```
 //!
-//! This lint is **warn** by default.
 
 use clippy_utils::{diagnostics::span_lint_and_then, source::snippet_opt};
 use rustc_ast::ast::{Expr, ExprKind};
-- 
cgit 1.4.1-3-g733a5


From 5948959c7e050a403618b134ec831f6ef1265ddd Mon Sep 17 00:00:00 2001
From: Dennis Luxen <info@project-osrm.org>
Date: Sat, 4 Jun 2022 19:37:28 +0200
Subject: Fix misnomer braces -> parenthesis

---
 CHANGELOG.md                                       |  2 +-
 clippy_lints/src/lib.register_all.rs               |  2 +-
 clippy_lints/src/lib.register_lints.rs             |  2 +-
 clippy_lints/src/lib.register_style.rs             |  2 +-
 clippy_lints/src/lib.rs                            |  4 +-
 .../src/needless_braces_on_range_literal.rs        | 66 ----------------------
 .../src/needless_parens_on_range_literal.rs        | 66 ++++++++++++++++++++++
 tests/ui/almost_complete_letter_range.fixed        |  2 +-
 tests/ui/almost_complete_letter_range.rs           |  2 +-
 tests/ui/needless_braces_on_range_literal.fixed    |  9 ---
 tests/ui/needless_braces_on_range_literal.rs       |  9 ---
 tests/ui/needless_braces_on_range_literal.stderr   | 16 ------
 tests/ui/needless_parens_on_range_literal.fixed    |  9 +++
 tests/ui/needless_parens_on_range_literal.rs       |  9 +++
 tests/ui/needless_parens_on_range_literal.stderr   | 16 ++++++
 15 files changed, 108 insertions(+), 108 deletions(-)
 delete mode 100644 clippy_lints/src/needless_braces_on_range_literal.rs
 create mode 100644 clippy_lints/src/needless_parens_on_range_literal.rs
 delete mode 100644 tests/ui/needless_braces_on_range_literal.fixed
 delete mode 100644 tests/ui/needless_braces_on_range_literal.rs
 delete mode 100644 tests/ui/needless_braces_on_range_literal.stderr
 create mode 100644 tests/ui/needless_parens_on_range_literal.fixed
 create mode 100644 tests/ui/needless_parens_on_range_literal.rs
 create mode 100644 tests/ui/needless_parens_on_range_literal.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index ce5fa64c0d1..d3db4be03f1 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3596,7 +3596,7 @@ Released 2018-09-13
 [`needless_bool`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_bool
 [`needless_borrow`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow
 [`needless_borrowed_reference`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrowed_reference
-[`needless_braces_on_range_literal`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_braces_on_range_literal
+[`needless_parens_on_range_literal`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_parens_on_range_literal
 [`needless_collect`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_collect
 [`needless_continue`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_continue
 [`needless_doctest_main`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_doctest_main
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 68c6a33403b..69f6496818c 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -241,7 +241,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(needless_bool::BOOL_COMPARISON),
     LintId::of(needless_bool::NEEDLESS_BOOL),
     LintId::of(needless_borrowed_ref::NEEDLESS_BORROWED_REFERENCE),
-    LintId::of(needless_braces_on_range_literal::NEEDLESS_BRACES_ON_RANGE_LITERAL),
+    LintId::of(needless_parens_on_range_literal::NEEDLESS_PARENS_ON_RANGE_LITERAL),
     LintId::of(needless_late_init::NEEDLESS_LATE_INIT),
     LintId::of(needless_question_mark::NEEDLESS_QUESTION_MARK),
     LintId::of(needless_update::NEEDLESS_UPDATE),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 01d7d404cf6..1dc65dabf84 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -405,7 +405,7 @@ store.register_lints(&[
     needless_bool::BOOL_COMPARISON,
     needless_bool::NEEDLESS_BOOL,
     needless_borrowed_ref::NEEDLESS_BORROWED_REFERENCE,
-    needless_braces_on_range_literal::NEEDLESS_BRACES_ON_RANGE_LITERAL,
+    needless_parens_on_range_literal::NEEDLESS_PARENS_ON_RANGE_LITERAL,
     needless_continue::NEEDLESS_CONTINUE,
     needless_for_each::NEEDLESS_FOR_EACH,
     needless_late_init::NEEDLESS_LATE_INIT,
diff --git a/clippy_lints/src/lib.register_style.rs b/clippy_lints/src/lib.register_style.rs
index f5d89e67fb6..4518384bd87 100644
--- a/clippy_lints/src/lib.register_style.rs
+++ b/clippy_lints/src/lib.register_style.rs
@@ -90,7 +90,7 @@ store.register_group(true, "clippy::style", Some("clippy_style"), vec![
     LintId::of(misc_early::REDUNDANT_PATTERN),
     LintId::of(mut_mutex_lock::MUT_MUTEX_LOCK),
     LintId::of(mut_reference::UNNECESSARY_MUT_PASSED),
-    LintId::of(needless_braces_on_range_literal::NEEDLESS_BRACES_ON_RANGE_LITERAL),
+    LintId::of(needless_parens_on_range_literal::NEEDLESS_PARENS_ON_RANGE_LITERAL),
     LintId::of(needless_late_init::NEEDLESS_LATE_INIT),
     LintId::of(neg_multiply::NEG_MULTIPLY),
     LintId::of(new_without_default::NEW_WITHOUT_DEFAULT),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index d43dbc06e8e..f9743056129 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -312,10 +312,10 @@ mod needless_arbitrary_self_type;
 mod needless_bitwise_bool;
 mod needless_bool;
 mod needless_borrowed_ref;
-mod needless_braces_on_range_literal;
 mod needless_continue;
 mod needless_for_each;
 mod needless_late_init;
+mod needless_parens_on_range_literal;
 mod needless_pass_by_value;
 mod needless_question_mark;
 mod needless_update;
@@ -747,7 +747,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_early_pass(|| Box::new(collapsible_if::CollapsibleIf));
     store.register_early_pass(|| Box::new(items_after_statements::ItemsAfterStatements));
     store.register_early_pass(|| Box::new(precedence::Precedence));
-    store.register_early_pass(|| Box::new(needless_braces_on_range_literal::NeedlessBracesOnRangeLiteral));
+    store.register_early_pass(|| Box::new(needless_parens_on_range_literal::NeedlessParensOnRangeLiteral));
     store.register_early_pass(|| Box::new(needless_continue::NeedlessContinue));
     store.register_early_pass(|| Box::new(redundant_else::RedundantElse));
     store.register_late_pass(|| Box::new(create_dir::CreateDir));
diff --git a/clippy_lints/src/needless_braces_on_range_literal.rs b/clippy_lints/src/needless_braces_on_range_literal.rs
deleted file mode 100644
index c96f50122f6..00000000000
--- a/clippy_lints/src/needless_braces_on_range_literal.rs
+++ /dev/null
@@ -1,66 +0,0 @@
-//! Checks for braces on literals in range statements
-//!
-//! For example, the lint would catch
-//!
-//! ```rust
-//! for i in (0)..10 {
-//!   println!("{i}");
-//! }
-//! ```
-//!
-//! Use instead:
-//!
-//! ```rust
-//! for i in 0..10 {
-//!   println!("{i}");
-//! }
-//! ```
-//!
-
-use clippy_utils::{diagnostics::span_lint_and_then, source::snippet_opt};
-use rustc_ast::ast::{Expr, ExprKind};
-use rustc_errors::Applicability;
-use rustc_lint::{EarlyContext, EarlyLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-
-declare_clippy_lint! {
-  /// ### What it does
-  /// The lint checks for braces on literals in range statements that are
-  /// superflous.
-  ///
-  /// ### Why is this bad?
-  /// Having superflous braces makes the code less legible as the impose an
-  /// overhead when reading.
-
-  #[clippy::version = "1.63.0"]
-  pub NEEDLESS_BRACES_ON_RANGE_LITERAL,
-  style,
-  "needless braces on range literal can be removed"
-}
-
-declare_lint_pass!(NeedlessBracesOnRangeLiteral => [NEEDLESS_BRACES_ON_RANGE_LITERAL]);
-
-fn check_for_braces(cx: &EarlyContext<'_>, e: &Expr) {
-    if_chain! {
-      if let ExprKind::Paren(ref start_statement) = &e.kind;
-    if let ExprKind::Lit(ref literal) = start_statement.kind;
-    then {
-      span_lint_and_then(cx, NEEDLESS_BRACES_ON_RANGE_LITERAL, e.span,
-        "needless braces on range literal can be removed",
-        |diag| {
-                if let Some(suggestion) = snippet_opt(cx, literal.span) {
-                  diag.span_suggestion(e.span, "try", suggestion, Applicability::MachineApplicable);
-              }
-        });
-    }
-    }
-}
-
-impl EarlyLintPass for NeedlessBracesOnRangeLiteral {
-    fn check_expr(&mut self, cx: &EarlyContext<'_>, e: &Expr) {
-        if let ExprKind::Range(Some(start), Some(end), _) = &e.kind {
-            check_for_braces(cx, start);
-            check_for_braces(cx, end);
-        }
-    }
-}
diff --git a/clippy_lints/src/needless_parens_on_range_literal.rs b/clippy_lints/src/needless_parens_on_range_literal.rs
new file mode 100644
index 00000000000..50a393311cd
--- /dev/null
+++ b/clippy_lints/src/needless_parens_on_range_literal.rs
@@ -0,0 +1,66 @@
+//! Checks for parantheses on literals in range statements
+//!
+//! For example, the lint would catch
+//!
+//! ```rust
+//! for i in (0)..10 {
+//!   println!("{i}");
+//! }
+//! ```
+//!
+//! Use instead:
+//!
+//! ```rust
+//! for i in 0..10 {
+//!   println!("{i}");
+//! }
+//! ```
+//!
+
+use clippy_utils::{diagnostics::span_lint_and_then, source::snippet_opt};
+use rustc_ast::ast::{Expr, ExprKind};
+use rustc_errors::Applicability;
+use rustc_lint::{EarlyContext, EarlyLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+  /// ### What it does
+  /// The lint checks for parenthesis on literals in range statements that are
+  /// superflous.
+  ///
+  /// ### Why is this bad?
+  /// Having superflous parenthesis makes the code less legible as the impose an
+  /// overhead when reading.
+
+  #[clippy::version = "1.63.0"]
+  pub NEEDLESS_PARENS_ON_RANGE_LITERAL,
+  style,
+  "needless parenthesis on range literal can be removed"
+}
+
+declare_lint_pass!(NeedlessParensOnRangeLiteral => [NEEDLESS_PARENS_ON_RANGE_LITERAL]);
+
+fn check_for_parens(cx: &EarlyContext<'_>, e: &Expr) {
+    if_chain! {
+      if let ExprKind::Paren(ref start_statement) = &e.kind;
+    if let ExprKind::Lit(ref literal) = start_statement.kind;
+    then {
+      span_lint_and_then(cx, NEEDLESS_PARENS_ON_RANGE_LITERAL, e.span,
+        "needless parenthesis on range literal can be removed",
+        |diag| {
+                if let Some(suggestion) = snippet_opt(cx, literal.span) {
+                  diag.span_suggestion(e.span, "try", suggestion, Applicability::MachineApplicable);
+              }
+        });
+    }
+    }
+}
+
+impl EarlyLintPass for NeedlessParensOnRangeLiteral {
+    fn check_expr(&mut self, cx: &EarlyContext<'_>, e: &Expr) {
+        if let ExprKind::Range(Some(start), Some(end), _) = &e.kind {
+            check_for_parens(cx, start);
+            check_for_parens(cx, end);
+        }
+    }
+}
diff --git a/tests/ui/almost_complete_letter_range.fixed b/tests/ui/almost_complete_letter_range.fixed
index d2d1bdb969d..83a6bf14c3f 100644
--- a/tests/ui/almost_complete_letter_range.fixed
+++ b/tests/ui/almost_complete_letter_range.fixed
@@ -6,7 +6,7 @@
 #![feature(stmt_expr_attributes)]
 #![warn(clippy::almost_complete_letter_range)]
 #![allow(ellipsis_inclusive_range_patterns)]
-#![allow(clippy::needless_braces_on_range_literal)]
+#![allow(clippy::needless_parens_on_range_literal)]
 
 macro_rules! a {
     () => {
diff --git a/tests/ui/almost_complete_letter_range.rs b/tests/ui/almost_complete_letter_range.rs
index 28965df0805..a8da9266ad7 100644
--- a/tests/ui/almost_complete_letter_range.rs
+++ b/tests/ui/almost_complete_letter_range.rs
@@ -6,7 +6,7 @@
 #![feature(stmt_expr_attributes)]
 #![warn(clippy::almost_complete_letter_range)]
 #![allow(ellipsis_inclusive_range_patterns)]
-#![allow(clippy::needless_braces_on_range_literal)]
+#![allow(clippy::needless_parens_on_range_literal)]
 
 macro_rules! a {
     () => {
diff --git a/tests/ui/needless_braces_on_range_literal.fixed b/tests/ui/needless_braces_on_range_literal.fixed
deleted file mode 100644
index a6cf610005c..00000000000
--- a/tests/ui/needless_braces_on_range_literal.fixed
+++ /dev/null
@@ -1,9 +0,0 @@
-// run-rustfix
-// edition:2018
-
-#![warn(clippy::needless_braces_on_range_literal)]
-#![allow(clippy::almost_complete_letter_range)]
-
-fn main() {
-    let _ = 'a'..='z';
-}
diff --git a/tests/ui/needless_braces_on_range_literal.rs b/tests/ui/needless_braces_on_range_literal.rs
deleted file mode 100644
index 7c24a4eb494..00000000000
--- a/tests/ui/needless_braces_on_range_literal.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-// run-rustfix
-// edition:2018
-
-#![warn(clippy::needless_braces_on_range_literal)]
-#![allow(clippy::almost_complete_letter_range)]
-
-fn main() {
-    let _ = ('a')..=('z');
-}
diff --git a/tests/ui/needless_braces_on_range_literal.stderr b/tests/ui/needless_braces_on_range_literal.stderr
deleted file mode 100644
index 581488d19fa..00000000000
--- a/tests/ui/needless_braces_on_range_literal.stderr
+++ /dev/null
@@ -1,16 +0,0 @@
-error: needless braces on range literal can be removed
-  --> $DIR/needless_braces_on_range_literal.rs:8:13
-   |
-LL |     let _ = ('a')..=('z');
-   |             ^^^^^ help: try: `'a'`
-   |
-   = note: `-D clippy::needless-braces-on-range-literal` implied by `-D warnings`
-
-error: needless braces on range literal can be removed
-  --> $DIR/needless_braces_on_range_literal.rs:8:21
-   |
-LL |     let _ = ('a')..=('z');
-   |                     ^^^^^ help: try: `'z'`
-
-error: aborting due to 2 previous errors
-
diff --git a/tests/ui/needless_parens_on_range_literal.fixed b/tests/ui/needless_parens_on_range_literal.fixed
new file mode 100644
index 00000000000..ba903fd688d
--- /dev/null
+++ b/tests/ui/needless_parens_on_range_literal.fixed
@@ -0,0 +1,9 @@
+// run-rustfix
+// edition:2018
+
+#![warn(clippy::needless_parens_on_range_literal)]
+#![allow(clippy::almost_complete_letter_range)]
+
+fn main() {
+    let _ = 'a'..='z';
+}
diff --git a/tests/ui/needless_parens_on_range_literal.rs b/tests/ui/needless_parens_on_range_literal.rs
new file mode 100644
index 00000000000..7fddd6bf782
--- /dev/null
+++ b/tests/ui/needless_parens_on_range_literal.rs
@@ -0,0 +1,9 @@
+// run-rustfix
+// edition:2018
+
+#![warn(clippy::needless_parens_on_range_literal)]
+#![allow(clippy::almost_complete_letter_range)]
+
+fn main() {
+    let _ = ('a')..=('z');
+}
diff --git a/tests/ui/needless_parens_on_range_literal.stderr b/tests/ui/needless_parens_on_range_literal.stderr
new file mode 100644
index 00000000000..f9655e8948d
--- /dev/null
+++ b/tests/ui/needless_parens_on_range_literal.stderr
@@ -0,0 +1,16 @@
+error: needless parenthesis on range literal can be removed
+  --> $DIR/needless_parens_on_range_literal.rs:8:13
+   |
+LL |     let _ = ('a')..=('z');
+   |             ^^^^^ help: try: `'a'`
+   |
+   = note: `-D clippy::needless-parens-on-range-literal` implied by `-D warnings`
+
+error: needless parenthesis on range literal can be removed
+  --> $DIR/needless_parens_on_range_literal.rs:8:21
+   |
+LL |     let _ = ('a')..=('z');
+   |                     ^^^^^ help: try: `'z'`
+
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 90c8463d7e213b8d15274db1fa9c413938b5ae02 Mon Sep 17 00:00:00 2001
From: Dennis Luxen <info@project-osrm.org>
Date: Sat, 4 Jun 2022 21:44:37 +0200
Subject: Rewrite check to account for floating point literals

---
 clippy_lints/src/lib.rs                            |  2 +-
 .../src/needless_parens_on_range_literal.rs        | 67 +++++++++++++++-------
 tests/ui/needless_parens_on_range_literal.fixed    |  3 +
 tests/ui/needless_parens_on_range_literal.rs       |  3 +
 tests/ui/needless_parens_on_range_literal.stderr   |  8 ++-
 5 files changed, 61 insertions(+), 22 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index f9743056129..19e1247d642 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -747,7 +747,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_early_pass(|| Box::new(collapsible_if::CollapsibleIf));
     store.register_early_pass(|| Box::new(items_after_statements::ItemsAfterStatements));
     store.register_early_pass(|| Box::new(precedence::Precedence));
-    store.register_early_pass(|| Box::new(needless_parens_on_range_literal::NeedlessParensOnRangeLiteral));
+    store.register_late_pass(|| Box::new(needless_parens_on_range_literal::NeedlessParensOnRangeLiteral));
     store.register_early_pass(|| Box::new(needless_continue::NeedlessContinue));
     store.register_early_pass(|| Box::new(redundant_else::RedundantElse));
     store.register_late_pass(|| Box::new(create_dir::CreateDir));
diff --git a/clippy_lints/src/needless_parens_on_range_literal.rs b/clippy_lints/src/needless_parens_on_range_literal.rs
index 50a393311cd..81c7f712770 100644
--- a/clippy_lints/src/needless_parens_on_range_literal.rs
+++ b/clippy_lints/src/needless_parens_on_range_literal.rs
@@ -17,10 +17,17 @@
 //! ```
 //!
 
-use clippy_utils::{diagnostics::span_lint_and_then, source::snippet_opt};
-use rustc_ast::ast::{Expr, ExprKind};
+use clippy_utils::{
+    diagnostics::span_lint_and_then,
+    higher,
+    source::{snippet, snippet_opt},
+};
+
+use rustc_ast::ast;
 use rustc_errors::Applicability;
-use rustc_lint::{EarlyContext, EarlyLintPass};
+use rustc_hir::{Expr, ExprKind};
+
+use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
@@ -40,27 +47,47 @@ declare_clippy_lint! {
 
 declare_lint_pass!(NeedlessParensOnRangeLiteral => [NEEDLESS_PARENS_ON_RANGE_LITERAL]);
 
-fn check_for_parens(cx: &EarlyContext<'_>, e: &Expr) {
-    if_chain! {
-      if let ExprKind::Paren(ref start_statement) = &e.kind;
-    if let ExprKind::Lit(ref literal) = start_statement.kind;
-    then {
-      span_lint_and_then(cx, NEEDLESS_PARENS_ON_RANGE_LITERAL, e.span,
-        "needless parenthesis on range literal can be removed",
-        |diag| {
-                if let Some(suggestion) = snippet_opt(cx, literal.span) {
-                  diag.span_suggestion(e.span, "try", suggestion, Applicability::MachineApplicable);
-              }
-        });
+fn snippet_enclosed_in_parenthesis(snippet: &str) -> bool {
+    snippet.starts_with('(') && snippet.ends_with(')')
+}
+
+fn check_for_parens(cx: &LateContext<'_>, e: &Expr<'_>, is_start: bool) {
+    if is_start &&
+    let ExprKind::Lit(ref literal) = e.kind &&
+    let ast::LitKind::Float(_sym, ast::LitFloatType::Unsuffixed) = literal.node
+    {
+        // don't check floating point literals on the start expression of a range
+        return;
     }
+    if_chain! {
+        if let ExprKind::Lit(ref literal) = e.kind;
+        // the indicator that paranthese surround the literal is that span of the expression and the literal differ
+        if (literal.span.data().hi - literal.span.data().lo) != (e.span.data().hi - e.span.data().lo);
+        // inspect the source code of the expression for parenthesis
+        if snippet_enclosed_in_parenthesis(&snippet(cx, e.span, ""));
+        then {
+            span_lint_and_then(cx, NEEDLESS_PARENS_ON_RANGE_LITERAL, e.span,
+                "needless parenthesis on range literal can be removed",
+                |diag| {
+                        if let Some(suggestion) = snippet_opt(cx, literal.span) {
+                        diag.span_suggestion(e.span, "try", suggestion, Applicability::MachineApplicable);
+                    }
+                });
+        }
     }
 }
 
-impl EarlyLintPass for NeedlessParensOnRangeLiteral {
-    fn check_expr(&mut self, cx: &EarlyContext<'_>, e: &Expr) {
-        if let ExprKind::Range(Some(start), Some(end), _) = &e.kind {
-            check_for_parens(cx, start);
-            check_for_parens(cx, end);
+impl<'tcx> LateLintPass<'tcx> for NeedlessParensOnRangeLiteral {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        // if let higher::Range { start, end, limits } = &e.kind {
+        if let Some(higher::Range {
+            start: Some(start),
+            end: Some(end),
+            ..
+        }) = higher::Range::hir(expr)
+        {
+            check_for_parens(cx, start, true);
+            check_for_parens(cx, end, false);
         }
     }
 }
diff --git a/tests/ui/needless_parens_on_range_literal.fixed b/tests/ui/needless_parens_on_range_literal.fixed
index ba903fd688d..7b1d09909fc 100644
--- a/tests/ui/needless_parens_on_range_literal.fixed
+++ b/tests/ui/needless_parens_on_range_literal.fixed
@@ -6,4 +6,7 @@
 
 fn main() {
     let _ = 'a'..='z';
+    let _ = 'a'..='z';
+    let _ = (1.)..2.;
+    let _ = (1.)..2.;
 }
diff --git a/tests/ui/needless_parens_on_range_literal.rs b/tests/ui/needless_parens_on_range_literal.rs
index 7fddd6bf782..306498c0faf 100644
--- a/tests/ui/needless_parens_on_range_literal.rs
+++ b/tests/ui/needless_parens_on_range_literal.rs
@@ -6,4 +6,7 @@
 
 fn main() {
     let _ = ('a')..=('z');
+    let _ = 'a'..='z';
+    let _ = (1.)..2.;
+    let _ = (1.)..(2.);
 }
diff --git a/tests/ui/needless_parens_on_range_literal.stderr b/tests/ui/needless_parens_on_range_literal.stderr
index f9655e8948d..3a646c6b22c 100644
--- a/tests/ui/needless_parens_on_range_literal.stderr
+++ b/tests/ui/needless_parens_on_range_literal.stderr
@@ -12,5 +12,11 @@ error: needless parenthesis on range literal can be removed
 LL |     let _ = ('a')..=('z');
    |                     ^^^^^ help: try: `'z'`
 
-error: aborting due to 2 previous errors
+error: needless parenthesis on range literal can be removed
+  --> $DIR/needless_parens_on_range_literal.rs:11:19
+   |
+LL |     let _ = (1.)..(2.);
+   |                   ^^^^ help: try: `2.`
+
+error: aborting due to 3 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 2e6903ccf9310ffdbfdcb00baa2bda63bf9c6a73 Mon Sep 17 00:00:00 2001
From: Dennis Luxen <info@project-osrm.org>
Date: Sat, 4 Jun 2022 21:48:44 +0200
Subject: Move description into lint macro

---
 .../src/needless_parens_on_range_literal.rs        | 36 ++++++++++------------
 1 file changed, 16 insertions(+), 20 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/needless_parens_on_range_literal.rs b/clippy_lints/src/needless_parens_on_range_literal.rs
index 81c7f712770..f02323bd109 100644
--- a/clippy_lints/src/needless_parens_on_range_literal.rs
+++ b/clippy_lints/src/needless_parens_on_range_literal.rs
@@ -1,22 +1,3 @@
-//! Checks for parantheses on literals in range statements
-//!
-//! For example, the lint would catch
-//!
-//! ```rust
-//! for i in (0)..10 {
-//!   println!("{i}");
-//! }
-//! ```
-//!
-//! Use instead:
-//!
-//! ```rust
-//! for i in 0..10 {
-//!   println!("{i}");
-//! }
-//! ```
-//!
-
 use clippy_utils::{
     diagnostics::span_lint_and_then,
     higher,
@@ -38,7 +19,22 @@ declare_clippy_lint! {
   /// ### Why is this bad?
   /// Having superflous parenthesis makes the code less legible as the impose an
   /// overhead when reading.
-
+  ///
+  /// ### Example
+  ///
+  /// ```rust
+  /// for i in (0)..10 {
+  ///   println!("{i}");
+  /// }
+  /// ```
+  ///
+  /// Use instead:
+  ///
+  /// ```rust
+  /// for i in 0..10 {
+  ///   println!("{i}");
+  /// }
+  /// ```
   #[clippy::version = "1.63.0"]
   pub NEEDLESS_PARENS_ON_RANGE_LITERAL,
   style,
-- 
cgit 1.4.1-3-g733a5


From 0409306bb02a73d9299410b42c9cd774a216090b Mon Sep 17 00:00:00 2001
From: Dennis Luxen <info@project-osrm.org>
Date: Sat, 4 Jun 2022 22:01:52 +0200
Subject: Implement support for implicit start and end

---
 clippy_lints/src/needless_parens_on_range_literal.rs | 16 +++++++---------
 tests/ui/needless_parens_on_range_literal.fixed      |  4 +++-
 tests/ui/needless_parens_on_range_literal.rs         |  4 +++-
 tests/ui/needless_parens_on_range_literal.stderr     | 20 +++++++++++++++++++-
 4 files changed, 32 insertions(+), 12 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/needless_parens_on_range_literal.rs b/clippy_lints/src/needless_parens_on_range_literal.rs
index f02323bd109..1979810f7c4 100644
--- a/clippy_lints/src/needless_parens_on_range_literal.rs
+++ b/clippy_lints/src/needless_parens_on_range_literal.rs
@@ -75,15 +75,13 @@ fn check_for_parens(cx: &LateContext<'_>, e: &Expr<'_>, is_start: bool) {
 
 impl<'tcx> LateLintPass<'tcx> for NeedlessParensOnRangeLiteral {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        // if let higher::Range { start, end, limits } = &e.kind {
-        if let Some(higher::Range {
-            start: Some(start),
-            end: Some(end),
-            ..
-        }) = higher::Range::hir(expr)
-        {
-            check_for_parens(cx, start, true);
-            check_for_parens(cx, end, false);
+        if let Some(higher::Range { start, end, .. }) = higher::Range::hir(expr) {
+            if let Some(start) = start {
+                check_for_parens(cx, start, true);
+            }
+            if let Some(end) = end {
+                check_for_parens(cx, end, false);
+            }
         }
     }
 }
diff --git a/tests/ui/needless_parens_on_range_literal.fixed b/tests/ui/needless_parens_on_range_literal.fixed
index 7b1d09909fc..e76189bd2a3 100644
--- a/tests/ui/needless_parens_on_range_literal.fixed
+++ b/tests/ui/needless_parens_on_range_literal.fixed
@@ -6,7 +6,9 @@
 
 fn main() {
     let _ = 'a'..='z';
-    let _ = 'a'..='z';
+    let _ = 'a'..'z';
     let _ = (1.)..2.;
     let _ = (1.)..2.;
+    let _ = 'a'..;
+    let _ = ..'z';
 }
diff --git a/tests/ui/needless_parens_on_range_literal.rs b/tests/ui/needless_parens_on_range_literal.rs
index 306498c0faf..aa4bcd40065 100644
--- a/tests/ui/needless_parens_on_range_literal.rs
+++ b/tests/ui/needless_parens_on_range_literal.rs
@@ -6,7 +6,9 @@
 
 fn main() {
     let _ = ('a')..=('z');
-    let _ = 'a'..='z';
+    let _ = 'a'..('z');
     let _ = (1.)..2.;
     let _ = (1.)..(2.);
+    let _ = ('a')..;
+    let _ = ..('z');
 }
diff --git a/tests/ui/needless_parens_on_range_literal.stderr b/tests/ui/needless_parens_on_range_literal.stderr
index 3a646c6b22c..e971f9cd629 100644
--- a/tests/ui/needless_parens_on_range_literal.stderr
+++ b/tests/ui/needless_parens_on_range_literal.stderr
@@ -12,11 +12,29 @@ error: needless parenthesis on range literal can be removed
 LL |     let _ = ('a')..=('z');
    |                     ^^^^^ help: try: `'z'`
 
+error: needless parenthesis on range literal can be removed
+  --> $DIR/needless_parens_on_range_literal.rs:9:18
+   |
+LL |     let _ = 'a'..('z');
+   |                  ^^^^^ help: try: `'z'`
+
 error: needless parenthesis on range literal can be removed
   --> $DIR/needless_parens_on_range_literal.rs:11:19
    |
 LL |     let _ = (1.)..(2.);
    |                   ^^^^ help: try: `2.`
 
-error: aborting due to 3 previous errors
+error: needless parenthesis on range literal can be removed
+  --> $DIR/needless_parens_on_range_literal.rs:12:13
+   |
+LL |     let _ = ('a')..;
+   |             ^^^^^ help: try: `'a'`
+
+error: needless parenthesis on range literal can be removed
+  --> $DIR/needless_parens_on_range_literal.rs:13:15
+   |
+LL |     let _ = ..('z');
+   |               ^^^^^ help: try: `'z'`
+
+error: aborting due to 6 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From c0aa1f78b488e0c99441bd19cb31001d1daab8cf Mon Sep 17 00:00:00 2001
From: Dennis Luxen <info@project-osrm.org>
Date: Sat, 4 Jun 2022 22:08:33 +0200
Subject: Implement suggestion generation with snippet_with_applicability(.)

---
 clippy_lints/src/needless_parens_on_range_literal.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/needless_parens_on_range_literal.rs b/clippy_lints/src/needless_parens_on_range_literal.rs
index 1979810f7c4..89cb015b7d4 100644
--- a/clippy_lints/src/needless_parens_on_range_literal.rs
+++ b/clippy_lints/src/needless_parens_on_range_literal.rs
@@ -1,7 +1,7 @@
 use clippy_utils::{
     diagnostics::span_lint_and_then,
     higher,
-    source::{snippet, snippet_opt},
+    source::{snippet, snippet_with_applicability},
 };
 
 use rustc_ast::ast;
@@ -62,12 +62,12 @@ fn check_for_parens(cx: &LateContext<'_>, e: &Expr<'_>, is_start: bool) {
         // inspect the source code of the expression for parenthesis
         if snippet_enclosed_in_parenthesis(&snippet(cx, e.span, ""));
         then {
+            let mut applicability = Applicability::MachineApplicable;
             span_lint_and_then(cx, NEEDLESS_PARENS_ON_RANGE_LITERAL, e.span,
                 "needless parenthesis on range literal can be removed",
                 |diag| {
-                        if let Some(suggestion) = snippet_opt(cx, literal.span) {
-                        diag.span_suggestion(e.span, "try", suggestion, Applicability::MachineApplicable);
-                    }
+                    let suggestion = snippet_with_applicability(cx, literal.span, "_", &mut applicability);
+                    diag.span_suggestion(e.span, "try", suggestion, applicability);
                 });
         }
     }
-- 
cgit 1.4.1-3-g733a5


From 58a605f45301717219242c9bbd38764072092d01 Mon Sep 17 00:00:00 2001
From: Dennis Luxen <info@project-osrm.org>
Date: Sat, 4 Jun 2022 22:12:35 +0200
Subject: Rerun cargo dev update_lints

---
 CHANGELOG.md                           | 2 +-
 clippy_lints/src/lib.register_all.rs   | 2 +-
 clippy_lints/src/lib.register_lints.rs | 2 +-
 clippy_lints/src/lib.register_style.rs | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index d3db4be03f1..5d2b6300969 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3596,7 +3596,6 @@ Released 2018-09-13
 [`needless_bool`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_bool
 [`needless_borrow`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow
 [`needless_borrowed_reference`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrowed_reference
-[`needless_parens_on_range_literal`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_parens_on_range_literal
 [`needless_collect`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_collect
 [`needless_continue`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_continue
 [`needless_doctest_main`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_doctest_main
@@ -3606,6 +3605,7 @@ Released 2018-09-13
 [`needless_match`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_match
 [`needless_option_as_deref`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_option_as_deref
 [`needless_option_take`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_option_take
+[`needless_parens_on_range_literal`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_parens_on_range_literal
 [`needless_pass_by_value`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_pass_by_value
 [`needless_question_mark`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_question_mark
 [`needless_range_loop`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_range_loop
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 69f6496818c..0c6d01083c5 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -241,8 +241,8 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(needless_bool::BOOL_COMPARISON),
     LintId::of(needless_bool::NEEDLESS_BOOL),
     LintId::of(needless_borrowed_ref::NEEDLESS_BORROWED_REFERENCE),
-    LintId::of(needless_parens_on_range_literal::NEEDLESS_PARENS_ON_RANGE_LITERAL),
     LintId::of(needless_late_init::NEEDLESS_LATE_INIT),
+    LintId::of(needless_parens_on_range_literal::NEEDLESS_PARENS_ON_RANGE_LITERAL),
     LintId::of(needless_question_mark::NEEDLESS_QUESTION_MARK),
     LintId::of(needless_update::NEEDLESS_UPDATE),
     LintId::of(neg_cmp_op_on_partial_ord::NEG_CMP_OP_ON_PARTIAL_ORD),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 1dc65dabf84..eb46a719bbf 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -405,10 +405,10 @@ store.register_lints(&[
     needless_bool::BOOL_COMPARISON,
     needless_bool::NEEDLESS_BOOL,
     needless_borrowed_ref::NEEDLESS_BORROWED_REFERENCE,
-    needless_parens_on_range_literal::NEEDLESS_PARENS_ON_RANGE_LITERAL,
     needless_continue::NEEDLESS_CONTINUE,
     needless_for_each::NEEDLESS_FOR_EACH,
     needless_late_init::NEEDLESS_LATE_INIT,
+    needless_parens_on_range_literal::NEEDLESS_PARENS_ON_RANGE_LITERAL,
     needless_pass_by_value::NEEDLESS_PASS_BY_VALUE,
     needless_question_mark::NEEDLESS_QUESTION_MARK,
     needless_update::NEEDLESS_UPDATE,
diff --git a/clippy_lints/src/lib.register_style.rs b/clippy_lints/src/lib.register_style.rs
index 4518384bd87..37c55ae4916 100644
--- a/clippy_lints/src/lib.register_style.rs
+++ b/clippy_lints/src/lib.register_style.rs
@@ -90,8 +90,8 @@ store.register_group(true, "clippy::style", Some("clippy_style"), vec![
     LintId::of(misc_early::REDUNDANT_PATTERN),
     LintId::of(mut_mutex_lock::MUT_MUTEX_LOCK),
     LintId::of(mut_reference::UNNECESSARY_MUT_PASSED),
-    LintId::of(needless_parens_on_range_literal::NEEDLESS_PARENS_ON_RANGE_LITERAL),
     LintId::of(needless_late_init::NEEDLESS_LATE_INIT),
+    LintId::of(needless_parens_on_range_literal::NEEDLESS_PARENS_ON_RANGE_LITERAL),
     LintId::of(neg_multiply::NEG_MULTIPLY),
     LintId::of(new_without_default::NEW_WITHOUT_DEFAULT),
     LintId::of(non_copy_const::BORROW_INTERIOR_MUTABLE_CONST),
-- 
cgit 1.4.1-3-g733a5


From bf7a7864815f0e42ab020f768aaf8c671895d727 Mon Sep 17 00:00:00 2001
From: Dennis Luxen <ich@dennisluxen.de>
Date: Sun, 5 Jun 2022 21:41:00 +0200
Subject: Apply suggestions from code review

Co-authored-by: dswij <dharmasw@outlook.com>
---
 clippy_lints/src/needless_parens_on_range_literal.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/needless_parens_on_range_literal.rs b/clippy_lints/src/needless_parens_on_range_literal.rs
index 89cb015b7d4..b9f618d5f56 100644
--- a/clippy_lints/src/needless_parens_on_range_literal.rs
+++ b/clippy_lints/src/needless_parens_on_range_literal.rs
@@ -14,10 +14,10 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 declare_clippy_lint! {
   /// ### What it does
   /// The lint checks for parenthesis on literals in range statements that are
-  /// superflous.
+  /// superfluous.
   ///
   /// ### Why is this bad?
-  /// Having superflous parenthesis makes the code less legible as the impose an
+  /// Having superfluous parenthesis makes the code less readable
   /// overhead when reading.
   ///
   /// ### Example
@@ -57,7 +57,7 @@ fn check_for_parens(cx: &LateContext<'_>, e: &Expr<'_>, is_start: bool) {
     }
     if_chain! {
         if let ExprKind::Lit(ref literal) = e.kind;
-        // the indicator that paranthese surround the literal is that span of the expression and the literal differ
+        // the indicator that parenthesis surround the literal is that the span of the expression and the literal differ
         if (literal.span.data().hi - literal.span.data().lo) != (e.span.data().hi - e.span.data().lo);
         // inspect the source code of the expression for parenthesis
         if snippet_enclosed_in_parenthesis(&snippet(cx, e.span, ""));
-- 
cgit 1.4.1-3-g733a5


From 8ba377a78329824da2dac54cd35a86ab6c13f686 Mon Sep 17 00:00:00 2001
From: Dennis Luxen <info@project-osrm.org>
Date: Sun, 5 Jun 2022 22:12:30 +0200
Subject: Fix names to use plural

---
 clippy_lints/src/lib.register_all.rs               |  2 +-
 clippy_lints/src/lib.register_lints.rs             |  2 +-
 clippy_lints/src/lib.register_style.rs             |  2 +-
 clippy_lints/src/lib.rs                            |  4 +-
 .../src/needless_parens_on_range_literal.rs        | 87 ----------------------
 .../src/needless_parens_on_range_literals.rs       | 87 ++++++++++++++++++++++
 tests/ui/almost_complete_letter_range.fixed        |  2 +-
 tests/ui/almost_complete_letter_range.rs           |  2 +-
 tests/ui/needless_parens_on_range_literal.fixed    | 14 ----
 tests/ui/needless_parens_on_range_literal.rs       | 14 ----
 tests/ui/needless_parens_on_range_literal.stderr   | 40 ----------
 tests/ui/needless_parens_on_range_literals.fixed   | 14 ++++
 tests/ui/needless_parens_on_range_literals.rs      | 14 ++++
 tests/ui/needless_parens_on_range_literals.stderr  | 40 ++++++++++
 14 files changed, 162 insertions(+), 162 deletions(-)
 delete mode 100644 clippy_lints/src/needless_parens_on_range_literal.rs
 create mode 100644 clippy_lints/src/needless_parens_on_range_literals.rs
 delete mode 100644 tests/ui/needless_parens_on_range_literal.fixed
 delete mode 100644 tests/ui/needless_parens_on_range_literal.rs
 delete mode 100644 tests/ui/needless_parens_on_range_literal.stderr
 create mode 100644 tests/ui/needless_parens_on_range_literals.fixed
 create mode 100644 tests/ui/needless_parens_on_range_literals.rs
 create mode 100644 tests/ui/needless_parens_on_range_literals.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 0c6d01083c5..4691f957cb4 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -242,7 +242,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(needless_bool::NEEDLESS_BOOL),
     LintId::of(needless_borrowed_ref::NEEDLESS_BORROWED_REFERENCE),
     LintId::of(needless_late_init::NEEDLESS_LATE_INIT),
-    LintId::of(needless_parens_on_range_literal::NEEDLESS_PARENS_ON_RANGE_LITERAL),
+    LintId::of(needless_parens_on_range_literals::NEEDLESS_PARENS_ON_RANGE_LITERALS),
     LintId::of(needless_question_mark::NEEDLESS_QUESTION_MARK),
     LintId::of(needless_update::NEEDLESS_UPDATE),
     LintId::of(neg_cmp_op_on_partial_ord::NEG_CMP_OP_ON_PARTIAL_ORD),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index eb46a719bbf..efb073af6b6 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -408,7 +408,7 @@ store.register_lints(&[
     needless_continue::NEEDLESS_CONTINUE,
     needless_for_each::NEEDLESS_FOR_EACH,
     needless_late_init::NEEDLESS_LATE_INIT,
-    needless_parens_on_range_literal::NEEDLESS_PARENS_ON_RANGE_LITERAL,
+    needless_parens_on_range_literals::NEEDLESS_PARENS_ON_RANGE_LITERALS,
     needless_pass_by_value::NEEDLESS_PASS_BY_VALUE,
     needless_question_mark::NEEDLESS_QUESTION_MARK,
     needless_update::NEEDLESS_UPDATE,
diff --git a/clippy_lints/src/lib.register_style.rs b/clippy_lints/src/lib.register_style.rs
index 37c55ae4916..b6992ae0ad2 100644
--- a/clippy_lints/src/lib.register_style.rs
+++ b/clippy_lints/src/lib.register_style.rs
@@ -91,7 +91,7 @@ store.register_group(true, "clippy::style", Some("clippy_style"), vec![
     LintId::of(mut_mutex_lock::MUT_MUTEX_LOCK),
     LintId::of(mut_reference::UNNECESSARY_MUT_PASSED),
     LintId::of(needless_late_init::NEEDLESS_LATE_INIT),
-    LintId::of(needless_parens_on_range_literal::NEEDLESS_PARENS_ON_RANGE_LITERAL),
+    LintId::of(needless_parens_on_range_literals::NEEDLESS_PARENS_ON_RANGE_LITERALS),
     LintId::of(neg_multiply::NEG_MULTIPLY),
     LintId::of(new_without_default::NEW_WITHOUT_DEFAULT),
     LintId::of(non_copy_const::BORROW_INTERIOR_MUTABLE_CONST),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 19e1247d642..a0a6bab407c 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -315,7 +315,7 @@ mod needless_borrowed_ref;
 mod needless_continue;
 mod needless_for_each;
 mod needless_late_init;
-mod needless_parens_on_range_literal;
+mod needless_parens_on_range_literals;
 mod needless_pass_by_value;
 mod needless_question_mark;
 mod needless_update;
@@ -747,7 +747,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_early_pass(|| Box::new(collapsible_if::CollapsibleIf));
     store.register_early_pass(|| Box::new(items_after_statements::ItemsAfterStatements));
     store.register_early_pass(|| Box::new(precedence::Precedence));
-    store.register_late_pass(|| Box::new(needless_parens_on_range_literal::NeedlessParensOnRangeLiteral));
+    store.register_late_pass(|| Box::new(needless_parens_on_range_literals::NeedlessParensOnRangeLiterals));
     store.register_early_pass(|| Box::new(needless_continue::NeedlessContinue));
     store.register_early_pass(|| Box::new(redundant_else::RedundantElse));
     store.register_late_pass(|| Box::new(create_dir::CreateDir));
diff --git a/clippy_lints/src/needless_parens_on_range_literal.rs b/clippy_lints/src/needless_parens_on_range_literal.rs
deleted file mode 100644
index b9f618d5f56..00000000000
--- a/clippy_lints/src/needless_parens_on_range_literal.rs
+++ /dev/null
@@ -1,87 +0,0 @@
-use clippy_utils::{
-    diagnostics::span_lint_and_then,
-    higher,
-    source::{snippet, snippet_with_applicability},
-};
-
-use rustc_ast::ast;
-use rustc_errors::Applicability;
-use rustc_hir::{Expr, ExprKind};
-
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-
-declare_clippy_lint! {
-  /// ### What it does
-  /// The lint checks for parenthesis on literals in range statements that are
-  /// superfluous.
-  ///
-  /// ### Why is this bad?
-  /// Having superfluous parenthesis makes the code less readable
-  /// overhead when reading.
-  ///
-  /// ### Example
-  ///
-  /// ```rust
-  /// for i in (0)..10 {
-  ///   println!("{i}");
-  /// }
-  /// ```
-  ///
-  /// Use instead:
-  ///
-  /// ```rust
-  /// for i in 0..10 {
-  ///   println!("{i}");
-  /// }
-  /// ```
-  #[clippy::version = "1.63.0"]
-  pub NEEDLESS_PARENS_ON_RANGE_LITERAL,
-  style,
-  "needless parenthesis on range literal can be removed"
-}
-
-declare_lint_pass!(NeedlessParensOnRangeLiteral => [NEEDLESS_PARENS_ON_RANGE_LITERAL]);
-
-fn snippet_enclosed_in_parenthesis(snippet: &str) -> bool {
-    snippet.starts_with('(') && snippet.ends_with(')')
-}
-
-fn check_for_parens(cx: &LateContext<'_>, e: &Expr<'_>, is_start: bool) {
-    if is_start &&
-    let ExprKind::Lit(ref literal) = e.kind &&
-    let ast::LitKind::Float(_sym, ast::LitFloatType::Unsuffixed) = literal.node
-    {
-        // don't check floating point literals on the start expression of a range
-        return;
-    }
-    if_chain! {
-        if let ExprKind::Lit(ref literal) = e.kind;
-        // the indicator that parenthesis surround the literal is that the span of the expression and the literal differ
-        if (literal.span.data().hi - literal.span.data().lo) != (e.span.data().hi - e.span.data().lo);
-        // inspect the source code of the expression for parenthesis
-        if snippet_enclosed_in_parenthesis(&snippet(cx, e.span, ""));
-        then {
-            let mut applicability = Applicability::MachineApplicable;
-            span_lint_and_then(cx, NEEDLESS_PARENS_ON_RANGE_LITERAL, e.span,
-                "needless parenthesis on range literal can be removed",
-                |diag| {
-                    let suggestion = snippet_with_applicability(cx, literal.span, "_", &mut applicability);
-                    diag.span_suggestion(e.span, "try", suggestion, applicability);
-                });
-        }
-    }
-}
-
-impl<'tcx> LateLintPass<'tcx> for NeedlessParensOnRangeLiteral {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if let Some(higher::Range { start, end, .. }) = higher::Range::hir(expr) {
-            if let Some(start) = start {
-                check_for_parens(cx, start, true);
-            }
-            if let Some(end) = end {
-                check_for_parens(cx, end, false);
-            }
-        }
-    }
-}
diff --git a/clippy_lints/src/needless_parens_on_range_literals.rs b/clippy_lints/src/needless_parens_on_range_literals.rs
new file mode 100644
index 00000000000..6e54b243c03
--- /dev/null
+++ b/clippy_lints/src/needless_parens_on_range_literals.rs
@@ -0,0 +1,87 @@
+use clippy_utils::{
+    diagnostics::span_lint_and_then,
+    higher,
+    source::{snippet, snippet_with_applicability},
+};
+
+use rustc_ast::ast;
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind};
+
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+  /// ### What it does
+  /// The lint checks for parenthesis on literals in range statements that are
+  /// superfluous.
+  ///
+  /// ### Why is this bad?
+  /// Having superfluous parenthesis makes the code less readable
+  /// overhead when reading.
+  ///
+  /// ### Example
+  ///
+  /// ```rust
+  /// for i in (0)..10 {
+  ///   println!("{i}");
+  /// }
+  /// ```
+  ///
+  /// Use instead:
+  ///
+  /// ```rust
+  /// for i in 0..10 {
+  ///   println!("{i}");
+  /// }
+  /// ```
+  #[clippy::version = "1.63.0"]
+  pub NEEDLESS_PARENS_ON_RANGE_LITERALS,
+  style,
+  "needless parenthesis on range literals can be removed"
+}
+
+declare_lint_pass!(NeedlessParensOnRangeLiterals => [NEEDLESS_PARENS_ON_RANGE_LITERALS]);
+
+fn snippet_enclosed_in_parenthesis(snippet: &str) -> bool {
+    snippet.starts_with('(') && snippet.ends_with(')')
+}
+
+fn check_for_parens(cx: &LateContext<'_>, e: &Expr<'_>, is_start: bool) {
+    if is_start &&
+    let ExprKind::Lit(ref literal) = e.kind &&
+    let ast::LitKind::Float(_sym, ast::LitFloatType::Unsuffixed) = literal.node
+    {
+        // don't check floating point literals on the start expression of a range
+        return;
+    }
+    if_chain! {
+        if let ExprKind::Lit(ref literal) = e.kind;
+        // the indicator that parenthesis surround the literal is that the span of the expression and the literal differ
+        if (literal.span.data().hi - literal.span.data().lo) != (e.span.data().hi - e.span.data().lo);
+        // inspect the source code of the expression for parenthesis
+        if snippet_enclosed_in_parenthesis(&snippet(cx, e.span, ""));
+        then {
+            let mut applicability = Applicability::MachineApplicable;
+            span_lint_and_then(cx, NEEDLESS_PARENS_ON_RANGE_LITERALS, e.span,
+                "needless parenthesis on range literals can be removed",
+                |diag| {
+                    let suggestion = snippet_with_applicability(cx, literal.span, "_", &mut applicability);
+                    diag.span_suggestion(e.span, "try", suggestion, applicability);
+                });
+        }
+    }
+}
+
+impl<'tcx> LateLintPass<'tcx> for NeedlessParensOnRangeLiterals {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        if let Some(higher::Range { start, end, .. }) = higher::Range::hir(expr) {
+            if let Some(start) = start {
+                check_for_parens(cx, start, true);
+            }
+            if let Some(end) = end {
+                check_for_parens(cx, end, false);
+            }
+        }
+    }
+}
diff --git a/tests/ui/almost_complete_letter_range.fixed b/tests/ui/almost_complete_letter_range.fixed
index 83a6bf14c3f..e69b40f35f4 100644
--- a/tests/ui/almost_complete_letter_range.fixed
+++ b/tests/ui/almost_complete_letter_range.fixed
@@ -6,7 +6,7 @@
 #![feature(stmt_expr_attributes)]
 #![warn(clippy::almost_complete_letter_range)]
 #![allow(ellipsis_inclusive_range_patterns)]
-#![allow(clippy::needless_parens_on_range_literal)]
+#![allow(clippy::needless_parens_on_range_literals)]
 
 macro_rules! a {
     () => {
diff --git a/tests/ui/almost_complete_letter_range.rs b/tests/ui/almost_complete_letter_range.rs
index a8da9266ad7..f2240981d45 100644
--- a/tests/ui/almost_complete_letter_range.rs
+++ b/tests/ui/almost_complete_letter_range.rs
@@ -6,7 +6,7 @@
 #![feature(stmt_expr_attributes)]
 #![warn(clippy::almost_complete_letter_range)]
 #![allow(ellipsis_inclusive_range_patterns)]
-#![allow(clippy::needless_parens_on_range_literal)]
+#![allow(clippy::needless_parens_on_range_literals)]
 
 macro_rules! a {
     () => {
diff --git a/tests/ui/needless_parens_on_range_literal.fixed b/tests/ui/needless_parens_on_range_literal.fixed
deleted file mode 100644
index e76189bd2a3..00000000000
--- a/tests/ui/needless_parens_on_range_literal.fixed
+++ /dev/null
@@ -1,14 +0,0 @@
-// run-rustfix
-// edition:2018
-
-#![warn(clippy::needless_parens_on_range_literal)]
-#![allow(clippy::almost_complete_letter_range)]
-
-fn main() {
-    let _ = 'a'..='z';
-    let _ = 'a'..'z';
-    let _ = (1.)..2.;
-    let _ = (1.)..2.;
-    let _ = 'a'..;
-    let _ = ..'z';
-}
diff --git a/tests/ui/needless_parens_on_range_literal.rs b/tests/ui/needless_parens_on_range_literal.rs
deleted file mode 100644
index aa4bcd40065..00000000000
--- a/tests/ui/needless_parens_on_range_literal.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-// run-rustfix
-// edition:2018
-
-#![warn(clippy::needless_parens_on_range_literal)]
-#![allow(clippy::almost_complete_letter_range)]
-
-fn main() {
-    let _ = ('a')..=('z');
-    let _ = 'a'..('z');
-    let _ = (1.)..2.;
-    let _ = (1.)..(2.);
-    let _ = ('a')..;
-    let _ = ..('z');
-}
diff --git a/tests/ui/needless_parens_on_range_literal.stderr b/tests/ui/needless_parens_on_range_literal.stderr
deleted file mode 100644
index e971f9cd629..00000000000
--- a/tests/ui/needless_parens_on_range_literal.stderr
+++ /dev/null
@@ -1,40 +0,0 @@
-error: needless parenthesis on range literal can be removed
-  --> $DIR/needless_parens_on_range_literal.rs:8:13
-   |
-LL |     let _ = ('a')..=('z');
-   |             ^^^^^ help: try: `'a'`
-   |
-   = note: `-D clippy::needless-parens-on-range-literal` implied by `-D warnings`
-
-error: needless parenthesis on range literal can be removed
-  --> $DIR/needless_parens_on_range_literal.rs:8:21
-   |
-LL |     let _ = ('a')..=('z');
-   |                     ^^^^^ help: try: `'z'`
-
-error: needless parenthesis on range literal can be removed
-  --> $DIR/needless_parens_on_range_literal.rs:9:18
-   |
-LL |     let _ = 'a'..('z');
-   |                  ^^^^^ help: try: `'z'`
-
-error: needless parenthesis on range literal can be removed
-  --> $DIR/needless_parens_on_range_literal.rs:11:19
-   |
-LL |     let _ = (1.)..(2.);
-   |                   ^^^^ help: try: `2.`
-
-error: needless parenthesis on range literal can be removed
-  --> $DIR/needless_parens_on_range_literal.rs:12:13
-   |
-LL |     let _ = ('a')..;
-   |             ^^^^^ help: try: `'a'`
-
-error: needless parenthesis on range literal can be removed
-  --> $DIR/needless_parens_on_range_literal.rs:13:15
-   |
-LL |     let _ = ..('z');
-   |               ^^^^^ help: try: `'z'`
-
-error: aborting due to 6 previous errors
-
diff --git a/tests/ui/needless_parens_on_range_literals.fixed b/tests/ui/needless_parens_on_range_literals.fixed
new file mode 100644
index 00000000000..1bd75c806bc
--- /dev/null
+++ b/tests/ui/needless_parens_on_range_literals.fixed
@@ -0,0 +1,14 @@
+// run-rustfix
+// edition:2018
+
+#![warn(clippy::needless_parens_on_range_literals)]
+#![allow(clippy::almost_complete_letter_range)]
+
+fn main() {
+    let _ = 'a'..='z';
+    let _ = 'a'..'z';
+    let _ = (1.)..2.;
+    let _ = (1.)..2.;
+    let _ = 'a'..;
+    let _ = ..'z';
+}
diff --git a/tests/ui/needless_parens_on_range_literals.rs b/tests/ui/needless_parens_on_range_literals.rs
new file mode 100644
index 00000000000..7abb8a1adc1
--- /dev/null
+++ b/tests/ui/needless_parens_on_range_literals.rs
@@ -0,0 +1,14 @@
+// run-rustfix
+// edition:2018
+
+#![warn(clippy::needless_parens_on_range_literals)]
+#![allow(clippy::almost_complete_letter_range)]
+
+fn main() {
+    let _ = ('a')..=('z');
+    let _ = 'a'..('z');
+    let _ = (1.)..2.;
+    let _ = (1.)..(2.);
+    let _ = ('a')..;
+    let _ = ..('z');
+}
diff --git a/tests/ui/needless_parens_on_range_literals.stderr b/tests/ui/needless_parens_on_range_literals.stderr
new file mode 100644
index 00000000000..505f7ac916d
--- /dev/null
+++ b/tests/ui/needless_parens_on_range_literals.stderr
@@ -0,0 +1,40 @@
+error: needless parenthesis on range literals can be removed
+  --> $DIR/needless_parens_on_range_literals.rs:8:13
+   |
+LL |     let _ = ('a')..=('z');
+   |             ^^^^^ help: try: `'a'`
+   |
+   = note: `-D clippy::needless-parens-on-range-literals` implied by `-D warnings`
+
+error: needless parenthesis on range literals can be removed
+  --> $DIR/needless_parens_on_range_literals.rs:8:21
+   |
+LL |     let _ = ('a')..=('z');
+   |                     ^^^^^ help: try: `'z'`
+
+error: needless parenthesis on range literals can be removed
+  --> $DIR/needless_parens_on_range_literals.rs:9:18
+   |
+LL |     let _ = 'a'..('z');
+   |                  ^^^^^ help: try: `'z'`
+
+error: needless parenthesis on range literals can be removed
+  --> $DIR/needless_parens_on_range_literals.rs:11:19
+   |
+LL |     let _ = (1.)..(2.);
+   |                   ^^^^ help: try: `2.`
+
+error: needless parenthesis on range literals can be removed
+  --> $DIR/needless_parens_on_range_literals.rs:12:13
+   |
+LL |     let _ = ('a')..;
+   |             ^^^^^ help: try: `'a'`
+
+error: needless parenthesis on range literals can be removed
+  --> $DIR/needless_parens_on_range_literals.rs:13:15
+   |
+LL |     let _ = ..('z');
+   |               ^^^^^ help: try: `'z'`
+
+error: aborting due to 6 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From a613460e8ade73dc387c19b0a45588681de46fef Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Mon, 6 Jun 2022 11:51:36 +0200
Subject: Fix `#[expect]` for `needless_borrow`, `ref_binding_to_ref`

---
 clippy_lints/src/dereference.rs          | 45 ++++++++++++++++++--------------
 tests/ui/needless_borrow.fixed           |  8 ++++++
 tests/ui/needless_borrow.rs              |  8 ++++++
 tests/ui/needless_borrow.stderr          | 32 +++++++++++------------
 tests/ui/ref_binding_to_reference.rs     | 10 +++++++
 tests/ui/ref_binding_to_reference.stderr | 14 +++++-----
 6 files changed, 75 insertions(+), 42 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index 8288f7a8b9b..6d32cc8253f 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
+use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_hir_and_then};
 use clippy_utils::source::{snippet_with_applicability, snippet_with_context};
 use clippy_utils::sugg::has_enclosing_paren;
 use clippy_utils::ty::peel_mid_ty_refs;
@@ -131,6 +131,7 @@ pub struct Dereferencing {
 struct StateData {
     /// Span of the top level expression
     span: Span,
+    hir_id: HirId,
 }
 
 enum State {
@@ -165,6 +166,8 @@ struct RefPat {
     app: Applicability,
     /// All the replacements which need to be made.
     replacements: Vec<(Span, String)>,
+    /// The [`HirId`] that the lint should be emitted at.
+    hir_id: HirId,
 }
 
 impl<'tcx> LateLintPass<'tcx> for Dereferencing {
@@ -218,7 +221,10 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing {
                                 is_final_ufcs: matches!(expr.kind, ExprKind::Call(..)),
                                 target_mut,
                             },
-                            StateData { span: expr.span },
+                            StateData {
+                                span: expr.span,
+                                hir_id: expr.hir_id,
+                            },
                         ));
                     },
                     RefOp::AddrOf => {
@@ -290,7 +296,10 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing {
                                     required_precedence,
                                     msg,
                                 },
-                                StateData { span: expr.span },
+                                StateData {
+                                    span: expr.span,
+                                    hir_id: expr.hir_id,
+                                },
                             ));
                         }
                     },
@@ -383,6 +392,7 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing {
                             spans: vec![pat.span],
                             app,
                             replacements: vec![(pat.span, snip.into())],
+                            hir_id: pat.hir_id
                         }),
                     );
                 }
@@ -395,13 +405,15 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing {
             for pat in self.ref_locals.drain(..).filter_map(|(_, x)| x) {
                 let replacements = pat.replacements;
                 let app = pat.app;
-                span_lint_and_then(
+                let lint = if pat.always_deref {
+                    NEEDLESS_BORROW
+                } else {
+                    REF_BINDING_TO_REFERENCE
+                };
+                span_lint_hir_and_then(
                     cx,
-                    if pat.always_deref {
-                        NEEDLESS_BORROW
-                    } else {
-                        REF_BINDING_TO_REFERENCE
-                    },
+                    lint,
+                    pat.hir_id,
                     pat.spans,
                     "this pattern creates a reference to a reference",
                     |diag| {
@@ -638,19 +650,14 @@ fn report<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>, state: State, data: S
         } => {
             let mut app = Applicability::MachineApplicable;
             let snip = snippet_with_context(cx, expr.span, data.span.ctxt(), "..", &mut app).0;
-            span_lint_and_sugg(
-                cx,
-                NEEDLESS_BORROW,
-                data.span,
-                msg,
-                "change this to",
-                if required_precedence > expr.precedence().order() && !has_enclosing_paren(&snip) {
+            span_lint_hir_and_then(cx, NEEDLESS_BORROW, data.hir_id, data.span, msg, |diag| {
+                let sugg = if required_precedence > expr.precedence().order() && !has_enclosing_paren(&snip) {
                     format!("({})", snip)
                 } else {
                     snip.into()
-                },
-                app,
-            );
+                };
+                diag.span_suggestion(data.span, "change this to", sugg, app);
+            });
         },
     }
 }
diff --git a/tests/ui/needless_borrow.fixed b/tests/ui/needless_borrow.fixed
index efeb5cf5b2b..6b1576d6732 100644
--- a/tests/ui/needless_borrow.fixed
+++ b/tests/ui/needless_borrow.fixed
@@ -1,5 +1,7 @@
 // run-rustfix
 
+#![feature(lint_reasons)]
+
 #[warn(clippy::all, clippy::needless_borrow)]
 #[allow(unused_variables, clippy::unnecessary_mut_passed)]
 fn main() {
@@ -96,3 +98,9 @@ trait Trait {}
 impl<'a> Trait for &'a str {}
 
 fn h(_: &dyn Trait) {}
+
+fn check_expect_suppression() {
+    let a = 5;
+    #[expect(clippy::needless_borrow)]
+    let _ = x(&&a);
+}
diff --git a/tests/ui/needless_borrow.rs b/tests/ui/needless_borrow.rs
index 3e416a0eb84..ebe76361db4 100644
--- a/tests/ui/needless_borrow.rs
+++ b/tests/ui/needless_borrow.rs
@@ -1,5 +1,7 @@
 // run-rustfix
 
+#![feature(lint_reasons)]
+
 #[warn(clippy::all, clippy::needless_borrow)]
 #[allow(unused_variables, clippy::unnecessary_mut_passed)]
 fn main() {
@@ -96,3 +98,9 @@ trait Trait {}
 impl<'a> Trait for &'a str {}
 
 fn h(_: &dyn Trait) {}
+
+fn check_expect_suppression() {
+    let a = 5;
+    #[expect(clippy::needless_borrow)]
+    let _ = x(&&a);
+}
diff --git a/tests/ui/needless_borrow.stderr b/tests/ui/needless_borrow.stderr
index 05591ce4117..be59d8f546d 100644
--- a/tests/ui/needless_borrow.stderr
+++ b/tests/ui/needless_borrow.stderr
@@ -1,5 +1,5 @@
 error: this expression creates a reference which is immediately dereferenced by the compiler
-  --> $DIR/needless_borrow.rs:9:15
+  --> $DIR/needless_borrow.rs:11:15
    |
 LL |     let _ = x(&&a); // warn
    |               ^^^ help: change this to: `&a`
@@ -7,91 +7,91 @@ LL |     let _ = x(&&a); // warn
    = note: `-D clippy::needless-borrow` implied by `-D warnings`
 
 error: this expression creates a reference which is immediately dereferenced by the compiler
-  --> $DIR/needless_borrow.rs:13:13
+  --> $DIR/needless_borrow.rs:15:13
    |
 LL |     mut_ref(&mut &mut b); // warn
    |             ^^^^^^^^^^^ help: change this to: `&mut b`
 
 error: this expression creates a reference which is immediately dereferenced by the compiler
-  --> $DIR/needless_borrow.rs:25:13
+  --> $DIR/needless_borrow.rs:27:13
    |
 LL |             &&a
    |             ^^^ help: change this to: `&a`
 
 error: this expression creates a reference which is immediately dereferenced by the compiler
-  --> $DIR/needless_borrow.rs:27:15
+  --> $DIR/needless_borrow.rs:29:15
    |
 LL |         46 => &&a,
    |               ^^^ help: change this to: `&a`
 
 error: this expression creates a reference which is immediately dereferenced by the compiler
-  --> $DIR/needless_borrow.rs:33:27
+  --> $DIR/needless_borrow.rs:35:27
    |
 LL |                     break &ref_a;
    |                           ^^^^^^ help: change this to: `ref_a`
 
 error: this expression creates a reference which is immediately dereferenced by the compiler
-  --> $DIR/needless_borrow.rs:40:15
+  --> $DIR/needless_borrow.rs:42:15
    |
 LL |     let _ = x(&&&a);
    |               ^^^^ help: change this to: `&a`
 
 error: this expression creates a reference which is immediately dereferenced by the compiler
-  --> $DIR/needless_borrow.rs:41:15
+  --> $DIR/needless_borrow.rs:43:15
    |
 LL |     let _ = x(&mut &&a);
    |               ^^^^^^^^ help: change this to: `&a`
 
 error: this expression creates a reference which is immediately dereferenced by the compiler
-  --> $DIR/needless_borrow.rs:42:15
+  --> $DIR/needless_borrow.rs:44:15
    |
 LL |     let _ = x(&&&mut b);
    |               ^^^^^^^^ help: change this to: `&mut b`
 
 error: this expression creates a reference which is immediately dereferenced by the compiler
-  --> $DIR/needless_borrow.rs:43:15
+  --> $DIR/needless_borrow.rs:45:15
    |
 LL |     let _ = x(&&ref_a);
    |               ^^^^^^^ help: change this to: `ref_a`
 
 error: this expression creates a reference which is immediately dereferenced by the compiler
-  --> $DIR/needless_borrow.rs:46:11
+  --> $DIR/needless_borrow.rs:48:11
    |
 LL |         x(&b);
    |           ^^ help: change this to: `b`
 
 error: this expression creates a reference which is immediately dereferenced by the compiler
-  --> $DIR/needless_borrow.rs:53:13
+  --> $DIR/needless_borrow.rs:55:13
    |
 LL |     mut_ref(&mut x);
    |             ^^^^^^ help: change this to: `x`
 
 error: this expression creates a reference which is immediately dereferenced by the compiler
-  --> $DIR/needless_borrow.rs:54:13
+  --> $DIR/needless_borrow.rs:56:13
    |
 LL |     mut_ref(&mut &mut x);
    |             ^^^^^^^^^^^ help: change this to: `x`
 
 error: this expression creates a reference which is immediately dereferenced by the compiler
-  --> $DIR/needless_borrow.rs:55:23
+  --> $DIR/needless_borrow.rs:57:23
    |
 LL |     let y: &mut i32 = &mut x;
    |                       ^^^^^^ help: change this to: `x`
 
 error: this expression creates a reference which is immediately dereferenced by the compiler
-  --> $DIR/needless_borrow.rs:56:23
+  --> $DIR/needless_borrow.rs:58:23
    |
 LL |     let y: &mut i32 = &mut &mut x;
    |                       ^^^^^^^^^^^ help: change this to: `x`
 
 error: this expression borrows a value the compiler would automatically borrow
-  --> $DIR/needless_borrow.rs:72:13
+  --> $DIR/needless_borrow.rs:74:13
    |
 LL |     let _ = (&x).0;
    |             ^^^^ help: change this to: `x`
 
 error: this expression borrows a value the compiler would automatically borrow
-  --> $DIR/needless_borrow.rs:74:22
+  --> $DIR/needless_borrow.rs:76:22
    |
 LL |     let _ = unsafe { (&*x).0 };
    |                      ^^^^^ help: change this to: `(*x)`
diff --git a/tests/ui/ref_binding_to_reference.rs b/tests/ui/ref_binding_to_reference.rs
index fe742a4c2f4..570ef406e4a 100644
--- a/tests/ui/ref_binding_to_reference.rs
+++ b/tests/ui/ref_binding_to_reference.rs
@@ -1,5 +1,6 @@
 // FIXME: run-rustfix waiting on multi-span suggestions
 
+#![feature(lint_reasons)]
 #![warn(clippy::ref_binding_to_reference)]
 #![allow(clippy::needless_borrowed_reference)]
 
@@ -73,3 +74,12 @@ impl T1 for S {
         let _: &&String = x;
     }
 }
+
+fn check_expect_suppression() {
+    let x = String::new();
+    #[expect(clippy::ref_binding_to_reference)]
+    let _: &&String = match Some(&x) {
+        Some(ref x) => x,
+        None => return,
+    };
+}
diff --git a/tests/ui/ref_binding_to_reference.stderr b/tests/ui/ref_binding_to_reference.stderr
index c5856e15fa9..eb36cd516a2 100644
--- a/tests/ui/ref_binding_to_reference.stderr
+++ b/tests/ui/ref_binding_to_reference.stderr
@@ -1,5 +1,5 @@
 error: this pattern creates a reference to a reference
-  --> $DIR/ref_binding_to_reference.rs:30:14
+  --> $DIR/ref_binding_to_reference.rs:31:14
    |
 LL |         Some(ref x) => x,
    |              ^^^^^
@@ -11,7 +11,7 @@ LL |         Some(x) => &x,
    |              ~     ~~
 
 error: this pattern creates a reference to a reference
-  --> $DIR/ref_binding_to_reference.rs:36:14
+  --> $DIR/ref_binding_to_reference.rs:37:14
    |
 LL |         Some(ref x) => {
    |              ^^^^^
@@ -25,7 +25,7 @@ LL ~             &x
    |
 
 error: this pattern creates a reference to a reference
-  --> $DIR/ref_binding_to_reference.rs:46:14
+  --> $DIR/ref_binding_to_reference.rs:47:14
    |
 LL |         Some(ref x) => m2!(x),
    |              ^^^^^
@@ -36,7 +36,7 @@ LL |         Some(x) => m2!(&x),
    |              ~         ~~
 
 error: this pattern creates a reference to a reference
-  --> $DIR/ref_binding_to_reference.rs:51:15
+  --> $DIR/ref_binding_to_reference.rs:52:15
    |
 LL |     let _ = |&ref x: &&String| {
    |               ^^^^^
@@ -48,7 +48,7 @@ LL ~         let _: &&String = &x;
    |
 
 error: this pattern creates a reference to a reference
-  --> $DIR/ref_binding_to_reference.rs:57:12
+  --> $DIR/ref_binding_to_reference.rs:58:12
    |
 LL | fn f2<'a>(&ref x: &&'a String) -> &'a String {
    |            ^^^^^
@@ -61,7 +61,7 @@ LL ~     x
    |
 
 error: this pattern creates a reference to a reference
-  --> $DIR/ref_binding_to_reference.rs:64:11
+  --> $DIR/ref_binding_to_reference.rs:65:11
    |
 LL |     fn f(&ref x: &&String) {
    |           ^^^^^
@@ -73,7 +73,7 @@ LL ~         let _: &&String = &x;
    |
 
 error: this pattern creates a reference to a reference
-  --> $DIR/ref_binding_to_reference.rs:72:11
+  --> $DIR/ref_binding_to_reference.rs:73:11
    |
 LL |     fn f(&ref x: &&String) {
    |           ^^^^^
-- 
cgit 1.4.1-3-g733a5


From 7e1730e16c779f688392e0edcd553036b2afe1f1 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Mon, 6 Jun 2022 12:36:57 +0200
Subject: Fix `#[expect]` for `same_name_method`

---
 clippy_lints/src/same_name_method.rs | 17 ++++++++++-------
 tests/ui/same_name_method.rs         | 16 ++++++++++++++++
 tests/ui/same_name_method.stderr     | 20 ++++++++++----------
 3 files changed, 36 insertions(+), 17 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/same_name_method.rs b/clippy_lints/src/same_name_method.rs
index 9158cbcc04e..04d9ee7d912 100644
--- a/clippy_lints/src/same_name_method.rs
+++ b/clippy_lints/src/same_name_method.rs
@@ -1,7 +1,7 @@
-use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::diagnostics::span_lint_hir_and_then;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_hir::def::{DefKind, Res};
-use rustc_hir::{Impl, ItemKind, Node, Path, QPath, TraitRef, TyKind};
+use rustc_hir::{HirId, Impl, ItemKind, Node, Path, QPath, TraitRef, TyKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::AssocKind;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -42,7 +42,7 @@ declare_clippy_lint! {
 declare_lint_pass!(SameNameMethod => [SAME_NAME_METHOD]);
 
 struct ExistingName {
-    impl_methods: BTreeMap<Symbol, Span>,
+    impl_methods: BTreeMap<Symbol, (Span, HirId)>,
     trait_methods: BTreeMap<Symbol, Vec<Span>>,
 }
 
@@ -97,10 +97,11 @@ impl<'tcx> LateLintPass<'tcx> for SameNameMethod {
                         };
 
                         let mut check_trait_method = |method_name: Symbol, trait_method_span: Span| {
-                            if let Some(impl_span) = existing_name.impl_methods.get(&method_name) {
-                                span_lint_and_then(
+                            if let Some((impl_span, hir_id)) = existing_name.impl_methods.get(&method_name) {
+                                span_lint_hir_and_then(
                                     cx,
                                     SAME_NAME_METHOD,
+                                    *hir_id,
                                     *impl_span,
                                     "method's name is the same as an existing method in a trait",
                                     |diag| {
@@ -136,10 +137,12 @@ impl<'tcx> LateLintPass<'tcx> for SameNameMethod {
                         }) {
                             let method_name = impl_item_ref.ident.name;
                             let impl_span = impl_item_ref.span;
+                            let hir_id = impl_item_ref.id.hir_id();
                             if let Some(trait_spans) = existing_name.trait_methods.get(&method_name) {
-                                span_lint_and_then(
+                                span_lint_hir_and_then(
                                     cx,
                                     SAME_NAME_METHOD,
+                                    hir_id,
                                     impl_span,
                                     "method's name is the same as an existing method in a trait",
                                     |diag| {
@@ -152,7 +155,7 @@ impl<'tcx> LateLintPass<'tcx> for SameNameMethod {
                                     },
                                 );
                             }
-                            existing_name.impl_methods.insert(method_name, impl_span);
+                            existing_name.impl_methods.insert(method_name, (impl_span, hir_id));
                         }
                     },
                 }
diff --git a/tests/ui/same_name_method.rs b/tests/ui/same_name_method.rs
index 12e10ba6c49..9562b47f0c4 100644
--- a/tests/ui/same_name_method.rs
+++ b/tests/ui/same_name_method.rs
@@ -1,3 +1,4 @@
+#![feature(lint_reasons)]
 #![warn(clippy::same_name_method)]
 #![allow(dead_code, non_camel_case_types)]
 
@@ -108,4 +109,19 @@ mod should_not_lint {
     }
 }
 
+mod check_expect_suppression {
+    use crate::T1;
+
+    struct S;
+
+    impl S {
+        #[expect(clippy::same_name_method)]
+        fn foo() {}
+    }
+
+    impl T1 for S {
+        fn foo() {}
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/same_name_method.stderr b/tests/ui/same_name_method.stderr
index cf06eb32e0c..f55ec9f3cc6 100644
--- a/tests/ui/same_name_method.stderr
+++ b/tests/ui/same_name_method.stderr
@@ -1,61 +1,61 @@
 error: method's name is the same as an existing method in a trait
-  --> $DIR/same_name_method.rs:20:13
+  --> $DIR/same_name_method.rs:21:13
    |
 LL |             fn foo() {}
    |             ^^^^^^^^^^^
    |
    = note: `-D clippy::same-name-method` implied by `-D warnings`
 note: existing `foo` defined here
-  --> $DIR/same_name_method.rs:24:13
+  --> $DIR/same_name_method.rs:25:13
    |
 LL |             fn foo() {}
    |             ^^^^^^^^^^^
 
 error: method's name is the same as an existing method in a trait
-  --> $DIR/same_name_method.rs:34:13
+  --> $DIR/same_name_method.rs:35:13
    |
 LL |             fn clone() {}
    |             ^^^^^^^^^^^^^
    |
 note: existing `clone` defined here
-  --> $DIR/same_name_method.rs:30:18
+  --> $DIR/same_name_method.rs:31:18
    |
 LL |         #[derive(Clone)]
    |                  ^^^^^
    = note: this error originates in the derive macro `Clone` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: method's name is the same as an existing method in a trait
-  --> $DIR/same_name_method.rs:44:13
+  --> $DIR/same_name_method.rs:45:13
    |
 LL |             fn foo() {}
    |             ^^^^^^^^^^^
    |
 note: existing `foo` defined here
-  --> $DIR/same_name_method.rs:48:13
+  --> $DIR/same_name_method.rs:49:13
    |
 LL |             fn foo() {}
    |             ^^^^^^^^^^^
 
 error: method's name is the same as an existing method in a trait
-  --> $DIR/same_name_method.rs:58:13
+  --> $DIR/same_name_method.rs:59:13
    |
 LL |             fn foo() {}
    |             ^^^^^^^^^^^
    |
 note: existing `foo` defined here
-  --> $DIR/same_name_method.rs:61:9
+  --> $DIR/same_name_method.rs:62:9
    |
 LL |         impl T1 for S {}
    |         ^^^^^^^^^^^^^^^^
 
 error: method's name is the same as an existing method in a trait
-  --> $DIR/same_name_method.rs:70:13
+  --> $DIR/same_name_method.rs:71:13
    |
 LL |             fn foo() {}
    |             ^^^^^^^^^^^
    |
 note: existing `foo` defined here
-  --> $DIR/same_name_method.rs:73:9
+  --> $DIR/same_name_method.rs:74:9
    |
 LL |         impl T1 for S {}
    |         ^^^^^^^^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From 8db734990be40e2acd59c2b20bf6e02343830fd6 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Mon, 6 Jun 2022 14:03:11 +0200
Subject: Fix `#[expect]` for `async_yields_async`

---
 clippy_lints/src/async_yields_async.rs |  5 +++--
 clippy_lints/src/same_name_method.rs   |  1 +
 tests/ui/async_yields_async.fixed      | 13 ++++++++++++-
 tests/ui/async_yields_async.rs         | 13 ++++++++++++-
 tests/ui/needless_borrow.fixed         |  1 +
 tests/ui/needless_borrow.rs            |  1 +
 6 files changed, 30 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/async_yields_async.rs b/clippy_lints/src/async_yields_async.rs
index 0619490e73c..d32724d040c 100644
--- a/clippy_lints/src/async_yields_async.rs
+++ b/clippy_lints/src/async_yields_async.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::diagnostics::span_lint_hir_and_then;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::implements_trait;
 use rustc_errors::Applicability;
@@ -63,9 +63,10 @@ impl<'tcx> LateLintPass<'tcx> for AsyncYieldsAsync {
                         _ => None,
                     };
                     if let Some(return_expr_span) = return_expr_span {
-                        span_lint_and_then(
+                        span_lint_hir_and_then(
                             cx,
                             ASYNC_YIELDS_ASYNC,
+                            body.value.hir_id,
                             return_expr_span,
                             "an async construct yields a type which is itself awaitable",
                             |db| {
diff --git a/clippy_lints/src/same_name_method.rs b/clippy_lints/src/same_name_method.rs
index 04d9ee7d912..73f8e083b29 100644
--- a/clippy_lints/src/same_name_method.rs
+++ b/clippy_lints/src/same_name_method.rs
@@ -47,6 +47,7 @@ struct ExistingName {
 }
 
 impl<'tcx> LateLintPass<'tcx> for SameNameMethod {
+    #[expect(clippy::too_many_lines)]
     fn check_crate_post(&mut self, cx: &LateContext<'tcx>) {
         let mut map = FxHashMap::<Res, ExistingName>::default();
 
diff --git a/tests/ui/async_yields_async.fixed b/tests/ui/async_yields_async.fixed
index e20b58269b9..3cf380d2b95 100644
--- a/tests/ui/async_yields_async.fixed
+++ b/tests/ui/async_yields_async.fixed
@@ -1,5 +1,5 @@
 // run-rustfix
-
+#![feature(lint_reasons)]
 #![feature(async_closure)]
 #![warn(clippy::async_yields_async)]
 
@@ -65,3 +65,14 @@ fn main() {
     let _n = async || custom_future_type_ctor();
     let _o = async || f();
 }
+
+#[rustfmt::skip]
+#[allow(dead_code)]
+fn check_expect_suppression() {
+    #[expect(clippy::async_yields_async)]
+    let _j = async || {
+        async {
+            3
+        }
+    };
+}
diff --git a/tests/ui/async_yields_async.rs b/tests/ui/async_yields_async.rs
index c1dfa398450..dd4131b60ab 100644
--- a/tests/ui/async_yields_async.rs
+++ b/tests/ui/async_yields_async.rs
@@ -1,5 +1,5 @@
 // run-rustfix
-
+#![feature(lint_reasons)]
 #![feature(async_closure)]
 #![warn(clippy::async_yields_async)]
 
@@ -65,3 +65,14 @@ fn main() {
     let _n = async || custom_future_type_ctor();
     let _o = async || f();
 }
+
+#[rustfmt::skip]
+#[allow(dead_code)]
+fn check_expect_suppression() {
+    #[expect(clippy::async_yields_async)]
+    let _j = async || {
+        async {
+            3
+        }
+    };
+}
diff --git a/tests/ui/needless_borrow.fixed b/tests/ui/needless_borrow.fixed
index 6b1576d6732..e7a483c0582 100644
--- a/tests/ui/needless_borrow.fixed
+++ b/tests/ui/needless_borrow.fixed
@@ -99,6 +99,7 @@ impl<'a> Trait for &'a str {}
 
 fn h(_: &dyn Trait) {}
 
+#[allow(dead_code)]
 fn check_expect_suppression() {
     let a = 5;
     #[expect(clippy::needless_borrow)]
diff --git a/tests/ui/needless_borrow.rs b/tests/ui/needless_borrow.rs
index ebe76361db4..1d6bf46405a 100644
--- a/tests/ui/needless_borrow.rs
+++ b/tests/ui/needless_borrow.rs
@@ -99,6 +99,7 @@ impl<'a> Trait for &'a str {}
 
 fn h(_: &dyn Trait) {}
 
+#[allow(dead_code)]
 fn check_expect_suppression() {
     let a = 5;
     #[expect(clippy::needless_borrow)]
-- 
cgit 1.4.1-3-g733a5


From fdadebe6721a0016b87063d7a54e48c3db6bab82 Mon Sep 17 00:00:00 2001
From: Serial <69764315+Serial-ATA@users.noreply.github.com>
Date: Sat, 28 May 2022 15:27:53 -0400
Subject: Add lint output to lint list

---
 Cargo.toml                                         |   2 +-
 clippy_lints/Cargo.toml                            |   4 +-
 clippy_lints/src/collapsible_if.rs                 |  12 +-
 clippy_lints/src/doc.rs                            |   4 +-
 clippy_lints/src/large_include_file.rs             |   3 +-
 clippy_lints/src/literal_representation.rs         |   1 +
 clippy_lints/src/methods/mod.rs                    |   1 +
 .../src/utils/internal_lints/metadata_collector.rs | 228 +++++++++++++++++++--
 tests/dogfood.rs                                   |   4 +-
 util/gh-pages/index.html                           |  20 ++
 10 files changed, 247 insertions(+), 32 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/Cargo.toml b/Cargo.toml
index d23d681df00..42455998fe7 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -59,7 +59,7 @@ rustc_tools_util = { version = "0.2", path = "rustc_tools_util" }
 [features]
 deny-warnings = ["clippy_lints/deny-warnings"]
 integration = ["tempfile"]
-internal = ["clippy_lints/internal"]
+internal = ["clippy_lints/internal", "tempfile"]
 
 [package.metadata.rust-analyzer]
 # This package uses #[feature(rustc_private)]
diff --git a/clippy_lints/Cargo.toml b/clippy_lints/Cargo.toml
index 0a3f04da357..eb4582b93f2 100644
--- a/clippy_lints/Cargo.toml
+++ b/clippy_lints/Cargo.toml
@@ -10,6 +10,7 @@ edition = "2021"
 
 [dependencies]
 cargo_metadata = "0.14"
+clippy_dev = { path = "../clippy_dev", optional = true }
 clippy_utils = { path = "../clippy_utils" }
 if_chain = "1.0"
 itertools = "0.10.1"
@@ -18,6 +19,7 @@ quine-mc_cluskey = "0.2"
 regex-syntax = "0.6"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = { version = "1.0", optional = true }
+tempfile = { version = "3.3.0", optional = true }
 toml = "0.5"
 unicode-normalization = "0.1"
 unicode-script = { version = "0.5", default-features = false }
@@ -30,7 +32,7 @@ url = { version = "2.2", features = ["serde"] }
 [features]
 deny-warnings = ["clippy_utils/deny-warnings"]
 # build clippy with internal lints enabled, off by default
-internal = ["clippy_utils/internal", "serde_json"]
+internal = ["clippy_utils/internal", "serde_json", "tempfile", "clippy_dev"]
 
 [package.metadata.rust-analyzer]
 # This crate uses #[feature(rustc_private)]
diff --git a/clippy_lints/src/collapsible_if.rs b/clippy_lints/src/collapsible_if.rs
index 3eceb848822..90430b71a0e 100644
--- a/clippy_lints/src/collapsible_if.rs
+++ b/clippy_lints/src/collapsible_if.rs
@@ -32,20 +32,20 @@ declare_clippy_lint! {
     /// makes code look more complex than it really is.
     ///
     /// ### Example
-    /// ```rust,ignore
+    /// ```rust
+    /// # let (x, y) = (true, true);
     /// if x {
     ///     if y {
-    ///         …
+    ///         // …
     ///     }
     /// }
-    ///
     /// ```
     ///
     /// Use instead:
-    ///
-    /// ```rust,ignore
+    /// ```rust
+    /// # let (x, y) = (true, true);
     /// if x && y {
-    ///     …
+    ///     // …
     /// }
     /// ```
     #[clippy::version = "pre 1.29.0"]
diff --git a/clippy_lints/src/doc.rs b/clippy_lints/src/doc.rs
index aaec88f50c7..bf8c810a3e7 100644
--- a/clippy_lints/src/doc.rs
+++ b/clippy_lints/src/doc.rs
@@ -178,7 +178,7 @@ declare_clippy_lint! {
     /// if the `fn main()` is left implicit.
     ///
     /// ### Examples
-    /// ``````rust
+    /// ```rust
     /// /// An example of a doctest with a `main()` function
     /// ///
     /// /// # Examples
@@ -191,7 +191,7 @@ declare_clippy_lint! {
     /// fn needless_main() {
     ///     unimplemented!();
     /// }
-    /// ``````
+    /// ```
     #[clippy::version = "1.40.0"]
     pub NEEDLESS_DOCTEST_MAIN,
     style,
diff --git a/clippy_lints/src/large_include_file.rs b/clippy_lints/src/large_include_file.rs
index 8bef13c682d..84dd61a1e4b 100644
--- a/clippy_lints/src/large_include_file.rs
+++ b/clippy_lints/src/large_include_file.rs
@@ -22,10 +22,11 @@ declare_clippy_lint! {
     /// let included_bytes = include_bytes!("very_large_file.txt");
     /// ```
     ///
-    /// Instead, you can load the file at runtime:
+    /// Use instead:
     /// ```rust,ignore
     /// use std::fs;
     ///
+    /// // You can load the file at runtime
     /// let string = fs::read_to_string("very_large_file.txt")?;
     /// let bytes = fs::read("very_large_file.txt")?;
     /// ```
diff --git a/clippy_lints/src/literal_representation.rs b/clippy_lints/src/literal_representation.rs
index 9998712b852..2a4e1262276 100644
--- a/clippy_lints/src/literal_representation.rs
+++ b/clippy_lints/src/literal_representation.rs
@@ -46,6 +46,7 @@ declare_clippy_lint! {
     /// - Does not match on `_127` since that is a valid grouping for decimal and octal numbers
     ///
     /// ### Example
+    /// ```ignore
     /// `2_32` => `2_i32`
     /// `250_8 => `250_u8`
     /// ```
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 7308e74c323..904454037ea 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1039,6 +1039,7 @@ declare_clippy_lint! {
     ///
     /// // Good
     /// _.split('x');
+    /// ```
     #[clippy::version = "pre 1.29.0"]
     pub SINGLE_CHAR_PATTERN,
     perf,
diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index cf2de6a42af..069d8374b26 100644
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -31,6 +31,8 @@ use std::fmt::Write as _;
 use std::fs::{self, OpenOptions};
 use std::io::prelude::*;
 use std::path::Path;
+use std::path::PathBuf;
+use std::process::Command;
 
 /// This is the output file of the lint collector.
 const OUTPUT_FILE: &str = "../util/gh-pages/lints.json";
@@ -180,6 +182,7 @@ pub struct MetadataCollector {
     lints: BinaryHeap<LintMetadata>,
     applicability_info: FxHashMap<String, ApplicabilityInfo>,
     config: Vec<ClippyConfiguration>,
+    clippy_project_root: PathBuf,
 }
 
 impl MetadataCollector {
@@ -188,6 +191,7 @@ impl MetadataCollector {
             lints: BinaryHeap::<LintMetadata>::default(),
             applicability_info: FxHashMap::<String, ApplicabilityInfo>::default(),
             config: collect_configs(),
+            clippy_project_root: clippy_dev::clippy_project_root(),
         }
     }
 
@@ -215,11 +219,13 @@ impl Drop for MetadataCollector {
 
         // Mapping the final data
         let mut lints = std::mem::take(&mut self.lints).into_sorted_vec();
-        collect_renames(&mut lints);
         for x in &mut lints {
             x.applicability = Some(applicability_info.remove(&x.id).unwrap_or_default());
+            replace_produces(&x.id, &mut x.docs, &self.clippy_project_root);
         }
 
+        collect_renames(&mut lints);
+
         // Outputting
         if Path::new(OUTPUT_FILE).exists() {
             fs::remove_file(OUTPUT_FILE).unwrap();
@@ -263,14 +269,193 @@ impl LintMetadata {
     }
 }
 
+fn replace_produces(lint_name: &str, docs: &mut String, clippy_project_root: &Path) {
+    let mut doc_lines = docs.lines().map(ToString::to_string).collect::<Vec<_>>();
+    let mut lines = doc_lines.iter_mut();
+
+    'outer: loop {
+        // Find the start of the example
+
+        // ```rust
+        loop {
+            match lines.next() {
+                Some(line) if line.trim_start().starts_with("```rust") => {
+                    if line.contains("ignore") || line.contains("no_run") {
+                        // A {{produces}} marker may have been put on a ignored code block by mistake,
+                        // just seek to the end of the code block and continue checking.
+                        if lines.any(|line| line.trim_start().starts_with("```")) {
+                            continue;
+                        }
+
+                        panic!("lint `{}` has an unterminated code block", lint_name)
+                    }
+
+                    break;
+                },
+                Some(line) if line.trim_start() == "{{produces}}" => {
+                    panic!(
+                        "lint `{}` has marker {{{{produces}}}} with an ignored or missing code block",
+                        lint_name
+                    )
+                },
+                Some(line) => {
+                    let line = line.trim();
+                    // These are the two most common markers of the corrections section
+                    if line.eq_ignore_ascii_case("Use instead:") || line.eq_ignore_ascii_case("Could be written as:") {
+                        break 'outer;
+                    }
+                },
+                None => break 'outer,
+            }
+        }
+
+        // Collect the example
+        let mut example = Vec::new();
+        loop {
+            match lines.next() {
+                Some(line) if line.trim_start() == "```" => break,
+                Some(line) => example.push(line),
+                None => panic!("lint `{}` has an unterminated code block", lint_name),
+            }
+        }
+
+        // Find the {{produces}} and attempt to generate the output
+        loop {
+            match lines.next() {
+                Some(line) if line.is_empty() => {},
+                Some(line) if line.trim() == "{{produces}}" => {
+                    let output = get_lint_output(lint_name, &example, clippy_project_root);
+                    line.replace_range(
+                        ..,
+                        &format!(
+                            "<details>\
+                            <summary>Produces</summary>\n\
+                            \n\
+                            ```text\n\
+                            {}\n\
+                            ```\n\
+                        </details>",
+                            output
+                        ),
+                    );
+
+                    break;
+                },
+                // No {{produces}}, we can move on to the next example
+                Some(_) => break,
+                None => break 'outer,
+            }
+        }
+    }
+
+    *docs = cleanup_docs(&doc_lines);
+}
+
+fn get_lint_output(lint_name: &str, example: &[&mut String], clippy_project_root: &Path) -> String {
+    let dir = tempfile::tempdir().unwrap_or_else(|e| panic!("failed to create temp dir: {e}"));
+    let file = dir.path().join("lint_example.rs");
+
+    let mut source = String::new();
+    let unhidden = example
+        .iter()
+        .map(|line| line.trim_start().strip_prefix("# ").unwrap_or(line));
+
+    // Get any attributes
+    let mut lines = unhidden.peekable();
+    while let Some(line) = lines.peek() {
+        if line.starts_with("#!") {
+            source.push_str(line);
+            source.push('\n');
+            lines.next();
+        } else {
+            break;
+        }
+    }
+
+    let needs_main = !example.iter().any(|line| line.contains("fn main"));
+    if needs_main {
+        source.push_str("fn main() {\n");
+    }
+
+    for line in lines {
+        source.push_str(line);
+        source.push('\n');
+    }
+
+    if needs_main {
+        source.push_str("}\n");
+    }
+
+    if let Err(e) = fs::write(&file, &source) {
+        panic!("failed to write to `{}`: {e}", file.as_path().to_string_lossy());
+    }
+
+    let prefixed_name = format!("{}{lint_name}", CLIPPY_LINT_GROUP_PREFIX);
+
+    let mut cmd = Command::new("cargo");
+
+    cmd.current_dir(clippy_project_root)
+        .env("CARGO_INCREMENTAL", "0")
+        .env("CLIPPY_ARGS", "")
+        .env("CLIPPY_DISABLE_DOCS_LINKS", "1")
+        // We need to disable this to enable all lints
+        .env("ENABLE_METADATA_COLLECTION", "0")
+        .args(["run", "--bin", "clippy-driver"])
+        .args(["--target-dir", "./clippy_lints/target"])
+        .args(["--", "--error-format=json"])
+        .args(["--edition", "2021"])
+        .arg("-Cdebuginfo=0")
+        .args(["-A", "clippy::all"])
+        .args(["-W", &prefixed_name])
+        .args(["-L", "./target/debug"])
+        .args(["-Z", "no-codegen"]);
+
+    let output = cmd
+        .arg(file.as_path())
+        .output()
+        .unwrap_or_else(|e| panic!("failed to run `{:?}`: {e}", cmd));
+
+    let tmp_file_path = file.to_string_lossy();
+    let stderr = std::str::from_utf8(&output.stderr).unwrap();
+    let msgs = stderr
+        .lines()
+        .filter(|line| line.starts_with('{'))
+        .map(|line| serde_json::from_str(line).unwrap())
+        .collect::<Vec<serde_json::Value>>();
+
+    let mut rendered = String::new();
+    let iter = msgs
+        .iter()
+        .filter(|msg| matches!(&msg["code"]["code"], serde_json::Value::String(s) if s == &prefixed_name));
+
+    for message in iter {
+        let rendered_part = message["rendered"].as_str().expect("rendered field should exist");
+        rendered.push_str(rendered_part);
+    }
+
+    if rendered.is_empty() {
+        let rendered: Vec<&str> = msgs.iter().filter_map(|msg| msg["rendered"].as_str()).collect();
+        let non_json: Vec<&str> = stderr.lines().filter(|line| !line.starts_with('{')).collect();
+        panic!(
+            "did not find lint `{}` in output of example, got:\n{}\n{}",
+            lint_name,
+            non_json.join("\n"),
+            rendered.join("\n")
+        );
+    }
+
+    // The reader doesn't need to see `/tmp/.tmpfiy2Qd/lint_example.rs` :)
+    rendered.trim_end().replace(&*tmp_file_path, "lint_example.rs")
+}
+
 #[derive(Debug, Clone, Serialize, PartialEq, Eq, PartialOrd, Ord)]
 struct SerializableSpan {
     path: String,
     line: usize,
 }
 
-impl std::fmt::Display for SerializableSpan {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl fmt::Display for SerializableSpan {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "{}:{}", self.path.rsplit('/').next().unwrap_or_default(), self.line)
     }
 }
@@ -435,10 +620,10 @@ impl<'hir> LateLintPass<'hir> for MetadataCollector {
                 if !BLACK_LISTED_LINTS.contains(&lint_name.as_str());
                 // metadata extraction
                 if let Some((group, level)) = get_lint_group_and_level_or_lint(cx, &lint_name, item);
-                if let Some(mut docs) = extract_attr_docs_or_lint(cx, item);
+                if let Some(mut raw_docs) = extract_attr_docs_or_lint(cx, item);
                 then {
                     if let Some(configuration_section) = self.get_lint_configs(&lint_name) {
-                        docs.push_str(&configuration_section);
+                        raw_docs.push_str(&configuration_section);
                     }
                     let version = get_lint_version(cx, item);
 
@@ -448,7 +633,7 @@ impl<'hir> LateLintPass<'hir> for MetadataCollector {
                         group,
                         level,
                         version,
-                        docs,
+                        raw_docs,
                     ));
                 }
             }
@@ -459,7 +644,7 @@ impl<'hir> LateLintPass<'hir> for MetadataCollector {
                 let lint_name = sym_to_string(item.ident.name).to_ascii_lowercase();
                 if !BLACK_LISTED_LINTS.contains(&lint_name.as_str());
                 // Metadata the little we can get from a deprecated lint
-                if let Some(docs) = extract_attr_docs_or_lint(cx, item);
+                if let Some(raw_docs) = extract_attr_docs_or_lint(cx, item);
                 then {
                     let version = get_lint_version(cx, item);
 
@@ -469,7 +654,7 @@ impl<'hir> LateLintPass<'hir> for MetadataCollector {
                         DEPRECATED_LINT_GROUP_STR.to_string(),
                         DEPRECATED_LINT_LEVEL,
                         version,
-                        docs,
+                        raw_docs,
                     ));
                 }
             }
@@ -535,22 +720,28 @@ fn extract_attr_docs_or_lint(cx: &LateContext<'_>, item: &Item<'_>) -> Option<St
 /// ```
 ///
 /// Would result in `Hello world!\n=^.^=\n`
-///
-/// ---
-///
+fn extract_attr_docs(cx: &LateContext<'_>, item: &Item<'_>) -> Option<String> {
+    let attrs = cx.tcx.hir().attrs(item.hir_id());
+    let mut lines = attrs.iter().filter_map(ast::Attribute::doc_str);
+
+    if let Some(line) = lines.next() {
+        let raw_docs = lines.fold(String::from(line.as_str()) + "\n", |s, line| s + line.as_str() + "\n");
+        return Some(raw_docs);
+    }
+
+    None
+}
+
 /// This function may modify the doc comment to ensure that the string can be displayed using a
 /// markdown viewer in Clippy's lint list. The following modifications could be applied:
 /// * Removal of leading space after a new line. (Important to display tables)
 /// * Ensures that code blocks only contain language information
-fn extract_attr_docs(cx: &LateContext<'_>, item: &Item<'_>) -> Option<String> {
-    let attrs = cx.tcx.hir().attrs(item.hir_id());
-    let mut lines = attrs.iter().filter_map(ast::Attribute::doc_str);
-    let mut docs = String::from(lines.next()?.as_str());
+fn cleanup_docs(docs_collection: &Vec<String>) -> String {
     let mut in_code_block = false;
     let mut is_code_block_rust = false;
-    for line in lines {
-        let line = line.as_str();
 
+    let mut docs = String::new();
+    for line in docs_collection {
         // Rustdoc hides code lines starting with `# ` and this removes them from Clippy's lint list :)
         if is_code_block_rust && line.trim_start().starts_with("# ") {
             continue;
@@ -583,7 +774,8 @@ fn extract_attr_docs(cx: &LateContext<'_>, item: &Item<'_>) -> Option<String> {
             docs.push_str(line);
         }
     }
-    Some(docs)
+
+    docs
 }
 
 fn get_lint_version(cx: &LateContext<'_>, item: &Item<'_>) -> String {
diff --git a/tests/dogfood.rs b/tests/dogfood.rs
index 9da80518ce9..fffc5360342 100644
--- a/tests/dogfood.rs
+++ b/tests/dogfood.rs
@@ -21,7 +21,7 @@ fn dogfood_clippy() {
 
     // "" is the root package
     for package in &["", "clippy_dev", "clippy_lints", "clippy_utils", "rustc_tools_util"] {
-        run_clippy_for_package(package, &[]);
+        run_clippy_for_package(package, &["-D", "clippy::all", "-D", "clippy::pedantic"]);
     }
 }
 
@@ -77,8 +77,6 @@ fn run_clippy_for_package(project: &str, args: &[&str]) {
         .arg("--all-features")
         .arg("--")
         .args(args)
-        .args(&["-D", "clippy::all"])
-        .args(&["-D", "clippy::pedantic"])
         .arg("-Cdebuginfo=0"); // disable debuginfo to generate less data in the target dir
 
     if cfg!(feature = "internal") {
diff --git a/util/gh-pages/index.html b/util/gh-pages/index.html
index 2076d129978..4999cce7511 100644
--- a/util/gh-pages/index.html
+++ b/util/gh-pages/index.html
@@ -206,6 +206,26 @@ Otherwise, have a great day =^.^=
             margin: auto 5px;
             font-family: monospace;
         }
+
+        details {
+            border-radius: 4px;
+            padding: .5em .5em 0;
+        }
+
+        code {
+            white-space: pre !important;
+        }
+
+        summary {
+            font-weight: bold;
+            margin: -.5em -.5em 0;
+            padding: .5em;
+            display: revert;
+        }
+
+        details[open] {
+            padding: .5em;
+        }
     </style>
     <style>
         /* Expanding the mdBoom theme*/
-- 
cgit 1.4.1-3-g733a5


From cab5362d3258c14dc4f1763a494827b61e997ebb Mon Sep 17 00:00:00 2001
From: Serial <69764315+Serial-ATA@users.noreply.github.com>
Date: Mon, 6 Jun 2022 20:28:16 -0400
Subject: Suppress `unused` in doc examples

---
 clippy_lints/src/casts/mod.rs             | 18 +++++----------
 clippy_lints/src/checked_conversions.rs   | 12 ++++------
 clippy_lints/src/indexing_slicing.rs      |  6 ++---
 clippy_lints/src/infinite_iter.rs         |  2 +-
 clippy_lints/src/methods/mod.rs           | 37 ++++++++++++-------------------
 clippy_lints/src/needless_borrowed_ref.rs |  4 ++--
 clippy_lints/src/ranges.rs                |  6 ++---
 clippy_lints/src/strings.rs               |  2 --
 clippy_lints/src/write.rs                 |  6 -----
 9 files changed, 31 insertions(+), 62 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index fe8e372b6f5..74ea70d1af1 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -220,15 +220,13 @@ declare_clippy_lint! {
     /// ### Example
     /// ```rust
     /// fn fun() -> i32 { 1 }
-    /// # let _ =
-    /// fun as i64;
+    /// let _ = fun as i64;
     /// ```
     ///
     /// Use instead:
     /// ```rust
     /// # fn fun() -> i32 { 1 }
-    /// # let _ =
-    /// fun as usize;
+    /// let _ = fun as usize;
     /// ```
     #[clippy::version = "pre 1.29.0"]
     pub FN_TO_NUMERIC_CAST,
@@ -251,8 +249,7 @@ declare_clippy_lint! {
     /// fn fn1() -> i16 {
     ///     1
     /// };
-    /// # let _ =
-    /// fn1 as i32;
+    /// let _ = fn1 as i32;
     /// ```
     ///
     /// Use instead:
@@ -287,8 +284,7 @@ declare_clippy_lint! {
     /// fn fn1() -> u16 {
     ///     1
     /// };
-    /// # let _ =
-    /// fn1 as usize;
+    /// let _ = fn1 as usize;
     /// ```
     ///
     /// Use instead:
@@ -297,8 +293,7 @@ declare_clippy_lint! {
     /// fn fn2() -> u16 {
     ///     1
     /// };
-    /// # let _ =
-    /// fn2() as usize;
+    /// let _ = fn2() as usize;
     ///
     /// // or
     ///
@@ -306,8 +301,7 @@ declare_clippy_lint! {
     /// fn fn3() -> u16 {
     ///     1
     /// }
-    /// # let _ =
-    /// fn3 as fn() -> u16;
+    /// let _ = fn3 as fn() -> u16;
     /// ```
     #[clippy::version = "1.58.0"]
     pub FN_TO_NUMERIC_CAST_ANY,
diff --git a/clippy_lints/src/checked_conversions.rs b/clippy_lints/src/checked_conversions.rs
index 1010340c712..4b99d1d614e 100644
--- a/clippy_lints/src/checked_conversions.rs
+++ b/clippy_lints/src/checked_conversions.rs
@@ -22,18 +22,14 @@ declare_clippy_lint! {
     /// ### Example
     /// ```rust
     /// # let foo: u32 = 5;
-    /// # let _ =
-    /// foo <= i32::MAX as u32
-    /// # ;
+    /// foo <= i32::MAX as u32;
     /// ```
     ///
-    /// Could be written:
-    ///
+    /// Use instead:
     /// ```rust
     /// # let foo = 1;
-    /// # let _ =
-    /// i32::try_from(foo).is_ok()
-    /// # ;
+    /// # #[allow(unused)]
+    /// i32::try_from(foo).is_ok();
     /// ```
     #[clippy::version = "1.37.0"]
     pub CHECKED_CONVERSIONS,
diff --git a/clippy_lints/src/indexing_slicing.rs b/clippy_lints/src/indexing_slicing.rs
index 301686612a1..4a375752e1d 100644
--- a/clippy_lints/src/indexing_slicing.rs
+++ b/clippy_lints/src/indexing_slicing.rs
@@ -67,16 +67,14 @@ declare_clippy_lint! {
     ///
     /// Use instead:
     /// ```rust
+    /// # #![allow(unused)]
+    ///
     /// # let x = vec![0; 5];
     /// # let y = [0, 1, 2, 3];
-    /// # let _ =
     /// x.get(2);
-    /// # let _ =
     /// x.get(2..100);
     ///
-    /// # let _ =
     /// y.get(10);
-    /// # let _ =
     /// y.get(10..100);
     /// ```
     #[clippy::version = "pre 1.29.0"]
diff --git a/clippy_lints/src/infinite_iter.rs b/clippy_lints/src/infinite_iter.rs
index fc8e473dd9e..27fa9042269 100644
--- a/clippy_lints/src/infinite_iter.rs
+++ b/clippy_lints/src/infinite_iter.rs
@@ -41,7 +41,7 @@ declare_clippy_lint! {
     /// ### Example
     /// ```rust
     /// let infinite_iter = 0..;
-    /// # let _ =
+    /// # #[allow(unused)]
     /// [0..].iter().zip(infinite_iter.take_while(|x| *x > 5));
     /// ```
     #[clippy::version = "pre 1.29.0"]
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 9d78f0a9fc1..e1ea8426e58 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -131,18 +131,14 @@ declare_clippy_lint! {
     /// ### Examples
     /// ```rust
     /// # let vec = vec!["string".to_string()];
-    /// # let _ =
     /// vec.iter().cloned().take(10);
-    /// # let _ =
     /// vec.iter().cloned().last();
     /// ```
     ///
     /// Use instead:
     /// ```rust
     /// # let vec = vec!["string".to_string()];
-    /// # let _ =
     /// vec.iter().take(10).cloned();
-    /// # let _ =
     /// vec.iter().last().cloned();
     /// ```
     #[clippy::version = "1.59.0"]
@@ -590,7 +586,6 @@ declare_clippy_lint! {
     /// let vec = vec![vec![1]];
     /// let opt = Some(5);
     ///
-    /// # let _ =
     /// vec.iter().map(|x| x.iter()).flatten();
     /// opt.map(|x| Some(x * 2)).flatten();
     /// ```
@@ -599,7 +594,6 @@ declare_clippy_lint! {
     /// ```rust
     /// # let vec = vec![vec![1]];
     /// # let opt = Some(5);
-    /// # let _ =
     /// vec.iter().flat_map(|x| x.iter());
     /// opt.and_then(|x| Some(x * 2));
     /// ```
@@ -620,7 +614,7 @@ declare_clippy_lint! {
     ///
      /// ### Example
     /// ```rust
-    /// # let  _ =
+    /// # #![allow(unused)]
     /// (0_i32..10)
     ///     .filter(|n| n.checked_add(1).is_some())
     ///     .map(|n| n.checked_add(1).unwrap());
@@ -628,7 +622,7 @@ declare_clippy_lint! {
     ///
     /// Use instead:
     /// ```rust
-    /// # let _ =
+    /// # #[allow(unused)]
     /// (0_i32..10).filter_map(|n| n.checked_add(1));
     /// ```
     #[clippy::version = "1.51.0"]
@@ -721,11 +715,10 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust
+    /// # #![allow(unused)]
     /// let vec = vec![1];
-    /// # let _ =
     /// vec.iter().find(|x| **x == 0).is_some();
     ///
-    /// # let _ =
     /// "hello world".find("world").is_none();
     /// ```
     ///
@@ -734,7 +727,7 @@ declare_clippy_lint! {
     /// let vec = vec![1];
     /// vec.iter().any(|x| *x == 0);
     ///
-    /// # let _ =
+    /// # #[allow(unused)]
     /// !"hello world".contains("world");
     /// ```
     #[clippy::version = "pre 1.29.0"]
@@ -1428,13 +1421,12 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust
-    /// # let _ =
+    /// # #[allow(unused)]
     /// (0..3).fold(false, |acc, x| acc || x > 2);
     /// ```
     ///
     /// Use instead:
     /// ```rust
-    /// # let _ =
     /// (0..3).any(|x| x > 2);
     /// ```
     #[clippy::version = "pre 1.29.0"]
@@ -1515,14 +1507,14 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust
-    /// # let _ =
-    /// (&vec![3, 4, 5]).into_iter();
+    /// # let vec = vec![3, 4, 5];
+    /// (&vec).into_iter();
     /// ```
     ///
     /// Use instead:
     /// ```rust
-    /// # let _ =
-    /// (&vec![3, 4, 5]).iter();
+    /// # let vec = vec![3, 4, 5];
+    /// (&vec).iter();
     /// ```
     #[clippy::version = "1.32.0"]
     pub INTO_ITER_ON_REF,
@@ -1931,13 +1923,13 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust
-    /// # let _ =
+    /// # #[allow(unused)]
     /// "Hello".bytes().nth(3);
     /// ```
     ///
     /// Use instead:
     /// ```rust
-    /// # let _ =
+    /// # #[allow(unused)]
     /// "Hello".as_bytes().get(3);
     /// ```
     #[clippy::version = "1.52.0"]
@@ -1982,19 +1974,18 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust
+    /// # #![allow(unused)]
     /// let some_vec = vec![0, 1, 2, 3];
-    /// # let _ =
+    ///
     /// some_vec.iter().count();
-    /// # let _ =
     /// &some_vec[..].iter().count();
     /// ```
     ///
     /// Use instead:
     /// ```rust
     /// let some_vec = vec![0, 1, 2, 3];
-    /// # let _ =
+    ///
     /// some_vec.len();
-    /// # let _ =
     /// &some_vec[..].len();
     /// ```
     #[clippy::version = "1.52.0"]
diff --git a/clippy_lints/src/needless_borrowed_ref.rs b/clippy_lints/src/needless_borrowed_ref.rs
index 55da6e0f0a3..05c012b92e8 100644
--- a/clippy_lints/src/needless_borrowed_ref.rs
+++ b/clippy_lints/src/needless_borrowed_ref.rs
@@ -29,14 +29,14 @@ declare_clippy_lint! {
     /// ### Example
     /// ```rust
     /// let mut v = Vec::<String>::new();
-    /// # let _ =
+    /// # #[allow(unused)]
     /// v.iter_mut().filter(|&ref a| a.is_empty());
     /// ```
     ///
     /// Use instead:
     /// ```rust
     /// let mut v = Vec::<String>::new();
-    /// # let _ =
+    /// # #[allow(unused)]
     /// v.iter_mut().filter(|a| a.is_empty());
     /// ```
     #[clippy::version = "pre 1.29.0"]
diff --git a/clippy_lints/src/ranges.rs b/clippy_lints/src/ranges.rs
index be7eae02687..056637c2048 100644
--- a/clippy_lints/src/ranges.rs
+++ b/clippy_lints/src/ranges.rs
@@ -27,15 +27,13 @@ declare_clippy_lint! {
     /// ### Example
     /// ```rust
     /// # let x = vec![1];
-    /// # let _ =
-    /// x.iter().zip(0..x.len());
+    /// let _ = x.iter().zip(0..x.len());
     /// ```
     ///
     /// Use instead:
     /// ```rust
     /// # let x = vec![1];
-    /// # let _ =
-    /// x.iter().enumerate();
+    /// let _ = x.iter().enumerate();
     /// ```
     #[clippy::version = "pre 1.29.0"]
     pub RANGE_ZIP_WITH_LEN,
diff --git a/clippy_lints/src/strings.rs b/clippy_lints/src/strings.rs
index 9ea2de001e2..71f3e6b6a6e 100644
--- a/clippy_lints/src/strings.rs
+++ b/clippy_lints/src/strings.rs
@@ -224,13 +224,11 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust
-    /// # let _ =
     /// std::str::from_utf8(&"Hello World!".as_bytes()[6..11]).unwrap();
     /// ```
     ///
     /// Use instead:
     /// ```rust
-    /// # let _ =
     /// &"Hello World!"[6..11];
     /// ```
     #[clippy::version = "1.50.0"]
diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs
index bb74f2a7f0f..67b2bc8c3f3 100644
--- a/clippy_lints/src/write.rs
+++ b/clippy_lints/src/write.rs
@@ -178,7 +178,6 @@ declare_clippy_lint! {
     /// ```rust
     /// # use std::fmt::Write;
     /// # let mut buf = String::new();
-    /// # let _ =
     /// writeln!(buf, "");
     /// ```
     ///
@@ -186,7 +185,6 @@ declare_clippy_lint! {
     /// ```rust
     /// # use std::fmt::Write;
     /// # let mut buf = String::new();
-    /// # let _ =
     /// writeln!(buf);
     /// ```
     #[clippy::version = "pre 1.29.0"]
@@ -210,7 +208,6 @@ declare_clippy_lint! {
     /// # use std::fmt::Write;
     /// # let mut buf = String::new();
     /// # let name = "World";
-    /// # let _ =
     /// write!(buf, "Hello {}!\n", name);
     /// ```
     ///
@@ -219,7 +216,6 @@ declare_clippy_lint! {
     /// # use std::fmt::Write;
     /// # let mut buf = String::new();
     /// # let name = "World";
-    /// # let _ =
     /// writeln!(buf, "Hello {}!", name);
     /// ```
     #[clippy::version = "pre 1.29.0"]
@@ -245,7 +241,6 @@ declare_clippy_lint! {
     /// ```rust
     /// # use std::fmt::Write;
     /// # let mut buf = String::new();
-    /// # let _ =
     /// writeln!(buf, "{}", "foo");
     /// ```
     ///
@@ -253,7 +248,6 @@ declare_clippy_lint! {
     /// ```rust
     /// # use std::fmt::Write;
     /// # let mut buf = String::new();
-    /// # let _ =
     /// writeln!(buf, "foo");
     /// ```
     #[clippy::version = "pre 1.29.0"]
-- 
cgit 1.4.1-3-g733a5


From bf3ab592f04fafd854190f6960510bf0c23ef8ae Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Tue, 7 Jun 2022 00:40:32 -0400
Subject: Changes to `iter_overeager_cloned` * Don't lint on
 `.cloned().flatten()` when `T::Item` doesn't implement `IntoIterator` *
 Reduce verbosity of lint message * Narrow down the scope of the replacement
 range

---
 clippy_lints/src/methods/iter_overeager_cloned.rs | 97 ++++++++++-------------
 clippy_lints/src/methods/mod.rs                   | 24 +++---
 clippy_utils/src/ty.rs                            |  4 +-
 tests/ui/iter_overeager_cloned.fixed              |  6 +-
 tests/ui/iter_overeager_cloned.rs                 |  3 +
 tests/ui/iter_overeager_cloned.stderr             | 42 ++++++----
 6 files changed, 92 insertions(+), 84 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/iter_overeager_cloned.rs b/clippy_lints/src/methods/iter_overeager_cloned.rs
index 54c9ca435a4..06a39c5997e 100644
--- a/clippy_lints/src/methods/iter_overeager_cloned.rs
+++ b/clippy_lints/src/methods/iter_overeager_cloned.rs
@@ -1,70 +1,59 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::source::snippet;
-use clippy_utils::ty::{get_iterator_item_ty, implements_trait, is_copy};
-use itertools::Itertools;
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::source::snippet_opt;
+use clippy_utils::ty::{get_associated_type, implements_trait, is_copy};
 use rustc_errors::Applicability;
-use rustc_hir as hir;
+use rustc_hir::Expr;
 use rustc_lint::LateContext;
 use rustc_middle::ty;
 use rustc_span::sym;
-use std::ops::Not;
 
 use super::ITER_OVEREAGER_CLONED;
 use crate::redundant_clone::REDUNDANT_CLONE;
 
-/// lint overeager use of `cloned()` for `Iterator`s
 pub(super) fn check<'tcx>(
     cx: &LateContext<'tcx>,
-    expr: &'tcx hir::Expr<'_>,
-    recv: &'tcx hir::Expr<'_>,
-    name: &str,
-    map_arg: &[hir::Expr<'_>],
+    expr: &'tcx Expr<'_>,
+    cloned_call: &'tcx Expr<'_>,
+    cloned_recv: &'tcx Expr<'_>,
+    is_count: bool,
+    needs_into_iter: bool,
 ) {
-    // Check if it's iterator and get type associated with `Item`.
-    let inner_ty = if_chain! {
-        if let Some(iterator_trait_id) = cx.tcx.get_diagnostic_item(sym::Iterator);
-        let recv_ty = cx.typeck_results().expr_ty(recv);
-        if implements_trait(cx, recv_ty, iterator_trait_id, &[]);
-        if let Some(inner_ty) = get_iterator_item_ty(cx, cx.typeck_results().expr_ty_adjusted(recv));
-        then {
-            inner_ty
-        } else {
+    let typeck = cx.typeck_results();
+    if let Some(iter_id) = cx.tcx.get_diagnostic_item(sym::Iterator)
+        && let Some(method_id) = typeck.type_dependent_def_id(expr.hir_id)
+        && cx.tcx.trait_of_item(method_id) == Some(iter_id)
+        && let Some(method_id) = typeck.type_dependent_def_id(cloned_call.hir_id)
+        && cx.tcx.trait_of_item(method_id) == Some(iter_id)
+        && let cloned_recv_ty = typeck.expr_ty_adjusted(cloned_recv)
+        && let Some(iter_assoc_ty) = get_associated_type(cx, cloned_recv_ty, iter_id, "Item")
+        && matches!(*iter_assoc_ty.kind(), ty::Ref(_, ty, _) if !is_copy(cx, ty))
+    {
+        if needs_into_iter
+            && let Some(into_iter_id) = cx.tcx.get_diagnostic_item(sym::IntoIterator)
+            && !implements_trait(cx, iter_assoc_ty, into_iter_id, &[])
+        {
             return;
         }
-    };
-
-    match inner_ty.kind() {
-        ty::Ref(_, ty, _) if !is_copy(cx, *ty) => {},
-        _ => return,
-    };
 
-    let (lint, preserve_cloned) = match name {
-        "count" => (REDUNDANT_CLONE, false),
-        _ => (ITER_OVEREAGER_CLONED, true),
-    };
-    let wildcard_params = map_arg.is_empty().not().then(|| "...").unwrap_or_default();
-    let msg = format!(
-        "called `cloned().{}({})` on an `Iterator`. It may be more efficient to call `{}({}){}` instead",
-        name,
-        wildcard_params,
-        name,
-        wildcard_params,
-        preserve_cloned.then(|| ".cloned()").unwrap_or_default(),
-    );
+        let (lint, msg, trailing_clone) = if is_count {
+            (REDUNDANT_CLONE, "unneeded cloning of iterator items", "")
+        } else {
+            (ITER_OVEREAGER_CLONED, "unnecessarily eager cloning of iterator items", ".cloned()")
+        };
 
-    span_lint_and_sugg(
-        cx,
-        lint,
-        expr.span,
-        &msg,
-        "try this",
-        format!(
-            "{}.{}({}){}",
-            snippet(cx, recv.span, ".."),
-            name,
-            map_arg.iter().map(|a| snippet(cx, a.span, "..")).join(", "),
-            preserve_cloned.then(|| ".cloned()").unwrap_or_default(),
-        ),
-        Applicability::MachineApplicable,
-    );
+        span_lint_and_then(
+            cx,
+            lint,
+            expr.span,
+            msg,
+            |diag| {
+                let method_span = expr.span.with_lo(cloned_call.span.hi());
+                if let Some(mut snip) = snippet_opt(cx, method_span) {
+                    snip.push_str(trailing_clone);
+                    let replace_span = expr.span.with_lo(cloned_recv.span.hi());
+                    diag.span_suggestion(replace_span, "try this", snip, Applicability::MachineApplicable);
+                }
+            }
+        );
+    }
 }
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 7308e74c323..2ebfcb7a5fe 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -2583,8 +2583,8 @@ impl Methods {
                     },
                     _ => {},
                 },
-                (name @ "count", args @ []) => match method_call(recv) {
-                    Some(("cloned", [recv2], _)) => iter_overeager_cloned::check(cx, expr, recv2, name, args),
+                ("count", []) => match method_call(recv) {
+                    Some(("cloned", [recv2], _)) => iter_overeager_cloned::check(cx, expr, recv, recv2, true, false),
                     Some((name2 @ ("into_iter" | "iter" | "iter_mut"), [recv2], _)) => {
                         iter_count::check(cx, expr, recv2, name2);
                     },
@@ -2614,9 +2614,9 @@ impl Methods {
                     flat_map_identity::check(cx, expr, arg, span);
                     flat_map_option::check(cx, expr, arg, span);
                 },
-                (name @ "flatten", args @ []) => match method_call(recv) {
+                ("flatten", []) => match method_call(recv) {
                     Some(("map", [recv, map_arg], map_span)) => map_flatten::check(cx, expr, recv, map_arg, map_span),
-                    Some(("cloned", [recv2], _)) => iter_overeager_cloned::check(cx, expr, recv2, name, args),
+                    Some(("cloned", [recv2], _)) => iter_overeager_cloned::check(cx, expr, recv, recv2, false, true),
                     _ => {},
                 },
                 ("fold", [init, acc]) => unnecessary_fold::check(cx, expr, init, acc, span),
@@ -2636,10 +2636,10 @@ impl Methods {
                         unnecessary_join::check(cx, expr, recv, join_arg, span);
                     }
                 },
-                ("last", args @ []) | ("skip", args @ [_]) => {
+                ("last", []) | ("skip", [_]) => {
                     if let Some((name2, [recv2, args2 @ ..], _span2)) = method_call(recv) {
                         if let ("cloned", []) = (name2, args2) {
-                            iter_overeager_cloned::check(cx, expr, recv2, name, args);
+                            iter_overeager_cloned::check(cx, expr, recv, recv2, false, false);
                         }
                     }
                 },
@@ -2660,10 +2660,10 @@ impl Methods {
                     map_identity::check(cx, expr, recv, m_arg, name, span);
                 },
                 ("map_or", [def, map]) => option_map_or_none::check(cx, expr, recv, def, map),
-                (name @ "next", args @ []) => {
+                ("next", []) => {
                     if let Some((name2, [recv2, args2 @ ..], _)) = method_call(recv) {
                         match (name2, args2) {
-                            ("cloned", []) => iter_overeager_cloned::check(cx, expr, recv2, name, args),
+                            ("cloned", []) => iter_overeager_cloned::check(cx, expr, recv, recv2, false, false),
                             ("filter", [arg]) => filter_next::check(cx, expr, recv2, arg),
                             ("filter_map", [arg]) => filter_map_next::check(cx, expr, recv2, arg, self.msrv),
                             ("iter", []) => iter_next_slice::check(cx, expr, recv2),
@@ -2673,9 +2673,9 @@ impl Methods {
                         }
                     }
                 },
-                ("nth", args @ [n_arg]) => match method_call(recv) {
+                ("nth", [n_arg]) => match method_call(recv) {
                     Some(("bytes", [recv2], _)) => bytes_nth::check(cx, expr, recv2, n_arg),
-                    Some(("cloned", [recv2], _)) => iter_overeager_cloned::check(cx, expr, recv2, name, args),
+                    Some(("cloned", [recv2], _)) => iter_overeager_cloned::check(cx, expr, recv, recv2, false, false),
                     Some(("iter", [recv2], _)) => iter_nth::check(cx, expr, recv2, recv, n_arg, false),
                     Some(("iter_mut", [recv2], _)) => iter_nth::check(cx, expr, recv2, recv, n_arg, true),
                     _ => iter_nth_zero::check(cx, expr, recv, n_arg),
@@ -2698,10 +2698,10 @@ impl Methods {
                     }
                 },
                 ("step_by", [arg]) => iterator_step_by_zero::check(cx, expr, arg),
-                ("take", args @ [_arg]) => {
+                ("take", [_arg]) => {
                     if let Some((name2, [recv2, args2 @ ..], _span2)) = method_call(recv) {
                         if let ("cloned", []) = (name2, args2) {
-                            iter_overeager_cloned::check(cx, expr, recv2, name, args);
+                            iter_overeager_cloned::check(cx, expr, recv, recv2, false, false);
                         }
                     }
                 },
diff --git a/clippy_utils/src/ty.rs b/clippy_utils/src/ty.rs
index a10515d2fec..227e97d37ec 100644
--- a/clippy_utils/src/ty.rs
+++ b/clippy_utils/src/ty.rs
@@ -78,9 +78,9 @@ pub fn get_associated_type<'tcx>(
     cx.tcx
         .associated_items(trait_id)
         .find_by_name_and_kind(cx.tcx, Ident::from_str(name), ty::AssocKind::Type, trait_id)
-        .map(|assoc| {
+        .and_then(|assoc| {
             let proj = cx.tcx.mk_projection(assoc.def_id, cx.tcx.mk_substs_trait(ty, &[]));
-            cx.tcx.normalize_erasing_regions(cx.param_env, proj)
+            cx.tcx.try_normalize_erasing_regions(cx.param_env, proj).ok()
         })
 }
 
diff --git a/tests/ui/iter_overeager_cloned.fixed b/tests/ui/iter_overeager_cloned.fixed
index 7c2b05d837b..c100705d017 100644
--- a/tests/ui/iter_overeager_cloned.fixed
+++ b/tests/ui/iter_overeager_cloned.fixed
@@ -18,7 +18,8 @@ fn main() {
     let _ = vec.iter().filter(|x| x == &"2").nth(2).cloned();
 
     let _ = [Some(Some("str".to_string())), Some(Some("str".to_string()))]
-        .iter().flatten().cloned();
+        .iter()
+        .flatten().cloned();
 
     // Not implemented yet
     let _ = vec.iter().cloned().filter(|x| x.starts_with('2'));
@@ -43,6 +44,9 @@ fn main() {
 
     // Should probably stay as it is.
     let _ = [0, 1, 2, 3, 4].iter().cloned().take(10);
+
+    // `&Range<_>` doesn't implement `IntoIterator`
+    let _ = [0..1, 2..5].iter().cloned().flatten();
 }
 
 // #8527
diff --git a/tests/ui/iter_overeager_cloned.rs b/tests/ui/iter_overeager_cloned.rs
index f2d0b155d2c..2caa8802066 100644
--- a/tests/ui/iter_overeager_cloned.rs
+++ b/tests/ui/iter_overeager_cloned.rs
@@ -45,6 +45,9 @@ fn main() {
 
     // Should probably stay as it is.
     let _ = [0, 1, 2, 3, 4].iter().cloned().take(10);
+
+    // `&Range<_>` doesn't implement `IntoIterator`
+    let _ = [0..1, 2..5].iter().cloned().flatten();
 }
 
 // #8527
diff --git a/tests/ui/iter_overeager_cloned.stderr b/tests/ui/iter_overeager_cloned.stderr
index 0582700fd16..dcae7cecd33 100644
--- a/tests/ui/iter_overeager_cloned.stderr
+++ b/tests/ui/iter_overeager_cloned.stderr
@@ -1,44 +1,56 @@
-error: called `cloned().last()` on an `Iterator`. It may be more efficient to call `last().cloned()` instead
+error: unnecessarily eager cloning of iterator items
   --> $DIR/iter_overeager_cloned.rs:8:29
    |
 LL |     let _: Option<String> = vec.iter().cloned().last();
-   |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `vec.iter().last().cloned()`
+   |                             ^^^^^^^^^^----------------
+   |                                       |
+   |                                       help: try this: `.last().cloned()`
    |
    = note: `-D clippy::iter-overeager-cloned` implied by `-D warnings`
 
-error: called `cloned().next()` on an `Iterator`. It may be more efficient to call `next().cloned()` instead
+error: unnecessarily eager cloning of iterator items
   --> $DIR/iter_overeager_cloned.rs:10:29
    |
 LL |     let _: Option<String> = vec.iter().chain(vec.iter()).cloned().next();
-   |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `vec.iter().chain(vec.iter()).next().cloned()`
+   |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^----------------
+   |                                                         |
+   |                                                         help: try this: `.next().cloned()`
 
-error: called `cloned().count()` on an `Iterator`. It may be more efficient to call `count()` instead
+error: unneeded cloning of iterator items
   --> $DIR/iter_overeager_cloned.rs:12:20
    |
 LL |     let _: usize = vec.iter().filter(|x| x == &"2").cloned().count();
-   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `vec.iter().filter(|x| x == &"2").count()`
+   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-----------------
+   |                                                    |
+   |                                                    help: try this: `.count()`
    |
    = note: `-D clippy::redundant-clone` implied by `-D warnings`
 
-error: called `cloned().take(...)` on an `Iterator`. It may be more efficient to call `take(...).cloned()` instead
+error: unnecessarily eager cloning of iterator items
   --> $DIR/iter_overeager_cloned.rs:14:21
    |
 LL |     let _: Vec<_> = vec.iter().cloned().take(2).collect();
-   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `vec.iter().take(2).cloned()`
+   |                     ^^^^^^^^^^-----------------
+   |                               |
+   |                               help: try this: `.take(2).cloned()`
 
-error: called `cloned().skip(...)` on an `Iterator`. It may be more efficient to call `skip(...).cloned()` instead
+error: unnecessarily eager cloning of iterator items
   --> $DIR/iter_overeager_cloned.rs:16:21
    |
 LL |     let _: Vec<_> = vec.iter().cloned().skip(2).collect();
-   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `vec.iter().skip(2).cloned()`
+   |                     ^^^^^^^^^^-----------------
+   |                               |
+   |                               help: try this: `.skip(2).cloned()`
 
-error: called `cloned().nth(...)` on an `Iterator`. It may be more efficient to call `nth(...).cloned()` instead
+error: unnecessarily eager cloning of iterator items
   --> $DIR/iter_overeager_cloned.rs:18:13
    |
 LL |     let _ = vec.iter().filter(|x| x == &"2").cloned().nth(2);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `vec.iter().filter(|x| x == &"2").nth(2).cloned()`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^----------------
+   |                                             |
+   |                                             help: try this: `.nth(2).cloned()`
 
-error: called `cloned().flatten()` on an `Iterator`. It may be more efficient to call `flatten().cloned()` instead
+error: unnecessarily eager cloning of iterator items
   --> $DIR/iter_overeager_cloned.rs:20:13
    |
 LL |       let _ = [Some(Some("str".to_string())), Some(Some("str".to_string()))]
@@ -50,8 +62,8 @@ LL | |         .flatten();
    |
 help: try this
    |
-LL ~     let _ = [Some(Some("str".to_string())), Some(Some("str".to_string()))]
-LL ~         .iter().flatten().cloned();
+LL ~         .iter()
+LL ~         .flatten().cloned();
    |
 
 error: aborting due to 7 previous errors
-- 
cgit 1.4.1-3-g733a5


From 0e07f55cebe65d3cf984fea57b9bc22049c6eb2e Mon Sep 17 00:00:00 2001
From: Serial <69764315+Serial-ATA@users.noreply.github.com>
Date: Tue, 7 Jun 2022 18:51:45 -0400
Subject: Hide unnecessary code in [`implicit_saturating_sub`]

---
 clippy_lints/src/implicit_saturating_sub.rs | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/implicit_saturating_sub.rs b/clippy_lints/src/implicit_saturating_sub.rs
index 9d858e0c212..46654bc61e0 100644
--- a/clippy_lints/src/implicit_saturating_sub.rs
+++ b/clippy_lints/src/implicit_saturating_sub.rs
@@ -16,7 +16,10 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust
-    /// # let mut i: u32 = 0;
+    /// # let end: u32 = 10;
+    /// # let start: u32 = 5;
+    /// let mut i: u32 = end - start;
+    ///
     /// if i != 0 {
     ///     i -= 1;
     /// }
@@ -24,7 +27,10 @@ declare_clippy_lint! {
     ///
     /// Use instead:
     /// ```rust
-    /// # let mut i: u32 = 0;
+    /// # let end: u32 = 10;
+    /// # let start: u32 = 5;
+    /// let mut i: u32 = end - start;
+    ///
     /// i = i.saturating_sub(1);
     /// ```
     #[clippy::version = "1.44.0"]
-- 
cgit 1.4.1-3-g733a5


From 9d201d68b41eefab9bae6f61de1eccb881524ccc Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Thu, 9 Jun 2022 09:17:46 +0200
Subject: Fix `#[expect]` for `default_numeric_fallback`

---
 clippy_lints/src/default_numeric_fallback.rs | 15 +++++----
 tests/ui/default_numeric_fallback_i32.fixed  |  6 ++++
 tests/ui/default_numeric_fallback_i32.rs     |  6 ++++
 tests/ui/default_numeric_fallback_i32.stderr | 50 ++++++++++++++--------------
 4 files changed, 45 insertions(+), 32 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/default_numeric_fallback.rs b/clippy_lints/src/default_numeric_fallback.rs
index 3d9f9ed41ce..fb418a3251f 100644
--- a/clippy_lints/src/default_numeric_fallback.rs
+++ b/clippy_lints/src/default_numeric_fallback.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::diagnostics::span_lint_hir_and_then;
 use clippy_utils::numeric_literal;
 use clippy_utils::source::snippet_opt;
 use if_chain::if_chain;
@@ -76,7 +76,7 @@ impl<'a, 'tcx> NumericFallbackVisitor<'a, 'tcx> {
     }
 
     /// Check whether a passed literal has potential to cause fallback or not.
-    fn check_lit(&self, lit: &Lit, lit_ty: Ty<'tcx>) {
+    fn check_lit(&self, lit: &Lit, lit_ty: Ty<'tcx>, emit_hir_id: HirId) {
         if_chain! {
                 if !in_external_macro(self.cx.sess(), lit.span);
                 if let Some(ty_bound) = self.ty_bounds.last();
@@ -101,14 +101,15 @@ impl<'a, 'tcx> NumericFallbackVisitor<'a, 'tcx> {
                         }
                     };
                     let sugg = numeric_literal::format(&src, Some(suffix), is_float);
-                    span_lint_and_sugg(
+                    span_lint_hir_and_then(
                         self.cx,
                         DEFAULT_NUMERIC_FALLBACK,
+                        emit_hir_id,
                         lit.span,
                         "default numeric fallback might occur",
-                        "consider adding suffix",
-                        sugg,
-                        Applicability::MaybeIncorrect,
+                        |diag| {
+                            diag.span_suggestion(lit.span, "consider adding suffix", sugg, Applicability::MaybeIncorrect);
+                        }
                     );
                 }
         }
@@ -179,7 +180,7 @@ impl<'a, 'tcx> Visitor<'tcx> for NumericFallbackVisitor<'a, 'tcx> {
 
             ExprKind::Lit(lit) => {
                 let ty = self.cx.typeck_results().expr_ty(expr);
-                self.check_lit(lit, ty);
+                self.check_lit(lit, ty, expr.hir_id);
                 return;
             },
 
diff --git a/tests/ui/default_numeric_fallback_i32.fixed b/tests/ui/default_numeric_fallback_i32.fixed
index fa85d278c8f..55451cf2f7d 100644
--- a/tests/ui/default_numeric_fallback_i32.fixed
+++ b/tests/ui/default_numeric_fallback_i32.fixed
@@ -1,6 +1,7 @@
 // run-rustfix
 // aux-build:macro_rules.rs
 
+#![feature(lint_reasons)]
 #![warn(clippy::default_numeric_fallback)]
 #![allow(
     unused,
@@ -173,4 +174,9 @@ mod in_macro {
     }
 }
 
+fn check_expect_suppression() {
+    #[expect(clippy::default_numeric_fallback)]
+    let x = 21;
+}
+
 fn main() {}
diff --git a/tests/ui/default_numeric_fallback_i32.rs b/tests/ui/default_numeric_fallback_i32.rs
index 71acccd702b..62d72f2feba 100644
--- a/tests/ui/default_numeric_fallback_i32.rs
+++ b/tests/ui/default_numeric_fallback_i32.rs
@@ -1,6 +1,7 @@
 // run-rustfix
 // aux-build:macro_rules.rs
 
+#![feature(lint_reasons)]
 #![warn(clippy::default_numeric_fallback)]
 #![allow(
     unused,
@@ -173,4 +174,9 @@ mod in_macro {
     }
 }
 
+fn check_expect_suppression() {
+    #[expect(clippy::default_numeric_fallback)]
+    let x = 21;
+}
+
 fn main() {}
diff --git a/tests/ui/default_numeric_fallback_i32.stderr b/tests/ui/default_numeric_fallback_i32.stderr
index 3cc84ff1132..f7c5e724c40 100644
--- a/tests/ui/default_numeric_fallback_i32.stderr
+++ b/tests/ui/default_numeric_fallback_i32.stderr
@@ -1,5 +1,5 @@
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:20:17
+  --> $DIR/default_numeric_fallback_i32.rs:21:17
    |
 LL |         let x = 22;
    |                 ^^ help: consider adding suffix: `22_i32`
@@ -7,145 +7,145 @@ LL |         let x = 22;
    = note: `-D clippy::default-numeric-fallback` implied by `-D warnings`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:21:18
+  --> $DIR/default_numeric_fallback_i32.rs:22:18
    |
 LL |         let x = [1, 2, 3];
    |                  ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:21:21
+  --> $DIR/default_numeric_fallback_i32.rs:22:21
    |
 LL |         let x = [1, 2, 3];
    |                     ^ help: consider adding suffix: `2_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:21:24
+  --> $DIR/default_numeric_fallback_i32.rs:22:24
    |
 LL |         let x = [1, 2, 3];
    |                        ^ help: consider adding suffix: `3_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:22:28
+  --> $DIR/default_numeric_fallback_i32.rs:23:28
    |
 LL |         let x = if true { (1, 2) } else { (3, 4) };
    |                            ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:22:31
+  --> $DIR/default_numeric_fallback_i32.rs:23:31
    |
 LL |         let x = if true { (1, 2) } else { (3, 4) };
    |                               ^ help: consider adding suffix: `2_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:22:44
+  --> $DIR/default_numeric_fallback_i32.rs:23:44
    |
 LL |         let x = if true { (1, 2) } else { (3, 4) };
    |                                            ^ help: consider adding suffix: `3_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:22:47
+  --> $DIR/default_numeric_fallback_i32.rs:23:47
    |
 LL |         let x = if true { (1, 2) } else { (3, 4) };
    |                                               ^ help: consider adding suffix: `4_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:23:23
+  --> $DIR/default_numeric_fallback_i32.rs:24:23
    |
 LL |         let x = match 1 {
    |                       ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:24:13
+  --> $DIR/default_numeric_fallback_i32.rs:25:13
    |
 LL |             1 => 1,
    |             ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:24:18
+  --> $DIR/default_numeric_fallback_i32.rs:25:18
    |
 LL |             1 => 1,
    |                  ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:25:18
+  --> $DIR/default_numeric_fallback_i32.rs:26:18
    |
 LL |             _ => 2,
    |                  ^ help: consider adding suffix: `2_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:42:21
+  --> $DIR/default_numeric_fallback_i32.rs:43:21
    |
 LL |             let y = 1;
    |                     ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:50:21
+  --> $DIR/default_numeric_fallback_i32.rs:51:21
    |
 LL |             let y = 1;
    |                     ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:56:21
+  --> $DIR/default_numeric_fallback_i32.rs:57:21
    |
 LL |             let y = 1;
    |                     ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:68:9
+  --> $DIR/default_numeric_fallback_i32.rs:69:9
    |
 LL |         1
    |         ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:74:27
+  --> $DIR/default_numeric_fallback_i32.rs:75:27
    |
 LL |         let f = || -> _ { 1 };
    |                           ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:78:29
+  --> $DIR/default_numeric_fallback_i32.rs:79:29
    |
 LL |         let f = || -> i32 { 1 };
    |                             ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:92:21
+  --> $DIR/default_numeric_fallback_i32.rs:93:21
    |
 LL |         generic_arg(1);
    |                     ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:95:32
+  --> $DIR/default_numeric_fallback_i32.rs:96:32
    |
 LL |         let x: _ = generic_arg(1);
    |                                ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:113:28
+  --> $DIR/default_numeric_fallback_i32.rs:114:28
    |
 LL |         GenericStruct { x: 1 };
    |                            ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:116:36
+  --> $DIR/default_numeric_fallback_i32.rs:117:36
    |
 LL |         let _ = GenericStruct { x: 1 };
    |                                    ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:134:24
+  --> $DIR/default_numeric_fallback_i32.rs:135:24
    |
 LL |         GenericEnum::X(1);
    |                        ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:154:23
+  --> $DIR/default_numeric_fallback_i32.rs:155:23
    |
 LL |         s.generic_arg(1);
    |                       ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:161:21
+  --> $DIR/default_numeric_fallback_i32.rs:162:21
    |
 LL |             let x = 22;
    |                     ^^ help: consider adding suffix: `22_i32`
-- 
cgit 1.4.1-3-g733a5


From 649ac368365065694b4b51cb21abcb8e5502c5b0 Mon Sep 17 00:00:00 2001
From: Serial <69764315+Serial-ATA@users.noreply.github.com>
Date: Thu, 9 Jun 2022 06:54:01 -0400
Subject: Fix [`needless_bool`] example

---
 clippy_lints/src/needless_bool.rs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/needless_bool.rs b/clippy_lints/src/needless_bool.rs
index 33638fe3734..a4eec95b371 100644
--- a/clippy_lints/src/needless_bool.rs
+++ b/clippy_lints/src/needless_bool.rs
@@ -34,11 +34,10 @@ declare_clippy_lint! {
     /// # let x = true;
     /// if x {
     ///     false
-    /// # ;
     /// } else {
     ///     true
-    /// # ;
     /// }
+    /// # ;
     /// ```
     ///
     /// Use instead:
-- 
cgit 1.4.1-3-g733a5


From 2b655d46309aa688fcb7dff6aa692278a722ee68 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Thu, 9 Jun 2022 13:43:26 +0000
Subject: Correct some `#[clippy::version]`s

---
 clippy_lints/src/casts/mod.rs                  | 4 ++--
 clippy_lints/src/doc.rs                        | 2 +-
 clippy_lints/src/index_refutable_slice.rs      | 2 +-
 clippy_lints/src/loops/mod.rs                  | 2 +-
 clippy_lints/src/methods/mod.rs                | 8 ++++----
 clippy_lints/src/needless_late_init.rs         | 2 +-
 clippy_lints/src/octal_escapes.rs              | 2 +-
 clippy_lints/src/only_used_in_recursion.rs     | 2 +-
 clippy_lints/src/redundant_slicing.rs          | 2 +-
 clippy_lints/src/single_char_lifetime_names.rs | 2 +-
 10 files changed, 14 insertions(+), 14 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index 74ea70d1af1..02c2f30a4dd 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -414,7 +414,7 @@ declare_clippy_lint! {
     /// enum E { X = 256 };
     /// let _ = E::X as u8;
     /// ```
-    #[clippy::version = "1.60.0"]
+    #[clippy::version = "1.61.0"]
     pub CAST_ENUM_TRUNCATION,
     suspicious,
     "casts from an enum type to an integral type which will truncate the value"
@@ -459,7 +459,7 @@ declare_clippy_lint! {
     ///     println!("{:?}", &*new_ptr);
     /// }
     /// ```
-    #[clippy::version = "1.60.0"]
+    #[clippy::version = "1.61.0"]
     pub CAST_SLICE_DIFFERENT_SIZES,
     correctness,
     "casting using `as` between raw pointers to slices of types with different sizes"
diff --git a/clippy_lints/src/doc.rs b/clippy_lints/src/doc.rs
index aaec88f50c7..bb0d39866a4 100644
--- a/clippy_lints/src/doc.rs
+++ b/clippy_lints/src/doc.rs
@@ -163,7 +163,7 @@ declare_clippy_lint! {
     ///     }
     /// }
     /// ```
-    #[clippy::version = "1.52.0"]
+    #[clippy::version = "1.51.0"]
     pub MISSING_PANICS_DOC,
     pedantic,
     "`pub fn` may panic without `# Panics` in doc comment"
diff --git a/clippy_lints/src/index_refutable_slice.rs b/clippy_lints/src/index_refutable_slice.rs
index 9ce5b8e17a9..d0c6495e35a 100644
--- a/clippy_lints/src/index_refutable_slice.rs
+++ b/clippy_lints/src/index_refutable_slice.rs
@@ -45,7 +45,7 @@ declare_clippy_lint! {
     ///     println!("{}", first);
     /// }
     /// ```
-    #[clippy::version = "1.58.0"]
+    #[clippy::version = "1.59.0"]
     pub INDEX_REFUTABLE_SLICE,
     nursery,
     "avoid indexing on slices which could be destructed"
diff --git a/clippy_lints/src/loops/mod.rs b/clippy_lints/src/loops/mod.rs
index acf974c586a..391de922e1e 100644
--- a/clippy_lints/src/loops/mod.rs
+++ b/clippy_lints/src/loops/mod.rs
@@ -596,7 +596,7 @@ declare_clippy_lint! {
     ///     std::hint::spin_loop()
     /// }
     /// ```
-    #[clippy::version = "1.59.0"]
+    #[clippy::version = "1.61.0"]
     pub MISSING_SPIN_LOOP,
     perf,
     "An empty busy waiting loop"
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index ec19c317c88..9bb7bb7a7ab 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -141,7 +141,7 @@ declare_clippy_lint! {
     /// vec.iter().take(10).cloned();
     /// vec.iter().last().cloned();
     /// ```
-    #[clippy::version = "1.59.0"]
+    #[clippy::version = "1.60.0"]
     pub ITER_OVEREAGER_CLONED,
     perf,
     "using `cloned()` early with `Iterator::iter()` can lead to some performance inefficiencies"
@@ -1907,7 +1907,7 @@ declare_clippy_lint! {
     /// let x = [1, 2, 3];
     /// let y: Vec<_> = x.iter().map(|x| 2*x).collect();
     /// ```
-    #[clippy::version = "1.52.0"]
+    #[clippy::version = "1.47.0"]
     pub MAP_IDENTITY,
     complexity,
     "using iterator.map(|x| x)"
@@ -2100,7 +2100,7 @@ declare_clippy_lint! {
     /// let str = "key=value=add";
     /// let _ = str.split('=').next().unwrap();
     /// ```
-    #[clippy::version = "1.58.0"]
+    #[clippy::version = "1.59.0"]
     pub NEEDLESS_SPLITN,
     complexity,
     "usages of `str::splitn` that can be replaced with `str::split`"
@@ -2131,7 +2131,7 @@ declare_clippy_lint! {
     /// foo(&path.to_string_lossy());
     /// fn foo(s: &str) {}
     /// ```
-    #[clippy::version = "1.58.0"]
+    #[clippy::version = "1.59.0"]
     pub UNNECESSARY_TO_OWNED,
     perf,
     "unnecessary calls to `to_owned`-like functions"
diff --git a/clippy_lints/src/needless_late_init.rs b/clippy_lints/src/needless_late_init.rs
index 4154c71b428..e8a0da7e478 100644
--- a/clippy_lints/src/needless_late_init.rs
+++ b/clippy_lints/src/needless_late_init.rs
@@ -56,7 +56,7 @@ declare_clippy_lint! {
     ///     -1
     /// };
     /// ```
-    #[clippy::version = "1.58.0"]
+    #[clippy::version = "1.59.0"]
     pub NEEDLESS_LATE_INIT,
     style,
     "late initializations that can be replaced by a `let` statement with an initializer"
diff --git a/clippy_lints/src/octal_escapes.rs b/clippy_lints/src/octal_escapes.rs
index c8854539677..3ab4b6c4f6f 100644
--- a/clippy_lints/src/octal_escapes.rs
+++ b/clippy_lints/src/octal_escapes.rs
@@ -42,7 +42,7 @@ declare_clippy_lint! {
     /// let one = "\x1b[1mWill this be bold?\x1b[0m";
     /// let two = "\x0033\x00";
     /// ```
-    #[clippy::version = "1.58.0"]
+    #[clippy::version = "1.59.0"]
     pub OCTAL_ESCAPES,
     suspicious,
     "string escape sequences looking like octal characters"
diff --git a/clippy_lints/src/only_used_in_recursion.rs b/clippy_lints/src/only_used_in_recursion.rs
index d66698f8adc..30b11618801 100644
--- a/clippy_lints/src/only_used_in_recursion.rs
+++ b/clippy_lints/src/only_used_in_recursion.rs
@@ -87,7 +87,7 @@ declare_clippy_lint! {
     /// #     print!("{}", f(1));
     /// # }
     /// ```
-    #[clippy::version = "1.60.0"]
+    #[clippy::version = "1.61.0"]
     pub ONLY_USED_IN_RECURSION,
     nursery,
     "arguments that is only used in recursion can be removed"
diff --git a/clippy_lints/src/redundant_slicing.rs b/clippy_lints/src/redundant_slicing.rs
index 25a9072ef6e..db6c97f3739 100644
--- a/clippy_lints/src/redundant_slicing.rs
+++ b/clippy_lints/src/redundant_slicing.rs
@@ -60,7 +60,7 @@ declare_clippy_lint! {
     /// let vec = vec![1, 2, 3];
     /// let slice = &*vec;
     /// ```
-    #[clippy::version = "1.60.0"]
+    #[clippy::version = "1.61.0"]
     pub DEREF_BY_SLICING,
     restriction,
     "slicing instead of dereferencing"
diff --git a/clippy_lints/src/single_char_lifetime_names.rs b/clippy_lints/src/single_char_lifetime_names.rs
index aa306a630c4..3dc995e2fa5 100644
--- a/clippy_lints/src/single_char_lifetime_names.rs
+++ b/clippy_lints/src/single_char_lifetime_names.rs
@@ -33,7 +33,7 @@ declare_clippy_lint! {
     ///     source: &'src str,
     /// }
     /// ```
-    #[clippy::version = "1.59.0"]
+    #[clippy::version = "1.60.0"]
     pub SINGLE_CHAR_LIFETIME_NAMES,
     restriction,
     "warns against single-character lifetime names"
-- 
cgit 1.4.1-3-g733a5


From 6d6c63ee23c627aa9299cffa738f40189126c08a Mon Sep 17 00:00:00 2001
From: Micha White <botahamec@outlook.com>
Date: Thu, 9 Jun 2022 16:25:48 -0400
Subject: Lint single_match with Options, Results, and Cows

---
 clippy_lints/src/matches/single_match.rs | 53 +++++++++++++++++++-------------
 tests/ui/single_match.stderr             | 11 ++++++-
 tests/ui/single_match_else.stderr        | 42 ++++++++++++++++++++++++-
 3 files changed, 82 insertions(+), 24 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/single_match.rs b/clippy_lints/src/matches/single_match.rs
index 0c4cb45d147..b54d4e8a0ee 100644
--- a/clippy_lints/src/matches/single_match.rs
+++ b/clippy_lints/src/matches/single_match.rs
@@ -140,6 +140,23 @@ fn check_opt_like<'a>(
     ty: Ty<'a>,
     els: Option<&Expr<'_>>,
 ) {
+    // We want to suggest to exclude an arm that contains only wildcards or forms the exhaustive
+    // match with the second branch, without enum variants in matches.
+    if !contains_only_wilds(arms[1].pat) && !form_exhaustive_matches(cx, ty, arms[0].pat, arms[1].pat) {
+        return;
+    }
+
+    let mut paths_and_types = Vec::new();
+    if !collect_pat_paths(&mut paths_and_types, cx, arms[1].pat, ty) {
+        return;
+    }
+
+    if paths_and_types.iter().all(|info| in_candidate_enum(cx, info)) {
+        report_single_pattern(cx, ex, arms, expr, els);
+    }
+}
+
+fn in_candidate_enum<'a>(cx: &LateContext<'a>, path_info: &(String, Ty<'_>)) -> bool {
     // list of candidate `Enum`s we know will never get any more members
     let candidates = &[
         (&paths::COW, "Borrowed"),
@@ -151,29 +168,13 @@ fn check_opt_like<'a>(
         (&paths::RESULT, "Ok"),
     ];
 
-    // We want to suggest to exclude an arm that contains only wildcards or forms the exhaustive
-    // match with the second branch, without enum variants in matches.
-    if !contains_only_wilds(arms[1].pat) && !form_exhaustive_matches(arms[0].pat, arms[1].pat) {
-        return;
-    }
-
-    let mut paths_and_types = Vec::new();
-    if !collect_pat_paths(&mut paths_and_types, cx, arms[1].pat, ty) {
-        return;
-    }
-
-    let in_candidate_enum = |path_info: &(String, Ty<'_>)| -> bool {
-        let (path, ty) = path_info;
-        for &(ty_path, pat_path) in candidates {
-            if path == pat_path && match_type(cx, *ty, ty_path) {
-                return true;
-            }
+    let (path, ty) = path_info;
+    for &(ty_path, pat_path) in candidates {
+        if path == pat_path && match_type(cx, *ty, ty_path) {
+            return true;
         }
-        false
-    };
-    if paths_and_types.iter().all(in_candidate_enum) {
-        report_single_pattern(cx, ex, arms, expr, els);
     }
+    false
 }
 
 /// Collects paths and their types from the given patterns. Returns true if the given pattern could
@@ -218,7 +219,7 @@ fn contains_only_wilds(pat: &Pat<'_>) -> bool {
 
 /// Returns true if the given patterns forms only exhaustive matches that don't contain enum
 /// patterns without a wildcard.
-fn form_exhaustive_matches(left: &Pat<'_>, right: &Pat<'_>) -> bool {
+fn form_exhaustive_matches<'a>(cx: &LateContext<'a>, ty: Ty<'a>, left: &Pat<'_>, right: &Pat<'_>) -> bool {
     match (&left.kind, &right.kind) {
         (PatKind::Wild, _) | (_, PatKind::Wild) => true,
         (PatKind::Tuple(left_in, left_pos), PatKind::Tuple(right_in, right_pos)) => {
@@ -264,6 +265,14 @@ fn form_exhaustive_matches(left: &Pat<'_>, right: &Pat<'_>) -> bool {
             }
             true
         },
+        (PatKind::TupleStruct(..), PatKind::Path(_) | PatKind::TupleStruct(..)) => {
+            let mut paths_and_types = Vec::new();
+            if !collect_pat_paths(&mut paths_and_types, cx, right, ty) {
+                return false;
+            }
+
+            paths_and_types.iter().all(|info| in_candidate_enum(cx, info))
+        },
         _ => false,
     }
 }
diff --git a/tests/ui/single_match.stderr b/tests/ui/single_match.stderr
index 318faf25717..4d2b9ec5f90 100644
--- a/tests/ui/single_match.stderr
+++ b/tests/ui/single_match.stderr
@@ -38,6 +38,15 @@ LL | |         _ => {},
 LL | |     };
    | |_____^ help: try this: `if let (2..=3, 7..=9) = z { dummy() }`
 
+error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
+  --> $DIR/single_match.rs:54:5
+   |
+LL | /     match x {
+LL | |         Some(y) => dummy(),
+LL | |         None => (),
+LL | |     };
+   | |_____^ help: try this: `if let Some(y) = x { dummy() }`
+
 error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
   --> $DIR/single_match.rs:59:5
    |
@@ -146,5 +155,5 @@ LL | |         (..) => {},
 LL | |     }
    | |_____^ help: try this: `if let (.., Some(E::V), _) = (Some(42), Some(E::V), Some(42)) {}`
 
-error: aborting due to 15 previous errors
+error: aborting due to 16 previous errors
 
diff --git a/tests/ui/single_match_else.stderr b/tests/ui/single_match_else.stderr
index 7756c6f204e..dc603578fde 100644
--- a/tests/ui/single_match_else.stderr
+++ b/tests/ui/single_match_else.stderr
@@ -20,5 +20,45 @@ LL +         None
 LL ~     };
    |
 
-error: aborting due to previous error
+error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
+  --> $DIR/single_match_else.rs:84:5
+   |
+LL | /     match Some(1) {
+LL | |         Some(a) => println!("${:?}", a),
+LL | |         None => {
+LL | |             println!("else block");
+LL | |             return
+LL | |         },
+LL | |     }
+   | |_____^
+   |
+help: try this
+   |
+LL ~     if let Some(a) = Some(1) { println!("${:?}", a) } else {
+LL +         println!("else block");
+LL +         return
+LL +     }
+   |
+
+error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
+  --> $DIR/single_match_else.rs:93:5
+   |
+LL | /     match Some(1) {
+LL | |         Some(a) => println!("${:?}", a),
+LL | |         None => {
+LL | |             println!("else block");
+LL | |             return;
+LL | |         },
+LL | |     }
+   | |_____^
+   |
+help: try this
+   |
+LL ~     if let Some(a) = Some(1) { println!("${:?}", a) } else {
+LL +         println!("else block");
+LL +         return;
+LL +     }
+   |
+
+error: aborting due to 3 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 2967127de2b99957cb03a3af741e797710eae534 Mon Sep 17 00:00:00 2001
From: Micha White <botahamec@outlook.com>
Date: Thu, 9 Jun 2022 17:44:28 -0400
Subject: Refactored the candidate type checking

---
 clippy_lints/src/matches/single_match.rs | 48 ++++++--------------------------
 1 file changed, 9 insertions(+), 39 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/single_match.rs b/clippy_lints/src/matches/single_match.rs
index b54d4e8a0ee..7d1ff208729 100644
--- a/clippy_lints/src/matches/single_match.rs
+++ b/clippy_lints/src/matches/single_match.rs
@@ -151,26 +151,17 @@ fn check_opt_like<'a>(
         return;
     }
 
-    if paths_and_types.iter().all(|info| in_candidate_enum(cx, info)) {
+    if paths_and_types.iter().all(|ty| in_candidate_enum(cx, *ty)) {
         report_single_pattern(cx, ex, arms, expr, els);
     }
 }
 
-fn in_candidate_enum<'a>(cx: &LateContext<'a>, path_info: &(String, Ty<'_>)) -> bool {
+fn in_candidate_enum<'a>(cx: &LateContext<'a>, ty: Ty<'_>) -> bool {
     // list of candidate `Enum`s we know will never get any more members
-    let candidates = &[
-        (&paths::COW, "Borrowed"),
-        (&paths::COW, "Cow::Borrowed"),
-        (&paths::COW, "Cow::Owned"),
-        (&paths::COW, "Owned"),
-        (&paths::OPTION, "None"),
-        (&paths::RESULT, "Err"),
-        (&paths::RESULT, "Ok"),
-    ];
+    let candidates = [&paths::COW, &paths::OPTION, &paths::RESULT];
 
-    let (path, ty) = path_info;
-    for &(ty_path, pat_path) in candidates {
-        if path == pat_path && match_type(cx, *ty, ty_path) {
+    for candidate_ty in candidates {
+        if match_type(cx, ty, candidate_ty) {
             return true;
         }
     }
@@ -179,29 +170,15 @@ fn in_candidate_enum<'a>(cx: &LateContext<'a>, path_info: &(String, Ty<'_>)) ->
 
 /// Collects paths and their types from the given patterns. Returns true if the given pattern could
 /// be simplified, false otherwise.
-fn collect_pat_paths<'a>(acc: &mut Vec<(String, Ty<'a>)>, cx: &LateContext<'a>, pat: &Pat<'_>, ty: Ty<'a>) -> bool {
+fn collect_pat_paths<'a>(acc: &mut Vec<Ty<'a>>, cx: &LateContext<'a>, pat: &Pat<'_>, ty: Ty<'a>) -> bool {
     match pat.kind {
         PatKind::Wild => true,
         PatKind::Tuple(inner, _) => inner.iter().all(|p| {
             let p_ty = cx.typeck_results().pat_ty(p);
             collect_pat_paths(acc, cx, p, p_ty)
         }),
-        PatKind::TupleStruct(ref path, ..) => {
-            let path = rustc_hir_pretty::to_string(rustc_hir_pretty::NO_ANN, |s| {
-                s.print_qpath(path, false);
-            });
-            acc.push((path, ty));
-            true
-        },
-        PatKind::Binding(BindingAnnotation::Unannotated, .., ident, None) => {
-            acc.push((ident.to_string(), ty));
-            true
-        },
-        PatKind::Path(ref path) => {
-            let path = rustc_hir_pretty::to_string(rustc_hir_pretty::NO_ANN, |s| {
-                s.print_qpath(path, false);
-            });
-            acc.push((path, ty));
+        PatKind::TupleStruct(..) | PatKind::Binding(BindingAnnotation::Unannotated, .., None) | PatKind::Path(_) => {
+            acc.push(ty);
             true
         },
         _ => false,
@@ -265,14 +242,7 @@ fn form_exhaustive_matches<'a>(cx: &LateContext<'a>, ty: Ty<'a>, left: &Pat<'_>,
             }
             true
         },
-        (PatKind::TupleStruct(..), PatKind::Path(_) | PatKind::TupleStruct(..)) => {
-            let mut paths_and_types = Vec::new();
-            if !collect_pat_paths(&mut paths_and_types, cx, right, ty) {
-                return false;
-            }
-
-            paths_and_types.iter().all(|info| in_candidate_enum(cx, info))
-        },
+        (PatKind::TupleStruct(..), PatKind::Path(_) | PatKind::TupleStruct(..)) => in_candidate_enum(cx, ty),
         _ => false,
     }
 }
-- 
cgit 1.4.1-3-g733a5


From b46f1c4a7fa5c0705cc65953e9887c4449aa8cba Mon Sep 17 00:00:00 2001
From: Micha White <botahamec@outlook.com>
Date: Thu, 9 Jun 2022 20:01:22 -0400
Subject: Don't trigger if a binding is in the else pattern

---
 clippy_lints/src/matches/single_match.rs | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/single_match.rs b/clippy_lints/src/matches/single_match.rs
index 7d1ff208729..e67ef2a2c3a 100644
--- a/clippy_lints/src/matches/single_match.rs
+++ b/clippy_lints/src/matches/single_match.rs
@@ -242,7 +242,10 @@ fn form_exhaustive_matches<'a>(cx: &LateContext<'a>, ty: Ty<'a>, left: &Pat<'_>,
             }
             true
         },
-        (PatKind::TupleStruct(..), PatKind::Path(_) | PatKind::TupleStruct(..)) => in_candidate_enum(cx, ty),
+        (PatKind::TupleStruct(..), PatKind::Path(_)) => in_candidate_enum(cx, ty),
+        (PatKind::TupleStruct(..), PatKind::TupleStruct(_, inner, _)) => {
+            in_candidate_enum(cx, ty) && inner.iter().all(contains_only_wilds)
+        },
         _ => false,
     }
 }
-- 
cgit 1.4.1-3-g733a5


From b0c20302b7a647ae362071d72b382b1bd393e4a5 Mon Sep 17 00:00:00 2001
From: Micha White <botahamec@outlook.com>
Date: Thu, 9 Jun 2022 21:16:39 -0400
Subject: Some refactoring

---
 clippy_lints/src/matches/single_match.rs | 37 ++++++++++++++------------------
 1 file changed, 16 insertions(+), 21 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/single_match.rs b/clippy_lints/src/matches/single_match.rs
index e67ef2a2c3a..813469be2f7 100644
--- a/clippy_lints/src/matches/single_match.rs
+++ b/clippy_lints/src/matches/single_match.rs
@@ -140,22 +140,20 @@ fn check_opt_like<'a>(
     ty: Ty<'a>,
     els: Option<&Expr<'_>>,
 ) {
-    // We want to suggest to exclude an arm that contains only wildcards or forms the exhaustive
-    // match with the second branch, without enum variants in matches.
-    if !contains_only_wilds(arms[1].pat) && !form_exhaustive_matches(cx, ty, arms[0].pat, arms[1].pat) {
-        return;
+    // We don't want to lint if the second arm contains an enum which could
+    // have more variants in the future.
+    if form_exhaustive_matches(cx, ty, arms[0].pat, arms[1].pat) {
+        report_single_pattern(cx, ex, arms, expr, els);
     }
+}
 
+fn pat_in_candidate_enum<'a>(cx: &LateContext<'a>, ty: Ty<'a>, pat: &Pat<'_>) -> bool {
     let mut paths_and_types = Vec::new();
-    if !collect_pat_paths(&mut paths_and_types, cx, arms[1].pat, ty) {
-        return;
-    }
-
-    if paths_and_types.iter().all(|ty| in_candidate_enum(cx, *ty)) {
-        report_single_pattern(cx, ex, arms, expr, els);
-    }
+    collect_pat_paths(&mut paths_and_types, cx, pat, ty);
+    paths_and_types.iter().all(|ty| in_candidate_enum(cx, *ty))
 }
 
+/// Returns `true` if the given type is an enum we know won't be expanded in the future
 fn in_candidate_enum<'a>(cx: &LateContext<'a>, ty: Ty<'_>) -> bool {
     // list of candidate `Enum`s we know will never get any more members
     let candidates = [&paths::COW, &paths::OPTION, &paths::RESULT];
@@ -168,20 +166,17 @@ fn in_candidate_enum<'a>(cx: &LateContext<'a>, ty: Ty<'_>) -> bool {
     false
 }
 
-/// Collects paths and their types from the given patterns. Returns true if the given pattern could
-/// be simplified, false otherwise.
-fn collect_pat_paths<'a>(acc: &mut Vec<Ty<'a>>, cx: &LateContext<'a>, pat: &Pat<'_>, ty: Ty<'a>) -> bool {
+/// Collects paths and their types from the given patterns
+fn collect_pat_paths<'a>(acc: &mut Vec<Ty<'a>>, cx: &LateContext<'a>, pat: &Pat<'_>, ty: Ty<'a>) {
     match pat.kind {
-        PatKind::Wild => true,
-        PatKind::Tuple(inner, _) => inner.iter().all(|p| {
+        PatKind::Tuple(inner, _) => inner.iter().for_each(|p| {
             let p_ty = cx.typeck_results().pat_ty(p);
-            collect_pat_paths(acc, cx, p, p_ty)
+            collect_pat_paths(acc, cx, p, p_ty);
         }),
         PatKind::TupleStruct(..) | PatKind::Binding(BindingAnnotation::Unannotated, .., None) | PatKind::Path(_) => {
             acc.push(ty);
-            true
         },
-        _ => false,
+        _ => {},
     }
 }
 
@@ -242,9 +237,9 @@ fn form_exhaustive_matches<'a>(cx: &LateContext<'a>, ty: Ty<'a>, left: &Pat<'_>,
             }
             true
         },
-        (PatKind::TupleStruct(..), PatKind::Path(_)) => in_candidate_enum(cx, ty),
+        (PatKind::TupleStruct(..), PatKind::Path(_)) => pat_in_candidate_enum(cx, ty, right),
         (PatKind::TupleStruct(..), PatKind::TupleStruct(_, inner, _)) => {
-            in_candidate_enum(cx, ty) && inner.iter().all(contains_only_wilds)
+            pat_in_candidate_enum(cx, ty, right) && inner.iter().all(contains_only_wilds)
         },
         _ => false,
     }
-- 
cgit 1.4.1-3-g733a5


From f3dc7ae370a67988e48a573e332247717ce9bee4 Mon Sep 17 00:00:00 2001
From: Micha White <botahamec@outlook.com>
Date: Thu, 9 Jun 2022 21:46:13 -0400
Subject: Fixed up the documentation for a couple functions

---
 clippy_lints/src/matches/single_match.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/single_match.rs b/clippy_lints/src/matches/single_match.rs
index 813469be2f7..888ace687bb 100644
--- a/clippy_lints/src/matches/single_match.rs
+++ b/clippy_lints/src/matches/single_match.rs
@@ -147,6 +147,7 @@ fn check_opt_like<'a>(
     }
 }
 
+/// Returns `true` if all of the types in the pattern are candidate enums
 fn pat_in_candidate_enum<'a>(cx: &LateContext<'a>, ty: Ty<'a>, pat: &Pat<'_>) -> bool {
     let mut paths_and_types = Vec::new();
     collect_pat_paths(&mut paths_and_types, cx, pat, ty);
@@ -166,7 +167,7 @@ fn in_candidate_enum<'a>(cx: &LateContext<'a>, ty: Ty<'_>) -> bool {
     false
 }
 
-/// Collects paths and their types from the given patterns
+/// Collects types from the given pattern
 fn collect_pat_paths<'a>(acc: &mut Vec<Ty<'a>>, cx: &LateContext<'a>, pat: &Pat<'_>, ty: Ty<'a>) {
     match pat.kind {
         PatKind::Tuple(inner, _) => inner.iter().for_each(|p| {
-- 
cgit 1.4.1-3-g733a5


From ded2bb54642507c7a037a46bce31078026078672 Mon Sep 17 00:00:00 2001
From: Micha White <botahamec@outlook.com>
Date: Thu, 9 Jun 2022 21:47:24 -0400
Subject: Slight documentation change

---
 clippy_lints/src/matches/single_match.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/single_match.rs b/clippy_lints/src/matches/single_match.rs
index 888ace687bb..92091a0c339 100644
--- a/clippy_lints/src/matches/single_match.rs
+++ b/clippy_lints/src/matches/single_match.rs
@@ -147,7 +147,8 @@ fn check_opt_like<'a>(
     }
 }
 
-/// Returns `true` if all of the types in the pattern are candidate enums
+/// Returns `true` if all of the types in the pattern are enums which we know
+/// won't be expanded in the future
 fn pat_in_candidate_enum<'a>(cx: &LateContext<'a>, ty: Ty<'a>, pat: &Pat<'_>) -> bool {
     let mut paths_and_types = Vec::new();
     collect_pat_paths(&mut paths_and_types, cx, pat, ty);
-- 
cgit 1.4.1-3-g733a5


From 14478bb94b340c34d1ddc33cc0088119c9715358 Mon Sep 17 00:00:00 2001
From: tamaron <tamaron1203@gmail.com>
Date: Mon, 6 Jun 2022 22:48:05 +0900
Subject: add lint

---
 CHANGELOG.md                                 |   1 +
 clippy_lints/src/lib.register_all.rs         |   1 +
 clippy_lints/src/lib.register_correctness.rs |   1 +
 clippy_lints/src/lib.register_lints.rs       |   1 +
 clippy_lints/src/lib.rs                      |   2 +
 clippy_lints/src/read_zero_byte_vec.rs       | 142 +++++++++++++++++++++++++++
 tests/ui/read_zero_byte_vec.rs               |  87 ++++++++++++++++
 tests/ui/read_zero_byte_vec.stderr           |  64 ++++++++++++
 8 files changed, 299 insertions(+)
 create mode 100644 clippy_lints/src/read_zero_byte_vec.rs
 create mode 100644 tests/ui/read_zero_byte_vec.rs
 create mode 100644 tests/ui/read_zero_byte_vec.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 462e56892fd..6aaf12ed932 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3678,6 +3678,7 @@ Released 2018-09-13
 [`rc_buffer`]: https://rust-lang.github.io/rust-clippy/master/index.html#rc_buffer
 [`rc_clone_in_vec_init`]: https://rust-lang.github.io/rust-clippy/master/index.html#rc_clone_in_vec_init
 [`rc_mutex`]: https://rust-lang.github.io/rust-clippy/master/index.html#rc_mutex
+[`read_zero_byte_vec`]: https://rust-lang.github.io/rust-clippy/master/index.html#read_zero_byte_vec
 [`recursive_format_impl`]: https://rust-lang.github.io/rust-clippy/master/index.html#recursive_format_impl
 [`redundant_allocation`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_allocation
 [`redundant_clone`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_clone
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 4691f957cb4..8a2cfbff953 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -271,6 +271,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(ranges::RANGE_ZIP_WITH_LEN),
     LintId::of(ranges::REVERSED_EMPTY_RANGES),
     LintId::of(rc_clone_in_vec_init::RC_CLONE_IN_VEC_INIT),
+    LintId::of(read_zero_byte_vec::READ_ZERO_BYTE_VEC),
     LintId::of(redundant_clone::REDUNDANT_CLONE),
     LintId::of(redundant_closure_call::REDUNDANT_CLOSURE_CALL),
     LintId::of(redundant_field_names::REDUNDANT_FIELD_NAMES),
diff --git a/clippy_lints/src/lib.register_correctness.rs b/clippy_lints/src/lib.register_correctness.rs
index 50cdd0af923..92a3a0aabf1 100644
--- a/clippy_lints/src/lib.register_correctness.rs
+++ b/clippy_lints/src/lib.register_correctness.rs
@@ -55,6 +55,7 @@ store.register_group(true, "clippy::correctness", Some("clippy_correctness"), ve
     LintId::of(ptr::INVALID_NULL_PTR_USAGE),
     LintId::of(ptr::MUT_FROM_REF),
     LintId::of(ranges::REVERSED_EMPTY_RANGES),
+    LintId::of(read_zero_byte_vec::READ_ZERO_BYTE_VEC),
     LintId::of(regex::INVALID_REGEX),
     LintId::of(self_assignment::SELF_ASSIGNMENT),
     LintId::of(serde_api::SERDE_API_MISUSE),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index efb073af6b6..8ad984c68b8 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -459,6 +459,7 @@ store.register_lints(&[
     ranges::RANGE_ZIP_WITH_LEN,
     ranges::REVERSED_EMPTY_RANGES,
     rc_clone_in_vec_init::RC_CLONE_IN_VEC_INIT,
+    read_zero_byte_vec::READ_ZERO_BYTE_VEC,
     redundant_clone::REDUNDANT_CLONE,
     redundant_closure_call::REDUNDANT_CLOSURE_CALL,
     redundant_else::REDUNDANT_ELSE,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index a0a6bab407c..439b759be75 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -349,6 +349,7 @@ mod pub_use;
 mod question_mark;
 mod ranges;
 mod rc_clone_in_vec_init;
+mod read_zero_byte_vec;
 mod redundant_clone;
 mod redundant_closure_call;
 mod redundant_else;
@@ -909,6 +910,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(swap_ptr_to_ref::SwapPtrToRef));
     store.register_late_pass(|| Box::new(mismatching_type_param_order::TypeParamMismatch));
     store.register_late_pass(|| Box::new(as_underscore::AsUnderscore));
+    store.register_late_pass(|| Box::new(read_zero_byte_vec::ReadZeroByteVec));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/read_zero_byte_vec.rs b/clippy_lints/src/read_zero_byte_vec.rs
new file mode 100644
index 00000000000..9538a810473
--- /dev/null
+++ b/clippy_lints/src/read_zero_byte_vec.rs
@@ -0,0 +1,142 @@
+use clippy_utils::{
+    diagnostics::{span_lint, span_lint_and_sugg},
+    higher::{get_vec_init_kind, VecInitKind},
+    source::snippet,
+    visitors::expr_visitor_no_bodies,
+};
+use hir::{intravisit::Visitor, ExprKind, Local, PatKind, PathSegment, QPath, StmtKind};
+use rustc_errors::Applicability;
+use rustc_hir as hir;
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// This lint catches reads into a zero-length `Vec`.
+    /// Especially in the case of a call to `with_capacity`, this lint warns that read
+    /// gets the number of bytes from the `Vec`'s length, not its capacity.
+    ///
+    /// ### Why is this bad?
+    /// Reading zero bytes is almost certainly not the intended behavior.
+    ///
+    /// ### Known problems
+    /// In theory, a very unusual read implementation could assign some semantic meaning
+    /// to zero-byte reads. But it seems exceptionally unlikely that code intending to do
+    /// a zero-byte read would allocate a `Vec` for it.
+    ///
+    /// ### Example
+    /// ```rust
+    /// use std::io;
+    /// fn foo<F: io::Read>(mut f: F) {
+    ///     let mut data = Vec::with_capacity(100);
+    ///     f.read(&mut data).unwrap();
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// use std::io;
+    /// fn foo<F: io::Read>(mut f: F) {
+    ///     let mut data = Vec::with_capacity(100);
+    ///     data.resize(100, 0);
+    ///     f.read(&mut data).unwrap();
+    /// }
+    /// ```
+    #[clippy::version = "1.63.0"]
+    pub READ_ZERO_BYTE_VEC,
+    correctness,
+    "checks for reads into a zero-length `Vec`"
+}
+declare_lint_pass!(ReadZeroByteVec => [READ_ZERO_BYTE_VEC]);
+
+impl<'tcx> LateLintPass<'tcx> for ReadZeroByteVec {
+    fn check_block(&mut self, cx: &LateContext<'tcx>, block: &hir::Block<'tcx>) {
+        for (idx, stmt) in block.stmts.iter().enumerate() {
+            if !stmt.span.from_expansion()
+                // matches `let v = Vec::new();`
+                && let StmtKind::Local(local) = stmt.kind
+                && let Local { pat, init: Some(init), .. } = local
+                && let PatKind::Binding(_, _, ident, _) = pat.kind
+                && let Some(vec_init_kind) = get_vec_init_kind(cx, init)
+            {
+                // finds use of `_.read(&mut v)`
+                let mut read_found = false;
+                let mut visitor = expr_visitor_no_bodies(|expr| {
+                    if let ExprKind::MethodCall(path, [_self, arg], _) = expr.kind
+                        && let PathSegment { ident: read_or_read_exact, .. } = *path
+                        && matches!(read_or_read_exact.as_str(), "read" | "read_exact")
+                        && let ExprKind::AddrOf(_, hir::Mutability::Mut, inner) = arg.kind
+                        && let ExprKind::Path(QPath::Resolved(None, inner_path)) = inner.kind
+                        && let [inner_seg] = inner_path.segments
+                        && ident.name == inner_seg.ident.name
+                    {
+                        read_found = true;
+                    }
+                    !read_found
+                });
+
+                let next_stmt_span;
+                if idx == block.stmts.len() - 1 {
+                    // case { .. stmt; expr }
+                    if let Some(e) = block.expr {
+                        visitor.visit_expr(e);
+                        next_stmt_span = e.span;
+                    } else {
+                        return;
+                    }
+                } else {
+                    // case { .. stmt; stmt; .. }
+                    let next_stmt = &block.stmts[idx + 1];
+                    visitor.visit_stmt(next_stmt);
+                    next_stmt_span = next_stmt.span;
+                }
+                drop(visitor);
+
+                if read_found && !next_stmt_span.from_expansion() {
+                    let applicability = Applicability::MaybeIncorrect;
+                    match vec_init_kind {
+                        VecInitKind::WithConstCapacity(len) => {
+                            span_lint_and_sugg(
+                                cx,
+                                READ_ZERO_BYTE_VEC,
+                                next_stmt_span,
+                                "reading zero byte data to `Vec`",
+                                "try",
+                                format!("{}.resize({}, 0); {}",
+                                    ident.as_str(),
+                                    len,
+                                    snippet(cx, next_stmt_span, "..")
+                                ),
+                                applicability,
+                            );
+                        }
+                        VecInitKind::WithExprCapacity(hir_id) => {
+                            let e = cx.tcx.hir().expect_expr(hir_id);
+                            span_lint_and_sugg(
+                                cx,
+                                READ_ZERO_BYTE_VEC,
+                                next_stmt_span,
+                                "reading zero byte data to `Vec`",
+                                "try",
+                                format!("{}.resize({}, 0); {}",
+                                    ident.as_str(),
+                                    snippet(cx, e.span, ".."),
+                                    snippet(cx, next_stmt_span, "..")
+                                ),
+                                applicability,
+                            );
+                        }
+                        _ => {
+                            span_lint(
+                                cx,
+                                READ_ZERO_BYTE_VEC,
+                                next_stmt_span,
+                                "reading zero byte data to `Vec`",
+                            );
+
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/tests/ui/read_zero_byte_vec.rs b/tests/ui/read_zero_byte_vec.rs
new file mode 100644
index 00000000000..30807e0f8b9
--- /dev/null
+++ b/tests/ui/read_zero_byte_vec.rs
@@ -0,0 +1,87 @@
+#![warn(clippy::read_zero_byte_vec)]
+#![allow(clippy::unused_io_amount)]
+use std::fs::File;
+use std::io;
+use std::io::prelude::*;
+
+extern crate futures;
+use futures::io::{AsyncRead, AsyncReadExt};
+use tokio::io::{AsyncRead as TokioAsyncRead, AsyncReadExt as _, AsyncWrite as TokioAsyncWrite, AsyncWriteExt as _};
+
+fn test() -> io::Result<()> {
+    let cap = 1000;
+    let mut f = File::open("foo.txt").unwrap();
+
+    // should lint
+    let mut data = Vec::with_capacity(20);
+    f.read_exact(&mut data).unwrap();
+
+    // should lint
+    let mut data2 = Vec::with_capacity(cap);
+    f.read_exact(&mut data2)?;
+
+    // should lint
+    let mut data3 = Vec::new();
+    f.read_exact(&mut data3)?;
+
+    // should lint
+    let mut data4 = vec![];
+    let _ = f.read(&mut data4)?;
+
+    // should lint
+    let _ = {
+        let mut data5 = Vec::new();
+        f.read(&mut data5)
+    };
+
+    // should lint
+    let _ = {
+        let mut data6: Vec<u8> = Default::default();
+        f.read(&mut data6)
+    };
+
+    // should not lint
+    let mut buf = [0u8; 100];
+    f.read(&mut buf)?;
+
+    // should not lint
+    let mut empty = vec![];
+    let mut data7 = vec![];
+    f.read(&mut empty);
+
+    // should not lint
+    f.read(&mut data7);
+
+    // should not lint
+    let mut data8 = Vec::new();
+    data8.resize(100, 0);
+    f.read_exact(&mut data8)?;
+
+    // should not lint
+    let mut data9 = vec![1, 2, 3];
+    f.read_exact(&mut data9)?;
+
+    Ok(())
+}
+
+async fn test_futures<R: AsyncRead + Unpin>(r: &mut R) {
+    // should lint
+    let mut data = Vec::new();
+    r.read(&mut data).await.unwrap();
+
+    // should lint
+    let mut data2 = Vec::new();
+    r.read_exact(&mut data2).await.unwrap();
+}
+
+async fn test_tokio<R: TokioAsyncRead + Unpin>(r: &mut R) {
+    // should lint
+    let mut data = Vec::new();
+    r.read(&mut data).await.unwrap();
+
+    // should lint
+    let mut data2 = Vec::new();
+    r.read_exact(&mut data2).await.unwrap();
+}
+
+fn main() {}
diff --git a/tests/ui/read_zero_byte_vec.stderr b/tests/ui/read_zero_byte_vec.stderr
new file mode 100644
index 00000000000..08ba9753d7c
--- /dev/null
+++ b/tests/ui/read_zero_byte_vec.stderr
@@ -0,0 +1,64 @@
+error: reading zero byte data to `Vec`
+  --> $DIR/read_zero_byte_vec.rs:17:5
+   |
+LL |     f.read_exact(&mut data).unwrap();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `data.resize(20, 0); f.read_exact(&mut data).unwrap();`
+   |
+   = note: `-D clippy::read-zero-byte-vec` implied by `-D warnings`
+
+error: reading zero byte data to `Vec`
+  --> $DIR/read_zero_byte_vec.rs:21:5
+   |
+LL |     f.read_exact(&mut data2)?;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `data2.resize(cap, 0); f.read_exact(&mut data2)?;`
+
+error: reading zero byte data to `Vec`
+  --> $DIR/read_zero_byte_vec.rs:25:5
+   |
+LL |     f.read_exact(&mut data3)?;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: reading zero byte data to `Vec`
+  --> $DIR/read_zero_byte_vec.rs:29:5
+   |
+LL |     let _ = f.read(&mut data4)?;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: reading zero byte data to `Vec`
+  --> $DIR/read_zero_byte_vec.rs:34:9
+   |
+LL |         f.read(&mut data5)
+   |         ^^^^^^^^^^^^^^^^^^
+
+error: reading zero byte data to `Vec`
+  --> $DIR/read_zero_byte_vec.rs:40:9
+   |
+LL |         f.read(&mut data6)
+   |         ^^^^^^^^^^^^^^^^^^
+
+error: reading zero byte data to `Vec`
+  --> $DIR/read_zero_byte_vec.rs:70:5
+   |
+LL |     r.read(&mut data).await.unwrap();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: reading zero byte data to `Vec`
+  --> $DIR/read_zero_byte_vec.rs:74:5
+   |
+LL |     r.read_exact(&mut data2).await.unwrap();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: reading zero byte data to `Vec`
+  --> $DIR/read_zero_byte_vec.rs:80:5
+   |
+LL |     r.read(&mut data).await.unwrap();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: reading zero byte data to `Vec`
+  --> $DIR/read_zero_byte_vec.rs:84:5
+   |
+LL |     r.read_exact(&mut data2).await.unwrap();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 10 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 08cfb8ddc3082cfe2c81224ef1d090c3fd2394da Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Tue, 14 Jun 2022 16:28:34 +0000
Subject: Remove error-pattern comments

---
 clippy_lints/src/lib.rs                                               | 2 --
 tests/ui-toml/bad_toml/conf_bad_toml.rs                               | 2 --
 tests/ui-toml/bad_toml_type/conf_bad_type.rs                          | 3 ---
 tests/ui-toml/conf_deprecated_key/conf_deprecated_key.rs              | 3 ---
 tests/ui-toml/good_toml_no_false_negatives/conf_no_false_negatives.rs | 2 --
 tests/ui-toml/toml_unknown_key/conf_unknown_key.rs                    | 2 --
 6 files changed, 14 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 87595a347d3..02499f6e3ef 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1,5 +1,3 @@
-// error-pattern:cargo-clippy
-
 #![feature(array_windows)]
 #![feature(binary_heap_into_iter_sorted)]
 #![feature(box_patterns)]
diff --git a/tests/ui-toml/bad_toml/conf_bad_toml.rs b/tests/ui-toml/bad_toml/conf_bad_toml.rs
index 3b9458fc284..f328e4d9d04 100644
--- a/tests/ui-toml/bad_toml/conf_bad_toml.rs
+++ b/tests/ui-toml/bad_toml/conf_bad_toml.rs
@@ -1,3 +1 @@
-// error-pattern: error reading Clippy's configuration file
-
 fn main() {}
diff --git a/tests/ui-toml/bad_toml_type/conf_bad_type.rs b/tests/ui-toml/bad_toml_type/conf_bad_type.rs
index 8a0062423ad..f328e4d9d04 100644
--- a/tests/ui-toml/bad_toml_type/conf_bad_type.rs
+++ b/tests/ui-toml/bad_toml_type/conf_bad_type.rs
@@ -1,4 +1 @@
-// error-pattern: error reading Clippy's configuration file: `blacklisted-names` is expected to be a
-// `Vec < String >` but is a `integer`
-
 fn main() {}
diff --git a/tests/ui-toml/conf_deprecated_key/conf_deprecated_key.rs b/tests/ui-toml/conf_deprecated_key/conf_deprecated_key.rs
index 2577c1eef92..f328e4d9d04 100644
--- a/tests/ui-toml/conf_deprecated_key/conf_deprecated_key.rs
+++ b/tests/ui-toml/conf_deprecated_key/conf_deprecated_key.rs
@@ -1,4 +1 @@
-// error-pattern: error reading Clippy's configuration file: found deprecated field
-// `cyclomatic-complexity-threshold`. Please use `cognitive-complexity-threshold` instead.
-
 fn main() {}
diff --git a/tests/ui-toml/good_toml_no_false_negatives/conf_no_false_negatives.rs b/tests/ui-toml/good_toml_no_false_negatives/conf_no_false_negatives.rs
index 270b9c5c43c..f328e4d9d04 100644
--- a/tests/ui-toml/good_toml_no_false_negatives/conf_no_false_negatives.rs
+++ b/tests/ui-toml/good_toml_no_false_negatives/conf_no_false_negatives.rs
@@ -1,3 +1 @@
-// error-pattern: should give absolutely no error
-
 fn main() {}
diff --git a/tests/ui-toml/toml_unknown_key/conf_unknown_key.rs b/tests/ui-toml/toml_unknown_key/conf_unknown_key.rs
index a47569f62a3..f328e4d9d04 100644
--- a/tests/ui-toml/toml_unknown_key/conf_unknown_key.rs
+++ b/tests/ui-toml/toml_unknown_key/conf_unknown_key.rs
@@ -1,3 +1 @@
-// error-pattern: error reading Clippy's configuration file: unknown key `foobar`
-
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From a8370d4460ffaa6e1ded585db0bbdd30dc287c62 Mon Sep 17 00:00:00 2001
From: andylizi <andylizi666@gmail.com>
Date: Wed, 15 Jun 2022 17:54:43 +0800
Subject: Fix false positive for `never_loop` struct expression fields

---
 clippy_lints/src/loops/never_loop.rs | 12 +++++++++---
 tests/ui/never_loop.rs               | 17 +++++++++++++++++
 2 files changed, 26 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/never_loop.rs b/clippy_lints/src/loops/never_loop.rs
index c025f5972d5..5d9f1887550 100644
--- a/clippy_lints/src/loops/never_loop.rs
+++ b/clippy_lints/src/loops/never_loop.rs
@@ -117,13 +117,20 @@ fn never_loop_expr(expr: &Expr<'_>, main_loop_id: HirId) -> NeverLoopResult {
         | ExprKind::Type(e, _)
         | ExprKind::Field(e, _)
         | ExprKind::AddrOf(_, _, e)
-        | ExprKind::Struct(_, _, Some(e))
         | ExprKind::Repeat(e, _)
         | ExprKind::DropTemps(e) => never_loop_expr(e, main_loop_id),
         ExprKind::Let(let_expr) => never_loop_expr(let_expr.init, main_loop_id),
         ExprKind::Array(es) | ExprKind::MethodCall(_, es, _) | ExprKind::Tup(es) => {
             never_loop_expr_all(&mut es.iter(), main_loop_id)
         },
+        ExprKind::Struct(_, fields, base) => {
+            let fields = never_loop_expr_all(&mut fields.iter().map(|f| f.expr), main_loop_id);
+            if let Some(base) = base {
+                combine_both(fields, never_loop_expr(base, main_loop_id))
+            } else {
+                fields
+            }
+        },
         ExprKind::Call(e, es) => never_loop_expr_all(&mut once(e).chain(es.iter()), main_loop_id),
         ExprKind::Binary(_, e1, e2)
         | ExprKind::Assign(e1, e2, _)
@@ -180,8 +187,7 @@ fn never_loop_expr(expr: &Expr<'_>, main_loop_id: HirId) -> NeverLoopResult {
                 | InlineAsmOperand::SymStatic { .. } => NeverLoopResult::Otherwise,
             })
             .fold(NeverLoopResult::Otherwise, combine_both),
-        ExprKind::Struct(_, _, None)
-        | ExprKind::Yield(_, _)
+        ExprKind::Yield(_, _)
         | ExprKind::Closure(_, _, _, _, _)
         | ExprKind::Path(_)
         | ExprKind::ConstBlock(_)
diff --git a/tests/ui/never_loop.rs b/tests/ui/never_loop.rs
index 2770eb2b2ab..0a21589dd0d 100644
--- a/tests/ui/never_loop.rs
+++ b/tests/ui/never_loop.rs
@@ -186,6 +186,23 @@ pub fn test16() {
     }
 }
 
+// Issue #9001: `continue` in struct expression fields
+pub fn test17() {
+    struct Foo {
+        f: (),
+    }
+
+    let mut n = 0;
+    let _ = loop {
+        break Foo {
+            f: if n < 5 {
+                n += 1;
+                continue;
+            },
+        };
+    };
+}
+
 fn main() {
     test1();
     test2();
-- 
cgit 1.4.1-3-g733a5


From 2bb8c45026f0bfc244390f2d6cecc05cfa1f1171 Mon Sep 17 00:00:00 2001
From: kyoto7250 <50972773+kyoto7250@users.noreply.github.com>
Date: Sun, 12 Jun 2022 21:30:55 +0900
Subject: feat(lint): add default_iter_empty

Update description in clippy_lints/src/default_iter_empty.rs

Co-authored-by: Fridtjof Stoldt <xFrednet@gmail.com>

Update clippy_lints/src/default_iter_empty.rs

Co-authored-by: Alex Macleod <alex@macleod.io>

Update clippy_lints/src/default_iter_empty.rs

Co-authored-by: Alex Macleod <alex@macleod.io>

renamed default_iter_empty to default_instead_of_iter_empty

Avoid duplicate messages

add tests for regression

rewrite 'Why is this bad?'

cargo dev fmt

delete default_iter_empty lint in renamed_lint.rs

rewrite a message in the suggestion

cargo dev update_lints --check
---
 CHANGELOG.md                                      |  1 +
 clippy_lints/src/default_instead_of_iter_empty.rs | 68 +++++++++++++++++++++++
 clippy_lints/src/lib.register_all.rs              |  1 +
 clippy_lints/src/lib.register_lints.rs            |  1 +
 clippy_lints/src/lib.register_style.rs            |  1 +
 clippy_lints/src/lib.rs                           |  2 +
 clippy_utils/src/paths.rs                         |  1 +
 tests/ui/default_instead_of_iter_empty.fixed      | 21 +++++++
 tests/ui/default_instead_of_iter_empty.rs         | 21 +++++++
 tests/ui/default_instead_of_iter_empty.stderr     | 22 ++++++++
 10 files changed, 139 insertions(+)
 create mode 100644 clippy_lints/src/default_instead_of_iter_empty.rs
 create mode 100644 tests/ui/default_instead_of_iter_empty.fixed
 create mode 100644 tests/ui/default_instead_of_iter_empty.rs
 create mode 100644 tests/ui/default_instead_of_iter_empty.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 6aaf12ed932..d64dd772ac5 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3348,6 +3348,7 @@ Released 2018-09-13
 [`debug_assert_with_mut_call`]: https://rust-lang.github.io/rust-clippy/master/index.html#debug_assert_with_mut_call
 [`decimal_literal_representation`]: https://rust-lang.github.io/rust-clippy/master/index.html#decimal_literal_representation
 [`declare_interior_mutable_const`]: https://rust-lang.github.io/rust-clippy/master/index.html#declare_interior_mutable_const
+[`default_instead_of_iter_empty`]: https://rust-lang.github.io/rust-clippy/master/index.html#default_instead_of_iter_empty
 [`default_numeric_fallback`]: https://rust-lang.github.io/rust-clippy/master/index.html#default_numeric_fallback
 [`default_trait_access`]: https://rust-lang.github.io/rust-clippy/master/index.html#default_trait_access
 [`default_union_representation`]: https://rust-lang.github.io/rust-clippy/master/index.html#default_union_representation
diff --git a/clippy_lints/src/default_instead_of_iter_empty.rs b/clippy_lints/src/default_instead_of_iter_empty.rs
new file mode 100644
index 00000000000..3c996d3d2ae
--- /dev/null
+++ b/clippy_lints/src/default_instead_of_iter_empty.rs
@@ -0,0 +1,68 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::last_path_segment;
+use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::{match_def_path, paths};
+use rustc_errors::Applicability;
+use rustc_hir::{def, Expr, ExprKind, GenericArg, QPath, TyKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// It checks for `std::iter::Empty::default()` and suggests replacing it with
+    /// `std::iter::empty()`.
+    /// ### Why is this bad?
+    /// `std::iter::empty()` is the more idiomatic way.
+    /// ### Example
+    /// ```rust
+    /// let _ = std::iter::Empty::<usize>::default();
+    /// let iter: std::iter::Empty<usize> = std::iter::Empty::default();
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// let _ = std::iter::empty::<usize>();
+    /// let iter: std::iter::Empty<usize> = std::iter::empty();
+    /// ```
+    #[clippy::version = "1.63.0"]
+    pub DEFAULT_INSTEAD_OF_ITER_EMPTY,
+    style,
+    "check `std::iter::Empty::default()` and replace with `std::iter::empty()`"
+}
+declare_lint_pass!(DefaultIterEmpty => [DEFAULT_INSTEAD_OF_ITER_EMPTY]);
+
+impl<'tcx> LateLintPass<'tcx> for DefaultIterEmpty {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        if let ExprKind::Call(iter_expr, []) = &expr.kind
+            && let ExprKind::Path(QPath::TypeRelative(ty, _)) = &iter_expr.kind
+            && let TyKind::Path(ty_path) = &ty.kind
+            && let QPath::Resolved(None, path) = ty_path
+            && let def::Res::Def(_, def_id) = &path.res
+            && match_def_path(cx, *def_id, &paths::ITER_EMPTY)
+        {
+            let mut applicability = Applicability::MachineApplicable;
+            let sugg = make_sugg(cx, ty_path, &mut applicability);
+            span_lint_and_sugg(
+                cx,
+                DEFAULT_INSTEAD_OF_ITER_EMPTY,
+                expr.span,
+                "`std::iter::empty()` is the more idiomatic way",
+                "try",
+                sugg,
+                applicability,
+            );
+        }
+    }
+}
+
+fn make_sugg(cx: &LateContext<'_>, ty_path: &rustc_hir::QPath<'_>, applicability: &mut Applicability) -> String {
+    if let Some(last) = last_path_segment(ty_path).args
+        && let Some(iter_ty) = last.args.iter().find_map(|arg| match arg {
+            GenericArg::Type(ty) => Some(ty),
+            _ => None,
+        })
+    {
+        format!("std::iter::empty::<{}>()", snippet_with_applicability(cx, iter_ty.span, "..", applicability))
+    } else {
+        "std::iter::empty()".to_owned()
+    }
+}
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 8a2cfbff953..7876f21f6e6 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -43,6 +43,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(copies::IF_SAME_THEN_ELSE),
     LintId::of(crate_in_macro_def::CRATE_IN_MACRO_DEF),
     LintId::of(default::FIELD_REASSIGN_WITH_DEFAULT),
+    LintId::of(default_instead_of_iter_empty::DEFAULT_INSTEAD_OF_ITER_EMPTY),
     LintId::of(dereference::NEEDLESS_BORROW),
     LintId::of(derivable_impls::DERIVABLE_IMPLS),
     LintId::of(derive::DERIVE_HASH_XOR_EQ),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 8ad984c68b8..de22f50cf94 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -105,6 +105,7 @@ store.register_lints(&[
     dbg_macro::DBG_MACRO,
     default::DEFAULT_TRAIT_ACCESS,
     default::FIELD_REASSIGN_WITH_DEFAULT,
+    default_instead_of_iter_empty::DEFAULT_INSTEAD_OF_ITER_EMPTY,
     default_numeric_fallback::DEFAULT_NUMERIC_FALLBACK,
     default_union_representation::DEFAULT_UNION_REPRESENTATION,
     dereference::EXPLICIT_DEREF_METHODS,
diff --git a/clippy_lints/src/lib.register_style.rs b/clippy_lints/src/lib.register_style.rs
index b6992ae0ad2..d52ec50e542 100644
--- a/clippy_lints/src/lib.register_style.rs
+++ b/clippy_lints/src/lib.register_style.rs
@@ -14,6 +14,7 @@ store.register_group(true, "clippy::style", Some("clippy_style"), vec![
     LintId::of(collapsible_if::COLLAPSIBLE_IF),
     LintId::of(comparison_chain::COMPARISON_CHAIN),
     LintId::of(default::FIELD_REASSIGN_WITH_DEFAULT),
+    LintId::of(default_instead_of_iter_empty::DEFAULT_INSTEAD_OF_ITER_EMPTY),
     LintId::of(dereference::NEEDLESS_BORROW),
     LintId::of(derive::DERIVE_PARTIAL_EQ_WITHOUT_EQ),
     LintId::of(disallowed_methods::DISALLOWED_METHODS),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 84898eae05a..dcee11cc28c 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -199,6 +199,7 @@ mod crate_in_macro_def;
 mod create_dir;
 mod dbg_macro;
 mod default;
+mod default_instead_of_iter_empty;
 mod default_numeric_fallback;
 mod default_union_representation;
 mod dereference;
@@ -910,6 +911,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(mismatching_type_param_order::TypeParamMismatch));
     store.register_late_pass(|| Box::new(as_underscore::AsUnderscore));
     store.register_late_pass(|| Box::new(read_zero_byte_vec::ReadZeroByteVec));
+    store.register_late_pass(|| Box::new(default_instead_of_iter_empty::DefaultIterEmpty));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index 89789c3d851..b31e2c1cdb1 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -62,6 +62,7 @@ pub const IO_WRITE: [&str; 3] = ["std", "io", "Write"];
 pub const IPADDR_V4: [&str; 5] = ["std", "net", "ip", "IpAddr", "V4"];
 pub const IPADDR_V6: [&str; 5] = ["std", "net", "ip", "IpAddr", "V6"];
 pub const ITER_COUNT: [&str; 6] = ["core", "iter", "traits", "iterator", "Iterator", "count"];
+pub const ITER_EMPTY: [&str; 5] = ["core", "iter", "sources", "empty", "Empty"];
 pub const ITER_REPEAT: [&str; 5] = ["core", "iter", "sources", "repeat", "repeat"];
 #[expect(clippy::invalid_paths)] // internal lints do not know about all external crates
 pub const ITERTOOLS_NEXT_TUPLE: [&str; 3] = ["itertools", "Itertools", "next_tuple"];
diff --git a/tests/ui/default_instead_of_iter_empty.fixed b/tests/ui/default_instead_of_iter_empty.fixed
new file mode 100644
index 00000000000..f1abfdcd6ce
--- /dev/null
+++ b/tests/ui/default_instead_of_iter_empty.fixed
@@ -0,0 +1,21 @@
+// run-rustfix
+#![warn(clippy::default_instead_of_iter_empty)]
+#![allow(dead_code)]
+use std::collections::HashMap;
+
+#[derive(Default)]
+struct Iter {
+    iter: std::iter::Empty<usize>,
+}
+
+fn main() {
+    // Do lint.
+    let _ = std::iter::empty::<usize>();
+    let _ = std::iter::empty::<HashMap<usize, usize>>();
+    let _foo: std::iter::Empty<usize> = std::iter::empty();
+
+    // Do not lint.
+    let _ = Vec::<usize>::default();
+    let _ = String::default();
+    let _ = Iter::default();
+}
diff --git a/tests/ui/default_instead_of_iter_empty.rs b/tests/ui/default_instead_of_iter_empty.rs
new file mode 100644
index 00000000000..2630519c46d
--- /dev/null
+++ b/tests/ui/default_instead_of_iter_empty.rs
@@ -0,0 +1,21 @@
+// run-rustfix
+#![warn(clippy::default_instead_of_iter_empty)]
+#![allow(dead_code)]
+use std::collections::HashMap;
+
+#[derive(Default)]
+struct Iter {
+    iter: std::iter::Empty<usize>,
+}
+
+fn main() {
+    // Do lint.
+    let _ = std::iter::Empty::<usize>::default();
+    let _ = std::iter::Empty::<HashMap<usize, usize>>::default();
+    let _foo: std::iter::Empty<usize> = std::iter::Empty::default();
+
+    // Do not lint.
+    let _ = Vec::<usize>::default();
+    let _ = String::default();
+    let _ = Iter::default();
+}
diff --git a/tests/ui/default_instead_of_iter_empty.stderr b/tests/ui/default_instead_of_iter_empty.stderr
new file mode 100644
index 00000000000..460fc84def8
--- /dev/null
+++ b/tests/ui/default_instead_of_iter_empty.stderr
@@ -0,0 +1,22 @@
+error: `std::iter::empty()` is the more idiomatic way
+  --> $DIR/default_instead_of_iter_empty.rs:13:13
+   |
+LL |     let _ = std::iter::Empty::<usize>::default();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::iter::empty::<usize>()`
+   |
+   = note: `-D clippy::default-instead-of-iter-empty` implied by `-D warnings`
+
+error: `std::iter::empty()` is the more idiomatic way
+  --> $DIR/default_instead_of_iter_empty.rs:14:13
+   |
+LL |     let _ = std::iter::Empty::<HashMap<usize, usize>>::default();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::iter::empty::<HashMap<usize, usize>>()`
+
+error: `std::iter::empty()` is the more idiomatic way
+  --> $DIR/default_instead_of_iter_empty.rs:15:41
+   |
+LL |     let _foo: std::iter::Empty<usize> = std::iter::Empty::default();
+   |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::iter::empty()`
+
+error: aborting due to 3 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From a9215d90c8c576e5f2afd1ef69c6f172229e021e Mon Sep 17 00:00:00 2001
From: kyoto7250 <50972773+kyoto7250@users.noreply.github.com>
Date: Thu, 16 Jun 2022 23:19:46 +0900
Subject: ignore item in thread_local!

---
 clippy_lints/src/non_copy_const.rs                | 13 ++++++++++---
 tests/ui/declare_interior_mutable_const/others.rs |  5 +++++
 2 files changed, 15 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/non_copy_const.rs b/clippy_lints/src/non_copy_const.rs
index b727105f670..66b346bea20 100644
--- a/clippy_lints/src/non_copy_const.rs
+++ b/clippy_lints/src/non_copy_const.rs
@@ -6,6 +6,7 @@ use std::ptr;
 
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::in_constant;
+use clippy_utils::macros::macro_backtrace;
 use if_chain::if_chain;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::def_id::DefId;
@@ -17,7 +18,7 @@ use rustc_middle::mir::interpret::{ConstValue, ErrorHandled};
 use rustc_middle::ty::adjustment::Adjust;
 use rustc_middle::ty::{self, Const, Ty};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::{InnerSpan, Span, DUMMY_SP};
+use rustc_span::{sym, InnerSpan, Span, DUMMY_SP};
 use rustc_typeck::hir_ty_to_ty;
 
 // FIXME: this is a correctness problem but there's no suitable
@@ -250,8 +251,14 @@ impl<'tcx> LateLintPass<'tcx> for NonCopyConst {
     fn check_item(&mut self, cx: &LateContext<'tcx>, it: &'tcx Item<'_>) {
         if let ItemKind::Const(hir_ty, body_id) = it.kind {
             let ty = hir_ty_to_ty(cx.tcx, hir_ty);
-
-            if is_unfrozen(cx, ty) && is_value_unfrozen_poly(cx, body_id, ty) {
+            if !macro_backtrace(it.span).last().map_or(false, |macro_call| {
+                matches!(
+                    cx.tcx.get_diagnostic_name(macro_call.def_id),
+                    Some(sym::thread_local_macro)
+                )
+            }) && is_unfrozen(cx, ty)
+                && is_value_unfrozen_poly(cx, body_id, ty)
+            {
                 lint(cx, Source::Item { item: it.span });
             }
         }
diff --git a/tests/ui/declare_interior_mutable_const/others.rs b/tests/ui/declare_interior_mutable_const/others.rs
index 48c5e9537d6..62af545db50 100644
--- a/tests/ui/declare_interior_mutable_const/others.rs
+++ b/tests/ui/declare_interior_mutable_const/others.rs
@@ -31,4 +31,9 @@ const NO_ANN: &dyn Display = &70;
 static STATIC_TUPLE: (AtomicUsize, String) = (ATOMIC, STRING);
 //^ there should be no lints on this line
 
+// issue #8493
+thread_local! {
+    static THREAD_LOCAL: Cell<i32> = const { Cell::new(0) };
+}
+
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 4a4b5cf06153d8e8702ea5105d777d4822871edf Mon Sep 17 00:00:00 2001
From: kyoto7250 <50972773+kyoto7250@users.noreply.github.com>
Date: Mon, 20 Jun 2022 13:17:54 +0900
Subject: confirm  using chain in collapsible_span_lint_calls

---
 clippy_lints/src/utils/internal_lints.rs            | 1 +
 tests/ui-internal/collapsible_span_lint_calls.fixed | 7 ++++++-
 tests/ui-internal/collapsible_span_lint_calls.rs    | 7 ++++++-
 3 files changed, 13 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs
index b885e5132f1..36a85b0869f 100644
--- a/clippy_lints/src/utils/internal_lints.rs
+++ b/clippy_lints/src/utils/internal_lints.rs
@@ -668,6 +668,7 @@ impl<'tcx> LateLintPass<'tcx> for CollapsibleCalls {
             let body = cx.tcx.hir().body(*body);
             let only_expr = peel_blocks_with_stmt(&body.value);
             if let ExprKind::MethodCall(ps, span_call_args, _) = &only_expr.kind;
+            if let ExprKind::Path(..) = span_call_args[0].kind;
             then {
                 let and_then_snippets = get_and_then_snippets(cx, and_then_args);
                 let mut sle = SpanlessEq::new(cx).deny_side_effects();
diff --git a/tests/ui-internal/collapsible_span_lint_calls.fixed b/tests/ui-internal/collapsible_span_lint_calls.fixed
index a5a6f20ddd5..9f299d7dec7 100644
--- a/tests/ui-internal/collapsible_span_lint_calls.fixed
+++ b/tests/ui-internal/collapsible_span_lint_calls.fixed
@@ -45,7 +45,12 @@ impl EarlyLintPass for Pass {
             if predicate {
                 db.note(note_msg);
             }
-        })
+        });
+
+        // Issue #8798
+        span_lint_and_then(cx, TEST_LINT, expr.span, lint_msg, |db| {
+            db.help(help_msg).help(help_msg);
+        });
     }
 }
 
diff --git a/tests/ui-internal/collapsible_span_lint_calls.rs b/tests/ui-internal/collapsible_span_lint_calls.rs
index 6d783aa0786..2b113f555e4 100644
--- a/tests/ui-internal/collapsible_span_lint_calls.rs
+++ b/tests/ui-internal/collapsible_span_lint_calls.rs
@@ -55,7 +55,12 @@ impl EarlyLintPass for Pass {
             if predicate {
                 db.note(note_msg);
             }
-        })
+        });
+
+        // Issue #8798
+        span_lint_and_then(cx, TEST_LINT, expr.span, lint_msg, |db| {
+            db.help(help_msg).help(help_msg);
+        });
     }
 }
 
-- 
cgit 1.4.1-3-g733a5


From a0b107bbb624ab4bf889f916707d2f025964d3be Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Mon, 20 Jun 2022 12:03:27 +0000
Subject: unused_async: lint async methods

---
 clippy_lints/src/unused_async.rs           | 28 ++++++++++++------------
 tests/ui/methods.rs                        |  1 +
 tests/ui/methods.stderr                    |  4 ++--
 tests/ui/should_impl_trait/corner_cases.rs |  3 ++-
 tests/ui/unused_async.rs                   | 34 ++++++++++++++++++++++++++++++
 tests/ui/unused_async.stderr               | 14 ++++++++++--
 6 files changed, 64 insertions(+), 20 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unused_async.rs b/clippy_lints/src/unused_async.rs
index c8ec4442ab1..a832dfcccaf 100644
--- a/clippy_lints/src/unused_async.rs
+++ b/clippy_lints/src/unused_async.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_help;
 use rustc_hir::intravisit::{walk_expr, walk_fn, FnKind, Visitor};
-use rustc_hir::{Body, Expr, ExprKind, FnDecl, FnHeader, HirId, IsAsync, YieldSource};
+use rustc_hir::{Body, Expr, ExprKind, FnDecl, HirId, IsAsync, YieldSource};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::nested_filter;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -68,20 +68,18 @@ impl<'tcx> LateLintPass<'tcx> for UnusedAsync {
         span: Span,
         hir_id: HirId,
     ) {
-        if let FnKind::ItemFn(_, _, FnHeader { asyncness, .. }) = &fn_kind {
-            if matches!(asyncness, IsAsync::Async) {
-                let mut visitor = AsyncFnVisitor { cx, found_await: false };
-                walk_fn(&mut visitor, fn_kind, fn_decl, body.id(), span, hir_id);
-                if !visitor.found_await {
-                    span_lint_and_help(
-                        cx,
-                        UNUSED_ASYNC,
-                        span,
-                        "unused `async` for function with no await statements",
-                        None,
-                        "consider removing the `async` from this function",
-                    );
-                }
+        if !span.from_expansion() && fn_kind.asyncness() == IsAsync::Async {
+            let mut visitor = AsyncFnVisitor { cx, found_await: false };
+            walk_fn(&mut visitor, fn_kind, fn_decl, body.id(), span, hir_id);
+            if !visitor.found_await {
+                span_lint_and_help(
+                    cx,
+                    UNUSED_ASYNC,
+                    span,
+                    "unused `async` for function with no await statements",
+                    None,
+                    "consider removing the `async` from this function",
+                );
             }
         }
     }
diff --git a/tests/ui/methods.rs b/tests/ui/methods.rs
index 9805097084d..1970c2eae53 100644
--- a/tests/ui/methods.rs
+++ b/tests/ui/methods.rs
@@ -15,6 +15,7 @@
     clippy::use_self,
     clippy::useless_format,
     clippy::wrong_self_convention,
+    clippy::unused_async,
     clippy::unused_self,
     unused
 )]
diff --git a/tests/ui/methods.stderr b/tests/ui/methods.stderr
index 6be38b24fbd..b63672dd6fd 100644
--- a/tests/ui/methods.stderr
+++ b/tests/ui/methods.stderr
@@ -1,5 +1,5 @@
 error: methods called `new` usually return `Self`
-  --> $DIR/methods.rs:103:5
+  --> $DIR/methods.rs:104:5
    |
 LL | /     fn new() -> i32 {
 LL | |         0
@@ -9,7 +9,7 @@ LL | |     }
    = note: `-D clippy::new-ret-no-self` implied by `-D warnings`
 
 error: called `filter(..).next()` on an `Iterator`. This is more succinctly expressed by calling `.find(..)` instead
-  --> $DIR/methods.rs:124:13
+  --> $DIR/methods.rs:125:13
    |
 LL |       let _ = v.iter().filter(|&x| {
    |  _____________^
diff --git a/tests/ui/should_impl_trait/corner_cases.rs b/tests/ui/should_impl_trait/corner_cases.rs
index 1ccb0a1d167..50999c6f219 100644
--- a/tests/ui/should_impl_trait/corner_cases.rs
+++ b/tests/ui/should_impl_trait/corner_cases.rs
@@ -8,7 +8,8 @@
     clippy::missing_safety_doc,
     clippy::wrong_self_convention,
     clippy::missing_panics_doc,
-    clippy::return_self_not_must_use
+    clippy::return_self_not_must_use,
+    clippy::unused_async
 )]
 
 use std::ops::Mul;
diff --git a/tests/ui/unused_async.rs b/tests/ui/unused_async.rs
index 2a3a506a57b..4ca7f29b34c 100644
--- a/tests/ui/unused_async.rs
+++ b/tests/ui/unused_async.rs
@@ -1,5 +1,8 @@
 #![warn(clippy::unused_async)]
 
+use std::future::Future;
+use std::pin::Pin;
+
 async fn foo() -> i32 {
     4
 }
@@ -8,6 +11,37 @@ async fn bar() -> i32 {
     foo().await
 }
 
+struct S;
+
+impl S {
+    async fn unused(&self) -> i32 {
+        1
+    }
+
+    async fn used(&self) -> i32 {
+        self.unused().await
+    }
+}
+
+trait AsyncTrait {
+    fn trait_method() -> Pin<Box<dyn Future<Output = i32>>>;
+}
+
+macro_rules! async_trait_impl {
+    () => {
+        impl AsyncTrait for S {
+            fn trait_method() -> Pin<Box<dyn Future<Output = i32>>> {
+                async fn unused() -> i32 {
+                    5
+                }
+
+                Box::pin(unused())
+            }
+        }
+    };
+}
+async_trait_impl!();
+
 fn main() {
     foo();
     bar();
diff --git a/tests/ui/unused_async.stderr b/tests/ui/unused_async.stderr
index cc6096d65d9..8b8ad065a4c 100644
--- a/tests/ui/unused_async.stderr
+++ b/tests/ui/unused_async.stderr
@@ -1,5 +1,5 @@
 error: unused `async` for function with no await statements
-  --> $DIR/unused_async.rs:3:1
+  --> $DIR/unused_async.rs:6:1
    |
 LL | / async fn foo() -> i32 {
 LL | |     4
@@ -9,5 +9,15 @@ LL | | }
    = note: `-D clippy::unused-async` implied by `-D warnings`
    = help: consider removing the `async` from this function
 
-error: aborting due to previous error
+error: unused `async` for function with no await statements
+  --> $DIR/unused_async.rs:17:5
+   |
+LL | /     async fn unused(&self) -> i32 {
+LL | |         1
+LL | |     }
+   | |_____^
+   |
+   = help: consider removing the `async` from this function
+
+error: aborting due to 2 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 6fc84d4da39942857e243cfe951bbefbdba5250b Mon Sep 17 00:00:00 2001
From: Marcel Hellwig <git@cookiesoft.de>
Date: Mon, 20 Jun 2022 23:44:18 +0200
Subject: put parentheses around neg_multiply suggestion if needed

---
 clippy_lints/src/neg_multiply.rs |  9 ++++++++-
 tests/ui/neg_multiply.fixed      |  3 +++
 tests/ui/neg_multiply.rs         |  3 +++
 tests/ui/neg_multiply.stderr     | 14 +++++++++++++-
 4 files changed, 27 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/neg_multiply.rs b/clippy_lints/src/neg_multiply.rs
index ce6bb38b7c0..b087cfb36b1 100644
--- a/clippy_lints/src/neg_multiply.rs
+++ b/clippy_lints/src/neg_multiply.rs
@@ -1,7 +1,9 @@
 use clippy_utils::consts::{self, Constant};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::sugg::has_enclosing_paren;
 use if_chain::if_chain;
+use rustc_ast::util::parser::PREC_PREFIX;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
@@ -58,7 +60,12 @@ fn check_mul(cx: &LateContext<'_>, span: Span, lit: &Expr<'_>, exp: &Expr<'_>) {
 
         then {
             let mut applicability = Applicability::MachineApplicable;
-            let suggestion = format!("-{}", snippet_with_applicability(cx, exp.span, "..", &mut applicability));
+            let snip = snippet_with_applicability(cx, exp.span, "..", &mut applicability);
+            let suggestion = if exp.precedence().order() < PREC_PREFIX && !has_enclosing_paren(&snip) {
+                format!("-({})", snip)
+            } else {
+                format!("-{}", snip)
+            };
             span_lint_and_sugg(
                     cx,
                     NEG_MULTIPLY,
diff --git a/tests/ui/neg_multiply.fixed b/tests/ui/neg_multiply.fixed
index 35af9d6ae31..58ab9e85678 100644
--- a/tests/ui/neg_multiply.fixed
+++ b/tests/ui/neg_multiply.fixed
@@ -38,6 +38,9 @@ fn main() {
 
     0xcafe | -0xff00;
 
+    -(3_usize as i32);
+    -(3_usize as i32);
+
     -1 * -1; // should be ok
 
     X * -1; // should be ok
diff --git a/tests/ui/neg_multiply.rs b/tests/ui/neg_multiply.rs
index 7dbdb0906ce..581290dc72e 100644
--- a/tests/ui/neg_multiply.rs
+++ b/tests/ui/neg_multiply.rs
@@ -38,6 +38,9 @@ fn main() {
 
     0xcafe | 0xff00 * -1;
 
+    3_usize as i32 * -1;
+    (3_usize as i32) * -1;
+
     -1 * -1; // should be ok
 
     X * -1; // should be ok
diff --git a/tests/ui/neg_multiply.stderr b/tests/ui/neg_multiply.stderr
index dbf8fb36938..388ef29eb85 100644
--- a/tests/ui/neg_multiply.stderr
+++ b/tests/ui/neg_multiply.stderr
@@ -36,5 +36,17 @@ error: this multiplication by -1 can be written more succinctly
 LL |     0xcafe | 0xff00 * -1;
    |              ^^^^^^^^^^^ help: consider using: `-0xff00`
 
-error: aborting due to 6 previous errors
+error: this multiplication by -1 can be written more succinctly
+  --> $DIR/neg_multiply.rs:41:5
+   |
+LL |     3_usize as i32 * -1;
+   |     ^^^^^^^^^^^^^^^^^^^ help: consider using: `-(3_usize as i32)`
+
+error: this multiplication by -1 can be written more succinctly
+  --> $DIR/neg_multiply.rs:42:5
+   |
+LL |     (3_usize as i32) * -1;
+   |     ^^^^^^^^^^^^^^^^^^^^^ help: consider using: `-(3_usize as i32)`
+
+error: aborting due to 8 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 2476100c857147c3402b1b7c05ed65a84ceb228e Mon Sep 17 00:00:00 2001
From: Preston From <prestonfrom@gmail.com>
Date: Fri, 10 Jun 2022 01:14:28 -0600
Subject: Add details about significant drop in match scrutinees causing
 deadlocks

Adds more details about how a significant drop in a match scrutinee can
cause a deadlock and include link to documentation. Emits messages
indicating temporaries with significant drops in arms of matches and
message about possible deadlocks/unexpected behavior.

changelog: Add more details to significant drop lint to explicitly show
how temporaries in match scrutinees can cause deadlocks/unexpected
behavior.
---
 clippy_lints/src/matches/mod.rs                    |   2 +-
 .../src/matches/significant_drop_in_scrutinee.rs   | 160 ++++++++----
 tests/ui/significant_drop_in_scrutinee.rs          |  16 ++
 tests/ui/significant_drop_in_scrutinee.stderr      | 277 +++++++++++++++++----
 4 files changed, 363 insertions(+), 92 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/mod.rs b/clippy_lints/src/matches/mod.rs
index 3e765173fb9..d43ad1b8c9c 100644
--- a/clippy_lints/src/matches/mod.rs
+++ b/clippy_lints/src/matches/mod.rs
@@ -963,7 +963,7 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
                 return;
             }
             if matches!(source, MatchSource::Normal | MatchSource::ForLoopDesugar) {
-                significant_drop_in_scrutinee::check(cx, expr, ex, source);
+                significant_drop_in_scrutinee::check(cx, expr, ex, arms, source);
             }
 
             collapsible_match::check_match(cx, arms);
diff --git a/clippy_lints/src/matches/significant_drop_in_scrutinee.rs b/clippy_lints/src/matches/significant_drop_in_scrutinee.rs
index dcaf6f865de..59ca33cbcc7 100644
--- a/clippy_lints/src/matches/significant_drop_in_scrutinee.rs
+++ b/clippy_lints/src/matches/significant_drop_in_scrutinee.rs
@@ -4,7 +4,7 @@ use clippy_utils::get_attr;
 use clippy_utils::source::{indent_of, snippet};
 use rustc_errors::{Applicability, Diagnostic};
 use rustc_hir::intravisit::{walk_expr, Visitor};
-use rustc_hir::{Expr, ExprKind, MatchSource};
+use rustc_hir::{Arm, Expr, ExprKind, MatchSource};
 use rustc_lint::{LateContext, LintContext};
 use rustc_middle::ty::subst::GenericArgKind;
 use rustc_middle::ty::{Ty, TypeAndMut};
@@ -16,12 +16,21 @@ pub(super) fn check<'tcx>(
     cx: &LateContext<'tcx>,
     expr: &'tcx Expr<'tcx>,
     scrutinee: &'tcx Expr<'_>,
+    arms: &'tcx [Arm<'_>],
     source: MatchSource,
 ) {
     if let Some((suggestions, message)) = has_significant_drop_in_scrutinee(cx, scrutinee, source) {
         for found in suggestions {
             span_lint_and_then(cx, SIGNIFICANT_DROP_IN_SCRUTINEE, found.found_span, message, |diag| {
                 set_diagnostic(diag, cx, expr, found);
+                let s = Span::new(expr.span.hi(), expr.span.hi(), expr.span.ctxt(), None);
+                diag.span_label(s, "original temporary lives until here");
+                if let Some(spans) = has_significant_drop_in_arms(cx, arms) {
+                    for span in spans {
+                        diag.span_label(span, "significant drop in arm here");
+                    }
+                    diag.note("this might lead to deadlocks or other unexpected behavior");
+                }
             });
         }
     }
@@ -80,22 +89,77 @@ fn has_significant_drop_in_scrutinee<'tcx, 'a>(
     let mut helper = SigDropHelper::new(cx);
     helper.find_sig_drop(scrutinee).map(|drops| {
         let message = if source == MatchSource::Normal {
-            "temporary with significant drop in match scrutinee"
+            "temporary with drop impl with side effects in match scrutinee lives to end of block"
         } else {
-            "temporary with significant drop in for loop"
+            "temporary with drop impl with side effects in for loop condition lives to end of block"
         };
         (drops, message)
     })
 }
 
+struct SigDropChecker<'a, 'tcx> {
+    seen_types: FxHashSet<Ty<'tcx>>,
+    cx: &'a LateContext<'tcx>,
+}
+
+impl<'a, 'tcx> SigDropChecker<'a, 'tcx> {
+    fn new(cx: &'a LateContext<'tcx>) -> SigDropChecker<'a, 'tcx> {
+        SigDropChecker {
+            seen_types: FxHashSet::default(),
+            cx,
+        }
+    }
+
+    fn get_type(&self, ex: &'tcx Expr<'_>) -> Ty<'tcx> {
+        self.cx.typeck_results().expr_ty(ex)
+    }
+
+    fn has_seen_type(&mut self, ty: Ty<'tcx>) -> bool {
+        !self.seen_types.insert(ty)
+    }
+
+    fn has_sig_drop_attr(&mut self, cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
+        if let Some(adt) = ty.ty_adt_def() {
+            if get_attr(cx.sess(), cx.tcx.get_attrs_unchecked(adt.did()), "has_significant_drop").count() > 0 {
+                return true;
+            }
+        }
+
+        match ty.kind() {
+            rustc_middle::ty::Adt(a, b) => {
+                for f in a.all_fields() {
+                    let ty = f.ty(cx.tcx, b);
+                    if !self.has_seen_type(ty) && self.has_sig_drop_attr(cx, ty) {
+                        return true;
+                    }
+                }
+
+                for generic_arg in b.iter() {
+                    if let GenericArgKind::Type(ty) = generic_arg.unpack() {
+                        if self.has_sig_drop_attr(cx, ty) {
+                            return true;
+                        }
+                    }
+                }
+                false
+            },
+            rustc_middle::ty::Array(ty, _)
+            | rustc_middle::ty::RawPtr(TypeAndMut { ty, .. })
+            | rustc_middle::ty::Ref(_, ty, _)
+            | rustc_middle::ty::Slice(ty) => self.has_sig_drop_attr(cx, *ty),
+            _ => false,
+        }
+    }
+}
+
 struct SigDropHelper<'a, 'tcx> {
     cx: &'a LateContext<'tcx>,
     is_chain_end: bool,
-    seen_types: FxHashSet<Ty<'tcx>>,
     has_significant_drop: bool,
     current_sig_drop: Option<FoundSigDrop>,
     sig_drop_spans: Option<Vec<FoundSigDrop>>,
     special_handling_for_binary_op: bool,
+    sig_drop_checker: SigDropChecker<'a, 'tcx>,
 }
 
 #[expect(clippy::enum_variant_names)]
@@ -118,11 +182,11 @@ impl<'a, 'tcx> SigDropHelper<'a, 'tcx> {
         SigDropHelper {
             cx,
             is_chain_end: true,
-            seen_types: FxHashSet::default(),
             has_significant_drop: false,
             current_sig_drop: None,
             sig_drop_spans: None,
             special_handling_for_binary_op: false,
+            sig_drop_checker: SigDropChecker::new(cx),
         }
     }
 
@@ -163,7 +227,7 @@ impl<'a, 'tcx> SigDropHelper<'a, 'tcx> {
         if self.current_sig_drop.is_some() {
             return;
         }
-        let ty = self.get_type(expr);
+        let ty = self.sig_drop_checker.get_type(expr);
         if ty.is_ref() {
             // We checked that the type was ref, so builtin_deref will return Some TypeAndMut,
             // but let's avoid any chance of an ICE
@@ -187,14 +251,6 @@ impl<'a, 'tcx> SigDropHelper<'a, 'tcx> {
         }
     }
 
-    fn get_type(&self, ex: &'tcx Expr<'_>) -> Ty<'tcx> {
-        self.cx.typeck_results().expr_ty(ex)
-    }
-
-    fn has_seen_type(&mut self, ty: Ty<'tcx>) -> bool {
-        !self.seen_types.insert(ty)
-    }
-
     fn visit_exprs_for_binary_ops(
         &mut self,
         left: &'tcx Expr<'_>,
@@ -214,44 +270,15 @@ impl<'a, 'tcx> SigDropHelper<'a, 'tcx> {
 
         self.special_handling_for_binary_op = false;
     }
-
-    fn has_sig_drop_attr(&mut self, cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
-        if let Some(adt) = ty.ty_adt_def() {
-            if get_attr(cx.sess(), cx.tcx.get_attrs_unchecked(adt.did()), "has_significant_drop").count() > 0 {
-                return true;
-            }
-        }
-
-        match ty.kind() {
-            rustc_middle::ty::Adt(a, b) => {
-                for f in a.all_fields() {
-                    let ty = f.ty(cx.tcx, b);
-                    if !self.has_seen_type(ty) && self.has_sig_drop_attr(cx, ty) {
-                        return true;
-                    }
-                }
-
-                for generic_arg in b.iter() {
-                    if let GenericArgKind::Type(ty) = generic_arg.unpack() {
-                        if self.has_sig_drop_attr(cx, ty) {
-                            return true;
-                        }
-                    }
-                }
-                false
-            },
-            rustc_middle::ty::Array(ty, _)
-            | rustc_middle::ty::RawPtr(TypeAndMut { ty, .. })
-            | rustc_middle::ty::Ref(_, ty, _)
-            | rustc_middle::ty::Slice(ty) => self.has_sig_drop_attr(cx, *ty),
-            _ => false,
-        }
-    }
 }
 
 impl<'a, 'tcx> Visitor<'tcx> for SigDropHelper<'a, 'tcx> {
     fn visit_expr(&mut self, ex: &'tcx Expr<'_>) {
-        if !self.is_chain_end && self.has_sig_drop_attr(self.cx, self.get_type(ex)) {
+        if !self.is_chain_end
+            && self
+                .sig_drop_checker
+                .has_sig_drop_attr(self.cx, self.sig_drop_checker.get_type(ex))
+        {
             self.has_significant_drop = true;
             return;
         }
@@ -330,3 +357,40 @@ impl<'a, 'tcx> Visitor<'tcx> for SigDropHelper<'a, 'tcx> {
         }
     }
 }
+
+struct ArmSigDropHelper<'a, 'tcx> {
+    sig_drop_checker: SigDropChecker<'a, 'tcx>,
+    found_sig_drop_spans: Option<FxHashSet<Span>>,
+}
+
+impl<'a, 'tcx> ArmSigDropHelper<'a, 'tcx> {
+    fn new(cx: &'a LateContext<'tcx>) -> ArmSigDropHelper<'a, 'tcx> {
+        ArmSigDropHelper {
+            sig_drop_checker: SigDropChecker::new(cx),
+            found_sig_drop_spans: None,
+        }
+    }
+}
+
+fn has_significant_drop_in_arms<'tcx, 'a>(cx: &'a LateContext<'tcx>, arms: &'tcx [Arm<'_>]) -> Option<FxHashSet<Span>> {
+    let mut helper = ArmSigDropHelper::new(cx);
+    for arm in arms {
+        helper.visit_expr(arm.body);
+    }
+    helper.found_sig_drop_spans
+}
+
+impl<'a, 'tcx> Visitor<'tcx> for ArmSigDropHelper<'a, 'tcx> {
+    fn visit_expr(&mut self, ex: &'tcx Expr<'tcx>) {
+        if self
+            .sig_drop_checker
+            .has_sig_drop_attr(self.sig_drop_checker.cx, self.sig_drop_checker.get_type(ex))
+        {
+            self.found_sig_drop_spans
+                .get_or_insert_with(FxHashSet::default)
+                .insert(ex.span);
+            return;
+        }
+        walk_expr(self, ex);
+    }
+}
diff --git a/tests/ui/significant_drop_in_scrutinee.rs b/tests/ui/significant_drop_in_scrutinee.rs
index 4347610f393..dd64f240c4a 100644
--- a/tests/ui/significant_drop_in_scrutinee.rs
+++ b/tests/ui/significant_drop_in_scrutinee.rs
@@ -591,4 +591,20 @@ fn should_trigger_lint_for_read_write_lock_for_loop() {
     }
 }
 
+fn do_bar(mutex: &Mutex<State>) {
+    mutex.lock().unwrap().bar();
+}
+
+fn should_trigger_lint_without_significant_drop_in_arm() {
+    let mutex = Mutex::new(State {});
+
+    // Should trigger lint because the lifetime of the temporary MutexGuard is surprising because it
+    // is preserved until the end of the match, but there is no clear indication that this is the
+    // case.
+    match mutex.lock().unwrap().foo() {
+        true => do_bar(&mutex),
+        false => {},
+    };
+}
+
 fn main() {}
diff --git a/tests/ui/significant_drop_in_scrutinee.stderr b/tests/ui/significant_drop_in_scrutinee.stderr
index 303f3c1df03..472f998ebf2 100644
--- a/tests/ui/significant_drop_in_scrutinee.stderr
+++ b/tests/ui/significant_drop_in_scrutinee.stderr
@@ -1,45 +1,69 @@
-error: temporary with significant drop in match scrutinee
+error: temporary with drop impl with side effects in match scrutinee lives to end of block
   --> $DIR/significant_drop_in_scrutinee.rs:59:11
    |
 LL |     match mutex.lock().unwrap().foo() {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |         true => {
+LL |             mutex.lock().unwrap().bar();
+   |             --------------------- significant drop in arm here
+...
+LL |     };
+   |      - original temporary lives until here
    |
    = note: `-D clippy::significant-drop-in-scrutinee` implied by `-D warnings`
+   = note: this might lead to deadlocks or other unexpected behavior
 help: try moving the temporary above the match
    |
 LL ~     let value = mutex.lock().unwrap().foo();
 LL ~     match value {
    |
 
-error: temporary with significant drop in match scrutinee
+error: temporary with drop impl with side effects in match scrutinee lives to end of block
   --> $DIR/significant_drop_in_scrutinee.rs:132:11
    |
 LL |     match s.lock_m().get_the_value() {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
+...
+LL |             println!("{}", s.lock_m().get_the_value());
+   |                            ---------- significant drop in arm here
+...
+LL |     }
+   |      - original temporary lives until here
+   |
+   = note: this might lead to deadlocks or other unexpected behavior
 help: try moving the temporary above the match
    |
 LL ~     let value = s.lock_m().get_the_value();
 LL ~     match value {
    |
 
-error: temporary with significant drop in match scrutinee
+error: temporary with drop impl with side effects in match scrutinee lives to end of block
   --> $DIR/significant_drop_in_scrutinee.rs:153:11
    |
 LL |     match s.lock_m_m().get_the_value() {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
+...
+LL |             println!("{}", s.lock_m().get_the_value());
+   |                            ---------- significant drop in arm here
+...
+LL |     }
+   |      - original temporary lives until here
+   |
+   = note: this might lead to deadlocks or other unexpected behavior
 help: try moving the temporary above the match
    |
 LL ~     let value = s.lock_m_m().get_the_value();
 LL ~     match value {
    |
 
-error: temporary with significant drop in match scrutinee
+error: temporary with drop impl with side effects in match scrutinee lives to end of block
   --> $DIR/significant_drop_in_scrutinee.rs:201:11
    |
 LL |     match counter.temp_increment().len() {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+...
+LL |     };
+   |      - original temporary lives until here
    |
 help: try moving the temporary above the match
    |
@@ -47,127 +71,218 @@ LL ~     let value = counter.temp_increment().len();
 LL ~     match value {
    |
 
-error: temporary with significant drop in match scrutinee
+error: temporary with drop impl with side effects in match scrutinee lives to end of block
   --> $DIR/significant_drop_in_scrutinee.rs:224:16
    |
 LL |         match (mutex1.lock().unwrap().s.len(), true) {
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
+...
+LL |                 mutex1.lock().unwrap().s.len();
+   |                 ---------------------- significant drop in arm here
+...
+LL |         };
+   |          - original temporary lives until here
+   |
+   = note: this might lead to deadlocks or other unexpected behavior
 help: try moving the temporary above the match
    |
 LL ~         let value = mutex1.lock().unwrap().s.len();
 LL ~         match (value, true) {
    |
 
-error: temporary with significant drop in match scrutinee
+error: temporary with drop impl with side effects in match scrutinee lives to end of block
   --> $DIR/significant_drop_in_scrutinee.rs:233:22
    |
 LL |         match (true, mutex1.lock().unwrap().s.len(), true) {
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
+...
+LL |                 mutex1.lock().unwrap().s.len();
+   |                 ---------------------- significant drop in arm here
+...
+LL |         };
+   |          - original temporary lives until here
+   |
+   = note: this might lead to deadlocks or other unexpected behavior
 help: try moving the temporary above the match
    |
 LL ~         let value = mutex1.lock().unwrap().s.len();
 LL ~         match (true, value, true) {
    |
 
-error: temporary with significant drop in match scrutinee
+error: temporary with drop impl with side effects in match scrutinee lives to end of block
   --> $DIR/significant_drop_in_scrutinee.rs:243:16
    |
 LL |         match (mutex1.lock().unwrap().s.len(), true, mutex2.lock().unwrap().s.len()) {
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
+...
+LL |                 mutex1.lock().unwrap().s.len();
+   |                 ---------------------- significant drop in arm here
+LL |                 mutex2.lock().unwrap().s.len();
+   |                 ---------------------- significant drop in arm here
+...
+LL |         };
+   |          - original temporary lives until here
+   |
+   = note: this might lead to deadlocks or other unexpected behavior
 help: try moving the temporary above the match
    |
 LL ~         let value = mutex1.lock().unwrap().s.len();
 LL ~         match (value, true, mutex2.lock().unwrap().s.len()) {
    |
 
-error: temporary with significant drop in match scrutinee
+error: temporary with drop impl with side effects in match scrutinee lives to end of block
   --> $DIR/significant_drop_in_scrutinee.rs:243:54
    |
 LL |         match (mutex1.lock().unwrap().s.len(), true, mutex2.lock().unwrap().s.len()) {
    |                                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
+...
+LL |                 mutex1.lock().unwrap().s.len();
+   |                 ---------------------- significant drop in arm here
+LL |                 mutex2.lock().unwrap().s.len();
+   |                 ---------------------- significant drop in arm here
+...
+LL |         };
+   |          - original temporary lives until here
+   |
+   = note: this might lead to deadlocks or other unexpected behavior
 help: try moving the temporary above the match
    |
 LL ~         let value = mutex2.lock().unwrap().s.len();
 LL ~         match (mutex1.lock().unwrap().s.len(), true, value) {
    |
 
-error: temporary with significant drop in match scrutinee
+error: temporary with drop impl with side effects in match scrutinee lives to end of block
   --> $DIR/significant_drop_in_scrutinee.rs:254:15
    |
 LL |         match mutex3.lock().unwrap().s.as_str() {
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+...
+LL |                 mutex1.lock().unwrap().s.len();
+   |                 ---------------------- significant drop in arm here
+LL |                 mutex2.lock().unwrap().s.len();
+   |                 ---------------------- significant drop in arm here
+...
+LL |         };
+   |          - original temporary lives until here
+   |
+   = note: this might lead to deadlocks or other unexpected behavior
 
-error: temporary with significant drop in match scrutinee
+error: temporary with drop impl with side effects in match scrutinee lives to end of block
   --> $DIR/significant_drop_in_scrutinee.rs:264:22
    |
 LL |         match (true, mutex3.lock().unwrap().s.as_str()) {
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+...
+LL |                 mutex1.lock().unwrap().s.len();
+   |                 ---------------------- significant drop in arm here
+LL |                 mutex2.lock().unwrap().s.len();
+   |                 ---------------------- significant drop in arm here
+...
+LL |         };
+   |          - original temporary lives until here
+   |
+   = note: this might lead to deadlocks or other unexpected behavior
 
-error: temporary with significant drop in match scrutinee
+error: temporary with drop impl with side effects in match scrutinee lives to end of block
   --> $DIR/significant_drop_in_scrutinee.rs:283:11
    |
 LL |     match mutex.lock().unwrap().s.len() > 1 {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
+LL |         true => {
+LL |             mutex.lock().unwrap().s.len();
+   |             --------------------- significant drop in arm here
+...
+LL |     };
+   |      - original temporary lives until here
+   |
+   = note: this might lead to deadlocks or other unexpected behavior
 help: try moving the temporary above the match
    |
 LL ~     let value = mutex.lock().unwrap().s.len() > 1;
 LL ~     match value {
    |
 
-error: temporary with significant drop in match scrutinee
+error: temporary with drop impl with side effects in match scrutinee lives to end of block
   --> $DIR/significant_drop_in_scrutinee.rs:290:11
    |
 LL |     match 1 < mutex.lock().unwrap().s.len() {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
+LL |         true => {
+LL |             mutex.lock().unwrap().s.len();
+   |             --------------------- significant drop in arm here
+...
+LL |     };
+   |      - original temporary lives until here
+   |
+   = note: this might lead to deadlocks or other unexpected behavior
 help: try moving the temporary above the match
    |
 LL ~     let value = 1 < mutex.lock().unwrap().s.len();
 LL ~     match value {
    |
 
-error: temporary with significant drop in match scrutinee
+error: temporary with drop impl with side effects in match scrutinee lives to end of block
   --> $DIR/significant_drop_in_scrutinee.rs:308:11
    |
 LL |     match mutex1.lock().unwrap().s.len() < mutex2.lock().unwrap().s.len() {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
+...
+LL |                 mutex1.lock().unwrap().s.len(),
+   |                 ---------------------- significant drop in arm here
+LL |                 mutex2.lock().unwrap().s.len()
+   |                 ---------------------- significant drop in arm here
+...
+LL |     };
+   |      - original temporary lives until here
+   |
+   = note: this might lead to deadlocks or other unexpected behavior
 help: try moving the temporary above the match
    |
 LL ~     let value = mutex1.lock().unwrap().s.len() < mutex2.lock().unwrap().s.len();
 LL ~     match value {
    |
 
-error: temporary with significant drop in match scrutinee
+error: temporary with drop impl with side effects in match scrutinee lives to end of block
   --> $DIR/significant_drop_in_scrutinee.rs:319:11
    |
 LL |     match mutex1.lock().unwrap().s.len() >= mutex2.lock().unwrap().s.len() {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
+...
+LL |                 mutex1.lock().unwrap().s.len(),
+   |                 ---------------------- significant drop in arm here
+LL |                 mutex2.lock().unwrap().s.len()
+   |                 ---------------------- significant drop in arm here
+...
+LL |     };
+   |      - original temporary lives until here
+   |
+   = note: this might lead to deadlocks or other unexpected behavior
 help: try moving the temporary above the match
    |
 LL ~     let value = mutex1.lock().unwrap().s.len() >= mutex2.lock().unwrap().s.len();
 LL ~     match value {
    |
 
-error: temporary with significant drop in match scrutinee
+error: temporary with drop impl with side effects in match scrutinee lives to end of block
   --> $DIR/significant_drop_in_scrutinee.rs:354:11
    |
 LL |     match get_mutex_guard().s.len() > 1 {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
+LL |         true => {
+LL |             mutex1.lock().unwrap().s.len();
+   |             ---------------------- significant drop in arm here
+...
+LL |     };
+   |      - original temporary lives until here
+   |
+   = note: this might lead to deadlocks or other unexpected behavior
 help: try moving the temporary above the match
    |
 LL ~     let value = get_mutex_guard().s.len() > 1;
 LL ~     match value {
    |
 
-error: temporary with significant drop in match scrutinee
+error: temporary with drop impl with side effects in match scrutinee lives to end of block
   --> $DIR/significant_drop_in_scrutinee.rs:371:11
    |
 LL |       match match i {
@@ -179,7 +294,14 @@ LL | |     .s
 LL | |     .len()
 LL | |         > 1
    | |___________^
-   |
+...
+LL |               mutex1.lock().unwrap().s.len();
+   |               ---------------------- significant drop in arm here
+...
+LL |       };
+   |        - original temporary lives until here
+   |
+   = note: this might lead to deadlocks or other unexpected behavior
 help: try moving the temporary above the match
    |
 LL ~     let value = match i {
@@ -190,7 +312,7 @@ LL +     .s
 LL +     .len()
  ...
 
-error: temporary with significant drop in match scrutinee
+error: temporary with drop impl with side effects in match scrutinee lives to end of block
   --> $DIR/significant_drop_in_scrutinee.rs:397:11
    |
 LL |       match if i > 1 {
@@ -202,7 +324,14 @@ LL | |         mutex2.lock().unwrap()
 LL | |     .len()
 LL | |         > 1
    | |___________^
-   |
+...
+LL |               mutex1.lock().unwrap().s.len();
+   |               ---------------------- significant drop in arm here
+...
+LL |       };
+   |        - original temporary lives until here
+   |
+   = note: this might lead to deadlocks or other unexpected behavior
 help: try moving the temporary above the match
    |
 LL ~     let value = if i > 1 {
@@ -213,83 +342,145 @@ LL +     }
 LL +     .s
  ...
 
-error: temporary with significant drop in match scrutinee
+error: temporary with drop impl with side effects in match scrutinee lives to end of block
   --> $DIR/significant_drop_in_scrutinee.rs:451:11
    |
 LL |     match s.lock().deref().deref() {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^
+LL |         0 | 1 => println!("Value was less than 2"),
+LL |         _ => println!("Value is {}", s.lock().deref()),
+   |                                      ---------------- significant drop in arm here
+LL |     };
+   |      - original temporary lives until here
    |
+   = note: this might lead to deadlocks or other unexpected behavior
 help: try moving the temporary above the match and create a copy
    |
 LL ~     let value = *s.lock().deref().deref();
 LL ~     match value {
    |
 
-error: temporary with significant drop in match scrutinee
+error: temporary with drop impl with side effects in match scrutinee lives to end of block
   --> $DIR/significant_drop_in_scrutinee.rs:479:11
    |
 LL |     match s.lock().deref().deref() {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^
+LL |         matcher => println!("Value is {}", s.lock().deref()),
+   |                                            ---------------- significant drop in arm here
+LL |         _ => println!("Value was not a match"),
+LL |     };
+   |      - original temporary lives until here
+   |
+   = note: this might lead to deadlocks or other unexpected behavior
 
-error: temporary with significant drop in match scrutinee
+error: temporary with drop impl with side effects in match scrutinee lives to end of block
   --> $DIR/significant_drop_in_scrutinee.rs:498:11
    |
 LL |     match mutex.lock().unwrap().i = i {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
+LL |         _ => {
+LL |             println!("{}", mutex.lock().unwrap().i);
+   |                            --------------------- significant drop in arm here
+LL |         },
+LL |     };
+   |      - original temporary lives until here
+   |
+   = note: this might lead to deadlocks or other unexpected behavior
 help: try moving the temporary above the match
    |
 LL ~     mutex.lock().unwrap().i = i;
 LL ~     match () {
    |
 
-error: temporary with significant drop in match scrutinee
+error: temporary with drop impl with side effects in match scrutinee lives to end of block
   --> $DIR/significant_drop_in_scrutinee.rs:504:11
    |
 LL |     match i = mutex.lock().unwrap().i {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
+LL |         _ => {
+LL |             println!("{}", mutex.lock().unwrap().i);
+   |                            --------------------- significant drop in arm here
+LL |         },
+LL |     };
+   |      - original temporary lives until here
+   |
+   = note: this might lead to deadlocks or other unexpected behavior
 help: try moving the temporary above the match
    |
 LL ~     i = mutex.lock().unwrap().i;
 LL ~     match () {
    |
 
-error: temporary with significant drop in match scrutinee
+error: temporary with drop impl with side effects in match scrutinee lives to end of block
   --> $DIR/significant_drop_in_scrutinee.rs:510:11
    |
 LL |     match mutex.lock().unwrap().i += 1 {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
+LL |         _ => {
+LL |             println!("{}", mutex.lock().unwrap().i);
+   |                            --------------------- significant drop in arm here
+LL |         },
+LL |     };
+   |      - original temporary lives until here
+   |
+   = note: this might lead to deadlocks or other unexpected behavior
 help: try moving the temporary above the match
    |
 LL ~     mutex.lock().unwrap().i += 1;
 LL ~     match () {
    |
 
-error: temporary with significant drop in match scrutinee
+error: temporary with drop impl with side effects in match scrutinee lives to end of block
   --> $DIR/significant_drop_in_scrutinee.rs:516:11
    |
 LL |     match i += mutex.lock().unwrap().i {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
+LL |         _ => {
+LL |             println!("{}", mutex.lock().unwrap().i);
+   |                            --------------------- significant drop in arm here
+LL |         },
+LL |     };
+   |      - original temporary lives until here
+   |
+   = note: this might lead to deadlocks or other unexpected behavior
 help: try moving the temporary above the match
    |
 LL ~     i += mutex.lock().unwrap().i;
 LL ~     match () {
    |
 
-error: temporary with significant drop in match scrutinee
+error: temporary with drop impl with side effects in match scrutinee lives to end of block
   --> $DIR/significant_drop_in_scrutinee.rs:579:11
    |
 LL |     match rwlock.read().unwrap().to_number() {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+...
+LL |     };
+   |      - original temporary lives until here
 
-error: temporary with significant drop in for loop
+error: temporary with drop impl with side effects in for loop condition lives to end of block
   --> $DIR/significant_drop_in_scrutinee.rs:589:14
    |
 LL |     for s in rwlock.read().unwrap().iter() {
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |         println!("{}", s);
+LL |     }
+   |      - original temporary lives until here
+
+error: temporary with drop impl with side effects in match scrutinee lives to end of block
+  --> $DIR/significant_drop_in_scrutinee.rs:604:11
+   |
+LL |     match mutex.lock().unwrap().foo() {
+   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+...
+LL |     };
+   |      - original temporary lives until here
+   |
+help: try moving the temporary above the match
+   |
+LL ~     let value = mutex.lock().unwrap().foo();
+LL ~     match value {
+   |
 
-error: aborting due to 25 previous errors
+error: aborting due to 26 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From dc7f2275937c3ae1a9ea0a82c4ed14fc3c686898 Mon Sep 17 00:00:00 2001
From: alexey semenyuk <alexsemenyuk88@gmail.com>
Date: Sat, 18 Jun 2022 19:42:39 +0000
Subject: `For` example should be used instead `while` in WHILE_LET_ON_ITERATOR

`For` example should be used instead `while` in WHILE_LET_ON_ITERATOR

For example should be used instead while in WHILE_LET_ON_ITERATOR

Revert some changes

Fix cargo dev fmt
---
 clippy_lints/src/loops/mod.rs | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/mod.rs b/clippy_lints/src/loops/mod.rs
index 391de922e1e..fa7a8b10033 100644
--- a/clippy_lints/src/loops/mod.rs
+++ b/clippy_lints/src/loops/mod.rs
@@ -346,7 +346,14 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```ignore
-    /// while let Some(val) = iter() {
+    /// while let Some(val) = iter.next() {
+    ///     ..
+    /// }
+    /// ```
+    ///
+    /// Use instead:
+    /// ```ignore
+    /// for val in &mut iter {
     ///     ..
     /// }
     /// ```
-- 
cgit 1.4.1-3-g733a5


From 2bd1581bbf8e6e1ac3ad78638ac9c1ab0baa9a8f Mon Sep 17 00:00:00 2001
From: Serial <69764315+Serial-ATA@users.noreply.github.com>
Date: Sun, 22 May 2022 15:41:43 -0400
Subject: Add `dev deprecate`

---
 clippy_dev/Cargo.toml                              |   2 +-
 clippy_dev/src/main.rs                             |  18 +
 clippy_dev/src/new_lint.rs                         |   2 +-
 clippy_dev/src/update_lints.rs                     | 393 ++++++++++++++++++---
 clippy_lints/src/deprecated_lints.rs               |  16 +-
 clippy_lints/src/lib.register_internal.rs          |   1 +
 clippy_lints/src/lib.register_lints.rs             |   2 +
 clippy_lints/src/utils/internal_lints.rs           | 107 ++++--
 .../src/utils/internal_lints/metadata_collector.rs |   2 +-
 9 files changed, 474 insertions(+), 69 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_dev/Cargo.toml b/clippy_dev/Cargo.toml
index b0d470a2124..2ac3b4fe2ed 100644
--- a/clippy_dev/Cargo.toml
+++ b/clippy_dev/Cargo.toml
@@ -5,7 +5,7 @@ edition = "2021"
 
 [dependencies]
 aho-corasick = "0.7"
-clap = "3.1"
+clap = "3.2"
 indoc = "1.0"
 itertools = "0.10.1"
 opener = "0.5"
diff --git a/clippy_dev/src/main.rs b/clippy_dev/src/main.rs
index 2c27a0bcaf9..243a901503f 100644
--- a/clippy_dev/src/main.rs
+++ b/clippy_dev/src/main.rs
@@ -5,6 +5,7 @@
 use clap::{Arg, ArgAction, ArgMatches, Command, PossibleValue};
 use clippy_dev::{bless, fmt, lint, new_lint, serve, setup, update_lints};
 use indoc::indoc;
+
 fn main() {
     let matches = get_clap_config();
 
@@ -85,6 +86,11 @@ fn main() {
             let uplift = matches.contains_id("uplift");
             update_lints::rename(old_name, new_name, uplift);
         },
+        Some(("deprecate", matches)) => {
+            let name = matches.get_one::<String>("name").unwrap();
+            let reason = matches.get_one("reason");
+            update_lints::deprecate(name, reason);
+        },
         _ => {},
     }
 }
@@ -266,6 +272,18 @@ fn get_clap_config() -> ArgMatches {
                     .long("uplift")
                     .help("This lint will be uplifted into rustc"),
             ]),
+            Command::new("deprecate").about("Deprecates the given lint").args([
+                Arg::new("name")
+                    .index(1)
+                    .required(true)
+                    .help("The name of the lint to deprecate"),
+                Arg::new("reason")
+                    .long("reason")
+                    .short('r')
+                    .required(false)
+                    .takes_value(true)
+                    .help("The reason for deprecation"),
+            ]),
         ])
         .get_matches()
 }
diff --git a/clippy_dev/src/new_lint.rs b/clippy_dev/src/new_lint.rs
index 748d73c0801..7d7e760ef44 100644
--- a/clippy_dev/src/new_lint.rs
+++ b/clippy_dev/src/new_lint.rs
@@ -138,7 +138,7 @@ fn to_camel_case(name: &str) -> String {
         .collect()
 }
 
-fn get_stabilization_version() -> String {
+pub(crate) fn get_stabilization_version() -> String {
     fn parse_manifest(contents: &str) -> Option<String> {
         let version = contents
             .lines()
diff --git a/clippy_dev/src/update_lints.rs b/clippy_dev/src/update_lints.rs
index 1bbd9a45b61..31deb499b2e 100644
--- a/clippy_dev/src/update_lints.rs
+++ b/clippy_dev/src/update_lints.rs
@@ -1,16 +1,17 @@
+use crate::clippy_project_root;
 use aho_corasick::AhoCorasickBuilder;
-use core::fmt::Write as _;
+use indoc::writedoc;
 use itertools::Itertools;
 use rustc_lexer::{tokenize, unescape, LiteralKind, TokenKind};
 use std::collections::{HashMap, HashSet};
 use std::ffi::OsStr;
-use std::fs;
-use std::io::{self, Read as _, Seek as _, Write as _};
+use std::fmt::Write;
+use std::fs::{self, OpenOptions};
+use std::io::{self, Read, Seek, SeekFrom, Write as _};
+use std::ops::Range;
 use std::path::{Path, PathBuf};
 use walkdir::{DirEntry, WalkDir};
 
-use crate::clippy_project_root;
-
 const GENERATED_FILE_COMMENT: &str = "// This file was generated by `cargo dev update_lints`.\n\
      // Use that command to update this file and do not edit by hand.\n\
      // Manual edits will be overwritten.\n\n";
@@ -326,6 +327,198 @@ pub fn rename(old_name: &str, new_name: &str, uplift: bool) {
     println!("note: `cargo uitest` still needs to be run to update the test results");
 }
 
+const DEFAULT_DEPRECATION_REASON: &str = "default deprecation note";
+/// Runs the `deprecate` command
+///
+/// This does the following:
+/// * Adds an entry to `deprecated_lints.rs`.
+/// * Removes the lint declaration (and the entire file if applicable)
+///
+/// # Panics
+///
+/// If a file path could not read from or written to
+pub fn deprecate(name: &str, reason: Option<&String>) {
+    fn finish(
+        (lints, mut deprecated_lints, renamed_lints): (Vec<Lint>, Vec<DeprecatedLint>, Vec<RenamedLint>),
+        name: &str,
+        reason: &str,
+    ) {
+        deprecated_lints.push(DeprecatedLint {
+            name: name.to_string(),
+            reason: reason.to_string(),
+            declaration_range: Range::default(),
+        });
+
+        generate_lint_files(UpdateMode::Change, &lints, &deprecated_lints, &renamed_lints);
+        println!("info: `{}` has successfully been deprecated", name);
+
+        if reason == DEFAULT_DEPRECATION_REASON {
+            println!("note: the deprecation reason must be updated in `clippy_lints/src/deprecated_lints.rs`");
+        }
+        println!("note: you must run `cargo uitest` to update the test results");
+    }
+
+    let reason = reason.map_or(DEFAULT_DEPRECATION_REASON, String::as_str);
+    let name_lower = name.to_lowercase();
+    let name_upper = name.to_uppercase();
+
+    let (mut lints, deprecated_lints, renamed_lints) = gather_all();
+    let Some(lint) = lints.iter().find(|l| l.name == name_lower) else { panic!("failed to find lint `{}`", name) };
+
+    let mod_path = {
+        let mut mod_path = PathBuf::from(format!("clippy_lints/src/{}", lint.module));
+        if mod_path.is_dir() {
+            mod_path = mod_path.join(name);
+        }
+
+        mod_path.set_extension("rs");
+        mod_path
+    };
+
+    let deprecated_lints_path = &*clippy_project_root().join("clippy_lints/src/deprecated_lints.rs");
+
+    if remove_lint_declaration(&name_lower, &mod_path, &mut lints).unwrap_or(false) {
+        declare_deprecated(&name_upper, deprecated_lints_path, reason).unwrap();
+        finish((lints, deprecated_lints, renamed_lints), name, reason);
+        return;
+    }
+
+    eprintln!("error: lint not found");
+}
+
+fn remove_lint_declaration(name: &str, path: &Path, lints: &mut Vec<Lint>) -> io::Result<bool> {
+    fn remove_lint(name: &str, lints: &mut Vec<Lint>) {
+        lints.iter().position(|l| l.name == name).map(|pos| lints.remove(pos));
+    }
+
+    fn remove_test_assets(name: &str) {
+        let test_file_stem = format!("tests/ui/{}", name);
+        let path = Path::new(&test_file_stem);
+
+        // Some lints have their own directories, delete them
+        if path.is_dir() {
+            fs::remove_dir_all(path).ok();
+            return;
+        }
+
+        // Remove all related test files
+        fs::remove_file(path.with_extension("rs")).ok();
+        fs::remove_file(path.with_extension("stderr")).ok();
+        fs::remove_file(path.with_extension("fixed")).ok();
+    }
+
+    fn remove_impl_lint_pass(lint_name_upper: &str, content: &mut String) {
+        let impl_lint_pass_start = content.find("impl_lint_pass!").unwrap_or_else(|| {
+            content
+                .find("declare_lint_pass!")
+                .unwrap_or_else(|| panic!("failed to find `impl_lint_pass`"))
+        });
+        let mut impl_lint_pass_end = (&content[impl_lint_pass_start..])
+            .find(']')
+            .expect("failed to find `impl_lint_pass` terminator");
+
+        impl_lint_pass_end += impl_lint_pass_start;
+        if let Some(lint_name_pos) = content[impl_lint_pass_start..impl_lint_pass_end].find(&lint_name_upper) {
+            let mut lint_name_end = impl_lint_pass_start + (lint_name_pos + lint_name_upper.len());
+            for c in content[lint_name_end..impl_lint_pass_end].chars() {
+                // Remove trailing whitespace
+                if c.is_whitespace() {
+                    lint_name_end += 1;
+                } else {
+                    break;
+                }
+            }
+
+            content.replace_range(impl_lint_pass_start + lint_name_pos..lint_name_end, "");
+        }
+    }
+
+    if path.exists() {
+        if let Some(lint) = lints.iter().find(|l| l.name == name) {
+            if lint.module == name {
+                // The lint name is the same as the file, we can just delete the entire file
+                fs::remove_file(path)?;
+            } else {
+                // We can't delete the entire file, just remove the declaration
+                if lint.module != name {
+                    let mut mod_decl_path = path.to_path_buf();
+                    if mod_decl_path.is_dir() {
+                        mod_decl_path = Path::new("clippy_lints/src").join(&lint.module).join("mod.rs");
+                    }
+
+                    let mut content = fs::read_to_string(&mod_decl_path)
+                        .unwrap_or_else(|_| panic!("failed to read `{}`", path.to_string_lossy()));
+
+                    eprintln!(
+                        "warn: you will have to manually remove any code related to `{}` from `{}`",
+                        name,
+                        &mod_decl_path.to_string_lossy()
+                    );
+
+                    assert!(
+                        content[lint.declaration_range.clone()].contains(&name.to_uppercase()),
+                        "error: `{}` does not contain lint `{}`'s declaration",
+                        mod_decl_path.display(),
+                        lint.name
+                    );
+
+                    // Remove lint declaration (declare_clippy_lint!)
+                    content.replace_range(lint.declaration_range.clone(), "");
+
+                    // Remove the module declaration (mod xyz;)
+                    let mod_decl = format!("\nmod {};", name);
+                    content = content.replacen(&mod_decl, "", 1);
+
+                    remove_impl_lint_pass(&lint.name.to_uppercase(), &mut content);
+                    fs::write(mod_decl_path, content)
+                        .unwrap_or_else(|_| panic!("failed to write to `{}`", path.to_string_lossy()));
+                }
+            }
+
+            remove_test_assets(name);
+            remove_lint(name, lints);
+            return Ok(true);
+        }
+    }
+
+    Ok(false)
+}
+
+fn declare_deprecated(name: &str, path: &Path, reason: &str) -> io::Result<()> {
+    let mut file = OpenOptions::new().write(true).open(path)?;
+
+    file.seek(SeekFrom::End(0))?;
+
+    let version = crate::new_lint::get_stabilization_version();
+    let deprecation_reason = if reason == DEFAULT_DEPRECATION_REASON {
+        "TODO"
+    } else {
+        reason
+    };
+
+    writedoc!(
+        file,
+        "
+
+        declare_deprecated_lint! {{
+            /// ### What it does
+            /// Nothing. This lint has been deprecated.
+            ///
+            /// ### Deprecation reason
+            /// {}
+            #[clippy::version = \"{}\"]
+            pub {},
+            \"{}\"
+        }}
+
+        ",
+        deprecation_reason,
+        version,
+        name,
+        reason,
+    )
+}
+
 /// Replace substrings if they aren't bordered by identifier characters. Returns `None` if there
 /// were no replacements.
 fn replace_ident_like(contents: &str, replacements: &[(&str, &str)]) -> Option<String> {
@@ -393,16 +586,18 @@ struct Lint {
     group: String,
     desc: String,
     module: String,
+    declaration_range: Range<usize>,
 }
 
 impl Lint {
     #[must_use]
-    fn new(name: &str, group: &str, desc: &str, module: &str) -> Self {
+    fn new(name: &str, group: &str, desc: &str, module: &str, declaration_range: Range<usize>) -> Self {
         Self {
             name: name.to_lowercase(),
             group: group.into(),
             desc: remove_line_splices(desc),
             module: module.into(),
+            declaration_range,
         }
     }
 
@@ -433,12 +628,14 @@ impl Lint {
 struct DeprecatedLint {
     name: String,
     reason: String,
+    declaration_range: Range<usize>,
 }
 impl DeprecatedLint {
-    fn new(name: &str, reason: &str) -> Self {
+    fn new(name: &str, reason: &str, declaration_range: Range<usize>) -> Self {
         Self {
             name: name.to_lowercase(),
             reason: remove_line_splices(reason),
+            declaration_range,
         }
     }
 }
@@ -610,7 +807,11 @@ fn clippy_lints_src_files() -> impl Iterator<Item = (PathBuf, DirEntry)> {
 macro_rules! match_tokens {
     ($iter:ident, $($token:ident $({$($fields:tt)*})? $(($capture:ident))?)*) => {
          {
-            $($(let $capture =)? if let Some((TokenKind::$token $({$($fields)*})?, _x)) = $iter.next() {
+            $($(let $capture =)? if let Some(LintDeclSearchResult {
+                    token_kind: TokenKind::$token $({$($fields)*})?,
+                    content: _x,
+                    ..
+            }) = $iter.next() {
                 _x
             } else {
                 continue;
@@ -621,40 +822,72 @@ macro_rules! match_tokens {
     }
 }
 
+struct LintDeclSearchResult<'a> {
+    token_kind: TokenKind,
+    content: &'a str,
+    range: Range<usize>,
+}
+
 /// Parse a source file looking for `declare_clippy_lint` macro invocations.
 fn parse_contents(contents: &str, module: &str, lints: &mut Vec<Lint>) {
     let mut offset = 0usize;
     let mut iter = tokenize(contents).map(|t| {
         let range = offset..offset + t.len;
         offset = range.end;
-        (t.kind, &contents[range])
+
+        LintDeclSearchResult {
+            token_kind: t.kind,
+            content: &contents[range.clone()],
+            range,
+        }
     });
 
-    while iter.any(|(kind, s)| kind == TokenKind::Ident && s == "declare_clippy_lint") {
+    while let Some(LintDeclSearchResult { range, .. }) = iter.find(
+        |LintDeclSearchResult {
+             token_kind, content, ..
+         }| token_kind == &TokenKind::Ident && *content == "declare_clippy_lint",
+    ) {
+        let start = range.start;
+
         let mut iter = iter
             .by_ref()
-            .filter(|&(kind, _)| !matches!(kind, TokenKind::Whitespace | TokenKind::LineComment { .. }));
+            .filter(|t| !matches!(t.token_kind, TokenKind::Whitespace | TokenKind::LineComment { .. }));
         // matches `!{`
         match_tokens!(iter, Bang OpenBrace);
         match iter.next() {
             // #[clippy::version = "version"] pub
-            Some((TokenKind::Pound, _)) => {
+            Some(LintDeclSearchResult {
+                token_kind: TokenKind::Pound,
+                ..
+            }) => {
                 match_tokens!(iter, OpenBracket Ident Colon Colon Ident Eq Literal{..} CloseBracket Ident);
             },
             // pub
-            Some((TokenKind::Ident, _)) => (),
+            Some(LintDeclSearchResult {
+                token_kind: TokenKind::Ident,
+                ..
+            }) => (),
             _ => continue,
         }
+
         let (name, group, desc) = match_tokens!(
             iter,
             // LINT_NAME
             Ident(name) Comma
             // group,
             Ident(group) Comma
-            // "description" }
-            Literal{..}(desc) CloseBrace
+            // "description"
+            Literal{..}(desc)
         );
-        lints.push(Lint::new(name, group, desc, module));
+
+        if let Some(LintDeclSearchResult {
+            token_kind: TokenKind::CloseBrace,
+            range,
+            ..
+        }) = iter.next()
+        {
+            lints.push(Lint::new(name, group, desc, module, start..range.end));
+        }
     }
 }
 
@@ -664,12 +897,24 @@ fn parse_deprecated_contents(contents: &str, lints: &mut Vec<DeprecatedLint>) {
     let mut iter = tokenize(contents).map(|t| {
         let range = offset..offset + t.len;
         offset = range.end;
-        (t.kind, &contents[range])
+
+        LintDeclSearchResult {
+            token_kind: t.kind,
+            content: &contents[range.clone()],
+            range,
+        }
     });
-    while iter.any(|(kind, s)| kind == TokenKind::Ident && s == "declare_deprecated_lint") {
-        let mut iter = iter
-            .by_ref()
-            .filter(|&(kind, _)| !matches!(kind, TokenKind::Whitespace | TokenKind::LineComment { .. }));
+
+    while let Some(LintDeclSearchResult { range, .. }) = iter.find(
+        |LintDeclSearchResult {
+             token_kind, content, ..
+         }| token_kind == &TokenKind::Ident && *content == "declare_deprecated_lint",
+    ) {
+        let start = range.start;
+
+        let mut iter = iter.by_ref().filter(|LintDeclSearchResult { ref token_kind, .. }| {
+            !matches!(token_kind, TokenKind::Whitespace | TokenKind::LineComment { .. })
+        });
         let (name, reason) = match_tokens!(
             iter,
             // !{
@@ -680,10 +925,16 @@ fn parse_deprecated_contents(contents: &str, lints: &mut Vec<DeprecatedLint>) {
             Ident Ident(name) Comma
             // "description"
             Literal{kind: LiteralKind::Str{..},..}(reason)
-            // }
-            CloseBrace
         );
-        lints.push(DeprecatedLint::new(name, reason));
+
+        if let Some(LintDeclSearchResult {
+            token_kind: TokenKind::CloseBrace,
+            range,
+            ..
+        }) = iter.next()
+        {
+            lints.push(DeprecatedLint::new(name, reason, start..range.end));
+        }
     }
 }
 
@@ -693,8 +944,14 @@ fn parse_renamed_contents(contents: &str, lints: &mut Vec<RenamedLint>) {
         let mut iter = tokenize(line).map(|t| {
             let range = offset..offset + t.len;
             offset = range.end;
-            (t.kind, &line[range])
+
+            LintDeclSearchResult {
+                token_kind: t.kind,
+                content: &line[range.clone()],
+                range,
+            }
         });
+
         let (old_name, new_name) = match_tokens!(
             iter,
             // ("old_name",
@@ -844,10 +1101,25 @@ mod tests {
         "#;
         let mut result = Vec::new();
         parse_contents(CONTENTS, "module_name", &mut result);
+        for r in &mut result {
+            r.declaration_range = Range::default();
+        }
 
         let expected = vec![
-            Lint::new("ptr_arg", "style", "\"really long text\"", "module_name"),
-            Lint::new("doc_markdown", "pedantic", "\"single line\"", "module_name"),
+            Lint::new(
+                "ptr_arg",
+                "style",
+                "\"really long text\"",
+                "module_name",
+                Range::default(),
+            ),
+            Lint::new(
+                "doc_markdown",
+                "pedantic",
+                "\"single line\"",
+                "module_name",
+                Range::default(),
+            ),
         ];
         assert_eq!(expected, result);
     }
@@ -865,10 +1137,14 @@ mod tests {
 
         let mut result = Vec::new();
         parse_deprecated_contents(DEPRECATED_CONTENTS, &mut result);
+        for r in &mut result {
+            r.declaration_range = Range::default();
+        }
 
         let expected = vec![DeprecatedLint::new(
             "should_assert_eq",
             "\"`assert!()` will be more flexible with RFC 2011\"",
+            Range::default(),
         )];
         assert_eq!(expected, result);
     }
@@ -876,15 +1152,34 @@ mod tests {
     #[test]
     fn test_usable_lints() {
         let lints = vec![
-            Lint::new("should_assert_eq2", "Not Deprecated", "\"abc\"", "module_name"),
-            Lint::new("should_assert_eq2", "internal", "\"abc\"", "module_name"),
-            Lint::new("should_assert_eq2", "internal_style", "\"abc\"", "module_name"),
+            Lint::new(
+                "should_assert_eq2",
+                "Not Deprecated",
+                "\"abc\"",
+                "module_name",
+                Range::default(),
+            ),
+            Lint::new(
+                "should_assert_eq2",
+                "internal",
+                "\"abc\"",
+                "module_name",
+                Range::default(),
+            ),
+            Lint::new(
+                "should_assert_eq2",
+                "internal_style",
+                "\"abc\"",
+                "module_name",
+                Range::default(),
+            ),
         ];
         let expected = vec![Lint::new(
             "should_assert_eq2",
             "Not Deprecated",
             "\"abc\"",
             "module_name",
+            Range::default(),
         )];
         assert_eq!(expected, Lint::usable_lints(&lints));
     }
@@ -892,21 +1187,33 @@ mod tests {
     #[test]
     fn test_by_lint_group() {
         let lints = vec![
-            Lint::new("should_assert_eq", "group1", "\"abc\"", "module_name"),
-            Lint::new("should_assert_eq2", "group2", "\"abc\"", "module_name"),
-            Lint::new("incorrect_match", "group1", "\"abc\"", "module_name"),
+            Lint::new("should_assert_eq", "group1", "\"abc\"", "module_name", Range::default()),
+            Lint::new(
+                "should_assert_eq2",
+                "group2",
+                "\"abc\"",
+                "module_name",
+                Range::default(),
+            ),
+            Lint::new("incorrect_match", "group1", "\"abc\"", "module_name", Range::default()),
         ];
         let mut expected: HashMap<String, Vec<Lint>> = HashMap::new();
         expected.insert(
             "group1".to_string(),
             vec![
-                Lint::new("should_assert_eq", "group1", "\"abc\"", "module_name"),
-                Lint::new("incorrect_match", "group1", "\"abc\"", "module_name"),
+                Lint::new("should_assert_eq", "group1", "\"abc\"", "module_name", Range::default()),
+                Lint::new("incorrect_match", "group1", "\"abc\"", "module_name", Range::default()),
             ],
         );
         expected.insert(
             "group2".to_string(),
-            vec![Lint::new("should_assert_eq2", "group2", "\"abc\"", "module_name")],
+            vec![Lint::new(
+                "should_assert_eq2",
+                "group2",
+                "\"abc\"",
+                "module_name",
+                Range::default(),
+            )],
         );
         assert_eq!(expected, Lint::by_lint_group(lints.into_iter()));
     }
@@ -914,8 +1221,12 @@ mod tests {
     #[test]
     fn test_gen_deprecated() {
         let lints = vec![
-            DeprecatedLint::new("should_assert_eq", "\"has been superseded by should_assert_eq2\""),
-            DeprecatedLint::new("another_deprecated", "\"will be removed\""),
+            DeprecatedLint::new(
+                "should_assert_eq",
+                "\"has been superseded by should_assert_eq2\"",
+                Range::default(),
+            ),
+            DeprecatedLint::new("another_deprecated", "\"will be removed\"", Range::default()),
         ];
 
         let expected = GENERATED_FILE_COMMENT.to_string()
@@ -940,9 +1251,9 @@ mod tests {
     #[test]
     fn test_gen_lint_group_list() {
         let lints = vec![
-            Lint::new("abc", "group1", "\"abc\"", "module_name"),
-            Lint::new("should_assert_eq", "group1", "\"abc\"", "module_name"),
-            Lint::new("internal", "internal_style", "\"abc\"", "module_name"),
+            Lint::new("abc", "group1", "\"abc\"", "module_name", Range::default()),
+            Lint::new("should_assert_eq", "group1", "\"abc\"", "module_name", Range::default()),
+            Lint::new("internal", "internal_style", "\"abc\"", "module_name", Range::default()),
         ];
         let expected = GENERATED_FILE_COMMENT.to_string()
             + &[
diff --git a/clippy_lints/src/deprecated_lints.rs b/clippy_lints/src/deprecated_lints.rs
index 5d5ea0f49c8..d7a4b6f5c88 100644
--- a/clippy_lints/src/deprecated_lints.rs
+++ b/clippy_lints/src/deprecated_lints.rs
@@ -1,16 +1,22 @@
-// NOTE: if you add a deprecated lint in this file, please add a corresponding test in
-// tests/ui/deprecated.rs
+// NOTE: Entries should be created with `cargo dev deprecate`
 
 /// This struct fakes the `Lint` declaration that is usually created by `declare_lint!`. This
 /// enables the simple extraction of the metadata without changing the current deprecation
 /// declaration.
-pub struct ClippyDeprecatedLint;
+pub struct ClippyDeprecatedLint {
+    #[cfg(feature = "internal")]
+    #[allow(dead_code)]
+    desc: &'static str,
+}
 
 macro_rules! declare_deprecated_lint {
-    { $(#[$attr:meta])* pub $name: ident, $_reason: expr} => {
+    { $(#[$attr:meta])* pub $name: ident, $reason: literal} => {
         $(#[$attr])*
         #[allow(dead_code)]
-        pub static $name: ClippyDeprecatedLint = ClippyDeprecatedLint {};
+        pub static $name: ClippyDeprecatedLint = ClippyDeprecatedLint {
+            #[cfg(feature = "internal")]
+            desc: $reason
+        };
     }
 }
 
diff --git a/clippy_lints/src/lib.register_internal.rs b/clippy_lints/src/lib.register_internal.rs
index 4778f4fdfa7..be63646a12f 100644
--- a/clippy_lints/src/lib.register_internal.rs
+++ b/clippy_lints/src/lib.register_internal.rs
@@ -6,6 +6,7 @@ store.register_group(true, "clippy::internal", Some("clippy_internal"), vec![
     LintId::of(utils::internal_lints::CLIPPY_LINTS_INTERNAL),
     LintId::of(utils::internal_lints::COLLAPSIBLE_SPAN_LINT_CALLS),
     LintId::of(utils::internal_lints::COMPILER_LINT_FUNCTIONS),
+    LintId::of(utils::internal_lints::DEFAULT_DEPRECATION_REASON),
     LintId::of(utils::internal_lints::DEFAULT_LINT),
     LintId::of(utils::internal_lints::IF_CHAIN_STYLE),
     LintId::of(utils::internal_lints::INTERNING_DEFINED_SYMBOL),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index de22f50cf94..faa63b3036c 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -10,6 +10,8 @@ store.register_lints(&[
     #[cfg(feature = "internal")]
     utils::internal_lints::COMPILER_LINT_FUNCTIONS,
     #[cfg(feature = "internal")]
+    utils::internal_lints::DEFAULT_DEPRECATION_REASON,
+    #[cfg(feature = "internal")]
     utils::internal_lints::DEFAULT_LINT,
     #[cfg(feature = "internal")]
     utils::internal_lints::IF_CHAIN_STYLE,
diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs
index b885e5132f1..c5380662566 100644
--- a/clippy_lints/src/utils/internal_lints.rs
+++ b/clippy_lints/src/utils/internal_lints.rs
@@ -1,3 +1,4 @@
+use crate::utils::internal_lints::metadata_collector::is_deprecated_lint;
 use clippy_utils::consts::{constant_simple, Constant};
 use clippy_utils::diagnostics::{span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::macros::root_macro_call_first_node;
@@ -338,6 +339,47 @@ declare_clippy_lint! {
     "checking if all necessary steps were taken when adding a MSRV to a lint"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for cases of an auto-generated deprecated lint without an updated reason,
+    /// i.e. `"default deprecation note"`.
+    ///
+    /// ### Why is this bad?
+    /// Indicates that the documentation is incomplete.
+    ///
+    /// ### Example
+    /// Bad:
+    /// ```rust,ignore
+    /// declare_deprecated_lint! {
+    ///     /// ### What it does
+    ///     /// Nothing. This lint has been deprecated.
+    ///     ///
+    ///     /// ### Deprecation reason
+    ///     /// TODO
+    ///     #[clippy::version = "1.63.0"]
+    ///     pub COOL_LINT,
+    ///     "default deprecation note"
+    /// }
+    /// ```
+    ///
+    /// Good:
+    /// ```rust,ignore
+    /// declare_deprecated_lint! {
+    ///     /// ### What it does
+    ///     /// Nothing. This lint has been deprecated.
+    ///     ///
+    ///     /// ### Deprecation reason
+    ///     /// This lint has been replaced by `cooler_lint`
+    ///     #[clippy::version = "1.63.0"]
+    ///     pub COOL_LINT,
+    ///     "this lint has been replaced by `cooler_lint`"
+    /// }
+    /// ```
+    pub DEFAULT_DEPRECATION_REASON,
+    internal,
+    "found 'default deprecation note' in a deprecated lint declaration"
+}
+
 declare_lint_pass!(ClippyLintsInternal => [CLIPPY_LINTS_INTERNAL]);
 
 impl EarlyLintPass for ClippyLintsInternal {
@@ -375,42 +417,67 @@ pub struct LintWithoutLintPass {
     registered_lints: FxHashSet<Symbol>,
 }
 
-impl_lint_pass!(LintWithoutLintPass => [DEFAULT_LINT, LINT_WITHOUT_LINT_PASS, INVALID_CLIPPY_VERSION_ATTRIBUTE, MISSING_CLIPPY_VERSION_ATTRIBUTE]);
+impl_lint_pass!(LintWithoutLintPass => [DEFAULT_LINT, LINT_WITHOUT_LINT_PASS, INVALID_CLIPPY_VERSION_ATTRIBUTE, MISSING_CLIPPY_VERSION_ATTRIBUTE, DEFAULT_DEPRECATION_REASON]);
 
 impl<'tcx> LateLintPass<'tcx> for LintWithoutLintPass {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
-        if is_lint_allowed(cx, DEFAULT_LINT, item.hir_id()) {
+        if is_lint_allowed(cx, DEFAULT_LINT, item.hir_id())
+            || is_lint_allowed(cx, DEFAULT_DEPRECATION_REASON, item.hir_id())
+        {
             return;
         }
 
         if let hir::ItemKind::Static(ty, Mutability::Not, body_id) = item.kind {
-            if is_lint_ref_type(cx, ty) {
+            let is_lint_ref_ty = is_lint_ref_type(cx, ty);
+            if is_deprecated_lint(cx, ty) || is_lint_ref_ty {
                 check_invalid_clippy_version_attribute(cx, item);
 
                 let expr = &cx.tcx.hir().body(body_id).value;
-                if_chain! {
-                    if let ExprKind::AddrOf(_, _, inner_exp) = expr.kind;
-                    if let ExprKind::Struct(_, fields, _) = inner_exp.kind;
-                    let field = fields
-                        .iter()
-                        .find(|f| f.ident.as_str() == "desc")
-                        .expect("lints must have a description field");
-                    if let ExprKind::Lit(Spanned {
-                        node: LitKind::Str(ref sym, _),
-                        ..
-                    }) = field.expr.kind;
-                    if sym.as_str() == "default lint description";
-
-                    then {
+                let fields;
+                if is_lint_ref_ty {
+                    if let ExprKind::AddrOf(_, _, inner_exp) = expr.kind
+                        && let ExprKind::Struct(_, struct_fields, _) = inner_exp.kind {
+                            fields = struct_fields;
+                    } else {
+                        return;
+                    }
+                } else if let ExprKind::Struct(_, struct_fields, _) = expr.kind {
+                    fields = struct_fields;
+                } else {
+                    return;
+                }
+
+                let field = fields
+                    .iter()
+                    .find(|f| f.ident.as_str() == "desc")
+                    .expect("lints must have a description field");
+
+                if let ExprKind::Lit(Spanned {
+                    node: LitKind::Str(ref sym, _),
+                    ..
+                }) = field.expr.kind
+                {
+                    let sym_str = sym.as_str();
+                    if is_lint_ref_ty {
+                        if sym_str == "default lint description" {
+                            span_lint(
+                                cx,
+                                DEFAULT_LINT,
+                                item.span,
+                                &format!("the lint `{}` has the default lint description", item.ident.name),
+                            );
+                        }
+
+                        self.declared_lints.insert(item.ident.name, item.span);
+                    } else if sym_str == "default deprecation note" {
                         span_lint(
                             cx,
-                            DEFAULT_LINT,
+                            DEFAULT_DEPRECATION_REASON,
                             item.span,
-                            &format!("the lint `{}` has the default lint description", item.ident.name),
+                            &format!("the lint `{}` has the default deprecation reason", item.ident.name),
                         );
                     }
                 }
-                self.declared_lints.insert(item.ident.name, item.span);
             }
         } else if let Some(macro_call) = root_macro_call_first_node(cx, item) {
             if !matches!(
diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index 99e9e3275ab..025ad87f72d 100644
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -842,7 +842,7 @@ fn get_lint_level_from_group(lint_group: &str) -> Option<&'static str> {
         .find_map(|(group_name, group_level)| (*group_name == lint_group).then(|| *group_level))
 }
 
-fn is_deprecated_lint(cx: &LateContext<'_>, ty: &hir::Ty<'_>) -> bool {
+pub(super) fn is_deprecated_lint(cx: &LateContext<'_>, ty: &hir::Ty<'_>) -> bool {
     if let hir::TyKind::Path(ref path) = ty.kind {
         if let hir::def::Res::Def(DefKind::Struct, def_id) = cx.qpath_res(path, ty.hir_id) {
             return match_def_path(cx, def_id, &DEPRECATED_LINT_TYPE);
-- 
cgit 1.4.1-3-g733a5


From 890fd0e3c10a7176d6e329d8161f80be06b170ad Mon Sep 17 00:00:00 2001
From: Serial <69764315+Serial-ATA@users.noreply.github.com>
Date: Tue, 21 Jun 2022 14:04:37 -0400
Subject: Remove `cargo_dev` dependency

---
 clippy_lints/Cargo.toml                                     | 3 +--
 clippy_lints/src/utils/internal_lints/metadata_collector.rs | 7 ++++++-
 2 files changed, 7 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/Cargo.toml b/clippy_lints/Cargo.toml
index eb4582b93f2..8246df01dd9 100644
--- a/clippy_lints/Cargo.toml
+++ b/clippy_lints/Cargo.toml
@@ -10,7 +10,6 @@ edition = "2021"
 
 [dependencies]
 cargo_metadata = "0.14"
-clippy_dev = { path = "../clippy_dev", optional = true }
 clippy_utils = { path = "../clippy_utils" }
 if_chain = "1.0"
 itertools = "0.10.1"
@@ -32,7 +31,7 @@ url = { version = "2.2", features = ["serde"] }
 [features]
 deny-warnings = ["clippy_utils/deny-warnings"]
 # build clippy with internal lints enabled, off by default
-internal = ["clippy_utils/internal", "serde_json", "tempfile", "clippy_dev"]
+internal = ["clippy_utils/internal", "serde_json", "tempfile"]
 
 [package.metadata.rust-analyzer]
 # This crate uses #[feature(rustc_private)]
diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index 99e9e3275ab..f3d36938041 100644
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -191,7 +191,12 @@ impl MetadataCollector {
             lints: BinaryHeap::<LintMetadata>::default(),
             applicability_info: FxHashMap::<String, ApplicabilityInfo>::default(),
             config: collect_configs(),
-            clippy_project_root: clippy_dev::clippy_project_root(),
+            clippy_project_root: std::env::current_dir()
+                .expect("failed to get current dir")
+                .ancestors()
+                .nth(1)
+                .expect("failed to get project root")
+                .to_path_buf(),
         }
     }
 
-- 
cgit 1.4.1-3-g733a5


From e5ebd3edabc17436de086a7ce147983c2238939a Mon Sep 17 00:00:00 2001
From: Evan Typanski <evan.typanski@microfocus.com>
Date: Tue, 21 Jun 2022 14:13:15 -0400
Subject: Implement manual_rem_euclid lint

---
 CHANGELOG.md                                |   1 +
 clippy_lints/src/lib.register_all.rs        |   1 +
 clippy_lints/src/lib.register_complexity.rs |   1 +
 clippy_lints/src/lib.register_lints.rs      |   1 +
 clippy_lints/src/lib.rs                     |   2 +
 clippy_lints/src/manual_rem_euclid.rs       | 110 ++++++++++++++++++++++++++++
 clippy_utils/src/msrvs.rs                   |   2 +-
 tests/ui/manual_rem_euclid.fixed            |  17 +++++
 tests/ui/manual_rem_euclid.rs               |  17 +++++
 tests/ui/manual_rem_euclid.stderr           |  34 +++++++++
 tests/ui/min_rust_version_attr.rs           |   6 ++
 tests/ui/min_rust_version_attr.stderr       |   8 +-
 12 files changed, 195 insertions(+), 5 deletions(-)
 create mode 100644 clippy_lints/src/manual_rem_euclid.rs
 create mode 100644 tests/ui/manual_rem_euclid.fixed
 create mode 100644 tests/ui/manual_rem_euclid.rs
 create mode 100644 tests/ui/manual_rem_euclid.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index d64dd772ac5..dcc96bc10b8 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3527,6 +3527,7 @@ Released 2018-09-13
 [`manual_non_exhaustive`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_non_exhaustive
 [`manual_ok_or`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_ok_or
 [`manual_range_contains`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_range_contains
+[`manual_rem_euclid`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_rem_euclid
 [`manual_saturating_arithmetic`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_saturating_arithmetic
 [`manual_split_once`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_split_once
 [`manual_str_repeat`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_str_repeat
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 7876f21f6e6..a1565255b0b 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -135,6 +135,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(manual_async_fn::MANUAL_ASYNC_FN),
     LintId::of(manual_bits::MANUAL_BITS),
     LintId::of(manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE),
+    LintId::of(manual_rem_euclid::MANUAL_REM_EUCLID),
     LintId::of(manual_strip::MANUAL_STRIP),
     LintId::of(map_clone::MAP_CLONE),
     LintId::of(map_unit_fn::OPTION_MAP_UNIT_FN),
diff --git a/clippy_lints/src/lib.register_complexity.rs b/clippy_lints/src/lib.register_complexity.rs
index 4f1c3673f85..6370264a12a 100644
--- a/clippy_lints/src/lib.register_complexity.rs
+++ b/clippy_lints/src/lib.register_complexity.rs
@@ -24,6 +24,7 @@ store.register_group(true, "clippy::complexity", Some("clippy_complexity"), vec!
     LintId::of(loops::MANUAL_FLATTEN),
     LintId::of(loops::SINGLE_ELEMENT_LOOP),
     LintId::of(loops::WHILE_LET_LOOP),
+    LintId::of(manual_rem_euclid::MANUAL_REM_EUCLID),
     LintId::of(manual_strip::MANUAL_STRIP),
     LintId::of(map_unit_fn::OPTION_MAP_UNIT_FN),
     LintId::of(map_unit_fn::RESULT_MAP_UNIT_FN),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index de22f50cf94..f706ba0620f 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -254,6 +254,7 @@ store.register_lints(&[
     manual_bits::MANUAL_BITS,
     manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE,
     manual_ok_or::MANUAL_OK_OR,
+    manual_rem_euclid::MANUAL_REM_EUCLID,
     manual_strip::MANUAL_STRIP,
     map_clone::MAP_CLONE,
     map_err_ignore::MAP_ERR_IGNORE,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index dcee11cc28c..70cf6be8b7c 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -282,6 +282,7 @@ mod manual_async_fn;
 mod manual_bits;
 mod manual_non_exhaustive;
 mod manual_ok_or;
+mod manual_rem_euclid;
 mod manual_strip;
 mod map_clone;
 mod map_err_ignore;
@@ -912,6 +913,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(as_underscore::AsUnderscore));
     store.register_late_pass(|| Box::new(read_zero_byte_vec::ReadZeroByteVec));
     store.register_late_pass(|| Box::new(default_instead_of_iter_empty::DefaultIterEmpty));
+    store.register_late_pass(move || Box::new(manual_rem_euclid::ManualRemEuclid::new(msrv)));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/manual_rem_euclid.rs b/clippy_lints/src/manual_rem_euclid.rs
new file mode 100644
index 00000000000..7ef8f78a5f6
--- /dev/null
+++ b/clippy_lints/src/manual_rem_euclid.rs
@@ -0,0 +1,110 @@
+use clippy_utils::consts::{constant_full_int, FullInt};
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::{meets_msrv, msrvs, path_to_local};
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir::{BinOpKind, Expr, ExprKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_semver::RustcVersion;
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for an expression like `((x % 4) + 4) % 4` which is a common manual reimplementation
+    /// of `x.rem_euclid(4)`.
+    ///
+    /// ### Why is this bad?
+    /// It's simpler and more readable.
+    ///
+    /// ### Example
+    /// ```rust
+    /// let x = 24;
+    /// let rem = ((x % 4) + 4) % 4;
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// let x = 24;
+    /// let rem = x.rem_euclid(4);
+    /// ```
+    #[clippy::version = "1.63.0"]
+    pub MANUAL_REM_EUCLID,
+    complexity,
+    "manually reimplementing `rem_euclid`"
+}
+
+pub struct ManualRemEuclid {
+    msrv: Option<RustcVersion>,
+}
+
+impl ManualRemEuclid {
+    #[must_use]
+    pub fn new(msrv: Option<RustcVersion>) -> Self {
+        Self { msrv }
+    }
+}
+
+impl_lint_pass!(ManualRemEuclid => [MANUAL_REM_EUCLID]);
+
+impl<'tcx> LateLintPass<'tcx> for ManualRemEuclid {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        if !meets_msrv(self.msrv, msrvs::REM_EUCLID) {
+            return;
+        }
+
+        if_chain! {
+            if let ExprKind::Binary(op1, ..) = expr.kind;
+            if op1.node == BinOpKind::Rem;
+            if let Some((const1, expr1)) = check_for_positive_int_constant(cx, expr);
+            if let ExprKind::Binary(op2, ..) = expr1.kind;
+            if op2.node == BinOpKind::Add;
+            if let Some((const2, expr2)) = check_for_positive_int_constant(cx, expr1);
+            if let ExprKind::Binary(op3, ..) = expr2.kind;
+            if op3.node == BinOpKind::Rem;
+            if let Some((const3, expr3)) = check_for_positive_int_constant(cx, expr2);
+            if const1 == const2 && const2 == const3;
+            if path_to_local(expr3).is_some();
+            then {
+                let mut app = Applicability::MachineApplicable;
+                let rem_of = snippet_with_applicability(cx, expr3.span, "_", &mut app);
+                span_lint_and_sugg(
+                    cx,
+                    MANUAL_REM_EUCLID,
+                    expr.span,
+                    "manual `rem_euclid` implementation",
+                    "consider using",
+                    format!("{rem_of}.rem_euclid({const1})"),
+                    app,
+                );
+            }
+        }
+    }
+
+    extract_msrv_attr!(LateContext);
+}
+
+// Takes a binary expression and separates the operands into the int constant and the other
+// operand. Ensures the int constant is positive.
+fn check_for_positive_int_constant<'a>(cx: &'a LateContext<'_>, expr: &'a Expr<'_>) -> Option<(u128, &'a Expr<'a>)> {
+    let (int_const, other_op) = if let ExprKind::Binary(_, left, right) = expr.kind {
+        if let Some(int_const) = constant_full_int(cx, cx.typeck_results(), left) {
+            (int_const, right)
+        } else if let Some(int_const) = constant_full_int(cx, cx.typeck_results(), right) {
+            (int_const, left)
+        } else {
+            return None;
+        }
+    } else {
+        return None;
+    };
+
+    if int_const > FullInt::S(0) {
+        let val = match int_const {
+            FullInt::S(s) => s.try_into().unwrap(),
+            FullInt::U(u) => u,
+        };
+        Some((val, other_op))
+    } else {
+        None
+    }
+}
diff --git a/clippy_utils/src/msrvs.rs b/clippy_utils/src/msrvs.rs
index b9ec2c19fdd..8000f9e21a1 100644
--- a/clippy_utils/src/msrvs.rs
+++ b/clippy_utils/src/msrvs.rs
@@ -23,7 +23,7 @@ msrv_aliases! {
     1,42,0 { MATCHES_MACRO, SLICE_PATTERNS, PTR_SLICE_RAW_PARTS }
     1,41,0 { RE_REBALANCING_COHERENCE, RESULT_MAP_OR_ELSE }
     1,40,0 { MEM_TAKE, NON_EXHAUSTIVE, OPTION_AS_DEREF }
-    1,38,0 { POINTER_CAST }
+    1,38,0 { POINTER_CAST, REM_EUCLID }
     1,37,0 { TYPE_ALIAS_ENUM_VARIANTS }
     1,36,0 { ITERATOR_COPIED }
     1,35,0 { OPTION_COPIED, RANGE_CONTAINS }
diff --git a/tests/ui/manual_rem_euclid.fixed b/tests/ui/manual_rem_euclid.fixed
new file mode 100644
index 00000000000..f176fc9ad12
--- /dev/null
+++ b/tests/ui/manual_rem_euclid.fixed
@@ -0,0 +1,17 @@
+// run-rustfix
+
+#![warn(clippy::manual_rem_euclid)]
+
+fn main() {
+    let value: i32 = 5;
+
+    let _: i32 = value.rem_euclid(4);
+    let _: i32 = value.rem_euclid(4);
+    let _: i32 = value.rem_euclid(4);
+    let _: i32 = value.rem_euclid(4);
+    let _: i32 = 1 + value.rem_euclid(4);
+
+    let _: i32 = (3 + value % 4) % 4;
+    let _: i32 = (-4 + value % -4) % -4;
+    let _: i32 = ((5 % 4) + 4) % 4;
+}
diff --git a/tests/ui/manual_rem_euclid.rs b/tests/ui/manual_rem_euclid.rs
new file mode 100644
index 00000000000..b243065de87
--- /dev/null
+++ b/tests/ui/manual_rem_euclid.rs
@@ -0,0 +1,17 @@
+// run-rustfix
+
+#![warn(clippy::manual_rem_euclid)]
+
+fn main() {
+    let value: i32 = 5;
+
+    let _: i32 = ((value % 4) + 4) % 4;
+    let _: i32 = (4 + (value % 4)) % 4;
+    let _: i32 = (value % 4 + 4) % 4;
+    let _: i32 = (4 + value % 4) % 4;
+    let _: i32 = 1 + (4 + value % 4) % 4;
+
+    let _: i32 = (3 + value % 4) % 4;
+    let _: i32 = (-4 + value % -4) % -4;
+    let _: i32 = ((5 % 4) + 4) % 4;
+}
diff --git a/tests/ui/manual_rem_euclid.stderr b/tests/ui/manual_rem_euclid.stderr
new file mode 100644
index 00000000000..7134759dcc9
--- /dev/null
+++ b/tests/ui/manual_rem_euclid.stderr
@@ -0,0 +1,34 @@
+error: manual `rem_euclid` implementation
+  --> $DIR/manual_rem_euclid.rs:8:18
+   |
+LL |     let _: i32 = ((value % 4) + 4) % 4;
+   |                  ^^^^^^^^^^^^^^^^^^^^^ help: consider using: `value.rem_euclid(4)`
+   |
+   = note: `-D clippy::manual-rem-euclid` implied by `-D warnings`
+
+error: manual `rem_euclid` implementation
+  --> $DIR/manual_rem_euclid.rs:9:18
+   |
+LL |     let _: i32 = (4 + (value % 4)) % 4;
+   |                  ^^^^^^^^^^^^^^^^^^^^^ help: consider using: `value.rem_euclid(4)`
+
+error: manual `rem_euclid` implementation
+  --> $DIR/manual_rem_euclid.rs:10:18
+   |
+LL |     let _: i32 = (value % 4 + 4) % 4;
+   |                  ^^^^^^^^^^^^^^^^^^^ help: consider using: `value.rem_euclid(4)`
+
+error: manual `rem_euclid` implementation
+  --> $DIR/manual_rem_euclid.rs:11:18
+   |
+LL |     let _: i32 = (4 + value % 4) % 4;
+   |                  ^^^^^^^^^^^^^^^^^^^ help: consider using: `value.rem_euclid(4)`
+
+error: manual `rem_euclid` implementation
+  --> $DIR/manual_rem_euclid.rs:12:22
+   |
+LL |     let _: i32 = 1 + (4 + value % 4) % 4;
+   |                      ^^^^^^^^^^^^^^^^^^^ help: consider using: `value.rem_euclid(4)`
+
+error: aborting due to 5 previous errors
+
diff --git a/tests/ui/min_rust_version_attr.rs b/tests/ui/min_rust_version_attr.rs
index f83c3e0e281..301a8e54ccf 100644
--- a/tests/ui/min_rust_version_attr.rs
+++ b/tests/ui/min_rust_version_attr.rs
@@ -155,6 +155,11 @@ fn cast_abs_to_unsigned() {
     assert_eq!(10u32, x.abs() as u32);
 }
 
+fn manual_rem_euclid() {
+    let x: i32 = 10;
+    let _: i32 = ((x % 4) + 4) % 4;
+}
+
 fn main() {
     filter_map_next();
     checked_conversion();
@@ -174,6 +179,7 @@ fn main() {
     int_from_bool();
     err_expect();
     cast_abs_to_unsigned();
+    manual_rem_euclid();
 }
 
 mod just_under_msrv {
diff --git a/tests/ui/min_rust_version_attr.stderr b/tests/ui/min_rust_version_attr.stderr
index de225eb740d..b1c23b539ff 100644
--- a/tests/ui/min_rust_version_attr.stderr
+++ b/tests/ui/min_rust_version_attr.stderr
@@ -1,12 +1,12 @@
 error: stripping a prefix manually
-  --> $DIR/min_rust_version_attr.rs:198:24
+  --> $DIR/min_rust_version_attr.rs:204:24
    |
 LL |             assert_eq!(s["hello, ".len()..].to_uppercase(), "WORLD!");
    |                        ^^^^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::manual-strip` implied by `-D warnings`
 note: the prefix was tested here
-  --> $DIR/min_rust_version_attr.rs:197:9
+  --> $DIR/min_rust_version_attr.rs:203:9
    |
 LL |         if s.starts_with("hello, ") {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -17,13 +17,13 @@ LL ~             assert_eq!(<stripped>.to_uppercase(), "WORLD!");
    |
 
 error: stripping a prefix manually
-  --> $DIR/min_rust_version_attr.rs:210:24
+  --> $DIR/min_rust_version_attr.rs:216:24
    |
 LL |             assert_eq!(s["hello, ".len()..].to_uppercase(), "WORLD!");
    |                        ^^^^^^^^^^^^^^^^^^^^
    |
 note: the prefix was tested here
-  --> $DIR/min_rust_version_attr.rs:209:9
+  --> $DIR/min_rust_version_attr.rs:215:9
    |
 LL |         if s.starts_with("hello, ") {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From 6e1df4732b6fb877361b0dd3b209f194481bbe7b Mon Sep 17 00:00:00 2001
From: Evan Typanski <evan.typanski@microfocus.com>
Date: Tue, 21 Jun 2022 16:41:36 -0400
Subject: Fix case where suggestion errored for infer type

---
 clippy_lints/src/manual_rem_euclid.rs | 15 +++++++++++----
 tests/ui/manual_rem_euclid.fixed      |  7 +++++++
 tests/ui/manual_rem_euclid.rs         |  7 +++++++
 3 files changed, 25 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_rem_euclid.rs b/clippy_lints/src/manual_rem_euclid.rs
index 7ef8f78a5f6..cba03389a9b 100644
--- a/clippy_lints/src/manual_rem_euclid.rs
+++ b/clippy_lints/src/manual_rem_euclid.rs
@@ -4,7 +4,7 @@ use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::{meets_msrv, msrvs, path_to_local};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
-use rustc_hir::{BinOpKind, Expr, ExprKind};
+use rustc_hir::{BinOpKind, Expr, ExprKind, Node, TyKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
@@ -19,12 +19,12 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust
-    /// let x = 24;
+    /// let x: i32 = 24;
     /// let rem = ((x % 4) + 4) % 4;
     /// ```
     /// Use instead:
     /// ```rust
-    /// let x = 24;
+    /// let x: i32 = 24;
     /// let rem = x.rem_euclid(4);
     /// ```
     #[clippy::version = "1.63.0"]
@@ -63,7 +63,14 @@ impl<'tcx> LateLintPass<'tcx> for ManualRemEuclid {
             if op3.node == BinOpKind::Rem;
             if let Some((const3, expr3)) = check_for_positive_int_constant(cx, expr2);
             if const1 == const2 && const2 == const3;
-            if path_to_local(expr3).is_some();
+            // Only apply if we see an explicit type annotation on the local.
+            if let Some(hir_id) = path_to_local(expr3);
+            let hir = cx.tcx.hir();
+            if let Some(Node::Binding(_)) = hir.find(hir_id);
+            let parent = hir.get_parent_node(hir_id);
+            if let Some(Node::Local(local)) = hir.find(parent);
+            if let Some(ty) = local.ty;
+            if !matches!(ty.kind, TyKind::Infer);
             then {
                 let mut app = Applicability::MachineApplicable;
                 let rem_of = snippet_with_applicability(cx, expr3.span, "_", &mut app);
diff --git a/tests/ui/manual_rem_euclid.fixed b/tests/ui/manual_rem_euclid.fixed
index f176fc9ad12..10a10e812f4 100644
--- a/tests/ui/manual_rem_euclid.fixed
+++ b/tests/ui/manual_rem_euclid.fixed
@@ -14,4 +14,11 @@ fn main() {
     let _: i32 = (3 + value % 4) % 4;
     let _: i32 = (-4 + value % -4) % -4;
     let _: i32 = ((5 % 4) + 4) % 4;
+
+    // Make sure the lint does not trigger if it would cause an error, like with an ambiguous
+    // integer type
+    let not_annotated = 24;
+    let _ = ((not_annotated % 4) + 4) % 4;
+    let inferred: _ = 24;
+    let _ = ((inferred % 4) + 4) % 4;
 }
diff --git a/tests/ui/manual_rem_euclid.rs b/tests/ui/manual_rem_euclid.rs
index b243065de87..bf16f977ea9 100644
--- a/tests/ui/manual_rem_euclid.rs
+++ b/tests/ui/manual_rem_euclid.rs
@@ -14,4 +14,11 @@ fn main() {
     let _: i32 = (3 + value % 4) % 4;
     let _: i32 = (-4 + value % -4) % -4;
     let _: i32 = ((5 % 4) + 4) % 4;
+
+    // Make sure the lint does not trigger if it would cause an error, like with an ambiguous
+    // integer type
+    let not_annotated = 24;
+    let _ = ((not_annotated % 4) + 4) % 4;
+    let inferred: _ = 24;
+    let _ = ((inferred % 4) + 4) % 4;
 }
-- 
cgit 1.4.1-3-g733a5


From ab645bb08177723bf926a6ee2724b5b653fb5d4e Mon Sep 17 00:00:00 2001
From: kyoto7250 <50972773+kyoto7250@users.noreply.github.com>
Date: Wed, 22 Jun 2022 07:59:14 +0900
Subject: enum_variant_names should ignore when all prefixes are _

---
 clippy_lints/src/enum_variants.rs |  7 ++++++-
 tests/ui/enum_variants.rs         | 21 +++++++++++++++++++++
 tests/ui/enum_variants.stderr     | 27 ++++++++++++++++++++++++++-
 3 files changed, 53 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/enum_variants.rs b/clippy_lints/src/enum_variants.rs
index 23b75104570..517e11b4e6b 100644
--- a/clippy_lints/src/enum_variants.rs
+++ b/clippy_lints/src/enum_variants.rs
@@ -190,7 +190,7 @@ fn check_variant(cx: &LateContext<'_>, threshold: u64, def: &EnumDef<'_>, item_n
             .map(|e| *e.0)
             .collect();
     }
-    let (what, value) = match (pre.is_empty(), post.is_empty()) {
+    let (what, value) = match (have_no_extra_prefix(&pre), post.is_empty()) {
         (true, true) => return,
         (false, _) => ("pre", pre.join("")),
         (true, false) => {
@@ -212,6 +212,11 @@ fn check_variant(cx: &LateContext<'_>, threshold: u64, def: &EnumDef<'_>, item_n
     );
 }
 
+#[must_use]
+fn have_no_extra_prefix(prefixes: &Vec<&str>) -> bool {
+    prefixes.is_empty() || prefixes.join("") == "_"
+}
+
 #[must_use]
 fn to_camel_case(item_name: &str) -> String {
     let mut s = String::new();
diff --git a/tests/ui/enum_variants.rs b/tests/ui/enum_variants.rs
index b2bf7c4e360..efed12ee2ef 100644
--- a/tests/ui/enum_variants.rs
+++ b/tests/ui/enum_variants.rs
@@ -158,4 +158,25 @@ enum Phase {
     PostLookup,
 }
 
+mod issue9018 {
+    enum DoLint {
+        _TypeCreate,
+        _TypeRead,
+        _TypeUpdate,
+        _TypeDestroy,
+    }
+
+    enum DoLintToo {
+        _CreateType,
+        _UpdateType,
+        _DeleteType,
+    }
+
+    enum DoNotLint {
+        _Foo,
+        _Bar,
+        _Baz,
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/enum_variants.stderr b/tests/ui/enum_variants.stderr
index 8a3265086e8..7342aff80f0 100644
--- a/tests/ui/enum_variants.stderr
+++ b/tests/ui/enum_variants.stderr
@@ -120,5 +120,30 @@ LL | | }
    |
    = help: remove the postfixes and use full paths to the variants instead of glob imports
 
-error: aborting due to 12 previous errors
+error: all variants have the same prefix: `_Type`
+  --> $DIR/enum_variants.rs:162:5
+   |
+LL | /     enum DoLint {
+LL | |         _TypeCreate,
+LL | |         _TypeRead,
+LL | |         _TypeUpdate,
+LL | |         _TypeDestroy,
+LL | |     }
+   | |_____^
+   |
+   = help: remove the prefixes and use full paths to the variants instead of glob imports
+
+error: all variants have the same postfix: `Type`
+  --> $DIR/enum_variants.rs:169:5
+   |
+LL | /     enum DoLintToo {
+LL | |         _CreateType,
+LL | |         _UpdateType,
+LL | |         _DeleteType,
+LL | |     }
+   | |_____^
+   |
+   = help: remove the postfixes and use full paths to the variants instead of glob imports
+
+error: aborting due to 14 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From b969326874ecd1f0a9e52aab629d089f258039b4 Mon Sep 17 00:00:00 2001
From: alexey semenyuk <alexsemenyuk88@gmail.com>
Date: Wed, 22 Jun 2022 11:01:52 +0000
Subject: Example for VEC_RESIZE_TO_ZERO

---
 clippy_lints/src/vec_resize_to_zero.rs | 5 +++++
 1 file changed, 5 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/vec_resize_to_zero.rs b/clippy_lints/src/vec_resize_to_zero.rs
index 4d86abd0fa1..0fee3e812d2 100644
--- a/clippy_lints/src/vec_resize_to_zero.rs
+++ b/clippy_lints/src/vec_resize_to_zero.rs
@@ -20,6 +20,11 @@ declare_clippy_lint! {
     /// ```rust
     /// vec!(1, 2, 3, 4, 5).resize(0, 5)
     /// ```
+    ///
+    /// Use instead:
+    /// ```rust
+    /// vec!(1, 2, 3, 4, 5).clear()
+    /// ```
     #[clippy::version = "1.46.0"]
     pub VEC_RESIZE_TO_ZERO,
     correctness,
-- 
cgit 1.4.1-3-g733a5


From 75ed0c9f267c8e65d3bbd45c6e10acd11e702077 Mon Sep 17 00:00:00 2001
From: Evan Typanski <evan.typanski@microfocus.com>
Date: Wed, 22 Jun 2022 13:15:35 -0400
Subject: Prefer `.ok()?` over `.unwrap()`

---
 clippy_lints/src/manual_rem_euclid.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_rem_euclid.rs b/clippy_lints/src/manual_rem_euclid.rs
index cba03389a9b..d6b74b3e1ca 100644
--- a/clippy_lints/src/manual_rem_euclid.rs
+++ b/clippy_lints/src/manual_rem_euclid.rs
@@ -107,7 +107,7 @@ fn check_for_positive_int_constant<'a>(cx: &'a LateContext<'_>, expr: &'a Expr<'
 
     if int_const > FullInt::S(0) {
         let val = match int_const {
-            FullInt::S(s) => s.try_into().unwrap(),
+            FullInt::S(s) => s.try_into().ok()?,
             FullInt::U(u) => u,
         };
         Some((val, other_op))
-- 
cgit 1.4.1-3-g733a5


From 93e41d3305c683a4ed19ff3001832f8c84090310 Mon Sep 17 00:00:00 2001
From: Evan Typanski <evan.typanski@microfocus.com>
Date: Wed, 22 Jun 2022 13:26:13 -0400
Subject: Fix case where rem was considered commutative

---
 clippy_lints/src/manual_rem_euclid.rs | 21 +++++++++++++--------
 tests/ui/manual_rem_euclid.fixed      |  4 ++++
 tests/ui/manual_rem_euclid.rs         |  4 ++++
 3 files changed, 21 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_rem_euclid.rs b/clippy_lints/src/manual_rem_euclid.rs
index d6b74b3e1ca..9b31e70e3f0 100644
--- a/clippy_lints/src/manual_rem_euclid.rs
+++ b/clippy_lints/src/manual_rem_euclid.rs
@@ -55,13 +55,13 @@ impl<'tcx> LateLintPass<'tcx> for ManualRemEuclid {
         if_chain! {
             if let ExprKind::Binary(op1, ..) = expr.kind;
             if op1.node == BinOpKind::Rem;
-            if let Some((const1, expr1)) = check_for_positive_int_constant(cx, expr);
+            if let Some((const1, expr1)) = check_for_positive_int_constant(cx, expr, false);
             if let ExprKind::Binary(op2, ..) = expr1.kind;
             if op2.node == BinOpKind::Add;
-            if let Some((const2, expr2)) = check_for_positive_int_constant(cx, expr1);
+            if let Some((const2, expr2)) = check_for_positive_int_constant(cx, expr1, true);
             if let ExprKind::Binary(op3, ..) = expr2.kind;
             if op3.node == BinOpKind::Rem;
-            if let Some((const3, expr3)) = check_for_positive_int_constant(cx, expr2);
+            if let Some((const3, expr3)) = check_for_positive_int_constant(cx, expr2, false);
             if const1 == const2 && const2 == const3;
             // Only apply if we see an explicit type annotation on the local.
             if let Some(hir_id) = path_to_local(expr3);
@@ -91,13 +91,18 @@ impl<'tcx> LateLintPass<'tcx> for ManualRemEuclid {
 }
 
 // Takes a binary expression and separates the operands into the int constant and the other
-// operand. Ensures the int constant is positive.
-fn check_for_positive_int_constant<'a>(cx: &'a LateContext<'_>, expr: &'a Expr<'_>) -> Option<(u128, &'a Expr<'a>)> {
+// operand. Ensures the int constant is positive. Operators that are not commutative must have the
+// constant appear on the right hand side to return a value.
+fn check_for_positive_int_constant<'a>(
+    cx: &'a LateContext<'_>,
+    expr: &'a Expr<'_>,
+    is_commutative: bool,
+) -> Option<(u128, &'a Expr<'a>)> {
     let (int_const, other_op) = if let ExprKind::Binary(_, left, right) = expr.kind {
-        if let Some(int_const) = constant_full_int(cx, cx.typeck_results(), left) {
-            (int_const, right)
-        } else if let Some(int_const) = constant_full_int(cx, cx.typeck_results(), right) {
+        if let Some(int_const) = constant_full_int(cx, cx.typeck_results(), right) {
             (int_const, left)
+        } else if is_commutative && let Some(int_const) = constant_full_int(cx, cx.typeck_results(), left) {
+            (int_const, right)
         } else {
             return None;
         }
diff --git a/tests/ui/manual_rem_euclid.fixed b/tests/ui/manual_rem_euclid.fixed
index 10a10e812f4..d0aa2398811 100644
--- a/tests/ui/manual_rem_euclid.fixed
+++ b/tests/ui/manual_rem_euclid.fixed
@@ -21,4 +21,8 @@ fn main() {
     let _ = ((not_annotated % 4) + 4) % 4;
     let inferred: _ = 24;
     let _ = ((inferred % 4) + 4) % 4;
+
+    // For lint to apply the constant must always be on the RHS of the previous value for %
+    let _: i32 = 4 % ((value % 4) + 4);
+    let _: i32 = ((4 % value) + 4) % 4;
 }
diff --git a/tests/ui/manual_rem_euclid.rs b/tests/ui/manual_rem_euclid.rs
index bf16f977ea9..ff87d6fab52 100644
--- a/tests/ui/manual_rem_euclid.rs
+++ b/tests/ui/manual_rem_euclid.rs
@@ -21,4 +21,8 @@ fn main() {
     let _ = ((not_annotated % 4) + 4) % 4;
     let inferred: _ = 24;
     let _ = ((inferred % 4) + 4) % 4;
+
+    // For lint to apply the constant must always be on the RHS of the previous value for %
+    let _: i32 = 4 % ((value % 4) + 4);
+    let _: i32 = ((4 % value) + 4) % 4;
 }
-- 
cgit 1.4.1-3-g733a5


From c8df6d6970749abc8ee3b3b5f78d4c1a9ad33bb6 Mon Sep 17 00:00:00 2001
From: Evan Typanski <evan.typanski@microfocus.com>
Date: Wed, 22 Jun 2022 13:31:04 -0400
Subject: Prefer if let chain over macro

---
 clippy_lints/src/manual_rem_euclid.rs | 36 +++++++++++++++--------------------
 1 file changed, 15 insertions(+), 21 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_rem_euclid.rs b/clippy_lints/src/manual_rem_euclid.rs
index 9b31e70e3f0..3ffd9a07376 100644
--- a/clippy_lints/src/manual_rem_euclid.rs
+++ b/clippy_lints/src/manual_rem_euclid.rs
@@ -2,7 +2,6 @@ use clippy_utils::consts::{constant_full_int, FullInt};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::{meets_msrv, msrvs, path_to_local};
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind, Node, TyKind};
 use rustc_lint::{LateContext, LateLintPass};
@@ -52,26 +51,22 @@ impl<'tcx> LateLintPass<'tcx> for ManualRemEuclid {
             return;
         }
 
-        if_chain! {
-            if let ExprKind::Binary(op1, ..) = expr.kind;
-            if op1.node == BinOpKind::Rem;
-            if let Some((const1, expr1)) = check_for_positive_int_constant(cx, expr, false);
-            if let ExprKind::Binary(op2, ..) = expr1.kind;
-            if op2.node == BinOpKind::Add;
-            if let Some((const2, expr2)) = check_for_positive_int_constant(cx, expr1, true);
-            if let ExprKind::Binary(op3, ..) = expr2.kind;
-            if op3.node == BinOpKind::Rem;
-            if let Some((const3, expr3)) = check_for_positive_int_constant(cx, expr2, false);
-            if const1 == const2 && const2 == const3;
+        if let ExprKind::Binary(op1, ..) = expr.kind
+            && op1.node == BinOpKind::Rem
+            && let Some((const1, expr1)) = check_for_positive_int_constant(cx, expr, false)
+            && let ExprKind::Binary(op2, ..) = expr1.kind
+            && op2.node == BinOpKind::Add
+            && let Some((const2, expr2)) = check_for_positive_int_constant(cx, expr1, true)
+            && let ExprKind::Binary(op3, ..) = expr2.kind
+            && op3.node == BinOpKind::Rem
+            && let Some((const3, expr3)) = check_for_positive_int_constant(cx, expr2, false)
+            && const1 == const2 && const2 == const3
             // Only apply if we see an explicit type annotation on the local.
-            if let Some(hir_id) = path_to_local(expr3);
-            let hir = cx.tcx.hir();
-            if let Some(Node::Binding(_)) = hir.find(hir_id);
-            let parent = hir.get_parent_node(hir_id);
-            if let Some(Node::Local(local)) = hir.find(parent);
-            if let Some(ty) = local.ty;
-            if !matches!(ty.kind, TyKind::Infer);
-            then {
+            && let Some(hir_id) = path_to_local(expr3)
+            && let Some(Node::Binding(_)) = cx.tcx.hir().find(hir_id)
+            && let Some(Node::Local(local)) = cx.tcx.hir().find(cx.tcx.hir().get_parent_node(hir_id))
+            && let Some(ty) = local.ty
+            && !matches!(ty.kind, TyKind::Infer) {
                 let mut app = Applicability::MachineApplicable;
                 let rem_of = snippet_with_applicability(cx, expr3.span, "_", &mut app);
                 span_lint_and_sugg(
@@ -83,7 +78,6 @@ impl<'tcx> LateLintPass<'tcx> for ManualRemEuclid {
                     format!("{rem_of}.rem_euclid({const1})"),
                     app,
                 );
-            }
         }
     }
 
-- 
cgit 1.4.1-3-g733a5


From 90f8277fe3ce6d0e238feac3bf10891f8c18f23a Mon Sep 17 00:00:00 2001
From: Evan Typanski <evan.typanski@microfocus.com>
Date: Wed, 22 Jun 2022 14:08:47 -0400
Subject: Fix case for function params

---
 clippy_lints/src/manual_rem_euclid.rs | 21 ++++++++++++++++-----
 tests/ui/manual_rem_euclid.fixed      |  5 +++++
 tests/ui/manual_rem_euclid.rs         |  5 +++++
 tests/ui/manual_rem_euclid.stderr     |  8 +++++++-
 4 files changed, 33 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_rem_euclid.rs b/clippy_lints/src/manual_rem_euclid.rs
index 3ffd9a07376..c338447686f 100644
--- a/clippy_lints/src/manual_rem_euclid.rs
+++ b/clippy_lints/src/manual_rem_euclid.rs
@@ -61,12 +61,23 @@ impl<'tcx> LateLintPass<'tcx> for ManualRemEuclid {
             && op3.node == BinOpKind::Rem
             && let Some((const3, expr3)) = check_for_positive_int_constant(cx, expr2, false)
             && const1 == const2 && const2 == const3
-            // Only apply if we see an explicit type annotation on the local.
             && let Some(hir_id) = path_to_local(expr3)
-            && let Some(Node::Binding(_)) = cx.tcx.hir().find(hir_id)
-            && let Some(Node::Local(local)) = cx.tcx.hir().find(cx.tcx.hir().get_parent_node(hir_id))
-            && let Some(ty) = local.ty
-            && !matches!(ty.kind, TyKind::Infer) {
+            && let Some(Node::Binding(_)) = cx.tcx.hir().find(hir_id) {
+                // Apply only to params or locals with annotated types
+                match cx.tcx.hir().find(cx.tcx.hir().get_parent_node(hir_id)) {
+                    Some(Node::Param(..)) => (),
+                    Some(Node::Local(local)) => {
+                        if let Some(ty) = local.ty {
+                            if matches!(ty.kind, TyKind::Infer) {
+                                return;
+                            }
+                        } else {
+                            return;
+                        }
+                    }
+                    _ => return,
+                };
+
                 let mut app = Applicability::MachineApplicable;
                 let rem_of = snippet_with_applicability(cx, expr3.span, "_", &mut app);
                 span_lint_and_sugg(
diff --git a/tests/ui/manual_rem_euclid.fixed b/tests/ui/manual_rem_euclid.fixed
index d0aa2398811..7dcd78f4633 100644
--- a/tests/ui/manual_rem_euclid.fixed
+++ b/tests/ui/manual_rem_euclid.fixed
@@ -26,3 +26,8 @@ fn main() {
     let _: i32 = 4 % ((value % 4) + 4);
     let _: i32 = ((4 % value) + 4) % 4;
 }
+
+// Should lint for params too
+pub fn rem_euclid_4(num: i32) -> i32 {
+    num.rem_euclid(4)
+}
diff --git a/tests/ui/manual_rem_euclid.rs b/tests/ui/manual_rem_euclid.rs
index ff87d6fab52..f5d88ed6dfc 100644
--- a/tests/ui/manual_rem_euclid.rs
+++ b/tests/ui/manual_rem_euclid.rs
@@ -26,3 +26,8 @@ fn main() {
     let _: i32 = 4 % ((value % 4) + 4);
     let _: i32 = ((4 % value) + 4) % 4;
 }
+
+// Should lint for params too
+pub fn rem_euclid_4(num: i32) -> i32 {
+    ((num % 4) + 4) % 4
+}
diff --git a/tests/ui/manual_rem_euclid.stderr b/tests/ui/manual_rem_euclid.stderr
index 7134759dcc9..bad6e66beef 100644
--- a/tests/ui/manual_rem_euclid.stderr
+++ b/tests/ui/manual_rem_euclid.stderr
@@ -30,5 +30,11 @@ error: manual `rem_euclid` implementation
 LL |     let _: i32 = 1 + (4 + value % 4) % 4;
    |                      ^^^^^^^^^^^^^^^^^^^ help: consider using: `value.rem_euclid(4)`
 
-error: aborting due to 5 previous errors
+error: manual `rem_euclid` implementation
+  --> $DIR/manual_rem_euclid.rs:32:5
+   |
+LL |     ((num % 4) + 4) % 4
+   |     ^^^^^^^^^^^^^^^^^^^ help: consider using: `num.rem_euclid(4)`
+
+error: aborting due to 6 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 61e1870aff5d77088e487b1506cbf537ac81e63a Mon Sep 17 00:00:00 2001
From: Evan Typanski <evan.typanski@microfocus.com>
Date: Wed, 22 Jun 2022 14:17:52 -0400
Subject: Add MSRV check for const rem_euclid

---
 clippy_lints/src/manual_rem_euclid.rs | 6 +++++-
 clippy_utils/src/msrvs.rs             | 2 +-
 tests/ui/manual_rem_euclid.fixed      | 5 +++++
 tests/ui/manual_rem_euclid.rs         | 5 +++++
 tests/ui/manual_rem_euclid.stderr     | 8 +++++++-
 5 files changed, 23 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_rem_euclid.rs b/clippy_lints/src/manual_rem_euclid.rs
index c338447686f..d22397ca35e 100644
--- a/clippy_lints/src/manual_rem_euclid.rs
+++ b/clippy_lints/src/manual_rem_euclid.rs
@@ -1,7 +1,7 @@
 use clippy_utils::consts::{constant_full_int, FullInt};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::{meets_msrv, msrvs, path_to_local};
+use clippy_utils::{in_constant, meets_msrv, msrvs, path_to_local};
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind, Node, TyKind};
 use rustc_lint::{LateContext, LateLintPass};
@@ -51,6 +51,10 @@ impl<'tcx> LateLintPass<'tcx> for ManualRemEuclid {
             return;
         }
 
+        if in_constant(cx, expr.hir_id) && !meets_msrv(self.msrv, msrvs::REM_EUCLID_CONST) {
+            return;
+        }
+
         if let ExprKind::Binary(op1, ..) = expr.kind
             && op1.node == BinOpKind::Rem
             && let Some((const1, expr1)) = check_for_positive_int_constant(cx, expr, false)
diff --git a/clippy_utils/src/msrvs.rs b/clippy_utils/src/msrvs.rs
index 8000f9e21a1..43c0a03c42a 100644
--- a/clippy_utils/src/msrvs.rs
+++ b/clippy_utils/src/msrvs.rs
@@ -13,7 +13,7 @@ macro_rules! msrv_aliases {
 // names may refer to stabilized feature flags or library items
 msrv_aliases! {
     1,53,0 { OR_PATTERNS, MANUAL_BITS }
-    1,52,0 { STR_SPLIT_ONCE }
+    1,52,0 { STR_SPLIT_ONCE, REM_EUCLID_CONST }
     1,51,0 { BORROW_AS_PTR, UNSIGNED_ABS }
     1,50,0 { BOOL_THEN }
     1,47,0 { TAU }
diff --git a/tests/ui/manual_rem_euclid.fixed b/tests/ui/manual_rem_euclid.fixed
index 7dcd78f4633..a3e593eac06 100644
--- a/tests/ui/manual_rem_euclid.fixed
+++ b/tests/ui/manual_rem_euclid.fixed
@@ -31,3 +31,8 @@ fn main() {
 pub fn rem_euclid_4(num: i32) -> i32 {
     num.rem_euclid(4)
 }
+
+// Constant version came later, should still lint
+pub const fn const_rem_euclid_4(num: i32) -> i32 {
+    num.rem_euclid(4)
+}
diff --git a/tests/ui/manual_rem_euclid.rs b/tests/ui/manual_rem_euclid.rs
index f5d88ed6dfc..2d8c6411f20 100644
--- a/tests/ui/manual_rem_euclid.rs
+++ b/tests/ui/manual_rem_euclid.rs
@@ -31,3 +31,8 @@ fn main() {
 pub fn rem_euclid_4(num: i32) -> i32 {
     ((num % 4) + 4) % 4
 }
+
+// Constant version came later, should still lint
+pub const fn const_rem_euclid_4(num: i32) -> i32 {
+    ((num % 4) + 4) % 4
+}
diff --git a/tests/ui/manual_rem_euclid.stderr b/tests/ui/manual_rem_euclid.stderr
index bad6e66beef..3faeb6c6a88 100644
--- a/tests/ui/manual_rem_euclid.stderr
+++ b/tests/ui/manual_rem_euclid.stderr
@@ -36,5 +36,11 @@ error: manual `rem_euclid` implementation
 LL |     ((num % 4) + 4) % 4
    |     ^^^^^^^^^^^^^^^^^^^ help: consider using: `num.rem_euclid(4)`
 
-error: aborting due to 6 previous errors
+error: manual `rem_euclid` implementation
+  --> $DIR/manual_rem_euclid.rs:37:5
+   |
+LL |     ((num % 4) + 4) % 4
+   |     ^^^^^^^^^^^^^^^^^^^ help: consider using: `num.rem_euclid(4)`
+
+error: aborting due to 7 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 0447cc7affa8c4086c12eafea1b1eda3883f6677 Mon Sep 17 00:00:00 2001
From: Evan Typanski <evan.typanski@microfocus.com>
Date: Wed, 22 Jun 2022 15:26:08 -0400
Subject: Simplify with let else

---
 clippy_lints/src/manual_rem_euclid.rs | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_rem_euclid.rs b/clippy_lints/src/manual_rem_euclid.rs
index d22397ca35e..29d6027ac02 100644
--- a/clippy_lints/src/manual_rem_euclid.rs
+++ b/clippy_lints/src/manual_rem_euclid.rs
@@ -71,11 +71,8 @@ impl<'tcx> LateLintPass<'tcx> for ManualRemEuclid {
                 match cx.tcx.hir().find(cx.tcx.hir().get_parent_node(hir_id)) {
                     Some(Node::Param(..)) => (),
                     Some(Node::Local(local)) => {
-                        if let Some(ty) = local.ty {
-                            if matches!(ty.kind, TyKind::Infer) {
-                                return;
-                            }
-                        } else {
+                        let Some(ty) = local.ty else { return };
+                        if matches!(ty.kind, TyKind::Infer) {
                             return;
                         }
                     }
-- 
cgit 1.4.1-3-g733a5


From 87eded6500f1d1185ac7d0a951fe3aaac3d4dff4 Mon Sep 17 00:00:00 2001
From: "Samuel E. Moelius III" <sam@moeli.us>
Date: Tue, 21 Jun 2022 05:18:27 -0400
Subject: Fix `extra_unused_lifetimes` false positive

---
 clippy_lints/src/lifetimes.rs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lifetimes.rs b/clippy_lints/src/lifetimes.rs
index 93f5663312f..5c0bd57ac50 100644
--- a/clippy_lints/src/lifetimes.rs
+++ b/clippy_lints/src/lifetimes.rs
@@ -92,7 +92,9 @@ impl<'tcx> LateLintPass<'tcx> for Lifetimes {
         if let ItemKind::Fn(ref sig, generics, id) = item.kind {
             check_fn_inner(cx, sig.decl, Some(id), None, generics, item.span, true);
         } else if let ItemKind::Impl(impl_) = item.kind {
-            report_extra_impl_lifetimes(cx, impl_);
+            if !item.span.from_expansion() {
+                report_extra_impl_lifetimes(cx, impl_);
+            }
         }
     }
 
-- 
cgit 1.4.1-3-g733a5


From 1f707db0bf928454b699af1a2da745dfdbdeb680 Mon Sep 17 00:00:00 2001
From: Preston From <prestonfrom@gmail.com>
Date: Wed, 22 Jun 2022 22:34:49 -0600
Subject: Update messages for clarity when linting

---
 .../src/matches/significant_drop_in_scrutinee.rs   |   8 +-
 tests/ui/significant_drop_in_scrutinee.stderr      | 114 +++++++++++----------
 2 files changed, 64 insertions(+), 58 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/significant_drop_in_scrutinee.rs b/clippy_lints/src/matches/significant_drop_in_scrutinee.rs
index 59ca33cbcc7..98884ac7d73 100644
--- a/clippy_lints/src/matches/significant_drop_in_scrutinee.rs
+++ b/clippy_lints/src/matches/significant_drop_in_scrutinee.rs
@@ -27,10 +27,10 @@ pub(super) fn check<'tcx>(
                 diag.span_label(s, "original temporary lives until here");
                 if let Some(spans) = has_significant_drop_in_arms(cx, arms) {
                     for span in spans {
-                        diag.span_label(span, "significant drop in arm here");
+                        diag.span_label(span, "another temporary with significant `Drop` created here");
                     }
-                    diag.note("this might lead to deadlocks or other unexpected behavior");
                 }
+                diag.note("this might lead to deadlocks or other unexpected behavior");
             });
         }
     }
@@ -89,9 +89,9 @@ fn has_significant_drop_in_scrutinee<'tcx, 'a>(
     let mut helper = SigDropHelper::new(cx);
     helper.find_sig_drop(scrutinee).map(|drops| {
         let message = if source == MatchSource::Normal {
-            "temporary with drop impl with side effects in match scrutinee lives to end of block"
+            "temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression"
         } else {
-            "temporary with drop impl with side effects in for loop condition lives to end of block"
+            "temporary with significant `Drop` in `for` loop condition will live until the end of the `for` expression"
         };
         (drops, message)
     })
diff --git a/tests/ui/significant_drop_in_scrutinee.stderr b/tests/ui/significant_drop_in_scrutinee.stderr
index 472f998ebf2..f97b606c474 100644
--- a/tests/ui/significant_drop_in_scrutinee.stderr
+++ b/tests/ui/significant_drop_in_scrutinee.stderr
@@ -1,11 +1,11 @@
-error: temporary with drop impl with side effects in match scrutinee lives to end of block
+error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
   --> $DIR/significant_drop_in_scrutinee.rs:59:11
    |
 LL |     match mutex.lock().unwrap().foo() {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 LL |         true => {
 LL |             mutex.lock().unwrap().bar();
-   |             --------------------- significant drop in arm here
+   |             --------------------- another temporary with significant `Drop` created here
 ...
 LL |     };
    |      - original temporary lives until here
@@ -18,14 +18,14 @@ LL ~     let value = mutex.lock().unwrap().foo();
 LL ~     match value {
    |
 
-error: temporary with drop impl with side effects in match scrutinee lives to end of block
+error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
   --> $DIR/significant_drop_in_scrutinee.rs:132:11
    |
 LL |     match s.lock_m().get_the_value() {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^
 ...
 LL |             println!("{}", s.lock_m().get_the_value());
-   |                            ---------- significant drop in arm here
+   |                            ---------- another temporary with significant `Drop` created here
 ...
 LL |     }
    |      - original temporary lives until here
@@ -37,14 +37,14 @@ LL ~     let value = s.lock_m().get_the_value();
 LL ~     match value {
    |
 
-error: temporary with drop impl with side effects in match scrutinee lives to end of block
+error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
   --> $DIR/significant_drop_in_scrutinee.rs:153:11
    |
 LL |     match s.lock_m_m().get_the_value() {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 ...
 LL |             println!("{}", s.lock_m().get_the_value());
-   |                            ---------- significant drop in arm here
+   |                            ---------- another temporary with significant `Drop` created here
 ...
 LL |     }
    |      - original temporary lives until here
@@ -56,7 +56,7 @@ LL ~     let value = s.lock_m_m().get_the_value();
 LL ~     match value {
    |
 
-error: temporary with drop impl with side effects in match scrutinee lives to end of block
+error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
   --> $DIR/significant_drop_in_scrutinee.rs:201:11
    |
 LL |     match counter.temp_increment().len() {
@@ -65,20 +65,21 @@ LL |     match counter.temp_increment().len() {
 LL |     };
    |      - original temporary lives until here
    |
+   = note: this might lead to deadlocks or other unexpected behavior
 help: try moving the temporary above the match
    |
 LL ~     let value = counter.temp_increment().len();
 LL ~     match value {
    |
 
-error: temporary with drop impl with side effects in match scrutinee lives to end of block
+error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
   --> $DIR/significant_drop_in_scrutinee.rs:224:16
    |
 LL |         match (mutex1.lock().unwrap().s.len(), true) {
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 ...
 LL |                 mutex1.lock().unwrap().s.len();
-   |                 ---------------------- significant drop in arm here
+   |                 ---------------------- another temporary with significant `Drop` created here
 ...
 LL |         };
    |          - original temporary lives until here
@@ -90,14 +91,14 @@ LL ~         let value = mutex1.lock().unwrap().s.len();
 LL ~         match (value, true) {
    |
 
-error: temporary with drop impl with side effects in match scrutinee lives to end of block
+error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
   --> $DIR/significant_drop_in_scrutinee.rs:233:22
    |
 LL |         match (true, mutex1.lock().unwrap().s.len(), true) {
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 ...
 LL |                 mutex1.lock().unwrap().s.len();
-   |                 ---------------------- significant drop in arm here
+   |                 ---------------------- another temporary with significant `Drop` created here
 ...
 LL |         };
    |          - original temporary lives until here
@@ -109,16 +110,16 @@ LL ~         let value = mutex1.lock().unwrap().s.len();
 LL ~         match (true, value, true) {
    |
 
-error: temporary with drop impl with side effects in match scrutinee lives to end of block
+error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
   --> $DIR/significant_drop_in_scrutinee.rs:243:16
    |
 LL |         match (mutex1.lock().unwrap().s.len(), true, mutex2.lock().unwrap().s.len()) {
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 ...
 LL |                 mutex1.lock().unwrap().s.len();
-   |                 ---------------------- significant drop in arm here
+   |                 ---------------------- another temporary with significant `Drop` created here
 LL |                 mutex2.lock().unwrap().s.len();
-   |                 ---------------------- significant drop in arm here
+   |                 ---------------------- another temporary with significant `Drop` created here
 ...
 LL |         };
    |          - original temporary lives until here
@@ -130,16 +131,16 @@ LL ~         let value = mutex1.lock().unwrap().s.len();
 LL ~         match (value, true, mutex2.lock().unwrap().s.len()) {
    |
 
-error: temporary with drop impl with side effects in match scrutinee lives to end of block
+error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
   --> $DIR/significant_drop_in_scrutinee.rs:243:54
    |
 LL |         match (mutex1.lock().unwrap().s.len(), true, mutex2.lock().unwrap().s.len()) {
    |                                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 ...
 LL |                 mutex1.lock().unwrap().s.len();
-   |                 ---------------------- significant drop in arm here
+   |                 ---------------------- another temporary with significant `Drop` created here
 LL |                 mutex2.lock().unwrap().s.len();
-   |                 ---------------------- significant drop in arm here
+   |                 ---------------------- another temporary with significant `Drop` created here
 ...
 LL |         };
    |          - original temporary lives until here
@@ -151,46 +152,46 @@ LL ~         let value = mutex2.lock().unwrap().s.len();
 LL ~         match (mutex1.lock().unwrap().s.len(), true, value) {
    |
 
-error: temporary with drop impl with side effects in match scrutinee lives to end of block
+error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
   --> $DIR/significant_drop_in_scrutinee.rs:254:15
    |
 LL |         match mutex3.lock().unwrap().s.as_str() {
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 ...
 LL |                 mutex1.lock().unwrap().s.len();
-   |                 ---------------------- significant drop in arm here
+   |                 ---------------------- another temporary with significant `Drop` created here
 LL |                 mutex2.lock().unwrap().s.len();
-   |                 ---------------------- significant drop in arm here
+   |                 ---------------------- another temporary with significant `Drop` created here
 ...
 LL |         };
    |          - original temporary lives until here
    |
    = note: this might lead to deadlocks or other unexpected behavior
 
-error: temporary with drop impl with side effects in match scrutinee lives to end of block
+error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
   --> $DIR/significant_drop_in_scrutinee.rs:264:22
    |
 LL |         match (true, mutex3.lock().unwrap().s.as_str()) {
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 ...
 LL |                 mutex1.lock().unwrap().s.len();
-   |                 ---------------------- significant drop in arm here
+   |                 ---------------------- another temporary with significant `Drop` created here
 LL |                 mutex2.lock().unwrap().s.len();
-   |                 ---------------------- significant drop in arm here
+   |                 ---------------------- another temporary with significant `Drop` created here
 ...
 LL |         };
    |          - original temporary lives until here
    |
    = note: this might lead to deadlocks or other unexpected behavior
 
-error: temporary with drop impl with side effects in match scrutinee lives to end of block
+error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
   --> $DIR/significant_drop_in_scrutinee.rs:283:11
    |
 LL |     match mutex.lock().unwrap().s.len() > 1 {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 LL |         true => {
 LL |             mutex.lock().unwrap().s.len();
-   |             --------------------- significant drop in arm here
+   |             --------------------- another temporary with significant `Drop` created here
 ...
 LL |     };
    |      - original temporary lives until here
@@ -202,14 +203,14 @@ LL ~     let value = mutex.lock().unwrap().s.len() > 1;
 LL ~     match value {
    |
 
-error: temporary with drop impl with side effects in match scrutinee lives to end of block
+error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
   --> $DIR/significant_drop_in_scrutinee.rs:290:11
    |
 LL |     match 1 < mutex.lock().unwrap().s.len() {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 LL |         true => {
 LL |             mutex.lock().unwrap().s.len();
-   |             --------------------- significant drop in arm here
+   |             --------------------- another temporary with significant `Drop` created here
 ...
 LL |     };
    |      - original temporary lives until here
@@ -221,16 +222,16 @@ LL ~     let value = 1 < mutex.lock().unwrap().s.len();
 LL ~     match value {
    |
 
-error: temporary with drop impl with side effects in match scrutinee lives to end of block
+error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
   --> $DIR/significant_drop_in_scrutinee.rs:308:11
    |
 LL |     match mutex1.lock().unwrap().s.len() < mutex2.lock().unwrap().s.len() {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 ...
 LL |                 mutex1.lock().unwrap().s.len(),
-   |                 ---------------------- significant drop in arm here
+   |                 ---------------------- another temporary with significant `Drop` created here
 LL |                 mutex2.lock().unwrap().s.len()
-   |                 ---------------------- significant drop in arm here
+   |                 ---------------------- another temporary with significant `Drop` created here
 ...
 LL |     };
    |      - original temporary lives until here
@@ -242,16 +243,16 @@ LL ~     let value = mutex1.lock().unwrap().s.len() < mutex2.lock().unwrap().s.l
 LL ~     match value {
    |
 
-error: temporary with drop impl with side effects in match scrutinee lives to end of block
+error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
   --> $DIR/significant_drop_in_scrutinee.rs:319:11
    |
 LL |     match mutex1.lock().unwrap().s.len() >= mutex2.lock().unwrap().s.len() {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 ...
 LL |                 mutex1.lock().unwrap().s.len(),
-   |                 ---------------------- significant drop in arm here
+   |                 ---------------------- another temporary with significant `Drop` created here
 LL |                 mutex2.lock().unwrap().s.len()
-   |                 ---------------------- significant drop in arm here
+   |                 ---------------------- another temporary with significant `Drop` created here
 ...
 LL |     };
    |      - original temporary lives until here
@@ -263,14 +264,14 @@ LL ~     let value = mutex1.lock().unwrap().s.len() >= mutex2.lock().unwrap().s.
 LL ~     match value {
    |
 
-error: temporary with drop impl with side effects in match scrutinee lives to end of block
+error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
   --> $DIR/significant_drop_in_scrutinee.rs:354:11
    |
 LL |     match get_mutex_guard().s.len() > 1 {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 LL |         true => {
 LL |             mutex1.lock().unwrap().s.len();
-   |             ---------------------- significant drop in arm here
+   |             ---------------------- another temporary with significant `Drop` created here
 ...
 LL |     };
    |      - original temporary lives until here
@@ -282,7 +283,7 @@ LL ~     let value = get_mutex_guard().s.len() > 1;
 LL ~     match value {
    |
 
-error: temporary with drop impl with side effects in match scrutinee lives to end of block
+error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
   --> $DIR/significant_drop_in_scrutinee.rs:371:11
    |
 LL |       match match i {
@@ -296,7 +297,7 @@ LL | |         > 1
    | |___________^
 ...
 LL |               mutex1.lock().unwrap().s.len();
-   |               ---------------------- significant drop in arm here
+   |               ---------------------- another temporary with significant `Drop` created here
 ...
 LL |       };
    |        - original temporary lives until here
@@ -312,7 +313,7 @@ LL +     .s
 LL +     .len()
  ...
 
-error: temporary with drop impl with side effects in match scrutinee lives to end of block
+error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
   --> $DIR/significant_drop_in_scrutinee.rs:397:11
    |
 LL |       match if i > 1 {
@@ -326,7 +327,7 @@ LL | |         > 1
    | |___________^
 ...
 LL |               mutex1.lock().unwrap().s.len();
-   |               ---------------------- significant drop in arm here
+   |               ---------------------- another temporary with significant `Drop` created here
 ...
 LL |       };
    |        - original temporary lives until here
@@ -342,14 +343,14 @@ LL +     }
 LL +     .s
  ...
 
-error: temporary with drop impl with side effects in match scrutinee lives to end of block
+error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
   --> $DIR/significant_drop_in_scrutinee.rs:451:11
    |
 LL |     match s.lock().deref().deref() {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^
 LL |         0 | 1 => println!("Value was less than 2"),
 LL |         _ => println!("Value is {}", s.lock().deref()),
-   |                                      ---------------- significant drop in arm here
+   |                                      ---------------- another temporary with significant `Drop` created here
 LL |     };
    |      - original temporary lives until here
    |
@@ -360,27 +361,27 @@ LL ~     let value = *s.lock().deref().deref();
 LL ~     match value {
    |
 
-error: temporary with drop impl with side effects in match scrutinee lives to end of block
+error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
   --> $DIR/significant_drop_in_scrutinee.rs:479:11
    |
 LL |     match s.lock().deref().deref() {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^
 LL |         matcher => println!("Value is {}", s.lock().deref()),
-   |                                            ---------------- significant drop in arm here
+   |                                            ---------------- another temporary with significant `Drop` created here
 LL |         _ => println!("Value was not a match"),
 LL |     };
    |      - original temporary lives until here
    |
    = note: this might lead to deadlocks or other unexpected behavior
 
-error: temporary with drop impl with side effects in match scrutinee lives to end of block
+error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
   --> $DIR/significant_drop_in_scrutinee.rs:498:11
    |
 LL |     match mutex.lock().unwrap().i = i {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 LL |         _ => {
 LL |             println!("{}", mutex.lock().unwrap().i);
-   |                            --------------------- significant drop in arm here
+   |                            --------------------- another temporary with significant `Drop` created here
 LL |         },
 LL |     };
    |      - original temporary lives until here
@@ -392,14 +393,14 @@ LL ~     mutex.lock().unwrap().i = i;
 LL ~     match () {
    |
 
-error: temporary with drop impl with side effects in match scrutinee lives to end of block
+error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
   --> $DIR/significant_drop_in_scrutinee.rs:504:11
    |
 LL |     match i = mutex.lock().unwrap().i {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 LL |         _ => {
 LL |             println!("{}", mutex.lock().unwrap().i);
-   |                            --------------------- significant drop in arm here
+   |                            --------------------- another temporary with significant `Drop` created here
 LL |         },
 LL |     };
    |      - original temporary lives until here
@@ -411,14 +412,14 @@ LL ~     i = mutex.lock().unwrap().i;
 LL ~     match () {
    |
 
-error: temporary with drop impl with side effects in match scrutinee lives to end of block
+error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
   --> $DIR/significant_drop_in_scrutinee.rs:510:11
    |
 LL |     match mutex.lock().unwrap().i += 1 {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 LL |         _ => {
 LL |             println!("{}", mutex.lock().unwrap().i);
-   |                            --------------------- significant drop in arm here
+   |                            --------------------- another temporary with significant `Drop` created here
 LL |         },
 LL |     };
    |      - original temporary lives until here
@@ -430,14 +431,14 @@ LL ~     mutex.lock().unwrap().i += 1;
 LL ~     match () {
    |
 
-error: temporary with drop impl with side effects in match scrutinee lives to end of block
+error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
   --> $DIR/significant_drop_in_scrutinee.rs:516:11
    |
 LL |     match i += mutex.lock().unwrap().i {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 LL |         _ => {
 LL |             println!("{}", mutex.lock().unwrap().i);
-   |                            --------------------- significant drop in arm here
+   |                            --------------------- another temporary with significant `Drop` created here
 LL |         },
 LL |     };
    |      - original temporary lives until here
@@ -449,7 +450,7 @@ LL ~     i += mutex.lock().unwrap().i;
 LL ~     match () {
    |
 
-error: temporary with drop impl with side effects in match scrutinee lives to end of block
+error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
   --> $DIR/significant_drop_in_scrutinee.rs:579:11
    |
 LL |     match rwlock.read().unwrap().to_number() {
@@ -457,8 +458,10 @@ LL |     match rwlock.read().unwrap().to_number() {
 ...
 LL |     };
    |      - original temporary lives until here
+   |
+   = note: this might lead to deadlocks or other unexpected behavior
 
-error: temporary with drop impl with side effects in for loop condition lives to end of block
+error: temporary with significant `Drop` in `for` loop condition will live until the end of the `for` expression
   --> $DIR/significant_drop_in_scrutinee.rs:589:14
    |
 LL |     for s in rwlock.read().unwrap().iter() {
@@ -466,8 +469,10 @@ LL |     for s in rwlock.read().unwrap().iter() {
 LL |         println!("{}", s);
 LL |     }
    |      - original temporary lives until here
+   |
+   = note: this might lead to deadlocks or other unexpected behavior
 
-error: temporary with drop impl with side effects in match scrutinee lives to end of block
+error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
   --> $DIR/significant_drop_in_scrutinee.rs:604:11
    |
 LL |     match mutex.lock().unwrap().foo() {
@@ -476,6 +481,7 @@ LL |     match mutex.lock().unwrap().foo() {
 LL |     };
    |      - original temporary lives until here
    |
+   = note: this might lead to deadlocks or other unexpected behavior
 help: try moving the temporary above the match
    |
 LL ~     let value = mutex.lock().unwrap().foo();
-- 
cgit 1.4.1-3-g733a5


From 92704b494a5c284cd426d8f386c60cd1ef2c48fd Mon Sep 17 00:00:00 2001
From: Evan Typanski <evan.typanski@microfocus.com>
Date: Thu, 23 Jun 2022 10:35:14 -0400
Subject: Split constant check functions and simplify

---
 clippy_lints/src/manual_rem_euclid.rs | 52 ++++++++++++++---------------------
 1 file changed, 21 insertions(+), 31 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_rem_euclid.rs b/clippy_lints/src/manual_rem_euclid.rs
index 29d6027ac02..492bd4db434 100644
--- a/clippy_lints/src/manual_rem_euclid.rs
+++ b/clippy_lints/src/manual_rem_euclid.rs
@@ -55,15 +55,16 @@ impl<'tcx> LateLintPass<'tcx> for ManualRemEuclid {
             return;
         }
 
-        if let ExprKind::Binary(op1, ..) = expr.kind
+        if let ExprKind::Binary(op1, expr1, right) = expr.kind
             && op1.node == BinOpKind::Rem
-            && let Some((const1, expr1)) = check_for_positive_int_constant(cx, expr, false)
-            && let ExprKind::Binary(op2, ..) = expr1.kind
+            && let Some(const1) = check_for_unsigned_int_constant(cx, right)
+            && let ExprKind::Binary(op2, left, right) = expr1.kind
             && op2.node == BinOpKind::Add
-            && let Some((const2, expr2)) = check_for_positive_int_constant(cx, expr1, true)
-            && let ExprKind::Binary(op3, ..) = expr2.kind
+            && let Some((const2, expr2)) = check_for_either_unsigned_int_constant(cx, left, right)
+            && let ExprKind::Binary(op3, expr3, right) = expr2.kind
             && op3.node == BinOpKind::Rem
-            && let Some((const3, expr3)) = check_for_positive_int_constant(cx, expr2, false)
+            && let Some(const3) = check_for_unsigned_int_constant(cx, right)
+            // Also ensures the const is nonzero since zero can't be a divisor
             && const1 == const2 && const2 == const3
             && let Some(hir_id) = path_to_local(expr3)
             && let Some(Node::Binding(_)) = cx.tcx.hir().find(hir_id) {
@@ -96,33 +97,22 @@ impl<'tcx> LateLintPass<'tcx> for ManualRemEuclid {
     extract_msrv_attr!(LateContext);
 }
 
-// Takes a binary expression and separates the operands into the int constant and the other
-// operand. Ensures the int constant is positive. Operators that are not commutative must have the
-// constant appear on the right hand side to return a value.
-fn check_for_positive_int_constant<'a>(
+// Checks if either the left or right expressions can be an unsigned int constant and returns that
+// constant along with the other expression unchanged if so
+fn check_for_either_unsigned_int_constant<'a>(
     cx: &'a LateContext<'_>,
-    expr: &'a Expr<'_>,
-    is_commutative: bool,
+    left: &'a Expr<'_>,
+    right: &'a Expr<'_>,
 ) -> Option<(u128, &'a Expr<'a>)> {
-    let (int_const, other_op) = if let ExprKind::Binary(_, left, right) = expr.kind {
-        if let Some(int_const) = constant_full_int(cx, cx.typeck_results(), right) {
-            (int_const, left)
-        } else if is_commutative && let Some(int_const) = constant_full_int(cx, cx.typeck_results(), left) {
-            (int_const, right)
-        } else {
-            return None;
-        }
-    } else {
-        return None;
-    };
+    check_for_unsigned_int_constant(cx, left)
+        .map(|int_const| (int_const, right))
+        .or_else(|| check_for_unsigned_int_constant(cx, right).map(|int_const| (int_const, left)))
+}
 
-    if int_const > FullInt::S(0) {
-        let val = match int_const {
-            FullInt::S(s) => s.try_into().ok()?,
-            FullInt::U(u) => u,
-        };
-        Some((val, other_op))
-    } else {
-        None
+fn check_for_unsigned_int_constant<'a>(cx: &'a LateContext<'_>, expr: &'a Expr<'_>) -> Option<u128> {
+    let Some(int_const) = constant_full_int(cx, cx.typeck_results(), expr) else { return None };
+    match int_const {
+        FullInt::S(s) => s.try_into().ok(),
+        FullInt::U(u) => Some(u),
     }
 }
-- 
cgit 1.4.1-3-g733a5


From df26c3f551fec5854e3acd140782b8f8c98e987b Mon Sep 17 00:00:00 2001
From: Evan Typanski <evan.typanski@microfocus.com>
Date: Thu, 23 Jun 2022 16:34:52 -0400
Subject: Add external macro guard and test middle MSRV

---
 clippy_lints/src/manual_rem_euclid.rs |  7 ++++++-
 tests/ui/auxiliary/macro_rules.rs     |  8 ++++++++
 tests/ui/manual_rem_euclid.fixed      | 17 +++++++++++++++++
 tests/ui/manual_rem_euclid.rs         | 17 +++++++++++++++++
 tests/ui/manual_rem_euclid.stderr     | 27 +++++++++++++++++++--------
 tests/ui/min_rust_version_attr.rs     |  9 +++++++++
 6 files changed, 76 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_rem_euclid.rs b/clippy_lints/src/manual_rem_euclid.rs
index 492bd4db434..b5698965fc3 100644
--- a/clippy_lints/src/manual_rem_euclid.rs
+++ b/clippy_lints/src/manual_rem_euclid.rs
@@ -4,7 +4,8 @@ use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::{in_constant, meets_msrv, msrvs, path_to_local};
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind, Node, TyKind};
-use rustc_lint::{LateContext, LateLintPass};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_middle::lint::in_external_macro;
 use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 
@@ -55,6 +56,10 @@ impl<'tcx> LateLintPass<'tcx> for ManualRemEuclid {
             return;
         }
 
+        if in_external_macro(cx.sess(), expr.span) {
+            return;
+        }
+
         if let ExprKind::Binary(op1, expr1, right) = expr.kind
             && op1.node == BinOpKind::Rem
             && let Some(const1) = check_for_unsigned_int_constant(cx, right)
diff --git a/tests/ui/auxiliary/macro_rules.rs b/tests/ui/auxiliary/macro_rules.rs
index 9f283337c7e..5bd2c2799f0 100644
--- a/tests/ui/auxiliary/macro_rules.rs
+++ b/tests/ui/auxiliary/macro_rules.rs
@@ -127,3 +127,11 @@ macro_rules! ptr_as_ptr_cast {
         $ptr as *const i32
     };
 }
+
+#[macro_export]
+macro_rules! manual_rem_euclid {
+    () => {
+        let value: i32 = 5;
+        let _: i32 = ((value % 4) + 4) % 4;
+    };
+}
diff --git a/tests/ui/manual_rem_euclid.fixed b/tests/ui/manual_rem_euclid.fixed
index a3e593eac06..5601c96c10b 100644
--- a/tests/ui/manual_rem_euclid.fixed
+++ b/tests/ui/manual_rem_euclid.fixed
@@ -1,7 +1,18 @@
 // run-rustfix
+// aux-build:macro_rules.rs
 
 #![warn(clippy::manual_rem_euclid)]
 
+#[macro_use]
+extern crate macro_rules;
+
+macro_rules! internal_rem_euclid {
+    () => {
+        let value: i32 = 5;
+        let _: i32 = value.rem_euclid(4);
+    };
+}
+
 fn main() {
     let value: i32 = 5;
 
@@ -25,6 +36,12 @@ fn main() {
     // For lint to apply the constant must always be on the RHS of the previous value for %
     let _: i32 = 4 % ((value % 4) + 4);
     let _: i32 = ((4 % value) + 4) % 4;
+
+    // Lint in internal macros
+    internal_rem_euclid!();
+
+    // Do not lint in external macros
+    manual_rem_euclid!();
 }
 
 // Should lint for params too
diff --git a/tests/ui/manual_rem_euclid.rs b/tests/ui/manual_rem_euclid.rs
index 2d8c6411f20..52135be26b7 100644
--- a/tests/ui/manual_rem_euclid.rs
+++ b/tests/ui/manual_rem_euclid.rs
@@ -1,7 +1,18 @@
 // run-rustfix
+// aux-build:macro_rules.rs
 
 #![warn(clippy::manual_rem_euclid)]
 
+#[macro_use]
+extern crate macro_rules;
+
+macro_rules! internal_rem_euclid {
+    () => {
+        let value: i32 = 5;
+        let _: i32 = ((value % 4) + 4) % 4;
+    };
+}
+
 fn main() {
     let value: i32 = 5;
 
@@ -25,6 +36,12 @@ fn main() {
     // For lint to apply the constant must always be on the RHS of the previous value for %
     let _: i32 = 4 % ((value % 4) + 4);
     let _: i32 = ((4 % value) + 4) % 4;
+
+    // Lint in internal macros
+    internal_rem_euclid!();
+
+    // Do not lint in external macros
+    manual_rem_euclid!();
 }
 
 // Should lint for params too
diff --git a/tests/ui/manual_rem_euclid.stderr b/tests/ui/manual_rem_euclid.stderr
index 3faeb6c6a88..a237fd0213c 100644
--- a/tests/ui/manual_rem_euclid.stderr
+++ b/tests/ui/manual_rem_euclid.stderr
@@ -1,5 +1,5 @@
 error: manual `rem_euclid` implementation
-  --> $DIR/manual_rem_euclid.rs:8:18
+  --> $DIR/manual_rem_euclid.rs:19:18
    |
 LL |     let _: i32 = ((value % 4) + 4) % 4;
    |                  ^^^^^^^^^^^^^^^^^^^^^ help: consider using: `value.rem_euclid(4)`
@@ -7,40 +7,51 @@ LL |     let _: i32 = ((value % 4) + 4) % 4;
    = note: `-D clippy::manual-rem-euclid` implied by `-D warnings`
 
 error: manual `rem_euclid` implementation
-  --> $DIR/manual_rem_euclid.rs:9:18
+  --> $DIR/manual_rem_euclid.rs:20:18
    |
 LL |     let _: i32 = (4 + (value % 4)) % 4;
    |                  ^^^^^^^^^^^^^^^^^^^^^ help: consider using: `value.rem_euclid(4)`
 
 error: manual `rem_euclid` implementation
-  --> $DIR/manual_rem_euclid.rs:10:18
+  --> $DIR/manual_rem_euclid.rs:21:18
    |
 LL |     let _: i32 = (value % 4 + 4) % 4;
    |                  ^^^^^^^^^^^^^^^^^^^ help: consider using: `value.rem_euclid(4)`
 
 error: manual `rem_euclid` implementation
-  --> $DIR/manual_rem_euclid.rs:11:18
+  --> $DIR/manual_rem_euclid.rs:22:18
    |
 LL |     let _: i32 = (4 + value % 4) % 4;
    |                  ^^^^^^^^^^^^^^^^^^^ help: consider using: `value.rem_euclid(4)`
 
 error: manual `rem_euclid` implementation
-  --> $DIR/manual_rem_euclid.rs:12:22
+  --> $DIR/manual_rem_euclid.rs:23:22
    |
 LL |     let _: i32 = 1 + (4 + value % 4) % 4;
    |                      ^^^^^^^^^^^^^^^^^^^ help: consider using: `value.rem_euclid(4)`
 
 error: manual `rem_euclid` implementation
-  --> $DIR/manual_rem_euclid.rs:32:5
+  --> $DIR/manual_rem_euclid.rs:12:22
+   |
+LL |         let _: i32 = ((value % 4) + 4) % 4;
+   |                      ^^^^^^^^^^^^^^^^^^^^^ help: consider using: `value.rem_euclid(4)`
+...
+LL |     internal_rem_euclid!();
+   |     ---------------------- in this macro invocation
+   |
+   = note: this error originates in the macro `internal_rem_euclid` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: manual `rem_euclid` implementation
+  --> $DIR/manual_rem_euclid.rs:49:5
    |
 LL |     ((num % 4) + 4) % 4
    |     ^^^^^^^^^^^^^^^^^^^ help: consider using: `num.rem_euclid(4)`
 
 error: manual `rem_euclid` implementation
-  --> $DIR/manual_rem_euclid.rs:37:5
+  --> $DIR/manual_rem_euclid.rs:54:5
    |
 LL |     ((num % 4) + 4) % 4
    |     ^^^^^^^^^^^^^^^^^^^ help: consider using: `num.rem_euclid(4)`
 
-error: aborting due to 7 previous errors
+error: aborting due to 8 previous errors
 
diff --git a/tests/ui/min_rust_version_attr.rs b/tests/ui/min_rust_version_attr.rs
index 301a8e54ccf..44e407bd1ab 100644
--- a/tests/ui/min_rust_version_attr.rs
+++ b/tests/ui/min_rust_version_attr.rs
@@ -217,3 +217,12 @@ mod just_above_msrv {
         }
     }
 }
+
+mod const_rem_euclid {
+    #![feature(custom_inner_attributes)]
+    #![clippy::msrv = "1.50.0"]
+
+    pub const fn const_rem_euclid_4(num: i32) -> i32 {
+        ((num % 4) + 4) % 4
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From aec465cabdeb9a126446ccf791a9cf5ae045c185 Mon Sep 17 00:00:00 2001
From: Serial <69764315+Serial-ATA@users.noreply.github.com>
Date: Fri, 24 Jun 2022 14:11:24 -0400
Subject: Add test for [`default_deprecation_reason`]

---
 clippy_lints/src/deprecated_lints.rs               |  5 ++--
 clippy_lints/src/lib.rs                            |  2 +-
 clippy_lints/src/utils/internal_lints.rs           |  3 +--
 tests/compile-test.rs                              |  3 +++
 tests/ui-internal/default_deprecation_reason.rs    | 30 ++++++++++++++++++++++
 .../ui-internal/default_deprecation_reason.stderr  | 22 ++++++++++++++++
 6 files changed, 59 insertions(+), 6 deletions(-)
 create mode 100644 tests/ui-internal/default_deprecation_reason.rs
 create mode 100644 tests/ui-internal/default_deprecation_reason.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/deprecated_lints.rs b/clippy_lints/src/deprecated_lints.rs
index d7a4b6f5c88..9aa5af3190f 100644
--- a/clippy_lints/src/deprecated_lints.rs
+++ b/clippy_lints/src/deprecated_lints.rs
@@ -4,17 +4,16 @@
 /// enables the simple extraction of the metadata without changing the current deprecation
 /// declaration.
 pub struct ClippyDeprecatedLint {
-    #[cfg(feature = "internal")]
     #[allow(dead_code)]
-    desc: &'static str,
+    pub desc: &'static str,
 }
 
+#[macro_export]
 macro_rules! declare_deprecated_lint {
     { $(#[$attr:meta])* pub $name: ident, $reason: literal} => {
         $(#[$attr])*
         #[allow(dead_code)]
         pub static $name: ClippyDeprecatedLint = ClippyDeprecatedLint {
-            #[cfg(feature = "internal")]
             desc: $reason
         };
     }
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index dcee11cc28c..8eb75a0a548 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -159,7 +159,7 @@ macro_rules! declare_clippy_lint {
 }
 
 #[cfg(feature = "internal")]
-mod deprecated_lints;
+pub mod deprecated_lints;
 #[cfg_attr(feature = "internal", allow(clippy::missing_clippy_version_attribute))]
 mod utils;
 
diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs
index c5380662566..b8e704b983b 100644
--- a/clippy_lints/src/utils/internal_lints.rs
+++ b/clippy_lints/src/utils/internal_lints.rs
@@ -348,7 +348,6 @@ declare_clippy_lint! {
     /// Indicates that the documentation is incomplete.
     ///
     /// ### Example
-    /// Bad:
     /// ```rust,ignore
     /// declare_deprecated_lint! {
     ///     /// ### What it does
@@ -362,7 +361,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     ///
-    /// Good:
+    /// Use instead:
     /// ```rust,ignore
     /// declare_deprecated_lint! {
     ///     /// ### What it does
diff --git a/tests/compile-test.rs b/tests/compile-test.rs
index 7d219835723..a303d90d953 100644
--- a/tests/compile-test.rs
+++ b/tests/compile-test.rs
@@ -24,6 +24,7 @@ const RUN_INTERNAL_TESTS: bool = cfg!(feature = "internal");
 /// All crates used in UI tests are listed here
 static TEST_DEPENDENCIES: &[&str] = &[
     "clap",
+    "clippy_lints",
     "clippy_utils",
     "derive_new",
     "futures",
@@ -44,6 +45,8 @@ static TEST_DEPENDENCIES: &[&str] = &[
 #[allow(unused_extern_crates)]
 extern crate clap;
 #[allow(unused_extern_crates)]
+extern crate clippy_lints;
+#[allow(unused_extern_crates)]
 extern crate clippy_utils;
 #[allow(unused_extern_crates)]
 extern crate derive_new;
diff --git a/tests/ui-internal/default_deprecation_reason.rs b/tests/ui-internal/default_deprecation_reason.rs
new file mode 100644
index 00000000000..c8961d5e1f0
--- /dev/null
+++ b/tests/ui-internal/default_deprecation_reason.rs
@@ -0,0 +1,30 @@
+#![deny(clippy::internal)]
+#![feature(rustc_private)]
+
+#[macro_use]
+extern crate clippy_lints;
+use clippy_lints::deprecated_lints::ClippyDeprecatedLint;
+
+declare_deprecated_lint! {
+    /// ### What it does
+    /// Nothing. This lint has been deprecated.
+    ///
+    /// ### Deprecation reason
+    /// TODO
+    #[clippy::version = "1.63.0"]
+    pub COOL_LINT_DEFAULT,
+    "default deprecation note"
+}
+
+declare_deprecated_lint! {
+    /// ### What it does
+    /// Nothing. This lint has been deprecated.
+    ///
+    /// ### Deprecation reason
+    /// This lint has been replaced by `cooler_lint`
+    #[clippy::version = "1.63.0"]
+    pub COOL_LINT,
+    "this lint has been replaced by `cooler_lint`"
+}
+
+fn main() {}
diff --git a/tests/ui-internal/default_deprecation_reason.stderr b/tests/ui-internal/default_deprecation_reason.stderr
new file mode 100644
index 00000000000..ca26b649f98
--- /dev/null
+++ b/tests/ui-internal/default_deprecation_reason.stderr
@@ -0,0 +1,22 @@
+error: the lint `COOL_LINT_DEFAULT` has the default deprecation reason
+  --> $DIR/default_deprecation_reason.rs:8:1
+   |
+LL | / declare_deprecated_lint! {
+LL | |     /// ### What it does
+LL | |     /// Nothing. This lint has been deprecated.
+LL | |     ///
+...  |
+LL | |     "default deprecation note"
+LL | | }
+   | |_^
+   |
+note: the lint level is defined here
+  --> $DIR/default_deprecation_reason.rs:1:9
+   |
+LL | #![deny(clippy::internal)]
+   |         ^^^^^^^^^^^^^^^^
+   = note: `#[deny(clippy::default_deprecation_reason)]` implied by `#[deny(clippy::internal)]`
+   = note: this error originates in the macro `declare_deprecated_lint` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: aborting due to previous error
+
-- 
cgit 1.4.1-3-g733a5


From 7cdaabc9b7898fec15ee197ea32977c0ab4fd476 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Fri, 3 Jun 2022 22:12:26 -0400
Subject: Suggest `pointer::cast` when possible in `transmute_ptr_to_ref`
 Defensively add a cast to any type with lifetimes.

---
 clippy_lints/src/lib.rs                            |   2 +-
 clippy_lints/src/transmute/mod.rs                  |  25 +++--
 clippy_lints/src/transmute/transmute_ptr_to_ref.rs |  56 ++++++++---
 clippy_lints/src/transmute/utils.rs                |  28 +-----
 tests/ui/transmute_ptr_to_ref.fixed                |  78 ++++++++++++++++
 tests/ui/transmute_ptr_to_ref.rs                   |  39 +++++++-
 tests/ui/transmute_ptr_to_ref.stderr               | 102 ++++++++++++++++++---
 7 files changed, 265 insertions(+), 65 deletions(-)
 create mode 100644 tests/ui/transmute_ptr_to_ref.fixed

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 70cf6be8b7c..172c08a8168 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -641,7 +641,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(borrow_deref_ref::BorrowDerefRef));
     store.register_late_pass(|| Box::new(no_effect::NoEffect));
     store.register_late_pass(|| Box::new(temporary_assignment::TemporaryAssignment));
-    store.register_late_pass(|| Box::new(transmute::Transmute));
+    store.register_late_pass(move || Box::new(transmute::Transmute::new(msrv)));
     let cognitive_complexity_threshold = conf.cognitive_complexity_threshold;
     store.register_late_pass(move || {
         Box::new(cognitive_complexity::CognitiveComplexity::new(
diff --git a/clippy_lints/src/transmute/mod.rs b/clippy_lints/src/transmute/mod.rs
index cbe1406728b..5f3e98144f4 100644
--- a/clippy_lints/src/transmute/mod.rs
+++ b/clippy_lints/src/transmute/mod.rs
@@ -16,9 +16,10 @@ mod wrong_transmute;
 
 use clippy_utils::in_constant;
 use if_chain::if_chain;
-use rustc_hir::{Expr, ExprKind};
+use rustc_hir::{Expr, ExprKind, QPath};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_semver::RustcVersion;
+use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::symbol::sym;
 
 declare_clippy_lint! {
@@ -385,7 +386,10 @@ declare_clippy_lint! {
     "transmute to or from a type with an undefined representation"
 }
 
-declare_lint_pass!(Transmute => [
+pub struct Transmute {
+    msrv: Option<RustcVersion>,
+}
+impl_lint_pass!(Transmute => [
     CROSSPOINTER_TRANSMUTE,
     TRANSMUTE_PTR_TO_REF,
     TRANSMUTE_PTR_TO_PTR,
@@ -401,13 +405,18 @@ declare_lint_pass!(Transmute => [
     TRANSMUTES_EXPRESSIBLE_AS_PTR_CASTS,
     TRANSMUTE_UNDEFINED_REPR,
 ]);
-
+impl Transmute {
+    #[must_use]
+    pub fn new(msrv: Option<RustcVersion>) -> Self {
+        Self { msrv }
+    }
+}
 impl<'tcx> LateLintPass<'tcx> for Transmute {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
         if_chain! {
             if let ExprKind::Call(path_expr, [arg]) = e.kind;
-            if let ExprKind::Path(ref qpath) = path_expr.kind;
-            if let Some(def_id) = cx.qpath_res(qpath, path_expr.hir_id).opt_def_id();
+            if let ExprKind::Path(QPath::Resolved(None, path)) = path_expr.kind;
+            if let Some(def_id) = path.res.opt_def_id();
             if cx.tcx.is_diagnostic_item(sym::transmute, def_id);
             then {
                 // Avoid suggesting non-const operations in const contexts:
@@ -427,7 +436,7 @@ impl<'tcx> LateLintPass<'tcx> for Transmute {
 
                 let linted = wrong_transmute::check(cx, e, from_ty, to_ty)
                     | crosspointer_transmute::check(cx, e, from_ty, to_ty)
-                    | transmute_ptr_to_ref::check(cx, e, from_ty, to_ty, arg, qpath)
+                    | transmute_ptr_to_ref::check(cx, e, from_ty, to_ty, arg, path, self.msrv)
                     | transmute_int_to_char::check(cx, e, from_ty, to_ty, arg, const_context)
                     | transmute_ref_to_ref::check(cx, e, from_ty, to_ty, arg, const_context)
                     | transmute_ptr_to_ptr::check(cx, e, from_ty, to_ty, arg)
@@ -446,4 +455,6 @@ impl<'tcx> LateLintPass<'tcx> for Transmute {
             }
         }
     }
+
+    extract_msrv_attr!(LateContext);
 }
diff --git a/clippy_lints/src/transmute/transmute_ptr_to_ref.rs b/clippy_lints/src/transmute/transmute_ptr_to_ref.rs
index f3653199b37..3ed5d5c6950 100644
--- a/clippy_lints/src/transmute/transmute_ptr_to_ref.rs
+++ b/clippy_lints/src/transmute/transmute_ptr_to_ref.rs
@@ -1,11 +1,12 @@
-use super::utils::get_type_snippet;
 use super::TRANSMUTE_PTR_TO_REF;
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::sugg;
+use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::{meets_msrv, msrvs, sugg};
 use rustc_errors::Applicability;
-use rustc_hir::{Expr, Mutability, QPath};
+use rustc_hir::{self as hir, Expr, GenericArg, Mutability, Path, TyKind};
 use rustc_lint::LateContext;
-use rustc_middle::ty::{self, Ty};
+use rustc_middle::ty::{self, Ty, TypeFoldable};
+use rustc_semver::RustcVersion;
 
 /// Checks for `transmute_ptr_to_ref` lint.
 /// Returns `true` if it's triggered, otherwise returns `false`.
@@ -15,7 +16,8 @@ pub(super) fn check<'tcx>(
     from_ty: Ty<'tcx>,
     to_ty: Ty<'tcx>,
     arg: &'tcx Expr<'_>,
-    qpath: &'tcx QPath<'_>,
+    path: &'tcx Path<'_>,
+    msrv: Option<RustcVersion>,
 ) -> bool {
     match (&from_ty.kind(), &to_ty.kind()) {
         (ty::RawPtr(from_ptr_ty), ty::Ref(_, to_ref_ty, mutbl)) => {
@@ -34,19 +36,34 @@ pub(super) fn check<'tcx>(
                     } else {
                         ("&*", "*const")
                     };
+                    let mut app = Applicability::MachineApplicable;
 
-                    let arg = if from_ptr_ty.ty == *to_ref_ty {
-                        arg
+                    let sugg = if let Some(ty) = get_explicit_type(path) {
+                        let ty_snip = snippet_with_applicability(cx, ty.span, "..", &mut app);
+                        if meets_msrv(msrv, msrvs::POINTER_CAST) {
+                            format!("{}{}.cast::<{}>()", deref, arg.maybe_par(), ty_snip)
+                        } else if from_ptr_ty.has_erased_regions() {
+                            sugg::make_unop(deref, arg.as_ty(format!("{} () as {} {}", cast, cast, ty_snip)))
+                                .to_string()
+                        } else {
+                            sugg::make_unop(deref, arg.as_ty(format!("{} {}", cast, ty_snip))).to_string()
+                        }
+                    } else if from_ptr_ty.ty == *to_ref_ty {
+                        if from_ptr_ty.has_erased_regions() {
+                            if meets_msrv(msrv, msrvs::POINTER_CAST) {
+                                format!("{}{}.cast::<{}>()", deref, arg.maybe_par(), to_ref_ty)
+                            } else {
+                                sugg::make_unop(deref, arg.as_ty(format!("{} () as {} {}", cast, cast, to_ref_ty)))
+                                    .to_string()
+                            }
+                        } else {
+                            sugg::make_unop(deref, arg).to_string()
+                        }
                     } else {
-                        arg.as_ty(&format!("{} {}", cast, get_type_snippet(cx, qpath, *to_ref_ty)))
+                        sugg::make_unop(deref, arg.as_ty(format!("{} {}", cast, to_ref_ty))).to_string()
                     };
 
-                    diag.span_suggestion(
-                        e.span,
-                        "try",
-                        sugg::make_unop(deref, arg).to_string(),
-                        Applicability::Unspecified,
-                    );
+                    diag.span_suggestion(e.span, "try", sugg, app);
                 },
             );
             true
@@ -54,3 +71,14 @@ pub(super) fn check<'tcx>(
         _ => false,
     }
 }
+
+/// Gets the type `Bar` in `…::transmute<Foo, &Bar>`.
+fn get_explicit_type<'tcx>(path: &'tcx Path<'tcx>) -> Option<&'tcx hir::Ty<'tcx>> {
+    if let GenericArg::Type(ty) = path.segments.last()?.args?.args.get(1)?
+        && let TyKind::Rptr(_, ty) = &ty.kind
+    {
+        Some(ty.ty)
+    } else {
+        None
+    }
+}
diff --git a/clippy_lints/src/transmute/utils.rs b/clippy_lints/src/transmute/utils.rs
index 0cbf5ccefa6..74927570b40 100644
--- a/clippy_lints/src/transmute/utils.rs
+++ b/clippy_lints/src/transmute/utils.rs
@@ -1,35 +1,9 @@
-use clippy_utils::last_path_segment;
-use clippy_utils::source::snippet;
-use if_chain::if_chain;
-use rustc_hir::{Expr, GenericArg, QPath, TyKind};
+use rustc_hir::Expr;
 use rustc_lint::LateContext;
 use rustc_middle::ty::{cast::CastKind, Ty};
 use rustc_span::DUMMY_SP;
 use rustc_typeck::check::{cast::CastCheck, FnCtxt, Inherited};
 
-/// Gets the snippet of `Bar` in `…::transmute<Foo, &Bar>`. If that snippet is
-/// not available , use
-/// the type's `ToString` implementation. In weird cases it could lead to types
-/// with invalid `'_`
-/// lifetime, but it should be rare.
-pub(super) fn get_type_snippet(cx: &LateContext<'_>, path: &QPath<'_>, to_ref_ty: Ty<'_>) -> String {
-    let seg = last_path_segment(path);
-    if_chain! {
-        if let Some(params) = seg.args;
-        if !params.parenthesized;
-        if let Some(to_ty) = params.args.iter().filter_map(|arg| match arg {
-            GenericArg::Type(ty) => Some(ty),
-            _ => None,
-        }).nth(1);
-        if let TyKind::Rptr(_, ref to_ty) = to_ty.kind;
-        then {
-            return snippet(cx, to_ty.ty.span, &to_ref_ty.to_string()).to_string();
-        }
-    }
-
-    to_ref_ty.to_string()
-}
-
 // check if the component types of the transmuted collection and the result have different ABI,
 // size or alignment
 pub(super) fn is_layout_incompatible<'tcx>(cx: &LateContext<'tcx>, from: Ty<'tcx>, to: Ty<'tcx>) -> bool {
diff --git a/tests/ui/transmute_ptr_to_ref.fixed b/tests/ui/transmute_ptr_to_ref.fixed
new file mode 100644
index 00000000000..e5fe9133f97
--- /dev/null
+++ b/tests/ui/transmute_ptr_to_ref.fixed
@@ -0,0 +1,78 @@
+// run-rustfix
+
+#![feature(custom_inner_attributes)]
+#![warn(clippy::transmute_ptr_to_ref)]
+#![allow(clippy::match_single_binding)]
+
+unsafe fn _ptr_to_ref<T, U>(p: *const T, m: *mut T, o: *const U, om: *mut U) {
+    let _: &T = &*p;
+    let _: &T = &*p;
+
+    let _: &mut T = &mut *m;
+    let _: &mut T = &mut *m;
+
+    let _: &T = &*m;
+    let _: &T = &*m;
+
+    let _: &mut T = &mut *(p as *mut T);
+    let _ = &mut *(p as *mut T);
+
+    let _: &T = &*(o as *const T);
+    let _: &T = &*(o as *const T);
+
+    let _: &mut T = &mut *(om as *mut T);
+    let _: &mut T = &mut *(om as *mut T);
+
+    let _: &T = &*(om as *const T);
+    let _: &T = &*(om as *const T);
+}
+
+fn _issue1231() {
+    struct Foo<'a, T> {
+        bar: &'a T,
+    }
+
+    let raw = 42 as *const i32;
+    let _: &Foo<u8> = unsafe { &*raw.cast::<Foo<_>>() };
+
+    let _: &Foo<&u8> = unsafe { &*raw.cast::<Foo<&_>>() };
+
+    type Bar<'a> = &'a u8;
+    let raw = 42 as *const i32;
+    unsafe { &*(raw as *const u8) };
+}
+
+unsafe fn _issue8924<'a, 'b, 'c>(x: *const &'a u32, y: *const &'b u32) -> &'c &'b u32 {
+    match 0 {
+        0 => &*x.cast::<&u32>(),
+        1 => &*y.cast::<&u32>(),
+        2 => &*x.cast::<&'b u32>(),
+        _ => &*y.cast::<&'b u32>(),
+    }
+}
+
+unsafe fn _meets_msrv<'a, 'b, 'c>(x: *const &'a u32) -> &'c &'b u32 {
+    #![clippy::msrv = "1.38"]
+    let a = 0u32;
+    let a = &a as *const u32;
+    let _: &u32 = &*a;
+    let _: &u32 = &*a.cast::<u32>();
+    match 0 {
+        0 => &*x.cast::<&u32>(),
+        _ => &*x.cast::<&'b u32>(),
+    }
+}
+
+unsafe fn _under_msrv<'a, 'b, 'c>(x: *const &'a u32) -> &'c &'b u32 {
+    #![clippy::msrv = "1.37"]
+    let a = 0u32;
+    let a = &a as *const u32;
+    let _: &u32 = &*a;
+    let _: &u32 = &*(a as *const u32);
+    match 0 {
+        0 => &*(x as *const () as *const &u32),
+        _ => &*(x as *const () as *const &'b u32),
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/transmute_ptr_to_ref.rs b/tests/ui/transmute_ptr_to_ref.rs
index ba35c6adc4d..fe49cdc324f 100644
--- a/tests/ui/transmute_ptr_to_ref.rs
+++ b/tests/ui/transmute_ptr_to_ref.rs
@@ -1,4 +1,8 @@
+// run-rustfix
+
+#![feature(custom_inner_attributes)]
 #![warn(clippy::transmute_ptr_to_ref)]
+#![allow(clippy::match_single_binding)]
 
 unsafe fn _ptr_to_ref<T, U>(p: *const T, m: *mut T, o: *const U, om: *mut U) {
     let _: &T = std::mem::transmute(p);
@@ -23,7 +27,7 @@ unsafe fn _ptr_to_ref<T, U>(p: *const T, m: *mut T, o: *const U, om: *mut U) {
     let _: &T = &*(om as *const T);
 }
 
-fn issue1231() {
+fn _issue1231() {
     struct Foo<'a, T> {
         bar: &'a T,
     }
@@ -38,4 +42,37 @@ fn issue1231() {
     unsafe { std::mem::transmute::<_, Bar>(raw) };
 }
 
+unsafe fn _issue8924<'a, 'b, 'c>(x: *const &'a u32, y: *const &'b u32) -> &'c &'b u32 {
+    match 0 {
+        0 => std::mem::transmute(x),
+        1 => std::mem::transmute(y),
+        2 => std::mem::transmute::<_, &&'b u32>(x),
+        _ => std::mem::transmute::<_, &&'b u32>(y),
+    }
+}
+
+unsafe fn _meets_msrv<'a, 'b, 'c>(x: *const &'a u32) -> &'c &'b u32 {
+    #![clippy::msrv = "1.38"]
+    let a = 0u32;
+    let a = &a as *const u32;
+    let _: &u32 = std::mem::transmute(a);
+    let _: &u32 = std::mem::transmute::<_, &u32>(a);
+    match 0 {
+        0 => std::mem::transmute(x),
+        _ => std::mem::transmute::<_, &&'b u32>(x),
+    }
+}
+
+unsafe fn _under_msrv<'a, 'b, 'c>(x: *const &'a u32) -> &'c &'b u32 {
+    #![clippy::msrv = "1.37"]
+    let a = 0u32;
+    let a = &a as *const u32;
+    let _: &u32 = std::mem::transmute(a);
+    let _: &u32 = std::mem::transmute::<_, &u32>(a);
+    match 0 {
+        0 => std::mem::transmute(x),
+        _ => std::mem::transmute::<_, &&'b u32>(x),
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/transmute_ptr_to_ref.stderr b/tests/ui/transmute_ptr_to_ref.stderr
index df0598a58cd..2993e5e7b0c 100644
--- a/tests/ui/transmute_ptr_to_ref.stderr
+++ b/tests/ui/transmute_ptr_to_ref.stderr
@@ -1,5 +1,5 @@
 error: transmute from a pointer type (`*const T`) to a reference type (`&T`)
-  --> $DIR/transmute_ptr_to_ref.rs:4:17
+  --> $DIR/transmute_ptr_to_ref.rs:8:17
    |
 LL |     let _: &T = std::mem::transmute(p);
    |                 ^^^^^^^^^^^^^^^^^^^^^^ help: try: `&*p`
@@ -7,58 +7,130 @@ LL |     let _: &T = std::mem::transmute(p);
    = note: `-D clippy::transmute-ptr-to-ref` implied by `-D warnings`
 
 error: transmute from a pointer type (`*mut T`) to a reference type (`&mut T`)
-  --> $DIR/transmute_ptr_to_ref.rs:7:21
+  --> $DIR/transmute_ptr_to_ref.rs:11:21
    |
 LL |     let _: &mut T = std::mem::transmute(m);
    |                     ^^^^^^^^^^^^^^^^^^^^^^ help: try: `&mut *m`
 
 error: transmute from a pointer type (`*mut T`) to a reference type (`&T`)
-  --> $DIR/transmute_ptr_to_ref.rs:10:17
+  --> $DIR/transmute_ptr_to_ref.rs:14:17
    |
 LL |     let _: &T = std::mem::transmute(m);
    |                 ^^^^^^^^^^^^^^^^^^^^^^ help: try: `&*m`
 
 error: transmute from a pointer type (`*mut T`) to a reference type (`&mut T`)
-  --> $DIR/transmute_ptr_to_ref.rs:13:21
+  --> $DIR/transmute_ptr_to_ref.rs:17:21
    |
 LL |     let _: &mut T = std::mem::transmute(p as *mut T);
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&mut *(p as *mut T)`
 
 error: transmute from a pointer type (`*const U`) to a reference type (`&T`)
-  --> $DIR/transmute_ptr_to_ref.rs:16:17
+  --> $DIR/transmute_ptr_to_ref.rs:20:17
    |
 LL |     let _: &T = std::mem::transmute(o);
    |                 ^^^^^^^^^^^^^^^^^^^^^^ help: try: `&*(o as *const T)`
 
 error: transmute from a pointer type (`*mut U`) to a reference type (`&mut T`)
-  --> $DIR/transmute_ptr_to_ref.rs:19:21
+  --> $DIR/transmute_ptr_to_ref.rs:23:21
    |
 LL |     let _: &mut T = std::mem::transmute(om);
    |                     ^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&mut *(om as *mut T)`
 
 error: transmute from a pointer type (`*mut U`) to a reference type (`&T`)
-  --> $DIR/transmute_ptr_to_ref.rs:22:17
+  --> $DIR/transmute_ptr_to_ref.rs:26:17
    |
 LL |     let _: &T = std::mem::transmute(om);
    |                 ^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&*(om as *const T)`
 
-error: transmute from a pointer type (`*const i32`) to a reference type (`&issue1231::Foo<u8>`)
-  --> $DIR/transmute_ptr_to_ref.rs:32:32
+error: transmute from a pointer type (`*const i32`) to a reference type (`&_issue1231::Foo<u8>`)
+  --> $DIR/transmute_ptr_to_ref.rs:36:32
    |
 LL |     let _: &Foo<u8> = unsafe { std::mem::transmute::<_, &Foo<_>>(raw) };
-   |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&*(raw as *const Foo<_>)`
+   |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&*raw.cast::<Foo<_>>()`
 
-error: transmute from a pointer type (`*const i32`) to a reference type (`&issue1231::Foo<&u8>`)
-  --> $DIR/transmute_ptr_to_ref.rs:34:33
+error: transmute from a pointer type (`*const i32`) to a reference type (`&_issue1231::Foo<&u8>`)
+  --> $DIR/transmute_ptr_to_ref.rs:38:33
    |
 LL |     let _: &Foo<&u8> = unsafe { std::mem::transmute::<_, &Foo<&_>>(raw) };
-   |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&*(raw as *const Foo<&_>)`
+   |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&*raw.cast::<Foo<&_>>()`
 
 error: transmute from a pointer type (`*const i32`) to a reference type (`&u8`)
-  --> $DIR/transmute_ptr_to_ref.rs:38:14
+  --> $DIR/transmute_ptr_to_ref.rs:42:14
    |
 LL |     unsafe { std::mem::transmute::<_, Bar>(raw) };
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&*(raw as *const u8)`
 
-error: aborting due to 10 previous errors
+error: transmute from a pointer type (`*const &u32`) to a reference type (`&&u32`)
+  --> $DIR/transmute_ptr_to_ref.rs:47:14
+   |
+LL |         0 => std::mem::transmute(x),
+   |              ^^^^^^^^^^^^^^^^^^^^^^ help: try: `&*x.cast::<&u32>()`
+
+error: transmute from a pointer type (`*const &u32`) to a reference type (`&&u32`)
+  --> $DIR/transmute_ptr_to_ref.rs:48:14
+   |
+LL |         1 => std::mem::transmute(y),
+   |              ^^^^^^^^^^^^^^^^^^^^^^ help: try: `&*y.cast::<&u32>()`
+
+error: transmute from a pointer type (`*const &u32`) to a reference type (`&&u32`)
+  --> $DIR/transmute_ptr_to_ref.rs:49:14
+   |
+LL |         2 => std::mem::transmute::<_, &&'b u32>(x),
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&*x.cast::<&'b u32>()`
+
+error: transmute from a pointer type (`*const &u32`) to a reference type (`&&u32`)
+  --> $DIR/transmute_ptr_to_ref.rs:50:14
+   |
+LL |         _ => std::mem::transmute::<_, &&'b u32>(y),
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&*y.cast::<&'b u32>()`
+
+error: transmute from a pointer type (`*const u32`) to a reference type (`&u32`)
+  --> $DIR/transmute_ptr_to_ref.rs:58:19
+   |
+LL |     let _: &u32 = std::mem::transmute(a);
+   |                   ^^^^^^^^^^^^^^^^^^^^^^ help: try: `&*a`
+
+error: transmute from a pointer type (`*const u32`) to a reference type (`&u32`)
+  --> $DIR/transmute_ptr_to_ref.rs:59:19
+   |
+LL |     let _: &u32 = std::mem::transmute::<_, &u32>(a);
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&*a.cast::<u32>()`
+
+error: transmute from a pointer type (`*const &u32`) to a reference type (`&&u32`)
+  --> $DIR/transmute_ptr_to_ref.rs:61:14
+   |
+LL |         0 => std::mem::transmute(x),
+   |              ^^^^^^^^^^^^^^^^^^^^^^ help: try: `&*x.cast::<&u32>()`
+
+error: transmute from a pointer type (`*const &u32`) to a reference type (`&&u32`)
+  --> $DIR/transmute_ptr_to_ref.rs:62:14
+   |
+LL |         _ => std::mem::transmute::<_, &&'b u32>(x),
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&*x.cast::<&'b u32>()`
+
+error: transmute from a pointer type (`*const u32`) to a reference type (`&u32`)
+  --> $DIR/transmute_ptr_to_ref.rs:70:19
+   |
+LL |     let _: &u32 = std::mem::transmute(a);
+   |                   ^^^^^^^^^^^^^^^^^^^^^^ help: try: `&*a`
+
+error: transmute from a pointer type (`*const u32`) to a reference type (`&u32`)
+  --> $DIR/transmute_ptr_to_ref.rs:71:19
+   |
+LL |     let _: &u32 = std::mem::transmute::<_, &u32>(a);
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&*(a as *const u32)`
+
+error: transmute from a pointer type (`*const &u32`) to a reference type (`&&u32`)
+  --> $DIR/transmute_ptr_to_ref.rs:73:14
+   |
+LL |         0 => std::mem::transmute(x),
+   |              ^^^^^^^^^^^^^^^^^^^^^^ help: try: `&*(x as *const () as *const &u32)`
+
+error: transmute from a pointer type (`*const &u32`) to a reference type (`&&u32`)
+  --> $DIR/transmute_ptr_to_ref.rs:74:14
+   |
+LL |         _ => std::mem::transmute::<_, &&'b u32>(x),
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&*(x as *const () as *const &'b u32)`
+
+error: aborting due to 22 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From e7c55a478fd78cae940b0b43fbdbd4b4c7c6567b Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Sat, 25 Jun 2022 14:16:28 +0200
Subject: Fix `#[expect]` for `clippy::ptr_arg`

---
 clippy_lints/src/ptr.rs | 41 +++++++++++++++++++++++------------------
 tests/ui/ptr_arg.rs     |  6 ++++++
 tests/ui/ptr_arg.stderr | 40 +++++++++++++++++++++++-----------------
 3 files changed, 52 insertions(+), 35 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs
index b06eba13d2f..8f729feb090 100644
--- a/clippy_lints/src/ptr.rs
+++ b/clippy_lints/src/ptr.rs
@@ -1,6 +1,6 @@
 //! Checks for usage of  `&Vec[_]` and `&String`.
 
-use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg, span_lint_and_then};
+use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg, span_lint_and_then, span_lint_hir_and_then};
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::expr_sig;
 use clippy_utils::visitors::contains_unsafe_block;
@@ -166,15 +166,14 @@ impl<'tcx> LateLintPass<'tcx> for Ptr {
             )
             .filter(|arg| arg.mutability() == Mutability::Not)
             {
-                span_lint_and_sugg(
-                    cx,
-                    PTR_ARG,
-                    arg.span,
-                    &arg.build_msg(),
-                    "change this to",
-                    format!("{}{}", arg.ref_prefix, arg.deref_ty.display(cx)),
-                    Applicability::Unspecified,
-                );
+                span_lint_hir_and_then(cx, PTR_ARG, arg.emission_id, arg.span, &arg.build_msg(), |diag| {
+                    diag.span_suggestion(
+                        arg.span,
+                        "change this to",
+                        format!("{}{}", arg.ref_prefix, arg.deref_ty.display(cx)),
+                        Applicability::Unspecified,
+                    );
+                });
             }
         }
     }
@@ -221,7 +220,7 @@ impl<'tcx> LateLintPass<'tcx> for Ptr {
         let results = check_ptr_arg_usage(cx, body, &lint_args);
 
         for (result, args) in results.iter().zip(lint_args.iter()).filter(|(r, _)| !r.skip) {
-            span_lint_and_then(cx, PTR_ARG, args.span, &args.build_msg(), |diag| {
+            span_lint_hir_and_then(cx, PTR_ARG, args.emission_id, args.span, &args.build_msg(), |diag| {
                 diag.multipart_suggestion(
                     "change this to",
                     iter::once((args.span, format!("{}{}", args.ref_prefix, args.deref_ty.display(cx))))
@@ -315,6 +314,7 @@ struct PtrArgReplacement {
 
 struct PtrArg<'tcx> {
     idx: usize,
+    emission_id: hir::HirId,
     span: Span,
     ty_did: DefId,
     ty_name: Symbol,
@@ -419,10 +419,8 @@ fn check_fn_args<'cx, 'tcx: 'cx>(
                 if let [.., name] = path.segments;
                 if cx.tcx.item_name(adt.did()) == name.ident.name;
 
-                if !is_lint_allowed(cx, PTR_ARG, hir_ty.hir_id);
-                if params.get(i).map_or(true, |p| !is_lint_allowed(cx, PTR_ARG, p.hir_id));
-
                 then {
+                    let emission_id = params.get(i).map_or(hir_ty.hir_id, |param| param.hir_id);
                     let (method_renames, deref_ty) = match cx.tcx.get_diagnostic_name(adt.did()) {
                         Some(sym::Vec) => (
                             [("clone", ".to_owned()")].as_slice(),
@@ -455,14 +453,20 @@ fn check_fn_args<'cx, 'tcx: 'cx>(
                                 })
                                 .and_then(|arg| snippet_opt(cx, arg.span))
                                 .unwrap_or_else(|| substs.type_at(1).to_string());
-                            span_lint_and_sugg(
+                            span_lint_hir_and_then(
                                 cx,
                                 PTR_ARG,
+                                emission_id,
                                 hir_ty.span,
                                 "using a reference to `Cow` is not recommended",
-                                "change this to",
-                                format!("&{}{}", mutability.prefix_str(), ty_name),
-                                Applicability::Unspecified,
+                                |diag| {
+                                    diag.span_suggestion(
+                                        hir_ty.span,
+                                        "change this to",
+                                        format!("&{}{}", mutability.prefix_str(), ty_name),
+                                        Applicability::Unspecified,
+                                    );
+                                }
                             );
                             return None;
                         },
@@ -470,6 +474,7 @@ fn check_fn_args<'cx, 'tcx: 'cx>(
                     };
                     return Some(PtrArg {
                         idx: i,
+                        emission_id: emission_id,
                         span: hir_ty.span,
                         ty_did: adt.did(),
                         ty_name: name.ident.name,
diff --git a/tests/ui/ptr_arg.rs b/tests/ui/ptr_arg.rs
index 814bbc7af71..fd15001e540 100644
--- a/tests/ui/ptr_arg.rs
+++ b/tests/ui/ptr_arg.rs
@@ -1,3 +1,4 @@
+#![feature(lint_reasons)]
 #![allow(unused, clippy::many_single_char_names, clippy::redundant_clone)]
 #![warn(clippy::ptr_arg)]
 
@@ -109,9 +110,12 @@ mod issue_5644 {
         #[allow(clippy::ptr_arg)] _s: &String,
         #[allow(clippy::ptr_arg)] _p: &PathBuf,
         #[allow(clippy::ptr_arg)] _c: &Cow<[i32]>,
+        #[expect(clippy::ptr_arg)] _expect: &Cow<[i32]>,
     ) {
     }
 
+    fn some_allowed(#[allow(clippy::ptr_arg)] _v: &Vec<u32>, _s: &String) {}
+
     struct S;
     impl S {
         fn allowed(
@@ -119,6 +123,7 @@ mod issue_5644 {
             #[allow(clippy::ptr_arg)] _s: &String,
             #[allow(clippy::ptr_arg)] _p: &PathBuf,
             #[allow(clippy::ptr_arg)] _c: &Cow<[i32]>,
+            #[expect(clippy::ptr_arg)] _expect: &Cow<[i32]>,
         ) {
         }
     }
@@ -129,6 +134,7 @@ mod issue_5644 {
             #[allow(clippy::ptr_arg)] _s: &String,
             #[allow(clippy::ptr_arg)] _p: &PathBuf,
             #[allow(clippy::ptr_arg)] _c: &Cow<[i32]>,
+            #[expect(clippy::ptr_arg)] _expect: &Cow<[i32]>,
         ) {
         }
     }
diff --git a/tests/ui/ptr_arg.stderr b/tests/ui/ptr_arg.stderr
index a9613daadde..bbf731c6d01 100644
--- a/tests/ui/ptr_arg.stderr
+++ b/tests/ui/ptr_arg.stderr
@@ -1,5 +1,5 @@
 error: writing `&Vec` instead of `&[_]` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:7:14
+  --> $DIR/ptr_arg.rs:8:14
    |
 LL | fn do_vec(x: &Vec<i64>) {
    |              ^^^^^^^^^ help: change this to: `&[i64]`
@@ -7,43 +7,43 @@ LL | fn do_vec(x: &Vec<i64>) {
    = note: `-D clippy::ptr-arg` implied by `-D warnings`
 
 error: writing `&mut Vec` instead of `&mut [_]` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:11:18
+  --> $DIR/ptr_arg.rs:12:18
    |
 LL | fn do_vec_mut(x: &mut Vec<i64>) {
    |                  ^^^^^^^^^^^^^ help: change this to: `&mut [i64]`
 
 error: writing `&String` instead of `&str` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:15:14
+  --> $DIR/ptr_arg.rs:16:14
    |
 LL | fn do_str(x: &String) {
    |              ^^^^^^^ help: change this to: `&str`
 
 error: writing `&mut String` instead of `&mut str` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:19:18
+  --> $DIR/ptr_arg.rs:20:18
    |
 LL | fn do_str_mut(x: &mut String) {
    |                  ^^^^^^^^^^^ help: change this to: `&mut str`
 
 error: writing `&PathBuf` instead of `&Path` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:23:15
+  --> $DIR/ptr_arg.rs:24:15
    |
 LL | fn do_path(x: &PathBuf) {
    |               ^^^^^^^^ help: change this to: `&Path`
 
 error: writing `&mut PathBuf` instead of `&mut Path` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:27:19
+  --> $DIR/ptr_arg.rs:28:19
    |
 LL | fn do_path_mut(x: &mut PathBuf) {
    |                   ^^^^^^^^^^^^ help: change this to: `&mut Path`
 
 error: writing `&Vec` instead of `&[_]` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:35:18
+  --> $DIR/ptr_arg.rs:36:18
    |
 LL |     fn do_vec(x: &Vec<i64>);
    |                  ^^^^^^^^^ help: change this to: `&[i64]`
 
 error: writing `&Vec` instead of `&[_]` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:48:14
+  --> $DIR/ptr_arg.rs:49:14
    |
 LL | fn cloned(x: &Vec<u8>) -> Vec<u8> {
    |              ^^^^^^^^
@@ -59,7 +59,7 @@ LL |     let i = (e).clone();
  ...
 
 error: writing `&String` instead of `&str` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:57:18
+  --> $DIR/ptr_arg.rs:58:18
    |
 LL | fn str_cloned(x: &String) -> String {
    |                  ^^^^^^^
@@ -75,7 +75,7 @@ LL ~     x.to_owned()
    |
 
 error: writing `&PathBuf` instead of `&Path` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:65:19
+  --> $DIR/ptr_arg.rs:66:19
    |
 LL | fn path_cloned(x: &PathBuf) -> PathBuf {
    |                   ^^^^^^^^
@@ -91,7 +91,7 @@ LL ~     x.to_path_buf()
    |
 
 error: writing `&String` instead of `&str` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:73:44
+  --> $DIR/ptr_arg.rs:74:44
    |
 LL | fn false_positive_capacity(x: &Vec<u8>, y: &String) {
    |                                            ^^^^^^^
@@ -105,13 +105,19 @@ LL ~     let c = y;
    |
 
 error: using a reference to `Cow` is not recommended
-  --> $DIR/ptr_arg.rs:87:25
+  --> $DIR/ptr_arg.rs:88:25
    |
 LL | fn test_cow_with_ref(c: &Cow<[i32]>) {}
    |                         ^^^^^^^^^^^ help: change this to: `&[i32]`
 
+error: writing `&String` instead of `&str` involves a new object where a slice will do
+  --> $DIR/ptr_arg.rs:117:66
+   |
+LL |     fn some_allowed(#[allow(clippy::ptr_arg)] _v: &Vec<u32>, _s: &String) {}
+   |                                                                  ^^^^^^^ help: change this to: `&str`
+
 error: writing `&Vec` instead of `&[_]` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:140:21
+  --> $DIR/ptr_arg.rs:146:21
    |
 LL |     fn foo_vec(vec: &Vec<u8>) {
    |                     ^^^^^^^^
@@ -124,7 +130,7 @@ LL ~         let _ = vec.to_owned().clone();
    |
 
 error: writing `&PathBuf` instead of `&Path` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:145:23
+  --> $DIR/ptr_arg.rs:151:23
    |
 LL |     fn foo_path(path: &PathBuf) {
    |                       ^^^^^^^^
@@ -137,7 +143,7 @@ LL ~         let _ = path.to_path_buf().clone();
    |
 
 error: writing `&PathBuf` instead of `&Path` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:150:21
+  --> $DIR/ptr_arg.rs:156:21
    |
 LL |     fn foo_str(str: &PathBuf) {
    |                     ^^^^^^^^
@@ -150,10 +156,10 @@ LL ~         let _ = str.to_path_buf().clone();
    |
 
 error: writing `&mut Vec` instead of `&mut [_]` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:156:29
+  --> $DIR/ptr_arg.rs:162:29
    |
 LL | fn mut_vec_slice_methods(v: &mut Vec<u32>) {
    |                             ^^^^^^^^^^^^^ help: change this to: `&mut [u32]`
 
-error: aborting due to 16 previous errors
+error: aborting due to 17 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From a3c7101f61ae4f608b040c2c896b39570bfed38c Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Sat, 25 Jun 2022 14:16:30 +0200
Subject: Fix `#[expect]` for `clippy::logic_bug`

---
 clippy_lints/src/booleans.rs |  5 +++--
 tests/ui/logic_bug.rs        |  8 ++++++++
 tests/ui/logic_bug.stderr    | 20 ++++++++++----------
 3 files changed, 21 insertions(+), 12 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/booleans.rs b/clippy_lints/src/booleans.rs
index e4e122ba6eb..96a2d158514 100644
--- a/clippy_lints/src/booleans.rs
+++ b/clippy_lints/src/booleans.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
+use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then, span_lint_hir_and_then};
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::{implements_trait, is_type_diagnostic_item};
 use clippy_utils::{eq_expr_value, get_trait_def_id, paths};
@@ -394,9 +394,10 @@ impl<'a, 'tcx> NonminimalBoolVisitor<'a, 'tcx> {
                         continue 'simplified;
                     }
                     if stats.terminals[i] != 0 && simplified_stats.terminals[i] == 0 {
-                        span_lint_and_then(
+                        span_lint_hir_and_then(
                             self.cx,
                             LOGIC_BUG,
+                            e.hir_id,
                             e.span,
                             "this boolean expression contains a logic bug",
                             |diag| {
diff --git a/tests/ui/logic_bug.rs b/tests/ui/logic_bug.rs
index 4eaa2dd98eb..dd6b1db5f70 100644
--- a/tests/ui/logic_bug.rs
+++ b/tests/ui/logic_bug.rs
@@ -1,3 +1,4 @@
+#![feature(lint_reasons)]
 #![allow(unused, clippy::diverging_sub_expression)]
 #![warn(clippy::logic_bug)]
 
@@ -24,3 +25,10 @@ fn equality_stuff() {
     let _ = a > b && a <= b;
     let _ = a > b && a == b;
 }
+
+fn check_expect() {
+    let a: i32 = unimplemented!();
+    let b: i32 = unimplemented!();
+    #[expect(clippy::logic_bug)]
+    let _ = a < b && a >= b;
+}
diff --git a/tests/ui/logic_bug.stderr b/tests/ui/logic_bug.stderr
index 8f55e1c8ad8..4021fbf4570 100644
--- a/tests/ui/logic_bug.stderr
+++ b/tests/ui/logic_bug.stderr
@@ -1,60 +1,60 @@
 error: this boolean expression contains a logic bug
-  --> $DIR/logic_bug.rs:10:13
+  --> $DIR/logic_bug.rs:11:13
    |
 LL |     let _ = a && b || a;
    |             ^^^^^^^^^^^ help: it would look like the following: `a`
    |
    = note: `-D clippy::logic-bug` implied by `-D warnings`
 help: this expression can be optimized out by applying boolean operations to the outer expression
-  --> $DIR/logic_bug.rs:10:18
+  --> $DIR/logic_bug.rs:11:18
    |
 LL |     let _ = a && b || a;
    |                  ^
 
 error: this boolean expression contains a logic bug
-  --> $DIR/logic_bug.rs:12:13
+  --> $DIR/logic_bug.rs:13:13
    |
 LL |     let _ = false && a;
    |             ^^^^^^^^^^ help: it would look like the following: `false`
    |
 help: this expression can be optimized out by applying boolean operations to the outer expression
-  --> $DIR/logic_bug.rs:12:22
+  --> $DIR/logic_bug.rs:13:22
    |
 LL |     let _ = false && a;
    |                      ^
 
 error: this boolean expression contains a logic bug
-  --> $DIR/logic_bug.rs:22:13
+  --> $DIR/logic_bug.rs:23:13
    |
 LL |     let _ = a == b && a != b;
    |             ^^^^^^^^^^^^^^^^ help: it would look like the following: `false`
    |
 help: this expression can be optimized out by applying boolean operations to the outer expression
-  --> $DIR/logic_bug.rs:22:13
+  --> $DIR/logic_bug.rs:23:13
    |
 LL |     let _ = a == b && a != b;
    |             ^^^^^^
 
 error: this boolean expression contains a logic bug
-  --> $DIR/logic_bug.rs:23:13
+  --> $DIR/logic_bug.rs:24:13
    |
 LL |     let _ = a < b && a >= b;
    |             ^^^^^^^^^^^^^^^ help: it would look like the following: `false`
    |
 help: this expression can be optimized out by applying boolean operations to the outer expression
-  --> $DIR/logic_bug.rs:23:13
+  --> $DIR/logic_bug.rs:24:13
    |
 LL |     let _ = a < b && a >= b;
    |             ^^^^^
 
 error: this boolean expression contains a logic bug
-  --> $DIR/logic_bug.rs:24:13
+  --> $DIR/logic_bug.rs:25:13
    |
 LL |     let _ = a > b && a <= b;
    |             ^^^^^^^^^^^^^^^ help: it would look like the following: `false`
    |
 help: this expression can be optimized out by applying boolean operations to the outer expression
-  --> $DIR/logic_bug.rs:24:13
+  --> $DIR/logic_bug.rs:25:13
    |
 LL |     let _ = a > b && a <= b;
    |             ^^^^^
-- 
cgit 1.4.1-3-g733a5


From b6ee6bba4ce84cd20937ba4e9f64b5d8ba1ecae3 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Sat, 25 Jun 2022 14:16:30 +0200
Subject: Fix `#[expect]` for `clippy::nonminimal_bool`

---
 clippy_lints/src/booleans.rs    |  5 +++--
 tests/ui/nonminimal_bool.rs     |  7 +++++++
 tests/ui/nonminimal_bool.stderr | 24 ++++++++++++------------
 3 files changed, 22 insertions(+), 14 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/booleans.rs b/clippy_lints/src/booleans.rs
index 96a2d158514..526ee2f891a 100644
--- a/clippy_lints/src/booleans.rs
+++ b/clippy_lints/src/booleans.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then, span_lint_hir_and_then};
+use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_hir_and_then};
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::{implements_trait, is_type_diagnostic_item};
 use clippy_utils::{eq_expr_value, get_trait_def_id, paths};
@@ -430,9 +430,10 @@ impl<'a, 'tcx> NonminimalBoolVisitor<'a, 'tcx> {
                 }
             }
             let nonminimal_bool_lint = |suggestions: Vec<_>| {
-                span_lint_and_then(
+                span_lint_hir_and_then(
                     self.cx,
                     NONMINIMAL_BOOL,
+                    e.hir_id,
                     e.span,
                     "this boolean expression can be simplified",
                     |diag| {
diff --git a/tests/ui/nonminimal_bool.rs b/tests/ui/nonminimal_bool.rs
index fa5743c1155..24ae62bb058 100644
--- a/tests/ui/nonminimal_bool.rs
+++ b/tests/ui/nonminimal_bool.rs
@@ -1,3 +1,4 @@
+#![feature(lint_reasons)]
 #![allow(unused, clippy::diverging_sub_expression)]
 #![warn(clippy::nonminimal_bool)]
 
@@ -50,3 +51,9 @@ fn issue4548() {
 
     if i != j && f(i, j) != 0 || i == j && f(i, j) != 1 {}
 }
+
+fn check_expect() {
+    let a: bool = unimplemented!();
+    #[expect(clippy::nonminimal_bool)]
+    let _ = !!a;
+}
diff --git a/tests/ui/nonminimal_bool.stderr b/tests/ui/nonminimal_bool.stderr
index bb93cbbd5e1..fc6a5ce1dc2 100644
--- a/tests/ui/nonminimal_bool.stderr
+++ b/tests/ui/nonminimal_bool.stderr
@@ -1,5 +1,5 @@
 error: this boolean expression can be simplified
-  --> $DIR/nonminimal_bool.rs:10:13
+  --> $DIR/nonminimal_bool.rs:11:13
    |
 LL |     let _ = !true;
    |             ^^^^^ help: try: `false`
@@ -7,43 +7,43 @@ LL |     let _ = !true;
    = note: `-D clippy::nonminimal-bool` implied by `-D warnings`
 
 error: this boolean expression can be simplified
-  --> $DIR/nonminimal_bool.rs:11:13
+  --> $DIR/nonminimal_bool.rs:12:13
    |
 LL |     let _ = !false;
    |             ^^^^^^ help: try: `true`
 
 error: this boolean expression can be simplified
-  --> $DIR/nonminimal_bool.rs:12:13
+  --> $DIR/nonminimal_bool.rs:13:13
    |
 LL |     let _ = !!a;
    |             ^^^ help: try: `a`
 
 error: this boolean expression can be simplified
-  --> $DIR/nonminimal_bool.rs:13:13
+  --> $DIR/nonminimal_bool.rs:14:13
    |
 LL |     let _ = false || a;
    |             ^^^^^^^^^^ help: try: `a`
 
 error: this boolean expression can be simplified
-  --> $DIR/nonminimal_bool.rs:17:13
+  --> $DIR/nonminimal_bool.rs:18:13
    |
 LL |     let _ = !(!a && b);
    |             ^^^^^^^^^^ help: try: `a || !b`
 
 error: this boolean expression can be simplified
-  --> $DIR/nonminimal_bool.rs:18:13
+  --> $DIR/nonminimal_bool.rs:19:13
    |
 LL |     let _ = !(!a || b);
    |             ^^^^^^^^^^ help: try: `a && !b`
 
 error: this boolean expression can be simplified
-  --> $DIR/nonminimal_bool.rs:19:13
+  --> $DIR/nonminimal_bool.rs:20:13
    |
 LL |     let _ = !a && !(b && c);
    |             ^^^^^^^^^^^^^^^ help: try: `!(a || b && c)`
 
 error: this boolean expression can be simplified
-  --> $DIR/nonminimal_bool.rs:27:13
+  --> $DIR/nonminimal_bool.rs:28:13
    |
 LL |     let _ = a == b && c == 5 && a == b;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -56,7 +56,7 @@ LL |     let _ = a == b && c == 5;
    |             ~~~~~~~~~~~~~~~~
 
 error: this boolean expression can be simplified
-  --> $DIR/nonminimal_bool.rs:28:13
+  --> $DIR/nonminimal_bool.rs:29:13
    |
 LL |     let _ = a == b || c == 5 || a == b;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -69,7 +69,7 @@ LL |     let _ = a == b || c == 5;
    |             ~~~~~~~~~~~~~~~~
 
 error: this boolean expression can be simplified
-  --> $DIR/nonminimal_bool.rs:29:13
+  --> $DIR/nonminimal_bool.rs:30:13
    |
 LL |     let _ = a == b && c == 5 && b == a;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -82,7 +82,7 @@ LL |     let _ = a == b && c == 5;
    |             ~~~~~~~~~~~~~~~~
 
 error: this boolean expression can be simplified
-  --> $DIR/nonminimal_bool.rs:30:13
+  --> $DIR/nonminimal_bool.rs:31:13
    |
 LL |     let _ = a != b || !(a != b || c == d);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -95,7 +95,7 @@ LL |     let _ = a != b || c != d;
    |             ~~~~~~~~~~~~~~~~
 
 error: this boolean expression can be simplified
-  --> $DIR/nonminimal_bool.rs:31:13
+  --> $DIR/nonminimal_bool.rs:32:13
    |
 LL |     let _ = a != b && !(a != b && c == d);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From b2976980b59106971cbf29c4a9ba318c3804caeb Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Sat, 25 Jun 2022 14:16:30 +0200
Subject: Fix `#[expect]` for `clippy::boxed_local`

---
 clippy_lints/src/escape.rs      |   5 +-
 tests/ui/boxed_local.rs         | 210 ++++++++++++++++++++++++++++++++++++++++
 tests/ui/boxed_local.stderr     |  28 ++++++
 tests/ui/escape_analysis.rs     | 204 --------------------------------------
 tests/ui/escape_analysis.stderr |  28 ------
 5 files changed, 241 insertions(+), 234 deletions(-)
 create mode 100644 tests/ui/boxed_local.rs
 create mode 100644 tests/ui/boxed_local.stderr
 delete mode 100644 tests/ui/escape_analysis.rs
 delete mode 100644 tests/ui/escape_analysis.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/escape.rs b/clippy_lints/src/escape.rs
index 9d21dd71e0e..7a65b849a66 100644
--- a/clippy_lints/src/escape.rs
+++ b/clippy_lints/src/escape.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint;
+use clippy_utils::diagnostics::span_lint_hir;
 use clippy_utils::ty::contains_ty;
 use rustc_hir::intravisit;
 use rustc_hir::{self, AssocItemKind, Body, FnDecl, HirId, HirIdSet, Impl, ItemKind, Node};
@@ -118,9 +118,10 @@ impl<'tcx> LateLintPass<'tcx> for BoxedLocal {
         });
 
         for node in v.set {
-            span_lint(
+            span_lint_hir(
                 cx,
                 BOXED_LOCAL,
+                node,
                 cx.tcx.hir().span(node),
                 "local variable doesn't need to be boxed here",
             );
diff --git a/tests/ui/boxed_local.rs b/tests/ui/boxed_local.rs
new file mode 100644
index 00000000000..7c74aa75822
--- /dev/null
+++ b/tests/ui/boxed_local.rs
@@ -0,0 +1,210 @@
+#![feature(box_syntax)]
+#![feature(lint_reasons)]
+#![allow(
+    clippy::borrowed_box,
+    clippy::needless_pass_by_value,
+    clippy::unused_unit,
+    clippy::redundant_clone,
+    clippy::match_single_binding
+)]
+#![warn(clippy::boxed_local)]
+
+#[derive(Clone)]
+struct A;
+
+impl A {
+    fn foo(&self) {}
+}
+
+trait Z {
+    fn bar(&self);
+}
+
+impl Z for A {
+    fn bar(&self) {
+        //nothing
+    }
+}
+
+fn main() {}
+
+fn ok_box_trait(boxed_trait: &Box<dyn Z>) {
+    let boxed_local = boxed_trait;
+    // done
+}
+
+fn warn_call() {
+    let x = box A;
+    x.foo();
+}
+
+fn warn_arg(x: Box<A>) {
+    x.foo();
+}
+
+fn nowarn_closure_arg() {
+    let x = Some(box A);
+    x.map_or((), |x| take_ref(&x));
+}
+
+fn warn_rename_call() {
+    let x = box A;
+
+    let y = x;
+    y.foo(); // via autoderef
+}
+
+fn warn_notuse() {
+    let bz = box A;
+}
+
+fn warn_pass() {
+    let bz = box A;
+    take_ref(&bz); // via deref coercion
+}
+
+fn nowarn_return() -> Box<A> {
+    box A // moved out, "escapes"
+}
+
+fn nowarn_move() {
+    let bx = box A;
+    drop(bx) // moved in, "escapes"
+}
+fn nowarn_call() {
+    let bx = box A;
+    bx.clone(); // method only available to Box, not via autoderef
+}
+
+fn nowarn_pass() {
+    let bx = box A;
+    take_box(&bx); // fn needs &Box
+}
+
+fn take_box(x: &Box<A>) {}
+fn take_ref(x: &A) {}
+
+fn nowarn_ref_take() {
+    // false positive, should actually warn
+    let x = box A;
+    let y = &x;
+    take_box(y);
+}
+
+fn nowarn_match() {
+    let x = box A; // moved into a match
+    match x {
+        y => drop(y),
+    }
+}
+
+fn warn_match() {
+    let x = box A;
+    match &x {
+        // not moved
+        y => (),
+    }
+}
+
+fn nowarn_large_array() {
+    // should not warn, is large array
+    // and should not be on stack
+    let x = box [1; 10000];
+    match &x {
+        // not moved
+        y => (),
+    }
+}
+
+/// ICE regression test
+pub trait Foo {
+    type Item;
+}
+
+impl<'a> Foo for &'a () {
+    type Item = ();
+}
+
+pub struct PeekableSeekable<I: Foo> {
+    _peeked: I::Item,
+}
+
+pub fn new(_needs_name: Box<PeekableSeekable<&()>>) -> () {}
+
+/// Regression for #916, #1123
+///
+/// This shouldn't warn for `boxed_local`as the implementation of a trait
+/// can't change much about the trait definition.
+trait BoxedAction {
+    fn do_sth(self: Box<Self>);
+}
+
+impl BoxedAction for u64 {
+    fn do_sth(self: Box<Self>) {
+        println!("{}", *self)
+    }
+}
+
+/// Regression for #1478
+///
+/// This shouldn't warn for `boxed_local`as self itself is a box type.
+trait MyTrait {
+    fn do_sth(self);
+}
+
+impl<T> MyTrait for Box<T> {
+    fn do_sth(self) {}
+}
+
+// Issue #3739 - capture in closures
+mod issue_3739 {
+    use super::A;
+
+    fn consume<T>(_: T) {}
+    fn borrow<T>(_: &T) {}
+
+    fn closure_consume(x: Box<A>) {
+        let _ = move || {
+            consume(x);
+        };
+    }
+
+    fn closure_borrow(x: Box<A>) {
+        let _ = || {
+            borrow(&x);
+        };
+    }
+}
+
+/// Issue #5542
+///
+/// This shouldn't warn for `boxed_local` as it is intended to called from non-Rust code.
+pub extern "C" fn do_not_warn_me(_c_pointer: Box<String>) -> () {}
+
+#[rustfmt::skip] // Forces rustfmt to not add ABI
+pub extern fn do_not_warn_me_no_abi(_c_pointer: Box<String>) -> () {}
+
+// Issue #4804 - default implementation in trait
+mod issue4804 {
+    trait DefaultTraitImplTest {
+        // don't warn on `self`
+        fn default_impl(self: Box<Self>) -> u32 {
+            5
+        }
+
+        // warn on `x: Box<u32>`
+        fn default_impl_x(self: Box<Self>, x: Box<u32>) -> u32 {
+            4
+        }
+    }
+
+    trait WarnTrait {
+        // warn on `x: Box<u32>`
+        fn foo(x: Box<u32>) {}
+    }
+}
+
+#[expect(clippy::boxed_local)]
+fn check_expect(x: Box<A>) {
+    x.foo();
+}
diff --git a/tests/ui/boxed_local.stderr b/tests/ui/boxed_local.stderr
new file mode 100644
index 00000000000..9036529f39c
--- /dev/null
+++ b/tests/ui/boxed_local.stderr
@@ -0,0 +1,28 @@
+error: local variable doesn't need to be boxed here
+  --> $DIR/boxed_local.rs:41:13
+   |
+LL | fn warn_arg(x: Box<A>) {
+   |             ^
+   |
+   = note: `-D clippy::boxed-local` implied by `-D warnings`
+
+error: local variable doesn't need to be boxed here
+  --> $DIR/boxed_local.rs:132:12
+   |
+LL | pub fn new(_needs_name: Box<PeekableSeekable<&()>>) -> () {}
+   |            ^^^^^^^^^^^
+
+error: local variable doesn't need to be boxed here
+  --> $DIR/boxed_local.rs:196:44
+   |
+LL |         fn default_impl_x(self: Box<Self>, x: Box<u32>) -> u32 {
+   |                                            ^
+
+error: local variable doesn't need to be boxed here
+  --> $DIR/boxed_local.rs:203:16
+   |
+LL |         fn foo(x: Box<u32>) {}
+   |                ^
+
+error: aborting due to 4 previous errors
+
diff --git a/tests/ui/escape_analysis.rs b/tests/ui/escape_analysis.rs
deleted file mode 100644
index 13e2b6c7a2e..00000000000
--- a/tests/ui/escape_analysis.rs
+++ /dev/null
@@ -1,204 +0,0 @@
-#![feature(box_syntax)]
-#![allow(
-    clippy::borrowed_box,
-    clippy::needless_pass_by_value,
-    clippy::unused_unit,
-    clippy::redundant_clone,
-    clippy::match_single_binding
-)]
-#![warn(clippy::boxed_local)]
-
-#[derive(Clone)]
-struct A;
-
-impl A {
-    fn foo(&self) {}
-}
-
-trait Z {
-    fn bar(&self);
-}
-
-impl Z for A {
-    fn bar(&self) {
-        //nothing
-    }
-}
-
-fn main() {}
-
-fn ok_box_trait(boxed_trait: &Box<dyn Z>) {
-    let boxed_local = boxed_trait;
-    // done
-}
-
-fn warn_call() {
-    let x = box A;
-    x.foo();
-}
-
-fn warn_arg(x: Box<A>) {
-    x.foo();
-}
-
-fn nowarn_closure_arg() {
-    let x = Some(box A);
-    x.map_or((), |x| take_ref(&x));
-}
-
-fn warn_rename_call() {
-    let x = box A;
-
-    let y = x;
-    y.foo(); // via autoderef
-}
-
-fn warn_notuse() {
-    let bz = box A;
-}
-
-fn warn_pass() {
-    let bz = box A;
-    take_ref(&bz); // via deref coercion
-}
-
-fn nowarn_return() -> Box<A> {
-    box A // moved out, "escapes"
-}
-
-fn nowarn_move() {
-    let bx = box A;
-    drop(bx) // moved in, "escapes"
-}
-fn nowarn_call() {
-    let bx = box A;
-    bx.clone(); // method only available to Box, not via autoderef
-}
-
-fn nowarn_pass() {
-    let bx = box A;
-    take_box(&bx); // fn needs &Box
-}
-
-fn take_box(x: &Box<A>) {}
-fn take_ref(x: &A) {}
-
-fn nowarn_ref_take() {
-    // false positive, should actually warn
-    let x = box A;
-    let y = &x;
-    take_box(y);
-}
-
-fn nowarn_match() {
-    let x = box A; // moved into a match
-    match x {
-        y => drop(y),
-    }
-}
-
-fn warn_match() {
-    let x = box A;
-    match &x {
-        // not moved
-        y => (),
-    }
-}
-
-fn nowarn_large_array() {
-    // should not warn, is large array
-    // and should not be on stack
-    let x = box [1; 10000];
-    match &x {
-        // not moved
-        y => (),
-    }
-}
-
-/// ICE regression test
-pub trait Foo {
-    type Item;
-}
-
-impl<'a> Foo for &'a () {
-    type Item = ();
-}
-
-pub struct PeekableSeekable<I: Foo> {
-    _peeked: I::Item,
-}
-
-pub fn new(_needs_name: Box<PeekableSeekable<&()>>) -> () {}
-
-/// Regression for #916, #1123
-///
-/// This shouldn't warn for `boxed_local`as the implementation of a trait
-/// can't change much about the trait definition.
-trait BoxedAction {
-    fn do_sth(self: Box<Self>);
-}
-
-impl BoxedAction for u64 {
-    fn do_sth(self: Box<Self>) {
-        println!("{}", *self)
-    }
-}
-
-/// Regression for #1478
-///
-/// This shouldn't warn for `boxed_local`as self itself is a box type.
-trait MyTrait {
-    fn do_sth(self);
-}
-
-impl<T> MyTrait for Box<T> {
-    fn do_sth(self) {}
-}
-
-// Issue #3739 - capture in closures
-mod issue_3739 {
-    use super::A;
-
-    fn consume<T>(_: T) {}
-    fn borrow<T>(_: &T) {}
-
-    fn closure_consume(x: Box<A>) {
-        let _ = move || {
-            consume(x);
-        };
-    }
-
-    fn closure_borrow(x: Box<A>) {
-        let _ = || {
-            borrow(&x);
-        };
-    }
-}
-
-/// Issue #5542
-///
-/// This shouldn't warn for `boxed_local` as it is intended to called from non-Rust code.
-pub extern "C" fn do_not_warn_me(_c_pointer: Box<String>) -> () {}
-
-#[rustfmt::skip] // Forces rustfmt to not add ABI
-pub extern fn do_not_warn_me_no_abi(_c_pointer: Box<String>) -> () {}
-
-// Issue #4804 - default implementation in trait
-mod issue4804 {
-    trait DefaultTraitImplTest {
-        // don't warn on `self`
-        fn default_impl(self: Box<Self>) -> u32 {
-            5
-        }
-
-        // warn on `x: Box<u32>`
-        fn default_impl_x(self: Box<Self>, x: Box<u32>) -> u32 {
-            4
-        }
-    }
-
-    trait WarnTrait {
-        // warn on `x: Box<u32>`
-        fn foo(x: Box<u32>) {}
-    }
-}
diff --git a/tests/ui/escape_analysis.stderr b/tests/ui/escape_analysis.stderr
deleted file mode 100644
index 4a82b4419f9..00000000000
--- a/tests/ui/escape_analysis.stderr
+++ /dev/null
@@ -1,28 +0,0 @@
-error: local variable doesn't need to be boxed here
-  --> $DIR/escape_analysis.rs:40:13
-   |
-LL | fn warn_arg(x: Box<A>) {
-   |             ^
-   |
-   = note: `-D clippy::boxed-local` implied by `-D warnings`
-
-error: local variable doesn't need to be boxed here
-  --> $DIR/escape_analysis.rs:131:12
-   |
-LL | pub fn new(_needs_name: Box<PeekableSeekable<&()>>) -> () {}
-   |            ^^^^^^^^^^^
-
-error: local variable doesn't need to be boxed here
-  --> $DIR/escape_analysis.rs:195:44
-   |
-LL |         fn default_impl_x(self: Box<Self>, x: Box<u32>) -> u32 {
-   |                                            ^
-
-error: local variable doesn't need to be boxed here
-  --> $DIR/escape_analysis.rs:202:16
-   |
-LL |         fn foo(x: Box<u32>) {}
-   |                ^
-
-error: aborting due to 4 previous errors
-
-- 
cgit 1.4.1-3-g733a5


From 54ad99b6e5b46372ab4c14f700d2c74c2f246a7c Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Sat, 25 Jun 2022 14:16:31 +0200
Subject: Fix `#[expect]` for `clippy::implicit_return`

---
 clippy_lints/src/implicit_return.rs | 39 ++++++++++++++++++++++---------------
 tests/ui/implicit_return.fixed      | 12 +++++++++++-
 tests/ui/implicit_return.rs         | 12 +++++++++++-
 3 files changed, 45 insertions(+), 18 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/implicit_return.rs b/clippy_lints/src/implicit_return.rs
index 647947d5d30..a6610ade37e 100644
--- a/clippy_lints/src/implicit_return.rs
+++ b/clippy_lints/src/implicit_return.rs
@@ -1,5 +1,5 @@
 use clippy_utils::{
-    diagnostics::span_lint_and_sugg,
+    diagnostics::span_lint_hir_and_then,
     get_async_fn_body, is_async_fn,
     source::{snippet_with_applicability, snippet_with_context, walk_span_to_context},
     visitors::expr_visitor_no_bodies,
@@ -43,31 +43,38 @@ declare_clippy_lint! {
 
 declare_lint_pass!(ImplicitReturn => [IMPLICIT_RETURN]);
 
-fn lint_return(cx: &LateContext<'_>, span: Span) {
+fn lint_return(cx: &LateContext<'_>, emission_place: HirId, span: Span) {
     let mut app = Applicability::MachineApplicable;
     let snip = snippet_with_applicability(cx, span, "..", &mut app);
-    span_lint_and_sugg(
+    span_lint_hir_and_then(
         cx,
         IMPLICIT_RETURN,
+        emission_place,
         span,
         "missing `return` statement",
-        "add `return` as shown",
-        format!("return {}", snip),
-        app,
+        |diag| {
+            diag.span_suggestion(span, "add `return` as shown", format!("return {}", snip), app);
+        },
     );
 }
 
-fn lint_break(cx: &LateContext<'_>, break_span: Span, expr_span: Span) {
+fn lint_break(cx: &LateContext<'_>, emission_place: HirId, break_span: Span, expr_span: Span) {
     let mut app = Applicability::MachineApplicable;
     let snip = snippet_with_context(cx, expr_span, break_span.ctxt(), "..", &mut app).0;
-    span_lint_and_sugg(
+    span_lint_hir_and_then(
         cx,
         IMPLICIT_RETURN,
+        emission_place,
         break_span,
         "missing `return` statement",
-        "change `break` to `return` as shown",
-        format!("return {}", snip),
-        app,
+        |diag| {
+            diag.span_suggestion(
+                break_span,
+                "change `break` to `return` as shown",
+                format!("return {}", snip),
+                app,
+            );
+        },
     );
 }
 
@@ -152,7 +159,7 @@ fn lint_implicit_returns(
                             // At this point sub_expr can be `None` in async functions which either diverge, or return
                             // the unit type.
                             if let Some(sub_expr) = sub_expr {
-                                lint_break(cx, e.span, sub_expr.span);
+                                lint_break(cx, e.hir_id, e.span, sub_expr.span);
                             }
                         } else {
                             // the break expression is from a macro call, add a return to the loop
@@ -166,10 +173,10 @@ fn lint_implicit_returns(
             if add_return {
                 #[expect(clippy::option_if_let_else)]
                 if let Some(span) = call_site_span {
-                    lint_return(cx, span);
+                    lint_return(cx, expr.hir_id, span);
                     LintLocation::Parent
                 } else {
-                    lint_return(cx, expr.span);
+                    lint_return(cx, expr.hir_id, expr.span);
                     LintLocation::Inner
                 }
             } else {
@@ -198,10 +205,10 @@ fn lint_implicit_returns(
         {
             #[expect(clippy::option_if_let_else)]
             if let Some(span) = call_site_span {
-                lint_return(cx, span);
+                lint_return(cx, expr.hir_id, span);
                 LintLocation::Parent
             } else {
-                lint_return(cx, expr.span);
+                lint_return(cx, expr.hir_id, expr.span);
                 LintLocation::Inner
             }
         },
diff --git a/tests/ui/implicit_return.fixed b/tests/ui/implicit_return.fixed
index a51f7bc6a29..5e55b8b6739 100644
--- a/tests/ui/implicit_return.fixed
+++ b/tests/ui/implicit_return.fixed
@@ -1,5 +1,5 @@
 // run-rustfix
-
+#![feature(lint_reasons)]
 #![warn(clippy::implicit_return)]
 #![allow(clippy::needless_return, clippy::needless_bool, unused, clippy::never_loop)]
 
@@ -128,3 +128,13 @@ async fn foo() -> bool {
 }
 
 fn main() {}
+
+fn check_expect() -> bool {
+    if true {
+        // no error!
+        return true;
+    }
+
+    #[expect(clippy::implicit_return)]
+    true
+}
diff --git a/tests/ui/implicit_return.rs b/tests/ui/implicit_return.rs
index 03f8ec49d51..76f0a980352 100644
--- a/tests/ui/implicit_return.rs
+++ b/tests/ui/implicit_return.rs
@@ -1,5 +1,5 @@
 // run-rustfix
-
+#![feature(lint_reasons)]
 #![warn(clippy::implicit_return)]
 #![allow(clippy::needless_return, clippy::needless_bool, unused, clippy::never_loop)]
 
@@ -128,3 +128,13 @@ async fn foo() -> bool {
 }
 
 fn main() {}
+
+fn check_expect() -> bool {
+    if true {
+        // no error!
+        return true;
+    }
+
+    #[expect(clippy::implicit_return)]
+    true
+}
-- 
cgit 1.4.1-3-g733a5


From bdc6ece1b632324f72cfa23c8ef964fe553d5be7 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Sat, 25 Jun 2022 14:16:31 +0200
Subject: Fix `#[expect]` for `clippy::needless_return`

---
 clippy_lints/src/returns.rs     | 71 ++++++++++++++++++++++++++++-----------
 tests/ui/needless_return.fixed  | 10 ++++++
 tests/ui/needless_return.rs     | 10 ++++++
 tests/ui/needless_return.stderr | 74 ++++++++++++++++++++---------------------
 4 files changed, 109 insertions(+), 56 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
index e525eba53e2..5ae04947b82 100644
--- a/clippy_lints/src/returns.rs
+++ b/clippy_lints/src/returns.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
+use clippy_utils::diagnostics::span_lint_hir_and_then;
 use clippy_utils::source::{snippet_opt, snippet_with_context};
 use clippy_utils::{fn_def_id, path_to_local_id};
 use if_chain::if_chain;
@@ -94,9 +94,10 @@ impl<'tcx> LateLintPass<'tcx> for Return {
             if !in_external_macro(cx.sess(), retexpr.span);
             if !local.span.from_expansion();
             then {
-                span_lint_and_then(
+                span_lint_hir_and_then(
                     cx,
                     LET_AND_RETURN,
+                    retexpr.hir_id,
                     retexpr.span,
                     "returning the result of a `let` binding from a block",
                     |err| {
@@ -185,6 +186,7 @@ fn check_final_expr<'tcx>(
                 if !borrows {
                     emit_return_lint(
                         cx,
+                        inner.map_or(expr.hir_id, |inner| inner.hir_id),
                         span.expect("`else return` is not possible"),
                         inner.as_ref().map(|i| i.span),
                         replacement,
@@ -220,50 +222,81 @@ fn check_final_expr<'tcx>(
     }
 }
 
-fn emit_return_lint(cx: &LateContext<'_>, ret_span: Span, inner_span: Option<Span>, replacement: RetReplacement) {
+fn emit_return_lint(
+    cx: &LateContext<'_>,
+    emission_place: HirId,
+    ret_span: Span,
+    inner_span: Option<Span>,
+    replacement: RetReplacement,
+) {
     if ret_span.from_expansion() {
         return;
     }
     match inner_span {
         Some(inner_span) => {
             let mut applicability = Applicability::MachineApplicable;
-            span_lint_and_then(cx, NEEDLESS_RETURN, ret_span, "unneeded `return` statement", |diag| {
-                let (snippet, _) = snippet_with_context(cx, inner_span, ret_span.ctxt(), "..", &mut applicability);
-                diag.span_suggestion(ret_span, "remove `return`", snippet, applicability);
-            });
+            span_lint_hir_and_then(
+                cx,
+                NEEDLESS_RETURN,
+                emission_place,
+                ret_span,
+                "unneeded `return` statement",
+                |diag| {
+                    let (snippet, _) = snippet_with_context(cx, inner_span, ret_span.ctxt(), "..", &mut applicability);
+                    diag.span_suggestion(ret_span, "remove `return`", snippet, applicability);
+                },
+            );
         },
         None => match replacement {
             RetReplacement::Empty => {
-                span_lint_and_sugg(
+                span_lint_hir_and_then(
                     cx,
                     NEEDLESS_RETURN,
+                    emission_place,
                     ret_span,
                     "unneeded `return` statement",
-                    "remove `return`",
-                    String::new(),
-                    Applicability::MachineApplicable,
+                    |diag| {
+                        diag.span_suggestion(
+                            ret_span,
+                            "remove `return`",
+                            String::new(),
+                            Applicability::MachineApplicable,
+                        );
+                    },
                 );
             },
             RetReplacement::Block => {
-                span_lint_and_sugg(
+                span_lint_hir_and_then(
                     cx,
                     NEEDLESS_RETURN,
+                    emission_place,
                     ret_span,
                     "unneeded `return` statement",
-                    "replace `return` with an empty block",
-                    "{}".to_string(),
-                    Applicability::MachineApplicable,
+                    |diag| {
+                        diag.span_suggestion(
+                            ret_span,
+                            "replace `return` with an empty block",
+                            "{}".to_string(),
+                            Applicability::MachineApplicable,
+                        );
+                    },
                 );
             },
             RetReplacement::Unit => {
-                span_lint_and_sugg(
+                span_lint_hir_and_then(
                     cx,
                     NEEDLESS_RETURN,
+                    emission_place,
                     ret_span,
                     "unneeded `return` statement",
-                    "replace `return` with a unit value",
-                    "()".to_string(),
-                    Applicability::MachineApplicable,
+                    |diag| {
+                        diag.span_suggestion(
+                            ret_span,
+                            "replace `return` with a unit value",
+                            "()".to_string(),
+                            Applicability::MachineApplicable,
+                        );
+                    },
                 );
             },
         },
diff --git a/tests/ui/needless_return.fixed b/tests/ui/needless_return.fixed
index 166d9bea2e1..0bc0d0011ef 100644
--- a/tests/ui/needless_return.fixed
+++ b/tests/ui/needless_return.fixed
@@ -1,5 +1,6 @@
 // run-rustfix
 
+#![feature(lint_reasons)]
 #![feature(let_else)]
 #![allow(unused)]
 #![allow(
@@ -227,4 +228,13 @@ fn needless_return_macro() -> String {
     format!("Hello {}", "world!")
 }
 
+fn check_expect() -> bool {
+    if true {
+        // no error!
+        return true;
+    }
+    #[expect(clippy::needless_return)]
+    return true;
+}
+
 fn main() {}
diff --git a/tests/ui/needless_return.rs b/tests/ui/needless_return.rs
index f38d3c3fcd9..eb9f72e8e78 100644
--- a/tests/ui/needless_return.rs
+++ b/tests/ui/needless_return.rs
@@ -1,5 +1,6 @@
 // run-rustfix
 
+#![feature(lint_reasons)]
 #![feature(let_else)]
 #![allow(unused)]
 #![allow(
@@ -227,4 +228,13 @@ fn needless_return_macro() -> String {
     return format!("Hello {}", "world!");
 }
 
+fn check_expect() -> bool {
+    if true {
+        // no error!
+        return true;
+    }
+    #[expect(clippy::needless_return)]
+    return true;
+}
+
 fn main() {}
diff --git a/tests/ui/needless_return.stderr b/tests/ui/needless_return.stderr
index cadee6e00df..83ff0763869 100644
--- a/tests/ui/needless_return.stderr
+++ b/tests/ui/needless_return.stderr
@@ -1,5 +1,5 @@
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:26:5
+  --> $DIR/needless_return.rs:27:5
    |
 LL |     return true;
    |     ^^^^^^^^^^^^ help: remove `return`: `true`
@@ -7,217 +7,217 @@ LL |     return true;
    = note: `-D clippy::needless-return` implied by `-D warnings`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:30:5
+  --> $DIR/needless_return.rs:31:5
    |
 LL |     return true;
    |     ^^^^^^^^^^^^ help: remove `return`: `true`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:35:9
+  --> $DIR/needless_return.rs:36:9
    |
 LL |         return true;
    |         ^^^^^^^^^^^^ help: remove `return`: `true`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:37:9
+  --> $DIR/needless_return.rs:38:9
    |
 LL |         return false;
    |         ^^^^^^^^^^^^^ help: remove `return`: `false`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:43:17
+  --> $DIR/needless_return.rs:44:17
    |
 LL |         true => return false,
    |                 ^^^^^^^^^^^^ help: remove `return`: `false`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:45:13
+  --> $DIR/needless_return.rs:46:13
    |
 LL |             return true;
    |             ^^^^^^^^^^^^ help: remove `return`: `true`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:52:9
+  --> $DIR/needless_return.rs:53:9
    |
 LL |         return true;
    |         ^^^^^^^^^^^^ help: remove `return`: `true`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:54:16
+  --> $DIR/needless_return.rs:55:16
    |
 LL |     let _ = || return true;
    |                ^^^^^^^^^^^ help: remove `return`: `true`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:58:5
+  --> $DIR/needless_return.rs:59:5
    |
 LL |     return the_answer!();
    |     ^^^^^^^^^^^^^^^^^^^^^ help: remove `return`: `the_answer!()`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:62:5
+  --> $DIR/needless_return.rs:63:5
    |
 LL |     return;
    |     ^^^^^^^ help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:67:9
+  --> $DIR/needless_return.rs:68:9
    |
 LL |         return;
    |         ^^^^^^^ help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:69:9
+  --> $DIR/needless_return.rs:70:9
    |
 LL |         return;
    |         ^^^^^^^ help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:76:14
+  --> $DIR/needless_return.rs:77:14
    |
 LL |         _ => return,
    |              ^^^^^^ help: replace `return` with a unit value: `()`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:85:13
+  --> $DIR/needless_return.rs:86:13
    |
 LL |             return;
    |             ^^^^^^^ help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:87:14
+  --> $DIR/needless_return.rs:88:14
    |
 LL |         _ => return,
    |              ^^^^^^ help: replace `return` with a unit value: `()`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:100:9
+  --> $DIR/needless_return.rs:101:9
    |
 LL |         return String::from("test");
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove `return`: `String::from("test")`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:102:9
+  --> $DIR/needless_return.rs:103:9
    |
 LL |         return String::new();
    |         ^^^^^^^^^^^^^^^^^^^^^ help: remove `return`: `String::new()`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:124:32
+  --> $DIR/needless_return.rs:125:32
    |
 LL |         bar.unwrap_or_else(|_| return)
    |                                ^^^^^^ help: replace `return` with an empty block: `{}`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:129:13
+  --> $DIR/needless_return.rs:130:13
    |
 LL |             return;
    |             ^^^^^^^ help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:131:20
+  --> $DIR/needless_return.rs:132:20
    |
 LL |         let _ = || return;
    |                    ^^^^^^ help: replace `return` with an empty block: `{}`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:137:32
+  --> $DIR/needless_return.rs:138:32
    |
 LL |         res.unwrap_or_else(|_| return Foo)
    |                                ^^^^^^^^^^ help: remove `return`: `Foo`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:146:5
+  --> $DIR/needless_return.rs:147:5
    |
 LL |     return true;
    |     ^^^^^^^^^^^^ help: remove `return`: `true`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:150:5
+  --> $DIR/needless_return.rs:151:5
    |
 LL |     return true;
    |     ^^^^^^^^^^^^ help: remove `return`: `true`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:155:9
+  --> $DIR/needless_return.rs:156:9
    |
 LL |         return true;
    |         ^^^^^^^^^^^^ help: remove `return`: `true`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:157:9
+  --> $DIR/needless_return.rs:158:9
    |
 LL |         return false;
    |         ^^^^^^^^^^^^^ help: remove `return`: `false`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:163:17
+  --> $DIR/needless_return.rs:164:17
    |
 LL |         true => return false,
    |                 ^^^^^^^^^^^^ help: remove `return`: `false`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:165:13
+  --> $DIR/needless_return.rs:166:13
    |
 LL |             return true;
    |             ^^^^^^^^^^^^ help: remove `return`: `true`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:172:9
+  --> $DIR/needless_return.rs:173:9
    |
 LL |         return true;
    |         ^^^^^^^^^^^^ help: remove `return`: `true`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:174:16
+  --> $DIR/needless_return.rs:175:16
    |
 LL |     let _ = || return true;
    |                ^^^^^^^^^^^ help: remove `return`: `true`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:178:5
+  --> $DIR/needless_return.rs:179:5
    |
 LL |     return the_answer!();
    |     ^^^^^^^^^^^^^^^^^^^^^ help: remove `return`: `the_answer!()`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:182:5
+  --> $DIR/needless_return.rs:183:5
    |
 LL |     return;
    |     ^^^^^^^ help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:187:9
+  --> $DIR/needless_return.rs:188:9
    |
 LL |         return;
    |         ^^^^^^^ help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:189:9
+  --> $DIR/needless_return.rs:190:9
    |
 LL |         return;
    |         ^^^^^^^ help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:196:14
+  --> $DIR/needless_return.rs:197:14
    |
 LL |         _ => return,
    |              ^^^^^^ help: replace `return` with a unit value: `()`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:209:9
+  --> $DIR/needless_return.rs:210:9
    |
 LL |         return String::from("test");
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove `return`: `String::from("test")`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:211:9
+  --> $DIR/needless_return.rs:212:9
    |
 LL |         return String::new();
    |         ^^^^^^^^^^^^^^^^^^^^^ help: remove `return`: `String::new()`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:227:5
+  --> $DIR/needless_return.rs:228:5
    |
 LL |     return format!("Hello {}", "world!");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove `return`: `format!("Hello {}", "world!")`
-- 
cgit 1.4.1-3-g733a5


From 79fc2716dcf208f9af397226ea282296a1654e67 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Sat, 25 Jun 2022 14:16:32 +0200
Subject: Fix `#[expect]` for `unnecessary_unwrap`, `panicking_unwrap`

---
 clippy_lints/src/unwrap.rs                         |  8 +++--
 tests/ui/checked_unwrap/simple_conditionals.rs     | 16 +++++++++
 tests/ui/checked_unwrap/simple_conditionals.stderr | 38 +++++++++++-----------
 3 files changed, 40 insertions(+), 22 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unwrap.rs b/clippy_lints/src/unwrap.rs
index 9b9e25326f9..d3f9e5abfd7 100644
--- a/clippy_lints/src/unwrap.rs
+++ b/clippy_lints/src/unwrap.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::diagnostics::span_lint_hir_and_then;
 use clippy_utils::higher;
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::{path_to_local, usage::is_potentially_mutated};
@@ -251,9 +251,10 @@ impl<'a, 'tcx> Visitor<'tcx> for UnwrappableVariablesVisitor<'a, 'tcx> {
                             unwrappable.kind.error_variant_pattern()
                         };
 
-                        span_lint_and_then(
+                        span_lint_hir_and_then(
                             self.cx,
                             UNNECESSARY_UNWRAP,
+                            expr.hir_id,
                             expr.span,
                             &format!(
                                 "called `{}` on `{}` after checking its variant with `{}`",
@@ -283,9 +284,10 @@ impl<'a, 'tcx> Visitor<'tcx> for UnwrappableVariablesVisitor<'a, 'tcx> {
                             },
                         );
                     } else {
-                        span_lint_and_then(
+                        span_lint_hir_and_then(
                             self.cx,
                             PANICKING_UNWRAP,
+                            expr.hir_id,
                             expr.span,
                             &format!("this call to `{}()` will always panic",
                             method_name.ident.name),
diff --git a/tests/ui/checked_unwrap/simple_conditionals.rs b/tests/ui/checked_unwrap/simple_conditionals.rs
index ee3fdfabe9d..82dce81979f 100644
--- a/tests/ui/checked_unwrap/simple_conditionals.rs
+++ b/tests/ui/checked_unwrap/simple_conditionals.rs
@@ -1,3 +1,4 @@
+#![feature(lint_reasons)]
 #![deny(clippy::panicking_unwrap, clippy::unnecessary_unwrap)]
 #![allow(clippy::if_same_then_else, clippy::branches_sharing_code)]
 
@@ -84,3 +85,18 @@ fn main() {
 
     assert!(x.is_ok(), "{:?}", x.unwrap_err()); // ok, it's a common test pattern
 }
+
+fn check_expect() {
+    let x = Some(());
+    if x.is_some() {
+        #[expect(clippy::unnecessary_unwrap)]
+        x.unwrap(); // unnecessary
+        #[expect(clippy::unnecessary_unwrap)]
+        x.expect("an error message"); // unnecessary
+    } else {
+        #[expect(clippy::panicking_unwrap)]
+        x.unwrap(); // will panic
+        #[expect(clippy::panicking_unwrap)]
+        x.expect("an error message"); // will panic
+    }
+}
diff --git a/tests/ui/checked_unwrap/simple_conditionals.stderr b/tests/ui/checked_unwrap/simple_conditionals.stderr
index 34131592802..ef688274222 100644
--- a/tests/ui/checked_unwrap/simple_conditionals.stderr
+++ b/tests/ui/checked_unwrap/simple_conditionals.stderr
@@ -1,5 +1,5 @@
 error: called `unwrap` on `x` after checking its variant with `is_some`
-  --> $DIR/simple_conditionals.rs:39:9
+  --> $DIR/simple_conditionals.rs:40:9
    |
 LL |     if x.is_some() {
    |     -------------- help: try: `if let Some(..) = x`
@@ -7,13 +7,13 @@ LL |         x.unwrap(); // unnecessary
    |         ^^^^^^^^^^
    |
 note: the lint level is defined here
-  --> $DIR/simple_conditionals.rs:1:35
+  --> $DIR/simple_conditionals.rs:2:35
    |
 LL | #![deny(clippy::panicking_unwrap, clippy::unnecessary_unwrap)]
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: called `expect` on `x` after checking its variant with `is_some`
-  --> $DIR/simple_conditionals.rs:40:9
+  --> $DIR/simple_conditionals.rs:41:9
    |
 LL |     if x.is_some() {
    |     -------------- help: try: `if let Some(..) = x`
@@ -22,7 +22,7 @@ LL |         x.expect("an error message"); // unnecessary
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this call to `unwrap()` will always panic
-  --> $DIR/simple_conditionals.rs:42:9
+  --> $DIR/simple_conditionals.rs:43:9
    |
 LL |     if x.is_some() {
    |        ----------- because of this check
@@ -31,13 +31,13 @@ LL |         x.unwrap(); // will panic
    |         ^^^^^^^^^^
    |
 note: the lint level is defined here
-  --> $DIR/simple_conditionals.rs:1:9
+  --> $DIR/simple_conditionals.rs:2:9
    |
 LL | #![deny(clippy::panicking_unwrap, clippy::unnecessary_unwrap)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this call to `expect()` will always panic
-  --> $DIR/simple_conditionals.rs:43:9
+  --> $DIR/simple_conditionals.rs:44:9
    |
 LL |     if x.is_some() {
    |        ----------- because of this check
@@ -46,7 +46,7 @@ LL |         x.expect("an error message"); // will panic
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this call to `unwrap()` will always panic
-  --> $DIR/simple_conditionals.rs:46:9
+  --> $DIR/simple_conditionals.rs:47:9
    |
 LL |     if x.is_none() {
    |        ----------- because of this check
@@ -54,7 +54,7 @@ LL |         x.unwrap(); // will panic
    |         ^^^^^^^^^^
 
 error: called `unwrap` on `x` after checking its variant with `is_none`
-  --> $DIR/simple_conditionals.rs:48:9
+  --> $DIR/simple_conditionals.rs:49:9
    |
 LL |     if x.is_none() {
    |     -------------- help: try: `if let Some(..) = x`
@@ -63,7 +63,7 @@ LL |         x.unwrap(); // unnecessary
    |         ^^^^^^^^^^
 
 error: called `unwrap` on `x` after checking its variant with `is_some`
-  --> $DIR/simple_conditionals.rs:7:13
+  --> $DIR/simple_conditionals.rs:8:13
    |
 LL |         if $a.is_some() {
    |         --------------- help: try: `if let Some(..) = x`
@@ -76,7 +76,7 @@ LL |     m!(x);
    = note: this error originates in the macro `m` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: called `unwrap` on `x` after checking its variant with `is_ok`
-  --> $DIR/simple_conditionals.rs:56:9
+  --> $DIR/simple_conditionals.rs:57:9
    |
 LL |     if x.is_ok() {
    |     ------------ help: try: `if let Ok(..) = x`
@@ -84,7 +84,7 @@ LL |         x.unwrap(); // unnecessary
    |         ^^^^^^^^^^
 
 error: called `expect` on `x` after checking its variant with `is_ok`
-  --> $DIR/simple_conditionals.rs:57:9
+  --> $DIR/simple_conditionals.rs:58:9
    |
 LL |     if x.is_ok() {
    |     ------------ help: try: `if let Ok(..) = x`
@@ -93,7 +93,7 @@ LL |         x.expect("an error message"); // unnecessary
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this call to `unwrap_err()` will always panic
-  --> $DIR/simple_conditionals.rs:58:9
+  --> $DIR/simple_conditionals.rs:59:9
    |
 LL |     if x.is_ok() {
    |        --------- because of this check
@@ -102,7 +102,7 @@ LL |         x.unwrap_err(); // will panic
    |         ^^^^^^^^^^^^^^
 
 error: this call to `unwrap()` will always panic
-  --> $DIR/simple_conditionals.rs:60:9
+  --> $DIR/simple_conditionals.rs:61:9
    |
 LL |     if x.is_ok() {
    |        --------- because of this check
@@ -111,7 +111,7 @@ LL |         x.unwrap(); // will panic
    |         ^^^^^^^^^^
 
 error: this call to `expect()` will always panic
-  --> $DIR/simple_conditionals.rs:61:9
+  --> $DIR/simple_conditionals.rs:62:9
    |
 LL |     if x.is_ok() {
    |        --------- because of this check
@@ -120,7 +120,7 @@ LL |         x.expect("an error message"); // will panic
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: called `unwrap_err` on `x` after checking its variant with `is_ok`
-  --> $DIR/simple_conditionals.rs:62:9
+  --> $DIR/simple_conditionals.rs:63:9
    |
 LL |     if x.is_ok() {
    |     ------------ help: try: `if let Err(..) = x`
@@ -129,7 +129,7 @@ LL |         x.unwrap_err(); // unnecessary
    |         ^^^^^^^^^^^^^^
 
 error: this call to `unwrap()` will always panic
-  --> $DIR/simple_conditionals.rs:65:9
+  --> $DIR/simple_conditionals.rs:66:9
    |
 LL |     if x.is_err() {
    |        ---------- because of this check
@@ -137,7 +137,7 @@ LL |         x.unwrap(); // will panic
    |         ^^^^^^^^^^
 
 error: called `unwrap_err` on `x` after checking its variant with `is_err`
-  --> $DIR/simple_conditionals.rs:66:9
+  --> $DIR/simple_conditionals.rs:67:9
    |
 LL |     if x.is_err() {
    |     ------------- help: try: `if let Err(..) = x`
@@ -146,7 +146,7 @@ LL |         x.unwrap_err(); // unnecessary
    |         ^^^^^^^^^^^^^^
 
 error: called `unwrap` on `x` after checking its variant with `is_err`
-  --> $DIR/simple_conditionals.rs:68:9
+  --> $DIR/simple_conditionals.rs:69:9
    |
 LL |     if x.is_err() {
    |     ------------- help: try: `if let Ok(..) = x`
@@ -155,7 +155,7 @@ LL |         x.unwrap(); // unnecessary
    |         ^^^^^^^^^^
 
 error: this call to `unwrap_err()` will always panic
-  --> $DIR/simple_conditionals.rs:69:9
+  --> $DIR/simple_conditionals.rs:70:9
    |
 LL |     if x.is_err() {
    |        ---------- because of this check
-- 
cgit 1.4.1-3-g733a5


From ae4900c9b83b111df8eb55ac1e914e498d6a2746 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Sat, 25 Jun 2022 14:16:32 +0200
Subject: Fix `#[expect]` for `clippy::macro_use_imports`

---
 clippy_lints/src/macro_use.rs        | 42 +++++++++++++++++------------
 tests/ui/macro_use_imports.fixed     |  1 +
 tests/ui/macro_use_imports.rs        |  1 +
 tests/ui/macro_use_imports.stderr    | 14 +++++-----
 tests/ui/macro_use_imports_expect.rs | 51 ++++++++++++++++++++++++++++++++++++
 5 files changed, 85 insertions(+), 24 deletions(-)
 create mode 100644 tests/ui/macro_use_imports_expect.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/macro_use.rs b/clippy_lints/src/macro_use.rs
index da806918be0..6b78c162065 100644
--- a/clippy_lints/src/macro_use.rs
+++ b/clippy_lints/src/macro_use.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::diagnostics::span_lint_hir_and_then;
 use clippy_utils::source::snippet;
 use hir::def::{DefKind, Res};
 use if_chain::if_chain;
@@ -51,8 +51,9 @@ impl MacroRefData {
 #[derive(Default)]
 #[expect(clippy::module_name_repetitions)]
 pub struct MacroUseImports {
-    /// the actual import path used and the span of the attribute above it.
-    imports: Vec<(String, Span)>,
+    /// the actual import path used and the span of the attribute above it. The value is
+    /// the location, where the lint should be emitted.
+    imports: Vec<(String, Span, hir::HirId)>,
     /// the span of the macro reference, kept to ensure only one reference is used per macro call.
     collected: FxHashSet<Span>,
     mac_refs: Vec<MacroRefData>,
@@ -91,7 +92,8 @@ impl<'tcx> LateLintPass<'tcx> for MacroUseImports {
         if_chain! {
             if cx.sess().opts.edition >= Edition::Edition2018;
             if let hir::ItemKind::Use(path, _kind) = &item.kind;
-            let attrs = cx.tcx.hir().attrs(item.hir_id());
+            let hir_id = item.hir_id();
+            let attrs = cx.tcx.hir().attrs(hir_id);
             if let Some(mac_attr) = attrs.iter().find(|attr| attr.has_name(sym::macro_use));
             if let Res::Def(DefKind::Mod, id) = path.res;
             if !id.is_local();
@@ -100,7 +102,7 @@ impl<'tcx> LateLintPass<'tcx> for MacroUseImports {
                     if let Res::Def(DefKind::Macro(_mac_type), mac_id) = kid.res {
                         let span = mac_attr.span;
                         let def_path = cx.tcx.def_path_str(mac_id);
-                        self.imports.push((def_path, span));
+                        self.imports.push((def_path, span, hir_id));
                     }
                 }
             } else {
@@ -138,7 +140,7 @@ impl<'tcx> LateLintPass<'tcx> for MacroUseImports {
     fn check_crate_post(&mut self, cx: &LateContext<'_>) {
         let mut used = FxHashMap::default();
         let mut check_dup = vec![];
-        for (import, span) in &self.imports {
+        for (import, span, hir_id) in &self.imports {
             let found_idx = self.mac_refs.iter().position(|mac| import.ends_with(&mac.name));
 
             if let Some(idx) = found_idx {
@@ -151,7 +153,7 @@ impl<'tcx> LateLintPass<'tcx> for MacroUseImports {
                     [] | [_] => return,
                     [root, item] => {
                         if !check_dup.contains(&(*item).to_string()) {
-                            used.entry(((*root).to_string(), span))
+                            used.entry(((*root).to_string(), span, hir_id))
                                 .or_insert_with(Vec::new)
                                 .push((*item).to_string());
                             check_dup.push((*item).to_string());
@@ -169,13 +171,13 @@ impl<'tcx> LateLintPass<'tcx> for MacroUseImports {
                                     }
                                 })
                                 .collect::<Vec<_>>();
-                            used.entry(((*root).to_string(), span))
+                            used.entry(((*root).to_string(), span, hir_id))
                                 .or_insert_with(Vec::new)
                                 .push(filtered.join("::"));
                             check_dup.extend(filtered);
                         } else {
                             let rest = rest.to_vec();
-                            used.entry(((*root).to_string(), span))
+                            used.entry(((*root).to_string(), span, hir_id))
                                 .or_insert_with(Vec::new)
                                 .push(rest.join("::"));
                             check_dup.extend(rest.iter().map(ToString::to_string));
@@ -186,27 +188,33 @@ impl<'tcx> LateLintPass<'tcx> for MacroUseImports {
         }
 
         let mut suggestions = vec![];
-        for ((root, span), path) in used {
+        for ((root, span, hir_id), path) in used {
             if path.len() == 1 {
-                suggestions.push((span, format!("{}::{}", root, path[0])));
+                suggestions.push((span, format!("{}::{}", root, path[0]), hir_id));
             } else {
-                suggestions.push((span, format!("{}::{{{}}}", root, path.join(", "))));
+                suggestions.push((span, format!("{}::{{{}}}", root, path.join(", ")), hir_id));
             }
         }
 
         // If mac_refs is not empty we have encountered an import we could not handle
         // such as `std::prelude::v1::foo` or some other macro that expands to an import.
         if self.mac_refs.is_empty() {
-            for (span, import) in suggestions {
+            for (span, import, hir_id) in suggestions {
                 let help = format!("use {};", import);
-                span_lint_and_sugg(
+                span_lint_hir_and_then(
                     cx,
                     MACRO_USE_IMPORTS,
+                    *hir_id,
                     *span,
                     "`macro_use` attributes are no longer needed in the Rust 2018 edition",
-                    "remove the attribute and import the macro directly, try",
-                    help,
-                    Applicability::MaybeIncorrect,
+                    |diag| {
+                        diag.span_suggestion(
+                            *span,
+                            "remove the attribute and import the macro directly, try",
+                            help,
+                            Applicability::MaybeIncorrect,
+                        );
+                    },
                 );
             }
         }
diff --git a/tests/ui/macro_use_imports.fixed b/tests/ui/macro_use_imports.fixed
index a83c8ba0b64..e612480d264 100644
--- a/tests/ui/macro_use_imports.fixed
+++ b/tests/ui/macro_use_imports.fixed
@@ -4,6 +4,7 @@
 // run-rustfix
 // ignore-32bit
 
+#![feature(lint_reasons)]
 #![allow(unused_imports, unreachable_code, unused_variables, dead_code, unused_attributes)]
 #![allow(clippy::single_component_path_imports)]
 #![warn(clippy::macro_use_imports)]
diff --git a/tests/ui/macro_use_imports.rs b/tests/ui/macro_use_imports.rs
index e26a7545ea6..b34817cc3b2 100644
--- a/tests/ui/macro_use_imports.rs
+++ b/tests/ui/macro_use_imports.rs
@@ -4,6 +4,7 @@
 // run-rustfix
 // ignore-32bit
 
+#![feature(lint_reasons)]
 #![allow(unused_imports, unreachable_code, unused_variables, dead_code, unused_attributes)]
 #![allow(clippy::single_component_path_imports)]
 #![warn(clippy::macro_use_imports)]
diff --git a/tests/ui/macro_use_imports.stderr b/tests/ui/macro_use_imports.stderr
index 9028a636e7f..bf7b6edd0e3 100644
--- a/tests/ui/macro_use_imports.stderr
+++ b/tests/ui/macro_use_imports.stderr
@@ -1,28 +1,28 @@
 error: `macro_use` attributes are no longer needed in the Rust 2018 edition
-  --> $DIR/macro_use_imports.rs:18:5
+  --> $DIR/macro_use_imports.rs:23:5
    |
 LL |     #[macro_use]
-   |     ^^^^^^^^^^^^ help: remove the attribute and import the macro directly, try: `use mac::{pub_macro, function_macro, ty_macro, inner_mod_macro, pub_in_private_macro};`
+   |     ^^^^^^^^^^^^ help: remove the attribute and import the macro directly, try: `use mac::{inner::foofoo, inner::try_err};`
    |
    = note: `-D clippy::macro-use-imports` implied by `-D warnings`
 
 error: `macro_use` attributes are no longer needed in the Rust 2018 edition
-  --> $DIR/macro_use_imports.rs:20:5
+  --> $DIR/macro_use_imports.rs:21:5
    |
 LL |     #[macro_use]
    |     ^^^^^^^^^^^^ help: remove the attribute and import the macro directly, try: `use mini_mac::ClippyMiniMacroTest;`
 
 error: `macro_use` attributes are no longer needed in the Rust 2018 edition
-  --> $DIR/macro_use_imports.rs:22:5
+  --> $DIR/macro_use_imports.rs:25:5
    |
 LL |     #[macro_use]
-   |     ^^^^^^^^^^^^ help: remove the attribute and import the macro directly, try: `use mac::{inner::foofoo, inner::try_err};`
+   |     ^^^^^^^^^^^^ help: remove the attribute and import the macro directly, try: `use mac::inner::nested::string_add;`
 
 error: `macro_use` attributes are no longer needed in the Rust 2018 edition
-  --> $DIR/macro_use_imports.rs:24:5
+  --> $DIR/macro_use_imports.rs:19:5
    |
 LL |     #[macro_use]
-   |     ^^^^^^^^^^^^ help: remove the attribute and import the macro directly, try: `use mac::inner::nested::string_add;`
+   |     ^^^^^^^^^^^^ help: remove the attribute and import the macro directly, try: `use mac::{pub_macro, function_macro, ty_macro, inner_mod_macro, pub_in_private_macro};`
 
 error: aborting due to 4 previous errors
 
diff --git a/tests/ui/macro_use_imports_expect.rs b/tests/ui/macro_use_imports_expect.rs
new file mode 100644
index 00000000000..8a1b05da9ef
--- /dev/null
+++ b/tests/ui/macro_use_imports_expect.rs
@@ -0,0 +1,51 @@
+// aux-build:macro_rules.rs
+// aux-build:macro_use_helper.rs
+// aux-build:proc_macro_derive.rs
+// ignore-32bit
+
+#![feature(lint_reasons)]
+#![allow(unused_imports, unreachable_code, unused_variables, dead_code, unused_attributes)]
+#![allow(clippy::single_component_path_imports)]
+#![warn(clippy::macro_use_imports)]
+
+#[macro_use]
+extern crate macro_use_helper as mac;
+
+#[macro_use]
+extern crate proc_macro_derive as mini_mac;
+
+mod a {
+    #[expect(clippy::macro_use_imports)]
+    #[macro_use]
+    use mac;
+    #[expect(clippy::macro_use_imports)]
+    #[macro_use]
+    use mini_mac;
+    #[expect(clippy::macro_use_imports)]
+    #[macro_use]
+    use mac::inner;
+    #[expect(clippy::macro_use_imports)]
+    #[macro_use]
+    use mac::inner::nested;
+
+    #[derive(ClippyMiniMacroTest)]
+    struct Test;
+
+    fn test() {
+        pub_macro!();
+        inner_mod_macro!();
+        pub_in_private_macro!(_var);
+        function_macro!();
+        let v: ty_macro!() = Vec::default();
+
+        inner::try_err!();
+        inner::foofoo!();
+        nested::string_add!();
+    }
+}
+
+// issue #7015, ICE due to calling `module_children` with local `DefId`
+#[macro_use]
+use a as b;
+
+fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 525f5ee7ac9f69fd007bc11bd3dfdce24faa0a4e Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Sat, 25 Jun 2022 14:16:33 +0200
Subject: Update `useless_attribute` docs and allow `macro_use_imports`

---
 clippy_lints/src/attrs.rs | 20 +++++++++++++++-----
 1 file changed, 15 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs
index ed12ad9c367..4bcbeacf9fe 100644
--- a/clippy_lints/src/attrs.rs
+++ b/clippy_lints/src/attrs.rs
@@ -78,10 +78,17 @@ declare_clippy_lint! {
     /// Checks for `extern crate` and `use` items annotated with
     /// lint attributes.
     ///
-    /// This lint permits `#[allow(unused_imports)]`, `#[allow(deprecated)]`,
-    /// `#[allow(unreachable_pub)]`, `#[allow(clippy::wildcard_imports)]` and
-    /// `#[allow(clippy::enum_glob_use)]` on `use` items and `#[allow(unused_imports)]` on
-    /// `extern crate` items with a `#[macro_use]` attribute.
+    /// This lint permits lint attributes for lints emitted on the items themself.
+    /// For `use` items these lints are:
+    /// * deprecated
+    /// * unreachable_pub
+    /// * unused_imports
+    /// * clippy::enum_glob_use
+    /// * clippy::macro_use_imports
+    /// * clippy::wildcard_imports
+    ///
+    /// For `extern crate` items these lints are:
+    /// * `unused_imports` on items with `#[macro_use]`
     ///
     /// ### Why is this bad?
     /// Lint attributes have no effect on crate imports. Most
@@ -347,7 +354,10 @@ impl<'tcx> LateLintPass<'tcx> for Attributes {
                                             || extract_clippy_lint(lint).map_or(false, |s| {
                                                 matches!(
                                                     s.as_str(),
-                                                    "wildcard_imports" | "enum_glob_use" | "redundant_pub_crate",
+                                                    "wildcard_imports"
+                                                        | "enum_glob_use"
+                                                        | "redundant_pub_crate"
+                                                        | "macro_use_imports",
                                                 )
                                             })
                                         {
-- 
cgit 1.4.1-3-g733a5


From 6427ba4855702e14b8a8d668e37bf984d08a52bd Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Sat, 25 Jun 2022 14:16:33 +0200
Subject: Fix `#[expect]` for `clippy::manual_non_exhaustive`

---
 clippy_lints/src/manual_non_exhaustive.rs  | 9 +++++----
 tests/ui/manual_non_exhaustive_enum.rs     | 9 +++++++++
 tests/ui/manual_non_exhaustive_enum.stderr | 8 ++++----
 3 files changed, 18 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_non_exhaustive.rs b/clippy_lints/src/manual_non_exhaustive.rs
index 14f5faafd7c..4278e98dc91 100644
--- a/clippy_lints/src/manual_non_exhaustive.rs
+++ b/clippy_lints/src/manual_non_exhaustive.rs
@@ -1,6 +1,6 @@
-use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::diagnostics::{span_lint_and_then, span_lint_hir_and_then};
 use clippy_utils::source::snippet_opt;
-use clippy_utils::{is_doc_hidden, is_lint_allowed, meets_msrv, msrvs};
+use clippy_utils::{is_doc_hidden, meets_msrv, msrvs};
 use rustc_ast::ast::{self, VisibilityKind};
 use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Applicability;
@@ -190,12 +190,13 @@ impl<'tcx> LateLintPass<'tcx> for ManualNonExhaustiveEnum {
                 !self
                     .constructed_enum_variants
                     .contains(&(enum_id.to_def_id(), variant_id.to_def_id()))
-                    && !is_lint_allowed(cx, MANUAL_NON_EXHAUSTIVE, cx.tcx.hir().local_def_id_to_hir_id(enum_id))
             })
         {
-            span_lint_and_then(
+            let hir_id = cx.tcx.hir().local_def_id_to_hir_id(enum_id);
+            span_lint_hir_and_then(
                 cx,
                 MANUAL_NON_EXHAUSTIVE,
+                hir_id,
                 enum_span,
                 "this seems like a manual implementation of the non-exhaustive pattern",
                 |diag| {
diff --git a/tests/ui/manual_non_exhaustive_enum.rs b/tests/ui/manual_non_exhaustive_enum.rs
index f23c6d69b4c..03b2433f666 100644
--- a/tests/ui/manual_non_exhaustive_enum.rs
+++ b/tests/ui/manual_non_exhaustive_enum.rs
@@ -1,3 +1,4 @@
+#![feature(lint_reasons)]
 #![warn(clippy::manual_non_exhaustive)]
 #![allow(unused)]
 
@@ -75,4 +76,12 @@ fn foo(x: &mut UsedHidden) {
     }
 }
 
+#[expect(clippy::manual_non_exhaustive)]
+enum ExpectLint {
+    A,
+    B,
+    #[doc(hidden)]
+    _C,
+}
+
 fn main() {}
diff --git a/tests/ui/manual_non_exhaustive_enum.stderr b/tests/ui/manual_non_exhaustive_enum.stderr
index 317a45d2cbd..144fe86df55 100644
--- a/tests/ui/manual_non_exhaustive_enum.stderr
+++ b/tests/ui/manual_non_exhaustive_enum.stderr
@@ -1,5 +1,5 @@
 error: this seems like a manual implementation of the non-exhaustive pattern
-  --> $DIR/manual_non_exhaustive_enum.rs:4:1
+  --> $DIR/manual_non_exhaustive_enum.rs:5:1
    |
 LL |   enum E {
    |   ^-----
@@ -15,13 +15,13 @@ LL | | }
    |
    = note: `-D clippy::manual-non-exhaustive` implied by `-D warnings`
 help: remove this variant
-  --> $DIR/manual_non_exhaustive_enum.rs:8:5
+  --> $DIR/manual_non_exhaustive_enum.rs:9:5
    |
 LL |     _C,
    |     ^^
 
 error: this seems like a manual implementation of the non-exhaustive pattern
-  --> $DIR/manual_non_exhaustive_enum.rs:13:1
+  --> $DIR/manual_non_exhaustive_enum.rs:14:1
    |
 LL | / enum Ep {
 LL | |     A,
@@ -32,7 +32,7 @@ LL | | }
    | |_^
    |
 help: remove this variant
-  --> $DIR/manual_non_exhaustive_enum.rs:17:5
+  --> $DIR/manual_non_exhaustive_enum.rs:18:5
    |
 LL |     _C,
    |     ^^
-- 
cgit 1.4.1-3-g733a5


From 3a31ef7456eed7c901acdb82f91ac1eeb0a84f46 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Sat, 25 Jun 2022 14:53:54 +0200
Subject: Give clippy some Dogfood to make it happy =^.^=

---
 clippy_lints/src/ptr.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs
index 8f729feb090..dd01e4317a4 100644
--- a/clippy_lints/src/ptr.rs
+++ b/clippy_lints/src/ptr.rs
@@ -474,7 +474,7 @@ fn check_fn_args<'cx, 'tcx: 'cx>(
                     };
                     return Some(PtrArg {
                         idx: i,
-                        emission_id: emission_id,
+                        emission_id,
                         span: hir_ty.span,
                         ty_did: adt.did(),
                         ty_name: name.ident.name,
-- 
cgit 1.4.1-3-g733a5


From bf317a83cf2c409548168a13f243973389bbb851 Mon Sep 17 00:00:00 2001
From: kyoto7250 <50972773+kyoto7250@users.noreply.github.com>
Date: Sun, 26 Jun 2022 15:55:44 +0900
Subject: treat argument as a slice.

Co-authored-by: llogiq <bogusandre@gmail.com>
---
 clippy_lints/src/enum_variants.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/enum_variants.rs b/clippy_lints/src/enum_variants.rs
index 517e11b4e6b..99d5da2c2cc 100644
--- a/clippy_lints/src/enum_variants.rs
+++ b/clippy_lints/src/enum_variants.rs
@@ -213,7 +213,7 @@ fn check_variant(cx: &LateContext<'_>, threshold: u64, def: &EnumDef<'_>, item_n
 }
 
 #[must_use]
-fn have_no_extra_prefix(prefixes: &Vec<&str>) -> bool {
+fn have_no_extra_prefix(prefixes: &[&str]) -> bool {
     prefixes.is_empty() || prefixes.join("") == "_"
 }
 
-- 
cgit 1.4.1-3-g733a5


From d827b834d91383620d587fb4a1e74d8579e3a280 Mon Sep 17 00:00:00 2001
From: kyoto7250 <50972773+kyoto7250@users.noreply.github.com>
Date: Sun, 26 Jun 2022 16:11:04 +0900
Subject: use all instead of join

---
 clippy_lints/src/enum_variants.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/enum_variants.rs b/clippy_lints/src/enum_variants.rs
index 99d5da2c2cc..cd36f9fcd72 100644
--- a/clippy_lints/src/enum_variants.rs
+++ b/clippy_lints/src/enum_variants.rs
@@ -214,7 +214,7 @@ fn check_variant(cx: &LateContext<'_>, threshold: u64, def: &EnumDef<'_>, item_n
 
 #[must_use]
 fn have_no_extra_prefix(prefixes: &[&str]) -> bool {
-    prefixes.is_empty() || prefixes.join("") == "_"
+    prefixes.iter().all(|p| p == &"" || p == &"_")
 }
 
 #[must_use]
-- 
cgit 1.4.1-3-g733a5


From 4065702b1fa6f6dc990d8bbe21da1b81885138e4 Mon Sep 17 00:00:00 2001
From: alexey semenyuk <alexsemenyuk88@gmail.com>
Date: Sun, 26 Jun 2022 11:14:37 +0300
Subject: STRING_ADD example

---
 clippy_lints/src/strings.rs | 6 ++++++
 1 file changed, 6 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/strings.rs b/clippy_lints/src/strings.rs
index 71f3e6b6a6e..3f9f56c451a 100644
--- a/clippy_lints/src/strings.rs
+++ b/clippy_lints/src/strings.rs
@@ -60,6 +60,12 @@ declare_clippy_lint! {
     /// let x = "Hello".to_owned();
     /// x + ", World";
     /// ```
+    ///
+    /// Use instead:
+    /// ```rust
+    /// let x = "Hello".to_owned();
+    /// x.push_str(", World");
+    /// ```
     #[clippy::version = "pre 1.29.0"]
     pub STRING_ADD,
     restriction,
-- 
cgit 1.4.1-3-g733a5


From 16919143e449336d8b64d2bb5eb25811f2897d3c Mon Sep 17 00:00:00 2001
From: alexey semenyuk <alexsemenyuk88@gmail.com>
Date: Sun, 26 Jun 2022 08:36:50 +0000
Subject: STRING_ADD example

---
 clippy_lints/src/strings.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/strings.rs b/clippy_lints/src/strings.rs
index 3f9f56c451a..eb704a07451 100644
--- a/clippy_lints/src/strings.rs
+++ b/clippy_lints/src/strings.rs
@@ -63,7 +63,7 @@ declare_clippy_lint! {
     ///
     /// Use instead:
     /// ```rust
-    /// let x = "Hello".to_owned();
+    /// let mut x = "Hello".to_owned();
     /// x.push_str(", World");
     /// ```
     #[clippy::version = "pre 1.29.0"]
-- 
cgit 1.4.1-3-g733a5


From 5f2b8e67b3ab5f700e9076c3a0bba8bc2ed4a7f1 Mon Sep 17 00:00:00 2001
From: kyoto7250 <50972773+kyoto7250@users.noreply.github.com>
Date: Tue, 7 Jun 2022 12:11:33 +0900
Subject: feat(new lint): new lint `use_retain`

---
 CHANGELOG.md                           |   1 +
 clippy_lints/src/lib.register_all.rs   |   1 +
 clippy_lints/src/lib.register_lints.rs |   1 +
 clippy_lints/src/lib.register_style.rs |   1 +
 clippy_lints/src/lib.rs                |   2 +
 clippy_lints/src/use_retain.rs         | 233 +++++++++++++++++++++++++++++++++
 clippy_utils/src/paths.rs              |   9 ++
 tests/ui/use_retain.fixed              | 184 ++++++++++++++++++++++++++
 tests/ui/use_retain.rs                 | 190 +++++++++++++++++++++++++++
 tests/ui/use_retain.stderr             | 100 ++++++++++++++
 10 files changed, 722 insertions(+)
 create mode 100644 clippy_lints/src/use_retain.rs
 create mode 100644 tests/ui/use_retain.fixed
 create mode 100644 tests/ui/use_retain.rs
 create mode 100644 tests/ui/use_retain.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index dcc96bc10b8..56143e1cdb9 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3840,6 +3840,7 @@ Released 2018-09-13
 [`unwrap_used`]: https://rust-lang.github.io/rust-clippy/master/index.html#unwrap_used
 [`upper_case_acronyms`]: https://rust-lang.github.io/rust-clippy/master/index.html#upper_case_acronyms
 [`use_debug`]: https://rust-lang.github.io/rust-clippy/master/index.html#use_debug
+[`use_retain`]: https://rust-lang.github.io/rust-clippy/master/index.html#use_retain
 [`use_self`]: https://rust-lang.github.io/rust-clippy/master/index.html#use_self
 [`used_underscore_binding`]: https://rust-lang.github.io/rust-clippy/master/index.html#used_underscore_binding
 [`useless_asref`]: https://rust-lang.github.io/rust-clippy/master/index.html#useless_asref
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index a1565255b0b..88e4c291b68 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -336,6 +336,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(unwrap::PANICKING_UNWRAP),
     LintId::of(unwrap::UNNECESSARY_UNWRAP),
     LintId::of(upper_case_acronyms::UPPER_CASE_ACRONYMS),
+    LintId::of(use_retain::USE_RETAIN),
     LintId::of(useless_conversion::USELESS_CONVERSION),
     LintId::of(vec::USELESS_VEC),
     LintId::of(vec_init_then_push::VEC_INIT_THEN_PUSH),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index f706ba0620f..187786e80da 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -563,6 +563,7 @@ store.register_lints(&[
     unwrap::UNNECESSARY_UNWRAP,
     unwrap_in_result::UNWRAP_IN_RESULT,
     upper_case_acronyms::UPPER_CASE_ACRONYMS,
+    use_retain::USE_RETAIN,
     use_self::USE_SELF,
     useless_conversion::USELESS_CONVERSION,
     vec::USELESS_VEC,
diff --git a/clippy_lints/src/lib.register_style.rs b/clippy_lints/src/lib.register_style.rs
index d52ec50e542..3b3505f1e19 100644
--- a/clippy_lints/src/lib.register_style.rs
+++ b/clippy_lints/src/lib.register_style.rs
@@ -117,6 +117,7 @@ store.register_group(true, "clippy::style", Some("clippy_style"), vec![
     LintId::of(unsafe_removed_from_name::UNSAFE_REMOVED_FROM_NAME),
     LintId::of(unused_unit::UNUSED_UNIT),
     LintId::of(upper_case_acronyms::UPPER_CASE_ACRONYMS),
+    LintId::of(use_retain::USE_RETAIN),
     LintId::of(write::PRINTLN_EMPTY_STRING),
     LintId::of(write::PRINT_LITERAL),
     LintId::of(write::PRINT_WITH_NEWLINE),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 70cf6be8b7c..124f0d12b08 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -410,6 +410,7 @@ mod unused_unit;
 mod unwrap;
 mod unwrap_in_result;
 mod upper_case_acronyms;
+mod use_retain;
 mod use_self;
 mod useless_conversion;
 mod vec;
@@ -914,6 +915,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(read_zero_byte_vec::ReadZeroByteVec));
     store.register_late_pass(|| Box::new(default_instead_of_iter_empty::DefaultIterEmpty));
     store.register_late_pass(move || Box::new(manual_rem_euclid::ManualRemEuclid::new(msrv)));
+    store.register_late_pass(|| Box::new(use_retain::UseRetain));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/use_retain.rs b/clippy_lints/src/use_retain.rs
new file mode 100644
index 00000000000..ffe2786ee09
--- /dev/null
+++ b/clippy_lints/src/use_retain.rs
@@ -0,0 +1,233 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet;
+use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::{get_parent_expr, match_def_path, paths, SpanlessEq};
+use rustc_errors::Applicability;
+use rustc_hir as hir;
+use rustc_hir::def_id::DefId;
+use rustc_hir::ExprKind::Assign;
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::symbol::sym;
+
+const ACCEPTABLE_METHODS: [&[&str]; 4] = [
+    &paths::HASHSET_ITER,
+    &paths::BTREESET_ITER,
+    &paths::SLICE_INTO,
+    &paths::VEC_DEQUE_ITER,
+];
+const ACCEPTABLE_TYPES: [rustc_span::Symbol; 6] = [
+    sym::BTreeSet,
+    sym::BTreeMap,
+    sym::HashSet,
+    sym::HashMap,
+    sym::Vec,
+    sym::VecDeque,
+];
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for code to be replaced by `.retain()`.
+    /// ### Why is this bad?
+    /// `.retain()` is simpler.
+    /// ### Example
+    /// ```rust
+    /// let mut vec = vec![0, 1, 2];
+    /// vec = vec.iter().filter(|&x| x % 2 == 0).copied().collect();
+    /// vec = vec.into_iter().filter(|x| x % 2 == 0).collect();
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// let mut vec = vec![0, 1, 2];
+    /// vec.retain(|x| x % 2 == 0);
+    /// ```
+    #[clippy::version = "1.63.0"]
+    pub USE_RETAIN,
+    style,
+    "`retain()` is simpler and the same functionalitys"
+}
+declare_lint_pass!(UseRetain => [USE_RETAIN]);
+
+impl<'tcx> LateLintPass<'tcx> for UseRetain {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
+        if_chain! {
+            if let Some(parent_expr) = get_parent_expr(cx, expr);
+            if let Assign(left_expr, collect_expr, _) = &parent_expr.kind;
+            if let hir::ExprKind::MethodCall(seg, _, _) = &collect_expr.kind;
+            if seg.args.is_none();
+
+            if let hir::ExprKind::MethodCall(_, [target_expr], _) = &collect_expr.kind;
+            if let Some(collect_def_id) = cx.typeck_results().type_dependent_def_id(collect_expr.hir_id);
+            if match_def_path(cx, collect_def_id, &paths::CORE_ITER_COLLECT);
+
+            then {
+                check_into_iter(cx, parent_expr, left_expr, target_expr);
+                check_iter(cx, parent_expr, left_expr, target_expr);
+                check_to_owned(cx, parent_expr, left_expr, target_expr);
+            }
+        }
+    }
+}
+
+fn check_into_iter(
+    cx: &LateContext<'_>,
+    parent_expr: &hir::Expr<'_>,
+    left_expr: &hir::Expr<'_>,
+    target_expr: &hir::Expr<'_>,
+) {
+    if_chain! {
+        if let hir::ExprKind::MethodCall(_, [into_iter_expr, _], _) = &target_expr.kind;
+        if let Some(filter_def_id) = cx.typeck_results().type_dependent_def_id(target_expr.hir_id);
+        if match_def_path(cx, filter_def_id, &paths::CORE_ITER_FILTER);
+
+        if let hir::ExprKind::MethodCall(_, [struct_expr], _) = &into_iter_expr.kind;
+        if let Some(into_iter_def_id) = cx.typeck_results().type_dependent_def_id(into_iter_expr.hir_id);
+        if match_def_path(cx, into_iter_def_id, &paths::CORE_ITER_INTO_ITER);
+        if match_acceptable_type(cx, left_expr);
+
+        if SpanlessEq::new(cx).eq_expr(left_expr, struct_expr);
+
+        then {
+            suggest(cx, parent_expr, left_expr, target_expr);
+        }
+    }
+}
+
+fn check_iter(
+    cx: &LateContext<'_>,
+    parent_expr: &hir::Expr<'_>,
+    left_expr: &hir::Expr<'_>,
+    target_expr: &hir::Expr<'_>,
+) {
+    if_chain! {
+        if let hir::ExprKind::MethodCall(_, [filter_expr], _) = &target_expr.kind;
+        if let Some(copied_def_id) = cx.typeck_results().type_dependent_def_id(target_expr.hir_id);
+        if match_def_path(cx, copied_def_id, &paths::CORE_ITER_COPIED);
+
+        if let hir::ExprKind::MethodCall(_, [iter_expr, _], _) = &filter_expr.kind;
+        if let Some(filter_def_id) = cx.typeck_results().type_dependent_def_id(filter_expr.hir_id);
+        if match_def_path(cx, filter_def_id, &paths::CORE_ITER_FILTER);
+
+        if let hir::ExprKind::MethodCall(_, [struct_expr], _) = &iter_expr.kind;
+        if let Some(iter_expr_def_id) = cx.typeck_results().type_dependent_def_id(iter_expr.hir_id);
+        if match_acceptable_def_path(cx, iter_expr_def_id);
+        if match_acceptable_type(cx, left_expr);
+        if SpanlessEq::new(cx).eq_expr(left_expr, struct_expr);
+
+        then {
+            suggest(cx, parent_expr, left_expr, filter_expr);
+        }
+    }
+}
+
+fn check_to_owned(
+    cx: &LateContext<'_>,
+    parent_expr: &hir::Expr<'_>,
+    left_expr: &hir::Expr<'_>,
+    target_expr: &hir::Expr<'_>,
+) {
+    if_chain! {
+        if let hir::ExprKind::MethodCall(_, [filter_expr], _) = &target_expr.kind;
+        if let Some(to_owned_def_id) = cx.typeck_results().type_dependent_def_id(target_expr.hir_id);
+        if match_def_path(cx, to_owned_def_id, &paths::TO_OWNED_METHOD);
+
+        if let hir::ExprKind::MethodCall(_, [chars_expr, _], _) = &filter_expr.kind;
+        if let Some(filter_def_id) = cx.typeck_results().type_dependent_def_id(filter_expr.hir_id);
+        if match_def_path(cx, filter_def_id, &paths::CORE_ITER_FILTER);
+
+        if let hir::ExprKind::MethodCall(_, [str_expr], _) = &chars_expr.kind;
+        if let Some(chars_expr_def_id) = cx.typeck_results().type_dependent_def_id(chars_expr.hir_id);
+        if match_def_path(cx, chars_expr_def_id, &paths::STR_CHARS);
+
+        let ty = cx.typeck_results().expr_ty(str_expr).peel_refs();
+        if is_type_diagnostic_item(cx, ty, sym::String);
+        if SpanlessEq::new(cx).eq_expr(left_expr, str_expr);
+
+        then {
+            suggest(cx, parent_expr, left_expr, filter_expr);
+        }
+    }
+}
+
+fn suggest(cx: &LateContext<'_>, parent_expr: &hir::Expr<'_>, left_expr: &hir::Expr<'_>, filter_expr: &hir::Expr<'_>) {
+    if_chain! {
+        if let hir::ExprKind::MethodCall(_, [_, closure], _) = filter_expr.kind;
+        if let hir::ExprKind::Closure(_, _, filter_body_id, ..) = closure.kind;
+        let filter_body = cx.tcx.hir().body(filter_body_id);
+        if let [filter_params] = filter_body.params;
+        if let Some(sugg) = match filter_params.pat.kind {
+            hir::PatKind::Binding(_, _, filter_param_ident, None) => {
+                Some(format!("{}.retain(|{}| {})", snippet(cx, left_expr.span, ".."), filter_param_ident, snippet(cx, filter_body.value.span, "..")))
+            },
+            hir::PatKind::Tuple([key_pat, value_pat], _) => {
+                make_sugg(cx, key_pat, value_pat, left_expr, filter_body)
+            },
+            hir::PatKind::Ref(pat, _) => {
+                match pat.kind {
+                    hir::PatKind::Binding(_, _, filter_param_ident, None) => {
+                        Some(format!("{}.retain(|{}| {})", snippet(cx, left_expr.span, ".."), filter_param_ident, snippet(cx, filter_body.value.span, "..")))
+                    },
+                    _ => None
+                }
+            },
+            _ => None
+        };
+        then {
+            span_lint_and_sugg(
+                cx,
+                USE_RETAIN,
+                parent_expr.span,
+                "this expression can be written more simply using `.retain()`",
+                "consider calling `.retain()` instead",
+                sugg,
+                Applicability::MachineApplicable
+            );
+        }
+    }
+}
+
+fn make_sugg(
+    cx: &LateContext<'_>,
+    key_pat: &rustc_hir::Pat<'_>,
+    value_pat: &rustc_hir::Pat<'_>,
+    left_expr: &hir::Expr<'_>,
+    filter_body: &hir::Body<'_>,
+) -> Option<String> {
+    match (&key_pat.kind, &value_pat.kind) {
+        (hir::PatKind::Binding(_, _, key_param_ident, None), hir::PatKind::Binding(_, _, value_param_ident, None)) => {
+            Some(format!(
+                "{}.retain(|{}, &mut {}| {})",
+                snippet(cx, left_expr.span, ".."),
+                key_param_ident,
+                value_param_ident,
+                snippet(cx, filter_body.value.span, "..")
+            ))
+        },
+        (hir::PatKind::Binding(_, _, key_param_ident, None), hir::PatKind::Wild) => Some(format!(
+            "{}.retain(|{}, _| {})",
+            snippet(cx, left_expr.span, ".."),
+            key_param_ident,
+            snippet(cx, filter_body.value.span, "..")
+        )),
+        (hir::PatKind::Wild, hir::PatKind::Binding(_, _, value_param_ident, None)) => Some(format!(
+            "{}.retain(|_, &mut {}| {})",
+            snippet(cx, left_expr.span, ".."),
+            value_param_ident,
+            snippet(cx, filter_body.value.span, "..")
+        )),
+        _ => None,
+    }
+}
+
+fn match_acceptable_def_path(cx: &LateContext<'_>, collect_def_id: DefId) -> bool {
+    return ACCEPTABLE_METHODS
+        .iter()
+        .any(|&method| match_def_path(cx, collect_def_id, method));
+}
+
+fn match_acceptable_type(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> bool {
+    let expr_ty = cx.typeck_results().expr_ty(expr).peel_refs();
+    return ACCEPTABLE_TYPES
+        .iter()
+        .any(|&ty| is_type_diagnostic_item(cx, expr_ty, ty));
+}
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index b31e2c1cdb1..17cccd43a9c 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -21,8 +21,13 @@ pub const ASREF_TRAIT: [&str; 3] = ["core", "convert", "AsRef"];
 pub const BTREEMAP_CONTAINS_KEY: [&str; 6] = ["alloc", "collections", "btree", "map", "BTreeMap", "contains_key"];
 pub const BTREEMAP_ENTRY: [&str; 6] = ["alloc", "collections", "btree", "map", "entry", "Entry"];
 pub const BTREEMAP_INSERT: [&str; 6] = ["alloc", "collections", "btree", "map", "BTreeMap", "insert"];
+pub const BTREESET_ITER: [&str; 6] = ["alloc", "collections", "btree", "set", "BTreeSet", "iter"];
 pub const CLONE_TRAIT_METHOD: [&str; 4] = ["core", "clone", "Clone", "clone"];
 pub const COW: [&str; 3] = ["alloc", "borrow", "Cow"];
+pub const CORE_ITER_COLLECT: [&str; 6] = ["core", "iter", "traits", "iterator", "Iterator", "collect"];
+pub const CORE_ITER_COPIED: [&str; 6] = ["core", "iter", "traits", "iterator", "Iterator", "copied"];
+pub const CORE_ITER_FILTER: [&str; 6] = ["core", "iter", "traits", "iterator", "Iterator", "filter"];
+pub const CORE_ITER_INTO_ITER: [&str; 6] = ["core", "iter", "traits", "collect", "IntoIterator", "into_iter"];
 pub const CSTRING_AS_C_STR: [&str; 5] = ["alloc", "ffi", "c_str", "CString", "as_c_str"];
 pub const DEFAULT_TRAIT_METHOD: [&str; 4] = ["core", "default", "Default", "default"];
 pub const DEREF_MUT_TRAIT_METHOD: [&str; 5] = ["core", "ops", "deref", "DerefMut", "deref_mut"];
@@ -50,6 +55,7 @@ pub const FUTURES_IO_ASYNCWRITEEXT: [&str; 3] = ["futures_util", "io", "AsyncWri
 pub const HASHMAP_CONTAINS_KEY: [&str; 6] = ["std", "collections", "hash", "map", "HashMap", "contains_key"];
 pub const HASHMAP_ENTRY: [&str; 5] = ["std", "collections", "hash", "map", "Entry"];
 pub const HASHMAP_INSERT: [&str; 6] = ["std", "collections", "hash", "map", "HashMap", "insert"];
+pub const HASHSET_ITER: [&str; 6] = ["std", "collections", "hash", "set", "HashSet", "iter"];
 #[cfg(feature = "internal")]
 pub const IDENT: [&str; 3] = ["rustc_span", "symbol", "Ident"];
 #[cfg(feature = "internal")]
@@ -145,6 +151,7 @@ pub const SLICE_FROM_RAW_PARTS: [&str; 4] = ["core", "slice", "raw", "from_raw_p
 pub const SLICE_FROM_RAW_PARTS_MUT: [&str; 4] = ["core", "slice", "raw", "from_raw_parts_mut"];
 pub const SLICE_GET: [&str; 4] = ["core", "slice", "<impl [T]>", "get"];
 pub const SLICE_INTO_VEC: [&str; 4] = ["alloc", "slice", "<impl [T]>", "into_vec"];
+pub const SLICE_INTO: [&str; 4] = ["core", "slice", "<impl [T]>", "iter"];
 pub const SLICE_ITER: [&str; 4] = ["core", "slice", "iter", "Iter"];
 pub const STDERR: [&str; 4] = ["std", "io", "stdio", "stderr"];
 pub const STDOUT: [&str; 4] = ["std", "io", "stdio", "stdout"];
@@ -154,6 +161,7 @@ pub const STRING_AS_MUT_STR: [&str; 4] = ["alloc", "string", "String", "as_mut_s
 pub const STRING_AS_STR: [&str; 4] = ["alloc", "string", "String", "as_str"];
 pub const STRING_NEW: [&str; 4] = ["alloc", "string", "String", "new"];
 pub const STR_BYTES: [&str; 4] = ["core", "str", "<impl str>", "bytes"];
+pub const STR_CHARS: [&str; 4] = ["core", "str", "<impl str>", "chars"];
 pub const STR_ENDS_WITH: [&str; 4] = ["core", "str", "<impl str>", "ends_with"];
 pub const STR_FROM_UTF8: [&str; 4] = ["core", "str", "converts", "from_utf8"];
 pub const STR_LEN: [&str; 4] = ["core", "str", "<impl str>", "len"];
@@ -179,6 +187,7 @@ pub const TOKIO_IO_ASYNCWRITEEXT: [&str; 5] = ["tokio", "io", "util", "async_wri
 pub const TRY_FROM: [&str; 4] = ["core", "convert", "TryFrom", "try_from"];
 pub const VEC_AS_MUT_SLICE: [&str; 4] = ["alloc", "vec", "Vec", "as_mut_slice"];
 pub const VEC_AS_SLICE: [&str; 4] = ["alloc", "vec", "Vec", "as_slice"];
+pub const VEC_DEQUE_ITER: [&str; 5] = ["alloc", "collections", "vec_deque", "VecDeque", "iter"];
 pub const VEC_FROM_ELEM: [&str; 3] = ["alloc", "vec", "from_elem"];
 pub const VEC_NEW: [&str; 4] = ["alloc", "vec", "Vec", "new"];
 pub const VEC_RESIZE: [&str; 4] = ["alloc", "vec", "Vec", "resize"];
diff --git a/tests/ui/use_retain.fixed b/tests/ui/use_retain.fixed
new file mode 100644
index 00000000000..d24571b36f8
--- /dev/null
+++ b/tests/ui/use_retain.fixed
@@ -0,0 +1,184 @@
+// run-rustfix
+#![warn(clippy::use_retain)]
+#![allow(unused)]
+use std::collections::BTreeMap;
+use std::collections::BTreeSet;
+use std::collections::BinaryHeap;
+use std::collections::HashMap;
+use std::collections::HashSet;
+use std::collections::VecDeque;
+
+fn main() {
+    binary_heap_retain();
+    btree_set_retain();
+    btree_map_retain();
+    hash_set_retain();
+    hash_map_retain();
+    string_retain();
+    vec_queue_retain();
+    vec_retain();
+}
+
+fn binary_heap_retain() {
+    // NOTE: Do not lint now, because binary_heap_retain is nighyly API.
+    // https://github.com/rust-lang/rust/issues/71503
+    let mut heap = BinaryHeap::from([1, 2, 3]);
+    heap = heap.into_iter().filter(|x| x % 2 == 0).collect();
+    heap = heap.iter().filter(|&x| x % 2 == 0).copied().collect();
+
+    // Do not lint, because type conversion is performed
+    heap = heap.into_iter().filter(|x| x % 2 == 0).collect::<BinaryHeap<i8>>();
+    heap = heap.iter().filter(|&x| x % 2 == 0).copied().collect::<BinaryHeap<i8>>();
+
+    // Do not lint, because this expression is not assign.
+    let mut bar: BinaryHeap<i8> = heap.iter().filter(|&x| x % 2 == 0).copied().collect();
+    let mut foobar: BinaryHeap<i8> = heap.into_iter().filter(|x| x % 2 == 0).collect();
+
+    // Do not lint, because it is an assignment to a different variable.
+    bar = foobar.iter().filter(|&x| x % 2 == 0).copied().collect();
+    bar = foobar.into_iter().filter(|x| x % 2 == 0).collect();
+}
+
+fn btree_map_retain() {
+    let mut btree_map: BTreeMap<i8, i8> = (0..8).map(|x| (x, x * 10)).collect();
+    // Do lint.
+    btree_map.retain(|k, _| k % 2 == 0);
+    btree_map.retain(|_, &mut v| v % 2 == 0);
+    btree_map.retain(|k, &mut v| (k % 2 == 0) && (v % 2 == 0));
+
+    // Do not lint.
+    btree_map = btree_map
+        .into_iter()
+        .filter(|(x, _)| x % 2 == 0)
+        .collect::<BTreeMap<i8, i8>>();
+
+    // Do not lint, because this expression is not assign.
+    let mut foobar: BTreeMap<i8, i8> = btree_map.into_iter().filter(|(k, _)| k % 2 == 0).collect();
+
+    // Do not lint, because it is an assignment to a different variable.
+    btree_map = foobar.into_iter().filter(|(k, _)| k % 2 == 0).collect();
+}
+
+fn btree_set_retain() {
+    let mut btree_set = BTreeSet::from([1, 2, 3, 4, 5, 6]);
+
+    // Do lint.
+    btree_set.retain(|x| x % 2 == 0);
+    btree_set.retain(|x| x % 2 == 0);
+
+    // Do not lint, because type conversion is performed
+    btree_set = btree_set
+        .iter()
+        .filter(|&x| x % 2 == 0)
+        .copied()
+        .collect::<BTreeSet<i8>>();
+
+    btree_set = btree_set.into_iter().filter(|x| x % 2 == 0).collect::<BTreeSet<i8>>();
+
+    // Do not lint, because this expression is not assign.
+    let mut foobar: BTreeSet<i8> = btree_set.iter().filter(|&x| x % 2 == 0).copied().collect();
+    let mut bar: BTreeSet<i8> = btree_set.into_iter().filter(|x| x % 2 == 0).collect();
+
+    // Do not lint, because it is an assignment to a different variable.
+    bar = foobar.iter().filter(|&x| x % 2 == 0).copied().collect();
+    bar = foobar.into_iter().filter(|x| x % 2 == 0).collect();
+}
+
+fn hash_map_retain() {
+    let mut hash_map: HashMap<i8, i8> = (0..8).map(|x| (x, x * 10)).collect();
+    // Do lint.
+    hash_map.retain(|k, _| k % 2 == 0);
+    hash_map.retain(|_, &mut v| v % 2 == 0);
+    hash_map.retain(|k, &mut v| (k % 2 == 0) && (v % 2 == 0));
+
+    // Do not lint.
+    hash_map = hash_map
+        .into_iter()
+        .filter(|(x, _)| x % 2 == 0)
+        .collect::<HashMap<i8, i8>>();
+
+    // Do not lint, because this expression is not assign.
+    let mut foobar: HashMap<i8, i8> = hash_map.into_iter().filter(|(k, _)| k % 2 == 0).collect();
+
+    // Do not lint, because it is an assignment to a different variable.
+    hash_map = foobar.into_iter().filter(|(k, _)| k % 2 == 0).collect();
+}
+
+fn hash_set_retain() {
+    let mut hash_set = HashSet::from([1, 2, 3, 4, 5, 6]);
+    // Do lint.
+    hash_set.retain(|x| x % 2 == 0);
+    hash_set.retain(|x| x % 2 == 0);
+
+    // Do not lint, because type conversion is performed
+    hash_set = hash_set.into_iter().filter(|x| x % 2 == 0).collect::<HashSet<i8>>();
+    hash_set = hash_set
+        .iter()
+        .filter(|&x| x % 2 == 0)
+        .copied()
+        .collect::<HashSet<i8>>();
+
+    // Do not lint, because this expression is not assign.
+    let mut bar: HashSet<i8> = hash_set.iter().filter(|&x| x % 2 == 0).copied().collect();
+    let mut foobar: HashSet<i8> = hash_set.into_iter().filter(|x| x % 2 == 0).collect();
+
+    // Do not lint, because it is an assignment to a different variable.
+    bar = foobar.iter().filter(|&x| x % 2 == 0).copied().collect();
+    bar = foobar.into_iter().filter(|&x| x % 2 == 0).collect();
+}
+
+fn string_retain() {
+    let mut s = String::from("foobar");
+    // Do lint.
+    s.retain(|c| c != 'o');
+
+    // Do not lint, because this expression is not assign.
+    let mut bar: String = s.chars().filter(|&c| c != 'o').to_owned().collect();
+
+    // Do not lint, because it is an assignment to a different variable.
+    s = bar.chars().filter(|&c| c != 'o').to_owned().collect();
+}
+
+fn vec_retain() {
+    let mut vec = vec![0, 1, 2];
+    // Do lint.
+    vec.retain(|x| x % 2 == 0);
+    vec.retain(|x| x % 2 == 0);
+
+    // Do not lint, because type conversion is performed
+    vec = vec.into_iter().filter(|x| x % 2 == 0).collect::<Vec<i8>>();
+    vec = vec.iter().filter(|&x| x % 2 == 0).copied().collect::<Vec<i8>>();
+
+    // Do not lint, because this expression is not assign.
+    let mut bar: Vec<i8> = vec.iter().filter(|&x| x % 2 == 0).copied().collect();
+    let mut foobar: Vec<i8> = vec.into_iter().filter(|x| x % 2 == 0).collect();
+
+    // Do not lint, because it is an assignment to a different variable.
+    bar = foobar.iter().filter(|&x| x % 2 == 0).copied().collect();
+    bar = foobar.into_iter().filter(|x| x % 2 == 0).collect();
+}
+
+fn vec_queue_retain() {
+    let mut vec_deque = VecDeque::new();
+    vec_deque.extend(1..5);
+
+    // Do lint.
+    vec_deque.retain(|x| x % 2 == 0);
+    vec_deque.retain(|x| x % 2 == 0);
+
+    // Do not lint, because type conversion is performed
+    vec_deque = vec_deque
+        .iter()
+        .filter(|&x| x % 2 == 0)
+        .copied()
+        .collect::<VecDeque<i8>>();
+    vec_deque = vec_deque.into_iter().filter(|x| x % 2 == 0).collect::<VecDeque<i8>>();
+
+    // Do not lint, because this expression is not assign.
+    let mut bar: VecDeque<i8> = vec_deque.iter().filter(|&x| x % 2 == 0).copied().collect();
+    let mut foobar: VecDeque<i8> = vec_deque.into_iter().filter(|x| x % 2 == 0).collect();
+
+    // Do not lint, because it is an assignment to a different variable.
+    bar = foobar.iter().filter(|&x| x % 2 == 0).copied().collect();
+    bar = foobar.into_iter().filter(|x| x % 2 == 0).collect();
+}
diff --git a/tests/ui/use_retain.rs b/tests/ui/use_retain.rs
new file mode 100644
index 00000000000..4a51825c95f
--- /dev/null
+++ b/tests/ui/use_retain.rs
@@ -0,0 +1,190 @@
+// run-rustfix
+#![warn(clippy::use_retain)]
+#![allow(unused)]
+use std::collections::BTreeMap;
+use std::collections::BTreeSet;
+use std::collections::BinaryHeap;
+use std::collections::HashMap;
+use std::collections::HashSet;
+use std::collections::VecDeque;
+
+fn main() {
+    binary_heap_retain();
+    btree_set_retain();
+    btree_map_retain();
+    hash_set_retain();
+    hash_map_retain();
+    string_retain();
+    vec_queue_retain();
+    vec_retain();
+}
+
+fn binary_heap_retain() {
+    // NOTE: Do not lint now, because binary_heap_retain is nighyly API.
+    // https://github.com/rust-lang/rust/issues/71503
+    let mut heap = BinaryHeap::from([1, 2, 3]);
+    heap = heap.into_iter().filter(|x| x % 2 == 0).collect();
+    heap = heap.iter().filter(|&x| x % 2 == 0).copied().collect();
+
+    // Do not lint, because type conversion is performed
+    heap = heap.into_iter().filter(|x| x % 2 == 0).collect::<BinaryHeap<i8>>();
+    heap = heap.iter().filter(|&x| x % 2 == 0).copied().collect::<BinaryHeap<i8>>();
+
+    // Do not lint, because this expression is not assign.
+    let mut bar: BinaryHeap<i8> = heap.iter().filter(|&x| x % 2 == 0).copied().collect();
+    let mut foobar: BinaryHeap<i8> = heap.into_iter().filter(|x| x % 2 == 0).collect();
+
+    // Do not lint, because it is an assignment to a different variable.
+    bar = foobar.iter().filter(|&x| x % 2 == 0).copied().collect();
+    bar = foobar.into_iter().filter(|x| x % 2 == 0).collect();
+}
+
+fn btree_map_retain() {
+    let mut btree_map: BTreeMap<i8, i8> = (0..8).map(|x| (x, x * 10)).collect();
+    // Do lint.
+    btree_map = btree_map.into_iter().filter(|(k, _)| k % 2 == 0).collect();
+    btree_map = btree_map.into_iter().filter(|(_, v)| v % 2 == 0).collect();
+    btree_map = btree_map
+        .into_iter()
+        .filter(|(k, v)| (k % 2 == 0) && (v % 2 == 0))
+        .collect();
+
+    // Do not lint.
+    btree_map = btree_map
+        .into_iter()
+        .filter(|(x, _)| x % 2 == 0)
+        .collect::<BTreeMap<i8, i8>>();
+
+    // Do not lint, because this expression is not assign.
+    let mut foobar: BTreeMap<i8, i8> = btree_map.into_iter().filter(|(k, _)| k % 2 == 0).collect();
+
+    // Do not lint, because it is an assignment to a different variable.
+    btree_map = foobar.into_iter().filter(|(k, _)| k % 2 == 0).collect();
+}
+
+fn btree_set_retain() {
+    let mut btree_set = BTreeSet::from([1, 2, 3, 4, 5, 6]);
+
+    // Do lint.
+    btree_set = btree_set.iter().filter(|&x| x % 2 == 0).copied().collect();
+    btree_set = btree_set.into_iter().filter(|x| x % 2 == 0).collect();
+
+    // Do not lint, because type conversion is performed
+    btree_set = btree_set
+        .iter()
+        .filter(|&x| x % 2 == 0)
+        .copied()
+        .collect::<BTreeSet<i8>>();
+
+    btree_set = btree_set.into_iter().filter(|x| x % 2 == 0).collect::<BTreeSet<i8>>();
+
+    // Do not lint, because this expression is not assign.
+    let mut foobar: BTreeSet<i8> = btree_set.iter().filter(|&x| x % 2 == 0).copied().collect();
+    let mut bar: BTreeSet<i8> = btree_set.into_iter().filter(|x| x % 2 == 0).collect();
+
+    // Do not lint, because it is an assignment to a different variable.
+    bar = foobar.iter().filter(|&x| x % 2 == 0).copied().collect();
+    bar = foobar.into_iter().filter(|x| x % 2 == 0).collect();
+}
+
+fn hash_map_retain() {
+    let mut hash_map: HashMap<i8, i8> = (0..8).map(|x| (x, x * 10)).collect();
+    // Do lint.
+    hash_map = hash_map.into_iter().filter(|(k, _)| k % 2 == 0).collect();
+    hash_map = hash_map.into_iter().filter(|(_, v)| v % 2 == 0).collect();
+    hash_map = hash_map
+        .into_iter()
+        .filter(|(k, v)| (k % 2 == 0) && (v % 2 == 0))
+        .collect();
+
+    // Do not lint.
+    hash_map = hash_map
+        .into_iter()
+        .filter(|(x, _)| x % 2 == 0)
+        .collect::<HashMap<i8, i8>>();
+
+    // Do not lint, because this expression is not assign.
+    let mut foobar: HashMap<i8, i8> = hash_map.into_iter().filter(|(k, _)| k % 2 == 0).collect();
+
+    // Do not lint, because it is an assignment to a different variable.
+    hash_map = foobar.into_iter().filter(|(k, _)| k % 2 == 0).collect();
+}
+
+fn hash_set_retain() {
+    let mut hash_set = HashSet::from([1, 2, 3, 4, 5, 6]);
+    // Do lint.
+    hash_set = hash_set.into_iter().filter(|x| x % 2 == 0).collect();
+    hash_set = hash_set.iter().filter(|&x| x % 2 == 0).copied().collect();
+
+    // Do not lint, because type conversion is performed
+    hash_set = hash_set.into_iter().filter(|x| x % 2 == 0).collect::<HashSet<i8>>();
+    hash_set = hash_set
+        .iter()
+        .filter(|&x| x % 2 == 0)
+        .copied()
+        .collect::<HashSet<i8>>();
+
+    // Do not lint, because this expression is not assign.
+    let mut bar: HashSet<i8> = hash_set.iter().filter(|&x| x % 2 == 0).copied().collect();
+    let mut foobar: HashSet<i8> = hash_set.into_iter().filter(|x| x % 2 == 0).collect();
+
+    // Do not lint, because it is an assignment to a different variable.
+    bar = foobar.iter().filter(|&x| x % 2 == 0).copied().collect();
+    bar = foobar.into_iter().filter(|&x| x % 2 == 0).collect();
+}
+
+fn string_retain() {
+    let mut s = String::from("foobar");
+    // Do lint.
+    s = s.chars().filter(|&c| c != 'o').to_owned().collect();
+
+    // Do not lint, because this expression is not assign.
+    let mut bar: String = s.chars().filter(|&c| c != 'o').to_owned().collect();
+
+    // Do not lint, because it is an assignment to a different variable.
+    s = bar.chars().filter(|&c| c != 'o').to_owned().collect();
+}
+
+fn vec_retain() {
+    let mut vec = vec![0, 1, 2];
+    // Do lint.
+    vec = vec.iter().filter(|&x| x % 2 == 0).copied().collect();
+    vec = vec.into_iter().filter(|x| x % 2 == 0).collect();
+
+    // Do not lint, because type conversion is performed
+    vec = vec.into_iter().filter(|x| x % 2 == 0).collect::<Vec<i8>>();
+    vec = vec.iter().filter(|&x| x % 2 == 0).copied().collect::<Vec<i8>>();
+
+    // Do not lint, because this expression is not assign.
+    let mut bar: Vec<i8> = vec.iter().filter(|&x| x % 2 == 0).copied().collect();
+    let mut foobar: Vec<i8> = vec.into_iter().filter(|x| x % 2 == 0).collect();
+
+    // Do not lint, because it is an assignment to a different variable.
+    bar = foobar.iter().filter(|&x| x % 2 == 0).copied().collect();
+    bar = foobar.into_iter().filter(|x| x % 2 == 0).collect();
+}
+
+fn vec_queue_retain() {
+    let mut vec_deque = VecDeque::new();
+    vec_deque.extend(1..5);
+
+    // Do lint.
+    vec_deque = vec_deque.iter().filter(|&x| x % 2 == 0).copied().collect();
+    vec_deque = vec_deque.into_iter().filter(|x| x % 2 == 0).collect();
+
+    // Do not lint, because type conversion is performed
+    vec_deque = vec_deque
+        .iter()
+        .filter(|&x| x % 2 == 0)
+        .copied()
+        .collect::<VecDeque<i8>>();
+    vec_deque = vec_deque.into_iter().filter(|x| x % 2 == 0).collect::<VecDeque<i8>>();
+
+    // Do not lint, because this expression is not assign.
+    let mut bar: VecDeque<i8> = vec_deque.iter().filter(|&x| x % 2 == 0).copied().collect();
+    let mut foobar: VecDeque<i8> = vec_deque.into_iter().filter(|x| x % 2 == 0).collect();
+
+    // Do not lint, because it is an assignment to a different variable.
+    bar = foobar.iter().filter(|&x| x % 2 == 0).copied().collect();
+    bar = foobar.into_iter().filter(|x| x % 2 == 0).collect();
+}
diff --git a/tests/ui/use_retain.stderr b/tests/ui/use_retain.stderr
new file mode 100644
index 00000000000..331259c1626
--- /dev/null
+++ b/tests/ui/use_retain.stderr
@@ -0,0 +1,100 @@
+error: this expression can be written more simply using `.retain()`
+  --> $DIR/use_retain.rs:45:5
+   |
+LL |     btree_map = btree_map.into_iter().filter(|(k, _)| k % 2 == 0).collect();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `btree_map.retain(|k, _| k % 2 == 0)`
+   |
+   = note: `-D clippy::use-retain` implied by `-D warnings`
+
+error: this expression can be written more simply using `.retain()`
+  --> $DIR/use_retain.rs:46:5
+   |
+LL |     btree_map = btree_map.into_iter().filter(|(_, v)| v % 2 == 0).collect();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `btree_map.retain(|_, &mut v| v % 2 == 0)`
+
+error: this expression can be written more simply using `.retain()`
+  --> $DIR/use_retain.rs:47:5
+   |
+LL | /     btree_map = btree_map
+LL | |         .into_iter()
+LL | |         .filter(|(k, v)| (k % 2 == 0) && (v % 2 == 0))
+LL | |         .collect();
+   | |__________________^ help: consider calling `.retain()` instead: `btree_map.retain(|k, &mut v| (k % 2 == 0) && (v % 2 == 0))`
+
+error: this expression can be written more simply using `.retain()`
+  --> $DIR/use_retain.rs:69:5
+   |
+LL |     btree_set = btree_set.iter().filter(|&x| x % 2 == 0).copied().collect();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `btree_set.retain(|x| x % 2 == 0)`
+
+error: this expression can be written more simply using `.retain()`
+  --> $DIR/use_retain.rs:70:5
+   |
+LL |     btree_set = btree_set.into_iter().filter(|x| x % 2 == 0).collect();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `btree_set.retain(|x| x % 2 == 0)`
+
+error: this expression can be written more simply using `.retain()`
+  --> $DIR/use_retain.rs:93:5
+   |
+LL |     hash_map = hash_map.into_iter().filter(|(k, _)| k % 2 == 0).collect();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `hash_map.retain(|k, _| k % 2 == 0)`
+
+error: this expression can be written more simply using `.retain()`
+  --> $DIR/use_retain.rs:94:5
+   |
+LL |     hash_map = hash_map.into_iter().filter(|(_, v)| v % 2 == 0).collect();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `hash_map.retain(|_, &mut v| v % 2 == 0)`
+
+error: this expression can be written more simply using `.retain()`
+  --> $DIR/use_retain.rs:95:5
+   |
+LL | /     hash_map = hash_map
+LL | |         .into_iter()
+LL | |         .filter(|(k, v)| (k % 2 == 0) && (v % 2 == 0))
+LL | |         .collect();
+   | |__________________^ help: consider calling `.retain()` instead: `hash_map.retain(|k, &mut v| (k % 2 == 0) && (v % 2 == 0))`
+
+error: this expression can be written more simply using `.retain()`
+  --> $DIR/use_retain.rs:116:5
+   |
+LL |     hash_set = hash_set.into_iter().filter(|x| x % 2 == 0).collect();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `hash_set.retain(|x| x % 2 == 0)`
+
+error: this expression can be written more simply using `.retain()`
+  --> $DIR/use_retain.rs:117:5
+   |
+LL |     hash_set = hash_set.iter().filter(|&x| x % 2 == 0).copied().collect();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `hash_set.retain(|x| x % 2 == 0)`
+
+error: this expression can be written more simply using `.retain()`
+  --> $DIR/use_retain.rs:139:5
+   |
+LL |     s = s.chars().filter(|&c| c != 'o').to_owned().collect();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `s.retain(|c| c != 'o')`
+
+error: this expression can be written more simply using `.retain()`
+  --> $DIR/use_retain.rs:151:5
+   |
+LL |     vec = vec.iter().filter(|&x| x % 2 == 0).copied().collect();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `vec.retain(|x| x % 2 == 0)`
+
+error: this expression can be written more simply using `.retain()`
+  --> $DIR/use_retain.rs:152:5
+   |
+LL |     vec = vec.into_iter().filter(|x| x % 2 == 0).collect();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `vec.retain(|x| x % 2 == 0)`
+
+error: this expression can be written more simply using `.retain()`
+  --> $DIR/use_retain.rs:172:5
+   |
+LL |     vec_deque = vec_deque.iter().filter(|&x| x % 2 == 0).copied().collect();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `vec_deque.retain(|x| x % 2 == 0)`
+
+error: this expression can be written more simply using `.retain()`
+  --> $DIR/use_retain.rs:173:5
+   |
+LL |     vec_deque = vec_deque.into_iter().filter(|x| x % 2 == 0).collect();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `vec_deque.retain(|x| x % 2 == 0)`
+
+error: aborting due to 15 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From b20b8f10dd1965af7854477eddf16e9bba15eed9 Mon Sep 17 00:00:00 2001
From: kyoto7250 <50972773+kyoto7250@users.noreply.github.com>
Date: Thu, 9 Jun 2022 21:52:40 +0900
Subject: Update clippy_lints/src/use_retain.rs

Co-authored-by: llogiq <bogusandre@gmail.com>
---
 clippy_lints/src/use_retain.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/use_retain.rs b/clippy_lints/src/use_retain.rs
index ffe2786ee09..324ae06106c 100644
--- a/clippy_lints/src/use_retain.rs
+++ b/clippy_lints/src/use_retain.rs
@@ -29,7 +29,7 @@ declare_clippy_lint! {
     /// ### What it does
     /// Checks for code to be replaced by `.retain()`.
     /// ### Why is this bad?
-    /// `.retain()` is simpler.
+    /// `.retain()` is simpler and avoids needless allocation.
     /// ### Example
     /// ```rust
     /// let mut vec = vec![0, 1, 2];
-- 
cgit 1.4.1-3-g733a5


From e3afc72caad1132ecad4ba75fc810a3ad309b49e Mon Sep 17 00:00:00 2001
From: kyoto7250 <50972773+kyoto7250@users.noreply.github.com>
Date: Thu, 9 Jun 2022 22:20:59 +0900
Subject: remove needless return

---
 clippy_lints/src/use_retain.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/use_retain.rs b/clippy_lints/src/use_retain.rs
index 324ae06106c..d2479168ada 100644
--- a/clippy_lints/src/use_retain.rs
+++ b/clippy_lints/src/use_retain.rs
@@ -220,14 +220,14 @@ fn make_sugg(
 }
 
 fn match_acceptable_def_path(cx: &LateContext<'_>, collect_def_id: DefId) -> bool {
-    return ACCEPTABLE_METHODS
+    ACCEPTABLE_METHODS
         .iter()
-        .any(|&method| match_def_path(cx, collect_def_id, method));
+        .any(|&method| match_def_path(cx, collect_def_id, method))
 }
 
 fn match_acceptable_type(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> bool {
     let expr_ty = cx.typeck_results().expr_ty(expr).peel_refs();
-    return ACCEPTABLE_TYPES
+    ACCEPTABLE_TYPES
         .iter()
-        .any(|&ty| is_type_diagnostic_item(cx, expr_ty, ty));
+        .any(|&ty| is_type_diagnostic_item(cx, expr_ty, ty))
 }
-- 
cgit 1.4.1-3-g733a5


From 3953c530f4b2cfbe00864ae824fe4a543066a7f4 Mon Sep 17 00:00:00 2001
From: kyoto7250 <50972773+kyoto7250@users.noreply.github.com>
Date: Thu, 9 Jun 2022 22:25:07 +0900
Subject: change lint type from style to perf

---
 clippy_lints/src/lib.register_perf.rs  | 1 +
 clippy_lints/src/lib.register_style.rs | 1 -
 clippy_lints/src/use_retain.rs         | 2 +-
 3 files changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.register_perf.rs b/clippy_lints/src/lib.register_perf.rs
index 82431863e6c..b9d8ec72541 100644
--- a/clippy_lints/src/lib.register_perf.rs
+++ b/clippy_lints/src/lib.register_perf.rs
@@ -26,6 +26,7 @@ store.register_group(true, "clippy::perf", Some("clippy_perf"), vec![
     LintId::of(slow_vector_initialization::SLOW_VECTOR_INITIALIZATION),
     LintId::of(types::BOX_COLLECTION),
     LintId::of(types::REDUNDANT_ALLOCATION),
+    LintId::of(use_retain::USE_RETAIN),
     LintId::of(vec::USELESS_VEC),
     LintId::of(vec_init_then_push::VEC_INIT_THEN_PUSH),
 ])
diff --git a/clippy_lints/src/lib.register_style.rs b/clippy_lints/src/lib.register_style.rs
index 3b3505f1e19..d52ec50e542 100644
--- a/clippy_lints/src/lib.register_style.rs
+++ b/clippy_lints/src/lib.register_style.rs
@@ -117,7 +117,6 @@ store.register_group(true, "clippy::style", Some("clippy_style"), vec![
     LintId::of(unsafe_removed_from_name::UNSAFE_REMOVED_FROM_NAME),
     LintId::of(unused_unit::UNUSED_UNIT),
     LintId::of(upper_case_acronyms::UPPER_CASE_ACRONYMS),
-    LintId::of(use_retain::USE_RETAIN),
     LintId::of(write::PRINTLN_EMPTY_STRING),
     LintId::of(write::PRINT_LITERAL),
     LintId::of(write::PRINT_WITH_NEWLINE),
diff --git a/clippy_lints/src/use_retain.rs b/clippy_lints/src/use_retain.rs
index d2479168ada..b55e1006aac 100644
--- a/clippy_lints/src/use_retain.rs
+++ b/clippy_lints/src/use_retain.rs
@@ -43,7 +43,7 @@ declare_clippy_lint! {
     /// ```
     #[clippy::version = "1.63.0"]
     pub USE_RETAIN,
-    style,
+    perf,
     "`retain()` is simpler and the same functionalitys"
 }
 declare_lint_pass!(UseRetain => [USE_RETAIN]);
-- 
cgit 1.4.1-3-g733a5


From fd629c0cde26d727fbc19580455a4efd04a84828 Mon Sep 17 00:00:00 2001
From: kyoto7250 <50972773+kyoto7250@users.noreply.github.com>
Date: Thu, 9 Jun 2022 22:34:16 +0900
Subject: check  method

---
 clippy_lints/src/use_retain.rs |  2 +-
 clippy_utils/src/paths.rs      |  1 +
 tests/ui/use_retain.fixed      | 28 +++++++++++++++++++++
 tests/ui/use_retain.rs         | 28 +++++++++++++++++++++
 tests/ui/use_retain.stderr     | 56 ++++++++++++++++++++++++++++++------------
 5 files changed, 98 insertions(+), 17 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/use_retain.rs b/clippy_lints/src/use_retain.rs
index b55e1006aac..b6b6dc572c1 100644
--- a/clippy_lints/src/use_retain.rs
+++ b/clippy_lints/src/use_retain.rs
@@ -102,7 +102,7 @@ fn check_iter(
     if_chain! {
         if let hir::ExprKind::MethodCall(_, [filter_expr], _) = &target_expr.kind;
         if let Some(copied_def_id) = cx.typeck_results().type_dependent_def_id(target_expr.hir_id);
-        if match_def_path(cx, copied_def_id, &paths::CORE_ITER_COPIED);
+        if match_def_path(cx, copied_def_id, &paths::CORE_ITER_COPIED) || match_def_path(cx, copied_def_id, &paths::CORE_ITER_CLONED);
 
         if let hir::ExprKind::MethodCall(_, [iter_expr, _], _) = &filter_expr.kind;
         if let Some(filter_def_id) = cx.typeck_results().type_dependent_def_id(filter_expr.hir_id);
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index 17cccd43a9c..a2d5279e397 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -25,6 +25,7 @@ pub const BTREESET_ITER: [&str; 6] = ["alloc", "collections", "btree", "set", "B
 pub const CLONE_TRAIT_METHOD: [&str; 4] = ["core", "clone", "Clone", "clone"];
 pub const COW: [&str; 3] = ["alloc", "borrow", "Cow"];
 pub const CORE_ITER_COLLECT: [&str; 6] = ["core", "iter", "traits", "iterator", "Iterator", "collect"];
+pub const CORE_ITER_CLONED: [&str; 6] = ["core", "iter", "traits", "iterator", "Iterator", "cloned"];
 pub const CORE_ITER_COPIED: [&str; 6] = ["core", "iter", "traits", "iterator", "Iterator", "copied"];
 pub const CORE_ITER_FILTER: [&str; 6] = ["core", "iter", "traits", "iterator", "Iterator", "filter"];
 pub const CORE_ITER_INTO_ITER: [&str; 6] = ["core", "iter", "traits", "collect", "IntoIterator", "into_iter"];
diff --git a/tests/ui/use_retain.fixed b/tests/ui/use_retain.fixed
index d24571b36f8..0c80d0e204a 100644
--- a/tests/ui/use_retain.fixed
+++ b/tests/ui/use_retain.fixed
@@ -25,10 +25,12 @@ fn binary_heap_retain() {
     let mut heap = BinaryHeap::from([1, 2, 3]);
     heap = heap.into_iter().filter(|x| x % 2 == 0).collect();
     heap = heap.iter().filter(|&x| x % 2 == 0).copied().collect();
+    heap = heap.iter().filter(|&x| x % 2 == 0).cloned().collect();
 
     // Do not lint, because type conversion is performed
     heap = heap.into_iter().filter(|x| x % 2 == 0).collect::<BinaryHeap<i8>>();
     heap = heap.iter().filter(|&x| x % 2 == 0).copied().collect::<BinaryHeap<i8>>();
+    heap = heap.iter().filter(|&x| x % 2 == 0).cloned().collect::<BinaryHeap<i8>>();
 
     // Do not lint, because this expression is not assign.
     let mut bar: BinaryHeap<i8> = heap.iter().filter(|&x| x % 2 == 0).copied().collect();
@@ -65,6 +67,7 @@ fn btree_set_retain() {
     // Do lint.
     btree_set.retain(|x| x % 2 == 0);
     btree_set.retain(|x| x % 2 == 0);
+    btree_set.retain(|x| x % 2 == 0);
 
     // Do not lint, because type conversion is performed
     btree_set = btree_set
@@ -73,6 +76,12 @@ fn btree_set_retain() {
         .copied()
         .collect::<BTreeSet<i8>>();
 
+    btree_set = btree_set
+        .iter()
+        .filter(|&x| x % 2 == 0)
+        .cloned()
+        .collect::<BTreeSet<i8>>();
+
     btree_set = btree_set.into_iter().filter(|x| x % 2 == 0).collect::<BTreeSet<i8>>();
 
     // Do not lint, because this expression is not assign.
@@ -81,6 +90,7 @@ fn btree_set_retain() {
 
     // Do not lint, because it is an assignment to a different variable.
     bar = foobar.iter().filter(|&x| x % 2 == 0).copied().collect();
+    bar = foobar.iter().filter(|&x| x % 2 == 0).cloned().collect();
     bar = foobar.into_iter().filter(|x| x % 2 == 0).collect();
 }
 
@@ -109,6 +119,7 @@ fn hash_set_retain() {
     // Do lint.
     hash_set.retain(|x| x % 2 == 0);
     hash_set.retain(|x| x % 2 == 0);
+    hash_set.retain(|x| x % 2 == 0);
 
     // Do not lint, because type conversion is performed
     hash_set = hash_set.into_iter().filter(|x| x % 2 == 0).collect::<HashSet<i8>>();
@@ -118,12 +129,19 @@ fn hash_set_retain() {
         .copied()
         .collect::<HashSet<i8>>();
 
+    hash_set = hash_set
+        .iter()
+        .filter(|&x| x % 2 == 0)
+        .cloned()
+        .collect::<HashSet<i8>>();
+
     // Do not lint, because this expression is not assign.
     let mut bar: HashSet<i8> = hash_set.iter().filter(|&x| x % 2 == 0).copied().collect();
     let mut foobar: HashSet<i8> = hash_set.into_iter().filter(|x| x % 2 == 0).collect();
 
     // Do not lint, because it is an assignment to a different variable.
     bar = foobar.iter().filter(|&x| x % 2 == 0).copied().collect();
+    bar = foobar.iter().filter(|&x| x % 2 == 0).cloned().collect();
     bar = foobar.into_iter().filter(|&x| x % 2 == 0).collect();
 }
 
@@ -144,10 +162,12 @@ fn vec_retain() {
     // Do lint.
     vec.retain(|x| x % 2 == 0);
     vec.retain(|x| x % 2 == 0);
+    vec.retain(|x| x % 2 == 0);
 
     // Do not lint, because type conversion is performed
     vec = vec.into_iter().filter(|x| x % 2 == 0).collect::<Vec<i8>>();
     vec = vec.iter().filter(|&x| x % 2 == 0).copied().collect::<Vec<i8>>();
+    vec = vec.iter().filter(|&x| x % 2 == 0).cloned().collect::<Vec<i8>>();
 
     // Do not lint, because this expression is not assign.
     let mut bar: Vec<i8> = vec.iter().filter(|&x| x % 2 == 0).copied().collect();
@@ -155,6 +175,7 @@ fn vec_retain() {
 
     // Do not lint, because it is an assignment to a different variable.
     bar = foobar.iter().filter(|&x| x % 2 == 0).copied().collect();
+    bar = foobar.iter().filter(|&x| x % 2 == 0).cloned().collect();
     bar = foobar.into_iter().filter(|x| x % 2 == 0).collect();
 }
 
@@ -165,6 +186,7 @@ fn vec_queue_retain() {
     // Do lint.
     vec_deque.retain(|x| x % 2 == 0);
     vec_deque.retain(|x| x % 2 == 0);
+    vec_deque.retain(|x| x % 2 == 0);
 
     // Do not lint, because type conversion is performed
     vec_deque = vec_deque
@@ -172,6 +194,11 @@ fn vec_queue_retain() {
         .filter(|&x| x % 2 == 0)
         .copied()
         .collect::<VecDeque<i8>>();
+    vec_deque = vec_deque
+        .iter()
+        .filter(|&x| x % 2 == 0)
+        .cloned()
+        .collect::<VecDeque<i8>>();
     vec_deque = vec_deque.into_iter().filter(|x| x % 2 == 0).collect::<VecDeque<i8>>();
 
     // Do not lint, because this expression is not assign.
@@ -180,5 +207,6 @@ fn vec_queue_retain() {
 
     // Do not lint, because it is an assignment to a different variable.
     bar = foobar.iter().filter(|&x| x % 2 == 0).copied().collect();
+    bar = foobar.iter().filter(|&x| x % 2 == 0).cloned().collect();
     bar = foobar.into_iter().filter(|x| x % 2 == 0).collect();
 }
diff --git a/tests/ui/use_retain.rs b/tests/ui/use_retain.rs
index 4a51825c95f..08c184486f9 100644
--- a/tests/ui/use_retain.rs
+++ b/tests/ui/use_retain.rs
@@ -25,10 +25,12 @@ fn binary_heap_retain() {
     let mut heap = BinaryHeap::from([1, 2, 3]);
     heap = heap.into_iter().filter(|x| x % 2 == 0).collect();
     heap = heap.iter().filter(|&x| x % 2 == 0).copied().collect();
+    heap = heap.iter().filter(|&x| x % 2 == 0).cloned().collect();
 
     // Do not lint, because type conversion is performed
     heap = heap.into_iter().filter(|x| x % 2 == 0).collect::<BinaryHeap<i8>>();
     heap = heap.iter().filter(|&x| x % 2 == 0).copied().collect::<BinaryHeap<i8>>();
+    heap = heap.iter().filter(|&x| x % 2 == 0).cloned().collect::<BinaryHeap<i8>>();
 
     // Do not lint, because this expression is not assign.
     let mut bar: BinaryHeap<i8> = heap.iter().filter(|&x| x % 2 == 0).copied().collect();
@@ -67,6 +69,7 @@ fn btree_set_retain() {
 
     // Do lint.
     btree_set = btree_set.iter().filter(|&x| x % 2 == 0).copied().collect();
+    btree_set = btree_set.iter().filter(|&x| x % 2 == 0).cloned().collect();
     btree_set = btree_set.into_iter().filter(|x| x % 2 == 0).collect();
 
     // Do not lint, because type conversion is performed
@@ -76,6 +79,12 @@ fn btree_set_retain() {
         .copied()
         .collect::<BTreeSet<i8>>();
 
+    btree_set = btree_set
+        .iter()
+        .filter(|&x| x % 2 == 0)
+        .cloned()
+        .collect::<BTreeSet<i8>>();
+
     btree_set = btree_set.into_iter().filter(|x| x % 2 == 0).collect::<BTreeSet<i8>>();
 
     // Do not lint, because this expression is not assign.
@@ -84,6 +93,7 @@ fn btree_set_retain() {
 
     // Do not lint, because it is an assignment to a different variable.
     bar = foobar.iter().filter(|&x| x % 2 == 0).copied().collect();
+    bar = foobar.iter().filter(|&x| x % 2 == 0).cloned().collect();
     bar = foobar.into_iter().filter(|x| x % 2 == 0).collect();
 }
 
@@ -115,6 +125,7 @@ fn hash_set_retain() {
     // Do lint.
     hash_set = hash_set.into_iter().filter(|x| x % 2 == 0).collect();
     hash_set = hash_set.iter().filter(|&x| x % 2 == 0).copied().collect();
+    hash_set = hash_set.iter().filter(|&x| x % 2 == 0).cloned().collect();
 
     // Do not lint, because type conversion is performed
     hash_set = hash_set.into_iter().filter(|x| x % 2 == 0).collect::<HashSet<i8>>();
@@ -124,12 +135,19 @@ fn hash_set_retain() {
         .copied()
         .collect::<HashSet<i8>>();
 
+    hash_set = hash_set
+        .iter()
+        .filter(|&x| x % 2 == 0)
+        .cloned()
+        .collect::<HashSet<i8>>();
+
     // Do not lint, because this expression is not assign.
     let mut bar: HashSet<i8> = hash_set.iter().filter(|&x| x % 2 == 0).copied().collect();
     let mut foobar: HashSet<i8> = hash_set.into_iter().filter(|x| x % 2 == 0).collect();
 
     // Do not lint, because it is an assignment to a different variable.
     bar = foobar.iter().filter(|&x| x % 2 == 0).copied().collect();
+    bar = foobar.iter().filter(|&x| x % 2 == 0).cloned().collect();
     bar = foobar.into_iter().filter(|&x| x % 2 == 0).collect();
 }
 
@@ -149,11 +167,13 @@ fn vec_retain() {
     let mut vec = vec![0, 1, 2];
     // Do lint.
     vec = vec.iter().filter(|&x| x % 2 == 0).copied().collect();
+    vec = vec.iter().filter(|&x| x % 2 == 0).cloned().collect();
     vec = vec.into_iter().filter(|x| x % 2 == 0).collect();
 
     // Do not lint, because type conversion is performed
     vec = vec.into_iter().filter(|x| x % 2 == 0).collect::<Vec<i8>>();
     vec = vec.iter().filter(|&x| x % 2 == 0).copied().collect::<Vec<i8>>();
+    vec = vec.iter().filter(|&x| x % 2 == 0).cloned().collect::<Vec<i8>>();
 
     // Do not lint, because this expression is not assign.
     let mut bar: Vec<i8> = vec.iter().filter(|&x| x % 2 == 0).copied().collect();
@@ -161,6 +181,7 @@ fn vec_retain() {
 
     // Do not lint, because it is an assignment to a different variable.
     bar = foobar.iter().filter(|&x| x % 2 == 0).copied().collect();
+    bar = foobar.iter().filter(|&x| x % 2 == 0).cloned().collect();
     bar = foobar.into_iter().filter(|x| x % 2 == 0).collect();
 }
 
@@ -170,6 +191,7 @@ fn vec_queue_retain() {
 
     // Do lint.
     vec_deque = vec_deque.iter().filter(|&x| x % 2 == 0).copied().collect();
+    vec_deque = vec_deque.iter().filter(|&x| x % 2 == 0).cloned().collect();
     vec_deque = vec_deque.into_iter().filter(|x| x % 2 == 0).collect();
 
     // Do not lint, because type conversion is performed
@@ -178,6 +200,11 @@ fn vec_queue_retain() {
         .filter(|&x| x % 2 == 0)
         .copied()
         .collect::<VecDeque<i8>>();
+    vec_deque = vec_deque
+        .iter()
+        .filter(|&x| x % 2 == 0)
+        .cloned()
+        .collect::<VecDeque<i8>>();
     vec_deque = vec_deque.into_iter().filter(|x| x % 2 == 0).collect::<VecDeque<i8>>();
 
     // Do not lint, because this expression is not assign.
@@ -186,5 +213,6 @@ fn vec_queue_retain() {
 
     // Do not lint, because it is an assignment to a different variable.
     bar = foobar.iter().filter(|&x| x % 2 == 0).copied().collect();
+    bar = foobar.iter().filter(|&x| x % 2 == 0).cloned().collect();
     bar = foobar.into_iter().filter(|x| x % 2 == 0).collect();
 }
diff --git a/tests/ui/use_retain.stderr b/tests/ui/use_retain.stderr
index 331259c1626..e29d40a2e39 100644
--- a/tests/ui/use_retain.stderr
+++ b/tests/ui/use_retain.stderr
@@ -1,5 +1,5 @@
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/use_retain.rs:45:5
+  --> $DIR/use_retain.rs:47:5
    |
 LL |     btree_map = btree_map.into_iter().filter(|(k, _)| k % 2 == 0).collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `btree_map.retain(|k, _| k % 2 == 0)`
@@ -7,13 +7,13 @@ LL |     btree_map = btree_map.into_iter().filter(|(k, _)| k % 2 == 0).collect()
    = note: `-D clippy::use-retain` implied by `-D warnings`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/use_retain.rs:46:5
+  --> $DIR/use_retain.rs:48:5
    |
 LL |     btree_map = btree_map.into_iter().filter(|(_, v)| v % 2 == 0).collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `btree_map.retain(|_, &mut v| v % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/use_retain.rs:47:5
+  --> $DIR/use_retain.rs:49:5
    |
 LL | /     btree_map = btree_map
 LL | |         .into_iter()
@@ -22,31 +22,37 @@ LL | |         .collect();
    | |__________________^ help: consider calling `.retain()` instead: `btree_map.retain(|k, &mut v| (k % 2 == 0) && (v % 2 == 0))`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/use_retain.rs:69:5
+  --> $DIR/use_retain.rs:71:5
    |
 LL |     btree_set = btree_set.iter().filter(|&x| x % 2 == 0).copied().collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `btree_set.retain(|x| x % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/use_retain.rs:70:5
+  --> $DIR/use_retain.rs:72:5
+   |
+LL |     btree_set = btree_set.iter().filter(|&x| x % 2 == 0).cloned().collect();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `btree_set.retain(|x| x % 2 == 0)`
+
+error: this expression can be written more simply using `.retain()`
+  --> $DIR/use_retain.rs:73:5
    |
 LL |     btree_set = btree_set.into_iter().filter(|x| x % 2 == 0).collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `btree_set.retain(|x| x % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/use_retain.rs:93:5
+  --> $DIR/use_retain.rs:103:5
    |
 LL |     hash_map = hash_map.into_iter().filter(|(k, _)| k % 2 == 0).collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `hash_map.retain(|k, _| k % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/use_retain.rs:94:5
+  --> $DIR/use_retain.rs:104:5
    |
 LL |     hash_map = hash_map.into_iter().filter(|(_, v)| v % 2 == 0).collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `hash_map.retain(|_, &mut v| v % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/use_retain.rs:95:5
+  --> $DIR/use_retain.rs:105:5
    |
 LL | /     hash_map = hash_map
 LL | |         .into_iter()
@@ -55,46 +61,64 @@ LL | |         .collect();
    | |__________________^ help: consider calling `.retain()` instead: `hash_map.retain(|k, &mut v| (k % 2 == 0) && (v % 2 == 0))`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/use_retain.rs:116:5
+  --> $DIR/use_retain.rs:126:5
    |
 LL |     hash_set = hash_set.into_iter().filter(|x| x % 2 == 0).collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `hash_set.retain(|x| x % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/use_retain.rs:117:5
+  --> $DIR/use_retain.rs:127:5
    |
 LL |     hash_set = hash_set.iter().filter(|&x| x % 2 == 0).copied().collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `hash_set.retain(|x| x % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/use_retain.rs:139:5
+  --> $DIR/use_retain.rs:128:5
+   |
+LL |     hash_set = hash_set.iter().filter(|&x| x % 2 == 0).cloned().collect();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `hash_set.retain(|x| x % 2 == 0)`
+
+error: this expression can be written more simply using `.retain()`
+  --> $DIR/use_retain.rs:157:5
    |
 LL |     s = s.chars().filter(|&c| c != 'o').to_owned().collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `s.retain(|c| c != 'o')`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/use_retain.rs:151:5
+  --> $DIR/use_retain.rs:169:5
    |
 LL |     vec = vec.iter().filter(|&x| x % 2 == 0).copied().collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `vec.retain(|x| x % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/use_retain.rs:152:5
+  --> $DIR/use_retain.rs:170:5
+   |
+LL |     vec = vec.iter().filter(|&x| x % 2 == 0).cloned().collect();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `vec.retain(|x| x % 2 == 0)`
+
+error: this expression can be written more simply using `.retain()`
+  --> $DIR/use_retain.rs:171:5
    |
 LL |     vec = vec.into_iter().filter(|x| x % 2 == 0).collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `vec.retain(|x| x % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/use_retain.rs:172:5
+  --> $DIR/use_retain.rs:193:5
    |
 LL |     vec_deque = vec_deque.iter().filter(|&x| x % 2 == 0).copied().collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `vec_deque.retain(|x| x % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/use_retain.rs:173:5
+  --> $DIR/use_retain.rs:194:5
+   |
+LL |     vec_deque = vec_deque.iter().filter(|&x| x % 2 == 0).cloned().collect();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `vec_deque.retain(|x| x % 2 == 0)`
+
+error: this expression can be written more simply using `.retain()`
+  --> $DIR/use_retain.rs:195:5
    |
 LL |     vec_deque = vec_deque.into_iter().filter(|x| x % 2 == 0).collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `vec_deque.retain(|x| x % 2 == 0)`
 
-error: aborting due to 15 previous errors
+error: aborting due to 19 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 14212115c4f669d33007d45c2b26623b7879ccc0 Mon Sep 17 00:00:00 2001
From: kyoto7250 <50972773+kyoto7250@users.noreply.github.com>
Date: Thu, 9 Jun 2022 22:50:00 +0900
Subject: rewrite without if_chain macro

---
 clippy_lints/src/use_retain.rs | 146 +++++++++++++++++------------------------
 1 file changed, 60 insertions(+), 86 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/use_retain.rs b/clippy_lints/src/use_retain.rs
index b6b6dc572c1..7c57020761c 100644
--- a/clippy_lints/src/use_retain.rs
+++ b/clippy_lints/src/use_retain.rs
@@ -50,21 +50,16 @@ declare_lint_pass!(UseRetain => [USE_RETAIN]);
 
 impl<'tcx> LateLintPass<'tcx> for UseRetain {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
-        if_chain! {
-            if let Some(parent_expr) = get_parent_expr(cx, expr);
-            if let Assign(left_expr, collect_expr, _) = &parent_expr.kind;
-            if let hir::ExprKind::MethodCall(seg, _, _) = &collect_expr.kind;
-            if seg.args.is_none();
-
-            if let hir::ExprKind::MethodCall(_, [target_expr], _) = &collect_expr.kind;
-            if let Some(collect_def_id) = cx.typeck_results().type_dependent_def_id(collect_expr.hir_id);
-            if match_def_path(cx, collect_def_id, &paths::CORE_ITER_COLLECT);
-
-            then {
-                check_into_iter(cx, parent_expr, left_expr, target_expr);
-                check_iter(cx, parent_expr, left_expr, target_expr);
-                check_to_owned(cx, parent_expr, left_expr, target_expr);
-            }
+        if let Some(parent_expr) = get_parent_expr(cx, expr)
+            && let Assign(left_expr, collect_expr, _) = &parent_expr.kind
+            && let hir::ExprKind::MethodCall(seg, _, _) = &collect_expr.kind
+            && seg.args.is_none()
+            && let hir::ExprKind::MethodCall(_, [target_expr], _) = &collect_expr.kind
+            && let Some(collect_def_id) = cx.typeck_results().type_dependent_def_id(collect_expr.hir_id)
+            && match_def_path(cx, collect_def_id, &paths::CORE_ITER_COLLECT) {
+            check_into_iter(cx, parent_expr, left_expr, target_expr);
+            check_iter(cx, parent_expr, left_expr, target_expr);
+            check_to_owned(cx, parent_expr, left_expr, target_expr);
         }
     }
 }
@@ -75,21 +70,15 @@ fn check_into_iter(
     left_expr: &hir::Expr<'_>,
     target_expr: &hir::Expr<'_>,
 ) {
-    if_chain! {
-        if let hir::ExprKind::MethodCall(_, [into_iter_expr, _], _) = &target_expr.kind;
-        if let Some(filter_def_id) = cx.typeck_results().type_dependent_def_id(target_expr.hir_id);
-        if match_def_path(cx, filter_def_id, &paths::CORE_ITER_FILTER);
-
-        if let hir::ExprKind::MethodCall(_, [struct_expr], _) = &into_iter_expr.kind;
-        if let Some(into_iter_def_id) = cx.typeck_results().type_dependent_def_id(into_iter_expr.hir_id);
-        if match_def_path(cx, into_iter_def_id, &paths::CORE_ITER_INTO_ITER);
-        if match_acceptable_type(cx, left_expr);
-
-        if SpanlessEq::new(cx).eq_expr(left_expr, struct_expr);
-
-        then {
-            suggest(cx, parent_expr, left_expr, target_expr);
-        }
+    if let hir::ExprKind::MethodCall(_, [into_iter_expr, _], _) = &target_expr.kind
+        && let Some(filter_def_id) = cx.typeck_results().type_dependent_def_id(target_expr.hir_id)
+        && match_def_path(cx, filter_def_id, &paths::CORE_ITER_FILTER)
+        && let hir::ExprKind::MethodCall(_, [struct_expr], _) = &into_iter_expr.kind
+        && let Some(into_iter_def_id) = cx.typeck_results().type_dependent_def_id(into_iter_expr.hir_id)
+        && match_def_path(cx, into_iter_def_id, &paths::CORE_ITER_INTO_ITER)
+        && match_acceptable_type(cx, left_expr)
+        && SpanlessEq::new(cx).eq_expr(left_expr, struct_expr) {
+        suggest(cx, parent_expr, left_expr, target_expr);
     }
 }
 
@@ -99,24 +88,19 @@ fn check_iter(
     left_expr: &hir::Expr<'_>,
     target_expr: &hir::Expr<'_>,
 ) {
-    if_chain! {
-        if let hir::ExprKind::MethodCall(_, [filter_expr], _) = &target_expr.kind;
-        if let Some(copied_def_id) = cx.typeck_results().type_dependent_def_id(target_expr.hir_id);
-        if match_def_path(cx, copied_def_id, &paths::CORE_ITER_COPIED) || match_def_path(cx, copied_def_id, &paths::CORE_ITER_CLONED);
-
-        if let hir::ExprKind::MethodCall(_, [iter_expr, _], _) = &filter_expr.kind;
-        if let Some(filter_def_id) = cx.typeck_results().type_dependent_def_id(filter_expr.hir_id);
-        if match_def_path(cx, filter_def_id, &paths::CORE_ITER_FILTER);
-
-        if let hir::ExprKind::MethodCall(_, [struct_expr], _) = &iter_expr.kind;
-        if let Some(iter_expr_def_id) = cx.typeck_results().type_dependent_def_id(iter_expr.hir_id);
-        if match_acceptable_def_path(cx, iter_expr_def_id);
-        if match_acceptable_type(cx, left_expr);
-        if SpanlessEq::new(cx).eq_expr(left_expr, struct_expr);
-
-        then {
-            suggest(cx, parent_expr, left_expr, filter_expr);
-        }
+    if let hir::ExprKind::MethodCall(_, [filter_expr], _) = &target_expr.kind
+        && let Some(copied_def_id) = cx.typeck_results().type_dependent_def_id(target_expr.hir_id)
+        && (match_def_path(cx, copied_def_id, &paths::CORE_ITER_COPIED)
+            || match_def_path(cx, copied_def_id, &paths::CORE_ITER_CLONED))
+        && let hir::ExprKind::MethodCall(_, [iter_expr, _], _) = &filter_expr.kind
+        && let Some(filter_def_id) = cx.typeck_results().type_dependent_def_id(filter_expr.hir_id)
+        && match_def_path(cx, filter_def_id, &paths::CORE_ITER_FILTER)
+        && let hir::ExprKind::MethodCall(_, [struct_expr], _) = &iter_expr.kind
+        && let Some(iter_expr_def_id) = cx.typeck_results().type_dependent_def_id(iter_expr.hir_id)
+        && match_acceptable_def_path(cx, iter_expr_def_id)
+        && match_acceptable_type(cx, left_expr)
+        && SpanlessEq::new(cx).eq_expr(left_expr, struct_expr) {
+        suggest(cx, parent_expr, left_expr, filter_expr);
     }
 }
 
@@ -126,36 +110,28 @@ fn check_to_owned(
     left_expr: &hir::Expr<'_>,
     target_expr: &hir::Expr<'_>,
 ) {
-    if_chain! {
-        if let hir::ExprKind::MethodCall(_, [filter_expr], _) = &target_expr.kind;
-        if let Some(to_owned_def_id) = cx.typeck_results().type_dependent_def_id(target_expr.hir_id);
-        if match_def_path(cx, to_owned_def_id, &paths::TO_OWNED_METHOD);
-
-        if let hir::ExprKind::MethodCall(_, [chars_expr, _], _) = &filter_expr.kind;
-        if let Some(filter_def_id) = cx.typeck_results().type_dependent_def_id(filter_expr.hir_id);
-        if match_def_path(cx, filter_def_id, &paths::CORE_ITER_FILTER);
-
-        if let hir::ExprKind::MethodCall(_, [str_expr], _) = &chars_expr.kind;
-        if let Some(chars_expr_def_id) = cx.typeck_results().type_dependent_def_id(chars_expr.hir_id);
-        if match_def_path(cx, chars_expr_def_id, &paths::STR_CHARS);
-
-        let ty = cx.typeck_results().expr_ty(str_expr).peel_refs();
-        if is_type_diagnostic_item(cx, ty, sym::String);
-        if SpanlessEq::new(cx).eq_expr(left_expr, str_expr);
-
-        then {
-            suggest(cx, parent_expr, left_expr, filter_expr);
-        }
+    if let hir::ExprKind::MethodCall(_, [filter_expr], _) = &target_expr.kind
+        && let Some(to_owned_def_id) = cx.typeck_results().type_dependent_def_id(target_expr.hir_id)
+        && match_def_path(cx, to_owned_def_id, &paths::TO_OWNED_METHOD)
+        && let hir::ExprKind::MethodCall(_, [chars_expr, _], _) = &filter_expr.kind
+        && let Some(filter_def_id) = cx.typeck_results().type_dependent_def_id(filter_expr.hir_id)
+        && match_def_path(cx, filter_def_id, &paths::CORE_ITER_FILTER)
+        && let hir::ExprKind::MethodCall(_, [str_expr], _) = &chars_expr.kind
+        && let Some(chars_expr_def_id) = cx.typeck_results().type_dependent_def_id(chars_expr.hir_id)
+        && match_def_path(cx, chars_expr_def_id, &paths::STR_CHARS)
+        && let ty = cx.typeck_results().expr_ty(str_expr).peel_refs()
+        && is_type_diagnostic_item(cx, ty, sym::String)
+        && SpanlessEq::new(cx).eq_expr(left_expr, str_expr) {
+        suggest(cx, parent_expr, left_expr, filter_expr);
     }
 }
 
 fn suggest(cx: &LateContext<'_>, parent_expr: &hir::Expr<'_>, left_expr: &hir::Expr<'_>, filter_expr: &hir::Expr<'_>) {
-    if_chain! {
-        if let hir::ExprKind::MethodCall(_, [_, closure], _) = filter_expr.kind;
-        if let hir::ExprKind::Closure(_, _, filter_body_id, ..) = closure.kind;
-        let filter_body = cx.tcx.hir().body(filter_body_id);
-        if let [filter_params] = filter_body.params;
-        if let Some(sugg) = match filter_params.pat.kind {
+    if let hir::ExprKind::MethodCall(_, [_, closure], _) = filter_expr.kind
+        && let hir::ExprKind::Closure(_, _, filter_body_id, ..) = closure.kind
+        && let filter_body = cx.tcx.hir().body(filter_body_id)
+        && let [filter_params] = filter_body.params
+        && let Some(sugg) = match filter_params.pat.kind {
             hir::PatKind::Binding(_, _, filter_param_ident, None) => {
                 Some(format!("{}.retain(|{}| {})", snippet(cx, left_expr.span, ".."), filter_param_ident, snippet(cx, filter_body.value.span, "..")))
             },
@@ -171,18 +147,16 @@ fn suggest(cx: &LateContext<'_>, parent_expr: &hir::Expr<'_>, left_expr: &hir::E
                 }
             },
             _ => None
-        };
-        then {
-            span_lint_and_sugg(
-                cx,
-                USE_RETAIN,
-                parent_expr.span,
-                "this expression can be written more simply using `.retain()`",
-                "consider calling `.retain()` instead",
-                sugg,
-                Applicability::MachineApplicable
-            );
-        }
+        } {
+        span_lint_and_sugg(
+            cx,
+            USE_RETAIN,
+            parent_expr.span,
+            "this expression can be written more simply using `.retain()`",
+            "consider calling `.retain()` instead",
+            sugg,
+            Applicability::MachineApplicable
+        );
     }
 }
 
-- 
cgit 1.4.1-3-g733a5


From 4decfdec76a6b67dc87f29d6f1a8db148119211d Mon Sep 17 00:00:00 2001
From: kyoto7250 <50972773+kyoto7250@users.noreply.github.com>
Date: Fri, 10 Jun 2022 11:31:25 +0900
Subject: check msrv

---
 clippy_lints/src/lib.rs        |  2 +-
 clippy_lints/src/use_retain.rs | 59 ++++++++++++++++++++++++++++--------------
 clippy_utils/src/msrvs.rs      |  5 ++--
 tests/ui/use_retain.fixed      | 32 +++++++++++++++++++++--
 tests/ui/use_retain.rs         | 32 +++++++++++++++++++++--
 tests/ui/use_retain.stderr     | 38 +++++++++++++--------------
 6 files changed, 123 insertions(+), 45 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 124f0d12b08..716038aa522 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -915,7 +915,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(read_zero_byte_vec::ReadZeroByteVec));
     store.register_late_pass(|| Box::new(default_instead_of_iter_empty::DefaultIterEmpty));
     store.register_late_pass(move || Box::new(manual_rem_euclid::ManualRemEuclid::new(msrv)));
-    store.register_late_pass(|| Box::new(use_retain::UseRetain));
+    store.register_late_pass(move || Box::new(use_retain::UseRetain::new(msrv)));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/use_retain.rs b/clippy_lints/src/use_retain.rs
index 7c57020761c..185201514ad 100644
--- a/clippy_lints/src/use_retain.rs
+++ b/clippy_lints/src/use_retain.rs
@@ -2,12 +2,14 @@ use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::{get_parent_expr, match_def_path, paths, SpanlessEq};
+use clippy_utils::{meets_msrv, msrvs};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_hir::def_id::DefId;
 use rustc_hir::ExprKind::Assign;
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_semver::RustcVersion;
+use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::symbol::sym;
 
 const ACCEPTABLE_METHODS: [&[&str]; 4] = [
@@ -16,13 +18,13 @@ const ACCEPTABLE_METHODS: [&[&str]; 4] = [
     &paths::SLICE_INTO,
     &paths::VEC_DEQUE_ITER,
 ];
-const ACCEPTABLE_TYPES: [rustc_span::Symbol; 6] = [
-    sym::BTreeSet,
-    sym::BTreeMap,
-    sym::HashSet,
-    sym::HashMap,
-    sym::Vec,
-    sym::VecDeque,
+const ACCEPTABLE_TYPES: [(rustc_span::Symbol, Option<RustcVersion>); 6] = [
+    (sym::BTreeSet, Some(msrvs::BTREE_SET_RETAIN)),
+    (sym::BTreeMap, Some(msrvs::BTREE_MAP_RETAIN)),
+    (sym::HashSet, Some(msrvs::HASH_SET_RETAIN)),
+    (sym::HashMap, Some(msrvs::HASH_MAP_RETAIN)),
+    (sym::Vec, None),
+    (sym::VecDeque, None),
 ];
 
 declare_clippy_lint! {
@@ -46,7 +48,19 @@ declare_clippy_lint! {
     perf,
     "`retain()` is simpler and the same functionalitys"
 }
-declare_lint_pass!(UseRetain => [USE_RETAIN]);
+
+pub struct UseRetain {
+    msrv: Option<RustcVersion>,
+}
+
+impl UseRetain {
+    #[must_use]
+    pub fn new(msrv: Option<RustcVersion>) -> Self {
+        Self { msrv }
+    }
+}
+
+impl_lint_pass!(UseRetain => [USE_RETAIN]);
 
 impl<'tcx> LateLintPass<'tcx> for UseRetain {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
@@ -57,11 +71,13 @@ impl<'tcx> LateLintPass<'tcx> for UseRetain {
             && let hir::ExprKind::MethodCall(_, [target_expr], _) = &collect_expr.kind
             && let Some(collect_def_id) = cx.typeck_results().type_dependent_def_id(collect_expr.hir_id)
             && match_def_path(cx, collect_def_id, &paths::CORE_ITER_COLLECT) {
-            check_into_iter(cx, parent_expr, left_expr, target_expr);
-            check_iter(cx, parent_expr, left_expr, target_expr);
-            check_to_owned(cx, parent_expr, left_expr, target_expr);
+            check_into_iter(cx, parent_expr, left_expr, target_expr, self.msrv);
+            check_iter(cx, parent_expr, left_expr, target_expr, self.msrv);
+            check_to_owned(cx, parent_expr, left_expr, target_expr, self.msrv);
         }
     }
+
+    extract_msrv_attr!(LateContext);
 }
 
 fn check_into_iter(
@@ -69,6 +85,7 @@ fn check_into_iter(
     parent_expr: &hir::Expr<'_>,
     left_expr: &hir::Expr<'_>,
     target_expr: &hir::Expr<'_>,
+    msrv: Option<RustcVersion>,
 ) {
     if let hir::ExprKind::MethodCall(_, [into_iter_expr, _], _) = &target_expr.kind
         && let Some(filter_def_id) = cx.typeck_results().type_dependent_def_id(target_expr.hir_id)
@@ -76,7 +93,7 @@ fn check_into_iter(
         && let hir::ExprKind::MethodCall(_, [struct_expr], _) = &into_iter_expr.kind
         && let Some(into_iter_def_id) = cx.typeck_results().type_dependent_def_id(into_iter_expr.hir_id)
         && match_def_path(cx, into_iter_def_id, &paths::CORE_ITER_INTO_ITER)
-        && match_acceptable_type(cx, left_expr)
+        && match_acceptable_type(cx, left_expr, msrv)
         && SpanlessEq::new(cx).eq_expr(left_expr, struct_expr) {
         suggest(cx, parent_expr, left_expr, target_expr);
     }
@@ -87,6 +104,7 @@ fn check_iter(
     parent_expr: &hir::Expr<'_>,
     left_expr: &hir::Expr<'_>,
     target_expr: &hir::Expr<'_>,
+    msrv: Option<RustcVersion>,
 ) {
     if let hir::ExprKind::MethodCall(_, [filter_expr], _) = &target_expr.kind
         && let Some(copied_def_id) = cx.typeck_results().type_dependent_def_id(target_expr.hir_id)
@@ -98,7 +116,7 @@ fn check_iter(
         && let hir::ExprKind::MethodCall(_, [struct_expr], _) = &iter_expr.kind
         && let Some(iter_expr_def_id) = cx.typeck_results().type_dependent_def_id(iter_expr.hir_id)
         && match_acceptable_def_path(cx, iter_expr_def_id)
-        && match_acceptable_type(cx, left_expr)
+        && match_acceptable_type(cx, left_expr, msrv)
         && SpanlessEq::new(cx).eq_expr(left_expr, struct_expr) {
         suggest(cx, parent_expr, left_expr, filter_expr);
     }
@@ -109,8 +127,10 @@ fn check_to_owned(
     parent_expr: &hir::Expr<'_>,
     left_expr: &hir::Expr<'_>,
     target_expr: &hir::Expr<'_>,
+    msrv: Option<RustcVersion>,
 ) {
-    if let hir::ExprKind::MethodCall(_, [filter_expr], _) = &target_expr.kind
+    if meets_msrv(msrv,  msrvs::STRING_RETAIN)
+        && let hir::ExprKind::MethodCall(_, [filter_expr], _) = &target_expr.kind
         && let Some(to_owned_def_id) = cx.typeck_results().type_dependent_def_id(target_expr.hir_id)
         && match_def_path(cx, to_owned_def_id, &paths::TO_OWNED_METHOD)
         && let hir::ExprKind::MethodCall(_, [chars_expr, _], _) = &filter_expr.kind
@@ -199,9 +219,10 @@ fn match_acceptable_def_path(cx: &LateContext<'_>, collect_def_id: DefId) -> boo
         .any(|&method| match_def_path(cx, collect_def_id, method))
 }
 
-fn match_acceptable_type(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> bool {
+fn match_acceptable_type(cx: &LateContext<'_>, expr: &hir::Expr<'_>, msrv: Option<RustcVersion>) -> bool {
     let expr_ty = cx.typeck_results().expr_ty(expr).peel_refs();
-    ACCEPTABLE_TYPES
-        .iter()
-        .any(|&ty| is_type_diagnostic_item(cx, expr_ty, ty))
+    ACCEPTABLE_TYPES.iter().any(|(ty, acceptable_msrv)| {
+        is_type_diagnostic_item(cx, expr_ty, *ty)
+            && acceptable_msrv.map_or(true, |acceptable_msrv| meets_msrv(msrv, acceptable_msrv))
+    })
 }
diff --git a/clippy_utils/src/msrvs.rs b/clippy_utils/src/msrvs.rs
index 43c0a03c42a..b09c929f76e 100644
--- a/clippy_utils/src/msrvs.rs
+++ b/clippy_utils/src/msrvs.rs
@@ -12,7 +12,7 @@ macro_rules! msrv_aliases {
 
 // names may refer to stabilized feature flags or library items
 msrv_aliases! {
-    1,53,0 { OR_PATTERNS, MANUAL_BITS }
+    1,53,0 { OR_PATTERNS, MANUAL_BITS, BTREE_MAP_RETAIN, BTREE_SET_RETAIN }
     1,52,0 { STR_SPLIT_ONCE, REM_EUCLID_CONST }
     1,51,0 { BORROW_AS_PTR, UNSIGNED_ABS }
     1,50,0 { BOOL_THEN }
@@ -30,7 +30,8 @@ msrv_aliases! {
     1,34,0 { TRY_FROM }
     1,30,0 { ITERATOR_FIND_MAP, TOOL_ATTRIBUTES }
     1,28,0 { FROM_BOOL }
-    1,26,0 { RANGE_INCLUSIVE }
+    1,26,0 { RANGE_INCLUSIVE, STRING_RETAIN }
+    1,18,0 { HASH_MAP_RETAIN, HASH_SET_RETAIN }
     1,17,0 { FIELD_INIT_SHORTHAND, STATIC_IN_CONST, EXPECT_ERR }
     1,16,0 { STR_REPEAT }
     1,24,0 { IS_ASCII_DIGIT }
diff --git a/tests/ui/use_retain.fixed b/tests/ui/use_retain.fixed
index 0c80d0e204a..549b8a62c0c 100644
--- a/tests/ui/use_retain.fixed
+++ b/tests/ui/use_retain.fixed
@@ -1,4 +1,5 @@
 // run-rustfix
+#![feature(custom_inner_attributes)]
 #![warn(clippy::use_retain)]
 #![allow(unused)]
 use std::collections::BTreeMap;
@@ -15,12 +16,16 @@ fn main() {
     hash_set_retain();
     hash_map_retain();
     string_retain();
-    vec_queue_retain();
+    vec_deque_retain();
     vec_retain();
+    _msrv_153();
+    _msrv_126();
+    _msrv_118();
 }
 
 fn binary_heap_retain() {
     // NOTE: Do not lint now, because binary_heap_retain is nighyly API.
+    // And we need to add a test case for msrv if we update this implmention.
     // https://github.com/rust-lang/rust/issues/71503
     let mut heap = BinaryHeap::from([1, 2, 3]);
     heap = heap.into_iter().filter(|x| x % 2 == 0).collect();
@@ -179,7 +184,7 @@ fn vec_retain() {
     bar = foobar.into_iter().filter(|x| x % 2 == 0).collect();
 }
 
-fn vec_queue_retain() {
+fn vec_deque_retain() {
     let mut vec_deque = VecDeque::new();
     vec_deque.extend(1..5);
 
@@ -210,3 +215,26 @@ fn vec_queue_retain() {
     bar = foobar.iter().filter(|&x| x % 2 == 0).cloned().collect();
     bar = foobar.into_iter().filter(|x| x % 2 == 0).collect();
 }
+
+fn _msrv_153() {
+    #![clippy::msrv = "1.52"]
+    let mut btree_map: BTreeMap<i8, i8> = (0..8).map(|x| (x, x * 10)).collect();
+    btree_map = btree_map.into_iter().filter(|(k, _)| k % 2 == 0).collect();
+
+    let mut btree_set = BTreeSet::from([1, 2, 3, 4, 5, 6]);
+    btree_set = btree_set.iter().filter(|&x| x % 2 == 0).copied().collect();
+}
+
+fn _msrv_126() {
+    #![clippy::msrv = "1.25"]
+    let mut s = String::from("foobar");
+    s = s.chars().filter(|&c| c != 'o').to_owned().collect();
+}
+
+fn _msrv_118() {
+    #![clippy::msrv = "1.17"]
+    let mut hash_set = HashSet::from([1, 2, 3, 4, 5, 6]);
+    hash_set = hash_set.into_iter().filter(|x| x % 2 == 0).collect();
+    let mut hash_map: HashMap<i8, i8> = (0..8).map(|x| (x, x * 10)).collect();
+    hash_map = hash_map.into_iter().filter(|(k, _)| k % 2 == 0).collect();
+}
diff --git a/tests/ui/use_retain.rs b/tests/ui/use_retain.rs
index 08c184486f9..36c4176b8d5 100644
--- a/tests/ui/use_retain.rs
+++ b/tests/ui/use_retain.rs
@@ -1,4 +1,5 @@
 // run-rustfix
+#![feature(custom_inner_attributes)]
 #![warn(clippy::use_retain)]
 #![allow(unused)]
 use std::collections::BTreeMap;
@@ -15,12 +16,16 @@ fn main() {
     hash_set_retain();
     hash_map_retain();
     string_retain();
-    vec_queue_retain();
+    vec_deque_retain();
     vec_retain();
+    _msrv_153();
+    _msrv_126();
+    _msrv_118();
 }
 
 fn binary_heap_retain() {
     // NOTE: Do not lint now, because binary_heap_retain is nighyly API.
+    // And we need to add a test case for msrv if we update this implmention.
     // https://github.com/rust-lang/rust/issues/71503
     let mut heap = BinaryHeap::from([1, 2, 3]);
     heap = heap.into_iter().filter(|x| x % 2 == 0).collect();
@@ -185,7 +190,7 @@ fn vec_retain() {
     bar = foobar.into_iter().filter(|x| x % 2 == 0).collect();
 }
 
-fn vec_queue_retain() {
+fn vec_deque_retain() {
     let mut vec_deque = VecDeque::new();
     vec_deque.extend(1..5);
 
@@ -216,3 +221,26 @@ fn vec_queue_retain() {
     bar = foobar.iter().filter(|&x| x % 2 == 0).cloned().collect();
     bar = foobar.into_iter().filter(|x| x % 2 == 0).collect();
 }
+
+fn _msrv_153() {
+    #![clippy::msrv = "1.52"]
+    let mut btree_map: BTreeMap<i8, i8> = (0..8).map(|x| (x, x * 10)).collect();
+    btree_map = btree_map.into_iter().filter(|(k, _)| k % 2 == 0).collect();
+
+    let mut btree_set = BTreeSet::from([1, 2, 3, 4, 5, 6]);
+    btree_set = btree_set.iter().filter(|&x| x % 2 == 0).copied().collect();
+}
+
+fn _msrv_126() {
+    #![clippy::msrv = "1.25"]
+    let mut s = String::from("foobar");
+    s = s.chars().filter(|&c| c != 'o').to_owned().collect();
+}
+
+fn _msrv_118() {
+    #![clippy::msrv = "1.17"]
+    let mut hash_set = HashSet::from([1, 2, 3, 4, 5, 6]);
+    hash_set = hash_set.into_iter().filter(|x| x % 2 == 0).collect();
+    let mut hash_map: HashMap<i8, i8> = (0..8).map(|x| (x, x * 10)).collect();
+    hash_map = hash_map.into_iter().filter(|(k, _)| k % 2 == 0).collect();
+}
diff --git a/tests/ui/use_retain.stderr b/tests/ui/use_retain.stderr
index e29d40a2e39..decd406f22a 100644
--- a/tests/ui/use_retain.stderr
+++ b/tests/ui/use_retain.stderr
@@ -1,5 +1,5 @@
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/use_retain.rs:47:5
+  --> $DIR/use_retain.rs:52:5
    |
 LL |     btree_map = btree_map.into_iter().filter(|(k, _)| k % 2 == 0).collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `btree_map.retain(|k, _| k % 2 == 0)`
@@ -7,13 +7,13 @@ LL |     btree_map = btree_map.into_iter().filter(|(k, _)| k % 2 == 0).collect()
    = note: `-D clippy::use-retain` implied by `-D warnings`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/use_retain.rs:48:5
+  --> $DIR/use_retain.rs:53:5
    |
 LL |     btree_map = btree_map.into_iter().filter(|(_, v)| v % 2 == 0).collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `btree_map.retain(|_, &mut v| v % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/use_retain.rs:49:5
+  --> $DIR/use_retain.rs:54:5
    |
 LL | /     btree_map = btree_map
 LL | |         .into_iter()
@@ -22,37 +22,37 @@ LL | |         .collect();
    | |__________________^ help: consider calling `.retain()` instead: `btree_map.retain(|k, &mut v| (k % 2 == 0) && (v % 2 == 0))`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/use_retain.rs:71:5
+  --> $DIR/use_retain.rs:76:5
    |
 LL |     btree_set = btree_set.iter().filter(|&x| x % 2 == 0).copied().collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `btree_set.retain(|x| x % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/use_retain.rs:72:5
+  --> $DIR/use_retain.rs:77:5
    |
 LL |     btree_set = btree_set.iter().filter(|&x| x % 2 == 0).cloned().collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `btree_set.retain(|x| x % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/use_retain.rs:73:5
+  --> $DIR/use_retain.rs:78:5
    |
 LL |     btree_set = btree_set.into_iter().filter(|x| x % 2 == 0).collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `btree_set.retain(|x| x % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/use_retain.rs:103:5
+  --> $DIR/use_retain.rs:108:5
    |
 LL |     hash_map = hash_map.into_iter().filter(|(k, _)| k % 2 == 0).collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `hash_map.retain(|k, _| k % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/use_retain.rs:104:5
+  --> $DIR/use_retain.rs:109:5
    |
 LL |     hash_map = hash_map.into_iter().filter(|(_, v)| v % 2 == 0).collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `hash_map.retain(|_, &mut v| v % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/use_retain.rs:105:5
+  --> $DIR/use_retain.rs:110:5
    |
 LL | /     hash_map = hash_map
 LL | |         .into_iter()
@@ -61,61 +61,61 @@ LL | |         .collect();
    | |__________________^ help: consider calling `.retain()` instead: `hash_map.retain(|k, &mut v| (k % 2 == 0) && (v % 2 == 0))`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/use_retain.rs:126:5
+  --> $DIR/use_retain.rs:131:5
    |
 LL |     hash_set = hash_set.into_iter().filter(|x| x % 2 == 0).collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `hash_set.retain(|x| x % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/use_retain.rs:127:5
+  --> $DIR/use_retain.rs:132:5
    |
 LL |     hash_set = hash_set.iter().filter(|&x| x % 2 == 0).copied().collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `hash_set.retain(|x| x % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/use_retain.rs:128:5
+  --> $DIR/use_retain.rs:133:5
    |
 LL |     hash_set = hash_set.iter().filter(|&x| x % 2 == 0).cloned().collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `hash_set.retain(|x| x % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/use_retain.rs:157:5
+  --> $DIR/use_retain.rs:162:5
    |
 LL |     s = s.chars().filter(|&c| c != 'o').to_owned().collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `s.retain(|c| c != 'o')`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/use_retain.rs:169:5
+  --> $DIR/use_retain.rs:174:5
    |
 LL |     vec = vec.iter().filter(|&x| x % 2 == 0).copied().collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `vec.retain(|x| x % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/use_retain.rs:170:5
+  --> $DIR/use_retain.rs:175:5
    |
 LL |     vec = vec.iter().filter(|&x| x % 2 == 0).cloned().collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `vec.retain(|x| x % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/use_retain.rs:171:5
+  --> $DIR/use_retain.rs:176:5
    |
 LL |     vec = vec.into_iter().filter(|x| x % 2 == 0).collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `vec.retain(|x| x % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/use_retain.rs:193:5
+  --> $DIR/use_retain.rs:198:5
    |
 LL |     vec_deque = vec_deque.iter().filter(|&x| x % 2 == 0).copied().collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `vec_deque.retain(|x| x % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/use_retain.rs:194:5
+  --> $DIR/use_retain.rs:199:5
    |
 LL |     vec_deque = vec_deque.iter().filter(|&x| x % 2 == 0).cloned().collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `vec_deque.retain(|x| x % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/use_retain.rs:195:5
+  --> $DIR/use_retain.rs:200:5
    |
 LL |     vec_deque = vec_deque.into_iter().filter(|x| x % 2 == 0).collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `vec_deque.retain(|x| x % 2 == 0)`
-- 
cgit 1.4.1-3-g733a5


From dd3d0fdad30249505688eada4481b1d78190e971 Mon Sep 17 00:00:00 2001
From: kyoto7250 <50972773+kyoto7250@users.noreply.github.com>
Date: Fri, 10 Jun 2022 21:02:43 +0900
Subject: rename use_retain => manual_retain

---
 CHANGELOG.md                           |   2 +-
 clippy_lints/src/lib.register_all.rs   |   2 +-
 clippy_lints/src/lib.register_lints.rs |   2 +-
 clippy_lints/src/lib.register_perf.rs  |   2 +-
 clippy_lints/src/lib.rs                |   4 +-
 clippy_lints/src/manual_retain.rs      | 228 ++++++++++++++++++++++++++++++
 clippy_lints/src/use_retain.rs         | 228 ------------------------------
 tests/ui/manual_retain.fixed           | 240 ++++++++++++++++++++++++++++++++
 tests/ui/manual_retain.rs              | 246 +++++++++++++++++++++++++++++++++
 tests/ui/manual_retain.stderr          | 124 +++++++++++++++++
 tests/ui/use_retain.fixed              | 240 --------------------------------
 tests/ui/use_retain.rs                 | 246 ---------------------------------
 tests/ui/use_retain.stderr             | 124 -----------------
 13 files changed, 844 insertions(+), 844 deletions(-)
 create mode 100644 clippy_lints/src/manual_retain.rs
 delete mode 100644 clippy_lints/src/use_retain.rs
 create mode 100644 tests/ui/manual_retain.fixed
 create mode 100644 tests/ui/manual_retain.rs
 create mode 100644 tests/ui/manual_retain.stderr
 delete mode 100644 tests/ui/use_retain.fixed
 delete mode 100644 tests/ui/use_retain.rs
 delete mode 100644 tests/ui/use_retain.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 56143e1cdb9..cff60a21c99 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3528,6 +3528,7 @@ Released 2018-09-13
 [`manual_ok_or`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_ok_or
 [`manual_range_contains`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_range_contains
 [`manual_rem_euclid`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_rem_euclid
+[`manual_retain`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_retain
 [`manual_saturating_arithmetic`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_saturating_arithmetic
 [`manual_split_once`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_split_once
 [`manual_str_repeat`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_str_repeat
@@ -3840,7 +3841,6 @@ Released 2018-09-13
 [`unwrap_used`]: https://rust-lang.github.io/rust-clippy/master/index.html#unwrap_used
 [`upper_case_acronyms`]: https://rust-lang.github.io/rust-clippy/master/index.html#upper_case_acronyms
 [`use_debug`]: https://rust-lang.github.io/rust-clippy/master/index.html#use_debug
-[`use_retain`]: https://rust-lang.github.io/rust-clippy/master/index.html#use_retain
 [`use_self`]: https://rust-lang.github.io/rust-clippy/master/index.html#use_self
 [`used_underscore_binding`]: https://rust-lang.github.io/rust-clippy/master/index.html#used_underscore_binding
 [`useless_asref`]: https://rust-lang.github.io/rust-clippy/master/index.html#useless_asref
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 88e4c291b68..696f0c6f6b3 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -136,6 +136,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(manual_bits::MANUAL_BITS),
     LintId::of(manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE),
     LintId::of(manual_rem_euclid::MANUAL_REM_EUCLID),
+    LintId::of(manual_retain::MANUAL_RETAIN),
     LintId::of(manual_strip::MANUAL_STRIP),
     LintId::of(map_clone::MAP_CLONE),
     LintId::of(map_unit_fn::OPTION_MAP_UNIT_FN),
@@ -336,7 +337,6 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(unwrap::PANICKING_UNWRAP),
     LintId::of(unwrap::UNNECESSARY_UNWRAP),
     LintId::of(upper_case_acronyms::UPPER_CASE_ACRONYMS),
-    LintId::of(use_retain::USE_RETAIN),
     LintId::of(useless_conversion::USELESS_CONVERSION),
     LintId::of(vec::USELESS_VEC),
     LintId::of(vec_init_then_push::VEC_INIT_THEN_PUSH),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 187786e80da..f24c65fb35b 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -255,6 +255,7 @@ store.register_lints(&[
     manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE,
     manual_ok_or::MANUAL_OK_OR,
     manual_rem_euclid::MANUAL_REM_EUCLID,
+    manual_retain::MANUAL_RETAIN,
     manual_strip::MANUAL_STRIP,
     map_clone::MAP_CLONE,
     map_err_ignore::MAP_ERR_IGNORE,
@@ -563,7 +564,6 @@ store.register_lints(&[
     unwrap::UNNECESSARY_UNWRAP,
     unwrap_in_result::UNWRAP_IN_RESULT,
     upper_case_acronyms::UPPER_CASE_ACRONYMS,
-    use_retain::USE_RETAIN,
     use_self::USE_SELF,
     useless_conversion::USELESS_CONVERSION,
     vec::USELESS_VEC,
diff --git a/clippy_lints/src/lib.register_perf.rs b/clippy_lints/src/lib.register_perf.rs
index b9d8ec72541..2233b118849 100644
--- a/clippy_lints/src/lib.register_perf.rs
+++ b/clippy_lints/src/lib.register_perf.rs
@@ -13,6 +13,7 @@ store.register_group(true, "clippy::perf", Some("clippy_perf"), vec![
     LintId::of(loops::MANUAL_MEMCPY),
     LintId::of(loops::MISSING_SPIN_LOOP),
     LintId::of(loops::NEEDLESS_COLLECT),
+    LintId::of(manual_retain::MANUAL_RETAIN),
     LintId::of(methods::EXPECT_FUN_CALL),
     LintId::of(methods::EXTEND_WITH_DRAIN),
     LintId::of(methods::ITER_NTH),
@@ -26,7 +27,6 @@ store.register_group(true, "clippy::perf", Some("clippy_perf"), vec![
     LintId::of(slow_vector_initialization::SLOW_VECTOR_INITIALIZATION),
     LintId::of(types::BOX_COLLECTION),
     LintId::of(types::REDUNDANT_ALLOCATION),
-    LintId::of(use_retain::USE_RETAIN),
     LintId::of(vec::USELESS_VEC),
     LintId::of(vec_init_then_push::VEC_INIT_THEN_PUSH),
 ])
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 716038aa522..a068d5ab522 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -283,6 +283,7 @@ mod manual_bits;
 mod manual_non_exhaustive;
 mod manual_ok_or;
 mod manual_rem_euclid;
+mod manual_retain;
 mod manual_strip;
 mod map_clone;
 mod map_err_ignore;
@@ -410,7 +411,6 @@ mod unused_unit;
 mod unwrap;
 mod unwrap_in_result;
 mod upper_case_acronyms;
-mod use_retain;
 mod use_self;
 mod useless_conversion;
 mod vec;
@@ -915,7 +915,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(read_zero_byte_vec::ReadZeroByteVec));
     store.register_late_pass(|| Box::new(default_instead_of_iter_empty::DefaultIterEmpty));
     store.register_late_pass(move || Box::new(manual_rem_euclid::ManualRemEuclid::new(msrv)));
-    store.register_late_pass(move || Box::new(use_retain::UseRetain::new(msrv)));
+    store.register_late_pass(move || Box::new(manual_retain::ManualRetain::new(msrv)));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/manual_retain.rs b/clippy_lints/src/manual_retain.rs
new file mode 100644
index 00000000000..450c6d343c0
--- /dev/null
+++ b/clippy_lints/src/manual_retain.rs
@@ -0,0 +1,228 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet;
+use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::{get_parent_expr, match_def_path, paths, SpanlessEq};
+use clippy_utils::{meets_msrv, msrvs};
+use rustc_errors::Applicability;
+use rustc_hir as hir;
+use rustc_hir::def_id::DefId;
+use rustc_hir::ExprKind::Assign;
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_semver::RustcVersion;
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::symbol::sym;
+
+const ACCEPTABLE_METHODS: [&[&str]; 4] = [
+    &paths::HASHSET_ITER,
+    &paths::BTREESET_ITER,
+    &paths::SLICE_INTO,
+    &paths::VEC_DEQUE_ITER,
+];
+const ACCEPTABLE_TYPES: [(rustc_span::Symbol, Option<RustcVersion>); 6] = [
+    (sym::BTreeSet, Some(msrvs::BTREE_SET_RETAIN)),
+    (sym::BTreeMap, Some(msrvs::BTREE_MAP_RETAIN)),
+    (sym::HashSet, Some(msrvs::HASH_SET_RETAIN)),
+    (sym::HashMap, Some(msrvs::HASH_MAP_RETAIN)),
+    (sym::Vec, None),
+    (sym::VecDeque, None),
+];
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for code to be replaced by `.retain()`.
+    /// ### Why is this bad?
+    /// `.retain()` is simpler and avoids needless allocation.
+    /// ### Example
+    /// ```rust
+    /// let mut vec = vec![0, 1, 2];
+    /// vec = vec.iter().filter(|&x| x % 2 == 0).copied().collect();
+    /// vec = vec.into_iter().filter(|x| x % 2 == 0).collect();
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// let mut vec = vec![0, 1, 2];
+    /// vec.retain(|x| x % 2 == 0);
+    /// ```
+    #[clippy::version = "1.63.0"]
+    pub MANUAL_RETAIN,
+    perf,
+    "`retain()` is simpler and the same functionalitys"
+}
+
+pub struct ManualRetain {
+    msrv: Option<RustcVersion>,
+}
+
+impl ManualRetain {
+    #[must_use]
+    pub fn new(msrv: Option<RustcVersion>) -> Self {
+        Self { msrv }
+    }
+}
+
+impl_lint_pass!(ManualRetain => [MANUAL_RETAIN]);
+
+impl<'tcx> LateLintPass<'tcx> for ManualRetain {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
+        if let Some(parent_expr) = get_parent_expr(cx, expr)
+            && let Assign(left_expr, collect_expr, _) = &parent_expr.kind
+            && let hir::ExprKind::MethodCall(seg, _, _) = &collect_expr.kind
+            && seg.args.is_none()
+            && let hir::ExprKind::MethodCall(_, [target_expr], _) = &collect_expr.kind
+            && let Some(collect_def_id) = cx.typeck_results().type_dependent_def_id(collect_expr.hir_id)
+            && match_def_path(cx, collect_def_id, &paths::CORE_ITER_COLLECT) {
+            check_into_iter(cx, parent_expr, left_expr, target_expr, self.msrv);
+            check_iter(cx, parent_expr, left_expr, target_expr, self.msrv);
+            check_to_owned(cx, parent_expr, left_expr, target_expr, self.msrv);
+        }
+    }
+
+    extract_msrv_attr!(LateContext);
+}
+
+fn check_into_iter(
+    cx: &LateContext<'_>,
+    parent_expr: &hir::Expr<'_>,
+    left_expr: &hir::Expr<'_>,
+    target_expr: &hir::Expr<'_>,
+    msrv: Option<RustcVersion>,
+) {
+    if let hir::ExprKind::MethodCall(_, [into_iter_expr, _], _) = &target_expr.kind
+        && let Some(filter_def_id) = cx.typeck_results().type_dependent_def_id(target_expr.hir_id)
+        && match_def_path(cx, filter_def_id, &paths::CORE_ITER_FILTER)
+        && let hir::ExprKind::MethodCall(_, [struct_expr], _) = &into_iter_expr.kind
+        && let Some(into_iter_def_id) = cx.typeck_results().type_dependent_def_id(into_iter_expr.hir_id)
+        && match_def_path(cx, into_iter_def_id, &paths::CORE_ITER_INTO_ITER)
+        && match_acceptable_type(cx, left_expr, msrv)
+        && SpanlessEq::new(cx).eq_expr(left_expr, struct_expr) {
+        suggest(cx, parent_expr, left_expr, target_expr);
+    }
+}
+
+fn check_iter(
+    cx: &LateContext<'_>,
+    parent_expr: &hir::Expr<'_>,
+    left_expr: &hir::Expr<'_>,
+    target_expr: &hir::Expr<'_>,
+    msrv: Option<RustcVersion>,
+) {
+    if let hir::ExprKind::MethodCall(_, [filter_expr], _) = &target_expr.kind
+        && let Some(copied_def_id) = cx.typeck_results().type_dependent_def_id(target_expr.hir_id)
+        && (match_def_path(cx, copied_def_id, &paths::CORE_ITER_COPIED)
+            || match_def_path(cx, copied_def_id, &paths::CORE_ITER_CLONED))
+        && let hir::ExprKind::MethodCall(_, [iter_expr, _], _) = &filter_expr.kind
+        && let Some(filter_def_id) = cx.typeck_results().type_dependent_def_id(filter_expr.hir_id)
+        && match_def_path(cx, filter_def_id, &paths::CORE_ITER_FILTER)
+        && let hir::ExprKind::MethodCall(_, [struct_expr], _) = &iter_expr.kind
+        && let Some(iter_expr_def_id) = cx.typeck_results().type_dependent_def_id(iter_expr.hir_id)
+        && match_acceptable_def_path(cx, iter_expr_def_id)
+        && match_acceptable_type(cx, left_expr, msrv)
+        && SpanlessEq::new(cx).eq_expr(left_expr, struct_expr) {
+        suggest(cx, parent_expr, left_expr, filter_expr);
+    }
+}
+
+fn check_to_owned(
+    cx: &LateContext<'_>,
+    parent_expr: &hir::Expr<'_>,
+    left_expr: &hir::Expr<'_>,
+    target_expr: &hir::Expr<'_>,
+    msrv: Option<RustcVersion>,
+) {
+    if meets_msrv(msrv,  msrvs::STRING_RETAIN)
+        && let hir::ExprKind::MethodCall(_, [filter_expr], _) = &target_expr.kind
+        && let Some(to_owned_def_id) = cx.typeck_results().type_dependent_def_id(target_expr.hir_id)
+        && match_def_path(cx, to_owned_def_id, &paths::TO_OWNED_METHOD)
+        && let hir::ExprKind::MethodCall(_, [chars_expr, _], _) = &filter_expr.kind
+        && let Some(filter_def_id) = cx.typeck_results().type_dependent_def_id(filter_expr.hir_id)
+        && match_def_path(cx, filter_def_id, &paths::CORE_ITER_FILTER)
+        && let hir::ExprKind::MethodCall(_, [str_expr], _) = &chars_expr.kind
+        && let Some(chars_expr_def_id) = cx.typeck_results().type_dependent_def_id(chars_expr.hir_id)
+        && match_def_path(cx, chars_expr_def_id, &paths::STR_CHARS)
+        && let ty = cx.typeck_results().expr_ty(str_expr).peel_refs()
+        && is_type_diagnostic_item(cx, ty, sym::String)
+        && SpanlessEq::new(cx).eq_expr(left_expr, str_expr) {
+        suggest(cx, parent_expr, left_expr, filter_expr);
+    }
+}
+
+fn suggest(cx: &LateContext<'_>, parent_expr: &hir::Expr<'_>, left_expr: &hir::Expr<'_>, filter_expr: &hir::Expr<'_>) {
+    if let hir::ExprKind::MethodCall(_, [_, closure], _) = filter_expr.kind
+        && let hir::ExprKind::Closure(_, _, filter_body_id, ..) = closure.kind
+        && let filter_body = cx.tcx.hir().body(filter_body_id)
+        && let [filter_params] = filter_body.params
+        && let Some(sugg) = match filter_params.pat.kind {
+            hir::PatKind::Binding(_, _, filter_param_ident, None) => {
+                Some(format!("{}.retain(|{}| {})", snippet(cx, left_expr.span, ".."), filter_param_ident, snippet(cx, filter_body.value.span, "..")))
+            },
+            hir::PatKind::Tuple([key_pat, value_pat], _) => {
+                make_sugg(cx, key_pat, value_pat, left_expr, filter_body)
+            },
+            hir::PatKind::Ref(pat, _) => {
+                match pat.kind {
+                    hir::PatKind::Binding(_, _, filter_param_ident, None) => {
+                        Some(format!("{}.retain(|{}| {})", snippet(cx, left_expr.span, ".."), filter_param_ident, snippet(cx, filter_body.value.span, "..")))
+                    },
+                    _ => None
+                }
+            },
+            _ => None
+        } {
+        span_lint_and_sugg(
+            cx,
+            MANUAL_RETAIN,
+            parent_expr.span,
+            "this expression can be written more simply using `.retain()`",
+            "consider calling `.retain()` instead",
+            sugg,
+            Applicability::MachineApplicable
+        );
+    }
+}
+
+fn make_sugg(
+    cx: &LateContext<'_>,
+    key_pat: &rustc_hir::Pat<'_>,
+    value_pat: &rustc_hir::Pat<'_>,
+    left_expr: &hir::Expr<'_>,
+    filter_body: &hir::Body<'_>,
+) -> Option<String> {
+    match (&key_pat.kind, &value_pat.kind) {
+        (hir::PatKind::Binding(_, _, key_param_ident, None), hir::PatKind::Binding(_, _, value_param_ident, None)) => {
+            Some(format!(
+                "{}.retain(|{}, &mut {}| {})",
+                snippet(cx, left_expr.span, ".."),
+                key_param_ident,
+                value_param_ident,
+                snippet(cx, filter_body.value.span, "..")
+            ))
+        },
+        (hir::PatKind::Binding(_, _, key_param_ident, None), hir::PatKind::Wild) => Some(format!(
+            "{}.retain(|{}, _| {})",
+            snippet(cx, left_expr.span, ".."),
+            key_param_ident,
+            snippet(cx, filter_body.value.span, "..")
+        )),
+        (hir::PatKind::Wild, hir::PatKind::Binding(_, _, value_param_ident, None)) => Some(format!(
+            "{}.retain(|_, &mut {}| {})",
+            snippet(cx, left_expr.span, ".."),
+            value_param_ident,
+            snippet(cx, filter_body.value.span, "..")
+        )),
+        _ => None,
+    }
+}
+
+fn match_acceptable_def_path(cx: &LateContext<'_>, collect_def_id: DefId) -> bool {
+    ACCEPTABLE_METHODS
+        .iter()
+        .any(|&method| match_def_path(cx, collect_def_id, method))
+}
+
+fn match_acceptable_type(cx: &LateContext<'_>, expr: &hir::Expr<'_>, msrv: Option<RustcVersion>) -> bool {
+    let expr_ty = cx.typeck_results().expr_ty(expr).peel_refs();
+    ACCEPTABLE_TYPES.iter().any(|(ty, acceptable_msrv)| {
+        is_type_diagnostic_item(cx, expr_ty, *ty)
+            && acceptable_msrv.map_or(true, |acceptable_msrv| meets_msrv(msrv, acceptable_msrv))
+    })
+}
diff --git a/clippy_lints/src/use_retain.rs b/clippy_lints/src/use_retain.rs
deleted file mode 100644
index 185201514ad..00000000000
--- a/clippy_lints/src/use_retain.rs
+++ /dev/null
@@ -1,228 +0,0 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::source::snippet;
-use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{get_parent_expr, match_def_path, paths, SpanlessEq};
-use clippy_utils::{meets_msrv, msrvs};
-use rustc_errors::Applicability;
-use rustc_hir as hir;
-use rustc_hir::def_id::DefId;
-use rustc_hir::ExprKind::Assign;
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_semver::RustcVersion;
-use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::symbol::sym;
-
-const ACCEPTABLE_METHODS: [&[&str]; 4] = [
-    &paths::HASHSET_ITER,
-    &paths::BTREESET_ITER,
-    &paths::SLICE_INTO,
-    &paths::VEC_DEQUE_ITER,
-];
-const ACCEPTABLE_TYPES: [(rustc_span::Symbol, Option<RustcVersion>); 6] = [
-    (sym::BTreeSet, Some(msrvs::BTREE_SET_RETAIN)),
-    (sym::BTreeMap, Some(msrvs::BTREE_MAP_RETAIN)),
-    (sym::HashSet, Some(msrvs::HASH_SET_RETAIN)),
-    (sym::HashMap, Some(msrvs::HASH_MAP_RETAIN)),
-    (sym::Vec, None),
-    (sym::VecDeque, None),
-];
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for code to be replaced by `.retain()`.
-    /// ### Why is this bad?
-    /// `.retain()` is simpler and avoids needless allocation.
-    /// ### Example
-    /// ```rust
-    /// let mut vec = vec![0, 1, 2];
-    /// vec = vec.iter().filter(|&x| x % 2 == 0).copied().collect();
-    /// vec = vec.into_iter().filter(|x| x % 2 == 0).collect();
-    /// ```
-    /// Use instead:
-    /// ```rust
-    /// let mut vec = vec![0, 1, 2];
-    /// vec.retain(|x| x % 2 == 0);
-    /// ```
-    #[clippy::version = "1.63.0"]
-    pub USE_RETAIN,
-    perf,
-    "`retain()` is simpler and the same functionalitys"
-}
-
-pub struct UseRetain {
-    msrv: Option<RustcVersion>,
-}
-
-impl UseRetain {
-    #[must_use]
-    pub fn new(msrv: Option<RustcVersion>) -> Self {
-        Self { msrv }
-    }
-}
-
-impl_lint_pass!(UseRetain => [USE_RETAIN]);
-
-impl<'tcx> LateLintPass<'tcx> for UseRetain {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
-        if let Some(parent_expr) = get_parent_expr(cx, expr)
-            && let Assign(left_expr, collect_expr, _) = &parent_expr.kind
-            && let hir::ExprKind::MethodCall(seg, _, _) = &collect_expr.kind
-            && seg.args.is_none()
-            && let hir::ExprKind::MethodCall(_, [target_expr], _) = &collect_expr.kind
-            && let Some(collect_def_id) = cx.typeck_results().type_dependent_def_id(collect_expr.hir_id)
-            && match_def_path(cx, collect_def_id, &paths::CORE_ITER_COLLECT) {
-            check_into_iter(cx, parent_expr, left_expr, target_expr, self.msrv);
-            check_iter(cx, parent_expr, left_expr, target_expr, self.msrv);
-            check_to_owned(cx, parent_expr, left_expr, target_expr, self.msrv);
-        }
-    }
-
-    extract_msrv_attr!(LateContext);
-}
-
-fn check_into_iter(
-    cx: &LateContext<'_>,
-    parent_expr: &hir::Expr<'_>,
-    left_expr: &hir::Expr<'_>,
-    target_expr: &hir::Expr<'_>,
-    msrv: Option<RustcVersion>,
-) {
-    if let hir::ExprKind::MethodCall(_, [into_iter_expr, _], _) = &target_expr.kind
-        && let Some(filter_def_id) = cx.typeck_results().type_dependent_def_id(target_expr.hir_id)
-        && match_def_path(cx, filter_def_id, &paths::CORE_ITER_FILTER)
-        && let hir::ExprKind::MethodCall(_, [struct_expr], _) = &into_iter_expr.kind
-        && let Some(into_iter_def_id) = cx.typeck_results().type_dependent_def_id(into_iter_expr.hir_id)
-        && match_def_path(cx, into_iter_def_id, &paths::CORE_ITER_INTO_ITER)
-        && match_acceptable_type(cx, left_expr, msrv)
-        && SpanlessEq::new(cx).eq_expr(left_expr, struct_expr) {
-        suggest(cx, parent_expr, left_expr, target_expr);
-    }
-}
-
-fn check_iter(
-    cx: &LateContext<'_>,
-    parent_expr: &hir::Expr<'_>,
-    left_expr: &hir::Expr<'_>,
-    target_expr: &hir::Expr<'_>,
-    msrv: Option<RustcVersion>,
-) {
-    if let hir::ExprKind::MethodCall(_, [filter_expr], _) = &target_expr.kind
-        && let Some(copied_def_id) = cx.typeck_results().type_dependent_def_id(target_expr.hir_id)
-        && (match_def_path(cx, copied_def_id, &paths::CORE_ITER_COPIED)
-            || match_def_path(cx, copied_def_id, &paths::CORE_ITER_CLONED))
-        && let hir::ExprKind::MethodCall(_, [iter_expr, _], _) = &filter_expr.kind
-        && let Some(filter_def_id) = cx.typeck_results().type_dependent_def_id(filter_expr.hir_id)
-        && match_def_path(cx, filter_def_id, &paths::CORE_ITER_FILTER)
-        && let hir::ExprKind::MethodCall(_, [struct_expr], _) = &iter_expr.kind
-        && let Some(iter_expr_def_id) = cx.typeck_results().type_dependent_def_id(iter_expr.hir_id)
-        && match_acceptable_def_path(cx, iter_expr_def_id)
-        && match_acceptable_type(cx, left_expr, msrv)
-        && SpanlessEq::new(cx).eq_expr(left_expr, struct_expr) {
-        suggest(cx, parent_expr, left_expr, filter_expr);
-    }
-}
-
-fn check_to_owned(
-    cx: &LateContext<'_>,
-    parent_expr: &hir::Expr<'_>,
-    left_expr: &hir::Expr<'_>,
-    target_expr: &hir::Expr<'_>,
-    msrv: Option<RustcVersion>,
-) {
-    if meets_msrv(msrv,  msrvs::STRING_RETAIN)
-        && let hir::ExprKind::MethodCall(_, [filter_expr], _) = &target_expr.kind
-        && let Some(to_owned_def_id) = cx.typeck_results().type_dependent_def_id(target_expr.hir_id)
-        && match_def_path(cx, to_owned_def_id, &paths::TO_OWNED_METHOD)
-        && let hir::ExprKind::MethodCall(_, [chars_expr, _], _) = &filter_expr.kind
-        && let Some(filter_def_id) = cx.typeck_results().type_dependent_def_id(filter_expr.hir_id)
-        && match_def_path(cx, filter_def_id, &paths::CORE_ITER_FILTER)
-        && let hir::ExprKind::MethodCall(_, [str_expr], _) = &chars_expr.kind
-        && let Some(chars_expr_def_id) = cx.typeck_results().type_dependent_def_id(chars_expr.hir_id)
-        && match_def_path(cx, chars_expr_def_id, &paths::STR_CHARS)
-        && let ty = cx.typeck_results().expr_ty(str_expr).peel_refs()
-        && is_type_diagnostic_item(cx, ty, sym::String)
-        && SpanlessEq::new(cx).eq_expr(left_expr, str_expr) {
-        suggest(cx, parent_expr, left_expr, filter_expr);
-    }
-}
-
-fn suggest(cx: &LateContext<'_>, parent_expr: &hir::Expr<'_>, left_expr: &hir::Expr<'_>, filter_expr: &hir::Expr<'_>) {
-    if let hir::ExprKind::MethodCall(_, [_, closure], _) = filter_expr.kind
-        && let hir::ExprKind::Closure(_, _, filter_body_id, ..) = closure.kind
-        && let filter_body = cx.tcx.hir().body(filter_body_id)
-        && let [filter_params] = filter_body.params
-        && let Some(sugg) = match filter_params.pat.kind {
-            hir::PatKind::Binding(_, _, filter_param_ident, None) => {
-                Some(format!("{}.retain(|{}| {})", snippet(cx, left_expr.span, ".."), filter_param_ident, snippet(cx, filter_body.value.span, "..")))
-            },
-            hir::PatKind::Tuple([key_pat, value_pat], _) => {
-                make_sugg(cx, key_pat, value_pat, left_expr, filter_body)
-            },
-            hir::PatKind::Ref(pat, _) => {
-                match pat.kind {
-                    hir::PatKind::Binding(_, _, filter_param_ident, None) => {
-                        Some(format!("{}.retain(|{}| {})", snippet(cx, left_expr.span, ".."), filter_param_ident, snippet(cx, filter_body.value.span, "..")))
-                    },
-                    _ => None
-                }
-            },
-            _ => None
-        } {
-        span_lint_and_sugg(
-            cx,
-            USE_RETAIN,
-            parent_expr.span,
-            "this expression can be written more simply using `.retain()`",
-            "consider calling `.retain()` instead",
-            sugg,
-            Applicability::MachineApplicable
-        );
-    }
-}
-
-fn make_sugg(
-    cx: &LateContext<'_>,
-    key_pat: &rustc_hir::Pat<'_>,
-    value_pat: &rustc_hir::Pat<'_>,
-    left_expr: &hir::Expr<'_>,
-    filter_body: &hir::Body<'_>,
-) -> Option<String> {
-    match (&key_pat.kind, &value_pat.kind) {
-        (hir::PatKind::Binding(_, _, key_param_ident, None), hir::PatKind::Binding(_, _, value_param_ident, None)) => {
-            Some(format!(
-                "{}.retain(|{}, &mut {}| {})",
-                snippet(cx, left_expr.span, ".."),
-                key_param_ident,
-                value_param_ident,
-                snippet(cx, filter_body.value.span, "..")
-            ))
-        },
-        (hir::PatKind::Binding(_, _, key_param_ident, None), hir::PatKind::Wild) => Some(format!(
-            "{}.retain(|{}, _| {})",
-            snippet(cx, left_expr.span, ".."),
-            key_param_ident,
-            snippet(cx, filter_body.value.span, "..")
-        )),
-        (hir::PatKind::Wild, hir::PatKind::Binding(_, _, value_param_ident, None)) => Some(format!(
-            "{}.retain(|_, &mut {}| {})",
-            snippet(cx, left_expr.span, ".."),
-            value_param_ident,
-            snippet(cx, filter_body.value.span, "..")
-        )),
-        _ => None,
-    }
-}
-
-fn match_acceptable_def_path(cx: &LateContext<'_>, collect_def_id: DefId) -> bool {
-    ACCEPTABLE_METHODS
-        .iter()
-        .any(|&method| match_def_path(cx, collect_def_id, method))
-}
-
-fn match_acceptable_type(cx: &LateContext<'_>, expr: &hir::Expr<'_>, msrv: Option<RustcVersion>) -> bool {
-    let expr_ty = cx.typeck_results().expr_ty(expr).peel_refs();
-    ACCEPTABLE_TYPES.iter().any(|(ty, acceptable_msrv)| {
-        is_type_diagnostic_item(cx, expr_ty, *ty)
-            && acceptable_msrv.map_or(true, |acceptable_msrv| meets_msrv(msrv, acceptable_msrv))
-    })
-}
diff --git a/tests/ui/manual_retain.fixed b/tests/ui/manual_retain.fixed
new file mode 100644
index 00000000000..fba503a2066
--- /dev/null
+++ b/tests/ui/manual_retain.fixed
@@ -0,0 +1,240 @@
+// run-rustfix
+#![feature(custom_inner_attributes)]
+#![warn(clippy::manual_retain)]
+#![allow(unused)]
+use std::collections::BTreeMap;
+use std::collections::BTreeSet;
+use std::collections::BinaryHeap;
+use std::collections::HashMap;
+use std::collections::HashSet;
+use std::collections::VecDeque;
+
+fn main() {
+    binary_heap_retain();
+    btree_set_retain();
+    btree_map_retain();
+    hash_set_retain();
+    hash_map_retain();
+    string_retain();
+    vec_deque_retain();
+    vec_retain();
+    _msrv_153();
+    _msrv_126();
+    _msrv_118();
+}
+
+fn binary_heap_retain() {
+    // NOTE: Do not lint now, because binary_heap_retain is nighyly API.
+    // And we need to add a test case for msrv if we update this implmention.
+    // https://github.com/rust-lang/rust/issues/71503
+    let mut heap = BinaryHeap::from([1, 2, 3]);
+    heap = heap.into_iter().filter(|x| x % 2 == 0).collect();
+    heap = heap.iter().filter(|&x| x % 2 == 0).copied().collect();
+    heap = heap.iter().filter(|&x| x % 2 == 0).cloned().collect();
+
+    // Do not lint, because type conversion is performed
+    heap = heap.into_iter().filter(|x| x % 2 == 0).collect::<BinaryHeap<i8>>();
+    heap = heap.iter().filter(|&x| x % 2 == 0).copied().collect::<BinaryHeap<i8>>();
+    heap = heap.iter().filter(|&x| x % 2 == 0).cloned().collect::<BinaryHeap<i8>>();
+
+    // Do not lint, because this expression is not assign.
+    let mut bar: BinaryHeap<i8> = heap.iter().filter(|&x| x % 2 == 0).copied().collect();
+    let mut foobar: BinaryHeap<i8> = heap.into_iter().filter(|x| x % 2 == 0).collect();
+
+    // Do not lint, because it is an assignment to a different variable.
+    bar = foobar.iter().filter(|&x| x % 2 == 0).copied().collect();
+    bar = foobar.into_iter().filter(|x| x % 2 == 0).collect();
+}
+
+fn btree_map_retain() {
+    let mut btree_map: BTreeMap<i8, i8> = (0..8).map(|x| (x, x * 10)).collect();
+    // Do lint.
+    btree_map.retain(|k, _| k % 2 == 0);
+    btree_map.retain(|_, &mut v| v % 2 == 0);
+    btree_map.retain(|k, &mut v| (k % 2 == 0) && (v % 2 == 0));
+
+    // Do not lint.
+    btree_map = btree_map
+        .into_iter()
+        .filter(|(x, _)| x % 2 == 0)
+        .collect::<BTreeMap<i8, i8>>();
+
+    // Do not lint, because this expression is not assign.
+    let mut foobar: BTreeMap<i8, i8> = btree_map.into_iter().filter(|(k, _)| k % 2 == 0).collect();
+
+    // Do not lint, because it is an assignment to a different variable.
+    btree_map = foobar.into_iter().filter(|(k, _)| k % 2 == 0).collect();
+}
+
+fn btree_set_retain() {
+    let mut btree_set = BTreeSet::from([1, 2, 3, 4, 5, 6]);
+
+    // Do lint.
+    btree_set.retain(|x| x % 2 == 0);
+    btree_set.retain(|x| x % 2 == 0);
+    btree_set.retain(|x| x % 2 == 0);
+
+    // Do not lint, because type conversion is performed
+    btree_set = btree_set
+        .iter()
+        .filter(|&x| x % 2 == 0)
+        .copied()
+        .collect::<BTreeSet<i8>>();
+
+    btree_set = btree_set
+        .iter()
+        .filter(|&x| x % 2 == 0)
+        .cloned()
+        .collect::<BTreeSet<i8>>();
+
+    btree_set = btree_set.into_iter().filter(|x| x % 2 == 0).collect::<BTreeSet<i8>>();
+
+    // Do not lint, because this expression is not assign.
+    let mut foobar: BTreeSet<i8> = btree_set.iter().filter(|&x| x % 2 == 0).copied().collect();
+    let mut bar: BTreeSet<i8> = btree_set.into_iter().filter(|x| x % 2 == 0).collect();
+
+    // Do not lint, because it is an assignment to a different variable.
+    bar = foobar.iter().filter(|&x| x % 2 == 0).copied().collect();
+    bar = foobar.iter().filter(|&x| x % 2 == 0).cloned().collect();
+    bar = foobar.into_iter().filter(|x| x % 2 == 0).collect();
+}
+
+fn hash_map_retain() {
+    let mut hash_map: HashMap<i8, i8> = (0..8).map(|x| (x, x * 10)).collect();
+    // Do lint.
+    hash_map.retain(|k, _| k % 2 == 0);
+    hash_map.retain(|_, &mut v| v % 2 == 0);
+    hash_map.retain(|k, &mut v| (k % 2 == 0) && (v % 2 == 0));
+
+    // Do not lint.
+    hash_map = hash_map
+        .into_iter()
+        .filter(|(x, _)| x % 2 == 0)
+        .collect::<HashMap<i8, i8>>();
+
+    // Do not lint, because this expression is not assign.
+    let mut foobar: HashMap<i8, i8> = hash_map.into_iter().filter(|(k, _)| k % 2 == 0).collect();
+
+    // Do not lint, because it is an assignment to a different variable.
+    hash_map = foobar.into_iter().filter(|(k, _)| k % 2 == 0).collect();
+}
+
+fn hash_set_retain() {
+    let mut hash_set = HashSet::from([1, 2, 3, 4, 5, 6]);
+    // Do lint.
+    hash_set.retain(|x| x % 2 == 0);
+    hash_set.retain(|x| x % 2 == 0);
+    hash_set.retain(|x| x % 2 == 0);
+
+    // Do not lint, because type conversion is performed
+    hash_set = hash_set.into_iter().filter(|x| x % 2 == 0).collect::<HashSet<i8>>();
+    hash_set = hash_set
+        .iter()
+        .filter(|&x| x % 2 == 0)
+        .copied()
+        .collect::<HashSet<i8>>();
+
+    hash_set = hash_set
+        .iter()
+        .filter(|&x| x % 2 == 0)
+        .cloned()
+        .collect::<HashSet<i8>>();
+
+    // Do not lint, because this expression is not assign.
+    let mut bar: HashSet<i8> = hash_set.iter().filter(|&x| x % 2 == 0).copied().collect();
+    let mut foobar: HashSet<i8> = hash_set.into_iter().filter(|x| x % 2 == 0).collect();
+
+    // Do not lint, because it is an assignment to a different variable.
+    bar = foobar.iter().filter(|&x| x % 2 == 0).copied().collect();
+    bar = foobar.iter().filter(|&x| x % 2 == 0).cloned().collect();
+    bar = foobar.into_iter().filter(|&x| x % 2 == 0).collect();
+}
+
+fn string_retain() {
+    let mut s = String::from("foobar");
+    // Do lint.
+    s.retain(|c| c != 'o');
+
+    // Do not lint, because this expression is not assign.
+    let mut bar: String = s.chars().filter(|&c| c != 'o').to_owned().collect();
+
+    // Do not lint, because it is an assignment to a different variable.
+    s = bar.chars().filter(|&c| c != 'o').to_owned().collect();
+}
+
+fn vec_retain() {
+    let mut vec = vec![0, 1, 2];
+    // Do lint.
+    vec.retain(|x| x % 2 == 0);
+    vec.retain(|x| x % 2 == 0);
+    vec.retain(|x| x % 2 == 0);
+
+    // Do not lint, because type conversion is performed
+    vec = vec.into_iter().filter(|x| x % 2 == 0).collect::<Vec<i8>>();
+    vec = vec.iter().filter(|&x| x % 2 == 0).copied().collect::<Vec<i8>>();
+    vec = vec.iter().filter(|&x| x % 2 == 0).cloned().collect::<Vec<i8>>();
+
+    // Do not lint, because this expression is not assign.
+    let mut bar: Vec<i8> = vec.iter().filter(|&x| x % 2 == 0).copied().collect();
+    let mut foobar: Vec<i8> = vec.into_iter().filter(|x| x % 2 == 0).collect();
+
+    // Do not lint, because it is an assignment to a different variable.
+    bar = foobar.iter().filter(|&x| x % 2 == 0).copied().collect();
+    bar = foobar.iter().filter(|&x| x % 2 == 0).cloned().collect();
+    bar = foobar.into_iter().filter(|x| x % 2 == 0).collect();
+}
+
+fn vec_deque_retain() {
+    let mut vec_deque = VecDeque::new();
+    vec_deque.extend(1..5);
+
+    // Do lint.
+    vec_deque.retain(|x| x % 2 == 0);
+    vec_deque.retain(|x| x % 2 == 0);
+    vec_deque.retain(|x| x % 2 == 0);
+
+    // Do not lint, because type conversion is performed
+    vec_deque = vec_deque
+        .iter()
+        .filter(|&x| x % 2 == 0)
+        .copied()
+        .collect::<VecDeque<i8>>();
+    vec_deque = vec_deque
+        .iter()
+        .filter(|&x| x % 2 == 0)
+        .cloned()
+        .collect::<VecDeque<i8>>();
+    vec_deque = vec_deque.into_iter().filter(|x| x % 2 == 0).collect::<VecDeque<i8>>();
+
+    // Do not lint, because this expression is not assign.
+    let mut bar: VecDeque<i8> = vec_deque.iter().filter(|&x| x % 2 == 0).copied().collect();
+    let mut foobar: VecDeque<i8> = vec_deque.into_iter().filter(|x| x % 2 == 0).collect();
+
+    // Do not lint, because it is an assignment to a different variable.
+    bar = foobar.iter().filter(|&x| x % 2 == 0).copied().collect();
+    bar = foobar.iter().filter(|&x| x % 2 == 0).cloned().collect();
+    bar = foobar.into_iter().filter(|x| x % 2 == 0).collect();
+}
+
+fn _msrv_153() {
+    #![clippy::msrv = "1.52"]
+    let mut btree_map: BTreeMap<i8, i8> = (0..8).map(|x| (x, x * 10)).collect();
+    btree_map = btree_map.into_iter().filter(|(k, _)| k % 2 == 0).collect();
+
+    let mut btree_set = BTreeSet::from([1, 2, 3, 4, 5, 6]);
+    btree_set = btree_set.iter().filter(|&x| x % 2 == 0).copied().collect();
+}
+
+fn _msrv_126() {
+    #![clippy::msrv = "1.25"]
+    let mut s = String::from("foobar");
+    s = s.chars().filter(|&c| c != 'o').to_owned().collect();
+}
+
+fn _msrv_118() {
+    #![clippy::msrv = "1.17"]
+    let mut hash_set = HashSet::from([1, 2, 3, 4, 5, 6]);
+    hash_set = hash_set.into_iter().filter(|x| x % 2 == 0).collect();
+    let mut hash_map: HashMap<i8, i8> = (0..8).map(|x| (x, x * 10)).collect();
+    hash_map = hash_map.into_iter().filter(|(k, _)| k % 2 == 0).collect();
+}
diff --git a/tests/ui/manual_retain.rs b/tests/ui/manual_retain.rs
new file mode 100644
index 00000000000..81a849fe768
--- /dev/null
+++ b/tests/ui/manual_retain.rs
@@ -0,0 +1,246 @@
+// run-rustfix
+#![feature(custom_inner_attributes)]
+#![warn(clippy::manual_retain)]
+#![allow(unused)]
+use std::collections::BTreeMap;
+use std::collections::BTreeSet;
+use std::collections::BinaryHeap;
+use std::collections::HashMap;
+use std::collections::HashSet;
+use std::collections::VecDeque;
+
+fn main() {
+    binary_heap_retain();
+    btree_set_retain();
+    btree_map_retain();
+    hash_set_retain();
+    hash_map_retain();
+    string_retain();
+    vec_deque_retain();
+    vec_retain();
+    _msrv_153();
+    _msrv_126();
+    _msrv_118();
+}
+
+fn binary_heap_retain() {
+    // NOTE: Do not lint now, because binary_heap_retain is nighyly API.
+    // And we need to add a test case for msrv if we update this implmention.
+    // https://github.com/rust-lang/rust/issues/71503
+    let mut heap = BinaryHeap::from([1, 2, 3]);
+    heap = heap.into_iter().filter(|x| x % 2 == 0).collect();
+    heap = heap.iter().filter(|&x| x % 2 == 0).copied().collect();
+    heap = heap.iter().filter(|&x| x % 2 == 0).cloned().collect();
+
+    // Do not lint, because type conversion is performed
+    heap = heap.into_iter().filter(|x| x % 2 == 0).collect::<BinaryHeap<i8>>();
+    heap = heap.iter().filter(|&x| x % 2 == 0).copied().collect::<BinaryHeap<i8>>();
+    heap = heap.iter().filter(|&x| x % 2 == 0).cloned().collect::<BinaryHeap<i8>>();
+
+    // Do not lint, because this expression is not assign.
+    let mut bar: BinaryHeap<i8> = heap.iter().filter(|&x| x % 2 == 0).copied().collect();
+    let mut foobar: BinaryHeap<i8> = heap.into_iter().filter(|x| x % 2 == 0).collect();
+
+    // Do not lint, because it is an assignment to a different variable.
+    bar = foobar.iter().filter(|&x| x % 2 == 0).copied().collect();
+    bar = foobar.into_iter().filter(|x| x % 2 == 0).collect();
+}
+
+fn btree_map_retain() {
+    let mut btree_map: BTreeMap<i8, i8> = (0..8).map(|x| (x, x * 10)).collect();
+    // Do lint.
+    btree_map = btree_map.into_iter().filter(|(k, _)| k % 2 == 0).collect();
+    btree_map = btree_map.into_iter().filter(|(_, v)| v % 2 == 0).collect();
+    btree_map = btree_map
+        .into_iter()
+        .filter(|(k, v)| (k % 2 == 0) && (v % 2 == 0))
+        .collect();
+
+    // Do not lint.
+    btree_map = btree_map
+        .into_iter()
+        .filter(|(x, _)| x % 2 == 0)
+        .collect::<BTreeMap<i8, i8>>();
+
+    // Do not lint, because this expression is not assign.
+    let mut foobar: BTreeMap<i8, i8> = btree_map.into_iter().filter(|(k, _)| k % 2 == 0).collect();
+
+    // Do not lint, because it is an assignment to a different variable.
+    btree_map = foobar.into_iter().filter(|(k, _)| k % 2 == 0).collect();
+}
+
+fn btree_set_retain() {
+    let mut btree_set = BTreeSet::from([1, 2, 3, 4, 5, 6]);
+
+    // Do lint.
+    btree_set = btree_set.iter().filter(|&x| x % 2 == 0).copied().collect();
+    btree_set = btree_set.iter().filter(|&x| x % 2 == 0).cloned().collect();
+    btree_set = btree_set.into_iter().filter(|x| x % 2 == 0).collect();
+
+    // Do not lint, because type conversion is performed
+    btree_set = btree_set
+        .iter()
+        .filter(|&x| x % 2 == 0)
+        .copied()
+        .collect::<BTreeSet<i8>>();
+
+    btree_set = btree_set
+        .iter()
+        .filter(|&x| x % 2 == 0)
+        .cloned()
+        .collect::<BTreeSet<i8>>();
+
+    btree_set = btree_set.into_iter().filter(|x| x % 2 == 0).collect::<BTreeSet<i8>>();
+
+    // Do not lint, because this expression is not assign.
+    let mut foobar: BTreeSet<i8> = btree_set.iter().filter(|&x| x % 2 == 0).copied().collect();
+    let mut bar: BTreeSet<i8> = btree_set.into_iter().filter(|x| x % 2 == 0).collect();
+
+    // Do not lint, because it is an assignment to a different variable.
+    bar = foobar.iter().filter(|&x| x % 2 == 0).copied().collect();
+    bar = foobar.iter().filter(|&x| x % 2 == 0).cloned().collect();
+    bar = foobar.into_iter().filter(|x| x % 2 == 0).collect();
+}
+
+fn hash_map_retain() {
+    let mut hash_map: HashMap<i8, i8> = (0..8).map(|x| (x, x * 10)).collect();
+    // Do lint.
+    hash_map = hash_map.into_iter().filter(|(k, _)| k % 2 == 0).collect();
+    hash_map = hash_map.into_iter().filter(|(_, v)| v % 2 == 0).collect();
+    hash_map = hash_map
+        .into_iter()
+        .filter(|(k, v)| (k % 2 == 0) && (v % 2 == 0))
+        .collect();
+
+    // Do not lint.
+    hash_map = hash_map
+        .into_iter()
+        .filter(|(x, _)| x % 2 == 0)
+        .collect::<HashMap<i8, i8>>();
+
+    // Do not lint, because this expression is not assign.
+    let mut foobar: HashMap<i8, i8> = hash_map.into_iter().filter(|(k, _)| k % 2 == 0).collect();
+
+    // Do not lint, because it is an assignment to a different variable.
+    hash_map = foobar.into_iter().filter(|(k, _)| k % 2 == 0).collect();
+}
+
+fn hash_set_retain() {
+    let mut hash_set = HashSet::from([1, 2, 3, 4, 5, 6]);
+    // Do lint.
+    hash_set = hash_set.into_iter().filter(|x| x % 2 == 0).collect();
+    hash_set = hash_set.iter().filter(|&x| x % 2 == 0).copied().collect();
+    hash_set = hash_set.iter().filter(|&x| x % 2 == 0).cloned().collect();
+
+    // Do not lint, because type conversion is performed
+    hash_set = hash_set.into_iter().filter(|x| x % 2 == 0).collect::<HashSet<i8>>();
+    hash_set = hash_set
+        .iter()
+        .filter(|&x| x % 2 == 0)
+        .copied()
+        .collect::<HashSet<i8>>();
+
+    hash_set = hash_set
+        .iter()
+        .filter(|&x| x % 2 == 0)
+        .cloned()
+        .collect::<HashSet<i8>>();
+
+    // Do not lint, because this expression is not assign.
+    let mut bar: HashSet<i8> = hash_set.iter().filter(|&x| x % 2 == 0).copied().collect();
+    let mut foobar: HashSet<i8> = hash_set.into_iter().filter(|x| x % 2 == 0).collect();
+
+    // Do not lint, because it is an assignment to a different variable.
+    bar = foobar.iter().filter(|&x| x % 2 == 0).copied().collect();
+    bar = foobar.iter().filter(|&x| x % 2 == 0).cloned().collect();
+    bar = foobar.into_iter().filter(|&x| x % 2 == 0).collect();
+}
+
+fn string_retain() {
+    let mut s = String::from("foobar");
+    // Do lint.
+    s = s.chars().filter(|&c| c != 'o').to_owned().collect();
+
+    // Do not lint, because this expression is not assign.
+    let mut bar: String = s.chars().filter(|&c| c != 'o').to_owned().collect();
+
+    // Do not lint, because it is an assignment to a different variable.
+    s = bar.chars().filter(|&c| c != 'o').to_owned().collect();
+}
+
+fn vec_retain() {
+    let mut vec = vec![0, 1, 2];
+    // Do lint.
+    vec = vec.iter().filter(|&x| x % 2 == 0).copied().collect();
+    vec = vec.iter().filter(|&x| x % 2 == 0).cloned().collect();
+    vec = vec.into_iter().filter(|x| x % 2 == 0).collect();
+
+    // Do not lint, because type conversion is performed
+    vec = vec.into_iter().filter(|x| x % 2 == 0).collect::<Vec<i8>>();
+    vec = vec.iter().filter(|&x| x % 2 == 0).copied().collect::<Vec<i8>>();
+    vec = vec.iter().filter(|&x| x % 2 == 0).cloned().collect::<Vec<i8>>();
+
+    // Do not lint, because this expression is not assign.
+    let mut bar: Vec<i8> = vec.iter().filter(|&x| x % 2 == 0).copied().collect();
+    let mut foobar: Vec<i8> = vec.into_iter().filter(|x| x % 2 == 0).collect();
+
+    // Do not lint, because it is an assignment to a different variable.
+    bar = foobar.iter().filter(|&x| x % 2 == 0).copied().collect();
+    bar = foobar.iter().filter(|&x| x % 2 == 0).cloned().collect();
+    bar = foobar.into_iter().filter(|x| x % 2 == 0).collect();
+}
+
+fn vec_deque_retain() {
+    let mut vec_deque = VecDeque::new();
+    vec_deque.extend(1..5);
+
+    // Do lint.
+    vec_deque = vec_deque.iter().filter(|&x| x % 2 == 0).copied().collect();
+    vec_deque = vec_deque.iter().filter(|&x| x % 2 == 0).cloned().collect();
+    vec_deque = vec_deque.into_iter().filter(|x| x % 2 == 0).collect();
+
+    // Do not lint, because type conversion is performed
+    vec_deque = vec_deque
+        .iter()
+        .filter(|&x| x % 2 == 0)
+        .copied()
+        .collect::<VecDeque<i8>>();
+    vec_deque = vec_deque
+        .iter()
+        .filter(|&x| x % 2 == 0)
+        .cloned()
+        .collect::<VecDeque<i8>>();
+    vec_deque = vec_deque.into_iter().filter(|x| x % 2 == 0).collect::<VecDeque<i8>>();
+
+    // Do not lint, because this expression is not assign.
+    let mut bar: VecDeque<i8> = vec_deque.iter().filter(|&x| x % 2 == 0).copied().collect();
+    let mut foobar: VecDeque<i8> = vec_deque.into_iter().filter(|x| x % 2 == 0).collect();
+
+    // Do not lint, because it is an assignment to a different variable.
+    bar = foobar.iter().filter(|&x| x % 2 == 0).copied().collect();
+    bar = foobar.iter().filter(|&x| x % 2 == 0).cloned().collect();
+    bar = foobar.into_iter().filter(|x| x % 2 == 0).collect();
+}
+
+fn _msrv_153() {
+    #![clippy::msrv = "1.52"]
+    let mut btree_map: BTreeMap<i8, i8> = (0..8).map(|x| (x, x * 10)).collect();
+    btree_map = btree_map.into_iter().filter(|(k, _)| k % 2 == 0).collect();
+
+    let mut btree_set = BTreeSet::from([1, 2, 3, 4, 5, 6]);
+    btree_set = btree_set.iter().filter(|&x| x % 2 == 0).copied().collect();
+}
+
+fn _msrv_126() {
+    #![clippy::msrv = "1.25"]
+    let mut s = String::from("foobar");
+    s = s.chars().filter(|&c| c != 'o').to_owned().collect();
+}
+
+fn _msrv_118() {
+    #![clippy::msrv = "1.17"]
+    let mut hash_set = HashSet::from([1, 2, 3, 4, 5, 6]);
+    hash_set = hash_set.into_iter().filter(|x| x % 2 == 0).collect();
+    let mut hash_map: HashMap<i8, i8> = (0..8).map(|x| (x, x * 10)).collect();
+    hash_map = hash_map.into_iter().filter(|(k, _)| k % 2 == 0).collect();
+}
diff --git a/tests/ui/manual_retain.stderr b/tests/ui/manual_retain.stderr
new file mode 100644
index 00000000000..ec635919b48
--- /dev/null
+++ b/tests/ui/manual_retain.stderr
@@ -0,0 +1,124 @@
+error: this expression can be written more simply using `.retain()`
+  --> $DIR/manual_retain.rs:52:5
+   |
+LL |     btree_map = btree_map.into_iter().filter(|(k, _)| k % 2 == 0).collect();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `btree_map.retain(|k, _| k % 2 == 0)`
+   |
+   = note: `-D clippy::manual-retain` implied by `-D warnings`
+
+error: this expression can be written more simply using `.retain()`
+  --> $DIR/manual_retain.rs:53:5
+   |
+LL |     btree_map = btree_map.into_iter().filter(|(_, v)| v % 2 == 0).collect();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `btree_map.retain(|_, &mut v| v % 2 == 0)`
+
+error: this expression can be written more simply using `.retain()`
+  --> $DIR/manual_retain.rs:54:5
+   |
+LL | /     btree_map = btree_map
+LL | |         .into_iter()
+LL | |         .filter(|(k, v)| (k % 2 == 0) && (v % 2 == 0))
+LL | |         .collect();
+   | |__________________^ help: consider calling `.retain()` instead: `btree_map.retain(|k, &mut v| (k % 2 == 0) && (v % 2 == 0))`
+
+error: this expression can be written more simply using `.retain()`
+  --> $DIR/manual_retain.rs:76:5
+   |
+LL |     btree_set = btree_set.iter().filter(|&x| x % 2 == 0).copied().collect();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `btree_set.retain(|x| x % 2 == 0)`
+
+error: this expression can be written more simply using `.retain()`
+  --> $DIR/manual_retain.rs:77:5
+   |
+LL |     btree_set = btree_set.iter().filter(|&x| x % 2 == 0).cloned().collect();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `btree_set.retain(|x| x % 2 == 0)`
+
+error: this expression can be written more simply using `.retain()`
+  --> $DIR/manual_retain.rs:78:5
+   |
+LL |     btree_set = btree_set.into_iter().filter(|x| x % 2 == 0).collect();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `btree_set.retain(|x| x % 2 == 0)`
+
+error: this expression can be written more simply using `.retain()`
+  --> $DIR/manual_retain.rs:108:5
+   |
+LL |     hash_map = hash_map.into_iter().filter(|(k, _)| k % 2 == 0).collect();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `hash_map.retain(|k, _| k % 2 == 0)`
+
+error: this expression can be written more simply using `.retain()`
+  --> $DIR/manual_retain.rs:109:5
+   |
+LL |     hash_map = hash_map.into_iter().filter(|(_, v)| v % 2 == 0).collect();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `hash_map.retain(|_, &mut v| v % 2 == 0)`
+
+error: this expression can be written more simply using `.retain()`
+  --> $DIR/manual_retain.rs:110:5
+   |
+LL | /     hash_map = hash_map
+LL | |         .into_iter()
+LL | |         .filter(|(k, v)| (k % 2 == 0) && (v % 2 == 0))
+LL | |         .collect();
+   | |__________________^ help: consider calling `.retain()` instead: `hash_map.retain(|k, &mut v| (k % 2 == 0) && (v % 2 == 0))`
+
+error: this expression can be written more simply using `.retain()`
+  --> $DIR/manual_retain.rs:131:5
+   |
+LL |     hash_set = hash_set.into_iter().filter(|x| x % 2 == 0).collect();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `hash_set.retain(|x| x % 2 == 0)`
+
+error: this expression can be written more simply using `.retain()`
+  --> $DIR/manual_retain.rs:132:5
+   |
+LL |     hash_set = hash_set.iter().filter(|&x| x % 2 == 0).copied().collect();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `hash_set.retain(|x| x % 2 == 0)`
+
+error: this expression can be written more simply using `.retain()`
+  --> $DIR/manual_retain.rs:133:5
+   |
+LL |     hash_set = hash_set.iter().filter(|&x| x % 2 == 0).cloned().collect();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `hash_set.retain(|x| x % 2 == 0)`
+
+error: this expression can be written more simply using `.retain()`
+  --> $DIR/manual_retain.rs:162:5
+   |
+LL |     s = s.chars().filter(|&c| c != 'o').to_owned().collect();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `s.retain(|c| c != 'o')`
+
+error: this expression can be written more simply using `.retain()`
+  --> $DIR/manual_retain.rs:174:5
+   |
+LL |     vec = vec.iter().filter(|&x| x % 2 == 0).copied().collect();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `vec.retain(|x| x % 2 == 0)`
+
+error: this expression can be written more simply using `.retain()`
+  --> $DIR/manual_retain.rs:175:5
+   |
+LL |     vec = vec.iter().filter(|&x| x % 2 == 0).cloned().collect();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `vec.retain(|x| x % 2 == 0)`
+
+error: this expression can be written more simply using `.retain()`
+  --> $DIR/manual_retain.rs:176:5
+   |
+LL |     vec = vec.into_iter().filter(|x| x % 2 == 0).collect();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `vec.retain(|x| x % 2 == 0)`
+
+error: this expression can be written more simply using `.retain()`
+  --> $DIR/manual_retain.rs:198:5
+   |
+LL |     vec_deque = vec_deque.iter().filter(|&x| x % 2 == 0).copied().collect();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `vec_deque.retain(|x| x % 2 == 0)`
+
+error: this expression can be written more simply using `.retain()`
+  --> $DIR/manual_retain.rs:199:5
+   |
+LL |     vec_deque = vec_deque.iter().filter(|&x| x % 2 == 0).cloned().collect();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `vec_deque.retain(|x| x % 2 == 0)`
+
+error: this expression can be written more simply using `.retain()`
+  --> $DIR/manual_retain.rs:200:5
+   |
+LL |     vec_deque = vec_deque.into_iter().filter(|x| x % 2 == 0).collect();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `vec_deque.retain(|x| x % 2 == 0)`
+
+error: aborting due to 19 previous errors
+
diff --git a/tests/ui/use_retain.fixed b/tests/ui/use_retain.fixed
deleted file mode 100644
index 549b8a62c0c..00000000000
--- a/tests/ui/use_retain.fixed
+++ /dev/null
@@ -1,240 +0,0 @@
-// run-rustfix
-#![feature(custom_inner_attributes)]
-#![warn(clippy::use_retain)]
-#![allow(unused)]
-use std::collections::BTreeMap;
-use std::collections::BTreeSet;
-use std::collections::BinaryHeap;
-use std::collections::HashMap;
-use std::collections::HashSet;
-use std::collections::VecDeque;
-
-fn main() {
-    binary_heap_retain();
-    btree_set_retain();
-    btree_map_retain();
-    hash_set_retain();
-    hash_map_retain();
-    string_retain();
-    vec_deque_retain();
-    vec_retain();
-    _msrv_153();
-    _msrv_126();
-    _msrv_118();
-}
-
-fn binary_heap_retain() {
-    // NOTE: Do not lint now, because binary_heap_retain is nighyly API.
-    // And we need to add a test case for msrv if we update this implmention.
-    // https://github.com/rust-lang/rust/issues/71503
-    let mut heap = BinaryHeap::from([1, 2, 3]);
-    heap = heap.into_iter().filter(|x| x % 2 == 0).collect();
-    heap = heap.iter().filter(|&x| x % 2 == 0).copied().collect();
-    heap = heap.iter().filter(|&x| x % 2 == 0).cloned().collect();
-
-    // Do not lint, because type conversion is performed
-    heap = heap.into_iter().filter(|x| x % 2 == 0).collect::<BinaryHeap<i8>>();
-    heap = heap.iter().filter(|&x| x % 2 == 0).copied().collect::<BinaryHeap<i8>>();
-    heap = heap.iter().filter(|&x| x % 2 == 0).cloned().collect::<BinaryHeap<i8>>();
-
-    // Do not lint, because this expression is not assign.
-    let mut bar: BinaryHeap<i8> = heap.iter().filter(|&x| x % 2 == 0).copied().collect();
-    let mut foobar: BinaryHeap<i8> = heap.into_iter().filter(|x| x % 2 == 0).collect();
-
-    // Do not lint, because it is an assignment to a different variable.
-    bar = foobar.iter().filter(|&x| x % 2 == 0).copied().collect();
-    bar = foobar.into_iter().filter(|x| x % 2 == 0).collect();
-}
-
-fn btree_map_retain() {
-    let mut btree_map: BTreeMap<i8, i8> = (0..8).map(|x| (x, x * 10)).collect();
-    // Do lint.
-    btree_map.retain(|k, _| k % 2 == 0);
-    btree_map.retain(|_, &mut v| v % 2 == 0);
-    btree_map.retain(|k, &mut v| (k % 2 == 0) && (v % 2 == 0));
-
-    // Do not lint.
-    btree_map = btree_map
-        .into_iter()
-        .filter(|(x, _)| x % 2 == 0)
-        .collect::<BTreeMap<i8, i8>>();
-
-    // Do not lint, because this expression is not assign.
-    let mut foobar: BTreeMap<i8, i8> = btree_map.into_iter().filter(|(k, _)| k % 2 == 0).collect();
-
-    // Do not lint, because it is an assignment to a different variable.
-    btree_map = foobar.into_iter().filter(|(k, _)| k % 2 == 0).collect();
-}
-
-fn btree_set_retain() {
-    let mut btree_set = BTreeSet::from([1, 2, 3, 4, 5, 6]);
-
-    // Do lint.
-    btree_set.retain(|x| x % 2 == 0);
-    btree_set.retain(|x| x % 2 == 0);
-    btree_set.retain(|x| x % 2 == 0);
-
-    // Do not lint, because type conversion is performed
-    btree_set = btree_set
-        .iter()
-        .filter(|&x| x % 2 == 0)
-        .copied()
-        .collect::<BTreeSet<i8>>();
-
-    btree_set = btree_set
-        .iter()
-        .filter(|&x| x % 2 == 0)
-        .cloned()
-        .collect::<BTreeSet<i8>>();
-
-    btree_set = btree_set.into_iter().filter(|x| x % 2 == 0).collect::<BTreeSet<i8>>();
-
-    // Do not lint, because this expression is not assign.
-    let mut foobar: BTreeSet<i8> = btree_set.iter().filter(|&x| x % 2 == 0).copied().collect();
-    let mut bar: BTreeSet<i8> = btree_set.into_iter().filter(|x| x % 2 == 0).collect();
-
-    // Do not lint, because it is an assignment to a different variable.
-    bar = foobar.iter().filter(|&x| x % 2 == 0).copied().collect();
-    bar = foobar.iter().filter(|&x| x % 2 == 0).cloned().collect();
-    bar = foobar.into_iter().filter(|x| x % 2 == 0).collect();
-}
-
-fn hash_map_retain() {
-    let mut hash_map: HashMap<i8, i8> = (0..8).map(|x| (x, x * 10)).collect();
-    // Do lint.
-    hash_map.retain(|k, _| k % 2 == 0);
-    hash_map.retain(|_, &mut v| v % 2 == 0);
-    hash_map.retain(|k, &mut v| (k % 2 == 0) && (v % 2 == 0));
-
-    // Do not lint.
-    hash_map = hash_map
-        .into_iter()
-        .filter(|(x, _)| x % 2 == 0)
-        .collect::<HashMap<i8, i8>>();
-
-    // Do not lint, because this expression is not assign.
-    let mut foobar: HashMap<i8, i8> = hash_map.into_iter().filter(|(k, _)| k % 2 == 0).collect();
-
-    // Do not lint, because it is an assignment to a different variable.
-    hash_map = foobar.into_iter().filter(|(k, _)| k % 2 == 0).collect();
-}
-
-fn hash_set_retain() {
-    let mut hash_set = HashSet::from([1, 2, 3, 4, 5, 6]);
-    // Do lint.
-    hash_set.retain(|x| x % 2 == 0);
-    hash_set.retain(|x| x % 2 == 0);
-    hash_set.retain(|x| x % 2 == 0);
-
-    // Do not lint, because type conversion is performed
-    hash_set = hash_set.into_iter().filter(|x| x % 2 == 0).collect::<HashSet<i8>>();
-    hash_set = hash_set
-        .iter()
-        .filter(|&x| x % 2 == 0)
-        .copied()
-        .collect::<HashSet<i8>>();
-
-    hash_set = hash_set
-        .iter()
-        .filter(|&x| x % 2 == 0)
-        .cloned()
-        .collect::<HashSet<i8>>();
-
-    // Do not lint, because this expression is not assign.
-    let mut bar: HashSet<i8> = hash_set.iter().filter(|&x| x % 2 == 0).copied().collect();
-    let mut foobar: HashSet<i8> = hash_set.into_iter().filter(|x| x % 2 == 0).collect();
-
-    // Do not lint, because it is an assignment to a different variable.
-    bar = foobar.iter().filter(|&x| x % 2 == 0).copied().collect();
-    bar = foobar.iter().filter(|&x| x % 2 == 0).cloned().collect();
-    bar = foobar.into_iter().filter(|&x| x % 2 == 0).collect();
-}
-
-fn string_retain() {
-    let mut s = String::from("foobar");
-    // Do lint.
-    s.retain(|c| c != 'o');
-
-    // Do not lint, because this expression is not assign.
-    let mut bar: String = s.chars().filter(|&c| c != 'o').to_owned().collect();
-
-    // Do not lint, because it is an assignment to a different variable.
-    s = bar.chars().filter(|&c| c != 'o').to_owned().collect();
-}
-
-fn vec_retain() {
-    let mut vec = vec![0, 1, 2];
-    // Do lint.
-    vec.retain(|x| x % 2 == 0);
-    vec.retain(|x| x % 2 == 0);
-    vec.retain(|x| x % 2 == 0);
-
-    // Do not lint, because type conversion is performed
-    vec = vec.into_iter().filter(|x| x % 2 == 0).collect::<Vec<i8>>();
-    vec = vec.iter().filter(|&x| x % 2 == 0).copied().collect::<Vec<i8>>();
-    vec = vec.iter().filter(|&x| x % 2 == 0).cloned().collect::<Vec<i8>>();
-
-    // Do not lint, because this expression is not assign.
-    let mut bar: Vec<i8> = vec.iter().filter(|&x| x % 2 == 0).copied().collect();
-    let mut foobar: Vec<i8> = vec.into_iter().filter(|x| x % 2 == 0).collect();
-
-    // Do not lint, because it is an assignment to a different variable.
-    bar = foobar.iter().filter(|&x| x % 2 == 0).copied().collect();
-    bar = foobar.iter().filter(|&x| x % 2 == 0).cloned().collect();
-    bar = foobar.into_iter().filter(|x| x % 2 == 0).collect();
-}
-
-fn vec_deque_retain() {
-    let mut vec_deque = VecDeque::new();
-    vec_deque.extend(1..5);
-
-    // Do lint.
-    vec_deque.retain(|x| x % 2 == 0);
-    vec_deque.retain(|x| x % 2 == 0);
-    vec_deque.retain(|x| x % 2 == 0);
-
-    // Do not lint, because type conversion is performed
-    vec_deque = vec_deque
-        .iter()
-        .filter(|&x| x % 2 == 0)
-        .copied()
-        .collect::<VecDeque<i8>>();
-    vec_deque = vec_deque
-        .iter()
-        .filter(|&x| x % 2 == 0)
-        .cloned()
-        .collect::<VecDeque<i8>>();
-    vec_deque = vec_deque.into_iter().filter(|x| x % 2 == 0).collect::<VecDeque<i8>>();
-
-    // Do not lint, because this expression is not assign.
-    let mut bar: VecDeque<i8> = vec_deque.iter().filter(|&x| x % 2 == 0).copied().collect();
-    let mut foobar: VecDeque<i8> = vec_deque.into_iter().filter(|x| x % 2 == 0).collect();
-
-    // Do not lint, because it is an assignment to a different variable.
-    bar = foobar.iter().filter(|&x| x % 2 == 0).copied().collect();
-    bar = foobar.iter().filter(|&x| x % 2 == 0).cloned().collect();
-    bar = foobar.into_iter().filter(|x| x % 2 == 0).collect();
-}
-
-fn _msrv_153() {
-    #![clippy::msrv = "1.52"]
-    let mut btree_map: BTreeMap<i8, i8> = (0..8).map(|x| (x, x * 10)).collect();
-    btree_map = btree_map.into_iter().filter(|(k, _)| k % 2 == 0).collect();
-
-    let mut btree_set = BTreeSet::from([1, 2, 3, 4, 5, 6]);
-    btree_set = btree_set.iter().filter(|&x| x % 2 == 0).copied().collect();
-}
-
-fn _msrv_126() {
-    #![clippy::msrv = "1.25"]
-    let mut s = String::from("foobar");
-    s = s.chars().filter(|&c| c != 'o').to_owned().collect();
-}
-
-fn _msrv_118() {
-    #![clippy::msrv = "1.17"]
-    let mut hash_set = HashSet::from([1, 2, 3, 4, 5, 6]);
-    hash_set = hash_set.into_iter().filter(|x| x % 2 == 0).collect();
-    let mut hash_map: HashMap<i8, i8> = (0..8).map(|x| (x, x * 10)).collect();
-    hash_map = hash_map.into_iter().filter(|(k, _)| k % 2 == 0).collect();
-}
diff --git a/tests/ui/use_retain.rs b/tests/ui/use_retain.rs
deleted file mode 100644
index 36c4176b8d5..00000000000
--- a/tests/ui/use_retain.rs
+++ /dev/null
@@ -1,246 +0,0 @@
-// run-rustfix
-#![feature(custom_inner_attributes)]
-#![warn(clippy::use_retain)]
-#![allow(unused)]
-use std::collections::BTreeMap;
-use std::collections::BTreeSet;
-use std::collections::BinaryHeap;
-use std::collections::HashMap;
-use std::collections::HashSet;
-use std::collections::VecDeque;
-
-fn main() {
-    binary_heap_retain();
-    btree_set_retain();
-    btree_map_retain();
-    hash_set_retain();
-    hash_map_retain();
-    string_retain();
-    vec_deque_retain();
-    vec_retain();
-    _msrv_153();
-    _msrv_126();
-    _msrv_118();
-}
-
-fn binary_heap_retain() {
-    // NOTE: Do not lint now, because binary_heap_retain is nighyly API.
-    // And we need to add a test case for msrv if we update this implmention.
-    // https://github.com/rust-lang/rust/issues/71503
-    let mut heap = BinaryHeap::from([1, 2, 3]);
-    heap = heap.into_iter().filter(|x| x % 2 == 0).collect();
-    heap = heap.iter().filter(|&x| x % 2 == 0).copied().collect();
-    heap = heap.iter().filter(|&x| x % 2 == 0).cloned().collect();
-
-    // Do not lint, because type conversion is performed
-    heap = heap.into_iter().filter(|x| x % 2 == 0).collect::<BinaryHeap<i8>>();
-    heap = heap.iter().filter(|&x| x % 2 == 0).copied().collect::<BinaryHeap<i8>>();
-    heap = heap.iter().filter(|&x| x % 2 == 0).cloned().collect::<BinaryHeap<i8>>();
-
-    // Do not lint, because this expression is not assign.
-    let mut bar: BinaryHeap<i8> = heap.iter().filter(|&x| x % 2 == 0).copied().collect();
-    let mut foobar: BinaryHeap<i8> = heap.into_iter().filter(|x| x % 2 == 0).collect();
-
-    // Do not lint, because it is an assignment to a different variable.
-    bar = foobar.iter().filter(|&x| x % 2 == 0).copied().collect();
-    bar = foobar.into_iter().filter(|x| x % 2 == 0).collect();
-}
-
-fn btree_map_retain() {
-    let mut btree_map: BTreeMap<i8, i8> = (0..8).map(|x| (x, x * 10)).collect();
-    // Do lint.
-    btree_map = btree_map.into_iter().filter(|(k, _)| k % 2 == 0).collect();
-    btree_map = btree_map.into_iter().filter(|(_, v)| v % 2 == 0).collect();
-    btree_map = btree_map
-        .into_iter()
-        .filter(|(k, v)| (k % 2 == 0) && (v % 2 == 0))
-        .collect();
-
-    // Do not lint.
-    btree_map = btree_map
-        .into_iter()
-        .filter(|(x, _)| x % 2 == 0)
-        .collect::<BTreeMap<i8, i8>>();
-
-    // Do not lint, because this expression is not assign.
-    let mut foobar: BTreeMap<i8, i8> = btree_map.into_iter().filter(|(k, _)| k % 2 == 0).collect();
-
-    // Do not lint, because it is an assignment to a different variable.
-    btree_map = foobar.into_iter().filter(|(k, _)| k % 2 == 0).collect();
-}
-
-fn btree_set_retain() {
-    let mut btree_set = BTreeSet::from([1, 2, 3, 4, 5, 6]);
-
-    // Do lint.
-    btree_set = btree_set.iter().filter(|&x| x % 2 == 0).copied().collect();
-    btree_set = btree_set.iter().filter(|&x| x % 2 == 0).cloned().collect();
-    btree_set = btree_set.into_iter().filter(|x| x % 2 == 0).collect();
-
-    // Do not lint, because type conversion is performed
-    btree_set = btree_set
-        .iter()
-        .filter(|&x| x % 2 == 0)
-        .copied()
-        .collect::<BTreeSet<i8>>();
-
-    btree_set = btree_set
-        .iter()
-        .filter(|&x| x % 2 == 0)
-        .cloned()
-        .collect::<BTreeSet<i8>>();
-
-    btree_set = btree_set.into_iter().filter(|x| x % 2 == 0).collect::<BTreeSet<i8>>();
-
-    // Do not lint, because this expression is not assign.
-    let mut foobar: BTreeSet<i8> = btree_set.iter().filter(|&x| x % 2 == 0).copied().collect();
-    let mut bar: BTreeSet<i8> = btree_set.into_iter().filter(|x| x % 2 == 0).collect();
-
-    // Do not lint, because it is an assignment to a different variable.
-    bar = foobar.iter().filter(|&x| x % 2 == 0).copied().collect();
-    bar = foobar.iter().filter(|&x| x % 2 == 0).cloned().collect();
-    bar = foobar.into_iter().filter(|x| x % 2 == 0).collect();
-}
-
-fn hash_map_retain() {
-    let mut hash_map: HashMap<i8, i8> = (0..8).map(|x| (x, x * 10)).collect();
-    // Do lint.
-    hash_map = hash_map.into_iter().filter(|(k, _)| k % 2 == 0).collect();
-    hash_map = hash_map.into_iter().filter(|(_, v)| v % 2 == 0).collect();
-    hash_map = hash_map
-        .into_iter()
-        .filter(|(k, v)| (k % 2 == 0) && (v % 2 == 0))
-        .collect();
-
-    // Do not lint.
-    hash_map = hash_map
-        .into_iter()
-        .filter(|(x, _)| x % 2 == 0)
-        .collect::<HashMap<i8, i8>>();
-
-    // Do not lint, because this expression is not assign.
-    let mut foobar: HashMap<i8, i8> = hash_map.into_iter().filter(|(k, _)| k % 2 == 0).collect();
-
-    // Do not lint, because it is an assignment to a different variable.
-    hash_map = foobar.into_iter().filter(|(k, _)| k % 2 == 0).collect();
-}
-
-fn hash_set_retain() {
-    let mut hash_set = HashSet::from([1, 2, 3, 4, 5, 6]);
-    // Do lint.
-    hash_set = hash_set.into_iter().filter(|x| x % 2 == 0).collect();
-    hash_set = hash_set.iter().filter(|&x| x % 2 == 0).copied().collect();
-    hash_set = hash_set.iter().filter(|&x| x % 2 == 0).cloned().collect();
-
-    // Do not lint, because type conversion is performed
-    hash_set = hash_set.into_iter().filter(|x| x % 2 == 0).collect::<HashSet<i8>>();
-    hash_set = hash_set
-        .iter()
-        .filter(|&x| x % 2 == 0)
-        .copied()
-        .collect::<HashSet<i8>>();
-
-    hash_set = hash_set
-        .iter()
-        .filter(|&x| x % 2 == 0)
-        .cloned()
-        .collect::<HashSet<i8>>();
-
-    // Do not lint, because this expression is not assign.
-    let mut bar: HashSet<i8> = hash_set.iter().filter(|&x| x % 2 == 0).copied().collect();
-    let mut foobar: HashSet<i8> = hash_set.into_iter().filter(|x| x % 2 == 0).collect();
-
-    // Do not lint, because it is an assignment to a different variable.
-    bar = foobar.iter().filter(|&x| x % 2 == 0).copied().collect();
-    bar = foobar.iter().filter(|&x| x % 2 == 0).cloned().collect();
-    bar = foobar.into_iter().filter(|&x| x % 2 == 0).collect();
-}
-
-fn string_retain() {
-    let mut s = String::from("foobar");
-    // Do lint.
-    s = s.chars().filter(|&c| c != 'o').to_owned().collect();
-
-    // Do not lint, because this expression is not assign.
-    let mut bar: String = s.chars().filter(|&c| c != 'o').to_owned().collect();
-
-    // Do not lint, because it is an assignment to a different variable.
-    s = bar.chars().filter(|&c| c != 'o').to_owned().collect();
-}
-
-fn vec_retain() {
-    let mut vec = vec![0, 1, 2];
-    // Do lint.
-    vec = vec.iter().filter(|&x| x % 2 == 0).copied().collect();
-    vec = vec.iter().filter(|&x| x % 2 == 0).cloned().collect();
-    vec = vec.into_iter().filter(|x| x % 2 == 0).collect();
-
-    // Do not lint, because type conversion is performed
-    vec = vec.into_iter().filter(|x| x % 2 == 0).collect::<Vec<i8>>();
-    vec = vec.iter().filter(|&x| x % 2 == 0).copied().collect::<Vec<i8>>();
-    vec = vec.iter().filter(|&x| x % 2 == 0).cloned().collect::<Vec<i8>>();
-
-    // Do not lint, because this expression is not assign.
-    let mut bar: Vec<i8> = vec.iter().filter(|&x| x % 2 == 0).copied().collect();
-    let mut foobar: Vec<i8> = vec.into_iter().filter(|x| x % 2 == 0).collect();
-
-    // Do not lint, because it is an assignment to a different variable.
-    bar = foobar.iter().filter(|&x| x % 2 == 0).copied().collect();
-    bar = foobar.iter().filter(|&x| x % 2 == 0).cloned().collect();
-    bar = foobar.into_iter().filter(|x| x % 2 == 0).collect();
-}
-
-fn vec_deque_retain() {
-    let mut vec_deque = VecDeque::new();
-    vec_deque.extend(1..5);
-
-    // Do lint.
-    vec_deque = vec_deque.iter().filter(|&x| x % 2 == 0).copied().collect();
-    vec_deque = vec_deque.iter().filter(|&x| x % 2 == 0).cloned().collect();
-    vec_deque = vec_deque.into_iter().filter(|x| x % 2 == 0).collect();
-
-    // Do not lint, because type conversion is performed
-    vec_deque = vec_deque
-        .iter()
-        .filter(|&x| x % 2 == 0)
-        .copied()
-        .collect::<VecDeque<i8>>();
-    vec_deque = vec_deque
-        .iter()
-        .filter(|&x| x % 2 == 0)
-        .cloned()
-        .collect::<VecDeque<i8>>();
-    vec_deque = vec_deque.into_iter().filter(|x| x % 2 == 0).collect::<VecDeque<i8>>();
-
-    // Do not lint, because this expression is not assign.
-    let mut bar: VecDeque<i8> = vec_deque.iter().filter(|&x| x % 2 == 0).copied().collect();
-    let mut foobar: VecDeque<i8> = vec_deque.into_iter().filter(|x| x % 2 == 0).collect();
-
-    // Do not lint, because it is an assignment to a different variable.
-    bar = foobar.iter().filter(|&x| x % 2 == 0).copied().collect();
-    bar = foobar.iter().filter(|&x| x % 2 == 0).cloned().collect();
-    bar = foobar.into_iter().filter(|x| x % 2 == 0).collect();
-}
-
-fn _msrv_153() {
-    #![clippy::msrv = "1.52"]
-    let mut btree_map: BTreeMap<i8, i8> = (0..8).map(|x| (x, x * 10)).collect();
-    btree_map = btree_map.into_iter().filter(|(k, _)| k % 2 == 0).collect();
-
-    let mut btree_set = BTreeSet::from([1, 2, 3, 4, 5, 6]);
-    btree_set = btree_set.iter().filter(|&x| x % 2 == 0).copied().collect();
-}
-
-fn _msrv_126() {
-    #![clippy::msrv = "1.25"]
-    let mut s = String::from("foobar");
-    s = s.chars().filter(|&c| c != 'o').to_owned().collect();
-}
-
-fn _msrv_118() {
-    #![clippy::msrv = "1.17"]
-    let mut hash_set = HashSet::from([1, 2, 3, 4, 5, 6]);
-    hash_set = hash_set.into_iter().filter(|x| x % 2 == 0).collect();
-    let mut hash_map: HashMap<i8, i8> = (0..8).map(|x| (x, x * 10)).collect();
-    hash_map = hash_map.into_iter().filter(|(k, _)| k % 2 == 0).collect();
-}
diff --git a/tests/ui/use_retain.stderr b/tests/ui/use_retain.stderr
deleted file mode 100644
index decd406f22a..00000000000
--- a/tests/ui/use_retain.stderr
+++ /dev/null
@@ -1,124 +0,0 @@
-error: this expression can be written more simply using `.retain()`
-  --> $DIR/use_retain.rs:52:5
-   |
-LL |     btree_map = btree_map.into_iter().filter(|(k, _)| k % 2 == 0).collect();
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `btree_map.retain(|k, _| k % 2 == 0)`
-   |
-   = note: `-D clippy::use-retain` implied by `-D warnings`
-
-error: this expression can be written more simply using `.retain()`
-  --> $DIR/use_retain.rs:53:5
-   |
-LL |     btree_map = btree_map.into_iter().filter(|(_, v)| v % 2 == 0).collect();
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `btree_map.retain(|_, &mut v| v % 2 == 0)`
-
-error: this expression can be written more simply using `.retain()`
-  --> $DIR/use_retain.rs:54:5
-   |
-LL | /     btree_map = btree_map
-LL | |         .into_iter()
-LL | |         .filter(|(k, v)| (k % 2 == 0) && (v % 2 == 0))
-LL | |         .collect();
-   | |__________________^ help: consider calling `.retain()` instead: `btree_map.retain(|k, &mut v| (k % 2 == 0) && (v % 2 == 0))`
-
-error: this expression can be written more simply using `.retain()`
-  --> $DIR/use_retain.rs:76:5
-   |
-LL |     btree_set = btree_set.iter().filter(|&x| x % 2 == 0).copied().collect();
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `btree_set.retain(|x| x % 2 == 0)`
-
-error: this expression can be written more simply using `.retain()`
-  --> $DIR/use_retain.rs:77:5
-   |
-LL |     btree_set = btree_set.iter().filter(|&x| x % 2 == 0).cloned().collect();
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `btree_set.retain(|x| x % 2 == 0)`
-
-error: this expression can be written more simply using `.retain()`
-  --> $DIR/use_retain.rs:78:5
-   |
-LL |     btree_set = btree_set.into_iter().filter(|x| x % 2 == 0).collect();
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `btree_set.retain(|x| x % 2 == 0)`
-
-error: this expression can be written more simply using `.retain()`
-  --> $DIR/use_retain.rs:108:5
-   |
-LL |     hash_map = hash_map.into_iter().filter(|(k, _)| k % 2 == 0).collect();
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `hash_map.retain(|k, _| k % 2 == 0)`
-
-error: this expression can be written more simply using `.retain()`
-  --> $DIR/use_retain.rs:109:5
-   |
-LL |     hash_map = hash_map.into_iter().filter(|(_, v)| v % 2 == 0).collect();
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `hash_map.retain(|_, &mut v| v % 2 == 0)`
-
-error: this expression can be written more simply using `.retain()`
-  --> $DIR/use_retain.rs:110:5
-   |
-LL | /     hash_map = hash_map
-LL | |         .into_iter()
-LL | |         .filter(|(k, v)| (k % 2 == 0) && (v % 2 == 0))
-LL | |         .collect();
-   | |__________________^ help: consider calling `.retain()` instead: `hash_map.retain(|k, &mut v| (k % 2 == 0) && (v % 2 == 0))`
-
-error: this expression can be written more simply using `.retain()`
-  --> $DIR/use_retain.rs:131:5
-   |
-LL |     hash_set = hash_set.into_iter().filter(|x| x % 2 == 0).collect();
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `hash_set.retain(|x| x % 2 == 0)`
-
-error: this expression can be written more simply using `.retain()`
-  --> $DIR/use_retain.rs:132:5
-   |
-LL |     hash_set = hash_set.iter().filter(|&x| x % 2 == 0).copied().collect();
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `hash_set.retain(|x| x % 2 == 0)`
-
-error: this expression can be written more simply using `.retain()`
-  --> $DIR/use_retain.rs:133:5
-   |
-LL |     hash_set = hash_set.iter().filter(|&x| x % 2 == 0).cloned().collect();
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `hash_set.retain(|x| x % 2 == 0)`
-
-error: this expression can be written more simply using `.retain()`
-  --> $DIR/use_retain.rs:162:5
-   |
-LL |     s = s.chars().filter(|&c| c != 'o').to_owned().collect();
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `s.retain(|c| c != 'o')`
-
-error: this expression can be written more simply using `.retain()`
-  --> $DIR/use_retain.rs:174:5
-   |
-LL |     vec = vec.iter().filter(|&x| x % 2 == 0).copied().collect();
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `vec.retain(|x| x % 2 == 0)`
-
-error: this expression can be written more simply using `.retain()`
-  --> $DIR/use_retain.rs:175:5
-   |
-LL |     vec = vec.iter().filter(|&x| x % 2 == 0).cloned().collect();
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `vec.retain(|x| x % 2 == 0)`
-
-error: this expression can be written more simply using `.retain()`
-  --> $DIR/use_retain.rs:176:5
-   |
-LL |     vec = vec.into_iter().filter(|x| x % 2 == 0).collect();
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `vec.retain(|x| x % 2 == 0)`
-
-error: this expression can be written more simply using `.retain()`
-  --> $DIR/use_retain.rs:198:5
-   |
-LL |     vec_deque = vec_deque.iter().filter(|&x| x % 2 == 0).copied().collect();
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `vec_deque.retain(|x| x % 2 == 0)`
-
-error: this expression can be written more simply using `.retain()`
-  --> $DIR/use_retain.rs:199:5
-   |
-LL |     vec_deque = vec_deque.iter().filter(|&x| x % 2 == 0).cloned().collect();
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `vec_deque.retain(|x| x % 2 == 0)`
-
-error: this expression can be written more simply using `.retain()`
-  --> $DIR/use_retain.rs:200:5
-   |
-LL |     vec_deque = vec_deque.into_iter().filter(|x| x % 2 == 0).collect();
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `vec_deque.retain(|x| x % 2 == 0)`
-
-error: aborting due to 19 previous errors
-
-- 
cgit 1.4.1-3-g733a5


From 3a9c0ef8a1ed339e6e8ee3ed5a7282c0bef11632 Mon Sep 17 00:00:00 2001
From: kyoto7250 <50972773+kyoto7250@users.noreply.github.com>
Date: Sat, 18 Jun 2022 18:56:46 +0900
Subject: fix for git rebase

---
 clippy_lints/src/manual_retain.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_retain.rs b/clippy_lints/src/manual_retain.rs
index 450c6d343c0..c35e1e021ef 100644
--- a/clippy_lints/src/manual_retain.rs
+++ b/clippy_lints/src/manual_retain.rs
@@ -148,8 +148,8 @@ fn check_to_owned(
 
 fn suggest(cx: &LateContext<'_>, parent_expr: &hir::Expr<'_>, left_expr: &hir::Expr<'_>, filter_expr: &hir::Expr<'_>) {
     if let hir::ExprKind::MethodCall(_, [_, closure], _) = filter_expr.kind
-        && let hir::ExprKind::Closure(_, _, filter_body_id, ..) = closure.kind
-        && let filter_body = cx.tcx.hir().body(filter_body_id)
+        && let hir::ExprKind::Closure{ body, ..} = closure.kind
+        && let filter_body = cx.tcx.hir().body(body)
         && let [filter_params] = filter_body.params
         && let Some(sugg) = match filter_params.pat.kind {
             hir::PatKind::Binding(_, _, filter_param_ident, None) => {
-- 
cgit 1.4.1-3-g733a5


From 65f700fa894ba833251bfe0217dc4634b75ea6bc Mon Sep 17 00:00:00 2001
From: Klim Tsoutsman <klimusha@gmail.com>
Date: Mon, 13 Jun 2022 13:08:50 +1000
Subject: Fix `let_undescore_lock` false-positive when binding without locking

Signed-off-by: Klim Tsoutsman <klimusha@gmail.com>
---
 clippy_lints/src/let_underscore.rs  | 7 ++++---
 clippy_utils/src/paths.rs           | 2 --
 tests/ui/let_underscore_lock.rs     | 9 +++++++++
 tests/ui/let_underscore_lock.stderr | 8 ++++----
 4 files changed, 17 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/let_underscore.rs b/clippy_lints/src/let_underscore.rs
index 26c540e2223..176787497eb 100644
--- a/clippy_lints/src/let_underscore.rs
+++ b/clippy_lints/src/let_underscore.rs
@@ -99,12 +99,13 @@ declare_clippy_lint! {
 
 declare_lint_pass!(LetUnderscore => [LET_UNDERSCORE_MUST_USE, LET_UNDERSCORE_LOCK, LET_UNDERSCORE_DROP]);
 
-const SYNC_GUARD_PATHS: [&[&str]; 5] = [
+const SYNC_GUARD_PATHS: [&[&str]; 6] = [
     &paths::MUTEX_GUARD,
     &paths::RWLOCK_READ_GUARD,
     &paths::RWLOCK_WRITE_GUARD,
-    &paths::PARKING_LOT_RAWMUTEX,
-    &paths::PARKING_LOT_RAWRWLOCK,
+    &paths::PARKING_LOT_MUTEX_GUARD,
+    &paths::PARKING_LOT_RWLOCK_READ_GUARD,
+    &paths::PARKING_LOT_RWLOCK_WRITE_GUARD,
 ];
 
 impl<'tcx> LateLintPass<'tcx> for LetUnderscore {
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index b31e2c1cdb1..ceef1d342e2 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -84,8 +84,6 @@ pub const OPTION_SOME: [&str; 4] = ["core", "option", "Option", "Some"];
 pub const ORD: [&str; 3] = ["core", "cmp", "Ord"];
 pub const OS_STRING_AS_OS_STR: [&str; 5] = ["std", "ffi", "os_str", "OsString", "as_os_str"];
 pub const OS_STR_TO_OS_STRING: [&str; 5] = ["std", "ffi", "os_str", "OsStr", "to_os_string"];
-pub const PARKING_LOT_RAWMUTEX: [&str; 3] = ["parking_lot", "raw_mutex", "RawMutex"];
-pub const PARKING_LOT_RAWRWLOCK: [&str; 3] = ["parking_lot", "raw_rwlock", "RawRwLock"];
 pub const PARKING_LOT_MUTEX_GUARD: [&str; 3] = ["lock_api", "mutex", "MutexGuard"];
 pub const PARKING_LOT_RWLOCK_READ_GUARD: [&str; 3] = ["lock_api", "rwlock", "RwLockReadGuard"];
 pub const PARKING_LOT_RWLOCK_WRITE_GUARD: [&str; 3] = ["lock_api", "rwlock", "RwLockWriteGuard"];
diff --git a/tests/ui/let_underscore_lock.rs b/tests/ui/let_underscore_lock.rs
index 539d74d1d4c..7a7c4e92499 100644
--- a/tests/ui/let_underscore_lock.rs
+++ b/tests/ui/let_underscore_lock.rs
@@ -13,6 +13,10 @@ fn main() {
     let _ = rw.try_read();
     let _ = rw.try_write();
 
+    // These shouldn't throw an error.
+    let _ = m;
+    let _ = rw;
+
     use parking_lot::{lock_api::RawMutex, Mutex, RwLock};
 
     let p_m: Mutex<()> = Mutex::const_new(RawMutex::INIT, ());
@@ -24,4 +28,9 @@ fn main() {
     let p_rw = RwLock::new(0);
     let _ = p_rw.read();
     let _ = p_rw.write();
+
+    // These shouldn't throw an error.
+    let _ = p_m;
+    let _ = p_m1;
+    let _ = p_rw;
 }
diff --git a/tests/ui/let_underscore_lock.stderr b/tests/ui/let_underscore_lock.stderr
index 3a2bc17bf7b..4365b48fabb 100644
--- a/tests/ui/let_underscore_lock.stderr
+++ b/tests/ui/let_underscore_lock.stderr
@@ -48,7 +48,7 @@ LL |     let _ = rw.try_write();
    = help: consider using an underscore-prefixed named binding or dropping explicitly with `std::mem::drop`
 
 error: non-binding let on a synchronization lock
-  --> $DIR/let_underscore_lock.rs:19:5
+  --> $DIR/let_underscore_lock.rs:23:5
    |
 LL |     let _ = p_m.lock();
    |     ^^^^^^^^^^^^^^^^^^^
@@ -56,7 +56,7 @@ LL |     let _ = p_m.lock();
    = help: consider using an underscore-prefixed named binding or dropping explicitly with `std::mem::drop`
 
 error: non-binding let on a synchronization lock
-  --> $DIR/let_underscore_lock.rs:22:5
+  --> $DIR/let_underscore_lock.rs:26:5
    |
 LL |     let _ = p_m1.lock();
    |     ^^^^^^^^^^^^^^^^^^^^
@@ -64,7 +64,7 @@ LL |     let _ = p_m1.lock();
    = help: consider using an underscore-prefixed named binding or dropping explicitly with `std::mem::drop`
 
 error: non-binding let on a synchronization lock
-  --> $DIR/let_underscore_lock.rs:25:5
+  --> $DIR/let_underscore_lock.rs:29:5
    |
 LL |     let _ = p_rw.read();
    |     ^^^^^^^^^^^^^^^^^^^^
@@ -72,7 +72,7 @@ LL |     let _ = p_rw.read();
    = help: consider using an underscore-prefixed named binding or dropping explicitly with `std::mem::drop`
 
 error: non-binding let on a synchronization lock
-  --> $DIR/let_underscore_lock.rs:26:5
+  --> $DIR/let_underscore_lock.rs:30:5
    |
 LL |     let _ = p_rw.write();
    |     ^^^^^^^^^^^^^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From c6a222139377b3a357df3b461fdbef0722df5555 Mon Sep 17 00:00:00 2001
From: alexey semenyuk <alexsemenyuk88@gmail.com>
Date: Sat, 25 Jun 2022 11:57:32 +0000
Subject: Fix example `SELF_ASSIGNMENT`

---
 clippy_lints/src/self_assignment.rs | 14 +++++++++++---
 1 file changed, 11 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/self_assignment.rs b/clippy_lints/src/self_assignment.rs
index b14f0518bdb..af7f5c9b681 100644
--- a/clippy_lints/src/self_assignment.rs
+++ b/clippy_lints/src/self_assignment.rs
@@ -20,14 +20,22 @@ declare_clippy_lint! {
     /// ### Example
     /// ```rust
     /// struct Event {
-    ///     id: usize,
     ///     x: i32,
-    ///     y: i32,
+    /// }
+    ///
+    /// fn copy_position(a: &mut Event, b: &Event) {
+    ///     a.x = a.x;
+    /// }
+    /// ```
+    ///
+    /// Should be:
+    /// ```rust
+    /// struct Event {
+    ///     x: i32,
     /// }
     ///
     /// fn copy_position(a: &mut Event, b: &Event) {
     ///     a.x = b.x;
-    ///     a.y = a.y;
     /// }
     /// ```
     #[clippy::version = "1.48.0"]
-- 
cgit 1.4.1-3-g733a5


From 2315f76f9d66b39db975bc722046cca55bc17079 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Tue, 5 Apr 2022 21:14:42 -0400
Subject: Actually check lifetimes in `trivially_copy_pass_by_ref`

---
 clippy_lints/src/lib.rs                    |  1 +
 clippy_lints/src/pass_by_ref_or_value.rs   | 91 +++++++++++++++++-------------
 clippy_utils/src/ty.rs                     | 32 ++++++++++-
 tests/ui/trivially_copy_pass_by_ref.rs     | 26 +++++++++
 tests/ui/trivially_copy_pass_by_ref.stderr |  8 ++-
 5 files changed, 117 insertions(+), 41 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index db52122aef6..832e9df9665 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -7,6 +7,7 @@
 #![feature(let_chains)]
 #![feature(let_else)]
 #![feature(lint_reasons)]
+#![feature(never_type)]
 #![feature(once_cell)]
 #![feature(rustc_private)]
 #![feature(stmt_expr_attributes)]
diff --git a/clippy_lints/src/pass_by_ref_or_value.rs b/clippy_lints/src/pass_by_ref_or_value.rs
index 05ab62786f4..6edf0e7a7b2 100644
--- a/clippy_lints/src/pass_by_ref_or_value.rs
+++ b/clippy_lints/src/pass_by_ref_or_value.rs
@@ -3,17 +3,19 @@ use std::iter;
 
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet;
-use clippy_utils::ty::is_copy;
+use clippy_utils::ty::{for_each_top_level_late_bound_region, is_copy};
 use clippy_utils::{is_self, is_self_ty};
+use core::ops::ControlFlow;
 use if_chain::if_chain;
 use rustc_ast::attr;
+use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::{BindingAnnotation, Body, FnDecl, HirId, Impl, ItemKind, MutTy, Mutability, Node, PatKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty;
 use rustc_middle::ty::layout::LayoutOf;
+use rustc_middle::ty::{self, RegionKind};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::def_id::LocalDefId;
 use rustc_span::{sym, Span};
@@ -141,50 +143,62 @@ impl<'tcx> PassByRefOrValue {
         }
 
         let fn_sig = cx.tcx.fn_sig(def_id);
-        let fn_sig = cx.tcx.erase_late_bound_regions(fn_sig);
-
         let fn_body = cx.enclosing_body.map(|id| cx.tcx.hir().body(id));
 
-        for (index, (input, &ty)) in iter::zip(decl.inputs, fn_sig.inputs()).enumerate() {
+        // Gather all the lifetimes found in the output type which may affect whether
+        // `TRIVIALLY_COPY_PASS_BY_REF` should be linted.
+        let mut output_regions = FxHashSet::default();
+        for_each_top_level_late_bound_region(fn_sig.skip_binder().output(), |region| -> ControlFlow<!> {
+            output_regions.insert(region);
+            ControlFlow::Continue(())
+        });
+
+        for (index, (input, ty)) in iter::zip(
+            decl.inputs,
+            fn_sig.skip_binder().inputs().iter().map(|&ty| fn_sig.rebind(ty)),
+        )
+        .enumerate()
+        {
             // All spans generated from a proc-macro invocation are the same...
             match span {
-                Some(s) if s == input.span => return,
+                Some(s) if s == input.span => continue,
                 _ => (),
             }
 
-            match ty.kind() {
-                ty::Ref(input_lt, ty, Mutability::Not) => {
-                    // Use lifetimes to determine if we're returning a reference to the
-                    // argument. In that case we can't switch to pass-by-value as the
-                    // argument will not live long enough.
-                    let output_lts = match *fn_sig.output().kind() {
-                        ty::Ref(output_lt, _, _) => vec![output_lt],
-                        ty::Adt(_, substs) => substs.regions().collect(),
-                        _ => vec![],
-                    };
+            match *ty.skip_binder().kind() {
+                ty::Ref(lt, ty, Mutability::Not) => {
+                    match lt.kind() {
+                        RegionKind::ReLateBound(index, region)
+                            if index.as_u32() == 0 && output_regions.contains(&region) =>
+                        {
+                            continue;
+                        },
+                        // Early bound regions on functions are either from the containing item, are bounded by another
+                        // lifetime, or are used as a bound for a type or lifetime.
+                        RegionKind::ReEarlyBound(..) => continue,
+                        _ => (),
+                    }
 
-                    if_chain! {
-                        if !output_lts.contains(input_lt);
-                        if is_copy(cx, *ty);
-                        if let Some(size) = cx.layout_of(*ty).ok().map(|l| l.size.bytes());
-                        if size <= self.ref_min_size;
-                        if let hir::TyKind::Rptr(_, MutTy { ty: decl_ty, .. }) = input.kind;
-                        then {
-                            let value_type = if fn_body.and_then(|body| body.params.get(index)).map_or(false, is_self) {
-                                "self".into()
-                            } else {
-                                snippet(cx, decl_ty.span, "_").into()
-                            };
-                            span_lint_and_sugg(
-                                cx,
-                                TRIVIALLY_COPY_PASS_BY_REF,
-                                input.span,
-                                &format!("this argument ({} byte) is passed by reference, but would be more efficient if passed by value (limit: {} byte)", size, self.ref_min_size),
-                                "consider passing by value instead",
-                                value_type,
-                                Applicability::Unspecified,
-                            );
-                        }
+                    let ty = cx.tcx.erase_late_bound_regions(fn_sig.rebind(ty));
+                    if is_copy(cx, ty)
+                        && let Some(size) = cx.layout_of(ty).ok().map(|l| l.size.bytes())
+                        && size <= self.ref_min_size
+                        && let hir::TyKind::Rptr(_, MutTy { ty: decl_ty, .. }) = input.kind
+                    {
+                        let value_type = if fn_body.and_then(|body| body.params.get(index)).map_or(false, is_self) {
+                            "self".into()
+                        } else {
+                            snippet(cx, decl_ty.span, "_").into()
+                        };
+                        span_lint_and_sugg(
+                            cx,
+                            TRIVIALLY_COPY_PASS_BY_REF,
+                            input.span,
+                            &format!("this argument ({} byte) is passed by reference, but would be more efficient if passed by value (limit: {} byte)", size, self.ref_min_size),
+                            "consider passing by value instead",
+                            value_type,
+                            Applicability::Unspecified,
+                        );
                     }
                 },
 
@@ -196,6 +210,7 @@ impl<'tcx> PassByRefOrValue {
                             _ => continue,
                         }
                     }
+                    let ty = cx.tcx.erase_late_bound_regions(ty);
 
                     if_chain! {
                         if is_copy(cx, ty);
diff --git a/clippy_utils/src/ty.rs b/clippy_utils/src/ty.rs
index 227e97d37ec..4c079151f24 100644
--- a/clippy_utils/src/ty.rs
+++ b/clippy_utils/src/ty.rs
@@ -2,6 +2,7 @@
 
 #![allow(clippy::module_name_repetitions)]
 
+use core::ops::ControlFlow;
 use rustc_ast::ast::Mutability;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_hir as hir;
@@ -13,8 +14,8 @@ use rustc_lint::LateContext;
 use rustc_middle::mir::interpret::{ConstValue, Scalar};
 use rustc_middle::ty::subst::{GenericArg, GenericArgKind, Subst};
 use rustc_middle::ty::{
-    self, AdtDef, Binder, FnSig, IntTy, ParamEnv, Predicate, PredicateKind, Ty, TyCtxt, TypeFoldable, UintTy,
-    VariantDiscr,
+    self, AdtDef, Binder, BoundRegion, FnSig, IntTy, ParamEnv, Predicate, PredicateKind, Region, RegionKind, Ty,
+    TyCtxt, TypeFoldable, TypeSuperFoldable, TypeVisitor, UintTy, VariantDiscr,
 };
 use rustc_span::symbol::Ident;
 use rustc_span::{sym, Span, Symbol, DUMMY_SP};
@@ -667,3 +668,30 @@ pub fn is_c_void(cx: &LateContext<'_>, ty: Ty<'_>) -> bool {
         false
     }
 }
+
+pub fn for_each_top_level_late_bound_region<B>(
+    ty: Ty<'_>,
+    f: impl FnMut(BoundRegion) -> ControlFlow<B>,
+) -> ControlFlow<B> {
+    struct V<F> {
+        index: u32,
+        f: F,
+    }
+    impl<'tcx, B, F: FnMut(BoundRegion) -> ControlFlow<B>> TypeVisitor<'tcx> for V<F> {
+        type BreakTy = B;
+        fn visit_region(&mut self, r: Region<'tcx>) -> ControlFlow<Self::BreakTy> {
+            if let RegionKind::ReLateBound(idx, bound) = r.kind() && idx.as_u32() == self.index {
+                (self.f)(bound)
+            } else {
+                ControlFlow::Continue(())
+            }
+        }
+        fn visit_binder<T: TypeFoldable<'tcx>>(&mut self, t: &Binder<'tcx, T>) -> ControlFlow<Self::BreakTy> {
+            self.index += 1;
+            let res = t.super_visit_with(self);
+            self.index -= 1;
+            res
+        }
+    }
+    ty.visit_with(&mut V { index: 0, f })
+}
diff --git a/tests/ui/trivially_copy_pass_by_ref.rs b/tests/ui/trivially_copy_pass_by_ref.rs
index ea3dce17081..24117e37ed1 100644
--- a/tests/ui/trivially_copy_pass_by_ref.rs
+++ b/tests/ui/trivially_copy_pass_by_ref.rs
@@ -113,6 +113,32 @@ mod issue5876 {
     }
 }
 
+fn _ref_to_opt_ref_implicit(x: &u32) -> Option<&u32> {
+    Some(x)
+}
+
+#[allow(clippy::needless_lifetimes)]
+fn _ref_to_opt_ref_explicit<'a>(x: &'a u32) -> Option<&'a u32> {
+    Some(x)
+}
+
+fn _with_constraint<'a, 'b: 'a>(x: &'b u32, y: &'a u32) -> &'a u32 {
+    if true { x } else { y }
+}
+
+async fn _async_implicit(x: &u32) -> &u32 {
+    x
+}
+
+#[allow(clippy::needless_lifetimes)]
+async fn _async_explicit<'a>(x: &'a u32) -> &'a u32 {
+    x
+}
+
+fn _unrelated_lifetimes<'a, 'b>(_x: &'a u32, y: &'b u32) -> &'b u32 {
+    y
+}
+
 fn main() {
     let (mut foo, bar) = (Foo(0), Bar([0; 24]));
     let (mut a, b, c, x, y, z) = (0, 0, Bar([0; 24]), 0, Foo(0), 0);
diff --git a/tests/ui/trivially_copy_pass_by_ref.stderr b/tests/ui/trivially_copy_pass_by_ref.stderr
index a88d35f3ea5..66ecb3d8e77 100644
--- a/tests/ui/trivially_copy_pass_by_ref.stderr
+++ b/tests/ui/trivially_copy_pass_by_ref.stderr
@@ -106,5 +106,11 @@ error: this argument (N byte) is passed by reference, but would be more efficien
 LL |     fn foo(x: &i32) {
    |               ^^^^ help: consider passing by value instead: `i32`
 
-error: aborting due to 17 previous errors
+error: this argument (N byte) is passed by reference, but would be more efficient if passed by value (limit: N byte)
+  --> $DIR/trivially_copy_pass_by_ref.rs:138:37
+   |
+LL | fn _unrelated_lifetimes<'a, 'b>(_x: &'a u32, y: &'b u32) -> &'b u32 {
+   |                                     ^^^^^^^ help: consider passing by value instead: `u32`
+
+error: aborting due to 18 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From c10101cf1c62e504da6378ebf969cec2b74dccfb Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Tue, 5 Apr 2022 22:48:47 -0400
Subject: Don't lint `trivially_copy_pass_by_ref` when unsafe pointers are used

---
 clippy_lints/src/pass_by_ref_or_value.rs | 15 +++++++++++++++
 tests/ui/trivially_copy_pass_by_ref.rs   | 12 ++++++++++++
 2 files changed, 27 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/pass_by_ref_or_value.rs b/clippy_lints/src/pass_by_ref_or_value.rs
index 6edf0e7a7b2..5fa4fd74853 100644
--- a/clippy_lints/src/pass_by_ref_or_value.rs
+++ b/clippy_lints/src/pass_by_ref_or_value.rs
@@ -14,6 +14,7 @@ use rustc_hir as hir;
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::{BindingAnnotation, Body, FnDecl, HirId, Impl, ItemKind, MutTy, Mutability, Node, PatKind};
 use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::adjustment::{Adjust, PointerCast};
 use rustc_middle::ty::layout::LayoutOf;
 use rustc_middle::ty::{self, RegionKind};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
@@ -185,6 +186,20 @@ impl<'tcx> PassByRefOrValue {
                         && size <= self.ref_min_size
                         && let hir::TyKind::Rptr(_, MutTy { ty: decl_ty, .. }) = input.kind
                     {
+                        if let Some(typeck) = cx.maybe_typeck_results() {
+                            // Don't lint if an unsafe pointer is created.
+                            // TODO: Limit the check only to unsafe pointers to the argument (or part of the argument)
+                            //       which escape the current function.
+                            if typeck.node_types().iter().any(|(_, &ty)| ty.is_unsafe_ptr())
+                                || typeck
+                                    .adjustments()
+                                    .iter()
+                                    .flat_map(|(_, a)| a)
+                                    .any(|a| matches!(a.kind, Adjust::Pointer(PointerCast::UnsafeFnPointer)))
+                            {
+                                continue;
+                            }
+                        }
                         let value_type = if fn_body.and_then(|body| body.params.get(index)).map_or(false, is_self) {
                             "self".into()
                         } else {
diff --git a/tests/ui/trivially_copy_pass_by_ref.rs b/tests/ui/trivially_copy_pass_by_ref.rs
index 24117e37ed1..8f78f16a0a1 100644
--- a/tests/ui/trivially_copy_pass_by_ref.rs
+++ b/tests/ui/trivially_copy_pass_by_ref.rs
@@ -139,6 +139,18 @@ fn _unrelated_lifetimes<'a, 'b>(_x: &'a u32, y: &'b u32) -> &'b u32 {
     y
 }
 
+fn _return_ptr(x: &u32) -> *const u32 {
+    x
+}
+
+fn _return_field_ptr(x: &(u32, u32)) -> *const u32 {
+    &x.0
+}
+
+fn _return_field_ptr_addr_of(x: &(u32, u32)) -> *const u32 {
+    core::ptr::addr_of!(x.0)
+}
+
 fn main() {
     let (mut foo, bar) = (Foo(0), Bar([0; 24]));
     let (mut a, b, c, x, y, z) = (0, 0, Bar([0; 24]), 0, Foo(0), 0);
-- 
cgit 1.4.1-3-g733a5


From 3cfd1e52335517160923ae6ba9adcc14c2e7f9f9 Mon Sep 17 00:00:00 2001
From: Preston From <prestonfrom@gmail.com>
Date: Mon, 27 Jun 2022 22:52:22 -0600
Subject: Make messages more accurate, check lint enabled

---
 .../src/matches/significant_drop_in_scrutinee.rs   |  24 ++--
 tests/ui/significant_drop_in_scrutinee.rs          |  13 ++
 tests/ui/significant_drop_in_scrutinee.stderr      | 158 ++++++++++-----------
 3 files changed, 104 insertions(+), 91 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/significant_drop_in_scrutinee.rs b/clippy_lints/src/matches/significant_drop_in_scrutinee.rs
index 98884ac7d73..7efa81226e0 100644
--- a/clippy_lints/src/matches/significant_drop_in_scrutinee.rs
+++ b/clippy_lints/src/matches/significant_drop_in_scrutinee.rs
@@ -1,6 +1,6 @@
 use crate::FxHashSet;
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::get_attr;
+use clippy_utils::{get_attr, is_lint_allowed};
 use clippy_utils::source::{indent_of, snippet};
 use rustc_errors::{Applicability, Diagnostic};
 use rustc_hir::intravisit::{walk_expr, Visitor};
@@ -19,16 +19,18 @@ pub(super) fn check<'tcx>(
     arms: &'tcx [Arm<'_>],
     source: MatchSource,
 ) {
+    if is_lint_allowed(cx, SIGNIFICANT_DROP_IN_SCRUTINEE, expr.hir_id) {
+        return;
+    }
+
     if let Some((suggestions, message)) = has_significant_drop_in_scrutinee(cx, scrutinee, source) {
         for found in suggestions {
             span_lint_and_then(cx, SIGNIFICANT_DROP_IN_SCRUTINEE, found.found_span, message, |diag| {
                 set_diagnostic(diag, cx, expr, found);
                 let s = Span::new(expr.span.hi(), expr.span.hi(), expr.span.ctxt(), None);
-                diag.span_label(s, "original temporary lives until here");
-                if let Some(spans) = has_significant_drop_in_arms(cx, arms) {
-                    for span in spans {
-                        diag.span_label(span, "another temporary with significant `Drop` created here");
-                    }
+                diag.span_label(s, "temporary lives until here");
+                for span in has_significant_drop_in_arms(cx, arms) {
+                    diag.span_label(span, "another value with significant `Drop` created here");
                 }
                 diag.note("this might lead to deadlocks or other unexpected behavior");
             });
@@ -360,19 +362,19 @@ impl<'a, 'tcx> Visitor<'tcx> for SigDropHelper<'a, 'tcx> {
 
 struct ArmSigDropHelper<'a, 'tcx> {
     sig_drop_checker: SigDropChecker<'a, 'tcx>,
-    found_sig_drop_spans: Option<FxHashSet<Span>>,
+    found_sig_drop_spans: FxHashSet<Span>,
 }
 
 impl<'a, 'tcx> ArmSigDropHelper<'a, 'tcx> {
     fn new(cx: &'a LateContext<'tcx>) -> ArmSigDropHelper<'a, 'tcx> {
         ArmSigDropHelper {
             sig_drop_checker: SigDropChecker::new(cx),
-            found_sig_drop_spans: None,
+            found_sig_drop_spans: FxHashSet::<Span>::default(),
         }
     }
 }
 
-fn has_significant_drop_in_arms<'tcx, 'a>(cx: &'a LateContext<'tcx>, arms: &'tcx [Arm<'_>]) -> Option<FxHashSet<Span>> {
+fn has_significant_drop_in_arms<'tcx, 'a>(cx: &'a LateContext<'tcx>, arms: &'tcx [Arm<'_>]) -> FxHashSet<Span> {
     let mut helper = ArmSigDropHelper::new(cx);
     for arm in arms {
         helper.visit_expr(arm.body);
@@ -386,9 +388,7 @@ impl<'a, 'tcx> Visitor<'tcx> for ArmSigDropHelper<'a, 'tcx> {
             .sig_drop_checker
             .has_sig_drop_attr(self.sig_drop_checker.cx, self.sig_drop_checker.get_type(ex))
         {
-            self.found_sig_drop_spans
-                .get_or_insert_with(FxHashSet::default)
-                .insert(ex.span);
+            self.found_sig_drop_spans.insert(ex.span);
             return;
         }
         walk_expr(self, ex);
diff --git a/tests/ui/significant_drop_in_scrutinee.rs b/tests/ui/significant_drop_in_scrutinee.rs
index dd64f240c4a..185e5009b60 100644
--- a/tests/ui/significant_drop_in_scrutinee.rs
+++ b/tests/ui/significant_drop_in_scrutinee.rs
@@ -64,6 +64,19 @@ fn should_trigger_lint_with_mutex_guard_in_match_scrutinee() {
     };
 }
 
+fn should_not_trigger_lint_with_mutex_guard_in_match_scrutinee_when_lint_allowed() {
+    let mutex = Mutex::new(State {});
+
+    // Lint should not be triggered because it is "allowed" below.
+    #[allow(clippy::significant_drop_in_scrutinee)]
+    match mutex.lock().unwrap().foo() {
+        true => {
+            mutex.lock().unwrap().bar();
+        },
+        false => {},
+    };
+}
+
 fn should_not_trigger_lint_for_insignificant_drop() {
     // Should not trigger lint because there are no temporaries whose drops have a significant
     // side effect.
diff --git a/tests/ui/significant_drop_in_scrutinee.stderr b/tests/ui/significant_drop_in_scrutinee.stderr
index f97b606c474..dbb41837e79 100644
--- a/tests/ui/significant_drop_in_scrutinee.stderr
+++ b/tests/ui/significant_drop_in_scrutinee.stderr
@@ -5,10 +5,10 @@ LL |     match mutex.lock().unwrap().foo() {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 LL |         true => {
 LL |             mutex.lock().unwrap().bar();
-   |             --------------------- another temporary with significant `Drop` created here
+   |             --------------------- another value with significant `Drop` created here
 ...
 LL |     };
-   |      - original temporary lives until here
+   |      - temporary lives until here
    |
    = note: `-D clippy::significant-drop-in-scrutinee` implied by `-D warnings`
    = note: this might lead to deadlocks or other unexpected behavior
@@ -19,16 +19,16 @@ LL ~     match value {
    |
 
 error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
-  --> $DIR/significant_drop_in_scrutinee.rs:132:11
+  --> $DIR/significant_drop_in_scrutinee.rs:145:11
    |
 LL |     match s.lock_m().get_the_value() {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^
 ...
 LL |             println!("{}", s.lock_m().get_the_value());
-   |                            ---------- another temporary with significant `Drop` created here
+   |                            ---------- another value with significant `Drop` created here
 ...
 LL |     }
-   |      - original temporary lives until here
+   |      - temporary lives until here
    |
    = note: this might lead to deadlocks or other unexpected behavior
 help: try moving the temporary above the match
@@ -38,16 +38,16 @@ LL ~     match value {
    |
 
 error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
-  --> $DIR/significant_drop_in_scrutinee.rs:153:11
+  --> $DIR/significant_drop_in_scrutinee.rs:166:11
    |
 LL |     match s.lock_m_m().get_the_value() {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 ...
 LL |             println!("{}", s.lock_m().get_the_value());
-   |                            ---------- another temporary with significant `Drop` created here
+   |                            ---------- another value with significant `Drop` created here
 ...
 LL |     }
-   |      - original temporary lives until here
+   |      - temporary lives until here
    |
    = note: this might lead to deadlocks or other unexpected behavior
 help: try moving the temporary above the match
@@ -57,13 +57,13 @@ LL ~     match value {
    |
 
 error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
-  --> $DIR/significant_drop_in_scrutinee.rs:201:11
+  --> $DIR/significant_drop_in_scrutinee.rs:214:11
    |
 LL |     match counter.temp_increment().len() {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 ...
 LL |     };
-   |      - original temporary lives until here
+   |      - temporary lives until here
    |
    = note: this might lead to deadlocks or other unexpected behavior
 help: try moving the temporary above the match
@@ -73,16 +73,16 @@ LL ~     match value {
    |
 
 error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
-  --> $DIR/significant_drop_in_scrutinee.rs:224:16
+  --> $DIR/significant_drop_in_scrutinee.rs:237:16
    |
 LL |         match (mutex1.lock().unwrap().s.len(), true) {
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 ...
 LL |                 mutex1.lock().unwrap().s.len();
-   |                 ---------------------- another temporary with significant `Drop` created here
+   |                 ---------------------- another value with significant `Drop` created here
 ...
 LL |         };
-   |          - original temporary lives until here
+   |          - temporary lives until here
    |
    = note: this might lead to deadlocks or other unexpected behavior
 help: try moving the temporary above the match
@@ -92,16 +92,16 @@ LL ~         match (value, true) {
    |
 
 error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
-  --> $DIR/significant_drop_in_scrutinee.rs:233:22
+  --> $DIR/significant_drop_in_scrutinee.rs:246:22
    |
 LL |         match (true, mutex1.lock().unwrap().s.len(), true) {
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 ...
 LL |                 mutex1.lock().unwrap().s.len();
-   |                 ---------------------- another temporary with significant `Drop` created here
+   |                 ---------------------- another value with significant `Drop` created here
 ...
 LL |         };
-   |          - original temporary lives until here
+   |          - temporary lives until here
    |
    = note: this might lead to deadlocks or other unexpected behavior
 help: try moving the temporary above the match
@@ -111,18 +111,18 @@ LL ~         match (true, value, true) {
    |
 
 error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
-  --> $DIR/significant_drop_in_scrutinee.rs:243:16
+  --> $DIR/significant_drop_in_scrutinee.rs:256:16
    |
 LL |         match (mutex1.lock().unwrap().s.len(), true, mutex2.lock().unwrap().s.len()) {
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 ...
 LL |                 mutex1.lock().unwrap().s.len();
-   |                 ---------------------- another temporary with significant `Drop` created here
+   |                 ---------------------- another value with significant `Drop` created here
 LL |                 mutex2.lock().unwrap().s.len();
-   |                 ---------------------- another temporary with significant `Drop` created here
+   |                 ---------------------- another value with significant `Drop` created here
 ...
 LL |         };
-   |          - original temporary lives until here
+   |          - temporary lives until here
    |
    = note: this might lead to deadlocks or other unexpected behavior
 help: try moving the temporary above the match
@@ -132,18 +132,18 @@ LL ~         match (value, true, mutex2.lock().unwrap().s.len()) {
    |
 
 error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
-  --> $DIR/significant_drop_in_scrutinee.rs:243:54
+  --> $DIR/significant_drop_in_scrutinee.rs:256:54
    |
 LL |         match (mutex1.lock().unwrap().s.len(), true, mutex2.lock().unwrap().s.len()) {
    |                                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 ...
 LL |                 mutex1.lock().unwrap().s.len();
-   |                 ---------------------- another temporary with significant `Drop` created here
+   |                 ---------------------- another value with significant `Drop` created here
 LL |                 mutex2.lock().unwrap().s.len();
-   |                 ---------------------- another temporary with significant `Drop` created here
+   |                 ---------------------- another value with significant `Drop` created here
 ...
 LL |         };
-   |          - original temporary lives until here
+   |          - temporary lives until here
    |
    = note: this might lead to deadlocks or other unexpected behavior
 help: try moving the temporary above the match
@@ -153,48 +153,48 @@ LL ~         match (mutex1.lock().unwrap().s.len(), true, value) {
    |
 
 error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
-  --> $DIR/significant_drop_in_scrutinee.rs:254:15
+  --> $DIR/significant_drop_in_scrutinee.rs:267:15
    |
 LL |         match mutex3.lock().unwrap().s.as_str() {
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 ...
 LL |                 mutex1.lock().unwrap().s.len();
-   |                 ---------------------- another temporary with significant `Drop` created here
+   |                 ---------------------- another value with significant `Drop` created here
 LL |                 mutex2.lock().unwrap().s.len();
-   |                 ---------------------- another temporary with significant `Drop` created here
+   |                 ---------------------- another value with significant `Drop` created here
 ...
 LL |         };
-   |          - original temporary lives until here
+   |          - temporary lives until here
    |
    = note: this might lead to deadlocks or other unexpected behavior
 
 error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
-  --> $DIR/significant_drop_in_scrutinee.rs:264:22
+  --> $DIR/significant_drop_in_scrutinee.rs:277:22
    |
 LL |         match (true, mutex3.lock().unwrap().s.as_str()) {
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 ...
 LL |                 mutex1.lock().unwrap().s.len();
-   |                 ---------------------- another temporary with significant `Drop` created here
+   |                 ---------------------- another value with significant `Drop` created here
 LL |                 mutex2.lock().unwrap().s.len();
-   |                 ---------------------- another temporary with significant `Drop` created here
+   |                 ---------------------- another value with significant `Drop` created here
 ...
 LL |         };
-   |          - original temporary lives until here
+   |          - temporary lives until here
    |
    = note: this might lead to deadlocks or other unexpected behavior
 
 error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
-  --> $DIR/significant_drop_in_scrutinee.rs:283:11
+  --> $DIR/significant_drop_in_scrutinee.rs:296:11
    |
 LL |     match mutex.lock().unwrap().s.len() > 1 {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 LL |         true => {
 LL |             mutex.lock().unwrap().s.len();
-   |             --------------------- another temporary with significant `Drop` created here
+   |             --------------------- another value with significant `Drop` created here
 ...
 LL |     };
-   |      - original temporary lives until here
+   |      - temporary lives until here
    |
    = note: this might lead to deadlocks or other unexpected behavior
 help: try moving the temporary above the match
@@ -204,16 +204,16 @@ LL ~     match value {
    |
 
 error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
-  --> $DIR/significant_drop_in_scrutinee.rs:290:11
+  --> $DIR/significant_drop_in_scrutinee.rs:303:11
    |
 LL |     match 1 < mutex.lock().unwrap().s.len() {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 LL |         true => {
 LL |             mutex.lock().unwrap().s.len();
-   |             --------------------- another temporary with significant `Drop` created here
+   |             --------------------- another value with significant `Drop` created here
 ...
 LL |     };
-   |      - original temporary lives until here
+   |      - temporary lives until here
    |
    = note: this might lead to deadlocks or other unexpected behavior
 help: try moving the temporary above the match
@@ -223,18 +223,18 @@ LL ~     match value {
    |
 
 error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
-  --> $DIR/significant_drop_in_scrutinee.rs:308:11
+  --> $DIR/significant_drop_in_scrutinee.rs:321:11
    |
 LL |     match mutex1.lock().unwrap().s.len() < mutex2.lock().unwrap().s.len() {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 ...
 LL |                 mutex1.lock().unwrap().s.len(),
-   |                 ---------------------- another temporary with significant `Drop` created here
+   |                 ---------------------- another value with significant `Drop` created here
 LL |                 mutex2.lock().unwrap().s.len()
-   |                 ---------------------- another temporary with significant `Drop` created here
+   |                 ---------------------- another value with significant `Drop` created here
 ...
 LL |     };
-   |      - original temporary lives until here
+   |      - temporary lives until here
    |
    = note: this might lead to deadlocks or other unexpected behavior
 help: try moving the temporary above the match
@@ -244,18 +244,18 @@ LL ~     match value {
    |
 
 error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
-  --> $DIR/significant_drop_in_scrutinee.rs:319:11
+  --> $DIR/significant_drop_in_scrutinee.rs:332:11
    |
 LL |     match mutex1.lock().unwrap().s.len() >= mutex2.lock().unwrap().s.len() {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 ...
 LL |                 mutex1.lock().unwrap().s.len(),
-   |                 ---------------------- another temporary with significant `Drop` created here
+   |                 ---------------------- another value with significant `Drop` created here
 LL |                 mutex2.lock().unwrap().s.len()
-   |                 ---------------------- another temporary with significant `Drop` created here
+   |                 ---------------------- another value with significant `Drop` created here
 ...
 LL |     };
-   |      - original temporary lives until here
+   |      - temporary lives until here
    |
    = note: this might lead to deadlocks or other unexpected behavior
 help: try moving the temporary above the match
@@ -265,16 +265,16 @@ LL ~     match value {
    |
 
 error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
-  --> $DIR/significant_drop_in_scrutinee.rs:354:11
+  --> $DIR/significant_drop_in_scrutinee.rs:367:11
    |
 LL |     match get_mutex_guard().s.len() > 1 {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 LL |         true => {
 LL |             mutex1.lock().unwrap().s.len();
-   |             ---------------------- another temporary with significant `Drop` created here
+   |             ---------------------- another value with significant `Drop` created here
 ...
 LL |     };
-   |      - original temporary lives until here
+   |      - temporary lives until here
    |
    = note: this might lead to deadlocks or other unexpected behavior
 help: try moving the temporary above the match
@@ -284,7 +284,7 @@ LL ~     match value {
    |
 
 error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
-  --> $DIR/significant_drop_in_scrutinee.rs:371:11
+  --> $DIR/significant_drop_in_scrutinee.rs:384:11
    |
 LL |       match match i {
    |  ___________^
@@ -297,10 +297,10 @@ LL | |         > 1
    | |___________^
 ...
 LL |               mutex1.lock().unwrap().s.len();
-   |               ---------------------- another temporary with significant `Drop` created here
+   |               ---------------------- another value with significant `Drop` created here
 ...
 LL |       };
-   |        - original temporary lives until here
+   |        - temporary lives until here
    |
    = note: this might lead to deadlocks or other unexpected behavior
 help: try moving the temporary above the match
@@ -314,7 +314,7 @@ LL +     .len()
  ...
 
 error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
-  --> $DIR/significant_drop_in_scrutinee.rs:397:11
+  --> $DIR/significant_drop_in_scrutinee.rs:410:11
    |
 LL |       match if i > 1 {
    |  ___________^
@@ -327,10 +327,10 @@ LL | |         > 1
    | |___________^
 ...
 LL |               mutex1.lock().unwrap().s.len();
-   |               ---------------------- another temporary with significant `Drop` created here
+   |               ---------------------- another value with significant `Drop` created here
 ...
 LL |       };
-   |        - original temporary lives until here
+   |        - temporary lives until here
    |
    = note: this might lead to deadlocks or other unexpected behavior
 help: try moving the temporary above the match
@@ -344,15 +344,15 @@ LL +     .s
  ...
 
 error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
-  --> $DIR/significant_drop_in_scrutinee.rs:451:11
+  --> $DIR/significant_drop_in_scrutinee.rs:464:11
    |
 LL |     match s.lock().deref().deref() {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^
 LL |         0 | 1 => println!("Value was less than 2"),
 LL |         _ => println!("Value is {}", s.lock().deref()),
-   |                                      ---------------- another temporary with significant `Drop` created here
+   |                                      ---------------- another value with significant `Drop` created here
 LL |     };
-   |      - original temporary lives until here
+   |      - temporary lives until here
    |
    = note: this might lead to deadlocks or other unexpected behavior
 help: try moving the temporary above the match and create a copy
@@ -362,29 +362,29 @@ LL ~     match value {
    |
 
 error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
-  --> $DIR/significant_drop_in_scrutinee.rs:479:11
+  --> $DIR/significant_drop_in_scrutinee.rs:492:11
    |
 LL |     match s.lock().deref().deref() {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^
 LL |         matcher => println!("Value is {}", s.lock().deref()),
-   |                                            ---------------- another temporary with significant `Drop` created here
+   |                                            ---------------- another value with significant `Drop` created here
 LL |         _ => println!("Value was not a match"),
 LL |     };
-   |      - original temporary lives until here
+   |      - temporary lives until here
    |
    = note: this might lead to deadlocks or other unexpected behavior
 
 error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
-  --> $DIR/significant_drop_in_scrutinee.rs:498:11
+  --> $DIR/significant_drop_in_scrutinee.rs:511:11
    |
 LL |     match mutex.lock().unwrap().i = i {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 LL |         _ => {
 LL |             println!("{}", mutex.lock().unwrap().i);
-   |                            --------------------- another temporary with significant `Drop` created here
+   |                            --------------------- another value with significant `Drop` created here
 LL |         },
 LL |     };
-   |      - original temporary lives until here
+   |      - temporary lives until here
    |
    = note: this might lead to deadlocks or other unexpected behavior
 help: try moving the temporary above the match
@@ -394,16 +394,16 @@ LL ~     match () {
    |
 
 error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
-  --> $DIR/significant_drop_in_scrutinee.rs:504:11
+  --> $DIR/significant_drop_in_scrutinee.rs:517:11
    |
 LL |     match i = mutex.lock().unwrap().i {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 LL |         _ => {
 LL |             println!("{}", mutex.lock().unwrap().i);
-   |                            --------------------- another temporary with significant `Drop` created here
+   |                            --------------------- another value with significant `Drop` created here
 LL |         },
 LL |     };
-   |      - original temporary lives until here
+   |      - temporary lives until here
    |
    = note: this might lead to deadlocks or other unexpected behavior
 help: try moving the temporary above the match
@@ -413,16 +413,16 @@ LL ~     match () {
    |
 
 error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
-  --> $DIR/significant_drop_in_scrutinee.rs:510:11
+  --> $DIR/significant_drop_in_scrutinee.rs:523:11
    |
 LL |     match mutex.lock().unwrap().i += 1 {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 LL |         _ => {
 LL |             println!("{}", mutex.lock().unwrap().i);
-   |                            --------------------- another temporary with significant `Drop` created here
+   |                            --------------------- another value with significant `Drop` created here
 LL |         },
 LL |     };
-   |      - original temporary lives until here
+   |      - temporary lives until here
    |
    = note: this might lead to deadlocks or other unexpected behavior
 help: try moving the temporary above the match
@@ -432,16 +432,16 @@ LL ~     match () {
    |
 
 error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
-  --> $DIR/significant_drop_in_scrutinee.rs:516:11
+  --> $DIR/significant_drop_in_scrutinee.rs:529:11
    |
 LL |     match i += mutex.lock().unwrap().i {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 LL |         _ => {
 LL |             println!("{}", mutex.lock().unwrap().i);
-   |                            --------------------- another temporary with significant `Drop` created here
+   |                            --------------------- another value with significant `Drop` created here
 LL |         },
 LL |     };
-   |      - original temporary lives until here
+   |      - temporary lives until here
    |
    = note: this might lead to deadlocks or other unexpected behavior
 help: try moving the temporary above the match
@@ -451,35 +451,35 @@ LL ~     match () {
    |
 
 error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
-  --> $DIR/significant_drop_in_scrutinee.rs:579:11
+  --> $DIR/significant_drop_in_scrutinee.rs:592:11
    |
 LL |     match rwlock.read().unwrap().to_number() {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 ...
 LL |     };
-   |      - original temporary lives until here
+   |      - temporary lives until here
    |
    = note: this might lead to deadlocks or other unexpected behavior
 
 error: temporary with significant `Drop` in `for` loop condition will live until the end of the `for` expression
-  --> $DIR/significant_drop_in_scrutinee.rs:589:14
+  --> $DIR/significant_drop_in_scrutinee.rs:602:14
    |
 LL |     for s in rwlock.read().unwrap().iter() {
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 LL |         println!("{}", s);
 LL |     }
-   |      - original temporary lives until here
+   |      - temporary lives until here
    |
    = note: this might lead to deadlocks or other unexpected behavior
 
 error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
-  --> $DIR/significant_drop_in_scrutinee.rs:604:11
+  --> $DIR/significant_drop_in_scrutinee.rs:617:11
    |
 LL |     match mutex.lock().unwrap().foo() {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 ...
 LL |     };
-   |      - original temporary lives until here
+   |      - temporary lives until here
    |
    = note: this might lead to deadlocks or other unexpected behavior
 help: try moving the temporary above the match
-- 
cgit 1.4.1-3-g733a5


From 7bc40967a44f08e359c760ca6587b0d7d62e57a7 Mon Sep 17 00:00:00 2001
From: Preston From <prestonfrom@gmail.com>
Date: Mon, 27 Jun 2022 23:01:47 -0600
Subject: Run cargo dev fmt

---
 clippy_lints/src/matches/significant_drop_in_scrutinee.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/significant_drop_in_scrutinee.rs b/clippy_lints/src/matches/significant_drop_in_scrutinee.rs
index 7efa81226e0..0704a5af525 100644
--- a/clippy_lints/src/matches/significant_drop_in_scrutinee.rs
+++ b/clippy_lints/src/matches/significant_drop_in_scrutinee.rs
@@ -1,7 +1,7 @@
 use crate::FxHashSet;
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::{get_attr, is_lint_allowed};
 use clippy_utils::source::{indent_of, snippet};
+use clippy_utils::{get_attr, is_lint_allowed};
 use rustc_errors::{Applicability, Diagnostic};
 use rustc_hir::intravisit::{walk_expr, Visitor};
 use rustc_hir::{Arm, Expr, ExprKind, MatchSource};
-- 
cgit 1.4.1-3-g733a5


From 81737bf85062509dbd2bd80f917aac786dd9642f Mon Sep 17 00:00:00 2001
From: Marcel Hellwig <github@cookiesoft.de>
Date: Mon, 2 May 2022 11:31:39 +0200
Subject: try reading rust-version from Cargo.toml

Cargo.toml can contain a field `rust-version`, that acts like a MSRV of
clippy.toml file: https://doc.rust-lang.org/cargo/reference/manifest.html#the-rust-version-field
This will try to read that field and use it, if the clippy.toml config
has no `msrv` entry
---
 clippy_lints/src/lib.rs | 50 ++++++++++++++++++++++++++++++++++++-------------
 1 file changed, 37 insertions(+), 13 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 078df64a1e1..b6ff9bcb76d 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -52,6 +52,7 @@ extern crate clippy_utils;
 use clippy_utils::parse_msrv;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_lint::LintId;
+use rustc_semver::RustcVersion;
 use rustc_session::Session;
 
 /// Macro used to declare a Clippy lint.
@@ -450,6 +451,39 @@ pub fn register_pre_expansion_lints(store: &mut rustc_lint::LintStore, sess: &Se
     store.register_pre_expansion_pass(move || Box::new(attrs::EarlyAttributes { msrv }));
 }
 
+fn read_msrv(conf: &Conf, sess: &Session) -> Option<RustcVersion> {
+    let cargo_msrv = std::env::var("CARGO_PKG_RUST_VERSION")
+        .ok()
+        .and_then(|v| parse_msrv(&v, None, None));
+    let clippy_msrv = conf.msrv.as_ref().and_then(|s| {
+        parse_msrv(s, None, None).or_else(|| {
+            sess.err(&format!(
+                "error reading Clippy's configuration file. `{}` is not a valid Rust version",
+                s
+            ));
+            None
+        })
+    });
+
+    if let Some(cargo_msrv) = cargo_msrv {
+        if let Some(clippy_msrv) = clippy_msrv {
+            // if both files have an msrv, let's compare them and emit a warning if they differ
+            if clippy_msrv != cargo_msrv {
+                sess.warn(&format!(
+                    "the MSRV in `clippy.toml` and `Cargo.toml` differ; using `{}` from `clippy.toml`",
+                    clippy_msrv
+                ));
+            }
+
+            Some(clippy_msrv)
+        } else {
+            Some(cargo_msrv)
+        }
+    } else {
+        clippy_msrv
+    }
+}
+
 #[doc(hidden)]
 pub fn read_conf(sess: &Session) -> Conf {
     let file_name = match utils::conf::lookup_conf_file() {
@@ -465,12 +499,11 @@ pub fn read_conf(sess: &Session) -> Conf {
     let TryConf { conf, errors } = utils::conf::read(&file_name);
     // all conf errors are non-fatal, we just use the default conf in case of error
     for error in errors {
-        sess.struct_err(&format!(
+        sess.err(&format!(
             "error reading Clippy's configuration file `{}`: {}",
             file_name.display(),
             format_error(error)
-        ))
-        .emit();
+        ));
     }
 
     conf
@@ -577,16 +610,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(non_octal_unix_permissions::NonOctalUnixPermissions));
     store.register_early_pass(|| Box::new(unnecessary_self_imports::UnnecessarySelfImports));
 
-    let msrv = conf.msrv.as_ref().and_then(|s| {
-        parse_msrv(s, None, None).or_else(|| {
-            sess.err(&format!(
-                "error reading Clippy's configuration file. `{}` is not a valid Rust version",
-                s
-            ));
-            None
-        })
-    });
-
+    let msrv = read_msrv(conf, sess);
     let avoid_breaking_exported_api = conf.avoid_breaking_exported_api;
     let allow_expect_in_tests = conf.allow_expect_in_tests;
     let allow_unwrap_in_tests = conf.allow_unwrap_in_tests;
-- 
cgit 1.4.1-3-g733a5


From 8a74d3357079e5edf2454f6523a9c93081e7348e Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Wed, 26 Jan 2022 22:47:09 -0500
Subject: Add `explicit_auto_deref` lint

---
 CHANGELOG.md                                       |   1 +
 clippy_lints/src/dereference.rs                    | 309 ++++++++++++++++++++-
 clippy_lints/src/lib.register_all.rs               |   1 +
 clippy_lints/src/lib.register_complexity.rs        |   1 +
 clippy_lints/src/lib.register_lints.rs             |   1 +
 .../src/matches/match_str_case_mismatch.rs         |   2 +-
 clippy_lints/src/non_expressive_names.rs           |   2 +-
 clippy_lints/src/ptr.rs                            |   9 +-
 clippy_lints/src/redundant_static_lifetimes.rs     |   2 +-
 clippy_utils/src/lib.rs                            |  68 ++++-
 clippy_utils/src/ty.rs                             |  73 ++++-
 tests/ui/borrow_deref_ref_unfixable.rs             |   2 +-
 tests/ui/explicit_auto_deref.fixed                 | 161 +++++++++++
 tests/ui/explicit_auto_deref.rs                    | 161 +++++++++++
 tests/ui/explicit_auto_deref.stderr                | 160 +++++++++++
 tests/ui/explicit_deref_methods.fixed              |   3 +-
 tests/ui/explicit_deref_methods.rs                 |   3 +-
 tests/ui/explicit_deref_methods.stderr             |  24 +-
 tests/ui/useless_asref.fixed                       |   1 +
 tests/ui/useless_asref.rs                          |   1 +
 tests/ui/useless_asref.stderr                      |  22 +-
 21 files changed, 954 insertions(+), 53 deletions(-)
 create mode 100644 tests/ui/explicit_auto_deref.fixed
 create mode 100644 tests/ui/explicit_auto_deref.rs
 create mode 100644 tests/ui/explicit_auto_deref.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index bc50ff3a44a..9bc93c1cb42 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3400,6 +3400,7 @@ Released 2018-09-13
 [`expect_fun_call`]: https://rust-lang.github.io/rust-clippy/master/index.html#expect_fun_call
 [`expect_used`]: https://rust-lang.github.io/rust-clippy/master/index.html#expect_used
 [`expl_impl_clone_on_copy`]: https://rust-lang.github.io/rust-clippy/master/index.html#expl_impl_clone_on_copy
+[`explicit_auto_deref`]: https://rust-lang.github.io/rust-clippy/master/index.html#explicit_auto_deref
 [`explicit_counter_loop`]: https://rust-lang.github.io/rust-clippy/master/index.html#explicit_counter_loop
 [`explicit_deref_methods`]: https://rust-lang.github.io/rust-clippy/master/index.html#explicit_deref_methods
 [`explicit_into_iter_loop`]: https://rust-lang.github.io/rust-clippy/master/index.html#explicit_into_iter_loop
diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index b47441eff37..77518933a23 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -1,18 +1,21 @@
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_hir_and_then};
 use clippy_utils::source::{snippet_with_applicability, snippet_with_context};
 use clippy_utils::sugg::has_enclosing_paren;
-use clippy_utils::ty::peel_mid_ty_refs;
-use clippy_utils::{get_parent_expr, get_parent_node, is_lint_allowed, path_to_local};
+use clippy_utils::ty::{expr_sig, peel_mid_ty_refs, variant_of_res};
+use clippy_utils::{
+    get_parent_expr, get_parent_node, is_lint_allowed, path_to_local, peel_hir_ty_refs, walk_to_expr_usage,
+};
 use rustc_ast::util::parser::{PREC_POSTFIX, PREC_PREFIX};
 use rustc_data_structures::fx::FxIndexMap;
 use rustc_errors::Applicability;
 use rustc_hir::{
-    BindingAnnotation, Body, BodyId, BorrowKind, Destination, Expr, ExprKind, HirId, MatchSource, Mutability, Node,
-    Pat, PatKind, UnOp,
+    self as hir, BindingAnnotation, Body, BodyId, BorrowKind, Destination, Expr, ExprKind, FnRetTy, GenericArg, HirId,
+    ImplItem, ImplItemKind, Item, ItemKind, Local, MatchSource, Mutability, Node, Pat, PatKind, Path, QPath, TraitItem,
+    TraitItemKind, TyKind, UnOp,
 };
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::adjustment::{Adjust, Adjustment, AutoBorrow, AutoBorrowMutability};
-use rustc_middle::ty::{self, Ty, TyCtxt, TypeckResults};
+use rustc_middle::ty::{self, Ty, TyCtxt, TypeFoldable, TypeckResults};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::{symbol::sym, Span};
 
@@ -104,10 +107,34 @@ declare_clippy_lint! {
     "`ref` binding to a reference"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for dereferencing expressions which would be covered by auto-deref.
+    ///
+    /// ### Why is this bad?
+    /// This unnecessarily complicates the code.
+    ///
+    /// ### Example
+    /// ```rust
+    /// let x = String::new();
+    /// let y: &str = &*x;
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// let x = String::new();
+    /// let y: &str = &x;
+    /// ```
+    #[clippy::version = "1.60.0"]
+    pub EXPLICIT_AUTO_DEREF,
+    complexity,
+    "dereferencing when the compiler would automatically dereference"
+}
+
 impl_lint_pass!(Dereferencing => [
     EXPLICIT_DEREF_METHODS,
     NEEDLESS_BORROW,
     REF_BINDING_TO_REFERENCE,
+    EXPLICIT_AUTO_DEREF,
 ]);
 
 #[derive(Default)]
@@ -152,6 +179,11 @@ enum State {
         required_precedence: i8,
         msg: &'static str,
     },
+    ExplicitDeref {
+        deref_span: Span,
+        deref_hir_id: HirId,
+    },
+    Borrow,
 }
 
 // A reference operation considered by this lint pass
@@ -305,6 +337,14 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing {
                                     hir_id: expr.hir_id,
                                 },
                             ));
+                        } else if is_stable_auto_deref_position(cx, expr) {
+                            self.state = Some((
+                                State::Borrow,
+                                StateData {
+                                    span: expr.span,
+                                    hir_id: expr.hir_id,
+                                },
+                            ));
                         }
                     },
                     _ => (),
@@ -354,6 +394,18 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing {
                     data,
                 ));
             },
+            (Some((State::Borrow, data)), RefOp::Deref) => {
+                self.state = Some((
+                    State::ExplicitDeref {
+                        deref_span: expr.span,
+                        deref_hir_id: expr.hir_id,
+                    },
+                    data,
+                ));
+            },
+            (state @ Some((State::ExplicitDeref { .. }, _)), RefOp::Deref) => {
+                self.state = state;
+            },
 
             (Some((state, data)), _) => report(cx, expr, state, data),
         }
@@ -596,8 +648,230 @@ fn find_adjustments<'tcx>(
     }
 }
 
+// Checks if the expression for the given id occurs in a position which auto dereferencing applies.
+// Note that the target type must not be inferred in a way that may cause auto-deref to select a
+// different type, nor may the position be the result of a macro expansion.
+//
+// e.g. the following should not linted
+// macro_rules! foo { ($e:expr) => { let x: &str = $e; }}
+// foo!(&*String::new());
+// fn foo<T>(_: &T) {}
+// foo(&*String::new())
+fn is_stable_auto_deref_position<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> bool {
+    walk_to_expr_usage(cx, e, |node, child_id| match node {
+        Node::Local(&Local { ty: Some(ty), .. }) => Some(is_binding_ty_auto_deref_stable(ty)),
+        Node::Item(&Item {
+            kind: ItemKind::Static(..) | ItemKind::Const(..),
+            ..
+        })
+        | Node::TraitItem(&TraitItem {
+            kind: TraitItemKind::Const(..),
+            ..
+        })
+        | Node::ImplItem(&ImplItem {
+            kind: ImplItemKind::Const(..),
+            ..
+        }) => Some(true),
+
+        Node::Item(&Item {
+            kind: ItemKind::Fn(..),
+            def_id,
+            ..
+        })
+        | Node::TraitItem(&TraitItem {
+            kind: TraitItemKind::Fn(..),
+            def_id,
+            ..
+        })
+        | Node::ImplItem(&ImplItem {
+            kind: ImplItemKind::Fn(..),
+            def_id,
+            ..
+        }) => {
+            let output = cx.tcx.fn_sig(def_id.to_def_id()).skip_binder().output();
+            Some(!(output.has_placeholders() || output.has_opaque_types()))
+        },
+
+        Node::Expr(e) => match e.kind {
+            ExprKind::Ret(_) => {
+                let output = cx
+                    .tcx
+                    .fn_sig(cx.tcx.hir().body_owner_def_id(cx.enclosing_body.unwrap()))
+                    .skip_binder()
+                    .output();
+                Some(!(output.has_placeholders() || output.has_opaque_types()))
+            },
+            ExprKind::Call(func, args) => Some(
+                args.iter()
+                    .position(|arg| arg.hir_id == child_id)
+                    .zip(expr_sig(cx, func))
+                    .and_then(|(i, sig)| sig.input_with_hir(i))
+                    .map_or(false, |(hir_ty, ty)| match hir_ty {
+                        // Type inference for closures can depend on how they're called. Only go by the explicit
+                        // types here.
+                        Some(ty) => is_binding_ty_auto_deref_stable(ty),
+                        None => is_param_auto_deref_stable(ty.skip_binder()),
+                    }),
+            ),
+            ExprKind::MethodCall(_, [_, args @ ..], _) => {
+                let id = cx.typeck_results().type_dependent_def_id(e.hir_id).unwrap();
+                Some(args.iter().position(|arg| arg.hir_id == child_id).map_or(false, |i| {
+                    let arg = cx.tcx.fn_sig(id).skip_binder().inputs()[i + 1];
+                    is_param_auto_deref_stable(arg)
+                }))
+            },
+            ExprKind::Struct(path, fields, _) => {
+                let variant = variant_of_res(cx, cx.qpath_res(path, e.hir_id));
+                Some(
+                    fields
+                        .iter()
+                        .find(|f| f.expr.hir_id == child_id)
+                        .zip(variant)
+                        .and_then(|(field, variant)| variant.fields.iter().find(|f| f.name == field.ident.name))
+                        .map_or(false, |field| is_param_auto_deref_stable(cx.tcx.type_of(field.did))),
+                )
+            },
+            _ => None,
+        },
+        _ => None,
+    })
+    .unwrap_or(false)
+}
+
+// Checks whether auto-dereferencing any type into a binding of the given type will definitely
+// produce the same result.
+//
+// e.g.
+// let x = Box::new(Box::new(0u32));
+// let y1: &Box<_> = x.deref();
+// let y2: &Box<_> = &x;
+//
+// Here `y1` and `y2` would resolve to different types, so the type `&Box<_>` is not stable when
+// switching to auto-dereferencing.
+fn is_binding_ty_auto_deref_stable(ty: &hir::Ty<'_>) -> bool {
+    let (ty, count) = peel_hir_ty_refs(ty);
+    if count != 1 {
+        return false;
+    }
+
+    match &ty.kind {
+        TyKind::Rptr(_, ty) => is_binding_ty_auto_deref_stable(ty.ty),
+        &TyKind::Path(
+            QPath::TypeRelative(_, path)
+            | QPath::Resolved(
+                _,
+                Path {
+                    segments: [.., path], ..
+                },
+            ),
+        ) => {
+            if let Some(args) = path.args {
+                args.args.iter().all(|arg| {
+                    if let GenericArg::Type(ty) = arg {
+                        !ty_contains_infer(ty)
+                    } else {
+                        true
+                    }
+                })
+            } else {
+                true
+            }
+        },
+        TyKind::Slice(_)
+        | TyKind::Array(..)
+        | TyKind::BareFn(_)
+        | TyKind::Never
+        | TyKind::Tup(_)
+        | TyKind::Ptr(_)
+        | TyKind::TraitObject(..)
+        | TyKind::Path(_) => true,
+        TyKind::OpaqueDef(..) | TyKind::Infer | TyKind::Typeof(..) | TyKind::Err => false,
+    }
+}
+
+// Checks whether a type is inferred at some point.
+// e.g. `_`, `Box<_>`, `[_]`
+fn ty_contains_infer(ty: &hir::Ty<'_>) -> bool {
+    match &ty.kind {
+        TyKind::Slice(ty) | TyKind::Array(ty, _) => ty_contains_infer(ty),
+        TyKind::Ptr(ty) | TyKind::Rptr(_, ty) => ty_contains_infer(ty.ty),
+        TyKind::Tup(tys) => tys.iter().any(ty_contains_infer),
+        TyKind::BareFn(ty) => {
+            if ty.decl.inputs.iter().any(ty_contains_infer) {
+                return true;
+            }
+            if let FnRetTy::Return(ty) = &ty.decl.output {
+                ty_contains_infer(ty)
+            } else {
+                false
+            }
+        },
+        &TyKind::Path(
+            QPath::TypeRelative(_, path)
+            | QPath::Resolved(
+                _,
+                Path {
+                    segments: [.., path], ..
+                },
+            ),
+        ) => {
+            if let Some(args) = path.args {
+                args.args.iter().any(|arg| {
+                    if let GenericArg::Type(ty) = arg {
+                        ty_contains_infer(ty)
+                    } else {
+                        false
+                    }
+                })
+            } else {
+                false
+            }
+        },
+        TyKind::Path(_) | TyKind::OpaqueDef(..) | TyKind::Infer | TyKind::Typeof(_) | TyKind::Err => true,
+        TyKind::Never | TyKind::TraitObject(..) => false,
+    }
+}
+
+// Checks whether a type is stable when switching to auto dereferencing,
+fn is_param_auto_deref_stable(ty: Ty<'_>) -> bool {
+    let (ty, count) = peel_mid_ty_refs(ty);
+    if count != 1 {
+        return false;
+    }
+
+    match ty.kind() {
+        ty::Bool
+        | ty::Char
+        | ty::Int(_)
+        | ty::Uint(_)
+        | ty::Float(_)
+        | ty::Foreign(_)
+        | ty::Str
+        | ty::Array(..)
+        | ty::Slice(..)
+        | ty::RawPtr(..)
+        | ty::FnDef(..)
+        | ty::FnPtr(_)
+        | ty::Closure(..)
+        | ty::Generator(..)
+        | ty::GeneratorWitness(..)
+        | ty::Never
+        | ty::Tuple(_)
+        | ty::Ref(..)
+        | ty::Projection(_) => true,
+        ty::Infer(_)
+        | ty::Error(_)
+        | ty::Param(_)
+        | ty::Bound(..)
+        | ty::Opaque(..)
+        | ty::Placeholder(_)
+        | ty::Dynamic(..) => false,
+        ty::Adt(..) => !(ty.has_placeholders() || ty.has_param_types_or_consts()),
+    }
+}
+
 #[expect(clippy::needless_pass_by_value)]
-fn report<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>, state: State, data: StateData) {
+fn report<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, state: State, data: StateData) {
     match state {
         State::DerefMethod {
             ty_changed_count,
@@ -663,6 +937,29 @@ fn report<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>, state: State, data: S
                 diag.span_suggestion(data.span, "change this to", sugg, app);
             });
         },
+        State::ExplicitDeref {
+            deref_span,
+            deref_hir_id,
+        } => {
+            let (span, hir_id) = if cx.typeck_results().expr_ty(expr).is_ref() {
+                (data.span, data.hir_id)
+            } else {
+                (deref_span, deref_hir_id)
+            };
+            span_lint_hir_and_then(
+                cx,
+                EXPLICIT_AUTO_DEREF,
+                hir_id,
+                span,
+                "deref which would be done by auto-deref",
+                |diag| {
+                    let mut app = Applicability::MachineApplicable;
+                    let snip = snippet_with_context(cx, expr.span, span.ctxt(), "..", &mut app).0;
+                    diag.span_suggestion(span, "try this", snip.into_owned(), app);
+                },
+            );
+        },
+        State::Borrow => (),
     }
 }
 
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index b4edb8ea90e..56262c8f96e 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -44,6 +44,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(crate_in_macro_def::CRATE_IN_MACRO_DEF),
     LintId::of(default::FIELD_REASSIGN_WITH_DEFAULT),
     LintId::of(default_instead_of_iter_empty::DEFAULT_INSTEAD_OF_ITER_EMPTY),
+    LintId::of(dereference::EXPLICIT_AUTO_DEREF),
     LintId::of(dereference::NEEDLESS_BORROW),
     LintId::of(derivable_impls::DERIVABLE_IMPLS),
     LintId::of(derive::DERIVE_HASH_XOR_EQ),
diff --git a/clippy_lints/src/lib.register_complexity.rs b/clippy_lints/src/lib.register_complexity.rs
index 27de11bf1ae..d7f6140ca4b 100644
--- a/clippy_lints/src/lib.register_complexity.rs
+++ b/clippy_lints/src/lib.register_complexity.rs
@@ -9,6 +9,7 @@ store.register_group(true, "clippy::complexity", Some("clippy_complexity"), vec!
     LintId::of(bytes_count_to_len::BYTES_COUNT_TO_LEN),
     LintId::of(casts::CHAR_LIT_AS_U8),
     LintId::of(casts::UNNECESSARY_CAST),
+    LintId::of(dereference::EXPLICIT_AUTO_DEREF),
     LintId::of(derivable_impls::DERIVABLE_IMPLS),
     LintId::of(double_comparison::DOUBLE_COMPARISONS),
     LintId::of(double_parens::DOUBLE_PARENS),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 29a5f368f23..75993fa168f 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -110,6 +110,7 @@ store.register_lints(&[
     default_instead_of_iter_empty::DEFAULT_INSTEAD_OF_ITER_EMPTY,
     default_numeric_fallback::DEFAULT_NUMERIC_FALLBACK,
     default_union_representation::DEFAULT_UNION_REPRESENTATION,
+    dereference::EXPLICIT_AUTO_DEREF,
     dereference::EXPLICIT_DEREF_METHODS,
     dereference::NEEDLESS_BORROW,
     dereference::REF_BINDING_TO_REFERENCE,
diff --git a/clippy_lints/src/matches/match_str_case_mismatch.rs b/clippy_lints/src/matches/match_str_case_mismatch.rs
index 8302ce426e5..fa3b8d1fcea 100644
--- a/clippy_lints/src/matches/match_str_case_mismatch.rs
+++ b/clippy_lints/src/matches/match_str_case_mismatch.rs
@@ -118,7 +118,7 @@ fn lint(cx: &LateContext<'_>, case_method: &CaseMethod, bad_case_span: Span, bad
         MATCH_STR_CASE_MISMATCH,
         bad_case_span,
         "this `match` arm has a differing case than its expression",
-        &*format!("consider changing the case of this arm to respect `{}`", method_str),
+        &format!("consider changing the case of this arm to respect `{}`", method_str),
         format!("\"{}\"", suggestion),
         Applicability::MachineApplicable,
     );
diff --git a/clippy_lints/src/non_expressive_names.rs b/clippy_lints/src/non_expressive_names.rs
index c93b4b2f205..b96af06b8d7 100644
--- a/clippy_lints/src/non_expressive_names.rs
+++ b/clippy_lints/src/non_expressive_names.rs
@@ -326,7 +326,7 @@ impl<'a, 'tcx> Visitor<'tcx> for SimilarNamesLocalVisitor<'a, 'tcx> {
         // add the pattern after the expression because the bindings aren't available
         // yet in the init
         // expression
-        SimilarNamesNameVisitor(self).visit_pat(&*local.pat);
+        SimilarNamesNameVisitor(self).visit_pat(&local.pat);
     }
     fn visit_block(&mut self, blk: &'tcx Block) {
         self.single_char_names.push(vec![]);
diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs
index b06eba13d2f..5678b8f6ca6 100644
--- a/clippy_lints/src/ptr.rs
+++ b/clippy_lints/src/ptr.rs
@@ -574,14 +574,13 @@ fn check_ptr_arg_usage<'tcx>(cx: &LateContext<'tcx>, body: &'tcx Body<'_>, args:
                 Some((Node::Expr(e), child_id)) => match e.kind {
                     ExprKind::Call(f, expr_args) => {
                         let i = expr_args.iter().position(|arg| arg.hir_id == child_id).unwrap_or(0);
-                        if expr_sig(self.cx, f)
-                            .map(|sig| sig.input(i).skip_binder().peel_refs())
-                            .map_or(true, |ty| match *ty.kind() {
+                        if expr_sig(self.cx, f).and_then(|sig| sig.input(i)).map_or(true, |ty| {
+                            match *ty.skip_binder().peel_refs().kind() {
                                 ty::Param(_) => true,
                                 ty::Adt(def, _) => def.did() == args.ty_did,
                                 _ => false,
-                            })
-                        {
+                            }
+                        }) {
                             // Passed to a function taking the non-dereferenced type.
                             set_skip_flag();
                         }
diff --git a/clippy_lints/src/redundant_static_lifetimes.rs b/clippy_lints/src/redundant_static_lifetimes.rs
index 0825f00f421..f8801f769e8 100644
--- a/clippy_lints/src/redundant_static_lifetimes.rs
+++ b/clippy_lints/src/redundant_static_lifetimes.rs
@@ -87,7 +87,7 @@ impl RedundantStaticLifetimes {
                         _ => {},
                     }
                 }
-                self.visit_type(&*borrow_type.ty, cx, reason);
+                self.visit_type(&borrow_type.ty, cx, reason);
             },
             _ => {},
         }
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 73c1bdd0e3f..ca056e7c1a0 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -2058,6 +2058,21 @@ pub fn peel_hir_expr_refs<'a>(expr: &'a Expr<'a>) -> (&'a Expr<'a>, usize) {
     (e, count)
 }
 
+/// Peels off all references on the type. Returns the underlying type and the number of references
+/// removed.
+pub fn peel_hir_ty_refs<'a>(mut ty: &'a hir::Ty<'a>) -> (&'a hir::Ty<'a>, usize) {
+    let mut count = 0;
+    loop {
+        match &ty.kind {
+            TyKind::Rptr(_, ref_ty) => {
+                ty = ref_ty.ty;
+                count += 1;
+            },
+            _ => break (ty, count),
+        }
+    }
+}
+
 /// Removes `AddrOf` operators (`&`) or deref operators (`*`), but only if a reference type is
 /// dereferenced. An overloaded deref such as `Vec` to slice would not be removed.
 pub fn peel_ref_operators<'hir>(cx: &LateContext<'_>, mut expr: &'hir Expr<'hir>) -> &'hir Expr<'hir> {
@@ -2110,7 +2125,7 @@ fn with_test_item_names<'tcx>(tcx: TyCtxt<'tcx>, module: LocalDefId, f: impl Fn(
                 }
             }
             names.sort_unstable();
-            f(&*entry.insert(names))
+            f(entry.insert(names))
         },
     }
 }
@@ -2168,6 +2183,57 @@ pub fn is_test_module_or_function(tcx: TyCtxt<'_>, item: &Item<'_>) -> bool {
             && item.ident.name.as_str().split('_').any(|a| a == "test" || a == "tests")
 }
 
+/// Walks the HIR tree from the given expression, up to the node where the value produced by the
+/// expression is consumed. Calls the function for every node encountered this way until it returns
+/// `Some`.
+///
+/// This allows walking through `if`, `match`, `break`, block expressions to find where the value
+/// produced by the expression is consumed.
+pub fn walk_to_expr_usage<'tcx, T>(
+    cx: &LateContext<'tcx>,
+    e: &Expr<'tcx>,
+    mut f: impl FnMut(Node<'tcx>, HirId) -> Option<T>,
+) -> Option<T> {
+    let map = cx.tcx.hir();
+    let mut iter = map.parent_iter(e.hir_id);
+    let mut child_id = e.hir_id;
+
+    while let Some((parent_id, parent)) = iter.next() {
+        if let Some(x) = f(parent, child_id) {
+            return Some(x);
+        }
+        let parent = match parent {
+            Node::Expr(e) => e,
+            Node::Block(Block { expr: Some(body), .. }) | Node::Arm(Arm { body, .. }) if body.hir_id == child_id => {
+                child_id = parent_id;
+                continue;
+            },
+            Node::Arm(a) if a.body.hir_id == child_id => {
+                child_id = parent_id;
+                continue;
+            },
+            _ => return None,
+        };
+        match parent.kind {
+            ExprKind::If(child, ..) | ExprKind::Match(child, ..) if child.hir_id != child_id => {
+                child_id = parent_id;
+                continue;
+            },
+            ExprKind::Break(Destination { target_id: Ok(id), .. }, _) => {
+                child_id = id;
+                iter = map.parent_iter(id);
+                continue;
+            },
+            ExprKind::Block(..) => {
+                child_id = parent_id;
+                continue;
+            },
+            _ => return None,
+        }
+    }
+    None
+}
+
 macro_rules! op_utils {
     ($($name:ident $assign:ident)*) => {
         /// Binary operation traits like `LangItem::Add`
diff --git a/clippy_utils/src/ty.rs b/clippy_utils/src/ty.rs
index 12831ea4355..2c19e8a7adb 100644
--- a/clippy_utils/src/ty.rs
+++ b/clippy_utils/src/ty.rs
@@ -6,16 +6,16 @@ use core::ops::ControlFlow;
 use rustc_ast::ast::Mutability;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_hir as hir;
-use rustc_hir::def::{CtorKind, DefKind, Res};
+use rustc_hir::def::{CtorKind, CtorOf, DefKind, Res};
 use rustc_hir::def_id::DefId;
-use rustc_hir::{Expr, LangItem, TyKind, Unsafety};
+use rustc_hir::{Expr, FnDecl, LangItem, TyKind, Unsafety};
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::LateContext;
 use rustc_middle::mir::interpret::{ConstValue, Scalar};
 use rustc_middle::ty::subst::{GenericArg, GenericArgKind, Subst};
 use rustc_middle::ty::{
-    self, AdtDef, Binder, BoundRegion, FnSig, IntTy, ParamEnv, Predicate, PredicateKind, ProjectionTy, Region,
-    RegionKind, Ty, TyCtxt, TypeFoldable, TypeSuperFoldable, TypeVisitor, UintTy, VariantDiscr,
+    self, AdtDef, Binder, BoundRegion, DefIdTree, FnSig, IntTy, ParamEnv, Predicate, PredicateKind, ProjectionTy,
+    Region, RegionKind, Ty, TyCtxt, TypeFoldable, TypeSuperFoldable, TypeVisitor, UintTy, VariantDef, VariantDiscr,
 };
 use rustc_span::symbol::Ident;
 use rustc_span::{sym, Span, Symbol, DUMMY_SP};
@@ -502,16 +502,46 @@ pub fn all_predicates_of(tcx: TyCtxt<'_>, id: DefId) -> impl Iterator<Item = &(P
 #[derive(Clone, Copy)]
 pub enum ExprFnSig<'tcx> {
     Sig(Binder<'tcx, FnSig<'tcx>>),
-    Closure(Binder<'tcx, FnSig<'tcx>>),
+    Closure(Option<&'tcx FnDecl<'tcx>>, Binder<'tcx, FnSig<'tcx>>),
     Trait(Binder<'tcx, Ty<'tcx>>, Option<Binder<'tcx, Ty<'tcx>>>),
 }
 impl<'tcx> ExprFnSig<'tcx> {
-    /// Gets the argument type at the given offset.
-    pub fn input(self, i: usize) -> Binder<'tcx, Ty<'tcx>> {
+    /// Gets the argument type at the given offset. This will return `None` when the index is out of
+    /// bounds only for variadic functions, otherwise this will panic.
+    pub fn input(self, i: usize) -> Option<Binder<'tcx, Ty<'tcx>>> {
         match self {
-            Self::Sig(sig) => sig.input(i),
-            Self::Closure(sig) => sig.input(0).map_bound(|ty| ty.tuple_fields()[i]),
-            Self::Trait(inputs, _) => inputs.map_bound(|ty| ty.tuple_fields()[i]),
+            Self::Sig(sig) => {
+                if sig.c_variadic() {
+                    sig.inputs().map_bound(|inputs| inputs.get(i).copied()).transpose()
+                } else {
+                    Some(sig.input(i))
+                }
+            },
+            Self::Closure(_, sig) => Some(sig.input(0).map_bound(|ty| ty.tuple_fields()[i])),
+            Self::Trait(inputs, _) => Some(inputs.map_bound(|ty| ty.tuple_fields()[i])),
+        }
+    }
+
+    /// Gets the argument type at the given offset. For closures this will also get the type as
+    /// written. This will return `None` when the index is out of bounds only for variadic
+    /// functions, otherwise this will panic.
+    pub fn input_with_hir(self, i: usize) -> Option<(Option<&'tcx hir::Ty<'tcx>>, Binder<'tcx, Ty<'tcx>>)> {
+        match self {
+            Self::Sig(sig) => {
+                if sig.c_variadic() {
+                    sig.inputs()
+                        .map_bound(|inputs| inputs.get(i).copied())
+                        .transpose()
+                        .map(|arg| (None, arg))
+                } else {
+                    Some((None, sig.input(i)))
+                }
+            },
+            Self::Closure(decl, sig) => Some((
+                decl.and_then(|decl| decl.inputs.get(i)),
+                sig.input(0).map_bound(|ty| ty.tuple_fields()[i]),
+            )),
+            Self::Trait(inputs, _) => Some((None, inputs.map_bound(|ty| ty.tuple_fields()[i]))),
         }
     }
 
@@ -519,7 +549,7 @@ impl<'tcx> ExprFnSig<'tcx> {
     /// specified.
     pub fn output(self) -> Option<Binder<'tcx, Ty<'tcx>>> {
         match self {
-            Self::Sig(sig) | Self::Closure(sig) => Some(sig.output()),
+            Self::Sig(sig) | Self::Closure(_, sig) => Some(sig.output()),
             Self::Trait(_, output) => output,
         }
     }
@@ -536,7 +566,12 @@ pub fn expr_sig<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>) -> Option<ExprFnS
 
 fn ty_sig<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Option<ExprFnSig<'tcx>> {
     match *ty.kind() {
-        ty::Closure(_, subs) => Some(ExprFnSig::Closure(subs.as_closure().sig())),
+        ty::Closure(id, subs) => {
+            let decl = id
+                .as_local()
+                .and_then(|id| cx.tcx.hir().fn_decl_by_hir_id(cx.tcx.hir().local_def_id_to_hir_id(id)));
+            Some(ExprFnSig::Closure(decl, subs.as_closure().sig()))
+        },
         ty::FnDef(id, subs) => Some(ExprFnSig::Sig(cx.tcx.bound_fn_sig(id).subst(cx.tcx, subs))),
         ty::FnPtr(sig) => Some(ExprFnSig::Sig(sig)),
         ty::Dynamic(bounds, _) => {
@@ -739,3 +774,17 @@ pub fn for_each_top_level_late_bound_region<B>(
     }
     ty.visit_with(&mut V { index: 0, f })
 }
+
+pub fn variant_of_res<'tcx>(cx: &LateContext<'tcx>, res: Res) -> Option<&'tcx VariantDef> {
+    match res {
+        Res::Def(DefKind::Struct, id) => Some(cx.tcx.adt_def(id).non_enum_variant()),
+        Res::Def(DefKind::Variant, id) => Some(cx.tcx.adt_def(cx.tcx.parent(id)).variant_with_id(id)),
+        Res::Def(DefKind::Ctor(CtorOf::Struct, _), id) => Some(cx.tcx.adt_def(cx.tcx.parent(id)).non_enum_variant()),
+        Res::Def(DefKind::Ctor(CtorOf::Variant, _), id) => {
+            let var_id = cx.tcx.parent(id);
+            Some(cx.tcx.adt_def(cx.tcx.parent(var_id)).variant_with_id(var_id))
+        },
+        Res::SelfCtor(id) => Some(cx.tcx.type_of(id).ty_adt_def().unwrap().non_enum_variant()),
+        _ => None,
+    }
+}
diff --git a/tests/ui/borrow_deref_ref_unfixable.rs b/tests/ui/borrow_deref_ref_unfixable.rs
index a8e2bbfef0f..b4e93774436 100644
--- a/tests/ui/borrow_deref_ref_unfixable.rs
+++ b/tests/ui/borrow_deref_ref_unfixable.rs
@@ -1,4 +1,4 @@
-#![allow(dead_code, unused_variables)]
+#![allow(dead_code, unused_variables, clippy::explicit_auto_deref)]
 
 fn main() {}
 
diff --git a/tests/ui/explicit_auto_deref.fixed b/tests/ui/explicit_auto_deref.fixed
new file mode 100644
index 00000000000..04039ca3154
--- /dev/null
+++ b/tests/ui/explicit_auto_deref.fixed
@@ -0,0 +1,161 @@
+// run-rustfix
+
+#![warn(clippy::explicit_auto_deref)]
+#![allow(
+    dead_code,
+    unused_braces,
+    clippy::borrowed_box,
+    clippy::needless_borrow,
+    clippy::ptr_arg,
+    clippy::redundant_field_names,
+    clippy::too_many_arguments
+)]
+
+trait CallableStr {
+    type T: Fn(&str);
+    fn callable_str(&self) -> Self::T;
+}
+impl CallableStr for () {
+    type T = fn(&str);
+    fn callable_str(&self) -> Self::T {
+        fn f(_: &str) {}
+        f
+    }
+}
+impl CallableStr for i32 {
+    type T = <() as CallableStr>::T;
+    fn callable_str(&self) -> Self::T {
+        ().callable_str()
+    }
+}
+
+trait CallableT<U: ?Sized> {
+    type T: Fn(&U);
+    fn callable_t(&self) -> Self::T;
+}
+impl<U: ?Sized> CallableT<U> for () {
+    type T = fn(&U);
+    fn callable_t(&self) -> Self::T {
+        fn f<U: ?Sized>(_: &U) {}
+        f::<U>
+    }
+}
+impl<U: ?Sized> CallableT<U> for i32 {
+    type T = <() as CallableT<U>>::T;
+    fn callable_t(&self) -> Self::T {
+        ().callable_t()
+    }
+}
+
+fn f_str(_: &str) {}
+fn f_t<T>(_: T) {}
+fn f_ref_t<T: ?Sized>(_: &T) {}
+
+fn f_str_t<T>(_: &str, _: T) {}
+
+fn f_box_t<T>(_: &Box<T>) {}
+
+fn main() {
+    let s = String::new();
+
+    let _: &str = &s;
+    let _ = &*s; // Don't lint. Inferred type would change.
+    let _: &_ = &*s; // Don't lint. Inferred type would change.
+
+    f_str(&s);
+    f_t(&*s); // Don't lint. Inferred type would change.
+    f_ref_t(&*s); // Don't lint. Inferred type would change.
+
+    f_str_t(&s, &*s); // Don't lint second param.
+
+    let b = Box::new(Box::new(Box::new(5)));
+    let _: &Box<i32> = &b;
+    let _: &Box<_> = &**b; // Don't lint. Inferred type would change.
+
+    f_box_t(&**b); // Don't lint. Inferred type would change.
+
+    let c = |_x: &str| ();
+    c(&s);
+
+    let c = |_x| ();
+    c(&*s); // Don't lint. Inferred type would change.
+
+    fn _f(x: &String) -> &str {
+        x
+    }
+
+    fn _f1(x: &String) -> &str {
+        { x }
+    }
+
+    fn _f2(x: &String) -> &str {
+        { x }
+    }
+
+    fn _f3(x: &Box<Box<Box<i32>>>) -> &Box<i32> {
+        x
+    }
+
+    fn _f4(
+        x: String,
+        f1: impl Fn(&str),
+        f2: &dyn Fn(&str),
+        f3: fn(&str),
+        f4: impl CallableStr,
+        f5: <() as CallableStr>::T,
+        f6: <i32 as CallableStr>::T,
+        f7: &dyn CallableStr<T = fn(&str)>,
+        f8: impl CallableT<str>,
+        f9: <() as CallableT<str>>::T,
+        f10: <i32 as CallableT<str>>::T,
+        f11: &dyn CallableT<str, T = fn(&str)>,
+    ) {
+        f1(&x);
+        f2(&x);
+        f3(&x);
+        f4.callable_str()(&x);
+        f5(&x);
+        f6(&x);
+        f7.callable_str()(&x);
+        f8.callable_t()(&x);
+        f9(&x);
+        f10(&x);
+        f11.callable_t()(&x);
+    }
+
+    struct S1<'a>(&'a str);
+    let _ = S1(&s);
+
+    struct S2<'a> {
+        s: &'a str,
+    }
+    let _ = S2 { s: &s };
+
+    struct S3<'a, T: ?Sized>(&'a T);
+    let _ = S3(&*s); // Don't lint. Inferred type would change.
+
+    struct S4<'a, T: ?Sized> {
+        s: &'a T,
+    }
+    let _ = S4 { s: &*s }; // Don't lint. Inferred type would change.
+
+    enum E1<'a> {
+        S1(&'a str),
+        S2 { s: &'a str },
+    }
+    impl<'a> E1<'a> {
+        fn m1(s: &'a String) {
+            let _ = Self::S1(s);
+            let _ = Self::S2 { s: s };
+        }
+    }
+    let _ = E1::S1(&s);
+    let _ = E1::S2 { s: &s };
+
+    enum E2<'a, T: ?Sized> {
+        S1(&'a T),
+        S2 { s: &'a T },
+    }
+    let _ = E2::S1(&*s); // Don't lint. Inferred type would change.
+    let _ = E2::S2 { s: &*s }; // Don't lint. Inferred type would change.
+}
diff --git a/tests/ui/explicit_auto_deref.rs b/tests/ui/explicit_auto_deref.rs
new file mode 100644
index 00000000000..1cc77c1b08f
--- /dev/null
+++ b/tests/ui/explicit_auto_deref.rs
@@ -0,0 +1,161 @@
+// run-rustfix
+
+#![warn(clippy::explicit_auto_deref)]
+#![allow(
+    dead_code,
+    unused_braces,
+    clippy::borrowed_box,
+    clippy::needless_borrow,
+    clippy::ptr_arg,
+    clippy::redundant_field_names,
+    clippy::too_many_arguments
+)]
+
+trait CallableStr {
+    type T: Fn(&str);
+    fn callable_str(&self) -> Self::T;
+}
+impl CallableStr for () {
+    type T = fn(&str);
+    fn callable_str(&self) -> Self::T {
+        fn f(_: &str) {}
+        f
+    }
+}
+impl CallableStr for i32 {
+    type T = <() as CallableStr>::T;
+    fn callable_str(&self) -> Self::T {
+        ().callable_str()
+    }
+}
+
+trait CallableT<U: ?Sized> {
+    type T: Fn(&U);
+    fn callable_t(&self) -> Self::T;
+}
+impl<U: ?Sized> CallableT<U> for () {
+    type T = fn(&U);
+    fn callable_t(&self) -> Self::T {
+        fn f<U: ?Sized>(_: &U) {}
+        f::<U>
+    }
+}
+impl<U: ?Sized> CallableT<U> for i32 {
+    type T = <() as CallableT<U>>::T;
+    fn callable_t(&self) -> Self::T {
+        ().callable_t()
+    }
+}
+
+fn f_str(_: &str) {}
+fn f_t<T>(_: T) {}
+fn f_ref_t<T: ?Sized>(_: &T) {}
+
+fn f_str_t<T>(_: &str, _: T) {}
+
+fn f_box_t<T>(_: &Box<T>) {}
+
+fn main() {
+    let s = String::new();
+
+    let _: &str = &*s;
+    let _ = &*s; // Don't lint. Inferred type would change.
+    let _: &_ = &*s; // Don't lint. Inferred type would change.
+
+    f_str(&*s);
+    f_t(&*s); // Don't lint. Inferred type would change.
+    f_ref_t(&*s); // Don't lint. Inferred type would change.
+
+    f_str_t(&*s, &*s); // Don't lint second param.
+
+    let b = Box::new(Box::new(Box::new(5)));
+    let _: &Box<i32> = &**b;
+    let _: &Box<_> = &**b; // Don't lint. Inferred type would change.
+
+    f_box_t(&**b); // Don't lint. Inferred type would change.
+
+    let c = |_x: &str| ();
+    c(&*s);
+
+    let c = |_x| ();
+    c(&*s); // Don't lint. Inferred type would change.
+
+    fn _f(x: &String) -> &str {
+        &**x
+    }
+
+    fn _f1(x: &String) -> &str {
+        { &**x }
+    }
+
+    fn _f2(x: &String) -> &str {
+        &**{ x }
+    }
+
+    fn _f3(x: &Box<Box<Box<i32>>>) -> &Box<i32> {
+        &***x
+    }
+
+    fn _f4(
+        x: String,
+        f1: impl Fn(&str),
+        f2: &dyn Fn(&str),
+        f3: fn(&str),
+        f4: impl CallableStr,
+        f5: <() as CallableStr>::T,
+        f6: <i32 as CallableStr>::T,
+        f7: &dyn CallableStr<T = fn(&str)>,
+        f8: impl CallableT<str>,
+        f9: <() as CallableT<str>>::T,
+        f10: <i32 as CallableT<str>>::T,
+        f11: &dyn CallableT<str, T = fn(&str)>,
+    ) {
+        f1(&*x);
+        f2(&*x);
+        f3(&*x);
+        f4.callable_str()(&*x);
+        f5(&*x);
+        f6(&*x);
+        f7.callable_str()(&*x);
+        f8.callable_t()(&*x);
+        f9(&*x);
+        f10(&*x);
+        f11.callable_t()(&*x);
+    }
+
+    struct S1<'a>(&'a str);
+    let _ = S1(&*s);
+
+    struct S2<'a> {
+        s: &'a str,
+    }
+    let _ = S2 { s: &*s };
+
+    struct S3<'a, T: ?Sized>(&'a T);
+    let _ = S3(&*s); // Don't lint. Inferred type would change.
+
+    struct S4<'a, T: ?Sized> {
+        s: &'a T,
+    }
+    let _ = S4 { s: &*s }; // Don't lint. Inferred type would change.
+
+    enum E1<'a> {
+        S1(&'a str),
+        S2 { s: &'a str },
+    }
+    impl<'a> E1<'a> {
+        fn m1(s: &'a String) {
+            let _ = Self::S1(&**s);
+            let _ = Self::S2 { s: &**s };
+        }
+    }
+    let _ = E1::S1(&*s);
+    let _ = E1::S2 { s: &*s };
+
+    enum E2<'a, T: ?Sized> {
+        S1(&'a T),
+        S2 { s: &'a T },
+    }
+    let _ = E2::S1(&*s); // Don't lint. Inferred type would change.
+    let _ = E2::S2 { s: &*s }; // Don't lint. Inferred type would change.
+}
diff --git a/tests/ui/explicit_auto_deref.stderr b/tests/ui/explicit_auto_deref.stderr
new file mode 100644
index 00000000000..f3cceb6b889
--- /dev/null
+++ b/tests/ui/explicit_auto_deref.stderr
@@ -0,0 +1,160 @@
+error: deref which would be done by auto-deref
+  --> $DIR/explicit_auto_deref.rs:61:20
+   |
+LL |     let _: &str = &*s;
+   |                    ^^ help: try this: `s`
+   |
+   = note: `-D clippy::explicit-auto-deref` implied by `-D warnings`
+
+error: deref which would be done by auto-deref
+  --> $DIR/explicit_auto_deref.rs:65:12
+   |
+LL |     f_str(&*s);
+   |            ^^ help: try this: `s`
+
+error: deref which would be done by auto-deref
+  --> $DIR/explicit_auto_deref.rs:69:14
+   |
+LL |     f_str_t(&*s, &*s); // Don't lint second param.
+   |              ^^ help: try this: `s`
+
+error: deref which would be done by auto-deref
+  --> $DIR/explicit_auto_deref.rs:72:25
+   |
+LL |     let _: &Box<i32> = &**b;
+   |                         ^^^ help: try this: `b`
+
+error: deref which would be done by auto-deref
+  --> $DIR/explicit_auto_deref.rs:78:8
+   |
+LL |     c(&*s);
+   |        ^^ help: try this: `s`
+
+error: deref which would be done by auto-deref
+  --> $DIR/explicit_auto_deref.rs:84:9
+   |
+LL |         &**x
+   |         ^^^^ help: try this: `x`
+
+error: deref which would be done by auto-deref
+  --> $DIR/explicit_auto_deref.rs:88:11
+   |
+LL |         { &**x }
+   |           ^^^^ help: try this: `x`
+
+error: deref which would be done by auto-deref
+  --> $DIR/explicit_auto_deref.rs:92:9
+   |
+LL |         &**{ x }
+   |         ^^^^^^^^ help: try this: `{ x }`
+
+error: deref which would be done by auto-deref
+  --> $DIR/explicit_auto_deref.rs:96:9
+   |
+LL |         &***x
+   |         ^^^^^ help: try this: `x`
+
+error: deref which would be done by auto-deref
+  --> $DIR/explicit_auto_deref.rs:113:13
+   |
+LL |         f1(&*x);
+   |             ^^ help: try this: `x`
+
+error: deref which would be done by auto-deref
+  --> $DIR/explicit_auto_deref.rs:114:13
+   |
+LL |         f2(&*x);
+   |             ^^ help: try this: `x`
+
+error: deref which would be done by auto-deref
+  --> $DIR/explicit_auto_deref.rs:115:13
+   |
+LL |         f3(&*x);
+   |             ^^ help: try this: `x`
+
+error: deref which would be done by auto-deref
+  --> $DIR/explicit_auto_deref.rs:116:28
+   |
+LL |         f4.callable_str()(&*x);
+   |                            ^^ help: try this: `x`
+
+error: deref which would be done by auto-deref
+  --> $DIR/explicit_auto_deref.rs:117:13
+   |
+LL |         f5(&*x);
+   |             ^^ help: try this: `x`
+
+error: deref which would be done by auto-deref
+  --> $DIR/explicit_auto_deref.rs:118:13
+   |
+LL |         f6(&*x);
+   |             ^^ help: try this: `x`
+
+error: deref which would be done by auto-deref
+  --> $DIR/explicit_auto_deref.rs:119:28
+   |
+LL |         f7.callable_str()(&*x);
+   |                            ^^ help: try this: `x`
+
+error: deref which would be done by auto-deref
+  --> $DIR/explicit_auto_deref.rs:120:26
+   |
+LL |         f8.callable_t()(&*x);
+   |                          ^^ help: try this: `x`
+
+error: deref which would be done by auto-deref
+  --> $DIR/explicit_auto_deref.rs:121:13
+   |
+LL |         f9(&*x);
+   |             ^^ help: try this: `x`
+
+error: deref which would be done by auto-deref
+  --> $DIR/explicit_auto_deref.rs:122:14
+   |
+LL |         f10(&*x);
+   |              ^^ help: try this: `x`
+
+error: deref which would be done by auto-deref
+  --> $DIR/explicit_auto_deref.rs:123:27
+   |
+LL |         f11.callable_t()(&*x);
+   |                           ^^ help: try this: `x`
+
+error: deref which would be done by auto-deref
+  --> $DIR/explicit_auto_deref.rs:127:17
+   |
+LL |     let _ = S1(&*s);
+   |                 ^^ help: try this: `s`
+
+error: deref which would be done by auto-deref
+  --> $DIR/explicit_auto_deref.rs:132:22
+   |
+LL |     let _ = S2 { s: &*s };
+   |                      ^^ help: try this: `s`
+
+error: deref which would be done by auto-deref
+  --> $DIR/explicit_auto_deref.rs:148:30
+   |
+LL |             let _ = Self::S1(&**s);
+   |                              ^^^^ help: try this: `s`
+
+error: deref which would be done by auto-deref
+  --> $DIR/explicit_auto_deref.rs:149:35
+   |
+LL |             let _ = Self::S2 { s: &**s };
+   |                                   ^^^^ help: try this: `s`
+
+error: deref which would be done by auto-deref
+  --> $DIR/explicit_auto_deref.rs:152:21
+   |
+LL |     let _ = E1::S1(&*s);
+   |                     ^^ help: try this: `s`
+
+error: deref which would be done by auto-deref
+  --> $DIR/explicit_auto_deref.rs:153:26
+   |
+LL |     let _ = E1::S2 { s: &*s };
+   |                          ^^ help: try this: `s`
+
+error: aborting due to 26 previous errors
+
diff --git a/tests/ui/explicit_deref_methods.fixed b/tests/ui/explicit_deref_methods.fixed
index 92f27e68549..523cae183ee 100644
--- a/tests/ui/explicit_deref_methods.fixed
+++ b/tests/ui/explicit_deref_methods.fixed
@@ -4,7 +4,8 @@
     unused_variables,
     clippy::clone_double_ref,
     clippy::needless_borrow,
-    clippy::borrow_deref_ref
+    clippy::borrow_deref_ref,
+    clippy::explicit_auto_deref
 )]
 #![warn(clippy::explicit_deref_methods)]
 
diff --git a/tests/ui/explicit_deref_methods.rs b/tests/ui/explicit_deref_methods.rs
index d118607f992..0bbc1ae57cd 100644
--- a/tests/ui/explicit_deref_methods.rs
+++ b/tests/ui/explicit_deref_methods.rs
@@ -4,7 +4,8 @@
     unused_variables,
     clippy::clone_double_ref,
     clippy::needless_borrow,
-    clippy::borrow_deref_ref
+    clippy::borrow_deref_ref,
+    clippy::explicit_auto_deref
 )]
 #![warn(clippy::explicit_deref_methods)]
 
diff --git a/tests/ui/explicit_deref_methods.stderr b/tests/ui/explicit_deref_methods.stderr
index 8e8b358972b..4b10ed1377b 100644
--- a/tests/ui/explicit_deref_methods.stderr
+++ b/tests/ui/explicit_deref_methods.stderr
@@ -1,5 +1,5 @@
 error: explicit `deref` method call
-  --> $DIR/explicit_deref_methods.rs:35:19
+  --> $DIR/explicit_deref_methods.rs:36:19
    |
 LL |     let b: &str = a.deref();
    |                   ^^^^^^^^^ help: try this: `&*a`
@@ -7,67 +7,67 @@ LL |     let b: &str = a.deref();
    = note: `-D clippy::explicit-deref-methods` implied by `-D warnings`
 
 error: explicit `deref_mut` method call
-  --> $DIR/explicit_deref_methods.rs:37:23
+  --> $DIR/explicit_deref_methods.rs:38:23
    |
 LL |     let b: &mut str = a.deref_mut();
    |                       ^^^^^^^^^^^^^ help: try this: `&mut **a`
 
 error: explicit `deref` method call
-  --> $DIR/explicit_deref_methods.rs:40:39
+  --> $DIR/explicit_deref_methods.rs:41:39
    |
 LL |     let b: String = format!("{}, {}", a.deref(), a.deref());
    |                                       ^^^^^^^^^ help: try this: `&*a`
 
 error: explicit `deref` method call
-  --> $DIR/explicit_deref_methods.rs:40:50
+  --> $DIR/explicit_deref_methods.rs:41:50
    |
 LL |     let b: String = format!("{}, {}", a.deref(), a.deref());
    |                                                  ^^^^^^^^^ help: try this: `&*a`
 
 error: explicit `deref` method call
-  --> $DIR/explicit_deref_methods.rs:42:20
+  --> $DIR/explicit_deref_methods.rs:43:20
    |
 LL |     println!("{}", a.deref());
    |                    ^^^^^^^^^ help: try this: `&*a`
 
 error: explicit `deref` method call
-  --> $DIR/explicit_deref_methods.rs:45:11
+  --> $DIR/explicit_deref_methods.rs:46:11
    |
 LL |     match a.deref() {
    |           ^^^^^^^^^ help: try this: `&*a`
 
 error: explicit `deref` method call
-  --> $DIR/explicit_deref_methods.rs:49:28
+  --> $DIR/explicit_deref_methods.rs:50:28
    |
 LL |     let b: String = concat(a.deref());
    |                            ^^^^^^^^^ help: try this: `&*a`
 
 error: explicit `deref` method call
-  --> $DIR/explicit_deref_methods.rs:51:13
+  --> $DIR/explicit_deref_methods.rs:52:13
    |
 LL |     let b = just_return(a).deref();
    |             ^^^^^^^^^^^^^^^^^^^^^^ help: try this: `just_return(a)`
 
 error: explicit `deref` method call
-  --> $DIR/explicit_deref_methods.rs:53:28
+  --> $DIR/explicit_deref_methods.rs:54:28
    |
 LL |     let b: String = concat(just_return(a).deref());
    |                            ^^^^^^^^^^^^^^^^^^^^^^ help: try this: `just_return(a)`
 
 error: explicit `deref` method call
-  --> $DIR/explicit_deref_methods.rs:55:19
+  --> $DIR/explicit_deref_methods.rs:56:19
    |
 LL |     let b: &str = a.deref().deref();
    |                   ^^^^^^^^^^^^^^^^^ help: try this: `&**a`
 
 error: explicit `deref` method call
-  --> $DIR/explicit_deref_methods.rs:58:13
+  --> $DIR/explicit_deref_methods.rs:59:13
    |
 LL |     let b = opt_a.unwrap().deref();
    |             ^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&*opt_a.unwrap()`
 
 error: explicit `deref` method call
-  --> $DIR/explicit_deref_methods.rs:84:31
+  --> $DIR/explicit_deref_methods.rs:85:31
    |
 LL |     let b: &str = expr_deref!(a.deref());
    |                               ^^^^^^^^^ help: try this: `&*a`
diff --git a/tests/ui/useless_asref.fixed b/tests/ui/useless_asref.fixed
index e431661d180..90cb8945e77 100644
--- a/tests/ui/useless_asref.fixed
+++ b/tests/ui/useless_asref.fixed
@@ -1,6 +1,7 @@
 // run-rustfix
 
 #![deny(clippy::useless_asref)]
+#![allow(clippy::explicit_auto_deref)]
 
 use std::fmt::Debug;
 
diff --git a/tests/ui/useless_asref.rs b/tests/ui/useless_asref.rs
index 6ae931d7aa4..cb9f8ae5909 100644
--- a/tests/ui/useless_asref.rs
+++ b/tests/ui/useless_asref.rs
@@ -1,6 +1,7 @@
 // run-rustfix
 
 #![deny(clippy::useless_asref)]
+#![allow(clippy::explicit_auto_deref)]
 
 use std::fmt::Debug;
 
diff --git a/tests/ui/useless_asref.stderr b/tests/ui/useless_asref.stderr
index 5876b54aca8..b21c67bb364 100644
--- a/tests/ui/useless_asref.stderr
+++ b/tests/ui/useless_asref.stderr
@@ -1,5 +1,5 @@
 error: this call to `as_ref` does nothing
-  --> $DIR/useless_asref.rs:43:18
+  --> $DIR/useless_asref.rs:44:18
    |
 LL |         foo_rstr(rstr.as_ref());
    |                  ^^^^^^^^^^^^^ help: try this: `rstr`
@@ -11,61 +11,61 @@ LL | #![deny(clippy::useless_asref)]
    |         ^^^^^^^^^^^^^^^^^^^^^
 
 error: this call to `as_ref` does nothing
-  --> $DIR/useless_asref.rs:45:20
+  --> $DIR/useless_asref.rs:46:20
    |
 LL |         foo_rslice(rslice.as_ref());
    |                    ^^^^^^^^^^^^^^^ help: try this: `rslice`
 
 error: this call to `as_mut` does nothing
-  --> $DIR/useless_asref.rs:49:21
+  --> $DIR/useless_asref.rs:50:21
    |
 LL |         foo_mrslice(mrslice.as_mut());
    |                     ^^^^^^^^^^^^^^^^ help: try this: `mrslice`
 
 error: this call to `as_ref` does nothing
-  --> $DIR/useless_asref.rs:51:20
+  --> $DIR/useless_asref.rs:52:20
    |
 LL |         foo_rslice(mrslice.as_ref());
    |                    ^^^^^^^^^^^^^^^^ help: try this: `mrslice`
 
 error: this call to `as_ref` does nothing
-  --> $DIR/useless_asref.rs:58:20
+  --> $DIR/useless_asref.rs:59:20
    |
 LL |         foo_rslice(rrrrrslice.as_ref());
    |                    ^^^^^^^^^^^^^^^^^^^ help: try this: `rrrrrslice`
 
 error: this call to `as_ref` does nothing
-  --> $DIR/useless_asref.rs:60:18
+  --> $DIR/useless_asref.rs:61:18
    |
 LL |         foo_rstr(rrrrrstr.as_ref());
    |                  ^^^^^^^^^^^^^^^^^ help: try this: `rrrrrstr`
 
 error: this call to `as_mut` does nothing
-  --> $DIR/useless_asref.rs:65:21
+  --> $DIR/useless_asref.rs:66:21
    |
 LL |         foo_mrslice(mrrrrrslice.as_mut());
    |                     ^^^^^^^^^^^^^^^^^^^^ help: try this: `mrrrrrslice`
 
 error: this call to `as_ref` does nothing
-  --> $DIR/useless_asref.rs:67:20
+  --> $DIR/useless_asref.rs:68:20
    |
 LL |         foo_rslice(mrrrrrslice.as_ref());
    |                    ^^^^^^^^^^^^^^^^^^^^ help: try this: `mrrrrrslice`
 
 error: this call to `as_ref` does nothing
-  --> $DIR/useless_asref.rs:71:16
+  --> $DIR/useless_asref.rs:72:16
    |
 LL |     foo_rrrrmr((&&&&MoreRef).as_ref());
    |                ^^^^^^^^^^^^^^^^^^^^^^ help: try this: `(&&&&MoreRef)`
 
 error: this call to `as_mut` does nothing
-  --> $DIR/useless_asref.rs:121:13
+  --> $DIR/useless_asref.rs:122:13
    |
 LL |     foo_mrt(mrt.as_mut());
    |             ^^^^^^^^^^^^ help: try this: `mrt`
 
 error: this call to `as_ref` does nothing
-  --> $DIR/useless_asref.rs:123:12
+  --> $DIR/useless_asref.rs:124:12
    |
 LL |     foo_rt(mrt.as_ref());
    |            ^^^^^^^^^^^^ help: try this: `mrt`
-- 
cgit 1.4.1-3-g733a5


From ee532c02223059a5f6105b9ce423556032f1b487 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Thu, 27 Jan 2022 10:17:14 -0500
Subject: Don't lint `explicit_auto_deref` on reborrows

---
 clippy_lints/src/dereference.rs        | 38 +++++++++++++++++++++++--
 tests/ui/borrow_deref_ref_unfixable.rs |  2 +-
 tests/ui/explicit_auto_deref.fixed     |  8 +++++-
 tests/ui/explicit_auto_deref.rs        |  8 +++++-
 tests/ui/explicit_auto_deref.stderr    | 52 +++++++++++++++++-----------------
 5 files changed, 76 insertions(+), 32 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index 77518933a23..dc51da26269 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -183,6 +183,10 @@ enum State {
         deref_span: Span,
         deref_hir_id: HirId,
     },
+    Reborrow {
+        deref_span: Span,
+        deref_hir_id: HirId,
+    },
     Borrow,
 }
 
@@ -395,10 +399,38 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing {
                 ));
             },
             (Some((State::Borrow, data)), RefOp::Deref) => {
+                if typeck.expr_ty(sub_expr).is_ref() {
+                    self.state = Some((
+                        State::Reborrow {
+                            deref_span: expr.span,
+                            deref_hir_id: expr.hir_id,
+                        },
+                        data,
+                    ));
+                } else {
+                    self.state = Some((
+                        State::ExplicitDeref {
+                            deref_span: expr.span,
+                            deref_hir_id: expr.hir_id,
+                        },
+                        data,
+                    ));
+                }
+            },
+            (
+                Some((
+                    State::Reborrow {
+                        deref_span,
+                        deref_hir_id,
+                    },
+                    data,
+                )),
+                RefOp::Deref,
+            ) => {
                 self.state = Some((
                     State::ExplicitDeref {
-                        deref_span: expr.span,
-                        deref_hir_id: expr.hir_id,
+                        deref_span,
+                        deref_hir_id,
                     },
                     data,
                 ));
@@ -959,7 +991,7 @@ fn report<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, state: State, data
                 },
             );
         },
-        State::Borrow => (),
+        State::Borrow | State::Reborrow { .. } => (),
     }
 }
 
diff --git a/tests/ui/borrow_deref_ref_unfixable.rs b/tests/ui/borrow_deref_ref_unfixable.rs
index b4e93774436..a8e2bbfef0f 100644
--- a/tests/ui/borrow_deref_ref_unfixable.rs
+++ b/tests/ui/borrow_deref_ref_unfixable.rs
@@ -1,4 +1,4 @@
-#![allow(dead_code, unused_variables, clippy::explicit_auto_deref)]
+#![allow(dead_code, unused_variables)]
 
 fn main() {}
 
diff --git a/tests/ui/explicit_auto_deref.fixed b/tests/ui/explicit_auto_deref.fixed
index 04039ca3154..0d3f8b61afc 100644
--- a/tests/ui/explicit_auto_deref.fixed
+++ b/tests/ui/explicit_auto_deref.fixed
@@ -8,7 +8,8 @@
     clippy::needless_borrow,
     clippy::ptr_arg,
     clippy::redundant_field_names,
-    clippy::too_many_arguments
+    clippy::too_many_arguments,
+    clippy::borrow_deref_ref
 )]
 
 trait CallableStr {
@@ -48,6 +49,7 @@ impl<U: ?Sized> CallableT<U> for i32 {
 }
 
 fn f_str(_: &str) {}
+fn f_string(_: &String) {}
 fn f_t<T>(_: T) {}
 fn f_ref_t<T: ?Sized>(_: &T) {}
 
@@ -158,4 +160,8 @@ fn main() {
     }
     let _ = E2::S1(&*s); // Don't lint. Inferred type would change.
     let _ = E2::S2 { s: &*s }; // Don't lint. Inferred type would change.
+
+    let ref_s = &s;
+    let _: &String = &*ref_s; // Don't lint reborrow.
+    f_string(&*ref_s); // Don't lint reborrow.
 }
diff --git a/tests/ui/explicit_auto_deref.rs b/tests/ui/explicit_auto_deref.rs
index 1cc77c1b08f..31c268bcdec 100644
--- a/tests/ui/explicit_auto_deref.rs
+++ b/tests/ui/explicit_auto_deref.rs
@@ -8,7 +8,8 @@
     clippy::needless_borrow,
     clippy::ptr_arg,
     clippy::redundant_field_names,
-    clippy::too_many_arguments
+    clippy::too_many_arguments,
+    clippy::borrow_deref_ref
 )]
 
 trait CallableStr {
@@ -48,6 +49,7 @@ impl<U: ?Sized> CallableT<U> for i32 {
 }
 
 fn f_str(_: &str) {}
+fn f_string(_: &String) {}
 fn f_t<T>(_: T) {}
 fn f_ref_t<T: ?Sized>(_: &T) {}
 
@@ -158,4 +160,8 @@ fn main() {
     }
     let _ = E2::S1(&*s); // Don't lint. Inferred type would change.
     let _ = E2::S2 { s: &*s }; // Don't lint. Inferred type would change.
+
+    let ref_s = &s;
+    let _: &String = &*ref_s; // Don't lint reborrow.
+    f_string(&*ref_s); // Don't lint reborrow.
 }
diff --git a/tests/ui/explicit_auto_deref.stderr b/tests/ui/explicit_auto_deref.stderr
index f3cceb6b889..b53b4b4a200 100644
--- a/tests/ui/explicit_auto_deref.stderr
+++ b/tests/ui/explicit_auto_deref.stderr
@@ -1,5 +1,5 @@
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:61:20
+  --> $DIR/explicit_auto_deref.rs:63:20
    |
 LL |     let _: &str = &*s;
    |                    ^^ help: try this: `s`
@@ -7,151 +7,151 @@ LL |     let _: &str = &*s;
    = note: `-D clippy::explicit-auto-deref` implied by `-D warnings`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:65:12
+  --> $DIR/explicit_auto_deref.rs:67:12
    |
 LL |     f_str(&*s);
    |            ^^ help: try this: `s`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:69:14
+  --> $DIR/explicit_auto_deref.rs:71:14
    |
 LL |     f_str_t(&*s, &*s); // Don't lint second param.
    |              ^^ help: try this: `s`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:72:25
+  --> $DIR/explicit_auto_deref.rs:74:25
    |
 LL |     let _: &Box<i32> = &**b;
    |                         ^^^ help: try this: `b`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:78:8
+  --> $DIR/explicit_auto_deref.rs:80:8
    |
 LL |     c(&*s);
    |        ^^ help: try this: `s`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:84:9
+  --> $DIR/explicit_auto_deref.rs:86:9
    |
 LL |         &**x
    |         ^^^^ help: try this: `x`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:88:11
+  --> $DIR/explicit_auto_deref.rs:90:11
    |
 LL |         { &**x }
    |           ^^^^ help: try this: `x`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:92:9
+  --> $DIR/explicit_auto_deref.rs:94:9
    |
 LL |         &**{ x }
    |         ^^^^^^^^ help: try this: `{ x }`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:96:9
+  --> $DIR/explicit_auto_deref.rs:98:9
    |
 LL |         &***x
    |         ^^^^^ help: try this: `x`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:113:13
+  --> $DIR/explicit_auto_deref.rs:115:13
    |
 LL |         f1(&*x);
    |             ^^ help: try this: `x`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:114:13
+  --> $DIR/explicit_auto_deref.rs:116:13
    |
 LL |         f2(&*x);
    |             ^^ help: try this: `x`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:115:13
+  --> $DIR/explicit_auto_deref.rs:117:13
    |
 LL |         f3(&*x);
    |             ^^ help: try this: `x`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:116:28
+  --> $DIR/explicit_auto_deref.rs:118:28
    |
 LL |         f4.callable_str()(&*x);
    |                            ^^ help: try this: `x`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:117:13
+  --> $DIR/explicit_auto_deref.rs:119:13
    |
 LL |         f5(&*x);
    |             ^^ help: try this: `x`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:118:13
+  --> $DIR/explicit_auto_deref.rs:120:13
    |
 LL |         f6(&*x);
    |             ^^ help: try this: `x`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:119:28
+  --> $DIR/explicit_auto_deref.rs:121:28
    |
 LL |         f7.callable_str()(&*x);
    |                            ^^ help: try this: `x`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:120:26
+  --> $DIR/explicit_auto_deref.rs:122:26
    |
 LL |         f8.callable_t()(&*x);
    |                          ^^ help: try this: `x`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:121:13
+  --> $DIR/explicit_auto_deref.rs:123:13
    |
 LL |         f9(&*x);
    |             ^^ help: try this: `x`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:122:14
+  --> $DIR/explicit_auto_deref.rs:124:14
    |
 LL |         f10(&*x);
    |              ^^ help: try this: `x`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:123:27
+  --> $DIR/explicit_auto_deref.rs:125:27
    |
 LL |         f11.callable_t()(&*x);
    |                           ^^ help: try this: `x`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:127:17
+  --> $DIR/explicit_auto_deref.rs:129:17
    |
 LL |     let _ = S1(&*s);
    |                 ^^ help: try this: `s`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:132:22
+  --> $DIR/explicit_auto_deref.rs:134:22
    |
 LL |     let _ = S2 { s: &*s };
    |                      ^^ help: try this: `s`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:148:30
+  --> $DIR/explicit_auto_deref.rs:150:30
    |
 LL |             let _ = Self::S1(&**s);
    |                              ^^^^ help: try this: `s`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:149:35
+  --> $DIR/explicit_auto_deref.rs:151:35
    |
 LL |             let _ = Self::S2 { s: &**s };
    |                                   ^^^^ help: try this: `s`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:152:21
+  --> $DIR/explicit_auto_deref.rs:154:21
    |
 LL |     let _ = E1::S1(&*s);
    |                     ^^ help: try this: `s`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:153:26
+  --> $DIR/explicit_auto_deref.rs:155:26
    |
 LL |     let _ = E1::S2 { s: &*s };
    |                          ^^ help: try this: `s`
-- 
cgit 1.4.1-3-g733a5


From a187d6412bbcf52f2e0cdcb271b3e453520c2840 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Thu, 27 Jan 2022 20:03:50 -0500
Subject: Merge different parent walking loops in `dereference.rs`

`needless_borrow` will now walk further to find the target type.
---
 clippy_lints/src/dereference.rs | 425 +++++++++++++++++++---------------------
 tests/ui/needless_borrow.fixed  |  13 +-
 tests/ui/needless_borrow.rs     |  13 +-
 tests/ui/needless_borrow.stderr |  18 +-
 4 files changed, 240 insertions(+), 229 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index dc51da26269..bb0b04b6366 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -2,15 +2,13 @@ use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_hir_and_then};
 use clippy_utils::source::{snippet_with_applicability, snippet_with_context};
 use clippy_utils::sugg::has_enclosing_paren;
 use clippy_utils::ty::{expr_sig, peel_mid_ty_refs, variant_of_res};
-use clippy_utils::{
-    get_parent_expr, get_parent_node, is_lint_allowed, path_to_local, peel_hir_ty_refs, walk_to_expr_usage,
-};
+use clippy_utils::{get_parent_expr, get_parent_node, is_lint_allowed, path_to_local, walk_to_expr_usage};
 use rustc_ast::util::parser::{PREC_POSTFIX, PREC_PREFIX};
 use rustc_data_structures::fx::FxIndexMap;
 use rustc_errors::Applicability;
 use rustc_hir::{
-    self as hir, BindingAnnotation, Body, BodyId, BorrowKind, Destination, Expr, ExprKind, FnRetTy, GenericArg, HirId,
-    ImplItem, ImplItemKind, Item, ItemKind, Local, MatchSource, Mutability, Node, Pat, PatKind, Path, QPath, TraitItem,
+    self as hir, BindingAnnotation, Body, BodyId, BorrowKind, Expr, ExprKind, FnRetTy, GenericArg, HirId, ImplItem,
+    ImplItemKind, Item, ItemKind, Local, MatchSource, Mutability, Node, Pat, PatKind, Path, QPath, TraitItem,
     TraitItemKind, TyKind, UnOp,
 };
 use rustc_lint::{LateContext, LateLintPass};
@@ -268,8 +266,9 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing {
                         ));
                     },
                     RefOp::AddrOf => {
+                        let (stability, adjustments) = walk_parents(cx, expr);
                         // Find the number of times the borrow is auto-derefed.
-                        let mut iter = find_adjustments(cx.tcx, typeck, expr).iter();
+                        let mut iter = adjustments.iter();
                         let mut deref_count = 0usize;
                         let next_adjust = loop {
                             match iter.next() {
@@ -316,8 +315,7 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing {
                         } else if let Some(&Adjust::Borrow(AutoBorrow::Ref(_, mutability))) =
                             next_adjust.map(|a| &a.kind)
                         {
-                            if matches!(mutability, AutoBorrowMutability::Mut { .. })
-                                && !is_auto_reborrow_position(parent)
+                            if matches!(mutability, AutoBorrowMutability::Mut { .. }) && !stability.is_reborrow_stable()
                             {
                                 (3, 0, deref_msg)
                             } else {
@@ -341,7 +339,7 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing {
                                     hir_id: expr.hir_id,
                                 },
                             ));
-                        } else if is_stable_auto_deref_position(cx, expr) {
+                        } else if stability.is_deref_stable() {
                             self.state = Some((
                                 State::Borrow,
                                 StateData {
@@ -614,164 +612,139 @@ fn is_linted_explicit_deref_position(parent: Option<Node<'_>>, child_id: HirId,
     }
 }
 
-/// Checks if the given expression is in a position which can be auto-reborrowed.
-/// Note: This is only correct assuming auto-deref is already occurring.
-fn is_auto_reborrow_position(parent: Option<Node<'_>>) -> bool {
-    match parent {
-        Some(Node::Expr(parent)) => matches!(parent.kind, ExprKind::MethodCall(..) | ExprKind::Call(..)),
-        Some(Node::Local(_)) => true,
-        _ => false,
-    }
+/// How stable the result of auto-deref is.
+#[derive(Clone, Copy)]
+enum AutoDerefStability {
+    /// Auto-deref will always choose the same type.
+    Deref,
+    /// Auto-deref will always reborrow a reference.
+    Reborrow,
+    /// Auto-deref will not occur, or it may select a different type.
+    None,
 }
+impl AutoDerefStability {
+    fn is_deref_stable(self) -> bool {
+        matches!(self, Self::Deref)
+    }
 
-/// Checks if the given expression is a position which can auto-borrow.
-fn is_auto_borrow_position(parent: Option<Node<'_>>, child_id: HirId) -> bool {
-    if let Some(Node::Expr(parent)) = parent {
-        match parent.kind {
-            // ExprKind::MethodCall(_, [self_arg, ..], _) => self_arg.hir_id == child_id,
-            ExprKind::Field(..) => true,
-            ExprKind::Call(f, _) => f.hir_id == child_id,
-            _ => false,
-        }
-    } else {
-        false
+    fn is_reborrow_stable(self) -> bool {
+        matches!(self, Self::Deref | Self::Reborrow)
     }
 }
 
-/// Adjustments are sometimes made in the parent block rather than the expression itself.
-fn find_adjustments<'tcx>(
-    tcx: TyCtxt<'tcx>,
-    typeck: &'tcx TypeckResults<'tcx>,
-    expr: &'tcx Expr<'tcx>,
-) -> &'tcx [Adjustment<'tcx>] {
-    let map = tcx.hir();
-    let mut iter = map.parent_iter(expr.hir_id);
-    let mut prev = expr;
-
-    loop {
-        match typeck.expr_adjustments(prev) {
-            [] => (),
-            a => break a,
-        };
+/// Walks up the parent expressions attempting to determine both how stable the auto-deref result
+/// is, and which adjustments will be applied to it. Note this will not consider auto-borrow
+/// locations as those follow different rules.
+fn walk_parents<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> (AutoDerefStability, &'tcx [Adjustment<'tcx>]) {
+    let mut adjustments = [].as_slice();
+    let stability = walk_to_expr_usage(cx, e, &mut |node, child_id| {
+        // LocalTableInContext returns the wrong lifetime, so go use `expr_adjustments` instead.
+        if adjustments.is_empty() && let Node::Expr(e) = cx.tcx.hir().get(child_id) {
+            adjustments = cx.typeck_results().expr_adjustments(e);
+        }
+        match node {
+            Node::Local(Local { ty: Some(ty), .. }) => Some(binding_ty_auto_deref_stability(ty)),
+            Node::Item(&Item {
+                kind: ItemKind::Static(..) | ItemKind::Const(..),
+                ..
+            })
+            | Node::TraitItem(&TraitItem {
+                kind: TraitItemKind::Const(..),
+                ..
+            })
+            | Node::ImplItem(&ImplItem {
+                kind: ImplItemKind::Const(..),
+                ..
+            }) => Some(AutoDerefStability::Deref),
 
-        match iter.next().map(|(_, x)| x) {
-            Some(Node::Block(_)) => {
-                if let Some((_, Node::Expr(e))) = iter.next() {
-                    prev = e;
-                } else {
-                    // This shouldn't happen. Blocks are always contained in an expression.
-                    break &[];
-                }
-            },
-            Some(Node::Expr(&Expr {
-                kind: ExprKind::Break(Destination { target_id: Ok(id), .. }, _),
+            Node::Item(&Item {
+                kind: ItemKind::Fn(..),
+                def_id,
+                ..
+            })
+            | Node::TraitItem(&TraitItem {
+                kind: TraitItemKind::Fn(..),
+                def_id,
                 ..
-            })) => {
-                if let Some(Node::Expr(e)) = map.find(id) {
-                    prev = e;
-                    iter = map.parent_iter(id);
+            })
+            | Node::ImplItem(&ImplItem {
+                kind: ImplItemKind::Fn(..),
+                def_id,
+                ..
+            }) => {
+                let output = cx.tcx.fn_sig(def_id.to_def_id()).skip_binder().output();
+                Some(if output.has_placeholders() || output.has_opaque_types() {
+                    AutoDerefStability::Reborrow
                 } else {
-                    // This shouldn't happen. The destination should exist.
-                    break &[];
-                }
+                    AutoDerefStability::Deref
+                })
             },
-            _ => break &[],
-        }
-    }
-}
-
-// Checks if the expression for the given id occurs in a position which auto dereferencing applies.
-// Note that the target type must not be inferred in a way that may cause auto-deref to select a
-// different type, nor may the position be the result of a macro expansion.
-//
-// e.g. the following should not linted
-// macro_rules! foo { ($e:expr) => { let x: &str = $e; }}
-// foo!(&*String::new());
-// fn foo<T>(_: &T) {}
-// foo(&*String::new())
-fn is_stable_auto_deref_position<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> bool {
-    walk_to_expr_usage(cx, e, |node, child_id| match node {
-        Node::Local(&Local { ty: Some(ty), .. }) => Some(is_binding_ty_auto_deref_stable(ty)),
-        Node::Item(&Item {
-            kind: ItemKind::Static(..) | ItemKind::Const(..),
-            ..
-        })
-        | Node::TraitItem(&TraitItem {
-            kind: TraitItemKind::Const(..),
-            ..
-        })
-        | Node::ImplItem(&ImplItem {
-            kind: ImplItemKind::Const(..),
-            ..
-        }) => Some(true),
 
-        Node::Item(&Item {
-            kind: ItemKind::Fn(..),
-            def_id,
-            ..
-        })
-        | Node::TraitItem(&TraitItem {
-            kind: TraitItemKind::Fn(..),
-            def_id,
-            ..
-        })
-        | Node::ImplItem(&ImplItem {
-            kind: ImplItemKind::Fn(..),
-            def_id,
-            ..
-        }) => {
-            let output = cx.tcx.fn_sig(def_id.to_def_id()).skip_binder().output();
-            Some(!(output.has_placeholders() || output.has_opaque_types()))
-        },
-
-        Node::Expr(e) => match e.kind {
-            ExprKind::Ret(_) => {
-                let output = cx
-                    .tcx
-                    .fn_sig(cx.tcx.hir().body_owner_def_id(cx.enclosing_body.unwrap()))
-                    .skip_binder()
-                    .output();
-                Some(!(output.has_placeholders() || output.has_opaque_types()))
-            },
-            ExprKind::Call(func, args) => Some(
-                args.iter()
+            Node::Expr(e) => match e.kind {
+                ExprKind::Ret(_) => {
+                    let output = cx
+                        .tcx
+                        .fn_sig(cx.tcx.hir().body_owner_def_id(cx.enclosing_body.unwrap()))
+                        .skip_binder()
+                        .output();
+                    Some(if output.has_placeholders() || output.has_opaque_types() {
+                        AutoDerefStability::Reborrow
+                    } else {
+                        AutoDerefStability::Deref
+                    })
+                },
+                ExprKind::Call(func, args) => args
+                    .iter()
                     .position(|arg| arg.hir_id == child_id)
                     .zip(expr_sig(cx, func))
                     .and_then(|(i, sig)| sig.input_with_hir(i))
-                    .map_or(false, |(hir_ty, ty)| match hir_ty {
+                    .map(|(hir_ty, ty)| match hir_ty {
                         // Type inference for closures can depend on how they're called. Only go by the explicit
                         // types here.
-                        Some(ty) => is_binding_ty_auto_deref_stable(ty),
-                        None => is_param_auto_deref_stable(ty.skip_binder()),
+                        Some(ty) => binding_ty_auto_deref_stability(ty),
+                        None => param_auto_deref_stability(ty.skip_binder()),
                     }),
-            ),
-            ExprKind::MethodCall(_, [_, args @ ..], _) => {
-                let id = cx.typeck_results().type_dependent_def_id(e.hir_id).unwrap();
-                Some(args.iter().position(|arg| arg.hir_id == child_id).map_or(false, |i| {
-                    let arg = cx.tcx.fn_sig(id).skip_binder().inputs()[i + 1];
-                    is_param_auto_deref_stable(arg)
-                }))
-            },
-            ExprKind::Struct(path, fields, _) => {
-                let variant = variant_of_res(cx, cx.qpath_res(path, e.hir_id));
-                Some(
+                ExprKind::MethodCall(_, [_, args @ ..], _) => {
+                    let id = cx.typeck_results().type_dependent_def_id(e.hir_id).unwrap();
+                    args.iter().position(|arg| arg.hir_id == child_id).map(|i| {
+                        let arg = cx.tcx.fn_sig(id).skip_binder().inputs()[i + 1];
+                        param_auto_deref_stability(arg)
+                    })
+                },
+                ExprKind::MethodCall(..) => Some(AutoDerefStability::Reborrow),
+                ExprKind::Struct(path, fields, _) => {
+                    let variant = variant_of_res(cx, cx.qpath_res(path, e.hir_id));
                     fields
                         .iter()
                         .find(|f| f.expr.hir_id == child_id)
                         .zip(variant)
                         .and_then(|(field, variant)| variant.fields.iter().find(|f| f.name == field.ident.name))
-                        .map_or(false, |field| is_param_auto_deref_stable(cx.tcx.type_of(field.did))),
-                )
+                        .map(|field| param_auto_deref_stability(cx.tcx.type_of(field.did)))
+                },
+                _ => None,
             },
             _ => None,
-        },
-        _ => None,
+        }
     })
-    .unwrap_or(false)
+    .unwrap_or(AutoDerefStability::None);
+    (stability, adjustments)
+}
+
+/// Checks if the given expression is a position which can auto-borrow.
+fn is_auto_borrow_position(parent: Option<Node<'_>>, child_id: HirId) -> bool {
+    if let Some(Node::Expr(parent)) = parent {
+        match parent.kind {
+            // ExprKind::MethodCall(_, [self_arg, ..], _) => self_arg.hir_id == child_id,
+            ExprKind::Field(..) => true,
+            ExprKind::Call(f, _) => f.hir_id == child_id,
+            _ => false,
+        }
+    } else {
+        false
+    }
 }
 
-// Checks whether auto-dereferencing any type into a binding of the given type will definitely
-// produce the same result.
+// Checks the stability of auto-deref when assigned to a binding with the given explicit type.
 //
 // e.g.
 // let x = Box::new(Box::new(0u32));
@@ -780,44 +753,49 @@ fn is_stable_auto_deref_position<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>
 //
 // Here `y1` and `y2` would resolve to different types, so the type `&Box<_>` is not stable when
 // switching to auto-dereferencing.
-fn is_binding_ty_auto_deref_stable(ty: &hir::Ty<'_>) -> bool {
-    let (ty, count) = peel_hir_ty_refs(ty);
-    if count != 1 {
-        return false;
-    }
+fn binding_ty_auto_deref_stability(ty: &hir::Ty<'_>) -> AutoDerefStability {
+    let TyKind::Rptr(_, ty) = &ty.kind else {
+        return AutoDerefStability::None;
+    };
+    let mut ty = ty;
 
-    match &ty.kind {
-        TyKind::Rptr(_, ty) => is_binding_ty_auto_deref_stable(ty.ty),
-        &TyKind::Path(
-            QPath::TypeRelative(_, path)
-            | QPath::Resolved(
-                _,
-                Path {
-                    segments: [.., path], ..
-                },
-            ),
-        ) => {
-            if let Some(args) = path.args {
-                args.args.iter().all(|arg| {
-                    if let GenericArg::Type(ty) = arg {
-                        !ty_contains_infer(ty)
-                    } else {
-                        true
-                    }
-                })
-            } else {
-                true
-            }
-        },
-        TyKind::Slice(_)
-        | TyKind::Array(..)
-        | TyKind::BareFn(_)
-        | TyKind::Never
-        | TyKind::Tup(_)
-        | TyKind::Ptr(_)
-        | TyKind::TraitObject(..)
-        | TyKind::Path(_) => true,
-        TyKind::OpaqueDef(..) | TyKind::Infer | TyKind::Typeof(..) | TyKind::Err => false,
+    loop {
+        break match ty.ty.kind {
+            TyKind::Rptr(_, ref ref_ty) => {
+                ty = ref_ty;
+                continue;
+            },
+            TyKind::Path(
+                QPath::TypeRelative(_, path)
+                | QPath::Resolved(
+                    _,
+                    Path {
+                        segments: [.., path], ..
+                    },
+                ),
+            ) => {
+                if let Some(args) = path.args
+                    && args.args.iter().any(|arg| match arg {
+                        GenericArg::Infer(_) => true,
+                        GenericArg::Type(ty) => ty_contains_infer(ty),
+                        _ => false,
+                    })
+                {
+                    AutoDerefStability::Reborrow
+                } else {
+                    AutoDerefStability::Deref
+                }
+            },
+            TyKind::Slice(_)
+            | TyKind::Array(..)
+            | TyKind::BareFn(_)
+            | TyKind::Never
+            | TyKind::Tup(_)
+            | TyKind::Ptr(_)
+            | TyKind::TraitObject(..)
+            | TyKind::Path(_) => AutoDerefStability::Deref,
+            TyKind::OpaqueDef(..) | TyKind::Infer | TyKind::Typeof(..) | TyKind::Err => AutoDerefStability::Reborrow,
+        };
     }
 }
 
@@ -846,59 +824,58 @@ fn ty_contains_infer(ty: &hir::Ty<'_>) -> bool {
                     segments: [.., path], ..
                 },
             ),
-        ) => {
-            if let Some(args) = path.args {
-                args.args.iter().any(|arg| {
-                    if let GenericArg::Type(ty) = arg {
-                        ty_contains_infer(ty)
-                    } else {
-                        false
-                    }
-                })
-            } else {
-                false
-            }
-        },
+        ) => path.args.map_or(false, |args| {
+            args.args.iter().any(|arg| match arg {
+                GenericArg::Infer(_) => true,
+                GenericArg::Type(ty) => ty_contains_infer(ty),
+                _ => false,
+            })
+        }),
         TyKind::Path(_) | TyKind::OpaqueDef(..) | TyKind::Infer | TyKind::Typeof(_) | TyKind::Err => true,
         TyKind::Never | TyKind::TraitObject(..) => false,
     }
 }
 
 // Checks whether a type is stable when switching to auto dereferencing,
-fn is_param_auto_deref_stable(ty: Ty<'_>) -> bool {
-    let (ty, count) = peel_mid_ty_refs(ty);
-    if count != 1 {
-        return false;
-    }
+fn param_auto_deref_stability(ty: Ty<'_>) -> AutoDerefStability {
+    let ty::Ref(_, mut ty, _) = *ty.kind() else {
+        return AutoDerefStability::None;
+    };
 
-    match ty.kind() {
-        ty::Bool
-        | ty::Char
-        | ty::Int(_)
-        | ty::Uint(_)
-        | ty::Float(_)
-        | ty::Foreign(_)
-        | ty::Str
-        | ty::Array(..)
-        | ty::Slice(..)
-        | ty::RawPtr(..)
-        | ty::FnDef(..)
-        | ty::FnPtr(_)
-        | ty::Closure(..)
-        | ty::Generator(..)
-        | ty::GeneratorWitness(..)
-        | ty::Never
-        | ty::Tuple(_)
-        | ty::Ref(..)
-        | ty::Projection(_) => true,
-        ty::Infer(_)
-        | ty::Error(_)
-        | ty::Param(_)
-        | ty::Bound(..)
-        | ty::Opaque(..)
-        | ty::Placeholder(_)
-        | ty::Dynamic(..) => false,
-        ty::Adt(..) => !(ty.has_placeholders() || ty.has_param_types_or_consts()),
+    loop {
+        break match *ty.kind() {
+            ty::Ref(_, ref_ty, _) => {
+                ty = ref_ty;
+                continue;
+            },
+            ty::Bool
+            | ty::Char
+            | ty::Int(_)
+            | ty::Uint(_)
+            | ty::Float(_)
+            | ty::Foreign(_)
+            | ty::Str
+            | ty::Array(..)
+            | ty::Slice(..)
+            | ty::RawPtr(..)
+            | ty::FnDef(..)
+            | ty::FnPtr(_)
+            | ty::Closure(..)
+            | ty::Generator(..)
+            | ty::GeneratorWitness(..)
+            | ty::Never
+            | ty::Tuple(_)
+            | ty::Projection(_) => AutoDerefStability::Deref,
+            ty::Infer(_)
+            | ty::Error(_)
+            | ty::Param(_)
+            | ty::Bound(..)
+            | ty::Opaque(..)
+            | ty::Placeholder(_)
+            | ty::Dynamic(..) => AutoDerefStability::Reborrow,
+            ty::Adt(..) if ty.has_placeholders() || ty.has_param_types_or_consts() => AutoDerefStability::Reborrow,
+            ty::Adt(..) => AutoDerefStability::Deref,
+        };
     }
 }
 
diff --git a/tests/ui/needless_borrow.fixed b/tests/ui/needless_borrow.fixed
index e7a483c0582..f48f2ae58dc 100644
--- a/tests/ui/needless_borrow.fixed
+++ b/tests/ui/needless_borrow.fixed
@@ -62,7 +62,18 @@ fn main() {
         0 => &mut x,
         _ => &mut *x,
     };
-
+    let y: &mut i32 = match 0 {
+        // Lint here. The type given above triggers auto-borrow.
+        0 => x,
+        _ => &mut *x,
+    };
+    fn ref_mut_i32(_: &mut i32) {}
+    ref_mut_i32(match 0 {
+        // Lint here. The type given above triggers auto-borrow.
+        0 => x,
+        _ => &mut *x,
+    });
+    // use 'x' after to make sure it's still usable in the fixed code.
     *x = 5;
 
     let s = String::new();
diff --git a/tests/ui/needless_borrow.rs b/tests/ui/needless_borrow.rs
index 1d6bf46405a..63515a82158 100644
--- a/tests/ui/needless_borrow.rs
+++ b/tests/ui/needless_borrow.rs
@@ -62,7 +62,18 @@ fn main() {
         0 => &mut x,
         _ => &mut *x,
     };
-
+    let y: &mut i32 = match 0 {
+        // Lint here. The type given above triggers auto-borrow.
+        0 => &mut x,
+        _ => &mut *x,
+    };
+    fn ref_mut_i32(_: &mut i32) {}
+    ref_mut_i32(match 0 {
+        // Lint here. The type given above triggers auto-borrow.
+        0 => &mut x,
+        _ => &mut *x,
+    });
+    // use 'x' after to make sure it's still usable in the fixed code.
     *x = 5;
 
     let s = String::new();
diff --git a/tests/ui/needless_borrow.stderr b/tests/ui/needless_borrow.stderr
index be59d8f546d..cd23d9fd072 100644
--- a/tests/ui/needless_borrow.stderr
+++ b/tests/ui/needless_borrow.stderr
@@ -84,17 +84,29 @@ error: this expression creates a reference which is immediately dereferenced by
 LL |     let y: &mut i32 = &mut &mut x;
    |                       ^^^^^^^^^^^ help: change this to: `x`
 
+error: this expression creates a reference which is immediately dereferenced by the compiler
+  --> $DIR/needless_borrow.rs:67:14
+   |
+LL |         0 => &mut x,
+   |              ^^^^^^ help: change this to: `x`
+
+error: this expression creates a reference which is immediately dereferenced by the compiler
+  --> $DIR/needless_borrow.rs:73:14
+   |
+LL |         0 => &mut x,
+   |              ^^^^^^ help: change this to: `x`
+
 error: this expression borrows a value the compiler would automatically borrow
-  --> $DIR/needless_borrow.rs:74:13
+  --> $DIR/needless_borrow.rs:85:13
    |
 LL |     let _ = (&x).0;
    |             ^^^^ help: change this to: `x`
 
 error: this expression borrows a value the compiler would automatically borrow
-  --> $DIR/needless_borrow.rs:76:22
+  --> $DIR/needless_borrow.rs:87:22
    |
 LL |     let _ = unsafe { (&*x).0 };
    |                      ^^^^^ help: change this to: `(*x)`
 
-error: aborting due to 16 previous errors
+error: aborting due to 18 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 20ea26234a99eb94727b901c00a1f31de91e22b8 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Fri, 28 Jan 2022 09:12:34 -0500
Subject: Lint field accesses in `explicit_auto_deref`

---
 clippy_lints/src/dereference.rs                    | 46 ++++++++++++++++++++--
 .../src/matches/redundant_pattern_match.rs         |  4 +-
 tests/ui/explicit_auto_deref.fixed                 | 20 ++++++++++
 tests/ui/explicit_auto_deref.rs                    | 20 ++++++++++
 tests/ui/explicit_auto_deref.stderr                | 14 ++++++-
 5 files changed, 98 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index bb0b04b6366..f1915f16339 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -15,7 +15,7 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::adjustment::{Adjust, Adjustment, AutoBorrow, AutoBorrowMutability};
 use rustc_middle::ty::{self, Ty, TyCtxt, TypeFoldable, TypeckResults};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::{symbol::sym, Span};
+use rustc_span::{symbol::sym, Span, Symbol};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -181,6 +181,9 @@ enum State {
         deref_span: Span,
         deref_hir_id: HirId,
     },
+    ExplicitDerefField {
+        name: Symbol,
+    },
     Reborrow {
         deref_span: Span,
         deref_hir_id: HirId,
@@ -243,8 +246,18 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing {
             (None, kind) => {
                 let parent = get_parent_node(cx.tcx, expr.hir_id);
                 let expr_ty = typeck.expr_ty(expr);
-
                 match kind {
+                    RefOp::Deref => {
+                        if let Some(Node::Expr(e)) = parent
+                            && let ExprKind::Field(_, name) = e.kind
+                            && !ty_contains_field(typeck.expr_ty(sub_expr), name.name)
+                        {
+                            self.state = Some((
+                                State::ExplicitDerefField { name: name.name },
+                                StateData { span: expr.span, hir_id: expr.hir_id },
+                            ));
+                        }
+                    }
                     RefOp::Method(target_mut)
                         if !is_lint_allowed(cx, EXPLICIT_DEREF_METHODS, expr.hir_id)
                             && is_linted_explicit_deref_position(parent, expr.hir_id, expr.span) =>
@@ -349,7 +362,7 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing {
                             ));
                         }
                     },
-                    _ => (),
+                    RefOp::Method(..) => (),
                 }
             },
             (
@@ -436,6 +449,11 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing {
             (state @ Some((State::ExplicitDeref { .. }, _)), RefOp::Deref) => {
                 self.state = state;
             },
+            (Some((State::ExplicitDerefField { name }, data)), RefOp::Deref)
+                if !ty_contains_field(typeck.expr_ty(sub_expr), name) =>
+            {
+                self.state = Some((State::ExplicitDerefField { name }, data));
+            },
 
             (Some((state, data)), _) => report(cx, expr, state, data),
         }
@@ -879,6 +897,14 @@ fn param_auto_deref_stability(ty: Ty<'_>) -> AutoDerefStability {
     }
 }
 
+fn ty_contains_field(ty: Ty<'_>, name: Symbol) -> bool {
+    if let ty::Adt(adt, _) = *ty.kind() {
+        adt.is_struct() && adt.non_enum_variant().fields.iter().any(|f| f.name == name)
+    } else {
+        false
+    }
+}
+
 #[expect(clippy::needless_pass_by_value)]
 fn report<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, state: State, data: StateData) {
     match state {
@@ -968,6 +994,20 @@ fn report<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, state: State, data
                 },
             );
         },
+        State::ExplicitDerefField { .. } => {
+            span_lint_hir_and_then(
+                cx,
+                EXPLICIT_AUTO_DEREF,
+                data.hir_id,
+                data.span,
+                "deref which would be done by auto-deref",
+                |diag| {
+                    let mut app = Applicability::MachineApplicable;
+                    let snip = snippet_with_context(cx, expr.span, data.span.ctxt(), "..", &mut app).0;
+                    diag.span_suggestion(data.span, "try this", snip.into_owned(), app);
+                },
+            );
+        },
         State::Borrow | State::Reborrow { .. } => (),
     }
 }
diff --git a/clippy_lints/src/matches/redundant_pattern_match.rs b/clippy_lints/src/matches/redundant_pattern_match.rs
index 0ea3f3b673b..65cecd333f1 100644
--- a/clippy_lints/src/matches/redundant_pattern_match.rs
+++ b/clippy_lints/src/matches/redundant_pattern_match.rs
@@ -362,9 +362,9 @@ fn find_good_method_for_match<'a>(
         .qpath_res(path_right, arms[1].pat.hir_id)
         .opt_def_id()?;
     let body_node_pair = if match_def_path(cx, left_id, expected_left) && match_def_path(cx, right_id, expected_right) {
-        (&(*arms[0].body).kind, &(*arms[1].body).kind)
+        (&arms[0].body.kind, &arms[1].body.kind)
     } else if match_def_path(cx, right_id, expected_left) && match_def_path(cx, right_id, expected_right) {
-        (&(*arms[1].body).kind, &(*arms[0].body).kind)
+        (&arms[1].body.kind, &arms[0].body.kind)
     } else {
         return None;
     };
diff --git a/tests/ui/explicit_auto_deref.fixed b/tests/ui/explicit_auto_deref.fixed
index 0d3f8b61afc..91d0379b70e 100644
--- a/tests/ui/explicit_auto_deref.fixed
+++ b/tests/ui/explicit_auto_deref.fixed
@@ -164,4 +164,24 @@ fn main() {
     let ref_s = &s;
     let _: &String = &*ref_s; // Don't lint reborrow.
     f_string(&*ref_s); // Don't lint reborrow.
+
+    struct S5 {
+        foo: u32,
+    }
+    let b = Box::new(Box::new(S5 { foo: 5 }));
+    let _ = b.foo;
+    let _ = b.foo;
+    let _ = b.foo;
+
+    struct S6 {
+        foo: S5,
+    }
+    impl core::ops::Deref for S6 {
+        type Target = S5;
+        fn deref(&self) -> &Self::Target {
+            &self.foo
+        }
+    }
+    let s6 = S6 { foo: S5 { foo: 5 } };
+    let _ = (*s6).foo; // Don't lint. `S6` also has a field named `foo`
 }
diff --git a/tests/ui/explicit_auto_deref.rs b/tests/ui/explicit_auto_deref.rs
index 31c268bcdec..e57553b2a99 100644
--- a/tests/ui/explicit_auto_deref.rs
+++ b/tests/ui/explicit_auto_deref.rs
@@ -164,4 +164,24 @@ fn main() {
     let ref_s = &s;
     let _: &String = &*ref_s; // Don't lint reborrow.
     f_string(&*ref_s); // Don't lint reborrow.
+
+    struct S5 {
+        foo: u32,
+    }
+    let b = Box::new(Box::new(S5 { foo: 5 }));
+    let _ = b.foo;
+    let _ = (*b).foo;
+    let _ = (**b).foo;
+
+    struct S6 {
+        foo: S5,
+    }
+    impl core::ops::Deref for S6 {
+        type Target = S5;
+        fn deref(&self) -> &Self::Target {
+            &self.foo
+        }
+    }
+    let s6 = S6 { foo: S5 { foo: 5 } };
+    let _ = (*s6).foo; // Don't lint. `S6` also has a field named `foo`
 }
diff --git a/tests/ui/explicit_auto_deref.stderr b/tests/ui/explicit_auto_deref.stderr
index b53b4b4a200..54f1a2cd886 100644
--- a/tests/ui/explicit_auto_deref.stderr
+++ b/tests/ui/explicit_auto_deref.stderr
@@ -156,5 +156,17 @@ error: deref which would be done by auto-deref
 LL |     let _ = E1::S2 { s: &*s };
    |                          ^^ help: try this: `s`
 
-error: aborting due to 26 previous errors
+error: deref which would be done by auto-deref
+  --> $DIR/explicit_auto_deref.rs:173:13
+   |
+LL |     let _ = (*b).foo;
+   |             ^^^^ help: try this: `b`
+
+error: deref which would be done by auto-deref
+  --> $DIR/explicit_auto_deref.rs:174:13
+   |
+LL |     let _ = (**b).foo;
+   |             ^^^^^ help: try this: `b`
+
+error: aborting due to 28 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 442a68c64b177480da34fd7ee5349987ffd7f3d7 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Fri, 28 Jan 2022 10:56:20 -0500
Subject: Only check parent node once in `dereference.rs`

---
 clippy_lints/src/dereference.rs | 115 ++++++++++++++--------------------------
 1 file changed, 40 insertions(+), 75 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index f1915f16339..12c796bd100 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -15,7 +15,7 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::adjustment::{Adjust, Adjustment, AutoBorrow, AutoBorrowMutability};
 use rustc_middle::ty::{self, Ty, TyCtxt, TypeFoldable, TypeckResults};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::{symbol::sym, Span, Symbol};
+use rustc_span::{symbol::sym, Span, Symbol, SyntaxContext};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -244,23 +244,22 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing {
 
         match (self.state.take(), kind) {
             (None, kind) => {
-                let parent = get_parent_node(cx.tcx, expr.hir_id);
                 let expr_ty = typeck.expr_ty(expr);
+                let (position, parent_ctxt) = get_expr_position(cx, expr);
                 match kind {
                     RefOp::Deref => {
-                        if let Some(Node::Expr(e)) = parent
-                            && let ExprKind::Field(_, name) = e.kind
-                            && !ty_contains_field(typeck.expr_ty(sub_expr), name.name)
+                        if let Position::FieldAccess(name) = position
+                            && !ty_contains_field(typeck.expr_ty(sub_expr), name)
                         {
                             self.state = Some((
-                                State::ExplicitDerefField { name: name.name },
+                                State::ExplicitDerefField { name },
                                 StateData { span: expr.span, hir_id: expr.hir_id },
                             ));
                         }
                     }
                     RefOp::Method(target_mut)
                         if !is_lint_allowed(cx, EXPLICIT_DEREF_METHODS, expr.hir_id)
-                            && is_linted_explicit_deref_position(parent, expr.hir_id, expr.span) =>
+                            && (position.lint_explicit_deref() || parent_ctxt != expr.span.ctxt()) =>
                     {
                         self.state = Some((
                             State::DerefMethod {
@@ -322,8 +321,7 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing {
                             "this expression creates a reference which is immediately dereferenced by the compiler";
                         let borrow_msg = "this expression borrows a value the compiler would automatically borrow";
 
-                        let (required_refs, required_precedence, msg) = if is_auto_borrow_position(parent, expr.hir_id)
-                        {
+                        let (required_refs, required_precedence, msg) = if position.can_auto_borrow() {
                             (1, PREC_POSTFIX, if deref_count == 1 { borrow_msg } else { deref_msg })
                         } else if let Some(&Adjust::Borrow(AutoBorrow::Ref(_, mutability))) =
                             next_adjust.map(|a| &a.kind)
@@ -573,60 +571,41 @@ fn deref_method_same_type<'tcx>(result_ty: Ty<'tcx>, arg_ty: Ty<'tcx>) -> bool {
     }
 }
 
-// Checks whether the parent node is a suitable context for switching from a deref method to the
-// deref operator.
-fn is_linted_explicit_deref_position(parent: Option<Node<'_>>, child_id: HirId, child_span: Span) -> bool {
-    let parent = match parent {
-        Some(Node::Expr(e)) if e.span.ctxt() == child_span.ctxt() => e,
-        _ => return true,
-    };
-    match parent.kind {
-        // Leave deref calls in the middle of a method chain.
-        // e.g. x.deref().foo()
-        ExprKind::MethodCall(_, [self_arg, ..], _) if self_arg.hir_id == child_id => false,
-
-        // Leave deref calls resulting in a called function
-        // e.g. (x.deref())()
-        ExprKind::Call(func_expr, _) if func_expr.hir_id == child_id => false,
+#[derive(Clone, Copy)]
+enum Position {
+    MethodReceiver,
+    FieldAccess(Symbol),
+    Callee,
+    Postfix,
+    Deref,
+    Other,
+}
+impl Position {
+    fn can_auto_borrow(self) -> bool {
+        matches!(self, Self::MethodReceiver | Self::FieldAccess(_) | Self::Callee)
+    }
 
-        // Makes an ugly suggestion
-        // e.g. *x.deref() => *&*x
-        ExprKind::Unary(UnOp::Deref, _)
-        // Postfix expressions would require parens
-        | ExprKind::Match(_, _, MatchSource::TryDesugar | MatchSource::AwaitDesugar)
-        | ExprKind::Field(..)
-        | ExprKind::Index(..)
-        | ExprKind::Err => false,
+    fn lint_explicit_deref(self) -> bool {
+        matches!(self, Self::Other)
+    }
+}
 
-        ExprKind::Box(..)
-        | ExprKind::ConstBlock(..)
-        | ExprKind::Array(_)
-        | ExprKind::Call(..)
-        | ExprKind::MethodCall(..)
-        | ExprKind::Tup(..)
-        | ExprKind::Binary(..)
-        | ExprKind::Unary(..)
-        | ExprKind::Lit(..)
-        | ExprKind::Cast(..)
-        | ExprKind::Type(..)
-        | ExprKind::DropTemps(..)
-        | ExprKind::If(..)
-        | ExprKind::Loop(..)
-        | ExprKind::Match(..)
-        | ExprKind::Let(..)
-        | ExprKind::Closure{..}
-        | ExprKind::Block(..)
-        | ExprKind::Assign(..)
-        | ExprKind::AssignOp(..)
-        | ExprKind::Path(..)
-        | ExprKind::AddrOf(..)
-        | ExprKind::Break(..)
-        | ExprKind::Continue(..)
-        | ExprKind::Ret(..)
-        | ExprKind::InlineAsm(..)
-        | ExprKind::Struct(..)
-        | ExprKind::Repeat(..)
-        | ExprKind::Yield(..) => true,
+/// Get which position an expression is in relative to it's parent.
+fn get_expr_position(cx: &LateContext<'_>, e: &Expr<'_>) -> (Position, SyntaxContext) {
+    if let Some(Node::Expr(parent)) = get_parent_node(cx.tcx, e.hir_id) {
+        let pos = match parent.kind {
+            ExprKind::MethodCall(_, [self_arg, ..], _) if self_arg.hir_id == e.hir_id => Position::MethodReceiver,
+            ExprKind::Field(_, name) => Position::FieldAccess(name.name),
+            ExprKind::Call(f, _) if f.hir_id == e.hir_id => Position::Callee,
+            ExprKind::Unary(UnOp::Deref, _) => Position::Deref,
+            ExprKind::Match(_, _, MatchSource::TryDesugar | MatchSource::AwaitDesugar) | ExprKind::Index(..) => {
+                Position::Postfix
+            },
+            _ => Position::Other,
+        };
+        (pos, parent.span.ctxt())
+    } else {
+        (Position::Other, SyntaxContext::root())
     }
 }
 
@@ -748,20 +727,6 @@ fn walk_parents<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> (AutoDerefSt
     (stability, adjustments)
 }
 
-/// Checks if the given expression is a position which can auto-borrow.
-fn is_auto_borrow_position(parent: Option<Node<'_>>, child_id: HirId) -> bool {
-    if let Some(Node::Expr(parent)) = parent {
-        match parent.kind {
-            // ExprKind::MethodCall(_, [self_arg, ..], _) => self_arg.hir_id == child_id,
-            ExprKind::Field(..) => true,
-            ExprKind::Call(f, _) => f.hir_id == child_id,
-            _ => false,
-        }
-    } else {
-        false
-    }
-}
-
 // Checks the stability of auto-deref when assigned to a binding with the given explicit type.
 //
 // e.g.
-- 
cgit 1.4.1-3-g733a5


From 65bc6cb8bf1f1005ae02a0044f0f3027c702a807 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Fri, 28 Jan 2022 14:54:28 -0500
Subject: Lint `explicit_auto_deref` without a leading borrow

---
 clippy_lints/src/dereference.rs            | 29 +++++++++++++++++++++++++----
 tests/ui/explicit_auto_deref.fixed         | 14 ++++++++++++++
 tests/ui/explicit_auto_deref.rs            | 14 ++++++++++++++
 tests/ui/explicit_auto_deref.stderr        | 14 +++++++++++++-
 tests/ui/needless_borrow_pat.rs            |  2 +-
 tests/ui/ref_binding_to_reference.rs       |  2 +-
 tests/ui/search_is_some_fixable_none.fixed |  2 +-
 tests/ui/search_is_some_fixable_none.rs    |  2 +-
 tests/ui/search_is_some_fixable_some.fixed |  2 +-
 tests/ui/search_is_some_fixable_some.rs    |  2 +-
 10 files changed, 72 insertions(+), 11 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index 12c796bd100..32d1e26b74c 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -246,6 +246,8 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing {
             (None, kind) => {
                 let expr_ty = typeck.expr_ty(expr);
                 let (position, parent_ctxt) = get_expr_position(cx, expr);
+                let (stability, adjustments) = walk_parents(cx, expr);
+
                 match kind {
                     RefOp::Deref => {
                         if let Position::FieldAccess(name) = position
@@ -255,6 +257,11 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing {
                                 State::ExplicitDerefField { name },
                                 StateData { span: expr.span, hir_id: expr.hir_id },
                             ));
+                        } else if stability.is_deref_stable() {
+                            self.state = Some((
+                                State::ExplicitDeref { deref_span: expr.span, deref_hir_id: expr.hir_id },
+                                StateData { span: expr.span, hir_id: expr.hir_id },
+                            ));
                         }
                     }
                     RefOp::Method(target_mut)
@@ -278,7 +285,6 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing {
                         ));
                     },
                     RefOp::AddrOf => {
-                        let (stability, adjustments) = walk_parents(cx, expr);
                         // Find the number of times the borrow is auto-derefed.
                         let mut iter = adjustments.iter();
                         let mut deref_count = 0usize;
@@ -632,6 +638,7 @@ impl AutoDerefStability {
 /// Walks up the parent expressions attempting to determine both how stable the auto-deref result
 /// is, and which adjustments will be applied to it. Note this will not consider auto-borrow
 /// locations as those follow different rules.
+#[allow(clippy::too_many_lines)]
 fn walk_parents<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> (AutoDerefStability, &'tcx [Adjustment<'tcx>]) {
     let mut adjustments = [].as_slice();
     let stability = walk_to_expr_usage(cx, e, &mut |node, child_id| {
@@ -643,16 +650,26 @@ fn walk_parents<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> (AutoDerefSt
             Node::Local(Local { ty: Some(ty), .. }) => Some(binding_ty_auto_deref_stability(ty)),
             Node::Item(&Item {
                 kind: ItemKind::Static(..) | ItemKind::Const(..),
+                def_id,
                 ..
             })
             | Node::TraitItem(&TraitItem {
                 kind: TraitItemKind::Const(..),
+                def_id,
                 ..
             })
             | Node::ImplItem(&ImplItem {
                 kind: ImplItemKind::Const(..),
+                def_id,
                 ..
-            }) => Some(AutoDerefStability::Deref),
+            }) => {
+                let ty = cx.tcx.type_of(def_id);
+                Some(if ty.is_ref() {
+                    AutoDerefStability::None
+                } else {
+                    AutoDerefStability::Deref
+                })
+            },
 
             Node::Item(&Item {
                 kind: ItemKind::Fn(..),
@@ -670,7 +687,9 @@ fn walk_parents<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> (AutoDerefSt
                 ..
             }) => {
                 let output = cx.tcx.fn_sig(def_id.to_def_id()).skip_binder().output();
-                Some(if output.has_placeholders() || output.has_opaque_types() {
+                Some(if !output.is_ref() {
+                    AutoDerefStability::None
+                } else if output.has_placeholders() || output.has_opaque_types() {
                     AutoDerefStability::Reborrow
                 } else {
                     AutoDerefStability::Deref
@@ -684,7 +703,9 @@ fn walk_parents<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> (AutoDerefSt
                         .fn_sig(cx.tcx.hir().body_owner_def_id(cx.enclosing_body.unwrap()))
                         .skip_binder()
                         .output();
-                    Some(if output.has_placeholders() || output.has_opaque_types() {
+                    Some(if !output.is_ref() {
+                        AutoDerefStability::None
+                    } else if output.has_placeholders() || output.has_opaque_types() {
                         AutoDerefStability::Reborrow
                     } else {
                         AutoDerefStability::Deref
diff --git a/tests/ui/explicit_auto_deref.fixed b/tests/ui/explicit_auto_deref.fixed
index 91d0379b70e..d20a58e53bd 100644
--- a/tests/ui/explicit_auto_deref.fixed
+++ b/tests/ui/explicit_auto_deref.fixed
@@ -6,6 +6,7 @@
     unused_braces,
     clippy::borrowed_box,
     clippy::needless_borrow,
+    clippy::needless_return,
     clippy::ptr_arg,
     clippy::redundant_field_names,
     clippy::too_many_arguments,
@@ -184,4 +185,17 @@ fn main() {
     }
     let s6 = S6 { foo: S5 { foo: 5 } };
     let _ = (*s6).foo; // Don't lint. `S6` also has a field named `foo`
+
+    let ref_str = &"foo";
+    let _ = f_str(ref_str);
+    let ref_ref_str = &ref_str;
+    let _ = f_str(ref_ref_str);
+
+    fn _f5(x: &u32) -> u32 {
+        if true {
+            *x
+        } else {
+            return *x;
+        }
+    }
 }
diff --git a/tests/ui/explicit_auto_deref.rs b/tests/ui/explicit_auto_deref.rs
index e57553b2a99..f49bc8bb9f0 100644
--- a/tests/ui/explicit_auto_deref.rs
+++ b/tests/ui/explicit_auto_deref.rs
@@ -6,6 +6,7 @@
     unused_braces,
     clippy::borrowed_box,
     clippy::needless_borrow,
+    clippy::needless_return,
     clippy::ptr_arg,
     clippy::redundant_field_names,
     clippy::too_many_arguments,
@@ -184,4 +185,17 @@ fn main() {
     }
     let s6 = S6 { foo: S5 { foo: 5 } };
     let _ = (*s6).foo; // Don't lint. `S6` also has a field named `foo`
+
+    let ref_str = &"foo";
+    let _ = f_str(*ref_str);
+    let ref_ref_str = &ref_str;
+    let _ = f_str(**ref_ref_str);
+
+    fn _f5(x: &u32) -> u32 {
+        if true {
+            *x
+        } else {
+            return *x;
+        }
+    }
 }
diff --git a/tests/ui/explicit_auto_deref.stderr b/tests/ui/explicit_auto_deref.stderr
index 54f1a2cd886..de8c40ce5be 100644
--- a/tests/ui/explicit_auto_deref.stderr
+++ b/tests/ui/explicit_auto_deref.stderr
@@ -168,5 +168,17 @@ error: deref which would be done by auto-deref
 LL |     let _ = (**b).foo;
    |             ^^^^^ help: try this: `b`
 
-error: aborting due to 28 previous errors
+error: deref which would be done by auto-deref
+  --> $DIR/explicit_auto_deref.rs:189:19
+   |
+LL |     let _ = f_str(*ref_str);
+   |                   ^^^^^^^^ help: try this: `ref_str`
+
+error: deref which would be done by auto-deref
+  --> $DIR/explicit_auto_deref.rs:191:19
+   |
+LL |     let _ = f_str(**ref_ref_str);
+   |                   ^^^^^^^^^^^^^ help: try this: `ref_ref_str`
+
+error: aborting due to 30 previous errors
 
diff --git a/tests/ui/needless_borrow_pat.rs b/tests/ui/needless_borrow_pat.rs
index 04b6283da3c..222e8e61799 100644
--- a/tests/ui/needless_borrow_pat.rs
+++ b/tests/ui/needless_borrow_pat.rs
@@ -1,7 +1,7 @@
 // FIXME: run-rustfix waiting on multi-span suggestions
 
 #![warn(clippy::needless_borrow)]
-#![allow(clippy::needless_borrowed_reference)]
+#![allow(clippy::needless_borrowed_reference, clippy::explicit_auto_deref)]
 
 fn f1(_: &str) {}
 macro_rules! m1 {
diff --git a/tests/ui/ref_binding_to_reference.rs b/tests/ui/ref_binding_to_reference.rs
index 570ef406e4a..c8d0e56b197 100644
--- a/tests/ui/ref_binding_to_reference.rs
+++ b/tests/ui/ref_binding_to_reference.rs
@@ -2,7 +2,7 @@
 
 #![feature(lint_reasons)]
 #![warn(clippy::ref_binding_to_reference)]
-#![allow(clippy::needless_borrowed_reference)]
+#![allow(clippy::needless_borrowed_reference, clippy::explicit_auto_deref)]
 
 fn f1(_: &str) {}
 macro_rules! m2 {
diff --git a/tests/ui/search_is_some_fixable_none.fixed b/tests/ui/search_is_some_fixable_none.fixed
index 6831fb2cf59..5190c5304c7 100644
--- a/tests/ui/search_is_some_fixable_none.fixed
+++ b/tests/ui/search_is_some_fixable_none.fixed
@@ -1,5 +1,5 @@
 // run-rustfix
-#![allow(dead_code)]
+#![allow(dead_code, clippy::explicit_auto_deref)]
 #![warn(clippy::search_is_some)]
 
 fn main() {
diff --git a/tests/ui/search_is_some_fixable_none.rs b/tests/ui/search_is_some_fixable_none.rs
index 767518ab0c0..310d87333a9 100644
--- a/tests/ui/search_is_some_fixable_none.rs
+++ b/tests/ui/search_is_some_fixable_none.rs
@@ -1,5 +1,5 @@
 // run-rustfix
-#![allow(dead_code)]
+#![allow(dead_code, clippy::explicit_auto_deref)]
 #![warn(clippy::search_is_some)]
 
 fn main() {
diff --git a/tests/ui/search_is_some_fixable_some.fixed b/tests/ui/search_is_some_fixable_some.fixed
index 7c940a2b069..5a2aee465d1 100644
--- a/tests/ui/search_is_some_fixable_some.fixed
+++ b/tests/ui/search_is_some_fixable_some.fixed
@@ -1,5 +1,5 @@
 // run-rustfix
-#![allow(dead_code)]
+#![allow(dead_code, clippy::explicit_auto_deref)]
 #![warn(clippy::search_is_some)]
 
 fn main() {
diff --git a/tests/ui/search_is_some_fixable_some.rs b/tests/ui/search_is_some_fixable_some.rs
index 77fd52e4ce7..0e98ae18a21 100644
--- a/tests/ui/search_is_some_fixable_some.rs
+++ b/tests/ui/search_is_some_fixable_some.rs
@@ -1,5 +1,5 @@
 // run-rustfix
-#![allow(dead_code)]
+#![allow(dead_code, clippy::explicit_auto_deref)]
 #![warn(clippy::search_is_some)]
 
 fn main() {
-- 
cgit 1.4.1-3-g733a5


From 0204b9535731cbaba1689b6d6ef44a93aef2dae3 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sat, 29 Jan 2022 09:36:46 -0500
Subject: Lint `explicit_auto_deref` immediately after `needless_borrow`

---
 clippy_lints/src/dereference.rs     | 88 +++++++++++++++++++++++--------------
 tests/ui/explicit_auto_deref.fixed  |  3 ++
 tests/ui/explicit_auto_deref.rs     |  3 ++
 tests/ui/explicit_auto_deref.stderr | 14 +++++-
 4 files changed, 73 insertions(+), 35 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index 32d1e26b74c..cac99c21e9e 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -163,6 +163,14 @@ struct StateData {
     hir_id: HirId,
 }
 
+struct DerefedBorrow {
+    count: usize,
+    required_precedence: i8,
+    msg: &'static str,
+    stability: AutoDerefStability,
+    position: Position,
+}
+
 enum State {
     // Any number of deref method calls.
     DerefMethod {
@@ -172,11 +180,7 @@ enum State {
         /// The required mutability
         target_mut: Mutability,
     },
-    DerefedBorrow {
-        count: usize,
-        required_precedence: i8,
-        msg: &'static str,
-    },
+    DerefedBorrow(DerefedBorrow),
     ExplicitDeref {
         deref_span: Span,
         deref_hir_id: HirId,
@@ -344,17 +348,16 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing {
 
                         if deref_count >= required_refs {
                             self.state = Some((
-                                State::DerefedBorrow {
+                                State::DerefedBorrow(DerefedBorrow {
                                     // One of the required refs is for the current borrow expression, the remaining ones
                                     // can't be removed without breaking the code. See earlier comment.
                                     count: deref_count - required_refs,
                                     required_precedence,
                                     msg,
-                                },
-                                StateData {
-                                    span: expr.span,
-                                    hir_id: expr.hir_id,
-                                },
+                                    stability,
+                                    position,
+                                }),
+                                StateData { span: expr.span, hir_id: expr.hir_id },
                             ));
                         } else if stability.is_deref_stable() {
                             self.state = Some((
@@ -393,26 +396,47 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing {
                     data,
                 ));
             },
-            (
-                Some((
-                    State::DerefedBorrow {
-                        count,
-                        required_precedence,
-                        msg,
-                    },
-                    data,
-                )),
-                RefOp::AddrOf,
-            ) if count != 0 => {
+            (Some((State::DerefedBorrow(state), data)), RefOp::AddrOf) if state.count != 0 => {
                 self.state = Some((
-                    State::DerefedBorrow {
-                        count: count - 1,
-                        required_precedence,
-                        msg,
-                    },
+                    State::DerefedBorrow(DerefedBorrow {
+                        count: state.count - 1,
+                        ..state
+                    }),
                     data,
                 ));
             },
+            (Some((State::DerefedBorrow(state), data)), RefOp::AddrOf) => {
+                let stability = state.stability;
+                report(cx, expr, State::DerefedBorrow(state), data);
+                if stability.is_deref_stable() {
+                    self.state = Some((
+                        State::Borrow,
+                        StateData {
+                            span: expr.span,
+                            hir_id: expr.hir_id,
+                        },
+                    ));
+                }
+            },
+            (Some((State::DerefedBorrow(state), data)), RefOp::Deref) => {
+                let stability = state.stability;
+                let position = state.position;
+                report(cx, expr, State::DerefedBorrow(state), data);
+                if let Position::FieldAccess(name) = position
+                    && !ty_contains_field(typeck.expr_ty(sub_expr), name)
+                {
+                    self.state = Some((
+                        State::ExplicitDerefField { name },
+                        StateData { span: expr.span, hir_id: expr.hir_id },
+                    ));
+                } else if stability.is_deref_stable() {
+                    self.state = Some((
+                        State::ExplicitDeref { deref_span: expr.span, deref_hir_id: expr.hir_id },
+                        StateData { span: expr.span, hir_id: expr.hir_id },
+                    ));
+                }
+            },
+
             (Some((State::Borrow, data)), RefOp::Deref) => {
                 if typeck.expr_ty(sub_expr).is_ref() {
                     self.state = Some((
@@ -942,15 +966,11 @@ fn report<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, state: State, data
                 app,
             );
         },
-        State::DerefedBorrow {
-            required_precedence,
-            msg,
-            ..
-        } => {
+        State::DerefedBorrow(state) => {
             let mut app = Applicability::MachineApplicable;
             let snip = snippet_with_context(cx, expr.span, data.span.ctxt(), "..", &mut app).0;
-            span_lint_hir_and_then(cx, NEEDLESS_BORROW, data.hir_id, data.span, msg, |diag| {
-                let sugg = if required_precedence > expr.precedence().order() && !has_enclosing_paren(&snip) {
+            span_lint_hir_and_then(cx, NEEDLESS_BORROW, data.hir_id, data.span, state.msg, |diag| {
+                let sugg = if state.required_precedence > expr.precedence().order() && !has_enclosing_paren(&snip) {
                     format!("({})", snip)
                 } else {
                     snip.into()
diff --git a/tests/ui/explicit_auto_deref.fixed b/tests/ui/explicit_auto_deref.fixed
index d20a58e53bd..f534714bc65 100644
--- a/tests/ui/explicit_auto_deref.fixed
+++ b/tests/ui/explicit_auto_deref.fixed
@@ -198,4 +198,7 @@ fn main() {
             return *x;
         }
     }
+
+    f_str(&&ref_str); // `needless_borrow` will suggest removing both references
+    f_str(&ref_str); // `needless_borrow` will suggest removing only one reference
 }
diff --git a/tests/ui/explicit_auto_deref.rs b/tests/ui/explicit_auto_deref.rs
index f49bc8bb9f0..4781962882b 100644
--- a/tests/ui/explicit_auto_deref.rs
+++ b/tests/ui/explicit_auto_deref.rs
@@ -198,4 +198,7 @@ fn main() {
             return *x;
         }
     }
+
+    f_str(&&*ref_str); // `needless_borrow` will suggest removing both references
+    f_str(&&**ref_str); // `needless_borrow` will suggest removing only one reference
 }
diff --git a/tests/ui/explicit_auto_deref.stderr b/tests/ui/explicit_auto_deref.stderr
index de8c40ce5be..26357ffd96a 100644
--- a/tests/ui/explicit_auto_deref.stderr
+++ b/tests/ui/explicit_auto_deref.stderr
@@ -180,5 +180,17 @@ error: deref which would be done by auto-deref
 LL |     let _ = f_str(**ref_ref_str);
    |                   ^^^^^^^^^^^^^ help: try this: `ref_ref_str`
 
-error: aborting due to 30 previous errors
+error: deref which would be done by auto-deref
+  --> $DIR/explicit_auto_deref.rs:201:13
+   |
+LL |     f_str(&&*ref_str); // `needless_borrow` will suggest removing both references
+   |             ^^^^^^^^ help: try this: `ref_str`
+
+error: deref which would be done by auto-deref
+  --> $DIR/explicit_auto_deref.rs:202:12
+   |
+LL |     f_str(&&**ref_str); // `needless_borrow` will suggest removing only one reference
+   |            ^^^^^^^^^^ help: try this: `ref_str`
+
+error: aborting due to 32 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 0b4ba734cbd6758948cb18210437b4768e139fa9 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sat, 29 Jan 2022 18:06:14 -0500
Subject: Refactor `dereference.rs`

Merge `Position` and `AutoDerefStability`
---
 clippy_lints/src/dereference.rs     | 172 +++++++++++++++++-------------------
 tests/ui/explicit_auto_deref.fixed  |   3 +-
 tests/ui/explicit_auto_deref.rs     |   3 +-
 tests/ui/explicit_auto_deref.stderr |  64 +++++++-------
 4 files changed, 119 insertions(+), 123 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index cac99c21e9e..3821beaea53 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -2,7 +2,7 @@ use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_hir_and_then};
 use clippy_utils::source::{snippet_with_applicability, snippet_with_context};
 use clippy_utils::sugg::has_enclosing_paren;
 use clippy_utils::ty::{expr_sig, peel_mid_ty_refs, variant_of_res};
-use clippy_utils::{get_parent_expr, get_parent_node, is_lint_allowed, path_to_local, walk_to_expr_usage};
+use clippy_utils::{get_parent_expr, is_lint_allowed, path_to_local, walk_to_expr_usage};
 use rustc_ast::util::parser::{PREC_POSTFIX, PREC_PREFIX};
 use rustc_data_structures::fx::FxIndexMap;
 use rustc_errors::Applicability;
@@ -15,7 +15,7 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::adjustment::{Adjust, Adjustment, AutoBorrow, AutoBorrowMutability};
 use rustc_middle::ty::{self, Ty, TyCtxt, TypeFoldable, TypeckResults};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::{symbol::sym, Span, Symbol, SyntaxContext};
+use rustc_span::{symbol::sym, Span, Symbol};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -167,7 +167,6 @@ struct DerefedBorrow {
     count: usize,
     required_precedence: i8,
     msg: &'static str,
-    stability: AutoDerefStability,
     position: Position,
 }
 
@@ -249,8 +248,7 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing {
         match (self.state.take(), kind) {
             (None, kind) => {
                 let expr_ty = typeck.expr_ty(expr);
-                let (position, parent_ctxt) = get_expr_position(cx, expr);
-                let (stability, adjustments) = walk_parents(cx, expr);
+                let (position, adjustments) = walk_parents(cx, expr);
 
                 match kind {
                     RefOp::Deref => {
@@ -261,7 +259,7 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing {
                                 State::ExplicitDerefField { name },
                                 StateData { span: expr.span, hir_id: expr.hir_id },
                             ));
-                        } else if stability.is_deref_stable() {
+                        } else if position.is_deref_stable() {
                             self.state = Some((
                                 State::ExplicitDeref { deref_span: expr.span, deref_hir_id: expr.hir_id },
                                 StateData { span: expr.span, hir_id: expr.hir_id },
@@ -270,7 +268,7 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing {
                     }
                     RefOp::Method(target_mut)
                         if !is_lint_allowed(cx, EXPLICIT_DEREF_METHODS, expr.hir_id)
-                            && (position.lint_explicit_deref() || parent_ctxt != expr.span.ctxt()) =>
+                            && position.lint_explicit_deref() =>
                     {
                         self.state = Some((
                             State::DerefMethod {
@@ -336,7 +334,7 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing {
                         } else if let Some(&Adjust::Borrow(AutoBorrow::Ref(_, mutability))) =
                             next_adjust.map(|a| &a.kind)
                         {
-                            if matches!(mutability, AutoBorrowMutability::Mut { .. }) && !stability.is_reborrow_stable()
+                            if matches!(mutability, AutoBorrowMutability::Mut { .. }) && !position.is_reborrow_stable()
                             {
                                 (3, 0, deref_msg)
                             } else {
@@ -354,12 +352,11 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing {
                                     count: deref_count - required_refs,
                                     required_precedence,
                                     msg,
-                                    stability,
                                     position,
                                 }),
                                 StateData { span: expr.span, hir_id: expr.hir_id },
                             ));
-                        } else if stability.is_deref_stable() {
+                        } else if position.is_deref_stable() {
                             self.state = Some((
                                 State::Borrow,
                                 StateData {
@@ -406,9 +403,9 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing {
                 ));
             },
             (Some((State::DerefedBorrow(state), data)), RefOp::AddrOf) => {
-                let stability = state.stability;
+                let position = state.position;
                 report(cx, expr, State::DerefedBorrow(state), data);
-                if stability.is_deref_stable() {
+                if position.is_deref_stable() {
                     self.state = Some((
                         State::Borrow,
                         StateData {
@@ -419,7 +416,6 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing {
                 }
             },
             (Some((State::DerefedBorrow(state), data)), RefOp::Deref) => {
-                let stability = state.stability;
                 let position = state.position;
                 report(cx, expr, State::DerefedBorrow(state), data);
                 if let Position::FieldAccess(name) = position
@@ -429,7 +425,7 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing {
                         State::ExplicitDerefField { name },
                         StateData { span: expr.span, hir_id: expr.hir_id },
                     ));
-                } else if stability.is_deref_stable() {
+                } else if position.is_deref_stable() {
                     self.state = Some((
                         State::ExplicitDeref { deref_span: expr.span, deref_hir_id: expr.hir_id },
                         StateData { span: expr.span, hir_id: expr.hir_id },
@@ -601,61 +597,35 @@ fn deref_method_same_type<'tcx>(result_ty: Ty<'tcx>, arg_ty: Ty<'tcx>) -> bool {
     }
 }
 
+/// The position of an expression relative to it's parent.
 #[derive(Clone, Copy)]
 enum Position {
     MethodReceiver,
-    FieldAccess(Symbol),
     Callee,
+    FieldAccess(Symbol),
     Postfix,
     Deref,
+    /// Any other location which will trigger auto-deref to a specific time.
+    DerefStable,
+    /// Any other location which will trigger auto-reborrowing.
+    ReborrowStable,
     Other,
 }
 impl Position {
-    fn can_auto_borrow(self) -> bool {
-        matches!(self, Self::MethodReceiver | Self::FieldAccess(_) | Self::Callee)
-    }
-
-    fn lint_explicit_deref(self) -> bool {
-        matches!(self, Self::Other)
+    fn is_deref_stable(self) -> bool {
+        matches!(self, Self::DerefStable)
     }
-}
 
-/// Get which position an expression is in relative to it's parent.
-fn get_expr_position(cx: &LateContext<'_>, e: &Expr<'_>) -> (Position, SyntaxContext) {
-    if let Some(Node::Expr(parent)) = get_parent_node(cx.tcx, e.hir_id) {
-        let pos = match parent.kind {
-            ExprKind::MethodCall(_, [self_arg, ..], _) if self_arg.hir_id == e.hir_id => Position::MethodReceiver,
-            ExprKind::Field(_, name) => Position::FieldAccess(name.name),
-            ExprKind::Call(f, _) if f.hir_id == e.hir_id => Position::Callee,
-            ExprKind::Unary(UnOp::Deref, _) => Position::Deref,
-            ExprKind::Match(_, _, MatchSource::TryDesugar | MatchSource::AwaitDesugar) | ExprKind::Index(..) => {
-                Position::Postfix
-            },
-            _ => Position::Other,
-        };
-        (pos, parent.span.ctxt())
-    } else {
-        (Position::Other, SyntaxContext::root())
+    fn is_reborrow_stable(self) -> bool {
+        matches!(self, Self::DerefStable | Self::ReborrowStable)
     }
-}
 
-/// How stable the result of auto-deref is.
-#[derive(Clone, Copy)]
-enum AutoDerefStability {
-    /// Auto-deref will always choose the same type.
-    Deref,
-    /// Auto-deref will always reborrow a reference.
-    Reborrow,
-    /// Auto-deref will not occur, or it may select a different type.
-    None,
-}
-impl AutoDerefStability {
-    fn is_deref_stable(self) -> bool {
-        matches!(self, Self::Deref)
+    fn can_auto_borrow(self) -> bool {
+        matches!(self, Self::MethodReceiver | Self::FieldAccess(_) | Self::Callee)
     }
 
-    fn is_reborrow_stable(self) -> bool {
-        matches!(self, Self::Deref | Self::Reborrow)
+    fn lint_explicit_deref(self) -> bool {
+        matches!(self, Self::Other | Self::DerefStable | Self::ReborrowStable)
     }
 }
 
@@ -663,64 +633,73 @@ impl AutoDerefStability {
 /// is, and which adjustments will be applied to it. Note this will not consider auto-borrow
 /// locations as those follow different rules.
 #[allow(clippy::too_many_lines)]
-fn walk_parents<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> (AutoDerefStability, &'tcx [Adjustment<'tcx>]) {
+fn walk_parents<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> (Position, &'tcx [Adjustment<'tcx>]) {
     let mut adjustments = [].as_slice();
-    let stability = walk_to_expr_usage(cx, e, &mut |node, child_id| {
+    let ctxt = e.span.ctxt();
+    let position = walk_to_expr_usage(cx, e, &mut |parent, child_id| {
         // LocalTableInContext returns the wrong lifetime, so go use `expr_adjustments` instead.
         if adjustments.is_empty() && let Node::Expr(e) = cx.tcx.hir().get(child_id) {
             adjustments = cx.typeck_results().expr_adjustments(e);
         }
-        match node {
-            Node::Local(Local { ty: Some(ty), .. }) => Some(binding_ty_auto_deref_stability(ty)),
+        match parent {
+            Node::Local(Local { ty: Some(ty), span, .. }) if span.ctxt() == ctxt => {
+                Some(binding_ty_auto_deref_stability(ty))
+            },
             Node::Item(&Item {
                 kind: ItemKind::Static(..) | ItemKind::Const(..),
                 def_id,
+                span,
                 ..
             })
             | Node::TraitItem(&TraitItem {
                 kind: TraitItemKind::Const(..),
                 def_id,
+                span,
                 ..
             })
             | Node::ImplItem(&ImplItem {
                 kind: ImplItemKind::Const(..),
                 def_id,
+                span,
                 ..
-            }) => {
+            }) if span.ctxt() == ctxt => {
                 let ty = cx.tcx.type_of(def_id);
                 Some(if ty.is_ref() {
-                    AutoDerefStability::None
+                    Position::Other
                 } else {
-                    AutoDerefStability::Deref
+                    Position::DerefStable
                 })
             },
 
             Node::Item(&Item {
                 kind: ItemKind::Fn(..),
                 def_id,
+                span,
                 ..
             })
             | Node::TraitItem(&TraitItem {
                 kind: TraitItemKind::Fn(..),
                 def_id,
+                span,
                 ..
             })
             | Node::ImplItem(&ImplItem {
                 kind: ImplItemKind::Fn(..),
                 def_id,
+                span,
                 ..
-            }) => {
+            }) if span.ctxt() == ctxt => {
                 let output = cx.tcx.fn_sig(def_id.to_def_id()).skip_binder().output();
                 Some(if !output.is_ref() {
-                    AutoDerefStability::None
+                    Position::Other
                 } else if output.has_placeholders() || output.has_opaque_types() {
-                    AutoDerefStability::Reborrow
+                    Position::ReborrowStable
                 } else {
-                    AutoDerefStability::Deref
+                    Position::DerefStable
                 })
             },
 
-            Node::Expr(e) => match e.kind {
+            Node::Expr(parent) if parent.span.ctxt() == ctxt => match parent.kind {
                 ExprKind::Ret(_) => {
                     let output = cx
                         .tcx
@@ -728,13 +707,14 @@ fn walk_parents<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> (AutoDerefSt
                         .skip_binder()
                         .output();
                     Some(if !output.is_ref() {
-                        AutoDerefStability::None
+                        Position::Other
                     } else if output.has_placeholders() || output.has_opaque_types() {
-                        AutoDerefStability::Reborrow
+                        Position::ReborrowStable
                     } else {
-                        AutoDerefStability::Deref
+                        Position::DerefStable
                     })
                 },
+                ExprKind::Call(func, _) if func.hir_id == child_id => (child_id == e.hir_id).then(|| Position::Callee),
                 ExprKind::Call(func, args) => args
                     .iter()
                     .position(|arg| arg.hir_id == child_id)
@@ -746,16 +726,22 @@ fn walk_parents<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> (AutoDerefSt
                         Some(ty) => binding_ty_auto_deref_stability(ty),
                         None => param_auto_deref_stability(ty.skip_binder()),
                     }),
-                ExprKind::MethodCall(_, [_, args @ ..], _) => {
-                    let id = cx.typeck_results().type_dependent_def_id(e.hir_id).unwrap();
+                ExprKind::MethodCall(_, args, _) => {
+                    let id = cx.typeck_results().type_dependent_def_id(parent.hir_id).unwrap();
                     args.iter().position(|arg| arg.hir_id == child_id).map(|i| {
-                        let arg = cx.tcx.fn_sig(id).skip_binder().inputs()[i + 1];
-                        param_auto_deref_stability(arg)
+                        if i == 0 {
+                            if e.hir_id == child_id {
+                                Position::MethodReceiver
+                            } else {
+                                Position::ReborrowStable
+                            }
+                        } else {
+                            param_auto_deref_stability(cx.tcx.fn_sig(id).skip_binder().inputs()[i])
+                        }
                     })
                 },
-                ExprKind::MethodCall(..) => Some(AutoDerefStability::Reborrow),
                 ExprKind::Struct(path, fields, _) => {
-                    let variant = variant_of_res(cx, cx.qpath_res(path, e.hir_id));
+                    let variant = variant_of_res(cx, cx.qpath_res(path, parent.hir_id));
                     fields
                         .iter()
                         .find(|f| f.expr.hir_id == child_id)
@@ -763,13 +749,21 @@ fn walk_parents<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> (AutoDerefSt
                         .and_then(|(field, variant)| variant.fields.iter().find(|f| f.name == field.ident.name))
                         .map(|field| param_auto_deref_stability(cx.tcx.type_of(field.did)))
                 },
+                ExprKind::Field(child, name) if child.hir_id == e.hir_id => Some(Position::FieldAccess(name.name)),
+                ExprKind::Unary(UnOp::Deref, child) if child.hir_id == e.hir_id => Some(Position::Deref),
+                ExprKind::Match(child, _, MatchSource::TryDesugar | MatchSource::AwaitDesugar)
+                | ExprKind::Index(child, _)
+                    if child.hir_id == e.hir_id =>
+                {
+                    Some(Position::Postfix)
+                },
                 _ => None,
             },
             _ => None,
         }
     })
-    .unwrap_or(AutoDerefStability::None);
-    (stability, adjustments)
+    .unwrap_or(Position::Other);
+    (position, adjustments)
 }
 
 // Checks the stability of auto-deref when assigned to a binding with the given explicit type.
@@ -781,9 +775,9 @@ fn walk_parents<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> (AutoDerefSt
 //
 // Here `y1` and `y2` would resolve to different types, so the type `&Box<_>` is not stable when
 // switching to auto-dereferencing.
-fn binding_ty_auto_deref_stability(ty: &hir::Ty<'_>) -> AutoDerefStability {
+fn binding_ty_auto_deref_stability(ty: &hir::Ty<'_>) -> Position {
     let TyKind::Rptr(_, ty) = &ty.kind else {
-        return AutoDerefStability::None;
+        return Position::Other;
     };
     let mut ty = ty;
 
@@ -809,9 +803,9 @@ fn binding_ty_auto_deref_stability(ty: &hir::Ty<'_>) -> AutoDerefStability {
                         _ => false,
                     })
                 {
-                    AutoDerefStability::Reborrow
+                    Position::ReborrowStable
                 } else {
-                    AutoDerefStability::Deref
+                    Position::DerefStable
                 }
             },
             TyKind::Slice(_)
@@ -821,8 +815,8 @@ fn binding_ty_auto_deref_stability(ty: &hir::Ty<'_>) -> AutoDerefStability {
             | TyKind::Tup(_)
             | TyKind::Ptr(_)
             | TyKind::TraitObject(..)
-            | TyKind::Path(_) => AutoDerefStability::Deref,
-            TyKind::OpaqueDef(..) | TyKind::Infer | TyKind::Typeof(..) | TyKind::Err => AutoDerefStability::Reborrow,
+            | TyKind::Path(_) => Position::DerefStable,
+            TyKind::OpaqueDef(..) | TyKind::Infer | TyKind::Typeof(..) | TyKind::Err => Position::ReborrowStable,
         };
     }
 }
@@ -865,9 +859,9 @@ fn ty_contains_infer(ty: &hir::Ty<'_>) -> bool {
 }
 
 // Checks whether a type is stable when switching to auto dereferencing,
-fn param_auto_deref_stability(ty: Ty<'_>) -> AutoDerefStability {
+fn param_auto_deref_stability(ty: Ty<'_>) -> Position {
     let ty::Ref(_, mut ty, _) = *ty.kind() else {
-        return AutoDerefStability::None;
+        return Position::Other;
     };
 
     loop {
@@ -893,16 +887,16 @@ fn param_auto_deref_stability(ty: Ty<'_>) -> AutoDerefStability {
             | ty::GeneratorWitness(..)
             | ty::Never
             | ty::Tuple(_)
-            | ty::Projection(_) => AutoDerefStability::Deref,
+            | ty::Projection(_) => Position::DerefStable,
             ty::Infer(_)
             | ty::Error(_)
             | ty::Param(_)
             | ty::Bound(..)
             | ty::Opaque(..)
             | ty::Placeholder(_)
-            | ty::Dynamic(..) => AutoDerefStability::Reborrow,
-            ty::Adt(..) if ty.has_placeholders() || ty.has_param_types_or_consts() => AutoDerefStability::Reborrow,
-            ty::Adt(..) => AutoDerefStability::Deref,
+            | ty::Dynamic(..) => Position::ReborrowStable,
+            ty::Adt(..) if ty.has_placeholders() || ty.has_param_types_or_consts() => Position::ReborrowStable,
+            ty::Adt(..) => Position::DerefStable,
         };
     }
 }
diff --git a/tests/ui/explicit_auto_deref.fixed b/tests/ui/explicit_auto_deref.fixed
index f534714bc65..d4a9aa7e46c 100644
--- a/tests/ui/explicit_auto_deref.fixed
+++ b/tests/ui/explicit_auto_deref.fixed
@@ -10,7 +10,8 @@
     clippy::ptr_arg,
     clippy::redundant_field_names,
     clippy::too_many_arguments,
-    clippy::borrow_deref_ref
+    clippy::borrow_deref_ref,
+    clippy::let_unit_value
 )]
 
 trait CallableStr {
diff --git a/tests/ui/explicit_auto_deref.rs b/tests/ui/explicit_auto_deref.rs
index 4781962882b..243b8e919c6 100644
--- a/tests/ui/explicit_auto_deref.rs
+++ b/tests/ui/explicit_auto_deref.rs
@@ -10,7 +10,8 @@
     clippy::ptr_arg,
     clippy::redundant_field_names,
     clippy::too_many_arguments,
-    clippy::borrow_deref_ref
+    clippy::borrow_deref_ref,
+    clippy::let_unit_value
 )]
 
 trait CallableStr {
diff --git a/tests/ui/explicit_auto_deref.stderr b/tests/ui/explicit_auto_deref.stderr
index 26357ffd96a..19435eab96b 100644
--- a/tests/ui/explicit_auto_deref.stderr
+++ b/tests/ui/explicit_auto_deref.stderr
@@ -1,5 +1,5 @@
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:63:20
+  --> $DIR/explicit_auto_deref.rs:65:20
    |
 LL |     let _: &str = &*s;
    |                    ^^ help: try this: `s`
@@ -7,187 +7,187 @@ LL |     let _: &str = &*s;
    = note: `-D clippy::explicit-auto-deref` implied by `-D warnings`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:67:12
+  --> $DIR/explicit_auto_deref.rs:69:12
    |
 LL |     f_str(&*s);
    |            ^^ help: try this: `s`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:71:14
+  --> $DIR/explicit_auto_deref.rs:73:14
    |
 LL |     f_str_t(&*s, &*s); // Don't lint second param.
    |              ^^ help: try this: `s`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:74:25
+  --> $DIR/explicit_auto_deref.rs:76:25
    |
 LL |     let _: &Box<i32> = &**b;
    |                         ^^^ help: try this: `b`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:80:8
+  --> $DIR/explicit_auto_deref.rs:82:8
    |
 LL |     c(&*s);
    |        ^^ help: try this: `s`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:86:9
+  --> $DIR/explicit_auto_deref.rs:88:9
    |
 LL |         &**x
    |         ^^^^ help: try this: `x`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:90:11
+  --> $DIR/explicit_auto_deref.rs:92:11
    |
 LL |         { &**x }
    |           ^^^^ help: try this: `x`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:94:9
+  --> $DIR/explicit_auto_deref.rs:96:9
    |
 LL |         &**{ x }
    |         ^^^^^^^^ help: try this: `{ x }`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:98:9
+  --> $DIR/explicit_auto_deref.rs:100:9
    |
 LL |         &***x
    |         ^^^^^ help: try this: `x`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:115:13
+  --> $DIR/explicit_auto_deref.rs:117:13
    |
 LL |         f1(&*x);
    |             ^^ help: try this: `x`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:116:13
+  --> $DIR/explicit_auto_deref.rs:118:13
    |
 LL |         f2(&*x);
    |             ^^ help: try this: `x`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:117:13
+  --> $DIR/explicit_auto_deref.rs:119:13
    |
 LL |         f3(&*x);
    |             ^^ help: try this: `x`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:118:28
+  --> $DIR/explicit_auto_deref.rs:120:28
    |
 LL |         f4.callable_str()(&*x);
    |                            ^^ help: try this: `x`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:119:13
+  --> $DIR/explicit_auto_deref.rs:121:13
    |
 LL |         f5(&*x);
    |             ^^ help: try this: `x`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:120:13
+  --> $DIR/explicit_auto_deref.rs:122:13
    |
 LL |         f6(&*x);
    |             ^^ help: try this: `x`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:121:28
+  --> $DIR/explicit_auto_deref.rs:123:28
    |
 LL |         f7.callable_str()(&*x);
    |                            ^^ help: try this: `x`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:122:26
+  --> $DIR/explicit_auto_deref.rs:124:26
    |
 LL |         f8.callable_t()(&*x);
    |                          ^^ help: try this: `x`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:123:13
+  --> $DIR/explicit_auto_deref.rs:125:13
    |
 LL |         f9(&*x);
    |             ^^ help: try this: `x`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:124:14
+  --> $DIR/explicit_auto_deref.rs:126:14
    |
 LL |         f10(&*x);
    |              ^^ help: try this: `x`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:125:27
+  --> $DIR/explicit_auto_deref.rs:127:27
    |
 LL |         f11.callable_t()(&*x);
    |                           ^^ help: try this: `x`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:129:17
+  --> $DIR/explicit_auto_deref.rs:131:17
    |
 LL |     let _ = S1(&*s);
    |                 ^^ help: try this: `s`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:134:22
+  --> $DIR/explicit_auto_deref.rs:136:22
    |
 LL |     let _ = S2 { s: &*s };
    |                      ^^ help: try this: `s`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:150:30
+  --> $DIR/explicit_auto_deref.rs:152:30
    |
 LL |             let _ = Self::S1(&**s);
    |                              ^^^^ help: try this: `s`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:151:35
+  --> $DIR/explicit_auto_deref.rs:153:35
    |
 LL |             let _ = Self::S2 { s: &**s };
    |                                   ^^^^ help: try this: `s`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:154:21
+  --> $DIR/explicit_auto_deref.rs:156:21
    |
 LL |     let _ = E1::S1(&*s);
    |                     ^^ help: try this: `s`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:155:26
+  --> $DIR/explicit_auto_deref.rs:157:26
    |
 LL |     let _ = E1::S2 { s: &*s };
    |                          ^^ help: try this: `s`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:173:13
+  --> $DIR/explicit_auto_deref.rs:175:13
    |
 LL |     let _ = (*b).foo;
    |             ^^^^ help: try this: `b`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:174:13
+  --> $DIR/explicit_auto_deref.rs:176:13
    |
 LL |     let _ = (**b).foo;
    |             ^^^^^ help: try this: `b`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:189:19
+  --> $DIR/explicit_auto_deref.rs:191:19
    |
 LL |     let _ = f_str(*ref_str);
    |                   ^^^^^^^^ help: try this: `ref_str`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:191:19
+  --> $DIR/explicit_auto_deref.rs:193:19
    |
 LL |     let _ = f_str(**ref_ref_str);
    |                   ^^^^^^^^^^^^^ help: try this: `ref_ref_str`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:201:13
+  --> $DIR/explicit_auto_deref.rs:203:13
    |
 LL |     f_str(&&*ref_str); // `needless_borrow` will suggest removing both references
    |             ^^^^^^^^ help: try this: `ref_str`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:202:12
+  --> $DIR/explicit_auto_deref.rs:204:12
    |
 LL |     f_str(&&**ref_str); // `needless_borrow` will suggest removing only one reference
    |            ^^^^^^^^^^ help: try this: `ref_str`
-- 
cgit 1.4.1-3-g733a5


From 6d21b79be90553ef45f58b682b40432cac840b10 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sat, 29 Jan 2022 20:29:43 -0500
Subject: Fix `needless_borrow` suggestion when calling a trait method taking
 `self`

---
 clippy_lints/src/dereference.rs | 55 ++++++++++++++++++++++++++++++++---------
 tests/ui/needless_borrow.fixed  | 30 ++++++++++++++++++++++
 tests/ui/needless_borrow.rs     | 30 ++++++++++++++++++++++
 tests/ui/needless_borrow.stderr | 14 ++++++++++-
 4 files changed, 117 insertions(+), 12 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index 3821beaea53..9418c4a66b6 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -11,11 +11,13 @@ use rustc_hir::{
     ImplItemKind, Item, ItemKind, Local, MatchSource, Mutability, Node, Pat, PatKind, Path, QPath, TraitItem,
     TraitItemKind, TyKind, UnOp,
 };
+use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::adjustment::{Adjust, Adjustment, AutoBorrow, AutoBorrowMutability};
 use rustc_middle::ty::{self, Ty, TyCtxt, TypeFoldable, TypeckResults};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::{symbol::sym, Span, Symbol};
+use rustc_trait_selection::infer::InferCtxtExt;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -165,7 +167,6 @@ struct StateData {
 
 struct DerefedBorrow {
     count: usize,
-    required_precedence: i8,
     msg: &'static str,
     position: Position,
 }
@@ -329,19 +330,19 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing {
                             "this expression creates a reference which is immediately dereferenced by the compiler";
                         let borrow_msg = "this expression borrows a value the compiler would automatically borrow";
 
-                        let (required_refs, required_precedence, msg) = if position.can_auto_borrow() {
-                            (1, PREC_POSTFIX, if deref_count == 1 { borrow_msg } else { deref_msg })
+                        let (required_refs, msg) = if position.can_auto_borrow() {
+                            (1, if deref_count == 1 { borrow_msg } else { deref_msg })
                         } else if let Some(&Adjust::Borrow(AutoBorrow::Ref(_, mutability))) =
                             next_adjust.map(|a| &a.kind)
                         {
                             if matches!(mutability, AutoBorrowMutability::Mut { .. }) && !position.is_reborrow_stable()
                             {
-                                (3, 0, deref_msg)
+                                (3, deref_msg)
                             } else {
-                                (2, 0, deref_msg)
+                                (2, deref_msg)
                             }
                         } else {
-                            (2, 0, deref_msg)
+                            (2, deref_msg)
                         };
 
                         if deref_count >= required_refs {
@@ -350,7 +351,6 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing {
                                     // One of the required refs is for the current borrow expression, the remaining ones
                                     // can't be removed without breaking the code. See earlier comment.
                                     count: deref_count - required_refs,
-                                    required_precedence,
                                     msg,
                                     position,
                                 }),
@@ -601,6 +601,8 @@ fn deref_method_same_type<'tcx>(result_ty: Ty<'tcx>, arg_ty: Ty<'tcx>) -> bool {
 #[derive(Clone, Copy)]
 enum Position {
     MethodReceiver,
+    /// The method is defined on a reference type. e.g. `impl Foo for &T`
+    MethodReceiverRefImpl,
     Callee,
     FieldAccess(Symbol),
     Postfix,
@@ -627,6 +629,13 @@ impl Position {
     fn lint_explicit_deref(self) -> bool {
         matches!(self, Self::Other | Self::DerefStable | Self::ReborrowStable)
     }
+
+    fn needs_parens(self, precedence: i8) -> bool {
+        matches!(
+            self,
+            Self::MethodReceiver | Self::MethodReceiverRefImpl | Self::Callee | Self::FieldAccess(_) | Self::Postfix
+        ) && precedence < PREC_POSTFIX
+    }
 }
 
 /// Walks up the parent expressions attempting to determine both how stable the auto-deref result
@@ -730,10 +739,34 @@ fn walk_parents<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> (Position, &
                     let id = cx.typeck_results().type_dependent_def_id(parent.hir_id).unwrap();
                     args.iter().position(|arg| arg.hir_id == child_id).map(|i| {
                         if i == 0 {
-                            if e.hir_id == child_id {
-                                Position::MethodReceiver
-                            } else {
+                            // Check for calls to trait methods where the trait is implemented on a reference.
+                            // Two cases need to be handled:
+                            // * `self` methods on `&T` will never have auto-borrow
+                            // * `&self` methods on `&T` can have auto-borrow, but `&self` methods on `T` will take
+                            //   priority.
+                            if e.hir_id != child_id {
                                 Position::ReborrowStable
+                            } else if let Some(trait_id) = cx.tcx.trait_of_item(id)
+                                && let arg_ty = cx.tcx.erase_regions(cx.typeck_results().expr_ty_adjusted(e))
+                                && let ty::Ref(_, sub_ty, _) = *arg_ty.kind()
+                                && let subs = cx.typeck_results().node_substs_opt(child_id).unwrap_or_else(
+                                    || cx.tcx.mk_substs([].iter())
+                                ) && let impl_ty = if cx.tcx.fn_sig(id).skip_binder().inputs()[0].is_ref() {
+                                    // Trait methods taking `&self`
+                                    sub_ty
+                                } else {
+                                    // Trait methods taking `self`
+                                    arg_ty
+                                } && impl_ty.is_ref()
+                                && cx.tcx.infer_ctxt().enter(|infcx|
+                                    infcx
+                                        .type_implements_trait(trait_id, impl_ty, subs, cx.param_env)
+                                        .must_apply_modulo_regions()
+                                )
+                            {
+                                Position::MethodReceiverRefImpl
+                            } else {
+                                Position::MethodReceiver
                             }
                         } else {
                             param_auto_deref_stability(cx.tcx.fn_sig(id).skip_binder().inputs()[i])
@@ -964,7 +997,7 @@ fn report<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, state: State, data
             let mut app = Applicability::MachineApplicable;
             let snip = snippet_with_context(cx, expr.span, data.span.ctxt(), "..", &mut app).0;
             span_lint_hir_and_then(cx, NEEDLESS_BORROW, data.hir_id, data.span, state.msg, |diag| {
-                let sugg = if state.required_precedence > expr.precedence().order() && !has_enclosing_paren(&snip) {
+                let sugg = if state.position.needs_parens(expr.precedence().order()) && !has_enclosing_paren(&snip) {
                     format!("({})", snip)
                 } else {
                     snip.into()
diff --git a/tests/ui/needless_borrow.fixed b/tests/ui/needless_borrow.fixed
index f48f2ae58dc..cb005122436 100644
--- a/tests/ui/needless_borrow.fixed
+++ b/tests/ui/needless_borrow.fixed
@@ -85,6 +85,36 @@ fn main() {
     let _ = x.0;
     let x = &x as *const (i32, i32);
     let _ = unsafe { (*x).0 };
+
+    // Issue #8367
+    trait Foo {
+        fn foo(self);
+    }
+    impl Foo for &'_ () {
+        fn foo(self) {}
+    }
+    (&()).foo(); // Don't lint. `()` doesn't implement `Foo`
+    (&()).foo();
+
+    impl Foo for i32 {
+        fn foo(self) {}
+    }
+    impl Foo for &'_ i32 {
+        fn foo(self) {}
+    }
+    (&5).foo(); // Don't lint. `5` will call `<i32 as Foo>::foo`
+    (&5).foo();
+
+    trait FooRef {
+        fn foo_ref(&self);
+    }
+    impl FooRef for () {
+        fn foo_ref(&self) {}
+    }
+    impl FooRef for &'_ () {
+        fn foo_ref(&self) {}
+    }
+    (&&()).foo_ref(); // Don't lint. `&()` will call `<() as FooRef>::foo_ref`
 }
 
 #[allow(clippy::needless_borrowed_reference)]
diff --git a/tests/ui/needless_borrow.rs b/tests/ui/needless_borrow.rs
index 63515a82158..d636a401003 100644
--- a/tests/ui/needless_borrow.rs
+++ b/tests/ui/needless_borrow.rs
@@ -85,6 +85,36 @@ fn main() {
     let _ = (&x).0;
     let x = &x as *const (i32, i32);
     let _ = unsafe { (&*x).0 };
+
+    // Issue #8367
+    trait Foo {
+        fn foo(self);
+    }
+    impl Foo for &'_ () {
+        fn foo(self) {}
+    }
+    (&()).foo(); // Don't lint. `()` doesn't implement `Foo`
+    (&&()).foo();
+
+    impl Foo for i32 {
+        fn foo(self) {}
+    }
+    impl Foo for &'_ i32 {
+        fn foo(self) {}
+    }
+    (&5).foo(); // Don't lint. `5` will call `<i32 as Foo>::foo`
+    (&&5).foo();
+
+    trait FooRef {
+        fn foo_ref(&self);
+    }
+    impl FooRef for () {
+        fn foo_ref(&self) {}
+    }
+    impl FooRef for &'_ () {
+        fn foo_ref(&self) {}
+    }
+    (&&()).foo_ref(); // Don't lint. `&()` will call `<() as FooRef>::foo_ref`
 }
 
 #[allow(clippy::needless_borrowed_reference)]
diff --git a/tests/ui/needless_borrow.stderr b/tests/ui/needless_borrow.stderr
index cd23d9fd072..8a2e2b98959 100644
--- a/tests/ui/needless_borrow.stderr
+++ b/tests/ui/needless_borrow.stderr
@@ -108,5 +108,17 @@ error: this expression borrows a value the compiler would automatically borrow
 LL |     let _ = unsafe { (&*x).0 };
    |                      ^^^^^ help: change this to: `(*x)`
 
-error: aborting due to 18 previous errors
+error: this expression creates a reference which is immediately dereferenced by the compiler
+  --> $DIR/needless_borrow.rs:97:5
+   |
+LL |     (&&()).foo();
+   |     ^^^^^^ help: change this to: `(&())`
+
+error: this expression creates a reference which is immediately dereferenced by the compiler
+  --> $DIR/needless_borrow.rs:106:5
+   |
+LL |     (&&5).foo();
+   |     ^^^^^ help: change this to: `(&5)`
+
+error: aborting due to 20 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 9788107931ed6d86fc14cebca3d15b7da0d082c4 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Mon, 31 Jan 2022 02:06:18 -0500
Subject: Handle future precedence issues in `explicit_auto_deref` + cleanup

---
 clippy_lints/src/dereference.rs | 155 +++++++++++++++++++++++-----------------
 1 file changed, 89 insertions(+), 66 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index 9418c4a66b6..e3529d1c924 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -163,12 +163,12 @@ struct StateData {
     /// Span of the top level expression
     span: Span,
     hir_id: HirId,
+    position: Position,
 }
 
 struct DerefedBorrow {
     count: usize,
     msg: &'static str,
-    position: Position,
 }
 
 enum State {
@@ -182,8 +182,8 @@ enum State {
     },
     DerefedBorrow(DerefedBorrow),
     ExplicitDeref {
-        deref_span: Span,
-        deref_hir_id: HirId,
+        // Span and id of the top-level deref expression if the parent expression is a borrow.
+        deref_span_id: Option<(Span, HirId)>,
     },
     ExplicitDerefField {
         name: Symbol,
@@ -258,12 +258,12 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing {
                         {
                             self.state = Some((
                                 State::ExplicitDerefField { name },
-                                StateData { span: expr.span, hir_id: expr.hir_id },
+                                StateData { span: expr.span, hir_id: expr.hir_id, position },
                             ));
                         } else if position.is_deref_stable() {
                             self.state = Some((
-                                State::ExplicitDeref { deref_span: expr.span, deref_hir_id: expr.hir_id },
-                                StateData { span: expr.span, hir_id: expr.hir_id },
+                                State::ExplicitDeref { deref_span_id: None },
+                                StateData { span: expr.span, hir_id: expr.hir_id, position },
                             ));
                         }
                     }
@@ -284,6 +284,7 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing {
                             StateData {
                                 span: expr.span,
                                 hir_id: expr.hir_id,
+                                position
                             },
                         ));
                     },
@@ -352,9 +353,8 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing {
                                     // can't be removed without breaking the code. See earlier comment.
                                     count: deref_count - required_refs,
                                     msg,
-                                    position,
                                 }),
-                                StateData { span: expr.span, hir_id: expr.hir_id },
+                                StateData { span: expr.span, hir_id: expr.hir_id, position },
                             ));
                         } else if position.is_deref_stable() {
                             self.state = Some((
@@ -362,6 +362,7 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing {
                                 StateData {
                                     span: expr.span,
                                     hir_id: expr.hir_id,
+                                    position
                                 },
                             ));
                         }
@@ -403,7 +404,7 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing {
                 ));
             },
             (Some((State::DerefedBorrow(state), data)), RefOp::AddrOf) => {
-                let position = state.position;
+                let position = data.position;
                 report(cx, expr, State::DerefedBorrow(state), data);
                 if position.is_deref_stable() {
                     self.state = Some((
@@ -411,24 +412,25 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing {
                         StateData {
                             span: expr.span,
                             hir_id: expr.hir_id,
+                            position,
                         },
                     ));
                 }
             },
             (Some((State::DerefedBorrow(state), data)), RefOp::Deref) => {
-                let position = state.position;
+                let position = data.position;
                 report(cx, expr, State::DerefedBorrow(state), data);
                 if let Position::FieldAccess(name) = position
                     && !ty_contains_field(typeck.expr_ty(sub_expr), name)
                 {
                     self.state = Some((
                         State::ExplicitDerefField { name },
-                        StateData { span: expr.span, hir_id: expr.hir_id },
+                        StateData { span: expr.span, hir_id: expr.hir_id, position },
                     ));
                 } else if position.is_deref_stable() {
                     self.state = Some((
-                        State::ExplicitDeref { deref_span: expr.span, deref_hir_id: expr.hir_id },
-                        StateData { span: expr.span, hir_id: expr.hir_id },
+                        State::ExplicitDeref { deref_span_id: None },
+                        StateData { span: expr.span, hir_id: expr.hir_id, position },
                     ));
                 }
             },
@@ -445,8 +447,7 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing {
                 } else {
                     self.state = Some((
                         State::ExplicitDeref {
-                            deref_span: expr.span,
-                            deref_hir_id: expr.hir_id,
+                            deref_span_id: Some((expr.span, expr.hir_id)),
                         },
                         data,
                     ));
@@ -464,8 +465,7 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing {
             ) => {
                 self.state = Some((
                     State::ExplicitDeref {
-                        deref_span,
-                        deref_hir_id,
+                        deref_span_id: Some((deref_span, deref_hir_id)),
                     },
                     data,
                 ));
@@ -608,18 +608,18 @@ enum Position {
     Postfix,
     Deref,
     /// Any other location which will trigger auto-deref to a specific time.
-    DerefStable,
+    DerefStable(i8),
     /// Any other location which will trigger auto-reborrowing.
-    ReborrowStable,
-    Other,
+    ReborrowStable(i8),
+    Other(i8),
 }
 impl Position {
     fn is_deref_stable(self) -> bool {
-        matches!(self, Self::DerefStable)
+        matches!(self, Self::DerefStable(_))
     }
 
     fn is_reborrow_stable(self) -> bool {
-        matches!(self, Self::DerefStable | Self::ReborrowStable)
+        matches!(self, Self::DerefStable(_) | Self::ReborrowStable(_))
     }
 
     fn can_auto_borrow(self) -> bool {
@@ -627,14 +627,19 @@ impl Position {
     }
 
     fn lint_explicit_deref(self) -> bool {
-        matches!(self, Self::Other | Self::DerefStable | Self::ReborrowStable)
+        matches!(self, Self::Other(_) | Self::DerefStable(_) | Self::ReborrowStable(_))
     }
 
-    fn needs_parens(self, precedence: i8) -> bool {
-        matches!(
-            self,
-            Self::MethodReceiver | Self::MethodReceiverRefImpl | Self::Callee | Self::FieldAccess(_) | Self::Postfix
-        ) && precedence < PREC_POSTFIX
+    fn precedence(self) -> i8 {
+        match self {
+            Self::MethodReceiver
+            | Self::MethodReceiverRefImpl
+            | Self::Callee
+            | Self::FieldAccess(_)
+            | Self::Postfix => PREC_POSTFIX,
+            Self::Deref => PREC_PREFIX,
+            Self::DerefStable(p) | Self::ReborrowStable(p) | Self::Other(p) => p,
+        }
     }
 }
 
@@ -644,6 +649,7 @@ impl Position {
 #[allow(clippy::too_many_lines)]
 fn walk_parents<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> (Position, &'tcx [Adjustment<'tcx>]) {
     let mut adjustments = [].as_slice();
+    let mut precedence = 0i8;
     let ctxt = e.span.ctxt();
     let position = walk_to_expr_usage(cx, e, &mut |parent, child_id| {
         // LocalTableInContext returns the wrong lifetime, so go use `expr_adjustments` instead.
@@ -652,7 +658,7 @@ fn walk_parents<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> (Position, &
         }
         match parent {
             Node::Local(Local { ty: Some(ty), span, .. }) if span.ctxt() == ctxt => {
-                Some(binding_ty_auto_deref_stability(ty))
+                Some(binding_ty_auto_deref_stability(ty, precedence))
             },
             Node::Item(&Item {
                 kind: ItemKind::Static(..) | ItemKind::Const(..),
@@ -674,9 +680,9 @@ fn walk_parents<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> (Position, &
             }) if span.ctxt() == ctxt => {
                 let ty = cx.tcx.type_of(def_id);
                 Some(if ty.is_ref() {
-                    Position::Other
+                    Position::DerefStable(precedence)
                 } else {
-                    Position::DerefStable
+                    Position::Other(precedence)
                 })
             },
 
@@ -700,11 +706,11 @@ fn walk_parents<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> (Position, &
             }) if span.ctxt() == ctxt => {
                 let output = cx.tcx.fn_sig(def_id.to_def_id()).skip_binder().output();
                 Some(if !output.is_ref() {
-                    Position::Other
+                    Position::Other(precedence)
                 } else if output.has_placeholders() || output.has_opaque_types() {
-                    Position::ReborrowStable
+                    Position::ReborrowStable(precedence)
                 } else {
-                    Position::DerefStable
+                    Position::DerefStable(precedence)
                 })
             },
 
@@ -716,11 +722,11 @@ fn walk_parents<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> (Position, &
                         .skip_binder()
                         .output();
                     Some(if !output.is_ref() {
-                        Position::Other
+                        Position::Other(precedence)
                     } else if output.has_placeholders() || output.has_opaque_types() {
-                        Position::ReborrowStable
+                        Position::ReborrowStable(precedence)
                     } else {
-                        Position::DerefStable
+                        Position::DerefStable(precedence)
                     })
                 },
                 ExprKind::Call(func, _) if func.hir_id == child_id => (child_id == e.hir_id).then(|| Position::Callee),
@@ -732,8 +738,8 @@ fn walk_parents<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> (Position, &
                     .map(|(hir_ty, ty)| match hir_ty {
                         // Type inference for closures can depend on how they're called. Only go by the explicit
                         // types here.
-                        Some(ty) => binding_ty_auto_deref_stability(ty),
-                        None => param_auto_deref_stability(ty.skip_binder()),
+                        Some(ty) => binding_ty_auto_deref_stability(ty, precedence),
+                        None => param_auto_deref_stability(ty.skip_binder(), precedence),
                     }),
                 ExprKind::MethodCall(_, args, _) => {
                     let id = cx.typeck_results().type_dependent_def_id(parent.hir_id).unwrap();
@@ -745,7 +751,7 @@ fn walk_parents<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> (Position, &
                             // * `&self` methods on `&T` can have auto-borrow, but `&self` methods on `T` will take
                             //   priority.
                             if e.hir_id != child_id {
-                                Position::ReborrowStable
+                                Position::ReborrowStable(precedence)
                             } else if let Some(trait_id) = cx.tcx.trait_of_item(id)
                                 && let arg_ty = cx.tcx.erase_regions(cx.typeck_results().expr_ty_adjusted(e))
                                 && let ty::Ref(_, sub_ty, _) = *arg_ty.kind()
@@ -769,7 +775,7 @@ fn walk_parents<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> (Position, &
                                 Position::MethodReceiver
                             }
                         } else {
-                            param_auto_deref_stability(cx.tcx.fn_sig(id).skip_binder().inputs()[i])
+                            param_auto_deref_stability(cx.tcx.fn_sig(id).skip_binder().inputs()[i], precedence)
                         }
                     })
                 },
@@ -780,7 +786,7 @@ fn walk_parents<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> (Position, &
                         .find(|f| f.expr.hir_id == child_id)
                         .zip(variant)
                         .and_then(|(field, variant)| variant.fields.iter().find(|f| f.name == field.ident.name))
-                        .map(|field| param_auto_deref_stability(cx.tcx.type_of(field.did)))
+                        .map(|field| param_auto_deref_stability(cx.tcx.type_of(field.did), precedence))
                 },
                 ExprKind::Field(child, name) if child.hir_id == e.hir_id => Some(Position::FieldAccess(name.name)),
                 ExprKind::Unary(UnOp::Deref, child) if child.hir_id == e.hir_id => Some(Position::Deref),
@@ -790,12 +796,16 @@ fn walk_parents<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> (Position, &
                 {
                     Some(Position::Postfix)
                 },
+                _ if child_id == e.hir_id => {
+                    precedence = parent.precedence().order();
+                    None
+                },
                 _ => None,
             },
             _ => None,
         }
     })
-    .unwrap_or(Position::Other);
+    .unwrap_or(Position::Other(precedence));
     (position, adjustments)
 }
 
@@ -808,9 +818,9 @@ fn walk_parents<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> (Position, &
 //
 // Here `y1` and `y2` would resolve to different types, so the type `&Box<_>` is not stable when
 // switching to auto-dereferencing.
-fn binding_ty_auto_deref_stability(ty: &hir::Ty<'_>) -> Position {
+fn binding_ty_auto_deref_stability(ty: &hir::Ty<'_>, precedence: i8) -> Position {
     let TyKind::Rptr(_, ty) = &ty.kind else {
-        return Position::Other;
+        return Position::Other(precedence);
     };
     let mut ty = ty;
 
@@ -836,9 +846,9 @@ fn binding_ty_auto_deref_stability(ty: &hir::Ty<'_>) -> Position {
                         _ => false,
                     })
                 {
-                    Position::ReborrowStable
+                    Position::ReborrowStable(precedence)
                 } else {
-                    Position::DerefStable
+                    Position::DerefStable(precedence)
                 }
             },
             TyKind::Slice(_)
@@ -848,8 +858,11 @@ fn binding_ty_auto_deref_stability(ty: &hir::Ty<'_>) -> Position {
             | TyKind::Tup(_)
             | TyKind::Ptr(_)
             | TyKind::TraitObject(..)
-            | TyKind::Path(_) => Position::DerefStable,
-            TyKind::OpaqueDef(..) | TyKind::Infer | TyKind::Typeof(..) | TyKind::Err => Position::ReborrowStable,
+            | TyKind::Path(_) => Position::DerefStable(precedence),
+            TyKind::OpaqueDef(..)
+            | TyKind::Infer
+            | TyKind::Typeof(..)
+            | TyKind::Err => Position::ReborrowStable(precedence),
         };
     }
 }
@@ -892,9 +905,9 @@ fn ty_contains_infer(ty: &hir::Ty<'_>) -> bool {
 }
 
 // Checks whether a type is stable when switching to auto dereferencing,
-fn param_auto_deref_stability(ty: Ty<'_>) -> Position {
+fn param_auto_deref_stability(ty: Ty<'_>, precedence: i8) -> Position {
     let ty::Ref(_, mut ty, _) = *ty.kind() else {
-        return Position::Other;
+        return Position::Other(precedence);
     };
 
     loop {
@@ -920,16 +933,18 @@ fn param_auto_deref_stability(ty: Ty<'_>) -> Position {
             | ty::GeneratorWitness(..)
             | ty::Never
             | ty::Tuple(_)
-            | ty::Projection(_) => Position::DerefStable,
+            | ty::Projection(_) => Position::DerefStable(precedence),
             ty::Infer(_)
             | ty::Error(_)
             | ty::Param(_)
             | ty::Bound(..)
             | ty::Opaque(..)
             | ty::Placeholder(_)
-            | ty::Dynamic(..) => Position::ReborrowStable,
-            ty::Adt(..) if ty.has_placeholders() || ty.has_param_types_or_consts() => Position::ReborrowStable,
-            ty::Adt(..) => Position::DerefStable,
+            | ty::Dynamic(..) => Position::ReborrowStable(precedence),
+            ty::Adt(..) if ty.has_placeholders() || ty.has_param_types_or_consts() => {
+                Position::ReborrowStable(precedence)
+            },
+            ty::Adt(..) => Position::DerefStable(precedence),
         };
     }
 }
@@ -995,9 +1010,12 @@ fn report<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, state: State, data
         },
         State::DerefedBorrow(state) => {
             let mut app = Applicability::MachineApplicable;
-            let snip = snippet_with_context(cx, expr.span, data.span.ctxt(), "..", &mut app).0;
+            let (snip, snip_is_macro) = snippet_with_context(cx, expr.span, data.span.ctxt(), "..", &mut app);
             span_lint_hir_and_then(cx, NEEDLESS_BORROW, data.hir_id, data.span, state.msg, |diag| {
-                let sugg = if state.position.needs_parens(expr.precedence().order()) && !has_enclosing_paren(&snip) {
+                let sugg = if !snip_is_macro
+                    && expr.precedence().order() < data.position.precedence()
+                    && !has_enclosing_paren(&snip)
+                {
                     format!("({})", snip)
                 } else {
                     snip.into()
@@ -1005,14 +1023,13 @@ fn report<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, state: State, data
                 diag.span_suggestion(data.span, "change this to", sugg, app);
             });
         },
-        State::ExplicitDeref {
-            deref_span,
-            deref_hir_id,
-        } => {
-            let (span, hir_id) = if cx.typeck_results().expr_ty(expr).is_ref() {
-                (data.span, data.hir_id)
+        State::ExplicitDeref { deref_span_id } => {
+            let (span, hir_id, precedence) = if let Some((span, hir_id)) = deref_span_id
+                && !cx.typeck_results().expr_ty(expr).is_ref()
+            {
+                (span, hir_id, PREC_PREFIX)
             } else {
-                (deref_span, deref_hir_id)
+                (data.span, data.hir_id, data.position.precedence())
             };
             span_lint_hir_and_then(
                 cx,
@@ -1022,8 +1039,14 @@ fn report<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, state: State, data
                 "deref which would be done by auto-deref",
                 |diag| {
                     let mut app = Applicability::MachineApplicable;
-                    let snip = snippet_with_context(cx, expr.span, span.ctxt(), "..", &mut app).0;
-                    diag.span_suggestion(span, "try this", snip.into_owned(), app);
+                    let (snip, snip_is_macro) = snippet_with_context(cx, expr.span, span.ctxt(), "..", &mut app);
+                    let sugg =
+                        if !snip_is_macro && expr.precedence().order() < precedence && !has_enclosing_paren(&snip) {
+                            format!("({})", snip)
+                        } else {
+                            snip.into()
+                        };
+                    diag.span_suggestion(span, "try this", sugg, app);
                 },
             );
         },
-- 
cgit 1.4.1-3-g733a5


From 15df2289ea1b9e90eaa37890dcecc155946bb6ac Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Mon, 7 Feb 2022 10:29:45 -0500
Subject: Code cleanup

---
 clippy_lints/src/dereference.rs | 57 +++++++++++++++++++----------------------
 clippy_utils/src/lib.rs         | 11 ++------
 clippy_utils/src/ty.rs          |  1 +
 3 files changed, 29 insertions(+), 40 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index e3529d1c924..e80ee6af650 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -6,8 +6,9 @@ use clippy_utils::{get_parent_expr, is_lint_allowed, path_to_local, walk_to_expr
 use rustc_ast::util::parser::{PREC_POSTFIX, PREC_PREFIX};
 use rustc_data_structures::fx::FxIndexMap;
 use rustc_errors::Applicability;
+use rustc_hir::intravisit::{walk_ty, Visitor};
 use rustc_hir::{
-    self as hir, BindingAnnotation, Body, BodyId, BorrowKind, Expr, ExprKind, FnRetTy, GenericArg, HirId, ImplItem,
+    self as hir, BindingAnnotation, Body, BodyId, BorrowKind, Expr, ExprKind, GenericArg, HirId, ImplItem,
     ImplItemKind, Item, ItemKind, Local, MatchSource, Mutability, Node, Pat, PatKind, Path, QPath, TraitItem,
     TraitItemKind, TyKind, UnOp,
 };
@@ -870,38 +871,32 @@ fn binding_ty_auto_deref_stability(ty: &hir::Ty<'_>, precedence: i8) -> Position
 // Checks whether a type is inferred at some point.
 // e.g. `_`, `Box<_>`, `[_]`
 fn ty_contains_infer(ty: &hir::Ty<'_>) -> bool {
-    match &ty.kind {
-        TyKind::Slice(ty) | TyKind::Array(ty, _) => ty_contains_infer(ty),
-        TyKind::Ptr(ty) | TyKind::Rptr(_, ty) => ty_contains_infer(ty.ty),
-        TyKind::Tup(tys) => tys.iter().any(ty_contains_infer),
-        TyKind::BareFn(ty) => {
-            if ty.decl.inputs.iter().any(ty_contains_infer) {
-                return true;
-            }
-            if let FnRetTy::Return(ty) = &ty.decl.output {
-                ty_contains_infer(ty)
+    struct V(bool);
+    impl Visitor<'_> for V {
+        fn visit_ty(&mut self, ty: &hir::Ty<'_>) {
+            if self.0
+                || matches!(
+                    ty.kind,
+                    TyKind::OpaqueDef(..) | TyKind::Infer | TyKind::Typeof(_) | TyKind::Err
+                )
+            {
+                self.0 = true;
             } else {
-                false
+                walk_ty(self, ty);
             }
-        },
-        &TyKind::Path(
-            QPath::TypeRelative(_, path)
-            | QPath::Resolved(
-                _,
-                Path {
-                    segments: [.., path], ..
-                },
-            ),
-        ) => path.args.map_or(false, |args| {
-            args.args.iter().any(|arg| match arg {
-                GenericArg::Infer(_) => true,
-                GenericArg::Type(ty) => ty_contains_infer(ty),
-                _ => false,
-            })
-        }),
-        TyKind::Path(_) | TyKind::OpaqueDef(..) | TyKind::Infer | TyKind::Typeof(_) | TyKind::Err => true,
-        TyKind::Never | TyKind::TraitObject(..) => false,
+        }
+
+        fn visit_generic_arg(&mut self, arg: &GenericArg<'_>) {
+            if self.0 || matches!(arg, GenericArg::Infer(_)) {
+                self.0 = true;
+            } else if let GenericArg::Type(ty) = arg {
+                self.visit_ty(ty);
+            }
+        }
     }
+    let mut v = V(false);
+    v.visit_ty(ty);
+    v.0
 }
 
 // Checks whether a type is stable when switching to auto dereferencing,
@@ -951,7 +946,7 @@ fn param_auto_deref_stability(ty: Ty<'_>, precedence: i8) -> Position {
 
 fn ty_contains_field(ty: Ty<'_>, name: Symbol) -> bool {
     if let ty::Adt(adt, _) = *ty.kind() {
-        adt.is_struct() && adt.non_enum_variant().fields.iter().any(|f| f.name == name)
+        adt.is_struct() && adt.all_fields().any(|f| f.name == name)
     } else {
         false
     }
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index ca056e7c1a0..a2772edf738 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -2215,19 +2215,12 @@ pub fn walk_to_expr_usage<'tcx, T>(
             _ => return None,
         };
         match parent.kind {
-            ExprKind::If(child, ..) | ExprKind::Match(child, ..) if child.hir_id != child_id => {
-                child_id = parent_id;
-                continue;
-            },
+            ExprKind::If(child, ..) | ExprKind::Match(child, ..) if child.hir_id != child_id => child_id = parent_id,
             ExprKind::Break(Destination { target_id: Ok(id), .. }, _) => {
                 child_id = id;
                 iter = map.parent_iter(id);
-                continue;
-            },
-            ExprKind::Block(..) => {
-                child_id = parent_id;
-                continue;
             },
+            ExprKind::Block(..) => child_id = parent_id,
             _ => return None,
         }
     }
diff --git a/clippy_utils/src/ty.rs b/clippy_utils/src/ty.rs
index 2c19e8a7adb..6ca36eed4e6 100644
--- a/clippy_utils/src/ty.rs
+++ b/clippy_utils/src/ty.rs
@@ -775,6 +775,7 @@ pub fn for_each_top_level_late_bound_region<B>(
     ty.visit_with(&mut V { index: 0, f })
 }
 
+/// Gets the struct or enum variant from the given `Res`
 pub fn variant_of_res<'tcx>(cx: &LateContext<'tcx>, res: Res) -> Option<&'tcx VariantDef> {
     match res {
         Res::Def(DefKind::Struct, id) => Some(cx.tcx.adt_def(id).non_enum_variant()),
-- 
cgit 1.4.1-3-g733a5


From dd78ce7bbe70fcb87ecc4f0ce11611be0b3a7e59 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Tue, 31 May 2022 14:07:50 -0400
Subject: Add `Operators` lint pass

---
 clippy_lints/src/absurd_extreme_comparisons.rs     | 175 ---------------------
 clippy_lints/src/lib.register_all.rs               |   2 +-
 clippy_lints/src/lib.register_correctness.rs       |   2 +-
 clippy_lints/src/lib.register_lints.rs             |   2 +-
 clippy_lints/src/lib.rs                            |   4 +-
 .../src/operators/absurd_extreme_comparisons.rs    | 142 +++++++++++++++++
 clippy_lints/src/operators/mod.rs                  |  51 ++++++
 7 files changed, 198 insertions(+), 180 deletions(-)
 delete mode 100644 clippy_lints/src/absurd_extreme_comparisons.rs
 create mode 100644 clippy_lints/src/operators/absurd_extreme_comparisons.rs
 create mode 100644 clippy_lints/src/operators/mod.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/absurd_extreme_comparisons.rs b/clippy_lints/src/absurd_extreme_comparisons.rs
deleted file mode 100644
index 7665aa8380b..00000000000
--- a/clippy_lints/src/absurd_extreme_comparisons.rs
+++ /dev/null
@@ -1,175 +0,0 @@
-use rustc_hir::{BinOpKind, Expr, ExprKind};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-
-use clippy_utils::comparisons::{normalize_comparison, Rel};
-use clippy_utils::consts::{constant, Constant};
-use clippy_utils::diagnostics::span_lint_and_help;
-use clippy_utils::source::snippet;
-use clippy_utils::ty::is_isize_or_usize;
-use clippy_utils::{clip, int_bits, unsext};
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for comparisons where one side of the relation is
-    /// either the minimum or maximum value for its type and warns if it involves a
-    /// case that is always true or always false. Only integer and boolean types are
-    /// checked.
-    ///
-    /// ### Why is this bad?
-    /// An expression like `min <= x` may misleadingly imply
-    /// that it is possible for `x` to be less than the minimum. Expressions like
-    /// `max < x` are probably mistakes.
-    ///
-    /// ### Known problems
-    /// For `usize` the size of the current compile target will
-    /// be assumed (e.g., 64 bits on 64 bit systems). This means code that uses such
-    /// a comparison to detect target pointer width will trigger this lint. One can
-    /// use `mem::sizeof` and compare its value or conditional compilation
-    /// attributes
-    /// like `#[cfg(target_pointer_width = "64")] ..` instead.
-    ///
-    /// ### Example
-    /// ```rust
-    /// let vec: Vec<isize> = Vec::new();
-    /// if vec.len() <= 0 {}
-    /// if 100 > i32::MAX {}
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub ABSURD_EXTREME_COMPARISONS,
-    correctness,
-    "a comparison with a maximum or minimum value that is always true or false"
-}
-
-declare_lint_pass!(AbsurdExtremeComparisons => [ABSURD_EXTREME_COMPARISONS]);
-
-impl<'tcx> LateLintPass<'tcx> for AbsurdExtremeComparisons {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if let ExprKind::Binary(ref cmp, lhs, rhs) = expr.kind {
-            if let Some((culprit, result)) = detect_absurd_comparison(cx, cmp.node, lhs, rhs) {
-                if !expr.span.from_expansion() {
-                    let msg = "this comparison involving the minimum or maximum element for this \
-                               type contains a case that is always true or always false";
-
-                    let conclusion = match result {
-                        AbsurdComparisonResult::AlwaysFalse => "this comparison is always false".to_owned(),
-                        AbsurdComparisonResult::AlwaysTrue => "this comparison is always true".to_owned(),
-                        AbsurdComparisonResult::InequalityImpossible => format!(
-                            "the case where the two sides are not equal never occurs, consider using `{} == {}` \
-                             instead",
-                            snippet(cx, lhs.span, "lhs"),
-                            snippet(cx, rhs.span, "rhs")
-                        ),
-                    };
-
-                    let help = format!(
-                        "because `{}` is the {} value for this type, {}",
-                        snippet(cx, culprit.expr.span, "x"),
-                        match culprit.which {
-                            ExtremeType::Minimum => "minimum",
-                            ExtremeType::Maximum => "maximum",
-                        },
-                        conclusion
-                    );
-
-                    span_lint_and_help(cx, ABSURD_EXTREME_COMPARISONS, expr.span, msg, None, &help);
-                }
-            }
-        }
-    }
-}
-
-enum ExtremeType {
-    Minimum,
-    Maximum,
-}
-
-struct ExtremeExpr<'a> {
-    which: ExtremeType,
-    expr: &'a Expr<'a>,
-}
-
-enum AbsurdComparisonResult {
-    AlwaysFalse,
-    AlwaysTrue,
-    InequalityImpossible,
-}
-
-fn is_cast_between_fixed_and_target<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
-    if let ExprKind::Cast(cast_exp, _) = expr.kind {
-        let precast_ty = cx.typeck_results().expr_ty(cast_exp);
-        let cast_ty = cx.typeck_results().expr_ty(expr);
-
-        return is_isize_or_usize(precast_ty) != is_isize_or_usize(cast_ty);
-    }
-
-    false
-}
-
-fn detect_absurd_comparison<'tcx>(
-    cx: &LateContext<'tcx>,
-    op: BinOpKind,
-    lhs: &'tcx Expr<'_>,
-    rhs: &'tcx Expr<'_>,
-) -> Option<(ExtremeExpr<'tcx>, AbsurdComparisonResult)> {
-    use AbsurdComparisonResult::{AlwaysFalse, AlwaysTrue, InequalityImpossible};
-    use ExtremeType::{Maximum, Minimum};
-    // absurd comparison only makes sense on primitive types
-    // primitive types don't implement comparison operators with each other
-    if cx.typeck_results().expr_ty(lhs) != cx.typeck_results().expr_ty(rhs) {
-        return None;
-    }
-
-    // comparisons between fix sized types and target sized types are considered unanalyzable
-    if is_cast_between_fixed_and_target(cx, lhs) || is_cast_between_fixed_and_target(cx, rhs) {
-        return None;
-    }
-
-    let (rel, normalized_lhs, normalized_rhs) = normalize_comparison(op, lhs, rhs)?;
-
-    let lx = detect_extreme_expr(cx, normalized_lhs);
-    let rx = detect_extreme_expr(cx, normalized_rhs);
-
-    Some(match rel {
-        Rel::Lt => {
-            match (lx, rx) {
-                (Some(l @ ExtremeExpr { which: Maximum, .. }), _) => (l, AlwaysFalse), // max < x
-                (_, Some(r @ ExtremeExpr { which: Minimum, .. })) => (r, AlwaysFalse), // x < min
-                _ => return None,
-            }
-        },
-        Rel::Le => {
-            match (lx, rx) {
-                (Some(l @ ExtremeExpr { which: Minimum, .. }), _) => (l, AlwaysTrue), // min <= x
-                (Some(l @ ExtremeExpr { which: Maximum, .. }), _) => (l, InequalityImpossible), // max <= x
-                (_, Some(r @ ExtremeExpr { which: Minimum, .. })) => (r, InequalityImpossible), // x <= min
-                (_, Some(r @ ExtremeExpr { which: Maximum, .. })) => (r, AlwaysTrue), // x <= max
-                _ => return None,
-            }
-        },
-        Rel::Ne | Rel::Eq => return None,
-    })
-}
-
-fn detect_extreme_expr<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<ExtremeExpr<'tcx>> {
-    let ty = cx.typeck_results().expr_ty(expr);
-
-    let cv = constant(cx, cx.typeck_results(), expr)?.0;
-
-    let which = match (ty.kind(), cv) {
-        (&ty::Bool, Constant::Bool(false)) | (&ty::Uint(_), Constant::Int(0)) => ExtremeType::Minimum,
-        (&ty::Int(ity), Constant::Int(i)) if i == unsext(cx.tcx, i128::MIN >> (128 - int_bits(cx.tcx, ity)), ity) => {
-            ExtremeType::Minimum
-        },
-
-        (&ty::Bool, Constant::Bool(true)) => ExtremeType::Maximum,
-        (&ty::Int(ity), Constant::Int(i)) if i == unsext(cx.tcx, i128::MAX >> (128 - int_bits(cx.tcx, ity)), ity) => {
-            ExtremeType::Maximum
-        },
-        (&ty::Uint(uty), Constant::Int(i)) if clip(cx.tcx, u128::MAX, uty) == i => ExtremeType::Maximum,
-
-        _ => return None,
-    };
-    Some(ExtremeExpr { which, expr })
-}
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index b4edb8ea90e..7728157d228 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -3,7 +3,6 @@
 // Manual edits will be overwritten.
 
 store.register_group(true, "clippy::all", Some("clippy_all"), vec![
-    LintId::of(absurd_extreme_comparisons::ABSURD_EXTREME_COMPARISONS),
     LintId::of(almost_complete_letter_range::ALMOST_COMPLETE_LETTER_RANGE),
     LintId::of(approx_const::APPROX_CONSTANT),
     LintId::of(assertions_on_constants::ASSERTIONS_ON_CONSTANTS),
@@ -260,6 +259,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(non_octal_unix_permissions::NON_OCTAL_UNIX_PERMISSIONS),
     LintId::of(octal_escapes::OCTAL_ESCAPES),
     LintId::of(open_options::NONSENSICAL_OPEN_OPTIONS),
+    LintId::of(operators::ABSURD_EXTREME_COMPARISONS),
     LintId::of(option_env_unwrap::OPTION_ENV_UNWRAP),
     LintId::of(overflow_check_conditional::OVERFLOW_CHECK_CONDITIONAL),
     LintId::of(partialeq_ne_impl::PARTIALEQ_NE_IMPL),
diff --git a/clippy_lints/src/lib.register_correctness.rs b/clippy_lints/src/lib.register_correctness.rs
index 92a3a0aabf1..26852445fdc 100644
--- a/clippy_lints/src/lib.register_correctness.rs
+++ b/clippy_lints/src/lib.register_correctness.rs
@@ -3,7 +3,6 @@
 // Manual edits will be overwritten.
 
 store.register_group(true, "clippy::correctness", Some("clippy_correctness"), vec![
-    LintId::of(absurd_extreme_comparisons::ABSURD_EXTREME_COMPARISONS),
     LintId::of(approx_const::APPROX_CONSTANT),
     LintId::of(async_yields_async::ASYNC_YIELDS_ASYNC),
     LintId::of(attrs::DEPRECATED_SEMVER),
@@ -51,6 +50,7 @@ store.register_group(true, "clippy::correctness", Some("clippy_correctness"), ve
     LintId::of(misc::MODULO_ONE),
     LintId::of(non_octal_unix_permissions::NON_OCTAL_UNIX_PERMISSIONS),
     LintId::of(open_options::NONSENSICAL_OPEN_OPTIONS),
+    LintId::of(operators::ABSURD_EXTREME_COMPARISONS),
     LintId::of(option_env_unwrap::OPTION_ENV_UNWRAP),
     LintId::of(ptr::INVALID_NULL_PTR_USAGE),
     LintId::of(ptr::MUT_FROM_REF),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 29a5f368f23..f0ce0db65a7 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -35,7 +35,6 @@ store.register_lints(&[
     utils::internal_lints::PRODUCE_ICE,
     #[cfg(feature = "internal")]
     utils::internal_lints::UNNECESSARY_SYMBOL_STR,
-    absurd_extreme_comparisons::ABSURD_EXTREME_COMPARISONS,
     almost_complete_letter_range::ALMOST_COMPLETE_LETTER_RANGE,
     approx_const::APPROX_CONSTANT,
     as_conversions::AS_CONVERSIONS,
@@ -437,6 +436,7 @@ store.register_lints(&[
     octal_escapes::OCTAL_ESCAPES,
     only_used_in_recursion::ONLY_USED_IN_RECURSION,
     open_options::NONSENSICAL_OPEN_OPTIONS,
+    operators::ABSURD_EXTREME_COMPARISONS,
     option_env_unwrap::OPTION_ENV_UNWRAP,
     option_if_let_else::OPTION_IF_LET_ELSE,
     overflow_check_conditional::OVERFLOW_CHECK_CONDITIONAL,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 6c5b5ed98bc..16e72400fbf 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -168,7 +168,6 @@ mod utils;
 mod renamed_lints;
 
 // begin lints modules, do not remove this comment, it’s used in `update_lints`
-mod absurd_extreme_comparisons;
 mod almost_complete_letter_range;
 mod approx_const;
 mod as_conversions;
@@ -336,6 +335,7 @@ mod numeric_arithmetic;
 mod octal_escapes;
 mod only_used_in_recursion;
 mod open_options;
+mod operators;
 mod option_env_unwrap;
 mod option_if_let_else;
 mod overflow_check_conditional;
@@ -683,7 +683,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(derivable_impls::DerivableImpls));
     store.register_late_pass(|| Box::new(drop_forget_ref::DropForgetRef));
     store.register_late_pass(|| Box::new(empty_enum::EmptyEnum));
-    store.register_late_pass(|| Box::new(absurd_extreme_comparisons::AbsurdExtremeComparisons));
     store.register_late_pass(|| Box::new(invalid_upcast_comparisons::InvalidUpcastComparisons));
     store.register_late_pass(|| Box::new(regex::Regex));
     store.register_late_pass(|| Box::new(copies::CopyAndPaste));
@@ -941,6 +940,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(default_instead_of_iter_empty::DefaultIterEmpty));
     store.register_late_pass(move || Box::new(manual_rem_euclid::ManualRemEuclid::new(msrv)));
     store.register_late_pass(move || Box::new(manual_retain::ManualRetain::new(msrv)));
+    store.register_late_pass(|| Box::new(operators::Operators));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/operators/absurd_extreme_comparisons.rs b/clippy_lints/src/operators/absurd_extreme_comparisons.rs
new file mode 100644
index 00000000000..1ec4240afef
--- /dev/null
+++ b/clippy_lints/src/operators/absurd_extreme_comparisons.rs
@@ -0,0 +1,142 @@
+use rustc_hir::{BinOpKind, Expr, ExprKind};
+use rustc_lint::LateContext;
+use rustc_middle::ty;
+
+use clippy_utils::comparisons::{normalize_comparison, Rel};
+use clippy_utils::consts::{constant, Constant};
+use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::source::snippet;
+use clippy_utils::ty::is_isize_or_usize;
+use clippy_utils::{clip, int_bits, unsext};
+
+use super::ABSURD_EXTREME_COMPARISONS;
+
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx Expr<'_>,
+    op: BinOpKind,
+    lhs: &'tcx Expr<'_>,
+    rhs: &'tcx Expr<'_>,
+) {
+    if let Some((culprit, result)) = detect_absurd_comparison(cx, op, lhs, rhs) {
+        let msg = "this comparison involving the minimum or maximum element for this \
+                           type contains a case that is always true or always false";
+
+        let conclusion = match result {
+            AbsurdComparisonResult::AlwaysFalse => "this comparison is always false".to_owned(),
+            AbsurdComparisonResult::AlwaysTrue => "this comparison is always true".to_owned(),
+            AbsurdComparisonResult::InequalityImpossible => format!(
+                "the case where the two sides are not equal never occurs, consider using `{} == {}` \
+                         instead",
+                snippet(cx, lhs.span, "lhs"),
+                snippet(cx, rhs.span, "rhs")
+            ),
+        };
+
+        let help = format!(
+            "because `{}` is the {} value for this type, {}",
+            snippet(cx, culprit.expr.span, "x"),
+            match culprit.which {
+                ExtremeType::Minimum => "minimum",
+                ExtremeType::Maximum => "maximum",
+            },
+            conclusion
+        );
+
+        span_lint_and_help(cx, ABSURD_EXTREME_COMPARISONS, expr.span, msg, None, &help);
+    }
+}
+
+enum ExtremeType {
+    Minimum,
+    Maximum,
+}
+
+struct ExtremeExpr<'a> {
+    which: ExtremeType,
+    expr: &'a Expr<'a>,
+}
+
+enum AbsurdComparisonResult {
+    AlwaysFalse,
+    AlwaysTrue,
+    InequalityImpossible,
+}
+
+fn is_cast_between_fixed_and_target<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
+    if let ExprKind::Cast(cast_exp, _) = expr.kind {
+        let precast_ty = cx.typeck_results().expr_ty(cast_exp);
+        let cast_ty = cx.typeck_results().expr_ty(expr);
+
+        return is_isize_or_usize(precast_ty) != is_isize_or_usize(cast_ty);
+    }
+
+    false
+}
+
+fn detect_absurd_comparison<'tcx>(
+    cx: &LateContext<'tcx>,
+    op: BinOpKind,
+    lhs: &'tcx Expr<'_>,
+    rhs: &'tcx Expr<'_>,
+) -> Option<(ExtremeExpr<'tcx>, AbsurdComparisonResult)> {
+    use AbsurdComparisonResult::{AlwaysFalse, AlwaysTrue, InequalityImpossible};
+    use ExtremeType::{Maximum, Minimum};
+    // absurd comparison only makes sense on primitive types
+    // primitive types don't implement comparison operators with each other
+    if cx.typeck_results().expr_ty(lhs) != cx.typeck_results().expr_ty(rhs) {
+        return None;
+    }
+
+    // comparisons between fix sized types and target sized types are considered unanalyzable
+    if is_cast_between_fixed_and_target(cx, lhs) || is_cast_between_fixed_and_target(cx, rhs) {
+        return None;
+    }
+
+    let (rel, normalized_lhs, normalized_rhs) = normalize_comparison(op, lhs, rhs)?;
+
+    let lx = detect_extreme_expr(cx, normalized_lhs);
+    let rx = detect_extreme_expr(cx, normalized_rhs);
+
+    Some(match rel {
+        Rel::Lt => {
+            match (lx, rx) {
+                (Some(l @ ExtremeExpr { which: Maximum, .. }), _) => (l, AlwaysFalse), // max < x
+                (_, Some(r @ ExtremeExpr { which: Minimum, .. })) => (r, AlwaysFalse), // x < min
+                _ => return None,
+            }
+        },
+        Rel::Le => {
+            match (lx, rx) {
+                (Some(l @ ExtremeExpr { which: Minimum, .. }), _) => (l, AlwaysTrue), // min <= x
+                (Some(l @ ExtremeExpr { which: Maximum, .. }), _) => (l, InequalityImpossible), // max <= x
+                (_, Some(r @ ExtremeExpr { which: Minimum, .. })) => (r, InequalityImpossible), // x <= min
+                (_, Some(r @ ExtremeExpr { which: Maximum, .. })) => (r, AlwaysTrue), // x <= max
+                _ => return None,
+            }
+        },
+        Rel::Ne | Rel::Eq => return None,
+    })
+}
+
+fn detect_extreme_expr<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<ExtremeExpr<'tcx>> {
+    let ty = cx.typeck_results().expr_ty(expr);
+
+    let cv = constant(cx, cx.typeck_results(), expr)?.0;
+
+    let which = match (ty.kind(), cv) {
+        (&ty::Bool, Constant::Bool(false)) | (&ty::Uint(_), Constant::Int(0)) => ExtremeType::Minimum,
+        (&ty::Int(ity), Constant::Int(i)) if i == unsext(cx.tcx, i128::MIN >> (128 - int_bits(cx.tcx, ity)), ity) => {
+            ExtremeType::Minimum
+        },
+
+        (&ty::Bool, Constant::Bool(true)) => ExtremeType::Maximum,
+        (&ty::Int(ity), Constant::Int(i)) if i == unsext(cx.tcx, i128::MAX >> (128 - int_bits(cx.tcx, ity)), ity) => {
+            ExtremeType::Maximum
+        },
+        (&ty::Uint(uty), Constant::Int(i)) if clip(cx.tcx, u128::MAX, uty) == i => ExtremeType::Maximum,
+
+        _ => return None,
+    };
+    Some(ExtremeExpr { which, expr })
+}
diff --git a/clippy_lints/src/operators/mod.rs b/clippy_lints/src/operators/mod.rs
new file mode 100644
index 00000000000..6f5a1647277
--- /dev/null
+++ b/clippy_lints/src/operators/mod.rs
@@ -0,0 +1,51 @@
+use rustc_hir::{Expr, ExprKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+
+mod absurd_extreme_comparisons;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for comparisons where one side of the relation is
+    /// either the minimum or maximum value for its type and warns if it involves a
+    /// case that is always true or always false. Only integer and boolean types are
+    /// checked.
+    ///
+    /// ### Why is this bad?
+    /// An expression like `min <= x` may misleadingly imply
+    /// that it is possible for `x` to be less than the minimum. Expressions like
+    /// `max < x` are probably mistakes.
+    ///
+    /// ### Known problems
+    /// For `usize` the size of the current compile target will
+    /// be assumed (e.g., 64 bits on 64 bit systems). This means code that uses such
+    /// a comparison to detect target pointer width will trigger this lint. One can
+    /// use `mem::sizeof` and compare its value or conditional compilation
+    /// attributes
+    /// like `#[cfg(target_pointer_width = "64")] ..` instead.
+    ///
+    /// ### Example
+    /// ```rust
+    /// let vec: Vec<isize> = Vec::new();
+    /// if vec.len() <= 0 {}
+    /// if 100 > i32::MAX {}
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub ABSURD_EXTREME_COMPARISONS,
+    correctness,
+    "a comparison with a maximum or minimum value that is always true or false"
+}
+
+pub struct Operators;
+impl_lint_pass!(Operators => [
+    ABSURD_EXTREME_COMPARISONS,
+]);
+impl<'tcx> LateLintPass<'tcx> for Operators {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
+        if let ExprKind::Binary(op, lhs, rhs) = e.kind {
+            if !e.span.from_expansion() {
+                absurd_extreme_comparisons::check(cx, e, op.node, lhs, rhs);
+            }
+        }
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 448b6f45bd1175e3ea7f696e1ff7b9702d8a7cc6 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Tue, 31 May 2022 21:27:29 -0400
Subject: Move `Arithmetic` into `Operators` lint pass

---
 clippy_lints/src/lib.register_lints.rs           |   4 +-
 clippy_lints/src/lib.register_restriction.rs     |   4 +-
 clippy_lints/src/lib.rs                          |   4 +-
 clippy_lints/src/numeric_arithmetic.rs           | 170 -----------------------
 clippy_lints/src/operators/mod.rs                |  87 +++++++++++-
 clippy_lints/src/operators/numeric_arithmetic.rs | 127 +++++++++++++++++
 6 files changed, 213 insertions(+), 183 deletions(-)
 delete mode 100644 clippy_lints/src/numeric_arithmetic.rs
 create mode 100644 clippy_lints/src/operators/numeric_arithmetic.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index f0ce0db65a7..787ae1e79ec 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -431,12 +431,12 @@ store.register_lints(&[
     non_octal_unix_permissions::NON_OCTAL_UNIX_PERMISSIONS,
     non_send_fields_in_send_ty::NON_SEND_FIELDS_IN_SEND_TY,
     nonstandard_macro_braces::NONSTANDARD_MACRO_BRACES,
-    numeric_arithmetic::FLOAT_ARITHMETIC,
-    numeric_arithmetic::INTEGER_ARITHMETIC,
     octal_escapes::OCTAL_ESCAPES,
     only_used_in_recursion::ONLY_USED_IN_RECURSION,
     open_options::NONSENSICAL_OPEN_OPTIONS,
     operators::ABSURD_EXTREME_COMPARISONS,
+    operators::FLOAT_ARITHMETIC,
+    operators::INTEGER_ARITHMETIC,
     option_env_unwrap::OPTION_ENV_UNWRAP,
     option_if_let_else::OPTION_IF_LET_ELSE,
     overflow_check_conditional::OVERFLOW_CHECK_CONDITIONAL,
diff --git a/clippy_lints/src/lib.register_restriction.rs b/clippy_lints/src/lib.register_restriction.rs
index 3695012f552..b7441385230 100644
--- a/clippy_lints/src/lib.register_restriction.rs
+++ b/clippy_lints/src/lib.register_restriction.rs
@@ -50,8 +50,8 @@ store.register_group(true, "clippy::restriction", Some("clippy_restriction"), ve
     LintId::of(module_style::MOD_MODULE_FILES),
     LintId::of(module_style::SELF_NAMED_MODULE_FILES),
     LintId::of(modulo_arithmetic::MODULO_ARITHMETIC),
-    LintId::of(numeric_arithmetic::FLOAT_ARITHMETIC),
-    LintId::of(numeric_arithmetic::INTEGER_ARITHMETIC),
+    LintId::of(operators::FLOAT_ARITHMETIC),
+    LintId::of(operators::INTEGER_ARITHMETIC),
     LintId::of(panic_in_result_fn::PANIC_IN_RESULT_FN),
     LintId::of(panic_unimplemented::PANIC),
     LintId::of(panic_unimplemented::TODO),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 16e72400fbf..f1d28201309 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -331,7 +331,6 @@ mod non_expressive_names;
 mod non_octal_unix_permissions;
 mod non_send_fields_in_send_ty;
 mod nonstandard_macro_braces;
-mod numeric_arithmetic;
 mod octal_escapes;
 mod only_used_in_recursion;
 mod open_options;
@@ -705,7 +704,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(move || Box::new(doc::DocMarkdown::new(doc_valid_idents.clone())));
     store.register_late_pass(|| Box::new(neg_multiply::NegMultiply));
     store.register_late_pass(|| Box::new(mem_forget::MemForget));
-    store.register_late_pass(|| Box::new(numeric_arithmetic::NumericArithmetic::default()));
     store.register_late_pass(|| Box::new(assign_ops::AssignOps));
     store.register_late_pass(|| Box::new(let_if_seq::LetIfSeq));
     store.register_late_pass(|| Box::new(mixed_read_write_in_expression::EvalOrderDependence));
@@ -940,7 +938,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(default_instead_of_iter_empty::DefaultIterEmpty));
     store.register_late_pass(move || Box::new(manual_rem_euclid::ManualRemEuclid::new(msrv)));
     store.register_late_pass(move || Box::new(manual_retain::ManualRetain::new(msrv)));
-    store.register_late_pass(|| Box::new(operators::Operators));
+    store.register_late_pass(|| Box::new(operators::Operators::default()));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/numeric_arithmetic.rs b/clippy_lints/src/numeric_arithmetic.rs
deleted file mode 100644
index 5c4de338149..00000000000
--- a/clippy_lints/src/numeric_arithmetic.rs
+++ /dev/null
@@ -1,170 +0,0 @@
-use clippy_utils::consts::constant_simple;
-use clippy_utils::diagnostics::span_lint;
-use rustc_hir as hir;
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::source_map::Span;
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for integer arithmetic operations which could overflow or panic.
-    ///
-    /// Specifically, checks for any operators (`+`, `-`, `*`, `<<`, etc) which are capable
-    /// of overflowing according to the [Rust
-    /// Reference](https://doc.rust-lang.org/reference/expressions/operator-expr.html#overflow),
-    /// or which can panic (`/`, `%`). No bounds analysis or sophisticated reasoning is
-    /// attempted.
-    ///
-    /// ### Why is this bad?
-    /// Integer overflow will trigger a panic in debug builds or will wrap in
-    /// release mode. Division by zero will cause a panic in either mode. In some applications one
-    /// wants explicitly checked, wrapping or saturating arithmetic.
-    ///
-    /// ### Example
-    /// ```rust
-    /// # let a = 0;
-    /// a + 1;
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub INTEGER_ARITHMETIC,
-    restriction,
-    "any integer arithmetic expression which could overflow or panic"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for float arithmetic.
-    ///
-    /// ### Why is this bad?
-    /// For some embedded systems or kernel development, it
-    /// can be useful to rule out floating-point numbers.
-    ///
-    /// ### Example
-    /// ```rust
-    /// # let a = 0.0;
-    /// a + 1.0;
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub FLOAT_ARITHMETIC,
-    restriction,
-    "any floating-point arithmetic statement"
-}
-
-#[derive(Copy, Clone, Default)]
-pub struct NumericArithmetic {
-    expr_span: Option<Span>,
-    /// This field is used to check whether expressions are constants, such as in enum discriminants
-    /// and consts
-    const_span: Option<Span>,
-}
-
-impl_lint_pass!(NumericArithmetic => [INTEGER_ARITHMETIC, FLOAT_ARITHMETIC]);
-
-impl<'tcx> LateLintPass<'tcx> for NumericArithmetic {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
-        if self.expr_span.is_some() {
-            return;
-        }
-
-        if let Some(span) = self.const_span {
-            if span.contains(expr.span) {
-                return;
-            }
-        }
-        match &expr.kind {
-            hir::ExprKind::Binary(op, l, r) | hir::ExprKind::AssignOp(op, l, r) => {
-                match op.node {
-                    hir::BinOpKind::And
-                    | hir::BinOpKind::Or
-                    | hir::BinOpKind::BitAnd
-                    | hir::BinOpKind::BitOr
-                    | hir::BinOpKind::BitXor
-                    | hir::BinOpKind::Eq
-                    | hir::BinOpKind::Lt
-                    | hir::BinOpKind::Le
-                    | hir::BinOpKind::Ne
-                    | hir::BinOpKind::Ge
-                    | hir::BinOpKind::Gt => return,
-                    _ => (),
-                }
-
-                let (l_ty, r_ty) = (cx.typeck_results().expr_ty(l), cx.typeck_results().expr_ty(r));
-                if l_ty.peel_refs().is_integral() && r_ty.peel_refs().is_integral() {
-                    match op.node {
-                        hir::BinOpKind::Div | hir::BinOpKind::Rem => match &r.kind {
-                            hir::ExprKind::Lit(_lit) => (),
-                            hir::ExprKind::Unary(hir::UnOp::Neg, expr) => {
-                                if let hir::ExprKind::Lit(lit) = &expr.kind {
-                                    if let rustc_ast::ast::LitKind::Int(1, _) = lit.node {
-                                        span_lint(cx, INTEGER_ARITHMETIC, expr.span, "integer arithmetic detected");
-                                        self.expr_span = Some(expr.span);
-                                    }
-                                }
-                            },
-                            _ => {
-                                span_lint(cx, INTEGER_ARITHMETIC, expr.span, "integer arithmetic detected");
-                                self.expr_span = Some(expr.span);
-                            },
-                        },
-                        _ => {
-                            span_lint(cx, INTEGER_ARITHMETIC, expr.span, "integer arithmetic detected");
-                            self.expr_span = Some(expr.span);
-                        },
-                    }
-                } else if r_ty.peel_refs().is_floating_point() && r_ty.peel_refs().is_floating_point() {
-                    span_lint(cx, FLOAT_ARITHMETIC, expr.span, "floating-point arithmetic detected");
-                    self.expr_span = Some(expr.span);
-                }
-            },
-            hir::ExprKind::Unary(hir::UnOp::Neg, arg) => {
-                let ty = cx.typeck_results().expr_ty(arg);
-                if constant_simple(cx, cx.typeck_results(), expr).is_none() {
-                    if ty.is_integral() {
-                        span_lint(cx, INTEGER_ARITHMETIC, expr.span, "integer arithmetic detected");
-                        self.expr_span = Some(expr.span);
-                    } else if ty.is_floating_point() {
-                        span_lint(cx, FLOAT_ARITHMETIC, expr.span, "floating-point arithmetic detected");
-                        self.expr_span = Some(expr.span);
-                    }
-                }
-            },
-            _ => (),
-        }
-    }
-
-    fn check_expr_post(&mut self, _: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
-        if Some(expr.span) == self.expr_span {
-            self.expr_span = None;
-        }
-    }
-
-    fn check_body(&mut self, cx: &LateContext<'_>, body: &hir::Body<'_>) {
-        let body_owner = cx.tcx.hir().body_owner_def_id(body.id());
-
-        match cx.tcx.hir().body_owner_kind(body_owner) {
-            hir::BodyOwnerKind::Static(_) | hir::BodyOwnerKind::Const => {
-                let body_span = cx.tcx.def_span(body_owner);
-
-                if let Some(span) = self.const_span {
-                    if span.contains(body_span) {
-                        return;
-                    }
-                }
-                self.const_span = Some(body_span);
-            },
-            hir::BodyOwnerKind::Fn | hir::BodyOwnerKind::Closure => (),
-        }
-    }
-
-    fn check_body_post(&mut self, cx: &LateContext<'_>, body: &hir::Body<'_>) {
-        let body_owner = cx.tcx.hir().body_owner(body.id());
-        let body_span = cx.tcx.hir().span(body_owner);
-
-        if let Some(span) = self.const_span {
-            if span.contains(body_span) {
-                return;
-            }
-        }
-        self.const_span = None;
-    }
-}
diff --git a/clippy_lints/src/operators/mod.rs b/clippy_lints/src/operators/mod.rs
index 6f5a1647277..a7495f042da 100644
--- a/clippy_lints/src/operators/mod.rs
+++ b/clippy_lints/src/operators/mod.rs
@@ -1,8 +1,9 @@
-use rustc_hir::{Expr, ExprKind};
+use rustc_hir::{Body, Expr, ExprKind, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 
 mod absurd_extreme_comparisons;
+mod numeric_arithmetic;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -36,16 +37,90 @@ declare_clippy_lint! {
     "a comparison with a maximum or minimum value that is always true or false"
 }
 
-pub struct Operators;
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for integer arithmetic operations which could overflow or panic.
+    ///
+    /// Specifically, checks for any operators (`+`, `-`, `*`, `<<`, etc) which are capable
+    /// of overflowing according to the [Rust
+    /// Reference](https://doc.rust-lang.org/reference/expressions/operator-expr.html#overflow),
+    /// or which can panic (`/`, `%`). No bounds analysis or sophisticated reasoning is
+    /// attempted.
+    ///
+    /// ### Why is this bad?
+    /// Integer overflow will trigger a panic in debug builds or will wrap in
+    /// release mode. Division by zero will cause a panic in either mode. In some applications one
+    /// wants explicitly checked, wrapping or saturating arithmetic.
+    ///
+    /// ### Example
+    /// ```rust
+    /// # let a = 0;
+    /// a + 1;
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub INTEGER_ARITHMETIC,
+    restriction,
+    "any integer arithmetic expression which could overflow or panic"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for float arithmetic.
+    ///
+    /// ### Why is this bad?
+    /// For some embedded systems or kernel development, it
+    /// can be useful to rule out floating-point numbers.
+    ///
+    /// ### Example
+    /// ```rust
+    /// # let a = 0.0;
+    /// a + 1.0;
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub FLOAT_ARITHMETIC,
+    restriction,
+    "any floating-point arithmetic statement"
+}
+
+#[derive(Default)]
+pub struct Operators {
+    arithmetic_context: numeric_arithmetic::Context,
+}
 impl_lint_pass!(Operators => [
     ABSURD_EXTREME_COMPARISONS,
+    INTEGER_ARITHMETIC,
+    FLOAT_ARITHMETIC,
 ]);
 impl<'tcx> LateLintPass<'tcx> for Operators {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
-        if let ExprKind::Binary(op, lhs, rhs) = e.kind {
-            if !e.span.from_expansion() {
-                absurd_extreme_comparisons::check(cx, e, op.node, lhs, rhs);
-            }
+        match e.kind {
+            ExprKind::Binary(op, lhs, rhs) => {
+                if !e.span.from_expansion() {
+                    absurd_extreme_comparisons::check(cx, e, op.node, lhs, rhs);
+                }
+                self.arithmetic_context.check_binary(cx, e, op.node, lhs, rhs);
+            },
+            ExprKind::AssignOp(op, lhs, rhs) => {
+                self.arithmetic_context.check_binary(cx, e, op.node, lhs, rhs);
+            },
+            ExprKind::Unary(op, arg) => {
+                if op == UnOp::Neg {
+                    self.arithmetic_context.check_negate(cx, e, arg);
+                }
+            },
+            _ => (),
         }
     }
+
+    fn check_expr_post(&mut self, _: &LateContext<'_>, e: &Expr<'_>) {
+        self.arithmetic_context.expr_post(e.hir_id);
+    }
+
+    fn check_body(&mut self, cx: &LateContext<'tcx>, b: &'tcx Body<'_>) {
+        self.arithmetic_context.enter_body(cx, b);
+    }
+
+    fn check_body_post(&mut self, cx: &LateContext<'tcx>, b: &'tcx Body<'_>) {
+        self.arithmetic_context.body_post(cx, b);
+    }
 }
diff --git a/clippy_lints/src/operators/numeric_arithmetic.rs b/clippy_lints/src/operators/numeric_arithmetic.rs
new file mode 100644
index 00000000000..82f454d02f7
--- /dev/null
+++ b/clippy_lints/src/operators/numeric_arithmetic.rs
@@ -0,0 +1,127 @@
+use clippy_utils::consts::constant_simple;
+use clippy_utils::diagnostics::span_lint;
+use rustc_hir as hir;
+use rustc_lint::LateContext;
+use rustc_span::source_map::Span;
+
+use super::{FLOAT_ARITHMETIC, INTEGER_ARITHMETIC};
+
+#[derive(Default)]
+pub struct Context {
+    expr_id: Option<hir::HirId>,
+    /// This field is used to check whether expressions are constants, such as in enum discriminants
+    /// and consts
+    const_span: Option<Span>,
+}
+impl Context {
+    fn skip_expr(&mut self, e: &hir::Expr<'_>) -> bool {
+        self.expr_id.is_some() || self.const_span.map_or(false, |span| span.contains(e.span))
+    }
+
+    pub fn check_binary<'tcx>(
+        &mut self,
+        cx: &LateContext<'tcx>,
+        expr: &'tcx hir::Expr<'_>,
+        op: hir::BinOpKind,
+        l: &'tcx hir::Expr<'_>,
+        r: &'tcx hir::Expr<'_>,
+    ) {
+        if self.skip_expr(expr) {
+            return;
+        }
+        match op {
+            hir::BinOpKind::And
+            | hir::BinOpKind::Or
+            | hir::BinOpKind::BitAnd
+            | hir::BinOpKind::BitOr
+            | hir::BinOpKind::BitXor
+            | hir::BinOpKind::Eq
+            | hir::BinOpKind::Lt
+            | hir::BinOpKind::Le
+            | hir::BinOpKind::Ne
+            | hir::BinOpKind::Ge
+            | hir::BinOpKind::Gt => return,
+            _ => (),
+        }
+
+        let (l_ty, r_ty) = (cx.typeck_results().expr_ty(l), cx.typeck_results().expr_ty(r));
+        if l_ty.peel_refs().is_integral() && r_ty.peel_refs().is_integral() {
+            match op {
+                hir::BinOpKind::Div | hir::BinOpKind::Rem => match &r.kind {
+                    hir::ExprKind::Lit(_lit) => (),
+                    hir::ExprKind::Unary(hir::UnOp::Neg, expr) => {
+                        if let hir::ExprKind::Lit(lit) = &expr.kind {
+                            if let rustc_ast::ast::LitKind::Int(1, _) = lit.node {
+                                span_lint(cx, INTEGER_ARITHMETIC, expr.span, "integer arithmetic detected");
+                                self.expr_id = Some(expr.hir_id);
+                            }
+                        }
+                    },
+                    _ => {
+                        span_lint(cx, INTEGER_ARITHMETIC, expr.span, "integer arithmetic detected");
+                        self.expr_id = Some(expr.hir_id);
+                    },
+                },
+                _ => {
+                    span_lint(cx, INTEGER_ARITHMETIC, expr.span, "integer arithmetic detected");
+                    self.expr_id = Some(expr.hir_id);
+                },
+            }
+        } else if r_ty.peel_refs().is_floating_point() && r_ty.peel_refs().is_floating_point() {
+            span_lint(cx, FLOAT_ARITHMETIC, expr.span, "floating-point arithmetic detected");
+            self.expr_id = Some(expr.hir_id);
+        }
+    }
+
+    pub fn check_negate<'tcx>(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, arg: &'tcx hir::Expr<'_>) {
+        if self.skip_expr(expr) {
+            return;
+        }
+        let ty = cx.typeck_results().expr_ty(arg);
+        if constant_simple(cx, cx.typeck_results(), expr).is_none() {
+            if ty.is_integral() {
+                span_lint(cx, INTEGER_ARITHMETIC, expr.span, "integer arithmetic detected");
+                self.expr_id = Some(expr.hir_id);
+            } else if ty.is_floating_point() {
+                span_lint(cx, FLOAT_ARITHMETIC, expr.span, "floating-point arithmetic detected");
+                self.expr_id = Some(expr.hir_id);
+            }
+        }
+    }
+
+    pub fn expr_post(&mut self, id: hir::HirId) {
+        if Some(id) == self.expr_id {
+            self.expr_id = None;
+        }
+    }
+
+    pub fn enter_body(&mut self, cx: &LateContext<'_>, body: &hir::Body<'_>) {
+        let body_owner = cx.tcx.hir().body_owner_def_id(body.id());
+
+        match cx.tcx.hir().body_owner_kind(body_owner) {
+            hir::BodyOwnerKind::Static(_) | hir::BodyOwnerKind::Const => {
+                let body_span = cx.tcx.def_span(body_owner);
+
+                if let Some(span) = self.const_span {
+                    if span.contains(body_span) {
+                        return;
+                    }
+                }
+                self.const_span = Some(body_span);
+            },
+            hir::BodyOwnerKind::Fn | hir::BodyOwnerKind::Closure => (),
+        }
+    }
+
+    pub fn body_post(&mut self, cx: &LateContext<'_>, body: &hir::Body<'_>) {
+        let body_owner = cx.tcx.hir().body_owner(body.id());
+        let body_span = cx.tcx.hir().span(body_owner);
+
+        if let Some(span) = self.const_span {
+            if span.contains(body_span) {
+                return;
+            }
+        }
+        self.const_span = None;
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 751131b4acce37d0d4d62edd1eb831143c8fa46f Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Tue, 31 May 2022 21:57:32 -0400
Subject: Move `AssignOps` into `Operators` lint pass

---
 clippy_lints/src/assign_ops.rs                     | 235 ---------------------
 clippy_lints/src/lib.register_all.rs               |   4 +-
 clippy_lints/src/lib.register_lints.rs             |   4 +-
 clippy_lints/src/lib.register_style.rs             |   2 +-
 clippy_lints/src/lib.register_suspicious.rs        |   2 +-
 clippy_lints/src/lib.rs                            |   2 -
 clippy_lints/src/operators/assign_op_pattern.rs    | 101 +++++++++
 .../src/operators/misrefactored_assign_op.rs       |  84 ++++++++
 clippy_lints/src/operators/mod.rs                  |  70 ++++++
 9 files changed, 261 insertions(+), 243 deletions(-)
 delete mode 100644 clippy_lints/src/assign_ops.rs
 create mode 100644 clippy_lints/src/operators/assign_op_pattern.rs
 create mode 100644 clippy_lints/src/operators/misrefactored_assign_op.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/assign_ops.rs b/clippy_lints/src/assign_ops.rs
deleted file mode 100644
index f81da2d4223..00000000000
--- a/clippy_lints/src/assign_ops.rs
+++ /dev/null
@@ -1,235 +0,0 @@
-use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::source::snippet_opt;
-use clippy_utils::ty::implements_trait;
-use clippy_utils::{binop_traits, sugg};
-use clippy_utils::{eq_expr_value, trait_ref_of_method};
-use if_chain::if_chain;
-use rustc_errors::Applicability;
-use rustc_hir as hir;
-use rustc_hir::intravisit::{walk_expr, Visitor};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for `a = a op b` or `a = b commutative_op a`
-    /// patterns.
-    ///
-    /// ### Why is this bad?
-    /// These can be written as the shorter `a op= b`.
-    ///
-    /// ### Known problems
-    /// While forbidden by the spec, `OpAssign` traits may have
-    /// implementations that differ from the regular `Op` impl.
-    ///
-    /// ### Example
-    /// ```rust
-    /// let mut a = 5;
-    /// let b = 0;
-    /// // ...
-    ///
-    /// a = a + b;
-    /// ```
-    ///
-    /// Use instead:
-    /// ```rust
-    /// let mut a = 5;
-    /// let b = 0;
-    /// // ...
-    ///
-    /// a += b;
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub ASSIGN_OP_PATTERN,
-    style,
-    "assigning the result of an operation on a variable to that same variable"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for `a op= a op b` or `a op= b op a` patterns.
-    ///
-    /// ### Why is this bad?
-    /// Most likely these are bugs where one meant to write `a
-    /// op= b`.
-    ///
-    /// ### Known problems
-    /// Clippy cannot know for sure if `a op= a op b` should have
-    /// been `a = a op a op b` or `a = a op b`/`a op= b`. Therefore, it suggests both.
-    /// If `a op= a op b` is really the correct behavior it should be
-    /// written as `a = a op a op b` as it's less confusing.
-    ///
-    /// ### Example
-    /// ```rust
-    /// let mut a = 5;
-    /// let b = 2;
-    /// // ...
-    /// a += a + b;
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub MISREFACTORED_ASSIGN_OP,
-    suspicious,
-    "having a variable on both sides of an assign op"
-}
-
-declare_lint_pass!(AssignOps => [ASSIGN_OP_PATTERN, MISREFACTORED_ASSIGN_OP]);
-
-impl<'tcx> LateLintPass<'tcx> for AssignOps {
-    #[allow(clippy::too_many_lines)]
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
-        match &expr.kind {
-            hir::ExprKind::AssignOp(op, lhs, rhs) => {
-                if let hir::ExprKind::Binary(binop, l, r) = &rhs.kind {
-                    if op.node != binop.node {
-                        return;
-                    }
-                    // lhs op= l op r
-                    if eq_expr_value(cx, lhs, l) {
-                        lint_misrefactored_assign_op(cx, expr, *op, rhs, lhs, r);
-                    }
-                    // lhs op= l commutative_op r
-                    if is_commutative(op.node) && eq_expr_value(cx, lhs, r) {
-                        lint_misrefactored_assign_op(cx, expr, *op, rhs, lhs, l);
-                    }
-                }
-            },
-            hir::ExprKind::Assign(assignee, e, _) => {
-                if let hir::ExprKind::Binary(op, l, r) = &e.kind {
-                    let lint = |assignee: &hir::Expr<'_>, rhs: &hir::Expr<'_>| {
-                        let ty = cx.typeck_results().expr_ty(assignee);
-                        let rty = cx.typeck_results().expr_ty(rhs);
-                        if_chain! {
-                            if let Some((_, lang_item)) = binop_traits(op.node);
-                            if let Ok(trait_id) = cx.tcx.lang_items().require(lang_item);
-                            let parent_fn = cx.tcx.hir().get_parent_item(e.hir_id);
-                            if trait_ref_of_method(cx, parent_fn)
-                                .map_or(true, |t| t.path.res.def_id() != trait_id);
-                            if implements_trait(cx, ty, trait_id, &[rty.into()]);
-                            then {
-                                span_lint_and_then(
-                                    cx,
-                                    ASSIGN_OP_PATTERN,
-                                    expr.span,
-                                    "manual implementation of an assign operation",
-                                    |diag| {
-                                        if let (Some(snip_a), Some(snip_r)) =
-                                            (snippet_opt(cx, assignee.span), snippet_opt(cx, rhs.span))
-                                        {
-                                            diag.span_suggestion(
-                                                expr.span,
-                                                "replace it with",
-                                                format!("{} {}= {}", snip_a, op.node.as_str(), snip_r),
-                                                Applicability::MachineApplicable,
-                                            );
-                                        }
-                                    },
-                                );
-                            }
-                        }
-                    };
-
-                    let mut visitor = ExprVisitor {
-                        assignee,
-                        counter: 0,
-                        cx,
-                    };
-
-                    walk_expr(&mut visitor, e);
-
-                    if visitor.counter == 1 {
-                        // a = a op b
-                        if eq_expr_value(cx, assignee, l) {
-                            lint(assignee, r);
-                        }
-                        // a = b commutative_op a
-                        // Limited to primitive type as these ops are know to be commutative
-                        if eq_expr_value(cx, assignee, r) && cx.typeck_results().expr_ty(assignee).is_primitive_ty() {
-                            match op.node {
-                                hir::BinOpKind::Add
-                                | hir::BinOpKind::Mul
-                                | hir::BinOpKind::And
-                                | hir::BinOpKind::Or
-                                | hir::BinOpKind::BitXor
-                                | hir::BinOpKind::BitAnd
-                                | hir::BinOpKind::BitOr => {
-                                    lint(assignee, l);
-                                },
-                                _ => {},
-                            }
-                        }
-                    }
-                }
-            },
-            _ => {},
-        }
-    }
-}
-
-fn lint_misrefactored_assign_op(
-    cx: &LateContext<'_>,
-    expr: &hir::Expr<'_>,
-    op: hir::BinOp,
-    rhs: &hir::Expr<'_>,
-    assignee: &hir::Expr<'_>,
-    rhs_other: &hir::Expr<'_>,
-) {
-    span_lint_and_then(
-        cx,
-        MISREFACTORED_ASSIGN_OP,
-        expr.span,
-        "variable appears on both sides of an assignment operation",
-        |diag| {
-            if let (Some(snip_a), Some(snip_r)) = (snippet_opt(cx, assignee.span), snippet_opt(cx, rhs_other.span)) {
-                let a = &sugg::Sugg::hir(cx, assignee, "..");
-                let r = &sugg::Sugg::hir(cx, rhs, "..");
-                let long = format!("{} = {}", snip_a, sugg::make_binop(op.node.into(), a, r));
-                diag.span_suggestion(
-                    expr.span,
-                    &format!(
-                        "did you mean `{} = {} {} {}` or `{}`? Consider replacing it with",
-                        snip_a,
-                        snip_a,
-                        op.node.as_str(),
-                        snip_r,
-                        long
-                    ),
-                    format!("{} {}= {}", snip_a, op.node.as_str(), snip_r),
-                    Applicability::MaybeIncorrect,
-                );
-                diag.span_suggestion(
-                    expr.span,
-                    "or",
-                    long,
-                    Applicability::MaybeIncorrect, // snippet
-                );
-            }
-        },
-    );
-}
-
-#[must_use]
-fn is_commutative(op: hir::BinOpKind) -> bool {
-    use rustc_hir::BinOpKind::{
-        Add, And, BitAnd, BitOr, BitXor, Div, Eq, Ge, Gt, Le, Lt, Mul, Ne, Or, Rem, Shl, Shr, Sub,
-    };
-    match op {
-        Add | Mul | And | Or | BitXor | BitAnd | BitOr | Eq | Ne => true,
-        Sub | Div | Rem | Shl | Shr | Lt | Le | Ge | Gt => false,
-    }
-}
-
-struct ExprVisitor<'a, 'tcx> {
-    assignee: &'a hir::Expr<'a>,
-    counter: u8,
-    cx: &'a LateContext<'tcx>,
-}
-
-impl<'a, 'tcx> Visitor<'tcx> for ExprVisitor<'a, 'tcx> {
-    fn visit_expr(&mut self, expr: &'tcx hir::Expr<'_>) {
-        if eq_expr_value(self.cx, self.assignee, expr) {
-            self.counter += 1;
-        }
-
-        walk_expr(self, expr);
-    }
-}
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 7728157d228..b43c11330f0 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -6,8 +6,6 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(almost_complete_letter_range::ALMOST_COMPLETE_LETTER_RANGE),
     LintId::of(approx_const::APPROX_CONSTANT),
     LintId::of(assertions_on_constants::ASSERTIONS_ON_CONSTANTS),
-    LintId::of(assign_ops::ASSIGN_OP_PATTERN),
-    LintId::of(assign_ops::MISREFACTORED_ASSIGN_OP),
     LintId::of(async_yields_async::ASYNC_YIELDS_ASYNC),
     LintId::of(attrs::BLANKET_CLIPPY_RESTRICTION_LINTS),
     LintId::of(attrs::DEPRECATED_CFG_ATTR),
@@ -260,6 +258,8 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(octal_escapes::OCTAL_ESCAPES),
     LintId::of(open_options::NONSENSICAL_OPEN_OPTIONS),
     LintId::of(operators::ABSURD_EXTREME_COMPARISONS),
+    LintId::of(operators::ASSIGN_OP_PATTERN),
+    LintId::of(operators::MISREFACTORED_ASSIGN_OP),
     LintId::of(option_env_unwrap::OPTION_ENV_UNWRAP),
     LintId::of(overflow_check_conditional::OVERFLOW_CHECK_CONDITIONAL),
     LintId::of(partialeq_ne_impl::PARTIALEQ_NE_IMPL),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 787ae1e79ec..231511d46b7 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -42,8 +42,6 @@ store.register_lints(&[
     asm_syntax::INLINE_ASM_X86_ATT_SYNTAX,
     asm_syntax::INLINE_ASM_X86_INTEL_SYNTAX,
     assertions_on_constants::ASSERTIONS_ON_CONSTANTS,
-    assign_ops::ASSIGN_OP_PATTERN,
-    assign_ops::MISREFACTORED_ASSIGN_OP,
     async_yields_async::ASYNC_YIELDS_ASYNC,
     attrs::ALLOW_ATTRIBUTES_WITHOUT_REASON,
     attrs::BLANKET_CLIPPY_RESTRICTION_LINTS,
@@ -435,8 +433,10 @@ store.register_lints(&[
     only_used_in_recursion::ONLY_USED_IN_RECURSION,
     open_options::NONSENSICAL_OPEN_OPTIONS,
     operators::ABSURD_EXTREME_COMPARISONS,
+    operators::ASSIGN_OP_PATTERN,
     operators::FLOAT_ARITHMETIC,
     operators::INTEGER_ARITHMETIC,
+    operators::MISREFACTORED_ASSIGN_OP,
     option_env_unwrap::OPTION_ENV_UNWRAP,
     option_if_let_else::OPTION_IF_LET_ELSE,
     overflow_check_conditional::OVERFLOW_CHECK_CONDITIONAL,
diff --git a/clippy_lints/src/lib.register_style.rs b/clippy_lints/src/lib.register_style.rs
index d52ec50e542..78df54a4fff 100644
--- a/clippy_lints/src/lib.register_style.rs
+++ b/clippy_lints/src/lib.register_style.rs
@@ -4,7 +4,6 @@
 
 store.register_group(true, "clippy::style", Some("clippy_style"), vec![
     LintId::of(assertions_on_constants::ASSERTIONS_ON_CONSTANTS),
-    LintId::of(assign_ops::ASSIGN_OP_PATTERN),
     LintId::of(blacklisted_name::BLACKLISTED_NAME),
     LintId::of(blocks_in_if_conditions::BLOCKS_IN_IF_CONDITIONS),
     LintId::of(bool_assert_comparison::BOOL_ASSERT_COMPARISON),
@@ -98,6 +97,7 @@ store.register_group(true, "clippy::style", Some("clippy_style"), vec![
     LintId::of(non_copy_const::BORROW_INTERIOR_MUTABLE_CONST),
     LintId::of(non_copy_const::DECLARE_INTERIOR_MUTABLE_CONST),
     LintId::of(non_expressive_names::JUST_UNDERSCORES_AND_DIGITS),
+    LintId::of(operators::ASSIGN_OP_PATTERN),
     LintId::of(ptr::CMP_NULL),
     LintId::of(ptr::PTR_ARG),
     LintId::of(ptr_eq::PTR_EQ),
diff --git a/clippy_lints/src/lib.register_suspicious.rs b/clippy_lints/src/lib.register_suspicious.rs
index 7b13713c36e..4ee89b7bec5 100644
--- a/clippy_lints/src/lib.register_suspicious.rs
+++ b/clippy_lints/src/lib.register_suspicious.rs
@@ -4,7 +4,6 @@
 
 store.register_group(true, "clippy::suspicious", Some("clippy_suspicious"), vec![
     LintId::of(almost_complete_letter_range::ALMOST_COMPLETE_LETTER_RANGE),
-    LintId::of(assign_ops::MISREFACTORED_ASSIGN_OP),
     LintId::of(attrs::BLANKET_CLIPPY_RESTRICTION_LINTS),
     LintId::of(await_holding_invalid::AWAIT_HOLDING_INVALID_TYPE),
     LintId::of(await_holding_invalid::AWAIT_HOLDING_LOCK),
@@ -29,6 +28,7 @@ store.register_group(true, "clippy::suspicious", Some("clippy_suspicious"), vec!
     LintId::of(methods::SUSPICIOUS_MAP),
     LintId::of(mut_key::MUTABLE_KEY_TYPE),
     LintId::of(octal_escapes::OCTAL_ESCAPES),
+    LintId::of(operators::MISREFACTORED_ASSIGN_OP),
     LintId::of(rc_clone_in_vec_init::RC_CLONE_IN_VEC_INIT),
     LintId::of(suspicious_trait_impl::SUSPICIOUS_ARITHMETIC_IMPL),
     LintId::of(suspicious_trait_impl::SUSPICIOUS_OP_ASSIGN_IMPL),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index f1d28201309..0f9e3b06233 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -174,7 +174,6 @@ mod as_conversions;
 mod as_underscore;
 mod asm_syntax;
 mod assertions_on_constants;
-mod assign_ops;
 mod async_yields_async;
 mod attrs;
 mod await_holding_invalid;
@@ -704,7 +703,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(move || Box::new(doc::DocMarkdown::new(doc_valid_idents.clone())));
     store.register_late_pass(|| Box::new(neg_multiply::NegMultiply));
     store.register_late_pass(|| Box::new(mem_forget::MemForget));
-    store.register_late_pass(|| Box::new(assign_ops::AssignOps));
     store.register_late_pass(|| Box::new(let_if_seq::LetIfSeq));
     store.register_late_pass(|| Box::new(mixed_read_write_in_expression::EvalOrderDependence));
     store.register_late_pass(|| Box::new(missing_doc::MissingDoc::new()));
diff --git a/clippy_lints/src/operators/assign_op_pattern.rs b/clippy_lints/src/operators/assign_op_pattern.rs
new file mode 100644
index 00000000000..979e0a66707
--- /dev/null
+++ b/clippy_lints/src/operators/assign_op_pattern.rs
@@ -0,0 +1,101 @@
+use clippy_utils::binop_traits;
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::source::snippet_opt;
+use clippy_utils::ty::implements_trait;
+use clippy_utils::{eq_expr_value, trait_ref_of_method};
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir as hir;
+use rustc_hir::intravisit::{walk_expr, Visitor};
+use rustc_lint::LateContext;
+
+use super::ASSIGN_OP_PATTERN;
+
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx hir::Expr<'_>,
+    assignee: &'tcx hir::Expr<'_>,
+    e: &'tcx hir::Expr<'_>,
+) {
+    if let hir::ExprKind::Binary(op, l, r) = &e.kind {
+        let lint = |assignee: &hir::Expr<'_>, rhs: &hir::Expr<'_>| {
+            let ty = cx.typeck_results().expr_ty(assignee);
+            let rty = cx.typeck_results().expr_ty(rhs);
+            if_chain! {
+                if let Some((_, lang_item)) = binop_traits(op.node);
+                if let Ok(trait_id) = cx.tcx.lang_items().require(lang_item);
+                let parent_fn = cx.tcx.hir().get_parent_item(e.hir_id);
+                if trait_ref_of_method(cx, parent_fn)
+                    .map_or(true, |t| t.path.res.def_id() != trait_id);
+                if implements_trait(cx, ty, trait_id, &[rty.into()]);
+                then {
+                    span_lint_and_then(
+                        cx,
+                        ASSIGN_OP_PATTERN,
+                        expr.span,
+                        "manual implementation of an assign operation",
+                        |diag| {
+                            if let (Some(snip_a), Some(snip_r)) =
+                                (snippet_opt(cx, assignee.span), snippet_opt(cx, rhs.span))
+                            {
+                                diag.span_suggestion(
+                                    expr.span,
+                                    "replace it with",
+                                    format!("{} {}= {}", snip_a, op.node.as_str(), snip_r),
+                                    Applicability::MachineApplicable,
+                                );
+                            }
+                        },
+                    );
+                }
+            }
+        };
+
+        let mut visitor = ExprVisitor {
+            assignee,
+            counter: 0,
+            cx,
+        };
+
+        walk_expr(&mut visitor, e);
+
+        if visitor.counter == 1 {
+            // a = a op b
+            if eq_expr_value(cx, assignee, l) {
+                lint(assignee, r);
+            }
+            // a = b commutative_op a
+            // Limited to primitive type as these ops are know to be commutative
+            if eq_expr_value(cx, assignee, r) && cx.typeck_results().expr_ty(assignee).is_primitive_ty() {
+                match op.node {
+                    hir::BinOpKind::Add
+                    | hir::BinOpKind::Mul
+                    | hir::BinOpKind::And
+                    | hir::BinOpKind::Or
+                    | hir::BinOpKind::BitXor
+                    | hir::BinOpKind::BitAnd
+                    | hir::BinOpKind::BitOr => {
+                        lint(assignee, l);
+                    },
+                    _ => {},
+                }
+            }
+        }
+    }
+}
+
+struct ExprVisitor<'a, 'tcx> {
+    assignee: &'a hir::Expr<'a>,
+    counter: u8,
+    cx: &'a LateContext<'tcx>,
+}
+
+impl<'a, 'tcx> Visitor<'tcx> for ExprVisitor<'a, 'tcx> {
+    fn visit_expr(&mut self, expr: &'tcx hir::Expr<'_>) {
+        if eq_expr_value(self.cx, self.assignee, expr) {
+            self.counter += 1;
+        }
+
+        walk_expr(self, expr);
+    }
+}
diff --git a/clippy_lints/src/operators/misrefactored_assign_op.rs b/clippy_lints/src/operators/misrefactored_assign_op.rs
new file mode 100644
index 00000000000..0024384d927
--- /dev/null
+++ b/clippy_lints/src/operators/misrefactored_assign_op.rs
@@ -0,0 +1,84 @@
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::eq_expr_value;
+use clippy_utils::source::snippet_opt;
+use clippy_utils::sugg;
+use rustc_errors::Applicability;
+use rustc_hir as hir;
+use rustc_lint::LateContext;
+
+use super::MISREFACTORED_ASSIGN_OP;
+
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx hir::Expr<'_>,
+    op: hir::BinOpKind,
+    lhs: &'tcx hir::Expr<'_>,
+    rhs: &'tcx hir::Expr<'_>,
+) {
+    if let hir::ExprKind::Binary(binop, l, r) = &rhs.kind {
+        if op != binop.node {
+            return;
+        }
+        // lhs op= l op r
+        if eq_expr_value(cx, lhs, l) {
+            lint_misrefactored_assign_op(cx, expr, op, rhs, lhs, r);
+        }
+        // lhs op= l commutative_op r
+        if is_commutative(op) && eq_expr_value(cx, lhs, r) {
+            lint_misrefactored_assign_op(cx, expr, op, rhs, lhs, l);
+        }
+    }
+}
+
+fn lint_misrefactored_assign_op(
+    cx: &LateContext<'_>,
+    expr: &hir::Expr<'_>,
+    op: hir::BinOpKind,
+    rhs: &hir::Expr<'_>,
+    assignee: &hir::Expr<'_>,
+    rhs_other: &hir::Expr<'_>,
+) {
+    span_lint_and_then(
+        cx,
+        MISREFACTORED_ASSIGN_OP,
+        expr.span,
+        "variable appears on both sides of an assignment operation",
+        |diag| {
+            if let (Some(snip_a), Some(snip_r)) = (snippet_opt(cx, assignee.span), snippet_opt(cx, rhs_other.span)) {
+                let a = &sugg::Sugg::hir(cx, assignee, "..");
+                let r = &sugg::Sugg::hir(cx, rhs, "..");
+                let long = format!("{} = {}", snip_a, sugg::make_binop(op.into(), a, r));
+                diag.span_suggestion(
+                    expr.span,
+                    &format!(
+                        "did you mean `{} = {} {} {}` or `{}`? Consider replacing it with",
+                        snip_a,
+                        snip_a,
+                        op.as_str(),
+                        snip_r,
+                        long
+                    ),
+                    format!("{} {}= {}", snip_a, op.as_str(), snip_r),
+                    Applicability::MaybeIncorrect,
+                );
+                diag.span_suggestion(
+                    expr.span,
+                    "or",
+                    long,
+                    Applicability::MaybeIncorrect, // snippet
+                );
+            }
+        },
+    );
+}
+
+#[must_use]
+fn is_commutative(op: hir::BinOpKind) -> bool {
+    use rustc_hir::BinOpKind::{
+        Add, And, BitAnd, BitOr, BitXor, Div, Eq, Ge, Gt, Le, Lt, Mul, Ne, Or, Rem, Shl, Shr, Sub,
+    };
+    match op {
+        Add | Mul | And | Or | BitXor | BitAnd | BitOr | Eq | Ne => true,
+        Sub | Div | Rem | Shl | Shr | Lt | Le | Ge | Gt => false,
+    }
+}
diff --git a/clippy_lints/src/operators/mod.rs b/clippy_lints/src/operators/mod.rs
index a7495f042da..c1d038aa2b1 100644
--- a/clippy_lints/src/operators/mod.rs
+++ b/clippy_lints/src/operators/mod.rs
@@ -3,6 +3,8 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 
 mod absurd_extreme_comparisons;
+mod assign_op_pattern;
+mod misrefactored_assign_op;
 mod numeric_arithmetic;
 
 declare_clippy_lint! {
@@ -82,6 +84,68 @@ declare_clippy_lint! {
     "any floating-point arithmetic statement"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `a = a op b` or `a = b commutative_op a`
+    /// patterns.
+    ///
+    /// ### Why is this bad?
+    /// These can be written as the shorter `a op= b`.
+    ///
+    /// ### Known problems
+    /// While forbidden by the spec, `OpAssign` traits may have
+    /// implementations that differ from the regular `Op` impl.
+    ///
+    /// ### Example
+    /// ```rust
+    /// let mut a = 5;
+    /// let b = 0;
+    /// // ...
+    ///
+    /// a = a + b;
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust
+    /// let mut a = 5;
+    /// let b = 0;
+    /// // ...
+    ///
+    /// a += b;
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub ASSIGN_OP_PATTERN,
+    style,
+    "assigning the result of an operation on a variable to that same variable"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `a op= a op b` or `a op= b op a` patterns.
+    ///
+    /// ### Why is this bad?
+    /// Most likely these are bugs where one meant to write `a
+    /// op= b`.
+    ///
+    /// ### Known problems
+    /// Clippy cannot know for sure if `a op= a op b` should have
+    /// been `a = a op a op b` or `a = a op b`/`a op= b`. Therefore, it suggests both.
+    /// If `a op= a op b` is really the correct behavior it should be
+    /// written as `a = a op a op b` as it's less confusing.
+    ///
+    /// ### Example
+    /// ```rust
+    /// let mut a = 5;
+    /// let b = 2;
+    /// // ...
+    /// a += a + b;
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub MISREFACTORED_ASSIGN_OP,
+    suspicious,
+    "having a variable on both sides of an assign op"
+}
+
 #[derive(Default)]
 pub struct Operators {
     arithmetic_context: numeric_arithmetic::Context,
@@ -90,6 +154,8 @@ impl_lint_pass!(Operators => [
     ABSURD_EXTREME_COMPARISONS,
     INTEGER_ARITHMETIC,
     FLOAT_ARITHMETIC,
+    ASSIGN_OP_PATTERN,
+    MISREFACTORED_ASSIGN_OP,
 ]);
 impl<'tcx> LateLintPass<'tcx> for Operators {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
@@ -102,6 +168,10 @@ impl<'tcx> LateLintPass<'tcx> for Operators {
             },
             ExprKind::AssignOp(op, lhs, rhs) => {
                 self.arithmetic_context.check_binary(cx, e, op.node, lhs, rhs);
+                misrefactored_assign_op::check(cx, e, op.node, lhs, rhs);
+            },
+            ExprKind::Assign(lhs, rhs, _) => {
+                assign_op_pattern::check(cx, e, lhs, rhs);
             },
             ExprKind::Unary(op, arg) => {
                 if op == UnOp::Neg {
-- 
cgit 1.4.1-3-g733a5


From 68a7fd22ad39e1d7a50f2fd052696517e719dd18 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Tue, 31 May 2022 22:14:43 -0400
Subject: Move `BitMask` into `Operators` lint pass

---
 clippy_lints/src/bit_mask.rs                   | 335 -------------------------
 clippy_lints/src/lib.register_all.rs           |   4 +-
 clippy_lints/src/lib.register_correctness.rs   |   4 +-
 clippy_lints/src/lib.register_lints.rs         |   6 +-
 clippy_lints/src/lib.register_pedantic.rs      |   2 +-
 clippy_lints/src/lib.rs                        |   6 +-
 clippy_lints/src/operators/bit_mask.rs         | 197 +++++++++++++++
 clippy_lints/src/operators/mod.rs              | 111 +++++++-
 clippy_lints/src/operators/verbose_bit_mask.rs |  44 ++++
 9 files changed, 361 insertions(+), 348 deletions(-)
 delete mode 100644 clippy_lints/src/bit_mask.rs
 create mode 100644 clippy_lints/src/operators/bit_mask.rs
 create mode 100644 clippy_lints/src/operators/verbose_bit_mask.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/bit_mask.rs b/clippy_lints/src/bit_mask.rs
deleted file mode 100644
index dc7e400fdc2..00000000000
--- a/clippy_lints/src/bit_mask.rs
+++ /dev/null
@@ -1,335 +0,0 @@
-use clippy_utils::consts::{constant, Constant};
-use clippy_utils::diagnostics::{span_lint, span_lint_and_then};
-use clippy_utils::sugg::Sugg;
-use rustc_ast::ast::LitKind;
-use rustc_errors::Applicability;
-use rustc_hir::{BinOpKind, Expr, ExprKind};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::source_map::Span;
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for incompatible bit masks in comparisons.
-    ///
-    /// The formula for detecting if an expression of the type `_ <bit_op> m
-    /// <cmp_op> c` (where `<bit_op>` is one of {`&`, `|`} and `<cmp_op>` is one of
-    /// {`!=`, `>=`, `>`, `!=`, `>=`, `>`}) can be determined from the following
-    /// table:
-    ///
-    /// |Comparison  |Bit Op|Example      |is always|Formula               |
-    /// |------------|------|-------------|---------|----------------------|
-    /// |`==` or `!=`| `&`  |`x & 2 == 3` |`false`  |`c & m != c`          |
-    /// |`<`  or `>=`| `&`  |`x & 2 < 3`  |`true`   |`m < c`               |
-    /// |`>`  or `<=`| `&`  |`x & 1 > 1`  |`false`  |`m <= c`              |
-    /// |`==` or `!=`| `\|` |`x \| 1 == 0`|`false`  |`c \| m != c`         |
-    /// |`<`  or `>=`| `\|` |`x \| 1 < 1` |`false`  |`m >= c`              |
-    /// |`<=` or `>` | `\|` |`x \| 1 > 0` |`true`   |`m > c`               |
-    ///
-    /// ### Why is this bad?
-    /// If the bits that the comparison cares about are always
-    /// set to zero or one by the bit mask, the comparison is constant `true` or
-    /// `false` (depending on mask, compared value, and operators).
-    ///
-    /// So the code is actively misleading, and the only reason someone would write
-    /// this intentionally is to win an underhanded Rust contest or create a
-    /// test-case for this lint.
-    ///
-    /// ### Example
-    /// ```rust
-    /// # let x = 1;
-    /// if (x & 1 == 2) { }
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub BAD_BIT_MASK,
-    correctness,
-    "expressions of the form `_ & mask == select` that will only ever return `true` or `false`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for bit masks in comparisons which can be removed
-    /// without changing the outcome. The basic structure can be seen in the
-    /// following table:
-    ///
-    /// |Comparison| Bit Op   |Example     |equals |
-    /// |----------|----------|------------|-------|
-    /// |`>` / `<=`|`\|` / `^`|`x \| 2 > 3`|`x > 3`|
-    /// |`<` / `>=`|`\|` / `^`|`x ^ 1 < 4` |`x < 4`|
-    ///
-    /// ### Why is this bad?
-    /// Not equally evil as [`bad_bit_mask`](#bad_bit_mask),
-    /// but still a bit misleading, because the bit mask is ineffective.
-    ///
-    /// ### Known problems
-    /// False negatives: This lint will only match instances
-    /// where we have figured out the math (which is for a power-of-two compared
-    /// value). This means things like `x | 1 >= 7` (which would be better written
-    /// as `x >= 6`) will not be reported (but bit masks like this are fairly
-    /// uncommon).
-    ///
-    /// ### Example
-    /// ```rust
-    /// # let x = 1;
-    /// if (x | 1 > 3) {  }
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub INEFFECTIVE_BIT_MASK,
-    correctness,
-    "expressions where a bit mask will be rendered useless by a comparison, e.g., `(x | 1) > 2`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for bit masks that can be replaced by a call
-    /// to `trailing_zeros`
-    ///
-    /// ### Why is this bad?
-    /// `x.trailing_zeros() > 4` is much clearer than `x & 15
-    /// == 0`
-    ///
-    /// ### Known problems
-    /// llvm generates better code for `x & 15 == 0` on x86
-    ///
-    /// ### Example
-    /// ```rust
-    /// # let x = 1;
-    /// if x & 0b1111 == 0 { }
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub VERBOSE_BIT_MASK,
-    pedantic,
-    "expressions where a bit mask is less readable than the corresponding method call"
-}
-
-#[derive(Copy, Clone)]
-pub struct BitMask {
-    verbose_bit_mask_threshold: u64,
-}
-
-impl BitMask {
-    #[must_use]
-    pub fn new(verbose_bit_mask_threshold: u64) -> Self {
-        Self {
-            verbose_bit_mask_threshold,
-        }
-    }
-}
-
-impl_lint_pass!(BitMask => [BAD_BIT_MASK, INEFFECTIVE_BIT_MASK, VERBOSE_BIT_MASK]);
-
-impl<'tcx> LateLintPass<'tcx> for BitMask {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
-        if let ExprKind::Binary(cmp, left, right) = &e.kind {
-            if cmp.node.is_comparison() {
-                if let Some(cmp_opt) = fetch_int_literal(cx, right) {
-                    check_compare(cx, left, cmp.node, cmp_opt, e.span);
-                } else if let Some(cmp_val) = fetch_int_literal(cx, left) {
-                    check_compare(cx, right, invert_cmp(cmp.node), cmp_val, e.span);
-                }
-            }
-        }
-
-        if let ExprKind::Binary(op, left, right) = &e.kind
-            && BinOpKind::Eq == op.node
-            && let ExprKind::Binary(op1, left1, right1) = &left.kind
-            && BinOpKind::BitAnd == op1.node
-            && let ExprKind::Lit(lit) = &right1.kind
-            && let LitKind::Int(n, _) = lit.node
-            && let ExprKind::Lit(lit1) = &right.kind
-            && let LitKind::Int(0, _) = lit1.node
-            && n.leading_zeros() == n.count_zeros()
-            && n > u128::from(self.verbose_bit_mask_threshold)
-        {
-            span_lint_and_then(
-                cx,
-                VERBOSE_BIT_MASK,
-                e.span,
-                "bit mask could be simplified with a call to `trailing_zeros`",
-                |diag| {
-                    let sugg = Sugg::hir(cx, left1, "...").maybe_par();
-                    diag.span_suggestion(
-                        e.span,
-                        "try",
-                        format!("{}.trailing_zeros() >= {}", sugg, n.count_ones()),
-                        Applicability::MaybeIncorrect,
-                    );
-                },
-            );
-        }
-    }
-}
-
-#[must_use]
-fn invert_cmp(cmp: BinOpKind) -> BinOpKind {
-    match cmp {
-        BinOpKind::Eq => BinOpKind::Eq,
-        BinOpKind::Ne => BinOpKind::Ne,
-        BinOpKind::Lt => BinOpKind::Gt,
-        BinOpKind::Gt => BinOpKind::Lt,
-        BinOpKind::Le => BinOpKind::Ge,
-        BinOpKind::Ge => BinOpKind::Le,
-        _ => BinOpKind::Or, // Dummy
-    }
-}
-
-fn check_compare(cx: &LateContext<'_>, bit_op: &Expr<'_>, cmp_op: BinOpKind, cmp_value: u128, span: Span) {
-    if let ExprKind::Binary(op, left, right) = &bit_op.kind {
-        if op.node != BinOpKind::BitAnd && op.node != BinOpKind::BitOr {
-            return;
-        }
-        fetch_int_literal(cx, right)
-            .or_else(|| fetch_int_literal(cx, left))
-            .map_or((), |mask| check_bit_mask(cx, op.node, cmp_op, mask, cmp_value, span));
-    }
-}
-
-#[allow(clippy::too_many_lines)]
-fn check_bit_mask(
-    cx: &LateContext<'_>,
-    bit_op: BinOpKind,
-    cmp_op: BinOpKind,
-    mask_value: u128,
-    cmp_value: u128,
-    span: Span,
-) {
-    match cmp_op {
-        BinOpKind::Eq | BinOpKind::Ne => match bit_op {
-            BinOpKind::BitAnd => {
-                if mask_value & cmp_value != cmp_value {
-                    if cmp_value != 0 {
-                        span_lint(
-                            cx,
-                            BAD_BIT_MASK,
-                            span,
-                            &format!(
-                                "incompatible bit mask: `_ & {}` can never be equal to `{}`",
-                                mask_value, cmp_value
-                            ),
-                        );
-                    }
-                } else if mask_value == 0 {
-                    span_lint(cx, BAD_BIT_MASK, span, "&-masking with zero");
-                }
-            },
-            BinOpKind::BitOr => {
-                if mask_value | cmp_value != cmp_value {
-                    span_lint(
-                        cx,
-                        BAD_BIT_MASK,
-                        span,
-                        &format!(
-                            "incompatible bit mask: `_ | {}` can never be equal to `{}`",
-                            mask_value, cmp_value
-                        ),
-                    );
-                }
-            },
-            _ => (),
-        },
-        BinOpKind::Lt | BinOpKind::Ge => match bit_op {
-            BinOpKind::BitAnd => {
-                if mask_value < cmp_value {
-                    span_lint(
-                        cx,
-                        BAD_BIT_MASK,
-                        span,
-                        &format!(
-                            "incompatible bit mask: `_ & {}` will always be lower than `{}`",
-                            mask_value, cmp_value
-                        ),
-                    );
-                } else if mask_value == 0 {
-                    span_lint(cx, BAD_BIT_MASK, span, "&-masking with zero");
-                }
-            },
-            BinOpKind::BitOr => {
-                if mask_value >= cmp_value {
-                    span_lint(
-                        cx,
-                        BAD_BIT_MASK,
-                        span,
-                        &format!(
-                            "incompatible bit mask: `_ | {}` will never be lower than `{}`",
-                            mask_value, cmp_value
-                        ),
-                    );
-                } else {
-                    check_ineffective_lt(cx, span, mask_value, cmp_value, "|");
-                }
-            },
-            BinOpKind::BitXor => check_ineffective_lt(cx, span, mask_value, cmp_value, "^"),
-            _ => (),
-        },
-        BinOpKind::Le | BinOpKind::Gt => match bit_op {
-            BinOpKind::BitAnd => {
-                if mask_value <= cmp_value {
-                    span_lint(
-                        cx,
-                        BAD_BIT_MASK,
-                        span,
-                        &format!(
-                            "incompatible bit mask: `_ & {}` will never be higher than `{}`",
-                            mask_value, cmp_value
-                        ),
-                    );
-                } else if mask_value == 0 {
-                    span_lint(cx, BAD_BIT_MASK, span, "&-masking with zero");
-                }
-            },
-            BinOpKind::BitOr => {
-                if mask_value > cmp_value {
-                    span_lint(
-                        cx,
-                        BAD_BIT_MASK,
-                        span,
-                        &format!(
-                            "incompatible bit mask: `_ | {}` will always be higher than `{}`",
-                            mask_value, cmp_value
-                        ),
-                    );
-                } else {
-                    check_ineffective_gt(cx, span, mask_value, cmp_value, "|");
-                }
-            },
-            BinOpKind::BitXor => check_ineffective_gt(cx, span, mask_value, cmp_value, "^"),
-            _ => (),
-        },
-        _ => (),
-    }
-}
-
-fn check_ineffective_lt(cx: &LateContext<'_>, span: Span, m: u128, c: u128, op: &str) {
-    if c.is_power_of_two() && m < c {
-        span_lint(
-            cx,
-            INEFFECTIVE_BIT_MASK,
-            span,
-            &format!(
-                "ineffective bit mask: `x {} {}` compared to `{}`, is the same as x compared directly",
-                op, m, c
-            ),
-        );
-    }
-}
-
-fn check_ineffective_gt(cx: &LateContext<'_>, span: Span, m: u128, c: u128, op: &str) {
-    if (c + 1).is_power_of_two() && m <= c {
-        span_lint(
-            cx,
-            INEFFECTIVE_BIT_MASK,
-            span,
-            &format!(
-                "ineffective bit mask: `x {} {}` compared to `{}`, is the same as x compared directly",
-                op, m, c
-            ),
-        );
-    }
-}
-
-fn fetch_int_literal(cx: &LateContext<'_>, lit: &Expr<'_>) -> Option<u128> {
-    match constant(cx, cx.typeck_results(), lit)?.0 {
-        Constant::Int(n) => Some(n),
-        _ => None,
-    }
-}
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index b43c11330f0..ccb5357b86e 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -15,8 +15,6 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(await_holding_invalid::AWAIT_HOLDING_INVALID_TYPE),
     LintId::of(await_holding_invalid::AWAIT_HOLDING_LOCK),
     LintId::of(await_holding_invalid::AWAIT_HOLDING_REFCELL_REF),
-    LintId::of(bit_mask::BAD_BIT_MASK),
-    LintId::of(bit_mask::INEFFECTIVE_BIT_MASK),
     LintId::of(blacklisted_name::BLACKLISTED_NAME),
     LintId::of(blocks_in_if_conditions::BLOCKS_IN_IF_CONDITIONS),
     LintId::of(bool_assert_comparison::BOOL_ASSERT_COMPARISON),
@@ -259,6 +257,8 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(open_options::NONSENSICAL_OPEN_OPTIONS),
     LintId::of(operators::ABSURD_EXTREME_COMPARISONS),
     LintId::of(operators::ASSIGN_OP_PATTERN),
+    LintId::of(operators::BAD_BIT_MASK),
+    LintId::of(operators::INEFFECTIVE_BIT_MASK),
     LintId::of(operators::MISREFACTORED_ASSIGN_OP),
     LintId::of(option_env_unwrap::OPTION_ENV_UNWRAP),
     LintId::of(overflow_check_conditional::OVERFLOW_CHECK_CONDITIONAL),
diff --git a/clippy_lints/src/lib.register_correctness.rs b/clippy_lints/src/lib.register_correctness.rs
index 26852445fdc..76286e93493 100644
--- a/clippy_lints/src/lib.register_correctness.rs
+++ b/clippy_lints/src/lib.register_correctness.rs
@@ -8,8 +8,6 @@ store.register_group(true, "clippy::correctness", Some("clippy_correctness"), ve
     LintId::of(attrs::DEPRECATED_SEMVER),
     LintId::of(attrs::MISMATCHED_TARGET_OS),
     LintId::of(attrs::USELESS_ATTRIBUTE),
-    LintId::of(bit_mask::BAD_BIT_MASK),
-    LintId::of(bit_mask::INEFFECTIVE_BIT_MASK),
     LintId::of(booleans::LOGIC_BUG),
     LintId::of(casts::CAST_REF_TO_MUT),
     LintId::of(casts::CAST_SLICE_DIFFERENT_SIZES),
@@ -51,6 +49,8 @@ store.register_group(true, "clippy::correctness", Some("clippy_correctness"), ve
     LintId::of(non_octal_unix_permissions::NON_OCTAL_UNIX_PERMISSIONS),
     LintId::of(open_options::NONSENSICAL_OPEN_OPTIONS),
     LintId::of(operators::ABSURD_EXTREME_COMPARISONS),
+    LintId::of(operators::BAD_BIT_MASK),
+    LintId::of(operators::INEFFECTIVE_BIT_MASK),
     LintId::of(option_env_unwrap::OPTION_ENV_UNWRAP),
     LintId::of(ptr::INVALID_NULL_PTR_USAGE),
     LintId::of(ptr::MUT_FROM_REF),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 231511d46b7..1bcba0bc988 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -54,9 +54,6 @@ store.register_lints(&[
     await_holding_invalid::AWAIT_HOLDING_INVALID_TYPE,
     await_holding_invalid::AWAIT_HOLDING_LOCK,
     await_holding_invalid::AWAIT_HOLDING_REFCELL_REF,
-    bit_mask::BAD_BIT_MASK,
-    bit_mask::INEFFECTIVE_BIT_MASK,
-    bit_mask::VERBOSE_BIT_MASK,
     blacklisted_name::BLACKLISTED_NAME,
     blocks_in_if_conditions::BLOCKS_IN_IF_CONDITIONS,
     bool_assert_comparison::BOOL_ASSERT_COMPARISON,
@@ -434,9 +431,12 @@ store.register_lints(&[
     open_options::NONSENSICAL_OPEN_OPTIONS,
     operators::ABSURD_EXTREME_COMPARISONS,
     operators::ASSIGN_OP_PATTERN,
+    operators::BAD_BIT_MASK,
     operators::FLOAT_ARITHMETIC,
+    operators::INEFFECTIVE_BIT_MASK,
     operators::INTEGER_ARITHMETIC,
     operators::MISREFACTORED_ASSIGN_OP,
+    operators::VERBOSE_BIT_MASK,
     option_env_unwrap::OPTION_ENV_UNWRAP,
     option_if_let_else::OPTION_IF_LET_ELSE,
     overflow_check_conditional::OVERFLOW_CHECK_CONDITIONAL,
diff --git a/clippy_lints/src/lib.register_pedantic.rs b/clippy_lints/src/lib.register_pedantic.rs
index a8b6c5a5d63..b1603afa25f 100644
--- a/clippy_lints/src/lib.register_pedantic.rs
+++ b/clippy_lints/src/lib.register_pedantic.rs
@@ -4,7 +4,6 @@
 
 store.register_group(true, "clippy::pedantic", Some("clippy_pedantic"), vec![
     LintId::of(attrs::INLINE_ALWAYS),
-    LintId::of(bit_mask::VERBOSE_BIT_MASK),
     LintId::of(borrow_as_ptr::BORROW_AS_PTR),
     LintId::of(bytecount::NAIVE_BYTECOUNT),
     LintId::of(case_sensitive_file_extension_comparisons::CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS),
@@ -76,6 +75,7 @@ store.register_group(true, "clippy::pedantic", Some("clippy_pedantic"), vec![
     LintId::of(no_effect::NO_EFFECT_UNDERSCORE_BINDING),
     LintId::of(non_expressive_names::MANY_SINGLE_CHAR_NAMES),
     LintId::of(non_expressive_names::SIMILAR_NAMES),
+    LintId::of(operators::VERBOSE_BIT_MASK),
     LintId::of(pass_by_ref_or_value::LARGE_TYPES_PASSED_BY_VALUE),
     LintId::of(pass_by_ref_or_value::TRIVIALLY_COPY_PASS_BY_REF),
     LintId::of(ranges::RANGE_MINUS_ONE),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 0f9e3b06233..f8362998b8c 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -177,7 +177,6 @@ mod assertions_on_constants;
 mod async_yields_async;
 mod attrs;
 mod await_holding_invalid;
-mod bit_mask;
 mod blacklisted_name;
 mod blocks_in_if_conditions;
 mod bool_assert_comparison;
@@ -582,8 +581,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(eq_op::EqOp));
     store.register_late_pass(|| Box::new(enum_clike::UnportableVariant));
     store.register_late_pass(|| Box::new(float_literal::FloatLiteral));
-    let verbose_bit_mask_threshold = conf.verbose_bit_mask_threshold;
-    store.register_late_pass(move || Box::new(bit_mask::BitMask::new(verbose_bit_mask_threshold)));
     store.register_late_pass(|| Box::new(ptr::Ptr));
     store.register_late_pass(|| Box::new(ptr_eq::PtrEq));
     store.register_late_pass(|| Box::new(needless_bool::NeedlessBool));
@@ -936,7 +933,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(default_instead_of_iter_empty::DefaultIterEmpty));
     store.register_late_pass(move || Box::new(manual_rem_euclid::ManualRemEuclid::new(msrv)));
     store.register_late_pass(move || Box::new(manual_retain::ManualRetain::new(msrv)));
-    store.register_late_pass(|| Box::new(operators::Operators::default()));
+    let verbose_bit_mask_threshold = conf.verbose_bit_mask_threshold;
+    store.register_late_pass(move || Box::new(operators::Operators::new(verbose_bit_mask_threshold)));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/operators/bit_mask.rs b/clippy_lints/src/operators/bit_mask.rs
new file mode 100644
index 00000000000..74387fbc87b
--- /dev/null
+++ b/clippy_lints/src/operators/bit_mask.rs
@@ -0,0 +1,197 @@
+use clippy_utils::consts::{constant, Constant};
+use clippy_utils::diagnostics::span_lint;
+use rustc_hir::{BinOpKind, Expr, ExprKind};
+use rustc_lint::LateContext;
+use rustc_span::source_map::Span;
+
+use super::{BAD_BIT_MASK, INEFFECTIVE_BIT_MASK};
+
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    e: &'tcx Expr<'_>,
+    op: BinOpKind,
+    left: &'tcx Expr<'_>,
+    right: &'tcx Expr<'_>,
+) {
+    if op.is_comparison() {
+        if let Some(cmp_opt) = fetch_int_literal(cx, right) {
+            check_compare(cx, left, op, cmp_opt, e.span);
+        } else if let Some(cmp_val) = fetch_int_literal(cx, left) {
+            check_compare(cx, right, invert_cmp(op), cmp_val, e.span);
+        }
+    }
+}
+
+#[must_use]
+fn invert_cmp(cmp: BinOpKind) -> BinOpKind {
+    match cmp {
+        BinOpKind::Eq => BinOpKind::Eq,
+        BinOpKind::Ne => BinOpKind::Ne,
+        BinOpKind::Lt => BinOpKind::Gt,
+        BinOpKind::Gt => BinOpKind::Lt,
+        BinOpKind::Le => BinOpKind::Ge,
+        BinOpKind::Ge => BinOpKind::Le,
+        _ => BinOpKind::Or, // Dummy
+    }
+}
+
+fn check_compare(cx: &LateContext<'_>, bit_op: &Expr<'_>, cmp_op: BinOpKind, cmp_value: u128, span: Span) {
+    if let ExprKind::Binary(op, left, right) = &bit_op.kind {
+        if op.node != BinOpKind::BitAnd && op.node != BinOpKind::BitOr {
+            return;
+        }
+        fetch_int_literal(cx, right)
+            .or_else(|| fetch_int_literal(cx, left))
+            .map_or((), |mask| check_bit_mask(cx, op.node, cmp_op, mask, cmp_value, span));
+    }
+}
+
+#[allow(clippy::too_many_lines)]
+fn check_bit_mask(
+    cx: &LateContext<'_>,
+    bit_op: BinOpKind,
+    cmp_op: BinOpKind,
+    mask_value: u128,
+    cmp_value: u128,
+    span: Span,
+) {
+    match cmp_op {
+        BinOpKind::Eq | BinOpKind::Ne => match bit_op {
+            BinOpKind::BitAnd => {
+                if mask_value & cmp_value != cmp_value {
+                    if cmp_value != 0 {
+                        span_lint(
+                            cx,
+                            BAD_BIT_MASK,
+                            span,
+                            &format!(
+                                "incompatible bit mask: `_ & {}` can never be equal to `{}`",
+                                mask_value, cmp_value
+                            ),
+                        );
+                    }
+                } else if mask_value == 0 {
+                    span_lint(cx, BAD_BIT_MASK, span, "&-masking with zero");
+                }
+            },
+            BinOpKind::BitOr => {
+                if mask_value | cmp_value != cmp_value {
+                    span_lint(
+                        cx,
+                        BAD_BIT_MASK,
+                        span,
+                        &format!(
+                            "incompatible bit mask: `_ | {}` can never be equal to `{}`",
+                            mask_value, cmp_value
+                        ),
+                    );
+                }
+            },
+            _ => (),
+        },
+        BinOpKind::Lt | BinOpKind::Ge => match bit_op {
+            BinOpKind::BitAnd => {
+                if mask_value < cmp_value {
+                    span_lint(
+                        cx,
+                        BAD_BIT_MASK,
+                        span,
+                        &format!(
+                            "incompatible bit mask: `_ & {}` will always be lower than `{}`",
+                            mask_value, cmp_value
+                        ),
+                    );
+                } else if mask_value == 0 {
+                    span_lint(cx, BAD_BIT_MASK, span, "&-masking with zero");
+                }
+            },
+            BinOpKind::BitOr => {
+                if mask_value >= cmp_value {
+                    span_lint(
+                        cx,
+                        BAD_BIT_MASK,
+                        span,
+                        &format!(
+                            "incompatible bit mask: `_ | {}` will never be lower than `{}`",
+                            mask_value, cmp_value
+                        ),
+                    );
+                } else {
+                    check_ineffective_lt(cx, span, mask_value, cmp_value, "|");
+                }
+            },
+            BinOpKind::BitXor => check_ineffective_lt(cx, span, mask_value, cmp_value, "^"),
+            _ => (),
+        },
+        BinOpKind::Le | BinOpKind::Gt => match bit_op {
+            BinOpKind::BitAnd => {
+                if mask_value <= cmp_value {
+                    span_lint(
+                        cx,
+                        BAD_BIT_MASK,
+                        span,
+                        &format!(
+                            "incompatible bit mask: `_ & {}` will never be higher than `{}`",
+                            mask_value, cmp_value
+                        ),
+                    );
+                } else if mask_value == 0 {
+                    span_lint(cx, BAD_BIT_MASK, span, "&-masking with zero");
+                }
+            },
+            BinOpKind::BitOr => {
+                if mask_value > cmp_value {
+                    span_lint(
+                        cx,
+                        BAD_BIT_MASK,
+                        span,
+                        &format!(
+                            "incompatible bit mask: `_ | {}` will always be higher than `{}`",
+                            mask_value, cmp_value
+                        ),
+                    );
+                } else {
+                    check_ineffective_gt(cx, span, mask_value, cmp_value, "|");
+                }
+            },
+            BinOpKind::BitXor => check_ineffective_gt(cx, span, mask_value, cmp_value, "^"),
+            _ => (),
+        },
+        _ => (),
+    }
+}
+
+fn check_ineffective_lt(cx: &LateContext<'_>, span: Span, m: u128, c: u128, op: &str) {
+    if c.is_power_of_two() && m < c {
+        span_lint(
+            cx,
+            INEFFECTIVE_BIT_MASK,
+            span,
+            &format!(
+                "ineffective bit mask: `x {} {}` compared to `{}`, is the same as x compared directly",
+                op, m, c
+            ),
+        );
+    }
+}
+
+fn check_ineffective_gt(cx: &LateContext<'_>, span: Span, m: u128, c: u128, op: &str) {
+    if (c + 1).is_power_of_two() && m <= c {
+        span_lint(
+            cx,
+            INEFFECTIVE_BIT_MASK,
+            span,
+            &format!(
+                "ineffective bit mask: `x {} {}` compared to `{}`, is the same as x compared directly",
+                op, m, c
+            ),
+        );
+    }
+}
+
+fn fetch_int_literal(cx: &LateContext<'_>, lit: &Expr<'_>) -> Option<u128> {
+    match constant(cx, cx.typeck_results(), lit)?.0 {
+        Constant::Int(n) => Some(n),
+        _ => None,
+    }
+}
diff --git a/clippy_lints/src/operators/mod.rs b/clippy_lints/src/operators/mod.rs
index c1d038aa2b1..fd91fbd63a4 100644
--- a/clippy_lints/src/operators/mod.rs
+++ b/clippy_lints/src/operators/mod.rs
@@ -4,8 +4,10 @@ use rustc_session::{declare_tool_lint, impl_lint_pass};
 
 mod absurd_extreme_comparisons;
 mod assign_op_pattern;
+mod bit_mask;
 mod misrefactored_assign_op;
 mod numeric_arithmetic;
+mod verbose_bit_mask;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -146,9 +148,103 @@ declare_clippy_lint! {
     "having a variable on both sides of an assign op"
 }
 
-#[derive(Default)]
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for incompatible bit masks in comparisons.
+    ///
+    /// The formula for detecting if an expression of the type `_ <bit_op> m
+    /// <cmp_op> c` (where `<bit_op>` is one of {`&`, `|`} and `<cmp_op>` is one of
+    /// {`!=`, `>=`, `>`, `!=`, `>=`, `>`}) can be determined from the following
+    /// table:
+    ///
+    /// |Comparison  |Bit Op|Example      |is always|Formula               |
+    /// |------------|------|-------------|---------|----------------------|
+    /// |`==` or `!=`| `&`  |`x & 2 == 3` |`false`  |`c & m != c`          |
+    /// |`<`  or `>=`| `&`  |`x & 2 < 3`  |`true`   |`m < c`               |
+    /// |`>`  or `<=`| `&`  |`x & 1 > 1`  |`false`  |`m <= c`              |
+    /// |`==` or `!=`| `\|` |`x \| 1 == 0`|`false`  |`c \| m != c`         |
+    /// |`<`  or `>=`| `\|` |`x \| 1 < 1` |`false`  |`m >= c`              |
+    /// |`<=` or `>` | `\|` |`x \| 1 > 0` |`true`   |`m > c`               |
+    ///
+    /// ### Why is this bad?
+    /// If the bits that the comparison cares about are always
+    /// set to zero or one by the bit mask, the comparison is constant `true` or
+    /// `false` (depending on mask, compared value, and operators).
+    ///
+    /// So the code is actively misleading, and the only reason someone would write
+    /// this intentionally is to win an underhanded Rust contest or create a
+    /// test-case for this lint.
+    ///
+    /// ### Example
+    /// ```rust
+    /// # let x = 1;
+    /// if (x & 1 == 2) { }
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub BAD_BIT_MASK,
+    correctness,
+    "expressions of the form `_ & mask == select` that will only ever return `true` or `false`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for bit masks in comparisons which can be removed
+    /// without changing the outcome. The basic structure can be seen in the
+    /// following table:
+    ///
+    /// |Comparison| Bit Op   |Example     |equals |
+    /// |----------|----------|------------|-------|
+    /// |`>` / `<=`|`\|` / `^`|`x \| 2 > 3`|`x > 3`|
+    /// |`<` / `>=`|`\|` / `^`|`x ^ 1 < 4` |`x < 4`|
+    ///
+    /// ### Why is this bad?
+    /// Not equally evil as [`bad_bit_mask`](#bad_bit_mask),
+    /// but still a bit misleading, because the bit mask is ineffective.
+    ///
+    /// ### Known problems
+    /// False negatives: This lint will only match instances
+    /// where we have figured out the math (which is for a power-of-two compared
+    /// value). This means things like `x | 1 >= 7` (which would be better written
+    /// as `x >= 6`) will not be reported (but bit masks like this are fairly
+    /// uncommon).
+    ///
+    /// ### Example
+    /// ```rust
+    /// # let x = 1;
+    /// if (x | 1 > 3) {  }
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub INEFFECTIVE_BIT_MASK,
+    correctness,
+    "expressions where a bit mask will be rendered useless by a comparison, e.g., `(x | 1) > 2`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for bit masks that can be replaced by a call
+    /// to `trailing_zeros`
+    ///
+    /// ### Why is this bad?
+    /// `x.trailing_zeros() > 4` is much clearer than `x & 15
+    /// == 0`
+    ///
+    /// ### Known problems
+    /// llvm generates better code for `x & 15 == 0` on x86
+    ///
+    /// ### Example
+    /// ```rust
+    /// # let x = 1;
+    /// if x & 0b1111 == 0 { }
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub VERBOSE_BIT_MASK,
+    pedantic,
+    "expressions where a bit mask is less readable than the corresponding method call"
+}
+
 pub struct Operators {
     arithmetic_context: numeric_arithmetic::Context,
+    verbose_bit_mask_threshold: u64,
 }
 impl_lint_pass!(Operators => [
     ABSURD_EXTREME_COMPARISONS,
@@ -156,7 +252,18 @@ impl_lint_pass!(Operators => [
     FLOAT_ARITHMETIC,
     ASSIGN_OP_PATTERN,
     MISREFACTORED_ASSIGN_OP,
+    BAD_BIT_MASK,
+    INEFFECTIVE_BIT_MASK,
+    VERBOSE_BIT_MASK,
 ]);
+impl Operators {
+    pub fn new(verbose_bit_mask_threshold: u64) -> Self {
+        Self {
+            arithmetic_context: numeric_arithmetic::Context::default(),
+            verbose_bit_mask_threshold,
+        }
+    }
+}
 impl<'tcx> LateLintPass<'tcx> for Operators {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
         match e.kind {
@@ -165,6 +272,8 @@ impl<'tcx> LateLintPass<'tcx> for Operators {
                     absurd_extreme_comparisons::check(cx, e, op.node, lhs, rhs);
                 }
                 self.arithmetic_context.check_binary(cx, e, op.node, lhs, rhs);
+                bit_mask::check(cx, e, op.node, lhs, rhs);
+                verbose_bit_mask::check(cx, e, op.node, lhs, rhs, self.verbose_bit_mask_threshold);
             },
             ExprKind::AssignOp(op, lhs, rhs) => {
                 self.arithmetic_context.check_binary(cx, e, op.node, lhs, rhs);
diff --git a/clippy_lints/src/operators/verbose_bit_mask.rs b/clippy_lints/src/operators/verbose_bit_mask.rs
new file mode 100644
index 00000000000..ff85fd55429
--- /dev/null
+++ b/clippy_lints/src/operators/verbose_bit_mask.rs
@@ -0,0 +1,44 @@
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::sugg::Sugg;
+use rustc_ast::ast::LitKind;
+use rustc_errors::Applicability;
+use rustc_hir::{BinOpKind, Expr, ExprKind};
+use rustc_lint::LateContext;
+
+use super::VERBOSE_BIT_MASK;
+
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    e: &'tcx Expr<'_>,
+    op: BinOpKind,
+    left: &'tcx Expr<'_>,
+    right: &'tcx Expr<'_>,
+    threshold: u64,
+) {
+    if BinOpKind::Eq == op
+        && let ExprKind::Binary(op1, left1, right1) = &left.kind
+        && BinOpKind::BitAnd == op1.node
+        && let ExprKind::Lit(lit) = &right1.kind
+        && let LitKind::Int(n, _) = lit.node
+        && let ExprKind::Lit(lit1) = &right.kind
+        && let LitKind::Int(0, _) = lit1.node
+        && n.leading_zeros() == n.count_zeros()
+        && n > u128::from(threshold)
+    {
+        span_lint_and_then(
+            cx,
+            VERBOSE_BIT_MASK,
+            e.span,
+            "bit mask could be simplified with a call to `trailing_zeros`",
+            |diag| {
+                let sugg = Sugg::hir(cx, left1, "...").maybe_par();
+                diag.span_suggestion(
+                    e.span,
+                    "try",
+                    format!("{}.trailing_zeros() >= {}", sugg, n.count_ones()),
+                    Applicability::MaybeIncorrect,
+                );
+            },
+        );
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 4ac3626f2e3728e333f1dd0298e5e8c2d9a16c6b Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Tue, 31 May 2022 22:32:13 -0400
Subject: Move `DoubleComparison` into `Operators` lint pass

---
 clippy_lints/src/double_comparison.rs           | 96 -------------------------
 clippy_lints/src/lib.register_all.rs            |  2 +-
 clippy_lints/src/lib.register_complexity.rs     |  2 +-
 clippy_lints/src/lib.register_lints.rs          |  2 +-
 clippy_lints/src/lib.rs                         |  2 -
 clippy_lints/src/operators/double_comparison.rs | 54 ++++++++++++++
 clippy_lints/src/operators/mod.rs               | 31 ++++++++
 7 files changed, 88 insertions(+), 101 deletions(-)
 delete mode 100644 clippy_lints/src/double_comparison.rs
 create mode 100644 clippy_lints/src/operators/double_comparison.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/double_comparison.rs b/clippy_lints/src/double_comparison.rs
deleted file mode 100644
index ee0440e52ff..00000000000
--- a/clippy_lints/src/double_comparison.rs
+++ /dev/null
@@ -1,96 +0,0 @@
-//! Lint on unnecessary double comparisons. Some examples:
-
-use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::eq_expr_value;
-use clippy_utils::source::snippet_with_applicability;
-use rustc_errors::Applicability;
-use rustc_hir::{BinOpKind, Expr, ExprKind};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::source_map::Span;
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for double comparisons that could be simplified to a single expression.
-    ///
-    ///
-    /// ### Why is this bad?
-    /// Readability.
-    ///
-    /// ### Example
-    /// ```rust
-    /// # let x = 1;
-    /// # let y = 2;
-    /// if x == y || x < y {}
-    /// ```
-    ///
-    /// Use instead:
-    ///
-    /// ```rust
-    /// # let x = 1;
-    /// # let y = 2;
-    /// if x <= y {}
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub DOUBLE_COMPARISONS,
-    complexity,
-    "unnecessary double comparisons that can be simplified"
-}
-
-declare_lint_pass!(DoubleComparisons => [DOUBLE_COMPARISONS]);
-
-impl<'tcx> DoubleComparisons {
-    #[expect(clippy::similar_names)]
-    fn check_binop(cx: &LateContext<'tcx>, op: BinOpKind, lhs: &'tcx Expr<'_>, rhs: &'tcx Expr<'_>, span: Span) {
-        let (lkind, llhs, lrhs, rkind, rlhs, rrhs) = match (&lhs.kind, &rhs.kind) {
-            (ExprKind::Binary(lb, llhs, lrhs), ExprKind::Binary(rb, rlhs, rrhs)) => {
-                (lb.node, llhs, lrhs, rb.node, rlhs, rrhs)
-            },
-            _ => return,
-        };
-        if !(eq_expr_value(cx, llhs, rlhs) && eq_expr_value(cx, lrhs, rrhs)) {
-            return;
-        }
-        macro_rules! lint_double_comparison {
-            ($op:tt) => {{
-                let mut applicability = Applicability::MachineApplicable;
-                let lhs_str = snippet_with_applicability(cx, llhs.span, "", &mut applicability);
-                let rhs_str = snippet_with_applicability(cx, lrhs.span, "", &mut applicability);
-                let sugg = format!("{} {} {}", lhs_str, stringify!($op), rhs_str);
-                span_lint_and_sugg(
-                    cx,
-                    DOUBLE_COMPARISONS,
-                    span,
-                    "this binary expression can be simplified",
-                    "try",
-                    sugg,
-                    applicability,
-                );
-            }};
-        }
-        #[rustfmt::skip]
-        match (op, lkind, rkind) {
-            (BinOpKind::Or, BinOpKind::Eq, BinOpKind::Lt) | (BinOpKind::Or, BinOpKind::Lt, BinOpKind::Eq) => {
-                lint_double_comparison!(<=);
-            },
-            (BinOpKind::Or, BinOpKind::Eq, BinOpKind::Gt) | (BinOpKind::Or, BinOpKind::Gt, BinOpKind::Eq) => {
-                lint_double_comparison!(>=);
-            },
-            (BinOpKind::Or, BinOpKind::Lt, BinOpKind::Gt) | (BinOpKind::Or, BinOpKind::Gt, BinOpKind::Lt) => {
-                lint_double_comparison!(!=);
-            },
-            (BinOpKind::And, BinOpKind::Le, BinOpKind::Ge) | (BinOpKind::And, BinOpKind::Ge, BinOpKind::Le) => {
-                lint_double_comparison!(==);
-            },
-            _ => (),
-        };
-    }
-}
-
-impl<'tcx> LateLintPass<'tcx> for DoubleComparisons {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if let ExprKind::Binary(ref kind, lhs, rhs) = expr.kind {
-            Self::check_binop(cx, kind.node, lhs, rhs, expr.span);
-        }
-    }
-}
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index ccb5357b86e..22400f7b199 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -48,7 +48,6 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(disallowed_types::DISALLOWED_TYPES),
     LintId::of(doc::MISSING_SAFETY_DOC),
     LintId::of(doc::NEEDLESS_DOCTEST_MAIN),
-    LintId::of(double_comparison::DOUBLE_COMPARISONS),
     LintId::of(double_parens::DOUBLE_PARENS),
     LintId::of(drop_forget_ref::DROP_COPY),
     LintId::of(drop_forget_ref::DROP_NON_DROP),
@@ -258,6 +257,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(operators::ABSURD_EXTREME_COMPARISONS),
     LintId::of(operators::ASSIGN_OP_PATTERN),
     LintId::of(operators::BAD_BIT_MASK),
+    LintId::of(operators::DOUBLE_COMPARISONS),
     LintId::of(operators::INEFFECTIVE_BIT_MASK),
     LintId::of(operators::MISREFACTORED_ASSIGN_OP),
     LintId::of(option_env_unwrap::OPTION_ENV_UNWRAP),
diff --git a/clippy_lints/src/lib.register_complexity.rs b/clippy_lints/src/lib.register_complexity.rs
index 27de11bf1ae..03bb6788189 100644
--- a/clippy_lints/src/lib.register_complexity.rs
+++ b/clippy_lints/src/lib.register_complexity.rs
@@ -10,7 +10,6 @@ store.register_group(true, "clippy::complexity", Some("clippy_complexity"), vec!
     LintId::of(casts::CHAR_LIT_AS_U8),
     LintId::of(casts::UNNECESSARY_CAST),
     LintId::of(derivable_impls::DERIVABLE_IMPLS),
-    LintId::of(double_comparison::DOUBLE_COMPARISONS),
     LintId::of(double_parens::DOUBLE_PARENS),
     LintId::of(duration_subsec::DURATION_SUBSEC),
     LintId::of(explicit_write::EXPLICIT_WRITE),
@@ -71,6 +70,7 @@ store.register_group(true, "clippy::complexity", Some("clippy_complexity"), vec!
     LintId::of(neg_cmp_op_on_partial_ord::NEG_CMP_OP_ON_PARTIAL_ORD),
     LintId::of(no_effect::NO_EFFECT),
     LintId::of(no_effect::UNNECESSARY_OPERATION),
+    LintId::of(operators::DOUBLE_COMPARISONS),
     LintId::of(overflow_check_conditional::OVERFLOW_CHECK_CONDITIONAL),
     LintId::of(partialeq_ne_impl::PARTIALEQ_NE_IMPL),
     LintId::of(precedence::PRECEDENCE),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 1bcba0bc988..a08ad4a3104 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -122,7 +122,6 @@ store.register_lints(&[
     doc::MISSING_SAFETY_DOC,
     doc::NEEDLESS_DOCTEST_MAIN,
     doc_link_with_quotes::DOC_LINK_WITH_QUOTES,
-    double_comparison::DOUBLE_COMPARISONS,
     double_parens::DOUBLE_PARENS,
     drop_forget_ref::DROP_COPY,
     drop_forget_ref::DROP_NON_DROP,
@@ -432,6 +431,7 @@ store.register_lints(&[
     operators::ABSURD_EXTREME_COMPARISONS,
     operators::ASSIGN_OP_PATTERN,
     operators::BAD_BIT_MASK,
+    operators::DOUBLE_COMPARISONS,
     operators::FLOAT_ARITHMETIC,
     operators::INEFFECTIVE_BIT_MASK,
     operators::INTEGER_ARITHMETIC,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index f8362998b8c..931039d8c12 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -209,7 +209,6 @@ mod disallowed_script_idents;
 mod disallowed_types;
 mod doc;
 mod doc_link_with_quotes;
-mod double_comparison;
 mod double_parens;
 mod drop_forget_ref;
 mod duplicate_mod;
@@ -726,7 +725,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(useless_conversion::UselessConversion::default()));
     store.register_late_pass(|| Box::new(implicit_hasher::ImplicitHasher));
     store.register_late_pass(|| Box::new(fallible_impl_from::FallibleImplFrom));
-    store.register_late_pass(|| Box::new(double_comparison::DoubleComparisons));
     store.register_late_pass(|| Box::new(question_mark::QuestionMark));
     store.register_early_pass(|| Box::new(suspicious_operation_groupings::SuspiciousOperationGroupings));
     store.register_late_pass(|| Box::new(suspicious_trait_impl::SuspiciousImpl));
diff --git a/clippy_lints/src/operators/double_comparison.rs b/clippy_lints/src/operators/double_comparison.rs
new file mode 100644
index 00000000000..56a86d0ffa2
--- /dev/null
+++ b/clippy_lints/src/operators/double_comparison.rs
@@ -0,0 +1,54 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::eq_expr_value;
+use clippy_utils::source::snippet_with_applicability;
+use rustc_errors::Applicability;
+use rustc_hir::{BinOpKind, Expr, ExprKind};
+use rustc_lint::LateContext;
+use rustc_span::source_map::Span;
+
+use super::DOUBLE_COMPARISONS;
+
+#[expect(clippy::similar_names)]
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, op: BinOpKind, lhs: &'tcx Expr<'_>, rhs: &'tcx Expr<'_>, span: Span) {
+    let (lkind, llhs, lrhs, rkind, rlhs, rrhs) = match (&lhs.kind, &rhs.kind) {
+        (ExprKind::Binary(lb, llhs, lrhs), ExprKind::Binary(rb, rlhs, rrhs)) => {
+            (lb.node, llhs, lrhs, rb.node, rlhs, rrhs)
+        },
+        _ => return,
+    };
+    if !(eq_expr_value(cx, llhs, rlhs) && eq_expr_value(cx, lrhs, rrhs)) {
+        return;
+    }
+    macro_rules! lint_double_comparison {
+        ($op:tt) => {{
+            let mut applicability = Applicability::MachineApplicable;
+            let lhs_str = snippet_with_applicability(cx, llhs.span, "", &mut applicability);
+            let rhs_str = snippet_with_applicability(cx, lrhs.span, "", &mut applicability);
+            let sugg = format!("{} {} {}", lhs_str, stringify!($op), rhs_str);
+            span_lint_and_sugg(
+                cx,
+                DOUBLE_COMPARISONS,
+                span,
+                "this binary expression can be simplified",
+                "try",
+                sugg,
+                applicability,
+            );
+        }};
+    }
+    match (op, lkind, rkind) {
+        (BinOpKind::Or, BinOpKind::Eq, BinOpKind::Lt) | (BinOpKind::Or, BinOpKind::Lt, BinOpKind::Eq) => {
+            lint_double_comparison!(<=);
+        },
+        (BinOpKind::Or, BinOpKind::Eq, BinOpKind::Gt) | (BinOpKind::Or, BinOpKind::Gt, BinOpKind::Eq) => {
+            lint_double_comparison!(>=);
+        },
+        (BinOpKind::Or, BinOpKind::Lt, BinOpKind::Gt) | (BinOpKind::Or, BinOpKind::Gt, BinOpKind::Lt) => {
+            lint_double_comparison!(!=);
+        },
+        (BinOpKind::And, BinOpKind::Le, BinOpKind::Ge) | (BinOpKind::And, BinOpKind::Ge, BinOpKind::Le) => {
+            lint_double_comparison!(==);
+        },
+        _ => (),
+    };
+}
diff --git a/clippy_lints/src/operators/mod.rs b/clippy_lints/src/operators/mod.rs
index fd91fbd63a4..b3ddab629e4 100644
--- a/clippy_lints/src/operators/mod.rs
+++ b/clippy_lints/src/operators/mod.rs
@@ -5,6 +5,7 @@ use rustc_session::{declare_tool_lint, impl_lint_pass};
 mod absurd_extreme_comparisons;
 mod assign_op_pattern;
 mod bit_mask;
+mod double_comparison;
 mod misrefactored_assign_op;
 mod numeric_arithmetic;
 mod verbose_bit_mask;
@@ -242,6 +243,34 @@ declare_clippy_lint! {
     "expressions where a bit mask is less readable than the corresponding method call"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for double comparisons that could be simplified to a single expression.
+    ///
+    ///
+    /// ### Why is this bad?
+    /// Readability.
+    ///
+    /// ### Example
+    /// ```rust
+    /// # let x = 1;
+    /// # let y = 2;
+    /// if x == y || x < y {}
+    /// ```
+    ///
+    /// Use instead:
+    ///
+    /// ```rust
+    /// # let x = 1;
+    /// # let y = 2;
+    /// if x <= y {}
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub DOUBLE_COMPARISONS,
+    complexity,
+    "unnecessary double comparisons that can be simplified"
+}
+
 pub struct Operators {
     arithmetic_context: numeric_arithmetic::Context,
     verbose_bit_mask_threshold: u64,
@@ -255,6 +284,7 @@ impl_lint_pass!(Operators => [
     BAD_BIT_MASK,
     INEFFECTIVE_BIT_MASK,
     VERBOSE_BIT_MASK,
+    DOUBLE_COMPARISONS,
 ]);
 impl Operators {
     pub fn new(verbose_bit_mask_threshold: u64) -> Self {
@@ -274,6 +304,7 @@ impl<'tcx> LateLintPass<'tcx> for Operators {
                 self.arithmetic_context.check_binary(cx, e, op.node, lhs, rhs);
                 bit_mask::check(cx, e, op.node, lhs, rhs);
                 verbose_bit_mask::check(cx, e, op.node, lhs, rhs, self.verbose_bit_mask_threshold);
+                double_comparison::check(cx, op.node, lhs, rhs, e.span);
             },
             ExprKind::AssignOp(op, lhs, rhs) => {
                 self.arithmetic_context.check_binary(cx, e, op.node, lhs, rhs);
-- 
cgit 1.4.1-3-g733a5


From 732d7162ab065c2b399d2a1aec7a8d5794f893d6 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Tue, 31 May 2022 22:48:17 -0400
Subject: Move `DurationSubsec` into `Operators` lint pass

---
 clippy_lints/src/duration_subsec.rs           | 75 ---------------------------
 clippy_lints/src/lib.register_all.rs          |  2 +-
 clippy_lints/src/lib.register_complexity.rs   |  2 +-
 clippy_lints/src/lib.register_lints.rs        |  2 +-
 clippy_lints/src/lib.rs                       |  2 -
 clippy_lints/src/operators/duration_subsec.rs | 44 ++++++++++++++++
 clippy_lints/src/operators/mod.rs             | 33 ++++++++++++
 7 files changed, 80 insertions(+), 80 deletions(-)
 delete mode 100644 clippy_lints/src/duration_subsec.rs
 create mode 100644 clippy_lints/src/operators/duration_subsec.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/duration_subsec.rs b/clippy_lints/src/duration_subsec.rs
deleted file mode 100644
index d85ace3a279..00000000000
--- a/clippy_lints/src/duration_subsec.rs
+++ /dev/null
@@ -1,75 +0,0 @@
-use clippy_utils::consts::{constant, Constant};
-use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::ty::is_type_diagnostic_item;
-use if_chain::if_chain;
-use rustc_errors::Applicability;
-use rustc_hir::{BinOpKind, Expr, ExprKind};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::source_map::Spanned;
-use rustc_span::sym;
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for calculation of subsecond microseconds or milliseconds
-    /// from other `Duration` methods.
-    ///
-    /// ### Why is this bad?
-    /// It's more concise to call `Duration::subsec_micros()` or
-    /// `Duration::subsec_millis()` than to calculate them.
-    ///
-    /// ### Example
-    /// ```rust
-    /// # use std::time::Duration;
-    /// # let duration = Duration::new(5, 0);
-    /// let micros = duration.subsec_nanos() / 1_000;
-    /// let millis = duration.subsec_nanos() / 1_000_000;
-    /// ```
-    ///
-    /// Use instead:
-    /// ```rust
-    /// # use std::time::Duration;
-    /// # let duration = Duration::new(5, 0);
-    /// let micros = duration.subsec_micros();
-    /// let millis = duration.subsec_millis();
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub DURATION_SUBSEC,
-    complexity,
-    "checks for calculation of subsecond microseconds or milliseconds"
-}
-
-declare_lint_pass!(DurationSubsec => [DURATION_SUBSEC]);
-
-impl<'tcx> LateLintPass<'tcx> for DurationSubsec {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if_chain! {
-            if let ExprKind::Binary(Spanned { node: BinOpKind::Div, .. }, left, right) = expr.kind;
-            if let ExprKind::MethodCall(method_path, args, _) = left.kind;
-            if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&args[0]).peel_refs(), sym::Duration);
-            if let Some((Constant::Int(divisor), _)) = constant(cx, cx.typeck_results(), right);
-            then {
-                let suggested_fn = match (method_path.ident.as_str(), divisor) {
-                    ("subsec_micros", 1_000) | ("subsec_nanos", 1_000_000) => "subsec_millis",
-                    ("subsec_nanos", 1_000) => "subsec_micros",
-                    _ => return,
-                };
-                let mut applicability = Applicability::MachineApplicable;
-                span_lint_and_sugg(
-                    cx,
-                    DURATION_SUBSEC,
-                    expr.span,
-                    &format!("calling `{}()` is more concise than this calculation", suggested_fn),
-                    "try",
-                    format!(
-                        "{}.{}()",
-                        snippet_with_applicability(cx, args[0].span, "_", &mut applicability),
-                        suggested_fn
-                    ),
-                    applicability,
-                );
-            }
-        }
-    }
-}
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 22400f7b199..b64a5652586 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -57,7 +57,6 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(drop_forget_ref::FORGET_REF),
     LintId::of(drop_forget_ref::UNDROPPED_MANUALLY_DROPS),
     LintId::of(duplicate_mod::DUPLICATE_MOD),
-    LintId::of(duration_subsec::DURATION_SUBSEC),
     LintId::of(entry::MAP_ENTRY),
     LintId::of(enum_clike::ENUM_CLIKE_UNPORTABLE_VARIANT),
     LintId::of(enum_variants::ENUM_VARIANT_NAMES),
@@ -258,6 +257,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(operators::ASSIGN_OP_PATTERN),
     LintId::of(operators::BAD_BIT_MASK),
     LintId::of(operators::DOUBLE_COMPARISONS),
+    LintId::of(operators::DURATION_SUBSEC),
     LintId::of(operators::INEFFECTIVE_BIT_MASK),
     LintId::of(operators::MISREFACTORED_ASSIGN_OP),
     LintId::of(option_env_unwrap::OPTION_ENV_UNWRAP),
diff --git a/clippy_lints/src/lib.register_complexity.rs b/clippy_lints/src/lib.register_complexity.rs
index 03bb6788189..3a8a00d4ef0 100644
--- a/clippy_lints/src/lib.register_complexity.rs
+++ b/clippy_lints/src/lib.register_complexity.rs
@@ -11,7 +11,6 @@ store.register_group(true, "clippy::complexity", Some("clippy_complexity"), vec!
     LintId::of(casts::UNNECESSARY_CAST),
     LintId::of(derivable_impls::DERIVABLE_IMPLS),
     LintId::of(double_parens::DOUBLE_PARENS),
-    LintId::of(duration_subsec::DURATION_SUBSEC),
     LintId::of(explicit_write::EXPLICIT_WRITE),
     LintId::of(format::USELESS_FORMAT),
     LintId::of(functions::TOO_MANY_ARGUMENTS),
@@ -71,6 +70,7 @@ store.register_group(true, "clippy::complexity", Some("clippy_complexity"), vec!
     LintId::of(no_effect::NO_EFFECT),
     LintId::of(no_effect::UNNECESSARY_OPERATION),
     LintId::of(operators::DOUBLE_COMPARISONS),
+    LintId::of(operators::DURATION_SUBSEC),
     LintId::of(overflow_check_conditional::OVERFLOW_CHECK_CONDITIONAL),
     LintId::of(partialeq_ne_impl::PARTIALEQ_NE_IMPL),
     LintId::of(precedence::PRECEDENCE),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index a08ad4a3104..d0b38522f88 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -131,7 +131,6 @@ store.register_lints(&[
     drop_forget_ref::FORGET_REF,
     drop_forget_ref::UNDROPPED_MANUALLY_DROPS,
     duplicate_mod::DUPLICATE_MOD,
-    duration_subsec::DURATION_SUBSEC,
     else_if_without_else::ELSE_IF_WITHOUT_ELSE,
     empty_drop::EMPTY_DROP,
     empty_enum::EMPTY_ENUM,
@@ -432,6 +431,7 @@ store.register_lints(&[
     operators::ASSIGN_OP_PATTERN,
     operators::BAD_BIT_MASK,
     operators::DOUBLE_COMPARISONS,
+    operators::DURATION_SUBSEC,
     operators::FLOAT_ARITHMETIC,
     operators::INEFFECTIVE_BIT_MASK,
     operators::INTEGER_ARITHMETIC,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 931039d8c12..9b1b3afa2bd 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -212,7 +212,6 @@ mod doc_link_with_quotes;
 mod double_parens;
 mod drop_forget_ref;
 mod duplicate_mod;
-mod duration_subsec;
 mod else_if_without_else;
 mod empty_drop;
 mod empty_enum;
@@ -732,7 +731,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(inherent_impl::MultipleInherentImpl));
     store.register_late_pass(|| Box::new(neg_cmp_op_on_partial_ord::NoNegCompOpForPartialOrd));
     store.register_late_pass(|| Box::new(unwrap::Unwrap));
-    store.register_late_pass(|| Box::new(duration_subsec::DurationSubsec));
     store.register_late_pass(|| Box::new(indexing_slicing::IndexingSlicing));
     store.register_late_pass(|| Box::new(non_copy_const::NonCopyConst));
     store.register_late_pass(|| Box::new(ptr_offset_with_cast::PtrOffsetWithCast));
diff --git a/clippy_lints/src/operators/duration_subsec.rs b/clippy_lints/src/operators/duration_subsec.rs
new file mode 100644
index 00000000000..0d067d1e196
--- /dev/null
+++ b/clippy_lints/src/operators/duration_subsec.rs
@@ -0,0 +1,44 @@
+use clippy_utils::consts::{constant, Constant};
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::ty::is_type_diagnostic_item;
+use rustc_errors::Applicability;
+use rustc_hir::{BinOpKind, Expr, ExprKind};
+use rustc_lint::LateContext;
+use rustc_span::sym;
+
+use super::DURATION_SUBSEC;
+
+pub(crate) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx Expr<'_>,
+    op: BinOpKind,
+    left: &'tcx Expr<'_>,
+    right: &'tcx Expr<'_>,
+) {
+    if op == BinOpKind::Div
+        && let ExprKind::MethodCall(method_path, [self_arg], _) = left.kind
+        && is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(self_arg).peel_refs(), sym::Duration)
+        && let Some((Constant::Int(divisor), _)) = constant(cx, cx.typeck_results(), right)
+    {
+        let suggested_fn = match (method_path.ident.as_str(), divisor) {
+            ("subsec_micros", 1_000) | ("subsec_nanos", 1_000_000) => "subsec_millis",
+            ("subsec_nanos", 1_000) => "subsec_micros",
+            _ => return,
+        };
+        let mut applicability = Applicability::MachineApplicable;
+        span_lint_and_sugg(
+            cx,
+            DURATION_SUBSEC,
+            expr.span,
+            &format!("calling `{}()` is more concise than this calculation", suggested_fn),
+            "try",
+            format!(
+                "{}.{}()",
+                snippet_with_applicability(cx, self_arg.span, "_", &mut applicability),
+                suggested_fn
+            ),
+            applicability,
+        );
+    }
+}
diff --git a/clippy_lints/src/operators/mod.rs b/clippy_lints/src/operators/mod.rs
index b3ddab629e4..fb2c2bced93 100644
--- a/clippy_lints/src/operators/mod.rs
+++ b/clippy_lints/src/operators/mod.rs
@@ -6,6 +6,7 @@ mod absurd_extreme_comparisons;
 mod assign_op_pattern;
 mod bit_mask;
 mod double_comparison;
+mod duration_subsec;
 mod misrefactored_assign_op;
 mod numeric_arithmetic;
 mod verbose_bit_mask;
@@ -271,6 +272,36 @@ declare_clippy_lint! {
     "unnecessary double comparisons that can be simplified"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for calculation of subsecond microseconds or milliseconds
+    /// from other `Duration` methods.
+    ///
+    /// ### Why is this bad?
+    /// It's more concise to call `Duration::subsec_micros()` or
+    /// `Duration::subsec_millis()` than to calculate them.
+    ///
+    /// ### Example
+    /// ```rust
+    /// # use std::time::Duration;
+    /// # let duration = Duration::new(5, 0);
+    /// let micros = duration.subsec_nanos() / 1_000;
+    /// let millis = duration.subsec_nanos() / 1_000_000;
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust
+    /// # use std::time::Duration;
+    /// # let duration = Duration::new(5, 0);
+    /// let micros = duration.subsec_micros();
+    /// let millis = duration.subsec_millis();
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub DURATION_SUBSEC,
+    complexity,
+    "checks for calculation of subsecond microseconds or milliseconds"
+}
+
 pub struct Operators {
     arithmetic_context: numeric_arithmetic::Context,
     verbose_bit_mask_threshold: u64,
@@ -285,6 +316,7 @@ impl_lint_pass!(Operators => [
     INEFFECTIVE_BIT_MASK,
     VERBOSE_BIT_MASK,
     DOUBLE_COMPARISONS,
+    DURATION_SUBSEC,
 ]);
 impl Operators {
     pub fn new(verbose_bit_mask_threshold: u64) -> Self {
@@ -305,6 +337,7 @@ impl<'tcx> LateLintPass<'tcx> for Operators {
                 bit_mask::check(cx, e, op.node, lhs, rhs);
                 verbose_bit_mask::check(cx, e, op.node, lhs, rhs, self.verbose_bit_mask_threshold);
                 double_comparison::check(cx, op.node, lhs, rhs, e.span);
+                duration_subsec::check(cx, e, op.node, lhs, rhs);
             },
             ExprKind::AssignOp(op, lhs, rhs) => {
                 self.arithmetic_context.check_binary(cx, e, op.node, lhs, rhs);
-- 
cgit 1.4.1-3-g733a5


From 0adb3c051805998ab8cabb7654208141ae433ce0 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Tue, 31 May 2022 23:39:00 -0400
Subject: Move `EqOp` into `Operators` lint pass

---
 clippy_lints/src/eq_op.rs                    | 319 ---------------------------
 clippy_lints/src/lib.register_all.rs         |   4 +-
 clippy_lints/src/lib.register_correctness.rs |   2 +-
 clippy_lints/src/lib.register_lints.rs       |   4 +-
 clippy_lints/src/lib.register_style.rs       |   2 +-
 clippy_lints/src/lib.rs                      |   2 -
 clippy_lints/src/operators/eq_op.rs          |  45 ++++
 clippy_lints/src/operators/mod.rs            |  73 ++++++
 clippy_lints/src/operators/op_ref.rs         | 218 ++++++++++++++++++
 tests/ui/zero_div_zero.rs                    |   2 +-
 tests/ui/zero_div_zero.stderr                |  28 +--
 11 files changed, 344 insertions(+), 355 deletions(-)
 delete mode 100644 clippy_lints/src/eq_op.rs
 create mode 100644 clippy_lints/src/operators/eq_op.rs
 create mode 100644 clippy_lints/src/operators/op_ref.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/eq_op.rs b/clippy_lints/src/eq_op.rs
deleted file mode 100644
index 2f4c90d07cf..00000000000
--- a/clippy_lints/src/eq_op.rs
+++ /dev/null
@@ -1,319 +0,0 @@
-use clippy_utils::diagnostics::{multispan_sugg, span_lint, span_lint_and_then};
-use clippy_utils::get_enclosing_block;
-use clippy_utils::macros::{find_assert_eq_args, first_node_macro_backtrace};
-use clippy_utils::source::snippet;
-use clippy_utils::ty::{implements_trait, is_copy};
-use clippy_utils::{ast_utils::is_useless_with_eq_exprs, eq_expr_value, is_in_test_function};
-use if_chain::if_chain;
-use rustc_errors::Applicability;
-use rustc_hir::{def::Res, def_id::DefId, BinOpKind, BorrowKind, Expr, ExprKind, GenericArg, ItemKind, QPath, TyKind};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty::{self, Ty};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for equal operands to comparison, logical and
-    /// bitwise, difference and division binary operators (`==`, `>`, etc., `&&`,
-    /// `||`, `&`, `|`, `^`, `-` and `/`).
-    ///
-    /// ### Why is this bad?
-    /// This is usually just a typo or a copy and paste error.
-    ///
-    /// ### Known problems
-    /// False negatives: We had some false positives regarding
-    /// calls (notably [racer](https://github.com/phildawes/racer) had one instance
-    /// of `x.pop() && x.pop()`), so we removed matching any function or method
-    /// calls. We may introduce a list of known pure functions in the future.
-    ///
-    /// ### Example
-    /// ```rust
-    /// # let x = 1;
-    /// if x + 1 == x + 1 {}
-    ///
-    /// // or
-    ///
-    /// # let a = 3;
-    /// # let b = 4;
-    /// assert_eq!(a, a);
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub EQ_OP,
-    correctness,
-    "equal operands on both sides of a comparison or bitwise combination (e.g., `x == x`)"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for arguments to `==` which have their address
-    /// taken to satisfy a bound
-    /// and suggests to dereference the other argument instead
-    ///
-    /// ### Why is this bad?
-    /// It is more idiomatic to dereference the other argument.
-    ///
-    /// ### Example
-    /// ```rust,ignore
-    /// &x == y
-    /// ```
-    ///
-    /// Use instead:
-    /// ```rust,ignore
-    /// x == *y
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub OP_REF,
-    style,
-    "taking a reference to satisfy the type constraints on `==`"
-}
-
-declare_lint_pass!(EqOp => [EQ_OP, OP_REF]);
-
-impl<'tcx> LateLintPass<'tcx> for EqOp {
-    #[expect(clippy::similar_names, clippy::too_many_lines)]
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
-        if_chain! {
-            if let Some((macro_call, macro_name)) = first_node_macro_backtrace(cx, e).find_map(|macro_call| {
-                let name = cx.tcx.item_name(macro_call.def_id);
-                matches!(name.as_str(), "assert_eq" | "assert_ne" | "debug_assert_eq" | "debug_assert_ne")
-                    .then(|| (macro_call, name))
-            });
-            if let Some((lhs, rhs, _)) = find_assert_eq_args(cx, e, macro_call.expn);
-            if eq_expr_value(cx, lhs, rhs);
-            if macro_call.is_local();
-            if !is_in_test_function(cx.tcx, e.hir_id);
-            then {
-                span_lint(
-                    cx,
-                    EQ_OP,
-                    lhs.span.to(rhs.span),
-                    &format!("identical args used in this `{}!` macro call", macro_name),
-                );
-            }
-        }
-        if let ExprKind::Binary(op, left, right) = e.kind {
-            if e.span.from_expansion() {
-                return;
-            }
-            let macro_with_not_op = |expr_kind: &ExprKind<'_>| {
-                if let ExprKind::Unary(_, expr) = *expr_kind {
-                    expr.span.from_expansion()
-                } else {
-                    false
-                }
-            };
-            if macro_with_not_op(&left.kind) || macro_with_not_op(&right.kind) {
-                return;
-            }
-            if is_useless_with_eq_exprs(op.node.into())
-                && eq_expr_value(cx, left, right)
-                && !is_in_test_function(cx.tcx, e.hir_id)
-            {
-                span_lint(
-                    cx,
-                    EQ_OP,
-                    e.span,
-                    &format!("equal expressions as operands to `{}`", op.node.as_str()),
-                );
-                return;
-            }
-            let (trait_id, requires_ref) = match op.node {
-                BinOpKind::Add => (cx.tcx.lang_items().add_trait(), false),
-                BinOpKind::Sub => (cx.tcx.lang_items().sub_trait(), false),
-                BinOpKind::Mul => (cx.tcx.lang_items().mul_trait(), false),
-                BinOpKind::Div => (cx.tcx.lang_items().div_trait(), false),
-                BinOpKind::Rem => (cx.tcx.lang_items().rem_trait(), false),
-                // don't lint short circuiting ops
-                BinOpKind::And | BinOpKind::Or => return,
-                BinOpKind::BitXor => (cx.tcx.lang_items().bitxor_trait(), false),
-                BinOpKind::BitAnd => (cx.tcx.lang_items().bitand_trait(), false),
-                BinOpKind::BitOr => (cx.tcx.lang_items().bitor_trait(), false),
-                BinOpKind::Shl => (cx.tcx.lang_items().shl_trait(), false),
-                BinOpKind::Shr => (cx.tcx.lang_items().shr_trait(), false),
-                BinOpKind::Ne | BinOpKind::Eq => (cx.tcx.lang_items().eq_trait(), true),
-                BinOpKind::Lt | BinOpKind::Le | BinOpKind::Ge | BinOpKind::Gt => {
-                    (cx.tcx.lang_items().partial_ord_trait(), true)
-                },
-            };
-            if let Some(trait_id) = trait_id {
-                match (&left.kind, &right.kind) {
-                    // do not suggest to dereference literals
-                    (&ExprKind::Lit(..), _) | (_, &ExprKind::Lit(..)) => {},
-                    // &foo == &bar
-                    (&ExprKind::AddrOf(BorrowKind::Ref, _, l), &ExprKind::AddrOf(BorrowKind::Ref, _, r)) => {
-                        let lty = cx.typeck_results().expr_ty(l);
-                        let rty = cx.typeck_results().expr_ty(r);
-                        let lcpy = is_copy(cx, lty);
-                        let rcpy = is_copy(cx, rty);
-                        if let Some((self_ty, other_ty)) = in_impl(cx, e, trait_id) {
-                            if (are_equal(cx, rty, self_ty) && are_equal(cx, lty, other_ty))
-                                || (are_equal(cx, rty, other_ty) && are_equal(cx, lty, self_ty))
-                            {
-                                return; // Don't lint
-                            }
-                        }
-                        // either operator autorefs or both args are copyable
-                        if (requires_ref || (lcpy && rcpy)) && implements_trait(cx, lty, trait_id, &[rty.into()]) {
-                            span_lint_and_then(
-                                cx,
-                                OP_REF,
-                                e.span,
-                                "needlessly taken reference of both operands",
-                                |diag| {
-                                    let lsnip = snippet(cx, l.span, "...").to_string();
-                                    let rsnip = snippet(cx, r.span, "...").to_string();
-                                    multispan_sugg(
-                                        diag,
-                                        "use the values directly",
-                                        vec![(left.span, lsnip), (right.span, rsnip)],
-                                    );
-                                },
-                            );
-                        } else if lcpy
-                            && !rcpy
-                            && implements_trait(cx, lty, trait_id, &[cx.typeck_results().expr_ty(right).into()])
-                        {
-                            span_lint_and_then(
-                                cx,
-                                OP_REF,
-                                e.span,
-                                "needlessly taken reference of left operand",
-                                |diag| {
-                                    let lsnip = snippet(cx, l.span, "...").to_string();
-                                    diag.span_suggestion(
-                                        left.span,
-                                        "use the left value directly",
-                                        lsnip,
-                                        Applicability::MaybeIncorrect, // FIXME #2597
-                                    );
-                                },
-                            );
-                        } else if !lcpy
-                            && rcpy
-                            && implements_trait(cx, cx.typeck_results().expr_ty(left), trait_id, &[rty.into()])
-                        {
-                            span_lint_and_then(
-                                cx,
-                                OP_REF,
-                                e.span,
-                                "needlessly taken reference of right operand",
-                                |diag| {
-                                    let rsnip = snippet(cx, r.span, "...").to_string();
-                                    diag.span_suggestion(
-                                        right.span,
-                                        "use the right value directly",
-                                        rsnip,
-                                        Applicability::MaybeIncorrect, // FIXME #2597
-                                    );
-                                },
-                            );
-                        }
-                    },
-                    // &foo == bar
-                    (&ExprKind::AddrOf(BorrowKind::Ref, _, l), _) => {
-                        let lty = cx.typeck_results().expr_ty(l);
-                        if let Some((self_ty, other_ty)) = in_impl(cx, e, trait_id) {
-                            let rty = cx.typeck_results().expr_ty(right);
-                            if (are_equal(cx, rty, self_ty) && are_equal(cx, lty, other_ty))
-                                || (are_equal(cx, rty, other_ty) && are_equal(cx, lty, self_ty))
-                            {
-                                return; // Don't lint
-                            }
-                        }
-                        let lcpy = is_copy(cx, lty);
-                        if (requires_ref || lcpy)
-                            && implements_trait(cx, lty, trait_id, &[cx.typeck_results().expr_ty(right).into()])
-                        {
-                            span_lint_and_then(
-                                cx,
-                                OP_REF,
-                                e.span,
-                                "needlessly taken reference of left operand",
-                                |diag| {
-                                    let lsnip = snippet(cx, l.span, "...").to_string();
-                                    diag.span_suggestion(
-                                        left.span,
-                                        "use the left value directly",
-                                        lsnip,
-                                        Applicability::MaybeIncorrect, // FIXME #2597
-                                    );
-                                },
-                            );
-                        }
-                    },
-                    // foo == &bar
-                    (_, &ExprKind::AddrOf(BorrowKind::Ref, _, r)) => {
-                        let rty = cx.typeck_results().expr_ty(r);
-                        if let Some((self_ty, other_ty)) = in_impl(cx, e, trait_id) {
-                            let lty = cx.typeck_results().expr_ty(left);
-                            if (are_equal(cx, rty, self_ty) && are_equal(cx, lty, other_ty))
-                                || (are_equal(cx, rty, other_ty) && are_equal(cx, lty, self_ty))
-                            {
-                                return; // Don't lint
-                            }
-                        }
-                        let rcpy = is_copy(cx, rty);
-                        if (requires_ref || rcpy)
-                            && implements_trait(cx, cx.typeck_results().expr_ty(left), trait_id, &[rty.into()])
-                        {
-                            span_lint_and_then(cx, OP_REF, e.span, "taken reference of right operand", |diag| {
-                                let rsnip = snippet(cx, r.span, "...").to_string();
-                                diag.span_suggestion(
-                                    right.span,
-                                    "use the right value directly",
-                                    rsnip,
-                                    Applicability::MaybeIncorrect, // FIXME #2597
-                                );
-                            });
-                        }
-                    },
-                    _ => {},
-                }
-            }
-        }
-    }
-}
-
-fn in_impl<'tcx>(
-    cx: &LateContext<'tcx>,
-    e: &'tcx Expr<'_>,
-    bin_op: DefId,
-) -> Option<(&'tcx rustc_hir::Ty<'tcx>, &'tcx rustc_hir::Ty<'tcx>)> {
-    if_chain! {
-        if let Some(block) = get_enclosing_block(cx, e.hir_id);
-        if let Some(impl_def_id) = cx.tcx.impl_of_method(block.hir_id.owner.to_def_id());
-        let item = cx.tcx.hir().expect_item(impl_def_id.expect_local());
-        if let ItemKind::Impl(item) = &item.kind;
-        if let Some(of_trait) = &item.of_trait;
-        if let Some(seg) = of_trait.path.segments.last();
-        if let Some(Res::Def(_, trait_id)) = seg.res;
-        if trait_id == bin_op;
-        if let Some(generic_args) = seg.args;
-        if let Some(GenericArg::Type(other_ty)) = generic_args.args.last();
-
-        then {
-            Some((item.self_ty, other_ty))
-        }
-        else {
-            None
-        }
-    }
-}
-
-fn are_equal<'tcx>(cx: &LateContext<'tcx>, middle_ty: Ty<'_>, hir_ty: &rustc_hir::Ty<'_>) -> bool {
-    if_chain! {
-        if let ty::Adt(adt_def, _) = middle_ty.kind();
-        if let Some(local_did) = adt_def.did().as_local();
-        let item = cx.tcx.hir().expect_item(local_did);
-        let middle_ty_id = item.def_id.to_def_id();
-        if let TyKind::Path(QPath::Resolved(_, path)) = hir_ty.kind;
-        if let Res::Def(_, hir_ty_id) = path.res;
-
-        then {
-            hir_ty_id == middle_ty_id
-        }
-        else {
-            false
-        }
-    }
-}
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index b64a5652586..634d7f1f69f 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -61,8 +61,6 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(enum_clike::ENUM_CLIKE_UNPORTABLE_VARIANT),
     LintId::of(enum_variants::ENUM_VARIANT_NAMES),
     LintId::of(enum_variants::MODULE_INCEPTION),
-    LintId::of(eq_op::EQ_OP),
-    LintId::of(eq_op::OP_REF),
     LintId::of(erasing_op::ERASING_OP),
     LintId::of(escape::BOXED_LOCAL),
     LintId::of(eta_reduction::REDUNDANT_CLOSURE),
@@ -258,8 +256,10 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(operators::BAD_BIT_MASK),
     LintId::of(operators::DOUBLE_COMPARISONS),
     LintId::of(operators::DURATION_SUBSEC),
+    LintId::of(operators::EQ_OP),
     LintId::of(operators::INEFFECTIVE_BIT_MASK),
     LintId::of(operators::MISREFACTORED_ASSIGN_OP),
+    LintId::of(operators::OP_REF),
     LintId::of(option_env_unwrap::OPTION_ENV_UNWRAP),
     LintId::of(overflow_check_conditional::OVERFLOW_CHECK_CONDITIONAL),
     LintId::of(partialeq_ne_impl::PARTIALEQ_NE_IMPL),
diff --git a/clippy_lints/src/lib.register_correctness.rs b/clippy_lints/src/lib.register_correctness.rs
index 76286e93493..2b81eee1326 100644
--- a/clippy_lints/src/lib.register_correctness.rs
+++ b/clippy_lints/src/lib.register_correctness.rs
@@ -21,7 +21,6 @@ store.register_group(true, "clippy::correctness", Some("clippy_correctness"), ve
     LintId::of(drop_forget_ref::FORGET_REF),
     LintId::of(drop_forget_ref::UNDROPPED_MANUALLY_DROPS),
     LintId::of(enum_clike::ENUM_CLIKE_UNPORTABLE_VARIANT),
-    LintId::of(eq_op::EQ_OP),
     LintId::of(erasing_op::ERASING_OP),
     LintId::of(format_impl::RECURSIVE_FORMAT_IMPL),
     LintId::of(formatting::POSSIBLE_MISSING_COMMA),
@@ -50,6 +49,7 @@ store.register_group(true, "clippy::correctness", Some("clippy_correctness"), ve
     LintId::of(open_options::NONSENSICAL_OPEN_OPTIONS),
     LintId::of(operators::ABSURD_EXTREME_COMPARISONS),
     LintId::of(operators::BAD_BIT_MASK),
+    LintId::of(operators::EQ_OP),
     LintId::of(operators::INEFFECTIVE_BIT_MASK),
     LintId::of(option_env_unwrap::OPTION_ENV_UNWRAP),
     LintId::of(ptr::INVALID_NULL_PTR_USAGE),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index d0b38522f88..8b1bb440f08 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -140,8 +140,6 @@ store.register_lints(&[
     enum_variants::ENUM_VARIANT_NAMES,
     enum_variants::MODULE_INCEPTION,
     enum_variants::MODULE_NAME_REPETITIONS,
-    eq_op::EQ_OP,
-    eq_op::OP_REF,
     equatable_if_let::EQUATABLE_IF_LET,
     erasing_op::ERASING_OP,
     escape::BOXED_LOCAL,
@@ -432,10 +430,12 @@ store.register_lints(&[
     operators::BAD_BIT_MASK,
     operators::DOUBLE_COMPARISONS,
     operators::DURATION_SUBSEC,
+    operators::EQ_OP,
     operators::FLOAT_ARITHMETIC,
     operators::INEFFECTIVE_BIT_MASK,
     operators::INTEGER_ARITHMETIC,
     operators::MISREFACTORED_ASSIGN_OP,
+    operators::OP_REF,
     operators::VERBOSE_BIT_MASK,
     option_env_unwrap::OPTION_ENV_UNWRAP,
     option_if_let_else::OPTION_IF_LET_ELSE,
diff --git a/clippy_lints/src/lib.register_style.rs b/clippy_lints/src/lib.register_style.rs
index 78df54a4fff..a438577d992 100644
--- a/clippy_lints/src/lib.register_style.rs
+++ b/clippy_lints/src/lib.register_style.rs
@@ -22,7 +22,6 @@ store.register_group(true, "clippy::style", Some("clippy_style"), vec![
     LintId::of(doc::NEEDLESS_DOCTEST_MAIN),
     LintId::of(enum_variants::ENUM_VARIANT_NAMES),
     LintId::of(enum_variants::MODULE_INCEPTION),
-    LintId::of(eq_op::OP_REF),
     LintId::of(eta_reduction::REDUNDANT_CLOSURE),
     LintId::of(float_literal::EXCESSIVE_PRECISION),
     LintId::of(from_over_into::FROM_OVER_INTO),
@@ -98,6 +97,7 @@ store.register_group(true, "clippy::style", Some("clippy_style"), vec![
     LintId::of(non_copy_const::DECLARE_INTERIOR_MUTABLE_CONST),
     LintId::of(non_expressive_names::JUST_UNDERSCORES_AND_DIGITS),
     LintId::of(operators::ASSIGN_OP_PATTERN),
+    LintId::of(operators::OP_REF),
     LintId::of(ptr::CMP_NULL),
     LintId::of(ptr::PTR_ARG),
     LintId::of(ptr_eq::PTR_EQ),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 9b1b3afa2bd..f042d7547c2 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -219,7 +219,6 @@ mod empty_structs_with_brackets;
 mod entry;
 mod enum_clike;
 mod enum_variants;
-mod eq_op;
 mod equatable_if_let;
 mod erasing_op;
 mod escape;
@@ -576,7 +575,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     });
     store.register_late_pass(|| Box::new(booleans::NonminimalBool));
     store.register_late_pass(|| Box::new(needless_bitwise_bool::NeedlessBitwiseBool));
-    store.register_late_pass(|| Box::new(eq_op::EqOp));
     store.register_late_pass(|| Box::new(enum_clike::UnportableVariant));
     store.register_late_pass(|| Box::new(float_literal::FloatLiteral));
     store.register_late_pass(|| Box::new(ptr::Ptr));
diff --git a/clippy_lints/src/operators/eq_op.rs b/clippy_lints/src/operators/eq_op.rs
new file mode 100644
index 00000000000..44cf0bb0612
--- /dev/null
+++ b/clippy_lints/src/operators/eq_op.rs
@@ -0,0 +1,45 @@
+use clippy_utils::diagnostics::span_lint;
+use clippy_utils::macros::{find_assert_eq_args, first_node_macro_backtrace};
+use clippy_utils::{ast_utils::is_useless_with_eq_exprs, eq_expr_value, is_in_test_function};
+use rustc_hir::{BinOpKind, Expr};
+use rustc_lint::LateContext;
+
+use super::EQ_OP;
+
+pub(crate) fn check_assert<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
+    if let Some((macro_call, macro_name))
+        = first_node_macro_backtrace(cx, e).find_map(|macro_call| {
+            let name = cx.tcx.item_name(macro_call.def_id);
+            matches!(name.as_str(), "assert_eq" | "assert_ne" | "debug_assert_eq" | "debug_assert_ne")
+                .then(|| (macro_call, name))
+        })
+        && let Some((lhs, rhs, _)) = find_assert_eq_args(cx, e, macro_call.expn)
+        && eq_expr_value(cx, lhs, rhs)
+        && macro_call.is_local()
+        && !is_in_test_function(cx.tcx, e.hir_id)
+    {
+        span_lint(
+            cx,
+            EQ_OP,
+            lhs.span.to(rhs.span),
+            &format!("identical args used in this `{}!` macro call", macro_name),
+        );
+    }
+}
+
+pub(crate) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    e: &'tcx Expr<'_>,
+    op: BinOpKind,
+    left: &'tcx Expr<'_>,
+    right: &'tcx Expr<'_>,
+) {
+    if is_useless_with_eq_exprs(op.into()) && eq_expr_value(cx, left, right) && !is_in_test_function(cx.tcx, e.hir_id) {
+        span_lint(
+            cx,
+            EQ_OP,
+            e.span,
+            &format!("equal expressions as operands to `{}`", op.as_str()),
+        );
+    }
+}
diff --git a/clippy_lints/src/operators/mod.rs b/clippy_lints/src/operators/mod.rs
index fb2c2bced93..fd8b55beaed 100644
--- a/clippy_lints/src/operators/mod.rs
+++ b/clippy_lints/src/operators/mod.rs
@@ -7,8 +7,10 @@ mod assign_op_pattern;
 mod bit_mask;
 mod double_comparison;
 mod duration_subsec;
+mod eq_op;
 mod misrefactored_assign_op;
 mod numeric_arithmetic;
+mod op_ref;
 mod verbose_bit_mask;
 
 declare_clippy_lint! {
@@ -302,6 +304,62 @@ declare_clippy_lint! {
     "checks for calculation of subsecond microseconds or milliseconds"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for equal operands to comparison, logical and
+    /// bitwise, difference and division binary operators (`==`, `>`, etc., `&&`,
+    /// `||`, `&`, `|`, `^`, `-` and `/`).
+    ///
+    /// ### Why is this bad?
+    /// This is usually just a typo or a copy and paste error.
+    ///
+    /// ### Known problems
+    /// False negatives: We had some false positives regarding
+    /// calls (notably [racer](https://github.com/phildawes/racer) had one instance
+    /// of `x.pop() && x.pop()`), so we removed matching any function or method
+    /// calls. We may introduce a list of known pure functions in the future.
+    ///
+    /// ### Example
+    /// ```rust
+    /// # let x = 1;
+    /// if x + 1 == x + 1 {}
+    ///
+    /// // or
+    ///
+    /// # let a = 3;
+    /// # let b = 4;
+    /// assert_eq!(a, a);
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub EQ_OP,
+    correctness,
+    "equal operands on both sides of a comparison or bitwise combination (e.g., `x == x`)"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for arguments to `==` which have their address
+    /// taken to satisfy a bound
+    /// and suggests to dereference the other argument instead
+    ///
+    /// ### Why is this bad?
+    /// It is more idiomatic to dereference the other argument.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// &x == y
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust,ignore
+    /// x == *y
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub OP_REF,
+    style,
+    "taking a reference to satisfy the type constraints on `==`"
+}
+
 pub struct Operators {
     arithmetic_context: numeric_arithmetic::Context,
     verbose_bit_mask_threshold: u64,
@@ -317,6 +375,8 @@ impl_lint_pass!(Operators => [
     VERBOSE_BIT_MASK,
     DOUBLE_COMPARISONS,
     DURATION_SUBSEC,
+    EQ_OP,
+    OP_REF,
 ]);
 impl Operators {
     pub fn new(verbose_bit_mask_threshold: u64) -> Self {
@@ -328,10 +388,15 @@ impl Operators {
 }
 impl<'tcx> LateLintPass<'tcx> for Operators {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
+        eq_op::check_assert(cx, e);
         match e.kind {
             ExprKind::Binary(op, lhs, rhs) => {
                 if !e.span.from_expansion() {
                     absurd_extreme_comparisons::check(cx, e, op.node, lhs, rhs);
+                    if !(macro_with_not_op(lhs) || macro_with_not_op(rhs)) {
+                        eq_op::check(cx, e, op.node, lhs, rhs);
+                        op_ref::check(cx, e, op.node, lhs, rhs);
+                    }
                 }
                 self.arithmetic_context.check_binary(cx, e, op.node, lhs, rhs);
                 bit_mask::check(cx, e, op.node, lhs, rhs);
@@ -367,3 +432,11 @@ impl<'tcx> LateLintPass<'tcx> for Operators {
         self.arithmetic_context.body_post(cx, b);
     }
 }
+
+fn macro_with_not_op(e: &Expr<'_>) -> bool {
+    if let ExprKind::Unary(_, e) = e.kind {
+        e.span.from_expansion()
+    } else {
+        false
+    }
+}
diff --git a/clippy_lints/src/operators/op_ref.rs b/clippy_lints/src/operators/op_ref.rs
new file mode 100644
index 00000000000..1805672e372
--- /dev/null
+++ b/clippy_lints/src/operators/op_ref.rs
@@ -0,0 +1,218 @@
+use clippy_utils::diagnostics::{multispan_sugg, span_lint_and_then};
+use clippy_utils::get_enclosing_block;
+use clippy_utils::source::snippet;
+use clippy_utils::ty::{implements_trait, is_copy};
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir::{def::Res, def_id::DefId, BinOpKind, BorrowKind, Expr, ExprKind, GenericArg, ItemKind, QPath, TyKind};
+use rustc_lint::LateContext;
+use rustc_middle::ty::{self, Ty};
+
+use super::OP_REF;
+
+#[expect(clippy::similar_names, clippy::too_many_lines)]
+pub(crate) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    e: &'tcx Expr<'_>,
+    op: BinOpKind,
+    left: &'tcx Expr<'_>,
+    right: &'tcx Expr<'_>,
+) {
+    let (trait_id, requires_ref) = match op {
+        BinOpKind::Add => (cx.tcx.lang_items().add_trait(), false),
+        BinOpKind::Sub => (cx.tcx.lang_items().sub_trait(), false),
+        BinOpKind::Mul => (cx.tcx.lang_items().mul_trait(), false),
+        BinOpKind::Div => (cx.tcx.lang_items().div_trait(), false),
+        BinOpKind::Rem => (cx.tcx.lang_items().rem_trait(), false),
+        // don't lint short circuiting ops
+        BinOpKind::And | BinOpKind::Or => return,
+        BinOpKind::BitXor => (cx.tcx.lang_items().bitxor_trait(), false),
+        BinOpKind::BitAnd => (cx.tcx.lang_items().bitand_trait(), false),
+        BinOpKind::BitOr => (cx.tcx.lang_items().bitor_trait(), false),
+        BinOpKind::Shl => (cx.tcx.lang_items().shl_trait(), false),
+        BinOpKind::Shr => (cx.tcx.lang_items().shr_trait(), false),
+        BinOpKind::Ne | BinOpKind::Eq => (cx.tcx.lang_items().eq_trait(), true),
+        BinOpKind::Lt | BinOpKind::Le | BinOpKind::Ge | BinOpKind::Gt => {
+            (cx.tcx.lang_items().partial_ord_trait(), true)
+        },
+    };
+    if let Some(trait_id) = trait_id {
+        match (&left.kind, &right.kind) {
+            // do not suggest to dereference literals
+            (&ExprKind::Lit(..), _) | (_, &ExprKind::Lit(..)) => {},
+            // &foo == &bar
+            (&ExprKind::AddrOf(BorrowKind::Ref, _, l), &ExprKind::AddrOf(BorrowKind::Ref, _, r)) => {
+                let lty = cx.typeck_results().expr_ty(l);
+                let rty = cx.typeck_results().expr_ty(r);
+                let lcpy = is_copy(cx, lty);
+                let rcpy = is_copy(cx, rty);
+                if let Some((self_ty, other_ty)) = in_impl(cx, e, trait_id) {
+                    if (are_equal(cx, rty, self_ty) && are_equal(cx, lty, other_ty))
+                        || (are_equal(cx, rty, other_ty) && are_equal(cx, lty, self_ty))
+                    {
+                        return; // Don't lint
+                    }
+                }
+                // either operator autorefs or both args are copyable
+                if (requires_ref || (lcpy && rcpy)) && implements_trait(cx, lty, trait_id, &[rty.into()]) {
+                    span_lint_and_then(
+                        cx,
+                        OP_REF,
+                        e.span,
+                        "needlessly taken reference of both operands",
+                        |diag| {
+                            let lsnip = snippet(cx, l.span, "...").to_string();
+                            let rsnip = snippet(cx, r.span, "...").to_string();
+                            multispan_sugg(
+                                diag,
+                                "use the values directly",
+                                vec![(left.span, lsnip), (right.span, rsnip)],
+                            );
+                        },
+                    );
+                } else if lcpy
+                    && !rcpy
+                    && implements_trait(cx, lty, trait_id, &[cx.typeck_results().expr_ty(right).into()])
+                {
+                    span_lint_and_then(
+                        cx,
+                        OP_REF,
+                        e.span,
+                        "needlessly taken reference of left operand",
+                        |diag| {
+                            let lsnip = snippet(cx, l.span, "...").to_string();
+                            diag.span_suggestion(
+                                left.span,
+                                "use the left value directly",
+                                lsnip,
+                                Applicability::MaybeIncorrect, // FIXME #2597
+                            );
+                        },
+                    );
+                } else if !lcpy
+                    && rcpy
+                    && implements_trait(cx, cx.typeck_results().expr_ty(left), trait_id, &[rty.into()])
+                {
+                    span_lint_and_then(
+                        cx,
+                        OP_REF,
+                        e.span,
+                        "needlessly taken reference of right operand",
+                        |diag| {
+                            let rsnip = snippet(cx, r.span, "...").to_string();
+                            diag.span_suggestion(
+                                right.span,
+                                "use the right value directly",
+                                rsnip,
+                                Applicability::MaybeIncorrect, // FIXME #2597
+                            );
+                        },
+                    );
+                }
+            },
+            // &foo == bar
+            (&ExprKind::AddrOf(BorrowKind::Ref, _, l), _) => {
+                let lty = cx.typeck_results().expr_ty(l);
+                if let Some((self_ty, other_ty)) = in_impl(cx, e, trait_id) {
+                    let rty = cx.typeck_results().expr_ty(right);
+                    if (are_equal(cx, rty, self_ty) && are_equal(cx, lty, other_ty))
+                        || (are_equal(cx, rty, other_ty) && are_equal(cx, lty, self_ty))
+                    {
+                        return; // Don't lint
+                    }
+                }
+                let lcpy = is_copy(cx, lty);
+                if (requires_ref || lcpy)
+                    && implements_trait(cx, lty, trait_id, &[cx.typeck_results().expr_ty(right).into()])
+                {
+                    span_lint_and_then(
+                        cx,
+                        OP_REF,
+                        e.span,
+                        "needlessly taken reference of left operand",
+                        |diag| {
+                            let lsnip = snippet(cx, l.span, "...").to_string();
+                            diag.span_suggestion(
+                                left.span,
+                                "use the left value directly",
+                                lsnip,
+                                Applicability::MaybeIncorrect, // FIXME #2597
+                            );
+                        },
+                    );
+                }
+            },
+            // foo == &bar
+            (_, &ExprKind::AddrOf(BorrowKind::Ref, _, r)) => {
+                let rty = cx.typeck_results().expr_ty(r);
+                if let Some((self_ty, other_ty)) = in_impl(cx, e, trait_id) {
+                    let lty = cx.typeck_results().expr_ty(left);
+                    if (are_equal(cx, rty, self_ty) && are_equal(cx, lty, other_ty))
+                        || (are_equal(cx, rty, other_ty) && are_equal(cx, lty, self_ty))
+                    {
+                        return; // Don't lint
+                    }
+                }
+                let rcpy = is_copy(cx, rty);
+                if (requires_ref || rcpy)
+                    && implements_trait(cx, cx.typeck_results().expr_ty(left), trait_id, &[rty.into()])
+                {
+                    span_lint_and_then(cx, OP_REF, e.span, "taken reference of right operand", |diag| {
+                        let rsnip = snippet(cx, r.span, "...").to_string();
+                        diag.span_suggestion(
+                            right.span,
+                            "use the right value directly",
+                            rsnip,
+                            Applicability::MaybeIncorrect, // FIXME #2597
+                        );
+                    });
+                }
+            },
+            _ => {},
+        }
+    }
+}
+
+fn in_impl<'tcx>(
+    cx: &LateContext<'tcx>,
+    e: &'tcx Expr<'_>,
+    bin_op: DefId,
+) -> Option<(&'tcx rustc_hir::Ty<'tcx>, &'tcx rustc_hir::Ty<'tcx>)> {
+    if_chain! {
+        if let Some(block) = get_enclosing_block(cx, e.hir_id);
+        if let Some(impl_def_id) = cx.tcx.impl_of_method(block.hir_id.owner.to_def_id());
+        let item = cx.tcx.hir().expect_item(impl_def_id.expect_local());
+        if let ItemKind::Impl(item) = &item.kind;
+        if let Some(of_trait) = &item.of_trait;
+        if let Some(seg) = of_trait.path.segments.last();
+        if let Some(Res::Def(_, trait_id)) = seg.res;
+        if trait_id == bin_op;
+        if let Some(generic_args) = seg.args;
+        if let Some(GenericArg::Type(other_ty)) = generic_args.args.last();
+
+        then {
+            Some((item.self_ty, other_ty))
+        }
+        else {
+            None
+        }
+    }
+}
+
+fn are_equal<'tcx>(cx: &LateContext<'tcx>, middle_ty: Ty<'_>, hir_ty: &rustc_hir::Ty<'_>) -> bool {
+    if_chain! {
+        if let ty::Adt(adt_def, _) = middle_ty.kind();
+        if let Some(local_did) = adt_def.did().as_local();
+        let item = cx.tcx.hir().expect_item(local_did);
+        let middle_ty_id = item.def_id.to_def_id();
+        if let TyKind::Path(QPath::Resolved(_, path)) = hir_ty.kind;
+        if let Res::Def(_, hir_ty_id) = path.res;
+
+        then {
+            hir_ty_id == middle_ty_id
+        }
+        else {
+            false
+        }
+    }
+}
diff --git a/tests/ui/zero_div_zero.rs b/tests/ui/zero_div_zero.rs
index ed3a9208fc3..968c58f40ae 100644
--- a/tests/ui/zero_div_zero.rs
+++ b/tests/ui/zero_div_zero.rs
@@ -1,4 +1,4 @@
-#[allow(unused_variables)]
+#[allow(unused_variables, clippy::eq_op)]
 #[warn(clippy::zero_divided_by_zero)]
 fn main() {
     let nan = 0.0 / 0.0;
diff --git a/tests/ui/zero_div_zero.stderr b/tests/ui/zero_div_zero.stderr
index 0931dd32e7a..86563542e06 100644
--- a/tests/ui/zero_div_zero.stderr
+++ b/tests/ui/zero_div_zero.stderr
@@ -1,11 +1,3 @@
-error: equal expressions as operands to `/`
-  --> $DIR/zero_div_zero.rs:4:15
-   |
-LL |     let nan = 0.0 / 0.0;
-   |               ^^^^^^^^^
-   |
-   = note: `#[deny(clippy::eq_op)]` on by default
-
 error: constant division of `0.0` with `0.0` will always result in NaN
   --> $DIR/zero_div_zero.rs:4:15
    |
@@ -15,12 +7,6 @@ LL |     let nan = 0.0 / 0.0;
    = note: `-D clippy::zero-divided-by-zero` implied by `-D warnings`
    = help: consider using `f64::NAN` if you would like a constant representing NaN
 
-error: equal expressions as operands to `/`
-  --> $DIR/zero_div_zero.rs:5:19
-   |
-LL |     let f64_nan = 0.0 / 0.0f64;
-   |                   ^^^^^^^^^^^^
-
 error: constant division of `0.0` with `0.0` will always result in NaN
   --> $DIR/zero_div_zero.rs:5:19
    |
@@ -29,12 +15,6 @@ LL |     let f64_nan = 0.0 / 0.0f64;
    |
    = help: consider using `f64::NAN` if you would like a constant representing NaN
 
-error: equal expressions as operands to `/`
-  --> $DIR/zero_div_zero.rs:6:25
-   |
-LL |     let other_f64_nan = 0.0f64 / 0.0;
-   |                         ^^^^^^^^^^^^
-
 error: constant division of `0.0` with `0.0` will always result in NaN
   --> $DIR/zero_div_zero.rs:6:25
    |
@@ -43,12 +23,6 @@ LL |     let other_f64_nan = 0.0f64 / 0.0;
    |
    = help: consider using `f64::NAN` if you would like a constant representing NaN
 
-error: equal expressions as operands to `/`
-  --> $DIR/zero_div_zero.rs:7:28
-   |
-LL |     let one_more_f64_nan = 0.0f64 / 0.0f64;
-   |                            ^^^^^^^^^^^^^^^
-
 error: constant division of `0.0` with `0.0` will always result in NaN
   --> $DIR/zero_div_zero.rs:7:28
    |
@@ -57,5 +31,5 @@ LL |     let one_more_f64_nan = 0.0f64 / 0.0f64;
    |
    = help: consider using `f64::NAN` if you would like a constant representing NaN
 
-error: aborting due to 8 previous errors
+error: aborting due to 4 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 3de70a4996dd96c260baeabfb9a18cdda5e5eb6a Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Tue, 31 May 2022 23:47:59 -0400
Subject: Move `ErasingOp` into `Operators` lint pass

---
 clippy_lints/src/erasing_op.rs               | 77 ----------------------------
 clippy_lints/src/lib.register_all.rs         |  2 +-
 clippy_lints/src/lib.register_correctness.rs |  2 +-
 clippy_lints/src/lib.register_lints.rs       |  2 +-
 clippy_lints/src/lib.rs                      |  2 -
 clippy_lints/src/operators/erasing_op.rs     | 53 +++++++++++++++++++
 clippy_lints/src/operators/mod.rs            | 25 +++++++++
 7 files changed, 81 insertions(+), 82 deletions(-)
 delete mode 100644 clippy_lints/src/erasing_op.rs
 create mode 100644 clippy_lints/src/operators/erasing_op.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/erasing_op.rs b/clippy_lints/src/erasing_op.rs
deleted file mode 100644
index c1a84973c42..00000000000
--- a/clippy_lints/src/erasing_op.rs
+++ /dev/null
@@ -1,77 +0,0 @@
-use clippy_utils::consts::{constant_simple, Constant};
-use clippy_utils::diagnostics::span_lint;
-use clippy_utils::ty::same_type_and_consts;
-
-use rustc_hir::{BinOpKind, Expr, ExprKind};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty::TypeckResults;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for erasing operations, e.g., `x * 0`.
-    ///
-    /// ### Why is this bad?
-    /// The whole expression can be replaced by zero.
-    /// This is most likely not the intended outcome and should probably be
-    /// corrected
-    ///
-    /// ### Example
-    /// ```rust
-    /// let x = 1;
-    /// 0 / x;
-    /// 0 * x;
-    /// x & 0;
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub ERASING_OP,
-    correctness,
-    "using erasing operations, e.g., `x * 0` or `y & 0`"
-}
-
-declare_lint_pass!(ErasingOp => [ERASING_OP]);
-
-impl<'tcx> LateLintPass<'tcx> for ErasingOp {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
-        if e.span.from_expansion() {
-            return;
-        }
-        if let ExprKind::Binary(ref cmp, left, right) = e.kind {
-            let tck = cx.typeck_results();
-            match cmp.node {
-                BinOpKind::Mul | BinOpKind::BitAnd => {
-                    check(cx, tck, left, right, e);
-                    check(cx, tck, right, left, e);
-                },
-                BinOpKind::Div => check(cx, tck, left, right, e),
-                _ => (),
-            }
-        }
-    }
-}
-
-fn different_types(tck: &TypeckResults<'_>, input: &Expr<'_>, output: &Expr<'_>) -> bool {
-    let input_ty = tck.expr_ty(input).peel_refs();
-    let output_ty = tck.expr_ty(output).peel_refs();
-    !same_type_and_consts(input_ty, output_ty)
-}
-
-fn check<'tcx>(
-    cx: &LateContext<'tcx>,
-    tck: &TypeckResults<'tcx>,
-    op: &Expr<'tcx>,
-    other: &Expr<'tcx>,
-    parent: &Expr<'tcx>,
-) {
-    if constant_simple(cx, tck, op) == Some(Constant::Int(0)) {
-        if different_types(tck, other, parent) {
-            return;
-        }
-        span_lint(
-            cx,
-            ERASING_OP,
-            parent.span,
-            "this operation will always return zero. This is likely not the intended outcome",
-        );
-    }
-}
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 634d7f1f69f..533e6294925 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -61,7 +61,6 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(enum_clike::ENUM_CLIKE_UNPORTABLE_VARIANT),
     LintId::of(enum_variants::ENUM_VARIANT_NAMES),
     LintId::of(enum_variants::MODULE_INCEPTION),
-    LintId::of(erasing_op::ERASING_OP),
     LintId::of(escape::BOXED_LOCAL),
     LintId::of(eta_reduction::REDUNDANT_CLOSURE),
     LintId::of(explicit_write::EXPLICIT_WRITE),
@@ -257,6 +256,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(operators::DOUBLE_COMPARISONS),
     LintId::of(operators::DURATION_SUBSEC),
     LintId::of(operators::EQ_OP),
+    LintId::of(operators::ERASING_OP),
     LintId::of(operators::INEFFECTIVE_BIT_MASK),
     LintId::of(operators::MISREFACTORED_ASSIGN_OP),
     LintId::of(operators::OP_REF),
diff --git a/clippy_lints/src/lib.register_correctness.rs b/clippy_lints/src/lib.register_correctness.rs
index 2b81eee1326..b8362d5a72d 100644
--- a/clippy_lints/src/lib.register_correctness.rs
+++ b/clippy_lints/src/lib.register_correctness.rs
@@ -21,7 +21,6 @@ store.register_group(true, "clippy::correctness", Some("clippy_correctness"), ve
     LintId::of(drop_forget_ref::FORGET_REF),
     LintId::of(drop_forget_ref::UNDROPPED_MANUALLY_DROPS),
     LintId::of(enum_clike::ENUM_CLIKE_UNPORTABLE_VARIANT),
-    LintId::of(erasing_op::ERASING_OP),
     LintId::of(format_impl::RECURSIVE_FORMAT_IMPL),
     LintId::of(formatting::POSSIBLE_MISSING_COMMA),
     LintId::of(functions::NOT_UNSAFE_PTR_ARG_DEREF),
@@ -50,6 +49,7 @@ store.register_group(true, "clippy::correctness", Some("clippy_correctness"), ve
     LintId::of(operators::ABSURD_EXTREME_COMPARISONS),
     LintId::of(operators::BAD_BIT_MASK),
     LintId::of(operators::EQ_OP),
+    LintId::of(operators::ERASING_OP),
     LintId::of(operators::INEFFECTIVE_BIT_MASK),
     LintId::of(option_env_unwrap::OPTION_ENV_UNWRAP),
     LintId::of(ptr::INVALID_NULL_PTR_USAGE),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 8b1bb440f08..7ebf2880d2c 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -141,7 +141,6 @@ store.register_lints(&[
     enum_variants::MODULE_INCEPTION,
     enum_variants::MODULE_NAME_REPETITIONS,
     equatable_if_let::EQUATABLE_IF_LET,
-    erasing_op::ERASING_OP,
     escape::BOXED_LOCAL,
     eta_reduction::REDUNDANT_CLOSURE,
     eta_reduction::REDUNDANT_CLOSURE_FOR_METHOD_CALLS,
@@ -431,6 +430,7 @@ store.register_lints(&[
     operators::DOUBLE_COMPARISONS,
     operators::DURATION_SUBSEC,
     operators::EQ_OP,
+    operators::ERASING_OP,
     operators::FLOAT_ARITHMETIC,
     operators::INEFFECTIVE_BIT_MASK,
     operators::INTEGER_ARITHMETIC,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index f042d7547c2..3ded4a84375 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -220,7 +220,6 @@ mod entry;
 mod enum_clike;
 mod enum_variants;
 mod equatable_if_let;
-mod erasing_op;
 mod escape;
 mod eta_reduction;
 mod excessive_bools;
@@ -585,7 +584,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(misc::MiscLints));
     store.register_late_pass(|| Box::new(eta_reduction::EtaReduction));
     store.register_late_pass(|| Box::new(identity_op::IdentityOp));
-    store.register_late_pass(|| Box::new(erasing_op::ErasingOp));
     store.register_late_pass(|| Box::new(mut_mut::MutMut));
     store.register_late_pass(|| Box::new(mut_reference::UnnecessaryMutPassed));
     store.register_late_pass(|| Box::new(len_zero::LenZero));
diff --git a/clippy_lints/src/operators/erasing_op.rs b/clippy_lints/src/operators/erasing_op.rs
new file mode 100644
index 00000000000..066e08f3bd4
--- /dev/null
+++ b/clippy_lints/src/operators/erasing_op.rs
@@ -0,0 +1,53 @@
+use clippy_utils::consts::{constant_simple, Constant};
+use clippy_utils::diagnostics::span_lint;
+use clippy_utils::ty::same_type_and_consts;
+
+use rustc_hir::{BinOpKind, Expr};
+use rustc_lint::LateContext;
+use rustc_middle::ty::TypeckResults;
+
+use super::ERASING_OP;
+
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    e: &'tcx Expr<'_>,
+    op: BinOpKind,
+    left: &'tcx Expr<'_>,
+    right: &'tcx Expr<'_>,
+) {
+    let tck = cx.typeck_results();
+    match op {
+        BinOpKind::Mul | BinOpKind::BitAnd => {
+            check_op(cx, tck, left, right, e);
+            check_op(cx, tck, right, left, e);
+        },
+        BinOpKind::Div => check_op(cx, tck, left, right, e),
+        _ => (),
+    }
+}
+
+fn different_types(tck: &TypeckResults<'_>, input: &Expr<'_>, output: &Expr<'_>) -> bool {
+    let input_ty = tck.expr_ty(input).peel_refs();
+    let output_ty = tck.expr_ty(output).peel_refs();
+    !same_type_and_consts(input_ty, output_ty)
+}
+
+fn check_op<'tcx>(
+    cx: &LateContext<'tcx>,
+    tck: &TypeckResults<'tcx>,
+    op: &Expr<'tcx>,
+    other: &Expr<'tcx>,
+    parent: &Expr<'tcx>,
+) {
+    if constant_simple(cx, tck, op) == Some(Constant::Int(0)) {
+        if different_types(tck, other, parent) {
+            return;
+        }
+        span_lint(
+            cx,
+            ERASING_OP,
+            parent.span,
+            "this operation will always return zero. This is likely not the intended outcome",
+        );
+    }
+}
diff --git a/clippy_lints/src/operators/mod.rs b/clippy_lints/src/operators/mod.rs
index fd8b55beaed..01a23f0e322 100644
--- a/clippy_lints/src/operators/mod.rs
+++ b/clippy_lints/src/operators/mod.rs
@@ -8,6 +8,7 @@ mod bit_mask;
 mod double_comparison;
 mod duration_subsec;
 mod eq_op;
+mod erasing_op;
 mod misrefactored_assign_op;
 mod numeric_arithmetic;
 mod op_ref;
@@ -360,6 +361,28 @@ declare_clippy_lint! {
     "taking a reference to satisfy the type constraints on `==`"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for erasing operations, e.g., `x * 0`.
+    ///
+    /// ### Why is this bad?
+    /// The whole expression can be replaced by zero.
+    /// This is most likely not the intended outcome and should probably be
+    /// corrected
+    ///
+    /// ### Example
+    /// ```rust
+    /// let x = 1;
+    /// 0 / x;
+    /// 0 * x;
+    /// x & 0;
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub ERASING_OP,
+    correctness,
+    "using erasing operations, e.g., `x * 0` or `y & 0`"
+}
+
 pub struct Operators {
     arithmetic_context: numeric_arithmetic::Context,
     verbose_bit_mask_threshold: u64,
@@ -377,6 +400,7 @@ impl_lint_pass!(Operators => [
     DURATION_SUBSEC,
     EQ_OP,
     OP_REF,
+    ERASING_OP,
 ]);
 impl Operators {
     pub fn new(verbose_bit_mask_threshold: u64) -> Self {
@@ -397,6 +421,7 @@ impl<'tcx> LateLintPass<'tcx> for Operators {
                         eq_op::check(cx, e, op.node, lhs, rhs);
                         op_ref::check(cx, e, op.node, lhs, rhs);
                     }
+                    erasing_op::check(cx, e, op.node, lhs, rhs);
                 }
                 self.arithmetic_context.check_binary(cx, e, op.node, lhs, rhs);
                 bit_mask::check(cx, e, op.node, lhs, rhs);
-- 
cgit 1.4.1-3-g733a5


From 56f50d36e7462a612446e6d78bacf586f614cab5 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Wed, 1 Jun 2022 01:06:56 -0400
Subject: Move `FloatEqualityWithoutAbs` into `Operators` lint pass

---
 clippy_lints/src/float_equality_without_abs.rs     | 116 ---------------------
 clippy_lints/src/lib.register_all.rs               |   2 +-
 clippy_lints/src/lib.register_lints.rs             |   2 +-
 clippy_lints/src/lib.register_suspicious.rs        |   2 +-
 clippy_lints/src/lib.rs                            |   2 -
 .../src/operators/float_equality_without_abs.rs    |  71 +++++++++++++
 clippy_lints/src/operators/mod.rs                  |  36 +++++++
 7 files changed, 110 insertions(+), 121 deletions(-)
 delete mode 100644 clippy_lints/src/float_equality_without_abs.rs
 create mode 100644 clippy_lints/src/operators/float_equality_without_abs.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/float_equality_without_abs.rs b/clippy_lints/src/float_equality_without_abs.rs
deleted file mode 100644
index 98aee7592ae..00000000000
--- a/clippy_lints/src/float_equality_without_abs.rs
+++ /dev/null
@@ -1,116 +0,0 @@
-use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::{match_def_path, paths, sugg};
-use if_chain::if_chain;
-use rustc_ast::util::parser::AssocOp;
-use rustc_errors::Applicability;
-use rustc_hir::def::{DefKind, Res};
-use rustc_hir::{BinOpKind, Expr, ExprKind};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::source_map::Spanned;
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for statements of the form `(a - b) < f32::EPSILON` or
-    /// `(a - b) < f64::EPSILON`. Notes the missing `.abs()`.
-    ///
-    /// ### Why is this bad?
-    /// The code without `.abs()` is more likely to have a bug.
-    ///
-    /// ### Known problems
-    /// If the user can ensure that b is larger than a, the `.abs()` is
-    /// technically unnecessary. However, it will make the code more robust and doesn't have any
-    /// large performance implications. If the abs call was deliberately left out for performance
-    /// reasons, it is probably better to state this explicitly in the code, which then can be done
-    /// with an allow.
-    ///
-    /// ### Example
-    /// ```rust
-    /// pub fn is_roughly_equal(a: f32, b: f32) -> bool {
-    ///     (a - b) < f32::EPSILON
-    /// }
-    /// ```
-    /// Use instead:
-    /// ```rust
-    /// pub fn is_roughly_equal(a: f32, b: f32) -> bool {
-    ///     (a - b).abs() < f32::EPSILON
-    /// }
-    /// ```
-    #[clippy::version = "1.48.0"]
-    pub FLOAT_EQUALITY_WITHOUT_ABS,
-    suspicious,
-    "float equality check without `.abs()`"
-}
-
-declare_lint_pass!(FloatEqualityWithoutAbs => [FLOAT_EQUALITY_WITHOUT_ABS]);
-
-impl<'tcx> LateLintPass<'tcx> for FloatEqualityWithoutAbs {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        let lhs;
-        let rhs;
-
-        // check if expr is a binary expression with a lt or gt operator
-        if let ExprKind::Binary(op, left, right) = expr.kind {
-            match op.node {
-                BinOpKind::Lt => {
-                    lhs = left;
-                    rhs = right;
-                },
-                BinOpKind::Gt => {
-                    lhs = right;
-                    rhs = left;
-                },
-                _ => return,
-            };
-        } else {
-            return;
-        }
-
-        if_chain! {
-
-            // left hand side is a subtraction
-            if let ExprKind::Binary(
-                Spanned {
-                    node: BinOpKind::Sub,
-                    ..
-                },
-                val_l,
-                val_r,
-            ) = lhs.kind;
-
-            // right hand side matches either f32::EPSILON or f64::EPSILON
-            if let ExprKind::Path(ref epsilon_path) = rhs.kind;
-            if let Res::Def(DefKind::AssocConst, def_id) = cx.qpath_res(epsilon_path, rhs.hir_id);
-            if match_def_path(cx, def_id, &paths::F32_EPSILON) || match_def_path(cx, def_id, &paths::F64_EPSILON);
-
-            // values of the subtractions on the left hand side are of the type float
-            let t_val_l = cx.typeck_results().expr_ty(val_l);
-            let t_val_r = cx.typeck_results().expr_ty(val_r);
-            if let ty::Float(_) = t_val_l.kind();
-            if let ty::Float(_) = t_val_r.kind();
-
-            then {
-                let sug_l = sugg::Sugg::hir(cx, val_l, "..");
-                let sug_r = sugg::Sugg::hir(cx, val_r, "..");
-                // format the suggestion
-                let suggestion = format!("{}.abs()", sugg::make_assoc(AssocOp::Subtract, &sug_l, &sug_r).maybe_par());
-                // spans the lint
-                span_lint_and_then(
-                    cx,
-                    FLOAT_EQUALITY_WITHOUT_ABS,
-                    expr.span,
-                    "float equality check without `.abs()`",
-                    | diag | {
-                        diag.span_suggestion(
-                            lhs.span,
-                            "add `.abs()`",
-                            suggestion,
-                            Applicability::MaybeIncorrect,
-                        );
-                    }
-                );
-            }
-        }
-    }
-}
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 533e6294925..708038c8e22 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -64,7 +64,6 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(escape::BOXED_LOCAL),
     LintId::of(eta_reduction::REDUNDANT_CLOSURE),
     LintId::of(explicit_write::EXPLICIT_WRITE),
-    LintId::of(float_equality_without_abs::FLOAT_EQUALITY_WITHOUT_ABS),
     LintId::of(float_literal::EXCESSIVE_PRECISION),
     LintId::of(format::USELESS_FORMAT),
     LintId::of(format_args::FORMAT_IN_FORMAT_ARGS),
@@ -257,6 +256,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(operators::DURATION_SUBSEC),
     LintId::of(operators::EQ_OP),
     LintId::of(operators::ERASING_OP),
+    LintId::of(operators::FLOAT_EQUALITY_WITHOUT_ABS),
     LintId::of(operators::INEFFECTIVE_BIT_MASK),
     LintId::of(operators::MISREFACTORED_ASSIGN_OP),
     LintId::of(operators::OP_REF),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 7ebf2880d2c..c0de13d1572 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -151,7 +151,6 @@ store.register_lints(&[
     exit::EXIT,
     explicit_write::EXPLICIT_WRITE,
     fallible_impl_from::FALLIBLE_IMPL_FROM,
-    float_equality_without_abs::FLOAT_EQUALITY_WITHOUT_ABS,
     float_literal::EXCESSIVE_PRECISION,
     float_literal::LOSSY_FLOAT_LITERAL,
     floating_point_arithmetic::IMPRECISE_FLOPS,
@@ -432,6 +431,7 @@ store.register_lints(&[
     operators::EQ_OP,
     operators::ERASING_OP,
     operators::FLOAT_ARITHMETIC,
+    operators::FLOAT_EQUALITY_WITHOUT_ABS,
     operators::INEFFECTIVE_BIT_MASK,
     operators::INTEGER_ARITHMETIC,
     operators::MISREFACTORED_ASSIGN_OP,
diff --git a/clippy_lints/src/lib.register_suspicious.rs b/clippy_lints/src/lib.register_suspicious.rs
index 4ee89b7bec5..f7558f87098 100644
--- a/clippy_lints/src/lib.register_suspicious.rs
+++ b/clippy_lints/src/lib.register_suspicious.rs
@@ -15,7 +15,6 @@ store.register_group(true, "clippy::suspicious", Some("clippy_suspicious"), vec!
     LintId::of(drop_forget_ref::DROP_NON_DROP),
     LintId::of(drop_forget_ref::FORGET_NON_DROP),
     LintId::of(duplicate_mod::DUPLICATE_MOD),
-    LintId::of(float_equality_without_abs::FLOAT_EQUALITY_WITHOUT_ABS),
     LintId::of(format_impl::PRINT_IN_FORMAT_IMPL),
     LintId::of(formatting::SUSPICIOUS_ASSIGNMENT_FORMATTING),
     LintId::of(formatting::SUSPICIOUS_ELSE_FORMATTING),
@@ -28,6 +27,7 @@ store.register_group(true, "clippy::suspicious", Some("clippy_suspicious"), vec!
     LintId::of(methods::SUSPICIOUS_MAP),
     LintId::of(mut_key::MUTABLE_KEY_TYPE),
     LintId::of(octal_escapes::OCTAL_ESCAPES),
+    LintId::of(operators::FLOAT_EQUALITY_WITHOUT_ABS),
     LintId::of(operators::MISREFACTORED_ASSIGN_OP),
     LintId::of(rc_clone_in_vec_init::RC_CLONE_IN_VEC_INIT),
     LintId::of(suspicious_trait_impl::SUSPICIOUS_ARITHMETIC_IMPL),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 3ded4a84375..5e2ab9ddbec 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -227,7 +227,6 @@ mod exhaustive_items;
 mod exit;
 mod explicit_write;
 mod fallible_impl_from;
-mod float_equality_without_abs;
 mod float_literal;
 mod floating_point_arithmetic;
 mod format;
@@ -842,7 +841,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(unwrap_in_result::UnwrapInResult));
     store.register_late_pass(|| Box::new(self_assignment::SelfAssignment));
     store.register_late_pass(|| Box::new(manual_ok_or::ManualOkOr));
-    store.register_late_pass(|| Box::new(float_equality_without_abs::FloatEqualityWithoutAbs));
     store.register_late_pass(|| Box::new(semicolon_if_nothing_returned::SemicolonIfNothingReturned));
     store.register_late_pass(|| Box::new(async_yields_async::AsyncYieldsAsync));
     let disallowed_methods = conf.disallowed_methods.clone();
diff --git a/clippy_lints/src/operators/float_equality_without_abs.rs b/clippy_lints/src/operators/float_equality_without_abs.rs
new file mode 100644
index 00000000000..a0a8b6aabd9
--- /dev/null
+++ b/clippy_lints/src/operators/float_equality_without_abs.rs
@@ -0,0 +1,71 @@
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::{match_def_path, paths, sugg};
+use if_chain::if_chain;
+use rustc_ast::util::parser::AssocOp;
+use rustc_errors::Applicability;
+use rustc_hir::def::{DefKind, Res};
+use rustc_hir::{BinOpKind, Expr, ExprKind};
+use rustc_lint::LateContext;
+use rustc_middle::ty;
+use rustc_span::source_map::Spanned;
+
+use super::FLOAT_EQUALITY_WITHOUT_ABS;
+
+pub(crate) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx Expr<'_>,
+    op: BinOpKind,
+    lhs: &'tcx Expr<'_>,
+    rhs: &'tcx Expr<'_>,
+) {
+    let (lhs, rhs) = match op {
+        BinOpKind::Lt => (lhs, rhs),
+        BinOpKind::Gt => (rhs, lhs),
+        _ => return,
+    };
+
+    if_chain! {
+        // left hand side is a subtraction
+        if let ExprKind::Binary(
+            Spanned {
+                node: BinOpKind::Sub,
+                ..
+            },
+            val_l,
+            val_r,
+        ) = lhs.kind;
+
+        // right hand side matches either f32::EPSILON or f64::EPSILON
+        if let ExprKind::Path(ref epsilon_path) = rhs.kind;
+        if let Res::Def(DefKind::AssocConst, def_id) = cx.qpath_res(epsilon_path, rhs.hir_id);
+        if match_def_path(cx, def_id, &paths::F32_EPSILON) || match_def_path(cx, def_id, &paths::F64_EPSILON);
+
+        // values of the subtractions on the left hand side are of the type float
+        let t_val_l = cx.typeck_results().expr_ty(val_l);
+        let t_val_r = cx.typeck_results().expr_ty(val_r);
+        if let ty::Float(_) = t_val_l.kind();
+        if let ty::Float(_) = t_val_r.kind();
+
+        then {
+            let sug_l = sugg::Sugg::hir(cx, val_l, "..");
+            let sug_r = sugg::Sugg::hir(cx, val_r, "..");
+            // format the suggestion
+            let suggestion = format!("{}.abs()", sugg::make_assoc(AssocOp::Subtract, &sug_l, &sug_r).maybe_par());
+            // spans the lint
+            span_lint_and_then(
+                cx,
+                FLOAT_EQUALITY_WITHOUT_ABS,
+                expr.span,
+                "float equality check without `.abs()`",
+                | diag | {
+                    diag.span_suggestion(
+                        lhs.span,
+                        "add `.abs()`",
+                        suggestion,
+                        Applicability::MaybeIncorrect,
+                    );
+                }
+            );
+        }
+    }
+}
diff --git a/clippy_lints/src/operators/mod.rs b/clippy_lints/src/operators/mod.rs
index 01a23f0e322..0786765119b 100644
--- a/clippy_lints/src/operators/mod.rs
+++ b/clippy_lints/src/operators/mod.rs
@@ -9,6 +9,7 @@ mod double_comparison;
 mod duration_subsec;
 mod eq_op;
 mod erasing_op;
+mod float_equality_without_abs;
 mod misrefactored_assign_op;
 mod numeric_arithmetic;
 mod op_ref;
@@ -383,6 +384,39 @@ declare_clippy_lint! {
     "using erasing operations, e.g., `x * 0` or `y & 0`"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for statements of the form `(a - b) < f32::EPSILON` or
+    /// `(a - b) < f64::EPSILON`. Notes the missing `.abs()`.
+    ///
+    /// ### Why is this bad?
+    /// The code without `.abs()` is more likely to have a bug.
+    ///
+    /// ### Known problems
+    /// If the user can ensure that b is larger than a, the `.abs()` is
+    /// technically unnecessary. However, it will make the code more robust and doesn't have any
+    /// large performance implications. If the abs call was deliberately left out for performance
+    /// reasons, it is probably better to state this explicitly in the code, which then can be done
+    /// with an allow.
+    ///
+    /// ### Example
+    /// ```rust
+    /// pub fn is_roughly_equal(a: f32, b: f32) -> bool {
+    ///     (a - b) < f32::EPSILON
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// pub fn is_roughly_equal(a: f32, b: f32) -> bool {
+    ///     (a - b).abs() < f32::EPSILON
+    /// }
+    /// ```
+    #[clippy::version = "1.48.0"]
+    pub FLOAT_EQUALITY_WITHOUT_ABS,
+    suspicious,
+    "float equality check without `.abs()`"
+}
+
 pub struct Operators {
     arithmetic_context: numeric_arithmetic::Context,
     verbose_bit_mask_threshold: u64,
@@ -401,6 +435,7 @@ impl_lint_pass!(Operators => [
     EQ_OP,
     OP_REF,
     ERASING_OP,
+    FLOAT_EQUALITY_WITHOUT_ABS,
 ]);
 impl Operators {
     pub fn new(verbose_bit_mask_threshold: u64) -> Self {
@@ -428,6 +463,7 @@ impl<'tcx> LateLintPass<'tcx> for Operators {
                 verbose_bit_mask::check(cx, e, op.node, lhs, rhs, self.verbose_bit_mask_threshold);
                 double_comparison::check(cx, op.node, lhs, rhs, e.span);
                 duration_subsec::check(cx, e, op.node, lhs, rhs);
+                float_equality_without_abs::check(cx, e, op.node, lhs, rhs);
             },
             ExprKind::AssignOp(op, lhs, rhs) => {
                 self.arithmetic_context.check_binary(cx, e, op.node, lhs, rhs);
-- 
cgit 1.4.1-3-g733a5


From 83de67cfec4a1e68c8b63ec8153777c51a19addc Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Wed, 1 Jun 2022 01:23:57 -0400
Subject: Move `IdentityOp` into `Operators` lint pass

---
 clippy_lints/src/identity_op.rs             | 169 ----------------------------
 clippy_lints/src/lib.register_all.rs        |   2 +-
 clippy_lints/src/lib.register_complexity.rs |   2 +-
 clippy_lints/src/lib.register_lints.rs      |   2 +-
 clippy_lints/src/lib.rs                     |   2 -
 clippy_lints/src/operators/identity_op.rs   | 148 ++++++++++++++++++++++++
 clippy_lints/src/operators/mod.rs           |  22 ++++
 7 files changed, 173 insertions(+), 174 deletions(-)
 delete mode 100644 clippy_lints/src/identity_op.rs
 create mode 100644 clippy_lints/src/operators/identity_op.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/identity_op.rs b/clippy_lints/src/identity_op.rs
deleted file mode 100644
index 419ea5a6811..00000000000
--- a/clippy_lints/src/identity_op.rs
+++ /dev/null
@@ -1,169 +0,0 @@
-use clippy_utils::consts::{constant_full_int, constant_simple, Constant, FullInt};
-use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::{clip, unsext};
-use rustc_errors::Applicability;
-use rustc_hir::{BinOp, BinOpKind, Expr, ExprKind, Node};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::source_map::Span;
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for identity operations, e.g., `x + 0`.
-    ///
-    /// ### Why is this bad?
-    /// This code can be removed without changing the
-    /// meaning. So it just obscures what's going on. Delete it mercilessly.
-    ///
-    /// ### Example
-    /// ```rust
-    /// # let x = 1;
-    /// x / 1 + 0 * 1 - 0 | 0;
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub IDENTITY_OP,
-    complexity,
-    "using identity operations, e.g., `x + 0` or `y / 1`"
-}
-
-declare_lint_pass!(IdentityOp => [IDENTITY_OP]);
-
-impl<'tcx> LateLintPass<'tcx> for IdentityOp {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if expr.span.from_expansion() {
-            return;
-        }
-        if let ExprKind::Binary(cmp, left, right) = &expr.kind {
-            if !is_allowed(cx, *cmp, left, right) {
-                match cmp.node {
-                    BinOpKind::Add | BinOpKind::BitOr | BinOpKind::BitXor => {
-                        check(cx, left, 0, expr.span, right.span, needs_parenthesis(cx, expr, right));
-                        check(cx, right, 0, expr.span, left.span, Parens::Unneeded);
-                    },
-                    BinOpKind::Shl | BinOpKind::Shr | BinOpKind::Sub => {
-                        check(cx, right, 0, expr.span, left.span, Parens::Unneeded);
-                    },
-                    BinOpKind::Mul => {
-                        check(cx, left, 1, expr.span, right.span, needs_parenthesis(cx, expr, right));
-                        check(cx, right, 1, expr.span, left.span, Parens::Unneeded);
-                    },
-                    BinOpKind::Div => check(cx, right, 1, expr.span, left.span, Parens::Unneeded),
-                    BinOpKind::BitAnd => {
-                        check(cx, left, -1, expr.span, right.span, needs_parenthesis(cx, expr, right));
-                        check(cx, right, -1, expr.span, left.span, Parens::Unneeded);
-                    },
-                    BinOpKind::Rem => check_remainder(cx, left, right, expr.span, left.span),
-                    _ => (),
-                }
-            }
-        }
-    }
-}
-
-#[derive(Copy, Clone)]
-enum Parens {
-    Needed,
-    Unneeded,
-}
-
-/// Checks if `left op right` needs parenthesis when reduced to `right`
-/// e.g. `0 + if b { 1 } else { 2 } + if b { 3 } else { 4 }` cannot be reduced
-/// to `if b { 1 } else { 2 } + if b { 3 } else { 4 }` where the `if` could be
-/// interpreted as a statement
-///
-/// See #8724
-fn needs_parenthesis(cx: &LateContext<'_>, binary: &Expr<'_>, right: &Expr<'_>) -> Parens {
-    match right.kind {
-        ExprKind::Binary(_, lhs, _) | ExprKind::Cast(lhs, _) => {
-            // ensure we're checking against the leftmost expression of `right`
-            //
-            //     ~~~ `lhs`
-            // 0 + {4} * 2
-            //     ~~~~~~~ `right`
-            return needs_parenthesis(cx, binary, lhs);
-        },
-        ExprKind::If(..) | ExprKind::Match(..) | ExprKind::Block(..) | ExprKind::Loop(..) => {},
-        _ => return Parens::Unneeded,
-    }
-
-    let mut prev_id = binary.hir_id;
-    for (_, node) in cx.tcx.hir().parent_iter(binary.hir_id) {
-        if let Node::Expr(expr) = node
-            && let ExprKind::Binary(_, lhs, _) | ExprKind::Cast(lhs, _) = expr.kind
-            && lhs.hir_id == prev_id
-        {
-            // keep going until we find a node that encompasses left of `binary`
-            prev_id = expr.hir_id;
-            continue;
-        }
-
-        match node {
-            Node::Block(_) | Node::Stmt(_) => break,
-            _ => return Parens::Unneeded,
-        };
-    }
-
-    Parens::Needed
-}
-
-fn is_allowed(cx: &LateContext<'_>, cmp: BinOp, left: &Expr<'_>, right: &Expr<'_>) -> bool {
-    // This lint applies to integers
-    !cx.typeck_results().expr_ty(left).peel_refs().is_integral()
-        || !cx.typeck_results().expr_ty(right).peel_refs().is_integral()
-        // `1 << 0` is a common pattern in bit manipulation code
-        || (cmp.node == BinOpKind::Shl
-            && constant_simple(cx, cx.typeck_results(), right) == Some(Constant::Int(0))
-            && constant_simple(cx, cx.typeck_results(), left) == Some(Constant::Int(1)))
-}
-
-fn check_remainder(cx: &LateContext<'_>, left: &Expr<'_>, right: &Expr<'_>, span: Span, arg: Span) {
-    let lhs_const = constant_full_int(cx, cx.typeck_results(), left);
-    let rhs_const = constant_full_int(cx, cx.typeck_results(), right);
-    if match (lhs_const, rhs_const) {
-        (Some(FullInt::S(lv)), Some(FullInt::S(rv))) => lv.abs() < rv.abs(),
-        (Some(FullInt::U(lv)), Some(FullInt::U(rv))) => lv < rv,
-        _ => return,
-    } {
-        span_ineffective_operation(cx, span, arg, Parens::Unneeded);
-    }
-}
-
-fn check(cx: &LateContext<'_>, e: &Expr<'_>, m: i8, span: Span, arg: Span, parens: Parens) {
-    if let Some(Constant::Int(v)) = constant_simple(cx, cx.typeck_results(), e).map(Constant::peel_refs) {
-        let check = match *cx.typeck_results().expr_ty(e).peel_refs().kind() {
-            ty::Int(ity) => unsext(cx.tcx, -1_i128, ity),
-            ty::Uint(uty) => clip(cx.tcx, !0, uty),
-            _ => return,
-        };
-        if match m {
-            0 => v == 0,
-            -1 => v == check,
-            1 => v == 1,
-            _ => unreachable!(),
-        } {
-            span_ineffective_operation(cx, span, arg, parens);
-        }
-    }
-}
-
-fn span_ineffective_operation(cx: &LateContext<'_>, span: Span, arg: Span, parens: Parens) {
-    let mut applicability = Applicability::MachineApplicable;
-    let expr_snippet = snippet_with_applicability(cx, arg, "..", &mut applicability);
-
-    let suggestion = match parens {
-        Parens::Needed => format!("({expr_snippet})"),
-        Parens::Unneeded => expr_snippet.into_owned(),
-    };
-
-    span_lint_and_sugg(
-        cx,
-        IDENTITY_OP,
-        span,
-        "this operation has no effect",
-        "consider reducing it to",
-        suggestion,
-        applicability,
-    );
-}
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 708038c8e22..fb08d7d112d 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -83,7 +83,6 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(functions::RESULT_UNIT_ERR),
     LintId::of(functions::TOO_MANY_ARGUMENTS),
     LintId::of(get_first::GET_FIRST),
-    LintId::of(identity_op::IDENTITY_OP),
     LintId::of(if_let_mutex::IF_LET_MUTEX),
     LintId::of(indexing_slicing::OUT_OF_BOUNDS_INDEXING),
     LintId::of(infinite_iter::INFINITE_ITER),
@@ -257,6 +256,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(operators::EQ_OP),
     LintId::of(operators::ERASING_OP),
     LintId::of(operators::FLOAT_EQUALITY_WITHOUT_ABS),
+    LintId::of(operators::IDENTITY_OP),
     LintId::of(operators::INEFFECTIVE_BIT_MASK),
     LintId::of(operators::MISREFACTORED_ASSIGN_OP),
     LintId::of(operators::OP_REF),
diff --git a/clippy_lints/src/lib.register_complexity.rs b/clippy_lints/src/lib.register_complexity.rs
index 3a8a00d4ef0..ed5446f5844 100644
--- a/clippy_lints/src/lib.register_complexity.rs
+++ b/clippy_lints/src/lib.register_complexity.rs
@@ -14,7 +14,6 @@ store.register_group(true, "clippy::complexity", Some("clippy_complexity"), vec!
     LintId::of(explicit_write::EXPLICIT_WRITE),
     LintId::of(format::USELESS_FORMAT),
     LintId::of(functions::TOO_MANY_ARGUMENTS),
-    LintId::of(identity_op::IDENTITY_OP),
     LintId::of(int_plus_one::INT_PLUS_ONE),
     LintId::of(lifetimes::EXTRA_UNUSED_LIFETIMES),
     LintId::of(lifetimes::NEEDLESS_LIFETIMES),
@@ -71,6 +70,7 @@ store.register_group(true, "clippy::complexity", Some("clippy_complexity"), vec!
     LintId::of(no_effect::UNNECESSARY_OPERATION),
     LintId::of(operators::DOUBLE_COMPARISONS),
     LintId::of(operators::DURATION_SUBSEC),
+    LintId::of(operators::IDENTITY_OP),
     LintId::of(overflow_check_conditional::OVERFLOW_CHECK_CONDITIONAL),
     LintId::of(partialeq_ne_impl::PARTIALEQ_NE_IMPL),
     LintId::of(precedence::PRECEDENCE),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index c0de13d1572..946e8c76f17 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -176,7 +176,6 @@ store.register_lints(&[
     functions::TOO_MANY_LINES,
     future_not_send::FUTURE_NOT_SEND,
     get_first::GET_FIRST,
-    identity_op::IDENTITY_OP,
     if_let_mutex::IF_LET_MUTEX,
     if_not_else::IF_NOT_ELSE,
     if_then_some_else_none::IF_THEN_SOME_ELSE_NONE,
@@ -432,6 +431,7 @@ store.register_lints(&[
     operators::ERASING_OP,
     operators::FLOAT_ARITHMETIC,
     operators::FLOAT_EQUALITY_WITHOUT_ABS,
+    operators::IDENTITY_OP,
     operators::INEFFECTIVE_BIT_MASK,
     operators::INTEGER_ARITHMETIC,
     operators::MISREFACTORED_ASSIGN_OP,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 5e2ab9ddbec..327a1150952 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -239,7 +239,6 @@ mod from_str_radix_10;
 mod functions;
 mod future_not_send;
 mod get_first;
-mod identity_op;
 mod if_let_mutex;
 mod if_not_else;
 mod if_then_some_else_none;
@@ -582,7 +581,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(needless_for_each::NeedlessForEach));
     store.register_late_pass(|| Box::new(misc::MiscLints));
     store.register_late_pass(|| Box::new(eta_reduction::EtaReduction));
-    store.register_late_pass(|| Box::new(identity_op::IdentityOp));
     store.register_late_pass(|| Box::new(mut_mut::MutMut));
     store.register_late_pass(|| Box::new(mut_reference::UnnecessaryMutPassed));
     store.register_late_pass(|| Box::new(len_zero::LenZero));
diff --git a/clippy_lints/src/operators/identity_op.rs b/clippy_lints/src/operators/identity_op.rs
new file mode 100644
index 00000000000..b48d6c4e2e2
--- /dev/null
+++ b/clippy_lints/src/operators/identity_op.rs
@@ -0,0 +1,148 @@
+use clippy_utils::consts::{constant_full_int, constant_simple, Constant, FullInt};
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::{clip, unsext};
+use rustc_errors::Applicability;
+use rustc_hir::{BinOpKind, Expr, ExprKind, Node};
+use rustc_lint::LateContext;
+use rustc_middle::ty;
+use rustc_span::source_map::Span;
+
+use super::IDENTITY_OP;
+
+pub(crate) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx Expr<'_>,
+    op: BinOpKind,
+    left: &'tcx Expr<'_>,
+    right: &'tcx Expr<'_>,
+) {
+    if !is_allowed(cx, op, left, right) {
+        match op {
+            BinOpKind::Add | BinOpKind::BitOr | BinOpKind::BitXor => {
+                check_op(cx, left, 0, expr.span, right.span, needs_parenthesis(cx, expr, right));
+                check_op(cx, right, 0, expr.span, left.span, Parens::Unneeded);
+            },
+            BinOpKind::Shl | BinOpKind::Shr | BinOpKind::Sub => {
+                check_op(cx, right, 0, expr.span, left.span, Parens::Unneeded);
+            },
+            BinOpKind::Mul => {
+                check_op(cx, left, 1, expr.span, right.span, needs_parenthesis(cx, expr, right));
+                check_op(cx, right, 1, expr.span, left.span, Parens::Unneeded);
+            },
+            BinOpKind::Div => check_op(cx, right, 1, expr.span, left.span, Parens::Unneeded),
+            BinOpKind::BitAnd => {
+                check_op(cx, left, -1, expr.span, right.span, needs_parenthesis(cx, expr, right));
+                check_op(cx, right, -1, expr.span, left.span, Parens::Unneeded);
+            },
+            BinOpKind::Rem => check_remainder(cx, left, right, expr.span, left.span),
+            _ => (),
+        }
+    }
+}
+
+#[derive(Copy, Clone)]
+enum Parens {
+    Needed,
+    Unneeded,
+}
+
+/// Checks if `left op right` needs parenthesis when reduced to `right`
+/// e.g. `0 + if b { 1 } else { 2 } + if b { 3 } else { 4 }` cannot be reduced
+/// to `if b { 1 } else { 2 } + if b { 3 } else { 4 }` where the `if` could be
+/// interpreted as a statement
+///
+/// See #8724
+fn needs_parenthesis(cx: &LateContext<'_>, binary: &Expr<'_>, right: &Expr<'_>) -> Parens {
+    match right.kind {
+        ExprKind::Binary(_, lhs, _) | ExprKind::Cast(lhs, _) => {
+            // ensure we're checking against the leftmost expression of `right`
+            //
+            //     ~~~ `lhs`
+            // 0 + {4} * 2
+            //     ~~~~~~~ `right`
+            return needs_parenthesis(cx, binary, lhs);
+        },
+        ExprKind::If(..) | ExprKind::Match(..) | ExprKind::Block(..) | ExprKind::Loop(..) => {},
+        _ => return Parens::Unneeded,
+    }
+
+    let mut prev_id = binary.hir_id;
+    for (_, node) in cx.tcx.hir().parent_iter(binary.hir_id) {
+        if let Node::Expr(expr) = node
+            && let ExprKind::Binary(_, lhs, _) | ExprKind::Cast(lhs, _) = expr.kind
+            && lhs.hir_id == prev_id
+        {
+            // keep going until we find a node that encompasses left of `binary`
+            prev_id = expr.hir_id;
+            continue;
+        }
+
+        match node {
+            Node::Block(_) | Node::Stmt(_) => break,
+            _ => return Parens::Unneeded,
+        };
+    }
+
+    Parens::Needed
+}
+
+fn is_allowed(cx: &LateContext<'_>, cmp: BinOpKind, left: &Expr<'_>, right: &Expr<'_>) -> bool {
+    // This lint applies to integers
+    !cx.typeck_results().expr_ty(left).peel_refs().is_integral()
+        || !cx.typeck_results().expr_ty(right).peel_refs().is_integral()
+        // `1 << 0` is a common pattern in bit manipulation code
+        || (cmp == BinOpKind::Shl
+            && constant_simple(cx, cx.typeck_results(), right) == Some(Constant::Int(0))
+            && constant_simple(cx, cx.typeck_results(), left) == Some(Constant::Int(1)))
+}
+
+fn check_remainder(cx: &LateContext<'_>, left: &Expr<'_>, right: &Expr<'_>, span: Span, arg: Span) {
+    let lhs_const = constant_full_int(cx, cx.typeck_results(), left);
+    let rhs_const = constant_full_int(cx, cx.typeck_results(), right);
+    if match (lhs_const, rhs_const) {
+        (Some(FullInt::S(lv)), Some(FullInt::S(rv))) => lv.abs() < rv.abs(),
+        (Some(FullInt::U(lv)), Some(FullInt::U(rv))) => lv < rv,
+        _ => return,
+    } {
+        span_ineffective_operation(cx, span, arg, Parens::Unneeded);
+    }
+}
+
+fn check_op(cx: &LateContext<'_>, e: &Expr<'_>, m: i8, span: Span, arg: Span, parens: Parens) {
+    if let Some(Constant::Int(v)) = constant_simple(cx, cx.typeck_results(), e).map(Constant::peel_refs) {
+        let check = match *cx.typeck_results().expr_ty(e).peel_refs().kind() {
+            ty::Int(ity) => unsext(cx.tcx, -1_i128, ity),
+            ty::Uint(uty) => clip(cx.tcx, !0, uty),
+            _ => return,
+        };
+        if match m {
+            0 => v == 0,
+            -1 => v == check,
+            1 => v == 1,
+            _ => unreachable!(),
+        } {
+            span_ineffective_operation(cx, span, arg, parens);
+        }
+    }
+}
+
+fn span_ineffective_operation(cx: &LateContext<'_>, span: Span, arg: Span, parens: Parens) {
+    let mut applicability = Applicability::MachineApplicable;
+    let expr_snippet = snippet_with_applicability(cx, arg, "..", &mut applicability);
+
+    let suggestion = match parens {
+        Parens::Needed => format!("({expr_snippet})"),
+        Parens::Unneeded => expr_snippet.into_owned(),
+    };
+
+    span_lint_and_sugg(
+        cx,
+        IDENTITY_OP,
+        span,
+        "this operation has no effect",
+        "consider reducing it to",
+        suggestion,
+        applicability,
+    );
+}
diff --git a/clippy_lints/src/operators/mod.rs b/clippy_lints/src/operators/mod.rs
index 0786765119b..91550e0e678 100644
--- a/clippy_lints/src/operators/mod.rs
+++ b/clippy_lints/src/operators/mod.rs
@@ -10,6 +10,7 @@ mod duration_subsec;
 mod eq_op;
 mod erasing_op;
 mod float_equality_without_abs;
+mod identity_op;
 mod misrefactored_assign_op;
 mod numeric_arithmetic;
 mod op_ref;
@@ -417,6 +418,25 @@ declare_clippy_lint! {
     "float equality check without `.abs()`"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for identity operations, e.g., `x + 0`.
+    ///
+    /// ### Why is this bad?
+    /// This code can be removed without changing the
+    /// meaning. So it just obscures what's going on. Delete it mercilessly.
+    ///
+    /// ### Example
+    /// ```rust
+    /// # let x = 1;
+    /// x / 1 + 0 * 1 - 0 | 0;
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub IDENTITY_OP,
+    complexity,
+    "using identity operations, e.g., `x + 0` or `y / 1`"
+}
+
 pub struct Operators {
     arithmetic_context: numeric_arithmetic::Context,
     verbose_bit_mask_threshold: u64,
@@ -436,6 +456,7 @@ impl_lint_pass!(Operators => [
     OP_REF,
     ERASING_OP,
     FLOAT_EQUALITY_WITHOUT_ABS,
+    IDENTITY_OP,
 ]);
 impl Operators {
     pub fn new(verbose_bit_mask_threshold: u64) -> Self {
@@ -457,6 +478,7 @@ impl<'tcx> LateLintPass<'tcx> for Operators {
                         op_ref::check(cx, e, op.node, lhs, rhs);
                     }
                     erasing_op::check(cx, e, op.node, lhs, rhs);
+                    identity_op::check(cx, e, op.node, lhs, rhs);
                 }
                 self.arithmetic_context.check_binary(cx, e, op.node, lhs, rhs);
                 bit_mask::check(cx, e, op.node, lhs, rhs);
-- 
cgit 1.4.1-3-g733a5


From a8df16ae1df9084dc8e20e835f3de981e32d110c Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Wed, 1 Jun 2022 01:33:06 -0400
Subject: Move `IntegerDivision` into `Operators` lint pass

---
 clippy_lints/src/integer_division.rs           | 61 --------------------------
 clippy_lints/src/lib.register_lints.rs         |  2 +-
 clippy_lints/src/lib.register_restriction.rs   |  2 +-
 clippy_lints/src/lib.rs                        |  2 -
 clippy_lints/src/operators/integer_division.rs | 27 ++++++++++++
 clippy_lints/src/operators/mod.rs              | 29 ++++++++++++
 6 files changed, 58 insertions(+), 65 deletions(-)
 delete mode 100644 clippy_lints/src/integer_division.rs
 create mode 100644 clippy_lints/src/operators/integer_division.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/integer_division.rs b/clippy_lints/src/integer_division.rs
deleted file mode 100644
index 3effba56826..00000000000
--- a/clippy_lints/src/integer_division.rs
+++ /dev/null
@@ -1,61 +0,0 @@
-use clippy_utils::diagnostics::span_lint_and_help;
-use if_chain::if_chain;
-use rustc_hir as hir;
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for division of integers
-    ///
-    /// ### Why is this bad?
-    /// When outside of some very specific algorithms,
-    /// integer division is very often a mistake because it discards the
-    /// remainder.
-    ///
-    /// ### Example
-    /// ```rust
-    /// let x = 3 / 2;
-    /// println!("{}", x);
-    /// ```
-    ///
-    /// Use instead:
-    /// ```rust
-    /// let x = 3f32 / 2f32;
-    /// println!("{}", x);
-    /// ```
-    #[clippy::version = "1.37.0"]
-    pub INTEGER_DIVISION,
-    restriction,
-    "integer division may cause loss of precision"
-}
-
-declare_lint_pass!(IntegerDivision => [INTEGER_DIVISION]);
-
-impl<'tcx> LateLintPass<'tcx> for IntegerDivision {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
-        if is_integer_division(cx, expr) {
-            span_lint_and_help(
-                cx,
-                INTEGER_DIVISION,
-                expr.span,
-                "integer division",
-                None,
-                "division of integers may cause loss of precision. consider using floats",
-            );
-        }
-    }
-}
-
-fn is_integer_division<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) -> bool {
-    if_chain! {
-        if let hir::ExprKind::Binary(binop, left, right) = &expr.kind;
-        if binop.node == hir::BinOpKind::Div;
-        then {
-            let (left_ty, right_ty) = (cx.typeck_results().expr_ty(left), cx.typeck_results().expr_ty(right));
-            return left_ty.is_integral() && right_ty.is_integral();
-        }
-    }
-
-    false
-}
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 946e8c76f17..7acfdf56840 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -194,7 +194,6 @@ store.register_lints(&[
     init_numbered_fields::INIT_NUMBERED_FIELDS,
     inline_fn_without_body::INLINE_FN_WITHOUT_BODY,
     int_plus_one::INT_PLUS_ONE,
-    integer_division::INTEGER_DIVISION,
     invalid_upcast_comparisons::INVALID_UPCAST_COMPARISONS,
     items_after_statements::ITEMS_AFTER_STATEMENTS,
     iter_not_returning_iterator::ITER_NOT_RETURNING_ITERATOR,
@@ -434,6 +433,7 @@ store.register_lints(&[
     operators::IDENTITY_OP,
     operators::INEFFECTIVE_BIT_MASK,
     operators::INTEGER_ARITHMETIC,
+    operators::INTEGER_DIVISION,
     operators::MISREFACTORED_ASSIGN_OP,
     operators::OP_REF,
     operators::VERBOSE_BIT_MASK,
diff --git a/clippy_lints/src/lib.register_restriction.rs b/clippy_lints/src/lib.register_restriction.rs
index b7441385230..53d968c4710 100644
--- a/clippy_lints/src/lib.register_restriction.rs
+++ b/clippy_lints/src/lib.register_restriction.rs
@@ -25,7 +25,6 @@ store.register_group(true, "clippy::restriction", Some("clippy_restriction"), ve
     LintId::of(implicit_return::IMPLICIT_RETURN),
     LintId::of(indexing_slicing::INDEXING_SLICING),
     LintId::of(inherent_impl::MULTIPLE_INHERENT_IMPL),
-    LintId::of(integer_division::INTEGER_DIVISION),
     LintId::of(large_include_file::LARGE_INCLUDE_FILE),
     LintId::of(let_underscore::LET_UNDERSCORE_MUST_USE),
     LintId::of(literal_representation::DECIMAL_LITERAL_REPRESENTATION),
@@ -52,6 +51,7 @@ store.register_group(true, "clippy::restriction", Some("clippy_restriction"), ve
     LintId::of(modulo_arithmetic::MODULO_ARITHMETIC),
     LintId::of(operators::FLOAT_ARITHMETIC),
     LintId::of(operators::INTEGER_ARITHMETIC),
+    LintId::of(operators::INTEGER_DIVISION),
     LintId::of(panic_in_result_fn::PANIC_IN_RESULT_FN),
     LintId::of(panic_unimplemented::PANIC),
     LintId::of(panic_unimplemented::TODO),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 327a1150952..4c4d149e177 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -254,7 +254,6 @@ mod inherent_to_string;
 mod init_numbered_fields;
 mod inline_fn_without_body;
 mod int_plus_one;
-mod integer_division;
 mod invalid_upcast_comparisons;
 mod items_after_statements;
 mod iter_not_returning_iterator;
@@ -734,7 +733,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(assertions_on_constants::AssertionsOnConstants));
     store.register_late_pass(|| Box::new(transmuting_null::TransmutingNull));
     store.register_late_pass(|| Box::new(path_buf_push_overwrite::PathBufPushOverwrite));
-    store.register_late_pass(|| Box::new(integer_division::IntegerDivision));
     store.register_late_pass(|| Box::new(inherent_to_string::InherentToString));
     let max_trait_bounds = conf.max_trait_bounds;
     store.register_late_pass(move || Box::new(trait_bounds::TraitBounds::new(max_trait_bounds)));
diff --git a/clippy_lints/src/operators/integer_division.rs b/clippy_lints/src/operators/integer_division.rs
new file mode 100644
index 00000000000..631d10f4a72
--- /dev/null
+++ b/clippy_lints/src/operators/integer_division.rs
@@ -0,0 +1,27 @@
+use clippy_utils::diagnostics::span_lint_and_help;
+use rustc_hir as hir;
+use rustc_lint::LateContext;
+
+use super::INTEGER_DIVISION;
+
+pub(crate) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx hir::Expr<'_>,
+    op: hir::BinOpKind,
+    left: &'tcx hir::Expr<'_>,
+    right: &'tcx hir::Expr<'_>,
+) {
+    if op == hir::BinOpKind::Div
+        && cx.typeck_results().expr_ty(left).is_integral()
+        && cx.typeck_results().expr_ty(right).is_integral()
+    {
+        span_lint_and_help(
+            cx,
+            INTEGER_DIVISION,
+            expr.span,
+            "integer division",
+            None,
+            "division of integers may cause loss of precision. consider using floats",
+        );
+    }
+}
diff --git a/clippy_lints/src/operators/mod.rs b/clippy_lints/src/operators/mod.rs
index 91550e0e678..ea6a0083bc8 100644
--- a/clippy_lints/src/operators/mod.rs
+++ b/clippy_lints/src/operators/mod.rs
@@ -11,6 +11,7 @@ mod eq_op;
 mod erasing_op;
 mod float_equality_without_abs;
 mod identity_op;
+mod integer_division;
 mod misrefactored_assign_op;
 mod numeric_arithmetic;
 mod op_ref;
@@ -437,6 +438,32 @@ declare_clippy_lint! {
     "using identity operations, e.g., `x + 0` or `y / 1`"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for division of integers
+    ///
+    /// ### Why is this bad?
+    /// When outside of some very specific algorithms,
+    /// integer division is very often a mistake because it discards the
+    /// remainder.
+    ///
+    /// ### Example
+    /// ```rust
+    /// let x = 3 / 2;
+    /// println!("{}", x);
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust
+    /// let x = 3f32 / 2f32;
+    /// println!("{}", x);
+    /// ```
+    #[clippy::version = "1.37.0"]
+    pub INTEGER_DIVISION,
+    restriction,
+    "integer division may cause loss of precision"
+}
+
 pub struct Operators {
     arithmetic_context: numeric_arithmetic::Context,
     verbose_bit_mask_threshold: u64,
@@ -457,6 +484,7 @@ impl_lint_pass!(Operators => [
     ERASING_OP,
     FLOAT_EQUALITY_WITHOUT_ABS,
     IDENTITY_OP,
+    INTEGER_DIVISION,
 ]);
 impl Operators {
     pub fn new(verbose_bit_mask_threshold: u64) -> Self {
@@ -486,6 +514,7 @@ impl<'tcx> LateLintPass<'tcx> for Operators {
                 double_comparison::check(cx, op.node, lhs, rhs, e.span);
                 duration_subsec::check(cx, e, op.node, lhs, rhs);
                 float_equality_without_abs::check(cx, e, op.node, lhs, rhs);
+                integer_division::check(cx, e, op.node, lhs, rhs);
             },
             ExprKind::AssignOp(op, lhs, rhs) => {
                 self.arithmetic_context.check_binary(cx, e, op.node, lhs, rhs);
-- 
cgit 1.4.1-3-g733a5


From c0b0ee5bdcbf9005cdd7f48e0ad350b42387e1c6 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Wed, 1 Jun 2022 02:06:12 -0400
Subject: Move some lints from `Misc` to `Operators`

---
 clippy_lints/src/lib.register_all.rs         |   6 +-
 clippy_lints/src/lib.register_correctness.rs |   4 +-
 clippy_lints/src/lib.register_lints.rs       |  10 +-
 clippy_lints/src/lib.register_pedantic.rs    |   2 +-
 clippy_lints/src/lib.register_perf.rs        |   2 +-
 clippy_lints/src/lib.register_restriction.rs |   2 +-
 clippy_lints/src/misc.rs                     | 483 +--------------------------
 clippy_lints/src/operators/cmp_nan.rs        |  30 ++
 clippy_lints/src/operators/cmp_owned.rs      | 147 ++++++++
 clippy_lints/src/operators/float_cmp.rs      | 139 ++++++++
 clippy_lints/src/operators/mod.rs            | 163 +++++++++
 clippy_lints/src/operators/modulo_one.rs     |  26 ++
 12 files changed, 524 insertions(+), 490 deletions(-)
 create mode 100644 clippy_lints/src/operators/cmp_nan.rs
 create mode 100644 clippy_lints/src/operators/cmp_owned.rs
 create mode 100644 clippy_lints/src/operators/float_cmp.rs
 create mode 100644 clippy_lints/src/operators/modulo_one.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index fb08d7d112d..06f8a6325ff 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -212,9 +212,6 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(methods::WRONG_SELF_CONVENTION),
     LintId::of(methods::ZST_OFFSET),
     LintId::of(minmax::MIN_MAX),
-    LintId::of(misc::CMP_NAN),
-    LintId::of(misc::CMP_OWNED),
-    LintId::of(misc::MODULO_ONE),
     LintId::of(misc::SHORT_CIRCUIT_STATEMENT),
     LintId::of(misc::TOPLEVEL_REF_ARG),
     LintId::of(misc::ZERO_PTR),
@@ -251,6 +248,8 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(operators::ABSURD_EXTREME_COMPARISONS),
     LintId::of(operators::ASSIGN_OP_PATTERN),
     LintId::of(operators::BAD_BIT_MASK),
+    LintId::of(operators::CMP_NAN),
+    LintId::of(operators::CMP_OWNED),
     LintId::of(operators::DOUBLE_COMPARISONS),
     LintId::of(operators::DURATION_SUBSEC),
     LintId::of(operators::EQ_OP),
@@ -259,6 +258,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(operators::IDENTITY_OP),
     LintId::of(operators::INEFFECTIVE_BIT_MASK),
     LintId::of(operators::MISREFACTORED_ASSIGN_OP),
+    LintId::of(operators::MODULO_ONE),
     LintId::of(operators::OP_REF),
     LintId::of(option_env_unwrap::OPTION_ENV_UNWRAP),
     LintId::of(overflow_check_conditional::OVERFLOW_CHECK_CONDITIONAL),
diff --git a/clippy_lints/src/lib.register_correctness.rs b/clippy_lints/src/lib.register_correctness.rs
index b8362d5a72d..7133b6cdd88 100644
--- a/clippy_lints/src/lib.register_correctness.rs
+++ b/clippy_lints/src/lib.register_correctness.rs
@@ -42,15 +42,15 @@ store.register_group(true, "clippy::correctness", Some("clippy_correctness"), ve
     LintId::of(methods::UNINIT_ASSUMED_INIT),
     LintId::of(methods::ZST_OFFSET),
     LintId::of(minmax::MIN_MAX),
-    LintId::of(misc::CMP_NAN),
-    LintId::of(misc::MODULO_ONE),
     LintId::of(non_octal_unix_permissions::NON_OCTAL_UNIX_PERMISSIONS),
     LintId::of(open_options::NONSENSICAL_OPEN_OPTIONS),
     LintId::of(operators::ABSURD_EXTREME_COMPARISONS),
     LintId::of(operators::BAD_BIT_MASK),
+    LintId::of(operators::CMP_NAN),
     LintId::of(operators::EQ_OP),
     LintId::of(operators::ERASING_OP),
     LintId::of(operators::INEFFECTIVE_BIT_MASK),
+    LintId::of(operators::MODULO_ONE),
     LintId::of(option_env_unwrap::OPTION_ENV_UNWRAP),
     LintId::of(ptr::INVALID_NULL_PTR_USAGE),
     LintId::of(ptr::MUT_FROM_REF),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 7acfdf56840..139b55e965f 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -356,11 +356,6 @@ store.register_lints(&[
     methods::WRONG_SELF_CONVENTION,
     methods::ZST_OFFSET,
     minmax::MIN_MAX,
-    misc::CMP_NAN,
-    misc::CMP_OWNED,
-    misc::FLOAT_CMP,
-    misc::FLOAT_CMP_CONST,
-    misc::MODULO_ONE,
     misc::SHORT_CIRCUIT_STATEMENT,
     misc::TOPLEVEL_REF_ARG,
     misc::USED_UNDERSCORE_BINDING,
@@ -424,17 +419,22 @@ store.register_lints(&[
     operators::ABSURD_EXTREME_COMPARISONS,
     operators::ASSIGN_OP_PATTERN,
     operators::BAD_BIT_MASK,
+    operators::CMP_NAN,
+    operators::CMP_OWNED,
     operators::DOUBLE_COMPARISONS,
     operators::DURATION_SUBSEC,
     operators::EQ_OP,
     operators::ERASING_OP,
     operators::FLOAT_ARITHMETIC,
+    operators::FLOAT_CMP,
+    operators::FLOAT_CMP_CONST,
     operators::FLOAT_EQUALITY_WITHOUT_ABS,
     operators::IDENTITY_OP,
     operators::INEFFECTIVE_BIT_MASK,
     operators::INTEGER_ARITHMETIC,
     operators::INTEGER_DIVISION,
     operators::MISREFACTORED_ASSIGN_OP,
+    operators::MODULO_ONE,
     operators::OP_REF,
     operators::VERBOSE_BIT_MASK,
     option_env_unwrap::OPTION_ENV_UNWRAP,
diff --git a/clippy_lints/src/lib.register_pedantic.rs b/clippy_lints/src/lib.register_pedantic.rs
index b1603afa25f..0c02c2bef56 100644
--- a/clippy_lints/src/lib.register_pedantic.rs
+++ b/clippy_lints/src/lib.register_pedantic.rs
@@ -64,7 +64,6 @@ store.register_group(true, "clippy::pedantic", Some("clippy_pedantic"), vec![
     LintId::of(methods::INEFFICIENT_TO_STRING),
     LintId::of(methods::MAP_UNWRAP_OR),
     LintId::of(methods::UNNECESSARY_JOIN),
-    LintId::of(misc::FLOAT_CMP),
     LintId::of(misc::USED_UNDERSCORE_BINDING),
     LintId::of(mismatching_type_param_order::MISMATCHING_TYPE_PARAM_ORDER),
     LintId::of(mut_mut::MUT_MUT),
@@ -75,6 +74,7 @@ store.register_group(true, "clippy::pedantic", Some("clippy_pedantic"), vec![
     LintId::of(no_effect::NO_EFFECT_UNDERSCORE_BINDING),
     LintId::of(non_expressive_names::MANY_SINGLE_CHAR_NAMES),
     LintId::of(non_expressive_names::SIMILAR_NAMES),
+    LintId::of(operators::FLOAT_CMP),
     LintId::of(operators::VERBOSE_BIT_MASK),
     LintId::of(pass_by_ref_or_value::LARGE_TYPES_PASSED_BY_VALUE),
     LintId::of(pass_by_ref_or_value::TRIVIALLY_COPY_PASS_BY_REF),
diff --git a/clippy_lints/src/lib.register_perf.rs b/clippy_lints/src/lib.register_perf.rs
index 2233b118849..6bf519c24e8 100644
--- a/clippy_lints/src/lib.register_perf.rs
+++ b/clippy_lints/src/lib.register_perf.rs
@@ -22,7 +22,7 @@ store.register_group(true, "clippy::perf", Some("clippy_perf"), vec![
     LintId::of(methods::OR_FUN_CALL),
     LintId::of(methods::SINGLE_CHAR_PATTERN),
     LintId::of(methods::UNNECESSARY_TO_OWNED),
-    LintId::of(misc::CMP_OWNED),
+    LintId::of(operators::CMP_OWNED),
     LintId::of(redundant_clone::REDUNDANT_CLONE),
     LintId::of(slow_vector_initialization::SLOW_VECTOR_INITIALIZATION),
     LintId::of(types::BOX_COLLECTION),
diff --git a/clippy_lints/src/lib.register_restriction.rs b/clippy_lints/src/lib.register_restriction.rs
index 53d968c4710..e66dc67f3dc 100644
--- a/clippy_lints/src/lib.register_restriction.rs
+++ b/clippy_lints/src/lib.register_restriction.rs
@@ -38,7 +38,6 @@ store.register_group(true, "clippy::restriction", Some("clippy_restriction"), ve
     LintId::of(methods::FILETYPE_IS_FILE),
     LintId::of(methods::GET_UNWRAP),
     LintId::of(methods::UNWRAP_USED),
-    LintId::of(misc::FLOAT_CMP_CONST),
     LintId::of(misc_early::SEPARATED_LITERAL_SUFFIX),
     LintId::of(misc_early::UNNEEDED_FIELD_PATTERN),
     LintId::of(misc_early::UNSEPARATED_LITERAL_SUFFIX),
@@ -50,6 +49,7 @@ store.register_group(true, "clippy::restriction", Some("clippy_restriction"), ve
     LintId::of(module_style::SELF_NAMED_MODULE_FILES),
     LintId::of(modulo_arithmetic::MODULO_ARITHMETIC),
     LintId::of(operators::FLOAT_ARITHMETIC),
+    LintId::of(operators::FLOAT_CMP_CONST),
     LintId::of(operators::INTEGER_ARITHMETIC),
     LintId::of(operators::INTEGER_DIVISION),
     LintId::of(panic_in_result_fn::PANIC_IN_RESULT_FN),
diff --git a/clippy_lints/src/misc.rs b/clippy_lints/src/misc.rs
index 01bf871198a..df2430ced6b 100644
--- a/clippy_lints/src/misc.rs
+++ b/clippy_lints/src/misc.rs
@@ -1,28 +1,21 @@
-use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg, span_lint_and_then, span_lint_hir_and_then};
+use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg, span_lint_hir_and_then};
 use clippy_utils::source::{snippet, snippet_opt};
-use clippy_utils::ty::{implements_trait, is_copy};
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::{
     self as hir, def, BinOpKind, BindingAnnotation, Body, Expr, ExprKind, FnDecl, HirId, Mutability, PatKind, Stmt,
-    StmtKind, TyKind, UnOp,
+    StmtKind, TyKind,
 };
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::lint::in_external_macro;
-use rustc_middle::ty::{self, Ty};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::hygiene::DesugaringKind;
 use rustc_span::source_map::{ExpnKind, Span};
-use rustc_span::symbol::sym;
 
-use clippy_utils::consts::{constant, Constant};
 use clippy_utils::sugg::Sugg;
-use clippy_utils::{
-    get_item_name, get_parent_expr, in_constant, is_integer_const, iter_input_pats, last_path_segment,
-    match_any_def_paths, path_def_id, paths, unsext, SpanlessEq,
-};
+use clippy_utils::{get_parent_expr, in_constant, iter_input_pats, last_path_segment, SpanlessEq};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -58,122 +51,6 @@ declare_clippy_lint! {
     style,
     "an entire binding declared as `ref`, in a function argument or a `let` statement"
 }
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for comparisons to NaN.
-    ///
-    /// ### Why is this bad?
-    /// NaN does not compare meaningfully to anything – not
-    /// even itself – so those comparisons are simply wrong.
-    ///
-    /// ### Example
-    /// ```rust
-    /// # let x = 1.0;
-    /// if x == f32::NAN { }
-    /// ```
-    ///
-    /// Use instead:
-    /// ```rust
-    /// # let x = 1.0f32;
-    /// if x.is_nan() { }
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub CMP_NAN,
-    correctness,
-    "comparisons to `NAN`, which will always return false, probably not intended"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for (in-)equality comparisons on floating-point
-    /// values (apart from zero), except in functions called `*eq*` (which probably
-    /// implement equality for a type involving floats).
-    ///
-    /// ### Why is this bad?
-    /// Floating point calculations are usually imprecise, so
-    /// asking if two values are *exactly* equal is asking for trouble. For a good
-    /// guide on what to do, see [the floating point
-    /// guide](http://www.floating-point-gui.de/errors/comparison).
-    ///
-    /// ### Example
-    /// ```rust
-    /// let x = 1.2331f64;
-    /// let y = 1.2332f64;
-    ///
-    /// if y == 1.23f64 { }
-    /// if y != x {} // where both are floats
-    /// ```
-    ///
-    /// Use instead:
-    /// ```rust
-    /// # let x = 1.2331f64;
-    /// # let y = 1.2332f64;
-    /// let error_margin = f64::EPSILON; // Use an epsilon for comparison
-    /// // Or, if Rust <= 1.42, use `std::f64::EPSILON` constant instead.
-    /// // let error_margin = std::f64::EPSILON;
-    /// if (y - 1.23f64).abs() < error_margin { }
-    /// if (y - x).abs() > error_margin { }
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub FLOAT_CMP,
-    pedantic,
-    "using `==` or `!=` on float values instead of comparing difference with an epsilon"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for conversions to owned values just for the sake
-    /// of a comparison.
-    ///
-    /// ### Why is this bad?
-    /// The comparison can operate on a reference, so creating
-    /// an owned value effectively throws it away directly afterwards, which is
-    /// needlessly consuming code and heap space.
-    ///
-    /// ### Example
-    /// ```rust
-    /// # let x = "foo";
-    /// # let y = String::from("foo");
-    /// if x.to_owned() == y {}
-    /// ```
-    ///
-    /// Use instead:
-    /// ```rust
-    /// # let x = "foo";
-    /// # let y = String::from("foo");
-    /// if x == y {}
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub CMP_OWNED,
-    perf,
-    "creating owned instances for comparing with others, e.g., `x == \"foo\".to_string()`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for getting the remainder of a division by one or minus
-    /// one.
-    ///
-    /// ### Why is this bad?
-    /// The result for a divisor of one can only ever be zero; for
-    /// minus one it can cause panic/overflow (if the left operand is the minimal value of
-    /// the respective integer type) or results in zero. No one will write such code
-    /// deliberately, unless trying to win an Underhanded Rust Contest. Even for that
-    /// contest, it's probably a bad idea. Use something more underhanded.
-    ///
-    /// ### Example
-    /// ```rust
-    /// # let x = 1;
-    /// let a = x % 1;
-    /// let a = x % -1;
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub MODULO_ONE,
-    correctness,
-    "taking a number modulo +/-1, which can either panic/overflow or always returns 0"
-}
-
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for the use of bindings with a single leading
@@ -244,51 +121,11 @@ declare_clippy_lint! {
     "using `0 as *{const, mut} T`"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for (in-)equality comparisons on floating-point
-    /// value and constant, except in functions called `*eq*` (which probably
-    /// implement equality for a type involving floats).
-    ///
-    /// ### Why is this bad?
-    /// Floating point calculations are usually imprecise, so
-    /// asking if two values are *exactly* equal is asking for trouble. For a good
-    /// guide on what to do, see [the floating point
-    /// guide](http://www.floating-point-gui.de/errors/comparison).
-    ///
-    /// ### Example
-    /// ```rust
-    /// let x: f64 = 1.0;
-    /// const ONE: f64 = 1.00;
-    ///
-    /// if x == ONE { } // where both are floats
-    /// ```
-    ///
-    /// Use instead:
-    /// ```rust
-    /// # let x: f64 = 1.0;
-    /// # const ONE: f64 = 1.00;
-    /// let error_margin = f64::EPSILON; // Use an epsilon for comparison
-    /// // Or, if Rust <= 1.42, use `std::f64::EPSILON` constant instead.
-    /// // let error_margin = std::f64::EPSILON;
-    /// if (x - ONE).abs() < error_margin { }
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub FLOAT_CMP_CONST,
-    restriction,
-    "using `==` or `!=` on float constants instead of comparing difference with an epsilon"
-}
-
 declare_lint_pass!(MiscLints => [
     TOPLEVEL_REF_ARG,
-    CMP_NAN,
-    FLOAT_CMP,
-    CMP_OWNED,
-    MODULO_ONE,
     USED_UNDERSCORE_BINDING,
     SHORT_CIRCUIT_STATEMENT,
     ZERO_PTR,
-    FLOAT_CMP_CONST
 ]);
 
 impl<'tcx> LateLintPass<'tcx> for MiscLints {
@@ -398,16 +235,9 @@ impl<'tcx> LateLintPass<'tcx> for MiscLints {
     }
 
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        match expr.kind {
-            ExprKind::Cast(e, ty) => {
-                check_cast(cx, expr.span, e, ty);
-                return;
-            },
-            ExprKind::Binary(ref cmp, left, right) => {
-                check_binary(cx, expr, cmp, left, right);
-                return;
-            },
-            _ => {},
+        if let ExprKind::Cast(e, ty) = expr.kind {
+            check_cast(cx, expr.span, e, ty);
+            return;
         }
         if in_attributes_expansion(expr) || expr.span.is_desugaring(DesugaringKind::Await) {
             // Don't lint things expanded by #[derive(...)], etc or `await` desugaring
@@ -455,236 +285,6 @@ impl<'tcx> LateLintPass<'tcx> for MiscLints {
     }
 }
 
-fn get_lint_and_message(
-    is_comparing_constants: bool,
-    is_comparing_arrays: bool,
-) -> (&'static rustc_lint::Lint, &'static str) {
-    if is_comparing_constants {
-        (
-            FLOAT_CMP_CONST,
-            if is_comparing_arrays {
-                "strict comparison of `f32` or `f64` constant arrays"
-            } else {
-                "strict comparison of `f32` or `f64` constant"
-            },
-        )
-    } else {
-        (
-            FLOAT_CMP,
-            if is_comparing_arrays {
-                "strict comparison of `f32` or `f64` arrays"
-            } else {
-                "strict comparison of `f32` or `f64`"
-            },
-        )
-    }
-}
-
-fn check_nan(cx: &LateContext<'_>, expr: &Expr<'_>, cmp_expr: &Expr<'_>) {
-    if_chain! {
-        if !in_constant(cx, cmp_expr.hir_id);
-        if let Some((value, _)) = constant(cx, cx.typeck_results(), expr);
-        if match value {
-            Constant::F32(num) => num.is_nan(),
-            Constant::F64(num) => num.is_nan(),
-            _ => false,
-        };
-        then {
-            span_lint(
-                cx,
-                CMP_NAN,
-                cmp_expr.span,
-                "doomed comparison with `NAN`, use `{f32,f64}::is_nan()` instead",
-            );
-        }
-    }
-}
-
-fn is_named_constant<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> bool {
-    if let Some((_, res)) = constant(cx, cx.typeck_results(), expr) {
-        res
-    } else {
-        false
-    }
-}
-
-fn is_allowed<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> bool {
-    match constant(cx, cx.typeck_results(), expr) {
-        Some((Constant::F32(f), _)) => f == 0.0 || f.is_infinite(),
-        Some((Constant::F64(f), _)) => f == 0.0 || f.is_infinite(),
-        Some((Constant::Vec(vec), _)) => vec.iter().all(|f| match f {
-            Constant::F32(f) => *f == 0.0 || (*f).is_infinite(),
-            Constant::F64(f) => *f == 0.0 || (*f).is_infinite(),
-            _ => false,
-        }),
-        _ => false,
-    }
-}
-
-// Return true if `expr` is the result of `signum()` invoked on a float value.
-fn is_signum(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-    // The negation of a signum is still a signum
-    if let ExprKind::Unary(UnOp::Neg, child_expr) = expr.kind {
-        return is_signum(cx, child_expr);
-    }
-
-    if_chain! {
-        if let ExprKind::MethodCall(method_name, [ref self_arg, ..], _) = expr.kind;
-        if sym!(signum) == method_name.ident.name;
-        // Check that the receiver of the signum() is a float (expressions[0] is the receiver of
-        // the method call)
-        then {
-            return is_float(cx, self_arg);
-        }
-    }
-    false
-}
-
-fn is_float(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-    let value = &cx.typeck_results().expr_ty(expr).peel_refs().kind();
-
-    if let ty::Array(arr_ty, _) = value {
-        return matches!(arr_ty.kind(), ty::Float(_));
-    };
-
-    matches!(value, ty::Float(_))
-}
-
-fn is_array(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-    matches!(&cx.typeck_results().expr_ty(expr).peel_refs().kind(), ty::Array(_, _))
-}
-
-#[expect(clippy::too_many_lines)]
-fn check_to_owned(cx: &LateContext<'_>, expr: &Expr<'_>, other: &Expr<'_>, left: bool) {
-    #[derive(Default)]
-    struct EqImpl {
-        ty_eq_other: bool,
-        other_eq_ty: bool,
-    }
-
-    impl EqImpl {
-        fn is_implemented(&self) -> bool {
-            self.ty_eq_other || self.other_eq_ty
-        }
-    }
-
-    fn symmetric_partial_eq<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>, other: Ty<'tcx>) -> Option<EqImpl> {
-        cx.tcx.lang_items().eq_trait().map(|def_id| EqImpl {
-            ty_eq_other: implements_trait(cx, ty, def_id, &[other.into()]),
-            other_eq_ty: implements_trait(cx, other, def_id, &[ty.into()]),
-        })
-    }
-
-    let typeck = cx.typeck_results();
-    let (arg, arg_span) = match expr.kind {
-        ExprKind::MethodCall(.., [arg], _)
-            if typeck
-                .type_dependent_def_id(expr.hir_id)
-                .and_then(|id| cx.tcx.trait_of_item(id))
-                .map_or(false, |id| {
-                    matches!(cx.tcx.get_diagnostic_name(id), Some(sym::ToString | sym::ToOwned))
-                }) =>
-        {
-            (arg, arg.span)
-        },
-        ExprKind::Call(path, [arg])
-            if path_def_id(cx, path)
-                .and_then(|id| match_any_def_paths(cx, id, &[&paths::FROM_STR_METHOD, &paths::FROM_FROM]))
-                .map_or(false, |idx| match idx {
-                    0 => true,
-                    1 => !is_copy(cx, typeck.expr_ty(expr)),
-                    _ => false,
-                }) =>
-        {
-            (arg, arg.span)
-        },
-        _ => return,
-    };
-
-    let arg_ty = typeck.expr_ty(arg);
-    let other_ty = typeck.expr_ty(other);
-
-    let without_deref = symmetric_partial_eq(cx, arg_ty, other_ty).unwrap_or_default();
-    let with_deref = arg_ty
-        .builtin_deref(true)
-        .and_then(|tam| symmetric_partial_eq(cx, tam.ty, other_ty))
-        .unwrap_or_default();
-
-    if !with_deref.is_implemented() && !without_deref.is_implemented() {
-        return;
-    }
-
-    let other_gets_derefed = matches!(other.kind, ExprKind::Unary(UnOp::Deref, _));
-
-    let lint_span = if other_gets_derefed {
-        expr.span.to(other.span)
-    } else {
-        expr.span
-    };
-
-    span_lint_and_then(
-        cx,
-        CMP_OWNED,
-        lint_span,
-        "this creates an owned instance just for comparison",
-        |diag| {
-            // This also catches `PartialEq` implementations that call `to_owned`.
-            if other_gets_derefed {
-                diag.span_label(lint_span, "try implementing the comparison without allocating");
-                return;
-            }
-
-            let arg_snip = snippet(cx, arg_span, "..");
-            let expr_snip;
-            let eq_impl;
-            if with_deref.is_implemented() {
-                expr_snip = format!("*{}", arg_snip);
-                eq_impl = with_deref;
-            } else {
-                expr_snip = arg_snip.to_string();
-                eq_impl = without_deref;
-            };
-
-            let span;
-            let hint;
-            if (eq_impl.ty_eq_other && left) || (eq_impl.other_eq_ty && !left) {
-                span = expr.span;
-                hint = expr_snip;
-            } else {
-                span = expr.span.to(other.span);
-
-                let cmp_span = if other.span < expr.span {
-                    other.span.between(expr.span)
-                } else {
-                    expr.span.between(other.span)
-                };
-                if eq_impl.ty_eq_other {
-                    hint = format!(
-                        "{}{}{}",
-                        expr_snip,
-                        snippet(cx, cmp_span, ".."),
-                        snippet(cx, other.span, "..")
-                    );
-                } else {
-                    hint = format!(
-                        "{}{}{}",
-                        snippet(cx, other.span, ".."),
-                        snippet(cx, cmp_span, ".."),
-                        expr_snip
-                    );
-                }
-            }
-
-            diag.span_suggestion(
-                span,
-                "try",
-                hint,
-                Applicability::MachineApplicable, // snippet
-            );
-        },
-    );
-}
-
 /// Heuristic to see if an expression is used. Should be compatible with
 /// `unused_variables`'s idea
 /// of what it means for an expression to be "used".
@@ -740,74 +340,3 @@ fn check_cast(cx: &LateContext<'_>, span: Span, e: &Expr<'_>, ty: &hir::Ty<'_>)
         }
     }
 }
-
-fn check_binary<'a>(
-    cx: &LateContext<'a>,
-    expr: &Expr<'_>,
-    cmp: &rustc_span::source_map::Spanned<rustc_hir::BinOpKind>,
-    left: &'a Expr<'_>,
-    right: &'a Expr<'_>,
-) {
-    let op = cmp.node;
-    if op.is_comparison() {
-        check_nan(cx, left, expr);
-        check_nan(cx, right, expr);
-        check_to_owned(cx, left, right, true);
-        check_to_owned(cx, right, left, false);
-    }
-    if (op == BinOpKind::Eq || op == BinOpKind::Ne) && (is_float(cx, left) || is_float(cx, right)) {
-        if is_allowed(cx, left) || is_allowed(cx, right) {
-            return;
-        }
-
-        // Allow comparing the results of signum()
-        if is_signum(cx, left) && is_signum(cx, right) {
-            return;
-        }
-
-        if let Some(name) = get_item_name(cx, expr) {
-            let name = name.as_str();
-            if name == "eq" || name == "ne" || name == "is_nan" || name.starts_with("eq_") || name.ends_with("_eq") {
-                return;
-            }
-        }
-        let is_comparing_arrays = is_array(cx, left) || is_array(cx, right);
-        let (lint, msg) = get_lint_and_message(
-            is_named_constant(cx, left) || is_named_constant(cx, right),
-            is_comparing_arrays,
-        );
-        span_lint_and_then(cx, lint, expr.span, msg, |diag| {
-            let lhs = Sugg::hir(cx, left, "..");
-            let rhs = Sugg::hir(cx, right, "..");
-
-            if !is_comparing_arrays {
-                diag.span_suggestion(
-                    expr.span,
-                    "consider comparing them within some margin of error",
-                    format!(
-                        "({}).abs() {} error_margin",
-                        lhs - rhs,
-                        if op == BinOpKind::Eq { '<' } else { '>' }
-                    ),
-                    Applicability::HasPlaceholders, // snippet
-                );
-            }
-            diag.note("`f32::EPSILON` and `f64::EPSILON` are available for the `error_margin`");
-        });
-    } else if op == BinOpKind::Rem {
-        if is_integer_const(cx, right, 1) {
-            span_lint(cx, MODULO_ONE, expr.span, "any number modulo 1 will be 0");
-        }
-
-        if let ty::Int(ity) = cx.typeck_results().expr_ty(right).kind() {
-            if is_integer_const(cx, right, unsext(cx.tcx, -1, *ity)) {
-                span_lint(
-                    cx,
-                    MODULO_ONE,
-                    expr.span,
-                    "any number modulo -1 will panic/overflow or result in 0",
-                );
-            }
-        };
-    }
-}
diff --git a/clippy_lints/src/operators/cmp_nan.rs b/clippy_lints/src/operators/cmp_nan.rs
new file mode 100644
index 00000000000..786ae1552ad
--- /dev/null
+++ b/clippy_lints/src/operators/cmp_nan.rs
@@ -0,0 +1,30 @@
+use clippy_utils::consts::{constant, Constant};
+use clippy_utils::diagnostics::span_lint;
+use clippy_utils::in_constant;
+use rustc_hir::{BinOpKind, Expr};
+use rustc_lint::LateContext;
+
+use super::CMP_NAN;
+
+pub(super) fn check(cx: &LateContext<'_>, e: &Expr<'_>, op: BinOpKind, lhs: &Expr<'_>, rhs: &Expr<'_>) {
+    if op.is_comparison() && !in_constant(cx, e.hir_id) && (is_nan(cx, lhs) || is_nan(cx, rhs)) {
+        span_lint(
+            cx,
+            CMP_NAN,
+            e.span,
+            "doomed comparison with `NAN`, use `{f32,f64}::is_nan()` instead",
+        );
+    }
+}
+
+fn is_nan(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
+    if let Some((value, _)) = constant(cx, cx.typeck_results(), e) {
+        match value {
+            Constant::F32(num) => num.is_nan(),
+            Constant::F64(num) => num.is_nan(),
+            _ => false,
+        }
+    } else {
+        false
+    }
+}
diff --git a/clippy_lints/src/operators/cmp_owned.rs b/clippy_lints/src/operators/cmp_owned.rs
new file mode 100644
index 00000000000..e1f9b5906f6
--- /dev/null
+++ b/clippy_lints/src/operators/cmp_owned.rs
@@ -0,0 +1,147 @@
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::source::snippet;
+use clippy_utils::ty::{implements_trait, is_copy};
+use clippy_utils::{match_any_def_paths, path_def_id, paths};
+use rustc_errors::Applicability;
+use rustc_hir::{BinOpKind, Expr, ExprKind, UnOp};
+use rustc_lint::LateContext;
+use rustc_middle::ty::Ty;
+use rustc_span::symbol::sym;
+
+use super::CMP_OWNED;
+
+pub(super) fn check(cx: &LateContext<'_>, op: BinOpKind, lhs: &Expr<'_>, rhs: &Expr<'_>) {
+    if op.is_comparison() {
+        check_op(cx, lhs, rhs, true);
+        check_op(cx, rhs, lhs, false);
+    }
+}
+
+#[derive(Default)]
+struct EqImpl {
+    ty_eq_other: bool,
+    other_eq_ty: bool,
+}
+impl EqImpl {
+    fn is_implemented(&self) -> bool {
+        self.ty_eq_other || self.other_eq_ty
+    }
+}
+
+fn symmetric_partial_eq<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>, other: Ty<'tcx>) -> Option<EqImpl> {
+    cx.tcx.lang_items().eq_trait().map(|def_id| EqImpl {
+        ty_eq_other: implements_trait(cx, ty, def_id, &[other.into()]),
+        other_eq_ty: implements_trait(cx, other, def_id, &[ty.into()]),
+    })
+}
+
+fn check_op(cx: &LateContext<'_>, expr: &Expr<'_>, other: &Expr<'_>, left: bool) {
+    let typeck = cx.typeck_results();
+    let (arg, arg_span) = match expr.kind {
+        ExprKind::MethodCall(.., [arg], _)
+            if typeck
+                .type_dependent_def_id(expr.hir_id)
+                .and_then(|id| cx.tcx.trait_of_item(id))
+                .map_or(false, |id| {
+                    matches!(cx.tcx.get_diagnostic_name(id), Some(sym::ToString | sym::ToOwned))
+                }) =>
+        {
+            (arg, arg.span)
+        },
+        ExprKind::Call(path, [arg])
+            if path_def_id(cx, path)
+                .and_then(|id| match_any_def_paths(cx, id, &[&paths::FROM_STR_METHOD, &paths::FROM_FROM]))
+                .map_or(false, |idx| match idx {
+                    0 => true,
+                    1 => !is_copy(cx, typeck.expr_ty(expr)),
+                    _ => false,
+                }) =>
+        {
+            (arg, arg.span)
+        },
+        _ => return,
+    };
+
+    let arg_ty = typeck.expr_ty(arg);
+    let other_ty = typeck.expr_ty(other);
+
+    let without_deref = symmetric_partial_eq(cx, arg_ty, other_ty).unwrap_or_default();
+    let with_deref = arg_ty
+        .builtin_deref(true)
+        .and_then(|tam| symmetric_partial_eq(cx, tam.ty, other_ty))
+        .unwrap_or_default();
+
+    if !with_deref.is_implemented() && !without_deref.is_implemented() {
+        return;
+    }
+
+    let other_gets_derefed = matches!(other.kind, ExprKind::Unary(UnOp::Deref, _));
+
+    let lint_span = if other_gets_derefed {
+        expr.span.to(other.span)
+    } else {
+        expr.span
+    };
+
+    span_lint_and_then(
+        cx,
+        CMP_OWNED,
+        lint_span,
+        "this creates an owned instance just for comparison",
+        |diag| {
+            // This also catches `PartialEq` implementations that call `to_owned`.
+            if other_gets_derefed {
+                diag.span_label(lint_span, "try implementing the comparison without allocating");
+                return;
+            }
+
+            let arg_snip = snippet(cx, arg_span, "..");
+            let expr_snip;
+            let eq_impl;
+            if with_deref.is_implemented() {
+                expr_snip = format!("*{}", arg_snip);
+                eq_impl = with_deref;
+            } else {
+                expr_snip = arg_snip.to_string();
+                eq_impl = without_deref;
+            };
+
+            let span;
+            let hint;
+            if (eq_impl.ty_eq_other && left) || (eq_impl.other_eq_ty && !left) {
+                span = expr.span;
+                hint = expr_snip;
+            } else {
+                span = expr.span.to(other.span);
+
+                let cmp_span = if other.span < expr.span {
+                    other.span.between(expr.span)
+                } else {
+                    expr.span.between(other.span)
+                };
+                if eq_impl.ty_eq_other {
+                    hint = format!(
+                        "{}{}{}",
+                        expr_snip,
+                        snippet(cx, cmp_span, ".."),
+                        snippet(cx, other.span, "..")
+                    );
+                } else {
+                    hint = format!(
+                        "{}{}{}",
+                        snippet(cx, other.span, ".."),
+                        snippet(cx, cmp_span, ".."),
+                        expr_snip
+                    );
+                }
+            }
+
+            diag.span_suggestion(
+                span,
+                "try",
+                hint,
+                Applicability::MachineApplicable, // snippet
+            );
+        },
+    );
+}
diff --git a/clippy_lints/src/operators/float_cmp.rs b/clippy_lints/src/operators/float_cmp.rs
new file mode 100644
index 00000000000..0ef793443ff
--- /dev/null
+++ b/clippy_lints/src/operators/float_cmp.rs
@@ -0,0 +1,139 @@
+use clippy_utils::consts::{constant, Constant};
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::get_item_name;
+use clippy_utils::sugg::Sugg;
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir::{BinOpKind, Expr, ExprKind, UnOp};
+use rustc_lint::LateContext;
+use rustc_middle::ty;
+
+use super::{FLOAT_CMP, FLOAT_CMP_CONST};
+
+pub(crate) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx Expr<'_>,
+    op: BinOpKind,
+    left: &'tcx Expr<'_>,
+    right: &'tcx Expr<'_>,
+) {
+    if (op == BinOpKind::Eq || op == BinOpKind::Ne) && (is_float(cx, left) || is_float(cx, right)) {
+        if is_allowed(cx, left) || is_allowed(cx, right) {
+            return;
+        }
+
+        // Allow comparing the results of signum()
+        if is_signum(cx, left) && is_signum(cx, right) {
+            return;
+        }
+
+        if let Some(name) = get_item_name(cx, expr) {
+            let name = name.as_str();
+            if name == "eq" || name == "ne" || name == "is_nan" || name.starts_with("eq_") || name.ends_with("_eq") {
+                return;
+            }
+        }
+        let is_comparing_arrays = is_array(cx, left) || is_array(cx, right);
+        let (lint, msg) = get_lint_and_message(
+            is_named_constant(cx, left) || is_named_constant(cx, right),
+            is_comparing_arrays,
+        );
+        span_lint_and_then(cx, lint, expr.span, msg, |diag| {
+            let lhs = Sugg::hir(cx, left, "..");
+            let rhs = Sugg::hir(cx, right, "..");
+
+            if !is_comparing_arrays {
+                diag.span_suggestion(
+                    expr.span,
+                    "consider comparing them within some margin of error",
+                    format!(
+                        "({}).abs() {} error_margin",
+                        lhs - rhs,
+                        if op == BinOpKind::Eq { '<' } else { '>' }
+                    ),
+                    Applicability::HasPlaceholders, // snippet
+                );
+            }
+            diag.note("`f32::EPSILON` and `f64::EPSILON` are available for the `error_margin`");
+        });
+    }
+}
+
+fn get_lint_and_message(
+    is_comparing_constants: bool,
+    is_comparing_arrays: bool,
+) -> (&'static rustc_lint::Lint, &'static str) {
+    if is_comparing_constants {
+        (
+            FLOAT_CMP_CONST,
+            if is_comparing_arrays {
+                "strict comparison of `f32` or `f64` constant arrays"
+            } else {
+                "strict comparison of `f32` or `f64` constant"
+            },
+        )
+    } else {
+        (
+            FLOAT_CMP,
+            if is_comparing_arrays {
+                "strict comparison of `f32` or `f64` arrays"
+            } else {
+                "strict comparison of `f32` or `f64`"
+            },
+        )
+    }
+}
+
+fn is_named_constant<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> bool {
+    if let Some((_, res)) = constant(cx, cx.typeck_results(), expr) {
+        res
+    } else {
+        false
+    }
+}
+
+fn is_allowed<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> bool {
+    match constant(cx, cx.typeck_results(), expr) {
+        Some((Constant::F32(f), _)) => f == 0.0 || f.is_infinite(),
+        Some((Constant::F64(f), _)) => f == 0.0 || f.is_infinite(),
+        Some((Constant::Vec(vec), _)) => vec.iter().all(|f| match f {
+            Constant::F32(f) => *f == 0.0 || (*f).is_infinite(),
+            Constant::F64(f) => *f == 0.0 || (*f).is_infinite(),
+            _ => false,
+        }),
+        _ => false,
+    }
+}
+
+// Return true if `expr` is the result of `signum()` invoked on a float value.
+fn is_signum(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+    // The negation of a signum is still a signum
+    if let ExprKind::Unary(UnOp::Neg, child_expr) = expr.kind {
+        return is_signum(cx, child_expr);
+    }
+
+    if_chain! {
+        if let ExprKind::MethodCall(method_name, [ref self_arg, ..], _) = expr.kind;
+        if sym!(signum) == method_name.ident.name;
+        // Check that the receiver of the signum() is a float (expressions[0] is the receiver of
+        // the method call)
+        then {
+            return is_float(cx, self_arg);
+        }
+    }
+    false
+}
+
+fn is_float(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+    let value = &cx.typeck_results().expr_ty(expr).peel_refs().kind();
+
+    if let ty::Array(arr_ty, _) = value {
+        return matches!(arr_ty.kind(), ty::Float(_));
+    };
+
+    matches!(value, ty::Float(_))
+}
+
+fn is_array(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+    matches!(&cx.typeck_results().expr_ty(expr).peel_refs().kind(), ty::Array(_, _))
+}
diff --git a/clippy_lints/src/operators/mod.rs b/clippy_lints/src/operators/mod.rs
index ea6a0083bc8..e4aff267fef 100644
--- a/clippy_lints/src/operators/mod.rs
+++ b/clippy_lints/src/operators/mod.rs
@@ -5,14 +5,18 @@ use rustc_session::{declare_tool_lint, impl_lint_pass};
 mod absurd_extreme_comparisons;
 mod assign_op_pattern;
 mod bit_mask;
+mod cmp_nan;
+mod cmp_owned;
 mod double_comparison;
 mod duration_subsec;
 mod eq_op;
 mod erasing_op;
+mod float_cmp;
 mod float_equality_without_abs;
 mod identity_op;
 mod integer_division;
 mod misrefactored_assign_op;
+mod modulo_one;
 mod numeric_arithmetic;
 mod op_ref;
 mod verbose_bit_mask;
@@ -464,6 +468,156 @@ declare_clippy_lint! {
     "integer division may cause loss of precision"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for comparisons to NaN.
+    ///
+    /// ### Why is this bad?
+    /// NaN does not compare meaningfully to anything – not
+    /// even itself – so those comparisons are simply wrong.
+    ///
+    /// ### Example
+    /// ```rust
+    /// # let x = 1.0;
+    /// if x == f32::NAN { }
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust
+    /// # let x = 1.0f32;
+    /// if x.is_nan() { }
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub CMP_NAN,
+    correctness,
+    "comparisons to `NAN`, which will always return false, probably not intended"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for conversions to owned values just for the sake
+    /// of a comparison.
+    ///
+    /// ### Why is this bad?
+    /// The comparison can operate on a reference, so creating
+    /// an owned value effectively throws it away directly afterwards, which is
+    /// needlessly consuming code and heap space.
+    ///
+    /// ### Example
+    /// ```rust
+    /// # let x = "foo";
+    /// # let y = String::from("foo");
+    /// if x.to_owned() == y {}
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust
+    /// # let x = "foo";
+    /// # let y = String::from("foo");
+    /// if x == y {}
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub CMP_OWNED,
+    perf,
+    "creating owned instances for comparing with others, e.g., `x == \"foo\".to_string()`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for (in-)equality comparisons on floating-point
+    /// values (apart from zero), except in functions called `*eq*` (which probably
+    /// implement equality for a type involving floats).
+    ///
+    /// ### Why is this bad?
+    /// Floating point calculations are usually imprecise, so
+    /// asking if two values are *exactly* equal is asking for trouble. For a good
+    /// guide on what to do, see [the floating point
+    /// guide](http://www.floating-point-gui.de/errors/comparison).
+    ///
+    /// ### Example
+    /// ```rust
+    /// let x = 1.2331f64;
+    /// let y = 1.2332f64;
+    ///
+    /// if y == 1.23f64 { }
+    /// if y != x {} // where both are floats
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust
+    /// # let x = 1.2331f64;
+    /// # let y = 1.2332f64;
+    /// let error_margin = f64::EPSILON; // Use an epsilon for comparison
+    /// // Or, if Rust <= 1.42, use `std::f64::EPSILON` constant instead.
+    /// // let error_margin = std::f64::EPSILON;
+    /// if (y - 1.23f64).abs() < error_margin { }
+    /// if (y - x).abs() > error_margin { }
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub FLOAT_CMP,
+    pedantic,
+    "using `==` or `!=` on float values instead of comparing difference with an epsilon"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for (in-)equality comparisons on floating-point
+    /// value and constant, except in functions called `*eq*` (which probably
+    /// implement equality for a type involving floats).
+    ///
+    /// ### Why is this bad?
+    /// Floating point calculations are usually imprecise, so
+    /// asking if two values are *exactly* equal is asking for trouble. For a good
+    /// guide on what to do, see [the floating point
+    /// guide](http://www.floating-point-gui.de/errors/comparison).
+    ///
+    /// ### Example
+    /// ```rust
+    /// let x: f64 = 1.0;
+    /// const ONE: f64 = 1.00;
+    ///
+    /// if x == ONE { } // where both are floats
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust
+    /// # let x: f64 = 1.0;
+    /// # const ONE: f64 = 1.00;
+    /// let error_margin = f64::EPSILON; // Use an epsilon for comparison
+    /// // Or, if Rust <= 1.42, use `std::f64::EPSILON` constant instead.
+    /// // let error_margin = std::f64::EPSILON;
+    /// if (x - ONE).abs() < error_margin { }
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub FLOAT_CMP_CONST,
+    restriction,
+    "using `==` or `!=` on float constants instead of comparing difference with an epsilon"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for getting the remainder of a division by one or minus
+    /// one.
+    ///
+    /// ### Why is this bad?
+    /// The result for a divisor of one can only ever be zero; for
+    /// minus one it can cause panic/overflow (if the left operand is the minimal value of
+    /// the respective integer type) or results in zero. No one will write such code
+    /// deliberately, unless trying to win an Underhanded Rust Contest. Even for that
+    /// contest, it's probably a bad idea. Use something more underhanded.
+    ///
+    /// ### Example
+    /// ```rust
+    /// # let x = 1;
+    /// let a = x % 1;
+    /// let a = x % -1;
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub MODULO_ONE,
+    correctness,
+    "taking a number modulo +/-1, which can either panic/overflow or always returns 0"
+}
+
 pub struct Operators {
     arithmetic_context: numeric_arithmetic::Context,
     verbose_bit_mask_threshold: u64,
@@ -485,6 +639,11 @@ impl_lint_pass!(Operators => [
     FLOAT_EQUALITY_WITHOUT_ABS,
     IDENTITY_OP,
     INTEGER_DIVISION,
+    CMP_NAN,
+    CMP_OWNED,
+    FLOAT_CMP,
+    FLOAT_CMP_CONST,
+    MODULO_ONE,
 ]);
 impl Operators {
     pub fn new(verbose_bit_mask_threshold: u64) -> Self {
@@ -515,6 +674,10 @@ impl<'tcx> LateLintPass<'tcx> for Operators {
                 duration_subsec::check(cx, e, op.node, lhs, rhs);
                 float_equality_without_abs::check(cx, e, op.node, lhs, rhs);
                 integer_division::check(cx, e, op.node, lhs, rhs);
+                cmp_nan::check(cx, e, op.node, lhs, rhs);
+                cmp_owned::check(cx, op.node, lhs, rhs);
+                float_cmp::check(cx, e, op.node, lhs, rhs);
+                modulo_one::check(cx, e, op.node, rhs);
             },
             ExprKind::AssignOp(op, lhs, rhs) => {
                 self.arithmetic_context.check_binary(cx, e, op.node, lhs, rhs);
diff --git a/clippy_lints/src/operators/modulo_one.rs b/clippy_lints/src/operators/modulo_one.rs
new file mode 100644
index 00000000000..54eea14833f
--- /dev/null
+++ b/clippy_lints/src/operators/modulo_one.rs
@@ -0,0 +1,26 @@
+use clippy_utils::diagnostics::span_lint;
+use clippy_utils::{is_integer_const, unsext};
+use rustc_hir::{BinOpKind, Expr};
+use rustc_lint::LateContext;
+use rustc_middle::ty;
+
+use super::MODULO_ONE;
+
+pub(crate) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, op: BinOpKind, right: &Expr<'_>) {
+    if op == BinOpKind::Rem {
+        if is_integer_const(cx, right, 1) {
+            span_lint(cx, MODULO_ONE, expr.span, "any number modulo 1 will be 0");
+        }
+
+        if let ty::Int(ity) = cx.typeck_results().expr_ty(right).kind() {
+            if is_integer_const(cx, right, unsext(cx.tcx, -1, *ity)) {
+                span_lint(
+                    cx,
+                    MODULO_ONE,
+                    expr.span,
+                    "any number modulo -1 will panic/overflow or result in 0",
+                );
+            }
+        };
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 71c2daa60aa71446451d5fa9a2c43e9881e83f03 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Wed, 1 Jun 2022 09:50:33 -0400
Subject: Move `ModuloArithmetic` into `Operators` lint pass

---
 clippy_lints/src/lib.register_lints.rs          |   2 +-
 clippy_lints/src/lib.register_restriction.rs    |   2 +-
 clippy_lints/src/lib.rs                         |   2 -
 clippy_lints/src/modulo_arithmetic.rs           | 150 ------------------------
 clippy_lints/src/operators/mod.rs               |  26 ++++
 clippy_lints/src/operators/modulo_arithmetic.rs | 126 ++++++++++++++++++++
 6 files changed, 154 insertions(+), 154 deletions(-)
 delete mode 100644 clippy_lints/src/modulo_arithmetic.rs
 create mode 100644 clippy_lints/src/operators/modulo_arithmetic.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 139b55e965f..fea98c08e4a 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -379,7 +379,6 @@ store.register_lints(&[
     mixed_read_write_in_expression::MIXED_READ_WRITE_IN_EXPRESSION,
     module_style::MOD_MODULE_FILES,
     module_style::SELF_NAMED_MODULE_FILES,
-    modulo_arithmetic::MODULO_ARITHMETIC,
     mut_key::MUTABLE_KEY_TYPE,
     mut_mut::MUT_MUT,
     mut_mutex_lock::MUT_MUTEX_LOCK,
@@ -434,6 +433,7 @@ store.register_lints(&[
     operators::INTEGER_ARITHMETIC,
     operators::INTEGER_DIVISION,
     operators::MISREFACTORED_ASSIGN_OP,
+    operators::MODULO_ARITHMETIC,
     operators::MODULO_ONE,
     operators::OP_REF,
     operators::VERBOSE_BIT_MASK,
diff --git a/clippy_lints/src/lib.register_restriction.rs b/clippy_lints/src/lib.register_restriction.rs
index e66dc67f3dc..970e9db4772 100644
--- a/clippy_lints/src/lib.register_restriction.rs
+++ b/clippy_lints/src/lib.register_restriction.rs
@@ -47,11 +47,11 @@ store.register_group(true, "clippy::restriction", Some("clippy_restriction"), ve
     LintId::of(mixed_read_write_in_expression::MIXED_READ_WRITE_IN_EXPRESSION),
     LintId::of(module_style::MOD_MODULE_FILES),
     LintId::of(module_style::SELF_NAMED_MODULE_FILES),
-    LintId::of(modulo_arithmetic::MODULO_ARITHMETIC),
     LintId::of(operators::FLOAT_ARITHMETIC),
     LintId::of(operators::FLOAT_CMP_CONST),
     LintId::of(operators::INTEGER_ARITHMETIC),
     LintId::of(operators::INTEGER_DIVISION),
+    LintId::of(operators::MODULO_ARITHMETIC),
     LintId::of(panic_in_result_fn::PANIC_IN_RESULT_FN),
     LintId::of(panic_unimplemented::PANIC),
     LintId::of(panic_unimplemented::TODO),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 4c4d149e177..724674471f2 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -295,7 +295,6 @@ mod missing_enforced_import_rename;
 mod missing_inline;
 mod mixed_read_write_in_expression;
 mod module_style;
-mod modulo_arithmetic;
 mod mut_key;
 mod mut_mut;
 mod mut_mutex_lock;
@@ -738,7 +737,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(move || Box::new(trait_bounds::TraitBounds::new(max_trait_bounds)));
     store.register_late_pass(|| Box::new(comparison_chain::ComparisonChain));
     store.register_late_pass(|| Box::new(mut_key::MutableKeyType));
-    store.register_late_pass(|| Box::new(modulo_arithmetic::ModuloArithmetic));
     store.register_early_pass(|| Box::new(reference::DerefAddrOf));
     store.register_early_pass(|| Box::new(double_parens::DoubleParens));
     store.register_late_pass(|| Box::new(format_impl::FormatImpl::new()));
diff --git a/clippy_lints/src/modulo_arithmetic.rs b/clippy_lints/src/modulo_arithmetic.rs
deleted file mode 100644
index 195b2e5c2ee..00000000000
--- a/clippy_lints/src/modulo_arithmetic.rs
+++ /dev/null
@@ -1,150 +0,0 @@
-use clippy_utils::consts::{constant, Constant};
-use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::sext;
-use if_chain::if_chain;
-use rustc_hir::{BinOpKind, Expr, ExprKind};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty::{self, Ty};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use std::fmt::Display;
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for modulo arithmetic.
-    ///
-    /// ### Why is this bad?
-    /// The results of modulo (%) operation might differ
-    /// depending on the language, when negative numbers are involved.
-    /// If you interop with different languages it might be beneficial
-    /// to double check all places that use modulo arithmetic.
-    ///
-    /// For example, in Rust `17 % -3 = 2`, but in Python `17 % -3 = -1`.
-    ///
-    /// ### Example
-    /// ```rust
-    /// let x = -17 % 3;
-    /// ```
-    #[clippy::version = "1.42.0"]
-    pub MODULO_ARITHMETIC,
-    restriction,
-    "any modulo arithmetic statement"
-}
-
-declare_lint_pass!(ModuloArithmetic => [MODULO_ARITHMETIC]);
-
-struct OperandInfo {
-    string_representation: Option<String>,
-    is_negative: bool,
-    is_integral: bool,
-}
-
-fn analyze_operand(operand: &Expr<'_>, cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<OperandInfo> {
-    match constant(cx, cx.typeck_results(), operand) {
-        Some((Constant::Int(v), _)) => match *cx.typeck_results().expr_ty(expr).kind() {
-            ty::Int(ity) => {
-                let value = sext(cx.tcx, v, ity);
-                return Some(OperandInfo {
-                    string_representation: Some(value.to_string()),
-                    is_negative: value < 0,
-                    is_integral: true,
-                });
-            },
-            ty::Uint(_) => {
-                return Some(OperandInfo {
-                    string_representation: None,
-                    is_negative: false,
-                    is_integral: true,
-                });
-            },
-            _ => {},
-        },
-        Some((Constant::F32(f), _)) => {
-            return Some(floating_point_operand_info(&f));
-        },
-        Some((Constant::F64(f), _)) => {
-            return Some(floating_point_operand_info(&f));
-        },
-        _ => {},
-    }
-    None
-}
-
-fn floating_point_operand_info<T: Display + PartialOrd + From<f32>>(f: &T) -> OperandInfo {
-    OperandInfo {
-        string_representation: Some(format!("{:.3}", *f)),
-        is_negative: *f < 0.0.into(),
-        is_integral: false,
-    }
-}
-
-fn might_have_negative_value(t: Ty<'_>) -> bool {
-    t.is_signed() || t.is_floating_point()
-}
-
-fn check_const_operands<'tcx>(
-    cx: &LateContext<'tcx>,
-    expr: &'tcx Expr<'_>,
-    lhs_operand: &OperandInfo,
-    rhs_operand: &OperandInfo,
-) {
-    if lhs_operand.is_negative ^ rhs_operand.is_negative {
-        span_lint_and_then(
-            cx,
-            MODULO_ARITHMETIC,
-            expr.span,
-            &format!(
-                "you are using modulo operator on constants with different signs: `{} % {}`",
-                lhs_operand.string_representation.as_ref().unwrap(),
-                rhs_operand.string_representation.as_ref().unwrap()
-            ),
-            |diag| {
-                diag.note("double check for expected result especially when interoperating with different languages");
-                if lhs_operand.is_integral {
-                    diag.note("or consider using `rem_euclid` or similar function");
-                }
-            },
-        );
-    }
-}
-
-fn check_non_const_operands<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, operand: &Expr<'_>) {
-    let operand_type = cx.typeck_results().expr_ty(operand);
-    if might_have_negative_value(operand_type) {
-        span_lint_and_then(
-            cx,
-            MODULO_ARITHMETIC,
-            expr.span,
-            "you are using modulo operator on types that might have different signs",
-            |diag| {
-                diag.note("double check for expected result especially when interoperating with different languages");
-                if operand_type.is_integral() {
-                    diag.note("or consider using `rem_euclid` or similar function");
-                }
-            },
-        );
-    }
-}
-
-impl<'tcx> LateLintPass<'tcx> for ModuloArithmetic {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        match &expr.kind {
-            ExprKind::Binary(op, lhs, rhs) | ExprKind::AssignOp(op, lhs, rhs) => {
-                if op.node == BinOpKind::Rem {
-                    let lhs_operand = analyze_operand(lhs, cx, expr);
-                    let rhs_operand = analyze_operand(rhs, cx, expr);
-                    if_chain! {
-                        if let Some(lhs_operand) = lhs_operand;
-                        if let Some(rhs_operand) = rhs_operand;
-                        then {
-                            check_const_operands(cx, expr, &lhs_operand, &rhs_operand);
-                        }
-                        else {
-                            check_non_const_operands(cx, expr, lhs);
-                        }
-                    }
-                };
-            },
-            _ => {},
-        }
-    }
-}
diff --git a/clippy_lints/src/operators/mod.rs b/clippy_lints/src/operators/mod.rs
index e4aff267fef..7db38f0fcfb 100644
--- a/clippy_lints/src/operators/mod.rs
+++ b/clippy_lints/src/operators/mod.rs
@@ -16,6 +16,7 @@ mod float_equality_without_abs;
 mod identity_op;
 mod integer_division;
 mod misrefactored_assign_op;
+mod modulo_arithmetic;
 mod modulo_one;
 mod numeric_arithmetic;
 mod op_ref;
@@ -618,6 +619,28 @@ declare_clippy_lint! {
     "taking a number modulo +/-1, which can either panic/overflow or always returns 0"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for modulo arithmetic.
+    ///
+    /// ### Why is this bad?
+    /// The results of modulo (%) operation might differ
+    /// depending on the language, when negative numbers are involved.
+    /// If you interop with different languages it might be beneficial
+    /// to double check all places that use modulo arithmetic.
+    ///
+    /// For example, in Rust `17 % -3 = 2`, but in Python `17 % -3 = -1`.
+    ///
+    /// ### Example
+    /// ```rust
+    /// let x = -17 % 3;
+    /// ```
+    #[clippy::version = "1.42.0"]
+    pub MODULO_ARITHMETIC,
+    restriction,
+    "any modulo arithmetic statement"
+}
+
 pub struct Operators {
     arithmetic_context: numeric_arithmetic::Context,
     verbose_bit_mask_threshold: u64,
@@ -644,6 +667,7 @@ impl_lint_pass!(Operators => [
     FLOAT_CMP,
     FLOAT_CMP_CONST,
     MODULO_ONE,
+    MODULO_ARITHMETIC,
 ]);
 impl Operators {
     pub fn new(verbose_bit_mask_threshold: u64) -> Self {
@@ -678,10 +702,12 @@ impl<'tcx> LateLintPass<'tcx> for Operators {
                 cmp_owned::check(cx, op.node, lhs, rhs);
                 float_cmp::check(cx, e, op.node, lhs, rhs);
                 modulo_one::check(cx, e, op.node, rhs);
+                modulo_arithmetic::check(cx, e, op.node, lhs, rhs);
             },
             ExprKind::AssignOp(op, lhs, rhs) => {
                 self.arithmetic_context.check_binary(cx, e, op.node, lhs, rhs);
                 misrefactored_assign_op::check(cx, e, op.node, lhs, rhs);
+                modulo_arithmetic::check(cx, e, op.node, lhs, rhs);
             },
             ExprKind::Assign(lhs, rhs, _) => {
                 assign_op_pattern::check(cx, e, lhs, rhs);
diff --git a/clippy_lints/src/operators/modulo_arithmetic.rs b/clippy_lints/src/operators/modulo_arithmetic.rs
new file mode 100644
index 00000000000..af4e74947f4
--- /dev/null
+++ b/clippy_lints/src/operators/modulo_arithmetic.rs
@@ -0,0 +1,126 @@
+use clippy_utils::consts::{constant, Constant};
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::sext;
+use if_chain::if_chain;
+use rustc_hir::{BinOpKind, Expr};
+use rustc_lint::LateContext;
+use rustc_middle::ty::{self, Ty};
+use std::fmt::Display;
+
+use super::MODULO_ARITHMETIC;
+
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    e: &'tcx Expr<'_>,
+    op: BinOpKind,
+    lhs: &'tcx Expr<'_>,
+    rhs: &'tcx Expr<'_>,
+) {
+    if op == BinOpKind::Rem {
+        let lhs_operand = analyze_operand(lhs, cx, e);
+        let rhs_operand = analyze_operand(rhs, cx, e);
+        if_chain! {
+            if let Some(lhs_operand) = lhs_operand;
+            if let Some(rhs_operand) = rhs_operand;
+            then {
+                check_const_operands(cx, e, &lhs_operand, &rhs_operand);
+            }
+            else {
+                check_non_const_operands(cx, e, lhs);
+            }
+        }
+    };
+}
+
+struct OperandInfo {
+    string_representation: Option<String>,
+    is_negative: bool,
+    is_integral: bool,
+}
+
+fn analyze_operand(operand: &Expr<'_>, cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<OperandInfo> {
+    match constant(cx, cx.typeck_results(), operand) {
+        Some((Constant::Int(v), _)) => match *cx.typeck_results().expr_ty(expr).kind() {
+            ty::Int(ity) => {
+                let value = sext(cx.tcx, v, ity);
+                return Some(OperandInfo {
+                    string_representation: Some(value.to_string()),
+                    is_negative: value < 0,
+                    is_integral: true,
+                });
+            },
+            ty::Uint(_) => {
+                return Some(OperandInfo {
+                    string_representation: None,
+                    is_negative: false,
+                    is_integral: true,
+                });
+            },
+            _ => {},
+        },
+        Some((Constant::F32(f), _)) => {
+            return Some(floating_point_operand_info(&f));
+        },
+        Some((Constant::F64(f), _)) => {
+            return Some(floating_point_operand_info(&f));
+        },
+        _ => {},
+    }
+    None
+}
+
+fn floating_point_operand_info<T: Display + PartialOrd + From<f32>>(f: &T) -> OperandInfo {
+    OperandInfo {
+        string_representation: Some(format!("{:.3}", *f)),
+        is_negative: *f < 0.0.into(),
+        is_integral: false,
+    }
+}
+
+fn might_have_negative_value(t: Ty<'_>) -> bool {
+    t.is_signed() || t.is_floating_point()
+}
+
+fn check_const_operands<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx Expr<'_>,
+    lhs_operand: &OperandInfo,
+    rhs_operand: &OperandInfo,
+) {
+    if lhs_operand.is_negative ^ rhs_operand.is_negative {
+        span_lint_and_then(
+            cx,
+            MODULO_ARITHMETIC,
+            expr.span,
+            &format!(
+                "you are using modulo operator on constants with different signs: `{} % {}`",
+                lhs_operand.string_representation.as_ref().unwrap(),
+                rhs_operand.string_representation.as_ref().unwrap()
+            ),
+            |diag| {
+                diag.note("double check for expected result especially when interoperating with different languages");
+                if lhs_operand.is_integral {
+                    diag.note("or consider using `rem_euclid` or similar function");
+                }
+            },
+        );
+    }
+}
+
+fn check_non_const_operands<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, operand: &Expr<'_>) {
+    let operand_type = cx.typeck_results().expr_ty(operand);
+    if might_have_negative_value(operand_type) {
+        span_lint_and_then(
+            cx,
+            MODULO_ARITHMETIC,
+            expr.span,
+            "you are using modulo operator on types that might have different signs",
+            |diag| {
+                diag.note("double check for expected result especially when interoperating with different languages");
+                if operand_type.is_integral() {
+                    diag.note("or consider using `rem_euclid` or similar function");
+                }
+            },
+        );
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From fc5eac58948d5a93304bd2eaa8b566de7018e408 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Wed, 1 Jun 2022 10:12:26 -0400
Subject: Move `NeedlessBitwiseBool` into `Operators` lint pass

---
 clippy_lints/src/lib.register_lints.rs             |  2 +-
 clippy_lints/src/lib.register_pedantic.rs          |  2 +-
 clippy_lints/src/lib.rs                            |  2 -
 clippy_lints/src/needless_bitwise_bool.rs          | 85 ----------------------
 clippy_lints/src/operators/mod.rs                  | 32 ++++++++
 .../src/operators/needless_bitwise_bool.rs         | 36 +++++++++
 6 files changed, 70 insertions(+), 89 deletions(-)
 delete mode 100644 clippy_lints/src/needless_bitwise_bool.rs
 create mode 100644 clippy_lints/src/operators/needless_bitwise_bool.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index fea98c08e4a..d006aa4bce5 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -387,7 +387,6 @@ store.register_lints(&[
     mutex_atomic::MUTEX_ATOMIC,
     mutex_atomic::MUTEX_INTEGER,
     needless_arbitrary_self_type::NEEDLESS_ARBITRARY_SELF_TYPE,
-    needless_bitwise_bool::NEEDLESS_BITWISE_BOOL,
     needless_bool::BOOL_COMPARISON,
     needless_bool::NEEDLESS_BOOL,
     needless_borrowed_ref::NEEDLESS_BORROWED_REFERENCE,
@@ -435,6 +434,7 @@ store.register_lints(&[
     operators::MISREFACTORED_ASSIGN_OP,
     operators::MODULO_ARITHMETIC,
     operators::MODULO_ONE,
+    operators::NEEDLESS_BITWISE_BOOL,
     operators::OP_REF,
     operators::VERBOSE_BIT_MASK,
     option_env_unwrap::OPTION_ENV_UNWRAP,
diff --git a/clippy_lints/src/lib.register_pedantic.rs b/clippy_lints/src/lib.register_pedantic.rs
index 0c02c2bef56..4d4b89687d0 100644
--- a/clippy_lints/src/lib.register_pedantic.rs
+++ b/clippy_lints/src/lib.register_pedantic.rs
@@ -67,7 +67,6 @@ store.register_group(true, "clippy::pedantic", Some("clippy_pedantic"), vec![
     LintId::of(misc::USED_UNDERSCORE_BINDING),
     LintId::of(mismatching_type_param_order::MISMATCHING_TYPE_PARAM_ORDER),
     LintId::of(mut_mut::MUT_MUT),
-    LintId::of(needless_bitwise_bool::NEEDLESS_BITWISE_BOOL),
     LintId::of(needless_continue::NEEDLESS_CONTINUE),
     LintId::of(needless_for_each::NEEDLESS_FOR_EACH),
     LintId::of(needless_pass_by_value::NEEDLESS_PASS_BY_VALUE),
@@ -75,6 +74,7 @@ store.register_group(true, "clippy::pedantic", Some("clippy_pedantic"), vec![
     LintId::of(non_expressive_names::MANY_SINGLE_CHAR_NAMES),
     LintId::of(non_expressive_names::SIMILAR_NAMES),
     LintId::of(operators::FLOAT_CMP),
+    LintId::of(operators::NEEDLESS_BITWISE_BOOL),
     LintId::of(operators::VERBOSE_BIT_MASK),
     LintId::of(pass_by_ref_or_value::LARGE_TYPES_PASSED_BY_VALUE),
     LintId::of(pass_by_ref_or_value::TRIVIALLY_COPY_PASS_BY_REF),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 724674471f2..42d4abcde43 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -302,7 +302,6 @@ mod mut_reference;
 mod mutable_debug_assertion;
 mod mutex_atomic;
 mod needless_arbitrary_self_type;
-mod needless_bitwise_bool;
 mod needless_bool;
 mod needless_borrowed_ref;
 mod needless_continue;
@@ -569,7 +568,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         ))
     });
     store.register_late_pass(|| Box::new(booleans::NonminimalBool));
-    store.register_late_pass(|| Box::new(needless_bitwise_bool::NeedlessBitwiseBool));
     store.register_late_pass(|| Box::new(enum_clike::UnportableVariant));
     store.register_late_pass(|| Box::new(float_literal::FloatLiteral));
     store.register_late_pass(|| Box::new(ptr::Ptr));
diff --git a/clippy_lints/src/needless_bitwise_bool.rs b/clippy_lints/src/needless_bitwise_bool.rs
deleted file mode 100644
index 623d22bc9bd..00000000000
--- a/clippy_lints/src/needless_bitwise_bool.rs
+++ /dev/null
@@ -1,85 +0,0 @@
-use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::source::snippet_opt;
-use if_chain::if_chain;
-use rustc_errors::Applicability;
-use rustc_hir::{BinOpKind, Expr, ExprKind};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for uses of bitwise and/or operators between booleans, where performance may be improved by using
-    /// a lazy and.
-    ///
-    /// ### Why is this bad?
-    /// The bitwise operators do not support short-circuiting, so it may hinder code performance.
-    /// Additionally, boolean logic "masked" as bitwise logic is not caught by lints like `unnecessary_fold`
-    ///
-    /// ### Known problems
-    /// This lint evaluates only when the right side is determined to have no side effects. At this time, that
-    /// determination is quite conservative.
-    ///
-    /// ### Example
-    /// ```rust
-    /// let (x,y) = (true, false);
-    /// if x & !y {} // where both x and y are booleans
-    /// ```
-    /// Use instead:
-    /// ```rust
-    /// let (x,y) = (true, false);
-    /// if x && !y {}
-    /// ```
-    #[clippy::version = "1.54.0"]
-    pub NEEDLESS_BITWISE_BOOL,
-    pedantic,
-    "Boolean expressions that use bitwise rather than lazy operators"
-}
-
-declare_lint_pass!(NeedlessBitwiseBool => [NEEDLESS_BITWISE_BOOL]);
-
-fn is_bitwise_operation(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-    let ty = cx.typeck_results().expr_ty(expr);
-    if_chain! {
-        if !expr.span.from_expansion();
-        if let (&ExprKind::Binary(ref op, _, right), &ty::Bool) = (&expr.kind, &ty.kind());
-        if op.node == BinOpKind::BitAnd || op.node == BinOpKind::BitOr;
-        if let ExprKind::Call(..) | ExprKind::MethodCall(..) | ExprKind::Binary(..) | ExprKind::Unary(..) = right.kind;
-        if !right.can_have_side_effects();
-        then {
-            return true;
-        }
-    }
-    false
-}
-
-fn suggestion_snippet(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<String> {
-    if let ExprKind::Binary(ref op, left, right) = expr.kind {
-        if let (Some(l_snippet), Some(r_snippet)) = (snippet_opt(cx, left.span), snippet_opt(cx, right.span)) {
-            let op_snippet = match op.node {
-                BinOpKind::BitAnd => "&&",
-                _ => "||",
-            };
-            return Some(format!("{} {} {}", l_snippet, op_snippet, r_snippet));
-        }
-    }
-    None
-}
-
-impl LateLintPass<'_> for NeedlessBitwiseBool {
-    fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
-        if is_bitwise_operation(cx, expr) {
-            span_lint_and_then(
-                cx,
-                NEEDLESS_BITWISE_BOOL,
-                expr.span,
-                "use of bitwise operator instead of lazy operator between booleans",
-                |diag| {
-                    if let Some(sugg) = suggestion_snippet(cx, expr) {
-                        diag.span_suggestion(expr.span, "try", sugg, Applicability::MachineApplicable);
-                    }
-                },
-            );
-        }
-    }
-}
diff --git a/clippy_lints/src/operators/mod.rs b/clippy_lints/src/operators/mod.rs
index 7db38f0fcfb..0c5b8f3da6a 100644
--- a/clippy_lints/src/operators/mod.rs
+++ b/clippy_lints/src/operators/mod.rs
@@ -18,6 +18,7 @@ mod integer_division;
 mod misrefactored_assign_op;
 mod modulo_arithmetic;
 mod modulo_one;
+mod needless_bitwise_bool;
 mod numeric_arithmetic;
 mod op_ref;
 mod verbose_bit_mask;
@@ -641,6 +642,35 @@ declare_clippy_lint! {
     "any modulo arithmetic statement"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for uses of bitwise and/or operators between booleans, where performance may be improved by using
+    /// a lazy and.
+    ///
+    /// ### Why is this bad?
+    /// The bitwise operators do not support short-circuiting, so it may hinder code performance.
+    /// Additionally, boolean logic "masked" as bitwise logic is not caught by lints like `unnecessary_fold`
+    ///
+    /// ### Known problems
+    /// This lint evaluates only when the right side is determined to have no side effects. At this time, that
+    /// determination is quite conservative.
+    ///
+    /// ### Example
+    /// ```rust
+    /// let (x,y) = (true, false);
+    /// if x & !y {} // where both x and y are booleans
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// let (x,y) = (true, false);
+    /// if x && !y {}
+    /// ```
+    #[clippy::version = "1.54.0"]
+    pub NEEDLESS_BITWISE_BOOL,
+    pedantic,
+    "Boolean expressions that use bitwise rather than lazy operators"
+}
+
 pub struct Operators {
     arithmetic_context: numeric_arithmetic::Context,
     verbose_bit_mask_threshold: u64,
@@ -668,6 +698,7 @@ impl_lint_pass!(Operators => [
     FLOAT_CMP_CONST,
     MODULO_ONE,
     MODULO_ARITHMETIC,
+    NEEDLESS_BITWISE_BOOL,
 ]);
 impl Operators {
     pub fn new(verbose_bit_mask_threshold: u64) -> Self {
@@ -690,6 +721,7 @@ impl<'tcx> LateLintPass<'tcx> for Operators {
                     }
                     erasing_op::check(cx, e, op.node, lhs, rhs);
                     identity_op::check(cx, e, op.node, lhs, rhs);
+                    needless_bitwise_bool::check(cx, e, op.node, lhs, rhs);
                 }
                 self.arithmetic_context.check_binary(cx, e, op.node, lhs, rhs);
                 bit_mask::check(cx, e, op.node, lhs, rhs);
diff --git a/clippy_lints/src/operators/needless_bitwise_bool.rs b/clippy_lints/src/operators/needless_bitwise_bool.rs
new file mode 100644
index 00000000000..e902235a014
--- /dev/null
+++ b/clippy_lints/src/operators/needless_bitwise_bool.rs
@@ -0,0 +1,36 @@
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::source::snippet_opt;
+use rustc_errors::Applicability;
+use rustc_hir::{BinOpKind, Expr, ExprKind};
+use rustc_lint::LateContext;
+
+use super::NEEDLESS_BITWISE_BOOL;
+
+pub(super) fn check(cx: &LateContext<'_>, e: &Expr<'_>, op: BinOpKind, lhs: &Expr<'_>, rhs: &Expr<'_>) {
+    let op_str = match op {
+        BinOpKind::BitAnd => "&&",
+        BinOpKind::BitOr => "||",
+        _ => return,
+    };
+    if matches!(
+        rhs.kind,
+        ExprKind::Call(..) | ExprKind::MethodCall(..) | ExprKind::Binary(..) | ExprKind::Unary(..)
+    ) && cx.typeck_results().expr_ty(e).is_bool()
+        && !rhs.can_have_side_effects()
+    {
+        span_lint_and_then(
+            cx,
+            NEEDLESS_BITWISE_BOOL,
+            e.span,
+            "use of bitwise operator instead of lazy operator between booleans",
+            |diag| {
+                if let Some(lhs_snip) = snippet_opt(cx, lhs.span)
+                    && let Some(rhs_snip) = snippet_opt(cx, rhs.span)
+                {
+                    let sugg = format!("{} {} {}", lhs_snip, op_str, rhs_snip);
+                    diag.span_suggestion(e.span, "try", sugg, Applicability::MachineApplicable);
+                }
+            },
+        );
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 92891a01a1a8c9a703dd6323567ed8d9914e562f Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Wed, 1 Jun 2022 10:37:37 -0400
Subject: Move `PtrEq` into `Operators` lin pass

---
 clippy_lints/src/lib.register_all.rs   |  2 +-
 clippy_lints/src/lib.register_lints.rs |  2 +-
 clippy_lints/src/lib.register_style.rs |  2 +-
 clippy_lints/src/lib.rs                |  2 -
 clippy_lints/src/operators/mod.rs      | 32 +++++++++++
 clippy_lints/src/operators/ptr_eq.rs   | 65 +++++++++++++++++++++++
 clippy_lints/src/ptr_eq.rs             | 97 ----------------------------------
 7 files changed, 100 insertions(+), 102 deletions(-)
 create mode 100644 clippy_lints/src/operators/ptr_eq.rs
 delete mode 100644 clippy_lints/src/ptr_eq.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 06f8a6325ff..b8aac47202c 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -260,6 +260,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(operators::MISREFACTORED_ASSIGN_OP),
     LintId::of(operators::MODULO_ONE),
     LintId::of(operators::OP_REF),
+    LintId::of(operators::PTR_EQ),
     LintId::of(option_env_unwrap::OPTION_ENV_UNWRAP),
     LintId::of(overflow_check_conditional::OVERFLOW_CHECK_CONDITIONAL),
     LintId::of(partialeq_ne_impl::PARTIALEQ_NE_IMPL),
@@ -268,7 +269,6 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(ptr::INVALID_NULL_PTR_USAGE),
     LintId::of(ptr::MUT_FROM_REF),
     LintId::of(ptr::PTR_ARG),
-    LintId::of(ptr_eq::PTR_EQ),
     LintId::of(ptr_offset_with_cast::PTR_OFFSET_WITH_CAST),
     LintId::of(question_mark::QUESTION_MARK),
     LintId::of(ranges::MANUAL_RANGE_CONTAINS),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index d006aa4bce5..408f2857263 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -436,6 +436,7 @@ store.register_lints(&[
     operators::MODULO_ONE,
     operators::NEEDLESS_BITWISE_BOOL,
     operators::OP_REF,
+    operators::PTR_EQ,
     operators::VERBOSE_BIT_MASK,
     option_env_unwrap::OPTION_ENV_UNWRAP,
     option_if_let_else::OPTION_IF_LET_ELSE,
@@ -455,7 +456,6 @@ store.register_lints(&[
     ptr::INVALID_NULL_PTR_USAGE,
     ptr::MUT_FROM_REF,
     ptr::PTR_ARG,
-    ptr_eq::PTR_EQ,
     ptr_offset_with_cast::PTR_OFFSET_WITH_CAST,
     pub_use::PUB_USE,
     question_mark::QUESTION_MARK,
diff --git a/clippy_lints/src/lib.register_style.rs b/clippy_lints/src/lib.register_style.rs
index a438577d992..15a1bc569af 100644
--- a/clippy_lints/src/lib.register_style.rs
+++ b/clippy_lints/src/lib.register_style.rs
@@ -98,9 +98,9 @@ store.register_group(true, "clippy::style", Some("clippy_style"), vec![
     LintId::of(non_expressive_names::JUST_UNDERSCORES_AND_DIGITS),
     LintId::of(operators::ASSIGN_OP_PATTERN),
     LintId::of(operators::OP_REF),
+    LintId::of(operators::PTR_EQ),
     LintId::of(ptr::CMP_NULL),
     LintId::of(ptr::PTR_ARG),
-    LintId::of(ptr_eq::PTR_EQ),
     LintId::of(question_mark::QUESTION_MARK),
     LintId::of(ranges::MANUAL_RANGE_CONTAINS),
     LintId::of(redundant_field_names::REDUNDANT_FIELD_NAMES),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 42d4abcde43..7b618831ae0 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -335,7 +335,6 @@ mod path_buf_push_overwrite;
 mod pattern_type_mismatch;
 mod precedence;
 mod ptr;
-mod ptr_eq;
 mod ptr_offset_with_cast;
 mod pub_use;
 mod question_mark;
@@ -571,7 +570,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(enum_clike::UnportableVariant));
     store.register_late_pass(|| Box::new(float_literal::FloatLiteral));
     store.register_late_pass(|| Box::new(ptr::Ptr));
-    store.register_late_pass(|| Box::new(ptr_eq::PtrEq));
     store.register_late_pass(|| Box::new(needless_bool::NeedlessBool));
     store.register_late_pass(|| Box::new(needless_bool::BoolComparison));
     store.register_late_pass(|| Box::new(needless_for_each::NeedlessForEach));
diff --git a/clippy_lints/src/operators/mod.rs b/clippy_lints/src/operators/mod.rs
index 0c5b8f3da6a..b2cf1660ae0 100644
--- a/clippy_lints/src/operators/mod.rs
+++ b/clippy_lints/src/operators/mod.rs
@@ -21,6 +21,7 @@ mod modulo_one;
 mod needless_bitwise_bool;
 mod numeric_arithmetic;
 mod op_ref;
+mod ptr_eq;
 mod verbose_bit_mask;
 
 declare_clippy_lint! {
@@ -671,6 +672,35 @@ declare_clippy_lint! {
     "Boolean expressions that use bitwise rather than lazy operators"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Use `std::ptr::eq` when applicable
+    ///
+    /// ### Why is this bad?
+    /// `ptr::eq` can be used to compare `&T` references
+    /// (which coerce to `*const T` implicitly) by their address rather than
+    /// comparing the values they point to.
+    ///
+    /// ### Example
+    /// ```rust
+    /// let a = &[1, 2, 3];
+    /// let b = &[1, 2, 3];
+    ///
+    /// assert!(a as *const _ as usize == b as *const _ as usize);
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// let a = &[1, 2, 3];
+    /// let b = &[1, 2, 3];
+    ///
+    /// assert!(std::ptr::eq(a, b));
+    /// ```
+    #[clippy::version = "1.49.0"]
+    pub PTR_EQ,
+    style,
+    "use `std::ptr::eq` when comparing raw pointers"
+}
+
 pub struct Operators {
     arithmetic_context: numeric_arithmetic::Context,
     verbose_bit_mask_threshold: u64,
@@ -699,6 +729,7 @@ impl_lint_pass!(Operators => [
     MODULO_ONE,
     MODULO_ARITHMETIC,
     NEEDLESS_BITWISE_BOOL,
+    PTR_EQ,
 ]);
 impl Operators {
     pub fn new(verbose_bit_mask_threshold: u64) -> Self {
@@ -722,6 +753,7 @@ impl<'tcx> LateLintPass<'tcx> for Operators {
                     erasing_op::check(cx, e, op.node, lhs, rhs);
                     identity_op::check(cx, e, op.node, lhs, rhs);
                     needless_bitwise_bool::check(cx, e, op.node, lhs, rhs);
+                    ptr_eq::check(cx, e, op.node, lhs, rhs);
                 }
                 self.arithmetic_context.check_binary(cx, e, op.node, lhs, rhs);
                 bit_mask::check(cx, e, op.node, lhs, rhs);
diff --git a/clippy_lints/src/operators/ptr_eq.rs b/clippy_lints/src/operators/ptr_eq.rs
new file mode 100644
index 00000000000..1aefc2741c2
--- /dev/null
+++ b/clippy_lints/src/operators/ptr_eq.rs
@@ -0,0 +1,65 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet_opt;
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir::{BinOpKind, Expr, ExprKind};
+use rustc_lint::LateContext;
+
+use super::PTR_EQ;
+
+static LINT_MSG: &str = "use `std::ptr::eq` when comparing raw pointers";
+
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx Expr<'_>,
+    op: BinOpKind,
+    left: &'tcx Expr<'_>,
+    right: &'tcx Expr<'_>,
+) {
+    if BinOpKind::Eq == op {
+        let (left, right) = match (expr_as_cast_to_usize(cx, left), expr_as_cast_to_usize(cx, right)) {
+            (Some(lhs), Some(rhs)) => (lhs, rhs),
+            _ => (left, right),
+        };
+
+        if_chain! {
+            if let Some(left_var) = expr_as_cast_to_raw_pointer(cx, left);
+            if let Some(right_var) = expr_as_cast_to_raw_pointer(cx, right);
+            if let Some(left_snip) = snippet_opt(cx, left_var.span);
+            if let Some(right_snip) = snippet_opt(cx, right_var.span);
+            then {
+                span_lint_and_sugg(
+                    cx,
+                    PTR_EQ,
+                    expr.span,
+                    LINT_MSG,
+                    "try",
+                    format!("std::ptr::eq({}, {})", left_snip, right_snip),
+                    Applicability::MachineApplicable,
+                    );
+            }
+        }
+    }
+}
+
+// If the given expression is a cast to a usize, return the lhs of the cast
+// E.g., `foo as *const _ as usize` returns `foo as *const _`.
+fn expr_as_cast_to_usize<'tcx>(cx: &LateContext<'tcx>, cast_expr: &'tcx Expr<'_>) -> Option<&'tcx Expr<'tcx>> {
+    if cx.typeck_results().expr_ty(cast_expr) == cx.tcx.types.usize {
+        if let ExprKind::Cast(expr, _) = cast_expr.kind {
+            return Some(expr);
+        }
+    }
+    None
+}
+
+// If the given expression is a cast to a `*const` pointer, return the lhs of the cast
+// E.g., `foo as *const _` returns `foo`.
+fn expr_as_cast_to_raw_pointer<'tcx>(cx: &LateContext<'tcx>, cast_expr: &'tcx Expr<'_>) -> Option<&'tcx Expr<'tcx>> {
+    if cx.typeck_results().expr_ty(cast_expr).is_unsafe_ptr() {
+        if let ExprKind::Cast(expr, _) = cast_expr.kind {
+            return Some(expr);
+        }
+    }
+    None
+}
diff --git a/clippy_lints/src/ptr_eq.rs b/clippy_lints/src/ptr_eq.rs
deleted file mode 100644
index 2bec93ac606..00000000000
--- a/clippy_lints/src/ptr_eq.rs
+++ /dev/null
@@ -1,97 +0,0 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::source::snippet_opt;
-use if_chain::if_chain;
-use rustc_errors::Applicability;
-use rustc_hir::{BinOpKind, Expr, ExprKind};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Use `std::ptr::eq` when applicable
-    ///
-    /// ### Why is this bad?
-    /// `ptr::eq` can be used to compare `&T` references
-    /// (which coerce to `*const T` implicitly) by their address rather than
-    /// comparing the values they point to.
-    ///
-    /// ### Example
-    /// ```rust
-    /// let a = &[1, 2, 3];
-    /// let b = &[1, 2, 3];
-    ///
-    /// assert!(a as *const _ as usize == b as *const _ as usize);
-    /// ```
-    /// Use instead:
-    /// ```rust
-    /// let a = &[1, 2, 3];
-    /// let b = &[1, 2, 3];
-    ///
-    /// assert!(std::ptr::eq(a, b));
-    /// ```
-    #[clippy::version = "1.49.0"]
-    pub PTR_EQ,
-    style,
-    "use `std::ptr::eq` when comparing raw pointers"
-}
-
-declare_lint_pass!(PtrEq => [PTR_EQ]);
-
-static LINT_MSG: &str = "use `std::ptr::eq` when comparing raw pointers";
-
-impl<'tcx> LateLintPass<'tcx> for PtrEq {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if expr.span.from_expansion() {
-            return;
-        }
-
-        if let ExprKind::Binary(ref op, left, right) = expr.kind {
-            if BinOpKind::Eq == op.node {
-                let (left, right) = match (expr_as_cast_to_usize(cx, left), expr_as_cast_to_usize(cx, right)) {
-                    (Some(lhs), Some(rhs)) => (lhs, rhs),
-                    _ => (left, right),
-                };
-
-                if_chain! {
-                    if let Some(left_var) = expr_as_cast_to_raw_pointer(cx, left);
-                    if let Some(right_var) = expr_as_cast_to_raw_pointer(cx, right);
-                    if let Some(left_snip) = snippet_opt(cx, left_var.span);
-                    if let Some(right_snip) = snippet_opt(cx, right_var.span);
-                    then {
-                        span_lint_and_sugg(
-                            cx,
-                            PTR_EQ,
-                            expr.span,
-                            LINT_MSG,
-                            "try",
-                            format!("std::ptr::eq({}, {})", left_snip, right_snip),
-                            Applicability::MachineApplicable,
-                            );
-                    }
-                }
-            }
-        }
-    }
-}
-
-// If the given expression is a cast to a usize, return the lhs of the cast
-// E.g., `foo as *const _ as usize` returns `foo as *const _`.
-fn expr_as_cast_to_usize<'tcx>(cx: &LateContext<'tcx>, cast_expr: &'tcx Expr<'_>) -> Option<&'tcx Expr<'tcx>> {
-    if cx.typeck_results().expr_ty(cast_expr) == cx.tcx.types.usize {
-        if let ExprKind::Cast(expr, _) = cast_expr.kind {
-            return Some(expr);
-        }
-    }
-    None
-}
-
-// If the given expression is a cast to a `*const` pointer, return the lhs of the cast
-// E.g., `foo as *const _` returns `foo`.
-fn expr_as_cast_to_raw_pointer<'tcx>(cx: &LateContext<'tcx>, cast_expr: &'tcx Expr<'_>) -> Option<&'tcx Expr<'tcx>> {
-    if cx.typeck_results().expr_ty(cast_expr).is_unsafe_ptr() {
-        if let ExprKind::Cast(expr, _) = cast_expr.kind {
-            return Some(expr);
-        }
-    }
-    None
-}
-- 
cgit 1.4.1-3-g733a5


From 5e2a2d3ac993cc6b89e561e69b4571d95d0f7627 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Tue, 14 Jun 2022 11:44:43 -0400
Subject: Fix dogfood

---
 clippy_dev/src/update_lints.rs                   |  2 +-
 clippy_lints/src/dereference.rs                  | 26 ++++++++++++------------
 clippy_lints/src/matches/match_same_arms.rs      |  2 +-
 clippy_lints/src/matches/match_single_binding.rs |  4 ++--
 4 files changed, 17 insertions(+), 17 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_dev/src/update_lints.rs b/clippy_dev/src/update_lints.rs
index 115f5f0064f..2e0659f42d7 100644
--- a/clippy_dev/src/update_lints.rs
+++ b/clippy_dev/src/update_lints.rs
@@ -413,7 +413,7 @@ fn remove_lint_declaration(name: &str, path: &Path, lints: &mut Vec<Lint>) -> io
                 .find("declare_lint_pass!")
                 .unwrap_or_else(|| panic!("failed to find `impl_lint_pass`"))
         });
-        let mut impl_lint_pass_end = (&content[impl_lint_pass_start..])
+        let mut impl_lint_pass_end = content[impl_lint_pass_start..]
             .find(']')
             .expect("failed to find `impl_lint_pass` terminator");
 
diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index e80ee6af650..59dcc1ebf19 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -911,7 +911,18 @@ fn param_auto_deref_stability(ty: Ty<'_>, precedence: i8) -> Position {
                 ty = ref_ty;
                 continue;
             },
-            ty::Bool
+            ty::Infer(_)
+            | ty::Error(_)
+            | ty::Param(_)
+            | ty::Bound(..)
+            | ty::Opaque(..)
+            | ty::Placeholder(_)
+            | ty::Dynamic(..) => Position::ReborrowStable(precedence),
+            ty::Adt(..) if ty.has_placeholders() || ty.has_param_types_or_consts() => {
+                Position::ReborrowStable(precedence)
+            },
+            ty::Adt(..)
+            | ty::Bool
             | ty::Char
             | ty::Int(_)
             | ty::Uint(_)
@@ -929,17 +940,6 @@ fn param_auto_deref_stability(ty: Ty<'_>, precedence: i8) -> Position {
             | ty::Never
             | ty::Tuple(_)
             | ty::Projection(_) => Position::DerefStable(precedence),
-            ty::Infer(_)
-            | ty::Error(_)
-            | ty::Param(_)
-            | ty::Bound(..)
-            | ty::Opaque(..)
-            | ty::Placeholder(_)
-            | ty::Dynamic(..) => Position::ReborrowStable(precedence),
-            ty::Adt(..) if ty.has_placeholders() || ty.has_param_types_or_consts() => {
-                Position::ReborrowStable(precedence)
-            },
-            ty::Adt(..) => Position::DerefStable(precedence),
         };
     }
 }
@@ -952,7 +952,7 @@ fn ty_contains_field(ty: Ty<'_>, name: Symbol) -> bool {
     }
 }
 
-#[expect(clippy::needless_pass_by_value)]
+#[expect(clippy::needless_pass_by_value, clippy::too_many_lines)]
 fn report<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, state: State, data: StateData) {
     match state {
         State::DerefMethod {
diff --git a/clippy_lints/src/matches/match_same_arms.rs b/clippy_lints/src/matches/match_same_arms.rs
index 16fefea5520..15513de7d86 100644
--- a/clippy_lints/src/matches/match_same_arms.rs
+++ b/clippy_lints/src/matches/match_same_arms.rs
@@ -285,7 +285,7 @@ impl<'a> NormalizedPat<'a> {
                 // TODO: Handle negative integers. They're currently treated as a wild match.
                 ExprKind::Lit(lit) => match lit.node {
                     LitKind::Str(sym, _) => Self::LitStr(sym),
-                    LitKind::ByteStr(ref bytes) => Self::LitBytes(&**bytes),
+                    LitKind::ByteStr(ref bytes) => Self::LitBytes(bytes),
                     LitKind::Byte(val) => Self::LitInt(val.into()),
                     LitKind::Char(val) => Self::LitInt(val.into()),
                     LitKind::Int(val, _) => Self::LitInt(val),
diff --git a/clippy_lints/src/matches/match_single_binding.rs b/clippy_lints/src/matches/match_single_binding.rs
index 9df2db45dcf..5ae4a65acaf 100644
--- a/clippy_lints/src/matches/match_single_binding.rs
+++ b/clippy_lints/src/matches/match_single_binding.rs
@@ -55,7 +55,7 @@ pub(crate) fn check<'a>(cx: &LateContext<'a>, ex: &Expr<'a>, arms: &[Arm<'_>], e
                         cx,
                         (ex, expr),
                         (bind_names, matched_vars),
-                        &*snippet_body,
+                        &snippet_body,
                         &mut applicability,
                         Some(span),
                     );
@@ -88,7 +88,7 @@ pub(crate) fn check<'a>(cx: &LateContext<'a>, ex: &Expr<'a>, arms: &[Arm<'_>], e
                         cx,
                         (ex, expr),
                         (bind_names, matched_vars),
-                        &*snippet_body,
+                        &snippet_body,
                         &mut applicability,
                         None,
                     );
-- 
cgit 1.4.1-3-g733a5


From ffbba8550a9fb02528638307c93235f758dcf78c Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Wed, 1 Jun 2022 10:43:02 -0400
Subject: Move `SelfAssignment` into `Operators` lint pass

---
 clippy_lints/src/lib.register_all.rs          |  2 +-
 clippy_lints/src/lib.register_correctness.rs  |  2 +-
 clippy_lints/src/lib.register_lints.rs        |  2 +-
 clippy_lints/src/lib.rs                       |  2 -
 clippy_lints/src/operators/mod.rs             | 42 ++++++++++++++++++
 clippy_lints/src/operators/self_assignment.rs | 20 +++++++++
 clippy_lints/src/self_assignment.rs           | 64 ---------------------------
 7 files changed, 65 insertions(+), 69 deletions(-)
 create mode 100644 clippy_lints/src/operators/self_assignment.rs
 delete mode 100644 clippy_lints/src/self_assignment.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index b8aac47202c..27acdd7c726 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -261,6 +261,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(operators::MODULO_ONE),
     LintId::of(operators::OP_REF),
     LintId::of(operators::PTR_EQ),
+    LintId::of(operators::SELF_ASSIGNMENT),
     LintId::of(option_env_unwrap::OPTION_ENV_UNWRAP),
     LintId::of(overflow_check_conditional::OVERFLOW_CHECK_CONDITIONAL),
     LintId::of(partialeq_ne_impl::PARTIALEQ_NE_IMPL),
@@ -286,7 +287,6 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(repeat_once::REPEAT_ONCE),
     LintId::of(returns::LET_AND_RETURN),
     LintId::of(returns::NEEDLESS_RETURN),
-    LintId::of(self_assignment::SELF_ASSIGNMENT),
     LintId::of(self_named_constructors::SELF_NAMED_CONSTRUCTORS),
     LintId::of(serde_api::SERDE_API_MISUSE),
     LintId::of(single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS),
diff --git a/clippy_lints/src/lib.register_correctness.rs b/clippy_lints/src/lib.register_correctness.rs
index 7133b6cdd88..7d5e65cb27a 100644
--- a/clippy_lints/src/lib.register_correctness.rs
+++ b/clippy_lints/src/lib.register_correctness.rs
@@ -51,13 +51,13 @@ store.register_group(true, "clippy::correctness", Some("clippy_correctness"), ve
     LintId::of(operators::ERASING_OP),
     LintId::of(operators::INEFFECTIVE_BIT_MASK),
     LintId::of(operators::MODULO_ONE),
+    LintId::of(operators::SELF_ASSIGNMENT),
     LintId::of(option_env_unwrap::OPTION_ENV_UNWRAP),
     LintId::of(ptr::INVALID_NULL_PTR_USAGE),
     LintId::of(ptr::MUT_FROM_REF),
     LintId::of(ranges::REVERSED_EMPTY_RANGES),
     LintId::of(read_zero_byte_vec::READ_ZERO_BYTE_VEC),
     LintId::of(regex::INVALID_REGEX),
-    LintId::of(self_assignment::SELF_ASSIGNMENT),
     LintId::of(serde_api::SERDE_API_MISUSE),
     LintId::of(size_of_in_element_count::SIZE_OF_IN_ELEMENT_COUNT),
     LintId::of(swap::ALMOST_SWAPPED),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 408f2857263..af7226f242f 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -437,6 +437,7 @@ store.register_lints(&[
     operators::NEEDLESS_BITWISE_BOOL,
     operators::OP_REF,
     operators::PTR_EQ,
+    operators::SELF_ASSIGNMENT,
     operators::VERBOSE_BIT_MASK,
     option_env_unwrap::OPTION_ENV_UNWRAP,
     option_if_let_else::OPTION_IF_LET_ELSE,
@@ -483,7 +484,6 @@ store.register_lints(&[
     returns::LET_AND_RETURN,
     returns::NEEDLESS_RETURN,
     same_name_method::SAME_NAME_METHOD,
-    self_assignment::SELF_ASSIGNMENT,
     self_named_constructors::SELF_NAMED_CONSTRUCTORS,
     semicolon_if_nothing_returned::SEMICOLON_IF_NOTHING_RETURNED,
     serde_api::SERDE_API_MISUSE,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 7b618831ae0..172fdf8c852 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -355,7 +355,6 @@ mod repeat_once;
 mod return_self_not_must_use;
 mod returns;
 mod same_name_method;
-mod self_assignment;
 mod self_named_constructors;
 mod semicolon_if_nothing_returned;
 mod serde_api;
@@ -829,7 +828,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(stable_sort_primitive::StableSortPrimitive));
     store.register_late_pass(|| Box::new(repeat_once::RepeatOnce));
     store.register_late_pass(|| Box::new(unwrap_in_result::UnwrapInResult));
-    store.register_late_pass(|| Box::new(self_assignment::SelfAssignment));
     store.register_late_pass(|| Box::new(manual_ok_or::ManualOkOr));
     store.register_late_pass(|| Box::new(semicolon_if_nothing_returned::SemicolonIfNothingReturned));
     store.register_late_pass(|| Box::new(async_yields_async::AsyncYieldsAsync));
diff --git a/clippy_lints/src/operators/mod.rs b/clippy_lints/src/operators/mod.rs
index b2cf1660ae0..35fe405bcf1 100644
--- a/clippy_lints/src/operators/mod.rs
+++ b/clippy_lints/src/operators/mod.rs
@@ -22,6 +22,7 @@ mod needless_bitwise_bool;
 mod numeric_arithmetic;
 mod op_ref;
 mod ptr_eq;
+mod self_assignment;
 mod verbose_bit_mask;
 
 declare_clippy_lint! {
@@ -701,6 +702,45 @@ declare_clippy_lint! {
     "use `std::ptr::eq` when comparing raw pointers"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for explicit self-assignments.
+    ///
+    /// ### Why is this bad?
+    /// Self-assignments are redundant and unlikely to be
+    /// intentional.
+    ///
+    /// ### Known problems
+    /// If expression contains any deref coercions or
+    /// indexing operations they are assumed not to have any side effects.
+    ///
+    /// ### Example
+    /// ```rust
+    /// struct Event {
+    ///     x: i32,
+    /// }
+    ///
+    /// fn copy_position(a: &mut Event, b: &Event) {
+    ///     a.x = a.x;
+    /// }
+    /// ```
+    ///
+    /// Should be:
+    /// ```rust
+    /// struct Event {
+    ///     x: i32,
+    /// }
+    ///
+    /// fn copy_position(a: &mut Event, b: &Event) {
+    ///     a.x = b.x;
+    /// }
+    /// ```
+    #[clippy::version = "1.48.0"]
+    pub SELF_ASSIGNMENT,
+    correctness,
+    "explicit self-assignment"
+}
+
 pub struct Operators {
     arithmetic_context: numeric_arithmetic::Context,
     verbose_bit_mask_threshold: u64,
@@ -730,6 +770,7 @@ impl_lint_pass!(Operators => [
     MODULO_ARITHMETIC,
     NEEDLESS_BITWISE_BOOL,
     PTR_EQ,
+    SELF_ASSIGNMENT,
 ]);
 impl Operators {
     pub fn new(verbose_bit_mask_threshold: u64) -> Self {
@@ -775,6 +816,7 @@ impl<'tcx> LateLintPass<'tcx> for Operators {
             },
             ExprKind::Assign(lhs, rhs, _) => {
                 assign_op_pattern::check(cx, e, lhs, rhs);
+                self_assignment::check(cx, e, lhs, rhs);
             },
             ExprKind::Unary(op, arg) => {
                 if op == UnOp::Neg {
diff --git a/clippy_lints/src/operators/self_assignment.rs b/clippy_lints/src/operators/self_assignment.rs
new file mode 100644
index 00000000000..9d6bec05bf0
--- /dev/null
+++ b/clippy_lints/src/operators/self_assignment.rs
@@ -0,0 +1,20 @@
+use clippy_utils::diagnostics::span_lint;
+use clippy_utils::eq_expr_value;
+use clippy_utils::source::snippet;
+use rustc_hir::Expr;
+use rustc_lint::LateContext;
+
+use super::SELF_ASSIGNMENT;
+
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>, lhs: &'tcx Expr<'_>, rhs: &'tcx Expr<'_>) {
+    if eq_expr_value(cx, lhs, rhs) {
+        let lhs = snippet(cx, lhs.span, "<lhs>");
+        let rhs = snippet(cx, rhs.span, "<rhs>");
+        span_lint(
+            cx,
+            SELF_ASSIGNMENT,
+            e.span,
+            &format!("self-assignment of `{}` to `{}`", rhs, lhs),
+        );
+    }
+}
diff --git a/clippy_lints/src/self_assignment.rs b/clippy_lints/src/self_assignment.rs
deleted file mode 100644
index af7f5c9b681..00000000000
--- a/clippy_lints/src/self_assignment.rs
+++ /dev/null
@@ -1,64 +0,0 @@
-use clippy_utils::diagnostics::span_lint;
-use clippy_utils::eq_expr_value;
-use clippy_utils::source::snippet;
-use rustc_hir::{Expr, ExprKind};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for explicit self-assignments.
-    ///
-    /// ### Why is this bad?
-    /// Self-assignments are redundant and unlikely to be
-    /// intentional.
-    ///
-    /// ### Known problems
-    /// If expression contains any deref coercions or
-    /// indexing operations they are assumed not to have any side effects.
-    ///
-    /// ### Example
-    /// ```rust
-    /// struct Event {
-    ///     x: i32,
-    /// }
-    ///
-    /// fn copy_position(a: &mut Event, b: &Event) {
-    ///     a.x = a.x;
-    /// }
-    /// ```
-    ///
-    /// Should be:
-    /// ```rust
-    /// struct Event {
-    ///     x: i32,
-    /// }
-    ///
-    /// fn copy_position(a: &mut Event, b: &Event) {
-    ///     a.x = b.x;
-    /// }
-    /// ```
-    #[clippy::version = "1.48.0"]
-    pub SELF_ASSIGNMENT,
-    correctness,
-    "explicit self-assignment"
-}
-
-declare_lint_pass!(SelfAssignment => [SELF_ASSIGNMENT]);
-
-impl<'tcx> LateLintPass<'tcx> for SelfAssignment {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if let ExprKind::Assign(lhs, rhs, _) = &expr.kind {
-            if eq_expr_value(cx, lhs, rhs) {
-                let lhs = snippet(cx, lhs.span, "<lhs>");
-                let rhs = snippet(cx, rhs.span, "<rhs>");
-                span_lint(
-                    cx,
-                    SELF_ASSIGNMENT,
-                    expr.span,
-                    &format!("self-assignment of `{}` to `{}`", rhs, lhs),
-                );
-            }
-        }
-    }
-}
-- 
cgit 1.4.1-3-g733a5


From 58434ae38514222ba03f99183391e56323970243 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Fri, 8 Apr 2022 12:55:48 -0400
Subject: Extract util functions from `redundant_pattern_match`

---
 .../src/matches/redundant_pattern_match.rs         |  84 +------------
 clippy_utils/src/visitors.rs                       | 131 ++++++++++++++++++++-
 2 files changed, 131 insertions(+), 84 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/redundant_pattern_match.rs b/clippy_lints/src/matches/redundant_pattern_match.rs
index 65cecd333f1..8499e050af2 100644
--- a/clippy_lints/src/matches/redundant_pattern_match.rs
+++ b/clippy_lints/src/matches/redundant_pattern_match.rs
@@ -3,16 +3,13 @@ use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet;
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::needs_ordered_drop;
-use clippy_utils::{higher, match_def_path};
-use clippy_utils::{is_lang_ctor, is_trait_method, paths};
+use clippy_utils::visitors::any_temporaries_need_ordered_drop;
+use clippy_utils::{higher, is_lang_ctor, is_trait_method, match_def_path, paths};
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::LangItem::{OptionNone, PollPending};
-use rustc_hir::{
-    intravisit::{walk_expr, Visitor},
-    Arm, Block, Expr, ExprKind, Node, Pat, PatKind, QPath, UnOp,
-};
+use rustc_hir::{Arm, Expr, ExprKind, Node, Pat, PatKind, QPath, UnOp};
 use rustc_lint::LateContext;
 use rustc_middle::ty::{self, subst::GenericArgKind, DefIdTree, Ty};
 use rustc_span::sym;
@@ -47,79 +44,6 @@ fn try_get_generic_ty(ty: Ty<'_>, index: usize) -> Option<Ty<'_>> {
     }
 }
 
-// Checks if there are any temporaries created in the given expression for which drop order
-// matters.
-fn temporaries_need_ordered_drop<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
-    struct V<'a, 'tcx> {
-        cx: &'a LateContext<'tcx>,
-        res: bool,
-    }
-    impl<'a, 'tcx> Visitor<'tcx> for V<'a, 'tcx> {
-        fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) {
-            match expr.kind {
-                // Taking the reference of a value leaves a temporary
-                // e.g. In `&String::new()` the string is a temporary value.
-                // Remaining fields are temporary values
-                // e.g. In `(String::new(), 0).1` the string is a temporary value.
-                ExprKind::AddrOf(_, _, expr) | ExprKind::Field(expr, _) => {
-                    if !matches!(expr.kind, ExprKind::Path(_)) {
-                        if needs_ordered_drop(self.cx, self.cx.typeck_results().expr_ty(expr)) {
-                            self.res = true;
-                        } else {
-                            self.visit_expr(expr);
-                        }
-                    }
-                },
-                // the base type is always taken by reference.
-                // e.g. In `(vec![0])[0]` the vector is a temporary value.
-                ExprKind::Index(base, index) => {
-                    if !matches!(base.kind, ExprKind::Path(_)) {
-                        if needs_ordered_drop(self.cx, self.cx.typeck_results().expr_ty(base)) {
-                            self.res = true;
-                        } else {
-                            self.visit_expr(base);
-                        }
-                    }
-                    self.visit_expr(index);
-                },
-                // Method calls can take self by reference.
-                // e.g. In `String::new().len()` the string is a temporary value.
-                ExprKind::MethodCall(_, [self_arg, args @ ..], _) => {
-                    if !matches!(self_arg.kind, ExprKind::Path(_)) {
-                        let self_by_ref = self
-                            .cx
-                            .typeck_results()
-                            .type_dependent_def_id(expr.hir_id)
-                            .map_or(false, |id| self.cx.tcx.fn_sig(id).skip_binder().inputs()[0].is_ref());
-                        if self_by_ref && needs_ordered_drop(self.cx, self.cx.typeck_results().expr_ty(self_arg)) {
-                            self.res = true;
-                        } else {
-                            self.visit_expr(self_arg);
-                        }
-                    }
-                    args.iter().for_each(|arg| self.visit_expr(arg));
-                },
-                // Either explicitly drops values, or changes control flow.
-                ExprKind::DropTemps(_)
-                | ExprKind::Ret(_)
-                | ExprKind::Break(..)
-                | ExprKind::Yield(..)
-                | ExprKind::Block(Block { expr: None, .. }, _)
-                | ExprKind::Loop(..) => (),
-
-                // Only consider the final expression.
-                ExprKind::Block(Block { expr: Some(expr), .. }, _) => self.visit_expr(expr),
-
-                _ => walk_expr(self, expr),
-            }
-        }
-    }
-
-    let mut v = V { cx, res: false };
-    v.visit_expr(expr);
-    v.res
-}
-
 fn find_sugg_for_if_let<'tcx>(
     cx: &LateContext<'tcx>,
     expr: &'tcx Expr<'_>,
@@ -191,7 +115,7 @@ fn find_sugg_for_if_let<'tcx>(
     // scrutinee would be, so they have to be considered as well.
     // e.g. in `if let Some(x) = foo.lock().unwrap().baz.as_ref() { .. }` the lock will be held
     // for the duration if body.
-    let needs_drop = needs_ordered_drop(cx, check_ty) || temporaries_need_ordered_drop(cx, let_expr);
+    let needs_drop = needs_ordered_drop(cx, check_ty) || any_temporaries_need_ordered_drop(cx, let_expr);
 
     // check that `while_let_on_iterator` lint does not trigger
     if_chain! {
diff --git a/clippy_utils/src/visitors.rs b/clippy_utils/src/visitors.rs
index b6c8f1d516e..68cfa8c1aa8 100644
--- a/clippy_utils/src/visitors.rs
+++ b/clippy_utils/src/visitors.rs
@@ -1,16 +1,18 @@
+use crate::ty::needs_ordered_drop;
 use crate::{get_enclosing_block, path_to_local_id};
 use core::ops::ControlFlow;
 use rustc_hir as hir;
-use rustc_hir::def::{DefKind, Res};
+use rustc_hir::def::{CtorKind, DefKind, Res};
 use rustc_hir::intravisit::{self, walk_block, walk_expr, Visitor};
 use rustc_hir::{
-    Arm, Block, BlockCheckMode, Body, BodyId, Expr, ExprKind, HirId, ItemId, ItemKind, Stmt, UnOp, UnsafeSource,
-    Unsafety,
+    Arm, Block, BlockCheckMode, Body, BodyId, Expr, ExprKind, HirId, ItemId, ItemKind, Let, QPath, Stmt, UnOp,
+    UnsafeSource, Unsafety,
 };
 use rustc_lint::LateContext;
 use rustc_middle::hir::map::Map;
 use rustc_middle::hir::nested_filter;
-use rustc_middle::ty;
+use rustc_middle::ty::adjustment::Adjust;
+use rustc_middle::ty::{self, Ty, TypeckResults};
 
 /// Convenience method for creating a `Visitor` with just `visit_expr` overridden and nested
 /// bodies (i.e. closures) are visited.
@@ -494,3 +496,124 @@ pub fn for_each_local_use_after_expr<'tcx, B>(
         ControlFlow::Continue(())
     }
 }
+
+// Calls the given function for every unconsumed temporary created by the expression. Note the
+// function is only guaranteed to be called for types which need to be dropped, but it may be called
+// for other types.
+pub fn for_each_unconsumed_temporary<'tcx, B>(
+    cx: &LateContext<'tcx>,
+    e: &'tcx Expr<'tcx>,
+    mut f: impl FnMut(Ty<'tcx>) -> ControlFlow<B>,
+) -> ControlFlow<B> {
+    // Todo: Handle partially consumed values.
+    fn helper<'tcx, B>(
+        typeck: &'tcx TypeckResults<'tcx>,
+        consume: bool,
+        e: &'tcx Expr<'tcx>,
+        f: &mut impl FnMut(Ty<'tcx>) -> ControlFlow<B>,
+    ) -> ControlFlow<B> {
+        if !consume
+            || matches!(
+                typeck.expr_adjustments(e),
+                [adjust, ..] if matches!(adjust.kind, Adjust::Borrow(_) | Adjust::Deref(_))
+            )
+        {
+            match e.kind {
+                ExprKind::Path(QPath::Resolved(None, p))
+                    if matches!(p.res, Res::Def(DefKind::Ctor(_, CtorKind::Const), _)) =>
+                {
+                    f(typeck.expr_ty(e))?;
+                },
+                ExprKind::Path(_)
+                | ExprKind::Unary(UnOp::Deref, _)
+                | ExprKind::Index(..)
+                | ExprKind::Field(..)
+                | ExprKind::AddrOf(..) => (),
+                _ => f(typeck.expr_ty(e))?,
+            }
+        }
+        match e.kind {
+            ExprKind::AddrOf(_, _, e)
+            | ExprKind::Field(e, _)
+            | ExprKind::Unary(UnOp::Deref, e)
+            | ExprKind::Match(e, ..)
+            | ExprKind::Let(&Let { init: e, .. }) => {
+                helper(typeck, false, e, f)?;
+            },
+            ExprKind::Block(&Block { expr: Some(e), .. }, _)
+            | ExprKind::Box(e)
+            | ExprKind::Cast(e, _)
+            | ExprKind::Unary(_, e) => {
+                helper(typeck, true, e, f)?;
+            },
+            ExprKind::Call(callee, args) => {
+                helper(typeck, true, callee, f)?;
+                for arg in args {
+                    helper(typeck, true, arg, f)?;
+                }
+            },
+            ExprKind::MethodCall(_, args, _) | ExprKind::Tup(args) | ExprKind::Array(args) => {
+                for arg in args {
+                    helper(typeck, true, arg, f)?;
+                }
+            },
+            ExprKind::Index(borrowed, consumed)
+            | ExprKind::Assign(borrowed, consumed, _)
+            | ExprKind::AssignOp(_, borrowed, consumed) => {
+                helper(typeck, false, borrowed, f)?;
+                helper(typeck, true, consumed, f)?;
+            },
+            ExprKind::Binary(_, lhs, rhs) => {
+                helper(typeck, true, lhs, f)?;
+                helper(typeck, true, rhs, f)?;
+            },
+            ExprKind::Struct(_, fields, default) => {
+                for field in fields {
+                    helper(typeck, true, field.expr, f)?;
+                }
+                if let Some(default) = default {
+                    helper(typeck, false, default, f)?;
+                }
+            },
+            ExprKind::If(cond, then, else_expr) => {
+                helper(typeck, true, cond, f)?;
+                helper(typeck, true, then, f)?;
+                if let Some(else_expr) = else_expr {
+                    helper(typeck, true, else_expr, f)?;
+                }
+            },
+            ExprKind::Type(e, _) => {
+                helper(typeck, consume, e, f)?;
+            },
+
+            // Either drops temporaries, jumps out of the current expression, or has no sub expression.
+            ExprKind::DropTemps(_)
+            | ExprKind::Ret(_)
+            | ExprKind::Break(..)
+            | ExprKind::Yield(..)
+            | ExprKind::Block(..)
+            | ExprKind::Loop(..)
+            | ExprKind::Repeat(..)
+            | ExprKind::Lit(_)
+            | ExprKind::ConstBlock(_)
+            | ExprKind::Closure { .. }
+            | ExprKind::Path(_)
+            | ExprKind::Continue(_)
+            | ExprKind::InlineAsm(_)
+            | ExprKind::Err => (),
+        }
+        ControlFlow::Continue(())
+    }
+    helper(cx.typeck_results(), true, e, &mut f)
+}
+
+pub fn any_temporaries_need_ordered_drop<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'tcx>) -> bool {
+    for_each_unconsumed_temporary(cx, e, |ty| {
+        if needs_ordered_drop(cx, ty) {
+            ControlFlow::Break(())
+        } else {
+            ControlFlow::Continue(())
+        }
+    })
+    .is_break()
+}
-- 
cgit 1.4.1-3-g733a5


From adbc8499d392f61cbc563895fe50a85ed8c63892 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Fri, 8 Apr 2022 13:21:04 -0400
Subject: Don't lint `while_let_loop` when drop order would change

---
 clippy_lints/src/loops/while_let_loop.rs | 106 +++++++++++++++----------------
 tests/ui/while_let_loop.rs               |  26 ++++++++
 2 files changed, 76 insertions(+), 56 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/while_let_loop.rs b/clippy_lints/src/loops/while_let_loop.rs
index 8f57df0be6b..45af6be2653 100644
--- a/clippy_lints/src/loops/while_let_loop.rs
+++ b/clippy_lints/src/loops/while_let_loop.rs
@@ -2,71 +2,60 @@ use super::WHILE_LET_LOOP;
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::higher;
 use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::ty::needs_ordered_drop;
+use clippy_utils::visitors::any_temporaries_need_ordered_drop;
 use rustc_errors::Applicability;
-use rustc_hir::{Block, Expr, ExprKind, MatchSource, Pat, StmtKind};
-use rustc_lint::{LateContext, LintContext};
-use rustc_middle::lint::in_external_macro;
+use rustc_hir::{Block, Expr, ExprKind, Local, MatchSource, Pat, StmtKind};
+use rustc_lint::LateContext;
 
 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, loop_block: &'tcx Block<'_>) {
-    // extract the expression from the first statement (if any) in a block
-    let inner_stmt_expr = extract_expr_from_first_stmt(loop_block);
-    // or extract the first expression (if any) from the block
-    if let Some(inner) = inner_stmt_expr.or_else(|| extract_first_expr(loop_block)) {
-        if let Some(higher::IfLet {
-            let_pat,
-            let_expr,
-            if_else: Some(if_else),
-            ..
-        }) = higher::IfLet::hir(cx, inner)
-        {
-            if is_simple_break_expr(if_else) {
-                could_be_while_let(cx, expr, let_pat, let_expr);
+    let (init, has_trailing_exprs) = match (loop_block.stmts, loop_block.expr) {
+        ([stmt, stmts @ ..], expr) => {
+            if let StmtKind::Local(&Local { init: Some(e), .. }) | StmtKind::Semi(e) | StmtKind::Expr(e) = stmt.kind {
+                (e, !stmts.is_empty() || expr.is_some())
+            } else {
+                return;
             }
-        }
-
-        if let ExprKind::Match(matchexpr, arms, MatchSource::Normal) = inner.kind {
-            if arms.len() == 2
-                && arms[0].guard.is_none()
-                && arms[1].guard.is_none()
-                && is_simple_break_expr(arms[1].body)
-            {
-                could_be_while_let(cx, expr, arms[0].pat, matchexpr);
-            }
-        }
-    }
-}
+        },
+        ([], Some(e)) => (e, false),
+        _ => return,
+    };
 
-/// If a block begins with a statement (possibly a `let` binding) and has an
-/// expression, return it.
-fn extract_expr_from_first_stmt<'tcx>(block: &Block<'tcx>) -> Option<&'tcx Expr<'tcx>> {
-    if let Some(first_stmt) = block.stmts.get(0) {
-        if let StmtKind::Local(local) = first_stmt.kind {
-            return local.init;
-        }
+    if let Some(if_let) = higher::IfLet::hir(cx, init)
+        && let Some(else_expr) = if_let.if_else
+        && is_simple_break_expr(else_expr)
+    {
+        could_be_while_let(cx, expr, if_let.let_pat, if_let.let_expr, has_trailing_exprs);
+    } else if let ExprKind::Match(scrutinee, [arm1, arm2], MatchSource::Normal) = init.kind
+        && arm1.guard.is_none()
+        && arm2.guard.is_none()
+        && is_simple_break_expr(arm2.body)
+    {
+        could_be_while_let(cx, expr, arm1.pat, scrutinee, has_trailing_exprs);
     }
-    None
 }
 
-/// If a block begins with an expression (with or without semicolon), return it.
-fn extract_first_expr<'tcx>(block: &Block<'tcx>) -> Option<&'tcx Expr<'tcx>> {
-    match block.expr {
-        Some(expr) if block.stmts.is_empty() => Some(expr),
-        None if !block.stmts.is_empty() => match block.stmts[0].kind {
-            StmtKind::Expr(expr) | StmtKind::Semi(expr) => Some(expr),
-            StmtKind::Local(..) | StmtKind::Item(..) => None,
-        },
-        _ => None,
-    }
+/// Returns `true` if expr contains a single break expression without a label or eub-expression.
+fn is_simple_break_expr(e: &Expr<'_>) -> bool {
+    matches!(peel_blocks(e).kind, ExprKind::Break(dest, None) if dest.label.is_none())
 }
 
-/// Returns `true` if expr contains a single break expr without destination label
-/// and
-/// passed expression. The expression may be within a block.
-fn is_simple_break_expr(expr: &Expr<'_>) -> bool {
-    match expr.kind {
-        ExprKind::Break(dest, ref passed_expr) if dest.label.is_none() && passed_expr.is_none() => true,
-        ExprKind::Block(b, _) => extract_first_expr(b).map_or(false, is_simple_break_expr),
-        _ => false,
+/// Removes any blocks containing only a single expression.
+fn peel_blocks<'tcx>(e: &'tcx Expr<'tcx>) -> &'tcx Expr<'tcx> {
+    if let ExprKind::Block(b, _) = e.kind {
+        match (b.stmts, b.expr) {
+            ([s], None) => {
+                if let StmtKind::Expr(e) | StmtKind::Semi(e) = s.kind {
+                    peel_blocks(e)
+                } else {
+                    e
+                }
+            },
+            ([], Some(e)) => peel_blocks(e),
+            _ => e,
+        }
+    } else {
+        e
     }
 }
 
@@ -75,8 +64,13 @@ fn could_be_while_let<'tcx>(
     expr: &'tcx Expr<'_>,
     let_pat: &'tcx Pat<'_>,
     let_expr: &'tcx Expr<'_>,
+    has_trailing_exprs: bool,
 ) {
-    if in_external_macro(cx.sess(), expr.span) {
+    if has_trailing_exprs
+        && (needs_ordered_drop(cx, cx.typeck_results().expr_ty(let_expr))
+            || any_temporaries_need_ordered_drop(cx, let_expr))
+    {
+        // Switching to a `while let` loop will extend the lifetime of some values.
         return;
     }
 
diff --git a/tests/ui/while_let_loop.rs b/tests/ui/while_let_loop.rs
index 3ce699f551b..c42e2a79a9b 100644
--- a/tests/ui/while_let_loop.rs
+++ b/tests/ui/while_let_loop.rs
@@ -117,3 +117,29 @@ fn issue1948() {
         }
     };
 }
+
+fn issue_7913(m: &std::sync::Mutex<Vec<u32>>) {
+    // Don't lint. The lock shouldn't be held while printing.
+    loop {
+        let x = if let Some(x) = m.lock().unwrap().pop() {
+            x
+        } else {
+            break;
+        };
+
+        println!("{}", x);
+    }
+}
+
+fn issue_5715(mut m: core::cell::RefCell<Option<u32>>) {
+    // Don't lint. The temporary from `borrow_mut` must be dropped before overwriting the `RefCell`.
+    loop {
+        let x = if let &mut Some(x) = &mut *m.borrow_mut() {
+            x
+        } else {
+            break;
+        };
+
+        m = core::cell::RefCell::new(Some(x + 1));
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 5d75a9bd4c4ec2d6c80be2d91edea57c7f0871b6 Mon Sep 17 00:00:00 2001
From: tamaron <tamaron1203@gmail.com>
Date: Thu, 30 Jun 2022 11:59:23 +0900
Subject: fix

---
 clippy_lints/src/matches/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/mod.rs b/clippy_lints/src/matches/mod.rs
index d43ad1b8c9c..b2a873ef582 100644
--- a/clippy_lints/src/matches/mod.rs
+++ b/clippy_lints/src/matches/mod.rs
@@ -791,7 +791,7 @@ declare_clippy_lint! {
     /// the match block and thus will not unlock.
     ///
     /// ### Example
-    /// ```rust.ignore
+    /// ```rust,ignore
     /// # use std::sync::Mutex;
     ///
     /// # struct State {}
-- 
cgit 1.4.1-3-g733a5


From 5d9e1b6f009f67c401905551d774aa352f5b9273 Mon Sep 17 00:00:00 2001
From: tamaron <tamaron1203@gmail.com>
Date: Thu, 30 Jun 2022 13:21:17 +0900
Subject: Update large_const_arrays.rs

---
 clippy_lints/src/large_const_arrays.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/large_const_arrays.rs b/clippy_lints/src/large_const_arrays.rs
index 289755bfec6..984c5cd4e37 100644
--- a/clippy_lints/src/large_const_arrays.rs
+++ b/clippy_lints/src/large_const_arrays.rs
@@ -24,7 +24,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust.ignore
+    /// ```rust,ignore
     /// pub static a = [0u32; 1_000_000];
     /// ```
     #[clippy::version = "1.44.0"]
-- 
cgit 1.4.1-3-g733a5


From b7051077c9d7e73704c4ea83f38f2a2e9f2003c1 Mon Sep 17 00:00:00 2001
From: dAxpeDDa <daxpedda@gmail.com>
Date: Thu, 30 Jun 2022 17:45:34 +0200
Subject: Fix false-positive in `equatable_if_let`

---
 clippy_lints/src/equatable_if_let.rs |  4 +++-
 tests/ui/auxiliary/macro_rules.rs    |  5 +++++
 tests/ui/equatable_if_let.fixed      |  6 ++++++
 tests/ui/equatable_if_let.rs         |  6 ++++++
 tests/ui/equatable_if_let.stderr     | 22 +++++++++++-----------
 5 files changed, 31 insertions(+), 12 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/equatable_if_let.rs b/clippy_lints/src/equatable_if_let.rs
index ef1216358dd..fdfb821ac78 100644
--- a/clippy_lints/src/equatable_if_let.rs
+++ b/clippy_lints/src/equatable_if_let.rs
@@ -4,7 +4,8 @@ use clippy_utils::ty::implements_trait;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, Pat, PatKind};
-use rustc_lint::{LateContext, LateLintPass};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::Ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
@@ -67,6 +68,7 @@ fn is_structural_partial_eq<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>, other: T
 impl<'tcx> LateLintPass<'tcx> for PatternEquality {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
         if_chain! {
+            if !in_external_macro(cx.sess(), expr.span);
             if let ExprKind::Let(let_expr) = expr.kind;
             if unary_pattern(let_expr.pat);
             let exp_ty = cx.typeck_results().expr_ty(let_expr.init);
diff --git a/tests/ui/auxiliary/macro_rules.rs b/tests/ui/auxiliary/macro_rules.rs
index 5bd2c2799f0..83a0af6b87a 100644
--- a/tests/ui/auxiliary/macro_rules.rs
+++ b/tests/ui/auxiliary/macro_rules.rs
@@ -135,3 +135,8 @@ macro_rules! manual_rem_euclid {
         let _: i32 = ((value % 4) + 4) % 4;
     };
 }
+
+#[macro_export]
+macro_rules! equatable_if_let {
+    ($a:ident) => {{ if let 2 = $a {} }};
+}
diff --git a/tests/ui/equatable_if_let.fixed b/tests/ui/equatable_if_let.fixed
index 47bf25e409b..687efdada6e 100644
--- a/tests/ui/equatable_if_let.fixed
+++ b/tests/ui/equatable_if_let.fixed
@@ -1,8 +1,12 @@
 // run-rustfix
+// aux-build:macro_rules.rs
 
 #![allow(unused_variables, dead_code, clippy::derive_partial_eq_without_eq)]
 #![warn(clippy::equatable_if_let)]
 
+#[macro_use]
+extern crate macro_rules;
+
 use std::cmp::Ordering;
 
 #[derive(PartialEq)]
@@ -75,4 +79,6 @@ fn main() {
     if "abc" == m1!(x) {
         println!("OK");
     }
+
+    equatable_if_let!(a);
 }
diff --git a/tests/ui/equatable_if_let.rs b/tests/ui/equatable_if_let.rs
index d498bca2455..8c467d14d2a 100644
--- a/tests/ui/equatable_if_let.rs
+++ b/tests/ui/equatable_if_let.rs
@@ -1,8 +1,12 @@
 // run-rustfix
+// aux-build:macro_rules.rs
 
 #![allow(unused_variables, dead_code, clippy::derive_partial_eq_without_eq)]
 #![warn(clippy::equatable_if_let)]
 
+#[macro_use]
+extern crate macro_rules;
+
 use std::cmp::Ordering;
 
 #[derive(PartialEq)]
@@ -75,4 +79,6 @@ fn main() {
     if let m1!(x) = "abc" {
         println!("OK");
     }
+
+    equatable_if_let!(a);
 }
diff --git a/tests/ui/equatable_if_let.stderr b/tests/ui/equatable_if_let.stderr
index 760ff88f448..9c4c3cc3682 100644
--- a/tests/ui/equatable_if_let.stderr
+++ b/tests/ui/equatable_if_let.stderr
@@ -1,5 +1,5 @@
 error: this pattern matching can be expressed using equality
-  --> $DIR/equatable_if_let.rs:49:8
+  --> $DIR/equatable_if_let.rs:53:8
    |
 LL |     if let 2 = a {}
    |        ^^^^^^^^^ help: try: `a == 2`
@@ -7,61 +7,61 @@ LL |     if let 2 = a {}
    = note: `-D clippy::equatable-if-let` implied by `-D warnings`
 
 error: this pattern matching can be expressed using equality
-  --> $DIR/equatable_if_let.rs:50:8
+  --> $DIR/equatable_if_let.rs:54:8
    |
 LL |     if let Ordering::Greater = a.cmp(&b) {}
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `a.cmp(&b) == Ordering::Greater`
 
 error: this pattern matching can be expressed using equality
-  --> $DIR/equatable_if_let.rs:51:8
+  --> $DIR/equatable_if_let.rs:55:8
    |
 LL |     if let Some(2) = c {}
    |        ^^^^^^^^^^^^^^^ help: try: `c == Some(2)`
 
 error: this pattern matching can be expressed using equality
-  --> $DIR/equatable_if_let.rs:52:8
+  --> $DIR/equatable_if_let.rs:56:8
    |
 LL |     if let Struct { a: 2, b: false } = d {}
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `d == (Struct { a: 2, b: false })`
 
 error: this pattern matching can be expressed using equality
-  --> $DIR/equatable_if_let.rs:53:8
+  --> $DIR/equatable_if_let.rs:57:8
    |
 LL |     if let Enum::TupleVariant(32, 64) = e {}
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `e == Enum::TupleVariant(32, 64)`
 
 error: this pattern matching can be expressed using equality
-  --> $DIR/equatable_if_let.rs:54:8
+  --> $DIR/equatable_if_let.rs:58:8
    |
 LL |     if let Enum::RecordVariant { a: 64, b: 32 } = e {}
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `e == (Enum::RecordVariant { a: 64, b: 32 })`
 
 error: this pattern matching can be expressed using equality
-  --> $DIR/equatable_if_let.rs:55:8
+  --> $DIR/equatable_if_let.rs:59:8
    |
 LL |     if let Enum::UnitVariant = e {}
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `e == Enum::UnitVariant`
 
 error: this pattern matching can be expressed using equality
-  --> $DIR/equatable_if_let.rs:56:8
+  --> $DIR/equatable_if_let.rs:60:8
    |
 LL |     if let (Enum::UnitVariant, &Struct { a: 2, b: false }) = (e, &d) {}
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `(e, &d) == (Enum::UnitVariant, &Struct { a: 2, b: false })`
 
 error: this pattern matching can be expressed using equality
-  --> $DIR/equatable_if_let.rs:66:8
+  --> $DIR/equatable_if_let.rs:70:8
    |
 LL |     if let NotStructuralEq::A = g {}
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `g == NotStructuralEq::A`
 
 error: this pattern matching can be expressed using equality
-  --> $DIR/equatable_if_let.rs:68:8
+  --> $DIR/equatable_if_let.rs:72:8
    |
 LL |     if let Some(NotStructuralEq::A) = Some(g) {}
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Some(g) == Some(NotStructuralEq::A)`
 
 error: this pattern matching can be expressed using equality
-  --> $DIR/equatable_if_let.rs:75:8
+  --> $DIR/equatable_if_let.rs:79:8
    |
 LL |     if let m1!(x) = "abc" {
    |        ^^^^^^^^^^^^^^^^^^ help: try: `"abc" == m1!(x)`
-- 
cgit 1.4.1-3-g733a5


From a2b8a67777500139ba36d07d21f7e543e9c0f65c Mon Sep 17 00:00:00 2001
From: Muhammad Hamza <muhammadhamza1311@gmail.com>
Date: Fri, 1 Jul 2022 00:14:38 +0500
Subject: Fix broken hyperlink

---
 clippy_lints/src/methods/mod.rs | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 9bb7bb7a7ab..cc1530f0ed0 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -2196,12 +2196,9 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Finds usages of [`char::is_digit`]
-    /// (https://doc.rust-lang.org/stable/std/primitive.char.html#method.is_digit) that
-    /// can be replaced with [`is_ascii_digit`]
-    /// (https://doc.rust-lang.org/stable/std/primitive.char.html#method.is_ascii_digit) or
-    /// [`is_ascii_hexdigit`]
-    /// (https://doc.rust-lang.org/stable/std/primitive.char.html#method.is_ascii_hexdigit).
+    /// Finds usages of [`char::is_digit`](https://doc.rust-lang.org/stable/std/primitive.char.html#method.is_digit) that
+    /// can be replaced with [`is_ascii_digit`](https://doc.rust-lang.org/stable/std/primitive.char.html#method.is_ascii_digit) or
+    /// [`is_ascii_hexdigit`](https://doc.rust-lang.org/stable/std/primitive.char.html#method.is_ascii_hexdigit).
     ///
     /// ### Why is this bad?
     /// `is_digit(..)` is slower and requires specifying the radix.
-- 
cgit 1.4.1-3-g733a5


From a5b70a4c1df9d009823ec067e7544ce28ec29c2f Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Fri, 1 Jul 2022 12:08:28 +0000
Subject: Fix allow attributes in let_unit_value

---
 clippy_lints/src/unit_types/let_unit_value.rs | 17 ++++++++---------
 clippy_lints/src/unit_types/mod.rs            |  6 +++---
 tests/ui/let_unit.fixed                       | 12 +++++++++++-
 tests/ui/let_unit.rs                          | 12 +++++++++++-
 tests/ui/let_unit.stderr                      | 22 +++++++++++-----------
 5 files changed, 44 insertions(+), 25 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unit_types/let_unit_value.rs b/clippy_lints/src/unit_types/let_unit_value.rs
index 27678c8ba3c..17d60a40dce 100644
--- a/clippy_lints/src/unit_types/let_unit_value.rs
+++ b/clippy_lints/src/unit_types/let_unit_value.rs
@@ -4,18 +4,17 @@ use clippy_utils::visitors::for_each_value_source;
 use core::ops::ControlFlow;
 use rustc_errors::Applicability;
 use rustc_hir::def::{DefKind, Res};
-use rustc_hir::{Expr, ExprKind, PatKind, Stmt, StmtKind};
+use rustc_hir::{Expr, ExprKind, Local, PatKind};
 use rustc_lint::{LateContext, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::{self, Ty, TypeFoldable, TypeSuperFoldable, TypeVisitor};
 
 use super::LET_UNIT_VALUE;
 
-pub(super) fn check(cx: &LateContext<'_>, stmt: &Stmt<'_>) {
-    if let StmtKind::Local(local) = stmt.kind
-        && let Some(init) = local.init
+pub(super) fn check(cx: &LateContext<'_>, local: &Local<'_>) {
+    if let Some(init) = local.init
         && !local.pat.span.from_expansion()
-        && !in_external_macro(cx.sess(), stmt.span)
+        && !in_external_macro(cx.sess(), local.span)
         && cx.typeck_results().pat_ty(local.pat).is_unit()
     {
         let needs_inferred = for_each_value_source(init, &mut |e| if needs_inferred_result_ty(cx, e) {
@@ -29,7 +28,7 @@ pub(super) fn check(cx: &LateContext<'_>, stmt: &Stmt<'_>) {
                 span_lint_and_then(
                     cx,
                     LET_UNIT_VALUE,
-                    stmt.span,
+                    local.span,
                     "this let-binding has unit value",
                     |diag| {
                             diag.span_suggestion(
@@ -45,15 +44,15 @@ pub(super) fn check(cx: &LateContext<'_>, stmt: &Stmt<'_>) {
             span_lint_and_then(
                 cx,
                 LET_UNIT_VALUE,
-                stmt.span,
+                local.span,
                 "this let-binding has unit value",
                 |diag| {
                     if let Some(expr) = &local.init {
                         let snip = snippet_with_macro_callsite(cx, expr.span, "()");
                         diag.span_suggestion(
-                            stmt.span,
+                            local.span,
                             "omit the `let` binding",
-                            format!("{};", snip),
+                            format!("{snip};"),
                             Applicability::MachineApplicable, // snippet
                         );
                     }
diff --git a/clippy_lints/src/unit_types/mod.rs b/clippy_lints/src/unit_types/mod.rs
index a9e2073dec2..e57d4fc3b89 100644
--- a/clippy_lints/src/unit_types/mod.rs
+++ b/clippy_lints/src/unit_types/mod.rs
@@ -3,7 +3,7 @@ mod unit_arg;
 mod unit_cmp;
 mod utils;
 
-use rustc_hir::{Expr, Stmt};
+use rustc_hir::{Expr, Local};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
@@ -99,8 +99,8 @@ declare_clippy_lint! {
 declare_lint_pass!(UnitTypes => [LET_UNIT_VALUE, UNIT_CMP, UNIT_ARG]);
 
 impl LateLintPass<'_> for UnitTypes {
-    fn check_stmt(&mut self, cx: &LateContext<'_>, stmt: &Stmt<'_>) {
-        let_unit_value::check(cx, stmt);
+    fn check_local(&mut self, cx: &LateContext<'_>, local: &Local<'_>) {
+        let_unit_value::check(cx, local);
     }
 
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
diff --git a/tests/ui/let_unit.fixed b/tests/ui/let_unit.fixed
index e72b7462325..18c2672f880 100644
--- a/tests/ui/let_unit.fixed
+++ b/tests/ui/let_unit.fixed
@@ -1,8 +1,9 @@
 // run-rustfix
 
+#![feature(lint_reasons)]
 #![warn(clippy::let_unit_value)]
 #![allow(clippy::no_effect)]
-#![allow(unused_variables)]
+#![allow(unused)]
 
 macro_rules! let_and_return {
     ($n:expr) => {{
@@ -113,3 +114,12 @@ fn _returns_generic() {
         Some(_) => (),
     };
 }
+
+fn attributes() {
+    fn f() {}
+
+    #[allow(clippy::let_unit_value)]
+    let _ = f();
+    #[expect(clippy::let_unit_value)]
+    let _ = f();
+}
diff --git a/tests/ui/let_unit.rs b/tests/ui/let_unit.rs
index 47ee0a76724..c9c4582a956 100644
--- a/tests/ui/let_unit.rs
+++ b/tests/ui/let_unit.rs
@@ -1,8 +1,9 @@
 // run-rustfix
 
+#![feature(lint_reasons)]
 #![warn(clippy::let_unit_value)]
 #![allow(clippy::no_effect)]
-#![allow(unused_variables)]
+#![allow(unused)]
 
 macro_rules! let_and_return {
     ($n:expr) => {{
@@ -113,3 +114,12 @@ fn _returns_generic() {
         Some(_) => (),
     };
 }
+
+fn attributes() {
+    fn f() {}
+
+    #[allow(clippy::let_unit_value)]
+    let _ = f();
+    #[expect(clippy::let_unit_value)]
+    let _ = f();
+}
diff --git a/tests/ui/let_unit.stderr b/tests/ui/let_unit.stderr
index 45bf67acdb7..47a2a6e3cc1 100644
--- a/tests/ui/let_unit.stderr
+++ b/tests/ui/let_unit.stderr
@@ -1,5 +1,5 @@
 error: this let-binding has unit value
-  --> $DIR/let_unit.rs:14:5
+  --> $DIR/let_unit.rs:15:5
    |
 LL |     let _x = println!("x");
    |     ^^^^^^^^^^^^^^^^^^^^^^^ help: omit the `let` binding: `println!("x");`
@@ -7,13 +7,13 @@ LL |     let _x = println!("x");
    = note: `-D clippy::let-unit-value` implied by `-D warnings`
 
 error: this let-binding has unit value
-  --> $DIR/let_unit.rs:18:9
+  --> $DIR/let_unit.rs:19:9
    |
 LL |         let _a = ();
    |         ^^^^^^^^^^^^ help: omit the `let` binding: `();`
 
 error: this let-binding has unit value
-  --> $DIR/let_unit.rs:53:5
+  --> $DIR/let_unit.rs:54:5
    |
 LL | /     let _ = v
 LL | |         .into_iter()
@@ -36,7 +36,7 @@ LL +         .unwrap();
    |
 
 error: this let-binding has unit value
-  --> $DIR/let_unit.rs:80:5
+  --> $DIR/let_unit.rs:81:5
    |
 LL |     let x: () = f(); // Lint.
    |     ^^^^-^^^^^^^^^^^
@@ -44,7 +44,7 @@ LL |     let x: () = f(); // Lint.
    |         help: use a wild (`_`) binding: `_`
 
 error: this let-binding has unit value
-  --> $DIR/let_unit.rs:83:5
+  --> $DIR/let_unit.rs:84:5
    |
 LL |     let x: () = f2(0i32); // Lint.
    |     ^^^^-^^^^^^^^^^^^^^^^
@@ -52,31 +52,31 @@ LL |     let x: () = f2(0i32); // Lint.
    |         help: use a wild (`_`) binding: `_`
 
 error: this let-binding has unit value
-  --> $DIR/let_unit.rs:85:5
+  --> $DIR/let_unit.rs:86:5
    |
 LL |     let _: () = f3(()); // Lint
    |     ^^^^^^^^^^^^^^^^^^^ help: omit the `let` binding: `f3(());`
 
 error: this let-binding has unit value
-  --> $DIR/let_unit.rs:86:5
+  --> $DIR/let_unit.rs:87:5
    |
 LL |     let x: () = f3(()); // Lint
    |     ^^^^^^^^^^^^^^^^^^^ help: omit the `let` binding: `f3(());`
 
 error: this let-binding has unit value
-  --> $DIR/let_unit.rs:88:5
+  --> $DIR/let_unit.rs:89:5
    |
 LL |     let _: () = f4(vec![()]); // Lint
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^ help: omit the `let` binding: `f4(vec![()]);`
 
 error: this let-binding has unit value
-  --> $DIR/let_unit.rs:89:5
+  --> $DIR/let_unit.rs:90:5
    |
 LL |     let x: () = f4(vec![()]); // Lint
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^ help: omit the `let` binding: `f4(vec![()]);`
 
 error: this let-binding has unit value
-  --> $DIR/let_unit.rs:98:5
+  --> $DIR/let_unit.rs:99:5
    |
 LL |     let x: () = if true { f() } else { f2(0) }; // Lint
    |     ^^^^-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -84,7 +84,7 @@ LL |     let x: () = if true { f() } else { f2(0) }; // Lint
    |         help: use a wild (`_`) binding: `_`
 
 error: this let-binding has unit value
-  --> $DIR/let_unit.rs:109:5
+  --> $DIR/let_unit.rs:110:5
    |
 LL | /     let _: () = match Some(0) {
 LL | |         None => f2(1),
-- 
cgit 1.4.1-3-g733a5


From a86bf81e44dd530b69b686c556069bb8f6569c64 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Fri, 1 Jul 2022 18:05:45 +0200
Subject: Correct lint version for `format_push_string`

---
 clippy_lints/src/format_push_string.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/format_push_string.rs b/clippy_lints/src/format_push_string.rs
index ee15ae9f59a..de19c5ec20e 100644
--- a/clippy_lints/src/format_push_string.rs
+++ b/clippy_lints/src/format_push_string.rs
@@ -27,7 +27,7 @@ declare_clippy_lint! {
     /// let mut s = String::new();
     /// let _ = write!(s, "0x{:X}", 1024);
     /// ```
-    #[clippy::version = "1.61.0"]
+    #[clippy::version = "1.62.0"]
     pub FORMAT_PUSH_STRING,
     perf,
     "`format!(..)` appended to existing `String`"
-- 
cgit 1.4.1-3-g733a5


From 3e80d3988d70847e6b870749641ea6d434ff261b Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sat, 2 Jul 2022 00:59:58 -0400
Subject: Fix ICE in `dereference.rs`

---
 clippy_lints/src/dereference.rs     | 40 +++++++++++++++++++++++++------------
 tests/ui/explicit_auto_deref.fixed  |  4 ++++
 tests/ui/explicit_auto_deref.rs     |  4 ++++
 tests/ui/explicit_auto_deref.stderr |  8 +++++++-
 4 files changed, 42 insertions(+), 14 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index 59dcc1ebf19..14e8d5940cf 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -8,7 +8,7 @@ use rustc_data_structures::fx::FxIndexMap;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_ty, Visitor};
 use rustc_hir::{
-    self as hir, BindingAnnotation, Body, BodyId, BorrowKind, Expr, ExprKind, GenericArg, HirId, ImplItem,
+    self as hir, BindingAnnotation, Body, BodyId, BorrowKind, Expr, ExprKind, FnRetTy, GenericArg, HirId, ImplItem,
     ImplItemKind, Item, ItemKind, Local, MatchSource, Mutability, Node, Pat, PatKind, Path, QPath, TraitItem,
     TraitItemKind, TyKind, UnOp,
 };
@@ -717,18 +717,32 @@ fn walk_parents<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> (Position, &
 
             Node::Expr(parent) if parent.span.ctxt() == ctxt => match parent.kind {
                 ExprKind::Ret(_) => {
-                    let output = cx
-                        .tcx
-                        .fn_sig(cx.tcx.hir().body_owner_def_id(cx.enclosing_body.unwrap()))
-                        .skip_binder()
-                        .output();
-                    Some(if !output.is_ref() {
-                        Position::Other(precedence)
-                    } else if output.has_placeholders() || output.has_opaque_types() {
-                        Position::ReborrowStable(precedence)
-                    } else {
-                        Position::DerefStable(precedence)
-                    })
+                    let owner_id = cx.tcx.hir().body_owner(cx.enclosing_body.unwrap());
+                    Some(
+                        if let Node::Expr(Expr {
+                            kind: ExprKind::Closure { fn_decl, .. },
+                            ..
+                        }) = cx.tcx.hir().get(owner_id)
+                        {
+                            match fn_decl.output {
+                                FnRetTy::Return(ty) => binding_ty_auto_deref_stability(ty, precedence),
+                                FnRetTy::DefaultReturn(_) => Position::Other(precedence),
+                            }
+                        } else {
+                            let output = cx
+                                .tcx
+                                .fn_sig(cx.tcx.hir().local_def_id(owner_id))
+                                .skip_binder()
+                                .output();
+                            if !output.is_ref() {
+                                Position::Other(precedence)
+                            } else if output.has_placeholders() || output.has_opaque_types() {
+                                Position::ReborrowStable(precedence)
+                            } else {
+                                Position::DerefStable(precedence)
+                            }
+                        },
+                    )
                 },
                 ExprKind::Call(func, _) if func.hir_id == child_id => (child_id == e.hir_id).then(|| Position::Callee),
                 ExprKind::Call(func, args) => args
diff --git a/tests/ui/explicit_auto_deref.fixed b/tests/ui/explicit_auto_deref.fixed
index d4ff1b1566d..a650fdc1f89 100644
--- a/tests/ui/explicit_auto_deref.fixed
+++ b/tests/ui/explicit_auto_deref.fixed
@@ -211,4 +211,8 @@ fn main() {
     unsafe {
         var(0, &**x);
     }
+
+    let s = &"str";
+    let _ = || return *s;
+    let _ = || -> &'static str { return s };
 }
diff --git a/tests/ui/explicit_auto_deref.rs b/tests/ui/explicit_auto_deref.rs
index 99294a7947b..8f4f352576a 100644
--- a/tests/ui/explicit_auto_deref.rs
+++ b/tests/ui/explicit_auto_deref.rs
@@ -211,4 +211,8 @@ fn main() {
     unsafe {
         var(0, &**x);
     }
+
+    let s = &"str";
+    let _ = || return *s;
+    let _ = || -> &'static str { return *s };
 }
diff --git a/tests/ui/explicit_auto_deref.stderr b/tests/ui/explicit_auto_deref.stderr
index 55f956e37ae..92765307ea7 100644
--- a/tests/ui/explicit_auto_deref.stderr
+++ b/tests/ui/explicit_auto_deref.stderr
@@ -192,5 +192,11 @@ error: deref which would be done by auto-deref
 LL |     f_str(&&**ref_str); // `needless_borrow` will suggest removing only one reference
    |            ^^^^^^^^^^ help: try this: `ref_str`
 
-error: aborting due to 32 previous errors
+error: deref which would be done by auto-deref
+  --> $DIR/explicit_auto_deref.rs:217:41
+   |
+LL |     let _ = || -> &'static str { return *s };
+   |                                         ^^ help: try this: `s`
+
+error: aborting due to 33 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 988b813649c147383bcce125c9afbb0adc681110 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sat, 2 Jul 2022 15:32:29 -0400
Subject: Use correct substitutions when checking if `needless_borrow` can
 apply to a method receiver

---
 clippy_lints/src/dereference.rs | 11 ++++++++---
 tests/ui/needless_borrow.fixed  | 12 ++++++++++++
 tests/ui/needless_borrow.rs     | 12 ++++++++++++
 3 files changed, 32 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index 59dcc1ebf19..d6bd43a7494 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -756,9 +756,14 @@ fn walk_parents<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> (Position, &
                             } else if let Some(trait_id) = cx.tcx.trait_of_item(id)
                                 && let arg_ty = cx.tcx.erase_regions(cx.typeck_results().expr_ty_adjusted(e))
                                 && let ty::Ref(_, sub_ty, _) = *arg_ty.kind()
-                                && let subs = cx.typeck_results().node_substs_opt(child_id).unwrap_or_else(
-                                    || cx.tcx.mk_substs([].iter())
-                                ) && let impl_ty = if cx.tcx.fn_sig(id).skip_binder().inputs()[0].is_ref() {
+                                && let subs = match cx
+                                    .typeck_results()
+                                    .node_substs_opt(parent.hir_id)
+                                    .and_then(|subs| subs.get(1..))
+                                {
+                                    Some(subs) => cx.tcx.mk_substs(subs.iter().copied()),
+                                    None => cx.tcx.mk_substs([].iter()),
+                                } && let impl_ty = if cx.tcx.fn_sig(id).skip_binder().inputs()[0].is_ref() {
                                     // Trait methods taking `&self`
                                     sub_ty
                                 } else {
diff --git a/tests/ui/needless_borrow.fixed b/tests/ui/needless_borrow.fixed
index cb005122436..09afe2ddbbf 100644
--- a/tests/ui/needless_borrow.fixed
+++ b/tests/ui/needless_borrow.fixed
@@ -115,6 +115,18 @@ fn main() {
         fn foo_ref(&self) {}
     }
     (&&()).foo_ref(); // Don't lint. `&()` will call `<() as FooRef>::foo_ref`
+
+    struct S;
+    impl From<S> for u32 {
+        fn from(s: S) -> Self {
+            (&s).into()
+        }
+    }
+    impl From<&S> for u32 {
+        fn from(s: &S) -> Self {
+            0
+        }
+    }
 }
 
 #[allow(clippy::needless_borrowed_reference)]
diff --git a/tests/ui/needless_borrow.rs b/tests/ui/needless_borrow.rs
index d636a401003..3ae4722a1f8 100644
--- a/tests/ui/needless_borrow.rs
+++ b/tests/ui/needless_borrow.rs
@@ -115,6 +115,18 @@ fn main() {
         fn foo_ref(&self) {}
     }
     (&&()).foo_ref(); // Don't lint. `&()` will call `<() as FooRef>::foo_ref`
+
+    struct S;
+    impl From<S> for u32 {
+        fn from(s: S) -> Self {
+            (&s).into()
+        }
+    }
+    impl From<&S> for u32 {
+        fn from(s: &S) -> Self {
+            0
+        }
+    }
 }
 
 #[allow(clippy::needless_borrowed_reference)]
-- 
cgit 1.4.1-3-g733a5


From 2dd5fc14da4065fa0ac7710582e7393822d40d37 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Sun, 3 Jul 2022 17:02:48 +0200
Subject: Correct `[clippy::version]` for 1.62 lints and add note to docs

---
 book/src/development/infrastructure/changelog_update.md | 3 +++
 clippy_lints/src/await_holding_invalid.rs               | 2 +-
 clippy_lints/src/casts/mod.rs                           | 2 +-
 clippy_lints/src/crate_in_macro_def.rs                  | 2 +-
 clippy_lints/src/drop_forget_ref.rs                     | 4 ++--
 clippy_lints/src/empty_drop.rs                          | 2 +-
 clippy_lints/src/methods/mod.rs                         | 6 +++---
 7 files changed, 12 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/book/src/development/infrastructure/changelog_update.md b/book/src/development/infrastructure/changelog_update.md
index e560f4c6a3e..80a47affe30 100644
--- a/book/src/development/infrastructure/changelog_update.md
+++ b/book/src/development/infrastructure/changelog_update.md
@@ -95,6 +95,9 @@ As section headers, we use:
 Please also be sure to update the Beta/Unreleased sections at the top with the
 relevant commit ranges.
 
+If you have the time, it would be appreciated if you double-check, that the
+`#[clippy::version]` attributes for the added lints contains the correct version.
+
 [changelog]: https://github.com/rust-lang/rust-clippy/blob/master/CHANGELOG.md
 [forge]: https://forge.rust-lang.org/
 [rust_master_tools]: https://github.com/rust-lang/rust/tree/master/src/tools/clippy
diff --git a/clippy_lints/src/await_holding_invalid.rs b/clippy_lints/src/await_holding_invalid.rs
index eee5f90d178..1761360fb28 100644
--- a/clippy_lints/src/await_holding_invalid.rs
+++ b/clippy_lints/src/await_holding_invalid.rs
@@ -161,7 +161,7 @@ declare_clippy_lint! {
     ///   baz().await; // Lint violation
     /// }
     /// ```
-    #[clippy::version = "1.49.0"]
+    #[clippy::version = "1.62.0"]
     pub AWAIT_HOLDING_INVALID_TYPE,
     suspicious,
     "holding a type across an await point which is not allowed to be held as per the configuration"
diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index 02c2f30a4dd..af3798a0cc8 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -500,7 +500,7 @@ declare_clippy_lint! {
     /// let x: i32 = -42;
     /// let y: u32 = x.unsigned_abs();
     /// ```
-    #[clippy::version = "1.61.0"]
+    #[clippy::version = "1.62.0"]
     pub CAST_ABS_TO_UNSIGNED,
     suspicious,
     "casting the result of `abs()` to an unsigned integer can panic"
diff --git a/clippy_lints/src/crate_in_macro_def.rs b/clippy_lints/src/crate_in_macro_def.rs
index 9b8a481b6ea..f6ec8fe7edc 100644
--- a/clippy_lints/src/crate_in_macro_def.rs
+++ b/clippy_lints/src/crate_in_macro_def.rs
@@ -43,7 +43,7 @@ declare_clippy_lint! {
     /// #[allow(clippy::crate_in_macro_def)]
     /// macro_rules! ok { ... crate::foo ... }
     /// ```
-    #[clippy::version = "1.61.0"]
+    #[clippy::version = "1.62.0"]
     pub CRATE_IN_MACRO_DEF,
     suspicious,
     "using `crate` in a macro definition"
diff --git a/clippy_lints/src/drop_forget_ref.rs b/clippy_lints/src/drop_forget_ref.rs
index 25014bfa1a5..b35f0b8ca52 100644
--- a/clippy_lints/src/drop_forget_ref.rs
+++ b/clippy_lints/src/drop_forget_ref.rs
@@ -116,7 +116,7 @@ declare_clippy_lint! {
     /// let x = Foo;
     /// std::mem::drop(x);
     /// ```
-    #[clippy::version = "1.61.0"]
+    #[clippy::version = "1.62.0"]
     pub DROP_NON_DROP,
     suspicious,
     "call to `std::mem::drop` with a value which does not implement `Drop`"
@@ -136,7 +136,7 @@ declare_clippy_lint! {
     /// let x = Foo;
     /// std::mem::forget(x);
     /// ```
-    #[clippy::version = "1.61.0"]
+    #[clippy::version = "1.62.0"]
     pub FORGET_NON_DROP,
     suspicious,
     "call to `std::mem::forget` with a value which does not implement `Drop`"
diff --git a/clippy_lints/src/empty_drop.rs b/clippy_lints/src/empty_drop.rs
index 325ae2356c1..ec063c0f777 100644
--- a/clippy_lints/src/empty_drop.rs
+++ b/clippy_lints/src/empty_drop.rs
@@ -26,7 +26,7 @@ declare_clippy_lint! {
     /// ```rust
     /// struct S;
     /// ```
-    #[clippy::version = "1.61.0"]
+    #[clippy::version = "1.62.0"]
     pub EMPTY_DROP,
     restriction,
     "empty `Drop` implementations"
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index cc1530f0ed0..e8a239ecc7a 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -369,7 +369,7 @@ declare_clippy_lint! {
     /// let x: Result<u32, &str> = Ok(10);
     /// x.expect_err("Testing expect_err");
     /// ```
-    #[clippy::version = "1.61.0"]
+    #[clippy::version = "1.62.0"]
     pub ERR_EXPECT,
     style,
     r#"using `.err().expect("")` when `.expect_err("")` can be used"#
@@ -2215,7 +2215,7 @@ declare_clippy_lint! {
     /// c.is_ascii_digit();
     /// c.is_ascii_hexdigit();
     /// ```
-    #[clippy::version = "1.61.0"]
+    #[clippy::version = "1.62.0"]
     pub IS_DIGIT_ASCII_RADIX,
     style,
     "use of `char::is_digit(..)` with literal radix of 10 or 16"
@@ -2235,7 +2235,7 @@ declare_clippy_lint! {
     /// let x = Some(3);
     /// x.as_ref();
     /// ```
-    #[clippy::version = "1.61.0"]
+    #[clippy::version = "1.62.0"]
     pub NEEDLESS_OPTION_TAKE,
     complexity,
     "using `.as_ref().take()` on a temporary value"
-- 
cgit 1.4.1-3-g733a5


From de646e10db2141fc9fffddf103611fe7d1fd9d68 Mon Sep 17 00:00:00 2001
From: Serial <69764315+Serial-ATA@users.noreply.github.com>
Date: Sat, 2 Jul 2022 22:24:26 -0400
Subject: Add `invalid_utf8_in_unchecked`

---
 CHANGELOG.md                                  |  1 +
 clippy_lints/src/invalid_utf8_in_unchecked.rs | 74 +++++++++++++++++++++++++++
 clippy_lints/src/lib.register_all.rs          |  1 +
 clippy_lints/src/lib.register_correctness.rs  |  1 +
 clippy_lints/src/lib.register_lints.rs        |  1 +
 clippy_lints/src/lib.rs                       |  2 +
 clippy_utils/src/paths.rs                     |  1 +
 tests/ui/invalid_utf8_in_unchecked.rs         | 20 ++++++++
 tests/ui/invalid_utf8_in_unchecked.stderr     | 22 ++++++++
 9 files changed, 123 insertions(+)
 create mode 100644 clippy_lints/src/invalid_utf8_in_unchecked.rs
 create mode 100644 tests/ui/invalid_utf8_in_unchecked.rs
 create mode 100644 tests/ui/invalid_utf8_in_unchecked.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 71e498c301b..1b792736a6a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3641,6 +3641,7 @@ Released 2018-09-13
 [`invalid_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#invalid_ref
 [`invalid_regex`]: https://rust-lang.github.io/rust-clippy/master/index.html#invalid_regex
 [`invalid_upcast_comparisons`]: https://rust-lang.github.io/rust-clippy/master/index.html#invalid_upcast_comparisons
+[`invalid_utf8_in_unchecked`]: https://rust-lang.github.io/rust-clippy/master/index.html#invalid_utf8_in_unchecked
 [`invisible_characters`]: https://rust-lang.github.io/rust-clippy/master/index.html#invisible_characters
 [`is_digit_ascii_radix`]: https://rust-lang.github.io/rust-clippy/master/index.html#is_digit_ascii_radix
 [`items_after_statements`]: https://rust-lang.github.io/rust-clippy/master/index.html#items_after_statements
diff --git a/clippy_lints/src/invalid_utf8_in_unchecked.rs b/clippy_lints/src/invalid_utf8_in_unchecked.rs
new file mode 100644
index 00000000000..e0a607f9a95
--- /dev/null
+++ b/clippy_lints/src/invalid_utf8_in_unchecked.rs
@@ -0,0 +1,74 @@
+use clippy_utils::diagnostics::span_lint;
+use clippy_utils::{match_function_call, paths};
+use rustc_ast::{BorrowKind, LitKind};
+use rustc_hir::{Expr, ExprKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::source_map::Spanned;
+use rustc_span::Span;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `std::str::from_utf8_unchecked` with an invalid UTF-8 literal
+    ///
+    /// ### Why is this bad?
+    /// Creating such a `str` would result in undefined behavior
+    ///
+    /// ### Example
+    /// ```rust
+    /// # #[allow(unused)]
+    /// unsafe {
+    ///     std::str::from_utf8_unchecked(b"cl\x82ippy");
+    /// }
+    /// ```
+    #[clippy::version = "1.64.0"]
+    pub INVALID_UTF8_IN_UNCHECKED,
+    correctness,
+    "using a non UTF-8 literal in `std::std::from_utf8_unchecked`"
+}
+declare_lint_pass!(InvalidUtf8InUnchecked => [INVALID_UTF8_IN_UNCHECKED]);
+
+impl<'tcx> LateLintPass<'tcx> for InvalidUtf8InUnchecked {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
+        if let Some([arg]) = match_function_call(cx, expr, &paths::STR_FROM_UTF8_UNCHECKED) {
+            match &arg.kind {
+                ExprKind::Lit(Spanned { node: lit, .. }) => {
+                    if let LitKind::ByteStr(bytes) = &lit
+                        && std::str::from_utf8(bytes).is_err()
+                    {
+                        lint(cx, expr.span);
+                    }
+                },
+                ExprKind::AddrOf(BorrowKind::Ref, _, Expr { kind: ExprKind::Array(args), .. }) => {
+                    let elements = args.iter().map(|e|{
+                        match &e.kind {
+                            ExprKind::Lit(Spanned { node: lit, .. }) => match lit {
+                                LitKind::Byte(b) => Some(*b),
+                                #[allow(clippy::cast_possible_truncation)]
+                                LitKind::Int(b, _) => Some(*b as u8),
+                                _ => None
+                            }
+                            _ => None
+                        }
+                    }).collect::<Option<Vec<_>>>();
+
+                    if let Some(elements) = elements
+                        && std::str::from_utf8(&elements).is_err()
+                    {
+                        lint(cx, expr.span);
+                    }
+                }
+                _ => {}
+            }
+        }
+    }
+}
+
+fn lint(cx: &LateContext<'_>, span: Span) {
+    span_lint(
+        cx,
+        INVALID_UTF8_IN_UNCHECKED,
+        span,
+        "non UTF-8 literal in `std::str::from_utf8_unchecked`",
+    );
+}
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 563ad891603..da26a3f0130 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -92,6 +92,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(init_numbered_fields::INIT_NUMBERED_FIELDS),
     LintId::of(inline_fn_without_body::INLINE_FN_WITHOUT_BODY),
     LintId::of(int_plus_one::INT_PLUS_ONE),
+    LintId::of(invalid_utf8_in_unchecked::INVALID_UTF8_IN_UNCHECKED),
     LintId::of(large_const_arrays::LARGE_CONST_ARRAYS),
     LintId::of(large_enum_variant::LARGE_ENUM_VARIANT),
     LintId::of(len_zero::COMPARISON_TO_EMPTY),
diff --git a/clippy_lints/src/lib.register_correctness.rs b/clippy_lints/src/lib.register_correctness.rs
index 7d5e65cb27a..9975859c54f 100644
--- a/clippy_lints/src/lib.register_correctness.rs
+++ b/clippy_lints/src/lib.register_correctness.rs
@@ -29,6 +29,7 @@ store.register_group(true, "clippy::correctness", Some("clippy_correctness"), ve
     LintId::of(infinite_iter::INFINITE_ITER),
     LintId::of(inherent_to_string::INHERENT_TO_STRING_SHADOW_DISPLAY),
     LintId::of(inline_fn_without_body::INLINE_FN_WITHOUT_BODY),
+    LintId::of(invalid_utf8_in_unchecked::INVALID_UTF8_IN_UNCHECKED),
     LintId::of(let_underscore::LET_UNDERSCORE_LOCK),
     LintId::of(literal_representation::MISTYPED_LITERAL_SUFFIXES),
     LintId::of(loops::ITER_NEXT_LOOP),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index d3c75f8b519..ceb8470657f 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -196,6 +196,7 @@ store.register_lints(&[
     inline_fn_without_body::INLINE_FN_WITHOUT_BODY,
     int_plus_one::INT_PLUS_ONE,
     invalid_upcast_comparisons::INVALID_UPCAST_COMPARISONS,
+    invalid_utf8_in_unchecked::INVALID_UTF8_IN_UNCHECKED,
     items_after_statements::ITEMS_AFTER_STATEMENTS,
     iter_not_returning_iterator::ITER_NOT_RETURNING_ITERATOR,
     large_const_arrays::LARGE_CONST_ARRAYS,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 172fdf8c852..1604d1078ee 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -255,6 +255,7 @@ mod init_numbered_fields;
 mod inline_fn_without_body;
 mod int_plus_one;
 mod invalid_upcast_comparisons;
+mod invalid_utf8_in_unchecked;
 mod items_after_statements;
 mod iter_not_returning_iterator;
 mod large_const_arrays;
@@ -913,6 +914,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(move || Box::new(manual_retain::ManualRetain::new(msrv)));
     let verbose_bit_mask_threshold = conf.verbose_bit_mask_threshold;
     store.register_late_pass(move || Box::new(operators::Operators::new(verbose_bit_mask_threshold)));
+    store.register_late_pass(|| Box::new(invalid_utf8_in_unchecked::InvalidUtf8InUnchecked));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index 6542e77113b..05429d05d9e 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -163,6 +163,7 @@ pub const STR_BYTES: [&str; 4] = ["core", "str", "<impl str>", "bytes"];
 pub const STR_CHARS: [&str; 4] = ["core", "str", "<impl str>", "chars"];
 pub const STR_ENDS_WITH: [&str; 4] = ["core", "str", "<impl str>", "ends_with"];
 pub const STR_FROM_UTF8: [&str; 4] = ["core", "str", "converts", "from_utf8"];
+pub const STR_FROM_UTF8_UNCHECKED: [&str; 4] = ["core", "str", "converts", "from_utf8_unchecked"];
 pub const STR_LEN: [&str; 4] = ["core", "str", "<impl str>", "len"];
 pub const STR_STARTS_WITH: [&str; 4] = ["core", "str", "<impl str>", "starts_with"];
 #[cfg(feature = "internal")]
diff --git a/tests/ui/invalid_utf8_in_unchecked.rs b/tests/ui/invalid_utf8_in_unchecked.rs
new file mode 100644
index 00000000000..3dc096d3197
--- /dev/null
+++ b/tests/ui/invalid_utf8_in_unchecked.rs
@@ -0,0 +1,20 @@
+#![warn(clippy::invalid_utf8_in_unchecked)]
+
+fn main() {
+    // Valid
+    unsafe {
+        std::str::from_utf8_unchecked(&[99, 108, 105, 112, 112, 121]);
+        std::str::from_utf8_unchecked(&[b'c', b'l', b'i', b'p', b'p', b'y']);
+        std::str::from_utf8_unchecked(b"clippy");
+
+        let x = 0xA0;
+        std::str::from_utf8_unchecked(&[0xC0, x]);
+    }
+
+    // Invalid
+    unsafe {
+        std::str::from_utf8_unchecked(&[99, 108, 130, 105, 112, 112, 121]);
+        std::str::from_utf8_unchecked(&[b'c', b'l', b'\x82', b'i', b'p', b'p', b'y']);
+        std::str::from_utf8_unchecked(b"cl\x82ippy");
+    }
+}
diff --git a/tests/ui/invalid_utf8_in_unchecked.stderr b/tests/ui/invalid_utf8_in_unchecked.stderr
new file mode 100644
index 00000000000..c89cd2758ee
--- /dev/null
+++ b/tests/ui/invalid_utf8_in_unchecked.stderr
@@ -0,0 +1,22 @@
+error: non UTF-8 literal in `std::str::from_utf8_unchecked`
+  --> $DIR/invalid_utf8_in_unchecked.rs:16:9
+   |
+LL |         std::str::from_utf8_unchecked(&[99, 108, 130, 105, 112, 112, 121]);
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::invalid-utf8-in-unchecked` implied by `-D warnings`
+
+error: non UTF-8 literal in `std::str::from_utf8_unchecked`
+  --> $DIR/invalid_utf8_in_unchecked.rs:17:9
+   |
+LL |         std::str::from_utf8_unchecked(&[b'c', b'l', b'/x82', b'i', b'p', b'p', b'y']);
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: non UTF-8 literal in `std::str::from_utf8_unchecked`
+  --> $DIR/invalid_utf8_in_unchecked.rs:18:9
+   |
+LL |         std::str::from_utf8_unchecked(b"cl/x82ippy");
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 3 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From fec45930823c77acd91bfeec153b323bacfab099 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Mon, 4 Jul 2022 14:03:11 +0000
Subject: new_without_default: ignore const generics/lifetime params on fn new

---
 clippy_lints/src/new_without_default.rs | 12 +++---------
 tests/ui/new_without_default.rs         | 14 ++++++++++++++
 2 files changed, 17 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/new_without_default.rs b/clippy_lints/src/new_without_default.rs
index 093ec389335..5c45ee6d94a 100644
--- a/clippy_lints/src/new_without_default.rs
+++ b/clippy_lints/src/new_without_default.rs
@@ -88,15 +88,9 @@ impl<'tcx> LateLintPass<'tcx> for NewWithoutDefault {
                             // shouldn't be implemented when it is hidden in docs
                             return;
                         }
-                        if impl_item
-                            .generics
-                            .params
-                            .iter()
-                            .any(|gen| matches!(gen.kind, hir::GenericParamKind::Type { .. }))
-                        {
-                            // when the result of `new()` depends on a type parameter we should not require
-                            // an
-                            // impl of `Default`
+                        if !impl_item.generics.params.is_empty() {
+                            // when the result of `new()` depends on a parameter we should not require
+                            // an impl of `Default`
                             return;
                         }
                         if_chain! {
diff --git a/tests/ui/new_without_default.rs b/tests/ui/new_without_default.rs
index 538927b1805..65809023f8d 100644
--- a/tests/ui/new_without_default.rs
+++ b/tests/ui/new_without_default.rs
@@ -212,3 +212,17 @@ impl DocHidden {
 }
 
 fn main() {}
+
+pub struct IgnoreConstGenericNew(usize);
+impl IgnoreConstGenericNew {
+    pub fn new<const N: usize>() -> Self {
+        Self(N)
+    }
+}
+
+pub struct IgnoreLifetimeNew;
+impl IgnoreLifetimeNew {
+    pub fn new<'a>() -> Self {
+        Self
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 975667945c5be3ab84a0f7fd5bd6715168285a95 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Mon, 4 Jul 2022 13:53:42 -0400
Subject: Fix `undocumented_unsafe_blocks` in closures

---
 clippy_lints/src/undocumented_unsafe_blocks.rs | 18 +++++++-
 tests/ui/undocumented_unsafe_blocks.rs         |  9 +++-
 tests/ui/undocumented_unsafe_blocks.stderr     | 62 +++++++++++++-------------
 3 files changed, 54 insertions(+), 35 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/undocumented_unsafe_blocks.rs b/clippy_lints/src/undocumented_unsafe_blocks.rs
index 025dd57e83a..04f16fd2161 100644
--- a/clippy_lints/src/undocumented_unsafe_blocks.rs
+++ b/clippy_lints/src/undocumented_unsafe_blocks.rs
@@ -265,14 +265,28 @@ fn span_from_macro_expansion_has_safety_comment(cx: &LateContext<'_>, span: Span
     }
 }
 
+fn get_body_search_span(cx: &LateContext<'_>) -> Option<Span> {
+    let body = cx.enclosing_body?;
+    let map = cx.tcx.hir();
+    let mut span = map.body(body).value.span;
+    for (_, node) in map.parent_iter(body.hir_id) {
+        match node {
+            Node::Expr(e) => span = e.span,
+            Node::Block(_) | Node::Arm(_) | Node::Stmt(_) | Node::Local(_) => (),
+            _ => break,
+        }
+    }
+    Some(span)
+}
+
 fn span_in_body_has_safety_comment(cx: &LateContext<'_>, span: Span) -> bool {
     let source_map = cx.sess().source_map();
     let ctxt = span.ctxt();
     if ctxt == SyntaxContext::root()
-        && let Some(body) = cx.enclosing_body
+        && let Some(search_span) = get_body_search_span(cx)
     {
         if let Ok(unsafe_line) = source_map.lookup_line(span.lo())
-            && let Some(body_span) = walk_span_to_context(cx.tcx.hir().body(body).value.span, SyntaxContext::root())
+            && let Some(body_span) = walk_span_to_context(search_span, SyntaxContext::root())
             && let Ok(body_line) = source_map.lookup_line(body_span.lo())
             && Lrc::ptr_eq(&unsafe_line.sf, &body_line.sf)
             && let Some(src) = unsafe_line.sf.src.as_deref()
diff --git a/tests/ui/undocumented_unsafe_blocks.rs b/tests/ui/undocumented_unsafe_blocks.rs
index 33b6a82f9d2..08aee433215 100644
--- a/tests/ui/undocumented_unsafe_blocks.rs
+++ b/tests/ui/undocumented_unsafe_blocks.rs
@@ -250,6 +250,11 @@ fn from_proc_macro() {
     proc_macro_unsafe::unsafe_block!(token);
 }
 
+fn in_closure(x: *const u32) {
+    // Safety: reason
+    let _ = || unsafe { *x };
+}
+
 // Invalid comments
 
 #[rustfmt::skip]
@@ -351,9 +356,9 @@ mod unsafe_impl_smoke_test {
 
     #[rustfmt::skip]
     mod sub_mod2 {
-        // 
+        //
         // SAFETY: ok
-        // 
+        //
 
         unsafe impl B for (u32) {}
         unsafe trait B {}
diff --git a/tests/ui/undocumented_unsafe_blocks.stderr b/tests/ui/undocumented_unsafe_blocks.stderr
index b79949e9d06..c6a2127443b 100644
--- a/tests/ui/undocumented_unsafe_blocks.stderr
+++ b/tests/ui/undocumented_unsafe_blocks.stderr
@@ -1,5 +1,5 @@
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:257:19
+  --> $DIR/undocumented_unsafe_blocks.rs:262:19
    |
 LL |     /* Safety: */ unsafe {}
    |                   ^^^^^^^^^
@@ -8,7 +8,7 @@ LL |     /* Safety: */ unsafe {}
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:261:5
+  --> $DIR/undocumented_unsafe_blocks.rs:266:5
    |
 LL |     unsafe {}
    |     ^^^^^^^^^
@@ -16,7 +16,7 @@ LL |     unsafe {}
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:265:14
+  --> $DIR/undocumented_unsafe_blocks.rs:270:14
    |
 LL |     let _ = [unsafe { 14 }, unsafe { 15 }, 42, unsafe { 16 }];
    |              ^^^^^^^^^^^^^
@@ -24,7 +24,7 @@ LL |     let _ = [unsafe { 14 }, unsafe { 15 }, 42, unsafe { 16 }];
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:265:29
+  --> $DIR/undocumented_unsafe_blocks.rs:270:29
    |
 LL |     let _ = [unsafe { 14 }, unsafe { 15 }, 42, unsafe { 16 }];
    |                             ^^^^^^^^^^^^^
@@ -32,7 +32,7 @@ LL |     let _ = [unsafe { 14 }, unsafe { 15 }, 42, unsafe { 16 }];
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:265:48
+  --> $DIR/undocumented_unsafe_blocks.rs:270:48
    |
 LL |     let _ = [unsafe { 14 }, unsafe { 15 }, 42, unsafe { 16 }];
    |                                                ^^^^^^^^^^^^^
@@ -40,7 +40,7 @@ LL |     let _ = [unsafe { 14 }, unsafe { 15 }, 42, unsafe { 16 }];
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:269:18
+  --> $DIR/undocumented_unsafe_blocks.rs:274:18
    |
 LL |     let _ = (42, unsafe {}, "test", unsafe {});
    |                  ^^^^^^^^^
@@ -48,7 +48,7 @@ LL |     let _ = (42, unsafe {}, "test", unsafe {});
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:269:37
+  --> $DIR/undocumented_unsafe_blocks.rs:274:37
    |
 LL |     let _ = (42, unsafe {}, "test", unsafe {});
    |                                     ^^^^^^^^^
@@ -56,7 +56,7 @@ LL |     let _ = (42, unsafe {}, "test", unsafe {});
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:273:14
+  --> $DIR/undocumented_unsafe_blocks.rs:278:14
    |
 LL |     let _ = *unsafe { &42 };
    |              ^^^^^^^^^^^^^^
@@ -64,7 +64,7 @@ LL |     let _ = *unsafe { &42 };
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:278:19
+  --> $DIR/undocumented_unsafe_blocks.rs:283:19
    |
 LL |     let _ = match unsafe {} {
    |                   ^^^^^^^^^
@@ -72,7 +72,7 @@ LL |     let _ = match unsafe {} {
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:284:14
+  --> $DIR/undocumented_unsafe_blocks.rs:289:14
    |
 LL |     let _ = &unsafe {};
    |              ^^^^^^^^^
@@ -80,7 +80,7 @@ LL |     let _ = &unsafe {};
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:288:14
+  --> $DIR/undocumented_unsafe_blocks.rs:293:14
    |
 LL |     let _ = [unsafe {}; 5];
    |              ^^^^^^^^^
@@ -88,7 +88,7 @@ LL |     let _ = [unsafe {}; 5];
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:292:13
+  --> $DIR/undocumented_unsafe_blocks.rs:297:13
    |
 LL |     let _ = unsafe {};
    |             ^^^^^^^^^
@@ -96,7 +96,7 @@ LL |     let _ = unsafe {};
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:302:8
+  --> $DIR/undocumented_unsafe_blocks.rs:307:8
    |
 LL |     t!(unsafe {});
    |        ^^^^^^^^^
@@ -104,7 +104,7 @@ LL |     t!(unsafe {});
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:308:13
+  --> $DIR/undocumented_unsafe_blocks.rs:313:13
    |
 LL |             unsafe {}
    |             ^^^^^^^^^
@@ -116,7 +116,7 @@ LL |     t!();
    = note: this error originates in the macro `t` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:316:5
+  --> $DIR/undocumented_unsafe_blocks.rs:321:5
    |
 LL |     unsafe {} // SAFETY:
    |     ^^^^^^^^^
@@ -124,7 +124,7 @@ LL |     unsafe {} // SAFETY:
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:320:5
+  --> $DIR/undocumented_unsafe_blocks.rs:325:5
    |
 LL |     unsafe {
    |     ^^^^^^^^
@@ -132,7 +132,7 @@ LL |     unsafe {
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:330:5
+  --> $DIR/undocumented_unsafe_blocks.rs:335:5
    |
 LL |     unsafe {};
    |     ^^^^^^^^^
@@ -140,7 +140,7 @@ LL |     unsafe {};
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:334:20
+  --> $DIR/undocumented_unsafe_blocks.rs:339:20
    |
 LL |     println!("{}", unsafe { String::from_utf8_unchecked(vec![]) });
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -148,7 +148,7 @@ LL |     println!("{}", unsafe { String::from_utf8_unchecked(vec![]) });
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe impl missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:341:5
+  --> $DIR/undocumented_unsafe_blocks.rs:346:5
    |
 LL |     unsafe impl A for () {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^
@@ -156,7 +156,7 @@ LL |     unsafe impl A for () {}
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe impl missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:348:9
+  --> $DIR/undocumented_unsafe_blocks.rs:353:9
    |
 LL |         unsafe impl B for (u32) {}
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -164,7 +164,7 @@ LL |         unsafe impl B for (u32) {}
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe impl missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:369:13
+  --> $DIR/undocumented_unsafe_blocks.rs:374:13
    |
 LL |             unsafe impl T for $t {}
    |             ^^^^^^^^^^^^^^^^^^^^^^^
@@ -176,7 +176,7 @@ LL |     no_safety_comment!(());
    = note: this error originates in the macro `no_safety_comment` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: unsafe impl missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:394:13
+  --> $DIR/undocumented_unsafe_blocks.rs:399:13
    |
 LL |             unsafe impl T for $t {}
    |             ^^^^^^^^^^^^^^^^^^^^^^^
@@ -188,7 +188,7 @@ LL |     no_safety_comment!(());
    = note: this error originates in the macro `no_safety_comment` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: unsafe impl missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:402:5
+  --> $DIR/undocumented_unsafe_blocks.rs:407:5
    |
 LL |     unsafe impl T for (i32) {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -196,7 +196,7 @@ LL |     unsafe impl T for (i32) {}
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe impl missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:394:13
+  --> $DIR/undocumented_unsafe_blocks.rs:399:13
    |
 LL |             unsafe impl T for $t {}
    |             ^^^^^^^^^^^^^^^^^^^^^^^
@@ -208,7 +208,7 @@ LL |     no_safety_comment!(u32);
    = note: this error originates in the macro `no_safety_comment` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: unsafe impl missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:408:5
+  --> $DIR/undocumented_unsafe_blocks.rs:413:5
    |
 LL |     unsafe impl T for (bool) {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -216,7 +216,7 @@ LL |     unsafe impl T for (bool) {}
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe impl missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:454:5
+  --> $DIR/undocumented_unsafe_blocks.rs:459:5
    |
 LL |     unsafe impl NoComment for () {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -224,7 +224,7 @@ LL |     unsafe impl NoComment for () {}
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe impl missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:458:19
+  --> $DIR/undocumented_unsafe_blocks.rs:463:19
    |
 LL |     /* SAFETY: */ unsafe impl InlineComment for () {}
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -232,7 +232,7 @@ LL |     /* SAFETY: */ unsafe impl InlineComment for () {}
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe impl missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:462:5
+  --> $DIR/undocumented_unsafe_blocks.rs:467:5
    |
 LL |     unsafe impl TrailingComment for () {} // SAFETY:
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -240,7 +240,7 @@ LL |     unsafe impl TrailingComment for () {} // SAFETY:
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe impl missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:467:5
+  --> $DIR/undocumented_unsafe_blocks.rs:472:5
    |
 LL |     unsafe impl Interference for () {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -248,7 +248,7 @@ LL |     unsafe impl Interference for () {}
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe impl missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:474:5
+  --> $DIR/undocumented_unsafe_blocks.rs:479:5
    |
 LL |     unsafe impl ImplInFn for () {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -256,7 +256,7 @@ LL |     unsafe impl ImplInFn for () {}
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe impl missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:483:1
+  --> $DIR/undocumented_unsafe_blocks.rs:488:1
    |
 LL | unsafe impl CrateRoot for () {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From 3db0e00bdc1ebd35aa9f28b83c3ed4de7ba78a25 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Tue, 5 Jul 2022 15:21:27 -0400
Subject: Lint `shadow_*` lints in anon const blocks

---
 clippy_lints/src/shadow.rs | 14 ++++++--------
 tests/ui/shadow.stderr     | 14 +++++++++++++-
 2 files changed, 19 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/shadow.rs b/clippy_lints/src/shadow.rs
index bf318c055da..5dcdab5b8ab 100644
--- a/clippy_lints/src/shadow.rs
+++ b/clippy_lints/src/shadow.rs
@@ -99,7 +99,7 @@ declare_clippy_lint! {
 
 #[derive(Default)]
 pub(crate) struct Shadow {
-    bindings: Vec<FxHashMap<Symbol, Vec<ItemLocalId>>>,
+    bindings: Vec<(FxHashMap<Symbol, Vec<ItemLocalId>>, LocalDefId)>,
 }
 
 impl_lint_pass!(Shadow => [SHADOW_SAME, SHADOW_REUSE, SHADOW_UNRELATED]);
@@ -121,7 +121,7 @@ impl<'tcx> LateLintPass<'tcx> for Shadow {
 
         let HirId { owner, local_id } = id;
         // get (or insert) the list of items for this owner and symbol
-        let data = self.bindings.last_mut().unwrap();
+        let (ref mut data, scope_owner) = *self.bindings.last_mut().unwrap();
         let items_with_name = data.entry(ident.name).or_default();
 
         // check other bindings with the same name, most recently seen first
@@ -131,7 +131,7 @@ impl<'tcx> LateLintPass<'tcx> for Shadow {
                 return;
             }
 
-            if is_shadow(cx, owner, prev, local_id) {
+            if is_shadow(cx, scope_owner, prev, local_id) {
                 let prev_hir_id = HirId { owner, local_id: prev };
                 lint_shadow(cx, pat, prev_hir_id, ident.span);
                 // only lint against the "nearest" shadowed binding
@@ -144,11 +144,9 @@ impl<'tcx> LateLintPass<'tcx> for Shadow {
 
     fn check_body(&mut self, cx: &LateContext<'_>, body: &Body<'_>) {
         let hir = cx.tcx.hir();
-        if !matches!(
-            hir.body_owner_kind(hir.body_owner_def_id(body.id())),
-            BodyOwnerKind::Closure
-        ) {
-            self.bindings.push(FxHashMap::default());
+        let owner_id = hir.body_owner_def_id(body.id());
+        if !matches!(hir.body_owner_kind(owner_id), BodyOwnerKind::Closure) {
+            self.bindings.push((FxHashMap::default(), owner_id));
         }
     }
 
diff --git a/tests/ui/shadow.stderr b/tests/ui/shadow.stderr
index 3bd41d06260..43d76094d0e 100644
--- a/tests/ui/shadow.stderr
+++ b/tests/ui/shadow.stderr
@@ -265,5 +265,17 @@ note: previous binding is here
 LL | pub async fn foo2(_a: i32, _b: i64) {
    |                            ^^
 
-error: aborting due to 22 previous errors
+error: `x` shadows a previous, unrelated binding
+  --> $DIR/shadow.rs:94:21
+   |
+LL |         if let Some(x) = Some(1) { x } else { 1 }
+   |                     ^
+   |
+note: previous binding is here
+  --> $DIR/shadow.rs:93:13
+   |
+LL |         let x = 1;
+   |             ^
+
+error: aborting due to 23 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 528308b5aa544454e6c90f6d051c3adeb1a46e1b Mon Sep 17 00:00:00 2001
From: Josh Triplett <josh@joshtriplett.org>
Date: Sat, 2 Jul 2022 15:00:24 -0700
Subject: Extend unnecessary_lazy_eval to cover `bool::then` ->
 `bool::then_some`

---
 clippy_lints/src/methods/mod.rs                   |  1 +
 clippy_lints/src/methods/unnecessary_lazy_eval.rs |  7 ++-
 tests/ui/unnecessary_lazy_eval.fixed              |  2 +
 tests/ui/unnecessary_lazy_eval.rs                 |  2 +
 tests/ui/unnecessary_lazy_eval.stderr             | 76 +++++++++++++----------
 5 files changed, 52 insertions(+), 36 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index cc1530f0ed0..36389d798ed 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -2737,6 +2737,7 @@ impl Methods {
                     }
                 },
                 ("take", []) => needless_option_take::check(cx, expr, recv),
+                ("then", [arg]) => unnecessary_lazy_eval::check(cx, expr, recv, arg, "then_some"),
                 ("to_os_string" | "to_owned" | "to_path_buf" | "to_vec", []) => {
                     implicit_clone::check(cx, name, expr, recv);
                 },
diff --git a/clippy_lints/src/methods/unnecessary_lazy_eval.rs b/clippy_lints/src/methods/unnecessary_lazy_eval.rs
index 865f6d0318e..a9c641b4606 100644
--- a/clippy_lints/src/methods/unnecessary_lazy_eval.rs
+++ b/clippy_lints/src/methods/unnecessary_lazy_eval.rs
@@ -20,8 +20,9 @@ pub(super) fn check<'tcx>(
 ) {
     let is_option = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(recv), sym::Option);
     let is_result = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(recv), sym::Result);
+    let is_bool = cx.typeck_results().expr_ty(recv).is_bool();
 
-    if is_option || is_result {
+    if is_option || is_result || is_bool {
         if let hir::ExprKind::Closure { body, .. } = arg.kind {
             let body = cx.tcx.hir().body(body);
             let body_expr = &body.value;
@@ -33,8 +34,10 @@ pub(super) fn check<'tcx>(
             if eager_or_lazy::switch_to_eager_eval(cx, body_expr) {
                 let msg = if is_option {
                     "unnecessary closure used to substitute value for `Option::None`"
-                } else {
+                } else if is_result {
                     "unnecessary closure used to substitute value for `Result::Err`"
+                } else {
+                    "unnecessary closure used with `bool::then`"
                 };
                 let applicability = if body
                     .params
diff --git a/tests/ui/unnecessary_lazy_eval.fixed b/tests/ui/unnecessary_lazy_eval.fixed
index 65fcdc43061..eed81796883 100644
--- a/tests/ui/unnecessary_lazy_eval.fixed
+++ b/tests/ui/unnecessary_lazy_eval.fixed
@@ -30,6 +30,7 @@ fn main() {
     let ext_opt = Some(42);
     let nested_opt = Some(Some(42));
     let nested_tuple_opt = Some(Some((42, 43)));
+    let cond = true;
 
     // Should lint - Option
     let _ = opt.unwrap_or(2);
@@ -42,6 +43,7 @@ fn main() {
     let _ = opt.get_or_insert(2);
     let _ = opt.ok_or(2);
     let _ = nested_tuple_opt.unwrap_or(Some((1, 2)));
+    let _ = cond.then_some(astronomers_pi);
 
     // Cases when unwrap is not called on a simple variable
     let _ = Some(10).unwrap_or(2);
diff --git a/tests/ui/unnecessary_lazy_eval.rs b/tests/ui/unnecessary_lazy_eval.rs
index 206080ed69a..1588db79b38 100644
--- a/tests/ui/unnecessary_lazy_eval.rs
+++ b/tests/ui/unnecessary_lazy_eval.rs
@@ -30,6 +30,7 @@ fn main() {
     let ext_opt = Some(42);
     let nested_opt = Some(Some(42));
     let nested_tuple_opt = Some(Some((42, 43)));
+    let cond = true;
 
     // Should lint - Option
     let _ = opt.unwrap_or_else(|| 2);
@@ -42,6 +43,7 @@ fn main() {
     let _ = opt.get_or_insert_with(|| 2);
     let _ = opt.ok_or_else(|| 2);
     let _ = nested_tuple_opt.unwrap_or_else(|| Some((1, 2)));
+    let _ = cond.then(|| astronomers_pi);
 
     // Cases when unwrap is not called on a simple variable
     let _ = Some(10).unwrap_or_else(|| 2);
diff --git a/tests/ui/unnecessary_lazy_eval.stderr b/tests/ui/unnecessary_lazy_eval.stderr
index 7e4dd7730e7..83dc7fd832c 100644
--- a/tests/ui/unnecessary_lazy_eval.stderr
+++ b/tests/ui/unnecessary_lazy_eval.stderr
@@ -1,5 +1,5 @@
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:35:13
+  --> $DIR/unnecessary_lazy_eval.rs:36:13
    |
 LL |     let _ = opt.unwrap_or_else(|| 2);
    |             ^^^^--------------------
@@ -9,7 +9,7 @@ LL |     let _ = opt.unwrap_or_else(|| 2);
    = note: `-D clippy::unnecessary-lazy-evaluations` implied by `-D warnings`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:36:13
+  --> $DIR/unnecessary_lazy_eval.rs:37:13
    |
 LL |     let _ = opt.unwrap_or_else(|| astronomers_pi);
    |             ^^^^---------------------------------
@@ -17,7 +17,7 @@ LL |     let _ = opt.unwrap_or_else(|| astronomers_pi);
    |                 help: use `unwrap_or(..)` instead: `unwrap_or(astronomers_pi)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:37:13
+  --> $DIR/unnecessary_lazy_eval.rs:38:13
    |
 LL |     let _ = opt.unwrap_or_else(|| ext_str.some_field);
    |             ^^^^-------------------------------------
@@ -25,7 +25,7 @@ LL |     let _ = opt.unwrap_or_else(|| ext_str.some_field);
    |                 help: use `unwrap_or(..)` instead: `unwrap_or(ext_str.some_field)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:39:13
+  --> $DIR/unnecessary_lazy_eval.rs:40:13
    |
 LL |     let _ = opt.and_then(|_| ext_opt);
    |             ^^^^---------------------
@@ -33,7 +33,7 @@ LL |     let _ = opt.and_then(|_| ext_opt);
    |                 help: use `and(..)` instead: `and(ext_opt)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:40:13
+  --> $DIR/unnecessary_lazy_eval.rs:41:13
    |
 LL |     let _ = opt.or_else(|| ext_opt);
    |             ^^^^-------------------
@@ -41,7 +41,7 @@ LL |     let _ = opt.or_else(|| ext_opt);
    |                 help: use `or(..)` instead: `or(ext_opt)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:41:13
+  --> $DIR/unnecessary_lazy_eval.rs:42:13
    |
 LL |     let _ = opt.or_else(|| None);
    |             ^^^^----------------
@@ -49,7 +49,7 @@ LL |     let _ = opt.or_else(|| None);
    |                 help: use `or(..)` instead: `or(None)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:42:13
+  --> $DIR/unnecessary_lazy_eval.rs:43:13
    |
 LL |     let _ = opt.get_or_insert_with(|| 2);
    |             ^^^^------------------------
@@ -57,7 +57,7 @@ LL |     let _ = opt.get_or_insert_with(|| 2);
    |                 help: use `get_or_insert(..)` instead: `get_or_insert(2)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:43:13
+  --> $DIR/unnecessary_lazy_eval.rs:44:13
    |
 LL |     let _ = opt.ok_or_else(|| 2);
    |             ^^^^----------------
@@ -65,15 +65,23 @@ LL |     let _ = opt.ok_or_else(|| 2);
    |                 help: use `ok_or(..)` instead: `ok_or(2)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:44:13
+  --> $DIR/unnecessary_lazy_eval.rs:45:13
    |
 LL |     let _ = nested_tuple_opt.unwrap_or_else(|| Some((1, 2)));
    |             ^^^^^^^^^^^^^^^^^-------------------------------
    |                              |
    |                              help: use `unwrap_or(..)` instead: `unwrap_or(Some((1, 2)))`
 
+error: unnecessary closure used with `bool::then`
+  --> $DIR/unnecessary_lazy_eval.rs:46:13
+   |
+LL |     let _ = cond.then(|| astronomers_pi);
+   |             ^^^^^-----------------------
+   |                  |
+   |                  help: use `then_some(..)` instead: `then_some(astronomers_pi)`
+
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:47:13
+  --> $DIR/unnecessary_lazy_eval.rs:49:13
    |
 LL |     let _ = Some(10).unwrap_or_else(|| 2);
    |             ^^^^^^^^^--------------------
@@ -81,7 +89,7 @@ LL |     let _ = Some(10).unwrap_or_else(|| 2);
    |                      help: use `unwrap_or(..)` instead: `unwrap_or(2)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:48:13
+  --> $DIR/unnecessary_lazy_eval.rs:50:13
    |
 LL |     let _ = Some(10).and_then(|_| ext_opt);
    |             ^^^^^^^^^---------------------
@@ -89,7 +97,7 @@ LL |     let _ = Some(10).and_then(|_| ext_opt);
    |                      help: use `and(..)` instead: `and(ext_opt)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:49:28
+  --> $DIR/unnecessary_lazy_eval.rs:51:28
    |
 LL |     let _: Option<usize> = None.or_else(|| ext_opt);
    |                            ^^^^^-------------------
@@ -97,7 +105,7 @@ LL |     let _: Option<usize> = None.or_else(|| ext_opt);
    |                                 help: use `or(..)` instead: `or(ext_opt)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:50:13
+  --> $DIR/unnecessary_lazy_eval.rs:52:13
    |
 LL |     let _ = None.get_or_insert_with(|| 2);
    |             ^^^^^------------------------
@@ -105,7 +113,7 @@ LL |     let _ = None.get_or_insert_with(|| 2);
    |                  help: use `get_or_insert(..)` instead: `get_or_insert(2)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:51:35
+  --> $DIR/unnecessary_lazy_eval.rs:53:35
    |
 LL |     let _: Result<usize, usize> = None.ok_or_else(|| 2);
    |                                   ^^^^^----------------
@@ -113,7 +121,7 @@ LL |     let _: Result<usize, usize> = None.ok_or_else(|| 2);
    |                                        help: use `ok_or(..)` instead: `ok_or(2)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:52:28
+  --> $DIR/unnecessary_lazy_eval.rs:54:28
    |
 LL |     let _: Option<usize> = None.or_else(|| None);
    |                            ^^^^^----------------
@@ -121,7 +129,7 @@ LL |     let _: Option<usize> = None.or_else(|| None);
    |                                 help: use `or(..)` instead: `or(None)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:55:13
+  --> $DIR/unnecessary_lazy_eval.rs:57:13
    |
 LL |     let _ = deep.0.unwrap_or_else(|| 2);
    |             ^^^^^^^--------------------
@@ -129,7 +137,7 @@ LL |     let _ = deep.0.unwrap_or_else(|| 2);
    |                    help: use `unwrap_or(..)` instead: `unwrap_or(2)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:56:13
+  --> $DIR/unnecessary_lazy_eval.rs:58:13
    |
 LL |     let _ = deep.0.and_then(|_| ext_opt);
    |             ^^^^^^^---------------------
@@ -137,7 +145,7 @@ LL |     let _ = deep.0.and_then(|_| ext_opt);
    |                    help: use `and(..)` instead: `and(ext_opt)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:57:13
+  --> $DIR/unnecessary_lazy_eval.rs:59:13
    |
 LL |     let _ = deep.0.or_else(|| None);
    |             ^^^^^^^----------------
@@ -145,7 +153,7 @@ LL |     let _ = deep.0.or_else(|| None);
    |                    help: use `or(..)` instead: `or(None)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:58:13
+  --> $DIR/unnecessary_lazy_eval.rs:60:13
    |
 LL |     let _ = deep.0.get_or_insert_with(|| 2);
    |             ^^^^^^^------------------------
@@ -153,7 +161,7 @@ LL |     let _ = deep.0.get_or_insert_with(|| 2);
    |                    help: use `get_or_insert(..)` instead: `get_or_insert(2)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:59:13
+  --> $DIR/unnecessary_lazy_eval.rs:61:13
    |
 LL |     let _ = deep.0.ok_or_else(|| 2);
    |             ^^^^^^^----------------
@@ -161,7 +169,7 @@ LL |     let _ = deep.0.ok_or_else(|| 2);
    |                    help: use `ok_or(..)` instead: `ok_or(2)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:79:28
+  --> $DIR/unnecessary_lazy_eval.rs:81:28
    |
 LL |     let _: Option<usize> = None.or_else(|| Some(3));
    |                            ^^^^^-------------------
@@ -169,7 +177,7 @@ LL |     let _: Option<usize> = None.or_else(|| Some(3));
    |                                 help: use `or(..)` instead: `or(Some(3))`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:80:13
+  --> $DIR/unnecessary_lazy_eval.rs:82:13
    |
 LL |     let _ = deep.0.or_else(|| Some(3));
    |             ^^^^^^^-------------------
@@ -177,7 +185,7 @@ LL |     let _ = deep.0.or_else(|| Some(3));
    |                    help: use `or(..)` instead: `or(Some(3))`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:81:13
+  --> $DIR/unnecessary_lazy_eval.rs:83:13
    |
 LL |     let _ = opt.or_else(|| Some(3));
    |             ^^^^-------------------
@@ -185,7 +193,7 @@ LL |     let _ = opt.or_else(|| Some(3));
    |                 help: use `or(..)` instead: `or(Some(3))`
 
 error: unnecessary closure used to substitute value for `Result::Err`
-  --> $DIR/unnecessary_lazy_eval.rs:87:13
+  --> $DIR/unnecessary_lazy_eval.rs:89:13
    |
 LL |     let _ = res2.unwrap_or_else(|_| 2);
    |             ^^^^^---------------------
@@ -193,7 +201,7 @@ LL |     let _ = res2.unwrap_or_else(|_| 2);
    |                  help: use `unwrap_or(..)` instead: `unwrap_or(2)`
 
 error: unnecessary closure used to substitute value for `Result::Err`
-  --> $DIR/unnecessary_lazy_eval.rs:88:13
+  --> $DIR/unnecessary_lazy_eval.rs:90:13
    |
 LL |     let _ = res2.unwrap_or_else(|_| astronomers_pi);
    |             ^^^^^----------------------------------
@@ -201,7 +209,7 @@ LL |     let _ = res2.unwrap_or_else(|_| astronomers_pi);
    |                  help: use `unwrap_or(..)` instead: `unwrap_or(astronomers_pi)`
 
 error: unnecessary closure used to substitute value for `Result::Err`
-  --> $DIR/unnecessary_lazy_eval.rs:89:13
+  --> $DIR/unnecessary_lazy_eval.rs:91:13
    |
 LL |     let _ = res2.unwrap_or_else(|_| ext_str.some_field);
    |             ^^^^^--------------------------------------
@@ -209,7 +217,7 @@ LL |     let _ = res2.unwrap_or_else(|_| ext_str.some_field);
    |                  help: use `unwrap_or(..)` instead: `unwrap_or(ext_str.some_field)`
 
 error: unnecessary closure used to substitute value for `Result::Err`
-  --> $DIR/unnecessary_lazy_eval.rs:111:35
+  --> $DIR/unnecessary_lazy_eval.rs:113:35
    |
 LL |     let _: Result<usize, usize> = res.and_then(|_| Err(2));
    |                                   ^^^^--------------------
@@ -217,7 +225,7 @@ LL |     let _: Result<usize, usize> = res.and_then(|_| Err(2));
    |                                       help: use `and(..)` instead: `and(Err(2))`
 
 error: unnecessary closure used to substitute value for `Result::Err`
-  --> $DIR/unnecessary_lazy_eval.rs:112:35
+  --> $DIR/unnecessary_lazy_eval.rs:114:35
    |
 LL |     let _: Result<usize, usize> = res.and_then(|_| Err(astronomers_pi));
    |                                   ^^^^---------------------------------
@@ -225,7 +233,7 @@ LL |     let _: Result<usize, usize> = res.and_then(|_| Err(astronomers_pi));
    |                                       help: use `and(..)` instead: `and(Err(astronomers_pi))`
 
 error: unnecessary closure used to substitute value for `Result::Err`
-  --> $DIR/unnecessary_lazy_eval.rs:113:35
+  --> $DIR/unnecessary_lazy_eval.rs:115:35
    |
 LL |     let _: Result<usize, usize> = res.and_then(|_| Err(ext_str.some_field));
    |                                   ^^^^-------------------------------------
@@ -233,7 +241,7 @@ LL |     let _: Result<usize, usize> = res.and_then(|_| Err(ext_str.some_field))
    |                                       help: use `and(..)` instead: `and(Err(ext_str.some_field))`
 
 error: unnecessary closure used to substitute value for `Result::Err`
-  --> $DIR/unnecessary_lazy_eval.rs:115:35
+  --> $DIR/unnecessary_lazy_eval.rs:117:35
    |
 LL |     let _: Result<usize, usize> = res.or_else(|_| Ok(2));
    |                                   ^^^^------------------
@@ -241,7 +249,7 @@ LL |     let _: Result<usize, usize> = res.or_else(|_| Ok(2));
    |                                       help: use `or(..)` instead: `or(Ok(2))`
 
 error: unnecessary closure used to substitute value for `Result::Err`
-  --> $DIR/unnecessary_lazy_eval.rs:116:35
+  --> $DIR/unnecessary_lazy_eval.rs:118:35
    |
 LL |     let _: Result<usize, usize> = res.or_else(|_| Ok(astronomers_pi));
    |                                   ^^^^-------------------------------
@@ -249,7 +257,7 @@ LL |     let _: Result<usize, usize> = res.or_else(|_| Ok(astronomers_pi));
    |                                       help: use `or(..)` instead: `or(Ok(astronomers_pi))`
 
 error: unnecessary closure used to substitute value for `Result::Err`
-  --> $DIR/unnecessary_lazy_eval.rs:117:35
+  --> $DIR/unnecessary_lazy_eval.rs:119:35
    |
 LL |     let _: Result<usize, usize> = res.or_else(|_| Ok(ext_str.some_field));
    |                                   ^^^^-----------------------------------
@@ -257,7 +265,7 @@ LL |     let _: Result<usize, usize> = res.or_else(|_| Ok(ext_str.some_field));
    |                                       help: use `or(..)` instead: `or(Ok(ext_str.some_field))`
 
 error: unnecessary closure used to substitute value for `Result::Err`
-  --> $DIR/unnecessary_lazy_eval.rs:118:35
+  --> $DIR/unnecessary_lazy_eval.rs:120:35
    |
 LL |       let _: Result<usize, usize> = res.
    |  ___________________________________^
@@ -271,5 +279,5 @@ LL | |         or_else(|_| Ok(ext_str.some_field));
    |           |
    |           help: use `or(..)` instead: `or(Ok(ext_str.some_field))`
 
-error: aborting due to 33 previous errors
+error: aborting due to 34 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From ebff7206bcc4c740be9016dc7d2e10cf421463f9 Mon Sep 17 00:00:00 2001
From: Josh Triplett <josh@joshtriplett.org>
Date: Wed, 6 Jul 2022 00:51:40 -0700
Subject: Add MSRV check for `bool::then_some`

---
 clippy_lints/src/methods/mod.rs | 7 ++++++-
 clippy_utils/src/msrvs.rs       | 1 +
 2 files changed, 7 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 36389d798ed..15d98098f33 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -2737,7 +2737,12 @@ impl Methods {
                     }
                 },
                 ("take", []) => needless_option_take::check(cx, expr, recv),
-                ("then", [arg]) => unnecessary_lazy_eval::check(cx, expr, recv, arg, "then_some"),
+                ("then", [arg]) => {
+                    if !meets_msrv(self.msrv, msrvs::BOOL_THEN_SOME) {
+                        return;
+                    }
+                    unnecessary_lazy_eval::check(cx, expr, recv, arg, "then_some");
+                },
                 ("to_os_string" | "to_owned" | "to_path_buf" | "to_vec", []) => {
                     implicit_clone::check(cx, name, expr, recv);
                 },
diff --git a/clippy_utils/src/msrvs.rs b/clippy_utils/src/msrvs.rs
index b09c929f76e..9e238c6f1ac 100644
--- a/clippy_utils/src/msrvs.rs
+++ b/clippy_utils/src/msrvs.rs
@@ -12,6 +12,7 @@ macro_rules! msrv_aliases {
 
 // names may refer to stabilized feature flags or library items
 msrv_aliases! {
+    1,62,0 { BOOL_THEN_SOME }
     1,53,0 { OR_PATTERNS, MANUAL_BITS, BTREE_MAP_RETAIN, BTREE_SET_RETAIN }
     1,52,0 { STR_SPLIT_ONCE, REM_EUCLID_CONST }
     1,51,0 { BORROW_AS_PTR, UNSIGNED_ABS }
-- 
cgit 1.4.1-3-g733a5


From b7230d4f44e974c6639980a2e44e8d7523b6c90c Mon Sep 17 00:00:00 2001
From: Josh Triplett <josh@joshtriplett.org>
Date: Wed, 6 Jul 2022 00:52:53 -0700
Subject: Dogfood fixes to use `bool::then_some`

---
 clippy_dev/src/update_lints.rs                              | 2 +-
 clippy_lints/src/dereference.rs                             | 4 +++-
 clippy_lints/src/entry.rs                                   | 2 +-
 clippy_lints/src/inherent_impl.rs                           | 2 +-
 clippy_lints/src/manual_non_exhaustive.rs                   | 2 +-
 clippy_lints/src/matches/manual_map.rs                      | 2 +-
 clippy_lints/src/matches/match_same_arms.rs                 | 4 ++--
 clippy_lints/src/matches/mod.rs                             | 4 ++--
 clippy_lints/src/methods/manual_str_repeat.rs               | 2 +-
 clippy_lints/src/option_if_let_else.rs                      | 2 +-
 clippy_lints/src/ptr.rs                                     | 2 +-
 clippy_lints/src/swap_ptr_to_ref.rs                         | 2 +-
 clippy_lints/src/utils/internal_lints/metadata_collector.rs | 2 +-
 clippy_lints/src/write.rs                                   | 2 +-
 clippy_utils/src/lib.rs                                     | 2 +-
 clippy_utils/src/source.rs                                  | 2 +-
 16 files changed, 20 insertions(+), 18 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_dev/src/update_lints.rs b/clippy_dev/src/update_lints.rs
index 2e0659f42d7..c089f4d8ce4 100644
--- a/clippy_dev/src/update_lints.rs
+++ b/clippy_dev/src/update_lints.rs
@@ -553,7 +553,7 @@ fn replace_ident_like(contents: &str, replacements: &[(&str, &str)]) -> Option<S
         pos = m.end();
     }
     result.push_str(&contents[pos..]);
-    edited.then(|| result)
+    edited.then_some(result)
 }
 
 fn round_to_fifty(count: usize) -> usize {
diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index 59dcc1ebf19..6a35044d459 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -730,7 +730,9 @@ fn walk_parents<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> (Position, &
                         Position::DerefStable(precedence)
                     })
                 },
-                ExprKind::Call(func, _) if func.hir_id == child_id => (child_id == e.hir_id).then(|| Position::Callee),
+                ExprKind::Call(func, _) if func.hir_id == child_id => {
+                    (child_id == e.hir_id).then_some(Position::Callee)
+                },
                 ExprKind::Call(func, args) => args
                     .iter()
                     .position(|arg| arg.hir_id == child_id)
diff --git a/clippy_lints/src/entry.rs b/clippy_lints/src/entry.rs
index 27743a0ebec..4e3ae4c9614 100644
--- a/clippy_lints/src/entry.rs
+++ b/clippy_lints/src/entry.rs
@@ -650,7 +650,7 @@ fn find_insert_calls<'tcx>(
     let allow_insert_closure = s.allow_insert_closure;
     let is_single_insert = s.is_single_insert;
     let edits = s.edits;
-    s.can_use_entry.then(|| InsertSearchResults {
+    s.can_use_entry.then_some(InsertSearchResults {
         edits,
         allow_insert_closure,
         is_single_insert,
diff --git a/clippy_lints/src/inherent_impl.rs b/clippy_lints/src/inherent_impl.rs
index 6a031a627df..c5abcc46254 100644
--- a/clippy_lints/src/inherent_impl.rs
+++ b/clippy_lints/src/inherent_impl.rs
@@ -127,7 +127,7 @@ fn get_impl_span(cx: &LateContext<'_>, id: LocalDefId) -> Option<Span> {
         (!span.from_expansion()
             && impl_item.generics.params.is_empty()
             && !is_lint_allowed(cx, MULTIPLE_INHERENT_IMPL, id))
-        .then(|| span)
+        .then_some(span)
     } else {
         None
     }
diff --git a/clippy_lints/src/manual_non_exhaustive.rs b/clippy_lints/src/manual_non_exhaustive.rs
index 4278e98dc91..2b04475c7a9 100644
--- a/clippy_lints/src/manual_non_exhaustive.rs
+++ b/clippy_lints/src/manual_non_exhaustive.rs
@@ -161,7 +161,7 @@ impl<'tcx> LateLintPass<'tcx> for ManualNonExhaustiveEnum {
                 (matches!(v.data, hir::VariantData::Unit(_))
                     && v.ident.as_str().starts_with('_')
                     && is_doc_hidden(cx.tcx.hir().attrs(v.id)))
-                .then(|| (id, v.span))
+                .then_some((id, v.span))
             });
             if let Some((id, span)) = iter.next()
                 && iter.next().is_none()
diff --git a/clippy_lints/src/matches/manual_map.rs b/clippy_lints/src/matches/manual_map.rs
index 542905a2d76..8f98b43b9e5 100644
--- a/clippy_lints/src/matches/manual_map.rs
+++ b/clippy_lints/src/matches/manual_map.rs
@@ -105,7 +105,7 @@ fn check<'tcx>(
 
     // Determine which binding mode to use.
     let explicit_ref = some_pat.contains_explicit_ref_binding();
-    let binding_ref = explicit_ref.or_else(|| (ty_ref_count != pat_ref_count).then(|| ty_mutability));
+    let binding_ref = explicit_ref.or_else(|| (ty_ref_count != pat_ref_count).then_some(ty_mutability));
 
     let as_ref_str = match binding_ref {
         Some(Mutability::Mut) => ".as_mut()",
diff --git a/clippy_lints/src/matches/match_same_arms.rs b/clippy_lints/src/matches/match_same_arms.rs
index 15513de7d86..61d28b15066 100644
--- a/clippy_lints/src/matches/match_same_arms.rs
+++ b/clippy_lints/src/matches/match_same_arms.rs
@@ -38,7 +38,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>]) {
             normalized_pats[i + 1..]
                 .iter()
                 .enumerate()
-                .find_map(|(j, other)| pat.has_overlapping_values(other).then(|| i + 1 + j))
+                .find_map(|(j, other)| pat.has_overlapping_values(other).then_some(i + 1 + j))
                 .unwrap_or(normalized_pats.len())
         })
         .collect();
@@ -55,7 +55,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>]) {
                 .zip(forwards_blocking_idxs[..i].iter().copied().rev())
                 .skip_while(|&(_, forward_block)| forward_block > i)
                 .find_map(|((j, other), forward_block)| {
-                    (forward_block == i || pat.has_overlapping_values(other)).then(|| j)
+                    (forward_block == i || pat.has_overlapping_values(other)).then_some(j)
                 })
                 .unwrap_or(0)
         })
diff --git a/clippy_lints/src/matches/mod.rs b/clippy_lints/src/matches/mod.rs
index b2a873ef582..5c996bc33f3 100644
--- a/clippy_lints/src/matches/mod.rs
+++ b/clippy_lints/src/matches/mod.rs
@@ -1061,7 +1061,7 @@ fn contains_cfg_arm(cx: &LateContext<'_>, e: &Expr<'_>, scrutinee: &Expr<'_>, ar
     let start = scrutinee_span.hi();
     let mut arm_spans = arms.iter().map(|arm| {
         let data = arm.span.data();
-        (data.ctxt == SyntaxContext::root()).then(|| (data.lo, data.hi))
+        (data.ctxt == SyntaxContext::root()).then_some((data.lo, data.hi))
     });
     let end = e.span.hi();
 
@@ -1095,7 +1095,7 @@ fn contains_cfg_arm(cx: &LateContext<'_>, e: &Expr<'_>, scrutinee: &Expr<'_>, ar
             parent: None,
         }
         .span();
-        (!span_contains_cfg(cx, span)).then(|| next_start).ok_or(())
+        (!span_contains_cfg(cx, span)).then_some(next_start).ok_or(())
     });
     match found {
         Ok(start) => {
diff --git a/clippy_lints/src/methods/manual_str_repeat.rs b/clippy_lints/src/methods/manual_str_repeat.rs
index 68a75667914..46d2fc493f8 100644
--- a/clippy_lints/src/methods/manual_str_repeat.rs
+++ b/clippy_lints/src/methods/manual_str_repeat.rs
@@ -43,7 +43,7 @@ fn parse_repeat_arg(cx: &LateContext<'_>, e: &Expr<'_>) -> Option<RepeatKind> {
             Some(RepeatKind::String)
         } else {
             let ty = ty.peel_refs();
-            (ty.is_str() || is_type_diagnostic_item(cx, ty, sym::String)).then(|| RepeatKind::String)
+            (ty.is_str() || is_type_diagnostic_item(cx, ty, sym::String)).then_some(RepeatKind::String)
         }
     }
 }
diff --git a/clippy_lints/src/option_if_let_else.rs b/clippy_lints/src/option_if_let_else.rs
index ea5a8f0858b..44f153cffac 100644
--- a/clippy_lints/src/option_if_let_else.rs
+++ b/clippy_lints/src/option_if_let_else.rs
@@ -146,7 +146,7 @@ fn detect_option_if_let_else<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>) ->
                 });
                 if let ExprKind::Path(QPath::Resolved(None, Path { res: Res::Local(local_id), .. })) = e.kind {
                     match some_captures.get(local_id)
-                        .or_else(|| (method_sugg == "map_or_else").then(|| ()).and_then(|_| none_captures.get(local_id)))
+                        .or_else(|| (method_sugg == "map_or_else").then_some(()).and_then(|_| none_captures.get(local_id)))
                     {
                         Some(CaptureKind::Value | CaptureKind::Ref(Mutability::Mut)) => return None,
                         Some(CaptureKind::Ref(Mutability::Not)) if as_mut => return None,
diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs
index 25b73918c0a..8bacc6f6b32 100644
--- a/clippy_lints/src/ptr.rs
+++ b/clippy_lints/src/ptr.rs
@@ -501,7 +501,7 @@ fn check_mut_from_ref<'tcx>(cx: &LateContext<'tcx>, sig: &FnSig<'_>, body: Optio
             .iter()
             .filter_map(get_rptr_lm)
             .filter(|&(lt, _, _)| lt.name == out.name)
-            .map(|(_, mutability, span)| (mutability == Mutability::Not).then(|| span))
+            .map(|(_, mutability, span)| (mutability == Mutability::Not).then_some(span))
             .collect();
         if let Some(args) = args
             && !args.is_empty()
diff --git a/clippy_lints/src/swap_ptr_to_ref.rs b/clippy_lints/src/swap_ptr_to_ref.rs
index 75d3b040c96..3cbbda80f3a 100644
--- a/clippy_lints/src/swap_ptr_to_ref.rs
+++ b/clippy_lints/src/swap_ptr_to_ref.rs
@@ -73,7 +73,7 @@ fn is_ptr_to_ref(cx: &LateContext<'_>, e: &Expr<'_>, ctxt: SyntaxContext) -> (bo
         && let ExprKind::Unary(UnOp::Deref, derefed_expr) = borrowed_expr.kind
         && cx.typeck_results().expr_ty(derefed_expr).is_unsafe_ptr()
     {
-        (true, (borrowed_expr.span.ctxt() == ctxt || derefed_expr.span.ctxt() == ctxt).then(|| derefed_expr.span))
+        (true, (borrowed_expr.span.ctxt() == ctxt || derefed_expr.span.ctxt() == ctxt).then_some(derefed_expr.span))
     } else {
         (false, None)
     }
diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index 6518e0a6ea0..3010fc0223c 100644
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -843,7 +843,7 @@ fn get_lint_group(cx: &LateContext<'_>, lint_id: LintId) -> Option<String> {
 fn get_lint_level_from_group(lint_group: &str) -> Option<&'static str> {
     DEFAULT_LINT_LEVELS
         .iter()
-        .find_map(|(group_name, group_level)| (*group_name == lint_group).then(|| *group_level))
+        .find_map(|(group_name, group_level)| (*group_name == lint_group).then_some(*group_level))
 }
 
 pub(super) fn is_deprecated_lint(cx: &LateContext<'_>, ty: &hir::Ty<'_>) -> bool {
diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs
index 67b2bc8c3f3..08b88947520 100644
--- a/clippy_lints/src/write.rs
+++ b/clippy_lints/src/write.rs
@@ -515,7 +515,7 @@ impl Write {
             args.push(arg, span);
         }
 
-        parser.errors.is_empty().then(move || args)
+        parser.errors.is_empty().then_some(args)
     }
 
     /// Checks the arguments of `print[ln]!` and `write[ln]!` calls. It will return a tuple of two
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 9fa28e137f9..0e739303683 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -1016,7 +1016,7 @@ pub fn can_move_expr_to_closure<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'
         captures: HirIdMap::default(),
     };
     v.visit_expr(expr);
-    v.allow_closure.then(|| v.captures)
+    v.allow_closure.then_some(v.captures)
 }
 
 /// Returns the method names and argument list of nested method call expressions that make up
diff --git a/clippy_utils/src/source.rs b/clippy_utils/src/source.rs
index f88a92fb11c..1197fe914de 100644
--- a/clippy_utils/src/source.rs
+++ b/clippy_utils/src/source.rs
@@ -353,7 +353,7 @@ pub fn snippet_with_context<'a>(
 /// span containing `m!(0)`.
 pub fn walk_span_to_context(span: Span, outer: SyntaxContext) -> Option<Span> {
     let outer_span = hygiene::walk_chain(span, outer);
-    (outer_span.ctxt() == outer).then(|| outer_span)
+    (outer_span.ctxt() == outer).then_some(outer_span)
 }
 
 /// Removes block comments from the given `Vec` of lines.
-- 
cgit 1.4.1-3-g733a5


From f2bef55389e3e053cab50d91a674739d8a1ca036 Mon Sep 17 00:00:00 2001
From: Marcel Hellwig <github@cookiesoft.de>
Date: Thu, 7 Jul 2022 11:59:55 +0200
Subject: trait_bounds: rework two loops into one

the two loops did practically the same, only the type were different (&&
vs &), so I used `copied` to convert `&&` and chained them together.
Instead of parsing the trait info manually, I use the already provided
method `get_trait_info_from_bound`.
Also, instead of using manual string writing, I used `join` by
`itertools`.
---
 clippy_lints/src/trait_bounds.rs | 36 ++++++++++++------------------------
 1 file changed, 12 insertions(+), 24 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/trait_bounds.rs b/clippy_lints/src/trait_bounds.rs
index 71957572f2e..76b739c48f1 100644
--- a/clippy_lints/src/trait_bounds.rs
+++ b/clippy_lints/src/trait_bounds.rs
@@ -3,6 +3,7 @@ use clippy_utils::source::{snippet, snippet_with_applicability};
 use clippy_utils::{SpanlessEq, SpanlessHash};
 use core::hash::{Hash, Hasher};
 use if_chain::if_chain;
+use itertools::Itertools;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_data_structures::unhash::UnhashMap;
 use rustc_errors::Applicability;
@@ -14,7 +15,6 @@ use rustc_hir::{
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::Span;
-use std::fmt::Write as _;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -178,30 +178,18 @@ impl TraitBounds {
                 );
 
                 then {
-                    let mut hint_string = format!(
-                        "consider combining the bounds: `{}:",
-                        snippet(cx, p.bounded_ty.span, "_")
+                    let trait_bounds = v
+                        .iter()
+                        .copied()
+                        .chain(p.bounds.iter())
+                        .filter_map(get_trait_info_from_bound)
+                        .map(|(_, _, span)| snippet_with_applicability(cx, span, "..", &mut applicability))
+                        .join(" + ");
+                    let hint_string = format!(
+                        "consider combining the bounds: `{}: {}`",
+                        snippet(cx, p.bounded_ty.span, "_"),
+                        trait_bounds,
                     );
-                    for b in v.iter() {
-                        if let GenericBound::Trait(ref poly_trait_ref, _) = b {
-                            let path = &poly_trait_ref.trait_ref.path;
-                            let _ = write!(hint_string,
-                                " {} +",
-                                snippet_with_applicability(cx, path.span, "..", &mut applicability)
-                            );
-                        }
-                    }
-                    for b in p.bounds.iter() {
-                        if let GenericBound::Trait(ref poly_trait_ref, _) = b {
-                            let path = &poly_trait_ref.trait_ref.path;
-                            let _ = write!(hint_string,
-                                " {} +",
-                                snippet_with_applicability(cx, path.span, "..", &mut applicability)
-                            );
-                        }
-                    }
-                    hint_string.truncate(hint_string.len() - 2);
-                    hint_string.push('`');
                     span_lint_and_help(
                         cx,
                         TYPE_REPETITION_IN_BOUNDS,
-- 
cgit 1.4.1-3-g733a5


From ead2c4f1222c7c9023f02bf6dceaa49eb987c716 Mon Sep 17 00:00:00 2001
From: Marcel Hellwig <github@cookiesoft.de>
Date: Thu, 7 Jul 2022 12:24:17 +0200
Subject: fix incorrect suggestion for maybe trait bounds

---
 clippy_lints/src/trait_bounds.rs          | 19 ++++++++++++++-----
 tests/ui/type_repetition_in_bounds.rs     | 12 ++++++++++++
 tests/ui/type_repetition_in_bounds.stderr | 18 +++++++++++++++++-
 3 files changed, 43 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/trait_bounds.rs b/clippy_lints/src/trait_bounds.rs
index 76b739c48f1..2741179074b 100644
--- a/clippy_lints/src/trait_bounds.rs
+++ b/clippy_lints/src/trait_bounds.rs
@@ -9,12 +9,12 @@ use rustc_data_structures::unhash::UnhashMap;
 use rustc_errors::Applicability;
 use rustc_hir::def::Res;
 use rustc_hir::{
-    GenericBound, Generics, Item, ItemKind, Node, Path, PathSegment, PredicateOrigin, QPath, TraitItem, Ty, TyKind,
-    WherePredicate,
+    GenericBound, Generics, Item, ItemKind, Node, Path, PathSegment, PredicateOrigin, QPath, TraitBoundModifier,
+    TraitItem, Ty, TyKind, WherePredicate,
 };
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::Span;
+use rustc_span::{BytePos, Span};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -242,8 +242,17 @@ fn check_trait_bound_duplication(cx: &LateContext<'_>, gen: &'_ Generics<'_>) {
 }
 
 fn get_trait_info_from_bound<'a>(bound: &'a GenericBound<'_>) -> Option<(Res, &'a [PathSegment<'a>], Span)> {
-    if let GenericBound::Trait(t, _) = bound {
-        Some((t.trait_ref.path.res, t.trait_ref.path.segments, t.span))
+    if let GenericBound::Trait(t, tbm) = bound {
+        let trait_path = t.trait_ref.path;
+        let trait_span = {
+            let path_span = trait_path.span;
+            if let TraitBoundModifier::Maybe = tbm {
+                path_span.with_lo(path_span.lo() - BytePos(1)) // include the `?`
+            } else {
+                path_span
+            }
+        };
+        Some((trait_path.res, trait_path.segments, trait_span))
     } else {
         None
     }
diff --git a/tests/ui/type_repetition_in_bounds.rs b/tests/ui/type_repetition_in_bounds.rs
index d11432f9046..2eca1f4701c 100644
--- a/tests/ui/type_repetition_in_bounds.rs
+++ b/tests/ui/type_repetition_in_bounds.rs
@@ -79,6 +79,18 @@ where
     u: U,
 }
 
+// Check for the `?` in `?Sized`
+pub fn f<T: ?Sized>()
+where
+    T: Clone,
+{
+}
+pub fn g<T: Clone>()
+where
+    T: ?Sized,
+{
+}
+
 // This should not lint
 fn impl_trait(_: impl AsRef<str>, _: impl AsRef<str>) {}
 
diff --git a/tests/ui/type_repetition_in_bounds.stderr b/tests/ui/type_repetition_in_bounds.stderr
index 148c19c7d07..1d88714814d 100644
--- a/tests/ui/type_repetition_in_bounds.stderr
+++ b/tests/ui/type_repetition_in_bounds.stderr
@@ -19,5 +19,21 @@ LL |     Self: Copy + Default + Ord,
    |
    = help: consider combining the bounds: `Self: Clone + Copy + Default + Ord`
 
-error: aborting due to 2 previous errors
+error: this type has already been used as a bound predicate
+  --> $DIR/type_repetition_in_bounds.rs:85:5
+   |
+LL |     T: Clone,
+   |     ^^^^^^^^
+   |
+   = help: consider combining the bounds: `T: ?Sized + Clone`
+
+error: this type has already been used as a bound predicate
+  --> $DIR/type_repetition_in_bounds.rs:90:5
+   |
+LL |     T: ?Sized,
+   |     ^^^^^^^^^
+   |
+   = help: consider combining the bounds: `T: Clone + ?Sized`
+
+error: aborting due to 4 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 307b8cd82537b5ac46da2f04cced4e4362835757 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Mon, 6 Jun 2022 15:09:37 +0000
Subject: Lint simple expressions in manual_filter_map, manual_find_map

---
 clippy_lints/src/methods/filter_map.rs | 107 +++++++++++++-------------
 tests/ui/manual_filter_map.fixed       |  34 +++++++++
 tests/ui/manual_filter_map.rs          |  38 +++++++++
 tests/ui/manual_filter_map.stderr      | 120 ++++++++++++++++++++++++++---
 tests/ui/manual_find_map.fixed         |  37 +++++++++
 tests/ui/manual_find_map.rs            |  41 ++++++++++
 tests/ui/manual_find_map.stderr        | 136 ++++++++++++++++++++++++++++++---
 7 files changed, 440 insertions(+), 73 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/filter_map.rs b/clippy_lints/src/methods/filter_map.rs
index 58c3e52e138..b694a5a7948 100644
--- a/clippy_lints/src/methods/filter_map.rs
+++ b/clippy_lints/src/methods/filter_map.rs
@@ -8,6 +8,7 @@ use rustc_hir as hir;
 use rustc_hir::def::Res;
 use rustc_hir::{Expr, ExprKind, PatKind, PathSegment, QPath, UnOp};
 use rustc_lint::LateContext;
+use rustc_middle::ty::adjustment::Adjust;
 use rustc_span::source_map::Span;
 use rustc_span::symbol::{sym, Symbol};
 use std::borrow::Cow;
@@ -49,35 +50,18 @@ fn is_option_filter_map<'tcx>(cx: &LateContext<'tcx>, filter_arg: &hir::Expr<'_>
     is_method(cx, map_arg, sym::unwrap) && is_method(cx, filter_arg, sym!(is_some))
 }
 
-/// lint use of `filter().map()` for `Iterators`
-fn lint_filter_some_map_unwrap(
+/// is `filter(|x| x.is_some()).map(|x| x.unwrap())`
+fn is_filter_some_map_unwrap(
     cx: &LateContext<'_>,
     expr: &hir::Expr<'_>,
     filter_recv: &hir::Expr<'_>,
     filter_arg: &hir::Expr<'_>,
     map_arg: &hir::Expr<'_>,
-    target_span: Span,
-    methods_span: Span,
-) {
+) -> bool {
     let iterator = is_trait_method(cx, expr, sym::Iterator);
     let option = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(filter_recv), sym::Option);
-    if (iterator || option) && is_option_filter_map(cx, filter_arg, map_arg) {
-        let msg = "`filter` for `Some` followed by `unwrap`";
-        let help = "consider using `flatten` instead";
-        let sugg = format!(
-            "{}",
-            reindent_multiline(Cow::Borrowed("flatten()"), true, indent_of(cx, target_span),)
-        );
-        span_lint_and_sugg(
-            cx,
-            OPTION_FILTER_MAP,
-            methods_span,
-            msg,
-            help,
-            sugg,
-            Applicability::MachineApplicable,
-        );
-    }
+
+    (iterator || option) && is_option_filter_map(cx, filter_arg, map_arg)
 }
 
 /// lint use of `filter().map()` or `find().map()` for `Iterators`
@@ -93,15 +77,20 @@ pub(super) fn check<'tcx>(
     map_span: Span,
     is_find: bool,
 ) {
-    lint_filter_some_map_unwrap(
-        cx,
-        expr,
-        filter_recv,
-        filter_arg,
-        map_arg,
-        map_span,
-        filter_span.with_hi(expr.span.hi()),
-    );
+    if is_filter_some_map_unwrap(cx, expr, filter_recv, filter_arg, map_arg) {
+        span_lint_and_sugg(
+            cx,
+            OPTION_FILTER_MAP,
+            filter_span.with_hi(expr.span.hi()),
+            "`filter` for `Some` followed by `unwrap`",
+            "consider using `flatten` instead",
+            reindent_multiline(Cow::Borrowed("flatten()"), true, indent_of(cx, map_span)).into_owned(),
+            Applicability::MachineApplicable,
+        );
+
+        return;
+    }
+
     if_chain! {
             if is_trait_method(cx, map_recv, sym::Iterator);
 
@@ -118,7 +107,7 @@ pub(super) fn check<'tcx>(
             // closure ends with is_some() or is_ok()
             if let PatKind::Binding(_, filter_param_id, _, None) = filter_pat.kind;
             if let ExprKind::MethodCall(path, [filter_arg], _) = filter_body.value.kind;
-            if let Some(opt_ty) = cx.typeck_results().expr_ty(filter_arg).ty_adt_def();
+            if let Some(opt_ty) = cx.typeck_results().expr_ty(filter_arg).peel_refs().ty_adt_def();
             if let Some(is_result) = if cx.tcx.is_diagnostic_item(sym::Option, opt_ty.did()) {
                 Some(false)
             } else if cx.tcx.is_diagnostic_item(sym::Result, opt_ty.did()) {
@@ -137,6 +126,19 @@ pub(super) fn check<'tcx>(
             if let ExprKind::MethodCall(seg, [map_arg, ..], _) = map_body.value.kind;
             if matches!(seg.ident.name, sym::expect | sym::unwrap | sym::unwrap_or);
 
+            // .filter(..).map(|y| f(y).copied().unwrap())
+            //                     ~~~~
+            let map_arg_peeled = match map_arg.kind {
+                ExprKind::MethodCall(method, [original_arg], _) if acceptable_methods(method) => {
+                    original_arg
+                },
+                _ => map_arg,
+            };
+
+            // .filter(|x| x.is_some()).map(|y| y[.acceptable_method()].unwrap())
+            let simple_equal = path_to_local_id(filter_arg, filter_param_id)
+                && path_to_local_id(map_arg_peeled, map_param_id);
+
             let eq_fallback = |a: &Expr<'_>, b: &Expr<'_>| {
                 // in `filter(|x| ..)`, replace `*x` with `x`
                 let a_path = if_chain! {
@@ -145,25 +147,12 @@ pub(super) fn check<'tcx>(
                     then { expr_path } else { a }
                 };
                 // let the filter closure arg and the map closure arg be equal
-                if_chain! {
-                    if path_to_local_id(a_path, filter_param_id);
-                    if path_to_local_id(b, map_param_id);
-                    if cx.typeck_results().expr_ty_adjusted(a) == cx.typeck_results().expr_ty_adjusted(b);
-                    then {
-                        return true;
-                    }
-                }
-                false
-            };
-
-            if match map_arg.kind {
-                ExprKind::MethodCall(method, [original_arg], _) => {
-                    acceptable_methods(method)
-                        && SpanlessEq::new(cx).expr_fallback(eq_fallback).eq_expr(filter_arg, original_arg)
-                },
-                _ => SpanlessEq::new(cx).expr_fallback(eq_fallback).eq_expr(filter_arg, map_arg)
+                path_to_local_id(a_path, filter_param_id)
+                    && path_to_local_id(b, map_param_id)
+                    && cx.typeck_results().expr_ty_adjusted(a) == cx.typeck_results().expr_ty_adjusted(b)
             };
 
+            if simple_equal || SpanlessEq::new(cx).expr_fallback(eq_fallback).eq_expr(filter_arg, map_arg_peeled);
             then {
                 let span = filter_span.with_hi(expr.span.hi());
                 let (filter_name, lint) = if is_find {
@@ -171,10 +160,22 @@ pub(super) fn check<'tcx>(
                 } else {
                     ("filter", MANUAL_FILTER_MAP)
                 };
-                let msg = format!("`{}(..).map(..)` can be simplified as `{0}_map(..)`", filter_name);
-                let to_opt = if is_result { ".ok()" } else { "" };
-                let sugg = format!("{}_map(|{}| {}{})", filter_name, map_param_ident,
-                    snippet(cx, map_arg.span, ".."), to_opt);
+                let msg = format!("`{filter_name}(..).map(..)` can be simplified as `{filter_name}_map(..)`");
+                let (to_opt, deref) = if is_result {
+                    (".ok()", String::new())
+                } else {
+                    let derefs = cx.typeck_results()
+                        .expr_adjustments(map_arg)
+                        .iter()
+                        .filter(|adj| matches!(adj.kind, Adjust::Deref(_)))
+                        .count();
+
+                    ("", "*".repeat(derefs))
+                };
+                let sugg = format!(
+                    "{filter_name}_map(|{map_param_ident}| {deref}{}{to_opt})",
+                    snippet(cx, map_arg.span, ".."),
+                );
                 span_lint_and_sugg(cx, lint, span, &msg, "try", sugg, Applicability::MachineApplicable);
             }
     }
diff --git a/tests/ui/manual_filter_map.fixed b/tests/ui/manual_filter_map.fixed
index de0d8614889..4936dc9b2e0 100644
--- a/tests/ui/manual_filter_map.fixed
+++ b/tests/ui/manual_filter_map.fixed
@@ -12,6 +12,32 @@ fn main() {
 
     // is_ok(), unwrap_or()
     let _ = (0..).filter_map(|a| to_res(a).ok());
+
+    let _ = (1..5)
+        .filter_map(|y| *to_ref(to_opt(y)));
+    let _ = (1..5)
+        .filter_map(|y| *to_ref(to_opt(y)));
+
+    let _ = (1..5)
+        .filter_map(|y| to_ref(to_res(y)).ok());
+    let _ = (1..5)
+        .filter_map(|y| to_ref(to_res(y)).ok());
+}
+
+#[rustfmt::skip]
+fn simple_equal() {
+    iter::<Option<&u8>>().find_map(|x| x.cloned());
+    iter::<&Option<&u8>>().find_map(|x| x.cloned());
+    iter::<&Option<String>>().find_map(|x| x.as_deref());
+    iter::<Option<&String>>().find_map(|y| to_ref(y).cloned());
+
+    iter::<Result<u8, ()>>().find_map(|x| x.ok());
+    iter::<&Result<u8, ()>>().find_map(|x| x.ok());
+    iter::<&&Result<u8, ()>>().find_map(|x| x.ok());
+    iter::<Result<&u8, ()>>().find_map(|x| x.cloned().ok());
+    iter::<&Result<&u8, ()>>().find_map(|x| x.cloned().ok());
+    iter::<&Result<String, ()>>().find_map(|x| x.as_deref().ok());
+    iter::<Result<&String, ()>>().find_map(|y| to_ref(y).cloned().ok());
 }
 
 fn no_lint() {
@@ -28,6 +54,10 @@ fn no_lint() {
         .map(|a| to_opt(a).unwrap());
 }
 
+fn iter<T>() -> impl Iterator<Item = T> {
+    std::iter::empty()
+}
+
 fn to_opt<T>(_: T) -> Option<T> {
     unimplemented!()
 }
@@ -36,6 +66,10 @@ fn to_res<T>(_: T) -> Result<T, ()> {
     unimplemented!()
 }
 
+fn to_ref<'a, T>(_: T) -> &'a T {
+    unimplemented!()
+}
+
 struct Issue8920<'a> {
     option_field: Option<String>,
     result_field: Result<String, ()>,
diff --git a/tests/ui/manual_filter_map.rs b/tests/ui/manual_filter_map.rs
index bd6516f038b..8c67e827b4c 100644
--- a/tests/ui/manual_filter_map.rs
+++ b/tests/ui/manual_filter_map.rs
@@ -12,6 +12,36 @@ fn main() {
 
     // is_ok(), unwrap_or()
     let _ = (0..).filter(|&n| to_res(n).is_ok()).map(|a| to_res(a).unwrap_or(1));
+
+    let _ = (1..5)
+        .filter(|&x| to_ref(to_opt(x)).is_some())
+        .map(|y| to_ref(to_opt(y)).unwrap());
+    let _ = (1..5)
+        .filter(|x| to_ref(to_opt(*x)).is_some())
+        .map(|y| to_ref(to_opt(y)).unwrap());
+
+    let _ = (1..5)
+        .filter(|&x| to_ref(to_res(x)).is_ok())
+        .map(|y| to_ref(to_res(y)).unwrap());
+    let _ = (1..5)
+        .filter(|x| to_ref(to_res(*x)).is_ok())
+        .map(|y| to_ref(to_res(y)).unwrap());
+}
+
+#[rustfmt::skip]
+fn simple_equal() {
+    iter::<Option<&u8>>().find(|x| x.is_some()).map(|x| x.cloned().unwrap());
+    iter::<&Option<&u8>>().find(|x| x.is_some()).map(|x| x.cloned().unwrap());
+    iter::<&Option<String>>().find(|x| x.is_some()).map(|x| x.as_deref().unwrap());
+    iter::<Option<&String>>().find(|&x| to_ref(x).is_some()).map(|y| to_ref(y).cloned().unwrap());
+
+    iter::<Result<u8, ()>>().find(|x| x.is_ok()).map(|x| x.unwrap());
+    iter::<&Result<u8, ()>>().find(|x| x.is_ok()).map(|x| x.unwrap());
+    iter::<&&Result<u8, ()>>().find(|x| x.is_ok()).map(|x| x.unwrap());
+    iter::<Result<&u8, ()>>().find(|x| x.is_ok()).map(|x| x.cloned().unwrap());
+    iter::<&Result<&u8, ()>>().find(|x| x.is_ok()).map(|x| x.cloned().unwrap());
+    iter::<&Result<String, ()>>().find(|x| x.is_ok()).map(|x| x.as_deref().unwrap());
+    iter::<Result<&String, ()>>().find(|&x| to_ref(x).is_ok()).map(|y| to_ref(y).cloned().unwrap());
 }
 
 fn no_lint() {
@@ -28,6 +58,10 @@ fn no_lint() {
         .map(|a| to_opt(a).unwrap());
 }
 
+fn iter<T>() -> impl Iterator<Item = T> {
+    std::iter::empty()
+}
+
 fn to_opt<T>(_: T) -> Option<T> {
     unimplemented!()
 }
@@ -36,6 +70,10 @@ fn to_res<T>(_: T) -> Result<T, ()> {
     unimplemented!()
 }
 
+fn to_ref<'a, T>(_: T) -> &'a T {
+    unimplemented!()
+}
+
 struct Issue8920<'a> {
     option_field: Option<String>,
     result_field: Result<String, ()>,
diff --git a/tests/ui/manual_filter_map.stderr b/tests/ui/manual_filter_map.stderr
index 465f1b19110..6e5bbe8f2aa 100644
--- a/tests/ui/manual_filter_map.stderr
+++ b/tests/ui/manual_filter_map.stderr
@@ -19,7 +19,107 @@ LL |     let _ = (0..).filter(|&n| to_res(n).is_ok()).map(|a| to_res(a).unwrap_o
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `filter_map(|a| to_res(a).ok())`
 
 error: `filter(..).map(..)` can be simplified as `filter_map(..)`
-  --> $DIR/manual_filter_map.rs:54:10
+  --> $DIR/manual_filter_map.rs:17:10
+   |
+LL |           .filter(|&x| to_ref(to_opt(x)).is_some())
+   |  __________^
+LL | |         .map(|y| to_ref(to_opt(y)).unwrap());
+   | |____________________________________________^ help: try: `filter_map(|y| *to_ref(to_opt(y)))`
+
+error: `filter(..).map(..)` can be simplified as `filter_map(..)`
+  --> $DIR/manual_filter_map.rs:20:10
+   |
+LL |           .filter(|x| to_ref(to_opt(*x)).is_some())
+   |  __________^
+LL | |         .map(|y| to_ref(to_opt(y)).unwrap());
+   | |____________________________________________^ help: try: `filter_map(|y| *to_ref(to_opt(y)))`
+
+error: `filter(..).map(..)` can be simplified as `filter_map(..)`
+  --> $DIR/manual_filter_map.rs:24:10
+   |
+LL |           .filter(|&x| to_ref(to_res(x)).is_ok())
+   |  __________^
+LL | |         .map(|y| to_ref(to_res(y)).unwrap());
+   | |____________________________________________^ help: try: `filter_map(|y| to_ref(to_res(y)).ok())`
+
+error: `filter(..).map(..)` can be simplified as `filter_map(..)`
+  --> $DIR/manual_filter_map.rs:27:10
+   |
+LL |           .filter(|x| to_ref(to_res(*x)).is_ok())
+   |  __________^
+LL | |         .map(|y| to_ref(to_res(y)).unwrap());
+   | |____________________________________________^ help: try: `filter_map(|y| to_ref(to_res(y)).ok())`
+
+error: `find(..).map(..)` can be simplified as `find_map(..)`
+  --> $DIR/manual_filter_map.rs:33:27
+   |
+LL |     iter::<Option<&u8>>().find(|x| x.is_some()).map(|x| x.cloned().unwrap());
+   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|x| x.cloned())`
+   |
+   = note: `-D clippy::manual-find-map` implied by `-D warnings`
+
+error: `find(..).map(..)` can be simplified as `find_map(..)`
+  --> $DIR/manual_filter_map.rs:34:28
+   |
+LL |     iter::<&Option<&u8>>().find(|x| x.is_some()).map(|x| x.cloned().unwrap());
+   |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|x| x.cloned())`
+
+error: `find(..).map(..)` can be simplified as `find_map(..)`
+  --> $DIR/manual_filter_map.rs:35:31
+   |
+LL |     iter::<&Option<String>>().find(|x| x.is_some()).map(|x| x.as_deref().unwrap());
+   |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|x| x.as_deref())`
+
+error: `find(..).map(..)` can be simplified as `find_map(..)`
+  --> $DIR/manual_filter_map.rs:36:31
+   |
+LL |     iter::<Option<&String>>().find(|&x| to_ref(x).is_some()).map(|y| to_ref(y).cloned().unwrap());
+   |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|y| to_ref(y).cloned())`
+
+error: `find(..).map(..)` can be simplified as `find_map(..)`
+  --> $DIR/manual_filter_map.rs:38:30
+   |
+LL |     iter::<Result<u8, ()>>().find(|x| x.is_ok()).map(|x| x.unwrap());
+   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|x| x.ok())`
+
+error: `find(..).map(..)` can be simplified as `find_map(..)`
+  --> $DIR/manual_filter_map.rs:39:31
+   |
+LL |     iter::<&Result<u8, ()>>().find(|x| x.is_ok()).map(|x| x.unwrap());
+   |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|x| x.ok())`
+
+error: `find(..).map(..)` can be simplified as `find_map(..)`
+  --> $DIR/manual_filter_map.rs:40:32
+   |
+LL |     iter::<&&Result<u8, ()>>().find(|x| x.is_ok()).map(|x| x.unwrap());
+   |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|x| x.ok())`
+
+error: `find(..).map(..)` can be simplified as `find_map(..)`
+  --> $DIR/manual_filter_map.rs:41:31
+   |
+LL |     iter::<Result<&u8, ()>>().find(|x| x.is_ok()).map(|x| x.cloned().unwrap());
+   |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|x| x.cloned().ok())`
+
+error: `find(..).map(..)` can be simplified as `find_map(..)`
+  --> $DIR/manual_filter_map.rs:42:32
+   |
+LL |     iter::<&Result<&u8, ()>>().find(|x| x.is_ok()).map(|x| x.cloned().unwrap());
+   |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|x| x.cloned().ok())`
+
+error: `find(..).map(..)` can be simplified as `find_map(..)`
+  --> $DIR/manual_filter_map.rs:43:35
+   |
+LL |     iter::<&Result<String, ()>>().find(|x| x.is_ok()).map(|x| x.as_deref().unwrap());
+   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|x| x.as_deref().ok())`
+
+error: `find(..).map(..)` can be simplified as `find_map(..)`
+  --> $DIR/manual_filter_map.rs:44:35
+   |
+LL |     iter::<Result<&String, ()>>().find(|&x| to_ref(x).is_ok()).map(|y| to_ref(y).cloned().unwrap());
+   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|y| to_ref(y).cloned().ok())`
+
+error: `filter(..).map(..)` can be simplified as `filter_map(..)`
+  --> $DIR/manual_filter_map.rs:92:10
    |
 LL |           .filter(|f| f.option_field.is_some())
    |  __________^
@@ -27,7 +127,7 @@ LL | |         .map(|f| f.option_field.clone().unwrap());
    | |_________________________________________________^ help: try: `filter_map(|f| f.option_field.clone())`
 
 error: `filter(..).map(..)` can be simplified as `filter_map(..)`
-  --> $DIR/manual_filter_map.rs:59:10
+  --> $DIR/manual_filter_map.rs:97:10
    |
 LL |           .filter(|f| f.ref_field.is_some())
    |  __________^
@@ -35,7 +135,7 @@ LL | |         .map(|f| f.ref_field.cloned().unwrap());
    | |_______________________________________________^ help: try: `filter_map(|f| f.ref_field.cloned())`
 
 error: `filter(..).map(..)` can be simplified as `filter_map(..)`
-  --> $DIR/manual_filter_map.rs:64:10
+  --> $DIR/manual_filter_map.rs:102:10
    |
 LL |           .filter(|f| f.ref_field.is_some())
    |  __________^
@@ -43,7 +143,7 @@ LL | |         .map(|f| f.ref_field.copied().unwrap());
    | |_______________________________________________^ help: try: `filter_map(|f| f.ref_field.copied())`
 
 error: `filter(..).map(..)` can be simplified as `filter_map(..)`
-  --> $DIR/manual_filter_map.rs:69:10
+  --> $DIR/manual_filter_map.rs:107:10
    |
 LL |           .filter(|f| f.result_field.is_ok())
    |  __________^
@@ -51,7 +151,7 @@ LL | |         .map(|f| f.result_field.clone().unwrap());
    | |_________________________________________________^ help: try: `filter_map(|f| f.result_field.clone().ok())`
 
 error: `filter(..).map(..)` can be simplified as `filter_map(..)`
-  --> $DIR/manual_filter_map.rs:74:10
+  --> $DIR/manual_filter_map.rs:112:10
    |
 LL |           .filter(|f| f.result_field.is_ok())
    |  __________^
@@ -59,7 +159,7 @@ LL | |         .map(|f| f.result_field.as_ref().unwrap());
    | |__________________________________________________^ help: try: `filter_map(|f| f.result_field.as_ref().ok())`
 
 error: `filter(..).map(..)` can be simplified as `filter_map(..)`
-  --> $DIR/manual_filter_map.rs:79:10
+  --> $DIR/manual_filter_map.rs:117:10
    |
 LL |           .filter(|f| f.result_field.is_ok())
    |  __________^
@@ -67,7 +167,7 @@ LL | |         .map(|f| f.result_field.as_deref().unwrap());
    | |____________________________________________________^ help: try: `filter_map(|f| f.result_field.as_deref().ok())`
 
 error: `filter(..).map(..)` can be simplified as `filter_map(..)`
-  --> $DIR/manual_filter_map.rs:84:10
+  --> $DIR/manual_filter_map.rs:122:10
    |
 LL |           .filter(|f| f.result_field.is_ok())
    |  __________^
@@ -75,7 +175,7 @@ LL | |         .map(|f| f.result_field.as_mut().unwrap());
    | |__________________________________________________^ help: try: `filter_map(|f| f.result_field.as_mut().ok())`
 
 error: `filter(..).map(..)` can be simplified as `filter_map(..)`
-  --> $DIR/manual_filter_map.rs:89:10
+  --> $DIR/manual_filter_map.rs:127:10
    |
 LL |           .filter(|f| f.result_field.is_ok())
    |  __________^
@@ -83,12 +183,12 @@ LL | |         .map(|f| f.result_field.as_deref_mut().unwrap());
    | |________________________________________________________^ help: try: `filter_map(|f| f.result_field.as_deref_mut().ok())`
 
 error: `filter(..).map(..)` can be simplified as `filter_map(..)`
-  --> $DIR/manual_filter_map.rs:94:10
+  --> $DIR/manual_filter_map.rs:132:10
    |
 LL |           .filter(|f| f.result_field.is_ok())
    |  __________^
 LL | |         .map(|f| f.result_field.to_owned().unwrap());
    | |____________________________________________________^ help: try: `filter_map(|f| f.result_field.to_owned().ok())`
 
-error: aborting due to 12 previous errors
+error: aborting due to 27 previous errors
 
diff --git a/tests/ui/manual_find_map.fixed b/tests/ui/manual_find_map.fixed
index d69b6c1dcf3..54302beceff 100644
--- a/tests/ui/manual_find_map.fixed
+++ b/tests/ui/manual_find_map.fixed
@@ -12,6 +12,35 @@ fn main() {
 
     // is_ok(), unwrap_or()
     let _ = (0..).find_map(|a| to_res(a).ok());
+
+    let _ = (1..5)
+        .find_map(|y| *to_ref(to_opt(y)));
+    let _ = (1..5)
+        .find_map(|y| *to_ref(to_opt(y)));
+
+    let _ = (1..5)
+        .find_map(|y| to_ref(to_res(y)).ok());
+    let _ = (1..5)
+        .find_map(|y| to_ref(to_res(y)).ok());
+}
+
+#[rustfmt::skip]
+fn simple_equal() {
+    iter::<Option<u8>>().find_map(|x| x);
+    iter::<&Option<u8>>().find_map(|x| *x);
+    iter::<&&Option<u8>>().find_map(|x| **x);
+    iter::<Option<&u8>>().find_map(|x| x.cloned());
+    iter::<&Option<&u8>>().find_map(|x| x.cloned());
+    iter::<&Option<String>>().find_map(|x| x.as_deref());
+    iter::<Option<&String>>().find_map(|y| to_ref(y).cloned());
+
+    iter::<Result<u8, ()>>().find_map(|x| x.ok());
+    iter::<&Result<u8, ()>>().find_map(|x| x.ok());
+    iter::<&&Result<u8, ()>>().find_map(|x| x.ok());
+    iter::<Result<&u8, ()>>().find_map(|x| x.cloned().ok());
+    iter::<&Result<&u8, ()>>().find_map(|x| x.cloned().ok());
+    iter::<&Result<String, ()>>().find_map(|x| x.as_deref().ok());
+    iter::<Result<&String, ()>>().find_map(|y| to_ref(y).cloned().ok());
 }
 
 fn no_lint() {
@@ -28,6 +57,10 @@ fn no_lint() {
         .map(|a| to_opt(a).unwrap());
 }
 
+fn iter<T>() -> impl Iterator<Item = T> {
+    std::iter::empty()
+}
+
 fn to_opt<T>(_: T) -> Option<T> {
     unimplemented!()
 }
@@ -36,6 +69,10 @@ fn to_res<T>(_: T) -> Result<T, ()> {
     unimplemented!()
 }
 
+fn to_ref<'a, T>(_: T) -> &'a T {
+    unimplemented!()
+}
+
 struct Issue8920<'a> {
     option_field: Option<String>,
     result_field: Result<String, ()>,
diff --git a/tests/ui/manual_find_map.rs b/tests/ui/manual_find_map.rs
index 1c4e18e31c8..afcc1825a9a 100644
--- a/tests/ui/manual_find_map.rs
+++ b/tests/ui/manual_find_map.rs
@@ -12,6 +12,39 @@ fn main() {
 
     // is_ok(), unwrap_or()
     let _ = (0..).find(|&n| to_res(n).is_ok()).map(|a| to_res(a).unwrap_or(1));
+
+    let _ = (1..5)
+        .find(|&x| to_ref(to_opt(x)).is_some())
+        .map(|y| to_ref(to_opt(y)).unwrap());
+    let _ = (1..5)
+        .find(|x| to_ref(to_opt(*x)).is_some())
+        .map(|y| to_ref(to_opt(y)).unwrap());
+
+    let _ = (1..5)
+        .find(|&x| to_ref(to_res(x)).is_ok())
+        .map(|y| to_ref(to_res(y)).unwrap());
+    let _ = (1..5)
+        .find(|x| to_ref(to_res(*x)).is_ok())
+        .map(|y| to_ref(to_res(y)).unwrap());
+}
+
+#[rustfmt::skip]
+fn simple_equal() {
+    iter::<Option<u8>>().find(|x| x.is_some()).map(|x| x.unwrap());
+    iter::<&Option<u8>>().find(|x| x.is_some()).map(|x| x.unwrap());
+    iter::<&&Option<u8>>().find(|x| x.is_some()).map(|x| x.unwrap());
+    iter::<Option<&u8>>().find(|x| x.is_some()).map(|x| x.cloned().unwrap());
+    iter::<&Option<&u8>>().find(|x| x.is_some()).map(|x| x.cloned().unwrap());
+    iter::<&Option<String>>().find(|x| x.is_some()).map(|x| x.as_deref().unwrap());
+    iter::<Option<&String>>().find(|&x| to_ref(x).is_some()).map(|y| to_ref(y).cloned().unwrap());
+
+    iter::<Result<u8, ()>>().find(|x| x.is_ok()).map(|x| x.unwrap());
+    iter::<&Result<u8, ()>>().find(|x| x.is_ok()).map(|x| x.unwrap());
+    iter::<&&Result<u8, ()>>().find(|x| x.is_ok()).map(|x| x.unwrap());
+    iter::<Result<&u8, ()>>().find(|x| x.is_ok()).map(|x| x.cloned().unwrap());
+    iter::<&Result<&u8, ()>>().find(|x| x.is_ok()).map(|x| x.cloned().unwrap());
+    iter::<&Result<String, ()>>().find(|x| x.is_ok()).map(|x| x.as_deref().unwrap());
+    iter::<Result<&String, ()>>().find(|&x| to_ref(x).is_ok()).map(|y| to_ref(y).cloned().unwrap());
 }
 
 fn no_lint() {
@@ -28,6 +61,10 @@ fn no_lint() {
         .map(|a| to_opt(a).unwrap());
 }
 
+fn iter<T>() -> impl Iterator<Item = T> {
+    std::iter::empty()
+}
+
 fn to_opt<T>(_: T) -> Option<T> {
     unimplemented!()
 }
@@ -36,6 +73,10 @@ fn to_res<T>(_: T) -> Result<T, ()> {
     unimplemented!()
 }
 
+fn to_ref<'a, T>(_: T) -> &'a T {
+    unimplemented!()
+}
+
 struct Issue8920<'a> {
     option_field: Option<String>,
     result_field: Result<String, ()>,
diff --git a/tests/ui/manual_find_map.stderr b/tests/ui/manual_find_map.stderr
index 9dea42b7686..c1ac499f7c6 100644
--- a/tests/ui/manual_find_map.stderr
+++ b/tests/ui/manual_find_map.stderr
@@ -19,7 +19,123 @@ LL |     let _ = (0..).find(|&n| to_res(n).is_ok()).map(|a| to_res(a).unwrap_or(
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|a| to_res(a).ok())`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> $DIR/manual_find_map.rs:54:10
+  --> $DIR/manual_find_map.rs:17:10
+   |
+LL |           .find(|&x| to_ref(to_opt(x)).is_some())
+   |  __________^
+LL | |         .map(|y| to_ref(to_opt(y)).unwrap());
+   | |____________________________________________^ help: try: `find_map(|y| *to_ref(to_opt(y)))`
+
+error: `find(..).map(..)` can be simplified as `find_map(..)`
+  --> $DIR/manual_find_map.rs:20:10
+   |
+LL |           .find(|x| to_ref(to_opt(*x)).is_some())
+   |  __________^
+LL | |         .map(|y| to_ref(to_opt(y)).unwrap());
+   | |____________________________________________^ help: try: `find_map(|y| *to_ref(to_opt(y)))`
+
+error: `find(..).map(..)` can be simplified as `find_map(..)`
+  --> $DIR/manual_find_map.rs:24:10
+   |
+LL |           .find(|&x| to_ref(to_res(x)).is_ok())
+   |  __________^
+LL | |         .map(|y| to_ref(to_res(y)).unwrap());
+   | |____________________________________________^ help: try: `find_map(|y| to_ref(to_res(y)).ok())`
+
+error: `find(..).map(..)` can be simplified as `find_map(..)`
+  --> $DIR/manual_find_map.rs:27:10
+   |
+LL |           .find(|x| to_ref(to_res(*x)).is_ok())
+   |  __________^
+LL | |         .map(|y| to_ref(to_res(y)).unwrap());
+   | |____________________________________________^ help: try: `find_map(|y| to_ref(to_res(y)).ok())`
+
+error: `find(..).map(..)` can be simplified as `find_map(..)`
+  --> $DIR/manual_find_map.rs:33:26
+   |
+LL |     iter::<Option<u8>>().find(|x| x.is_some()).map(|x| x.unwrap());
+   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|x| x)`
+
+error: `find(..).map(..)` can be simplified as `find_map(..)`
+  --> $DIR/manual_find_map.rs:34:27
+   |
+LL |     iter::<&Option<u8>>().find(|x| x.is_some()).map(|x| x.unwrap());
+   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|x| *x)`
+
+error: `find(..).map(..)` can be simplified as `find_map(..)`
+  --> $DIR/manual_find_map.rs:35:28
+   |
+LL |     iter::<&&Option<u8>>().find(|x| x.is_some()).map(|x| x.unwrap());
+   |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|x| **x)`
+
+error: `find(..).map(..)` can be simplified as `find_map(..)`
+  --> $DIR/manual_find_map.rs:36:27
+   |
+LL |     iter::<Option<&u8>>().find(|x| x.is_some()).map(|x| x.cloned().unwrap());
+   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|x| x.cloned())`
+
+error: `find(..).map(..)` can be simplified as `find_map(..)`
+  --> $DIR/manual_find_map.rs:37:28
+   |
+LL |     iter::<&Option<&u8>>().find(|x| x.is_some()).map(|x| x.cloned().unwrap());
+   |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|x| x.cloned())`
+
+error: `find(..).map(..)` can be simplified as `find_map(..)`
+  --> $DIR/manual_find_map.rs:38:31
+   |
+LL |     iter::<&Option<String>>().find(|x| x.is_some()).map(|x| x.as_deref().unwrap());
+   |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|x| x.as_deref())`
+
+error: `find(..).map(..)` can be simplified as `find_map(..)`
+  --> $DIR/manual_find_map.rs:39:31
+   |
+LL |     iter::<Option<&String>>().find(|&x| to_ref(x).is_some()).map(|y| to_ref(y).cloned().unwrap());
+   |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|y| to_ref(y).cloned())`
+
+error: `find(..).map(..)` can be simplified as `find_map(..)`
+  --> $DIR/manual_find_map.rs:41:30
+   |
+LL |     iter::<Result<u8, ()>>().find(|x| x.is_ok()).map(|x| x.unwrap());
+   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|x| x.ok())`
+
+error: `find(..).map(..)` can be simplified as `find_map(..)`
+  --> $DIR/manual_find_map.rs:42:31
+   |
+LL |     iter::<&Result<u8, ()>>().find(|x| x.is_ok()).map(|x| x.unwrap());
+   |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|x| x.ok())`
+
+error: `find(..).map(..)` can be simplified as `find_map(..)`
+  --> $DIR/manual_find_map.rs:43:32
+   |
+LL |     iter::<&&Result<u8, ()>>().find(|x| x.is_ok()).map(|x| x.unwrap());
+   |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|x| x.ok())`
+
+error: `find(..).map(..)` can be simplified as `find_map(..)`
+  --> $DIR/manual_find_map.rs:44:31
+   |
+LL |     iter::<Result<&u8, ()>>().find(|x| x.is_ok()).map(|x| x.cloned().unwrap());
+   |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|x| x.cloned().ok())`
+
+error: `find(..).map(..)` can be simplified as `find_map(..)`
+  --> $DIR/manual_find_map.rs:45:32
+   |
+LL |     iter::<&Result<&u8, ()>>().find(|x| x.is_ok()).map(|x| x.cloned().unwrap());
+   |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|x| x.cloned().ok())`
+
+error: `find(..).map(..)` can be simplified as `find_map(..)`
+  --> $DIR/manual_find_map.rs:46:35
+   |
+LL |     iter::<&Result<String, ()>>().find(|x| x.is_ok()).map(|x| x.as_deref().unwrap());
+   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|x| x.as_deref().ok())`
+
+error: `find(..).map(..)` can be simplified as `find_map(..)`
+  --> $DIR/manual_find_map.rs:47:35
+   |
+LL |     iter::<Result<&String, ()>>().find(|&x| to_ref(x).is_ok()).map(|y| to_ref(y).cloned().unwrap());
+   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|y| to_ref(y).cloned().ok())`
+
+error: `find(..).map(..)` can be simplified as `find_map(..)`
+  --> $DIR/manual_find_map.rs:95:10
    |
 LL |           .find(|f| f.option_field.is_some())
    |  __________^
@@ -27,7 +143,7 @@ LL | |         .map(|f| f.option_field.clone().unwrap());
    | |_________________________________________________^ help: try: `find_map(|f| f.option_field.clone())`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> $DIR/manual_find_map.rs:59:10
+  --> $DIR/manual_find_map.rs:100:10
    |
 LL |           .find(|f| f.ref_field.is_some())
    |  __________^
@@ -35,7 +151,7 @@ LL | |         .map(|f| f.ref_field.cloned().unwrap());
    | |_______________________________________________^ help: try: `find_map(|f| f.ref_field.cloned())`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> $DIR/manual_find_map.rs:64:10
+  --> $DIR/manual_find_map.rs:105:10
    |
 LL |           .find(|f| f.ref_field.is_some())
    |  __________^
@@ -43,7 +159,7 @@ LL | |         .map(|f| f.ref_field.copied().unwrap());
    | |_______________________________________________^ help: try: `find_map(|f| f.ref_field.copied())`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> $DIR/manual_find_map.rs:69:10
+  --> $DIR/manual_find_map.rs:110:10
    |
 LL |           .find(|f| f.result_field.is_ok())
    |  __________^
@@ -51,7 +167,7 @@ LL | |         .map(|f| f.result_field.clone().unwrap());
    | |_________________________________________________^ help: try: `find_map(|f| f.result_field.clone().ok())`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> $DIR/manual_find_map.rs:74:10
+  --> $DIR/manual_find_map.rs:115:10
    |
 LL |           .find(|f| f.result_field.is_ok())
    |  __________^
@@ -59,7 +175,7 @@ LL | |         .map(|f| f.result_field.as_ref().unwrap());
    | |__________________________________________________^ help: try: `find_map(|f| f.result_field.as_ref().ok())`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> $DIR/manual_find_map.rs:79:10
+  --> $DIR/manual_find_map.rs:120:10
    |
 LL |           .find(|f| f.result_field.is_ok())
    |  __________^
@@ -67,7 +183,7 @@ LL | |         .map(|f| f.result_field.as_deref().unwrap());
    | |____________________________________________________^ help: try: `find_map(|f| f.result_field.as_deref().ok())`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> $DIR/manual_find_map.rs:84:10
+  --> $DIR/manual_find_map.rs:125:10
    |
 LL |           .find(|f| f.result_field.is_ok())
    |  __________^
@@ -75,7 +191,7 @@ LL | |         .map(|f| f.result_field.as_mut().unwrap());
    | |__________________________________________________^ help: try: `find_map(|f| f.result_field.as_mut().ok())`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> $DIR/manual_find_map.rs:89:10
+  --> $DIR/manual_find_map.rs:130:10
    |
 LL |           .find(|f| f.result_field.is_ok())
    |  __________^
@@ -83,12 +199,12 @@ LL | |         .map(|f| f.result_field.as_deref_mut().unwrap());
    | |________________________________________________________^ help: try: `find_map(|f| f.result_field.as_deref_mut().ok())`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> $DIR/manual_find_map.rs:94:10
+  --> $DIR/manual_find_map.rs:135:10
    |
 LL |           .find(|f| f.result_field.is_ok())
    |  __________^
 LL | |         .map(|f| f.result_field.to_owned().unwrap());
    | |____________________________________________________^ help: try: `find_map(|f| f.result_field.to_owned().ok())`
 
-error: aborting due to 12 previous errors
+error: aborting due to 30 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 196174ddad8cac276db8d44c22c7739f614a0fbc Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Fri, 17 Jun 2022 22:21:42 -0400
Subject: Changes to `let_unit_value` * View through locals in `let_unit_value`
 when determining if inference is required * Don't remove typed let bindings
 for more functions

---
 clippy_lints/src/unit_types/let_unit_value.rs | 127 ++++++++++++++++++--------
 clippy_lints/src/unit_types/mod.rs            |   4 +-
 clippy_utils/src/visitors.rs                  |  46 ++++++++++
 tests/ui/let_unit.fixed                       |  62 +++++++++++--
 tests/ui/let_unit.rs                          |  62 +++++++++++--
 tests/ui/let_unit.stderr                      |  38 ++++----
 6 files changed, 266 insertions(+), 73 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unit_types/let_unit_value.rs b/clippy_lints/src/unit_types/let_unit_value.rs
index 17d60a40dce..c98f9e01a8d 100644
--- a/clippy_lints/src/unit_types/let_unit_value.rs
+++ b/clippy_lints/src/unit_types/let_unit_value.rs
@@ -1,29 +1,24 @@
 use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::get_parent_node;
 use clippy_utils::source::snippet_with_macro_callsite;
-use clippy_utils::visitors::for_each_value_source;
+use clippy_utils::visitors::{for_each_local_assignment, for_each_value_source};
 use core::ops::ControlFlow;
 use rustc_errors::Applicability;
 use rustc_hir::def::{DefKind, Res};
-use rustc_hir::{Expr, ExprKind, Local, PatKind};
+use rustc_hir::{Expr, ExprKind, HirId, HirIdSet, Local, Node, PatKind, QPath, TyKind};
 use rustc_lint::{LateContext, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_middle::ty::{self, Ty, TypeFoldable, TypeSuperFoldable, TypeVisitor};
+use rustc_middle::ty;
 
 use super::LET_UNIT_VALUE;
 
-pub(super) fn check(cx: &LateContext<'_>, local: &Local<'_>) {
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, local: &'tcx Local<'_>) {
     if let Some(init) = local.init
         && !local.pat.span.from_expansion()
         && !in_external_macro(cx.sess(), local.span)
         && cx.typeck_results().pat_ty(local.pat).is_unit()
     {
-        let needs_inferred = for_each_value_source(init, &mut |e| if needs_inferred_result_ty(cx, e) {
-            ControlFlow::Continue(())
-        } else {
-            ControlFlow::Break(())
-        }).is_continue();
-
-        if needs_inferred {
+        if local.ty.is_some() && expr_needs_inferred_result(cx, init) {
             if !matches!(local.pat.kind, PatKind::Wild) {
                 span_lint_and_then(
                     cx,
@@ -62,48 +57,106 @@ pub(super) fn check(cx: &LateContext<'_>, local: &Local<'_>) {
     }
 }
 
-fn needs_inferred_result_ty(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
-    let id = match e.kind {
+/// Checks sub-expressions which create the value returned by the given expression for whether
+/// return value inference is needed. This checks through locals to see if they also need inference
+/// at this point.
+///
+/// e.g.
+/// ```rust,ignore
+/// let bar = foo();
+/// let x: u32 = if true { baz() } else { bar };
+/// ```
+/// Here the sources of the value assigned to `x` would be `baz()`, and `foo()` via the
+/// initialization of `bar`. If both `foo` and `baz` have a return type which require type
+/// inference then this function would return `true`.
+fn expr_needs_inferred_result<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> bool {
+    // The locals used for initialization which have yet to be checked.
+    let mut locals_to_check = Vec::new();
+    // All the locals which have been added to `locals_to_check`. Needed to prevent cycles.
+    let mut seen_locals = HirIdSet::default();
+    if !each_value_source_needs_inference(cx, e, &mut locals_to_check, &mut seen_locals) {
+        return false;
+    }
+    while let Some(id) = locals_to_check.pop() {
+        if let Some(Node::Local(l)) = get_parent_node(cx.tcx, id) {
+            if !l.ty.map_or(true, |ty| matches!(ty.kind, TyKind::Infer)) {
+                return false;
+            }
+            if let Some(e) = l.init {
+                if !each_value_source_needs_inference(cx, e, &mut locals_to_check, &mut seen_locals) {
+                    return false;
+                }
+            } else if for_each_local_assignment(cx, id, |e| {
+                if each_value_source_needs_inference(cx, e, &mut locals_to_check, &mut seen_locals) {
+                    ControlFlow::Continue(())
+                } else {
+                    ControlFlow::Break(())
+                }
+            })
+            .is_break()
+            {
+                return false;
+            }
+        }
+    }
+
+    true
+}
+
+fn each_value_source_needs_inference(
+    cx: &LateContext<'_>,
+    e: &Expr<'_>,
+    locals_to_check: &mut Vec<HirId>,
+    seen_locals: &mut HirIdSet,
+) -> bool {
+    for_each_value_source(e, &mut |e| {
+        if needs_inferred_result_ty(cx, e, locals_to_check, seen_locals) {
+            ControlFlow::Continue(())
+        } else {
+            ControlFlow::Break(())
+        }
+    })
+    .is_continue()
+}
+
+fn needs_inferred_result_ty(
+    cx: &LateContext<'_>,
+    e: &Expr<'_>,
+    locals_to_check: &mut Vec<HirId>,
+    seen_locals: &mut HirIdSet,
+) -> bool {
+    let (id, args) = match e.kind {
         ExprKind::Call(
             Expr {
                 kind: ExprKind::Path(ref path),
                 hir_id,
                 ..
             },
-            _,
+            args,
         ) => match cx.qpath_res(path, *hir_id) {
-            Res::Def(DefKind::AssocFn | DefKind::Fn, id) => id,
+            Res::Def(DefKind::AssocFn | DefKind::Fn, id) => (id, args),
             _ => return false,
         },
-        ExprKind::MethodCall(..) => match cx.typeck_results().type_dependent_def_id(e.hir_id) {
-            Some(id) => id,
+        ExprKind::MethodCall(_, args, _) => match cx.typeck_results().type_dependent_def_id(e.hir_id) {
+            Some(id) => (id, args),
             None => return false,
         },
+        ExprKind::Path(QPath::Resolved(None, path)) => {
+            if let Res::Local(id) = path.res
+                && seen_locals.insert(id)
+            {
+                locals_to_check.push(id);
+            }
+            return true;
+        },
         _ => return false,
     };
     let sig = cx.tcx.fn_sig(id).skip_binder();
     if let ty::Param(output_ty) = *sig.output().kind() {
-        sig.inputs().iter().all(|&ty| !ty_contains_param(ty, output_ty.index))
+        sig.inputs().iter().zip(args).all(|(&ty, arg)| {
+            !ty.is_param(output_ty.index) || each_value_source_needs_inference(cx, arg, locals_to_check, seen_locals)
+        })
     } else {
         false
     }
 }
-
-fn ty_contains_param(ty: Ty<'_>, index: u32) -> bool {
-    struct Visitor(u32);
-    impl<'tcx> TypeVisitor<'tcx> for Visitor {
-        type BreakTy = ();
-        fn visit_ty(&mut self, ty: Ty<'tcx>) -> ControlFlow<Self::BreakTy> {
-            if let ty::Param(ty) = *ty.kind() {
-                if ty.index == self.0 {
-                    ControlFlow::BREAK
-                } else {
-                    ControlFlow::CONTINUE
-                }
-            } else {
-                ty.super_visit_with(self)
-            }
-        }
-    }
-    ty.visit_with(&mut Visitor(index)).is_break()
-}
diff --git a/clippy_lints/src/unit_types/mod.rs b/clippy_lints/src/unit_types/mod.rs
index e57d4fc3b89..6aa86a57c9b 100644
--- a/clippy_lints/src/unit_types/mod.rs
+++ b/clippy_lints/src/unit_types/mod.rs
@@ -98,8 +98,8 @@ declare_clippy_lint! {
 
 declare_lint_pass!(UnitTypes => [LET_UNIT_VALUE, UNIT_CMP, UNIT_ARG]);
 
-impl LateLintPass<'_> for UnitTypes {
-    fn check_local(&mut self, cx: &LateContext<'_>, local: &Local<'_>) {
+impl<'tcx> LateLintPass<'tcx> for UnitTypes {
+    fn check_local(&mut self, cx: &LateContext<'tcx>, local: &'tcx Local<'tcx>) {
         let_unit_value::check(cx, local);
     }
 
diff --git a/clippy_utils/src/visitors.rs b/clippy_utils/src/visitors.rs
index 68cfa8c1aa8..e89a46b8538 100644
--- a/clippy_utils/src/visitors.rs
+++ b/clippy_utils/src/visitors.rs
@@ -617,3 +617,49 @@ pub fn any_temporaries_need_ordered_drop<'tcx>(cx: &LateContext<'tcx>, e: &'tcx
     })
     .is_break()
 }
+
+/// Runs the given function for each path expression referencing the given local which occur after
+/// the given expression.
+pub fn for_each_local_assignment<'tcx, B>(
+    cx: &LateContext<'tcx>,
+    local_id: HirId,
+    f: impl FnMut(&'tcx Expr<'tcx>) -> ControlFlow<B>,
+) -> ControlFlow<B> {
+    struct V<'cx, 'tcx, F, B> {
+        cx: &'cx LateContext<'tcx>,
+        local_id: HirId,
+        res: ControlFlow<B>,
+        f: F,
+    }
+    impl<'cx, 'tcx, F: FnMut(&'tcx Expr<'tcx>) -> ControlFlow<B>, B> Visitor<'tcx> for V<'cx, 'tcx, F, B> {
+        type NestedFilter = nested_filter::OnlyBodies;
+        fn nested_visit_map(&mut self) -> Self::Map {
+            self.cx.tcx.hir()
+        }
+
+        fn visit_expr(&mut self, e: &'tcx Expr<'tcx>) {
+            if let ExprKind::Assign(lhs, rhs, _) = e.kind
+                && self.res.is_continue()
+                && path_to_local_id(lhs, self.local_id)
+            {
+                self.res = (self.f)(rhs);
+                self.visit_expr(rhs);
+            } else {
+                walk_expr(self, e);
+            }
+        }
+    }
+
+    if let Some(b) = get_enclosing_block(cx, local_id) {
+        let mut v = V {
+            cx,
+            local_id,
+            res: ControlFlow::Continue(()),
+            f,
+        };
+        v.visit_block(b);
+        v.res
+    } else {
+        ControlFlow::Continue(())
+    }
+}
diff --git a/tests/ui/let_unit.fixed b/tests/ui/let_unit.fixed
index 18c2672f880..3d2a9635d75 100644
--- a/tests/ui/let_unit.fixed
+++ b/tests/ui/let_unit.fixed
@@ -2,8 +2,7 @@
 
 #![feature(lint_reasons)]
 #![warn(clippy::let_unit_value)]
-#![allow(clippy::no_effect)]
-#![allow(unused)]
+#![allow(unused, clippy::no_effect, clippy::needless_late_init, path_statements)]
 
 macro_rules! let_and_return {
     ($n:expr) => {{
@@ -73,8 +72,8 @@ fn _returns_generic() {
     fn f3<T>(x: T) -> T {
         x
     }
-    fn f4<T>(mut x: Vec<T>) -> T {
-        x.pop().unwrap()
+    fn f5<T: Default>(x: bool) -> Option<T> {
+        x.then(|| T::default())
     }
 
     let _: () = f(); // Ok
@@ -86,8 +85,12 @@ fn _returns_generic() {
     f3(()); // Lint
     f3(()); // Lint
 
-    f4(vec![()]); // Lint
-    f4(vec![()]); // Lint
+    // Should lint:
+    // fn f4<T>(mut x: Vec<T>) -> T {
+    //    x.pop().unwrap()
+    // }
+    // let _: () = f4(vec![()]);
+    // let x: () = f4(vec![()]);
 
     // Ok
     let _: () = {
@@ -113,6 +116,53 @@ fn _returns_generic() {
         Some(1) => f2(3),
         Some(_) => (),
     };
+
+    let _: () = f5(true).unwrap();
+
+    #[allow(clippy::let_unit_value)]
+    {
+        let x = f();
+        let y;
+        let z;
+        match 0 {
+            0 => {
+                y = f();
+                z = f();
+            },
+            1 => {
+                println!("test");
+                y = f();
+                z = f3(());
+            },
+            _ => panic!(),
+        }
+
+        let x1;
+        let x2;
+        if true {
+            x1 = f();
+            x2 = x1;
+        } else {
+            x2 = f();
+            x1 = x2;
+        }
+
+        let opt;
+        match f5(true) {
+            Some(x) => opt = x,
+            None => panic!(),
+        };
+
+        #[warn(clippy::let_unit_value)]
+        {
+            let _: () = x;
+            let _: () = y;
+            z;
+            let _: () = x1;
+            let _: () = x2;
+            let _: () = opt;
+        }
+    }
 }
 
 fn attributes() {
diff --git a/tests/ui/let_unit.rs b/tests/ui/let_unit.rs
index c9c4582a956..625927f76f1 100644
--- a/tests/ui/let_unit.rs
+++ b/tests/ui/let_unit.rs
@@ -2,8 +2,7 @@
 
 #![feature(lint_reasons)]
 #![warn(clippy::let_unit_value)]
-#![allow(clippy::no_effect)]
-#![allow(unused)]
+#![allow(unused, clippy::no_effect, clippy::needless_late_init, path_statements)]
 
 macro_rules! let_and_return {
     ($n:expr) => {{
@@ -73,8 +72,8 @@ fn _returns_generic() {
     fn f3<T>(x: T) -> T {
         x
     }
-    fn f4<T>(mut x: Vec<T>) -> T {
-        x.pop().unwrap()
+    fn f5<T: Default>(x: bool) -> Option<T> {
+        x.then(|| T::default())
     }
 
     let _: () = f(); // Ok
@@ -86,8 +85,12 @@ fn _returns_generic() {
     let _: () = f3(()); // Lint
     let x: () = f3(()); // Lint
 
-    let _: () = f4(vec![()]); // Lint
-    let x: () = f4(vec![()]); // Lint
+    // Should lint:
+    // fn f4<T>(mut x: Vec<T>) -> T {
+    //    x.pop().unwrap()
+    // }
+    // let _: () = f4(vec![()]);
+    // let x: () = f4(vec![()]);
 
     // Ok
     let _: () = {
@@ -113,6 +116,53 @@ fn _returns_generic() {
         Some(1) => f2(3),
         Some(_) => (),
     };
+
+    let _: () = f5(true).unwrap();
+
+    #[allow(clippy::let_unit_value)]
+    {
+        let x = f();
+        let y;
+        let z;
+        match 0 {
+            0 => {
+                y = f();
+                z = f();
+            },
+            1 => {
+                println!("test");
+                y = f();
+                z = f3(());
+            },
+            _ => panic!(),
+        }
+
+        let x1;
+        let x2;
+        if true {
+            x1 = f();
+            x2 = x1;
+        } else {
+            x2 = f();
+            x1 = x2;
+        }
+
+        let opt;
+        match f5(true) {
+            Some(x) => opt = x,
+            None => panic!(),
+        };
+
+        #[warn(clippy::let_unit_value)]
+        {
+            let _: () = x;
+            let _: () = y;
+            let _: () = z;
+            let _: () = x1;
+            let _: () = x2;
+            let _: () = opt;
+        }
+    }
 }
 
 fn attributes() {
diff --git a/tests/ui/let_unit.stderr b/tests/ui/let_unit.stderr
index 47a2a6e3cc1..49da74ca7e1 100644
--- a/tests/ui/let_unit.stderr
+++ b/tests/ui/let_unit.stderr
@@ -1,5 +1,5 @@
 error: this let-binding has unit value
-  --> $DIR/let_unit.rs:15:5
+  --> $DIR/let_unit.rs:14:5
    |
 LL |     let _x = println!("x");
    |     ^^^^^^^^^^^^^^^^^^^^^^^ help: omit the `let` binding: `println!("x");`
@@ -7,13 +7,13 @@ LL |     let _x = println!("x");
    = note: `-D clippy::let-unit-value` implied by `-D warnings`
 
 error: this let-binding has unit value
-  --> $DIR/let_unit.rs:19:9
+  --> $DIR/let_unit.rs:18:9
    |
 LL |         let _a = ();
    |         ^^^^^^^^^^^^ help: omit the `let` binding: `();`
 
 error: this let-binding has unit value
-  --> $DIR/let_unit.rs:54:5
+  --> $DIR/let_unit.rs:53:5
    |
 LL | /     let _ = v
 LL | |         .into_iter()
@@ -36,7 +36,7 @@ LL +         .unwrap();
    |
 
 error: this let-binding has unit value
-  --> $DIR/let_unit.rs:81:5
+  --> $DIR/let_unit.rs:80:5
    |
 LL |     let x: () = f(); // Lint.
    |     ^^^^-^^^^^^^^^^^
@@ -44,7 +44,7 @@ LL |     let x: () = f(); // Lint.
    |         help: use a wild (`_`) binding: `_`
 
 error: this let-binding has unit value
-  --> $DIR/let_unit.rs:84:5
+  --> $DIR/let_unit.rs:83:5
    |
 LL |     let x: () = f2(0i32); // Lint.
    |     ^^^^-^^^^^^^^^^^^^^^^
@@ -52,31 +52,19 @@ LL |     let x: () = f2(0i32); // Lint.
    |         help: use a wild (`_`) binding: `_`
 
 error: this let-binding has unit value
-  --> $DIR/let_unit.rs:86:5
+  --> $DIR/let_unit.rs:85:5
    |
 LL |     let _: () = f3(()); // Lint
    |     ^^^^^^^^^^^^^^^^^^^ help: omit the `let` binding: `f3(());`
 
 error: this let-binding has unit value
-  --> $DIR/let_unit.rs:87:5
+  --> $DIR/let_unit.rs:86:5
    |
 LL |     let x: () = f3(()); // Lint
    |     ^^^^^^^^^^^^^^^^^^^ help: omit the `let` binding: `f3(());`
 
 error: this let-binding has unit value
-  --> $DIR/let_unit.rs:89:5
-   |
-LL |     let _: () = f4(vec![()]); // Lint
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^ help: omit the `let` binding: `f4(vec![()]);`
-
-error: this let-binding has unit value
-  --> $DIR/let_unit.rs:90:5
-   |
-LL |     let x: () = f4(vec![()]); // Lint
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^ help: omit the `let` binding: `f4(vec![()]);`
-
-error: this let-binding has unit value
-  --> $DIR/let_unit.rs:99:5
+  --> $DIR/let_unit.rs:102:5
    |
 LL |     let x: () = if true { f() } else { f2(0) }; // Lint
    |     ^^^^-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -84,7 +72,7 @@ LL |     let x: () = if true { f() } else { f2(0) }; // Lint
    |         help: use a wild (`_`) binding: `_`
 
 error: this let-binding has unit value
-  --> $DIR/let_unit.rs:110:5
+  --> $DIR/let_unit.rs:113:5
    |
 LL | /     let _: () = match Some(0) {
 LL | |         None => f2(1),
@@ -104,5 +92,11 @@ LL +         Some(_) => (),
 LL +     };
    |
 
-error: aborting due to 11 previous errors
+error: this let-binding has unit value
+  --> $DIR/let_unit.rs:160:13
+   |
+LL |             let _: () = z;
+   |             ^^^^^^^^^^^^^^ help: omit the `let` binding: `z;`
+
+error: aborting due to 10 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 2872b7e0a48e6ae41570804afa88bd12bf5f507a Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Mon, 27 Jun 2022 12:48:38 -0400
Subject: Allow `let () = ..` as type inference for `let_unit_value`

---
 clippy_lints/src/unit_types/let_unit_value.rs | 19 +++++++++++--------
 tests/ui/let_unit.fixed                       |  2 ++
 tests/ui/let_unit.rs                          |  2 ++
 3 files changed, 15 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unit_types/let_unit_value.rs b/clippy_lints/src/unit_types/let_unit_value.rs
index c98f9e01a8d..aec028d5c48 100644
--- a/clippy_lints/src/unit_types/let_unit_value.rs
+++ b/clippy_lints/src/unit_types/let_unit_value.rs
@@ -18,20 +18,23 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, local: &'tcx Local<'_>) {
         && !in_external_macro(cx.sess(), local.span)
         && cx.typeck_results().pat_ty(local.pat).is_unit()
     {
-        if local.ty.is_some() && expr_needs_inferred_result(cx, init) {
-            if !matches!(local.pat.kind, PatKind::Wild) {
+        if (local.ty.map_or(false, |ty| !matches!(ty.kind, TyKind::Infer))
+            || matches!(local.pat.kind, PatKind::Tuple([], None)))
+            && expr_needs_inferred_result(cx, init)
+        {
+            if !matches!(local.pat.kind, PatKind::Wild | PatKind::Tuple([], None)) {
                 span_lint_and_then(
                     cx,
                     LET_UNIT_VALUE,
                     local.span,
                     "this let-binding has unit value",
                     |diag| {
-                            diag.span_suggestion(
-                                local.pat.span,
-                                "use a wild (`_`) binding",
-                                "_",
-                                Applicability::MaybeIncorrect, // snippet
-                            );
+                        diag.span_suggestion(
+                            local.pat.span,
+                            "use a wild (`_`) binding",
+                            "_",
+                            Applicability::MaybeIncorrect, // snippet
+                        );
                     },
                 );
             }
diff --git a/tests/ui/let_unit.fixed b/tests/ui/let_unit.fixed
index 3d2a9635d75..6343cff0f7f 100644
--- a/tests/ui/let_unit.fixed
+++ b/tests/ui/let_unit.fixed
@@ -163,6 +163,8 @@ fn _returns_generic() {
             let _: () = opt;
         }
     }
+
+    let () = f();
 }
 
 fn attributes() {
diff --git a/tests/ui/let_unit.rs b/tests/ui/let_unit.rs
index 625927f76f1..c9bb2849f5c 100644
--- a/tests/ui/let_unit.rs
+++ b/tests/ui/let_unit.rs
@@ -163,6 +163,8 @@ fn _returns_generic() {
             let _: () = opt;
         }
     }
+
+    let () = f();
 }
 
 fn attributes() {
-- 
cgit 1.4.1-3-g733a5


From 9fa12def3c231f3b60f53d68c3787b8a82376843 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Thu, 7 Jul 2022 10:45:20 -0400
Subject: Improve `while_let_on_iterator` suggestion inside an `FnOnce` closure

---
 clippy_lints/src/loops/while_let_on_iterator.rs | 19 ++++--
 clippy_utils/src/lib.rs                         | 60 +++++++++++++++----
 clippy_utils/src/ty.rs                          | 48 ++++++++++++---
 tests/ui/while_let_on_iterator.fixed            | 46 ++++++++++++++-
 tests/ui/while_let_on_iterator.rs               | 46 ++++++++++++++-
 tests/ui/while_let_on_iterator.stderr           | 78 +++++++++++++++----------
 6 files changed, 240 insertions(+), 57 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/while_let_on_iterator.rs b/clippy_lints/src/loops/while_let_on_iterator.rs
index a5715975066..c18151a44e2 100644
--- a/clippy_lints/src/loops/while_let_on_iterator.rs
+++ b/clippy_lints/src/loops/while_let_on_iterator.rs
@@ -3,13 +3,15 @@ use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::higher;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::{
-    get_enclosing_loop_or_closure, is_refutable, is_trait_method, match_def_path, paths, visitors::is_res_used,
+    get_enclosing_loop_or_multi_call_closure, is_refutable, is_trait_method, match_def_path, paths,
+    visitors::is_res_used,
 };
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_expr, Visitor};
 use rustc_hir::{def::Res, Expr, ExprKind, HirId, Local, Mutability, PatKind, QPath, UnOp};
 use rustc_lint::LateContext;
+use rustc_middle::hir::nested_filter::OnlyBodies;
 use rustc_middle::ty::adjustment::Adjust;
 use rustc_span::{symbol::sym, Symbol};
 
@@ -249,6 +251,11 @@ fn needs_mutable_borrow(cx: &LateContext<'_>, iter_expr: &IterExpr, loop_expr: &
         used_iter: bool,
     }
     impl<'tcx> Visitor<'tcx> for AfterLoopVisitor<'_, '_, 'tcx> {
+        type NestedFilter = OnlyBodies;
+        fn nested_visit_map(&mut self) -> Self::Map {
+            self.cx.tcx.hir()
+        }
+
         fn visit_expr(&mut self, e: &'tcx Expr<'_>) {
             if self.used_iter {
                 return;
@@ -283,6 +290,11 @@ fn needs_mutable_borrow(cx: &LateContext<'_>, iter_expr: &IterExpr, loop_expr: &
         used_after: bool,
     }
     impl<'a, 'b, 'tcx> Visitor<'tcx> for NestedLoopVisitor<'a, 'b, 'tcx> {
+        type NestedFilter = OnlyBodies;
+        fn nested_visit_map(&mut self) -> Self::Map {
+            self.cx.tcx.hir()
+        }
+
         fn visit_local(&mut self, l: &'tcx Local<'_>) {
             if !self.after_loop {
                 l.pat.each_binding_or_first(&mut |_, id, _, _| {
@@ -320,10 +332,7 @@ fn needs_mutable_borrow(cx: &LateContext<'_>, iter_expr: &IterExpr, loop_expr: &
         }
     }
 
-    if let Some(e) = get_enclosing_loop_or_closure(cx.tcx, loop_expr) {
-        // The iterator expression will be used on the next iteration (for loops), or on the next call (for
-        // closures) unless it is declared within the enclosing expression. TODO: Check for closures
-        // used where an `FnOnce` type is expected.
+    if let Some(e) = get_enclosing_loop_or_multi_call_closure(cx, loop_expr) {
         let local_id = match iter_expr.path {
             Res::Local(id) => id,
             _ => return true,
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 0e739303683..0d31203f3f7 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -93,7 +93,9 @@ use rustc_middle::ty::fast_reject::SimplifiedTypeGen::{
     ArraySimplifiedType, BoolSimplifiedType, CharSimplifiedType, FloatSimplifiedType, IntSimplifiedType,
     PtrSimplifiedType, SliceSimplifiedType, StrSimplifiedType, UintSimplifiedType,
 };
-use rustc_middle::ty::{layout::IntegerExt, BorrowKind, DefIdTree, Ty, TyCtxt, TypeAndMut, TypeFoldable, UpvarCapture};
+use rustc_middle::ty::{
+    layout::IntegerExt, BorrowKind, ClosureKind, DefIdTree, Ty, TyCtxt, TypeAndMut, TypeFoldable, UpvarCapture,
+};
 use rustc_middle::ty::{FloatTy, IntTy, UintTy};
 use rustc_semver::RustcVersion;
 use rustc_session::Session;
@@ -105,7 +107,7 @@ use rustc_span::{Span, DUMMY_SP};
 use rustc_target::abi::Integer;
 
 use crate::consts::{constant, Constant};
-use crate::ty::{can_partially_move_ty, is_copy, is_recursively_primitive_type};
+use crate::ty::{can_partially_move_ty, expr_sig, is_copy, is_recursively_primitive_type, ty_is_fn_once_param};
 use crate::visitors::expr_visitor_no_bodies;
 
 pub fn parse_msrv(msrv: &str, sess: Option<&Session>, span: Option<Span>) -> Option<RustcVersion> {
@@ -1197,16 +1199,54 @@ pub fn get_enclosing_block<'tcx>(cx: &LateContext<'tcx>, hir_id: HirId) -> Optio
 }
 
 /// Gets the loop or closure enclosing the given expression, if any.
-pub fn get_enclosing_loop_or_closure<'tcx>(tcx: TyCtxt<'tcx>, expr: &Expr<'_>) -> Option<&'tcx Expr<'tcx>> {
-    for (_, node) in tcx.hir().parent_iter(expr.hir_id) {
+pub fn get_enclosing_loop_or_multi_call_closure<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &Expr<'_>,
+) -> Option<&'tcx Expr<'tcx>> {
+    for (_, node) in cx.tcx.hir().parent_iter(expr.hir_id) {
         match node {
-            Node::Expr(
-                e @ Expr {
-                    kind: ExprKind::Loop(..) | ExprKind::Closure { .. },
-                    ..
+            Node::Expr(e) => match e.kind {
+                ExprKind::Closure { .. } => {
+                    if let rustc_ty::Closure(_, subs) = cx.typeck_results().expr_ty(e).kind()
+                        && subs.as_closure().kind() == ClosureKind::FnOnce
+                    {
+                        continue;
+                    }
+                    let is_once = walk_to_expr_usage(cx, e, |node, id| {
+                        let Node::Expr(e) = node else {
+                            return None;
+                        };
+                        match e.kind {
+                            ExprKind::Call(f, _) if f.hir_id == id => Some(()),
+                            ExprKind::Call(f, args) => {
+                                let i = args.iter().position(|arg| arg.hir_id == id)?;
+                                let sig = expr_sig(cx, f)?;
+                                let predicates = sig
+                                    .predicates_id()
+                                    .map_or(cx.param_env, |id| cx.tcx.param_env(id))
+                                    .caller_bounds();
+                                sig.input(i).and_then(|ty| {
+                                    ty_is_fn_once_param(cx.tcx, ty.skip_binder(), predicates).then_some(())
+                                })
+                            },
+                            ExprKind::MethodCall(_, args, _) => {
+                                let i = args.iter().position(|arg| arg.hir_id == id)?;
+                                let id = cx.typeck_results().type_dependent_def_id(e.hir_id)?;
+                                let ty = cx.tcx.fn_sig(id).skip_binder().inputs()[i];
+                                ty_is_fn_once_param(cx.tcx, ty, cx.tcx.param_env(id).caller_bounds()).then_some(())
+                            },
+                            _ => None,
+                        }
+                    })
+                    .is_some();
+                    if !is_once {
+                        return Some(e);
+                    }
                 },
-            ) => return Some(e),
-            Node::Expr(_) | Node::Stmt(_) | Node::Block(_) | Node::Local(_) | Node::Arm(_) => (),
+                ExprKind::Loop(..) => return Some(e),
+                _ => (),
+            },
+            Node::Stmt(_) | Node::Block(_) | Node::Local(_) | Node::Arm(_) => (),
             _ => break,
         }
     }
diff --git a/clippy_utils/src/ty.rs b/clippy_utils/src/ty.rs
index cb3d91c0919..2bfe550c895 100644
--- a/clippy_utils/src/ty.rs
+++ b/clippy_utils/src/ty.rs
@@ -501,7 +501,7 @@ pub fn all_predicates_of(tcx: TyCtxt<'_>, id: DefId) -> impl Iterator<Item = &(P
 /// A signature for a function like type.
 #[derive(Clone, Copy)]
 pub enum ExprFnSig<'tcx> {
-    Sig(Binder<'tcx, FnSig<'tcx>>),
+    Sig(Binder<'tcx, FnSig<'tcx>>, Option<DefId>),
     Closure(Option<&'tcx FnDecl<'tcx>>, Binder<'tcx, FnSig<'tcx>>),
     Trait(Binder<'tcx, Ty<'tcx>>, Option<Binder<'tcx, Ty<'tcx>>>),
 }
@@ -510,7 +510,7 @@ impl<'tcx> ExprFnSig<'tcx> {
     /// bounds only for variadic functions, otherwise this will panic.
     pub fn input(self, i: usize) -> Option<Binder<'tcx, Ty<'tcx>>> {
         match self {
-            Self::Sig(sig) => {
+            Self::Sig(sig, _) => {
                 if sig.c_variadic() {
                     sig.inputs().map_bound(|inputs| inputs.get(i).copied()).transpose()
                 } else {
@@ -527,7 +527,7 @@ impl<'tcx> ExprFnSig<'tcx> {
     /// functions, otherwise this will panic.
     pub fn input_with_hir(self, i: usize) -> Option<(Option<&'tcx hir::Ty<'tcx>>, Binder<'tcx, Ty<'tcx>>)> {
         match self {
-            Self::Sig(sig) => {
+            Self::Sig(sig, _) => {
                 if sig.c_variadic() {
                     sig.inputs()
                         .map_bound(|inputs| inputs.get(i).copied())
@@ -549,16 +549,20 @@ impl<'tcx> ExprFnSig<'tcx> {
     /// specified.
     pub fn output(self) -> Option<Binder<'tcx, Ty<'tcx>>> {
         match self {
-            Self::Sig(sig) | Self::Closure(_, sig) => Some(sig.output()),
+            Self::Sig(sig, _) | Self::Closure(_, sig) => Some(sig.output()),
             Self::Trait(_, output) => output,
         }
     }
+
+    pub fn predicates_id(&self) -> Option<DefId> {
+        if let ExprFnSig::Sig(_, id) = *self { id } else { None }
+    }
 }
 
 /// If the expression is function like, get the signature for it.
 pub fn expr_sig<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>) -> Option<ExprFnSig<'tcx>> {
     if let Res::Def(DefKind::Fn | DefKind::Ctor(_, CtorKind::Fn) | DefKind::AssocFn, id) = path_res(cx, expr) {
-        Some(ExprFnSig::Sig(cx.tcx.fn_sig(id)))
+        Some(ExprFnSig::Sig(cx.tcx.fn_sig(id), Some(id)))
     } else {
         ty_sig(cx, cx.typeck_results().expr_ty_adjusted(expr).peel_refs())
     }
@@ -575,9 +579,9 @@ fn ty_sig<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Option<ExprFnSig<'tcx>>
                 .and_then(|id| cx.tcx.hir().fn_decl_by_hir_id(cx.tcx.hir().local_def_id_to_hir_id(id)));
             Some(ExprFnSig::Closure(decl, subs.as_closure().sig()))
         },
-        ty::FnDef(id, subs) => Some(ExprFnSig::Sig(cx.tcx.bound_fn_sig(id).subst(cx.tcx, subs))),
+        ty::FnDef(id, subs) => Some(ExprFnSig::Sig(cx.tcx.bound_fn_sig(id).subst(cx.tcx, subs), Some(id))),
         ty::Opaque(id, _) => ty_sig(cx, cx.tcx.type_of(id)),
-        ty::FnPtr(sig) => Some(ExprFnSig::Sig(sig)),
+        ty::FnPtr(sig) => Some(ExprFnSig::Sig(sig, None)),
         ty::Dynamic(bounds, _) => {
             let lang_items = cx.tcx.lang_items();
             match bounds.principal() {
@@ -793,3 +797,33 @@ pub fn variant_of_res<'tcx>(cx: &LateContext<'tcx>, res: Res) -> Option<&'tcx Va
         _ => None,
     }
 }
+
+/// Checks if the type is a type parameter implementing `FnOnce`, but not `FnMut`.
+pub fn ty_is_fn_once_param<'tcx>(tcx: TyCtxt<'_>, ty: Ty<'tcx>, predicates: &'tcx [Predicate<'_>]) -> bool {
+    let ty::Param(ty) = *ty.kind() else {
+        return false;
+    };
+    let lang = tcx.lang_items();
+    let (Some(fn_once_id), Some(fn_mut_id), Some(fn_id))
+        = (lang.fn_once_trait(), lang.fn_mut_trait(), lang.fn_trait())
+    else {
+        return false;
+    };
+    predicates
+        .iter()
+        .try_fold(false, |found, p| {
+            if let PredicateKind::Trait(p) = p.kind().skip_binder()
+            && let ty::Param(self_ty) = p.trait_ref.self_ty().kind()
+            && ty.index == self_ty.index
+        {
+            // This should use `super_traits_of`, but that's a private function.
+            if p.trait_ref.def_id == fn_once_id {
+                return Some(true);
+            } else if p.trait_ref.def_id == fn_mut_id || p.trait_ref.def_id == fn_id {
+                return None;
+            }
+        }
+            Some(found)
+        })
+        .unwrap_or(false)
+}
diff --git a/tests/ui/while_let_on_iterator.fixed b/tests/ui/while_let_on_iterator.fixed
index e9ff64431e1..c57c4673634 100644
--- a/tests/ui/while_let_on_iterator.fixed
+++ b/tests/ui/while_let_on_iterator.fixed
@@ -7,7 +7,8 @@
     unused_mut,
     dead_code,
     clippy::equatable_if_let,
-    clippy::manual_find
+    clippy::manual_find,
+    clippy::redundant_closure_call
 )]
 
 fn base() {
@@ -259,7 +260,7 @@ fn issue1924() {
         fn f(&mut self) -> Option<u32> {
             // Used as a field.
             for i in self.0.by_ref() {
-                if !(3..=7).contains(&i) {
+                if !(3..8).contains(&i) {
                     return Some(i);
                 }
             }
@@ -403,6 +404,47 @@ fn issue_8113() {
     }
 }
 
+fn fn_once_closure() {
+    let mut it = 0..10;
+    (|| {
+        for x in it {
+            if x % 2 == 0 {
+                break;
+            }
+        }
+    })();
+
+    fn f(_: impl FnOnce()) {}
+    let mut it = 0..10;
+    f(|| {
+        for x in it {
+            if x % 2 == 0 {
+                break;
+            }
+        }
+    });
+
+    fn f2(_: impl FnMut()) {}
+    let mut it = 0..10;
+    f2(|| {
+        for x in it.by_ref() {
+            if x % 2 == 0 {
+                break;
+            }
+        }
+    });
+
+    fn f3(_: fn()) {}
+    f3(|| {
+        let mut it = 0..10;
+        for x in it {
+            if x % 2 == 0 {
+                break;
+            }
+        }
+    })
+}
+
 fn main() {
     let mut it = 0..20;
     for _ in it {
diff --git a/tests/ui/while_let_on_iterator.rs b/tests/ui/while_let_on_iterator.rs
index 03da39526b2..8b9a2dbcce3 100644
--- a/tests/ui/while_let_on_iterator.rs
+++ b/tests/ui/while_let_on_iterator.rs
@@ -7,7 +7,8 @@
     unused_mut,
     dead_code,
     clippy::equatable_if_let,
-    clippy::manual_find
+    clippy::manual_find,
+    clippy::redundant_closure_call
 )]
 
 fn base() {
@@ -259,7 +260,7 @@ fn issue1924() {
         fn f(&mut self) -> Option<u32> {
             // Used as a field.
             while let Some(i) = self.0.next() {
-                if i < 3 || i > 7 {
+                if !(3..8).contains(&i) {
                     return Some(i);
                 }
             }
@@ -403,6 +404,47 @@ fn issue_8113() {
     }
 }
 
+fn fn_once_closure() {
+    let mut it = 0..10;
+    (|| {
+        while let Some(x) = it.next() {
+            if x % 2 == 0 {
+                break;
+            }
+        }
+    })();
+
+    fn f(_: impl FnOnce()) {}
+    let mut it = 0..10;
+    f(|| {
+        while let Some(x) = it.next() {
+            if x % 2 == 0 {
+                break;
+            }
+        }
+    });
+
+    fn f2(_: impl FnMut()) {}
+    let mut it = 0..10;
+    f2(|| {
+        while let Some(x) = it.next() {
+            if x % 2 == 0 {
+                break;
+            }
+        }
+    });
+
+    fn f3(_: fn()) {}
+    f3(|| {
+        let mut it = 0..10;
+        while let Some(x) = it.next() {
+            if x % 2 == 0 {
+                break;
+            }
+        }
+    })
+}
+
 fn main() {
     let mut it = 0..20;
     while let Some(..) = it.next() {
diff --git a/tests/ui/while_let_on_iterator.stderr b/tests/ui/while_let_on_iterator.stderr
index 42859243855..3236765e1db 100644
--- a/tests/ui/while_let_on_iterator.stderr
+++ b/tests/ui/while_let_on_iterator.stderr
@@ -1,5 +1,5 @@
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:15:5
+  --> $DIR/while_let_on_iterator.rs:16:5
    |
 LL |     while let Option::Some(x) = iter.next() {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for x in iter`
@@ -7,138 +7,154 @@ LL |     while let Option::Some(x) = iter.next() {
    = note: `-D clippy::while-let-on-iterator` implied by `-D warnings`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:20:5
+  --> $DIR/while_let_on_iterator.rs:21:5
    |
 LL |     while let Some(x) = iter.next() {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for x in iter`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:25:5
+  --> $DIR/while_let_on_iterator.rs:26:5
    |
 LL |     while let Some(_) = iter.next() {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for _ in iter`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:101:9
+  --> $DIR/while_let_on_iterator.rs:102:9
    |
 LL |         while let Some([..]) = it.next() {}
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for [..] in it`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:108:9
+  --> $DIR/while_let_on_iterator.rs:109:9
    |
 LL |         while let Some([_x]) = it.next() {}
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for [_x] in it`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:121:9
+  --> $DIR/while_let_on_iterator.rs:122:9
    |
 LL |         while let Some(x @ [_]) = it.next() {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for x @ [_] in it`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:141:9
+  --> $DIR/while_let_on_iterator.rs:142:9
    |
 LL |         while let Some(_) = y.next() {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for _ in y`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:198:9
+  --> $DIR/while_let_on_iterator.rs:199:9
    |
 LL |         while let Some(m) = it.next() {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for m in it.by_ref()`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:209:5
+  --> $DIR/while_let_on_iterator.rs:210:5
    |
 LL |     while let Some(n) = it.next() {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for n in it`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:211:9
+  --> $DIR/while_let_on_iterator.rs:212:9
    |
 LL |         while let Some(m) = it.next() {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for m in it`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:220:9
+  --> $DIR/while_let_on_iterator.rs:221:9
    |
 LL |         while let Some(m) = it.next() {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for m in it`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:229:9
+  --> $DIR/while_let_on_iterator.rs:230:9
    |
 LL |         while let Some(m) = it.next() {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for m in it.by_ref()`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:246:9
+  --> $DIR/while_let_on_iterator.rs:247:9
    |
 LL |         while let Some(m) = it.next() {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for m in it.by_ref()`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:261:13
+  --> $DIR/while_let_on_iterator.rs:262:13
    |
 LL |             while let Some(i) = self.0.next() {
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for i in self.0.by_ref()`
 
-error: manual `!RangeInclusive::contains` implementation
-  --> $DIR/while_let_on_iterator.rs:262:20
-   |
-LL |                 if i < 3 || i > 7 {
-   |                    ^^^^^^^^^^^^^^ help: use: `!(3..=7).contains(&i)`
-   |
-   = note: `-D clippy::manual-range-contains` implied by `-D warnings`
-
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:293:13
+  --> $DIR/while_let_on_iterator.rs:294:13
    |
 LL |             while let Some(i) = self.0.0.0.next() {
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for i in self.0.0.0.by_ref()`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:322:5
+  --> $DIR/while_let_on_iterator.rs:323:5
    |
 LL |     while let Some(n) = it.next() {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for n in it.by_ref()`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:334:9
+  --> $DIR/while_let_on_iterator.rs:335:9
    |
 LL |         while let Some(x) = it.next() {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for x in it.by_ref()`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:348:5
+  --> $DIR/while_let_on_iterator.rs:349:5
    |
 LL |     while let Some(x) = it.next() {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for x in it.by_ref()`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:359:5
+  --> $DIR/while_let_on_iterator.rs:360:5
    |
 LL |     while let Some(x) = it.0.next() {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for x in it.0.by_ref()`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:394:5
+  --> $DIR/while_let_on_iterator.rs:395:5
    |
 LL |     while let Some(x) = s.x.next() {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for x in s.x.by_ref()`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:401:5
+  --> $DIR/while_let_on_iterator.rs:402:5
    |
 LL |     while let Some(x) = x[0].next() {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for x in x[0].by_ref()`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:408:5
+  --> $DIR/while_let_on_iterator.rs:410:9
+   |
+LL |         while let Some(x) = it.next() {
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for x in it`
+
+error: this loop could be written as a `for` loop
+  --> $DIR/while_let_on_iterator.rs:420:9
+   |
+LL |         while let Some(x) = it.next() {
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for x in it`
+
+error: this loop could be written as a `for` loop
+  --> $DIR/while_let_on_iterator.rs:430:9
+   |
+LL |         while let Some(x) = it.next() {
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for x in it.by_ref()`
+
+error: this loop could be written as a `for` loop
+  --> $DIR/while_let_on_iterator.rs:440:9
+   |
+LL |         while let Some(x) = it.next() {
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for x in it`
+
+error: this loop could be written as a `for` loop
+  --> $DIR/while_let_on_iterator.rs:450:5
    |
 LL |     while let Some(..) = it.next() {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for _ in it`
 
-error: aborting due to 23 previous errors
+error: aborting due to 26 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From d0b8f7508c584f74ed668b1bf665657894c63a4a Mon Sep 17 00:00:00 2001
From: bors <bors@rust-lang.org>
Date: Fri, 8 Jul 2022 16:12:00 +0000
Subject: Simplify if let statements

fixes: #8288

---

changelog: Allowing [`qustion_mark`] lint to check `if let` expressions that immediatly return unwrapped value
---
 clippy_lints/src/question_mark.rs | 290 +++++++++++++++++++++++---------------
 tests/ui/needless_match.fixed     |   1 +
 tests/ui/needless_match.rs        |   1 +
 tests/ui/needless_match.stderr    |   4 +-
 tests/ui/question_mark.fixed      |  65 ++++++---
 tests/ui/question_mark.rs         |  69 ++++++---
 tests/ui/question_mark.stderr     |  52 ++++---
 7 files changed, 312 insertions(+), 170 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/question_mark.rs b/clippy_lints/src/question_mark.rs
index 899568a933f..f0155ed6051 100644
--- a/clippy_lints/src/question_mark.rs
+++ b/clippy_lints/src/question_mark.rs
@@ -1,16 +1,19 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::higher;
 use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{eq_expr_value, is_lang_ctor, path_to_local, path_to_local_id, peel_blocks, peel_blocks_with_stmt};
+use clippy_utils::{
+    eq_expr_value, get_parent_node, is_else_clause, is_lang_ctor, path_to_local, path_to_local_id, peel_blocks,
+    peel_blocks_with_stmt,
+};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
-use rustc_hir::LangItem::{OptionNone, OptionSome, ResultOk};
-use rustc_hir::{BindingAnnotation, Expr, ExprKind, PatKind};
+use rustc_hir::LangItem::{OptionNone, OptionSome, ResultErr, ResultOk};
+use rustc_hir::{BindingAnnotation, Expr, ExprKind, Node, PatKind, PathSegment, QPath};
 use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::Ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::sym;
+use rustc_span::{sym, symbol::Symbol};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -39,135 +42,190 @@ declare_clippy_lint! {
 
 declare_lint_pass!(QuestionMark => [QUESTION_MARK]);
 
-impl QuestionMark {
-    /// Checks if the given expression on the given context matches the following structure:
+enum IfBlockType<'hir> {
+    /// An `if x.is_xxx() { a } else { b } ` expression.
     ///
-    /// ```ignore
-    /// if option.is_none() {
-    ///    return None;
-    /// }
-    /// ```
-    ///
-    /// ```ignore
-    /// if result.is_err() {
-    ///     return result;
-    /// }
-    /// ```
+    /// Contains: caller (x), caller_type, call_sym (is_xxx), if_then (a), if_else (b)
+    IfIs(
+        &'hir Expr<'hir>,
+        Ty<'hir>,
+        Symbol,
+        &'hir Expr<'hir>,
+        Option<&'hir Expr<'hir>>,
+    ),
+    /// An `if let Xxx(a) = b { c } else { d }` expression.
     ///
-    /// If it matches, it will suggest to use the question mark operator instead
-    fn check_is_none_or_err_and_early_return(cx: &LateContext<'_>, expr: &Expr<'_>) {
-        if_chain! {
-            if let Some(higher::If { cond, then, r#else }) = higher::If::hir(expr);
-            if let ExprKind::MethodCall(segment, args, _) = &cond.kind;
-            if let Some(subject) = args.get(0);
-            if (Self::option_check_and_early_return(cx, subject, then) && segment.ident.name == sym!(is_none)) ||
-                (Self::result_check_and_early_return(cx, subject, then) && segment.ident.name == sym!(is_err));
-            then {
-                let mut applicability = Applicability::MachineApplicable;
-                let receiver_str = &Sugg::hir_with_applicability(cx, subject, "..", &mut applicability);
-                let mut replacement: Option<String> = None;
-                if let Some(else_inner) = r#else {
-                    if eq_expr_value(cx, subject, peel_blocks(else_inner)) {
-                        replacement = Some(format!("Some({}?)", receiver_str));
-                    }
-                } else if Self::moves_by_default(cx, subject)
-                    && !matches!(subject.kind, ExprKind::Call(..) | ExprKind::MethodCall(..))
-                {
-                    replacement = Some(format!("{}.as_ref()?;", receiver_str));
-                } else {
-                    replacement = Some(format!("{}?;", receiver_str));
-                }
+    /// Contains: let_pat_qpath (Xxx), let_pat_type, let_pat_sym (a), let_expr (b), if_then (c),
+    /// if_else (d)
+    IfLet(
+        &'hir QPath<'hir>,
+        Ty<'hir>,
+        Symbol,
+        &'hir Expr<'hir>,
+        &'hir Expr<'hir>,
+        Option<&'hir Expr<'hir>>,
+    ),
+}
 
-                if let Some(replacement_str) = replacement {
-                    span_lint_and_sugg(
-                        cx,
-                        QUESTION_MARK,
-                        expr.span,
-                        "this block may be rewritten with the `?` operator",
-                        "replace it with",
-                        replacement_str,
-                        applicability,
-                    );
+/// Checks if the given expression on the given context matches the following structure:
+///
+/// ```ignore
+/// if option.is_none() {
+///    return None;
+/// }
+/// ```
+///
+/// ```ignore
+/// if result.is_err() {
+///     return result;
+/// }
+/// ```
+///
+/// If it matches, it will suggest to use the question mark operator instead
+fn check_is_none_or_err_and_early_return<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>) {
+    if_chain! {
+        if let Some(higher::If { cond, then, r#else }) = higher::If::hir(expr);
+        if !is_else_clause(cx.tcx, expr);
+        if let ExprKind::MethodCall(segment, args, _) = &cond.kind;
+        if let Some(caller) = args.get(0);
+        let caller_ty = cx.typeck_results().expr_ty(caller);
+        let if_block = IfBlockType::IfIs(caller, caller_ty, segment.ident.name, then, r#else);
+        if is_early_return(sym::Option, cx, &if_block) || is_early_return(sym::Result, cx, &if_block);
+        then {
+            let mut applicability = Applicability::MachineApplicable;
+            let receiver_str = snippet_with_applicability(cx, caller.span, "..", &mut applicability);
+            let by_ref = !caller_ty.is_copy_modulo_regions(cx.tcx.at(caller.span), cx.param_env) &&
+                !matches!(caller.kind, ExprKind::Call(..) | ExprKind::MethodCall(..));
+            let sugg = if let Some(else_inner) = r#else {
+                if eq_expr_value(cx, caller, peel_blocks(else_inner)) {
+                    format!("Some({}?)", receiver_str)
+                } else {
+                    return;
                 }
-            }
+            } else {
+                format!("{}{}?;", receiver_str, if by_ref { ".as_ref()" } else { "" })
+            };
+
+            span_lint_and_sugg(
+                cx,
+                QUESTION_MARK,
+                expr.span,
+                "this block may be rewritten with the `?` operator",
+                "replace it with",
+                sugg,
+                applicability,
+            );
         }
     }
+}
 
-    fn check_if_let_some_or_err_and_early_return(cx: &LateContext<'_>, expr: &Expr<'_>) {
-        if_chain! {
-            if let Some(higher::IfLet { let_pat, let_expr, if_then, if_else: Some(if_else) })
-                = higher::IfLet::hir(cx, expr);
-            if let PatKind::TupleStruct(ref path1, fields, None) = let_pat.kind;
-            if (Self::option_check_and_early_return(cx, let_expr, if_else) && is_lang_ctor(cx, path1, OptionSome)) ||
-                (Self::result_check_and_early_return(cx, let_expr, if_else) && is_lang_ctor(cx, path1, ResultOk));
-
-            if let PatKind::Binding(annot, bind_id, _, _) = fields[0].kind;
+fn check_if_let_some_or_err_and_early_return<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>) {
+    if_chain! {
+        if let Some(higher::IfLet { let_pat, let_expr, if_then, if_else }) = higher::IfLet::hir(cx, expr);
+        if !is_else_clause(cx.tcx, expr);
+        if let PatKind::TupleStruct(ref path1, fields, None) = let_pat.kind;
+        if let PatKind::Binding(annot, bind_id, ident, _) = fields[0].kind;
+        let caller_ty = cx.typeck_results().expr_ty(let_expr);
+        let if_block = IfBlockType::IfLet(path1, caller_ty, ident.name, let_expr, if_then, if_else);
+        if (is_early_return(sym::Option, cx, &if_block) && path_to_local_id(peel_blocks(if_then), bind_id))
+            || is_early_return(sym::Result, cx, &if_block);
+        if if_else.map(|e| eq_expr_value(cx, let_expr, peel_blocks(e))).filter(|e| *e).is_none();
+        then {
+            let mut applicability = Applicability::MachineApplicable;
+            let receiver_str = snippet_with_applicability(cx, let_expr.span, "..", &mut applicability);
             let by_ref = matches!(annot, BindingAnnotation::Ref | BindingAnnotation::RefMut);
-            if path_to_local_id(peel_blocks(if_then), bind_id);
-            then {
-                let mut applicability = Applicability::MachineApplicable;
-                let receiver_str = snippet_with_applicability(cx, let_expr.span, "..", &mut applicability);
-                let replacement = format!("{}{}?", receiver_str, if by_ref { ".as_ref()" } else { "" },);
-
-                span_lint_and_sugg(
-                    cx,
-                    QUESTION_MARK,
-                    expr.span,
-                    "this if-let-else may be rewritten with the `?` operator",
-                    "replace it with",
-                    replacement,
-                    applicability,
-                );
-            }
+            let requires_semi = matches!(get_parent_node(cx.tcx, expr.hir_id), Some(Node::Stmt(_)));
+            let sugg = format!(
+                "{}{}?{}",
+                receiver_str,
+                if by_ref { ".as_ref()" } else { "" },
+                if requires_semi { ";" } else { "" }
+            );
+            span_lint_and_sugg(
+                cx,
+                QUESTION_MARK,
+                expr.span,
+                "this block may be rewritten with the `?` operator",
+                "replace it with",
+                sugg,
+                applicability,
+            );
         }
     }
+}
 
-    fn result_check_and_early_return(cx: &LateContext<'_>, expr: &Expr<'_>, nested_expr: &Expr<'_>) -> bool {
-        Self::is_result(cx, expr) && Self::expression_returns_unmodified_err(nested_expr, expr)
-    }
-
-    fn option_check_and_early_return(cx: &LateContext<'_>, expr: &Expr<'_>, nested_expr: &Expr<'_>) -> bool {
-        Self::is_option(cx, expr) && Self::expression_returns_none(cx, nested_expr)
-    }
-
-    fn moves_by_default(cx: &LateContext<'_>, expression: &Expr<'_>) -> bool {
-        let expr_ty = cx.typeck_results().expr_ty(expression);
-
-        !expr_ty.is_copy_modulo_regions(cx.tcx.at(expression.span), cx.param_env)
-    }
-
-    fn is_option(cx: &LateContext<'_>, expression: &Expr<'_>) -> bool {
-        let expr_ty = cx.typeck_results().expr_ty(expression);
-
-        is_type_diagnostic_item(cx, expr_ty, sym::Option)
-    }
-
-    fn is_result(cx: &LateContext<'_>, expression: &Expr<'_>) -> bool {
-        let expr_ty = cx.typeck_results().expr_ty(expression);
-
-        is_type_diagnostic_item(cx, expr_ty, sym::Result)
-    }
-
-    fn expression_returns_none(cx: &LateContext<'_>, expression: &Expr<'_>) -> bool {
-        match peel_blocks_with_stmt(expression).kind {
-            ExprKind::Ret(Some(expr)) => Self::expression_returns_none(cx, expr),
-            ExprKind::Path(ref qpath) => is_lang_ctor(cx, qpath, OptionNone),
-            _ => false,
-        }
+fn is_early_return(smbl: Symbol, cx: &LateContext<'_>, if_block: &IfBlockType<'_>) -> bool {
+    match *if_block {
+        IfBlockType::IfIs(caller, caller_ty, call_sym, if_then, _) => {
+            // If the block could be identified as `if x.is_none()/is_err()`,
+            // we then only need to check the if_then return to see if it is none/err.
+            is_type_diagnostic_item(cx, caller_ty, smbl)
+                && expr_return_none_or_err(smbl, cx, if_then, caller, None)
+                && match smbl {
+                    sym::Option => call_sym == sym!(is_none),
+                    sym::Result => call_sym == sym!(is_err),
+                    _ => false,
+                }
+        },
+        IfBlockType::IfLet(qpath, let_expr_ty, let_pat_sym, let_expr, if_then, if_else) => {
+            is_type_diagnostic_item(cx, let_expr_ty, smbl)
+                && match smbl {
+                    sym::Option => {
+                        // We only need to check `if let Some(x) = option` not `if let None = option`,
+                        // because the later one will be suggested as `if option.is_none()` thus causing conflict.
+                        is_lang_ctor(cx, qpath, OptionSome)
+                            && if_else.is_some()
+                            && expr_return_none_or_err(smbl, cx, if_else.unwrap(), let_expr, None)
+                    },
+                    sym::Result => {
+                        (is_lang_ctor(cx, qpath, ResultOk)
+                            && if_else.is_some()
+                            && expr_return_none_or_err(smbl, cx, if_else.unwrap(), let_expr, Some(let_pat_sym)))
+                            || is_lang_ctor(cx, qpath, ResultErr)
+                                && expr_return_none_or_err(smbl, cx, if_then, let_expr, Some(let_pat_sym))
+                    },
+                    _ => false,
+                }
+        },
     }
+}
 
-    fn expression_returns_unmodified_err(expr: &Expr<'_>, cond_expr: &Expr<'_>) -> bool {
-        match peel_blocks_with_stmt(expr).kind {
-            ExprKind::Ret(Some(ret_expr)) => Self::expression_returns_unmodified_err(ret_expr, cond_expr),
-            ExprKind::Path(_) => path_to_local(expr).is_some() && path_to_local(expr) == path_to_local(cond_expr),
+fn expr_return_none_or_err(
+    smbl: Symbol,
+    cx: &LateContext<'_>,
+    expr: &Expr<'_>,
+    cond_expr: &Expr<'_>,
+    err_sym: Option<Symbol>,
+) -> bool {
+    match peel_blocks_with_stmt(expr).kind {
+        ExprKind::Ret(Some(ret_expr)) => expr_return_none_or_err(smbl, cx, ret_expr, cond_expr, err_sym),
+        ExprKind::Path(ref qpath) => match smbl {
+            sym::Option => is_lang_ctor(cx, qpath, OptionNone),
+            sym::Result => path_to_local(expr).is_some() && path_to_local(expr) == path_to_local(cond_expr),
             _ => false,
-        }
+        },
+        ExprKind::Call(call_expr, args_expr) => {
+            if_chain! {
+                if smbl == sym::Result;
+                if let ExprKind::Path(QPath::Resolved(_, path)) = &call_expr.kind;
+                if let Some(segment) = path.segments.first();
+                if let Some(err_sym) = err_sym;
+                if let Some(arg) = args_expr.first();
+                if let ExprKind::Path(QPath::Resolved(_, arg_path)) = &arg.kind;
+                if let Some(PathSegment { ident, .. }) = arg_path.segments.first();
+                then {
+                    return segment.ident.name == sym::Err && err_sym == ident.name;
+                }
+            }
+            false
+        },
+        _ => false,
     }
 }
 
 impl<'tcx> LateLintPass<'tcx> for QuestionMark {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        Self::check_is_none_or_err_and_early_return(cx, expr);
-        Self::check_if_let_some_or_err_and_early_return(cx, expr);
+        check_is_none_or_err_and_early_return(cx, expr);
+        check_if_let_some_or_err_and_early_return(cx, expr);
     }
 }
diff --git a/tests/ui/needless_match.fixed b/tests/ui/needless_match.fixed
index b997e5316cf..0c9178fb85e 100644
--- a/tests/ui/needless_match.fixed
+++ b/tests/ui/needless_match.fixed
@@ -99,6 +99,7 @@ fn if_let_result() {
     let _: Result<i32, i32> = x;
     let _: Result<i32, i32> = x;
     // Input type mismatch, don't trigger
+    #[allow(clippy::question_mark)]
     let _: Result<i32, i32> = if let Err(e) = Ok(1) { Err(e) } else { x };
 }
 
diff --git a/tests/ui/needless_match.rs b/tests/ui/needless_match.rs
index 90482775a1e..f66f01d7cca 100644
--- a/tests/ui/needless_match.rs
+++ b/tests/ui/needless_match.rs
@@ -122,6 +122,7 @@ fn if_let_result() {
     let _: Result<i32, i32> = if let Err(e) = x { Err(e) } else { x };
     let _: Result<i32, i32> = if let Ok(val) = x { Ok(val) } else { x };
     // Input type mismatch, don't trigger
+    #[allow(clippy::question_mark)]
     let _: Result<i32, i32> = if let Err(e) = Ok(1) { Err(e) } else { x };
 }
 
diff --git a/tests/ui/needless_match.stderr b/tests/ui/needless_match.stderr
index 2d679631c6f..5bc79800a1a 100644
--- a/tests/ui/needless_match.stderr
+++ b/tests/ui/needless_match.stderr
@@ -84,7 +84,7 @@ LL |     let _: Result<i32, i32> = if let Ok(val) = x { Ok(val) } else { x };
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `x`
 
 error: this if-let expression is unnecessary
-  --> $DIR/needless_match.rs:129:21
+  --> $DIR/needless_match.rs:130:21
    |
 LL |       let _: Simple = if let Simple::A = x {
    |  _____________________^
@@ -97,7 +97,7 @@ LL | |     };
    | |_____^ help: replace it with: `x`
 
 error: this match expression is unnecessary
-  --> $DIR/needless_match.rs:168:26
+  --> $DIR/needless_match.rs:169:26
    |
 LL |           let _: Complex = match ce {
    |  __________________________^
diff --git a/tests/ui/question_mark.fixed b/tests/ui/question_mark.fixed
index 13ce0f32d4b..c4c9c821433 100644
--- a/tests/ui/question_mark.fixed
+++ b/tests/ui/question_mark.fixed
@@ -1,5 +1,6 @@
 // run-rustfix
 #![allow(unreachable_code)]
+#![allow(dead_code)]
 #![allow(clippy::unnecessary_wraps)]
 
 fn some_func(a: Option<u32>) -> Option<u32> {
@@ -154,26 +155,56 @@ fn f() -> NotOption {
     NotOption::First
 }
 
-fn main() {
-    some_func(Some(42));
-    some_func(None);
-    some_other_func(Some(42));
+fn do_something() {}
 
-    let copy_struct = CopyStruct { opt: Some(54) };
-    copy_struct.func();
+fn err_immediate_return() -> Result<i32, i32> {
+    func_returning_result()?;
+    Ok(1)
+}
 
-    let move_struct = MoveStruct {
-        opt: Some(vec![42, 1337]),
-    };
-    move_struct.ref_func();
-    move_struct.clone().mov_func_reuse();
-    move_struct.mov_func_no_use();
+fn err_immediate_return_and_do_something() -> Result<i32, i32> {
+    func_returning_result()?;
+    do_something();
+    Ok(1)
+}
 
-    let so = SeemsOption::Some(45);
-    returns_something_similar_to_option(so);
+// No warning
+fn no_immediate_return() -> Result<i32, i32> {
+    if let Err(err) = func_returning_result() {
+        do_something();
+        return Err(err);
+    }
+    Ok(1)
+}
 
-    func();
+// No warning
+fn mixed_result_and_option() -> Option<i32> {
+    if let Err(err) = func_returning_result() {
+        return Some(err);
+    }
+    None
+}
+
+// No warning
+fn else_if_check() -> Result<i32, i32> {
+    if true {
+        Ok(1)
+    } else if let Err(e) = func_returning_result() {
+        Err(e)
+    } else {
+        Err(-1)
+    }
+}
 
-    let _ = result_func(Ok(42));
-    let _ = f();
+// No warning
+#[allow(clippy::manual_map)]
+#[rustfmt::skip]
+fn option_map() -> Option<bool> {
+    if let Some(a) = Some(false) {
+        Some(!a)
+    } else {
+        None
+    }
 }
+
+fn main() {}
diff --git a/tests/ui/question_mark.rs b/tests/ui/question_mark.rs
index 60590fd9311..cdbc7b1606f 100644
--- a/tests/ui/question_mark.rs
+++ b/tests/ui/question_mark.rs
@@ -1,5 +1,6 @@
 // run-rustfix
 #![allow(unreachable_code)]
+#![allow(dead_code)]
 #![allow(clippy::unnecessary_wraps)]
 
 fn some_func(a: Option<u32>) -> Option<u32> {
@@ -186,26 +187,60 @@ fn f() -> NotOption {
     NotOption::First
 }
 
-fn main() {
-    some_func(Some(42));
-    some_func(None);
-    some_other_func(Some(42));
+fn do_something() {}
 
-    let copy_struct = CopyStruct { opt: Some(54) };
-    copy_struct.func();
+fn err_immediate_return() -> Result<i32, i32> {
+    if let Err(err) = func_returning_result() {
+        return Err(err);
+    }
+    Ok(1)
+}
 
-    let move_struct = MoveStruct {
-        opt: Some(vec![42, 1337]),
-    };
-    move_struct.ref_func();
-    move_struct.clone().mov_func_reuse();
-    move_struct.mov_func_no_use();
+fn err_immediate_return_and_do_something() -> Result<i32, i32> {
+    if let Err(err) = func_returning_result() {
+        return Err(err);
+    }
+    do_something();
+    Ok(1)
+}
 
-    let so = SeemsOption::Some(45);
-    returns_something_similar_to_option(so);
+// No warning
+fn no_immediate_return() -> Result<i32, i32> {
+    if let Err(err) = func_returning_result() {
+        do_something();
+        return Err(err);
+    }
+    Ok(1)
+}
 
-    func();
+// No warning
+fn mixed_result_and_option() -> Option<i32> {
+    if let Err(err) = func_returning_result() {
+        return Some(err);
+    }
+    None
+}
 
-    let _ = result_func(Ok(42));
-    let _ = f();
+// No warning
+fn else_if_check() -> Result<i32, i32> {
+    if true {
+        Ok(1)
+    } else if let Err(e) = func_returning_result() {
+        Err(e)
+    } else {
+        Err(-1)
+    }
 }
+
+// No warning
+#[allow(clippy::manual_map)]
+#[rustfmt::skip]
+fn option_map() -> Option<bool> {
+    if let Some(a) = Some(false) {
+        Some(!a)
+    } else {
+        None
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/question_mark.stderr b/tests/ui/question_mark.stderr
index 8d782b71dd6..1b6cd524b2f 100644
--- a/tests/ui/question_mark.stderr
+++ b/tests/ui/question_mark.stderr
@@ -1,5 +1,5 @@
 error: this block may be rewritten with the `?` operator
-  --> $DIR/question_mark.rs:6:5
+  --> $DIR/question_mark.rs:7:5
    |
 LL | /     if a.is_none() {
 LL | |         return None;
@@ -9,7 +9,7 @@ LL | |     }
    = note: `-D clippy::question-mark` implied by `-D warnings`
 
 error: this block may be rewritten with the `?` operator
-  --> $DIR/question_mark.rs:51:9
+  --> $DIR/question_mark.rs:52:9
    |
 LL | /         if (self.opt).is_none() {
 LL | |             return None;
@@ -17,7 +17,7 @@ LL | |         }
    | |_________^ help: replace it with: `(self.opt)?;`
 
 error: this block may be rewritten with the `?` operator
-  --> $DIR/question_mark.rs:55:9
+  --> $DIR/question_mark.rs:56:9
    |
 LL | /         if self.opt.is_none() {
 LL | |             return None
@@ -25,7 +25,7 @@ LL | |         }
    | |_________^ help: replace it with: `self.opt?;`
 
 error: this block may be rewritten with the `?` operator
-  --> $DIR/question_mark.rs:59:17
+  --> $DIR/question_mark.rs:60:17
    |
 LL |           let _ = if self.opt.is_none() {
    |  _________________^
@@ -35,8 +35,8 @@ LL | |             self.opt
 LL | |         };
    | |_________^ help: replace it with: `Some(self.opt?)`
 
-error: this if-let-else may be rewritten with the `?` operator
-  --> $DIR/question_mark.rs:65:17
+error: this block may be rewritten with the `?` operator
+  --> $DIR/question_mark.rs:66:17
    |
 LL |           let _ = if let Some(x) = self.opt {
    |  _________________^
@@ -47,7 +47,7 @@ LL | |         };
    | |_________^ help: replace it with: `self.opt?`
 
 error: this block may be rewritten with the `?` operator
-  --> $DIR/question_mark.rs:82:9
+  --> $DIR/question_mark.rs:83:9
    |
 LL | /         if self.opt.is_none() {
 LL | |             return None;
@@ -55,7 +55,7 @@ LL | |         }
    | |_________^ help: replace it with: `self.opt.as_ref()?;`
 
 error: this block may be rewritten with the `?` operator
-  --> $DIR/question_mark.rs:90:9
+  --> $DIR/question_mark.rs:91:9
    |
 LL | /         if self.opt.is_none() {
 LL | |             return None;
@@ -63,15 +63,15 @@ LL | |         }
    | |_________^ help: replace it with: `self.opt.as_ref()?;`
 
 error: this block may be rewritten with the `?` operator
-  --> $DIR/question_mark.rs:98:9
+  --> $DIR/question_mark.rs:99:9
    |
 LL | /         if self.opt.is_none() {
 LL | |             return None;
 LL | |         }
    | |_________^ help: replace it with: `self.opt.as_ref()?;`
 
-error: this if-let-else may be rewritten with the `?` operator
-  --> $DIR/question_mark.rs:105:26
+error: this block may be rewritten with the `?` operator
+  --> $DIR/question_mark.rs:106:26
    |
 LL |           let v: &Vec<_> = if let Some(ref v) = self.opt {
    |  __________________________^
@@ -81,8 +81,8 @@ LL | |             return None;
 LL | |         };
    | |_________^ help: replace it with: `self.opt.as_ref()?`
 
-error: this if-let-else may be rewritten with the `?` operator
-  --> $DIR/question_mark.rs:115:17
+error: this block may be rewritten with the `?` operator
+  --> $DIR/question_mark.rs:116:17
    |
 LL |           let v = if let Some(v) = self.opt {
    |  _________________^
@@ -93,26 +93,42 @@ LL | |         };
    | |_________^ help: replace it with: `self.opt?`
 
 error: this block may be rewritten with the `?` operator
-  --> $DIR/question_mark.rs:130:5
+  --> $DIR/question_mark.rs:131:5
    |
 LL | /     if f().is_none() {
 LL | |         return None;
 LL | |     }
    | |_____^ help: replace it with: `f()?;`
 
-error: this if-let-else may be rewritten with the `?` operator
-  --> $DIR/question_mark.rs:142:13
+error: this block may be rewritten with the `?` operator
+  --> $DIR/question_mark.rs:143:13
    |
 LL |     let _ = if let Ok(x) = x { x } else { return x };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `x?`
 
 error: this block may be rewritten with the `?` operator
-  --> $DIR/question_mark.rs:144:5
+  --> $DIR/question_mark.rs:145:5
    |
 LL | /     if x.is_err() {
 LL | |         return x;
 LL | |     }
    | |_____^ help: replace it with: `x?;`
 
-error: aborting due to 13 previous errors
+error: this block may be rewritten with the `?` operator
+  --> $DIR/question_mark.rs:193:5
+   |
+LL | /     if let Err(err) = func_returning_result() {
+LL | |         return Err(err);
+LL | |     }
+   | |_____^ help: replace it with: `func_returning_result()?;`
+
+error: this block may be rewritten with the `?` operator
+  --> $DIR/question_mark.rs:200:5
+   |
+LL | /     if let Err(err) = func_returning_result() {
+LL | |         return Err(err);
+LL | |     }
+   | |_____^ help: replace it with: `func_returning_result()?;`
+
+error: aborting due to 15 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 4e60134ec31c4424259f992489615b3fd9614253 Mon Sep 17 00:00:00 2001
From: alexey semenyuk <alexsemenyuk88@gmail.com>
Date: Fri, 8 Jul 2022 22:07:44 +0300
Subject: Fix example header

---
 clippy_lints/src/octal_escapes.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/octal_escapes.rs b/clippy_lints/src/octal_escapes.rs
index 3ab4b6c4f6f..6ad6837f0e3 100644
--- a/clippy_lints/src/octal_escapes.rs
+++ b/clippy_lints/src/octal_escapes.rs
@@ -31,7 +31,7 @@ declare_clippy_lint! {
     /// and friends since the string is already preprocessed when Clippy lints
     /// can see it.
     ///
-    /// # Example
+    /// ### Example
     /// ```rust
     /// let one = "\033[1m Bold? \033[0m";  // \033 intended as escape
     /// let two = "\033\0";                 // \033 intended as null-3-3
-- 
cgit 1.4.1-3-g733a5


From 55563f9ce1cea79a473954d70dea620822514c39 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Fri, 8 Jul 2022 15:29:23 -0400
Subject: Fixes for `branches_sharing_code` * Don't suggest moving
 modifications to locals used in any of the condition expressions * Don't
 suggest moving anything after a local with a significant drop

---
 clippy_lints/src/copies.rs                        | 64 ++++++++++++++++++++---
 clippy_utils/src/lib.rs                           |  2 +-
 tests/ui/branches_sharing_code/false_positives.rs | 54 +++++++++++++++++++
 3 files changed, 113 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/copies.rs b/clippy_lints/src/copies.rs
index 1deff9684a1..0e3d9317590 100644
--- a/clippy_lints/src/copies.rs
+++ b/clippy_lints/src/copies.rs
@@ -1,13 +1,16 @@
 use clippy_utils::diagnostics::{span_lint_and_note, span_lint_and_then};
 use clippy_utils::source::{first_line_of_span, indent_of, reindent_multiline, snippet, snippet_opt};
+use clippy_utils::ty::needs_ordered_drop;
+use clippy_utils::visitors::for_each_expr;
 use clippy_utils::{
-    eq_expr_value, get_enclosing_block, hash_expr, hash_stmt, if_sequence, is_else_clause, is_lint_allowed,
-    search_same, ContainsName, HirEqInterExpr, SpanlessEq,
+    capture_local_usage, eq_expr_value, get_enclosing_block, hash_expr, hash_stmt, if_sequence, is_else_clause,
+    is_lint_allowed, path_to_local, search_same, ContainsName, HirEqInterExpr, SpanlessEq,
 };
 use core::iter;
+use core::ops::ControlFlow;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit;
-use rustc_hir::{BinOpKind, Block, Expr, ExprKind, HirId, Stmt, StmtKind};
+use rustc_hir::{BinOpKind, Block, Expr, ExprKind, HirId, HirIdSet, Stmt, StmtKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::hygiene::walk_chain;
@@ -214,7 +217,7 @@ fn lint_if_same_then_else(cx: &LateContext<'_>, conds: &[&Expr<'_>], blocks: &[&
 fn lint_branches_sharing_code<'tcx>(
     cx: &LateContext<'tcx>,
     conds: &[&'tcx Expr<'_>],
-    blocks: &[&Block<'tcx>],
+    blocks: &[&'tcx Block<'_>],
     expr: &'tcx Expr<'_>,
 ) {
     // We only lint ifs with multiple blocks
@@ -340,6 +343,21 @@ fn eq_binding_names(s: &Stmt<'_>, names: &[(HirId, Symbol)]) -> bool {
     }
 }
 
+/// Checks if the statement modifies or moves any of the given locals.
+fn modifies_any_local<'tcx>(cx: &LateContext<'tcx>, s: &'tcx Stmt<'_>, locals: &HirIdSet) -> bool {
+    for_each_expr(s, |e| {
+        if let Some(id) = path_to_local(e)
+            && locals.contains(&id)
+            && !capture_local_usage(cx, e).is_imm_ref()
+        {
+            ControlFlow::Break(())
+        } else {
+            ControlFlow::Continue(())
+        }
+    })
+    .is_some()
+}
+
 /// Checks if the given statement should be considered equal to the statement in the same position
 /// for each block.
 fn eq_stmts(
@@ -365,18 +383,52 @@ fn eq_stmts(
         .all(|b| get_stmt(b).map_or(false, |s| eq.eq_stmt(s, stmt)))
 }
 
-fn scan_block_for_eq(cx: &LateContext<'_>, _conds: &[&Expr<'_>], block: &Block<'_>, blocks: &[&Block<'_>]) -> BlockEq {
+#[expect(clippy::too_many_lines)]
+fn scan_block_for_eq<'tcx>(
+    cx: &LateContext<'tcx>,
+    conds: &[&'tcx Expr<'_>],
+    block: &'tcx Block<'_>,
+    blocks: &[&'tcx Block<'_>],
+) -> BlockEq {
     let mut eq = SpanlessEq::new(cx);
     let mut eq = eq.inter_expr();
     let mut moved_locals = Vec::new();
 
+    let mut cond_locals = HirIdSet::default();
+    for &cond in conds {
+        let _: Option<!> = for_each_expr(cond, |e| {
+            if let Some(id) = path_to_local(e) {
+                cond_locals.insert(id);
+            }
+            ControlFlow::Continue(())
+        });
+    }
+
+    let mut local_needs_ordered_drop = false;
     let start_end_eq = block
         .stmts
         .iter()
         .enumerate()
-        .find(|&(i, stmt)| !eq_stmts(stmt, blocks, |b| b.stmts.get(i), &mut eq, &mut moved_locals))
+        .find(|&(i, stmt)| {
+            if let StmtKind::Local(l) = stmt.kind
+                && needs_ordered_drop(cx, cx.typeck_results().node_type(l.hir_id))
+            {
+                local_needs_ordered_drop = true;
+                return true;
+            }
+            modifies_any_local(cx, stmt, &cond_locals)
+                || !eq_stmts(stmt, blocks, |b| b.stmts.get(i), &mut eq, &mut moved_locals)
+        })
         .map_or(block.stmts.len(), |(i, _)| i);
 
+    if local_needs_ordered_drop {
+        return BlockEq {
+            start_end_eq,
+            end_begin_eq: None,
+            moved_locals,
+        };
+    }
+
     // Walk backwards through the final expression/statements so long as their hashes are equal. Note
     // `SpanlessHash` treats all local references as equal allowing locals declared earlier in the block
     // to match those in other blocks. e.g. If each block ends with the following the hash value will be
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 0e739303683..fd0c6869929 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -890,7 +890,7 @@ pub fn capture_local_usage<'tcx>(cx: &LateContext<'tcx>, e: &Expr<'_>) -> Captur
             Node::Expr(e) => match e.kind {
                 ExprKind::AddrOf(_, mutability, _) => return CaptureKind::Ref(mutability),
                 ExprKind::Index(..) | ExprKind::Unary(UnOp::Deref, _) => capture = CaptureKind::Ref(Mutability::Not),
-                ExprKind::Assign(lhs, ..) | ExprKind::Assign(_, lhs, _) if lhs.hir_id == child_id => {
+                ExprKind::Assign(lhs, ..) | ExprKind::AssignOp(_, lhs, _) if lhs.hir_id == child_id => {
                     return CaptureKind::Ref(Mutability::Mut);
                 },
                 ExprKind::Field(..) => {
diff --git a/tests/ui/branches_sharing_code/false_positives.rs b/tests/ui/branches_sharing_code/false_positives.rs
index 06448200951..5e3a1a29693 100644
--- a/tests/ui/branches_sharing_code/false_positives.rs
+++ b/tests/ui/branches_sharing_code/false_positives.rs
@@ -1,6 +1,8 @@
 #![allow(dead_code)]
 #![deny(clippy::if_same_then_else, clippy::branches_sharing_code)]
 
+use std::sync::Mutex;
+
 // ##################################
 // # Issue clippy#7369
 // ##################################
@@ -38,4 +40,56 @@ fn main() {
         let (y, x) = x;
         foo(x, y)
     };
+
+    let m = Mutex::new(0u32);
+    let l = m.lock().unwrap();
+    let _ = if true {
+        drop(l);
+        println!("foo");
+        m.lock().unwrap();
+        0
+    } else if *l == 0 {
+        drop(l);
+        println!("foo");
+        println!("bar");
+        m.lock().unwrap();
+        1
+    } else {
+        drop(l);
+        println!("foo");
+        println!("baz");
+        m.lock().unwrap();
+        2
+    };
+
+    if true {
+        let _guard = m.lock();
+        println!("foo");
+    } else {
+        println!("foo");
+    }
+
+    if true {
+        let _guard = m.lock();
+        println!("foo");
+        println!("bar");
+    } else {
+        let _guard = m.lock();
+        println!("foo");
+        println!("baz");
+    }
+
+    let mut c = 0;
+    for _ in 0..5 {
+        if c == 0 {
+            c += 1;
+            println!("0");
+        } else if c == 1 {
+            c += 1;
+            println!("1");
+        } else {
+            c += 1;
+            println!("more");
+        }
+    }
 }
-- 
cgit 1.4.1-3-g733a5


From 95b78799c38ee7e9b7489f265963b69405686e06 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sat, 9 Jul 2022 08:15:13 -0400
Subject: Ignore the `IntoIterator::into_iter` call from for loops in
 `significant_drop_in_scrutinee`

---
 clippy_lints/src/matches/significant_drop_in_scrutinee.rs | 4 ++++
 tests/ui/significant_drop_in_scrutinee.rs                 | 7 +++++++
 2 files changed, 11 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/significant_drop_in_scrutinee.rs b/clippy_lints/src/matches/significant_drop_in_scrutinee.rs
index 0704a5af525..b0b15b3f54c 100644
--- a/clippy_lints/src/matches/significant_drop_in_scrutinee.rs
+++ b/clippy_lints/src/matches/significant_drop_in_scrutinee.rs
@@ -89,6 +89,10 @@ fn has_significant_drop_in_scrutinee<'tcx, 'a>(
     source: MatchSource,
 ) -> Option<(Vec<FoundSigDrop>, &'static str)> {
     let mut helper = SigDropHelper::new(cx);
+    let scrutinee = match (source, &scrutinee.kind) {
+        (MatchSource::ForLoopDesugar, ExprKind::Call(_, [e])) => e,
+        _ => scrutinee,
+    };
     helper.find_sig_drop(scrutinee).map(|drops| {
         let message = if source == MatchSource::Normal {
             "temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression"
diff --git a/tests/ui/significant_drop_in_scrutinee.rs b/tests/ui/significant_drop_in_scrutinee.rs
index 185e5009b60..84ecf1ea53e 100644
--- a/tests/ui/significant_drop_in_scrutinee.rs
+++ b/tests/ui/significant_drop_in_scrutinee.rs
@@ -620,4 +620,11 @@ fn should_trigger_lint_without_significant_drop_in_arm() {
     };
 }
 
+fn should_not_trigger_on_significant_iterator_drop() {
+    let lines = std::io::stdin().lines();
+    for line in lines {
+        println!("foo: {}", line.unwrap());
+    }
+}
+
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 97cd46fa33a36bc1edcbc8eba2c142be5da34055 Mon Sep 17 00:00:00 2001
From: alex-semenyuk <alexsemenyuk88@gmail.com>
Date: Sun, 10 Jul 2022 13:11:19 +0300
Subject: Fix span for or_fun_call

---
 clippy_lints/src/methods/or_fun_call.rs |  23 +++----
 tests/ui/or_fun_call.fixed              |  12 ++--
 tests/ui/or_fun_call.stderr             | 106 +++++++-------------------------
 3 files changed, 37 insertions(+), 104 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/or_fun_call.rs b/clippy_lints/src/methods/or_fun_call.rs
index 3d1208824fa..16e160e6a17 100644
--- a/clippy_lints/src/methods/or_fun_call.rs
+++ b/clippy_lints/src/methods/or_fun_call.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::eager_or_lazy::switch_to_lazy_eval;
-use clippy_utils::source::{snippet, snippet_with_applicability, snippet_with_macro_callsite};
+use clippy_utils::source::{snippet, snippet_with_macro_callsite};
 use clippy_utils::ty::{implements_trait, match_type};
 use clippy_utils::{contains_return, is_trait_item, last_path_segment, paths};
 use if_chain::if_chain;
@@ -28,10 +28,10 @@ pub(super) fn check<'tcx>(
         cx: &LateContext<'_>,
         name: &str,
         fun: &hir::Expr<'_>,
-        self_expr: &hir::Expr<'_>,
         arg: &hir::Expr<'_>,
         or_has_args: bool,
         span: Span,
+        method_span: Span,
     ) -> bool {
         let is_default_default = || is_trait_item(cx, fun, sym::Default);
 
@@ -52,24 +52,15 @@ pub(super) fn check<'tcx>(
                 || (matches!(path, sym::new) && implements_default(arg, default_trait_id));
 
             then {
-                let mut applicability = Applicability::MachineApplicable;
-                let hint = "unwrap_or_default()";
-                let sugg_span = span;
-
-                let sugg: String = format!(
-                    "{}.{}",
-                    snippet_with_applicability(cx, self_expr.span, "..", &mut applicability),
-                    hint
-                );
-
+                let span_replace_word = method_span.with_hi(span.hi());
                 span_lint_and_sugg(
                     cx,
                     OR_FUN_CALL,
-                    sugg_span,
+                    span_replace_word,
                     &format!("use of `{}` followed by a call to `{}`", name, path),
                     "try this",
-                    sugg,
-                    applicability,
+                    format!("unwrap_or_default()"),
+                    Applicability::MachineApplicable,
                 );
 
                 true
@@ -171,7 +162,7 @@ pub(super) fn check<'tcx>(
         match inner_arg.kind {
             hir::ExprKind::Call(fun, or_args) => {
                 let or_has_args = !or_args.is_empty();
-                if !check_unwrap_or_default(cx, name, fun, self_arg, arg, or_has_args, expr.span) {
+                if !check_unwrap_or_default(cx, name, fun, arg, or_has_args, expr.span, method_span) {
                     let fun_span = if or_has_args { None } else { Some(fun.span) };
                     check_general_case(cx, name, method_span, self_arg, arg, expr.span, fun_span);
                 }
diff --git a/tests/ui/or_fun_call.fixed b/tests/ui/or_fun_call.fixed
index 123aed40251..fdb08d953ff 100644
--- a/tests/ui/or_fun_call.fixed
+++ b/tests/ui/or_fun_call.fixed
@@ -185,7 +185,8 @@ mod issue8239 {
             .reduce(|mut acc, f| {
                 acc.push_str(&f);
                 acc
-            }).unwrap_or_default();
+            })
+            .unwrap_or_default();
     }
 
     fn more_to_max_suggestion_highest_lines_1() {
@@ -197,7 +198,8 @@ mod issue8239 {
                 let _ = "";
                 acc.push_str(&f);
                 acc
-            }).unwrap_or_default();
+            })
+            .unwrap_or_default();
     }
 
     fn equal_to_max_suggestion_highest_lines() {
@@ -208,7 +210,8 @@ mod issue8239 {
                 let _ = "";
                 acc.push_str(&f);
                 acc
-            }).unwrap_or_default();
+            })
+            .unwrap_or_default();
     }
 
     fn less_than_max_suggestion_highest_lines() {
@@ -218,7 +221,8 @@ mod issue8239 {
         map.reduce(|mut acc, f| {
             acc.push_str(&f);
             acc
-        }).unwrap_or_default();
+        })
+        .unwrap_or_default();
     }
 }
 
diff --git a/tests/ui/or_fun_call.stderr b/tests/ui/or_fun_call.stderr
index dfe15654bc3..4c5938ab88b 100644
--- a/tests/ui/or_fun_call.stderr
+++ b/tests/ui/or_fun_call.stderr
@@ -7,10 +7,10 @@ LL |     with_constructor.unwrap_or(make());
    = note: `-D clippy::or-fun-call` implied by `-D warnings`
 
 error: use of `unwrap_or` followed by a call to `new`
-  --> $DIR/or_fun_call.rs:52:5
+  --> $DIR/or_fun_call.rs:52:14
    |
 LL |     with_new.unwrap_or(Vec::new());
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `with_new.unwrap_or_default()`
+   |              ^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_default()`
 
 error: use of `unwrap_or` followed by a function call
   --> $DIR/or_fun_call.rs:55:21
@@ -31,16 +31,16 @@ LL |     with_err_args.unwrap_or(Vec::with_capacity(12));
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|_| Vec::with_capacity(12))`
 
 error: use of `unwrap_or` followed by a call to `default`
-  --> $DIR/or_fun_call.rs:64:5
+  --> $DIR/or_fun_call.rs:64:24
    |
 LL |     with_default_trait.unwrap_or(Default::default());
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `with_default_trait.unwrap_or_default()`
+   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_default()`
 
 error: use of `unwrap_or` followed by a call to `default`
-  --> $DIR/or_fun_call.rs:67:5
+  --> $DIR/or_fun_call.rs:67:23
    |
 LL |     with_default_type.unwrap_or(u64::default());
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `with_default_type.unwrap_or_default()`
+   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_default()`
 
 error: use of `unwrap_or` followed by a function call
   --> $DIR/or_fun_call.rs:70:18
@@ -49,16 +49,16 @@ LL |     self_default.unwrap_or(<FakeDefault>::default());
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(<FakeDefault>::default)`
 
 error: use of `unwrap_or` followed by a call to `default`
-  --> $DIR/or_fun_call.rs:73:5
+  --> $DIR/or_fun_call.rs:73:18
    |
 LL |     real_default.unwrap_or(<FakeDefault as Default>::default());
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `real_default.unwrap_or_default()`
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_default()`
 
 error: use of `unwrap_or` followed by a call to `new`
-  --> $DIR/or_fun_call.rs:76:5
+  --> $DIR/or_fun_call.rs:76:14
    |
 LL |     with_vec.unwrap_or(vec![]);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `with_vec.unwrap_or_default()`
+   |              ^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_default()`
 
 error: use of `unwrap_or` followed by a function call
   --> $DIR/or_fun_call.rs:79:21
@@ -109,90 +109,28 @@ LL |         None.unwrap_or( unsafe { ptr_to_ref(s) }    );
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|| unsafe { ptr_to_ref(s) })`
 
 error: use of `unwrap_or` followed by a call to `new`
-  --> $DIR/or_fun_call.rs:182:9
-   |
-LL | /         frames
-LL | |             .iter()
-LL | |             .map(|f: &String| f.to_lowercase())
-LL | |             .reduce(|mut acc, f| {
-...  |
-LL | |             })
-LL | |             .unwrap_or(String::new());
-   | |_____________________________________^
-   |
-help: try this
-   |
-LL ~         frames
-LL +             .iter()
-LL +             .map(|f: &String| f.to_lowercase())
-LL +             .reduce(|mut acc, f| {
-LL +                 acc.push_str(&f);
-LL +                 acc
-LL ~             }).unwrap_or_default();
+  --> $DIR/or_fun_call.rs:189:14
    |
+LL |             .unwrap_or(String::new());
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_default()`
 
 error: use of `unwrap_or` followed by a call to `new`
-  --> $DIR/or_fun_call.rs:195:9
-   |
-LL | /         iter.map(|f: &String| f.to_lowercase())
-LL | |             .reduce(|mut acc, f| {
-LL | |                 let _ = "";
-LL | |                 let _ = "";
-...  |
-LL | |             })
-LL | |             .unwrap_or(String::new());
-   | |_____________________________________^
-   |
-help: try this
-   |
-LL ~         iter.map(|f: &String| f.to_lowercase())
-LL +             .reduce(|mut acc, f| {
-LL +                 let _ = "";
-LL +                 let _ = "";
-LL +                 acc.push_str(&f);
-LL +                 acc
-LL ~             }).unwrap_or_default();
+  --> $DIR/or_fun_call.rs:202:14
    |
+LL |             .unwrap_or(String::new());
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_default()`
 
 error: use of `unwrap_or` followed by a call to `new`
-  --> $DIR/or_fun_call.rs:208:9
-   |
-LL | /         iter.map(|f: &String| f.to_lowercase())
-LL | |             .reduce(|mut acc, f| {
-LL | |                 let _ = "";
-LL | |                 acc.push_str(&f);
-LL | |                 acc
-LL | |             })
-LL | |             .unwrap_or(String::new());
-   | |_____________________________________^
-   |
-help: try this
-   |
-LL ~         iter.map(|f: &String| f.to_lowercase())
-LL +             .reduce(|mut acc, f| {
-LL +                 let _ = "";
-LL +                 acc.push_str(&f);
-LL +                 acc
-LL ~             }).unwrap_or_default();
+  --> $DIR/or_fun_call.rs:214:14
    |
+LL |             .unwrap_or(String::new());
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_default()`
 
 error: use of `unwrap_or` followed by a call to `new`
-  --> $DIR/or_fun_call.rs:221:9
-   |
-LL | /         map.reduce(|mut acc, f| {
-LL | |             acc.push_str(&f);
-LL | |             acc
-LL | |         })
-LL | |         .unwrap_or(String::new());
-   | |_________________________________^
-   |
-help: try this
-   |
-LL ~         map.reduce(|mut acc, f| {
-LL +             acc.push_str(&f);
-LL +             acc
-LL ~         }).unwrap_or_default();
+  --> $DIR/or_fun_call.rs:225:10
    |
+LL |         .unwrap_or(String::new());
+   |          ^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_default()`
 
 error: aborting due to 22 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 783992e69389bff1890adaca4cac5967c6724b40 Mon Sep 17 00:00:00 2001
From: alex-semenyuk <alexsemenyuk88@gmail.com>
Date: Sun, 10 Jul 2022 13:34:58 +0300
Subject: Fix dogfood issue for or_fun_call

---
 clippy_lints/src/methods/or_fun_call.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/or_fun_call.rs b/clippy_lints/src/methods/or_fun_call.rs
index 16e160e6a17..5a356108434 100644
--- a/clippy_lints/src/methods/or_fun_call.rs
+++ b/clippy_lints/src/methods/or_fun_call.rs
@@ -59,7 +59,7 @@ pub(super) fn check<'tcx>(
                     span_replace_word,
                     &format!("use of `{}` followed by a call to `{}`", name, path),
                     "try this",
-                    format!("unwrap_or_default()"),
+                    "unwrap_or_default()".to_string(),
                     Applicability::MachineApplicable,
                 );
 
-- 
cgit 1.4.1-3-g733a5


From 25fe4193ec9403dbb942075b782e4b91b420f2bd Mon Sep 17 00:00:00 2001
From: kyoto7250 <50972773+kyoto7250@users.noreply.github.com>
Date: Sun, 10 Jul 2022 23:01:13 +0900
Subject: change applicability type to MaybeIncorrect

---
 clippy_lints/src/loops/explicit_counter_loop.rs | 27 +++++++++++++++----------
 1 file changed, 16 insertions(+), 11 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/explicit_counter_loop.rs b/clippy_lints/src/loops/explicit_counter_loop.rs
index fc50e8addcc..32a14887d20 100644
--- a/clippy_lints/src/loops/explicit_counter_loop.rs
+++ b/clippy_lints/src/loops/explicit_counter_loop.rs
@@ -1,5 +1,5 @@
 use super::{make_iterator_snippet, IncrementVisitor, InitializeVisitor, EXPLICIT_COUNTER_LOOP};
-use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::{get_enclosing_block, is_integer_const};
 use if_chain::if_chain;
@@ -34,24 +34,29 @@ pub(super) fn check<'tcx>(
                 if let Some((name, ty, initializer)) = initialize_visitor.get_result();
                 if is_integer_const(cx, initializer, 0);
                 then {
-                    let mut applicability = Applicability::MachineApplicable;
+                    let mut applicability = Applicability::MaybeIncorrect;
 
                     let int_name = match ty.map(Ty::kind) {
                         // usize or inferred
                         Some(ty::Uint(UintTy::Usize)) | None => {
-                            span_lint_and_sugg(
+                            span_lint_and_then(
                                 cx,
                                 EXPLICIT_COUNTER_LOOP,
                                 expr.span.with_hi(arg.span.hi()),
                                 &format!("the variable `{}` is used as a loop counter", name),
-                                "consider using",
-                                format!(
-                                    "for ({}, {}) in {}.enumerate()",
-                                    name,
-                                    snippet_with_applicability(cx, pat.span, "item", &mut applicability),
-                                    make_iterator_snippet(cx, arg, &mut applicability),
-                                ),
-                                applicability,
+                                |diag| {
+                                    diag.span_suggestion(
+                                        expr.span.with_hi(arg.span.hi()),
+                                        "consider using",
+                                        format!(
+                                            "for ({}, {}) in {}.enumerate()",
+                                            name,
+                                            snippet_with_applicability(cx, pat.span, "item", &mut applicability),
+                                            make_iterator_snippet(cx, arg, &mut applicability),
+                                        ),
+                                        applicability,
+                                    );
+                                }
                             );
                             return;
                         }
-- 
cgit 1.4.1-3-g733a5


From c3c4cda50b1b1b212eb02e5d822b3fd1479dc24c Mon Sep 17 00:00:00 2001
From: alex-semenyuk <alexsemenyuk88@gmail.com>
Date: Mon, 11 Jul 2022 10:34:01 +0300
Subject: Address review

---
 clippy_lints/src/methods/or_fun_call.rs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/or_fun_call.rs b/clippy_lints/src/methods/or_fun_call.rs
index 5a356108434..6af134019a4 100644
--- a/clippy_lints/src/methods/or_fun_call.rs
+++ b/clippy_lints/src/methods/or_fun_call.rs
@@ -52,11 +52,10 @@ pub(super) fn check<'tcx>(
                 || (matches!(path, sym::new) && implements_default(arg, default_trait_id));
 
             then {
-                let span_replace_word = method_span.with_hi(span.hi());
                 span_lint_and_sugg(
                     cx,
                     OR_FUN_CALL,
-                    span_replace_word,
+                    method_span.with_hi(span.hi()),
                     &format!("use of `{}` followed by a call to `{}`", name, path),
                     "try this",
                     "unwrap_or_default()".to_string(),
-- 
cgit 1.4.1-3-g733a5


From c8d32e53a2b0a4a697343bcb8c0d515de5e2411b Mon Sep 17 00:00:00 2001
From: Mateusz Mikuła <mati865@users.noreply.github.com>
Date: Mon, 11 Jul 2022 17:01:46 +0200
Subject: Fix Clippy version in `derive_partial_eq_without_eq` lint

It was first added to Rust in https://github.com/rust-lang/rust/pull/97248 which missed 1.62 just by few days.
---
 clippy_lints/src/derive.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/derive.rs b/clippy_lints/src/derive.rs
index 28f218a8e34..a982990e418 100644
--- a/clippy_lints/src/derive.rs
+++ b/clippy_lints/src/derive.rs
@@ -189,7 +189,7 @@ declare_clippy_lint! {
     ///     i_am_eq_too: Vec<String>,
     /// }
     /// ```
-    #[clippy::version = "1.62.0"]
+    #[clippy::version = "1.63.0"]
     pub DERIVE_PARTIAL_EQ_WITHOUT_EQ,
     style,
     "deriving `PartialEq` on a type that can implement `Eq`, without implementing `Eq`"
-- 
cgit 1.4.1-3-g733a5


From 134d0dee41846d1c0867fa3745b8de25b52ae7af Mon Sep 17 00:00:00 2001
From: kyoto7250 <50972773+kyoto7250@users.noreply.github.com>
Date: Tue, 12 Jul 2022 11:00:22 +0900
Subject: declare span variable before call

---
 clippy_lints/src/loops/explicit_counter_loop.rs | 32 +++++++++++--------------
 1 file changed, 14 insertions(+), 18 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/explicit_counter_loop.rs b/clippy_lints/src/loops/explicit_counter_loop.rs
index 32a14887d20..8e3ab26a947 100644
--- a/clippy_lints/src/loops/explicit_counter_loop.rs
+++ b/clippy_lints/src/loops/explicit_counter_loop.rs
@@ -1,5 +1,5 @@
 use super::{make_iterator_snippet, IncrementVisitor, InitializeVisitor, EXPLICIT_COUNTER_LOOP};
-use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::{get_enclosing_block, is_integer_const};
 use if_chain::if_chain;
@@ -35,28 +35,24 @@ pub(super) fn check<'tcx>(
                 if is_integer_const(cx, initializer, 0);
                 then {
                     let mut applicability = Applicability::MaybeIncorrect;
+                    let span = expr.span.with_hi(arg.span.hi());
 
                     let int_name = match ty.map(Ty::kind) {
                         // usize or inferred
                         Some(ty::Uint(UintTy::Usize)) | None => {
-                            span_lint_and_then(
+                            span_lint_and_sugg(
                                 cx,
                                 EXPLICIT_COUNTER_LOOP,
-                                expr.span.with_hi(arg.span.hi()),
+                                span,
                                 &format!("the variable `{}` is used as a loop counter", name),
-                                |diag| {
-                                    diag.span_suggestion(
-                                        expr.span.with_hi(arg.span.hi()),
-                                        "consider using",
-                                        format!(
-                                            "for ({}, {}) in {}.enumerate()",
-                                            name,
-                                            snippet_with_applicability(cx, pat.span, "item", &mut applicability),
-                                            make_iterator_snippet(cx, arg, &mut applicability),
-                                        ),
-                                        applicability,
-                                    );
-                                }
+                                "consider using",
+                                format!(
+                                    "for ({}, {}) in {}.enumerate()",
+                                    name,
+                                    snippet_with_applicability(cx, pat.span, "item", &mut applicability),
+                                    make_iterator_snippet(cx, arg, &mut applicability),
+                                ),
+                                applicability,
                             );
                             return;
                         }
@@ -68,11 +64,11 @@ pub(super) fn check<'tcx>(
                     span_lint_and_then(
                         cx,
                         EXPLICIT_COUNTER_LOOP,
-                        expr.span.with_hi(arg.span.hi()),
+                        span,
                         &format!("the variable `{}` is used as a loop counter", name),
                         |diag| {
                             diag.span_suggestion(
-                                expr.span.with_hi(arg.span.hi()),
+                                span,
                                 "consider using",
                                 format!(
                                     "for ({}, {}) in (0_{}..).zip({})",
-- 
cgit 1.4.1-3-g733a5


From 8878d674b1d030cbf87605fce2ebbd05cc8f3670 Mon Sep 17 00:00:00 2001
From: Allen Hsu <allen.hsu@fivegoodfriends.com.au>
Date: Wed, 13 Apr 2022 00:21:08 +1000
Subject: Lint for repeated traits within trait bounds or where clauses.

---
 clippy_lints/src/trait_bounds.rs            | 129 ++++++++++++++++++++++++++--
 tests/compile-test.rs                       |   1 +
 tests/ui/trait_duplication_in_bounds.rs     | 111 ++++++++++++++++++++++++
 tests/ui/trait_duplication_in_bounds.stderr | 114 ++++++++++++++++++++++--
 4 files changed, 340 insertions(+), 15 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/trait_bounds.rs b/clippy_lints/src/trait_bounds.rs
index 2741179074b..0a42a31fb8c 100644
--- a/clippy_lints/src/trait_bounds.rs
+++ b/clippy_lints/src/trait_bounds.rs
@@ -1,5 +1,5 @@
-use clippy_utils::diagnostics::span_lint_and_help;
-use clippy_utils::source::{snippet, snippet_with_applicability};
+use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg};
+use clippy_utils::source::{snippet, snippet_opt, snippet_with_applicability};
 use clippy_utils::{SpanlessEq, SpanlessHash};
 use core::hash::{Hash, Hasher};
 use if_chain::if_chain;
@@ -9,8 +9,8 @@ use rustc_data_structures::unhash::UnhashMap;
 use rustc_errors::Applicability;
 use rustc_hir::def::Res;
 use rustc_hir::{
-    GenericBound, Generics, Item, ItemKind, Node, Path, PathSegment, PredicateOrigin, QPath, TraitBoundModifier,
-    TraitItem, Ty, TyKind, WherePredicate,
+    GenericArg, GenericBound, Generics, Item, ItemKind, Node, Path, PathSegment, PredicateOrigin, QPath,
+    TraitBoundModifier, TraitItem, TraitRef, Ty, TyKind, WherePredicate,
 };
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
@@ -36,7 +36,7 @@ declare_clippy_lint! {
     #[clippy::version = "1.38.0"]
     pub TYPE_REPETITION_IN_BOUNDS,
     nursery,
-    "Types are repeated unnecessary in trait bounds use `+` instead of using `T: _, T: _`"
+    "types are repeated unnecessary in trait bounds use `+` instead of using `T: _, T: _`"
 }
 
 declare_clippy_lint! {
@@ -63,10 +63,26 @@ declare_clippy_lint! {
     ///
     /// fn func<T>(arg: T) where T: Clone + Default {}
     /// ```
+    ///
+    /// ```rust
+    /// fn foo<T: Default + Default>(bar: T) {}
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// fn foo<T: Default>(bar: T) {}
+    /// ```
+    ///
+    /// ```rust
+    /// fn foo<T>(bar: T) where T: Default + Default {}
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// fn foo<T>(bar: T) where T: Default {}
+    /// ```
     #[clippy::version = "1.47.0"]
     pub TRAIT_DUPLICATION_IN_BOUNDS,
     nursery,
-    "Check if the same trait bounds are specified twice during a function declaration"
+    "check if the same trait bounds are specified more than once during a generic declaration"
 }
 
 #[derive(Copy, Clone)]
@@ -87,6 +103,19 @@ impl<'tcx> LateLintPass<'tcx> for TraitBounds {
     fn check_generics(&mut self, cx: &LateContext<'tcx>, gen: &'tcx Generics<'_>) {
         self.check_type_repetition(cx, gen);
         check_trait_bound_duplication(cx, gen);
+        check_bounds_or_where_duplication(cx, gen);
+    }
+
+    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
+        // special handling for self trait bounds as these are not considered generics
+        // ie. trait Foo: Display {}
+        if let Item {
+            kind: ItemKind::Trait(_, _, _, bounds, ..),
+            ..
+        } = item
+        {
+            rollup_traits(cx, bounds, "these bounds contain repeated elements");
+        }
     }
 
     fn check_trait_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx TraitItem<'tcx>) {
@@ -241,6 +270,26 @@ fn check_trait_bound_duplication(cx: &LateContext<'_>, gen: &'_ Generics<'_>) {
     }
 }
 
+#[derive(PartialEq, Eq, Hash, Debug)]
+struct ComparableTraitRef(Res, Vec<Res>);
+
+fn check_bounds_or_where_duplication(cx: &LateContext<'_>, gen: &'_ Generics<'_>) {
+    if gen.span.from_expansion() {
+        return;
+    }
+
+    for predicate in gen.predicates {
+        if let WherePredicate::BoundPredicate(ref bound_predicate) = predicate {
+            let msg = if predicate.in_where_clause() {
+                "these where clauses contain repeated elements"
+            } else {
+                "these bounds contain repeated elements"
+            };
+            rollup_traits(cx, bound_predicate.bounds, msg);
+        }
+    }
+}
+
 fn get_trait_info_from_bound<'a>(bound: &'a GenericBound<'_>) -> Option<(Res, &'a [PathSegment<'a>], Span)> {
     if let GenericBound::Trait(t, tbm) = bound {
         let trait_path = t.trait_ref.path;
@@ -257,3 +306,71 @@ fn get_trait_info_from_bound<'a>(bound: &'a GenericBound<'_>) -> Option<(Res, &'
         None
     }
 }
+
+// FIXME: ComparableTraitRef does not support nested bounds needed for associated_type_bounds
+fn into_comparable_trait_ref(trait_ref: &TraitRef<'_>) -> ComparableTraitRef {
+    ComparableTraitRef(
+        trait_ref.path.res,
+        trait_ref
+            .path
+            .segments
+            .iter()
+            .filter_map(|segment| {
+                // get trait bound type arguments
+                Some(segment.args?.args.iter().filter_map(|arg| {
+                    if_chain! {
+                        if let GenericArg::Type(ty) = arg;
+                        if let TyKind::Path(QPath::Resolved(_, path)) = ty.kind;
+                        then { return Some(path.res) }
+                    }
+                    None
+                }))
+            })
+            .flatten()
+            .collect(),
+    )
+}
+
+fn rollup_traits(cx: &LateContext<'_>, bounds: &[GenericBound<'_>], msg: &str) {
+    let mut map = FxHashMap::default();
+    let mut repeated_res = false;
+
+    let only_comparable_trait_refs = |bound: &GenericBound<'_>| {
+        if let GenericBound::Trait(t, _) = bound {
+            Some((into_comparable_trait_ref(&t.trait_ref), t.span))
+        } else {
+            None
+        }
+    };
+
+    for bound in bounds.iter().filter_map(only_comparable_trait_refs) {
+        let (comparable_bound, span_direct) = bound;
+        if map.insert(comparable_bound, span_direct).is_some() {
+            repeated_res = true;
+        }
+    }
+
+    if_chain! {
+        if repeated_res;
+        if let [first_trait, .., last_trait] = bounds;
+        then {
+            let all_trait_span = first_trait.span().to(last_trait.span());
+
+            let mut traits = map.values()
+                .filter_map(|span| snippet_opt(cx, *span))
+                .collect::<Vec<_>>();
+            traits.sort_unstable();
+            let traits = traits.join(" + ");
+
+            span_lint_and_sugg(
+                cx,
+                TRAIT_DUPLICATION_IN_BOUNDS,
+                all_trait_span,
+                msg,
+                "try",
+                traits,
+                Applicability::MachineApplicable
+            );
+        }
+    }
+}
diff --git a/tests/compile-test.rs b/tests/compile-test.rs
index 41048298349..52cf751c8d0 100644
--- a/tests/compile-test.rs
+++ b/tests/compile-test.rs
@@ -397,6 +397,7 @@ const RUSTFIX_COVERAGE_KNOWN_EXCEPTIONS: &[&str] = &[
     "single_component_path_imports_nested_first.rs",
     "string_add.rs",
     "toplevel_ref_arg_non_rustfix.rs",
+    "trait_duplication_in_bounds.rs",
     "unit_arg.rs",
     "unnecessary_clone.rs",
     "unnecessary_lazy_eval_unfixable.rs",
diff --git a/tests/ui/trait_duplication_in_bounds.rs b/tests/ui/trait_duplication_in_bounds.rs
index a21d4c5d637..a5751c58aab 100644
--- a/tests/ui/trait_duplication_in_bounds.rs
+++ b/tests/ui/trait_duplication_in_bounds.rs
@@ -1,4 +1,5 @@
 #![deny(clippy::trait_duplication_in_bounds)]
+#![allow(unused)]
 
 use std::collections::BTreeMap;
 use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Sub, SubAssign};
@@ -98,4 +99,114 @@ trait FooIter: Iterator<Item = Foo> {
 // This should not lint
 fn impl_trait(_: impl AsRef<str>, _: impl AsRef<str>) {}
 
+mod repeated_where_clauses_or_trait_bounds {
+    fn bad_foo<T: Clone + Clone + Clone + Copy, U: Clone + Copy>(arg0: T, argo1: U) {
+        unimplemented!();
+    }
+
+    fn bad_bar<T, U>(arg0: T, arg1: U)
+    where
+        T: Clone + Clone + Clone + Copy,
+        U: Clone + Copy,
+    {
+        unimplemented!();
+    }
+
+    fn good_bar<T: Clone + Copy, U: Clone + Copy>(arg0: T, arg1: U) {
+        unimplemented!();
+    }
+
+    fn good_foo<T, U>(arg0: T, arg1: U)
+    where
+        T: Clone + Copy,
+        U: Clone + Copy,
+    {
+        unimplemented!();
+    }
+
+    trait GoodSelfTraitBound: Clone + Copy {
+        fn f();
+    }
+
+    trait GoodSelfWhereClause {
+        fn f()
+        where
+            Self: Clone + Copy;
+    }
+
+    trait BadSelfTraitBound: Clone + Clone + Clone {
+        fn f();
+    }
+
+    trait BadSelfWhereClause {
+        fn f()
+        where
+            Self: Clone + Clone + Clone;
+    }
+
+    trait GoodTraitBound<T: Clone + Copy, U: Clone + Copy> {
+        fn f();
+    }
+
+    trait GoodWhereClause<T, U> {
+        fn f()
+        where
+            T: Clone + Copy,
+            U: Clone + Copy;
+    }
+
+    trait BadTraitBound<T: Clone + Clone + Clone + Copy, U: Clone + Copy> {
+        fn f();
+    }
+
+    trait BadWhereClause<T, U> {
+        fn f()
+        where
+            T: Clone + Clone + Clone + Copy,
+            U: Clone + Copy;
+    }
+
+    struct GoodStructBound<T: Clone + Copy, U: Clone + Copy> {
+        t: T,
+        u: U,
+    }
+
+    impl<T: Clone + Copy, U: Clone + Copy> GoodTraitBound<T, U> for GoodStructBound<T, U> {
+        // this should not warn
+        fn f() {}
+    }
+
+    struct GoodStructWhereClause;
+
+    impl<T, U> GoodTraitBound<T, U> for GoodStructWhereClause
+    where
+        T: Clone + Copy,
+        U: Clone + Copy,
+    {
+        // this should not warn
+        fn f() {}
+    }
+
+    fn no_error_separate_arg_bounds(program: impl AsRef<()>, dir: impl AsRef<()>, args: &[impl AsRef<()>]) {}
+
+    trait GenericTrait<T> {}
+
+    // This should not warn but currently does see #8757
+    fn good_generic<T: GenericTrait<u64> + GenericTrait<u32>>(arg0: T) {
+        unimplemented!();
+    }
+
+    fn bad_generic<T: GenericTrait<u64> + GenericTrait<u32> + GenericTrait<u64>>(arg0: T) {
+        unimplemented!();
+    }
+
+    mod foo {
+        pub trait Clone {}
+    }
+
+    fn qualified_path<T: std::clone::Clone + Clone + foo::Clone>(arg0: T) {
+        unimplemented!();
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/trait_duplication_in_bounds.stderr b/tests/ui/trait_duplication_in_bounds.stderr
index 6f8c8e47dfb..7ef04e52708 100644
--- a/tests/ui/trait_duplication_in_bounds.stderr
+++ b/tests/ui/trait_duplication_in_bounds.stderr
@@ -1,5 +1,5 @@
 error: this trait bound is already specified in the where clause
-  --> $DIR/trait_duplication_in_bounds.rs:6:15
+  --> $DIR/trait_duplication_in_bounds.rs:7:15
    |
 LL | fn bad_foo<T: Clone + Default, Z: Copy>(arg0: T, arg1: Z)
    |               ^^^^^
@@ -12,7 +12,7 @@ LL | #![deny(clippy::trait_duplication_in_bounds)]
    = help: consider removing this trait bound
 
 error: this trait bound is already specified in the where clause
-  --> $DIR/trait_duplication_in_bounds.rs:6:23
+  --> $DIR/trait_duplication_in_bounds.rs:7:23
    |
 LL | fn bad_foo<T: Clone + Default, Z: Copy>(arg0: T, arg1: Z)
    |                       ^^^^^^^
@@ -20,7 +20,7 @@ LL | fn bad_foo<T: Clone + Default, Z: Copy>(arg0: T, arg1: Z)
    = help: consider removing this trait bound
 
 error: this trait bound is already specified in trait declaration
-  --> $DIR/trait_duplication_in_bounds.rs:35:15
+  --> $DIR/trait_duplication_in_bounds.rs:36:15
    |
 LL |         Self: Default;
    |               ^^^^^^^
@@ -28,7 +28,7 @@ LL |         Self: Default;
    = help: consider removing this trait bound
 
 error: this trait bound is already specified in trait declaration
-  --> $DIR/trait_duplication_in_bounds.rs:49:15
+  --> $DIR/trait_duplication_in_bounds.rs:50:15
    |
 LL |         Self: Default + Clone;
    |               ^^^^^^^
@@ -36,7 +36,7 @@ LL |         Self: Default + Clone;
    = help: consider removing this trait bound
 
 error: this trait bound is already specified in trait declaration
-  --> $DIR/trait_duplication_in_bounds.rs:55:15
+  --> $DIR/trait_duplication_in_bounds.rs:56:15
    |
 LL |         Self: Default + Clone;
    |               ^^^^^^^
@@ -44,7 +44,7 @@ LL |         Self: Default + Clone;
    = help: consider removing this trait bound
 
 error: this trait bound is already specified in trait declaration
-  --> $DIR/trait_duplication_in_bounds.rs:55:25
+  --> $DIR/trait_duplication_in_bounds.rs:56:25
    |
 LL |         Self: Default + Clone;
    |                         ^^^^^
@@ -52,7 +52,7 @@ LL |         Self: Default + Clone;
    = help: consider removing this trait bound
 
 error: this trait bound is already specified in trait declaration
-  --> $DIR/trait_duplication_in_bounds.rs:58:15
+  --> $DIR/trait_duplication_in_bounds.rs:59:15
    |
 LL |         Self: Default;
    |               ^^^^^^^
@@ -60,12 +60,108 @@ LL |         Self: Default;
    = help: consider removing this trait bound
 
 error: this trait bound is already specified in trait declaration
-  --> $DIR/trait_duplication_in_bounds.rs:93:15
+  --> $DIR/trait_duplication_in_bounds.rs:94:15
    |
 LL |         Self: Iterator<Item = Foo>,
    |               ^^^^^^^^^^^^^^^^^^^^
    |
    = help: consider removing this trait bound
 
-error: aborting due to 8 previous errors
+error: this trait bound is already specified in the where clause
+  --> $DIR/trait_duplication_in_bounds.rs:103:19
+   |
+LL |     fn bad_foo<T: Clone + Clone + Clone + Copy, U: Clone + Copy>(arg0: T, argo1: U) {
+   |                   ^^^^^
+   |
+   = help: consider removing this trait bound
+
+error: these bounds contain repeated elements
+  --> $DIR/trait_duplication_in_bounds.rs:103:19
+   |
+LL |     fn bad_foo<T: Clone + Clone + Clone + Copy, U: Clone + Copy>(arg0: T, argo1: U) {
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Clone + Copy`
+
+error: this trait bound is already specified in the where clause
+  --> $DIR/trait_duplication_in_bounds.rs:109:12
+   |
+LL |         T: Clone + Clone + Clone + Copy,
+   |            ^^^^^
+   |
+   = help: consider removing this trait bound
+
+error: these where clauses contain repeated elements
+  --> $DIR/trait_duplication_in_bounds.rs:109:12
+   |
+LL |         T: Clone + Clone + Clone + Copy,
+   |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Clone + Copy`
+
+error: these bounds contain repeated elements
+  --> $DIR/trait_duplication_in_bounds.rs:137:30
+   |
+LL |     trait BadSelfTraitBound: Clone + Clone + Clone {
+   |                              ^^^^^^^^^^^^^^^^^^^^^ help: try: `Clone`
+
+error: these where clauses contain repeated elements
+  --> $DIR/trait_duplication_in_bounds.rs:144:19
+   |
+LL |             Self: Clone + Clone + Clone;
+   |                   ^^^^^^^^^^^^^^^^^^^^^ help: try: `Clone`
+
+error: this trait bound is already specified in the where clause
+  --> $DIR/trait_duplication_in_bounds.rs:158:28
+   |
+LL |     trait BadTraitBound<T: Clone + Clone + Clone + Copy, U: Clone + Copy> {
+   |                            ^^^^^
+   |
+   = help: consider removing this trait bound
+
+error: these bounds contain repeated elements
+  --> $DIR/trait_duplication_in_bounds.rs:158:28
+   |
+LL |     trait BadTraitBound<T: Clone + Clone + Clone + Copy, U: Clone + Copy> {
+   |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Clone + Copy`
+
+error: these where clauses contain repeated elements
+  --> $DIR/trait_duplication_in_bounds.rs:165:16
+   |
+LL |             T: Clone + Clone + Clone + Copy,
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Clone + Copy`
+
+error: this trait bound is already specified in the where clause
+  --> $DIR/trait_duplication_in_bounds.rs:195:24
+   |
+LL |     fn good_generic<T: GenericTrait<u64> + GenericTrait<u32>>(arg0: T) {
+   |                        ^^^^^^^^^^^^^^^^^
+   |
+   = help: consider removing this trait bound
+
+error: this trait bound is already specified in the where clause
+  --> $DIR/trait_duplication_in_bounds.rs:199:23
+   |
+LL |     fn bad_generic<T: GenericTrait<u64> + GenericTrait<u32> + GenericTrait<u64>>(arg0: T) {
+   |                       ^^^^^^^^^^^^^^^^^
+   |
+   = help: consider removing this trait bound
+
+error: these bounds contain repeated elements
+  --> $DIR/trait_duplication_in_bounds.rs:199:23
+   |
+LL |     fn bad_generic<T: GenericTrait<u64> + GenericTrait<u32> + GenericTrait<u64>>(arg0: T) {
+   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `GenericTrait<u32> + GenericTrait<u64>`
+
+error: this trait bound is already specified in the where clause
+  --> $DIR/trait_duplication_in_bounds.rs:207:26
+   |
+LL |     fn qualified_path<T: std::clone::Clone + Clone + foo::Clone>(arg0: T) {
+   |                          ^^^^^^^^^^^^^^^^^
+   |
+   = help: consider removing this trait bound
+
+error: these bounds contain repeated elements
+  --> $DIR/trait_duplication_in_bounds.rs:207:26
+   |
+LL |     fn qualified_path<T: std::clone::Clone + Clone + foo::Clone>(arg0: T) {
+   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Clone + foo::Clone`
+
+error: aborting due to 22 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From c26188e327c44609c54733a9592ebf872b7b4f7e Mon Sep 17 00:00:00 2001
From: Victor-N-Suadicani <v.n.suadicani@gmail.com>
Date: Tue, 12 Jul 2022 23:11:19 +0200
Subject: Moves format_push_string to pedantic.

---
 clippy_lints/src/format_push_string.rs    | 2 +-
 clippy_lints/src/lib.register_all.rs      | 1 -
 clippy_lints/src/lib.register_pedantic.rs | 1 +
 clippy_lints/src/lib.register_perf.rs     | 1 -
 4 files changed, 2 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/format_push_string.rs b/clippy_lints/src/format_push_string.rs
index de19c5ec20e..2d01c71d438 100644
--- a/clippy_lints/src/format_push_string.rs
+++ b/clippy_lints/src/format_push_string.rs
@@ -29,7 +29,7 @@ declare_clippy_lint! {
     /// ```
     #[clippy::version = "1.62.0"]
     pub FORMAT_PUSH_STRING,
-    perf,
+    pedantic,
     "`format!(..)` appended to existing `String`"
 }
 declare_lint_pass!(FormatPushString => [FORMAT_PUSH_STRING]);
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index da26a3f0130..9afc714b11c 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -71,7 +71,6 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(format_args::TO_STRING_IN_FORMAT_ARGS),
     LintId::of(format_impl::PRINT_IN_FORMAT_IMPL),
     LintId::of(format_impl::RECURSIVE_FORMAT_IMPL),
-    LintId::of(format_push_string::FORMAT_PUSH_STRING),
     LintId::of(formatting::POSSIBLE_MISSING_COMMA),
     LintId::of(formatting::SUSPICIOUS_ASSIGNMENT_FORMATTING),
     LintId::of(formatting::SUSPICIOUS_ELSE_FORMATTING),
diff --git a/clippy_lints/src/lib.register_pedantic.rs b/clippy_lints/src/lib.register_pedantic.rs
index 4d4b89687d0..0b7fff56a5d 100644
--- a/clippy_lints/src/lib.register_pedantic.rs
+++ b/clippy_lints/src/lib.register_pedantic.rs
@@ -31,6 +31,7 @@ store.register_group(true, "clippy::pedantic", Some("clippy_pedantic"), vec![
     LintId::of(eta_reduction::REDUNDANT_CLOSURE_FOR_METHOD_CALLS),
     LintId::of(excessive_bools::FN_PARAMS_EXCESSIVE_BOOLS),
     LintId::of(excessive_bools::STRUCT_EXCESSIVE_BOOLS),
+    LintId::of(format_push_string::FORMAT_PUSH_STRING),
     LintId::of(functions::MUST_USE_CANDIDATE),
     LintId::of(functions::TOO_MANY_LINES),
     LintId::of(if_not_else::IF_NOT_ELSE),
diff --git a/clippy_lints/src/lib.register_perf.rs b/clippy_lints/src/lib.register_perf.rs
index 6bf519c24e8..e1b90acb93c 100644
--- a/clippy_lints/src/lib.register_perf.rs
+++ b/clippy_lints/src/lib.register_perf.rs
@@ -7,7 +7,6 @@ store.register_group(true, "clippy::perf", Some("clippy_perf"), vec![
     LintId::of(escape::BOXED_LOCAL),
     LintId::of(format_args::FORMAT_IN_FORMAT_ARGS),
     LintId::of(format_args::TO_STRING_IN_FORMAT_ARGS),
-    LintId::of(format_push_string::FORMAT_PUSH_STRING),
     LintId::of(large_const_arrays::LARGE_CONST_ARRAYS),
     LintId::of(large_enum_variant::LARGE_ENUM_VARIANT),
     LintId::of(loops::MANUAL_MEMCPY),
-- 
cgit 1.4.1-3-g733a5


From 852c38c543d4b2cdea4af9fe8d5ddf229ebd1410 Mon Sep 17 00:00:00 2001
From: Korlo <88337245+Rqnsom@users.noreply.github.com>
Date: Mon, 11 Jul 2022 16:53:04 +0200
Subject: fix for manual_flatten help texts order

Whenever suggestion for this lint does not fit in one line,
lint will generate two help messages. The second help message
will always contain the suggestion.

The first help message refers to suggestion message,
and it should adapt depending on the location of the suggestion:
- inline suggestion within the error/warning message
- suggestion separated into second help text
---
 clippy_lints/src/loops/manual_flatten.rs | 16 +++++++++++++---
 tests/lint_message_convention.rs         |  1 +
 tests/ui/manual_flatten.rs               | 16 ++++++++++++++++
 tests/ui/manual_flatten.stderr           | 30 +++++++++++++++++++++++++++++-
 4 files changed, 59 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/manual_flatten.rs b/clippy_lints/src/loops/manual_flatten.rs
index d276c901059..1d6ddf4b99f 100644
--- a/clippy_lints/src/loops/manual_flatten.rs
+++ b/clippy_lints/src/loops/manual_flatten.rs
@@ -51,22 +51,32 @@ pub(super) fn check<'tcx>(
                 _ => ""
             };
 
+            let sugg = format!("{arg_snippet}{copied}.flatten()");
+
+            // If suggestion is not a one-liner, it won't be shown inline within the error message. In that case,
+            // it will be shown in the extra `help` message at the end, which is why the first `help_msg` needs
+            // to refer to the correct relative position of the suggestion.
+            let help_msg = if sugg.contains('\n') {
+                "remove the `if let` statement in the for loop and then..."
+            } else {
+                "...and remove the `if let` statement in the for loop"
+            };
+
             span_lint_and_then(
                 cx,
                 MANUAL_FLATTEN,
                 span,
                 &msg,
                 |diag| {
-                    let sugg = format!("{}{}.flatten()", arg_snippet, copied);
                     diag.span_suggestion(
                         arg.span,
                         "try",
                         sugg,
-                        Applicability::MaybeIncorrect,
+                        applicability,
                     );
                     diag.span_help(
                         inner_expr.span,
-                        "...and remove the `if let` statement in the for loop",
+                        help_msg,
                     );
                 }
             );
diff --git a/tests/lint_message_convention.rs b/tests/lint_message_convention.rs
index dd1d4412036..9519c2e9379 100644
--- a/tests/lint_message_convention.rs
+++ b/tests/lint_message_convention.rs
@@ -42,6 +42,7 @@ impl Message {
             r".*remove .*the return type...",
             r"note: Clippy version: .*",
             r"the compiler unexpectedly panicked. this is a bug.",
+            r"remove the `if let` statement in the for loop and then...",
         ])
         .unwrap();
 
diff --git a/tests/ui/manual_flatten.rs b/tests/ui/manual_flatten.rs
index 6c5232ec5f5..d922593bc6f 100644
--- a/tests/ui/manual_flatten.rs
+++ b/tests/ui/manual_flatten.rs
@@ -106,4 +106,20 @@ fn main() {
     for n in vec![Some(1), Some(2), Some(3)].iter().flatten() {
         println!("{}", n);
     }
+
+    run_unformatted_tests();
+}
+
+#[rustfmt::skip]
+fn run_unformatted_tests() {
+    // Skip rustfmt here on purpose so the suggestion does not fit in one line
+    for n in vec![
+        Some(1),
+        Some(2),
+        Some(3)
+    ].iter() {
+        if let Some(n) = n {
+            println!("{:?}", n);
+        }
+    }
 }
diff --git a/tests/ui/manual_flatten.stderr b/tests/ui/manual_flatten.stderr
index 392e1a39393..da053c05668 100644
--- a/tests/ui/manual_flatten.stderr
+++ b/tests/ui/manual_flatten.stderr
@@ -167,5 +167,33 @@ LL | |             println!("{:?}", n);
 LL | |         }
    | |_________^
 
-error: aborting due to 8 previous errors
+error: unnecessary `if let` since only the `Some` variant of the iterator element is used
+  --> $DIR/manual_flatten.rs:116:5
+   |
+LL | /     for n in vec![
+LL | |         Some(1),
+LL | |         Some(2),
+LL | |         Some(3)
+...  |
+LL | |         }
+LL | |     }
+   | |_____^
+   |
+help: remove the `if let` statement in the for loop and then...
+  --> $DIR/manual_flatten.rs:121:9
+   |
+LL | /         if let Some(n) = n {
+LL | |             println!("{:?}", n);
+LL | |         }
+   | |_________^
+help: try
+   |
+LL ~     for n in vec![
+LL +         Some(1),
+LL +         Some(2),
+LL +         Some(3)
+LL ~     ].iter().flatten() {
+   |
+
+error: aborting due to 9 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 565d3fd67d86fdc610e56c0f12133af1838b7cda Mon Sep 17 00:00:00 2001
From: Victor Nordam Suadicani <v.n.suadicani@gmail.com>
Date: Wed, 13 Jul 2022 12:59:55 +0200
Subject: Move to restriction

---
 clippy_lints/src/format_push_string.rs       | 2 +-
 clippy_lints/src/lib.register_pedantic.rs    | 1 -
 clippy_lints/src/lib.register_restriction.rs | 1 +
 3 files changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/format_push_string.rs b/clippy_lints/src/format_push_string.rs
index 2d01c71d438..17aa482d716 100644
--- a/clippy_lints/src/format_push_string.rs
+++ b/clippy_lints/src/format_push_string.rs
@@ -29,7 +29,7 @@ declare_clippy_lint! {
     /// ```
     #[clippy::version = "1.62.0"]
     pub FORMAT_PUSH_STRING,
-    pedantic,
+    restriction,
     "`format!(..)` appended to existing `String`"
 }
 declare_lint_pass!(FormatPushString => [FORMAT_PUSH_STRING]);
diff --git a/clippy_lints/src/lib.register_pedantic.rs b/clippy_lints/src/lib.register_pedantic.rs
index 0b7fff56a5d..4d4b89687d0 100644
--- a/clippy_lints/src/lib.register_pedantic.rs
+++ b/clippy_lints/src/lib.register_pedantic.rs
@@ -31,7 +31,6 @@ store.register_group(true, "clippy::pedantic", Some("clippy_pedantic"), vec![
     LintId::of(eta_reduction::REDUNDANT_CLOSURE_FOR_METHOD_CALLS),
     LintId::of(excessive_bools::FN_PARAMS_EXCESSIVE_BOOLS),
     LintId::of(excessive_bools::STRUCT_EXCESSIVE_BOOLS),
-    LintId::of(format_push_string::FORMAT_PUSH_STRING),
     LintId::of(functions::MUST_USE_CANDIDATE),
     LintId::of(functions::TOO_MANY_LINES),
     LintId::of(if_not_else::IF_NOT_ELSE),
diff --git a/clippy_lints/src/lib.register_restriction.rs b/clippy_lints/src/lib.register_restriction.rs
index 970e9db4772..88d43c8989f 100644
--- a/clippy_lints/src/lib.register_restriction.rs
+++ b/clippy_lints/src/lib.register_restriction.rs
@@ -21,6 +21,7 @@ store.register_group(true, "clippy::restriction", Some("clippy_restriction"), ve
     LintId::of(exhaustive_items::EXHAUSTIVE_STRUCTS),
     LintId::of(exit::EXIT),
     LintId::of(float_literal::LOSSY_FLOAT_LITERAL),
+    LintId::of(format_push_string::FORMAT_PUSH_STRING),
     LintId::of(if_then_some_else_none::IF_THEN_SOME_ELSE_NONE),
     LintId::of(implicit_return::IMPLICIT_RETURN),
     LintId::of(indexing_slicing::INDEXING_SLICING),
-- 
cgit 1.4.1-3-g733a5


From 0930ac91b9109e9ebc31ebe70620a2ec0fe08b57 Mon Sep 17 00:00:00 2001
From: bors <bors@rust-lang.org>
Date: Wed, 13 Jul 2022 14:48:32 +0000
Subject: Fix typos

changelog: none
---
 CHANGELOG.md                                                | 4 ++--
 book/src/usage.md                                           | 2 +-
 clippy_lints/src/borrow_deref_ref.rs                        | 2 +-
 clippy_lints/src/large_enum_variant.rs                      | 2 +-
 clippy_lints/src/loops/manual_find.rs                       | 2 +-
 clippy_lints/src/matches/match_same_arms.rs                 | 2 +-
 clippy_lints/src/mismatching_type_param_order.rs            | 2 +-
 clippy_lints/src/utils/internal_lints/metadata_collector.rs | 2 +-
 clippy_utils/src/visitors.rs                                | 2 +-
 tests/ui/if_let_mutex.rs                                    | 2 +-
 tests/ui/inconsistent_struct_constructor.fixed              | 2 +-
 tests/ui/inconsistent_struct_constructor.rs                 | 2 +-
 tests/ui/map_flatten_fixable.fixed                          | 2 +-
 tests/ui/map_flatten_fixable.rs                             | 2 +-
 tests/ui/map_flatten_fixable.stderr                         | 4 ++--
 tests/ui/same_name_method.rs                                | 2 +-
 tests/ui/transmutes_expressible_as_ptr_casts.fixed          | 2 +-
 tests/ui/transmutes_expressible_as_ptr_casts.rs             | 2 +-
 tests/ui/wildcard_imports.fixed                             | 2 +-
 tests/ui/wildcard_imports.rs                                | 2 +-
 20 files changed, 22 insertions(+), 22 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 1b792736a6a..201929ec11c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -364,7 +364,7 @@ Released 2022-04-07
 
 * [`needless_borrow`]: Prevent mutable borrows being moved and suggest removing the borrow on method calls
   [#8217](https://github.com/rust-lang/rust-clippy/pull/8217)
-* [`chars_next_cmp`]: Correctly excapes the suggestion
+* [`chars_next_cmp`]: Correctly escapes the suggestion
   [#8376](https://github.com/rust-lang/rust-clippy/pull/8376)
 * [`explicit_write`]: Add suggestions for `write!`s with format arguments
   [#8365](https://github.com/rust-lang/rust-clippy/pull/8365)
@@ -2525,7 +2525,7 @@ Released 2019-09-26
   * [`inherent_to_string_shadow_display`] [#4259](https://github.com/rust-lang/rust-clippy/pull/4259)
   * [`type_repetition_in_bounds`] [#3766](https://github.com/rust-lang/rust-clippy/pull/3766)
   * [`try_err`] [#4222](https://github.com/rust-lang/rust-clippy/pull/4222)
-* Move `{unnnecessary,panicking}_unwrap` out of nursery [#4307](https://github.com/rust-lang/rust-clippy/pull/4307)
+* Move `{unnecessary,panicking}_unwrap` out of nursery [#4307](https://github.com/rust-lang/rust-clippy/pull/4307)
 * Extend the `use_self` lint to suggest uses of `Self::Variant` [#4308](https://github.com/rust-lang/rust-clippy/pull/4308)
 * Improve suggestion for needless return [#4262](https://github.com/rust-lang/rust-clippy/pull/4262)
 * Add auto-fixable suggestion for `let_unit` [#4337](https://github.com/rust-lang/rust-clippy/pull/4337)
diff --git a/book/src/usage.md b/book/src/usage.md
index 337680aa313..f03967d88bc 100644
--- a/book/src/usage.md
+++ b/book/src/usage.md
@@ -56,7 +56,7 @@ For more information on configuring lint levels, see the [rustc documentation].
 Clippy has lint groups which are allow-by-default. This means, that you will
 have to enable the lints in those groups manually.
 
-For a full list of all lints with their description and examples, please refere
+For a full list of all lints with their description and examples, please refer
 to [Clippy's lint list]. The two most important allow-by-default groups are
 described below:
 
diff --git a/clippy_lints/src/borrow_deref_ref.rs b/clippy_lints/src/borrow_deref_ref.rs
index 1582ec9ee5c..937765b6614 100644
--- a/clippy_lints/src/borrow_deref_ref.rs
+++ b/clippy_lints/src/borrow_deref_ref.rs
@@ -22,7 +22,7 @@ declare_clippy_lint! {
     /// ```
     /// let x = &12;
     /// let addr_x = &x as *const _ as usize;
-    /// let addr_y = &&*x as *const _ as usize; // assert ok now, and lint triggerd.
+    /// let addr_y = &&*x as *const _ as usize; // assert ok now, and lint triggered.
     ///                                         // But if we fix it, assert will fail.
     /// assert_ne!(addr_x, addr_y);
     /// ```
diff --git a/clippy_lints/src/large_enum_variant.rs b/clippy_lints/src/large_enum_variant.rs
index 9be057bcf90..c58df126d62 100644
--- a/clippy_lints/src/large_enum_variant.rs
+++ b/clippy_lints/src/large_enum_variant.rs
@@ -30,7 +30,7 @@ declare_clippy_lint! {
     /// For types that implement `Copy`, the suggestion to `Box` a variant's
     /// data would require removing the trait impl. The types can of course
     /// still be `Clone`, but that is worse ergonomically. Depending on the
-    /// use case it may be possible to store the large data in an auxillary
+    /// use case it may be possible to store the large data in an auxiliary
     /// structure (e.g. Arena or ECS).
     ///
     /// The lint will ignore generic types if the layout depends on the
diff --git a/clippy_lints/src/loops/manual_find.rs b/clippy_lints/src/loops/manual_find.rs
index 33736d6d4e6..215c83a7edf 100644
--- a/clippy_lints/src/loops/manual_find.rs
+++ b/clippy_lints/src/loops/manual_find.rs
@@ -139,7 +139,7 @@ fn last_stmt_and_ret<'tcx>(
     if_chain! {
         // This should be the loop
         if let Some((node_hir, Node::Stmt(..))) = parent_iter.next();
-        // This should be the funciton body
+        // This should be the function body
         if let Some((_, Node::Block(block))) = parent_iter.next();
         if let Some((last_stmt, last_ret)) = extract(block);
         if last_stmt.hir_id == node_hir;
diff --git a/clippy_lints/src/matches/match_same_arms.rs b/clippy_lints/src/matches/match_same_arms.rs
index 61d28b15066..582782f245f 100644
--- a/clippy_lints/src/matches/match_same_arms.rs
+++ b/clippy_lints/src/matches/match_same_arms.rs
@@ -365,7 +365,7 @@ impl<'a> NormalizedPat<'a> {
             (Self::Slice(pats, None), Self::Slice(front, Some(back)))
             | (Self::Slice(front, Some(back)), Self::Slice(pats, None)) => {
                 // Here `pats` is an exact size match. If the combined lengths of `front` and `back` are greater
-                // then the minium length required will be greater than the length of `pats`.
+                // then the minimum length required will be greater than the length of `pats`.
                 if pats.len() < front.len() + back.len() {
                     return false;
                 }
diff --git a/clippy_lints/src/mismatching_type_param_order.rs b/clippy_lints/src/mismatching_type_param_order.rs
index d466d54a6ba..254d9a70010 100644
--- a/clippy_lints/src/mismatching_type_param_order.rs
+++ b/clippy_lints/src/mismatching_type_param_order.rs
@@ -9,7 +9,7 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for type parameters which are positioned inconsistently between
-    /// a type definition and impl block. Specifically, a paramater in an impl
+    /// a type definition and impl block. Specifically, a parameter in an impl
     /// block which has the same name as a parameter in the type def, but is in
     /// a different place.
     ///
diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index 3010fc0223c..aaeca47677d 100644
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -1018,7 +1018,7 @@ impl<'a, 'hir> intravisit::Visitor<'hir> for LintResolver<'a, 'hir> {
 /// This visitor finds the highest applicability value in the visited expressions
 struct ApplicabilityResolver<'a, 'hir> {
     cx: &'a LateContext<'hir>,
-    /// This is the index of hightest `Applicability` for `paths::APPLICABILITY_VALUES`
+    /// This is the index of highest `Applicability` for `paths::APPLICABILITY_VALUES`
     applicability_index: Option<usize>,
 }
 
diff --git a/clippy_utils/src/visitors.rs b/clippy_utils/src/visitors.rs
index 0b9f75238a6..bae8ad9f565 100644
--- a/clippy_utils/src/visitors.rs
+++ b/clippy_utils/src/visitors.rs
@@ -30,7 +30,7 @@ impl Continue for () {
     }
 }
 
-/// Allows for controlled descent whe using visitor functions. Use `()` instead when always
+/// Allows for controlled descent when using visitor functions. Use `()` instead when always
 /// descending into child nodes.
 #[derive(Clone, Copy)]
 pub enum Descend {
diff --git a/tests/ui/if_let_mutex.rs b/tests/ui/if_let_mutex.rs
index 58feae422a3..6cbfafbb38b 100644
--- a/tests/ui/if_let_mutex.rs
+++ b/tests/ui/if_let_mutex.rs
@@ -27,7 +27,7 @@ fn if_let_option() {
     };
 }
 
-// When mutexs are different don't warn
+// When mutexes are different don't warn
 fn if_let_different_mutex() {
     let m = Mutex::new(Some(0_u8));
     let other = Mutex::new(None::<u8>);
diff --git a/tests/ui/inconsistent_struct_constructor.fixed b/tests/ui/inconsistent_struct_constructor.fixed
index eb66d1afddc..74ba2f1c5e7 100644
--- a/tests/ui/inconsistent_struct_constructor.fixed
+++ b/tests/ui/inconsistent_struct_constructor.fixed
@@ -36,7 +36,7 @@ mod without_base {
         // issue #7069.
         new_foo!();
 
-        // Shoule NOT lint because the order is the same as in the definition.
+        // Should NOT lint because the order is the same as in the definition.
         Foo { x, y, z };
 
         // Should NOT lint because z is not a shorthand init.
diff --git a/tests/ui/inconsistent_struct_constructor.rs b/tests/ui/inconsistent_struct_constructor.rs
index 5caadc7c620..ba96e1e330f 100644
--- a/tests/ui/inconsistent_struct_constructor.rs
+++ b/tests/ui/inconsistent_struct_constructor.rs
@@ -36,7 +36,7 @@ mod without_base {
         // issue #7069.
         new_foo!();
 
-        // Shoule NOT lint because the order is the same as in the definition.
+        // Should NOT lint because the order is the same as in the definition.
         Foo { x, y, z };
 
         // Should NOT lint because z is not a shorthand init.
diff --git a/tests/ui/map_flatten_fixable.fixed b/tests/ui/map_flatten_fixable.fixed
index 9097a6b9967..312819a0a2c 100644
--- a/tests/ui/map_flatten_fixable.fixed
+++ b/tests/ui/map_flatten_fixable.fixed
@@ -58,7 +58,7 @@ fn issue8878() {
         .and_then(|_| {
 // we need some newlines
 // so that the span is big enough
-// for a splitted output of the diagnostic
+// for a split output of the diagnostic
             Some("")
  // whitespace beforehand is important as well
         });
diff --git a/tests/ui/map_flatten_fixable.rs b/tests/ui/map_flatten_fixable.rs
index 3916263404a..3fbf4f9a1b0 100644
--- a/tests/ui/map_flatten_fixable.rs
+++ b/tests/ui/map_flatten_fixable.rs
@@ -59,7 +59,7 @@ fn issue8878() {
         .map(|_| {
 // we need some newlines
 // so that the span is big enough
-// for a splitted output of the diagnostic
+// for a split output of the diagnostic
             Some("")
  // whitespace beforehand is important as well
         })
diff --git a/tests/ui/map_flatten_fixable.stderr b/tests/ui/map_flatten_fixable.stderr
index afaf6af66b2..c91f0b9ae94 100644
--- a/tests/ui/map_flatten_fixable.stderr
+++ b/tests/ui/map_flatten_fixable.stderr
@@ -78,7 +78,7 @@ LL |           .map(|_| {
    |  __________^
 LL | | // we need some newlines
 LL | | // so that the span is big enough
-LL | | // for a splitted output of the diagnostic
+LL | | // for a split output of the diagnostic
 ...  |
 LL | |         })
 LL | |         .flatten();
@@ -89,7 +89,7 @@ help: try replacing `map` with `and_then` and remove the `.flatten()`
 LL ~         .and_then(|_| {
 LL + // we need some newlines
 LL + // so that the span is big enough
-LL + // for a splitted output of the diagnostic
+LL + // for a split output of the diagnostic
 LL +             Some("")
 LL +  // whitespace beforehand is important as well
 LL ~         });
diff --git a/tests/ui/same_name_method.rs b/tests/ui/same_name_method.rs
index 9562b47f0c4..daef95a425c 100644
--- a/tests/ui/same_name_method.rs
+++ b/tests/ui/same_name_method.rs
@@ -62,7 +62,7 @@ mod should_lint {
         impl T1 for S {}
     }
 
-    mod mulitply_conflicit_trait {
+    mod multiply_conflicit_trait {
         use crate::{T1, T2};
 
         struct S;
diff --git a/tests/ui/transmutes_expressible_as_ptr_casts.fixed b/tests/ui/transmutes_expressible_as_ptr_casts.fixed
index b425cdd6cbf..539239fc18f 100644
--- a/tests/ui/transmutes_expressible_as_ptr_casts.fixed
+++ b/tests/ui/transmutes_expressible_as_ptr_casts.fixed
@@ -1,6 +1,6 @@
 // run-rustfix
 #![warn(clippy::transmutes_expressible_as_ptr_casts)]
-// These two warnings currrently cover the cases transmutes_expressible_as_ptr_casts
+// These two warnings currently cover the cases transmutes_expressible_as_ptr_casts
 // would otherwise be responsible for
 #![warn(clippy::useless_transmute)]
 #![warn(clippy::transmute_ptr_to_ptr)]
diff --git a/tests/ui/transmutes_expressible_as_ptr_casts.rs b/tests/ui/transmutes_expressible_as_ptr_casts.rs
index 8fd57c59652..b9e446dc89a 100644
--- a/tests/ui/transmutes_expressible_as_ptr_casts.rs
+++ b/tests/ui/transmutes_expressible_as_ptr_casts.rs
@@ -1,6 +1,6 @@
 // run-rustfix
 #![warn(clippy::transmutes_expressible_as_ptr_casts)]
-// These two warnings currrently cover the cases transmutes_expressible_as_ptr_casts
+// These two warnings currently cover the cases transmutes_expressible_as_ptr_casts
 // would otherwise be responsible for
 #![warn(clippy::useless_transmute)]
 #![warn(clippy::transmute_ptr_to_ptr)]
diff --git a/tests/ui/wildcard_imports.fixed b/tests/ui/wildcard_imports.fixed
index b6f47ae906b..ef55f1c31a8 100644
--- a/tests/ui/wildcard_imports.fixed
+++ b/tests/ui/wildcard_imports.fixed
@@ -199,7 +199,7 @@ mod super_imports {
         }
     }
 
-    mod should_be_replaced_futher_inside {
+    mod should_be_replaced_further_inside {
         fn insidefoo() {}
         mod inner {
             use super::insidefoo;
diff --git a/tests/ui/wildcard_imports.rs b/tests/ui/wildcard_imports.rs
index eb404b7a3de..b8128514206 100644
--- a/tests/ui/wildcard_imports.rs
+++ b/tests/ui/wildcard_imports.rs
@@ -200,7 +200,7 @@ mod super_imports {
         }
     }
 
-    mod should_be_replaced_futher_inside {
+    mod should_be_replaced_further_inside {
         fn insidefoo() {}
         mod inner {
             use super::*;
-- 
cgit 1.4.1-3-g733a5


From 467e1b23aa7f33e126bc92e89217158362129df4 Mon Sep 17 00:00:00 2001
From: Korlo <88337245+Rqnsom@users.noreply.github.com>
Date: Wed, 13 Jul 2022 17:02:09 +0200
Subject: box_collection: raise warn for all std collections

So far, only [Vec, String, Hashmap] were considered.

Extend collection checklist for this lint with:
- HashSet
- VecDeque
- LinkedList
- BTreeMap
- BTreeSet
- BinaryHeap
---
 clippy_lints/src/types/box_collection.rs | 27 ++++++++++-----
 tests/ui/box_collection.rs               | 16 +++++++--
 tests/ui/box_collection.stderr           | 56 +++++++++++++++++++++++++++++---
 3 files changed, 84 insertions(+), 15 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types/box_collection.rs b/clippy_lints/src/types/box_collection.rs
index 21a9558ec07..ba51404d214 100644
--- a/clippy_lints/src/types/box_collection.rs
+++ b/clippy_lints/src/types/box_collection.rs
@@ -15,19 +15,17 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_
                 sym::String => "",
                 _ => "<..>",
             };
+
+            let box_content = format!("{outer}{generic}", outer = item_type);
             span_lint_and_help(
                 cx,
                 BOX_COLLECTION,
                 hir_ty.span,
                 &format!(
-                    "you seem to be trying to use `Box<{outer}{generic}>`. Consider using just `{outer}{generic}`",
-                    outer=item_type,
-                    generic = generic),
+                    "you seem to be trying to use `Box<{box_content}>`. Consider using just `{box_content}`"),
                 None,
                 &format!(
-                    "`{outer}{generic}` is already on the heap, `Box<{outer}{generic}>` makes an extra allocation",
-                    outer=item_type,
-                    generic = generic)
+                    "`{box_content}` is already on the heap, `Box<{box_content}>` makes an extra allocation")
             );
             true
         } else {
@@ -39,7 +37,18 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_
 fn get_std_collection(cx: &LateContext<'_>, qpath: &QPath<'_>) -> Option<Symbol> {
     let param = qpath_generic_tys(qpath).next()?;
     let id = path_def_id(cx, param)?;
-    cx.tcx
-        .get_diagnostic_name(id)
-        .filter(|&name| matches!(name, sym::HashMap | sym::String | sym::Vec))
+    cx.tcx.get_diagnostic_name(id).filter(|&name| {
+        matches!(
+            name,
+            sym::HashMap
+                | sym::String
+                | sym::Vec
+                | sym::HashSet
+                | sym::VecDeque
+                | sym::LinkedList
+                | sym::BTreeMap
+                | sym::BTreeSet
+                | sym::BinaryHeap
+        )
+    })
 }
diff --git a/tests/ui/box_collection.rs b/tests/ui/box_collection.rs
index e00f061f28a..1a74cdb3ff6 100644
--- a/tests/ui/box_collection.rs
+++ b/tests/ui/box_collection.rs
@@ -6,7 +6,7 @@
     unused
 )]
 
-use std::collections::HashMap;
+use std::collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, LinkedList, VecDeque};
 
 macro_rules! boxit {
     ($init:expr, $x:ty) => {
@@ -18,7 +18,7 @@ fn test_macro() {
     boxit!(Vec::new(), Vec<u8>);
 }
 
-fn test(foo: Box<Vec<bool>>) {}
+fn test1(foo: Box<Vec<bool>>) {}
 
 fn test2(foo: Box<dyn Fn(Vec<u32>)>) {
     // pass if #31 is fixed
@@ -29,6 +29,18 @@ fn test3(foo: Box<String>) {}
 
 fn test4(foo: Box<HashMap<String, String>>) {}
 
+fn test5(foo: Box<HashSet<i64>>) {}
+
+fn test6(foo: Box<VecDeque<i32>>) {}
+
+fn test7(foo: Box<LinkedList<i16>>) {}
+
+fn test8(foo: Box<BTreeMap<i8, String>>) {}
+
+fn test9(foo: Box<BTreeSet<u64>>) {}
+
+fn test10(foo: Box<BinaryHeap<u32>>) {}
+
 fn test_local_not_linted() {
     let _: Box<Vec<bool>>;
 }
diff --git a/tests/ui/box_collection.stderr b/tests/ui/box_collection.stderr
index 6de85d05a99..2b28598ded9 100644
--- a/tests/ui/box_collection.stderr
+++ b/tests/ui/box_collection.stderr
@@ -1,8 +1,8 @@
 error: you seem to be trying to use `Box<Vec<..>>`. Consider using just `Vec<..>`
-  --> $DIR/box_collection.rs:21:14
+  --> $DIR/box_collection.rs:21:15
    |
-LL | fn test(foo: Box<Vec<bool>>) {}
-   |              ^^^^^^^^^^^^^^
+LL | fn test1(foo: Box<Vec<bool>>) {}
+   |               ^^^^^^^^^^^^^^
    |
    = note: `-D clippy::box-collection` implied by `-D warnings`
    = help: `Vec<..>` is already on the heap, `Box<Vec<..>>` makes an extra allocation
@@ -23,5 +23,53 @@ LL | fn test4(foo: Box<HashMap<String, String>>) {}
    |
    = help: `HashMap<..>` is already on the heap, `Box<HashMap<..>>` makes an extra allocation
 
-error: aborting due to 3 previous errors
+error: you seem to be trying to use `Box<HashSet<..>>`. Consider using just `HashSet<..>`
+  --> $DIR/box_collection.rs:32:15
+   |
+LL | fn test5(foo: Box<HashSet<i64>>) {}
+   |               ^^^^^^^^^^^^^^^^^
+   |
+   = help: `HashSet<..>` is already on the heap, `Box<HashSet<..>>` makes an extra allocation
+
+error: you seem to be trying to use `Box<VecDeque<..>>`. Consider using just `VecDeque<..>`
+  --> $DIR/box_collection.rs:34:15
+   |
+LL | fn test6(foo: Box<VecDeque<i32>>) {}
+   |               ^^^^^^^^^^^^^^^^^^
+   |
+   = help: `VecDeque<..>` is already on the heap, `Box<VecDeque<..>>` makes an extra allocation
+
+error: you seem to be trying to use `Box<LinkedList<..>>`. Consider using just `LinkedList<..>`
+  --> $DIR/box_collection.rs:36:15
+   |
+LL | fn test7(foo: Box<LinkedList<i16>>) {}
+   |               ^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: `LinkedList<..>` is already on the heap, `Box<LinkedList<..>>` makes an extra allocation
+
+error: you seem to be trying to use `Box<BTreeMap<..>>`. Consider using just `BTreeMap<..>`
+  --> $DIR/box_collection.rs:38:15
+   |
+LL | fn test8(foo: Box<BTreeMap<i8, String>>) {}
+   |               ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: `BTreeMap<..>` is already on the heap, `Box<BTreeMap<..>>` makes an extra allocation
+
+error: you seem to be trying to use `Box<BTreeSet<..>>`. Consider using just `BTreeSet<..>`
+  --> $DIR/box_collection.rs:40:15
+   |
+LL | fn test9(foo: Box<BTreeSet<u64>>) {}
+   |               ^^^^^^^^^^^^^^^^^^
+   |
+   = help: `BTreeSet<..>` is already on the heap, `Box<BTreeSet<..>>` makes an extra allocation
+
+error: you seem to be trying to use `Box<BinaryHeap<..>>`. Consider using just `BinaryHeap<..>`
+  --> $DIR/box_collection.rs:42:16
+   |
+LL | fn test10(foo: Box<BinaryHeap<u32>>) {}
+   |                ^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: `BinaryHeap<..>` is already on the heap, `Box<BinaryHeap<..>>` makes an extra allocation
+
+error: aborting due to 9 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 43ac256cd19ebb7a423ed75a2fd0e81af38ececc Mon Sep 17 00:00:00 2001
From: Victor Nordam Suadicani <v.n.suadicani@gmail.com>
Date: Thu, 14 Jul 2022 13:26:56 +0200
Subject: Add Known problems section

---
 clippy_lints/src/format_push_string.rs | 6 ++++++
 1 file changed, 6 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/format_push_string.rs b/clippy_lints/src/format_push_string.rs
index 17aa482d716..ebf5ab086dc 100644
--- a/clippy_lints/src/format_push_string.rs
+++ b/clippy_lints/src/format_push_string.rs
@@ -14,6 +14,12 @@ declare_clippy_lint! {
     /// ### Why is this bad?
     /// Introduces an extra, avoidable heap allocation.
     ///
+    /// ### Known problems
+    /// `format!` returns a `String` but `write!` returns a `Result`.
+    /// Thus you are forced to ignore the `Err` variant to achieve the same API.
+    ///
+    /// While using `write!` in the suggested way should never fail, this isn't necessarily clear to the programmer.
+    ///
     /// ### Example
     /// ```rust
     /// let mut s = String::new();
-- 
cgit 1.4.1-3-g733a5


From 2f825db5789678965861e5109aa30b9b9e2a7b4c Mon Sep 17 00:00:00 2001
From: i509VCB <git@i509.me>
Date: Fri, 1 Jul 2022 23:59:03 -0500
Subject: std_instead_of_core, std_instead_of_alloc, alloc_instead_of_core

---
 CHANGELOG.md                                 |   3 +
 clippy_lints/src/lib.register_lints.rs       |   3 +
 clippy_lints/src/lib.register_restriction.rs |   3 +
 clippy_lints/src/lib.rs                      |   2 +
 clippy_lints/src/std_instead_of_core.rs      | 134 +++++++++++++++++++++++++++
 tests/ui/std_instead_of_core.rs              |  39 ++++++++
 tests/ui/std_instead_of_core.stderr          |  85 +++++++++++++++++
 7 files changed, 269 insertions(+)
 create mode 100644 clippy_lints/src/std_instead_of_core.rs
 create mode 100644 tests/ui/std_instead_of_core.rs
 create mode 100644 tests/ui/std_instead_of_core.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 201929ec11c..920d397add7 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3432,6 +3432,7 @@ Released 2018-09-13
 <!-- lint disable no-unused-definitions -->
 <!-- begin autogenerated links to lint list -->
 [`absurd_extreme_comparisons`]: https://rust-lang.github.io/rust-clippy/master/index.html#absurd_extreme_comparisons
+[`alloc_instead_of_core`]: https://rust-lang.github.io/rust-clippy/master/index.html#alloc_instead_of_core
 [`allow_attributes_without_reason`]: https://rust-lang.github.io/rust-clippy/master/index.html#allow_attributes_without_reason
 [`almost_complete_letter_range`]: https://rust-lang.github.io/rust-clippy/master/index.html#almost_complete_letter_range
 [`almost_swapped`]: https://rust-lang.github.io/rust-clippy/master/index.html#almost_swapped
@@ -3901,6 +3902,8 @@ Released 2018-09-13
 [`skip_while_next`]: https://rust-lang.github.io/rust-clippy/master/index.html#skip_while_next
 [`slow_vector_initialization`]: https://rust-lang.github.io/rust-clippy/master/index.html#slow_vector_initialization
 [`stable_sort_primitive`]: https://rust-lang.github.io/rust-clippy/master/index.html#stable_sort_primitive
+[`std_instead_of_alloc`]: https://rust-lang.github.io/rust-clippy/master/index.html#std_instead_of_alloc
+[`std_instead_of_core`]: https://rust-lang.github.io/rust-clippy/master/index.html#std_instead_of_core
 [`str_to_string`]: https://rust-lang.github.io/rust-clippy/master/index.html#str_to_string
 [`string_add`]: https://rust-lang.github.io/rust-clippy/master/index.html#string_add
 [`string_add_assign`]: https://rust-lang.github.io/rust-clippy/master/index.html#string_add_assign
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index ceb8470657f..91d27bf526d 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -497,6 +497,9 @@ store.register_lints(&[
     size_of_in_element_count::SIZE_OF_IN_ELEMENT_COUNT,
     slow_vector_initialization::SLOW_VECTOR_INITIALIZATION,
     stable_sort_primitive::STABLE_SORT_PRIMITIVE,
+    std_instead_of_core::ALLOC_INSTEAD_OF_CORE,
+    std_instead_of_core::STD_INSTEAD_OF_ALLOC,
+    std_instead_of_core::STD_INSTEAD_OF_CORE,
     strings::STRING_ADD,
     strings::STRING_ADD_ASSIGN,
     strings::STRING_FROM_UTF8_AS_BYTES,
diff --git a/clippy_lints/src/lib.register_restriction.rs b/clippy_lints/src/lib.register_restriction.rs
index 88d43c8989f..43f1c892eb9 100644
--- a/clippy_lints/src/lib.register_restriction.rs
+++ b/clippy_lints/src/lib.register_restriction.rs
@@ -66,6 +66,9 @@ store.register_group(true, "clippy::restriction", Some("clippy_restriction"), ve
     LintId::of(shadow::SHADOW_SAME),
     LintId::of(shadow::SHADOW_UNRELATED),
     LintId::of(single_char_lifetime_names::SINGLE_CHAR_LIFETIME_NAMES),
+    LintId::of(std_instead_of_core::ALLOC_INSTEAD_OF_CORE),
+    LintId::of(std_instead_of_core::STD_INSTEAD_OF_ALLOC),
+    LintId::of(std_instead_of_core::STD_INSTEAD_OF_CORE),
     LintId::of(strings::STRING_ADD),
     LintId::of(strings::STRING_SLICE),
     LintId::of(strings::STRING_TO_STRING),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 1604d1078ee..4f9db4eb5ae 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -365,6 +365,7 @@ mod single_component_path_imports;
 mod size_of_in_element_count;
 mod slow_vector_initialization;
 mod stable_sort_primitive;
+mod std_instead_of_core;
 mod strings;
 mod strlen_on_c_strings;
 mod suspicious_operation_groupings;
@@ -915,6 +916,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     let verbose_bit_mask_threshold = conf.verbose_bit_mask_threshold;
     store.register_late_pass(move || Box::new(operators::Operators::new(verbose_bit_mask_threshold)));
     store.register_late_pass(|| Box::new(invalid_utf8_in_unchecked::InvalidUtf8InUnchecked));
+    store.register_late_pass(|| Box::new(std_instead_of_core::StdReexports));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/std_instead_of_core.rs b/clippy_lints/src/std_instead_of_core.rs
new file mode 100644
index 00000000000..56f2a7bae15
--- /dev/null
+++ b/clippy_lints/src/std_instead_of_core.rs
@@ -0,0 +1,134 @@
+use clippy_utils::diagnostics::span_lint_and_help;
+use rustc_hir::{def::Res, HirId, Path, PathSegment};
+use rustc_lint::{LateContext, LateLintPass, Lint};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::{sym, symbol::kw, Symbol};
+
+declare_clippy_lint! {
+    /// ### What it does
+    ///
+    /// Finds items imported through `std` when available through `core`.
+    ///
+    /// ### Why is this bad?
+    ///
+    /// Crates which have `no_std` compatibility may wish to ensure types are imported from core to ensure
+    /// disabling `std` does not cause the crate to fail to compile. This lint is also useful for crates
+    /// migrating to become `no_std` compatible.
+    ///
+    /// ### Example
+    /// ```rust
+    /// use std::hash::Hasher;
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// use core::hash::Hasher;
+    /// ```
+    #[clippy::version = "1.64.0"]
+    pub STD_INSTEAD_OF_CORE,
+    restriction,
+    "type is imported from std when available in core"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    ///
+    /// Finds items imported through `std` when available through `alloc`.
+    ///
+    /// ### Why is this bad?
+    ///
+    /// Crates which have `no_std` compatibility and require alloc may wish to ensure types are imported from
+    /// alloc to ensure disabling `std` does not cause the crate to fail to compile. This lint is also useful
+    /// for crates migrating to become `no_std` compatible.
+    ///
+    /// ### Example
+    /// ```rust
+    /// use std::vec::Vec;
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// # extern crate alloc;
+    /// use alloc::vec::Vec;
+    /// ```
+    #[clippy::version = "1.64.0"]
+    pub STD_INSTEAD_OF_ALLOC,
+    restriction,
+    "type is imported from std when available in alloc"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    ///
+    /// Finds items imported through `alloc` when available through `core`.
+    ///
+    /// ### Why is this bad?
+    ///
+    /// Crates which have `no_std` compatibility and may optionally require alloc may wish to ensure types are
+    /// imported from alloc to ensure disabling `alloc` does not cause the crate to fail to compile. This lint
+    /// is also useful for crates migrating to become `no_std` compatible.
+    ///
+    /// ### Example
+    /// ```rust
+    /// # extern crate alloc;
+    /// use alloc::slice::from_ref;
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// use core::slice::from_ref;
+    /// ```
+    #[clippy::version = "1.64.0"]
+    pub ALLOC_INSTEAD_OF_CORE,
+    restriction,
+    "type is imported from alloc when available in core"
+}
+
+declare_lint_pass!(StdReexports => [STD_INSTEAD_OF_CORE, STD_INSTEAD_OF_ALLOC, ALLOC_INSTEAD_OF_CORE]);
+
+impl<'tcx> LateLintPass<'tcx> for StdReexports {
+    fn check_path(&mut self, cx: &LateContext<'tcx>, path: &Path<'tcx>, _: HirId) {
+        // std_instead_of_core
+        check_path(cx, path, sym::std, sym::core, STD_INSTEAD_OF_CORE);
+        // std_instead_of_alloc
+        check_path(cx, path, sym::std, sym::alloc, STD_INSTEAD_OF_ALLOC);
+        // alloc_instead_of_core
+        check_path(cx, path, sym::alloc, sym::core, ALLOC_INSTEAD_OF_CORE);
+    }
+}
+
+fn check_path(cx: &LateContext<'_>, path: &Path<'_>, krate: Symbol, suggested_crate: Symbol, lint: &'static Lint) {
+    if_chain! {
+        // check if path resolves to the suggested crate.
+        if let Res::Def(_, def_id) = path.res;
+        if suggested_crate == cx.tcx.crate_name(def_id.krate);
+
+        // check if the first segment of the path is the crate we want to identify
+        if let Some(path_root_segment) = get_first_segment(path);
+
+        // check if the path matches the crate we want to suggest the other path for.
+        if krate == path_root_segment.ident.name;
+        then {
+            span_lint_and_help(
+                cx,
+                lint,
+                path.span,
+                &format!("used import from `{}` instead of `{}`", krate, suggested_crate),
+                None,
+                &format!("consider importing the item from `{}`", suggested_crate),
+            );
+        }
+    }
+}
+
+/// Returns the first named segment of a [`Path`].
+///
+/// If this is a global path (such as `::std::fmt::Debug`), then the segment after [`kw::PathRoot`]
+/// is returned.
+fn get_first_segment<'tcx>(path: &Path<'tcx>) -> Option<&'tcx PathSegment<'tcx>> {
+    let segment = path.segments.first()?;
+
+    // A global path will have PathRoot as the first segment. In this case, return the segment after.
+    if segment.ident.name == kw::PathRoot {
+        path.segments.get(1)
+    } else {
+        Some(segment)
+    }
+}
diff --git a/tests/ui/std_instead_of_core.rs b/tests/ui/std_instead_of_core.rs
new file mode 100644
index 00000000000..74f05ec1f65
--- /dev/null
+++ b/tests/ui/std_instead_of_core.rs
@@ -0,0 +1,39 @@
+#![warn(clippy::std_instead_of_core)]
+#![allow(unused_imports)]
+
+extern crate alloc;
+
+#[warn(clippy::std_instead_of_core)]
+fn std_instead_of_core() {
+    // Regular import
+    use std::hash::Hasher;
+    // Absolute path
+    use ::std::hash::Hash;
+
+    // Multiple imports
+    use std::fmt::{Debug, Result};
+
+    // Function calls
+    let ptr = std::ptr::null::<u32>();
+    let ptr_mut = ::std::ptr::null_mut::<usize>();
+
+    // Types
+    let cell = std::cell::Cell::new(8u32);
+    let cell_absolute = ::std::cell::Cell::new(8u32);
+}
+
+#[warn(clippy::std_instead_of_alloc)]
+fn std_instead_of_alloc() {
+    use std::vec::Vec;
+}
+
+#[warn(clippy::alloc_instead_of_core)]
+fn alloc_instead_of_core() {
+    use alloc::slice::from_ref;
+}
+
+fn main() {
+    std_instead_of_core();
+    std_instead_of_alloc();
+    alloc_instead_of_core();
+}
diff --git a/tests/ui/std_instead_of_core.stderr b/tests/ui/std_instead_of_core.stderr
new file mode 100644
index 00000000000..9f1644835c1
--- /dev/null
+++ b/tests/ui/std_instead_of_core.stderr
@@ -0,0 +1,85 @@
+error: used import from `std` instead of `core`
+  --> $DIR/std_instead_of_core.rs:9:9
+   |
+LL |     use std::hash::Hasher;
+   |         ^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::std-instead-of-core` implied by `-D warnings`
+   = help: consider importing the item from `core`
+
+error: used import from `std` instead of `core`
+  --> $DIR/std_instead_of_core.rs:11:9
+   |
+LL |     use ::std::hash::Hash;
+   |         ^^^^^^^^^^^^^^^^^
+   |
+   = help: consider importing the item from `core`
+
+error: used import from `std` instead of `core`
+  --> $DIR/std_instead_of_core.rs:14:20
+   |
+LL |     use std::fmt::{Debug, Result};
+   |                    ^^^^^
+   |
+   = help: consider importing the item from `core`
+
+error: used import from `std` instead of `core`
+  --> $DIR/std_instead_of_core.rs:14:27
+   |
+LL |     use std::fmt::{Debug, Result};
+   |                           ^^^^^^
+   |
+   = help: consider importing the item from `core`
+
+error: used import from `std` instead of `core`
+  --> $DIR/std_instead_of_core.rs:17:15
+   |
+LL |     let ptr = std::ptr::null::<u32>();
+   |               ^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider importing the item from `core`
+
+error: used import from `std` instead of `core`
+  --> $DIR/std_instead_of_core.rs:18:19
+   |
+LL |     let ptr_mut = ::std::ptr::null_mut::<usize>();
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider importing the item from `core`
+
+error: used import from `std` instead of `core`
+  --> $DIR/std_instead_of_core.rs:21:16
+   |
+LL |     let cell = std::cell::Cell::new(8u32);
+   |                ^^^^^^^^^^^^^^^
+   |
+   = help: consider importing the item from `core`
+
+error: used import from `std` instead of `core`
+  --> $DIR/std_instead_of_core.rs:22:25
+   |
+LL |     let cell_absolute = ::std::cell::Cell::new(8u32);
+   |                         ^^^^^^^^^^^^^^^^^
+   |
+   = help: consider importing the item from `core`
+
+error: used import from `std` instead of `alloc`
+  --> $DIR/std_instead_of_core.rs:27:9
+   |
+LL |     use std::vec::Vec;
+   |         ^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::std-instead-of-alloc` implied by `-D warnings`
+   = help: consider importing the item from `alloc`
+
+error: used import from `alloc` instead of `core`
+  --> $DIR/std_instead_of_core.rs:32:9
+   |
+LL |     use alloc::slice::from_ref;
+   |         ^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::alloc-instead-of-core` implied by `-D warnings`
+   = help: consider importing the item from `core`
+
+error: aborting due to 10 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 2894df34092ce5fb9bfcf74a22a397b17dfaf983 Mon Sep 17 00:00:00 2001
From: alex-semenyuk <alexsemenyuk88@gmail.com>
Date: Fri, 15 Jul 2022 09:15:31 +0300
Subject: match_like_matches_macro does not trigger when one arm contains
 contains a block with only a bool literal

---
 clippy_lints/src/matches/match_like_matches.rs | 10 +++++-----
 tests/ui/match_expr_like_matches_macro.fixed   |  6 ++++++
 tests/ui/match_expr_like_matches_macro.rs      | 12 ++++++++++++
 tests/ui/match_expr_like_matches_macro.stderr  | 27 +++++++++++++++++++-------
 4 files changed, 43 insertions(+), 12 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/match_like_matches.rs b/clippy_lints/src/matches/match_like_matches.rs
index a68eec842ab..0da4833f1df 100644
--- a/clippy_lints/src/matches/match_like_matches.rs
+++ b/clippy_lints/src/matches/match_like_matches.rs
@@ -81,14 +81,14 @@ where
         if let Some((_, last_pat_opt, last_expr, _)) = iter.next_back();
         let iter_without_last = iter.clone();
         if let Some((first_attrs, _, first_expr, first_guard)) = iter.next();
-        if let Some(b0) = find_bool_lit(&first_expr.kind, is_if_let);
-        if let Some(b1) = find_bool_lit(&last_expr.kind, is_if_let);
+        if let Some(b0) = find_bool_lit(&first_expr.kind);
+        if let Some(b1) = find_bool_lit(&last_expr.kind);
         if b0 != b1;
         if first_guard.is_none() || iter.len() == 0;
         if first_attrs.is_empty();
         if iter
             .all(|arm| {
-                find_bool_lit(&arm.2.kind, is_if_let).map_or(false, |b| b == b0) && arm.3.is_none() && arm.0.is_empty()
+                find_bool_lit(&arm.2.kind).map_or(false, |b| b == b0) && arm.3.is_none() && arm.0.is_empty()
             });
         then {
             if let Some(last_pat) = last_pat_opt {
@@ -144,7 +144,7 @@ where
 }
 
 /// Extract a `bool` or `{ bool }`
-fn find_bool_lit(ex: &ExprKind<'_>, is_if_let: bool) -> Option<bool> {
+fn find_bool_lit(ex: &ExprKind<'_>) -> Option<bool> {
     match ex {
         ExprKind::Lit(Spanned {
             node: LitKind::Bool(b), ..
@@ -156,7 +156,7 @@ fn find_bool_lit(ex: &ExprKind<'_>, is_if_let: bool) -> Option<bool> {
                 ..
             },
             _,
-        ) if is_if_let => {
+        ) => {
             if let ExprKind::Lit(Spanned {
                 node: LitKind::Bool(b), ..
             }) = exp.kind
diff --git a/tests/ui/match_expr_like_matches_macro.fixed b/tests/ui/match_expr_like_matches_macro.fixed
index 36f233f3346..1ccbfda64b7 100644
--- a/tests/ui/match_expr_like_matches_macro.fixed
+++ b/tests/ui/match_expr_like_matches_macro.fixed
@@ -45,6 +45,12 @@ fn main() {
         // lint
         let _ans = matches!(x, E::A(_) | E::B(_));
     }
+    {
+        // lint
+        // skip rustfmt to prevent removing block for first pattern
+        #[rustfmt::skip]
+        let _ans = matches!(x, E::A(_) | E::B(_));
+    }
     {
         // lint
         let _ans = !matches!(x, E::B(_) | E::C);
diff --git a/tests/ui/match_expr_like_matches_macro.rs b/tests/ui/match_expr_like_matches_macro.rs
index 750f69fa508..a49991f5941 100644
--- a/tests/ui/match_expr_like_matches_macro.rs
+++ b/tests/ui/match_expr_like_matches_macro.rs
@@ -61,6 +61,18 @@ fn main() {
             _ => false,
         };
     }
+    {
+        // lint
+        // skip rustfmt to prevent removing block for first pattern
+        #[rustfmt::skip]
+        let _ans = match x {
+            E::A(_) => {
+                true
+            }
+            E::B(_) => true,
+            _ => false,
+        };
+    }
     {
         // lint
         let _ans = match x {
diff --git a/tests/ui/match_expr_like_matches_macro.stderr b/tests/ui/match_expr_like_matches_macro.stderr
index d7cedf9f9f1..e94555e2744 100644
--- a/tests/ui/match_expr_like_matches_macro.stderr
+++ b/tests/ui/match_expr_like_matches_macro.stderr
@@ -60,7 +60,20 @@ LL | |         };
    | |_________^ help: try this: `matches!(x, E::A(_) | E::B(_))`
 
 error: match expression looks like `matches!` macro
-  --> $DIR/match_expr_like_matches_macro.rs:66:20
+  --> $DIR/match_expr_like_matches_macro.rs:68:20
+   |
+LL |           let _ans = match x {
+   |  ____________________^
+LL | |             E::A(_) => {
+LL | |                 true
+LL | |             }
+LL | |             E::B(_) => true,
+LL | |             _ => false,
+LL | |         };
+   | |_________^ help: try this: `matches!(x, E::A(_) | E::B(_))`
+
+error: match expression looks like `matches!` macro
+  --> $DIR/match_expr_like_matches_macro.rs:78:20
    |
 LL |           let _ans = match x {
    |  ____________________^
@@ -71,7 +84,7 @@ LL | |         };
    | |_________^ help: try this: `!matches!(x, E::B(_) | E::C)`
 
 error: match expression looks like `matches!` macro
-  --> $DIR/match_expr_like_matches_macro.rs:126:18
+  --> $DIR/match_expr_like_matches_macro.rs:138:18
    |
 LL |           let _z = match &z {
    |  __________________^
@@ -81,7 +94,7 @@ LL | |         };
    | |_________^ help: try this: `matches!(z, Some(3))`
 
 error: match expression looks like `matches!` macro
-  --> $DIR/match_expr_like_matches_macro.rs:135:18
+  --> $DIR/match_expr_like_matches_macro.rs:147:18
    |
 LL |           let _z = match &z {
    |  __________________^
@@ -91,7 +104,7 @@ LL | |         };
    | |_________^ help: try this: `matches!(&z, Some(3))`
 
 error: match expression looks like `matches!` macro
-  --> $DIR/match_expr_like_matches_macro.rs:152:21
+  --> $DIR/match_expr_like_matches_macro.rs:164:21
    |
 LL |               let _ = match &z {
    |  _____________________^
@@ -101,7 +114,7 @@ LL | |             };
    | |_____________^ help: try this: `matches!(&z, AnEnum::X)`
 
 error: match expression looks like `matches!` macro
-  --> $DIR/match_expr_like_matches_macro.rs:166:20
+  --> $DIR/match_expr_like_matches_macro.rs:178:20
    |
 LL |           let _res = match &val {
    |  ____________________^
@@ -111,7 +124,7 @@ LL | |         };
    | |_________^ help: try this: `matches!(&val, &Some(ref _a))`
 
 error: match expression looks like `matches!` macro
-  --> $DIR/match_expr_like_matches_macro.rs:178:20
+  --> $DIR/match_expr_like_matches_macro.rs:190:20
    |
 LL |           let _res = match &val {
    |  ____________________^
@@ -120,5 +133,5 @@ LL | |             _ => false,
 LL | |         };
    | |_________^ help: try this: `matches!(&val, &Some(ref _a))`
 
-error: aborting due to 12 previous errors
+error: aborting due to 13 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 4c43aa7053a38ea7e0bb3aca2ffec4e734f7164f Mon Sep 17 00:00:00 2001
From: Aaron Christiansen <aaronc20000@gmail.com>
Date: Sat, 25 Jun 2022 23:15:44 +0100
Subject: Fix suggestion for `async` in redundant_closure_call

Fix redundant_closure_call for single-expression async closures

Add Sugg::asyncify

Use Sugg for redundant_closure_call implementation
---
 clippy_lints/src/redundant_closure_call.rs     | 21 +++++++----
 clippy_utils/src/sugg.rs                       |  6 ++++
 tests/ui/redundant_closure_call_fixable.fixed  | 20 +++++++++++
 tests/ui/redundant_closure_call_fixable.rs     | 20 +++++++++++
 tests/ui/redundant_closure_call_fixable.stderr | 50 ++++++++++++++++++++++++--
 5 files changed, 109 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/redundant_closure_call.rs b/clippy_lints/src/redundant_closure_call.rs
index f5a93cebab8..74eea6de4bb 100644
--- a/clippy_lints/src/redundant_closure_call.rs
+++ b/clippy_lints/src/redundant_closure_call.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::{span_lint, span_lint_and_then};
-use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::sugg::Sugg;
 use if_chain::if_chain;
 use rustc_ast::ast;
 use rustc_ast::visit as ast_visit;
@@ -69,7 +69,7 @@ impl EarlyLintPass for RedundantClosureCall {
         if_chain! {
             if let ast::ExprKind::Call(ref paren, _) = expr.kind;
             if let ast::ExprKind::Paren(ref closure) = paren.kind;
-            if let ast::ExprKind::Closure(_, _, _, _, ref decl, ref block, _) = closure.kind;
+            if let ast::ExprKind::Closure(_, _, ref r#async, _, ref decl, ref block, _) = closure.kind;
             then {
                 let mut visitor = ReturnVisitor::new();
                 visitor.visit_expr(block);
@@ -81,10 +81,19 @@ impl EarlyLintPass for RedundantClosureCall {
                         "try not to call a closure in the expression where it is declared",
                         |diag| {
                             if decl.inputs.is_empty() {
-                                let mut app = Applicability::MachineApplicable;
-                                let hint =
-                                    snippet_with_applicability(cx, block.span, "..", &mut app).into_owned();
-                                diag.span_suggestion(expr.span, "try doing something like", hint, app);
+                                let app = Applicability::MachineApplicable;
+                                let mut hint = Sugg::ast(cx, block, "..");
+
+                                if r#async.is_async() {
+                                    // `async x` is a syntax error, so it becomes `async { x }`
+                                    if !matches!(block.kind, ast::ExprKind::Block(_, _)) {
+                                        hint = hint.blockify();
+                                    }
+
+                                    hint = hint.asyncify();
+                                }
+
+                                diag.span_suggestion(expr.span, "try doing something like", hint.to_string(), app);
                             }
                         },
                     );
diff --git a/clippy_utils/src/sugg.rs b/clippy_utils/src/sugg.rs
index bad291dfc25..081c98e2f3c 100644
--- a/clippy_utils/src/sugg.rs
+++ b/clippy_utils/src/sugg.rs
@@ -315,6 +315,12 @@ impl<'a> Sugg<'a> {
         Sugg::NonParen(Cow::Owned(format!("{{ {} }}", self)))
     }
 
+    /// Convenience method to prefix the expression with the `async` keyword.
+    /// Can be used after `blockify` to create an async block.
+    pub fn asyncify(self) -> Sugg<'static> {
+        Sugg::NonParen(Cow::Owned(format!("async {}", self)))
+    }
+
     /// Convenience method to create the `<lhs>..<rhs>` or `<lhs>...<rhs>`
     /// suggestion.
     pub fn range(self, end: &Self, limit: ast::RangeLimits) -> Sugg<'static> {
diff --git a/tests/ui/redundant_closure_call_fixable.fixed b/tests/ui/redundant_closure_call_fixable.fixed
index 0abca6fca06..7cd687c95a0 100644
--- a/tests/ui/redundant_closure_call_fixable.fixed
+++ b/tests/ui/redundant_closure_call_fixable.fixed
@@ -1,8 +1,28 @@
 // run-rustfix
 
+#![feature(async_closure)]
 #![warn(clippy::redundant_closure_call)]
 #![allow(unused)]
 
+async fn something() -> u32 {
+    21
+}
+
+async fn something_else() -> u32 {
+    2
+}
+
 fn main() {
     let a = 42;
+    let b = async {
+        let x = something().await;
+        let y = something_else().await;
+        x * y
+    };
+    let c = {
+        let x = 21;
+        let y = 2;
+        x * y
+    };
+    let d = async { something().await };
 }
diff --git a/tests/ui/redundant_closure_call_fixable.rs b/tests/ui/redundant_closure_call_fixable.rs
index f8b9d37a5cc..37e4d223864 100644
--- a/tests/ui/redundant_closure_call_fixable.rs
+++ b/tests/ui/redundant_closure_call_fixable.rs
@@ -1,8 +1,28 @@
 // run-rustfix
 
+#![feature(async_closure)]
 #![warn(clippy::redundant_closure_call)]
 #![allow(unused)]
 
+async fn something() -> u32 {
+    21
+}
+
+async fn something_else() -> u32 {
+    2
+}
+
 fn main() {
     let a = (|| 42)();
+    let b = (async || {
+        let x = something().await;
+        let y = something_else().await;
+        x * y
+    })();
+    let c = (|| {
+        let x = 21;
+        let y = 2;
+        x * y
+    })();
+    let d = (async || something().await)();
 }
diff --git a/tests/ui/redundant_closure_call_fixable.stderr b/tests/ui/redundant_closure_call_fixable.stderr
index afd704ef12a..56a8e57c0c3 100644
--- a/tests/ui/redundant_closure_call_fixable.stderr
+++ b/tests/ui/redundant_closure_call_fixable.stderr
@@ -1,10 +1,56 @@
 error: try not to call a closure in the expression where it is declared
-  --> $DIR/redundant_closure_call_fixable.rs:7:13
+  --> $DIR/redundant_closure_call_fixable.rs:16:13
    |
 LL |     let a = (|| 42)();
    |             ^^^^^^^^^ help: try doing something like: `42`
    |
    = note: `-D clippy::redundant-closure-call` implied by `-D warnings`
 
-error: aborting due to previous error
+error: try not to call a closure in the expression where it is declared
+  --> $DIR/redundant_closure_call_fixable.rs:17:13
+   |
+LL |       let b = (async || {
+   |  _____________^
+LL | |         let x = something().await;
+LL | |         let y = something_else().await;
+LL | |         x * y
+LL | |     })();
+   | |________^
+   |
+help: try doing something like
+   |
+LL ~     let b = async {
+LL +         let x = something().await;
+LL +         let y = something_else().await;
+LL +         x * y
+LL ~     };
+   |
+
+error: try not to call a closure in the expression where it is declared
+  --> $DIR/redundant_closure_call_fixable.rs:22:13
+   |
+LL |       let c = (|| {
+   |  _____________^
+LL | |         let x = 21;
+LL | |         let y = 2;
+LL | |         x * y
+LL | |     })();
+   | |________^
+   |
+help: try doing something like
+   |
+LL ~     let c = {
+LL +         let x = 21;
+LL +         let y = 2;
+LL +         x * y
+LL ~     };
+   |
+
+error: try not to call a closure in the expression where it is declared
+  --> $DIR/redundant_closure_call_fixable.rs:27:13
+   |
+LL |     let d = (async || something().await)();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try doing something like: `async { something().await }`
+
+error: aborting due to 4 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From e7804355de8bfc93b3604beec7a7c32665a305ee Mon Sep 17 00:00:00 2001
From: alexey semenyuk <alexsemenyuk88@gmail.com>
Date: Sun, 19 Jun 2022 14:15:14 +0000
Subject: NEEDLESS_OPTION_TAKE doc improvements

NEEDLESS_OPTION_TAKE doc improvements

NEEDLESS_OPTION_TAKE doc improvements

NEEDLESS_OPTION_TAKE doc improvements

NEEDLESS_OPTION_TAKE doc improvements

NEEDLESS_OPTION_TAKE doc improvements

NEEDLESS_OPTION_TAKE doc improvements

NEEDLESS_OPTION_TAKE doc improvements
---
 clippy_lints/src/methods/mod.rs | 4 ++++
 1 file changed, 4 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 9bb7bb7a7ab..4bdb5785cff 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -2225,8 +2225,12 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for calling `take` function after `as_ref`.
     ///
     /// ### Why is this bad?
+    /// Redundant code. `take` writes `None` to its argument.
+    /// In this case the modification is useless as it's a temporary that cannot be read from afterwards.
     ///
     /// ### Example
     /// ```rust
-- 
cgit 1.4.1-3-g733a5


From c990e2922ac7ff27e9a7516e9ac92cac5989c9e0 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Tue, 5 Jul 2022 16:03:51 -0400
Subject: Don't suggest using auto deref for block expressions

---
 clippy_lints/src/dereference.rs     | 127 ++++++++++++++++++++++++++----------
 tests/ui/explicit_auto_deref.fixed  |  17 +++++
 tests/ui/explicit_auto_deref.rs     |  17 +++++
 tests/ui/explicit_auto_deref.stderr |  72 ++++++++++----------
 4 files changed, 167 insertions(+), 66 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index 8c7cf7748be..b87d41455d9 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -17,7 +17,7 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::adjustment::{Adjust, Adjustment, AutoBorrow, AutoBorrowMutability};
 use rustc_middle::ty::{self, Ty, TyCtxt, TypeVisitable, TypeckResults};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::{symbol::sym, Span, Symbol};
+use rustc_span::{symbol::sym, Span, Symbol, DUMMY_SP};
 use rustc_trait_selection::infer::InferCtxtExt;
 
 declare_clippy_lint! {
@@ -609,18 +609,21 @@ enum Position {
     Postfix,
     Deref,
     /// Any other location which will trigger auto-deref to a specific time.
-    DerefStable(i8),
+    /// Contains the precedence of the parent expression and whether the target type is sized.
+    DerefStable(i8, bool),
     /// Any other location which will trigger auto-reborrowing.
+    /// Contains the precedence of the parent expression.
     ReborrowStable(i8),
+    /// Contains the precedence of the parent expression.
     Other(i8),
 }
 impl Position {
     fn is_deref_stable(self) -> bool {
-        matches!(self, Self::DerefStable(_))
+        matches!(self, Self::DerefStable(..))
     }
 
     fn is_reborrow_stable(self) -> bool {
-        matches!(self, Self::DerefStable(_) | Self::ReborrowStable(_))
+        matches!(self, Self::DerefStable(..) | Self::ReborrowStable(_))
     }
 
     fn can_auto_borrow(self) -> bool {
@@ -628,7 +631,7 @@ impl Position {
     }
 
     fn lint_explicit_deref(self) -> bool {
-        matches!(self, Self::Other(_) | Self::DerefStable(_) | Self::ReborrowStable(_))
+        matches!(self, Self::Other(_) | Self::DerefStable(..) | Self::ReborrowStable(_))
     }
 
     fn precedence(self) -> i8 {
@@ -639,7 +642,7 @@ impl Position {
             | Self::FieldAccess(_)
             | Self::Postfix => PREC_POSTFIX,
             Self::Deref => PREC_PREFIX,
-            Self::DerefStable(p) | Self::ReborrowStable(p) | Self::Other(p) => p,
+            Self::DerefStable(p, _) | Self::ReborrowStable(p) | Self::Other(p) => p,
         }
     }
 }
@@ -659,7 +662,7 @@ fn walk_parents<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> (Position, &
         }
         match parent {
             Node::Local(Local { ty: Some(ty), span, .. }) if span.ctxt() == ctxt => {
-                Some(binding_ty_auto_deref_stability(ty, precedence))
+                Some(binding_ty_auto_deref_stability(cx, ty, precedence))
             },
             Node::Item(&Item {
                 kind: ItemKind::Static(..) | ItemKind::Const(..),
@@ -680,8 +683,11 @@ fn walk_parents<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> (Position, &
                 ..
             }) if span.ctxt() == ctxt => {
                 let ty = cx.tcx.type_of(def_id);
-                Some(if ty.is_ref() {
-                    Position::DerefStable(precedence)
+                Some(if let ty::Ref(_, ty, _) = *ty.kind() {
+                    Position::DerefStable(
+                        precedence,
+                        ty.is_sized(cx.tcx.at(DUMMY_SP), cx.param_env.without_caller_bounds()),
+                    )
                 } else {
                     Position::Other(precedence)
                 })
@@ -705,13 +711,20 @@ fn walk_parents<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> (Position, &
                 span,
                 ..
             }) if span.ctxt() == ctxt => {
-                let output = cx.tcx.fn_sig(def_id.to_def_id()).skip_binder().output();
-                Some(if !output.is_ref() {
-                    Position::Other(precedence)
-                } else if output.has_placeholders() || output.has_opaque_types() {
-                    Position::ReborrowStable(precedence)
+                let output = cx
+                    .tcx
+                    .erase_late_bound_regions(cx.tcx.fn_sig(def_id.to_def_id()).output());
+                Some(if let ty::Ref(_, ty, _) = *output.kind() {
+                    if ty.has_placeholders() || ty.has_opaque_types() {
+                        Position::ReborrowStable(precedence)
+                    } else {
+                        Position::DerefStable(
+                            precedence,
+                            ty.is_sized(cx.tcx.at(DUMMY_SP), cx.param_env.without_caller_bounds()),
+                        )
+                    }
                 } else {
-                    Position::DerefStable(precedence)
+                    Position::Other(precedence)
                 })
             },
 
@@ -725,21 +738,24 @@ fn walk_parents<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> (Position, &
                         }) = cx.tcx.hir().get(owner_id)
                         {
                             match fn_decl.output {
-                                FnRetTy::Return(ty) => binding_ty_auto_deref_stability(ty, precedence),
+                                FnRetTy::Return(ty) => binding_ty_auto_deref_stability(cx, ty, precedence),
                                 FnRetTy::DefaultReturn(_) => Position::Other(precedence),
                             }
                         } else {
                             let output = cx
                                 .tcx
-                                .fn_sig(cx.tcx.hir().local_def_id(owner_id))
-                                .skip_binder()
-                                .output();
-                            if !output.is_ref() {
-                                Position::Other(precedence)
-                            } else if output.has_placeholders() || output.has_opaque_types() {
-                                Position::ReborrowStable(precedence)
+                                .erase_late_bound_regions(cx.tcx.fn_sig(cx.tcx.hir().local_def_id(owner_id)).output());
+                            if let ty::Ref(_, ty, _) = *output.kind() {
+                                if ty.has_placeholders() || ty.has_opaque_types() {
+                                    Position::ReborrowStable(precedence)
+                                } else {
+                                    Position::DerefStable(
+                                        precedence,
+                                        ty.is_sized(cx.tcx.at(DUMMY_SP), cx.param_env.without_caller_bounds()),
+                                    )
+                                }
                             } else {
-                                Position::DerefStable(precedence)
+                                Position::Other(precedence)
                             }
                         },
                     )
@@ -755,8 +771,8 @@ fn walk_parents<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> (Position, &
                     .map(|(hir_ty, ty)| match hir_ty {
                         // Type inference for closures can depend on how they're called. Only go by the explicit
                         // types here.
-                        Some(ty) => binding_ty_auto_deref_stability(ty, precedence),
-                        None => param_auto_deref_stability(ty.skip_binder(), precedence),
+                        Some(ty) => binding_ty_auto_deref_stability(cx, ty, precedence),
+                        None => param_auto_deref_stability(cx, cx.tcx.erase_late_bound_regions(ty), precedence),
                     }),
                 ExprKind::MethodCall(_, args, _) => {
                     let id = cx.typeck_results().type_dependent_def_id(parent.hir_id).unwrap();
@@ -797,7 +813,11 @@ fn walk_parents<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> (Position, &
                                 Position::MethodReceiver
                             }
                         } else {
-                            param_auto_deref_stability(cx.tcx.fn_sig(id).skip_binder().inputs()[i], precedence)
+                            param_auto_deref_stability(
+                                cx,
+                                cx.tcx.erase_late_bound_regions(cx.tcx.fn_sig(id).input(i)),
+                                precedence,
+                            )
                         }
                     })
                 },
@@ -808,7 +828,7 @@ fn walk_parents<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> (Position, &
                         .find(|f| f.expr.hir_id == child_id)
                         .zip(variant)
                         .and_then(|(field, variant)| variant.fields.iter().find(|f| f.name == field.ident.name))
-                        .map(|field| param_auto_deref_stability(cx.tcx.type_of(field.did), precedence))
+                        .map(|field| param_auto_deref_stability(cx, cx.tcx.type_of(field.did), precedence))
                 },
                 ExprKind::Field(child, name) if child.hir_id == e.hir_id => Some(Position::FieldAccess(name.name)),
                 ExprKind::Unary(UnOp::Deref, child) if child.hir_id == e.hir_id => Some(Position::Deref),
@@ -840,7 +860,7 @@ fn walk_parents<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> (Position, &
 //
 // Here `y1` and `y2` would resolve to different types, so the type `&Box<_>` is not stable when
 // switching to auto-dereferencing.
-fn binding_ty_auto_deref_stability(ty: &hir::Ty<'_>, precedence: i8) -> Position {
+fn binding_ty_auto_deref_stability(cx: &LateContext<'_>, ty: &hir::Ty<'_>, precedence: i8) -> Position {
     let TyKind::Rptr(_, ty) = &ty.kind else {
         return Position::Other(precedence);
     };
@@ -870,7 +890,13 @@ fn binding_ty_auto_deref_stability(ty: &hir::Ty<'_>, precedence: i8) -> Position
                 {
                     Position::ReborrowStable(precedence)
                 } else {
-                    Position::DerefStable(precedence)
+                    Position::DerefStable(
+                        precedence,
+                        cx
+                            .typeck_results()
+                            .node_type(ty.ty.hir_id)
+                            .is_sized(cx.tcx.at(DUMMY_SP), cx.param_env.without_caller_bounds()),
+                    )
                 }
             },
             TyKind::Slice(_)
@@ -880,7 +906,13 @@ fn binding_ty_auto_deref_stability(ty: &hir::Ty<'_>, precedence: i8) -> Position
             | TyKind::Tup(_)
             | TyKind::Ptr(_)
             | TyKind::TraitObject(..)
-            | TyKind::Path(_) => Position::DerefStable(precedence),
+            | TyKind::Path(_) => Position::DerefStable(
+                precedence,
+                cx
+                    .typeck_results()
+                    .node_type(ty.ty.hir_id)
+                    .is_sized(cx.tcx.at(DUMMY_SP), cx.param_env.without_caller_bounds()),
+            ),
             TyKind::OpaqueDef(..)
             | TyKind::Infer
             | TyKind::Typeof(..)
@@ -921,7 +953,7 @@ fn ty_contains_infer(ty: &hir::Ty<'_>) -> bool {
 }
 
 // Checks whether a type is stable when switching to auto dereferencing,
-fn param_auto_deref_stability(ty: Ty<'_>, precedence: i8) -> Position {
+fn param_auto_deref_stability<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>, precedence: i8) -> Position {
     let ty::Ref(_, mut ty, _) = *ty.kind() else {
         return Position::Other(precedence);
     };
@@ -960,7 +992,10 @@ fn param_auto_deref_stability(ty: Ty<'_>, precedence: i8) -> Position {
             | ty::GeneratorWitness(..)
             | ty::Never
             | ty::Tuple(_)
-            | ty::Projection(_) => Position::DerefStable(precedence),
+            | ty::Projection(_) => Position::DerefStable(
+                precedence,
+                ty.is_sized(cx.tcx.at(DUMMY_SP), cx.param_env.without_caller_bounds()),
+            ),
         };
     }
 }
@@ -1040,6 +1075,19 @@ fn report<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, state: State, data
             });
         },
         State::ExplicitDeref { deref_span_id } => {
+            if matches!(
+                expr.kind,
+                ExprKind::Block(..)
+                    | ExprKind::ConstBlock(_)
+                    | ExprKind::If(..)
+                    | ExprKind::Loop(..)
+                    | ExprKind::Match(..)
+            ) && matches!(data.position, Position::DerefStable(_, true))
+            {
+                // Rustc bug: auto deref doesn't work on block expression when targeting sized types.
+                return;
+            }
+
             let (span, hir_id, precedence) = if let Some((span, hir_id)) = deref_span_id
                 && !cx.typeck_results().expr_ty(expr).is_ref()
             {
@@ -1067,6 +1115,19 @@ fn report<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, state: State, data
             );
         },
         State::ExplicitDerefField { .. } => {
+            if matches!(
+                expr.kind,
+                ExprKind::Block(..)
+                    | ExprKind::ConstBlock(_)
+                    | ExprKind::If(..)
+                    | ExprKind::Loop(..)
+                    | ExprKind::Match(..)
+            ) && matches!(data.position, Position::DerefStable(_, true))
+            {
+                // Rustc bug: auto deref doesn't work on block expression when targeting sized types.
+                return;
+            }
+
             span_lint_hir_and_then(
                 cx,
                 EXPLICIT_AUTO_DEREF,
diff --git a/tests/ui/explicit_auto_deref.fixed b/tests/ui/explicit_auto_deref.fixed
index a650fdc1f89..327cfbaf324 100644
--- a/tests/ui/explicit_auto_deref.fixed
+++ b/tests/ui/explicit_auto_deref.fixed
@@ -67,6 +67,7 @@ fn main() {
     let s = String::new();
 
     let _: &str = &s;
+    let _: &str = &{ String::new() };
     let _ = &*s; // Don't lint. Inferred type would change.
     let _: &_ = &*s; // Don't lint. Inferred type would change.
 
@@ -215,4 +216,20 @@ fn main() {
     let s = &"str";
     let _ = || return *s;
     let _ = || -> &'static str { return s };
+
+    struct X;
+    struct Y(X);
+    impl core::ops::Deref for Y {
+        type Target = X;
+        fn deref(&self) -> &Self::Target {
+            &self.0
+        }
+    }
+    let _: &X = &*{ Y(X) };
+    let _: &X = &*match 0 {
+        #[rustfmt::skip]
+        0 => { Y(X) },
+        _ => panic!(),
+    };
+    let _: &X = &*if true { Y(X) } else { panic!() };
 }
diff --git a/tests/ui/explicit_auto_deref.rs b/tests/ui/explicit_auto_deref.rs
index 8f4f352576a..471a03d60a9 100644
--- a/tests/ui/explicit_auto_deref.rs
+++ b/tests/ui/explicit_auto_deref.rs
@@ -67,6 +67,7 @@ fn main() {
     let s = String::new();
 
     let _: &str = &*s;
+    let _: &str = &*{ String::new() };
     let _ = &*s; // Don't lint. Inferred type would change.
     let _: &_ = &*s; // Don't lint. Inferred type would change.
 
@@ -215,4 +216,20 @@ fn main() {
     let s = &"str";
     let _ = || return *s;
     let _ = || -> &'static str { return *s };
+
+    struct X;
+    struct Y(X);
+    impl core::ops::Deref for Y {
+        type Target = X;
+        fn deref(&self) -> &Self::Target {
+            &self.0
+        }
+    }
+    let _: &X = &*{ Y(X) };
+    let _: &X = &*match 0 {
+        #[rustfmt::skip]
+        0 => { Y(X) },
+        _ => panic!(),
+    };
+    let _: &X = &*if true { Y(X) } else { panic!() };
 }
diff --git a/tests/ui/explicit_auto_deref.stderr b/tests/ui/explicit_auto_deref.stderr
index 92765307ea7..d1bc51f5bdd 100644
--- a/tests/ui/explicit_auto_deref.stderr
+++ b/tests/ui/explicit_auto_deref.stderr
@@ -7,196 +7,202 @@ LL |     let _: &str = &*s;
    = note: `-D clippy::explicit-auto-deref` implied by `-D warnings`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:73:12
+  --> $DIR/explicit_auto_deref.rs:70:20
+   |
+LL |     let _: &str = &*{ String::new() };
+   |                    ^^^^^^^^^^^^^^^^^^ help: try this: `{ String::new() }`
+
+error: deref which would be done by auto-deref
+  --> $DIR/explicit_auto_deref.rs:74:12
    |
 LL |     f_str(&*s);
    |            ^^ help: try this: `s`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:77:14
+  --> $DIR/explicit_auto_deref.rs:78:14
    |
 LL |     f_str_t(&*s, &*s); // Don't lint second param.
    |              ^^ help: try this: `s`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:80:25
+  --> $DIR/explicit_auto_deref.rs:81:25
    |
 LL |     let _: &Box<i32> = &**b;
    |                         ^^^ help: try this: `b`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:86:8
+  --> $DIR/explicit_auto_deref.rs:87:8
    |
 LL |     c(&*s);
    |        ^^ help: try this: `s`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:92:9
+  --> $DIR/explicit_auto_deref.rs:93:9
    |
 LL |         &**x
    |         ^^^^ help: try this: `x`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:96:11
+  --> $DIR/explicit_auto_deref.rs:97:11
    |
 LL |         { &**x }
    |           ^^^^ help: try this: `x`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:100:9
+  --> $DIR/explicit_auto_deref.rs:101:9
    |
 LL |         &**{ x }
    |         ^^^^^^^^ help: try this: `{ x }`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:104:9
+  --> $DIR/explicit_auto_deref.rs:105:9
    |
 LL |         &***x
    |         ^^^^^ help: try this: `x`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:121:13
+  --> $DIR/explicit_auto_deref.rs:122:13
    |
 LL |         f1(&*x);
    |             ^^ help: try this: `x`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:122:13
+  --> $DIR/explicit_auto_deref.rs:123:13
    |
 LL |         f2(&*x);
    |             ^^ help: try this: `x`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:123:13
+  --> $DIR/explicit_auto_deref.rs:124:13
    |
 LL |         f3(&*x);
    |             ^^ help: try this: `x`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:124:28
+  --> $DIR/explicit_auto_deref.rs:125:28
    |
 LL |         f4.callable_str()(&*x);
    |                            ^^ help: try this: `x`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:125:13
+  --> $DIR/explicit_auto_deref.rs:126:13
    |
 LL |         f5(&*x);
    |             ^^ help: try this: `x`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:126:13
+  --> $DIR/explicit_auto_deref.rs:127:13
    |
 LL |         f6(&*x);
    |             ^^ help: try this: `x`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:127:28
+  --> $DIR/explicit_auto_deref.rs:128:28
    |
 LL |         f7.callable_str()(&*x);
    |                            ^^ help: try this: `x`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:128:26
+  --> $DIR/explicit_auto_deref.rs:129:26
    |
 LL |         f8.callable_t()(&*x);
    |                          ^^ help: try this: `x`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:129:13
+  --> $DIR/explicit_auto_deref.rs:130:13
    |
 LL |         f9(&*x);
    |             ^^ help: try this: `x`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:130:14
+  --> $DIR/explicit_auto_deref.rs:131:14
    |
 LL |         f10(&*x);
    |              ^^ help: try this: `x`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:131:27
+  --> $DIR/explicit_auto_deref.rs:132:27
    |
 LL |         f11.callable_t()(&*x);
    |                           ^^ help: try this: `x`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:135:17
+  --> $DIR/explicit_auto_deref.rs:136:17
    |
 LL |     let _ = S1(&*s);
    |                 ^^ help: try this: `s`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:140:22
+  --> $DIR/explicit_auto_deref.rs:141:22
    |
 LL |     let _ = S2 { s: &*s };
    |                      ^^ help: try this: `s`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:156:30
+  --> $DIR/explicit_auto_deref.rs:157:30
    |
 LL |             let _ = Self::S1(&**s);
    |                              ^^^^ help: try this: `s`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:157:35
+  --> $DIR/explicit_auto_deref.rs:158:35
    |
 LL |             let _ = Self::S2 { s: &**s };
    |                                   ^^^^ help: try this: `s`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:160:21
+  --> $DIR/explicit_auto_deref.rs:161:21
    |
 LL |     let _ = E1::S1(&*s);
    |                     ^^ help: try this: `s`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:161:26
+  --> $DIR/explicit_auto_deref.rs:162:26
    |
 LL |     let _ = E1::S2 { s: &*s };
    |                          ^^ help: try this: `s`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:179:13
+  --> $DIR/explicit_auto_deref.rs:180:13
    |
 LL |     let _ = (*b).foo;
    |             ^^^^ help: try this: `b`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:180:13
+  --> $DIR/explicit_auto_deref.rs:181:13
    |
 LL |     let _ = (**b).foo;
    |             ^^^^^ help: try this: `b`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:195:19
+  --> $DIR/explicit_auto_deref.rs:196:19
    |
 LL |     let _ = f_str(*ref_str);
    |                   ^^^^^^^^ help: try this: `ref_str`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:197:19
+  --> $DIR/explicit_auto_deref.rs:198:19
    |
 LL |     let _ = f_str(**ref_ref_str);
    |                   ^^^^^^^^^^^^^ help: try this: `ref_ref_str`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:207:13
+  --> $DIR/explicit_auto_deref.rs:208:13
    |
 LL |     f_str(&&*ref_str); // `needless_borrow` will suggest removing both references
    |             ^^^^^^^^ help: try this: `ref_str`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:208:12
+  --> $DIR/explicit_auto_deref.rs:209:12
    |
 LL |     f_str(&&**ref_str); // `needless_borrow` will suggest removing only one reference
    |            ^^^^^^^^^^ help: try this: `ref_str`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:217:41
+  --> $DIR/explicit_auto_deref.rs:218:41
    |
 LL |     let _ = || -> &'static str { return *s };
    |                                         ^^ help: try this: `s`
 
-error: aborting due to 33 previous errors
+error: aborting due to 34 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 9ce0f82b8ab44869777d441b51aecfb9d8ebdef9 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Tue, 5 Jul 2022 22:30:36 -0400
Subject: Include the borrow in the suggestion for `explicit_auto_deref`

---
 clippy_lints/src/dereference.rs     |  79 +++++++++++-------------
 tests/ui/explicit_auto_deref.fixed  |   1 +
 tests/ui/explicit_auto_deref.rs     |   1 +
 tests/ui/explicit_auto_deref.stderr | 118 +++++++++++++++++++-----------------
 4 files changed, 98 insertions(+), 101 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index b87d41455d9..8495d2c6df7 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -183,24 +183,24 @@ enum State {
     },
     DerefedBorrow(DerefedBorrow),
     ExplicitDeref {
-        // Span and id of the top-level deref expression if the parent expression is a borrow.
-        deref_span_id: Option<(Span, HirId)>,
+        mutability: Option<Mutability>,
     },
     ExplicitDerefField {
         name: Symbol,
     },
     Reborrow {
-        deref_span: Span,
-        deref_hir_id: HirId,
+        mutability: Mutability,
+    },
+    Borrow {
+        mutability: Mutability,
     },
-    Borrow,
 }
 
 // A reference operation considered by this lint pass
 enum RefOp {
     Method(Mutability),
     Deref,
-    AddrOf,
+    AddrOf(Mutability),
 }
 
 struct RefPat {
@@ -263,7 +263,7 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing {
                             ));
                         } else if position.is_deref_stable() {
                             self.state = Some((
-                                State::ExplicitDeref { deref_span_id: None },
+                                State::ExplicitDeref { mutability: None },
                                 StateData { span: expr.span, hir_id: expr.hir_id, position },
                             ));
                         }
@@ -289,7 +289,7 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing {
                             },
                         ));
                     },
-                    RefOp::AddrOf => {
+                    RefOp::AddrOf(mutability) => {
                         // Find the number of times the borrow is auto-derefed.
                         let mut iter = adjustments.iter();
                         let mut deref_count = 0usize;
@@ -359,7 +359,7 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing {
                             ));
                         } else if position.is_deref_stable() {
                             self.state = Some((
-                                State::Borrow,
+                                State::Borrow { mutability },
                                 StateData {
                                     span: expr.span,
                                     hir_id: expr.hir_id,
@@ -395,7 +395,7 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing {
                     data,
                 ));
             },
-            (Some((State::DerefedBorrow(state), data)), RefOp::AddrOf) if state.count != 0 => {
+            (Some((State::DerefedBorrow(state), data)), RefOp::AddrOf(_)) if state.count != 0 => {
                 self.state = Some((
                     State::DerefedBorrow(DerefedBorrow {
                         count: state.count - 1,
@@ -404,12 +404,12 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing {
                     data,
                 ));
             },
-            (Some((State::DerefedBorrow(state), data)), RefOp::AddrOf) => {
+            (Some((State::DerefedBorrow(state), data)), RefOp::AddrOf(mutability)) => {
                 let position = data.position;
                 report(cx, expr, State::DerefedBorrow(state), data);
                 if position.is_deref_stable() {
                     self.state = Some((
-                        State::Borrow,
+                        State::Borrow { mutability },
                         StateData {
                             span: expr.span,
                             hir_id: expr.hir_id,
@@ -430,43 +430,28 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing {
                     ));
                 } else if position.is_deref_stable() {
                     self.state = Some((
-                        State::ExplicitDeref { deref_span_id: None },
+                        State::ExplicitDeref { mutability: None },
                         StateData { span: expr.span, hir_id: expr.hir_id, position },
                     ));
                 }
             },
 
-            (Some((State::Borrow, data)), RefOp::Deref) => {
+            (Some((State::Borrow { mutability }, data)), RefOp::Deref) => {
                 if typeck.expr_ty(sub_expr).is_ref() {
-                    self.state = Some((
-                        State::Reborrow {
-                            deref_span: expr.span,
-                            deref_hir_id: expr.hir_id,
-                        },
-                        data,
-                    ));
+                    self.state = Some((State::Reborrow { mutability }, data));
                 } else {
                     self.state = Some((
                         State::ExplicitDeref {
-                            deref_span_id: Some((expr.span, expr.hir_id)),
+                            mutability: Some(mutability),
                         },
                         data,
                     ));
                 }
             },
-            (
-                Some((
-                    State::Reborrow {
-                        deref_span,
-                        deref_hir_id,
-                    },
-                    data,
-                )),
-                RefOp::Deref,
-            ) => {
+            (Some((State::Reborrow { mutability }, data)), RefOp::Deref) => {
                 self.state = Some((
                     State::ExplicitDeref {
-                        deref_span_id: Some((deref_span, deref_hir_id)),
+                        mutability: Some(mutability),
                     },
                     data,
                 ));
@@ -573,7 +558,7 @@ fn try_parse_ref_op<'tcx>(
         ExprKind::Unary(UnOp::Deref, sub_expr) if !typeck.expr_ty(sub_expr).is_unsafe_ptr() => {
             return Some((RefOp::Deref, sub_expr));
         },
-        ExprKind::AddrOf(BorrowKind::Ref, _, sub_expr) => return Some((RefOp::AddrOf, sub_expr)),
+        ExprKind::AddrOf(BorrowKind::Ref, mutability, sub_expr) => return Some((RefOp::AddrOf(mutability), sub_expr)),
         _ => return None,
     };
     if tcx.is_diagnostic_item(sym::deref_method, def_id) {
@@ -1074,7 +1059,7 @@ fn report<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, state: State, data
                 diag.span_suggestion(data.span, "change this to", sugg, app);
             });
         },
-        State::ExplicitDeref { deref_span_id } => {
+        State::ExplicitDeref { mutability } => {
             if matches!(
                 expr.kind,
                 ExprKind::Block(..)
@@ -1088,29 +1073,33 @@ fn report<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, state: State, data
                 return;
             }
 
-            let (span, hir_id, precedence) = if let Some((span, hir_id)) = deref_span_id
+            let (prefix, precedence) = if let Some(mutability) = mutability
                 && !cx.typeck_results().expr_ty(expr).is_ref()
             {
-                (span, hir_id, PREC_PREFIX)
+                let prefix = match mutability {
+                    Mutability::Not => "&",
+                    Mutability::Mut => "&mut ",
+                };
+                (prefix, 0)
             } else {
-                (data.span, data.hir_id, data.position.precedence())
+                ("", data.position.precedence())
             };
             span_lint_hir_and_then(
                 cx,
                 EXPLICIT_AUTO_DEREF,
-                hir_id,
-                span,
+                data.hir_id,
+                data.span,
                 "deref which would be done by auto-deref",
                 |diag| {
                     let mut app = Applicability::MachineApplicable;
-                    let (snip, snip_is_macro) = snippet_with_context(cx, expr.span, span.ctxt(), "..", &mut app);
+                    let (snip, snip_is_macro) = snippet_with_context(cx, expr.span, data.span.ctxt(), "..", &mut app);
                     let sugg =
                         if !snip_is_macro && expr.precedence().order() < precedence && !has_enclosing_paren(&snip) {
-                            format!("({})", snip)
+                            format!("{}({})", prefix, snip)
                         } else {
-                            snip.into()
+                            format!("{}{}", prefix, snip)
                         };
-                    diag.span_suggestion(span, "try this", sugg, app);
+                    diag.span_suggestion(data.span, "try this", sugg, app);
                 },
             );
         },
@@ -1141,7 +1130,7 @@ fn report<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, state: State, data
                 },
             );
         },
-        State::Borrow | State::Reborrow { .. } => (),
+        State::Borrow { .. } | State::Reborrow { .. } => (),
     }
 }
 
diff --git a/tests/ui/explicit_auto_deref.fixed b/tests/ui/explicit_auto_deref.fixed
index 327cfbaf324..d3efc299414 100644
--- a/tests/ui/explicit_auto_deref.fixed
+++ b/tests/ui/explicit_auto_deref.fixed
@@ -68,6 +68,7 @@ fn main() {
 
     let _: &str = &s;
     let _: &str = &{ String::new() };
+    let _: &str = &mut { String::new() };
     let _ = &*s; // Don't lint. Inferred type would change.
     let _: &_ = &*s; // Don't lint. Inferred type would change.
 
diff --git a/tests/ui/explicit_auto_deref.rs b/tests/ui/explicit_auto_deref.rs
index 471a03d60a9..e25ccbe78ce 100644
--- a/tests/ui/explicit_auto_deref.rs
+++ b/tests/ui/explicit_auto_deref.rs
@@ -68,6 +68,7 @@ fn main() {
 
     let _: &str = &*s;
     let _: &str = &*{ String::new() };
+    let _: &str = &mut *{ String::new() };
     let _ = &*s; // Don't lint. Inferred type would change.
     let _: &_ = &*s; // Don't lint. Inferred type would change.
 
diff --git a/tests/ui/explicit_auto_deref.stderr b/tests/ui/explicit_auto_deref.stderr
index d1bc51f5bdd..0d7a9564a90 100644
--- a/tests/ui/explicit_auto_deref.stderr
+++ b/tests/ui/explicit_auto_deref.stderr
@@ -1,208 +1,214 @@
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:69:20
+  --> $DIR/explicit_auto_deref.rs:69:19
    |
 LL |     let _: &str = &*s;
-   |                    ^^ help: try this: `s`
+   |                   ^^^ help: try this: `&s`
    |
    = note: `-D clippy::explicit-auto-deref` implied by `-D warnings`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:70:20
+  --> $DIR/explicit_auto_deref.rs:70:19
    |
 LL |     let _: &str = &*{ String::new() };
-   |                    ^^^^^^^^^^^^^^^^^^ help: try this: `{ String::new() }`
+   |                   ^^^^^^^^^^^^^^^^^^^ help: try this: `&{ String::new() }`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:74:12
+  --> $DIR/explicit_auto_deref.rs:71:19
+   |
+LL |     let _: &str = &mut *{ String::new() };
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&mut { String::new() }`
+
+error: deref which would be done by auto-deref
+  --> $DIR/explicit_auto_deref.rs:75:11
    |
 LL |     f_str(&*s);
-   |            ^^ help: try this: `s`
+   |           ^^^ help: try this: `&s`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:78:14
+  --> $DIR/explicit_auto_deref.rs:79:13
    |
 LL |     f_str_t(&*s, &*s); // Don't lint second param.
-   |              ^^ help: try this: `s`
+   |             ^^^ help: try this: `&s`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:81:25
+  --> $DIR/explicit_auto_deref.rs:82:24
    |
 LL |     let _: &Box<i32> = &**b;
-   |                         ^^^ help: try this: `b`
+   |                        ^^^^ help: try this: `&b`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:87:8
+  --> $DIR/explicit_auto_deref.rs:88:7
    |
 LL |     c(&*s);
-   |        ^^ help: try this: `s`
+   |       ^^^ help: try this: `&s`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:93:9
+  --> $DIR/explicit_auto_deref.rs:94:9
    |
 LL |         &**x
    |         ^^^^ help: try this: `x`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:97:11
+  --> $DIR/explicit_auto_deref.rs:98:11
    |
 LL |         { &**x }
    |           ^^^^ help: try this: `x`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:101:9
+  --> $DIR/explicit_auto_deref.rs:102:9
    |
 LL |         &**{ x }
    |         ^^^^^^^^ help: try this: `{ x }`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:105:9
+  --> $DIR/explicit_auto_deref.rs:106:9
    |
 LL |         &***x
    |         ^^^^^ help: try this: `x`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:122:13
+  --> $DIR/explicit_auto_deref.rs:123:12
    |
 LL |         f1(&*x);
-   |             ^^ help: try this: `x`
+   |            ^^^ help: try this: `&x`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:123:13
+  --> $DIR/explicit_auto_deref.rs:124:12
    |
 LL |         f2(&*x);
-   |             ^^ help: try this: `x`
+   |            ^^^ help: try this: `&x`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:124:13
+  --> $DIR/explicit_auto_deref.rs:125:12
    |
 LL |         f3(&*x);
-   |             ^^ help: try this: `x`
+   |            ^^^ help: try this: `&x`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:125:28
+  --> $DIR/explicit_auto_deref.rs:126:27
    |
 LL |         f4.callable_str()(&*x);
-   |                            ^^ help: try this: `x`
+   |                           ^^^ help: try this: `&x`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:126:13
+  --> $DIR/explicit_auto_deref.rs:127:12
    |
 LL |         f5(&*x);
-   |             ^^ help: try this: `x`
+   |            ^^^ help: try this: `&x`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:127:13
+  --> $DIR/explicit_auto_deref.rs:128:12
    |
 LL |         f6(&*x);
-   |             ^^ help: try this: `x`
+   |            ^^^ help: try this: `&x`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:128:28
+  --> $DIR/explicit_auto_deref.rs:129:27
    |
 LL |         f7.callable_str()(&*x);
-   |                            ^^ help: try this: `x`
+   |                           ^^^ help: try this: `&x`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:129:26
+  --> $DIR/explicit_auto_deref.rs:130:25
    |
 LL |         f8.callable_t()(&*x);
-   |                          ^^ help: try this: `x`
+   |                         ^^^ help: try this: `&x`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:130:13
+  --> $DIR/explicit_auto_deref.rs:131:12
    |
 LL |         f9(&*x);
-   |             ^^ help: try this: `x`
+   |            ^^^ help: try this: `&x`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:131:14
+  --> $DIR/explicit_auto_deref.rs:132:13
    |
 LL |         f10(&*x);
-   |              ^^ help: try this: `x`
+   |             ^^^ help: try this: `&x`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:132:27
+  --> $DIR/explicit_auto_deref.rs:133:26
    |
 LL |         f11.callable_t()(&*x);
-   |                           ^^ help: try this: `x`
+   |                          ^^^ help: try this: `&x`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:136:17
+  --> $DIR/explicit_auto_deref.rs:137:16
    |
 LL |     let _ = S1(&*s);
-   |                 ^^ help: try this: `s`
+   |                ^^^ help: try this: `&s`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:141:22
+  --> $DIR/explicit_auto_deref.rs:142:21
    |
 LL |     let _ = S2 { s: &*s };
-   |                      ^^ help: try this: `s`
+   |                     ^^^ help: try this: `&s`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:157:30
+  --> $DIR/explicit_auto_deref.rs:158:30
    |
 LL |             let _ = Self::S1(&**s);
    |                              ^^^^ help: try this: `s`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:158:35
+  --> $DIR/explicit_auto_deref.rs:159:35
    |
 LL |             let _ = Self::S2 { s: &**s };
    |                                   ^^^^ help: try this: `s`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:161:21
+  --> $DIR/explicit_auto_deref.rs:162:20
    |
 LL |     let _ = E1::S1(&*s);
-   |                     ^^ help: try this: `s`
+   |                    ^^^ help: try this: `&s`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:162:26
+  --> $DIR/explicit_auto_deref.rs:163:25
    |
 LL |     let _ = E1::S2 { s: &*s };
-   |                          ^^ help: try this: `s`
+   |                         ^^^ help: try this: `&s`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:180:13
+  --> $DIR/explicit_auto_deref.rs:181:13
    |
 LL |     let _ = (*b).foo;
    |             ^^^^ help: try this: `b`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:181:13
+  --> $DIR/explicit_auto_deref.rs:182:13
    |
 LL |     let _ = (**b).foo;
    |             ^^^^^ help: try this: `b`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:196:19
+  --> $DIR/explicit_auto_deref.rs:197:19
    |
 LL |     let _ = f_str(*ref_str);
    |                   ^^^^^^^^ help: try this: `ref_str`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:198:19
+  --> $DIR/explicit_auto_deref.rs:199:19
    |
 LL |     let _ = f_str(**ref_ref_str);
    |                   ^^^^^^^^^^^^^ help: try this: `ref_ref_str`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:208:13
+  --> $DIR/explicit_auto_deref.rs:209:13
    |
 LL |     f_str(&&*ref_str); // `needless_borrow` will suggest removing both references
    |             ^^^^^^^^ help: try this: `ref_str`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:209:12
+  --> $DIR/explicit_auto_deref.rs:210:12
    |
 LL |     f_str(&&**ref_str); // `needless_borrow` will suggest removing only one reference
    |            ^^^^^^^^^^ help: try this: `ref_str`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:218:41
+  --> $DIR/explicit_auto_deref.rs:219:41
    |
 LL |     let _ = || -> &'static str { return *s };
    |                                         ^^ help: try this: `s`
 
-error: aborting due to 34 previous errors
+error: aborting due to 35 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 84e03b621522799a72f55d3e728d63aebb561139 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sun, 10 Jul 2022 15:04:29 -0400
Subject: Don't lint `explicit_auto_deref` on `dyn Trait` return

---
 clippy_lints/src/dereference.rs     | 122 +++++++++++++++++++-----------------
 clippy_utils/src/ty.rs              |  51 +++++++++------
 tests/ui/explicit_auto_deref.fixed  |   9 +++
 tests/ui/explicit_auto_deref.rs     |   9 +++
 tests/ui/explicit_auto_deref.stderr |   8 ++-
 5 files changed, 119 insertions(+), 80 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index 8495d2c6df7..40e62dbd586 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -668,14 +668,7 @@ fn walk_parents<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> (Position, &
                 ..
             }) if span.ctxt() == ctxt => {
                 let ty = cx.tcx.type_of(def_id);
-                Some(if let ty::Ref(_, ty, _) = *ty.kind() {
-                    Position::DerefStable(
-                        precedence,
-                        ty.is_sized(cx.tcx.at(DUMMY_SP), cx.param_env.without_caller_bounds()),
-                    )
-                } else {
-                    Position::Other(precedence)
-                })
+                Some(ty_auto_deref_stability(cx, ty, precedence).position_for_result(cx))
             },
 
             Node::Item(&Item {
@@ -699,18 +692,7 @@ fn walk_parents<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> (Position, &
                 let output = cx
                     .tcx
                     .erase_late_bound_regions(cx.tcx.fn_sig(def_id.to_def_id()).output());
-                Some(if let ty::Ref(_, ty, _) = *output.kind() {
-                    if ty.has_placeholders() || ty.has_opaque_types() {
-                        Position::ReborrowStable(precedence)
-                    } else {
-                        Position::DerefStable(
-                            precedence,
-                            ty.is_sized(cx.tcx.at(DUMMY_SP), cx.param_env.without_caller_bounds()),
-                        )
-                    }
-                } else {
-                    Position::Other(precedence)
-                })
+                Some(ty_auto_deref_stability(cx, output, precedence).position_for_result(cx))
             },
 
             Node::Expr(parent) if parent.span.ctxt() == ctxt => match parent.kind {
@@ -730,18 +712,7 @@ fn walk_parents<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> (Position, &
                             let output = cx
                                 .tcx
                                 .erase_late_bound_regions(cx.tcx.fn_sig(cx.tcx.hir().local_def_id(owner_id)).output());
-                            if let ty::Ref(_, ty, _) = *output.kind() {
-                                if ty.has_placeholders() || ty.has_opaque_types() {
-                                    Position::ReborrowStable(precedence)
-                                } else {
-                                    Position::DerefStable(
-                                        precedence,
-                                        ty.is_sized(cx.tcx.at(DUMMY_SP), cx.param_env.without_caller_bounds()),
-                                    )
-                                }
-                            } else {
-                                Position::Other(precedence)
-                            }
+                            ty_auto_deref_stability(cx, output, precedence).position_for_result(cx)
                         },
                     )
                 },
@@ -757,7 +728,8 @@ fn walk_parents<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> (Position, &
                         // Type inference for closures can depend on how they're called. Only go by the explicit
                         // types here.
                         Some(ty) => binding_ty_auto_deref_stability(cx, ty, precedence),
-                        None => param_auto_deref_stability(cx, cx.tcx.erase_late_bound_regions(ty), precedence),
+                        None => ty_auto_deref_stability(cx, cx.tcx.erase_late_bound_regions(ty), precedence)
+                            .position_for_arg(),
                     }),
                 ExprKind::MethodCall(_, args, _) => {
                     let id = cx.typeck_results().type_dependent_def_id(parent.hir_id).unwrap();
@@ -798,11 +770,12 @@ fn walk_parents<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> (Position, &
                                 Position::MethodReceiver
                             }
                         } else {
-                            param_auto_deref_stability(
+                            ty_auto_deref_stability(
                                 cx,
                                 cx.tcx.erase_late_bound_regions(cx.tcx.fn_sig(id).input(i)),
                                 precedence,
                             )
+                            .position_for_arg()
                         }
                     })
                 },
@@ -813,7 +786,9 @@ fn walk_parents<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> (Position, &
                         .find(|f| f.expr.hir_id == child_id)
                         .zip(variant)
                         .and_then(|(field, variant)| variant.fields.iter().find(|f| f.name == field.ident.name))
-                        .map(|field| param_auto_deref_stability(cx, cx.tcx.type_of(field.did), precedence))
+                        .map(|field| {
+                            ty_auto_deref_stability(cx, cx.tcx.type_of(field.did), precedence).position_for_arg()
+                        })
                 },
                 ExprKind::Field(child, name) if child.hir_id == e.hir_id => Some(Position::FieldAccess(name.name)),
                 ExprKind::Unary(UnOp::Deref, child) if child.hir_id == e.hir_id => Some(Position::Deref),
@@ -890,17 +865,17 @@ fn binding_ty_auto_deref_stability(cx: &LateContext<'_>, ty: &hir::Ty<'_>, prece
             | TyKind::Never
             | TyKind::Tup(_)
             | TyKind::Ptr(_)
-            | TyKind::TraitObject(..)
             | TyKind::Path(_) => Position::DerefStable(
                 precedence,
                 cx
-                    .typeck_results()
-                    .node_type(ty.ty.hir_id)
-                    .is_sized(cx.tcx.at(DUMMY_SP), cx.param_env.without_caller_bounds()),
+                .typeck_results()
+                .node_type(ty.ty.hir_id)
+                .is_sized(cx.tcx.at(DUMMY_SP), cx.param_env.without_caller_bounds()),
             ),
             TyKind::OpaqueDef(..)
             | TyKind::Infer
             | TyKind::Typeof(..)
+            | TyKind::TraitObject(..)
             | TyKind::Err => Position::ReborrowStable(precedence),
         };
     }
@@ -937,10 +912,39 @@ fn ty_contains_infer(ty: &hir::Ty<'_>) -> bool {
     v.0
 }
 
+struct TyPosition<'tcx> {
+    position: Position,
+    ty: Option<Ty<'tcx>>,
+}
+impl From<Position> for TyPosition<'_> {
+    fn from(position: Position) -> Self {
+        Self { position, ty: None }
+    }
+}
+impl<'tcx> TyPosition<'tcx> {
+    fn new_deref_stable_for_result(precedence: i8, ty: Ty<'tcx>) -> Self {
+        Self {
+            position: Position::ReborrowStable(precedence),
+            ty: Some(ty),
+        }
+    }
+    fn position_for_result(self, cx: &LateContext<'tcx>) -> Position {
+        match (self.position, self.ty) {
+            (Position::ReborrowStable(precedence), Some(ty)) => {
+                Position::DerefStable(precedence, ty.is_sized(cx.tcx.at(DUMMY_SP), cx.param_env))
+            },
+            (position, _) => position,
+        }
+    }
+    fn position_for_arg(self) -> Position {
+        self.position
+    }
+}
+
 // Checks whether a type is stable when switching to auto dereferencing,
-fn param_auto_deref_stability<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>, precedence: i8) -> Position {
+fn ty_auto_deref_stability<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>, precedence: i8) -> TyPosition<'tcx> {
     let ty::Ref(_, mut ty, _) = *ty.kind() else {
-        return Position::Other(precedence);
+        return Position::Other(precedence).into();
     };
 
     loop {
@@ -949,38 +953,38 @@ fn param_auto_deref_stability<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>, preced
                 ty = ref_ty;
                 continue;
             },
-            ty::Infer(_)
-            | ty::Error(_)
-            | ty::Param(_)
-            | ty::Bound(..)
-            | ty::Opaque(..)
-            | ty::Placeholder(_)
-            | ty::Dynamic(..) => Position::ReborrowStable(precedence),
-            ty::Adt(..) if ty.has_placeholders() || ty.has_param_types_or_consts() => {
-                Position::ReborrowStable(precedence)
+            ty::Param(_) => TyPosition::new_deref_stable_for_result(precedence, ty),
+            ty::Infer(_) | ty::Error(_) | ty::Bound(..) | ty::Opaque(..) | ty::Placeholder(_) | ty::Dynamic(..) => {
+                Position::ReborrowStable(precedence).into()
             },
-            ty::Adt(..)
-            | ty::Bool
+            ty::Adt(..) if ty.has_placeholders() || ty.has_opaque_types() => {
+                Position::ReborrowStable(precedence).into()
+            },
+            ty::Adt(_, substs) if substs.has_param_types_or_consts() => {
+                TyPosition::new_deref_stable_for_result(precedence, ty)
+            },
+            ty::Bool
             | ty::Char
             | ty::Int(_)
             | ty::Uint(_)
-            | ty::Float(_)
-            | ty::Foreign(_)
-            | ty::Str
             | ty::Array(..)
-            | ty::Slice(..)
+            | ty::Float(_)
             | ty::RawPtr(..)
+            | ty::FnPtr(_) => Position::DerefStable(precedence, true).into(),
+            ty::Str | ty::Slice(..) => Position::DerefStable(precedence, false).into(),
+            ty::Adt(..)
+            | ty::Foreign(_)
             | ty::FnDef(..)
-            | ty::FnPtr(_)
-            | ty::Closure(..)
             | ty::Generator(..)
             | ty::GeneratorWitness(..)
+            | ty::Closure(..)
             | ty::Never
             | ty::Tuple(_)
             | ty::Projection(_) => Position::DerefStable(
                 precedence,
                 ty.is_sized(cx.tcx.at(DUMMY_SP), cx.param_env.without_caller_bounds()),
-            ),
+            )
+            .into(),
         };
     }
 }
diff --git a/clippy_utils/src/ty.rs b/clippy_utils/src/ty.rs
index a05d633d980..d394360fc67 100644
--- a/clippy_utils/src/ty.rs
+++ b/clippy_utils/src/ty.rs
@@ -503,7 +503,7 @@ pub fn all_predicates_of(tcx: TyCtxt<'_>, id: DefId) -> impl Iterator<Item = &(P
 pub enum ExprFnSig<'tcx> {
     Sig(Binder<'tcx, FnSig<'tcx>>, Option<DefId>),
     Closure(Option<&'tcx FnDecl<'tcx>>, Binder<'tcx, FnSig<'tcx>>),
-    Trait(Binder<'tcx, Ty<'tcx>>, Option<Binder<'tcx, Ty<'tcx>>>),
+    Trait(Binder<'tcx, Ty<'tcx>>, Option<Binder<'tcx, Ty<'tcx>>>, Option<DefId>),
 }
 impl<'tcx> ExprFnSig<'tcx> {
     /// Gets the argument type at the given offset. This will return `None` when the index is out of
@@ -518,7 +518,7 @@ impl<'tcx> ExprFnSig<'tcx> {
                 }
             },
             Self::Closure(_, sig) => Some(sig.input(0).map_bound(|ty| ty.tuple_fields()[i])),
-            Self::Trait(inputs, _) => Some(inputs.map_bound(|ty| ty.tuple_fields()[i])),
+            Self::Trait(inputs, _, _) => Some(inputs.map_bound(|ty| ty.tuple_fields()[i])),
         }
     }
 
@@ -541,7 +541,7 @@ impl<'tcx> ExprFnSig<'tcx> {
                 decl.and_then(|decl| decl.inputs.get(i)),
                 sig.input(0).map_bound(|ty| ty.tuple_fields()[i]),
             )),
-            Self::Trait(inputs, _) => Some((None, inputs.map_bound(|ty| ty.tuple_fields()[i]))),
+            Self::Trait(inputs, _, _) => Some((None, inputs.map_bound(|ty| ty.tuple_fields()[i]))),
         }
     }
 
@@ -550,12 +550,16 @@ impl<'tcx> ExprFnSig<'tcx> {
     pub fn output(self) -> Option<Binder<'tcx, Ty<'tcx>>> {
         match self {
             Self::Sig(sig, _) | Self::Closure(_, sig) => Some(sig.output()),
-            Self::Trait(_, output) => output,
+            Self::Trait(_, output, _) => output,
         }
     }
 
     pub fn predicates_id(&self) -> Option<DefId> {
-        if let ExprFnSig::Sig(_, id) = *self { id } else { None }
+        if let ExprFnSig::Sig(_, id) | ExprFnSig::Trait(_, _, id) = *self {
+            id
+        } else {
+            None
+        }
     }
 }
 
@@ -580,7 +584,7 @@ fn ty_sig<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Option<ExprFnSig<'tcx>>
             Some(ExprFnSig::Closure(decl, subs.as_closure().sig()))
         },
         ty::FnDef(id, subs) => Some(ExprFnSig::Sig(cx.tcx.bound_fn_sig(id).subst(cx.tcx, subs), Some(id))),
-        ty::Opaque(id, _) => ty_sig(cx, cx.tcx.type_of(id)),
+        ty::Opaque(id, _) => sig_from_bounds(cx, ty, cx.tcx.item_bounds(id), cx.tcx.opt_parent(id)),
         ty::FnPtr(sig) => Some(ExprFnSig::Sig(sig, None)),
         ty::Dynamic(bounds, _) => {
             let lang_items = cx.tcx.lang_items();
@@ -594,26 +598,31 @@ fn ty_sig<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Option<ExprFnSig<'tcx>>
                         .projection_bounds()
                         .find(|p| lang_items.fn_once_output().map_or(false, |id| id == p.item_def_id()))
                         .map(|p| p.map_bound(|p| p.term.ty().unwrap()));
-                    Some(ExprFnSig::Trait(bound.map_bound(|b| b.substs.type_at(0)), output))
+                    Some(ExprFnSig::Trait(bound.map_bound(|b| b.substs.type_at(0)), output, None))
                 },
                 _ => None,
             }
         },
         ty::Projection(proj) => match cx.tcx.try_normalize_erasing_regions(cx.param_env, ty) {
             Ok(normalized_ty) if normalized_ty != ty => ty_sig(cx, normalized_ty),
-            _ => sig_for_projection(cx, proj).or_else(|| sig_from_bounds(cx, ty)),
+            _ => sig_for_projection(cx, proj).or_else(|| sig_from_bounds(cx, ty, cx.param_env.caller_bounds(), None)),
         },
-        ty::Param(_) => sig_from_bounds(cx, ty),
+        ty::Param(_) => sig_from_bounds(cx, ty, cx.param_env.caller_bounds(), None),
         _ => None,
     }
 }
 
-fn sig_from_bounds<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Option<ExprFnSig<'tcx>> {
+fn sig_from_bounds<'tcx>(
+    cx: &LateContext<'tcx>,
+    ty: Ty<'tcx>,
+    predicates: &'tcx [Predicate<'tcx>],
+    predicates_id: Option<DefId>,
+) -> Option<ExprFnSig<'tcx>> {
     let mut inputs = None;
     let mut output = None;
     let lang_items = cx.tcx.lang_items();
 
-    for (pred, _) in all_predicates_of(cx.tcx, cx.typeck_results().hir_owner.to_def_id()) {
+    for pred in predicates {
         match pred.kind().skip_binder() {
             PredicateKind::Trait(p)
                 if (lang_items.fn_trait() == Some(p.def_id())
@@ -621,11 +630,12 @@ fn sig_from_bounds<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Option<ExprFnS
                     || lang_items.fn_once_trait() == Some(p.def_id()))
                     && p.self_ty() == ty =>
             {
-                if inputs.is_some() {
+                let i = pred.kind().rebind(p.trait_ref.substs.type_at(1));
+                if inputs.map_or(false, |inputs| i != inputs) {
                     // Multiple different fn trait impls. Is this even allowed?
                     return None;
                 }
-                inputs = Some(pred.kind().rebind(p.trait_ref.substs.type_at(1)));
+                inputs = Some(i);
             },
             PredicateKind::Projection(p)
                 if Some(p.projection_ty.item_def_id) == lang_items.fn_once_output()
@@ -641,7 +651,7 @@ fn sig_from_bounds<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Option<ExprFnS
         }
     }
 
-    inputs.map(|ty| ExprFnSig::Trait(ty, output))
+    inputs.map(|ty| ExprFnSig::Trait(ty, output, predicates_id))
 }
 
 fn sig_for_projection<'tcx>(cx: &LateContext<'tcx>, ty: ProjectionTy<'tcx>) -> Option<ExprFnSig<'tcx>> {
@@ -661,14 +671,15 @@ fn sig_for_projection<'tcx>(cx: &LateContext<'tcx>, ty: ProjectionTy<'tcx>) -> O
                     || lang_items.fn_mut_trait() == Some(p.def_id())
                     || lang_items.fn_once_trait() == Some(p.def_id())) =>
             {
-                if inputs.is_some() {
+                let i = pred
+                    .map_bound(|pred| pred.kind().rebind(p.trait_ref.substs.type_at(1)))
+                    .subst(cx.tcx, ty.substs);
+
+                if inputs.map_or(false, |inputs| inputs != i) {
                     // Multiple different fn trait impls. Is this even allowed?
                     return None;
                 }
-                inputs = Some(
-                    pred.map_bound(|pred| pred.kind().rebind(p.trait_ref.substs.type_at(1)))
-                        .subst(cx.tcx, ty.substs),
-                );
+                inputs = Some(i);
             },
             PredicateKind::Projection(p) if Some(p.projection_ty.item_def_id) == lang_items.fn_once_output() => {
                 if output.is_some() {
@@ -684,7 +695,7 @@ fn sig_for_projection<'tcx>(cx: &LateContext<'tcx>, ty: ProjectionTy<'tcx>) -> O
         }
     }
 
-    inputs.map(|ty| ExprFnSig::Trait(ty, output))
+    inputs.map(|ty| ExprFnSig::Trait(ty, output, None))
 }
 
 #[derive(Clone, Copy)]
diff --git a/tests/ui/explicit_auto_deref.fixed b/tests/ui/explicit_auto_deref.fixed
index d3efc299414..464dd2dc0da 100644
--- a/tests/ui/explicit_auto_deref.fixed
+++ b/tests/ui/explicit_auto_deref.fixed
@@ -233,4 +233,13 @@ fn main() {
         _ => panic!(),
     };
     let _: &X = &*if true { Y(X) } else { panic!() };
+
+    fn deref_to_u<U, T: core::ops::Deref<Target = U>>(x: &T) -> &U {
+        x
+    }
+
+    let _ = |x: &'static Box<dyn Iterator<Item = u32>>| -> &'static dyn Iterator<Item = u32> { &**x };
+    fn ret_any(x: &Box<dyn std::any::Any>) -> &dyn std::any::Any {
+        &**x
+    }
 }
diff --git a/tests/ui/explicit_auto_deref.rs b/tests/ui/explicit_auto_deref.rs
index e25ccbe78ce..453b90f09b3 100644
--- a/tests/ui/explicit_auto_deref.rs
+++ b/tests/ui/explicit_auto_deref.rs
@@ -233,4 +233,13 @@ fn main() {
         _ => panic!(),
     };
     let _: &X = &*if true { Y(X) } else { panic!() };
+
+    fn deref_to_u<U, T: core::ops::Deref<Target = U>>(x: &T) -> &U {
+        &**x
+    }
+
+    let _ = |x: &'static Box<dyn Iterator<Item = u32>>| -> &'static dyn Iterator<Item = u32> { &**x };
+    fn ret_any(x: &Box<dyn std::any::Any>) -> &dyn std::any::Any {
+        &**x
+    }
 }
diff --git a/tests/ui/explicit_auto_deref.stderr b/tests/ui/explicit_auto_deref.stderr
index 0d7a9564a90..f2933390fb9 100644
--- a/tests/ui/explicit_auto_deref.stderr
+++ b/tests/ui/explicit_auto_deref.stderr
@@ -210,5 +210,11 @@ error: deref which would be done by auto-deref
 LL |     let _ = || -> &'static str { return *s };
    |                                         ^^ help: try this: `s`
 
-error: aborting due to 35 previous errors
+error: deref which would be done by auto-deref
+  --> $DIR/explicit_auto_deref.rs:238:9
+   |
+LL |         &**x
+   |         ^^^^ help: try this: `x`
+
+error: aborting due to 36 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From d602ab1445a7c1982583df9297e21e137b450eb2 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sun, 17 Jul 2022 11:12:25 -0400
Subject: Don't lint `exlipicit_auto_deref` when other adjustments are needed

---
 clippy_lints/src/dereference.rs    |  6 +++++-
 tests/ui/explicit_auto_deref.fixed | 13 +++++++++++++
 tests/ui/explicit_auto_deref.rs    | 13 +++++++++++++
 3 files changed, 31 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index 40e62dbd586..05dbc743485 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -357,7 +357,11 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing {
                                 }),
                                 StateData { span: expr.span, hir_id: expr.hir_id, position },
                             ));
-                        } else if position.is_deref_stable() {
+                        } else if position.is_deref_stable()
+                            // Auto-deref doesn't combine with other adjustments
+                            && next_adjust.map_or(true, |a| matches!(a.kind, Adjust::Deref(_) | Adjust::Borrow(_)))
+                            && iter.all(|a| matches!(a.kind, Adjust::Deref(_) | Adjust::Borrow(_)))
+                        {
                             self.state = Some((
                                 State::Borrow { mutability },
                                 StateData {
diff --git a/tests/ui/explicit_auto_deref.fixed b/tests/ui/explicit_auto_deref.fixed
index 464dd2dc0da..1e868af87cb 100644
--- a/tests/ui/explicit_auto_deref.fixed
+++ b/tests/ui/explicit_auto_deref.fixed
@@ -242,4 +242,17 @@ fn main() {
     fn ret_any(x: &Box<dyn std::any::Any>) -> &dyn std::any::Any {
         &**x
     }
+
+    let x = String::new();
+    let _: *const str = &*x;
+
+    struct S7([u32; 1]);
+    impl core::ops::Deref for S7 {
+        type Target = [u32; 1];
+        fn deref(&self) -> &Self::Target {
+            &self.0
+        }
+    }
+    let x = S7([0]);
+    let _: &[u32] = &*x;
 }
diff --git a/tests/ui/explicit_auto_deref.rs b/tests/ui/explicit_auto_deref.rs
index 453b90f09b3..a2157d9b4f0 100644
--- a/tests/ui/explicit_auto_deref.rs
+++ b/tests/ui/explicit_auto_deref.rs
@@ -242,4 +242,17 @@ fn main() {
     fn ret_any(x: &Box<dyn std::any::Any>) -> &dyn std::any::Any {
         &**x
     }
+
+    let x = String::new();
+    let _: *const str = &*x;
+
+    struct S7([u32; 1]);
+    impl core::ops::Deref for S7 {
+        type Target = [u32; 1];
+        fn deref(&self) -> &Self::Target {
+            &self.0
+        }
+    }
+    let x = S7([0]);
+    let _: &[u32] = &*x;
 }
-- 
cgit 1.4.1-3-g733a5


From 8cf39a8c1908709831ab27937a53a2d6d0278ff6 Mon Sep 17 00:00:00 2001
From: Ariel Uy <ariel.b.uy@gmail.com>
Date: Sun, 10 Jul 2022 09:39:36 -0700
Subject: Fix `mismatching_type_param_order` false positive

Previously was giving false positive when an impl had a nontrivial
generic argument such as a tuple. Don't lint on these cases.
---
 clippy_lints/src/mismatching_type_param_order.rs | 24 +++++++++++++++---------
 tests/ui/mismatching_type_param_order.rs         |  4 ++++
 2 files changed, 19 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/mismatching_type_param_order.rs b/clippy_lints/src/mismatching_type_param_order.rs
index d466d54a6ba..8e477cb7179 100644
--- a/clippy_lints/src/mismatching_type_param_order.rs
+++ b/clippy_lints/src/mismatching_type_param_order.rs
@@ -18,6 +18,11 @@ declare_clippy_lint! {
     /// Naming type parameters inconsistently may cause you to refer to the
     /// wrong type parameter.
     ///
+    /// ### Limitations
+    /// This lint only applies to impl blocks with simple generic params, e.g.
+    /// `A`. If there is anything more complicated, such as a tuple, it will be
+    /// ignored.
+    ///
     /// ### Example
     /// ```rust
     /// struct Foo<A, B> {
@@ -53,14 +58,15 @@ impl<'tcx> LateLintPass<'tcx> for TypeParamMismatch {
             if !generic_args.args.is_empty();
             then {
                 // get the name and span of the generic parameters in the Impl
-                let impl_params = generic_args.args.iter()
-                .filter_map(|p|
+                let mut impl_params = Vec::new();
+                for p in generic_args.args.iter() {
                     match p {
                         GenericArg::Type(Ty {kind: TyKind::Path(QPath::Resolved(_, path)), ..}) =>
-                            Some((path.segments[0].ident.to_string(), path.span)),
-                        _ => None,
-                    }
-                );
+                            impl_params.push((path.segments[0].ident.to_string(), path.span)),
+                        GenericArg::Type(_) => return,
+                        _ => (),
+                    };
+                }
 
                 // find the type that the Impl is for
                 // only lint on struct/enum/union for now
@@ -83,8 +89,8 @@ impl<'tcx> LateLintPass<'tcx> for TypeParamMismatch {
                     type_param_names.iter().enumerate().map(|(i, param)| (param, i)).collect();
 
                 let type_name = segment.ident;
-                for (i, (impl_param_name, impl_param_span)) in impl_params.enumerate() {
-                    if mismatch_param_name(i, &impl_param_name, &type_param_names_hashmap) {
+                for (i, (impl_param_name, impl_param_span)) in impl_params.iter().enumerate() {
+                    if mismatch_param_name(i, impl_param_name, &type_param_names_hashmap) {
                         let msg = format!("`{}` has a similarly named generic type parameter `{}` in its declaration, but in a different order",
                                           type_name, impl_param_name);
                         let help = format!("try `{}`, or a name that does not conflict with `{}`'s generic params",
@@ -92,7 +98,7 @@ impl<'tcx> LateLintPass<'tcx> for TypeParamMismatch {
                         span_lint_and_help(
                             cx,
                             MISMATCHING_TYPE_PARAM_ORDER,
-                            impl_param_span,
+                            *impl_param_span,
                             &msg,
                             None,
                             &help
diff --git a/tests/ui/mismatching_type_param_order.rs b/tests/ui/mismatching_type_param_order.rs
index 8f286c9304c..8c0da84d8e9 100644
--- a/tests/ui/mismatching_type_param_order.rs
+++ b/tests/ui/mismatching_type_param_order.rs
@@ -57,4 +57,8 @@ fn main() {
         B: Copy,
     {
     }
+
+    // if the types are complicated, do not lint
+    impl<K, V, B> Foo<(K, V), B> {}
+    impl<K, V, A> Foo<(K, V), A> {}
 }
-- 
cgit 1.4.1-3-g733a5


From 142898e5443d431269caa258b18047c1ac93e7a2 Mon Sep 17 00:00:00 2001
From: alexey semenyuk <alexsemenyuk88@gmail.com>
Date: Mon, 18 Jul 2022 00:35:34 +0300
Subject: Fix example for `clippy::invalid_regex`

---
 clippy_lints/src/regex.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/regex.rs b/clippy_lints/src/regex.rs
index 67129299e2f..f9a9b069193 100644
--- a/clippy_lints/src/regex.rs
+++ b/clippy_lints/src/regex.rs
@@ -19,7 +19,7 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```ignore
-    /// Regex::new("|")
+    /// Regex::new("(")
     /// ```
     #[clippy::version = "pre 1.29.0"]
     pub INVALID_REGEX,
-- 
cgit 1.4.1-3-g733a5


From 9ff7c911008fc74c8d6c76afe12d7e30e67f8d25 Mon Sep 17 00:00:00 2001
From: Ariel Uy <ariel.b.uy@gmail.com>
Date: Sun, 10 Jul 2022 14:37:38 -0700
Subject: Add new lint `obfuscated_if_else`

New lint suggests using `if .. else ..` instead of
`.then_some(..).unwrap_or(..)`.
---
 CHANGELOG.md                                   |  1 +
 clippy_lints/src/lib.register_all.rs           |  1 +
 clippy_lints/src/lib.register_lints.rs         |  1 +
 clippy_lints/src/lib.register_style.rs         |  1 +
 clippy_lints/src/methods/mod.rs                | 34 +++++++++++++++++++++
 clippy_lints/src/methods/obfuscated_if_else.rs | 42 ++++++++++++++++++++++++++
 tests/ui/obfuscated_if_else.fixed              |  7 +++++
 tests/ui/obfuscated_if_else.rs                 |  7 +++++
 tests/ui/obfuscated_if_else.stderr             | 10 ++++++
 9 files changed, 104 insertions(+)
 create mode 100644 clippy_lints/src/methods/obfuscated_if_else.rs
 create mode 100644 tests/ui/obfuscated_if_else.fixed
 create mode 100644 tests/ui/obfuscated_if_else.rs
 create mode 100644 tests/ui/obfuscated_if_else.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 1b792736a6a..00fce79ec06 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3792,6 +3792,7 @@ Released 2018-09-13
 [`nonsensical_open_options`]: https://rust-lang.github.io/rust-clippy/master/index.html#nonsensical_open_options
 [`nonstandard_macro_braces`]: https://rust-lang.github.io/rust-clippy/master/index.html#nonstandard_macro_braces
 [`not_unsafe_ptr_arg_deref`]: https://rust-lang.github.io/rust-clippy/master/index.html#not_unsafe_ptr_arg_deref
+[`obfuscated_if_else`]: https://rust-lang.github.io/rust-clippy/master/index.html#obfuscated_if_else
 [`octal_escapes`]: https://rust-lang.github.io/rust-clippy/master/index.html#octal_escapes
 [`ok_expect`]: https://rust-lang.github.io/rust-clippy/master/index.html#ok_expect
 [`only_used_in_recursion`]: https://rust-lang.github.io/rust-clippy/master/index.html#only_used_in_recursion
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index da26a3f0130..69387d560c9 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -188,6 +188,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(methods::NEEDLESS_SPLITN),
     LintId::of(methods::NEW_RET_NO_SELF),
     LintId::of(methods::NO_EFFECT_REPLACE),
+    LintId::of(methods::OBFUSCATED_IF_ELSE),
     LintId::of(methods::OK_EXPECT),
     LintId::of(methods::OPTION_AS_REF_DEREF),
     LintId::of(methods::OPTION_FILTER_MAP),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index ceb8470657f..24b921faf03 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -330,6 +330,7 @@ store.register_lints(&[
     methods::NEEDLESS_SPLITN,
     methods::NEW_RET_NO_SELF,
     methods::NO_EFFECT_REPLACE,
+    methods::OBFUSCATED_IF_ELSE,
     methods::OK_EXPECT,
     methods::OPTION_AS_REF_DEREF,
     methods::OPTION_FILTER_MAP,
diff --git a/clippy_lints/src/lib.register_style.rs b/clippy_lints/src/lib.register_style.rs
index 15a1bc569af..e95bab1d045 100644
--- a/clippy_lints/src/lib.register_style.rs
+++ b/clippy_lints/src/lib.register_style.rs
@@ -70,6 +70,7 @@ store.register_group(true, "clippy::style", Some("clippy_style"), vec![
     LintId::of(methods::MANUAL_SATURATING_ARITHMETIC),
     LintId::of(methods::MAP_COLLECT_RESULT_UNIT),
     LintId::of(methods::NEW_RET_NO_SELF),
+    LintId::of(methods::OBFUSCATED_IF_ELSE),
     LintId::of(methods::OK_EXPECT),
     LintId::of(methods::OPTION_MAP_OR_NONE),
     LintId::of(methods::RESULT_MAP_OR_INTO_OPTION),
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 29ec6e04286..c252272e254 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -46,6 +46,7 @@ mod map_unwrap_or;
 mod needless_option_as_deref;
 mod needless_option_take;
 mod no_effect_replace;
+mod obfuscated_if_else;
 mod ok_expect;
 mod option_as_ref_deref;
 mod option_map_or_none;
@@ -2259,6 +2260,35 @@ declare_clippy_lint! {
     "replace with no effect"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usages of `.then_some(..).unwrap_or(..)`
+    ///
+    /// ### Why is this bad?
+    /// This can be written more clearly with `if .. else ..`
+    ///
+    /// ### Limitations
+    /// This lint currently only looks for usages of
+    /// `.then_some(..).unwrap_or(..)`, but will be expanded
+    /// to account for similar patterns.
+    ///
+    /// ### Example
+    /// ```rust
+    /// let x = true;
+    /// x.then_some("a").unwrap_or("b");
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// let x = true;
+    /// if x { "a" } else { "b" };
+    /// ```
+    #[clippy::version = "1.64.0"]
+    pub OBFUSCATED_IF_ELSE,
+    style,
+    "use of `.then_some(..).unwrap_or(..)` can be written \
+    more clearly with `if .. else ..`"
+}
+
 pub struct Methods {
     avoid_breaking_exported_api: bool,
     msrv: Option<RustcVersion>,
@@ -2360,6 +2390,7 @@ impl_lint_pass!(Methods => [
     IS_DIGIT_ASCII_RADIX,
     NEEDLESS_OPTION_TAKE,
     NO_EFFECT_REPLACE,
+    OBFUSCATED_IF_ELSE,
 ]);
 
 /// Extracts a method call name, args, and `Span` of the method name.
@@ -2768,6 +2799,9 @@ impl Methods {
                     Some(("map", [m_recv, m_arg], span)) => {
                         option_map_unwrap_or::check(cx, expr, m_recv, m_arg, recv, u_arg, span);
                     },
+                    Some(("then_some", [t_recv, t_arg], _)) => {
+                        obfuscated_if_else::check(cx, expr, t_recv, t_arg, u_arg);
+                    },
                     _ => {},
                 },
                 ("unwrap_or_else", [u_arg]) => match method_call(recv) {
diff --git a/clippy_lints/src/methods/obfuscated_if_else.rs b/clippy_lints/src/methods/obfuscated_if_else.rs
new file mode 100644
index 00000000000..4d7427b2662
--- /dev/null
+++ b/clippy_lints/src/methods/obfuscated_if_else.rs
@@ -0,0 +1,42 @@
+// run-rustfix
+
+use super::OBFUSCATED_IF_ELSE;
+use clippy_utils::{diagnostics::span_lint_and_sugg, source::snippet_with_applicability};
+use rustc_errors::Applicability;
+use rustc_hir as hir;
+use rustc_lint::LateContext;
+
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx hir::Expr<'_>,
+    then_recv: &'tcx hir::Expr<'_>,
+    then_arg: &'tcx hir::Expr<'_>,
+    unwrap_arg: &'tcx hir::Expr<'_>,
+) {
+    // something.then_some(blah).unwrap_or(blah)
+    // ^^^^^^^^^-then_recv ^^^^-then_arg   ^^^^- unwrap_arg
+    // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^- expr
+
+    let recv_ty = cx.typeck_results().expr_ty(then_recv);
+
+    if recv_ty.is_bool() {
+        let mut applicability = Applicability::MachineApplicable;
+        let sugg = format!(
+            "if {} {{ {} }} else {{ {} }}",
+            snippet_with_applicability(cx, then_recv.span, "..", &mut applicability),
+            snippet_with_applicability(cx, then_arg.span, "..", &mut applicability),
+            snippet_with_applicability(cx, unwrap_arg.span, "..", &mut applicability)
+        );
+
+        span_lint_and_sugg(
+            cx,
+            OBFUSCATED_IF_ELSE,
+            expr.span,
+            "use of `.then_some(..).unwrap_or(..)` can be written \
+            more clearly with `if .. else ..`",
+            "try",
+            sugg,
+            applicability,
+        );
+    }
+}
diff --git a/tests/ui/obfuscated_if_else.fixed b/tests/ui/obfuscated_if_else.fixed
new file mode 100644
index 00000000000..62d932c2c6b
--- /dev/null
+++ b/tests/ui/obfuscated_if_else.fixed
@@ -0,0 +1,7 @@
+// run-rustfix
+
+#![warn(clippy::obfuscated_if_else)]
+
+fn main() {
+    if true { "a" } else { "b" };
+}
diff --git a/tests/ui/obfuscated_if_else.rs b/tests/ui/obfuscated_if_else.rs
new file mode 100644
index 00000000000..273be9092a7
--- /dev/null
+++ b/tests/ui/obfuscated_if_else.rs
@@ -0,0 +1,7 @@
+// run-rustfix
+
+#![warn(clippy::obfuscated_if_else)]
+
+fn main() {
+    true.then_some("a").unwrap_or("b");
+}
diff --git a/tests/ui/obfuscated_if_else.stderr b/tests/ui/obfuscated_if_else.stderr
new file mode 100644
index 00000000000..e4180c28869
--- /dev/null
+++ b/tests/ui/obfuscated_if_else.stderr
@@ -0,0 +1,10 @@
+error: use of `.then_some(..).unwrap_or(..)` can be written more clearly with `if .. else ..`
+  --> $DIR/obfuscated_if_else.rs:6:5
+   |
+LL |     true.then_some("a").unwrap_or("b");
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `if true { "a" } else { "b" }`
+   |
+   = note: `-D clippy::obfuscated-if-else` implied by `-D warnings`
+
+error: aborting due to previous error
+
-- 
cgit 1.4.1-3-g733a5


From 7a5965b459ecbaa3ca702ebb9ae31b89ef449528 Mon Sep 17 00:00:00 2001
From: Xiretza <xiretza@xiretza.xyz>
Date: Mon, 18 Jul 2022 10:36:48 +0200
Subject: unused_self: respect avoid-breaking-exported-api

---
 clippy_lints/src/lib.rs         |  2 +-
 clippy_lints/src/unused_self.rs | 17 +++++++++++++++--
 clippy_lints/src/utils/conf.rs  |  2 +-
 tests/ui/unused_self.rs         |  9 +++++++++
 4 files changed, 26 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 4f9db4eb5ae..8444532f6bb 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -782,7 +782,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         ))
     });
     store.register_late_pass(|| Box::new(default::Default::default()));
-    store.register_late_pass(|| Box::new(unused_self::UnusedSelf));
+    store.register_late_pass(move || Box::new(unused_self::UnusedSelf::new(avoid_breaking_exported_api)));
     store.register_late_pass(|| Box::new(mutable_debug_assertion::DebugAssertWithMutCall));
     store.register_late_pass(|| Box::new(exit::Exit));
     store.register_late_pass(|| Box::new(to_digit_is_some::ToDigitIsSome));
diff --git a/clippy_lints/src/unused_self.rs b/clippy_lints/src/unused_self.rs
index fd9d5b52e50..51c65d898cf 100644
--- a/clippy_lints/src/unused_self.rs
+++ b/clippy_lints/src/unused_self.rs
@@ -3,7 +3,7 @@ use clippy_utils::visitors::is_local_used;
 use if_chain::if_chain;
 use rustc_hir::{Impl, ImplItem, ImplItemKind, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -35,7 +35,19 @@ declare_clippy_lint! {
     "methods that contain a `self` argument but don't use it"
 }
 
-declare_lint_pass!(UnusedSelf => [UNUSED_SELF]);
+pub struct UnusedSelf {
+    avoid_breaking_exported_api: bool,
+}
+
+impl_lint_pass!(UnusedSelf => [UNUSED_SELF]);
+
+impl UnusedSelf {
+    pub fn new(avoid_breaking_exported_api: bool) -> Self {
+        Self {
+            avoid_breaking_exported_api,
+        }
+    }
+}
 
 impl<'tcx> LateLintPass<'tcx> for UnusedSelf {
     fn check_impl_item(&mut self, cx: &LateContext<'tcx>, impl_item: &ImplItem<'_>) {
@@ -49,6 +61,7 @@ impl<'tcx> LateLintPass<'tcx> for UnusedSelf {
             if let ItemKind::Impl(Impl { of_trait: None, .. }) = parent_item.kind;
             if assoc_item.fn_has_self_parameter;
             if let ImplItemKind::Fn(.., body_id) = &impl_item.kind;
+            if !cx.access_levels.is_exported(impl_item.def_id) || !self.avoid_breaking_exported_api;
             let body = cx.tcx.hir().body(*body_id);
             if let [self_param, ..] = body.params;
             if !is_local_used(cx, body, self_param.pat.hir_id);
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 38e5c5e5b73..6153dbbc88d 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -191,7 +191,7 @@ macro_rules! define_Conf {
 }
 
 define_Conf! {
-    /// Lint: ENUM_VARIANT_NAMES, LARGE_TYPES_PASSED_BY_VALUE, TRIVIALLY_COPY_PASS_BY_REF, UNNECESSARY_WRAPS, UPPER_CASE_ACRONYMS, WRONG_SELF_CONVENTION, BOX_COLLECTION, REDUNDANT_ALLOCATION, RC_BUFFER, VEC_BOX, OPTION_OPTION, LINKEDLIST, RC_MUTEX.
+    /// Lint: ENUM_VARIANT_NAMES, LARGE_TYPES_PASSED_BY_VALUE, TRIVIALLY_COPY_PASS_BY_REF, UNNECESSARY_WRAPS, UNUSED_SELF, UPPER_CASE_ACRONYMS, WRONG_SELF_CONVENTION, BOX_COLLECTION, REDUNDANT_ALLOCATION, RC_BUFFER, VEC_BOX, OPTION_OPTION, LINKEDLIST, RC_MUTEX.
     ///
     /// Suppress lints whenever the suggested change would cause breakage for other crates.
     (avoid_breaking_exported_api: bool = true),
diff --git a/tests/ui/unused_self.rs b/tests/ui/unused_self.rs
index 08bf58fec7c..92e8e1dba69 100644
--- a/tests/ui/unused_self.rs
+++ b/tests/ui/unused_self.rs
@@ -53,8 +53,17 @@ mod unused_self_allow {
         // shouldn't trigger
         fn unused_self_move(self) {}
     }
+
+    pub struct D;
+
+    impl D {
+        // shouldn't trigger for public methods
+        pub fn unused_self_move(self) {}
+    }
 }
 
+pub use unused_self_allow::D;
+
 mod used_self {
     use std::pin::Pin;
 
-- 
cgit 1.4.1-3-g733a5


From c94ca1c625ba195964ead7e1eac640563526c20b Mon Sep 17 00:00:00 2001
From: Paul <34397452+PaulTheNeko@users.noreply.github.com>
Date: Mon, 18 Jul 2022 16:24:30 +0200
Subject: Fix typo in alloc_instead_of_core

The description previously claimed it ensures items are imported from alloc, to ensure a crate won't require alloc, which can't be true.
---
 clippy_lints/src/std_instead_of_core.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/std_instead_of_core.rs b/clippy_lints/src/std_instead_of_core.rs
index 56f2a7bae15..560a3164563 100644
--- a/clippy_lints/src/std_instead_of_core.rs
+++ b/clippy_lints/src/std_instead_of_core.rs
@@ -63,7 +63,7 @@ declare_clippy_lint! {
     /// ### Why is this bad?
     ///
     /// Crates which have `no_std` compatibility and may optionally require alloc may wish to ensure types are
-    /// imported from alloc to ensure disabling `alloc` does not cause the crate to fail to compile. This lint
+    /// imported from core to ensure disabling `alloc` does not cause the crate to fail to compile. This lint
     /// is also useful for crates migrating to become `no_std` compatible.
     ///
     /// ### Example
-- 
cgit 1.4.1-3-g733a5


From 31e5465f8a0e35b8f9e8e28d359e4098e9f44e4f Mon Sep 17 00:00:00 2001
From: Caio <c410.f3r@gmail.com>
Date: Mon, 18 Jul 2022 14:29:45 -0300
Subject: Add Arithmetic lint

---
 CHANGELOG.md                                       |   1 +
 clippy_lints/src/lib.register_lints.rs             |   1 +
 clippy_lints/src/lib.register_restriction.rs       |   1 +
 clippy_lints/src/lib.rs                            |   2 +
 clippy_lints/src/operators/arithmetic.rs           | 119 +++++++++++++++++++++
 clippy_lints/src/operators/mod.rs                  |  39 +++++++
 clippy_lints/src/utils/conf.rs                     |   4 +
 .../arithmetic_allowed/arithmetic_allowed.rs       |  24 +++++
 tests/ui-toml/arithmetic_allowed/clippy.toml       |   1 +
 .../toml_unknown_key/conf_unknown_key.stderr       |   1 +
 tests/ui/arithmetic.fixed                          |  27 +++++
 tests/ui/arithmetic.rs                             |  27 +++++
 12 files changed, 247 insertions(+)
 create mode 100644 clippy_lints/src/operators/arithmetic.rs
 create mode 100644 tests/ui-toml/arithmetic_allowed/arithmetic_allowed.rs
 create mode 100644 tests/ui-toml/arithmetic_allowed/clippy.toml
 create mode 100644 tests/ui/arithmetic.fixed
 create mode 100644 tests/ui/arithmetic.rs

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 1d5c216c154..aeaf3975649 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3437,6 +3437,7 @@ Released 2018-09-13
 [`almost_complete_letter_range`]: https://rust-lang.github.io/rust-clippy/master/index.html#almost_complete_letter_range
 [`almost_swapped`]: https://rust-lang.github.io/rust-clippy/master/index.html#almost_swapped
 [`approx_constant`]: https://rust-lang.github.io/rust-clippy/master/index.html#approx_constant
+[`arithmetic`]: https://rust-lang.github.io/rust-clippy/master/index.html#arithmetic
 [`as_conversions`]: https://rust-lang.github.io/rust-clippy/master/index.html#as_conversions
 [`as_underscore`]: https://rust-lang.github.io/rust-clippy/master/index.html#as_underscore
 [`assertions_on_constants`]: https://rust-lang.github.io/rust-clippy/master/index.html#assertions_on_constants
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index d40c6aec04a..1ffd190cb9b 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -418,6 +418,7 @@ store.register_lints(&[
     only_used_in_recursion::ONLY_USED_IN_RECURSION,
     open_options::NONSENSICAL_OPEN_OPTIONS,
     operators::ABSURD_EXTREME_COMPARISONS,
+    operators::ARITHMETIC,
     operators::ASSIGN_OP_PATTERN,
     operators::BAD_BIT_MASK,
     operators::CMP_NAN,
diff --git a/clippy_lints/src/lib.register_restriction.rs b/clippy_lints/src/lib.register_restriction.rs
index 43f1c892eb9..495abd8387e 100644
--- a/clippy_lints/src/lib.register_restriction.rs
+++ b/clippy_lints/src/lib.register_restriction.rs
@@ -48,6 +48,7 @@ store.register_group(true, "clippy::restriction", Some("clippy_restriction"), ve
     LintId::of(mixed_read_write_in_expression::MIXED_READ_WRITE_IN_EXPRESSION),
     LintId::of(module_style::MOD_MODULE_FILES),
     LintId::of(module_style::SELF_NAMED_MODULE_FILES),
+    LintId::of(operators::ARITHMETIC),
     LintId::of(operators::FLOAT_ARITHMETIC),
     LintId::of(operators::FLOAT_CMP_CONST),
     LintId::of(operators::INTEGER_ARITHMETIC),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 8444532f6bb..8ac40cc73e0 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -548,6 +548,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         store.register_late_pass(|| Box::new(utils::internal_lints::MsrvAttrImpl));
     }
 
+    let arithmetic_allowed = conf.arithmetic_allowed.clone();
+    store.register_late_pass(move || Box::new(operators::arithmetic::Arithmetic::new(arithmetic_allowed.clone())));
     store.register_late_pass(|| Box::new(utils::dump_hir::DumpHir));
     store.register_late_pass(|| Box::new(utils::author::Author));
     let await_holding_invalid_types = conf.await_holding_invalid_types.clone();
diff --git a/clippy_lints/src/operators/arithmetic.rs b/clippy_lints/src/operators/arithmetic.rs
new file mode 100644
index 00000000000..800cf249f5c
--- /dev/null
+++ b/clippy_lints/src/operators/arithmetic.rs
@@ -0,0 +1,119 @@
+#![allow(
+    // False positive
+    clippy::match_same_arms
+)]
+
+use super::ARITHMETIC;
+use clippy_utils::{consts::constant_simple, diagnostics::span_lint};
+use rustc_data_structures::fx::FxHashSet;
+use rustc_hir as hir;
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::impl_lint_pass;
+use rustc_span::source_map::Span;
+
+const HARD_CODED_ALLOWED: &[&str] = &["std::num::Saturating", "std::string::String", "std::num::Wrapping"];
+
+#[derive(Debug)]
+pub struct Arithmetic {
+    allowed: FxHashSet<String>,
+    // Used to check whether expressions are constants, such as in enum discriminants and consts
+    const_span: Option<Span>,
+    expr_span: Option<Span>,
+}
+
+impl_lint_pass!(Arithmetic => [ARITHMETIC]);
+
+impl Arithmetic {
+    #[must_use]
+    pub fn new(mut allowed: FxHashSet<String>) -> Self {
+        allowed.extend(HARD_CODED_ALLOWED.iter().copied().map(String::from));
+        Self {
+            allowed,
+            const_span: None,
+            expr_span: None,
+        }
+    }
+
+    /// Checks if the given `expr` has any of the inner `allowed` elements.
+    fn is_allowed_ty(&self, cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> bool {
+        self.allowed.contains(
+            cx.typeck_results()
+                .expr_ty(expr)
+                .to_string()
+                .split('<')
+                .next()
+                .unwrap_or_default(),
+        )
+    }
+
+    fn issue_lint(&mut self, cx: &LateContext<'_>, expr: &hir::Expr<'_>) {
+        span_lint(cx, ARITHMETIC, expr.span, "arithmetic detected");
+        self.expr_span = Some(expr.span);
+    }
+}
+
+impl<'tcx> LateLintPass<'tcx> for Arithmetic {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
+        if self.expr_span.is_some() {
+            return;
+        }
+        if let Some(span) = self.const_span && span.contains(expr.span) {
+            return;
+        }
+        match &expr.kind {
+            hir::ExprKind::Binary(op, lhs, rhs) | hir::ExprKind::AssignOp(op, lhs, rhs) => {
+                let (
+                    hir::BinOpKind::Add
+                    | hir::BinOpKind::Sub
+                    | hir::BinOpKind::Mul
+                    | hir::BinOpKind::Div
+                    | hir::BinOpKind::Rem
+                    | hir::BinOpKind::Shl
+                    | hir::BinOpKind::Shr
+                ) = op.node else {
+                    return;
+                };
+                if self.is_allowed_ty(cx, lhs) || self.is_allowed_ty(cx, rhs) {
+                    return;
+                }
+                self.issue_lint(cx, expr);
+            },
+            hir::ExprKind::Unary(hir::UnOp::Neg, _) => {
+                // CTFE already takes care of things like `-1` that do not overflow.
+                if constant_simple(cx, cx.typeck_results(), expr).is_none() {
+                    self.issue_lint(cx, expr);
+                }
+            },
+            _ => {},
+        }
+    }
+
+    fn check_body(&mut self, cx: &LateContext<'_>, body: &hir::Body<'_>) {
+        let body_owner = cx.tcx.hir().body_owner_def_id(body.id());
+        match cx.tcx.hir().body_owner_kind(body_owner) {
+            hir::BodyOwnerKind::Const | hir::BodyOwnerKind::Static(_) => {
+                let body_span = cx.tcx.def_span(body_owner);
+                if let Some(span) = self.const_span && span.contains(body_span) {
+                    return;
+                }
+                self.const_span = Some(body_span);
+            },
+            hir::BodyOwnerKind::Closure | hir::BodyOwnerKind::Fn => {},
+        }
+    }
+
+    fn check_body_post(&mut self, cx: &LateContext<'_>, body: &hir::Body<'_>) {
+        let body_owner = cx.tcx.hir().body_owner(body.id());
+        let body_span = cx.tcx.hir().span(body_owner);
+        if let Some(span) = self.const_span && span.contains(body_span) {
+            return;
+        }
+        self.const_span = None;
+    }
+
+    fn check_expr_post(&mut self, _: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
+        if Some(expr.span) == self.expr_span {
+            self.expr_span = None;
+        }
+    }
+}
diff --git a/clippy_lints/src/operators/mod.rs b/clippy_lints/src/operators/mod.rs
index 35fe405bcf1..c688d94bb52 100644
--- a/clippy_lints/src/operators/mod.rs
+++ b/clippy_lints/src/operators/mod.rs
@@ -2,6 +2,8 @@ use rustc_hir::{Body, Expr, ExprKind, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 
+pub(crate) mod arithmetic;
+
 mod absurd_extreme_comparisons;
 mod assign_op_pattern;
 mod bit_mask;
@@ -57,6 +59,42 @@ declare_clippy_lint! {
     "a comparison with a maximum or minimum value that is always true or false"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for any kind of arithmetic operation of any type.
+    ///
+    /// Operators like `+`, `-`, `*` or `<<` are usually capable of overflowing according to the [Rust
+    /// Reference](https://doc.rust-lang.org/reference/expressions/operator-expr.html#overflow),
+    /// or can panic (`/`, `%`). Known safe built-in types like `Wrapping` or `Saturing` are filtered
+    /// away.
+    ///
+    /// ### Why is this bad?
+    /// Integer overflow will trigger a panic in debug builds or will wrap in
+    /// release mode. Division by zero will cause a panic in either mode. In some applications one
+    /// wants explicitly checked, wrapping or saturating arithmetic.
+    ///
+    /// #### Example
+    /// ```rust
+    /// # let a = 0;
+    /// a + 1;
+    /// ```
+    ///
+    /// Third-party types also tend to overflow.
+    ///
+    /// #### Example
+    /// ```ignore,rust
+    /// use rust_decimal::Decimal;
+    /// let _n = Decimal::MAX + Decimal::MAX;
+    /// ```
+    ///
+    /// ### Allowed types
+    /// Custom allowed types can be specified through the "arithmetic-allowed" filter.
+    #[clippy::version = "1.64.0"]
+    pub ARITHMETIC,
+    restriction,
+    "any arithmetic expression that could overflow or panic"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for integer arithmetic operations which could overflow or panic.
@@ -747,6 +785,7 @@ pub struct Operators {
 }
 impl_lint_pass!(Operators => [
     ABSURD_EXTREME_COMPARISONS,
+    ARITHMETIC,
     INTEGER_ARITHMETIC,
     FLOAT_ARITHMETIC,
     ASSIGN_OP_PATTERN,
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 6153dbbc88d..6e033b3be2d 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -191,6 +191,10 @@ macro_rules! define_Conf {
 }
 
 define_Conf! {
+    /// Lint: Arithmetic.
+    ///
+    /// Suppress checking of the passed type names.
+    (arithmetic_allowed: rustc_data_structures::fx::FxHashSet<String> = <_>::default()),
     /// Lint: ENUM_VARIANT_NAMES, LARGE_TYPES_PASSED_BY_VALUE, TRIVIALLY_COPY_PASS_BY_REF, UNNECESSARY_WRAPS, UNUSED_SELF, UPPER_CASE_ACRONYMS, WRONG_SELF_CONVENTION, BOX_COLLECTION, REDUNDANT_ALLOCATION, RC_BUFFER, VEC_BOX, OPTION_OPTION, LINKEDLIST, RC_MUTEX.
     ///
     /// Suppress lints whenever the suggested change would cause breakage for other crates.
diff --git a/tests/ui-toml/arithmetic_allowed/arithmetic_allowed.rs b/tests/ui-toml/arithmetic_allowed/arithmetic_allowed.rs
new file mode 100644
index 00000000000..195fabdbf71
--- /dev/null
+++ b/tests/ui-toml/arithmetic_allowed/arithmetic_allowed.rs
@@ -0,0 +1,24 @@
+#![warn(clippy::arithmetic)]
+
+use core::ops::Add;
+
+#[derive(Clone, Copy)]
+struct Point {
+    x: i32,
+    y: i32,
+}
+
+impl Add for Point {
+    type Output = Self;
+
+    fn add(self, other: Self) -> Self {
+        todo!()
+    }
+}
+
+fn main() {
+    let _ = Point { x: 1, y: 0 } + Point { x: 2, y: 3 };
+
+    let point: Point = Point { x: 1, y: 0 };
+    let _ = point + point;
+}
diff --git a/tests/ui-toml/arithmetic_allowed/clippy.toml b/tests/ui-toml/arithmetic_allowed/clippy.toml
new file mode 100644
index 00000000000..cc40570b12a
--- /dev/null
+++ b/tests/ui-toml/arithmetic_allowed/clippy.toml
@@ -0,0 +1 @@
+arithmetic-allowed = ["Point"]
diff --git a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
index 1d87fd91a25..fe5139c4768 100644
--- a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
+++ b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
@@ -3,6 +3,7 @@ error: error reading Clippy's configuration file `$DIR/clippy.toml`: unknown fie
            allow-expect-in-tests
            allow-unwrap-in-tests
            allowed-scripts
+           arithmetic-allowed
            array-size-threshold
            avoid-breaking-exported-api
            await-holding-invalid-types
diff --git a/tests/ui/arithmetic.fixed b/tests/ui/arithmetic.fixed
new file mode 100644
index 00000000000..a2a1c4394c2
--- /dev/null
+++ b/tests/ui/arithmetic.fixed
@@ -0,0 +1,27 @@
+// run-rustfix
+
+#![allow(clippy::unnecessary_owned_empty_strings)]
+#![feature(saturating_int_impl)]
+#![warn(clippy::arithmetic)]
+
+use core::num::{Saturating, Wrapping};
+
+pub fn hard_coded_allowed() {
+    let _ = Saturating(0u32) + Saturating(0u32);
+    let _ = String::new() + "";
+    let _ = Wrapping(0u32) + Wrapping(0u32);
+
+    let saturating: Saturating<u32> = Saturating(0u32);
+    let string: String = String::new();
+    let wrapping: Wrapping<u32> = Wrapping(0u32);
+
+    let inferred_saturating = saturating + saturating;
+    let inferred_string = string + "";
+    let inferred_wrapping = wrapping + wrapping;
+
+    let _ = inferred_saturating + inferred_saturating;
+    let _ = inferred_string + "";
+    let _ = inferred_wrapping + inferred_wrapping;
+}
+
+fn main() {}
diff --git a/tests/ui/arithmetic.rs b/tests/ui/arithmetic.rs
new file mode 100644
index 00000000000..a2a1c4394c2
--- /dev/null
+++ b/tests/ui/arithmetic.rs
@@ -0,0 +1,27 @@
+// run-rustfix
+
+#![allow(clippy::unnecessary_owned_empty_strings)]
+#![feature(saturating_int_impl)]
+#![warn(clippy::arithmetic)]
+
+use core::num::{Saturating, Wrapping};
+
+pub fn hard_coded_allowed() {
+    let _ = Saturating(0u32) + Saturating(0u32);
+    let _ = String::new() + "";
+    let _ = Wrapping(0u32) + Wrapping(0u32);
+
+    let saturating: Saturating<u32> = Saturating(0u32);
+    let string: String = String::new();
+    let wrapping: Wrapping<u32> = Wrapping(0u32);
+
+    let inferred_saturating = saturating + saturating;
+    let inferred_string = string + "";
+    let inferred_wrapping = wrapping + wrapping;
+
+    let _ = inferred_saturating + inferred_saturating;
+    let _ = inferred_string + "";
+    let _ = inferred_wrapping + inferred_wrapping;
+}
+
+fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 40340745a80904722323845b7f93d43af1c1f83a Mon Sep 17 00:00:00 2001
From: Evan Typanski <evan.typanski@microfocus.com>
Date: Tue, 19 Jul 2022 15:17:24 -0400
Subject: Use parens around [`needless_borrow`] field calls

---
 clippy_lints/src/dereference.rs |  3 ++-
 tests/ui/needless_borrow.fixed  | 25 +++++++++++++++++++++++++
 tests/ui/needless_borrow.rs     | 25 +++++++++++++++++++++++++
 tests/ui/needless_borrow.stderr | 14 +++++++++++++-
 4 files changed, 65 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index 8c7cf7748be..a90f894a7b1 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -1028,9 +1028,10 @@ fn report<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, state: State, data
             let mut app = Applicability::MachineApplicable;
             let (snip, snip_is_macro) = snippet_with_context(cx, expr.span, data.span.ctxt(), "..", &mut app);
             span_lint_hir_and_then(cx, NEEDLESS_BORROW, data.hir_id, data.span, state.msg, |diag| {
+                let calls_field = matches!(expr.kind, ExprKind::Field(..)) && matches!(data.position, Position::Callee);
                 let sugg = if !snip_is_macro
-                    && expr.precedence().order() < data.position.precedence()
                     && !has_enclosing_paren(&snip)
+                    && (expr.precedence().order() < data.position.precedence() || calls_field)
                 {
                     format!("({})", snip)
                 } else {
diff --git a/tests/ui/needless_borrow.fixed b/tests/ui/needless_borrow.fixed
index 09afe2ddbbf..bfd2725ecaa 100644
--- a/tests/ui/needless_borrow.fixed
+++ b/tests/ui/needless_borrow.fixed
@@ -158,3 +158,28 @@ fn check_expect_suppression() {
     #[expect(clippy::needless_borrow)]
     let _ = x(&&a);
 }
+
+#[allow(dead_code)]
+mod issue9160 {
+    pub struct S<F> {
+        f: F,
+    }
+
+    impl<T, F> S<F>
+    where
+        F: Fn() -> T,
+    {
+        fn calls_field(&self) -> T {
+            (self.f)()
+        }
+    }
+
+    impl<T, F> S<F>
+    where
+        F: FnMut() -> T,
+    {
+        fn calls_mut_field(&mut self) -> T {
+            (self.f)()
+        }
+    }
+}
diff --git a/tests/ui/needless_borrow.rs b/tests/ui/needless_borrow.rs
index 3ae4722a1f8..c457d8c5471 100644
--- a/tests/ui/needless_borrow.rs
+++ b/tests/ui/needless_borrow.rs
@@ -158,3 +158,28 @@ fn check_expect_suppression() {
     #[expect(clippy::needless_borrow)]
     let _ = x(&&a);
 }
+
+#[allow(dead_code)]
+mod issue9160 {
+    pub struct S<F> {
+        f: F,
+    }
+
+    impl<T, F> S<F>
+    where
+        F: Fn() -> T,
+    {
+        fn calls_field(&self) -> T {
+            (&self.f)()
+        }
+    }
+
+    impl<T, F> S<F>
+    where
+        F: FnMut() -> T,
+    {
+        fn calls_mut_field(&mut self) -> T {
+            (&mut self.f)()
+        }
+    }
+}
diff --git a/tests/ui/needless_borrow.stderr b/tests/ui/needless_borrow.stderr
index 8a2e2b98959..66588689d81 100644
--- a/tests/ui/needless_borrow.stderr
+++ b/tests/ui/needless_borrow.stderr
@@ -120,5 +120,17 @@ error: this expression creates a reference which is immediately dereferenced by
 LL |     (&&5).foo();
    |     ^^^^^ help: change this to: `(&5)`
 
-error: aborting due to 20 previous errors
+error: this expression borrows a value the compiler would automatically borrow
+  --> $DIR/needless_borrow.rs:173:13
+   |
+LL |             (&self.f)()
+   |             ^^^^^^^^^ help: change this to: `(self.f)`
+
+error: this expression borrows a value the compiler would automatically borrow
+  --> $DIR/needless_borrow.rs:182:13
+   |
+LL |             (&mut self.f)()
+   |             ^^^^^^^^^^^^^ help: change this to: `(self.f)`
+
+error: aborting due to 22 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From a2f9b9311656afd18468f242db3507157371c545 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Wed, 20 Jul 2022 10:00:04 -0400
Subject: Don't lint `assign_op_pattern` when the suggestion would cause
 borrowck errors

---
 clippy_lints/src/operators/assign_op_pattern.rs | 80 +++++++++++++++++++++++++
 tests/ui/assign_ops.fixed                       | 11 ++++
 tests/ui/assign_ops.rs                          | 11 ++++
 tests/ui/assign_ops.stderr                      | 32 ++++++----
 4 files changed, 124 insertions(+), 10 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/operators/assign_op_pattern.rs b/clippy_lints/src/operators/assign_op_pattern.rs
index 979e0a66707..945a09a647c 100644
--- a/clippy_lints/src/operators/assign_op_pattern.rs
+++ b/clippy_lints/src/operators/assign_op_pattern.rs
@@ -8,6 +8,10 @@ use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_hir::intravisit::{walk_expr, Visitor};
 use rustc_lint::LateContext;
+use rustc_middle::mir::FakeReadCause;
+use rustc_middle::ty::BorrowKind;
+use rustc_trait_selection::infer::TyCtxtInferExt;
+use rustc_typeck::expr_use_visitor::{Delegate, ExprUseVisitor, PlaceBase, PlaceWithHirId};
 
 use super::ASSIGN_OP_PATTERN;
 
@@ -29,6 +33,16 @@ pub(super) fn check<'tcx>(
                     .map_or(true, |t| t.path.res.def_id() != trait_id);
                 if implements_trait(cx, ty, trait_id, &[rty.into()]);
                 then {
+                    // Primitive types execute assign-ops right-to-left. Every other type is left-to-right.
+                    if !(ty.is_primitive() && rty.is_primitive()) {
+                        // TODO: This will have false negatives as it doesn't check if the borrows are
+                        // actually live at the end of their respective expressions.
+                        let mut_borrows = mut_borrows_in_expr(cx, assignee);
+                        let imm_borrows = imm_borrows_in_expr(cx, rhs);
+                        if mut_borrows.iter().any(|id| imm_borrows.contains(id)) {
+                            return;
+                        }
+                    }
                     span_lint_and_then(
                         cx,
                         ASSIGN_OP_PATTERN,
@@ -99,3 +113,69 @@ impl<'a, 'tcx> Visitor<'tcx> for ExprVisitor<'a, 'tcx> {
         walk_expr(self, expr);
     }
 }
+
+fn imm_borrows_in_expr(cx: &LateContext<'_>, e: &hir::Expr<'_>) -> hir::HirIdSet {
+    struct S(hir::HirIdSet);
+    impl Delegate<'_> for S {
+        fn borrow(&mut self, place: &PlaceWithHirId<'_>, _: hir::HirId, kind: BorrowKind) {
+            if matches!(kind, BorrowKind::ImmBorrow | BorrowKind::UniqueImmBorrow) {
+                self.0.insert(match place.place.base {
+                    PlaceBase::Local(id) => id,
+                    PlaceBase::Upvar(id) => id.var_path.hir_id,
+                    _ => return,
+                });
+            }
+        }
+
+        fn consume(&mut self, _: &PlaceWithHirId<'_>, _: hir::HirId) {}
+        fn mutate(&mut self, _: &PlaceWithHirId<'_>, _: hir::HirId) {}
+        fn fake_read(&mut self, _: &PlaceWithHirId<'_>, _: FakeReadCause, _: hir::HirId) {}
+        fn copy(&mut self, _: &PlaceWithHirId<'_>, _: hir::HirId) {}
+    }
+
+    let mut s = S(hir::HirIdSet::default());
+    cx.tcx.infer_ctxt().enter(|infcx| {
+        let mut v = ExprUseVisitor::new(
+            &mut s,
+            &infcx,
+            cx.tcx.hir().body_owner_def_id(cx.enclosing_body.unwrap()),
+            cx.param_env,
+            cx.typeck_results(),
+        );
+        v.consume_expr(e);
+    });
+    s.0
+}
+
+fn mut_borrows_in_expr(cx: &LateContext<'_>, e: &hir::Expr<'_>) -> hir::HirIdSet {
+    struct S(hir::HirIdSet);
+    impl Delegate<'_> for S {
+        fn borrow(&mut self, place: &PlaceWithHirId<'_>, _: hir::HirId, kind: BorrowKind) {
+            if matches!(kind, BorrowKind::MutBorrow) {
+                self.0.insert(match place.place.base {
+                    PlaceBase::Local(id) => id,
+                    PlaceBase::Upvar(id) => id.var_path.hir_id,
+                    _ => return,
+                });
+            }
+        }
+
+        fn consume(&mut self, _: &PlaceWithHirId<'_>, _: hir::HirId) {}
+        fn mutate(&mut self, _: &PlaceWithHirId<'_>, _: hir::HirId) {}
+        fn fake_read(&mut self, _: &PlaceWithHirId<'_>, _: FakeReadCause, _: hir::HirId) {}
+        fn copy(&mut self, _: &PlaceWithHirId<'_>, _: hir::HirId) {}
+    }
+
+    let mut s = S(hir::HirIdSet::default());
+    cx.tcx.infer_ctxt().enter(|infcx| {
+        let mut v = ExprUseVisitor::new(
+            &mut s,
+            &infcx,
+            cx.tcx.hir().body_owner_def_id(cx.enclosing_body.unwrap()),
+            cx.param_env,
+            cx.typeck_results(),
+        );
+        v.consume_expr(e);
+    });
+    s.0
+}
diff --git a/tests/ui/assign_ops.fixed b/tests/ui/assign_ops.fixed
index 52b1b3afe16..da034b51cfd 100644
--- a/tests/ui/assign_ops.fixed
+++ b/tests/ui/assign_ops.fixed
@@ -1,5 +1,7 @@
 // run-rustfix
 
+use core::num::Wrapping;
+
 #[allow(dead_code, unused_assignments)]
 #[warn(clippy::assign_op_pattern)]
 fn main() {
@@ -18,4 +20,13 @@ fn main() {
     a = 6 << a;
     let mut s = String::new();
     s += "bla";
+
+    // Issue #9180
+    let mut a = Wrapping(0u32);
+    a += Wrapping(1u32);
+    let mut v = vec![0u32, 1u32];
+    v[0] += v[1];
+    let mut v = vec![Wrapping(0u32), Wrapping(1u32)];
+    v[0] = v[0] + v[1];
+    let _ = || v[0] = v[0] + v[1];
 }
diff --git a/tests/ui/assign_ops.rs b/tests/ui/assign_ops.rs
index 527a46b2c2b..337bb02c8a6 100644
--- a/tests/ui/assign_ops.rs
+++ b/tests/ui/assign_ops.rs
@@ -1,5 +1,7 @@
 // run-rustfix
 
+use core::num::Wrapping;
+
 #[allow(dead_code, unused_assignments)]
 #[warn(clippy::assign_op_pattern)]
 fn main() {
@@ -18,4 +20,13 @@ fn main() {
     a = 6 << a;
     let mut s = String::new();
     s = s + "bla";
+
+    // Issue #9180
+    let mut a = Wrapping(0u32);
+    a = a + Wrapping(1u32);
+    let mut v = vec![0u32, 1u32];
+    v[0] = v[0] + v[1];
+    let mut v = vec![Wrapping(0u32), Wrapping(1u32)];
+    v[0] = v[0] + v[1];
+    let _ = || v[0] = v[0] + v[1];
 }
diff --git a/tests/ui/assign_ops.stderr b/tests/ui/assign_ops.stderr
index 3486bd8da4d..63a938ab4b4 100644
--- a/tests/ui/assign_ops.stderr
+++ b/tests/ui/assign_ops.stderr
@@ -1,5 +1,5 @@
 error: manual implementation of an assign operation
-  --> $DIR/assign_ops.rs:7:5
+  --> $DIR/assign_ops.rs:9:5
    |
 LL |     a = a + 1;
    |     ^^^^^^^^^ help: replace it with: `a += 1`
@@ -7,52 +7,64 @@ LL |     a = a + 1;
    = note: `-D clippy::assign-op-pattern` implied by `-D warnings`
 
 error: manual implementation of an assign operation
-  --> $DIR/assign_ops.rs:8:5
+  --> $DIR/assign_ops.rs:10:5
    |
 LL |     a = 1 + a;
    |     ^^^^^^^^^ help: replace it with: `a += 1`
 
 error: manual implementation of an assign operation
-  --> $DIR/assign_ops.rs:9:5
+  --> $DIR/assign_ops.rs:11:5
    |
 LL |     a = a - 1;
    |     ^^^^^^^^^ help: replace it with: `a -= 1`
 
 error: manual implementation of an assign operation
-  --> $DIR/assign_ops.rs:10:5
+  --> $DIR/assign_ops.rs:12:5
    |
 LL |     a = a * 99;
    |     ^^^^^^^^^^ help: replace it with: `a *= 99`
 
 error: manual implementation of an assign operation
-  --> $DIR/assign_ops.rs:11:5
+  --> $DIR/assign_ops.rs:13:5
    |
 LL |     a = 42 * a;
    |     ^^^^^^^^^^ help: replace it with: `a *= 42`
 
 error: manual implementation of an assign operation
-  --> $DIR/assign_ops.rs:12:5
+  --> $DIR/assign_ops.rs:14:5
    |
 LL |     a = a / 2;
    |     ^^^^^^^^^ help: replace it with: `a /= 2`
 
 error: manual implementation of an assign operation
-  --> $DIR/assign_ops.rs:13:5
+  --> $DIR/assign_ops.rs:15:5
    |
 LL |     a = a % 5;
    |     ^^^^^^^^^ help: replace it with: `a %= 5`
 
 error: manual implementation of an assign operation
-  --> $DIR/assign_ops.rs:14:5
+  --> $DIR/assign_ops.rs:16:5
    |
 LL |     a = a & 1;
    |     ^^^^^^^^^ help: replace it with: `a &= 1`
 
 error: manual implementation of an assign operation
-  --> $DIR/assign_ops.rs:20:5
+  --> $DIR/assign_ops.rs:22:5
    |
 LL |     s = s + "bla";
    |     ^^^^^^^^^^^^^ help: replace it with: `s += "bla"`
 
-error: aborting due to 9 previous errors
+error: manual implementation of an assign operation
+  --> $DIR/assign_ops.rs:26:5
+   |
+LL |     a = a + Wrapping(1u32);
+   |     ^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `a += Wrapping(1u32)`
+
+error: manual implementation of an assign operation
+  --> $DIR/assign_ops.rs:28:5
+   |
+LL |     v[0] = v[0] + v[1];
+   |     ^^^^^^^^^^^^^^^^^^ help: replace it with: `v[0] += v[1]`
+
+error: aborting due to 11 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 8dfea7436746c7adce35504609c8ed0f3c59478b Mon Sep 17 00:00:00 2001
From: Serial <69764315+Serial-ATA@users.noreply.github.com>
Date: Wed, 20 Jul 2022 21:35:11 -0400
Subject: Remove extra newlines in [`significant_drop_in_scrutinee`] docs

---
 clippy_lints/src/matches/mod.rs | 10 ----------
 1 file changed, 10 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/mod.rs b/clippy_lints/src/matches/mod.rs
index d55082c66dc..a3d69a4d09c 100644
--- a/clippy_lints/src/matches/mod.rs
+++ b/clippy_lints/src/matches/mod.rs
@@ -793,18 +793,13 @@ declare_clippy_lint! {
     /// ### Example
     /// ```rust,ignore
     /// # use std::sync::Mutex;
-    ///
     /// # struct State {}
-    ///
     /// # impl State {
     /// #     fn foo(&self) -> bool {
     /// #         true
     /// #     }
-    ///
     /// #     fn bar(&self) {}
     /// # }
-    ///
-    ///
     /// let mutex = Mutex::new(State {});
     ///
     /// match mutex.lock().unwrap().foo() {
@@ -815,22 +810,17 @@ declare_clippy_lint! {
     /// };
     ///
     /// println!("All done!");
-    ///
     /// ```
     /// Use instead:
     /// ```rust
     /// # use std::sync::Mutex;
-    ///
     /// # struct State {}
-    ///
     /// # impl State {
     /// #     fn foo(&self) -> bool {
     /// #         true
     /// #     }
-    ///
     /// #     fn bar(&self) {}
     /// # }
-    ///
     /// let mutex = Mutex::new(State {});
     ///
     /// let is_foo = mutex.lock().unwrap().foo();
-- 
cgit 1.4.1-3-g733a5


From 6ee03e2b014fc98e1bbfdbf5c39872b8308cd15d Mon Sep 17 00:00:00 2001
From: Sosthène Guédon <sosthene@guedon.gdn>
Date: Thu, 21 Jul 2022 22:45:12 +0200
Subject: unwrap_used: Stop recommending using `expect` when the `expect_used`
 lint is not allowed

---
 clippy_lints/src/methods/unwrap_used.rs | 21 +++++++++++--------
 tests/ui/unwrap_expect_used.rs          | 10 +++++++++
 tests/ui/unwrap_expect_used.stderr      | 36 +++++++++++++++++++++++++++++++++
 3 files changed, 59 insertions(+), 8 deletions(-)
 create mode 100644 tests/ui/unwrap_expect_used.rs
 create mode 100644 tests/ui/unwrap_expect_used.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/unwrap_used.rs b/clippy_lints/src/methods/unwrap_used.rs
index 5c761014927..eae6ba693a2 100644
--- a/clippy_lints/src/methods/unwrap_used.rs
+++ b/clippy_lints/src/methods/unwrap_used.rs
@@ -1,11 +1,11 @@
 use clippy_utils::diagnostics::span_lint_and_help;
-use clippy_utils::is_in_test_function;
 use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::{is_in_test_function, is_lint_allowed};
 use rustc_hir as hir;
 use rustc_lint::LateContext;
 use rustc_span::sym;
 
-use super::UNWRAP_USED;
+use super::{EXPECT_USED, UNWRAP_USED};
 
 /// lint use of `unwrap()` for `Option`s and `Result`s
 pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr<'_>, allow_unwrap_in_tests: bool) {
@@ -24,17 +24,22 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr
     }
 
     if let Some((lint, kind, none_value)) = mess {
+        let help = if is_lint_allowed(cx, EXPECT_USED, expr.hir_id) {
+            format!(
+                "if you don't want to handle the `{none_value}` case gracefully, consider \
+                using `expect()` to provide a better panic message"
+            )
+        } else {
+            format!("if this value is an `{none_value}`, it will panic")
+        };
+
         span_lint_and_help(
             cx,
             lint,
             expr.span,
-            &format!("used `unwrap()` on `{}` value", kind,),
+            &format!("used `unwrap()` on `{kind}` value"),
             None,
-            &format!(
-                "if you don't want to handle the `{}` case gracefully, consider \
-                using `expect()` to provide a better panic message",
-                none_value,
-            ),
+            &help,
         );
     }
 }
diff --git a/tests/ui/unwrap_expect_used.rs b/tests/ui/unwrap_expect_used.rs
new file mode 100644
index 00000000000..0d4a0504a6e
--- /dev/null
+++ b/tests/ui/unwrap_expect_used.rs
@@ -0,0 +1,10 @@
+#![warn(clippy::unwrap_used, clippy::expect_used)]
+
+fn main() {
+    Some(3).unwrap();
+    Some(3).expect("Hello world!");
+
+    let a: Result<i32, i32> = Ok(3);
+    a.unwrap();
+    a.expect("Hello world!");
+}
diff --git a/tests/ui/unwrap_expect_used.stderr b/tests/ui/unwrap_expect_used.stderr
new file mode 100644
index 00000000000..a44aed4cb38
--- /dev/null
+++ b/tests/ui/unwrap_expect_used.stderr
@@ -0,0 +1,36 @@
+error: used `unwrap()` on `an Option` value
+  --> $DIR/unwrap_expect_used.rs:4:5
+   |
+LL |     Some(3).unwrap();
+   |     ^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::unwrap-used` implied by `-D warnings`
+   = help: if this value is an `None`, it will panic
+
+error: used `expect()` on `an Option` value
+  --> $DIR/unwrap_expect_used.rs:5:5
+   |
+LL |     Some(3).expect("Hello world!");
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::expect-used` implied by `-D warnings`
+   = help: if this value is an `None`, it will panic
+
+error: used `unwrap()` on `a Result` value
+  --> $DIR/unwrap_expect_used.rs:8:5
+   |
+LL |     a.unwrap();
+   |     ^^^^^^^^^^
+   |
+   = help: if this value is an `Err`, it will panic
+
+error: used `expect()` on `a Result` value
+  --> $DIR/unwrap_expect_used.rs:9:5
+   |
+LL |     a.expect("Hello world!");
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: if this value is an `Err`, it will panic
+
+error: aborting due to 4 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 6620aa05832a3a3d600e49f61a807945bd8f6037 Mon Sep 17 00:00:00 2001
From: Max Baumann <max@bmn.dev>
Date: Fri, 22 Jul 2022 16:39:45 +0200
Subject: update case_sensitive_file_extension_comparisons example The old
 example does not work in case the delimiter is not in the name

Co-authored-by: flip1995 <9744647+flip1995@users.noreply.github.com>
---
 clippy_lints/src/case_sensitive_file_extension_comparisons.rs | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/case_sensitive_file_extension_comparisons.rs b/clippy_lints/src/case_sensitive_file_extension_comparisons.rs
index 7af200708ff..7eff71d5007 100644
--- a/clippy_lints/src/case_sensitive_file_extension_comparisons.rs
+++ b/clippy_lints/src/case_sensitive_file_extension_comparisons.rs
@@ -24,7 +24,10 @@ declare_clippy_lint! {
     /// Use instead:
     /// ```rust
     /// fn is_rust_file(filename: &str) -> bool {
-    ///     filename.rsplit('.').next().map(|ext| ext.eq_ignore_ascii_case("rs")) == Some(true)
+    ///     let filename = std::path::Path::new(filename);
+    ///     filename.extension()
+    ///         .map(|ext| ext.eq_ignore_ascii_case("rs"))
+    ///         .unwrap_or(false)
     /// }
     /// ```
     #[clippy::version = "1.51.0"]
-- 
cgit 1.4.1-3-g733a5


From 3e5203147176bf4e7895c917d694a14d33e13419 Mon Sep 17 00:00:00 2001
From: Sosthène Guédon <sosthene@guedon.gdn>
Date: Fri, 22 Jul 2022 19:14:31 +0200
Subject: unwrap_used: Fix help, "an `None`" -> "`None`"

---
 clippy_lints/src/methods/expect_used.rs      | 10 +++++-----
 clippy_lints/src/methods/unwrap_used.rs      |  8 ++++----
 tests/ui-toml/expect_used/expect_used.stderr |  2 +-
 tests/ui/expect.stderr                       |  2 +-
 tests/ui/unwrap_expect_used.stderr           |  4 ++--
 5 files changed, 13 insertions(+), 13 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/expect_used.rs b/clippy_lints/src/methods/expect_used.rs
index fbc3348f185..5ef08ca6290 100644
--- a/clippy_lints/src/methods/expect_used.rs
+++ b/clippy_lints/src/methods/expect_used.rs
@@ -12,9 +12,9 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr
     let obj_ty = cx.typeck_results().expr_ty(recv).peel_refs();
 
     let mess = if is_type_diagnostic_item(cx, obj_ty, sym::Option) {
-        Some((EXPECT_USED, "an Option", "None"))
+        Some((EXPECT_USED, "an Option", "None", ""))
     } else if is_type_diagnostic_item(cx, obj_ty, sym::Result) {
-        Some((EXPECT_USED, "a Result", "Err"))
+        Some((EXPECT_USED, "a Result", "Err", "an "))
     } else {
         None
     };
@@ -23,14 +23,14 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr
         return;
     }
 
-    if let Some((lint, kind, none_value)) = mess {
+    if let Some((lint, kind, none_value, none_prefix)) = mess {
         span_lint_and_help(
             cx,
             lint,
             expr.span,
-            &format!("used `expect()` on `{}` value", kind,),
+            &format!("used `expect()` on `{kind}` value"),
             None,
-            &format!("if this value is an `{}`, it will panic", none_value,),
+            &format!("if this value is {none_prefix}`{none_value}`, it will panic"),
         );
     }
 }
diff --git a/clippy_lints/src/methods/unwrap_used.rs b/clippy_lints/src/methods/unwrap_used.rs
index eae6ba693a2..ce1a52e5480 100644
--- a/clippy_lints/src/methods/unwrap_used.rs
+++ b/clippy_lints/src/methods/unwrap_used.rs
@@ -12,9 +12,9 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr
     let obj_ty = cx.typeck_results().expr_ty(recv).peel_refs();
 
     let mess = if is_type_diagnostic_item(cx, obj_ty, sym::Option) {
-        Some((UNWRAP_USED, "an Option", "None"))
+        Some((UNWRAP_USED, "an Option", "None", ""))
     } else if is_type_diagnostic_item(cx, obj_ty, sym::Result) {
-        Some((UNWRAP_USED, "a Result", "Err"))
+        Some((UNWRAP_USED, "a Result", "Err", "an "))
     } else {
         None
     };
@@ -23,14 +23,14 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr
         return;
     }
 
-    if let Some((lint, kind, none_value)) = mess {
+    if let Some((lint, kind, none_value, none_prefix)) = mess {
         let help = if is_lint_allowed(cx, EXPECT_USED, expr.hir_id) {
             format!(
                 "if you don't want to handle the `{none_value}` case gracefully, consider \
                 using `expect()` to provide a better panic message"
             )
         } else {
-            format!("if this value is an `{none_value}`, it will panic")
+            format!("if this value is {none_prefix}`{none_value}`, it will panic")
         };
 
         span_lint_and_help(
diff --git a/tests/ui-toml/expect_used/expect_used.stderr b/tests/ui-toml/expect_used/expect_used.stderr
index 9cb2199ed21..c5d95cb8a14 100644
--- a/tests/ui-toml/expect_used/expect_used.stderr
+++ b/tests/ui-toml/expect_used/expect_used.stderr
@@ -5,7 +5,7 @@ LL |     let _ = opt.expect("");
    |             ^^^^^^^^^^^^^^
    |
    = note: `-D clippy::expect-used` implied by `-D warnings`
-   = help: if this value is an `None`, it will panic
+   = help: if this value is `None`, it will panic
 
 error: used `expect()` on `a Result` value
   --> $DIR/expect_used.rs:11:13
diff --git a/tests/ui/expect.stderr b/tests/ui/expect.stderr
index 9d3fc7df15c..ab28aac4556 100644
--- a/tests/ui/expect.stderr
+++ b/tests/ui/expect.stderr
@@ -5,7 +5,7 @@ LL |     let _ = opt.expect("");
    |             ^^^^^^^^^^^^^^
    |
    = note: `-D clippy::expect-used` implied by `-D warnings`
-   = help: if this value is an `None`, it will panic
+   = help: if this value is `None`, it will panic
 
 error: used `expect()` on `a Result` value
   --> $DIR/expect.rs:10:13
diff --git a/tests/ui/unwrap_expect_used.stderr b/tests/ui/unwrap_expect_used.stderr
index a44aed4cb38..f54bfd617c4 100644
--- a/tests/ui/unwrap_expect_used.stderr
+++ b/tests/ui/unwrap_expect_used.stderr
@@ -5,7 +5,7 @@ LL |     Some(3).unwrap();
    |     ^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::unwrap-used` implied by `-D warnings`
-   = help: if this value is an `None`, it will panic
+   = help: if this value is `None`, it will panic
 
 error: used `expect()` on `an Option` value
   --> $DIR/unwrap_expect_used.rs:5:5
@@ -14,7 +14,7 @@ LL |     Some(3).expect("Hello world!");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::expect-used` implied by `-D warnings`
-   = help: if this value is an `None`, it will panic
+   = help: if this value is `None`, it will panic
 
 error: used `unwrap()` on `a Result` value
   --> $DIR/unwrap_expect_used.rs:8:5
-- 
cgit 1.4.1-3-g733a5


From a7389556f86bec7d31ee8b8cce5358f9af030cf0 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sat, 23 Jul 2022 08:36:26 -0400
Subject: fix outdated lint names in docs

---
 clippy_lints/src/as_conversions.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/as_conversions.rs b/clippy_lints/src/as_conversions.rs
index 6e5c8f44581..c7a76e5f907 100644
--- a/clippy_lints/src/as_conversions.rs
+++ b/clippy_lints/src/as_conversions.rs
@@ -11,7 +11,7 @@ declare_clippy_lint! {
     /// Note that this lint is specialized in linting *every single* use of `as`
     /// regardless of whether good alternatives exist or not.
     /// If you want more precise lints for `as`, please consider using these separate lints:
-    /// `unnecessary_cast`, `cast_lossless/possible_truncation/possible_wrap/precision_loss/sign_loss`,
+    /// `unnecessary_cast`, `cast_lossless/cast_possible_truncation/cast_possible_wrap/cast_precision_loss/cast_sign_loss`,
     /// `fn_to_numeric_cast(_with_truncation)`, `char_lit_as_u8`, `ref_to_mut` and `ptr_as_ptr`.
     /// There is a good explanation the reason why this lint should work in this way and how it is useful
     /// [in this issue](https://github.com/rust-lang/rust-clippy/issues/5122).
-- 
cgit 1.4.1-3-g733a5


From d60d5e8bde9650f967f511f6649bc8f8ece8decc Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Sun, 24 Jul 2022 16:37:08 +0000
Subject: Fix `useless_format` spans for `format!("{foo}")`

---
 clippy_lints/src/format.rs | 19 ++-----------------
 tests/ui/format.fixed      |  6 ++++++
 tests/ui/format.rs         |  6 ++++++
 tests/ui/format.stderr     | 14 +++++++++++++-
 4 files changed, 27 insertions(+), 18 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/format.rs b/clippy_lints/src/format.rs
index 3084c70589f..9137d8ef382 100644
--- a/clippy_lints/src/format.rs
+++ b/clippy_lints/src/format.rs
@@ -9,7 +9,7 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::symbol::kw;
-use rustc_span::{sym, BytePos, Span};
+use rustc_span::{sym, Span};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -85,22 +85,7 @@ impl<'tcx> LateLintPass<'tcx> for UselessFormat {
                         ExprKind::MethodCall(path, ..) => path.ident.name.as_str() == "to_string",
                         _ => false,
                     };
-                    let sugg = if format_args.format_string_span.contains(value.span) {
-                        // Implicit argument. e.g. `format!("{x}")` span points to `{x}`
-                        let spdata = value.span.data();
-                        let span = Span::new(
-                            spdata.lo + BytePos(1),
-                            spdata.hi - BytePos(1),
-                            spdata.ctxt,
-                            spdata.parent
-                        );
-                        let snip = snippet_with_applicability(cx, span, "..", &mut applicability);
-                        if is_new_string {
-                            snip.into()
-                        } else {
-                            format!("{snip}.to_string()")
-                        }
-                    } else if is_new_string {
+                    let sugg = if is_new_string {
                         snippet_with_applicability(cx, value.span, "..", &mut applicability).into_owned()
                     } else {
                         let sugg = Sugg::hir_with_applicability(cx, value, "<arg>", &mut applicability);
diff --git a/tests/ui/format.fixed b/tests/ui/format.fixed
index d08f8f52495..f4db2d20c71 100644
--- a/tests/ui/format.fixed
+++ b/tests/ui/format.fixed
@@ -84,4 +84,10 @@ fn main() {
     let _ = x.to_string();
     let _ = format!("{x:?}"); // Don't lint on debug
     let _ = x.to_string();
+
+    // Issue #9234
+    let abc = "abc";
+    let _ = abc.to_string();
+    let xx = "xx";
+    let _ = xx.to_string();
 }
diff --git a/tests/ui/format.rs b/tests/ui/format.rs
index 4a10b580d26..bf687cb1e96 100644
--- a/tests/ui/format.rs
+++ b/tests/ui/format.rs
@@ -86,4 +86,10 @@ fn main() {
     let _ = format!("{x}");
     let _ = format!("{x:?}"); // Don't lint on debug
     let _ = format!("{y}", y = x);
+
+    // Issue #9234
+    let abc = "abc";
+    let _ = format!("{abc}");
+    let xx = "xx";
+    let _ = format!("{xx}");
 }
diff --git a/tests/ui/format.stderr b/tests/ui/format.stderr
index f25c7fb1ff1..a0f8e7d1937 100644
--- a/tests/ui/format.stderr
+++ b/tests/ui/format.stderr
@@ -111,5 +111,17 @@ error: useless use of `format!`
 LL |     let _ = format!("{y}", y = x);
    |             ^^^^^^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `x.to_string()`
 
-error: aborting due to 17 previous errors
+error: useless use of `format!`
+  --> $DIR/format.rs:92:13
+   |
+LL |     let _ = format!("{abc}");
+   |             ^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `abc.to_string()`
+
+error: useless use of `format!`
+  --> $DIR/format.rs:94:13
+   |
+LL |     let _ = format!("{xx}");
+   |             ^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `xx.to_string()`
+
+error: aborting due to 19 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 2255cfd2abd089d14a682c9df0cf2dd2ef697552 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sun, 24 Jul 2022 23:12:29 -0400
Subject: Fix ICE in `question_mark`

---
 clippy_lints/src/question_mark.rs | 4 ++--
 tests/ui/crashes/ice-9242.rs      | 8 ++++++++
 2 files changed, 10 insertions(+), 2 deletions(-)
 create mode 100644 tests/ui/crashes/ice-9242.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/question_mark.rs b/clippy_lints/src/question_mark.rs
index f0155ed6051..fd0a53839e6 100644
--- a/clippy_lints/src/question_mark.rs
+++ b/clippy_lints/src/question_mark.rs
@@ -123,8 +123,8 @@ fn check_if_let_some_or_err_and_early_return<'tcx>(cx: &LateContext<'tcx>, expr:
     if_chain! {
         if let Some(higher::IfLet { let_pat, let_expr, if_then, if_else }) = higher::IfLet::hir(cx, expr);
         if !is_else_clause(cx.tcx, expr);
-        if let PatKind::TupleStruct(ref path1, fields, None) = let_pat.kind;
-        if let PatKind::Binding(annot, bind_id, ident, _) = fields[0].kind;
+        if let PatKind::TupleStruct(ref path1, [field], None) = let_pat.kind;
+        if let PatKind::Binding(annot, bind_id, ident, _) = field.kind;
         let caller_ty = cx.typeck_results().expr_ty(let_expr);
         let if_block = IfBlockType::IfLet(path1, caller_ty, ident.name, let_expr, if_then, if_else);
         if (is_early_return(sym::Option, cx, &if_block) && path_to_local_id(peel_blocks(if_then), bind_id))
diff --git a/tests/ui/crashes/ice-9242.rs b/tests/ui/crashes/ice-9242.rs
new file mode 100644
index 00000000000..0099e6e2f34
--- /dev/null
+++ b/tests/ui/crashes/ice-9242.rs
@@ -0,0 +1,8 @@
+enum E {
+    X(),
+    Y,
+}
+
+fn main() {
+    let _ = if let E::X() = E::X() { 1 } else { 2 };
+}
-- 
cgit 1.4.1-3-g733a5


From 6bc024df188526a984827d9ecca978414df0afff Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sun, 24 Jul 2022 20:17:55 -0400
Subject: Improve `[std|alloc]_instead_of_[alloc|core]` lints * Don't call
 `TyCtxt::crate_name` unless necessary * Don't lint on `use std::env` * Only
 lint once on `use std::vec`

---
 clippy_lints/src/lib.rs                 |  2 +-
 clippy_lints/src/std_instead_of_core.rs | 94 +++++++++++++++++++--------------
 tests/ui/std_instead_of_core.rs         |  6 +++
 tests/ui/std_instead_of_core.stderr     | 28 ++++++----
 4 files changed, 79 insertions(+), 51 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 8444532f6bb..fd4da166dfe 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -916,7 +916,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     let verbose_bit_mask_threshold = conf.verbose_bit_mask_threshold;
     store.register_late_pass(move || Box::new(operators::Operators::new(verbose_bit_mask_threshold)));
     store.register_late_pass(|| Box::new(invalid_utf8_in_unchecked::InvalidUtf8InUnchecked));
-    store.register_late_pass(|| Box::new(std_instead_of_core::StdReexports));
+    store.register_late_pass(|| Box::new(std_instead_of_core::StdReexports::default()));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/std_instead_of_core.rs b/clippy_lints/src/std_instead_of_core.rs
index 560a3164563..ffd63cc687a 100644
--- a/clippy_lints/src/std_instead_of_core.rs
+++ b/clippy_lints/src/std_instead_of_core.rs
@@ -1,8 +1,8 @@
 use clippy_utils::diagnostics::span_lint_and_help;
 use rustc_hir::{def::Res, HirId, Path, PathSegment};
-use rustc_lint::{LateContext, LateLintPass, Lint};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::{sym, symbol::kw, Symbol};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::{sym, symbol::kw, Span};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -81,39 +81,55 @@ declare_clippy_lint! {
     "type is imported from alloc when available in core"
 }
 
-declare_lint_pass!(StdReexports => [STD_INSTEAD_OF_CORE, STD_INSTEAD_OF_ALLOC, ALLOC_INSTEAD_OF_CORE]);
+#[derive(Default)]
+pub struct StdReexports {
+    // Paths which can be either a module or a macro (e.g. `std::env`) will cause this check to happen
+    // twice. First for the mod, second for the macro. This is used to avoid the lint reporting for the macro
+    // when the path could be also be used to access the module.
+    prev_span: Span,
+}
+impl_lint_pass!(StdReexports => [STD_INSTEAD_OF_CORE, STD_INSTEAD_OF_ALLOC, ALLOC_INSTEAD_OF_CORE]);
 
 impl<'tcx> LateLintPass<'tcx> for StdReexports {
     fn check_path(&mut self, cx: &LateContext<'tcx>, path: &Path<'tcx>, _: HirId) {
-        // std_instead_of_core
-        check_path(cx, path, sym::std, sym::core, STD_INSTEAD_OF_CORE);
-        // std_instead_of_alloc
-        check_path(cx, path, sym::std, sym::alloc, STD_INSTEAD_OF_ALLOC);
-        // alloc_instead_of_core
-        check_path(cx, path, sym::alloc, sym::core, ALLOC_INSTEAD_OF_CORE);
-    }
-}
-
-fn check_path(cx: &LateContext<'_>, path: &Path<'_>, krate: Symbol, suggested_crate: Symbol, lint: &'static Lint) {
-    if_chain! {
-        // check if path resolves to the suggested crate.
-        if let Res::Def(_, def_id) = path.res;
-        if suggested_crate == cx.tcx.crate_name(def_id.krate);
-
-        // check if the first segment of the path is the crate we want to identify
-        if let Some(path_root_segment) = get_first_segment(path);
-
-        // check if the path matches the crate we want to suggest the other path for.
-        if krate == path_root_segment.ident.name;
-        then {
-            span_lint_and_help(
-                cx,
-                lint,
-                path.span,
-                &format!("used import from `{}` instead of `{}`", krate, suggested_crate),
-                None,
-                &format!("consider importing the item from `{}`", suggested_crate),
-            );
+        if let Res::Def(_, def_id) = path.res
+            && let Some(first_segment) = get_first_segment(path)
+        {
+            let (lint, msg, help) = match first_segment.ident.name {
+                sym::std => match cx.tcx.crate_name(def_id.krate) {
+                    sym::core => (
+                        STD_INSTEAD_OF_CORE,
+                        "used import from `std` instead of `core`",
+                        "consider importing the item from `core`",
+                    ),
+                    sym::alloc => (
+                        STD_INSTEAD_OF_ALLOC,
+                        "used import from `std` instead of `alloc`",
+                        "consider importing the item from `alloc`",
+                    ),
+                    _ => {
+                        self.prev_span = path.span;
+                        return;
+                    },
+                },
+                sym::alloc => {
+                    if cx.tcx.crate_name(def_id.krate) == sym::core {
+                        (
+                            ALLOC_INSTEAD_OF_CORE,
+                            "used import from `alloc` instead of `core`",
+                            "consider importing the item from `core`",
+                        )
+                    } else {
+                        self.prev_span = path.span;
+                        return;
+                    }
+                },
+                _ => return,
+            };
+            if path.span != self.prev_span {
+                span_lint_and_help(cx, lint, path.span, msg, None, help);
+                self.prev_span = path.span;
+            }
         }
     }
 }
@@ -123,12 +139,10 @@ fn check_path(cx: &LateContext<'_>, path: &Path<'_>, krate: Symbol, suggested_cr
 /// If this is a global path (such as `::std::fmt::Debug`), then the segment after [`kw::PathRoot`]
 /// is returned.
 fn get_first_segment<'tcx>(path: &Path<'tcx>) -> Option<&'tcx PathSegment<'tcx>> {
-    let segment = path.segments.first()?;
-
-    // A global path will have PathRoot as the first segment. In this case, return the segment after.
-    if segment.ident.name == kw::PathRoot {
-        path.segments.get(1)
-    } else {
-        Some(segment)
+    match path.segments {
+        // A global path will have PathRoot as the first segment. In this case, return the segment after.
+        [x, y, ..] if x.ident.name == kw::PathRoot => Some(y),
+        [x, ..] => Some(x),
+        _ => None,
     }
 }
diff --git a/tests/ui/std_instead_of_core.rs b/tests/ui/std_instead_of_core.rs
index 74f05ec1f65..6b27475de4c 100644
--- a/tests/ui/std_instead_of_core.rs
+++ b/tests/ui/std_instead_of_core.rs
@@ -9,6 +9,8 @@ fn std_instead_of_core() {
     use std::hash::Hasher;
     // Absolute path
     use ::std::hash::Hash;
+    // Don't lint on `env` macro
+    use std::env;
 
     // Multiple imports
     use std::fmt::{Debug, Result};
@@ -20,10 +22,14 @@ fn std_instead_of_core() {
     // Types
     let cell = std::cell::Cell::new(8u32);
     let cell_absolute = ::std::cell::Cell::new(8u32);
+
+    let _ = std::env!("PATH");
 }
 
 #[warn(clippy::std_instead_of_alloc)]
 fn std_instead_of_alloc() {
+    // Only lint once.
+    use std::vec;
     use std::vec::Vec;
 }
 
diff --git a/tests/ui/std_instead_of_core.stderr b/tests/ui/std_instead_of_core.stderr
index 9f1644835c1..bc49dabf586 100644
--- a/tests/ui/std_instead_of_core.stderr
+++ b/tests/ui/std_instead_of_core.stderr
@@ -16,7 +16,7 @@ LL |     use ::std::hash::Hash;
    = help: consider importing the item from `core`
 
 error: used import from `std` instead of `core`
-  --> $DIR/std_instead_of_core.rs:14:20
+  --> $DIR/std_instead_of_core.rs:16:20
    |
 LL |     use std::fmt::{Debug, Result};
    |                    ^^^^^
@@ -24,7 +24,7 @@ LL |     use std::fmt::{Debug, Result};
    = help: consider importing the item from `core`
 
 error: used import from `std` instead of `core`
-  --> $DIR/std_instead_of_core.rs:14:27
+  --> $DIR/std_instead_of_core.rs:16:27
    |
 LL |     use std::fmt::{Debug, Result};
    |                           ^^^^^^
@@ -32,7 +32,7 @@ LL |     use std::fmt::{Debug, Result};
    = help: consider importing the item from `core`
 
 error: used import from `std` instead of `core`
-  --> $DIR/std_instead_of_core.rs:17:15
+  --> $DIR/std_instead_of_core.rs:19:15
    |
 LL |     let ptr = std::ptr::null::<u32>();
    |               ^^^^^^^^^^^^^^^^^^^^^
@@ -40,7 +40,7 @@ LL |     let ptr = std::ptr::null::<u32>();
    = help: consider importing the item from `core`
 
 error: used import from `std` instead of `core`
-  --> $DIR/std_instead_of_core.rs:18:19
+  --> $DIR/std_instead_of_core.rs:20:19
    |
 LL |     let ptr_mut = ::std::ptr::null_mut::<usize>();
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -48,7 +48,7 @@ LL |     let ptr_mut = ::std::ptr::null_mut::<usize>();
    = help: consider importing the item from `core`
 
 error: used import from `std` instead of `core`
-  --> $DIR/std_instead_of_core.rs:21:16
+  --> $DIR/std_instead_of_core.rs:23:16
    |
 LL |     let cell = std::cell::Cell::new(8u32);
    |                ^^^^^^^^^^^^^^^
@@ -56,7 +56,7 @@ LL |     let cell = std::cell::Cell::new(8u32);
    = help: consider importing the item from `core`
 
 error: used import from `std` instead of `core`
-  --> $DIR/std_instead_of_core.rs:22:25
+  --> $DIR/std_instead_of_core.rs:24:25
    |
 LL |     let cell_absolute = ::std::cell::Cell::new(8u32);
    |                         ^^^^^^^^^^^^^^^^^
@@ -64,16 +64,24 @@ LL |     let cell_absolute = ::std::cell::Cell::new(8u32);
    = help: consider importing the item from `core`
 
 error: used import from `std` instead of `alloc`
-  --> $DIR/std_instead_of_core.rs:27:9
+  --> $DIR/std_instead_of_core.rs:32:9
+   |
+LL |     use std::vec;
+   |         ^^^^^^^^
+   |
+   = note: `-D clippy::std-instead-of-alloc` implied by `-D warnings`
+   = help: consider importing the item from `alloc`
+
+error: used import from `std` instead of `alloc`
+  --> $DIR/std_instead_of_core.rs:33:9
    |
 LL |     use std::vec::Vec;
    |         ^^^^^^^^^^^^^
    |
-   = note: `-D clippy::std-instead-of-alloc` implied by `-D warnings`
    = help: consider importing the item from `alloc`
 
 error: used import from `alloc` instead of `core`
-  --> $DIR/std_instead_of_core.rs:32:9
+  --> $DIR/std_instead_of_core.rs:38:9
    |
 LL |     use alloc::slice::from_ref;
    |         ^^^^^^^^^^^^^^^^^^^^^^
@@ -81,5 +89,5 @@ LL |     use alloc::slice::from_ref;
    = note: `-D clippy::alloc-instead-of-core` implied by `-D warnings`
    = help: consider importing the item from `core`
 
-error: aborting due to 10 previous errors
+error: aborting due to 11 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 477356460b0797a3ce666f5e55cfa5fc74314c00 Mon Sep 17 00:00:00 2001
From: kyoto7250 <50972773+kyoto7250@users.noreply.github.com>
Date: Mon, 25 Jul 2022 21:41:12 +0900
Subject: check macro statements in non_copy_const.rs

---
 Cargo.toml                                         |  2 +-
 clippy_lints/src/non_copy_const.rs                 | 18 ++++++++-------
 tests/ui/declare_interior_mutable_const/others.rs  | 27 +++++++++++++++++++---
 .../declare_interior_mutable_const/others.stderr   | 13 ++++++++++-
 4 files changed, 47 insertions(+), 13 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/Cargo.toml b/Cargo.toml
index 69deaca0b4b..699e68b86f7 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -52,7 +52,7 @@ serde = { version = "1.0.125", features = ["derive"] }
 syn = { version = "1.0", features = ["full"] }
 futures = "0.3"
 parking_lot = "0.12"
-tokio = { version = "1", features = ["io-util"] }
+tokio = { version = "1", features = ["full"] }
 rustc-semver = "1.1"
 
 [build-dependencies]
diff --git a/clippy_lints/src/non_copy_const.rs b/clippy_lints/src/non_copy_const.rs
index 6bce5fbd4c1..72c86f28bbc 100644
--- a/clippy_lints/src/non_copy_const.rs
+++ b/clippy_lints/src/non_copy_const.rs
@@ -251,14 +251,7 @@ impl<'tcx> LateLintPass<'tcx> for NonCopyConst {
     fn check_item(&mut self, cx: &LateContext<'tcx>, it: &'tcx Item<'_>) {
         if let ItemKind::Const(hir_ty, body_id) = it.kind {
             let ty = hir_ty_to_ty(cx.tcx, hir_ty);
-            if !macro_backtrace(it.span).last().map_or(false, |macro_call| {
-                matches!(
-                    cx.tcx.get_diagnostic_name(macro_call.def_id),
-                    Some(sym::thread_local_macro)
-                )
-            }) && is_unfrozen(cx, ty)
-                && is_value_unfrozen_poly(cx, body_id, ty)
-            {
+            if !ignored_macro(cx, it) && is_unfrozen(cx, ty) && is_value_unfrozen_poly(cx, body_id, ty) {
                 lint(cx, Source::Item { item: it.span });
             }
         }
@@ -445,3 +438,12 @@ impl<'tcx> LateLintPass<'tcx> for NonCopyConst {
         }
     }
 }
+
+fn ignored_macro(cx: &LateContext<'_>, it: &rustc_hir::Item<'_>) -> bool {
+    macro_backtrace(it.span).any(|macro_call| {
+        matches!(
+            cx.tcx.get_diagnostic_name(macro_call.def_id),
+            Some(sym::thread_local_macro)
+        )
+    })
+}
diff --git a/tests/ui/declare_interior_mutable_const/others.rs b/tests/ui/declare_interior_mutable_const/others.rs
index 62af545db50..f46d3499f4e 100644
--- a/tests/ui/declare_interior_mutable_const/others.rs
+++ b/tests/ui/declare_interior_mutable_const/others.rs
@@ -31,9 +31,30 @@ const NO_ANN: &dyn Display = &70;
 static STATIC_TUPLE: (AtomicUsize, String) = (ATOMIC, STRING);
 //^ there should be no lints on this line
 
-// issue #8493
-thread_local! {
-    static THREAD_LOCAL: Cell<i32> = const { Cell::new(0) };
+mod issue_8493 {
+    use std::cell::Cell;
+
+    // https://github.com/rust-lang/rust-clippy/issues/9224
+    tokio::task_local! {
+        pub static _FOO: String;
+    }
+
+    thread_local! {
+        static _BAR: Cell<i32> = const { Cell::new(0) };
+    }
+
+    macro_rules! issue_8493 {
+        () => {
+            const _BAZ: Cell<usize> = Cell::new(0); //~ ERROR interior mutable
+            static _FOOBAR: () = {
+                thread_local! {
+                    static _VAR: Cell<i32> = const { Cell::new(0) };
+                }
+            };
+        };
+    }
+
+    issue_8493!();
 }
 
 fn main() {}
diff --git a/tests/ui/declare_interior_mutable_const/others.stderr b/tests/ui/declare_interior_mutable_const/others.stderr
index fd0689dfc4c..6cba9491ef4 100644
--- a/tests/ui/declare_interior_mutable_const/others.stderr
+++ b/tests/ui/declare_interior_mutable_const/others.stderr
@@ -35,5 +35,16 @@ LL | declare_const!(_ONCE: Once = Once::new()); //~ ERROR interior mutable
    |
    = note: this error originates in the macro `declare_const` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to 4 previous errors
+error: a `const` item should never be interior mutable
+  --> $DIR/others.rs:48:13
+   |
+LL |             const _BAZ: Cell<usize> = Cell::new(0); //~ ERROR interior mutable
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+...
+LL |     issue_8493!();
+   |     ------------- in this macro invocation
+   |
+   = note: this error originates in the macro `issue_8493` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: aborting due to 5 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 8454602cef2d4ce1271425c0924303955ee47e82 Mon Sep 17 00:00:00 2001
From: tabokie <xy.tao@outlook.com>
Date: Fri, 22 Jul 2022 13:17:10 +0800
Subject: Add `[assertions_on_result_states]` lint

Signed-off-by: tabokie <xy.tao@outlook.com>
---
 CHANGELOG.md                                    |  1 +
 clippy_lints/src/assertions_on_result_states.rs | 98 +++++++++++++++++++++++++
 clippy_lints/src/lib.register_all.rs            |  1 +
 clippy_lints/src/lib.register_lints.rs          |  1 +
 clippy_lints/src/lib.register_style.rs          |  1 +
 clippy_lints/src/lib.rs                         |  2 +
 tests/ui/assertions_on_result_states.fixed      | 69 +++++++++++++++++
 tests/ui/assertions_on_result_states.rs         | 69 +++++++++++++++++
 tests/ui/assertions_on_result_states.stderr     | 40 ++++++++++
 9 files changed, 282 insertions(+)
 create mode 100644 clippy_lints/src/assertions_on_result_states.rs
 create mode 100644 tests/ui/assertions_on_result_states.fixed
 create mode 100644 tests/ui/assertions_on_result_states.rs
 create mode 100644 tests/ui/assertions_on_result_states.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 1d5c216c154..e64e5d94bc9 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3440,6 +3440,7 @@ Released 2018-09-13
 [`as_conversions`]: https://rust-lang.github.io/rust-clippy/master/index.html#as_conversions
 [`as_underscore`]: https://rust-lang.github.io/rust-clippy/master/index.html#as_underscore
 [`assertions_on_constants`]: https://rust-lang.github.io/rust-clippy/master/index.html#assertions_on_constants
+[`assertions_on_result_states`]: https://rust-lang.github.io/rust-clippy/master/index.html#assertions_on_result_states
 [`assign_op_pattern`]: https://rust-lang.github.io/rust-clippy/master/index.html#assign_op_pattern
 [`assign_ops`]: https://rust-lang.github.io/rust-clippy/master/index.html#assign_ops
 [`async_yields_async`]: https://rust-lang.github.io/rust-clippy/master/index.html#async_yields_async
diff --git a/clippy_lints/src/assertions_on_result_states.rs b/clippy_lints/src/assertions_on_result_states.rs
new file mode 100644
index 00000000000..b6affdee523
--- /dev/null
+++ b/clippy_lints/src/assertions_on_result_states.rs
@@ -0,0 +1,98 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::macros::{find_assert_args, root_macro_call_first_node, PanicExpn};
+use clippy_utils::path_res;
+use clippy_utils::source::snippet_with_context;
+use clippy_utils::ty::{implements_trait, is_copy, is_type_diagnostic_item};
+use clippy_utils::usage::local_used_after_expr;
+use rustc_errors::Applicability;
+use rustc_hir::def::Res;
+use rustc_hir::{Expr, ExprKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::{self, Ty};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::sym;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `assert!(r.is_ok())` or `assert!(r.is_err())` calls.
+    ///
+    /// ### Why is this bad?
+    /// An assertion failure cannot output an useful message of the error.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// # let r = Ok::<_, ()>(());
+    /// assert!(r.is_ok());
+    /// # let r = Err::<_, ()>(());
+    /// assert!(r.is_err());
+    /// ```
+    #[clippy::version = "1.64.0"]
+    pub ASSERTIONS_ON_RESULT_STATES,
+    style,
+    "`assert!(r.is_ok())`/`assert!(r.is_err())` gives worse error message than directly calling `r.unwrap()`/`r.unwrap_err()`"
+}
+
+declare_lint_pass!(AssertionsOnResultStates => [ASSERTIONS_ON_RESULT_STATES]);
+
+impl<'tcx> LateLintPass<'tcx> for AssertionsOnResultStates {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
+        if let Some(macro_call) = root_macro_call_first_node(cx, e)
+            && matches!(cx.tcx.get_diagnostic_name(macro_call.def_id), Some(sym::assert_macro))
+            && let Some((condition, panic_expn)) = find_assert_args(cx, e, macro_call.expn)
+            && matches!(panic_expn, PanicExpn::Empty)
+            && let ExprKind::MethodCall(method_segment, [recv], _) = condition.kind
+            && let result_type_with_refs = cx.typeck_results().expr_ty(recv)
+            && let result_type = result_type_with_refs.peel_refs()
+            && is_type_diagnostic_item(cx, result_type, sym::Result)
+            && let ty::Adt(_, substs) = result_type.kind()
+        {
+            if !is_copy(cx, result_type) {
+                if result_type_with_refs != result_type {
+                    return;
+                } else if let Res::Local(binding_id) = path_res(cx, recv)
+                    && local_used_after_expr(cx, binding_id, recv) {
+                    return;
+                }
+            }
+            let mut app = Applicability::MachineApplicable;
+            match method_segment.ident.as_str() {
+                "is_ok" if has_debug_impl(cx, substs.type_at(1)) => {
+                    span_lint_and_sugg(
+                        cx,
+                        ASSERTIONS_ON_RESULT_STATES,
+                        macro_call.span,
+                        "called `assert!` with `Result::is_ok`",
+                        "replace with",
+                        format!(
+                            "{}.unwrap()",
+                            snippet_with_context(cx, recv.span, condition.span.ctxt(), "..", &mut app).0
+                        ),
+                        app,
+                    );
+                }
+                "is_err" if has_debug_impl(cx, substs.type_at(0)) => {
+                    span_lint_and_sugg(
+                        cx,
+                        ASSERTIONS_ON_RESULT_STATES,
+                        macro_call.span,
+                        "called `assert!` with `Result::is_err`",
+                        "replace with",
+                        format!(
+                            "{}.unwrap_err()",
+                            snippet_with_context(cx, recv.span, condition.span.ctxt(), "..", &mut app).0
+                        ),
+                        app,
+                    );
+                }
+                _ => (),
+            };
+        }
+    }
+}
+
+/// This checks whether a given type is known to implement Debug.
+fn has_debug_impl<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
+    cx.tcx
+        .get_diagnostic_item(sym::Debug)
+        .map_or(false, |debug| implements_trait(cx, ty, debug, &[]))
+}
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 0ba9b7ae7e5..5be1c417bf8 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -6,6 +6,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(almost_complete_letter_range::ALMOST_COMPLETE_LETTER_RANGE),
     LintId::of(approx_const::APPROX_CONSTANT),
     LintId::of(assertions_on_constants::ASSERTIONS_ON_CONSTANTS),
+    LintId::of(assertions_on_result_states::ASSERTIONS_ON_RESULT_STATES),
     LintId::of(async_yields_async::ASYNC_YIELDS_ASYNC),
     LintId::of(attrs::BLANKET_CLIPPY_RESTRICTION_LINTS),
     LintId::of(attrs::DEPRECATED_CFG_ATTR),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index d40c6aec04a..65e01de2b16 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -42,6 +42,7 @@ store.register_lints(&[
     asm_syntax::INLINE_ASM_X86_ATT_SYNTAX,
     asm_syntax::INLINE_ASM_X86_INTEL_SYNTAX,
     assertions_on_constants::ASSERTIONS_ON_CONSTANTS,
+    assertions_on_result_states::ASSERTIONS_ON_RESULT_STATES,
     async_yields_async::ASYNC_YIELDS_ASYNC,
     attrs::ALLOW_ATTRIBUTES_WITHOUT_REASON,
     attrs::BLANKET_CLIPPY_RESTRICTION_LINTS,
diff --git a/clippy_lints/src/lib.register_style.rs b/clippy_lints/src/lib.register_style.rs
index e95bab1d045..e029a5235e7 100644
--- a/clippy_lints/src/lib.register_style.rs
+++ b/clippy_lints/src/lib.register_style.rs
@@ -4,6 +4,7 @@
 
 store.register_group(true, "clippy::style", Some("clippy_style"), vec![
     LintId::of(assertions_on_constants::ASSERTIONS_ON_CONSTANTS),
+    LintId::of(assertions_on_result_states::ASSERTIONS_ON_RESULT_STATES),
     LintId::of(blacklisted_name::BLACKLISTED_NAME),
     LintId::of(blocks_in_if_conditions::BLOCKS_IN_IF_CONDITIONS),
     LintId::of(bool_assert_comparison::BOOL_ASSERT_COMPARISON),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 8444532f6bb..6cd1928e9c1 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -174,6 +174,7 @@ mod as_conversions;
 mod as_underscore;
 mod asm_syntax;
 mod assertions_on_constants;
+mod assertions_on_result_states;
 mod async_yields_async;
 mod attrs;
 mod await_holding_invalid;
@@ -727,6 +728,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(unnecessary_sort_by::UnnecessarySortBy));
     store.register_late_pass(move || Box::new(unnecessary_wraps::UnnecessaryWraps::new(avoid_breaking_exported_api)));
     store.register_late_pass(|| Box::new(assertions_on_constants::AssertionsOnConstants));
+    store.register_late_pass(|| Box::new(assertions_on_result_states::AssertionsOnResultStates));
     store.register_late_pass(|| Box::new(transmuting_null::TransmutingNull));
     store.register_late_pass(|| Box::new(path_buf_push_overwrite::PathBufPushOverwrite));
     store.register_late_pass(|| Box::new(inherent_to_string::InherentToString));
diff --git a/tests/ui/assertions_on_result_states.fixed b/tests/ui/assertions_on_result_states.fixed
new file mode 100644
index 00000000000..7bde72e4b6b
--- /dev/null
+++ b/tests/ui/assertions_on_result_states.fixed
@@ -0,0 +1,69 @@
+// run-rustfix
+#![warn(clippy::assertions_on_result_states)]
+
+use std::result::Result;
+
+struct Foo;
+
+#[derive(Debug)]
+struct DebugFoo;
+
+#[derive(Copy, Clone, Debug)]
+struct CopyFoo;
+
+macro_rules! get_ok_macro {
+    () => {
+        Ok::<_, DebugFoo>(Foo)
+    };
+}
+
+fn main() {
+    // test ok
+    let r: Result<Foo, DebugFoo> = Ok(Foo);
+    debug_assert!(r.is_ok());
+    r.unwrap();
+
+    // test ok with non-debug error type
+    let r: Result<Foo, Foo> = Ok(Foo);
+    assert!(r.is_ok());
+
+    // test temporary ok
+    fn get_ok() -> Result<Foo, DebugFoo> {
+        Ok(Foo)
+    }
+    get_ok().unwrap();
+
+    // test macro ok
+    get_ok_macro!().unwrap();
+
+    // test ok that shouldn't be moved
+    let r: Result<CopyFoo, DebugFoo> = Ok(CopyFoo);
+    fn test_ref_unmoveable_ok(r: &Result<CopyFoo, DebugFoo>) {
+        assert!(r.is_ok());
+    }
+    test_ref_unmoveable_ok(&r);
+    assert!(r.is_ok());
+    r.unwrap();
+
+    // test ok that is copied
+    let r: Result<CopyFoo, CopyFoo> = Ok(CopyFoo);
+    r.unwrap();
+    r.unwrap();
+
+    // test reference to ok
+    let r: Result<CopyFoo, CopyFoo> = Ok(CopyFoo);
+    fn test_ref_copy_ok(r: &Result<CopyFoo, CopyFoo>) {
+        r.unwrap();
+    }
+    test_ref_copy_ok(&r);
+    r.unwrap();
+
+    // test err
+    let r: Result<DebugFoo, Foo> = Err(Foo);
+    debug_assert!(r.is_err());
+    r.unwrap_err();
+
+    // test err with non-debug value type
+    let r: Result<Foo, Foo> = Err(Foo);
+    assert!(r.is_err());
+}
diff --git a/tests/ui/assertions_on_result_states.rs b/tests/ui/assertions_on_result_states.rs
new file mode 100644
index 00000000000..4c5af81efc2
--- /dev/null
+++ b/tests/ui/assertions_on_result_states.rs
@@ -0,0 +1,69 @@
+// run-rustfix
+#![warn(clippy::assertions_on_result_states)]
+
+use std::result::Result;
+
+struct Foo;
+
+#[derive(Debug)]
+struct DebugFoo;
+
+#[derive(Copy, Clone, Debug)]
+struct CopyFoo;
+
+macro_rules! get_ok_macro {
+    () => {
+        Ok::<_, DebugFoo>(Foo)
+    };
+}
+
+fn main() {
+    // test ok
+    let r: Result<Foo, DebugFoo> = Ok(Foo);
+    debug_assert!(r.is_ok());
+    assert!(r.is_ok());
+
+    // test ok with non-debug error type
+    let r: Result<Foo, Foo> = Ok(Foo);
+    assert!(r.is_ok());
+
+    // test temporary ok
+    fn get_ok() -> Result<Foo, DebugFoo> {
+        Ok(Foo)
+    }
+    assert!(get_ok().is_ok());
+
+    // test macro ok
+    assert!(get_ok_macro!().is_ok());
+
+    // test ok that shouldn't be moved
+    let r: Result<CopyFoo, DebugFoo> = Ok(CopyFoo);
+    fn test_ref_unmoveable_ok(r: &Result<CopyFoo, DebugFoo>) {
+        assert!(r.is_ok());
+    }
+    test_ref_unmoveable_ok(&r);
+    assert!(r.is_ok());
+    r.unwrap();
+
+    // test ok that is copied
+    let r: Result<CopyFoo, CopyFoo> = Ok(CopyFoo);
+    assert!(r.is_ok());
+    r.unwrap();
+
+    // test reference to ok
+    let r: Result<CopyFoo, CopyFoo> = Ok(CopyFoo);
+    fn test_ref_copy_ok(r: &Result<CopyFoo, CopyFoo>) {
+        assert!(r.is_ok());
+    }
+    test_ref_copy_ok(&r);
+    r.unwrap();
+
+    // test err
+    let r: Result<DebugFoo, Foo> = Err(Foo);
+    debug_assert!(r.is_err());
+    assert!(r.is_err());
+
+    // test err with non-debug value type
+    let r: Result<Foo, Foo> = Err(Foo);
+    assert!(r.is_err());
+}
diff --git a/tests/ui/assertions_on_result_states.stderr b/tests/ui/assertions_on_result_states.stderr
new file mode 100644
index 00000000000..13c2dd877a9
--- /dev/null
+++ b/tests/ui/assertions_on_result_states.stderr
@@ -0,0 +1,40 @@
+error: called `assert!` with `Result::is_ok`
+  --> $DIR/assertions_on_result_states.rs:24:5
+   |
+LL |     assert!(r.is_ok());
+   |     ^^^^^^^^^^^^^^^^^^ help: replace with: `r.unwrap()`
+   |
+   = note: `-D clippy::assertions-on-result-states` implied by `-D warnings`
+
+error: called `assert!` with `Result::is_ok`
+  --> $DIR/assertions_on_result_states.rs:34:5
+   |
+LL |     assert!(get_ok().is_ok());
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `get_ok().unwrap()`
+
+error: called `assert!` with `Result::is_ok`
+  --> $DIR/assertions_on_result_states.rs:37:5
+   |
+LL |     assert!(get_ok_macro!().is_ok());
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `get_ok_macro!().unwrap()`
+
+error: called `assert!` with `Result::is_ok`
+  --> $DIR/assertions_on_result_states.rs:50:5
+   |
+LL |     assert!(r.is_ok());
+   |     ^^^^^^^^^^^^^^^^^^ help: replace with: `r.unwrap()`
+
+error: called `assert!` with `Result::is_ok`
+  --> $DIR/assertions_on_result_states.rs:56:9
+   |
+LL |         assert!(r.is_ok());
+   |         ^^^^^^^^^^^^^^^^^^ help: replace with: `r.unwrap()`
+
+error: called `assert!` with `Result::is_err`
+  --> $DIR/assertions_on_result_states.rs:64:5
+   |
+LL |     assert!(r.is_err());
+   |     ^^^^^^^^^^^^^^^^^^^ help: replace with: `r.unwrap_err()`
+
+error: aborting due to 6 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 51cd5a866728539c1d1db81c437c474ffbef7ccf Mon Sep 17 00:00:00 2001
From: Serial <69764315+Serial-ATA@users.noreply.github.com>
Date: Thu, 14 Jul 2022 15:58:38 -0400
Subject: Add `--type` flag to `dev new_lint`

---
 clippy_dev/src/main.rs            |   9 +-
 clippy_dev/src/new_lint.rs        | 294 +++++++++++++++++++++++++++++++++-----
 clippy_dev/src/update_lints.rs    |  10 +-
 clippy_lints/src/cargo/mod.rs     |  10 +-
 clippy_lints/src/matches/mod.rs   |  20 +--
 clippy_lints/src/operators/mod.rs |  12 +-
 6 files changed, 295 insertions(+), 60 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_dev/src/main.rs b/clippy_dev/src/main.rs
index a29ba2d0c85..2008942d087 100644
--- a/clippy_dev/src/main.rs
+++ b/clippy_dev/src/main.rs
@@ -37,6 +37,7 @@ fn main() {
                 matches.get_one::<String>("pass"),
                 matches.get_one::<String>("name"),
                 matches.get_one::<String>("category"),
+                matches.get_one::<String>("type"),
                 matches.contains_id("msrv"),
             ) {
                 Ok(_) => update_lints::update(update_lints::UpdateMode::Change),
@@ -157,7 +158,8 @@ fn get_clap_config() -> ArgMatches {
                         .help("Specify whether the lint runs during the early or late pass")
                         .takes_value(true)
                         .value_parser([PossibleValue::new("early"), PossibleValue::new("late")])
-                        .required(true),
+                        .conflicts_with("type")
+                        .required_unless_present("type"),
                     Arg::new("name")
                         .short('n')
                         .long("name")
@@ -183,6 +185,11 @@ fn get_clap_config() -> ArgMatches {
                             PossibleValue::new("internal_warn"),
                         ])
                         .takes_value(true),
+                    Arg::new("type")
+                        .long("type")
+                        .help("What directory the lint belongs in")
+                        .takes_value(true)
+                        .required(false),
                     Arg::new("msrv").long("msrv").help("Add MSRV config code to the lint"),
                 ]),
             Command::new("setup")
diff --git a/clippy_dev/src/new_lint.rs b/clippy_dev/src/new_lint.rs
index 7d7e760ef44..af22cb89942 100644
--- a/clippy_dev/src/new_lint.rs
+++ b/clippy_dev/src/new_lint.rs
@@ -1,5 +1,5 @@
 use crate::clippy_project_root;
-use indoc::indoc;
+use indoc::{indoc, writedoc};
 use std::fmt::Write as _;
 use std::fs::{self, OpenOptions};
 use std::io::prelude::*;
@@ -10,6 +10,7 @@ struct LintData<'a> {
     pass: &'a str,
     name: &'a str,
     category: &'a str,
+    ty: Option<&'a str>,
     project_root: PathBuf,
 }
 
@@ -38,25 +39,35 @@ pub fn create(
     pass: Option<&String>,
     lint_name: Option<&String>,
     category: Option<&String>,
+    ty: Option<&String>,
     msrv: bool,
 ) -> io::Result<()> {
     let lint = LintData {
-        pass: pass.expect("`pass` argument is validated by clap"),
+        pass: pass.map_or("", String::as_str),
         name: lint_name.expect("`name` argument is validated by clap"),
         category: category.expect("`category` argument is validated by clap"),
+        ty: ty.map(String::as_str),
         project_root: clippy_project_root(),
     };
 
     create_lint(&lint, msrv).context("Unable to create lint implementation")?;
     create_test(&lint).context("Unable to create a test for the new lint")?;
-    add_lint(&lint, msrv).context("Unable to add lint to clippy_lints/src/lib.rs")
+
+    if lint.ty.is_none() {
+        add_lint(&lint, msrv).context("Unable to add lint to clippy_lints/src/lib.rs")?;
+    }
+
+    Ok(())
 }
 
 fn create_lint(lint: &LintData<'_>, enable_msrv: bool) -> io::Result<()> {
-    let lint_contents = get_lint_file_contents(lint, enable_msrv);
-
-    let lint_path = format!("clippy_lints/src/{}.rs", lint.name);
-    write_file(lint.project_root.join(&lint_path), lint_contents.as_bytes())
+    if let Some(ty) = lint.ty {
+        generate_from_ty(lint, enable_msrv, ty)
+    } else {
+        let lint_contents = get_lint_file_contents(lint, enable_msrv);
+        let lint_path = format!("clippy_lints/src/{}.rs", lint.name);
+        write_file(lint.project_root.join(&lint_path), lint_contents.as_bytes())
+    }
 }
 
 fn create_test(lint: &LintData<'_>) -> io::Result<()> {
@@ -204,7 +215,6 @@ fn get_lint_file_contents(lint: &LintData<'_>, enable_msrv: bool) -> String {
         },
     };
 
-    let version = get_stabilization_version();
     let lint_name = lint.name;
     let category = lint.category;
     let name_camel = to_camel_case(lint.name);
@@ -238,32 +248,7 @@ fn get_lint_file_contents(lint: &LintData<'_>, enable_msrv: bool) -> String {
         )
     });
 
-    let _ = write!(
-        result,
-        indoc! {r#"
-            declare_clippy_lint! {{
-                /// ### What it does
-                ///
-                /// ### Why is this bad?
-                ///
-                /// ### Example
-                /// ```rust
-                /// // example code where clippy issues a warning
-                /// ```
-                /// Use instead:
-                /// ```rust
-                /// // example code which does not raise clippy warning
-                /// ```
-                #[clippy::version = "{version}"]
-                pub {name_upper},
-                {category},
-                "default lint description"
-            }}
-        "#},
-        version = version,
-        name_upper = name_upper,
-        category = category,
-    );
+    let _ = write!(result, "{}", get_lint_declaration(&name_upper, category));
 
     result.push_str(&if enable_msrv {
         format!(
@@ -312,6 +297,247 @@ fn get_lint_file_contents(lint: &LintData<'_>, enable_msrv: bool) -> String {
     result
 }
 
+fn get_lint_declaration(name_upper: &str, category: &str) -> String {
+    format!(
+        indoc! {r#"
+            declare_clippy_lint! {{
+                /// ### What it does
+                ///
+                /// ### Why is this bad?
+                ///
+                /// ### Example
+                /// ```rust
+                /// // example code where clippy issues a warning
+                /// ```
+                /// Use instead:
+                /// ```rust
+                /// // example code which does not raise clippy warning
+                /// ```
+                #[clippy::version = "{version}"]
+                pub {name_upper},
+                {category},
+                "default lint description"
+            }}
+        "#},
+        version = get_stabilization_version(),
+        name_upper = name_upper,
+        category = category,
+    )
+}
+
+fn generate_from_ty(lint: &LintData<'_>, enable_msrv: bool, ty: &str) -> io::Result<()> {
+    if ty == "cargo" {
+        assert_eq!(
+            lint.category, "cargo",
+            "Lints of type `cargo` must have the `cargo` category"
+        );
+    }
+
+    let ty_dir = lint.project_root.join(format!("clippy_lints/src/{}", ty));
+    assert!(
+        ty_dir.exists() && ty_dir.is_dir(),
+        "Directory `{}` does not exist!",
+        ty_dir.display()
+    );
+
+    let lint_file_path = ty_dir.join(format!("{}.rs", lint.name));
+    assert!(
+        !lint_file_path.exists(),
+        "File `{}` already exists",
+        lint_file_path.display()
+    );
+
+    let mod_file_path = ty_dir.join("mod.rs");
+    let context_import = setup_mod_file(&mod_file_path, lint)?;
+
+    let name_upper = lint.name.to_uppercase();
+    let mut lint_file_contents = String::new();
+
+    if enable_msrv {
+        let _ = writedoc!(
+            lint_file_contents,
+            r#"
+                use clippy_utils::{{meets_msrv, msrvs}};
+                use rustc_lint::{{{context_import}, LintContext}};
+                use rustc_semver::RustcVersion;
+
+                use super::{name_upper};
+
+                // TODO: Adjust the parameters as necessary
+                pub(super) fn check(cx: &{context_import}, msrv: Option<RustcVersion>) {{
+                    if !meets_msrv(msrv, todo!("Add a new entry in `clippy_utils/src/msrvs`")) {{
+                        return;
+                    }}
+                    todo!();
+                }}
+           "#,
+            context_import = context_import,
+            name_upper = name_upper,
+        );
+    } else {
+        let _ = writedoc!(
+            lint_file_contents,
+            r#"
+                use rustc_lint::{{{context_import}, LintContext}};
+
+                use super::{name_upper};
+
+                // TODO: Adjust the parameters as necessary
+                pub(super) fn check(cx: &{context_import}) {{
+                    todo!();
+                }}
+           "#,
+            context_import = context_import,
+            name_upper = name_upper,
+        );
+    }
+
+    write_file(lint_file_path, lint_file_contents)?;
+
+    Ok(())
+}
+
+#[allow(clippy::too_many_lines)]
+fn setup_mod_file(path: &Path, lint: &LintData<'_>) -> io::Result<&'static str> {
+    use super::update_lints::{match_tokens, LintDeclSearchResult};
+    use rustc_lexer::TokenKind;
+
+    let lint_name_upper = lint.name.to_uppercase();
+
+    let mut file_contents = fs::read_to_string(path)?;
+    assert!(
+        !file_contents.contains(&lint_name_upper),
+        "Lint `{}` already defined in `{}`",
+        lint.name,
+        path.display()
+    );
+
+    let mut offset = 0usize;
+    let mut last_decl_curly_offset = None;
+    let mut lint_context = None;
+
+    let mut iter = rustc_lexer::tokenize(&file_contents).map(|t| {
+        let range = offset..offset + t.len;
+        offset = range.end;
+
+        LintDeclSearchResult {
+            token_kind: t.kind,
+            content: &file_contents[range.clone()],
+            range,
+        }
+    });
+
+    // Find both the last lint declaration (declare_clippy_lint!) and the lint pass impl
+    while let Some(LintDeclSearchResult { content, .. }) = iter.find(|result| result.token_kind == TokenKind::Ident) {
+        let mut iter = iter
+            .by_ref()
+            .filter(|t| !matches!(t.token_kind, TokenKind::Whitespace | TokenKind::LineComment { .. }));
+
+        match content {
+            "declare_clippy_lint" => {
+                // matches `!{`
+                match_tokens!(iter, Bang OpenBrace);
+                if let Some(LintDeclSearchResult { range, .. }) =
+                    iter.find(|result| result.token_kind == TokenKind::CloseBrace)
+                {
+                    last_decl_curly_offset = Some(range.end);
+                }
+            },
+            "impl" => {
+                let mut token = iter.next();
+                match token {
+                    // matches <'foo>
+                    Some(LintDeclSearchResult {
+                        token_kind: TokenKind::Lt,
+                        ..
+                    }) => {
+                        match_tokens!(iter, Lifetime { .. } Gt);
+                        token = iter.next();
+                    },
+                    None => break,
+                    _ => {},
+                }
+
+                if let Some(LintDeclSearchResult {
+                    token_kind: TokenKind::Ident,
+                    content,
+                    ..
+                }) = token
+                {
+                    // Get the appropriate lint context struct
+                    lint_context = match content {
+                        "LateLintPass" => Some("LateContext"),
+                        "EarlyLintPass" => Some("EarlyContext"),
+                        _ => continue,
+                    };
+                }
+            },
+            _ => {},
+        }
+    }
+
+    drop(iter);
+
+    let last_decl_curly_offset =
+        last_decl_curly_offset.unwrap_or_else(|| panic!("No lint declarations found in `{}`", path.display()));
+    let lint_context =
+        lint_context.unwrap_or_else(|| panic!("No lint pass implementation found in `{}`", path.display()));
+
+    // Add the lint declaration to `mod.rs`
+    file_contents.replace_range(
+        // Remove the trailing newline, which should always be present
+        last_decl_curly_offset..=last_decl_curly_offset,
+        &format!("\n\n{}", get_lint_declaration(&lint_name_upper, lint.category)),
+    );
+
+    // Add the lint to `impl_lint_pass`/`declare_lint_pass`
+    let impl_lint_pass_start = file_contents.find("impl_lint_pass!").unwrap_or_else(|| {
+        file_contents
+            .find("declare_lint_pass!")
+            .unwrap_or_else(|| panic!("failed to find `impl_lint_pass`/`declare_lint_pass`"))
+    });
+
+    let mut arr_start = file_contents[impl_lint_pass_start..].find('[').unwrap_or_else(|| {
+        panic!("malformed `impl_lint_pass`/`declare_lint_pass`");
+    });
+
+    arr_start += impl_lint_pass_start;
+
+    let mut arr_end = file_contents[arr_start..]
+        .find(']')
+        .expect("failed to find `impl_lint_pass` terminator");
+
+    arr_end += arr_start;
+
+    let mut arr_content = file_contents[arr_start + 1..arr_end].to_string();
+    arr_content.retain(|c| !c.is_whitespace());
+
+    let mut new_arr_content = String::new();
+    for ident in arr_content
+        .split(',')
+        .chain(std::iter::once(&*lint_name_upper))
+        .filter(|s| !s.is_empty())
+    {
+        let _ = write!(new_arr_content, "\n    {},", ident);
+    }
+    new_arr_content.push('\n');
+
+    file_contents.replace_range(arr_start + 1..arr_end, &new_arr_content);
+
+    // Just add the mod declaration at the top, it'll be fixed by rustfmt
+    file_contents.insert_str(0, &format!("mod {};\n", &lint.name));
+
+    let mut file = OpenOptions::new()
+        .write(true)
+        .truncate(true)
+        .open(path)
+        .context(format!("trying to open: `{}`", path.display()))?;
+    file.write_all(file_contents.as_bytes())
+        .context(format!("writing to file: `{}`", path.display()))?;
+
+    Ok(lint_context)
+}
+
 #[test]
 fn test_camel_case() {
     let s = "a_lint";
diff --git a/clippy_dev/src/update_lints.rs b/clippy_dev/src/update_lints.rs
index c089f4d8ce4..aed38bc2817 100644
--- a/clippy_dev/src/update_lints.rs
+++ b/clippy_dev/src/update_lints.rs
@@ -824,10 +824,12 @@ macro_rules! match_tokens {
     }
 }
 
-struct LintDeclSearchResult<'a> {
-    token_kind: TokenKind,
-    content: &'a str,
-    range: Range<usize>,
+pub(crate) use match_tokens;
+
+pub(crate) struct LintDeclSearchResult<'a> {
+    pub token_kind: TokenKind,
+    pub content: &'a str,
+    pub range: Range<usize>,
 }
 
 /// Parse a source file looking for `declare_clippy_lint` macro invocations.
diff --git a/clippy_lints/src/cargo/mod.rs b/clippy_lints/src/cargo/mod.rs
index abe95c6663f..9f45db86a09 100644
--- a/clippy_lints/src/cargo/mod.rs
+++ b/clippy_lints/src/cargo/mod.rs
@@ -1,3 +1,8 @@
+mod common_metadata;
+mod feature_name;
+mod multiple_crate_versions;
+mod wildcard_dependencies;
+
 use cargo_metadata::MetadataCommand;
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::is_lint_allowed;
@@ -6,11 +11,6 @@ use rustc_lint::{LateContext, LateLintPass, Lint};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::DUMMY_SP;
 
-mod common_metadata;
-mod feature_name;
-mod multiple_crate_versions;
-mod wildcard_dependencies;
-
 declare_clippy_lint! {
     /// ### What it does
     /// Checks to see if all common metadata is defined in
diff --git a/clippy_lints/src/matches/mod.rs b/clippy_lints/src/matches/mod.rs
index a3d69a4d09c..b638f271602 100644
--- a/clippy_lints/src/matches/mod.rs
+++ b/clippy_lints/src/matches/mod.rs
@@ -1,13 +1,3 @@
-use clippy_utils::source::{snippet_opt, span_starts_with, walk_span_to_context};
-use clippy_utils::{higher, in_constant, meets_msrv, msrvs};
-use rustc_hir::{Arm, Expr, ExprKind, Local, MatchSource, Pat};
-use rustc_lexer::{tokenize, TokenKind};
-use rustc_lint::{LateContext, LateLintPass, LintContext};
-use rustc_middle::lint::in_external_macro;
-use rustc_semver::RustcVersion;
-use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::{Span, SpanData, SyntaxContext};
-
 mod collapsible_match;
 mod infallible_destructuring_match;
 mod manual_map;
@@ -31,6 +21,16 @@ mod single_match;
 mod try_err;
 mod wild_in_or_pats;
 
+use clippy_utils::source::{snippet_opt, span_starts_with, walk_span_to_context};
+use clippy_utils::{higher, in_constant, meets_msrv, msrvs};
+use rustc_hir::{Arm, Expr, ExprKind, Local, MatchSource, Pat};
+use rustc_lexer::{tokenize, TokenKind};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_middle::lint::in_external_macro;
+use rustc_semver::RustcVersion;
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::{Span, SpanData, SyntaxContext};
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for matches with a single arm where an `if let`
diff --git a/clippy_lints/src/operators/mod.rs b/clippy_lints/src/operators/mod.rs
index c688d94bb52..bb6d99406b4 100644
--- a/clippy_lints/src/operators/mod.rs
+++ b/clippy_lints/src/operators/mod.rs
@@ -1,9 +1,3 @@
-use rustc_hir::{Body, Expr, ExprKind, UnOp};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
-
-pub(crate) mod arithmetic;
-
 mod absurd_extreme_comparisons;
 mod assign_op_pattern;
 mod bit_mask;
@@ -27,6 +21,12 @@ mod ptr_eq;
 mod self_assignment;
 mod verbose_bit_mask;
 
+pub(crate) mod arithmetic;
+
+use rustc_hir::{Body, Expr, ExprKind, UnOp};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for comparisons where one side of the relation is
-- 
cgit 1.4.1-3-g733a5


From 08e7ec40478203a7c1e0959461515ecdaf5754a7 Mon Sep 17 00:00:00 2001
From: Philipp Krones <hello@philkrones.com>
Date: Wed, 27 Jul 2022 17:18:20 +0100
Subject: Read and use deprecated configuration (as well as emitting a warning)

Co-authored-by: Andy Caldwell <andycaldwell@microsoft.com>
---
 clippy_lints/src/lib.rs                              | 11 ++++++++++-
 clippy_lints/src/utils/conf.rs                       | 20 ++++++++++++++------
 tests/ui-toml/conf_deprecated_key/clippy.toml        |  2 +-
 .../conf_deprecated_key/conf_deprecated_key.rs       | 10 ++++++++++
 .../conf_deprecated_key/conf_deprecated_key.stderr   | 13 +++++++++++--
 5 files changed, 46 insertions(+), 10 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 5a311163239..5bec503402c 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -487,7 +487,7 @@ pub fn read_conf(sess: &Session) -> Conf {
         },
     };
 
-    let TryConf { conf, errors } = utils::conf::read(&file_name);
+    let TryConf { conf, errors, warnings } = utils::conf::read(&file_name);
     // all conf errors are non-fatal, we just use the default conf in case of error
     for error in errors {
         sess.err(&format!(
@@ -497,6 +497,15 @@ pub fn read_conf(sess: &Session) -> Conf {
         ));
     }
 
+    for warning in warnings {
+        sess.struct_warn(&format!(
+            "error reading Clippy's configuration file `{}`: {}",
+            file_name.display(),
+            format_error(warning)
+        ))
+        .emit();
+    }
+
     conf
 }
 
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 6e033b3be2d..60f4b388761 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -68,6 +68,7 @@ pub enum DisallowedType {
 pub struct TryConf {
     pub conf: Conf,
     pub errors: Vec<Box<dyn Error>>,
+    pub warnings: Vec<Box<dyn Error>>,
 }
 
 impl TryConf {
@@ -75,6 +76,7 @@ impl TryConf {
         Self {
             conf: Conf::default(),
             errors: vec![Box::new(error)],
+            warnings: vec![],
         }
     }
 }
@@ -97,7 +99,7 @@ fn conf_error(s: String) -> Box<dyn Error> {
 macro_rules! define_Conf {
     ($(
         $(#[doc = $doc:literal])+
-        $(#[conf_deprecated($dep:literal)])?
+        $(#[conf_deprecated($dep:literal, $new_conf:ident)])?
         ($name:ident: $ty:ty = $default:expr),
     )*) => {
         /// Clippy lint configuration
@@ -137,17 +139,23 @@ macro_rules! define_Conf {
 
             fn visit_map<V>(self, mut map: V) -> Result<Self::Value, V::Error> where V: MapAccess<'de> {
                 let mut errors = Vec::new();
+                let mut warnings = Vec::new();
                 $(let mut $name = None;)*
                 // could get `Field` here directly, but get `str` first for diagnostics
                 while let Some(name) = map.next_key::<&str>()? {
                     match Field::deserialize(name.into_deserializer())? {
                         $(Field::$name => {
-                            $(errors.push(conf_error(format!("deprecated field `{}`. {}", name, $dep)));)?
+                            $(warnings.push(conf_error(format!("deprecated field `{}`. {}", name, $dep)));)?
                             match map.next_value() {
                                 Err(e) => errors.push(conf_error(e.to_string())),
                                 Ok(value) => match $name {
                                     Some(_) => errors.push(conf_error(format!("duplicate field `{}`", name))),
-                                    None => $name = Some(value),
+                                    None => {
+                                        $name = Some(value);
+                                        // $new_conf is the same as one of the defined `$name`s, so
+                                        // this variable is defined in line 2 of this function.
+                                        $($new_conf = Some(value);)?
+                                    },
                                 }
                             }
                         })*
@@ -156,7 +164,7 @@ macro_rules! define_Conf {
                     }
                 }
                 let conf = Conf { $($name: $name.unwrap_or_else(defaults::$name),)* };
-                Ok(TryConf { conf, errors })
+                Ok(TryConf { conf, errors, warnings })
             }
         }
 
@@ -216,8 +224,8 @@ define_Conf! {
     /// DEPRECATED LINT: CYCLOMATIC_COMPLEXITY.
     ///
     /// Use the Cognitive Complexity lint instead.
-    #[conf_deprecated("Please use `cognitive-complexity-threshold` instead")]
-    (cyclomatic_complexity_threshold: Option<u64> = None),
+    #[conf_deprecated("Please use `cognitive-complexity-threshold` instead", cognitive_complexity_threshold)]
+    (cyclomatic_complexity_threshold: u64 = 25),
     /// Lint: DOC_MARKDOWN.
     ///
     /// The list of words this lint should not consider as identifiers needing ticks. The value
diff --git a/tests/ui-toml/conf_deprecated_key/clippy.toml b/tests/ui-toml/conf_deprecated_key/clippy.toml
index ac47b195042..138160d7ac8 100644
--- a/tests/ui-toml/conf_deprecated_key/clippy.toml
+++ b/tests/ui-toml/conf_deprecated_key/clippy.toml
@@ -1,5 +1,5 @@
 # that one is an error
-cyclomatic-complexity-threshold = 42
+cyclomatic-complexity-threshold = 2
 
 # that one is white-listed
 [third-party]
diff --git a/tests/ui-toml/conf_deprecated_key/conf_deprecated_key.rs b/tests/ui-toml/conf_deprecated_key/conf_deprecated_key.rs
index f328e4d9d04..b4e677ea124 100644
--- a/tests/ui-toml/conf_deprecated_key/conf_deprecated_key.rs
+++ b/tests/ui-toml/conf_deprecated_key/conf_deprecated_key.rs
@@ -1 +1,11 @@
 fn main() {}
+
+#[warn(clippy::cognitive_complexity)]
+fn cognitive_complexity() {
+    let x = vec![1, 2, 3];
+    for i in x {
+        if i == 1 {
+            println!("{}", i);
+        }
+    }
+}
diff --git a/tests/ui-toml/conf_deprecated_key/conf_deprecated_key.stderr b/tests/ui-toml/conf_deprecated_key/conf_deprecated_key.stderr
index 90021a034a3..3b4c72044da 100644
--- a/tests/ui-toml/conf_deprecated_key/conf_deprecated_key.stderr
+++ b/tests/ui-toml/conf_deprecated_key/conf_deprecated_key.stderr
@@ -1,4 +1,13 @@
-error: error reading Clippy's configuration file `$DIR/clippy.toml`: deprecated field `cyclomatic-complexity-threshold`. Please use `cognitive-complexity-threshold` instead
+warning: error reading Clippy's configuration file `$DIR/clippy.toml`: deprecated field `cyclomatic-complexity-threshold`. Please use `cognitive-complexity-threshold` instead
 
-error: aborting due to previous error
+error: the function has a cognitive complexity of (3/2)
+  --> $DIR/conf_deprecated_key.rs:4:4
+   |
+LL | fn cognitive_complexity() {
+   |    ^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::cognitive-complexity` implied by `-D warnings`
+   = help: you could split it up into multiple smaller functions
+
+error: aborting due to previous error; 1 warning emitted
 
-- 
cgit 1.4.1-3-g733a5


From 307b800f27aaab6363ad5ca09009a71852f6d7cc Mon Sep 17 00:00:00 2001
From: Sosthène Guédon <sosthene@guedon.gdn>
Date: Thu, 28 Jul 2022 22:08:48 +0200
Subject: unwrap_used: Fix doc to not recommend expect when expect_used is not
 allowed

---
 clippy_lints/src/methods/mod.rs | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 202fbc1f7f6..05f20e6cb9c 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -197,13 +197,22 @@ declare_clippy_lint! {
     /// result.unwrap();
     /// ```
     ///
-    /// Use instead:
+    /// If [expect_used](#expect_used) is allowed, instead:
     /// ```rust
     /// # let option = Some(1);
     /// # let result: Result<usize, ()> = Ok(1);
     /// option.expect("more helpful message");
     /// result.expect("more helpful message");
     /// ```
+    ///
+    /// Otherwise try using
+    /// ```rust
+    /// option?;
+    ///
+    /// // or
+    ///
+    /// result?;
+    /// ```
     #[clippy::version = "1.45.0"]
     pub UNWRAP_USED,
     restriction,
-- 
cgit 1.4.1-3-g733a5


From 1fd9f2d2716689022a0473f8bce5d2f40275bd64 Mon Sep 17 00:00:00 2001
From: Sosthène Guédon <sosthene@guedon.gdn>
Date: Thu, 28 Jul 2022 22:27:50 +0200
Subject: Fix tests

---
 clippy_lints/src/methods/mod.rs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 05f20e6cb9c..06e7af57ee1 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -206,7 +206,9 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Otherwise try using
-    /// ```rust
+    /// ```rust,ignore
+    /// # let option = Some(1);
+    /// # let result: Result<usize, ()> = Ok(1);
     /// option?;
     ///
     /// // or
-- 
cgit 1.4.1-3-g733a5


From ea25ef10cf942172e09b463c305b934fabccc8e2 Mon Sep 17 00:00:00 2001
From: Andy Caldwell <andrew.caldwell@metaswitch.com>
Date: Thu, 28 Jul 2022 23:05:24 +0100
Subject: Harden duplicates checking and add tests

---
 clippy_lints/src/utils/conf.rs                       | 12 +++++++++---
 tests/ui-toml/conf_deprecated_key/clippy.toml        |  2 +-
 tests/ui-toml/duplicated_keys/clippy.toml            |  5 +++++
 tests/ui-toml/duplicated_keys/duplicated_keys.rs     |  1 +
 tests/ui-toml/duplicated_keys/duplicated_keys.stderr |  8 ++++++++
 5 files changed, 24 insertions(+), 4 deletions(-)
 create mode 100644 tests/ui-toml/duplicated_keys/clippy.toml
 create mode 100644 tests/ui-toml/duplicated_keys/duplicated_keys.rs
 create mode 100644 tests/ui-toml/duplicated_keys/duplicated_keys.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 60f4b388761..1dd22cb3185 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -92,8 +92,8 @@ impl fmt::Display for ConfError {
 
 impl Error for ConfError {}
 
-fn conf_error(s: String) -> Box<dyn Error> {
-    Box::new(ConfError(s))
+fn conf_error(s: impl Into<String>) -> Box<dyn Error> {
+    Box::new(ConfError(s.into()))
 }
 
 macro_rules! define_Conf {
@@ -154,7 +154,13 @@ macro_rules! define_Conf {
                                         $name = Some(value);
                                         // $new_conf is the same as one of the defined `$name`s, so
                                         // this variable is defined in line 2 of this function.
-                                        $($new_conf = Some(value);)?
+                                        $(match $new_conf {
+                                            Some(_) => errors.push(conf_error(concat!(
+                                                "duplicate field `", stringify!($new_conf),
+                                                "` (provided as `", stringify!($name), "`)"
+                                            ))),
+                                            None => $new_conf = Some(value),
+                                        })?
                                     },
                                 }
                             }
diff --git a/tests/ui-toml/conf_deprecated_key/clippy.toml b/tests/ui-toml/conf_deprecated_key/clippy.toml
index 138160d7ac8..30cd9eecd98 100644
--- a/tests/ui-toml/conf_deprecated_key/clippy.toml
+++ b/tests/ui-toml/conf_deprecated_key/clippy.toml
@@ -1,4 +1,4 @@
-# that one is an error
+# that one is a warning
 cyclomatic-complexity-threshold = 2
 
 # that one is white-listed
diff --git a/tests/ui-toml/duplicated_keys/clippy.toml b/tests/ui-toml/duplicated_keys/clippy.toml
new file mode 100644
index 00000000000..63a893cc6c7
--- /dev/null
+++ b/tests/ui-toml/duplicated_keys/clippy.toml
@@ -0,0 +1,5 @@
+cognitive-complexity-threshold = 2
+# This is the deprecated name for the same key
+cyclomatic-complexity-threshold = 3
+# Check we get duplication warning regardless of order
+cognitive-complexity-threshold = 4
diff --git a/tests/ui-toml/duplicated_keys/duplicated_keys.rs b/tests/ui-toml/duplicated_keys/duplicated_keys.rs
new file mode 100644
index 00000000000..f328e4d9d04
--- /dev/null
+++ b/tests/ui-toml/duplicated_keys/duplicated_keys.rs
@@ -0,0 +1 @@
+fn main() {}
diff --git a/tests/ui-toml/duplicated_keys/duplicated_keys.stderr b/tests/ui-toml/duplicated_keys/duplicated_keys.stderr
new file mode 100644
index 00000000000..d99490a242d
--- /dev/null
+++ b/tests/ui-toml/duplicated_keys/duplicated_keys.stderr
@@ -0,0 +1,8 @@
+error: error reading Clippy's configuration file `$DIR/clippy.toml`: duplicate field `cognitive_complexity_threshold` (provided as `cyclomatic_complexity_threshold`)
+
+error: error reading Clippy's configuration file `$DIR/clippy.toml`: duplicate field `cognitive-complexity-threshold`
+
+warning: error reading Clippy's configuration file `$DIR/clippy.toml`: deprecated field `cyclomatic-complexity-threshold`. Please use `cognitive-complexity-threshold` instead
+
+error: aborting due to 2 previous errors; 1 warning emitted
+
-- 
cgit 1.4.1-3-g733a5


From 2f48257cfb1732f6824fed7da10c559b01e9554e Mon Sep 17 00:00:00 2001
From: Andy Caldwell <andrew.caldwell@metaswitch.com>
Date: Wed, 8 Jun 2022 16:20:30 +0100
Subject: Rename "blacklisted name" to "disallowed name" throughout

---
 CHANGELOG.md                                       |  5 +-
 README.md                                          |  2 +-
 book/src/configuration.md                          |  2 +-
 clippy_lints/src/blacklisted_name.rs               | 77 -------------------
 clippy_lints/src/disallowed_name.rs                | 77 +++++++++++++++++++
 clippy_lints/src/lib.register_all.rs               |  2 +-
 clippy_lints/src/lib.register_lints.rs             |  2 +-
 clippy_lints/src/lib.register_style.rs             |  2 +-
 clippy_lints/src/lib.rs                            |  6 +-
 clippy_lints/src/renamed_lints.rs                  |  1 +
 clippy_lints/src/utils/conf.rs                     | 21 ++++--
 .../src/utils/internal_lints/metadata_collector.rs |  4 +-
 tests/ui-toml/bad_toml_type/clippy.toml            |  2 +-
 tests/ui-toml/bad_toml_type/conf_bad_type.stderr   |  2 +-
 .../blacklisted_names_append/blacklisted_names.rs  | 10 ---
 .../blacklisted_names.stderr                       | 16 ----
 tests/ui-toml/blacklisted_names_append/clippy.toml |  1 -
 .../blacklisted_names_replace/blacklisted_names.rs | 10 ---
 .../blacklisted_names.stderr                       | 10 ---
 .../ui-toml/blacklisted_names_replace/clippy.toml  |  1 -
 tests/ui-toml/disallowed_names_append/clippy.toml  |  1 +
 .../disallowed_names_append/disallowed_names.rs    | 10 +++
 .../disallowed_names.stderr                        | 16 ++++
 tests/ui-toml/disallowed_names_replace/clippy.toml |  1 +
 .../disallowed_names_replace/disallowed_names.rs   | 10 +++
 .../disallowed_names.stderr                        | 10 +++
 tests/ui-toml/toml_blacklist/clippy.toml           |  1 -
 .../toml_blacklist/conf_french_blacklisted_name.rs | 20 -----
 .../conf_french_blacklisted_name.stderr            | 46 -----------
 tests/ui-toml/toml_disallow/clippy.toml            |  1 +
 .../toml_disallow/conf_french_disallowed_name.rs   | 20 +++++
 .../conf_french_disallowed_name.stderr             | 46 +++++++++++
 .../toml_unknown_key/conf_unknown_key.stderr       |  1 +
 tests/ui/blacklisted_name.rs                       | 57 --------------
 tests/ui/blacklisted_name.stderr                   | 88 ----------------------
 tests/ui/borrow_box.rs                             |  2 +-
 tests/ui/box_collection.rs                         |  7 +-
 tests/ui/box_collection.stderr                     | 18 ++---
 tests/ui/crashes/ice-2760.rs                       |  7 +-
 tests/ui/crashes/ice-3462.rs                       |  2 +-
 tests/ui/crashes/regressions.rs                    |  2 +-
 tests/ui/disallowed_name.rs                        | 57 ++++++++++++++
 tests/ui/disallowed_name.stderr                    | 88 ++++++++++++++++++++++
 tests/ui/if_same_then_else.rs                      |  2 +-
 tests/ui/if_same_then_else2.rs                     |  2 +-
 tests/ui/iter_skip_next.fixed                      |  2 +-
 tests/ui/iter_skip_next.rs                         |  2 +-
 tests/ui/let_if_seq.rs                             |  2 +-
 tests/ui/manual_ok_or.fixed                        |  2 +-
 tests/ui/manual_ok_or.rs                           |  2 +-
 tests/ui/match_same_arms2.rs                       |  2 +-
 tests/ui/methods.rs                                |  2 +-
 tests/ui/mismatching_type_param_order.rs           |  2 +-
 tests/ui/mixed_read_write_in_expression.rs         |  2 +-
 tests/ui/op_ref.rs                                 |  2 +-
 tests/ui/rc_mutex.rs                               |  2 +-
 tests/ui/redundant_allocation.rs                   |  2 +-
 tests/ui/redundant_allocation_fixable.fixed        |  2 +-
 tests/ui/redundant_allocation_fixable.rs           |  2 +-
 tests/ui/rename.fixed                              |  2 +
 tests/ui/rename.rs                                 |  2 +
 tests/ui/rename.stderr                             | 78 ++++++++++---------
 tests/ui/skip_while_next.rs                        |  2 +-
 tests/ui/swap.fixed                                |  2 +-
 tests/ui/swap.rs                                   |  2 +-
 tests/ui/trivially_copy_pass_by_ref.rs             |  2 +-
 tests/ui/used_underscore_binding.rs                |  2 +-
 67 files changed, 448 insertions(+), 440 deletions(-)
 delete mode 100644 clippy_lints/src/blacklisted_name.rs
 create mode 100644 clippy_lints/src/disallowed_name.rs
 delete mode 100644 tests/ui-toml/blacklisted_names_append/blacklisted_names.rs
 delete mode 100644 tests/ui-toml/blacklisted_names_append/blacklisted_names.stderr
 delete mode 100644 tests/ui-toml/blacklisted_names_append/clippy.toml
 delete mode 100644 tests/ui-toml/blacklisted_names_replace/blacklisted_names.rs
 delete mode 100644 tests/ui-toml/blacklisted_names_replace/blacklisted_names.stderr
 delete mode 100644 tests/ui-toml/blacklisted_names_replace/clippy.toml
 create mode 100644 tests/ui-toml/disallowed_names_append/clippy.toml
 create mode 100644 tests/ui-toml/disallowed_names_append/disallowed_names.rs
 create mode 100644 tests/ui-toml/disallowed_names_append/disallowed_names.stderr
 create mode 100644 tests/ui-toml/disallowed_names_replace/clippy.toml
 create mode 100644 tests/ui-toml/disallowed_names_replace/disallowed_names.rs
 create mode 100644 tests/ui-toml/disallowed_names_replace/disallowed_names.stderr
 delete mode 100644 tests/ui-toml/toml_blacklist/clippy.toml
 delete mode 100644 tests/ui-toml/toml_blacklist/conf_french_blacklisted_name.rs
 delete mode 100644 tests/ui-toml/toml_blacklist/conf_french_blacklisted_name.stderr
 create mode 100644 tests/ui-toml/toml_disallow/clippy.toml
 create mode 100644 tests/ui-toml/toml_disallow/conf_french_disallowed_name.rs
 create mode 100644 tests/ui-toml/toml_disallow/conf_french_disallowed_name.stderr
 delete mode 100644 tests/ui/blacklisted_name.rs
 delete mode 100644 tests/ui/blacklisted_name.stderr
 create mode 100644 tests/ui/disallowed_name.rs
 create mode 100644 tests/ui/disallowed_name.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 2278a8dc16b..d3d4d5a4784 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -965,7 +965,7 @@ Released 2021-09-09
   [#7407](https://github.com/rust-lang/rust-clippy/pull/7407)
 * [`redundant_allocation`]: Now additionally supports the `Arc<>` type
   [#7308](https://github.com/rust-lang/rust-clippy/pull/7308)
-* [`blacklisted_name`]: Now allows blacklisted names in test code
+* [`disallowed_name`]: Now allows disallowed names in test code
   [#7379](https://github.com/rust-lang/rust-clippy/pull/7379)
 * [`redundant_closure`]: Suggests `&mut` for `FnMut`
   [#7437](https://github.com/rust-lang/rust-clippy/pull/7437)
@@ -2066,7 +2066,7 @@ Released 2020-08-27
   [#5692](https://github.com/rust-lang/rust-clippy/pull/5692)
 * [`if_same_then_else`]: Don't assume multiplication is always commutative
   [#5702](https://github.com/rust-lang/rust-clippy/pull/5702)
-* [`blacklisted_name`]: Remove `bar` from the default configuration
+* [`disallowed_name`]: Remove `bar` from the default configuration
   [#5712](https://github.com/rust-lang/rust-clippy/pull/5712)
 * [`redundant_pattern_matching`]: Avoid suggesting non-`const fn` calls in const contexts
   [#5724](https://github.com/rust-lang/rust-clippy/pull/5724)
@@ -3522,6 +3522,7 @@ Released 2018-09-13
 [`derive_partial_eq_without_eq`]: https://rust-lang.github.io/rust-clippy/master/index.html#derive_partial_eq_without_eq
 [`disallowed_method`]: https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_method
 [`disallowed_methods`]: https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_methods
+[`disallowed_name`]: https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_name
 [`disallowed_script_idents`]: https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_script_idents
 [`disallowed_type`]: https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_type
 [`disallowed_types`]: https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_types
diff --git a/README.md b/README.md
index 2c3defeaa83..1193771ff73 100644
--- a/README.md
+++ b/README.md
@@ -144,7 +144,7 @@ value` mapping e.g.
 
 ```toml
 avoid-breaking-exported-api = false
-blacklisted-names = ["toto", "tata", "titi"]
+disallowed-names = ["toto", "tata", "titi"]
 cognitive-complexity-threshold = 30
 ```
 
diff --git a/book/src/configuration.md b/book/src/configuration.md
index 6e295ac3181..77f1d2e8797 100644
--- a/book/src/configuration.md
+++ b/book/src/configuration.md
@@ -7,7 +7,7 @@ basic `variable = value` mapping eg.
 
 ```toml
 avoid-breaking-exported-api = false
-blacklisted-names = ["toto", "tata", "titi"]
+disallowed-names = ["toto", "tata", "titi"]
 cognitive-complexity-threshold = 30
 ```
 
diff --git a/clippy_lints/src/blacklisted_name.rs b/clippy_lints/src/blacklisted_name.rs
deleted file mode 100644
index 1600fb25d89..00000000000
--- a/clippy_lints/src/blacklisted_name.rs
+++ /dev/null
@@ -1,77 +0,0 @@
-use clippy_utils::{diagnostics::span_lint, is_test_module_or_function};
-use rustc_data_structures::fx::FxHashSet;
-use rustc_hir::{Item, Pat, PatKind};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for usage of blacklisted names for variables, such
-    /// as `foo`.
-    ///
-    /// ### Why is this bad?
-    /// These names are usually placeholder names and should be
-    /// avoided.
-    ///
-    /// ### Example
-    /// ```rust
-    /// let foo = 3.14;
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub BLACKLISTED_NAME,
-    style,
-    "usage of a blacklisted/placeholder name"
-}
-
-#[derive(Clone, Debug)]
-pub struct BlacklistedName {
-    blacklist: FxHashSet<String>,
-    test_modules_deep: u32,
-}
-
-impl BlacklistedName {
-    pub fn new(blacklist: FxHashSet<String>) -> Self {
-        Self {
-            blacklist,
-            test_modules_deep: 0,
-        }
-    }
-
-    fn in_test_module(&self) -> bool {
-        self.test_modules_deep != 0
-    }
-}
-
-impl_lint_pass!(BlacklistedName => [BLACKLISTED_NAME]);
-
-impl<'tcx> LateLintPass<'tcx> for BlacklistedName {
-    fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
-        if is_test_module_or_function(cx.tcx, item) {
-            self.test_modules_deep = self.test_modules_deep.saturating_add(1);
-        }
-    }
-
-    fn check_pat(&mut self, cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>) {
-        // Check whether we are under the `test` attribute.
-        if self.in_test_module() {
-            return;
-        }
-
-        if let PatKind::Binding(.., ident, _) = pat.kind {
-            if self.blacklist.contains(&ident.name.to_string()) {
-                span_lint(
-                    cx,
-                    BLACKLISTED_NAME,
-                    ident.span,
-                    &format!("use of a blacklisted/placeholder name `{}`", ident.name),
-                );
-            }
-        }
-    }
-
-    fn check_item_post(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
-        if is_test_module_or_function(cx.tcx, item) {
-            self.test_modules_deep = self.test_modules_deep.saturating_sub(1);
-        }
-    }
-}
diff --git a/clippy_lints/src/disallowed_name.rs b/clippy_lints/src/disallowed_name.rs
new file mode 100644
index 00000000000..98735ce7db1
--- /dev/null
+++ b/clippy_lints/src/disallowed_name.rs
@@ -0,0 +1,77 @@
+use clippy_utils::{diagnostics::span_lint, is_test_module_or_function};
+use rustc_data_structures::fx::FxHashSet;
+use rustc_hir::{Item, Pat, PatKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of disallowed names for variables, such
+    /// as `foo`.
+    ///
+    /// ### Why is this bad?
+    /// These names are usually placeholder names and should be
+    /// avoided.
+    ///
+    /// ### Example
+    /// ```rust
+    /// let foo = 3.14;
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub DISALLOWED_NAME,
+    style,
+    "usage of a disallowed/placeholder name"
+}
+
+#[derive(Clone, Debug)]
+pub struct DisallowedName {
+    disallow: FxHashSet<String>,
+    test_modules_deep: u32,
+}
+
+impl DisallowedName {
+    pub fn new(disallow: FxHashSet<String>) -> Self {
+        Self {
+            disallow,
+            test_modules_deep: 0,
+        }
+    }
+
+    fn in_test_module(&self) -> bool {
+        self.test_modules_deep != 0
+    }
+}
+
+impl_lint_pass!(DisallowedName => [DISALLOWED_NAME]);
+
+impl<'tcx> LateLintPass<'tcx> for DisallowedName {
+    fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
+        if is_test_module_or_function(cx.tcx, item) {
+            self.test_modules_deep = self.test_modules_deep.saturating_add(1);
+        }
+    }
+
+    fn check_pat(&mut self, cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>) {
+        // Check whether we are under the `test` attribute.
+        if self.in_test_module() {
+            return;
+        }
+
+        if let PatKind::Binding(.., ident, _) = pat.kind {
+            if self.disallow.contains(&ident.name.to_string()) {
+                span_lint(
+                    cx,
+                    DISALLOWED_NAME,
+                    ident.span,
+                    &format!("use of a disallowed/placeholder name `{}`", ident.name),
+                );
+            }
+        }
+    }
+
+    fn check_item_post(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
+        if is_test_module_or_function(cx.tcx, item) {
+            self.test_modules_deep = self.test_modules_deep.saturating_sub(1);
+        }
+    }
+}
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 5be1c417bf8..d8b6aa9793f 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -16,7 +16,6 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(await_holding_invalid::AWAIT_HOLDING_INVALID_TYPE),
     LintId::of(await_holding_invalid::AWAIT_HOLDING_LOCK),
     LintId::of(await_holding_invalid::AWAIT_HOLDING_REFCELL_REF),
-    LintId::of(blacklisted_name::BLACKLISTED_NAME),
     LintId::of(blocks_in_if_conditions::BLOCKS_IN_IF_CONDITIONS),
     LintId::of(bool_assert_comparison::BOOL_ASSERT_COMPARISON),
     LintId::of(booleans::LOGIC_BUG),
@@ -47,6 +46,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(derive::DERIVE_ORD_XOR_PARTIAL_ORD),
     LintId::of(derive::DERIVE_PARTIAL_EQ_WITHOUT_EQ),
     LintId::of(disallowed_methods::DISALLOWED_METHODS),
+    LintId::of(disallowed_name::DISALLOWED_NAME),
     LintId::of(disallowed_types::DISALLOWED_TYPES),
     LintId::of(doc::MISSING_SAFETY_DOC),
     LintId::of(doc::NEEDLESS_DOCTEST_MAIN),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 99bde35cf15..562c755d10f 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -55,7 +55,6 @@ store.register_lints(&[
     await_holding_invalid::AWAIT_HOLDING_INVALID_TYPE,
     await_holding_invalid::AWAIT_HOLDING_LOCK,
     await_holding_invalid::AWAIT_HOLDING_REFCELL_REF,
-    blacklisted_name::BLACKLISTED_NAME,
     blocks_in_if_conditions::BLOCKS_IN_IF_CONDITIONS,
     bool_assert_comparison::BOOL_ASSERT_COMPARISON,
     booleans::LOGIC_BUG,
@@ -116,6 +115,7 @@ store.register_lints(&[
     derive::EXPL_IMPL_CLONE_ON_COPY,
     derive::UNSAFE_DERIVE_DESERIALIZE,
     disallowed_methods::DISALLOWED_METHODS,
+    disallowed_name::DISALLOWED_NAME,
     disallowed_script_idents::DISALLOWED_SCRIPT_IDENTS,
     disallowed_types::DISALLOWED_TYPES,
     doc::DOC_MARKDOWN,
diff --git a/clippy_lints/src/lib.register_style.rs b/clippy_lints/src/lib.register_style.rs
index e029a5235e7..615a86a27e5 100644
--- a/clippy_lints/src/lib.register_style.rs
+++ b/clippy_lints/src/lib.register_style.rs
@@ -5,7 +5,6 @@
 store.register_group(true, "clippy::style", Some("clippy_style"), vec![
     LintId::of(assertions_on_constants::ASSERTIONS_ON_CONSTANTS),
     LintId::of(assertions_on_result_states::ASSERTIONS_ON_RESULT_STATES),
-    LintId::of(blacklisted_name::BLACKLISTED_NAME),
     LintId::of(blocks_in_if_conditions::BLOCKS_IN_IF_CONDITIONS),
     LintId::of(bool_assert_comparison::BOOL_ASSERT_COMPARISON),
     LintId::of(casts::FN_TO_NUMERIC_CAST),
@@ -18,6 +17,7 @@ store.register_group(true, "clippy::style", Some("clippy_style"), vec![
     LintId::of(dereference::NEEDLESS_BORROW),
     LintId::of(derive::DERIVE_PARTIAL_EQ_WITHOUT_EQ),
     LintId::of(disallowed_methods::DISALLOWED_METHODS),
+    LintId::of(disallowed_name::DISALLOWED_NAME),
     LintId::of(disallowed_types::DISALLOWED_TYPES),
     LintId::of(doc::MISSING_SAFETY_DOC),
     LintId::of(doc::NEEDLESS_DOCTEST_MAIN),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 54b0346b767..ca398038f3e 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -177,7 +177,6 @@ mod assertions_on_result_states;
 mod async_yields_async;
 mod attrs;
 mod await_holding_invalid;
-mod blacklisted_name;
 mod blocks_in_if_conditions;
 mod bool_assert_comparison;
 mod booleans;
@@ -205,6 +204,7 @@ mod dereference;
 mod derivable_impls;
 mod derive;
 mod disallowed_methods;
+mod disallowed_name;
 mod disallowed_script_idents;
 mod disallowed_types;
 mod doc;
@@ -683,8 +683,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(swap::Swap));
     store.register_late_pass(|| Box::new(overflow_check_conditional::OverflowCheckConditional));
     store.register_late_pass(|| Box::new(new_without_default::NewWithoutDefault::default()));
-    let blacklisted_names = conf.blacklisted_names.iter().cloned().collect::<FxHashSet<_>>();
-    store.register_late_pass(move || Box::new(blacklisted_name::BlacklistedName::new(blacklisted_names.clone())));
+    let disallowed_names = conf.disallowed_names.iter().cloned().collect::<FxHashSet<_>>();
+    store.register_late_pass(move || Box::new(disallowed_name::DisallowedName::new(disallowed_names.clone())));
     let too_many_arguments_threshold = conf.too_many_arguments_threshold;
     let too_many_lines_threshold = conf.too_many_lines_threshold;
     store.register_late_pass(move || {
diff --git a/clippy_lints/src/renamed_lints.rs b/clippy_lints/src/renamed_lints.rs
index ba03ef93721..f06af29e1e2 100644
--- a/clippy_lints/src/renamed_lints.rs
+++ b/clippy_lints/src/renamed_lints.rs
@@ -5,6 +5,7 @@ pub static RENAMED_LINTS: &[(&str, &str)] = &[
     ("clippy::block_in_if_condition_expr", "clippy::blocks_in_if_conditions"),
     ("clippy::block_in_if_condition_stmt", "clippy::blocks_in_if_conditions"),
     ("clippy::box_vec", "clippy::box_collection"),
+    ("clippy::blacklisted_name", "clippy::disallowed_name"),
     ("clippy::const_static_lifetime", "clippy::redundant_static_lifetimes"),
     ("clippy::cyclomatic_complexity", "clippy::cognitive_complexity"),
     ("clippy::disallowed_method", "clippy::disallowed_methods"),
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 1dd22cb3185..5a3fe7f8966 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -30,7 +30,7 @@ const DEFAULT_DOC_VALID_IDENTS: &[&str] = &[
     "MinGW",
     "CamelCase",
 ];
-const DEFAULT_BLACKLISTED_NAMES: &[&str] = &["foo", "baz", "quux"];
+const DEFAULT_DISALLOWED_NAMES: &[&str] = &["foo", "baz", "quux"];
 
 /// Holds information used by `MISSING_ENFORCED_IMPORT_RENAMES` lint.
 #[derive(Clone, Debug, Deserialize)]
@@ -159,7 +159,7 @@ macro_rules! define_Conf {
                                                 "duplicate field `", stringify!($new_conf),
                                                 "` (provided as `", stringify!($name), "`)"
                                             ))),
-                                            None => $new_conf = Some(value),
+                                            None => $new_conf = $name.clone(),
                                         })?
                                     },
                                 }
@@ -217,12 +217,11 @@ define_Conf! {
     ///
     /// The minimum rust version that the project supports
     (msrv: Option<String> = None),
-    /// Lint: BLACKLISTED_NAME.
+    /// DEPRECATED LINT: BLACKLISTED_NAME.
     ///
-    /// The list of blacklisted names to lint about. NB: `bar` is not here since it has legitimate uses. The value
-    /// `".."` can be used as part of the list to indicate, that the configured values should be appended to the
-    /// default configuration of Clippy. By default any configuraction will replace the default value.
-    (blacklisted_names: Vec<String> = super::DEFAULT_BLACKLISTED_NAMES.iter().map(ToString::to_string).collect()),
+    /// Use the Disallowed Names lint instead
+    #[conf_deprecated("Please use `disallowed-names` instead", disallowed_names)]
+    (blacklisted_names: Vec<String> = Vec::new()),
     /// Lint: COGNITIVE_COMPLEXITY.
     ///
     /// The maximum cognitive complexity a function can have
@@ -232,6 +231,12 @@ define_Conf! {
     /// Use the Cognitive Complexity lint instead.
     #[conf_deprecated("Please use `cognitive-complexity-threshold` instead", cognitive_complexity_threshold)]
     (cyclomatic_complexity_threshold: u64 = 25),
+    /// Lint: DISALLOWED_NAME.
+    ///
+    /// The list of disallowed names to lint about. NB: `bar` is not here since it has legitimate uses. The value
+    /// `".."` can be used as part of the list to indicate, that the configured values should be appended to the
+    /// default configuration of Clippy. By default any configuration will replace the default value.
+    (disallowed_names: Vec<String> = super::DEFAULT_DISALLOWED_NAMES.iter().map(ToString::to_string).collect()),
     /// Lint: DOC_MARKDOWN.
     ///
     /// The list of words this lint should not consider as identifiers needing ticks. The value
@@ -434,7 +439,7 @@ pub fn read(path: &Path) -> TryConf {
     match toml::from_str::<TryConf>(&content) {
         Ok(mut conf) => {
             extend_vec_if_indicator_present(&mut conf.conf.doc_valid_idents, DEFAULT_DOC_VALID_IDENTS);
-            extend_vec_if_indicator_present(&mut conf.conf.blacklisted_names, DEFAULT_BLACKLISTED_NAMES);
+            extend_vec_if_indicator_present(&mut conf.conf.disallowed_names, DEFAULT_DISALLOWED_NAMES);
 
             conf
         },
diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index 92934c16d4b..92cf42c7ad4 100644
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -619,7 +619,7 @@ impl<'hir> LateLintPass<'hir> for MetadataCollector {
             if_chain! {
                 // item validation
                 if is_lint_ref_type(cx, ty);
-                // blacklist check
+                // disallow check
                 let lint_name = sym_to_string(item.ident.name).to_ascii_lowercase();
                 if !BLACK_LISTED_LINTS.contains(&lint_name.as_str());
                 // metadata extraction
@@ -644,7 +644,7 @@ impl<'hir> LateLintPass<'hir> for MetadataCollector {
 
             if_chain! {
                 if is_deprecated_lint(cx, ty);
-                // blacklist check
+                // disallow check
                 let lint_name = sym_to_string(item.ident.name).to_ascii_lowercase();
                 if !BLACK_LISTED_LINTS.contains(&lint_name.as_str());
                 // Metadata the little we can get from a deprecated lint
diff --git a/tests/ui-toml/bad_toml_type/clippy.toml b/tests/ui-toml/bad_toml_type/clippy.toml
index 168675394d7..d48bab08f69 100644
--- a/tests/ui-toml/bad_toml_type/clippy.toml
+++ b/tests/ui-toml/bad_toml_type/clippy.toml
@@ -1 +1 @@
-blacklisted-names = 42
+disallowed-names = 42
diff --git a/tests/ui-toml/bad_toml_type/conf_bad_type.stderr b/tests/ui-toml/bad_toml_type/conf_bad_type.stderr
index c7bc261de6c..e3ec6019204 100644
--- a/tests/ui-toml/bad_toml_type/conf_bad_type.stderr
+++ b/tests/ui-toml/bad_toml_type/conf_bad_type.stderr
@@ -1,4 +1,4 @@
-error: error reading Clippy's configuration file `$DIR/clippy.toml`: invalid type: integer `42`, expected a sequence for key `blacklisted-names`
+error: error reading Clippy's configuration file `$DIR/clippy.toml`: invalid type: integer `42`, expected a sequence for key `disallowed-names`
 
 error: aborting due to previous error
 
diff --git a/tests/ui-toml/blacklisted_names_append/blacklisted_names.rs b/tests/ui-toml/blacklisted_names_append/blacklisted_names.rs
deleted file mode 100644
index fb2395cf90b..00000000000
--- a/tests/ui-toml/blacklisted_names_append/blacklisted_names.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-#[warn(clippy::blacklisted_name)]
-
-fn main() {
-    // `foo` is part of the default configuration
-    let foo = "bar";
-    // `ducks` was unrightfully blacklisted
-    let ducks = ["quack", "quack"];
-    // `fox` is okay
-    let fox = ["what", "does", "the", "fox", "say", "?"];
-}
diff --git a/tests/ui-toml/blacklisted_names_append/blacklisted_names.stderr b/tests/ui-toml/blacklisted_names_append/blacklisted_names.stderr
deleted file mode 100644
index 9169bb0e866..00000000000
--- a/tests/ui-toml/blacklisted_names_append/blacklisted_names.stderr
+++ /dev/null
@@ -1,16 +0,0 @@
-error: use of a blacklisted/placeholder name `foo`
-  --> $DIR/blacklisted_names.rs:5:9
-   |
-LL |     let foo = "bar";
-   |         ^^^
-   |
-   = note: `-D clippy::blacklisted-name` implied by `-D warnings`
-
-error: use of a blacklisted/placeholder name `ducks`
-  --> $DIR/blacklisted_names.rs:7:9
-   |
-LL |     let ducks = ["quack", "quack"];
-   |         ^^^^^
-
-error: aborting due to 2 previous errors
-
diff --git a/tests/ui-toml/blacklisted_names_append/clippy.toml b/tests/ui-toml/blacklisted_names_append/clippy.toml
deleted file mode 100644
index 0e052ef50f0..00000000000
--- a/tests/ui-toml/blacklisted_names_append/clippy.toml
+++ /dev/null
@@ -1 +0,0 @@
-blacklisted-names = ["ducks", ".."]
diff --git a/tests/ui-toml/blacklisted_names_replace/blacklisted_names.rs b/tests/ui-toml/blacklisted_names_replace/blacklisted_names.rs
deleted file mode 100644
index fb2395cf90b..00000000000
--- a/tests/ui-toml/blacklisted_names_replace/blacklisted_names.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-#[warn(clippy::blacklisted_name)]
-
-fn main() {
-    // `foo` is part of the default configuration
-    let foo = "bar";
-    // `ducks` was unrightfully blacklisted
-    let ducks = ["quack", "quack"];
-    // `fox` is okay
-    let fox = ["what", "does", "the", "fox", "say", "?"];
-}
diff --git a/tests/ui-toml/blacklisted_names_replace/blacklisted_names.stderr b/tests/ui-toml/blacklisted_names_replace/blacklisted_names.stderr
deleted file mode 100644
index ec6f7f084f2..00000000000
--- a/tests/ui-toml/blacklisted_names_replace/blacklisted_names.stderr
+++ /dev/null
@@ -1,10 +0,0 @@
-error: use of a blacklisted/placeholder name `ducks`
-  --> $DIR/blacklisted_names.rs:7:9
-   |
-LL |     let ducks = ["quack", "quack"];
-   |         ^^^^^
-   |
-   = note: `-D clippy::blacklisted-name` implied by `-D warnings`
-
-error: aborting due to previous error
-
diff --git a/tests/ui-toml/blacklisted_names_replace/clippy.toml b/tests/ui-toml/blacklisted_names_replace/clippy.toml
deleted file mode 100644
index 4582f1c0667..00000000000
--- a/tests/ui-toml/blacklisted_names_replace/clippy.toml
+++ /dev/null
@@ -1 +0,0 @@
-blacklisted-names = ["ducks"]
diff --git a/tests/ui-toml/disallowed_names_append/clippy.toml b/tests/ui-toml/disallowed_names_append/clippy.toml
new file mode 100644
index 00000000000..6df96a3c214
--- /dev/null
+++ b/tests/ui-toml/disallowed_names_append/clippy.toml
@@ -0,0 +1 @@
+disallowed-names = ["ducks", ".."]
diff --git a/tests/ui-toml/disallowed_names_append/disallowed_names.rs b/tests/ui-toml/disallowed_names_append/disallowed_names.rs
new file mode 100644
index 00000000000..939d48cb677
--- /dev/null
+++ b/tests/ui-toml/disallowed_names_append/disallowed_names.rs
@@ -0,0 +1,10 @@
+#[warn(clippy::disallowed_name)]
+
+fn main() {
+    // `foo` is part of the default configuration
+    let foo = "bar";
+    // `ducks` was unrightfully disallowed
+    let ducks = ["quack", "quack"];
+    // `fox` is okay
+    let fox = ["what", "does", "the", "fox", "say", "?"];
+}
diff --git a/tests/ui-toml/disallowed_names_append/disallowed_names.stderr b/tests/ui-toml/disallowed_names_append/disallowed_names.stderr
new file mode 100644
index 00000000000..d59872b0cb3
--- /dev/null
+++ b/tests/ui-toml/disallowed_names_append/disallowed_names.stderr
@@ -0,0 +1,16 @@
+error: use of a disallowed/placeholder name `foo`
+  --> $DIR/disallowed_names.rs:5:9
+   |
+LL |     let foo = "bar";
+   |         ^^^
+   |
+   = note: `-D clippy::disallowed-name` implied by `-D warnings`
+
+error: use of a disallowed/placeholder name `ducks`
+  --> $DIR/disallowed_names.rs:7:9
+   |
+LL |     let ducks = ["quack", "quack"];
+   |         ^^^^^
+
+error: aborting due to 2 previous errors
+
diff --git a/tests/ui-toml/disallowed_names_replace/clippy.toml b/tests/ui-toml/disallowed_names_replace/clippy.toml
new file mode 100644
index 00000000000..a1c515652d3
--- /dev/null
+++ b/tests/ui-toml/disallowed_names_replace/clippy.toml
@@ -0,0 +1 @@
+disallowed-names = ["ducks"]
diff --git a/tests/ui-toml/disallowed_names_replace/disallowed_names.rs b/tests/ui-toml/disallowed_names_replace/disallowed_names.rs
new file mode 100644
index 00000000000..939d48cb677
--- /dev/null
+++ b/tests/ui-toml/disallowed_names_replace/disallowed_names.rs
@@ -0,0 +1,10 @@
+#[warn(clippy::disallowed_name)]
+
+fn main() {
+    // `foo` is part of the default configuration
+    let foo = "bar";
+    // `ducks` was unrightfully disallowed
+    let ducks = ["quack", "quack"];
+    // `fox` is okay
+    let fox = ["what", "does", "the", "fox", "say", "?"];
+}
diff --git a/tests/ui-toml/disallowed_names_replace/disallowed_names.stderr b/tests/ui-toml/disallowed_names_replace/disallowed_names.stderr
new file mode 100644
index 00000000000..26f98bbb82d
--- /dev/null
+++ b/tests/ui-toml/disallowed_names_replace/disallowed_names.stderr
@@ -0,0 +1,10 @@
+error: use of a disallowed/placeholder name `ducks`
+  --> $DIR/disallowed_names.rs:7:9
+   |
+LL |     let ducks = ["quack", "quack"];
+   |         ^^^^^
+   |
+   = note: `-D clippy::disallowed-name` implied by `-D warnings`
+
+error: aborting due to previous error
+
diff --git a/tests/ui-toml/toml_blacklist/clippy.toml b/tests/ui-toml/toml_blacklist/clippy.toml
deleted file mode 100644
index 6abe5a3bbc2..00000000000
--- a/tests/ui-toml/toml_blacklist/clippy.toml
+++ /dev/null
@@ -1 +0,0 @@
-blacklisted-names = ["toto", "tata", "titi"]
diff --git a/tests/ui-toml/toml_blacklist/conf_french_blacklisted_name.rs b/tests/ui-toml/toml_blacklist/conf_french_blacklisted_name.rs
deleted file mode 100644
index cb35d0e8589..00000000000
--- a/tests/ui-toml/toml_blacklist/conf_french_blacklisted_name.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-#![allow(dead_code)]
-#![allow(clippy::single_match)]
-#![allow(unused_variables)]
-#![warn(clippy::blacklisted_name)]
-
-fn test(toto: ()) {}
-
-fn main() {
-    let toto = 42;
-    let tata = 42;
-    let titi = 42;
-
-    let tatab = 42;
-    let tatatataic = 42;
-
-    match (42, Some(1337), Some(0)) {
-        (toto, Some(tata), titi @ Some(_)) => (),
-        _ => (),
-    }
-}
diff --git a/tests/ui-toml/toml_blacklist/conf_french_blacklisted_name.stderr b/tests/ui-toml/toml_blacklist/conf_french_blacklisted_name.stderr
deleted file mode 100644
index 84ba77851f7..00000000000
--- a/tests/ui-toml/toml_blacklist/conf_french_blacklisted_name.stderr
+++ /dev/null
@@ -1,46 +0,0 @@
-error: use of a blacklisted/placeholder name `toto`
-  --> $DIR/conf_french_blacklisted_name.rs:6:9
-   |
-LL | fn test(toto: ()) {}
-   |         ^^^^
-   |
-   = note: `-D clippy::blacklisted-name` implied by `-D warnings`
-
-error: use of a blacklisted/placeholder name `toto`
-  --> $DIR/conf_french_blacklisted_name.rs:9:9
-   |
-LL |     let toto = 42;
-   |         ^^^^
-
-error: use of a blacklisted/placeholder name `tata`
-  --> $DIR/conf_french_blacklisted_name.rs:10:9
-   |
-LL |     let tata = 42;
-   |         ^^^^
-
-error: use of a blacklisted/placeholder name `titi`
-  --> $DIR/conf_french_blacklisted_name.rs:11:9
-   |
-LL |     let titi = 42;
-   |         ^^^^
-
-error: use of a blacklisted/placeholder name `toto`
-  --> $DIR/conf_french_blacklisted_name.rs:17:10
-   |
-LL |         (toto, Some(tata), titi @ Some(_)) => (),
-   |          ^^^^
-
-error: use of a blacklisted/placeholder name `tata`
-  --> $DIR/conf_french_blacklisted_name.rs:17:21
-   |
-LL |         (toto, Some(tata), titi @ Some(_)) => (),
-   |                     ^^^^
-
-error: use of a blacklisted/placeholder name `titi`
-  --> $DIR/conf_french_blacklisted_name.rs:17:28
-   |
-LL |         (toto, Some(tata), titi @ Some(_)) => (),
-   |                            ^^^^
-
-error: aborting due to 7 previous errors
-
diff --git a/tests/ui-toml/toml_disallow/clippy.toml b/tests/ui-toml/toml_disallow/clippy.toml
new file mode 100644
index 00000000000..e4f0cb6df57
--- /dev/null
+++ b/tests/ui-toml/toml_disallow/clippy.toml
@@ -0,0 +1 @@
+disallowed-names = ["toto", "tata", "titi"]
diff --git a/tests/ui-toml/toml_disallow/conf_french_disallowed_name.rs b/tests/ui-toml/toml_disallow/conf_french_disallowed_name.rs
new file mode 100644
index 00000000000..897daee0fa6
--- /dev/null
+++ b/tests/ui-toml/toml_disallow/conf_french_disallowed_name.rs
@@ -0,0 +1,20 @@
+#![allow(dead_code)]
+#![allow(clippy::single_match)]
+#![allow(unused_variables)]
+#![warn(clippy::disallowed_name)]
+
+fn test(toto: ()) {}
+
+fn main() {
+    let toto = 42;
+    let tata = 42;
+    let titi = 42;
+
+    let tatab = 42;
+    let tatatataic = 42;
+
+    match (42, Some(1337), Some(0)) {
+        (toto, Some(tata), titi @ Some(_)) => (),
+        _ => (),
+    }
+}
diff --git a/tests/ui-toml/toml_disallow/conf_french_disallowed_name.stderr b/tests/ui-toml/toml_disallow/conf_french_disallowed_name.stderr
new file mode 100644
index 00000000000..b9a15043f2d
--- /dev/null
+++ b/tests/ui-toml/toml_disallow/conf_french_disallowed_name.stderr
@@ -0,0 +1,46 @@
+error: use of a disallowed/placeholder name `toto`
+  --> $DIR/conf_french_disallowed_name.rs:6:9
+   |
+LL | fn test(toto: ()) {}
+   |         ^^^^
+   |
+   = note: `-D clippy::disallowed-name` implied by `-D warnings`
+
+error: use of a disallowed/placeholder name `toto`
+  --> $DIR/conf_french_disallowed_name.rs:9:9
+   |
+LL |     let toto = 42;
+   |         ^^^^
+
+error: use of a disallowed/placeholder name `tata`
+  --> $DIR/conf_french_disallowed_name.rs:10:9
+   |
+LL |     let tata = 42;
+   |         ^^^^
+
+error: use of a disallowed/placeholder name `titi`
+  --> $DIR/conf_french_disallowed_name.rs:11:9
+   |
+LL |     let titi = 42;
+   |         ^^^^
+
+error: use of a disallowed/placeholder name `toto`
+  --> $DIR/conf_french_disallowed_name.rs:17:10
+   |
+LL |         (toto, Some(tata), titi @ Some(_)) => (),
+   |          ^^^^
+
+error: use of a disallowed/placeholder name `tata`
+  --> $DIR/conf_french_disallowed_name.rs:17:21
+   |
+LL |         (toto, Some(tata), titi @ Some(_)) => (),
+   |                     ^^^^
+
+error: use of a disallowed/placeholder name `titi`
+  --> $DIR/conf_french_disallowed_name.rs:17:28
+   |
+LL |         (toto, Some(tata), titi @ Some(_)) => (),
+   |                            ^^^^
+
+error: aborting due to 7 previous errors
+
diff --git a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
index fe5139c4768..9f8e778b3b9 100644
--- a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
+++ b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
@@ -12,6 +12,7 @@ error: error reading Clippy's configuration file `$DIR/clippy.toml`: unknown fie
            cognitive-complexity-threshold
            cyclomatic-complexity-threshold
            disallowed-methods
+           disallowed-names
            disallowed-types
            doc-valid-idents
            enable-raw-pointer-heuristic-for-send
diff --git a/tests/ui/blacklisted_name.rs b/tests/ui/blacklisted_name.rs
deleted file mode 100644
index 27df732a088..00000000000
--- a/tests/ui/blacklisted_name.rs
+++ /dev/null
@@ -1,57 +0,0 @@
-#![allow(
-    dead_code,
-    clippy::similar_names,
-    clippy::single_match,
-    clippy::toplevel_ref_arg,
-    unused_mut,
-    unused_variables
-)]
-#![warn(clippy::blacklisted_name)]
-
-fn test(foo: ()) {}
-
-fn main() {
-    let foo = 42;
-    let baz = 42;
-    let quux = 42;
-    // Unlike these others, `bar` is actually considered an acceptable name.
-    // Among many other legitimate uses, bar commonly refers to a period of time in music.
-    // See https://github.com/rust-lang/rust-clippy/issues/5225.
-    let bar = 42;
-
-    let food = 42;
-    let foodstuffs = 42;
-    let bazaar = 42;
-
-    match (42, Some(1337), Some(0)) {
-        (foo, Some(baz), quux @ Some(_)) => (),
-        _ => (),
-    }
-}
-
-fn issue_1647(mut foo: u8) {
-    let mut baz = 0;
-    if let Some(mut quux) = Some(42) {}
-}
-
-fn issue_1647_ref() {
-    let ref baz = 0;
-    if let Some(ref quux) = Some(42) {}
-}
-
-fn issue_1647_ref_mut() {
-    let ref mut baz = 0;
-    if let Some(ref mut quux) = Some(42) {}
-}
-
-mod tests {
-    fn issue_7305() {
-        // `blacklisted_name` lint should not be triggered inside of the test code.
-        let foo = 0;
-
-        // Check that even in nested functions warning is still not triggered.
-        fn nested() {
-            let foo = 0;
-        }
-    }
-}
diff --git a/tests/ui/blacklisted_name.stderr b/tests/ui/blacklisted_name.stderr
deleted file mode 100644
index 70dbdaece8b..00000000000
--- a/tests/ui/blacklisted_name.stderr
+++ /dev/null
@@ -1,88 +0,0 @@
-error: use of a blacklisted/placeholder name `foo`
-  --> $DIR/blacklisted_name.rs:11:9
-   |
-LL | fn test(foo: ()) {}
-   |         ^^^
-   |
-   = note: `-D clippy::blacklisted-name` implied by `-D warnings`
-
-error: use of a blacklisted/placeholder name `foo`
-  --> $DIR/blacklisted_name.rs:14:9
-   |
-LL |     let foo = 42;
-   |         ^^^
-
-error: use of a blacklisted/placeholder name `baz`
-  --> $DIR/blacklisted_name.rs:15:9
-   |
-LL |     let baz = 42;
-   |         ^^^
-
-error: use of a blacklisted/placeholder name `quux`
-  --> $DIR/blacklisted_name.rs:16:9
-   |
-LL |     let quux = 42;
-   |         ^^^^
-
-error: use of a blacklisted/placeholder name `foo`
-  --> $DIR/blacklisted_name.rs:27:10
-   |
-LL |         (foo, Some(baz), quux @ Some(_)) => (),
-   |          ^^^
-
-error: use of a blacklisted/placeholder name `baz`
-  --> $DIR/blacklisted_name.rs:27:20
-   |
-LL |         (foo, Some(baz), quux @ Some(_)) => (),
-   |                    ^^^
-
-error: use of a blacklisted/placeholder name `quux`
-  --> $DIR/blacklisted_name.rs:27:26
-   |
-LL |         (foo, Some(baz), quux @ Some(_)) => (),
-   |                          ^^^^
-
-error: use of a blacklisted/placeholder name `foo`
-  --> $DIR/blacklisted_name.rs:32:19
-   |
-LL | fn issue_1647(mut foo: u8) {
-   |                   ^^^
-
-error: use of a blacklisted/placeholder name `baz`
-  --> $DIR/blacklisted_name.rs:33:13
-   |
-LL |     let mut baz = 0;
-   |             ^^^
-
-error: use of a blacklisted/placeholder name `quux`
-  --> $DIR/blacklisted_name.rs:34:21
-   |
-LL |     if let Some(mut quux) = Some(42) {}
-   |                     ^^^^
-
-error: use of a blacklisted/placeholder name `baz`
-  --> $DIR/blacklisted_name.rs:38:13
-   |
-LL |     let ref baz = 0;
-   |             ^^^
-
-error: use of a blacklisted/placeholder name `quux`
-  --> $DIR/blacklisted_name.rs:39:21
-   |
-LL |     if let Some(ref quux) = Some(42) {}
-   |                     ^^^^
-
-error: use of a blacklisted/placeholder name `baz`
-  --> $DIR/blacklisted_name.rs:43:17
-   |
-LL |     let ref mut baz = 0;
-   |                 ^^^
-
-error: use of a blacklisted/placeholder name `quux`
-  --> $DIR/blacklisted_name.rs:44:25
-   |
-LL |     if let Some(ref mut quux) = Some(42) {}
-   |                         ^^^^
-
-error: aborting due to 14 previous errors
-
diff --git a/tests/ui/borrow_box.rs b/tests/ui/borrow_box.rs
index b606f773cfb..2a4f8b53e8b 100644
--- a/tests/ui/borrow_box.rs
+++ b/tests/ui/borrow_box.rs
@@ -1,5 +1,5 @@
 #![deny(clippy::borrowed_box)]
-#![allow(clippy::blacklisted_name)]
+#![allow(clippy::disallowed_name)]
 #![allow(unused_variables)]
 #![allow(dead_code)]
 
diff --git a/tests/ui/box_collection.rs b/tests/ui/box_collection.rs
index 1a74cdb3ff6..690ed905cdd 100644
--- a/tests/ui/box_collection.rs
+++ b/tests/ui/box_collection.rs
@@ -1,10 +1,5 @@
 #![warn(clippy::all)]
-#![allow(
-    clippy::boxed_local,
-    clippy::needless_pass_by_value,
-    clippy::blacklisted_name,
-    unused
-)]
+#![allow(clippy::boxed_local, clippy::needless_pass_by_value, clippy::disallowed_name, unused)]
 
 use std::collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, LinkedList, VecDeque};
 
diff --git a/tests/ui/box_collection.stderr b/tests/ui/box_collection.stderr
index 2b28598ded9..4a559e616d1 100644
--- a/tests/ui/box_collection.stderr
+++ b/tests/ui/box_collection.stderr
@@ -1,5 +1,5 @@
 error: you seem to be trying to use `Box<Vec<..>>`. Consider using just `Vec<..>`
-  --> $DIR/box_collection.rs:21:15
+  --> $DIR/box_collection.rs:16:15
    |
 LL | fn test1(foo: Box<Vec<bool>>) {}
    |               ^^^^^^^^^^^^^^
@@ -8,7 +8,7 @@ LL | fn test1(foo: Box<Vec<bool>>) {}
    = help: `Vec<..>` is already on the heap, `Box<Vec<..>>` makes an extra allocation
 
 error: you seem to be trying to use `Box<String>`. Consider using just `String`
-  --> $DIR/box_collection.rs:28:15
+  --> $DIR/box_collection.rs:23:15
    |
 LL | fn test3(foo: Box<String>) {}
    |               ^^^^^^^^^^^
@@ -16,7 +16,7 @@ LL | fn test3(foo: Box<String>) {}
    = help: `String` is already on the heap, `Box<String>` makes an extra allocation
 
 error: you seem to be trying to use `Box<HashMap<..>>`. Consider using just `HashMap<..>`
-  --> $DIR/box_collection.rs:30:15
+  --> $DIR/box_collection.rs:25:15
    |
 LL | fn test4(foo: Box<HashMap<String, String>>) {}
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -24,7 +24,7 @@ LL | fn test4(foo: Box<HashMap<String, String>>) {}
    = help: `HashMap<..>` is already on the heap, `Box<HashMap<..>>` makes an extra allocation
 
 error: you seem to be trying to use `Box<HashSet<..>>`. Consider using just `HashSet<..>`
-  --> $DIR/box_collection.rs:32:15
+  --> $DIR/box_collection.rs:27:15
    |
 LL | fn test5(foo: Box<HashSet<i64>>) {}
    |               ^^^^^^^^^^^^^^^^^
@@ -32,7 +32,7 @@ LL | fn test5(foo: Box<HashSet<i64>>) {}
    = help: `HashSet<..>` is already on the heap, `Box<HashSet<..>>` makes an extra allocation
 
 error: you seem to be trying to use `Box<VecDeque<..>>`. Consider using just `VecDeque<..>`
-  --> $DIR/box_collection.rs:34:15
+  --> $DIR/box_collection.rs:29:15
    |
 LL | fn test6(foo: Box<VecDeque<i32>>) {}
    |               ^^^^^^^^^^^^^^^^^^
@@ -40,7 +40,7 @@ LL | fn test6(foo: Box<VecDeque<i32>>) {}
    = help: `VecDeque<..>` is already on the heap, `Box<VecDeque<..>>` makes an extra allocation
 
 error: you seem to be trying to use `Box<LinkedList<..>>`. Consider using just `LinkedList<..>`
-  --> $DIR/box_collection.rs:36:15
+  --> $DIR/box_collection.rs:31:15
    |
 LL | fn test7(foo: Box<LinkedList<i16>>) {}
    |               ^^^^^^^^^^^^^^^^^^^^
@@ -48,7 +48,7 @@ LL | fn test7(foo: Box<LinkedList<i16>>) {}
    = help: `LinkedList<..>` is already on the heap, `Box<LinkedList<..>>` makes an extra allocation
 
 error: you seem to be trying to use `Box<BTreeMap<..>>`. Consider using just `BTreeMap<..>`
-  --> $DIR/box_collection.rs:38:15
+  --> $DIR/box_collection.rs:33:15
    |
 LL | fn test8(foo: Box<BTreeMap<i8, String>>) {}
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -56,7 +56,7 @@ LL | fn test8(foo: Box<BTreeMap<i8, String>>) {}
    = help: `BTreeMap<..>` is already on the heap, `Box<BTreeMap<..>>` makes an extra allocation
 
 error: you seem to be trying to use `Box<BTreeSet<..>>`. Consider using just `BTreeSet<..>`
-  --> $DIR/box_collection.rs:40:15
+  --> $DIR/box_collection.rs:35:15
    |
 LL | fn test9(foo: Box<BTreeSet<u64>>) {}
    |               ^^^^^^^^^^^^^^^^^^
@@ -64,7 +64,7 @@ LL | fn test9(foo: Box<BTreeSet<u64>>) {}
    = help: `BTreeSet<..>` is already on the heap, `Box<BTreeSet<..>>` makes an extra allocation
 
 error: you seem to be trying to use `Box<BinaryHeap<..>>`. Consider using just `BinaryHeap<..>`
-  --> $DIR/box_collection.rs:42:16
+  --> $DIR/box_collection.rs:37:16
    |
 LL | fn test10(foo: Box<BinaryHeap<u32>>) {}
    |                ^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/crashes/ice-2760.rs b/tests/ui/crashes/ice-2760.rs
index f1a229f3f4f..4504d311385 100644
--- a/tests/ui/crashes/ice-2760.rs
+++ b/tests/ui/crashes/ice-2760.rs
@@ -1,9 +1,4 @@
-#![allow(
-    unused_variables,
-    clippy::blacklisted_name,
-    clippy::needless_pass_by_value,
-    dead_code
-)]
+#![allow(unused_variables, clippy::disallowed_name, clippy::needless_pass_by_value, dead_code)]
 
 /// This should not compile-fail with:
 ///
diff --git a/tests/ui/crashes/ice-3462.rs b/tests/ui/crashes/ice-3462.rs
index 02c49aa0d7c..a7d9017bc68 100644
--- a/tests/ui/crashes/ice-3462.rs
+++ b/tests/ui/crashes/ice-3462.rs
@@ -1,5 +1,5 @@
 #![warn(clippy::all)]
-#![allow(clippy::blacklisted_name, clippy::equatable_if_let)]
+#![allow(clippy::disallowed_name, clippy::equatable_if_let)]
 #![allow(unused)]
 
 /// Test for https://github.com/rust-lang/rust-clippy/issues/3462
diff --git a/tests/ui/crashes/regressions.rs b/tests/ui/crashes/regressions.rs
index 6f9d98bbfe7..86985391fc0 100644
--- a/tests/ui/crashes/regressions.rs
+++ b/tests/ui/crashes/regressions.rs
@@ -1,4 +1,4 @@
-#![allow(clippy::blacklisted_name)]
+#![allow(clippy::disallowed_name)]
 
 pub fn foo(bar: *const u8) {
     println!("{:#p}", bar);
diff --git a/tests/ui/disallowed_name.rs b/tests/ui/disallowed_name.rs
new file mode 100644
index 00000000000..17acc8533e0
--- /dev/null
+++ b/tests/ui/disallowed_name.rs
@@ -0,0 +1,57 @@
+#![allow(
+    dead_code,
+    clippy::similar_names,
+    clippy::single_match,
+    clippy::toplevel_ref_arg,
+    unused_mut,
+    unused_variables
+)]
+#![warn(clippy::disallowed_name)]
+
+fn test(foo: ()) {}
+
+fn main() {
+    let foo = 42;
+    let baz = 42;
+    let quux = 42;
+    // Unlike these others, `bar` is actually considered an acceptable name.
+    // Among many other legitimate uses, bar commonly refers to a period of time in music.
+    // See https://github.com/rust-lang/rust-clippy/issues/5225.
+    let bar = 42;
+
+    let food = 42;
+    let foodstuffs = 42;
+    let bazaar = 42;
+
+    match (42, Some(1337), Some(0)) {
+        (foo, Some(baz), quux @ Some(_)) => (),
+        _ => (),
+    }
+}
+
+fn issue_1647(mut foo: u8) {
+    let mut baz = 0;
+    if let Some(mut quux) = Some(42) {}
+}
+
+fn issue_1647_ref() {
+    let ref baz = 0;
+    if let Some(ref quux) = Some(42) {}
+}
+
+fn issue_1647_ref_mut() {
+    let ref mut baz = 0;
+    if let Some(ref mut quux) = Some(42) {}
+}
+
+mod tests {
+    fn issue_7305() {
+        // `disallowed_name` lint should not be triggered inside of the test code.
+        let foo = 0;
+
+        // Check that even in nested functions warning is still not triggered.
+        fn nested() {
+            let foo = 0;
+        }
+    }
+}
diff --git a/tests/ui/disallowed_name.stderr b/tests/ui/disallowed_name.stderr
new file mode 100644
index 00000000000..240c167e223
--- /dev/null
+++ b/tests/ui/disallowed_name.stderr
@@ -0,0 +1,88 @@
+error: use of a disallowed/placeholder name `foo`
+  --> $DIR/disallowed_name.rs:11:9
+   |
+LL | fn test(foo: ()) {}
+   |         ^^^
+   |
+   = note: `-D clippy::disallowed-name` implied by `-D warnings`
+
+error: use of a disallowed/placeholder name `foo`
+  --> $DIR/disallowed_name.rs:14:9
+   |
+LL |     let foo = 42;
+   |         ^^^
+
+error: use of a disallowed/placeholder name `baz`
+  --> $DIR/disallowed_name.rs:15:9
+   |
+LL |     let baz = 42;
+   |         ^^^
+
+error: use of a disallowed/placeholder name `quux`
+  --> $DIR/disallowed_name.rs:16:9
+   |
+LL |     let quux = 42;
+   |         ^^^^
+
+error: use of a disallowed/placeholder name `foo`
+  --> $DIR/disallowed_name.rs:27:10
+   |
+LL |         (foo, Some(baz), quux @ Some(_)) => (),
+   |          ^^^
+
+error: use of a disallowed/placeholder name `baz`
+  --> $DIR/disallowed_name.rs:27:20
+   |
+LL |         (foo, Some(baz), quux @ Some(_)) => (),
+   |                    ^^^
+
+error: use of a disallowed/placeholder name `quux`
+  --> $DIR/disallowed_name.rs:27:26
+   |
+LL |         (foo, Some(baz), quux @ Some(_)) => (),
+   |                          ^^^^
+
+error: use of a disallowed/placeholder name `foo`
+  --> $DIR/disallowed_name.rs:32:19
+   |
+LL | fn issue_1647(mut foo: u8) {
+   |                   ^^^
+
+error: use of a disallowed/placeholder name `baz`
+  --> $DIR/disallowed_name.rs:33:13
+   |
+LL |     let mut baz = 0;
+   |             ^^^
+
+error: use of a disallowed/placeholder name `quux`
+  --> $DIR/disallowed_name.rs:34:21
+   |
+LL |     if let Some(mut quux) = Some(42) {}
+   |                     ^^^^
+
+error: use of a disallowed/placeholder name `baz`
+  --> $DIR/disallowed_name.rs:38:13
+   |
+LL |     let ref baz = 0;
+   |             ^^^
+
+error: use of a disallowed/placeholder name `quux`
+  --> $DIR/disallowed_name.rs:39:21
+   |
+LL |     if let Some(ref quux) = Some(42) {}
+   |                     ^^^^
+
+error: use of a disallowed/placeholder name `baz`
+  --> $DIR/disallowed_name.rs:43:17
+   |
+LL |     let ref mut baz = 0;
+   |                 ^^^
+
+error: use of a disallowed/placeholder name `quux`
+  --> $DIR/disallowed_name.rs:44:25
+   |
+LL |     if let Some(ref mut quux) = Some(42) {}
+   |                         ^^^^
+
+error: aborting due to 14 previous errors
+
diff --git a/tests/ui/if_same_then_else.rs b/tests/ui/if_same_then_else.rs
index 2598c2ab426..dd25008cbbe 100644
--- a/tests/ui/if_same_then_else.rs
+++ b/tests/ui/if_same_then_else.rs
@@ -1,6 +1,6 @@
 #![warn(clippy::if_same_then_else)]
 #![allow(
-    clippy::blacklisted_name,
+    clippy::disallowed_name,
     clippy::eq_op,
     clippy::never_loop,
     clippy::no_effect,
diff --git a/tests/ui/if_same_then_else2.rs b/tests/ui/if_same_then_else2.rs
index 0016009a02f..8b643c48914 100644
--- a/tests/ui/if_same_then_else2.rs
+++ b/tests/ui/if_same_then_else2.rs
@@ -1,6 +1,6 @@
 #![warn(clippy::if_same_then_else)]
 #![allow(
-    clippy::blacklisted_name,
+    clippy::disallowed_name,
     clippy::collapsible_else_if,
     clippy::equatable_if_let,
     clippy::collapsible_if,
diff --git a/tests/ui/iter_skip_next.fixed b/tests/ui/iter_skip_next.fixed
index 2db4c2bee7f..2cb89665411 100644
--- a/tests/ui/iter_skip_next.fixed
+++ b/tests/ui/iter_skip_next.fixed
@@ -2,7 +2,7 @@
 // aux-build:option_helpers.rs
 
 #![warn(clippy::iter_skip_next)]
-#![allow(clippy::blacklisted_name)]
+#![allow(clippy::disallowed_name)]
 #![allow(clippy::iter_nth)]
 #![allow(unused_mut, dead_code)]
 
diff --git a/tests/ui/iter_skip_next.rs b/tests/ui/iter_skip_next.rs
index 692edb9aed9..972d1e2b51f 100644
--- a/tests/ui/iter_skip_next.rs
+++ b/tests/ui/iter_skip_next.rs
@@ -2,7 +2,7 @@
 // aux-build:option_helpers.rs
 
 #![warn(clippy::iter_skip_next)]
-#![allow(clippy::blacklisted_name)]
+#![allow(clippy::disallowed_name)]
 #![allow(clippy::iter_nth)]
 #![allow(unused_mut, dead_code)]
 
diff --git a/tests/ui/let_if_seq.rs b/tests/ui/let_if_seq.rs
index c5cb2eb1fe1..ee351880b80 100644
--- a/tests/ui/let_if_seq.rs
+++ b/tests/ui/let_if_seq.rs
@@ -2,7 +2,7 @@
     unused_variables,
     unused_assignments,
     clippy::similar_names,
-    clippy::blacklisted_name,
+    clippy::disallowed_name,
     clippy::branches_sharing_code,
     clippy::needless_late_init
 )]
diff --git a/tests/ui/manual_ok_or.fixed b/tests/ui/manual_ok_or.fixed
index 887a97d7a01..9ee71bf9090 100644
--- a/tests/ui/manual_ok_or.fixed
+++ b/tests/ui/manual_ok_or.fixed
@@ -1,6 +1,6 @@
 // run-rustfix
 #![warn(clippy::manual_ok_or)]
-#![allow(clippy::blacklisted_name)]
+#![allow(clippy::disallowed_name)]
 #![allow(clippy::redundant_closure)]
 #![allow(dead_code)]
 #![allow(unused_must_use)]
diff --git a/tests/ui/manual_ok_or.rs b/tests/ui/manual_ok_or.rs
index 3c99872f502..0e1bc085769 100644
--- a/tests/ui/manual_ok_or.rs
+++ b/tests/ui/manual_ok_or.rs
@@ -1,6 +1,6 @@
 // run-rustfix
 #![warn(clippy::manual_ok_or)]
-#![allow(clippy::blacklisted_name)]
+#![allow(clippy::disallowed_name)]
 #![allow(clippy::redundant_closure)]
 #![allow(dead_code)]
 #![allow(unused_must_use)]
diff --git a/tests/ui/match_same_arms2.rs b/tests/ui/match_same_arms2.rs
index 7aba5b447d5..086e3e9b805 100644
--- a/tests/ui/match_same_arms2.rs
+++ b/tests/ui/match_same_arms2.rs
@@ -1,5 +1,5 @@
 #![warn(clippy::match_same_arms)]
-#![allow(clippy::blacklisted_name, clippy::diverging_sub_expression)]
+#![allow(clippy::disallowed_name, clippy::diverging_sub_expression)]
 
 fn bar<T>(_: T) {}
 fn foo() -> bool {
diff --git a/tests/ui/methods.rs b/tests/ui/methods.rs
index 1970c2eae53..8d782f73821 100644
--- a/tests/ui/methods.rs
+++ b/tests/ui/methods.rs
@@ -2,7 +2,7 @@
 
 #![warn(clippy::all, clippy::pedantic)]
 #![allow(
-    clippy::blacklisted_name,
+    clippy::disallowed_name,
     clippy::default_trait_access,
     clippy::missing_docs_in_private_items,
     clippy::missing_safety_doc,
diff --git a/tests/ui/mismatching_type_param_order.rs b/tests/ui/mismatching_type_param_order.rs
index 8c0da84d8e9..c2195bf18d1 100644
--- a/tests/ui/mismatching_type_param_order.rs
+++ b/tests/ui/mismatching_type_param_order.rs
@@ -1,5 +1,5 @@
 #![warn(clippy::mismatching_type_param_order)]
-#![allow(clippy::blacklisted_name)]
+#![allow(clippy::disallowed_name)]
 
 fn main() {
     struct Foo<A, B> {
diff --git a/tests/ui/mixed_read_write_in_expression.rs b/tests/ui/mixed_read_write_in_expression.rs
index 7640057ab6e..6e413fcf5bb 100644
--- a/tests/ui/mixed_read_write_in_expression.rs
+++ b/tests/ui/mixed_read_write_in_expression.rs
@@ -4,7 +4,7 @@
     unused_variables,
     clippy::no_effect,
     dead_code,
-    clippy::blacklisted_name
+    clippy::disallowed_name
 )]
 fn main() {
     let mut x = 0;
diff --git a/tests/ui/op_ref.rs b/tests/ui/op_ref.rs
index d8bf66603d9..8e53f2073e5 100644
--- a/tests/ui/op_ref.rs
+++ b/tests/ui/op_ref.rs
@@ -1,4 +1,4 @@
-#![allow(unused_variables, clippy::blacklisted_name)]
+#![allow(unused_variables, clippy::disallowed_name)]
 #![warn(clippy::op_ref)]
 use std::collections::HashSet;
 use std::ops::{BitAnd, Mul};
diff --git a/tests/ui/rc_mutex.rs b/tests/ui/rc_mutex.rs
index 18e8a2e01e0..ee707a630fa 100644
--- a/tests/ui/rc_mutex.rs
+++ b/tests/ui/rc_mutex.rs
@@ -1,5 +1,5 @@
 #![warn(clippy::rc_mutex)]
-#![allow(unused, clippy::blacklisted_name)]
+#![allow(unused, clippy::disallowed_name)]
 
 use std::rc::Rc;
 use std::sync::Mutex;
diff --git a/tests/ui/redundant_allocation.rs b/tests/ui/redundant_allocation.rs
index cf7d8c6e349..7b9e02f974c 100644
--- a/tests/ui/redundant_allocation.rs
+++ b/tests/ui/redundant_allocation.rs
@@ -1,6 +1,6 @@
 #![warn(clippy::all)]
 #![allow(clippy::boxed_local, clippy::needless_pass_by_value)]
-#![allow(clippy::blacklisted_name, unused_variables, dead_code)]
+#![allow(clippy::disallowed_name, unused_variables, dead_code)]
 #![allow(unused_imports)]
 
 pub struct MyStruct;
diff --git a/tests/ui/redundant_allocation_fixable.fixed b/tests/ui/redundant_allocation_fixable.fixed
index e7ed84731c0..4c85b20afe5 100644
--- a/tests/ui/redundant_allocation_fixable.fixed
+++ b/tests/ui/redundant_allocation_fixable.fixed
@@ -1,7 +1,7 @@
 // run-rustfix
 #![warn(clippy::all)]
 #![allow(clippy::boxed_local, clippy::needless_pass_by_value)]
-#![allow(clippy::blacklisted_name, unused_variables, dead_code)]
+#![allow(clippy::disallowed_name, unused_variables, dead_code)]
 #![allow(unused_imports)]
 
 pub struct MyStruct;
diff --git a/tests/ui/redundant_allocation_fixable.rs b/tests/ui/redundant_allocation_fixable.rs
index de763f98b5c..8b402e47873 100644
--- a/tests/ui/redundant_allocation_fixable.rs
+++ b/tests/ui/redundant_allocation_fixable.rs
@@ -1,7 +1,7 @@
 // run-rustfix
 #![warn(clippy::all)]
 #![allow(clippy::boxed_local, clippy::needless_pass_by_value)]
-#![allow(clippy::blacklisted_name, unused_variables, dead_code)]
+#![allow(clippy::disallowed_name, unused_variables, dead_code)]
 #![allow(unused_imports)]
 
 pub struct MyStruct;
diff --git a/tests/ui/rename.fixed b/tests/ui/rename.fixed
index 53288be9404..e65327737ce 100644
--- a/tests/ui/rename.fixed
+++ b/tests/ui/rename.fixed
@@ -6,6 +6,7 @@
 
 #![allow(clippy::blocks_in_if_conditions)]
 #![allow(clippy::box_collection)]
+#![allow(clippy::disallowed_name)]
 #![allow(clippy::redundant_static_lifetimes)]
 #![allow(clippy::cognitive_complexity)]
 #![allow(clippy::disallowed_methods)]
@@ -36,6 +37,7 @@
 #![warn(clippy::blocks_in_if_conditions)]
 #![warn(clippy::blocks_in_if_conditions)]
 #![warn(clippy::box_collection)]
+#![warn(clippy::disallowed_name)]
 #![warn(clippy::redundant_static_lifetimes)]
 #![warn(clippy::cognitive_complexity)]
 #![warn(clippy::disallowed_methods)]
diff --git a/tests/ui/rename.rs b/tests/ui/rename.rs
index 539f34f847a..8125b153589 100644
--- a/tests/ui/rename.rs
+++ b/tests/ui/rename.rs
@@ -6,6 +6,7 @@
 
 #![allow(clippy::blocks_in_if_conditions)]
 #![allow(clippy::box_collection)]
+#![allow(clippy::disallowed_name)]
 #![allow(clippy::redundant_static_lifetimes)]
 #![allow(clippy::cognitive_complexity)]
 #![allow(clippy::disallowed_methods)]
@@ -36,6 +37,7 @@
 #![warn(clippy::block_in_if_condition_expr)]
 #![warn(clippy::block_in_if_condition_stmt)]
 #![warn(clippy::box_vec)]
+#![warn(clippy::blacklisted_name)]
 #![warn(clippy::const_static_lifetime)]
 #![warn(clippy::cyclomatic_complexity)]
 #![warn(clippy::disallowed_method)]
diff --git a/tests/ui/rename.stderr b/tests/ui/rename.stderr
index 8ea46b580a8..d2829311059 100644
--- a/tests/ui/rename.stderr
+++ b/tests/ui/rename.stderr
@@ -1,5 +1,5 @@
 error: lint `clippy::block_in_if_condition_expr` has been renamed to `clippy::blocks_in_if_conditions`
-  --> $DIR/rename.rs:36:9
+  --> $DIR/rename.rs:37:9
    |
 LL | #![warn(clippy::block_in_if_condition_expr)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::blocks_in_if_conditions`
@@ -7,208 +7,214 @@ LL | #![warn(clippy::block_in_if_condition_expr)]
    = note: `-D renamed-and-removed-lints` implied by `-D warnings`
 
 error: lint `clippy::block_in_if_condition_stmt` has been renamed to `clippy::blocks_in_if_conditions`
-  --> $DIR/rename.rs:37:9
+  --> $DIR/rename.rs:38:9
    |
 LL | #![warn(clippy::block_in_if_condition_stmt)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::blocks_in_if_conditions`
 
 error: lint `clippy::box_vec` has been renamed to `clippy::box_collection`
-  --> $DIR/rename.rs:38:9
+  --> $DIR/rename.rs:39:9
    |
 LL | #![warn(clippy::box_vec)]
    |         ^^^^^^^^^^^^^^^ help: use the new name: `clippy::box_collection`
 
+error: lint `clippy::blacklisted_name` has been renamed to `clippy::disallowed_name`
+  --> $DIR/rename.rs:40:9
+   |
+LL | #![warn(clippy::blacklisted_name)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::disallowed_name`
+
 error: lint `clippy::const_static_lifetime` has been renamed to `clippy::redundant_static_lifetimes`
-  --> $DIR/rename.rs:39:9
+  --> $DIR/rename.rs:41:9
    |
 LL | #![warn(clippy::const_static_lifetime)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::redundant_static_lifetimes`
 
 error: lint `clippy::cyclomatic_complexity` has been renamed to `clippy::cognitive_complexity`
-  --> $DIR/rename.rs:40:9
+  --> $DIR/rename.rs:42:9
    |
 LL | #![warn(clippy::cyclomatic_complexity)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::cognitive_complexity`
 
 error: lint `clippy::disallowed_method` has been renamed to `clippy::disallowed_methods`
-  --> $DIR/rename.rs:41:9
+  --> $DIR/rename.rs:43:9
    |
 LL | #![warn(clippy::disallowed_method)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::disallowed_methods`
 
 error: lint `clippy::disallowed_type` has been renamed to `clippy::disallowed_types`
-  --> $DIR/rename.rs:42:9
+  --> $DIR/rename.rs:44:9
    |
 LL | #![warn(clippy::disallowed_type)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::disallowed_types`
 
 error: lint `clippy::eval_order_dependence` has been renamed to `clippy::mixed_read_write_in_expression`
-  --> $DIR/rename.rs:43:9
+  --> $DIR/rename.rs:45:9
    |
 LL | #![warn(clippy::eval_order_dependence)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::mixed_read_write_in_expression`
 
 error: lint `clippy::for_loop_over_option` has been renamed to `clippy::for_loops_over_fallibles`
-  --> $DIR/rename.rs:44:9
+  --> $DIR/rename.rs:46:9
    |
 LL | #![warn(clippy::for_loop_over_option)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::for_loops_over_fallibles`
 
 error: lint `clippy::for_loop_over_result` has been renamed to `clippy::for_loops_over_fallibles`
-  --> $DIR/rename.rs:45:9
+  --> $DIR/rename.rs:47:9
    |
 LL | #![warn(clippy::for_loop_over_result)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::for_loops_over_fallibles`
 
 error: lint `clippy::identity_conversion` has been renamed to `clippy::useless_conversion`
-  --> $DIR/rename.rs:46:9
+  --> $DIR/rename.rs:48:9
    |
 LL | #![warn(clippy::identity_conversion)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::useless_conversion`
 
 error: lint `clippy::if_let_some_result` has been renamed to `clippy::match_result_ok`
-  --> $DIR/rename.rs:47:9
+  --> $DIR/rename.rs:49:9
    |
 LL | #![warn(clippy::if_let_some_result)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::match_result_ok`
 
 error: lint `clippy::new_without_default_derive` has been renamed to `clippy::new_without_default`
-  --> $DIR/rename.rs:48:9
+  --> $DIR/rename.rs:50:9
    |
 LL | #![warn(clippy::new_without_default_derive)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::new_without_default`
 
 error: lint `clippy::option_and_then_some` has been renamed to `clippy::bind_instead_of_map`
-  --> $DIR/rename.rs:49:9
+  --> $DIR/rename.rs:51:9
    |
 LL | #![warn(clippy::option_and_then_some)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::bind_instead_of_map`
 
 error: lint `clippy::option_expect_used` has been renamed to `clippy::expect_used`
-  --> $DIR/rename.rs:50:9
+  --> $DIR/rename.rs:52:9
    |
 LL | #![warn(clippy::option_expect_used)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::expect_used`
 
 error: lint `clippy::option_map_unwrap_or` has been renamed to `clippy::map_unwrap_or`
-  --> $DIR/rename.rs:51:9
+  --> $DIR/rename.rs:53:9
    |
 LL | #![warn(clippy::option_map_unwrap_or)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::map_unwrap_or`
 
 error: lint `clippy::option_map_unwrap_or_else` has been renamed to `clippy::map_unwrap_or`
-  --> $DIR/rename.rs:52:9
+  --> $DIR/rename.rs:54:9
    |
 LL | #![warn(clippy::option_map_unwrap_or_else)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::map_unwrap_or`
 
 error: lint `clippy::option_unwrap_used` has been renamed to `clippy::unwrap_used`
-  --> $DIR/rename.rs:53:9
+  --> $DIR/rename.rs:55:9
    |
 LL | #![warn(clippy::option_unwrap_used)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::unwrap_used`
 
 error: lint `clippy::ref_in_deref` has been renamed to `clippy::needless_borrow`
-  --> $DIR/rename.rs:54:9
+  --> $DIR/rename.rs:56:9
    |
 LL | #![warn(clippy::ref_in_deref)]
    |         ^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::needless_borrow`
 
 error: lint `clippy::result_expect_used` has been renamed to `clippy::expect_used`
-  --> $DIR/rename.rs:55:9
+  --> $DIR/rename.rs:57:9
    |
 LL | #![warn(clippy::result_expect_used)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::expect_used`
 
 error: lint `clippy::result_map_unwrap_or_else` has been renamed to `clippy::map_unwrap_or`
-  --> $DIR/rename.rs:56:9
+  --> $DIR/rename.rs:58:9
    |
 LL | #![warn(clippy::result_map_unwrap_or_else)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::map_unwrap_or`
 
 error: lint `clippy::result_unwrap_used` has been renamed to `clippy::unwrap_used`
-  --> $DIR/rename.rs:57:9
+  --> $DIR/rename.rs:59:9
    |
 LL | #![warn(clippy::result_unwrap_used)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::unwrap_used`
 
 error: lint `clippy::single_char_push_str` has been renamed to `clippy::single_char_add_str`
-  --> $DIR/rename.rs:58:9
+  --> $DIR/rename.rs:60:9
    |
 LL | #![warn(clippy::single_char_push_str)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::single_char_add_str`
 
 error: lint `clippy::stutter` has been renamed to `clippy::module_name_repetitions`
-  --> $DIR/rename.rs:59:9
+  --> $DIR/rename.rs:61:9
    |
 LL | #![warn(clippy::stutter)]
    |         ^^^^^^^^^^^^^^^ help: use the new name: `clippy::module_name_repetitions`
 
 error: lint `clippy::to_string_in_display` has been renamed to `clippy::recursive_format_impl`
-  --> $DIR/rename.rs:60:9
+  --> $DIR/rename.rs:62:9
    |
 LL | #![warn(clippy::to_string_in_display)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::recursive_format_impl`
 
 error: lint `clippy::zero_width_space` has been renamed to `clippy::invisible_characters`
-  --> $DIR/rename.rs:61:9
+  --> $DIR/rename.rs:63:9
    |
 LL | #![warn(clippy::zero_width_space)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::invisible_characters`
 
 error: lint `clippy::drop_bounds` has been renamed to `drop_bounds`
-  --> $DIR/rename.rs:62:9
+  --> $DIR/rename.rs:64:9
    |
 LL | #![warn(clippy::drop_bounds)]
    |         ^^^^^^^^^^^^^^^^^^^ help: use the new name: `drop_bounds`
 
 error: lint `clippy::into_iter_on_array` has been renamed to `array_into_iter`
-  --> $DIR/rename.rs:63:9
+  --> $DIR/rename.rs:65:9
    |
 LL | #![warn(clippy::into_iter_on_array)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `array_into_iter`
 
 error: lint `clippy::invalid_atomic_ordering` has been renamed to `invalid_atomic_ordering`
-  --> $DIR/rename.rs:64:9
+  --> $DIR/rename.rs:66:9
    |
 LL | #![warn(clippy::invalid_atomic_ordering)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `invalid_atomic_ordering`
 
 error: lint `clippy::invalid_ref` has been renamed to `invalid_value`
-  --> $DIR/rename.rs:65:9
+  --> $DIR/rename.rs:67:9
    |
 LL | #![warn(clippy::invalid_ref)]
    |         ^^^^^^^^^^^^^^^^^^^ help: use the new name: `invalid_value`
 
 error: lint `clippy::mem_discriminant_non_enum` has been renamed to `enum_intrinsics_non_enums`
-  --> $DIR/rename.rs:66:9
+  --> $DIR/rename.rs:68:9
    |
 LL | #![warn(clippy::mem_discriminant_non_enum)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `enum_intrinsics_non_enums`
 
 error: lint `clippy::panic_params` has been renamed to `non_fmt_panics`
-  --> $DIR/rename.rs:67:9
+  --> $DIR/rename.rs:69:9
    |
 LL | #![warn(clippy::panic_params)]
    |         ^^^^^^^^^^^^^^^^^^^^ help: use the new name: `non_fmt_panics`
 
 error: lint `clippy::temporary_cstring_as_ptr` has been renamed to `temporary_cstring_as_ptr`
-  --> $DIR/rename.rs:68:9
+  --> $DIR/rename.rs:70:9
    |
 LL | #![warn(clippy::temporary_cstring_as_ptr)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `temporary_cstring_as_ptr`
 
 error: lint `clippy::unknown_clippy_lints` has been renamed to `unknown_lints`
-  --> $DIR/rename.rs:69:9
+  --> $DIR/rename.rs:71:9
    |
 LL | #![warn(clippy::unknown_clippy_lints)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `unknown_lints`
 
 error: lint `clippy::unused_label` has been renamed to `unused_labels`
-  --> $DIR/rename.rs:70:9
+  --> $DIR/rename.rs:72:9
    |
 LL | #![warn(clippy::unused_label)]
    |         ^^^^^^^^^^^^^^^^^^^^ help: use the new name: `unused_labels`
 
-error: aborting due to 35 previous errors
+error: aborting due to 36 previous errors
 
diff --git a/tests/ui/skip_while_next.rs b/tests/ui/skip_while_next.rs
index a522c0f08b2..bedd2704100 100644
--- a/tests/ui/skip_while_next.rs
+++ b/tests/ui/skip_while_next.rs
@@ -1,7 +1,7 @@
 // aux-build:option_helpers.rs
 
 #![warn(clippy::skip_while_next)]
-#![allow(clippy::blacklisted_name)]
+#![allow(clippy::disallowed_name)]
 
 extern crate option_helpers;
 use option_helpers::IteratorFalsePositives;
diff --git a/tests/ui/swap.fixed b/tests/ui/swap.fixed
index 3329efbd4ff..0865287c08a 100644
--- a/tests/ui/swap.fixed
+++ b/tests/ui/swap.fixed
@@ -2,7 +2,7 @@
 
 #![warn(clippy::all)]
 #![allow(
-    clippy::blacklisted_name,
+    clippy::disallowed_name,
     clippy::no_effect,
     clippy::redundant_clone,
     redundant_semicolons,
diff --git a/tests/ui/swap.rs b/tests/ui/swap.rs
index 8179ac1f2ab..8f87c488462 100644
--- a/tests/ui/swap.rs
+++ b/tests/ui/swap.rs
@@ -2,7 +2,7 @@
 
 #![warn(clippy::all)]
 #![allow(
-    clippy::blacklisted_name,
+    clippy::disallowed_name,
     clippy::no_effect,
     clippy::redundant_clone,
     redundant_semicolons,
diff --git a/tests/ui/trivially_copy_pass_by_ref.rs b/tests/ui/trivially_copy_pass_by_ref.rs
index 8f78f16a0a1..732b139ea12 100644
--- a/tests/ui/trivially_copy_pass_by_ref.rs
+++ b/tests/ui/trivially_copy_pass_by_ref.rs
@@ -2,7 +2,7 @@
 // normalize-stderr-test "\(limit: \d+ byte\)" -> "(limit: N byte)"
 
 #![deny(clippy::trivially_copy_pass_by_ref)]
-#![allow(clippy::blacklisted_name, clippy::redundant_field_names)]
+#![allow(clippy::disallowed_name, clippy::redundant_field_names)]
 
 #[derive(Copy, Clone)]
 struct Foo(u32);
diff --git a/tests/ui/used_underscore_binding.rs b/tests/ui/used_underscore_binding.rs
index d20977d55d2..91c88079363 100644
--- a/tests/ui/used_underscore_binding.rs
+++ b/tests/ui/used_underscore_binding.rs
@@ -2,7 +2,7 @@
 
 #![feature(rustc_private)]
 #![warn(clippy::all)]
-#![allow(clippy::blacklisted_name, clippy::eq_op)]
+#![allow(clippy::disallowed_name, clippy::eq_op)]
 #![warn(clippy::used_underscore_binding)]
 
 #[macro_use]
-- 
cgit 1.4.1-3-g733a5


From 66b46749e68bc4d8c3ed754722631746a2331518 Mon Sep 17 00:00:00 2001
From: Andy Caldwell <andrew.caldwell@metaswitch.com>
Date: Wed, 8 Jun 2022 20:08:37 +0100
Subject: Change lint name to plural

---
 CHANGELOG.md                                       |  6 +-
 clippy_lints/src/disallowed_name.rs                | 77 -------------------
 clippy_lints/src/disallowed_names.rs               | 77 +++++++++++++++++++
 clippy_lints/src/lib.register_all.rs               |  2 +-
 clippy_lints/src/lib.register_lints.rs             |  2 +-
 clippy_lints/src/lib.register_style.rs             |  2 +-
 clippy_lints/src/lib.rs                            |  4 +-
 clippy_lints/src/renamed_lints.rs                  |  2 +-
 clippy_lints/src/utils/conf.rs                     |  2 +-
 .../disallowed_names_append/disallowed_names.rs    |  2 +-
 .../disallowed_names.stderr                        |  2 +-
 .../disallowed_names_replace/disallowed_names.rs   |  2 +-
 .../disallowed_names.stderr                        |  2 +-
 .../toml_disallow/conf_french_disallowed_name.rs   |  2 +-
 .../conf_french_disallowed_name.stderr             |  2 +-
 tests/ui/borrow_box.rs                             |  2 +-
 tests/ui/box_collection.rs                         |  7 +-
 tests/ui/box_collection.stderr                     | 18 ++---
 tests/ui/crashes/ice-2760.rs                       |  7 +-
 tests/ui/crashes/ice-3462.rs                       |  2 +-
 tests/ui/crashes/regressions.rs                    |  2 +-
 tests/ui/disallowed_name.rs                        | 57 --------------
 tests/ui/disallowed_name.stderr                    | 88 ----------------------
 tests/ui/disallowed_names.rs                       | 57 ++++++++++++++
 tests/ui/disallowed_names.stderr                   | 88 ++++++++++++++++++++++
 tests/ui/if_same_then_else.rs                      |  2 +-
 tests/ui/if_same_then_else2.rs                     |  2 +-
 tests/ui/iter_skip_next.fixed                      |  2 +-
 tests/ui/iter_skip_next.rs                         |  2 +-
 tests/ui/let_if_seq.rs                             |  2 +-
 tests/ui/manual_ok_or.fixed                        |  2 +-
 tests/ui/manual_ok_or.rs                           |  2 +-
 tests/ui/match_same_arms2.rs                       |  2 +-
 tests/ui/methods.rs                                |  2 +-
 tests/ui/mismatching_type_param_order.rs           |  2 +-
 tests/ui/mixed_read_write_in_expression.rs         |  2 +-
 tests/ui/op_ref.rs                                 |  2 +-
 tests/ui/rc_mutex.rs                               |  2 +-
 tests/ui/redundant_allocation.rs                   |  2 +-
 tests/ui/redundant_allocation_fixable.fixed        |  2 +-
 tests/ui/redundant_allocation_fixable.rs           |  2 +-
 tests/ui/rename.fixed                              |  4 +-
 tests/ui/rename.rs                                 |  2 +-
 tests/ui/rename.stderr                             |  4 +-
 tests/ui/skip_while_next.rs                        |  2 +-
 tests/ui/swap.fixed                                |  2 +-
 tests/ui/swap.rs                                   |  2 +-
 tests/ui/trivially_copy_pass_by_ref.rs             |  2 +-
 tests/ui/used_underscore_binding.rs                |  2 +-
 49 files changed, 288 insertions(+), 278 deletions(-)
 delete mode 100644 clippy_lints/src/disallowed_name.rs
 create mode 100644 clippy_lints/src/disallowed_names.rs
 delete mode 100644 tests/ui/disallowed_name.rs
 delete mode 100644 tests/ui/disallowed_name.stderr
 create mode 100644 tests/ui/disallowed_names.rs
 create mode 100644 tests/ui/disallowed_names.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index d3d4d5a4784..646e1128e9a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -965,7 +965,7 @@ Released 2021-09-09
   [#7407](https://github.com/rust-lang/rust-clippy/pull/7407)
 * [`redundant_allocation`]: Now additionally supports the `Arc<>` type
   [#7308](https://github.com/rust-lang/rust-clippy/pull/7308)
-* [`disallowed_name`]: Now allows disallowed names in test code
+* [`disallowed_names`]: Now allows disallowed names in test code
   [#7379](https://github.com/rust-lang/rust-clippy/pull/7379)
 * [`redundant_closure`]: Suggests `&mut` for `FnMut`
   [#7437](https://github.com/rust-lang/rust-clippy/pull/7437)
@@ -2066,7 +2066,7 @@ Released 2020-08-27
   [#5692](https://github.com/rust-lang/rust-clippy/pull/5692)
 * [`if_same_then_else`]: Don't assume multiplication is always commutative
   [#5702](https://github.com/rust-lang/rust-clippy/pull/5702)
-* [`disallowed_name`]: Remove `bar` from the default configuration
+* [`disallowed_names`]: Remove `bar` from the default configuration
   [#5712](https://github.com/rust-lang/rust-clippy/pull/5712)
 * [`redundant_pattern_matching`]: Avoid suggesting non-`const fn` calls in const contexts
   [#5724](https://github.com/rust-lang/rust-clippy/pull/5724)
@@ -3522,7 +3522,7 @@ Released 2018-09-13
 [`derive_partial_eq_without_eq`]: https://rust-lang.github.io/rust-clippy/master/index.html#derive_partial_eq_without_eq
 [`disallowed_method`]: https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_method
 [`disallowed_methods`]: https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_methods
-[`disallowed_name`]: https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_name
+[`disallowed_names`]: https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_names
 [`disallowed_script_idents`]: https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_script_idents
 [`disallowed_type`]: https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_type
 [`disallowed_types`]: https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_types
diff --git a/clippy_lints/src/disallowed_name.rs b/clippy_lints/src/disallowed_name.rs
deleted file mode 100644
index 98735ce7db1..00000000000
--- a/clippy_lints/src/disallowed_name.rs
+++ /dev/null
@@ -1,77 +0,0 @@
-use clippy_utils::{diagnostics::span_lint, is_test_module_or_function};
-use rustc_data_structures::fx::FxHashSet;
-use rustc_hir::{Item, Pat, PatKind};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for usage of disallowed names for variables, such
-    /// as `foo`.
-    ///
-    /// ### Why is this bad?
-    /// These names are usually placeholder names and should be
-    /// avoided.
-    ///
-    /// ### Example
-    /// ```rust
-    /// let foo = 3.14;
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub DISALLOWED_NAME,
-    style,
-    "usage of a disallowed/placeholder name"
-}
-
-#[derive(Clone, Debug)]
-pub struct DisallowedName {
-    disallow: FxHashSet<String>,
-    test_modules_deep: u32,
-}
-
-impl DisallowedName {
-    pub fn new(disallow: FxHashSet<String>) -> Self {
-        Self {
-            disallow,
-            test_modules_deep: 0,
-        }
-    }
-
-    fn in_test_module(&self) -> bool {
-        self.test_modules_deep != 0
-    }
-}
-
-impl_lint_pass!(DisallowedName => [DISALLOWED_NAME]);
-
-impl<'tcx> LateLintPass<'tcx> for DisallowedName {
-    fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
-        if is_test_module_or_function(cx.tcx, item) {
-            self.test_modules_deep = self.test_modules_deep.saturating_add(1);
-        }
-    }
-
-    fn check_pat(&mut self, cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>) {
-        // Check whether we are under the `test` attribute.
-        if self.in_test_module() {
-            return;
-        }
-
-        if let PatKind::Binding(.., ident, _) = pat.kind {
-            if self.disallow.contains(&ident.name.to_string()) {
-                span_lint(
-                    cx,
-                    DISALLOWED_NAME,
-                    ident.span,
-                    &format!("use of a disallowed/placeholder name `{}`", ident.name),
-                );
-            }
-        }
-    }
-
-    fn check_item_post(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
-        if is_test_module_or_function(cx.tcx, item) {
-            self.test_modules_deep = self.test_modules_deep.saturating_sub(1);
-        }
-    }
-}
diff --git a/clippy_lints/src/disallowed_names.rs b/clippy_lints/src/disallowed_names.rs
new file mode 100644
index 00000000000..6e6615f08ee
--- /dev/null
+++ b/clippy_lints/src/disallowed_names.rs
@@ -0,0 +1,77 @@
+use clippy_utils::{diagnostics::span_lint, is_test_module_or_function};
+use rustc_data_structures::fx::FxHashSet;
+use rustc_hir::{Item, Pat, PatKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of disallowed names for variables, such
+    /// as `foo`.
+    ///
+    /// ### Why is this bad?
+    /// These names are usually placeholder names and should be
+    /// avoided.
+    ///
+    /// ### Example
+    /// ```rust
+    /// let foo = 3.14;
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub DISALLOWED_NAMES,
+    style,
+    "usage of a disallowed/placeholder name"
+}
+
+#[derive(Clone, Debug)]
+pub struct DisallowedNames {
+    disallow: FxHashSet<String>,
+    test_modules_deep: u32,
+}
+
+impl DisallowedNames {
+    pub fn new(disallow: FxHashSet<String>) -> Self {
+        Self {
+            disallow,
+            test_modules_deep: 0,
+        }
+    }
+
+    fn in_test_module(&self) -> bool {
+        self.test_modules_deep != 0
+    }
+}
+
+impl_lint_pass!(DisallowedNames => [DISALLOWED_NAMES]);
+
+impl<'tcx> LateLintPass<'tcx> for DisallowedNames {
+    fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
+        if is_test_module_or_function(cx.tcx, item) {
+            self.test_modules_deep = self.test_modules_deep.saturating_add(1);
+        }
+    }
+
+    fn check_pat(&mut self, cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>) {
+        // Check whether we are under the `test` attribute.
+        if self.in_test_module() {
+            return;
+        }
+
+        if let PatKind::Binding(.., ident, _) = pat.kind {
+            if self.disallow.contains(&ident.name.to_string()) {
+                span_lint(
+                    cx,
+                    DISALLOWED_NAMES,
+                    ident.span,
+                    &format!("use of a disallowed/placeholder name `{}`", ident.name),
+                );
+            }
+        }
+    }
+
+    fn check_item_post(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
+        if is_test_module_or_function(cx.tcx, item) {
+            self.test_modules_deep = self.test_modules_deep.saturating_sub(1);
+        }
+    }
+}
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index d8b6aa9793f..cb33b3b3279 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -46,7 +46,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(derive::DERIVE_ORD_XOR_PARTIAL_ORD),
     LintId::of(derive::DERIVE_PARTIAL_EQ_WITHOUT_EQ),
     LintId::of(disallowed_methods::DISALLOWED_METHODS),
-    LintId::of(disallowed_name::DISALLOWED_NAME),
+    LintId::of(disallowed_names::DISALLOWED_NAMES),
     LintId::of(disallowed_types::DISALLOWED_TYPES),
     LintId::of(doc::MISSING_SAFETY_DOC),
     LintId::of(doc::NEEDLESS_DOCTEST_MAIN),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 562c755d10f..430b8585f6d 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -115,7 +115,7 @@ store.register_lints(&[
     derive::EXPL_IMPL_CLONE_ON_COPY,
     derive::UNSAFE_DERIVE_DESERIALIZE,
     disallowed_methods::DISALLOWED_METHODS,
-    disallowed_name::DISALLOWED_NAME,
+    disallowed_names::DISALLOWED_NAMES,
     disallowed_script_idents::DISALLOWED_SCRIPT_IDENTS,
     disallowed_types::DISALLOWED_TYPES,
     doc::DOC_MARKDOWN,
diff --git a/clippy_lints/src/lib.register_style.rs b/clippy_lints/src/lib.register_style.rs
index 615a86a27e5..31852881615 100644
--- a/clippy_lints/src/lib.register_style.rs
+++ b/clippy_lints/src/lib.register_style.rs
@@ -17,7 +17,7 @@ store.register_group(true, "clippy::style", Some("clippy_style"), vec![
     LintId::of(dereference::NEEDLESS_BORROW),
     LintId::of(derive::DERIVE_PARTIAL_EQ_WITHOUT_EQ),
     LintId::of(disallowed_methods::DISALLOWED_METHODS),
-    LintId::of(disallowed_name::DISALLOWED_NAME),
+    LintId::of(disallowed_names::DISALLOWED_NAMES),
     LintId::of(disallowed_types::DISALLOWED_TYPES),
     LintId::of(doc::MISSING_SAFETY_DOC),
     LintId::of(doc::NEEDLESS_DOCTEST_MAIN),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index ca398038f3e..6ebf1983156 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -204,7 +204,7 @@ mod dereference;
 mod derivable_impls;
 mod derive;
 mod disallowed_methods;
-mod disallowed_name;
+mod disallowed_names;
 mod disallowed_script_idents;
 mod disallowed_types;
 mod doc;
@@ -684,7 +684,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(overflow_check_conditional::OverflowCheckConditional));
     store.register_late_pass(|| Box::new(new_without_default::NewWithoutDefault::default()));
     let disallowed_names = conf.disallowed_names.iter().cloned().collect::<FxHashSet<_>>();
-    store.register_late_pass(move || Box::new(disallowed_name::DisallowedName::new(disallowed_names.clone())));
+    store.register_late_pass(move || Box::new(disallowed_names::DisallowedNames::new(disallowed_names.clone())));
     let too_many_arguments_threshold = conf.too_many_arguments_threshold;
     let too_many_lines_threshold = conf.too_many_lines_threshold;
     store.register_late_pass(move || {
diff --git a/clippy_lints/src/renamed_lints.rs b/clippy_lints/src/renamed_lints.rs
index f06af29e1e2..be16bd64132 100644
--- a/clippy_lints/src/renamed_lints.rs
+++ b/clippy_lints/src/renamed_lints.rs
@@ -5,7 +5,7 @@ pub static RENAMED_LINTS: &[(&str, &str)] = &[
     ("clippy::block_in_if_condition_expr", "clippy::blocks_in_if_conditions"),
     ("clippy::block_in_if_condition_stmt", "clippy::blocks_in_if_conditions"),
     ("clippy::box_vec", "clippy::box_collection"),
-    ("clippy::blacklisted_name", "clippy::disallowed_name"),
+    ("clippy::blacklisted_name", "clippy::disallowed_names"),
     ("clippy::const_static_lifetime", "clippy::redundant_static_lifetimes"),
     ("clippy::cyclomatic_complexity", "clippy::cognitive_complexity"),
     ("clippy::disallowed_method", "clippy::disallowed_methods"),
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 5a3fe7f8966..3faae9ac0d2 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -231,7 +231,7 @@ define_Conf! {
     /// Use the Cognitive Complexity lint instead.
     #[conf_deprecated("Please use `cognitive-complexity-threshold` instead", cognitive_complexity_threshold)]
     (cyclomatic_complexity_threshold: u64 = 25),
-    /// Lint: DISALLOWED_NAME.
+    /// Lint: DISALLOWED_NAMES.
     ///
     /// The list of disallowed names to lint about. NB: `bar` is not here since it has legitimate uses. The value
     /// `".."` can be used as part of the list to indicate, that the configured values should be appended to the
diff --git a/tests/ui-toml/disallowed_names_append/disallowed_names.rs b/tests/ui-toml/disallowed_names_append/disallowed_names.rs
index 939d48cb677..a2e2b46c426 100644
--- a/tests/ui-toml/disallowed_names_append/disallowed_names.rs
+++ b/tests/ui-toml/disallowed_names_append/disallowed_names.rs
@@ -1,4 +1,4 @@
-#[warn(clippy::disallowed_name)]
+#[warn(clippy::disallowed_names)]
 
 fn main() {
     // `foo` is part of the default configuration
diff --git a/tests/ui-toml/disallowed_names_append/disallowed_names.stderr b/tests/ui-toml/disallowed_names_append/disallowed_names.stderr
index d59872b0cb3..23c3e96a8d0 100644
--- a/tests/ui-toml/disallowed_names_append/disallowed_names.stderr
+++ b/tests/ui-toml/disallowed_names_append/disallowed_names.stderr
@@ -4,7 +4,7 @@ error: use of a disallowed/placeholder name `foo`
 LL |     let foo = "bar";
    |         ^^^
    |
-   = note: `-D clippy::disallowed-name` implied by `-D warnings`
+   = note: `-D clippy::disallowed-names` implied by `-D warnings`
 
 error: use of a disallowed/placeholder name `ducks`
   --> $DIR/disallowed_names.rs:7:9
diff --git a/tests/ui-toml/disallowed_names_replace/disallowed_names.rs b/tests/ui-toml/disallowed_names_replace/disallowed_names.rs
index 939d48cb677..a2e2b46c426 100644
--- a/tests/ui-toml/disallowed_names_replace/disallowed_names.rs
+++ b/tests/ui-toml/disallowed_names_replace/disallowed_names.rs
@@ -1,4 +1,4 @@
-#[warn(clippy::disallowed_name)]
+#[warn(clippy::disallowed_names)]
 
 fn main() {
     // `foo` is part of the default configuration
diff --git a/tests/ui-toml/disallowed_names_replace/disallowed_names.stderr b/tests/ui-toml/disallowed_names_replace/disallowed_names.stderr
index 26f98bbb82d..d961fa34074 100644
--- a/tests/ui-toml/disallowed_names_replace/disallowed_names.stderr
+++ b/tests/ui-toml/disallowed_names_replace/disallowed_names.stderr
@@ -4,7 +4,7 @@ error: use of a disallowed/placeholder name `ducks`
 LL |     let ducks = ["quack", "quack"];
    |         ^^^^^
    |
-   = note: `-D clippy::disallowed-name` implied by `-D warnings`
+   = note: `-D clippy::disallowed-names` implied by `-D warnings`
 
 error: aborting due to previous error
 
diff --git a/tests/ui-toml/toml_disallow/conf_french_disallowed_name.rs b/tests/ui-toml/toml_disallow/conf_french_disallowed_name.rs
index 897daee0fa6..2f86b3eda4c 100644
--- a/tests/ui-toml/toml_disallow/conf_french_disallowed_name.rs
+++ b/tests/ui-toml/toml_disallow/conf_french_disallowed_name.rs
@@ -1,7 +1,7 @@
 #![allow(dead_code)]
 #![allow(clippy::single_match)]
 #![allow(unused_variables)]
-#![warn(clippy::disallowed_name)]
+#![warn(clippy::disallowed_names)]
 
 fn test(toto: ()) {}
 
diff --git a/tests/ui-toml/toml_disallow/conf_french_disallowed_name.stderr b/tests/ui-toml/toml_disallow/conf_french_disallowed_name.stderr
index b9a15043f2d..9082c1c54c3 100644
--- a/tests/ui-toml/toml_disallow/conf_french_disallowed_name.stderr
+++ b/tests/ui-toml/toml_disallow/conf_french_disallowed_name.stderr
@@ -4,7 +4,7 @@ error: use of a disallowed/placeholder name `toto`
 LL | fn test(toto: ()) {}
    |         ^^^^
    |
-   = note: `-D clippy::disallowed-name` implied by `-D warnings`
+   = note: `-D clippy::disallowed-names` implied by `-D warnings`
 
 error: use of a disallowed/placeholder name `toto`
   --> $DIR/conf_french_disallowed_name.rs:9:9
diff --git a/tests/ui/borrow_box.rs b/tests/ui/borrow_box.rs
index 2a4f8b53e8b..35ed87b0f18 100644
--- a/tests/ui/borrow_box.rs
+++ b/tests/ui/borrow_box.rs
@@ -1,5 +1,5 @@
 #![deny(clippy::borrowed_box)]
-#![allow(clippy::disallowed_name)]
+#![allow(clippy::disallowed_names)]
 #![allow(unused_variables)]
 #![allow(dead_code)]
 
diff --git a/tests/ui/box_collection.rs b/tests/ui/box_collection.rs
index 690ed905cdd..0780c8f0586 100644
--- a/tests/ui/box_collection.rs
+++ b/tests/ui/box_collection.rs
@@ -1,5 +1,10 @@
 #![warn(clippy::all)]
-#![allow(clippy::boxed_local, clippy::needless_pass_by_value, clippy::disallowed_name, unused)]
+#![allow(
+    clippy::boxed_local,
+    clippy::needless_pass_by_value,
+    clippy::disallowed_names,
+    unused
+)]
 
 use std::collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, LinkedList, VecDeque};
 
diff --git a/tests/ui/box_collection.stderr b/tests/ui/box_collection.stderr
index 4a559e616d1..2b28598ded9 100644
--- a/tests/ui/box_collection.stderr
+++ b/tests/ui/box_collection.stderr
@@ -1,5 +1,5 @@
 error: you seem to be trying to use `Box<Vec<..>>`. Consider using just `Vec<..>`
-  --> $DIR/box_collection.rs:16:15
+  --> $DIR/box_collection.rs:21:15
    |
 LL | fn test1(foo: Box<Vec<bool>>) {}
    |               ^^^^^^^^^^^^^^
@@ -8,7 +8,7 @@ LL | fn test1(foo: Box<Vec<bool>>) {}
    = help: `Vec<..>` is already on the heap, `Box<Vec<..>>` makes an extra allocation
 
 error: you seem to be trying to use `Box<String>`. Consider using just `String`
-  --> $DIR/box_collection.rs:23:15
+  --> $DIR/box_collection.rs:28:15
    |
 LL | fn test3(foo: Box<String>) {}
    |               ^^^^^^^^^^^
@@ -16,7 +16,7 @@ LL | fn test3(foo: Box<String>) {}
    = help: `String` is already on the heap, `Box<String>` makes an extra allocation
 
 error: you seem to be trying to use `Box<HashMap<..>>`. Consider using just `HashMap<..>`
-  --> $DIR/box_collection.rs:25:15
+  --> $DIR/box_collection.rs:30:15
    |
 LL | fn test4(foo: Box<HashMap<String, String>>) {}
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -24,7 +24,7 @@ LL | fn test4(foo: Box<HashMap<String, String>>) {}
    = help: `HashMap<..>` is already on the heap, `Box<HashMap<..>>` makes an extra allocation
 
 error: you seem to be trying to use `Box<HashSet<..>>`. Consider using just `HashSet<..>`
-  --> $DIR/box_collection.rs:27:15
+  --> $DIR/box_collection.rs:32:15
    |
 LL | fn test5(foo: Box<HashSet<i64>>) {}
    |               ^^^^^^^^^^^^^^^^^
@@ -32,7 +32,7 @@ LL | fn test5(foo: Box<HashSet<i64>>) {}
    = help: `HashSet<..>` is already on the heap, `Box<HashSet<..>>` makes an extra allocation
 
 error: you seem to be trying to use `Box<VecDeque<..>>`. Consider using just `VecDeque<..>`
-  --> $DIR/box_collection.rs:29:15
+  --> $DIR/box_collection.rs:34:15
    |
 LL | fn test6(foo: Box<VecDeque<i32>>) {}
    |               ^^^^^^^^^^^^^^^^^^
@@ -40,7 +40,7 @@ LL | fn test6(foo: Box<VecDeque<i32>>) {}
    = help: `VecDeque<..>` is already on the heap, `Box<VecDeque<..>>` makes an extra allocation
 
 error: you seem to be trying to use `Box<LinkedList<..>>`. Consider using just `LinkedList<..>`
-  --> $DIR/box_collection.rs:31:15
+  --> $DIR/box_collection.rs:36:15
    |
 LL | fn test7(foo: Box<LinkedList<i16>>) {}
    |               ^^^^^^^^^^^^^^^^^^^^
@@ -48,7 +48,7 @@ LL | fn test7(foo: Box<LinkedList<i16>>) {}
    = help: `LinkedList<..>` is already on the heap, `Box<LinkedList<..>>` makes an extra allocation
 
 error: you seem to be trying to use `Box<BTreeMap<..>>`. Consider using just `BTreeMap<..>`
-  --> $DIR/box_collection.rs:33:15
+  --> $DIR/box_collection.rs:38:15
    |
 LL | fn test8(foo: Box<BTreeMap<i8, String>>) {}
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -56,7 +56,7 @@ LL | fn test8(foo: Box<BTreeMap<i8, String>>) {}
    = help: `BTreeMap<..>` is already on the heap, `Box<BTreeMap<..>>` makes an extra allocation
 
 error: you seem to be trying to use `Box<BTreeSet<..>>`. Consider using just `BTreeSet<..>`
-  --> $DIR/box_collection.rs:35:15
+  --> $DIR/box_collection.rs:40:15
    |
 LL | fn test9(foo: Box<BTreeSet<u64>>) {}
    |               ^^^^^^^^^^^^^^^^^^
@@ -64,7 +64,7 @@ LL | fn test9(foo: Box<BTreeSet<u64>>) {}
    = help: `BTreeSet<..>` is already on the heap, `Box<BTreeSet<..>>` makes an extra allocation
 
 error: you seem to be trying to use `Box<BinaryHeap<..>>`. Consider using just `BinaryHeap<..>`
-  --> $DIR/box_collection.rs:37:16
+  --> $DIR/box_collection.rs:42:16
    |
 LL | fn test10(foo: Box<BinaryHeap<u32>>) {}
    |                ^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/crashes/ice-2760.rs b/tests/ui/crashes/ice-2760.rs
index 4504d311385..61ef2480498 100644
--- a/tests/ui/crashes/ice-2760.rs
+++ b/tests/ui/crashes/ice-2760.rs
@@ -1,4 +1,9 @@
-#![allow(unused_variables, clippy::disallowed_name, clippy::needless_pass_by_value, dead_code)]
+#![allow(
+    unused_variables,
+    clippy::disallowed_names,
+    clippy::needless_pass_by_value,
+    dead_code
+)]
 
 /// This should not compile-fail with:
 ///
diff --git a/tests/ui/crashes/ice-3462.rs b/tests/ui/crashes/ice-3462.rs
index a7d9017bc68..b402052882a 100644
--- a/tests/ui/crashes/ice-3462.rs
+++ b/tests/ui/crashes/ice-3462.rs
@@ -1,5 +1,5 @@
 #![warn(clippy::all)]
-#![allow(clippy::disallowed_name, clippy::equatable_if_let)]
+#![allow(clippy::disallowed_names, clippy::equatable_if_let)]
 #![allow(unused)]
 
 /// Test for https://github.com/rust-lang/rust-clippy/issues/3462
diff --git a/tests/ui/crashes/regressions.rs b/tests/ui/crashes/regressions.rs
index 86985391fc0..55a8b403407 100644
--- a/tests/ui/crashes/regressions.rs
+++ b/tests/ui/crashes/regressions.rs
@@ -1,4 +1,4 @@
-#![allow(clippy::disallowed_name)]
+#![allow(clippy::disallowed_names)]
 
 pub fn foo(bar: *const u8) {
     println!("{:#p}", bar);
diff --git a/tests/ui/disallowed_name.rs b/tests/ui/disallowed_name.rs
deleted file mode 100644
index 17acc8533e0..00000000000
--- a/tests/ui/disallowed_name.rs
+++ /dev/null
@@ -1,57 +0,0 @@
-#![allow(
-    dead_code,
-    clippy::similar_names,
-    clippy::single_match,
-    clippy::toplevel_ref_arg,
-    unused_mut,
-    unused_variables
-)]
-#![warn(clippy::disallowed_name)]
-
-fn test(foo: ()) {}
-
-fn main() {
-    let foo = 42;
-    let baz = 42;
-    let quux = 42;
-    // Unlike these others, `bar` is actually considered an acceptable name.
-    // Among many other legitimate uses, bar commonly refers to a period of time in music.
-    // See https://github.com/rust-lang/rust-clippy/issues/5225.
-    let bar = 42;
-
-    let food = 42;
-    let foodstuffs = 42;
-    let bazaar = 42;
-
-    match (42, Some(1337), Some(0)) {
-        (foo, Some(baz), quux @ Some(_)) => (),
-        _ => (),
-    }
-}
-
-fn issue_1647(mut foo: u8) {
-    let mut baz = 0;
-    if let Some(mut quux) = Some(42) {}
-}
-
-fn issue_1647_ref() {
-    let ref baz = 0;
-    if let Some(ref quux) = Some(42) {}
-}
-
-fn issue_1647_ref_mut() {
-    let ref mut baz = 0;
-    if let Some(ref mut quux) = Some(42) {}
-}
-
-mod tests {
-    fn issue_7305() {
-        // `disallowed_name` lint should not be triggered inside of the test code.
-        let foo = 0;
-
-        // Check that even in nested functions warning is still not triggered.
-        fn nested() {
-            let foo = 0;
-        }
-    }
-}
diff --git a/tests/ui/disallowed_name.stderr b/tests/ui/disallowed_name.stderr
deleted file mode 100644
index 240c167e223..00000000000
--- a/tests/ui/disallowed_name.stderr
+++ /dev/null
@@ -1,88 +0,0 @@
-error: use of a disallowed/placeholder name `foo`
-  --> $DIR/disallowed_name.rs:11:9
-   |
-LL | fn test(foo: ()) {}
-   |         ^^^
-   |
-   = note: `-D clippy::disallowed-name` implied by `-D warnings`
-
-error: use of a disallowed/placeholder name `foo`
-  --> $DIR/disallowed_name.rs:14:9
-   |
-LL |     let foo = 42;
-   |         ^^^
-
-error: use of a disallowed/placeholder name `baz`
-  --> $DIR/disallowed_name.rs:15:9
-   |
-LL |     let baz = 42;
-   |         ^^^
-
-error: use of a disallowed/placeholder name `quux`
-  --> $DIR/disallowed_name.rs:16:9
-   |
-LL |     let quux = 42;
-   |         ^^^^
-
-error: use of a disallowed/placeholder name `foo`
-  --> $DIR/disallowed_name.rs:27:10
-   |
-LL |         (foo, Some(baz), quux @ Some(_)) => (),
-   |          ^^^
-
-error: use of a disallowed/placeholder name `baz`
-  --> $DIR/disallowed_name.rs:27:20
-   |
-LL |         (foo, Some(baz), quux @ Some(_)) => (),
-   |                    ^^^
-
-error: use of a disallowed/placeholder name `quux`
-  --> $DIR/disallowed_name.rs:27:26
-   |
-LL |         (foo, Some(baz), quux @ Some(_)) => (),
-   |                          ^^^^
-
-error: use of a disallowed/placeholder name `foo`
-  --> $DIR/disallowed_name.rs:32:19
-   |
-LL | fn issue_1647(mut foo: u8) {
-   |                   ^^^
-
-error: use of a disallowed/placeholder name `baz`
-  --> $DIR/disallowed_name.rs:33:13
-   |
-LL |     let mut baz = 0;
-   |             ^^^
-
-error: use of a disallowed/placeholder name `quux`
-  --> $DIR/disallowed_name.rs:34:21
-   |
-LL |     if let Some(mut quux) = Some(42) {}
-   |                     ^^^^
-
-error: use of a disallowed/placeholder name `baz`
-  --> $DIR/disallowed_name.rs:38:13
-   |
-LL |     let ref baz = 0;
-   |             ^^^
-
-error: use of a disallowed/placeholder name `quux`
-  --> $DIR/disallowed_name.rs:39:21
-   |
-LL |     if let Some(ref quux) = Some(42) {}
-   |                     ^^^^
-
-error: use of a disallowed/placeholder name `baz`
-  --> $DIR/disallowed_name.rs:43:17
-   |
-LL |     let ref mut baz = 0;
-   |                 ^^^
-
-error: use of a disallowed/placeholder name `quux`
-  --> $DIR/disallowed_name.rs:44:25
-   |
-LL |     if let Some(ref mut quux) = Some(42) {}
-   |                         ^^^^
-
-error: aborting due to 14 previous errors
-
diff --git a/tests/ui/disallowed_names.rs b/tests/ui/disallowed_names.rs
new file mode 100644
index 00000000000..e937c49f389
--- /dev/null
+++ b/tests/ui/disallowed_names.rs
@@ -0,0 +1,57 @@
+#![allow(
+    dead_code,
+    clippy::similar_names,
+    clippy::single_match,
+    clippy::toplevel_ref_arg,
+    unused_mut,
+    unused_variables
+)]
+#![warn(clippy::disallowed_names)]
+
+fn test(foo: ()) {}
+
+fn main() {
+    let foo = 42;
+    let baz = 42;
+    let quux = 42;
+    // Unlike these others, `bar` is actually considered an acceptable name.
+    // Among many other legitimate uses, bar commonly refers to a period of time in music.
+    // See https://github.com/rust-lang/rust-clippy/issues/5225.
+    let bar = 42;
+
+    let food = 42;
+    let foodstuffs = 42;
+    let bazaar = 42;
+
+    match (42, Some(1337), Some(0)) {
+        (foo, Some(baz), quux @ Some(_)) => (),
+        _ => (),
+    }
+}
+
+fn issue_1647(mut foo: u8) {
+    let mut baz = 0;
+    if let Some(mut quux) = Some(42) {}
+}
+
+fn issue_1647_ref() {
+    let ref baz = 0;
+    if let Some(ref quux) = Some(42) {}
+}
+
+fn issue_1647_ref_mut() {
+    let ref mut baz = 0;
+    if let Some(ref mut quux) = Some(42) {}
+}
+
+mod tests {
+    fn issue_7305() {
+        // `disallowed_names` lint should not be triggered inside of the test code.
+        let foo = 0;
+
+        // Check that even in nested functions warning is still not triggered.
+        fn nested() {
+            let foo = 0;
+        }
+    }
+}
diff --git a/tests/ui/disallowed_names.stderr b/tests/ui/disallowed_names.stderr
new file mode 100644
index 00000000000..78cb55096ff
--- /dev/null
+++ b/tests/ui/disallowed_names.stderr
@@ -0,0 +1,88 @@
+error: use of a disallowed/placeholder name `foo`
+  --> $DIR/disallowed_names.rs:11:9
+   |
+LL | fn test(foo: ()) {}
+   |         ^^^
+   |
+   = note: `-D clippy::disallowed-names` implied by `-D warnings`
+
+error: use of a disallowed/placeholder name `foo`
+  --> $DIR/disallowed_names.rs:14:9
+   |
+LL |     let foo = 42;
+   |         ^^^
+
+error: use of a disallowed/placeholder name `baz`
+  --> $DIR/disallowed_names.rs:15:9
+   |
+LL |     let baz = 42;
+   |         ^^^
+
+error: use of a disallowed/placeholder name `quux`
+  --> $DIR/disallowed_names.rs:16:9
+   |
+LL |     let quux = 42;
+   |         ^^^^
+
+error: use of a disallowed/placeholder name `foo`
+  --> $DIR/disallowed_names.rs:27:10
+   |
+LL |         (foo, Some(baz), quux @ Some(_)) => (),
+   |          ^^^
+
+error: use of a disallowed/placeholder name `baz`
+  --> $DIR/disallowed_names.rs:27:20
+   |
+LL |         (foo, Some(baz), quux @ Some(_)) => (),
+   |                    ^^^
+
+error: use of a disallowed/placeholder name `quux`
+  --> $DIR/disallowed_names.rs:27:26
+   |
+LL |         (foo, Some(baz), quux @ Some(_)) => (),
+   |                          ^^^^
+
+error: use of a disallowed/placeholder name `foo`
+  --> $DIR/disallowed_names.rs:32:19
+   |
+LL | fn issue_1647(mut foo: u8) {
+   |                   ^^^
+
+error: use of a disallowed/placeholder name `baz`
+  --> $DIR/disallowed_names.rs:33:13
+   |
+LL |     let mut baz = 0;
+   |             ^^^
+
+error: use of a disallowed/placeholder name `quux`
+  --> $DIR/disallowed_names.rs:34:21
+   |
+LL |     if let Some(mut quux) = Some(42) {}
+   |                     ^^^^
+
+error: use of a disallowed/placeholder name `baz`
+  --> $DIR/disallowed_names.rs:38:13
+   |
+LL |     let ref baz = 0;
+   |             ^^^
+
+error: use of a disallowed/placeholder name `quux`
+  --> $DIR/disallowed_names.rs:39:21
+   |
+LL |     if let Some(ref quux) = Some(42) {}
+   |                     ^^^^
+
+error: use of a disallowed/placeholder name `baz`
+  --> $DIR/disallowed_names.rs:43:17
+   |
+LL |     let ref mut baz = 0;
+   |                 ^^^
+
+error: use of a disallowed/placeholder name `quux`
+  --> $DIR/disallowed_names.rs:44:25
+   |
+LL |     if let Some(ref mut quux) = Some(42) {}
+   |                         ^^^^
+
+error: aborting due to 14 previous errors
+
diff --git a/tests/ui/if_same_then_else.rs b/tests/ui/if_same_then_else.rs
index dd25008cbbe..07d2002eb27 100644
--- a/tests/ui/if_same_then_else.rs
+++ b/tests/ui/if_same_then_else.rs
@@ -1,6 +1,6 @@
 #![warn(clippy::if_same_then_else)]
 #![allow(
-    clippy::disallowed_name,
+    clippy::disallowed_names,
     clippy::eq_op,
     clippy::never_loop,
     clippy::no_effect,
diff --git a/tests/ui/if_same_then_else2.rs b/tests/ui/if_same_then_else2.rs
index 8b643c48914..58167f4446d 100644
--- a/tests/ui/if_same_then_else2.rs
+++ b/tests/ui/if_same_then_else2.rs
@@ -1,6 +1,6 @@
 #![warn(clippy::if_same_then_else)]
 #![allow(
-    clippy::disallowed_name,
+    clippy::disallowed_names,
     clippy::collapsible_else_if,
     clippy::equatable_if_let,
     clippy::collapsible_if,
diff --git a/tests/ui/iter_skip_next.fixed b/tests/ui/iter_skip_next.fixed
index 2cb89665411..d56d623b526 100644
--- a/tests/ui/iter_skip_next.fixed
+++ b/tests/ui/iter_skip_next.fixed
@@ -2,7 +2,7 @@
 // aux-build:option_helpers.rs
 
 #![warn(clippy::iter_skip_next)]
-#![allow(clippy::disallowed_name)]
+#![allow(clippy::disallowed_names)]
 #![allow(clippy::iter_nth)]
 #![allow(unused_mut, dead_code)]
 
diff --git a/tests/ui/iter_skip_next.rs b/tests/ui/iter_skip_next.rs
index 972d1e2b51f..3ec5d1b8214 100644
--- a/tests/ui/iter_skip_next.rs
+++ b/tests/ui/iter_skip_next.rs
@@ -2,7 +2,7 @@
 // aux-build:option_helpers.rs
 
 #![warn(clippy::iter_skip_next)]
-#![allow(clippy::disallowed_name)]
+#![allow(clippy::disallowed_names)]
 #![allow(clippy::iter_nth)]
 #![allow(unused_mut, dead_code)]
 
diff --git a/tests/ui/let_if_seq.rs b/tests/ui/let_if_seq.rs
index ee351880b80..959567f6867 100644
--- a/tests/ui/let_if_seq.rs
+++ b/tests/ui/let_if_seq.rs
@@ -2,7 +2,7 @@
     unused_variables,
     unused_assignments,
     clippy::similar_names,
-    clippy::disallowed_name,
+    clippy::disallowed_names,
     clippy::branches_sharing_code,
     clippy::needless_late_init
 )]
diff --git a/tests/ui/manual_ok_or.fixed b/tests/ui/manual_ok_or.fixed
index 9ee71bf9090..d864f855453 100644
--- a/tests/ui/manual_ok_or.fixed
+++ b/tests/ui/manual_ok_or.fixed
@@ -1,6 +1,6 @@
 // run-rustfix
 #![warn(clippy::manual_ok_or)]
-#![allow(clippy::disallowed_name)]
+#![allow(clippy::disallowed_names)]
 #![allow(clippy::redundant_closure)]
 #![allow(dead_code)]
 #![allow(unused_must_use)]
diff --git a/tests/ui/manual_ok_or.rs b/tests/ui/manual_ok_or.rs
index 0e1bc085769..6264768460e 100644
--- a/tests/ui/manual_ok_or.rs
+++ b/tests/ui/manual_ok_or.rs
@@ -1,6 +1,6 @@
 // run-rustfix
 #![warn(clippy::manual_ok_or)]
-#![allow(clippy::disallowed_name)]
+#![allow(clippy::disallowed_names)]
 #![allow(clippy::redundant_closure)]
 #![allow(dead_code)]
 #![allow(unused_must_use)]
diff --git a/tests/ui/match_same_arms2.rs b/tests/ui/match_same_arms2.rs
index 086e3e9b805..61793e80c98 100644
--- a/tests/ui/match_same_arms2.rs
+++ b/tests/ui/match_same_arms2.rs
@@ -1,5 +1,5 @@
 #![warn(clippy::match_same_arms)]
-#![allow(clippy::disallowed_name, clippy::diverging_sub_expression)]
+#![allow(clippy::disallowed_names, clippy::diverging_sub_expression)]
 
 fn bar<T>(_: T) {}
 fn foo() -> bool {
diff --git a/tests/ui/methods.rs b/tests/ui/methods.rs
index 8d782f73821..6f22366eab2 100644
--- a/tests/ui/methods.rs
+++ b/tests/ui/methods.rs
@@ -2,7 +2,7 @@
 
 #![warn(clippy::all, clippy::pedantic)]
 #![allow(
-    clippy::disallowed_name,
+    clippy::disallowed_names,
     clippy::default_trait_access,
     clippy::missing_docs_in_private_items,
     clippy::missing_safety_doc,
diff --git a/tests/ui/mismatching_type_param_order.rs b/tests/ui/mismatching_type_param_order.rs
index c2195bf18d1..40c1fcae1fd 100644
--- a/tests/ui/mismatching_type_param_order.rs
+++ b/tests/ui/mismatching_type_param_order.rs
@@ -1,5 +1,5 @@
 #![warn(clippy::mismatching_type_param_order)]
-#![allow(clippy::disallowed_name)]
+#![allow(clippy::disallowed_names)]
 
 fn main() {
     struct Foo<A, B> {
diff --git a/tests/ui/mixed_read_write_in_expression.rs b/tests/ui/mixed_read_write_in_expression.rs
index 6e413fcf5bb..6efc7657ec0 100644
--- a/tests/ui/mixed_read_write_in_expression.rs
+++ b/tests/ui/mixed_read_write_in_expression.rs
@@ -4,7 +4,7 @@
     unused_variables,
     clippy::no_effect,
     dead_code,
-    clippy::disallowed_name
+    clippy::disallowed_names
 )]
 fn main() {
     let mut x = 0;
diff --git a/tests/ui/op_ref.rs b/tests/ui/op_ref.rs
index 8e53f2073e5..07226b0a1a8 100644
--- a/tests/ui/op_ref.rs
+++ b/tests/ui/op_ref.rs
@@ -1,4 +1,4 @@
-#![allow(unused_variables, clippy::disallowed_name)]
+#![allow(unused_variables, clippy::disallowed_names)]
 #![warn(clippy::op_ref)]
 use std::collections::HashSet;
 use std::ops::{BitAnd, Mul};
diff --git a/tests/ui/rc_mutex.rs b/tests/ui/rc_mutex.rs
index ee707a630fa..432972bbc31 100644
--- a/tests/ui/rc_mutex.rs
+++ b/tests/ui/rc_mutex.rs
@@ -1,5 +1,5 @@
 #![warn(clippy::rc_mutex)]
-#![allow(unused, clippy::disallowed_name)]
+#![allow(unused, clippy::disallowed_names)]
 
 use std::rc::Rc;
 use std::sync::Mutex;
diff --git a/tests/ui/redundant_allocation.rs b/tests/ui/redundant_allocation.rs
index 7b9e02f974c..9f2b1f4a281 100644
--- a/tests/ui/redundant_allocation.rs
+++ b/tests/ui/redundant_allocation.rs
@@ -1,6 +1,6 @@
 #![warn(clippy::all)]
 #![allow(clippy::boxed_local, clippy::needless_pass_by_value)]
-#![allow(clippy::disallowed_name, unused_variables, dead_code)]
+#![allow(clippy::disallowed_names, unused_variables, dead_code)]
 #![allow(unused_imports)]
 
 pub struct MyStruct;
diff --git a/tests/ui/redundant_allocation_fixable.fixed b/tests/ui/redundant_allocation_fixable.fixed
index 4c85b20afe5..6db02718c70 100644
--- a/tests/ui/redundant_allocation_fixable.fixed
+++ b/tests/ui/redundant_allocation_fixable.fixed
@@ -1,7 +1,7 @@
 // run-rustfix
 #![warn(clippy::all)]
 #![allow(clippy::boxed_local, clippy::needless_pass_by_value)]
-#![allow(clippy::disallowed_name, unused_variables, dead_code)]
+#![allow(clippy::disallowed_names, unused_variables, dead_code)]
 #![allow(unused_imports)]
 
 pub struct MyStruct;
diff --git a/tests/ui/redundant_allocation_fixable.rs b/tests/ui/redundant_allocation_fixable.rs
index 8b402e47873..c15806f30c0 100644
--- a/tests/ui/redundant_allocation_fixable.rs
+++ b/tests/ui/redundant_allocation_fixable.rs
@@ -1,7 +1,7 @@
 // run-rustfix
 #![warn(clippy::all)]
 #![allow(clippy::boxed_local, clippy::needless_pass_by_value)]
-#![allow(clippy::disallowed_name, unused_variables, dead_code)]
+#![allow(clippy::disallowed_names, unused_variables, dead_code)]
 #![allow(unused_imports)]
 
 pub struct MyStruct;
diff --git a/tests/ui/rename.fixed b/tests/ui/rename.fixed
index e65327737ce..2a74c6e54f4 100644
--- a/tests/ui/rename.fixed
+++ b/tests/ui/rename.fixed
@@ -6,7 +6,7 @@
 
 #![allow(clippy::blocks_in_if_conditions)]
 #![allow(clippy::box_collection)]
-#![allow(clippy::disallowed_name)]
+#![allow(clippy::disallowed_names)]
 #![allow(clippy::redundant_static_lifetimes)]
 #![allow(clippy::cognitive_complexity)]
 #![allow(clippy::disallowed_methods)]
@@ -37,7 +37,7 @@
 #![warn(clippy::blocks_in_if_conditions)]
 #![warn(clippy::blocks_in_if_conditions)]
 #![warn(clippy::box_collection)]
-#![warn(clippy::disallowed_name)]
+#![warn(clippy::disallowed_names)]
 #![warn(clippy::redundant_static_lifetimes)]
 #![warn(clippy::cognitive_complexity)]
 #![warn(clippy::disallowed_methods)]
diff --git a/tests/ui/rename.rs b/tests/ui/rename.rs
index 8125b153589..fa88af95974 100644
--- a/tests/ui/rename.rs
+++ b/tests/ui/rename.rs
@@ -6,7 +6,7 @@
 
 #![allow(clippy::blocks_in_if_conditions)]
 #![allow(clippy::box_collection)]
-#![allow(clippy::disallowed_name)]
+#![allow(clippy::disallowed_names)]
 #![allow(clippy::redundant_static_lifetimes)]
 #![allow(clippy::cognitive_complexity)]
 #![allow(clippy::disallowed_methods)]
diff --git a/tests/ui/rename.stderr b/tests/ui/rename.stderr
index d2829311059..d510951b121 100644
--- a/tests/ui/rename.stderr
+++ b/tests/ui/rename.stderr
@@ -18,11 +18,11 @@ error: lint `clippy::box_vec` has been renamed to `clippy::box_collection`
 LL | #![warn(clippy::box_vec)]
    |         ^^^^^^^^^^^^^^^ help: use the new name: `clippy::box_collection`
 
-error: lint `clippy::blacklisted_name` has been renamed to `clippy::disallowed_name`
+error: lint `clippy::blacklisted_name` has been renamed to `clippy::disallowed_names`
   --> $DIR/rename.rs:40:9
    |
 LL | #![warn(clippy::blacklisted_name)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::disallowed_name`
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::disallowed_names`
 
 error: lint `clippy::const_static_lifetime` has been renamed to `clippy::redundant_static_lifetimes`
   --> $DIR/rename.rs:41:9
diff --git a/tests/ui/skip_while_next.rs b/tests/ui/skip_while_next.rs
index bedd2704100..a551c19d98b 100644
--- a/tests/ui/skip_while_next.rs
+++ b/tests/ui/skip_while_next.rs
@@ -1,7 +1,7 @@
 // aux-build:option_helpers.rs
 
 #![warn(clippy::skip_while_next)]
-#![allow(clippy::disallowed_name)]
+#![allow(clippy::disallowed_names)]
 
 extern crate option_helpers;
 use option_helpers::IteratorFalsePositives;
diff --git a/tests/ui/swap.fixed b/tests/ui/swap.fixed
index 0865287c08a..24b229235d3 100644
--- a/tests/ui/swap.fixed
+++ b/tests/ui/swap.fixed
@@ -2,7 +2,7 @@
 
 #![warn(clippy::all)]
 #![allow(
-    clippy::disallowed_name,
+    clippy::disallowed_names,
     clippy::no_effect,
     clippy::redundant_clone,
     redundant_semicolons,
diff --git a/tests/ui/swap.rs b/tests/ui/swap.rs
index 8f87c488462..a318c27919c 100644
--- a/tests/ui/swap.rs
+++ b/tests/ui/swap.rs
@@ -2,7 +2,7 @@
 
 #![warn(clippy::all)]
 #![allow(
-    clippy::disallowed_name,
+    clippy::disallowed_names,
     clippy::no_effect,
     clippy::redundant_clone,
     redundant_semicolons,
diff --git a/tests/ui/trivially_copy_pass_by_ref.rs b/tests/ui/trivially_copy_pass_by_ref.rs
index 732b139ea12..c0c64ebcabf 100644
--- a/tests/ui/trivially_copy_pass_by_ref.rs
+++ b/tests/ui/trivially_copy_pass_by_ref.rs
@@ -2,7 +2,7 @@
 // normalize-stderr-test "\(limit: \d+ byte\)" -> "(limit: N byte)"
 
 #![deny(clippy::trivially_copy_pass_by_ref)]
-#![allow(clippy::disallowed_name, clippy::redundant_field_names)]
+#![allow(clippy::disallowed_names, clippy::redundant_field_names)]
 
 #[derive(Copy, Clone)]
 struct Foo(u32);
diff --git a/tests/ui/used_underscore_binding.rs b/tests/ui/used_underscore_binding.rs
index 91c88079363..322083511ac 100644
--- a/tests/ui/used_underscore_binding.rs
+++ b/tests/ui/used_underscore_binding.rs
@@ -2,7 +2,7 @@
 
 #![feature(rustc_private)]
 #![warn(clippy::all)]
-#![allow(clippy::disallowed_name, clippy::eq_op)]
+#![allow(clippy::disallowed_names, clippy::eq_op)]
 #![warn(clippy::used_underscore_binding)]
 
 #[macro_use]
-- 
cgit 1.4.1-3-g733a5


From 23b4fe6da55291a5937535d09af2bdfed8a9a50d Mon Sep 17 00:00:00 2001
From: Sosthene <51865119+sgued@users.noreply.github.com>
Date: Sat, 30 Jul 2022 13:17:51 +0200
Subject: Apply suggestions from code review

The expect_used lint is allow-by-default, so it would be better to show the case where this is enabled.

Co-authored-by: Takayuki Nakata <f.seasons017@gmail.com>
---
 clippy_lints/src/methods/mod.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 06e7af57ee1..5ac6b09f0aa 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -197,7 +197,7 @@ declare_clippy_lint! {
     /// result.unwrap();
     /// ```
     ///
-    /// If [expect_used](#expect_used) is allowed, instead:
+    /// Use instead:
     /// ```rust
     /// # let option = Some(1);
     /// # let result: Result<usize, ()> = Ok(1);
@@ -205,7 +205,7 @@ declare_clippy_lint! {
     /// result.expect("more helpful message");
     /// ```
     ///
-    /// Otherwise try using
+    /// If [expect_used](#expect_used) is enabled, instead:
     /// ```rust,ignore
     /// # let option = Some(1);
     /// # let result: Result<usize, ()> = Ok(1);
-- 
cgit 1.4.1-3-g733a5


From e00ceb99cdee70a30ba15ff490f3c249495c9c03 Mon Sep 17 00:00:00 2001
From: tabokie <xy.tao@outlook.com>
Date: Mon, 1 Aug 2022 13:22:16 +0800
Subject: move [`assertions_on_result_states`] to restriction

Signed-off-by: tabokie <xy.tao@outlook.com>
---
 clippy_lints/src/assertions_on_result_states.rs | 5 ++++-
 clippy_lints/src/lib.register_all.rs            | 1 -
 clippy_lints/src/lib.register_restriction.rs    | 1 +
 clippy_lints/src/lib.register_style.rs          | 1 -
 4 files changed, 5 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/assertions_on_result_states.rs b/clippy_lints/src/assertions_on_result_states.rs
index b6affdee523..4caab623090 100644
--- a/clippy_lints/src/assertions_on_result_states.rs
+++ b/clippy_lints/src/assertions_on_result_states.rs
@@ -19,6 +19,9 @@ declare_clippy_lint! {
     /// ### Why is this bad?
     /// An assertion failure cannot output an useful message of the error.
     ///
+    /// ### Known problems
+    /// The suggested replacement decreases the readability of code and log output.
+    ///
     /// ### Example
     /// ```rust,ignore
     /// # let r = Ok::<_, ()>(());
@@ -28,7 +31,7 @@ declare_clippy_lint! {
     /// ```
     #[clippy::version = "1.64.0"]
     pub ASSERTIONS_ON_RESULT_STATES,
-    style,
+    restriction,
     "`assert!(r.is_ok())`/`assert!(r.is_err())` gives worse error message than directly calling `r.unwrap()`/`r.unwrap_err()`"
 }
 
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index cb33b3b3279..b9cc9fc1e85 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -6,7 +6,6 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(almost_complete_letter_range::ALMOST_COMPLETE_LETTER_RANGE),
     LintId::of(approx_const::APPROX_CONSTANT),
     LintId::of(assertions_on_constants::ASSERTIONS_ON_CONSTANTS),
-    LintId::of(assertions_on_result_states::ASSERTIONS_ON_RESULT_STATES),
     LintId::of(async_yields_async::ASYNC_YIELDS_ASYNC),
     LintId::of(attrs::BLANKET_CLIPPY_RESTRICTION_LINTS),
     LintId::of(attrs::DEPRECATED_CFG_ATTR),
diff --git a/clippy_lints/src/lib.register_restriction.rs b/clippy_lints/src/lib.register_restriction.rs
index 495abd8387e..a7339ef2721 100644
--- a/clippy_lints/src/lib.register_restriction.rs
+++ b/clippy_lints/src/lib.register_restriction.rs
@@ -7,6 +7,7 @@ store.register_group(true, "clippy::restriction", Some("clippy_restriction"), ve
     LintId::of(as_underscore::AS_UNDERSCORE),
     LintId::of(asm_syntax::INLINE_ASM_X86_ATT_SYNTAX),
     LintId::of(asm_syntax::INLINE_ASM_X86_INTEL_SYNTAX),
+    LintId::of(assertions_on_result_states::ASSERTIONS_ON_RESULT_STATES),
     LintId::of(attrs::ALLOW_ATTRIBUTES_WITHOUT_REASON),
     LintId::of(casts::FN_TO_NUMERIC_CAST_ANY),
     LintId::of(create_dir::CREATE_DIR),
diff --git a/clippy_lints/src/lib.register_style.rs b/clippy_lints/src/lib.register_style.rs
index 31852881615..ebc0933e31d 100644
--- a/clippy_lints/src/lib.register_style.rs
+++ b/clippy_lints/src/lib.register_style.rs
@@ -4,7 +4,6 @@
 
 store.register_group(true, "clippy::style", Some("clippy_style"), vec![
     LintId::of(assertions_on_constants::ASSERTIONS_ON_CONSTANTS),
-    LintId::of(assertions_on_result_states::ASSERTIONS_ON_RESULT_STATES),
     LintId::of(blocks_in_if_conditions::BLOCKS_IN_IF_CONDITIONS),
     LintId::of(bool_assert_comparison::BOOL_ASSERT_COMPARISON),
     LintId::of(casts::FN_TO_NUMERIC_CAST),
-- 
cgit 1.4.1-3-g733a5


From 48ad9d8bc7d50fd5ebe90c1bbe760fcb8dc0dc14 Mon Sep 17 00:00:00 2001
From: tabokie <xy.tao@outlook.com>
Date: Mon, 1 Aug 2022 13:30:43 +0800
Subject: do not apply [`assertions_on_result_states`] to unwrap unit type

Signed-off-by: tabokie <xy.tao@outlook.com>
---
 clippy_lints/src/assertions_on_result_states.rs | 11 ++++++++---
 tests/ui/assertions_on_result_states.fixed      |  8 ++++++++
 tests/ui/assertions_on_result_states.rs         |  8 ++++++++
 tests/ui/assertions_on_result_states.stderr     | 10 +++++-----
 4 files changed, 29 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/assertions_on_result_states.rs b/clippy_lints/src/assertions_on_result_states.rs
index 4caab623090..6a6554f968b 100644
--- a/clippy_lints/src/assertions_on_result_states.rs
+++ b/clippy_lints/src/assertions_on_result_states.rs
@@ -53,13 +53,14 @@ impl<'tcx> LateLintPass<'tcx> for AssertionsOnResultStates {
                 if result_type_with_refs != result_type {
                     return;
                 } else if let Res::Local(binding_id) = path_res(cx, recv)
-                    && local_used_after_expr(cx, binding_id, recv) {
+                    && local_used_after_expr(cx, binding_id, recv)
+                {
                     return;
                 }
             }
             let mut app = Applicability::MachineApplicable;
             match method_segment.ident.as_str() {
-                "is_ok" if has_debug_impl(cx, substs.type_at(1)) => {
+                "is_ok" if type_suitable_to_unwrap(cx, substs.type_at(1)) => {
                     span_lint_and_sugg(
                         cx,
                         ASSERTIONS_ON_RESULT_STATES,
@@ -73,7 +74,7 @@ impl<'tcx> LateLintPass<'tcx> for AssertionsOnResultStates {
                         app,
                     );
                 }
-                "is_err" if has_debug_impl(cx, substs.type_at(0)) => {
+                "is_err" if type_suitable_to_unwrap(cx, substs.type_at(0)) => {
                     span_lint_and_sugg(
                         cx,
                         ASSERTIONS_ON_RESULT_STATES,
@@ -99,3 +100,7 @@ fn has_debug_impl<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
         .get_diagnostic_item(sym::Debug)
         .map_or(false, |debug| implements_trait(cx, ty, debug, &[]))
 }
+
+fn type_suitable_to_unwrap<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
+    has_debug_impl(cx, ty) && !ty.is_unit() && !ty.is_never()
+}
diff --git a/tests/ui/assertions_on_result_states.fixed b/tests/ui/assertions_on_result_states.fixed
index 7bde72e4b6b..795f435f24c 100644
--- a/tests/ui/assertions_on_result_states.fixed
+++ b/tests/ui/assertions_on_result_states.fixed
@@ -27,6 +27,14 @@ fn main() {
     let r: Result<Foo, Foo> = Ok(Foo);
     assert!(r.is_ok());
 
+    // test ok with some messages
+    let r: Result<Foo, DebugFoo> = Ok(Foo);
+    assert!(r.is_ok(), "oops");
+
+    // test ok with unit error
+    let r: Result<Foo, ()> = Ok(Foo);
+    assert!(r.is_ok());
+
     // test temporary ok
     fn get_ok() -> Result<Foo, DebugFoo> {
         Ok(Foo)
diff --git a/tests/ui/assertions_on_result_states.rs b/tests/ui/assertions_on_result_states.rs
index 4c5af81efc2..1101aec1e1b 100644
--- a/tests/ui/assertions_on_result_states.rs
+++ b/tests/ui/assertions_on_result_states.rs
@@ -27,6 +27,14 @@ fn main() {
     let r: Result<Foo, Foo> = Ok(Foo);
     assert!(r.is_ok());
 
+    // test ok with some messages
+    let r: Result<Foo, DebugFoo> = Ok(Foo);
+    assert!(r.is_ok(), "oops");
+
+    // test ok with unit error
+    let r: Result<Foo, ()> = Ok(Foo);
+    assert!(r.is_ok());
+
     // test temporary ok
     fn get_ok() -> Result<Foo, DebugFoo> {
         Ok(Foo)
diff --git a/tests/ui/assertions_on_result_states.stderr b/tests/ui/assertions_on_result_states.stderr
index 13c2dd877a9..97a5f3dfca4 100644
--- a/tests/ui/assertions_on_result_states.stderr
+++ b/tests/ui/assertions_on_result_states.stderr
@@ -7,31 +7,31 @@ LL |     assert!(r.is_ok());
    = note: `-D clippy::assertions-on-result-states` implied by `-D warnings`
 
 error: called `assert!` with `Result::is_ok`
-  --> $DIR/assertions_on_result_states.rs:34:5
+  --> $DIR/assertions_on_result_states.rs:42:5
    |
 LL |     assert!(get_ok().is_ok());
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `get_ok().unwrap()`
 
 error: called `assert!` with `Result::is_ok`
-  --> $DIR/assertions_on_result_states.rs:37:5
+  --> $DIR/assertions_on_result_states.rs:45:5
    |
 LL |     assert!(get_ok_macro!().is_ok());
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `get_ok_macro!().unwrap()`
 
 error: called `assert!` with `Result::is_ok`
-  --> $DIR/assertions_on_result_states.rs:50:5
+  --> $DIR/assertions_on_result_states.rs:58:5
    |
 LL |     assert!(r.is_ok());
    |     ^^^^^^^^^^^^^^^^^^ help: replace with: `r.unwrap()`
 
 error: called `assert!` with `Result::is_ok`
-  --> $DIR/assertions_on_result_states.rs:56:9
+  --> $DIR/assertions_on_result_states.rs:64:9
    |
 LL |         assert!(r.is_ok());
    |         ^^^^^^^^^^^^^^^^^^ help: replace with: `r.unwrap()`
 
 error: called `assert!` with `Result::is_err`
-  --> $DIR/assertions_on_result_states.rs:64:5
+  --> $DIR/assertions_on_result_states.rs:72:5
    |
 LL |     assert!(r.is_err());
    |     ^^^^^^^^^^^^^^^^^^^ help: replace with: `r.unwrap_err()`
-- 
cgit 1.4.1-3-g733a5


From 0696624ba789acbe84a2d9e5e76e929fd2511381 Mon Sep 17 00:00:00 2001
From: Federico Guerinoni <guerinoni.federico@gmail.com>
Date: Sat, 30 Jul 2022 14:33:10 +0200
Subject: Add `elapsed_instant` lint

Closes #8603

Signed-off-by: Federico Guerinoni <guerinoni.federico@gmail.com>
---
 CHANGELOG.md                               |  1 +
 clippy_lints/src/lib.register_lints.rs     |  1 +
 clippy_lints/src/lib.register_pedantic.rs  |  1 +
 clippy_lints/src/lib.rs                    |  2 +
 clippy_lints/src/manual_instant_elapsed.rs | 69 ++++++++++++++++++++++++++++++
 clippy_utils/src/paths.rs                  |  2 +
 tests/ui/manual_instant_elapsed.fixed      | 27 ++++++++++++
 tests/ui/manual_instant_elapsed.rs         | 27 ++++++++++++
 tests/ui/manual_instant_elapsed.stderr     | 16 +++++++
 9 files changed, 146 insertions(+)
 create mode 100644 clippy_lints/src/manual_instant_elapsed.rs
 create mode 100644 tests/ui/manual_instant_elapsed.fixed
 create mode 100644 tests/ui/manual_instant_elapsed.rs
 create mode 100644 tests/ui/manual_instant_elapsed.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 646e1128e9a..84f06d98879 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3686,6 +3686,7 @@ Released 2018-09-13
 [`manual_find`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_find
 [`manual_find_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_find_map
 [`manual_flatten`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_flatten
+[`manual_instant_elapsed`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_instant_elapsed
 [`manual_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_map
 [`manual_memcpy`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_memcpy
 [`manual_non_exhaustive`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_non_exhaustive
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 430b8585f6d..c2bc4badc43 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -244,6 +244,7 @@ store.register_lints(&[
     manual_assert::MANUAL_ASSERT,
     manual_async_fn::MANUAL_ASYNC_FN,
     manual_bits::MANUAL_BITS,
+    manual_instant_elapsed::MANUAL_INSTANT_ELAPSED,
     manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE,
     manual_ok_or::MANUAL_OK_OR,
     manual_rem_euclid::MANUAL_REM_EUCLID,
diff --git a/clippy_lints/src/lib.register_pedantic.rs b/clippy_lints/src/lib.register_pedantic.rs
index 4d4b89687d0..4250ee055e6 100644
--- a/clippy_lints/src/lib.register_pedantic.rs
+++ b/clippy_lints/src/lib.register_pedantic.rs
@@ -49,6 +49,7 @@ store.register_group(true, "clippy::pedantic", Some("clippy_pedantic"), vec![
     LintId::of(loops::EXPLICIT_ITER_LOOP),
     LintId::of(macro_use::MACRO_USE_IMPORTS),
     LintId::of(manual_assert::MANUAL_ASSERT),
+    LintId::of(manual_instant_elapsed::MANUAL_INSTANT_ELAPSED),
     LintId::of(manual_ok_or::MANUAL_OK_OR),
     LintId::of(matches::MATCH_BOOL),
     LintId::of(matches::MATCH_ON_VEC_ITEMS),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 6ebf1983156..88c1a727f8d 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -273,6 +273,7 @@ mod main_recursion;
 mod manual_assert;
 mod manual_async_fn;
 mod manual_bits;
+mod manual_instant_elapsed;
 mod manual_non_exhaustive;
 mod manual_ok_or;
 mod manual_rem_euclid;
@@ -929,6 +930,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(move || Box::new(operators::Operators::new(verbose_bit_mask_threshold)));
     store.register_late_pass(|| Box::new(invalid_utf8_in_unchecked::InvalidUtf8InUnchecked));
     store.register_late_pass(|| Box::new(std_instead_of_core::StdReexports::default()));
+    store.register_late_pass(|| Box::new(manual_instant_elapsed::ManualInstantElapsed));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/manual_instant_elapsed.rs b/clippy_lints/src/manual_instant_elapsed.rs
new file mode 100644
index 00000000000..331cda1db89
--- /dev/null
+++ b/clippy_lints/src/manual_instant_elapsed.rs
@@ -0,0 +1,69 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use rustc_errors::Applicability;
+use rustc_hir::{BinOpKind, Expr, ExprKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::source_map::Spanned;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Lints subtraction between `Instant::now()` and another `Instant`.
+    ///
+    /// ### Why is this bad?
+    /// It is easy to accidentally write `prev_instant - Instant::now()`, which will always be 0ns
+    /// as `Instant` subtraction saturates.
+    ///
+    /// `prev_instant.elapsed()` also more clearly signals intention.
+    ///
+    /// ### Example
+    /// ```rust
+    /// use std::time::Instant;
+    /// let prev_instant = Instant::now();
+    /// let duration = Instant::now() - prev_instant;
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// use std::time::Instant;
+    /// let prev_instant = Instant::now();
+    /// let duration = prev_instant.elapsed();
+    /// ```
+    #[clippy::version = "1.64.0"]
+    pub MANUAL_INSTANT_ELAPSED,
+    pedantic,
+    "subtraction between `Instant::now()` and previous `Instant`"
+}
+
+declare_lint_pass!(ManualInstantElapsed => [MANUAL_INSTANT_ELAPSED]);
+
+impl LateLintPass<'_> for ManualInstantElapsed {
+    fn check_expr(&mut self, cx: &LateContext<'_>, expr: &'_ Expr<'_>) {
+        if let ExprKind::Binary(Spanned {node: BinOpKind::Sub, ..}, lhs, rhs) = expr.kind
+            && check_instant_now_call(cx, lhs)
+            && let ty_resolved = cx.typeck_results().expr_ty(rhs)
+            && let rustc_middle::ty::Adt(def, _) = ty_resolved.kind()
+            && clippy_utils::match_def_path(cx, def.did(), &clippy_utils::paths::INSTANT)
+            && let Some(sugg) = clippy_utils::sugg::Sugg::hir_opt(cx, rhs)
+        {
+            span_lint_and_sugg(
+                cx,
+                MANUAL_INSTANT_ELAPSED,
+                expr.span,
+                "manual implementation of `Instant::elapsed`",
+                "try",
+                format!("{}.elapsed()", sugg.maybe_par()),
+                Applicability::MachineApplicable,
+            );
+        }
+    }
+}
+
+fn check_instant_now_call(cx: &LateContext<'_>, expr_block: &'_ Expr<'_>) -> bool {
+    if let ExprKind::Call(fn_expr, []) = expr_block.kind
+        && let Some(fn_id) = clippy_utils::path_def_id(cx, fn_expr)
+        && clippy_utils::match_def_path(cx, fn_id, &clippy_utils::paths::INSTANT_NOW)
+    {
+        true
+    } else {
+        false
+    }
+}
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index 05429d05d9e..8d697a301c4 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -194,3 +194,5 @@ pub const VEC_RESIZE: [&str; 4] = ["alloc", "vec", "Vec", "resize"];
 pub const WEAK_ARC: [&str; 3] = ["alloc", "sync", "Weak"];
 pub const WEAK_RC: [&str; 3] = ["alloc", "rc", "Weak"];
 pub const PTR_NON_NULL: [&str; 4] = ["core", "ptr", "non_null", "NonNull"];
+pub const INSTANT_NOW: [&str; 4] = ["std", "time", "Instant", "now"];
+pub const INSTANT: [&str; 3] = ["std", "time", "Instant"];
diff --git a/tests/ui/manual_instant_elapsed.fixed b/tests/ui/manual_instant_elapsed.fixed
new file mode 100644
index 00000000000..0fa776b7b2e
--- /dev/null
+++ b/tests/ui/manual_instant_elapsed.fixed
@@ -0,0 +1,27 @@
+// run-rustfix
+#![warn(clippy::manual_instant_elapsed)]
+#![allow(clippy::unnecessary_operation)]
+#![allow(unused_variables)]
+#![allow(unused_must_use)]
+
+use std::time::Instant;
+
+fn main() {
+    let prev_instant = Instant::now();
+
+    {
+        // don't influence
+        let another_instant = Instant::now();
+    }
+
+    let duration = prev_instant.elapsed();
+
+    // don't catch
+    let duration = prev_instant.elapsed();
+
+    Instant::now() - duration;
+
+    let ref_to_instant = &Instant::now();
+
+    (*ref_to_instant).elapsed(); // to ensure parens are added correctly
+}
diff --git a/tests/ui/manual_instant_elapsed.rs b/tests/ui/manual_instant_elapsed.rs
new file mode 100644
index 00000000000..5b11b84535d
--- /dev/null
+++ b/tests/ui/manual_instant_elapsed.rs
@@ -0,0 +1,27 @@
+// run-rustfix
+#![warn(clippy::manual_instant_elapsed)]
+#![allow(clippy::unnecessary_operation)]
+#![allow(unused_variables)]
+#![allow(unused_must_use)]
+
+use std::time::Instant;
+
+fn main() {
+    let prev_instant = Instant::now();
+
+    {
+        // don't influence
+        let another_instant = Instant::now();
+    }
+
+    let duration = Instant::now() - prev_instant;
+
+    // don't catch
+    let duration = prev_instant.elapsed();
+
+    Instant::now() - duration;
+
+    let ref_to_instant = &Instant::now();
+
+    Instant::now() - *ref_to_instant; // to ensure parens are added correctly
+}
diff --git a/tests/ui/manual_instant_elapsed.stderr b/tests/ui/manual_instant_elapsed.stderr
new file mode 100644
index 00000000000..5537f5642a2
--- /dev/null
+++ b/tests/ui/manual_instant_elapsed.stderr
@@ -0,0 +1,16 @@
+error: manual implementation of `Instant::elapsed`
+  --> $DIR/manual_instant_elapsed.rs:17:20
+   |
+LL |     let duration = Instant::now() - prev_instant;
+   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `prev_instant.elapsed()`
+   |
+   = note: `-D clippy::manual-instant-elapsed` implied by `-D warnings`
+
+error: manual implementation of `Instant::elapsed`
+  --> $DIR/manual_instant_elapsed.rs:26:5
+   |
+LL |     Instant::now() - *ref_to_instant; // to ensure parens are added correctly
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `(*ref_to_instant).elapsed()`
+
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 9ab6146afea0119afb1a06afef5fbed5a3efe422 Mon Sep 17 00:00:00 2001
From: tabokie <xy.tao@outlook.com>
Date: Tue, 2 Aug 2022 11:37:44 +0800
Subject: simplify unit type check

Signed-off-by: tabokie <xy.tao@outlook.com>
---
 clippy_lints/src/map_unit_fn.rs | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/map_unit_fn.rs b/clippy_lints/src/map_unit_fn.rs
index af9d948af00..6db852c3ffe 100644
--- a/clippy_lints/src/map_unit_fn.rs
+++ b/clippy_lints/src/map_unit_fn.rs
@@ -97,11 +97,7 @@ declare_clippy_lint! {
 declare_lint_pass!(MapUnit => [OPTION_MAP_UNIT_FN, RESULT_MAP_UNIT_FN]);
 
 fn is_unit_type(ty: Ty<'_>) -> bool {
-    match ty.kind() {
-        ty::Tuple(slice) => slice.is_empty(),
-        ty::Never => true,
-        _ => false,
-    }
+    ty.is_unit() || ty.is_never()
 }
 
 fn is_unit_function(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> bool {
-- 
cgit 1.4.1-3-g733a5


From ac7a91ea161d2fec96f8eda01c3925e161bf9f38 Mon Sep 17 00:00:00 2001
From: tabokie <xy.tao@outlook.com>
Date: Tue, 2 Aug 2022 12:01:36 +0800
Subject: use slice match more often

Signed-off-by: tabokie <xy.tao@outlook.com>
---
 clippy_lints/src/checked_conversions.rs        |  5 +----
 clippy_lints/src/create_dir.rs                 |  4 ++--
 clippy_lints/src/from_str_radix_10.rs          | 11 +++++------
 clippy_lints/src/loops/manual_memcpy.rs        | 10 +++-------
 clippy_lints/src/loops/needless_range_loop.rs  |  5 ++---
 clippy_lints/src/manual_ok_or.rs               | 11 ++++-------
 clippy_lints/src/map_err_ignore.rs             |  6 +++---
 clippy_lints/src/matches/match_as_ref.rs       |  6 +++---
 clippy_lints/src/matches/try_err.rs            |  6 ++----
 clippy_lints/src/mem_replace.rs                |  6 ++----
 clippy_lints/src/path_buf_push_overwrite.rs    |  6 ++----
 clippy_lints/src/question_mark.rs              |  3 +--
 clippy_lints/src/ranges.rs                     | 12 ++++++------
 clippy_lints/src/regex.rs                      | 11 +++++------
 clippy_lints/src/slow_vector_initialization.rs |  9 ++-------
 clippy_lints/src/stable_sort_primitive.rs      |  5 ++---
 clippy_lints/src/useless_conversion.rs         | 23 +++++++++++------------
 clippy_lints/src/verbose_file_reads.rs         |  6 +++---
 18 files changed, 59 insertions(+), 86 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/checked_conversions.rs b/clippy_lints/src/checked_conversions.rs
index 17fc81951f9..37b2fdcff09 100644
--- a/clippy_lints/src/checked_conversions.rs
+++ b/clippy_lints/src/checked_conversions.rs
@@ -270,10 +270,7 @@ fn get_types_from_cast<'a>(
     let limit_from: Option<(&Expr<'_>, &str)> = call_from_cast.or_else(|| {
         if_chain! {
             // `from_type::from, to_type::max_value()`
-            if let ExprKind::Call(from_func, args) = &expr.kind;
-            // `to_type::max_value()`
-            if args.len() == 1;
-            if let limit = &args[0];
+            if let ExprKind::Call(from_func, [limit]) = &expr.kind;
             // `from_type::from`
             if let ExprKind::Path(ref path) = &from_func.kind;
             if let Some(from_sym) = get_implementing_type(path, INTS, "from");
diff --git a/clippy_lints/src/create_dir.rs b/clippy_lints/src/create_dir.rs
index 18d34370a7b..878248a6bdc 100644
--- a/clippy_lints/src/create_dir.rs
+++ b/clippy_lints/src/create_dir.rs
@@ -34,7 +34,7 @@ declare_lint_pass!(CreateDir => [CREATE_DIR]);
 impl LateLintPass<'_> for CreateDir {
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
         if_chain! {
-            if let ExprKind::Call(func, args) = expr.kind;
+            if let ExprKind::Call(func, [arg, ..]) = expr.kind;
             if let ExprKind::Path(ref path) = func.kind;
             if let Some(def_id) = cx.qpath_res(path, func.hir_id).opt_def_id();
             if match_def_path(cx, def_id, &paths::STD_FS_CREATE_DIR);
@@ -45,7 +45,7 @@ impl LateLintPass<'_> for CreateDir {
                     expr.span,
                     "calling `std::fs::create_dir` where there may be a better way",
                     "consider calling `std::fs::create_dir_all` instead",
-                    format!("create_dir_all({})", snippet(cx, args[0].span, "..")),
+                    format!("create_dir_all({})", snippet(cx, arg.span, "..")),
                     Applicability::MaybeIncorrect,
                 )
             }
diff --git a/clippy_lints/src/from_str_radix_10.rs b/clippy_lints/src/from_str_radix_10.rs
index 57b07513205..74941d817be 100644
--- a/clippy_lints/src/from_str_radix_10.rs
+++ b/clippy_lints/src/from_str_radix_10.rs
@@ -46,7 +46,7 @@ declare_lint_pass!(FromStrRadix10 => [FROM_STR_RADIX_10]);
 impl<'tcx> LateLintPass<'tcx> for FromStrRadix10 {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, exp: &Expr<'tcx>) {
         if_chain! {
-            if let ExprKind::Call(maybe_path, arguments) = &exp.kind;
+            if let ExprKind::Call(maybe_path, [src, radix]) = &exp.kind;
             if let ExprKind::Path(QPath::TypeRelative(ty, pathseg)) = &maybe_path.kind;
 
             // check if the first part of the path is some integer primitive
@@ -60,20 +60,19 @@ impl<'tcx> LateLintPass<'tcx> for FromStrRadix10 {
             if pathseg.ident.name.as_str() == "from_str_radix";
 
             // check if the second argument is a primitive `10`
-            if arguments.len() == 2;
-            if let ExprKind::Lit(lit) = &arguments[1].kind;
+            if let ExprKind::Lit(lit) = &radix.kind;
             if let rustc_ast::ast::LitKind::Int(10, _) = lit.node;
 
             then {
-                let expr = if let ExprKind::AddrOf(_, _, expr) = &arguments[0].kind {
+                let expr = if let ExprKind::AddrOf(_, _, expr) = &src.kind {
                     let ty = cx.typeck_results().expr_ty(expr);
                     if is_ty_stringish(cx, ty) {
                         expr
                     } else {
-                        &arguments[0]
+                        &src
                     }
                 } else {
-                    &arguments[0]
+                    &src
                 };
 
                 let sugg = Sugg::hir_with_applicability(
diff --git a/clippy_lints/src/loops/manual_memcpy.rs b/clippy_lints/src/loops/manual_memcpy.rs
index b31015d195b..a65df48e413 100644
--- a/clippy_lints/src/loops/manual_memcpy.rs
+++ b/clippy_lints/src/loops/manual_memcpy.rs
@@ -119,11 +119,9 @@ fn build_manual_memcpy_suggestion<'tcx>(
 
     let print_limit = |end: &Expr<'_>, end_str: &str, base: &Expr<'_>, sugg: MinifyingSugg<'static>| {
         if_chain! {
-            if let ExprKind::MethodCall(method, len_args, _) = end.kind;
+            if let ExprKind::MethodCall(method, [recv], _) = end.kind;
             if method.ident.name == sym::len;
-            if len_args.len() == 1;
-            if let Some(arg) = len_args.get(0);
-            if path_to_local(arg) == path_to_local(base);
+            if path_to_local(recv) == path_to_local(base);
             then {
                 if sugg.to_string() == end_str {
                     sugg::EMPTY.into()
@@ -343,10 +341,8 @@ fn get_slice_like_element_ty<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Opti
 
 fn fetch_cloned_expr<'tcx>(expr: &'tcx Expr<'tcx>) -> &'tcx Expr<'tcx> {
     if_chain! {
-        if let ExprKind::MethodCall(method, args, _) = expr.kind;
+        if let ExprKind::MethodCall(method, [arg], _) = expr.kind;
         if method.ident.name == sym::clone;
-        if args.len() == 1;
-        if let Some(arg) = args.get(0);
         then { arg } else { expr }
     }
 }
diff --git a/clippy_lints/src/loops/needless_range_loop.rs b/clippy_lints/src/loops/needless_range_loop.rs
index a7ef562b21f..7ca4a7c4ebf 100644
--- a/clippy_lints/src/loops/needless_range_loop.rs
+++ b/clippy_lints/src/loops/needless_range_loop.rs
@@ -188,10 +188,9 @@ pub(super) fn check<'tcx>(
 
 fn is_len_call(expr: &Expr<'_>, var: Symbol) -> bool {
     if_chain! {
-        if let ExprKind::MethodCall(method, len_args, _) = expr.kind;
-        if len_args.len() == 1;
+        if let ExprKind::MethodCall(method, [recv], _) = expr.kind;
         if method.ident.name == sym::len;
-        if let ExprKind::Path(QPath::Resolved(_, path)) = len_args[0].kind;
+        if let ExprKind::Path(QPath::Resolved(_, path)) = recv.kind;
         if path.segments.len() == 1;
         if path.segments[0].ident.name == var;
         then {
diff --git a/clippy_lints/src/manual_ok_or.rs b/clippy_lints/src/manual_ok_or.rs
index 9abf2507b92..cf5004399b8 100644
--- a/clippy_lints/src/manual_ok_or.rs
+++ b/clippy_lints/src/manual_ok_or.rs
@@ -47,17 +47,14 @@ impl<'tcx> LateLintPass<'tcx> for ManualOkOr {
         }
 
         if_chain! {
-            if let ExprKind::MethodCall(method_segment, args, _) = scrutinee.kind;
+            if let ExprKind::MethodCall(method_segment, [receiver, or_expr, map_expr], _) = scrutinee.kind;
             if method_segment.ident.name == sym!(map_or);
-            if args.len() == 3;
-            let method_receiver = &args[0];
-            let ty = cx.typeck_results().expr_ty(method_receiver);
+            let ty = cx.typeck_results().expr_ty(receiver);
             if is_type_diagnostic_item(cx, ty, sym::Option);
-            let or_expr = &args[1];
-            if is_ok_wrapping(cx, &args[2]);
+            if is_ok_wrapping(cx, map_expr);
             if let ExprKind::Call(Expr { kind: ExprKind::Path(err_path), .. }, &[ref err_arg]) = or_expr.kind;
             if is_lang_ctor(cx, err_path, ResultErr);
-            if let Some(method_receiver_snippet) = snippet_opt(cx, method_receiver.span);
+            if let Some(method_receiver_snippet) = snippet_opt(cx, receiver.span);
             if let Some(err_arg_snippet) = snippet_opt(cx, err_arg.span);
             if let Some(indent) = indent_of(cx, scrutinee.span);
             then {
diff --git a/clippy_lints/src/map_err_ignore.rs b/clippy_lints/src/map_err_ignore.rs
index 21d0e19eb0a..1e542447c96 100644
--- a/clippy_lints/src/map_err_ignore.rs
+++ b/clippy_lints/src/map_err_ignore.rs
@@ -113,10 +113,10 @@ impl<'tcx> LateLintPass<'tcx> for MapErrIgnore {
         }
 
         // check if this is a method call (e.g. x.foo())
-        if let ExprKind::MethodCall(method, args, _) = e.kind {
+        if let ExprKind::MethodCall(method, [_, arg], _) = e.kind {
             // only work if the method name is `map_err` and there are only 2 arguments (e.g. x.map_err(|_|[1]
             // Enum::Variant[2]))
-            if method.ident.as_str() == "map_err" && args.len() == 2 {
+            if method.ident.name == sym!(map_err) {
                 // make sure the first argument is a closure, and grab the CaptureRef, BodyId, and fn_decl_span
                 // fields
                 if let ExprKind::Closure(&Closure {
@@ -124,7 +124,7 @@ impl<'tcx> LateLintPass<'tcx> for MapErrIgnore {
                     body,
                     fn_decl_span,
                     ..
-                }) = args[1].kind
+                }) = arg.kind
                 {
                     // check if this is by Reference (meaning there's no move statement)
                     if capture_clause == CaptureBy::Ref {
diff --git a/clippy_lints/src/matches/match_as_ref.rs b/clippy_lints/src/matches/match_as_ref.rs
index d914eba0171..a0efdecec67 100644
--- a/clippy_lints/src/matches/match_as_ref.rs
+++ b/clippy_lints/src/matches/match_as_ref.rs
@@ -72,10 +72,10 @@ fn is_ref_some_arm(cx: &LateContext<'_>, arm: &Arm<'_>) -> Option<BindingAnnotat
         if is_lang_ctor(cx, qpath, LangItem::OptionSome);
         if let PatKind::Binding(rb, .., ident, _) = first_pat.kind;
         if rb == BindingAnnotation::Ref || rb == BindingAnnotation::RefMut;
-        if let ExprKind::Call(e, args) = peel_blocks(arm.body).kind;
+        if let ExprKind::Call(e, [arg]) = peel_blocks(arm.body).kind;
         if let ExprKind::Path(ref some_path) = e.kind;
-        if is_lang_ctor(cx, some_path, LangItem::OptionSome) && args.len() == 1;
-        if let ExprKind::Path(QPath::Resolved(_, path2)) = args[0].kind;
+        if is_lang_ctor(cx, some_path, LangItem::OptionSome);
+        if let ExprKind::Path(QPath::Resolved(_, path2)) = arg.kind;
         if path2.segments.len() == 1 && ident.name == path2.segments[0].ident.name;
         then {
             return Some(rb)
diff --git a/clippy_lints/src/matches/try_err.rs b/clippy_lints/src/matches/try_err.rs
index 0491a0679f3..663277d1136 100644
--- a/clippy_lints/src/matches/try_err.rs
+++ b/clippy_lints/src/matches/try_err.rs
@@ -23,12 +23,10 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, scrutine
     //         val,
     // };
     if_chain! {
-        if let ExprKind::Call(match_fun, try_args) = scrutinee.kind;
+        if let ExprKind::Call(match_fun, [try_arg, ..]) = scrutinee.kind;
         if let ExprKind::Path(ref match_fun_path) = match_fun.kind;
         if matches!(match_fun_path, QPath::LangItem(LangItem::TryTraitBranch, ..));
-        if let Some(try_arg) = try_args.get(0);
-        if let ExprKind::Call(err_fun, err_args) = try_arg.kind;
-        if let Some(err_arg) = err_args.get(0);
+        if let ExprKind::Call(err_fun, [err_arg, ..]) = try_arg.kind;
         if let ExprKind::Path(ref err_fun_path) = err_fun.kind;
         if is_lang_ctor(cx, err_fun_path, ResultErr);
         if let Some(return_ty) = find_return_type(cx, &expr.kind);
diff --git a/clippy_lints/src/mem_replace.rs b/clippy_lints/src/mem_replace.rs
index 41073d40f3d..cad3ea2a176 100644
--- a/clippy_lints/src/mem_replace.rs
+++ b/clippy_lints/src/mem_replace.rs
@@ -163,8 +163,7 @@ fn check_replace_with_uninit(cx: &LateContext<'_>, src: &Expr<'_>, dest: &Expr<'
     }
 
     if_chain! {
-        if let ExprKind::Call(repl_func, repl_args) = src.kind;
-        if repl_args.is_empty();
+        if let ExprKind::Call(repl_func, []) = src.kind;
         if let ExprKind::Path(ref repl_func_qpath) = repl_func.kind;
         if let Some(repl_def_id) = cx.qpath_res(repl_func_qpath, repl_func.hir_id).opt_def_id();
         then {
@@ -246,11 +245,10 @@ impl<'tcx> LateLintPass<'tcx> for MemReplace {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if_chain! {
             // Check that `expr` is a call to `mem::replace()`
-            if let ExprKind::Call(func, func_args) = expr.kind;
+            if let ExprKind::Call(func, [dest, src]) = expr.kind;
             if let ExprKind::Path(ref func_qpath) = func.kind;
             if let Some(def_id) = cx.qpath_res(func_qpath, func.hir_id).opt_def_id();
             if cx.tcx.is_diagnostic_item(sym::mem_replace, def_id);
-            if let [dest, src] = func_args;
             then {
                 check_replace_option_with_none(cx, src, dest, expr.span);
                 check_replace_with_uninit(cx, src, dest, expr.span);
diff --git a/clippy_lints/src/path_buf_push_overwrite.rs b/clippy_lints/src/path_buf_push_overwrite.rs
index 3f940ce61c0..bc6a918f703 100644
--- a/clippy_lints/src/path_buf_push_overwrite.rs
+++ b/clippy_lints/src/path_buf_push_overwrite.rs
@@ -46,11 +46,9 @@ declare_lint_pass!(PathBufPushOverwrite => [PATH_BUF_PUSH_OVERWRITE]);
 impl<'tcx> LateLintPass<'tcx> for PathBufPushOverwrite {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if_chain! {
-            if let ExprKind::MethodCall(path, args, _) = expr.kind;
+            if let ExprKind::MethodCall(path, [recv, get_index_arg], _) = expr.kind;
             if path.ident.name == sym!(push);
-            if args.len() == 2;
-            if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&args[0]).peel_refs(), sym::PathBuf);
-            if let Some(get_index_arg) = args.get(1);
+            if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(recv).peel_refs(), sym::PathBuf);
             if let ExprKind::Lit(ref lit) = get_index_arg.kind;
             if let LitKind::Str(ref path_lit, _) = lit.node;
             if let pushed_path = Path::new(path_lit.as_str());
diff --git a/clippy_lints/src/question_mark.rs b/clippy_lints/src/question_mark.rs
index fd0a53839e6..964a057f00d 100644
--- a/clippy_lints/src/question_mark.rs
+++ b/clippy_lints/src/question_mark.rs
@@ -86,8 +86,7 @@ fn check_is_none_or_err_and_early_return<'tcx>(cx: &LateContext<'tcx>, expr: &Ex
     if_chain! {
         if let Some(higher::If { cond, then, r#else }) = higher::If::hir(expr);
         if !is_else_clause(cx.tcx, expr);
-        if let ExprKind::MethodCall(segment, args, _) = &cond.kind;
-        if let Some(caller) = args.get(0);
+        if let ExprKind::MethodCall(segment, [caller, ..], _) = &cond.kind;
         let caller_ty = cx.typeck_results().expr_ty(caller);
         let if_block = IfBlockType::IfIs(caller, caller_ty, segment.ident.name, then, r#else);
         if is_early_return(sym::Option, cx, &if_block) || is_early_return(sym::Result, cx, &if_block);
diff --git a/clippy_lints/src/ranges.rs b/clippy_lints/src/ranges.rs
index 056637c2048..fbf842c339e 100644
--- a/clippy_lints/src/ranges.rs
+++ b/clippy_lints/src/ranges.rs
@@ -385,24 +385,24 @@ fn check_range_zip_with_len(cx: &LateContext<'_>, path: &PathSegment<'_>, args:
         if path.ident.as_str() == "zip";
         if let [iter, zip_arg] = args;
         // `.iter()` call
-        if let ExprKind::MethodCall(iter_path, iter_args, _) = iter.kind;
+        if let ExprKind::MethodCall(iter_path, [iter_caller, ..], _) = iter.kind;
         if iter_path.ident.name == sym::iter;
         // range expression in `.zip()` call: `0..x.len()`
         if let Some(higher::Range { start: Some(start), end: Some(end), .. }) = higher::Range::hir(zip_arg);
         if is_integer_const(cx, start, 0);
         // `.len()` call
-        if let ExprKind::MethodCall(len_path, len_args, _) = end.kind;
-        if len_path.ident.name == sym::len && len_args.len() == 1;
+        if let ExprKind::MethodCall(len_path, [len_caller], _) = end.kind;
+        if len_path.ident.name == sym::len;
         // `.iter()` and `.len()` called on same `Path`
-        if let ExprKind::Path(QPath::Resolved(_, iter_path)) = iter_args[0].kind;
-        if let ExprKind::Path(QPath::Resolved(_, len_path)) = len_args[0].kind;
+        if let ExprKind::Path(QPath::Resolved(_, iter_path)) = iter_caller.kind;
+        if let ExprKind::Path(QPath::Resolved(_, len_path)) = len_caller.kind;
         if SpanlessEq::new(cx).eq_path_segments(iter_path.segments, len_path.segments);
         then {
             span_lint(cx,
                 RANGE_ZIP_WITH_LEN,
                 span,
                 &format!("it is more idiomatic to use `{}.iter().enumerate()`",
-                    snippet(cx, iter_args[0].span, "_"))
+                    snippet(cx, iter_caller.span, "_"))
             );
         }
     }
diff --git a/clippy_lints/src/regex.rs b/clippy_lints/src/regex.rs
index f9a9b069193..6bcae0da8f4 100644
--- a/clippy_lints/src/regex.rs
+++ b/clippy_lints/src/regex.rs
@@ -57,21 +57,20 @@ declare_lint_pass!(Regex => [INVALID_REGEX, TRIVIAL_REGEX]);
 impl<'tcx> LateLintPass<'tcx> for Regex {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if_chain! {
-            if let ExprKind::Call(fun, args) = expr.kind;
+            if let ExprKind::Call(fun, [arg]) = expr.kind;
             if let ExprKind::Path(ref qpath) = fun.kind;
-            if args.len() == 1;
             if let Some(def_id) = cx.qpath_res(qpath, fun.hir_id).opt_def_id();
             then {
                 if match_def_path(cx, def_id, &paths::REGEX_NEW) ||
                    match_def_path(cx, def_id, &paths::REGEX_BUILDER_NEW) {
-                    check_regex(cx, &args[0], true);
+                    check_regex(cx, arg, true);
                 } else if match_def_path(cx, def_id, &paths::REGEX_BYTES_NEW) ||
                    match_def_path(cx, def_id, &paths::REGEX_BYTES_BUILDER_NEW) {
-                    check_regex(cx, &args[0], false);
+                    check_regex(cx, arg, false);
                 } else if match_def_path(cx, def_id, &paths::REGEX_SET_NEW) {
-                    check_set(cx, &args[0], true);
+                    check_set(cx, arg, true);
                 } else if match_def_path(cx, def_id, &paths::REGEX_BYTES_SET_NEW) {
-                    check_set(cx, &args[0], false);
+                    check_set(cx, arg, false);
                 }
             }
         }
diff --git a/clippy_lints/src/slow_vector_initialization.rs b/clippy_lints/src/slow_vector_initialization.rs
index 2c8aa17e80d..b59a25e3a40 100644
--- a/clippy_lints/src/slow_vector_initialization.rs
+++ b/clippy_lints/src/slow_vector_initialization.rs
@@ -233,15 +233,10 @@ impl<'a, 'tcx> VectorInitializationVisitor<'a, 'tcx> {
     /// Returns `true` if give expression is `repeat(0).take(...)`
     fn is_repeat_take(&self, expr: &Expr<'_>) -> bool {
         if_chain! {
-            if let ExprKind::MethodCall(take_path, take_args, _) = expr.kind;
+            if let ExprKind::MethodCall(take_path, [recv, len_arg, ..], _) = expr.kind;
             if take_path.ident.name == sym!(take);
-
             // Check that take is applied to `repeat(0)`
-            if let Some(repeat_expr) = take_args.get(0);
-            if self.is_repeat_zero(repeat_expr);
-
-            if let Some(len_arg) = take_args.get(1);
-
+            if self.is_repeat_zero(recv);
             then {
                 // Check that len expression is equals to `with_capacity` expression
                 if SpanlessEq::new(self.cx).eq_expr(len_arg, self.vec_alloc.len_expr) {
diff --git a/clippy_lints/src/stable_sort_primitive.rs b/clippy_lints/src/stable_sort_primitive.rs
index a6c685df721..6d54935f81a 100644
--- a/clippy_lints/src/stable_sort_primitive.rs
+++ b/clippy_lints/src/stable_sort_primitive.rs
@@ -97,12 +97,11 @@ struct LintDetection {
 
 fn detect_stable_sort_primitive(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<LintDetection> {
     if_chain! {
-        if let ExprKind::MethodCall(method_name, args, _) = &expr.kind;
-        if let Some(slice) = &args.get(0);
+        if let ExprKind::MethodCall(method_name, [slice, args @ ..], _) = &expr.kind;
         if let Some(method) = SortingKind::from_stable_name(method_name.ident.name.as_str());
         if let Some(slice_type) = is_slice_of_primitives(cx, slice);
         then {
-            let args_str = args.iter().skip(1).map(|arg| Sugg::hir(cx, arg, "..").to_string()).collect::<Vec<String>>().join(", ");
+            let args_str = args.iter().map(|arg| Sugg::hir(cx, arg, "..").to_string()).collect::<Vec<String>>().join(", ");
             Some(LintDetection { slice_name: Sugg::hir(cx, slice, "..").to_string(), method, method_args: args_str, slice_type })
         } else {
             None
diff --git a/clippy_lints/src/useless_conversion.rs b/clippy_lints/src/useless_conversion.rs
index fe29bf29d0c..b6738e2891d 100644
--- a/clippy_lints/src/useless_conversion.rs
+++ b/clippy_lints/src/useless_conversion.rs
@@ -59,17 +59,17 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
                     ExprKind::Ret(Some(e)) | ExprKind::Break(_, Some(e)) => e,
                     _ => return,
                 };
-                if let ExprKind::Call(_, args) = e.kind {
-                    self.try_desugar_arm.push(args[0].hir_id);
+                if let ExprKind::Call(_, [arg, ..]) = e.kind {
+                    self.try_desugar_arm.push(arg.hir_id);
                 }
             },
 
-            ExprKind::MethodCall(name, .., args, _) => {
+            ExprKind::MethodCall(name, .., [recv, ..], _) => {
                 if is_trait_method(cx, e, sym::Into) && name.ident.as_str() == "into" {
                     let a = cx.typeck_results().expr_ty(e);
-                    let b = cx.typeck_results().expr_ty(&args[0]);
+                    let b = cx.typeck_results().expr_ty(recv);
                     if same_type_and_consts(a, b) {
-                        let sugg = snippet_with_macro_callsite(cx, args[0].span, "<expr>").to_string();
+                        let sugg = snippet_with_macro_callsite(cx, recv.span, "<expr>").to_string();
                         span_lint_and_sugg(
                             cx,
                             USELESS_CONVERSION,
@@ -90,9 +90,9 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
                         }
                     }
                     let a = cx.typeck_results().expr_ty(e);
-                    let b = cx.typeck_results().expr_ty(&args[0]);
+                    let b = cx.typeck_results().expr_ty(recv);
                     if same_type_and_consts(a, b) {
-                        let sugg = snippet(cx, args[0].span, "<expr>").into_owned();
+                        let sugg = snippet(cx, recv.span, "<expr>").into_owned();
                         span_lint_and_sugg(
                             cx,
                             USELESS_CONVERSION,
@@ -107,7 +107,7 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
                 if_chain! {
                     if is_trait_method(cx, e, sym::TryInto) && name.ident.name == sym::try_into;
                     let a = cx.typeck_results().expr_ty(e);
-                    let b = cx.typeck_results().expr_ty(&args[0]);
+                    let b = cx.typeck_results().expr_ty(recv);
                     if is_type_diagnostic_item(cx, a, sym::Result);
                     if let ty::Adt(_, substs) = a.kind();
                     if let Some(a_type) = substs.types().next();
@@ -126,14 +126,13 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
                 }
             },
 
-            ExprKind::Call(path, args) => {
+            ExprKind::Call(path, [arg]) => {
                 if_chain! {
-                    if args.len() == 1;
                     if let ExprKind::Path(ref qpath) = path.kind;
                     if let Some(def_id) = cx.qpath_res(qpath, path.hir_id).opt_def_id();
                     then {
                         let a = cx.typeck_results().expr_ty(e);
-                        let b = cx.typeck_results().expr_ty(&args[0]);
+                        let b = cx.typeck_results().expr_ty(arg);
                         if_chain! {
                             if match_def_path(cx, def_id, &paths::TRY_FROM);
                             if is_type_diagnostic_item(cx, a, sym::Result);
@@ -159,7 +158,7 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
                             if same_type_and_consts(a, b);
 
                             then {
-                                let sugg = Sugg::hir_with_macro_callsite(cx, &args[0], "<expr>").maybe_par();
+                                let sugg = Sugg::hir_with_macro_callsite(cx, arg, "<expr>").maybe_par();
                                 let sugg_msg =
                                     format!("consider removing `{}()`", snippet(cx, path.span, "From::from"));
                                 span_lint_and_sugg(
diff --git a/clippy_lints/src/verbose_file_reads.rs b/clippy_lints/src/verbose_file_reads.rs
index 8e2ddd225fd..afd0077a658 100644
--- a/clippy_lints/src/verbose_file_reads.rs
+++ b/clippy_lints/src/verbose_file_reads.rs
@@ -61,10 +61,10 @@ impl<'tcx> LateLintPass<'tcx> for VerboseFileReads {
 
 fn is_file_read_to_end<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
     if_chain! {
-        if let ExprKind::MethodCall(method_name, exprs, _) = expr.kind;
+        if let ExprKind::MethodCall(method_name, [recv, ..], _) = expr.kind;
         if method_name.ident.as_str() == "read_to_end";
-        if let ExprKind::Path(QPath::Resolved(None, _)) = &exprs[0].kind;
-        let ty = cx.typeck_results().expr_ty(&exprs[0]);
+        if let ExprKind::Path(QPath::Resolved(None, _)) = &recv.kind;
+        let ty = cx.typeck_results().expr_ty(recv);
         if match_type(cx, ty, &paths::FILE);
         then {
             return true
-- 
cgit 1.4.1-3-g733a5


From 171d082433904096a7c563d937c860d52ba9b25f Mon Sep 17 00:00:00 2001
From: Allen Hsu <allen@thelookoutway.com>
Date: Tue, 12 Jul 2022 22:29:12 +1000
Subject: Compare where predicates to trait bounds.

- only compare where predicates to trait bounds when generating where
  clause specific message to fix #9151
- use comparable_trait_ref to account for trait bound generics to fix #8757
---
 clippy_lints/src/trait_bounds.rs            | 71 ++++++++++++++++++++---------
 tests/ui/trait_duplication_in_bounds.stderr | 50 +-------------------
 2 files changed, 50 insertions(+), 71 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/trait_bounds.rs b/clippy_lints/src/trait_bounds.rs
index 0a42a31fb8c..537e6eafb17 100644
--- a/clippy_lints/src/trait_bounds.rs
+++ b/clippy_lints/src/trait_bounds.rs
@@ -4,7 +4,7 @@ use clippy_utils::{SpanlessEq, SpanlessHash};
 use core::hash::{Hash, Hasher};
 use if_chain::if_chain;
 use itertools::Itertools;
-use rustc_data_structures::fx::FxHashMap;
+use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_data_structures::unhash::UnhashMap;
 use rustc_errors::Applicability;
 use rustc_hir::def::Res;
@@ -238,31 +238,58 @@ fn check_trait_bound_duplication(cx: &LateContext<'_>, gen: &'_ Generics<'_>) {
         return;
     }
 
-    let mut map = FxHashMap::<_, Vec<_>>::default();
-    for predicate in gen.predicates {
+    // Explanation:
+    // fn bad_foo<T: Clone + Default, Z: Copy>(arg0: T, arg1: Z)
+    // where T: Clone + Default, { unimplemented!(); }
+    //       ^^^^^^^^^^^^^^^^^^
+    //       |
+    // collects each of these where clauses into a set keyed by generic name and comparable trait
+    // eg. (T, Clone)
+    let where_predicates = gen
+        .predicates
+        .iter()
+        .filter_map(|pred| {
+            if_chain! {
+                if pred.in_where_clause();
+                if let WherePredicate::BoundPredicate(bound_predicate) = pred;
+                if let TyKind::Path(QPath::Resolved(_, path)) =  bound_predicate.bounded_ty.kind;
+                then {
+                    return Some(bound_predicate.bounds.iter().filter_map(|t| {
+                        Some((path.res, into_comparable_trait_ref(t.trait_ref()?)))
+                    }))
+                }
+            }
+            None
+        })
+        .flatten()
+        .collect::<FxHashSet<_>>();
+
+    // Explanation:
+    // fn bad_foo<T: Clone + Default, Z: Copy>(arg0: T, arg1: Z) ...
+    //            ^^^^^^^^^^^^^^^^^^  ^^^^^^^
+    //            |
+    // compare trait bounds keyed by generic name and comparable trait to collected where
+    // predicates eg. (T, Clone)
+    for predicate in gen.predicates.iter().filter(|pred| !pred.in_where_clause()) {
         if_chain! {
-            if let WherePredicate::BoundPredicate(ref bound_predicate) = predicate;
+            if let WherePredicate::BoundPredicate(bound_predicate) = predicate;
             if bound_predicate.origin != PredicateOrigin::ImplTrait;
             if !bound_predicate.span.from_expansion();
-            if let TyKind::Path(QPath::Resolved(_, Path { segments, .. })) = bound_predicate.bounded_ty.kind;
-            if let Some(segment) = segments.first();
+            if let TyKind::Path(QPath::Resolved(_, path)) =  bound_predicate.bounded_ty.kind;
             then {
-                for (res_where, _, span_where) in bound_predicate.bounds.iter().filter_map(get_trait_info_from_bound) {
-                    let trait_resolutions_direct = map.entry(segment.ident).or_default();
-                    if let Some((_, span_direct)) = trait_resolutions_direct
-                                                .iter()
-                                                .find(|(res_direct, _)| *res_direct == res_where) {
-                        span_lint_and_help(
-                            cx,
-                            TRAIT_DUPLICATION_IN_BOUNDS,
-                            *span_direct,
-                            "this trait bound is already specified in the where clause",
-                            None,
-                            "consider removing this trait bound",
-                        );
-                    }
-                    else {
-                        trait_resolutions_direct.push((res_where, span_where));
+                for t in bound_predicate.bounds {
+                    if let Some(trait_ref) = t.trait_ref() {
+                        let key = (path.res, into_comparable_trait_ref(trait_ref));
+                        if where_predicates.contains(&key) {
+                            span_lint_and_help(
+                                cx,
+                                TRAIT_DUPLICATION_IN_BOUNDS,
+                                t.span(),
+                                "this trait bound is already specified in the where clause",
+                                None,
+                                "consider removing this trait bound",
+                                );
+                        }
                     }
                 }
             }
diff --git a/tests/ui/trait_duplication_in_bounds.stderr b/tests/ui/trait_duplication_in_bounds.stderr
index 7ef04e52708..9b603fdea32 100644
--- a/tests/ui/trait_duplication_in_bounds.stderr
+++ b/tests/ui/trait_duplication_in_bounds.stderr
@@ -67,28 +67,12 @@ LL |         Self: Iterator<Item = Foo>,
    |
    = help: consider removing this trait bound
 
-error: this trait bound is already specified in the where clause
-  --> $DIR/trait_duplication_in_bounds.rs:103:19
-   |
-LL |     fn bad_foo<T: Clone + Clone + Clone + Copy, U: Clone + Copy>(arg0: T, argo1: U) {
-   |                   ^^^^^
-   |
-   = help: consider removing this trait bound
-
 error: these bounds contain repeated elements
   --> $DIR/trait_duplication_in_bounds.rs:103:19
    |
 LL |     fn bad_foo<T: Clone + Clone + Clone + Copy, U: Clone + Copy>(arg0: T, argo1: U) {
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Clone + Copy`
 
-error: this trait bound is already specified in the where clause
-  --> $DIR/trait_duplication_in_bounds.rs:109:12
-   |
-LL |         T: Clone + Clone + Clone + Copy,
-   |            ^^^^^
-   |
-   = help: consider removing this trait bound
-
 error: these where clauses contain repeated elements
   --> $DIR/trait_duplication_in_bounds.rs:109:12
    |
@@ -107,14 +91,6 @@ error: these where clauses contain repeated elements
 LL |             Self: Clone + Clone + Clone;
    |                   ^^^^^^^^^^^^^^^^^^^^^ help: try: `Clone`
 
-error: this trait bound is already specified in the where clause
-  --> $DIR/trait_duplication_in_bounds.rs:158:28
-   |
-LL |     trait BadTraitBound<T: Clone + Clone + Clone + Copy, U: Clone + Copy> {
-   |                            ^^^^^
-   |
-   = help: consider removing this trait bound
-
 error: these bounds contain repeated elements
   --> $DIR/trait_duplication_in_bounds.rs:158:28
    |
@@ -127,41 +103,17 @@ error: these where clauses contain repeated elements
 LL |             T: Clone + Clone + Clone + Copy,
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Clone + Copy`
 
-error: this trait bound is already specified in the where clause
-  --> $DIR/trait_duplication_in_bounds.rs:195:24
-   |
-LL |     fn good_generic<T: GenericTrait<u64> + GenericTrait<u32>>(arg0: T) {
-   |                        ^^^^^^^^^^^^^^^^^
-   |
-   = help: consider removing this trait bound
-
-error: this trait bound is already specified in the where clause
-  --> $DIR/trait_duplication_in_bounds.rs:199:23
-   |
-LL |     fn bad_generic<T: GenericTrait<u64> + GenericTrait<u32> + GenericTrait<u64>>(arg0: T) {
-   |                       ^^^^^^^^^^^^^^^^^
-   |
-   = help: consider removing this trait bound
-
 error: these bounds contain repeated elements
   --> $DIR/trait_duplication_in_bounds.rs:199:23
    |
 LL |     fn bad_generic<T: GenericTrait<u64> + GenericTrait<u32> + GenericTrait<u64>>(arg0: T) {
    |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `GenericTrait<u32> + GenericTrait<u64>`
 
-error: this trait bound is already specified in the where clause
-  --> $DIR/trait_duplication_in_bounds.rs:207:26
-   |
-LL |     fn qualified_path<T: std::clone::Clone + Clone + foo::Clone>(arg0: T) {
-   |                          ^^^^^^^^^^^^^^^^^
-   |
-   = help: consider removing this trait bound
-
 error: these bounds contain repeated elements
   --> $DIR/trait_duplication_in_bounds.rs:207:26
    |
 LL |     fn qualified_path<T: std::clone::Clone + Clone + foo::Clone>(arg0: T) {
    |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Clone + foo::Clone`
 
-error: aborting due to 22 previous errors
+error: aborting due to 16 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 145ebb1cd723e34dc5a940ec3e498de814e6293d Mon Sep 17 00:00:00 2001
From: Daniel Macovei <djmacovei@gmail.com>
Date: Tue, 2 Aug 2022 10:39:35 -0500
Subject: add paren before '?' when suggesting deref

---
 clippy_lints/src/methods/clone_on_copy.rs | 6 +++++-
 tests/ui/clone_on_copy.fixed              | 6 +++++-
 tests/ui/clone_on_copy.rs                 | 6 +++++-
 tests/ui/clone_on_copy.stderr             | 8 +++++++-
 4 files changed, 22 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/clone_on_copy.rs b/clippy_lints/src/methods/clone_on_copy.rs
index 0b38a07204e..a813d39441b 100644
--- a/clippy_lints/src/methods/clone_on_copy.rs
+++ b/clippy_lints/src/methods/clone_on_copy.rs
@@ -4,7 +4,7 @@ use clippy_utils::source::snippet_with_context;
 use clippy_utils::sugg;
 use clippy_utils::ty::is_copy;
 use rustc_errors::Applicability;
-use rustc_hir::{BindingAnnotation, Expr, ExprKind, MatchSource, Node, PatKind};
+use rustc_hir::{BindingAnnotation, Expr, ExprKind, MatchSource, Node, PatKind, QPath};
 use rustc_lint::LateContext;
 use rustc_middle::ty::{self, adjustment::Adjust};
 use rustc_span::symbol::{sym, Symbol};
@@ -86,6 +86,10 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, method_name: Symbol,
                 {
                     return;
                 },
+                ExprKind::Call(hir_callee, _) => match hir_callee.kind {
+                    ExprKind::Path(QPath::LangItem(rustc_hir::LangItem::TryTraitBranch, _, _)) => true,
+                    _ => false,
+                },
                 ExprKind::MethodCall(_, [self_arg, ..], _) if expr.hir_id == self_arg.hir_id => true,
                 ExprKind::Match(_, _, MatchSource::TryDesugar | MatchSource::AwaitDesugar)
                 | ExprKind::Field(..)
diff --git a/tests/ui/clone_on_copy.fixed b/tests/ui/clone_on_copy.fixed
index dc062762604..43849121b04 100644
--- a/tests/ui/clone_on_copy.fixed
+++ b/tests/ui/clone_on_copy.fixed
@@ -21,7 +21,7 @@ fn is_ascii(ch: char) -> bool {
     ch.is_ascii()
 }
 
-fn clone_on_copy() {
+fn clone_on_copy() -> Option<(i32)> {
     42;
 
     vec![1].clone(); // ok, not a Copy type
@@ -71,4 +71,8 @@ fn clone_on_copy() {
     // Issue #5436
     let mut vec = Vec::new();
     vec.push(42);
+
+    let opt: &Option<i32> = &None;
+    let value = (*opt)?;
+    None
 }
diff --git a/tests/ui/clone_on_copy.rs b/tests/ui/clone_on_copy.rs
index 8c39d0d55dd..1f10599da22 100644
--- a/tests/ui/clone_on_copy.rs
+++ b/tests/ui/clone_on_copy.rs
@@ -21,7 +21,7 @@ fn is_ascii(ch: char) -> bool {
     ch.is_ascii()
 }
 
-fn clone_on_copy() {
+fn clone_on_copy() -> Option<(i32)> {
     42.clone();
 
     vec![1].clone(); // ok, not a Copy type
@@ -71,4 +71,8 @@ fn clone_on_copy() {
     // Issue #5436
     let mut vec = Vec::new();
     vec.push(42.clone());
+
+    let opt: &Option<i32> = &None;
+    let value = opt.clone()?;
+    None
 }
diff --git a/tests/ui/clone_on_copy.stderr b/tests/ui/clone_on_copy.stderr
index 861543d0aa9..483ea35af2a 100644
--- a/tests/ui/clone_on_copy.stderr
+++ b/tests/ui/clone_on_copy.stderr
@@ -48,5 +48,11 @@ error: using `clone` on type `i32` which implements the `Copy` trait
 LL |     vec.push(42.clone());
    |              ^^^^^^^^^^ help: try removing the `clone` call: `42`
 
-error: aborting due to 8 previous errors
+error: using `clone` on type `std::option::Option<i32>` which implements the `Copy` trait
+  --> $DIR/clone_on_copy.rs:76:17
+   |
+LL |     let value = opt.clone()?;
+   |                 ^^^^^^^^^^^ help: try dereferencing it: `(*opt)`
+
+error: aborting due to 9 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 503c03c5584bb697071f3585953ed6e5b16d2e10 Mon Sep 17 00:00:00 2001
From: Daniel Macovei <djmacovei@gmail.com>
Date: Tue, 2 Aug 2022 12:06:22 -0500
Subject: clean up

---
 clippy_lints/src/methods/clone_on_copy.rs | 9 +++++----
 tests/ui/clone_on_copy.fixed              | 3 ++-
 tests/ui/clone_on_copy.rs                 | 3 ++-
 tests/ui/clone_on_copy.stderr             | 4 ++--
 4 files changed, 11 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/clone_on_copy.rs b/clippy_lints/src/methods/clone_on_copy.rs
index a813d39441b..60e1355f9b9 100644
--- a/clippy_lints/src/methods/clone_on_copy.rs
+++ b/clippy_lints/src/methods/clone_on_copy.rs
@@ -86,10 +86,11 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, method_name: Symbol,
                 {
                     return;
                 },
-                ExprKind::Call(hir_callee, _) => match hir_callee.kind {
-                    ExprKind::Path(QPath::LangItem(rustc_hir::LangItem::TryTraitBranch, _, _)) => true,
-                    _ => false,
-                },
+                // ? is a Call, makes sure not to rec *x?, but rather (*x)?
+                ExprKind::Call(hir_callee, _) => matches!(
+                    hir_callee.kind,
+                    ExprKind::Path(QPath::LangItem(rustc_hir::LangItem::TryTraitBranch, _, _))
+                ),
                 ExprKind::MethodCall(_, [self_arg, ..], _) if expr.hir_id == self_arg.hir_id => true,
                 ExprKind::Match(_, _, MatchSource::TryDesugar | MatchSource::AwaitDesugar)
                 | ExprKind::Field(..)
diff --git a/tests/ui/clone_on_copy.fixed b/tests/ui/clone_on_copy.fixed
index 43849121b04..72b12227098 100644
--- a/tests/ui/clone_on_copy.fixed
+++ b/tests/ui/clone_on_copy.fixed
@@ -72,7 +72,8 @@ fn clone_on_copy() -> Option<(i32)> {
     let mut vec = Vec::new();
     vec.push(42);
 
+    //  Issue #9277
     let opt: &Option<i32> = &None;
-    let value = (*opt)?;
+    let value = (*opt)?; // operator precedence needed (*opt)?
     None
 }
diff --git a/tests/ui/clone_on_copy.rs b/tests/ui/clone_on_copy.rs
index 1f10599da22..03e210ebad9 100644
--- a/tests/ui/clone_on_copy.rs
+++ b/tests/ui/clone_on_copy.rs
@@ -72,7 +72,8 @@ fn clone_on_copy() -> Option<(i32)> {
     let mut vec = Vec::new();
     vec.push(42.clone());
 
+    //  Issue #9277
     let opt: &Option<i32> = &None;
-    let value = opt.clone()?;
+    let value = opt.clone()?; // operator precedence needed (*opt)?
     None
 }
diff --git a/tests/ui/clone_on_copy.stderr b/tests/ui/clone_on_copy.stderr
index 483ea35af2a..42ae227777c 100644
--- a/tests/ui/clone_on_copy.stderr
+++ b/tests/ui/clone_on_copy.stderr
@@ -49,9 +49,9 @@ LL |     vec.push(42.clone());
    |              ^^^^^^^^^^ help: try removing the `clone` call: `42`
 
 error: using `clone` on type `std::option::Option<i32>` which implements the `Copy` trait
-  --> $DIR/clone_on_copy.rs:76:17
+  --> $DIR/clone_on_copy.rs:77:17
    |
-LL |     let value = opt.clone()?;
+LL |     let value = opt.clone()?; // operator precedence needed (*opt)?
    |                 ^^^^^^^^^^^ help: try dereferencing it: `(*opt)`
 
 error: aborting due to 9 previous errors
-- 
cgit 1.4.1-3-g733a5


From b426bd52a167a55eee029a45b42e7c0eece1f1c0 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Wed, 3 Aug 2022 13:16:04 -0400
Subject: Don't lint `transmute_undefined_repr` when the the first field of a
 `repr(C)` type is compatible with the other type

---
 .../src/transmute/transmute_undefined_repr.rs      | 29 +++++++++++++---------
 tests/ui/transmute_undefined_repr.rs               |  8 ++++++
 tests/ui/transmute_undefined_repr.stderr           | 22 +++++++++++++---
 3 files changed, 44 insertions(+), 15 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/transmute/transmute_undefined_repr.rs b/clippy_lints/src/transmute/transmute_undefined_repr.rs
index 20b348fc14f..bf1cfb859bc 100644
--- a/clippy_lints/src/transmute/transmute_undefined_repr.rs
+++ b/clippy_lints/src/transmute/transmute_undefined_repr.rs
@@ -164,9 +164,18 @@ pub(super) fn check<'tcx>(
                     );
                     return true;
                 },
+                // `Repr(C)` <-> unordered type.
+                // If the first field of the `Repr(C)` type matches then the transmute is ok
+                (ReducedTy::OrderedFields(_, Some(from_sub_ty)), ReducedTy::UnorderedFields(to_sub_ty))
+                | (ReducedTy::UnorderedFields(from_sub_ty), ReducedTy::OrderedFields(_, Some(to_sub_ty)))
+                | (ReducedTy::Ref(from_sub_ty), ReducedTy::Ref(to_sub_ty)) => {
+                    from_ty = from_sub_ty;
+                    to_ty = to_sub_ty;
+                    continue;
+                },
                 (
                     ReducedTy::UnorderedFields(from_ty),
-                    ReducedTy::Other(_) | ReducedTy::OrderedFields(_) | ReducedTy::Ref(_),
+                    ReducedTy::Other(_) | ReducedTy::OrderedFields(..) | ReducedTy::Ref(_),
                 ) => {
                     span_lint_and_then(
                         cx,
@@ -182,7 +191,7 @@ pub(super) fn check<'tcx>(
                     return true;
                 },
                 (
-                    ReducedTy::Other(_) | ReducedTy::OrderedFields(_) | ReducedTy::Ref(_),
+                    ReducedTy::Other(_) | ReducedTy::OrderedFields(..) | ReducedTy::Ref(_),
                     ReducedTy::UnorderedFields(to_ty),
                 ) => {
                     span_lint_and_then(
@@ -198,14 +207,9 @@ pub(super) fn check<'tcx>(
                     );
                     return true;
                 },
-                (ReducedTy::Ref(from_sub_ty), ReducedTy::Ref(to_sub_ty)) => {
-                    from_ty = from_sub_ty;
-                    to_ty = to_sub_ty;
-                    continue;
-                },
                 (
-                    ReducedTy::OrderedFields(_) | ReducedTy::Ref(_) | ReducedTy::Other(_) | ReducedTy::Param,
-                    ReducedTy::OrderedFields(_) | ReducedTy::Ref(_) | ReducedTy::Other(_) | ReducedTy::Param,
+                    ReducedTy::OrderedFields(..) | ReducedTy::Ref(_) | ReducedTy::Other(_) | ReducedTy::Param,
+                    ReducedTy::OrderedFields(..) | ReducedTy::Ref(_) | ReducedTy::Other(_) | ReducedTy::Param,
                 )
                 | (
                     ReducedTy::UnorderedFields(_) | ReducedTy::Param,
@@ -269,7 +273,8 @@ enum ReducedTy<'tcx> {
     TypeErasure,
     /// The type is a struct containing either zero non-zero sized fields, or multiple non-zero
     /// sized fields with a defined order.
-    OrderedFields(Ty<'tcx>),
+    /// The second value is the first non-zero sized type.
+    OrderedFields(Ty<'tcx>, Option<Ty<'tcx>>),
     /// The type is a struct containing multiple non-zero sized fields with no defined order.
     UnorderedFields(Ty<'tcx>),
     /// The type is a reference to the contained type.
@@ -294,7 +299,7 @@ fn reduce_ty<'tcx>(cx: &LateContext<'tcx>, mut ty: Ty<'tcx>) -> ReducedTy<'tcx>
             ty::Tuple(args) => {
                 let mut iter = args.iter();
                 let Some(sized_ty) = iter.find(|&ty| !is_zero_sized_ty(cx, ty)) else {
-                    return ReducedTy::OrderedFields(ty);
+                    return ReducedTy::OrderedFields(ty, None);
                 };
                 if iter.all(|ty| is_zero_sized_ty(cx, ty)) {
                     ty = sized_ty;
@@ -316,7 +321,7 @@ fn reduce_ty<'tcx>(cx: &LateContext<'tcx>, mut ty: Ty<'tcx>) -> ReducedTy<'tcx>
                     continue;
                 }
                 if def.repr().inhibit_struct_field_reordering_opt() {
-                    ReducedTy::OrderedFields(ty)
+                    ReducedTy::OrderedFields(ty, Some(sized_ty))
                 } else {
                     ReducedTy::UnorderedFields(ty)
                 }
diff --git a/tests/ui/transmute_undefined_repr.rs b/tests/ui/transmute_undefined_repr.rs
index ebcaa7a84cf..6df8ed8feea 100644
--- a/tests/ui/transmute_undefined_repr.rs
+++ b/tests/ui/transmute_undefined_repr.rs
@@ -109,6 +109,14 @@ fn main() {
         let _: Ty2<u32, u32> = transmute(value::<MaybeUninit<Ty2<u32, u32>>>()); // Ok
 
         let _: Ty<&[u32]> = transmute::<&[u32], _>(value::<&Vec<u32>>()); // Ok
+
+        let _: *const Ty2<u32, u32> = transmute(value::<*const Ty2C<Ty2<u32, u32>, u32>>()); // Ok
+        let _: *const Ty2C<Ty2<u32, u32>, u32> = transmute(value::<*const Ty2<u32, u32>>()); // Ok
+        let _: *const Ty2<u32, u32> = transmute(value::<*const Ty2C<(), Ty2<u32, u32>>>()); // Ok
+        let _: *const Ty2C<(), Ty2<u32, u32>> = transmute(value::<*const Ty2<u32, u32>>()); // Ok
+
+        let _: *const Ty2<u32, u32> = transmute(value::<*const Ty2C<u32, Ty2<u32, u32>>>()); // Err
+        let _: *const Ty2C<u32, Ty2<u32, u32>> = transmute(value::<*const Ty2<u32, u32>>()); // Err
     }
 }
 
diff --git a/tests/ui/transmute_undefined_repr.stderr b/tests/ui/transmute_undefined_repr.stderr
index 28bfba6c757..8319f71a83d 100644
--- a/tests/ui/transmute_undefined_repr.stderr
+++ b/tests/ui/transmute_undefined_repr.stderr
@@ -60,8 +60,24 @@ LL |         let _: Box<Ty2<u32, u32>> = transmute(value::<&'static mut Ty2<u32,
    |
    = note: two instances of the same generic type (`Ty2`) may have different layouts
 
+error: transmute into `*const Ty2<u32, u32>` which has an undefined layout
+  --> $DIR/transmute_undefined_repr.rs:118:39
+   |
+LL |         let _: *const Ty2<u32, u32> = transmute(value::<*const Ty2C<u32, Ty2<u32, u32>>>()); // Err
+   |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: the contained type `Ty2<u32, u32>` has an undefined layout
+
+error: transmute from `*const Ty2<u32, u32>` which has an undefined layout
+  --> $DIR/transmute_undefined_repr.rs:119:50
+   |
+LL |         let _: *const Ty2C<u32, Ty2<u32, u32>> = transmute(value::<*const Ty2<u32, u32>>()); // Err
+   |                                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: the contained type `Ty2<u32, u32>` has an undefined layout
+
 error: transmute from `std::vec::Vec<Ty2<U, i32>>` to `std::vec::Vec<Ty2<T, u32>>`, both of which have an undefined layout
-  --> $DIR/transmute_undefined_repr.rs:138:35
+  --> $DIR/transmute_undefined_repr.rs:146:35
    |
 LL |         let _: Vec<Ty2<T, u32>> = transmute(value::<Vec<Ty2<U, i32>>>()); // Err
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -69,12 +85,12 @@ LL |         let _: Vec<Ty2<T, u32>> = transmute(value::<Vec<Ty2<U, i32>>>()); /
    = note: two instances of the same generic type (`Vec`) may have different layouts
 
 error: transmute from `std::vec::Vec<Ty2<T, u32>>` to `std::vec::Vec<Ty2<U, i32>>`, both of which have an undefined layout
-  --> $DIR/transmute_undefined_repr.rs:139:35
+  --> $DIR/transmute_undefined_repr.rs:147:35
    |
 LL |         let _: Vec<Ty2<U, i32>> = transmute(value::<Vec<Ty2<T, u32>>>()); // Err
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: two instances of the same generic type (`Vec`) may have different layouts
 
-error: aborting due to 10 previous errors
+error: aborting due to 12 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 80f0f280df446d5b4169d1cf1314b030f52c02c1 Mon Sep 17 00:00:00 2001
From: Michael Krasnitski <michael.krasnitski@gmail.com>
Date: Wed, 3 Aug 2022 23:06:12 -0400
Subject: Extend `if_then_some_else_none` to also suggest `bool::then_some`

---
 clippy_lints/src/if_then_some_else_none.rs | 82 ++++++++++++++++--------------
 tests/ui/if_then_some_else_none.stderr     |  8 +--
 2 files changed, 47 insertions(+), 43 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/if_then_some_else_none.rs b/clippy_lints/src/if_then_some_else_none.rs
index b8d227855d9..20fcba90773 100644
--- a/clippy_lints/src/if_then_some_else_none.rs
+++ b/clippy_lints/src/if_then_some_else_none.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::eager_or_lazy::switch_to_eager_eval;
 use clippy_utils::source::snippet_with_macro_callsite;
 use clippy_utils::{contains_return, higher, is_else_clause, is_lang_ctor, meets_msrv, msrvs, peel_blocks};
-use if_chain::if_chain;
 use rustc_hir::LangItem::{OptionNone, OptionSome};
 use rustc_hir::{Expr, ExprKind, Stmt, StmtKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
@@ -56,7 +56,7 @@ impl IfThenSomeElseNone {
 impl_lint_pass!(IfThenSomeElseNone => [IF_THEN_SOME_ELSE_NONE]);
 
 impl<'tcx> LateLintPass<'tcx> for IfThenSomeElseNone {
-    fn check_expr(&mut self, cx: &LateContext<'_>, expr: &'tcx Expr<'_>) {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
         if !meets_msrv(self.msrv, msrvs::BOOL_THEN) {
             return;
         }
@@ -70,43 +70,47 @@ impl<'tcx> LateLintPass<'tcx> for IfThenSomeElseNone {
             return;
         }
 
-        if_chain! {
-            if let Some(higher::If { cond, then, r#else: Some(els) }) = higher::If::hir(expr);
-            if let ExprKind::Block(then_block, _) = then.kind;
-            if let Some(then_expr) = then_block.expr;
-            if let ExprKind::Call(then_call, [then_arg]) = then_expr.kind;
-            if let ExprKind::Path(ref then_call_qpath) = then_call.kind;
-            if is_lang_ctor(cx, then_call_qpath, OptionSome);
-            if let ExprKind::Path(ref qpath) = peel_blocks(els).kind;
-            if is_lang_ctor(cx, qpath, OptionNone);
-            if !stmts_contains_early_return(then_block.stmts);
-            then {
-                let cond_snip = snippet_with_macro_callsite(cx, cond.span, "[condition]");
-                let cond_snip = if matches!(cond.kind, ExprKind::Unary(_, _) | ExprKind::Binary(_, _, _)) {
-                    format!("({})", cond_snip)
-                } else {
-                    cond_snip.into_owned()
-                };
-                let arg_snip = snippet_with_macro_callsite(cx, then_arg.span, "");
-                let closure_body = if then_block.stmts.is_empty() {
-                    arg_snip.into_owned()
-                } else {
-                    format!("{{ /* snippet */ {} }}", arg_snip)
-                };
-                let help = format!(
-                    "consider using `bool::then` like: `{}.then(|| {})`",
-                    cond_snip,
-                    closure_body,
-                );
-                span_lint_and_help(
-                    cx,
-                    IF_THEN_SOME_ELSE_NONE,
-                    expr.span,
-                    "this could be simplified with `bool::then`",
-                    None,
-                    &help,
-                );
-            }
+        if let Some(higher::If { cond, then, r#else: Some(els) }) = higher::If::hir(expr)
+            && let ExprKind::Block(then_block, _) = then.kind
+            && let Some(then_expr) = then_block.expr
+            && let ExprKind::Call(then_call, [then_arg]) = then_expr.kind
+            && let ExprKind::Path(ref then_call_qpath) = then_call.kind
+            && is_lang_ctor(cx, then_call_qpath, OptionSome)
+            && let ExprKind::Path(ref qpath) = peel_blocks(els).kind
+            && is_lang_ctor(cx, qpath, OptionNone)
+            && !stmts_contains_early_return(then_block.stmts)
+        {
+            let cond_snip = snippet_with_macro_callsite(cx, cond.span, "[condition]");
+            let cond_snip = if matches!(cond.kind, ExprKind::Unary(_, _) | ExprKind::Binary(_, _, _)) {
+                format!("({})", cond_snip)
+            } else {
+                cond_snip.into_owned()
+            };
+            let arg_snip = snippet_with_macro_callsite(cx, then_arg.span, "");
+            let mut method_body = if then_block.stmts.is_empty() {
+                arg_snip.into_owned()
+            } else {
+                format!("{{ /* snippet */ {} }}", arg_snip)
+            };
+            let method_name = if switch_to_eager_eval(cx, expr) && meets_msrv(self.msrv, msrvs::BOOL_THEN_SOME) {
+                "then_some"
+            } else {
+                method_body.insert_str(0, "|| ");
+                "then"
+            };
+
+            let help = format!(
+                "consider using `bool::{}` like: `{}.{}({})`",
+                method_name, cond_snip, method_name, method_body,
+            );
+            span_lint_and_help(
+                cx,
+                IF_THEN_SOME_ELSE_NONE,
+                expr.span,
+                &format!("this could be simplified with `bool::{}`", method_name),
+                None,
+                &help,
+            );
         }
     }
 
diff --git a/tests/ui/if_then_some_else_none.stderr b/tests/ui/if_then_some_else_none.stderr
index 8cb22d569f4..c22ace30d2d 100644
--- a/tests/ui/if_then_some_else_none.stderr
+++ b/tests/ui/if_then_some_else_none.stderr
@@ -27,21 +27,21 @@ LL | |     };
    |
    = help: consider using `bool::then` like: `matches!(true, true).then(|| { /* snippet */ matches!(true, false) })`
 
-error: this could be simplified with `bool::then`
+error: this could be simplified with `bool::then_some`
   --> $DIR/if_then_some_else_none.rs:23:28
    |
 LL |     let _ = x.and_then(|o| if o < 32 { Some(o) } else { None });
    |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: consider using `bool::then` like: `(o < 32).then(|| o)`
+   = help: consider using `bool::then_some` like: `(o < 32).then_some(o)`
 
-error: this could be simplified with `bool::then`
+error: this could be simplified with `bool::then_some`
   --> $DIR/if_then_some_else_none.rs:27:13
    |
 LL |     let _ = if !x { Some(0) } else { None };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: consider using `bool::then` like: `(!x).then(|| 0)`
+   = help: consider using `bool::then_some` like: `(!x).then_some(0)`
 
 error: this could be simplified with `bool::then`
   --> $DIR/if_then_some_else_none.rs:82:13
-- 
cgit 1.4.1-3-g733a5


From 7062a013e73a9571470cfe4df9940f7c47c6cbf3 Mon Sep 17 00:00:00 2001
From: alex-semenyuk <alexsemenyuk88@gmail.com>
Date: Thu, 4 Aug 2022 19:53:07 +0300
Subject: Fix some typos

---
 clippy_lints/src/missing_const_for_fn.rs                | 4 ++--
 clippy_lints/src/utils/internal_lints.rs                | 2 +-
 tests/ui-internal/check_clippy_version_attribute.stderr | 4 ++--
 3 files changed, 5 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/missing_const_for_fn.rs b/clippy_lints/src/missing_const_for_fn.rs
index 16d65966c10..2bd920db302 100644
--- a/clippy_lints/src/missing_const_for_fn.rs
+++ b/clippy_lints/src/missing_const_for_fn.rs
@@ -124,7 +124,7 @@ impl<'tcx> LateLintPass<'tcx> for MissingConstForFn {
             FnKind::Method(_, sig, ..) => {
                 if trait_ref_of_method(cx, def_id).is_some()
                     || already_const(sig.header)
-                    || method_accepts_dropable(cx, sig.decl.inputs)
+                    || method_accepts_droppable(cx, sig.decl.inputs)
                 {
                     return;
                 }
@@ -159,7 +159,7 @@ impl<'tcx> LateLintPass<'tcx> for MissingConstForFn {
 
 /// Returns true if any of the method parameters is a type that implements `Drop`. The method
 /// can't be made const then, because `drop` can't be const-evaluated.
-fn method_accepts_dropable(cx: &LateContext<'_>, param_tys: &[hir::Ty<'_>]) -> bool {
+fn method_accepts_droppable(cx: &LateContext<'_>, param_tys: &[hir::Ty<'_>]) -> bool {
     // If any of the params are droppable, return true
     param_tys.iter().any(|hir_ty| {
         let ty_ty = hir_ty_to_ty(cx.tcx, hir_ty);
diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs
index b309653291b..3de96f72bbc 100644
--- a/clippy_lints/src/utils/internal_lints.rs
+++ b/clippy_lints/src/utils/internal_lints.rs
@@ -569,7 +569,7 @@ fn check_invalid_clippy_version_attribute(cx: &LateContext<'_>, item: &'_ Item<'
                 item.span,
                 "this item has an invalid `clippy::version` attribute",
                 None,
-                "please use a valid sematic version, see `doc/adding_lints.md`",
+                "please use a valid semantic version, see `doc/adding_lints.md`",
             );
         }
     } else {
diff --git a/tests/ui-internal/check_clippy_version_attribute.stderr b/tests/ui-internal/check_clippy_version_attribute.stderr
index 5331075885c..ab7c8d59307 100644
--- a/tests/ui-internal/check_clippy_version_attribute.stderr
+++ b/tests/ui-internal/check_clippy_version_attribute.stderr
@@ -16,7 +16,7 @@ note: the lint level is defined here
 LL | #![deny(clippy::internal)]
    |         ^^^^^^^^^^^^^^^^
    = note: `#[deny(clippy::invalid_clippy_version_attribute)]` implied by `#[deny(clippy::internal)]`
-   = help: please use a valid sematic version, see `doc/adding_lints.md`
+   = help: please use a valid senmatic version, see `doc/adding_lints.md`
    = note: this error originates in the macro `$crate::declare_tool_lint` which comes from the expansion of the macro `declare_tool_lint` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: this item has an invalid `clippy::version` attribute
@@ -31,7 +31,7 @@ LL | |     report_in_external_macro: true
 LL | | }
    | |_^
    |
-   = help: please use a valid sematic version, see `doc/adding_lints.md`
+   = help: please use a valid semantic version, see `doc/adding_lints.md`
    = note: this error originates in the macro `$crate::declare_tool_lint` which comes from the expansion of the macro `declare_tool_lint` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: this lint is missing the `clippy::version` attribute or version value
-- 
cgit 1.4.1-3-g733a5


From 0e1d65850afd9ebf894526c75ddf7d6dcabf4097 Mon Sep 17 00:00:00 2001
From: alex-semenyuk <alexsemenyuk88@gmail.com>
Date: Sat, 30 Jul 2022 17:21:37 +0300
Subject: Fix cast_abs_to_unsigned generates non-compiling code when original
 code is in parens

---
 clippy_lints/src/casts/cast_abs_to_unsigned.rs | 2 +-
 tests/ui/cast_abs_to_unsigned.fixed            | 2 ++
 tests/ui/cast_abs_to_unsigned.rs               | 2 ++
 tests/ui/cast_abs_to_unsigned.stderr           | 8 +++++++-
 4 files changed, 12 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/cast_abs_to_unsigned.rs b/clippy_lints/src/casts/cast_abs_to_unsigned.rs
index 64ea326b75a..6426e8c25ac 100644
--- a/clippy_lints/src/casts/cast_abs_to_unsigned.rs
+++ b/clippy_lints/src/casts/cast_abs_to_unsigned.rs
@@ -37,7 +37,7 @@ pub(super) fn check(
             span,
             &format!("casting the result of `{cast_from}::abs()` to {cast_to}"),
             "replace with",
-            format!("{}.unsigned_abs()", Sugg::hir(cx, &args[0], "..")),
+            format!("{}.unsigned_abs()", Sugg::hir(cx, &args[0], "..").maybe_par()),
             Applicability::MachineApplicable,
         );
     }
diff --git a/tests/ui/cast_abs_to_unsigned.fixed b/tests/ui/cast_abs_to_unsigned.fixed
index a68b32b097e..7ecefd7b134 100644
--- a/tests/ui/cast_abs_to_unsigned.fixed
+++ b/tests/ui/cast_abs_to_unsigned.fixed
@@ -26,4 +26,6 @@ fn main() {
     let _ = a.unsigned_abs() as u32;
     let _ = a.unsigned_abs() as u64;
     let _ = a.unsigned_abs() as u128;
+
+    let _ = (x as i64 - y as i64).unsigned_abs() as u32;
 }
diff --git a/tests/ui/cast_abs_to_unsigned.rs b/tests/ui/cast_abs_to_unsigned.rs
index 110fbc6c2df..30c603fca9a 100644
--- a/tests/ui/cast_abs_to_unsigned.rs
+++ b/tests/ui/cast_abs_to_unsigned.rs
@@ -26,4 +26,6 @@ fn main() {
     let _ = a.abs() as u32;
     let _ = a.abs() as u64;
     let _ = a.abs() as u128;
+
+    let _ = (x as i64 - y as i64).abs() as u32;
 }
diff --git a/tests/ui/cast_abs_to_unsigned.stderr b/tests/ui/cast_abs_to_unsigned.stderr
index 02c24e10659..04553774526 100644
--- a/tests/ui/cast_abs_to_unsigned.stderr
+++ b/tests/ui/cast_abs_to_unsigned.stderr
@@ -96,5 +96,11 @@ error: casting the result of `isize::abs()` to u128
 LL |     let _ = a.abs() as u128;
    |             ^^^^^^^ help: replace with: `a.unsigned_abs()`
 
-error: aborting due to 16 previous errors
+error: casting the result of `i64::abs()` to u32
+  --> $DIR/cast_abs_to_unsigned.rs:30:13
+   |
+LL |     let _ = (x as i64 - y as i64).abs() as u32;
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `(x as i64 - y as i64).unsigned_abs()`
+
+error: aborting due to 17 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 99e77d07b2856fccd083d5810a9756e07cc4c524 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sun, 7 Aug 2022 17:47:24 -0400
Subject: Allow type erasure using `*const/mut int_type` in
 `transmute_undefined_repr`

---
 .../src/transmute/transmute_undefined_repr.rs      | 397 ++++++++++-----------
 tests/ui/transmute_undefined_repr.rs               |   4 +
 tests/ui/transmute_undefined_repr.stderr           |  24 +-
 3 files changed, 195 insertions(+), 230 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/transmute/transmute_undefined_repr.rs b/clippy_lints/src/transmute/transmute_undefined_repr.rs
index bf1cfb859bc..b6d7d9f5b42 100644
--- a/clippy_lints/src/transmute/transmute_undefined_repr.rs
+++ b/clippy_lints/src/transmute/transmute_undefined_repr.rs
@@ -5,9 +5,9 @@ use rustc_hir::Expr;
 use rustc_lint::LateContext;
 use rustc_middle::ty::subst::{Subst, SubstsRef};
 use rustc_middle::ty::{self, IntTy, Ty, TypeAndMut, UintTy};
-use rustc_span::Span;
+use rustc_span::DUMMY_SP;
 
-#[allow(clippy::too_many_lines)]
+#[expect(clippy::too_many_lines)]
 pub(super) fn check<'tcx>(
     cx: &LateContext<'tcx>,
     e: &'tcx Expr<'_>,
@@ -18,116 +18,89 @@ pub(super) fn check<'tcx>(
     let mut to_ty = cx.tcx.erase_regions(to_ty_orig);
 
     while from_ty != to_ty {
-        match reduce_refs(cx, e.span, from_ty, to_ty) {
-            ReducedTys::FromFatPtr {
-                unsized_ty,
-                to_ty: to_sub_ty,
-            } => match reduce_ty(cx, to_sub_ty) {
-                ReducedTy::TypeErasure => break,
-                ReducedTy::UnorderedFields(ty) if is_size_pair(ty) => break,
-                ReducedTy::Ref(to_sub_ty) => {
-                    from_ty = unsized_ty;
-                    to_ty = to_sub_ty;
-                    continue;
-                },
-                _ => {
-                    span_lint_and_then(
-                        cx,
-                        TRANSMUTE_UNDEFINED_REPR,
-                        e.span,
-                        &format!("transmute from `{}` which has an undefined layout", from_ty_orig),
-                        |diag| {
-                            if from_ty_orig.peel_refs() != unsized_ty {
-                                diag.note(&format!("the contained type `&{}` has an undefined layout", unsized_ty));
-                            }
-                        },
-                    );
-                    return true;
-                },
+        let reduced_tys = reduce_refs(cx, from_ty, to_ty);
+        match (reduce_ty(cx, reduced_tys.from_ty), reduce_ty(cx, reduced_tys.to_ty)) {
+            // Various forms of type erasure.
+            (ReducedTy::TypeErasure { raw_ptr_only: false }, _)
+            | (_, ReducedTy::TypeErasure { raw_ptr_only: false }) => return false,
+            (ReducedTy::TypeErasure { .. }, _) if reduced_tys.from_raw_ptr => return false,
+            (_, ReducedTy::TypeErasure { .. }) if reduced_tys.to_raw_ptr => return false,
+
+            // `Repr(C)` <-> unordered type.
+            // If the first field of the `Repr(C)` type matches then the transmute is ok
+            (ReducedTy::OrderedFields(_, Some(from_sub_ty)), ReducedTy::UnorderedFields(to_sub_ty))
+            | (ReducedTy::UnorderedFields(from_sub_ty), ReducedTy::OrderedFields(_, Some(to_sub_ty))) => {
+                from_ty = from_sub_ty;
+                to_ty = to_sub_ty;
+                continue;
             },
-            ReducedTys::ToFatPtr {
-                unsized_ty,
-                from_ty: from_sub_ty,
-            } => match reduce_ty(cx, from_sub_ty) {
-                ReducedTy::TypeErasure => break,
-                ReducedTy::UnorderedFields(ty) if is_size_pair(ty) => break,
-                ReducedTy::Ref(from_sub_ty) => {
-                    from_ty = from_sub_ty;
-                    to_ty = unsized_ty;
-                    continue;
-                },
-                _ => {
-                    span_lint_and_then(
-                        cx,
-                        TRANSMUTE_UNDEFINED_REPR,
-                        e.span,
-                        &format!("transmute to `{}` which has an undefined layout", to_ty_orig),
-                        |diag| {
-                            if to_ty_orig.peel_refs() != unsized_ty {
-                                diag.note(&format!("the contained type `&{}` has an undefined layout", unsized_ty));
-                            }
-                        },
-                    );
-                    return true;
-                },
+            (ReducedTy::OrderedFields(_, Some(from_sub_ty)), ReducedTy::Other(to_sub_ty)) if reduced_tys.to_fat_ptr => {
+                from_ty = from_sub_ty;
+                to_ty = to_sub_ty;
+                continue;
             },
-            ReducedTys::ToPtr {
-                from_ty: from_sub_ty,
-                to_ty: to_sub_ty,
-            } => match reduce_ty(cx, from_sub_ty) {
-                ReducedTy::UnorderedFields(from_ty) => {
-                    span_lint_and_then(
-                        cx,
-                        TRANSMUTE_UNDEFINED_REPR,
-                        e.span,
-                        &format!("transmute from `{}` which has an undefined layout", from_ty_orig),
-                        |diag| {
-                            if from_ty_orig.peel_refs() != from_ty {
-                                diag.note(&format!("the contained type `{}` has an undefined layout", from_ty));
-                            }
-                        },
-                    );
-                    return true;
-                },
-                ReducedTy::Ref(from_sub_ty) => {
-                    from_ty = from_sub_ty;
-                    to_ty = to_sub_ty;
-                    continue;
-                },
-                _ => break,
+            (ReducedTy::Other(from_sub_ty), ReducedTy::OrderedFields(_, Some(to_sub_ty)))
+                if reduced_tys.from_fat_ptr =>
+            {
+                from_ty = from_sub_ty;
+                to_ty = to_sub_ty;
+                continue;
             },
-            ReducedTys::FromPtr {
-                from_ty: from_sub_ty,
-                to_ty: to_sub_ty,
-            } => match reduce_ty(cx, to_sub_ty) {
-                ReducedTy::UnorderedFields(to_ty) => {
-                    span_lint_and_then(
-                        cx,
-                        TRANSMUTE_UNDEFINED_REPR,
-                        e.span,
-                        &format!("transmute to `{}` which has an undefined layout", to_ty_orig),
-                        |diag| {
-                            if to_ty_orig.peel_refs() != to_ty {
-                                diag.note(&format!("the contained type `{}` has an undefined layout", to_ty));
-                            }
-                        },
-                    );
-                    return true;
-                },
-                ReducedTy::Ref(to_sub_ty) => {
-                    from_ty = from_sub_ty;
-                    to_ty = to_sub_ty;
-                    continue;
-                },
-                _ => break,
+
+            // ptr <-> ptr
+            (ReducedTy::Other(from_sub_ty), ReducedTy::Other(to_sub_ty))
+                if matches!(from_sub_ty.kind(), ty::Ref(..) | ty::RawPtr(_))
+                    && matches!(to_sub_ty.kind(), ty::Ref(..) | ty::RawPtr(_)) =>
+            {
+                from_ty = from_sub_ty;
+                to_ty = to_sub_ty;
+                continue;
             },
-            ReducedTys::Other {
-                from_ty: from_sub_ty,
-                to_ty: to_sub_ty,
-            } => match (reduce_ty(cx, from_sub_ty), reduce_ty(cx, to_sub_ty)) {
-                (ReducedTy::TypeErasure, _) | (_, ReducedTy::TypeErasure) => return false,
-                (ReducedTy::UnorderedFields(from_ty), ReducedTy::UnorderedFields(to_ty)) if from_ty != to_ty => {
-                    let same_adt_did = if let (ty::Adt(from_def, from_subs), ty::Adt(to_def, to_subs))
+
+            // fat ptr <-> (*size, *size)
+            (ReducedTy::Other(_), ReducedTy::UnorderedFields(to_ty))
+                if reduced_tys.from_fat_ptr && is_size_pair(to_ty) =>
+            {
+                return false;
+            },
+            (ReducedTy::UnorderedFields(from_ty), ReducedTy::Other(_))
+                if reduced_tys.to_fat_ptr && is_size_pair(from_ty) =>
+            {
+                return false;
+            },
+
+            // fat ptr -> some struct | some struct -> fat ptr
+            (ReducedTy::Other(_), _) if reduced_tys.from_fat_ptr => {
+                span_lint_and_then(
+                    cx,
+                    TRANSMUTE_UNDEFINED_REPR,
+                    e.span,
+                    &format!("transmute from `{}` which has an undefined layout", from_ty_orig),
+                    |diag| {
+                        if from_ty_orig.peel_refs() != from_ty.peel_refs() {
+                            diag.note(&format!("the contained type `{}` has an undefined layout", from_ty));
+                        }
+                    },
+                );
+                return true;
+            },
+            (_, ReducedTy::Other(_)) if reduced_tys.to_fat_ptr => {
+                span_lint_and_then(
+                    cx,
+                    TRANSMUTE_UNDEFINED_REPR,
+                    e.span,
+                    &format!("transmute to `{}` which has an undefined layout", to_ty_orig),
+                    |diag| {
+                        if to_ty_orig.peel_refs() != to_ty.peel_refs() {
+                            diag.note(&format!("the contained type `{}` has an undefined layout", to_ty));
+                        }
+                    },
+                );
+                return true;
+            },
+
+            (ReducedTy::UnorderedFields(from_ty), ReducedTy::UnorderedFields(to_ty)) if from_ty != to_ty => {
+                let same_adt_did = if let (ty::Adt(from_def, from_subs), ty::Adt(to_def, to_subs))
                         = (from_ty.kind(), to_ty.kind())
                         && from_def == to_def
                     {
@@ -138,83 +111,72 @@ pub(super) fn check<'tcx>(
                     } else {
                         None
                     };
-                    span_lint_and_then(
-                        cx,
-                        TRANSMUTE_UNDEFINED_REPR,
-                        e.span,
-                        &format!(
-                            "transmute from `{}` to `{}`, both of which have an undefined layout",
-                            from_ty_orig, to_ty_orig
-                        ),
-                        |diag| {
-                            if let Some(same_adt_did) = same_adt_did {
-                                diag.note(&format!(
-                                    "two instances of the same generic type (`{}`) may have different layouts",
-                                    cx.tcx.item_name(same_adt_did)
-                                ));
-                            } else {
-                                if from_ty_orig.peel_refs() != from_ty {
-                                    diag.note(&format!("the contained type `{}` has an undefined layout", from_ty));
-                                }
-                                if to_ty_orig.peel_refs() != to_ty {
-                                    diag.note(&format!("the contained type `{}` has an undefined layout", to_ty));
-                                }
-                            }
-                        },
-                    );
-                    return true;
-                },
-                // `Repr(C)` <-> unordered type.
-                // If the first field of the `Repr(C)` type matches then the transmute is ok
-                (ReducedTy::OrderedFields(_, Some(from_sub_ty)), ReducedTy::UnorderedFields(to_sub_ty))
-                | (ReducedTy::UnorderedFields(from_sub_ty), ReducedTy::OrderedFields(_, Some(to_sub_ty)))
-                | (ReducedTy::Ref(from_sub_ty), ReducedTy::Ref(to_sub_ty)) => {
-                    from_ty = from_sub_ty;
-                    to_ty = to_sub_ty;
-                    continue;
-                },
-                (
-                    ReducedTy::UnorderedFields(from_ty),
-                    ReducedTy::Other(_) | ReducedTy::OrderedFields(..) | ReducedTy::Ref(_),
-                ) => {
-                    span_lint_and_then(
-                        cx,
-                        TRANSMUTE_UNDEFINED_REPR,
-                        e.span,
-                        &format!("transmute from `{}` which has an undefined layout", from_ty_orig),
-                        |diag| {
+                span_lint_and_then(
+                    cx,
+                    TRANSMUTE_UNDEFINED_REPR,
+                    e.span,
+                    &format!(
+                        "transmute from `{}` to `{}`, both of which have an undefined layout",
+                        from_ty_orig, to_ty_orig
+                    ),
+                    |diag| {
+                        if let Some(same_adt_did) = same_adt_did {
+                            diag.note(&format!(
+                                "two instances of the same generic type (`{}`) may have different layouts",
+                                cx.tcx.item_name(same_adt_did)
+                            ));
+                        } else {
                             if from_ty_orig.peel_refs() != from_ty {
                                 diag.note(&format!("the contained type `{}` has an undefined layout", from_ty));
                             }
-                        },
-                    );
-                    return true;
-                },
-                (
-                    ReducedTy::Other(_) | ReducedTy::OrderedFields(..) | ReducedTy::Ref(_),
-                    ReducedTy::UnorderedFields(to_ty),
-                ) => {
-                    span_lint_and_then(
-                        cx,
-                        TRANSMUTE_UNDEFINED_REPR,
-                        e.span,
-                        &format!("transmute into `{}` which has an undefined layout", to_ty_orig),
-                        |diag| {
                             if to_ty_orig.peel_refs() != to_ty {
                                 diag.note(&format!("the contained type `{}` has an undefined layout", to_ty));
                             }
-                        },
-                    );
-                    return true;
-                },
-                (
-                    ReducedTy::OrderedFields(..) | ReducedTy::Ref(_) | ReducedTy::Other(_) | ReducedTy::Param,
-                    ReducedTy::OrderedFields(..) | ReducedTy::Ref(_) | ReducedTy::Other(_) | ReducedTy::Param,
-                )
-                | (
-                    ReducedTy::UnorderedFields(_) | ReducedTy::Param,
-                    ReducedTy::UnorderedFields(_) | ReducedTy::Param,
-                ) => break,
+                        }
+                    },
+                );
+                return true;
+            },
+            (
+                ReducedTy::UnorderedFields(from_ty),
+                ReducedTy::Other(_) | ReducedTy::OrderedFields(..) | ReducedTy::TypeErasure { raw_ptr_only: true },
+            ) => {
+                span_lint_and_then(
+                    cx,
+                    TRANSMUTE_UNDEFINED_REPR,
+                    e.span,
+                    &format!("transmute from `{}` which has an undefined layout", from_ty_orig),
+                    |diag| {
+                        if from_ty_orig.peel_refs() != from_ty {
+                            diag.note(&format!("the contained type `{}` has an undefined layout", from_ty));
+                        }
+                    },
+                );
+                return true;
+            },
+            (
+                ReducedTy::Other(_) | ReducedTy::OrderedFields(..) | ReducedTy::TypeErasure { raw_ptr_only: true },
+                ReducedTy::UnorderedFields(to_ty),
+            ) => {
+                span_lint_and_then(
+                    cx,
+                    TRANSMUTE_UNDEFINED_REPR,
+                    e.span,
+                    &format!("transmute into `{}` which has an undefined layout", to_ty_orig),
+                    |diag| {
+                        if to_ty_orig.peel_refs() != to_ty {
+                            diag.note(&format!("the contained type `{}` has an undefined layout", to_ty));
+                        }
+                    },
+                );
+                return true;
+            },
+            (
+                ReducedTy::OrderedFields(..) | ReducedTy::Other(_) | ReducedTy::TypeErasure { raw_ptr_only: true },
+                ReducedTy::OrderedFields(..) | ReducedTy::Other(_) | ReducedTy::TypeErasure { raw_ptr_only: true },
+            )
+            | (ReducedTy::UnorderedFields(_), ReducedTy::UnorderedFields(_)) => {
+                break;
             },
         }
     }
@@ -222,65 +184,64 @@ pub(super) fn check<'tcx>(
     false
 }
 
-enum ReducedTys<'tcx> {
-    FromFatPtr { unsized_ty: Ty<'tcx>, to_ty: Ty<'tcx> },
-    ToFatPtr { unsized_ty: Ty<'tcx>, from_ty: Ty<'tcx> },
-    ToPtr { from_ty: Ty<'tcx>, to_ty: Ty<'tcx> },
-    FromPtr { from_ty: Ty<'tcx>, to_ty: Ty<'tcx> },
-    Other { from_ty: Ty<'tcx>, to_ty: Ty<'tcx> },
+#[expect(clippy::struct_excessive_bools)]
+struct ReducedTys<'tcx> {
+    from_ty: Ty<'tcx>,
+    to_ty: Ty<'tcx>,
+    from_raw_ptr: bool,
+    to_raw_ptr: bool,
+    from_fat_ptr: bool,
+    to_fat_ptr: bool,
 }
 
 /// Remove references so long as both types are references.
-fn reduce_refs<'tcx>(
-    cx: &LateContext<'tcx>,
-    span: Span,
-    mut from_ty: Ty<'tcx>,
-    mut to_ty: Ty<'tcx>,
-) -> ReducedTys<'tcx> {
-    loop {
-        return match (from_ty.kind(), to_ty.kind()) {
+fn reduce_refs<'tcx>(cx: &LateContext<'tcx>, mut from_ty: Ty<'tcx>, mut to_ty: Ty<'tcx>) -> ReducedTys<'tcx> {
+    let mut from_raw_ptr = false;
+    let mut to_raw_ptr = false;
+    let (from_fat_ptr, to_fat_ptr) = loop {
+        break match (from_ty.kind(), to_ty.kind()) {
             (
                 &(ty::Ref(_, from_sub_ty, _) | ty::RawPtr(TypeAndMut { ty: from_sub_ty, .. })),
                 &(ty::Ref(_, to_sub_ty, _) | ty::RawPtr(TypeAndMut { ty: to_sub_ty, .. })),
             ) => {
+                from_raw_ptr = matches!(*from_ty.kind(), ty::RawPtr(_));
                 from_ty = from_sub_ty;
+                to_raw_ptr = matches!(*to_ty.kind(), ty::RawPtr(_));
                 to_ty = to_sub_ty;
                 continue;
             },
             (&(ty::Ref(_, unsized_ty, _) | ty::RawPtr(TypeAndMut { ty: unsized_ty, .. })), _)
-                if !unsized_ty.is_sized(cx.tcx.at(span), cx.param_env) =>
+                if !unsized_ty.is_sized(cx.tcx.at(DUMMY_SP), cx.param_env) =>
             {
-                ReducedTys::FromFatPtr { unsized_ty, to_ty }
+                (true, false)
             },
             (_, &(ty::Ref(_, unsized_ty, _) | ty::RawPtr(TypeAndMut { ty: unsized_ty, .. })))
-                if !unsized_ty.is_sized(cx.tcx.at(span), cx.param_env) =>
+                if !unsized_ty.is_sized(cx.tcx.at(DUMMY_SP), cx.param_env) =>
             {
-                ReducedTys::ToFatPtr { unsized_ty, from_ty }
+                (false, true)
             },
-            (&(ty::Ref(_, from_ty, _) | ty::RawPtr(TypeAndMut { ty: from_ty, .. })), _) => {
-                ReducedTys::FromPtr { from_ty, to_ty }
-            },
-            (_, &(ty::Ref(_, to_ty, _) | ty::RawPtr(TypeAndMut { ty: to_ty, .. }))) => {
-                ReducedTys::ToPtr { from_ty, to_ty }
-            },
-            _ => ReducedTys::Other { from_ty, to_ty },
+            _ => (false, false),
         };
+    };
+    ReducedTys {
+        from_ty,
+        to_ty,
+        from_raw_ptr,
+        to_raw_ptr,
+        from_fat_ptr,
+        to_fat_ptr,
     }
 }
 
 enum ReducedTy<'tcx> {
     /// The type can be used for type erasure.
-    TypeErasure,
+    TypeErasure { raw_ptr_only: bool },
     /// The type is a struct containing either zero non-zero sized fields, or multiple non-zero
     /// sized fields with a defined order.
     /// The second value is the first non-zero sized type.
     OrderedFields(Ty<'tcx>, Option<Ty<'tcx>>),
     /// The type is a struct containing multiple non-zero sized fields with no defined order.
     UnorderedFields(Ty<'tcx>),
-    /// The type is a reference to the contained type.
-    Ref(Ty<'tcx>),
-    /// The type is a generic parameter.
-    Param,
     /// Any other type.
     Other(Ty<'tcx>),
 }
@@ -290,12 +251,14 @@ fn reduce_ty<'tcx>(cx: &LateContext<'tcx>, mut ty: Ty<'tcx>) -> ReducedTy<'tcx>
     loop {
         ty = cx.tcx.try_normalize_erasing_regions(cx.param_env, ty).unwrap_or(ty);
         return match *ty.kind() {
-            ty::Array(sub_ty, _) if matches!(sub_ty.kind(), ty::Int(_) | ty::Uint(_)) => ReducedTy::TypeErasure,
+            ty::Array(sub_ty, _) if matches!(sub_ty.kind(), ty::Int(_) | ty::Uint(_)) => {
+                ReducedTy::TypeErasure { raw_ptr_only: false }
+            },
             ty::Array(sub_ty, _) | ty::Slice(sub_ty) => {
                 ty = sub_ty;
                 continue;
             },
-            ty::Tuple(args) if args.is_empty() => ReducedTy::TypeErasure,
+            ty::Tuple(args) if args.is_empty() => ReducedTy::TypeErasure { raw_ptr_only: false },
             ty::Tuple(args) => {
                 let mut iter = args.iter();
                 let Some(sized_ty) = iter.find(|&ty| !is_zero_sized_ty(cx, ty)) else {
@@ -314,7 +277,7 @@ fn reduce_ty<'tcx>(cx: &LateContext<'tcx>, mut ty: Ty<'tcx>) -> ReducedTy<'tcx>
                     .iter()
                     .map(|f| cx.tcx.bound_type_of(f.did).subst(cx.tcx, substs));
                 let Some(sized_ty) = iter.find(|&ty| !is_zero_sized_ty(cx, ty)) else {
-                    return ReducedTy::TypeErasure;
+                    return ReducedTy::TypeErasure { raw_ptr_only: false };
                 };
                 if iter.all(|ty| is_zero_sized_ty(cx, ty)) {
                     ty = sized_ty;
@@ -327,14 +290,12 @@ fn reduce_ty<'tcx>(cx: &LateContext<'tcx>, mut ty: Ty<'tcx>) -> ReducedTy<'tcx>
                 }
             },
             ty::Adt(def, _) if def.is_enum() && (def.variants().is_empty() || is_c_void(cx, ty)) => {
-                ReducedTy::TypeErasure
+                ReducedTy::TypeErasure { raw_ptr_only: false }
             },
             // TODO: Check if the conversion to or from at least one of a union's fields is valid.
-            ty::Adt(def, _) if def.is_union() => ReducedTy::TypeErasure,
-            ty::Foreign(_) => ReducedTy::TypeErasure,
-            ty::Ref(_, ty, _) => ReducedTy::Ref(ty),
-            ty::RawPtr(ty) => ReducedTy::Ref(ty.ty),
-            ty::Param(_) => ReducedTy::Param,
+            ty::Adt(def, _) if def.is_union() => ReducedTy::TypeErasure { raw_ptr_only: false },
+            ty::Foreign(_) | ty::Param(_) => ReducedTy::TypeErasure { raw_ptr_only: false },
+            ty::Int(_) | ty::Uint(_) => ReducedTy::TypeErasure { raw_ptr_only: true },
             _ => ReducedTy::Other(ty),
         };
     }
diff --git a/tests/ui/transmute_undefined_repr.rs b/tests/ui/transmute_undefined_repr.rs
index 6df8ed8feea..5aad0b44270 100644
--- a/tests/ui/transmute_undefined_repr.rs
+++ b/tests/ui/transmute_undefined_repr.rs
@@ -4,6 +4,7 @@
 use core::any::TypeId;
 use core::ffi::c_void;
 use core::mem::{size_of, transmute, MaybeUninit};
+use core::ptr::NonNull;
 
 fn value<T>() -> T {
     unimplemented!()
@@ -117,6 +118,9 @@ fn main() {
 
         let _: *const Ty2<u32, u32> = transmute(value::<*const Ty2C<u32, Ty2<u32, u32>>>()); // Err
         let _: *const Ty2C<u32, Ty2<u32, u32>> = transmute(value::<*const Ty2<u32, u32>>()); // Err
+
+        let _: NonNull<u8> = transmute(value::<NonNull<(String, String)>>()); // Ok
+        let _: NonNull<(String, String)> = transmute(value::<NonNull<u8>>()); // Ok
     }
 }
 
diff --git a/tests/ui/transmute_undefined_repr.stderr b/tests/ui/transmute_undefined_repr.stderr
index 8319f71a83d..e50a773290e 100644
--- a/tests/ui/transmute_undefined_repr.stderr
+++ b/tests/ui/transmute_undefined_repr.stderr
@@ -1,5 +1,5 @@
 error: transmute from `Ty2<u32, i32>` which has an undefined layout
-  --> $DIR/transmute_undefined_repr.rs:27:33
+  --> $DIR/transmute_undefined_repr.rs:28:33
    |
 LL |         let _: Ty2C<u32, i32> = transmute(value::<Ty2<u32, i32>>()); // Lint, Ty2 is unordered
    |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -7,13 +7,13 @@ LL |         let _: Ty2C<u32, i32> = transmute(value::<Ty2<u32, i32>>()); // Lin
    = note: `-D clippy::transmute-undefined-repr` implied by `-D warnings`
 
 error: transmute into `Ty2<u32, i32>` which has an undefined layout
-  --> $DIR/transmute_undefined_repr.rs:28:32
+  --> $DIR/transmute_undefined_repr.rs:29:32
    |
 LL |         let _: Ty2<u32, i32> = transmute(value::<Ty2C<u32, i32>>()); // Lint, Ty2 is unordered
    |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: transmute from `Ty<Ty2<u32, i32>>` to `Ty2<u32, f32>`, both of which have an undefined layout
-  --> $DIR/transmute_undefined_repr.rs:33:32
+  --> $DIR/transmute_undefined_repr.rs:34:32
    |
 LL |         let _: Ty2<u32, f32> = transmute(value::<Ty<Ty2<u32, i32>>>()); // Lint, different Ty2 instances
    |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -21,7 +21,7 @@ LL |         let _: Ty2<u32, f32> = transmute(value::<Ty<Ty2<u32, i32>>>()); //
    = note: two instances of the same generic type (`Ty2`) may have different layouts
 
 error: transmute from `Ty2<u32, f32>` to `Ty<Ty2<u32, i32>>`, both of which have an undefined layout
-  --> $DIR/transmute_undefined_repr.rs:34:36
+  --> $DIR/transmute_undefined_repr.rs:35:36
    |
 LL |         let _: Ty<Ty2<u32, i32>> = transmute(value::<Ty2<u32, f32>>()); // Lint, different Ty2 instances
    |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -29,7 +29,7 @@ LL |         let _: Ty<Ty2<u32, i32>> = transmute(value::<Ty2<u32, f32>>()); //
    = note: two instances of the same generic type (`Ty2`) may have different layouts
 
 error: transmute from `Ty<&Ty2<u32, i32>>` to `&Ty2<u32, f32>`, both of which have an undefined layout
-  --> $DIR/transmute_undefined_repr.rs:39:33
+  --> $DIR/transmute_undefined_repr.rs:40:33
    |
 LL |         let _: &Ty2<u32, f32> = transmute(value::<Ty<&Ty2<u32, i32>>>()); // Lint, different Ty2 instances
    |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -37,7 +37,7 @@ LL |         let _: &Ty2<u32, f32> = transmute(value::<Ty<&Ty2<u32, i32>>>()); /
    = note: two instances of the same generic type (`Ty2`) may have different layouts
 
 error: transmute from `&Ty2<u32, f32>` to `Ty<&Ty2<u32, i32>>`, both of which have an undefined layout
-  --> $DIR/transmute_undefined_repr.rs:40:37
+  --> $DIR/transmute_undefined_repr.rs:41:37
    |
 LL |         let _: Ty<&Ty2<u32, i32>> = transmute(value::<&Ty2<u32, f32>>()); // Lint, different Ty2 instances
    |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -45,7 +45,7 @@ LL |         let _: Ty<&Ty2<u32, i32>> = transmute(value::<&Ty2<u32, f32>>()); /
    = note: two instances of the same generic type (`Ty2`) may have different layouts
 
 error: transmute from `std::boxed::Box<Ty2<u32, u32>>` to `&mut Ty2<u32, f32>`, both of which have an undefined layout
-  --> $DIR/transmute_undefined_repr.rs:57:45
+  --> $DIR/transmute_undefined_repr.rs:58:45
    |
 LL |         let _: &'static mut Ty2<u32, f32> = transmute(value::<Box<Ty2<u32, u32>>>()); // Lint, different Ty2 instances
    |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -53,7 +53,7 @@ LL |         let _: &'static mut Ty2<u32, f32> = transmute(value::<Box<Ty2<u32,
    = note: two instances of the same generic type (`Ty2`) may have different layouts
 
 error: transmute from `&mut Ty2<u32, f32>` to `std::boxed::Box<Ty2<u32, u32>>`, both of which have an undefined layout
-  --> $DIR/transmute_undefined_repr.rs:58:37
+  --> $DIR/transmute_undefined_repr.rs:59:37
    |
 LL |         let _: Box<Ty2<u32, u32>> = transmute(value::<&'static mut Ty2<u32, f32>>()); // Lint, different Ty2 instances
    |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -61,7 +61,7 @@ LL |         let _: Box<Ty2<u32, u32>> = transmute(value::<&'static mut Ty2<u32,
    = note: two instances of the same generic type (`Ty2`) may have different layouts
 
 error: transmute into `*const Ty2<u32, u32>` which has an undefined layout
-  --> $DIR/transmute_undefined_repr.rs:118:39
+  --> $DIR/transmute_undefined_repr.rs:119:39
    |
 LL |         let _: *const Ty2<u32, u32> = transmute(value::<*const Ty2C<u32, Ty2<u32, u32>>>()); // Err
    |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -69,7 +69,7 @@ LL |         let _: *const Ty2<u32, u32> = transmute(value::<*const Ty2C<u32, Ty
    = note: the contained type `Ty2<u32, u32>` has an undefined layout
 
 error: transmute from `*const Ty2<u32, u32>` which has an undefined layout
-  --> $DIR/transmute_undefined_repr.rs:119:50
+  --> $DIR/transmute_undefined_repr.rs:120:50
    |
 LL |         let _: *const Ty2C<u32, Ty2<u32, u32>> = transmute(value::<*const Ty2<u32, u32>>()); // Err
    |                                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -77,7 +77,7 @@ LL |         let _: *const Ty2C<u32, Ty2<u32, u32>> = transmute(value::<*const T
    = note: the contained type `Ty2<u32, u32>` has an undefined layout
 
 error: transmute from `std::vec::Vec<Ty2<U, i32>>` to `std::vec::Vec<Ty2<T, u32>>`, both of which have an undefined layout
-  --> $DIR/transmute_undefined_repr.rs:146:35
+  --> $DIR/transmute_undefined_repr.rs:150:35
    |
 LL |         let _: Vec<Ty2<T, u32>> = transmute(value::<Vec<Ty2<U, i32>>>()); // Err
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -85,7 +85,7 @@ LL |         let _: Vec<Ty2<T, u32>> = transmute(value::<Vec<Ty2<U, i32>>>()); /
    = note: two instances of the same generic type (`Vec`) may have different layouts
 
 error: transmute from `std::vec::Vec<Ty2<T, u32>>` to `std::vec::Vec<Ty2<U, i32>>`, both of which have an undefined layout
-  --> $DIR/transmute_undefined_repr.rs:147:35
+  --> $DIR/transmute_undefined_repr.rs:151:35
    |
 LL |         let _: Vec<Ty2<U, i32>> = transmute(value::<Vec<Ty2<T, u32>>>()); // Err
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From aa0b0af3ba170ab6d502ae19ce64124a4ee70017 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sun, 7 Aug 2022 21:01:27 -0400
Subject: Move `significant_drop_in_scrutinee` into `nursey`

---
 clippy_lints/src/lib.register_all.rs        | 1 -
 clippy_lints/src/lib.register_nursery.rs    | 1 +
 clippy_lints/src/lib.register_suspicious.rs | 1 -
 clippy_lints/src/matches/mod.rs             | 2 +-
 4 files changed, 2 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index b9cc9fc1e85..ab08e65d608 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -144,7 +144,6 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(matches::MATCH_STR_CASE_MISMATCH),
     LintId::of(matches::NEEDLESS_MATCH),
     LintId::of(matches::REDUNDANT_PATTERN_MATCHING),
-    LintId::of(matches::SIGNIFICANT_DROP_IN_SCRUTINEE),
     LintId::of(matches::SINGLE_MATCH),
     LintId::of(matches::WILDCARD_IN_OR_PATTERNS),
     LintId::of(mem_replace::MEM_REPLACE_OPTION_WITH_NONE),
diff --git a/clippy_lints/src/lib.register_nursery.rs b/clippy_lints/src/lib.register_nursery.rs
index f961952991f..7d731d52dbb 100644
--- a/clippy_lints/src/lib.register_nursery.rs
+++ b/clippy_lints/src/lib.register_nursery.rs
@@ -13,6 +13,7 @@ store.register_group(true, "clippy::nursery", Some("clippy_nursery"), vec![
     LintId::of(future_not_send::FUTURE_NOT_SEND),
     LintId::of(index_refutable_slice::INDEX_REFUTABLE_SLICE),
     LintId::of(let_if_seq::USELESS_LET_IF_SEQ),
+    LintId::of(matches::SIGNIFICANT_DROP_IN_SCRUTINEE),
     LintId::of(methods::ITER_WITH_DRAIN),
     LintId::of(missing_const_for_fn::MISSING_CONST_FOR_FN),
     LintId::of(mutable_debug_assertion::DEBUG_ASSERT_WITH_MUT_CALL),
diff --git a/clippy_lints/src/lib.register_suspicious.rs b/clippy_lints/src/lib.register_suspicious.rs
index f7558f87098..964992bd94f 100644
--- a/clippy_lints/src/lib.register_suspicious.rs
+++ b/clippy_lints/src/lib.register_suspicious.rs
@@ -22,7 +22,6 @@ store.register_group(true, "clippy::suspicious", Some("clippy_suspicious"), vec!
     LintId::of(loops::EMPTY_LOOP),
     LintId::of(loops::FOR_LOOPS_OVER_FALLIBLES),
     LintId::of(loops::MUT_RANGE_BOUND),
-    LintId::of(matches::SIGNIFICANT_DROP_IN_SCRUTINEE),
     LintId::of(methods::NO_EFFECT_REPLACE),
     LintId::of(methods::SUSPICIOUS_MAP),
     LintId::of(mut_key::MUTABLE_KEY_TYPE),
diff --git a/clippy_lints/src/matches/mod.rs b/clippy_lints/src/matches/mod.rs
index b638f271602..97cfdf3e2d2 100644
--- a/clippy_lints/src/matches/mod.rs
+++ b/clippy_lints/src/matches/mod.rs
@@ -835,7 +835,7 @@ declare_clippy_lint! {
     /// ```
     #[clippy::version = "1.60.0"]
     pub SIGNIFICANT_DROP_IN_SCRUTINEE,
-    suspicious,
+    nursery,
     "warns when a temporary of a type with a drop with a significant side-effect might have a surprising lifetime"
 }
 
-- 
cgit 1.4.1-3-g733a5


From 2ae8b300a7f55f5cf132b640ad6a5727ba282d1e Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Wed, 13 Apr 2022 00:36:13 -0400
Subject: Don't lint `unit_arg` when expanded from a proc-macro

---
 clippy_lints/src/matches/mod.rs         |   6 +-
 clippy_lints/src/unit_types/unit_arg.rs |   3 +-
 clippy_utils/src/check_proc_macro.rs    | 167 ++++++++++++++++++++++++++++++++
 clippy_utils/src/lib.rs                 |   2 +
 clippy_utils/src/source.rs              |  18 ----
 tests/ui/unit_arg.rs                    |  12 ++-
 tests/ui/unit_arg.stderr                |  20 ++--
 7 files changed, 195 insertions(+), 33 deletions(-)
 create mode 100644 clippy_utils/src/check_proc_macro.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/mod.rs b/clippy_lints/src/matches/mod.rs
index b638f271602..a74166c32d1 100644
--- a/clippy_lints/src/matches/mod.rs
+++ b/clippy_lints/src/matches/mod.rs
@@ -21,8 +21,8 @@ mod single_match;
 mod try_err;
 mod wild_in_or_pats;
 
-use clippy_utils::source::{snippet_opt, span_starts_with, walk_span_to_context};
-use clippy_utils::{higher, in_constant, meets_msrv, msrvs};
+use clippy_utils::source::{snippet_opt, walk_span_to_context};
+use clippy_utils::{higher, in_constant, is_span_match, meets_msrv, msrvs};
 use rustc_hir::{Arm, Expr, ExprKind, Local, MatchSource, Pat};
 use rustc_lexer::{tokenize, TokenKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
@@ -949,7 +949,7 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
         let from_expansion = expr.span.from_expansion();
 
         if let ExprKind::Match(ex, arms, source) = expr.kind {
-            if source == MatchSource::Normal && !span_starts_with(cx, expr.span, "match") {
+            if source == MatchSource::Normal && !is_span_match(cx, expr.span) {
                 return;
             }
             if matches!(source, MatchSource::Normal | MatchSource::ForLoopDesugar) {
diff --git a/clippy_lints/src/unit_types/unit_arg.rs b/clippy_lints/src/unit_types/unit_arg.rs
index 97d92f10e1c..cd38720f722 100644
--- a/clippy_lints/src/unit_types/unit_arg.rs
+++ b/clippy_lints/src/unit_types/unit_arg.rs
@@ -1,4 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::is_expr_from_proc_macro;
 use clippy_utils::source::{indent_of, reindent_multiline, snippet_opt};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
@@ -44,7 +45,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>) {
                     }
                 })
                 .collect::<Vec<_>>();
-            if !args_to_recover.is_empty() {
+            if !args_to_recover.is_empty() && !is_expr_from_proc_macro(cx, expr) {
                 lint_unit_args(cx, expr, &args_to_recover);
             }
         },
diff --git a/clippy_utils/src/check_proc_macro.rs b/clippy_utils/src/check_proc_macro.rs
new file mode 100644
index 00000000000..387bf720008
--- /dev/null
+++ b/clippy_utils/src/check_proc_macro.rs
@@ -0,0 +1,167 @@
+//! This module handles checking if the span given is from a proc-macro or not.
+//!
+//! Proc-macros are capable of setting the span of every token they output to a few possible spans.
+//! This includes spans we can detect easily as coming from a proc-macro (e.g. the call site
+//! or the def site), and spans we can't easily detect as such (e.g. the span of any token
+//! passed into the proc macro). This capability means proc-macros are capable of generating code
+//! with a span that looks like it was written by the user, but which should not be linted by clippy
+//! as it was generated by an external macro.
+//!
+//! That brings us to this module. The current approach is to determine a small bit of text which
+//! must exist at both the start and the end of an item (e.g. an expression or a path) assuming the
+//! code was written, and check if the span contains that text. Note this will only work correctly
+//! if the span is not from a `macro_rules` based macro.
+
+use rustc_ast::ast::{IntTy, LitIntType, LitKind, StrStyle, UintTy};
+use rustc_hir::{
+    Block, BlockCheckMode, Closure, Destination, Expr, ExprKind, LoopSource, MatchSource, QPath, UnOp, UnsafeSource,
+    YieldSource,
+};
+use rustc_lint::{LateContext, LintContext};
+use rustc_middle::ty::TyCtxt;
+use rustc_session::Session;
+use rustc_span::{Span, Symbol};
+
+#[derive(Clone, Copy)]
+enum Pat {
+    Str(&'static str),
+    Sym(Symbol),
+    Num,
+}
+
+/// Checks if the start and the end of the span's text matches the patterns. This will return false
+/// if the span crosses multiple files or if source is not available.
+fn span_matches_pat(sess: &Session, span: Span, start_pat: Pat, end_pat: Pat) -> bool {
+    let pos = sess.source_map().lookup_byte_offset(span.lo());
+    let Some(ref src) = pos.sf.src else {
+        return false;
+    };
+    let end = span.hi() - pos.sf.start_pos;
+    src.get(pos.pos.0 as usize..end.0 as usize).map_or(false, |s| {
+        // Spans can be wrapped in a mixture or parenthesis, whitespace, and trailing commas.
+        let start_str = s.trim_start_matches(|c: char| c.is_whitespace() || c == '(');
+        let end_str = s.trim_end_matches(|c: char| c.is_whitespace() || c == ')' || c == ',');
+        (match start_pat {
+            Pat::Str(text) => start_str.starts_with(text),
+            Pat::Sym(sym) => start_str.starts_with(sym.as_str()),
+            Pat::Num => start_str.as_bytes().first().map_or(false, u8::is_ascii_digit),
+        } && match end_pat {
+            Pat::Str(text) => end_str.ends_with(text),
+            Pat::Sym(sym) => end_str.ends_with(sym.as_str()),
+            Pat::Num => end_str.as_bytes().last().map_or(false, u8::is_ascii_hexdigit),
+        })
+    })
+}
+
+/// Get the search patterns to use for the given literal
+fn lit_search_pat(lit: &LitKind) -> (Pat, Pat) {
+    match lit {
+        LitKind::Str(_, StrStyle::Cooked) => (Pat::Str("\""), Pat::Str("\"")),
+        LitKind::Str(_, StrStyle::Raw(0)) => (Pat::Str("r"), Pat::Str("\"")),
+        LitKind::Str(_, StrStyle::Raw(_)) => (Pat::Str("r#"), Pat::Str("#")),
+        LitKind::ByteStr(_) => (Pat::Str("b\""), Pat::Str("\"")),
+        LitKind::Byte(_) => (Pat::Str("b'"), Pat::Str("'")),
+        LitKind::Char(_) => (Pat::Str("'"), Pat::Str("'")),
+        LitKind::Int(_, LitIntType::Signed(IntTy::Isize)) => (Pat::Num, Pat::Str("isize")),
+        LitKind::Int(_, LitIntType::Unsigned(UintTy::Usize)) => (Pat::Num, Pat::Str("usize")),
+        LitKind::Int(..) => (Pat::Num, Pat::Num),
+        LitKind::Float(..) => (Pat::Num, Pat::Str("")),
+        LitKind::Bool(true) => (Pat::Str("true"), Pat::Str("true")),
+        LitKind::Bool(false) => (Pat::Str("false"), Pat::Str("false")),
+        _ => (Pat::Str(""), Pat::Str("")),
+    }
+}
+
+/// Get the search patterns to use for the given path
+fn qpath_search_pat(path: &QPath<'_>) -> (Pat, Pat) {
+    match path {
+        QPath::Resolved(ty, path) => {
+            let start = if ty.is_some() {
+                Pat::Str("<")
+            } else {
+                path.segments
+                    .first()
+                    .map_or(Pat::Str(""), |seg| Pat::Sym(seg.ident.name))
+            };
+            let end = path.segments.last().map_or(Pat::Str(""), |seg| {
+                if seg.args.is_some() {
+                    Pat::Str(">")
+                } else {
+                    Pat::Sym(seg.ident.name)
+                }
+            });
+            (start, end)
+        },
+        QPath::TypeRelative(_, name) => (Pat::Str(""), Pat::Sym(name.ident.name)),
+        QPath::LangItem(..) => (Pat::Str(""), Pat::Str("")),
+    }
+}
+
+/// Get the search patterns to use for the given expression
+fn expr_search_pat(tcx: TyCtxt<'_>, e: &Expr<'_>) -> (Pat, Pat) {
+    match e.kind {
+        ExprKind::Box(e) => (Pat::Str("box"), expr_search_pat(tcx, e).1),
+        ExprKind::ConstBlock(_) => (Pat::Str("const"), Pat::Str("}")),
+        ExprKind::Tup([]) => (Pat::Str(")"), Pat::Str("(")),
+        ExprKind::Unary(UnOp::Deref, _) => (Pat::Str("*"), expr_search_pat(tcx, e).1),
+        ExprKind::Unary(UnOp::Not, _) => (Pat::Str("!"), expr_search_pat(tcx, e).1),
+        ExprKind::Unary(UnOp::Neg, _) => (Pat::Str("-"), expr_search_pat(tcx, e).1),
+        ExprKind::Lit(ref lit) => lit_search_pat(&lit.node),
+        ExprKind::Array(_) | ExprKind::Repeat(..) => (Pat::Str("["), Pat::Str("]")),
+        ExprKind::Call(e, []) | ExprKind::MethodCall(_, [e], _) => (expr_search_pat(tcx, e).0, Pat::Str("(")),
+        ExprKind::Call(first, [.., last])
+        | ExprKind::MethodCall(_, [first, .., last], _)
+        | ExprKind::Binary(_, first, last)
+        | ExprKind::Tup([first, .., last])
+        | ExprKind::Assign(first, last, _)
+        | ExprKind::AssignOp(_, first, last) => (expr_search_pat(tcx, first).0, expr_search_pat(tcx, last).1),
+        ExprKind::Tup([e]) | ExprKind::DropTemps(e) => expr_search_pat(tcx, e),
+        ExprKind::Cast(e, _) | ExprKind::Type(e, _) => (expr_search_pat(tcx, e).0, Pat::Str("")),
+        ExprKind::Let(let_expr) => (Pat::Str("let"), expr_search_pat(tcx, let_expr.init).1),
+        ExprKind::If(..) => (Pat::Str("if"), Pat::Str("}")),
+        ExprKind::Loop(_, Some(_), _, _) | ExprKind::Block(_, Some(_)) => (Pat::Str("'"), Pat::Str("}")),
+        ExprKind::Loop(_, None, LoopSource::Loop, _) => (Pat::Str("loop"), Pat::Str("}")),
+        ExprKind::Loop(_, None, LoopSource::While, _) => (Pat::Str("while"), Pat::Str("}")),
+        ExprKind::Loop(_, None, LoopSource::ForLoop, _) | ExprKind::Match(_, _, MatchSource::ForLoopDesugar) => {
+            (Pat::Str("for"), Pat::Str("}"))
+        },
+        ExprKind::Match(_, _, MatchSource::Normal) => (Pat::Str("match"), Pat::Str("}")),
+        ExprKind::Match(e, _, MatchSource::TryDesugar) => (expr_search_pat(tcx, e).0, Pat::Str("?")),
+        ExprKind::Match(e, _, MatchSource::AwaitDesugar) | ExprKind::Yield(e, YieldSource::Await { .. }) => {
+            (expr_search_pat(tcx, e).0, Pat::Str("await"))
+        },
+        ExprKind::Closure(&Closure { body, .. }) => (Pat::Str(""), expr_search_pat(tcx, &tcx.hir().body(body).value).1),
+        ExprKind::Block(
+            Block {
+                rules: BlockCheckMode::UnsafeBlock(UnsafeSource::UserProvided),
+                ..
+            },
+            None,
+        ) => (Pat::Str("unsafe"), Pat::Str("}")),
+        ExprKind::Block(_, None) => (Pat::Str("{"), Pat::Str("}")),
+        ExprKind::Field(e, name) => (expr_search_pat(tcx, e).0, Pat::Sym(name.name)),
+        ExprKind::Index(e, _) => (expr_search_pat(tcx, e).0, Pat::Str("]")),
+        ExprKind::Path(ref path) => qpath_search_pat(path),
+        ExprKind::AddrOf(_, _, e) => (Pat::Str("&"), expr_search_pat(tcx, e).1),
+        ExprKind::Break(Destination { label: None, .. }, None) => (Pat::Str("break"), Pat::Str("break")),
+        ExprKind::Break(Destination { label: Some(name), .. }, None) => (Pat::Str("break"), Pat::Sym(name.ident.name)),
+        ExprKind::Break(_, Some(e)) => (Pat::Str("break"), expr_search_pat(tcx, e).1),
+        ExprKind::Continue(Destination { label: None, .. }) => (Pat::Str("continue"), Pat::Str("continue")),
+        ExprKind::Continue(Destination { label: Some(name), .. }) => (Pat::Str("continue"), Pat::Sym(name.ident.name)),
+        ExprKind::Ret(None) => (Pat::Str("return"), Pat::Str("return")),
+        ExprKind::Struct(path, _, _) => (qpath_search_pat(path).0, Pat::Str("}")),
+        ExprKind::Yield(e, YieldSource::Yield) => (Pat::Str("yield"), expr_search_pat(tcx, e).1),
+        _ => (Pat::Str(""), Pat::Str("")),
+    }
+}
+
+/// Checks if the expression likely came from a proc-macro
+pub fn is_expr_from_proc_macro(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
+    let (start_pat, end_pat) = expr_search_pat(cx.tcx, e);
+    !span_matches_pat(cx.sess(), e.span, start_pat, end_pat)
+}
+
+/// Checks if the span actually refers to a match expression
+pub fn is_span_match(cx: &LateContext<'_>, span: Span) -> bool {
+    span_matches_pat(cx.sess(), span, Pat::Str("match"), Pat::Str("}"))
+}
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 9ffbc73dc62..2d051e3a815 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -38,6 +38,7 @@ pub mod sym_helper;
 
 pub mod ast_utils;
 pub mod attrs;
+mod check_proc_macro;
 pub mod comparisons;
 pub mod consts;
 pub mod diagnostics;
@@ -58,6 +59,7 @@ pub mod usage;
 pub mod visitors;
 
 pub use self::attrs::*;
+pub use self::check_proc_macro::{is_expr_from_proc_macro, is_span_match};
 pub use self::hir_utils::{
     both, count_eq, eq_expr_value, hash_expr, hash_stmt, over, HirEqInterExpr, SpanlessEq, SpanlessHash,
 };
diff --git a/clippy_utils/src/source.rs b/clippy_utils/src/source.rs
index 1197fe914de..d85f591fb9a 100644
--- a/clippy_utils/src/source.rs
+++ b/clippy_utils/src/source.rs
@@ -11,24 +11,6 @@ use rustc_span::source_map::SourceMap;
 use rustc_span::{BytePos, Pos, Span, SpanData, SyntaxContext};
 use std::borrow::Cow;
 
-/// Checks if the span starts with the given text. This will return false if the span crosses
-/// multiple files or if source is not available.
-///
-/// This is used to check for proc macros giving unhelpful spans to things.
-pub fn span_starts_with<T: LintContext>(cx: &T, span: Span, text: &str) -> bool {
-    fn helper(sm: &SourceMap, span: Span, text: &str) -> bool {
-        let pos = sm.lookup_byte_offset(span.lo());
-        let Some(ref src) = pos.sf.src else {
-            return false;
-        };
-        let end = span.hi() - pos.sf.start_pos;
-        src.get(pos.pos.0 as usize..end.0 as usize)
-            // Expression spans can include wrapping parenthesis. Remove them first.
-            .map_or(false, |s| s.trim_start_matches('(').starts_with(text))
-    }
-    helper(cx.sess().source_map(), span, text)
-}
-
 /// Like `snippet_block`, but add braces if the expr is not an `ExprKind::Block`.
 /// Also takes an `Option<String>` which can be put inside the braces.
 pub fn expr_block<'a, T: LintContext>(
diff --git a/tests/ui/unit_arg.rs b/tests/ui/unit_arg.rs
index 38be87bddf1..7bf3adc07ac 100644
--- a/tests/ui/unit_arg.rs
+++ b/tests/ui/unit_arg.rs
@@ -1,3 +1,5 @@
+// aux-build: proc_macro_with_span.rs
+
 #![warn(clippy::unit_arg)]
 #![allow(
     clippy::no_effect,
@@ -8,9 +10,13 @@
     clippy::or_fun_call,
     clippy::needless_question_mark,
     clippy::self_named_constructors,
-    clippy::let_unit_value
+    clippy::let_unit_value,
+    clippy::never_loop
 )]
 
+extern crate proc_macro_with_span;
+
+use proc_macro_with_span::with_span;
 use std::fmt::Debug;
 
 fn foo<T: Debug>(t: T) {
@@ -127,6 +133,10 @@ fn returning_expr() -> Option<()> {
 
 fn taking_multiple_units(a: (), b: ()) {}
 
+fn proc_macro() {
+    with_span!(span taking_multiple_units(unsafe { (); }, 'x: loop { break 'x (); }));
+}
+
 fn main() {
     bad();
     ok();
diff --git a/tests/ui/unit_arg.stderr b/tests/ui/unit_arg.stderr
index 11cfe66a30e..1de9d44bb0d 100644
--- a/tests/ui/unit_arg.stderr
+++ b/tests/ui/unit_arg.stderr
@@ -1,5 +1,5 @@
 error: passing a unit value to a function
-  --> $DIR/unit_arg.rs:57:5
+  --> $DIR/unit_arg.rs:63:5
    |
 LL | /     foo({
 LL | |         1;
@@ -20,7 +20,7 @@ LL ~     foo(());
    |
 
 error: passing a unit value to a function
-  --> $DIR/unit_arg.rs:60:5
+  --> $DIR/unit_arg.rs:66:5
    |
 LL |     foo(foo(1));
    |     ^^^^^^^^^^^
@@ -32,7 +32,7 @@ LL ~     foo(());
    |
 
 error: passing a unit value to a function
-  --> $DIR/unit_arg.rs:61:5
+  --> $DIR/unit_arg.rs:67:5
    |
 LL | /     foo({
 LL | |         foo(1);
@@ -54,7 +54,7 @@ LL ~     foo(());
    |
 
 error: passing a unit value to a function
-  --> $DIR/unit_arg.rs:66:5
+  --> $DIR/unit_arg.rs:72:5
    |
 LL | /     b.bar({
 LL | |         1;
@@ -74,7 +74,7 @@ LL ~     b.bar(());
    |
 
 error: passing unit values to a function
-  --> $DIR/unit_arg.rs:69:5
+  --> $DIR/unit_arg.rs:75:5
    |
 LL |     taking_multiple_units(foo(0), foo(1));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -87,7 +87,7 @@ LL ~     taking_multiple_units((), ());
    |
 
 error: passing unit values to a function
-  --> $DIR/unit_arg.rs:70:5
+  --> $DIR/unit_arg.rs:76:5
    |
 LL | /     taking_multiple_units(foo(0), {
 LL | |         foo(1);
@@ -110,7 +110,7 @@ LL ~     taking_multiple_units((), ());
    |
 
 error: passing unit values to a function
-  --> $DIR/unit_arg.rs:74:5
+  --> $DIR/unit_arg.rs:80:5
    |
 LL | /     taking_multiple_units(
 LL | |         {
@@ -146,7 +146,7 @@ LL ~     );
    |
 
 error: passing a unit value to a function
-  --> $DIR/unit_arg.rs:85:13
+  --> $DIR/unit_arg.rs:91:13
    |
 LL |     None.or(Some(foo(2)));
    |             ^^^^^^^^^^^^
@@ -160,7 +160,7 @@ LL ~     });
    |
 
 error: passing a unit value to a function
-  --> $DIR/unit_arg.rs:88:5
+  --> $DIR/unit_arg.rs:94:5
    |
 LL |     foo(foo(()));
    |     ^^^^^^^^^^^^
@@ -172,7 +172,7 @@ LL ~     foo(());
    |
 
 error: passing a unit value to a function
-  --> $DIR/unit_arg.rs:125:5
+  --> $DIR/unit_arg.rs:131:5
    |
 LL |     Some(foo(1))
    |     ^^^^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From 37e838f759b99dd3ac042a61f60a4f14272b99c2 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Wed, 13 Apr 2022 01:13:47 -0400
Subject: Use new util function in `suspicious_else_formatting`

---
 clippy_lints/src/formatting.rs       | 6 +++---
 clippy_utils/src/check_proc_macro.rs | 7 ++++++-
 clippy_utils/src/lib.rs              | 2 +-
 3 files changed, 10 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/formatting.rs b/clippy_lints/src/formatting.rs
index db0166da57f..01cefe4af85 100644
--- a/clippy_lints/src/formatting.rs
+++ b/clippy_lints/src/formatting.rs
@@ -1,4 +1,5 @@
 use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_note};
+use clippy_utils::is_span_if;
 use clippy_utils::source::snippet_opt;
 use if_chain::if_chain;
 use rustc_ast::ast::{BinOpKind, Block, Expr, ExprKind, StmtKind, UnOp};
@@ -297,12 +298,11 @@ fn check_array(cx: &EarlyContext<'_>, expr: &Expr) {
 fn check_missing_else(cx: &EarlyContext<'_>, first: &Expr, second: &Expr) {
     if_chain! {
         if !first.span.from_expansion() && !second.span.from_expansion();
-        if let ExprKind::If(cond_expr, ..) = &first.kind;
+        if matches!(first.kind, ExprKind::If(..));
         if is_block(second) || is_if(second);
 
         // Proc-macros can give weird spans. Make sure this is actually an `if`.
-        if let Some(if_snip) = snippet_opt(cx, first.span.until(cond_expr.span));
-        if if_snip.starts_with("if");
+        if is_span_if(cx, first.span);
 
         // If there is a line break between the two expressions, don't lint.
         // If there is a non-whitespace character, this span came from a proc-macro.
diff --git a/clippy_utils/src/check_proc_macro.rs b/clippy_utils/src/check_proc_macro.rs
index 387bf720008..51cd70f5e7c 100644
--- a/clippy_utils/src/check_proc_macro.rs
+++ b/clippy_utils/src/check_proc_macro.rs
@@ -162,6 +162,11 @@ pub fn is_expr_from_proc_macro(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
 }
 
 /// Checks if the span actually refers to a match expression
-pub fn is_span_match(cx: &LateContext<'_>, span: Span) -> bool {
+pub fn is_span_match(cx: &impl LintContext, span: Span) -> bool {
     span_matches_pat(cx.sess(), span, Pat::Str("match"), Pat::Str("}"))
 }
+
+/// Checks if the span actually refers to an if expression
+pub fn is_span_if(cx: &impl LintContext, span: Span) -> bool {
+    span_matches_pat(cx.sess(), span, Pat::Str("if"), Pat::Str("}"))
+}
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 2d051e3a815..086e6d6e3a2 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -59,7 +59,7 @@ pub mod usage;
 pub mod visitors;
 
 pub use self::attrs::*;
-pub use self::check_proc_macro::{is_expr_from_proc_macro, is_span_match};
+pub use self::check_proc_macro::{is_expr_from_proc_macro, is_span_if, is_span_match};
 pub use self::hir_utils::{
     both, count_eq, eq_expr_value, hash_expr, hash_stmt, over, HirEqInterExpr, SpanlessEq, SpanlessHash,
 };
-- 
cgit 1.4.1-3-g733a5


From 4ae582ef88adbdcd3a01686a7a61120efd7a208b Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Wed, 13 Apr 2022 09:23:12 -0400
Subject: Don't lint `missing_docs_in_private_items` on proc-macro output

---
 clippy_lints/src/missing_doc.rs           |  21 +++-
 clippy_lints/src/unit_types/mod.rs        |   2 +-
 clippy_lints/src/unit_types/unit_arg.rs   |   6 +-
 clippy_utils/src/check_proc_macro.rs      | 130 ++++++++++++++++++++++--
 clippy_utils/src/lib.rs                   |   2 +-
 tests/ui/missing-doc-crate-missing.rs     |   3 -
 tests/ui/missing-doc-crate-missing.stderr |  12 ---
 tests/ui/missing-doc-crate.rs             |   4 -
 tests/ui/missing-doc-impl.rs              |  92 -----------------
 tests/ui/missing-doc-impl.stderr          | 107 --------------------
 tests/ui/missing-doc.rs                   | 102 -------------------
 tests/ui/missing-doc.stderr               | 159 ------------------------------
 tests/ui/missing_doc.rs                   | 115 +++++++++++++++++++++
 tests/ui/missing_doc.stderr               | 159 ++++++++++++++++++++++++++++++
 tests/ui/missing_doc_crate.rs             |   4 +
 tests/ui/missing_doc_crate_missing.rs     |   3 +
 tests/ui/missing_doc_crate_missing.stderr |  12 +++
 tests/ui/missing_doc_impl.rs              | 107 ++++++++++++++++++++
 tests/ui/missing_doc_impl.stderr          | 107 ++++++++++++++++++++
 19 files changed, 651 insertions(+), 496 deletions(-)
 delete mode 100644 tests/ui/missing-doc-crate-missing.rs
 delete mode 100644 tests/ui/missing-doc-crate-missing.stderr
 delete mode 100644 tests/ui/missing-doc-crate.rs
 delete mode 100644 tests/ui/missing-doc-impl.rs
 delete mode 100644 tests/ui/missing-doc-impl.stderr
 delete mode 100644 tests/ui/missing-doc.rs
 delete mode 100644 tests/ui/missing-doc.stderr
 create mode 100644 tests/ui/missing_doc.rs
 create mode 100644 tests/ui/missing_doc.stderr
 create mode 100644 tests/ui/missing_doc_crate.rs
 create mode 100644 tests/ui/missing_doc_crate_missing.rs
 create mode 100644 tests/ui/missing_doc_crate_missing.stderr
 create mode 100644 tests/ui/missing_doc_impl.rs
 create mode 100644 tests/ui/missing_doc_impl.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/missing_doc.rs b/clippy_lints/src/missing_doc.rs
index b99052e66ba..7ef80b1a596 100644
--- a/clippy_lints/src/missing_doc.rs
+++ b/clippy_lints/src/missing_doc.rs
@@ -7,6 +7,7 @@
 
 use clippy_utils::attrs::is_doc_hidden;
 use clippy_utils::diagnostics::span_lint;
+use clippy_utils::is_from_proc_macro;
 use if_chain::if_chain;
 use rustc_ast::ast::{self, MetaItem, MetaItemKind};
 use rustc_hir as hir;
@@ -158,14 +159,18 @@ impl<'tcx> LateLintPass<'tcx> for MissingDoc {
         let (article, desc) = cx.tcx.article_and_description(it.def_id.to_def_id());
 
         let attrs = cx.tcx.hir().attrs(it.hir_id());
-        self.check_missing_docs_attrs(cx, attrs, it.span, article, desc);
+        if !is_from_proc_macro(cx, it) {
+            self.check_missing_docs_attrs(cx, attrs, it.span, article, desc);
+        }
     }
 
     fn check_trait_item(&mut self, cx: &LateContext<'tcx>, trait_item: &'tcx hir::TraitItem<'_>) {
         let (article, desc) = cx.tcx.article_and_description(trait_item.def_id.to_def_id());
 
         let attrs = cx.tcx.hir().attrs(trait_item.hir_id());
-        self.check_missing_docs_attrs(cx, attrs, trait_item.span, article, desc);
+        if !is_from_proc_macro(cx, trait_item) {
+            self.check_missing_docs_attrs(cx, attrs, trait_item.span, article, desc);
+        }
     }
 
     fn check_impl_item(&mut self, cx: &LateContext<'tcx>, impl_item: &'tcx hir::ImplItem<'_>) {
@@ -181,18 +186,24 @@ impl<'tcx> LateLintPass<'tcx> for MissingDoc {
 
         let (article, desc) = cx.tcx.article_and_description(impl_item.def_id.to_def_id());
         let attrs = cx.tcx.hir().attrs(impl_item.hir_id());
-        self.check_missing_docs_attrs(cx, attrs, impl_item.span, article, desc);
+        if !is_from_proc_macro(cx, impl_item) {
+            self.check_missing_docs_attrs(cx, attrs, impl_item.span, article, desc);
+        }
     }
 
     fn check_field_def(&mut self, cx: &LateContext<'tcx>, sf: &'tcx hir::FieldDef<'_>) {
         if !sf.is_positional() {
             let attrs = cx.tcx.hir().attrs(sf.hir_id);
-            self.check_missing_docs_attrs(cx, attrs, sf.span, "a", "struct field");
+            if !is_from_proc_macro(cx, sf) {
+                self.check_missing_docs_attrs(cx, attrs, sf.span, "a", "struct field");
+            }
         }
     }
 
     fn check_variant(&mut self, cx: &LateContext<'tcx>, v: &'tcx hir::Variant<'_>) {
         let attrs = cx.tcx.hir().attrs(v.id);
-        self.check_missing_docs_attrs(cx, attrs, v.span, "a", "variant");
+        if !is_from_proc_macro(cx, v) {
+            self.check_missing_docs_attrs(cx, attrs, v.span, "a", "variant");
+        }
     }
 }
diff --git a/clippy_lints/src/unit_types/mod.rs b/clippy_lints/src/unit_types/mod.rs
index 6aa86a57c9b..546242ebd9a 100644
--- a/clippy_lints/src/unit_types/mod.rs
+++ b/clippy_lints/src/unit_types/mod.rs
@@ -103,7 +103,7 @@ impl<'tcx> LateLintPass<'tcx> for UnitTypes {
         let_unit_value::check(cx, local);
     }
 
-    fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
         unit_cmp::check(cx, expr);
         unit_arg::check(cx, expr);
     }
diff --git a/clippy_lints/src/unit_types/unit_arg.rs b/clippy_lints/src/unit_types/unit_arg.rs
index cd38720f722..16da2f11b81 100644
--- a/clippy_lints/src/unit_types/unit_arg.rs
+++ b/clippy_lints/src/unit_types/unit_arg.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::is_expr_from_proc_macro;
+use clippy_utils::is_from_proc_macro;
 use clippy_utils::source::{indent_of, reindent_multiline, snippet_opt};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
@@ -8,7 +8,7 @@ use rustc_lint::LateContext;
 
 use super::{utils, UNIT_ARG};
 
-pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>) {
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
     if expr.span.from_expansion() {
         return;
     }
@@ -45,7 +45,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>) {
                     }
                 })
                 .collect::<Vec<_>>();
-            if !args_to_recover.is_empty() && !is_expr_from_proc_macro(cx, expr) {
+            if !args_to_recover.is_empty() && !is_from_proc_macro(cx, expr) {
                 lint_unit_args(cx, expr, &args_to_recover);
             }
         },
diff --git a/clippy_utils/src/check_proc_macro.rs b/clippy_utils/src/check_proc_macro.rs
index 51cd70f5e7c..4dd0ec6b6d0 100644
--- a/clippy_utils/src/check_proc_macro.rs
+++ b/clippy_utils/src/check_proc_macro.rs
@@ -14,17 +14,20 @@
 
 use rustc_ast::ast::{IntTy, LitIntType, LitKind, StrStyle, UintTy};
 use rustc_hir::{
-    Block, BlockCheckMode, Closure, Destination, Expr, ExprKind, LoopSource, MatchSource, QPath, UnOp, UnsafeSource,
-    YieldSource,
+    Block, BlockCheckMode, Closure, Destination, Expr, ExprKind, FieldDef, FnHeader, Impl, ImplItem, ImplItemKind,
+    IsAuto, Item, ItemKind, LoopSource, MatchSource, QPath, TraitItem, TraitItemKind, UnOp, UnsafeSource, Unsafety,
+    Variant, VariantData, VisibilityKind, YieldSource,
 };
 use rustc_lint::{LateContext, LintContext};
 use rustc_middle::ty::TyCtxt;
 use rustc_session::Session;
 use rustc_span::{Span, Symbol};
+use rustc_target::spec::abi::Abi;
 
 #[derive(Clone, Copy)]
-enum Pat {
+pub enum Pat {
     Str(&'static str),
+    MultiStr(&'static [&'static str]),
     Sym(Symbol),
     Num,
 }
@@ -43,10 +46,12 @@ fn span_matches_pat(sess: &Session, span: Span, start_pat: Pat, end_pat: Pat) ->
         let end_str = s.trim_end_matches(|c: char| c.is_whitespace() || c == ')' || c == ',');
         (match start_pat {
             Pat::Str(text) => start_str.starts_with(text),
+            Pat::MultiStr(texts) => texts.iter().any(|s| start_str.starts_with(s)),
             Pat::Sym(sym) => start_str.starts_with(sym.as_str()),
             Pat::Num => start_str.as_bytes().first().map_or(false, u8::is_ascii_digit),
         } && match end_pat {
             Pat::Str(text) => end_str.ends_with(text),
+            Pat::MultiStr(texts) => texts.iter().any(|s| start_str.ends_with(s)),
             Pat::Sym(sym) => end_str.ends_with(sym.as_str()),
             Pat::Num => end_str.as_bytes().last().map_or(false, u8::is_ascii_hexdigit),
         })
@@ -155,10 +160,121 @@ fn expr_search_pat(tcx: TyCtxt<'_>, e: &Expr<'_>) -> (Pat, Pat) {
     }
 }
 
-/// Checks if the expression likely came from a proc-macro
-pub fn is_expr_from_proc_macro(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
-    let (start_pat, end_pat) = expr_search_pat(cx.tcx, e);
-    !span_matches_pat(cx.sess(), e.span, start_pat, end_pat)
+fn fn_header_search_pat(header: FnHeader) -> Pat {
+    if header.is_async() {
+        Pat::Str("async")
+    } else if header.is_const() {
+        Pat::Str("const")
+    } else if header.is_unsafe() {
+        Pat::Str("unsafe")
+    } else if header.abi != Abi::Rust {
+        Pat::Str("extern")
+    } else {
+        Pat::MultiStr(&["fn", "extern"])
+    }
+}
+
+fn item_search_pat(item: &Item<'_>) -> (Pat, Pat) {
+    let (start_pat, end_pat) = match &item.kind {
+        ItemKind::ExternCrate(_) => (Pat::Str("extern"), Pat::Str(";")),
+        ItemKind::Static(..) => (Pat::Str("static"), Pat::Str(";")),
+        ItemKind::Const(..) => (Pat::Str("const"), Pat::Str(";")),
+        ItemKind::Fn(sig, ..) => (fn_header_search_pat(sig.header), Pat::Str("")),
+        ItemKind::ForeignMod { .. } => (Pat::Str("extern"), Pat::Str("}")),
+        ItemKind::TyAlias(..) | ItemKind::OpaqueTy(_) => (Pat::Str("type"), Pat::Str(";")),
+        ItemKind::Enum(..) => (Pat::Str("enum"), Pat::Str("}")),
+        ItemKind::Struct(VariantData::Struct(..), _) => (Pat::Str("struct"), Pat::Str("}")),
+        ItemKind::Struct(..) => (Pat::Str("struct"), Pat::Str(";")),
+        ItemKind::Union(..) => (Pat::Str("union"), Pat::Str("}")),
+        ItemKind::Trait(_, Unsafety::Unsafe, ..)
+        | ItemKind::Impl(Impl {
+            unsafety: Unsafety::Unsafe,
+            ..
+        }) => (Pat::Str("unsafe"), Pat::Str("}")),
+        ItemKind::Trait(IsAuto::Yes, ..) => (Pat::Str("auto"), Pat::Str("}")),
+        ItemKind::Trait(..) => (Pat::Str("trait"), Pat::Str("}")),
+        ItemKind::Impl(_) => (Pat::Str("impl"), Pat::Str("}")),
+        _ => return (Pat::Str(""), Pat::Str("")),
+    };
+    if matches!(item.vis.node, VisibilityKind::Inherited) {
+        (start_pat, end_pat)
+    } else {
+        (Pat::Str("pub"), end_pat)
+    }
+}
+
+fn trait_item_search_pat(item: &TraitItem<'_>) -> (Pat, Pat) {
+    match &item.kind {
+        TraitItemKind::Const(..) => (Pat::Str("const"), Pat::Str(";")),
+        TraitItemKind::Type(..) => (Pat::Str("type"), Pat::Str(";")),
+        TraitItemKind::Fn(sig, ..) => (fn_header_search_pat(sig.header), Pat::Str("")),
+    }
+}
+
+fn impl_item_search_pat(item: &ImplItem<'_>) -> (Pat, Pat) {
+    let (start_pat, end_pat) = match &item.kind {
+        ImplItemKind::Const(..) => (Pat::Str("const"), Pat::Str(";")),
+        ImplItemKind::TyAlias(..) => (Pat::Str("type"), Pat::Str(";")),
+        ImplItemKind::Fn(sig, ..) => (fn_header_search_pat(sig.header), Pat::Str("")),
+    };
+    if matches!(item.vis.node, VisibilityKind::Inherited) {
+        (start_pat, end_pat)
+    } else {
+        (Pat::Str("pub"), end_pat)
+    }
+}
+
+fn field_def_search_pat(def: &FieldDef<'_>) -> (Pat, Pat) {
+    if matches!(def.vis.node, VisibilityKind::Inherited) {
+        if def.is_positional() {
+            (Pat::Str(""), Pat::Str(""))
+        } else {
+            (Pat::Sym(def.ident.name), Pat::Str(""))
+        }
+    } else {
+        (Pat::Str("pub"), Pat::Str(""))
+    }
+}
+
+fn variant_search_pat(v: &Variant<'_>) -> (Pat, Pat) {
+    match v.data {
+        VariantData::Struct(..) => (Pat::Sym(v.ident.name), Pat::Str("}")),
+        VariantData::Tuple(..) => (Pat::Sym(v.ident.name), Pat::Str("")),
+        VariantData::Unit(..) => (Pat::Sym(v.ident.name), Pat::Sym(v.ident.name)),
+    }
+}
+
+pub trait WithSearchPat {
+    type Context: LintContext;
+    fn search_pat(&self, cx: &Self::Context) -> (Pat, Pat);
+    fn span(&self) -> Span;
+}
+macro_rules! impl_with_search_pat {
+    ($cx:ident: $ty:ident with $fn:ident $(($tcx:ident))?) => {
+        impl<'cx> WithSearchPat for $ty<'cx> {
+            type Context = $cx<'cx>;
+            #[allow(unused_variables)]
+            fn search_pat(&self, cx: &Self::Context) -> (Pat, Pat) {
+                $(let $tcx = cx.tcx;)?
+                $fn($($tcx,)? self)
+            }
+            fn span(&self) -> Span {
+                self.span
+            }
+        }
+    };
+}
+impl_with_search_pat!(LateContext: Expr with expr_search_pat(tcx));
+impl_with_search_pat!(LateContext: Item with item_search_pat);
+impl_with_search_pat!(LateContext: TraitItem with trait_item_search_pat);
+impl_with_search_pat!(LateContext: ImplItem with impl_item_search_pat);
+impl_with_search_pat!(LateContext: FieldDef with field_def_search_pat);
+impl_with_search_pat!(LateContext: Variant with variant_search_pat);
+
+/// Checks if the item likely came from a proc-macro
+pub fn is_from_proc_macro<T: WithSearchPat>(cx: &T::Context, item: &T) -> bool {
+    let (start_pat, end_pat) = item.search_pat(cx);
+    !span_matches_pat(cx.sess(), item.span(), start_pat, end_pat)
 }
 
 /// Checks if the span actually refers to a match expression
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 086e6d6e3a2..dcfc03475b4 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -59,7 +59,7 @@ pub mod usage;
 pub mod visitors;
 
 pub use self::attrs::*;
-pub use self::check_proc_macro::{is_expr_from_proc_macro, is_span_if, is_span_match};
+pub use self::check_proc_macro::{is_from_proc_macro, is_span_if, is_span_match};
 pub use self::hir_utils::{
     both, count_eq, eq_expr_value, hash_expr, hash_stmt, over, HirEqInterExpr, SpanlessEq, SpanlessHash,
 };
diff --git a/tests/ui/missing-doc-crate-missing.rs b/tests/ui/missing-doc-crate-missing.rs
deleted file mode 100644
index 51fd57df8df..00000000000
--- a/tests/ui/missing-doc-crate-missing.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-#![warn(clippy::missing_docs_in_private_items)]
-
-fn main() {}
diff --git a/tests/ui/missing-doc-crate-missing.stderr b/tests/ui/missing-doc-crate-missing.stderr
deleted file mode 100644
index d56c5cc4c3a..00000000000
--- a/tests/ui/missing-doc-crate-missing.stderr
+++ /dev/null
@@ -1,12 +0,0 @@
-error: missing documentation for the crate
-  --> $DIR/missing-doc-crate-missing.rs:1:1
-   |
-LL | / #![warn(clippy::missing_docs_in_private_items)]
-LL | |
-LL | | fn main() {}
-   | |____________^
-   |
-   = note: `-D clippy::missing-docs-in-private-items` implied by `-D warnings`
-
-error: aborting due to previous error
-
diff --git a/tests/ui/missing-doc-crate.rs b/tests/ui/missing-doc-crate.rs
deleted file mode 100644
index e00c7fbfed1..00000000000
--- a/tests/ui/missing-doc-crate.rs
+++ /dev/null
@@ -1,4 +0,0 @@
-#![warn(clippy::missing_docs_in_private_items)]
-#![doc = include_str!("../../README.md")]
-
-fn main() {}
diff --git a/tests/ui/missing-doc-impl.rs b/tests/ui/missing-doc-impl.rs
deleted file mode 100644
index d5724bf661c..00000000000
--- a/tests/ui/missing-doc-impl.rs
+++ /dev/null
@@ -1,92 +0,0 @@
-#![warn(clippy::missing_docs_in_private_items)]
-#![allow(dead_code)]
-#![feature(associated_type_defaults)]
-
-//! Some garbage docs for the crate here
-#![doc = "More garbage"]
-
-struct Foo {
-    a: isize,
-    b: isize,
-}
-
-pub struct PubFoo {
-    pub a: isize,
-    b: isize,
-}
-
-#[allow(clippy::missing_docs_in_private_items)]
-pub struct PubFoo2 {
-    pub a: isize,
-    pub c: isize,
-}
-
-/// dox
-pub trait A {
-    /// dox
-    fn foo(&self);
-    /// dox
-    fn foo_with_impl(&self) {}
-}
-
-#[allow(clippy::missing_docs_in_private_items)]
-trait B {
-    fn foo(&self);
-    fn foo_with_impl(&self) {}
-}
-
-pub trait C {
-    fn foo(&self);
-    fn foo_with_impl(&self) {}
-}
-
-#[allow(clippy::missing_docs_in_private_items)]
-pub trait D {
-    fn dummy(&self) {}
-}
-
-/// dox
-pub trait E: Sized {
-    type AssociatedType;
-    type AssociatedTypeDef = Self;
-
-    /// dox
-    type DocumentedType;
-    /// dox
-    type DocumentedTypeDef = Self;
-    /// dox
-    fn dummy(&self) {}
-}
-
-impl Foo {
-    pub fn new() -> Self {
-        Foo { a: 0, b: 0 }
-    }
-    fn bar() {}
-}
-
-impl PubFoo {
-    pub fn foo() {}
-    /// dox
-    pub fn foo1() {}
-    #[must_use = "yep"]
-    fn foo2() -> u32 {
-        1
-    }
-    #[allow(clippy::missing_docs_in_private_items)]
-    pub fn foo3() {}
-}
-
-#[allow(clippy::missing_docs_in_private_items)]
-trait F {
-    fn a();
-    fn b(&self);
-}
-
-// should need to redefine documentation for implementations of traits
-impl F for Foo {
-    fn a() {}
-    fn b(&self) {}
-}
-
-fn main() {}
diff --git a/tests/ui/missing-doc-impl.stderr b/tests/ui/missing-doc-impl.stderr
deleted file mode 100644
index bda63d66a17..00000000000
--- a/tests/ui/missing-doc-impl.stderr
+++ /dev/null
@@ -1,107 +0,0 @@
-error: missing documentation for a struct
-  --> $DIR/missing-doc-impl.rs:8:1
-   |
-LL | / struct Foo {
-LL | |     a: isize,
-LL | |     b: isize,
-LL | | }
-   | |_^
-   |
-   = note: `-D clippy::missing-docs-in-private-items` implied by `-D warnings`
-
-error: missing documentation for a struct field
-  --> $DIR/missing-doc-impl.rs:9:5
-   |
-LL |     a: isize,
-   |     ^^^^^^^^
-
-error: missing documentation for a struct field
-  --> $DIR/missing-doc-impl.rs:10:5
-   |
-LL |     b: isize,
-   |     ^^^^^^^^
-
-error: missing documentation for a struct
-  --> $DIR/missing-doc-impl.rs:13:1
-   |
-LL | / pub struct PubFoo {
-LL | |     pub a: isize,
-LL | |     b: isize,
-LL | | }
-   | |_^
-
-error: missing documentation for a struct field
-  --> $DIR/missing-doc-impl.rs:14:5
-   |
-LL |     pub a: isize,
-   |     ^^^^^^^^^^^^
-
-error: missing documentation for a struct field
-  --> $DIR/missing-doc-impl.rs:15:5
-   |
-LL |     b: isize,
-   |     ^^^^^^^^
-
-error: missing documentation for a trait
-  --> $DIR/missing-doc-impl.rs:38:1
-   |
-LL | / pub trait C {
-LL | |     fn foo(&self);
-LL | |     fn foo_with_impl(&self) {}
-LL | | }
-   | |_^
-
-error: missing documentation for an associated function
-  --> $DIR/missing-doc-impl.rs:39:5
-   |
-LL |     fn foo(&self);
-   |     ^^^^^^^^^^^^^^
-
-error: missing documentation for an associated function
-  --> $DIR/missing-doc-impl.rs:40:5
-   |
-LL |     fn foo_with_impl(&self) {}
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: missing documentation for an associated type
-  --> $DIR/missing-doc-impl.rs:50:5
-   |
-LL |     type AssociatedType;
-   |     ^^^^^^^^^^^^^^^^^^^^
-
-error: missing documentation for an associated type
-  --> $DIR/missing-doc-impl.rs:51:5
-   |
-LL |     type AssociatedTypeDef = Self;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: missing documentation for an associated function
-  --> $DIR/missing-doc-impl.rs:62:5
-   |
-LL | /     pub fn new() -> Self {
-LL | |         Foo { a: 0, b: 0 }
-LL | |     }
-   | |_____^
-
-error: missing documentation for an associated function
-  --> $DIR/missing-doc-impl.rs:65:5
-   |
-LL |     fn bar() {}
-   |     ^^^^^^^^^^^
-
-error: missing documentation for an associated function
-  --> $DIR/missing-doc-impl.rs:69:5
-   |
-LL |     pub fn foo() {}
-   |     ^^^^^^^^^^^^^^^
-
-error: missing documentation for an associated function
-  --> $DIR/missing-doc-impl.rs:73:5
-   |
-LL | /     fn foo2() -> u32 {
-LL | |         1
-LL | |     }
-   | |_____^
-
-error: aborting due to 15 previous errors
-
diff --git a/tests/ui/missing-doc.rs b/tests/ui/missing-doc.rs
deleted file mode 100644
index 6e2e710e21c..00000000000
--- a/tests/ui/missing-doc.rs
+++ /dev/null
@@ -1,102 +0,0 @@
-#![warn(clippy::missing_docs_in_private_items)]
-// When denying at the crate level, be sure to not get random warnings from the
-// injected intrinsics by the compiler.
-#![allow(dead_code)]
-//! Some garbage docs for the crate here
-#![doc = "More garbage"]
-
-use std::arch::global_asm;
-
-type Typedef = String;
-pub type PubTypedef = String;
-
-mod module_no_dox {}
-pub mod pub_module_no_dox {}
-
-/// dox
-pub fn foo() {}
-pub fn foo2() {}
-fn foo3() {}
-#[allow(clippy::missing_docs_in_private_items)]
-pub fn foo4() {}
-
-// It sure is nice if doc(hidden) implies allow(missing_docs), and that it
-// applies recursively
-#[doc(hidden)]
-mod a {
-    pub fn baz() {}
-    pub mod b {
-        pub fn baz() {}
-    }
-}
-
-enum Baz {
-    BazA { a: isize, b: isize },
-    BarB,
-}
-
-pub enum PubBaz {
-    PubBazA { a: isize },
-}
-
-/// dox
-pub enum PubBaz2 {
-    /// dox
-    PubBaz2A {
-        /// dox
-        a: isize,
-    },
-}
-
-#[allow(clippy::missing_docs_in_private_items)]
-pub enum PubBaz3 {
-    PubBaz3A { b: isize },
-}
-
-#[doc(hidden)]
-pub fn baz() {}
-
-const FOO: u32 = 0;
-/// dox
-pub const FOO1: u32 = 0;
-#[allow(clippy::missing_docs_in_private_items)]
-pub const FOO2: u32 = 0;
-#[doc(hidden)]
-pub const FOO3: u32 = 0;
-pub const FOO4: u32 = 0;
-
-static BAR: u32 = 0;
-/// dox
-pub static BAR1: u32 = 0;
-#[allow(clippy::missing_docs_in_private_items)]
-pub static BAR2: u32 = 0;
-#[doc(hidden)]
-pub static BAR3: u32 = 0;
-pub static BAR4: u32 = 0;
-
-mod internal_impl {
-    /// dox
-    pub fn documented() {}
-    pub fn undocumented1() {}
-    pub fn undocumented2() {}
-    fn undocumented3() {}
-    /// dox
-    pub mod globbed {
-        /// dox
-        pub fn also_documented() {}
-        pub fn also_undocumented1() {}
-        fn also_undocumented2() {}
-    }
-}
-/// dox
-pub mod public_interface {
-    pub use crate::internal_impl::documented as foo;
-    pub use crate::internal_impl::globbed::*;
-    pub use crate::internal_impl::undocumented1 as bar;
-    pub use crate::internal_impl::{documented, undocumented2};
-}
-
-fn main() {}
-
-// Ensure global asm doesn't require documentation.
-global_asm! { "" }
diff --git a/tests/ui/missing-doc.stderr b/tests/ui/missing-doc.stderr
deleted file mode 100644
index a876dc078eb..00000000000
--- a/tests/ui/missing-doc.stderr
+++ /dev/null
@@ -1,159 +0,0 @@
-error: missing documentation for a type alias
-  --> $DIR/missing-doc.rs:10:1
-   |
-LL | type Typedef = String;
-   | ^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: `-D clippy::missing-docs-in-private-items` implied by `-D warnings`
-
-error: missing documentation for a type alias
-  --> $DIR/missing-doc.rs:11:1
-   |
-LL | pub type PubTypedef = String;
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: missing documentation for a module
-  --> $DIR/missing-doc.rs:13:1
-   |
-LL | mod module_no_dox {}
-   | ^^^^^^^^^^^^^^^^^^^^
-
-error: missing documentation for a module
-  --> $DIR/missing-doc.rs:14:1
-   |
-LL | pub mod pub_module_no_dox {}
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: missing documentation for a function
-  --> $DIR/missing-doc.rs:18:1
-   |
-LL | pub fn foo2() {}
-   | ^^^^^^^^^^^^^^^^
-
-error: missing documentation for a function
-  --> $DIR/missing-doc.rs:19:1
-   |
-LL | fn foo3() {}
-   | ^^^^^^^^^^^^
-
-error: missing documentation for an enum
-  --> $DIR/missing-doc.rs:33:1
-   |
-LL | / enum Baz {
-LL | |     BazA { a: isize, b: isize },
-LL | |     BarB,
-LL | | }
-   | |_^
-
-error: missing documentation for a variant
-  --> $DIR/missing-doc.rs:34:5
-   |
-LL |     BazA { a: isize, b: isize },
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: missing documentation for a struct field
-  --> $DIR/missing-doc.rs:34:12
-   |
-LL |     BazA { a: isize, b: isize },
-   |            ^^^^^^^^
-
-error: missing documentation for a struct field
-  --> $DIR/missing-doc.rs:34:22
-   |
-LL |     BazA { a: isize, b: isize },
-   |                      ^^^^^^^^
-
-error: missing documentation for a variant
-  --> $DIR/missing-doc.rs:35:5
-   |
-LL |     BarB,
-   |     ^^^^
-
-error: missing documentation for an enum
-  --> $DIR/missing-doc.rs:38:1
-   |
-LL | / pub enum PubBaz {
-LL | |     PubBazA { a: isize },
-LL | | }
-   | |_^
-
-error: missing documentation for a variant
-  --> $DIR/missing-doc.rs:39:5
-   |
-LL |     PubBazA { a: isize },
-   |     ^^^^^^^^^^^^^^^^^^^^
-
-error: missing documentation for a struct field
-  --> $DIR/missing-doc.rs:39:15
-   |
-LL |     PubBazA { a: isize },
-   |               ^^^^^^^^
-
-error: missing documentation for a constant
-  --> $DIR/missing-doc.rs:59:1
-   |
-LL | const FOO: u32 = 0;
-   | ^^^^^^^^^^^^^^^^^^^
-
-error: missing documentation for a constant
-  --> $DIR/missing-doc.rs:66:1
-   |
-LL | pub const FOO4: u32 = 0;
-   | ^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: missing documentation for a static
-  --> $DIR/missing-doc.rs:68:1
-   |
-LL | static BAR: u32 = 0;
-   | ^^^^^^^^^^^^^^^^^^^^
-
-error: missing documentation for a static
-  --> $DIR/missing-doc.rs:75:1
-   |
-LL | pub static BAR4: u32 = 0;
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: missing documentation for a module
-  --> $DIR/missing-doc.rs:77:1
-   |
-LL | / mod internal_impl {
-LL | |     /// dox
-LL | |     pub fn documented() {}
-LL | |     pub fn undocumented1() {}
-...  |
-LL | |     }
-LL | | }
-   | |_^
-
-error: missing documentation for a function
-  --> $DIR/missing-doc.rs:80:5
-   |
-LL |     pub fn undocumented1() {}
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: missing documentation for a function
-  --> $DIR/missing-doc.rs:81:5
-   |
-LL |     pub fn undocumented2() {}
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: missing documentation for a function
-  --> $DIR/missing-doc.rs:82:5
-   |
-LL |     fn undocumented3() {}
-   |     ^^^^^^^^^^^^^^^^^^^^^
-
-error: missing documentation for a function
-  --> $DIR/missing-doc.rs:87:9
-   |
-LL |         pub fn also_undocumented1() {}
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: missing documentation for a function
-  --> $DIR/missing-doc.rs:88:9
-   |
-LL |         fn also_undocumented2() {}
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: aborting due to 24 previous errors
-
diff --git a/tests/ui/missing_doc.rs b/tests/ui/missing_doc.rs
new file mode 100644
index 00000000000..29cc026a8fd
--- /dev/null
+++ b/tests/ui/missing_doc.rs
@@ -0,0 +1,115 @@
+// aux-build: proc_macro_with_span.rs
+
+#![warn(clippy::missing_docs_in_private_items)]
+// When denying at the crate level, be sure to not get random warnings from the
+// injected intrinsics by the compiler.
+#![allow(dead_code)]
+//! Some garbage docs for the crate here
+#![doc = "More garbage"]
+
+extern crate proc_macro_with_span;
+
+use proc_macro_with_span::with_span;
+use std::arch::global_asm;
+
+type Typedef = String;
+pub type PubTypedef = String;
+
+mod module_no_dox {}
+pub mod pub_module_no_dox {}
+
+/// dox
+pub fn foo() {}
+pub fn foo2() {}
+fn foo3() {}
+#[allow(clippy::missing_docs_in_private_items)]
+pub fn foo4() {}
+
+// It sure is nice if doc(hidden) implies allow(missing_docs), and that it
+// applies recursively
+#[doc(hidden)]
+mod a {
+    pub fn baz() {}
+    pub mod b {
+        pub fn baz() {}
+    }
+}
+
+enum Baz {
+    BazA { a: isize, b: isize },
+    BarB,
+}
+
+pub enum PubBaz {
+    PubBazA { a: isize },
+}
+
+/// dox
+pub enum PubBaz2 {
+    /// dox
+    PubBaz2A {
+        /// dox
+        a: isize,
+    },
+}
+
+#[allow(clippy::missing_docs_in_private_items)]
+pub enum PubBaz3 {
+    PubBaz3A { b: isize },
+}
+
+#[doc(hidden)]
+pub fn baz() {}
+
+const FOO: u32 = 0;
+/// dox
+pub const FOO1: u32 = 0;
+#[allow(clippy::missing_docs_in_private_items)]
+pub const FOO2: u32 = 0;
+#[doc(hidden)]
+pub const FOO3: u32 = 0;
+pub const FOO4: u32 = 0;
+
+static BAR: u32 = 0;
+/// dox
+pub static BAR1: u32 = 0;
+#[allow(clippy::missing_docs_in_private_items)]
+pub static BAR2: u32 = 0;
+#[doc(hidden)]
+pub static BAR3: u32 = 0;
+pub static BAR4: u32 = 0;
+
+mod internal_impl {
+    /// dox
+    pub fn documented() {}
+    pub fn undocumented1() {}
+    pub fn undocumented2() {}
+    fn undocumented3() {}
+    /// dox
+    pub mod globbed {
+        /// dox
+        pub fn also_documented() {}
+        pub fn also_undocumented1() {}
+        fn also_undocumented2() {}
+    }
+}
+/// dox
+pub mod public_interface {
+    pub use crate::internal_impl::documented as foo;
+    pub use crate::internal_impl::globbed::*;
+    pub use crate::internal_impl::undocumented1 as bar;
+    pub use crate::internal_impl::{documented, undocumented2};
+}
+
+fn main() {}
+
+// Ensure global asm doesn't require documentation.
+global_asm! { "" }
+
+// Don't lint proc macro output with an unexpected span.
+with_span!(span pub struct FooPm { pub field: u32});
+with_span!(span pub struct FooPm2;);
+with_span!(span pub enum FooPm3 { A, B(u32), C { field: u32 }});
+with_span!(span pub fn foo_pm() {});
+with_span!(span pub static FOO_PM: u32 = 0;);
+with_span!(span pub const FOO2_PM: u32 = 0;);
diff --git a/tests/ui/missing_doc.stderr b/tests/ui/missing_doc.stderr
new file mode 100644
index 00000000000..6c8e66f4643
--- /dev/null
+++ b/tests/ui/missing_doc.stderr
@@ -0,0 +1,159 @@
+error: missing documentation for a type alias
+  --> $DIR/missing_doc.rs:15:1
+   |
+LL | type Typedef = String;
+   | ^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::missing-docs-in-private-items` implied by `-D warnings`
+
+error: missing documentation for a type alias
+  --> $DIR/missing_doc.rs:16:1
+   |
+LL | pub type PubTypedef = String;
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: missing documentation for a module
+  --> $DIR/missing_doc.rs:18:1
+   |
+LL | mod module_no_dox {}
+   | ^^^^^^^^^^^^^^^^^^^^
+
+error: missing documentation for a module
+  --> $DIR/missing_doc.rs:19:1
+   |
+LL | pub mod pub_module_no_dox {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: missing documentation for a function
+  --> $DIR/missing_doc.rs:23:1
+   |
+LL | pub fn foo2() {}
+   | ^^^^^^^^^^^^^^^^
+
+error: missing documentation for a function
+  --> $DIR/missing_doc.rs:24:1
+   |
+LL | fn foo3() {}
+   | ^^^^^^^^^^^^
+
+error: missing documentation for an enum
+  --> $DIR/missing_doc.rs:38:1
+   |
+LL | / enum Baz {
+LL | |     BazA { a: isize, b: isize },
+LL | |     BarB,
+LL | | }
+   | |_^
+
+error: missing documentation for a variant
+  --> $DIR/missing_doc.rs:39:5
+   |
+LL |     BazA { a: isize, b: isize },
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: missing documentation for a struct field
+  --> $DIR/missing_doc.rs:39:12
+   |
+LL |     BazA { a: isize, b: isize },
+   |            ^^^^^^^^
+
+error: missing documentation for a struct field
+  --> $DIR/missing_doc.rs:39:22
+   |
+LL |     BazA { a: isize, b: isize },
+   |                      ^^^^^^^^
+
+error: missing documentation for a variant
+  --> $DIR/missing_doc.rs:40:5
+   |
+LL |     BarB,
+   |     ^^^^
+
+error: missing documentation for an enum
+  --> $DIR/missing_doc.rs:43:1
+   |
+LL | / pub enum PubBaz {
+LL | |     PubBazA { a: isize },
+LL | | }
+   | |_^
+
+error: missing documentation for a variant
+  --> $DIR/missing_doc.rs:44:5
+   |
+LL |     PubBazA { a: isize },
+   |     ^^^^^^^^^^^^^^^^^^^^
+
+error: missing documentation for a struct field
+  --> $DIR/missing_doc.rs:44:15
+   |
+LL |     PubBazA { a: isize },
+   |               ^^^^^^^^
+
+error: missing documentation for a constant
+  --> $DIR/missing_doc.rs:64:1
+   |
+LL | const FOO: u32 = 0;
+   | ^^^^^^^^^^^^^^^^^^^
+
+error: missing documentation for a constant
+  --> $DIR/missing_doc.rs:71:1
+   |
+LL | pub const FOO4: u32 = 0;
+   | ^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: missing documentation for a static
+  --> $DIR/missing_doc.rs:73:1
+   |
+LL | static BAR: u32 = 0;
+   | ^^^^^^^^^^^^^^^^^^^^
+
+error: missing documentation for a static
+  --> $DIR/missing_doc.rs:80:1
+   |
+LL | pub static BAR4: u32 = 0;
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: missing documentation for a module
+  --> $DIR/missing_doc.rs:82:1
+   |
+LL | / mod internal_impl {
+LL | |     /// dox
+LL | |     pub fn documented() {}
+LL | |     pub fn undocumented1() {}
+...  |
+LL | |     }
+LL | | }
+   | |_^
+
+error: missing documentation for a function
+  --> $DIR/missing_doc.rs:85:5
+   |
+LL |     pub fn undocumented1() {}
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: missing documentation for a function
+  --> $DIR/missing_doc.rs:86:5
+   |
+LL |     pub fn undocumented2() {}
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: missing documentation for a function
+  --> $DIR/missing_doc.rs:87:5
+   |
+LL |     fn undocumented3() {}
+   |     ^^^^^^^^^^^^^^^^^^^^^
+
+error: missing documentation for a function
+  --> $DIR/missing_doc.rs:92:9
+   |
+LL |         pub fn also_undocumented1() {}
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: missing documentation for a function
+  --> $DIR/missing_doc.rs:93:9
+   |
+LL |         fn also_undocumented2() {}
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 24 previous errors
+
diff --git a/tests/ui/missing_doc_crate.rs b/tests/ui/missing_doc_crate.rs
new file mode 100644
index 00000000000..e00c7fbfed1
--- /dev/null
+++ b/tests/ui/missing_doc_crate.rs
@@ -0,0 +1,4 @@
+#![warn(clippy::missing_docs_in_private_items)]
+#![doc = include_str!("../../README.md")]
+
+fn main() {}
diff --git a/tests/ui/missing_doc_crate_missing.rs b/tests/ui/missing_doc_crate_missing.rs
new file mode 100644
index 00000000000..51fd57df8df
--- /dev/null
+++ b/tests/ui/missing_doc_crate_missing.rs
@@ -0,0 +1,3 @@
+#![warn(clippy::missing_docs_in_private_items)]
+
+fn main() {}
diff --git a/tests/ui/missing_doc_crate_missing.stderr b/tests/ui/missing_doc_crate_missing.stderr
new file mode 100644
index 00000000000..19516bf5fab
--- /dev/null
+++ b/tests/ui/missing_doc_crate_missing.stderr
@@ -0,0 +1,12 @@
+error: missing documentation for the crate
+  --> $DIR/missing_doc_crate_missing.rs:1:1
+   |
+LL | / #![warn(clippy::missing_docs_in_private_items)]
+LL | |
+LL | | fn main() {}
+   | |____________^
+   |
+   = note: `-D clippy::missing-docs-in-private-items` implied by `-D warnings`
+
+error: aborting due to previous error
+
diff --git a/tests/ui/missing_doc_impl.rs b/tests/ui/missing_doc_impl.rs
new file mode 100644
index 00000000000..0396d1193ff
--- /dev/null
+++ b/tests/ui/missing_doc_impl.rs
@@ -0,0 +1,107 @@
+// aux-build: proc_macro_with_span.rs
+
+#![warn(clippy::missing_docs_in_private_items)]
+#![allow(dead_code)]
+#![feature(associated_type_defaults)]
+
+//! Some garbage docs for the crate here
+#![doc = "More garbage"]
+
+extern crate proc_macro_with_span;
+use proc_macro_with_span::with_span;
+
+struct Foo {
+    a: isize,
+    b: isize,
+}
+
+pub struct PubFoo {
+    pub a: isize,
+    b: isize,
+}
+
+#[allow(clippy::missing_docs_in_private_items)]
+pub struct PubFoo2 {
+    pub a: isize,
+    pub c: isize,
+}
+
+/// dox
+pub trait A {
+    /// dox
+    fn foo(&self);
+    /// dox
+    fn foo_with_impl(&self) {}
+}
+
+#[allow(clippy::missing_docs_in_private_items)]
+trait B {
+    fn foo(&self);
+    fn foo_with_impl(&self) {}
+}
+
+pub trait C {
+    fn foo(&self);
+    fn foo_with_impl(&self) {}
+}
+
+#[allow(clippy::missing_docs_in_private_items)]
+pub trait D {
+    fn dummy(&self) {}
+}
+
+/// dox
+pub trait E: Sized {
+    type AssociatedType;
+    type AssociatedTypeDef = Self;
+
+    /// dox
+    type DocumentedType;
+    /// dox
+    type DocumentedTypeDef = Self;
+    /// dox
+    fn dummy(&self) {}
+}
+
+impl Foo {
+    pub fn new() -> Self {
+        Foo { a: 0, b: 0 }
+    }
+    fn bar() {}
+}
+
+impl PubFoo {
+    pub fn foo() {}
+    /// dox
+    pub fn foo1() {}
+    #[must_use = "yep"]
+    fn foo2() -> u32 {
+        1
+    }
+    #[allow(clippy::missing_docs_in_private_items)]
+    pub fn foo3() {}
+}
+
+#[allow(clippy::missing_docs_in_private_items)]
+trait F {
+    fn a();
+    fn b(&self);
+}
+
+// should need to redefine documentation for implementations of traits
+impl F for Foo {
+    fn a() {}
+    fn b(&self) {}
+}
+
+fn main() {}
+
+// don't lint proc macro output
+with_span!(span
+    pub struct FooPm;
+    impl FooPm {
+        pub fn foo() {}
+        pub const fn bar() {}
+        pub const X: u32 = 0;
+    }
+);
diff --git a/tests/ui/missing_doc_impl.stderr b/tests/ui/missing_doc_impl.stderr
new file mode 100644
index 00000000000..f22fa19dbca
--- /dev/null
+++ b/tests/ui/missing_doc_impl.stderr
@@ -0,0 +1,107 @@
+error: missing documentation for a struct
+  --> $DIR/missing_doc_impl.rs:13:1
+   |
+LL | / struct Foo {
+LL | |     a: isize,
+LL | |     b: isize,
+LL | | }
+   | |_^
+   |
+   = note: `-D clippy::missing-docs-in-private-items` implied by `-D warnings`
+
+error: missing documentation for a struct field
+  --> $DIR/missing_doc_impl.rs:14:5
+   |
+LL |     a: isize,
+   |     ^^^^^^^^
+
+error: missing documentation for a struct field
+  --> $DIR/missing_doc_impl.rs:15:5
+   |
+LL |     b: isize,
+   |     ^^^^^^^^
+
+error: missing documentation for a struct
+  --> $DIR/missing_doc_impl.rs:18:1
+   |
+LL | / pub struct PubFoo {
+LL | |     pub a: isize,
+LL | |     b: isize,
+LL | | }
+   | |_^
+
+error: missing documentation for a struct field
+  --> $DIR/missing_doc_impl.rs:19:5
+   |
+LL |     pub a: isize,
+   |     ^^^^^^^^^^^^
+
+error: missing documentation for a struct field
+  --> $DIR/missing_doc_impl.rs:20:5
+   |
+LL |     b: isize,
+   |     ^^^^^^^^
+
+error: missing documentation for a trait
+  --> $DIR/missing_doc_impl.rs:43:1
+   |
+LL | / pub trait C {
+LL | |     fn foo(&self);
+LL | |     fn foo_with_impl(&self) {}
+LL | | }
+   | |_^
+
+error: missing documentation for an associated function
+  --> $DIR/missing_doc_impl.rs:44:5
+   |
+LL |     fn foo(&self);
+   |     ^^^^^^^^^^^^^^
+
+error: missing documentation for an associated function
+  --> $DIR/missing_doc_impl.rs:45:5
+   |
+LL |     fn foo_with_impl(&self) {}
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: missing documentation for an associated type
+  --> $DIR/missing_doc_impl.rs:55:5
+   |
+LL |     type AssociatedType;
+   |     ^^^^^^^^^^^^^^^^^^^^
+
+error: missing documentation for an associated type
+  --> $DIR/missing_doc_impl.rs:56:5
+   |
+LL |     type AssociatedTypeDef = Self;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: missing documentation for an associated function
+  --> $DIR/missing_doc_impl.rs:67:5
+   |
+LL | /     pub fn new() -> Self {
+LL | |         Foo { a: 0, b: 0 }
+LL | |     }
+   | |_____^
+
+error: missing documentation for an associated function
+  --> $DIR/missing_doc_impl.rs:70:5
+   |
+LL |     fn bar() {}
+   |     ^^^^^^^^^^^
+
+error: missing documentation for an associated function
+  --> $DIR/missing_doc_impl.rs:74:5
+   |
+LL |     pub fn foo() {}
+   |     ^^^^^^^^^^^^^^^
+
+error: missing documentation for an associated function
+  --> $DIR/missing_doc_impl.rs:78:5
+   |
+LL | /     fn foo2() -> u32 {
+LL | |         1
+LL | |     }
+   | |_____^
+
+error: aborting due to 15 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 670efd5720b31e235c8e97f49f612e685db97b93 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Wed, 13 Apr 2022 10:13:39 -0400
Subject: Don't lint `default_trait_access` in proc-macro expansions

---
 clippy_lints/src/default.rs          |  5 ++++-
 clippy_utils/src/check_proc_macro.rs |  8 ++++----
 tests/ui/default_trait_access.fixed  |  6 ++++++
 tests/ui/default_trait_access.rs     |  6 ++++++
 tests/ui/default_trait_access.stderr | 18 +++++++++---------
 5 files changed, 29 insertions(+), 14 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/default.rs b/clippy_lints/src/default.rs
index d99a1aa2969..74f7df61177 100644
--- a/clippy_lints/src/default.rs
+++ b/clippy_lints/src/default.rs
@@ -1,7 +1,9 @@
 use clippy_utils::diagnostics::{span_lint_and_note, span_lint_and_sugg};
 use clippy_utils::source::snippet_with_macro_callsite;
 use clippy_utils::ty::{has_drop, is_copy};
-use clippy_utils::{any_parent_is_automatically_derived, contains_name, get_parent_expr, match_def_path, paths};
+use clippy_utils::{
+    any_parent_is_automatically_derived, contains_name, get_parent_expr, is_from_proc_macro, match_def_path, paths,
+};
 use if_chain::if_chain;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Applicability;
@@ -94,6 +96,7 @@ impl<'tcx> LateLintPass<'tcx> for Default {
             if let QPath::Resolved(None, _path) = qpath;
             let expr_ty = cx.typeck_results().expr_ty(expr);
             if let ty::Adt(def, ..) = expr_ty.kind();
+            if !is_from_proc_macro(cx, expr);
             then {
                 // TODO: Work out a way to put "whatever the imported way of referencing
                 // this type in this file" rather than a fully-qualified type.
diff --git a/clippy_utils/src/check_proc_macro.rs b/clippy_utils/src/check_proc_macro.rs
index 4dd0ec6b6d0..f546a788c5d 100644
--- a/clippy_utils/src/check_proc_macro.rs
+++ b/clippy_utils/src/check_proc_macro.rs
@@ -16,7 +16,7 @@ use rustc_ast::ast::{IntTy, LitIntType, LitKind, StrStyle, UintTy};
 use rustc_hir::{
     Block, BlockCheckMode, Closure, Destination, Expr, ExprKind, FieldDef, FnHeader, Impl, ImplItem, ImplItemKind,
     IsAuto, Item, ItemKind, LoopSource, MatchSource, QPath, TraitItem, TraitItemKind, UnOp, UnsafeSource, Unsafety,
-    Variant, VariantData, VisibilityKind, YieldSource,
+    Variant, VariantData, YieldSource,
 };
 use rustc_lint::{LateContext, LintContext};
 use rustc_middle::ty::TyCtxt;
@@ -196,7 +196,7 @@ fn item_search_pat(item: &Item<'_>) -> (Pat, Pat) {
         ItemKind::Impl(_) => (Pat::Str("impl"), Pat::Str("}")),
         _ => return (Pat::Str(""), Pat::Str("")),
     };
-    if matches!(item.vis.node, VisibilityKind::Inherited) {
+    if item.vis_span.is_empty() {
         (start_pat, end_pat)
     } else {
         (Pat::Str("pub"), end_pat)
@@ -217,7 +217,7 @@ fn impl_item_search_pat(item: &ImplItem<'_>) -> (Pat, Pat) {
         ImplItemKind::TyAlias(..) => (Pat::Str("type"), Pat::Str(";")),
         ImplItemKind::Fn(sig, ..) => (fn_header_search_pat(sig.header), Pat::Str("")),
     };
-    if matches!(item.vis.node, VisibilityKind::Inherited) {
+    if item.vis_span.is_empty() {
         (start_pat, end_pat)
     } else {
         (Pat::Str("pub"), end_pat)
@@ -225,7 +225,7 @@ fn impl_item_search_pat(item: &ImplItem<'_>) -> (Pat, Pat) {
 }
 
 fn field_def_search_pat(def: &FieldDef<'_>) -> (Pat, Pat) {
-    if matches!(def.vis.node, VisibilityKind::Inherited) {
+    if def.vis_span.is_empty() {
         if def.is_positional() {
             (Pat::Str(""), Pat::Str(""))
         } else {
diff --git a/tests/ui/default_trait_access.fixed b/tests/ui/default_trait_access.fixed
index 264dd4efaeb..fce66eb1759 100644
--- a/tests/ui/default_trait_access.fixed
+++ b/tests/ui/default_trait_access.fixed
@@ -1,8 +1,12 @@
 // run-rustfix
+// aux-build: proc_macro_with_span.rs
 
 #![allow(unused_imports, dead_code)]
 #![deny(clippy::default_trait_access)]
 
+extern crate proc_macro_with_span;
+
+use proc_macro_with_span::with_span;
 use std::default;
 use std::default::Default as D2;
 use std::string;
@@ -51,6 +55,8 @@ fn main() {
         ..Default::default()
     };
 
+    let _s21: String = with_span!(s Default::default());
+
     println!(
         "[{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}] [{:?}] [{:?}] [{:?}] [{:?}] [{:?}] [{:?}] [{:?}] [{:?}] [{:?}] [{:?}] [{:?}]",
         s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17, s18, s19, s20,
diff --git a/tests/ui/default_trait_access.rs b/tests/ui/default_trait_access.rs
index a0930fab8e7..3e8e898b7bc 100644
--- a/tests/ui/default_trait_access.rs
+++ b/tests/ui/default_trait_access.rs
@@ -1,8 +1,12 @@
 // run-rustfix
+// aux-build: proc_macro_with_span.rs
 
 #![allow(unused_imports, dead_code)]
 #![deny(clippy::default_trait_access)]
 
+extern crate proc_macro_with_span;
+
+use proc_macro_with_span::with_span;
 use std::default;
 use std::default::Default as D2;
 use std::string;
@@ -51,6 +55,8 @@ fn main() {
         ..Default::default()
     };
 
+    let _s21: String = with_span!(s Default::default());
+
     println!(
         "[{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}] [{}] [{:?}] [{:?}] [{:?}] [{:?}] [{:?}] [{:?}] [{:?}] [{:?}] [{:?}] [{:?}] [{:?}]",
         s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17, s18, s19, s20,
diff --git a/tests/ui/default_trait_access.stderr b/tests/ui/default_trait_access.stderr
index df8a5b94ddc..3493de37a55 100644
--- a/tests/ui/default_trait_access.stderr
+++ b/tests/ui/default_trait_access.stderr
@@ -1,53 +1,53 @@
 error: calling `std::string::String::default()` is more clear than this expression
-  --> $DIR/default_trait_access.rs:11:22
+  --> $DIR/default_trait_access.rs:15:22
    |
 LL |     let s1: String = Default::default();
    |                      ^^^^^^^^^^^^^^^^^^ help: try: `std::string::String::default()`
    |
 note: the lint level is defined here
-  --> $DIR/default_trait_access.rs:4:9
+  --> $DIR/default_trait_access.rs:5:9
    |
 LL | #![deny(clippy::default_trait_access)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: calling `std::string::String::default()` is more clear than this expression
-  --> $DIR/default_trait_access.rs:15:22
+  --> $DIR/default_trait_access.rs:19:22
    |
 LL |     let s3: String = D2::default();
    |                      ^^^^^^^^^^^^^ help: try: `std::string::String::default()`
 
 error: calling `std::string::String::default()` is more clear than this expression
-  --> $DIR/default_trait_access.rs:17:22
+  --> $DIR/default_trait_access.rs:21:22
    |
 LL |     let s4: String = std::default::Default::default();
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::string::String::default()`
 
 error: calling `std::string::String::default()` is more clear than this expression
-  --> $DIR/default_trait_access.rs:21:22
+  --> $DIR/default_trait_access.rs:25:22
    |
 LL |     let s6: String = default::Default::default();
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::string::String::default()`
 
 error: calling `GenericDerivedDefault::default()` is more clear than this expression
-  --> $DIR/default_trait_access.rs:31:46
+  --> $DIR/default_trait_access.rs:35:46
    |
 LL |     let s11: GenericDerivedDefault<String> = Default::default();
    |                                              ^^^^^^^^^^^^^^^^^^ help: try: `GenericDerivedDefault::default()`
 
 error: calling `TupleDerivedDefault::default()` is more clear than this expression
-  --> $DIR/default_trait_access.rs:37:36
+  --> $DIR/default_trait_access.rs:41:36
    |
 LL |     let s14: TupleDerivedDefault = Default::default();
    |                                    ^^^^^^^^^^^^^^^^^^ help: try: `TupleDerivedDefault::default()`
 
 error: calling `ArrayDerivedDefault::default()` is more clear than this expression
-  --> $DIR/default_trait_access.rs:39:36
+  --> $DIR/default_trait_access.rs:43:36
    |
 LL |     let s15: ArrayDerivedDefault = Default::default();
    |                                    ^^^^^^^^^^^^^^^^^^ help: try: `ArrayDerivedDefault::default()`
 
 error: calling `TupleStructDerivedDefault::default()` is more clear than this expression
-  --> $DIR/default_trait_access.rs:43:42
+  --> $DIR/default_trait_access.rs:47:42
    |
 LL |     let s17: TupleStructDerivedDefault = Default::default();
    |                                          ^^^^^^^^^^^^^^^^^^ help: try: `TupleStructDerivedDefault::default()`
-- 
cgit 1.4.1-3-g733a5


From 5285928bc0190efb54495d8126b68778873884b9 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Mon, 8 Aug 2022 10:09:05 -0400
Subject: Fix ICE when checking the HIR ty of closure args.

---
 clippy_lints/src/dereference.rs     | 67 ++++++++++++++++++-----------
 tests/ui/explicit_auto_deref.fixed  | 11 +++++
 tests/ui/explicit_auto_deref.rs     | 11 +++++
 tests/ui/explicit_auto_deref.stderr | 86 +++++++++++++++++++++----------------
 4 files changed, 112 insertions(+), 63 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index 05dbc743485..821528d7ab9 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -15,7 +15,7 @@ use rustc_hir::{
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::adjustment::{Adjust, Adjustment, AutoBorrow, AutoBorrowMutability};
-use rustc_middle::ty::{self, Ty, TyCtxt, TypeVisitable, TypeckResults};
+use rustc_middle::ty::{self, Binder, BoundVariableKind, List, Ty, TyCtxt, TypeVisitable, TypeckResults};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::{symbol::sym, Span, Symbol, DUMMY_SP};
 use rustc_trait_selection::infer::InferCtxtExt;
@@ -651,7 +651,7 @@ fn walk_parents<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> (Position, &
         }
         match parent {
             Node::Local(Local { ty: Some(ty), span, .. }) if span.ctxt() == ctxt => {
-                Some(binding_ty_auto_deref_stability(cx, ty, precedence))
+                Some(binding_ty_auto_deref_stability(cx, ty, precedence, List::empty()))
             },
             Node::Item(&Item {
                 kind: ItemKind::Static(..) | ItemKind::Const(..),
@@ -703,13 +703,23 @@ fn walk_parents<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> (Position, &
                 ExprKind::Ret(_) => {
                     let owner_id = cx.tcx.hir().body_owner(cx.enclosing_body.unwrap());
                     Some(
-                        if let Node::Expr(Expr {
-                            kind: ExprKind::Closure(&Closure { fn_decl, .. }),
-                            ..
-                        }) = cx.tcx.hir().get(owner_id)
+                        if let Node::Expr(
+                            closure @ Expr {
+                                kind: ExprKind::Closure(&Closure { fn_decl, .. }),
+                                ..
+                            },
+                        ) = cx.tcx.hir().get(owner_id)
                         {
                             match fn_decl.output {
-                                FnRetTy::Return(ty) => binding_ty_auto_deref_stability(cx, ty, precedence),
+                                FnRetTy::Return(ty) => {
+                                    if let Some(sig) = expr_sig(cx, closure)
+                                        && let Some(output) = sig.output()
+                                    {
+                                        binding_ty_auto_deref_stability(cx, ty, precedence, output.bound_vars())
+                                    } else {
+                                        Position::Other(precedence)
+                                    }
+                                },
                                 FnRetTy::DefaultReturn(_) => Position::Other(precedence),
                             }
                         } else {
@@ -731,7 +741,7 @@ fn walk_parents<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> (Position, &
                     .map(|(hir_ty, ty)| match hir_ty {
                         // Type inference for closures can depend on how they're called. Only go by the explicit
                         // types here.
-                        Some(ty) => binding_ty_auto_deref_stability(cx, ty, precedence),
+                        Some(hir_ty) => binding_ty_auto_deref_stability(cx, hir_ty, precedence, ty.bound_vars()),
                         None => ty_auto_deref_stability(cx, cx.tcx.erase_late_bound_regions(ty), precedence)
                             .position_for_arg(),
                     }),
@@ -824,7 +834,12 @@ fn walk_parents<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> (Position, &
 //
 // Here `y1` and `y2` would resolve to different types, so the type `&Box<_>` is not stable when
 // switching to auto-dereferencing.
-fn binding_ty_auto_deref_stability(cx: &LateContext<'_>, ty: &hir::Ty<'_>, precedence: i8) -> Position {
+fn binding_ty_auto_deref_stability<'tcx>(
+    cx: &LateContext<'tcx>,
+    ty: &'tcx hir::Ty<'_>,
+    precedence: i8,
+    binder_args: &'tcx List<BoundVariableKind>,
+) -> Position {
     let TyKind::Rptr(_, ty) = &ty.kind else {
         return Position::Other(precedence);
     };
@@ -856,31 +871,31 @@ fn binding_ty_auto_deref_stability(cx: &LateContext<'_>, ty: &hir::Ty<'_>, prece
                 } else {
                     Position::DerefStable(
                         precedence,
-                        cx
-                            .typeck_results()
-                            .node_type(ty.ty.hir_id)
+                        cx.tcx
+                            .erase_late_bound_regions(Binder::bind_with_vars(
+                                cx.typeck_results().node_type(ty.ty.hir_id),
+                                binder_args,
+                            ))
                             .is_sized(cx.tcx.at(DUMMY_SP), cx.param_env.without_caller_bounds()),
                     )
                 }
             },
-            TyKind::Slice(_)
-            | TyKind::Array(..)
-            | TyKind::BareFn(_)
-            | TyKind::Never
+            TyKind::Slice(_) => Position::DerefStable(precedence, false),
+            TyKind::Array(..) | TyKind::Ptr(_) | TyKind::BareFn(_) => Position::DerefStable(precedence, true),
+            TyKind::Never
             | TyKind::Tup(_)
-            | TyKind::Ptr(_)
             | TyKind::Path(_) => Position::DerefStable(
                 precedence,
-                cx
-                .typeck_results()
-                .node_type(ty.ty.hir_id)
-                .is_sized(cx.tcx.at(DUMMY_SP), cx.param_env.without_caller_bounds()),
+                cx.tcx
+                    .erase_late_bound_regions(Binder::bind_with_vars(
+                        cx.typeck_results().node_type(ty.ty.hir_id),
+                        binder_args,
+                    ))
+                    .is_sized(cx.tcx.at(DUMMY_SP), cx.param_env.without_caller_bounds()),
             ),
-            TyKind::OpaqueDef(..)
-            | TyKind::Infer
-            | TyKind::Typeof(..)
-            | TyKind::TraitObject(..)
-            | TyKind::Err => Position::ReborrowStable(precedence),
+            TyKind::OpaqueDef(..) | TyKind::Infer | TyKind::Typeof(..) | TyKind::TraitObject(..) | TyKind::Err => {
+                Position::ReborrowStable(precedence)
+            },
         };
     }
 }
diff --git a/tests/ui/explicit_auto_deref.fixed b/tests/ui/explicit_auto_deref.fixed
index 1e868af87cb..27bc7fbfae3 100644
--- a/tests/ui/explicit_auto_deref.fixed
+++ b/tests/ui/explicit_auto_deref.fixed
@@ -1,5 +1,6 @@
 // run-rustfix
 
+#![feature(closure_lifetime_binder)]
 #![warn(clippy::explicit_auto_deref)]
 #![allow(
     dead_code,
@@ -255,4 +256,14 @@ fn main() {
     }
     let x = S7([0]);
     let _: &[u32] = &*x;
+
+    let c1 = |x: &Vec<&u32>| {};
+    let x = &&vec![&1u32];
+    c1(x);
+    let _ = for<'a, 'b> |x: &'a &'a Vec<&'b u32>, b: bool| -> &'a Vec<&'b u32> {
+        if b {
+            return x;
+        }
+        *x
+    };
 }
diff --git a/tests/ui/explicit_auto_deref.rs b/tests/ui/explicit_auto_deref.rs
index a2157d9b4f0..64aea9f464e 100644
--- a/tests/ui/explicit_auto_deref.rs
+++ b/tests/ui/explicit_auto_deref.rs
@@ -1,5 +1,6 @@
 // run-rustfix
 
+#![feature(closure_lifetime_binder)]
 #![warn(clippy::explicit_auto_deref)]
 #![allow(
     dead_code,
@@ -255,4 +256,14 @@ fn main() {
     }
     let x = S7([0]);
     let _: &[u32] = &*x;
+
+    let c1 = |x: &Vec<&u32>| {};
+    let x = &&vec![&1u32];
+    c1(*x);
+    let _ = for<'a, 'b> |x: &'a &'a Vec<&'b u32>, b: bool| -> &'a Vec<&'b u32> {
+        if b {
+            return *x;
+        }
+        *x
+    };
 }
diff --git a/tests/ui/explicit_auto_deref.stderr b/tests/ui/explicit_auto_deref.stderr
index f2933390fb9..12db0c6f87f 100644
--- a/tests/ui/explicit_auto_deref.stderr
+++ b/tests/ui/explicit_auto_deref.stderr
@@ -1,5 +1,5 @@
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:69:19
+  --> $DIR/explicit_auto_deref.rs:70:19
    |
 LL |     let _: &str = &*s;
    |                   ^^^ help: try this: `&s`
@@ -7,214 +7,226 @@ LL |     let _: &str = &*s;
    = note: `-D clippy::explicit-auto-deref` implied by `-D warnings`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:70:19
+  --> $DIR/explicit_auto_deref.rs:71:19
    |
 LL |     let _: &str = &*{ String::new() };
    |                   ^^^^^^^^^^^^^^^^^^^ help: try this: `&{ String::new() }`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:71:19
+  --> $DIR/explicit_auto_deref.rs:72:19
    |
 LL |     let _: &str = &mut *{ String::new() };
    |                   ^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&mut { String::new() }`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:75:11
+  --> $DIR/explicit_auto_deref.rs:76:11
    |
 LL |     f_str(&*s);
    |           ^^^ help: try this: `&s`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:79:13
+  --> $DIR/explicit_auto_deref.rs:80:13
    |
 LL |     f_str_t(&*s, &*s); // Don't lint second param.
    |             ^^^ help: try this: `&s`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:82:24
+  --> $DIR/explicit_auto_deref.rs:83:24
    |
 LL |     let _: &Box<i32> = &**b;
    |                        ^^^^ help: try this: `&b`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:88:7
+  --> $DIR/explicit_auto_deref.rs:89:7
    |
 LL |     c(&*s);
    |       ^^^ help: try this: `&s`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:94:9
+  --> $DIR/explicit_auto_deref.rs:95:9
    |
 LL |         &**x
    |         ^^^^ help: try this: `x`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:98:11
+  --> $DIR/explicit_auto_deref.rs:99:11
    |
 LL |         { &**x }
    |           ^^^^ help: try this: `x`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:102:9
+  --> $DIR/explicit_auto_deref.rs:103:9
    |
 LL |         &**{ x }
    |         ^^^^^^^^ help: try this: `{ x }`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:106:9
+  --> $DIR/explicit_auto_deref.rs:107:9
    |
 LL |         &***x
    |         ^^^^^ help: try this: `x`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:123:12
+  --> $DIR/explicit_auto_deref.rs:124:12
    |
 LL |         f1(&*x);
    |            ^^^ help: try this: `&x`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:124:12
+  --> $DIR/explicit_auto_deref.rs:125:12
    |
 LL |         f2(&*x);
    |            ^^^ help: try this: `&x`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:125:12
+  --> $DIR/explicit_auto_deref.rs:126:12
    |
 LL |         f3(&*x);
    |            ^^^ help: try this: `&x`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:126:27
+  --> $DIR/explicit_auto_deref.rs:127:27
    |
 LL |         f4.callable_str()(&*x);
    |                           ^^^ help: try this: `&x`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:127:12
+  --> $DIR/explicit_auto_deref.rs:128:12
    |
 LL |         f5(&*x);
    |            ^^^ help: try this: `&x`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:128:12
+  --> $DIR/explicit_auto_deref.rs:129:12
    |
 LL |         f6(&*x);
    |            ^^^ help: try this: `&x`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:129:27
+  --> $DIR/explicit_auto_deref.rs:130:27
    |
 LL |         f7.callable_str()(&*x);
    |                           ^^^ help: try this: `&x`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:130:25
+  --> $DIR/explicit_auto_deref.rs:131:25
    |
 LL |         f8.callable_t()(&*x);
    |                         ^^^ help: try this: `&x`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:131:12
+  --> $DIR/explicit_auto_deref.rs:132:12
    |
 LL |         f9(&*x);
    |            ^^^ help: try this: `&x`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:132:13
+  --> $DIR/explicit_auto_deref.rs:133:13
    |
 LL |         f10(&*x);
    |             ^^^ help: try this: `&x`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:133:26
+  --> $DIR/explicit_auto_deref.rs:134:26
    |
 LL |         f11.callable_t()(&*x);
    |                          ^^^ help: try this: `&x`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:137:16
+  --> $DIR/explicit_auto_deref.rs:138:16
    |
 LL |     let _ = S1(&*s);
    |                ^^^ help: try this: `&s`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:142:21
+  --> $DIR/explicit_auto_deref.rs:143:21
    |
 LL |     let _ = S2 { s: &*s };
    |                     ^^^ help: try this: `&s`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:158:30
+  --> $DIR/explicit_auto_deref.rs:159:30
    |
 LL |             let _ = Self::S1(&**s);
    |                              ^^^^ help: try this: `s`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:159:35
+  --> $DIR/explicit_auto_deref.rs:160:35
    |
 LL |             let _ = Self::S2 { s: &**s };
    |                                   ^^^^ help: try this: `s`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:162:20
+  --> $DIR/explicit_auto_deref.rs:163:20
    |
 LL |     let _ = E1::S1(&*s);
    |                    ^^^ help: try this: `&s`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:163:25
+  --> $DIR/explicit_auto_deref.rs:164:25
    |
 LL |     let _ = E1::S2 { s: &*s };
    |                         ^^^ help: try this: `&s`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:181:13
+  --> $DIR/explicit_auto_deref.rs:182:13
    |
 LL |     let _ = (*b).foo;
    |             ^^^^ help: try this: `b`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:182:13
+  --> $DIR/explicit_auto_deref.rs:183:13
    |
 LL |     let _ = (**b).foo;
    |             ^^^^^ help: try this: `b`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:197:19
+  --> $DIR/explicit_auto_deref.rs:198:19
    |
 LL |     let _ = f_str(*ref_str);
    |                   ^^^^^^^^ help: try this: `ref_str`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:199:19
+  --> $DIR/explicit_auto_deref.rs:200:19
    |
 LL |     let _ = f_str(**ref_ref_str);
    |                   ^^^^^^^^^^^^^ help: try this: `ref_ref_str`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:209:13
+  --> $DIR/explicit_auto_deref.rs:210:13
    |
 LL |     f_str(&&*ref_str); // `needless_borrow` will suggest removing both references
    |             ^^^^^^^^ help: try this: `ref_str`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:210:12
+  --> $DIR/explicit_auto_deref.rs:211:12
    |
 LL |     f_str(&&**ref_str); // `needless_borrow` will suggest removing only one reference
    |            ^^^^^^^^^^ help: try this: `ref_str`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:219:41
+  --> $DIR/explicit_auto_deref.rs:220:41
    |
 LL |     let _ = || -> &'static str { return *s };
    |                                         ^^ help: try this: `s`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:238:9
+  --> $DIR/explicit_auto_deref.rs:239:9
    |
 LL |         &**x
    |         ^^^^ help: try this: `x`
 
-error: aborting due to 36 previous errors
+error: deref which would be done by auto-deref
+  --> $DIR/explicit_auto_deref.rs:262:8
+   |
+LL |     c1(*x);
+   |        ^^ help: try this: `x`
+
+error: deref which would be done by auto-deref
+  --> $DIR/explicit_auto_deref.rs:265:20
+   |
+LL |             return *x;
+   |                    ^^ help: try this: `x`
+
+error: aborting due to 38 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From ecb51fe6a55f975f2d3bfd65d3568c263c248460 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Mon, 8 Aug 2022 10:25:05 -0400
Subject: Lint `explicit_auto_deref` in implicit return positions for closures

---
 clippy_lints/src/dereference.rs     | 45 ++++++++++++++++++++++++-------------
 clippy_utils/src/ty.rs              |  3 ++-
 tests/ui/explicit_auto_deref.fixed  |  4 ++--
 tests/ui/explicit_auto_deref.rs     |  2 +-
 tests/ui/explicit_auto_deref.stderr |  8 ++++++-
 5 files changed, 42 insertions(+), 20 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index 821528d7ab9..1c19a9e0e60 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_hir_and_then};
 use clippy_utils::source::{snippet_with_applicability, snippet_with_context};
 use clippy_utils::sugg::has_enclosing_paren;
-use clippy_utils::ty::{expr_sig, peel_mid_ty_refs, variant_of_res};
+use clippy_utils::ty::{expr_sig, peel_mid_ty_refs, ty_sig, variant_of_res};
 use clippy_utils::{get_parent_expr, is_lint_allowed, path_to_local, walk_to_expr_usage};
 use rustc_ast::util::parser::{PREC_POSTFIX, PREC_PREFIX};
 use rustc_data_structures::fx::FxIndexMap;
@@ -704,24 +704,13 @@ fn walk_parents<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> (Position, &
                     let owner_id = cx.tcx.hir().body_owner(cx.enclosing_body.unwrap());
                     Some(
                         if let Node::Expr(
-                            closure @ Expr {
-                                kind: ExprKind::Closure(&Closure { fn_decl, .. }),
+                            closure_expr @ Expr {
+                                kind: ExprKind::Closure(closure),
                                 ..
                             },
                         ) = cx.tcx.hir().get(owner_id)
                         {
-                            match fn_decl.output {
-                                FnRetTy::Return(ty) => {
-                                    if let Some(sig) = expr_sig(cx, closure)
-                                        && let Some(output) = sig.output()
-                                    {
-                                        binding_ty_auto_deref_stability(cx, ty, precedence, output.bound_vars())
-                                    } else {
-                                        Position::Other(precedence)
-                                    }
-                                },
-                                FnRetTy::DefaultReturn(_) => Position::Other(precedence),
-                            }
+                            closure_result_position(cx, closure, cx.typeck_results().expr_ty(closure_expr), precedence)
                         } else {
                             let output = cx
                                 .tcx
@@ -730,6 +719,12 @@ fn walk_parents<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> (Position, &
                         },
                     )
                 },
+                ExprKind::Closure(closure) => Some(closure_result_position(
+                    cx,
+                    closure,
+                    cx.typeck_results().expr_ty(parent),
+                    precedence,
+                )),
                 ExprKind::Call(func, _) if func.hir_id == child_id => {
                     (child_id == e.hir_id).then_some(Position::Callee)
                 },
@@ -825,6 +820,26 @@ fn walk_parents<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> (Position, &
     (position, adjustments)
 }
 
+fn closure_result_position<'tcx>(
+    cx: &LateContext<'tcx>,
+    closure: &'tcx Closure<'_>,
+    ty: Ty<'tcx>,
+    precedence: i8,
+) -> Position {
+    match closure.fn_decl.output {
+        FnRetTy::Return(hir_ty) => {
+            if let Some(sig) = ty_sig(cx, ty)
+                && let Some(output) = sig.output()
+            {
+                binding_ty_auto_deref_stability(cx, hir_ty, precedence, output.bound_vars())
+            } else {
+                Position::Other(precedence)
+            }
+        },
+        FnRetTy::DefaultReturn(_) => Position::Other(precedence),
+    }
+}
+
 // Checks the stability of auto-deref when assigned to a binding with the given explicit type.
 //
 // e.g.
diff --git a/clippy_utils/src/ty.rs b/clippy_utils/src/ty.rs
index d394360fc67..e7d670766a0 100644
--- a/clippy_utils/src/ty.rs
+++ b/clippy_utils/src/ty.rs
@@ -572,7 +572,8 @@ pub fn expr_sig<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>) -> Option<ExprFnS
     }
 }
 
-fn ty_sig<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Option<ExprFnSig<'tcx>> {
+/// If the type is function like, get the signature for it.
+pub fn ty_sig<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Option<ExprFnSig<'tcx>> {
     if ty.is_box() {
         return ty_sig(cx, ty.boxed_ty());
     }
diff --git a/tests/ui/explicit_auto_deref.fixed b/tests/ui/explicit_auto_deref.fixed
index 27bc7fbfae3..d1d35e5c0eb 100644
--- a/tests/ui/explicit_auto_deref.fixed
+++ b/tests/ui/explicit_auto_deref.fixed
@@ -257,13 +257,13 @@ fn main() {
     let x = S7([0]);
     let _: &[u32] = &*x;
 
-    let c1 = |x: &Vec<&u32>| {};
+    let c1 = |_: &Vec<&u32>| {};
     let x = &&vec![&1u32];
     c1(x);
     let _ = for<'a, 'b> |x: &'a &'a Vec<&'b u32>, b: bool| -> &'a Vec<&'b u32> {
         if b {
             return x;
         }
-        *x
+        x
     };
 }
diff --git a/tests/ui/explicit_auto_deref.rs b/tests/ui/explicit_auto_deref.rs
index 64aea9f464e..deedafad153 100644
--- a/tests/ui/explicit_auto_deref.rs
+++ b/tests/ui/explicit_auto_deref.rs
@@ -257,7 +257,7 @@ fn main() {
     let x = S7([0]);
     let _: &[u32] = &*x;
 
-    let c1 = |x: &Vec<&u32>| {};
+    let c1 = |_: &Vec<&u32>| {};
     let x = &&vec![&1u32];
     c1(*x);
     let _ = for<'a, 'b> |x: &'a &'a Vec<&'b u32>, b: bool| -> &'a Vec<&'b u32> {
diff --git a/tests/ui/explicit_auto_deref.stderr b/tests/ui/explicit_auto_deref.stderr
index 12db0c6f87f..91863abcc5d 100644
--- a/tests/ui/explicit_auto_deref.stderr
+++ b/tests/ui/explicit_auto_deref.stderr
@@ -228,5 +228,11 @@ error: deref which would be done by auto-deref
 LL |             return *x;
    |                    ^^ help: try this: `x`
 
-error: aborting due to 38 previous errors
+error: deref which would be done by auto-deref
+  --> $DIR/explicit_auto_deref.rs:267:9
+   |
+LL |         *x
+   |         ^^ help: try this: `x`
+
+error: aborting due to 39 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From f6cab94bd073c9b5103605c67006808d874ee5c1 Mon Sep 17 00:00:00 2001
From: Federico Guerinoni <guerinoni.federico@gmail.com>
Date: Mon, 8 Aug 2022 18:12:24 +0200
Subject: Rename `logic_bug` to `overly_complex_bool_expr`

Closes #1916
---
 CHANGELOG.md                                 |  1 +
 clippy_lints/src/booleans.rs                 |  6 +-
 clippy_lints/src/lib.register_all.rs         |  2 +-
 clippy_lints/src/lib.register_correctness.rs |  2 +-
 clippy_lints/src/lib.register_lints.rs       |  2 +-
 clippy_lints/src/renamed_lints.rs            |  3 +-
 tests/ui/diverging_sub_expression.rs         |  2 +-
 tests/ui/expect_tool_lint_rfc_2383.rs        |  4 +-
 tests/ui/expect_tool_lint_rfc_2383.stderr    |  4 +-
 tests/ui/logic_bug.rs                        | 34 ----------
 tests/ui/logic_bug.stderr                    | 63 -------------------
 tests/ui/overly_complex_bool_expr.rs         | 34 ++++++++++
 tests/ui/overly_complex_bool_expr.stderr     | 63 +++++++++++++++++++
 tests/ui/rename.fixed                        |  6 +-
 tests/ui/rename.rs                           |  6 +-
 tests/ui/rename.stderr                       | 94 +++++++++++++++-------------
 16 files changed, 169 insertions(+), 157 deletions(-)
 delete mode 100644 tests/ui/logic_bug.rs
 delete mode 100644 tests/ui/logic_bug.stderr
 create mode 100644 tests/ui/overly_complex_bool_expr.rs
 create mode 100644 tests/ui/overly_complex_bool_expr.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 84f06d98879..7ea7e76ee10 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3818,6 +3818,7 @@ Released 2018-09-13
 [`or_then_unwrap`]: https://rust-lang.github.io/rust-clippy/master/index.html#or_then_unwrap
 [`out_of_bounds_indexing`]: https://rust-lang.github.io/rust-clippy/master/index.html#out_of_bounds_indexing
 [`overflow_check_conditional`]: https://rust-lang.github.io/rust-clippy/master/index.html#overflow_check_conditional
+[`overly_complex_bool_expr`]: https://rust-lang.github.io/rust-clippy/master/index.html#overly_complex_bool_expr
 [`panic`]: https://rust-lang.github.io/rust-clippy/master/index.html#panic
 [`panic_in_result_fn`]: https://rust-lang.github.io/rust-clippy/master/index.html#panic_in_result_fn
 [`panic_params`]: https://rust-lang.github.io/rust-clippy/master/index.html#panic_params
diff --git a/clippy_lints/src/booleans.rs b/clippy_lints/src/booleans.rs
index 526ee2f891a..6eb78d21e82 100644
--- a/clippy_lints/src/booleans.rs
+++ b/clippy_lints/src/booleans.rs
@@ -64,7 +64,7 @@ declare_clippy_lint! {
     /// if a {}
     /// ```
     #[clippy::version = "pre 1.29.0"]
-    pub LOGIC_BUG,
+    pub OVERLY_COMPLEX_BOOL_EXPR,
     correctness,
     "boolean expressions that contain terminals which can be eliminated"
 }
@@ -72,7 +72,7 @@ declare_clippy_lint! {
 // For each pairs, both orders are considered.
 const METHODS_WITH_NEGATION: [(&str, &str); 2] = [("is_some", "is_none"), ("is_err", "is_ok")];
 
-declare_lint_pass!(NonminimalBool => [NONMINIMAL_BOOL, LOGIC_BUG]);
+declare_lint_pass!(NonminimalBool => [NONMINIMAL_BOOL, OVERLY_COMPLEX_BOOL_EXPR]);
 
 impl<'tcx> LateLintPass<'tcx> for NonminimalBool {
     fn check_fn(
@@ -396,7 +396,7 @@ impl<'a, 'tcx> NonminimalBoolVisitor<'a, 'tcx> {
                     if stats.terminals[i] != 0 && simplified_stats.terminals[i] == 0 {
                         span_lint_hir_and_then(
                             self.cx,
-                            LOGIC_BUG,
+                            OVERLY_COMPLEX_BOOL_EXPR,
                             e.hir_id,
                             e.span,
                             "this boolean expression contains a logic bug",
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index ab08e65d608..3caee50322c 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -17,8 +17,8 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(await_holding_invalid::AWAIT_HOLDING_REFCELL_REF),
     LintId::of(blocks_in_if_conditions::BLOCKS_IN_IF_CONDITIONS),
     LintId::of(bool_assert_comparison::BOOL_ASSERT_COMPARISON),
-    LintId::of(booleans::LOGIC_BUG),
     LintId::of(booleans::NONMINIMAL_BOOL),
+    LintId::of(booleans::OVERLY_COMPLEX_BOOL_EXPR),
     LintId::of(borrow_deref_ref::BORROW_DEREF_REF),
     LintId::of(bytes_count_to_len::BYTES_COUNT_TO_LEN),
     LintId::of(casts::CAST_ABS_TO_UNSIGNED),
diff --git a/clippy_lints/src/lib.register_correctness.rs b/clippy_lints/src/lib.register_correctness.rs
index 9975859c54f..006275d1383 100644
--- a/clippy_lints/src/lib.register_correctness.rs
+++ b/clippy_lints/src/lib.register_correctness.rs
@@ -8,7 +8,7 @@ store.register_group(true, "clippy::correctness", Some("clippy_correctness"), ve
     LintId::of(attrs::DEPRECATED_SEMVER),
     LintId::of(attrs::MISMATCHED_TARGET_OS),
     LintId::of(attrs::USELESS_ATTRIBUTE),
-    LintId::of(booleans::LOGIC_BUG),
+    LintId::of(booleans::OVERLY_COMPLEX_BOOL_EXPR),
     LintId::of(casts::CAST_REF_TO_MUT),
     LintId::of(casts::CAST_SLICE_DIFFERENT_SIZES),
     LintId::of(copies::IFS_SAME_COND),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index c2bc4badc43..d83508a2d6c 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -57,8 +57,8 @@ store.register_lints(&[
     await_holding_invalid::AWAIT_HOLDING_REFCELL_REF,
     blocks_in_if_conditions::BLOCKS_IN_IF_CONDITIONS,
     bool_assert_comparison::BOOL_ASSERT_COMPARISON,
-    booleans::LOGIC_BUG,
     booleans::NONMINIMAL_BOOL,
+    booleans::OVERLY_COMPLEX_BOOL_EXPR,
     borrow_as_ptr::BORROW_AS_PTR,
     borrow_deref_ref::BORROW_DEREF_REF,
     bytecount::NAIVE_BYTECOUNT,
diff --git a/clippy_lints/src/renamed_lints.rs b/clippy_lints/src/renamed_lints.rs
index be16bd64132..6bea6dc0773 100644
--- a/clippy_lints/src/renamed_lints.rs
+++ b/clippy_lints/src/renamed_lints.rs
@@ -2,10 +2,10 @@
 
 #[rustfmt::skip]
 pub static RENAMED_LINTS: &[(&str, &str)] = &[
+    ("clippy::blacklisted_name", "clippy::disallowed_names"),
     ("clippy::block_in_if_condition_expr", "clippy::blocks_in_if_conditions"),
     ("clippy::block_in_if_condition_stmt", "clippy::blocks_in_if_conditions"),
     ("clippy::box_vec", "clippy::box_collection"),
-    ("clippy::blacklisted_name", "clippy::disallowed_names"),
     ("clippy::const_static_lifetime", "clippy::redundant_static_lifetimes"),
     ("clippy::cyclomatic_complexity", "clippy::cognitive_complexity"),
     ("clippy::disallowed_method", "clippy::disallowed_methods"),
@@ -15,6 +15,7 @@ pub static RENAMED_LINTS: &[(&str, &str)] = &[
     ("clippy::for_loop_over_result", "clippy::for_loops_over_fallibles"),
     ("clippy::identity_conversion", "clippy::useless_conversion"),
     ("clippy::if_let_some_result", "clippy::match_result_ok"),
+    ("clippy::logic_bug", "clippy::overly_complex_bool_expr"),
     ("clippy::new_without_default_derive", "clippy::new_without_default"),
     ("clippy::option_and_then_some", "clippy::bind_instead_of_map"),
     ("clippy::option_expect_used", "clippy::expect_used"),
diff --git a/tests/ui/diverging_sub_expression.rs b/tests/ui/diverging_sub_expression.rs
index e27f9fea708..e8f992e6dde 100644
--- a/tests/ui/diverging_sub_expression.rs
+++ b/tests/ui/diverging_sub_expression.rs
@@ -1,5 +1,5 @@
 #![warn(clippy::diverging_sub_expression)]
-#![allow(clippy::match_same_arms, clippy::logic_bug)]
+#![allow(clippy::match_same_arms, clippy::overly_complex_bool_expr)]
 #[allow(clippy::empty_loop)]
 fn diverge() -> ! {
     loop {}
diff --git a/tests/ui/expect_tool_lint_rfc_2383.rs b/tests/ui/expect_tool_lint_rfc_2383.rs
index 985835ffa65..018f875d60b 100644
--- a/tests/ui/expect_tool_lint_rfc_2383.rs
+++ b/tests/ui/expect_tool_lint_rfc_2383.rs
@@ -98,7 +98,7 @@ mod clippy_ok {
         let _ = if true { 42 } else { 42 };
     }
 
-    #[expect(clippy::logic_bug)]
+    #[expect(clippy::overly_complex_bool_expr)]
     fn burger() {
         let a = false;
         let b = true;
@@ -127,7 +127,7 @@ mod clippy_warn {
         let _ = if true { 33 } else { 42 };
     }
 
-    #[expect(clippy::logic_bug)]
+    #[expect(clippy::overly_complex_bool_expr)]
     fn burger() {
         let a = false;
         let b = true;
diff --git a/tests/ui/expect_tool_lint_rfc_2383.stderr b/tests/ui/expect_tool_lint_rfc_2383.stderr
index db29e85a821..7ce9e855b5e 100644
--- a/tests/ui/expect_tool_lint_rfc_2383.stderr
+++ b/tests/ui/expect_tool_lint_rfc_2383.stderr
@@ -33,8 +33,8 @@ LL |     #[expect(clippy::if_same_then_else)]
 error: this lint expectation is unfulfilled
   --> $DIR/expect_tool_lint_rfc_2383.rs:130:14
    |
-LL |     #[expect(clippy::logic_bug)]
-   |              ^^^^^^^^^^^^^^^^^
+LL |     #[expect(clippy::overly_complex_bool_expr)]
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to 6 previous errors
 
diff --git a/tests/ui/logic_bug.rs b/tests/ui/logic_bug.rs
deleted file mode 100644
index dd6b1db5f70..00000000000
--- a/tests/ui/logic_bug.rs
+++ /dev/null
@@ -1,34 +0,0 @@
-#![feature(lint_reasons)]
-#![allow(unused, clippy::diverging_sub_expression)]
-#![warn(clippy::logic_bug)]
-
-fn main() {
-    let a: bool = unimplemented!();
-    let b: bool = unimplemented!();
-    let c: bool = unimplemented!();
-    let d: bool = unimplemented!();
-    let e: bool = unimplemented!();
-    let _ = a && b || a;
-    let _ = !(a && b);
-    let _ = false && a;
-    // don't lint on cfgs
-    let _ = cfg!(you_shall_not_not_pass) && a;
-    let _ = a || !b || !c || !d || !e;
-    let _ = !(a && b || c);
-}
-
-fn equality_stuff() {
-    let a: i32 = unimplemented!();
-    let b: i32 = unimplemented!();
-    let _ = a == b && a != b;
-    let _ = a < b && a >= b;
-    let _ = a > b && a <= b;
-    let _ = a > b && a == b;
-}
-
-fn check_expect() {
-    let a: i32 = unimplemented!();
-    let b: i32 = unimplemented!();
-    #[expect(clippy::logic_bug)]
-    let _ = a < b && a >= b;
-}
diff --git a/tests/ui/logic_bug.stderr b/tests/ui/logic_bug.stderr
deleted file mode 100644
index 4021fbf4570..00000000000
--- a/tests/ui/logic_bug.stderr
+++ /dev/null
@@ -1,63 +0,0 @@
-error: this boolean expression contains a logic bug
-  --> $DIR/logic_bug.rs:11:13
-   |
-LL |     let _ = a && b || a;
-   |             ^^^^^^^^^^^ help: it would look like the following: `a`
-   |
-   = note: `-D clippy::logic-bug` implied by `-D warnings`
-help: this expression can be optimized out by applying boolean operations to the outer expression
-  --> $DIR/logic_bug.rs:11:18
-   |
-LL |     let _ = a && b || a;
-   |                  ^
-
-error: this boolean expression contains a logic bug
-  --> $DIR/logic_bug.rs:13:13
-   |
-LL |     let _ = false && a;
-   |             ^^^^^^^^^^ help: it would look like the following: `false`
-   |
-help: this expression can be optimized out by applying boolean operations to the outer expression
-  --> $DIR/logic_bug.rs:13:22
-   |
-LL |     let _ = false && a;
-   |                      ^
-
-error: this boolean expression contains a logic bug
-  --> $DIR/logic_bug.rs:23:13
-   |
-LL |     let _ = a == b && a != b;
-   |             ^^^^^^^^^^^^^^^^ help: it would look like the following: `false`
-   |
-help: this expression can be optimized out by applying boolean operations to the outer expression
-  --> $DIR/logic_bug.rs:23:13
-   |
-LL |     let _ = a == b && a != b;
-   |             ^^^^^^
-
-error: this boolean expression contains a logic bug
-  --> $DIR/logic_bug.rs:24:13
-   |
-LL |     let _ = a < b && a >= b;
-   |             ^^^^^^^^^^^^^^^ help: it would look like the following: `false`
-   |
-help: this expression can be optimized out by applying boolean operations to the outer expression
-  --> $DIR/logic_bug.rs:24:13
-   |
-LL |     let _ = a < b && a >= b;
-   |             ^^^^^
-
-error: this boolean expression contains a logic bug
-  --> $DIR/logic_bug.rs:25:13
-   |
-LL |     let _ = a > b && a <= b;
-   |             ^^^^^^^^^^^^^^^ help: it would look like the following: `false`
-   |
-help: this expression can be optimized out by applying boolean operations to the outer expression
-  --> $DIR/logic_bug.rs:25:13
-   |
-LL |     let _ = a > b && a <= b;
-   |             ^^^^^
-
-error: aborting due to 5 previous errors
-
diff --git a/tests/ui/overly_complex_bool_expr.rs b/tests/ui/overly_complex_bool_expr.rs
new file mode 100644
index 00000000000..04a30a83250
--- /dev/null
+++ b/tests/ui/overly_complex_bool_expr.rs
@@ -0,0 +1,34 @@
+#![feature(lint_reasons)]
+#![allow(unused, clippy::diverging_sub_expression)]
+#![warn(clippy::overly_complex_bool_expr)]
+
+fn main() {
+    let a: bool = unimplemented!();
+    let b: bool = unimplemented!();
+    let c: bool = unimplemented!();
+    let d: bool = unimplemented!();
+    let e: bool = unimplemented!();
+    let _ = a && b || a;
+    let _ = !(a && b);
+    let _ = false && a;
+    // don't lint on cfgs
+    let _ = cfg!(you_shall_not_not_pass) && a;
+    let _ = a || !b || !c || !d || !e;
+    let _ = !(a && b || c);
+}
+
+fn equality_stuff() {
+    let a: i32 = unimplemented!();
+    let b: i32 = unimplemented!();
+    let _ = a == b && a != b;
+    let _ = a < b && a >= b;
+    let _ = a > b && a <= b;
+    let _ = a > b && a == b;
+}
+
+fn check_expect() {
+    let a: i32 = unimplemented!();
+    let b: i32 = unimplemented!();
+    #[expect(clippy::overly_complex_bool_expr)]
+    let _ = a < b && a >= b;
+}
diff --git a/tests/ui/overly_complex_bool_expr.stderr b/tests/ui/overly_complex_bool_expr.stderr
new file mode 100644
index 00000000000..158cae8b8f3
--- /dev/null
+++ b/tests/ui/overly_complex_bool_expr.stderr
@@ -0,0 +1,63 @@
+error: this boolean expression contains a logic bug
+  --> $DIR/overly_complex_bool_expr.rs:11:13
+   |
+LL |     let _ = a && b || a;
+   |             ^^^^^^^^^^^ help: it would look like the following: `a`
+   |
+   = note: `-D clippy::overly-complex-bool-expr` implied by `-D warnings`
+help: this expression can be optimized out by applying boolean operations to the outer expression
+  --> $DIR/overly_complex_bool_expr.rs:11:18
+   |
+LL |     let _ = a && b || a;
+   |                  ^
+
+error: this boolean expression contains a logic bug
+  --> $DIR/overly_complex_bool_expr.rs:13:13
+   |
+LL |     let _ = false && a;
+   |             ^^^^^^^^^^ help: it would look like the following: `false`
+   |
+help: this expression can be optimized out by applying boolean operations to the outer expression
+  --> $DIR/overly_complex_bool_expr.rs:13:22
+   |
+LL |     let _ = false && a;
+   |                      ^
+
+error: this boolean expression contains a logic bug
+  --> $DIR/overly_complex_bool_expr.rs:23:13
+   |
+LL |     let _ = a == b && a != b;
+   |             ^^^^^^^^^^^^^^^^ help: it would look like the following: `false`
+   |
+help: this expression can be optimized out by applying boolean operations to the outer expression
+  --> $DIR/overly_complex_bool_expr.rs:23:13
+   |
+LL |     let _ = a == b && a != b;
+   |             ^^^^^^
+
+error: this boolean expression contains a logic bug
+  --> $DIR/overly_complex_bool_expr.rs:24:13
+   |
+LL |     let _ = a < b && a >= b;
+   |             ^^^^^^^^^^^^^^^ help: it would look like the following: `false`
+   |
+help: this expression can be optimized out by applying boolean operations to the outer expression
+  --> $DIR/overly_complex_bool_expr.rs:24:13
+   |
+LL |     let _ = a < b && a >= b;
+   |             ^^^^^
+
+error: this boolean expression contains a logic bug
+  --> $DIR/overly_complex_bool_expr.rs:25:13
+   |
+LL |     let _ = a > b && a <= b;
+   |             ^^^^^^^^^^^^^^^ help: it would look like the following: `false`
+   |
+help: this expression can be optimized out by applying boolean operations to the outer expression
+  --> $DIR/overly_complex_bool_expr.rs:25:13
+   |
+LL |     let _ = a > b && a <= b;
+   |             ^^^^^
+
+error: aborting due to 5 previous errors
+
diff --git a/tests/ui/rename.fixed b/tests/ui/rename.fixed
index 2a74c6e54f4..9cbad2269a0 100644
--- a/tests/ui/rename.fixed
+++ b/tests/ui/rename.fixed
@@ -4,9 +4,9 @@
 
 // run-rustfix
 
+#![allow(clippy::disallowed_names)]
 #![allow(clippy::blocks_in_if_conditions)]
 #![allow(clippy::box_collection)]
-#![allow(clippy::disallowed_names)]
 #![allow(clippy::redundant_static_lifetimes)]
 #![allow(clippy::cognitive_complexity)]
 #![allow(clippy::disallowed_methods)]
@@ -15,6 +15,7 @@
 #![allow(clippy::for_loops_over_fallibles)]
 #![allow(clippy::useless_conversion)]
 #![allow(clippy::match_result_ok)]
+#![allow(clippy::overly_complex_bool_expr)]
 #![allow(clippy::new_without_default)]
 #![allow(clippy::bind_instead_of_map)]
 #![allow(clippy::expect_used)]
@@ -34,10 +35,10 @@
 #![allow(temporary_cstring_as_ptr)]
 #![allow(unknown_lints)]
 #![allow(unused_labels)]
+#![warn(clippy::disallowed_names)]
 #![warn(clippy::blocks_in_if_conditions)]
 #![warn(clippy::blocks_in_if_conditions)]
 #![warn(clippy::box_collection)]
-#![warn(clippy::disallowed_names)]
 #![warn(clippy::redundant_static_lifetimes)]
 #![warn(clippy::cognitive_complexity)]
 #![warn(clippy::disallowed_methods)]
@@ -47,6 +48,7 @@
 #![warn(clippy::for_loops_over_fallibles)]
 #![warn(clippy::useless_conversion)]
 #![warn(clippy::match_result_ok)]
+#![warn(clippy::overly_complex_bool_expr)]
 #![warn(clippy::new_without_default)]
 #![warn(clippy::bind_instead_of_map)]
 #![warn(clippy::expect_used)]
diff --git a/tests/ui/rename.rs b/tests/ui/rename.rs
index fa88af95974..9153c0dab02 100644
--- a/tests/ui/rename.rs
+++ b/tests/ui/rename.rs
@@ -4,9 +4,9 @@
 
 // run-rustfix
 
+#![allow(clippy::disallowed_names)]
 #![allow(clippy::blocks_in_if_conditions)]
 #![allow(clippy::box_collection)]
-#![allow(clippy::disallowed_names)]
 #![allow(clippy::redundant_static_lifetimes)]
 #![allow(clippy::cognitive_complexity)]
 #![allow(clippy::disallowed_methods)]
@@ -15,6 +15,7 @@
 #![allow(clippy::for_loops_over_fallibles)]
 #![allow(clippy::useless_conversion)]
 #![allow(clippy::match_result_ok)]
+#![allow(clippy::overly_complex_bool_expr)]
 #![allow(clippy::new_without_default)]
 #![allow(clippy::bind_instead_of_map)]
 #![allow(clippy::expect_used)]
@@ -34,10 +35,10 @@
 #![allow(temporary_cstring_as_ptr)]
 #![allow(unknown_lints)]
 #![allow(unused_labels)]
+#![warn(clippy::blacklisted_name)]
 #![warn(clippy::block_in_if_condition_expr)]
 #![warn(clippy::block_in_if_condition_stmt)]
 #![warn(clippy::box_vec)]
-#![warn(clippy::blacklisted_name)]
 #![warn(clippy::const_static_lifetime)]
 #![warn(clippy::cyclomatic_complexity)]
 #![warn(clippy::disallowed_method)]
@@ -47,6 +48,7 @@
 #![warn(clippy::for_loop_over_result)]
 #![warn(clippy::identity_conversion)]
 #![warn(clippy::if_let_some_result)]
+#![warn(clippy::logic_bug)]
 #![warn(clippy::new_without_default_derive)]
 #![warn(clippy::option_and_then_some)]
 #![warn(clippy::option_expect_used)]
diff --git a/tests/ui/rename.stderr b/tests/ui/rename.stderr
index d510951b121..9c03ea914bb 100644
--- a/tests/ui/rename.stderr
+++ b/tests/ui/rename.stderr
@@ -1,220 +1,226 @@
+error: lint `clippy::blacklisted_name` has been renamed to `clippy::disallowed_names`
+  --> $DIR/rename.rs:38:9
+   |
+LL | #![warn(clippy::blacklisted_name)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::disallowed_names`
+   |
+   = note: `-D renamed-and-removed-lints` implied by `-D warnings`
+
 error: lint `clippy::block_in_if_condition_expr` has been renamed to `clippy::blocks_in_if_conditions`
-  --> $DIR/rename.rs:37:9
+  --> $DIR/rename.rs:39:9
    |
 LL | #![warn(clippy::block_in_if_condition_expr)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::blocks_in_if_conditions`
-   |
-   = note: `-D renamed-and-removed-lints` implied by `-D warnings`
 
 error: lint `clippy::block_in_if_condition_stmt` has been renamed to `clippy::blocks_in_if_conditions`
-  --> $DIR/rename.rs:38:9
+  --> $DIR/rename.rs:40:9
    |
 LL | #![warn(clippy::block_in_if_condition_stmt)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::blocks_in_if_conditions`
 
 error: lint `clippy::box_vec` has been renamed to `clippy::box_collection`
-  --> $DIR/rename.rs:39:9
+  --> $DIR/rename.rs:41:9
    |
 LL | #![warn(clippy::box_vec)]
    |         ^^^^^^^^^^^^^^^ help: use the new name: `clippy::box_collection`
 
-error: lint `clippy::blacklisted_name` has been renamed to `clippy::disallowed_names`
-  --> $DIR/rename.rs:40:9
-   |
-LL | #![warn(clippy::blacklisted_name)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::disallowed_names`
-
 error: lint `clippy::const_static_lifetime` has been renamed to `clippy::redundant_static_lifetimes`
-  --> $DIR/rename.rs:41:9
+  --> $DIR/rename.rs:42:9
    |
 LL | #![warn(clippy::const_static_lifetime)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::redundant_static_lifetimes`
 
 error: lint `clippy::cyclomatic_complexity` has been renamed to `clippy::cognitive_complexity`
-  --> $DIR/rename.rs:42:9
+  --> $DIR/rename.rs:43:9
    |
 LL | #![warn(clippy::cyclomatic_complexity)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::cognitive_complexity`
 
 error: lint `clippy::disallowed_method` has been renamed to `clippy::disallowed_methods`
-  --> $DIR/rename.rs:43:9
+  --> $DIR/rename.rs:44:9
    |
 LL | #![warn(clippy::disallowed_method)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::disallowed_methods`
 
 error: lint `clippy::disallowed_type` has been renamed to `clippy::disallowed_types`
-  --> $DIR/rename.rs:44:9
+  --> $DIR/rename.rs:45:9
    |
 LL | #![warn(clippy::disallowed_type)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::disallowed_types`
 
 error: lint `clippy::eval_order_dependence` has been renamed to `clippy::mixed_read_write_in_expression`
-  --> $DIR/rename.rs:45:9
+  --> $DIR/rename.rs:46:9
    |
 LL | #![warn(clippy::eval_order_dependence)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::mixed_read_write_in_expression`
 
 error: lint `clippy::for_loop_over_option` has been renamed to `clippy::for_loops_over_fallibles`
-  --> $DIR/rename.rs:46:9
+  --> $DIR/rename.rs:47:9
    |
 LL | #![warn(clippy::for_loop_over_option)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::for_loops_over_fallibles`
 
 error: lint `clippy::for_loop_over_result` has been renamed to `clippy::for_loops_over_fallibles`
-  --> $DIR/rename.rs:47:9
+  --> $DIR/rename.rs:48:9
    |
 LL | #![warn(clippy::for_loop_over_result)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::for_loops_over_fallibles`
 
 error: lint `clippy::identity_conversion` has been renamed to `clippy::useless_conversion`
-  --> $DIR/rename.rs:48:9
+  --> $DIR/rename.rs:49:9
    |
 LL | #![warn(clippy::identity_conversion)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::useless_conversion`
 
 error: lint `clippy::if_let_some_result` has been renamed to `clippy::match_result_ok`
-  --> $DIR/rename.rs:49:9
+  --> $DIR/rename.rs:50:9
    |
 LL | #![warn(clippy::if_let_some_result)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::match_result_ok`
 
+error: lint `clippy::logic_bug` has been renamed to `clippy::overly_complex_bool_expr`
+  --> $DIR/rename.rs:51:9
+   |
+LL | #![warn(clippy::logic_bug)]
+   |         ^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::overly_complex_bool_expr`
+
 error: lint `clippy::new_without_default_derive` has been renamed to `clippy::new_without_default`
-  --> $DIR/rename.rs:50:9
+  --> $DIR/rename.rs:52:9
    |
 LL | #![warn(clippy::new_without_default_derive)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::new_without_default`
 
 error: lint `clippy::option_and_then_some` has been renamed to `clippy::bind_instead_of_map`
-  --> $DIR/rename.rs:51:9
+  --> $DIR/rename.rs:53:9
    |
 LL | #![warn(clippy::option_and_then_some)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::bind_instead_of_map`
 
 error: lint `clippy::option_expect_used` has been renamed to `clippy::expect_used`
-  --> $DIR/rename.rs:52:9
+  --> $DIR/rename.rs:54:9
    |
 LL | #![warn(clippy::option_expect_used)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::expect_used`
 
 error: lint `clippy::option_map_unwrap_or` has been renamed to `clippy::map_unwrap_or`
-  --> $DIR/rename.rs:53:9
+  --> $DIR/rename.rs:55:9
    |
 LL | #![warn(clippy::option_map_unwrap_or)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::map_unwrap_or`
 
 error: lint `clippy::option_map_unwrap_or_else` has been renamed to `clippy::map_unwrap_or`
-  --> $DIR/rename.rs:54:9
+  --> $DIR/rename.rs:56:9
    |
 LL | #![warn(clippy::option_map_unwrap_or_else)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::map_unwrap_or`
 
 error: lint `clippy::option_unwrap_used` has been renamed to `clippy::unwrap_used`
-  --> $DIR/rename.rs:55:9
+  --> $DIR/rename.rs:57:9
    |
 LL | #![warn(clippy::option_unwrap_used)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::unwrap_used`
 
 error: lint `clippy::ref_in_deref` has been renamed to `clippy::needless_borrow`
-  --> $DIR/rename.rs:56:9
+  --> $DIR/rename.rs:58:9
    |
 LL | #![warn(clippy::ref_in_deref)]
    |         ^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::needless_borrow`
 
 error: lint `clippy::result_expect_used` has been renamed to `clippy::expect_used`
-  --> $DIR/rename.rs:57:9
+  --> $DIR/rename.rs:59:9
    |
 LL | #![warn(clippy::result_expect_used)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::expect_used`
 
 error: lint `clippy::result_map_unwrap_or_else` has been renamed to `clippy::map_unwrap_or`
-  --> $DIR/rename.rs:58:9
+  --> $DIR/rename.rs:60:9
    |
 LL | #![warn(clippy::result_map_unwrap_or_else)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::map_unwrap_or`
 
 error: lint `clippy::result_unwrap_used` has been renamed to `clippy::unwrap_used`
-  --> $DIR/rename.rs:59:9
+  --> $DIR/rename.rs:61:9
    |
 LL | #![warn(clippy::result_unwrap_used)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::unwrap_used`
 
 error: lint `clippy::single_char_push_str` has been renamed to `clippy::single_char_add_str`
-  --> $DIR/rename.rs:60:9
+  --> $DIR/rename.rs:62:9
    |
 LL | #![warn(clippy::single_char_push_str)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::single_char_add_str`
 
 error: lint `clippy::stutter` has been renamed to `clippy::module_name_repetitions`
-  --> $DIR/rename.rs:61:9
+  --> $DIR/rename.rs:63:9
    |
 LL | #![warn(clippy::stutter)]
    |         ^^^^^^^^^^^^^^^ help: use the new name: `clippy::module_name_repetitions`
 
 error: lint `clippy::to_string_in_display` has been renamed to `clippy::recursive_format_impl`
-  --> $DIR/rename.rs:62:9
+  --> $DIR/rename.rs:64:9
    |
 LL | #![warn(clippy::to_string_in_display)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::recursive_format_impl`
 
 error: lint `clippy::zero_width_space` has been renamed to `clippy::invisible_characters`
-  --> $DIR/rename.rs:63:9
+  --> $DIR/rename.rs:65:9
    |
 LL | #![warn(clippy::zero_width_space)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::invisible_characters`
 
 error: lint `clippy::drop_bounds` has been renamed to `drop_bounds`
-  --> $DIR/rename.rs:64:9
+  --> $DIR/rename.rs:66:9
    |
 LL | #![warn(clippy::drop_bounds)]
    |         ^^^^^^^^^^^^^^^^^^^ help: use the new name: `drop_bounds`
 
 error: lint `clippy::into_iter_on_array` has been renamed to `array_into_iter`
-  --> $DIR/rename.rs:65:9
+  --> $DIR/rename.rs:67:9
    |
 LL | #![warn(clippy::into_iter_on_array)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `array_into_iter`
 
 error: lint `clippy::invalid_atomic_ordering` has been renamed to `invalid_atomic_ordering`
-  --> $DIR/rename.rs:66:9
+  --> $DIR/rename.rs:68:9
    |
 LL | #![warn(clippy::invalid_atomic_ordering)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `invalid_atomic_ordering`
 
 error: lint `clippy::invalid_ref` has been renamed to `invalid_value`
-  --> $DIR/rename.rs:67:9
+  --> $DIR/rename.rs:69:9
    |
 LL | #![warn(clippy::invalid_ref)]
    |         ^^^^^^^^^^^^^^^^^^^ help: use the new name: `invalid_value`
 
 error: lint `clippy::mem_discriminant_non_enum` has been renamed to `enum_intrinsics_non_enums`
-  --> $DIR/rename.rs:68:9
+  --> $DIR/rename.rs:70:9
    |
 LL | #![warn(clippy::mem_discriminant_non_enum)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `enum_intrinsics_non_enums`
 
 error: lint `clippy::panic_params` has been renamed to `non_fmt_panics`
-  --> $DIR/rename.rs:69:9
+  --> $DIR/rename.rs:71:9
    |
 LL | #![warn(clippy::panic_params)]
    |         ^^^^^^^^^^^^^^^^^^^^ help: use the new name: `non_fmt_panics`
 
 error: lint `clippy::temporary_cstring_as_ptr` has been renamed to `temporary_cstring_as_ptr`
-  --> $DIR/rename.rs:70:9
+  --> $DIR/rename.rs:72:9
    |
 LL | #![warn(clippy::temporary_cstring_as_ptr)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `temporary_cstring_as_ptr`
 
 error: lint `clippy::unknown_clippy_lints` has been renamed to `unknown_lints`
-  --> $DIR/rename.rs:71:9
+  --> $DIR/rename.rs:73:9
    |
 LL | #![warn(clippy::unknown_clippy_lints)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `unknown_lints`
 
 error: lint `clippy::unused_label` has been renamed to `unused_labels`
-  --> $DIR/rename.rs:72:9
+  --> $DIR/rename.rs:74:9
    |
 LL | #![warn(clippy::unused_label)]
    |         ^^^^^^^^^^^^^^^^^^^^ help: use the new name: `unused_labels`
 
-error: aborting due to 36 previous errors
+error: aborting due to 37 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 657b0da912f0281aa11fe61df7fa273bf9be1d5b Mon Sep 17 00:00:00 2001
From: Lukas Lueg <lukas.lueg@gmail.com>
Date: Wed, 3 Aug 2022 22:13:06 +0200
Subject: Add partialeq_to_none lint

Fixes #9275
---
 CHANGELOG.md                                   |   1 +
 clippy_lints/src/lib.register_all.rs           |   1 +
 clippy_lints/src/lib.register_lints.rs         |   1 +
 clippy_lints/src/lib.register_style.rs         |   1 +
 clippy_lints/src/lib.rs                        |   2 +
 clippy_lints/src/partialeq_to_none.rs          | 104 +++++++++++++++++++++++
 tests/ui/ifs_same_cond.rs                      |   4 +-
 tests/ui/manual_assert.edition2018.fixed       |   2 +-
 tests/ui/manual_assert.edition2021.fixed       |   2 +-
 tests/ui/manual_assert.fixed                   |   2 +-
 tests/ui/manual_assert.rs                      |   2 +-
 tests/ui/partialeq_to_none.fixed               |  62 ++++++++++++++
 tests/ui/partialeq_to_none.rs                  |  62 ++++++++++++++
 tests/ui/partialeq_to_none.stderr              | 110 +++++++++++++++++++++++++
 tests/ui/same_functions_in_if_condition.rs     |   4 +-
 tests/ui/same_functions_in_if_condition.stderr |   8 +-
 16 files changed, 356 insertions(+), 12 deletions(-)
 create mode 100644 clippy_lints/src/partialeq_to_none.rs
 create mode 100644 tests/ui/partialeq_to_none.fixed
 create mode 100644 tests/ui/partialeq_to_none.rs
 create mode 100644 tests/ui/partialeq_to_none.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 84f06d98879..ecac6086ffc 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3823,6 +3823,7 @@ Released 2018-09-13
 [`panic_params`]: https://rust-lang.github.io/rust-clippy/master/index.html#panic_params
 [`panicking_unwrap`]: https://rust-lang.github.io/rust-clippy/master/index.html#panicking_unwrap
 [`partialeq_ne_impl`]: https://rust-lang.github.io/rust-clippy/master/index.html#partialeq_ne_impl
+[`partialeq_to_none`]: https://rust-lang.github.io/rust-clippy/master/index.html#partialeq_to_none
 [`path_buf_push_overwrite`]: https://rust-lang.github.io/rust-clippy/master/index.html#path_buf_push_overwrite
 [`pattern_type_mismatch`]: https://rust-lang.github.io/rust-clippy/master/index.html#pattern_type_mismatch
 [`possible_missing_comma`]: https://rust-lang.github.io/rust-clippy/master/index.html#possible_missing_comma
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index b9cc9fc1e85..5b10061052d 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -267,6 +267,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(option_env_unwrap::OPTION_ENV_UNWRAP),
     LintId::of(overflow_check_conditional::OVERFLOW_CHECK_CONDITIONAL),
     LintId::of(partialeq_ne_impl::PARTIALEQ_NE_IMPL),
+    LintId::of(partialeq_to_none::PARTIALEQ_TO_NONE),
     LintId::of(precedence::PRECEDENCE),
     LintId::of(ptr::CMP_NULL),
     LintId::of(ptr::INVALID_NULL_PTR_USAGE),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index c2bc4badc43..7468fc8b47b 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -454,6 +454,7 @@ store.register_lints(&[
     panic_unimplemented::UNIMPLEMENTED,
     panic_unimplemented::UNREACHABLE,
     partialeq_ne_impl::PARTIALEQ_NE_IMPL,
+    partialeq_to_none::PARTIALEQ_TO_NONE,
     pass_by_ref_or_value::LARGE_TYPES_PASSED_BY_VALUE,
     pass_by_ref_or_value::TRIVIALLY_COPY_PASS_BY_REF,
     path_buf_push_overwrite::PATH_BUF_PUSH_OVERWRITE,
diff --git a/clippy_lints/src/lib.register_style.rs b/clippy_lints/src/lib.register_style.rs
index ebc0933e31d..bfa654238f1 100644
--- a/clippy_lints/src/lib.register_style.rs
+++ b/clippy_lints/src/lib.register_style.rs
@@ -100,6 +100,7 @@ store.register_group(true, "clippy::style", Some("clippy_style"), vec![
     LintId::of(operators::ASSIGN_OP_PATTERN),
     LintId::of(operators::OP_REF),
     LintId::of(operators::PTR_EQ),
+    LintId::of(partialeq_to_none::PARTIALEQ_TO_NONE),
     LintId::of(ptr::CMP_NULL),
     LintId::of(ptr::PTR_ARG),
     LintId::of(question_mark::QUESTION_MARK),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 88c1a727f8d..e6a405f8170 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -332,6 +332,7 @@ mod overflow_check_conditional;
 mod panic_in_result_fn;
 mod panic_unimplemented;
 mod partialeq_ne_impl;
+mod partialeq_to_none;
 mod pass_by_ref_or_value;
 mod path_buf_push_overwrite;
 mod pattern_type_mismatch;
@@ -931,6 +932,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(invalid_utf8_in_unchecked::InvalidUtf8InUnchecked));
     store.register_late_pass(|| Box::new(std_instead_of_core::StdReexports::default()));
     store.register_late_pass(|| Box::new(manual_instant_elapsed::ManualInstantElapsed));
+    store.register_late_pass(|| Box::new(partialeq_to_none::PartialeqToNone));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/partialeq_to_none.rs b/clippy_lints/src/partialeq_to_none.rs
new file mode 100644
index 00000000000..eee7642068d
--- /dev/null
+++ b/clippy_lints/src/partialeq_to_none.rs
@@ -0,0 +1,104 @@
+use clippy_utils::{
+    diagnostics::span_lint_and_sugg, is_lang_ctor, peel_hir_expr_refs, peel_ref_operators, sugg,
+    ty::is_type_diagnostic_item,
+};
+use rustc_errors::Applicability;
+use rustc_hir::{BinOpKind, Expr, ExprKind, LangItem};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::sym;
+
+declare_clippy_lint! {
+    /// ### What it does
+    ///
+    /// Checks for binary comparisons to a literal `Option::None`.
+    ///
+    /// ### Why is this bad?
+    ///
+    /// A programmer checking if some `foo` is `None` via a comparison `foo == None`
+    /// is usually inspired from other programming languages (e.g. `foo is None`
+    /// in Python).
+    /// Checking if a value of type `Option<T>` is (not) equal to `None` in that
+    /// way relies on `T: PartialEq` to do the comparison, which is unneeded.
+    ///
+    /// ### Example
+    /// ```rust
+    /// fn foo(f: Option<u32>) -> &'static str {
+    ///     if f != None { "yay" } else { "nay" }
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// fn foo(f: Option<u32>) -> &'static str {
+    ///     if f.is_some() { "yay" } else { "nay" }
+    /// }
+    /// ```
+    #[clippy::version = "1.64.0"]
+    pub PARTIALEQ_TO_NONE,
+    style,
+    "Binary comparison to `Option<T>::None` relies on `T: PartialEq`, which is unneeded"
+}
+declare_lint_pass!(PartialeqToNone => [PARTIALEQ_TO_NONE]);
+
+impl<'tcx> LateLintPass<'tcx> for PartialeqToNone {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
+        // Skip expanded code, as we have no control over it anyway...
+        if e.span.from_expansion() {
+            return;
+        }
+
+        // If the expression is of type `Option`
+        let is_ty_option =
+            |expr: &Expr<'_>| is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(expr).peel_refs(), sym::Option);
+
+        // If the expression is a literal `Option::None`
+        let is_none_ctor = |expr: &Expr<'_>| {
+            matches!(&peel_hir_expr_refs(expr).0.kind,
+            ExprKind::Path(p) if is_lang_ctor(cx, p, LangItem::OptionNone))
+        };
+
+        let mut applicability = Applicability::MachineApplicable;
+
+        if let ExprKind::Binary(op, left_side, right_side) = e.kind {
+            // All other comparisons (e.g. `>= None`) have special meaning wrt T
+            let is_eq = match op.node {
+                BinOpKind::Eq => true,
+                BinOpKind::Ne => false,
+                _ => return,
+            };
+
+            // We are only interested in comparisons between `Option` and a literal `Option::None`
+            let scrutinee = match (
+                is_none_ctor(left_side) && is_ty_option(right_side),
+                is_none_ctor(right_side) && is_ty_option(left_side),
+            ) {
+                (true, false) => right_side,
+                (false, true) => left_side,
+                _ => return,
+            };
+
+            // Peel away refs/derefs (as long as we don't cross manual deref impls), as
+            // autoref/autoderef will take care of those
+            let sugg = format!(
+                "{}.{}",
+                sugg::Sugg::hir_with_applicability(cx, peel_ref_operators(cx, scrutinee), "..", &mut applicability)
+                    .maybe_par(),
+                if is_eq { "is_none()" } else { "is_some()" }
+            );
+
+            span_lint_and_sugg(
+                cx,
+                PARTIALEQ_TO_NONE,
+                e.span,
+                "binary comparison to literal `Option::None`",
+                if is_eq {
+                    "use `Option::is_none()` instead"
+                } else {
+                    "use `Option::is_some()` instead"
+                },
+                sugg,
+                applicability,
+            );
+        }
+    }
+}
diff --git a/tests/ui/ifs_same_cond.rs b/tests/ui/ifs_same_cond.rs
index 80e9839ff40..9850fc0919e 100644
--- a/tests/ui/ifs_same_cond.rs
+++ b/tests/ui/ifs_same_cond.rs
@@ -32,9 +32,9 @@ fn ifs_same_cond() {
     };
 
     let mut v = vec![1];
-    if v.pop() == None {
+    if v.pop().is_none() {
         // ok, functions
-    } else if v.pop() == None {
+    } else if v.pop().is_none() {
     }
 
     if v.len() == 42 {
diff --git a/tests/ui/manual_assert.edition2018.fixed b/tests/ui/manual_assert.edition2018.fixed
index d0bc640db88..65598f1eacc 100644
--- a/tests/ui/manual_assert.edition2018.fixed
+++ b/tests/ui/manual_assert.edition2018.fixed
@@ -17,7 +17,7 @@ fn main() {
     let c = Some(2);
     if !a.is_empty()
         && a.len() == 3
-        && c != None
+        && c.is_some()
         && !a.is_empty()
         && a.len() == 3
         && !a.is_empty()
diff --git a/tests/ui/manual_assert.edition2021.fixed b/tests/ui/manual_assert.edition2021.fixed
index d0bc640db88..65598f1eacc 100644
--- a/tests/ui/manual_assert.edition2021.fixed
+++ b/tests/ui/manual_assert.edition2021.fixed
@@ -17,7 +17,7 @@ fn main() {
     let c = Some(2);
     if !a.is_empty()
         && a.len() == 3
-        && c != None
+        && c.is_some()
         && !a.is_empty()
         && a.len() == 3
         && !a.is_empty()
diff --git a/tests/ui/manual_assert.fixed b/tests/ui/manual_assert.fixed
index 6c2a25c37d8..a2393674fe6 100644
--- a/tests/ui/manual_assert.fixed
+++ b/tests/ui/manual_assert.fixed
@@ -11,7 +11,7 @@ fn main() {
     let c = Some(2);
     if !a.is_empty()
         && a.len() == 3
-        && c != None
+        && c.is_some()
         && !a.is_empty()
         && a.len() == 3
         && !a.is_empty()
diff --git a/tests/ui/manual_assert.rs b/tests/ui/manual_assert.rs
index 027747d8386..4d2706dd621 100644
--- a/tests/ui/manual_assert.rs
+++ b/tests/ui/manual_assert.rs
@@ -17,7 +17,7 @@ fn main() {
     let c = Some(2);
     if !a.is_empty()
         && a.len() == 3
-        && c != None
+        && c.is_some()
         && !a.is_empty()
         && a.len() == 3
         && !a.is_empty()
diff --git a/tests/ui/partialeq_to_none.fixed b/tests/ui/partialeq_to_none.fixed
new file mode 100644
index 00000000000..f3e4c58d694
--- /dev/null
+++ b/tests/ui/partialeq_to_none.fixed
@@ -0,0 +1,62 @@
+// run-rustfix
+#![warn(clippy::partialeq_to_none)]
+
+struct Foobar;
+
+impl PartialEq<Option<()>> for Foobar {
+    fn eq(&self, _: &Option<()>) -> bool {
+        false
+    }
+}
+
+#[allow(dead_code)]
+fn foo(f: Option<u32>) -> &'static str {
+    if f.is_some() { "yay" } else { "nay" }
+}
+
+fn foobar() -> Option<()> {
+    None
+}
+
+fn bar() -> Result<(), ()> {
+    Ok(())
+}
+
+fn optref() -> &'static &'static Option<()> {
+    &&None
+}
+
+fn main() {
+    let x = Some(0);
+
+    let _ = x.is_none();
+    let _ = x.is_some();
+    let _ = x.is_none();
+    let _ = x.is_some();
+
+    if foobar().is_none() {}
+
+    if bar().ok().is_some() {}
+
+    let _ = Some(1 + 2).is_some();
+
+    let _ = { Some(0) }.is_none();
+
+    let _ = {
+        /*
+          This comment runs long
+        */
+        Some(1)
+    }.is_some();
+
+    // Should not trigger, as `Foobar` is not an `Option` and has no `is_none`
+    let _ = Foobar == None;
+
+    let _ = optref().is_none();
+    let _ = optref().is_some();
+    let _ = optref().is_none();
+    let _ = optref().is_some();
+
+    let x = Box::new(Option::<()>::None);
+    let _ = (*x).is_some();
+}
diff --git a/tests/ui/partialeq_to_none.rs b/tests/ui/partialeq_to_none.rs
new file mode 100644
index 00000000000..767b2a38bcc
--- /dev/null
+++ b/tests/ui/partialeq_to_none.rs
@@ -0,0 +1,62 @@
+// run-rustfix
+#![warn(clippy::partialeq_to_none)]
+
+struct Foobar;
+
+impl PartialEq<Option<()>> for Foobar {
+    fn eq(&self, _: &Option<()>) -> bool {
+        false
+    }
+}
+
+#[allow(dead_code)]
+fn foo(f: Option<u32>) -> &'static str {
+    if f != None { "yay" } else { "nay" }
+}
+
+fn foobar() -> Option<()> {
+    None
+}
+
+fn bar() -> Result<(), ()> {
+    Ok(())
+}
+
+fn optref() -> &'static &'static Option<()> {
+    &&None
+}
+
+fn main() {
+    let x = Some(0);
+
+    let _ = x == None;
+    let _ = x != None;
+    let _ = None == x;
+    let _ = None != x;
+
+    if foobar() == None {}
+
+    if bar().ok() != None {}
+
+    let _ = Some(1 + 2) != None;
+
+    let _ = { Some(0) } == None;
+
+    let _ = {
+        /*
+          This comment runs long
+        */
+        Some(1)
+    } != None;
+
+    // Should not trigger, as `Foobar` is not an `Option` and has no `is_none`
+    let _ = Foobar == None;
+
+    let _ = optref() == &&None;
+    let _ = &&None != optref();
+    let _ = **optref() == None;
+    let _ = &None != *optref();
+
+    let x = Box::new(Option::<()>::None);
+    let _ = None != *x;
+}
diff --git a/tests/ui/partialeq_to_none.stderr b/tests/ui/partialeq_to_none.stderr
new file mode 100644
index 00000000000..de15a9f7baa
--- /dev/null
+++ b/tests/ui/partialeq_to_none.stderr
@@ -0,0 +1,110 @@
+error: binary comparison to literal `Option::None`
+  --> $DIR/partialeq_to_none.rs:14:8
+   |
+LL |     if f != None { "yay" } else { "nay" }
+   |        ^^^^^^^^^ help: use `Option::is_some()` instead: `f.is_some()`
+   |
+   = note: `-D clippy::partialeq-to-none` implied by `-D warnings`
+
+error: binary comparison to literal `Option::None`
+  --> $DIR/partialeq_to_none.rs:32:13
+   |
+LL |     let _ = x == None;
+   |             ^^^^^^^^^ help: use `Option::is_none()` instead: `x.is_none()`
+
+error: binary comparison to literal `Option::None`
+  --> $DIR/partialeq_to_none.rs:33:13
+   |
+LL |     let _ = x != None;
+   |             ^^^^^^^^^ help: use `Option::is_some()` instead: `x.is_some()`
+
+error: binary comparison to literal `Option::None`
+  --> $DIR/partialeq_to_none.rs:34:13
+   |
+LL |     let _ = None == x;
+   |             ^^^^^^^^^ help: use `Option::is_none()` instead: `x.is_none()`
+
+error: binary comparison to literal `Option::None`
+  --> $DIR/partialeq_to_none.rs:35:13
+   |
+LL |     let _ = None != x;
+   |             ^^^^^^^^^ help: use `Option::is_some()` instead: `x.is_some()`
+
+error: binary comparison to literal `Option::None`
+  --> $DIR/partialeq_to_none.rs:37:8
+   |
+LL |     if foobar() == None {}
+   |        ^^^^^^^^^^^^^^^^ help: use `Option::is_none()` instead: `foobar().is_none()`
+
+error: binary comparison to literal `Option::None`
+  --> $DIR/partialeq_to_none.rs:39:8
+   |
+LL |     if bar().ok() != None {}
+   |        ^^^^^^^^^^^^^^^^^^ help: use `Option::is_some()` instead: `bar().ok().is_some()`
+
+error: binary comparison to literal `Option::None`
+  --> $DIR/partialeq_to_none.rs:41:13
+   |
+LL |     let _ = Some(1 + 2) != None;
+   |             ^^^^^^^^^^^^^^^^^^^ help: use `Option::is_some()` instead: `Some(1 + 2).is_some()`
+
+error: binary comparison to literal `Option::None`
+  --> $DIR/partialeq_to_none.rs:43:13
+   |
+LL |     let _ = { Some(0) } == None;
+   |             ^^^^^^^^^^^^^^^^^^^ help: use `Option::is_none()` instead: `{ Some(0) }.is_none()`
+
+error: binary comparison to literal `Option::None`
+  --> $DIR/partialeq_to_none.rs:45:13
+   |
+LL |       let _ = {
+   |  _____________^
+LL | |         /*
+LL | |           This comment runs long
+LL | |         */
+LL | |         Some(1)
+LL | |     } != None;
+   | |_____________^
+   |
+help: use `Option::is_some()` instead
+   |
+LL ~     let _ = {
+LL +         /*
+LL +           This comment runs long
+LL +         */
+LL +         Some(1)
+LL ~     }.is_some();
+   |
+
+error: binary comparison to literal `Option::None`
+  --> $DIR/partialeq_to_none.rs:55:13
+   |
+LL |     let _ = optref() == &&None;
+   |             ^^^^^^^^^^^^^^^^^^ help: use `Option::is_none()` instead: `optref().is_none()`
+
+error: binary comparison to literal `Option::None`
+  --> $DIR/partialeq_to_none.rs:56:13
+   |
+LL |     let _ = &&None != optref();
+   |             ^^^^^^^^^^^^^^^^^^ help: use `Option::is_some()` instead: `optref().is_some()`
+
+error: binary comparison to literal `Option::None`
+  --> $DIR/partialeq_to_none.rs:57:13
+   |
+LL |     let _ = **optref() == None;
+   |             ^^^^^^^^^^^^^^^^^^ help: use `Option::is_none()` instead: `optref().is_none()`
+
+error: binary comparison to literal `Option::None`
+  --> $DIR/partialeq_to_none.rs:58:13
+   |
+LL |     let _ = &None != *optref();
+   |             ^^^^^^^^^^^^^^^^^^ help: use `Option::is_some()` instead: `optref().is_some()`
+
+error: binary comparison to literal `Option::None`
+  --> $DIR/partialeq_to_none.rs:61:13
+   |
+LL |     let _ = None != *x;
+   |             ^^^^^^^^^^ help: use `Option::is_some()` instead: `(*x).is_some()`
+
+error: aborting due to 15 previous errors
+
diff --git a/tests/ui/same_functions_in_if_condition.rs b/tests/ui/same_functions_in_if_condition.rs
index 3d2295912c9..a48829caac0 100644
--- a/tests/ui/same_functions_in_if_condition.rs
+++ b/tests/ui/same_functions_in_if_condition.rs
@@ -48,9 +48,9 @@ fn ifs_same_cond_fn() {
     }
 
     let mut v = vec![1];
-    if v.pop() == None {
+    if v.pop().is_none() {
         //~ ERROR ifs same condition
-    } else if v.pop() == None {
+    } else if v.pop().is_none() {
     }
 
     if v.len() == 42 {
diff --git a/tests/ui/same_functions_in_if_condition.stderr b/tests/ui/same_functions_in_if_condition.stderr
index 71e82910ef7..cd438b83040 100644
--- a/tests/ui/same_functions_in_if_condition.stderr
+++ b/tests/ui/same_functions_in_if_condition.stderr
@@ -50,14 +50,14 @@ LL |     if obj.method_arg(a) {
 error: this `if` has the same function call as a previous `if`
   --> $DIR/same_functions_in_if_condition.rs:53:15
    |
-LL |     } else if v.pop() == None {
-   |               ^^^^^^^^^^^^^^^
+LL |     } else if v.pop().is_none() {
+   |               ^^^^^^^^^^^^^^^^^
    |
 note: same as this
   --> $DIR/same_functions_in_if_condition.rs:51:8
    |
-LL |     if v.pop() == None {
-   |        ^^^^^^^^^^^^^^^
+LL |     if v.pop().is_none() {
+   |        ^^^^^^^^^^^^^^^^^
 
 error: this `if` has the same function call as a previous `if`
   --> $DIR/same_functions_in_if_condition.rs:58:15
-- 
cgit 1.4.1-3-g733a5


From 73cd95465e85f878fc5c30a79ce76a9fb59d690c Mon Sep 17 00:00:00 2001
From: Sosthène Guédon <sosthene@guedon.gdn>
Date: Sat, 16 Jul 2022 10:22:43 +0200
Subject: Add iter_once and iter_empty lints

---
 CHANGELOG.md                              |   2 +
 clippy_lints/src/iter_once_empty.rs       | 164 ++++++++++++++++++++++++++++++
 clippy_lints/src/lib.register_lints.rs    |   2 +
 clippy_lints/src/lib.register_nursery.rs  |   2 +
 clippy_lints/src/lib.register_pedantic.rs |   2 +
 clippy_lints/src/lib.rs                   |   2 +
 clippy_utils/src/lib.rs                   |   1 +
 tests/ui/iter_empty.fixed                 |  32 ++++++
 tests/ui/iter_empty.rs                    |  32 ++++++
 tests/ui/iter_empty.stderr                |  40 ++++++++
 tests/ui/iter_once.fixed                  |  32 ++++++
 tests/ui/iter_once.rs                     |  32 ++++++
 tests/ui/iter_once.stderr                 |  40 ++++++++
 13 files changed, 383 insertions(+)
 create mode 100644 clippy_lints/src/iter_once_empty.rs
 create mode 100644 tests/ui/iter_empty.fixed
 create mode 100644 tests/ui/iter_empty.rs
 create mode 100644 tests/ui/iter_empty.stderr
 create mode 100644 tests/ui/iter_once.fixed
 create mode 100644 tests/ui/iter_once.rs
 create mode 100644 tests/ui/iter_once.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 7ea7e76ee10..94f71eba0a2 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3651,11 +3651,13 @@ Released 2018-09-13
 [`items_after_statements`]: https://rust-lang.github.io/rust-clippy/master/index.html#items_after_statements
 [`iter_cloned_collect`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_cloned_collect
 [`iter_count`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_count
+[`iter_empty`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_empty
 [`iter_next_loop`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_next_loop
 [`iter_next_slice`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_next_slice
 [`iter_not_returning_iterator`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_not_returning_iterator
 [`iter_nth`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_nth
 [`iter_nth_zero`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_nth_zero
+[`iter_once`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_once
 [`iter_overeager_cloned`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_overeager_cloned
 [`iter_skip_next`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_skip_next
 [`iter_with_drain`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_with_drain
diff --git a/clippy_lints/src/iter_once_empty.rs b/clippy_lints/src/iter_once_empty.rs
new file mode 100644
index 00000000000..09896001112
--- /dev/null
+++ b/clippy_lints/src/iter_once_empty.rs
@@ -0,0 +1,164 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet;
+use rustc_ast::ast::{Expr, ExprKind};
+use rustc_errors::Applicability;
+use rustc_lint::{EarlyContext, EarlyLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// ### What it does
+    ///
+    /// Checks for usage of:
+    ///
+    /// - `[foo].iter()`
+    /// - `[foo].iter_mut()`
+    /// - `[foo].into_iter()`
+    /// - `Some(foo).iter()`
+    /// - `Some(foo).iter_mut()`
+    /// - `Some(foo).into_iter()`
+    ///
+    /// ### Why is this bad?
+    ///
+    /// It is simpler to use the once function from the standard library:
+    ///
+    /// ### Example
+    ///
+    /// ```rust
+    /// let a = [123].iter();
+    /// let b = Some(123).into_iter();
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// use std::iter;
+    /// let a = iter::once(&123);
+    /// let b = iter::once(123);
+    /// ```
+    ///
+    /// ### Known problems
+    ///
+    /// The type of the resulting iterator might become incompatible with its usage
+    #[clippy::version = "1.64.0"]
+    pub ITER_ONCE,
+    nursery,
+    "Iterator for array of length 1"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    ///
+    /// Checks for usage of:
+    ///
+    /// - `[].iter()`
+    /// - `[].iter_mut()`
+    /// - `[].into_iter()`
+    /// - `None.iter()`
+    /// - `None.iter_mut()`
+    /// - `None.into_iter()`
+    ///
+    /// ### Why is this bad?
+    ///
+    /// It is simpler to use the empty function from the standard library:
+    ///
+    /// ### Example
+    ///
+    /// ```rust
+    /// use std::{slice, option};
+    /// let a: slice::Iter<i32> = [].iter();
+    /// let f: option::IntoIter<i32> = None.into_iter();
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// use std::iter;
+    /// let a: iter::Empty<i32> = iter::empty();
+    /// let b: iter::Empty<i32> = iter::empty();
+    /// ```
+    ///
+    /// ### Known problems
+    ///
+    /// The type of the resulting iterator might become incompatible with its usage
+    #[clippy::version = "1.64.0"]
+    pub ITER_EMPTY,
+    nursery,
+    "Iterator for empty array"
+}
+
+declare_lint_pass!(IterOnceEmpty => [ITER_ONCE, ITER_EMPTY]);
+
+impl EarlyLintPass for IterOnceEmpty {
+    fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
+        if expr.span.from_expansion() {
+            // Don't lint match expressions present in
+            // macro_rules! block
+            return;
+        }
+
+        let (method_name, args) = if let ExprKind::MethodCall(seg, args, _) = &expr.kind {
+            (seg.ident.as_str(), args)
+        } else {
+            return;
+        };
+        let arg = if args.len() == 1 {
+            &args[0]
+        } else {
+            return;
+        };
+
+        let item = match &arg.kind {
+            ExprKind::Array(v) if v.len() <= 1 => v.first(),
+            ExprKind::Path(None, p) => {
+                if p.segments.len() == 1 && p.segments[0].ident.name == rustc_span::sym::None {
+                    None
+                } else {
+                    return;
+                }
+            },
+            ExprKind::Call(f, some_args) if some_args.len() == 1 => {
+                if let ExprKind::Path(None, p) = &f.kind {
+                    if p.segments.len() == 1 && p.segments[0].ident.name == rustc_span::sym::Some {
+                        Some(&some_args[0])
+                    } else {
+                        return;
+                    }
+                } else {
+                    return;
+                }
+            },
+            _ => return,
+        };
+
+        if let Some(i) = item {
+            let (sugg, msg) = match method_name {
+                "iter" => (
+                    format!("std::iter::once(&{})", snippet(cx, i.span, "...")),
+                    "this `iter` call can be replaced with std::iter::once",
+                ),
+                "iter_mut" => (
+                    format!("std::iter::once(&mut {})", snippet(cx, i.span, "...")),
+                    "this `iter_mut` call can be replaced with std::iter::once",
+                ),
+                "into_iter" => (
+                    format!("std::iter::once({})", snippet(cx, i.span, "...")),
+                    "this `into_iter` call can be replaced with std::iter::once",
+                ),
+                _ => return,
+            };
+            span_lint_and_sugg(cx, ITER_ONCE, expr.span, msg, "try", sugg, Applicability::Unspecified);
+        } else {
+            let msg = match method_name {
+                "iter" => "this `iter call` can be replaced with std::iter::empty",
+                "iter_mut" => "this `iter_mut` call can be replaced with std::iter::empty",
+                "into_iter" => "this `into_iter` call can be replaced with std::iter::empty",
+                _ => return,
+            };
+            span_lint_and_sugg(
+                cx,
+                ITER_EMPTY,
+                expr.span,
+                msg,
+                "try",
+                "std::iter::empty()".to_string(),
+                Applicability::Unspecified,
+            );
+        }
+    }
+}
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index d83508a2d6c..49fc3a89527 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -200,6 +200,8 @@ store.register_lints(&[
     invalid_utf8_in_unchecked::INVALID_UTF8_IN_UNCHECKED,
     items_after_statements::ITEMS_AFTER_STATEMENTS,
     iter_not_returning_iterator::ITER_NOT_RETURNING_ITERATOR,
+    iter_once_empty::ITER_EMPTY,
+    iter_once_empty::ITER_ONCE,
     large_const_arrays::LARGE_CONST_ARRAYS,
     large_enum_variant::LARGE_ENUM_VARIANT,
     large_include_file::LARGE_INCLUDE_FILE,
diff --git a/clippy_lints/src/lib.register_nursery.rs b/clippy_lints/src/lib.register_nursery.rs
index 7d731d52dbb..9953aca43ee 100644
--- a/clippy_lints/src/lib.register_nursery.rs
+++ b/clippy_lints/src/lib.register_nursery.rs
@@ -14,6 +14,8 @@ store.register_group(true, "clippy::nursery", Some("clippy_nursery"), vec![
     LintId::of(index_refutable_slice::INDEX_REFUTABLE_SLICE),
     LintId::of(let_if_seq::USELESS_LET_IF_SEQ),
     LintId::of(matches::SIGNIFICANT_DROP_IN_SCRUTINEE),
+    LintId::of(methods::ITER_EMPTY),
+    LintId::of(methods::ITER_ONCE),
     LintId::of(methods::ITER_WITH_DRAIN),
     LintId::of(missing_const_for_fn::MISSING_CONST_FOR_FN),
     LintId::of(mutable_debug_assertion::DEBUG_ASSERT_WITH_MUT_CALL),
diff --git a/clippy_lints/src/lib.register_pedantic.rs b/clippy_lints/src/lib.register_pedantic.rs
index 4250ee055e6..6063fb00a7b 100644
--- a/clippy_lints/src/lib.register_pedantic.rs
+++ b/clippy_lints/src/lib.register_pedantic.rs
@@ -41,6 +41,8 @@ store.register_group(true, "clippy::pedantic", Some("clippy_pedantic"), vec![
     LintId::of(invalid_upcast_comparisons::INVALID_UPCAST_COMPARISONS),
     LintId::of(items_after_statements::ITEMS_AFTER_STATEMENTS),
     LintId::of(iter_not_returning_iterator::ITER_NOT_RETURNING_ITERATOR),
+    LintId::of(iter_once_empty::ITER_EMPTY),
+    LintId::of(iter_once_empty::ITER_ONCE),
     LintId::of(large_stack_arrays::LARGE_STACK_ARRAYS),
     LintId::of(let_underscore::LET_UNDERSCORE_DROP),
     LintId::of(literal_representation::LARGE_DIGIT_GROUPS),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 88c1a727f8d..78279db9ad5 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -258,6 +258,7 @@ mod invalid_upcast_comparisons;
 mod invalid_utf8_in_unchecked;
 mod items_after_statements;
 mod iter_not_returning_iterator;
+mod iter_once_empty;
 mod large_const_arrays;
 mod large_enum_variant;
 mod large_include_file;
@@ -931,6 +932,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(invalid_utf8_in_unchecked::InvalidUtf8InUnchecked));
     store.register_late_pass(|| Box::new(std_instead_of_core::StdReexports::default()));
     store.register_late_pass(|| Box::new(manual_instant_elapsed::ManualInstantElapsed));
+    store.register_early_pass(|| Box::new(iter_once_empty::IterOnceEmpty));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index dcfc03475b4..9c58978a070 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -484,6 +484,7 @@ pub fn def_path_res(cx: &LateContext<'_>, path: &[&str]) -> Res {
     }
     fn find_primitive<'tcx>(tcx: TyCtxt<'tcx>, name: &str) -> impl Iterator<Item = DefId> + 'tcx {
         let single = |ty| tcx.incoherent_impls(ty).iter().copied();
+        #[allow(clippy::iter_empty)]
         let empty = || [].iter().copied();
         match name {
             "bool" => single(BoolSimplifiedType),
diff --git a/tests/ui/iter_empty.fixed b/tests/ui/iter_empty.fixed
new file mode 100644
index 00000000000..fb7118f0d4a
--- /dev/null
+++ b/tests/ui/iter_empty.fixed
@@ -0,0 +1,32 @@
+// run-rustfix
+#![warn(clippy::iter_empty)]
+#![allow(clippy::iter_next_slice, clippy::redundant_clone)]
+
+fn array() {
+    assert_eq!(std::iter::empty().next(), Option::<i32>::None);
+    assert_eq!(std::iter::empty().next(), Option::<&mut i32>::None);
+    assert_eq!(std::iter::empty().next(), Option::<&i32>::None);
+    assert_eq!(std::iter::empty().next(), Option::<i32>::None);
+    assert_eq!(std::iter::empty().next(), Option::<&mut i32>::None);
+    assert_eq!(std::iter::empty().next(), Option::<&i32>::None);
+
+    // Don't trigger on non-iter methods
+    let _: Option<String> = None.clone();
+    let _: [String; 0] = [].clone();
+}
+
+macro_rules! in_macros {
+    () => {
+        assert_eq!([].into_iter().next(), Option::<i32>::None);
+        assert_eq!([].iter_mut().next(), Option::<&mut i32>::None);
+        assert_eq!([].iter().next(), Option::<&i32>::None);
+        assert_eq!(None.into_iter().next(), Option::<i32>::None);
+        assert_eq!(None.iter_mut().next(), Option::<&mut i32>::None);
+        assert_eq!(None.iter().next(), Option::<&i32>::None);
+    };
+}
+
+fn main() {
+    array();
+    in_macros!();
+}
diff --git a/tests/ui/iter_empty.rs b/tests/ui/iter_empty.rs
new file mode 100644
index 00000000000..bb192fe16d1
--- /dev/null
+++ b/tests/ui/iter_empty.rs
@@ -0,0 +1,32 @@
+// run-rustfix
+#![warn(clippy::iter_empty)]
+#![allow(clippy::iter_next_slice, clippy::redundant_clone)]
+
+fn array() {
+    assert_eq!([].into_iter().next(), Option::<i32>::None);
+    assert_eq!([].iter_mut().next(), Option::<&mut i32>::None);
+    assert_eq!([].iter().next(), Option::<&i32>::None);
+    assert_eq!(None.into_iter().next(), Option::<i32>::None);
+    assert_eq!(None.iter_mut().next(), Option::<&mut i32>::None);
+    assert_eq!(None.iter().next(), Option::<&i32>::None);
+
+    // Don't trigger on non-iter methods
+    let _: Option<String> = None.clone();
+    let _: [String; 0] = [].clone();
+}
+
+macro_rules! in_macros {
+    () => {
+        assert_eq!([].into_iter().next(), Option::<i32>::None);
+        assert_eq!([].iter_mut().next(), Option::<&mut i32>::None);
+        assert_eq!([].iter().next(), Option::<&i32>::None);
+        assert_eq!(None.into_iter().next(), Option::<i32>::None);
+        assert_eq!(None.iter_mut().next(), Option::<&mut i32>::None);
+        assert_eq!(None.iter().next(), Option::<&i32>::None);
+    };
+}
+
+fn main() {
+    array();
+    in_macros!();
+}
diff --git a/tests/ui/iter_empty.stderr b/tests/ui/iter_empty.stderr
new file mode 100644
index 00000000000..f4f06e93b23
--- /dev/null
+++ b/tests/ui/iter_empty.stderr
@@ -0,0 +1,40 @@
+error: this `into_iter` call can be replaced with std::iter::empty
+  --> $DIR/iter_empty.rs:6:16
+   |
+LL |     assert_eq!([].into_iter().next(), Option::<i32>::None);
+   |                ^^^^^^^^^^^^^^ help: try: `std::iter::empty()`
+   |
+   = note: `-D clippy::iter-empty` implied by `-D warnings`
+
+error: this `iter_mut` call can be replaced with std::iter::empty
+  --> $DIR/iter_empty.rs:7:16
+   |
+LL |     assert_eq!([].iter_mut().next(), Option::<&mut i32>::None);
+   |                ^^^^^^^^^^^^^ help: try: `std::iter::empty()`
+
+error: this `iter call` can be replaced with std::iter::empty
+  --> $DIR/iter_empty.rs:8:16
+   |
+LL |     assert_eq!([].iter().next(), Option::<&i32>::None);
+   |                ^^^^^^^^^ help: try: `std::iter::empty()`
+
+error: this `into_iter` call can be replaced with std::iter::empty
+  --> $DIR/iter_empty.rs:9:16
+   |
+LL |     assert_eq!(None.into_iter().next(), Option::<i32>::None);
+   |                ^^^^^^^^^^^^^^^^ help: try: `std::iter::empty()`
+
+error: this `iter_mut` call can be replaced with std::iter::empty
+  --> $DIR/iter_empty.rs:10:16
+   |
+LL |     assert_eq!(None.iter_mut().next(), Option::<&mut i32>::None);
+   |                ^^^^^^^^^^^^^^^ help: try: `std::iter::empty()`
+
+error: this `iter call` can be replaced with std::iter::empty
+  --> $DIR/iter_empty.rs:11:16
+   |
+LL |     assert_eq!(None.iter().next(), Option::<&i32>::None);
+   |                ^^^^^^^^^^^ help: try: `std::iter::empty()`
+
+error: aborting due to 6 previous errors
+
diff --git a/tests/ui/iter_once.fixed b/tests/ui/iter_once.fixed
new file mode 100644
index 00000000000..7247e34d7e8
--- /dev/null
+++ b/tests/ui/iter_once.fixed
@@ -0,0 +1,32 @@
+// run-rustfix
+#![warn(clippy::iter_once)]
+#![allow(clippy::iter_next_slice, clippy::redundant_clone)]
+
+fn array() {
+    assert_eq!(std::iter::once(123).next(), Some(123));
+    assert_eq!(std::iter::once(&mut 123).next(), Some(&mut 123));
+    assert_eq!(std::iter::once(&123).next(), Some(&123));
+    assert_eq!(std::iter::once(123).next(), Some(123));
+    assert_eq!(std::iter::once(&mut 123).next(), Some(&mut 123));
+    assert_eq!(std::iter::once(&123).next(), Some(&123));
+
+    // Don't trigger on non-iter methods
+    let _: Option<String> = Some("test".to_string()).clone();
+    let _: [String; 1] = ["test".to_string()].clone();
+}
+
+macro_rules! in_macros {
+    () => {
+        assert_eq!([123].into_iter().next(), Some(123));
+        assert_eq!([123].iter_mut().next(), Some(&mut 123));
+        assert_eq!([123].iter().next(), Some(&123));
+        assert_eq!(Some(123).into_iter().next(), Some(123));
+        assert_eq!(Some(123).iter_mut().next(), Some(&mut 123));
+        assert_eq!(Some(123).iter().next(), Some(&123));
+    };
+}
+
+fn main() {
+    array();
+    in_macros!();
+}
diff --git a/tests/ui/iter_once.rs b/tests/ui/iter_once.rs
new file mode 100644
index 00000000000..3a2b9c95cc5
--- /dev/null
+++ b/tests/ui/iter_once.rs
@@ -0,0 +1,32 @@
+// run-rustfix
+#![warn(clippy::iter_once)]
+#![allow(clippy::iter_next_slice, clippy::redundant_clone)]
+
+fn array() {
+    assert_eq!([123].into_iter().next(), Some(123));
+    assert_eq!([123].iter_mut().next(), Some(&mut 123));
+    assert_eq!([123].iter().next(), Some(&123));
+    assert_eq!(Some(123).into_iter().next(), Some(123));
+    assert_eq!(Some(123).iter_mut().next(), Some(&mut 123));
+    assert_eq!(Some(123).iter().next(), Some(&123));
+
+    // Don't trigger on non-iter methods
+    let _: Option<String> = Some("test".to_string()).clone();
+    let _: [String; 1] = ["test".to_string()].clone();
+}
+
+macro_rules! in_macros {
+    () => {
+        assert_eq!([123].into_iter().next(), Some(123));
+        assert_eq!([123].iter_mut().next(), Some(&mut 123));
+        assert_eq!([123].iter().next(), Some(&123));
+        assert_eq!(Some(123).into_iter().next(), Some(123));
+        assert_eq!(Some(123).iter_mut().next(), Some(&mut 123));
+        assert_eq!(Some(123).iter().next(), Some(&123));
+    };
+}
+
+fn main() {
+    array();
+    in_macros!();
+}
diff --git a/tests/ui/iter_once.stderr b/tests/ui/iter_once.stderr
new file mode 100644
index 00000000000..d9e8f96f763
--- /dev/null
+++ b/tests/ui/iter_once.stderr
@@ -0,0 +1,40 @@
+error: this `into_iter` call can be replaced with std::iter::once
+  --> $DIR/iter_once.rs:6:16
+   |
+LL |     assert_eq!([123].into_iter().next(), Some(123));
+   |                ^^^^^^^^^^^^^^^^^ help: try: `std::iter::once(123)`
+   |
+   = note: `-D clippy::iter-once` implied by `-D warnings`
+
+error: this `iter_mut` call can be replaced with std::iter::once
+  --> $DIR/iter_once.rs:7:16
+   |
+LL |     assert_eq!([123].iter_mut().next(), Some(&mut 123));
+   |                ^^^^^^^^^^^^^^^^ help: try: `std::iter::once(&mut 123)`
+
+error: this `iter` call can be replaced with std::iter::once
+  --> $DIR/iter_once.rs:8:16
+   |
+LL |     assert_eq!([123].iter().next(), Some(&123));
+   |                ^^^^^^^^^^^^ help: try: `std::iter::once(&123)`
+
+error: this `into_iter` call can be replaced with std::iter::once
+  --> $DIR/iter_once.rs:9:16
+   |
+LL |     assert_eq!(Some(123).into_iter().next(), Some(123));
+   |                ^^^^^^^^^^^^^^^^^^^^^ help: try: `std::iter::once(123)`
+
+error: this `iter_mut` call can be replaced with std::iter::once
+  --> $DIR/iter_once.rs:10:16
+   |
+LL |     assert_eq!(Some(123).iter_mut().next(), Some(&mut 123));
+   |                ^^^^^^^^^^^^^^^^^^^^ help: try: `std::iter::once(&mut 123)`
+
+error: this `iter` call can be replaced with std::iter::once
+  --> $DIR/iter_once.rs:11:16
+   |
+LL |     assert_eq!(Some(123).iter().next(), Some(&123));
+   |                ^^^^^^^^^^^^^^^^ help: try: `std::iter::once(&123)`
+
+error: aborting due to 6 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 332e03146e456ccedc1ab960fcdd739dd45080b5 Mon Sep 17 00:00:00 2001
From: Sosthène Guédon <sosthene@guedon.gdn>
Date: Sat, 16 Jul 2022 12:44:33 +0200
Subject: Fix the lint in clippy itself

---
 clippy_lints/src/dereference.rs                             | 2 +-
 clippy_lints/src/derive.rs                                  | 5 ++++-
 clippy_lints/src/redundant_slicing.rs                       | 4 +++-
 clippy_lints/src/types/mod.rs                               | 1 +
 clippy_lints/src/utils/conf.rs                              | 2 +-
 clippy_lints/src/utils/internal_lints/metadata_collector.rs | 2 +-
 6 files changed, 11 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index 5d41c63928d..e0b94f7190a 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -760,7 +760,7 @@ fn walk_parents<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> (Position, &
                                     .and_then(|subs| subs.get(1..))
                                 {
                                     Some(subs) => cx.tcx.mk_substs(subs.iter().copied()),
-                                    None => cx.tcx.mk_substs([].iter()),
+                                    None => cx.tcx.mk_substs(std::iter::empty::<ty::subst::GenericArg<'_>>()),
                                 } && let impl_ty = if cx.tcx.fn_sig(id).skip_binder().inputs()[0].is_ref() {
                                     // Trait methods taking `&self`
                                     sub_ty
diff --git a/clippy_lints/src/derive.rs b/clippy_lints/src/derive.rs
index a982990e418..9ca443b7dff 100644
--- a/clippy_lints/src/derive.rs
+++ b/clippy_lints/src/derive.rs
@@ -516,7 +516,10 @@ fn param_env_for_derived_eq(tcx: TyCtxt<'_>, did: DefId, eq_trait_id: DefId) ->
         tcx.mk_predicates(ty_predicates.iter().map(|&(p, _)| p).chain(
             params.iter().filter(|&&(_, needs_eq)| needs_eq).map(|&(param, _)| {
                 tcx.mk_predicate(Binder::dummy(PredicateKind::Trait(TraitPredicate {
-                    trait_ref: TraitRef::new(eq_trait_id, tcx.mk_substs([tcx.mk_param_from_def(param)].into_iter())),
+                    trait_ref: TraitRef::new(
+                        eq_trait_id,
+                        tcx.mk_substs(std::iter::once(tcx.mk_param_from_def(param))),
+                    ),
                     constness: BoundConstness::NotConst,
                     polarity: ImplPolarity::Positive,
                 })))
diff --git a/clippy_lints/src/redundant_slicing.rs b/clippy_lints/src/redundant_slicing.rs
index db6c97f3739..8693ca9af83 100644
--- a/clippy_lints/src/redundant_slicing.rs
+++ b/clippy_lints/src/redundant_slicing.rs
@@ -11,6 +11,8 @@ use rustc_middle::ty::adjustment::{Adjust, AutoBorrow, AutoBorrowMutability};
 use rustc_middle::ty::subst::GenericArg;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
+use std::iter;
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for redundant slicing expressions which use the full range, and
@@ -134,7 +136,7 @@ impl<'tcx> LateLintPass<'tcx> for RedundantSlicing {
                 } else if let Some(target_id) = cx.tcx.lang_items().deref_target() {
                     if let Ok(deref_ty) = cx.tcx.try_normalize_erasing_regions(
                         cx.param_env,
-                        cx.tcx.mk_projection(target_id, cx.tcx.mk_substs([GenericArg::from(indexed_ty)].into_iter())),
+                        cx.tcx.mk_projection(target_id, cx.tcx.mk_substs(iter::once(GenericArg::from(indexed_ty)))),
                     ) {
                         if deref_ty == expr_ty {
                             let snip = snippet_with_context(cx, indexed.span, ctxt, "..", &mut app).0;
diff --git a/clippy_lints/src/types/mod.rs b/clippy_lints/src/types/mod.rs
index 353a6f6b899..f3ba096237f 100644
--- a/clippy_lints/src/types/mod.rs
+++ b/clippy_lints/src/types/mod.rs
@@ -490,6 +490,7 @@ impl Types {
                         }
                     }
                 }
+                #[allow(clippy::iter_empty)]
                 match *qpath {
                     QPath::Resolved(Some(ty), p) => {
                         context.is_nested_call = true;
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 3faae9ac0d2..47b72f4783e 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -350,7 +350,7 @@ define_Conf! {
     /// Lint: DISALLOWED_SCRIPT_IDENTS.
     ///
     /// The list of unicode scripts allowed to be used in the scope.
-    (allowed_scripts: Vec<String> = ["Latin"].iter().map(ToString::to_string).collect()),
+    (allowed_scripts: Vec<String> = vec!["Latin".to_string()]),
     /// Lint: NON_SEND_FIELDS_IN_SEND_TY.
     ///
     /// Whether to apply the raw pointer heuristic to determine if a type is `Send`.
diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index 92cf42c7ad4..b1148bccc2a 100644
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -797,7 +797,7 @@ fn get_lint_group_and_level_or_lint(
     let result = cx.lint_store.check_lint_name(
         lint_name,
         Some(sym::clippy),
-        &[Ident::with_dummy_span(sym::clippy)].into_iter().collect(),
+        &std::iter::once(Ident::with_dummy_span(sym::clippy)).collect(),
     );
     if let CheckLintNameResult::Tool(Ok(lint_lst)) = result {
         if let Some(group) = get_lint_group(cx, lint_lst[0]) {
-- 
cgit 1.4.1-3-g733a5


From f3f86d8fd96dfa5986ffe10d0837169e473b9b83 Mon Sep 17 00:00:00 2001
From: Sosthène Guédon <sosthene@guedon.gdn>
Date: Sat, 16 Jul 2022 23:07:06 +0200
Subject: Move iter_once and iter_empty to methods as a late pass

This enables more thorough checking of types to avoid triggering on
custom Some and None enum variants
---
 clippy_lints/src/iter_once_empty.rs         | 164 ----------------------------
 clippy_lints/src/lib.register_lints.rs      |   4 +-
 clippy_lints/src/lib.register_pedantic.rs   |   2 -
 clippy_lints/src/lib.rs                     |   2 -
 clippy_lints/src/methods/iter_once_empty.rs |  70 ++++++++++++
 clippy_lints/src/methods/mod.rs             |  81 ++++++++++++++
 tests/ui/iter_empty.fixed                   |  23 ++++
 tests/ui/iter_empty.rs                      |  23 ++++
 tests/ui/iter_once.fixed                    |  23 ++++
 tests/ui/iter_once.rs                       |  23 ++++
 10 files changed, 245 insertions(+), 170 deletions(-)
 delete mode 100644 clippy_lints/src/iter_once_empty.rs
 create mode 100644 clippy_lints/src/methods/iter_once_empty.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/iter_once_empty.rs b/clippy_lints/src/iter_once_empty.rs
deleted file mode 100644
index 09896001112..00000000000
--- a/clippy_lints/src/iter_once_empty.rs
+++ /dev/null
@@ -1,164 +0,0 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::source::snippet;
-use rustc_ast::ast::{Expr, ExprKind};
-use rustc_errors::Applicability;
-use rustc_lint::{EarlyContext, EarlyLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-
-declare_clippy_lint! {
-    /// ### What it does
-    ///
-    /// Checks for usage of:
-    ///
-    /// - `[foo].iter()`
-    /// - `[foo].iter_mut()`
-    /// - `[foo].into_iter()`
-    /// - `Some(foo).iter()`
-    /// - `Some(foo).iter_mut()`
-    /// - `Some(foo).into_iter()`
-    ///
-    /// ### Why is this bad?
-    ///
-    /// It is simpler to use the once function from the standard library:
-    ///
-    /// ### Example
-    ///
-    /// ```rust
-    /// let a = [123].iter();
-    /// let b = Some(123).into_iter();
-    /// ```
-    /// Use instead:
-    /// ```rust
-    /// use std::iter;
-    /// let a = iter::once(&123);
-    /// let b = iter::once(123);
-    /// ```
-    ///
-    /// ### Known problems
-    ///
-    /// The type of the resulting iterator might become incompatible with its usage
-    #[clippy::version = "1.64.0"]
-    pub ITER_ONCE,
-    nursery,
-    "Iterator for array of length 1"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    ///
-    /// Checks for usage of:
-    ///
-    /// - `[].iter()`
-    /// - `[].iter_mut()`
-    /// - `[].into_iter()`
-    /// - `None.iter()`
-    /// - `None.iter_mut()`
-    /// - `None.into_iter()`
-    ///
-    /// ### Why is this bad?
-    ///
-    /// It is simpler to use the empty function from the standard library:
-    ///
-    /// ### Example
-    ///
-    /// ```rust
-    /// use std::{slice, option};
-    /// let a: slice::Iter<i32> = [].iter();
-    /// let f: option::IntoIter<i32> = None.into_iter();
-    /// ```
-    /// Use instead:
-    /// ```rust
-    /// use std::iter;
-    /// let a: iter::Empty<i32> = iter::empty();
-    /// let b: iter::Empty<i32> = iter::empty();
-    /// ```
-    ///
-    /// ### Known problems
-    ///
-    /// The type of the resulting iterator might become incompatible with its usage
-    #[clippy::version = "1.64.0"]
-    pub ITER_EMPTY,
-    nursery,
-    "Iterator for empty array"
-}
-
-declare_lint_pass!(IterOnceEmpty => [ITER_ONCE, ITER_EMPTY]);
-
-impl EarlyLintPass for IterOnceEmpty {
-    fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
-        if expr.span.from_expansion() {
-            // Don't lint match expressions present in
-            // macro_rules! block
-            return;
-        }
-
-        let (method_name, args) = if let ExprKind::MethodCall(seg, args, _) = &expr.kind {
-            (seg.ident.as_str(), args)
-        } else {
-            return;
-        };
-        let arg = if args.len() == 1 {
-            &args[0]
-        } else {
-            return;
-        };
-
-        let item = match &arg.kind {
-            ExprKind::Array(v) if v.len() <= 1 => v.first(),
-            ExprKind::Path(None, p) => {
-                if p.segments.len() == 1 && p.segments[0].ident.name == rustc_span::sym::None {
-                    None
-                } else {
-                    return;
-                }
-            },
-            ExprKind::Call(f, some_args) if some_args.len() == 1 => {
-                if let ExprKind::Path(None, p) = &f.kind {
-                    if p.segments.len() == 1 && p.segments[0].ident.name == rustc_span::sym::Some {
-                        Some(&some_args[0])
-                    } else {
-                        return;
-                    }
-                } else {
-                    return;
-                }
-            },
-            _ => return,
-        };
-
-        if let Some(i) = item {
-            let (sugg, msg) = match method_name {
-                "iter" => (
-                    format!("std::iter::once(&{})", snippet(cx, i.span, "...")),
-                    "this `iter` call can be replaced with std::iter::once",
-                ),
-                "iter_mut" => (
-                    format!("std::iter::once(&mut {})", snippet(cx, i.span, "...")),
-                    "this `iter_mut` call can be replaced with std::iter::once",
-                ),
-                "into_iter" => (
-                    format!("std::iter::once({})", snippet(cx, i.span, "...")),
-                    "this `into_iter` call can be replaced with std::iter::once",
-                ),
-                _ => return,
-            };
-            span_lint_and_sugg(cx, ITER_ONCE, expr.span, msg, "try", sugg, Applicability::Unspecified);
-        } else {
-            let msg = match method_name {
-                "iter" => "this `iter call` can be replaced with std::iter::empty",
-                "iter_mut" => "this `iter_mut` call can be replaced with std::iter::empty",
-                "into_iter" => "this `into_iter` call can be replaced with std::iter::empty",
-                _ => return,
-            };
-            span_lint_and_sugg(
-                cx,
-                ITER_EMPTY,
-                expr.span,
-                msg,
-                "try",
-                "std::iter::empty()".to_string(),
-                Applicability::Unspecified,
-            );
-        }
-    }
-}
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 49fc3a89527..e49321d83fa 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -200,8 +200,6 @@ store.register_lints(&[
     invalid_utf8_in_unchecked::INVALID_UTF8_IN_UNCHECKED,
     items_after_statements::ITEMS_AFTER_STATEMENTS,
     iter_not_returning_iterator::ITER_NOT_RETURNING_ITERATOR,
-    iter_once_empty::ITER_EMPTY,
-    iter_once_empty::ITER_ONCE,
     large_const_arrays::LARGE_CONST_ARRAYS,
     large_enum_variant::LARGE_ENUM_VARIANT,
     large_include_file::LARGE_INCLUDE_FILE,
@@ -314,9 +312,11 @@ store.register_lints(&[
     methods::ITERATOR_STEP_BY_ZERO,
     methods::ITER_CLONED_COLLECT,
     methods::ITER_COUNT,
+    methods::ITER_EMPTY,
     methods::ITER_NEXT_SLICE,
     methods::ITER_NTH,
     methods::ITER_NTH_ZERO,
+    methods::ITER_ONCE,
     methods::ITER_OVEREAGER_CLONED,
     methods::ITER_SKIP_NEXT,
     methods::ITER_WITH_DRAIN,
diff --git a/clippy_lints/src/lib.register_pedantic.rs b/clippy_lints/src/lib.register_pedantic.rs
index 6063fb00a7b..4250ee055e6 100644
--- a/clippy_lints/src/lib.register_pedantic.rs
+++ b/clippy_lints/src/lib.register_pedantic.rs
@@ -41,8 +41,6 @@ store.register_group(true, "clippy::pedantic", Some("clippy_pedantic"), vec![
     LintId::of(invalid_upcast_comparisons::INVALID_UPCAST_COMPARISONS),
     LintId::of(items_after_statements::ITEMS_AFTER_STATEMENTS),
     LintId::of(iter_not_returning_iterator::ITER_NOT_RETURNING_ITERATOR),
-    LintId::of(iter_once_empty::ITER_EMPTY),
-    LintId::of(iter_once_empty::ITER_ONCE),
     LintId::of(large_stack_arrays::LARGE_STACK_ARRAYS),
     LintId::of(let_underscore::LET_UNDERSCORE_DROP),
     LintId::of(literal_representation::LARGE_DIGIT_GROUPS),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 78279db9ad5..88c1a727f8d 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -258,7 +258,6 @@ mod invalid_upcast_comparisons;
 mod invalid_utf8_in_unchecked;
 mod items_after_statements;
 mod iter_not_returning_iterator;
-mod iter_once_empty;
 mod large_const_arrays;
 mod large_enum_variant;
 mod large_include_file;
@@ -932,7 +931,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(invalid_utf8_in_unchecked::InvalidUtf8InUnchecked));
     store.register_late_pass(|| Box::new(std_instead_of_core::StdReexports::default()));
     store.register_late_pass(|| Box::new(manual_instant_elapsed::ManualInstantElapsed));
-    store.register_early_pass(|| Box::new(iter_once_empty::IterOnceEmpty));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/methods/iter_once_empty.rs b/clippy_lints/src/methods/iter_once_empty.rs
new file mode 100644
index 00000000000..d45dfc67880
--- /dev/null
+++ b/clippy_lints/src/methods/iter_once_empty.rs
@@ -0,0 +1,70 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::is_lang_ctor;
+use clippy_utils::source::snippet;
+
+use rustc_errors::Applicability;
+use rustc_hir::LangItem::{OptionNone, OptionSome};
+use rustc_hir::{Expr, ExprKind};
+use rustc_lint::LateContext;
+
+use super::{ITER_EMPTY, ITER_ONCE};
+
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, method_name: &str, recv: &Expr<'_>) {
+    let item = match &recv.kind {
+        ExprKind::Array(v) if v.len() <= 1 => v.first(),
+        ExprKind::Path(p) => {
+            if is_lang_ctor(cx, p, OptionNone) {
+                None
+            } else {
+                return;
+            }
+        },
+        ExprKind::Call(f, some_args) if some_args.len() == 1 => {
+            if let ExprKind::Path(p) = &f.kind {
+                if is_lang_ctor(cx, p, OptionSome) {
+                    Some(&some_args[0])
+                } else {
+                    return;
+                }
+            } else {
+                return;
+            }
+        },
+        _ => return,
+    };
+
+    if let Some(i) = item {
+        let (sugg, msg) = match method_name {
+            "iter" => (
+                format!("std::iter::once(&{})", snippet(cx, i.span, "...")),
+                "this `iter` call can be replaced with std::iter::once",
+            ),
+            "iter_mut" => (
+                format!("std::iter::once(&mut {})", snippet(cx, i.span, "...")),
+                "this `iter_mut` call can be replaced with std::iter::once",
+            ),
+            "into_iter" => (
+                format!("std::iter::once({})", snippet(cx, i.span, "...")),
+                "this `into_iter` call can be replaced with std::iter::once",
+            ),
+            _ => return,
+        };
+        span_lint_and_sugg(cx, ITER_ONCE, expr.span, msg, "try", sugg, Applicability::Unspecified);
+    } else {
+        let msg = match method_name {
+            "iter" => "this `iter call` can be replaced with std::iter::empty",
+            "iter_mut" => "this `iter_mut` call can be replaced with std::iter::empty",
+            "into_iter" => "this `into_iter` call can be replaced with std::iter::empty",
+            _ => return,
+        };
+        span_lint_and_sugg(
+            cx,
+            ITER_EMPTY,
+            expr.span,
+            msg,
+            "try",
+            "std::iter::empty()".to_string(),
+            Applicability::Unspecified,
+        );
+    }
+}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 5ac6b09f0aa..e449ae0e424 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -33,6 +33,7 @@ mod iter_count;
 mod iter_next_slice;
 mod iter_nth;
 mod iter_nth_zero;
+mod iter_once_empty;
 mod iter_overeager_cloned;
 mod iter_skip_next;
 mod iter_with_drain;
@@ -2304,6 +2305,83 @@ declare_clippy_lint! {
     more clearly with `if .. else ..`"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    ///
+    /// Checks for usage of:
+    ///
+    /// - `[foo].iter()`
+    /// - `[foo].iter_mut()`
+    /// - `[foo].into_iter()`
+    /// - `Some(foo).iter()`
+    /// - `Some(foo).iter_mut()`
+    /// - `Some(foo).into_iter()`
+    ///
+    /// ### Why is this bad?
+    ///
+    /// It is simpler to use the once function from the standard library:
+    ///
+    /// ### Example
+    ///
+    /// ```rust
+    /// let a = [123].iter();
+    /// let b = Some(123).into_iter();
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// use std::iter;
+    /// let a = iter::once(&123);
+    /// let b = iter::once(123);
+    /// ```
+    ///
+    /// ### Known problems
+    ///
+    /// The type of the resulting iterator might become incompatible with its usage
+    #[clippy::version = "1.64.0"]
+    pub ITER_ONCE,
+    nursery,
+    "Iterator for array of length 1"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    ///
+    /// Checks for usage of:
+    ///
+    /// - `[].iter()`
+    /// - `[].iter_mut()`
+    /// - `[].into_iter()`
+    /// - `None.iter()`
+    /// - `None.iter_mut()`
+    /// - `None.into_iter()`
+    ///
+    /// ### Why is this bad?
+    ///
+    /// It is simpler to use the empty function from the standard library:
+    ///
+    /// ### Example
+    ///
+    /// ```rust
+    /// use std::{slice, option};
+    /// let a: slice::Iter<i32> = [].iter();
+    /// let f: option::IntoIter<i32> = None.into_iter();
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// use std::iter;
+    /// let a: iter::Empty<i32> = iter::empty();
+    /// let b: iter::Empty<i32> = iter::empty();
+    /// ```
+    ///
+    /// ### Known problems
+    ///
+    /// The type of the resulting iterator might become incompatible with its usage
+    #[clippy::version = "1.64.0"]
+    pub ITER_EMPTY,
+    nursery,
+    "Iterator for empty array"
+}
+
 pub struct Methods {
     avoid_breaking_exported_api: bool,
     msrv: Option<RustcVersion>,
@@ -2406,6 +2484,8 @@ impl_lint_pass!(Methods => [
     NEEDLESS_OPTION_TAKE,
     NO_EFFECT_REPLACE,
     OBFUSCATED_IF_ELSE,
+    ITER_ONCE,
+    ITER_EMPTY
 ]);
 
 /// Extracts a method call name, args, and `Span` of the method name.
@@ -2708,6 +2788,7 @@ impl Methods {
                 ("is_digit", [radix]) => is_digit_ascii_radix::check(cx, expr, recv, radix, self.msrv),
                 ("is_none", []) => check_is_some_is_none(cx, expr, recv, false),
                 ("is_some", []) => check_is_some_is_none(cx, expr, recv, true),
+                ("iter" | "iter_mut" | "into_iter", []) => iter_once_empty::check(cx, expr, name, recv),
                 ("join", [join_arg]) => {
                     if let Some(("collect", _, span)) = method_call(recv) {
                         unnecessary_join::check(cx, expr, recv, join_arg, span);
diff --git a/tests/ui/iter_empty.fixed b/tests/ui/iter_empty.fixed
index fb7118f0d4a..690da5a8761 100644
--- a/tests/ui/iter_empty.fixed
+++ b/tests/ui/iter_empty.fixed
@@ -26,7 +26,30 @@ macro_rules! in_macros {
     };
 }
 
+// Don't trigger on a `None` that isn't std's option
+mod custom_option {
+    #[allow(unused)]
+    enum CustomOption {
+        Some(i32),
+        None,
+    }
+
+    impl CustomOption {
+        fn iter(&self) {}
+        fn iter_mut(&mut self) {}
+        fn into_iter(self) {}
+    }
+    use CustomOption::*;
+
+    pub fn custom_option() {
+        None.iter();
+        None.iter_mut();
+        None.into_iter();
+    }
+}
+
 fn main() {
     array();
+    custom_option::custom_option();
     in_macros!();
 }
diff --git a/tests/ui/iter_empty.rs b/tests/ui/iter_empty.rs
index bb192fe16d1..f8b56898f2d 100644
--- a/tests/ui/iter_empty.rs
+++ b/tests/ui/iter_empty.rs
@@ -26,7 +26,30 @@ macro_rules! in_macros {
     };
 }
 
+// Don't trigger on a `None` that isn't std's option
+mod custom_option {
+    #[allow(unused)]
+    enum CustomOption {
+        Some(i32),
+        None,
+    }
+
+    impl CustomOption {
+        fn iter(&self) {}
+        fn iter_mut(&mut self) {}
+        fn into_iter(self) {}
+    }
+    use CustomOption::*;
+
+    pub fn custom_option() {
+        None.iter();
+        None.iter_mut();
+        None.into_iter();
+    }
+}
+
 fn main() {
     array();
+    custom_option::custom_option();
     in_macros!();
 }
diff --git a/tests/ui/iter_once.fixed b/tests/ui/iter_once.fixed
index 7247e34d7e8..0c82ab20be1 100644
--- a/tests/ui/iter_once.fixed
+++ b/tests/ui/iter_once.fixed
@@ -26,7 +26,30 @@ macro_rules! in_macros {
     };
 }
 
+// Don't trigger on a `Some` that isn't std's option
+mod custom_option {
+    #[allow(unused)]
+    enum CustomOption {
+        Some(i32),
+        None,
+    }
+
+    impl CustomOption {
+        fn iter(&self) {}
+        fn iter_mut(&mut self) {}
+        fn into_iter(self) {}
+    }
+    use CustomOption::*;
+
+    pub fn custom_option() {
+        Some(3).iter();
+        Some(3).iter_mut();
+        Some(3).into_iter();
+    }
+}
+
 fn main() {
     array();
+    custom_option::custom_option();
     in_macros!();
 }
diff --git a/tests/ui/iter_once.rs b/tests/ui/iter_once.rs
index 3a2b9c95cc5..d561bf27c1d 100644
--- a/tests/ui/iter_once.rs
+++ b/tests/ui/iter_once.rs
@@ -26,7 +26,30 @@ macro_rules! in_macros {
     };
 }
 
+// Don't trigger on a `Some` that isn't std's option
+mod custom_option {
+    #[allow(unused)]
+    enum CustomOption {
+        Some(i32),
+        None,
+    }
+
+    impl CustomOption {
+        fn iter(&self) {}
+        fn iter_mut(&mut self) {}
+        fn into_iter(self) {}
+    }
+    use CustomOption::*;
+
+    pub fn custom_option() {
+        Some(3).iter();
+        Some(3).iter_mut();
+        Some(3).into_iter();
+    }
+}
+
 fn main() {
     array();
+    custom_option::custom_option();
     in_macros!();
 }
-- 
cgit 1.4.1-3-g733a5


From f30d7c2495b3188bfa0cf8bd6dbbf76494c9845e Mon Sep 17 00:00:00 2001
From: Sosthène Guédon <sosthene@guedon.gdn>
Date: Tue, 19 Jul 2022 22:08:03 +0200
Subject: Improve suggestions

---
 clippy_lints/src/methods/iter_once_empty.rs | 70 ++++++++++++++++++-----------
 clippy_lints/src/methods/mod.rs             | 18 +-------
 tests/ui/iter_empty.stderr                  | 12 ++---
 tests/ui/iter_once.stderr                   | 12 ++---
 4 files changed, 59 insertions(+), 53 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/iter_once_empty.rs b/clippy_lints/src/methods/iter_once_empty.rs
index d45dfc67880..82fafb8a45e 100644
--- a/clippy_lints/src/methods/iter_once_empty.rs
+++ b/clippy_lints/src/methods/iter_once_empty.rs
@@ -1,5 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::is_lang_ctor;
+use clippy_utils::is_no_std_crate;
 use clippy_utils::source::snippet;
 
 use rustc_errors::Applicability;
@@ -9,6 +10,22 @@ use rustc_lint::LateContext;
 
 use super::{ITER_EMPTY, ITER_ONCE};
 
+enum IterType {
+    Iter,
+    IterMut,
+    IntoIter,
+}
+
+impl IterType {
+    fn ref_prefix(&self) -> &'static str {
+        match self {
+            Self::Iter => "&",
+            Self::IterMut => "&mut ",
+            Self::IntoIter => "",
+        }
+    }
+}
+
 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, method_name: &str, recv: &Expr<'_>) {
     let item = match &recv.kind {
         ExprKind::Array(v) if v.len() <= 1 => v.first(),
@@ -32,39 +49,42 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, method_name:
         },
         _ => return,
     };
+    let iter_type = match method_name {
+        "iter" => IterType::Iter,
+        "iter_mut" => IterType::IterMut,
+        "into_iter" => IterType::IntoIter,
+        _ => return,
+    };
 
     if let Some(i) = item {
-        let (sugg, msg) = match method_name {
-            "iter" => (
-                format!("std::iter::once(&{})", snippet(cx, i.span, "...")),
-                "this `iter` call can be replaced with std::iter::once",
-            ),
-            "iter_mut" => (
-                format!("std::iter::once(&mut {})", snippet(cx, i.span, "...")),
-                "this `iter_mut` call can be replaced with std::iter::once",
-            ),
-            "into_iter" => (
-                format!("std::iter::once({})", snippet(cx, i.span, "...")),
-                "this `into_iter` call can be replaced with std::iter::once",
-            ),
-            _ => return,
-        };
-        span_lint_and_sugg(cx, ITER_ONCE, expr.span, msg, "try", sugg, Applicability::Unspecified);
+        let sugg = format!(
+            "{}::iter::once({}{})",
+            if is_no_std_crate(cx) { "core" } else { "std" },
+            iter_type.ref_prefix(),
+            snippet(cx, i.span, "...")
+        );
+        span_lint_and_sugg(
+            cx,
+            ITER_ONCE,
+            expr.span,
+            &format!("`{method_name}` call on a collection with only one item"),
+            "try",
+            sugg,
+            Applicability::MaybeIncorrect,
+        );
     } else {
-        let msg = match method_name {
-            "iter" => "this `iter call` can be replaced with std::iter::empty",
-            "iter_mut" => "this `iter_mut` call can be replaced with std::iter::empty",
-            "into_iter" => "this `into_iter` call can be replaced with std::iter::empty",
-            _ => return,
-        };
         span_lint_and_sugg(
             cx,
             ITER_EMPTY,
             expr.span,
-            msg,
+            &format!("`{method_name}` call on an empty collection"),
             "try",
-            "std::iter::empty()".to_string(),
-            Applicability::Unspecified,
+            if is_no_std_crate(cx) {
+                "core::iter::empty()".to_string()
+            } else {
+                "std::iter::empty()".to_string()
+            },
+            Applicability::MaybeIncorrect,
         );
     }
 }
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index e449ae0e424..015cd094a9e 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -2308,14 +2308,7 @@ declare_clippy_lint! {
 declare_clippy_lint! {
     /// ### What it does
     ///
-    /// Checks for usage of:
-    ///
-    /// - `[foo].iter()`
-    /// - `[foo].iter_mut()`
-    /// - `[foo].into_iter()`
-    /// - `Some(foo).iter()`
-    /// - `Some(foo).iter_mut()`
-    /// - `Some(foo).into_iter()`
+    /// Checks for calls to `iter`, `iter_mut` or `into_iter` on collections containing a single item
     ///
     /// ### Why is this bad?
     ///
@@ -2346,14 +2339,7 @@ declare_clippy_lint! {
 declare_clippy_lint! {
     /// ### What it does
     ///
-    /// Checks for usage of:
-    ///
-    /// - `[].iter()`
-    /// - `[].iter_mut()`
-    /// - `[].into_iter()`
-    /// - `None.iter()`
-    /// - `None.iter_mut()`
-    /// - `None.into_iter()`
+    /// Checks for calls to `iter`, `iter_mut` or `into_iter` on empty collections
     ///
     /// ### Why is this bad?
     ///
diff --git a/tests/ui/iter_empty.stderr b/tests/ui/iter_empty.stderr
index f4f06e93b23..40c08e6f82b 100644
--- a/tests/ui/iter_empty.stderr
+++ b/tests/ui/iter_empty.stderr
@@ -1,4 +1,4 @@
-error: this `into_iter` call can be replaced with std::iter::empty
+error: `into_iter` call on an empty collection
   --> $DIR/iter_empty.rs:6:16
    |
 LL |     assert_eq!([].into_iter().next(), Option::<i32>::None);
@@ -6,31 +6,31 @@ LL |     assert_eq!([].into_iter().next(), Option::<i32>::None);
    |
    = note: `-D clippy::iter-empty` implied by `-D warnings`
 
-error: this `iter_mut` call can be replaced with std::iter::empty
+error: `iter_mut` call on an empty collection
   --> $DIR/iter_empty.rs:7:16
    |
 LL |     assert_eq!([].iter_mut().next(), Option::<&mut i32>::None);
    |                ^^^^^^^^^^^^^ help: try: `std::iter::empty()`
 
-error: this `iter call` can be replaced with std::iter::empty
+error: `iter` call on an empty collection
   --> $DIR/iter_empty.rs:8:16
    |
 LL |     assert_eq!([].iter().next(), Option::<&i32>::None);
    |                ^^^^^^^^^ help: try: `std::iter::empty()`
 
-error: this `into_iter` call can be replaced with std::iter::empty
+error: `into_iter` call on an empty collection
   --> $DIR/iter_empty.rs:9:16
    |
 LL |     assert_eq!(None.into_iter().next(), Option::<i32>::None);
    |                ^^^^^^^^^^^^^^^^ help: try: `std::iter::empty()`
 
-error: this `iter_mut` call can be replaced with std::iter::empty
+error: `iter_mut` call on an empty collection
   --> $DIR/iter_empty.rs:10:16
    |
 LL |     assert_eq!(None.iter_mut().next(), Option::<&mut i32>::None);
    |                ^^^^^^^^^^^^^^^ help: try: `std::iter::empty()`
 
-error: this `iter call` can be replaced with std::iter::empty
+error: `iter` call on an empty collection
   --> $DIR/iter_empty.rs:11:16
    |
 LL |     assert_eq!(None.iter().next(), Option::<&i32>::None);
diff --git a/tests/ui/iter_once.stderr b/tests/ui/iter_once.stderr
index d9e8f96f763..b22c8a99f10 100644
--- a/tests/ui/iter_once.stderr
+++ b/tests/ui/iter_once.stderr
@@ -1,4 +1,4 @@
-error: this `into_iter` call can be replaced with std::iter::once
+error: `into_iter` call on a collection with only one item
   --> $DIR/iter_once.rs:6:16
    |
 LL |     assert_eq!([123].into_iter().next(), Some(123));
@@ -6,31 +6,31 @@ LL |     assert_eq!([123].into_iter().next(), Some(123));
    |
    = note: `-D clippy::iter-once` implied by `-D warnings`
 
-error: this `iter_mut` call can be replaced with std::iter::once
+error: `iter_mut` call on a collection with only one item
   --> $DIR/iter_once.rs:7:16
    |
 LL |     assert_eq!([123].iter_mut().next(), Some(&mut 123));
    |                ^^^^^^^^^^^^^^^^ help: try: `std::iter::once(&mut 123)`
 
-error: this `iter` call can be replaced with std::iter::once
+error: `iter` call on a collection with only one item
   --> $DIR/iter_once.rs:8:16
    |
 LL |     assert_eq!([123].iter().next(), Some(&123));
    |                ^^^^^^^^^^^^ help: try: `std::iter::once(&123)`
 
-error: this `into_iter` call can be replaced with std::iter::once
+error: `into_iter` call on a collection with only one item
   --> $DIR/iter_once.rs:9:16
    |
 LL |     assert_eq!(Some(123).into_iter().next(), Some(123));
    |                ^^^^^^^^^^^^^^^^^^^^^ help: try: `std::iter::once(123)`
 
-error: this `iter_mut` call can be replaced with std::iter::once
+error: `iter_mut` call on a collection with only one item
   --> $DIR/iter_once.rs:10:16
    |
 LL |     assert_eq!(Some(123).iter_mut().next(), Some(&mut 123));
    |                ^^^^^^^^^^^^^^^^^^^^ help: try: `std::iter::once(&mut 123)`
 
-error: this `iter` call can be replaced with std::iter::once
+error: `iter` call on a collection with only one item
   --> $DIR/iter_once.rs:11:16
    |
 LL |     assert_eq!(Some(123).iter().next(), Some(&123));
-- 
cgit 1.4.1-3-g733a5


From b247594a39cb8e2c3d8d193860eac0eb1c63e1ae Mon Sep 17 00:00:00 2001
From: Sosthène Guédon <sosthene@guedon.gdn>
Date: Thu, 28 Jul 2022 22:54:23 +0200
Subject: Prevent some false positives

---
 clippy_lints/src/methods/iter_once_empty.rs | 23 ++++++++++++++++++++---
 clippy_lints/src/types/mod.rs               |  1 -
 clippy_utils/src/lib.rs                     |  1 -
 tests/ui/iter_empty.fixed                   |  8 ++++++++
 tests/ui/iter_empty.rs                      |  8 ++++++++
 tests/ui/iter_once.fixed                    |  8 ++++++++
 tests/ui/iter_once.rs                       |  8 ++++++++
 7 files changed, 52 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/iter_once_empty.rs b/clippy_lints/src/methods/iter_once_empty.rs
index 82fafb8a45e..96b1484528c 100644
--- a/clippy_lints/src/methods/iter_once_empty.rs
+++ b/clippy_lints/src/methods/iter_once_empty.rs
@@ -1,11 +1,10 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::is_lang_ctor;
-use clippy_utils::is_no_std_crate;
 use clippy_utils::source::snippet;
+use clippy_utils::{get_expr_use_or_unification_node, is_lang_ctor, is_no_std_crate};
 
 use rustc_errors::Applicability;
 use rustc_hir::LangItem::{OptionNone, OptionSome};
-use rustc_hir::{Expr, ExprKind};
+use rustc_hir::{Expr, ExprKind, Node};
 use rustc_lint::LateContext;
 
 use super::{ITER_EMPTY, ITER_ONCE};
@@ -56,6 +55,24 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, method_name:
         _ => return,
     };
 
+    let is_unified = match get_expr_use_or_unification_node(cx.tcx, expr) {
+        Some((Node::Expr(parent), child_id)) => match parent.kind {
+            ExprKind::If(e, _, _) | ExprKind::Match(e, _, _) if e.hir_id == child_id => false,
+            ExprKind::If(_, _, _)
+            | ExprKind::Match(_, _, _)
+            | ExprKind::Closure(_)
+            | ExprKind::Ret(_)
+            | ExprKind::Break(_, _) => true,
+            _ => false,
+        },
+        Some((Node::Stmt(_) | Node::Local(_), _)) => false,
+        _ => true,
+    };
+
+    if is_unified {
+        return;
+    }
+
     if let Some(i) = item {
         let sugg = format!(
             "{}::iter::once({}{})",
diff --git a/clippy_lints/src/types/mod.rs b/clippy_lints/src/types/mod.rs
index f3ba096237f..353a6f6b899 100644
--- a/clippy_lints/src/types/mod.rs
+++ b/clippy_lints/src/types/mod.rs
@@ -490,7 +490,6 @@ impl Types {
                         }
                     }
                 }
-                #[allow(clippy::iter_empty)]
                 match *qpath {
                     QPath::Resolved(Some(ty), p) => {
                         context.is_nested_call = true;
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 9c58978a070..dcfc03475b4 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -484,7 +484,6 @@ pub fn def_path_res(cx: &LateContext<'_>, path: &[&str]) -> Res {
     }
     fn find_primitive<'tcx>(tcx: TyCtxt<'tcx>, name: &str) -> impl Iterator<Item = DefId> + 'tcx {
         let single = |ty| tcx.incoherent_impls(ty).iter().copied();
-        #[allow(clippy::iter_empty)]
         let empty = || [].iter().copied();
         match name {
             "bool" => single(BoolSimplifiedType),
diff --git a/tests/ui/iter_empty.fixed b/tests/ui/iter_empty.fixed
index 690da5a8761..ad1e106d2b1 100644
--- a/tests/ui/iter_empty.fixed
+++ b/tests/ui/iter_empty.fixed
@@ -13,6 +13,14 @@ fn array() {
     // Don't trigger on non-iter methods
     let _: Option<String> = None.clone();
     let _: [String; 0] = [].clone();
+
+    // Don't trigger on match or if branches
+    let _ = match 123 {
+        123 => [].iter(),
+        _ => ["test"].iter(),
+    };
+
+    let _ = if false { ["test"].iter() } else { [].iter() };
 }
 
 macro_rules! in_macros {
diff --git a/tests/ui/iter_empty.rs b/tests/ui/iter_empty.rs
index f8b56898f2d..625149b5da5 100644
--- a/tests/ui/iter_empty.rs
+++ b/tests/ui/iter_empty.rs
@@ -13,6 +13,14 @@ fn array() {
     // Don't trigger on non-iter methods
     let _: Option<String> = None.clone();
     let _: [String; 0] = [].clone();
+
+    // Don't trigger on match or if branches
+    let _ = match 123 {
+        123 => [].iter(),
+        _ => ["test"].iter(),
+    };
+
+    let _ = if false { ["test"].iter() } else { [].iter() };
 }
 
 macro_rules! in_macros {
diff --git a/tests/ui/iter_once.fixed b/tests/ui/iter_once.fixed
index 0c82ab20be1..0495bc47e4b 100644
--- a/tests/ui/iter_once.fixed
+++ b/tests/ui/iter_once.fixed
@@ -13,6 +13,14 @@ fn array() {
     // Don't trigger on non-iter methods
     let _: Option<String> = Some("test".to_string()).clone();
     let _: [String; 1] = ["test".to_string()].clone();
+
+    // Don't trigger on match or if branches
+    let _ = match 123 {
+        123 => [].iter(),
+        _ => ["test"].iter(),
+    };
+
+    let _ = if false { ["test"].iter() } else { [].iter() };
 }
 
 macro_rules! in_macros {
diff --git a/tests/ui/iter_once.rs b/tests/ui/iter_once.rs
index d561bf27c1d..96641109bb9 100644
--- a/tests/ui/iter_once.rs
+++ b/tests/ui/iter_once.rs
@@ -13,6 +13,14 @@ fn array() {
     // Don't trigger on non-iter methods
     let _: Option<String> = Some("test".to_string()).clone();
     let _: [String; 1] = ["test".to_string()].clone();
+
+    // Don't trigger on match or if branches
+    let _ = match 123 {
+        123 => [].iter(),
+        _ => ["test"].iter(),
+    };
+
+    let _ = if false { ["test"].iter() } else { [].iter() };
 }
 
 macro_rules! in_macros {
-- 
cgit 1.4.1-3-g733a5


From af4885c0cde76bf1faace76dc8fb53d3d4791422 Mon Sep 17 00:00:00 2001
From: Sosthène Guédon <sosthene@guedon.gdn>
Date: Sat, 30 Jul 2022 13:39:55 +0200
Subject: Rename new lints to iter_on_empty_collections and
 iter_on_single_items

---
 CHANGELOG.md                                       |   4 +-
 clippy_lints/src/lib.register_lints.rs             |   4 +-
 clippy_lints/src/lib.register_nursery.rs           |   4 +-
 .../methods/iter_on_single_or_empty_collections.rs | 107 +++++++++++++++++++++
 clippy_lints/src/methods/iter_once_empty.rs        | 107 ---------------------
 clippy_lints/src/methods/mod.rs                    |  14 +--
 tests/ui/iter_empty.fixed                          |  63 ------------
 tests/ui/iter_empty.rs                             |  63 ------------
 tests/ui/iter_empty.stderr                         |  40 --------
 tests/ui/iter_on_empty_collections.fixed           |  63 ++++++++++++
 tests/ui/iter_on_empty_collections.rs              |  63 ++++++++++++
 tests/ui/iter_on_empty_collections.stderr          |  40 ++++++++
 tests/ui/iter_on_single_items.fixed                |  63 ++++++++++++
 tests/ui/iter_on_single_items.rs                   |  63 ++++++++++++
 tests/ui/iter_on_single_items.stderr               |  40 ++++++++
 tests/ui/iter_once.fixed                           |  63 ------------
 tests/ui/iter_once.rs                              |  63 ------------
 tests/ui/iter_once.stderr                          |  40 --------
 18 files changed, 453 insertions(+), 451 deletions(-)
 create mode 100644 clippy_lints/src/methods/iter_on_single_or_empty_collections.rs
 delete mode 100644 clippy_lints/src/methods/iter_once_empty.rs
 delete mode 100644 tests/ui/iter_empty.fixed
 delete mode 100644 tests/ui/iter_empty.rs
 delete mode 100644 tests/ui/iter_empty.stderr
 create mode 100644 tests/ui/iter_on_empty_collections.fixed
 create mode 100644 tests/ui/iter_on_empty_collections.rs
 create mode 100644 tests/ui/iter_on_empty_collections.stderr
 create mode 100644 tests/ui/iter_on_single_items.fixed
 create mode 100644 tests/ui/iter_on_single_items.rs
 create mode 100644 tests/ui/iter_on_single_items.stderr
 delete mode 100644 tests/ui/iter_once.fixed
 delete mode 100644 tests/ui/iter_once.rs
 delete mode 100644 tests/ui/iter_once.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 94f71eba0a2..03a76ccf607 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3651,13 +3651,13 @@ Released 2018-09-13
 [`items_after_statements`]: https://rust-lang.github.io/rust-clippy/master/index.html#items_after_statements
 [`iter_cloned_collect`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_cloned_collect
 [`iter_count`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_count
-[`iter_empty`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_empty
 [`iter_next_loop`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_next_loop
 [`iter_next_slice`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_next_slice
 [`iter_not_returning_iterator`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_not_returning_iterator
 [`iter_nth`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_nth
 [`iter_nth_zero`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_nth_zero
-[`iter_once`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_once
+[`iter_on_empty_collections`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_on_empty_collections
+[`iter_on_single_items`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_on_single_items
 [`iter_overeager_cloned`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_overeager_cloned
 [`iter_skip_next`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_skip_next
 [`iter_with_drain`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_with_drain
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index e49321d83fa..b697eb76290 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -312,11 +312,11 @@ store.register_lints(&[
     methods::ITERATOR_STEP_BY_ZERO,
     methods::ITER_CLONED_COLLECT,
     methods::ITER_COUNT,
-    methods::ITER_EMPTY,
     methods::ITER_NEXT_SLICE,
     methods::ITER_NTH,
     methods::ITER_NTH_ZERO,
-    methods::ITER_ONCE,
+    methods::ITER_ON_EMPTY_COLLECTIONS,
+    methods::ITER_ON_SINGLE_ITEMS,
     methods::ITER_OVEREAGER_CLONED,
     methods::ITER_SKIP_NEXT,
     methods::ITER_WITH_DRAIN,
diff --git a/clippy_lints/src/lib.register_nursery.rs b/clippy_lints/src/lib.register_nursery.rs
index 9953aca43ee..d6590192655 100644
--- a/clippy_lints/src/lib.register_nursery.rs
+++ b/clippy_lints/src/lib.register_nursery.rs
@@ -14,8 +14,8 @@ store.register_group(true, "clippy::nursery", Some("clippy_nursery"), vec![
     LintId::of(index_refutable_slice::INDEX_REFUTABLE_SLICE),
     LintId::of(let_if_seq::USELESS_LET_IF_SEQ),
     LintId::of(matches::SIGNIFICANT_DROP_IN_SCRUTINEE),
-    LintId::of(methods::ITER_EMPTY),
-    LintId::of(methods::ITER_ONCE),
+    LintId::of(methods::ITER_ON_EMPTY_COLLECTIONS),
+    LintId::of(methods::ITER_ON_SINGLE_ITEMS),
     LintId::of(methods::ITER_WITH_DRAIN),
     LintId::of(missing_const_for_fn::MISSING_CONST_FOR_FN),
     LintId::of(mutable_debug_assertion::DEBUG_ASSERT_WITH_MUT_CALL),
diff --git a/clippy_lints/src/methods/iter_on_single_or_empty_collections.rs b/clippy_lints/src/methods/iter_on_single_or_empty_collections.rs
new file mode 100644
index 00000000000..cea7b0d82ff
--- /dev/null
+++ b/clippy_lints/src/methods/iter_on_single_or_empty_collections.rs
@@ -0,0 +1,107 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet;
+use clippy_utils::{get_expr_use_or_unification_node, is_lang_ctor, is_no_std_crate};
+
+use rustc_errors::Applicability;
+use rustc_hir::LangItem::{OptionNone, OptionSome};
+use rustc_hir::{Expr, ExprKind, Node};
+use rustc_lint::LateContext;
+
+use super::{ITER_ON_EMPTY_COLLECTIONS, ITER_ON_SINGLE_ITEMS};
+
+enum IterType {
+    Iter,
+    IterMut,
+    IntoIter,
+}
+
+impl IterType {
+    fn ref_prefix(&self) -> &'static str {
+        match self {
+            Self::Iter => "&",
+            Self::IterMut => "&mut ",
+            Self::IntoIter => "",
+        }
+    }
+}
+
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, method_name: &str, recv: &Expr<'_>) {
+    let item = match &recv.kind {
+        ExprKind::Array(v) if v.len() <= 1 => v.first(),
+        ExprKind::Path(p) => {
+            if is_lang_ctor(cx, p, OptionNone) {
+                None
+            } else {
+                return;
+            }
+        },
+        ExprKind::Call(f, some_args) if some_args.len() == 1 => {
+            if let ExprKind::Path(p) = &f.kind {
+                if is_lang_ctor(cx, p, OptionSome) {
+                    Some(&some_args[0])
+                } else {
+                    return;
+                }
+            } else {
+                return;
+            }
+        },
+        _ => return,
+    };
+    let iter_type = match method_name {
+        "iter" => IterType::Iter,
+        "iter_mut" => IterType::IterMut,
+        "into_iter" => IterType::IntoIter,
+        _ => return,
+    };
+
+    let is_unified = match get_expr_use_or_unification_node(cx.tcx, expr) {
+        Some((Node::Expr(parent), child_id)) => match parent.kind {
+            ExprKind::If(e, _, _) | ExprKind::Match(e, _, _) if e.hir_id == child_id => false,
+            ExprKind::If(_, _, _)
+            | ExprKind::Match(_, _, _)
+            | ExprKind::Closure(_)
+            | ExprKind::Ret(_)
+            | ExprKind::Break(_, _) => true,
+            _ => false,
+        },
+        Some((Node::Stmt(_) | Node::Local(_), _)) => false,
+        _ => true,
+    };
+
+    if is_unified {
+        return;
+    }
+
+    if let Some(i) = item {
+        let sugg = format!(
+            "{}::iter::once({}{})",
+            if is_no_std_crate(cx) { "core" } else { "std" },
+            iter_type.ref_prefix(),
+            snippet(cx, i.span, "...")
+        );
+        span_lint_and_sugg(
+            cx,
+            ITER_ON_SINGLE_ITEMS,
+            expr.span,
+            &format!("`{method_name}` call on a collection with only one item"),
+            "try",
+            sugg,
+            Applicability::MaybeIncorrect,
+        );
+    } else {
+        span_lint_and_sugg(
+            cx,
+            ITER_ON_EMPTY_COLLECTIONS,
+            expr.span,
+            &format!("`{method_name}` call on an empty collection"),
+            "try",
+            if is_no_std_crate(cx) {
+                "core::iter::empty()".to_string()
+            } else {
+                "std::iter::empty()".to_string()
+            },
+            Applicability::MaybeIncorrect,
+        );
+    }
+}
diff --git a/clippy_lints/src/methods/iter_once_empty.rs b/clippy_lints/src/methods/iter_once_empty.rs
deleted file mode 100644
index 96b1484528c..00000000000
--- a/clippy_lints/src/methods/iter_once_empty.rs
+++ /dev/null
@@ -1,107 +0,0 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::source::snippet;
-use clippy_utils::{get_expr_use_or_unification_node, is_lang_ctor, is_no_std_crate};
-
-use rustc_errors::Applicability;
-use rustc_hir::LangItem::{OptionNone, OptionSome};
-use rustc_hir::{Expr, ExprKind, Node};
-use rustc_lint::LateContext;
-
-use super::{ITER_EMPTY, ITER_ONCE};
-
-enum IterType {
-    Iter,
-    IterMut,
-    IntoIter,
-}
-
-impl IterType {
-    fn ref_prefix(&self) -> &'static str {
-        match self {
-            Self::Iter => "&",
-            Self::IterMut => "&mut ",
-            Self::IntoIter => "",
-        }
-    }
-}
-
-pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, method_name: &str, recv: &Expr<'_>) {
-    let item = match &recv.kind {
-        ExprKind::Array(v) if v.len() <= 1 => v.first(),
-        ExprKind::Path(p) => {
-            if is_lang_ctor(cx, p, OptionNone) {
-                None
-            } else {
-                return;
-            }
-        },
-        ExprKind::Call(f, some_args) if some_args.len() == 1 => {
-            if let ExprKind::Path(p) = &f.kind {
-                if is_lang_ctor(cx, p, OptionSome) {
-                    Some(&some_args[0])
-                } else {
-                    return;
-                }
-            } else {
-                return;
-            }
-        },
-        _ => return,
-    };
-    let iter_type = match method_name {
-        "iter" => IterType::Iter,
-        "iter_mut" => IterType::IterMut,
-        "into_iter" => IterType::IntoIter,
-        _ => return,
-    };
-
-    let is_unified = match get_expr_use_or_unification_node(cx.tcx, expr) {
-        Some((Node::Expr(parent), child_id)) => match parent.kind {
-            ExprKind::If(e, _, _) | ExprKind::Match(e, _, _) if e.hir_id == child_id => false,
-            ExprKind::If(_, _, _)
-            | ExprKind::Match(_, _, _)
-            | ExprKind::Closure(_)
-            | ExprKind::Ret(_)
-            | ExprKind::Break(_, _) => true,
-            _ => false,
-        },
-        Some((Node::Stmt(_) | Node::Local(_), _)) => false,
-        _ => true,
-    };
-
-    if is_unified {
-        return;
-    }
-
-    if let Some(i) = item {
-        let sugg = format!(
-            "{}::iter::once({}{})",
-            if is_no_std_crate(cx) { "core" } else { "std" },
-            iter_type.ref_prefix(),
-            snippet(cx, i.span, "...")
-        );
-        span_lint_and_sugg(
-            cx,
-            ITER_ONCE,
-            expr.span,
-            &format!("`{method_name}` call on a collection with only one item"),
-            "try",
-            sugg,
-            Applicability::MaybeIncorrect,
-        );
-    } else {
-        span_lint_and_sugg(
-            cx,
-            ITER_EMPTY,
-            expr.span,
-            &format!("`{method_name}` call on an empty collection"),
-            "try",
-            if is_no_std_crate(cx) {
-                "core::iter::empty()".to_string()
-            } else {
-                "std::iter::empty()".to_string()
-            },
-            Applicability::MaybeIncorrect,
-        );
-    }
-}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 015cd094a9e..0936a3f48ca 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -33,7 +33,7 @@ mod iter_count;
 mod iter_next_slice;
 mod iter_nth;
 mod iter_nth_zero;
-mod iter_once_empty;
+mod iter_on_single_or_empty_collections;
 mod iter_overeager_cloned;
 mod iter_skip_next;
 mod iter_with_drain;
@@ -2331,7 +2331,7 @@ declare_clippy_lint! {
     ///
     /// The type of the resulting iterator might become incompatible with its usage
     #[clippy::version = "1.64.0"]
-    pub ITER_ONCE,
+    pub ITER_ON_SINGLE_ITEMS,
     nursery,
     "Iterator for array of length 1"
 }
@@ -2363,7 +2363,7 @@ declare_clippy_lint! {
     ///
     /// The type of the resulting iterator might become incompatible with its usage
     #[clippy::version = "1.64.0"]
-    pub ITER_EMPTY,
+    pub ITER_ON_EMPTY_COLLECTIONS,
     nursery,
     "Iterator for empty array"
 }
@@ -2470,8 +2470,8 @@ impl_lint_pass!(Methods => [
     NEEDLESS_OPTION_TAKE,
     NO_EFFECT_REPLACE,
     OBFUSCATED_IF_ELSE,
-    ITER_ONCE,
-    ITER_EMPTY
+    ITER_ON_SINGLE_ITEMS,
+    ITER_ON_EMPTY_COLLECTIONS
 ]);
 
 /// Extracts a method call name, args, and `Span` of the method name.
@@ -2774,7 +2774,9 @@ impl Methods {
                 ("is_digit", [radix]) => is_digit_ascii_radix::check(cx, expr, recv, radix, self.msrv),
                 ("is_none", []) => check_is_some_is_none(cx, expr, recv, false),
                 ("is_some", []) => check_is_some_is_none(cx, expr, recv, true),
-                ("iter" | "iter_mut" | "into_iter", []) => iter_once_empty::check(cx, expr, name, recv),
+                ("iter" | "iter_mut" | "into_iter", []) => {
+                    iter_on_single_or_empty_collections::check(cx, expr, name, recv);
+                },
                 ("join", [join_arg]) => {
                     if let Some(("collect", _, span)) = method_call(recv) {
                         unnecessary_join::check(cx, expr, recv, join_arg, span);
diff --git a/tests/ui/iter_empty.fixed b/tests/ui/iter_empty.fixed
deleted file mode 100644
index ad1e106d2b1..00000000000
--- a/tests/ui/iter_empty.fixed
+++ /dev/null
@@ -1,63 +0,0 @@
-// run-rustfix
-#![warn(clippy::iter_empty)]
-#![allow(clippy::iter_next_slice, clippy::redundant_clone)]
-
-fn array() {
-    assert_eq!(std::iter::empty().next(), Option::<i32>::None);
-    assert_eq!(std::iter::empty().next(), Option::<&mut i32>::None);
-    assert_eq!(std::iter::empty().next(), Option::<&i32>::None);
-    assert_eq!(std::iter::empty().next(), Option::<i32>::None);
-    assert_eq!(std::iter::empty().next(), Option::<&mut i32>::None);
-    assert_eq!(std::iter::empty().next(), Option::<&i32>::None);
-
-    // Don't trigger on non-iter methods
-    let _: Option<String> = None.clone();
-    let _: [String; 0] = [].clone();
-
-    // Don't trigger on match or if branches
-    let _ = match 123 {
-        123 => [].iter(),
-        _ => ["test"].iter(),
-    };
-
-    let _ = if false { ["test"].iter() } else { [].iter() };
-}
-
-macro_rules! in_macros {
-    () => {
-        assert_eq!([].into_iter().next(), Option::<i32>::None);
-        assert_eq!([].iter_mut().next(), Option::<&mut i32>::None);
-        assert_eq!([].iter().next(), Option::<&i32>::None);
-        assert_eq!(None.into_iter().next(), Option::<i32>::None);
-        assert_eq!(None.iter_mut().next(), Option::<&mut i32>::None);
-        assert_eq!(None.iter().next(), Option::<&i32>::None);
-    };
-}
-
-// Don't trigger on a `None` that isn't std's option
-mod custom_option {
-    #[allow(unused)]
-    enum CustomOption {
-        Some(i32),
-        None,
-    }
-
-    impl CustomOption {
-        fn iter(&self) {}
-        fn iter_mut(&mut self) {}
-        fn into_iter(self) {}
-    }
-    use CustomOption::*;
-
-    pub fn custom_option() {
-        None.iter();
-        None.iter_mut();
-        None.into_iter();
-    }
-}
-
-fn main() {
-    array();
-    custom_option::custom_option();
-    in_macros!();
-}
diff --git a/tests/ui/iter_empty.rs b/tests/ui/iter_empty.rs
deleted file mode 100644
index 625149b5da5..00000000000
--- a/tests/ui/iter_empty.rs
+++ /dev/null
@@ -1,63 +0,0 @@
-// run-rustfix
-#![warn(clippy::iter_empty)]
-#![allow(clippy::iter_next_slice, clippy::redundant_clone)]
-
-fn array() {
-    assert_eq!([].into_iter().next(), Option::<i32>::None);
-    assert_eq!([].iter_mut().next(), Option::<&mut i32>::None);
-    assert_eq!([].iter().next(), Option::<&i32>::None);
-    assert_eq!(None.into_iter().next(), Option::<i32>::None);
-    assert_eq!(None.iter_mut().next(), Option::<&mut i32>::None);
-    assert_eq!(None.iter().next(), Option::<&i32>::None);
-
-    // Don't trigger on non-iter methods
-    let _: Option<String> = None.clone();
-    let _: [String; 0] = [].clone();
-
-    // Don't trigger on match or if branches
-    let _ = match 123 {
-        123 => [].iter(),
-        _ => ["test"].iter(),
-    };
-
-    let _ = if false { ["test"].iter() } else { [].iter() };
-}
-
-macro_rules! in_macros {
-    () => {
-        assert_eq!([].into_iter().next(), Option::<i32>::None);
-        assert_eq!([].iter_mut().next(), Option::<&mut i32>::None);
-        assert_eq!([].iter().next(), Option::<&i32>::None);
-        assert_eq!(None.into_iter().next(), Option::<i32>::None);
-        assert_eq!(None.iter_mut().next(), Option::<&mut i32>::None);
-        assert_eq!(None.iter().next(), Option::<&i32>::None);
-    };
-}
-
-// Don't trigger on a `None` that isn't std's option
-mod custom_option {
-    #[allow(unused)]
-    enum CustomOption {
-        Some(i32),
-        None,
-    }
-
-    impl CustomOption {
-        fn iter(&self) {}
-        fn iter_mut(&mut self) {}
-        fn into_iter(self) {}
-    }
-    use CustomOption::*;
-
-    pub fn custom_option() {
-        None.iter();
-        None.iter_mut();
-        None.into_iter();
-    }
-}
-
-fn main() {
-    array();
-    custom_option::custom_option();
-    in_macros!();
-}
diff --git a/tests/ui/iter_empty.stderr b/tests/ui/iter_empty.stderr
deleted file mode 100644
index 40c08e6f82b..00000000000
--- a/tests/ui/iter_empty.stderr
+++ /dev/null
@@ -1,40 +0,0 @@
-error: `into_iter` call on an empty collection
-  --> $DIR/iter_empty.rs:6:16
-   |
-LL |     assert_eq!([].into_iter().next(), Option::<i32>::None);
-   |                ^^^^^^^^^^^^^^ help: try: `std::iter::empty()`
-   |
-   = note: `-D clippy::iter-empty` implied by `-D warnings`
-
-error: `iter_mut` call on an empty collection
-  --> $DIR/iter_empty.rs:7:16
-   |
-LL |     assert_eq!([].iter_mut().next(), Option::<&mut i32>::None);
-   |                ^^^^^^^^^^^^^ help: try: `std::iter::empty()`
-
-error: `iter` call on an empty collection
-  --> $DIR/iter_empty.rs:8:16
-   |
-LL |     assert_eq!([].iter().next(), Option::<&i32>::None);
-   |                ^^^^^^^^^ help: try: `std::iter::empty()`
-
-error: `into_iter` call on an empty collection
-  --> $DIR/iter_empty.rs:9:16
-   |
-LL |     assert_eq!(None.into_iter().next(), Option::<i32>::None);
-   |                ^^^^^^^^^^^^^^^^ help: try: `std::iter::empty()`
-
-error: `iter_mut` call on an empty collection
-  --> $DIR/iter_empty.rs:10:16
-   |
-LL |     assert_eq!(None.iter_mut().next(), Option::<&mut i32>::None);
-   |                ^^^^^^^^^^^^^^^ help: try: `std::iter::empty()`
-
-error: `iter` call on an empty collection
-  --> $DIR/iter_empty.rs:11:16
-   |
-LL |     assert_eq!(None.iter().next(), Option::<&i32>::None);
-   |                ^^^^^^^^^^^ help: try: `std::iter::empty()`
-
-error: aborting due to 6 previous errors
-
diff --git a/tests/ui/iter_on_empty_collections.fixed b/tests/ui/iter_on_empty_collections.fixed
new file mode 100644
index 00000000000..bd9b07aefbf
--- /dev/null
+++ b/tests/ui/iter_on_empty_collections.fixed
@@ -0,0 +1,63 @@
+// run-rustfix
+#![warn(clippy::iter_on_empty_collections)]
+#![allow(clippy::iter_next_slice, clippy::redundant_clone)]
+
+fn array() {
+    assert_eq!(std::iter::empty().next(), Option::<i32>::None);
+    assert_eq!(std::iter::empty().next(), Option::<&mut i32>::None);
+    assert_eq!(std::iter::empty().next(), Option::<&i32>::None);
+    assert_eq!(std::iter::empty().next(), Option::<i32>::None);
+    assert_eq!(std::iter::empty().next(), Option::<&mut i32>::None);
+    assert_eq!(std::iter::empty().next(), Option::<&i32>::None);
+
+    // Don't trigger on non-iter methods
+    let _: Option<String> = None.clone();
+    let _: [String; 0] = [].clone();
+
+    // Don't trigger on match or if branches
+    let _ = match 123 {
+        123 => [].iter(),
+        _ => ["test"].iter(),
+    };
+
+    let _ = if false { ["test"].iter() } else { [].iter() };
+}
+
+macro_rules! in_macros {
+    () => {
+        assert_eq!([].into_iter().next(), Option::<i32>::None);
+        assert_eq!([].iter_mut().next(), Option::<&mut i32>::None);
+        assert_eq!([].iter().next(), Option::<&i32>::None);
+        assert_eq!(None.into_iter().next(), Option::<i32>::None);
+        assert_eq!(None.iter_mut().next(), Option::<&mut i32>::None);
+        assert_eq!(None.iter().next(), Option::<&i32>::None);
+    };
+}
+
+// Don't trigger on a `None` that isn't std's option
+mod custom_option {
+    #[allow(unused)]
+    enum CustomOption {
+        Some(i32),
+        None,
+    }
+
+    impl CustomOption {
+        fn iter(&self) {}
+        fn iter_mut(&mut self) {}
+        fn into_iter(self) {}
+    }
+    use CustomOption::*;
+
+    pub fn custom_option() {
+        None.iter();
+        None.iter_mut();
+        None.into_iter();
+    }
+}
+
+fn main() {
+    array();
+    custom_option::custom_option();
+    in_macros!();
+}
diff --git a/tests/ui/iter_on_empty_collections.rs b/tests/ui/iter_on_empty_collections.rs
new file mode 100644
index 00000000000..e15ba94bd46
--- /dev/null
+++ b/tests/ui/iter_on_empty_collections.rs
@@ -0,0 +1,63 @@
+// run-rustfix
+#![warn(clippy::iter_on_empty_collections)]
+#![allow(clippy::iter_next_slice, clippy::redundant_clone)]
+
+fn array() {
+    assert_eq!([].into_iter().next(), Option::<i32>::None);
+    assert_eq!([].iter_mut().next(), Option::<&mut i32>::None);
+    assert_eq!([].iter().next(), Option::<&i32>::None);
+    assert_eq!(None.into_iter().next(), Option::<i32>::None);
+    assert_eq!(None.iter_mut().next(), Option::<&mut i32>::None);
+    assert_eq!(None.iter().next(), Option::<&i32>::None);
+
+    // Don't trigger on non-iter methods
+    let _: Option<String> = None.clone();
+    let _: [String; 0] = [].clone();
+
+    // Don't trigger on match or if branches
+    let _ = match 123 {
+        123 => [].iter(),
+        _ => ["test"].iter(),
+    };
+
+    let _ = if false { ["test"].iter() } else { [].iter() };
+}
+
+macro_rules! in_macros {
+    () => {
+        assert_eq!([].into_iter().next(), Option::<i32>::None);
+        assert_eq!([].iter_mut().next(), Option::<&mut i32>::None);
+        assert_eq!([].iter().next(), Option::<&i32>::None);
+        assert_eq!(None.into_iter().next(), Option::<i32>::None);
+        assert_eq!(None.iter_mut().next(), Option::<&mut i32>::None);
+        assert_eq!(None.iter().next(), Option::<&i32>::None);
+    };
+}
+
+// Don't trigger on a `None` that isn't std's option
+mod custom_option {
+    #[allow(unused)]
+    enum CustomOption {
+        Some(i32),
+        None,
+    }
+
+    impl CustomOption {
+        fn iter(&self) {}
+        fn iter_mut(&mut self) {}
+        fn into_iter(self) {}
+    }
+    use CustomOption::*;
+
+    pub fn custom_option() {
+        None.iter();
+        None.iter_mut();
+        None.into_iter();
+    }
+}
+
+fn main() {
+    array();
+    custom_option::custom_option();
+    in_macros!();
+}
diff --git a/tests/ui/iter_on_empty_collections.stderr b/tests/ui/iter_on_empty_collections.stderr
new file mode 100644
index 00000000000..cbd61176956
--- /dev/null
+++ b/tests/ui/iter_on_empty_collections.stderr
@@ -0,0 +1,40 @@
+error: `into_iter` call on an empty collection
+  --> $DIR/iter_on_empty_collections.rs:6:16
+   |
+LL |     assert_eq!([].into_iter().next(), Option::<i32>::None);
+   |                ^^^^^^^^^^^^^^ help: try: `std::iter::empty()`
+   |
+   = note: `-D clippy::iter-on-empty-collections` implied by `-D warnings`
+
+error: `iter_mut` call on an empty collection
+  --> $DIR/iter_on_empty_collections.rs:7:16
+   |
+LL |     assert_eq!([].iter_mut().next(), Option::<&mut i32>::None);
+   |                ^^^^^^^^^^^^^ help: try: `std::iter::empty()`
+
+error: `iter` call on an empty collection
+  --> $DIR/iter_on_empty_collections.rs:8:16
+   |
+LL |     assert_eq!([].iter().next(), Option::<&i32>::None);
+   |                ^^^^^^^^^ help: try: `std::iter::empty()`
+
+error: `into_iter` call on an empty collection
+  --> $DIR/iter_on_empty_collections.rs:9:16
+   |
+LL |     assert_eq!(None.into_iter().next(), Option::<i32>::None);
+   |                ^^^^^^^^^^^^^^^^ help: try: `std::iter::empty()`
+
+error: `iter_mut` call on an empty collection
+  --> $DIR/iter_on_empty_collections.rs:10:16
+   |
+LL |     assert_eq!(None.iter_mut().next(), Option::<&mut i32>::None);
+   |                ^^^^^^^^^^^^^^^ help: try: `std::iter::empty()`
+
+error: `iter` call on an empty collection
+  --> $DIR/iter_on_empty_collections.rs:11:16
+   |
+LL |     assert_eq!(None.iter().next(), Option::<&i32>::None);
+   |                ^^^^^^^^^^^ help: try: `std::iter::empty()`
+
+error: aborting due to 6 previous errors
+
diff --git a/tests/ui/iter_on_single_items.fixed b/tests/ui/iter_on_single_items.fixed
new file mode 100644
index 00000000000..1fa4b03641b
--- /dev/null
+++ b/tests/ui/iter_on_single_items.fixed
@@ -0,0 +1,63 @@
+// run-rustfix
+#![warn(clippy::iter_on_single_items)]
+#![allow(clippy::iter_next_slice, clippy::redundant_clone)]
+
+fn array() {
+    assert_eq!(std::iter::once(123).next(), Some(123));
+    assert_eq!(std::iter::once(&mut 123).next(), Some(&mut 123));
+    assert_eq!(std::iter::once(&123).next(), Some(&123));
+    assert_eq!(std::iter::once(123).next(), Some(123));
+    assert_eq!(std::iter::once(&mut 123).next(), Some(&mut 123));
+    assert_eq!(std::iter::once(&123).next(), Some(&123));
+
+    // Don't trigger on non-iter methods
+    let _: Option<String> = Some("test".to_string()).clone();
+    let _: [String; 1] = ["test".to_string()].clone();
+
+    // Don't trigger on match or if branches
+    let _ = match 123 {
+        123 => [].iter(),
+        _ => ["test"].iter(),
+    };
+
+    let _ = if false { ["test"].iter() } else { [].iter() };
+}
+
+macro_rules! in_macros {
+    () => {
+        assert_eq!([123].into_iter().next(), Some(123));
+        assert_eq!([123].iter_mut().next(), Some(&mut 123));
+        assert_eq!([123].iter().next(), Some(&123));
+        assert_eq!(Some(123).into_iter().next(), Some(123));
+        assert_eq!(Some(123).iter_mut().next(), Some(&mut 123));
+        assert_eq!(Some(123).iter().next(), Some(&123));
+    };
+}
+
+// Don't trigger on a `Some` that isn't std's option
+mod custom_option {
+    #[allow(unused)]
+    enum CustomOption {
+        Some(i32),
+        None,
+    }
+
+    impl CustomOption {
+        fn iter(&self) {}
+        fn iter_mut(&mut self) {}
+        fn into_iter(self) {}
+    }
+    use CustomOption::*;
+
+    pub fn custom_option() {
+        Some(3).iter();
+        Some(3).iter_mut();
+        Some(3).into_iter();
+    }
+}
+
+fn main() {
+    array();
+    custom_option::custom_option();
+    in_macros!();
+}
diff --git a/tests/ui/iter_on_single_items.rs b/tests/ui/iter_on_single_items.rs
new file mode 100644
index 00000000000..ea96d8066c5
--- /dev/null
+++ b/tests/ui/iter_on_single_items.rs
@@ -0,0 +1,63 @@
+// run-rustfix
+#![warn(clippy::iter_on_single_items)]
+#![allow(clippy::iter_next_slice, clippy::redundant_clone)]
+
+fn array() {
+    assert_eq!([123].into_iter().next(), Some(123));
+    assert_eq!([123].iter_mut().next(), Some(&mut 123));
+    assert_eq!([123].iter().next(), Some(&123));
+    assert_eq!(Some(123).into_iter().next(), Some(123));
+    assert_eq!(Some(123).iter_mut().next(), Some(&mut 123));
+    assert_eq!(Some(123).iter().next(), Some(&123));
+
+    // Don't trigger on non-iter methods
+    let _: Option<String> = Some("test".to_string()).clone();
+    let _: [String; 1] = ["test".to_string()].clone();
+
+    // Don't trigger on match or if branches
+    let _ = match 123 {
+        123 => [].iter(),
+        _ => ["test"].iter(),
+    };
+
+    let _ = if false { ["test"].iter() } else { [].iter() };
+}
+
+macro_rules! in_macros {
+    () => {
+        assert_eq!([123].into_iter().next(), Some(123));
+        assert_eq!([123].iter_mut().next(), Some(&mut 123));
+        assert_eq!([123].iter().next(), Some(&123));
+        assert_eq!(Some(123).into_iter().next(), Some(123));
+        assert_eq!(Some(123).iter_mut().next(), Some(&mut 123));
+        assert_eq!(Some(123).iter().next(), Some(&123));
+    };
+}
+
+// Don't trigger on a `Some` that isn't std's option
+mod custom_option {
+    #[allow(unused)]
+    enum CustomOption {
+        Some(i32),
+        None,
+    }
+
+    impl CustomOption {
+        fn iter(&self) {}
+        fn iter_mut(&mut self) {}
+        fn into_iter(self) {}
+    }
+    use CustomOption::*;
+
+    pub fn custom_option() {
+        Some(3).iter();
+        Some(3).iter_mut();
+        Some(3).into_iter();
+    }
+}
+
+fn main() {
+    array();
+    custom_option::custom_option();
+    in_macros!();
+}
diff --git a/tests/ui/iter_on_single_items.stderr b/tests/ui/iter_on_single_items.stderr
new file mode 100644
index 00000000000..d6c54711636
--- /dev/null
+++ b/tests/ui/iter_on_single_items.stderr
@@ -0,0 +1,40 @@
+error: `into_iter` call on a collection with only one item
+  --> $DIR/iter_on_single_items.rs:6:16
+   |
+LL |     assert_eq!([123].into_iter().next(), Some(123));
+   |                ^^^^^^^^^^^^^^^^^ help: try: `std::iter::once(123)`
+   |
+   = note: `-D clippy::iter-on-single-items` implied by `-D warnings`
+
+error: `iter_mut` call on a collection with only one item
+  --> $DIR/iter_on_single_items.rs:7:16
+   |
+LL |     assert_eq!([123].iter_mut().next(), Some(&mut 123));
+   |                ^^^^^^^^^^^^^^^^ help: try: `std::iter::once(&mut 123)`
+
+error: `iter` call on a collection with only one item
+  --> $DIR/iter_on_single_items.rs:8:16
+   |
+LL |     assert_eq!([123].iter().next(), Some(&123));
+   |                ^^^^^^^^^^^^ help: try: `std::iter::once(&123)`
+
+error: `into_iter` call on a collection with only one item
+  --> $DIR/iter_on_single_items.rs:9:16
+   |
+LL |     assert_eq!(Some(123).into_iter().next(), Some(123));
+   |                ^^^^^^^^^^^^^^^^^^^^^ help: try: `std::iter::once(123)`
+
+error: `iter_mut` call on a collection with only one item
+  --> $DIR/iter_on_single_items.rs:10:16
+   |
+LL |     assert_eq!(Some(123).iter_mut().next(), Some(&mut 123));
+   |                ^^^^^^^^^^^^^^^^^^^^ help: try: `std::iter::once(&mut 123)`
+
+error: `iter` call on a collection with only one item
+  --> $DIR/iter_on_single_items.rs:11:16
+   |
+LL |     assert_eq!(Some(123).iter().next(), Some(&123));
+   |                ^^^^^^^^^^^^^^^^ help: try: `std::iter::once(&123)`
+
+error: aborting due to 6 previous errors
+
diff --git a/tests/ui/iter_once.fixed b/tests/ui/iter_once.fixed
deleted file mode 100644
index 0495bc47e4b..00000000000
--- a/tests/ui/iter_once.fixed
+++ /dev/null
@@ -1,63 +0,0 @@
-// run-rustfix
-#![warn(clippy::iter_once)]
-#![allow(clippy::iter_next_slice, clippy::redundant_clone)]
-
-fn array() {
-    assert_eq!(std::iter::once(123).next(), Some(123));
-    assert_eq!(std::iter::once(&mut 123).next(), Some(&mut 123));
-    assert_eq!(std::iter::once(&123).next(), Some(&123));
-    assert_eq!(std::iter::once(123).next(), Some(123));
-    assert_eq!(std::iter::once(&mut 123).next(), Some(&mut 123));
-    assert_eq!(std::iter::once(&123).next(), Some(&123));
-
-    // Don't trigger on non-iter methods
-    let _: Option<String> = Some("test".to_string()).clone();
-    let _: [String; 1] = ["test".to_string()].clone();
-
-    // Don't trigger on match or if branches
-    let _ = match 123 {
-        123 => [].iter(),
-        _ => ["test"].iter(),
-    };
-
-    let _ = if false { ["test"].iter() } else { [].iter() };
-}
-
-macro_rules! in_macros {
-    () => {
-        assert_eq!([123].into_iter().next(), Some(123));
-        assert_eq!([123].iter_mut().next(), Some(&mut 123));
-        assert_eq!([123].iter().next(), Some(&123));
-        assert_eq!(Some(123).into_iter().next(), Some(123));
-        assert_eq!(Some(123).iter_mut().next(), Some(&mut 123));
-        assert_eq!(Some(123).iter().next(), Some(&123));
-    };
-}
-
-// Don't trigger on a `Some` that isn't std's option
-mod custom_option {
-    #[allow(unused)]
-    enum CustomOption {
-        Some(i32),
-        None,
-    }
-
-    impl CustomOption {
-        fn iter(&self) {}
-        fn iter_mut(&mut self) {}
-        fn into_iter(self) {}
-    }
-    use CustomOption::*;
-
-    pub fn custom_option() {
-        Some(3).iter();
-        Some(3).iter_mut();
-        Some(3).into_iter();
-    }
-}
-
-fn main() {
-    array();
-    custom_option::custom_option();
-    in_macros!();
-}
diff --git a/tests/ui/iter_once.rs b/tests/ui/iter_once.rs
deleted file mode 100644
index 96641109bb9..00000000000
--- a/tests/ui/iter_once.rs
+++ /dev/null
@@ -1,63 +0,0 @@
-// run-rustfix
-#![warn(clippy::iter_once)]
-#![allow(clippy::iter_next_slice, clippy::redundant_clone)]
-
-fn array() {
-    assert_eq!([123].into_iter().next(), Some(123));
-    assert_eq!([123].iter_mut().next(), Some(&mut 123));
-    assert_eq!([123].iter().next(), Some(&123));
-    assert_eq!(Some(123).into_iter().next(), Some(123));
-    assert_eq!(Some(123).iter_mut().next(), Some(&mut 123));
-    assert_eq!(Some(123).iter().next(), Some(&123));
-
-    // Don't trigger on non-iter methods
-    let _: Option<String> = Some("test".to_string()).clone();
-    let _: [String; 1] = ["test".to_string()].clone();
-
-    // Don't trigger on match or if branches
-    let _ = match 123 {
-        123 => [].iter(),
-        _ => ["test"].iter(),
-    };
-
-    let _ = if false { ["test"].iter() } else { [].iter() };
-}
-
-macro_rules! in_macros {
-    () => {
-        assert_eq!([123].into_iter().next(), Some(123));
-        assert_eq!([123].iter_mut().next(), Some(&mut 123));
-        assert_eq!([123].iter().next(), Some(&123));
-        assert_eq!(Some(123).into_iter().next(), Some(123));
-        assert_eq!(Some(123).iter_mut().next(), Some(&mut 123));
-        assert_eq!(Some(123).iter().next(), Some(&123));
-    };
-}
-
-// Don't trigger on a `Some` that isn't std's option
-mod custom_option {
-    #[allow(unused)]
-    enum CustomOption {
-        Some(i32),
-        None,
-    }
-
-    impl CustomOption {
-        fn iter(&self) {}
-        fn iter_mut(&mut self) {}
-        fn into_iter(self) {}
-    }
-    use CustomOption::*;
-
-    pub fn custom_option() {
-        Some(3).iter();
-        Some(3).iter_mut();
-        Some(3).into_iter();
-    }
-}
-
-fn main() {
-    array();
-    custom_option::custom_option();
-    in_macros!();
-}
diff --git a/tests/ui/iter_once.stderr b/tests/ui/iter_once.stderr
deleted file mode 100644
index b22c8a99f10..00000000000
--- a/tests/ui/iter_once.stderr
+++ /dev/null
@@ -1,40 +0,0 @@
-error: `into_iter` call on a collection with only one item
-  --> $DIR/iter_once.rs:6:16
-   |
-LL |     assert_eq!([123].into_iter().next(), Some(123));
-   |                ^^^^^^^^^^^^^^^^^ help: try: `std::iter::once(123)`
-   |
-   = note: `-D clippy::iter-once` implied by `-D warnings`
-
-error: `iter_mut` call on a collection with only one item
-  --> $DIR/iter_once.rs:7:16
-   |
-LL |     assert_eq!([123].iter_mut().next(), Some(&mut 123));
-   |                ^^^^^^^^^^^^^^^^ help: try: `std::iter::once(&mut 123)`
-
-error: `iter` call on a collection with only one item
-  --> $DIR/iter_once.rs:8:16
-   |
-LL |     assert_eq!([123].iter().next(), Some(&123));
-   |                ^^^^^^^^^^^^ help: try: `std::iter::once(&123)`
-
-error: `into_iter` call on a collection with only one item
-  --> $DIR/iter_once.rs:9:16
-   |
-LL |     assert_eq!(Some(123).into_iter().next(), Some(123));
-   |                ^^^^^^^^^^^^^^^^^^^^^ help: try: `std::iter::once(123)`
-
-error: `iter_mut` call on a collection with only one item
-  --> $DIR/iter_once.rs:10:16
-   |
-LL |     assert_eq!(Some(123).iter_mut().next(), Some(&mut 123));
-   |                ^^^^^^^^^^^^^^^^^^^^ help: try: `std::iter::once(&mut 123)`
-
-error: `iter` call on a collection with only one item
-  --> $DIR/iter_once.rs:11:16
-   |
-LL |     assert_eq!(Some(123).iter().next(), Some(&123));
-   |                ^^^^^^^^^^^^^^^^ help: try: `std::iter::once(&123)`
-
-error: aborting due to 6 previous errors
-
-- 
cgit 1.4.1-3-g733a5


From 8d4f2ac38195567ee8eca0123d428951821db507 Mon Sep 17 00:00:00 2001
From: dAxpeDDa <daxpedda@gmail.com>
Date: Tue, 9 Aug 2022 03:26:08 +0200
Subject: Use `check_proc_macro` for `missing_const_for_fn`

---
 clippy_lints/src/missing_const_for_fn.rs       | 14 ++++++---
 clippy_utils/src/check_proc_macro.rs           | 39 ++++++++++++++++++++++++--
 tests/ui/missing_const_for_fn/cant_be_const.rs |  9 ++++++
 3 files changed, 55 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/missing_const_for_fn.rs b/clippy_lints/src/missing_const_for_fn.rs
index 2bd920db302..bc304c081b9 100644
--- a/clippy_lints/src/missing_const_for_fn.rs
+++ b/clippy_lints/src/missing_const_for_fn.rs
@@ -1,7 +1,9 @@
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::qualify_min_const_fn::is_min_const_fn;
 use clippy_utils::ty::has_drop;
-use clippy_utils::{fn_has_unsatisfiable_preds, is_entrypoint_fn, meets_msrv, msrvs, trait_ref_of_method};
+use clippy_utils::{
+    fn_has_unsatisfiable_preds, is_entrypoint_fn, is_from_proc_macro, meets_msrv, msrvs, trait_ref_of_method,
+};
 use rustc_hir as hir;
 use rustc_hir::def_id::CRATE_DEF_ID;
 use rustc_hir::intravisit::FnKind;
@@ -86,10 +88,10 @@ impl MissingConstForFn {
 impl<'tcx> LateLintPass<'tcx> for MissingConstForFn {
     fn check_fn(
         &mut self,
-        cx: &LateContext<'_>,
-        kind: FnKind<'_>,
+        cx: &LateContext<'tcx>,
+        kind: FnKind<'tcx>,
         _: &FnDecl<'_>,
-        _: &Body<'_>,
+        body: &Body<'tcx>,
         span: Span,
         hir_id: HirId,
     ) {
@@ -144,6 +146,10 @@ impl<'tcx> LateLintPass<'tcx> for MissingConstForFn {
             }
         }
 
+        if is_from_proc_macro(cx, &(&kind, body, hir_id, span)) {
+            return;
+        }
+
         let mir = cx.tcx.optimized_mir(def_id);
 
         if let Err((span, err)) = is_min_const_fn(cx.tcx, mir, self.msrv) {
diff --git a/clippy_utils/src/check_proc_macro.rs b/clippy_utils/src/check_proc_macro.rs
index 0f00a1cdf0f..1062f223912 100644
--- a/clippy_utils/src/check_proc_macro.rs
+++ b/clippy_utils/src/check_proc_macro.rs
@@ -14,9 +14,9 @@
 
 use rustc_ast::ast::{IntTy, LitIntType, LitKind, StrStyle, UintTy};
 use rustc_hir::{
-    Block, BlockCheckMode, Closure, Destination, Expr, ExprKind, FieldDef, FnHeader, Impl, ImplItem, ImplItemKind,
-    IsAuto, Item, ItemKind, LoopSource, MatchSource, QPath, TraitItem, TraitItemKind, UnOp, UnsafeSource, Unsafety,
-    Variant, VariantData, YieldSource,
+    intravisit::FnKind, Block, BlockCheckMode, Body, Closure, Destination, Expr, ExprKind, FieldDef, FnHeader, HirId,
+    Impl, ImplItem, ImplItemKind, IsAuto, Item, ItemKind, LoopSource, MatchSource, QPath, TraitItem, TraitItemKind,
+    UnOp, UnsafeSource, Unsafety, Variant, VariantData, YieldSource,
 };
 use rustc_lint::{LateContext, LintContext};
 use rustc_middle::ty::TyCtxt;
@@ -250,6 +250,27 @@ fn variant_search_pat(v: &Variant<'_>) -> (Pat, Pat) {
     }
 }
 
+fn fn_kind_pat(tcx: TyCtxt<'_>, kind: &FnKind<'_>, body: &Body<'_>, hir_id: HirId) -> (Pat, Pat) {
+    let (start_pat, end_pat, visibility) = match kind {
+        FnKind::ItemFn(.., header) => (
+            fn_header_search_pat(*header),
+            Pat::Str(""),
+            tcx.visibility(tcx.hir().local_def_id(hir_id)),
+        ),
+        FnKind::Method(.., sig) => (
+            fn_header_search_pat(sig.header),
+            Pat::Str(""),
+            tcx.visibility(tcx.hir().local_def_id(hir_id)),
+        ),
+        FnKind::Closure => return (Pat::Str(""), expr_search_pat(tcx, &body.value).1),
+    };
+    if visibility.is_public() {
+        (Pat::Str("pub"), end_pat)
+    } else {
+        (start_pat, end_pat)
+    }
+}
+
 pub trait WithSearchPat {
     type Context: LintContext;
     fn search_pat(&self, cx: &Self::Context) -> (Pat, Pat);
@@ -277,6 +298,18 @@ impl_with_search_pat!(LateContext: ImplItem with impl_item_search_pat);
 impl_with_search_pat!(LateContext: FieldDef with field_def_search_pat);
 impl_with_search_pat!(LateContext: Variant with variant_search_pat);
 
+impl<'cx> WithSearchPat for (&FnKind<'cx>, &Body<'cx>, HirId, Span) {
+    type Context = LateContext<'cx>;
+
+    fn search_pat(&self, cx: &Self::Context) -> (Pat, Pat) {
+        fn_kind_pat(cx.tcx, self.0, self.1, self.2)
+    }
+
+    fn span(&self) -> Span {
+        self.3
+    }
+}
+
 /// Checks if the item likely came from a proc-macro.
 ///
 /// This should be called after `in_external_macro` and the initial pattern matching of the ast as
diff --git a/tests/ui/missing_const_for_fn/cant_be_const.rs b/tests/ui/missing_const_for_fn/cant_be_const.rs
index aa60d0504e5..b950248ef94 100644
--- a/tests/ui/missing_const_for_fn/cant_be_const.rs
+++ b/tests/ui/missing_const_for_fn/cant_be_const.rs
@@ -3,12 +3,16 @@
 //! The .stderr output of this test should be empty. Otherwise it's a bug somewhere.
 
 // aux-build:helper.rs
+// aux-build:../../auxiliary/proc_macro_with_span.rs
 
 #![warn(clippy::missing_const_for_fn)]
 #![feature(start)]
 #![feature(custom_inner_attributes)]
 
 extern crate helper;
+extern crate proc_macro_with_span;
+
+use proc_macro_with_span::with_span;
 
 struct Game;
 
@@ -119,3 +123,8 @@ mod const_fn_stabilized_after_msrv {
         byte.is_ascii_digit();
     }
 }
+
+with_span! {
+    span
+    fn dont_check_in_proc_macro() {}
+}
-- 
cgit 1.4.1-3-g733a5


From 9ffddf563c0380abbfc7b77274d89a1cb71573ae Mon Sep 17 00:00:00 2001
From: miam-miam100 <49870539+miam-miam100@users.noreply.github.com>
Date: Thu, 23 Jun 2022 20:09:47 +0100
Subject: Add new lint [`positional_named_format_parameters`]

---
 CHANGELOG.md                                       |   1 +
 clippy_lints/src/lib.register_all.rs               |   1 +
 clippy_lints/src/lib.register_lints.rs             |   1 +
 clippy_lints/src/lib.register_suspicious.rs        |   1 +
 clippy_lints/src/write.rs                          | 129 ++++++-
 tests/ui/positional_named_format_parameters.fixed  |  56 +++
 tests/ui/positional_named_format_parameters.rs     |  56 +++
 tests/ui/positional_named_format_parameters.stderr | 418 +++++++++++++++++++++
 8 files changed, 657 insertions(+), 6 deletions(-)
 create mode 100644 tests/ui/positional_named_format_parameters.fixed
 create mode 100644 tests/ui/positional_named_format_parameters.rs
 create mode 100644 tests/ui/positional_named_format_parameters.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 2278a8dc16b..569020db5b7 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3823,6 +3823,7 @@ Released 2018-09-13
 [`partialeq_ne_impl`]: https://rust-lang.github.io/rust-clippy/master/index.html#partialeq_ne_impl
 [`path_buf_push_overwrite`]: https://rust-lang.github.io/rust-clippy/master/index.html#path_buf_push_overwrite
 [`pattern_type_mismatch`]: https://rust-lang.github.io/rust-clippy/master/index.html#pattern_type_mismatch
+[`positional_named_format_parameters`]: https://rust-lang.github.io/rust-clippy/master/index.html#positional_named_format_parameters
 [`possible_missing_comma`]: https://rust-lang.github.io/rust-clippy/master/index.html#possible_missing_comma
 [`precedence`]: https://rust-lang.github.io/rust-clippy/master/index.html#precedence
 [`print_in_format_impl`]: https://rust-lang.github.io/rust-clippy/master/index.html#print_in_format_impl
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 5be1c417bf8..88b2dd487dd 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -345,6 +345,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(vec::USELESS_VEC),
     LintId::of(vec_init_then_push::VEC_INIT_THEN_PUSH),
     LintId::of(vec_resize_to_zero::VEC_RESIZE_TO_ZERO),
+    LintId::of(write::POSITIONAL_NAMED_FORMAT_PARAMETERS),
     LintId::of(write::PRINTLN_EMPTY_STRING),
     LintId::of(write::PRINT_LITERAL),
     LintId::of(write::PRINT_WITH_NEWLINE),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 99bde35cf15..dacdae0c4a9 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -583,6 +583,7 @@ store.register_lints(&[
     verbose_file_reads::VERBOSE_FILE_READS,
     wildcard_imports::ENUM_GLOB_USE,
     wildcard_imports::WILDCARD_IMPORTS,
+    write::POSITIONAL_NAMED_FORMAT_PARAMETERS,
     write::PRINTLN_EMPTY_STRING,
     write::PRINT_LITERAL,
     write::PRINT_STDERR,
diff --git a/clippy_lints/src/lib.register_suspicious.rs b/clippy_lints/src/lib.register_suspicious.rs
index f7558f87098..2aea0bf8c45 100644
--- a/clippy_lints/src/lib.register_suspicious.rs
+++ b/clippy_lints/src/lib.register_suspicious.rs
@@ -33,4 +33,5 @@ store.register_group(true, "clippy::suspicious", Some("clippy_suspicious"), vec!
     LintId::of(suspicious_trait_impl::SUSPICIOUS_ARITHMETIC_IMPL),
     LintId::of(suspicious_trait_impl::SUSPICIOUS_OP_ASSIGN_IMPL),
     LintId::of(swap_ptr_to_ref::SWAP_PTR_TO_REF),
+    LintId::of(write::POSITIONAL_NAMED_FORMAT_PARAMETERS),
 ])
diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs
index 08b88947520..31890707644 100644
--- a/clippy_lints/src/write.rs
+++ b/clippy_lints/src/write.rs
@@ -3,8 +3,9 @@ use std::iter;
 use std::ops::{Deref, Range};
 
 use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg, span_lint_and_then};
-use clippy_utils::source::{snippet_opt, snippet_with_applicability};
+use clippy_utils::source::{snippet, snippet_opt, snippet_with_applicability};
 use rustc_ast::ast::{Expr, ExprKind, Impl, Item, ItemKind, MacCall, Path, StrLit, StrStyle};
+use rustc_ast::ptr::P;
 use rustc_ast::token::{self, LitKind};
 use rustc_ast::tokenstream::TokenStream;
 use rustc_errors::{Applicability, DiagnosticBuilder};
@@ -256,6 +257,28 @@ declare_clippy_lint! {
     "writing a literal with a format string"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// This lint warns when a named parameter in a format string is used as a positional one.
+    ///
+    /// ### Why is this bad?
+    /// It may be confused for an assignment and obfuscates which parameter is being used.
+    ///
+    /// ### Example
+    /// ```rust
+    /// println!("{}", x = 10);
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust
+    /// println!("{x}", x = 10);
+    /// ```
+    #[clippy::version = "1.63.0"]
+    pub POSITIONAL_NAMED_FORMAT_PARAMETERS,
+    suspicious,
+    "named parameter in a format string is used positionally"
+}
+
 #[derive(Default)]
 pub struct Write {
     in_debug_impl: bool,
@@ -270,7 +293,8 @@ impl_lint_pass!(Write => [
     PRINT_LITERAL,
     WRITE_WITH_NEWLINE,
     WRITELN_EMPTY_STRING,
-    WRITE_LITERAL
+    WRITE_LITERAL,
+    POSITIONAL_NAMED_FORMAT_PARAMETERS,
 ]);
 
 impl EarlyLintPass for Write {
@@ -408,6 +432,7 @@ fn newline_span(fmtstr: &StrLit) -> (Span, bool) {
 #[derive(Default)]
 struct SimpleFormatArgs {
     unnamed: Vec<Vec<Span>>,
+    complex_unnamed: Vec<Vec<Span>>,
     named: Vec<(Symbol, Vec<Span>)>,
 }
 impl SimpleFormatArgs {
@@ -419,6 +444,10 @@ impl SimpleFormatArgs {
         })
     }
 
+    fn get_complex_unnamed(&self) -> impl Iterator<Item = &[Span]> {
+        self.complex_unnamed.iter().map(Vec::as_slice)
+    }
+
     fn get_named(&self, n: &Path) -> &[Span] {
         self.named.iter().find(|x| *n == x.0).map_or(&[], |x| x.1.as_slice())
     }
@@ -479,6 +508,61 @@ impl SimpleFormatArgs {
             },
         };
     }
+
+    fn push_to_complex(&mut self, span: Span, position: usize) {
+        if self.complex_unnamed.len() <= position {
+            self.complex_unnamed.resize_with(position, Vec::new);
+            self.complex_unnamed.push(vec![span]);
+        } else {
+            let args: &mut Vec<Span> = &mut self.complex_unnamed[position];
+            args.push(span);
+        }
+    }
+
+    fn push_complex(
+        &mut self,
+        cx: &EarlyContext<'_>,
+        arg: rustc_parse_format::Argument<'_>,
+        str_lit_span: Span,
+        fmt_span: Span,
+    ) {
+        use rustc_parse_format::{ArgumentImplicitlyIs, ArgumentIs, CountIsParam};
+
+        let snippet = snippet_opt(cx, fmt_span);
+
+        let end = snippet
+            .as_ref()
+            .and_then(|s| s.find(':'))
+            .or_else(|| fmt_span.hi().0.checked_sub(fmt_span.lo().0 + 1).map(|u| u as usize));
+
+        if let (ArgumentIs(n) | ArgumentImplicitlyIs(n), Some(end)) = (arg.position, end) {
+            let span = fmt_span.from_inner(InnerSpan::new(1, end));
+            self.push_to_complex(span, n);
+        };
+
+        if let (CountIsParam(n), Some(span)) = (arg.format.precision, arg.format.precision_span) {
+            // We need to do this hack as precision spans should be converted from .* to .foo$
+            let hack = if snippet.as_ref().and_then(|s| s.find('*')).is_some() {
+                0
+            } else {
+                1
+            };
+
+            let span = str_lit_span.from_inner(InnerSpan {
+                start: span.start + 1,
+                end: span.end - hack,
+            });
+            self.push_to_complex(span, n);
+        };
+
+        if let (CountIsParam(n), Some(span)) = (arg.format.width, arg.format.width_span) {
+            let span = str_lit_span.from_inner(InnerSpan {
+                start: span.start,
+                end: span.end - 1,
+            });
+            self.push_to_complex(span, n);
+        };
+    }
 }
 
 impl Write {
@@ -511,8 +595,8 @@ impl Write {
                 // FIXME: modify rustc's fmt string parser to give us the current span
                 span_lint(cx, USE_DEBUG, span, "use of `Debug`-based formatting");
             }
-
             args.push(arg, span);
+            args.push_complex(cx, arg, str_lit.span, span);
         }
 
         parser.errors.is_empty().then_some(args)
@@ -566,6 +650,7 @@ impl Write {
 
         let lint = if is_write { WRITE_LITERAL } else { PRINT_LITERAL };
         let mut unnamed_args = args.get_unnamed();
+        let mut complex_unnamed_args = args.get_complex_unnamed();
         loop {
             if !parser.eat(&token::Comma) {
                 return (Some(fmtstr), expr);
@@ -577,11 +662,20 @@ impl Write {
             } else {
                 return (Some(fmtstr), None);
             };
+            let complex_unnamed_arg = complex_unnamed_args.next();
+
             let (fmt_spans, lit) = match &token_expr.kind {
                 ExprKind::Lit(lit) => (unnamed_args.next().unwrap_or(&[]), lit),
-                ExprKind::Assign(lhs, rhs, _) => match (&lhs.kind, &rhs.kind) {
-                    (ExprKind::Path(_, p), ExprKind::Lit(lit)) => (args.get_named(p), lit),
-                    _ => continue,
+                ExprKind::Assign(lhs, rhs, _) => {
+                    if let Some(span) = complex_unnamed_arg {
+                        for x in span {
+                            Self::report_positional_named_param(cx, *x, lhs, rhs);
+                        }
+                    }
+                    match (&lhs.kind, &rhs.kind) {
+                        (ExprKind::Path(_, p), ExprKind::Lit(lit)) => (args.get_named(p), lit),
+                        _ => continue,
+                    }
                 },
                 _ => {
                     unnamed_args.next();
@@ -637,6 +731,29 @@ impl Write {
         }
     }
 
+    fn report_positional_named_param(cx: &EarlyContext<'_>, span: Span, lhs: &P<Expr>, _rhs: &P<Expr>) {
+        if let ExprKind::Path(_, _p) = &lhs.kind {
+            let mut applicability = Applicability::MachineApplicable;
+            let name = snippet_with_applicability(cx, lhs.span, "name", &mut applicability);
+            // We need to do this hack as precision spans should be converted from .* to .foo$
+            let hack = snippet(cx, span, "").contains('*');
+
+            span_lint_and_sugg(
+                cx,
+                POSITIONAL_NAMED_FORMAT_PARAMETERS,
+                span,
+                &format!("named parameter {} is used as a positional parameter", name),
+                "replace it with",
+                if hack {
+                    format!("{}$", name)
+                } else {
+                    format!("{}", name)
+                },
+                applicability,
+            );
+        };
+    }
+
     fn lint_println_empty_string(&self, cx: &EarlyContext<'_>, mac: &MacCall) {
         if let (Some(fmt_str), _) = self.check_tts(cx, mac.args.inner_tokens(), false) {
             if fmt_str.symbol == kw::Empty {
diff --git a/tests/ui/positional_named_format_parameters.fixed b/tests/ui/positional_named_format_parameters.fixed
new file mode 100644
index 00000000000..4170e109820
--- /dev/null
+++ b/tests/ui/positional_named_format_parameters.fixed
@@ -0,0 +1,56 @@
+// run-rustfix
+#![allow(unused_must_use)]
+#![allow(named_arguments_used_positionally)] // Unstable at time of writing.
+#![warn(clippy::positional_named_format_parameters)]
+
+use std::io::Write;
+
+fn main() {
+    let mut v = Vec::new();
+    let hello = "Hello";
+
+    println!("{hello:.foo$}", foo = 2);
+    writeln!(v, "{hello:.foo$}", foo = 2);
+
+    // Warnings
+    println!("{zero} {one:?}", zero = 0, one = 1);
+    println!("This is a test {zero} {one:?}", zero = 0, one = 1);
+    println!("Hello {one} is {two:.zero$}", zero = 5, one = hello, two = 0.01);
+    println!("Hello {one:zero$}!", zero = 5, one = 1);
+    println!("Hello {zero:one$}!", zero = 4, one = 1);
+    println!("Hello {zero:0one$}!", zero = 4, one = 1);
+    println!("Hello is {one:.zero$}", zero = 5, one = 0.01);
+    println!("Hello is {one:<6.zero$}", zero = 5, one = 0.01);
+    println!("{zero}, `{two:>8.one$}` has 3", zero = hello, one = 3, two = hello);
+    println!("Hello {one} is {two:.zero$}", zero = 5, one = hello, two = 0.01);
+    println!("Hello {world} {world}!", world = 5);
+
+    writeln!(v, "{zero} {one:?}", zero = 0, one = 1);
+    writeln!(v, "This is a test {zero} {one:?}", zero = 0, one = 1);
+    writeln!(v, "Hello {one} is {two:.zero$}", zero = 5, one = hello, two = 0.01);
+    writeln!(v, "Hello {one:zero$}!", zero = 4, one = 1);
+    writeln!(v, "Hello {zero:one$}!", zero = 4, one = 1);
+    writeln!(v, "Hello {zero:0one$}!", zero = 4, one = 1);
+    writeln!(v, "Hello is {one:.zero$}", zero = 3, one = 0.01);
+    writeln!(v, "Hello is {one:<6.zero$}", zero = 2, one = 0.01);
+    writeln!(v, "{zero}, `{two:>8.one$}` has 3", zero = hello, one = 3, two = hello);
+    writeln!(v, "Hello {one} is {two:.zero$}", zero = 1, one = hello, two = 0.01);
+    writeln!(v, "Hello {world} {world}!", world = 0);
+
+    // Tests from other files
+    println!("{w:w$}", w = 1);
+    println!("{p:.p$}", p = 1);
+    println!("{v}", v = 1);
+    println!("{v:v$}", v = 1);
+    println!("{v:v$}", v = 1);
+    println!("{v:v$.v$}", v = 1);
+    println!("{v:v$.v$}", v = 1);
+    println!("{v:v$.v$}", v = 1);
+    println!("{v:v$.v$}", v = 1);
+    println!("{v:v$.v$}", v = 1);
+    println!("{v:v$.v$}", v = 1);
+    println!("{v:v$.v$}", v = 1);
+    println!("{w:w$}", w = 1);
+    println!("{p:.p$}", p = 1);
+    println!("{:p$.w$}", 1, w = 1, p = 1);
+}
diff --git a/tests/ui/positional_named_format_parameters.rs b/tests/ui/positional_named_format_parameters.rs
new file mode 100644
index 00000000000..553d8494ecc
--- /dev/null
+++ b/tests/ui/positional_named_format_parameters.rs
@@ -0,0 +1,56 @@
+// run-rustfix
+#![allow(unused_must_use)]
+#![allow(named_arguments_used_positionally)] // Unstable at time of writing.
+#![warn(clippy::positional_named_format_parameters)]
+
+use std::io::Write;
+
+fn main() {
+    let mut v = Vec::new();
+    let hello = "Hello";
+
+    println!("{hello:.foo$}", foo = 2);
+    writeln!(v, "{hello:.foo$}", foo = 2);
+
+    // Warnings
+    println!("{} {1:?}", zero = 0, one = 1);
+    println!("This is a test { } {000001:?}", zero = 0, one = 1);
+    println!("Hello {1} is {2:.0$}", zero = 5, one = hello, two = 0.01);
+    println!("Hello {1:0$}!", zero = 5, one = 1);
+    println!("Hello {0:1$}!", zero = 4, one = 1);
+    println!("Hello {0:01$}!", zero = 4, one = 1);
+    println!("Hello is {1:.*}", zero = 5, one = 0.01);
+    println!("Hello is {:<6.*}", zero = 5, one = 0.01);
+    println!("{}, `{two:>8.*}` has 3", zero = hello, one = 3, two = hello);
+    println!("Hello {1} is {2:.0$}", zero = 5, one = hello, two = 0.01);
+    println!("Hello {world} {}!", world = 5);
+
+    writeln!(v, "{} {1:?}", zero = 0, one = 1);
+    writeln!(v, "This is a test { } {000001:?}", zero = 0, one = 1);
+    writeln!(v, "Hello {1} is {2:.0$}", zero = 5, one = hello, two = 0.01);
+    writeln!(v, "Hello {1:0$}!", zero = 4, one = 1);
+    writeln!(v, "Hello {0:1$}!", zero = 4, one = 1);
+    writeln!(v, "Hello {0:01$}!", zero = 4, one = 1);
+    writeln!(v, "Hello is {1:.*}", zero = 3, one = 0.01);
+    writeln!(v, "Hello is {:<6.*}", zero = 2, one = 0.01);
+    writeln!(v, "{}, `{two:>8.*}` has 3", zero = hello, one = 3, two = hello);
+    writeln!(v, "Hello {1} is {2:.0$}", zero = 1, one = hello, two = 0.01);
+    writeln!(v, "Hello {world} {}!", world = 0);
+
+    // Tests from other files
+    println!("{:w$}", w = 1);
+    println!("{:.p$}", p = 1);
+    println!("{}", v = 1);
+    println!("{:0$}", v = 1);
+    println!("{0:0$}", v = 1);
+    println!("{:0$.0$}", v = 1);
+    println!("{0:0$.0$}", v = 1);
+    println!("{0:0$.v$}", v = 1);
+    println!("{0:v$.0$}", v = 1);
+    println!("{v:0$.0$}", v = 1);
+    println!("{v:v$.0$}", v = 1);
+    println!("{v:0$.v$}", v = 1);
+    println!("{:w$}", w = 1);
+    println!("{:.p$}", p = 1);
+    println!("{:p$.w$}", 1, w = 1, p = 1);
+}
diff --git a/tests/ui/positional_named_format_parameters.stderr b/tests/ui/positional_named_format_parameters.stderr
new file mode 100644
index 00000000000..48ddb6d67ad
--- /dev/null
+++ b/tests/ui/positional_named_format_parameters.stderr
@@ -0,0 +1,418 @@
+error: named parameter zero is used as a positional parameter
+  --> $DIR/positional_named_format_parameters.rs:16:16
+   |
+LL |     println!("{} {1:?}", zero = 0, one = 1);
+   |                ^ help: replace it with: `zero`
+   |
+   = note: `-D clippy::positional-named-format-parameters` implied by `-D warnings`
+
+error: named parameter one is used as a positional parameter
+  --> $DIR/positional_named_format_parameters.rs:16:19
+   |
+LL |     println!("{} {1:?}", zero = 0, one = 1);
+   |                   ^ help: replace it with: `one`
+
+error: named parameter zero is used as a positional parameter
+  --> $DIR/positional_named_format_parameters.rs:17:31
+   |
+LL |     println!("This is a test { } {000001:?}", zero = 0, one = 1);
+   |                               ^ help: replace it with: `zero`
+
+error: named parameter one is used as a positional parameter
+  --> $DIR/positional_named_format_parameters.rs:17:35
+   |
+LL |     println!("This is a test { } {000001:?}", zero = 0, one = 1);
+   |                                   ^^^^^^ help: replace it with: `one`
+
+error: named parameter zero is used as a positional parameter
+  --> $DIR/positional_named_format_parameters.rs:18:32
+   |
+LL |     println!("Hello {1} is {2:.0$}", zero = 5, one = hello, two = 0.01);
+   |                                ^ help: replace it with: `zero`
+
+error: named parameter one is used as a positional parameter
+  --> $DIR/positional_named_format_parameters.rs:18:22
+   |
+LL |     println!("Hello {1} is {2:.0$}", zero = 5, one = hello, two = 0.01);
+   |                      ^ help: replace it with: `one`
+
+error: named parameter two is used as a positional parameter
+  --> $DIR/positional_named_format_parameters.rs:18:29
+   |
+LL |     println!("Hello {1} is {2:.0$}", zero = 5, one = hello, two = 0.01);
+   |                             ^ help: replace it with: `two`
+
+error: named parameter zero is used as a positional parameter
+  --> $DIR/positional_named_format_parameters.rs:19:24
+   |
+LL |     println!("Hello {1:0$}!", zero = 5, one = 1);
+   |                        ^ help: replace it with: `zero`
+
+error: named parameter one is used as a positional parameter
+  --> $DIR/positional_named_format_parameters.rs:19:22
+   |
+LL |     println!("Hello {1:0$}!", zero = 5, one = 1);
+   |                      ^ help: replace it with: `one`
+
+error: named parameter zero is used as a positional parameter
+  --> $DIR/positional_named_format_parameters.rs:20:22
+   |
+LL |     println!("Hello {0:1$}!", zero = 4, one = 1);
+   |                      ^ help: replace it with: `zero`
+
+error: named parameter one is used as a positional parameter
+  --> $DIR/positional_named_format_parameters.rs:20:24
+   |
+LL |     println!("Hello {0:1$}!", zero = 4, one = 1);
+   |                        ^ help: replace it with: `one`
+
+error: named parameter zero is used as a positional parameter
+  --> $DIR/positional_named_format_parameters.rs:21:22
+   |
+LL |     println!("Hello {0:01$}!", zero = 4, one = 1);
+   |                      ^ help: replace it with: `zero`
+
+error: named parameter one is used as a positional parameter
+  --> $DIR/positional_named_format_parameters.rs:21:25
+   |
+LL |     println!("Hello {0:01$}!", zero = 4, one = 1);
+   |                         ^ help: replace it with: `one`
+
+error: named parameter zero is used as a positional parameter
+  --> $DIR/positional_named_format_parameters.rs:22:28
+   |
+LL |     println!("Hello is {1:.*}", zero = 5, one = 0.01);
+   |                            ^ help: replace it with: `zero$`
+
+error: named parameter one is used as a positional parameter
+  --> $DIR/positional_named_format_parameters.rs:22:25
+   |
+LL |     println!("Hello is {1:.*}", zero = 5, one = 0.01);
+   |                         ^ help: replace it with: `one`
+
+error: named parameter zero is used as a positional parameter
+  --> $DIR/positional_named_format_parameters.rs:23:29
+   |
+LL |     println!("Hello is {:<6.*}", zero = 5, one = 0.01);
+   |                             ^ help: replace it with: `zero$`
+
+error: named parameter one is used as a positional parameter
+  --> $DIR/positional_named_format_parameters.rs:23:25
+   |
+LL |     println!("Hello is {:<6.*}", zero = 5, one = 0.01);
+   |                         ^ help: replace it with: `one`
+
+error: named parameter zero is used as a positional parameter
+  --> $DIR/positional_named_format_parameters.rs:24:16
+   |
+LL |     println!("{}, `{two:>8.*}` has 3", zero = hello, one = 3, two = hello);
+   |                ^ help: replace it with: `zero`
+
+error: named parameter one is used as a positional parameter
+  --> $DIR/positional_named_format_parameters.rs:24:28
+   |
+LL |     println!("{}, `{two:>8.*}` has 3", zero = hello, one = 3, two = hello);
+   |                            ^ help: replace it with: `one$`
+
+error: named parameter zero is used as a positional parameter
+  --> $DIR/positional_named_format_parameters.rs:25:32
+   |
+LL |     println!("Hello {1} is {2:.0$}", zero = 5, one = hello, two = 0.01);
+   |                                ^ help: replace it with: `zero`
+
+error: named parameter one is used as a positional parameter
+  --> $DIR/positional_named_format_parameters.rs:25:22
+   |
+LL |     println!("Hello {1} is {2:.0$}", zero = 5, one = hello, two = 0.01);
+   |                      ^ help: replace it with: `one`
+
+error: named parameter two is used as a positional parameter
+  --> $DIR/positional_named_format_parameters.rs:25:29
+   |
+LL |     println!("Hello {1} is {2:.0$}", zero = 5, one = hello, two = 0.01);
+   |                             ^ help: replace it with: `two`
+
+error: named parameter world is used as a positional parameter
+  --> $DIR/positional_named_format_parameters.rs:26:30
+   |
+LL |     println!("Hello {world} {}!", world = 5);
+   |                              ^ help: replace it with: `world`
+
+error: named parameter zero is used as a positional parameter
+  --> $DIR/positional_named_format_parameters.rs:28:19
+   |
+LL |     writeln!(v, "{} {1:?}", zero = 0, one = 1);
+   |                   ^ help: replace it with: `zero`
+
+error: named parameter one is used as a positional parameter
+  --> $DIR/positional_named_format_parameters.rs:28:22
+   |
+LL |     writeln!(v, "{} {1:?}", zero = 0, one = 1);
+   |                      ^ help: replace it with: `one`
+
+error: named parameter zero is used as a positional parameter
+  --> $DIR/positional_named_format_parameters.rs:29:34
+   |
+LL |     writeln!(v, "This is a test { } {000001:?}", zero = 0, one = 1);
+   |                                  ^ help: replace it with: `zero`
+
+error: named parameter one is used as a positional parameter
+  --> $DIR/positional_named_format_parameters.rs:29:38
+   |
+LL |     writeln!(v, "This is a test { } {000001:?}", zero = 0, one = 1);
+   |                                      ^^^^^^ help: replace it with: `one`
+
+error: named parameter zero is used as a positional parameter
+  --> $DIR/positional_named_format_parameters.rs:30:35
+   |
+LL |     writeln!(v, "Hello {1} is {2:.0$}", zero = 5, one = hello, two = 0.01);
+   |                                   ^ help: replace it with: `zero`
+
+error: named parameter one is used as a positional parameter
+  --> $DIR/positional_named_format_parameters.rs:30:25
+   |
+LL |     writeln!(v, "Hello {1} is {2:.0$}", zero = 5, one = hello, two = 0.01);
+   |                         ^ help: replace it with: `one`
+
+error: named parameter two is used as a positional parameter
+  --> $DIR/positional_named_format_parameters.rs:30:32
+   |
+LL |     writeln!(v, "Hello {1} is {2:.0$}", zero = 5, one = hello, two = 0.01);
+   |                                ^ help: replace it with: `two`
+
+error: named parameter zero is used as a positional parameter
+  --> $DIR/positional_named_format_parameters.rs:31:27
+   |
+LL |     writeln!(v, "Hello {1:0$}!", zero = 4, one = 1);
+   |                           ^ help: replace it with: `zero`
+
+error: named parameter one is used as a positional parameter
+  --> $DIR/positional_named_format_parameters.rs:31:25
+   |
+LL |     writeln!(v, "Hello {1:0$}!", zero = 4, one = 1);
+   |                         ^ help: replace it with: `one`
+
+error: named parameter zero is used as a positional parameter
+  --> $DIR/positional_named_format_parameters.rs:32:25
+   |
+LL |     writeln!(v, "Hello {0:1$}!", zero = 4, one = 1);
+   |                         ^ help: replace it with: `zero`
+
+error: named parameter one is used as a positional parameter
+  --> $DIR/positional_named_format_parameters.rs:32:27
+   |
+LL |     writeln!(v, "Hello {0:1$}!", zero = 4, one = 1);
+   |                           ^ help: replace it with: `one`
+
+error: named parameter zero is used as a positional parameter
+  --> $DIR/positional_named_format_parameters.rs:33:25
+   |
+LL |     writeln!(v, "Hello {0:01$}!", zero = 4, one = 1);
+   |                         ^ help: replace it with: `zero`
+
+error: named parameter one is used as a positional parameter
+  --> $DIR/positional_named_format_parameters.rs:33:28
+   |
+LL |     writeln!(v, "Hello {0:01$}!", zero = 4, one = 1);
+   |                            ^ help: replace it with: `one`
+
+error: named parameter zero is used as a positional parameter
+  --> $DIR/positional_named_format_parameters.rs:34:31
+   |
+LL |     writeln!(v, "Hello is {1:.*}", zero = 3, one = 0.01);
+   |                               ^ help: replace it with: `zero$`
+
+error: named parameter one is used as a positional parameter
+  --> $DIR/positional_named_format_parameters.rs:34:28
+   |
+LL |     writeln!(v, "Hello is {1:.*}", zero = 3, one = 0.01);
+   |                            ^ help: replace it with: `one`
+
+error: named parameter zero is used as a positional parameter
+  --> $DIR/positional_named_format_parameters.rs:35:32
+   |
+LL |     writeln!(v, "Hello is {:<6.*}", zero = 2, one = 0.01);
+   |                                ^ help: replace it with: `zero$`
+
+error: named parameter one is used as a positional parameter
+  --> $DIR/positional_named_format_parameters.rs:35:28
+   |
+LL |     writeln!(v, "Hello is {:<6.*}", zero = 2, one = 0.01);
+   |                            ^ help: replace it with: `one`
+
+error: named parameter zero is used as a positional parameter
+  --> $DIR/positional_named_format_parameters.rs:36:19
+   |
+LL |     writeln!(v, "{}, `{two:>8.*}` has 3", zero = hello, one = 3, two = hello);
+   |                   ^ help: replace it with: `zero`
+
+error: named parameter one is used as a positional parameter
+  --> $DIR/positional_named_format_parameters.rs:36:31
+   |
+LL |     writeln!(v, "{}, `{two:>8.*}` has 3", zero = hello, one = 3, two = hello);
+   |                               ^ help: replace it with: `one$`
+
+error: named parameter zero is used as a positional parameter
+  --> $DIR/positional_named_format_parameters.rs:37:35
+   |
+LL |     writeln!(v, "Hello {1} is {2:.0$}", zero = 1, one = hello, two = 0.01);
+   |                                   ^ help: replace it with: `zero`
+
+error: named parameter one is used as a positional parameter
+  --> $DIR/positional_named_format_parameters.rs:37:25
+   |
+LL |     writeln!(v, "Hello {1} is {2:.0$}", zero = 1, one = hello, two = 0.01);
+   |                         ^ help: replace it with: `one`
+
+error: named parameter two is used as a positional parameter
+  --> $DIR/positional_named_format_parameters.rs:37:32
+   |
+LL |     writeln!(v, "Hello {1} is {2:.0$}", zero = 1, one = hello, two = 0.01);
+   |                                ^ help: replace it with: `two`
+
+error: named parameter world is used as a positional parameter
+  --> $DIR/positional_named_format_parameters.rs:38:33
+   |
+LL |     writeln!(v, "Hello {world} {}!", world = 0);
+   |                                 ^ help: replace it with: `world`
+
+error: named parameter w is used as a positional parameter
+  --> $DIR/positional_named_format_parameters.rs:41:16
+   |
+LL |     println!("{:w$}", w = 1);
+   |                ^ help: replace it with: `w`
+
+error: named parameter p is used as a positional parameter
+  --> $DIR/positional_named_format_parameters.rs:42:16
+   |
+LL |     println!("{:.p$}", p = 1);
+   |                ^ help: replace it with: `p`
+
+error: named parameter v is used as a positional parameter
+  --> $DIR/positional_named_format_parameters.rs:43:16
+   |
+LL |     println!("{}", v = 1);
+   |                ^ help: replace it with: `v`
+
+error: named parameter v is used as a positional parameter
+  --> $DIR/positional_named_format_parameters.rs:44:16
+   |
+LL |     println!("{:0$}", v = 1);
+   |                ^ help: replace it with: `v`
+
+error: named parameter v is used as a positional parameter
+  --> $DIR/positional_named_format_parameters.rs:44:17
+   |
+LL |     println!("{:0$}", v = 1);
+   |                 ^ help: replace it with: `v`
+
+error: named parameter v is used as a positional parameter
+  --> $DIR/positional_named_format_parameters.rs:45:16
+   |
+LL |     println!("{0:0$}", v = 1);
+   |                ^ help: replace it with: `v`
+
+error: named parameter v is used as a positional parameter
+  --> $DIR/positional_named_format_parameters.rs:45:18
+   |
+LL |     println!("{0:0$}", v = 1);
+   |                  ^ help: replace it with: `v`
+
+error: named parameter v is used as a positional parameter
+  --> $DIR/positional_named_format_parameters.rs:46:16
+   |
+LL |     println!("{:0$.0$}", v = 1);
+   |                ^ help: replace it with: `v`
+
+error: named parameter v is used as a positional parameter
+  --> $DIR/positional_named_format_parameters.rs:46:20
+   |
+LL |     println!("{:0$.0$}", v = 1);
+   |                    ^ help: replace it with: `v`
+
+error: named parameter v is used as a positional parameter
+  --> $DIR/positional_named_format_parameters.rs:46:17
+   |
+LL |     println!("{:0$.0$}", v = 1);
+   |                 ^ help: replace it with: `v`
+
+error: named parameter v is used as a positional parameter
+  --> $DIR/positional_named_format_parameters.rs:47:16
+   |
+LL |     println!("{0:0$.0$}", v = 1);
+   |                ^ help: replace it with: `v`
+
+error: named parameter v is used as a positional parameter
+  --> $DIR/positional_named_format_parameters.rs:47:21
+   |
+LL |     println!("{0:0$.0$}", v = 1);
+   |                     ^ help: replace it with: `v`
+
+error: named parameter v is used as a positional parameter
+  --> $DIR/positional_named_format_parameters.rs:47:18
+   |
+LL |     println!("{0:0$.0$}", v = 1);
+   |                  ^ help: replace it with: `v`
+
+error: named parameter v is used as a positional parameter
+  --> $DIR/positional_named_format_parameters.rs:48:16
+   |
+LL |     println!("{0:0$.v$}", v = 1);
+   |                ^ help: replace it with: `v`
+
+error: named parameter v is used as a positional parameter
+  --> $DIR/positional_named_format_parameters.rs:48:18
+   |
+LL |     println!("{0:0$.v$}", v = 1);
+   |                  ^ help: replace it with: `v`
+
+error: named parameter v is used as a positional parameter
+  --> $DIR/positional_named_format_parameters.rs:49:16
+   |
+LL |     println!("{0:v$.0$}", v = 1);
+   |                ^ help: replace it with: `v`
+
+error: named parameter v is used as a positional parameter
+  --> $DIR/positional_named_format_parameters.rs:49:21
+   |
+LL |     println!("{0:v$.0$}", v = 1);
+   |                     ^ help: replace it with: `v`
+
+error: named parameter v is used as a positional parameter
+  --> $DIR/positional_named_format_parameters.rs:50:21
+   |
+LL |     println!("{v:0$.0$}", v = 1);
+   |                     ^ help: replace it with: `v`
+
+error: named parameter v is used as a positional parameter
+  --> $DIR/positional_named_format_parameters.rs:50:18
+   |
+LL |     println!("{v:0$.0$}", v = 1);
+   |                  ^ help: replace it with: `v`
+
+error: named parameter v is used as a positional parameter
+  --> $DIR/positional_named_format_parameters.rs:51:21
+   |
+LL |     println!("{v:v$.0$}", v = 1);
+   |                     ^ help: replace it with: `v`
+
+error: named parameter v is used as a positional parameter
+  --> $DIR/positional_named_format_parameters.rs:52:18
+   |
+LL |     println!("{v:0$.v$}", v = 1);
+   |                  ^ help: replace it with: `v`
+
+error: named parameter w is used as a positional parameter
+  --> $DIR/positional_named_format_parameters.rs:53:16
+   |
+LL |     println!("{:w$}", w = 1);
+   |                ^ help: replace it with: `w`
+
+error: named parameter p is used as a positional parameter
+  --> $DIR/positional_named_format_parameters.rs:54:16
+   |
+LL |     println!("{:.p$}", p = 1);
+   |                ^ help: replace it with: `p`
+
+error: aborting due to 69 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 6a73a454186c6795e692108b878492f8e25cd558 Mon Sep 17 00:00:00 2001
From: Lukas Lueg <lukas.lueg@gmail.com>
Date: Wed, 10 Aug 2022 19:40:42 +0200
Subject: Fix if_let_mutex not checking Mutexes behind refs

Fixes #9193
---
 clippy_lints/src/if_let_mutex.rs |  2 +-
 tests/ui/if_let_mutex.rs         |  8 ++++++++
 tests/ui/if_let_mutex.stderr     | 14 +++++++++++++-
 3 files changed, 22 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/if_let_mutex.rs b/clippy_lints/src/if_let_mutex.rs
index e9501700784..7c12a638529 100644
--- a/clippy_lints/src/if_let_mutex.rs
+++ b/clippy_lints/src/if_let_mutex.rs
@@ -129,7 +129,7 @@ fn is_mutex_lock_call<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Opt
     if_chain! {
         if let ExprKind::MethodCall(path, [self_arg, ..], _) = &expr.kind;
         if path.ident.as_str() == "lock";
-        let ty = cx.typeck_results().expr_ty(self_arg);
+        let ty = cx.typeck_results().expr_ty(self_arg).peel_refs();
         if is_type_diagnostic_item(cx, ty, sym::Mutex);
         then {
             Some(self_arg)
diff --git a/tests/ui/if_let_mutex.rs b/tests/ui/if_let_mutex.rs
index 6cbfafbb38b..321feb0224e 100644
--- a/tests/ui/if_let_mutex.rs
+++ b/tests/ui/if_let_mutex.rs
@@ -39,4 +39,12 @@ fn if_let_different_mutex() {
     };
 }
 
+fn mutex_ref(mutex: &Mutex<i32>) {
+    if let Ok(i) = mutex.lock() {
+        do_stuff(i);
+    } else {
+        let _x = mutex.lock();
+    };
+}
+
 fn main() {}
diff --git a/tests/ui/if_let_mutex.stderr b/tests/ui/if_let_mutex.stderr
index e9c4d916332..a831090c1f9 100644
--- a/tests/ui/if_let_mutex.stderr
+++ b/tests/ui/if_let_mutex.stderr
@@ -25,5 +25,17 @@ LL | |     };
    |
    = help: move the lock call outside of the `if let ...` expression
 
-error: aborting due to 2 previous errors
+error: calling `Mutex::lock` inside the scope of another `Mutex::lock` causes a deadlock
+  --> $DIR/if_let_mutex.rs:43:5
+   |
+LL | /     if let Ok(i) = mutex.lock() {
+LL | |         do_stuff(i);
+LL | |     } else {
+LL | |         let _x = mutex.lock();
+LL | |     };
+   | |_____^
+   |
+   = help: move the lock call outside of the `if let ...` expression
+
+error: aborting due to 3 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 0428f0d234319649ce7b7d1571ec169d58a6642e Mon Sep 17 00:00:00 2001
From: Lukas Lueg <lukas.lueg@gmail.com>
Date: Wed, 10 Aug 2022 20:56:44 +0200
Subject: Add labels to if_let_mutex

---
 clippy_lints/src/if_let_mutex.rs | 48 +++++++++++++++++++++-------------------
 tests/ui/if_let_mutex.stderr     | 18 ++++++++++++---
 2 files changed, 40 insertions(+), 26 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/if_let_mutex.rs b/clippy_lints/src/if_let_mutex.rs
index 7c12a638529..b6f9fefdee9 100644
--- a/clippy_lints/src/if_let_mutex.rs
+++ b/clippy_lints/src/if_let_mutex.rs
@@ -1,8 +1,9 @@
-use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::higher;
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::SpanlessEq;
 use if_chain::if_chain;
+use rustc_errors::Diagnostic;
 use rustc_hir::intravisit::{self as visit, Visitor};
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
@@ -45,16 +46,8 @@ declare_lint_pass!(IfLetMutex => [IF_LET_MUTEX]);
 
 impl<'tcx> LateLintPass<'tcx> for IfLetMutex {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
-        let mut arm_visit = ArmVisitor {
-            mutex_lock_called: false,
-            found_mutex: None,
-            cx,
-        };
-        let mut op_visit = OppVisitor {
-            mutex_lock_called: false,
-            found_mutex: None,
-            cx,
-        };
+        let mut arm_visit = ArmVisitor { found_mutex: None, cx };
+        let mut op_visit = OppVisitor { found_mutex: None, cx };
         if let Some(higher::IfLet {
             let_expr,
             if_then,
@@ -63,18 +56,28 @@ impl<'tcx> LateLintPass<'tcx> for IfLetMutex {
         }) = higher::IfLet::hir(cx, expr)
         {
             op_visit.visit_expr(let_expr);
-            if op_visit.mutex_lock_called {
+            if let Some(op_mutex) = op_visit.found_mutex {
                 arm_visit.visit_expr(if_then);
                 arm_visit.visit_expr(if_else);
 
-                if arm_visit.mutex_lock_called && arm_visit.same_mutex(cx, op_visit.found_mutex.unwrap()) {
-                    span_lint_and_help(
+                if let Some(arm_mutex) = arm_visit.found_mutex_if_same_as(op_mutex) {
+                    let diag = |diag: &mut Diagnostic| {
+                        diag.span_label(
+                            op_mutex.span,
+                            "This Mutex will remain locked for the entire `if let`-block...",
+                        );
+                        diag.span_label(
+                            arm_mutex.span,
+                            "... and is tried to lock again here, which will always deadlock.",
+                        );
+                        diag.help("move the lock call outside of the `if let ...` expression");
+                    };
+                    span_lint_and_then(
                         cx,
                         IF_LET_MUTEX,
                         expr.span,
                         "calling `Mutex::lock` inside the scope of another `Mutex::lock` causes a deadlock",
-                        None,
-                        "move the lock call outside of the `if let ...` expression",
+                        diag,
                     );
                 }
             }
@@ -84,7 +87,6 @@ impl<'tcx> LateLintPass<'tcx> for IfLetMutex {
 
 /// Checks if `Mutex::lock` is called in the `if let` expr.
 pub struct OppVisitor<'a, 'tcx> {
-    mutex_lock_called: bool,
     found_mutex: Option<&'tcx Expr<'tcx>>,
     cx: &'a LateContext<'tcx>,
 }
@@ -93,7 +95,6 @@ impl<'tcx> Visitor<'tcx> for OppVisitor<'_, 'tcx> {
     fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
         if let Some(mutex) = is_mutex_lock_call(self.cx, expr) {
             self.found_mutex = Some(mutex);
-            self.mutex_lock_called = true;
             return;
         }
         visit::walk_expr(self, expr);
@@ -102,7 +103,6 @@ impl<'tcx> Visitor<'tcx> for OppVisitor<'_, 'tcx> {
 
 /// Checks if `Mutex::lock` is called in any of the branches.
 pub struct ArmVisitor<'a, 'tcx> {
-    mutex_lock_called: bool,
     found_mutex: Option<&'tcx Expr<'tcx>>,
     cx: &'a LateContext<'tcx>,
 }
@@ -111,7 +111,6 @@ impl<'tcx> Visitor<'tcx> for ArmVisitor<'_, 'tcx> {
     fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) {
         if let Some(mutex) = is_mutex_lock_call(self.cx, expr) {
             self.found_mutex = Some(mutex);
-            self.mutex_lock_called = true;
             return;
         }
         visit::walk_expr(self, expr);
@@ -119,9 +118,12 @@ impl<'tcx> Visitor<'tcx> for ArmVisitor<'_, 'tcx> {
 }
 
 impl<'tcx, 'l> ArmVisitor<'tcx, 'l> {
-    fn same_mutex(&self, cx: &LateContext<'_>, op_mutex: &Expr<'_>) -> bool {
-        self.found_mutex
-            .map_or(false, |arm_mutex| SpanlessEq::new(cx).eq_expr(op_mutex, arm_mutex))
+    fn found_mutex_if_same_as(&self, op_mutex: &Expr<'_>) -> Option<&Expr<'_>> {
+        self.found_mutex.and_then(|arm_mutex| {
+            SpanlessEq::new(self.cx)
+                .eq_expr(op_mutex, arm_mutex)
+                .then_some(arm_mutex)
+        })
     }
 }
 
diff --git a/tests/ui/if_let_mutex.stderr b/tests/ui/if_let_mutex.stderr
index a831090c1f9..6dbfc4be412 100644
--- a/tests/ui/if_let_mutex.stderr
+++ b/tests/ui/if_let_mutex.stderr
@@ -1,10 +1,14 @@
 error: calling `Mutex::lock` inside the scope of another `Mutex::lock` causes a deadlock
   --> $DIR/if_let_mutex.rs:10:5
    |
-LL | /     if let Err(locked) = m.lock() {
+LL |       if let Err(locked) = m.lock() {
+   |       ^                    - This Mutex will remain locked for the entire `if let`-block...
+   |  _____|
+   | |
 LL | |         do_stuff(locked);
 LL | |     } else {
 LL | |         let lock = m.lock().unwrap();
+   | |                    - ... and is tried to lock again here, which will always deadlock.
 LL | |         do_stuff(lock);
 LL | |     };
    | |_____^
@@ -15,10 +19,14 @@ LL | |     };
 error: calling `Mutex::lock` inside the scope of another `Mutex::lock` causes a deadlock
   --> $DIR/if_let_mutex.rs:22:5
    |
-LL | /     if let Some(locked) = m.lock().unwrap().deref() {
+LL |       if let Some(locked) = m.lock().unwrap().deref() {
+   |       ^                     - This Mutex will remain locked for the entire `if let`-block...
+   |  _____|
+   | |
 LL | |         do_stuff(locked);
 LL | |     } else {
 LL | |         let lock = m.lock().unwrap();
+   | |                    - ... and is tried to lock again here, which will always deadlock.
 LL | |         do_stuff(lock);
 LL | |     };
    | |_____^
@@ -28,10 +36,14 @@ LL | |     };
 error: calling `Mutex::lock` inside the scope of another `Mutex::lock` causes a deadlock
   --> $DIR/if_let_mutex.rs:43:5
    |
-LL | /     if let Ok(i) = mutex.lock() {
+LL |       if let Ok(i) = mutex.lock() {
+   |       ^              ----- This Mutex will remain locked for the entire `if let`-block...
+   |  _____|
+   | |
 LL | |         do_stuff(i);
 LL | |     } else {
 LL | |         let _x = mutex.lock();
+   | |                  ----- ... and is tried to lock again here, which will always deadlock.
 LL | |     };
    | |_____^
    |
-- 
cgit 1.4.1-3-g733a5


From 459821b1914248180cac691128dd35d945bfde88 Mon Sep 17 00:00:00 2001
From: tamaron <tamaron1203@gmail.com>
Date: Sat, 2 Jul 2022 12:57:57 +0900
Subject: fix

---
 clippy_lints/src/matches/needless_match.rs |  4 +++-
 tests/ui/needless_match.fixed              | 26 +++++++++++++++++++++++
 tests/ui/needless_match.rs                 | 33 ++++++++++++++++++++++++++++++
 tests/ui/needless_match.stderr             | 23 ++++++++++++++++++++-
 4 files changed, 84 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/needless_match.rs b/clippy_lints/src/matches/needless_match.rs
index fa19cddd35e..53a4a91d0e7 100644
--- a/clippy_lints/src/matches/needless_match.rs
+++ b/clippy_lints/src/matches/needless_match.rs
@@ -66,7 +66,9 @@ fn check_all_arms(cx: &LateContext<'_>, match_expr: &Expr<'_>, arms: &[Arm<'_>])
     for arm in arms {
         let arm_expr = peel_blocks_with_stmt(arm.body);
         if let PatKind::Wild = arm.pat.kind {
-            return eq_expr_value(cx, match_expr, strip_return(arm_expr));
+            if !eq_expr_value(cx, match_expr, strip_return(arm_expr)) {
+                return false;
+            }
         } else if !pat_same_as_expr(arm.pat, arm_expr) {
             return false;
         }
diff --git a/tests/ui/needless_match.fixed b/tests/ui/needless_match.fixed
index 0c9178fb85e..9d4427f1df2 100644
--- a/tests/ui/needless_match.fixed
+++ b/tests/ui/needless_match.fixed
@@ -207,4 +207,30 @@ impl Tr for Result<i32, i32> {
     }
 }
 
+mod issue9084 {
+    fn wildcard_if() {
+        let some_bool = true;
+        let e = Some(1);
+
+        // should lint
+        let _ = e;
+
+        // should lint
+        let _ = e;
+
+        // should not lint
+        let _ = match e {
+            _ if some_bool => e,
+            _ => Some(2),
+        };
+
+        // should not lint
+        let _ = match e {
+            Some(i) => Some(i + 1),
+            _ if some_bool => e,
+            _ => e,
+        };
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/needless_match.rs b/tests/ui/needless_match.rs
index f66f01d7cca..cae850fb059 100644
--- a/tests/ui/needless_match.rs
+++ b/tests/ui/needless_match.rs
@@ -244,4 +244,37 @@ impl Tr for Result<i32, i32> {
     }
 }
 
+mod issue9084 {
+    fn wildcard_if() {
+        let some_bool = true;
+        let e = Some(1);
+
+        // should lint
+        let _ = match e {
+            _ if some_bool => e,
+            _ => e,
+        };
+
+        // should lint
+        let _ = match e {
+            Some(i) => Some(i),
+            _ if some_bool => e,
+            _ => e,
+        };
+
+        // should not lint
+        let _ = match e {
+            _ if some_bool => e,
+            _ => Some(2),
+        };
+
+        // should not lint
+        let _ = match e {
+            Some(i) => Some(i + 1),
+            _ if some_bool => e,
+            _ => e,
+        };
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/needless_match.stderr b/tests/ui/needless_match.stderr
index 5bc79800a1a..a173bbe4d77 100644
--- a/tests/ui/needless_match.stderr
+++ b/tests/ui/needless_match.stderr
@@ -109,5 +109,26 @@ LL | |             Complex::D(E::VariantB(ea, eb), b) => Complex::D(E::VariantB(
 LL | |         };
    | |_________^ help: replace it with: `ce`
 
-error: aborting due to 11 previous errors
+error: this match expression is unnecessary
+  --> $DIR/needless_match.rs:252:17
+   |
+LL |           let _ = match e {
+   |  _________________^
+LL | |             _ if some_bool => e,
+LL | |             _ => e,
+LL | |         };
+   | |_________^ help: replace it with: `e`
+
+error: this match expression is unnecessary
+  --> $DIR/needless_match.rs:258:17
+   |
+LL |           let _ = match e {
+   |  _________________^
+LL | |             Some(i) => Some(i),
+LL | |             _ if some_bool => e,
+LL | |             _ => e,
+LL | |         };
+   | |_________^ help: replace it with: `e`
+
+error: aborting due to 13 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 45084eeefb4edb981ce437c7fee6a07e61ff224b Mon Sep 17 00:00:00 2001
From: tamaron <tamaron1203@gmail.com>
Date: Thu, 11 Aug 2022 12:00:46 +0900
Subject: give up when gurad has side effects

---
 clippy_lints/src/matches/needless_match.rs | 18 +++++++++++++++++-
 tests/ui/needless_match.fixed              | 15 ++++++++++++++-
 tests/ui/needless_match.rs                 | 15 ++++++++++++++-
 3 files changed, 45 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/needless_match.rs b/clippy_lints/src/matches/needless_match.rs
index 53a4a91d0e7..6f037339ec7 100644
--- a/clippy_lints/src/matches/needless_match.rs
+++ b/clippy_lints/src/matches/needless_match.rs
@@ -8,7 +8,7 @@ use clippy_utils::{
 };
 use rustc_errors::Applicability;
 use rustc_hir::LangItem::OptionNone;
-use rustc_hir::{Arm, BindingAnnotation, Expr, ExprKind, FnRetTy, Node, Pat, PatKind, Path, QPath};
+use rustc_hir::{Arm, BindingAnnotation, Expr, ExprKind, FnRetTy, Guard, Node, Pat, PatKind, Path, QPath};
 use rustc_lint::LateContext;
 use rustc_span::sym;
 use rustc_typeck::hir_ty_to_ty;
@@ -65,6 +65,22 @@ pub(crate) fn check_if_let<'tcx>(cx: &LateContext<'tcx>, ex: &Expr<'_>, if_let:
 fn check_all_arms(cx: &LateContext<'_>, match_expr: &Expr<'_>, arms: &[Arm<'_>]) -> bool {
     for arm in arms {
         let arm_expr = peel_blocks_with_stmt(arm.body);
+
+        if let Some(guard_expr) = &arm.guard {
+            match guard_expr {
+                // gives up if `pat if expr` can have side effects
+                Guard::If(if_cond) => {
+                    if if_cond.can_have_side_effects() {
+                        return false;
+                    }
+                },
+                // gives up `pat if let ...` arm
+                Guard::IfLet(_) => {
+                    return false;
+                },
+            };
+        }
+
         if let PatKind::Wild = arm.pat.kind {
             if !eq_expr_value(cx, match_expr, strip_return(arm_expr)) {
                 return false;
diff --git a/tests/ui/needless_match.fixed b/tests/ui/needless_match.fixed
index 9d4427f1df2..7e47406798c 100644
--- a/tests/ui/needless_match.fixed
+++ b/tests/ui/needless_match.fixed
@@ -209,7 +209,7 @@ impl Tr for Result<i32, i32> {
 
 mod issue9084 {
     fn wildcard_if() {
-        let some_bool = true;
+        let mut some_bool = true;
         let e = Some(1);
 
         // should lint
@@ -230,6 +230,19 @@ mod issue9084 {
             _ if some_bool => e,
             _ => e,
         };
+
+        // should not lint (guard has side effects)
+        let _ = match e {
+            Some(i) => Some(i),
+            _ if {
+                some_bool = false;
+                some_bool
+            } =>
+            {
+                e
+            },
+            _ => e,
+        };
     }
 }
 
diff --git a/tests/ui/needless_match.rs b/tests/ui/needless_match.rs
index cae850fb059..809c694bf40 100644
--- a/tests/ui/needless_match.rs
+++ b/tests/ui/needless_match.rs
@@ -246,7 +246,7 @@ impl Tr for Result<i32, i32> {
 
 mod issue9084 {
     fn wildcard_if() {
-        let some_bool = true;
+        let mut some_bool = true;
         let e = Some(1);
 
         // should lint
@@ -274,6 +274,19 @@ mod issue9084 {
             _ if some_bool => e,
             _ => e,
         };
+
+        // should not lint (guard has side effects)
+        let _ = match e {
+            Some(i) => Some(i),
+            _ if {
+                some_bool = false;
+                some_bool
+            } =>
+            {
+                e
+            },
+            _ => e,
+        };
     }
 }
 
-- 
cgit 1.4.1-3-g733a5


From f7f60b82e8d9ce281f67cef8b95019482ff47298 Mon Sep 17 00:00:00 2001
From: Michael Krasnitski <michael.krasnitski@gmail.com>
Date: Thu, 11 Aug 2022 22:41:25 -0400
Subject: Adjust lint description for better clarity

---
 clippy_lints/src/if_then_some_else_none.rs | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/if_then_some_else_none.rs b/clippy_lints/src/if_then_some_else_none.rs
index 20fcba90773..11c43247868 100644
--- a/clippy_lints/src/if_then_some_else_none.rs
+++ b/clippy_lints/src/if_then_some_else_none.rs
@@ -11,10 +11,12 @@ use rustc_session::{declare_tool_lint, impl_lint_pass};
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for if-else that could be written to `bool::then`.
+    /// Checks for if-else that could be written using either `bool::then` or `bool::then_some`.
     ///
     /// ### Why is this bad?
-    /// Looks a little redundant. Using `bool::then` helps it have less lines of code.
+    /// Looks a little redundant. Using `bool::then` is more concise and incurs no loss of clarity.
+    /// For simple calculations and known values, use `bool::then_some`, which is eagerly evaluated
+    /// in comparison to `bool::then`.
     ///
     /// ### Example
     /// ```rust
@@ -39,7 +41,7 @@ declare_clippy_lint! {
     #[clippy::version = "1.53.0"]
     pub IF_THEN_SOME_ELSE_NONE,
     restriction,
-    "Finds if-else that could be written using `bool::then`"
+    "Finds if-else that could be written using either `bool::then` or `bool::then_some`"
 }
 
 pub struct IfThenSomeElseNone {
-- 
cgit 1.4.1-3-g733a5


From 8bae517c2d540dcf62bff12ba7404a23a4233d99 Mon Sep 17 00:00:00 2001
From: Allen Hsu <allen.hsusp+git@gmail.com>
Date: Fri, 12 Aug 2022 12:51:58 +1000
Subject: Lint trait duplication in one pass.

---
 clippy_lints/src/trait_bounds.rs                   | 55 ++++++++--------------
 .../trait_duplication_in_bounds_unfixable.stderr   |  8 ++--
 2 files changed, 23 insertions(+), 40 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/trait_bounds.rs b/clippy_lints/src/trait_bounds.rs
index 537e6eafb17..0434720f79b 100644
--- a/clippy_lints/src/trait_bounds.rs
+++ b/clippy_lints/src/trait_bounds.rs
@@ -103,7 +103,6 @@ impl<'tcx> LateLintPass<'tcx> for TraitBounds {
     fn check_generics(&mut self, cx: &LateContext<'tcx>, gen: &'tcx Generics<'_>) {
         self.check_type_repetition(cx, gen);
         check_trait_bound_duplication(cx, gen);
-        check_bounds_or_where_duplication(cx, gen);
     }
 
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
@@ -234,7 +233,7 @@ impl TraitBounds {
 }
 
 fn check_trait_bound_duplication(cx: &LateContext<'_>, gen: &'_ Generics<'_>) {
-    if gen.span.from_expansion() || gen.params.is_empty() || gen.predicates.is_empty() {
+    if gen.span.from_expansion() {
         return;
     }
 
@@ -254,9 +253,9 @@ fn check_trait_bound_duplication(cx: &LateContext<'_>, gen: &'_ Generics<'_>) {
                 if let WherePredicate::BoundPredicate(bound_predicate) = pred;
                 if let TyKind::Path(QPath::Resolved(_, path)) =  bound_predicate.bounded_ty.kind;
                 then {
-                    return Some(bound_predicate.bounds.iter().filter_map(|t| {
-                        Some((path.res, into_comparable_trait_ref(t.trait_ref()?)))
-                    }))
+                    return Some(
+                        rollup_traits(cx, bound_predicate.bounds, "these where clauses contain repeated elements")
+                        .into_keys().map(|trait_ref| (path.res, trait_ref)))
                 }
             }
             None
@@ -277,19 +276,18 @@ fn check_trait_bound_duplication(cx: &LateContext<'_>, gen: &'_ Generics<'_>) {
             if !bound_predicate.span.from_expansion();
             if let TyKind::Path(QPath::Resolved(_, path)) =  bound_predicate.bounded_ty.kind;
             then {
-                for t in bound_predicate.bounds {
-                    if let Some(trait_ref) = t.trait_ref() {
-                        let key = (path.res, into_comparable_trait_ref(trait_ref));
-                        if where_predicates.contains(&key) {
-                            span_lint_and_help(
-                                cx,
-                                TRAIT_DUPLICATION_IN_BOUNDS,
-                                t.span(),
-                                "this trait bound is already specified in the where clause",
-                                None,
-                                "consider removing this trait bound",
-                                );
-                        }
+                let traits = rollup_traits(cx, bound_predicate.bounds, "these bounds contain repeated elements");
+                for (trait_ref, span) in traits {
+                    let key = (path.res, trait_ref);
+                    if where_predicates.contains(&key) {
+                        span_lint_and_help(
+                            cx,
+                            TRAIT_DUPLICATION_IN_BOUNDS,
+                            span,
+                            "this trait bound is already specified in the where clause",
+                            None,
+                            "consider removing this trait bound",
+                            );
                     }
                 }
             }
@@ -300,23 +298,6 @@ fn check_trait_bound_duplication(cx: &LateContext<'_>, gen: &'_ Generics<'_>) {
 #[derive(PartialEq, Eq, Hash, Debug)]
 struct ComparableTraitRef(Res, Vec<Res>);
 
-fn check_bounds_or_where_duplication(cx: &LateContext<'_>, gen: &'_ Generics<'_>) {
-    if gen.span.from_expansion() {
-        return;
-    }
-
-    for predicate in gen.predicates {
-        if let WherePredicate::BoundPredicate(ref bound_predicate) = predicate {
-            let msg = if predicate.in_where_clause() {
-                "these where clauses contain repeated elements"
-            } else {
-                "these bounds contain repeated elements"
-            };
-            rollup_traits(cx, bound_predicate.bounds, msg);
-        }
-    }
-}
-
 fn get_trait_info_from_bound<'a>(bound: &'a GenericBound<'_>) -> Option<(Res, &'a [PathSegment<'a>], Span)> {
     if let GenericBound::Trait(t, tbm) = bound {
         let trait_path = t.trait_ref.path;
@@ -358,7 +339,7 @@ fn into_comparable_trait_ref(trait_ref: &TraitRef<'_>) -> ComparableTraitRef {
     )
 }
 
-fn rollup_traits(cx: &LateContext<'_>, bounds: &[GenericBound<'_>], msg: &str) {
+fn rollup_traits(cx: &LateContext<'_>, bounds: &[GenericBound<'_>], msg: &str) -> FxHashMap<ComparableTraitRef, Span> {
     let mut map = FxHashMap::default();
     let mut repeated_res = false;
 
@@ -400,4 +381,6 @@ fn rollup_traits(cx: &LateContext<'_>, bounds: &[GenericBound<'_>], msg: &str) {
             );
         }
     }
+
+    map
 }
diff --git a/tests/ui/trait_duplication_in_bounds_unfixable.stderr b/tests/ui/trait_duplication_in_bounds_unfixable.stderr
index fbd9abb005f..aa44114eb6c 100644
--- a/tests/ui/trait_duplication_in_bounds_unfixable.stderr
+++ b/tests/ui/trait_duplication_in_bounds_unfixable.stderr
@@ -1,8 +1,8 @@
 error: this trait bound is already specified in the where clause
-  --> $DIR/trait_duplication_in_bounds_unfixable.rs:6:15
+  --> $DIR/trait_duplication_in_bounds_unfixable.rs:6:23
    |
 LL | fn bad_foo<T: Clone + Default, Z: Copy>(arg0: T, arg1: Z)
-   |               ^^^^^
+   |                       ^^^^^^^
    |
 note: the lint level is defined here
   --> $DIR/trait_duplication_in_bounds_unfixable.rs:1:9
@@ -12,10 +12,10 @@ LL | #![deny(clippy::trait_duplication_in_bounds)]
    = help: consider removing this trait bound
 
 error: this trait bound is already specified in the where clause
-  --> $DIR/trait_duplication_in_bounds_unfixable.rs:6:23
+  --> $DIR/trait_duplication_in_bounds_unfixable.rs:6:15
    |
 LL | fn bad_foo<T: Clone + Default, Z: Copy>(arg0: T, arg1: Z)
-   |                       ^^^^^^^
+   |               ^^^^^
    |
    = help: consider removing this trait bound
 
-- 
cgit 1.4.1-3-g733a5


From f18cd274be3595c5b065fdba2b75ce9e8adc6c25 Mon Sep 17 00:00:00 2001
From: flip1995 <hello@philkrones.com>
Date: Fri, 12 Aug 2022 23:19:53 +0200
Subject: Update lint versions for 1.63 release

---
 clippy_lints/src/borrow_deref_ref.rs             | 2 +-
 clippy_lints/src/doc_link_with_quotes.rs         | 2 +-
 clippy_lints/src/duplicate_mod.rs                | 2 +-
 clippy_lints/src/methods/mod.rs                  | 2 +-
 clippy_lints/src/mismatching_type_param_order.rs | 2 +-
 clippy_lints/src/rc_clone_in_vec_init.rs         | 2 +-
 clippy_lints/src/unused_rounding.rs              | 2 +-
 7 files changed, 7 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/borrow_deref_ref.rs b/clippy_lints/src/borrow_deref_ref.rs
index 937765b6614..e65b67c655e 100644
--- a/clippy_lints/src/borrow_deref_ref.rs
+++ b/clippy_lints/src/borrow_deref_ref.rs
@@ -44,7 +44,7 @@ declare_clippy_lint! {
     /// let a: &String = s;
     /// foo(&**s);
     /// ```
-    #[clippy::version = "1.59.0"]
+    #[clippy::version = "1.63.0"]
     pub BORROW_DEREF_REF,
     complexity,
     "deref on an immutable reference returns the same type as itself"
diff --git a/clippy_lints/src/doc_link_with_quotes.rs b/clippy_lints/src/doc_link_with_quotes.rs
index cb07f57e870..0ff1d2755da 100644
--- a/clippy_lints/src/doc_link_with_quotes.rs
+++ b/clippy_lints/src/doc_link_with_quotes.rs
@@ -21,7 +21,7 @@ declare_clippy_lint! {
     /// /// See also: [`foo`]
     /// fn bar() {}
     /// ```
-    #[clippy::version = "1.60.0"]
+    #[clippy::version = "1.63.0"]
     pub DOC_LINK_WITH_QUOTES,
     pedantic,
     "possible typo for an intra-doc link"
diff --git a/clippy_lints/src/duplicate_mod.rs b/clippy_lints/src/duplicate_mod.rs
index e1eb3b6324c..7ff7068f0b0 100644
--- a/clippy_lints/src/duplicate_mod.rs
+++ b/clippy_lints/src/duplicate_mod.rs
@@ -39,7 +39,7 @@ declare_clippy_lint! {
     /// // a.rs
     /// use crate::b;
     /// ```
-    #[clippy::version = "1.62.0"]
+    #[clippy::version = "1.63.0"]
     pub DUPLICATE_MOD,
     suspicious,
     "file loaded as module multiple times"
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 5ac6b09f0aa..b8dba5ba165 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -2269,7 +2269,7 @@ declare_clippy_lint! {
     /// "1234".replace("12", "12");
     /// "1234".replacen("12", "12", 1);
     /// ```
-    #[clippy::version = "1.62.0"]
+    #[clippy::version = "1.63.0"]
     pub NO_EFFECT_REPLACE,
     suspicious,
     "replace with no effect"
diff --git a/clippy_lints/src/mismatching_type_param_order.rs b/clippy_lints/src/mismatching_type_param_order.rs
index f763e0d24c9..020efeaebf0 100644
--- a/clippy_lints/src/mismatching_type_param_order.rs
+++ b/clippy_lints/src/mismatching_type_param_order.rs
@@ -40,7 +40,7 @@ declare_clippy_lint! {
     /// }
     /// impl<A, B> Foo<A, B> {}
     /// ```
-    #[clippy::version = "1.62.0"]
+    #[clippy::version = "1.63.0"]
     pub MISMATCHING_TYPE_PARAM_ORDER,
     pedantic,
     "type parameter positioned inconsistently between type def and impl block"
diff --git a/clippy_lints/src/rc_clone_in_vec_init.rs b/clippy_lints/src/rc_clone_in_vec_init.rs
index 8db8c4e9b78..e82aa3a7b98 100644
--- a/clippy_lints/src/rc_clone_in_vec_init.rs
+++ b/clippy_lints/src/rc_clone_in_vec_init.rs
@@ -41,7 +41,7 @@ declare_clippy_lint! {
     /// let data = std::rc::Rc::new("some data".to_string());
     /// let v = vec![data; 100];
     /// ```
-    #[clippy::version = "1.62.0"]
+    #[clippy::version = "1.63.0"]
     pub RC_CLONE_IN_VEC_INIT,
     suspicious,
     "initializing reference-counted pointer in `vec![elem; len]`"
diff --git a/clippy_lints/src/unused_rounding.rs b/clippy_lints/src/unused_rounding.rs
index 306afe44148..72d8a4431fd 100644
--- a/clippy_lints/src/unused_rounding.rs
+++ b/clippy_lints/src/unused_rounding.rs
@@ -22,7 +22,7 @@ declare_clippy_lint! {
     /// ```rust
     /// let x = 1f32;
     /// ```
-    #[clippy::version = "1.62.0"]
+    #[clippy::version = "1.63.0"]
     pub UNUSED_ROUNDING,
     nursery,
     "Uselessly rounding a whole number floating-point literal"
-- 
cgit 1.4.1-3-g733a5


From 80826c3944df4233fd532ee8cf465851dfe1b0fc Mon Sep 17 00:00:00 2001
From: Guilherme-Vasconcelos
 <49197151+Guilherme-Vasconcelos@users.noreply.github.com>
Date: Sun, 17 Jul 2022 21:20:51 -0300
Subject: Implement clippy::manual_empty_string_creations lint

---
 CHANGELOG.md                                      |   1 +
 clippy_lints/src/lib.register_all.rs              |   1 +
 clippy_lints/src/lib.register_lints.rs            |   1 +
 clippy_lints/src/lib.register_style.rs            |   1 +
 clippy_lints/src/lib.rs                           |   2 +
 clippy_lints/src/manual_empty_string_creations.rs | 141 ++++++++++++++++++++++
 clippy_utils/src/msrvs.rs                         |   2 +-
 tests/ui/manual_empty_string_creations.fixed      |  63 ++++++++++
 tests/ui/manual_empty_string_creations.rs         |  63 ++++++++++
 tests/ui/manual_empty_string_creations.stderr     |  58 +++++++++
 10 files changed, 332 insertions(+), 1 deletion(-)
 create mode 100644 clippy_lints/src/manual_empty_string_creations.rs
 create mode 100644 tests/ui/manual_empty_string_creations.fixed
 create mode 100644 tests/ui/manual_empty_string_creations.rs
 create mode 100644 tests/ui/manual_empty_string_creations.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index d74ec71a0e8..eedbe10320d 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3828,6 +3828,7 @@ Released 2018-09-13
 [`manual_assert`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_assert
 [`manual_async_fn`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_async_fn
 [`manual_bits`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_bits
+[`manual_empty_string_creations`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_empty_string_creations
 [`manual_filter_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_filter_map
 [`manual_find`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_find
 [`manual_find_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_find_map
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 01082cc8eeb..e253f656b0d 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -124,6 +124,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(main_recursion::MAIN_RECURSION),
     LintId::of(manual_async_fn::MANUAL_ASYNC_FN),
     LintId::of(manual_bits::MANUAL_BITS),
+    LintId::of(manual_empty_string_creations::MANUAL_EMPTY_STRING_CREATIONS),
     LintId::of(manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE),
     LintId::of(manual_rem_euclid::MANUAL_REM_EUCLID),
     LintId::of(manual_retain::MANUAL_RETAIN),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index c540573b802..29d923a0d8d 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -244,6 +244,7 @@ store.register_lints(&[
     manual_assert::MANUAL_ASSERT,
     manual_async_fn::MANUAL_ASYNC_FN,
     manual_bits::MANUAL_BITS,
+    manual_empty_string_creations::MANUAL_EMPTY_STRING_CREATIONS,
     manual_instant_elapsed::MANUAL_INSTANT_ELAPSED,
     manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE,
     manual_ok_or::MANUAL_OK_OR,
diff --git a/clippy_lints/src/lib.register_style.rs b/clippy_lints/src/lib.register_style.rs
index bfa654238f1..6972c75597a 100644
--- a/clippy_lints/src/lib.register_style.rs
+++ b/clippy_lints/src/lib.register_style.rs
@@ -44,6 +44,7 @@ store.register_group(true, "clippy::style", Some("clippy_style"), vec![
     LintId::of(main_recursion::MAIN_RECURSION),
     LintId::of(manual_async_fn::MANUAL_ASYNC_FN),
     LintId::of(manual_bits::MANUAL_BITS),
+    LintId::of(manual_empty_string_creations::MANUAL_EMPTY_STRING_CREATIONS),
     LintId::of(manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE),
     LintId::of(map_clone::MAP_CLONE),
     LintId::of(match_result_ok::MATCH_RESULT_OK),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index e6a405f8170..4201cd9c0bf 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -273,6 +273,7 @@ mod main_recursion;
 mod manual_assert;
 mod manual_async_fn;
 mod manual_bits;
+mod manual_empty_string_creations;
 mod manual_instant_elapsed;
 mod manual_non_exhaustive;
 mod manual_ok_or;
@@ -933,6 +934,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(std_instead_of_core::StdReexports::default()));
     store.register_late_pass(|| Box::new(manual_instant_elapsed::ManualInstantElapsed));
     store.register_late_pass(|| Box::new(partialeq_to_none::PartialeqToNone));
+    store.register_late_pass(|| Box::new(manual_empty_string_creations::ManualEmptyStringCreations));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/manual_empty_string_creations.rs b/clippy_lints/src/manual_empty_string_creations.rs
new file mode 100644
index 00000000000..dd602a89b4f
--- /dev/null
+++ b/clippy_lints/src/manual_empty_string_creations.rs
@@ -0,0 +1,141 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use rustc_ast::LitKind;
+use rustc_errors::Applicability::MachineApplicable;
+use rustc_hir::{Expr, ExprKind, PathSegment, QPath, TyKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::{sym, symbol, Span};
+
+declare_clippy_lint! {
+    /// ### What it does
+    ///
+    /// Checks for usage of `""` to create a `String`, such as `"".to_string()`, `"".to_owned()`,
+    /// `String::from("")` and others.
+    ///
+    /// ### Why is this bad?
+    ///
+    /// Different ways of creating an empty string makes your code less standardized, which can
+    /// be confusing.
+    ///
+    /// ### Example
+    /// ```rust
+    /// let a = "".to_string();
+    /// let b: String = "".into();
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// let a = String::new();
+    /// let b = String::new();
+    /// ```
+    #[clippy::version = "1.65.0"]
+    pub MANUAL_EMPTY_STRING_CREATIONS,
+    style,
+    "empty String is being created manually"
+}
+declare_lint_pass!(ManualEmptyStringCreations => [MANUAL_EMPTY_STRING_CREATIONS]);
+
+impl LateLintPass<'_> for ManualEmptyStringCreations {
+    fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
+        if expr.span.from_expansion() {
+            return;
+        }
+
+        let ty = cx.typeck_results().expr_ty(expr);
+        match ty.kind() {
+            ty::Adt(adt_def, _) if adt_def.is_struct() => {
+                if !cx.tcx.is_diagnostic_item(sym::String, adt_def.did()) {
+                    return;
+                }
+            },
+            _ => return,
+        }
+
+        match expr.kind {
+            ExprKind::Call(func, args) => {
+                parse_call(cx, expr.span, func, args);
+            },
+            ExprKind::MethodCall(path_segment, args, _) => {
+                parse_method_call(cx, expr.span, path_segment, args);
+            },
+            _ => (),
+        }
+    }
+}
+
+/// Checks if an expression's kind corresponds to an empty &str.
+fn is_expr_kind_empty_str(expr_kind: &ExprKind<'_>) -> bool {
+    if  let ExprKind::Lit(lit) = expr_kind &&
+        let LitKind::Str(value, _) = lit.node &&
+        value == symbol::kw::Empty
+    {
+        return true;
+    }
+
+    false
+}
+
+/// Emits the `MANUAL_EMPTY_STRING_CREATION` warning and suggests the appropriate fix.
+fn warn_then_suggest(cx: &LateContext<'_>, span: Span) {
+    span_lint_and_sugg(
+        cx,
+        MANUAL_EMPTY_STRING_CREATIONS,
+        span,
+        "empty String is being created manually",
+        "consider using",
+        "String::new()".into(),
+        MachineApplicable,
+    );
+}
+
+/// Tries to parse an expression as a method call, emiting the warning if necessary.
+fn parse_method_call(cx: &LateContext<'_>, span: Span, path_segment: &PathSegment<'_>, args: &[Expr<'_>]) {
+    if args.is_empty() {
+        // When parsing TryFrom::try_from(...).expect(...), we will have more than 1 arg.
+        return;
+    }
+
+    let ident = path_segment.ident.as_str();
+    let method_arg_kind = &args[0].kind;
+    if ["to_string", "to_owned", "into"].contains(&ident) && is_expr_kind_empty_str(method_arg_kind) {
+        warn_then_suggest(cx, span);
+    } else if let ExprKind::Call(func, args) = method_arg_kind {
+        // If our first argument is a function call itself, it could be an `unwrap`-like function.
+        // E.g. String::try_from("hello").unwrap(), TryFrom::try_from("").expect("hello"), etc.
+        parse_call(cx, span, func, args);
+    }
+}
+
+/// Tries to parse an expression as a function call, emiting the warning if necessary.
+fn parse_call(cx: &LateContext<'_>, span: Span, func: &Expr<'_>, args: &[Expr<'_>]) {
+    if args.len() != 1 {
+        return;
+    }
+
+    let arg_kind = &args[0].kind;
+    if let ExprKind::Path(qpath) = &func.kind {
+        if let QPath::TypeRelative(_, _) = qpath {
+            // String::from(...) or String::try_from(...)
+            if  let QPath::TypeRelative(ty, path_seg) = qpath &&
+                [sym::from, sym::try_from].contains(&path_seg.ident.name) &&
+                let TyKind::Path(qpath) = &ty.kind &&
+                let QPath::Resolved(_, path) = qpath &&
+                let [path_seg] = path.segments &&
+                path_seg.ident.name == sym::String &&
+                is_expr_kind_empty_str(arg_kind)
+            {
+                warn_then_suggest(cx, span);
+            }
+        } else if let QPath::Resolved(_, path) = qpath {
+            // From::from(...) or TryFrom::try_from(...)
+            if  let [path_seg1, path_seg2] = path.segments &&
+                is_expr_kind_empty_str(arg_kind) && (
+                    (path_seg1.ident.name == sym::From && path_seg2.ident.name == sym::from) ||
+                    (path_seg1.ident.name == sym::TryFrom && path_seg2.ident.name == sym::try_from)
+                )
+            {
+                warn_then_suggest(cx, span);
+            }
+        }
+    }
+}
diff --git a/clippy_utils/src/msrvs.rs b/clippy_utils/src/msrvs.rs
index 9e238c6f1ac..d539d11a39f 100644
--- a/clippy_utils/src/msrvs.rs
+++ b/clippy_utils/src/msrvs.rs
@@ -32,8 +32,8 @@ msrv_aliases! {
     1,30,0 { ITERATOR_FIND_MAP, TOOL_ATTRIBUTES }
     1,28,0 { FROM_BOOL }
     1,26,0 { RANGE_INCLUSIVE, STRING_RETAIN }
+    1,24,0 { IS_ASCII_DIGIT }
     1,18,0 { HASH_MAP_RETAIN, HASH_SET_RETAIN }
     1,17,0 { FIELD_INIT_SHORTHAND, STATIC_IN_CONST, EXPECT_ERR }
     1,16,0 { STR_REPEAT }
-    1,24,0 { IS_ASCII_DIGIT }
 }
diff --git a/tests/ui/manual_empty_string_creations.fixed b/tests/ui/manual_empty_string_creations.fixed
new file mode 100644
index 00000000000..3516312ee0c
--- /dev/null
+++ b/tests/ui/manual_empty_string_creations.fixed
@@ -0,0 +1,63 @@
+// run-rustfix
+
+#![warn(clippy::manual_empty_string_creations)]
+
+macro_rules! create_strings_from_macro {
+    // When inside a macro, nothing should warn to prevent false positives.
+    ($some_str:expr) => {
+        let _: String = $some_str.into();
+        let _ = $some_str.to_string();
+    }
+}
+
+fn main() {
+    // Method calls
+    let _ = String::new();
+    let _ = "no warning".to_string();
+
+    let _ = String::new();
+    let _ = "no warning".to_owned();
+
+    let _: String = String::new();
+    let _: String = "no warning".into();
+
+    let _: SomeOtherStruct = "no warning".into();
+    let _: SomeOtherStruct = "".into(); // No warning too. We are not converting into String.
+
+    // Calls
+    let _ = String::new();
+    let _ = String::new();
+    let _ = String::from("no warning");
+    let _ = SomeOtherStruct::from("no warning");
+    let _ = SomeOtherStruct::from(""); // Again: no warning.
+
+    let _ = String::new();
+    let _ = String::try_from("no warning").unwrap();
+    let _ = String::try_from("no warning").expect("this should not warn");
+    let _ = SomeOtherStruct::try_from("no warning").unwrap();
+    let _ = SomeOtherStruct::try_from("").unwrap(); // Again: no warning.
+
+    let _: String = String::new();
+    let _: String = From::from("no warning");
+    let _: SomeOtherStruct = From::from("no warning");
+    let _: SomeOtherStruct = From::from(""); // Again: no warning.
+
+    let _: String = String::new();
+    let _: String = TryFrom::try_from("no warning").unwrap();
+    let _: String = TryFrom::try_from("no warning").expect("this should not warn");
+    let _: String = String::new();
+    let _: SomeOtherStruct = TryFrom::try_from("no_warning").unwrap();
+    let _: SomeOtherStruct = TryFrom::try_from("").unwrap(); // Again: no warning.
+
+    // Macros (never warn)
+    create_strings_from_macro!("");
+    create_strings_from_macro!("Hey");
+}
+
+struct SomeOtherStruct {}
+
+impl From<&str> for SomeOtherStruct {
+    fn from(_value: &str) -> Self {
+        Self {}
+    }
+}
diff --git a/tests/ui/manual_empty_string_creations.rs b/tests/ui/manual_empty_string_creations.rs
new file mode 100644
index 00000000000..ed39a05ed5c
--- /dev/null
+++ b/tests/ui/manual_empty_string_creations.rs
@@ -0,0 +1,63 @@
+// run-rustfix
+
+#![warn(clippy::manual_empty_string_creations)]
+
+macro_rules! create_strings_from_macro {
+    // When inside a macro, nothing should warn to prevent false positives.
+    ($some_str:expr) => {
+        let _: String = $some_str.into();
+        let _ = $some_str.to_string();
+    };
+}
+
+fn main() {
+    // Method calls
+    let _ = "".to_string();
+    let _ = "no warning".to_string();
+
+    let _ = "".to_owned();
+    let _ = "no warning".to_owned();
+
+    let _: String = "".into();
+    let _: String = "no warning".into();
+
+    let _: SomeOtherStruct = "no warning".into();
+    let _: SomeOtherStruct = "".into(); // No warning too. We are not converting into String.
+
+    // Calls
+    let _ = String::from("");
+    let _ = <String>::from("");
+    let _ = String::from("no warning");
+    let _ = SomeOtherStruct::from("no warning");
+    let _ = SomeOtherStruct::from(""); // Again: no warning.
+
+    let _ = String::try_from("").unwrap();
+    let _ = String::try_from("no warning").unwrap();
+    let _ = String::try_from("no warning").expect("this should not warn");
+    let _ = SomeOtherStruct::try_from("no warning").unwrap();
+    let _ = SomeOtherStruct::try_from("").unwrap(); // Again: no warning.
+
+    let _: String = From::from("");
+    let _: String = From::from("no warning");
+    let _: SomeOtherStruct = From::from("no warning");
+    let _: SomeOtherStruct = From::from(""); // Again: no warning.
+
+    let _: String = TryFrom::try_from("").unwrap();
+    let _: String = TryFrom::try_from("no warning").unwrap();
+    let _: String = TryFrom::try_from("no warning").expect("this should not warn");
+    let _: String = TryFrom::try_from("").expect("this should warn");
+    let _: SomeOtherStruct = TryFrom::try_from("no_warning").unwrap();
+    let _: SomeOtherStruct = TryFrom::try_from("").unwrap(); // Again: no warning.
+
+    // Macros (never warn)
+    create_strings_from_macro!("");
+    create_strings_from_macro!("Hey");
+}
+
+struct SomeOtherStruct {}
+
+impl From<&str> for SomeOtherStruct {
+    fn from(_value: &str) -> Self {
+        Self {}
+    }
+}
diff --git a/tests/ui/manual_empty_string_creations.stderr b/tests/ui/manual_empty_string_creations.stderr
new file mode 100644
index 00000000000..f38ba02a508
--- /dev/null
+++ b/tests/ui/manual_empty_string_creations.stderr
@@ -0,0 +1,58 @@
+error: empty String is being created manually
+  --> $DIR/manual_empty_string_creations.rs:15:13
+   |
+LL |     let _ = "".to_string();
+   |             ^^^^^^^^^^^^^^ help: consider using: `String::new()`
+   |
+   = note: `-D clippy::manual-empty-string-creations` implied by `-D warnings`
+
+error: empty String is being created manually
+  --> $DIR/manual_empty_string_creations.rs:18:13
+   |
+LL |     let _ = "".to_owned();
+   |             ^^^^^^^^^^^^^ help: consider using: `String::new()`
+
+error: empty String is being created manually
+  --> $DIR/manual_empty_string_creations.rs:21:21
+   |
+LL |     let _: String = "".into();
+   |                     ^^^^^^^^^ help: consider using: `String::new()`
+
+error: empty String is being created manually
+  --> $DIR/manual_empty_string_creations.rs:28:13
+   |
+LL |     let _ = String::from("");
+   |             ^^^^^^^^^^^^^^^^ help: consider using: `String::new()`
+
+error: empty String is being created manually
+  --> $DIR/manual_empty_string_creations.rs:29:13
+   |
+LL |     let _ = <String>::from("");
+   |             ^^^^^^^^^^^^^^^^^^ help: consider using: `String::new()`
+
+error: empty String is being created manually
+  --> $DIR/manual_empty_string_creations.rs:34:13
+   |
+LL |     let _ = String::try_from("").unwrap();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `String::new()`
+
+error: empty String is being created manually
+  --> $DIR/manual_empty_string_creations.rs:40:21
+   |
+LL |     let _: String = From::from("");
+   |                     ^^^^^^^^^^^^^^ help: consider using: `String::new()`
+
+error: empty String is being created manually
+  --> $DIR/manual_empty_string_creations.rs:45:21
+   |
+LL |     let _: String = TryFrom::try_from("").unwrap();
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `String::new()`
+
+error: empty String is being created manually
+  --> $DIR/manual_empty_string_creations.rs:48:21
+   |
+LL |     let _: String = TryFrom::try_from("").expect("this should warn");
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `String::new()`
+
+error: aborting due to 9 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 1bf88414790bacf5773bd7f19f0c58e183d0ca7c Mon Sep 17 00:00:00 2001
From: Guilherme-Vasconcelos
 <49197151+Guilherme-Vasconcelos@users.noreply.github.com>
Date: Fri, 5 Aug 2022 20:59:50 -0300
Subject: Update all tests to comply with clippy::manual_empty_string_creations

---
 clippy_dev/src/new_lint.rs                                |  2 +-
 clippy_lints/src/manual_async_fn.rs                       |  2 +-
 clippy_lints/src/methods/option_map_unwrap_or.rs          |  2 +-
 clippy_lints/src/misc_early/unneeded_wildcard_pattern.rs  |  2 +-
 clippy_lints/src/unnecessary_wraps.rs                     |  2 +-
 tests/ui/case_sensitive_file_extension_comparisons.rs     | 10 +++++-----
 tests/ui/case_sensitive_file_extension_comparisons.stderr | 12 ++++++------
 tests/ui/format.fixed                                     |  2 +-
 tests/ui/format.rs                                        |  2 +-
 tests/ui/identity_op.fixed                                |  2 +-
 tests/ui/identity_op.rs                                   |  2 +-
 tests/ui/manual_empty_string_creations.fixed              |  2 +-
 tests/ui/or_fun_call.fixed                                |  4 ++--
 tests/ui/or_fun_call.rs                                   |  4 ++--
 tests/ui/or_fun_call.stderr                               |  6 +++---
 tests/ui/string_add.rs                                    |  4 ++--
 tests/ui/string_add_assign.fixed                          |  4 ++--
 tests/ui/string_add_assign.rs                             |  4 ++--
 tests/ui/unnecessary_owned_empty_strings.fixed            |  1 +
 tests/ui/unnecessary_owned_empty_strings.rs               |  1 +
 tests/ui/unnecessary_owned_empty_strings.stderr           |  2 +-
 tests/ui/useless_conversion_try.rs                        |  4 ++--
 tests/ui/useless_conversion_try.stderr                    |  2 +-
 23 files changed, 40 insertions(+), 38 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_dev/src/new_lint.rs b/clippy_dev/src/new_lint.rs
index 10a8f31f457..be05e67d724 100644
--- a/clippy_dev/src/new_lint.rs
+++ b/clippy_dev/src/new_lint.rs
@@ -155,7 +155,7 @@ fn to_camel_case(name: &str) -> String {
     name.split('_')
         .map(|s| {
             if s.is_empty() {
-                String::from("")
+                String::new()
             } else {
                 [&s[0..1].to_uppercase(), &s[1..]].concat()
             }
diff --git a/clippy_lints/src/manual_async_fn.rs b/clippy_lints/src/manual_async_fn.rs
index a0ca7e6ff1e..2502c8f880d 100644
--- a/clippy_lints/src/manual_async_fn.rs
+++ b/clippy_lints/src/manual_async_fn.rs
@@ -192,7 +192,7 @@ fn suggested_ret(cx: &LateContext<'_>, output: &Ty<'_>) -> Option<(&'static str,
     match output.kind {
         TyKind::Tup(tys) if tys.is_empty() => {
             let sugg = "remove the return type";
-            Some((sugg, "".into()))
+            Some((sugg, String::new()))
         },
         _ => {
             let sugg = "return the output of the future directly";
diff --git a/clippy_lints/src/methods/option_map_unwrap_or.rs b/clippy_lints/src/methods/option_map_unwrap_or.rs
index 6c641af59f9..3c4002a3aef 100644
--- a/clippy_lints/src/methods/option_map_unwrap_or.rs
+++ b/clippy_lints/src/methods/option_map_unwrap_or.rs
@@ -78,7 +78,7 @@ pub(super) fn check<'tcx>(
                     map_span,
                     String::from(if unwrap_snippet_none { "and_then" } else { "map_or" }),
                 ),
-                (expr.span.with_lo(unwrap_recv.span.hi()), String::from("")),
+                (expr.span.with_lo(unwrap_recv.span.hi()), String::new()),
             ];
 
             if !unwrap_snippet_none {
diff --git a/clippy_lints/src/misc_early/unneeded_wildcard_pattern.rs b/clippy_lints/src/misc_early/unneeded_wildcard_pattern.rs
index df044538fe1..7c4ae746e90 100644
--- a/clippy_lints/src/misc_early/unneeded_wildcard_pattern.rs
+++ b/clippy_lints/src/misc_early/unneeded_wildcard_pattern.rs
@@ -46,7 +46,7 @@ fn span_lint(cx: &EarlyContext<'_>, span: Span, only_one: bool) {
             "these patterns are unneeded as the `..` pattern can match those elements"
         },
         if only_one { "remove it" } else { "remove them" },
-        "".to_string(),
+        String::new(),
         Applicability::MachineApplicable,
     );
 }
diff --git a/clippy_lints/src/unnecessary_wraps.rs b/clippy_lints/src/unnecessary_wraps.rs
index f4f5a4336a3..a5afbb8ff9d 100644
--- a/clippy_lints/src/unnecessary_wraps.rs
+++ b/clippy_lints/src/unnecessary_wraps.rs
@@ -130,7 +130,7 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryWraps {
                         (
                             ret_expr.span,
                             if inner_type.is_unit() {
-                                "".to_string()
+                                String::new()
                             } else {
                                 snippet(cx, arg.span.source_callsite(), "..").to_string()
                             }
diff --git a/tests/ui/case_sensitive_file_extension_comparisons.rs b/tests/ui/case_sensitive_file_extension_comparisons.rs
index 0d65071af15..6f0485b5279 100644
--- a/tests/ui/case_sensitive_file_extension_comparisons.rs
+++ b/tests/ui/case_sensitive_file_extension_comparisons.rs
@@ -14,31 +14,31 @@ fn is_rust_file(filename: &str) -> bool {
 
 fn main() {
     // std::string::String and &str should trigger the lint failure with .ext12
-    let _ = String::from("").ends_with(".ext12");
+    let _ = String::new().ends_with(".ext12");
     let _ = "str".ends_with(".ext12");
 
     // The test struct should not trigger the lint failure with .ext12
     TestStruct {}.ends_with(".ext12");
 
     // std::string::String and &str should trigger the lint failure with .EXT12
-    let _ = String::from("").ends_with(".EXT12");
+    let _ = String::new().ends_with(".EXT12");
     let _ = "str".ends_with(".EXT12");
 
     // The test struct should not trigger the lint failure with .EXT12
     TestStruct {}.ends_with(".EXT12");
 
     // Should not trigger the lint failure with .eXT12
-    let _ = String::from("").ends_with(".eXT12");
+    let _ = String::new().ends_with(".eXT12");
     let _ = "str".ends_with(".eXT12");
     TestStruct {}.ends_with(".eXT12");
 
     // Should not trigger the lint failure with .EXT123 (too long)
-    let _ = String::from("").ends_with(".EXT123");
+    let _ = String::new().ends_with(".EXT123");
     let _ = "str".ends_with(".EXT123");
     TestStruct {}.ends_with(".EXT123");
 
     // Shouldn't fail if it doesn't start with a dot
-    let _ = String::from("").ends_with("a.ext");
+    let _ = String::new().ends_with("a.ext");
     let _ = "str".ends_with("a.extA");
     TestStruct {}.ends_with("a.ext");
 }
diff --git a/tests/ui/case_sensitive_file_extension_comparisons.stderr b/tests/ui/case_sensitive_file_extension_comparisons.stderr
index 05b98169f2d..5d9a043edb9 100644
--- a/tests/ui/case_sensitive_file_extension_comparisons.stderr
+++ b/tests/ui/case_sensitive_file_extension_comparisons.stderr
@@ -8,10 +8,10 @@ LL |     filename.ends_with(".rs")
    = help: consider using a case-insensitive comparison instead
 
 error: case-sensitive file extension comparison
-  --> $DIR/case_sensitive_file_extension_comparisons.rs:17:30
+  --> $DIR/case_sensitive_file_extension_comparisons.rs:17:27
    |
-LL |     let _ = String::from("").ends_with(".ext12");
-   |                              ^^^^^^^^^^^^^^^^^^^
+LL |     let _ = String::new().ends_with(".ext12");
+   |                           ^^^^^^^^^^^^^^^^^^^
    |
    = help: consider using a case-insensitive comparison instead
 
@@ -24,10 +24,10 @@ LL |     let _ = "str".ends_with(".ext12");
    = help: consider using a case-insensitive comparison instead
 
 error: case-sensitive file extension comparison
-  --> $DIR/case_sensitive_file_extension_comparisons.rs:24:30
+  --> $DIR/case_sensitive_file_extension_comparisons.rs:24:27
    |
-LL |     let _ = String::from("").ends_with(".EXT12");
-   |                              ^^^^^^^^^^^^^^^^^^^
+LL |     let _ = String::new().ends_with(".EXT12");
+   |                           ^^^^^^^^^^^^^^^^^^^
    |
    = help: consider using a case-insensitive comparison instead
 
diff --git a/tests/ui/format.fixed b/tests/ui/format.fixed
index 6b754f3bd71..b56d6aec508 100644
--- a/tests/ui/format.fixed
+++ b/tests/ui/format.fixed
@@ -33,7 +33,7 @@ fn main() {
     format!("foo {}", "bar");
     format!("{} bar", "foo");
 
-    let arg: String = "".to_owned();
+    let arg = String::new();
     arg.to_string();
     format!("{:?}", arg); // Don't warn about debug.
     format!("{:8}", arg);
diff --git a/tests/ui/format.rs b/tests/ui/format.rs
index ca9826b356e..4c1a3a840ed 100644
--- a/tests/ui/format.rs
+++ b/tests/ui/format.rs
@@ -35,7 +35,7 @@ fn main() {
     format!("foo {}", "bar");
     format!("{} bar", "foo");
 
-    let arg: String = "".to_owned();
+    let arg = String::new();
     format!("{}", arg);
     format!("{:?}", arg); // Don't warn about debug.
     format!("{:8}", arg);
diff --git a/tests/ui/identity_op.fixed b/tests/ui/identity_op.fixed
index 5f9cebe212a..fa564e23cd2 100644
--- a/tests/ui/identity_op.fixed
+++ b/tests/ui/identity_op.fixed
@@ -68,7 +68,7 @@ fn main() {
     &x;
     x;
 
-    let mut a = A("".into());
+    let mut a = A(String::new());
     let b = a << 0; // no error: non-integer
 
     1 * Meter; // no error: non-integer
diff --git a/tests/ui/identity_op.rs b/tests/ui/identity_op.rs
index ca799c9cfac..3d06d2a73b6 100644
--- a/tests/ui/identity_op.rs
+++ b/tests/ui/identity_op.rs
@@ -68,7 +68,7 @@ fn main() {
     &x >> 0;
     x >> &0;
 
-    let mut a = A("".into());
+    let mut a = A(String::new());
     let b = a << 0; // no error: non-integer
 
     1 * Meter; // no error: non-integer
diff --git a/tests/ui/manual_empty_string_creations.fixed b/tests/ui/manual_empty_string_creations.fixed
index 3516312ee0c..caf0c657c81 100644
--- a/tests/ui/manual_empty_string_creations.fixed
+++ b/tests/ui/manual_empty_string_creations.fixed
@@ -7,7 +7,7 @@ macro_rules! create_strings_from_macro {
     ($some_str:expr) => {
         let _: String = $some_str.into();
         let _ = $some_str.to_string();
-    }
+    };
 }
 
 fn main() {
diff --git a/tests/ui/or_fun_call.fixed b/tests/ui/or_fun_call.fixed
index fdb08d953ff..18ea4e55029 100644
--- a/tests/ui/or_fun_call.fixed
+++ b/tests/ui/or_fun_call.fixed
@@ -90,8 +90,8 @@ fn or_fun_call() {
     let mut btree_vec = BTreeMap::<u64, Vec<i32>>::new();
     btree_vec.entry(42).or_insert(vec![]);
 
-    let stringy = Some(String::from(""));
-    let _ = stringy.unwrap_or_else(|| "".to_owned());
+    let stringy = Some(String::new());
+    let _ = stringy.unwrap_or_default();
 
     let opt = Some(1);
     let hello = "Hello";
diff --git a/tests/ui/or_fun_call.rs b/tests/ui/or_fun_call.rs
index 57ab5f03ee2..c353b41e449 100644
--- a/tests/ui/or_fun_call.rs
+++ b/tests/ui/or_fun_call.rs
@@ -90,8 +90,8 @@ fn or_fun_call() {
     let mut btree_vec = BTreeMap::<u64, Vec<i32>>::new();
     btree_vec.entry(42).or_insert(vec![]);
 
-    let stringy = Some(String::from(""));
-    let _ = stringy.unwrap_or("".to_owned());
+    let stringy = Some(String::new());
+    let _ = stringy.unwrap_or(String::new());
 
     let opt = Some(1);
     let hello = "Hello";
diff --git a/tests/ui/or_fun_call.stderr b/tests/ui/or_fun_call.stderr
index 4c5938ab88b..887f23ac976 100644
--- a/tests/ui/or_fun_call.stderr
+++ b/tests/ui/or_fun_call.stderr
@@ -66,11 +66,11 @@ error: use of `unwrap_or` followed by a function call
 LL |     without_default.unwrap_or(Foo::new());
    |                     ^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(Foo::new)`
 
-error: use of `unwrap_or` followed by a function call
+error: use of `unwrap_or` followed by a call to `new`
   --> $DIR/or_fun_call.rs:94:21
    |
-LL |     let _ = stringy.unwrap_or("".to_owned());
-   |                     ^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|| "".to_owned())`
+LL |     let _ = stringy.unwrap_or(String::new());
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_default()`
 
 error: use of `unwrap_or` followed by a function call
   --> $DIR/or_fun_call.rs:102:21
diff --git a/tests/ui/string_add.rs b/tests/ui/string_add.rs
index 30fd17c59e5..16673c01e63 100644
--- a/tests/ui/string_add.rs
+++ b/tests/ui/string_add.rs
@@ -7,13 +7,13 @@ extern crate macro_rules;
 #[allow(clippy::string_add_assign, unused)]
 fn main() {
     // ignores assignment distinction
-    let mut x = "".to_owned();
+    let mut x = String::new();
 
     for _ in 1..3 {
         x = x + ".";
     }
 
-    let y = "".to_owned();
+    let y = String::new();
     let z = y + "...";
 
     assert_eq!(&x, &z);
diff --git a/tests/ui/string_add_assign.fixed b/tests/ui/string_add_assign.fixed
index db71bab1e52..b687f43b254 100644
--- a/tests/ui/string_add_assign.fixed
+++ b/tests/ui/string_add_assign.fixed
@@ -4,13 +4,13 @@
 #[warn(clippy::string_add_assign)]
 fn main() {
     // ignores assignment distinction
-    let mut x = "".to_owned();
+    let mut x = String::new();
 
     for _ in 1..3 {
         x += ".";
     }
 
-    let y = "".to_owned();
+    let y = String::new();
     let z = y + "...";
 
     assert_eq!(&x, &z);
diff --git a/tests/ui/string_add_assign.rs b/tests/ui/string_add_assign.rs
index 644991945cb..e5dbde108fb 100644
--- a/tests/ui/string_add_assign.rs
+++ b/tests/ui/string_add_assign.rs
@@ -4,13 +4,13 @@
 #[warn(clippy::string_add_assign)]
 fn main() {
     // ignores assignment distinction
-    let mut x = "".to_owned();
+    let mut x = String::new();
 
     for _ in 1..3 {
         x = x + ".";
     }
 
-    let y = "".to_owned();
+    let y = String::new();
     let z = y + "...";
 
     assert_eq!(&x, &z);
diff --git a/tests/ui/unnecessary_owned_empty_strings.fixed b/tests/ui/unnecessary_owned_empty_strings.fixed
index f95f91329a2..c390618ca98 100644
--- a/tests/ui/unnecessary_owned_empty_strings.fixed
+++ b/tests/ui/unnecessary_owned_empty_strings.fixed
@@ -12,6 +12,7 @@ fn main() {
     ref_str_argument("");
 
     // should be linted
+    #[allow(clippy::manual_empty_string_creations)]
     ref_str_argument("");
 
     // should not be linted
diff --git a/tests/ui/unnecessary_owned_empty_strings.rs b/tests/ui/unnecessary_owned_empty_strings.rs
index 0cbdc151ed9..4a9d6125eb1 100644
--- a/tests/ui/unnecessary_owned_empty_strings.rs
+++ b/tests/ui/unnecessary_owned_empty_strings.rs
@@ -12,6 +12,7 @@ fn main() {
     ref_str_argument(&String::new());
 
     // should be linted
+    #[allow(clippy::manual_empty_string_creations)]
     ref_str_argument(&String::from(""));
 
     // should not be linted
diff --git a/tests/ui/unnecessary_owned_empty_strings.stderr b/tests/ui/unnecessary_owned_empty_strings.stderr
index 46bc4597b33..1eb198a8675 100644
--- a/tests/ui/unnecessary_owned_empty_strings.stderr
+++ b/tests/ui/unnecessary_owned_empty_strings.stderr
@@ -7,7 +7,7 @@ LL |     ref_str_argument(&String::new());
    = note: `-D clippy::unnecessary-owned-empty-strings` implied by `-D warnings`
 
 error: usage of `&String::from("")` for a function expecting a `&str` argument
-  --> $DIR/unnecessary_owned_empty_strings.rs:15:22
+  --> $DIR/unnecessary_owned_empty_strings.rs:16:22
    |
 LL |     ref_str_argument(&String::from(""));
    |                      ^^^^^^^^^^^^^^^^^ help: try: `""`
diff --git a/tests/ui/useless_conversion_try.rs b/tests/ui/useless_conversion_try.rs
index 39f54c27bee..4acf5b5fa2d 100644
--- a/tests/ui/useless_conversion_try.rs
+++ b/tests/ui/useless_conversion_try.rs
@@ -29,10 +29,10 @@ fn main() {
     let _ = String::try_from("foo".to_string()).unwrap();
     let _ = String::try_from(format!("A: {:04}", 123)).unwrap();
     let _: String = format!("Hello {}", "world").try_into().unwrap();
-    let _: String = "".to_owned().try_into().unwrap();
+    let _: String = String::new().try_into().unwrap();
     let _: String = match String::from("_").try_into() {
         Ok(a) => a,
-        Err(_) => "".into(),
+        Err(_) => String::new(),
     };
     // FIXME this is a false negative
     #[allow(clippy::cmp_owned)]
diff --git a/tests/ui/useless_conversion_try.stderr b/tests/ui/useless_conversion_try.stderr
index b691c13f7db..12e74d61471 100644
--- a/tests/ui/useless_conversion_try.stderr
+++ b/tests/ui/useless_conversion_try.stderr
@@ -62,7 +62,7 @@ LL |     let _: String = format!("Hello {}", "world").try_into().unwrap();
 error: useless conversion to the same type: `std::string::String`
   --> $DIR/useless_conversion_try.rs:32:21
    |
-LL |     let _: String = "".to_owned().try_into().unwrap();
+LL |     let _: String = String::new().try_into().unwrap();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: consider removing `.try_into()`
-- 
cgit 1.4.1-3-g733a5


From 1a2aaf68de4989eaacf5b669da00b50dca8b41e0 Mon Sep 17 00:00:00 2001
From: xphoniex <dj.2dixx@gmail.com>
Date: Sun, 14 Aug 2022 16:29:26 +0000
Subject: Skip `unnecessary_to_owned` when `t != t.to_string()`

Signed-off-by: xphoniex <dj.2dixx@gmail.com>
---
 clippy_lints/src/methods/unnecessary_to_owned.rs | 17 ++++++++++++--
 tests/ui/unnecessary_to_owned.fixed              | 28 ++++++++++++++++++++++++
 tests/ui/unnecessary_to_owned.rs                 | 28 ++++++++++++++++++++++++
 3 files changed, 71 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/unnecessary_to_owned.rs b/clippy_lints/src/methods/unnecessary_to_owned.rs
index b3276f1394e..99b56da7a50 100644
--- a/clippy_lints/src/methods/unnecessary_to_owned.rs
+++ b/clippy_lints/src/methods/unnecessary_to_owned.rs
@@ -3,7 +3,8 @@ use super::unnecessary_iter_cloned::{self, is_into_iter};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::{
-    contains_ty, get_associated_type, get_iterator_item_ty, implements_trait, is_copy, peel_mid_ty_refs,
+    contains_ty, get_associated_type, get_iterator_item_ty, implements_trait, is_copy, is_type_diagnostic_item,
+    peel_mid_ty_refs,
 };
 use clippy_utils::{meets_msrv, msrvs};
 
@@ -279,7 +280,19 @@ fn check_other_call_arg<'tcx>(
                 &trait_predicate.trait_ref.substs.iter().skip(1).collect::<Vec<_>>()[..],
                 call_substs,
             );
-            implements_trait(cx, receiver_ty, as_ref_trait_id, &composed_substs)
+            // if `expr` is a `String` and generic target is [u8], skip
+            // (https://github.com/rust-lang/rust-clippy/issues/9317).
+            if let [subst] = composed_substs[..]
+                && let GenericArgKind::Type(arg_ty) = subst.unpack()
+                && arg_ty.is_slice()
+                && let inner_ty = arg_ty.builtin_index().unwrap()
+                && let ty::Uint(ty::UintTy::U8) = inner_ty.kind()
+                && let self_ty = cx.typeck_results().expr_ty(expr).peel_refs()
+                && is_type_diagnostic_item(cx, self_ty, sym::String) {
+                false
+            } else {
+                implements_trait(cx, receiver_ty, as_ref_trait_id, &composed_substs)
+            }
         } else {
             false
         };
diff --git a/tests/ui/unnecessary_to_owned.fixed b/tests/ui/unnecessary_to_owned.fixed
index f4f76cd3dd4..9cd5bc73b1e 100644
--- a/tests/ui/unnecessary_to_owned.fixed
+++ b/tests/ui/unnecessary_to_owned.fixed
@@ -329,3 +329,31 @@ mod issue_8759_variant {
         rw.set_view(&rw.default_view().to_owned());
     }
 }
+
+mod issue_9317 {
+    #![allow(dead_code)]
+
+    struct Bytes {}
+
+    impl ToString for Bytes {
+        fn to_string(&self) -> String {
+            "123".to_string()
+        }
+    }
+
+    impl AsRef<[u8]> for Bytes {
+        fn as_ref(&self) -> &[u8] {
+            &[1, 2, 3]
+        }
+    }
+
+    fn consume<C: AsRef<[u8]>>(c: C) {
+        let _ = c;
+    }
+
+    pub fn main() {
+        let b = Bytes {};
+        // Should not lint.
+        consume(b.to_string());
+    }
+}
diff --git a/tests/ui/unnecessary_to_owned.rs b/tests/ui/unnecessary_to_owned.rs
index fe09a489ab0..7f62ba3ab5d 100644
--- a/tests/ui/unnecessary_to_owned.rs
+++ b/tests/ui/unnecessary_to_owned.rs
@@ -329,3 +329,31 @@ mod issue_8759_variant {
         rw.set_view(&rw.default_view().to_owned());
     }
 }
+
+mod issue_9317 {
+    #![allow(dead_code)]
+
+    struct Bytes {}
+
+    impl ToString for Bytes {
+        fn to_string(&self) -> String {
+            "123".to_string()
+        }
+    }
+
+    impl AsRef<[u8]> for Bytes {
+        fn as_ref(&self) -> &[u8] {
+            &[1, 2, 3]
+        }
+    }
+
+    fn consume<C: AsRef<[u8]>>(c: C) {
+        let _ = c;
+    }
+
+    pub fn main() {
+        let b = Bytes {};
+        // Should not lint.
+        consume(b.to_string());
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 6de4bdfa8e36bcf5c814b0d43afc1cefb0630533 Mon Sep 17 00:00:00 2001
From: lukaslueg <lukas.lueg@gmail.com>
Date: Mon, 15 Aug 2022 20:13:31 +0200
Subject: Fix label not starting with lcase-letter

Co-authored-by: Fridtjof Stoldt <xFrednet@gmail.com>
---
 clippy_lints/src/if_let_mutex.rs | 2 +-
 tests/ui/if_let_mutex.stderr     | 6 +++---
 2 files changed, 4 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/if_let_mutex.rs b/clippy_lints/src/if_let_mutex.rs
index b6f9fefdee9..4d703d691ac 100644
--- a/clippy_lints/src/if_let_mutex.rs
+++ b/clippy_lints/src/if_let_mutex.rs
@@ -64,7 +64,7 @@ impl<'tcx> LateLintPass<'tcx> for IfLetMutex {
                     let diag = |diag: &mut Diagnostic| {
                         diag.span_label(
                             op_mutex.span,
-                            "This Mutex will remain locked for the entire `if let`-block...",
+                            "this Mutex will remain locked for the entire `if let`-block...",
                         );
                         diag.span_label(
                             arm_mutex.span,
diff --git a/tests/ui/if_let_mutex.stderr b/tests/ui/if_let_mutex.stderr
index 6dbfc4be412..8a4d5dbac59 100644
--- a/tests/ui/if_let_mutex.stderr
+++ b/tests/ui/if_let_mutex.stderr
@@ -2,7 +2,7 @@ error: calling `Mutex::lock` inside the scope of another `Mutex::lock` causes a
   --> $DIR/if_let_mutex.rs:10:5
    |
 LL |       if let Err(locked) = m.lock() {
-   |       ^                    - This Mutex will remain locked for the entire `if let`-block...
+   |       ^                    - this Mutex will remain locked for the entire `if let`-block...
    |  _____|
    | |
 LL | |         do_stuff(locked);
@@ -20,7 +20,7 @@ error: calling `Mutex::lock` inside the scope of another `Mutex::lock` causes a
   --> $DIR/if_let_mutex.rs:22:5
    |
 LL |       if let Some(locked) = m.lock().unwrap().deref() {
-   |       ^                     - This Mutex will remain locked for the entire `if let`-block...
+   |       ^                     - this Mutex will remain locked for the entire `if let`-block...
    |  _____|
    | |
 LL | |         do_stuff(locked);
@@ -37,7 +37,7 @@ error: calling `Mutex::lock` inside the scope of another `Mutex::lock` causes a
   --> $DIR/if_let_mutex.rs:43:5
    |
 LL |       if let Ok(i) = mutex.lock() {
-   |       ^              ----- This Mutex will remain locked for the entire `if let`-block...
+   |       ^              ----- this Mutex will remain locked for the entire `if let`-block...
    |  _____|
    | |
 LL | |         do_stuff(i);
-- 
cgit 1.4.1-3-g733a5


From 7727c303e5eaef93dbccc75a0b9004d9c75d3a62 Mon Sep 17 00:00:00 2001
From: Stanislav Tkach <stanislav.tkach@gmail.com>
Date: Sat, 13 Aug 2022 16:04:30 +0200
Subject: Simplify the borrow_deref_ref lint example

---
 clippy_lints/src/borrow_deref_ref.rs | 5 -----
 1 file changed, 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/borrow_deref_ref.rs b/clippy_lints/src/borrow_deref_ref.rs
index e65b67c655e..c4520d00392 100644
--- a/clippy_lints/src/borrow_deref_ref.rs
+++ b/clippy_lints/src/borrow_deref_ref.rs
@@ -29,20 +29,15 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust
-    /// fn foo(_x: &str) {}
-    ///
     /// let s = &String::new();
     ///
     /// let a: &String = &* s;
-    /// foo(&*s);
     /// ```
     ///
     /// Use instead:
     /// ```rust
-    /// # fn foo(_x: &str) {}
     /// # let s = &String::new();
     /// let a: &String = s;
-    /// foo(&**s);
     /// ```
     #[clippy::version = "1.63.0"]
     pub BORROW_DEREF_REF,
-- 
cgit 1.4.1-3-g733a5


From 9e9b3ddf69d28bcfd8564a1e31637e6b135ab69b Mon Sep 17 00:00:00 2001
From: alexey semenyuk <alexsemenyuk88@gmail.com>
Date: Tue, 16 Aug 2022 12:50:53 +0300
Subject: Fix example

---
 clippy_lints/src/escape.rs | 10 ++--------
 1 file changed, 2 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/escape.rs b/clippy_lints/src/escape.rs
index 1ac7bfba06b..0a4a0ebb3f9 100644
--- a/clippy_lints/src/escape.rs
+++ b/clippy_lints/src/escape.rs
@@ -30,18 +30,12 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust
-    /// # fn foo(bar: usize) {}
-    /// let x = Box::new(1);
-    /// foo(*x);
-    /// println!("{}", *x);
+    /// fn foo(x: Box<u32>) {}
     /// ```
     ///
     /// Use instead:
     /// ```rust
-    /// # fn foo(bar: usize) {}
-    /// let x = 1;
-    /// foo(x);
-    /// println!("{}", x);
+    /// fn foo(x: u32) {}
     /// ```
     #[clippy::version = "pre 1.29.0"]
     pub BOXED_LOCAL,
-- 
cgit 1.4.1-3-g733a5


From c1e04352bd220d2b912715aa07e1d04fe97d84f2 Mon Sep 17 00:00:00 2001
From: Sosthène Guédon <sosthene@guedon.gdn>
Date: Mon, 15 Aug 2022 20:30:30 +0200
Subject: unwrap_used and expect_used: trigger on uses of their _err variants

---
 clippy_lints/src/methods/expect_used.rs | 18 +++++++++++++-----
 clippy_lints/src/methods/mod.rs         | 10 ++++++----
 clippy_lints/src/methods/unwrap_used.rs | 18 +++++++++++++-----
 tests/ui/unwrap_expect_used.rs          | 25 +++++++++++++++++++++++++
 tests/ui/unwrap_expect_used.stderr      | 26 +++++++++++++++++++++-----
 5 files changed, 78 insertions(+), 19 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/expect_used.rs b/clippy_lints/src/methods/expect_used.rs
index 5ef08ca6290..d59fefa1ddc 100644
--- a/clippy_lints/src/methods/expect_used.rs
+++ b/clippy_lints/src/methods/expect_used.rs
@@ -7,18 +7,26 @@ use rustc_span::sym;
 
 use super::EXPECT_USED;
 
-/// lint use of `expect()` for `Option`s and `Result`s
-pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr<'_>, allow_expect_in_tests: bool) {
+/// lint use of `expect()` or `expect_err` for `Result` and `expect()` for `Option`.
+pub(super) fn check(
+    cx: &LateContext<'_>,
+    expr: &hir::Expr<'_>,
+    recv: &hir::Expr<'_>,
+    is_err: bool,
+    allow_expect_in_tests: bool,
+) {
     let obj_ty = cx.typeck_results().expr_ty(recv).peel_refs();
 
-    let mess = if is_type_diagnostic_item(cx, obj_ty, sym::Option) {
+    let mess = if is_type_diagnostic_item(cx, obj_ty, sym::Option) && !is_err {
         Some((EXPECT_USED, "an Option", "None", ""))
     } else if is_type_diagnostic_item(cx, obj_ty, sym::Result) {
-        Some((EXPECT_USED, "a Result", "Err", "an "))
+        Some((EXPECT_USED, "a Result", if is_err { "Ok" } else { "Err" }, "an "))
     } else {
         None
     };
 
+    let method = if is_err { "expect_err" } else { "expect" };
+
     if allow_expect_in_tests && is_in_test_function(cx.tcx, expr.hir_id) {
         return;
     }
@@ -28,7 +36,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr
             cx,
             lint,
             expr.span,
-            &format!("used `expect()` on `{kind}` value"),
+            &format!("used `{method}()` on `{kind}` value"),
             None,
             &format!("if this value is {none_prefix}`{none_value}`, it will panic"),
         );
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 99aae5800ff..b68a2651e1b 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -174,7 +174,7 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for `.unwrap()` calls on `Option`s and on `Result`s.
+    /// Checks for `.unwrap()` or `.unwrap_err()` calls on `Result`s and `.unwrap()` call on `Option`s.
     ///
     /// ### Why is this bad?
     /// It is better to handle the `None` or `Err` case,
@@ -224,7 +224,7 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for `.expect()` calls on `Option`s and `Result`s.
+    /// Checks for `.expect()` or `.expect_err()` calls on `Result`s and `.expect()` call on `Option`s.
     ///
     /// ### Why is this bad?
     /// Usually it is better to handle the `None` or `Err` case.
@@ -2740,8 +2740,9 @@ impl Methods {
                 ("expect", [_]) => match method_call(recv) {
                     Some(("ok", [recv], _)) => ok_expect::check(cx, expr, recv),
                     Some(("err", [recv], err_span)) => err_expect::check(cx, expr, recv, self.msrv, span, err_span),
-                    _ => expect_used::check(cx, expr, recv, self.allow_expect_in_tests),
+                    _ => expect_used::check(cx, expr, recv, false, self.allow_expect_in_tests),
                 },
+                ("expect_err", [_]) => expect_used::check(cx, expr, recv, true, self.allow_expect_in_tests),
                 ("extend", [arg]) => {
                     string_extend_chars::check(cx, expr, recv, arg);
                     extend_with_drain::check(cx, expr, recv, arg);
@@ -2874,8 +2875,9 @@ impl Methods {
                         },
                         _ => {},
                     }
-                    unwrap_used::check(cx, expr, recv, self.allow_unwrap_in_tests);
+                    unwrap_used::check(cx, expr, recv, false, self.allow_unwrap_in_tests);
                 },
+                ("unwrap_err", []) => unwrap_used::check(cx, expr, recv, true, self.allow_unwrap_in_tests),
                 ("unwrap_or", [u_arg]) => match method_call(recv) {
                     Some((arith @ ("checked_add" | "checked_sub" | "checked_mul"), [lhs, rhs], _)) => {
                         manual_saturating_arithmetic::check(cx, expr, lhs, rhs, u_arg, &arith["checked_".len()..]);
diff --git a/clippy_lints/src/methods/unwrap_used.rs b/clippy_lints/src/methods/unwrap_used.rs
index ce1a52e5480..05915c14109 100644
--- a/clippy_lints/src/methods/unwrap_used.rs
+++ b/clippy_lints/src/methods/unwrap_used.rs
@@ -7,18 +7,26 @@ use rustc_span::sym;
 
 use super::{EXPECT_USED, UNWRAP_USED};
 
-/// lint use of `unwrap()` for `Option`s and `Result`s
-pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr<'_>, allow_unwrap_in_tests: bool) {
+/// lint use of `unwrap()` or `unwrap_err` for `Result` and `unwrap()` for `Option`.
+pub(super) fn check(
+    cx: &LateContext<'_>,
+    expr: &hir::Expr<'_>,
+    recv: &hir::Expr<'_>,
+    is_err: bool,
+    allow_unwrap_in_tests: bool,
+) {
     let obj_ty = cx.typeck_results().expr_ty(recv).peel_refs();
 
-    let mess = if is_type_diagnostic_item(cx, obj_ty, sym::Option) {
+    let mess = if is_type_diagnostic_item(cx, obj_ty, sym::Option) && !is_err {
         Some((UNWRAP_USED, "an Option", "None", ""))
     } else if is_type_diagnostic_item(cx, obj_ty, sym::Result) {
-        Some((UNWRAP_USED, "a Result", "Err", "an "))
+        Some((UNWRAP_USED, "a Result", if is_err { "Ok" } else { "Err" }, "an "))
     } else {
         None
     };
 
+    let method = if is_err { "unwrap_err" } else { "unwrap" };
+
     if allow_unwrap_in_tests && is_in_test_function(cx.tcx, expr.hir_id) {
         return;
     }
@@ -37,7 +45,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr
             cx,
             lint,
             expr.span,
-            &format!("used `unwrap()` on `{kind}` value"),
+            &format!("used `{method}()` on `{kind}` value"),
             None,
             &help,
         );
diff --git a/tests/ui/unwrap_expect_used.rs b/tests/ui/unwrap_expect_used.rs
index 0d4a0504a6e..9f27fef8249 100644
--- a/tests/ui/unwrap_expect_used.rs
+++ b/tests/ui/unwrap_expect_used.rs
@@ -1,10 +1,35 @@
 #![warn(clippy::unwrap_used, clippy::expect_used)]
 
+trait OptionExt {
+    type Item;
+
+    fn unwrap_err(self) -> Self::Item;
+
+    fn expect_err(self, msg: &str) -> Self::Item;
+}
+
+impl<T> OptionExt for Option<T> {
+    type Item = T;
+    fn unwrap_err(self) -> T {
+        panic!();
+    }
+
+    fn expect_err(self, msg: &str) -> T {
+        panic!();
+    }
+}
+
 fn main() {
     Some(3).unwrap();
     Some(3).expect("Hello world!");
 
+    // Don't trigger on unwrap_err on an option
+    Some(3).unwrap_err();
+    Some(3).expect_err("Hellow none!");
+
     let a: Result<i32, i32> = Ok(3);
     a.unwrap();
     a.expect("Hello world!");
+    a.unwrap_err();
+    a.expect_err("Hello error!");
 }
diff --git a/tests/ui/unwrap_expect_used.stderr b/tests/ui/unwrap_expect_used.stderr
index f54bfd617c4..1a19459b2c1 100644
--- a/tests/ui/unwrap_expect_used.stderr
+++ b/tests/ui/unwrap_expect_used.stderr
@@ -1,5 +1,5 @@
 error: used `unwrap()` on `an Option` value
-  --> $DIR/unwrap_expect_used.rs:4:5
+  --> $DIR/unwrap_expect_used.rs:23:5
    |
 LL |     Some(3).unwrap();
    |     ^^^^^^^^^^^^^^^^
@@ -8,7 +8,7 @@ LL |     Some(3).unwrap();
    = help: if this value is `None`, it will panic
 
 error: used `expect()` on `an Option` value
-  --> $DIR/unwrap_expect_used.rs:5:5
+  --> $DIR/unwrap_expect_used.rs:24:5
    |
 LL |     Some(3).expect("Hello world!");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -17,7 +17,7 @@ LL |     Some(3).expect("Hello world!");
    = help: if this value is `None`, it will panic
 
 error: used `unwrap()` on `a Result` value
-  --> $DIR/unwrap_expect_used.rs:8:5
+  --> $DIR/unwrap_expect_used.rs:31:5
    |
 LL |     a.unwrap();
    |     ^^^^^^^^^^
@@ -25,12 +25,28 @@ LL |     a.unwrap();
    = help: if this value is an `Err`, it will panic
 
 error: used `expect()` on `a Result` value
-  --> $DIR/unwrap_expect_used.rs:9:5
+  --> $DIR/unwrap_expect_used.rs:32:5
    |
 LL |     a.expect("Hello world!");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: if this value is an `Err`, it will panic
 
-error: aborting due to 4 previous errors
+error: used `unwrap_err()` on `a Result` value
+  --> $DIR/unwrap_expect_used.rs:33:5
+   |
+LL |     a.unwrap_err();
+   |     ^^^^^^^^^^^^^^
+   |
+   = help: if this value is an `Ok`, it will panic
+
+error: used `expect_err()` on `a Result` value
+  --> $DIR/unwrap_expect_used.rs:34:5
+   |
+LL |     a.expect_err("Hello error!");
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: if this value is an `Ok`, it will panic
+
+error: aborting due to 6 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From bd121eff8ac3bc1a65f13c7528dddbabd7a32207 Mon Sep 17 00:00:00 2001
From: Serial <69764315+Serial-ATA@users.noreply.github.com>
Date: Fri, 12 Aug 2022 20:02:57 -0400
Subject: Fix [`non_ascii_literal`] in tests

---
 clippy_lints/src/unicode.rs |  7 +++++++
 tests/ui/unicode.fixed      | 48 +++++++++++++++++++++++++++++++++------------
 tests/ui/unicode.rs         | 48 +++++++++++++++++++++++++++++++++------------
 tests/ui/unicode.stderr     | 46 +++++++++++++++++++++++++++++--------------
 4 files changed, 110 insertions(+), 39 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unicode.rs b/clippy_lints/src/unicode.rs
index cc64d17be05..8980283e5c8 100644
--- a/clippy_lints/src/unicode.rs
+++ b/clippy_lints/src/unicode.rs
@@ -1,5 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::is_lint_allowed;
+use clippy_utils::macros::span_is_local;
 use clippy_utils::source::snippet;
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
@@ -98,6 +99,10 @@ fn escape<T: Iterator<Item = char>>(s: T) -> String {
 }
 
 fn check_str(cx: &LateContext<'_>, span: Span, id: HirId) {
+    if !span_is_local(span) {
+        return;
+    }
+
     let string = snippet(cx, span, "");
     if string.chars().any(|c| ['\u{200B}', '\u{ad}', '\u{2060}'].contains(&c)) {
         span_lint_and_sugg(
@@ -113,6 +118,7 @@ fn check_str(cx: &LateContext<'_>, span: Span, id: HirId) {
             Applicability::MachineApplicable,
         );
     }
+
     if string.chars().any(|c| c as u32 > 0x7F) {
         span_lint_and_sugg(
             cx,
@@ -128,6 +134,7 @@ fn check_str(cx: &LateContext<'_>, span: Span, id: HirId) {
             Applicability::MachineApplicable,
         );
     }
+
     if is_lint_allowed(cx, NON_ASCII_LITERAL, id) && string.chars().zip(string.nfc()).any(|(a, b)| a != b) {
         span_lint_and_sugg(
             cx,
diff --git a/tests/ui/unicode.fixed b/tests/ui/unicode.fixed
index 328cda369e1..94b4723452f 100644
--- a/tests/ui/unicode.fixed
+++ b/tests/ui/unicode.fixed
@@ -1,4 +1,7 @@
 // run-rustfix
+// compile-flags: --test
+#![allow(dead_code)]
+
 #[warn(clippy::invisible_characters)]
 fn zero() {
     print!("Here >\u{200B}< is a ZWS, and \u{200B}another");
@@ -15,22 +18,43 @@ fn canon() {
     print!("a\u{0300}h?"); // also ok
 }
 
-#[warn(clippy::non_ascii_literal)]
-fn uni() {
-    print!("\u{dc}ben!");
-    print!("\u{DC}ben!"); // this is ok
-}
+mod non_ascii_literal {
+    #![deny(clippy::non_ascii_literal)]
+
+    fn uni() {
+        print!("\u{dc}ben!");
+        print!("\u{DC}ben!"); // this is ok
+    }
+
+    // issue 8013
+    fn single_quote() {
+        const _EMPTY_BLOCK: char = '\u{25b1}';
+        const _FULL_BLOCK: char = '\u{25b0}';
+    }
+
+    #[test]
+    pub fn issue_7739() {
+        // Ryū crate: https://github.com/dtolnay/ryu
+    }
+
+    mod issue_8263 {
+        #![deny(clippy::non_ascii_literal)]
+
+        // Re-allow for a single test
+        #[test]
+        #[allow(clippy::non_ascii_literal)]
+        fn allowed() {
+            let _ = "悲しいかな、ここに日本語を書くことはできない。";
+        }
 
-// issue 8013
-#[warn(clippy::non_ascii_literal)]
-fn single_quote() {
-    const _EMPTY_BLOCK: char = '\u{25b1}';
-    const _FULL_BLOCK: char = '\u{25b0}';
+        #[test]
+        fn denied() {
+            let _ = "\u{60b2}\u{3057}\u{3044}\u{304b}\u{306a}\u{3001}\u{3053}\u{3053}\u{306b}\u{65e5}\u{672c}\u{8a9e}\u{3092}\u{66f8}\u{304f}\u{3053}\u{3068}\u{306f}\u{3067}\u{304d}\u{306a}\u{3044}\u{3002}";
+        }
+    }
 }
 
 fn main() {
     zero();
-    uni();
     canon();
-    single_quote();
 }
diff --git a/tests/ui/unicode.rs b/tests/ui/unicode.rs
index 7828d6bcbea..6ad0b255b94 100644
--- a/tests/ui/unicode.rs
+++ b/tests/ui/unicode.rs
@@ -1,4 +1,7 @@
 // run-rustfix
+// compile-flags: --test
+#![allow(dead_code)]
+
 #[warn(clippy::invisible_characters)]
 fn zero() {
     print!("Here >​< is a ZWS, and ​another");
@@ -15,22 +18,43 @@ fn canon() {
     print!("a\u{0300}h?"); // also ok
 }
 
-#[warn(clippy::non_ascii_literal)]
-fn uni() {
-    print!("Üben!");
-    print!("\u{DC}ben!"); // this is ok
-}
+mod non_ascii_literal {
+    #![deny(clippy::non_ascii_literal)]
+
+    fn uni() {
+        print!("Üben!");
+        print!("\u{DC}ben!"); // this is ok
+    }
+
+    // issue 8013
+    fn single_quote() {
+        const _EMPTY_BLOCK: char = '▱';
+        const _FULL_BLOCK: char = '▰';
+    }
+
+    #[test]
+    pub fn issue_7739() {
+        // Ryū crate: https://github.com/dtolnay/ryu
+    }
+
+    mod issue_8263 {
+        #![deny(clippy::non_ascii_literal)]
+
+        // Re-allow for a single test
+        #[test]
+        #[allow(clippy::non_ascii_literal)]
+        fn allowed() {
+            let _ = "悲しいかな、ここに日本語を書くことはできない。";
+        }
 
-// issue 8013
-#[warn(clippy::non_ascii_literal)]
-fn single_quote() {
-    const _EMPTY_BLOCK: char = '▱';
-    const _FULL_BLOCK: char = '▰';
+        #[test]
+        fn denied() {
+            let _ = "悲しいかな、ここに日本語を書くことはできない。";
+        }
+    }
 }
 
 fn main() {
     zero();
-    uni();
     canon();
-    single_quote();
 }
diff --git a/tests/ui/unicode.stderr b/tests/ui/unicode.stderr
index 01d3f3c0296..ea74a81451e 100644
--- a/tests/ui/unicode.stderr
+++ b/tests/ui/unicode.stderr
@@ -1,5 +1,5 @@
 error: invisible character detected
-  --> $DIR/unicode.rs:4:12
+  --> $DIR/unicode.rs:7:12
    |
 LL |     print!("Here >​< is a ZWS, and ​another");
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider replacing the string with: `"Here >/u{200B}< is a ZWS, and /u{200B}another"`
@@ -7,19 +7,19 @@ LL |     print!("Here >​< is a ZWS, and ​another");
    = note: `-D clippy::invisible-characters` implied by `-D warnings`
 
 error: invisible character detected
-  --> $DIR/unicode.rs:6:12
+  --> $DIR/unicode.rs:9:12
    |
 LL |     print!("Here >­< is a SHY, and ­another");
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider replacing the string with: `"Here >/u{AD}< is a SHY, and /u{AD}another"`
 
 error: invisible character detected
-  --> $DIR/unicode.rs:8:12
+  --> $DIR/unicode.rs:11:12
    |
 LL |     print!("Here >⁠< is a WJ, and ⁠another");
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider replacing the string with: `"Here >/u{2060}< is a WJ, and /u{2060}another"`
 
 error: non-NFC Unicode sequence detected
-  --> $DIR/unicode.rs:14:12
+  --> $DIR/unicode.rs:17:12
    |
 LL |     print!("̀àh?");
    |            ^^^^^ help: consider replacing the string with: `"̀àh?"`
@@ -27,24 +27,40 @@ LL |     print!("̀àh?");
    = note: `-D clippy::unicode-not-nfc` implied by `-D warnings`
 
 error: literal non-ASCII character detected
-  --> $DIR/unicode.rs:20:12
+  --> $DIR/unicode.rs:25:16
    |
-LL |     print!("Üben!");
-   |            ^^^^^^^ help: consider replacing the string with: `"/u{dc}ben!"`
+LL |         print!("Üben!");
+   |                ^^^^^^^ help: consider replacing the string with: `"/u{dc}ben!"`
    |
-   = note: `-D clippy::non-ascii-literal` implied by `-D warnings`
+note: the lint level is defined here
+  --> $DIR/unicode.rs:22:13
+   |
+LL |     #![deny(clippy::non_ascii_literal)]
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: literal non-ASCII character detected
+  --> $DIR/unicode.rs:31:36
+   |
+LL |         const _EMPTY_BLOCK: char = '▱';
+   |                                    ^^^ help: consider replacing the string with: `'/u{25b1}'`
 
 error: literal non-ASCII character detected
-  --> $DIR/unicode.rs:27:32
+  --> $DIR/unicode.rs:32:35
    |
-LL |     const _EMPTY_BLOCK: char = '▱';
-   |                                ^^^ help: consider replacing the string with: `'/u{25b1}'`
+LL |         const _FULL_BLOCK: char = '▰';
+   |                                   ^^^ help: consider replacing the string with: `'/u{25b0}'`
 
 error: literal non-ASCII character detected
-  --> $DIR/unicode.rs:28:31
+  --> $DIR/unicode.rs:52:21
+   |
+LL |             let _ = "悲しいかな、ここに日本語を書くことはできない。";
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider replacing the string with: `"/u{60b2}/u{3057}/u{3044}/u{304b}/u{306a}/u{3001}/u{3053}/u{3053}/u{306b}/u{65e5}/u{672c}/u{8a9e}/u{3092}/u{66f8}/u{304f}/u{3053}/u{3068}/u{306f}/u{3067}/u{304d}/u{306a}/u{3044}/u{3002}"`
+   |
+note: the lint level is defined here
+  --> $DIR/unicode.rs:41:17
    |
-LL |     const _FULL_BLOCK: char = '▰';
-   |                               ^^^ help: consider replacing the string with: `'/u{25b0}'`
+LL |         #![deny(clippy::non_ascii_literal)]
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 7 previous errors
+error: aborting due to 8 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From bfeaae89304443894c5f64a73188015f938fc97d Mon Sep 17 00:00:00 2001
From: Brian Caswell <bcaswell@microsoft.com>
Date: Tue, 16 Aug 2022 16:03:23 -0400
Subject: suggest map_or in case_sensitive_file_extension_comparisons

Currently, case_sensitive_file_extension_comparisons suggests using
`map(..).unwrap_or(..)` which trips up `map_unwrap_or`.  This updates
the suggestion to use map_or.
---
 clippy_lints/src/case_sensitive_file_extension_comparisons.rs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/case_sensitive_file_extension_comparisons.rs b/clippy_lints/src/case_sensitive_file_extension_comparisons.rs
index 7eff71d5007..bef196565a2 100644
--- a/clippy_lints/src/case_sensitive_file_extension_comparisons.rs
+++ b/clippy_lints/src/case_sensitive_file_extension_comparisons.rs
@@ -26,8 +26,7 @@ declare_clippy_lint! {
     /// fn is_rust_file(filename: &str) -> bool {
     ///     let filename = std::path::Path::new(filename);
     ///     filename.extension()
-    ///         .map(|ext| ext.eq_ignore_ascii_case("rs"))
-    ///         .unwrap_or(false)
+    ///         .map_or(false, |ext| ext.eq_ignore_ascii_case("rs"))
     /// }
     /// ```
     #[clippy::version = "1.51.0"]
-- 
cgit 1.4.1-3-g733a5


From a05cb74d3080f0359a97c7380913edd2a5ebe7ee Mon Sep 17 00:00:00 2001
From: "Samuel E. Moelius III" <sam@moeli.us>
Date: Fri, 8 Jul 2022 05:29:10 -0400
Subject: Enhance `needless_borrow` to consider trait implementations

---
 clippy_lints/src/dereference.rs                  | 307 ++++++++++++++++++++---
 clippy_lints/src/lib.rs                          |   2 +-
 clippy_lints/src/methods/unnecessary_to_owned.rs |  19 +-
 clippy_utils/src/msrvs.rs                        |   2 +-
 tests/ui/needless_borrow.fixed                   | 117 ++++++++-
 tests/ui/needless_borrow.rs                      | 117 ++++++++-
 tests/ui/needless_borrow.stderr                  |  48 +++-
 7 files changed, 559 insertions(+), 53 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index e0b94f7190a..e38704701ea 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -1,24 +1,31 @@
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_hir_and_then};
 use clippy_utils::source::{snippet_with_applicability, snippet_with_context};
 use clippy_utils::sugg::has_enclosing_paren;
-use clippy_utils::ty::{expr_sig, peel_mid_ty_refs, ty_sig, variant_of_res};
-use clippy_utils::{get_parent_expr, is_lint_allowed, path_to_local, walk_to_expr_usage};
+use clippy_utils::ty::{contains_ty, expr_sig, is_copy, peel_mid_ty_refs, ty_sig, variant_of_res};
+use clippy_utils::{fn_def_id, get_parent_expr, is_lint_allowed, meets_msrv, msrvs, path_to_local, walk_to_expr_usage};
 use rustc_ast::util::parser::{PREC_POSTFIX, PREC_PREFIX};
 use rustc_data_structures::fx::FxIndexMap;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_ty, Visitor};
 use rustc_hir::{
-    self as hir, BindingAnnotation, Body, BodyId, BorrowKind, Closure, Expr, ExprKind, FnRetTy, GenericArg, HirId,
-    ImplItem, ImplItemKind, Item, ItemKind, Local, MatchSource, Mutability, Node, Pat, PatKind, Path, QPath, TraitItem,
-    TraitItemKind, TyKind, UnOp,
+    self as hir, def_id::DefId, BindingAnnotation, Body, BodyId, BorrowKind, Closure, Expr, ExprKind, FnRetTy,
+    GenericArg, HirId, ImplItem, ImplItemKind, Item, ItemKind, Local, MatchSource, Mutability, Node, Pat, PatKind,
+    Path, QPath, TraitItem, TraitItemKind, TyKind, UnOp,
 };
+use rustc_index::bit_set::BitSet;
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::adjustment::{Adjust, Adjustment, AutoBorrow, AutoBorrowMutability};
-use rustc_middle::ty::{self, Binder, BoundVariableKind, List, Ty, TyCtxt, TypeVisitable, TypeckResults};
+use rustc_middle::ty::{
+    self, subst::Subst, Binder, BoundVariableKind, EarlyBinder, FnSig, GenericArgKind, List, ParamTy, PredicateKind,
+    ProjectionPredicate, Ty, TyCtxt, TypeVisitable, TypeckResults,
+};
+use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::{symbol::sym, Span, Symbol, DUMMY_SP};
-use rustc_trait_selection::infer::InferCtxtExt;
+use rustc_trait_selection::infer::InferCtxtExt as _;
+use rustc_trait_selection::traits::{query::evaluate_obligation::InferCtxtExt as _, Obligation, ObligationCause};
+use std::collections::VecDeque;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -151,6 +158,7 @@ pub struct Dereferencing {
     /// been finished. Note we can't lint at the end of every body as they can be nested within each
     /// other.
     current_body: Option<BodyId>,
+
     /// The list of locals currently being checked by the lint.
     /// If the value is `None`, then the binding has been seen as a ref pattern, but is not linted.
     /// This is needed for or patterns where one of the branches can be linted, but another can not
@@ -158,6 +166,19 @@ pub struct Dereferencing {
     ///
     /// e.g. `m!(x) | Foo::Bar(ref x)`
     ref_locals: FxIndexMap<HirId, Option<RefPat>>,
+
+    // `IntoIterator` for arrays requires Rust 1.53.
+    msrv: Option<RustcVersion>,
+}
+
+impl Dereferencing {
+    #[must_use]
+    pub fn new(msrv: Option<RustcVersion>) -> Self {
+        Self {
+            msrv,
+            ..Dereferencing::default()
+        }
+    }
 }
 
 struct StateData {
@@ -170,6 +191,7 @@ struct StateData {
 struct DerefedBorrow {
     count: usize,
     msg: &'static str,
+    snip_expr: Option<HirId>,
 }
 
 enum State {
@@ -250,7 +272,7 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing {
         match (self.state.take(), kind) {
             (None, kind) => {
                 let expr_ty = typeck.expr_ty(expr);
-                let (position, adjustments) = walk_parents(cx, expr);
+                let (position, adjustments) = walk_parents(cx, expr, self.msrv);
 
                 match kind {
                     RefOp::Deref => {
@@ -331,20 +353,23 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing {
                         let deref_msg =
                             "this expression creates a reference which is immediately dereferenced by the compiler";
                         let borrow_msg = "this expression borrows a value the compiler would automatically borrow";
+                        let impl_msg = "the borrowed expression implements the required traits";
 
-                        let (required_refs, msg) = if position.can_auto_borrow() {
-                            (1, if deref_count == 1 { borrow_msg } else { deref_msg })
+                        let (required_refs, msg, snip_expr) = if position.can_auto_borrow() {
+                            (1, if deref_count == 1 { borrow_msg } else { deref_msg }, None)
+                        } else if let Position::ImplArg(hir_id) = position {
+                            (0, impl_msg, Some(hir_id))
                         } else if let Some(&Adjust::Borrow(AutoBorrow::Ref(_, mutability))) =
                             next_adjust.map(|a| &a.kind)
                         {
                             if matches!(mutability, AutoBorrowMutability::Mut { .. }) && !position.is_reborrow_stable()
                             {
-                                (3, deref_msg)
+                                (3, deref_msg, None)
                             } else {
-                                (2, deref_msg)
+                                (2, deref_msg, None)
                             }
                         } else {
-                            (2, deref_msg)
+                            (2, deref_msg, None)
                         };
 
                         if deref_count >= required_refs {
@@ -354,6 +379,7 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing {
                                     // can't be removed without breaking the code. See earlier comment.
                                     count: deref_count - required_refs,
                                     msg,
+                                    snip_expr,
                                 }),
                                 StateData { span: expr.span, hir_id: expr.hir_id, position },
                             ));
@@ -510,7 +536,7 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing {
                             spans: vec![pat.span],
                             app,
                             replacements: vec![(pat.span, snip.into())],
-                            hir_id: pat.hir_id
+                            hir_id: pat.hir_id,
                         }),
                     );
                 }
@@ -542,6 +568,8 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing {
             self.current_body = None;
         }
     }
+
+    extract_msrv_attr!(LateContext);
 }
 
 fn try_parse_ref_op<'tcx>(
@@ -594,6 +622,7 @@ enum Position {
     /// The method is defined on a reference type. e.g. `impl Foo for &T`
     MethodReceiverRefImpl,
     Callee,
+    ImplArg(HirId),
     FieldAccess(Symbol),
     Postfix,
     Deref,
@@ -630,7 +659,7 @@ impl Position {
             | Self::Callee
             | Self::FieldAccess(_)
             | Self::Postfix => PREC_POSTFIX,
-            Self::Deref => PREC_PREFIX,
+            Self::ImplArg(_) | Self::Deref => PREC_PREFIX,
             Self::DerefStable(p, _) | Self::ReborrowStable(p) | Self::Other(p) => p,
         }
     }
@@ -639,8 +668,12 @@ impl Position {
 /// Walks up the parent expressions attempting to determine both how stable the auto-deref result
 /// is, and which adjustments will be applied to it. Note this will not consider auto-borrow
 /// locations as those follow different rules.
-#[allow(clippy::too_many_lines)]
-fn walk_parents<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> (Position, &'tcx [Adjustment<'tcx>]) {
+#[expect(clippy::too_many_lines)]
+fn walk_parents<'tcx>(
+    cx: &LateContext<'tcx>,
+    e: &'tcx Expr<'_>,
+    msrv: Option<RustcVersion>,
+) -> (Position, &'tcx [Adjustment<'tcx>]) {
     let mut adjustments = [].as_slice();
     let mut precedence = 0i8;
     let ctxt = e.span.ctxt();
@@ -732,13 +765,20 @@ fn walk_parents<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> (Position, &
                     .iter()
                     .position(|arg| arg.hir_id == child_id)
                     .zip(expr_sig(cx, func))
-                    .and_then(|(i, sig)| sig.input_with_hir(i))
-                    .map(|(hir_ty, ty)| match hir_ty {
-                        // Type inference for closures can depend on how they're called. Only go by the explicit
-                        // types here.
-                        Some(hir_ty) => binding_ty_auto_deref_stability(cx, hir_ty, precedence, ty.bound_vars()),
-                        None => ty_auto_deref_stability(cx, cx.tcx.erase_late_bound_regions(ty), precedence)
-                            .position_for_arg(),
+                    .and_then(|(i, sig)| {
+                        sig.input_with_hir(i).map(|(hir_ty, ty)| match hir_ty {
+                            // Type inference for closures can depend on how they're called. Only go by the explicit
+                            // types here.
+                            Some(hir_ty) => binding_ty_auto_deref_stability(cx, hir_ty, precedence, ty.bound_vars()),
+                            None => {
+                                if let ty::Param(param_ty) = ty.skip_binder().kind() {
+                                    needless_borrow_impl_arg_position(cx, parent, i, *param_ty, e, precedence, msrv)
+                                } else {
+                                    ty_auto_deref_stability(cx, cx.tcx.erase_late_bound_regions(ty), precedence)
+                                        .position_for_arg()
+                                }
+                            },
+                        })
                     }),
                 ExprKind::MethodCall(_, args, _) => {
                     let id = cx.typeck_results().type_dependent_def_id(parent.hir_id).unwrap();
@@ -779,12 +819,17 @@ fn walk_parents<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> (Position, &
                                 Position::MethodReceiver
                             }
                         } else {
-                            ty_auto_deref_stability(
-                                cx,
-                                cx.tcx.erase_late_bound_regions(cx.tcx.fn_sig(id).input(i)),
-                                precedence,
-                            )
-                            .position_for_arg()
+                            let ty = cx.tcx.fn_sig(id).skip_binder().inputs()[i];
+                            if let ty::Param(param_ty) = ty.kind() {
+                                needless_borrow_impl_arg_position(cx, parent, i, *param_ty, e, precedence, msrv)
+                            } else {
+                                ty_auto_deref_stability(
+                                    cx,
+                                    cx.tcx.erase_late_bound_regions(cx.tcx.fn_sig(id).input(i)),
+                                    precedence,
+                                )
+                                .position_for_arg()
+                            }
                         }
                     })
                 },
@@ -946,6 +991,205 @@ fn ty_contains_infer(ty: &hir::Ty<'_>) -> bool {
     v.0
 }
 
+// Checks whether:
+// * child is an expression of the form `&e` in an argument position requiring an `impl Trait`
+// * `e`'s type implements `Trait` and is copyable
+// If the conditions are met, returns `Some(Position::ImplArg(..))`; otherwise, returns `None`.
+//   The "is copyable" condition is to avoid the case where removing the `&` means `e` would have to
+// be moved, but it cannot be.
+fn needless_borrow_impl_arg_position<'tcx>(
+    cx: &LateContext<'tcx>,
+    parent: &Expr<'tcx>,
+    arg_index: usize,
+    param_ty: ParamTy,
+    mut expr: &Expr<'tcx>,
+    precedence: i8,
+    msrv: Option<RustcVersion>,
+) -> Position {
+    let destruct_trait_def_id = cx.tcx.lang_items().destruct_trait();
+    let sized_trait_def_id = cx.tcx.lang_items().sized_trait();
+
+    let Some(callee_def_id) = fn_def_id(cx, parent) else { return Position::Other(precedence) };
+    let fn_sig = cx.tcx.fn_sig(callee_def_id).skip_binder();
+    let substs_with_expr_ty = cx
+        .typeck_results()
+        .node_substs(if let ExprKind::Call(callee, _) = parent.kind {
+            callee.hir_id
+        } else {
+            parent.hir_id
+        });
+
+    let predicates = cx.tcx.param_env(callee_def_id).caller_bounds();
+    let projection_predicates = predicates
+        .iter()
+        .filter_map(|predicate| {
+            if let PredicateKind::Projection(projection_predicate) = predicate.kind().skip_binder() {
+                Some(projection_predicate)
+            } else {
+                None
+            }
+        })
+        .collect::<Vec<_>>();
+
+    let mut trait_with_ref_mut_self_method = false;
+
+    // If no traits were found, or only the `Destruct`, `Sized`, or `Any` traits were found, return.
+    if predicates
+        .iter()
+        .filter_map(|predicate| {
+            if let PredicateKind::Trait(trait_predicate) = predicate.kind().skip_binder()
+                && trait_predicate.trait_ref.self_ty() == param_ty.to_ty(cx.tcx)
+            {
+                Some(trait_predicate.trait_ref.def_id)
+            } else {
+                None
+            }
+        })
+        .inspect(|trait_def_id| {
+            trait_with_ref_mut_self_method |= has_ref_mut_self_method(cx, *trait_def_id);
+        })
+        .all(|trait_def_id| {
+            Some(trait_def_id) == destruct_trait_def_id
+                || Some(trait_def_id) == sized_trait_def_id
+                || cx.tcx.is_diagnostic_item(sym::Any, trait_def_id)
+        })
+    {
+        return Position::Other(precedence);
+    }
+
+    // `substs_with_referent_ty` can be constructed outside of `check_referent` because the same
+    // elements are modified each time `check_referent` is called.
+    let mut substs_with_referent_ty = substs_with_expr_ty.to_vec();
+
+    let mut check_referent = |referent| {
+        let referent_ty = cx.typeck_results().expr_ty(referent);
+
+        if !is_copy(cx, referent_ty) {
+            return false;
+        }
+
+        // https://github.com/rust-lang/rust-clippy/pull/9136#pullrequestreview-1037379321
+        if trait_with_ref_mut_self_method && !matches!(referent_ty.kind(), ty::Ref(_, _, Mutability::Mut)) {
+            return false;
+        }
+
+        if !replace_types(
+            cx,
+            param_ty,
+            referent_ty,
+            fn_sig,
+            arg_index,
+            &projection_predicates,
+            &mut substs_with_referent_ty,
+        ) {
+            return false;
+        }
+
+        predicates.iter().all(|predicate| {
+            if let PredicateKind::Trait(trait_predicate) = predicate.kind().skip_binder()
+                && cx.tcx.is_diagnostic_item(sym::IntoIterator, trait_predicate.trait_ref.def_id)
+                && let ty::Param(param_ty) = trait_predicate.self_ty().kind()
+                && let GenericArgKind::Type(ty) = substs_with_referent_ty[param_ty.index as usize].unpack()
+                && ty.is_array()
+                && !meets_msrv(msrv, msrvs::ARRAY_INTO_ITERATOR)
+            {
+                return false;
+            }
+
+            let predicate = EarlyBinder(predicate).subst(cx.tcx, &substs_with_referent_ty);
+            let obligation = Obligation::new(ObligationCause::dummy(), cx.param_env, predicate);
+            cx.tcx
+                .infer_ctxt()
+                .enter(|infcx| infcx.predicate_must_hold_modulo_regions(&obligation))
+        })
+    };
+
+    let mut needless_borrow = false;
+    while let ExprKind::AddrOf(_, _, referent) = expr.kind {
+        if !check_referent(referent) {
+            break;
+        }
+        expr = referent;
+        needless_borrow = true;
+    }
+
+    if needless_borrow {
+        Position::ImplArg(expr.hir_id)
+    } else {
+        Position::Other(precedence)
+    }
+}
+
+fn has_ref_mut_self_method(cx: &LateContext<'_>, trait_def_id: DefId) -> bool {
+    cx.tcx
+        .associated_items(trait_def_id)
+        .in_definition_order()
+        .any(|assoc_item| {
+            if assoc_item.fn_has_self_parameter {
+                let self_ty = cx.tcx.fn_sig(assoc_item.def_id).skip_binder().inputs()[0];
+                matches!(self_ty.kind(), ty::Ref(_, _, Mutability::Mut))
+            } else {
+                false
+            }
+        })
+}
+
+// Iteratively replaces `param_ty` with `new_ty` in `substs`, and similarly for each resulting
+// projected type that is a type parameter. Returns `false` if replacing the types would have an
+// effect on the function signature beyond substituting `new_ty` for `param_ty`.
+// See: https://github.com/rust-lang/rust-clippy/pull/9136#discussion_r927212757
+fn replace_types<'tcx>(
+    cx: &LateContext<'tcx>,
+    param_ty: ParamTy,
+    new_ty: Ty<'tcx>,
+    fn_sig: FnSig<'tcx>,
+    arg_index: usize,
+    projection_predicates: &[ProjectionPredicate<'tcx>],
+    substs: &mut [ty::GenericArg<'tcx>],
+) -> bool {
+    let mut replaced = BitSet::new_empty(substs.len());
+
+    let mut deque = VecDeque::with_capacity(substs.len());
+    deque.push_back((param_ty, new_ty));
+
+    while let Some((param_ty, new_ty)) = deque.pop_front() {
+        // If `replaced.is_empty()`, then `param_ty` and `new_ty` are those initially passed in.
+        if !fn_sig
+            .inputs_and_output
+            .iter()
+            .enumerate()
+            .all(|(i, ty)| (replaced.is_empty() && i == arg_index) || !contains_ty(ty, param_ty.to_ty(cx.tcx)))
+        {
+            return false;
+        }
+
+        substs[param_ty.index as usize] = ty::GenericArg::from(new_ty);
+
+        // The `replaced.insert(...)` check provides some protection against infinite loops.
+        if replaced.insert(param_ty.index) {
+            for projection_predicate in projection_predicates {
+                if projection_predicate.projection_ty.self_ty() == param_ty.to_ty(cx.tcx)
+                    && let ty::Term::Ty(term_ty) = projection_predicate.term
+                    && let ty::Param(term_param_ty) = term_ty.kind()
+                {
+                    let item_def_id = projection_predicate.projection_ty.item_def_id;
+                    let assoc_item = cx.tcx.associated_item(item_def_id);
+                    let projection = cx.tcx
+                        .mk_projection(assoc_item.def_id, cx.tcx.mk_substs_trait(new_ty, &[]));
+
+                    if let Ok(projected_ty) = cx.tcx.try_normalize_erasing_regions(cx.param_env, projection)
+                        && substs[term_param_ty.index as usize] != ty::GenericArg::from(projected_ty)
+                    {
+                        deque.push_back((*term_param_ty, projected_ty));
+                    }
+                }
+            }
+        }
+    }
+
+    true
+}
+
 struct TyPosition<'tcx> {
     position: Position,
     ty: Option<Ty<'tcx>>,
@@ -1084,7 +1328,8 @@ fn report<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, state: State, data
         },
         State::DerefedBorrow(state) => {
             let mut app = Applicability::MachineApplicable;
-            let (snip, snip_is_macro) = snippet_with_context(cx, expr.span, data.span.ctxt(), "..", &mut app);
+            let snip_expr = state.snip_expr.map_or(expr, |hir_id| cx.tcx.hir().expect_expr(hir_id));
+            let (snip, snip_is_macro) = snippet_with_context(cx, snip_expr.span, data.span.ctxt(), "..", &mut app);
             span_lint_hir_and_then(cx, NEEDLESS_BORROW, data.hir_id, data.span, state.msg, |diag| {
                 let calls_field = matches!(expr.kind, ExprKind::Field(..)) && matches!(data.position, Position::Callee);
                 let sugg = if !snip_is_macro
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index e6a405f8170..521739c28ff 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -821,7 +821,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(verbose_file_reads::VerboseFileReads));
     store.register_late_pass(|| Box::new(redundant_pub_crate::RedundantPubCrate::default()));
     store.register_late_pass(|| Box::new(unnamed_address::UnnamedAddress));
-    store.register_late_pass(|| Box::new(dereference::Dereferencing::default()));
+    store.register_late_pass(move || Box::new(dereference::Dereferencing::new(msrv)));
     store.register_late_pass(|| Box::new(option_if_let_else::OptionIfLetElse));
     store.register_late_pass(|| Box::new(future_not_send::FutureNotSend));
     store.register_late_pass(|| Box::new(if_let_mutex::IfLetMutex));
diff --git a/clippy_lints/src/methods/unnecessary_to_owned.rs b/clippy_lints/src/methods/unnecessary_to_owned.rs
index 99b56da7a50..e4624167ad0 100644
--- a/clippy_lints/src/methods/unnecessary_to_owned.rs
+++ b/clippy_lints/src/methods/unnecessary_to_owned.rs
@@ -6,9 +6,8 @@ use clippy_utils::ty::{
     contains_ty, get_associated_type, get_iterator_item_ty, implements_trait, is_copy, is_type_diagnostic_item,
     peel_mid_ty_refs,
 };
-use clippy_utils::{meets_msrv, msrvs};
-
 use clippy_utils::{fn_def_id, get_parent_expr, is_diag_item_method, is_diag_trait_item};
+use clippy_utils::{meets_msrv, msrvs};
 use rustc_errors::Applicability;
 use rustc_hir::{def_id::DefId, BorrowKind, Expr, ExprKind};
 use rustc_lint::LateContext;
@@ -373,25 +372,15 @@ fn get_input_traits_and_projections<'tcx>(
 ) -> (Vec<TraitPredicate<'tcx>>, Vec<ProjectionPredicate<'tcx>>) {
     let mut trait_predicates = Vec::new();
     let mut projection_predicates = Vec::new();
-    for (predicate, _) in cx.tcx.predicates_of(callee_def_id).predicates.iter() {
-        // `substs` should have 1 + n elements. The first is the type on the left hand side of an
-        // `as`. The remaining n are trait parameters.
-        let is_input_substs = |substs: SubstsRef<'tcx>| {
-            if_chain! {
-                if let Some(arg) = substs.iter().next();
-                if let GenericArgKind::Type(arg_ty) = arg.unpack();
-                if arg_ty == input;
-                then { true } else { false }
-            }
-        };
+    for predicate in cx.tcx.param_env(callee_def_id).caller_bounds() {
         match predicate.kind().skip_binder() {
             PredicateKind::Trait(trait_predicate) => {
-                if is_input_substs(trait_predicate.trait_ref.substs) {
+                if trait_predicate.trait_ref.self_ty() == input {
                     trait_predicates.push(trait_predicate);
                 }
             },
             PredicateKind::Projection(projection_predicate) => {
-                if is_input_substs(projection_predicate.projection_ty.substs) {
+                if projection_predicate.projection_ty.self_ty() == input {
                     projection_predicates.push(projection_predicate);
                 }
             },
diff --git a/clippy_utils/src/msrvs.rs b/clippy_utils/src/msrvs.rs
index 9e238c6f1ac..7fa0046a267 100644
--- a/clippy_utils/src/msrvs.rs
+++ b/clippy_utils/src/msrvs.rs
@@ -13,7 +13,7 @@ macro_rules! msrv_aliases {
 // names may refer to stabilized feature flags or library items
 msrv_aliases! {
     1,62,0 { BOOL_THEN_SOME }
-    1,53,0 { OR_PATTERNS, MANUAL_BITS, BTREE_MAP_RETAIN, BTREE_SET_RETAIN }
+    1,53,0 { OR_PATTERNS, MANUAL_BITS, BTREE_MAP_RETAIN, BTREE_SET_RETAIN, ARRAY_INTO_ITERATOR }
     1,52,0 { STR_SPLIT_ONCE, REM_EUCLID_CONST }
     1,51,0 { BORROW_AS_PTR, UNSIGNED_ABS }
     1,50,0 { BOOL_THEN }
diff --git a/tests/ui/needless_borrow.fixed b/tests/ui/needless_borrow.fixed
index bfd2725ecaa..8cf93bd2481 100644
--- a/tests/ui/needless_borrow.fixed
+++ b/tests/ui/needless_borrow.fixed
@@ -1,6 +1,6 @@
 // run-rustfix
 
-#![feature(lint_reasons)]
+#![feature(custom_inner_attributes, lint_reasons)]
 
 #[warn(clippy::all, clippy::needless_borrow)]
 #[allow(unused_variables, clippy::unnecessary_mut_passed)]
@@ -127,6 +127,20 @@ fn main() {
             0
         }
     }
+
+    let _ = std::process::Command::new("ls").args(["-a", "-l"]).status().unwrap();
+    let _ = std::path::Path::new(".").join(".");
+    deref_target_is_x(X);
+    multiple_constraints([[""]]);
+    multiple_constraints_normalizes_to_same(X, X);
+    let _ = Some("").unwrap_or("");
+
+    only_sized(&""); // Don't lint. `Sized` is only bound
+    let _ = std::any::Any::type_id(&""); // Don't lint. `Any` is only bound
+    let _ = Box::new(&""); // Don't lint. Type parameter appears in return type
+    ref_as_ref_path(&""); // Don't lint. Argument type is not a type parameter
+    refs_only(&()); // Don't lint. `&T` implements trait, but `T` doesn't
+    multiple_constraints_normalizes_to_different(&[[""]], &[""]); // Don't lint. Projected type appears in arguments
 }
 
 #[allow(clippy::needless_borrowed_reference)]
@@ -183,3 +197,104 @@ mod issue9160 {
         }
     }
 }
+
+#[derive(Clone, Copy)]
+struct X;
+
+impl std::ops::Deref for X {
+    type Target = X;
+    fn deref(&self) -> &Self::Target {
+        self
+    }
+}
+
+fn deref_target_is_x<T>(_: T)
+where
+    T: std::ops::Deref<Target = X>,
+{
+}
+
+fn multiple_constraints<T, U, V, X, Y>(_: T)
+where
+    T: IntoIterator<Item = U> + IntoIterator<Item = X>,
+    U: IntoIterator<Item = V>,
+    V: AsRef<str>,
+    X: IntoIterator<Item = Y>,
+    Y: AsRef<std::ffi::OsStr>,
+{
+}
+
+fn multiple_constraints_normalizes_to_same<T, U, V>(_: T, _: V)
+where
+    T: std::ops::Deref<Target = U>,
+    U: std::ops::Deref<Target = V>,
+{
+}
+
+fn only_sized<T>(_: T) {}
+
+fn ref_as_ref_path<T: 'static>(_: &'static T)
+where
+    &'static T: AsRef<std::path::Path>,
+{
+}
+
+trait RefsOnly {
+    type Referent;
+}
+
+impl<T> RefsOnly for &T {
+    type Referent = T;
+}
+
+fn refs_only<T, U>(_: T)
+where
+    T: RefsOnly<Referent = U>,
+{
+}
+
+fn multiple_constraints_normalizes_to_different<T, U, V>(_: T, _: U)
+where
+    T: IntoIterator<Item = U>,
+    U: IntoIterator<Item = V>,
+    V: AsRef<str>,
+{
+}
+
+// https://github.com/rust-lang/rust-clippy/pull/9136#pullrequestreview-1037379321
+#[allow(dead_code)]
+mod copyable_iterator {
+    #[derive(Clone, Copy)]
+    struct Iter;
+    impl Iterator for Iter {
+        type Item = ();
+        fn next(&mut self) -> Option<Self::Item> {
+            None
+        }
+    }
+    fn takes_iter(_: impl Iterator) {}
+    fn dont_warn(mut x: Iter) {
+        takes_iter(&mut x);
+    }
+    fn warn(mut x: &mut Iter) {
+        takes_iter(&mut x)
+    }
+}
+
+mod under_msrv {
+    #![allow(dead_code)]
+    #![clippy::msrv = "1.52.0"]
+
+    fn foo() {
+        let _ = std::process::Command::new("ls").args(&["-a", "-l"]).status().unwrap();
+    }
+}
+
+mod meets_msrv {
+    #![allow(dead_code)]
+    #![clippy::msrv = "1.53.0"]
+
+    fn foo() {
+        let _ = std::process::Command::new("ls").args(["-a", "-l"]).status().unwrap();
+    }
+}
diff --git a/tests/ui/needless_borrow.rs b/tests/ui/needless_borrow.rs
index c457d8c5471..fd9b2a11df9 100644
--- a/tests/ui/needless_borrow.rs
+++ b/tests/ui/needless_borrow.rs
@@ -1,6 +1,6 @@
 // run-rustfix
 
-#![feature(lint_reasons)]
+#![feature(custom_inner_attributes, lint_reasons)]
 
 #[warn(clippy::all, clippy::needless_borrow)]
 #[allow(unused_variables, clippy::unnecessary_mut_passed)]
@@ -127,6 +127,20 @@ fn main() {
             0
         }
     }
+
+    let _ = std::process::Command::new("ls").args(&["-a", "-l"]).status().unwrap();
+    let _ = std::path::Path::new(".").join(&&".");
+    deref_target_is_x(&X);
+    multiple_constraints(&[[""]]);
+    multiple_constraints_normalizes_to_same(&X, X);
+    let _ = Some("").unwrap_or(&"");
+
+    only_sized(&""); // Don't lint. `Sized` is only bound
+    let _ = std::any::Any::type_id(&""); // Don't lint. `Any` is only bound
+    let _ = Box::new(&""); // Don't lint. Type parameter appears in return type
+    ref_as_ref_path(&""); // Don't lint. Argument type is not a type parameter
+    refs_only(&()); // Don't lint. `&T` implements trait, but `T` doesn't
+    multiple_constraints_normalizes_to_different(&[[""]], &[""]); // Don't lint. Projected type appears in arguments
 }
 
 #[allow(clippy::needless_borrowed_reference)]
@@ -183,3 +197,104 @@ mod issue9160 {
         }
     }
 }
+
+#[derive(Clone, Copy)]
+struct X;
+
+impl std::ops::Deref for X {
+    type Target = X;
+    fn deref(&self) -> &Self::Target {
+        self
+    }
+}
+
+fn deref_target_is_x<T>(_: T)
+where
+    T: std::ops::Deref<Target = X>,
+{
+}
+
+fn multiple_constraints<T, U, V, X, Y>(_: T)
+where
+    T: IntoIterator<Item = U> + IntoIterator<Item = X>,
+    U: IntoIterator<Item = V>,
+    V: AsRef<str>,
+    X: IntoIterator<Item = Y>,
+    Y: AsRef<std::ffi::OsStr>,
+{
+}
+
+fn multiple_constraints_normalizes_to_same<T, U, V>(_: T, _: V)
+where
+    T: std::ops::Deref<Target = U>,
+    U: std::ops::Deref<Target = V>,
+{
+}
+
+fn only_sized<T>(_: T) {}
+
+fn ref_as_ref_path<T: 'static>(_: &'static T)
+where
+    &'static T: AsRef<std::path::Path>,
+{
+}
+
+trait RefsOnly {
+    type Referent;
+}
+
+impl<T> RefsOnly for &T {
+    type Referent = T;
+}
+
+fn refs_only<T, U>(_: T)
+where
+    T: RefsOnly<Referent = U>,
+{
+}
+
+fn multiple_constraints_normalizes_to_different<T, U, V>(_: T, _: U)
+where
+    T: IntoIterator<Item = U>,
+    U: IntoIterator<Item = V>,
+    V: AsRef<str>,
+{
+}
+
+// https://github.com/rust-lang/rust-clippy/pull/9136#pullrequestreview-1037379321
+#[allow(dead_code)]
+mod copyable_iterator {
+    #[derive(Clone, Copy)]
+    struct Iter;
+    impl Iterator for Iter {
+        type Item = ();
+        fn next(&mut self) -> Option<Self::Item> {
+            None
+        }
+    }
+    fn takes_iter(_: impl Iterator) {}
+    fn dont_warn(mut x: Iter) {
+        takes_iter(&mut x);
+    }
+    fn warn(mut x: &mut Iter) {
+        takes_iter(&mut x)
+    }
+}
+
+mod under_msrv {
+    #![allow(dead_code)]
+    #![clippy::msrv = "1.52.0"]
+
+    fn foo() {
+        let _ = std::process::Command::new("ls").args(&["-a", "-l"]).status().unwrap();
+    }
+}
+
+mod meets_msrv {
+    #![allow(dead_code)]
+    #![clippy::msrv = "1.53.0"]
+
+    fn foo() {
+        let _ = std::process::Command::new("ls").args(&["-a", "-l"]).status().unwrap();
+    }
+}
diff --git a/tests/ui/needless_borrow.stderr b/tests/ui/needless_borrow.stderr
index 66588689d81..5af68706d4b 100644
--- a/tests/ui/needless_borrow.stderr
+++ b/tests/ui/needless_borrow.stderr
@@ -120,17 +120,59 @@ error: this expression creates a reference which is immediately dereferenced by
 LL |     (&&5).foo();
    |     ^^^^^ help: change this to: `(&5)`
 
+error: the borrowed expression implements the required traits
+  --> $DIR/needless_borrow.rs:131:51
+   |
+LL |     let _ = std::process::Command::new("ls").args(&["-a", "-l"]).status().unwrap();
+   |                                                   ^^^^^^^^^^^^^ help: change this to: `["-a", "-l"]`
+
+error: the borrowed expression implements the required traits
+  --> $DIR/needless_borrow.rs:132:44
+   |
+LL |     let _ = std::path::Path::new(".").join(&&".");
+   |                                            ^^^^^ help: change this to: `"."`
+
+error: the borrowed expression implements the required traits
+  --> $DIR/needless_borrow.rs:133:23
+   |
+LL |     deref_target_is_x(&X);
+   |                       ^^ help: change this to: `X`
+
+error: the borrowed expression implements the required traits
+  --> $DIR/needless_borrow.rs:134:26
+   |
+LL |     multiple_constraints(&[[""]]);
+   |                          ^^^^^^^ help: change this to: `[[""]]`
+
+error: the borrowed expression implements the required traits
+  --> $DIR/needless_borrow.rs:135:45
+   |
+LL |     multiple_constraints_normalizes_to_same(&X, X);
+   |                                             ^^ help: change this to: `X`
+
+error: this expression creates a reference which is immediately dereferenced by the compiler
+  --> $DIR/needless_borrow.rs:136:32
+   |
+LL |     let _ = Some("").unwrap_or(&"");
+   |                                ^^^ help: change this to: `""`
+
 error: this expression borrows a value the compiler would automatically borrow
-  --> $DIR/needless_borrow.rs:173:13
+  --> $DIR/needless_borrow.rs:187:13
    |
 LL |             (&self.f)()
    |             ^^^^^^^^^ help: change this to: `(self.f)`
 
 error: this expression borrows a value the compiler would automatically borrow
-  --> $DIR/needless_borrow.rs:182:13
+  --> $DIR/needless_borrow.rs:196:13
    |
 LL |             (&mut self.f)()
    |             ^^^^^^^^^^^^^ help: change this to: `(self.f)`
 
-error: aborting due to 22 previous errors
+error: the borrowed expression implements the required traits
+  --> $DIR/needless_borrow.rs:298:55
+   |
+LL |         let _ = std::process::Command::new("ls").args(&["-a", "-l"]).status().unwrap();
+   |                                                       ^^^^^^^^^^^^^ help: change this to: `["-a", "-l"]`
+
+error: aborting due to 29 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From aadd0148632645a3244c0ca119d47c5a736c042a Mon Sep 17 00:00:00 2001
From: cherryblossom <31467609+cherryblossom000@users.noreply.github.com>
Date: Wed, 17 Aug 2022 18:56:06 +1000
Subject: Fix typo in as_undescore docs

du -> due
---
 clippy_lints/src/as_underscore.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/as_underscore.rs b/clippy_lints/src/as_underscore.rs
index 0bdef9d0a7e..5b4b2c631c8 100644
--- a/clippy_lints/src/as_underscore.rs
+++ b/clippy_lints/src/as_underscore.rs
@@ -12,7 +12,7 @@ declare_clippy_lint! {
     ///
     /// ### Why is this bad?
     /// The conversion might include lossy conversion and dangerous cast that might go
-    /// undetected du to the type being inferred.
+    /// undetected due to the type being inferred.
     ///
     /// The lint is allowed by default as using `_` is less wordy than always specifying the type.
     ///
-- 
cgit 1.4.1-3-g733a5


From ab91d5a5408cdb888b49ed3d893c0e28afef5861 Mon Sep 17 00:00:00 2001
From: Sosthène Guédon <sosthene@guedon.gdn>
Date: Wed, 17 Aug 2022 18:58:17 +0200
Subject: unwrap_used: Fix error message for unwrap_err when expect_used is
 allowed

---
 clippy_lints/src/methods/unwrap_used.rs |  6 +++---
 tests/ui/expect.rs                      |  3 ++-
 tests/ui/expect.stderr                  | 10 +++++++++-
 tests/ui/unwrap.rs                      |  3 ++-
 tests/ui/unwrap.stderr                  | 10 +++++++++-
 5 files changed, 25 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/unwrap_used.rs b/clippy_lints/src/methods/unwrap_used.rs
index 05915c14109..ee17f2d7889 100644
--- a/clippy_lints/src/methods/unwrap_used.rs
+++ b/clippy_lints/src/methods/unwrap_used.rs
@@ -25,7 +25,7 @@ pub(super) fn check(
         None
     };
 
-    let method = if is_err { "unwrap_err" } else { "unwrap" };
+    let method_suffix = if is_err { "_err" } else { "" };
 
     if allow_unwrap_in_tests && is_in_test_function(cx.tcx, expr.hir_id) {
         return;
@@ -35,7 +35,7 @@ pub(super) fn check(
         let help = if is_lint_allowed(cx, EXPECT_USED, expr.hir_id) {
             format!(
                 "if you don't want to handle the `{none_value}` case gracefully, consider \
-                using `expect()` to provide a better panic message"
+                using `expect{method_suffix}()` to provide a better panic message"
             )
         } else {
             format!("if this value is {none_prefix}`{none_value}`, it will panic")
@@ -45,7 +45,7 @@ pub(super) fn check(
             cx,
             lint,
             expr.span,
-            &format!("used `{method}()` on `{kind}` value"),
+            &format!("used `unwrap{method_suffix}()` on `{kind}` value"),
             None,
             &help,
         );
diff --git a/tests/ui/expect.rs b/tests/ui/expect.rs
index 1073acf6f0c..d742595e14d 100644
--- a/tests/ui/expect.rs
+++ b/tests/ui/expect.rs
@@ -6,8 +6,9 @@ fn expect_option() {
 }
 
 fn expect_result() {
-    let res: Result<u8, ()> = Ok(0);
+    let res: Result<u8, u8> = Ok(0);
     let _ = res.expect("");
+    let _ = res.expect_err("");
 }
 
 fn main() {
diff --git a/tests/ui/expect.stderr b/tests/ui/expect.stderr
index ab28aac4556..904c0904645 100644
--- a/tests/ui/expect.stderr
+++ b/tests/ui/expect.stderr
@@ -15,5 +15,13 @@ LL |     let _ = res.expect("");
    |
    = help: if this value is an `Err`, it will panic
 
-error: aborting due to 2 previous errors
+error: used `expect_err()` on `a Result` value
+  --> $DIR/expect.rs:11:13
+   |
+LL |     let _ = res.expect_err("");
+   |             ^^^^^^^^^^^^^^^^^^
+   |
+   = help: if this value is an `Ok`, it will panic
+
+error: aborting due to 3 previous errors
 
diff --git a/tests/ui/unwrap.rs b/tests/ui/unwrap.rs
index a4a3cd1d379..d9fd402e7cf 100644
--- a/tests/ui/unwrap.rs
+++ b/tests/ui/unwrap.rs
@@ -6,8 +6,9 @@ fn unwrap_option() {
 }
 
 fn unwrap_result() {
-    let res: Result<u8, ()> = Ok(0);
+    let res: Result<u8, u8> = Ok(0);
     let _ = res.unwrap();
+    let _ = res.unwrap_err();
 }
 
 fn main() {
diff --git a/tests/ui/unwrap.stderr b/tests/ui/unwrap.stderr
index 4f0858005f6..78422757819 100644
--- a/tests/ui/unwrap.stderr
+++ b/tests/ui/unwrap.stderr
@@ -15,5 +15,13 @@ LL |     let _ = res.unwrap();
    |
    = help: if you don't want to handle the `Err` case gracefully, consider using `expect()` to provide a better panic message
 
-error: aborting due to 2 previous errors
+error: used `unwrap_err()` on `a Result` value
+  --> $DIR/unwrap.rs:11:13
+   |
+LL |     let _ = res.unwrap_err();
+   |             ^^^^^^^^^^^^^^^^
+   |
+   = help: if you don't want to handle the `Ok` case gracefully, consider using `expect_err()` to provide a better panic message
+
+error: aborting due to 3 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From e87a5a1cc5e799b929abf27a03a6535a88698ce6 Mon Sep 17 00:00:00 2001
From: Lukas Lueg <lukas.lueg@gmail.com>
Date: Thu, 18 Aug 2022 19:30:56 +0200
Subject: Dont lint on match pattern-binding

Fixes #9347

Technically it is possible to have a blank match-pattern that does
nothing, and we fail to lint. But its easier to be safe than sorry here.
---
 clippy_lints/src/question_mark.rs |  2 +-
 tests/ui/question_mark.fixed      | 15 +++++++++++++++
 tests/ui/question_mark.rs         | 15 +++++++++++++++
 3 files changed, 31 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/question_mark.rs b/clippy_lints/src/question_mark.rs
index 964a057f00d..b432ccb1ee3 100644
--- a/clippy_lints/src/question_mark.rs
+++ b/clippy_lints/src/question_mark.rs
@@ -123,7 +123,7 @@ fn check_if_let_some_or_err_and_early_return<'tcx>(cx: &LateContext<'tcx>, expr:
         if let Some(higher::IfLet { let_pat, let_expr, if_then, if_else }) = higher::IfLet::hir(cx, expr);
         if !is_else_clause(cx.tcx, expr);
         if let PatKind::TupleStruct(ref path1, [field], None) = let_pat.kind;
-        if let PatKind::Binding(annot, bind_id, ident, _) = field.kind;
+        if let PatKind::Binding(annot, bind_id, ident, None) = field.kind;
         let caller_ty = cx.typeck_results().expr_ty(let_expr);
         let if_block = IfBlockType::IfLet(path1, caller_ty, ident.name, let_expr, if_then, if_else);
         if (is_early_return(sym::Option, cx, &if_block) && path_to_local_id(peel_blocks(if_then), bind_id))
diff --git a/tests/ui/question_mark.fixed b/tests/ui/question_mark.fixed
index c4c9c821433..57f23bd1916 100644
--- a/tests/ui/question_mark.fixed
+++ b/tests/ui/question_mark.fixed
@@ -207,4 +207,19 @@ fn option_map() -> Option<bool> {
     }
 }
 
+pub struct PatternedError {
+    flag: bool,
+}
+
+// No warning
+fn pattern() -> Result<(), PatternedError> {
+    let res = Ok(());
+
+    if let Err(err @ PatternedError { flag: true }) = res {
+        return Err(err);
+    }
+
+    res
+}
+
 fn main() {}
diff --git a/tests/ui/question_mark.rs b/tests/ui/question_mark.rs
index cdbc7b1606f..436f027c215 100644
--- a/tests/ui/question_mark.rs
+++ b/tests/ui/question_mark.rs
@@ -243,4 +243,19 @@ fn option_map() -> Option<bool> {
     }
 }
 
+pub struct PatternedError {
+    flag: bool,
+}
+
+// No warning
+fn pattern() -> Result<(), PatternedError> {
+    let res = Ok(());
+
+    if let Err(err @ PatternedError { flag: true }) = res {
+        return Err(err);
+    }
+
+    res
+}
+
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 2666c38acb8352b7fd5903f50ee5fd76e2441cff Mon Sep 17 00:00:00 2001
From: Serial <69764315+Serial-ATA@users.noreply.github.com>
Date: Thu, 28 Jul 2022 20:50:43 -0400
Subject: Add [`unused_peekable`] lint

---
 CHANGELOG.md                                |   1 +
 clippy_lints/src/lib.register_all.rs        |   1 +
 clippy_lints/src/lib.register_lints.rs      |   1 +
 clippy_lints/src/lib.register_suspicious.rs |   1 +
 clippy_lints/src/lib.rs                     |   2 +
 clippy_lints/src/unused_peekable.rs         | 208 ++++++++++++++++++++++++++++
 clippy_utils/src/paths.rs                   |   1 +
 clippy_utils/src/ty.rs                      |   2 +-
 tests/ui/unused_peekable.rs                 | 119 ++++++++++++++++
 tests/ui/unused_peekable.stderr             |  51 +++++++
 10 files changed, 386 insertions(+), 1 deletion(-)
 create mode 100644 clippy_lints/src/unused_peekable.rs
 create mode 100644 tests/ui/unused_peekable.rs
 create mode 100644 tests/ui/unused_peekable.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index edd7bc250a7..c42a03c04a0 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4152,6 +4152,7 @@ Released 2018-09-13
 [`unused_collect`]: https://rust-lang.github.io/rust-clippy/master/index.html#unused_collect
 [`unused_io_amount`]: https://rust-lang.github.io/rust-clippy/master/index.html#unused_io_amount
 [`unused_label`]: https://rust-lang.github.io/rust-clippy/master/index.html#unused_label
+[`unused_peekable`]: https://rust-lang.github.io/rust-clippy/master/index.html#unused_peekable
 [`unused_rounding`]: https://rust-lang.github.io/rust-clippy/master/index.html#unused_rounding
 [`unused_self`]: https://rust-lang.github.io/rust-clippy/master/index.html#unused_self
 [`unused_unit`]: https://rust-lang.github.io/rust-clippy/master/index.html#unused_unit
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index a0a4b07a77e..de0514c1b66 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -337,6 +337,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(unnecessary_sort_by::UNNECESSARY_SORT_BY),
     LintId::of(unsafe_removed_from_name::UNSAFE_REMOVED_FROM_NAME),
     LintId::of(unused_io_amount::UNUSED_IO_AMOUNT),
+    LintId::of(unused_peekable::UNUSED_PEEKABLE),
     LintId::of(unused_unit::UNUSED_UNIT),
     LintId::of(unwrap::PANICKING_UNWRAP),
     LintId::of(unwrap::UNNECESSARY_UNWRAP),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index b7dbd30aa0c..eb23bb0c7db 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -573,6 +573,7 @@ store.register_lints(&[
     unsafe_removed_from_name::UNSAFE_REMOVED_FROM_NAME,
     unused_async::UNUSED_ASYNC,
     unused_io_amount::UNUSED_IO_AMOUNT,
+    unused_peekable::UNUSED_PEEKABLE,
     unused_rounding::UNUSED_ROUNDING,
     unused_self::UNUSED_SELF,
     unused_unit::UNUSED_UNIT,
diff --git a/clippy_lints/src/lib.register_suspicious.rs b/clippy_lints/src/lib.register_suspicious.rs
index 6e185f8d31e..5793d59bcad 100644
--- a/clippy_lints/src/lib.register_suspicious.rs
+++ b/clippy_lints/src/lib.register_suspicious.rs
@@ -33,4 +33,5 @@ store.register_group(true, "clippy::suspicious", Some("clippy_suspicious"), vec!
     LintId::of(suspicious_trait_impl::SUSPICIOUS_OP_ASSIGN_IMPL),
     LintId::of(swap_ptr_to_ref::SWAP_PTR_TO_REF),
     LintId::of(write::POSITIONAL_NAMED_FORMAT_PARAMETERS),
+    LintId::of(unused_peekable::UNUSED_PEEKABLE),
 ])
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index a041fbc7fd9..d4c6c4918cb 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -398,6 +398,7 @@ mod unnested_or_patterns;
 mod unsafe_removed_from_name;
 mod unused_async;
 mod unused_io_amount;
+mod unused_peekable;
 mod unused_rounding;
 mod unused_self;
 mod unused_unit;
@@ -935,6 +936,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(manual_instant_elapsed::ManualInstantElapsed));
     store.register_late_pass(|| Box::new(partialeq_to_none::PartialeqToNone));
     store.register_late_pass(|| Box::new(manual_empty_string_creations::ManualEmptyStringCreations));
+    store.register_late_pass(|| Box::new(unused_peekable::UnusedPeekable::default()));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/unused_peekable.rs b/clippy_lints/src/unused_peekable.rs
new file mode 100644
index 00000000000..4988ec0eca1
--- /dev/null
+++ b/clippy_lints/src/unused_peekable.rs
@@ -0,0 +1,208 @@
+use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::ty::{match_type, peel_mid_ty_refs_is_mutable};
+use clippy_utils::{fn_def_id, path_to_local_id, paths, peel_ref_operators};
+use rustc_ast::Mutability;
+use rustc_hir::intravisit::{walk_expr, Visitor};
+use rustc_hir::lang_items::LangItem;
+use rustc_hir::{Block, Expr, ExprKind, HirId, Local, Node, PatKind, PathSegment, StmtKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::Ty;
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for the creation of a `peekable` iterator that is never `.peek()`ed
+    ///
+    /// ### Why is this bad?
+    /// Creating a peekable iterator without using any of its methods is likely a mistake,
+    /// or just a leftover after a refactor.
+    ///
+    /// ### Example
+    /// ```rust
+    /// let collection = vec![1, 2, 3];
+    /// let iter = collection.iter().peekable();
+    ///
+    /// for item in iter {
+    ///     // ...
+    /// }
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust
+    /// let collection = vec![1, 2, 3];
+    /// let iter = collection.iter();
+    ///
+    /// for item in iter {
+    ///     // ...
+    /// }
+    /// ```
+    #[clippy::version = "1.64.0"]
+    pub UNUSED_PEEKABLE,
+    suspicious,
+    "creating a peekable iterator without using any of its methods"
+}
+
+#[derive(Default)]
+pub struct UnusedPeekable {
+    visited: Vec<HirId>,
+}
+
+impl_lint_pass!(UnusedPeekable => [UNUSED_PEEKABLE]);
+
+impl<'tcx> LateLintPass<'tcx> for UnusedPeekable {
+    fn check_block(&mut self, cx: &LateContext<'tcx>, block: &Block<'tcx>) {
+        // Don't lint `Peekable`s returned from a block
+        if let Some(expr) = block.expr
+            && let Some(ty) = cx.typeck_results().expr_ty_opt(peel_ref_operators(cx, expr))
+            && match_type(cx, ty, &paths::PEEKABLE)
+        {
+            return;
+        }
+
+        for (idx, stmt) in block.stmts.iter().enumerate() {
+            if !stmt.span.from_expansion()
+                && let StmtKind::Local(local) = stmt.kind
+                && !self.visited.contains(&local.pat.hir_id)
+                && let PatKind::Binding(_, _, ident, _) = local.pat.kind
+                && let Some(init) = local.init
+                && !init.span.from_expansion()
+                && let Some(ty) = cx.typeck_results().expr_ty_opt(init)
+                && let (ty, _, Mutability::Mut) = peel_mid_ty_refs_is_mutable(ty)
+                && match_type(cx, ty, &paths::PEEKABLE)
+            {
+                let mut vis = PeekableVisitor::new(cx, local.pat.hir_id);
+
+                if idx + 1 == block.stmts.len() && block.expr.is_none() {
+                    return;
+                }
+
+                for stmt in &block.stmts[idx..] {
+                    vis.visit_stmt(stmt);
+                }
+
+                if let Some(expr) = block.expr {
+                    vis.visit_expr(expr);
+                }
+
+                if !vis.found_peek_call {
+                    span_lint_and_help(
+                        cx,
+                        UNUSED_PEEKABLE,
+                        ident.span,
+                        "`peek` never called on `Peekable` iterator",
+                        None,
+                        "consider removing the call to `peekable`"
+                   );
+                }
+            }
+        }
+    }
+}
+
+struct PeekableVisitor<'a, 'tcx> {
+    cx: &'a LateContext<'tcx>,
+    expected_hir_id: HirId,
+    found_peek_call: bool,
+}
+
+impl<'a, 'tcx> PeekableVisitor<'a, 'tcx> {
+    fn new(cx: &'a LateContext<'tcx>, expected_hir_id: HirId) -> Self {
+        Self {
+            cx,
+            expected_hir_id,
+            found_peek_call: false,
+        }
+    }
+}
+
+impl<'tcx> Visitor<'_> for PeekableVisitor<'_, 'tcx> {
+    fn visit_expr(&mut self, ex: &'_ Expr<'_>) {
+        if path_to_local_id(ex, self.expected_hir_id) {
+            for (_, node) in self.cx.tcx.hir().parent_iter(ex.hir_id) {
+                match node {
+                    Node::Expr(expr) => {
+                        match expr.kind {
+                            // some_function(peekable)
+                            //
+                            // If the Peekable is passed to a function, stop
+                            ExprKind::Call(_, args) => {
+                                if let Some(func_did) = fn_def_id(self.cx, expr)
+                                    && let Ok(into_iter_did) = self
+                                        .cx
+                                        .tcx
+                                        .lang_items()
+                                        .require(LangItem::IntoIterIntoIter)
+                                    && func_did == into_iter_did
+                                {
+                                    // Probably a for loop desugar, stop searching
+                                    return;
+                                }
+
+                                for arg in args.iter().map(|arg| peel_ref_operators(self.cx, arg)) {
+                                    if let ExprKind::Path(_) = arg.kind
+                                        && let Some(ty) = self
+                                            .cx
+                                            .typeck_results()
+                                            .expr_ty_opt(arg)
+                                            .map(Ty::peel_refs)
+                                        && match_type(self.cx, ty, &paths::PEEKABLE)
+                                    {
+                                        self.found_peek_call = true;
+                                        return;
+                                    }
+                                }
+                            },
+                            // Peekable::peek()
+                            ExprKind::MethodCall(PathSegment { ident: method_name, .. }, [arg, ..], _) => {
+                                let arg = peel_ref_operators(self.cx, arg);
+                                let method_name = method_name.name.as_str();
+
+                                if (method_name == "peek"
+                                    || method_name == "peek_mut"
+                                    || method_name == "next_if"
+                                    || method_name == "next_if_eq")
+                                    && let ExprKind::Path(_) = arg.kind
+                                    && let Some(ty) = self.cx.typeck_results().expr_ty_opt(arg).map(Ty::peel_refs)
+                                    && match_type(self.cx, ty, &paths::PEEKABLE)
+                                {
+                                    self.found_peek_call = true;
+                                    return;
+                                }
+                            },
+                            // Don't bother if moved into a struct
+                            ExprKind::Struct(..) => {
+                                self.found_peek_call = true;
+                                return;
+                            },
+                            _ => {},
+                        }
+                    },
+                    Node::Local(Local { init: Some(init), .. }) => {
+                        if let Some(ty) = self.cx.typeck_results().expr_ty_opt(init)
+                            && let (ty, _, Mutability::Mut) = peel_mid_ty_refs_is_mutable(ty)
+                            && match_type(self.cx, ty, &paths::PEEKABLE)
+                        {
+                            self.found_peek_call = true;
+                            return;
+                        }
+
+                        break;
+                    },
+                    Node::Stmt(stmt) => match stmt.kind {
+                        StmtKind::Expr(_) | StmtKind::Semi(_) => {},
+                        _ => {
+                            self.found_peek_call = true;
+                            return;
+                        },
+                    },
+                    Node::Block(_) => {},
+                    _ => {
+                        break;
+                    },
+                }
+            }
+        }
+
+        walk_expr(self, ex);
+    }
+}
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index 8d697a301c4..d3ae537a890 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -96,6 +96,7 @@ pub const PARKING_LOT_RWLOCK_READ_GUARD: [&str; 3] = ["lock_api", "rwlock", "RwL
 pub const PARKING_LOT_RWLOCK_WRITE_GUARD: [&str; 3] = ["lock_api", "rwlock", "RwLockWriteGuard"];
 pub const PATH_BUF_AS_PATH: [&str; 4] = ["std", "path", "PathBuf", "as_path"];
 pub const PATH_TO_PATH_BUF: [&str; 4] = ["std", "path", "Path", "to_path_buf"];
+pub const PEEKABLE: [&str; 5] = ["core", "iter", "adapters", "peekable", "Peekable"];
 pub const PERMISSIONS: [&str; 3] = ["std", "fs", "Permissions"];
 #[cfg_attr(not(unix), allow(clippy::invalid_paths))]
 pub const PERMISSIONS_FROM_MODE: [&str; 6] = ["std", "os", "unix", "fs", "PermissionsExt", "from_mode"];
diff --git a/clippy_utils/src/ty.rs b/clippy_utils/src/ty.rs
index e7d670766a0..edbe9c5a897 100644
--- a/clippy_utils/src/ty.rs
+++ b/clippy_utils/src/ty.rs
@@ -410,7 +410,7 @@ pub fn peel_mid_ty_refs(ty: Ty<'_>) -> (Ty<'_>, usize) {
     peel(ty, 0)
 }
 
-/// Peels off all references on the type.Returns the underlying type, the number of references
+/// Peels off all references on the type. Returns the underlying type, the number of references
 /// removed, and whether the pointer is ultimately mutable or not.
 pub fn peel_mid_ty_refs_is_mutable(ty: Ty<'_>) -> (Ty<'_>, usize, Mutability) {
     fn f(ty: Ty<'_>, count: usize, mutability: Mutability) -> (Ty<'_>, usize, Mutability) {
diff --git a/tests/ui/unused_peekable.rs b/tests/ui/unused_peekable.rs
new file mode 100644
index 00000000000..12cab995621
--- /dev/null
+++ b/tests/ui/unused_peekable.rs
@@ -0,0 +1,119 @@
+#![warn(clippy::unused_peekable)]
+#![allow(clippy::no_effect)]
+
+use std::iter::Empty;
+use std::iter::Peekable;
+
+fn main() {
+    invalid();
+    valid();
+}
+
+#[allow(clippy::unused_unit)]
+fn invalid() {
+    let peekable = std::iter::empty::<u32>().peekable();
+
+    // Only lint `new_local`
+    let old_local = std::iter::empty::<u32>().peekable();
+    let new_local = old_local;
+
+    // Behind mut ref
+    let mut by_mut_ref_test = std::iter::empty::<u32>().peekable();
+    let by_mut_ref = &mut by_mut_ref_test;
+
+    // Explicitly returns `Peekable`
+    fn returns_peekable() -> Peekable<Empty<u32>> {
+        std::iter::empty().peekable()
+    }
+
+    let peekable_from_fn = returns_peekable();
+
+    // Using a method not exclusive to `Peekable`
+    let mut peekable_using_iterator_method = std::iter::empty::<u32>().peekable();
+    peekable_using_iterator_method.next();
+
+    let mut peekable_in_for_loop = std::iter::empty::<u32>().peekable();
+    for x in peekable_in_for_loop {}
+}
+
+fn valid() {
+    fn takes_peekable(_peek: Peekable<Empty<u32>>) {}
+
+    // Passed to another function
+    let passed_along = std::iter::empty::<u32>().peekable();
+    takes_peekable(passed_along);
+
+    // `peek` called in another block
+    let mut peekable_in_block = std::iter::empty::<u32>().peekable();
+    {
+        peekable_in_block.peek();
+    }
+
+    // Check the other `Peekable` methods :)
+    {
+        let mut peekable_with_peek_mut = std::iter::empty::<u32>().peekable();
+        peekable_with_peek_mut.peek_mut();
+
+        let mut peekable_with_next_if = std::iter::empty::<u32>().peekable();
+        peekable_with_next_if.next_if(|_| true);
+
+        let mut peekable_with_next_if_eq = std::iter::empty::<u32>().peekable();
+        peekable_with_next_if_eq.next_if_eq(&3);
+    }
+
+    let mut peekable_in_closure = std::iter::empty::<u32>().peekable();
+    let call_peek = |p: &mut Peekable<Empty<u32>>| {
+        p.peek();
+    };
+    call_peek(&mut peekable_in_closure);
+
+    // From a macro
+    macro_rules! make_me_a_peekable_please {
+        () => {
+            std::iter::empty::<u32>().peekable()
+        };
+    }
+
+    let _unsuspecting_macro_user = make_me_a_peekable_please!();
+
+    // Generic Iterator returned
+    fn return_an_iter() -> impl Iterator<Item = u32> {
+        std::iter::empty::<u32>().peekable()
+    }
+
+    let _unsuspecting_user = return_an_iter();
+
+    // Call `peek` in a macro
+    macro_rules! peek_iter {
+        ($iter:ident) => {
+            $iter.peek();
+        };
+    }
+
+    let mut peek_in_macro = std::iter::empty::<u32>().peekable();
+    peek_iter!(peek_in_macro);
+
+    // Behind mut ref
+    let mut by_mut_ref_test = std::iter::empty::<u32>().peekable();
+    let by_mut_ref = &mut by_mut_ref_test;
+    by_mut_ref.peek();
+
+    // Behind ref
+    let mut by_ref_test = std::iter::empty::<u32>().peekable();
+    let by_ref = &by_ref_test;
+    by_ref_test.peek();
+
+    // In struct
+    struct PeekableWrapper {
+        f: Peekable<Empty<u32>>,
+    }
+
+    let struct_test = std::iter::empty::<u32>().peekable();
+    PeekableWrapper { f: struct_test };
+
+    // `peek` called in another block as the last expression
+    let mut peekable_last_expr = std::iter::empty::<u32>().peekable();
+    {
+        peekable_last_expr.peek();
+    }
+}
diff --git a/tests/ui/unused_peekable.stderr b/tests/ui/unused_peekable.stderr
new file mode 100644
index 00000000000..bd087f56e4c
--- /dev/null
+++ b/tests/ui/unused_peekable.stderr
@@ -0,0 +1,51 @@
+error: `peek` never called on `Peekable` iterator
+  --> $DIR/unused_peekable.rs:14:9
+   |
+LL |     let peekable = std::iter::empty::<u32>().peekable();
+   |         ^^^^^^^^
+   |
+   = note: `-D clippy::unused-peekable` implied by `-D warnings`
+   = help: consider removing the call to `peekable`
+
+error: `peek` never called on `Peekable` iterator
+  --> $DIR/unused_peekable.rs:18:9
+   |
+LL |     let new_local = old_local;
+   |         ^^^^^^^^^
+   |
+   = help: consider removing the call to `peekable`
+
+error: `peek` never called on `Peekable` iterator
+  --> $DIR/unused_peekable.rs:22:9
+   |
+LL |     let by_mut_ref = &mut by_mut_ref_test;
+   |         ^^^^^^^^^^
+   |
+   = help: consider removing the call to `peekable`
+
+error: `peek` never called on `Peekable` iterator
+  --> $DIR/unused_peekable.rs:29:9
+   |
+LL |     let peekable_from_fn = returns_peekable();
+   |         ^^^^^^^^^^^^^^^^
+   |
+   = help: consider removing the call to `peekable`
+
+error: `peek` never called on `Peekable` iterator
+  --> $DIR/unused_peekable.rs:32:13
+   |
+LL |     let mut peekable_using_iterator_method = std::iter::empty::<u32>().peekable();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider removing the call to `peekable`
+
+error: `peek` never called on `Peekable` iterator
+  --> $DIR/unused_peekable.rs:35:13
+   |
+LL |     let mut peekable_in_for_loop = std::iter::empty::<u32>().peekable();
+   |             ^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider removing the call to `peekable`
+
+error: aborting due to 6 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 0efafa4a6e2d96f55584fe77782c289199a560b1 Mon Sep 17 00:00:00 2001
From: Serial <69764315+Serial-ATA@users.noreply.github.com>
Date: Fri, 5 Aug 2022 13:49:43 -0400
Subject: Better handle method/function calls

---
 clippy_lints/src/lib.register_suspicious.rs |   2 +-
 clippy_lints/src/lib.rs                     |   2 +-
 clippy_lints/src/unused_peekable.rs         | 103 ++++++++++++++++------------
 tests/ui/unused_peekable.rs                 |  25 +++++++
 tests/ui/unused_peekable.stderr             |  20 +++++-
 5 files changed, 105 insertions(+), 47 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.register_suspicious.rs b/clippy_lints/src/lib.register_suspicious.rs
index 5793d59bcad..369d4b4eed6 100644
--- a/clippy_lints/src/lib.register_suspicious.rs
+++ b/clippy_lints/src/lib.register_suspicious.rs
@@ -32,6 +32,6 @@ store.register_group(true, "clippy::suspicious", Some("clippy_suspicious"), vec!
     LintId::of(suspicious_trait_impl::SUSPICIOUS_ARITHMETIC_IMPL),
     LintId::of(suspicious_trait_impl::SUSPICIOUS_OP_ASSIGN_IMPL),
     LintId::of(swap_ptr_to_ref::SWAP_PTR_TO_REF),
-    LintId::of(write::POSITIONAL_NAMED_FORMAT_PARAMETERS),
     LintId::of(unused_peekable::UNUSED_PEEKABLE),
+    LintId::of(write::POSITIONAL_NAMED_FORMAT_PARAMETERS),
 ])
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index d4c6c4918cb..2a0fb30131f 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -936,7 +936,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(manual_instant_elapsed::ManualInstantElapsed));
     store.register_late_pass(|| Box::new(partialeq_to_none::PartialeqToNone));
     store.register_late_pass(|| Box::new(manual_empty_string_creations::ManualEmptyStringCreations));
-    store.register_late_pass(|| Box::new(unused_peekable::UnusedPeekable::default()));
+    store.register_late_pass(|| Box::new(unused_peekable::UnusedPeekable));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/unused_peekable.rs b/clippy_lints/src/unused_peekable.rs
index 4988ec0eca1..c060d767e23 100644
--- a/clippy_lints/src/unused_peekable.rs
+++ b/clippy_lints/src/unused_peekable.rs
@@ -1,13 +1,13 @@
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::ty::{match_type, peel_mid_ty_refs_is_mutable};
-use clippy_utils::{fn_def_id, path_to_local_id, paths, peel_ref_operators};
+use clippy_utils::{fn_def_id, is_trait_method, path_to_local_id, paths, peel_ref_operators};
 use rustc_ast::Mutability;
 use rustc_hir::intravisit::{walk_expr, Visitor};
 use rustc_hir::lang_items::LangItem;
 use rustc_hir::{Block, Expr, ExprKind, HirId, Local, Node, PatKind, PathSegment, StmtKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty::Ty;
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::sym;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -42,12 +42,7 @@ declare_clippy_lint! {
     "creating a peekable iterator without using any of its methods"
 }
 
-#[derive(Default)]
-pub struct UnusedPeekable {
-    visited: Vec<HirId>,
-}
-
-impl_lint_pass!(UnusedPeekable => [UNUSED_PEEKABLE]);
+declare_lint_pass!(UnusedPeekable => [UNUSED_PEEKABLE]);
 
 impl<'tcx> LateLintPass<'tcx> for UnusedPeekable {
     fn check_block(&mut self, cx: &LateContext<'tcx>, block: &Block<'tcx>) {
@@ -62,15 +57,14 @@ impl<'tcx> LateLintPass<'tcx> for UnusedPeekable {
         for (idx, stmt) in block.stmts.iter().enumerate() {
             if !stmt.span.from_expansion()
                 && let StmtKind::Local(local) = stmt.kind
-                && !self.visited.contains(&local.pat.hir_id)
-                && let PatKind::Binding(_, _, ident, _) = local.pat.kind
+                && let PatKind::Binding(_, binding, ident, _) = local.pat.kind
                 && let Some(init) = local.init
                 && !init.span.from_expansion()
                 && let Some(ty) = cx.typeck_results().expr_ty_opt(init)
                 && let (ty, _, Mutability::Mut) = peel_mid_ty_refs_is_mutable(ty)
                 && match_type(cx, ty, &paths::PEEKABLE)
             {
-                let mut vis = PeekableVisitor::new(cx, local.pat.hir_id);
+                let mut vis = PeekableVisitor::new(cx, binding);
 
                 if idx + 1 == block.stmts.len() && block.expr.is_none() {
                     return;
@@ -117,6 +111,10 @@ impl<'a, 'tcx> PeekableVisitor<'a, 'tcx> {
 
 impl<'tcx> Visitor<'_> for PeekableVisitor<'_, 'tcx> {
     fn visit_expr(&mut self, ex: &'_ Expr<'_>) {
+        if self.found_peek_call {
+            return;
+        }
+
         if path_to_local_id(ex, self.expected_hir_id) {
             for (_, node) in self.cx.tcx.hir().parent_iter(ex.hir_id) {
                 match node {
@@ -138,50 +136,58 @@ impl<'tcx> Visitor<'_> for PeekableVisitor<'_, 'tcx> {
                                     return;
                                 }
 
-                                for arg in args.iter().map(|arg| peel_ref_operators(self.cx, arg)) {
-                                    if let ExprKind::Path(_) = arg.kind
-                                        && let Some(ty) = self
-                                            .cx
-                                            .typeck_results()
-                                            .expr_ty_opt(arg)
-                                            .map(Ty::peel_refs)
-                                        && match_type(self.cx, ty, &paths::PEEKABLE)
-                                    {
-                                        self.found_peek_call = true;
-                                        return;
-                                    }
+                                if args.iter().any(|arg| {
+                                    matches!(arg.kind, ExprKind::Path(_)) && arg_is_mut_peekable(self.cx, arg)
+                                }) {
+                                    self.found_peek_call = true;
+                                    return;
                                 }
                             },
-                            // Peekable::peek()
-                            ExprKind::MethodCall(PathSegment { ident: method_name, .. }, [arg, ..], _) => {
-                                let arg = peel_ref_operators(self.cx, arg);
-                                let method_name = method_name.name.as_str();
-
-                                if (method_name == "peek"
-                                    || method_name == "peek_mut"
-                                    || method_name == "next_if"
-                                    || method_name == "next_if_eq")
-                                    && let ExprKind::Path(_) = arg.kind
-                                    && let Some(ty) = self.cx.typeck_results().expr_ty_opt(arg).map(Ty::peel_refs)
-                                    && match_type(self.cx, ty, &paths::PEEKABLE)
+                            // Catch anything taking a Peekable mutably
+                            ExprKind::MethodCall(
+                                PathSegment {
+                                    ident: method_name_ident,
+                                    ..
+                                },
+                                [self_arg, remaining_args @ ..],
+                                _,
+                            ) => {
+                                let method_name = method_name_ident.name.as_str();
+
+                                // `Peekable` methods
+                                if matches!(method_name, "peek" | "peek_mut" | "next_if" | "next_if_eq")
+                                    && arg_is_mut_peekable(self.cx, self_arg)
+                                {
+                                    self.found_peek_call = true;
+                                    return;
+                                }
+
+                                // foo.some_method() excluding Iterator methods
+                                if remaining_args.iter().any(|arg| arg_is_mut_peekable(self.cx, arg))
+                                    && !is_trait_method(self.cx, expr, sym::Iterator)
                                 {
                                     self.found_peek_call = true;
                                     return;
                                 }
+
+                                // foo.by_ref(), keep checking for `peek`
+                                if method_name == "by_ref" {
+                                    continue;
+                                }
+
+                                return;
+                            },
+                            ExprKind::AddrOf(_, Mutability::Mut, _) | ExprKind::Unary(..) | ExprKind::DropTemps(_) => {
                             },
-                            // Don't bother if moved into a struct
-                            ExprKind::Struct(..) => {
+                            ExprKind::AddrOf(_, Mutability::Not, _) => return,
+                            _ => {
                                 self.found_peek_call = true;
                                 return;
                             },
-                            _ => {},
                         }
                     },
                     Node::Local(Local { init: Some(init), .. }) => {
-                        if let Some(ty) = self.cx.typeck_results().expr_ty_opt(init)
-                            && let (ty, _, Mutability::Mut) = peel_mid_ty_refs_is_mutable(ty)
-                            && match_type(self.cx, ty, &paths::PEEKABLE)
-                        {
+                        if arg_is_mut_peekable(self.cx, init) {
                             self.found_peek_call = true;
                             return;
                         }
@@ -206,3 +212,14 @@ impl<'tcx> Visitor<'_> for PeekableVisitor<'_, 'tcx> {
         walk_expr(self, ex);
     }
 }
+
+fn arg_is_mut_peekable(cx: &LateContext<'_>, arg: &Expr<'_>) -> bool {
+    if let Some(ty) = cx.typeck_results().expr_ty_opt(arg)
+        && let (ty, _, Mutability::Mut) = peel_mid_ty_refs_is_mutable(ty)
+        && match_type(cx, ty, &paths::PEEKABLE)
+    {
+        true
+    } else {
+        false
+    }
+}
diff --git a/tests/ui/unused_peekable.rs b/tests/ui/unused_peekable.rs
index 12cab995621..153457e3671 100644
--- a/tests/ui/unused_peekable.rs
+++ b/tests/ui/unused_peekable.rs
@@ -32,6 +32,15 @@ fn invalid() {
     let mut peekable_using_iterator_method = std::iter::empty::<u32>().peekable();
     peekable_using_iterator_method.next();
 
+    // Passed by ref to another function
+    fn takes_ref(_peek: &Peekable<Empty<u32>>) {}
+    let passed_along_ref = std::iter::empty::<u32>().peekable();
+    takes_ref(&passed_along_ref);
+
+    // `by_ref` without `peek`
+    let mut by_ref_test = std::iter::empty::<u32>().peekable();
+    let _by_ref = by_ref_test.by_ref();
+
     let mut peekable_in_for_loop = std::iter::empty::<u32>().peekable();
     for x in peekable_in_for_loop {}
 }
@@ -43,6 +52,18 @@ fn valid() {
     let passed_along = std::iter::empty::<u32>().peekable();
     takes_peekable(passed_along);
 
+    // Passed to another method
+    struct PeekableConsumer;
+    impl PeekableConsumer {
+        fn consume(&self, _: Peekable<Empty<u32>>) {}
+        fn consume_mut_ref(&self, _: &mut Peekable<Empty<u32>>) {}
+    }
+
+    let peekable_consumer = PeekableConsumer;
+    let mut passed_along_to_method = std::iter::empty::<u32>().peekable();
+    peekable_consumer.consume_mut_ref(&mut passed_along_to_method);
+    peekable_consumer.consume(passed_along_to_method);
+
     // `peek` called in another block
     let mut peekable_in_block = std::iter::empty::<u32>().peekable();
     {
@@ -111,6 +132,10 @@ fn valid() {
     let struct_test = std::iter::empty::<u32>().peekable();
     PeekableWrapper { f: struct_test };
 
+    // `by_ref` before `peek`
+    let mut by_ref_test = std::iter::empty::<u32>().peekable();
+    let peeked_val = by_ref_test.by_ref().peek();
+
     // `peek` called in another block as the last expression
     let mut peekable_last_expr = std::iter::empty::<u32>().peekable();
     {
diff --git a/tests/ui/unused_peekable.stderr b/tests/ui/unused_peekable.stderr
index bd087f56e4c..d557f54179d 100644
--- a/tests/ui/unused_peekable.stderr
+++ b/tests/ui/unused_peekable.stderr
@@ -40,12 +40,28 @@ LL |     let mut peekable_using_iterator_method = std::iter::empty::<u32>().peek
    = help: consider removing the call to `peekable`
 
 error: `peek` never called on `Peekable` iterator
-  --> $DIR/unused_peekable.rs:35:13
+  --> $DIR/unused_peekable.rs:37:9
+   |
+LL |     let passed_along_ref = std::iter::empty::<u32>().peekable();
+   |         ^^^^^^^^^^^^^^^^
+   |
+   = help: consider removing the call to `peekable`
+
+error: `peek` never called on `Peekable` iterator
+  --> $DIR/unused_peekable.rs:42:9
+   |
+LL |     let _by_ref = by_ref_test.by_ref();
+   |         ^^^^^^^
+   |
+   = help: consider removing the call to `peekable`
+
+error: `peek` never called on `Peekable` iterator
+  --> $DIR/unused_peekable.rs:44:13
    |
 LL |     let mut peekable_in_for_loop = std::iter::empty::<u32>().peekable();
    |             ^^^^^^^^^^^^^^^^^^^^
    |
    = help: consider removing the call to `peekable`
 
-error: aborting due to 6 previous errors
+error: aborting due to 8 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 8ab2f880d00bea8822f78289bbd3d1ae59990121 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sun, 5 Jun 2022 09:13:13 -0400
Subject: Move `AsUnderscore` into `Casts` lint pass

---
 clippy_lints/src/as_underscore.rs            | 74 ----------------------------
 clippy_lints/src/casts/as_underscore.rs      | 25 ++++++++++
 clippy_lints/src/casts/mod.rs                | 38 ++++++++++++--
 clippy_lints/src/lib.register_lints.rs       |  2 +-
 clippy_lints/src/lib.register_restriction.rs |  2 +-
 clippy_lints/src/lib.rs                      |  2 -
 6 files changed, 62 insertions(+), 81 deletions(-)
 delete mode 100644 clippy_lints/src/as_underscore.rs
 create mode 100644 clippy_lints/src/casts/as_underscore.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/as_underscore.rs b/clippy_lints/src/as_underscore.rs
deleted file mode 100644
index 5b4b2c631c8..00000000000
--- a/clippy_lints/src/as_underscore.rs
+++ /dev/null
@@ -1,74 +0,0 @@
-use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_then};
-use rustc_errors::Applicability;
-use rustc_hir::{Expr, ExprKind, TyKind};
-use rustc_lint::{LateContext, LateLintPass, LintContext};
-use rustc_middle::lint::in_external_macro;
-use rustc_middle::ty;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Check for the usage of `as _` conversion using inferred type.
-    ///
-    /// ### Why is this bad?
-    /// The conversion might include lossy conversion and dangerous cast that might go
-    /// undetected due to the type being inferred.
-    ///
-    /// The lint is allowed by default as using `_` is less wordy than always specifying the type.
-    ///
-    /// ### Example
-    /// ```rust
-    /// fn foo(n: usize) {}
-    /// let n: u16 = 256;
-    /// foo(n as _);
-    /// ```
-    /// Use instead:
-    /// ```rust
-    /// fn foo(n: usize) {}
-    /// let n: u16 = 256;
-    /// foo(n as usize);
-    /// ```
-    #[clippy::version = "1.63.0"]
-    pub AS_UNDERSCORE,
-    restriction,
-    "detects `as _` conversion"
-}
-declare_lint_pass!(AsUnderscore => [AS_UNDERSCORE]);
-
-impl<'tcx> LateLintPass<'tcx> for AsUnderscore {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &Expr<'tcx>) {
-        if in_external_macro(cx.sess(), expr.span) {
-            return;
-        }
-
-        if let ExprKind::Cast(_, ty) = expr.kind && let TyKind::Infer = ty.kind {
-
-            let ty_resolved = cx.typeck_results().expr_ty(expr);
-            if let ty::Error(_) = ty_resolved.kind() {
-                span_lint_and_help(
-                    cx,
-                AS_UNDERSCORE,
-                expr.span,
-                "using `as _` conversion",
-                None,
-                "consider giving the type explicitly",
-                );
-            } else {
-            span_lint_and_then(
-                cx,
-                AS_UNDERSCORE,
-                expr.span,
-                "using `as _` conversion",
-                |diag| {
-                    diag.span_suggestion(
-                        ty.span,
-                        "consider giving the type explicitly",
-                        ty_resolved,
-                        Applicability::MachineApplicable,
-                    );
-            }
-            );
-        }
-        }
-    }
-}
diff --git a/clippy_lints/src/casts/as_underscore.rs b/clippy_lints/src/casts/as_underscore.rs
new file mode 100644
index 00000000000..56e894c6261
--- /dev/null
+++ b/clippy_lints/src/casts/as_underscore.rs
@@ -0,0 +1,25 @@
+use clippy_utils::diagnostics::span_lint_and_then;
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, Ty, TyKind};
+use rustc_lint::LateContext;
+use rustc_middle::ty;
+
+use super::AS_UNDERSCORE;
+
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, ty: &'tcx Ty<'_>) {
+    if matches!(ty.kind, TyKind::Infer) {
+        span_lint_and_then(cx, AS_UNDERSCORE, expr.span, "using `as _` conversion", |diag| {
+            let ty_resolved = cx.typeck_results().expr_ty(expr);
+            if let ty::Error(_) = ty_resolved.kind() {
+                diag.help("consider giving the type explicitly");
+            } else {
+                diag.span_suggestion(
+                    ty.span,
+                    "consider giving the type explicitly",
+                    ty_resolved,
+                    Applicability::MachineApplicable,
+                );
+            }
+        });
+    }
+}
diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index af3798a0cc8..01057d9f67c 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -1,3 +1,4 @@
+mod as_underscore;
 mod cast_abs_to_unsigned;
 mod cast_enum_constructor;
 mod cast_lossless;
@@ -506,6 +507,34 @@ declare_clippy_lint! {
     "casting the result of `abs()` to an unsigned integer can panic"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Check for the usage of `as _` conversion using inferred type.
+    ///
+    /// ### Why is this bad?
+    /// The conversion might include lossy conversion and dangerous cast that might go
+    /// undetected due to the type being inferred.
+    ///
+    /// The lint is allowed by default as using `_` is less wordy than always specifying the type.
+    ///
+    /// ### Example
+    /// ```rust
+    /// fn foo(n: usize) {}
+    /// let n: u16 = 256;
+    /// foo(n as _);
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// fn foo(n: usize) {}
+    /// let n: u16 = 256;
+    /// foo(n as usize);
+    /// ```
+    #[clippy::version = "1.63.0"]
+    pub AS_UNDERSCORE,
+    restriction,
+    "detects `as _` conversion"
+}
+
 pub struct Casts {
     msrv: Option<RustcVersion>,
 }
@@ -534,7 +563,8 @@ impl_lint_pass!(Casts => [
     PTR_AS_PTR,
     CAST_ENUM_TRUNCATION,
     CAST_ENUM_CONSTRUCTOR,
-    CAST_ABS_TO_UNSIGNED
+    CAST_ABS_TO_UNSIGNED,
+    AS_UNDERSCORE,
 ]);
 
 impl<'tcx> LateLintPass<'tcx> for Casts {
@@ -547,8 +577,8 @@ impl<'tcx> LateLintPass<'tcx> for Casts {
             return;
         }
 
-        if let ExprKind::Cast(cast_expr, cast_to) = expr.kind {
-            if is_hir_ty_cfg_dependant(cx, cast_to) {
+        if let ExprKind::Cast(cast_expr, cast_to_hir) = expr.kind {
+            if is_hir_ty_cfg_dependant(cx, cast_to_hir) {
                 return;
             }
             let (cast_from, cast_to) = (
@@ -575,6 +605,8 @@ impl<'tcx> LateLintPass<'tcx> for Casts {
                 cast_lossless::check(cx, expr, cast_expr, cast_from, cast_to, self.msrv);
                 cast_enum_constructor::check(cx, expr, cast_expr, cast_from);
             }
+
+            as_underscore::check(cx, expr, cast_to_hir);
         }
 
         cast_ref_to_mut::check(cx, expr);
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index b7dbd30aa0c..e7665c3fa1d 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -38,7 +38,6 @@ store.register_lints(&[
     almost_complete_letter_range::ALMOST_COMPLETE_LETTER_RANGE,
     approx_const::APPROX_CONSTANT,
     as_conversions::AS_CONVERSIONS,
-    as_underscore::AS_UNDERSCORE,
     asm_syntax::INLINE_ASM_X86_ATT_SYNTAX,
     asm_syntax::INLINE_ASM_X86_INTEL_SYNTAX,
     assertions_on_constants::ASSERTIONS_ON_CONSTANTS,
@@ -69,6 +68,7 @@ store.register_lints(&[
     cargo::REDUNDANT_FEATURE_NAMES,
     cargo::WILDCARD_DEPENDENCIES,
     case_sensitive_file_extension_comparisons::CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS,
+    casts::AS_UNDERSCORE,
     casts::CAST_ABS_TO_UNSIGNED,
     casts::CAST_ENUM_CONSTRUCTOR,
     casts::CAST_ENUM_TRUNCATION,
diff --git a/clippy_lints/src/lib.register_restriction.rs b/clippy_lints/src/lib.register_restriction.rs
index a7339ef2721..890ae2792ab 100644
--- a/clippy_lints/src/lib.register_restriction.rs
+++ b/clippy_lints/src/lib.register_restriction.rs
@@ -4,11 +4,11 @@
 
 store.register_group(true, "clippy::restriction", Some("clippy_restriction"), vec![
     LintId::of(as_conversions::AS_CONVERSIONS),
-    LintId::of(as_underscore::AS_UNDERSCORE),
     LintId::of(asm_syntax::INLINE_ASM_X86_ATT_SYNTAX),
     LintId::of(asm_syntax::INLINE_ASM_X86_INTEL_SYNTAX),
     LintId::of(assertions_on_result_states::ASSERTIONS_ON_RESULT_STATES),
     LintId::of(attrs::ALLOW_ATTRIBUTES_WITHOUT_REASON),
+    LintId::of(casts::AS_UNDERSCORE),
     LintId::of(casts::FN_TO_NUMERIC_CAST_ANY),
     LintId::of(create_dir::CREATE_DIR),
     LintId::of(dbg_macro::DBG_MACRO),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index a041fbc7fd9..d32a2fad493 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -170,7 +170,6 @@ mod renamed_lints;
 mod almost_complete_letter_range;
 mod approx_const;
 mod as_conversions;
-mod as_underscore;
 mod asm_syntax;
 mod assertions_on_constants;
 mod assertions_on_result_states;
@@ -923,7 +922,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_early_pass(move || Box::new(almost_complete_letter_range::AlmostCompleteLetterRange::new(msrv)));
     store.register_late_pass(|| Box::new(swap_ptr_to_ref::SwapPtrToRef));
     store.register_late_pass(|| Box::new(mismatching_type_param_order::TypeParamMismatch));
-    store.register_late_pass(|| Box::new(as_underscore::AsUnderscore));
     store.register_late_pass(|| Box::new(read_zero_byte_vec::ReadZeroByteVec));
     store.register_late_pass(|| Box::new(default_instead_of_iter_empty::DefaultIterEmpty));
     store.register_late_pass(move || Box::new(manual_rem_euclid::ManualRemEuclid::new(msrv)));
-- 
cgit 1.4.1-3-g733a5


From 21f595433e449ff44de5e6cd6373b8a852512d49 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sun, 5 Jun 2022 09:33:15 -0400
Subject: Move `BorrowAsPtr` into `Casts` lint pass

---
 clippy_lints/src/borrow_as_ptr.rs         | 99 -------------------------------
 clippy_lints/src/casts/borrow_as_ptr.rs   | 37 ++++++++++++
 clippy_lints/src/casts/mod.rs             | 41 ++++++++++++-
 clippy_lints/src/lib.register_lints.rs    |  2 +-
 clippy_lints/src/lib.register_pedantic.rs |  2 +-
 clippy_lints/src/lib.rs                   |  2 -
 6 files changed, 79 insertions(+), 104 deletions(-)
 delete mode 100644 clippy_lints/src/borrow_as_ptr.rs
 create mode 100644 clippy_lints/src/casts/borrow_as_ptr.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/borrow_as_ptr.rs b/clippy_lints/src/borrow_as_ptr.rs
deleted file mode 100644
index 0993adbae2e..00000000000
--- a/clippy_lints/src/borrow_as_ptr.rs
+++ /dev/null
@@ -1,99 +0,0 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::is_no_std_crate;
-use clippy_utils::source::snippet_opt;
-use clippy_utils::{meets_msrv, msrvs};
-use if_chain::if_chain;
-use rustc_errors::Applicability;
-use rustc_hir::{BorrowKind, Expr, ExprKind, Mutability, TyKind};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_semver::RustcVersion;
-use rustc_session::{declare_tool_lint, impl_lint_pass};
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for the usage of `&expr as *const T` or
-    /// `&mut expr as *mut T`, and suggest using `ptr::addr_of` or
-    /// `ptr::addr_of_mut` instead.
-    ///
-    /// ### Why is this bad?
-    /// This would improve readability and avoid creating a reference
-    /// that points to an uninitialized value or unaligned place.
-    /// Read the `ptr::addr_of` docs for more information.
-    ///
-    /// ### Example
-    /// ```rust
-    /// let val = 1;
-    /// let p = &val as *const i32;
-    ///
-    /// let mut val_mut = 1;
-    /// let p_mut = &mut val_mut as *mut i32;
-    /// ```
-    /// Use instead:
-    /// ```rust
-    /// let val = 1;
-    /// let p = std::ptr::addr_of!(val);
-    ///
-    /// let mut val_mut = 1;
-    /// let p_mut = std::ptr::addr_of_mut!(val_mut);
-    /// ```
-    #[clippy::version = "1.60.0"]
-    pub BORROW_AS_PTR,
-    pedantic,
-    "borrowing just to cast to a raw pointer"
-}
-
-impl_lint_pass!(BorrowAsPtr => [BORROW_AS_PTR]);
-
-pub struct BorrowAsPtr {
-    msrv: Option<RustcVersion>,
-}
-
-impl BorrowAsPtr {
-    #[must_use]
-    pub fn new(msrv: Option<RustcVersion>) -> Self {
-        Self { msrv }
-    }
-}
-
-impl<'tcx> LateLintPass<'tcx> for BorrowAsPtr {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if !meets_msrv(self.msrv, msrvs::BORROW_AS_PTR) {
-            return;
-        }
-
-        if expr.span.from_expansion() {
-            return;
-        }
-
-        if_chain! {
-            if let ExprKind::Cast(left_expr, ty) = &expr.kind;
-            if let TyKind::Ptr(_) = ty.kind;
-            if let ExprKind::AddrOf(BorrowKind::Ref, mutability, e) = &left_expr.kind;
-
-            then {
-                let core_or_std = if is_no_std_crate(cx) { "core" } else { "std" };
-                let macro_name = match mutability {
-                    Mutability::Not => "addr_of",
-                    Mutability::Mut => "addr_of_mut",
-                };
-
-                span_lint_and_sugg(
-                    cx,
-                    BORROW_AS_PTR,
-                    expr.span,
-                    "borrow as raw pointer",
-                    "try",
-                    format!(
-                        "{}::ptr::{}!({})",
-                        core_or_std,
-                        macro_name,
-                        snippet_opt(cx, e.span).unwrap()
-                    ),
-                    Applicability::MachineApplicable,
-                );
-            }
-        }
-    }
-
-    extract_msrv_attr!(LateContext);
-}
diff --git a/clippy_lints/src/casts/borrow_as_ptr.rs b/clippy_lints/src/casts/borrow_as_ptr.rs
new file mode 100644
index 00000000000..6e1f8cd64f0
--- /dev/null
+++ b/clippy_lints/src/casts/borrow_as_ptr.rs
@@ -0,0 +1,37 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::is_no_std_crate;
+use clippy_utils::source::snippet_with_context;
+use rustc_errors::Applicability;
+use rustc_hir::{BorrowKind, Expr, ExprKind, Mutability, Ty, TyKind};
+use rustc_lint::LateContext;
+
+use super::BORROW_AS_PTR;
+
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx Expr<'_>,
+    cast_expr: &'tcx Expr<'_>,
+    cast_to: &'tcx Ty<'_>,
+) {
+    if matches!(cast_to.kind, TyKind::Ptr(_))
+        && let ExprKind::AddrOf(BorrowKind::Ref, mutability, e) = cast_expr.kind
+    {
+        let core_or_std = if is_no_std_crate(cx) { "core" } else { "std" };
+        let macro_name = match mutability {
+            Mutability::Not => "addr_of",
+            Mutability::Mut => "addr_of_mut",
+        };
+        let mut app = Applicability::MachineApplicable;
+        let snip = snippet_with_context(cx, e.span, cast_expr.span.ctxt(), "..", &mut app).0;
+
+        span_lint_and_sugg(
+            cx,
+            BORROW_AS_PTR,
+            expr.span,
+            "borrow as raw pointer",
+            "try",
+            format!("{}::ptr::{}!({})", core_or_std, macro_name, snip),
+            Applicability::MachineApplicable,
+        );
+    }
+}
diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index 01057d9f67c..644edefb8fe 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -1,4 +1,5 @@
 mod as_underscore;
+mod borrow_as_ptr;
 mod cast_abs_to_unsigned;
 mod cast_enum_constructor;
 mod cast_lossless;
@@ -17,7 +18,7 @@ mod ptr_as_ptr;
 mod unnecessary_cast;
 mod utils;
 
-use clippy_utils::is_hir_ty_cfg_dependant;
+use clippy_utils::{is_hir_ty_cfg_dependant, meets_msrv, msrvs};
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
@@ -535,6 +536,39 @@ declare_clippy_lint! {
     "detects `as _` conversion"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for the usage of `&expr as *const T` or
+    /// `&mut expr as *mut T`, and suggest using `ptr::addr_of` or
+    /// `ptr::addr_of_mut` instead.
+    ///
+    /// ### Why is this bad?
+    /// This would improve readability and avoid creating a reference
+    /// that points to an uninitialized value or unaligned place.
+    /// Read the `ptr::addr_of` docs for more information.
+    ///
+    /// ### Example
+    /// ```rust
+    /// let val = 1;
+    /// let p = &val as *const i32;
+    ///
+    /// let mut val_mut = 1;
+    /// let p_mut = &mut val_mut as *mut i32;
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// let val = 1;
+    /// let p = std::ptr::addr_of!(val);
+    ///
+    /// let mut val_mut = 1;
+    /// let p_mut = std::ptr::addr_of_mut!(val_mut);
+    /// ```
+    #[clippy::version = "1.60.0"]
+    pub BORROW_AS_PTR,
+    pedantic,
+    "borrowing just to cast to a raw pointer"
+}
+
 pub struct Casts {
     msrv: Option<RustcVersion>,
 }
@@ -565,6 +599,7 @@ impl_lint_pass!(Casts => [
     CAST_ENUM_CONSTRUCTOR,
     CAST_ABS_TO_UNSIGNED,
     AS_UNDERSCORE,
+    BORROW_AS_PTR,
 ]);
 
 impl<'tcx> LateLintPass<'tcx> for Casts {
@@ -607,6 +642,10 @@ impl<'tcx> LateLintPass<'tcx> for Casts {
             }
 
             as_underscore::check(cx, expr, cast_to_hir);
+
+            if meets_msrv(self.msrv, msrvs::BORROW_AS_PTR) {
+                borrow_as_ptr::check(cx, expr, cast_expr, cast_to_hir);
+            }
         }
 
         cast_ref_to_mut::check(cx, expr);
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index e7665c3fa1d..7883711e5a3 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -58,7 +58,6 @@ store.register_lints(&[
     bool_assert_comparison::BOOL_ASSERT_COMPARISON,
     booleans::NONMINIMAL_BOOL,
     booleans::OVERLY_COMPLEX_BOOL_EXPR,
-    borrow_as_ptr::BORROW_AS_PTR,
     borrow_deref_ref::BORROW_DEREF_REF,
     bytecount::NAIVE_BYTECOUNT,
     bytes_count_to_len::BYTES_COUNT_TO_LEN,
@@ -69,6 +68,7 @@ store.register_lints(&[
     cargo::WILDCARD_DEPENDENCIES,
     case_sensitive_file_extension_comparisons::CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS,
     casts::AS_UNDERSCORE,
+    casts::BORROW_AS_PTR,
     casts::CAST_ABS_TO_UNSIGNED,
     casts::CAST_ENUM_CONSTRUCTOR,
     casts::CAST_ENUM_TRUNCATION,
diff --git a/clippy_lints/src/lib.register_pedantic.rs b/clippy_lints/src/lib.register_pedantic.rs
index 4250ee055e6..ae9f046f023 100644
--- a/clippy_lints/src/lib.register_pedantic.rs
+++ b/clippy_lints/src/lib.register_pedantic.rs
@@ -4,9 +4,9 @@
 
 store.register_group(true, "clippy::pedantic", Some("clippy_pedantic"), vec![
     LintId::of(attrs::INLINE_ALWAYS),
-    LintId::of(borrow_as_ptr::BORROW_AS_PTR),
     LintId::of(bytecount::NAIVE_BYTECOUNT),
     LintId::of(case_sensitive_file_extension_comparisons::CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS),
+    LintId::of(casts::BORROW_AS_PTR),
     LintId::of(casts::CAST_LOSSLESS),
     LintId::of(casts::CAST_POSSIBLE_TRUNCATION),
     LintId::of(casts::CAST_POSSIBLE_WRAP),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index d32a2fad493..63e0fcf6b0f 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -179,7 +179,6 @@ mod await_holding_invalid;
 mod blocks_in_if_conditions;
 mod bool_assert_comparison;
 mod booleans;
-mod borrow_as_ptr;
 mod borrow_deref_ref;
 mod bytecount;
 mod bytes_count_to_len;
@@ -893,7 +892,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(return_self_not_must_use::ReturnSelfNotMustUse));
     store.register_late_pass(|| Box::new(init_numbered_fields::NumberedFields));
     store.register_early_pass(|| Box::new(single_char_lifetime_names::SingleCharLifetimeNames));
-    store.register_late_pass(move || Box::new(borrow_as_ptr::BorrowAsPtr::new(msrv)));
     store.register_late_pass(move || Box::new(manual_bits::ManualBits::new(msrv)));
     store.register_late_pass(|| Box::new(default_union_representation::DefaultUnionRepresentation));
     store.register_early_pass(|| Box::new(doc_link_with_quotes::DocLinkWithQuotes));
-- 
cgit 1.4.1-3-g733a5


From 25028986864fbb3231c54feb5e769c8778e037bf Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sun, 5 Jun 2022 11:39:36 -0400
Subject: Move `ByteCount` into `Methods` lint pass

---
 clippy_lints/src/bytecount.rs             | 103 ------------------------------
 clippy_lints/src/lib.register_lints.rs    |   2 +-
 clippy_lints/src/lib.register_pedantic.rs |   2 +-
 clippy_lints/src/lib.rs                   |   2 -
 clippy_lints/src/methods/bytecount.rs     |  70 ++++++++++++++++++++
 clippy_lints/src/methods/mod.rs           |  42 +++++++++++-
 6 files changed, 111 insertions(+), 110 deletions(-)
 delete mode 100644 clippy_lints/src/bytecount.rs
 create mode 100644 clippy_lints/src/methods/bytecount.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/bytecount.rs b/clippy_lints/src/bytecount.rs
deleted file mode 100644
index 326ce34082a..00000000000
--- a/clippy_lints/src/bytecount.rs
+++ /dev/null
@@ -1,103 +0,0 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::ty::match_type;
-use clippy_utils::visitors::is_local_used;
-use clippy_utils::{path_to_local_id, paths, peel_blocks, peel_ref_operators, strip_pat_refs};
-use if_chain::if_chain;
-use rustc_errors::Applicability;
-use rustc_hir::{BinOpKind, Closure, Expr, ExprKind, PatKind};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty::{self, UintTy};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::sym;
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for naive byte counts
-    ///
-    /// ### Why is this bad?
-    /// The [`bytecount`](https://crates.io/crates/bytecount)
-    /// crate has methods to count your bytes faster, especially for large slices.
-    ///
-    /// ### Known problems
-    /// If you have predominantly small slices, the
-    /// `bytecount::count(..)` method may actually be slower. However, if you can
-    /// ensure that less than 2³²-1 matches arise, the `naive_count_32(..)` can be
-    /// faster in those cases.
-    ///
-    /// ### Example
-    /// ```rust
-    /// # let vec = vec![1_u8];
-    /// let count = vec.iter().filter(|x| **x == 0u8).count();
-    /// ```
-    ///
-    /// Use instead:
-    /// ```rust,ignore
-    /// # let vec = vec![1_u8];
-    /// let count = bytecount::count(&vec, 0u8);
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub NAIVE_BYTECOUNT,
-    pedantic,
-    "use of naive `<slice>.filter(|&x| x == y).count()` to count byte values"
-}
-
-declare_lint_pass!(ByteCount => [NAIVE_BYTECOUNT]);
-
-impl<'tcx> LateLintPass<'tcx> for ByteCount {
-    fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
-        if_chain! {
-            if let ExprKind::MethodCall(count, [count_recv], _) = expr.kind;
-            if count.ident.name == sym::count;
-            if let ExprKind::MethodCall(filter, [filter_recv, filter_arg], _) = count_recv.kind;
-            if filter.ident.name == sym!(filter);
-            if let ExprKind::Closure(&Closure { body, .. }) = filter_arg.kind;
-            let body = cx.tcx.hir().body(body);
-            if let [param] = body.params;
-            if let PatKind::Binding(_, arg_id, _, _) = strip_pat_refs(param.pat).kind;
-            if let ExprKind::Binary(ref op, l, r) = body.value.kind;
-            if op.node == BinOpKind::Eq;
-            if match_type(cx,
-                       cx.typeck_results().expr_ty(filter_recv).peel_refs(),
-                       &paths::SLICE_ITER);
-            let operand_is_arg = |expr| {
-                let expr = peel_ref_operators(cx, peel_blocks(expr));
-                path_to_local_id(expr, arg_id)
-            };
-            let needle = if operand_is_arg(l) {
-                r
-            } else if operand_is_arg(r) {
-                l
-            } else {
-                return;
-            };
-            if ty::Uint(UintTy::U8) == *cx.typeck_results().expr_ty(needle).peel_refs().kind();
-            if !is_local_used(cx, needle, arg_id);
-            then {
-                let haystack = if let ExprKind::MethodCall(path, args, _) =
-                        filter_recv.kind {
-                    let p = path.ident.name;
-                    if (p == sym::iter || p == sym!(iter_mut)) && args.len() == 1 {
-                        &args[0]
-                    } else {
-                        filter_recv
-                    }
-                } else {
-                    filter_recv
-                };
-                let mut applicability = Applicability::MaybeIncorrect;
-                span_lint_and_sugg(
-                    cx,
-                    NAIVE_BYTECOUNT,
-                    expr.span,
-                    "you appear to be counting bytes the naive way",
-                    "consider using the bytecount crate",
-                    format!("bytecount::count({}, {})",
-                            snippet_with_applicability(cx, haystack.span, "..", &mut applicability),
-                            snippet_with_applicability(cx, needle.span, "..", &mut applicability)),
-                    applicability,
-                );
-            }
-        };
-    }
-}
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 7883711e5a3..c3c24fb1668 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -59,7 +59,6 @@ store.register_lints(&[
     booleans::NONMINIMAL_BOOL,
     booleans::OVERLY_COMPLEX_BOOL_EXPR,
     borrow_deref_ref::BORROW_DEREF_REF,
-    bytecount::NAIVE_BYTECOUNT,
     bytes_count_to_len::BYTES_COUNT_TO_LEN,
     cargo::CARGO_COMMON_METADATA,
     cargo::MULTIPLE_CRATE_VERSIONS,
@@ -330,6 +329,7 @@ store.register_lints(&[
     methods::MAP_FLATTEN,
     methods::MAP_IDENTITY,
     methods::MAP_UNWRAP_OR,
+    methods::NAIVE_BYTECOUNT,
     methods::NEEDLESS_OPTION_AS_DEREF,
     methods::NEEDLESS_OPTION_TAKE,
     methods::NEEDLESS_SPLITN,
diff --git a/clippy_lints/src/lib.register_pedantic.rs b/clippy_lints/src/lib.register_pedantic.rs
index ae9f046f023..241d70d2628 100644
--- a/clippy_lints/src/lib.register_pedantic.rs
+++ b/clippy_lints/src/lib.register_pedantic.rs
@@ -4,7 +4,6 @@
 
 store.register_group(true, "clippy::pedantic", Some("clippy_pedantic"), vec![
     LintId::of(attrs::INLINE_ALWAYS),
-    LintId::of(bytecount::NAIVE_BYTECOUNT),
     LintId::of(case_sensitive_file_extension_comparisons::CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS),
     LintId::of(casts::BORROW_AS_PTR),
     LintId::of(casts::CAST_LOSSLESS),
@@ -64,6 +63,7 @@ store.register_group(true, "clippy::pedantic", Some("clippy_pedantic"), vec![
     LintId::of(methods::IMPLICIT_CLONE),
     LintId::of(methods::INEFFICIENT_TO_STRING),
     LintId::of(methods::MAP_UNWRAP_OR),
+    LintId::of(methods::NAIVE_BYTECOUNT),
     LintId::of(methods::UNNECESSARY_JOIN),
     LintId::of(misc::USED_UNDERSCORE_BINDING),
     LintId::of(mismatching_type_param_order::MISMATCHING_TYPE_PARAM_ORDER),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 63e0fcf6b0f..617f1622325 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -180,7 +180,6 @@ mod blocks_in_if_conditions;
 mod bool_assert_comparison;
 mod booleans;
 mod borrow_deref_ref;
-mod bytecount;
 mod bytes_count_to_len;
 mod cargo;
 mod case_sensitive_file_extension_comparisons;
@@ -718,7 +717,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     );
     store.register_late_pass(move || Box::new(pass_by_ref_or_value));
     store.register_late_pass(|| Box::new(ref_option_ref::RefOptionRef));
-    store.register_late_pass(|| Box::new(bytecount::ByteCount));
     store.register_late_pass(|| Box::new(infinite_iter::InfiniteIter));
     store.register_late_pass(|| Box::new(inline_fn_without_body::InlineFnWithoutBody));
     store.register_late_pass(|| Box::new(useless_conversion::UselessConversion::default()));
diff --git a/clippy_lints/src/methods/bytecount.rs b/clippy_lints/src/methods/bytecount.rs
new file mode 100644
index 00000000000..6a7c63d76f7
--- /dev/null
+++ b/clippy_lints/src/methods/bytecount.rs
@@ -0,0 +1,70 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::ty::match_type;
+use clippy_utils::visitors::is_local_used;
+use clippy_utils::{path_to_local_id, paths, peel_blocks, peel_ref_operators, strip_pat_refs};
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir::{BinOpKind, Closure, Expr, ExprKind, PatKind};
+use rustc_lint::LateContext;
+use rustc_middle::ty::{self, UintTy};
+use rustc_span::sym;
+
+use super::NAIVE_BYTECOUNT;
+
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx Expr<'_>,
+    filter_recv: &'tcx Expr<'_>,
+    filter_arg: &'tcx Expr<'_>,
+) {
+    if_chain! {
+        if let ExprKind::Closure(&Closure { body, .. }) = filter_arg.kind;
+        let body = cx.tcx.hir().body(body);
+        if let [param] = body.params;
+        if let PatKind::Binding(_, arg_id, _, _) = strip_pat_refs(param.pat).kind;
+        if let ExprKind::Binary(ref op, l, r) = body.value.kind;
+        if op.node == BinOpKind::Eq;
+        if match_type(cx,
+                    cx.typeck_results().expr_ty(filter_recv).peel_refs(),
+                    &paths::SLICE_ITER);
+        let operand_is_arg = |expr| {
+            let expr = peel_ref_operators(cx, peel_blocks(expr));
+            path_to_local_id(expr, arg_id)
+        };
+        let needle = if operand_is_arg(l) {
+            r
+        } else if operand_is_arg(r) {
+            l
+        } else {
+            return;
+        };
+        if ty::Uint(UintTy::U8) == *cx.typeck_results().expr_ty(needle).peel_refs().kind();
+        if !is_local_used(cx, needle, arg_id);
+        then {
+            let haystack = if let ExprKind::MethodCall(path, args, _) =
+                    filter_recv.kind {
+                let p = path.ident.name;
+                if (p == sym::iter || p == sym!(iter_mut)) && args.len() == 1 {
+                    &args[0]
+                } else {
+                    filter_recv
+                }
+            } else {
+                filter_recv
+            };
+            let mut applicability = Applicability::MaybeIncorrect;
+            span_lint_and_sugg(
+                cx,
+                NAIVE_BYTECOUNT,
+                expr.span,
+                "you appear to be counting bytes the naive way",
+                "consider using the bytecount crate",
+                format!("bytecount::count({}, {})",
+                        snippet_with_applicability(cx, haystack.span, "..", &mut applicability),
+                        snippet_with_applicability(cx, needle.span, "..", &mut applicability)),
+                applicability,
+            );
+        }
+    };
+}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index b68a2651e1b..f0d9dce5518 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1,4 +1,5 @@
 mod bind_instead_of_map;
+mod bytecount;
 mod bytes_nth;
 mod chars_cmp;
 mod chars_cmp_with_unwrap;
@@ -82,7 +83,9 @@ use bind_instead_of_map::BindInsteadOfMap;
 use clippy_utils::consts::{constant, Constant};
 use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
 use clippy_utils::ty::{contains_adt_constructor, contains_ty, implements_trait, is_copy, is_type_diagnostic_item};
-use clippy_utils::{contains_return, get_trait_def_id, iter_input_pats, meets_msrv, msrvs, paths, return_ty};
+use clippy_utils::{
+    contains_return, get_trait_def_id, is_trait_method, iter_input_pats, meets_msrv, msrvs, paths, return_ty,
+};
 use if_chain::if_chain;
 use rustc_hir as hir;
 use rustc_hir::def::Res;
@@ -2368,6 +2371,37 @@ declare_clippy_lint! {
     "Iterator for empty array"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for naive byte counts
+    ///
+    /// ### Why is this bad?
+    /// The [`bytecount`](https://crates.io/crates/bytecount)
+    /// crate has methods to count your bytes faster, especially for large slices.
+    ///
+    /// ### Known problems
+    /// If you have predominantly small slices, the
+    /// `bytecount::count(..)` method may actually be slower. However, if you can
+    /// ensure that less than 2³²-1 matches arise, the `naive_count_32(..)` can be
+    /// faster in those cases.
+    ///
+    /// ### Example
+    /// ```rust
+    /// # let vec = vec![1_u8];
+    /// let count = vec.iter().filter(|x| **x == 0u8).count();
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust,ignore
+    /// # let vec = vec![1_u8];
+    /// let count = bytecount::count(&vec, 0u8);
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub NAIVE_BYTECOUNT,
+    pedantic,
+    "use of naive `<slice>.filter(|&x| x == y).count()` to count byte values"
+}
+
 pub struct Methods {
     avoid_breaking_exported_api: bool,
     msrv: Option<RustcVersion>,
@@ -2471,7 +2505,8 @@ impl_lint_pass!(Methods => [
     NO_EFFECT_REPLACE,
     OBFUSCATED_IF_ELSE,
     ITER_ON_SINGLE_ITEMS,
-    ITER_ON_EMPTY_COLLECTIONS
+    ITER_ON_EMPTY_COLLECTIONS,
+    NAIVE_BYTECOUNT,
 ]);
 
 /// Extracts a method call name, args, and `Span` of the method name.
@@ -2726,12 +2761,13 @@ impl Methods {
                     },
                     _ => {},
                 },
-                ("count", []) => match method_call(recv) {
+                ("count", []) if is_trait_method(cx, expr, sym::Iterator) => match method_call(recv) {
                     Some(("cloned", [recv2], _)) => iter_overeager_cloned::check(cx, expr, recv, recv2, true, false),
                     Some((name2 @ ("into_iter" | "iter" | "iter_mut"), [recv2], _)) => {
                         iter_count::check(cx, expr, recv2, name2);
                     },
                     Some(("map", [_, arg], _)) => suspicious_map::check(cx, expr, recv, arg),
+                    Some(("filter", [recv2, arg], _)) => bytecount::check(cx, expr, recv2, arg),
                     _ => {},
                 },
                 ("drain", [arg]) => {
-- 
cgit 1.4.1-3-g733a5


From ba6a4595285e38f35970e66db903475989e0be6f Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sun, 5 Jun 2022 13:05:11 -0400
Subject: Move `BytesCountToLen` into `Methods` lint pass

---
 clippy_lints/src/bytes_count_to_len.rs         | 70 --------------------------
 clippy_lints/src/lib.register_all.rs           |  2 +-
 clippy_lints/src/lib.register_complexity.rs    |  2 +-
 clippy_lints/src/lib.register_lints.rs         |  2 +-
 clippy_lints/src/lib.rs                        |  2 -
 clippy_lints/src/methods/bytes_count_to_len.rs | 37 ++++++++++++++
 clippy_lints/src/methods/mod.rs                | 28 +++++++++++
 7 files changed, 68 insertions(+), 75 deletions(-)
 delete mode 100644 clippy_lints/src/bytes_count_to_len.rs
 create mode 100644 clippy_lints/src/methods/bytes_count_to_len.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/bytes_count_to_len.rs b/clippy_lints/src/bytes_count_to_len.rs
deleted file mode 100644
index d70dbf5b239..00000000000
--- a/clippy_lints/src/bytes_count_to_len.rs
+++ /dev/null
@@ -1,70 +0,0 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{match_def_path, paths};
-use if_chain::if_chain;
-use rustc_errors::Applicability;
-use rustc_hir as hir;
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::sym;
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// It checks for `str::bytes().count()` and suggests replacing it with
-    /// `str::len()`.
-    ///
-    /// ### Why is this bad?
-    /// `str::bytes().count()` is longer and may not be as performant as using
-    /// `str::len()`.
-    ///
-    /// ### Example
-    /// ```rust
-    /// "hello".bytes().count();
-    /// String::from("hello").bytes().count();
-    /// ```
-    /// Use instead:
-    /// ```rust
-    /// "hello".len();
-    /// String::from("hello").len();
-    /// ```
-    #[clippy::version = "1.62.0"]
-    pub BYTES_COUNT_TO_LEN,
-    complexity,
-    "Using `bytes().count()` when `len()` performs the same functionality"
-}
-
-declare_lint_pass!(BytesCountToLen => [BYTES_COUNT_TO_LEN]);
-
-impl<'tcx> LateLintPass<'tcx> for BytesCountToLen {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
-        if_chain! {
-            if let hir::ExprKind::MethodCall(_, expr_args, _) = &expr.kind;
-            if let Some(expr_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
-            if match_def_path(cx, expr_def_id, &paths::ITER_COUNT);
-
-            if let [bytes_expr] = &**expr_args;
-            if let hir::ExprKind::MethodCall(_, bytes_args, _) = &bytes_expr.kind;
-            if let Some(bytes_def_id) = cx.typeck_results().type_dependent_def_id(bytes_expr.hir_id);
-            if match_def_path(cx, bytes_def_id, &paths::STR_BYTES);
-
-            if let [str_expr] = &**bytes_args;
-            let ty = cx.typeck_results().expr_ty(str_expr).peel_refs();
-
-            if is_type_diagnostic_item(cx, ty, sym::String) || ty.kind() == &ty::Str;
-            then {
-                let mut applicability = Applicability::MachineApplicable;
-                span_lint_and_sugg(
-                    cx,
-                    BYTES_COUNT_TO_LEN,
-                    expr.span,
-                    "using long and hard to read `.bytes().count()`",
-                    "consider calling `.len()` instead",
-                    format!("{}.len()", snippet_with_applicability(cx, str_expr.span, "..", &mut applicability)),
-                    applicability
-                );
-            }
-        };
-    }
-}
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index a0a4b07a77e..f48e542ee41 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -20,7 +20,6 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(booleans::NONMINIMAL_BOOL),
     LintId::of(booleans::OVERLY_COMPLEX_BOOL_EXPR),
     LintId::of(borrow_deref_ref::BORROW_DEREF_REF),
-    LintId::of(bytes_count_to_len::BYTES_COUNT_TO_LEN),
     LintId::of(casts::CAST_ABS_TO_UNSIGNED),
     LintId::of(casts::CAST_ENUM_CONSTRUCTOR),
     LintId::of(casts::CAST_ENUM_TRUNCATION),
@@ -151,6 +150,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(mem_replace::MEM_REPLACE_WITH_DEFAULT),
     LintId::of(mem_replace::MEM_REPLACE_WITH_UNINIT),
     LintId::of(methods::BIND_INSTEAD_OF_MAP),
+    LintId::of(methods::BYTES_COUNT_TO_LEN),
     LintId::of(methods::BYTES_NTH),
     LintId::of(methods::CHARS_LAST_CMP),
     LintId::of(methods::CHARS_NEXT_CMP),
diff --git a/clippy_lints/src/lib.register_complexity.rs b/clippy_lints/src/lib.register_complexity.rs
index 3784d3c68dc..324b380317f 100644
--- a/clippy_lints/src/lib.register_complexity.rs
+++ b/clippy_lints/src/lib.register_complexity.rs
@@ -6,7 +6,6 @@ store.register_group(true, "clippy::complexity", Some("clippy_complexity"), vec!
     LintId::of(attrs::DEPRECATED_CFG_ATTR),
     LintId::of(booleans::NONMINIMAL_BOOL),
     LintId::of(borrow_deref_ref::BORROW_DEREF_REF),
-    LintId::of(bytes_count_to_len::BYTES_COUNT_TO_LEN),
     LintId::of(casts::CHAR_LIT_AS_U8),
     LintId::of(casts::UNNECESSARY_CAST),
     LintId::of(dereference::EXPLICIT_AUTO_DEREF),
@@ -33,6 +32,7 @@ store.register_group(true, "clippy::complexity", Some("clippy_complexity"), vec!
     LintId::of(matches::NEEDLESS_MATCH),
     LintId::of(matches::WILDCARD_IN_OR_PATTERNS),
     LintId::of(methods::BIND_INSTEAD_OF_MAP),
+    LintId::of(methods::BYTES_COUNT_TO_LEN),
     LintId::of(methods::CLONE_ON_COPY),
     LintId::of(methods::FILTER_MAP_IDENTITY),
     LintId::of(methods::FILTER_NEXT),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index c3c24fb1668..bfd12b98944 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -59,7 +59,6 @@ store.register_lints(&[
     booleans::NONMINIMAL_BOOL,
     booleans::OVERLY_COMPLEX_BOOL_EXPR,
     borrow_deref_ref::BORROW_DEREF_REF,
-    bytes_count_to_len::BYTES_COUNT_TO_LEN,
     cargo::CARGO_COMMON_METADATA,
     cargo::MULTIPLE_CRATE_VERSIONS,
     cargo::NEGATIVE_FEATURE_NAMES,
@@ -284,6 +283,7 @@ store.register_lints(&[
     mem_replace::MEM_REPLACE_WITH_DEFAULT,
     mem_replace::MEM_REPLACE_WITH_UNINIT,
     methods::BIND_INSTEAD_OF_MAP,
+    methods::BYTES_COUNT_TO_LEN,
     methods::BYTES_NTH,
     methods::CHARS_LAST_CMP,
     methods::CHARS_NEXT_CMP,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 617f1622325..f4cb5e5bf16 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -180,7 +180,6 @@ mod blocks_in_if_conditions;
 mod bool_assert_comparison;
 mod booleans;
 mod borrow_deref_ref;
-mod bytes_count_to_len;
 mod cargo;
 mod case_sensitive_file_extension_comparisons;
 mod casts;
@@ -907,7 +906,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(unnecessary_owned_empty_strings::UnnecessaryOwnedEmptyStrings));
     store.register_early_pass(|| Box::new(pub_use::PubUse));
     store.register_late_pass(|| Box::new(format_push_string::FormatPushString));
-    store.register_late_pass(|| Box::new(bytes_count_to_len::BytesCountToLen));
     let max_include_file_size = conf.max_include_file_size;
     store.register_late_pass(move || Box::new(large_include_file::LargeIncludeFile::new(max_include_file_size)));
     store.register_late_pass(|| Box::new(strings::TrimSplitWhitespace));
diff --git a/clippy_lints/src/methods/bytes_count_to_len.rs b/clippy_lints/src/methods/bytes_count_to_len.rs
new file mode 100644
index 00000000000..fcfc25b523d
--- /dev/null
+++ b/clippy_lints/src/methods/bytes_count_to_len.rs
@@ -0,0 +1,37 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::ty::is_type_diagnostic_item;
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir as hir;
+use rustc_lint::LateContext;
+use rustc_span::sym;
+
+use super::BYTES_COUNT_TO_LEN;
+
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx hir::Expr<'_>,
+    count_recv: &'tcx hir::Expr<'_>,
+    bytes_recv: &'tcx hir::Expr<'_>,
+) {
+    if_chain! {
+        if let Some(bytes_id) = cx.typeck_results().type_dependent_def_id(count_recv.hir_id);
+        if let Some(impl_id) = cx.tcx.impl_of_method(bytes_id);
+        if cx.tcx.type_of(impl_id).is_str();
+        let ty = cx.typeck_results().expr_ty(bytes_recv).peel_refs();
+        if ty.is_str() || is_type_diagnostic_item(cx, ty, sym::String);
+        then {
+            let mut applicability = Applicability::MachineApplicable;
+            span_lint_and_sugg(
+                cx,
+                BYTES_COUNT_TO_LEN,
+                expr.span,
+                "using long and hard to read `.bytes().count()`",
+                "consider calling `.len()` instead",
+                format!("{}.len()", snippet_with_applicability(cx, bytes_recv.span, "..", &mut applicability)),
+                applicability
+            );
+        }
+    };
+}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index f0d9dce5518..eab3ca1842b 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1,5 +1,6 @@
 mod bind_instead_of_map;
 mod bytecount;
+mod bytes_count_to_len;
 mod bytes_nth;
 mod chars_cmp;
 mod chars_cmp_with_unwrap;
@@ -2402,6 +2403,31 @@ declare_clippy_lint! {
     "use of naive `<slice>.filter(|&x| x == y).count()` to count byte values"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// It checks for `str::bytes().count()` and suggests replacing it with
+    /// `str::len()`.
+    ///
+    /// ### Why is this bad?
+    /// `str::bytes().count()` is longer and may not be as performant as using
+    /// `str::len()`.
+    ///
+    /// ### Example
+    /// ```rust
+    /// "hello".bytes().count();
+    /// String::from("hello").bytes().count();
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// "hello".len();
+    /// String::from("hello").len();
+    /// ```
+    #[clippy::version = "1.62.0"]
+    pub BYTES_COUNT_TO_LEN,
+    complexity,
+    "Using `bytes().count()` when `len()` performs the same functionality"
+}
+
 pub struct Methods {
     avoid_breaking_exported_api: bool,
     msrv: Option<RustcVersion>,
@@ -2507,6 +2533,7 @@ impl_lint_pass!(Methods => [
     ITER_ON_SINGLE_ITEMS,
     ITER_ON_EMPTY_COLLECTIONS,
     NAIVE_BYTECOUNT,
+    BYTES_COUNT_TO_LEN,
 ]);
 
 /// Extracts a method call name, args, and `Span` of the method name.
@@ -2768,6 +2795,7 @@ impl Methods {
                     },
                     Some(("map", [_, arg], _)) => suspicious_map::check(cx, expr, recv, arg),
                     Some(("filter", [recv2, arg], _)) => bytecount::check(cx, expr, recv2, arg),
+                    Some(("bytes", [recv2], _)) => bytes_count_to_len::check(cx, expr, recv, recv2),
                     _ => {},
                 },
                 ("drain", [arg]) => {
-- 
cgit 1.4.1-3-g733a5


From e3b77974d0025b6900fde9799ad4b2cd324050fb Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sun, 5 Jun 2022 13:21:04 -0400
Subject: Move `CaseSensitiveFileExtensionComparisons` into `Methods` lint pass

---
 .../case_sensitive_file_extension_comparisons.rs   | 85 ----------------------
 clippy_lints/src/lib.register_lints.rs             |  2 +-
 clippy_lints/src/lib.register_pedantic.rs          |  2 +-
 clippy_lints/src/lib.rs                            |  4 -
 .../case_sensitive_file_extension_comparisons.rs   | 41 +++++++++++
 clippy_lints/src/methods/mod.rs                    | 34 +++++++++
 6 files changed, 77 insertions(+), 91 deletions(-)
 delete mode 100644 clippy_lints/src/case_sensitive_file_extension_comparisons.rs
 create mode 100644 clippy_lints/src/methods/case_sensitive_file_extension_comparisons.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/case_sensitive_file_extension_comparisons.rs b/clippy_lints/src/case_sensitive_file_extension_comparisons.rs
deleted file mode 100644
index bef196565a2..00000000000
--- a/clippy_lints/src/case_sensitive_file_extension_comparisons.rs
+++ /dev/null
@@ -1,85 +0,0 @@
-use clippy_utils::diagnostics::span_lint_and_help;
-use if_chain::if_chain;
-use rustc_ast::ast::LitKind;
-use rustc_hir::{Expr, ExprKind, PathSegment};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::{source_map::Spanned, symbol::sym, Span};
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for calls to `ends_with` with possible file extensions
-    /// and suggests to use a case-insensitive approach instead.
-    ///
-    /// ### Why is this bad?
-    /// `ends_with` is case-sensitive and may not detect files with a valid extension.
-    ///
-    /// ### Example
-    /// ```rust
-    /// fn is_rust_file(filename: &str) -> bool {
-    ///     filename.ends_with(".rs")
-    /// }
-    /// ```
-    /// Use instead:
-    /// ```rust
-    /// fn is_rust_file(filename: &str) -> bool {
-    ///     let filename = std::path::Path::new(filename);
-    ///     filename.extension()
-    ///         .map_or(false, |ext| ext.eq_ignore_ascii_case("rs"))
-    /// }
-    /// ```
-    #[clippy::version = "1.51.0"]
-    pub CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS,
-    pedantic,
-    "Checks for calls to ends_with with case-sensitive file extensions"
-}
-
-declare_lint_pass!(CaseSensitiveFileExtensionComparisons => [CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS]);
-
-fn check_case_sensitive_file_extension_comparison(ctx: &LateContext<'_>, expr: &Expr<'_>) -> Option<Span> {
-    if_chain! {
-        if let ExprKind::MethodCall(PathSegment { ident, .. }, [obj, extension, ..], span) = expr.kind;
-        if ident.as_str() == "ends_with";
-        if let ExprKind::Lit(Spanned { node: LitKind::Str(ext_literal, ..), ..}) = extension.kind;
-        if (2..=6).contains(&ext_literal.as_str().len());
-        if ext_literal.as_str().starts_with('.');
-        if ext_literal.as_str().chars().skip(1).all(|c| c.is_uppercase() || c.is_ascii_digit())
-            || ext_literal.as_str().chars().skip(1).all(|c| c.is_lowercase() || c.is_ascii_digit());
-        then {
-            let mut ty = ctx.typeck_results().expr_ty(obj);
-            ty = match ty.kind() {
-                ty::Ref(_, ty, ..) => *ty,
-                _ => ty
-            };
-
-            match ty.kind() {
-                ty::Str => {
-                    return Some(span);
-                },
-                ty::Adt(def, _) => {
-                    if ctx.tcx.is_diagnostic_item(sym::String, def.did()) {
-                        return Some(span);
-                    }
-                },
-                _ => { return None; }
-            }
-        }
-    }
-    None
-}
-
-impl<'tcx> LateLintPass<'tcx> for CaseSensitiveFileExtensionComparisons {
-    fn check_expr(&mut self, ctx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
-        if let Some(span) = check_case_sensitive_file_extension_comparison(ctx, expr) {
-            span_lint_and_help(
-                ctx,
-                CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS,
-                span,
-                "case-sensitive file extension comparison",
-                None,
-                "consider using a case-insensitive comparison instead",
-            );
-        }
-    }
-}
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index bfd12b98944..10ff1fa1f58 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -64,7 +64,6 @@ store.register_lints(&[
     cargo::NEGATIVE_FEATURE_NAMES,
     cargo::REDUNDANT_FEATURE_NAMES,
     cargo::WILDCARD_DEPENDENCIES,
-    case_sensitive_file_extension_comparisons::CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS,
     casts::AS_UNDERSCORE,
     casts::BORROW_AS_PTR,
     casts::CAST_ABS_TO_UNSIGNED,
@@ -285,6 +284,7 @@ store.register_lints(&[
     methods::BIND_INSTEAD_OF_MAP,
     methods::BYTES_COUNT_TO_LEN,
     methods::BYTES_NTH,
+    methods::CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS,
     methods::CHARS_LAST_CMP,
     methods::CHARS_NEXT_CMP,
     methods::CLONED_INSTEAD_OF_COPIED,
diff --git a/clippy_lints/src/lib.register_pedantic.rs b/clippy_lints/src/lib.register_pedantic.rs
index 241d70d2628..c9cf7dbd078 100644
--- a/clippy_lints/src/lib.register_pedantic.rs
+++ b/clippy_lints/src/lib.register_pedantic.rs
@@ -4,7 +4,6 @@
 
 store.register_group(true, "clippy::pedantic", Some("clippy_pedantic"), vec![
     LintId::of(attrs::INLINE_ALWAYS),
-    LintId::of(case_sensitive_file_extension_comparisons::CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS),
     LintId::of(casts::BORROW_AS_PTR),
     LintId::of(casts::CAST_LOSSLESS),
     LintId::of(casts::CAST_POSSIBLE_TRUNCATION),
@@ -56,6 +55,7 @@ store.register_group(true, "clippy::pedantic", Some("clippy_pedantic"), vec![
     LintId::of(matches::MATCH_WILDCARD_FOR_SINGLE_VARIANTS),
     LintId::of(matches::MATCH_WILD_ERR_ARM),
     LintId::of(matches::SINGLE_MATCH_ELSE),
+    LintId::of(methods::CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS),
     LintId::of(methods::CLONED_INSTEAD_OF_COPIED),
     LintId::of(methods::FILTER_MAP_NEXT),
     LintId::of(methods::FLAT_MAP_OPTION),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index f4cb5e5bf16..68f69dc64b8 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -181,7 +181,6 @@ mod bool_assert_comparison;
 mod booleans;
 mod borrow_deref_ref;
 mod cargo;
-mod case_sensitive_file_extension_comparisons;
 mod casts;
 mod checked_conversions;
 mod cognitive_complexity;
@@ -852,9 +851,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(strings::StringToString));
     store.register_late_pass(|| Box::new(zero_sized_map_values::ZeroSizedMapValues));
     store.register_late_pass(|| Box::new(vec_init_then_push::VecInitThenPush::default()));
-    store.register_late_pass(|| {
-        Box::new(case_sensitive_file_extension_comparisons::CaseSensitiveFileExtensionComparisons)
-    });
     store.register_late_pass(|| Box::new(redundant_slicing::RedundantSlicing));
     store.register_late_pass(|| Box::new(from_str_radix_10::FromStrRadix10));
     store.register_late_pass(move || Box::new(if_then_some_else_none::IfThenSomeElseNone::new(msrv)));
diff --git a/clippy_lints/src/methods/case_sensitive_file_extension_comparisons.rs b/clippy_lints/src/methods/case_sensitive_file_extension_comparisons.rs
new file mode 100644
index 00000000000..b3c2c7c9a2d
--- /dev/null
+++ b/clippy_lints/src/methods/case_sensitive_file_extension_comparisons.rs
@@ -0,0 +1,41 @@
+use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::ty::is_type_diagnostic_item;
+use if_chain::if_chain;
+use rustc_ast::ast::LitKind;
+use rustc_hir::{Expr, ExprKind};
+use rustc_lint::LateContext;
+use rustc_span::{source_map::Spanned, symbol::sym, Span};
+
+use super::CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS;
+
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx Expr<'_>,
+    call_span: Span,
+    recv: &'tcx Expr<'_>,
+    arg: &'tcx Expr<'_>,
+) {
+    if_chain! {
+        if let Some(method_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
+        if let Some(impl_id) = cx.tcx.impl_of_method(method_id);
+        if cx.tcx.type_of(impl_id).is_str();
+        if let ExprKind::Lit(Spanned { node: LitKind::Str(ext_literal, ..), ..}) = arg.kind;
+        if (2..=6).contains(&ext_literal.as_str().len());
+        let ext_str = ext_literal.as_str();
+        if ext_str.starts_with('.');
+        if ext_str.chars().skip(1).all(|c| c.is_uppercase() || c.is_ascii_digit())
+            || ext_str.chars().skip(1).all(|c| c.is_lowercase() || c.is_ascii_digit());
+        let recv_ty = cx.typeck_results().expr_ty(recv).peel_refs();
+        if recv_ty.is_str() || is_type_diagnostic_item(cx, recv_ty, sym::String);
+        then {
+            span_lint_and_help(
+                cx,
+                CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS,
+                call_span,
+                "case-sensitive file extension comparison",
+                None,
+                "consider using a case-insensitive comparison instead",
+            );
+        }
+    }
+}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index eab3ca1842b..0bb247c7e81 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -2,6 +2,7 @@ mod bind_instead_of_map;
 mod bytecount;
 mod bytes_count_to_len;
 mod bytes_nth;
+mod case_sensitive_file_extension_comparisons;
 mod chars_cmp;
 mod chars_cmp_with_unwrap;
 mod chars_last_cmp;
@@ -2428,6 +2429,34 @@ declare_clippy_lint! {
     "Using `bytes().count()` when `len()` performs the same functionality"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for calls to `ends_with` with possible file extensions
+    /// and suggests to use a case-insensitive approach instead.
+    ///
+    /// ### Why is this bad?
+    /// `ends_with` is case-sensitive and may not detect files with a valid extension.
+    ///
+    /// ### Example
+    /// ```rust
+    /// fn is_rust_file(filename: &str) -> bool {
+    ///     filename.ends_with(".rs")
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// fn is_rust_file(filename: &str) -> bool {
+    ///     let filename = std::path::Path::new(filename);
+    ///     filename.extension()
+    ///         .map_or(false, |ext| ext.eq_ignore_ascii_case("rs"))
+    /// }
+    /// ```
+    #[clippy::version = "1.51.0"]
+    pub CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS,
+    pedantic,
+    "Checks for calls to ends_with with case-sensitive file extensions"
+}
+
 pub struct Methods {
     avoid_breaking_exported_api: bool,
     msrv: Option<RustcVersion>,
@@ -2534,6 +2563,7 @@ impl_lint_pass!(Methods => [
     ITER_ON_EMPTY_COLLECTIONS,
     NAIVE_BYTECOUNT,
     BYTES_COUNT_TO_LEN,
+    CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS,
 ]);
 
 /// Extracts a method call name, args, and `Span` of the method name.
@@ -2801,6 +2831,10 @@ impl Methods {
                 ("drain", [arg]) => {
                     iter_with_drain::check(cx, expr, recv, span, arg);
                 },
+                ("ends_with", [arg]) => {
+                    if let ExprKind::MethodCall(_, _, span) = expr.kind {
+                    case_sensitive_file_extension_comparisons::check(cx, expr, span, recv, arg);
+                },
                 ("expect", [_]) => match method_call(recv) {
                     Some(("ok", [recv], _)) => ok_expect::check(cx, expr, recv),
                     Some(("err", [recv], err_span)) => err_expect::check(cx, expr, recv, self.msrv, span, err_span),
-- 
cgit 1.4.1-3-g733a5


From a8d80d531f1d358c26295eb3d81624594544dd4b Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sun, 5 Jun 2022 13:44:09 -0400
Subject: Move `GetFirst` into `Methods` lint pass

---
 clippy_lints/src/get_first.rs          | 68 ----------------------------------
 clippy_lints/src/lib.register_all.rs   |  2 +-
 clippy_lints/src/lib.register_lints.rs |  2 +-
 clippy_lints/src/lib.register_style.rs |  2 +-
 clippy_lints/src/lib.rs                |  2 -
 clippy_lints/src/methods/get_first.rs  | 39 +++++++++++++++++++
 clippy_lints/src/methods/mod.rs        | 36 +++++++++++++++++-
 7 files changed, 76 insertions(+), 75 deletions(-)
 delete mode 100644 clippy_lints/src/get_first.rs
 create mode 100644 clippy_lints/src/methods/get_first.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/get_first.rs b/clippy_lints/src/get_first.rs
deleted file mode 100644
index 529f7babaa5..00000000000
--- a/clippy_lints/src/get_first.rs
+++ /dev/null
@@ -1,68 +0,0 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::{is_slice_of_primitives, match_def_path, paths};
-use if_chain::if_chain;
-use rustc_ast::LitKind;
-use rustc_errors::Applicability;
-use rustc_hir as hir;
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::source_map::Spanned;
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for using `x.get(0)` instead of
-    /// `x.first()`.
-    ///
-    /// ### Why is this bad?
-    /// Using `x.first()` is easier to read and has the same
-    /// result.
-    ///
-    /// ### Example
-    /// ```rust
-    /// let x = vec![2, 3, 5];
-    /// let first_element = x.get(0);
-    /// ```
-    ///
-    /// Use instead:
-    /// ```rust
-    /// let x = vec![2, 3, 5];
-    /// let first_element = x.first();
-    /// ```
-    #[clippy::version = "1.63.0"]
-    pub GET_FIRST,
-    style,
-    "Using `x.get(0)` when `x.first()` is simpler"
-}
-declare_lint_pass!(GetFirst => [GET_FIRST]);
-
-impl<'tcx> LateLintPass<'tcx> for GetFirst {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
-        if_chain! {
-            if let hir::ExprKind::MethodCall(_, [struct_calling_on, method_arg], _) = &expr.kind;
-            if let Some(expr_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
-            if match_def_path(cx, expr_def_id, &paths::SLICE_GET);
-
-            if let Some(_) = is_slice_of_primitives(cx, struct_calling_on);
-            if let hir::ExprKind::Lit(Spanned { node: LitKind::Int(0, _), .. }) = method_arg.kind;
-
-            then {
-                let mut applicability = Applicability::MachineApplicable;
-                let slice_name = snippet_with_applicability(
-                    cx,
-                    struct_calling_on.span, "..",
-                    &mut applicability,
-                );
-                span_lint_and_sugg(
-                    cx,
-                    GET_FIRST,
-                    expr.span,
-                    &format!("accessing first element with `{0}.get(0)`", slice_name),
-                    "try",
-                    format!("{}.first()", slice_name),
-                    applicability,
-                );
-            }
-        }
-    }
-}
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index f48e542ee41..8ce0a26915f 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -81,7 +81,6 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(functions::NOT_UNSAFE_PTR_ARG_DEREF),
     LintId::of(functions::RESULT_UNIT_ERR),
     LintId::of(functions::TOO_MANY_ARGUMENTS),
-    LintId::of(get_first::GET_FIRST),
     LintId::of(if_let_mutex::IF_LET_MUTEX),
     LintId::of(indexing_slicing::OUT_OF_BOUNDS_INDEXING),
     LintId::of(infinite_iter::INFINITE_ITER),
@@ -162,6 +161,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(methods::FILTER_MAP_IDENTITY),
     LintId::of(methods::FILTER_NEXT),
     LintId::of(methods::FLAT_MAP_IDENTITY),
+    LintId::of(methods::GET_FIRST),
     LintId::of(methods::GET_LAST_WITH_LEN),
     LintId::of(methods::INSPECT_FOR_EACH),
     LintId::of(methods::INTO_ITER_ON_REF),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 10ff1fa1f58..a6224035ec8 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -174,7 +174,6 @@ store.register_lints(&[
     functions::TOO_MANY_ARGUMENTS,
     functions::TOO_MANY_LINES,
     future_not_send::FUTURE_NOT_SEND,
-    get_first::GET_FIRST,
     if_let_mutex::IF_LET_MUTEX,
     if_not_else::IF_NOT_ELSE,
     if_then_some_else_none::IF_THEN_SOME_ELSE_NONE,
@@ -302,6 +301,7 @@ store.register_lints(&[
     methods::FLAT_MAP_IDENTITY,
     methods::FLAT_MAP_OPTION,
     methods::FROM_ITER_INSTEAD_OF_COLLECT,
+    methods::GET_FIRST,
     methods::GET_LAST_WITH_LEN,
     methods::GET_UNWRAP,
     methods::IMPLICIT_CLONE,
diff --git a/clippy_lints/src/lib.register_style.rs b/clippy_lints/src/lib.register_style.rs
index 6972c75597a..5ddaba2396e 100644
--- a/clippy_lints/src/lib.register_style.rs
+++ b/clippy_lints/src/lib.register_style.rs
@@ -29,7 +29,6 @@ store.register_group(true, "clippy::style", Some("clippy_style"), vec![
     LintId::of(functions::DOUBLE_MUST_USE),
     LintId::of(functions::MUST_USE_UNIT),
     LintId::of(functions::RESULT_UNIT_ERR),
-    LintId::of(get_first::GET_FIRST),
     LintId::of(inherent_to_string::INHERENT_TO_STRING),
     LintId::of(init_numbered_fields::INIT_NUMBERED_FIELDS),
     LintId::of(len_zero::COMPARISON_TO_EMPTY),
@@ -62,6 +61,7 @@ store.register_group(true, "clippy::style", Some("clippy_style"), vec![
     LintId::of(methods::CHARS_LAST_CMP),
     LintId::of(methods::CHARS_NEXT_CMP),
     LintId::of(methods::ERR_EXPECT),
+    LintId::of(methods::GET_FIRST),
     LintId::of(methods::INTO_ITER_ON_REF),
     LintId::of(methods::IS_DIGIT_ASCII_RADIX),
     LintId::of(methods::ITER_CLONED_COLLECT),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 68f69dc64b8..3fcdc84113d 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -233,7 +233,6 @@ mod from_over_into;
 mod from_str_radix_10;
 mod functions;
 mod future_not_send;
-mod get_first;
 mod if_let_mutex;
 mod if_not_else;
 mod if_then_some_else_none;
@@ -907,7 +906,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(strings::TrimSplitWhitespace));
     store.register_late_pass(|| Box::new(rc_clone_in_vec_init::RcCloneInVecInit));
     store.register_early_pass(|| Box::new(duplicate_mod::DuplicateMod::default()));
-    store.register_late_pass(|| Box::new(get_first::GetFirst));
     store.register_early_pass(|| Box::new(unused_rounding::UnusedRounding));
     store.register_early_pass(move || Box::new(almost_complete_letter_range::AlmostCompleteLetterRange::new(msrv)));
     store.register_late_pass(|| Box::new(swap_ptr_to_ref::SwapPtrToRef));
diff --git a/clippy_lints/src/methods/get_first.rs b/clippy_lints/src/methods/get_first.rs
new file mode 100644
index 00000000000..4de77de7404
--- /dev/null
+++ b/clippy_lints/src/methods/get_first.rs
@@ -0,0 +1,39 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::is_slice_of_primitives;
+use clippy_utils::source::snippet_with_applicability;
+use if_chain::if_chain;
+use rustc_ast::LitKind;
+use rustc_errors::Applicability;
+use rustc_hir as hir;
+use rustc_lint::LateContext;
+use rustc_span::source_map::Spanned;
+
+use super::GET_FIRST;
+
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx hir::Expr<'_>,
+    recv: &'tcx hir::Expr<'_>,
+    arg: &'tcx hir::Expr<'_>,
+) {
+    if_chain! {
+        if let Some(method_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
+        if let Some(impl_id) = cx.tcx.impl_of_method(method_id);
+        if cx.tcx.type_of(impl_id).is_slice();
+        if let Some(_) = is_slice_of_primitives(cx, recv);
+        if let hir::ExprKind::Lit(Spanned { node: LitKind::Int(0, _), .. }) = arg.kind;
+        then {
+            let mut app = Applicability::MachineApplicable;
+            let slice_name = snippet_with_applicability(cx, recv.span, "..", &mut app);
+            span_lint_and_sugg(
+                cx,
+                GET_FIRST,
+                expr.span,
+                &format!("accessing first element with `{0}.get(0)`", slice_name),
+                "try",
+                format!("{}.first()", slice_name),
+                app,
+            );
+        }
+    }
+}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 0bb247c7e81..c3438426985 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -24,6 +24,7 @@ mod filter_next;
 mod flat_map_identity;
 mod flat_map_option;
 mod from_iter_instead_of_collect;
+mod get_first;
 mod get_last_with_len;
 mod get_unwrap;
 mod implicit_clone;
@@ -2457,6 +2458,32 @@ declare_clippy_lint! {
     "Checks for calls to ends_with with case-sensitive file extensions"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for using `x.get(0)` instead of
+    /// `x.first()`.
+    ///
+    /// ### Why is this bad?
+    /// Using `x.first()` is easier to read and has the same
+    /// result.
+    ///
+    /// ### Example
+    /// ```rust
+    /// let x = vec![2, 3, 5];
+    /// let first_element = x.get(0);
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust
+    /// let x = vec![2, 3, 5];
+    /// let first_element = x.first();
+    /// ```
+    #[clippy::version = "1.63.0"]
+    pub GET_FIRST,
+    style,
+    "Using `x.get(0)` when `x.first()` is simpler"
+}
+
 pub struct Methods {
     avoid_breaking_exported_api: bool,
     msrv: Option<RustcVersion>,
@@ -2564,6 +2591,7 @@ impl_lint_pass!(Methods => [
     NAIVE_BYTECOUNT,
     BYTES_COUNT_TO_LEN,
     CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS,
+    GET_FIRST,
 ]);
 
 /// Extracts a method call name, args, and `Span` of the method name.
@@ -2833,7 +2861,8 @@ impl Methods {
                 },
                 ("ends_with", [arg]) => {
                     if let ExprKind::MethodCall(_, _, span) = expr.kind {
-                    case_sensitive_file_extension_comparisons::check(cx, expr, span, recv, arg);
+                        case_sensitive_file_extension_comparisons::check(cx, expr, span, recv, arg);
+                    }
                 },
                 ("expect", [_]) => match method_call(recv) {
                     Some(("ok", [recv], _)) => ok_expect::check(cx, expr, recv),
@@ -2867,7 +2896,10 @@ impl Methods {
                         inspect_for_each::check(cx, expr, span2);
                     }
                 },
-                ("get", [arg]) => get_last_with_len::check(cx, expr, recv, arg),
+                ("get", [arg]) => {
+                    get_first::check(cx, expr, recv, arg);
+                    get_last_with_len::check(cx, expr, recv, arg);
+                },
                 ("get_or_insert_with", [arg]) => unnecessary_lazy_eval::check(cx, expr, recv, arg, "get_or_insert"),
                 ("is_file", []) => filetype_is_file::check(cx, expr, recv),
                 ("is_digit", [radix]) => is_digit_ascii_radix::check(cx, expr, recv, radix, self.msrv),
-- 
cgit 1.4.1-3-g733a5


From 5bc8813cdd4f33f42c4dc17572d148c284d3e81b Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sun, 5 Jun 2022 15:20:47 -0400
Subject: Move `ManualOkOr` into `Methods` lint pass

---
 clippy_lints/src/lib.register_lints.rs    |  2 +-
 clippy_lints/src/lib.register_pedantic.rs |  2 +-
 clippy_lints/src/lib.rs                   |  2 -
 clippy_lints/src/manual_ok_or.rs          | 95 -------------------------------
 clippy_lints/src/methods/manual_ok_or.rs  | 64 +++++++++++++++++++++
 clippy_lints/src/methods/mod.rs           | 33 ++++++++++-
 6 files changed, 98 insertions(+), 100 deletions(-)
 delete mode 100644 clippy_lints/src/manual_ok_or.rs
 create mode 100644 clippy_lints/src/methods/manual_ok_or.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index a6224035ec8..ac30c8b6eac 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -243,7 +243,6 @@ store.register_lints(&[
     manual_empty_string_creations::MANUAL_EMPTY_STRING_CREATIONS,
     manual_instant_elapsed::MANUAL_INSTANT_ELAPSED,
     manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE,
-    manual_ok_or::MANUAL_OK_OR,
     manual_rem_euclid::MANUAL_REM_EUCLID,
     manual_retain::MANUAL_RETAIN,
     manual_strip::MANUAL_STRIP,
@@ -322,6 +321,7 @@ store.register_lints(&[
     methods::ITER_WITH_DRAIN,
     methods::MANUAL_FILTER_MAP,
     methods::MANUAL_FIND_MAP,
+    methods::MANUAL_OK_OR,
     methods::MANUAL_SATURATING_ARITHMETIC,
     methods::MANUAL_SPLIT_ONCE,
     methods::MANUAL_STR_REPEAT,
diff --git a/clippy_lints/src/lib.register_pedantic.rs b/clippy_lints/src/lib.register_pedantic.rs
index c9cf7dbd078..5c04a331d0a 100644
--- a/clippy_lints/src/lib.register_pedantic.rs
+++ b/clippy_lints/src/lib.register_pedantic.rs
@@ -48,7 +48,6 @@ store.register_group(true, "clippy::pedantic", Some("clippy_pedantic"), vec![
     LintId::of(macro_use::MACRO_USE_IMPORTS),
     LintId::of(manual_assert::MANUAL_ASSERT),
     LintId::of(manual_instant_elapsed::MANUAL_INSTANT_ELAPSED),
-    LintId::of(manual_ok_or::MANUAL_OK_OR),
     LintId::of(matches::MATCH_BOOL),
     LintId::of(matches::MATCH_ON_VEC_ITEMS),
     LintId::of(matches::MATCH_SAME_ARMS),
@@ -62,6 +61,7 @@ store.register_group(true, "clippy::pedantic", Some("clippy_pedantic"), vec![
     LintId::of(methods::FROM_ITER_INSTEAD_OF_COLLECT),
     LintId::of(methods::IMPLICIT_CLONE),
     LintId::of(methods::INEFFICIENT_TO_STRING),
+    LintId::of(methods::MANUAL_OK_OR),
     LintId::of(methods::MAP_UNWRAP_OR),
     LintId::of(methods::NAIVE_BYTECOUNT),
     LintId::of(methods::UNNECESSARY_JOIN),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 3fcdc84113d..774ae01cc4f 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -270,7 +270,6 @@ mod manual_bits;
 mod manual_empty_string_creations;
 mod manual_instant_elapsed;
 mod manual_non_exhaustive;
-mod manual_ok_or;
 mod manual_rem_euclid;
 mod manual_retain;
 mod manual_strip;
@@ -838,7 +837,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(stable_sort_primitive::StableSortPrimitive));
     store.register_late_pass(|| Box::new(repeat_once::RepeatOnce));
     store.register_late_pass(|| Box::new(unwrap_in_result::UnwrapInResult));
-    store.register_late_pass(|| Box::new(manual_ok_or::ManualOkOr));
     store.register_late_pass(|| Box::new(semicolon_if_nothing_returned::SemicolonIfNothingReturned));
     store.register_late_pass(|| Box::new(async_yields_async::AsyncYieldsAsync));
     let disallowed_methods = conf.disallowed_methods.clone();
diff --git a/clippy_lints/src/manual_ok_or.rs b/clippy_lints/src/manual_ok_or.rs
deleted file mode 100644
index cf5004399b8..00000000000
--- a/clippy_lints/src/manual_ok_or.rs
+++ /dev/null
@@ -1,95 +0,0 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::source::{indent_of, reindent_multiline, snippet_opt};
-use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{is_lang_ctor, path_to_local_id};
-use if_chain::if_chain;
-use rustc_errors::Applicability;
-use rustc_hir::LangItem::{ResultErr, ResultOk};
-use rustc_hir::{Closure, Expr, ExprKind, PatKind};
-use rustc_lint::LintContext;
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::lint::in_external_macro;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::symbol::sym;
-
-declare_clippy_lint! {
-    /// ### What it does
-    ///
-    /// Finds patterns that reimplement `Option::ok_or`.
-    ///
-    /// ### Why is this bad?
-    ///
-    /// Concise code helps focusing on behavior instead of boilerplate.
-    ///
-    /// ### Examples
-    /// ```rust
-    /// let foo: Option<i32> = None;
-    /// foo.map_or(Err("error"), |v| Ok(v));
-    /// ```
-    ///
-    /// Use instead:
-    /// ```rust
-    /// let foo: Option<i32> = None;
-    /// foo.ok_or("error");
-    /// ```
-    #[clippy::version = "1.49.0"]
-    pub MANUAL_OK_OR,
-    pedantic,
-    "finds patterns that can be encoded more concisely with `Option::ok_or`"
-}
-
-declare_lint_pass!(ManualOkOr => [MANUAL_OK_OR]);
-
-impl<'tcx> LateLintPass<'tcx> for ManualOkOr {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, scrutinee: &'tcx Expr<'tcx>) {
-        if in_external_macro(cx.sess(), scrutinee.span) {
-            return;
-        }
-
-        if_chain! {
-            if let ExprKind::MethodCall(method_segment, [receiver, or_expr, map_expr], _) = scrutinee.kind;
-            if method_segment.ident.name == sym!(map_or);
-            let ty = cx.typeck_results().expr_ty(receiver);
-            if is_type_diagnostic_item(cx, ty, sym::Option);
-            if is_ok_wrapping(cx, map_expr);
-            if let ExprKind::Call(Expr { kind: ExprKind::Path(err_path), .. }, &[ref err_arg]) = or_expr.kind;
-            if is_lang_ctor(cx, err_path, ResultErr);
-            if let Some(method_receiver_snippet) = snippet_opt(cx, receiver.span);
-            if let Some(err_arg_snippet) = snippet_opt(cx, err_arg.span);
-            if let Some(indent) = indent_of(cx, scrutinee.span);
-            then {
-                let reindented_err_arg_snippet =
-                    reindent_multiline(err_arg_snippet.into(), true, Some(indent + 4));
-                span_lint_and_sugg(
-                    cx,
-                    MANUAL_OK_OR,
-                    scrutinee.span,
-                    "this pattern reimplements `Option::ok_or`",
-                    "replace with",
-                    format!(
-                        "{}.ok_or({})",
-                        method_receiver_snippet,
-                        reindented_err_arg_snippet
-                    ),
-                    Applicability::MachineApplicable,
-                );
-            }
-        }
-    }
-}
-
-fn is_ok_wrapping(cx: &LateContext<'_>, map_expr: &Expr<'_>) -> bool {
-    if let ExprKind::Path(ref qpath) = map_expr.kind {
-        if is_lang_ctor(cx, qpath, ResultOk) {
-            return true;
-        }
-    }
-    if_chain! {
-        if let ExprKind::Closure(&Closure { body, .. }) = map_expr.kind;
-        let body = cx.tcx.hir().body(body);
-        if let PatKind::Binding(_, param_id, ..) = body.params[0].pat.kind;
-        if let ExprKind::Call(Expr { kind: ExprKind::Path(ok_path), .. }, &[ref ok_arg]) = body.value.kind;
-        if is_lang_ctor(cx, ok_path, ResultOk);
-        then { path_to_local_id(ok_arg, param_id) } else { false }
-    }
-}
diff --git a/clippy_lints/src/methods/manual_ok_or.rs b/clippy_lints/src/methods/manual_ok_or.rs
new file mode 100644
index 00000000000..ffd2f4a38b8
--- /dev/null
+++ b/clippy_lints/src/methods/manual_ok_or.rs
@@ -0,0 +1,64 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::{indent_of, reindent_multiline, snippet_opt};
+use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::{is_lang_ctor, path_to_local_id};
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir::LangItem::{ResultErr, ResultOk};
+use rustc_hir::{Closure, Expr, ExprKind, PatKind};
+use rustc_lint::LateContext;
+use rustc_span::symbol::sym;
+
+use super::MANUAL_OK_OR;
+
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx Expr<'tcx>,
+    recv: &'tcx Expr<'_>,
+    or_expr: &'tcx Expr<'_>,
+    map_expr: &'tcx Expr<'_>,
+) {
+    if_chain! {
+        if let Some(method_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
+        if let Some(impl_id) = cx.tcx.impl_of_method(method_id);
+        if is_type_diagnostic_item(cx, cx.tcx.type_of(impl_id), sym::Option);
+        if let ExprKind::Call(Expr { kind: ExprKind::Path(err_path), .. }, [err_arg]) = or_expr.kind;
+        if is_lang_ctor(cx, err_path, ResultErr);
+        if is_ok_wrapping(cx, map_expr);
+        if let Some(recv_snippet) = snippet_opt(cx, recv.span);
+        if let Some(err_arg_snippet) = snippet_opt(cx, err_arg.span);
+        if let Some(indent) = indent_of(cx, expr.span);
+        then {
+            let reindented_err_arg_snippet = reindent_multiline(err_arg_snippet.into(), true, Some(indent + 4));
+            span_lint_and_sugg(
+                cx,
+                MANUAL_OK_OR,
+                expr.span,
+                "this pattern reimplements `Option::ok_or`",
+                "replace with",
+                format!(
+                    "{}.ok_or({})",
+                    recv_snippet,
+                    reindented_err_arg_snippet
+                ),
+                Applicability::MachineApplicable,
+            );
+        }
+    }
+}
+
+fn is_ok_wrapping(cx: &LateContext<'_>, map_expr: &Expr<'_>) -> bool {
+    if let ExprKind::Path(ref qpath) = map_expr.kind {
+        if is_lang_ctor(cx, qpath, ResultOk) {
+            return true;
+        }
+    }
+    if_chain! {
+        if let ExprKind::Closure(&Closure { body, .. }) = map_expr.kind;
+        let body = cx.tcx.hir().body(body);
+        if let PatKind::Binding(_, param_id, ..) = body.params[0].pat.kind;
+        if let ExprKind::Call(Expr { kind: ExprKind::Path(ok_path), .. }, &[ref ok_arg]) = body.value.kind;
+        if is_lang_ctor(cx, ok_path, ResultOk);
+        then { path_to_local_id(ok_arg, param_id) } else { false }
+    }
+}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index c3438426985..132f6040a51 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -42,6 +42,7 @@ mod iter_overeager_cloned;
 mod iter_skip_next;
 mod iter_with_drain;
 mod iterator_step_by_zero;
+mod manual_ok_or;
 mod manual_saturating_arithmetic;
 mod manual_str_repeat;
 mod map_collect_result_unit;
@@ -2484,6 +2485,32 @@ declare_clippy_lint! {
     "Using `x.get(0)` when `x.first()` is simpler"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    ///
+    /// Finds patterns that reimplement `Option::ok_or`.
+    ///
+    /// ### Why is this bad?
+    ///
+    /// Concise code helps focusing on behavior instead of boilerplate.
+    ///
+    /// ### Examples
+    /// ```rust
+    /// let foo: Option<i32> = None;
+    /// foo.map_or(Err("error"), |v| Ok(v));
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust
+    /// let foo: Option<i32> = None;
+    /// foo.ok_or("error");
+    /// ```
+    #[clippy::version = "1.49.0"]
+    pub MANUAL_OK_OR,
+    pedantic,
+    "finds patterns that can be encoded more concisely with `Option::ok_or`"
+}
+
 pub struct Methods {
     avoid_breaking_exported_api: bool,
     msrv: Option<RustcVersion>,
@@ -2592,6 +2619,7 @@ impl_lint_pass!(Methods => [
     BYTES_COUNT_TO_LEN,
     CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS,
     GET_FIRST,
+    MANUAL_OK_OR,
 ]);
 
 /// Extracts a method call name, args, and `Span` of the method name.
@@ -2936,7 +2964,10 @@ impl Methods {
                     }
                     map_identity::check(cx, expr, recv, m_arg, name, span);
                 },
-                ("map_or", [def, map]) => option_map_or_none::check(cx, expr, recv, def, map),
+                ("map_or", [def, map]) => {
+                    option_map_or_none::check(cx, expr, recv, def, map);
+                    manual_ok_or::check(cx, expr, recv, def, map);
+                },
                 ("next", []) => {
                     if let Some((name2, [recv2, args2 @ ..], _)) = method_call(recv) {
                         match (name2, args2) {
-- 
cgit 1.4.1-3-g733a5


From 452395485b113b06c1a47313eeab75d374d97e9f Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sun, 5 Jun 2022 15:45:04 -0400
Subject: Move `MapClone` into `Methods` lint pass

---
 clippy_lints/src/lib.register_all.rs   |   2 +-
 clippy_lints/src/lib.register_lints.rs |   2 +-
 clippy_lints/src/lib.register_style.rs |   2 +-
 clippy_lints/src/lib.rs                |   3 -
 clippy_lints/src/map_clone.rs          | 167 ---------------------------------
 clippy_lints/src/methods/map_clone.rs  | 122 ++++++++++++++++++++++++
 clippy_lints/src/methods/mod.rs        |  34 +++++++
 7 files changed, 159 insertions(+), 173 deletions(-)
 delete mode 100644 clippy_lints/src/map_clone.rs
 create mode 100644 clippy_lints/src/methods/map_clone.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 8ce0a26915f..c496fd289bb 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -127,7 +127,6 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(manual_rem_euclid::MANUAL_REM_EUCLID),
     LintId::of(manual_retain::MANUAL_RETAIN),
     LintId::of(manual_strip::MANUAL_STRIP),
-    LintId::of(map_clone::MAP_CLONE),
     LintId::of(map_unit_fn::OPTION_MAP_UNIT_FN),
     LintId::of(map_unit_fn::RESULT_MAP_UNIT_FN),
     LintId::of(match_result_ok::MATCH_RESULT_OK),
@@ -179,6 +178,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(methods::MANUAL_SATURATING_ARITHMETIC),
     LintId::of(methods::MANUAL_SPLIT_ONCE),
     LintId::of(methods::MANUAL_STR_REPEAT),
+    LintId::of(methods::MAP_CLONE),
     LintId::of(methods::MAP_COLLECT_RESULT_UNIT),
     LintId::of(methods::MAP_FLATTEN),
     LintId::of(methods::MAP_IDENTITY),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index ac30c8b6eac..c7ea7f703f2 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -246,7 +246,6 @@ store.register_lints(&[
     manual_rem_euclid::MANUAL_REM_EUCLID,
     manual_retain::MANUAL_RETAIN,
     manual_strip::MANUAL_STRIP,
-    map_clone::MAP_CLONE,
     map_err_ignore::MAP_ERR_IGNORE,
     map_unit_fn::OPTION_MAP_UNIT_FN,
     map_unit_fn::RESULT_MAP_UNIT_FN,
@@ -325,6 +324,7 @@ store.register_lints(&[
     methods::MANUAL_SATURATING_ARITHMETIC,
     methods::MANUAL_SPLIT_ONCE,
     methods::MANUAL_STR_REPEAT,
+    methods::MAP_CLONE,
     methods::MAP_COLLECT_RESULT_UNIT,
     methods::MAP_FLATTEN,
     methods::MAP_IDENTITY,
diff --git a/clippy_lints/src/lib.register_style.rs b/clippy_lints/src/lib.register_style.rs
index 5ddaba2396e..52bf019c82e 100644
--- a/clippy_lints/src/lib.register_style.rs
+++ b/clippy_lints/src/lib.register_style.rs
@@ -45,7 +45,6 @@ store.register_group(true, "clippy::style", Some("clippy_style"), vec![
     LintId::of(manual_bits::MANUAL_BITS),
     LintId::of(manual_empty_string_creations::MANUAL_EMPTY_STRING_CREATIONS),
     LintId::of(manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE),
-    LintId::of(map_clone::MAP_CLONE),
     LintId::of(match_result_ok::MATCH_RESULT_OK),
     LintId::of(matches::COLLAPSIBLE_MATCH),
     LintId::of(matches::INFALLIBLE_DESTRUCTURING_MATCH),
@@ -69,6 +68,7 @@ store.register_group(true, "clippy::style", Some("clippy_style"), vec![
     LintId::of(methods::ITER_NTH_ZERO),
     LintId::of(methods::ITER_SKIP_NEXT),
     LintId::of(methods::MANUAL_SATURATING_ARITHMETIC),
+    LintId::of(methods::MAP_CLONE),
     LintId::of(methods::MAP_COLLECT_RESULT_UNIT),
     LintId::of(methods::NEW_RET_NO_SELF),
     LintId::of(methods::OBFUSCATED_IF_ELSE),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 774ae01cc4f..8f31e4b938c 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -273,7 +273,6 @@ mod manual_non_exhaustive;
 mod manual_rem_euclid;
 mod manual_retain;
 mod manual_strip;
-mod map_clone;
 mod map_err_ignore;
 mod map_unit_fn;
 mod match_result_ok;
@@ -628,8 +627,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(move || Box::new(needless_question_mark::NeedlessQuestionMark));
     store.register_late_pass(move || Box::new(casts::Casts::new(msrv)));
     store.register_early_pass(move || Box::new(unnested_or_patterns::UnnestedOrPatterns::new(msrv)));
-    store.register_late_pass(move || Box::new(map_clone::MapClone::new(msrv)));
-
     store.register_late_pass(|| Box::new(size_of_in_element_count::SizeOfInElementCount));
     store.register_late_pass(|| Box::new(same_name_method::SameNameMethod));
     let max_suggested_slice_pattern_length = conf.max_suggested_slice_pattern_length;
diff --git a/clippy_lints/src/map_clone.rs b/clippy_lints/src/map_clone.rs
deleted file mode 100644
index 95c312f1fe2..00000000000
--- a/clippy_lints/src/map_clone.rs
+++ /dev/null
@@ -1,167 +0,0 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::ty::{is_copy, is_type_diagnostic_item};
-use clippy_utils::{is_trait_method, meets_msrv, msrvs, peel_blocks};
-use if_chain::if_chain;
-use rustc_errors::Applicability;
-use rustc_hir as hir;
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::mir::Mutability;
-use rustc_middle::ty;
-use rustc_middle::ty::adjustment::Adjust;
-use rustc_semver::RustcVersion;
-use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::symbol::Ident;
-use rustc_span::{sym, Span};
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for usage of `map(|x| x.clone())` or
-    /// dereferencing closures for `Copy` types, on `Iterator` or `Option`,
-    /// and suggests `cloned()` or `copied()` instead
-    ///
-    /// ### Why is this bad?
-    /// Readability, this can be written more concisely
-    ///
-    /// ### Example
-    /// ```rust
-    /// let x = vec![42, 43];
-    /// let y = x.iter();
-    /// let z = y.map(|i| *i);
-    /// ```
-    ///
-    /// The correct use would be:
-    ///
-    /// ```rust
-    /// let x = vec![42, 43];
-    /// let y = x.iter();
-    /// let z = y.cloned();
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub MAP_CLONE,
-    style,
-    "using `iterator.map(|x| x.clone())`, or dereferencing closures for `Copy` types"
-}
-
-pub struct MapClone {
-    msrv: Option<RustcVersion>,
-}
-
-impl_lint_pass!(MapClone => [MAP_CLONE]);
-
-impl MapClone {
-    pub fn new(msrv: Option<RustcVersion>) -> Self {
-        Self { msrv }
-    }
-}
-
-impl<'tcx> LateLintPass<'tcx> for MapClone {
-    fn check_expr(&mut self, cx: &LateContext<'_>, e: &hir::Expr<'_>) {
-        if e.span.from_expansion() {
-            return;
-        }
-
-        if_chain! {
-            if let hir::ExprKind::MethodCall(method, args, _) = e.kind;
-            if args.len() == 2;
-            if method.ident.name == sym::map;
-            let ty = cx.typeck_results().expr_ty(&args[0]);
-            if is_type_diagnostic_item(cx, ty, sym::Option) || is_trait_method(cx, e, sym::Iterator);
-            if let hir::ExprKind::Closure(&hir::Closure { body, .. }) = args[1].kind;
-            then {
-                let closure_body = cx.tcx.hir().body(body);
-                let closure_expr = peel_blocks(&closure_body.value);
-                match closure_body.params[0].pat.kind {
-                    hir::PatKind::Ref(inner, hir::Mutability::Not) => if let hir::PatKind::Binding(
-                        hir::BindingAnnotation::Unannotated, .., name, None
-                    ) = inner.kind {
-                        if ident_eq(name, closure_expr) {
-                            self.lint_explicit_closure(cx, e.span, args[0].span, true);
-                        }
-                    },
-                    hir::PatKind::Binding(hir::BindingAnnotation::Unannotated, .., name, None) => {
-                        match closure_expr.kind {
-                            hir::ExprKind::Unary(hir::UnOp::Deref, inner) => {
-                                if ident_eq(name, inner) {
-                                    if let ty::Ref(.., Mutability::Not) = cx.typeck_results().expr_ty(inner).kind() {
-                                        self.lint_explicit_closure(cx, e.span, args[0].span, true);
-                                    }
-                                }
-                            },
-                            hir::ExprKind::MethodCall(method, [obj], _) => if_chain! {
-                                if ident_eq(name, obj) && method.ident.name == sym::clone;
-                                if let Some(fn_id) = cx.typeck_results().type_dependent_def_id(closure_expr.hir_id);
-                                if let Some(trait_id) = cx.tcx.trait_of_item(fn_id);
-                                if cx.tcx.lang_items().clone_trait().map_or(false, |id| id == trait_id);
-                                // no autoderefs
-                                if !cx.typeck_results().expr_adjustments(obj).iter()
-                                    .any(|a| matches!(a.kind, Adjust::Deref(Some(..))));
-                                then {
-                                    let obj_ty = cx.typeck_results().expr_ty(obj);
-                                    if let ty::Ref(_, ty, mutability) = obj_ty.kind() {
-                                        if matches!(mutability, Mutability::Not) {
-                                            let copy = is_copy(cx, *ty);
-                                            self.lint_explicit_closure(cx, e.span, args[0].span, copy);
-                                        }
-                                    } else {
-                                        lint_needless_cloning(cx, e.span, args[0].span);
-                                    }
-                                }
-                            },
-                            _ => {},
-                        }
-                    },
-                    _ => {},
-                }
-            }
-        }
-    }
-
-    extract_msrv_attr!(LateContext);
-}
-
-fn ident_eq(name: Ident, path: &hir::Expr<'_>) -> bool {
-    if let hir::ExprKind::Path(hir::QPath::Resolved(None, path)) = path.kind {
-        path.segments.len() == 1 && path.segments[0].ident == name
-    } else {
-        false
-    }
-}
-
-fn lint_needless_cloning(cx: &LateContext<'_>, root: Span, receiver: Span) {
-    span_lint_and_sugg(
-        cx,
-        MAP_CLONE,
-        root.trim_start(receiver).unwrap(),
-        "you are needlessly cloning iterator elements",
-        "remove the `map` call",
-        String::new(),
-        Applicability::MachineApplicable,
-    );
-}
-
-impl MapClone {
-    fn lint_explicit_closure(&self, cx: &LateContext<'_>, replace: Span, root: Span, is_copy: bool) {
-        let mut applicability = Applicability::MachineApplicable;
-
-        let (message, sugg_method) = if is_copy && meets_msrv(self.msrv, msrvs::ITERATOR_COPIED) {
-            ("you are using an explicit closure for copying elements", "copied")
-        } else {
-            ("you are using an explicit closure for cloning elements", "cloned")
-        };
-
-        span_lint_and_sugg(
-            cx,
-            MAP_CLONE,
-            replace,
-            message,
-            &format!("consider calling the dedicated `{}` method", sugg_method),
-            format!(
-                "{}.{}()",
-                snippet_with_applicability(cx, root, "..", &mut applicability),
-                sugg_method,
-            ),
-            applicability,
-        );
-    }
-}
diff --git a/clippy_lints/src/methods/map_clone.rs b/clippy_lints/src/methods/map_clone.rs
new file mode 100644
index 00000000000..ffedda95ff8
--- /dev/null
+++ b/clippy_lints/src/methods/map_clone.rs
@@ -0,0 +1,122 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::ty::{is_copy, is_type_diagnostic_item};
+use clippy_utils::{is_diag_trait_item, meets_msrv, msrvs, peel_blocks};
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir as hir;
+use rustc_lint::LateContext;
+use rustc_middle::mir::Mutability;
+use rustc_middle::ty;
+use rustc_middle::ty::adjustment::Adjust;
+use rustc_semver::RustcVersion;
+use rustc_span::symbol::Ident;
+use rustc_span::{sym, Span};
+
+use super::MAP_CLONE;
+
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'_>,
+    e: &hir::Expr<'_>,
+    recv: &hir::Expr<'_>,
+    arg: &'tcx hir::Expr<'_>,
+    msrv: Option<RustcVersion>,
+) {
+    if_chain! {
+        if let Some(method_id) = cx.typeck_results().type_dependent_def_id(e.hir_id);
+        if cx.tcx.impl_of_method(method_id)
+            .map_or(false, |id| is_type_diagnostic_item(cx, cx.tcx.type_of(id), sym::Option))
+            || is_diag_trait_item(cx, method_id, sym::Iterator);
+        if let hir::ExprKind::Closure(&hir::Closure{ body, .. }) = arg.kind;
+        then {
+            let closure_body = cx.tcx.hir().body(body);
+            let closure_expr = peel_blocks(&closure_body.value);
+            match closure_body.params[0].pat.kind {
+                hir::PatKind::Ref(inner, hir::Mutability::Not) => if let hir::PatKind::Binding(
+                    hir::BindingAnnotation::Unannotated, .., name, None
+                ) = inner.kind {
+                    if ident_eq(name, closure_expr) {
+                        lint_explicit_closure(cx, e.span, recv.span, true, msrv);
+                    }
+                },
+                hir::PatKind::Binding(hir::BindingAnnotation::Unannotated, .., name, None) => {
+                    match closure_expr.kind {
+                        hir::ExprKind::Unary(hir::UnOp::Deref, inner) => {
+                            if ident_eq(name, inner) {
+                                if let ty::Ref(.., Mutability::Not) = cx.typeck_results().expr_ty(inner).kind() {
+                                    lint_explicit_closure(cx, e.span, recv.span, true, msrv);
+                                }
+                            }
+                        },
+                        hir::ExprKind::MethodCall(method, [obj], _) => if_chain! {
+                            if ident_eq(name, obj) && method.ident.name == sym::clone;
+                            if let Some(fn_id) = cx.typeck_results().type_dependent_def_id(closure_expr.hir_id);
+                            if let Some(trait_id) = cx.tcx.trait_of_item(fn_id);
+                            if cx.tcx.lang_items().clone_trait().map_or(false, |id| id == trait_id);
+                            // no autoderefs
+                            if !cx.typeck_results().expr_adjustments(obj).iter()
+                                .any(|a| matches!(a.kind, Adjust::Deref(Some(..))));
+                            then {
+                                let obj_ty = cx.typeck_results().expr_ty(obj);
+                                if let ty::Ref(_, ty, mutability) = obj_ty.kind() {
+                                    if matches!(mutability, Mutability::Not) {
+                                        let copy = is_copy(cx, *ty);
+                                        lint_explicit_closure(cx, e.span, recv.span, copy, msrv);
+                                    }
+                                } else {
+                                    lint_needless_cloning(cx, e.span, recv.span);
+                                }
+                            }
+                        },
+                        _ => {},
+                    }
+                },
+                _ => {},
+            }
+        }
+    }
+}
+
+fn ident_eq(name: Ident, path: &hir::Expr<'_>) -> bool {
+    if let hir::ExprKind::Path(hir::QPath::Resolved(None, path)) = path.kind {
+        path.segments.len() == 1 && path.segments[0].ident == name
+    } else {
+        false
+    }
+}
+
+fn lint_needless_cloning(cx: &LateContext<'_>, root: Span, receiver: Span) {
+    span_lint_and_sugg(
+        cx,
+        MAP_CLONE,
+        root.trim_start(receiver).unwrap(),
+        "you are needlessly cloning iterator elements",
+        "remove the `map` call",
+        String::new(),
+        Applicability::MachineApplicable,
+    );
+}
+
+fn lint_explicit_closure(cx: &LateContext<'_>, replace: Span, root: Span, is_copy: bool, msrv: Option<RustcVersion>) {
+    let mut applicability = Applicability::MachineApplicable;
+
+    let (message, sugg_method) = if is_copy && meets_msrv(msrv, msrvs::ITERATOR_COPIED) {
+        ("you are using an explicit closure for copying elements", "copied")
+    } else {
+        ("you are using an explicit closure for cloning elements", "cloned")
+    };
+
+    span_lint_and_sugg(
+        cx,
+        MAP_CLONE,
+        replace,
+        message,
+        &format!("consider calling the dedicated `{}` method", sugg_method),
+        format!(
+            "{}.{}()",
+            snippet_with_applicability(cx, root, "..", &mut applicability),
+            sugg_method,
+        ),
+        applicability,
+    );
+}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 132f6040a51..02592da1aae 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -45,6 +45,7 @@ mod iterator_step_by_zero;
 mod manual_ok_or;
 mod manual_saturating_arithmetic;
 mod manual_str_repeat;
+mod map_clone;
 mod map_collect_result_unit;
 mod map_flatten;
 mod map_identity;
@@ -2511,6 +2512,35 @@ declare_clippy_lint! {
     "finds patterns that can be encoded more concisely with `Option::ok_or`"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of `map(|x| x.clone())` or
+    /// dereferencing closures for `Copy` types, on `Iterator` or `Option`,
+    /// and suggests `cloned()` or `copied()` instead
+    ///
+    /// ### Why is this bad?
+    /// Readability, this can be written more concisely
+    ///
+    /// ### Example
+    /// ```rust
+    /// let x = vec![42, 43];
+    /// let y = x.iter();
+    /// let z = y.map(|i| *i);
+    /// ```
+    ///
+    /// The correct use would be:
+    ///
+    /// ```rust
+    /// let x = vec![42, 43];
+    /// let y = x.iter();
+    /// let z = y.cloned();
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub MAP_CLONE,
+    style,
+    "using `iterator.map(|x| x.clone())`, or dereferencing closures for `Copy` types"
+}
+
 pub struct Methods {
     avoid_breaking_exported_api: bool,
     msrv: Option<RustcVersion>,
@@ -2620,6 +2650,7 @@ impl_lint_pass!(Methods => [
     CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS,
     GET_FIRST,
     MANUAL_OK_OR,
+    MAP_CLONE,
 ]);
 
 /// Extracts a method call name, args, and `Span` of the method name.
@@ -2949,6 +2980,9 @@ impl Methods {
                     }
                 },
                 (name @ ("map" | "map_err"), [m_arg]) => {
+                    if name == "map" {
+                        map_clone::check(cx, expr, recv, m_arg, self.msrv);
+                    }
                     if let Some((name, [recv2, args @ ..], span2)) = method_call(recv) {
                         match (name, args) {
                             ("as_mut", []) => option_as_ref_deref::check(cx, expr, recv2, m_arg, true, self.msrv),
-- 
cgit 1.4.1-3-g733a5


From 2f0ed0a0b1fa7928464b95e0cfd0883699cb9c33 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sun, 5 Jun 2022 15:59:24 -0400
Subject: Move `MapErrIgnore` into `Methods` lint pass

---
 clippy_lints/src/lib.register_lints.rs       |   2 +-
 clippy_lints/src/lib.register_restriction.rs |   2 +-
 clippy_lints/src/lib.rs                      |   2 -
 clippy_lints/src/map_err_ignore.rs           | 154 ---------------------------
 clippy_lints/src/methods/map_err_ignore.rs   |  34 ++++++
 clippy_lints/src/methods/mod.rs              | 104 ++++++++++++++++++
 6 files changed, 140 insertions(+), 158 deletions(-)
 delete mode 100644 clippy_lints/src/map_err_ignore.rs
 create mode 100644 clippy_lints/src/methods/map_err_ignore.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index c7ea7f703f2..67fb0d50931 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -246,7 +246,6 @@ store.register_lints(&[
     manual_rem_euclid::MANUAL_REM_EUCLID,
     manual_retain::MANUAL_RETAIN,
     manual_strip::MANUAL_STRIP,
-    map_err_ignore::MAP_ERR_IGNORE,
     map_unit_fn::OPTION_MAP_UNIT_FN,
     map_unit_fn::RESULT_MAP_UNIT_FN,
     match_result_ok::MATCH_RESULT_OK,
@@ -326,6 +325,7 @@ store.register_lints(&[
     methods::MANUAL_STR_REPEAT,
     methods::MAP_CLONE,
     methods::MAP_COLLECT_RESULT_UNIT,
+    methods::MAP_ERR_IGNORE,
     methods::MAP_FLATTEN,
     methods::MAP_IDENTITY,
     methods::MAP_UNWRAP_OR,
diff --git a/clippy_lints/src/lib.register_restriction.rs b/clippy_lints/src/lib.register_restriction.rs
index 890ae2792ab..7fc5eef5f8a 100644
--- a/clippy_lints/src/lib.register_restriction.rs
+++ b/clippy_lints/src/lib.register_restriction.rs
@@ -30,7 +30,6 @@ store.register_group(true, "clippy::restriction", Some("clippy_restriction"), ve
     LintId::of(large_include_file::LARGE_INCLUDE_FILE),
     LintId::of(let_underscore::LET_UNDERSCORE_MUST_USE),
     LintId::of(literal_representation::DECIMAL_LITERAL_REPRESENTATION),
-    LintId::of(map_err_ignore::MAP_ERR_IGNORE),
     LintId::of(matches::REST_PAT_IN_FULLY_BOUND_STRUCTS),
     LintId::of(matches::TRY_ERR),
     LintId::of(matches::WILDCARD_ENUM_MATCH_ARM),
@@ -39,6 +38,7 @@ store.register_group(true, "clippy::restriction", Some("clippy_restriction"), ve
     LintId::of(methods::EXPECT_USED),
     LintId::of(methods::FILETYPE_IS_FILE),
     LintId::of(methods::GET_UNWRAP),
+    LintId::of(methods::MAP_ERR_IGNORE),
     LintId::of(methods::UNWRAP_USED),
     LintId::of(misc_early::SEPARATED_LITERAL_SUFFIX),
     LintId::of(misc_early::UNNEEDED_FIELD_PATTERN),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 8f31e4b938c..179d630089f 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -273,7 +273,6 @@ mod manual_non_exhaustive;
 mod manual_rem_euclid;
 mod manual_retain;
 mod manual_strip;
-mod map_err_ignore;
 mod map_unit_fn;
 mod match_result_ok;
 mod matches;
@@ -636,7 +635,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
             msrv,
         ))
     });
-    store.register_late_pass(|| Box::new(map_err_ignore::MapErrIgnore));
     store.register_late_pass(|| Box::new(shadow::Shadow::default()));
     store.register_late_pass(|| Box::new(unit_types::UnitTypes));
     store.register_late_pass(|| Box::new(loops::Loops));
diff --git a/clippy_lints/src/map_err_ignore.rs b/clippy_lints/src/map_err_ignore.rs
deleted file mode 100644
index 1e542447c96..00000000000
--- a/clippy_lints/src/map_err_ignore.rs
+++ /dev/null
@@ -1,154 +0,0 @@
-use clippy_utils::diagnostics::span_lint_and_help;
-use rustc_hir::{CaptureBy, Closure, Expr, ExprKind, PatKind};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for instances of `map_err(|_| Some::Enum)`
-    ///
-    /// ### Why is this bad?
-    /// This `map_err` throws away the original error rather than allowing the enum to contain and report the cause of the error
-    ///
-    /// ### Example
-    /// Before:
-    /// ```rust
-    /// use std::fmt;
-    ///
-    /// #[derive(Debug)]
-    /// enum Error {
-    ///     Indivisible,
-    ///     Remainder(u8),
-    /// }
-    ///
-    /// impl fmt::Display for Error {
-    ///     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-    ///         match self {
-    ///             Error::Indivisible => write!(f, "could not divide input by three"),
-    ///             Error::Remainder(remainder) => write!(
-    ///                 f,
-    ///                 "input is not divisible by three, remainder = {}",
-    ///                 remainder
-    ///             ),
-    ///         }
-    ///     }
-    /// }
-    ///
-    /// impl std::error::Error for Error {}
-    ///
-    /// fn divisible_by_3(input: &str) -> Result<(), Error> {
-    ///     input
-    ///         .parse::<i32>()
-    ///         .map_err(|_| Error::Indivisible)
-    ///         .map(|v| v % 3)
-    ///         .and_then(|remainder| {
-    ///             if remainder == 0 {
-    ///                 Ok(())
-    ///             } else {
-    ///                 Err(Error::Remainder(remainder as u8))
-    ///             }
-    ///         })
-    /// }
-    ///  ```
-    ///
-    ///  After:
-    ///  ```rust
-    /// use std::{fmt, num::ParseIntError};
-    ///
-    /// #[derive(Debug)]
-    /// enum Error {
-    ///     Indivisible(ParseIntError),
-    ///     Remainder(u8),
-    /// }
-    ///
-    /// impl fmt::Display for Error {
-    ///     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-    ///         match self {
-    ///             Error::Indivisible(_) => write!(f, "could not divide input by three"),
-    ///             Error::Remainder(remainder) => write!(
-    ///                 f,
-    ///                 "input is not divisible by three, remainder = {}",
-    ///                 remainder
-    ///             ),
-    ///         }
-    ///     }
-    /// }
-    ///
-    /// impl std::error::Error for Error {
-    ///     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-    ///         match self {
-    ///             Error::Indivisible(source) => Some(source),
-    ///             _ => None,
-    ///         }
-    ///     }
-    /// }
-    ///
-    /// fn divisible_by_3(input: &str) -> Result<(), Error> {
-    ///     input
-    ///         .parse::<i32>()
-    ///         .map_err(Error::Indivisible)
-    ///         .map(|v| v % 3)
-    ///         .and_then(|remainder| {
-    ///             if remainder == 0 {
-    ///                 Ok(())
-    ///             } else {
-    ///                 Err(Error::Remainder(remainder as u8))
-    ///             }
-    ///         })
-    /// }
-    /// ```
-    #[clippy::version = "1.48.0"]
-    pub MAP_ERR_IGNORE,
-    restriction,
-    "`map_err` should not ignore the original error"
-}
-
-declare_lint_pass!(MapErrIgnore => [MAP_ERR_IGNORE]);
-
-impl<'tcx> LateLintPass<'tcx> for MapErrIgnore {
-    // do not try to lint if this is from a macro or desugaring
-    fn check_expr(&mut self, cx: &LateContext<'_>, e: &Expr<'_>) {
-        if e.span.from_expansion() {
-            return;
-        }
-
-        // check if this is a method call (e.g. x.foo())
-        if let ExprKind::MethodCall(method, [_, arg], _) = e.kind {
-            // only work if the method name is `map_err` and there are only 2 arguments (e.g. x.map_err(|_|[1]
-            // Enum::Variant[2]))
-            if method.ident.name == sym!(map_err) {
-                // make sure the first argument is a closure, and grab the CaptureRef, BodyId, and fn_decl_span
-                // fields
-                if let ExprKind::Closure(&Closure {
-                    capture_clause,
-                    body,
-                    fn_decl_span,
-                    ..
-                }) = arg.kind
-                {
-                    // check if this is by Reference (meaning there's no move statement)
-                    if capture_clause == CaptureBy::Ref {
-                        // Get the closure body to check the parameters and values
-                        let closure_body = cx.tcx.hir().body(body);
-                        // make sure there's only one parameter (`|_|`)
-                        if closure_body.params.len() == 1 {
-                            // make sure that parameter is the wild token (`_`)
-                            if let PatKind::Wild = closure_body.params[0].pat.kind {
-                                // span the area of the closure capture and warn that the
-                                // original error will be thrown away
-                                span_lint_and_help(
-                                    cx,
-                                    MAP_ERR_IGNORE,
-                                    fn_decl_span,
-                                    "`map_err(|_|...` wildcard pattern discards the original error",
-                                    None,
-                                    "consider storing the original error as a source in the new error, or silence this warning using an ignored identifier (`.map_err(|_foo| ...`)",
-                                );
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-}
diff --git a/clippy_lints/src/methods/map_err_ignore.rs b/clippy_lints/src/methods/map_err_ignore.rs
new file mode 100644
index 00000000000..1fb6617145e
--- /dev/null
+++ b/clippy_lints/src/methods/map_err_ignore.rs
@@ -0,0 +1,34 @@
+use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::ty::is_type_diagnostic_item;
+use rustc_hir::{CaptureBy, Closure, Expr, ExprKind, PatKind};
+use rustc_lint::LateContext;
+use rustc_span::sym;
+
+use super::MAP_ERR_IGNORE;
+
+pub(super) fn check<'tcx>(cx: &LateContext<'_>, e: &Expr<'_>, arg: &'tcx Expr<'_>) {
+    if let Some(method_id) = cx.typeck_results().type_dependent_def_id(e.hir_id)
+        && let Some(impl_id) = cx.tcx.impl_of_method(method_id)
+        && is_type_diagnostic_item(cx, cx.tcx.type_of(impl_id), sym::Result)
+        && let ExprKind::Closure(&Closure {
+            capture_clause: CaptureBy::Ref,
+            body,
+            fn_decl_span,
+            ..
+        }) = arg.kind
+        && let closure_body = cx.tcx.hir().body(body)
+        && let [param] = closure_body.params
+        && let PatKind::Wild = param.pat.kind
+    {
+        // span the area of the closure capture and warn that the
+        // original error will be thrown away
+        span_lint_and_help(
+            cx,
+            MAP_ERR_IGNORE,
+            fn_decl_span,
+            "`map_err(|_|...` wildcard pattern discards the original error",
+            None,
+            "consider storing the original error as a source in the new error, or silence this warning using an ignored identifier (`.map_err(|_foo| ...`)",
+        );
+    }
+}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 02592da1aae..e327bdcf578 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -47,6 +47,7 @@ mod manual_saturating_arithmetic;
 mod manual_str_repeat;
 mod map_clone;
 mod map_collect_result_unit;
+mod map_err_ignore;
 mod map_flatten;
 mod map_identity;
 mod map_unwrap_or;
@@ -2541,6 +2542,106 @@ declare_clippy_lint! {
     "using `iterator.map(|x| x.clone())`, or dereferencing closures for `Copy` types"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for instances of `map_err(|_| Some::Enum)`
+    ///
+    /// ### Why is this bad?
+    /// This `map_err` throws away the original error rather than allowing the enum to contain and report the cause of the error
+    ///
+    /// ### Example
+    /// Before:
+    /// ```rust
+    /// use std::fmt;
+    ///
+    /// #[derive(Debug)]
+    /// enum Error {
+    ///     Indivisible,
+    ///     Remainder(u8),
+    /// }
+    ///
+    /// impl fmt::Display for Error {
+    ///     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    ///         match self {
+    ///             Error::Indivisible => write!(f, "could not divide input by three"),
+    ///             Error::Remainder(remainder) => write!(
+    ///                 f,
+    ///                 "input is not divisible by three, remainder = {}",
+    ///                 remainder
+    ///             ),
+    ///         }
+    ///     }
+    /// }
+    ///
+    /// impl std::error::Error for Error {}
+    ///
+    /// fn divisible_by_3(input: &str) -> Result<(), Error> {
+    ///     input
+    ///         .parse::<i32>()
+    ///         .map_err(|_| Error::Indivisible)
+    ///         .map(|v| v % 3)
+    ///         .and_then(|remainder| {
+    ///             if remainder == 0 {
+    ///                 Ok(())
+    ///             } else {
+    ///                 Err(Error::Remainder(remainder as u8))
+    ///             }
+    ///         })
+    /// }
+    ///  ```
+    ///
+    ///  After:
+    ///  ```rust
+    /// use std::{fmt, num::ParseIntError};
+    ///
+    /// #[derive(Debug)]
+    /// enum Error {
+    ///     Indivisible(ParseIntError),
+    ///     Remainder(u8),
+    /// }
+    ///
+    /// impl fmt::Display for Error {
+    ///     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    ///         match self {
+    ///             Error::Indivisible(_) => write!(f, "could not divide input by three"),
+    ///             Error::Remainder(remainder) => write!(
+    ///                 f,
+    ///                 "input is not divisible by three, remainder = {}",
+    ///                 remainder
+    ///             ),
+    ///         }
+    ///     }
+    /// }
+    ///
+    /// impl std::error::Error for Error {
+    ///     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+    ///         match self {
+    ///             Error::Indivisible(source) => Some(source),
+    ///             _ => None,
+    ///         }
+    ///     }
+    /// }
+    ///
+    /// fn divisible_by_3(input: &str) -> Result<(), Error> {
+    ///     input
+    ///         .parse::<i32>()
+    ///         .map_err(Error::Indivisible)
+    ///         .map(|v| v % 3)
+    ///         .and_then(|remainder| {
+    ///             if remainder == 0 {
+    ///                 Ok(())
+    ///             } else {
+    ///                 Err(Error::Remainder(remainder as u8))
+    ///             }
+    ///         })
+    /// }
+    /// ```
+    #[clippy::version = "1.48.0"]
+    pub MAP_ERR_IGNORE,
+    restriction,
+    "`map_err` should not ignore the original error"
+}
+
 pub struct Methods {
     avoid_breaking_exported_api: bool,
     msrv: Option<RustcVersion>,
@@ -2651,6 +2752,7 @@ impl_lint_pass!(Methods => [
     GET_FIRST,
     MANUAL_OK_OR,
     MAP_CLONE,
+    MAP_ERR_IGNORE,
 ]);
 
 /// Extracts a method call name, args, and `Span` of the method name.
@@ -2982,6 +3084,8 @@ impl Methods {
                 (name @ ("map" | "map_err"), [m_arg]) => {
                     if name == "map" {
                         map_clone::check(cx, expr, recv, m_arg, self.msrv);
+                    } else {
+                        map_err_ignore::check(cx, expr, m_arg);
                     }
                     if let Some((name, [recv2, args @ ..], span2)) = method_call(recv) {
                         match (name, args) {
-- 
cgit 1.4.1-3-g733a5


From 508cf6bdbc9d4d97503f2603f86ec4b3aa1db26a Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sun, 5 Jun 2022 19:57:58 -0400
Subject: Move `MutMutexLock` into `Methods` lint pass

---
 clippy_lints/src/lib.register_all.rs       |  2 +-
 clippy_lints/src/lib.register_lints.rs     |  2 +-
 clippy_lints/src/lib.register_style.rs     |  2 +-
 clippy_lints/src/lib.rs                    |  2 -
 clippy_lints/src/methods/mod.rs            | 41 +++++++++++++++++
 clippy_lints/src/methods/mut_mutex_lock.rs | 30 +++++++++++++
 clippy_lints/src/mut_mutex_lock.rs         | 70 ------------------------------
 7 files changed, 74 insertions(+), 75 deletions(-)
 create mode 100644 clippy_lints/src/methods/mut_mutex_lock.rs
 delete mode 100644 clippy_lints/src/mut_mutex_lock.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index c496fd289bb..1151cd42e59 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -182,6 +182,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(methods::MAP_COLLECT_RESULT_UNIT),
     LintId::of(methods::MAP_FLATTEN),
     LintId::of(methods::MAP_IDENTITY),
+    LintId::of(methods::MUT_MUTEX_LOCK),
     LintId::of(methods::NEEDLESS_OPTION_AS_DEREF),
     LintId::of(methods::NEEDLESS_OPTION_TAKE),
     LintId::of(methods::NEEDLESS_SPLITN),
@@ -226,7 +227,6 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(misc_early::ZERO_PREFIXED_LITERAL),
     LintId::of(mixed_read_write_in_expression::DIVERGING_SUB_EXPRESSION),
     LintId::of(mut_key::MUTABLE_KEY_TYPE),
-    LintId::of(mut_mutex_lock::MUT_MUTEX_LOCK),
     LintId::of(mut_reference::UNNECESSARY_MUT_PASSED),
     LintId::of(needless_arbitrary_self_type::NEEDLESS_ARBITRARY_SELF_TYPE),
     LintId::of(needless_bool::BOOL_COMPARISON),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 67fb0d50931..2ae93b49737 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -329,6 +329,7 @@ store.register_lints(&[
     methods::MAP_FLATTEN,
     methods::MAP_IDENTITY,
     methods::MAP_UNWRAP_OR,
+    methods::MUT_MUTEX_LOCK,
     methods::NAIVE_BYTECOUNT,
     methods::NEEDLESS_OPTION_AS_DEREF,
     methods::NEEDLESS_OPTION_TAKE,
@@ -389,7 +390,6 @@ store.register_lints(&[
     module_style::SELF_NAMED_MODULE_FILES,
     mut_key::MUTABLE_KEY_TYPE,
     mut_mut::MUT_MUT,
-    mut_mutex_lock::MUT_MUTEX_LOCK,
     mut_reference::UNNECESSARY_MUT_PASSED,
     mutable_debug_assertion::DEBUG_ASSERT_WITH_MUT_CALL,
     mutex_atomic::MUTEX_ATOMIC,
diff --git a/clippy_lints/src/lib.register_style.rs b/clippy_lints/src/lib.register_style.rs
index 52bf019c82e..d34aadd1d37 100644
--- a/clippy_lints/src/lib.register_style.rs
+++ b/clippy_lints/src/lib.register_style.rs
@@ -70,6 +70,7 @@ store.register_group(true, "clippy::style", Some("clippy_style"), vec![
     LintId::of(methods::MANUAL_SATURATING_ARITHMETIC),
     LintId::of(methods::MAP_CLONE),
     LintId::of(methods::MAP_COLLECT_RESULT_UNIT),
+    LintId::of(methods::MUT_MUTEX_LOCK),
     LintId::of(methods::NEW_RET_NO_SELF),
     LintId::of(methods::OBFUSCATED_IF_ELSE),
     LintId::of(methods::OK_EXPECT),
@@ -89,7 +90,6 @@ store.register_group(true, "clippy::style", Some("clippy_style"), vec![
     LintId::of(misc_early::DUPLICATE_UNDERSCORE_ARGUMENT),
     LintId::of(misc_early::MIXED_CASE_HEX_LITERALS),
     LintId::of(misc_early::REDUNDANT_PATTERN),
-    LintId::of(mut_mutex_lock::MUT_MUTEX_LOCK),
     LintId::of(mut_reference::UNNECESSARY_MUT_PASSED),
     LintId::of(needless_late_init::NEEDLESS_LATE_INIT),
     LintId::of(needless_parens_on_range_literals::NEEDLESS_PARENS_ON_RANGE_LITERALS),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 179d630089f..9f6ea1266d5 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -291,7 +291,6 @@ mod mixed_read_write_in_expression;
 mod module_style;
 mod mut_key;
 mod mut_mut;
-mod mut_mutex_lock;
 mod mut_reference;
 mod mutable_debug_assertion;
 mod mutex_atomic;
@@ -815,7 +814,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(if_let_mutex::IfLetMutex));
     store.register_late_pass(|| Box::new(if_not_else::IfNotElse));
     store.register_late_pass(|| Box::new(equatable_if_let::PatternEquality));
-    store.register_late_pass(|| Box::new(mut_mutex_lock::MutMutexLock));
     store.register_late_pass(|| Box::new(manual_async_fn::ManualAsyncFn));
     store.register_late_pass(|| Box::new(vec_resize_to_zero::VecResizeToZero));
     store.register_late_pass(|| Box::new(panic_in_result_fn::PanicInResultFn));
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index e327bdcf578..6ad32ae09d7 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -51,6 +51,7 @@ mod map_err_ignore;
 mod map_flatten;
 mod map_identity;
 mod map_unwrap_or;
+mod mut_mutex_lock;
 mod needless_option_as_deref;
 mod needless_option_take;
 mod no_effect_replace;
@@ -2642,6 +2643,42 @@ declare_clippy_lint! {
     "`map_err` should not ignore the original error"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `&mut Mutex::lock` calls
+    ///
+    /// ### Why is this bad?
+    /// `Mutex::lock` is less efficient than
+    /// calling `Mutex::get_mut`. In addition you also have a statically
+    /// guarantee that the mutex isn't locked, instead of just a runtime
+    /// guarantee.
+    ///
+    /// ### Example
+    /// ```rust
+    /// use std::sync::{Arc, Mutex};
+    ///
+    /// let mut value_rc = Arc::new(Mutex::new(42_u8));
+    /// let value_mutex = Arc::get_mut(&mut value_rc).unwrap();
+    ///
+    /// let mut value = value_mutex.lock().unwrap();
+    /// *value += 1;
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// use std::sync::{Arc, Mutex};
+    ///
+    /// let mut value_rc = Arc::new(Mutex::new(42_u8));
+    /// let value_mutex = Arc::get_mut(&mut value_rc).unwrap();
+    ///
+    /// let value = value_mutex.get_mut().unwrap();
+    /// *value += 1;
+    /// ```
+    #[clippy::version = "1.49.0"]
+    pub MUT_MUTEX_LOCK,
+    style,
+    "`&mut Mutex::lock` does unnecessary locking"
+}
+
 pub struct Methods {
     avoid_breaking_exported_api: bool,
     msrv: Option<RustcVersion>,
@@ -2753,6 +2790,7 @@ impl_lint_pass!(Methods => [
     MANUAL_OK_OR,
     MAP_CLONE,
     MAP_ERR_IGNORE,
+    MUT_MUTEX_LOCK,
 ]);
 
 /// Extracts a method call name, args, and `Span` of the method name.
@@ -3081,6 +3119,9 @@ impl Methods {
                         }
                     }
                 },
+                ("lock", []) => {
+                    mut_mutex_lock::check(cx, expr, recv, span);
+                },
                 (name @ ("map" | "map_err"), [m_arg]) => {
                     if name == "map" {
                         map_clone::check(cx, expr, recv, m_arg, self.msrv);
diff --git a/clippy_lints/src/methods/mut_mutex_lock.rs b/clippy_lints/src/methods/mut_mutex_lock.rs
new file mode 100644
index 00000000000..bd8458a222e
--- /dev/null
+++ b/clippy_lints/src/methods/mut_mutex_lock.rs
@@ -0,0 +1,30 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::ty::is_type_diagnostic_item;
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, Mutability};
+use rustc_lint::LateContext;
+use rustc_middle::ty;
+use rustc_span::{sym, Span};
+
+use super::MUT_MUTEX_LOCK;
+
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, ex: &'tcx Expr<'tcx>, recv: &'tcx Expr<'tcx>, name_span: Span) {
+    if_chain! {
+        if let ty::Ref(_, _, Mutability::Mut) = cx.typeck_results().expr_ty(recv).kind();
+        if let Some(method_id) = cx.typeck_results().type_dependent_def_id(ex.hir_id);
+        if let Some(impl_id) = cx.tcx.impl_of_method(method_id);
+        if is_type_diagnostic_item(cx, cx.tcx.type_of(impl_id), sym::Mutex);
+        then {
+            span_lint_and_sugg(
+                cx,
+                MUT_MUTEX_LOCK,
+                name_span,
+                "calling `&mut Mutex::lock` unnecessarily locks an exclusive (mutable) reference",
+                "change this to",
+                "get_mut".to_owned(),
+                Applicability::MaybeIncorrect,
+            );
+        }
+    }
+}
diff --git a/clippy_lints/src/mut_mutex_lock.rs b/clippy_lints/src/mut_mutex_lock.rs
deleted file mode 100644
index b7f981faa2d..00000000000
--- a/clippy_lints/src/mut_mutex_lock.rs
+++ /dev/null
@@ -1,70 +0,0 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::ty::is_type_diagnostic_item;
-use if_chain::if_chain;
-use rustc_errors::Applicability;
-use rustc_hir::{Expr, ExprKind, Mutability};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::sym;
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for `&mut Mutex::lock` calls
-    ///
-    /// ### Why is this bad?
-    /// `Mutex::lock` is less efficient than
-    /// calling `Mutex::get_mut`. In addition you also have a statically
-    /// guarantee that the mutex isn't locked, instead of just a runtime
-    /// guarantee.
-    ///
-    /// ### Example
-    /// ```rust
-    /// use std::sync::{Arc, Mutex};
-    ///
-    /// let mut value_rc = Arc::new(Mutex::new(42_u8));
-    /// let value_mutex = Arc::get_mut(&mut value_rc).unwrap();
-    ///
-    /// let mut value = value_mutex.lock().unwrap();
-    /// *value += 1;
-    /// ```
-    /// Use instead:
-    /// ```rust
-    /// use std::sync::{Arc, Mutex};
-    ///
-    /// let mut value_rc = Arc::new(Mutex::new(42_u8));
-    /// let value_mutex = Arc::get_mut(&mut value_rc).unwrap();
-    ///
-    /// let value = value_mutex.get_mut().unwrap();
-    /// *value += 1;
-    /// ```
-    #[clippy::version = "1.49.0"]
-    pub MUT_MUTEX_LOCK,
-    style,
-    "`&mut Mutex::lock` does unnecessary locking"
-}
-
-declare_lint_pass!(MutMutexLock => [MUT_MUTEX_LOCK]);
-
-impl<'tcx> LateLintPass<'tcx> for MutMutexLock {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, ex: &'tcx Expr<'tcx>) {
-        if_chain! {
-            if let ExprKind::MethodCall(path, [self_arg, ..], _) = &ex.kind;
-            if path.ident.name == sym!(lock);
-            let ty = cx.typeck_results().expr_ty(self_arg);
-            if let ty::Ref(_, inner_ty, Mutability::Mut) = ty.kind();
-            if is_type_diagnostic_item(cx, *inner_ty, sym::Mutex);
-            then {
-                span_lint_and_sugg(
-                    cx,
-                    MUT_MUTEX_LOCK,
-                    path.ident.span,
-                    "calling `&mut Mutex::lock` unnecessarily locks an exclusive (mutable) reference",
-                    "change this to",
-                    "get_mut".to_owned(),
-                    Applicability::MaybeIncorrect,
-                );
-            }
-        }
-    }
-}
-- 
cgit 1.4.1-3-g733a5


From 0cc01cef304838cf4911d2e0e8dee7842a4b645b Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sun, 5 Jun 2022 20:09:55 -0400
Subject: Move `OpenOptions` into `Methods` lint pass

---
 clippy_lints/src/lib.register_all.rs         |   2 +-
 clippy_lints/src/lib.register_correctness.rs |   2 +-
 clippy_lints/src/lib.register_lints.rs       |   2 +-
 clippy_lints/src/lib.rs                      |   2 -
 clippy_lints/src/methods/mod.rs              |  26 ++++
 clippy_lints/src/methods/open_options.rs     | 178 +++++++++++++++++++++++
 clippy_lints/src/open_options.rs             | 202 ---------------------------
 7 files changed, 207 insertions(+), 207 deletions(-)
 create mode 100644 clippy_lints/src/methods/open_options.rs
 delete mode 100644 clippy_lints/src/open_options.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 1151cd42e59..9f4d5b728a4 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -187,6 +187,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(methods::NEEDLESS_OPTION_TAKE),
     LintId::of(methods::NEEDLESS_SPLITN),
     LintId::of(methods::NEW_RET_NO_SELF),
+    LintId::of(methods::NONSENSICAL_OPEN_OPTIONS),
     LintId::of(methods::NO_EFFECT_REPLACE),
     LintId::of(methods::OBFUSCATED_IF_ELSE),
     LintId::of(methods::OK_EXPECT),
@@ -246,7 +247,6 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(non_expressive_names::JUST_UNDERSCORES_AND_DIGITS),
     LintId::of(non_octal_unix_permissions::NON_OCTAL_UNIX_PERMISSIONS),
     LintId::of(octal_escapes::OCTAL_ESCAPES),
-    LintId::of(open_options::NONSENSICAL_OPEN_OPTIONS),
     LintId::of(operators::ABSURD_EXTREME_COMPARISONS),
     LintId::of(operators::ASSIGN_OP_PATTERN),
     LintId::of(operators::BAD_BIT_MASK),
diff --git a/clippy_lints/src/lib.register_correctness.rs b/clippy_lints/src/lib.register_correctness.rs
index 006275d1383..8ba39cc973e 100644
--- a/clippy_lints/src/lib.register_correctness.rs
+++ b/clippy_lints/src/lib.register_correctness.rs
@@ -39,12 +39,12 @@ store.register_group(true, "clippy::correctness", Some("clippy_correctness"), ve
     LintId::of(mem_replace::MEM_REPLACE_WITH_UNINIT),
     LintId::of(methods::CLONE_DOUBLE_REF),
     LintId::of(methods::ITERATOR_STEP_BY_ZERO),
+    LintId::of(methods::NONSENSICAL_OPEN_OPTIONS),
     LintId::of(methods::SUSPICIOUS_SPLITN),
     LintId::of(methods::UNINIT_ASSUMED_INIT),
     LintId::of(methods::ZST_OFFSET),
     LintId::of(minmax::MIN_MAX),
     LintId::of(non_octal_unix_permissions::NON_OCTAL_UNIX_PERMISSIONS),
-    LintId::of(open_options::NONSENSICAL_OPEN_OPTIONS),
     LintId::of(operators::ABSURD_EXTREME_COMPARISONS),
     LintId::of(operators::BAD_BIT_MASK),
     LintId::of(operators::CMP_NAN),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 2ae93b49737..cf58d1bc518 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -335,6 +335,7 @@ store.register_lints(&[
     methods::NEEDLESS_OPTION_TAKE,
     methods::NEEDLESS_SPLITN,
     methods::NEW_RET_NO_SELF,
+    methods::NONSENSICAL_OPEN_OPTIONS,
     methods::NO_EFFECT_REPLACE,
     methods::OBFUSCATED_IF_ELSE,
     methods::OK_EXPECT,
@@ -421,7 +422,6 @@ store.register_lints(&[
     nonstandard_macro_braces::NONSTANDARD_MACRO_BRACES,
     octal_escapes::OCTAL_ESCAPES,
     only_used_in_recursion::ONLY_USED_IN_RECURSION,
-    open_options::NONSENSICAL_OPEN_OPTIONS,
     operators::ABSURD_EXTREME_COMPARISONS,
     operators::ARITHMETIC,
     operators::ASSIGN_OP_PATTERN,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 9f6ea1266d5..0d2cc07504a 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -315,7 +315,6 @@ mod non_send_fields_in_send_ty;
 mod nonstandard_macro_braces;
 mod octal_escapes;
 mod only_used_in_recursion;
-mod open_options;
 mod operators;
 mod option_env_unwrap;
 mod option_if_let_else;
@@ -641,7 +640,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(lifetimes::Lifetimes));
     store.register_late_pass(|| Box::new(entry::HashMapPass));
     store.register_late_pass(|| Box::new(minmax::MinMaxPass));
-    store.register_late_pass(|| Box::new(open_options::OpenOptions));
     store.register_late_pass(|| Box::new(zero_div_zero::ZeroDiv));
     store.register_late_pass(|| Box::new(mutex_atomic::Mutex));
     store.register_late_pass(|| Box::new(needless_update::NeedlessUpdate));
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 6ad32ae09d7..3532aa17afd 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -57,6 +57,7 @@ mod needless_option_take;
 mod no_effect_replace;
 mod obfuscated_if_else;
 mod ok_expect;
+mod open_options;
 mod option_as_ref_deref;
 mod option_map_or_none;
 mod option_map_unwrap_or;
@@ -2679,6 +2680,27 @@ declare_clippy_lint! {
     "`&mut Mutex::lock` does unnecessary locking"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for duplicate open options as well as combinations
+    /// that make no sense.
+    ///
+    /// ### Why is this bad?
+    /// In the best case, the code will be harder to read than
+    /// necessary. I don't know the worst case.
+    ///
+    /// ### Example
+    /// ```rust
+    /// use std::fs::OpenOptions;
+    ///
+    /// OpenOptions::new().read(true).truncate(true);
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub NONSENSICAL_OPEN_OPTIONS,
+    correctness,
+    "nonsensical combination of options for opening a file"
+}
+
 pub struct Methods {
     avoid_breaking_exported_api: bool,
     msrv: Option<RustcVersion>,
@@ -2791,6 +2813,7 @@ impl_lint_pass!(Methods => [
     MAP_CLONE,
     MAP_ERR_IGNORE,
     MUT_MUTEX_LOCK,
+    NONSENSICAL_OPEN_OPTIONS,
 ]);
 
 /// Extracts a method call name, args, and `Span` of the method name.
@@ -3168,6 +3191,9 @@ impl Methods {
                     _ => iter_nth_zero::check(cx, expr, recv, n_arg),
                 },
                 ("ok_or_else", [arg]) => unnecessary_lazy_eval::check(cx, expr, recv, arg, "ok_or"),
+                ("open", [_]) => {
+                    open_options::check(cx, expr, recv);
+                },
                 ("or_else", [arg]) => {
                     if !bind_instead_of_map::ResultOrElseErrInfo::check(cx, expr, recv, arg) {
                         unnecessary_lazy_eval::check(cx, expr, recv, arg, "or");
diff --git a/clippy_lints/src/methods/open_options.rs b/clippy_lints/src/methods/open_options.rs
new file mode 100644
index 00000000000..c3112823e34
--- /dev/null
+++ b/clippy_lints/src/methods/open_options.rs
@@ -0,0 +1,178 @@
+use clippy_utils::diagnostics::span_lint;
+use clippy_utils::paths;
+use clippy_utils::ty::match_type;
+use rustc_ast::ast::LitKind;
+use rustc_hir::{Expr, ExprKind};
+use rustc_lint::LateContext;
+use rustc_span::source_map::{Span, Spanned};
+
+use super::NONSENSICAL_OPEN_OPTIONS;
+
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>, recv: &'tcx Expr<'_>) {
+    if let Some(method_id) = cx.typeck_results().type_dependent_def_id(e.hir_id)
+        && let Some(impl_id) = cx.tcx.impl_of_method(method_id)
+        && match_type(cx, cx.tcx.type_of(impl_id), &paths::OPEN_OPTIONS)
+    {
+        let mut options = Vec::new();
+        get_open_options(cx, recv, &mut options);
+        check_open_options(cx, &options, e.span);
+    }
+}
+
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+enum Argument {
+    True,
+    False,
+    Unknown,
+}
+
+#[derive(Debug)]
+enum OpenOption {
+    Write,
+    Read,
+    Truncate,
+    Create,
+    Append,
+}
+
+fn get_open_options(cx: &LateContext<'_>, argument: &Expr<'_>, options: &mut Vec<(OpenOption, Argument)>) {
+    if let ExprKind::MethodCall(path, arguments, _) = argument.kind {
+        let obj_ty = cx.typeck_results().expr_ty(&arguments[0]).peel_refs();
+
+        // Only proceed if this is a call on some object of type std::fs::OpenOptions
+        if match_type(cx, obj_ty, &paths::OPEN_OPTIONS) && arguments.len() >= 2 {
+            let argument_option = match arguments[1].kind {
+                ExprKind::Lit(ref span) => {
+                    if let Spanned {
+                        node: LitKind::Bool(lit),
+                        ..
+                    } = *span
+                    {
+                        if lit { Argument::True } else { Argument::False }
+                    } else {
+                        // The function is called with a literal which is not a boolean literal.
+                        // This is theoretically possible, but not very likely.
+                        return;
+                    }
+                },
+                _ => Argument::Unknown,
+            };
+
+            match path.ident.as_str() {
+                "create" => {
+                    options.push((OpenOption::Create, argument_option));
+                },
+                "append" => {
+                    options.push((OpenOption::Append, argument_option));
+                },
+                "truncate" => {
+                    options.push((OpenOption::Truncate, argument_option));
+                },
+                "read" => {
+                    options.push((OpenOption::Read, argument_option));
+                },
+                "write" => {
+                    options.push((OpenOption::Write, argument_option));
+                },
+                _ => (),
+            }
+
+            get_open_options(cx, &arguments[0], options);
+        }
+    }
+}
+
+fn check_open_options(cx: &LateContext<'_>, options: &[(OpenOption, Argument)], span: Span) {
+    let (mut create, mut append, mut truncate, mut read, mut write) = (false, false, false, false, false);
+    let (mut create_arg, mut append_arg, mut truncate_arg, mut read_arg, mut write_arg) =
+        (false, false, false, false, false);
+    // This code is almost duplicated (oh, the irony), but I haven't found a way to
+    // unify it.
+
+    for option in options {
+        match *option {
+            (OpenOption::Create, arg) => {
+                if create {
+                    span_lint(
+                        cx,
+                        NONSENSICAL_OPEN_OPTIONS,
+                        span,
+                        "the method `create` is called more than once",
+                    );
+                } else {
+                    create = true;
+                }
+                create_arg = create_arg || (arg == Argument::True);
+            },
+            (OpenOption::Append, arg) => {
+                if append {
+                    span_lint(
+                        cx,
+                        NONSENSICAL_OPEN_OPTIONS,
+                        span,
+                        "the method `append` is called more than once",
+                    );
+                } else {
+                    append = true;
+                }
+                append_arg = append_arg || (arg == Argument::True);
+            },
+            (OpenOption::Truncate, arg) => {
+                if truncate {
+                    span_lint(
+                        cx,
+                        NONSENSICAL_OPEN_OPTIONS,
+                        span,
+                        "the method `truncate` is called more than once",
+                    );
+                } else {
+                    truncate = true;
+                }
+                truncate_arg = truncate_arg || (arg == Argument::True);
+            },
+            (OpenOption::Read, arg) => {
+                if read {
+                    span_lint(
+                        cx,
+                        NONSENSICAL_OPEN_OPTIONS,
+                        span,
+                        "the method `read` is called more than once",
+                    );
+                } else {
+                    read = true;
+                }
+                read_arg = read_arg || (arg == Argument::True);
+            },
+            (OpenOption::Write, arg) => {
+                if write {
+                    span_lint(
+                        cx,
+                        NONSENSICAL_OPEN_OPTIONS,
+                        span,
+                        "the method `write` is called more than once",
+                    );
+                } else {
+                    write = true;
+                }
+                write_arg = write_arg || (arg == Argument::True);
+            },
+        }
+    }
+
+    if read && truncate && read_arg && truncate_arg && !(write && write_arg) {
+        span_lint(
+            cx,
+            NONSENSICAL_OPEN_OPTIONS,
+            span,
+            "file opened with `truncate` and `read`",
+        );
+    }
+    if append && truncate && append_arg && truncate_arg {
+        span_lint(
+            cx,
+            NONSENSICAL_OPEN_OPTIONS,
+            span,
+            "file opened with `append` and `truncate`",
+        );
+    }
+}
diff --git a/clippy_lints/src/open_options.rs b/clippy_lints/src/open_options.rs
deleted file mode 100644
index 5a0b5042018..00000000000
--- a/clippy_lints/src/open_options.rs
+++ /dev/null
@@ -1,202 +0,0 @@
-use clippy_utils::diagnostics::span_lint;
-use clippy_utils::paths;
-use clippy_utils::ty::match_type;
-use rustc_ast::ast::LitKind;
-use rustc_hir::{Expr, ExprKind};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::source_map::{Span, Spanned};
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for duplicate open options as well as combinations
-    /// that make no sense.
-    ///
-    /// ### Why is this bad?
-    /// In the best case, the code will be harder to read than
-    /// necessary. I don't know the worst case.
-    ///
-    /// ### Example
-    /// ```rust
-    /// use std::fs::OpenOptions;
-    ///
-    /// OpenOptions::new().read(true).truncate(true);
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub NONSENSICAL_OPEN_OPTIONS,
-    correctness,
-    "nonsensical combination of options for opening a file"
-}
-
-declare_lint_pass!(OpenOptions => [NONSENSICAL_OPEN_OPTIONS]);
-
-impl<'tcx> LateLintPass<'tcx> for OpenOptions {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
-        if let ExprKind::MethodCall(path, [self_arg, ..], _) = &e.kind {
-            let obj_ty = cx.typeck_results().expr_ty(self_arg).peel_refs();
-            if path.ident.name == sym!(open) && match_type(cx, obj_ty, &paths::OPEN_OPTIONS) {
-                let mut options = Vec::new();
-                get_open_options(cx, self_arg, &mut options);
-                check_open_options(cx, &options, e.span);
-            }
-        }
-    }
-}
-
-#[derive(Debug, PartialEq, Eq, Clone, Copy)]
-enum Argument {
-    True,
-    False,
-    Unknown,
-}
-
-#[derive(Debug)]
-enum OpenOption {
-    Write,
-    Read,
-    Truncate,
-    Create,
-    Append,
-}
-
-fn get_open_options(cx: &LateContext<'_>, argument: &Expr<'_>, options: &mut Vec<(OpenOption, Argument)>) {
-    if let ExprKind::MethodCall(path, arguments, _) = argument.kind {
-        let obj_ty = cx.typeck_results().expr_ty(&arguments[0]).peel_refs();
-
-        // Only proceed if this is a call on some object of type std::fs::OpenOptions
-        if match_type(cx, obj_ty, &paths::OPEN_OPTIONS) && arguments.len() >= 2 {
-            let argument_option = match arguments[1].kind {
-                ExprKind::Lit(ref span) => {
-                    if let Spanned {
-                        node: LitKind::Bool(lit),
-                        ..
-                    } = *span
-                    {
-                        if lit { Argument::True } else { Argument::False }
-                    } else {
-                        // The function is called with a literal which is not a boolean literal.
-                        // This is theoretically possible, but not very likely.
-                        return;
-                    }
-                },
-                _ => Argument::Unknown,
-            };
-
-            match path.ident.as_str() {
-                "create" => {
-                    options.push((OpenOption::Create, argument_option));
-                },
-                "append" => {
-                    options.push((OpenOption::Append, argument_option));
-                },
-                "truncate" => {
-                    options.push((OpenOption::Truncate, argument_option));
-                },
-                "read" => {
-                    options.push((OpenOption::Read, argument_option));
-                },
-                "write" => {
-                    options.push((OpenOption::Write, argument_option));
-                },
-                _ => (),
-            }
-
-            get_open_options(cx, &arguments[0], options);
-        }
-    }
-}
-
-fn check_open_options(cx: &LateContext<'_>, options: &[(OpenOption, Argument)], span: Span) {
-    let (mut create, mut append, mut truncate, mut read, mut write) = (false, false, false, false, false);
-    let (mut create_arg, mut append_arg, mut truncate_arg, mut read_arg, mut write_arg) =
-        (false, false, false, false, false);
-    // This code is almost duplicated (oh, the irony), but I haven't found a way to
-    // unify it.
-
-    for option in options {
-        match *option {
-            (OpenOption::Create, arg) => {
-                if create {
-                    span_lint(
-                        cx,
-                        NONSENSICAL_OPEN_OPTIONS,
-                        span,
-                        "the method `create` is called more than once",
-                    );
-                } else {
-                    create = true;
-                }
-                create_arg = create_arg || (arg == Argument::True);
-            },
-            (OpenOption::Append, arg) => {
-                if append {
-                    span_lint(
-                        cx,
-                        NONSENSICAL_OPEN_OPTIONS,
-                        span,
-                        "the method `append` is called more than once",
-                    );
-                } else {
-                    append = true;
-                }
-                append_arg = append_arg || (arg == Argument::True);
-            },
-            (OpenOption::Truncate, arg) => {
-                if truncate {
-                    span_lint(
-                        cx,
-                        NONSENSICAL_OPEN_OPTIONS,
-                        span,
-                        "the method `truncate` is called more than once",
-                    );
-                } else {
-                    truncate = true;
-                }
-                truncate_arg = truncate_arg || (arg == Argument::True);
-            },
-            (OpenOption::Read, arg) => {
-                if read {
-                    span_lint(
-                        cx,
-                        NONSENSICAL_OPEN_OPTIONS,
-                        span,
-                        "the method `read` is called more than once",
-                    );
-                } else {
-                    read = true;
-                }
-                read_arg = read_arg || (arg == Argument::True);
-            },
-            (OpenOption::Write, arg) => {
-                if write {
-                    span_lint(
-                        cx,
-                        NONSENSICAL_OPEN_OPTIONS,
-                        span,
-                        "the method `write` is called more than once",
-                    );
-                } else {
-                    write = true;
-                }
-                write_arg = write_arg || (arg == Argument::True);
-            },
-        }
-    }
-
-    if read && truncate && read_arg && truncate_arg && !(write && write_arg) {
-        span_lint(
-            cx,
-            NONSENSICAL_OPEN_OPTIONS,
-            span,
-            "file opened with `truncate` and `read`",
-        );
-    }
-    if append && truncate && append_arg && truncate_arg {
-        span_lint(
-            cx,
-            NONSENSICAL_OPEN_OPTIONS,
-            span,
-            "file opened with `append` and `truncate`",
-        );
-    }
-}
-- 
cgit 1.4.1-3-g733a5


From 226f135a033f48178ffaa629045664a54c23aa0e Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sun, 5 Jun 2022 20:27:36 -0400
Subject: Move `PathBufPushOverwrite` into `Methods` lint group

---
 clippy_lints/src/lib.register_lints.rs             |  2 +-
 clippy_lints/src/lib.register_nursery.rs           |  2 +-
 clippy_lints/src/lib.rs                            |  2 -
 clippy_lints/src/methods/mod.rs                    | 37 +++++++++++
 .../src/methods/path_buf_push_overwrite.rs         | 37 +++++++++++
 clippy_lints/src/path_buf_push_overwrite.rs        | 72 ----------------------
 6 files changed, 76 insertions(+), 76 deletions(-)
 create mode 100644 clippy_lints/src/methods/path_buf_push_overwrite.rs
 delete mode 100644 clippy_lints/src/path_buf_push_overwrite.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index cf58d1bc518..5750f914ac5 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -344,6 +344,7 @@ store.register_lints(&[
     methods::OPTION_MAP_OR_NONE,
     methods::OR_FUN_CALL,
     methods::OR_THEN_UNWRAP,
+    methods::PATH_BUF_PUSH_OVERWRITE,
     methods::RESULT_MAP_OR_INTO_OPTION,
     methods::SEARCH_IS_SOME,
     methods::SHOULD_IMPLEMENT_TRAIT,
@@ -460,7 +461,6 @@ store.register_lints(&[
     partialeq_to_none::PARTIALEQ_TO_NONE,
     pass_by_ref_or_value::LARGE_TYPES_PASSED_BY_VALUE,
     pass_by_ref_or_value::TRIVIALLY_COPY_PASS_BY_REF,
-    path_buf_push_overwrite::PATH_BUF_PUSH_OVERWRITE,
     pattern_type_mismatch::PATTERN_TYPE_MISMATCH,
     precedence::PRECEDENCE,
     ptr::CMP_NULL,
diff --git a/clippy_lints/src/lib.register_nursery.rs b/clippy_lints/src/lib.register_nursery.rs
index d6590192655..dc50816452f 100644
--- a/clippy_lints/src/lib.register_nursery.rs
+++ b/clippy_lints/src/lib.register_nursery.rs
@@ -17,6 +17,7 @@ store.register_group(true, "clippy::nursery", Some("clippy_nursery"), vec![
     LintId::of(methods::ITER_ON_EMPTY_COLLECTIONS),
     LintId::of(methods::ITER_ON_SINGLE_ITEMS),
     LintId::of(methods::ITER_WITH_DRAIN),
+    LintId::of(methods::PATH_BUF_PUSH_OVERWRITE),
     LintId::of(missing_const_for_fn::MISSING_CONST_FOR_FN),
     LintId::of(mutable_debug_assertion::DEBUG_ASSERT_WITH_MUT_CALL),
     LintId::of(mutex_atomic::MUTEX_ATOMIC),
@@ -25,7 +26,6 @@ store.register_group(true, "clippy::nursery", Some("clippy_nursery"), vec![
     LintId::of(nonstandard_macro_braces::NONSTANDARD_MACRO_BRACES),
     LintId::of(only_used_in_recursion::ONLY_USED_IN_RECURSION),
     LintId::of(option_if_let_else::OPTION_IF_LET_ELSE),
-    LintId::of(path_buf_push_overwrite::PATH_BUF_PUSH_OVERWRITE),
     LintId::of(redundant_pub_crate::REDUNDANT_PUB_CRATE),
     LintId::of(regex::TRIVIAL_REGEX),
     LintId::of(strings::STRING_LIT_AS_BYTES),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 0d2cc07504a..44cfe0d00ec 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -324,7 +324,6 @@ mod panic_unimplemented;
 mod partialeq_ne_impl;
 mod partialeq_to_none;
 mod pass_by_ref_or_value;
-mod path_buf_push_overwrite;
 mod pattern_type_mismatch;
 mod precedence;
 mod ptr;
@@ -727,7 +726,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(assertions_on_constants::AssertionsOnConstants));
     store.register_late_pass(|| Box::new(assertions_on_result_states::AssertionsOnResultStates));
     store.register_late_pass(|| Box::new(transmuting_null::TransmutingNull));
-    store.register_late_pass(|| Box::new(path_buf_push_overwrite::PathBufPushOverwrite));
     store.register_late_pass(|| Box::new(inherent_to_string::InherentToString));
     let max_trait_bounds = conf.max_trait_bounds;
     store.register_late_pass(move || Box::new(trait_bounds::TraitBounds::new(max_trait_bounds)));
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 3532aa17afd..545cf7918af 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -63,6 +63,7 @@ mod option_map_or_none;
 mod option_map_unwrap_or;
 mod or_fun_call;
 mod or_then_unwrap;
+mod path_buf_push_overwrite;
 mod search_is_some;
 mod single_char_add_str;
 mod single_char_insert_string;
@@ -2701,6 +2702,38 @@ declare_clippy_lint! {
     "nonsensical combination of options for opening a file"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    ///* Checks for [push](https://doc.rust-lang.org/std/path/struct.PathBuf.html#method.push)
+    /// calls on `PathBuf` that can cause overwrites.
+    ///
+    /// ### Why is this bad?
+    /// Calling `push` with a root path at the start can overwrite the
+    /// previous defined path.
+    ///
+    /// ### Example
+    /// ```rust
+    /// use std::path::PathBuf;
+    ///
+    /// let mut x = PathBuf::from("/foo");
+    /// x.push("/bar");
+    /// assert_eq!(x, PathBuf::from("/bar"));
+    /// ```
+    /// Could be written:
+    ///
+    /// ```rust
+    /// use std::path::PathBuf;
+    ///
+    /// let mut x = PathBuf::from("/foo");
+    /// x.push("bar");
+    /// assert_eq!(x, PathBuf::from("/foo/bar"));
+    /// ```
+    #[clippy::version = "1.36.0"]
+    pub PATH_BUF_PUSH_OVERWRITE,
+    nursery,
+    "calling `push` with file system root on `PathBuf` can overwrite it"
+}
+
 pub struct Methods {
     avoid_breaking_exported_api: bool,
     msrv: Option<RustcVersion>,
@@ -2814,6 +2847,7 @@ impl_lint_pass!(Methods => [
     MAP_ERR_IGNORE,
     MUT_MUTEX_LOCK,
     NONSENSICAL_OPEN_OPTIONS,
+    PATH_BUF_PUSH_OVERWRITE,
 ]);
 
 /// Extracts a method call name, args, and `Span` of the method name.
@@ -3199,6 +3233,9 @@ impl Methods {
                         unnecessary_lazy_eval::check(cx, expr, recv, arg, "or");
                     }
                 },
+                ("push", [arg]) => {
+                    path_buf_push_overwrite::check(cx, expr, arg);
+                },
                 ("splitn" | "rsplitn", [count_arg, pat_arg]) => {
                     if let Some((Constant::Int(count), _)) = constant(cx, cx.typeck_results(), count_arg) {
                         suspicious_splitn::check(cx, name, expr, recv, count);
diff --git a/clippy_lints/src/methods/path_buf_push_overwrite.rs b/clippy_lints/src/methods/path_buf_push_overwrite.rs
new file mode 100644
index 00000000000..0cc28c0dcb3
--- /dev/null
+++ b/clippy_lints/src/methods/path_buf_push_overwrite.rs
@@ -0,0 +1,37 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::ty::is_type_diagnostic_item;
+use if_chain::if_chain;
+use rustc_ast::ast::LitKind;
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind};
+use rustc_lint::LateContext;
+use rustc_span::symbol::sym;
+use std::path::{Component, Path};
+
+use super::PATH_BUF_PUSH_OVERWRITE;
+
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, arg: &'tcx Expr<'_>) {
+    if_chain! {
+        if let Some(method_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
+        if let Some(impl_id) = cx.tcx.impl_of_method(method_id);
+        if is_type_diagnostic_item(cx, cx.tcx.type_of(impl_id), sym::PathBuf);
+        if let ExprKind::Lit(ref lit) = arg.kind;
+        if let LitKind::Str(ref path_lit, _) = lit.node;
+        if let pushed_path = Path::new(path_lit.as_str());
+        if let Some(pushed_path_lit) = pushed_path.to_str();
+        if pushed_path.has_root();
+        if let Some(root) = pushed_path.components().next();
+        if root == Component::RootDir;
+        then {
+            span_lint_and_sugg(
+                cx,
+                PATH_BUF_PUSH_OVERWRITE,
+                lit.span,
+                "calling `push` with '/' or '\\' (file system root) will overwrite the previous path definition",
+                "try",
+                format!("\"{}\"", pushed_path_lit.trim_start_matches(|c| c == '/' || c == '\\')),
+                Applicability::MachineApplicable,
+            );
+        }
+    }
+}
diff --git a/clippy_lints/src/path_buf_push_overwrite.rs b/clippy_lints/src/path_buf_push_overwrite.rs
deleted file mode 100644
index bc6a918f703..00000000000
--- a/clippy_lints/src/path_buf_push_overwrite.rs
+++ /dev/null
@@ -1,72 +0,0 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::ty::is_type_diagnostic_item;
-use if_chain::if_chain;
-use rustc_ast::ast::LitKind;
-use rustc_errors::Applicability;
-use rustc_hir::{Expr, ExprKind};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::symbol::sym;
-use std::path::{Component, Path};
-
-declare_clippy_lint! {
-    /// ### What it does
-    ///* Checks for [push](https://doc.rust-lang.org/std/path/struct.PathBuf.html#method.push)
-    /// calls on `PathBuf` that can cause overwrites.
-    ///
-    /// ### Why is this bad?
-    /// Calling `push` with a root path at the start can overwrite the
-    /// previous defined path.
-    ///
-    /// ### Example
-    /// ```rust
-    /// use std::path::PathBuf;
-    ///
-    /// let mut x = PathBuf::from("/foo");
-    /// x.push("/bar");
-    /// assert_eq!(x, PathBuf::from("/bar"));
-    /// ```
-    /// Could be written:
-    ///
-    /// ```rust
-    /// use std::path::PathBuf;
-    ///
-    /// let mut x = PathBuf::from("/foo");
-    /// x.push("bar");
-    /// assert_eq!(x, PathBuf::from("/foo/bar"));
-    /// ```
-    #[clippy::version = "1.36.0"]
-    pub PATH_BUF_PUSH_OVERWRITE,
-    nursery,
-    "calling `push` with file system root on `PathBuf` can overwrite it"
-}
-
-declare_lint_pass!(PathBufPushOverwrite => [PATH_BUF_PUSH_OVERWRITE]);
-
-impl<'tcx> LateLintPass<'tcx> for PathBufPushOverwrite {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if_chain! {
-            if let ExprKind::MethodCall(path, [recv, get_index_arg], _) = expr.kind;
-            if path.ident.name == sym!(push);
-            if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(recv).peel_refs(), sym::PathBuf);
-            if let ExprKind::Lit(ref lit) = get_index_arg.kind;
-            if let LitKind::Str(ref path_lit, _) = lit.node;
-            if let pushed_path = Path::new(path_lit.as_str());
-            if let Some(pushed_path_lit) = pushed_path.to_str();
-            if pushed_path.has_root();
-            if let Some(root) = pushed_path.components().next();
-            if root == Component::RootDir;
-            then {
-                span_lint_and_sugg(
-                    cx,
-                    PATH_BUF_PUSH_OVERWRITE,
-                    lit.span,
-                    "calling `push` with '/' or '\\' (file system root) will overwrite the previous path definition",
-                    "try",
-                    format!("\"{}\"", pushed_path_lit.trim_start_matches(|c| c == '/' || c == '\\')),
-                    Applicability::MachineApplicable,
-                );
-            }
-        }
-    }
-}
-- 
cgit 1.4.1-3-g733a5


From fd5376194a4b74021ef01b7f2c96898ea204b75d Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sun, 5 Jun 2022 20:39:57 -0400
Subject: Move `range_zip_with_len` into `Methods` lint pass

---
 clippy_lints/src/lib.register_all.rs           |  2 +-
 clippy_lints/src/lib.register_complexity.rs    |  2 +-
 clippy_lints/src/lib.register_lints.rs         |  2 +-
 clippy_lints/src/methods/mod.rs                | 34 ++++++++++++
 clippy_lints/src/methods/range_zip_with_len.rs | 34 ++++++++++++
 clippy_lints/src/ranges.rs                     | 73 +++-----------------------
 6 files changed, 77 insertions(+), 70 deletions(-)
 create mode 100644 clippy_lints/src/methods/range_zip_with_len.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 9f4d5b728a4..d2c8c44b14f 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -196,6 +196,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(methods::OPTION_MAP_OR_NONE),
     LintId::of(methods::OR_FUN_CALL),
     LintId::of(methods::OR_THEN_UNWRAP),
+    LintId::of(methods::RANGE_ZIP_WITH_LEN),
     LintId::of(methods::RESULT_MAP_OR_INTO_OPTION),
     LintId::of(methods::SEARCH_IS_SOME),
     LintId::of(methods::SHOULD_IMPLEMENT_TRAIT),
@@ -276,7 +277,6 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(ptr_offset_with_cast::PTR_OFFSET_WITH_CAST),
     LintId::of(question_mark::QUESTION_MARK),
     LintId::of(ranges::MANUAL_RANGE_CONTAINS),
-    LintId::of(ranges::RANGE_ZIP_WITH_LEN),
     LintId::of(ranges::REVERSED_EMPTY_RANGES),
     LintId::of(rc_clone_in_vec_init::RC_CLONE_IN_VEC_INIT),
     LintId::of(read_zero_byte_vec::READ_ZERO_BYTE_VEC),
diff --git a/clippy_lints/src/lib.register_complexity.rs b/clippy_lints/src/lib.register_complexity.rs
index 324b380317f..f77483de4e4 100644
--- a/clippy_lints/src/lib.register_complexity.rs
+++ b/clippy_lints/src/lib.register_complexity.rs
@@ -51,6 +51,7 @@ store.register_group(true, "clippy::complexity", Some("clippy_complexity"), vec!
     LintId::of(methods::OPTION_AS_REF_DEREF),
     LintId::of(methods::OPTION_FILTER_MAP),
     LintId::of(methods::OR_THEN_UNWRAP),
+    LintId::of(methods::RANGE_ZIP_WITH_LEN),
     LintId::of(methods::SEARCH_IS_SOME),
     LintId::of(methods::SKIP_WHILE_NEXT),
     LintId::of(methods::UNNECESSARY_FILTER_MAP),
@@ -76,7 +77,6 @@ store.register_group(true, "clippy::complexity", Some("clippy_complexity"), vec!
     LintId::of(partialeq_ne_impl::PARTIALEQ_NE_IMPL),
     LintId::of(precedence::PRECEDENCE),
     LintId::of(ptr_offset_with_cast::PTR_OFFSET_WITH_CAST),
-    LintId::of(ranges::RANGE_ZIP_WITH_LEN),
     LintId::of(redundant_closure_call::REDUNDANT_CLOSURE_CALL),
     LintId::of(redundant_slicing::REDUNDANT_SLICING),
     LintId::of(reference::DEREF_ADDROF),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 5750f914ac5..2e48e344955 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -345,6 +345,7 @@ store.register_lints(&[
     methods::OR_FUN_CALL,
     methods::OR_THEN_UNWRAP,
     methods::PATH_BUF_PUSH_OVERWRITE,
+    methods::RANGE_ZIP_WITH_LEN,
     methods::RESULT_MAP_OR_INTO_OPTION,
     methods::SEARCH_IS_SOME,
     methods::SHOULD_IMPLEMENT_TRAIT,
@@ -473,7 +474,6 @@ store.register_lints(&[
     ranges::MANUAL_RANGE_CONTAINS,
     ranges::RANGE_MINUS_ONE,
     ranges::RANGE_PLUS_ONE,
-    ranges::RANGE_ZIP_WITH_LEN,
     ranges::REVERSED_EMPTY_RANGES,
     rc_clone_in_vec_init::RC_CLONE_IN_VEC_INIT,
     read_zero_byte_vec::READ_ZERO_BYTE_VEC,
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 545cf7918af..4a768117296 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -64,6 +64,7 @@ mod option_map_unwrap_or;
 mod or_fun_call;
 mod or_then_unwrap;
 mod path_buf_push_overwrite;
+mod range_zip_with_len;
 mod search_is_some;
 mod single_char_add_str;
 mod single_char_insert_string;
@@ -2734,6 +2735,31 @@ declare_clippy_lint! {
     "calling `push` with file system root on `PathBuf` can overwrite it"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for zipping a collection with the range of
+    /// `0.._.len()`.
+    ///
+    /// ### Why is this bad?
+    /// The code is better expressed with `.enumerate()`.
+    ///
+    /// ### Example
+    /// ```rust
+    /// # let x = vec![1];
+    /// let _ = x.iter().zip(0..x.len());
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust
+    /// # let x = vec![1];
+    /// let _ = x.iter().enumerate();
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub RANGE_ZIP_WITH_LEN,
+    complexity,
+    "zipping iterator with a range when `enumerate()` would do"
+}
+
 pub struct Methods {
     avoid_breaking_exported_api: bool,
     msrv: Option<RustcVersion>,
@@ -2848,6 +2874,7 @@ impl_lint_pass!(Methods => [
     MUT_MUTEX_LOCK,
     NONSENSICAL_OPEN_OPTIONS,
     PATH_BUF_PUSH_OVERWRITE,
+    RANGE_ZIP_WITH_LEN,
 ]);
 
 /// Extracts a method call name, args, and `Span` of the method name.
@@ -3304,6 +3331,13 @@ impl Methods {
                 ("replace" | "replacen", [arg1, arg2] | [arg1, arg2, _]) => {
                     no_effect_replace::check(cx, expr, arg1, arg2);
                 },
+                ("zip", [arg]) => {
+                    if let ExprKind::MethodCall(name, [iter_recv], _) = recv.kind
+                        && name.ident.name == sym::iter
+                    {
+                        range_zip_with_len::check(cx, expr, iter_recv, arg);
+                    }
+                },
                 _ => {},
             }
         }
diff --git a/clippy_lints/src/methods/range_zip_with_len.rs b/clippy_lints/src/methods/range_zip_with_len.rs
new file mode 100644
index 00000000000..00a2a0d14d1
--- /dev/null
+++ b/clippy_lints/src/methods/range_zip_with_len.rs
@@ -0,0 +1,34 @@
+use clippy_utils::diagnostics::span_lint;
+use clippy_utils::source::snippet;
+use clippy_utils::{higher, SpanlessEq};
+use clippy_utils::{is_integer_const, is_trait_method};
+use if_chain::if_chain;
+use rustc_hir::{Expr, ExprKind, QPath};
+use rustc_lint::LateContext;
+use rustc_span::sym;
+
+use super::RANGE_ZIP_WITH_LEN;
+
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, recv: &'tcx Expr<'_>, zip_arg: &'tcx Expr<'_>) {
+    if_chain! {
+        if is_trait_method(cx, expr, sym::Iterator);
+        // range expression in `.zip()` call: `0..x.len()`
+        if let Some(higher::Range { start: Some(start), end: Some(end), .. }) = higher::Range::hir(zip_arg);
+        if is_integer_const(cx, start, 0);
+        // `.len()` call
+        if let ExprKind::MethodCall(len_path, [len_recv], _) = end.kind;
+        if len_path.ident.name == sym::len;
+        // `.iter()` and `.len()` called on same `Path`
+        if let ExprKind::Path(QPath::Resolved(_, iter_path)) = recv.kind;
+        if let ExprKind::Path(QPath::Resolved(_, len_path)) = len_recv.kind;
+        if SpanlessEq::new(cx).eq_path_segments(iter_path.segments, len_path.segments);
+        then {
+            span_lint(cx,
+                RANGE_ZIP_WITH_LEN,
+                expr.span,
+                &format!("it is more idiomatic to use `{}.iter().enumerate()`",
+                    snippet(cx, recv.span, "_"))
+            );
+        }
+    }
+}
diff --git a/clippy_lints/src/ranges.rs b/clippy_lints/src/ranges.rs
index fbf842c339e..490f345d297 100644
--- a/clippy_lints/src/ranges.rs
+++ b/clippy_lints/src/ranges.rs
@@ -1,46 +1,20 @@
 use clippy_utils::consts::{constant, Constant};
 use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg, span_lint_and_then};
+use clippy_utils::higher;
 use clippy_utils::source::{snippet, snippet_opt, snippet_with_applicability};
 use clippy_utils::sugg::Sugg;
 use clippy_utils::{get_parent_expr, in_constant, is_integer_const, meets_msrv, msrvs, path_to_local};
-use clippy_utils::{higher, SpanlessEq};
 use if_chain::if_chain;
 use rustc_ast::ast::RangeLimits;
 use rustc_errors::Applicability;
-use rustc_hir::{BinOpKind, Expr, ExprKind, HirId, PathSegment, QPath};
+use rustc_hir::{BinOpKind, Expr, ExprKind, HirId};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
 use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::{Span, Spanned};
-use rustc_span::sym;
 use std::cmp::Ordering;
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for zipping a collection with the range of
-    /// `0.._.len()`.
-    ///
-    /// ### Why is this bad?
-    /// The code is better expressed with `.enumerate()`.
-    ///
-    /// ### Example
-    /// ```rust
-    /// # let x = vec![1];
-    /// let _ = x.iter().zip(0..x.len());
-    /// ```
-    ///
-    /// Use instead:
-    /// ```rust
-    /// # let x = vec![1];
-    /// let _ = x.iter().enumerate();
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub RANGE_ZIP_WITH_LEN,
-    complexity,
-    "zipping iterator with a range when `enumerate()` would do"
-}
-
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for exclusive ranges where 1 is added to the
@@ -198,7 +172,6 @@ impl Ranges {
 }
 
 impl_lint_pass!(Ranges => [
-    RANGE_ZIP_WITH_LEN,
     RANGE_PLUS_ONE,
     RANGE_MINUS_ONE,
     REVERSED_EMPTY_RANGES,
@@ -207,16 +180,10 @@ impl_lint_pass!(Ranges => [
 
 impl<'tcx> LateLintPass<'tcx> for Ranges {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        match expr.kind {
-            ExprKind::MethodCall(path, args, _) => {
-                check_range_zip_with_len(cx, path, args, expr.span);
-            },
-            ExprKind::Binary(ref op, l, r) => {
-                if meets_msrv(self.msrv, msrvs::RANGE_CONTAINS) {
-                    check_possible_range_contains(cx, op.node, l, r, expr, expr.span);
-                }
-            },
-            _ => {},
+        if let ExprKind::Binary(ref op, l, r) = expr.kind {
+            if meets_msrv(self.msrv, msrvs::RANGE_CONTAINS) {
+                check_possible_range_contains(cx, op.node, l, r, expr, expr.span);
+            }
         }
 
         check_exclusive_range_plus_one(cx, expr);
@@ -380,34 +347,6 @@ fn check_range_bounds<'a>(cx: &'a LateContext<'_>, ex: &'a Expr<'_>) -> Option<R
     None
 }
 
-fn check_range_zip_with_len(cx: &LateContext<'_>, path: &PathSegment<'_>, args: &[Expr<'_>], span: Span) {
-    if_chain! {
-        if path.ident.as_str() == "zip";
-        if let [iter, zip_arg] = args;
-        // `.iter()` call
-        if let ExprKind::MethodCall(iter_path, [iter_caller, ..], _) = iter.kind;
-        if iter_path.ident.name == sym::iter;
-        // range expression in `.zip()` call: `0..x.len()`
-        if let Some(higher::Range { start: Some(start), end: Some(end), .. }) = higher::Range::hir(zip_arg);
-        if is_integer_const(cx, start, 0);
-        // `.len()` call
-        if let ExprKind::MethodCall(len_path, [len_caller], _) = end.kind;
-        if len_path.ident.name == sym::len;
-        // `.iter()` and `.len()` called on same `Path`
-        if let ExprKind::Path(QPath::Resolved(_, iter_path)) = iter_caller.kind;
-        if let ExprKind::Path(QPath::Resolved(_, len_path)) = len_caller.kind;
-        if SpanlessEq::new(cx).eq_path_segments(iter_path.segments, len_path.segments);
-        then {
-            span_lint(cx,
-                RANGE_ZIP_WITH_LEN,
-                span,
-                &format!("it is more idiomatic to use `{}.iter().enumerate()`",
-                    snippet(cx, iter_caller.span, "_"))
-            );
-        }
-    }
-}
-
 // exclusive range plus one: `x..(y+1)`
 fn check_exclusive_range_plus_one(cx: &LateContext<'_>, expr: &Expr<'_>) {
     if_chain! {
-- 
cgit 1.4.1-3-g733a5


From 06d752e28dcc4b343f9d437e59d7ebbedff3fde8 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sun, 5 Jun 2022 20:49:03 -0400
Subject: Move `RepeatOnce` into `Methods` lint pass

---
 clippy_lints/src/lib.register_all.rs        |  2 +-
 clippy_lints/src/lib.register_complexity.rs |  2 +-
 clippy_lints/src/lib.register_lints.rs      |  2 +-
 clippy_lints/src/lib.rs                     |  2 -
 clippy_lints/src/methods/mod.rs             | 37 ++++++++++++
 clippy_lints/src/methods/repeat_once.rs     | 52 +++++++++++++++++
 clippy_lints/src/repeat_once.rs             | 89 -----------------------------
 7 files changed, 92 insertions(+), 94 deletions(-)
 create mode 100644 clippy_lints/src/methods/repeat_once.rs
 delete mode 100644 clippy_lints/src/repeat_once.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index d2c8c44b14f..812a89d33e5 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -197,6 +197,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(methods::OR_FUN_CALL),
     LintId::of(methods::OR_THEN_UNWRAP),
     LintId::of(methods::RANGE_ZIP_WITH_LEN),
+    LintId::of(methods::REPEAT_ONCE),
     LintId::of(methods::RESULT_MAP_OR_INTO_OPTION),
     LintId::of(methods::SEARCH_IS_SOME),
     LintId::of(methods::SHOULD_IMPLEMENT_TRAIT),
@@ -287,7 +288,6 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(redundant_static_lifetimes::REDUNDANT_STATIC_LIFETIMES),
     LintId::of(reference::DEREF_ADDROF),
     LintId::of(regex::INVALID_REGEX),
-    LintId::of(repeat_once::REPEAT_ONCE),
     LintId::of(returns::LET_AND_RETURN),
     LintId::of(returns::NEEDLESS_RETURN),
     LintId::of(self_named_constructors::SELF_NAMED_CONSTRUCTORS),
diff --git a/clippy_lints/src/lib.register_complexity.rs b/clippy_lints/src/lib.register_complexity.rs
index f77483de4e4..f79105f4960 100644
--- a/clippy_lints/src/lib.register_complexity.rs
+++ b/clippy_lints/src/lib.register_complexity.rs
@@ -52,6 +52,7 @@ store.register_group(true, "clippy::complexity", Some("clippy_complexity"), vec!
     LintId::of(methods::OPTION_FILTER_MAP),
     LintId::of(methods::OR_THEN_UNWRAP),
     LintId::of(methods::RANGE_ZIP_WITH_LEN),
+    LintId::of(methods::REPEAT_ONCE),
     LintId::of(methods::SEARCH_IS_SOME),
     LintId::of(methods::SKIP_WHILE_NEXT),
     LintId::of(methods::UNNECESSARY_FILTER_MAP),
@@ -80,7 +81,6 @@ store.register_group(true, "clippy::complexity", Some("clippy_complexity"), vec!
     LintId::of(redundant_closure_call::REDUNDANT_CLOSURE_CALL),
     LintId::of(redundant_slicing::REDUNDANT_SLICING),
     LintId::of(reference::DEREF_ADDROF),
-    LintId::of(repeat_once::REPEAT_ONCE),
     LintId::of(strings::STRING_FROM_UTF8_AS_BYTES),
     LintId::of(strlen_on_c_strings::STRLEN_ON_C_STRINGS),
     LintId::of(swap::MANUAL_SWAP),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 2e48e344955..659f0288d17 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -346,6 +346,7 @@ store.register_lints(&[
     methods::OR_THEN_UNWRAP,
     methods::PATH_BUF_PUSH_OVERWRITE,
     methods::RANGE_ZIP_WITH_LEN,
+    methods::REPEAT_ONCE,
     methods::RESULT_MAP_OR_INTO_OPTION,
     methods::SEARCH_IS_SOME,
     methods::SHOULD_IMPLEMENT_TRAIT,
@@ -489,7 +490,6 @@ store.register_lints(&[
     reference::DEREF_ADDROF,
     regex::INVALID_REGEX,
     regex::TRIVIAL_REGEX,
-    repeat_once::REPEAT_ONCE,
     return_self_not_must_use::RETURN_SELF_NOT_MUST_USE,
     returns::LET_AND_RETURN,
     returns::NEEDLESS_RETURN,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 44cfe0d00ec..40c77ede9ad 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -343,7 +343,6 @@ mod redundant_static_lifetimes;
 mod ref_option_ref;
 mod reference;
 mod regex;
-mod repeat_once;
 mod return_self_not_must_use;
 mod returns;
 mod same_name_method;
@@ -824,7 +823,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(macro_use::MacroUseImports::default()));
     store.register_late_pass(|| Box::new(pattern_type_mismatch::PatternTypeMismatch));
     store.register_late_pass(|| Box::new(stable_sort_primitive::StableSortPrimitive));
-    store.register_late_pass(|| Box::new(repeat_once::RepeatOnce));
     store.register_late_pass(|| Box::new(unwrap_in_result::UnwrapInResult));
     store.register_late_pass(|| Box::new(semicolon_if_nothing_returned::SemicolonIfNothingReturned));
     store.register_late_pass(|| Box::new(async_yields_async::AsyncYieldsAsync));
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 4a768117296..bbd6f56c5ea 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -65,6 +65,7 @@ mod or_fun_call;
 mod or_then_unwrap;
 mod path_buf_push_overwrite;
 mod range_zip_with_len;
+mod repeat_once;
 mod search_is_some;
 mod single_char_add_str;
 mod single_char_insert_string;
@@ -2760,6 +2761,38 @@ declare_clippy_lint! {
     "zipping iterator with a range when `enumerate()` would do"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of `.repeat(1)` and suggest the following method for each types.
+    /// - `.to_string()` for `str`
+    /// - `.clone()` for `String`
+    /// - `.to_vec()` for `slice`
+    ///
+    /// The lint will evaluate constant expressions and values as arguments of `.repeat(..)` and emit a message if
+    /// they are equivalent to `1`. (Related discussion in [rust-clippy#7306](https://github.com/rust-lang/rust-clippy/issues/7306))
+    ///
+    /// ### Why is this bad?
+    /// For example, `String.repeat(1)` is equivalent to `.clone()`. If cloning
+    /// the string is the intention behind this, `clone()` should be used.
+    ///
+    /// ### Example
+    /// ```rust
+    /// fn main() {
+    ///     let x = String::from("hello world").repeat(1);
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// fn main() {
+    ///     let x = String::from("hello world").clone();
+    /// }
+    /// ```
+    #[clippy::version = "1.47.0"]
+    pub REPEAT_ONCE,
+    complexity,
+    "using `.repeat(1)` instead of `String.clone()`, `str.to_string()` or `slice.to_vec()` "
+}
+
 pub struct Methods {
     avoid_breaking_exported_api: bool,
     msrv: Option<RustcVersion>,
@@ -2875,6 +2908,7 @@ impl_lint_pass!(Methods => [
     NONSENSICAL_OPEN_OPTIONS,
     PATH_BUF_PUSH_OVERWRITE,
     RANGE_ZIP_WITH_LEN,
+    REPEAT_ONCE,
 ]);
 
 /// Extracts a method call name, args, and `Span` of the method name.
@@ -3263,6 +3297,9 @@ impl Methods {
                 ("push", [arg]) => {
                     path_buf_push_overwrite::check(cx, expr, arg);
                 },
+                ("repeat", [arg]) => {
+                    repeat_once::check(cx, expr, recv, arg);
+                },
                 ("splitn" | "rsplitn", [count_arg, pat_arg]) => {
                     if let Some((Constant::Int(count), _)) = constant(cx, cx.typeck_results(), count_arg) {
                         suspicious_splitn::check(cx, name, expr, recv, count);
diff --git a/clippy_lints/src/methods/repeat_once.rs b/clippy_lints/src/methods/repeat_once.rs
new file mode 100644
index 00000000000..0a14f9216ab
--- /dev/null
+++ b/clippy_lints/src/methods/repeat_once.rs
@@ -0,0 +1,52 @@
+use clippy_utils::consts::{constant_context, Constant};
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet;
+use clippy_utils::ty::is_type_diagnostic_item;
+use rustc_errors::Applicability;
+use rustc_hir::Expr;
+use rustc_lint::LateContext;
+use rustc_span::sym;
+
+use super::REPEAT_ONCE;
+
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx Expr<'_>,
+    recv: &'tcx Expr<'_>,
+    repeat_arg: &'tcx Expr<'_>,
+) {
+    if constant_context(cx, cx.typeck_results()).expr(repeat_arg) == Some(Constant::Int(1)) {
+        let ty = cx.typeck_results().expr_ty(recv).peel_refs();
+        if ty.is_str() {
+            span_lint_and_sugg(
+                cx,
+                REPEAT_ONCE,
+                expr.span,
+                "calling `repeat(1)` on str",
+                "consider using `.to_string()` instead",
+                format!("{}.to_string()", snippet(cx, recv.span, r#""...""#)),
+                Applicability::MachineApplicable,
+            );
+        } else if ty.builtin_index().is_some() {
+            span_lint_and_sugg(
+                cx,
+                REPEAT_ONCE,
+                expr.span,
+                "calling `repeat(1)` on slice",
+                "consider using `.to_vec()` instead",
+                format!("{}.to_vec()", snippet(cx, recv.span, r#""...""#)),
+                Applicability::MachineApplicable,
+            );
+        } else if is_type_diagnostic_item(cx, ty, sym::String) {
+            span_lint_and_sugg(
+                cx,
+                REPEAT_ONCE,
+                expr.span,
+                "calling `repeat(1)` on a string literal",
+                "consider using `.clone()` instead",
+                format!("{}.clone()", snippet(cx, recv.span, r#""...""#)),
+                Applicability::MachineApplicable,
+            );
+        }
+    }
+}
diff --git a/clippy_lints/src/repeat_once.rs b/clippy_lints/src/repeat_once.rs
deleted file mode 100644
index 898c70ace66..00000000000
--- a/clippy_lints/src/repeat_once.rs
+++ /dev/null
@@ -1,89 +0,0 @@
-use clippy_utils::consts::{constant_context, Constant};
-use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::source::snippet;
-use clippy_utils::ty::is_type_diagnostic_item;
-use if_chain::if_chain;
-use rustc_errors::Applicability;
-use rustc_hir::{Expr, ExprKind};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::sym;
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for usage of `.repeat(1)` and suggest the following method for each types.
-    /// - `.to_string()` for `str`
-    /// - `.clone()` for `String`
-    /// - `.to_vec()` for `slice`
-    ///
-    /// The lint will evaluate constant expressions and values as arguments of `.repeat(..)` and emit a message if
-    /// they are equivalent to `1`. (Related discussion in [rust-clippy#7306](https://github.com/rust-lang/rust-clippy/issues/7306))
-    ///
-    /// ### Why is this bad?
-    /// For example, `String.repeat(1)` is equivalent to `.clone()`. If cloning
-    /// the string is the intention behind this, `clone()` should be used.
-    ///
-    /// ### Example
-    /// ```rust
-    /// fn main() {
-    ///     let x = String::from("hello world").repeat(1);
-    /// }
-    /// ```
-    /// Use instead:
-    /// ```rust
-    /// fn main() {
-    ///     let x = String::from("hello world").clone();
-    /// }
-    /// ```
-    #[clippy::version = "1.47.0"]
-    pub REPEAT_ONCE,
-    complexity,
-    "using `.repeat(1)` instead of `String.clone()`, `str.to_string()` or `slice.to_vec()` "
-}
-
-declare_lint_pass!(RepeatOnce => [REPEAT_ONCE]);
-
-impl<'tcx> LateLintPass<'tcx> for RepeatOnce {
-    fn check_expr(&mut self, cx: &LateContext<'_>, expr: &'tcx Expr<'_>) {
-        if_chain! {
-            if let ExprKind::MethodCall(path, [receiver, count], _) = &expr.kind;
-            if path.ident.name == sym!(repeat);
-            if constant_context(cx, cx.typeck_results()).expr(count) == Some(Constant::Int(1));
-            if !receiver.span.from_expansion();
-            then {
-                let ty = cx.typeck_results().expr_ty(receiver).peel_refs();
-                if ty.is_str() {
-                    span_lint_and_sugg(
-                        cx,
-                        REPEAT_ONCE,
-                        expr.span,
-                        "calling `repeat(1)` on str",
-                        "consider using `.to_string()` instead",
-                        format!("{}.to_string()", snippet(cx, receiver.span, r#""...""#)),
-                        Applicability::MachineApplicable,
-                    );
-                } else if ty.builtin_index().is_some() {
-                    span_lint_and_sugg(
-                        cx,
-                        REPEAT_ONCE,
-                        expr.span,
-                        "calling `repeat(1)` on slice",
-                        "consider using `.to_vec()` instead",
-                        format!("{}.to_vec()", snippet(cx, receiver.span, r#""...""#)),
-                        Applicability::MachineApplicable,
-                    );
-                } else if is_type_diagnostic_item(cx, ty, sym::String) {
-                    span_lint_and_sugg(
-                        cx,
-                        REPEAT_ONCE,
-                        expr.span,
-                        "calling `repeat(1)` on a string literal",
-                        "consider using `.clone()` instead",
-                        format!("{}.clone()", snippet(cx, receiver.span, r#""...""#)),
-                        Applicability::MachineApplicable,
-                    );
-                }
-            }
-        }
-    }
-}
-- 
cgit 1.4.1-3-g733a5


From e834855950701dae9657e7c0dbde195f85a96bf3 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sun, 5 Jun 2022 21:07:29 -0400
Subject: Move `StableSortPrimitive` to `Methods` lint pass

---
 clippy_lints/src/lib.register_lints.rs            |   2 +-
 clippy_lints/src/lib.register_pedantic.rs         |   2 +-
 clippy_lints/src/lib.rs                           |   2 -
 clippy_lints/src/methods/mod.rs                   |  43 +++++++
 clippy_lints/src/methods/stable_sort_primitive.rs |  31 +++++
 clippy_lints/src/stable_sort_primitive.rs         | 144 ----------------------
 6 files changed, 76 insertions(+), 148 deletions(-)
 create mode 100644 clippy_lints/src/methods/stable_sort_primitive.rs
 delete mode 100644 clippy_lints/src/stable_sort_primitive.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 659f0288d17..e8c796b4e9b 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -353,6 +353,7 @@ store.register_lints(&[
     methods::SINGLE_CHAR_ADD_STR,
     methods::SINGLE_CHAR_PATTERN,
     methods::SKIP_WHILE_NEXT,
+    methods::STABLE_SORT_PRIMITIVE,
     methods::STRING_EXTEND_CHARS,
     methods::SUSPICIOUS_MAP,
     methods::SUSPICIOUS_SPLITN,
@@ -504,7 +505,6 @@ store.register_lints(&[
     single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS,
     size_of_in_element_count::SIZE_OF_IN_ELEMENT_COUNT,
     slow_vector_initialization::SLOW_VECTOR_INITIALIZATION,
-    stable_sort_primitive::STABLE_SORT_PRIMITIVE,
     std_instead_of_core::ALLOC_INSTEAD_OF_CORE,
     std_instead_of_core::STD_INSTEAD_OF_ALLOC,
     std_instead_of_core::STD_INSTEAD_OF_CORE,
diff --git a/clippy_lints/src/lib.register_pedantic.rs b/clippy_lints/src/lib.register_pedantic.rs
index 5c04a331d0a..13474127e8d 100644
--- a/clippy_lints/src/lib.register_pedantic.rs
+++ b/clippy_lints/src/lib.register_pedantic.rs
@@ -64,6 +64,7 @@ store.register_group(true, "clippy::pedantic", Some("clippy_pedantic"), vec![
     LintId::of(methods::MANUAL_OK_OR),
     LintId::of(methods::MAP_UNWRAP_OR),
     LintId::of(methods::NAIVE_BYTECOUNT),
+    LintId::of(methods::STABLE_SORT_PRIMITIVE),
     LintId::of(methods::UNNECESSARY_JOIN),
     LintId::of(misc::USED_UNDERSCORE_BINDING),
     LintId::of(mismatching_type_param_order::MISMATCHING_TYPE_PARAM_ORDER),
@@ -85,7 +86,6 @@ store.register_group(true, "clippy::pedantic", Some("clippy_pedantic"), vec![
     LintId::of(ref_option_ref::REF_OPTION_REF),
     LintId::of(return_self_not_must_use::RETURN_SELF_NOT_MUST_USE),
     LintId::of(semicolon_if_nothing_returned::SEMICOLON_IF_NOTHING_RETURNED),
-    LintId::of(stable_sort_primitive::STABLE_SORT_PRIMITIVE),
     LintId::of(strings::STRING_ADD_ASSIGN),
     LintId::of(transmute::TRANSMUTE_PTR_TO_PTR),
     LintId::of(types::LINKEDLIST),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 40c77ede9ad..c424c373d32 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -354,7 +354,6 @@ mod single_char_lifetime_names;
 mod single_component_path_imports;
 mod size_of_in_element_count;
 mod slow_vector_initialization;
-mod stable_sort_primitive;
 mod std_instead_of_core;
 mod strings;
 mod strlen_on_c_strings;
@@ -822,7 +821,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_early_pass(move || Box::new(nonstandard_macro_braces::MacroBraces::new(&macro_matcher)));
     store.register_late_pass(|| Box::new(macro_use::MacroUseImports::default()));
     store.register_late_pass(|| Box::new(pattern_type_mismatch::PatternTypeMismatch));
-    store.register_late_pass(|| Box::new(stable_sort_primitive::StableSortPrimitive));
     store.register_late_pass(|| Box::new(unwrap_in_result::UnwrapInResult));
     store.register_late_pass(|| Box::new(semicolon_if_nothing_returned::SemicolonIfNothingReturned));
     store.register_late_pass(|| Box::new(async_yields_async::AsyncYieldsAsync));
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index bbd6f56c5ea..a47081d8752 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -72,6 +72,7 @@ mod single_char_insert_string;
 mod single_char_pattern;
 mod single_char_push_string;
 mod skip_while_next;
+mod stable_sort_primitive;
 mod str_splitn;
 mod string_extend_chars;
 mod suspicious_map;
@@ -2793,6 +2794,44 @@ declare_clippy_lint! {
     "using `.repeat(1)` instead of `String.clone()`, `str.to_string()` or `slice.to_vec()` "
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// When sorting primitive values (integers, bools, chars, as well
+    /// as arrays, slices, and tuples of such items), it is typically better to
+    /// use an unstable sort than a stable sort.
+    ///
+    /// ### Why is this bad?
+    /// Typically, using a stable sort consumes more memory and cpu cycles.
+    /// Because values which compare equal are identical, preserving their
+    /// relative order (the guarantee that a stable sort provides) means
+    /// nothing, while the extra costs still apply.
+    ///
+    /// ### Known problems
+    ///
+    /// As pointed out in
+    /// [issue #8241](https://github.com/rust-lang/rust-clippy/issues/8241),
+    /// a stable sort can instead be significantly faster for certain scenarios
+    /// (eg. when a sorted vector is extended with new data and resorted).
+    ///
+    /// For more information and benchmarking results, please refer to the
+    /// issue linked above.
+    ///
+    /// ### Example
+    /// ```rust
+    /// let mut vec = vec![2, 1, 3];
+    /// vec.sort();
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// let mut vec = vec![2, 1, 3];
+    /// vec.sort_unstable();
+    /// ```
+    #[clippy::version = "1.47.0"]
+    pub STABLE_SORT_PRIMITIVE,
+    pedantic,
+    "use of sort() when sort_unstable() is equivalent"
+}
+
 pub struct Methods {
     avoid_breaking_exported_api: bool,
     msrv: Option<RustcVersion>,
@@ -2909,6 +2948,7 @@ impl_lint_pass!(Methods => [
     PATH_BUF_PUSH_OVERWRITE,
     RANGE_ZIP_WITH_LEN,
     REPEAT_ONCE,
+    STABLE_SORT_PRIMITIVE,
 ]);
 
 /// Extracts a method call name, args, and `Span` of the method name.
@@ -3300,6 +3340,9 @@ impl Methods {
                 ("repeat", [arg]) => {
                     repeat_once::check(cx, expr, recv, arg);
                 },
+                ("sort", []) => {
+                    stable_sort_primitive::check(cx, expr, recv);
+                },
                 ("splitn" | "rsplitn", [count_arg, pat_arg]) => {
                     if let Some((Constant::Int(count), _)) = constant(cx, cx.typeck_results(), count_arg) {
                         suspicious_splitn::check(cx, name, expr, recv, count);
diff --git a/clippy_lints/src/methods/stable_sort_primitive.rs b/clippy_lints/src/methods/stable_sort_primitive.rs
new file mode 100644
index 00000000000..91951c65bb3
--- /dev/null
+++ b/clippy_lints/src/methods/stable_sort_primitive.rs
@@ -0,0 +1,31 @@
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::is_slice_of_primitives;
+use clippy_utils::source::snippet_with_context;
+use rustc_errors::Applicability;
+use rustc_hir::Expr;
+use rustc_lint::LateContext;
+
+use super::STABLE_SORT_PRIMITIVE;
+
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>, recv: &'tcx Expr<'_>) {
+    if let Some(method_id) = cx.typeck_results().type_dependent_def_id(e.hir_id)
+        && let Some(impl_id) = cx.tcx.impl_of_method(method_id)
+        && cx.tcx.type_of(impl_id).is_slice()
+        && let Some(slice_type) = is_slice_of_primitives(cx, recv)
+    {
+        span_lint_and_then(
+            cx,
+            STABLE_SORT_PRIMITIVE,
+            e.span,
+            &format!("used `sort` on primitive type `{}`", slice_type),
+            |diag| {
+                let mut app = Applicability::MachineApplicable;
+                let recv_snip = snippet_with_context(cx, recv.span, e.span.ctxt(), "..", &mut app).0;
+                diag.span_suggestion(e.span, "try", format!("{}.sort_unstable()", recv_snip), app);
+                diag.note(
+                    "an unstable sort typically performs faster without any observable difference for this data type",
+                );
+            },
+        );
+    }
+}
diff --git a/clippy_lints/src/stable_sort_primitive.rs b/clippy_lints/src/stable_sort_primitive.rs
deleted file mode 100644
index 6d54935f81a..00000000000
--- a/clippy_lints/src/stable_sort_primitive.rs
+++ /dev/null
@@ -1,144 +0,0 @@
-use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::{is_slice_of_primitives, sugg::Sugg};
-use if_chain::if_chain;
-use rustc_errors::Applicability;
-use rustc_hir::{Expr, ExprKind};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// When sorting primitive values (integers, bools, chars, as well
-    /// as arrays, slices, and tuples of such items), it is typically better to
-    /// use an unstable sort than a stable sort.
-    ///
-    /// ### Why is this bad?
-    /// Typically, using a stable sort consumes more memory and cpu cycles.
-    /// Because values which compare equal are identical, preserving their
-    /// relative order (the guarantee that a stable sort provides) means
-    /// nothing, while the extra costs still apply.
-    ///
-    /// ### Known problems
-    ///
-    /// As pointed out in
-    /// [issue #8241](https://github.com/rust-lang/rust-clippy/issues/8241),
-    /// a stable sort can instead be significantly faster for certain scenarios
-    /// (eg. when a sorted vector is extended with new data and resorted).
-    ///
-    /// For more information and benchmarking results, please refer to the
-    /// issue linked above.
-    ///
-    /// ### Example
-    /// ```rust
-    /// let mut vec = vec![2, 1, 3];
-    /// vec.sort();
-    /// ```
-    /// Use instead:
-    /// ```rust
-    /// let mut vec = vec![2, 1, 3];
-    /// vec.sort_unstable();
-    /// ```
-    #[clippy::version = "1.47.0"]
-    pub STABLE_SORT_PRIMITIVE,
-    pedantic,
-    "use of sort() when sort_unstable() is equivalent"
-}
-
-declare_lint_pass!(StableSortPrimitive => [STABLE_SORT_PRIMITIVE]);
-
-/// The three "kinds" of sorts
-enum SortingKind {
-    Vanilla,
-    /* The other kinds of lint are currently commented out because they
-     * can map distinct values to equal ones. If the key function is
-     * provably one-to-one, or if the Cmp function conserves equality,
-     * then they could be linted on, but I don't know if we can check
-     * for that. */
-
-    /* ByKey,
-     * ByCmp, */
-}
-impl SortingKind {
-    /// The name of the stable version of this kind of sort
-    fn stable_name(&self) -> &str {
-        match self {
-            SortingKind::Vanilla => "sort",
-            /* SortingKind::ByKey => "sort_by_key",
-             * SortingKind::ByCmp => "sort_by", */
-        }
-    }
-    /// The name of the unstable version of this kind of sort
-    fn unstable_name(&self) -> &str {
-        match self {
-            SortingKind::Vanilla => "sort_unstable",
-            /* SortingKind::ByKey => "sort_unstable_by_key",
-             * SortingKind::ByCmp => "sort_unstable_by", */
-        }
-    }
-    /// Takes the name of a function call and returns the kind of sort
-    /// that corresponds to that function name (or None if it isn't)
-    fn from_stable_name(name: &str) -> Option<SortingKind> {
-        match name {
-            "sort" => Some(SortingKind::Vanilla),
-            // "sort_by" => Some(SortingKind::ByCmp),
-            // "sort_by_key" => Some(SortingKind::ByKey),
-            _ => None,
-        }
-    }
-}
-
-/// A detected instance of this lint
-struct LintDetection {
-    slice_name: String,
-    method: SortingKind,
-    method_args: String,
-    slice_type: String,
-}
-
-fn detect_stable_sort_primitive(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<LintDetection> {
-    if_chain! {
-        if let ExprKind::MethodCall(method_name, [slice, args @ ..], _) = &expr.kind;
-        if let Some(method) = SortingKind::from_stable_name(method_name.ident.name.as_str());
-        if let Some(slice_type) = is_slice_of_primitives(cx, slice);
-        then {
-            let args_str = args.iter().map(|arg| Sugg::hir(cx, arg, "..").to_string()).collect::<Vec<String>>().join(", ");
-            Some(LintDetection { slice_name: Sugg::hir(cx, slice, "..").to_string(), method, method_args: args_str, slice_type })
-        } else {
-            None
-        }
-    }
-}
-
-impl LateLintPass<'_> for StableSortPrimitive {
-    fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
-        if let Some(detection) = detect_stable_sort_primitive(cx, expr) {
-            span_lint_and_then(
-                cx,
-                STABLE_SORT_PRIMITIVE,
-                expr.span,
-                format!(
-                    "used `{}` on primitive type `{}`",
-                    detection.method.stable_name(),
-                    detection.slice_type,
-                )
-                .as_str(),
-                |diag| {
-                    diag.span_suggestion(
-                        expr.span,
-                        "try",
-                        format!(
-                            "{}.{}({})",
-                            detection.slice_name,
-                            detection.method.unstable_name(),
-                            detection.method_args,
-                        ),
-                        Applicability::MachineApplicable,
-                    );
-                    diag.note(
-                        "an unstable sort typically performs faster without any observable difference for this data type",
-                    );
-                },
-            );
-        }
-    }
-}
-- 
cgit 1.4.1-3-g733a5


From e213b6ee35faec133333e07f962958fbbfe12679 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sun, 5 Jun 2022 21:36:40 -0400
Subject: Move `TransmutingNull` into `Transmute` lint pass

---
 clippy_lints/src/lib.register_all.rs           |  2 +-
 clippy_lints/src/lib.register_correctness.rs   |  2 +-
 clippy_lints/src/lib.register_lints.rs         |  2 +-
 clippy_lints/src/lib.rs                        |  2 -
 clippy_lints/src/transmute/mod.rs              | 25 ++++++++
 clippy_lints/src/transmute/transmuting_null.rs | 61 ++++++++++++++++++
 clippy_lints/src/transmuting_null.rs           | 89 --------------------------
 7 files changed, 89 insertions(+), 94 deletions(-)
 create mode 100644 clippy_lints/src/transmute/transmuting_null.rs
 delete mode 100644 clippy_lints/src/transmuting_null.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 812a89d33e5..aad6a1af200 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -315,10 +315,10 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(transmute::TRANSMUTE_INT_TO_FLOAT),
     LintId::of(transmute::TRANSMUTE_NUM_TO_BYTES),
     LintId::of(transmute::TRANSMUTE_PTR_TO_REF),
+    LintId::of(transmute::TRANSMUTING_NULL),
     LintId::of(transmute::UNSOUND_COLLECTION_TRANSMUTE),
     LintId::of(transmute::USELESS_TRANSMUTE),
     LintId::of(transmute::WRONG_TRANSMUTE),
-    LintId::of(transmuting_null::TRANSMUTING_NULL),
     LintId::of(types::BORROWED_BOX),
     LintId::of(types::BOX_COLLECTION),
     LintId::of(types::REDUNDANT_ALLOCATION),
diff --git a/clippy_lints/src/lib.register_correctness.rs b/clippy_lints/src/lib.register_correctness.rs
index 8ba39cc973e..9d69d4acc90 100644
--- a/clippy_lints/src/lib.register_correctness.rs
+++ b/clippy_lints/src/lib.register_correctness.rs
@@ -62,9 +62,9 @@ store.register_group(true, "clippy::correctness", Some("clippy_correctness"), ve
     LintId::of(serde_api::SERDE_API_MISUSE),
     LintId::of(size_of_in_element_count::SIZE_OF_IN_ELEMENT_COUNT),
     LintId::of(swap::ALMOST_SWAPPED),
+    LintId::of(transmute::TRANSMUTING_NULL),
     LintId::of(transmute::UNSOUND_COLLECTION_TRANSMUTE),
     LintId::of(transmute::WRONG_TRANSMUTE),
-    LintId::of(transmuting_null::TRANSMUTING_NULL),
     LintId::of(unicode::INVISIBLE_CHARACTERS),
     LintId::of(uninit_vec::UNINIT_VEC),
     LintId::of(unit_hash::UNIT_HASH),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index e8c796b4e9b..a2a81052070 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -540,10 +540,10 @@ store.register_lints(&[
     transmute::TRANSMUTE_PTR_TO_PTR,
     transmute::TRANSMUTE_PTR_TO_REF,
     transmute::TRANSMUTE_UNDEFINED_REPR,
+    transmute::TRANSMUTING_NULL,
     transmute::UNSOUND_COLLECTION_TRANSMUTE,
     transmute::USELESS_TRANSMUTE,
     transmute::WRONG_TRANSMUTE,
-    transmuting_null::TRANSMUTING_NULL,
     types::BORROWED_BOX,
     types::BOX_COLLECTION,
     types::LINKEDLIST,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index c424c373d32..e0b6ded0b58 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -367,7 +367,6 @@ mod to_digit_is_some;
 mod trailing_empty_array;
 mod trait_bounds;
 mod transmute;
-mod transmuting_null;
 mod types;
 mod undocumented_unsafe_blocks;
 mod unicode;
@@ -723,7 +722,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(move || Box::new(unnecessary_wraps::UnnecessaryWraps::new(avoid_breaking_exported_api)));
     store.register_late_pass(|| Box::new(assertions_on_constants::AssertionsOnConstants));
     store.register_late_pass(|| Box::new(assertions_on_result_states::AssertionsOnResultStates));
-    store.register_late_pass(|| Box::new(transmuting_null::TransmutingNull));
     store.register_late_pass(|| Box::new(inherent_to_string::InherentToString));
     let max_trait_bounds = conf.max_trait_bounds;
     store.register_late_pass(move || Box::new(trait_bounds::TraitBounds::new(max_trait_bounds)));
diff --git a/clippy_lints/src/transmute/mod.rs b/clippy_lints/src/transmute/mod.rs
index 5f3e98144f4..424a6e9264e 100644
--- a/clippy_lints/src/transmute/mod.rs
+++ b/clippy_lints/src/transmute/mod.rs
@@ -9,6 +9,7 @@ mod transmute_ptr_to_ref;
 mod transmute_ref_to_ref;
 mod transmute_undefined_repr;
 mod transmutes_expressible_as_ptr_casts;
+mod transmuting_null;
 mod unsound_collection_transmute;
 mod useless_transmute;
 mod utils;
@@ -386,6 +387,28 @@ declare_clippy_lint! {
     "transmute to or from a type with an undefined representation"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for transmute calls which would receive a null pointer.
+    ///
+    /// ### Why is this bad?
+    /// Transmuting a null pointer is undefined behavior.
+    ///
+    /// ### Known problems
+    /// Not all cases can be detected at the moment of this writing.
+    /// For example, variables which hold a null pointer and are then fed to a `transmute`
+    /// call, aren't detectable yet.
+    ///
+    /// ### Example
+    /// ```rust
+    /// let null_ref: &u64 = unsafe { std::mem::transmute(0 as *const u64) };
+    /// ```
+    #[clippy::version = "1.35.0"]
+    pub TRANSMUTING_NULL,
+    correctness,
+    "transmutes from a null pointer to a reference, which is undefined behavior"
+}
+
 pub struct Transmute {
     msrv: Option<RustcVersion>,
 }
@@ -404,6 +427,7 @@ impl_lint_pass!(Transmute => [
     UNSOUND_COLLECTION_TRANSMUTE,
     TRANSMUTES_EXPRESSIBLE_AS_PTR_CASTS,
     TRANSMUTE_UNDEFINED_REPR,
+    TRANSMUTING_NULL,
 ]);
 impl Transmute {
     #[must_use]
@@ -436,6 +460,7 @@ impl<'tcx> LateLintPass<'tcx> for Transmute {
 
                 let linted = wrong_transmute::check(cx, e, from_ty, to_ty)
                     | crosspointer_transmute::check(cx, e, from_ty, to_ty)
+                    | transmuting_null::check(cx, e, arg, to_ty)
                     | transmute_ptr_to_ref::check(cx, e, from_ty, to_ty, arg, path, self.msrv)
                     | transmute_int_to_char::check(cx, e, from_ty, to_ty, arg, const_context)
                     | transmute_ref_to_ref::check(cx, e, from_ty, to_ty, arg, const_context)
diff --git a/clippy_lints/src/transmute/transmuting_null.rs b/clippy_lints/src/transmute/transmuting_null.rs
new file mode 100644
index 00000000000..c4981124f39
--- /dev/null
+++ b/clippy_lints/src/transmute/transmuting_null.rs
@@ -0,0 +1,61 @@
+use clippy_utils::consts::{constant_context, Constant};
+use clippy_utils::diagnostics::span_lint;
+use clippy_utils::is_expr_diagnostic_item;
+use if_chain::if_chain;
+use rustc_ast::LitKind;
+use rustc_hir::{Expr, ExprKind};
+use rustc_lint::LateContext;
+use rustc_middle::ty::Ty;
+use rustc_span::symbol::sym;
+
+use super::TRANSMUTING_NULL;
+
+const LINT_MSG: &str = "transmuting a known null pointer into a reference";
+
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, arg: &'tcx Expr<'_>, to_ty: Ty<'tcx>) -> bool {
+    if !to_ty.is_ref() {
+        return false;
+    }
+
+    // Catching transmute over constants that resolve to `null`.
+    let mut const_eval_context = constant_context(cx, cx.typeck_results());
+    if_chain! {
+        if let ExprKind::Path(ref _qpath) = arg.kind;
+        if let Some(Constant::RawPtr(x)) = const_eval_context.expr(arg);
+        if x == 0;
+        then {
+            span_lint(cx, TRANSMUTING_NULL, expr.span, LINT_MSG);
+            return true;
+        }
+    }
+
+    // Catching:
+    // `std::mem::transmute(0 as *const i32)`
+    if_chain! {
+        if let ExprKind::Cast(inner_expr, _cast_ty) = arg.kind;
+        if let ExprKind::Lit(ref lit) = inner_expr.kind;
+        if let LitKind::Int(0, _) = lit.node;
+        then {
+            span_lint(cx, TRANSMUTING_NULL, expr.span, LINT_MSG);
+            return true;
+        }
+    }
+
+    // Catching:
+    // `std::mem::transmute(std::ptr::null::<i32>())`
+    if_chain! {
+        if let ExprKind::Call(func1, []) = arg.kind;
+        if is_expr_diagnostic_item(cx, func1, sym::ptr_null);
+        then {
+            span_lint(cx, TRANSMUTING_NULL, expr.span, LINT_MSG);
+            return true;
+        }
+    }
+
+    // FIXME:
+    // Also catch transmutations of variables which are known nulls.
+    // To do this, MIR const propagation seems to be the better tool.
+    // Whenever MIR const prop routines are more developed, this will
+    // become available. As of this writing (25/03/19) it is not yet.
+    false
+}
diff --git a/clippy_lints/src/transmuting_null.rs b/clippy_lints/src/transmuting_null.rs
deleted file mode 100644
index 7939dfedc3a..00000000000
--- a/clippy_lints/src/transmuting_null.rs
+++ /dev/null
@@ -1,89 +0,0 @@
-use clippy_utils::consts::{constant_context, Constant};
-use clippy_utils::diagnostics::span_lint;
-use clippy_utils::is_expr_diagnostic_item;
-use if_chain::if_chain;
-use rustc_ast::LitKind;
-use rustc_hir::{Expr, ExprKind};
-use rustc_lint::{LateContext, LateLintPass, LintContext};
-use rustc_middle::lint::in_external_macro;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::symbol::sym;
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for transmute calls which would receive a null pointer.
-    ///
-    /// ### Why is this bad?
-    /// Transmuting a null pointer is undefined behavior.
-    ///
-    /// ### Known problems
-    /// Not all cases can be detected at the moment of this writing.
-    /// For example, variables which hold a null pointer and are then fed to a `transmute`
-    /// call, aren't detectable yet.
-    ///
-    /// ### Example
-    /// ```rust
-    /// let null_ref: &u64 = unsafe { std::mem::transmute(0 as *const u64) };
-    /// ```
-    #[clippy::version = "1.35.0"]
-    pub TRANSMUTING_NULL,
-    correctness,
-    "transmutes from a null pointer to a reference, which is undefined behavior"
-}
-
-declare_lint_pass!(TransmutingNull => [TRANSMUTING_NULL]);
-
-const LINT_MSG: &str = "transmuting a known null pointer into a reference";
-
-impl<'tcx> LateLintPass<'tcx> for TransmutingNull {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if in_external_macro(cx.sess(), expr.span) {
-            return;
-        }
-
-        if_chain! {
-            if let ExprKind::Call(func, [arg]) = expr.kind;
-            if is_expr_diagnostic_item(cx, func, sym::transmute);
-
-            then {
-                // Catching transmute over constants that resolve to `null`.
-                let mut const_eval_context = constant_context(cx, cx.typeck_results());
-                if_chain! {
-                    if let ExprKind::Path(ref _qpath) = arg.kind;
-                    if let Some(Constant::RawPtr(x)) = const_eval_context.expr(arg);
-                    if x == 0;
-                    then {
-                        span_lint(cx, TRANSMUTING_NULL, expr.span, LINT_MSG)
-                    }
-                }
-
-                // Catching:
-                // `std::mem::transmute(0 as *const i32)`
-                if_chain! {
-                    if let ExprKind::Cast(inner_expr, _cast_ty) = arg.kind;
-                    if let ExprKind::Lit(ref lit) = inner_expr.kind;
-                    if let LitKind::Int(0, _) = lit.node;
-                    then {
-                        span_lint(cx, TRANSMUTING_NULL, expr.span, LINT_MSG)
-                    }
-                }
-
-                // Catching:
-                // `std::mem::transmute(std::ptr::null::<i32>())`
-                if_chain! {
-                    if let ExprKind::Call(func1, []) = arg.kind;
-                    if is_expr_diagnostic_item(cx, func1, sym::ptr_null);
-                    then {
-                        span_lint(cx, TRANSMUTING_NULL, expr.span, LINT_MSG)
-                    }
-                }
-
-                // FIXME:
-                // Also catch transmutations of variables which are known nulls.
-                // To do this, MIR const propagation seems to be the better tool.
-                // Whenever MIR const prop routines are more developed, this will
-                // become available. As of this writing (25/03/19) it is not yet.
-            }
-        }
-    }
-}
-- 
cgit 1.4.1-3-g733a5


From bb0584dfb425f6c1a8bef9faad9ee36f0bbc19fb Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sun, 5 Jun 2022 21:41:33 -0400
Subject: Move `UnitHash` into `Methods` lint pass

---
 clippy_lints/src/lib.register_all.rs         |  2 +-
 clippy_lints/src/lib.register_correctness.rs |  2 +-
 clippy_lints/src/lib.register_lints.rs       |  2 +-
 clippy_lints/src/lib.rs                      |  2 -
 clippy_lints/src/methods/mod.rs              | 44 ++++++++++++++++
 clippy_lints/src/methods/unit_hash.rs        | 29 +++++++++++
 clippy_lints/src/unit_hash.rs                | 78 ----------------------------
 7 files changed, 76 insertions(+), 83 deletions(-)
 create mode 100644 clippy_lints/src/methods/unit_hash.rs
 delete mode 100644 clippy_lints/src/unit_hash.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index aad6a1af200..e51ce0fa254 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -208,6 +208,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(methods::SUSPICIOUS_MAP),
     LintId::of(methods::SUSPICIOUS_SPLITN),
     LintId::of(methods::UNINIT_ASSUMED_INIT),
+    LintId::of(methods::UNIT_HASH),
     LintId::of(methods::UNNECESSARY_FILTER_MAP),
     LintId::of(methods::UNNECESSARY_FIND_MAP),
     LintId::of(methods::UNNECESSARY_FOLD),
@@ -326,7 +327,6 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(types::VEC_BOX),
     LintId::of(unicode::INVISIBLE_CHARACTERS),
     LintId::of(uninit_vec::UNINIT_VEC),
-    LintId::of(unit_hash::UNIT_HASH),
     LintId::of(unit_return_expecting_ord::UNIT_RETURN_EXPECTING_ORD),
     LintId::of(unit_types::LET_UNIT_VALUE),
     LintId::of(unit_types::UNIT_ARG),
diff --git a/clippy_lints/src/lib.register_correctness.rs b/clippy_lints/src/lib.register_correctness.rs
index 9d69d4acc90..d30e69b2240 100644
--- a/clippy_lints/src/lib.register_correctness.rs
+++ b/clippy_lints/src/lib.register_correctness.rs
@@ -42,6 +42,7 @@ store.register_group(true, "clippy::correctness", Some("clippy_correctness"), ve
     LintId::of(methods::NONSENSICAL_OPEN_OPTIONS),
     LintId::of(methods::SUSPICIOUS_SPLITN),
     LintId::of(methods::UNINIT_ASSUMED_INIT),
+    LintId::of(methods::UNIT_HASH),
     LintId::of(methods::ZST_OFFSET),
     LintId::of(minmax::MIN_MAX),
     LintId::of(non_octal_unix_permissions::NON_OCTAL_UNIX_PERMISSIONS),
@@ -67,7 +68,6 @@ store.register_group(true, "clippy::correctness", Some("clippy_correctness"), ve
     LintId::of(transmute::WRONG_TRANSMUTE),
     LintId::of(unicode::INVISIBLE_CHARACTERS),
     LintId::of(uninit_vec::UNINIT_VEC),
-    LintId::of(unit_hash::UNIT_HASH),
     LintId::of(unit_return_expecting_ord::UNIT_RETURN_EXPECTING_ORD),
     LintId::of(unit_types::UNIT_CMP),
     LintId::of(unnamed_address::FN_ADDRESS_COMPARISONS),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index a2a81052070..8aa1810fbd5 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -358,6 +358,7 @@ store.register_lints(&[
     methods::SUSPICIOUS_MAP,
     methods::SUSPICIOUS_SPLITN,
     methods::UNINIT_ASSUMED_INIT,
+    methods::UNIT_HASH,
     methods::UNNECESSARY_FILTER_MAP,
     methods::UNNECESSARY_FIND_MAP,
     methods::UNNECESSARY_FOLD,
@@ -558,7 +559,6 @@ store.register_lints(&[
     unicode::NON_ASCII_LITERAL,
     unicode::UNICODE_NOT_NFC,
     uninit_vec::UNINIT_VEC,
-    unit_hash::UNIT_HASH,
     unit_return_expecting_ord::UNIT_RETURN_EXPECTING_ORD,
     unit_types::LET_UNIT_VALUE,
     unit_types::UNIT_ARG,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index e0b6ded0b58..71ba3f18da8 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -371,7 +371,6 @@ mod types;
 mod undocumented_unsafe_blocks;
 mod unicode;
 mod uninit_vec;
-mod unit_hash;
 mod unit_return_expecting_ord;
 mod unit_types;
 mod unnamed_address;
@@ -582,7 +581,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(blocks_in_if_conditions::BlocksInIfConditions));
     store.register_late_pass(|| Box::new(unicode::Unicode));
     store.register_late_pass(|| Box::new(uninit_vec::UninitVec));
-    store.register_late_pass(|| Box::new(unit_hash::UnitHash));
     store.register_late_pass(|| Box::new(unit_return_expecting_ord::UnitReturnExpectingOrd));
     store.register_late_pass(|| Box::new(strings::StringAdd));
     store.register_late_pass(|| Box::new(implicit_return::ImplicitReturn));
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index a47081d8752..ce10b64c948 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -78,6 +78,7 @@ mod string_extend_chars;
 mod suspicious_map;
 mod suspicious_splitn;
 mod uninit_assumed_init;
+mod unit_hash;
 mod unnecessary_filter_map;
 mod unnecessary_fold;
 mod unnecessary_iter_cloned;
@@ -2832,6 +2833,45 @@ declare_clippy_lint! {
     "use of sort() when sort_unstable() is equivalent"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Detects `().hash(_)`.
+    ///
+    /// ### Why is this bad?
+    /// Hashing a unit value doesn't do anything as the implementation of `Hash` for `()` is a no-op.
+    ///
+    /// ### Example
+    /// ```rust
+    /// # use std::hash::Hash;
+    /// # use std::collections::hash_map::DefaultHasher;
+    /// # enum Foo { Empty, WithValue(u8) }
+    /// # use Foo::*;
+    /// # let mut state = DefaultHasher::new();
+    /// # let my_enum = Foo::Empty;
+    /// match my_enum {
+    /// 	Empty => ().hash(&mut state),
+    /// 	WithValue(x) => x.hash(&mut state),
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// # use std::hash::Hash;
+    /// # use std::collections::hash_map::DefaultHasher;
+    /// # enum Foo { Empty, WithValue(u8) }
+    /// # use Foo::*;
+    /// # let mut state = DefaultHasher::new();
+    /// # let my_enum = Foo::Empty;
+    /// match my_enum {
+    /// 	Empty => 0_u8.hash(&mut state),
+    /// 	WithValue(x) => x.hash(&mut state),
+    /// }
+    /// ```
+    #[clippy::version = "1.58.0"]
+    pub UNIT_HASH,
+    correctness,
+    "hashing a unit value, which does nothing"
+}
+
 pub struct Methods {
     avoid_breaking_exported_api: bool,
     msrv: Option<RustcVersion>,
@@ -2949,6 +2989,7 @@ impl_lint_pass!(Methods => [
     RANGE_ZIP_WITH_LEN,
     REPEAT_ONCE,
     STABLE_SORT_PRIMITIVE,
+    UNIT_HASH,
 ]);
 
 /// Extracts a method call name, args, and `Span` of the method name.
@@ -3258,6 +3299,9 @@ impl Methods {
                     get_last_with_len::check(cx, expr, recv, arg);
                 },
                 ("get_or_insert_with", [arg]) => unnecessary_lazy_eval::check(cx, expr, recv, arg, "get_or_insert"),
+                ("hash", [arg]) => {
+                    unit_hash::check(cx, expr, recv, arg);
+                },
                 ("is_file", []) => filetype_is_file::check(cx, expr, recv),
                 ("is_digit", [radix]) => is_digit_ascii_radix::check(cx, expr, recv, radix, self.msrv),
                 ("is_none", []) => check_is_some_is_none(cx, expr, recv, false),
diff --git a/clippy_lints/src/methods/unit_hash.rs b/clippy_lints/src/methods/unit_hash.rs
new file mode 100644
index 00000000000..3c7955bc469
--- /dev/null
+++ b/clippy_lints/src/methods/unit_hash.rs
@@ -0,0 +1,29 @@
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::is_trait_method;
+use clippy_utils::source::snippet;
+use rustc_errors::Applicability;
+use rustc_hir::Expr;
+use rustc_lint::LateContext;
+use rustc_span::sym;
+
+use super::UNIT_HASH;
+
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, recv: &'tcx Expr<'_>, arg: &'tcx Expr<'_>) {
+    if is_trait_method(cx, expr, sym::Hash) && cx.typeck_results().expr_ty(recv).is_unit() {
+        span_lint_and_then(
+            cx,
+            UNIT_HASH,
+            expr.span,
+            "this call to `hash` on the unit type will do nothing",
+            |diag| {
+                diag.span_suggestion(
+                    expr.span,
+                    "remove the call to `hash` or consider using",
+                    format!("0_u8.hash({})", snippet(cx, arg.span, ".."),),
+                    Applicability::MaybeIncorrect,
+                );
+                diag.note("the implementation of `Hash` for `()` is a no-op");
+            },
+        );
+    }
+}
diff --git a/clippy_lints/src/unit_hash.rs b/clippy_lints/src/unit_hash.rs
deleted file mode 100644
index 88ca0cb20a1..00000000000
--- a/clippy_lints/src/unit_hash.rs
+++ /dev/null
@@ -1,78 +0,0 @@
-use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::source::snippet;
-use rustc_errors::Applicability;
-use rustc_hir::{Expr, ExprKind};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::sym;
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Detects `().hash(_)`.
-    ///
-    /// ### Why is this bad?
-    /// Hashing a unit value doesn't do anything as the implementation of `Hash` for `()` is a no-op.
-    ///
-    /// ### Example
-    /// ```rust
-    /// # use std::hash::Hash;
-    /// # use std::collections::hash_map::DefaultHasher;
-    /// # enum Foo { Empty, WithValue(u8) }
-    /// # use Foo::*;
-    /// # let mut state = DefaultHasher::new();
-    /// # let my_enum = Foo::Empty;
-    /// match my_enum {
-    /// 	Empty => ().hash(&mut state),
-    /// 	WithValue(x) => x.hash(&mut state),
-    /// }
-    /// ```
-    /// Use instead:
-    /// ```rust
-    /// # use std::hash::Hash;
-    /// # use std::collections::hash_map::DefaultHasher;
-    /// # enum Foo { Empty, WithValue(u8) }
-    /// # use Foo::*;
-    /// # let mut state = DefaultHasher::new();
-    /// # let my_enum = Foo::Empty;
-    /// match my_enum {
-    /// 	Empty => 0_u8.hash(&mut state),
-    /// 	WithValue(x) => x.hash(&mut state),
-    /// }
-    /// ```
-    #[clippy::version = "1.58.0"]
-    pub UNIT_HASH,
-    correctness,
-    "hashing a unit value, which does nothing"
-}
-declare_lint_pass!(UnitHash => [UNIT_HASH]);
-
-impl<'tcx> LateLintPass<'tcx> for UnitHash {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
-        if_chain! {
-            if let ExprKind::MethodCall(name_ident, args, _) = &expr.kind;
-            if name_ident.ident.name == sym::hash;
-            if let [recv, state_param] = args;
-            if cx.typeck_results().expr_ty(recv).is_unit();
-            then {
-                span_lint_and_then(
-                    cx,
-                    UNIT_HASH,
-                    expr.span,
-                    "this call to `hash` on the unit type will do nothing",
-                    |diag| {
-                        diag.span_suggestion(
-                            expr.span,
-                            "remove the call to `hash` or consider using",
-                            format!(
-                                "0_u8.hash({})",
-                                snippet(cx, state_param.span, ".."),
-                            ),
-                            Applicability::MaybeIncorrect,
-                        );
-                        diag.note("the implementation of `Hash` for `()` is a no-op");
-                    }
-                );
-            }
-        }
-    }
-}
-- 
cgit 1.4.1-3-g733a5


From d8d4a135ea2bc460033c75d4a56d21ae977b9ae2 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sun, 5 Jun 2022 23:22:58 -0400
Subject: Move `UnnecessarySortBy` into `Methods` lint pass

---
 clippy_lints/src/lib.register_all.rs            |   2 +-
 clippy_lints/src/lib.register_complexity.rs     |   2 +-
 clippy_lints/src/lib.register_lints.rs          |   2 +-
 clippy_lints/src/lib.rs                         |   2 -
 clippy_lints/src/methods/mod.rs                 |  42 ++++
 clippy_lints/src/methods/unnecessary_sort_by.rs | 224 ++++++++++++++++++++
 clippy_lints/src/unnecessary_sort_by.rs         | 258 ------------------------
 7 files changed, 269 insertions(+), 263 deletions(-)
 create mode 100644 clippy_lints/src/methods/unnecessary_sort_by.rs
 delete mode 100644 clippy_lints/src/unnecessary_sort_by.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index e51ce0fa254..bb5b2866268 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -213,6 +213,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(methods::UNNECESSARY_FIND_MAP),
     LintId::of(methods::UNNECESSARY_FOLD),
     LintId::of(methods::UNNECESSARY_LAZY_EVALUATIONS),
+    LintId::of(methods::UNNECESSARY_SORT_BY),
     LintId::of(methods::UNNECESSARY_TO_OWNED),
     LintId::of(methods::UNWRAP_OR_ELSE_DEFAULT),
     LintId::of(methods::USELESS_ASREF),
@@ -334,7 +335,6 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(unnamed_address::FN_ADDRESS_COMPARISONS),
     LintId::of(unnamed_address::VTABLE_ADDRESS_COMPARISONS),
     LintId::of(unnecessary_owned_empty_strings::UNNECESSARY_OWNED_EMPTY_STRINGS),
-    LintId::of(unnecessary_sort_by::UNNECESSARY_SORT_BY),
     LintId::of(unsafe_removed_from_name::UNSAFE_REMOVED_FROM_NAME),
     LintId::of(unused_io_amount::UNUSED_IO_AMOUNT),
     LintId::of(unused_unit::UNUSED_UNIT),
diff --git a/clippy_lints/src/lib.register_complexity.rs b/clippy_lints/src/lib.register_complexity.rs
index f79105f4960..0f7433a79be 100644
--- a/clippy_lints/src/lib.register_complexity.rs
+++ b/clippy_lints/src/lib.register_complexity.rs
@@ -57,6 +57,7 @@ store.register_group(true, "clippy::complexity", Some("clippy_complexity"), vec!
     LintId::of(methods::SKIP_WHILE_NEXT),
     LintId::of(methods::UNNECESSARY_FILTER_MAP),
     LintId::of(methods::UNNECESSARY_FIND_MAP),
+    LintId::of(methods::UNNECESSARY_SORT_BY),
     LintId::of(methods::USELESS_ASREF),
     LintId::of(misc::SHORT_CIRCUIT_STATEMENT),
     LintId::of(misc_early::UNNEEDED_WILDCARD_PATTERN),
@@ -99,7 +100,6 @@ store.register_group(true, "clippy::complexity", Some("clippy_complexity"), vec!
     LintId::of(types::TYPE_COMPLEXITY),
     LintId::of(types::VEC_BOX),
     LintId::of(unit_types::UNIT_ARG),
-    LintId::of(unnecessary_sort_by::UNNECESSARY_SORT_BY),
     LintId::of(unwrap::UNNECESSARY_UNWRAP),
     LintId::of(useless_conversion::USELESS_CONVERSION),
     LintId::of(zero_div_zero::ZERO_DIVIDED_BY_ZERO),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 8aa1810fbd5..f5497c6bd6b 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -364,6 +364,7 @@ store.register_lints(&[
     methods::UNNECESSARY_FOLD,
     methods::UNNECESSARY_JOIN,
     methods::UNNECESSARY_LAZY_EVALUATIONS,
+    methods::UNNECESSARY_SORT_BY,
     methods::UNNECESSARY_TO_OWNED,
     methods::UNWRAP_OR_ELSE_DEFAULT,
     methods::UNWRAP_USED,
@@ -567,7 +568,6 @@ store.register_lints(&[
     unnamed_address::VTABLE_ADDRESS_COMPARISONS,
     unnecessary_owned_empty_strings::UNNECESSARY_OWNED_EMPTY_STRINGS,
     unnecessary_self_imports::UNNECESSARY_SELF_IMPORTS,
-    unnecessary_sort_by::UNNECESSARY_SORT_BY,
     unnecessary_wraps::UNNECESSARY_WRAPS,
     unnested_or_patterns::UNNESTED_OR_PATTERNS,
     unsafe_removed_from_name::UNSAFE_REMOVED_FROM_NAME,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 71ba3f18da8..cfcd4e3d141 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -376,7 +376,6 @@ mod unit_types;
 mod unnamed_address;
 mod unnecessary_owned_empty_strings;
 mod unnecessary_self_imports;
-mod unnecessary_sort_by;
 mod unnecessary_wraps;
 mod unnested_or_patterns;
 mod unsafe_removed_from_name;
@@ -716,7 +715,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(ptr_offset_with_cast::PtrOffsetWithCast));
     store.register_late_pass(|| Box::new(redundant_clone::RedundantClone));
     store.register_late_pass(|| Box::new(slow_vector_initialization::SlowVectorInit));
-    store.register_late_pass(|| Box::new(unnecessary_sort_by::UnnecessarySortBy));
     store.register_late_pass(move || Box::new(unnecessary_wraps::UnnecessaryWraps::new(avoid_breaking_exported_api)));
     store.register_late_pass(|| Box::new(assertions_on_constants::AssertionsOnConstants));
     store.register_late_pass(|| Box::new(assertions_on_result_states::AssertionsOnResultStates));
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index ce10b64c948..54a0275da96 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -84,6 +84,7 @@ mod unnecessary_fold;
 mod unnecessary_iter_cloned;
 mod unnecessary_join;
 mod unnecessary_lazy_eval;
+mod unnecessary_sort_by;
 mod unnecessary_to_owned;
 mod unwrap_or_else_default;
 mod unwrap_used;
@@ -2872,6 +2873,40 @@ declare_clippy_lint! {
     "hashing a unit value, which does nothing"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Detects uses of `Vec::sort_by` passing in a closure
+    /// which compares the two arguments, either directly or indirectly.
+    ///
+    /// ### Why is this bad?
+    /// It is more clear to use `Vec::sort_by_key` (or `Vec::sort` if
+    /// possible) than to use `Vec::sort_by` and a more complicated
+    /// closure.
+    ///
+    /// ### Known problems
+    /// If the suggested `Vec::sort_by_key` uses Reverse and it isn't already
+    /// imported by a use statement, then it will need to be added manually.
+    ///
+    /// ### Example
+    /// ```rust
+    /// # struct A;
+    /// # impl A { fn foo(&self) {} }
+    /// # let mut vec: Vec<A> = Vec::new();
+    /// vec.sort_by(|a, b| a.foo().cmp(&b.foo()));
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// # struct A;
+    /// # impl A { fn foo(&self) {} }
+    /// # let mut vec: Vec<A> = Vec::new();
+    /// vec.sort_by_key(|a| a.foo());
+    /// ```
+    #[clippy::version = "1.46.0"]
+    pub UNNECESSARY_SORT_BY,
+    complexity,
+    "Use of `Vec::sort_by` when `Vec::sort_by_key` or `Vec::sort` would be clearer"
+}
+
 pub struct Methods {
     avoid_breaking_exported_api: bool,
     msrv: Option<RustcVersion>,
@@ -2990,6 +3025,7 @@ impl_lint_pass!(Methods => [
     REPEAT_ONCE,
     STABLE_SORT_PRIMITIVE,
     UNIT_HASH,
+    UNNECESSARY_SORT_BY,
 ]);
 
 /// Extracts a method call name, args, and `Span` of the method name.
@@ -3387,6 +3423,12 @@ impl Methods {
                 ("sort", []) => {
                     stable_sort_primitive::check(cx, expr, recv);
                 },
+                ("sort_by", [arg]) => {
+                    unnecessary_sort_by::check(cx, expr, recv, arg, false);
+                },
+                ("sort_unstable_by", [arg]) => {
+                    unnecessary_sort_by::check(cx, expr, recv, arg, true);
+                },
                 ("splitn" | "rsplitn", [count_arg, pat_arg]) => {
                     if let Some((Constant::Int(count), _)) = constant(cx, cx.typeck_results(), count_arg) {
                         suspicious_splitn::check(cx, name, expr, recv, count);
diff --git a/clippy_lints/src/methods/unnecessary_sort_by.rs b/clippy_lints/src/methods/unnecessary_sort_by.rs
new file mode 100644
index 00000000000..1966990bd77
--- /dev/null
+++ b/clippy_lints/src/methods/unnecessary_sort_by.rs
@@ -0,0 +1,224 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::is_trait_method;
+use clippy_utils::sugg::Sugg;
+use clippy_utils::ty::implements_trait;
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir::{Closure, Expr, ExprKind, Mutability, Param, Pat, PatKind, Path, PathSegment, QPath};
+use rustc_lint::LateContext;
+use rustc_middle::ty::{self, subst::GenericArgKind};
+use rustc_span::sym;
+use rustc_span::symbol::Ident;
+use std::iter;
+
+use super::UNNECESSARY_SORT_BY;
+
+enum LintTrigger {
+    Sort(SortDetection),
+    SortByKey(SortByKeyDetection),
+}
+
+struct SortDetection {
+    vec_name: String,
+}
+
+struct SortByKeyDetection {
+    vec_name: String,
+    closure_arg: String,
+    closure_body: String,
+    reverse: bool,
+}
+
+/// Detect if the two expressions are mirrored (identical, except one
+/// contains a and the other replaces it with b)
+fn mirrored_exprs(a_expr: &Expr<'_>, a_ident: &Ident, b_expr: &Expr<'_>, b_ident: &Ident) -> bool {
+    match (&a_expr.kind, &b_expr.kind) {
+        // Two boxes with mirrored contents
+        (ExprKind::Box(left_expr), ExprKind::Box(right_expr)) => {
+            mirrored_exprs(left_expr, a_ident, right_expr, b_ident)
+        },
+        // Two arrays with mirrored contents
+        (ExprKind::Array(left_exprs), ExprKind::Array(right_exprs)) => {
+            iter::zip(*left_exprs, *right_exprs).all(|(left, right)| mirrored_exprs(left, a_ident, right, b_ident))
+        },
+        // The two exprs are function calls.
+        // Check to see that the function itself and its arguments are mirrored
+        (ExprKind::Call(left_expr, left_args), ExprKind::Call(right_expr, right_args)) => {
+            mirrored_exprs(left_expr, a_ident, right_expr, b_ident)
+                && iter::zip(*left_args, *right_args).all(|(left, right)| mirrored_exprs(left, a_ident, right, b_ident))
+        },
+        // The two exprs are method calls.
+        // Check to see that the function is the same and the arguments are mirrored
+        // This is enough because the receiver of the method is listed in the arguments
+        (ExprKind::MethodCall(left_segment, left_args, _), ExprKind::MethodCall(right_segment, right_args, _)) => {
+            left_segment.ident == right_segment.ident
+                && iter::zip(*left_args, *right_args).all(|(left, right)| mirrored_exprs(left, a_ident, right, b_ident))
+        },
+        // Two tuples with mirrored contents
+        (ExprKind::Tup(left_exprs), ExprKind::Tup(right_exprs)) => {
+            iter::zip(*left_exprs, *right_exprs).all(|(left, right)| mirrored_exprs(left, a_ident, right, b_ident))
+        },
+        // Two binary ops, which are the same operation and which have mirrored arguments
+        (ExprKind::Binary(left_op, left_left, left_right), ExprKind::Binary(right_op, right_left, right_right)) => {
+            left_op.node == right_op.node
+                && mirrored_exprs(left_left, a_ident, right_left, b_ident)
+                && mirrored_exprs(left_right, a_ident, right_right, b_ident)
+        },
+        // Two unary ops, which are the same operation and which have the same argument
+        (ExprKind::Unary(left_op, left_expr), ExprKind::Unary(right_op, right_expr)) => {
+            left_op == right_op && mirrored_exprs(left_expr, a_ident, right_expr, b_ident)
+        },
+        // The two exprs are literals of some kind
+        (ExprKind::Lit(left_lit), ExprKind::Lit(right_lit)) => left_lit.node == right_lit.node,
+        (ExprKind::Cast(left, _), ExprKind::Cast(right, _)) => mirrored_exprs(left, a_ident, right, b_ident),
+        (ExprKind::DropTemps(left_block), ExprKind::DropTemps(right_block)) => {
+            mirrored_exprs(left_block, a_ident, right_block, b_ident)
+        },
+        (ExprKind::Field(left_expr, left_ident), ExprKind::Field(right_expr, right_ident)) => {
+            left_ident.name == right_ident.name && mirrored_exprs(left_expr, a_ident, right_expr, right_ident)
+        },
+        // Two paths: either one is a and the other is b, or they're identical to each other
+        (
+            ExprKind::Path(QPath::Resolved(
+                _,
+                Path {
+                    segments: left_segments,
+                    ..
+                },
+            )),
+            ExprKind::Path(QPath::Resolved(
+                _,
+                Path {
+                    segments: right_segments,
+                    ..
+                },
+            )),
+        ) => {
+            (iter::zip(*left_segments, *right_segments).all(|(left, right)| left.ident == right.ident)
+                && left_segments
+                    .iter()
+                    .all(|seg| &seg.ident != a_ident && &seg.ident != b_ident))
+                || (left_segments.len() == 1
+                    && &left_segments[0].ident == a_ident
+                    && right_segments.len() == 1
+                    && &right_segments[0].ident == b_ident)
+        },
+        // Matching expressions, but one or both is borrowed
+        (
+            ExprKind::AddrOf(left_kind, Mutability::Not, left_expr),
+            ExprKind::AddrOf(right_kind, Mutability::Not, right_expr),
+        ) => left_kind == right_kind && mirrored_exprs(left_expr, a_ident, right_expr, b_ident),
+        (_, ExprKind::AddrOf(_, Mutability::Not, right_expr)) => mirrored_exprs(a_expr, a_ident, right_expr, b_ident),
+        (ExprKind::AddrOf(_, Mutability::Not, left_expr), _) => mirrored_exprs(left_expr, a_ident, b_expr, b_ident),
+        _ => false,
+    }
+}
+
+fn detect_lint(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'_>, arg: &Expr<'_>) -> Option<LintTrigger> {
+    if_chain! {
+        if let Some(method_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
+        if let Some(impl_id) = cx.tcx.impl_of_method(method_id);
+        if cx.tcx.type_of(impl_id).is_slice();
+        if let ExprKind::Closure(&Closure { body, .. }) = arg.kind;
+        if let closure_body = cx.tcx.hir().body(body);
+        if let &[
+            Param { pat: Pat { kind: PatKind::Binding(_, _, left_ident, _), .. }, ..},
+            Param { pat: Pat { kind: PatKind::Binding(_, _, right_ident, _), .. }, .. }
+        ] = &closure_body.params;
+        if let ExprKind::MethodCall(method_path, [left_expr, right_expr], _) = closure_body.value.kind;
+        if method_path.ident.name == sym::cmp;
+        if is_trait_method(cx, &closure_body.value, sym::Ord);
+        then {
+            let (closure_body, closure_arg, reverse) = if mirrored_exprs(
+                left_expr,
+                left_ident,
+                right_expr,
+                right_ident
+            ) {
+                (Sugg::hir(cx, left_expr, "..").to_string(), left_ident.name.to_string(), false)
+            } else if mirrored_exprs(left_expr, right_ident, right_expr, left_ident) {
+                (Sugg::hir(cx, left_expr, "..").to_string(), right_ident.name.to_string(), true)
+            } else {
+                return None;
+            };
+            let vec_name = Sugg::hir(cx, recv, "..").to_string();
+
+            if_chain! {
+                if let ExprKind::Path(QPath::Resolved(_, Path {
+                    segments: [PathSegment { ident: left_name, .. }], ..
+                })) = &left_expr.kind;
+                if left_name == left_ident;
+                if cx.tcx.get_diagnostic_item(sym::Ord).map_or(false, |id| {
+                    implements_trait(cx, cx.typeck_results().expr_ty(left_expr), id, &[])
+                });
+                then {
+                    return Some(LintTrigger::Sort(SortDetection { vec_name }));
+                }
+            }
+
+            if !expr_borrows(cx, left_expr) {
+                return Some(LintTrigger::SortByKey(SortByKeyDetection {
+                    vec_name,
+                    closure_arg,
+                    closure_body,
+                    reverse,
+                }));
+            }
+        }
+    }
+
+    None
+}
+
+fn expr_borrows(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+    let ty = cx.typeck_results().expr_ty(expr);
+    matches!(ty.kind(), ty::Ref(..)) || ty.walk().any(|arg| matches!(arg.unpack(), GenericArgKind::Lifetime(_)))
+}
+
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx Expr<'_>,
+    recv: &'tcx Expr<'_>,
+    arg: &'tcx Expr<'_>,
+    is_unstable: bool,
+) {
+    match detect_lint(cx, expr, recv, arg) {
+        Some(LintTrigger::SortByKey(trigger)) => span_lint_and_sugg(
+            cx,
+            UNNECESSARY_SORT_BY,
+            expr.span,
+            "use Vec::sort_by_key here instead",
+            "try",
+            format!(
+                "{}.sort{}_by_key(|{}| {})",
+                trigger.vec_name,
+                if is_unstable { "_unstable" } else { "" },
+                trigger.closure_arg,
+                if trigger.reverse {
+                    format!("std::cmp::Reverse({})", trigger.closure_body)
+                } else {
+                    trigger.closure_body.to_string()
+                },
+            ),
+            if trigger.reverse {
+                Applicability::MaybeIncorrect
+            } else {
+                Applicability::MachineApplicable
+            },
+        ),
+        Some(LintTrigger::Sort(trigger)) => span_lint_and_sugg(
+            cx,
+            UNNECESSARY_SORT_BY,
+            expr.span,
+            "use Vec::sort here instead",
+            "try",
+            format!(
+                "{}.sort{}()",
+                trigger.vec_name,
+                if is_unstable { "_unstable" } else { "" },
+            ),
+            Applicability::MachineApplicable,
+        ),
+        None => {},
+    }
+}
diff --git a/clippy_lints/src/unnecessary_sort_by.rs b/clippy_lints/src/unnecessary_sort_by.rs
deleted file mode 100644
index ea5aadbbca1..00000000000
--- a/clippy_lints/src/unnecessary_sort_by.rs
+++ /dev/null
@@ -1,258 +0,0 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::sugg::Sugg;
-use clippy_utils::ty::{implements_trait, is_type_diagnostic_item};
-use if_chain::if_chain;
-use rustc_errors::Applicability;
-use rustc_hir::{Closure, Expr, ExprKind, Mutability, Param, Pat, PatKind, Path, PathSegment, QPath};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty::{self, subst::GenericArgKind};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::sym;
-use rustc_span::symbol::Ident;
-use std::iter;
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Detects uses of `Vec::sort_by` passing in a closure
-    /// which compares the two arguments, either directly or indirectly.
-    ///
-    /// ### Why is this bad?
-    /// It is more clear to use `Vec::sort_by_key` (or `Vec::sort` if
-    /// possible) than to use `Vec::sort_by` and a more complicated
-    /// closure.
-    ///
-    /// ### Known problems
-    /// If the suggested `Vec::sort_by_key` uses Reverse and it isn't already
-    /// imported by a use statement, then it will need to be added manually.
-    ///
-    /// ### Example
-    /// ```rust
-    /// # struct A;
-    /// # impl A { fn foo(&self) {} }
-    /// # let mut vec: Vec<A> = Vec::new();
-    /// vec.sort_by(|a, b| a.foo().cmp(&b.foo()));
-    /// ```
-    /// Use instead:
-    /// ```rust
-    /// # struct A;
-    /// # impl A { fn foo(&self) {} }
-    /// # let mut vec: Vec<A> = Vec::new();
-    /// vec.sort_by_key(|a| a.foo());
-    /// ```
-    #[clippy::version = "1.46.0"]
-    pub UNNECESSARY_SORT_BY,
-    complexity,
-    "Use of `Vec::sort_by` when `Vec::sort_by_key` or `Vec::sort` would be clearer"
-}
-
-declare_lint_pass!(UnnecessarySortBy => [UNNECESSARY_SORT_BY]);
-
-enum LintTrigger {
-    Sort(SortDetection),
-    SortByKey(SortByKeyDetection),
-}
-
-struct SortDetection {
-    vec_name: String,
-    unstable: bool,
-}
-
-struct SortByKeyDetection {
-    vec_name: String,
-    closure_arg: String,
-    closure_body: String,
-    reverse: bool,
-    unstable: bool,
-}
-
-/// Detect if the two expressions are mirrored (identical, except one
-/// contains a and the other replaces it with b)
-fn mirrored_exprs(a_expr: &Expr<'_>, a_ident: &Ident, b_expr: &Expr<'_>, b_ident: &Ident) -> bool {
-    match (&a_expr.kind, &b_expr.kind) {
-        // Two boxes with mirrored contents
-        (ExprKind::Box(left_expr), ExprKind::Box(right_expr)) => {
-            mirrored_exprs(left_expr, a_ident, right_expr, b_ident)
-        },
-        // Two arrays with mirrored contents
-        (ExprKind::Array(left_exprs), ExprKind::Array(right_exprs)) => {
-            iter::zip(*left_exprs, *right_exprs).all(|(left, right)| mirrored_exprs(left, a_ident, right, b_ident))
-        },
-        // The two exprs are function calls.
-        // Check to see that the function itself and its arguments are mirrored
-        (ExprKind::Call(left_expr, left_args), ExprKind::Call(right_expr, right_args)) => {
-            mirrored_exprs(left_expr, a_ident, right_expr, b_ident)
-                && iter::zip(*left_args, *right_args).all(|(left, right)| mirrored_exprs(left, a_ident, right, b_ident))
-        },
-        // The two exprs are method calls.
-        // Check to see that the function is the same and the arguments are mirrored
-        // This is enough because the receiver of the method is listed in the arguments
-        (ExprKind::MethodCall(left_segment, left_args, _), ExprKind::MethodCall(right_segment, right_args, _)) => {
-            left_segment.ident == right_segment.ident
-                && iter::zip(*left_args, *right_args).all(|(left, right)| mirrored_exprs(left, a_ident, right, b_ident))
-        },
-        // Two tuples with mirrored contents
-        (ExprKind::Tup(left_exprs), ExprKind::Tup(right_exprs)) => {
-            iter::zip(*left_exprs, *right_exprs).all(|(left, right)| mirrored_exprs(left, a_ident, right, b_ident))
-        },
-        // Two binary ops, which are the same operation and which have mirrored arguments
-        (ExprKind::Binary(left_op, left_left, left_right), ExprKind::Binary(right_op, right_left, right_right)) => {
-            left_op.node == right_op.node
-                && mirrored_exprs(left_left, a_ident, right_left, b_ident)
-                && mirrored_exprs(left_right, a_ident, right_right, b_ident)
-        },
-        // Two unary ops, which are the same operation and which have the same argument
-        (ExprKind::Unary(left_op, left_expr), ExprKind::Unary(right_op, right_expr)) => {
-            left_op == right_op && mirrored_exprs(left_expr, a_ident, right_expr, b_ident)
-        },
-        // The two exprs are literals of some kind
-        (ExprKind::Lit(left_lit), ExprKind::Lit(right_lit)) => left_lit.node == right_lit.node,
-        (ExprKind::Cast(left, _), ExprKind::Cast(right, _)) => mirrored_exprs(left, a_ident, right, b_ident),
-        (ExprKind::DropTemps(left_block), ExprKind::DropTemps(right_block)) => {
-            mirrored_exprs(left_block, a_ident, right_block, b_ident)
-        },
-        (ExprKind::Field(left_expr, left_ident), ExprKind::Field(right_expr, right_ident)) => {
-            left_ident.name == right_ident.name && mirrored_exprs(left_expr, a_ident, right_expr, right_ident)
-        },
-        // Two paths: either one is a and the other is b, or they're identical to each other
-        (
-            ExprKind::Path(QPath::Resolved(
-                _,
-                Path {
-                    segments: left_segments,
-                    ..
-                },
-            )),
-            ExprKind::Path(QPath::Resolved(
-                _,
-                Path {
-                    segments: right_segments,
-                    ..
-                },
-            )),
-        ) => {
-            (iter::zip(*left_segments, *right_segments).all(|(left, right)| left.ident == right.ident)
-                && left_segments
-                    .iter()
-                    .all(|seg| &seg.ident != a_ident && &seg.ident != b_ident))
-                || (left_segments.len() == 1
-                    && &left_segments[0].ident == a_ident
-                    && right_segments.len() == 1
-                    && &right_segments[0].ident == b_ident)
-        },
-        // Matching expressions, but one or both is borrowed
-        (
-            ExprKind::AddrOf(left_kind, Mutability::Not, left_expr),
-            ExprKind::AddrOf(right_kind, Mutability::Not, right_expr),
-        ) => left_kind == right_kind && mirrored_exprs(left_expr, a_ident, right_expr, b_ident),
-        (_, ExprKind::AddrOf(_, Mutability::Not, right_expr)) => mirrored_exprs(a_expr, a_ident, right_expr, b_ident),
-        (ExprKind::AddrOf(_, Mutability::Not, left_expr), _) => mirrored_exprs(left_expr, a_ident, b_expr, b_ident),
-        _ => false,
-    }
-}
-
-fn detect_lint(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<LintTrigger> {
-    if_chain! {
-        if let ExprKind::MethodCall(name_ident, args, _) = &expr.kind;
-        if let name = name_ident.ident.name.to_ident_string();
-        if name == "sort_by" || name == "sort_unstable_by";
-        if let [vec, Expr { kind: ExprKind::Closure(Closure { body: closure_body_id, .. }), .. }] = args;
-        if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(vec), sym::Vec);
-        if let closure_body = cx.tcx.hir().body(*closure_body_id);
-        if let &[
-            Param { pat: Pat { kind: PatKind::Binding(_, _, left_ident, _), .. }, ..},
-            Param { pat: Pat { kind: PatKind::Binding(_, _, right_ident, _), .. }, .. }
-        ] = &closure_body.params;
-        if let ExprKind::MethodCall(method_path, [ref left_expr, ref right_expr], _) = &closure_body.value.kind;
-        if method_path.ident.name == sym::cmp;
-        then {
-            let (closure_body, closure_arg, reverse) = if mirrored_exprs(
-                left_expr,
-                left_ident,
-                right_expr,
-                right_ident
-            ) {
-                (Sugg::hir(cx, left_expr, "..").to_string(), left_ident.name.to_string(), false)
-            } else if mirrored_exprs(left_expr, right_ident, right_expr, left_ident) {
-                (Sugg::hir(cx, left_expr, "..").to_string(), right_ident.name.to_string(), true)
-            } else {
-                return None;
-            };
-            let vec_name = Sugg::hir(cx, &args[0], "..").to_string();
-            let unstable = name == "sort_unstable_by";
-
-            if_chain! {
-            if let ExprKind::Path(QPath::Resolved(_, Path {
-                segments: [PathSegment { ident: left_name, .. }], ..
-            })) = &left_expr.kind;
-            if left_name == left_ident;
-            if cx.tcx.get_diagnostic_item(sym::Ord).map_or(false, |id| {
-                implements_trait(cx, cx.typeck_results().expr_ty(left_expr), id, &[])
-            });
-                then {
-                    return Some(LintTrigger::Sort(SortDetection { vec_name, unstable }));
-                }
-            }
-
-            if !expr_borrows(cx, left_expr) {
-                return Some(LintTrigger::SortByKey(SortByKeyDetection {
-                    vec_name,
-                    closure_arg,
-                    closure_body,
-                    reverse,
-                    unstable,
-                }));
-            }
-        }
-    }
-
-    None
-}
-
-fn expr_borrows(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-    let ty = cx.typeck_results().expr_ty(expr);
-    matches!(ty.kind(), ty::Ref(..)) || ty.walk().any(|arg| matches!(arg.unpack(), GenericArgKind::Lifetime(_)))
-}
-
-impl LateLintPass<'_> for UnnecessarySortBy {
-    fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
-        match detect_lint(cx, expr) {
-            Some(LintTrigger::SortByKey(trigger)) => span_lint_and_sugg(
-                cx,
-                UNNECESSARY_SORT_BY,
-                expr.span,
-                "use Vec::sort_by_key here instead",
-                "try",
-                format!(
-                    "{}.sort{}_by_key(|{}| {})",
-                    trigger.vec_name,
-                    if trigger.unstable { "_unstable" } else { "" },
-                    trigger.closure_arg,
-                    if trigger.reverse {
-                        format!("std::cmp::Reverse({})", trigger.closure_body)
-                    } else {
-                        trigger.closure_body.to_string()
-                    },
-                ),
-                if trigger.reverse {
-                    Applicability::MaybeIncorrect
-                } else {
-                    Applicability::MachineApplicable
-                },
-            ),
-            Some(LintTrigger::Sort(trigger)) => span_lint_and_sugg(
-                cx,
-                UNNECESSARY_SORT_BY,
-                expr.span,
-                "use Vec::sort here instead",
-                "try",
-                format!(
-                    "{}.sort{}()",
-                    trigger.vec_name,
-                    if trigger.unstable { "_unstable" } else { "" },
-                ),
-                Applicability::MachineApplicable,
-            ),
-            None => {},
-        }
-    }
-}
-- 
cgit 1.4.1-3-g733a5


From 8acc4d2f1e255e0e97e48b7a285a7d6db4a03bd6 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Mon, 6 Jun 2022 11:17:38 -0400
Subject: Move `VecResizeToZero` into `Methods` lint pass

---
 clippy_lints/src/lib.register_all.rs           |  2 +-
 clippy_lints/src/lib.register_correctness.rs   |  2 +-
 clippy_lints/src/lib.register_lints.rs         |  2 +-
 clippy_lints/src/lib.rs                        |  2 -
 clippy_lints/src/methods/mod.rs                | 27 +++++++++++
 clippy_lints/src/methods/vec_resize_to_zero.rs | 45 ++++++++++++++++++
 clippy_lints/src/vec_resize_to_zero.rs         | 64 --------------------------
 tests/ui/vec_resize_to_zero.rs                 | 12 +++--
 tests/ui/vec_resize_to_zero.stderr             | 10 ++--
 9 files changed, 88 insertions(+), 78 deletions(-)
 create mode 100644 clippy_lints/src/methods/vec_resize_to_zero.rs
 delete mode 100644 clippy_lints/src/vec_resize_to_zero.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index bb5b2866268..4128096b43a 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -217,6 +217,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(methods::UNNECESSARY_TO_OWNED),
     LintId::of(methods::UNWRAP_OR_ELSE_DEFAULT),
     LintId::of(methods::USELESS_ASREF),
+    LintId::of(methods::VEC_RESIZE_TO_ZERO),
     LintId::of(methods::WRONG_SELF_CONVENTION),
     LintId::of(methods::ZST_OFFSET),
     LintId::of(minmax::MIN_MAX),
@@ -344,7 +345,6 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(useless_conversion::USELESS_CONVERSION),
     LintId::of(vec::USELESS_VEC),
     LintId::of(vec_init_then_push::VEC_INIT_THEN_PUSH),
-    LintId::of(vec_resize_to_zero::VEC_RESIZE_TO_ZERO),
     LintId::of(write::POSITIONAL_NAMED_FORMAT_PARAMETERS),
     LintId::of(write::PRINTLN_EMPTY_STRING),
     LintId::of(write::PRINT_LITERAL),
diff --git a/clippy_lints/src/lib.register_correctness.rs b/clippy_lints/src/lib.register_correctness.rs
index d30e69b2240..bb94037ec2e 100644
--- a/clippy_lints/src/lib.register_correctness.rs
+++ b/clippy_lints/src/lib.register_correctness.rs
@@ -43,6 +43,7 @@ store.register_group(true, "clippy::correctness", Some("clippy_correctness"), ve
     LintId::of(methods::SUSPICIOUS_SPLITN),
     LintId::of(methods::UNINIT_ASSUMED_INIT),
     LintId::of(methods::UNIT_HASH),
+    LintId::of(methods::VEC_RESIZE_TO_ZERO),
     LintId::of(methods::ZST_OFFSET),
     LintId::of(minmax::MIN_MAX),
     LintId::of(non_octal_unix_permissions::NON_OCTAL_UNIX_PERMISSIONS),
@@ -74,5 +75,4 @@ store.register_group(true, "clippy::correctness", Some("clippy_correctness"), ve
     LintId::of(unnamed_address::VTABLE_ADDRESS_COMPARISONS),
     LintId::of(unused_io_amount::UNUSED_IO_AMOUNT),
     LintId::of(unwrap::PANICKING_UNWRAP),
-    LintId::of(vec_resize_to_zero::VEC_RESIZE_TO_ZERO),
 ])
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index f5497c6bd6b..1b275516dfc 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -369,6 +369,7 @@ store.register_lints(&[
     methods::UNWRAP_OR_ELSE_DEFAULT,
     methods::UNWRAP_USED,
     methods::USELESS_ASREF,
+    methods::VEC_RESIZE_TO_ZERO,
     methods::WRONG_SELF_CONVENTION,
     methods::ZST_OFFSET,
     minmax::MIN_MAX,
@@ -584,7 +585,6 @@ store.register_lints(&[
     useless_conversion::USELESS_CONVERSION,
     vec::USELESS_VEC,
     vec_init_then_push::VEC_INIT_THEN_PUSH,
-    vec_resize_to_zero::VEC_RESIZE_TO_ZERO,
     verbose_file_reads::VERBOSE_FILE_READS,
     wildcard_imports::ENUM_GLOB_USE,
     wildcard_imports::WILDCARD_IMPORTS,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index cfcd4e3d141..ff68fbd1964 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -391,7 +391,6 @@ mod use_self;
 mod useless_conversion;
 mod vec;
 mod vec_init_then_push;
-mod vec_resize_to_zero;
 mod verbose_file_reads;
 mod wildcard_imports;
 mod write;
@@ -803,7 +802,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(if_not_else::IfNotElse));
     store.register_late_pass(|| Box::new(equatable_if_let::PatternEquality));
     store.register_late_pass(|| Box::new(manual_async_fn::ManualAsyncFn));
-    store.register_late_pass(|| Box::new(vec_resize_to_zero::VecResizeToZero));
     store.register_late_pass(|| Box::new(panic_in_result_fn::PanicInResultFn));
     let single_char_binding_names_threshold = conf.single_char_binding_names_threshold;
     store.register_early_pass(move || {
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 54a0275da96..1a225c9bc95 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -90,6 +90,7 @@ mod unwrap_or_else_default;
 mod unwrap_used;
 mod useless_asref;
 mod utils;
+mod vec_resize_to_zero;
 mod wrong_self_convention;
 mod zst_offset;
 
@@ -2907,6 +2908,28 @@ declare_clippy_lint! {
     "Use of `Vec::sort_by` when `Vec::sort_by_key` or `Vec::sort` would be clearer"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Finds occurrences of `Vec::resize(0, an_int)`
+    ///
+    /// ### Why is this bad?
+    /// This is probably an argument inversion mistake.
+    ///
+    /// ### Example
+    /// ```rust
+    /// vec!(1, 2, 3, 4, 5).resize(0, 5)
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust
+    /// vec!(1, 2, 3, 4, 5).clear()
+    /// ```
+    #[clippy::version = "1.46.0"]
+    pub VEC_RESIZE_TO_ZERO,
+    correctness,
+    "emptying a vector with `resize(0, an_int)` instead of `clear()` is probably an argument inversion mistake"
+}
+
 pub struct Methods {
     avoid_breaking_exported_api: bool,
     msrv: Option<RustcVersion>,
@@ -3026,6 +3049,7 @@ impl_lint_pass!(Methods => [
     STABLE_SORT_PRIMITIVE,
     UNIT_HASH,
     UNNECESSARY_SORT_BY,
+    VEC_RESIZE_TO_ZERO,
 ]);
 
 /// Extracts a method call name, args, and `Span` of the method name.
@@ -3420,6 +3444,9 @@ impl Methods {
                 ("repeat", [arg]) => {
                     repeat_once::check(cx, expr, recv, arg);
                 },
+                ("resize", [count_arg, default_arg]) => {
+                    vec_resize_to_zero::check(cx, expr, count_arg, default_arg, span);
+                },
                 ("sort", []) => {
                     stable_sort_primitive::check(cx, expr, recv);
                 },
diff --git a/clippy_lints/src/methods/vec_resize_to_zero.rs b/clippy_lints/src/methods/vec_resize_to_zero.rs
new file mode 100644
index 00000000000..02d8364cb29
--- /dev/null
+++ b/clippy_lints/src/methods/vec_resize_to_zero.rs
@@ -0,0 +1,45 @@
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::ty::is_type_diagnostic_item;
+use if_chain::if_chain;
+use rustc_ast::LitKind;
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind};
+use rustc_lint::LateContext;
+use rustc_span::source_map::Spanned;
+use rustc_span::{sym, Span};
+
+use super::VEC_RESIZE_TO_ZERO;
+
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx Expr<'_>,
+    count_arg: &'tcx Expr<'_>,
+    default_arg: &'tcx Expr<'_>,
+    name_span: Span,
+) {
+    if_chain! {
+        if let Some(method_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
+        if let Some(impl_id) = cx.tcx.impl_of_method(method_id);
+        if is_type_diagnostic_item(cx, cx.tcx.type_of(impl_id), sym::Vec);
+        if let ExprKind::Lit(Spanned { node: LitKind::Int(0, _), .. }) = count_arg.kind;
+        if let ExprKind::Lit(Spanned { node: LitKind::Int(..), .. }) = default_arg.kind;
+        then {
+            let method_call_span = expr.span.with_lo(name_span.lo());
+            span_lint_and_then(
+                cx,
+                VEC_RESIZE_TO_ZERO,
+                expr.span,
+                "emptying a vector with `resize`",
+                |db| {
+                    db.help("the arguments may be inverted...");
+                    db.span_suggestion(
+                        method_call_span,
+                        "...or you can empty the vector with",
+                        "clear()".to_string(),
+                        Applicability::MaybeIncorrect,
+                    );
+                },
+            );
+        }
+    }
+}
diff --git a/clippy_lints/src/vec_resize_to_zero.rs b/clippy_lints/src/vec_resize_to_zero.rs
deleted file mode 100644
index 0fee3e812d2..00000000000
--- a/clippy_lints/src/vec_resize_to_zero.rs
+++ /dev/null
@@ -1,64 +0,0 @@
-use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::{match_def_path, paths};
-use if_chain::if_chain;
-use rustc_ast::LitKind;
-use rustc_errors::Applicability;
-use rustc_hir as hir;
-use rustc_hir::{Expr, ExprKind};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::source_map::Spanned;
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Finds occurrences of `Vec::resize(0, an_int)`
-    ///
-    /// ### Why is this bad?
-    /// This is probably an argument inversion mistake.
-    ///
-    /// ### Example
-    /// ```rust
-    /// vec!(1, 2, 3, 4, 5).resize(0, 5)
-    /// ```
-    ///
-    /// Use instead:
-    /// ```rust
-    /// vec!(1, 2, 3, 4, 5).clear()
-    /// ```
-    #[clippy::version = "1.46.0"]
-    pub VEC_RESIZE_TO_ZERO,
-    correctness,
-    "emptying a vector with `resize(0, an_int)` instead of `clear()` is probably an argument inversion mistake"
-}
-
-declare_lint_pass!(VecResizeToZero => [VEC_RESIZE_TO_ZERO]);
-
-impl<'tcx> LateLintPass<'tcx> for VecResizeToZero {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if_chain! {
-            if let hir::ExprKind::MethodCall(path_segment, args, _) = expr.kind;
-            if let Some(method_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
-            if match_def_path(cx, method_def_id, &paths::VEC_RESIZE) && args.len() == 3;
-            if let ExprKind::Lit(Spanned { node: LitKind::Int(0, _), .. }) = args[1].kind;
-            if let ExprKind::Lit(Spanned { node: LitKind::Int(..), .. }) = args[2].kind;
-            then {
-                let method_call_span = expr.span.with_lo(path_segment.ident.span.lo());
-                span_lint_and_then(
-                    cx,
-                    VEC_RESIZE_TO_ZERO,
-                    expr.span,
-                    "emptying a vector with `resize`",
-                    |db| {
-                        db.help("the arguments may be inverted...");
-                        db.span_suggestion(
-                            method_call_span,
-                            "...or you can empty the vector with",
-                            "clear()".to_string(),
-                            Applicability::MaybeIncorrect,
-                        );
-                    },
-                );
-            }
-        }
-    }
-}
diff --git a/tests/ui/vec_resize_to_zero.rs b/tests/ui/vec_resize_to_zero.rs
index 7ed27439ec6..a8307e741cf 100644
--- a/tests/ui/vec_resize_to_zero.rs
+++ b/tests/ui/vec_resize_to_zero.rs
@@ -1,15 +1,19 @@
 #![warn(clippy::vec_resize_to_zero)]
 
 fn main() {
+    let mut v = vec![1, 2, 3, 4, 5];
+
     // applicable here
-    vec![1, 2, 3, 4, 5].resize(0, 5);
+    v.resize(0, 5);
 
     // not applicable
-    vec![1, 2, 3, 4, 5].resize(2, 5);
+    v.resize(2, 5);
+
+    let mut v = vec!["foo", "bar", "baz"];
 
     // applicable here, but only implemented for integer literals for now
-    vec!["foo", "bar", "baz"].resize(0, "bar");
+    v.resize(0, "bar");
 
     // not applicable
-    vec!["foo", "bar", "baz"].resize(2, "bar")
+    v.resize(2, "bar")
 }
diff --git a/tests/ui/vec_resize_to_zero.stderr b/tests/ui/vec_resize_to_zero.stderr
index feb846298c6..7428cf62d6c 100644
--- a/tests/ui/vec_resize_to_zero.stderr
+++ b/tests/ui/vec_resize_to_zero.stderr
@@ -1,10 +1,10 @@
 error: emptying a vector with `resize`
-  --> $DIR/vec_resize_to_zero.rs:5:5
+  --> $DIR/vec_resize_to_zero.rs:7:5
    |
-LL |     vec![1, 2, 3, 4, 5].resize(0, 5);
-   |     ^^^^^^^^^^^^^^^^^^^^------------
-   |                         |
-   |                         help: ...or you can empty the vector with: `clear()`
+LL |     v.resize(0, 5);
+   |     ^^------------
+   |       |
+   |       help: ...or you can empty the vector with: `clear()`
    |
    = note: `-D clippy::vec-resize-to-zero` implied by `-D warnings`
    = help: the arguments may be inverted...
-- 
cgit 1.4.1-3-g733a5


From d8808db006cf4fde950076f1112ca465bcaf72ef Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Mon, 6 Jun 2022 11:58:30 -0400
Subject: Move `VerboseFileReads` into `Methods` lint pass

---
 clippy_lints/src/lib.register_lints.rs         |  2 +-
 clippy_lints/src/lib.register_restriction.rs   |  2 +-
 clippy_lints/src/lib.rs                        |  2 -
 clippy_lints/src/methods/mod.rs                | 35 ++++++++++
 clippy_lints/src/methods/verbose_file_reads.rs | 28 ++++++++
 clippy_lints/src/verbose_file_reads.rs         | 88 --------------------------
 6 files changed, 65 insertions(+), 92 deletions(-)
 create mode 100644 clippy_lints/src/methods/verbose_file_reads.rs
 delete mode 100644 clippy_lints/src/verbose_file_reads.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 1b275516dfc..db475950086 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -370,6 +370,7 @@ store.register_lints(&[
     methods::UNWRAP_USED,
     methods::USELESS_ASREF,
     methods::VEC_RESIZE_TO_ZERO,
+    methods::VERBOSE_FILE_READS,
     methods::WRONG_SELF_CONVENTION,
     methods::ZST_OFFSET,
     minmax::MIN_MAX,
@@ -585,7 +586,6 @@ store.register_lints(&[
     useless_conversion::USELESS_CONVERSION,
     vec::USELESS_VEC,
     vec_init_then_push::VEC_INIT_THEN_PUSH,
-    verbose_file_reads::VERBOSE_FILE_READS,
     wildcard_imports::ENUM_GLOB_USE,
     wildcard_imports::WILDCARD_IMPORTS,
     write::POSITIONAL_NAMED_FORMAT_PARAMETERS,
diff --git a/clippy_lints/src/lib.register_restriction.rs b/clippy_lints/src/lib.register_restriction.rs
index 7fc5eef5f8a..dd1e1e1a8e3 100644
--- a/clippy_lints/src/lib.register_restriction.rs
+++ b/clippy_lints/src/lib.register_restriction.rs
@@ -40,6 +40,7 @@ store.register_group(true, "clippy::restriction", Some("clippy_restriction"), ve
     LintId::of(methods::GET_UNWRAP),
     LintId::of(methods::MAP_ERR_IGNORE),
     LintId::of(methods::UNWRAP_USED),
+    LintId::of(methods::VERBOSE_FILE_READS),
     LintId::of(misc_early::SEPARATED_LITERAL_SUFFIX),
     LintId::of(misc_early::UNNEEDED_FIELD_PATTERN),
     LintId::of(misc_early::UNSEPARATED_LITERAL_SUFFIX),
@@ -81,7 +82,6 @@ store.register_group(true, "clippy::restriction", Some("clippy_restriction"), ve
     LintId::of(unicode::NON_ASCII_LITERAL),
     LintId::of(unnecessary_self_imports::UNNECESSARY_SELF_IMPORTS),
     LintId::of(unwrap_in_result::UNWRAP_IN_RESULT),
-    LintId::of(verbose_file_reads::VERBOSE_FILE_READS),
     LintId::of(write::PRINT_STDERR),
     LintId::of(write::PRINT_STDOUT),
     LintId::of(write::USE_DEBUG),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index ff68fbd1964..dbea55a04d6 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -391,7 +391,6 @@ mod use_self;
 mod useless_conversion;
 mod vec;
 mod vec_init_then_push;
-mod verbose_file_reads;
 mod wildcard_imports;
 mod write;
 mod zero_div_zero;
@@ -792,7 +791,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_early_pass(|| Box::new(option_env_unwrap::OptionEnvUnwrap));
     let warn_on_all_wildcard_imports = conf.warn_on_all_wildcard_imports;
     store.register_late_pass(move || Box::new(wildcard_imports::WildcardImports::new(warn_on_all_wildcard_imports)));
-    store.register_late_pass(|| Box::new(verbose_file_reads::VerboseFileReads));
     store.register_late_pass(|| Box::new(redundant_pub_crate::RedundantPubCrate::default()));
     store.register_late_pass(|| Box::new(unnamed_address::UnnamedAddress));
     store.register_late_pass(move || Box::new(dereference::Dereferencing::new(msrv)));
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 1a225c9bc95..1cfe8c4191e 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -91,6 +91,7 @@ mod unwrap_used;
 mod useless_asref;
 mod utils;
 mod vec_resize_to_zero;
+mod verbose_file_reads;
 mod wrong_self_convention;
 mod zst_offset;
 
@@ -2930,6 +2931,33 @@ declare_clippy_lint! {
     "emptying a vector with `resize(0, an_int)` instead of `clear()` is probably an argument inversion mistake"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for use of File::read_to_end and File::read_to_string.
+    ///
+    /// ### Why is this bad?
+    /// `fs::{read, read_to_string}` provide the same functionality when `buf` is empty with fewer imports and no intermediate values.
+    /// See also: [fs::read docs](https://doc.rust-lang.org/std/fs/fn.read.html), [fs::read_to_string docs](https://doc.rust-lang.org/std/fs/fn.read_to_string.html)
+    ///
+    /// ### Example
+    /// ```rust,no_run
+    /// # use std::io::Read;
+    /// # use std::fs::File;
+    /// let mut f = File::open("foo.txt").unwrap();
+    /// let mut bytes = Vec::new();
+    /// f.read_to_end(&mut bytes).unwrap();
+    /// ```
+    /// Can be written more concisely as
+    /// ```rust,no_run
+    /// # use std::fs;
+    /// let mut bytes = fs::read("foo.txt").unwrap();
+    /// ```
+    #[clippy::version = "1.44.0"]
+    pub VERBOSE_FILE_READS,
+    restriction,
+    "use of `File::read_to_end` or `File::read_to_string`"
+}
+
 pub struct Methods {
     avoid_breaking_exported_api: bool,
     msrv: Option<RustcVersion>,
@@ -3050,6 +3078,7 @@ impl_lint_pass!(Methods => [
     UNIT_HASH,
     UNNECESSARY_SORT_BY,
     VEC_RESIZE_TO_ZERO,
+    VERBOSE_FILE_READS,
 ]);
 
 /// Extracts a method call name, args, and `Span` of the method name.
@@ -3441,6 +3470,12 @@ impl Methods {
                 ("push", [arg]) => {
                     path_buf_push_overwrite::check(cx, expr, arg);
                 },
+                ("read_to_end", [_]) => {
+                    verbose_file_reads::check(cx, expr, recv, verbose_file_reads::READ_TO_END_MSG);
+                },
+                ("read_to_string", [_]) => {
+                    verbose_file_reads::check(cx, expr, recv, verbose_file_reads::READ_TO_STRING_MSG);
+                },
                 ("repeat", [arg]) => {
                     repeat_once::check(cx, expr, recv, arg);
                 },
diff --git a/clippy_lints/src/methods/verbose_file_reads.rs b/clippy_lints/src/methods/verbose_file_reads.rs
new file mode 100644
index 00000000000..2fe5ae9a9ad
--- /dev/null
+++ b/clippy_lints/src/methods/verbose_file_reads.rs
@@ -0,0 +1,28 @@
+use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::is_trait_method;
+use clippy_utils::ty::is_type_diagnostic_item;
+use rustc_hir::{Expr, ExprKind, QPath};
+use rustc_lint::LateContext;
+use rustc_span::sym;
+
+use super::VERBOSE_FILE_READS;
+
+pub(super) const READ_TO_END_MSG: (&str, &str) = ("use of `File::read_to_end`", "consider using `fs::read` instead");
+pub(super) const READ_TO_STRING_MSG: (&str, &str) = (
+    "use of `File::read_to_string`",
+    "consider using `fs::read_to_string` instead",
+);
+
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx Expr<'_>,
+    recv: &'tcx Expr<'_>,
+    (msg, help): (&str, &str),
+) {
+    if is_trait_method(cx, expr, sym::IoRead)
+        && matches!(recv.kind, ExprKind::Path(QPath::Resolved(None, _)))
+        && is_type_diagnostic_item(cx, cx.typeck_results().expr_ty_adjusted(recv).peel_refs(), sym::File)
+    {
+        span_lint_and_help(cx, VERBOSE_FILE_READS, expr.span, msg, None, help);
+    }
+}
diff --git a/clippy_lints/src/verbose_file_reads.rs b/clippy_lints/src/verbose_file_reads.rs
deleted file mode 100644
index afd0077a658..00000000000
--- a/clippy_lints/src/verbose_file_reads.rs
+++ /dev/null
@@ -1,88 +0,0 @@
-use clippy_utils::diagnostics::span_lint_and_help;
-use clippy_utils::paths;
-use clippy_utils::ty::match_type;
-use if_chain::if_chain;
-use rustc_hir::{Expr, ExprKind, QPath};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for use of File::read_to_end and File::read_to_string.
-    ///
-    /// ### Why is this bad?
-    /// `fs::{read, read_to_string}` provide the same functionality when `buf` is empty with fewer imports and no intermediate values.
-    /// See also: [fs::read docs](https://doc.rust-lang.org/std/fs/fn.read.html), [fs::read_to_string docs](https://doc.rust-lang.org/std/fs/fn.read_to_string.html)
-    ///
-    /// ### Example
-    /// ```rust,no_run
-    /// # use std::io::Read;
-    /// # use std::fs::File;
-    /// let mut f = File::open("foo.txt").unwrap();
-    /// let mut bytes = Vec::new();
-    /// f.read_to_end(&mut bytes).unwrap();
-    /// ```
-    /// Can be written more concisely as
-    /// ```rust,no_run
-    /// # use std::fs;
-    /// let mut bytes = fs::read("foo.txt").unwrap();
-    /// ```
-    #[clippy::version = "1.44.0"]
-    pub VERBOSE_FILE_READS,
-    restriction,
-    "use of `File::read_to_end` or `File::read_to_string`"
-}
-
-declare_lint_pass!(VerboseFileReads => [VERBOSE_FILE_READS]);
-
-impl<'tcx> LateLintPass<'tcx> for VerboseFileReads {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
-        if is_file_read_to_end(cx, expr) {
-            span_lint_and_help(
-                cx,
-                VERBOSE_FILE_READS,
-                expr.span,
-                "use of `File::read_to_end`",
-                None,
-                "consider using `fs::read` instead",
-            );
-        } else if is_file_read_to_string(cx, expr) {
-            span_lint_and_help(
-                cx,
-                VERBOSE_FILE_READS,
-                expr.span,
-                "use of `File::read_to_string`",
-                None,
-                "consider using `fs::read_to_string` instead",
-            );
-        }
-    }
-}
-
-fn is_file_read_to_end<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
-    if_chain! {
-        if let ExprKind::MethodCall(method_name, [recv, ..], _) = expr.kind;
-        if method_name.ident.as_str() == "read_to_end";
-        if let ExprKind::Path(QPath::Resolved(None, _)) = &recv.kind;
-        let ty = cx.typeck_results().expr_ty(recv);
-        if match_type(cx, ty, &paths::FILE);
-        then {
-            return true
-        }
-    }
-    false
-}
-
-fn is_file_read_to_string<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
-    if_chain! {
-        if let ExprKind::MethodCall(method_name, exprs, _) = expr.kind;
-        if method_name.ident.as_str() == "read_to_string";
-        if let ExprKind::Path(QPath::Resolved(None, _)) = &exprs[0].kind;
-        let ty = cx.typeck_results().expr_ty(&exprs[0]);
-        if match_type(cx, ty, &paths::FILE);
-        then {
-            return true
-        }
-    }
-    false
-}
-- 
cgit 1.4.1-3-g733a5


From 4f049f5a695b003168125a3251f5c0295e64f261 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Thu, 18 Aug 2022 17:25:02 +0000
Subject: Refactor `FormatArgsExpn`

---
 clippy_lints/src/format.rs                      |  24 +-
 clippy_lints/src/format_args.rs                 |  31 +-
 clippy_lints/src/format_impl.rs                 |  11 +-
 clippy_lints/src/methods/uninit_assumed_init.rs |   4 +-
 clippy_lints/src/transmute/transmuting_null.rs  |   4 +-
 clippy_utils/Cargo.toml                         |   1 +
 clippy_utils/src/lib.rs                         |  15 +-
 clippy_utils/src/macros.rs                      | 674 +++++++++++++++++-------
 clippy_utils/src/paths.rs                       |   1 -
 tests/ui/format_args.fixed                      |  13 +-
 tests/ui/format_args.rs                         |  13 +-
 tests/ui/format_args.stderr                     |  42 +-
 12 files changed, 580 insertions(+), 253 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/format.rs b/clippy_lints/src/format.rs
index 925a8cb8dee..0c5851cdbed 100644
--- a/clippy_lints/src/format.rs
+++ b/clippy_lints/src/format.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::macros::{root_macro_call_first_node, FormatArgsExpn};
-use clippy_utils::source::{snippet_opt, snippet_with_applicability};
+use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::sugg::Sugg;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
@@ -56,29 +56,27 @@ impl<'tcx> LateLintPass<'tcx> for UselessFormat {
         };
 
         let mut applicability = Applicability::MachineApplicable;
-        if format_args.value_args.is_empty() {
-            match *format_args.format_string_parts {
+        if format_args.args.is_empty() {
+            match *format_args.format_string.parts {
                 [] => span_useless_format_empty(cx, call_site, "String::new()".to_owned(), applicability),
                 [_] => {
-                    if let Some(s_src) = snippet_opt(cx, format_args.format_string_span) {
-                        // Simulate macro expansion, converting {{ and }} to { and }.
-                        let s_expand = s_src.replace("{{", "{").replace("}}", "}");
-                        let sugg = format!("{}.to_string()", s_expand);
-                        span_useless_format(cx, call_site, sugg, applicability);
-                    }
+                    // Simulate macro expansion, converting {{ and }} to { and }.
+                    let s_expand = format_args.format_string.snippet.replace("{{", "{").replace("}}", "}");
+                    let sugg = format!("{}.to_string()", s_expand);
+                    span_useless_format(cx, call_site, sugg, applicability);
                 },
                 [..] => {},
             }
-        } else if let [value] = *format_args.value_args {
+        } else if let [arg] = &*format_args.args {
+            let value = arg.param.value;
             if_chain! {
-                if format_args.format_string_parts == [kw::Empty];
+                if format_args.format_string.parts == [kw::Empty];
                 if match cx.typeck_results().expr_ty(value).peel_refs().kind() {
                     ty::Adt(adt, _) => cx.tcx.is_diagnostic_item(sym::String, adt.did()),
                     ty::Str => true,
                     _ => false,
                 };
-                if let Some(args) = format_args.args();
-                if args.iter().all(|arg| arg.format_trait == sym::Display && !arg.has_string_formatting());
+                if !arg.format.has_string_formatting();
                 then {
                     let is_new_string = match value.kind {
                         ExprKind::Binary(..) => true,
diff --git a/clippy_lints/src/format_args.rs b/clippy_lints/src/format_args.rs
index 1e6feaac26c..5347ff880ce 100644
--- a/clippy_lints/src/format_args.rs
+++ b/clippy_lints/src/format_args.rs
@@ -1,11 +1,12 @@
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::is_diag_trait_item;
-use clippy_utils::macros::{is_format_macro, FormatArgsArg, FormatArgsExpn};
+use clippy_utils::macros::{is_format_macro, FormatArgsExpn};
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::implements_trait;
 use if_chain::if_chain;
+use itertools::Itertools;
 use rustc_errors::Applicability;
-use rustc_hir::{Expr, ExprKind};
+use rustc_hir::{Expr, ExprKind, HirId};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::adjustment::{Adjust, Adjustment};
 use rustc_middle::ty::Ty;
@@ -74,20 +75,16 @@ impl<'tcx> LateLintPass<'tcx> for FormatArgs {
             if let Some(macro_def_id) = outermost_expn_data.macro_def_id;
             if is_format_macro(cx, macro_def_id);
             if let ExpnKind::Macro(_, name) = outermost_expn_data.kind;
-            if let Some(args) = format_args.args();
             then {
-                for (i, arg) in args.iter().enumerate() {
-                    if arg.format_trait != sym::Display {
+                for arg in &format_args.args {
+                    if arg.format.has_string_formatting() {
                         continue;
                     }
-                    if arg.has_string_formatting() {
+                    if is_aliased(&format_args, arg.param.value.hir_id) {
                         continue;
                     }
-                    if is_aliased(&args, i) {
-                        continue;
-                    }
-                    check_format_in_format_args(cx, outermost_expn_data.call_site, name, arg.value);
-                    check_to_string_in_format_args(cx, name, arg.value);
+                    check_format_in_format_args(cx, outermost_expn_data.call_site, name, arg.param.value);
+                    check_to_string_in_format_args(cx, name, arg.param.value);
                 }
             }
         }
@@ -167,12 +164,12 @@ fn check_to_string_in_format_args(cx: &LateContext<'_>, name: Symbol, value: &Ex
     }
 }
 
-// Returns true if `args[i]` "refers to" or "is referred to by" another argument.
-fn is_aliased(args: &[FormatArgsArg<'_>], i: usize) -> bool {
-    let value = args[i].value;
-    args.iter()
-        .enumerate()
-        .any(|(j, arg)| i != j && std::ptr::eq(value, arg.value))
+// Returns true if `hir_id` is referred to by multiple format params
+fn is_aliased(args: &FormatArgsExpn<'_>, hir_id: HirId) -> bool {
+    args.params()
+        .filter(|param| param.value.hir_id == hir_id)
+        .at_most_one()
+        .is_err()
 }
 
 fn count_needed_derefs<'tcx, I>(mut ty: Ty<'tcx>, mut iter: I) -> (usize, Ty<'tcx>)
diff --git a/clippy_lints/src/format_impl.rs b/clippy_lints/src/format_impl.rs
index 04b5be6c80e..d8bc0bf08f2 100644
--- a/clippy_lints/src/format_impl.rs
+++ b/clippy_lints/src/format_impl.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg};
-use clippy_utils::macros::{is_format_macro, root_macro_call_first_node, FormatArgsArg, FormatArgsExpn};
+use clippy_utils::macros::{is_format_macro, root_macro_call_first_node, FormatArg, FormatArgsExpn};
 use clippy_utils::{get_parent_as_impl, is_diag_trait_item, path_to_local, peel_ref_operators};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
@@ -168,10 +168,9 @@ fn check_self_in_format_args<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>,
         if let macro_def_id = outer_macro.def_id;
         if let Some(format_args) = FormatArgsExpn::find_nested(cx, expr, outer_macro.expn);
         if is_format_macro(cx, macro_def_id);
-        if let Some(args) = format_args.args();
         then {
-            for arg in args {
-                if arg.format_trait != impl_trait.name {
+            for arg in format_args.args {
+                if arg.format.r#trait != impl_trait.name {
                     continue;
                 }
                 check_format_arg_self(cx, expr, &arg, impl_trait);
@@ -180,11 +179,11 @@ fn check_self_in_format_args<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>,
     }
 }
 
-fn check_format_arg_self(cx: &LateContext<'_>, expr: &Expr<'_>, arg: &FormatArgsArg<'_>, impl_trait: FormatTrait) {
+fn check_format_arg_self(cx: &LateContext<'_>, expr: &Expr<'_>, arg: &FormatArg<'_>, impl_trait: FormatTrait) {
     // Handle multiple dereferencing of references e.g. &&self
     // Handle dereference of &self -> self that is equivalent (i.e. via *self in fmt() impl)
     // Since the argument to fmt is itself a reference: &self
-    let reference = peel_ref_operators(cx, arg.value);
+    let reference = peel_ref_operators(cx, arg.param.value);
     let map = cx.tcx.hir();
     // Is the reference self?
     if path_to_local(reference).map(|x| map.name(x)) == Some(kw::SelfLower) {
diff --git a/clippy_lints/src/methods/uninit_assumed_init.rs b/clippy_lints/src/methods/uninit_assumed_init.rs
index 77d21f1d373..a1c6294737c 100644
--- a/clippy_lints/src/methods/uninit_assumed_init.rs
+++ b/clippy_lints/src/methods/uninit_assumed_init.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint;
-use clippy_utils::{is_expr_diagnostic_item, ty::is_uninit_value_valid_for_ty};
+use clippy_utils::{is_path_diagnostic_item, ty::is_uninit_value_valid_for_ty};
 use if_chain::if_chain;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
@@ -12,7 +12,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr
     if_chain! {
         if let hir::ExprKind::Call(callee, args) = recv.kind;
         if args.is_empty();
-        if is_expr_diagnostic_item(cx, callee, sym::maybe_uninit_uninit);
+        if is_path_diagnostic_item(cx, callee, sym::maybe_uninit_uninit);
         if !is_uninit_value_valid_for_ty(cx, cx.typeck_results().expr_ty_adjusted(expr));
         then {
             span_lint(
diff --git a/clippy_lints/src/transmute/transmuting_null.rs b/clippy_lints/src/transmute/transmuting_null.rs
index c4981124f39..d8e349af7af 100644
--- a/clippy_lints/src/transmute/transmuting_null.rs
+++ b/clippy_lints/src/transmute/transmuting_null.rs
@@ -1,6 +1,6 @@
 use clippy_utils::consts::{constant_context, Constant};
 use clippy_utils::diagnostics::span_lint;
-use clippy_utils::is_expr_diagnostic_item;
+use clippy_utils::is_path_diagnostic_item;
 use if_chain::if_chain;
 use rustc_ast::LitKind;
 use rustc_hir::{Expr, ExprKind};
@@ -45,7 +45,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, arg: &'t
     // `std::mem::transmute(std::ptr::null::<i32>())`
     if_chain! {
         if let ExprKind::Call(func1, []) = arg.kind;
-        if is_expr_diagnostic_item(cx, func1, sym::ptr_null);
+        if is_path_diagnostic_item(cx, func1, sym::ptr_null);
         then {
             span_lint(cx, TRANSMUTING_NULL, expr.span, LINT_MSG);
             return true;
diff --git a/clippy_utils/Cargo.toml b/clippy_utils/Cargo.toml
index a688050f63a..c36bca06507 100644
--- a/clippy_utils/Cargo.toml
+++ b/clippy_utils/Cargo.toml
@@ -7,6 +7,7 @@ publish = false
 [dependencies]
 arrayvec = { version = "0.7", default-features = false }
 if_chain = "1.0"
+itertools = "0.10.1"
 rustc-semver = "1.1"
 
 [features]
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index dc772e5efee..9308f085214 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -27,6 +27,7 @@ extern crate rustc_infer;
 extern crate rustc_lexer;
 extern crate rustc_lint;
 extern crate rustc_middle;
+extern crate rustc_parse_format;
 extern crate rustc_session;
 extern crate rustc_span;
 extern crate rustc_target;
@@ -371,15 +372,19 @@ pub fn match_qpath(path: &QPath<'_>, segments: &[&str]) -> bool {
 
 /// If the expression is a path, resolves it to a `DefId` and checks if it matches the given path.
 ///
-/// Please use `is_expr_diagnostic_item` if the target is a diagnostic item.
+/// Please use `is_path_diagnostic_item` if the target is a diagnostic item.
 pub fn is_expr_path_def_path(cx: &LateContext<'_>, expr: &Expr<'_>, segments: &[&str]) -> bool {
     path_def_id(cx, expr).map_or(false, |id| match_def_path(cx, id, segments))
 }
 
-/// If the expression is a path, resolves it to a `DefId` and checks if it matches the given
-/// diagnostic item.
-pub fn is_expr_diagnostic_item(cx: &LateContext<'_>, expr: &Expr<'_>, diag_item: Symbol) -> bool {
-    path_def_id(cx, expr).map_or(false, |id| cx.tcx.is_diagnostic_item(diag_item, id))
+/// If `maybe_path` is a path node which resolves to an item, resolves it to a `DefId` and checks if
+/// it matches the given diagnostic item.
+pub fn is_path_diagnostic_item<'tcx>(
+    cx: &LateContext<'_>,
+    maybe_path: &impl MaybePath<'tcx>,
+    diag_item: Symbol,
+) -> bool {
+    path_def_id(cx, maybe_path).map_or(false, |id| cx.tcx.is_diagnostic_item(diag_item, id))
 }
 
 /// THIS METHOD IS DEPRECATED and will eventually be removed since it does not match against the
diff --git a/clippy_utils/src/macros.rs b/clippy_utils/src/macros.rs
index a268e339bb1..37d8f1e458d 100644
--- a/clippy_utils/src/macros.rs
+++ b/clippy_utils/src/macros.rs
@@ -1,16 +1,21 @@
 #![allow(clippy::similar_names)] // `expr` and `expn`
 
+use crate::is_path_diagnostic_item;
+use crate::source::snippet_opt;
 use crate::visitors::expr_visitor_no_bodies;
 
 use arrayvec::ArrayVec;
-use if_chain::if_chain;
+use itertools::{izip, Either, Itertools};
 use rustc_ast::ast::LitKind;
 use rustc_hir::intravisit::Visitor;
 use rustc_hir::{self as hir, Expr, ExprKind, HirId, Node, QPath};
+use rustc_lexer::unescape::unescape_literal;
+use rustc_lexer::{tokenize, unescape, LiteralKind, TokenKind};
 use rustc_lint::LateContext;
+use rustc_parse_format::{self as rpf, Alignment};
 use rustc_span::def_id::DefId;
 use rustc_span::hygiene::{self, MacroKind, SyntaxContext};
-use rustc_span::{sym, ExpnData, ExpnId, ExpnKind, Span, Symbol};
+use rustc_span::{sym, BytePos, ExpnData, ExpnId, ExpnKind, Pos, Span, SpanData, Symbol};
 use std::ops::ControlFlow;
 
 const FORMAT_MACRO_DIAG_ITEMS: &[Symbol] = &[
@@ -332,121 +337,495 @@ fn is_assert_arg(cx: &LateContext<'_>, expr: &Expr<'_>, assert_expn: ExpnId) ->
     }
 }
 
-/// A parsed `format_args!` expansion
+/// The format string doesn't exist in the HIR, so we reassemble it from source code
 #[derive(Debug)]
-pub struct FormatArgsExpn<'tcx> {
-    /// Span of the first argument, the format string
-    pub format_string_span: Span,
-    /// The format string split by formatted args like `{..}`
-    pub format_string_parts: Vec<Symbol>,
-    /// Values passed after the format string
-    pub value_args: Vec<&'tcx Expr<'tcx>>,
-    /// Each element is a `value_args` index and a formatting trait (e.g. `sym::Debug`)
-    pub formatters: Vec<(usize, Symbol)>,
-    /// List of `fmt::v1::Argument { .. }` expressions. If this is empty,
-    /// then `formatters` represents the format args (`{..}`).
-    /// If this is non-empty, it represents the format args, and the `position`
-    /// parameters within the struct expressions are indexes of `formatters`.
-    pub specs: Vec<&'tcx Expr<'tcx>>,
+pub struct FormatString {
+    /// Span of the whole format string literal, including `[r#]"`.
+    pub span: Span,
+    /// Snippet of the whole format string literal, including `[r#]"`.
+    pub snippet: String,
+    /// If the string is raw `r"..."`/`r#""#`, how many `#`s does it have on each side.
+    pub style: Option<usize>,
+    /// The unescaped value of the format string, e.g. `"val – {}"` for the literal
+    /// `"val \u{2013} {}"`.
+    pub unescaped: String,
+    /// The format string split by format args like `{..}`.
+    pub parts: Vec<Symbol>,
 }
 
-impl<'tcx> FormatArgsExpn<'tcx> {
-    /// Parses an expanded `format_args!` or `format_args_nl!` invocation
-    pub fn parse(cx: &LateContext<'_>, expr: &'tcx Expr<'tcx>) -> Option<Self> {
-        macro_backtrace(expr.span).find(|macro_call| {
-            matches!(
-                cx.tcx.item_name(macro_call.def_id),
-                sym::const_format_args | sym::format_args | sym::format_args_nl
-            )
-        })?;
-        let mut format_string_span: Option<Span> = None;
-        let mut format_string_parts: Vec<Symbol> = Vec::new();
-        let mut value_args: Vec<&Expr<'_>> = Vec::new();
-        let mut formatters: Vec<(usize, Symbol)> = Vec::new();
-        let mut specs: Vec<&Expr<'_>> = Vec::new();
-        expr_visitor_no_bodies(|e| {
-            // if we're still inside of the macro definition...
-            if e.span.ctxt() == expr.span.ctxt() {
-                // ArgumentV1::new_<format_trait>(<value>)
-                if_chain! {
-                    if let ExprKind::Call(callee, [val]) = e.kind;
-                    if let ExprKind::Path(QPath::TypeRelative(ty, seg)) = callee.kind;
-                    if let hir::TyKind::Path(QPath::Resolved(_, path)) = ty.kind;
-                    if path.segments.last().unwrap().ident.name == sym::ArgumentV1;
-                    if seg.ident.name.as_str().starts_with("new_");
-                    then {
-                        let val_idx = if_chain! {
-                            if val.span.ctxt() == expr.span.ctxt();
-                            if let ExprKind::Field(_, field) = val.kind;
-                            if let Ok(idx) = field.name.as_str().parse();
-                            then {
-                                // tuple index
-                                idx
-                            } else {
-                                // assume the value expression is passed directly
-                                formatters.len()
-                            }
-                        };
-                        let fmt_trait = match seg.ident.name.as_str() {
-                            "new_display" => "Display",
-                            "new_debug" => "Debug",
-                            "new_lower_exp" => "LowerExp",
-                            "new_upper_exp" => "UpperExp",
-                            "new_octal" => "Octal",
-                            "new_pointer" => "Pointer",
-                            "new_binary" => "Binary",
-                            "new_lower_hex" => "LowerHex",
-                            "new_upper_hex" => "UpperHex",
-                            _ => unreachable!(),
-                        };
-                        formatters.push((val_idx, Symbol::intern(fmt_trait)));
-                    }
-                }
-                if let ExprKind::Struct(QPath::Resolved(_, path), ..) = e.kind {
-                    if path.segments.last().unwrap().ident.name == sym::Argument {
-                        specs.push(e);
-                    }
+impl FormatString {
+    fn new(cx: &LateContext<'_>, pieces: &Expr<'_>) -> Option<Self> {
+        // format_args!(r"a {} b \", 1);
+        //
+        // expands to
+        //
+        // ::core::fmt::Arguments::new_v1(&["a ", " b \\"],
+        //      &[::core::fmt::ArgumentV1::new_display(&1)]);
+        //
+        // where `pieces` is the expression `&["a ", " b \\"]`. It has the span of `r"a {} b \"`
+        let span = pieces.span;
+        let snippet = snippet_opt(cx, span)?;
+
+        let (inner, style) = match tokenize(&snippet).next()?.kind {
+            TokenKind::Literal { kind, .. } => {
+                let style = match kind {
+                    LiteralKind::Str { .. } => None,
+                    LiteralKind::RawStr { n_hashes: Some(n), .. } => Some(n.into()),
+                    _ => return None,
+                };
+
+                let start = style.map_or(1, |n| 2 + n);
+                let end = snippet.len() - style.map_or(1, |n| 1 + n);
+
+                (&snippet[start..end], style)
+            },
+            _ => return None,
+        };
+
+        let mode = if style.is_some() {
+            unescape::Mode::RawStr
+        } else {
+            unescape::Mode::Str
+        };
+
+        let mut unescaped = String::with_capacity(inner.len());
+        unescape_literal(inner, mode, &mut |_, ch| {
+            unescaped.push(ch.unwrap());
+        });
+
+        let mut parts = Vec::new();
+        expr_visitor_no_bodies(|expr| {
+            if let ExprKind::Lit(lit) = &expr.kind {
+                if let LitKind::Str(symbol, _) = lit.node {
+                    parts.push(symbol);
                 }
-                // walk through the macro expansion
-                return true;
             }
-            // assume that the first expr with a differing context represents
-            // (and has the span of) the format string
-            if format_string_span.is_none() {
-                format_string_span = Some(e.span);
-                let span = e.span;
-                // walk the expr and collect string literals which are format string parts
-                expr_visitor_no_bodies(|e| {
-                    if e.span.ctxt() != span.ctxt() {
-                        // defensive check, probably doesn't happen
-                        return false;
-                    }
-                    if let ExprKind::Lit(lit) = &e.kind {
-                        if let LitKind::Str(symbol, _s) = lit.node {
-                            format_string_parts.push(symbol);
-                        }
-                    }
-                    true
-                })
-                .visit_expr(e);
+
+            true
+        })
+        .visit_expr(pieces);
+
+        Some(Self {
+            span,
+            snippet,
+            style,
+            unescaped,
+            parts,
+        })
+    }
+}
+
+struct FormatArgsValues<'tcx> {
+    /// See `FormatArgsExpn::value_args`
+    value_args: Vec<&'tcx Expr<'tcx>>,
+    /// Maps an `rt::v1::Argument::position` or an `rt::v1::Count::Param` to its index in
+    /// `value_args`
+    pos_to_value_index: Vec<usize>,
+    /// Used to check if a value is declared inline & to resolve `InnerSpan`s.
+    format_string_span: SpanData,
+}
+
+impl<'tcx> FormatArgsValues<'tcx> {
+    fn new(args: &'tcx Expr<'tcx>, format_string_span: SpanData) -> Self {
+        let mut pos_to_value_index = Vec::new();
+        let mut value_args = Vec::new();
+        expr_visitor_no_bodies(|expr| {
+            if expr.span.ctxt() == args.span.ctxt() {
+                // ArgumentV1::new_<format_trait>(<val>)
+                // ArgumentV1::from_usize(<val>)
+                if let ExprKind::Call(callee, [val]) = expr.kind
+                    && let ExprKind::Path(QPath::TypeRelative(ty, _)) = callee.kind
+                    && let hir::TyKind::Path(QPath::Resolved(_, path)) = ty.kind
+                    && path.segments.last().unwrap().ident.name == sym::ArgumentV1
+                {
+                    let val_idx = if val.span.ctxt() == expr.span.ctxt()
+                        && let ExprKind::Field(_, field) = val.kind
+                        && let Ok(idx) = field.name.as_str().parse()
+                    {
+                        // tuple index
+                        idx
+                    } else {
+                        // assume the value expression is passed directly
+                        pos_to_value_index.len()
+                    };
+
+                    pos_to_value_index.push(val_idx);
+                }
+
+                true
             } else {
-                // assume that any further exprs with a differing context are value args
-                value_args.push(e);
+                // assume that any expr with a differing span is a value
+                value_args.push(expr);
+
+                false
             }
-            // don't walk anything not from the macro expansion (e.a. inputs)
-            false
         })
-        .visit_expr(expr);
-        Some(FormatArgsExpn {
-            format_string_span: format_string_span?,
-            format_string_parts,
+        .visit_expr(args);
+
+        Self {
             value_args,
-            formatters,
-            specs,
+            pos_to_value_index,
+            format_string_span,
+        }
+    }
+}
+
+/// The positions of a format argument's value, precision and width
+///
+/// A position is an index into the second argument of `Arguments::new_v1[_formatted]`
+#[derive(Debug, Default, Copy, Clone)]
+struct ParamPosition {
+    /// The position stored in `rt::v1::Argument::position`.
+    value: usize,
+    /// The position stored in `rt::v1::FormatSpec::width` if it is a `Count::Param`.
+    width: Option<usize>,
+    /// The position stored in `rt::v1::FormatSpec::precision` if it is a `Count::Param`.
+    precision: Option<usize>,
+}
+
+/// Parses the `fmt` arg of `Arguments::new_v1_formatted(pieces, args, fmt, _)`
+fn parse_rt_fmt<'tcx>(fmt_arg: &'tcx Expr<'tcx>) -> Option<impl Iterator<Item = ParamPosition> + 'tcx> {
+    fn parse_count(expr: &Expr<'_>) -> Option<usize> {
+        // ::core::fmt::rt::v1::Count::Param(1usize),
+        if let ExprKind::Call(ctor, [val]) = expr.kind
+            && let ExprKind::Path(QPath::Resolved(_, path)) = ctor.kind
+            && path.segments.last()?.ident.name == sym::Param
+            && let ExprKind::Lit(lit) = &val.kind
+            && let LitKind::Int(pos, _) = lit.node
+        {
+            Some(pos as usize)
+        } else {
+            None
+        }
+    }
+
+    if let ExprKind::AddrOf(.., array) = fmt_arg.kind
+        && let ExprKind::Array(specs) = array.kind
+    {
+        Some(specs.iter().map(|spec| {
+            let mut position = ParamPosition::default();
+
+            // ::core::fmt::rt::v1::Argument {
+            //     position: 0usize,
+            //     format: ::core::fmt::rt::v1::FormatSpec {
+            //         ..
+            //         precision: ::core::fmt::rt::v1::Count::Implied,
+            //         width: ::core::fmt::rt::v1::Count::Implied,
+            //     },
+            // }
+
+            // TODO: this can be made much nicer next sync with `Visitor::visit_expr_field`
+            if let ExprKind::Struct(_, fields, _) = spec.kind {
+                for field in fields {
+                    match (field.ident.name, &field.expr.kind) {
+                        (sym::position, ExprKind::Lit(lit)) => {
+                            if let LitKind::Int(pos, _) = lit.node {
+                                position.value = pos as usize;
+                            }
+                        },
+                        (sym::format, &ExprKind::Struct(_, spec_fields, _)) => {
+                            for spec_field in spec_fields {
+                                match spec_field.ident.name {
+                                    sym::precision => {
+                                        position.precision = parse_count(spec_field.expr);
+                                    },
+                                    sym::width => {
+                                        position.width = parse_count(spec_field.expr);
+                                    },
+                                    _ => {},
+                                }
+                            }
+                        },
+                        _ => {},
+                    }
+                }
+            }
+
+            position
+        }))
+    } else {
+        None
+    }
+}
+
+/// `Span::from_inner`, but for `rustc_parse_format`'s `InnerSpan`
+fn span_from_inner(base: SpanData, inner: rpf::InnerSpan) -> Span {
+    Span::new(
+        base.lo + BytePos::from_usize(inner.start),
+        base.lo + BytePos::from_usize(inner.end),
+        base.ctxt,
+        base.parent,
+    )
+}
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub enum FormatParamKind {
+    /// An implicit parameter , such as `{}` or `{:?}`.
+    Implicit,
+    /// A parameter with an explicit number, or an asterisk precision. e.g. `{1}`, `{0:?}`,
+    /// `{:.0$}` or `{:.*}`.
+    Numbered,
+    /// A named parameter with a named `value_arg`, such as the `x` in `format!("{x}", x = 1)`.
+    Named(Symbol),
+    /// An implicit named paramter, such as the `y` in `format!("{y}")`.
+    NamedInline(Symbol),
+}
+
+/// A `FormatParam` is any place in a `FormatArgument` that refers to a supplied value, e.g.
+///
+/// ```
+/// let precision = 2;
+/// format!("{:.precision$}", 0.1234);
+/// ```
+///
+/// has two `FormatParam`s, a [`FormatParamKind::Implicit`] `.kind` with a `.value` of `0.1234`
+/// and a [`FormatParamKind::NamedInline("precision")`] `.kind` with a `.value` of `2`
+#[derive(Debug, Copy, Clone)]
+pub struct FormatParam<'tcx> {
+    /// The expression this parameter refers to.
+    pub value: &'tcx Expr<'tcx>,
+    /// How this paramter refers to its `value`.
+    pub kind: FormatParamKind,
+    /// Span of the parameter, may be zero width. Includes the whitespace of implicit parameters.
+    ///
+    /// ```text
+    /// format!("{}, {  }, {0}, {name}", ...);
+    ///          ^    ~~    ~    ~~~~
+    /// ```
+    pub span: Span,
+}
+
+impl<'tcx> FormatParam<'tcx> {
+    fn new(
+        mut kind: FormatParamKind,
+        position: usize,
+        inner: rpf::InnerSpan,
+        values: &FormatArgsValues<'tcx>,
+    ) -> Option<Self> {
+        let value_index = *values.pos_to_value_index.get(position)?;
+        let value = *values.value_args.get(value_index)?;
+        let span = span_from_inner(values.format_string_span, inner);
+
+        // if a param is declared inline, e.g. `format!("{x}")`, the generated expr's span points
+        // into the format string
+        if let FormatParamKind::Named(name) = kind && values.format_string_span.contains(value.span.data()) {
+            kind = FormatParamKind::NamedInline(name);
+        }
+
+        Some(Self { value, kind, span })
+    }
+}
+
+/// Used by [width](https://doc.rust-lang.org/std/fmt/#width) and
+/// [precision](https://doc.rust-lang.org/std/fmt/#precision) specifiers.
+#[derive(Debug, Copy, Clone)]
+pub enum Count<'tcx> {
+    /// Specified with a literal number, stores the value.
+    Is(usize, Span),
+    /// Specified using `$` and `*` syntaxes. The `*` format is still considered to be
+    /// `FormatParamKind::Numbered`.
+    Param(FormatParam<'tcx>),
+    /// Not specified.
+    Implied,
+}
+
+impl<'tcx> Count<'tcx> {
+    fn new(
+        count: rpf::Count<'_>,
+        position: Option<usize>,
+        inner: Option<rpf::InnerSpan>,
+        values: &FormatArgsValues<'tcx>,
+    ) -> Option<Self> {
+        Some(match count {
+            rpf::Count::CountIs(val) => Self::Is(val, span_from_inner(values.format_string_span, inner?)),
+            rpf::Count::CountIsName(name, span) => Self::Param(FormatParam::new(
+                FormatParamKind::Named(Symbol::intern(name)),
+                position?,
+                span,
+                values,
+            )?),
+            rpf::Count::CountIsParam(_) => {
+                Self::Param(FormatParam::new(FormatParamKind::Numbered, position?, inner?, values)?)
+            },
+            rpf::Count::CountImplied => Self::Implied,
+        })
+    }
+
+    pub fn is_implied(self) -> bool {
+        matches!(self, Count::Implied)
+    }
+
+    pub fn param(self) -> Option<FormatParam<'tcx>> {
+        match self {
+            Count::Param(param) => Some(param),
+            _ => None,
+        }
+    }
+}
+
+/// Specification for the formatting of an argument in the format string. See
+/// <https://doc.rust-lang.org/std/fmt/index.html#formatting-parameters> for the precise meanings.
+#[derive(Debug)]
+pub struct FormatSpec<'tcx> {
+    /// Optionally specified character to fill alignment with.
+    pub fill: Option<char>,
+    /// Optionally specified alignment.
+    pub align: Alignment,
+    /// Packed version of various flags provided, see [`rustc_parse_format::Flag`].
+    pub flags: u32,
+    /// Represents either the maximum width or the integer precision.
+    pub precision: Count<'tcx>,
+    /// The minimum width, will be padded according to `width`/`align`
+    pub width: Count<'tcx>,
+    /// The formatting trait used by the argument, e.g. `sym::Display` for `{}`, `sym::Debug` for
+    /// `{:?}`.
+    pub r#trait: Symbol,
+    pub trait_span: Option<Span>,
+}
+
+impl<'tcx> FormatSpec<'tcx> {
+    fn new(spec: rpf::FormatSpec<'_>, positions: ParamPosition, values: &FormatArgsValues<'tcx>) -> Option<Self> {
+        Some(Self {
+            fill: spec.fill,
+            align: spec.align,
+            flags: spec.flags,
+            precision: Count::new(spec.precision, positions.precision, spec.precision_span, values)?,
+            width: Count::new(spec.width, positions.width, spec.width_span, values)?,
+            r#trait: match spec.ty {
+                "" => sym::Display,
+                "?" => sym::Debug,
+                "o" => sym!(Octal),
+                "x" => sym!(LowerHex),
+                "X" => sym!(UpperHex),
+                "p" => sym::Pointer,
+                "b" => sym!(Binary),
+                "e" => sym!(LowerExp),
+                "E" => sym!(UpperExp),
+                _ => return None,
+            },
+            trait_span: spec
+                .ty_span
+                .map(|span| span_from_inner(values.format_string_span, span)),
         })
     }
 
-    /// Finds a nested call to `format_args!` within a `format!`-like macro call
+    /// Returns true if this format spec would change the contents of a string when formatted
+    pub fn has_string_formatting(&self) -> bool {
+        self.r#trait != sym::Display || !self.width.is_implied() || !self.precision.is_implied()
+    }
+}
+
+/// A format argument, such as `{}`, `{foo:?}`.
+#[derive(Debug)]
+pub struct FormatArg<'tcx> {
+    /// The parameter the argument refers to.
+    pub param: FormatParam<'tcx>,
+    /// How to format `param`.
+    pub format: FormatSpec<'tcx>,
+    /// span of the whole argument, `{..}`.
+    pub span: Span,
+}
+
+/// A parsed `format_args!` expansion.
+#[derive(Debug)]
+pub struct FormatArgsExpn<'tcx> {
+    /// The format string literal.
+    pub format_string: FormatString,
+    // The format arguments, such as `{:?}`.
+    pub args: Vec<FormatArg<'tcx>>,
+    /// Has an added newline due to `println!()`/`writeln!()`/etc. The last format string part will
+    /// include this added newline.
+    pub newline: bool,
+    /// Values passed after the format string and implicit captures. `[1, z + 2, x]` for
+    /// `format!("{x} {} {y}", 1, z + 2)`.
+    value_args: Vec<&'tcx Expr<'tcx>>,
+}
+
+impl<'tcx> FormatArgsExpn<'tcx> {
+    pub fn parse(cx: &LateContext<'_>, expr: &'tcx Expr<'tcx>) -> Option<Self> {
+        let macro_name = macro_backtrace(expr.span)
+            .map(|macro_call| cx.tcx.item_name(macro_call.def_id))
+            .find(|&name| matches!(name, sym::const_format_args | sym::format_args | sym::format_args_nl))?;
+        let newline = macro_name == sym::format_args_nl;
+
+        // ::core::fmt::Arguments::new_v1(pieces, args)
+        // ::core::fmt::Arguments::new_v1_formatted(pieces, args, fmt, _unsafe_arg)
+        if let ExprKind::Call(callee, [pieces, args, rest @ ..]) = expr.kind
+            && let ExprKind::Path(QPath::TypeRelative(ty, seg)) = callee.kind
+            && is_path_diagnostic_item(cx, ty, sym::Arguments)
+            && matches!(seg.ident.as_str(), "new_v1" | "new_v1_formatted")
+        {
+            let format_string = FormatString::new(cx, pieces)?;
+
+            let mut parser = rpf::Parser::new(
+                &format_string.unescaped,
+                format_string.style,
+                Some(format_string.snippet.clone()),
+                // `format_string.unescaped` does not contain the appended newline
+                false,
+                rpf::ParseMode::Format,
+            );
+
+            let parsed_args = parser
+                .by_ref()
+                .filter_map(|piece| match piece {
+                    rpf::Piece::NextArgument(a) => Some(a),
+                    rpf::Piece::String(_) => None,
+                })
+                .collect_vec();
+            if !parser.errors.is_empty() {
+                return None;
+            }
+
+            let positions = if let Some(fmt_arg) = rest.first() {
+                // If the argument contains format specs, `new_v1_formatted(_, _, fmt, _)`, parse
+                // them.
+
+                Either::Left(parse_rt_fmt(fmt_arg)?)
+            } else {
+                // If no format specs are given, the positions are in the given order and there are
+                // no `precision`/`width`s to consider.
+
+                Either::Right((0..).map(|n| ParamPosition {
+                    value: n,
+                    width: None,
+                    precision: None,
+                }))
+            };
+
+            let values = FormatArgsValues::new(args, format_string.span.data());
+
+            let args = izip!(positions, parsed_args, parser.arg_places)
+                .map(|(position, parsed_arg, arg_span)| {
+                    Some(FormatArg {
+                        param: FormatParam::new(
+                            match parsed_arg.position {
+                                rpf::Position::ArgumentImplicitlyIs(_) => FormatParamKind::Implicit,
+                                rpf::Position::ArgumentIs(_) => FormatParamKind::Numbered,
+                                // NamedInline is handled by `FormatParam::new()`
+                                rpf::Position::ArgumentNamed(name) => FormatParamKind::Named(Symbol::intern(name)),
+                            },
+                            position.value,
+                            parsed_arg.position_span,
+                            &values,
+                        )?,
+                        format: FormatSpec::new(parsed_arg.format, position, &values)?,
+                        span: span_from_inner(values.format_string_span, arg_span),
+                    })
+                })
+                .collect::<Option<Vec<_>>>()?;
+
+            Some(Self {
+                format_string,
+                args,
+                value_args: values.value_args,
+                newline,
+            })
+        } else {
+            None
+        }
+    }
+
     pub fn find_nested(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, expn_id: ExpnId) -> Option<Self> {
         let mut format_args = None;
         expr_visitor_no_bodies(|e| {
@@ -466,88 +845,23 @@ impl<'tcx> FormatArgsExpn<'tcx> {
         format_args
     }
 
-    /// Returns a vector of `FormatArgsArg`.
-    pub fn args(&self) -> Option<Vec<FormatArgsArg<'tcx>>> {
-        if self.specs.is_empty() {
-            let args = std::iter::zip(&self.value_args, &self.formatters)
-                .map(|(value, &(_, format_trait))| FormatArgsArg {
-                    value,
-                    format_trait,
-                    spec: None,
-                })
-                .collect();
-            return Some(args);
-        }
-        self.specs
-            .iter()
-            .map(|spec| {
-                if_chain! {
-                    // struct `core::fmt::rt::v1::Argument`
-                    if let ExprKind::Struct(_, fields, _) = spec.kind;
-                    if let Some(position_field) = fields.iter().find(|f| f.ident.name == sym::position);
-                    if let ExprKind::Lit(lit) = &position_field.expr.kind;
-                    if let LitKind::Int(position, _) = lit.node;
-                    if let Ok(i) = usize::try_from(position);
-                    if let Some(&(j, format_trait)) = self.formatters.get(i);
-                    then {
-                        Some(FormatArgsArg {
-                            value: self.value_args[j],
-                            format_trait,
-                            spec: Some(spec),
-                        })
-                    } else {
-                        None
-                    }
-                }
-            })
-            .collect()
-    }
-
     /// Source callsite span of all inputs
     pub fn inputs_span(&self) -> Span {
         match *self.value_args {
-            [] => self.format_string_span,
+            [] => self.format_string.span,
             [.., last] => self
-                .format_string_span
-                .to(hygiene::walk_chain(last.span, self.format_string_span.ctxt())),
+                .format_string
+                .span
+                .to(hygiene::walk_chain(last.span, self.format_string.span.ctxt())),
         }
     }
-}
 
-/// Type representing a `FormatArgsExpn`'s format arguments
-pub struct FormatArgsArg<'tcx> {
-    /// An element of `value_args` according to `position`
-    pub value: &'tcx Expr<'tcx>,
-    /// An element of `args` according to `position`
-    pub format_trait: Symbol,
-    /// An element of `specs`
-    pub spec: Option<&'tcx Expr<'tcx>>,
-}
-
-impl<'tcx> FormatArgsArg<'tcx> {
-    /// Returns true if any formatting parameters are used that would have an effect on strings,
-    /// like `{:+2}` instead of just `{}`.
-    pub fn has_string_formatting(&self) -> bool {
-        self.spec.map_or(false, |spec| {
-            // `!` because these conditions check that `self` is unformatted.
-            !if_chain! {
-                // struct `core::fmt::rt::v1::Argument`
-                if let ExprKind::Struct(_, fields, _) = spec.kind;
-                if let Some(format_field) = fields.iter().find(|f| f.ident.name == sym::format);
-                // struct `core::fmt::rt::v1::FormatSpec`
-                if let ExprKind::Struct(_, subfields, _) = format_field.expr.kind;
-                if subfields.iter().all(|field| match field.ident.name {
-                    sym::precision | sym::width => match field.expr.kind {
-                        ExprKind::Path(QPath::Resolved(_, path)) => {
-                            path.segments.last().unwrap().ident.name == sym::Implied
-                        }
-                        _ => false,
-                    }
-                    _ => true,
-                });
-                then { true } else { false }
-            }
-        })
+    /// Iterator of all format params, both values and those referenced by `width`/`precision`s.
+    pub fn params(&'tcx self) -> impl Iterator<Item = FormatParam<'tcx>> {
+        self.args
+            .iter()
+            .flat_map(|arg| [Some(arg.param), arg.format.precision.param(), arg.format.width.param()])
+            .flatten()
     }
 }
 
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index 8d697a301c4..199a3ab12ae 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -71,7 +71,6 @@ pub const IPADDR_V6: [&str; 5] = ["std", "net", "ip", "IpAddr", "V6"];
 pub const ITER_COUNT: [&str; 6] = ["core", "iter", "traits", "iterator", "Iterator", "count"];
 pub const ITER_EMPTY: [&str; 5] = ["core", "iter", "sources", "empty", "Empty"];
 pub const ITER_REPEAT: [&str; 5] = ["core", "iter", "sources", "repeat", "repeat"];
-#[expect(clippy::invalid_paths)] // internal lints do not know about all external crates
 pub const ITERTOOLS_NEXT_TUPLE: [&str; 3] = ["itertools", "Itertools", "next_tuple"];
 #[cfg(feature = "internal")]
 pub const KW_MODULE: [&str; 3] = ["rustc_span", "symbol", "kw"];
diff --git a/tests/ui/format_args.fixed b/tests/ui/format_args.fixed
index 69b5e1c722e..4322891db76 100644
--- a/tests/ui/format_args.fixed
+++ b/tests/ui/format_args.fixed
@@ -1,8 +1,6 @@
 // run-rustfix
 
-#![allow(unreachable_code)]
-#![allow(unused_macros)]
-#![allow(unused_variables)]
+#![allow(unused)]
 #![allow(clippy::assertions_on_constants)]
 #![allow(clippy::eq_op)]
 #![allow(clippy::print_literal)]
@@ -115,3 +113,12 @@ fn main() {
     // https://github.com/rust-lang/rust-clippy/issues/7903
     println!("{foo}{foo:?}", foo = "foo".to_string());
 }
+
+fn issue8643(vendor_id: usize, product_id: usize, name: &str) {
+    println!(
+        "{:<9}  {:<10}  {}",
+        format!("0x{:x}", vendor_id),
+        format!("0x{:x}", product_id),
+        name
+    );
+}
diff --git a/tests/ui/format_args.rs b/tests/ui/format_args.rs
index 3a434c5bf00..61ad04612cd 100644
--- a/tests/ui/format_args.rs
+++ b/tests/ui/format_args.rs
@@ -1,8 +1,6 @@
 // run-rustfix
 
-#![allow(unreachable_code)]
-#![allow(unused_macros)]
-#![allow(unused_variables)]
+#![allow(unused)]
 #![allow(clippy::assertions_on_constants)]
 #![allow(clippy::eq_op)]
 #![allow(clippy::print_literal)]
@@ -115,3 +113,12 @@ fn main() {
     // https://github.com/rust-lang/rust-clippy/issues/7903
     println!("{foo}{foo:?}", foo = "foo".to_string());
 }
+
+fn issue8643(vendor_id: usize, product_id: usize, name: &str) {
+    println!(
+        "{:<9}  {:<10}  {}",
+        format!("0x{:x}", vendor_id),
+        format!("0x{:x}", product_id),
+        name
+    );
+}
diff --git a/tests/ui/format_args.stderr b/tests/ui/format_args.stderr
index c0cbca50795..0aca1c1a0df 100644
--- a/tests/ui/format_args.stderr
+++ b/tests/ui/format_args.stderr
@@ -1,5 +1,5 @@
 error: `to_string` applied to a type that implements `Display` in `format!` args
-  --> $DIR/format_args.rs:76:72
+  --> $DIR/format_args.rs:74:72
    |
 LL |     let _ = format!("error: something failed at {}", Location::caller().to_string());
    |                                                                        ^^^^^^^^^^^^ help: remove this
@@ -7,121 +7,121 @@ LL |     let _ = format!("error: something failed at {}", Location::caller().to_
    = note: `-D clippy::to-string-in-format-args` implied by `-D warnings`
 
 error: `to_string` applied to a type that implements `Display` in `write!` args
-  --> $DIR/format_args.rs:80:27
+  --> $DIR/format_args.rs:78:27
    |
 LL |         Location::caller().to_string()
    |                           ^^^^^^^^^^^^ help: remove this
 
 error: `to_string` applied to a type that implements `Display` in `writeln!` args
-  --> $DIR/format_args.rs:85:27
+  --> $DIR/format_args.rs:83:27
    |
 LL |         Location::caller().to_string()
    |                           ^^^^^^^^^^^^ help: remove this
 
 error: `to_string` applied to a type that implements `Display` in `print!` args
-  --> $DIR/format_args.rs:87:63
+  --> $DIR/format_args.rs:85:63
    |
 LL |     print!("error: something failed at {}", Location::caller().to_string());
    |                                                               ^^^^^^^^^^^^ help: remove this
 
 error: `to_string` applied to a type that implements `Display` in `println!` args
-  --> $DIR/format_args.rs:88:65
+  --> $DIR/format_args.rs:86:65
    |
 LL |     println!("error: something failed at {}", Location::caller().to_string());
    |                                                                 ^^^^^^^^^^^^ help: remove this
 
 error: `to_string` applied to a type that implements `Display` in `eprint!` args
-  --> $DIR/format_args.rs:89:64
+  --> $DIR/format_args.rs:87:64
    |
 LL |     eprint!("error: something failed at {}", Location::caller().to_string());
    |                                                                ^^^^^^^^^^^^ help: remove this
 
 error: `to_string` applied to a type that implements `Display` in `eprintln!` args
-  --> $DIR/format_args.rs:90:66
+  --> $DIR/format_args.rs:88:66
    |
 LL |     eprintln!("error: something failed at {}", Location::caller().to_string());
    |                                                                  ^^^^^^^^^^^^ help: remove this
 
 error: `to_string` applied to a type that implements `Display` in `format_args!` args
-  --> $DIR/format_args.rs:91:77
+  --> $DIR/format_args.rs:89:77
    |
 LL |     let _ = format_args!("error: something failed at {}", Location::caller().to_string());
    |                                                                             ^^^^^^^^^^^^ help: remove this
 
 error: `to_string` applied to a type that implements `Display` in `assert!` args
-  --> $DIR/format_args.rs:92:70
+  --> $DIR/format_args.rs:90:70
    |
 LL |     assert!(true, "error: something failed at {}", Location::caller().to_string());
    |                                                                      ^^^^^^^^^^^^ help: remove this
 
 error: `to_string` applied to a type that implements `Display` in `assert_eq!` args
-  --> $DIR/format_args.rs:93:73
+  --> $DIR/format_args.rs:91:73
    |
 LL |     assert_eq!(0, 0, "error: something failed at {}", Location::caller().to_string());
    |                                                                         ^^^^^^^^^^^^ help: remove this
 
 error: `to_string` applied to a type that implements `Display` in `assert_ne!` args
-  --> $DIR/format_args.rs:94:73
+  --> $DIR/format_args.rs:92:73
    |
 LL |     assert_ne!(0, 0, "error: something failed at {}", Location::caller().to_string());
    |                                                                         ^^^^^^^^^^^^ help: remove this
 
 error: `to_string` applied to a type that implements `Display` in `panic!` args
-  --> $DIR/format_args.rs:95:63
+  --> $DIR/format_args.rs:93:63
    |
 LL |     panic!("error: something failed at {}", Location::caller().to_string());
    |                                                               ^^^^^^^^^^^^ help: remove this
 
 error: `to_string` applied to a type that implements `Display` in `println!` args
-  --> $DIR/format_args.rs:96:20
+  --> $DIR/format_args.rs:94:20
    |
 LL |     println!("{}", X(1).to_string());
    |                    ^^^^^^^^^^^^^^^^ help: use this: `*X(1)`
 
 error: `to_string` applied to a type that implements `Display` in `println!` args
-  --> $DIR/format_args.rs:97:20
+  --> $DIR/format_args.rs:95:20
    |
 LL |     println!("{}", Y(&X(1)).to_string());
    |                    ^^^^^^^^^^^^^^^^^^^^ help: use this: `***Y(&X(1))`
 
 error: `to_string` applied to a type that implements `Display` in `println!` args
-  --> $DIR/format_args.rs:98:24
+  --> $DIR/format_args.rs:96:24
    |
 LL |     println!("{}", Z(1).to_string());
    |                        ^^^^^^^^^^^^ help: remove this
 
 error: `to_string` applied to a type that implements `Display` in `println!` args
-  --> $DIR/format_args.rs:99:20
+  --> $DIR/format_args.rs:97:20
    |
 LL |     println!("{}", x.to_string());
    |                    ^^^^^^^^^^^^^ help: use this: `**x`
 
 error: `to_string` applied to a type that implements `Display` in `println!` args
-  --> $DIR/format_args.rs:100:20
+  --> $DIR/format_args.rs:98:20
    |
 LL |     println!("{}", x_ref.to_string());
    |                    ^^^^^^^^^^^^^^^^^ help: use this: `***x_ref`
 
 error: `to_string` applied to a type that implements `Display` in `println!` args
-  --> $DIR/format_args.rs:102:39
+  --> $DIR/format_args.rs:100:39
    |
 LL |     println!("{foo}{bar}", foo = "foo".to_string(), bar = "bar");
    |                                       ^^^^^^^^^^^^ help: remove this
 
 error: `to_string` applied to a type that implements `Display` in `println!` args
-  --> $DIR/format_args.rs:103:52
+  --> $DIR/format_args.rs:101:52
    |
 LL |     println!("{foo}{bar}", foo = "foo", bar = "bar".to_string());
    |                                                    ^^^^^^^^^^^^ help: remove this
 
 error: `to_string` applied to a type that implements `Display` in `println!` args
-  --> $DIR/format_args.rs:104:39
+  --> $DIR/format_args.rs:102:39
    |
 LL |     println!("{foo}{bar}", bar = "bar".to_string(), foo = "foo");
    |                                       ^^^^^^^^^^^^ help: remove this
 
 error: `to_string` applied to a type that implements `Display` in `println!` args
-  --> $DIR/format_args.rs:105:52
+  --> $DIR/format_args.rs:103:52
    |
 LL |     println!("{foo}{bar}", bar = "bar", foo = "foo".to_string());
    |                                                    ^^^^^^^^^^^^ help: remove this
-- 
cgit 1.4.1-3-g733a5


From d95b67560c4cce38e07aed560abf7832eb5aeaa7 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sun, 8 May 2022 13:11:53 -0400
Subject: Rework `only_used_in_recursion`

---
 clippy_lints/src/lib.rs                    |   2 +-
 clippy_lints/src/only_used_in_recursion.rs | 828 ++++++++++-------------------
 tests/ui/only_used_in_recursion.rs         | 133 +++--
 tests/ui/only_used_in_recursion.stderr     | 193 +++++--
 tests/ui/only_used_in_recursion2.rs        |  91 ++++
 tests/ui/only_used_in_recursion2.stderr    |  63 +++
 6 files changed, 655 insertions(+), 655 deletions(-)
 create mode 100644 tests/ui/only_used_in_recursion2.rs
 create mode 100644 tests/ui/only_used_in_recursion2.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index dbea55a04d6..467051cfa68 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -860,7 +860,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(move || Box::new(manual_bits::ManualBits::new(msrv)));
     store.register_late_pass(|| Box::new(default_union_representation::DefaultUnionRepresentation));
     store.register_early_pass(|| Box::new(doc_link_with_quotes::DocLinkWithQuotes));
-    store.register_late_pass(|| Box::new(only_used_in_recursion::OnlyUsedInRecursion));
+    store.register_late_pass(|| Box::new(only_used_in_recursion::OnlyUsedInRecursion::default()));
     let allow_dbg_in_tests = conf.allow_dbg_in_tests;
     store.register_late_pass(move || Box::new(dbg_macro::DbgMacro::new(allow_dbg_in_tests)));
     let cargo_ignore_publish = conf.cargo_ignore_publish;
diff --git a/clippy_lints/src/only_used_in_recursion.rs b/clippy_lints/src/only_used_in_recursion.rs
index 413a740be25..a4f516df735 100644
--- a/clippy_lints/src/only_used_in_recursion.rs
+++ b/clippy_lints/src/only_used_in_recursion.rs
@@ -1,25 +1,16 @@
-use std::collections::VecDeque;
-
-use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::is_lint_allowed;
-use itertools::{izip, Itertools};
-use rustc_ast::{walk_list, Label, Mutability};
-use rustc_data_structures::fx::{FxHashMap, FxHashSet};
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::{get_expr_use_or_unification_node, get_parent_node, path_def_id, path_to_local, path_to_local_id};
+use core::cell::Cell;
+use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::Applicability;
-use rustc_hir::def::{DefKind, Res};
 use rustc_hir::def_id::DefId;
-use rustc_hir::definitions::{DefPathData, DisambiguatedDefPathData};
-use rustc_hir::intravisit::{walk_expr, walk_stmt, FnKind, Visitor};
-use rustc_hir::{
-    Arm, Block, Body, Closure, Expr, ExprKind, Guard, HirId, ImplicitSelfKind, Let, Local, Pat, PatKind, Path,
-    PathSegment, QPath, Stmt, StmtKind, TyKind, UnOp,
-};
+use rustc_hir::hir_id::HirIdMap;
+use rustc_hir::{Body, Expr, ExprKind, HirId, ImplItem, ImplItemKind, Node, PatKind, TraitItem, TraitItemKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty;
-use rustc_middle::ty::{Ty, TyCtxt, TypeckResults};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::symbol::kw;
-use rustc_span::symbol::Ident;
+use rustc_middle::ty::subst::{GenericArgKind, SubstsRef};
+use rustc_middle::ty::{self, ConstKind};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::symbol::{kw, Ident};
 use rustc_span::Span;
 
 declare_clippy_lint! {
@@ -92,569 +83,320 @@ declare_clippy_lint! {
     nursery,
     "arguments that is only used in recursion can be removed"
 }
-declare_lint_pass!(OnlyUsedInRecursion => [ONLY_USED_IN_RECURSION]);
-
-impl<'tcx> LateLintPass<'tcx> for OnlyUsedInRecursion {
-    fn check_fn(
-        &mut self,
-        cx: &LateContext<'tcx>,
-        kind: FnKind<'tcx>,
-        decl: &'tcx rustc_hir::FnDecl<'tcx>,
-        body: &'tcx Body<'tcx>,
-        _: Span,
-        id: HirId,
-    ) {
-        if is_lint_allowed(cx, ONLY_USED_IN_RECURSION, id) {
-            return;
-        }
-        if let FnKind::ItemFn(ident, ..) | FnKind::Method(ident, ..) = kind {
-            let def_id = id.owner.to_def_id();
-            let data = cx.tcx.def_path(def_id).data;
-
-            if data.len() > 1 {
-                match data.get(data.len() - 2) {
-                    Some(DisambiguatedDefPathData {
-                        data: DefPathData::Impl,
-                        disambiguator,
-                    }) if *disambiguator != 0 => return,
-                    _ => {},
-                }
-            }
-
-            let has_self = !matches!(decl.implicit_self, ImplicitSelfKind::None);
-
-            let ty_res = cx.typeck_results();
-            let param_span = body
-                .params
-                .iter()
-                .flat_map(|param| {
-                    let mut v = Vec::new();
-                    param.pat.each_binding(|_, hir_id, span, ident| {
-                        v.push((hir_id, span, ident));
-                    });
-                    v
-                })
-                .skip(if has_self { 1 } else { 0 })
-                .filter(|(_, _, ident)| !ident.name.as_str().starts_with('_'))
-                .collect_vec();
-
-            let params = body.params.iter().map(|param| param.pat).collect();
-
-            let mut visitor = SideEffectVisit {
-                graph: FxHashMap::default(),
-                has_side_effect: FxHashSet::default(),
-                ret_vars: Vec::new(),
-                contains_side_effect: false,
-                break_vars: FxHashMap::default(),
-                params,
-                fn_ident: ident,
-                fn_def_id: def_id,
-                is_method: matches!(kind, FnKind::Method(..)),
-                has_self,
-                ty_res,
-                tcx: cx.tcx,
-                visited_exprs: FxHashSet::default(),
-            };
-
-            visitor.visit_expr(&body.value);
-            let vars = std::mem::take(&mut visitor.ret_vars);
-            // this would set the return variables to side effect
-            visitor.add_side_effect(vars);
-
-            let mut queue = visitor.has_side_effect.iter().copied().collect::<VecDeque<_>>();
-
-            // a simple BFS to check all the variables that have side effect
-            while let Some(id) = queue.pop_front() {
-                if let Some(next) = visitor.graph.get(&id) {
-                    for i in next {
-                        if !visitor.has_side_effect.contains(i) {
-                            visitor.has_side_effect.insert(*i);
-                            queue.push_back(*i);
-                        }
-                    }
-                }
-            }
-
-            for (id, span, ident) in param_span {
-                // if the variable is not used in recursion, it would be marked as unused
-                if !visitor.has_side_effect.contains(&id) {
-                    let mut queue = VecDeque::new();
-                    let mut visited = FxHashSet::default();
-
-                    queue.push_back(id);
-
-                    // a simple BFS to check the graph can reach to itself
-                    // if it can't, it means the variable is never used in recursion
-                    while let Some(id) = queue.pop_front() {
-                        if let Some(next) = visitor.graph.get(&id) {
-                            for i in next {
-                                if !visited.contains(i) {
-                                    visited.insert(id);
-                                    queue.push_back(*i);
-                                }
-                            }
-                        }
-                    }
+impl_lint_pass!(OnlyUsedInRecursion => [ONLY_USED_IN_RECURSION]);
+
+#[derive(Clone, Copy)]
+enum FnKind {
+    Fn,
+    TraitFn,
+    // This is a hack. Ideally we would store a `SubstsRef<'tcx>` type here, but a lint pass must be `'static`.
+    // Substitutions are, however, interned. This allows us to store the pointer as a `usize` when comparing for
+    // equality.
+    ImplTraitFn(usize),
+}
 
-                    if visited.contains(&id) {
-                        span_lint_and_sugg(
-                            cx,
-                            ONLY_USED_IN_RECURSION,
-                            span,
-                            "parameter is only used in recursion",
-                            "if this is intentional, prefix with an underscore",
-                            format!("_{}", ident.name.as_str()),
-                            Applicability::MaybeIncorrect,
-                        );
-                    }
-                }
-            }
+struct Param {
+    /// The function this is a parameter for.
+    fn_id: DefId,
+    fn_kind: FnKind,
+    /// The index of this parameter.
+    idx: usize,
+    ident: Ident,
+    /// Whether this parameter should be linted. Set by `Params::flag_for_linting`.
+    apply_lint: Cell<bool>,
+    /// All the uses of this parameter.
+    uses: Vec<Usage>,
+}
+impl Param {
+    fn new(fn_id: DefId, fn_kind: FnKind, idx: usize, ident: Ident) -> Self {
+        Self {
+            fn_id,
+            fn_kind,
+            idx,
+            ident,
+            apply_lint: Cell::new(true),
+            uses: Vec::new(),
         }
     }
 }
 
-pub fn is_primitive(ty: Ty<'_>) -> bool {
-    let ty = ty.peel_refs();
-    ty.is_primitive() || ty.is_str()
+#[derive(Debug)]
+struct Usage {
+    span: Span,
+    idx: usize,
 }
-
-pub fn is_array(ty: Ty<'_>) -> bool {
-    let ty = ty.peel_refs();
-    ty.is_array() || ty.is_array_slice()
+impl Usage {
+    fn new(span: Span, idx: usize) -> Self {
+        Self { span, idx }
+    }
 }
 
-/// This builds the graph of side effect.
-/// The edge `a -> b` means if `a` has side effect, `b` will have side effect.
-///
-/// There are some example in following code:
-/// ```rust, ignore
-/// let b = 1;
-/// let a = b; // a -> b
-/// let (c, d) = (a, b); // c -> b, d -> b
-///
-/// let e = if a == 0 { // e -> a
-///     c // e -> c
-/// } else {
-///     d // e -> d
-/// };
-/// ```
-pub struct SideEffectVisit<'tcx> {
-    graph: FxHashMap<HirId, FxHashSet<HirId>>,
-    has_side_effect: FxHashSet<HirId>,
-    // bool for if the variable was dereferenced from mutable reference
-    ret_vars: Vec<(HirId, bool)>,
-    contains_side_effect: bool,
-    // break label
-    break_vars: FxHashMap<Ident, Vec<(HirId, bool)>>,
-    params: Vec<&'tcx Pat<'tcx>>,
-    fn_ident: Ident,
-    fn_def_id: DefId,
-    is_method: bool,
-    has_self: bool,
-    ty_res: &'tcx TypeckResults<'tcx>,
-    tcx: TyCtxt<'tcx>,
-    visited_exprs: FxHashSet<HirId>,
+/// The parameters being checked by the lint, indexed by both the parameter's `HirId` and the
+/// `DefId` of the function paired with the parameter's index.
+#[derive(Default)]
+struct Params {
+    params: Vec<Param>,
+    by_id: HirIdMap<usize>,
+    by_fn: FxHashMap<(DefId, usize), usize>,
 }
-
-impl<'tcx> Visitor<'tcx> for SideEffectVisit<'tcx> {
-    fn visit_stmt(&mut self, s: &'tcx Stmt<'tcx>) {
-        match s.kind {
-            StmtKind::Local(Local {
-                pat, init: Some(init), ..
-            }) => {
-                self.visit_pat_expr(pat, init, false);
-            },
-            StmtKind::Item(_) | StmtKind::Expr(_) | StmtKind::Semi(_) => {
-                walk_stmt(self, s);
-            },
-            StmtKind::Local(_) => {},
-        }
-        self.ret_vars.clear();
+impl Params {
+    fn insert(&mut self, param: Param, id: HirId) {
+        let idx = self.params.len();
+        self.by_id.insert(id, idx);
+        self.by_fn.insert((param.fn_id, param.idx), idx);
+        self.params.push(param);
     }
 
-    fn visit_expr(&mut self, ex: &'tcx Expr<'tcx>) {
-        if !self.visited_exprs.insert(ex.hir_id) {
-            return;
-        }
-        match ex.kind {
-            ExprKind::Array(exprs) | ExprKind::Tup(exprs) => {
-                self.ret_vars = exprs
-                    .iter()
-                    .flat_map(|expr| {
-                        self.visit_expr(expr);
-                        std::mem::take(&mut self.ret_vars)
-                    })
-                    .collect();
-            },
-            ExprKind::Call(callee, args) => self.visit_fn(callee, args),
-            ExprKind::MethodCall(path, args, _) => self.visit_method_call(path, args),
-            ExprKind::Binary(_, lhs, rhs) => {
-                self.visit_bin_op(lhs, rhs);
-            },
-            ExprKind::Unary(op, expr) => self.visit_un_op(op, expr),
-            ExprKind::Let(Let { pat, init, .. }) => self.visit_pat_expr(pat, init, false),
-            ExprKind::If(bind, then_expr, else_expr) => {
-                self.visit_if(bind, then_expr, else_expr);
-            },
-            ExprKind::Match(expr, arms, _) => self.visit_match(expr, arms),
-            // since analysing the closure is not easy, just set all variables in it to side-effect
-            ExprKind::Closure(&Closure { body, .. }) => {
-                let body = self.tcx.hir().body(body);
-                self.visit_body(body);
-                let vars = std::mem::take(&mut self.ret_vars);
-                self.add_side_effect(vars);
-            },
-            ExprKind::Loop(block, label, _, _) | ExprKind::Block(block, label) => {
-                self.visit_block_label(block, label);
-            },
-            ExprKind::Assign(bind, expr, _) => {
-                self.visit_assign(bind, expr);
-            },
-            ExprKind::AssignOp(_, bind, expr) => {
-                self.visit_assign(bind, expr);
-                self.visit_bin_op(bind, expr);
-            },
-            ExprKind::Field(expr, _) => {
-                self.visit_expr(expr);
-                if matches!(self.ty_res.expr_ty(expr).kind(), ty::Ref(_, _, Mutability::Mut)) {
-                    self.ret_vars.iter_mut().for_each(|(_, b)| *b = true);
-                }
-            },
-            ExprKind::Index(expr, index) => {
-                self.visit_expr(expr);
-                let mut vars = std::mem::take(&mut self.ret_vars);
-                self.visit_expr(index);
-                self.ret_vars.append(&mut vars);
-
-                if !is_array(self.ty_res.expr_ty(expr)) {
-                    self.add_side_effect(self.ret_vars.clone());
-                } else if matches!(self.ty_res.expr_ty(expr).kind(), ty::Ref(_, _, Mutability::Mut)) {
-                    self.ret_vars.iter_mut().for_each(|(_, b)| *b = true);
-                }
-            },
-            ExprKind::Break(dest, Some(expr)) => {
-                self.visit_expr(expr);
-                if let Some(label) = dest.label {
-                    self.break_vars
-                        .entry(label.ident)
-                        .or_insert(Vec::new())
-                        .append(&mut self.ret_vars);
-                }
-                self.contains_side_effect = true;
-            },
-            ExprKind::Ret(Some(expr)) => {
-                self.visit_expr(expr);
-                let vars = std::mem::take(&mut self.ret_vars);
-                self.add_side_effect(vars);
-                self.contains_side_effect = true;
-            },
-            ExprKind::Break(_, None) | ExprKind::Continue(_) | ExprKind::Ret(None) => {
-                self.contains_side_effect = true;
-            },
-            ExprKind::Struct(_, exprs, expr) => {
-                let mut ret_vars = exprs
-                    .iter()
-                    .flat_map(|field| {
-                        self.visit_expr(field.expr);
-                        std::mem::take(&mut self.ret_vars)
-                    })
-                    .collect();
-
-                walk_list!(self, visit_expr, expr);
-                self.ret_vars.append(&mut ret_vars);
-            },
-            _ => walk_expr(self, ex),
+    fn remove_by_id(&mut self, id: HirId) {
+        if let Some(param) = self.get_by_id_mut(id) {
+            param.uses = Vec::new();
+            let key = (param.fn_id, param.idx);
+            self.by_fn.remove(&key);
+            self.by_id.remove(&id);
         }
     }
 
-    fn visit_path(&mut self, path: &'tcx Path<'tcx>, _id: HirId) {
-        if let Res::Local(id) = path.res {
-            self.ret_vars.push((id, false));
-        }
+    fn get_by_id_mut(&mut self, id: HirId) -> Option<&mut Param> {
+        self.params.get_mut(*self.by_id.get(&id)?)
     }
-}
 
-impl<'tcx> SideEffectVisit<'tcx> {
-    fn visit_assign(&mut self, lhs: &'tcx Expr<'tcx>, rhs: &'tcx Expr<'tcx>) {
-        // Just support array and tuple unwrapping for now.
-        //
-        // ex) `(a, b) = (c, d);`
-        // The graph would look like this:
-        //   a -> c
-        //   b -> d
-        //
-        // This would minimize the connection of the side-effect graph.
-        match (&lhs.kind, &rhs.kind) {
-            (ExprKind::Array(lhs), ExprKind::Array(rhs)) | (ExprKind::Tup(lhs), ExprKind::Tup(rhs)) => {
-                // if not, it is a compile error
-                debug_assert!(lhs.len() == rhs.len());
-                izip!(*lhs, *rhs).for_each(|(lhs, rhs)| self.visit_assign(lhs, rhs));
-            },
-            // in other assigns, we have to connect all each other
-            // because they can be connected somehow
-            _ => {
-                self.visit_expr(lhs);
-                let lhs_vars = std::mem::take(&mut self.ret_vars);
-                self.visit_expr(rhs);
-                let rhs_vars = std::mem::take(&mut self.ret_vars);
-                self.connect_assign(&lhs_vars, &rhs_vars, false);
-            },
-        }
+    fn get_by_fn(&self, id: DefId, idx: usize) -> Option<&Param> {
+        self.params.get(*self.by_fn.get(&(id, idx))?)
     }
 
-    fn visit_block_label(&mut self, block: &'tcx Block<'tcx>, label: Option<Label>) {
-        self.visit_block(block);
-        let _ = label.and_then(|label| {
-            self.break_vars
-                .remove(&label.ident)
-                .map(|mut break_vars| self.ret_vars.append(&mut break_vars))
-        });
-    }
-
-    fn visit_bin_op(&mut self, lhs: &'tcx Expr<'tcx>, rhs: &'tcx Expr<'tcx>) {
-        self.visit_expr(lhs);
-        let mut ret_vars = std::mem::take(&mut self.ret_vars);
-        self.visit_expr(rhs);
-        self.ret_vars.append(&mut ret_vars);
-
-        // the binary operation between non primitive values are overloaded operators
-        // so they can have side-effects
-        if !is_primitive(self.ty_res.expr_ty(lhs)) || !is_primitive(self.ty_res.expr_ty(rhs)) {
-            self.ret_vars.iter().for_each(|id| {
-                self.has_side_effect.insert(id.0);
-            });
-            self.contains_side_effect = true;
-        }
+    fn clear(&mut self) {
+        self.params.clear();
+        self.by_id.clear();
+        self.by_fn.clear();
     }
 
-    fn visit_un_op(&mut self, op: UnOp, expr: &'tcx Expr<'tcx>) {
-        self.visit_expr(expr);
-        let ty = self.ty_res.expr_ty(expr);
-        // dereferencing a reference has no side-effect
-        if !is_primitive(ty) && !matches!((op, ty.kind()), (UnOp::Deref, ty::Ref(..))) {
-            self.add_side_effect(self.ret_vars.clone());
-        }
-
-        if matches!((op, ty.kind()), (UnOp::Deref, ty::Ref(_, _, Mutability::Mut))) {
-            self.ret_vars.iter_mut().for_each(|(_, b)| *b = true);
+    /// Sets the `apply_lint` flag on each parameter.
+    fn flag_for_linting(&mut self) {
+        // Stores the list of parameters currently being resolved. Needed to avoid cycles.
+        let mut eval_stack = Vec::new();
+        for param in &self.params {
+            self.try_disable_lint_for_param(param, &mut eval_stack);
         }
     }
 
-    fn visit_pat_expr(&mut self, pat: &'tcx Pat<'tcx>, expr: &'tcx Expr<'tcx>, connect_self: bool) {
-        match (&pat.kind, &expr.kind) {
-            (PatKind::Tuple(pats, _), ExprKind::Tup(exprs)) => {
-                self.ret_vars = izip!(*pats, *exprs)
-                    .flat_map(|(pat, expr)| {
-                        self.visit_pat_expr(pat, expr, connect_self);
-                        std::mem::take(&mut self.ret_vars)
-                    })
-                    .collect();
-            },
-            (PatKind::Slice(front_exprs, _, back_exprs), ExprKind::Array(exprs)) => {
-                let mut vars = izip!(*front_exprs, *exprs)
-                    .flat_map(|(pat, expr)| {
-                        self.visit_pat_expr(pat, expr, connect_self);
-                        std::mem::take(&mut self.ret_vars)
-                    })
-                    .collect();
-                self.ret_vars = izip!(back_exprs.iter().rev(), exprs.iter().rev())
-                    .flat_map(|(pat, expr)| {
-                        self.visit_pat_expr(pat, expr, connect_self);
-                        std::mem::take(&mut self.ret_vars)
-                    })
-                    .collect();
-                self.ret_vars.append(&mut vars);
-            },
-            _ => {
-                let mut lhs_vars = Vec::new();
-                pat.each_binding(|_, id, _, _| lhs_vars.push((id, false)));
-                self.visit_expr(expr);
-                let rhs_vars = std::mem::take(&mut self.ret_vars);
-                self.connect_assign(&lhs_vars, &rhs_vars, connect_self);
-                self.ret_vars = rhs_vars;
-            },
+    // Use by calling `flag_for_linting`.
+    fn try_disable_lint_for_param(&self, param: &Param, eval_stack: &mut Vec<usize>) -> bool {
+        if !param.apply_lint.get() {
+            true
+        } else if param.uses.is_empty() {
+            // Don't lint on unused parameters.
+            param.apply_lint.set(false);
+            true
+        } else if eval_stack.contains(&param.idx) {
+            // Already on the evaluation stack. Returning false will continue to evaluate other dependencies.
+            false
+        } else {
+            eval_stack.push(param.idx);
+            // Check all cases when used at a different parameter index.
+            // Needed to catch cases like: `fn f(x: u32, y: u32) { f(y, x) }`
+            for usage in param.uses.iter().filter(|u| u.idx != param.idx) {
+                if self
+                    .get_by_fn(param.fn_id, usage.idx)
+                    // If the parameter can't be found, then it's used for more than just recursion.
+                    .map_or(true, |p| self.try_disable_lint_for_param(p, eval_stack))
+                {
+                    param.apply_lint.set(false);
+                    eval_stack.pop();
+                    return true;
+                }
+            }
+            eval_stack.pop();
+            false
         }
     }
+}
 
-    fn visit_fn(&mut self, callee: &'tcx Expr<'tcx>, args: &'tcx [Expr<'tcx>]) {
-        self.visit_expr(callee);
-        let mut ret_vars = std::mem::take(&mut self.ret_vars);
-        self.add_side_effect(ret_vars.clone());
-
-        let mut is_recursive = false;
-
-        if_chain! {
-            if !self.has_self;
-            if let ExprKind::Path(QPath::Resolved(_, path)) = callee.kind;
-            if let Res::Def(DefKind::Fn, def_id) = path.res;
-            if self.fn_def_id == def_id;
-            then {
-                is_recursive = true;
-            }
-        }
+#[derive(Default)]
+pub struct OnlyUsedInRecursion {
+    /// Track the top-level body entered. Needed to delay reporting when entering nested bodies.
+    entered_body: Option<HirId>,
+    params: Params,
+}
 
-        if_chain! {
-            if !self.has_self && self.is_method;
-            if let ExprKind::Path(QPath::TypeRelative(ty, segment)) = callee.kind;
-            if segment.ident == self.fn_ident;
-            if let TyKind::Path(QPath::Resolved(_, path)) = ty.kind;
-            if let Res::SelfTy{ .. } = path.res;
-            then {
-                is_recursive = true;
-            }
+impl<'tcx> LateLintPass<'tcx> for OnlyUsedInRecursion {
+    fn check_body(&mut self, cx: &LateContext<'tcx>, body: &'tcx Body<'tcx>) {
+        if body.value.span.from_expansion() {
+            return;
         }
-
-        if is_recursive {
-            izip!(self.params.clone(), args).for_each(|(pat, expr)| {
-                self.visit_pat_expr(pat, expr, true);
-                self.ret_vars.clear();
-            });
-        } else {
-            // This would set arguments used in closure that does not have side-effect.
-            // Closure itself can be detected whether there is a side-effect, but the
-            // value of variable that is holding closure can change.
-            // So, we just check the variables.
-            self.ret_vars = args
-                .iter()
-                .flat_map(|expr| {
-                    self.visit_expr(expr);
-                    std::mem::take(&mut self.ret_vars)
-                })
-                .collect_vec()
-                .into_iter()
-                .map(|id| {
-                    self.has_side_effect.insert(id.0);
-                    id
-                })
-                .collect();
-            self.contains_side_effect = true;
+        // `skip_params` is either `0` or `1` to skip the `self` parameter in trait functions.
+        // It can't be renamed, and it can't be removed without removing it from multiple functions.
+        let (fn_id, fn_kind, skip_params) = match get_parent_node(cx.tcx, body.value.hir_id) {
+            Some(Node::Item(i)) => (i.def_id.to_def_id(), FnKind::Fn, 0),
+            Some(Node::TraitItem(&TraitItem {
+                kind: TraitItemKind::Fn(ref sig, _),
+                def_id,
+                ..
+            })) => (
+                def_id.to_def_id(),
+                FnKind::TraitFn,
+                if sig.decl.implicit_self.has_implicit_self() {
+                    1
+                } else {
+                    0
+                },
+            ),
+            Some(Node::ImplItem(&ImplItem {
+                kind: ImplItemKind::Fn(ref sig, _),
+                def_id,
+                ..
+            })) => {
+                #[allow(trivial_casts)]
+                if let Some(Node::Item(item)) = get_parent_node(cx.tcx, cx.tcx.hir().local_def_id_to_hir_id(def_id))
+                    && let Some(trait_ref) = cx.tcx.impl_trait_ref(item.def_id)
+                    && let Some(trait_item_id) = cx.tcx.associated_item(def_id).trait_item_def_id
+                {
+                    (
+                        trait_item_id,
+                        FnKind::ImplTraitFn(cx.tcx.erase_regions(trait_ref.substs) as *const _ as usize),
+                        if sig.decl.implicit_self.has_implicit_self() {
+                            1
+                        } else {
+                            0
+                        },
+                    )
+                } else {
+                    (def_id.to_def_id(), FnKind::Fn, 0)
+                }
+            },
+            _ => return,
+        };
+        body.params
+            .iter()
+            .enumerate()
+            .skip(skip_params)
+            .filter_map(|(idx, p)| match p.pat.kind {
+                PatKind::Binding(_, id, ident, None) if !ident.as_str().starts_with('_') => {
+                    Some((id, Param::new(fn_id, fn_kind, idx, ident)))
+                },
+                _ => None,
+            })
+            .for_each(|(id, param)| self.params.insert(param, id));
+        if self.entered_body.is_none() {
+            self.entered_body = Some(body.value.hir_id);
         }
-
-        self.ret_vars.append(&mut ret_vars);
     }
 
-    fn visit_method_call(&mut self, path: &'tcx PathSegment<'tcx>, args: &'tcx [Expr<'tcx>]) {
-        if_chain! {
-            if self.is_method;
-            if path.ident == self.fn_ident;
-            if let ExprKind::Path(QPath::Resolved(_, path)) = args.first().unwrap().kind;
-            if let Res::Local(..) = path.res;
-            let ident = path.segments.last().unwrap().ident;
-            if ident.name == kw::SelfLower;
-            then {
-                izip!(self.params.clone(), args.iter())
-                    .for_each(|(pat, expr)| {
-                        self.visit_pat_expr(pat, expr, true);
-                        self.ret_vars.clear();
-                    });
-            } else {
-                self.ret_vars = args
-                    .iter()
-                    .flat_map(|expr| {
-                        self.visit_expr(expr);
-                        std::mem::take(&mut self.ret_vars)
-                    })
-                    .collect_vec()
-                    .into_iter()
-                    .map(|a| {
-                        self.has_side_effect.insert(a.0);
-                        a
-                    })
-                    .collect();
-                self.contains_side_effect = true;
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'tcx>) {
+        if let Some(id) = path_to_local(e)
+            && let Some(param) = self.params.get_by_id_mut(id)
+        {
+            let typeck = cx.typeck_results();
+            let span = e.span;
+            let mut e = e;
+            loop {
+                match get_expr_use_or_unification_node(cx.tcx, e) {
+                    None | Some((Node::Stmt(_), _)) => return,
+                    Some((Node::Expr(parent), child_id)) => match parent.kind {
+                        // Recursive call. Track which index the parameter is used in.
+                        ExprKind::Call(callee, args)
+                            if path_def_id(cx, callee).map_or(false, |id| {
+                                id == param.fn_id
+                                    && has_matching_substs(param.fn_kind, typeck.node_substs(callee.hir_id))
+                            }) =>
+                        {
+                            if let Some(idx) = args.iter().position(|arg| arg.hir_id == child_id) {
+                                param.uses.push(Usage::new(span, idx));
+                            }
+                            return;
+                        },
+                        ExprKind::MethodCall(_, args, _)
+                            if typeck.type_dependent_def_id(parent.hir_id).map_or(false, |id| {
+                                id == param.fn_id
+                                    && has_matching_substs(param.fn_kind, typeck.node_substs(parent.hir_id))
+                            }) =>
+                        {
+                            if let Some(idx) = args.iter().position(|arg| arg.hir_id == child_id) {
+                                param.uses.push(Usage::new(span, idx));
+                            }
+                            return;
+                        },
+                        // Assignment to a parameter is fine.
+                        ExprKind::Assign(lhs, _, _) | ExprKind::AssignOp(_, lhs, _) if lhs.hir_id == child_id => {
+                            return;
+                        },
+                        // Parameter update e.g. `x = x + 1`
+                        ExprKind::Assign(lhs, rhs, _) | ExprKind::AssignOp(_, lhs, rhs)
+                            if rhs.hir_id == child_id && path_to_local_id(lhs, id) =>
+                        {
+                            return;
+                        },
+                        // Side-effect free expressions. Walk to the parent expression.
+                        ExprKind::Binary(_, lhs, rhs)
+                            if typeck.expr_ty(lhs).is_primitive() && typeck.expr_ty(rhs).is_primitive() =>
+                        {
+                            e = parent;
+                            continue;
+                        },
+                        ExprKind::Unary(_, arg) if typeck.expr_ty(arg).is_primitive() => {
+                            e = parent;
+                            continue;
+                        },
+                        ExprKind::AddrOf(..) | ExprKind::Cast(..) => {
+                            e = parent;
+                            continue;
+                        },
+                        // Only allow field accesses without auto-deref
+                        ExprKind::Field(..) if typeck.adjustments().get(child_id).is_none() => {
+                            e = parent;
+                            continue
+                        }
+                        _ => (),
+                    },
+                    _ => (),
+                }
+                self.params.remove_by_id(id);
+                return;
             }
         }
     }
 
-    fn visit_if(&mut self, bind: &'tcx Expr<'tcx>, then_expr: &'tcx Expr<'tcx>, else_expr: Option<&'tcx Expr<'tcx>>) {
-        let contains_side_effect = self.contains_side_effect;
-        self.contains_side_effect = false;
-        self.visit_expr(bind);
-        let mut vars = std::mem::take(&mut self.ret_vars);
-        self.visit_expr(then_expr);
-        let mut then_vars = std::mem::take(&mut self.ret_vars);
-        walk_list!(self, visit_expr, else_expr);
-        if self.contains_side_effect {
-            self.add_side_effect(vars.clone());
-        }
-        self.contains_side_effect |= contains_side_effect;
-        self.ret_vars.append(&mut vars);
-        self.ret_vars.append(&mut then_vars);
-    }
-
-    fn visit_match(&mut self, expr: &'tcx Expr<'tcx>, arms: &'tcx [Arm<'tcx>]) {
-        self.visit_expr(expr);
-        let mut expr_vars = std::mem::take(&mut self.ret_vars);
-        self.ret_vars = arms
-            .iter()
-            .flat_map(|arm| {
-                let contains_side_effect = self.contains_side_effect;
-                self.contains_side_effect = false;
-                // this would visit `expr` multiple times
-                // but couldn't think of a better way
-                self.visit_pat_expr(arm.pat, expr, false);
-                let mut vars = std::mem::take(&mut self.ret_vars);
-                let _ = arm.guard.as_ref().map(|guard| {
-                    self.visit_expr(match guard {
-                        Guard::If(expr) | Guard::IfLet(Let { init: expr, .. }) => expr,
-                    });
-                    vars.append(&mut self.ret_vars);
-                });
-                self.visit_expr(arm.body);
-                if self.contains_side_effect {
-                    self.add_side_effect(vars.clone());
-                    self.add_side_effect(expr_vars.clone());
+    fn check_body_post(&mut self, cx: &LateContext<'tcx>, body: &'tcx Body<'tcx>) {
+        if self.entered_body == Some(body.value.hir_id) {
+            self.entered_body = None;
+            self.params.flag_for_linting();
+            for param in &self.params.params {
+                if param.apply_lint.get() {
+                    span_lint_and_then(
+                        cx,
+                        ONLY_USED_IN_RECURSION,
+                        param.ident.span,
+                        "parameter is only used in recursion",
+                        |diag| {
+                            if param.ident.name != kw::SelfLower {
+                                diag.span_suggestion(
+                                    param.ident.span,
+                                    "if this is intentional, prefix it with an underscore",
+                                    format!("_{}", param.ident.name),
+                                    Applicability::MaybeIncorrect,
+                                );
+                            }
+                            diag.span_note(
+                                param.uses.iter().map(|x| x.span).collect::<Vec<_>>(),
+                                "parameter used here",
+                            );
+                        },
+                    );
                 }
-                self.contains_side_effect |= contains_side_effect;
-                vars.append(&mut self.ret_vars);
-                vars
-            })
-            .collect();
-        self.ret_vars.append(&mut expr_vars);
-    }
-
-    fn connect_assign(&mut self, lhs: &[(HirId, bool)], rhs: &[(HirId, bool)], connect_self: bool) {
-        // if mutable dereference is on assignment it can have side-effect
-        // (this can lead to parameter mutable dereference and change the original value)
-        // too hard to detect whether this value is from parameter, so this would all
-        // check mutable dereference assignment to side effect
-        lhs.iter().filter(|(_, b)| *b).for_each(|(id, _)| {
-            self.has_side_effect.insert(*id);
-            self.contains_side_effect = true;
-        });
-
-        // there is no connection
-        if lhs.is_empty() || rhs.is_empty() {
-            return;
-        }
-
-        // by connected rhs in cycle, the connections would decrease
-        // from `n * m` to `n + m`
-        // where `n` and `m` are length of `lhs` and `rhs`.
-
-        // unwrap is possible since rhs is not empty
-        let rhs_first = rhs.first().unwrap();
-        for (id, _) in lhs.iter() {
-            if connect_self || *id != rhs_first.0 {
-                self.graph
-                    .entry(*id)
-                    .or_insert_with(FxHashSet::default)
-                    .insert(rhs_first.0);
             }
+            self.params.clear();
         }
-
-        let rhs = rhs.iter();
-        izip!(rhs.clone().cycle().skip(1), rhs).for_each(|(from, to)| {
-            if connect_self || from.0 != to.0 {
-                self.graph.entry(from.0).or_insert_with(FxHashSet::default).insert(to.0);
-            }
-        });
     }
+}
 
-    fn add_side_effect(&mut self, v: Vec<(HirId, bool)>) {
-        for (id, _) in v {
-            self.has_side_effect.insert(id);
-            self.contains_side_effect = true;
-        }
+fn has_matching_substs(kind: FnKind, substs: SubstsRef<'_>) -> bool {
+    match kind {
+        FnKind::Fn => true,
+        FnKind::TraitFn => substs.iter().enumerate().all(|(idx, subst)| match subst.unpack() {
+            GenericArgKind::Lifetime(_) => true,
+            GenericArgKind::Type(ty) => matches!(*ty.kind(), ty::Param(ty) if ty.index as usize == idx),
+            GenericArgKind::Const(c) => matches!(c.kind(), ConstKind::Param(c) if c.index as usize == idx),
+        }),
+        #[allow(trivial_casts)]
+        FnKind::ImplTraitFn(expected_substs) => substs as *const _ as usize == expected_substs,
     }
 }
diff --git a/tests/ui/only_used_in_recursion.rs b/tests/ui/only_used_in_recursion.rs
index 5768434f988..f71e8ead519 100644
--- a/tests/ui/only_used_in_recursion.rs
+++ b/tests/ui/only_used_in_recursion.rs
@@ -1,122 +1,113 @@
 #![warn(clippy::only_used_in_recursion)]
 
-fn simple(a: usize, b: usize) -> usize {
-    if a == 0 { 1 } else { simple(a - 1, b) }
+fn _simple(x: u32) -> u32 {
+    x
 }
 
-fn with_calc(a: usize, b: isize) -> usize {
-    if a == 0 { 1 } else { with_calc(a - 1, -b + 1) }
+fn _simple2(x: u32) -> u32 {
+    _simple(x)
 }
 
-fn tuple((a, b): (usize, usize)) -> usize {
-    if a == 0 { 1 } else { tuple((a - 1, b + 1)) }
+fn _one_unused(flag: u32, a: usize) -> usize {
+    if flag == 0 { 0 } else { _one_unused(flag - 1, a) }
 }
 
-fn let_tuple(a: usize, b: usize) -> usize {
-    let (c, d) = (a, b);
-    if c == 0 { 1 } else { let_tuple(c - 1, d + 1) }
+fn _two_unused(flag: u32, a: u32, b: i32) -> usize {
+    if flag == 0 { 0 } else { _two_unused(flag - 1, a, b) }
 }
 
-fn array([a, b]: [usize; 2]) -> usize {
-    if a == 0 { 1 } else { array([a - 1, b + 1]) }
-}
-
-fn index(a: usize, mut b: &[usize], c: usize) -> usize {
-    if a == 0 { 1 } else { index(a - 1, b, c + b[0]) }
-}
-
-fn break_(a: usize, mut b: usize, mut c: usize) -> usize {
-    let c = loop {
-        b += 1;
-        c += 1;
-        if c == 10 {
-            break b;
-        }
-    };
-
-    if a == 0 { 1 } else { break_(a - 1, c, c) }
+fn _with_calc(flag: u32, a: i64) -> usize {
+    if flag == 0 {
+        0
+    } else {
+        _with_calc(flag - 1, (-a + 10) * 5)
+    }
 }
 
-// this has a side effect
-fn mut_ref(a: usize, b: &mut usize) -> usize {
-    *b = 1;
-    if a == 0 { 1 } else { mut_ref(a - 1, b) }
+// Don't lint
+fn _used_with_flag(flag: u32, a: u32) -> usize {
+    if flag == 0 { 0 } else { _used_with_flag(flag ^ a, a - 1) }
 }
 
-fn mut_ref2(a: usize, b: &mut usize) -> usize {
-    let mut c = *b;
-    if a == 0 { 1 } else { mut_ref2(a - 1, &mut c) }
+fn _used_with_unused(flag: u32, a: i32, b: i32) -> usize {
+    if flag == 0 {
+        0
+    } else {
+        _used_with_unused(flag - 1, -a, a + b)
+    }
 }
 
-fn not_primitive(a: usize, b: String) -> usize {
-    if a == 0 { 1 } else { not_primitive(a - 1, b) }
+fn _codependent_unused(flag: u32, a: i32, b: i32) -> usize {
+    if flag == 0 {
+        0
+    } else {
+        _codependent_unused(flag - 1, a * b, a + b)
+    }
 }
 
-// this doesn't have a side effect,
-// but `String` is not primitive.
-fn not_primitive_op(a: usize, b: String, c: &str) -> usize {
-    if a == 1 { 1 } else { not_primitive_op(a, b + c, c) }
+fn _not_primitive(flag: u32, b: String) -> usize {
+    if flag == 0 { 0 } else { _not_primitive(flag - 1, b) }
 }
 
 struct A;
 
 impl A {
-    fn method(a: usize, b: usize) -> usize {
-        if a == 0 { 1 } else { A::method(a - 1, b - 1) }
+    fn _method(flag: usize, a: usize) -> usize {
+        if flag == 0 { 0 } else { Self::_method(flag - 1, a) }
     }
 
-    fn method2(&self, a: usize, b: usize) -> usize {
-        if a == 0 { 1 } else { self.method2(a - 1, b + 1) }
+    fn _method_self(&self, flag: usize, a: usize) -> usize {
+        if flag == 0 { 0 } else { self._method_self(flag - 1, a) }
     }
 }
 
 trait B {
-    fn hello(a: usize, b: usize) -> usize;
-
-    fn hello2(&self, a: usize, b: usize) -> usize;
+    fn method(flag: u32, a: usize) -> usize;
+    fn method_self(&self, flag: u32, a: usize) -> usize;
 }
 
 impl B for A {
-    fn hello(a: usize, b: usize) -> usize {
-        if a == 0 { 1 } else { A::hello(a - 1, b + 1) }
+    fn method(flag: u32, a: usize) -> usize {
+        if flag == 0 { 0 } else { Self::method(flag - 1, a) }
     }
 
-    fn hello2(&self, a: usize, b: usize) -> usize {
-        if a == 0 { 1 } else { self.hello2(a - 1, b + 1) }
+    fn method_self(&self, flag: u32, a: usize) -> usize {
+        if flag == 0 { 0 } else { self.method_self(flag - 1, a) }
     }
 }
 
-trait C {
-    fn hello(a: usize, b: usize) -> usize {
-        if a == 0 { 1 } else { Self::hello(a - 1, b + 1) }
+impl B for () {
+    fn method(flag: u32, a: usize) -> usize {
+        if flag == 0 { 0 } else { a }
     }
 
-    fn hello2(&self, a: usize, b: usize) -> usize {
-        if a == 0 { 1 } else { self.hello2(a - 1, b + 1) }
+    fn method_self(&self, flag: u32, a: usize) -> usize {
+        if flag == 0 { 0 } else { a }
     }
 }
 
-fn ignore(a: usize, _: usize) -> usize {
-    if a == 1 { 1 } else { ignore(a - 1, 0) }
-}
+impl B for u32 {
+    fn method(flag: u32, a: usize) -> usize {
+        if flag == 0 { 0 } else { <() as B>::method(flag, a) }
+    }
 
-fn ignore2(a: usize, _b: usize) -> usize {
-    if a == 1 { 1 } else { ignore2(a - 1, _b) }
+    fn method_self(&self, flag: u32, a: usize) -> usize {
+        if flag == 0 { 0 } else { ().method_self(flag, a) }
+    }
 }
 
-fn f1(a: u32) -> u32 {
-    a
-}
+trait C {
+    fn method(flag: u32, a: usize) -> usize {
+        if flag == 0 { 0 } else { Self::method(flag - 1, a) }
+    }
 
-fn f2(a: u32) -> u32 {
-    f1(a)
+    fn method_self(&self, flag: u32, a: usize) -> usize {
+        if flag == 0 { 0 } else { self.method_self(flag - 1, a) }
+    }
 }
 
-fn inner_fn(a: u32) -> u32 {
-    fn inner_fn(a: u32) -> u32 {
-        a
-    }
-    inner_fn(a)
+fn _ignore(flag: usize, _a: usize) -> usize {
+    if flag == 0 { 0 } else { _ignore(flag - 1, _a) }
 }
 
 fn main() {}
diff --git a/tests/ui/only_used_in_recursion.stderr b/tests/ui/only_used_in_recursion.stderr
index 6fe9361bf5f..74057ddcfda 100644
--- a/tests/ui/only_used_in_recursion.stderr
+++ b/tests/ui/only_used_in_recursion.stderr
@@ -1,82 +1,195 @@
 error: parameter is only used in recursion
-  --> $DIR/only_used_in_recursion.rs:3:21
+  --> $DIR/only_used_in_recursion.rs:11:27
    |
-LL | fn simple(a: usize, b: usize) -> usize {
-   |                     ^ help: if this is intentional, prefix with an underscore: `_b`
+LL | fn _one_unused(flag: u32, a: usize) -> usize {
+   |                           ^ help: if this is intentional, prefix it with an underscore: `_a`
    |
    = note: `-D clippy::only-used-in-recursion` implied by `-D warnings`
+note: parameter used here
+  --> $DIR/only_used_in_recursion.rs:12:53
+   |
+LL |     if flag == 0 { 0 } else { _one_unused(flag - 1, a) }
+   |                                                     ^
+
+error: parameter is only used in recursion
+  --> $DIR/only_used_in_recursion.rs:15:27
+   |
+LL | fn _two_unused(flag: u32, a: u32, b: i32) -> usize {
+   |                           ^ help: if this is intentional, prefix it with an underscore: `_a`
+   |
+note: parameter used here
+  --> $DIR/only_used_in_recursion.rs:16:53
+   |
+LL |     if flag == 0 { 0 } else { _two_unused(flag - 1, a, b) }
+   |                                                     ^
+
+error: parameter is only used in recursion
+  --> $DIR/only_used_in_recursion.rs:15:35
+   |
+LL | fn _two_unused(flag: u32, a: u32, b: i32) -> usize {
+   |                                   ^ help: if this is intentional, prefix it with an underscore: `_b`
+   |
+note: parameter used here
+  --> $DIR/only_used_in_recursion.rs:16:56
+   |
+LL |     if flag == 0 { 0 } else { _two_unused(flag - 1, a, b) }
+   |                                                        ^
+
+error: parameter is only used in recursion
+  --> $DIR/only_used_in_recursion.rs:19:26
+   |
+LL | fn _with_calc(flag: u32, a: i64) -> usize {
+   |                          ^ help: if this is intentional, prefix it with an underscore: `_a`
+   |
+note: parameter used here
+  --> $DIR/only_used_in_recursion.rs:23:32
+   |
+LL |         _with_calc(flag - 1, (-a + 10) * 5)
+   |                                ^
 
 error: parameter is only used in recursion
-  --> $DIR/only_used_in_recursion.rs:7:24
+  --> $DIR/only_used_in_recursion.rs:32:33
+   |
+LL | fn _used_with_unused(flag: u32, a: i32, b: i32) -> usize {
+   |                                 ^ help: if this is intentional, prefix it with an underscore: `_a`
+   |
+note: parameter used here
+  --> $DIR/only_used_in_recursion.rs:36:38
    |
-LL | fn with_calc(a: usize, b: isize) -> usize {
-   |                        ^ help: if this is intentional, prefix with an underscore: `_b`
+LL |         _used_with_unused(flag - 1, -a, a + b)
+   |                                      ^  ^
 
 error: parameter is only used in recursion
-  --> $DIR/only_used_in_recursion.rs:11:14
+  --> $DIR/only_used_in_recursion.rs:32:41
+   |
+LL | fn _used_with_unused(flag: u32, a: i32, b: i32) -> usize {
+   |                                         ^ help: if this is intentional, prefix it with an underscore: `_b`
+   |
+note: parameter used here
+  --> $DIR/only_used_in_recursion.rs:36:45
    |
-LL | fn tuple((a, b): (usize, usize)) -> usize {
-   |              ^ help: if this is intentional, prefix with an underscore: `_b`
+LL |         _used_with_unused(flag - 1, -a, a + b)
+   |                                             ^
 
 error: parameter is only used in recursion
-  --> $DIR/only_used_in_recursion.rs:15:24
+  --> $DIR/only_used_in_recursion.rs:40:35
    |
-LL | fn let_tuple(a: usize, b: usize) -> usize {
-   |                        ^ help: if this is intentional, prefix with an underscore: `_b`
+LL | fn _codependent_unused(flag: u32, a: i32, b: i32) -> usize {
+   |                                   ^ help: if this is intentional, prefix it with an underscore: `_a`
+   |
+note: parameter used here
+  --> $DIR/only_used_in_recursion.rs:44:39
+   |
+LL |         _codependent_unused(flag - 1, a * b, a + b)
+   |                                       ^      ^
 
 error: parameter is only used in recursion
-  --> $DIR/only_used_in_recursion.rs:20:14
+  --> $DIR/only_used_in_recursion.rs:40:43
+   |
+LL | fn _codependent_unused(flag: u32, a: i32, b: i32) -> usize {
+   |                                           ^ help: if this is intentional, prefix it with an underscore: `_b`
    |
-LL | fn array([a, b]: [usize; 2]) -> usize {
-   |              ^ help: if this is intentional, prefix with an underscore: `_b`
+note: parameter used here
+  --> $DIR/only_used_in_recursion.rs:44:43
+   |
+LL |         _codependent_unused(flag - 1, a * b, a + b)
+   |                                           ^      ^
 
 error: parameter is only used in recursion
-  --> $DIR/only_used_in_recursion.rs:24:20
+  --> $DIR/only_used_in_recursion.rs:48:30
+   |
+LL | fn _not_primitive(flag: u32, b: String) -> usize {
+   |                              ^ help: if this is intentional, prefix it with an underscore: `_b`
    |
-LL | fn index(a: usize, mut b: &[usize], c: usize) -> usize {
-   |                    ^^^^^ help: if this is intentional, prefix with an underscore: `_b`
+note: parameter used here
+  --> $DIR/only_used_in_recursion.rs:49:56
+   |
+LL |     if flag == 0 { 0 } else { _not_primitive(flag - 1, b) }
+   |                                                        ^
 
 error: parameter is only used in recursion
-  --> $DIR/only_used_in_recursion.rs:24:37
+  --> $DIR/only_used_in_recursion.rs:55:29
+   |
+LL |     fn _method(flag: usize, a: usize) -> usize {
+   |                             ^ help: if this is intentional, prefix it with an underscore: `_a`
+   |
+note: parameter used here
+  --> $DIR/only_used_in_recursion.rs:56:59
    |
-LL | fn index(a: usize, mut b: &[usize], c: usize) -> usize {
-   |                                     ^ help: if this is intentional, prefix with an underscore: `_c`
+LL |         if flag == 0 { 0 } else { Self::_method(flag - 1, a) }
+   |                                                           ^
 
 error: parameter is only used in recursion
-  --> $DIR/only_used_in_recursion.rs:28:21
+  --> $DIR/only_used_in_recursion.rs:59:22
+   |
+LL |     fn _method_self(&self, flag: usize, a: usize) -> usize {
+   |                      ^^^^
+   |
+note: parameter used here
+  --> $DIR/only_used_in_recursion.rs:60:35
    |
-LL | fn break_(a: usize, mut b: usize, mut c: usize) -> usize {
-   |                     ^^^^^ help: if this is intentional, prefix with an underscore: `_b`
+LL |         if flag == 0 { 0 } else { self._method_self(flag - 1, a) }
+   |                                   ^^^^
 
 error: parameter is only used in recursion
-  --> $DIR/only_used_in_recursion.rs:46:23
+  --> $DIR/only_used_in_recursion.rs:59:41
    |
-LL | fn mut_ref2(a: usize, b: &mut usize) -> usize {
-   |                       ^ help: if this is intentional, prefix with an underscore: `_b`
+LL |     fn _method_self(&self, flag: usize, a: usize) -> usize {
+   |                                         ^ help: if this is intentional, prefix it with an underscore: `_a`
+   |
+note: parameter used here
+  --> $DIR/only_used_in_recursion.rs:60:63
+   |
+LL |         if flag == 0 { 0 } else { self._method_self(flag - 1, a) }
+   |                                                               ^
 
 error: parameter is only used in recursion
-  --> $DIR/only_used_in_recursion.rs:51:28
+  --> $DIR/only_used_in_recursion.rs:70:26
+   |
+LL |     fn method(flag: u32, a: usize) -> usize {
+   |                          ^ help: if this is intentional, prefix it with an underscore: `_a`
    |
-LL | fn not_primitive(a: usize, b: String) -> usize {
-   |                            ^ help: if this is intentional, prefix with an underscore: `_b`
+note: parameter used here
+  --> $DIR/only_used_in_recursion.rs:71:58
+   |
+LL |         if flag == 0 { 0 } else { Self::method(flag - 1, a) }
+   |                                                          ^
 
 error: parameter is only used in recursion
-  --> $DIR/only_used_in_recursion.rs:68:33
+  --> $DIR/only_used_in_recursion.rs:74:38
+   |
+LL |     fn method_self(&self, flag: u32, a: usize) -> usize {
+   |                                      ^ help: if this is intentional, prefix it with an underscore: `_a`
    |
-LL |     fn method2(&self, a: usize, b: usize) -> usize {
-   |                                 ^ help: if this is intentional, prefix with an underscore: `_b`
+note: parameter used here
+  --> $DIR/only_used_in_recursion.rs:75:62
+   |
+LL |         if flag == 0 { 0 } else { self.method_self(flag - 1, a) }
+   |                                                              ^
 
 error: parameter is only used in recursion
-  --> $DIR/only_used_in_recursion.rs:90:24
+  --> $DIR/only_used_in_recursion.rs:100:26
+   |
+LL |     fn method(flag: u32, a: usize) -> usize {
+   |                          ^ help: if this is intentional, prefix it with an underscore: `_a`
+   |
+note: parameter used here
+  --> $DIR/only_used_in_recursion.rs:101:58
    |
-LL |     fn hello(a: usize, b: usize) -> usize {
-   |                        ^ help: if this is intentional, prefix with an underscore: `_b`
+LL |         if flag == 0 { 0 } else { Self::method(flag - 1, a) }
+   |                                                          ^
 
 error: parameter is only used in recursion
-  --> $DIR/only_used_in_recursion.rs:94:32
+  --> $DIR/only_used_in_recursion.rs:104:38
+   |
+LL |     fn method_self(&self, flag: u32, a: usize) -> usize {
+   |                                      ^ help: if this is intentional, prefix it with an underscore: `_a`
+   |
+note: parameter used here
+  --> $DIR/only_used_in_recursion.rs:105:62
    |
-LL |     fn hello2(&self, a: usize, b: usize) -> usize {
-   |                                ^ help: if this is intentional, prefix with an underscore: `_b`
+LL |         if flag == 0 { 0 } else { self.method_self(flag - 1, a) }
+   |                                                              ^
 
-error: aborting due to 13 previous errors
+error: aborting due to 16 previous errors
 
diff --git a/tests/ui/only_used_in_recursion2.rs b/tests/ui/only_used_in_recursion2.rs
new file mode 100644
index 00000000000..45dd0553f58
--- /dev/null
+++ b/tests/ui/only_used_in_recursion2.rs
@@ -0,0 +1,91 @@
+#![warn(clippy::only_used_in_recursion)]
+
+fn _with_inner(flag: u32, a: u32, b: u32) -> usize {
+    fn inner(flag: u32, a: u32) -> u32 {
+        if flag == 0 { 0 } else { inner(flag, a) }
+    }
+
+    let x = inner(flag, a);
+    if flag == 0 { 0 } else { _with_inner(flag, a, b + x) }
+}
+
+fn _with_closure(a: Option<u32>, b: u32, f: impl Fn(u32, u32) -> Option<u32>) -> u32 {
+    if let Some(x) = a.and_then(|x| f(x, x)) {
+        _with_closure(Some(x), b, f)
+    } else {
+        0
+    }
+}
+
+// Issue #8560
+trait D {
+    fn foo(&mut self, arg: u32) -> u32;
+}
+
+mod m {
+    pub struct S(u32);
+    impl S {
+        pub fn foo(&mut self, arg: u32) -> u32 {
+            arg + self.0
+        }
+    }
+}
+
+impl D for m::S {
+    fn foo(&mut self, arg: u32) -> u32 {
+        self.foo(arg)
+    }
+}
+
+// Issue #8782
+fn only_let(x: u32) {
+    let y = 10u32;
+    let _z = x * y;
+}
+
+trait E<T: E<()>> {
+    fn method(flag: u32, a: usize) -> usize {
+        if flag == 0 {
+            0
+        } else {
+            <T as E<()>>::method(flag - 1, a)
+        }
+    }
+}
+
+impl E<()> for () {
+    fn method(flag: u32, a: usize) -> usize {
+        if flag == 0 { 0 } else { a }
+    }
+}
+
+fn overwritten_param(flag: u32, mut a: usize) -> usize {
+    if flag == 0 {
+        return 0;
+    } else if flag > 5 {
+        a += flag as usize;
+    } else {
+        a = 5;
+    }
+    overwritten_param(flag, a)
+}
+
+fn field_direct(flag: u32, mut a: (usize,)) -> usize {
+    if flag == 0 {
+        0
+    } else {
+        a.0 += 5;
+        field_direct(flag - 1, a)
+    }
+}
+
+fn field_deref(flag: u32, a: &mut Box<(usize,)>) -> usize {
+    if flag == 0 {
+        0
+    } else {
+        a.0 += 5;
+        field_deref(flag - 1, a)
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/only_used_in_recursion2.stderr b/tests/ui/only_used_in_recursion2.stderr
new file mode 100644
index 00000000000..23f6ffd30c9
--- /dev/null
+++ b/tests/ui/only_used_in_recursion2.stderr
@@ -0,0 +1,63 @@
+error: parameter is only used in recursion
+  --> $DIR/only_used_in_recursion2.rs:3:35
+   |
+LL | fn _with_inner(flag: u32, a: u32, b: u32) -> usize {
+   |                                   ^ help: if this is intentional, prefix it with an underscore: `_b`
+   |
+   = note: `-D clippy::only-used-in-recursion` implied by `-D warnings`
+note: parameter used here
+  --> $DIR/only_used_in_recursion2.rs:9:52
+   |
+LL |     if flag == 0 { 0 } else { _with_inner(flag, a, b + x) }
+   |                                                    ^
+
+error: parameter is only used in recursion
+  --> $DIR/only_used_in_recursion2.rs:4:25
+   |
+LL |     fn inner(flag: u32, a: u32) -> u32 {
+   |                         ^ help: if this is intentional, prefix it with an underscore: `_a`
+   |
+note: parameter used here
+  --> $DIR/only_used_in_recursion2.rs:5:47
+   |
+LL |         if flag == 0 { 0 } else { inner(flag, a) }
+   |                                               ^
+
+error: parameter is only used in recursion
+  --> $DIR/only_used_in_recursion2.rs:12:34
+   |
+LL | fn _with_closure(a: Option<u32>, b: u32, f: impl Fn(u32, u32) -> Option<u32>) -> u32 {
+   |                                  ^ help: if this is intentional, prefix it with an underscore: `_b`
+   |
+note: parameter used here
+  --> $DIR/only_used_in_recursion2.rs:14:32
+   |
+LL |         _with_closure(Some(x), b, f)
+   |                                ^
+
+error: parameter is only used in recursion
+  --> $DIR/only_used_in_recursion2.rs:62:37
+   |
+LL | fn overwritten_param(flag: u32, mut a: usize) -> usize {
+   |                                     ^ help: if this is intentional, prefix it with an underscore: `_a`
+   |
+note: parameter used here
+  --> $DIR/only_used_in_recursion2.rs:70:29
+   |
+LL |     overwritten_param(flag, a)
+   |                             ^
+
+error: parameter is only used in recursion
+  --> $DIR/only_used_in_recursion2.rs:73:32
+   |
+LL | fn field_direct(flag: u32, mut a: (usize,)) -> usize {
+   |                                ^ help: if this is intentional, prefix it with an underscore: `_a`
+   |
+note: parameter used here
+  --> $DIR/only_used_in_recursion2.rs:78:32
+   |
+LL |         field_direct(flag - 1, a)
+   |                                ^
+
+error: aborting due to 5 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 39f4bee98e2ad69bb247b57b6d5bc8df0b4f1090 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sun, 15 May 2022 20:06:17 -0400
Subject: Move `only_used_in_recursion` back into `complexity`

---
 clippy_lints/src/lib.register_all.rs           |  1 +
 clippy_lints/src/lib.register_complexity.rs    |  1 +
 clippy_lints/src/lib.register_nursery.rs       |  1 -
 clippy_lints/src/only_used_in_recursion.rs     |  2 +-
 clippy_lints/src/redundant_static_lifetimes.rs | 12 ++++++------
 5 files changed, 9 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 4128096b43a..fefac7632d8 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -252,6 +252,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(non_expressive_names::JUST_UNDERSCORES_AND_DIGITS),
     LintId::of(non_octal_unix_permissions::NON_OCTAL_UNIX_PERMISSIONS),
     LintId::of(octal_escapes::OCTAL_ESCAPES),
+    LintId::of(only_used_in_recursion::ONLY_USED_IN_RECURSION),
     LintId::of(operators::ABSURD_EXTREME_COMPARISONS),
     LintId::of(operators::ASSIGN_OP_PATTERN),
     LintId::of(operators::BAD_BIT_MASK),
diff --git a/clippy_lints/src/lib.register_complexity.rs b/clippy_lints/src/lib.register_complexity.rs
index 0f7433a79be..aa247352f88 100644
--- a/clippy_lints/src/lib.register_complexity.rs
+++ b/clippy_lints/src/lib.register_complexity.rs
@@ -72,6 +72,7 @@ store.register_group(true, "clippy::complexity", Some("clippy_complexity"), vec!
     LintId::of(neg_cmp_op_on_partial_ord::NEG_CMP_OP_ON_PARTIAL_ORD),
     LintId::of(no_effect::NO_EFFECT),
     LintId::of(no_effect::UNNECESSARY_OPERATION),
+    LintId::of(only_used_in_recursion::ONLY_USED_IN_RECURSION),
     LintId::of(operators::DOUBLE_COMPARISONS),
     LintId::of(operators::DURATION_SUBSEC),
     LintId::of(operators::IDENTITY_OP),
diff --git a/clippy_lints/src/lib.register_nursery.rs b/clippy_lints/src/lib.register_nursery.rs
index dc50816452f..7171c655ccc 100644
--- a/clippy_lints/src/lib.register_nursery.rs
+++ b/clippy_lints/src/lib.register_nursery.rs
@@ -24,7 +24,6 @@ store.register_group(true, "clippy::nursery", Some("clippy_nursery"), vec![
     LintId::of(mutex_atomic::MUTEX_INTEGER),
     LintId::of(non_send_fields_in_send_ty::NON_SEND_FIELDS_IN_SEND_TY),
     LintId::of(nonstandard_macro_braces::NONSTANDARD_MACRO_BRACES),
-    LintId::of(only_used_in_recursion::ONLY_USED_IN_RECURSION),
     LintId::of(option_if_let_else::OPTION_IF_LET_ELSE),
     LintId::of(redundant_pub_crate::REDUNDANT_PUB_CRATE),
     LintId::of(regex::TRIVIAL_REGEX),
diff --git a/clippy_lints/src/only_used_in_recursion.rs b/clippy_lints/src/only_used_in_recursion.rs
index a4f516df735..774a3540d1e 100644
--- a/clippy_lints/src/only_used_in_recursion.rs
+++ b/clippy_lints/src/only_used_in_recursion.rs
@@ -80,7 +80,7 @@ declare_clippy_lint! {
     /// ```
     #[clippy::version = "1.61.0"]
     pub ONLY_USED_IN_RECURSION,
-    nursery,
+    complexity,
     "arguments that is only used in recursion can be removed"
 }
 impl_lint_pass!(OnlyUsedInRecursion => [ONLY_USED_IN_RECURSION]);
diff --git a/clippy_lints/src/redundant_static_lifetimes.rs b/clippy_lints/src/redundant_static_lifetimes.rs
index f8801f769e8..2d751c27467 100644
--- a/clippy_lints/src/redundant_static_lifetimes.rs
+++ b/clippy_lints/src/redundant_static_lifetimes.rs
@@ -48,15 +48,15 @@ impl_lint_pass!(RedundantStaticLifetimes => [REDUNDANT_STATIC_LIFETIMES]);
 
 impl RedundantStaticLifetimes {
     // Recursively visit types
-    fn visit_type(&mut self, ty: &Ty, cx: &EarlyContext<'_>, reason: &str) {
+    fn visit_type(ty: &Ty, cx: &EarlyContext<'_>, reason: &str) {
         match ty.kind {
             // Be careful of nested structures (arrays and tuples)
             TyKind::Array(ref ty, _) | TyKind::Slice(ref ty) => {
-                self.visit_type(ty, cx, reason);
+                Self::visit_type(ty, cx, reason);
             },
             TyKind::Tup(ref tup) => {
                 for tup_ty in tup {
-                    self.visit_type(tup_ty, cx, reason);
+                    Self::visit_type(tup_ty, cx, reason);
                 }
             },
             // This is what we are looking for !
@@ -87,7 +87,7 @@ impl RedundantStaticLifetimes {
                         _ => {},
                     }
                 }
-                self.visit_type(&borrow_type.ty, cx, reason);
+                Self::visit_type(&borrow_type.ty, cx, reason);
             },
             _ => {},
         }
@@ -102,13 +102,13 @@ impl EarlyLintPass for RedundantStaticLifetimes {
 
         if !item.span.from_expansion() {
             if let ItemKind::Const(_, ref var_type, _) = item.kind {
-                self.visit_type(var_type, cx, "constants have by default a `'static` lifetime");
+                Self::visit_type(var_type, cx, "constants have by default a `'static` lifetime");
                 // Don't check associated consts because `'static` cannot be elided on those (issue
                 // #2438)
             }
 
             if let ItemKind::Static(ref var_type, _, _) = item.kind {
-                self.visit_type(var_type, cx, "statics have by default a `'static` lifetime");
+                Self::visit_type(var_type, cx, "statics have by default a `'static` lifetime");
             }
         }
     }
-- 
cgit 1.4.1-3-g733a5


From a4413f75bf829549fdc0f01a834988d1128d6ba9 Mon Sep 17 00:00:00 2001
From: Nahua Kang <kangnahua@gmail.com>
Date: Tue, 2 Aug 2022 22:37:40 +0200
Subject: Register new lint collapsible_str_replace to methods

---
 CHANGELOG.md                                       |  1 +
 clippy_lints/src/lib.register_all.rs               |  1 +
 clippy_lints/src/lib.register_lints.rs             |  1 +
 clippy_lints/src/lib.register_perf.rs              |  1 +
 .../src/methods/collapsible_str_replace.rs         |  6 +++
 clippy_lints/src/methods/mod.rs                    | 29 ++++++++++++
 tests/ui/collapsible_str_replace.rs                | 55 ++++++++++++++++++++++
 7 files changed, 94 insertions(+)
 create mode 100644 clippy_lints/src/methods/collapsible_str_replace.rs
 create mode 100644 tests/ui/collapsible_str_replace.rs

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index edd7bc250a7..6c4a0cc91aa 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3642,6 +3642,7 @@ Released 2018-09-13
 [`collapsible_else_if`]: https://rust-lang.github.io/rust-clippy/master/index.html#collapsible_else_if
 [`collapsible_if`]: https://rust-lang.github.io/rust-clippy/master/index.html#collapsible_if
 [`collapsible_match`]: https://rust-lang.github.io/rust-clippy/master/index.html#collapsible_match
+[`collapsible_str_replace`]: https://rust-lang.github.io/rust-clippy/master/index.html#collapsible_str_replace
 [`comparison_chain`]: https://rust-lang.github.io/rust-clippy/master/index.html#comparison_chain
 [`comparison_to_empty`]: https://rust-lang.github.io/rust-clippy/master/index.html#comparison_to_empty
 [`const_static_lifetime`]: https://rust-lang.github.io/rust-clippy/master/index.html#const_static_lifetime
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index fefac7632d8..65eda429989 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -154,6 +154,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(methods::CHARS_NEXT_CMP),
     LintId::of(methods::CLONE_DOUBLE_REF),
     LintId::of(methods::CLONE_ON_COPY),
+    LintId::of(methods::COLLAPSIBLE_STR_REPLACE),
     LintId::of(methods::ERR_EXPECT),
     LintId::of(methods::EXPECT_FUN_CALL),
     LintId::of(methods::EXTEND_WITH_DRAIN),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index db475950086..e64a473d068 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -287,6 +287,7 @@ store.register_lints(&[
     methods::CLONE_DOUBLE_REF,
     methods::CLONE_ON_COPY,
     methods::CLONE_ON_REF_PTR,
+    methods::COLLAPSIBLE_STR_REPLACE,
     methods::ERR_EXPECT,
     methods::EXPECT_FUN_CALL,
     methods::EXPECT_USED,
diff --git a/clippy_lints/src/lib.register_perf.rs b/clippy_lints/src/lib.register_perf.rs
index e1b90acb93c..531fc47f8fa 100644
--- a/clippy_lints/src/lib.register_perf.rs
+++ b/clippy_lints/src/lib.register_perf.rs
@@ -13,6 +13,7 @@ store.register_group(true, "clippy::perf", Some("clippy_perf"), vec![
     LintId::of(loops::MISSING_SPIN_LOOP),
     LintId::of(loops::NEEDLESS_COLLECT),
     LintId::of(manual_retain::MANUAL_RETAIN),
+    LintId::of(methods::COLLAPSIBLE_STR_REPLACE),
     LintId::of(methods::EXPECT_FUN_CALL),
     LintId::of(methods::EXTEND_WITH_DRAIN),
     LintId::of(methods::ITER_NTH),
diff --git a/clippy_lints/src/methods/collapsible_str_replace.rs b/clippy_lints/src/methods/collapsible_str_replace.rs
new file mode 100644
index 00000000000..e5547b50471
--- /dev/null
+++ b/clippy_lints/src/methods/collapsible_str_replace.rs
@@ -0,0 +1,6 @@
+use rustc_hir as hir;
+use rustc_hir::*;
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &hir::Expr<'_>) {}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 1cfe8c4191e..8f7cb105c22 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -12,6 +12,7 @@ mod chars_next_cmp_with_unwrap;
 mod clone_on_copy;
 mod clone_on_ref_ptr;
 mod cloned_instead_of_copied;
+mod collapsible_str_replace;
 mod err_expect;
 mod expect_fun_call;
 mod expect_used;
@@ -137,6 +138,32 @@ declare_clippy_lint! {
     "used `cloned` where `copied` could be used instead"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for consecutive calls to `str::replace` (2 or more)
+    /// that can be collapsed into a single call.
+    ///
+    /// ### Why is this bad?
+    /// Consecutive `str::replace` calls scan the string multiple times
+    /// with repetitive code.
+    ///
+    /// ### Example
+    /// ```rust
+    /// let hello = "hesuo worpd"
+    ///     .replace('s', "l")
+    ///     .replace("u", "l")
+    ///     .replace('p', "l")
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// let hello = "hesuo worpd".replace(|c| matches!(c, 's' | 'u' | 'p'), "l")
+    /// ```
+    #[clippy::version = "1.64.0"]
+    pub COLLAPSIBLE_STR_REPLACE,
+    perf,
+    "collapse consecutive calls to str::replace (2 or more) into a single call"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for usage of `_.cloned().<func>()` where call to `.cloned()` can be postponed.
@@ -3001,6 +3028,7 @@ impl_lint_pass!(Methods => [
     CLONE_ON_COPY,
     CLONE_ON_REF_PTR,
     CLONE_DOUBLE_REF,
+    COLLAPSIBLE_STR_REPLACE,
     ITER_OVEREAGER_CLONED,
     CLONED_INSTEAD_OF_COPIED,
     FLAT_MAP_OPTION,
@@ -3491,6 +3519,7 @@ impl Methods {
                 ("sort_unstable_by", [arg]) => {
                     unnecessary_sort_by::check(cx, expr, recv, arg, true);
                 },
+                ("replace", [_, _]) => collapsible_str_replace::check(cx, expr, recv, args),
                 ("splitn" | "rsplitn", [count_arg, pat_arg]) => {
                     if let Some((Constant::Int(count), _)) = constant(cx, cx.typeck_results(), count_arg) {
                         suspicious_splitn::check(cx, name, expr, recv, count);
diff --git a/tests/ui/collapsible_str_replace.rs b/tests/ui/collapsible_str_replace.rs
new file mode 100644
index 00000000000..c91809bc840
--- /dev/null
+++ b/tests/ui/collapsible_str_replace.rs
@@ -0,0 +1,55 @@
+#![warn(clippy::collapsible_str_replace)]
+
+fn main() {
+    let misspelled = "hesuo worpd";
+
+    let p = 'p';
+    let s = 's';
+    let u = 'u';
+
+    // If the first argument to a single `str::replace` call is a slice and none of the chars
+    // are variables, recommend `collapsible_str_replace`
+    let replacement = misspelled.replace(&['s', 'u', 'p'], "l");
+    println!("{replacement}");
+
+    // The first iteration of `collapsible_str_replace` will not create lint if the first argument to
+    // a single `str::replace` call is a slice and one or more of its chars are variables
+    let replacement = misspelled.replace(&['s', u, 'p'], "l");
+    println!("{replacement}");
+
+    let replacement = misspelled.replace(&[s, u, 'p'], "l");
+    println!("{replacement}");
+
+    let replacement = misspelled.replace(&[s, u, p], "l");
+    println!("{replacement}");
+
+    // If there is a single call to `str::replace` and the first argument is a char or a variable, don't
+    // not recommend `collapsible_str_replace`
+    let replacement = misspelled.replace('s', "l");
+    println!("{replacement}");
+
+    let replacement = misspelled.replace(s, "l");
+    println!("{replacement}");
+
+    // If there are consecutive calls to `str::replace` and none of the chars are variables,
+    // recommend `collapsible_str_replace`
+    let replacement = misspelled.replace('s', "l").replace('u', "l");
+    println!("{replacement}");
+
+    let replacement = misspelled.replace('s', "l").replace('u', "l").replace('p', "l");
+    println!("{replacement}");
+
+    // If there are consecutive calls to `str::replace` and all or any chars are variables,
+    // recommend the fallback `misspelled.replace(&[s, u, p], "l")`
+    let replacement = misspelled.replace(s, "l").replace('u', "l");
+    println!("{replacement}");
+
+    let replacement = misspelled.replace(s, "l").replace('u', "l").replace('p', "l");
+    println!("{replacement}");
+
+    let replacement = misspelled.replace(s, "l").replace(u, "l").replace('p', "l");
+    println!("{replacement}");
+
+    let replacement = misspelled.replace(s, "l").replace(u, "l").replace(p, "l");
+    println!("{replacement}");
+}
-- 
cgit 1.4.1-3-g733a5


From 6e866875294be38b02c1deaf0b1cba181a65109b Mon Sep 17 00:00:00 2001
From: Nahua Kang <kangnahua@gmail.com>
Date: Fri, 5 Aug 2022 21:08:43 +0200
Subject: Handle replace calls with char slices

---
 .../src/methods/collapsible_str_replace.rs         | 154 ++++++++++++++++++++-
 clippy_lints/src/methods/mod.rs                    |   2 +-
 tests/ui/collapsible_str_replace.rs                |  27 ++--
 3 files changed, 167 insertions(+), 16 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/collapsible_str_replace.rs b/clippy_lints/src/methods/collapsible_str_replace.rs
index e5547b50471..e2477fb06bd 100644
--- a/clippy_lints/src/methods/collapsible_str_replace.rs
+++ b/clippy_lints/src/methods/collapsible_str_replace.rs
@@ -1,6 +1,154 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+// use clippy_utils::source::snippet_with_context;
+use clippy_utils::visitors::for_each_expr;
+use core::ops::ControlFlow;
+use if_chain::if_chain;
+use rustc_ast::ast::LitKind;
+use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_hir::*;
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_lint::LateContext;
+use rustc_middle::ty;
+use rustc_span::source_map::Spanned;
+use std::unreachable;
+// use rustc_span::Span;
 
-pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &hir::Expr<'_>) {}
+use super::method_call;
+use super::COLLAPSIBLE_STR_REPLACE;
+
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx hir::Expr<'tcx>,
+    name: &str,
+    recv: &'tcx hir::Expr<'tcx>,
+    args: &'tcx [hir::Expr<'tcx>],
+) {
+    match (name, args) {
+        ("replace", [from, to]) => {
+            // Check for `str::replace` calls with char slice for linting
+            let original_recv = find_original_recv(recv);
+            let original_recv_ty = cx.typeck_results().expr_ty(original_recv).peel_refs();
+            if_chain! {
+                // Check the receiver of the method call is `str` type
+                if matches!(original_recv_ty.kind(), ty::Str);
+                let from_ty = cx.typeck_results().expr_ty(from).peel_refs();
+                if let ty::Array(array_ty, _) = from_ty.kind();
+                if matches!(array_ty.kind(), ty::Char);
+                then {
+                    check_replace_call_with_char_slice(cx, from, to);
+                }
+            }
+
+            match method_call(recv) {
+                // Check if there's an earlier `str::replace` call
+                Some(("replace", [prev_recv, prev_from, prev_to], prev_span)) => {
+                    println!("Consecutive replace calls");
+                    // Check that the original receiver is of `ty::Str` type
+                    // Check that all the `from` args are char literals
+                    // Check that all the `to` args are the same variable or has the same &str value
+                    // If so, then lint
+                },
+                _ => {},
+            }
+        },
+        _ => {},
+    }
+}
+
+fn find_original_recv<'tcx>(recv: &'tcx hir::Expr<'tcx>) -> &'tcx hir::Expr<'tcx> {
+    let mut original_recv = recv;
+
+    let _: Option<()> = for_each_expr(recv, |e| {
+        if let Some((name, [prev_recv, args @ ..], _)) = method_call(e) {
+            match (name, args) {
+                ("replace", [_, _]) => {
+                    original_recv = prev_recv;
+                    ControlFlow::Continue(())
+                },
+                _ => ControlFlow::BREAK,
+            }
+        } else {
+            ControlFlow::Continue(())
+        }
+    });
+
+    original_recv
+}
+
+fn check_replace_call_with_char_slice<'tcx>(
+    cx: &LateContext<'tcx>,
+    from_arg: &'tcx hir::Expr<'tcx>,
+    to_arg: &'tcx hir::Expr<'tcx>,
+) {
+    let mut has_no_var = true;
+    let mut char_list: Vec<char> = Vec::new();
+    // Go through the `from_arg` to collect all char literals
+    let _: Option<()> = for_each_expr(from_arg, |e| {
+        if let ExprKind::Lit(Spanned {
+            node: LitKind::Char(val),
+            ..
+        }) = e.kind
+        {
+            char_list.push(val);
+            ControlFlow::Continue(())
+        } else if let ExprKind::Path(..) = e.kind {
+            // If a variable is found in the char slice, no lint for first version of this lint
+            has_no_var = false;
+            ControlFlow::BREAK
+        } else {
+            ControlFlow::Continue(())
+        }
+    });
+
+    if has_no_var {
+        let to_arg_repr = match to_arg.kind {
+            ExprKind::Lit(Spanned {
+                node: LitKind::Str(to_arg_val, _),
+                ..
+            }) => {
+                let repr = to_arg_val.as_str();
+                let double_quote = "\"";
+                double_quote.to_owned() + repr + double_quote
+            },
+            ExprKind::Path(QPath::Resolved(
+                _,
+                Path {
+                    segments: path_segments,
+                    ..
+                },
+            )) => {
+                // join the path_segments values by "::"
+                let path_segment_ident_names: Vec<&str> = path_segments
+                    .iter()
+                    .map(|path_seg| path_seg.ident.name.as_str())
+                    .collect();
+
+                path_segment_ident_names.join("::")
+            },
+            _ => unreachable!(),
+        };
+
+        let app = Applicability::MachineApplicable;
+        span_lint_and_sugg(
+            cx,
+            COLLAPSIBLE_STR_REPLACE,
+            from_arg.span,
+            "used slice of chars in `str::replace` call",
+            "replace with",
+            format!(
+                "replace(|c| matches!(c, {}), {})",
+                format_slice_of_chars_for_sugg(&char_list),
+                to_arg_repr,
+            ),
+            app,
+        );
+    }
+}
+
+fn format_slice_of_chars_for_sugg(chars: &Vec<char>) -> String {
+    let single_quoted_chars: Vec<String> = chars
+        .iter()
+        .map(|c| "'".to_owned() + &c.to_string() + &"'".to_owned())
+        .collect();
+    single_quoted_chars.join(" | ")
+}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 8f7cb105c22..ec5d5402b0e 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3519,7 +3519,7 @@ impl Methods {
                 ("sort_unstable_by", [arg]) => {
                     unnecessary_sort_by::check(cx, expr, recv, arg, true);
                 },
-                ("replace", [_, _]) => collapsible_str_replace::check(cx, expr, recv, args),
+                ("replace", [_, _]) => collapsible_str_replace::check(cx, expr, name, recv, args),
                 ("splitn" | "rsplitn", [count_arg, pat_arg]) => {
                     if let Some((Constant::Int(count), _)) = constant(cx, cx.typeck_results(), count_arg) {
                         suspicious_splitn::check(cx, name, expr, recv, count);
diff --git a/tests/ui/collapsible_str_replace.rs b/tests/ui/collapsible_str_replace.rs
index 0f4bdf09480..943fb4473bb 100644
--- a/tests/ui/collapsible_str_replace.rs
+++ b/tests/ui/collapsible_str_replace.rs
@@ -10,6 +10,7 @@ fn main() {
     let p = 'p';
     let s = 's';
     let u = 'u';
+    let l = "l";
 
     // LINT CASES
     // If the first argument to a single `str::replace` call is a slice and none of the chars
@@ -17,6 +18,20 @@ fn main() {
     let replacement = misspelled.replace(&['s', 'u', 'p'], "l");
     println!("{replacement}");
 
+    let replacement = misspelled.replace(&['s', 'u', 'p'], l);
+    println!("{replacement}");
+
+    // If multiple `str::replace` calls contain slices and none of the chars are variables,
+    // recommend `collapsible_str_replace`
+    let replacement = misspelled.replace(&['s', 'u'], "l").replace(&['u', 'p'], "l");
+    println!("{replacement}");
+
+    let replacement = misspelled.replace('s', "l").replace(&['u', 'p'], "l");
+    println!("{replacement}");
+
+    let replacement = misspelled.replace(&['s', 'u'], "l").replace('p', "l");
+    println!("replacement");
+
     // If there are consecutive calls to `str::replace` and none of the chars are variables,
     // recommend `collapsible_str_replace`
     let replacement = misspelled.replace('s', "l").replace('u', "l");
@@ -38,18 +53,6 @@ fn main() {
     let replacement = misspelled.replace(&get_filter(), "l");
 
     // NO LINT TIL IMPROVEMENT
-    // If multiple `str::replace` calls contain slices and none of the chars are variables,
-    // the first iteration does not recommend `collapsible_str_replace`
-    let replacement = misspelled.replace(&['s', 'u', 'p'], "l").replace(&['s', 'p'], "l");
-    println!("{replacement}");
-
-    // If a mixture of `str::replace` calls with slice and char arguments are used for `from` arg,
-    // the first iteration does not recommend `collapsible_str_replace`
-    let replacement = misspelled.replace(&['s', 'u'], "l").replace('p', "l");
-    println!("replacement");
-
-    let replacement = misspelled.replace('p', "l").replace(&['s', 'u'], "l");
-
     // The first iteration of `collapsible_str_replace` will not create lint if the first argument to
     // a single `str::replace` call is a slice and one or more of its chars are variables
     let replacement = misspelled.replace(&['s', u, 'p'], "l");
-- 
cgit 1.4.1-3-g733a5


From a9bd0bd3214f04e5f3df9cc5cd9f6ecd375e6242 Mon Sep 17 00:00:00 2001
From: Nahua Kang <kangnahua@gmail.com>
Date: Sun, 7 Aug 2022 14:08:09 +0200
Subject: Handle repeated str::replace calls with single char kind to str

---
 .../src/methods/collapsible_str_replace.rs         | 337 +++++++++++++++------
 clippy_lints/src/methods/mod.rs                    |   8 +-
 tests/ui/collapsible_str_replace.rs                |   4 +
 3 files changed, 258 insertions(+), 91 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/collapsible_str_replace.rs b/clippy_lints/src/methods/collapsible_str_replace.rs
index e2477fb06bd..b4e97a3bea4 100644
--- a/clippy_lints/src/methods/collapsible_str_replace.rs
+++ b/clippy_lints/src/methods/collapsible_str_replace.rs
@@ -1,17 +1,16 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-// use clippy_utils::source::snippet_with_context;
+use clippy_utils::get_parent_expr;
 use clippy_utils::visitors::for_each_expr;
 use core::ops::ControlFlow;
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
+use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_hir::*;
 use rustc_lint::LateContext;
 use rustc_middle::ty;
 use rustc_span::source_map::Spanned;
-use std::unreachable;
-// use rustc_span::Span;
 
 use super::method_call;
 use super::COLLAPSIBLE_STR_REPLACE;
@@ -25,28 +24,46 @@ pub(super) fn check<'tcx>(
 ) {
     match (name, args) {
         ("replace", [from, to]) => {
-            // Check for `str::replace` calls with char slice for linting
+            // The receiver of the method call must be `str` type to lint `collapsible_str_replace`
             let original_recv = find_original_recv(recv);
-            let original_recv_ty = cx.typeck_results().expr_ty(original_recv).peel_refs();
+            let original_recv_ty_kind = cx.typeck_results().expr_ty(original_recv).peel_refs().kind();
+            let original_recv_is_str_kind = matches!(original_recv_ty_kind, ty::Str);
+
             if_chain! {
-                // Check the receiver of the method call is `str` type
-                if matches!(original_recv_ty.kind(), ty::Str);
-                let from_ty = cx.typeck_results().expr_ty(from).peel_refs();
-                if let ty::Array(array_ty, _) = from_ty.kind();
+                // Check for `str::replace` calls with char slice for linting
+                if original_recv_is_str_kind;
+                let from_ty_kind = cx.typeck_results().expr_ty(from).peel_refs().kind();
+                if let ty::Array(array_ty, _) = from_ty_kind;
                 if matches!(array_ty.kind(), ty::Char);
                 then {
                     check_replace_call_with_char_slice(cx, from, to);
+                    return;
+                }
+            }
+
+            if_chain! {
+                if original_recv_is_str_kind;
+                if let Some(parent) = get_parent_expr(cx, expr);
+                if let Some((name, [..], _)) = method_call(parent);
+
+                then {
+                    match name {
+                        "replace" => return,
+                        _ => {
+                            check_consecutive_replace_calls(cx, expr);
+                            return;
+                        },
+                    }
                 }
             }
 
             match method_call(recv) {
                 // Check if there's an earlier `str::replace` call
-                Some(("replace", [prev_recv, prev_from, prev_to], prev_span)) => {
-                    println!("Consecutive replace calls");
-                    // Check that the original receiver is of `ty::Str` type
-                    // Check that all the `from` args are char literals
-                    // Check that all the `to` args are the same variable or has the same &str value
-                    // If so, then lint
+                Some(("replace", [_, _, _], _)) => {
+                    if original_recv_is_str_kind {
+                        check_consecutive_replace_calls(cx, expr);
+                        return;
+                    }
                 },
                 _ => {},
             }
@@ -55,100 +72,246 @@ pub(super) fn check<'tcx>(
     }
 }
 
-fn find_original_recv<'tcx>(recv: &'tcx hir::Expr<'tcx>) -> &'tcx hir::Expr<'tcx> {
-    let mut original_recv = recv;
-
-    let _: Option<()> = for_each_expr(recv, |e| {
-        if let Some((name, [prev_recv, args @ ..], _)) = method_call(e) {
-            match (name, args) {
-                ("replace", [_, _]) => {
-                    original_recv = prev_recv;
-                    ControlFlow::Continue(())
-                },
-                _ => ControlFlow::BREAK,
-            }
-        } else {
-            ControlFlow::Continue(())
-        }
-    });
-
-    original_recv
-}
-
+/// Check a `str::replace` call that contains a char slice as `from` argument for
+/// `collapsible_str_replace` lint.
 fn check_replace_call_with_char_slice<'tcx>(
     cx: &LateContext<'tcx>,
     from_arg: &'tcx hir::Expr<'tcx>,
     to_arg: &'tcx hir::Expr<'tcx>,
 ) {
-    let mut has_no_var = true;
-    let mut char_list: Vec<char> = Vec::new();
+    let mut char_slice_has_no_variables = true;
+    let mut chars: Vec<String> = Vec::new();
+
     // Go through the `from_arg` to collect all char literals
     let _: Option<()> = for_each_expr(from_arg, |e| {
         if let ExprKind::Lit(Spanned {
-            node: LitKind::Char(val),
-            ..
+            node: LitKind::Char(_), ..
         }) = e.kind
         {
-            char_list.push(val);
+            chars.push(get_replace_call_char_arg_repr(e).unwrap());
             ControlFlow::Continue(())
         } else if let ExprKind::Path(..) = e.kind {
             // If a variable is found in the char slice, no lint for first version of this lint
-            has_no_var = false;
+            char_slice_has_no_variables = false;
             ControlFlow::BREAK
         } else {
             ControlFlow::Continue(())
         }
     });
 
-    if has_no_var {
-        let to_arg_repr = match to_arg.kind {
-            ExprKind::Lit(Spanned {
-                node: LitKind::Str(to_arg_val, _),
-                ..
-            }) => {
-                let repr = to_arg_val.as_str();
-                let double_quote = "\"";
-                double_quote.to_owned() + repr + double_quote
-            },
-            ExprKind::Path(QPath::Resolved(
-                _,
-                Path {
-                    segments: path_segments,
-                    ..
+    if char_slice_has_no_variables {
+        if let Some(to_arg_repr) = get_replace_call_char_arg_repr(to_arg) {
+            let app = Applicability::MachineApplicable;
+            span_lint_and_sugg(
+                cx,
+                COLLAPSIBLE_STR_REPLACE,
+                from_arg.span,
+                "used slice of chars in `str::replace` call",
+                "replace with",
+                format!("replace(|c| matches!(c, {}), {})", chars.join(" | "), to_arg_repr,),
+                app,
+            );
+        }
+    }
+}
+
+/// Check a chain of `str::replace` calls for `collapsible_str_replace` lint.
+fn check_consecutive_replace_calls<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'tcx>) {
+    if_chain! {
+        if let Some(from_args) = get_replace_call_from_args_if_all_char_ty(cx, expr);
+        if let Some(to_arg) = get_replace_call_unique_to_arg_repr(expr);
+        then {
+            if replace_call_from_args_are_only_lit_chars(&from_args) {
+                let from_arg_reprs: Vec<String> = from_args.iter().map(|from_arg| {
+                    get_replace_call_char_arg_repr(from_arg).unwrap()
+                }).collect();
+                let app = Applicability::MachineApplicable;
+
+                span_lint_and_sugg(
+                    cx,
+                    COLLAPSIBLE_STR_REPLACE,
+                    expr.span,
+                    "used consecutive `str::replace` call",
+                    "replace with",
+                    format!(
+                        "replace(|c| matches!(c, {}), {})",
+                        from_arg_reprs.join(" | "),
+                        to_arg,
+                    ),
+                    app,
+                );
+            } else {
+                // Use fallback lint
+                let from_arg_reprs: Vec<String> = from_args.iter().map(|from_arg| {
+                    get_replace_call_char_arg_repr(from_arg).unwrap()
+                }).collect();
+                let app = Applicability::MachineApplicable;
+
+                span_lint_and_sugg(
+                    cx,
+                    COLLAPSIBLE_STR_REPLACE,
+                    expr.span,
+                    "used consecutive `str::replace` call",
+                    "replace with",
+                    format!(
+                        "replace(&[{}], {})",
+                        from_arg_reprs.join(" , "),
+                        to_arg,
+                    ),
+                    app,
+                );
+            }
+        }
+    }
+}
+
+/// Check if all the `from` arguments of a chain of consecutive calls to `str::replace`
+/// are all of `ExprKind::Lit` types. If any is not, return false.
+fn replace_call_from_args_are_only_lit_chars<'tcx>(from_args: &Vec<&'tcx hir::Expr<'tcx>>) -> bool {
+    let mut only_lit_chars = true;
+
+    for from_arg in from_args.iter() {
+        match from_arg.kind {
+            ExprKind::Lit(..) => {},
+            _ => only_lit_chars = false,
+        }
+    }
+
+    only_lit_chars
+}
+
+/// Collect and return all of the `from` arguments of a chain of consecutive `str::replace` calls
+/// if these `from` arguments's expressions are of the `ty::Char` kind. Otherwise return `None`.
+fn get_replace_call_from_args_if_all_char_ty<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx hir::Expr<'tcx>,
+) -> Option<Vec<&'tcx hir::Expr<'tcx>>> {
+    let mut all_from_args_are_chars = true;
+    let mut from_args = Vec::new();
+
+    let _: Option<()> = for_each_expr(expr, |e| {
+        if let Some((name, [_, args @ ..], _)) = method_call(e) {
+            match (name, args) {
+                ("replace", [from, _]) => {
+                    let from_ty_kind = cx.typeck_results().expr_ty(from).peel_refs().kind();
+                    if matches!(from_ty_kind, ty::Char) {
+                        from_args.push(from);
+                    } else {
+                        all_from_args_are_chars = false;
+                    }
+                    ControlFlow::Continue(())
                 },
-            )) => {
-                // join the path_segments values by "::"
-                let path_segment_ident_names: Vec<&str> = path_segments
-                    .iter()
-                    .map(|path_seg| path_seg.ident.name.as_str())
-                    .collect();
-
-                path_segment_ident_names.join("::")
+                _ => ControlFlow::BREAK,
+            }
+        } else {
+            ControlFlow::Continue(())
+        }
+    });
+
+    if all_from_args_are_chars {
+        return Some(from_args);
+    } else {
+        return None;
+    }
+}
+
+/// Return a unique String representation of the `to` argument used in a chain of `str::replace`
+/// calls if each `str::replace` call's `to` argument is identical to the other `to` arguments in
+/// the chain. Otherwise, return `None`.
+fn get_replace_call_unique_to_arg_repr<'tcx>(expr: &'tcx hir::Expr<'tcx>) -> Option<String> {
+    let mut to_args = Vec::new();
+
+    let _: Option<()> = for_each_expr(expr, |e| {
+        if let Some((name, [_, args @ ..], _)) = method_call(e) {
+            match (name, args) {
+                ("replace", [_, to]) => {
+                    to_args.push(to);
+                    ControlFlow::Continue(())
+                },
+                _ => ControlFlow::BREAK,
+            }
+        } else {
+            ControlFlow::Continue(())
+        }
+    });
+
+    // let mut to_arg_repr_set = FxHashSet::default();
+    let mut to_arg_reprs = Vec::new();
+    for &to_arg in to_args.iter() {
+        if let Some(to_arg_repr) = get_replace_call_char_arg_repr(to_arg) {
+            to_arg_reprs.push(to_arg_repr);
+        }
+    }
+
+    let to_arg_repr_set = FxHashSet::from_iter(to_arg_reprs.iter().cloned());
+    // Check if the set of `to` argument representations has more than one unique value
+    if to_arg_repr_set.len() != 1 {
+        return None;
+    }
+
+    // Return the single representation value
+    to_arg_reprs.pop()
+}
+
+/// Get the representation of an argument of a `str::replace` call either of the literal char value
+/// or variable name, i.e. the resolved path segments `ident`.
+/// Return:
+/// - the str literal with double quotes, e.g. "\"l\""
+/// - the char literal with single quotes, e.g. "'l'"
+/// - the variable as a String, e.g. "l"
+fn get_replace_call_char_arg_repr<'tcx>(arg: &'tcx hir::Expr<'tcx>) -> Option<String> {
+    match arg.kind {
+        ExprKind::Lit(Spanned {
+            node: LitKind::Str(to_arg_val, _),
+            ..
+        }) => {
+            let repr = to_arg_val.as_str();
+            let double_quote = "\"";
+            Some(double_quote.to_owned() + repr + double_quote)
+        },
+        ExprKind::Lit(Spanned {
+            node: LitKind::Char(to_arg_val),
+            ..
+        }) => {
+            let repr = to_arg_val.to_string();
+            let double_quote = "\'";
+            Some(double_quote.to_owned() + &repr + double_quote)
+        },
+        ExprKind::Path(QPath::Resolved(
+            _,
+            Path {
+                segments: path_segments,
+                ..
             },
-            _ => unreachable!(),
-        };
-
-        let app = Applicability::MachineApplicable;
-        span_lint_and_sugg(
-            cx,
-            COLLAPSIBLE_STR_REPLACE,
-            from_arg.span,
-            "used slice of chars in `str::replace` call",
-            "replace with",
-            format!(
-                "replace(|c| matches!(c, {}), {})",
-                format_slice_of_chars_for_sugg(&char_list),
-                to_arg_repr,
-            ),
-            app,
-        );
+        )) => {
+            // join the path_segments values by "::"
+            let path_segment_ident_names: Vec<&str> = path_segments
+                .iter()
+                .map(|path_seg| path_seg.ident.name.as_str())
+                .collect();
+            Some(path_segment_ident_names.join("::"))
+        },
+        _ => None,
     }
 }
 
-fn format_slice_of_chars_for_sugg(chars: &Vec<char>) -> String {
-    let single_quoted_chars: Vec<String> = chars
-        .iter()
-        .map(|c| "'".to_owned() + &c.to_string() + &"'".to_owned())
-        .collect();
-    single_quoted_chars.join(" | ")
+/// Find the original receiver of a chain of `str::replace` method calls.
+fn find_original_recv<'tcx>(recv: &'tcx hir::Expr<'tcx>) -> &'tcx hir::Expr<'tcx> {
+    let mut original_recv = recv;
+
+    let _: Option<()> = for_each_expr(recv, |e| {
+        if let Some((name, [prev_recv, args @ ..], _)) = method_call(e) {
+            match (name, args) {
+                ("replace", [_, _]) => {
+                    original_recv = prev_recv;
+                    ControlFlow::Continue(())
+                },
+                _ => ControlFlow::BREAK,
+            }
+        } else {
+            ControlFlow::Continue(())
+        }
+    });
+
+    original_recv
 }
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index ec5d5402b0e..f9358693623 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3519,7 +3519,10 @@ impl Methods {
                 ("sort_unstable_by", [arg]) => {
                     unnecessary_sort_by::check(cx, expr, recv, arg, true);
                 },
-                ("replace", [_, _]) => collapsible_str_replace::check(cx, expr, name, recv, args),
+                ("replace" | "replacen", [arg1, arg2] | [arg1, arg2, _]) => {
+                    no_effect_replace::check(cx, expr, arg1, arg2);
+                    collapsible_str_replace::check(cx, expr, name, recv, args);
+                },
                 ("splitn" | "rsplitn", [count_arg, pat_arg]) => {
                     if let Some((Constant::Int(count), _)) = constant(cx, cx.typeck_results(), count_arg) {
                         suspicious_splitn::check(cx, name, expr, recv, count);
@@ -3585,9 +3588,6 @@ impl Methods {
                         unnecessary_lazy_eval::check(cx, expr, recv, u_arg, "unwrap_or");
                     },
                 },
-                ("replace" | "replacen", [arg1, arg2] | [arg1, arg2, _]) => {
-                    no_effect_replace::check(cx, expr, arg1, arg2);
-                },
                 ("zip", [arg]) => {
                     if let ExprKind::MethodCall(name, [iter_recv], _) = recv.kind
                         && name.ident.name == sym::iter
diff --git a/tests/ui/collapsible_str_replace.rs b/tests/ui/collapsible_str_replace.rs
index 943fb4473bb..4257fce448d 100644
--- a/tests/ui/collapsible_str_replace.rs
+++ b/tests/ui/collapsible_str_replace.rs
@@ -49,6 +49,10 @@ fn main() {
     let replacement = misspelled.replace(s, "l");
     println!("{replacement}");
 
+    // If the consecutive `str::replace` calls have different `to` arguments, do not lint
+    let replacement = misspelled.replace('s', "l").replace('u', "p");
+    println!("{replacement}");
+
     // If the `from` argument is of kind other than a slice or a char, do not lint
     let replacement = misspelled.replace(&get_filter(), "l");
 
-- 
cgit 1.4.1-3-g733a5


From c989746ccfae22dd0f7f6d1e3d4f984ac8889e9f Mon Sep 17 00:00:00 2001
From: Nahua Kang <kangnahua@gmail.com>
Date: Mon, 8 Aug 2022 22:02:26 +0200
Subject: Remove checks on char slice; improve lint suggestion

---
 .../src/methods/collapsible_str_replace.rs         | 89 +++++++---------------
 tests/ui/collapsible_str_replace.rs                | 61 ++++++++-------
 2 files changed, 59 insertions(+), 91 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/collapsible_str_replace.rs b/clippy_lints/src/methods/collapsible_str_replace.rs
index b4e97a3bea4..1760232041a 100644
--- a/clippy_lints/src/methods/collapsible_str_replace.rs
+++ b/clippy_lints/src/methods/collapsible_str_replace.rs
@@ -11,6 +11,7 @@ use rustc_hir::*;
 use rustc_lint::LateContext;
 use rustc_middle::ty;
 use rustc_span::source_map::Spanned;
+use rustc_span::Span;
 
 use super::method_call;
 use super::COLLAPSIBLE_STR_REPLACE;
@@ -23,31 +24,20 @@ pub(super) fn check<'tcx>(
     args: &'tcx [hir::Expr<'tcx>],
 ) {
     match (name, args) {
-        ("replace", [from, to]) => {
+        ("replace", ..) => {
             // The receiver of the method call must be `str` type to lint `collapsible_str_replace`
             let original_recv = find_original_recv(recv);
             let original_recv_ty_kind = cx.typeck_results().expr_ty(original_recv).peel_refs().kind();
             let original_recv_is_str_kind = matches!(original_recv_ty_kind, ty::Str);
 
-            if_chain! {
-                // Check for `str::replace` calls with char slice for linting
-                if original_recv_is_str_kind;
-                let from_ty_kind = cx.typeck_results().expr_ty(from).peel_refs().kind();
-                if let ty::Array(array_ty, _) = from_ty_kind;
-                if matches!(array_ty.kind(), ty::Char);
-                then {
-                    check_replace_call_with_char_slice(cx, from, to);
-                    return;
-                }
-            }
-
             if_chain! {
                 if original_recv_is_str_kind;
                 if let Some(parent) = get_parent_expr(cx, expr);
-                if let Some((name, [..], _)) = method_call(parent);
+                if let Some((name, ..)) = method_call(parent);
 
                 then {
                     match name {
+                        // If the parent node is a `str::replace` call, we've already handled the lint, don't lint again
                         "replace" => return,
                         _ => {
                             check_consecutive_replace_calls(cx, expr);
@@ -59,7 +49,7 @@ pub(super) fn check<'tcx>(
 
             match method_call(recv) {
                 // Check if there's an earlier `str::replace` call
-                Some(("replace", [_, _, _], _)) => {
+                Some(("replace", ..)) => {
                     if original_recv_is_str_kind {
                         check_consecutive_replace_calls(cx, expr);
                         return;
@@ -72,55 +62,14 @@ pub(super) fn check<'tcx>(
     }
 }
 
-/// Check a `str::replace` call that contains a char slice as `from` argument for
-/// `collapsible_str_replace` lint.
-fn check_replace_call_with_char_slice<'tcx>(
-    cx: &LateContext<'tcx>,
-    from_arg: &'tcx hir::Expr<'tcx>,
-    to_arg: &'tcx hir::Expr<'tcx>,
-) {
-    let mut char_slice_has_no_variables = true;
-    let mut chars: Vec<String> = Vec::new();
-
-    // Go through the `from_arg` to collect all char literals
-    let _: Option<()> = for_each_expr(from_arg, |e| {
-        if let ExprKind::Lit(Spanned {
-            node: LitKind::Char(_), ..
-        }) = e.kind
-        {
-            chars.push(get_replace_call_char_arg_repr(e).unwrap());
-            ControlFlow::Continue(())
-        } else if let ExprKind::Path(..) = e.kind {
-            // If a variable is found in the char slice, no lint for first version of this lint
-            char_slice_has_no_variables = false;
-            ControlFlow::BREAK
-        } else {
-            ControlFlow::Continue(())
-        }
-    });
-
-    if char_slice_has_no_variables {
-        if let Some(to_arg_repr) = get_replace_call_char_arg_repr(to_arg) {
-            let app = Applicability::MachineApplicable;
-            span_lint_and_sugg(
-                cx,
-                COLLAPSIBLE_STR_REPLACE,
-                from_arg.span,
-                "used slice of chars in `str::replace` call",
-                "replace with",
-                format!("replace(|c| matches!(c, {}), {})", chars.join(" | "), to_arg_repr,),
-                app,
-            );
-        }
-    }
-}
-
 /// Check a chain of `str::replace` calls for `collapsible_str_replace` lint.
 fn check_consecutive_replace_calls<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'tcx>) {
     if_chain! {
         if let Some(from_args) = get_replace_call_from_args_if_all_char_ty(cx, expr);
         if let Some(to_arg) = get_replace_call_unique_to_arg_repr(expr);
         then {
+            let earliest_replace_call_span = get_earliest_replace_call_span(expr);
+
             if replace_call_from_args_are_only_lit_chars(&from_args) {
                 let from_arg_reprs: Vec<String> = from_args.iter().map(|from_arg| {
                     get_replace_call_char_arg_repr(from_arg).unwrap()
@@ -130,7 +79,7 @@ fn check_consecutive_replace_calls<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir
                 span_lint_and_sugg(
                     cx,
                     COLLAPSIBLE_STR_REPLACE,
-                    expr.span,
+                    expr.span.with_lo(earliest_replace_call_span.lo()),
                     "used consecutive `str::replace` call",
                     "replace with",
                     format!(
@@ -150,7 +99,7 @@ fn check_consecutive_replace_calls<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir
                 span_lint_and_sugg(
                     cx,
                     COLLAPSIBLE_STR_REPLACE,
-                    expr.span,
+                    expr.span.with_lo(earliest_replace_call_span.lo()),
                     "used consecutive `str::replace` call",
                     "replace with",
                     format!(
@@ -295,6 +244,26 @@ fn get_replace_call_char_arg_repr<'tcx>(arg: &'tcx hir::Expr<'tcx>) -> Option<St
     }
 }
 
+fn get_earliest_replace_call_span<'tcx>(expr: &'tcx hir::Expr<'tcx>) -> Span {
+    let mut earliest_replace_call_span = expr.span;
+
+    let _: Option<()> = for_each_expr(expr, |e| {
+        if let Some((name, [_, args @ ..], span)) = method_call(e) {
+            match (name, args) {
+                ("replace", [_, _]) => {
+                    earliest_replace_call_span = span;
+                    ControlFlow::Continue(())
+                },
+                _ => ControlFlow::BREAK,
+            }
+        } else {
+            ControlFlow::Continue(())
+        }
+    });
+
+    earliest_replace_call_span
+}
+
 /// Find the original receiver of a chain of `str::replace` method calls.
 fn find_original_recv<'tcx>(recv: &'tcx hir::Expr<'tcx>) -> &'tcx hir::Expr<'tcx> {
     let mut original_recv = recv;
diff --git a/tests/ui/collapsible_str_replace.rs b/tests/ui/collapsible_str_replace.rs
index 4257fce448d..05a4fd08a32 100644
--- a/tests/ui/collapsible_str_replace.rs
+++ b/tests/ui/collapsible_str_replace.rs
@@ -13,36 +13,38 @@ fn main() {
     let l = "l";
 
     // LINT CASES
-    // If the first argument to a single `str::replace` call is a slice and none of the chars
-    // are variables, recommend `collapsible_str_replace`
-    let replacement = misspelled.replace(&['s', 'u', 'p'], "l");
+    let replacement = misspelled.replace('s', "l").replace('u', "l");
     println!("{replacement}");
 
-    let replacement = misspelled.replace(&['s', 'u', 'p'], l);
+    let replacement = misspelled.replace('s', l).replace('u', l);
     println!("{replacement}");
 
-    // If multiple `str::replace` calls contain slices and none of the chars are variables,
-    // recommend `collapsible_str_replace`
-    let replacement = misspelled.replace(&['s', 'u'], "l").replace(&['u', 'p'], "l");
+    let replacement = misspelled.replace('s', "l").replace('u', "l").replace('p', "l");
     println!("{replacement}");
 
-    let replacement = misspelled.replace('s', "l").replace(&['u', 'p'], "l");
+    let replacement = misspelled
+        .replace('s', "l")
+        .replace('u', "l")
+        .replace('p', "l")
+        .replace('d', "l");
     println!("{replacement}");
 
-    let replacement = misspelled.replace(&['s', 'u'], "l").replace('p', "l");
-    println!("replacement");
+    // FALLBACK CASES
+    // If there are consecutive calls to `str::replace` and all or any chars are variables,
+    // recommend the fallback `misspelled.replace(&[s, u, p], "l")`
+    let replacement = misspelled.replace(s, "l").replace('u', "l");
+    println!("{replacement}");
 
-    // If there are consecutive calls to `str::replace` and none of the chars are variables,
-    // recommend `collapsible_str_replace`
-    let replacement = misspelled.replace('s', "l").replace('u', "l");
+    let replacement = misspelled.replace(s, "l").replace('u', "l").replace('p', "l");
     println!("{replacement}");
 
-    let replacement = misspelled.replace('s', "l").replace('u', "l").replace('p', "l");
+    let replacement = misspelled.replace(s, "l").replace(u, "l").replace('p', "l");
+    println!("{replacement}");
+
+    let replacement = misspelled.replace(s, "l").replace(u, "l").replace(p, "l");
     println!("{replacement}");
 
     // NO LINT CASES
-    // If there is a single call to `str::replace` and the first argument is a char or a variable,
-    // do not recommend `collapsible_str_replace`
     let replacement = misspelled.replace('s', "l");
     println!("{replacement}");
 
@@ -53,36 +55,33 @@ fn main() {
     let replacement = misspelled.replace('s', "l").replace('u', "p");
     println!("{replacement}");
 
-    // If the `from` argument is of kind other than a slice or a char, do not lint
     let replacement = misspelled.replace(&get_filter(), "l");
+    println!("{replacement}");
 
-    // NO LINT TIL IMPROVEMENT
-    // The first iteration of `collapsible_str_replace` will not create lint if the first argument to
-    // a single `str::replace` call is a slice and one or more of its chars are variables
-    let replacement = misspelled.replace(&['s', u, 'p'], "l");
+    let replacement = misspelled.replace(&['s', 'u', 'p'], "l");
     println!("{replacement}");
 
-    let replacement = misspelled.replace(&[s, u, 'p'], "l");
+    let replacement = misspelled.replace(&['s', 'u', 'p'], l);
     println!("{replacement}");
 
-    let replacement = misspelled.replace(&[s, u, p], "l");
+    let replacement = misspelled.replace(&['s', 'u'], "l").replace(&['u', 'p'], "l");
     println!("{replacement}");
 
-    let replacement = misspelled.replace(&[s, u], "l").replace(&[u, p], "l");
+    let replacement = misspelled.replace('s', "l").replace(&['u', 'p'], "l");
     println!("{replacement}");
 
-    // FALLBACK CASES
-    // If there are consecutive calls to `str::replace` and all or any chars are variables,
-    // recommend the fallback `misspelled.replace(&[s, u, p], "l")`
-    let replacement = misspelled.replace(s, "l").replace('u', "l");
+    let replacement = misspelled.replace(&['s', 'u'], "l").replace('p', "l");
+    println!("replacement");
+
+    let replacement = misspelled.replace(&['s', u, 'p'], "l");
     println!("{replacement}");
 
-    let replacement = misspelled.replace(s, "l").replace('u', "l").replace('p', "l");
+    let replacement = misspelled.replace(&[s, u, 'p'], "l");
     println!("{replacement}");
 
-    let replacement = misspelled.replace(s, "l").replace(u, "l").replace('p', "l");
+    let replacement = misspelled.replace(&[s, u, p], "l");
     println!("{replacement}");
 
-    let replacement = misspelled.replace(s, "l").replace(u, "l").replace(p, "l");
+    let replacement = misspelled.replace(&[s, u], "l").replace(&[u, p], "l");
     println!("{replacement}");
 }
-- 
cgit 1.4.1-3-g733a5


From fb30b64f6379eb22880d70bfebce66ceccc75269 Mon Sep 17 00:00:00 2001
From: Nahua Kang <kangnahua@gmail.com>
Date: Mon, 8 Aug 2022 22:31:53 +0200
Subject: Adjust test cases; run cargo dev bless

---
 .../src/methods/collapsible_str_replace.rs         | 65 +++++++++-------------
 clippy_lints/src/methods/mod.rs                    |  6 +-
 tests/ui/collapsible_str_replace.fixed             | 65 ++++++++++++++++++++++
 tests/ui/collapsible_str_replace.rs                | 65 ++++++++--------------
 tests/ui/collapsible_str_replace.stderr            | 56 +++++++++++++++++++
 5 files changed, 174 insertions(+), 83 deletions(-)
 create mode 100644 tests/ui/collapsible_str_replace.fixed
 create mode 100644 tests/ui/collapsible_str_replace.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/collapsible_str_replace.rs b/clippy_lints/src/methods/collapsible_str_replace.rs
index 1760232041a..4c6288e798c 100644
--- a/clippy_lints/src/methods/collapsible_str_replace.rs
+++ b/clippy_lints/src/methods/collapsible_str_replace.rs
@@ -1,3 +1,5 @@
+// run-rustfix
+
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::get_parent_expr;
 use clippy_utils::visitors::for_each_expr;
@@ -7,7 +9,7 @@ use rustc_ast::ast::LitKind;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
-use rustc_hir::*;
+use rustc_hir::{ExprKind, Path, QPath};
 use rustc_lint::LateContext;
 use rustc_middle::ty;
 use rustc_span::source_map::Spanned;
@@ -21,44 +23,31 @@ pub(super) fn check<'tcx>(
     expr: &'tcx hir::Expr<'tcx>,
     name: &str,
     recv: &'tcx hir::Expr<'tcx>,
-    args: &'tcx [hir::Expr<'tcx>],
 ) {
-    match (name, args) {
-        ("replace", ..) => {
-            // The receiver of the method call must be `str` type to lint `collapsible_str_replace`
-            let original_recv = find_original_recv(recv);
-            let original_recv_ty_kind = cx.typeck_results().expr_ty(original_recv).peel_refs().kind();
-            let original_recv_is_str_kind = matches!(original_recv_ty_kind, ty::Str);
+    if name == "replace" {
+        // The receiver of the method call must be `str` type to lint `collapsible_str_replace`
+        let original_recv = find_original_recv(recv);
+        let original_recv_ty_kind = cx.typeck_results().expr_ty(original_recv).peel_refs().kind();
+        let original_recv_is_str_kind = matches!(original_recv_ty_kind, ty::Str);
 
-            if_chain! {
-                if original_recv_is_str_kind;
-                if let Some(parent) = get_parent_expr(cx, expr);
-                if let Some((name, ..)) = method_call(parent);
+        if_chain! {
+            if original_recv_is_str_kind;
+            if let Some(parent) = get_parent_expr(cx, expr);
+            if let Some((name, ..)) = method_call(parent);
+            if name == "replace";
 
-                then {
-                    match name {
-                        // If the parent node is a `str::replace` call, we've already handled the lint, don't lint again
-                        "replace" => return,
-                        _ => {
-                            check_consecutive_replace_calls(cx, expr);
-                            return;
-                        },
-                    }
-                }
+            then {
+                // If the parent node is a `str::replace` call, we've already handled the lint, don't lint again
+                return;
             }
+        }
 
-            match method_call(recv) {
-                // Check if there's an earlier `str::replace` call
-                Some(("replace", ..)) => {
-                    if original_recv_is_str_kind {
-                        check_consecutive_replace_calls(cx, expr);
-                        return;
-                    }
-                },
-                _ => {},
+        if let Some(("replace", ..)) = method_call(recv) {
+            // Check if there's an earlier `str::replace` call
+            if original_recv_is_str_kind {
+                check_consecutive_replace_calls(cx, expr);
             }
-        },
-        _ => {},
+        }
     }
 }
 
@@ -116,7 +105,7 @@ fn check_consecutive_replace_calls<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir
 
 /// Check if all the `from` arguments of a chain of consecutive calls to `str::replace`
 /// are all of `ExprKind::Lit` types. If any is not, return false.
-fn replace_call_from_args_are_only_lit_chars<'tcx>(from_args: &Vec<&'tcx hir::Expr<'tcx>>) -> bool {
+fn replace_call_from_args_are_only_lit_chars<'tcx>(from_args: &[&'tcx hir::Expr<'tcx>]) -> bool {
     let mut only_lit_chars = true;
 
     for from_arg in from_args.iter() {
@@ -159,9 +148,9 @@ fn get_replace_call_from_args_if_all_char_ty<'tcx>(
 
     if all_from_args_are_chars {
         return Some(from_args);
-    } else {
-        return None;
     }
+
+    None
 }
 
 /// Return a unique String representation of the `to` argument used in a chain of `str::replace`
@@ -186,13 +175,13 @@ fn get_replace_call_unique_to_arg_repr<'tcx>(expr: &'tcx hir::Expr<'tcx>) -> Opt
 
     // let mut to_arg_repr_set = FxHashSet::default();
     let mut to_arg_reprs = Vec::new();
-    for &to_arg in to_args.iter() {
+    for &to_arg in &to_args {
         if let Some(to_arg_repr) = get_replace_call_char_arg_repr(to_arg) {
             to_arg_reprs.push(to_arg_repr);
         }
     }
 
-    let to_arg_repr_set = FxHashSet::from_iter(to_arg_reprs.iter().cloned());
+    let to_arg_repr_set = to_arg_reprs.iter().cloned().collect::<FxHashSet<_>>();
     // Check if the set of `to` argument representations has more than one unique value
     if to_arg_repr_set.len() != 1 {
         return None;
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index f9358693623..8b2fa8e9457 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -152,11 +152,11 @@ declare_clippy_lint! {
     /// let hello = "hesuo worpd"
     ///     .replace('s', "l")
     ///     .replace("u", "l")
-    ///     .replace('p', "l")
+    ///     .replace('p', "l");
     /// ```
     /// Use instead:
     /// ```rust
-    /// let hello = "hesuo worpd".replace(|c| matches!(c, 's' | 'u' | 'p'), "l")
+    /// let hello = "hesuo worpd".replace(|c| matches!(c, 's' | 'u' | 'p'), "l");
     /// ```
     #[clippy::version = "1.64.0"]
     pub COLLAPSIBLE_STR_REPLACE,
@@ -3521,7 +3521,7 @@ impl Methods {
                 },
                 ("replace" | "replacen", [arg1, arg2] | [arg1, arg2, _]) => {
                     no_effect_replace::check(cx, expr, arg1, arg2);
-                    collapsible_str_replace::check(cx, expr, name, recv, args);
+                    collapsible_str_replace::check(cx, expr, name, recv);
                 },
                 ("splitn" | "rsplitn", [count_arg, pat_arg]) => {
                     if let Some((Constant::Int(count), _)) = constant(cx, cx.typeck_results(), count_arg) {
diff --git a/tests/ui/collapsible_str_replace.fixed b/tests/ui/collapsible_str_replace.fixed
new file mode 100644
index 00000000000..0bf857d9837
--- /dev/null
+++ b/tests/ui/collapsible_str_replace.fixed
@@ -0,0 +1,65 @@
+// run-rustfix
+
+#![warn(clippy::collapsible_str_replace)]
+
+fn get_filter() -> &'static str {
+    "u"
+}
+
+fn main() {
+    let misspelled = "hesuo worpd";
+
+    let p = 'p';
+    let s = 's';
+    let u = 'u';
+    let l = "l";
+
+    // LINT CASES
+    let _ = misspelled.replace(|c| matches!(c, 'u' | 's'), "l");
+
+    let _ = misspelled.replace(|c| matches!(c, 'u' | 's'), l);
+
+    let _ = misspelled.replace(|c| matches!(c, 'p' | 'u' | 's'), "l");
+
+    let _ = misspelled
+        .replace(|c| matches!(c, 'd' | 'p' | 'u' | 's'), "l");
+
+    // FALLBACK CASES
+    // If there are consecutive calls to `str::replace` and all or any chars are variables,
+    // recommend the fallback `misspelled.replace(&[s, u, p], "l")`
+    let _ = misspelled.replace(&['u' , s], "l");
+
+    let _ = misspelled.replace(&['p' , 'u' , s], "l");
+
+    let _ = misspelled.replace(&['p' , u , s], "l");
+
+    let _ = misspelled.replace(&[p , u , s], "l");
+
+    // NO LINT CASES
+    let _ = misspelled.replace('s', "l");
+
+    let _ = misspelled.replace(s, "l");
+
+    // If the consecutive `str::replace` calls have different `to` arguments, do not lint
+    let _ = misspelled.replace('s', "l").replace('u', "p");
+
+    let _ = misspelled.replace(&get_filter(), "l");
+
+    let _ = misspelled.replace(&['s', 'u', 'p'], "l");
+
+    let _ = misspelled.replace(&['s', 'u', 'p'], l);
+
+    let _ = misspelled.replace(&['s', 'u'], "l").replace(&['u', 'p'], "l");
+
+    let _ = misspelled.replace('s', "l").replace(&['u', 'p'], "l");
+
+    let _ = misspelled.replace(&['s', 'u'], "l").replace('p', "l");
+
+    let _ = misspelled.replace(&['s', u, 'p'], "l");
+
+    let _ = misspelled.replace(&[s, u, 'p'], "l");
+
+    let _ = misspelled.replace(&[s, u, p], "l");
+
+    let _ = misspelled.replace(&[s, u], "l").replace(&[u, p], "l");
+}
diff --git a/tests/ui/collapsible_str_replace.rs b/tests/ui/collapsible_str_replace.rs
index 05a4fd08a32..45d9fd87e5e 100644
--- a/tests/ui/collapsible_str_replace.rs
+++ b/tests/ui/collapsible_str_replace.rs
@@ -1,3 +1,5 @@
+// run-rustfix
+
 #![warn(clippy::collapsible_str_replace)]
 
 fn get_filter() -> &'static str {
@@ -13,75 +15,54 @@ fn main() {
     let l = "l";
 
     // LINT CASES
-    let replacement = misspelled.replace('s', "l").replace('u', "l");
-    println!("{replacement}");
+    let _ = misspelled.replace('s', "l").replace('u', "l");
 
-    let replacement = misspelled.replace('s', l).replace('u', l);
-    println!("{replacement}");
+    let _ = misspelled.replace('s', l).replace('u', l);
 
-    let replacement = misspelled.replace('s', "l").replace('u', "l").replace('p', "l");
-    println!("{replacement}");
+    let _ = misspelled.replace('s', "l").replace('u', "l").replace('p', "l");
 
-    let replacement = misspelled
+    let _ = misspelled
         .replace('s', "l")
         .replace('u', "l")
         .replace('p', "l")
         .replace('d', "l");
-    println!("{replacement}");
 
     // FALLBACK CASES
     // If there are consecutive calls to `str::replace` and all or any chars are variables,
     // recommend the fallback `misspelled.replace(&[s, u, p], "l")`
-    let replacement = misspelled.replace(s, "l").replace('u', "l");
-    println!("{replacement}");
+    let _ = misspelled.replace(s, "l").replace('u', "l");
 
-    let replacement = misspelled.replace(s, "l").replace('u', "l").replace('p', "l");
-    println!("{replacement}");
+    let _ = misspelled.replace(s, "l").replace('u', "l").replace('p', "l");
 
-    let replacement = misspelled.replace(s, "l").replace(u, "l").replace('p', "l");
-    println!("{replacement}");
+    let _ = misspelled.replace(s, "l").replace(u, "l").replace('p', "l");
 
-    let replacement = misspelled.replace(s, "l").replace(u, "l").replace(p, "l");
-    println!("{replacement}");
+    let _ = misspelled.replace(s, "l").replace(u, "l").replace(p, "l");
 
     // NO LINT CASES
-    let replacement = misspelled.replace('s', "l");
-    println!("{replacement}");
+    let _ = misspelled.replace('s', "l");
 
-    let replacement = misspelled.replace(s, "l");
-    println!("{replacement}");
+    let _ = misspelled.replace(s, "l");
 
     // If the consecutive `str::replace` calls have different `to` arguments, do not lint
-    let replacement = misspelled.replace('s', "l").replace('u', "p");
-    println!("{replacement}");
+    let _ = misspelled.replace('s', "l").replace('u', "p");
 
-    let replacement = misspelled.replace(&get_filter(), "l");
-    println!("{replacement}");
+    let _ = misspelled.replace(&get_filter(), "l");
 
-    let replacement = misspelled.replace(&['s', 'u', 'p'], "l");
-    println!("{replacement}");
+    let _ = misspelled.replace(&['s', 'u', 'p'], "l");
 
-    let replacement = misspelled.replace(&['s', 'u', 'p'], l);
-    println!("{replacement}");
+    let _ = misspelled.replace(&['s', 'u', 'p'], l);
 
-    let replacement = misspelled.replace(&['s', 'u'], "l").replace(&['u', 'p'], "l");
-    println!("{replacement}");
+    let _ = misspelled.replace(&['s', 'u'], "l").replace(&['u', 'p'], "l");
 
-    let replacement = misspelled.replace('s', "l").replace(&['u', 'p'], "l");
-    println!("{replacement}");
+    let _ = misspelled.replace('s', "l").replace(&['u', 'p'], "l");
 
-    let replacement = misspelled.replace(&['s', 'u'], "l").replace('p', "l");
-    println!("replacement");
+    let _ = misspelled.replace(&['s', 'u'], "l").replace('p', "l");
 
-    let replacement = misspelled.replace(&['s', u, 'p'], "l");
-    println!("{replacement}");
+    let _ = misspelled.replace(&['s', u, 'p'], "l");
 
-    let replacement = misspelled.replace(&[s, u, 'p'], "l");
-    println!("{replacement}");
+    let _ = misspelled.replace(&[s, u, 'p'], "l");
 
-    let replacement = misspelled.replace(&[s, u, p], "l");
-    println!("{replacement}");
+    let _ = misspelled.replace(&[s, u, p], "l");
 
-    let replacement = misspelled.replace(&[s, u], "l").replace(&[u, p], "l");
-    println!("{replacement}");
+    let _ = misspelled.replace(&[s, u], "l").replace(&[u, p], "l");
 }
diff --git a/tests/ui/collapsible_str_replace.stderr b/tests/ui/collapsible_str_replace.stderr
new file mode 100644
index 00000000000..372fe1da448
--- /dev/null
+++ b/tests/ui/collapsible_str_replace.stderr
@@ -0,0 +1,56 @@
+error: used consecutive `str::replace` call
+  --> $DIR/collapsible_str_replace.rs:18:24
+   |
+LL |     let _ = misspelled.replace('s', "l").replace('u', "l");
+   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `replace(|c| matches!(c, 'u' | 's'), "l")`
+   |
+   = note: `-D clippy::collapsible-str-replace` implied by `-D warnings`
+
+error: used consecutive `str::replace` call
+  --> $DIR/collapsible_str_replace.rs:20:24
+   |
+LL |     let _ = misspelled.replace('s', l).replace('u', l);
+   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `replace(|c| matches!(c, 'u' | 's'), l)`
+
+error: used consecutive `str::replace` call
+  --> $DIR/collapsible_str_replace.rs:22:24
+   |
+LL |     let _ = misspelled.replace('s', "l").replace('u', "l").replace('p', "l");
+   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `replace(|c| matches!(c, 'p' | 'u' | 's'), "l")`
+
+error: used consecutive `str::replace` call
+  --> $DIR/collapsible_str_replace.rs:25:10
+   |
+LL |           .replace('s', "l")
+   |  __________^
+LL | |         .replace('u', "l")
+LL | |         .replace('p', "l")
+LL | |         .replace('d', "l");
+   | |__________________________^ help: replace with: `replace(|c| matches!(c, 'd' | 'p' | 'u' | 's'), "l")`
+
+error: used consecutive `str::replace` call
+  --> $DIR/collapsible_str_replace.rs:33:24
+   |
+LL |     let _ = misspelled.replace(s, "l").replace('u', "l");
+   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `replace(&['u' , s], "l")`
+
+error: used consecutive `str::replace` call
+  --> $DIR/collapsible_str_replace.rs:35:24
+   |
+LL |     let _ = misspelled.replace(s, "l").replace('u', "l").replace('p', "l");
+   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `replace(&['p' , 'u' , s], "l")`
+
+error: used consecutive `str::replace` call
+  --> $DIR/collapsible_str_replace.rs:37:24
+   |
+LL |     let _ = misspelled.replace(s, "l").replace(u, "l").replace('p', "l");
+   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `replace(&['p' , u , s], "l")`
+
+error: used consecutive `str::replace` call
+  --> $DIR/collapsible_str_replace.rs:39:24
+   |
+LL |     let _ = misspelled.replace(s, "l").replace(u, "l").replace(p, "l");
+   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `replace(&[p , u , s], "l")`
+
+error: aborting due to 8 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 2781ad0e9ee9aaf827ff2e089cfad377892d9e74 Mon Sep 17 00:00:00 2001
From: alex-semenyuk <alexsemenyuk88@gmail.com>
Date: Sat, 20 Aug 2022 12:31:29 +0300
Subject: Fix typos

---
 clippy_lints/src/manual_empty_string_creations.rs | 4 ++--
 clippy_utils/src/macros.rs                        | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_empty_string_creations.rs b/clippy_lints/src/manual_empty_string_creations.rs
index dd602a89b4f..a2a10eb91e5 100644
--- a/clippy_lints/src/manual_empty_string_creations.rs
+++ b/clippy_lints/src/manual_empty_string_creations.rs
@@ -88,7 +88,7 @@ fn warn_then_suggest(cx: &LateContext<'_>, span: Span) {
     );
 }
 
-/// Tries to parse an expression as a method call, emiting the warning if necessary.
+/// Tries to parse an expression as a method call, emitting the warning if necessary.
 fn parse_method_call(cx: &LateContext<'_>, span: Span, path_segment: &PathSegment<'_>, args: &[Expr<'_>]) {
     if args.is_empty() {
         // When parsing TryFrom::try_from(...).expect(...), we will have more than 1 arg.
@@ -106,7 +106,7 @@ fn parse_method_call(cx: &LateContext<'_>, span: Span, path_segment: &PathSegmen
     }
 }
 
-/// Tries to parse an expression as a function call, emiting the warning if necessary.
+/// Tries to parse an expression as a function call, emitting the warning if necessary.
 fn parse_call(cx: &LateContext<'_>, span: Span, func: &Expr<'_>, args: &[Expr<'_>]) {
     if args.len() != 1 {
         return;
diff --git a/clippy_utils/src/macros.rs b/clippy_utils/src/macros.rs
index 37d8f1e458d..e5ca3545540 100644
--- a/clippy_utils/src/macros.rs
+++ b/clippy_utils/src/macros.rs
@@ -567,7 +567,7 @@ pub enum FormatParamKind {
     Numbered,
     /// A named parameter with a named `value_arg`, such as the `x` in `format!("{x}", x = 1)`.
     Named(Symbol),
-    /// An implicit named paramter, such as the `y` in `format!("{y}")`.
+    /// An implicit named parameter, such as the `y` in `format!("{y}")`.
     NamedInline(Symbol),
 }
 
@@ -584,7 +584,7 @@ pub enum FormatParamKind {
 pub struct FormatParam<'tcx> {
     /// The expression this parameter refers to.
     pub value: &'tcx Expr<'tcx>,
-    /// How this paramter refers to its `value`.
+    /// How this parameter refers to its `value`.
     pub kind: FormatParamKind,
     /// Span of the parameter, may be zero width. Includes the whitespace of implicit parameters.
     ///
-- 
cgit 1.4.1-3-g733a5


From b070b4045f348f9222008270a435bda17b048c15 Mon Sep 17 00:00:00 2001
From: Nahua Kang <kangnahua@gmail.com>
Date: Sun, 14 Aug 2022 18:33:55 +0200
Subject: Simplify lint logic and address code review comments

---
 .../src/methods/collapsible_str_replace.rs         | 301 +++++----------------
 clippy_lints/src/methods/mod.rs                    |  14 +-
 tests/ui/collapsible_str_replace.fixed             |  70 ++---
 tests/ui/collapsible_str_replace.rs                |  68 +++--
 tests/ui/collapsible_str_replace.stderr            |  78 ++++--
 5 files changed, 201 insertions(+), 330 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/collapsible_str_replace.rs b/clippy_lints/src/methods/collapsible_str_replace.rs
index 4c6288e798c..561033be5b6 100644
--- a/clippy_lints/src/methods/collapsible_str_replace.rs
+++ b/clippy_lints/src/methods/collapsible_str_replace.rs
@@ -1,19 +1,12 @@
-// run-rustfix
-
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::get_parent_expr;
+use clippy_utils::source::snippet;
 use clippy_utils::visitors::for_each_expr;
+use clippy_utils::{eq_expr_value, get_parent_expr};
 use core::ops::ControlFlow;
-use if_chain::if_chain;
-use rustc_ast::ast::LitKind;
-use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
-use rustc_hir::{ExprKind, Path, QPath};
 use rustc_lint::LateContext;
-use rustc_middle::ty;
-use rustc_span::source_map::Spanned;
-use rustc_span::Span;
+use std::collections::VecDeque;
 
 use super::method_call;
 use super::COLLAPSIBLE_STR_REPLACE;
@@ -21,255 +14,83 @@ use super::COLLAPSIBLE_STR_REPLACE;
 pub(super) fn check<'tcx>(
     cx: &LateContext<'tcx>,
     expr: &'tcx hir::Expr<'tcx>,
-    name: &str,
-    recv: &'tcx hir::Expr<'tcx>,
+    from: &'tcx hir::Expr<'tcx>,
+    to: &'tcx hir::Expr<'tcx>,
 ) {
-    if name == "replace" {
-        // The receiver of the method call must be `str` type to lint `collapsible_str_replace`
-        let original_recv = find_original_recv(recv);
-        let original_recv_ty_kind = cx.typeck_results().expr_ty(original_recv).peel_refs().kind();
-        let original_recv_is_str_kind = matches!(original_recv_ty_kind, ty::Str);
-
-        if_chain! {
-            if original_recv_is_str_kind;
-            if let Some(parent) = get_parent_expr(cx, expr);
-            if let Some((name, ..)) = method_call(parent);
-            if name == "replace";
-
-            then {
-                // If the parent node is a `str::replace` call, we've already handled the lint, don't lint again
-                return;
-            }
+    let replace_methods = collect_replace_calls(cx, expr, to);
+    if replace_methods.methods.len() > 1 {
+        let from_kind = cx.typeck_results().expr_ty(from).peel_refs().kind();
+        // If the parent node's `to` argument is the same as the `to` argument
+        // of the last replace call in the current chain, don't lint as it was already linted
+        if let Some(parent) = get_parent_expr(cx, expr)
+            && let Some(("replace", [_, current_from, current_to], _)) = method_call(parent)
+            && eq_expr_value(cx, to, current_to)
+            && from_kind == cx.typeck_results().expr_ty(current_from).peel_refs().kind()
+        {
+            return;
         }
 
-        if let Some(("replace", ..)) = method_call(recv) {
-            // Check if there's an earlier `str::replace` call
-            if original_recv_is_str_kind {
-                check_consecutive_replace_calls(cx, expr);
-            }
-        }
+        check_consecutive_replace_calls(cx, expr, &replace_methods, to);
     }
 }
 
-/// Check a chain of `str::replace` calls for `collapsible_str_replace` lint.
-fn check_consecutive_replace_calls<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'tcx>) {
-    if_chain! {
-        if let Some(from_args) = get_replace_call_from_args_if_all_char_ty(cx, expr);
-        if let Some(to_arg) = get_replace_call_unique_to_arg_repr(expr);
-        then {
-            let earliest_replace_call_span = get_earliest_replace_call_span(expr);
-
-            if replace_call_from_args_are_only_lit_chars(&from_args) {
-                let from_arg_reprs: Vec<String> = from_args.iter().map(|from_arg| {
-                    get_replace_call_char_arg_repr(from_arg).unwrap()
-                }).collect();
-                let app = Applicability::MachineApplicable;
-
-                span_lint_and_sugg(
-                    cx,
-                    COLLAPSIBLE_STR_REPLACE,
-                    expr.span.with_lo(earliest_replace_call_span.lo()),
-                    "used consecutive `str::replace` call",
-                    "replace with",
-                    format!(
-                        "replace(|c| matches!(c, {}), {})",
-                        from_arg_reprs.join(" | "),
-                        to_arg,
-                    ),
-                    app,
-                );
-            } else {
-                // Use fallback lint
-                let from_arg_reprs: Vec<String> = from_args.iter().map(|from_arg| {
-                    get_replace_call_char_arg_repr(from_arg).unwrap()
-                }).collect();
-                let app = Applicability::MachineApplicable;
-
-                span_lint_and_sugg(
-                    cx,
-                    COLLAPSIBLE_STR_REPLACE,
-                    expr.span.with_lo(earliest_replace_call_span.lo()),
-                    "used consecutive `str::replace` call",
-                    "replace with",
-                    format!(
-                        "replace(&[{}], {})",
-                        from_arg_reprs.join(" , "),
-                        to_arg,
-                    ),
-                    app,
-                );
-            }
-        }
-    }
+struct ReplaceMethods<'tcx> {
+    methods: VecDeque<&'tcx hir::Expr<'tcx>>,
+    from_args: VecDeque<&'tcx hir::Expr<'tcx>>,
 }
 
-/// Check if all the `from` arguments of a chain of consecutive calls to `str::replace`
-/// are all of `ExprKind::Lit` types. If any is not, return false.
-fn replace_call_from_args_are_only_lit_chars<'tcx>(from_args: &[&'tcx hir::Expr<'tcx>]) -> bool {
-    let mut only_lit_chars = true;
-
-    for from_arg in from_args.iter() {
-        match from_arg.kind {
-            ExprKind::Lit(..) => {},
-            _ => only_lit_chars = false,
-        }
-    }
-
-    only_lit_chars
-}
-
-/// Collect and return all of the `from` arguments of a chain of consecutive `str::replace` calls
-/// if these `from` arguments's expressions are of the `ty::Char` kind. Otherwise return `None`.
-fn get_replace_call_from_args_if_all_char_ty<'tcx>(
+fn collect_replace_calls<'tcx>(
     cx: &LateContext<'tcx>,
     expr: &'tcx hir::Expr<'tcx>,
-) -> Option<Vec<&'tcx hir::Expr<'tcx>>> {
-    let mut all_from_args_are_chars = true;
-    let mut from_args = Vec::new();
+    to_arg: &'tcx hir::Expr<'tcx>,
+) -> ReplaceMethods<'tcx> {
+    let mut methods = VecDeque::new();
+    let mut from_args = VecDeque::new();
 
     let _: Option<()> = for_each_expr(expr, |e| {
-        if let Some((name, [_, args @ ..], _)) = method_call(e) {
-            match (name, args) {
-                ("replace", [from, _]) => {
-                    let from_ty_kind = cx.typeck_results().expr_ty(from).peel_refs().kind();
-                    if matches!(from_ty_kind, ty::Char) {
-                        from_args.push(from);
-                    } else {
-                        all_from_args_are_chars = false;
-                    }
-                    ControlFlow::Continue(())
-                },
-                _ => ControlFlow::BREAK,
-            }
-        } else {
-            ControlFlow::Continue(())
-        }
-    });
-
-    if all_from_args_are_chars {
-        return Some(from_args);
-    }
-
-    None
-}
-
-/// Return a unique String representation of the `to` argument used in a chain of `str::replace`
-/// calls if each `str::replace` call's `to` argument is identical to the other `to` arguments in
-/// the chain. Otherwise, return `None`.
-fn get_replace_call_unique_to_arg_repr<'tcx>(expr: &'tcx hir::Expr<'tcx>) -> Option<String> {
-    let mut to_args = Vec::new();
-
-    let _: Option<()> = for_each_expr(expr, |e| {
-        if let Some((name, [_, args @ ..], _)) = method_call(e) {
-            match (name, args) {
-                ("replace", [_, to]) => {
-                    to_args.push(to);
-                    ControlFlow::Continue(())
-                },
-                _ => ControlFlow::BREAK,
+        if let Some(("replace", [_, from, to], _)) = method_call(e) {
+            if eq_expr_value(cx, to_arg, to) && cx.typeck_results().expr_ty(from).peel_refs().is_char() {
+                methods.push_front(e);
+                from_args.push_front(from);
+                ControlFlow::Continue(())
+            } else {
+                ControlFlow::BREAK
             }
         } else {
             ControlFlow::Continue(())
         }
     });
 
-    // let mut to_arg_repr_set = FxHashSet::default();
-    let mut to_arg_reprs = Vec::new();
-    for &to_arg in &to_args {
-        if let Some(to_arg_repr) = get_replace_call_char_arg_repr(to_arg) {
-            to_arg_reprs.push(to_arg_repr);
-        }
-    }
-
-    let to_arg_repr_set = to_arg_reprs.iter().cloned().collect::<FxHashSet<_>>();
-    // Check if the set of `to` argument representations has more than one unique value
-    if to_arg_repr_set.len() != 1 {
-        return None;
-    }
-
-    // Return the single representation value
-    to_arg_reprs.pop()
+    ReplaceMethods { methods, from_args }
 }
 
-/// Get the representation of an argument of a `str::replace` call either of the literal char value
-/// or variable name, i.e. the resolved path segments `ident`.
-/// Return:
-/// - the str literal with double quotes, e.g. "\"l\""
-/// - the char literal with single quotes, e.g. "'l'"
-/// - the variable as a String, e.g. "l"
-fn get_replace_call_char_arg_repr<'tcx>(arg: &'tcx hir::Expr<'tcx>) -> Option<String> {
-    match arg.kind {
-        ExprKind::Lit(Spanned {
-            node: LitKind::Str(to_arg_val, _),
-            ..
-        }) => {
-            let repr = to_arg_val.as_str();
-            let double_quote = "\"";
-            Some(double_quote.to_owned() + repr + double_quote)
-        },
-        ExprKind::Lit(Spanned {
-            node: LitKind::Char(to_arg_val),
-            ..
-        }) => {
-            let repr = to_arg_val.to_string();
-            let double_quote = "\'";
-            Some(double_quote.to_owned() + &repr + double_quote)
-        },
-        ExprKind::Path(QPath::Resolved(
-            _,
-            Path {
-                segments: path_segments,
-                ..
-            },
-        )) => {
-            // join the path_segments values by "::"
-            let path_segment_ident_names: Vec<&str> = path_segments
-                .iter()
-                .map(|path_seg| path_seg.ident.name.as_str())
-                .collect();
-            Some(path_segment_ident_names.join("::"))
-        },
-        _ => None,
+/// Check a chain of `str::replace` calls for `collapsible_str_replace` lint.
+fn check_consecutive_replace_calls<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx hir::Expr<'tcx>,
+    replace_methods: &ReplaceMethods<'tcx>,
+    to_arg: &'tcx hir::Expr<'tcx>,
+) {
+    let from_args = &replace_methods.from_args;
+    let from_arg_reprs: Vec<String> = from_args
+        .iter()
+        .map(|from_arg| snippet(cx, from_arg.span, "..").to_string())
+        .collect();
+    let app = Applicability::MachineApplicable;
+    let earliest_replace_call = replace_methods.methods.front().unwrap();
+    if let Some((_, [..], span_lo)) = method_call(earliest_replace_call) {
+        span_lint_and_sugg(
+            cx,
+            COLLAPSIBLE_STR_REPLACE,
+            expr.span.with_lo(span_lo.lo()),
+            "used consecutive `str::replace` call",
+            "replace with",
+            format!(
+                "replace([{}], {})",
+                from_arg_reprs.join(", "),
+                snippet(cx, to_arg.span, ".."),
+            ),
+            app,
+        );
     }
 }
-
-fn get_earliest_replace_call_span<'tcx>(expr: &'tcx hir::Expr<'tcx>) -> Span {
-    let mut earliest_replace_call_span = expr.span;
-
-    let _: Option<()> = for_each_expr(expr, |e| {
-        if let Some((name, [_, args @ ..], span)) = method_call(e) {
-            match (name, args) {
-                ("replace", [_, _]) => {
-                    earliest_replace_call_span = span;
-                    ControlFlow::Continue(())
-                },
-                _ => ControlFlow::BREAK,
-            }
-        } else {
-            ControlFlow::Continue(())
-        }
-    });
-
-    earliest_replace_call_span
-}
-
-/// Find the original receiver of a chain of `str::replace` method calls.
-fn find_original_recv<'tcx>(recv: &'tcx hir::Expr<'tcx>) -> &'tcx hir::Expr<'tcx> {
-    let mut original_recv = recv;
-
-    let _: Option<()> = for_each_expr(recv, |e| {
-        if let Some((name, [prev_recv, args @ ..], _)) = method_call(e) {
-            match (name, args) {
-                ("replace", [_, _]) => {
-                    original_recv = prev_recv;
-                    ControlFlow::Continue(())
-                },
-                _ => ControlFlow::BREAK,
-            }
-        } else {
-            ControlFlow::Continue(())
-        }
-    });
-
-    original_recv
-}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 8b2fa8e9457..49d4900295f 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -156,7 +156,7 @@ declare_clippy_lint! {
     /// ```
     /// Use instead:
     /// ```rust
-    /// let hello = "hesuo worpd".replace(|c| matches!(c, 's' | 'u' | 'p'), "l");
+    /// let hello = "hesuo worpd".replace(&['s', 'u', 'p'], "l");
     /// ```
     #[clippy::version = "1.64.0"]
     pub COLLAPSIBLE_STR_REPLACE,
@@ -3507,6 +3507,14 @@ impl Methods {
                 ("repeat", [arg]) => {
                     repeat_once::check(cx, expr, recv, arg);
                 },
+                (name @ ("replace" | "replacen"), [arg1, arg2] | [arg1, arg2, _]) => {
+                    no_effect_replace::check(cx, expr, arg1, arg2);
+
+                    // Check for repeated `str::replace` calls to perform `collapsible_str_replace` lint
+                    if name == "replace" && let Some(("replace", ..)) = method_call(recv) {
+                        collapsible_str_replace::check(cx, expr, arg1, arg2);
+                    }
+                },
                 ("resize", [count_arg, default_arg]) => {
                     vec_resize_to_zero::check(cx, expr, count_arg, default_arg, span);
                 },
@@ -3519,10 +3527,6 @@ impl Methods {
                 ("sort_unstable_by", [arg]) => {
                     unnecessary_sort_by::check(cx, expr, recv, arg, true);
                 },
-                ("replace" | "replacen", [arg1, arg2] | [arg1, arg2, _]) => {
-                    no_effect_replace::check(cx, expr, arg1, arg2);
-                    collapsible_str_replace::check(cx, expr, name, recv);
-                },
                 ("splitn" | "rsplitn", [count_arg, pat_arg]) => {
                     if let Some((Constant::Int(count), _)) = constant(cx, cx.typeck_results(), count_arg) {
                         suspicious_splitn::check(cx, name, expr, recv, count);
diff --git a/tests/ui/collapsible_str_replace.fixed b/tests/ui/collapsible_str_replace.fixed
index 0bf857d9837..49fc9a9629e 100644
--- a/tests/ui/collapsible_str_replace.fixed
+++ b/tests/ui/collapsible_str_replace.fixed
@@ -2,64 +2,72 @@
 
 #![warn(clippy::collapsible_str_replace)]
 
-fn get_filter() -> &'static str {
-    "u"
+fn get_filter() -> char {
+    'u'
 }
 
 fn main() {
-    let misspelled = "hesuo worpd";
-
+    let d = 'd';
     let p = 'p';
     let s = 's';
     let u = 'u';
     let l = "l";
 
+    let mut iter = ["l", "z"].iter();
+
     // LINT CASES
-    let _ = misspelled.replace(|c| matches!(c, 'u' | 's'), "l");
+    let _ = "hesuo worpd".replace(['s', 'u'], "l");
 
-    let _ = misspelled.replace(|c| matches!(c, 'u' | 's'), l);
+    let _ = "hesuo worpd".replace(['s', 'u'], l);
 
-    let _ = misspelled.replace(|c| matches!(c, 'p' | 'u' | 's'), "l");
+    let _ = "hesuo worpd".replace(['s', 'u', 'p'], "l");
 
-    let _ = misspelled
-        .replace(|c| matches!(c, 'd' | 'p' | 'u' | 's'), "l");
+    let _ = "hesuo worpd"
+        .replace(['s', 'u', 'p', 'd'], "l");
 
-    // FALLBACK CASES
-    // If there are consecutive calls to `str::replace` and all or any chars are variables,
-    // recommend the fallback `misspelled.replace(&[s, u, p], "l")`
-    let _ = misspelled.replace(&['u' , s], "l");
+    let _ = "hesuo world".replace([s, 'u'], "l");
 
-    let _ = misspelled.replace(&['p' , 'u' , s], "l");
+    let _ = "hesuo worpd".replace([s, 'u', 'p'], "l");
 
-    let _ = misspelled.replace(&['p' , u , s], "l");
+    let _ = "hesuo worpd".replace([s, u, 'p'], "l");
 
-    let _ = misspelled.replace(&[p , u , s], "l");
+    let _ = "hesuo worpd".replace([s, u, p], "l");
 
-    // NO LINT CASES
-    let _ = misspelled.replace('s', "l");
+    let _ = "hesuo worlp".replace(['s', 'u'], "l").replace('p', "d");
+
+    let _ = "hesuo worpd".replace('s', "x").replace(['u', 'p'], "l");
 
-    let _ = misspelled.replace(s, "l");
+    // Note: Future iterations could lint `replace(|c| matches!(c, "su" | 'd' | 'p'), "l")`
+    let _ = "hesudo worpd".replace("su", "l").replace(['d', 'p'], "l");
 
-    // If the consecutive `str::replace` calls have different `to` arguments, do not lint
-    let _ = misspelled.replace('s', "l").replace('u', "p");
+    let _ = "hesudo worpd".replace([d, 'p'], "l").replace("su", "l");
+
+    let _ = "hesuo world".replace([get_filter(), 's'], "l");
+
+    // NO LINT CASES
+    let _ = "hesuo world".replace('s', "l").replace('u', "p");
 
-    let _ = misspelled.replace(&get_filter(), "l");
+    let _ = "hesuo worpd".replace('s', "l").replace('p', l);
 
-    let _ = misspelled.replace(&['s', 'u', 'p'], "l");
+    let _ = "hesudo worpd".replace('d', "l").replace("su", "l").replace('p', "l");
 
-    let _ = misspelled.replace(&['s', 'u', 'p'], l);
+    // Note: Future iterations of `collapsible_str_replace` might lint this and combine to `[s, u, p]`
+    let _ = "hesuo worpd".replace([s, u], "l").replace([u, p], "l");
 
-    let _ = misspelled.replace(&['s', 'u'], "l").replace(&['u', 'p'], "l");
+    let _ = "hesuo worpd".replace(['s', 'u'], "l").replace(['u', 'p'], "l");
 
-    let _ = misspelled.replace('s', "l").replace(&['u', 'p'], "l");
+    let _ = "hesuo worpd".replace('s', "l").replace(['u', 'p'], "l");
 
-    let _ = misspelled.replace(&['s', 'u'], "l").replace('p', "l");
+    let _ = "hesuo worpd".replace(['s', 'u', 'p'], "l").replace('r', "l");
 
-    let _ = misspelled.replace(&['s', u, 'p'], "l");
+    let _ = "hesuo worpd".replace(['s', 'u', 'p'], l).replace('r', l);
 
-    let _ = misspelled.replace(&[s, u, 'p'], "l");
+    let _ = "hesuo worpd".replace(['s', u, 'p'], "l").replace('r', "l");
 
-    let _ = misspelled.replace(&[s, u, p], "l");
+    let _ = "hesuo worpd".replace([s, u], "l").replace(p, "l");
 
-    let _ = misspelled.replace(&[s, u], "l").replace(&[u, p], "l");
+    // Regression test
+    let _ = "hesuo worpd"
+        .replace('u', iter.next().unwrap())
+        .replace('s', iter.next().unwrap());
 }
diff --git a/tests/ui/collapsible_str_replace.rs b/tests/ui/collapsible_str_replace.rs
index 45d9fd87e5e..e3e25c4146f 100644
--- a/tests/ui/collapsible_str_replace.rs
+++ b/tests/ui/collapsible_str_replace.rs
@@ -2,67 +2,75 @@
 
 #![warn(clippy::collapsible_str_replace)]
 
-fn get_filter() -> &'static str {
-    "u"
+fn get_filter() -> char {
+    'u'
 }
 
 fn main() {
-    let misspelled = "hesuo worpd";
-
+    let d = 'd';
     let p = 'p';
     let s = 's';
     let u = 'u';
     let l = "l";
 
+    let mut iter = ["l", "z"].iter();
+
     // LINT CASES
-    let _ = misspelled.replace('s', "l").replace('u', "l");
+    let _ = "hesuo worpd".replace('s', "l").replace('u', "l");
 
-    let _ = misspelled.replace('s', l).replace('u', l);
+    let _ = "hesuo worpd".replace('s', l).replace('u', l);
 
-    let _ = misspelled.replace('s', "l").replace('u', "l").replace('p', "l");
+    let _ = "hesuo worpd".replace('s', "l").replace('u', "l").replace('p', "l");
 
-    let _ = misspelled
+    let _ = "hesuo worpd"
         .replace('s', "l")
         .replace('u', "l")
         .replace('p', "l")
         .replace('d', "l");
 
-    // FALLBACK CASES
-    // If there are consecutive calls to `str::replace` and all or any chars are variables,
-    // recommend the fallback `misspelled.replace(&[s, u, p], "l")`
-    let _ = misspelled.replace(s, "l").replace('u', "l");
+    let _ = "hesuo world".replace(s, "l").replace('u', "l");
 
-    let _ = misspelled.replace(s, "l").replace('u', "l").replace('p', "l");
+    let _ = "hesuo worpd".replace(s, "l").replace('u', "l").replace('p', "l");
 
-    let _ = misspelled.replace(s, "l").replace(u, "l").replace('p', "l");
+    let _ = "hesuo worpd".replace(s, "l").replace(u, "l").replace('p', "l");
 
-    let _ = misspelled.replace(s, "l").replace(u, "l").replace(p, "l");
+    let _ = "hesuo worpd".replace(s, "l").replace(u, "l").replace(p, "l");
 
-    // NO LINT CASES
-    let _ = misspelled.replace('s', "l");
+    let _ = "hesuo worlp".replace('s', "l").replace('u', "l").replace('p', "d");
+
+    let _ = "hesuo worpd".replace('s', "x").replace('u', "l").replace('p', "l");
 
-    let _ = misspelled.replace(s, "l");
+    // Note: Future iterations could lint `replace(|c| matches!(c, "su" | 'd' | 'p'), "l")`
+    let _ = "hesudo worpd".replace("su", "l").replace('d', "l").replace('p', "l");
 
-    // If the consecutive `str::replace` calls have different `to` arguments, do not lint
-    let _ = misspelled.replace('s', "l").replace('u', "p");
+    let _ = "hesudo worpd".replace(d, "l").replace('p', "l").replace("su", "l");
+
+    let _ = "hesuo world".replace(get_filter(), "l").replace('s', "l");
+
+    // NO LINT CASES
+    let _ = "hesuo world".replace('s', "l").replace('u', "p");
 
-    let _ = misspelled.replace(&get_filter(), "l");
+    let _ = "hesuo worpd".replace('s', "l").replace('p', l);
 
-    let _ = misspelled.replace(&['s', 'u', 'p'], "l");
+    let _ = "hesudo worpd".replace('d', "l").replace("su", "l").replace('p', "l");
 
-    let _ = misspelled.replace(&['s', 'u', 'p'], l);
+    // Note: Future iterations of `collapsible_str_replace` might lint this and combine to `[s, u, p]`
+    let _ = "hesuo worpd".replace([s, u], "l").replace([u, p], "l");
 
-    let _ = misspelled.replace(&['s', 'u'], "l").replace(&['u', 'p'], "l");
+    let _ = "hesuo worpd".replace(['s', 'u'], "l").replace(['u', 'p'], "l");
 
-    let _ = misspelled.replace('s', "l").replace(&['u', 'p'], "l");
+    let _ = "hesuo worpd".replace('s', "l").replace(['u', 'p'], "l");
 
-    let _ = misspelled.replace(&['s', 'u'], "l").replace('p', "l");
+    let _ = "hesuo worpd".replace(['s', 'u', 'p'], "l").replace('r', "l");
 
-    let _ = misspelled.replace(&['s', u, 'p'], "l");
+    let _ = "hesuo worpd".replace(['s', 'u', 'p'], l).replace('r', l);
 
-    let _ = misspelled.replace(&[s, u, 'p'], "l");
+    let _ = "hesuo worpd".replace(['s', u, 'p'], "l").replace('r', "l");
 
-    let _ = misspelled.replace(&[s, u, p], "l");
+    let _ = "hesuo worpd".replace([s, u], "l").replace(p, "l");
 
-    let _ = misspelled.replace(&[s, u], "l").replace(&[u, p], "l");
+    // Regression test
+    let _ = "hesuo worpd"
+        .replace('u', iter.next().unwrap())
+        .replace('s', iter.next().unwrap());
 }
diff --git a/tests/ui/collapsible_str_replace.stderr b/tests/ui/collapsible_str_replace.stderr
index 372fe1da448..8e3daf3b898 100644
--- a/tests/ui/collapsible_str_replace.stderr
+++ b/tests/ui/collapsible_str_replace.stderr
@@ -1,56 +1,86 @@
 error: used consecutive `str::replace` call
-  --> $DIR/collapsible_str_replace.rs:18:24
+  --> $DIR/collapsible_str_replace.rs:19:27
    |
-LL |     let _ = misspelled.replace('s', "l").replace('u', "l");
-   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `replace(|c| matches!(c, 'u' | 's'), "l")`
+LL |     let _ = "hesuo worpd".replace('s', "l").replace('u', "l");
+   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `replace(['s', 'u'], "l")`
    |
    = note: `-D clippy::collapsible-str-replace` implied by `-D warnings`
 
 error: used consecutive `str::replace` call
-  --> $DIR/collapsible_str_replace.rs:20:24
+  --> $DIR/collapsible_str_replace.rs:21:27
    |
-LL |     let _ = misspelled.replace('s', l).replace('u', l);
-   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `replace(|c| matches!(c, 'u' | 's'), l)`
+LL |     let _ = "hesuo worpd".replace('s', l).replace('u', l);
+   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `replace(['s', 'u'], l)`
 
 error: used consecutive `str::replace` call
-  --> $DIR/collapsible_str_replace.rs:22:24
+  --> $DIR/collapsible_str_replace.rs:23:27
    |
-LL |     let _ = misspelled.replace('s', "l").replace('u', "l").replace('p', "l");
-   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `replace(|c| matches!(c, 'p' | 'u' | 's'), "l")`
+LL |     let _ = "hesuo worpd".replace('s', "l").replace('u', "l").replace('p', "l");
+   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `replace(['s', 'u', 'p'], "l")`
 
 error: used consecutive `str::replace` call
-  --> $DIR/collapsible_str_replace.rs:25:10
+  --> $DIR/collapsible_str_replace.rs:26:10
    |
 LL |           .replace('s', "l")
    |  __________^
 LL | |         .replace('u', "l")
 LL | |         .replace('p', "l")
 LL | |         .replace('d', "l");
-   | |__________________________^ help: replace with: `replace(|c| matches!(c, 'd' | 'p' | 'u' | 's'), "l")`
+   | |__________________________^ help: replace with: `replace(['s', 'u', 'p', 'd'], "l")`
 
 error: used consecutive `str::replace` call
-  --> $DIR/collapsible_str_replace.rs:33:24
+  --> $DIR/collapsible_str_replace.rs:31:27
    |
-LL |     let _ = misspelled.replace(s, "l").replace('u', "l");
-   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `replace(&['u' , s], "l")`
+LL |     let _ = "hesuo world".replace(s, "l").replace('u', "l");
+   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `replace([s, 'u'], "l")`
 
 error: used consecutive `str::replace` call
-  --> $DIR/collapsible_str_replace.rs:35:24
+  --> $DIR/collapsible_str_replace.rs:33:27
    |
-LL |     let _ = misspelled.replace(s, "l").replace('u', "l").replace('p', "l");
-   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `replace(&['p' , 'u' , s], "l")`
+LL |     let _ = "hesuo worpd".replace(s, "l").replace('u', "l").replace('p', "l");
+   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `replace([s, 'u', 'p'], "l")`
 
 error: used consecutive `str::replace` call
-  --> $DIR/collapsible_str_replace.rs:37:24
+  --> $DIR/collapsible_str_replace.rs:35:27
    |
-LL |     let _ = misspelled.replace(s, "l").replace(u, "l").replace('p', "l");
-   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `replace(&['p' , u , s], "l")`
+LL |     let _ = "hesuo worpd".replace(s, "l").replace(u, "l").replace('p', "l");
+   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `replace([s, u, 'p'], "l")`
 
 error: used consecutive `str::replace` call
-  --> $DIR/collapsible_str_replace.rs:39:24
+  --> $DIR/collapsible_str_replace.rs:37:27
    |
-LL |     let _ = misspelled.replace(s, "l").replace(u, "l").replace(p, "l");
-   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `replace(&[p , u , s], "l")`
+LL |     let _ = "hesuo worpd".replace(s, "l").replace(u, "l").replace(p, "l");
+   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `replace([s, u, p], "l")`
 
-error: aborting due to 8 previous errors
+error: used consecutive `str::replace` call
+  --> $DIR/collapsible_str_replace.rs:39:27
+   |
+LL |     let _ = "hesuo worlp".replace('s', "l").replace('u', "l").replace('p', "d");
+   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `replace(['s', 'u'], "l")`
+
+error: used consecutive `str::replace` call
+  --> $DIR/collapsible_str_replace.rs:41:45
+   |
+LL |     let _ = "hesuo worpd".replace('s', "x").replace('u', "l").replace('p', "l");
+   |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `replace(['u', 'p'], "l")`
+
+error: used consecutive `str::replace` call
+  --> $DIR/collapsible_str_replace.rs:44:47
+   |
+LL |     let _ = "hesudo worpd".replace("su", "l").replace('d', "l").replace('p', "l");
+   |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `replace(['d', 'p'], "l")`
+
+error: used consecutive `str::replace` call
+  --> $DIR/collapsible_str_replace.rs:46:28
+   |
+LL |     let _ = "hesudo worpd".replace(d, "l").replace('p', "l").replace("su", "l");
+   |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `replace([d, 'p'], "l")`
+
+error: used consecutive `str::replace` call
+  --> $DIR/collapsible_str_replace.rs:48:27
+   |
+LL |     let _ = "hesuo world".replace(get_filter(), "l").replace('s', "l");
+   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `replace([get_filter(), 's'], "l")`
+
+error: aborting due to 13 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 5d403c0b859259499886d3ee3d4b4b4dfaab6ae2 Mon Sep 17 00:00:00 2001
From: J-ZhengLi <lizheng135@huawei.com>
Date: Sat, 16 Apr 2022 16:57:06 +0800
Subject: allow check for `match` in lint [`option_if_let_else`] and add test
 case for `Result`

---
 clippy_lints/src/option_if_let_else.rs | 170 ++++++++++++++++++++++++---------
 tests/ui/option_if_let_else.fixed      |  15 +++
 tests/ui/option_if_let_else.rs         |  21 ++++
 tests/ui/option_if_let_else.stderr     |  22 ++++-
 4 files changed, 183 insertions(+), 45 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/option_if_let_else.rs b/clippy_lints/src/option_if_let_else.rs
index 44f153cffac..b99966c5a5d 100644
--- a/clippy_lints/src/option_if_let_else.rs
+++ b/clippy_lints/src/option_if_let_else.rs
@@ -7,15 +7,18 @@ use clippy_utils::{
 };
 use if_chain::if_chain;
 use rustc_errors::Applicability;
-use rustc_hir::LangItem::OptionSome;
-use rustc_hir::{def::Res, BindingAnnotation, Expr, ExprKind, Mutability, PatKind, Path, QPath, UnOp};
+use rustc_hir::LangItem::{OptionNone, OptionSome};
+use rustc_hir::{
+    def::Res, Arm, BindingAnnotation, Expr, ExprKind, MatchSource, Mutability, Pat, PatKind, Path, QPath, UnOp,
+};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::sym;
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Lints usage of `if let Some(v) = ... { y } else { x }` which is more
+    /// Lints usage of `if let Some(v) = ... { y } else { x }` and
+    /// `match .. { Some(v) => y, None/_ => x }` which are more
     /// idiomatically done with `Option::map_or` (if the else bit is a pure
     /// expression) or `Option::map_or_else` (if the else bit is an impure
     /// expression).
@@ -39,6 +42,10 @@ declare_clippy_lint! {
     /// } else {
     ///     5
     /// };
+    /// let _ = match optional {
+    ///     Some(val) => val + 1,
+    ///     None => 5
+    /// };
     /// let _ = if let Some(foo) = optional {
     ///     foo
     /// } else {
@@ -53,6 +60,7 @@ declare_clippy_lint! {
     /// # let optional: Option<u32> = Some(0);
     /// # fn do_complicated_function() -> u32 { 5 };
     /// let _ = optional.map_or(5, |foo| foo);
+    /// let _ = optional.map_or(5, |val| val + 1);
     /// let _ = optional.map_or_else(||{
     ///     let y = do_complicated_function();
     ///     y*y
@@ -76,9 +84,21 @@ fn is_result_ok(cx: &LateContext<'_>, expr: &'_ Expr<'_>) -> bool {
     }
 }
 
-/// A struct containing information about occurrences of the
-/// `if let Some(..) = .. else` construct that this lint detects.
-struct OptionIfLetElseOccurrence {
+/// A struct containing information about occurrences of construct that this lint detects
+///
+/// Such as:
+///
+/// ```ignore
+/// if let Some(..) = {..} else {..}
+/// ```
+/// or
+/// ```ignore
+/// match x {
+///     Some(..) => {..},
+///     None/_ => {..}
+/// }
+/// ```
+struct OptionOccurence {
     option: String,
     method_sugg: String,
     some_expr: String,
@@ -99,43 +119,39 @@ fn format_option_in_sugg(cx: &LateContext<'_>, cond_expr: &Expr<'_>, as_ref: boo
     )
 }
 
-/// If this expression is the option if let/else construct we're detecting, then
-/// this function returns an `OptionIfLetElseOccurrence` struct with details if
-/// this construct is found, or None if this construct is not found.
-fn detect_option_if_let_else<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>) -> Option<OptionIfLetElseOccurrence> {
+fn try_get_option_occurence<'tcx>(
+    cx: &LateContext<'tcx>,
+    pat: &Pat<'tcx>,
+    expr: &Expr<'_>,
+    if_then: &'tcx Expr<'_>,
+    if_else: &'tcx Expr<'_>,
+) -> Option<OptionOccurence> {
+    let cond_expr = match expr.kind {
+        ExprKind::Unary(UnOp::Deref, inner_expr) | ExprKind::AddrOf(_, _, inner_expr) => inner_expr,
+        _ => expr,
+    };
     if_chain! {
-        if !expr.span.from_expansion(); // Don't lint macros, because it behaves weirdly
-        if !in_constant(cx, expr.hir_id);
-        if let Some(higher::IfLet { let_pat, let_expr, if_then, if_else: Some(if_else) })
-            = higher::IfLet::hir(cx, expr);
-        if !is_else_clause(cx.tcx, expr);
-        if !is_result_ok(cx, let_expr); // Don't lint on Result::ok because a different lint does it already
-        if let PatKind::TupleStruct(struct_qpath, [inner_pat], _) = &let_pat.kind;
-        if is_lang_ctor(cx, struct_qpath, OptionSome);
-        if let PatKind::Binding(bind_annotation, _, id, None) = &inner_pat.kind;
+        if !is_result_ok(cx, cond_expr); // Don't lint on Result::ok because a different lint does it already
+        let inner_pat = try_get_inner_pat(cx, pat)?;
+        if let PatKind::Binding(bind_annotation, _, id, None) = inner_pat.kind;
         if let Some(some_captures) = can_move_expr_to_closure(cx, if_then);
         if let Some(none_captures) = can_move_expr_to_closure(cx, if_else);
         if some_captures
             .iter()
             .filter_map(|(id, &c)| none_captures.get(id).map(|&c2| (c, c2)))
             .all(|(x, y)| x.is_imm_ref() && y.is_imm_ref());
-
         then {
-            let capture_mut = if bind_annotation == &BindingAnnotation::Mutable { "mut " } else { "" };
+            let capture_mut = if bind_annotation == BindingAnnotation::Mutable { "mut " } else { "" };
             let some_body = peel_blocks(if_then);
             let none_body = peel_blocks(if_else);
             let method_sugg = if eager_or_lazy::switch_to_eager_eval(cx, none_body) { "map_or" } else { "map_or_else" };
             let capture_name = id.name.to_ident_string();
-            let (as_ref, as_mut) = match &let_expr.kind {
+            let (as_ref, as_mut) = match &expr.kind {
                 ExprKind::AddrOf(_, Mutability::Not, _) => (true, false),
                 ExprKind::AddrOf(_, Mutability::Mut, _) => (false, true),
-                _ => (bind_annotation == &BindingAnnotation::Ref, bind_annotation == &BindingAnnotation::RefMut),
-            };
-            let cond_expr = match let_expr.kind {
-                // Pointer dereferencing happens automatically, so we can omit it in the suggestion
-                ExprKind::Unary(UnOp::Deref, expr) | ExprKind::AddrOf(_, _, expr) => expr,
-                _ => let_expr,
+                _ => (bind_annotation == BindingAnnotation::Ref, bind_annotation == BindingAnnotation::RefMut),
             };
+
             // Check if captures the closure will need conflict with borrows made in the scrutinee.
             // TODO: check all the references made in the scrutinee expression. This will require interacting
             // with the borrow checker. Currently only `<local>[.<field>]*` is checked for.
@@ -154,33 +170,99 @@ fn detect_option_if_let_else<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>) ->
                     }
                 }
             }
-            Some(OptionIfLetElseOccurrence {
+
+            return Some(OptionOccurence {
                 option: format_option_in_sugg(cx, cond_expr, as_ref, as_mut),
                 method_sugg: method_sugg.to_string(),
                 some_expr: format!("|{}{}| {}", capture_mut, capture_name, Sugg::hir_with_macro_callsite(cx, some_body, "..")),
                 none_expr: format!("{}{}", if method_sugg == "map_or" { "" } else { "|| " }, Sugg::hir_with_macro_callsite(cx, none_body, "..")),
-            })
+            });
+        }
+    }
+
+    None
+}
+
+fn try_get_inner_pat<'tcx>(cx: &LateContext<'tcx>, pat: &Pat<'tcx>) -> Option<&'tcx Pat<'tcx>> {
+    if let PatKind::TupleStruct(ref qpath, [inner_pat], ..) = pat.kind {
+        if is_lang_ctor(cx, qpath, OptionSome) {
+            return Some(inner_pat);
+        }
+    }
+    None
+}
+
+/// If this expression is the option if let/else construct we're detecting, then
+/// this function returns an `OptionOccurence` struct with details if
+/// this construct is found, or None if this construct is not found.
+fn detect_option_if_let_else<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>) -> Option<OptionOccurence> {
+    if let Some(higher::IfLet {
+        let_pat,
+        let_expr,
+        if_then,
+        if_else: Some(if_else),
+    }) = higher::IfLet::hir(cx, expr)
+    {
+        if !is_else_clause(cx.tcx, expr) {
+            return try_get_option_occurence(cx, let_pat, let_expr, if_then, if_else);
+        }
+    }
+    None
+}
+
+fn detect_option_match<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>) -> Option<OptionOccurence> {
+    if let ExprKind::Match(ex, arms, MatchSource::Normal) = expr.kind {
+        if let Some((let_pat, if_then, if_else)) = try_convert_match(cx, arms) {
+            return try_get_option_occurence(cx, let_pat, ex, if_then, if_else);
+        }
+    }
+    None
+}
+
+fn try_convert_match<'tcx>(
+    cx: &LateContext<'tcx>,
+    arms: &[Arm<'tcx>],
+) -> Option<(&'tcx Pat<'tcx>, &'tcx Expr<'tcx>, &'tcx Expr<'tcx>)> {
+    if arms.len() == 2 {
+        return if is_none_arm(cx, &arms[1]) {
+            Some((arms[0].pat, arms[0].body, arms[1].body))
+        } else if is_none_arm(cx, &arms[0]) {
+            Some((arms[1].pat, arms[1].body, arms[0].body))
         } else {
             None
-        }
+        };
+    }
+    None
+}
+
+fn is_none_arm(cx: &LateContext<'_>, arm: &Arm<'_>) -> bool {
+    match arm.pat.kind {
+        PatKind::Path(ref qpath) => is_lang_ctor(cx, qpath, OptionNone),
+        PatKind::Wild => true,
+        _ => false,
     }
 }
 
 impl<'tcx> LateLintPass<'tcx> for OptionIfLetElse {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &Expr<'tcx>) {
-        if let Some(detection) = detect_option_if_let_else(cx, expr) {
-            span_lint_and_sugg(
-                cx,
-                OPTION_IF_LET_ELSE,
-                expr.span,
-                format!("use Option::{} instead of an if let/else", detection.method_sugg).as_str(),
-                "try",
-                format!(
-                    "{}.{}({}, {})",
-                    detection.option, detection.method_sugg, detection.none_expr, detection.some_expr,
-                ),
-                Applicability::MaybeIncorrect,
-            );
+        // Don't lint macros, because it behaves weirdly
+        // and don't lint constant as well
+        if !expr.span.from_expansion() && !in_constant(cx, expr.hir_id) {
+            let detection = detect_option_if_let_else(cx, expr).or_else(|| detect_option_match(cx, expr));
+            if let Some(det) = detection {
+                span_lint_and_sugg(
+                    cx,
+                    OPTION_IF_LET_ELSE,
+                    expr.span,
+                    format!("use Option::{} instead of an if let/else", det.method_sugg).as_str(),
+                    "try",
+                    format!(
+                        "{}.{}({}, {})",
+                        det.option, det.method_sugg, det.none_expr, det.some_expr
+                    ),
+                    Applicability::MaybeIncorrect,
+                );
+            }
         }
     }
 }
diff --git a/tests/ui/option_if_let_else.fixed b/tests/ui/option_if_let_else.fixed
index b6d5e106f05..79610a0ea34 100644
--- a/tests/ui/option_if_let_else.fixed
+++ b/tests/ui/option_if_let_else.fixed
@@ -179,4 +179,19 @@ fn main() {
 
     let _ = pattern_to_vec("hello world");
     let _ = complex_subpat();
+
+    // issue #8492
+    let _ = s.map_or(1, |string| string.len());
+    let _ = Some(10).map_or(5, |a| a + 1);
+
+    let res: Result<i32, i32> = Ok(5);
+    let _ = match res {
+        Ok(a) => a + 1,
+        _ => 1,
+    };
+    let _ = match res {
+        Err(_) => 1,
+        Ok(a) => a + 1,
+    };
+    let _ = if let Ok(a) = res { a + 1 } else { 5 };
 }
diff --git a/tests/ui/option_if_let_else.rs b/tests/ui/option_if_let_else.rs
index 35bae159343..9eeaea12d3b 100644
--- a/tests/ui/option_if_let_else.rs
+++ b/tests/ui/option_if_let_else.rs
@@ -208,4 +208,25 @@ fn main() {
 
     let _ = pattern_to_vec("hello world");
     let _ = complex_subpat();
+
+    // issue #8492
+    let _ = match s {
+        Some(string) => string.len(),
+        None => 1,
+    };
+    let _ = match Some(10) {
+        Some(a) => a + 1,
+        None => 5,
+    };
+
+    let res: Result<i32, i32> = Ok(5);
+    let _ = match res {
+        Ok(a) => a + 1,
+        _ => 1,
+    };
+    let _ = match res {
+        Err(_) => 1,
+        Ok(a) => a + 1,
+    };
+    let _ = if let Ok(a) = res { a + 1 } else { 5 };
 }
diff --git a/tests/ui/option_if_let_else.stderr b/tests/ui/option_if_let_else.stderr
index daba606004e..4086b45b7c0 100644
--- a/tests/ui/option_if_let_else.stderr
+++ b/tests/ui/option_if_let_else.stderr
@@ -206,5 +206,25 @@ LL +         s.len() + x
 LL ~     });
    |
 
-error: aborting due to 15 previous errors
+error: use Option::map_or instead of an if let/else
+  --> $DIR/option_if_let_else.rs:212:13
+   |
+LL |       let _ = match s {
+   |  _____________^
+LL | |         Some(string) => string.len(),
+LL | |         None => 1,
+LL | |     };
+   | |_____^ help: try: `s.map_or(1, |string| string.len())`
+
+error: use Option::map_or instead of an if let/else
+  --> $DIR/option_if_let_else.rs:216:13
+   |
+LL |       let _ = match Some(10) {
+   |  _____________^
+LL | |         Some(a) => a + 1,
+LL | |         None => 5,
+LL | |     };
+   | |_____^ help: try: `Some(10).map_or(5, |a| a + 1)`
+
+error: aborting due to 17 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From ffe71251638d8f1c19de61905ff56a423132a692 Mon Sep 17 00:00:00 2001
From: J-ZhengLi <lizheng135@huawei.com>
Date: Sat, 16 Apr 2022 17:40:28 +0800
Subject: and check for `Result`

---
 clippy_lints/src/option_if_let_else.rs | 28 +++++++++-------------------
 tests/ui/option_if_let_else.fixed      | 12 +++---------
 tests/ui/option_if_let_else.stderr     | 28 +++++++++++++++++++++++++++-
 3 files changed, 39 insertions(+), 29 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/option_if_let_else.rs b/clippy_lints/src/option_if_let_else.rs
index b99966c5a5d..93388e78591 100644
--- a/clippy_lints/src/option_if_let_else.rs
+++ b/clippy_lints/src/option_if_let_else.rs
@@ -1,19 +1,17 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::sugg::Sugg;
-use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::{
     can_move_expr_to_closure, eager_or_lazy, higher, in_constant, is_else_clause, is_lang_ctor, peel_blocks,
     peel_hir_expr_while, CaptureKind,
 };
 use if_chain::if_chain;
 use rustc_errors::Applicability;
-use rustc_hir::LangItem::{OptionNone, OptionSome};
+use rustc_hir::LangItem::{OptionNone, OptionSome, ResultErr, ResultOk};
 use rustc_hir::{
     def::Res, Arm, BindingAnnotation, Expr, ExprKind, MatchSource, Mutability, Pat, PatKind, Path, QPath, UnOp,
 };
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::sym;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -74,16 +72,6 @@ declare_clippy_lint! {
 
 declare_lint_pass!(OptionIfLetElse => [OPTION_IF_LET_ELSE]);
 
-/// Returns true iff the given expression is the result of calling `Result::ok`
-fn is_result_ok(cx: &LateContext<'_>, expr: &'_ Expr<'_>) -> bool {
-    if let ExprKind::MethodCall(path, &[ref receiver], _) = &expr.kind {
-        path.ident.name.as_str() == "ok"
-            && is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(receiver), sym::Result)
-    } else {
-        false
-    }
-}
-
 /// A struct containing information about occurrences of construct that this lint detects
 ///
 /// Such as:
@@ -130,9 +118,8 @@ fn try_get_option_occurence<'tcx>(
         ExprKind::Unary(UnOp::Deref, inner_expr) | ExprKind::AddrOf(_, _, inner_expr) => inner_expr,
         _ => expr,
     };
+    let inner_pat = try_get_inner_pat(cx, pat)?;
     if_chain! {
-        if !is_result_ok(cx, cond_expr); // Don't lint on Result::ok because a different lint does it already
-        let inner_pat = try_get_inner_pat(cx, pat)?;
         if let PatKind::Binding(bind_annotation, _, id, None) = inner_pat.kind;
         if let Some(some_captures) = can_move_expr_to_closure(cx, if_then);
         if let Some(none_captures) = can_move_expr_to_closure(cx, if_else);
@@ -185,7 +172,7 @@ fn try_get_option_occurence<'tcx>(
 
 fn try_get_inner_pat<'tcx>(cx: &LateContext<'tcx>, pat: &Pat<'tcx>) -> Option<&'tcx Pat<'tcx>> {
     if let PatKind::TupleStruct(ref qpath, [inner_pat], ..) = pat.kind {
-        if is_lang_ctor(cx, qpath, OptionSome) {
+        if is_lang_ctor(cx, qpath, OptionSome) || is_lang_ctor(cx, qpath, ResultOk) {
             return Some(inner_pat);
         }
     }
@@ -224,9 +211,9 @@ fn try_convert_match<'tcx>(
     arms: &[Arm<'tcx>],
 ) -> Option<(&'tcx Pat<'tcx>, &'tcx Expr<'tcx>, &'tcx Expr<'tcx>)> {
     if arms.len() == 2 {
-        return if is_none_arm(cx, &arms[1]) {
+        return if is_none_or_err_arm(cx, &arms[1]) {
             Some((arms[0].pat, arms[0].body, arms[1].body))
-        } else if is_none_arm(cx, &arms[0]) {
+        } else if is_none_or_err_arm(cx, &arms[0]) {
             Some((arms[1].pat, arms[1].body, arms[0].body))
         } else {
             None
@@ -235,9 +222,12 @@ fn try_convert_match<'tcx>(
     None
 }
 
-fn is_none_arm(cx: &LateContext<'_>, arm: &Arm<'_>) -> bool {
+fn is_none_or_err_arm(cx: &LateContext<'_>, arm: &Arm<'_>) -> bool {
     match arm.pat.kind {
         PatKind::Path(ref qpath) => is_lang_ctor(cx, qpath, OptionNone),
+        PatKind::TupleStruct(ref qpath, [first_pat], _) => {
+            is_lang_ctor(cx, qpath, ResultErr) && matches!(first_pat.kind, PatKind::Wild)
+        },
         PatKind::Wild => true,
         _ => false,
     }
diff --git a/tests/ui/option_if_let_else.fixed b/tests/ui/option_if_let_else.fixed
index 79610a0ea34..f15ac551bb3 100644
--- a/tests/ui/option_if_let_else.fixed
+++ b/tests/ui/option_if_let_else.fixed
@@ -185,13 +185,7 @@ fn main() {
     let _ = Some(10).map_or(5, |a| a + 1);
 
     let res: Result<i32, i32> = Ok(5);
-    let _ = match res {
-        Ok(a) => a + 1,
-        _ => 1,
-    };
-    let _ = match res {
-        Err(_) => 1,
-        Ok(a) => a + 1,
-    };
-    let _ = if let Ok(a) = res { a + 1 } else { 5 };
+    let _ = res.map_or(1, |a| a + 1);
+    let _ = res.map_or(1, |a| a + 1);
+    let _ = res.map_or(5, |a| a + 1);
 }
diff --git a/tests/ui/option_if_let_else.stderr b/tests/ui/option_if_let_else.stderr
index 4086b45b7c0..1bf513e0872 100644
--- a/tests/ui/option_if_let_else.stderr
+++ b/tests/ui/option_if_let_else.stderr
@@ -226,5 +226,31 @@ LL | |         None => 5,
 LL | |     };
    | |_____^ help: try: `Some(10).map_or(5, |a| a + 1)`
 
-error: aborting due to 17 previous errors
+error: use Option::map_or instead of an if let/else
+  --> $DIR/option_if_let_else.rs:222:13
+   |
+LL |       let _ = match res {
+   |  _____________^
+LL | |         Ok(a) => a + 1,
+LL | |         _ => 1,
+LL | |     };
+   | |_____^ help: try: `res.map_or(1, |a| a + 1)`
+
+error: use Option::map_or instead of an if let/else
+  --> $DIR/option_if_let_else.rs:226:13
+   |
+LL |       let _ = match res {
+   |  _____________^
+LL | |         Err(_) => 1,
+LL | |         Ok(a) => a + 1,
+LL | |     };
+   | |_____^ help: try: `res.map_or(1, |a| a + 1)`
+
+error: use Option::map_or instead of an if let/else
+  --> $DIR/option_if_let_else.rs:230:13
+   |
+LL |     let _ = if let Ok(a) = res { a + 1 } else { 5 };
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `res.map_or(5, |a| a + 1)`
+
+error: aborting due to 20 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 1f75845a8f3318fba32aeb2f443f37aabdcc86f0 Mon Sep 17 00:00:00 2001
From: Philipp Krones <hello@philkrones.com>
Date: Sun, 21 Aug 2022 10:29:07 +0200
Subject: Reduce indentation and add comment about lint name

---
 clippy_lints/src/option_if_let_else.rs | 39 ++++++++++++++++++----------------
 tests/ui/option_if_let_else.stderr     | 10 ++++-----
 2 files changed, 26 insertions(+), 23 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/option_if_let_else.rs b/clippy_lints/src/option_if_let_else.rs
index 93388e78591..9602d0d1d2e 100644
--- a/clippy_lints/src/option_if_let_else.rs
+++ b/clippy_lints/src/option_if_let_else.rs
@@ -64,6 +64,8 @@ declare_clippy_lint! {
     ///     y*y
     /// }, |foo| foo);
     /// ```
+    // FIXME: Before moving this lint out of nursery, the lint name needs to be updated. It now also
+    // covers matches and `Result`.
     #[clippy::version = "1.47.0"]
     pub OPTION_IF_LET_ELSE,
     nursery,
@@ -235,24 +237,25 @@ fn is_none_or_err_arm(cx: &LateContext<'_>, arm: &Arm<'_>) -> bool {
 
 impl<'tcx> LateLintPass<'tcx> for OptionIfLetElse {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &Expr<'tcx>) {
-        // Don't lint macros, because it behaves weirdly
-        // and don't lint constant as well
-        if !expr.span.from_expansion() && !in_constant(cx, expr.hir_id) {
-            let detection = detect_option_if_let_else(cx, expr).or_else(|| detect_option_match(cx, expr));
-            if let Some(det) = detection {
-                span_lint_and_sugg(
-                    cx,
-                    OPTION_IF_LET_ELSE,
-                    expr.span,
-                    format!("use Option::{} instead of an if let/else", det.method_sugg).as_str(),
-                    "try",
-                    format!(
-                        "{}.{}({}, {})",
-                        det.option, det.method_sugg, det.none_expr, det.some_expr
-                    ),
-                    Applicability::MaybeIncorrect,
-                );
-            }
+        // Don't lint macros and constants
+        if expr.span.from_expansion() || in_constant(cx, expr.hir_id) {
+            return;
+        }
+
+        let detection = detect_option_if_let_else(cx, expr).or_else(|| detect_option_match(cx, expr));
+        if let Some(det) = detection {
+            span_lint_and_sugg(
+                cx,
+                OPTION_IF_LET_ELSE,
+                expr.span,
+                format!("use Option::{} instead of an if let/else", det.method_sugg).as_str(),
+                "try",
+                format!(
+                    "{}.{}({}, {})",
+                    det.option, det.method_sugg, det.none_expr, det.some_expr
+                ),
+                Applicability::MaybeIncorrect,
+            );
         }
     }
 }
diff --git a/tests/ui/option_if_let_else.stderr b/tests/ui/option_if_let_else.stderr
index 1bf513e0872..a5dbf6e1f22 100644
--- a/tests/ui/option_if_let_else.stderr
+++ b/tests/ui/option_if_let_else.stderr
@@ -207,7 +207,7 @@ LL ~     });
    |
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:212:13
+  --> $DIR/option_if_let_else.rs:213:13
    |
 LL |       let _ = match s {
    |  _____________^
@@ -217,7 +217,7 @@ LL | |     };
    | |_____^ help: try: `s.map_or(1, |string| string.len())`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:216:13
+  --> $DIR/option_if_let_else.rs:217:13
    |
 LL |       let _ = match Some(10) {
    |  _____________^
@@ -227,7 +227,7 @@ LL | |     };
    | |_____^ help: try: `Some(10).map_or(5, |a| a + 1)`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:222:13
+  --> $DIR/option_if_let_else.rs:223:13
    |
 LL |       let _ = match res {
    |  _____________^
@@ -237,7 +237,7 @@ LL | |     };
    | |_____^ help: try: `res.map_or(1, |a| a + 1)`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:226:13
+  --> $DIR/option_if_let_else.rs:227:13
    |
 LL |       let _ = match res {
    |  _____________^
@@ -247,7 +247,7 @@ LL | |     };
    | |_____^ help: try: `res.map_or(1, |a| a + 1)`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:230:13
+  --> $DIR/option_if_let_else.rs:231:13
    |
 LL |     let _ = if let Ok(a) = res { a + 1 } else { 5 };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `res.map_or(5, |a| a + 1)`
-- 
cgit 1.4.1-3-g733a5


From 5048af7a3a0c91e0fc5964c4bf6b373898b320aa Mon Sep 17 00:00:00 2001
From: kyoto7250 <50972773+kyoto7250@users.noreply.github.com>
Date: Mon, 13 Jun 2022 23:27:26 +0900
Subject: feat(fix): Do not lint if the target code is inside a loop

---
 clippy_lints/src/loops/needless_collect.rs |  33 ++++-
 tests/ui/needless_collect_indirect.rs      | 189 +++++++++++++++++++++++++++++
 tests/ui/needless_collect_indirect.stderr  | 119 +++++++++++++++++-
 3 files changed, 339 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/needless_collect.rs b/clippy_lints/src/loops/needless_collect.rs
index ddaffc75188..cc4827c56b6 100644
--- a/clippy_lints/src/loops/needless_collect.rs
+++ b/clippy_lints/src/loops/needless_collect.rs
@@ -1,5 +1,6 @@
 use super::NEEDLESS_COLLECT;
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_hir_and_then};
+use clippy_utils::higher;
 use clippy_utils::source::{snippet, snippet_with_applicability};
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::is_type_diagnostic_item;
@@ -184,10 +185,23 @@ struct IterFunctionVisitor<'a, 'tcx> {
 impl<'tcx> Visitor<'tcx> for IterFunctionVisitor<'_, 'tcx> {
     fn visit_block(&mut self, block: &'tcx Block<'tcx>) {
         for (expr, hir_id) in block.stmts.iter().filter_map(get_expr_and_hir_id_from_stmt) {
+            if is_loop(expr) {
+                continue;
+            }
             self.visit_block_expr(expr, hir_id);
         }
         if let Some(expr) = block.expr {
-            self.visit_block_expr(expr, None);
+            if is_loop(expr) {
+                if let Some(higher::WhileLet { let_expr, .. }) = higher::WhileLet::hir(expr) {
+                    self.visit_block_expr(let_expr, None);
+                } else if let Some(higher::While { condition, .. }) = higher::While::hir(expr) {
+                    self.visit_block_expr(condition, None);
+                } else if let Some(higher::ForLoop { arg, .. }) = higher::ForLoop::hir(expr) {
+                    self.visit_block_expr(arg, None);
+                }
+            } else {
+                self.visit_block_expr(expr, None);
+            }
         }
     }
 
@@ -264,6 +278,23 @@ impl<'tcx> Visitor<'tcx> for IterFunctionVisitor<'_, 'tcx> {
     }
 }
 
+fn is_loop(expr: &Expr<'_>) -> bool {
+    if let Some(higher::WhileLet { .. }) = higher::WhileLet::hir(expr) {
+        return true;
+    }
+    if let Some(higher::While { .. }) = higher::While::hir(expr) {
+        return true;
+    }
+    if let Some(higher::ForLoop { .. }) = higher::ForLoop::hir(expr) {
+        return true;
+    }
+    if let ExprKind::Loop { .. } = expr.kind {
+        return true;
+    }
+
+    false
+}
+
 impl<'tcx> IterFunctionVisitor<'_, 'tcx> {
     fn visit_block_expr(&mut self, expr: &'tcx Expr<'tcx>, hir_id: Option<HirId>) {
         self.current_statement_hir_id = hir_id;
diff --git a/tests/ui/needless_collect_indirect.rs b/tests/ui/needless_collect_indirect.rs
index 1f11d1f8d56..12a9ace1ee6 100644
--- a/tests/ui/needless_collect_indirect.rs
+++ b/tests/ui/needless_collect_indirect.rs
@@ -112,3 +112,192 @@ fn allow_test() {
     let v = [1].iter().collect::<Vec<_>>();
     v.into_iter().collect::<HashSet<_>>();
 }
+
+mod issue_8553 {
+    fn test_for() {
+        let vec = vec![1, 2];
+        let w: Vec<usize> = vec.iter().map(|i| i * i).collect();
+
+        for i in 0..2 {
+            // Do not lint, because this method call is in the loop
+            w.contains(&i);
+        }
+
+        for i in 0..2 {
+            let y: Vec<usize> = vec.iter().map(|k| k * k).collect();
+            let z: Vec<usize> = vec.iter().map(|k| k * k).collect();
+            // Do lint
+            y.contains(&i);
+            for j in 0..2 {
+                // Do not lint, because this method call is in the loop
+                z.contains(&j);
+            }
+        }
+
+        // Do not lint, because this variable is used.
+        w.contains(&0);
+    }
+
+    fn test_while() {
+        let vec = vec![1, 2];
+        let x: Vec<usize> = vec.iter().map(|i| i * i).collect();
+        let mut n = 0;
+        while n > 1 {
+            // Do not lint, because this method call is in the loop
+            x.contains(&n);
+            n += 1;
+        }
+
+        while n > 2 {
+            let y: Vec<usize> = vec.iter().map(|k| k * k).collect();
+            let z: Vec<usize> = vec.iter().map(|k| k * k).collect();
+            // Do lint
+            y.contains(&n);
+            n += 1;
+            while n > 4 {
+                // Do not lint, because this method call is in the loop
+                z.contains(&n);
+                n += 1;
+            }
+        }
+    }
+
+    fn test_loop() {
+        let vec = vec![1, 2];
+        let x: Vec<usize> = vec.iter().map(|i| i * i).collect();
+        let mut n = 0;
+        loop {
+            if n < 1 {
+                // Do not lint, because this method call is in the loop
+                x.contains(&n);
+                n += 1;
+            } else {
+                break;
+            }
+        }
+
+        loop {
+            if n < 2 {
+                let y: Vec<usize> = vec.iter().map(|k| k * k).collect();
+                let z: Vec<usize> = vec.iter().map(|k| k * k).collect();
+                // Do lint
+                y.contains(&n);
+                n += 1;
+                loop {
+                    if n < 4 {
+                        // Do not lint, because this method call is in the loop
+                        z.contains(&n);
+                        n += 1;
+                    } else {
+                        break;
+                    }
+                }
+            } else {
+                break;
+            }
+        }
+    }
+
+    fn test_while_let() {
+        let vec = vec![1, 2];
+        let x: Vec<usize> = vec.iter().map(|i| i * i).collect();
+        let optional = Some(0);
+        let mut n = 0;
+        while let Some(value) = optional {
+            if n < 1 {
+                // Do not lint, because this method call is in the loop
+                x.contains(&n);
+                n += 1;
+            } else {
+                break;
+            }
+        }
+
+        while let Some(value) = optional {
+            let y: Vec<usize> = vec.iter().map(|k| k * k).collect();
+            let z: Vec<usize> = vec.iter().map(|k| k * k).collect();
+            if n < 2 {
+                // Do lint
+                y.contains(&n);
+                n += 1;
+            } else {
+                break;
+            }
+
+            while let Some(value) = optional {
+                if n < 4 {
+                    // Do not lint, because this method call is in the loop
+                    z.contains(&n);
+                    n += 1;
+                } else {
+                    break;
+                }
+            }
+        }
+    }
+
+    fn test_if_cond() {
+        let vec = vec![1, 2];
+        let v: Vec<usize> = vec.iter().map(|i| i * i).collect();
+        let w = v.iter().collect::<Vec<_>>();
+        // Do lint
+        for _ in 0..w.len() {
+            todo!();
+        }
+    }
+
+    fn test_if_cond_false_case() {
+        let vec = vec![1, 2];
+        let v: Vec<usize> = vec.iter().map(|i| i * i).collect();
+        let w = v.iter().collect::<Vec<_>>();
+        // Do not lint, because w is used.
+        for _ in 0..w.len() {
+            todo!();
+        }
+
+        w.len();
+    }
+
+    fn test_while_cond() {
+        let mut vec = vec![1, 2];
+        let mut v: Vec<usize> = vec.iter().map(|i| i * i).collect();
+        let mut w = v.iter().collect::<Vec<_>>();
+        // Do lint
+        while 1 == w.len() {
+            todo!();
+        }
+    }
+
+    fn test_while_cond_false_case() {
+        let mut vec = vec![1, 2];
+        let mut v: Vec<usize> = vec.iter().map(|i| i * i).collect();
+        let mut w = v.iter().collect::<Vec<_>>();
+        // Do not lint, because w is used.
+        while 1 == w.len() {
+            todo!();
+        }
+
+        w.len();
+    }
+
+    fn test_while_let_cond() {
+        let mut vec = vec![1, 2];
+        let mut v: Vec<usize> = vec.iter().map(|i| i * i).collect();
+        let mut w = v.iter().collect::<Vec<_>>();
+        // Do lint
+        while let Some(i) = Some(w.len()) {
+            todo!();
+        }
+    }
+
+    fn test_while_let_cond_false_case() {
+        let mut vec = vec![1, 2];
+        let mut v: Vec<usize> = vec.iter().map(|i| i * i).collect();
+        let mut w = v.iter().collect::<Vec<_>>();
+        // Do not lint, because w is used.
+        while let Some(i) = Some(w.len()) {
+            todo!();
+        }
+        w.len();
+    }
+}
diff --git a/tests/ui/needless_collect_indirect.stderr b/tests/ui/needless_collect_indirect.stderr
index 0f5e78f9119..9f0880cc606 100644
--- a/tests/ui/needless_collect_indirect.stderr
+++ b/tests/ui/needless_collect_indirect.stderr
@@ -125,5 +125,122 @@ LL ~
 LL ~         sample.iter().count()
    |
 
-error: aborting due to 9 previous errors
+error: avoid using `collect()` when not needed
+  --> $DIR/needless_collect_indirect.rs:127:59
+   |
+LL |             let y: Vec<usize> = vec.iter().map(|k| k * k).collect();
+   |                                                           ^^^^^^^
+...
+LL |             y.contains(&i);
+   |             -------------- the iterator could be used here instead
+   |
+help: check if the original Iterator contains an element instead of collecting then checking
+   |
+LL ~             
+LL |             let z: Vec<usize> = vec.iter().map(|k| k * k).collect();
+LL |             // Do lint
+LL ~             vec.iter().map(|k| k * k).any(|x| x == i);
+   |
+
+error: avoid using `collect()` when not needed
+  --> $DIR/needless_collect_indirect.rs:152:59
+   |
+LL |             let y: Vec<usize> = vec.iter().map(|k| k * k).collect();
+   |                                                           ^^^^^^^
+...
+LL |             y.contains(&n);
+   |             -------------- the iterator could be used here instead
+   |
+help: check if the original Iterator contains an element instead of collecting then checking
+   |
+LL ~             
+LL |             let z: Vec<usize> = vec.iter().map(|k| k * k).collect();
+LL |             // Do lint
+LL ~             vec.iter().map(|k| k * k).any(|x| x == n);
+   |
+
+error: avoid using `collect()` when not needed
+  --> $DIR/needless_collect_indirect.rs:181:63
+   |
+LL |                 let y: Vec<usize> = vec.iter().map(|k| k * k).collect();
+   |                                                               ^^^^^^^
+...
+LL |                 y.contains(&n);
+   |                 -------------- the iterator could be used here instead
+   |
+help: check if the original Iterator contains an element instead of collecting then checking
+   |
+LL ~                 
+LL |                 let z: Vec<usize> = vec.iter().map(|k| k * k).collect();
+LL |                 // Do lint
+LL ~                 vec.iter().map(|k| k * k).any(|x| x == n);
+   |
+
+error: avoid using `collect()` when not needed
+  --> $DIR/needless_collect_indirect.rs:217:59
+   |
+LL |             let y: Vec<usize> = vec.iter().map(|k| k * k).collect();
+   |                                                           ^^^^^^^
+...
+LL |                 y.contains(&n);
+   |                 -------------- the iterator could be used here instead
+   |
+help: check if the original Iterator contains an element instead of collecting then checking
+   |
+LL ~             
+LL |             let z: Vec<usize> = vec.iter().map(|k| k * k).collect();
+LL |             if n < 2 {
+LL |                 // Do lint
+LL ~                 vec.iter().map(|k| k * k).any(|x| x == n);
+   |
+
+error: avoid using `collect()` when not needed
+  --> $DIR/needless_collect_indirect.rs:242:26
+   |
+LL |         let w = v.iter().collect::<Vec<_>>();
+   |                          ^^^^^^^
+LL |         // Do lint
+LL |         for _ in 0..w.len() {
+   |                     ------- the iterator could be used here instead
+   |
+help: take the original Iterator's count instead of collecting it and finding the length
+   |
+LL ~         
+LL |         // Do lint
+LL ~         for _ in 0..v.iter().count() {
+   |
+
+error: avoid using `collect()` when not needed
+  --> $DIR/needless_collect_indirect.rs:264:30
+   |
+LL |         let mut w = v.iter().collect::<Vec<_>>();
+   |                              ^^^^^^^
+LL |         // Do lint
+LL |         while 1 == w.len() {
+   |                    ------- the iterator could be used here instead
+   |
+help: take the original Iterator's count instead of collecting it and finding the length
+   |
+LL ~         
+LL |         // Do lint
+LL ~         while 1 == v.iter().count() {
+   |
+
+error: avoid using `collect()` when not needed
+  --> $DIR/needless_collect_indirect.rs:286:30
+   |
+LL |         let mut w = v.iter().collect::<Vec<_>>();
+   |                              ^^^^^^^
+LL |         // Do lint
+LL |         while let Some(i) = Some(w.len()) {
+   |                                  ------- the iterator could be used here instead
+   |
+help: take the original Iterator's count instead of collecting it and finding the length
+   |
+LL ~         
+LL |         // Do lint
+LL ~         while let Some(i) = Some(v.iter().count()) {
+   |
+
+error: aborting due to 16 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 318ed0592077c8ab7dd957e201c7fe8607f1994f Mon Sep 17 00:00:00 2001
From: Philipp Krones <hello@philkrones.com>
Date: Sun, 21 Aug 2022 11:03:54 +0200
Subject: Reduce code duplication

Only check for the kind of loop once instead of re-desugaring it.
---
 clippy_lints/src/loops/needless_collect.rs | 35 +++++++++++++++---------------
 1 file changed, 18 insertions(+), 17 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/needless_collect.rs b/clippy_lints/src/loops/needless_collect.rs
index cc4827c56b6..6d987f393fa 100644
--- a/clippy_lints/src/loops/needless_collect.rs
+++ b/clippy_lints/src/loops/needless_collect.rs
@@ -185,19 +185,15 @@ struct IterFunctionVisitor<'a, 'tcx> {
 impl<'tcx> Visitor<'tcx> for IterFunctionVisitor<'_, 'tcx> {
     fn visit_block(&mut self, block: &'tcx Block<'tcx>) {
         for (expr, hir_id) in block.stmts.iter().filter_map(get_expr_and_hir_id_from_stmt) {
-            if is_loop(expr) {
+            if check_loop_kind(expr).is_some() {
                 continue;
             }
             self.visit_block_expr(expr, hir_id);
         }
         if let Some(expr) = block.expr {
-            if is_loop(expr) {
-                if let Some(higher::WhileLet { let_expr, .. }) = higher::WhileLet::hir(expr) {
-                    self.visit_block_expr(let_expr, None);
-                } else if let Some(higher::While { condition, .. }) = higher::While::hir(expr) {
-                    self.visit_block_expr(condition, None);
-                } else if let Some(higher::ForLoop { arg, .. }) = higher::ForLoop::hir(expr) {
-                    self.visit_block_expr(arg, None);
+            if let Some(loop_kind) = check_loop_kind(expr) {
+                if let LoopKind::Conditional(block_expr) = loop_kind {
+                    self.visit_block_expr(block_expr, None);
                 }
             } else {
                 self.visit_block_expr(expr, None);
@@ -278,21 +274,26 @@ impl<'tcx> Visitor<'tcx> for IterFunctionVisitor<'_, 'tcx> {
     }
 }
 
-fn is_loop(expr: &Expr<'_>) -> bool {
-    if let Some(higher::WhileLet { .. }) = higher::WhileLet::hir(expr) {
-        return true;
+enum LoopKind<'tcx> {
+    Conditional(&'tcx Expr<'tcx>),
+    Loop,
+}
+
+fn check_loop_kind<'tcx>(expr: &Expr<'tcx>) -> Option<LoopKind<'tcx>> {
+    if let Some(higher::WhileLet { let_expr, .. }) = higher::WhileLet::hir(expr) {
+        return Some(LoopKind::Conditional(let_expr));
     }
-    if let Some(higher::While { .. }) = higher::While::hir(expr) {
-        return true;
+    if let Some(higher::While { condition, .. }) = higher::While::hir(expr) {
+        return Some(LoopKind::Conditional(condition));
     }
-    if let Some(higher::ForLoop { .. }) = higher::ForLoop::hir(expr) {
-        return true;
+    if let Some(higher::ForLoop { arg, .. }) = higher::ForLoop::hir(expr) {
+        return Some(LoopKind::Conditional(arg));
     }
     if let ExprKind::Loop { .. } = expr.kind {
-        return true;
+        return Some(LoopKind::Loop);
     }
 
-    false
+    None
 }
 
 impl<'tcx> IterFunctionVisitor<'_, 'tcx> {
-- 
cgit 1.4.1-3-g733a5


From 687fcf14c4bd8b60640253800755123b2ba4b02a Mon Sep 17 00:00:00 2001
From: "Samuel E. Moelius III" <sam@moeli.us>
Date: Fri, 29 Jul 2022 05:34:49 -0400
Subject: Fix `to_string_in_format_args` false positive

---
 clippy_lints/src/format_args.rs | 67 +++++++++++++++++++++++++----------------
 tests/ui/format_args.fixed      | 14 +++++++++
 tests/ui/format_args.rs         | 14 +++++++++
 tests/ui/format_args.stderr     |  8 ++++-
 4 files changed, 76 insertions(+), 27 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/format_args.rs b/clippy_lints/src/format_args.rs
index 5347ff880ce..473c9a8675f 100644
--- a/clippy_lints/src/format_args.rs
+++ b/clippy_lints/src/format_args.rs
@@ -131,34 +131,49 @@ fn check_to_string_in_format_args(cx: &LateContext<'_>, name: Symbol, value: &Ex
         if is_diag_trait_item(cx, method_def_id, sym::ToString);
         let receiver_ty = cx.typeck_results().expr_ty(receiver);
         if let Some(display_trait_id) = cx.tcx.get_diagnostic_item(sym::Display);
+        let (n_needed_derefs, target) =
+            count_needed_derefs(receiver_ty, cx.typeck_results().expr_adjustments(receiver).iter());
+        if implements_trait(cx, target, display_trait_id, &[]);
+        if let Some(sized_trait_id) = cx.tcx.lang_items().sized_trait();
         if let Some(receiver_snippet) = snippet_opt(cx, receiver.span);
         then {
-            let (n_needed_derefs, target) = count_needed_derefs(
-                receiver_ty,
-                cx.typeck_results().expr_adjustments(receiver).iter(),
-            );
-            if implements_trait(cx, target, display_trait_id, &[]) {
-                if n_needed_derefs == 0 {
-                    span_lint_and_sugg(
-                        cx,
-                        TO_STRING_IN_FORMAT_ARGS,
-                        value.span.with_lo(receiver.span.hi()),
-                        &format!("`to_string` applied to a type that implements `Display` in `{}!` args", name),
-                        "remove this",
-                        String::new(),
-                        Applicability::MachineApplicable,
-                    );
-                } else {
-                    span_lint_and_sugg(
-                        cx,
-                        TO_STRING_IN_FORMAT_ARGS,
-                        value.span,
-                        &format!("`to_string` applied to a type that implements `Display` in `{}!` args", name),
-                        "use this",
-                        format!("{:*>width$}{}", "", receiver_snippet, width = n_needed_derefs),
-                        Applicability::MachineApplicable,
-                    );
-                }
+            let needed_ref = if implements_trait(cx, receiver_ty, sized_trait_id, &[]) {
+                ""
+            } else {
+                "&"
+            };
+            if n_needed_derefs == 0 && needed_ref.is_empty() {
+                span_lint_and_sugg(
+                    cx,
+                    TO_STRING_IN_FORMAT_ARGS,
+                    value.span.with_lo(receiver.span.hi()),
+                    &format!(
+                        "`to_string` applied to a type that implements `Display` in `{}!` args",
+                        name
+                    ),
+                    "remove this",
+                    String::new(),
+                    Applicability::MachineApplicable,
+                );
+            } else {
+                span_lint_and_sugg(
+                    cx,
+                    TO_STRING_IN_FORMAT_ARGS,
+                    value.span,
+                    &format!(
+                        "`to_string` applied to a type that implements `Display` in `{}!` args",
+                        name
+                    ),
+                    "use this",
+                    format!(
+                        "{}{:*>width$}{}",
+                        needed_ref,
+                        "",
+                        receiver_snippet,
+                        width = n_needed_derefs
+                    ),
+                    Applicability::MachineApplicable,
+                );
             }
         }
     }
diff --git a/tests/ui/format_args.fixed b/tests/ui/format_args.fixed
index e07cae70277..e1c2d4d70be 100644
--- a/tests/ui/format_args.fixed
+++ b/tests/ui/format_args.fixed
@@ -146,3 +146,17 @@ mod issue_8855 {
         dbg!(x);
     }
 }
+
+// https://github.com/rust-lang/rust-clippy/issues/9256
+mod issue_9256 {
+    #![allow(dead_code)]
+
+    fn print_substring(original: &str) {
+        assert!(original.len() > 10);
+        println!("{}", &original[..10]);
+    }
+
+    fn main() {
+        print_substring("Hello, world!");
+    }
+}
diff --git a/tests/ui/format_args.rs b/tests/ui/format_args.rs
index 86e66bce2c5..b9a4d66c28a 100644
--- a/tests/ui/format_args.rs
+++ b/tests/ui/format_args.rs
@@ -146,3 +146,17 @@ mod issue_8855 {
         dbg!(x);
     }
 }
+
+// https://github.com/rust-lang/rust-clippy/issues/9256
+mod issue_9256 {
+    #![allow(dead_code)]
+
+    fn print_substring(original: &str) {
+        assert!(original.len() > 10);
+        println!("{}", original[..10].to_string());
+    }
+
+    fn main() {
+        print_substring("Hello, world!");
+    }
+}
diff --git a/tests/ui/format_args.stderr b/tests/ui/format_args.stderr
index e69999cc9d0..aa6e3659b43 100644
--- a/tests/ui/format_args.stderr
+++ b/tests/ui/format_args.stderr
@@ -132,5 +132,11 @@ error: `to_string` applied to a type that implements `Display` in `format!` args
 LL |         let x = format!("{} {}", a, b.to_string());
    |                                      ^^^^^^^^^^^^ help: remove this
 
-error: aborting due to 22 previous errors
+error: `to_string` applied to a type that implements `Display` in `println!` args
+  --> $DIR/format_args.rs:156:24
+   |
+LL |         println!("{}", original[..10].to_string());
+   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use this: `&original[..10]`
+
+error: aborting due to 23 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 0bc26c811c96c05b2e60c94d06e2904b0ce25fe7 Mon Sep 17 00:00:00 2001
From: "Samuel E. Moelius III" <sam@moeli.us>
Date: Fri, 29 Jul 2022 17:46:09 -0400
Subject: `needed_ref` -> `needs_ref`

---
 clippy_lints/src/format_args.rs | 10 +++-------
 1 file changed, 3 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/format_args.rs b/clippy_lints/src/format_args.rs
index 473c9a8675f..9fb9fd99748 100644
--- a/clippy_lints/src/format_args.rs
+++ b/clippy_lints/src/format_args.rs
@@ -137,12 +137,8 @@ fn check_to_string_in_format_args(cx: &LateContext<'_>, name: Symbol, value: &Ex
         if let Some(sized_trait_id) = cx.tcx.lang_items().sized_trait();
         if let Some(receiver_snippet) = snippet_opt(cx, receiver.span);
         then {
-            let needed_ref = if implements_trait(cx, receiver_ty, sized_trait_id, &[]) {
-                ""
-            } else {
-                "&"
-            };
-            if n_needed_derefs == 0 && needed_ref.is_empty() {
+            let needs_ref = !implements_trait(cx, receiver_ty, sized_trait_id, &[]);
+            if n_needed_derefs == 0 && !needs_ref {
                 span_lint_and_sugg(
                     cx,
                     TO_STRING_IN_FORMAT_ARGS,
@@ -167,7 +163,7 @@ fn check_to_string_in_format_args(cx: &LateContext<'_>, name: Symbol, value: &Ex
                     "use this",
                     format!(
                         "{}{:*>width$}{}",
-                        needed_ref,
+                        if needs_ref { "&" } else { "" },
                         "",
                         receiver_snippet,
                         width = n_needed_derefs
-- 
cgit 1.4.1-3-g733a5


From 2cb5318e97f7083f397c45664f3808e2601fbe78 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Tue, 23 Aug 2022 14:17:30 +0000
Subject: Rename `manual_empty_string_creation` and move to pedantic

---
 CHANGELOG.md                                      |   2 +-
 clippy_lints/src/lib.register_all.rs              |   1 -
 clippy_lints/src/lib.register_lints.rs            |   2 +-
 clippy_lints/src/lib.register_pedantic.rs         |   1 +
 clippy_lints/src/lib.register_style.rs            |   1 -
 clippy_lints/src/lib.rs                           |   4 +-
 clippy_lints/src/manual_empty_string_creations.rs | 141 ----------------------
 clippy_lints/src/manual_string_new.rs             | 140 +++++++++++++++++++++
 tests/ui/manual_empty_string_creations.fixed      |  63 ----------
 tests/ui/manual_empty_string_creations.rs         |  63 ----------
 tests/ui/manual_empty_string_creations.stderr     |  58 ---------
 tests/ui/manual_string_new.fixed                  |  63 ++++++++++
 tests/ui/manual_string_new.rs                     |  63 ++++++++++
 tests/ui/manual_string_new.stderr                 |  58 +++++++++
 tests/ui/unnecessary_owned_empty_strings.fixed    |   2 +-
 tests/ui/unnecessary_owned_empty_strings.rs       |   2 +-
 16 files changed, 331 insertions(+), 333 deletions(-)
 delete mode 100644 clippy_lints/src/manual_empty_string_creations.rs
 create mode 100644 clippy_lints/src/manual_string_new.rs
 delete mode 100644 tests/ui/manual_empty_string_creations.fixed
 delete mode 100644 tests/ui/manual_empty_string_creations.rs
 delete mode 100644 tests/ui/manual_empty_string_creations.stderr
 create mode 100644 tests/ui/manual_string_new.fixed
 create mode 100644 tests/ui/manual_string_new.rs
 create mode 100644 tests/ui/manual_string_new.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index caa488a7a9c..b3abdc61e63 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3831,7 +3831,6 @@ Released 2018-09-13
 [`manual_assert`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_assert
 [`manual_async_fn`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_async_fn
 [`manual_bits`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_bits
-[`manual_empty_string_creations`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_empty_string_creations
 [`manual_filter_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_filter_map
 [`manual_find`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_find
 [`manual_find_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_find_map
@@ -3847,6 +3846,7 @@ Released 2018-09-13
 [`manual_saturating_arithmetic`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_saturating_arithmetic
 [`manual_split_once`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_split_once
 [`manual_str_repeat`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_str_repeat
+[`manual_string_new`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_string_new
 [`manual_strip`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_strip
 [`manual_swap`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_swap
 [`manual_unwrap_or`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_unwrap_or
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index dac6aed61c0..3e46ba12c44 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -122,7 +122,6 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(main_recursion::MAIN_RECURSION),
     LintId::of(manual_async_fn::MANUAL_ASYNC_FN),
     LintId::of(manual_bits::MANUAL_BITS),
-    LintId::of(manual_empty_string_creations::MANUAL_EMPTY_STRING_CREATIONS),
     LintId::of(manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE),
     LintId::of(manual_rem_euclid::MANUAL_REM_EUCLID),
     LintId::of(manual_retain::MANUAL_RETAIN),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index be58e144184..e99b4ffdb3a 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -240,11 +240,11 @@ store.register_lints(&[
     manual_assert::MANUAL_ASSERT,
     manual_async_fn::MANUAL_ASYNC_FN,
     manual_bits::MANUAL_BITS,
-    manual_empty_string_creations::MANUAL_EMPTY_STRING_CREATIONS,
     manual_instant_elapsed::MANUAL_INSTANT_ELAPSED,
     manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE,
     manual_rem_euclid::MANUAL_REM_EUCLID,
     manual_retain::MANUAL_RETAIN,
+    manual_string_new::MANUAL_STRING_NEW,
     manual_strip::MANUAL_STRIP,
     map_unit_fn::OPTION_MAP_UNIT_FN,
     map_unit_fn::RESULT_MAP_UNIT_FN,
diff --git a/clippy_lints/src/lib.register_pedantic.rs b/clippy_lints/src/lib.register_pedantic.rs
index 13474127e8d..03c3c202e0a 100644
--- a/clippy_lints/src/lib.register_pedantic.rs
+++ b/clippy_lints/src/lib.register_pedantic.rs
@@ -48,6 +48,7 @@ store.register_group(true, "clippy::pedantic", Some("clippy_pedantic"), vec![
     LintId::of(macro_use::MACRO_USE_IMPORTS),
     LintId::of(manual_assert::MANUAL_ASSERT),
     LintId::of(manual_instant_elapsed::MANUAL_INSTANT_ELAPSED),
+    LintId::of(manual_string_new::MANUAL_STRING_NEW),
     LintId::of(matches::MATCH_BOOL),
     LintId::of(matches::MATCH_ON_VEC_ITEMS),
     LintId::of(matches::MATCH_SAME_ARMS),
diff --git a/clippy_lints/src/lib.register_style.rs b/clippy_lints/src/lib.register_style.rs
index d34aadd1d37..b5cb078e7a3 100644
--- a/clippy_lints/src/lib.register_style.rs
+++ b/clippy_lints/src/lib.register_style.rs
@@ -43,7 +43,6 @@ store.register_group(true, "clippy::style", Some("clippy_style"), vec![
     LintId::of(main_recursion::MAIN_RECURSION),
     LintId::of(manual_async_fn::MANUAL_ASYNC_FN),
     LintId::of(manual_bits::MANUAL_BITS),
-    LintId::of(manual_empty_string_creations::MANUAL_EMPTY_STRING_CREATIONS),
     LintId::of(manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE),
     LintId::of(match_result_ok::MATCH_RESULT_OK),
     LintId::of(matches::COLLAPSIBLE_MATCH),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 64c43d9acc4..be91630b8fa 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -267,11 +267,11 @@ mod main_recursion;
 mod manual_assert;
 mod manual_async_fn;
 mod manual_bits;
-mod manual_empty_string_creations;
 mod manual_instant_elapsed;
 mod manual_non_exhaustive;
 mod manual_rem_euclid;
 mod manual_retain;
+mod manual_string_new;
 mod manual_strip;
 mod map_unit_fn;
 mod match_result_ok;
@@ -894,7 +894,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(std_instead_of_core::StdReexports::default()));
     store.register_late_pass(|| Box::new(manual_instant_elapsed::ManualInstantElapsed));
     store.register_late_pass(|| Box::new(partialeq_to_none::PartialeqToNone));
-    store.register_late_pass(|| Box::new(manual_empty_string_creations::ManualEmptyStringCreations));
+    store.register_late_pass(|| Box::new(manual_string_new::ManualStringNew));
     store.register_late_pass(|| Box::new(unused_peekable::UnusedPeekable));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
diff --git a/clippy_lints/src/manual_empty_string_creations.rs b/clippy_lints/src/manual_empty_string_creations.rs
deleted file mode 100644
index a2a10eb91e5..00000000000
--- a/clippy_lints/src/manual_empty_string_creations.rs
+++ /dev/null
@@ -1,141 +0,0 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
-use rustc_ast::LitKind;
-use rustc_errors::Applicability::MachineApplicable;
-use rustc_hir::{Expr, ExprKind, PathSegment, QPath, TyKind};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::{sym, symbol, Span};
-
-declare_clippy_lint! {
-    /// ### What it does
-    ///
-    /// Checks for usage of `""` to create a `String`, such as `"".to_string()`, `"".to_owned()`,
-    /// `String::from("")` and others.
-    ///
-    /// ### Why is this bad?
-    ///
-    /// Different ways of creating an empty string makes your code less standardized, which can
-    /// be confusing.
-    ///
-    /// ### Example
-    /// ```rust
-    /// let a = "".to_string();
-    /// let b: String = "".into();
-    /// ```
-    /// Use instead:
-    /// ```rust
-    /// let a = String::new();
-    /// let b = String::new();
-    /// ```
-    #[clippy::version = "1.65.0"]
-    pub MANUAL_EMPTY_STRING_CREATIONS,
-    style,
-    "empty String is being created manually"
-}
-declare_lint_pass!(ManualEmptyStringCreations => [MANUAL_EMPTY_STRING_CREATIONS]);
-
-impl LateLintPass<'_> for ManualEmptyStringCreations {
-    fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
-        if expr.span.from_expansion() {
-            return;
-        }
-
-        let ty = cx.typeck_results().expr_ty(expr);
-        match ty.kind() {
-            ty::Adt(adt_def, _) if adt_def.is_struct() => {
-                if !cx.tcx.is_diagnostic_item(sym::String, adt_def.did()) {
-                    return;
-                }
-            },
-            _ => return,
-        }
-
-        match expr.kind {
-            ExprKind::Call(func, args) => {
-                parse_call(cx, expr.span, func, args);
-            },
-            ExprKind::MethodCall(path_segment, args, _) => {
-                parse_method_call(cx, expr.span, path_segment, args);
-            },
-            _ => (),
-        }
-    }
-}
-
-/// Checks if an expression's kind corresponds to an empty &str.
-fn is_expr_kind_empty_str(expr_kind: &ExprKind<'_>) -> bool {
-    if  let ExprKind::Lit(lit) = expr_kind &&
-        let LitKind::Str(value, _) = lit.node &&
-        value == symbol::kw::Empty
-    {
-        return true;
-    }
-
-    false
-}
-
-/// Emits the `MANUAL_EMPTY_STRING_CREATION` warning and suggests the appropriate fix.
-fn warn_then_suggest(cx: &LateContext<'_>, span: Span) {
-    span_lint_and_sugg(
-        cx,
-        MANUAL_EMPTY_STRING_CREATIONS,
-        span,
-        "empty String is being created manually",
-        "consider using",
-        "String::new()".into(),
-        MachineApplicable,
-    );
-}
-
-/// Tries to parse an expression as a method call, emitting the warning if necessary.
-fn parse_method_call(cx: &LateContext<'_>, span: Span, path_segment: &PathSegment<'_>, args: &[Expr<'_>]) {
-    if args.is_empty() {
-        // When parsing TryFrom::try_from(...).expect(...), we will have more than 1 arg.
-        return;
-    }
-
-    let ident = path_segment.ident.as_str();
-    let method_arg_kind = &args[0].kind;
-    if ["to_string", "to_owned", "into"].contains(&ident) && is_expr_kind_empty_str(method_arg_kind) {
-        warn_then_suggest(cx, span);
-    } else if let ExprKind::Call(func, args) = method_arg_kind {
-        // If our first argument is a function call itself, it could be an `unwrap`-like function.
-        // E.g. String::try_from("hello").unwrap(), TryFrom::try_from("").expect("hello"), etc.
-        parse_call(cx, span, func, args);
-    }
-}
-
-/// Tries to parse an expression as a function call, emitting the warning if necessary.
-fn parse_call(cx: &LateContext<'_>, span: Span, func: &Expr<'_>, args: &[Expr<'_>]) {
-    if args.len() != 1 {
-        return;
-    }
-
-    let arg_kind = &args[0].kind;
-    if let ExprKind::Path(qpath) = &func.kind {
-        if let QPath::TypeRelative(_, _) = qpath {
-            // String::from(...) or String::try_from(...)
-            if  let QPath::TypeRelative(ty, path_seg) = qpath &&
-                [sym::from, sym::try_from].contains(&path_seg.ident.name) &&
-                let TyKind::Path(qpath) = &ty.kind &&
-                let QPath::Resolved(_, path) = qpath &&
-                let [path_seg] = path.segments &&
-                path_seg.ident.name == sym::String &&
-                is_expr_kind_empty_str(arg_kind)
-            {
-                warn_then_suggest(cx, span);
-            }
-        } else if let QPath::Resolved(_, path) = qpath {
-            // From::from(...) or TryFrom::try_from(...)
-            if  let [path_seg1, path_seg2] = path.segments &&
-                is_expr_kind_empty_str(arg_kind) && (
-                    (path_seg1.ident.name == sym::From && path_seg2.ident.name == sym::from) ||
-                    (path_seg1.ident.name == sym::TryFrom && path_seg2.ident.name == sym::try_from)
-                )
-            {
-                warn_then_suggest(cx, span);
-            }
-        }
-    }
-}
diff --git a/clippy_lints/src/manual_string_new.rs b/clippy_lints/src/manual_string_new.rs
new file mode 100644
index 00000000000..a90eaa8fdcb
--- /dev/null
+++ b/clippy_lints/src/manual_string_new.rs
@@ -0,0 +1,140 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use rustc_ast::LitKind;
+use rustc_errors::Applicability::MachineApplicable;
+use rustc_hir::{Expr, ExprKind, PathSegment, QPath, TyKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::{sym, symbol, Span};
+
+declare_clippy_lint! {
+    /// ### What it does
+    ///
+    /// Checks for usage of `""` to create a `String`, such as `"".to_string()`, `"".to_owned()`,
+    /// `String::from("")` and others.
+    ///
+    /// ### Why is this bad?
+    ///
+    /// Different ways of creating an empty string makes your code less standardized, which can
+    /// be confusing.
+    ///
+    /// ### Example
+    /// ```rust
+    /// let a = "".to_string();
+    /// let b: String = "".into();
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// let a = String::new();
+    /// let b = String::new();
+    /// ```
+    #[clippy::version = "1.65.0"]
+    pub MANUAL_STRING_NEW,
+    pedantic,
+    "empty String is being created manually"
+}
+declare_lint_pass!(ManualStringNew => [MANUAL_STRING_NEW]);
+
+impl LateLintPass<'_> for ManualStringNew {
+    fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
+        if expr.span.from_expansion() {
+            return;
+        }
+
+        let ty = cx.typeck_results().expr_ty(expr);
+        match ty.kind() {
+            ty::Adt(adt_def, _) if adt_def.is_struct() => {
+                if !cx.tcx.is_diagnostic_item(sym::String, adt_def.did()) {
+                    return;
+                }
+            },
+            _ => return,
+        }
+
+        match expr.kind {
+            ExprKind::Call(func, args) => {
+                parse_call(cx, expr.span, func, args);
+            },
+            ExprKind::MethodCall(path_segment, args, _) => {
+                parse_method_call(cx, expr.span, path_segment, args);
+            },
+            _ => (),
+        }
+    }
+}
+
+/// Checks if an expression's kind corresponds to an empty &str.
+fn is_expr_kind_empty_str(expr_kind: &ExprKind<'_>) -> bool {
+    if  let ExprKind::Lit(lit) = expr_kind &&
+        let LitKind::Str(value, _) = lit.node &&
+        value == symbol::kw::Empty
+    {
+        return true;
+    }
+
+    false
+}
+
+fn warn_then_suggest(cx: &LateContext<'_>, span: Span) {
+    span_lint_and_sugg(
+        cx,
+        MANUAL_STRING_NEW,
+        span,
+        "empty String is being created manually",
+        "consider using",
+        "String::new()".into(),
+        MachineApplicable,
+    );
+}
+
+/// Tries to parse an expression as a method call, emitting the warning if necessary.
+fn parse_method_call(cx: &LateContext<'_>, span: Span, path_segment: &PathSegment<'_>, args: &[Expr<'_>]) {
+    if args.is_empty() {
+        // When parsing TryFrom::try_from(...).expect(...), we will have more than 1 arg.
+        return;
+    }
+
+    let ident = path_segment.ident.as_str();
+    let method_arg_kind = &args[0].kind;
+    if ["to_string", "to_owned", "into"].contains(&ident) && is_expr_kind_empty_str(method_arg_kind) {
+        warn_then_suggest(cx, span);
+    } else if let ExprKind::Call(func, args) = method_arg_kind {
+        // If our first argument is a function call itself, it could be an `unwrap`-like function.
+        // E.g. String::try_from("hello").unwrap(), TryFrom::try_from("").expect("hello"), etc.
+        parse_call(cx, span, func, args);
+    }
+}
+
+/// Tries to parse an expression as a function call, emitting the warning if necessary.
+fn parse_call(cx: &LateContext<'_>, span: Span, func: &Expr<'_>, args: &[Expr<'_>]) {
+    if args.len() != 1 {
+        return;
+    }
+
+    let arg_kind = &args[0].kind;
+    if let ExprKind::Path(qpath) = &func.kind {
+        if let QPath::TypeRelative(_, _) = qpath {
+            // String::from(...) or String::try_from(...)
+            if  let QPath::TypeRelative(ty, path_seg) = qpath &&
+                [sym::from, sym::try_from].contains(&path_seg.ident.name) &&
+                let TyKind::Path(qpath) = &ty.kind &&
+                let QPath::Resolved(_, path) = qpath &&
+                let [path_seg] = path.segments &&
+                path_seg.ident.name == sym::String &&
+                is_expr_kind_empty_str(arg_kind)
+            {
+                warn_then_suggest(cx, span);
+            }
+        } else if let QPath::Resolved(_, path) = qpath {
+            // From::from(...) or TryFrom::try_from(...)
+            if  let [path_seg1, path_seg2] = path.segments &&
+                is_expr_kind_empty_str(arg_kind) && (
+                    (path_seg1.ident.name == sym::From && path_seg2.ident.name == sym::from) ||
+                    (path_seg1.ident.name == sym::TryFrom && path_seg2.ident.name == sym::try_from)
+                )
+            {
+                warn_then_suggest(cx, span);
+            }
+        }
+    }
+}
diff --git a/tests/ui/manual_empty_string_creations.fixed b/tests/ui/manual_empty_string_creations.fixed
deleted file mode 100644
index caf0c657c81..00000000000
--- a/tests/ui/manual_empty_string_creations.fixed
+++ /dev/null
@@ -1,63 +0,0 @@
-// run-rustfix
-
-#![warn(clippy::manual_empty_string_creations)]
-
-macro_rules! create_strings_from_macro {
-    // When inside a macro, nothing should warn to prevent false positives.
-    ($some_str:expr) => {
-        let _: String = $some_str.into();
-        let _ = $some_str.to_string();
-    };
-}
-
-fn main() {
-    // Method calls
-    let _ = String::new();
-    let _ = "no warning".to_string();
-
-    let _ = String::new();
-    let _ = "no warning".to_owned();
-
-    let _: String = String::new();
-    let _: String = "no warning".into();
-
-    let _: SomeOtherStruct = "no warning".into();
-    let _: SomeOtherStruct = "".into(); // No warning too. We are not converting into String.
-
-    // Calls
-    let _ = String::new();
-    let _ = String::new();
-    let _ = String::from("no warning");
-    let _ = SomeOtherStruct::from("no warning");
-    let _ = SomeOtherStruct::from(""); // Again: no warning.
-
-    let _ = String::new();
-    let _ = String::try_from("no warning").unwrap();
-    let _ = String::try_from("no warning").expect("this should not warn");
-    let _ = SomeOtherStruct::try_from("no warning").unwrap();
-    let _ = SomeOtherStruct::try_from("").unwrap(); // Again: no warning.
-
-    let _: String = String::new();
-    let _: String = From::from("no warning");
-    let _: SomeOtherStruct = From::from("no warning");
-    let _: SomeOtherStruct = From::from(""); // Again: no warning.
-
-    let _: String = String::new();
-    let _: String = TryFrom::try_from("no warning").unwrap();
-    let _: String = TryFrom::try_from("no warning").expect("this should not warn");
-    let _: String = String::new();
-    let _: SomeOtherStruct = TryFrom::try_from("no_warning").unwrap();
-    let _: SomeOtherStruct = TryFrom::try_from("").unwrap(); // Again: no warning.
-
-    // Macros (never warn)
-    create_strings_from_macro!("");
-    create_strings_from_macro!("Hey");
-}
-
-struct SomeOtherStruct {}
-
-impl From<&str> for SomeOtherStruct {
-    fn from(_value: &str) -> Self {
-        Self {}
-    }
-}
diff --git a/tests/ui/manual_empty_string_creations.rs b/tests/ui/manual_empty_string_creations.rs
deleted file mode 100644
index ed39a05ed5c..00000000000
--- a/tests/ui/manual_empty_string_creations.rs
+++ /dev/null
@@ -1,63 +0,0 @@
-// run-rustfix
-
-#![warn(clippy::manual_empty_string_creations)]
-
-macro_rules! create_strings_from_macro {
-    // When inside a macro, nothing should warn to prevent false positives.
-    ($some_str:expr) => {
-        let _: String = $some_str.into();
-        let _ = $some_str.to_string();
-    };
-}
-
-fn main() {
-    // Method calls
-    let _ = "".to_string();
-    let _ = "no warning".to_string();
-
-    let _ = "".to_owned();
-    let _ = "no warning".to_owned();
-
-    let _: String = "".into();
-    let _: String = "no warning".into();
-
-    let _: SomeOtherStruct = "no warning".into();
-    let _: SomeOtherStruct = "".into(); // No warning too. We are not converting into String.
-
-    // Calls
-    let _ = String::from("");
-    let _ = <String>::from("");
-    let _ = String::from("no warning");
-    let _ = SomeOtherStruct::from("no warning");
-    let _ = SomeOtherStruct::from(""); // Again: no warning.
-
-    let _ = String::try_from("").unwrap();
-    let _ = String::try_from("no warning").unwrap();
-    let _ = String::try_from("no warning").expect("this should not warn");
-    let _ = SomeOtherStruct::try_from("no warning").unwrap();
-    let _ = SomeOtherStruct::try_from("").unwrap(); // Again: no warning.
-
-    let _: String = From::from("");
-    let _: String = From::from("no warning");
-    let _: SomeOtherStruct = From::from("no warning");
-    let _: SomeOtherStruct = From::from(""); // Again: no warning.
-
-    let _: String = TryFrom::try_from("").unwrap();
-    let _: String = TryFrom::try_from("no warning").unwrap();
-    let _: String = TryFrom::try_from("no warning").expect("this should not warn");
-    let _: String = TryFrom::try_from("").expect("this should warn");
-    let _: SomeOtherStruct = TryFrom::try_from("no_warning").unwrap();
-    let _: SomeOtherStruct = TryFrom::try_from("").unwrap(); // Again: no warning.
-
-    // Macros (never warn)
-    create_strings_from_macro!("");
-    create_strings_from_macro!("Hey");
-}
-
-struct SomeOtherStruct {}
-
-impl From<&str> for SomeOtherStruct {
-    fn from(_value: &str) -> Self {
-        Self {}
-    }
-}
diff --git a/tests/ui/manual_empty_string_creations.stderr b/tests/ui/manual_empty_string_creations.stderr
deleted file mode 100644
index f38ba02a508..00000000000
--- a/tests/ui/manual_empty_string_creations.stderr
+++ /dev/null
@@ -1,58 +0,0 @@
-error: empty String is being created manually
-  --> $DIR/manual_empty_string_creations.rs:15:13
-   |
-LL |     let _ = "".to_string();
-   |             ^^^^^^^^^^^^^^ help: consider using: `String::new()`
-   |
-   = note: `-D clippy::manual-empty-string-creations` implied by `-D warnings`
-
-error: empty String is being created manually
-  --> $DIR/manual_empty_string_creations.rs:18:13
-   |
-LL |     let _ = "".to_owned();
-   |             ^^^^^^^^^^^^^ help: consider using: `String::new()`
-
-error: empty String is being created manually
-  --> $DIR/manual_empty_string_creations.rs:21:21
-   |
-LL |     let _: String = "".into();
-   |                     ^^^^^^^^^ help: consider using: `String::new()`
-
-error: empty String is being created manually
-  --> $DIR/manual_empty_string_creations.rs:28:13
-   |
-LL |     let _ = String::from("");
-   |             ^^^^^^^^^^^^^^^^ help: consider using: `String::new()`
-
-error: empty String is being created manually
-  --> $DIR/manual_empty_string_creations.rs:29:13
-   |
-LL |     let _ = <String>::from("");
-   |             ^^^^^^^^^^^^^^^^^^ help: consider using: `String::new()`
-
-error: empty String is being created manually
-  --> $DIR/manual_empty_string_creations.rs:34:13
-   |
-LL |     let _ = String::try_from("").unwrap();
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `String::new()`
-
-error: empty String is being created manually
-  --> $DIR/manual_empty_string_creations.rs:40:21
-   |
-LL |     let _: String = From::from("");
-   |                     ^^^^^^^^^^^^^^ help: consider using: `String::new()`
-
-error: empty String is being created manually
-  --> $DIR/manual_empty_string_creations.rs:45:21
-   |
-LL |     let _: String = TryFrom::try_from("").unwrap();
-   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `String::new()`
-
-error: empty String is being created manually
-  --> $DIR/manual_empty_string_creations.rs:48:21
-   |
-LL |     let _: String = TryFrom::try_from("").expect("this should warn");
-   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `String::new()`
-
-error: aborting due to 9 previous errors
-
diff --git a/tests/ui/manual_string_new.fixed b/tests/ui/manual_string_new.fixed
new file mode 100644
index 00000000000..a376411bfbc
--- /dev/null
+++ b/tests/ui/manual_string_new.fixed
@@ -0,0 +1,63 @@
+// run-rustfix
+
+#![warn(clippy::manual_string_new)]
+
+macro_rules! create_strings_from_macro {
+    // When inside a macro, nothing should warn to prevent false positives.
+    ($some_str:expr) => {
+        let _: String = $some_str.into();
+        let _ = $some_str.to_string();
+    };
+}
+
+fn main() {
+    // Method calls
+    let _ = String::new();
+    let _ = "no warning".to_string();
+
+    let _ = String::new();
+    let _ = "no warning".to_owned();
+
+    let _: String = String::new();
+    let _: String = "no warning".into();
+
+    let _: SomeOtherStruct = "no warning".into();
+    let _: SomeOtherStruct = "".into(); // No warning too. We are not converting into String.
+
+    // Calls
+    let _ = String::new();
+    let _ = String::new();
+    let _ = String::from("no warning");
+    let _ = SomeOtherStruct::from("no warning");
+    let _ = SomeOtherStruct::from(""); // Again: no warning.
+
+    let _ = String::new();
+    let _ = String::try_from("no warning").unwrap();
+    let _ = String::try_from("no warning").expect("this should not warn");
+    let _ = SomeOtherStruct::try_from("no warning").unwrap();
+    let _ = SomeOtherStruct::try_from("").unwrap(); // Again: no warning.
+
+    let _: String = String::new();
+    let _: String = From::from("no warning");
+    let _: SomeOtherStruct = From::from("no warning");
+    let _: SomeOtherStruct = From::from(""); // Again: no warning.
+
+    let _: String = String::new();
+    let _: String = TryFrom::try_from("no warning").unwrap();
+    let _: String = TryFrom::try_from("no warning").expect("this should not warn");
+    let _: String = String::new();
+    let _: SomeOtherStruct = TryFrom::try_from("no_warning").unwrap();
+    let _: SomeOtherStruct = TryFrom::try_from("").unwrap(); // Again: no warning.
+
+    // Macros (never warn)
+    create_strings_from_macro!("");
+    create_strings_from_macro!("Hey");
+}
+
+struct SomeOtherStruct {}
+
+impl From<&str> for SomeOtherStruct {
+    fn from(_value: &str) -> Self {
+        Self {}
+    }
+}
diff --git a/tests/ui/manual_string_new.rs b/tests/ui/manual_string_new.rs
new file mode 100644
index 00000000000..6bfc52fb1bc
--- /dev/null
+++ b/tests/ui/manual_string_new.rs
@@ -0,0 +1,63 @@
+// run-rustfix
+
+#![warn(clippy::manual_string_new)]
+
+macro_rules! create_strings_from_macro {
+    // When inside a macro, nothing should warn to prevent false positives.
+    ($some_str:expr) => {
+        let _: String = $some_str.into();
+        let _ = $some_str.to_string();
+    };
+}
+
+fn main() {
+    // Method calls
+    let _ = "".to_string();
+    let _ = "no warning".to_string();
+
+    let _ = "".to_owned();
+    let _ = "no warning".to_owned();
+
+    let _: String = "".into();
+    let _: String = "no warning".into();
+
+    let _: SomeOtherStruct = "no warning".into();
+    let _: SomeOtherStruct = "".into(); // No warning too. We are not converting into String.
+
+    // Calls
+    let _ = String::from("");
+    let _ = <String>::from("");
+    let _ = String::from("no warning");
+    let _ = SomeOtherStruct::from("no warning");
+    let _ = SomeOtherStruct::from(""); // Again: no warning.
+
+    let _ = String::try_from("").unwrap();
+    let _ = String::try_from("no warning").unwrap();
+    let _ = String::try_from("no warning").expect("this should not warn");
+    let _ = SomeOtherStruct::try_from("no warning").unwrap();
+    let _ = SomeOtherStruct::try_from("").unwrap(); // Again: no warning.
+
+    let _: String = From::from("");
+    let _: String = From::from("no warning");
+    let _: SomeOtherStruct = From::from("no warning");
+    let _: SomeOtherStruct = From::from(""); // Again: no warning.
+
+    let _: String = TryFrom::try_from("").unwrap();
+    let _: String = TryFrom::try_from("no warning").unwrap();
+    let _: String = TryFrom::try_from("no warning").expect("this should not warn");
+    let _: String = TryFrom::try_from("").expect("this should warn");
+    let _: SomeOtherStruct = TryFrom::try_from("no_warning").unwrap();
+    let _: SomeOtherStruct = TryFrom::try_from("").unwrap(); // Again: no warning.
+
+    // Macros (never warn)
+    create_strings_from_macro!("");
+    create_strings_from_macro!("Hey");
+}
+
+struct SomeOtherStruct {}
+
+impl From<&str> for SomeOtherStruct {
+    fn from(_value: &str) -> Self {
+        Self {}
+    }
+}
diff --git a/tests/ui/manual_string_new.stderr b/tests/ui/manual_string_new.stderr
new file mode 100644
index 00000000000..e5ecfc61947
--- /dev/null
+++ b/tests/ui/manual_string_new.stderr
@@ -0,0 +1,58 @@
+error: empty String is being created manually
+  --> $DIR/manual_string_new.rs:15:13
+   |
+LL |     let _ = "".to_string();
+   |             ^^^^^^^^^^^^^^ help: consider using: `String::new()`
+   |
+   = note: `-D clippy::manual-string-new` implied by `-D warnings`
+
+error: empty String is being created manually
+  --> $DIR/manual_string_new.rs:18:13
+   |
+LL |     let _ = "".to_owned();
+   |             ^^^^^^^^^^^^^ help: consider using: `String::new()`
+
+error: empty String is being created manually
+  --> $DIR/manual_string_new.rs:21:21
+   |
+LL |     let _: String = "".into();
+   |                     ^^^^^^^^^ help: consider using: `String::new()`
+
+error: empty String is being created manually
+  --> $DIR/manual_string_new.rs:28:13
+   |
+LL |     let _ = String::from("");
+   |             ^^^^^^^^^^^^^^^^ help: consider using: `String::new()`
+
+error: empty String is being created manually
+  --> $DIR/manual_string_new.rs:29:13
+   |
+LL |     let _ = <String>::from("");
+   |             ^^^^^^^^^^^^^^^^^^ help: consider using: `String::new()`
+
+error: empty String is being created manually
+  --> $DIR/manual_string_new.rs:34:13
+   |
+LL |     let _ = String::try_from("").unwrap();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `String::new()`
+
+error: empty String is being created manually
+  --> $DIR/manual_string_new.rs:40:21
+   |
+LL |     let _: String = From::from("");
+   |                     ^^^^^^^^^^^^^^ help: consider using: `String::new()`
+
+error: empty String is being created manually
+  --> $DIR/manual_string_new.rs:45:21
+   |
+LL |     let _: String = TryFrom::try_from("").unwrap();
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `String::new()`
+
+error: empty String is being created manually
+  --> $DIR/manual_string_new.rs:48:21
+   |
+LL |     let _: String = TryFrom::try_from("").expect("this should warn");
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `String::new()`
+
+error: aborting due to 9 previous errors
+
diff --git a/tests/ui/unnecessary_owned_empty_strings.fixed b/tests/ui/unnecessary_owned_empty_strings.fixed
index c390618ca98..40052c41039 100644
--- a/tests/ui/unnecessary_owned_empty_strings.fixed
+++ b/tests/ui/unnecessary_owned_empty_strings.fixed
@@ -12,7 +12,7 @@ fn main() {
     ref_str_argument("");
 
     // should be linted
-    #[allow(clippy::manual_empty_string_creations)]
+    #[allow(clippy::manual_string_new)]
     ref_str_argument("");
 
     // should not be linted
diff --git a/tests/ui/unnecessary_owned_empty_strings.rs b/tests/ui/unnecessary_owned_empty_strings.rs
index 4a9d6125eb1..2304dff5192 100644
--- a/tests/ui/unnecessary_owned_empty_strings.rs
+++ b/tests/ui/unnecessary_owned_empty_strings.rs
@@ -12,7 +12,7 @@ fn main() {
     ref_str_argument(&String::new());
 
     // should be linted
-    #[allow(clippy::manual_empty_string_creations)]
+    #[allow(clippy::manual_string_new)]
     ref_str_argument(&String::from(""));
 
     // should not be linted
-- 
cgit 1.4.1-3-g733a5


From a6444a69e27275c69e7287fe02ba0c88d554c445 Mon Sep 17 00:00:00 2001
From: Nahua Kang <kangnahua@gmail.com>
Date: Tue, 23 Aug 2022 19:05:57 +0200
Subject: Remove if_chain from equatable_if_let

---
 clippy_lints/src/equatable_if_let.rs | 59 +++++++++++++++++-------------------
 1 file changed, 27 insertions(+), 32 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/equatable_if_let.rs b/clippy_lints/src/equatable_if_let.rs
index fdfb821ac78..ba615c8c164 100644
--- a/clippy_lints/src/equatable_if_let.rs
+++ b/clippy_lints/src/equatable_if_let.rs
@@ -1,7 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_context;
 use clippy_utils::ty::implements_trait;
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, Pat, PatKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
@@ -67,37 +66,33 @@ fn is_structural_partial_eq<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>, other: T
 
 impl<'tcx> LateLintPass<'tcx> for PatternEquality {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
-        if_chain! {
-            if !in_external_macro(cx.sess(), expr.span);
-            if let ExprKind::Let(let_expr) = expr.kind;
-            if unary_pattern(let_expr.pat);
-            let exp_ty = cx.typeck_results().expr_ty(let_expr.init);
-            let pat_ty = cx.typeck_results().pat_ty(let_expr.pat);
-            if is_structural_partial_eq(cx, exp_ty, pat_ty);
-            then {
-
-                let mut applicability = Applicability::MachineApplicable;
-                let pat_str = match let_expr.pat.kind {
-                    PatKind::Struct(..) => format!(
-                        "({})",
-                        snippet_with_context(cx, let_expr.pat.span, expr.span.ctxt(), "..", &mut applicability).0,
-                    ),
-                    _ => snippet_with_context(cx, let_expr.pat.span, expr.span.ctxt(), "..", &mut applicability).0.to_string(),
-                };
-                span_lint_and_sugg(
-                    cx,
-                    EQUATABLE_IF_LET,
-                    expr.span,
-                    "this pattern matching can be expressed using equality",
-                    "try",
-                    format!(
-                        "{} == {}",
-                        snippet_with_context(cx, let_expr.init.span, expr.span.ctxt(), "..", &mut applicability).0,
-                        pat_str,
-                    ),
-                    applicability,
-                );
-            }
+        if !in_external_macro(cx.sess(), expr.span)
+            && let ExprKind::Let(let_expr) = expr.kind
+            && unary_pattern(let_expr.pat)
+            && let exp_ty = cx.typeck_results().expr_ty(let_expr.init)
+            && let pat_ty = cx.typeck_results().pat_ty(let_expr.pat)
+            && is_structural_partial_eq(cx, exp_ty, pat_ty) {
+            let mut applicability = Applicability::MachineApplicable;
+            let pat_str = match let_expr.pat.kind {
+                PatKind::Struct(..) => format!(
+                    "({})",
+                    snippet_with_context(cx, let_expr.pat.span, expr.span.ctxt(), "..", &mut applicability).0,
+                ),
+                _ => snippet_with_context(cx, let_expr.pat.span, expr.span.ctxt(), "..", &mut applicability).0.to_string(),
+            };
+            span_lint_and_sugg(
+                cx,
+                EQUATABLE_IF_LET,
+                expr.span,
+                "this pattern matching can be expressed using equality",
+                "try",
+                format!(
+                    "{} == {}",
+                    snippet_with_context(cx, let_expr.init.span, expr.span.ctxt(), "..", &mut applicability).0,
+                    pat_str,
+                ),
+                applicability,
+            );
         }
     }
 }
-- 
cgit 1.4.1-3-g733a5


From 5ee1c24f28029162ad25614c092224cc94ba59ff Mon Sep 17 00:00:00 2001
From: Nahua Kang <kangnahua@gmail.com>
Date: Tue, 23 Aug 2022 19:46:04 +0200
Subject: Lint suggests matches macro if PartialEq trait is not implemented

---
 clippy_lints/src/equatable_if_let.rs | 64 ++++++++++++++++++++++--------------
 tests/ui/equatable_if_let.rs         |  7 ++++
 2 files changed, 47 insertions(+), 24 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/equatable_if_let.rs b/clippy_lints/src/equatable_if_let.rs
index ba615c8c164..6f26195d105 100644
--- a/clippy_lints/src/equatable_if_let.rs
+++ b/clippy_lints/src/equatable_if_let.rs
@@ -68,31 +68,47 @@ impl<'tcx> LateLintPass<'tcx> for PatternEquality {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
         if !in_external_macro(cx.sess(), expr.span)
             && let ExprKind::Let(let_expr) = expr.kind
-            && unary_pattern(let_expr.pat)
-            && let exp_ty = cx.typeck_results().expr_ty(let_expr.init)
-            && let pat_ty = cx.typeck_results().pat_ty(let_expr.pat)
-            && is_structural_partial_eq(cx, exp_ty, pat_ty) {
+            && unary_pattern(let_expr.pat) {
+            let exp_ty = cx.typeck_results().expr_ty(let_expr.init);
+            let pat_ty = cx.typeck_results().pat_ty(let_expr.pat);
             let mut applicability = Applicability::MachineApplicable;
-            let pat_str = match let_expr.pat.kind {
-                PatKind::Struct(..) => format!(
-                    "({})",
-                    snippet_with_context(cx, let_expr.pat.span, expr.span.ctxt(), "..", &mut applicability).0,
-                ),
-                _ => snippet_with_context(cx, let_expr.pat.span, expr.span.ctxt(), "..", &mut applicability).0.to_string(),
-            };
-            span_lint_and_sugg(
-                cx,
-                EQUATABLE_IF_LET,
-                expr.span,
-                "this pattern matching can be expressed using equality",
-                "try",
-                format!(
-                    "{} == {}",
-                    snippet_with_context(cx, let_expr.init.span, expr.span.ctxt(), "..", &mut applicability).0,
-                    pat_str,
-                ),
-                applicability,
-            );
+
+            if is_structural_partial_eq(cx, exp_ty, pat_ty) {
+                let pat_str = match let_expr.pat.kind {
+                    PatKind::Struct(..) => format!(
+                        "({})",
+                        snippet_with_context(cx, let_expr.pat.span, expr.span.ctxt(), "..", &mut applicability).0,
+                    ),
+                    _ => snippet_with_context(cx, let_expr.pat.span, expr.span.ctxt(), "..", &mut applicability).0.to_string(),
+                };
+                span_lint_and_sugg(
+                    cx,
+                    EQUATABLE_IF_LET,
+                    expr.span,
+                    "this pattern matching can be expressed using equality",
+                    "try",
+                    format!(
+                        "{} == {}",
+                        snippet_with_context(cx, let_expr.init.span, expr.span.ctxt(), "..", &mut applicability).0,
+                        pat_str,
+                    ),
+                    applicability,
+                );
+            } else {
+                span_lint_and_sugg(
+                    cx, 
+                    EQUATABLE_IF_LET,
+                    expr.span,
+                    "this pattern matching can be expressed using `matches!`", 
+                    "try", 
+                    format!(
+                        "matches!({}, {})",
+                        snippet_with_context(cx, let_expr.init.span, expr.span.ctxt(), "..", &mut applicability).0,
+                        snippet_with_context(cx, let_expr.pat.span, expr.span.ctxt(), "..", &mut applicability).0,
+                    ), 
+                    applicability,
+                )
+            }
         }
     }
 }
diff --git a/tests/ui/equatable_if_let.rs b/tests/ui/equatable_if_let.rs
index 8c467d14d2a..c3626c081dd 100644
--- a/tests/ui/equatable_if_let.rs
+++ b/tests/ui/equatable_if_let.rs
@@ -23,6 +23,11 @@ struct Struct {
     b: bool,
 }
 
+struct NoPartialEqStruct {
+    a: i32,
+    b: bool,
+}
+
 enum NotPartialEq {
     A,
     B,
@@ -47,6 +52,7 @@ fn main() {
     let e = Enum::UnitVariant;
     let f = NotPartialEq::A;
     let g = NotStructuralEq::A;
+    let h = NoPartialEqStruct { a: 2, b: false };
 
     // true
 
@@ -70,6 +76,7 @@ fn main() {
     if let NotStructuralEq::A = g {}
     if let Some(NotPartialEq::A) = Some(f) {}
     if let Some(NotStructuralEq::A) = Some(g) {}
+    if let NoPartialEqStruct { a: 2, b: false } = h {}
 
     macro_rules! m1 {
         (x) => {
-- 
cgit 1.4.1-3-g733a5


From 4eaadd622d21948c488a4952b3c65fd5b9d852dc Mon Sep 17 00:00:00 2001
From: Nahua Kang <kangnahua@gmail.com>
Date: Tue, 23 Aug 2022 19:50:34 +0200
Subject: Run cargo dev bless to update fixes & stderr

---
 clippy_lints/src/equatable_if_let.rs | 10 ++++-----
 tests/ui/equatable_if_let.fixed      | 11 ++++++++--
 tests/ui/equatable_if_let.stderr     | 42 +++++++++++++++++++++++++-----------
 3 files changed, 44 insertions(+), 19 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/equatable_if_let.rs b/clippy_lints/src/equatable_if_let.rs
index 6f26195d105..928128785f4 100644
--- a/clippy_lints/src/equatable_if_let.rs
+++ b/clippy_lints/src/equatable_if_let.rs
@@ -96,18 +96,18 @@ impl<'tcx> LateLintPass<'tcx> for PatternEquality {
                 );
             } else {
                 span_lint_and_sugg(
-                    cx, 
+                    cx,
                     EQUATABLE_IF_LET,
                     expr.span,
-                    "this pattern matching can be expressed using `matches!`", 
-                    "try", 
+                    "this pattern matching can be expressed using `matches!`",
+                    "try",
                     format!(
                         "matches!({}, {})",
                         snippet_with_context(cx, let_expr.init.span, expr.span.ctxt(), "..", &mut applicability).0,
                         snippet_with_context(cx, let_expr.pat.span, expr.span.ctxt(), "..", &mut applicability).0,
-                    ), 
+                    ),
                     applicability,
-                )
+                );
             }
         }
     }
diff --git a/tests/ui/equatable_if_let.fixed b/tests/ui/equatable_if_let.fixed
index 687efdada6e..9af2ba96272 100644
--- a/tests/ui/equatable_if_let.fixed
+++ b/tests/ui/equatable_if_let.fixed
@@ -23,6 +23,11 @@ struct Struct {
     b: bool,
 }
 
+struct NoPartialEqStruct {
+    a: i32,
+    b: bool,
+}
+
 enum NotPartialEq {
     A,
     B,
@@ -47,6 +52,7 @@ fn main() {
     let e = Enum::UnitVariant;
     let f = NotPartialEq::A;
     let g = NotStructuralEq::A;
+    let h = NoPartialEqStruct { a: 2, b: false };
 
     // true
 
@@ -66,10 +72,11 @@ fn main() {
     if let Some(3 | 4) = c {}
     if let Struct { a, b: false } = d {}
     if let Struct { a: 2, b: x } = d {}
-    if let NotPartialEq::A = f {}
+    if matches!(f, NotPartialEq::A) {}
     if g == NotStructuralEq::A {}
-    if let Some(NotPartialEq::A) = Some(f) {}
+    if matches!(Some(f), Some(NotPartialEq::A)) {}
     if Some(g) == Some(NotStructuralEq::A) {}
+    if matches!(h, NoPartialEqStruct { a: 2, b: false }) {}
 
     macro_rules! m1 {
         (x) => {
diff --git a/tests/ui/equatable_if_let.stderr b/tests/ui/equatable_if_let.stderr
index 9c4c3cc3682..40ca75b8da2 100644
--- a/tests/ui/equatable_if_let.stderr
+++ b/tests/ui/equatable_if_let.stderr
@@ -1,5 +1,5 @@
 error: this pattern matching can be expressed using equality
-  --> $DIR/equatable_if_let.rs:53:8
+  --> $DIR/equatable_if_let.rs:59:8
    |
 LL |     if let 2 = a {}
    |        ^^^^^^^^^ help: try: `a == 2`
@@ -7,64 +7,82 @@ LL |     if let 2 = a {}
    = note: `-D clippy::equatable-if-let` implied by `-D warnings`
 
 error: this pattern matching can be expressed using equality
-  --> $DIR/equatable_if_let.rs:54:8
+  --> $DIR/equatable_if_let.rs:60:8
    |
 LL |     if let Ordering::Greater = a.cmp(&b) {}
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `a.cmp(&b) == Ordering::Greater`
 
 error: this pattern matching can be expressed using equality
-  --> $DIR/equatable_if_let.rs:55:8
+  --> $DIR/equatable_if_let.rs:61:8
    |
 LL |     if let Some(2) = c {}
    |        ^^^^^^^^^^^^^^^ help: try: `c == Some(2)`
 
 error: this pattern matching can be expressed using equality
-  --> $DIR/equatable_if_let.rs:56:8
+  --> $DIR/equatable_if_let.rs:62:8
    |
 LL |     if let Struct { a: 2, b: false } = d {}
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `d == (Struct { a: 2, b: false })`
 
 error: this pattern matching can be expressed using equality
-  --> $DIR/equatable_if_let.rs:57:8
+  --> $DIR/equatable_if_let.rs:63:8
    |
 LL |     if let Enum::TupleVariant(32, 64) = e {}
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `e == Enum::TupleVariant(32, 64)`
 
 error: this pattern matching can be expressed using equality
-  --> $DIR/equatable_if_let.rs:58:8
+  --> $DIR/equatable_if_let.rs:64:8
    |
 LL |     if let Enum::RecordVariant { a: 64, b: 32 } = e {}
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `e == (Enum::RecordVariant { a: 64, b: 32 })`
 
 error: this pattern matching can be expressed using equality
-  --> $DIR/equatable_if_let.rs:59:8
+  --> $DIR/equatable_if_let.rs:65:8
    |
 LL |     if let Enum::UnitVariant = e {}
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `e == Enum::UnitVariant`
 
 error: this pattern matching can be expressed using equality
-  --> $DIR/equatable_if_let.rs:60:8
+  --> $DIR/equatable_if_let.rs:66:8
    |
 LL |     if let (Enum::UnitVariant, &Struct { a: 2, b: false }) = (e, &d) {}
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `(e, &d) == (Enum::UnitVariant, &Struct { a: 2, b: false })`
 
+error: this pattern matching can be expressed using `matches!`
+  --> $DIR/equatable_if_let.rs:75:8
+   |
+LL |     if let NotPartialEq::A = f {}
+   |        ^^^^^^^^^^^^^^^^^^^^^^^ help: try: `matches!(f, NotPartialEq::A)`
+
 error: this pattern matching can be expressed using equality
-  --> $DIR/equatable_if_let.rs:70:8
+  --> $DIR/equatable_if_let.rs:76:8
    |
 LL |     if let NotStructuralEq::A = g {}
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `g == NotStructuralEq::A`
 
+error: this pattern matching can be expressed using `matches!`
+  --> $DIR/equatable_if_let.rs:77:8
+   |
+LL |     if let Some(NotPartialEq::A) = Some(f) {}
+   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `matches!(Some(f), Some(NotPartialEq::A))`
+
 error: this pattern matching can be expressed using equality
-  --> $DIR/equatable_if_let.rs:72:8
+  --> $DIR/equatable_if_let.rs:78:8
    |
 LL |     if let Some(NotStructuralEq::A) = Some(g) {}
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Some(g) == Some(NotStructuralEq::A)`
 
-error: this pattern matching can be expressed using equality
+error: this pattern matching can be expressed using `matches!`
   --> $DIR/equatable_if_let.rs:79:8
    |
+LL |     if let NoPartialEqStruct { a: 2, b: false } = h {}
+   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `matches!(h, NoPartialEqStruct { a: 2, b: false })`
+
+error: this pattern matching can be expressed using equality
+  --> $DIR/equatable_if_let.rs:86:8
+   |
 LL |     if let m1!(x) = "abc" {
    |        ^^^^^^^^^^^^^^^^^^ help: try: `"abc" == m1!(x)`
 
-error: aborting due to 11 previous errors
+error: aborting due to 14 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From a0afbdfbec5923850ae20c77a2f466b904dae04c Mon Sep 17 00:00:00 2001
From: Michael Wright <mikerite@lavabit.com>
Date: Wed, 24 Aug 2022 08:11:29 +0200
Subject: Replace `contains_ty(..)` with `Ty::contains(..)`

This removes some code we don't need and the method syntax is
also more readable IMO.
---
 clippy_lints/src/dereference.rs                  | 4 ++--
 clippy_lints/src/escape.rs                       | 3 +--
 clippy_lints/src/methods/mod.rs                  | 8 ++++----
 clippy_lints/src/methods/unnecessary_to_owned.rs | 5 ++---
 clippy_lints/src/self_named_constructors.rs      | 4 ++--
 clippy_utils/src/ty.rs                           | 8 --------
 6 files changed, 11 insertions(+), 21 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index e38704701ea..abe01d6e2c4 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_hir_and_then};
 use clippy_utils::source::{snippet_with_applicability, snippet_with_context};
 use clippy_utils::sugg::has_enclosing_paren;
-use clippy_utils::ty::{contains_ty, expr_sig, is_copy, peel_mid_ty_refs, ty_sig, variant_of_res};
+use clippy_utils::ty::{expr_sig, is_copy, peel_mid_ty_refs, ty_sig, variant_of_res};
 use clippy_utils::{fn_def_id, get_parent_expr, is_lint_allowed, meets_msrv, msrvs, path_to_local, walk_to_expr_usage};
 use rustc_ast::util::parser::{PREC_POSTFIX, PREC_PREFIX};
 use rustc_data_structures::fx::FxIndexMap;
@@ -1158,7 +1158,7 @@ fn replace_types<'tcx>(
             .inputs_and_output
             .iter()
             .enumerate()
-            .all(|(i, ty)| (replaced.is_empty() && i == arg_index) || !contains_ty(ty, param_ty.to_ty(cx.tcx)))
+            .all(|(i, ty)| (replaced.is_empty() && i == arg_index) || !ty.contains(param_ty.to_ty(cx.tcx)))
         {
             return false;
         }
diff --git a/clippy_lints/src/escape.rs b/clippy_lints/src/escape.rs
index 0a4a0ebb3f9..327865e4c85 100644
--- a/clippy_lints/src/escape.rs
+++ b/clippy_lints/src/escape.rs
@@ -1,5 +1,4 @@
 use clippy_utils::diagnostics::span_lint_hir;
-use clippy_utils::ty::contains_ty;
 use rustc_hir::intravisit;
 use rustc_hir::{self, AssocItemKind, Body, FnDecl, HirId, HirIdSet, Impl, ItemKind, Node, Pat, PatKind};
 use rustc_infer::infer::TyCtxtInferExt;
@@ -166,7 +165,7 @@ impl<'a, 'tcx> Delegate<'tcx> for EscapeDelegate<'a, 'tcx> {
                 // skip if there is a `self` parameter binding to a type
                 // that contains `Self` (i.e.: `self: Box<Self>`), see #4804
                 if let Some(trait_self_ty) = self.trait_self_ty {
-                    if map.name(cmt.hir_id) == kw::SelfLower && contains_ty(cmt.place.ty(), trait_self_ty) {
+                    if map.name(cmt.hir_id) == kw::SelfLower && cmt.place.ty().contains(trait_self_ty) {
                         return;
                     }
                 }
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 49d4900295f..0ec35ddc1db 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -99,7 +99,7 @@ mod zst_offset;
 use bind_instead_of_map::BindInsteadOfMap;
 use clippy_utils::consts::{constant, Constant};
 use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
-use clippy_utils::ty::{contains_adt_constructor, contains_ty, implements_trait, is_copy, is_type_diagnostic_item};
+use clippy_utils::ty::{contains_adt_constructor, implements_trait, is_copy, is_type_diagnostic_item};
 use clippy_utils::{
     contains_return, get_trait_def_id, is_trait_method, iter_input_pats, meets_msrv, msrvs, paths, return_ty,
 };
@@ -3242,7 +3242,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
                 if contains_adt_constructor(ret_ty, self_adt) {
                     return;
                 }
-            } else if contains_ty(ret_ty, self_ty) {
+            } else if ret_ty.contains(self_ty) {
                 return;
             }
 
@@ -3260,7 +3260,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
                             if contains_adt_constructor(assoc_ty, self_adt) {
                                 return;
                             }
-                        } else if contains_ty(assoc_ty, self_ty) {
+                        } else if assoc_ty.contains(self_ty) {
                             return;
                         }
                     }
@@ -3309,7 +3309,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             if let TraitItemKind::Fn(_, _) = item.kind;
             let ret_ty = return_ty(cx, item.hir_id());
             let self_ty = TraitRef::identity(cx.tcx, item.def_id.to_def_id()).self_ty().skip_binder();
-            if !contains_ty(ret_ty, self_ty);
+            if !ret_ty.contains(self_ty);
 
             then {
                 span_lint(
diff --git a/clippy_lints/src/methods/unnecessary_to_owned.rs b/clippy_lints/src/methods/unnecessary_to_owned.rs
index e4624167ad0..44bf8435294 100644
--- a/clippy_lints/src/methods/unnecessary_to_owned.rs
+++ b/clippy_lints/src/methods/unnecessary_to_owned.rs
@@ -3,8 +3,7 @@ use super::unnecessary_iter_cloned::{self, is_into_iter};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::{
-    contains_ty, get_associated_type, get_iterator_item_ty, implements_trait, is_copy, is_type_diagnostic_item,
-    peel_mid_ty_refs,
+    get_associated_type, get_iterator_item_ty, implements_trait, is_copy, is_type_diagnostic_item, peel_mid_ty_refs,
 };
 use clippy_utils::{fn_def_id, get_parent_expr, is_diag_item_method, is_diag_trait_item};
 use clippy_utils::{meets_msrv, msrvs};
@@ -304,7 +303,7 @@ fn check_other_call_arg<'tcx>(
         // (https://github.com/rust-lang/rust-clippy/issues/8507).
         if (n_refs == 0 && !receiver_ty.is_ref())
             || trait_predicate.def_id() != as_ref_trait_id
-            || !contains_ty(fn_sig.output(), input);
+            || !fn_sig.output().contains(input);
         if let Some(receiver_snippet) = snippet_opt(cx, receiver.span);
         then {
             span_lint_and_sugg(
diff --git a/clippy_lints/src/self_named_constructors.rs b/clippy_lints/src/self_named_constructors.rs
index d07c26d7c89..9cea4d88067 100644
--- a/clippy_lints/src/self_named_constructors.rs
+++ b/clippy_lints/src/self_named_constructors.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::return_ty;
-use clippy_utils::ty::{contains_adt_constructor, contains_ty};
+use clippy_utils::ty::contains_adt_constructor;
 use rustc_hir::{Impl, ImplItem, ImplItemKind, ItemKind, Node};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -66,7 +66,7 @@ impl<'tcx> LateLintPass<'tcx> for SelfNamedConstructors {
             if !contains_adt_constructor(ret_ty, self_adt) {
                 return;
             }
-        } else if !contains_ty(ret_ty, self_ty) {
+        } else if !ret_ty.contains(self_ty) {
             return;
         }
 
diff --git a/clippy_utils/src/ty.rs b/clippy_utils/src/ty.rs
index edbe9c5a897..00182e739b8 100644
--- a/clippy_utils/src/ty.rs
+++ b/clippy_utils/src/ty.rs
@@ -43,14 +43,6 @@ pub fn can_partially_move_ty<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool
     }
 }
 
-/// Walks into `ty` and returns `true` if any inner type is the same as `other_ty`
-pub fn contains_ty<'tcx>(ty: Ty<'tcx>, other_ty: Ty<'tcx>) -> bool {
-    ty.walk().any(|inner| match inner.unpack() {
-        GenericArgKind::Type(inner_ty) => other_ty == inner_ty,
-        GenericArgKind::Lifetime(_) | GenericArgKind::Const(_) => false,
-    })
-}
-
 /// Walks into `ty` and returns `true` if any inner type is an instance of the given adt
 /// constructor.
 pub fn contains_adt_constructor<'tcx>(ty: Ty<'tcx>, adt: AdtDef<'tcx>) -> bool {
-- 
cgit 1.4.1-3-g733a5


From 61aa4efbf15b69c7d41e6c267881d4c336ebdd4a Mon Sep 17 00:00:00 2001
From: Alexander Clausen <a.clausen@fz-juelich.de>
Date: Thu, 25 Aug 2022 14:10:55 +0200
Subject: uninit_vec: Vec::spare_capacity_mut is stable

Quick documentation fix: `Vec::spare_capacity_mut` no longer needs nightly.
---
 clippy_lints/src/uninit_vec.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/uninit_vec.rs b/clippy_lints/src/uninit_vec.rs
index 9f4c5555f11..9a41603f2f4 100644
--- a/clippy_lints/src/uninit_vec.rs
+++ b/clippy_lints/src/uninit_vec.rs
@@ -45,7 +45,7 @@ declare_clippy_lint! {
     ///    let mut vec: Vec<MaybeUninit<T>> = Vec::with_capacity(1000);
     ///    vec.set_len(1000);  // `MaybeUninit` can be uninitialized
     ///    ```
-    /// 3. If you are on nightly, `Vec::spare_capacity_mut()` is available:
+    /// 3. If you are on 1.60.0 or later, `Vec::spare_capacity_mut()` is available:
     ///    ```rust,ignore
     ///    let mut vec: Vec<u8> = Vec::with_capacity(1000);
     ///    let remaining = vec.spare_capacity_mut();  // `&mut [MaybeUninit<u8>]`
-- 
cgit 1.4.1-3-g733a5


From fb7dffeac9df2f15c70c84c5defa5918af63b6af Mon Sep 17 00:00:00 2001
From: royrustdev <royrustdev@gmail.com>
Date: Fri, 26 Aug 2022 12:46:41 +0530
Subject: add `multi_assignments` lint

---
 CHANGELOG.md                                |  1 +
 clippy_lints/src/lib.register_all.rs        |  1 +
 clippy_lints/src/lib.register_lints.rs      |  1 +
 clippy_lints/src/lib.register_suspicious.rs |  1 +
 clippy_lints/src/lib.rs                     |  2 +
 clippy_lints/src/multi_assignments.rs       | 65 +++++++++++++++++++++++++++++
 tests/ui/multi_assignments.rs               |  9 ++++
 tests/ui/multi_assignments.stderr           | 40 ++++++++++++++++++
 8 files changed, 120 insertions(+)
 create mode 100644 clippy_lints/src/multi_assignments.rs
 create mode 100644 tests/ui/multi_assignments.rs
 create mode 100644 tests/ui/multi_assignments.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index caa488a7a9c..c285c1e6859 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3897,6 +3897,7 @@ Released 2018-09-13
 [`module_name_repetitions`]: https://rust-lang.github.io/rust-clippy/master/index.html#module_name_repetitions
 [`modulo_arithmetic`]: https://rust-lang.github.io/rust-clippy/master/index.html#modulo_arithmetic
 [`modulo_one`]: https://rust-lang.github.io/rust-clippy/master/index.html#modulo_one
+[`multi_assignments`]: https://rust-lang.github.io/rust-clippy/master/index.html#multi_assignments
 [`multiple_crate_versions`]: https://rust-lang.github.io/rust-clippy/master/index.html#multiple_crate_versions
 [`multiple_inherent_impl`]: https://rust-lang.github.io/rust-clippy/master/index.html#multiple_inherent_impl
 [`must_use_candidate`]: https://rust-lang.github.io/rust-clippy/master/index.html#must_use_candidate
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index dac6aed61c0..eaeb201ff50 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -233,6 +233,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(misc_early::UNNEEDED_WILDCARD_PATTERN),
     LintId::of(misc_early::ZERO_PREFIXED_LITERAL),
     LintId::of(mixed_read_write_in_expression::DIVERGING_SUB_EXPRESSION),
+    LintId::of(multi_assignments::MULTI_ASSIGNMENTS),
     LintId::of(mut_key::MUTABLE_KEY_TYPE),
     LintId::of(mut_reference::UNNECESSARY_MUT_PASSED),
     LintId::of(needless_arbitrary_self_type::NEEDLESS_ARBITRARY_SELF_TYPE),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index be58e144184..e058c45217e 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -398,6 +398,7 @@ store.register_lints(&[
     mixed_read_write_in_expression::MIXED_READ_WRITE_IN_EXPRESSION,
     module_style::MOD_MODULE_FILES,
     module_style::SELF_NAMED_MODULE_FILES,
+    multi_assignments::MULTI_ASSIGNMENTS,
     mut_key::MUTABLE_KEY_TYPE,
     mut_mut::MUT_MUT,
     mut_reference::UNNECESSARY_MUT_PASSED,
diff --git a/clippy_lints/src/lib.register_suspicious.rs b/clippy_lints/src/lib.register_suspicious.rs
index 369d4b4eed6..6f480c52cc9 100644
--- a/clippy_lints/src/lib.register_suspicious.rs
+++ b/clippy_lints/src/lib.register_suspicious.rs
@@ -24,6 +24,7 @@ store.register_group(true, "clippy::suspicious", Some("clippy_suspicious"), vec!
     LintId::of(loops::MUT_RANGE_BOUND),
     LintId::of(methods::NO_EFFECT_REPLACE),
     LintId::of(methods::SUSPICIOUS_MAP),
+    LintId::of(multi_assignments::MULTI_ASSIGNMENTS),
     LintId::of(mut_key::MUTABLE_KEY_TYPE),
     LintId::of(octal_escapes::OCTAL_ESCAPES),
     LintId::of(operators::FLOAT_EQUALITY_WITHOUT_ABS),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 64c43d9acc4..a3a4267abea 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -289,6 +289,7 @@ mod missing_enforced_import_rename;
 mod missing_inline;
 mod mixed_read_write_in_expression;
 mod module_style;
+mod multi_assignments;
 mod mut_key;
 mod mut_mut;
 mod mut_reference;
@@ -896,6 +897,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(partialeq_to_none::PartialeqToNone));
     store.register_late_pass(|| Box::new(manual_empty_string_creations::ManualEmptyStringCreations));
     store.register_late_pass(|| Box::new(unused_peekable::UnusedPeekable));
+    store.register_early_pass(|| Box::new(multi_assignments::MultiAssignments));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/multi_assignments.rs b/clippy_lints/src/multi_assignments.rs
new file mode 100644
index 00000000000..81eb1a085ae
--- /dev/null
+++ b/clippy_lints/src/multi_assignments.rs
@@ -0,0 +1,65 @@
+use clippy_utils::diagnostics::span_lint;
+use rustc_ast::ast::{Expr, ExprKind, Stmt, StmtKind};
+use rustc_lint::{EarlyContext, EarlyLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for nested assignments.
+    ///
+    /// ### Why is this bad?
+    /// While this is in most cases already a type mismatch,
+    /// the result of an assignment being `()` can throw off people coming from languages like python or C,
+    /// where such assignments return a copy of the assigned value.
+    ///
+    /// ### Example
+    /// ```rust
+    ///# let (a, b);
+    /// a = b = 42;
+    /// ```
+    /// Use instead:
+    /// ```rust
+    ///# let (a, b);
+    /// b = 42;
+    /// a = b;
+    /// ```
+    #[clippy::version = "1.65.0"]
+    pub MULTI_ASSIGNMENTS,
+    suspicious,
+    "instead of using `a = b = c;` use `a = c; b = c;`"
+}
+
+declare_lint_pass!(MultiAssignments => [MULTI_ASSIGNMENTS]);
+
+fn strip_paren_blocks(expr: &Expr) -> &Expr {
+    match &expr.kind {
+        ExprKind::Paren(e) => strip_paren_blocks(e),
+        ExprKind::Block(b, _) => {
+            if let [
+                Stmt {
+                    kind: StmtKind::Expr(e),
+                    ..
+                },
+            ] = &b.stmts[..]
+            {
+                strip_paren_blocks(e)
+            } else {
+                expr
+            }
+        },
+        _ => expr,
+    }
+}
+
+impl EarlyLintPass for MultiAssignments {
+    fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
+        if let ExprKind::Assign(target, source, _) = &expr.kind {
+            if let ExprKind::Assign(_target, _source, _) = &strip_paren_blocks(target).kind {
+                span_lint(cx, MULTI_ASSIGNMENTS, expr.span, "assignments don't nest intuitively");
+            };
+            if let ExprKind::Assign(_target, _source, _) = &strip_paren_blocks(source).kind {
+                span_lint(cx, MULTI_ASSIGNMENTS, expr.span, "assignments don't nest intuitively");
+            }
+        };
+    }
+}
diff --git a/tests/ui/multi_assignments.rs b/tests/ui/multi_assignments.rs
new file mode 100644
index 00000000000..b186bf8bbdb
--- /dev/null
+++ b/tests/ui/multi_assignments.rs
@@ -0,0 +1,9 @@
+#![warn(clippy::multi_assignments)]
+fn main() {
+    let (mut a, mut b, mut c, mut d) = ((), (), (), ());
+    a = b = c;
+    a = b = c = d;
+    a = b = { c };
+    a = { b = c };
+    a = (b = c);
+}
diff --git a/tests/ui/multi_assignments.stderr b/tests/ui/multi_assignments.stderr
new file mode 100644
index 00000000000..d6c42bb698c
--- /dev/null
+++ b/tests/ui/multi_assignments.stderr
@@ -0,0 +1,40 @@
+error: assignments don't nest intuitively
+  --> $DIR/multi_assignments.rs:4:5
+   |
+LL |     a = b = c;
+   |     ^^^^^^^^^
+   |
+   = note: `-D clippy::multi-assignments` implied by `-D warnings`
+
+error: assignments don't nest intuitively
+  --> $DIR/multi_assignments.rs:5:5
+   |
+LL |     a = b = c = d;
+   |     ^^^^^^^^^^^^^
+
+error: assignments don't nest intuitively
+  --> $DIR/multi_assignments.rs:5:9
+   |
+LL |     a = b = c = d;
+   |         ^^^^^^^^^
+
+error: assignments don't nest intuitively
+  --> $DIR/multi_assignments.rs:6:5
+   |
+LL |     a = b = { c };
+   |     ^^^^^^^^^^^^^
+
+error: assignments don't nest intuitively
+  --> $DIR/multi_assignments.rs:7:5
+   |
+LL |     a = { b = c };
+   |     ^^^^^^^^^^^^^
+
+error: assignments don't nest intuitively
+  --> $DIR/multi_assignments.rs:8:5
+   |
+LL |     a = (b = c);
+   |     ^^^^^^^^^^^
+
+error: aborting due to 6 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From fe93b8d001bf82b0789c7aac33511a5f9bd65045 Mon Sep 17 00:00:00 2001
From: Lukas Lueg <lukas.lueg@gmail.com>
Date: Fri, 26 Aug 2022 19:06:07 +0200
Subject: Don't lint `needless_return` if `return` has attrs

Fixes #9361
---
 clippy_lints/src/returns.rs    | 10 +---------
 tests/ui/needless_return.fixed | 10 +++-------
 tests/ui/needless_return.rs    | 10 +++-------
 3 files changed, 7 insertions(+), 23 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
index 1d9a2abf706..1926661c596 100644
--- a/clippy_lints/src/returns.rs
+++ b/clippy_lints/src/returns.rs
@@ -2,7 +2,6 @@ use clippy_utils::diagnostics::span_lint_hir_and_then;
 use clippy_utils::source::{snippet_opt, snippet_with_context};
 use clippy_utils::{fn_def_id, path_to_local_id};
 use if_chain::if_chain;
-use rustc_ast::ast::Attribute;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_expr, FnKind, Visitor};
 use rustc_hir::{Block, Body, Expr, ExprKind, FnDecl, HirId, MatchSource, PatKind, StmtKind};
@@ -11,7 +10,6 @@ use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::subst::GenericArgKind;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
-use rustc_span::sym;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -152,10 +150,6 @@ impl<'tcx> LateLintPass<'tcx> for Return {
     }
 }
 
-fn attr_is_cfg(attr: &Attribute) -> bool {
-    attr.meta_item_list().is_some() && attr.has_name(sym::cfg)
-}
-
 fn check_block_return<'tcx>(cx: &LateContext<'tcx>, block: &Block<'tcx>) {
     if let Some(expr) = block.expr {
         check_final_expr(cx, expr, Some(expr.span), RetReplacement::Empty);
@@ -178,9 +172,7 @@ fn check_final_expr<'tcx>(
     match expr.kind {
         // simple return is always "bad"
         ExprKind::Ret(ref inner) => {
-            // allow `#[cfg(a)] return a; #[cfg(b)] return b;`
-            let attrs = cx.tcx.hir().attrs(expr.hir_id);
-            if !attrs.iter().any(attr_is_cfg) {
+            if cx.tcx.hir().attrs(expr.hir_id).is_empty() {
                 let borrows = inner.map_or(false, |inner| last_statement_borrows(cx, inner));
                 if !borrows {
                     emit_return_lint(
diff --git a/tests/ui/needless_return.fixed b/tests/ui/needless_return.fixed
index 0bc0d0011ef..87c8fc03b3c 100644
--- a/tests/ui/needless_return.fixed
+++ b/tests/ui/needless_return.fixed
@@ -228,13 +228,9 @@ fn needless_return_macro() -> String {
     format!("Hello {}", "world!")
 }
 
-fn check_expect() -> bool {
-    if true {
-        // no error!
-        return true;
-    }
-    #[expect(clippy::needless_return)]
-    return true;
+fn issue_9361() -> i32 {
+    #[allow(clippy::integer_arithmetic)]
+    return 1 + 2;
 }
 
 fn main() {}
diff --git a/tests/ui/needless_return.rs b/tests/ui/needless_return.rs
index eb9f72e8e78..5a86e656255 100644
--- a/tests/ui/needless_return.rs
+++ b/tests/ui/needless_return.rs
@@ -228,13 +228,9 @@ fn needless_return_macro() -> String {
     return format!("Hello {}", "world!");
 }
 
-fn check_expect() -> bool {
-    if true {
-        // no error!
-        return true;
-    }
-    #[expect(clippy::needless_return)]
-    return true;
+fn issue_9361() -> i32 {
+    #[allow(clippy::integer_arithmetic)]
+    return 1 + 2;
 }
 
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From de028e2fb9d81d58d62dfc7bc8fd2335a9885641 Mon Sep 17 00:00:00 2001
From: Marco Mastropaolo <marco@mastropaolo.com>
Date: Fri, 10 Jun 2022 18:28:31 +0200
Subject: Implemented suspicious_to_owned lint to check if `to_owned` is called
 on a `Cow`.

This is done because `to_owned` is very similarly named to `into_owned`, but the
effect of calling those two methods is completely different. This creates
confusion (stemming from the ambiguity of the 'owned' term in the context of
`Cow`s) and might not be what the writer intended.
---
 CHANGELOG.md                                    |  1 +
 clippy_lints/src/lib.register_all.rs            |  1 +
 clippy_lints/src/lib.register_lints.rs          |  1 +
 clippy_lints/src/lib.register_suspicious.rs     |  1 +
 clippy_lints/src/methods/mod.rs                 | 58 ++++++++++++++++++++++-
 clippy_lints/src/methods/suspicious_to_owned.rs | 36 ++++++++++++++
 tests/compile-test.rs                           |  1 +
 tests/ui/suspicious_to_owned.rs                 | 62 +++++++++++++++++++++++++
 tests/ui/suspicious_to_owned.stderr             | 42 +++++++++++++++++
 9 files changed, 202 insertions(+), 1 deletion(-)
 create mode 100644 clippy_lints/src/methods/suspicious_to_owned.rs
 create mode 100644 tests/ui/suspicious_to_owned.rs
 create mode 100644 tests/ui/suspicious_to_owned.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 964f339b26c..a076997eebd 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4082,6 +4082,7 @@ Released 2018-09-13
 [`suspicious_op_assign_impl`]: https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_op_assign_impl
 [`suspicious_operation_groupings`]: https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_operation_groupings
 [`suspicious_splitn`]: https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_splitn
+[`suspicious_to_owned`]: https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_to_owned
 [`suspicious_unary_op_formatting`]: https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_unary_op_formatting
 [`swap_ptr_to_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#swap_ptr_to_ref
 [`tabs_in_doc_comments`]: https://rust-lang.github.io/rust-clippy/master/index.html#tabs_in_doc_comments
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 61bb5d1337c..64982851b56 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -207,6 +207,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(methods::STRING_EXTEND_CHARS),
     LintId::of(methods::SUSPICIOUS_MAP),
     LintId::of(methods::SUSPICIOUS_SPLITN),
+    LintId::of(methods::SUSPICIOUS_TO_OWNED),
     LintId::of(methods::UNINIT_ASSUMED_INIT),
     LintId::of(methods::UNIT_HASH),
     LintId::of(methods::UNNECESSARY_FILTER_MAP),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 0ec2884cb6b..fbf77fb734f 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -358,6 +358,7 @@ store.register_lints(&[
     methods::STRING_EXTEND_CHARS,
     methods::SUSPICIOUS_MAP,
     methods::SUSPICIOUS_SPLITN,
+    methods::SUSPICIOUS_TO_OWNED,
     methods::UNINIT_ASSUMED_INIT,
     methods::UNIT_HASH,
     methods::UNNECESSARY_FILTER_MAP,
diff --git a/clippy_lints/src/lib.register_suspicious.rs b/clippy_lints/src/lib.register_suspicious.rs
index 6f480c52cc9..aa4e571dbe2 100644
--- a/clippy_lints/src/lib.register_suspicious.rs
+++ b/clippy_lints/src/lib.register_suspicious.rs
@@ -24,6 +24,7 @@ store.register_group(true, "clippy::suspicious", Some("clippy_suspicious"), vec!
     LintId::of(loops::MUT_RANGE_BOUND),
     LintId::of(methods::NO_EFFECT_REPLACE),
     LintId::of(methods::SUSPICIOUS_MAP),
+    LintId::of(methods::SUSPICIOUS_TO_OWNED),
     LintId::of(multi_assignments::MULTI_ASSIGNMENTS),
     LintId::of(mut_key::MUTABLE_KEY_TYPE),
     LintId::of(octal_escapes::OCTAL_ESCAPES),
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 0ec35ddc1db..a0d190a58af 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -78,6 +78,7 @@ mod str_splitn;
 mod string_extend_chars;
 mod suspicious_map;
 mod suspicious_splitn;
+mod suspicious_to_owned;
 mod uninit_assumed_init;
 mod unit_hash;
 mod unnecessary_filter_map;
@@ -2053,6 +2054,55 @@ declare_clippy_lint! {
     "replace `.iter().count()` with `.len()`"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for the usage of `_.to_owned()`, on a `Cow<'_, _>`.
+    ///
+    /// ### Why is this bad?
+    /// Calling `to_owned()` on a `Cow` creates a clone of the `Cow`
+    /// itself, without taking ownership of the `Cow` contents (i.e.
+    /// it's equivalent to calling `Cow::clone`).
+    /// The similarly named `into_owned` method, on the other hand,
+    /// clones the `Cow` contents, effectively turning any `Cow::Borrowed`
+    /// into a `Cow::Owned`.
+    ///
+    /// Given the potential ambiguity, consider replacing `to_owned`
+    /// with `clone` for better readability or, if getting a `Cow::Owned`
+    /// was the original intent, using `into_owned` instead.
+    ///
+    /// ### Example
+    /// ```rust
+    /// # use std::borrow::Cow;
+    /// let s = "Hello world!";
+    /// let cow = Cow::Borrowed(s);
+    ///
+    /// let data = cow.to_owned();
+    /// assert!(matches!(data, Cow::Borrowed(_)))
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// # use std::borrow::Cow;
+    /// let s = "Hello world!";
+    /// let cow = Cow::Borrowed(s);
+    ///
+    /// let data = cow.clone();
+    /// assert!(matches!(data, Cow::Borrowed(_)))
+    /// ```
+    /// or
+    /// ```rust
+    /// # use std::borrow::Cow;
+    /// let s = "Hello world!";
+    /// let cow = Cow::Borrowed(s);
+    ///
+    /// let data = cow.into_owned();
+    /// assert!(matches!(data, String))
+    /// ```
+    #[clippy::version = "1.65.0"]
+    pub SUSPICIOUS_TO_OWNED,
+    suspicious,
+    "calls to `to_owned` on a `Cow<'_, _>` might not do what they are expected"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for calls to [`splitn`]
@@ -3075,6 +3125,7 @@ impl_lint_pass!(Methods => [
     FROM_ITER_INSTEAD_OF_COLLECT,
     INSPECT_FOR_EACH,
     IMPLICIT_CLONE,
+    SUSPICIOUS_TO_OWNED,
     SUSPICIOUS_SPLITN,
     MANUAL_STR_REPEAT,
     EXTEND_WITH_DRAIN,
@@ -3553,7 +3604,12 @@ impl Methods {
                     }
                     unnecessary_lazy_eval::check(cx, expr, recv, arg, "then_some");
                 },
-                ("to_os_string" | "to_owned" | "to_path_buf" | "to_vec", []) => {
+                ("to_owned", []) => {
+                    if !suspicious_to_owned::check(cx, expr, recv) {
+                        implicit_clone::check(cx, name, expr, recv);
+                    }
+                },
+                ("to_os_string" | "to_path_buf" | "to_vec", []) => {
                     implicit_clone::check(cx, name, expr, recv);
                 },
                 ("unwrap", []) => {
diff --git a/clippy_lints/src/methods/suspicious_to_owned.rs b/clippy_lints/src/methods/suspicious_to_owned.rs
new file mode 100644
index 00000000000..6b306fbf008
--- /dev/null
+++ b/clippy_lints/src/methods/suspicious_to_owned.rs
@@ -0,0 +1,36 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::is_diag_trait_item;
+use clippy_utils::source::snippet_with_context;
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir as hir;
+use rustc_lint::LateContext;
+use rustc_middle::ty;
+use rustc_span::sym;
+
+use super::SUSPICIOUS_TO_OWNED;
+
+pub fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr<'_>) -> bool {
+    if_chain! {
+        if let Some(method_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
+        if is_diag_trait_item(cx, method_def_id, sym::ToOwned);
+        let input_type = cx.typeck_results().expr_ty(expr);
+        if let ty::Adt(adt, _) = cx.typeck_results().expr_ty(expr).kind();
+        if cx.tcx.is_diagnostic_item(sym::Cow, adt.did());
+        then {
+            let mut app = Applicability::MaybeIncorrect;
+            let recv_snip = snippet_with_context(cx, recv.span, expr.span.ctxt(), "..", &mut app).0;
+            span_lint_and_sugg(
+                cx,
+                SUSPICIOUS_TO_OWNED,
+                expr.span,
+                &format!("this `to_owned` call clones the {0} itself and does not cause the {0} contents to become owned", input_type),
+                "consider using, depending on intent",
+                format!("{0}.clone()` or `{0}.into_owned()", recv_snip),
+                app,
+            );
+            return true;
+        }
+    }
+    false
+}
diff --git a/tests/compile-test.rs b/tests/compile-test.rs
index 5431f2ebc0a..ba6186e599e 100644
--- a/tests/compile-test.rs
+++ b/tests/compile-test.rs
@@ -393,6 +393,7 @@ const RUSTFIX_COVERAGE_KNOWN_EXCEPTIONS: &[&str] = &[
     "search_is_some.rs",
     "single_component_path_imports_nested_first.rs",
     "string_add.rs",
+    "suspicious_to_owned.rs",
     "toplevel_ref_arg_non_rustfix.rs",
     "unit_arg.rs",
     "unnecessary_clone.rs",
diff --git a/tests/ui/suspicious_to_owned.rs b/tests/ui/suspicious_to_owned.rs
new file mode 100644
index 00000000000..a90e78a0ea0
--- /dev/null
+++ b/tests/ui/suspicious_to_owned.rs
@@ -0,0 +1,62 @@
+#![warn(clippy::suspicious_to_owned)]
+#![warn(clippy::implicit_clone)]
+#![allow(clippy::redundant_clone)]
+use std::borrow::Cow;
+use std::ffi::CStr;
+
+fn main() {
+    let moo = "Moooo";
+    let c_moo = b"Moooo\0";
+    let c_moo_ptr = c_moo.as_ptr() as *const i8;
+    let moos = ['M', 'o', 'o'];
+    let moos_vec = moos.to_vec();
+
+    // we expect this to be linted
+    let cow = Cow::Borrowed(moo);
+    let _ = cow.to_owned();
+    // we expect no lints for this
+    let cow = Cow::Borrowed(moo);
+    let _ = cow.into_owned();
+    // we expect no lints for this
+    let cow = Cow::Borrowed(moo);
+    let _ = cow.clone();
+
+    // we expect this to be linted
+    let cow = Cow::Borrowed(&moos);
+    let _ = cow.to_owned();
+    // we expect no lints for this
+    let cow = Cow::Borrowed(&moos);
+    let _ = cow.into_owned();
+    // we expect no lints for this
+    let cow = Cow::Borrowed(&moos);
+    let _ = cow.clone();
+
+    // we expect this to be linted
+    let cow = Cow::Borrowed(&moos_vec);
+    let _ = cow.to_owned();
+    // we expect no lints for this
+    let cow = Cow::Borrowed(&moos_vec);
+    let _ = cow.into_owned();
+    // we expect no lints for this
+    let cow = Cow::Borrowed(&moos_vec);
+    let _ = cow.clone();
+
+    // we expect this to be linted
+    let cow = unsafe { CStr::from_ptr(c_moo_ptr) }.to_string_lossy();
+    let _ = cow.to_owned();
+    // we expect no lints for this
+    let cow = unsafe { CStr::from_ptr(c_moo_ptr) }.to_string_lossy();
+    let _ = cow.into_owned();
+    // we expect no lints for this
+    let cow = unsafe { CStr::from_ptr(c_moo_ptr) }.to_string_lossy();
+    let _ = cow.clone();
+
+    // we expect no lints for these
+    let _ = moo.to_owned();
+    let _ = c_moo.to_owned();
+    let _ = moos.to_owned();
+
+    // we expect implicit_clone lints for these
+    let _ = String::from(moo).to_owned();
+    let _ = moos_vec.to_owned();
+}
diff --git a/tests/ui/suspicious_to_owned.stderr b/tests/ui/suspicious_to_owned.stderr
new file mode 100644
index 00000000000..92e1024bf1f
--- /dev/null
+++ b/tests/ui/suspicious_to_owned.stderr
@@ -0,0 +1,42 @@
+error: this `to_owned` call clones the std::borrow::Cow<str> itself and does not cause the std::borrow::Cow<str> contents to become owned
+  --> $DIR/suspicious_to_owned.rs:16:13
+   |
+LL |     let _ = cow.to_owned();
+   |             ^^^^^^^^^^^^^^ help: consider using, depending on intent: `cow.clone()` or `cow.into_owned()`
+   |
+   = note: `-D clippy::suspicious-to-owned` implied by `-D warnings`
+
+error: this `to_owned` call clones the std::borrow::Cow<[char; 3]> itself and does not cause the std::borrow::Cow<[char; 3]> contents to become owned
+  --> $DIR/suspicious_to_owned.rs:26:13
+   |
+LL |     let _ = cow.to_owned();
+   |             ^^^^^^^^^^^^^^ help: consider using, depending on intent: `cow.clone()` or `cow.into_owned()`
+
+error: this `to_owned` call clones the std::borrow::Cow<std::vec::Vec<char>> itself and does not cause the std::borrow::Cow<std::vec::Vec<char>> contents to become owned
+  --> $DIR/suspicious_to_owned.rs:36:13
+   |
+LL |     let _ = cow.to_owned();
+   |             ^^^^^^^^^^^^^^ help: consider using, depending on intent: `cow.clone()` or `cow.into_owned()`
+
+error: this `to_owned` call clones the std::borrow::Cow<str> itself and does not cause the std::borrow::Cow<str> contents to become owned
+  --> $DIR/suspicious_to_owned.rs:46:13
+   |
+LL |     let _ = cow.to_owned();
+   |             ^^^^^^^^^^^^^^ help: consider using, depending on intent: `cow.clone()` or `cow.into_owned()`
+
+error: implicitly cloning a `String` by calling `to_owned` on its dereferenced type
+  --> $DIR/suspicious_to_owned.rs:60:13
+   |
+LL |     let _ = String::from(moo).to_owned();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `String::from(moo).clone()`
+   |
+   = note: `-D clippy::implicit-clone` implied by `-D warnings`
+
+error: implicitly cloning a `Vec` by calling `to_owned` on its dereferenced type
+  --> $DIR/suspicious_to_owned.rs:61:13
+   |
+LL |     let _ = moos_vec.to_owned();
+   |             ^^^^^^^^^^^^^^^^^^^ help: consider using: `moos_vec.clone()`
+
+error: aborting due to 6 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 90fe3bea52dd6ebd0cb02785ba523f182ff761e6 Mon Sep 17 00:00:00 2001
From: Andre Bogus <bogusandre@gmail.com>
Date: Sat, 27 Aug 2022 12:04:19 +0200
Subject: remove parenthesis from unnecessary_cast suggestion

---
 clippy_lints/src/casts/unnecessary_cast.rs |  9 ++++++++-
 tests/ui/unnecessary_cast.fixed            |  9 +++++++++
 tests/ui/unnecessary_cast.rs               |  9 +++++++++
 tests/ui/unnecessary_cast.stderr           | 14 +++++++++++++-
 4 files changed, 39 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/unnecessary_cast.rs b/clippy_lints/src/casts/unnecessary_cast.rs
index fff7da8e33f..19d2e6e1d12 100644
--- a/clippy_lints/src/casts/unnecessary_cast.rs
+++ b/clippy_lints/src/casts/unnecessary_cast.rs
@@ -90,13 +90,20 @@ pub(super) fn check<'tcx>(
 
 fn lint_unnecessary_cast(cx: &LateContext<'_>, expr: &Expr<'_>, literal_str: &str, cast_from: Ty<'_>, cast_to: Ty<'_>) {
     let literal_kind_name = if cast_from.is_integral() { "integer" } else { "float" };
+    let replaced_literal;
+    let matchless = if literal_str.contains(['(', ')']) {
+        replaced_literal = literal_str.replace(['(', ')'], "");
+        &replaced_literal
+    } else {
+        literal_str
+    };
     span_lint_and_sugg(
         cx,
         UNNECESSARY_CAST,
         expr.span,
         &format!("casting {} literal to `{}` is unnecessary", literal_kind_name, cast_to),
         "try",
-        format!("{}_{}", literal_str.trim_end_matches('.'), cast_to),
+        format!("{}_{}", matchless.trim_end_matches('.'), cast_to),
         Applicability::MachineApplicable,
     );
 }
diff --git a/tests/ui/unnecessary_cast.fixed b/tests/ui/unnecessary_cast.fixed
index b352b285c86..ee9f157342d 100644
--- a/tests/ui/unnecessary_cast.fixed
+++ b/tests/ui/unnecessary_cast.fixed
@@ -88,4 +88,13 @@ mod fixable {
     }
 
     type I32Alias = i32;
+
+    fn issue_9380() {
+        let _: i32 = -1_i32;
+        let _: f32 = -(1) as f32;
+        let _: i64 = -1_i64;
+        let _: i64 = -(1.0) as i64;
+
+        let _ = -(1 + 1) as i64;
+    }
 }
diff --git a/tests/ui/unnecessary_cast.rs b/tests/ui/unnecessary_cast.rs
index 6c8cc3effe8..5b70412424c 100644
--- a/tests/ui/unnecessary_cast.rs
+++ b/tests/ui/unnecessary_cast.rs
@@ -88,4 +88,13 @@ mod fixable {
     }
 
     type I32Alias = i32;
+
+    fn issue_9380() {
+        let _: i32 = -(1) as i32;
+        let _: f32 = -(1) as f32;
+        let _: i64 = -(1) as i64;
+        let _: i64 = -(1.0) as i64;
+
+        let _ = -(1 + 1) as i64;
+    }
 }
diff --git a/tests/ui/unnecessary_cast.stderr b/tests/ui/unnecessary_cast.stderr
index bad45f0025b..f7829ff3b0e 100644
--- a/tests/ui/unnecessary_cast.stderr
+++ b/tests/ui/unnecessary_cast.stderr
@@ -150,5 +150,17 @@ error: casting float literal to `f32` is unnecessary
 LL |         let _ = -1.0 as f32;
    |                 ^^^^^^^^^^^ help: try: `-1.0_f32`
 
-error: aborting due to 25 previous errors
+error: casting integer literal to `i32` is unnecessary
+  --> $DIR/unnecessary_cast.rs:93:22
+   |
+LL |         let _: i32 = -(1) as i32;
+   |                      ^^^^^^^^^^^ help: try: `-1_i32`
+
+error: casting integer literal to `i64` is unnecessary
+  --> $DIR/unnecessary_cast.rs:95:22
+   |
+LL |         let _: i64 = -(1) as i64;
+   |                      ^^^^^^^^^^^ help: try: `-1_i64`
+
+error: aborting due to 27 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From b07d72b69eac4f37081316801fa2979d904bbe13 Mon Sep 17 00:00:00 2001
From: dswij <dswijj@gmail.com>
Date: Sun, 28 Aug 2022 00:06:30 +0800
Subject: Ignore  when there is comment

---
 clippy_lints/src/matches/match_like_matches.rs |  4 +++-
 tests/ui/match_expr_like_matches_macro.fixed   | 25 +++++++++++++++++++++++++
 tests/ui/match_expr_like_matches_macro.rs      | 25 +++++++++++++++++++++++++
 3 files changed, 53 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/match_like_matches.rs b/clippy_lints/src/matches/match_like_matches.rs
index 0da4833f1df..34cc082687e 100644
--- a/clippy_lints/src/matches/match_like_matches.rs
+++ b/clippy_lints/src/matches/match_like_matches.rs
@@ -1,10 +1,11 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::is_wild;
 use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::span_contains_comment;
 use rustc_ast::{Attribute, LitKind};
 use rustc_errors::Applicability;
 use rustc_hir::{Arm, BorrowKind, Expr, ExprKind, Guard, Pat};
-use rustc_lint::LateContext;
+use rustc_lint::{LateContext, LintContext};
 use rustc_middle::ty;
 use rustc_span::source_map::Spanned;
 
@@ -76,6 +77,7 @@ where
         >,
 {
     if_chain! {
+        if !span_contains_comment(cx.sess().source_map(), expr.span);
         if iter.len() >= 2;
         if cx.typeck_results().expr_ty(expr).is_bool();
         if let Some((_, last_pat_opt, last_expr, _)) = iter.next_back();
diff --git a/tests/ui/match_expr_like_matches_macro.fixed b/tests/ui/match_expr_like_matches_macro.fixed
index 1ccbfda64b7..95ca571d07b 100644
--- a/tests/ui/match_expr_like_matches_macro.fixed
+++ b/tests/ui/match_expr_like_matches_macro.fixed
@@ -167,4 +167,29 @@ fn main() {
             _ => false,
         };
     }
+
+    let x = ' ';
+    // ignore if match block contains comment
+    let _line_comments = match x {
+        // numbers are bad!
+        '1' | '2' | '3' => true,
+        // spaces are very important to be true.
+        ' ' => true,
+        // as are dots
+        '.' => true,
+        _ => false,
+    };
+
+    let _block_comments = match x {
+        /* numbers are bad!
+         */
+        '1' | '2' | '3' => true,
+        /* spaces are very important to be true.
+         */
+        ' ' => true,
+        /* as are dots
+         */
+        '.' => true,
+        _ => false,
+    };
 }
diff --git a/tests/ui/match_expr_like_matches_macro.rs b/tests/ui/match_expr_like_matches_macro.rs
index a49991f5941..3b9c8cadadc 100644
--- a/tests/ui/match_expr_like_matches_macro.rs
+++ b/tests/ui/match_expr_like_matches_macro.rs
@@ -208,4 +208,29 @@ fn main() {
             _ => false,
         };
     }
+
+    let x = ' ';
+    // ignore if match block contains comment
+    let _line_comments = match x {
+        // numbers are bad!
+        '1' | '2' | '3' => true,
+        // spaces are very important to be true.
+        ' ' => true,
+        // as are dots
+        '.' => true,
+        _ => false,
+    };
+
+    let _block_comments = match x {
+        /* numbers are bad!
+         */
+        '1' | '2' | '3' => true,
+        /* spaces are very important to be true.
+         */
+        ' ' => true,
+        /* as are dots
+         */
+        '.' => true,
+        _ => false,
+    };
 }
-- 
cgit 1.4.1-3-g733a5


From c542f1fe3fcc48e1f8a299a7cbd07e2335b1f5f3 Mon Sep 17 00:00:00 2001
From: Lukas Lueg <lukas.lueg@gmail.com>
Date: Sun, 28 Aug 2022 12:18:50 +0200
Subject: Don't lint literal None from expansion

---
 clippy_lints/src/partialeq_to_none.rs |  3 ++-
 tests/ui/partialeq_to_none.fixed      | 12 ++++++++++++
 tests/ui/partialeq_to_none.rs         | 12 ++++++++++++
 tests/ui/partialeq_to_none.stderr     | 28 ++++++++++++++--------------
 4 files changed, 40 insertions(+), 15 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/partialeq_to_none.rs b/clippy_lints/src/partialeq_to_none.rs
index eee7642068d..000b0ba7a14 100644
--- a/clippy_lints/src/partialeq_to_none.rs
+++ b/clippy_lints/src/partialeq_to_none.rs
@@ -53,7 +53,8 @@ impl<'tcx> LateLintPass<'tcx> for PartialeqToNone {
 
         // If the expression is a literal `Option::None`
         let is_none_ctor = |expr: &Expr<'_>| {
-            matches!(&peel_hir_expr_refs(expr).0.kind,
+            !expr.span.from_expansion()
+                && matches!(&peel_hir_expr_refs(expr).0.kind,
             ExprKind::Path(p) if is_lang_ctor(cx, p, LangItem::OptionNone))
         };
 
diff --git a/tests/ui/partialeq_to_none.fixed b/tests/ui/partialeq_to_none.fixed
index f3e4c58d694..4644ea8f51d 100644
--- a/tests/ui/partialeq_to_none.fixed
+++ b/tests/ui/partialeq_to_none.fixed
@@ -26,6 +26,18 @@ fn optref() -> &'static &'static Option<()> {
     &&None
 }
 
+pub fn macro_expansion() {
+    macro_rules! foo {
+        () => {
+            None::<()>
+        };
+    }
+
+    let _ = foobar() == foo!();
+    let _ = foo!() == foobar();
+    let _ = foo!() == foo!();
+}
+
 fn main() {
     let x = Some(0);
 
diff --git a/tests/ui/partialeq_to_none.rs b/tests/ui/partialeq_to_none.rs
index 767b2a38bcc..61011b3a8c5 100644
--- a/tests/ui/partialeq_to_none.rs
+++ b/tests/ui/partialeq_to_none.rs
@@ -26,6 +26,18 @@ fn optref() -> &'static &'static Option<()> {
     &&None
 }
 
+pub fn macro_expansion() {
+    macro_rules! foo {
+        () => {
+            None::<()>
+        };
+    }
+
+    let _ = foobar() == foo!();
+    let _ = foo!() == foobar();
+    let _ = foo!() == foo!();
+}
+
 fn main() {
     let x = Some(0);
 
diff --git a/tests/ui/partialeq_to_none.stderr b/tests/ui/partialeq_to_none.stderr
index de15a9f7baa..d06ab7aee55 100644
--- a/tests/ui/partialeq_to_none.stderr
+++ b/tests/ui/partialeq_to_none.stderr
@@ -7,55 +7,55 @@ LL |     if f != None { "yay" } else { "nay" }
    = note: `-D clippy::partialeq-to-none` implied by `-D warnings`
 
 error: binary comparison to literal `Option::None`
-  --> $DIR/partialeq_to_none.rs:32:13
+  --> $DIR/partialeq_to_none.rs:44:13
    |
 LL |     let _ = x == None;
    |             ^^^^^^^^^ help: use `Option::is_none()` instead: `x.is_none()`
 
 error: binary comparison to literal `Option::None`
-  --> $DIR/partialeq_to_none.rs:33:13
+  --> $DIR/partialeq_to_none.rs:45:13
    |
 LL |     let _ = x != None;
    |             ^^^^^^^^^ help: use `Option::is_some()` instead: `x.is_some()`
 
 error: binary comparison to literal `Option::None`
-  --> $DIR/partialeq_to_none.rs:34:13
+  --> $DIR/partialeq_to_none.rs:46:13
    |
 LL |     let _ = None == x;
    |             ^^^^^^^^^ help: use `Option::is_none()` instead: `x.is_none()`
 
 error: binary comparison to literal `Option::None`
-  --> $DIR/partialeq_to_none.rs:35:13
+  --> $DIR/partialeq_to_none.rs:47:13
    |
 LL |     let _ = None != x;
    |             ^^^^^^^^^ help: use `Option::is_some()` instead: `x.is_some()`
 
 error: binary comparison to literal `Option::None`
-  --> $DIR/partialeq_to_none.rs:37:8
+  --> $DIR/partialeq_to_none.rs:49:8
    |
 LL |     if foobar() == None {}
    |        ^^^^^^^^^^^^^^^^ help: use `Option::is_none()` instead: `foobar().is_none()`
 
 error: binary comparison to literal `Option::None`
-  --> $DIR/partialeq_to_none.rs:39:8
+  --> $DIR/partialeq_to_none.rs:51:8
    |
 LL |     if bar().ok() != None {}
    |        ^^^^^^^^^^^^^^^^^^ help: use `Option::is_some()` instead: `bar().ok().is_some()`
 
 error: binary comparison to literal `Option::None`
-  --> $DIR/partialeq_to_none.rs:41:13
+  --> $DIR/partialeq_to_none.rs:53:13
    |
 LL |     let _ = Some(1 + 2) != None;
    |             ^^^^^^^^^^^^^^^^^^^ help: use `Option::is_some()` instead: `Some(1 + 2).is_some()`
 
 error: binary comparison to literal `Option::None`
-  --> $DIR/partialeq_to_none.rs:43:13
+  --> $DIR/partialeq_to_none.rs:55:13
    |
 LL |     let _ = { Some(0) } == None;
    |             ^^^^^^^^^^^^^^^^^^^ help: use `Option::is_none()` instead: `{ Some(0) }.is_none()`
 
 error: binary comparison to literal `Option::None`
-  --> $DIR/partialeq_to_none.rs:45:13
+  --> $DIR/partialeq_to_none.rs:57:13
    |
 LL |       let _ = {
    |  _____________^
@@ -77,31 +77,31 @@ LL ~     }.is_some();
    |
 
 error: binary comparison to literal `Option::None`
-  --> $DIR/partialeq_to_none.rs:55:13
+  --> $DIR/partialeq_to_none.rs:67:13
    |
 LL |     let _ = optref() == &&None;
    |             ^^^^^^^^^^^^^^^^^^ help: use `Option::is_none()` instead: `optref().is_none()`
 
 error: binary comparison to literal `Option::None`
-  --> $DIR/partialeq_to_none.rs:56:13
+  --> $DIR/partialeq_to_none.rs:68:13
    |
 LL |     let _ = &&None != optref();
    |             ^^^^^^^^^^^^^^^^^^ help: use `Option::is_some()` instead: `optref().is_some()`
 
 error: binary comparison to literal `Option::None`
-  --> $DIR/partialeq_to_none.rs:57:13
+  --> $DIR/partialeq_to_none.rs:69:13
    |
 LL |     let _ = **optref() == None;
    |             ^^^^^^^^^^^^^^^^^^ help: use `Option::is_none()` instead: `optref().is_none()`
 
 error: binary comparison to literal `Option::None`
-  --> $DIR/partialeq_to_none.rs:58:13
+  --> $DIR/partialeq_to_none.rs:70:13
    |
 LL |     let _ = &None != *optref();
    |             ^^^^^^^^^^^^^^^^^^ help: use `Option::is_some()` instead: `optref().is_some()`
 
 error: binary comparison to literal `Option::None`
-  --> $DIR/partialeq_to_none.rs:61:13
+  --> $DIR/partialeq_to_none.rs:73:13
    |
 LL |     let _ = None != *x;
    |             ^^^^^^^^^^ help: use `Option::is_some()` instead: `(*x).is_some()`
-- 
cgit 1.4.1-3-g733a5


From 9790a3291bd73e7745451da7561147930a1cfc97 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sun, 28 Aug 2022 06:22:08 -0400
Subject: Fixes for latest nightly

---
 clippy_lints/src/unused_peekable.rs      | 2 +-
 clippy_lints/src/utils/internal_lints.rs | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unused_peekable.rs b/clippy_lints/src/unused_peekable.rs
index c060d767e23..ac73173697e 100644
--- a/clippy_lints/src/unused_peekable.rs
+++ b/clippy_lints/src/unused_peekable.rs
@@ -201,7 +201,7 @@ impl<'tcx> Visitor<'_> for PeekableVisitor<'_, 'tcx> {
                             return;
                         },
                     },
-                    Node::Block(_) => {},
+                    Node::Block(_) | Node::ExprField(_) => {},
                     _ => {
                         break;
                     },
diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs
index 5dcacd604be..eb34085a2ab 100644
--- a/clippy_lints/src/utils/internal_lints.rs
+++ b/clippy_lints/src/utils/internal_lints.rs
@@ -593,8 +593,8 @@ fn extract_clippy_version_value(cx: &LateContext<'_>, item: &'_ Item<'_>) -> Opt
     attrs.iter().find_map(|attr| {
         if_chain! {
             // Identify attribute
-            if let ast::AttrKind::Normal(ref attr_kind, _) = &attr.kind;
-            if let [tool_name, attr_name] = &attr_kind.path.segments[..];
+            if let ast::AttrKind::Normal(ref attr_kind) = &attr.kind;
+            if let [tool_name, attr_name] = &attr_kind.item.path.segments[..];
             if tool_name.ident.name == sym::clippy;
             if attr_name.ident.name == sym::version;
             if let Some(version) = attr.value_str();
-- 
cgit 1.4.1-3-g733a5


From 26a6891925f8e8bca95c6b71eea8e6becd38b73d Mon Sep 17 00:00:00 2001
From: Lukas Lueg <lukas.lueg@gmail.com>
Date: Mon, 29 Aug 2022 13:56:03 +0200
Subject: Fix missing parens in `suboptimal_flops` sugg

Fixes #9391
---
 clippy_lints/src/floating_point_arithmetic.rs |  4 ++--
 tests/ui/floating_point_rad.fixed             |  5 +++++
 tests/ui/floating_point_rad.rs                |  5 +++++
 tests/ui/floating_point_rad.stderr            | 28 +++++++++++++++++++--------
 4 files changed, 32 insertions(+), 10 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/floating_point_arithmetic.rs b/clippy_lints/src/floating_point_arithmetic.rs
index df9b41d2c98..a052ecb6e04 100644
--- a/clippy_lints/src/floating_point_arithmetic.rs
+++ b/clippy_lints/src/floating_point_arithmetic.rs
@@ -651,7 +651,7 @@ fn check_radians(cx: &LateContext<'_>, expr: &Expr<'_>) {
             if (F32(f32_consts::PI) == rvalue || F64(f64_consts::PI) == rvalue) &&
                (F32(180_f32) == lvalue || F64(180_f64) == lvalue)
             {
-                let mut proposal = format!("{}.to_degrees()", Sugg::hir(cx, mul_lhs, ".."));
+                let mut proposal = format!("{}.to_degrees()", Sugg::hir(cx, mul_lhs, "..").maybe_par());
                 if_chain! {
                     if let ExprKind::Lit(ref literal) = mul_lhs.kind;
                     if let ast::LitKind::Float(ref value, float_type) = literal.node;
@@ -677,7 +677,7 @@ fn check_radians(cx: &LateContext<'_>, expr: &Expr<'_>) {
                 (F32(180_f32) == rvalue || F64(180_f64) == rvalue) &&
                 (F32(f32_consts::PI) == lvalue || F64(f64_consts::PI) == lvalue)
             {
-                let mut proposal = format!("{}.to_radians()", Sugg::hir(cx, mul_lhs, ".."));
+                let mut proposal = format!("{}.to_radians()", Sugg::hir(cx, mul_lhs, "..").maybe_par());
                 if_chain! {
                     if let ExprKind::Lit(ref literal) = mul_lhs.kind;
                     if let ast::LitKind::Float(ref value, float_type) = literal.node;
diff --git a/tests/ui/floating_point_rad.fixed b/tests/ui/floating_point_rad.fixed
index ce91fe176c6..27674b8a455 100644
--- a/tests/ui/floating_point_rad.fixed
+++ b/tests/ui/floating_point_rad.fixed
@@ -8,6 +8,11 @@ pub const fn const_context() {
     let _ = x * 180f32 / std::f32::consts::PI;
 }
 
+pub fn issue9391(degrees: i64) {
+    let _ = (degrees as f64).to_radians();
+    let _ = (degrees as f64).to_degrees();
+}
+
 fn main() {
     let x = 3f32;
     let _ = x.to_degrees();
diff --git a/tests/ui/floating_point_rad.rs b/tests/ui/floating_point_rad.rs
index 8f323498614..f1ea73df398 100644
--- a/tests/ui/floating_point_rad.rs
+++ b/tests/ui/floating_point_rad.rs
@@ -8,6 +8,11 @@ pub const fn const_context() {
     let _ = x * 180f32 / std::f32::consts::PI;
 }
 
+pub fn issue9391(degrees: i64) {
+    let _ = degrees as f64 * std::f64::consts::PI / 180.0;
+    let _ = degrees as f64 * 180.0 / std::f64::consts::PI;
+}
+
 fn main() {
     let x = 3f32;
     let _ = x * 180f32 / std::f32::consts::PI;
diff --git a/tests/ui/floating_point_rad.stderr b/tests/ui/floating_point_rad.stderr
index f12d3d23f3a..979442f2c24 100644
--- a/tests/ui/floating_point_rad.stderr
+++ b/tests/ui/floating_point_rad.stderr
@@ -1,40 +1,52 @@
+error: conversion to radians can be done more accurately
+  --> $DIR/floating_point_rad.rs:12:13
+   |
+LL |     let _ = degrees as f64 * std::f64::consts::PI / 180.0;
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(degrees as f64).to_radians()`
+   |
+   = note: `-D clippy::suboptimal-flops` implied by `-D warnings`
+
 error: conversion to degrees can be done more accurately
   --> $DIR/floating_point_rad.rs:13:13
    |
+LL |     let _ = degrees as f64 * 180.0 / std::f64::consts::PI;
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(degrees as f64).to_degrees()`
+
+error: conversion to degrees can be done more accurately
+  --> $DIR/floating_point_rad.rs:18:13
+   |
 LL |     let _ = x * 180f32 / std::f32::consts::PI;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.to_degrees()`
-   |
-   = note: `-D clippy::suboptimal-flops` implied by `-D warnings`
 
 error: conversion to degrees can be done more accurately
-  --> $DIR/floating_point_rad.rs:14:13
+  --> $DIR/floating_point_rad.rs:19:13
    |
 LL |     let _ = 90. * 180f64 / std::f64::consts::PI;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `90.0_f64.to_degrees()`
 
 error: conversion to degrees can be done more accurately
-  --> $DIR/floating_point_rad.rs:15:13
+  --> $DIR/floating_point_rad.rs:20:13
    |
 LL |     let _ = 90.5 * 180f64 / std::f64::consts::PI;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `90.5_f64.to_degrees()`
 
 error: conversion to radians can be done more accurately
-  --> $DIR/floating_point_rad.rs:16:13
+  --> $DIR/floating_point_rad.rs:21:13
    |
 LL |     let _ = x * std::f32::consts::PI / 180f32;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.to_radians()`
 
 error: conversion to radians can be done more accurately
-  --> $DIR/floating_point_rad.rs:17:13
+  --> $DIR/floating_point_rad.rs:22:13
    |
 LL |     let _ = 90. * std::f32::consts::PI / 180f32;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `90.0_f64.to_radians()`
 
 error: conversion to radians can be done more accurately
-  --> $DIR/floating_point_rad.rs:18:13
+  --> $DIR/floating_point_rad.rs:23:13
    |
 LL |     let _ = 90.5 * std::f32::consts::PI / 180f32;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `90.5_f64.to_radians()`
 
-error: aborting due to 6 previous errors
+error: aborting due to 8 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 30979bfe8314372051b3a62e88eb0695eedb512d Mon Sep 17 00:00:00 2001
From: clubby789 <jamie@hill-daniel.co.uk>
Date: Tue, 26 Jul 2022 19:17:21 +0100
Subject: Add lint `cast_slice_from_raw_parts`

---
 CHANGELOG.md                                       |  1 +
 .../src/casts/cast_slice_from_raw_parts.rs         | 63 ++++++++++++++++++++++
 clippy_lints/src/casts/mod.rs                      | 29 +++++++++-
 clippy_lints/src/lib.register_all.rs               |  1 +
 clippy_lints/src/lib.register_lints.rs             |  1 +
 clippy_lints/src/lib.register_suspicious.rs        |  1 +
 tests/ui/cast_raw_slice_pointer_cast.fixed         | 24 +++++++++
 tests/ui/cast_raw_slice_pointer_cast.rs            | 24 +++++++++
 tests/ui/cast_raw_slice_pointer_cast.stderr        | 46 ++++++++++++++++
 9 files changed, 189 insertions(+), 1 deletion(-)
 create mode 100644 clippy_lints/src/casts/cast_slice_from_raw_parts.rs
 create mode 100644 tests/ui/cast_raw_slice_pointer_cast.fixed
 create mode 100644 tests/ui/cast_raw_slice_pointer_cast.rs
 create mode 100644 tests/ui/cast_raw_slice_pointer_cast.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index a076997eebd..69ce0a201bf 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3627,6 +3627,7 @@ Released 2018-09-13
 [`cast_ref_to_mut`]: https://rust-lang.github.io/rust-clippy/master/index.html#cast_ref_to_mut
 [`cast_sign_loss`]: https://rust-lang.github.io/rust-clippy/master/index.html#cast_sign_loss
 [`cast_slice_different_sizes`]: https://rust-lang.github.io/rust-clippy/master/index.html#cast_slice_different_sizes
+[`cast_slice_from_raw_parts`]: https://rust-lang.github.io/rust-clippy/master/index.html#cast_slice_from_raw_parts
 [`char_lit_as_u8`]: https://rust-lang.github.io/rust-clippy/master/index.html#char_lit_as_u8
 [`chars_last_cmp`]: https://rust-lang.github.io/rust-clippy/master/index.html#chars_last_cmp
 [`chars_next_cmp`]: https://rust-lang.github.io/rust-clippy/master/index.html#chars_next_cmp
diff --git a/clippy_lints/src/casts/cast_slice_from_raw_parts.rs b/clippy_lints/src/casts/cast_slice_from_raw_parts.rs
new file mode 100644
index 00000000000..284ef165998
--- /dev/null
+++ b/clippy_lints/src/casts/cast_slice_from_raw_parts.rs
@@ -0,0 +1,63 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::{match_def_path, meets_msrv, msrvs, paths};
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir::{def_id::DefId, Expr, ExprKind};
+use rustc_lint::LateContext;
+use rustc_middle::ty::{self, Ty};
+use rustc_semver::RustcVersion;
+
+use super::CAST_SLICE_FROM_RAW_PARTS;
+
+enum RawPartsKind {
+    Immutable,
+    Mutable,
+}
+
+fn raw_parts_kind(cx: &LateContext<'_>, did: DefId) -> Option<RawPartsKind> {
+    if match_def_path(cx, did, &paths::SLICE_FROM_RAW_PARTS) {
+        Some(RawPartsKind::Immutable)
+    } else if match_def_path(cx, did, &paths::SLICE_FROM_RAW_PARTS_MUT) {
+        Some(RawPartsKind::Mutable)
+    } else {
+        None
+    }
+}
+
+pub(super) fn check(
+    cx: &LateContext<'_>,
+    expr: &Expr<'_>,
+    cast_expr: &Expr<'_>,
+    cast_to: Ty<'_>,
+    msrv: Option<RustcVersion>,
+) {
+    if_chain! {
+        if meets_msrv(msrv, msrvs::PTR_SLICE_RAW_PARTS);
+        if let ty::RawPtr(ptrty) = cast_to.kind();
+        if let ty::Slice(_) = ptrty.ty.kind();
+        if let ExprKind::Call(fun, [ptr_arg, len_arg]) = cast_expr.peel_blocks().kind;
+        if let ExprKind::Path(ref qpath) = fun.kind;
+        if let Some(fun_def_id) = cx.qpath_res(qpath, fun.hir_id).opt_def_id();
+        if let Some(rpk) = raw_parts_kind(cx, fun_def_id);
+        then {
+            let func = match rpk {
+                RawPartsKind::Immutable => "from_raw_parts",
+                RawPartsKind::Mutable => "from_raw_parts_mut"
+            };
+            let span = expr.span;
+            let mut applicability = Applicability::MachineApplicable;
+            let ptr = snippet_with_applicability(cx, ptr_arg.span, "ptr", &mut applicability);
+            let len = snippet_with_applicability(cx, len_arg.span, "len", &mut applicability);
+            span_lint_and_sugg(
+                cx,
+                CAST_SLICE_FROM_RAW_PARTS,
+                span,
+                &format!("casting the result of `{func}` to {cast_to}"),
+                "replace with",
+                format!("core::ptr::slice_{func}({ptr}, {len})"),
+                applicability
+            );
+        }
+    }
+}
diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index 644edefb8fe..14659eb3d11 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -10,6 +10,7 @@ mod cast_ptr_alignment;
 mod cast_ref_to_mut;
 mod cast_sign_loss;
 mod cast_slice_different_sizes;
+mod cast_slice_from_raw_parts;
 mod char_lit_as_u8;
 mod fn_to_numeric_cast;
 mod fn_to_numeric_cast_any;
@@ -568,6 +569,31 @@ declare_clippy_lint! {
     pedantic,
     "borrowing just to cast to a raw pointer"
 }
+declare_clippy_lint! {
+    /// **What it does:** Checks for a raw slice being cast to a slice pointer
+    ///
+    /// ### Why is this bad?
+    /// This can result in multiple `&mut` references to the same location when only a pointer is
+    /// required.
+    /// `ptr::slice_from_raw_parts` is a safe alternative that doesn't require
+    /// the same [safety requirements] to be upheld.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// let _: *const [u8] = std::slice::from_raw_parts(ptr, len) as *const _;
+    /// let _: *mut [u8] = std::slice::from_raw_parts_mut(ptr, len) as *mut _;
+    /// ```
+    /// Use instead:
+    /// ```rust,ignore
+    /// let _: *const [u8] = std::ptr::slice_from_raw_parts(ptr, len);
+    /// let _: *mut [u8] = std::ptr::slice_from_raw_parts_mut(ptr, len);
+    /// ```
+    /// [safety requirements]: https://doc.rust-lang.org/std/slice/fn.from_raw_parts.html#safety
+    #[clippy::version = "1.64.0"]
+    pub CAST_SLICE_FROM_RAW_PARTS,
+    suspicious,
+    "casting a slice created from a pointer and length to a slice pointer"
+}
 
 pub struct Casts {
     msrv: Option<RustcVersion>,
@@ -600,6 +626,7 @@ impl_lint_pass!(Casts => [
     CAST_ABS_TO_UNSIGNED,
     AS_UNDERSCORE,
     BORROW_AS_PTR,
+    CAST_SLICE_FROM_RAW_PARTS
 ]);
 
 impl<'tcx> LateLintPass<'tcx> for Casts {
@@ -624,7 +651,7 @@ impl<'tcx> LateLintPass<'tcx> for Casts {
             if unnecessary_cast::check(cx, expr, cast_expr, cast_from, cast_to) {
                 return;
             }
-
+            cast_slice_from_raw_parts::check(cx, expr, cast_expr, cast_to, self.msrv);
             fn_to_numeric_cast_any::check(cx, expr, cast_expr, cast_from, cast_to);
             fn_to_numeric_cast::check(cx, expr, cast_expr, cast_from, cast_to);
             fn_to_numeric_cast_with_truncation::check(cx, expr, cast_expr, cast_from, cast_to);
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 64982851b56..700762fa3ef 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -25,6 +25,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(casts::CAST_ENUM_TRUNCATION),
     LintId::of(casts::CAST_REF_TO_MUT),
     LintId::of(casts::CAST_SLICE_DIFFERENT_SIZES),
+    LintId::of(casts::CAST_SLICE_FROM_RAW_PARTS),
     LintId::of(casts::CHAR_LIT_AS_U8),
     LintId::of(casts::FN_TO_NUMERIC_CAST),
     LintId::of(casts::FN_TO_NUMERIC_CAST_WITH_TRUNCATION),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index fbf77fb734f..ee94165d2ed 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -77,6 +77,7 @@ store.register_lints(&[
     casts::CAST_REF_TO_MUT,
     casts::CAST_SIGN_LOSS,
     casts::CAST_SLICE_DIFFERENT_SIZES,
+    casts::CAST_SLICE_FROM_RAW_PARTS,
     casts::CHAR_LIT_AS_U8,
     casts::FN_TO_NUMERIC_CAST,
     casts::FN_TO_NUMERIC_CAST_ANY,
diff --git a/clippy_lints/src/lib.register_suspicious.rs b/clippy_lints/src/lib.register_suspicious.rs
index aa4e571dbe2..8f131bbf98b 100644
--- a/clippy_lints/src/lib.register_suspicious.rs
+++ b/clippy_lints/src/lib.register_suspicious.rs
@@ -11,6 +11,7 @@ store.register_group(true, "clippy::suspicious", Some("clippy_suspicious"), vec!
     LintId::of(casts::CAST_ABS_TO_UNSIGNED),
     LintId::of(casts::CAST_ENUM_CONSTRUCTOR),
     LintId::of(casts::CAST_ENUM_TRUNCATION),
+    LintId::of(casts::CAST_SLICE_FROM_RAW_PARTS),
     LintId::of(crate_in_macro_def::CRATE_IN_MACRO_DEF),
     LintId::of(drop_forget_ref::DROP_NON_DROP),
     LintId::of(drop_forget_ref::FORGET_NON_DROP),
diff --git a/tests/ui/cast_raw_slice_pointer_cast.fixed b/tests/ui/cast_raw_slice_pointer_cast.fixed
new file mode 100644
index 00000000000..b70c1912951
--- /dev/null
+++ b/tests/ui/cast_raw_slice_pointer_cast.fixed
@@ -0,0 +1,24 @@
+// run-rustfix
+#![warn(clippy::cast_slice_from_raw_parts)]
+
+#[allow(unused_imports, unused_unsafe)]
+fn main() {
+    let mut vec = vec![0u8; 1];
+    let ptr: *const u8 = vec.as_ptr();
+    let mptr = vec.as_mut_ptr();
+    let _: *const [u8] = unsafe { core::ptr::slice_from_raw_parts(ptr, 1) };
+    let _: *const [u8] = unsafe { core::ptr::slice_from_raw_parts_mut(mptr, 1) };
+    let _: *const [u8] = core::ptr::slice_from_raw_parts(ptr, 1);
+    {
+        use core::slice;
+        let _: *const [u8] = core::ptr::slice_from_raw_parts(ptr, 1);
+        use slice as one;
+        let _: *const [u8] = core::ptr::slice_from_raw_parts(ptr, 1);
+    }
+    {
+        use std::slice;
+        let _: *const [u8] = core::ptr::slice_from_raw_parts(ptr, 1);
+        use slice as one;
+        let _: *const [u8] = core::ptr::slice_from_raw_parts(ptr, 1);
+    }
+}
diff --git a/tests/ui/cast_raw_slice_pointer_cast.rs b/tests/ui/cast_raw_slice_pointer_cast.rs
new file mode 100644
index 00000000000..c1b316765c9
--- /dev/null
+++ b/tests/ui/cast_raw_slice_pointer_cast.rs
@@ -0,0 +1,24 @@
+// run-rustfix
+#![warn(clippy::cast_slice_from_raw_parts)]
+
+#[allow(unused_imports, unused_unsafe)]
+fn main() {
+    let mut vec = vec![0u8; 1];
+    let ptr: *const u8 = vec.as_ptr();
+    let mptr = vec.as_mut_ptr();
+    let _: *const [u8] = unsafe { std::slice::from_raw_parts(ptr, 1) as *const [u8] };
+    let _: *const [u8] = unsafe { std::slice::from_raw_parts_mut(mptr, 1) as *mut [u8] };
+    let _: *const [u8] = unsafe { std::slice::from_raw_parts(ptr, 1) } as *const [u8];
+    {
+        use core::slice;
+        let _: *const [u8] = unsafe { slice::from_raw_parts(ptr, 1) } as *const [u8];
+        use slice as one;
+        let _: *const [u8] = unsafe { one::from_raw_parts(ptr, 1) } as *const [u8];
+    }
+    {
+        use std::slice;
+        let _: *const [u8] = unsafe { slice::from_raw_parts(ptr, 1) } as *const [u8];
+        use slice as one;
+        let _: *const [u8] = unsafe { one::from_raw_parts(ptr, 1) } as *const [u8];
+    }
+}
diff --git a/tests/ui/cast_raw_slice_pointer_cast.stderr b/tests/ui/cast_raw_slice_pointer_cast.stderr
new file mode 100644
index 00000000000..f07801c197c
--- /dev/null
+++ b/tests/ui/cast_raw_slice_pointer_cast.stderr
@@ -0,0 +1,46 @@
+error: casting the result of `from_raw_parts` to *const [u8]
+  --> $DIR/cast_raw_slice_pointer_cast.rs:9:35
+   |
+LL |     let _: *const [u8] = unsafe { std::slice::from_raw_parts(ptr, 1) as *const [u8] };
+   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `core::ptr::slice_from_raw_parts(ptr, 1)`
+   |
+   = note: `-D clippy::cast-slice-from-raw-parts` implied by `-D warnings`
+
+error: casting the result of `from_raw_parts_mut` to *mut [u8]
+  --> $DIR/cast_raw_slice_pointer_cast.rs:10:35
+   |
+LL |     let _: *const [u8] = unsafe { std::slice::from_raw_parts_mut(mptr, 1) as *mut [u8] };
+   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `core::ptr::slice_from_raw_parts_mut(mptr, 1)`
+
+error: casting the result of `from_raw_parts` to *const [u8]
+  --> $DIR/cast_raw_slice_pointer_cast.rs:11:26
+   |
+LL |     let _: *const [u8] = unsafe { std::slice::from_raw_parts(ptr, 1) } as *const [u8];
+   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `core::ptr::slice_from_raw_parts(ptr, 1)`
+
+error: casting the result of `from_raw_parts` to *const [u8]
+  --> $DIR/cast_raw_slice_pointer_cast.rs:14:30
+   |
+LL |         let _: *const [u8] = unsafe { slice::from_raw_parts(ptr, 1) } as *const [u8];
+   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `core::ptr::slice_from_raw_parts(ptr, 1)`
+
+error: casting the result of `from_raw_parts` to *const [u8]
+  --> $DIR/cast_raw_slice_pointer_cast.rs:16:30
+   |
+LL |         let _: *const [u8] = unsafe { one::from_raw_parts(ptr, 1) } as *const [u8];
+   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `core::ptr::slice_from_raw_parts(ptr, 1)`
+
+error: casting the result of `from_raw_parts` to *const [u8]
+  --> $DIR/cast_raw_slice_pointer_cast.rs:20:30
+   |
+LL |         let _: *const [u8] = unsafe { slice::from_raw_parts(ptr, 1) } as *const [u8];
+   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `core::ptr::slice_from_raw_parts(ptr, 1)`
+
+error: casting the result of `from_raw_parts` to *const [u8]
+  --> $DIR/cast_raw_slice_pointer_cast.rs:22:30
+   |
+LL |         let _: *const [u8] = unsafe { one::from_raw_parts(ptr, 1) } as *const [u8];
+   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `core::ptr::slice_from_raw_parts(ptr, 1)`
+
+error: aborting due to 7 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From cc9f2035432135375ae73e3bdfb73e80114b55ea Mon Sep 17 00:00:00 2001
From: clubby789 <jamie@hill-daniel.co.uk>
Date: Mon, 29 Aug 2022 15:17:23 +0100
Subject: Update clippy_lints/src/casts/mod.rs

Co-authored-by: Alex Macleod <alex@macleod.io>
---
 clippy_lints/src/casts/mod.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index 14659eb3d11..cc5d346b954 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -570,7 +570,8 @@ declare_clippy_lint! {
     "borrowing just to cast to a raw pointer"
 }
 declare_clippy_lint! {
-    /// **What it does:** Checks for a raw slice being cast to a slice pointer
+    /// ### What it does
+    /// Checks for a raw slice being cast to a slice pointer
     ///
     /// ### Why is this bad?
     /// This can result in multiple `&mut` references to the same location when only a pointer is
-- 
cgit 1.4.1-3-g733a5


From 9ffc5a5c8d55b536703d414e8772c5942aa8df45 Mon Sep 17 00:00:00 2001
From: Lukas Lueg <lukas.lueg@gmail.com>
Date: Mon, 29 Aug 2022 22:36:11 +0200
Subject: Fix more parens for `suboptimal_flops` suggs

---
 clippy_lints/src/floating_point_arithmetic.rs | 18 ++++-----
 tests/ui/floating_point_exp.fixed             |  1 +
 tests/ui/floating_point_exp.rs                |  1 +
 tests/ui/floating_point_exp.stderr            | 12 ++++--
 tests/ui/floating_point_log.fixed             |  1 +
 tests/ui/floating_point_log.rs                |  1 +
 tests/ui/floating_point_log.stderr            | 54 +++++++++++++++------------
 tests/ui/floating_point_logbase.fixed         |  1 +
 tests/ui/floating_point_logbase.rs            |  1 +
 tests/ui/floating_point_logbase.stderr        | 12 ++++--
 tests/ui/floating_point_powf.fixed            |  3 ++
 tests/ui/floating_point_powf.rs               |  3 ++
 tests/ui/floating_point_powf.stderr           | 52 +++++++++++++++++---------
 tests/ui/floating_point_powi.fixed            |  1 +
 tests/ui/floating_point_powi.rs               |  1 +
 tests/ui/floating_point_powi.stderr           | 10 ++++-
 16 files changed, 114 insertions(+), 58 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/floating_point_arithmetic.rs b/clippy_lints/src/floating_point_arithmetic.rs
index a052ecb6e04..bb50e8fcabb 100644
--- a/clippy_lints/src/floating_point_arithmetic.rs
+++ b/clippy_lints/src/floating_point_arithmetic.rs
@@ -172,7 +172,7 @@ fn check_log_base(cx: &LateContext<'_>, expr: &Expr<'_>, args: &[Expr<'_>]) {
             expr.span,
             "logarithm for bases 2, 10 and e can be computed more accurately",
             "consider using",
-            format!("{}.{}()", Sugg::hir(cx, &args[0], ".."), method),
+            format!("{}.{}()", Sugg::hir(cx, &args[0], "..").maybe_par(), method),
             Applicability::MachineApplicable,
         );
     }
@@ -263,13 +263,13 @@ fn check_powf(cx: &LateContext<'_>, expr: &Expr<'_>, args: &[Expr<'_>]) {
             (
                 SUBOPTIMAL_FLOPS,
                 "square-root of a number can be computed more efficiently and accurately",
-                format!("{}.sqrt()", Sugg::hir(cx, &args[0], "..")),
+                format!("{}.sqrt()", Sugg::hir(cx, &args[0], "..").maybe_par()),
             )
         } else if F32(1.0 / 3.0) == value || F64(1.0 / 3.0) == value {
             (
                 IMPRECISE_FLOPS,
                 "cube-root of a number can be computed more accurately",
-                format!("{}.cbrt()", Sugg::hir(cx, &args[0], "..")),
+                format!("{}.cbrt()", Sugg::hir(cx, &args[0], "..").maybe_par()),
             )
         } else if let Some(exponent) = get_integer_from_float_constant(&value) {
             (
@@ -277,7 +277,7 @@ fn check_powf(cx: &LateContext<'_>, expr: &Expr<'_>, args: &[Expr<'_>]) {
                 "exponentiation with integer powers can be computed more efficiently",
                 format!(
                     "{}.powi({})",
-                    Sugg::hir(cx, &args[0], ".."),
+                    Sugg::hir(cx, &args[0], "..").maybe_par(),
                     numeric_literal::format(&exponent.to_string(), None, false)
                 ),
             )
@@ -327,7 +327,7 @@ fn check_powi(cx: &LateContext<'_>, expr: &Expr<'_>, args: &[Expr<'_>]) {
                         "consider using",
                         format!(
                             "{}.mul_add({}, {})",
-                            Sugg::hir(cx, &args[0], ".."),
+                            Sugg::hir(cx, &args[0], "..").maybe_par(),
                             Sugg::hir(cx, &args[0], ".."),
                             Sugg::hir(cx, other_addend, ".."),
                         ),
@@ -418,7 +418,7 @@ fn check_expm1(cx: &LateContext<'_>, expr: &Expr<'_>) {
                 "consider using",
                 format!(
                     "{}.exp_m1()",
-                    Sugg::hir(cx, self_arg, "..")
+                    Sugg::hir(cx, self_arg, "..").maybe_par()
                 ),
                 Applicability::MachineApplicable,
             );
@@ -550,11 +550,11 @@ fn check_custom_abs(cx: &LateContext<'_>, expr: &Expr<'_>) {
         then {
             let positive_abs_sugg = (
                 "manual implementation of `abs` method",
-                format!("{}.abs()", Sugg::hir(cx, body, "..")),
+                format!("{}.abs()", Sugg::hir(cx, body, "..").maybe_par()),
             );
             let negative_abs_sugg = (
                 "manual implementation of negation of `abs` method",
-                format!("-{}.abs()", Sugg::hir(cx, body, "..")),
+                format!("-{}.abs()", Sugg::hir(cx, body, "..").maybe_par()),
             );
             let sugg = if is_testing_positive(cx, cond, body) {
                 if if_expr_positive {
@@ -621,7 +621,7 @@ fn check_log_division(cx: &LateContext<'_>, expr: &Expr<'_>) {
                 expr.span,
                 "log base can be expressed more clearly",
                 "consider using",
-                format!("{}.log({})", Sugg::hir(cx, largs_self, ".."), Sugg::hir(cx, rargs_self, ".."),),
+                format!("{}.log({})", Sugg::hir(cx, largs_self, "..").maybe_par(), Sugg::hir(cx, rargs_self, ".."),),
                 Applicability::MachineApplicable,
             );
         }
diff --git a/tests/ui/floating_point_exp.fixed b/tests/ui/floating_point_exp.fixed
index ae7805fdf01..c86a502d15f 100644
--- a/tests/ui/floating_point_exp.fixed
+++ b/tests/ui/floating_point_exp.fixed
@@ -5,6 +5,7 @@ fn main() {
     let x = 2f32;
     let _ = x.exp_m1();
     let _ = x.exp_m1() + 2.0;
+    let _ = (x as f32).exp_m1() + 2.0;
     // Cases where the lint shouldn't be applied
     let _ = x.exp() - 2.0;
     let _ = x.exp() - 1.0 * 2.0;
diff --git a/tests/ui/floating_point_exp.rs b/tests/ui/floating_point_exp.rs
index 27e0b9bcbc9..e59589f912a 100644
--- a/tests/ui/floating_point_exp.rs
+++ b/tests/ui/floating_point_exp.rs
@@ -5,6 +5,7 @@ fn main() {
     let x = 2f32;
     let _ = x.exp() - 1.0;
     let _ = x.exp() - 1.0 + 2.0;
+    let _ = (x as f32).exp() - 1.0 + 2.0;
     // Cases where the lint shouldn't be applied
     let _ = x.exp() - 2.0;
     let _ = x.exp() - 1.0 * 2.0;
diff --git a/tests/ui/floating_point_exp.stderr b/tests/ui/floating_point_exp.stderr
index 5cd999ad47c..f84eede1987 100644
--- a/tests/ui/floating_point_exp.stderr
+++ b/tests/ui/floating_point_exp.stderr
@@ -13,16 +13,22 @@ LL |     let _ = x.exp() - 1.0 + 2.0;
    |             ^^^^^^^^^^^^^ help: consider using: `x.exp_m1()`
 
 error: (e.pow(x) - 1) can be computed more accurately
-  --> $DIR/floating_point_exp.rs:13:13
+  --> $DIR/floating_point_exp.rs:8:13
+   |
+LL |     let _ = (x as f32).exp() - 1.0 + 2.0;
+   |             ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(x as f32).exp_m1()`
+
+error: (e.pow(x) - 1) can be computed more accurately
+  --> $DIR/floating_point_exp.rs:14:13
    |
 LL |     let _ = x.exp() - 1.0;
    |             ^^^^^^^^^^^^^ help: consider using: `x.exp_m1()`
 
 error: (e.pow(x) - 1) can be computed more accurately
-  --> $DIR/floating_point_exp.rs:14:13
+  --> $DIR/floating_point_exp.rs:15:13
    |
 LL |     let _ = x.exp() - 1.0 + 2.0;
    |             ^^^^^^^^^^^^^ help: consider using: `x.exp_m1()`
 
-error: aborting due to 4 previous errors
+error: aborting due to 5 previous errors
 
diff --git a/tests/ui/floating_point_log.fixed b/tests/ui/floating_point_log.fixed
index 5b487bb8fcf..4def9300bb7 100644
--- a/tests/ui/floating_point_log.fixed
+++ b/tests/ui/floating_point_log.fixed
@@ -12,6 +12,7 @@ fn check_log_base() {
     let _ = x.ln();
     let _ = x.log2();
     let _ = x.ln();
+    let _ = (x as f32).log2();
 
     let x = 1f64;
     let _ = x.log2();
diff --git a/tests/ui/floating_point_log.rs b/tests/ui/floating_point_log.rs
index 01181484e7d..1e04caa7d2a 100644
--- a/tests/ui/floating_point_log.rs
+++ b/tests/ui/floating_point_log.rs
@@ -12,6 +12,7 @@ fn check_log_base() {
     let _ = x.log(std::f32::consts::E);
     let _ = x.log(TWO);
     let _ = x.log(E);
+    let _ = (x as f32).log(2f32);
 
     let x = 1f64;
     let _ = x.log(2f64);
diff --git a/tests/ui/floating_point_log.stderr b/tests/ui/floating_point_log.stderr
index 96e5a154441..89800a13a6e 100644
--- a/tests/ui/floating_point_log.stderr
+++ b/tests/ui/floating_point_log.stderr
@@ -31,25 +31,31 @@ LL |     let _ = x.log(E);
    |             ^^^^^^^^ help: consider using: `x.ln()`
 
 error: logarithm for bases 2, 10 and e can be computed more accurately
-  --> $DIR/floating_point_log.rs:17:13
+  --> $DIR/floating_point_log.rs:15:13
+   |
+LL |     let _ = (x as f32).log(2f32);
+   |             ^^^^^^^^^^^^^^^^^^^^ help: consider using: `(x as f32).log2()`
+
+error: logarithm for bases 2, 10 and e can be computed more accurately
+  --> $DIR/floating_point_log.rs:18:13
    |
 LL |     let _ = x.log(2f64);
    |             ^^^^^^^^^^^ help: consider using: `x.log2()`
 
 error: logarithm for bases 2, 10 and e can be computed more accurately
-  --> $DIR/floating_point_log.rs:18:13
+  --> $DIR/floating_point_log.rs:19:13
    |
 LL |     let _ = x.log(10f64);
    |             ^^^^^^^^^^^^ help: consider using: `x.log10()`
 
 error: logarithm for bases 2, 10 and e can be computed more accurately
-  --> $DIR/floating_point_log.rs:19:13
+  --> $DIR/floating_point_log.rs:20:13
    |
 LL |     let _ = x.log(std::f64::consts::E);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.ln()`
 
 error: ln(1 + x) can be computed more accurately
-  --> $DIR/floating_point_log.rs:24:13
+  --> $DIR/floating_point_log.rs:25:13
    |
 LL |     let _ = (1f32 + 2.).ln();
    |             ^^^^^^^^^^^^^^^^ help: consider using: `2.0f32.ln_1p()`
@@ -57,118 +63,118 @@ LL |     let _ = (1f32 + 2.).ln();
    = note: `-D clippy::imprecise-flops` implied by `-D warnings`
 
 error: ln(1 + x) can be computed more accurately
-  --> $DIR/floating_point_log.rs:25:13
+  --> $DIR/floating_point_log.rs:26:13
    |
 LL |     let _ = (1f32 + 2.0).ln();
    |             ^^^^^^^^^^^^^^^^^ help: consider using: `2.0f32.ln_1p()`
 
 error: ln(1 + x) can be computed more accurately
-  --> $DIR/floating_point_log.rs:26:13
+  --> $DIR/floating_point_log.rs:27:13
    |
 LL |     let _ = (1.0 + x).ln();
    |             ^^^^^^^^^^^^^^ help: consider using: `x.ln_1p()`
 
 error: ln(1 + x) can be computed more accurately
-  --> $DIR/floating_point_log.rs:27:13
+  --> $DIR/floating_point_log.rs:28:13
    |
 LL |     let _ = (1.0 + x / 2.0).ln();
    |             ^^^^^^^^^^^^^^^^^^^^ help: consider using: `(x / 2.0).ln_1p()`
 
 error: ln(1 + x) can be computed more accurately
-  --> $DIR/floating_point_log.rs:28:13
+  --> $DIR/floating_point_log.rs:29:13
    |
 LL |     let _ = (1.0 + x.powi(3)).ln();
    |             ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.powi(3).ln_1p()`
 
 error: ln(1 + x) can be computed more accurately
-  --> $DIR/floating_point_log.rs:29:13
+  --> $DIR/floating_point_log.rs:30:13
    |
 LL |     let _ = (1.0 + x.powi(3) / 2.0).ln();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(x.powi(3) / 2.0).ln_1p()`
 
 error: ln(1 + x) can be computed more accurately
-  --> $DIR/floating_point_log.rs:30:13
+  --> $DIR/floating_point_log.rs:31:13
    |
 LL |     let _ = (1.0 + (std::f32::consts::E - 1.0)).ln();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(std::f32::consts::E - 1.0).ln_1p()`
 
 error: ln(1 + x) can be computed more accurately
-  --> $DIR/floating_point_log.rs:31:13
+  --> $DIR/floating_point_log.rs:32:13
    |
 LL |     let _ = (x + 1.0).ln();
    |             ^^^^^^^^^^^^^^ help: consider using: `x.ln_1p()`
 
 error: ln(1 + x) can be computed more accurately
-  --> $DIR/floating_point_log.rs:32:13
+  --> $DIR/floating_point_log.rs:33:13
    |
 LL |     let _ = (x.powi(3) + 1.0).ln();
    |             ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.powi(3).ln_1p()`
 
 error: ln(1 + x) can be computed more accurately
-  --> $DIR/floating_point_log.rs:33:13
+  --> $DIR/floating_point_log.rs:34:13
    |
 LL |     let _ = (x + 2.0 + 1.0).ln();
    |             ^^^^^^^^^^^^^^^^^^^^ help: consider using: `(x + 2.0).ln_1p()`
 
 error: ln(1 + x) can be computed more accurately
-  --> $DIR/floating_point_log.rs:34:13
+  --> $DIR/floating_point_log.rs:35:13
    |
 LL |     let _ = (x / 2.0 + 1.0).ln();
    |             ^^^^^^^^^^^^^^^^^^^^ help: consider using: `(x / 2.0).ln_1p()`
 
 error: ln(1 + x) can be computed more accurately
-  --> $DIR/floating_point_log.rs:42:13
+  --> $DIR/floating_point_log.rs:43:13
    |
 LL |     let _ = (1f64 + 2.).ln();
    |             ^^^^^^^^^^^^^^^^ help: consider using: `2.0f64.ln_1p()`
 
 error: ln(1 + x) can be computed more accurately
-  --> $DIR/floating_point_log.rs:43:13
+  --> $DIR/floating_point_log.rs:44:13
    |
 LL |     let _ = (1f64 + 2.0).ln();
    |             ^^^^^^^^^^^^^^^^^ help: consider using: `2.0f64.ln_1p()`
 
 error: ln(1 + x) can be computed more accurately
-  --> $DIR/floating_point_log.rs:44:13
+  --> $DIR/floating_point_log.rs:45:13
    |
 LL |     let _ = (1.0 + x).ln();
    |             ^^^^^^^^^^^^^^ help: consider using: `x.ln_1p()`
 
 error: ln(1 + x) can be computed more accurately
-  --> $DIR/floating_point_log.rs:45:13
+  --> $DIR/floating_point_log.rs:46:13
    |
 LL |     let _ = (1.0 + x / 2.0).ln();
    |             ^^^^^^^^^^^^^^^^^^^^ help: consider using: `(x / 2.0).ln_1p()`
 
 error: ln(1 + x) can be computed more accurately
-  --> $DIR/floating_point_log.rs:46:13
+  --> $DIR/floating_point_log.rs:47:13
    |
 LL |     let _ = (1.0 + x.powi(3)).ln();
    |             ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.powi(3).ln_1p()`
 
 error: ln(1 + x) can be computed more accurately
-  --> $DIR/floating_point_log.rs:47:13
+  --> $DIR/floating_point_log.rs:48:13
    |
 LL |     let _ = (x + 1.0).ln();
    |             ^^^^^^^^^^^^^^ help: consider using: `x.ln_1p()`
 
 error: ln(1 + x) can be computed more accurately
-  --> $DIR/floating_point_log.rs:48:13
+  --> $DIR/floating_point_log.rs:49:13
    |
 LL |     let _ = (x.powi(3) + 1.0).ln();
    |             ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.powi(3).ln_1p()`
 
 error: ln(1 + x) can be computed more accurately
-  --> $DIR/floating_point_log.rs:49:13
+  --> $DIR/floating_point_log.rs:50:13
    |
 LL |     let _ = (x + 2.0 + 1.0).ln();
    |             ^^^^^^^^^^^^^^^^^^^^ help: consider using: `(x + 2.0).ln_1p()`
 
 error: ln(1 + x) can be computed more accurately
-  --> $DIR/floating_point_log.rs:50:13
+  --> $DIR/floating_point_log.rs:51:13
    |
 LL |     let _ = (x / 2.0 + 1.0).ln();
    |             ^^^^^^^^^^^^^^^^^^^^ help: consider using: `(x / 2.0).ln_1p()`
 
-error: aborting due to 28 previous errors
+error: aborting due to 29 previous errors
 
diff --git a/tests/ui/floating_point_logbase.fixed b/tests/ui/floating_point_logbase.fixed
index 13962a272d4..936462f9406 100644
--- a/tests/ui/floating_point_logbase.fixed
+++ b/tests/ui/floating_point_logbase.fixed
@@ -5,6 +5,7 @@ fn main() {
     let x = 3f32;
     let y = 5f32;
     let _ = x.log(y);
+    let _ = (x as f32).log(y);
     let _ = x.log(y);
     let _ = x.log(y);
     let _ = x.log(y);
diff --git a/tests/ui/floating_point_logbase.rs b/tests/ui/floating_point_logbase.rs
index 26bc20d5370..0b56fa8fa41 100644
--- a/tests/ui/floating_point_logbase.rs
+++ b/tests/ui/floating_point_logbase.rs
@@ -5,6 +5,7 @@ fn main() {
     let x = 3f32;
     let y = 5f32;
     let _ = x.ln() / y.ln();
+    let _ = (x as f32).ln() / y.ln();
     let _ = x.log2() / y.log2();
     let _ = x.log10() / y.log10();
     let _ = x.log(5f32) / y.log(5f32);
diff --git a/tests/ui/floating_point_logbase.stderr b/tests/ui/floating_point_logbase.stderr
index 78354c2f62d..384e3554cbb 100644
--- a/tests/ui/floating_point_logbase.stderr
+++ b/tests/ui/floating_point_logbase.stderr
@@ -9,20 +9,26 @@ LL |     let _ = x.ln() / y.ln();
 error: log base can be expressed more clearly
   --> $DIR/floating_point_logbase.rs:8:13
    |
+LL |     let _ = (x as f32).ln() / y.ln();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(x as f32).log(y)`
+
+error: log base can be expressed more clearly
+  --> $DIR/floating_point_logbase.rs:9:13
+   |
 LL |     let _ = x.log2() / y.log2();
    |             ^^^^^^^^^^^^^^^^^^^ help: consider using: `x.log(y)`
 
 error: log base can be expressed more clearly
-  --> $DIR/floating_point_logbase.rs:9:13
+  --> $DIR/floating_point_logbase.rs:10:13
    |
 LL |     let _ = x.log10() / y.log10();
    |             ^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.log(y)`
 
 error: log base can be expressed more clearly
-  --> $DIR/floating_point_logbase.rs:10:13
+  --> $DIR/floating_point_logbase.rs:11:13
    |
 LL |     let _ = x.log(5f32) / y.log(5f32);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.log(y)`
 
-error: aborting due to 4 previous errors
+error: aborting due to 5 previous errors
 
diff --git a/tests/ui/floating_point_powf.fixed b/tests/ui/floating_point_powf.fixed
index b0641a100cd..7efe10a10f9 100644
--- a/tests/ui/floating_point_powf.fixed
+++ b/tests/ui/floating_point_powf.fixed
@@ -11,10 +11,13 @@ fn main() {
     let _ = (-3.1f32).exp();
     let _ = x.sqrt();
     let _ = x.cbrt();
+    let _ = (x as f32).cbrt();
     let _ = x.powi(3);
     let _ = x.powi(-2);
     let _ = x.powi(16_777_215);
     let _ = x.powi(-16_777_215);
+    let _ = (x as f32).powi(-16_777_215);
+    let _ = (x as f32).powi(3);
     // Cases where the lint shouldn't be applied
     let _ = x.powf(2.1);
     let _ = x.powf(-2.1);
diff --git a/tests/ui/floating_point_powf.rs b/tests/ui/floating_point_powf.rs
index a0a2c973900..445080417f2 100644
--- a/tests/ui/floating_point_powf.rs
+++ b/tests/ui/floating_point_powf.rs
@@ -11,10 +11,13 @@ fn main() {
     let _ = std::f32::consts::E.powf(-3.1);
     let _ = x.powf(1.0 / 2.0);
     let _ = x.powf(1.0 / 3.0);
+    let _ = (x as f32).powf(1.0 / 3.0);
     let _ = x.powf(3.0);
     let _ = x.powf(-2.0);
     let _ = x.powf(16_777_215.0);
     let _ = x.powf(-16_777_215.0);
+    let _ = (x as f32).powf(-16_777_215.0);
+    let _ = (x as f32).powf(3.0);
     // Cases where the lint shouldn't be applied
     let _ = x.powf(2.1);
     let _ = x.powf(-2.1);
diff --git a/tests/ui/floating_point_powf.stderr b/tests/ui/floating_point_powf.stderr
index 2422eb911e9..6ee696e6ada 100644
--- a/tests/ui/floating_point_powf.stderr
+++ b/tests/ui/floating_point_powf.stderr
@@ -50,101 +50,119 @@ LL |     let _ = x.powf(1.0 / 3.0);
    |
    = note: `-D clippy::imprecise-flops` implied by `-D warnings`
 
-error: exponentiation with integer powers can be computed more efficiently
+error: cube-root of a number can be computed more accurately
   --> $DIR/floating_point_powf.rs:14:13
    |
+LL |     let _ = (x as f32).powf(1.0 / 3.0);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(x as f32).cbrt()`
+
+error: exponentiation with integer powers can be computed more efficiently
+  --> $DIR/floating_point_powf.rs:15:13
+   |
 LL |     let _ = x.powf(3.0);
    |             ^^^^^^^^^^^ help: consider using: `x.powi(3)`
 
 error: exponentiation with integer powers can be computed more efficiently
-  --> $DIR/floating_point_powf.rs:15:13
+  --> $DIR/floating_point_powf.rs:16:13
    |
 LL |     let _ = x.powf(-2.0);
    |             ^^^^^^^^^^^^ help: consider using: `x.powi(-2)`
 
 error: exponentiation with integer powers can be computed more efficiently
-  --> $DIR/floating_point_powf.rs:16:13
+  --> $DIR/floating_point_powf.rs:17:13
    |
 LL |     let _ = x.powf(16_777_215.0);
    |             ^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.powi(16_777_215)`
 
 error: exponentiation with integer powers can be computed more efficiently
-  --> $DIR/floating_point_powf.rs:17:13
+  --> $DIR/floating_point_powf.rs:18:13
    |
 LL |     let _ = x.powf(-16_777_215.0);
    |             ^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.powi(-16_777_215)`
 
+error: exponentiation with integer powers can be computed more efficiently
+  --> $DIR/floating_point_powf.rs:19:13
+   |
+LL |     let _ = (x as f32).powf(-16_777_215.0);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(x as f32).powi(-16_777_215)`
+
+error: exponentiation with integer powers can be computed more efficiently
+  --> $DIR/floating_point_powf.rs:20:13
+   |
+LL |     let _ = (x as f32).powf(3.0);
+   |             ^^^^^^^^^^^^^^^^^^^^ help: consider using: `(x as f32).powi(3)`
+
 error: exponent for bases 2 and e can be computed more accurately
-  --> $DIR/floating_point_powf.rs:25:13
+  --> $DIR/floating_point_powf.rs:28:13
    |
 LL |     let _ = 2f64.powf(x);
    |             ^^^^^^^^^^^^ help: consider using: `x.exp2()`
 
 error: exponent for bases 2 and e can be computed more accurately
-  --> $DIR/floating_point_powf.rs:26:13
+  --> $DIR/floating_point_powf.rs:29:13
    |
 LL |     let _ = 2f64.powf(3.1);
    |             ^^^^^^^^^^^^^^ help: consider using: `3.1f64.exp2()`
 
 error: exponent for bases 2 and e can be computed more accurately
-  --> $DIR/floating_point_powf.rs:27:13
+  --> $DIR/floating_point_powf.rs:30:13
    |
 LL |     let _ = 2f64.powf(-3.1);
    |             ^^^^^^^^^^^^^^^ help: consider using: `(-3.1f64).exp2()`
 
 error: exponent for bases 2 and e can be computed more accurately
-  --> $DIR/floating_point_powf.rs:28:13
+  --> $DIR/floating_point_powf.rs:31:13
    |
 LL |     let _ = std::f64::consts::E.powf(x);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.exp()`
 
 error: exponent for bases 2 and e can be computed more accurately
-  --> $DIR/floating_point_powf.rs:29:13
+  --> $DIR/floating_point_powf.rs:32:13
    |
 LL |     let _ = std::f64::consts::E.powf(3.1);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `3.1f64.exp()`
 
 error: exponent for bases 2 and e can be computed more accurately
-  --> $DIR/floating_point_powf.rs:30:13
+  --> $DIR/floating_point_powf.rs:33:13
    |
 LL |     let _ = std::f64::consts::E.powf(-3.1);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(-3.1f64).exp()`
 
 error: square-root of a number can be computed more efficiently and accurately
-  --> $DIR/floating_point_powf.rs:31:13
+  --> $DIR/floating_point_powf.rs:34:13
    |
 LL |     let _ = x.powf(1.0 / 2.0);
    |             ^^^^^^^^^^^^^^^^^ help: consider using: `x.sqrt()`
 
 error: cube-root of a number can be computed more accurately
-  --> $DIR/floating_point_powf.rs:32:13
+  --> $DIR/floating_point_powf.rs:35:13
    |
 LL |     let _ = x.powf(1.0 / 3.0);
    |             ^^^^^^^^^^^^^^^^^ help: consider using: `x.cbrt()`
 
 error: exponentiation with integer powers can be computed more efficiently
-  --> $DIR/floating_point_powf.rs:33:13
+  --> $DIR/floating_point_powf.rs:36:13
    |
 LL |     let _ = x.powf(3.0);
    |             ^^^^^^^^^^^ help: consider using: `x.powi(3)`
 
 error: exponentiation with integer powers can be computed more efficiently
-  --> $DIR/floating_point_powf.rs:34:13
+  --> $DIR/floating_point_powf.rs:37:13
    |
 LL |     let _ = x.powf(-2.0);
    |             ^^^^^^^^^^^^ help: consider using: `x.powi(-2)`
 
 error: exponentiation with integer powers can be computed more efficiently
-  --> $DIR/floating_point_powf.rs:35:13
+  --> $DIR/floating_point_powf.rs:38:13
    |
 LL |     let _ = x.powf(-2_147_483_648.0);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.powi(-2_147_483_648)`
 
 error: exponentiation with integer powers can be computed more efficiently
-  --> $DIR/floating_point_powf.rs:36:13
+  --> $DIR/floating_point_powf.rs:39:13
    |
 LL |     let _ = x.powf(2_147_483_647.0);
    |             ^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.powi(2_147_483_647)`
 
-error: aborting due to 24 previous errors
+error: aborting due to 27 previous errors
 
diff --git a/tests/ui/floating_point_powi.fixed b/tests/ui/floating_point_powi.fixed
index 85f7c531e39..5758db7c6c8 100644
--- a/tests/ui/floating_point_powi.fixed
+++ b/tests/ui/floating_point_powi.fixed
@@ -8,6 +8,7 @@ fn main() {
     let y = 4f32;
     let _ = x.mul_add(x, y);
     let _ = y.mul_add(y, x);
+    let _ = (y as f32).mul_add(y as f32, x);
     let _ = x.mul_add(x, y).sqrt();
     let _ = y.mul_add(y, x).sqrt();
     // Cases where the lint shouldn't be applied
diff --git a/tests/ui/floating_point_powi.rs b/tests/ui/floating_point_powi.rs
index ece61d1bec4..5926bf1b000 100644
--- a/tests/ui/floating_point_powi.rs
+++ b/tests/ui/floating_point_powi.rs
@@ -8,6 +8,7 @@ fn main() {
     let y = 4f32;
     let _ = x.powi(2) + y;
     let _ = x + y.powi(2);
+    let _ = x + (y as f32).powi(2);
     let _ = (x.powi(2) + y).sqrt();
     let _ = (x + y.powi(2)).sqrt();
     // Cases where the lint shouldn't be applied
diff --git a/tests/ui/floating_point_powi.stderr b/tests/ui/floating_point_powi.stderr
index 37d840988bb..a3c74544212 100644
--- a/tests/ui/floating_point_powi.stderr
+++ b/tests/ui/floating_point_powi.stderr
@@ -15,14 +15,20 @@ LL |     let _ = x + y.powi(2);
 error: multiply and add expressions can be calculated more efficiently and accurately
   --> $DIR/floating_point_powi.rs:11:13
    |
+LL |     let _ = x + (y as f32).powi(2);
+   |             ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(y as f32).mul_add(y as f32, x)`
+
+error: multiply and add expressions can be calculated more efficiently and accurately
+  --> $DIR/floating_point_powi.rs:12:13
+   |
 LL |     let _ = (x.powi(2) + y).sqrt();
    |             ^^^^^^^^^^^^^^^ help: consider using: `x.mul_add(x, y)`
 
 error: multiply and add expressions can be calculated more efficiently and accurately
-  --> $DIR/floating_point_powi.rs:12:13
+  --> $DIR/floating_point_powi.rs:13:13
    |
 LL |     let _ = (x + y.powi(2)).sqrt();
    |             ^^^^^^^^^^^^^^^ help: consider using: `y.mul_add(y, x)`
 
-error: aborting due to 4 previous errors
+error: aborting due to 5 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 19ef04ff5df281f248ace29741b1054abf224752 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Tue, 30 Aug 2022 00:33:56 -0400
Subject: Fix the order of `trait_duplication_in_bounds` * Emit the lint in
 source order * Make suggestions with multiple traits be in source order
 rather than alphabetical

---
 clippy_lints/src/trait_bounds.rs                   | 34 ++++++++++++++++------
 tests/ui/trait_duplication_in_bounds.fixed         |  4 +--
 tests/ui/trait_duplication_in_bounds.stderr        |  4 +--
 .../trait_duplication_in_bounds_unfixable.stderr   |  8 ++---
 4 files changed, 33 insertions(+), 17 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/trait_bounds.rs b/clippy_lints/src/trait_bounds.rs
index 0434720f79b..2ffa022b04f 100644
--- a/clippy_lints/src/trait_bounds.rs
+++ b/clippy_lints/src/trait_bounds.rs
@@ -15,6 +15,7 @@ use rustc_hir::{
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::{BytePos, Span};
+use std::collections::hash_map::Entry;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -255,7 +256,7 @@ fn check_trait_bound_duplication(cx: &LateContext<'_>, gen: &'_ Generics<'_>) {
                 then {
                     return Some(
                         rollup_traits(cx, bound_predicate.bounds, "these where clauses contain repeated elements")
-                        .into_keys().map(|trait_ref| (path.res, trait_ref)))
+                        .into_iter().map(|(trait_ref, _)| (path.res, trait_ref)))
                 }
             }
             None
@@ -295,8 +296,13 @@ fn check_trait_bound_duplication(cx: &LateContext<'_>, gen: &'_ Generics<'_>) {
     }
 }
 
-#[derive(PartialEq, Eq, Hash, Debug)]
+#[derive(Clone, PartialEq, Eq, Hash, Debug)]
 struct ComparableTraitRef(Res, Vec<Res>);
+impl Default for ComparableTraitRef {
+    fn default() -> Self {
+        Self(Res::Err, Vec::new())
+    }
+}
 
 fn get_trait_info_from_bound<'a>(bound: &'a GenericBound<'_>) -> Option<(Res, &'a [PathSegment<'a>], Span)> {
     if let GenericBound::Trait(t, tbm) = bound {
@@ -339,7 +345,7 @@ fn into_comparable_trait_ref(trait_ref: &TraitRef<'_>) -> ComparableTraitRef {
     )
 }
 
-fn rollup_traits(cx: &LateContext<'_>, bounds: &[GenericBound<'_>], msg: &str) -> FxHashMap<ComparableTraitRef, Span> {
+fn rollup_traits(cx: &LateContext<'_>, bounds: &[GenericBound<'_>], msg: &str) -> Vec<(ComparableTraitRef, Span)> {
     let mut map = FxHashMap::default();
     let mut repeated_res = false;
 
@@ -351,23 +357,33 @@ fn rollup_traits(cx: &LateContext<'_>, bounds: &[GenericBound<'_>], msg: &str) -
         }
     };
 
+    let mut i = 0usize;
     for bound in bounds.iter().filter_map(only_comparable_trait_refs) {
         let (comparable_bound, span_direct) = bound;
-        if map.insert(comparable_bound, span_direct).is_some() {
-            repeated_res = true;
+        match map.entry(comparable_bound) {
+            Entry::Occupied(_) => repeated_res = true,
+            Entry::Vacant(e) => {
+                e.insert((span_direct, i));
+                i += 1;
+            },
         }
     }
 
+    // Put bounds in source order
+    let mut comparable_bounds = vec![Default::default(); map.len()];
+    for (k, (v, i)) in map {
+        comparable_bounds[i] = (k, v);
+    }
+
     if_chain! {
         if repeated_res;
         if let [first_trait, .., last_trait] = bounds;
         then {
             let all_trait_span = first_trait.span().to(last_trait.span());
 
-            let mut traits = map.values()
-                .filter_map(|span| snippet_opt(cx, *span))
+            let traits = comparable_bounds.iter()
+                .filter_map(|&(_, span)| snippet_opt(cx, span))
                 .collect::<Vec<_>>();
-            traits.sort_unstable();
             let traits = traits.join(" + ");
 
             span_lint_and_sugg(
@@ -382,5 +398,5 @@ fn rollup_traits(cx: &LateContext<'_>, bounds: &[GenericBound<'_>], msg: &str) -
         }
     }
 
-    map
+    comparable_bounds
 }
diff --git a/tests/ui/trait_duplication_in_bounds.fixed b/tests/ui/trait_duplication_in_bounds.fixed
index b4e6bf0ea1c..4ce5d421782 100644
--- a/tests/ui/trait_duplication_in_bounds.fixed
+++ b/tests/ui/trait_duplication_in_bounds.fixed
@@ -97,7 +97,7 @@ fn good_generic<T: GenericTrait<u64> + GenericTrait<u32>>(arg0: T) {
     unimplemented!();
 }
 
-fn bad_generic<T: GenericTrait<u32> + GenericTrait<u64>>(arg0: T) {
+fn bad_generic<T: GenericTrait<u64> + GenericTrait<u32>>(arg0: T) {
     unimplemented!();
 }
 
@@ -105,7 +105,7 @@ mod foo {
     pub trait Clone {}
 }
 
-fn qualified_path<T: Clone + foo::Clone>(arg0: T) {
+fn qualified_path<T: std::clone::Clone + foo::Clone>(arg0: T) {
     unimplemented!();
 }
 
diff --git a/tests/ui/trait_duplication_in_bounds.stderr b/tests/ui/trait_duplication_in_bounds.stderr
index 86c593811a7..af800ba7888 100644
--- a/tests/ui/trait_duplication_in_bounds.stderr
+++ b/tests/ui/trait_duplication_in_bounds.stderr
@@ -44,13 +44,13 @@ error: these bounds contain repeated elements
   --> $DIR/trait_duplication_in_bounds.rs:100:19
    |
 LL | fn bad_generic<T: GenericTrait<u64> + GenericTrait<u32> + GenericTrait<u64>>(arg0: T) {
-   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `GenericTrait<u32> + GenericTrait<u64>`
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `GenericTrait<u64> + GenericTrait<u32>`
 
 error: these bounds contain repeated elements
   --> $DIR/trait_duplication_in_bounds.rs:108:22
    |
 LL | fn qualified_path<T: std::clone::Clone + Clone + foo::Clone>(arg0: T) {
-   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Clone + foo::Clone`
+   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::clone::Clone + foo::Clone`
 
 error: aborting due to 8 previous errors
 
diff --git a/tests/ui/trait_duplication_in_bounds_unfixable.stderr b/tests/ui/trait_duplication_in_bounds_unfixable.stderr
index aa44114eb6c..fbd9abb005f 100644
--- a/tests/ui/trait_duplication_in_bounds_unfixable.stderr
+++ b/tests/ui/trait_duplication_in_bounds_unfixable.stderr
@@ -1,8 +1,8 @@
 error: this trait bound is already specified in the where clause
-  --> $DIR/trait_duplication_in_bounds_unfixable.rs:6:23
+  --> $DIR/trait_duplication_in_bounds_unfixable.rs:6:15
    |
 LL | fn bad_foo<T: Clone + Default, Z: Copy>(arg0: T, arg1: Z)
-   |                       ^^^^^^^
+   |               ^^^^^
    |
 note: the lint level is defined here
   --> $DIR/trait_duplication_in_bounds_unfixable.rs:1:9
@@ -12,10 +12,10 @@ LL | #![deny(clippy::trait_duplication_in_bounds)]
    = help: consider removing this trait bound
 
 error: this trait bound is already specified in the where clause
-  --> $DIR/trait_duplication_in_bounds_unfixable.rs:6:15
+  --> $DIR/trait_duplication_in_bounds_unfixable.rs:6:23
    |
 LL | fn bad_foo<T: Clone + Default, Z: Copy>(arg0: T, arg1: Z)
-   |               ^^^^^
+   |                       ^^^^^^^
    |
    = help: consider removing this trait bound
 
-- 
cgit 1.4.1-3-g733a5


From 66a97055b2721700b472e4460a560c8ded70b3c2 Mon Sep 17 00:00:00 2001
From: Lukas Lueg <lukas.lueg@gmail.com>
Date: Wed, 24 Aug 2022 23:11:19 +0200
Subject: Initial implementation of `result_large_err`

---
 CHANGELOG.md                                       |   1 +
 clippy_lints/src/functions/mod.rs                  |  56 ++++++++++--
 clippy_lints/src/functions/result.rs               | 100 +++++++++++++++++++++
 clippy_lints/src/functions/result_unit_err.rs      |  66 --------------
 clippy_lints/src/lib.register_all.rs               |   1 +
 clippy_lints/src/lib.register_lints.rs             |   1 +
 clippy_lints/src/lib.register_perf.rs              |   1 +
 clippy_lints/src/lib.rs                            |   2 +
 clippy_lints/src/utils/conf.rs                     |   4 +
 clippy_utils/src/ty.rs                             |  50 +++++++++++
 .../toml_unknown_key/conf_unknown_key.stderr       |   1 +
 tests/ui/result_large_err.rs                       |  98 ++++++++++++++++++++
 tests/ui/result_large_err.stderr                   |  91 +++++++++++++++++++
 13 files changed, 401 insertions(+), 71 deletions(-)
 create mode 100644 clippy_lints/src/functions/result.rs
 delete mode 100644 clippy_lints/src/functions/result_unit_err.rs
 create mode 100644 tests/ui/result_large_err.rs
 create mode 100644 tests/ui/result_large_err.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 69ce0a201bf..c488c142e46 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4025,6 +4025,7 @@ Released 2018-09-13
 [`replace_consts`]: https://rust-lang.github.io/rust-clippy/master/index.html#replace_consts
 [`rest_pat_in_fully_bound_structs`]: https://rust-lang.github.io/rust-clippy/master/index.html#rest_pat_in_fully_bound_structs
 [`result_expect_used`]: https://rust-lang.github.io/rust-clippy/master/index.html#result_expect_used
+[`result_large_err`]: https://rust-lang.github.io/rust-clippy/master/index.html#result_large_err
 [`result_map_or_into_option`]: https://rust-lang.github.io/rust-clippy/master/index.html#result_map_or_into_option
 [`result_map_unit_fn`]: https://rust-lang.github.io/rust-clippy/master/index.html#result_map_unit_fn
 [`result_map_unwrap_or_else`]: https://rust-lang.github.io/rust-clippy/master/index.html#result_map_unwrap_or_else
diff --git a/clippy_lints/src/functions/mod.rs b/clippy_lints/src/functions/mod.rs
index 73261fb8a44..90911e0bf25 100644
--- a/clippy_lints/src/functions/mod.rs
+++ b/clippy_lints/src/functions/mod.rs
@@ -1,6 +1,6 @@
 mod must_use;
 mod not_unsafe_ptr_arg_deref;
-mod result_unit_err;
+mod result;
 mod too_many_arguments;
 mod too_many_lines;
 
@@ -217,17 +217,62 @@ declare_clippy_lint! {
     "public function returning `Result` with an `Err` type of `()`"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for functions that return `Result` with an unusually large
+    /// `Err`-variant.
+    ///
+    /// ### Why is this bad?
+    /// A `Result` is at least as large as the `Err`-variant. While we
+    /// expect that variant to be seldomly used, the compiler needs to reserve
+    /// and move that much memory every single time.
+    ///
+    /// ### Known problems
+    /// The size determined by Clippy is platform-dependent.
+    ///
+    /// ### Examples
+    /// ```rust
+    /// pub enum ParseError {
+    ///     UnparsedBytes([u8; 512]),
+    ///     UnexpectedEof,
+    /// }
+    ///
+    /// // The `Result` has at least 512 bytes, even in the `Ok`-case
+    /// pub fn parse() -> Result<(), ParseError> {
+    ///     Ok(())
+    /// }
+    /// ```
+    /// should be
+    /// ```
+    /// pub enum ParseError {
+    ///     UnparsedBytes(Box<[u8; 512]>),
+    ///     UnexpectedEof,
+    /// }
+    ///
+    /// // The `Result` is slightly larger than a pointer
+    /// pub fn parse() -> Result<(), ParseError> {
+    ///     Ok(())
+    /// }
+    /// ```
+    #[clippy::version = "1.64.0"]
+    pub RESULT_LARGE_ERR,
+    perf,
+    "function returning `Result` with large `Err` type"
+}
+
 #[derive(Copy, Clone)]
 pub struct Functions {
     too_many_arguments_threshold: u64,
     too_many_lines_threshold: u64,
+    large_error_threshold: u64,
 }
 
 impl Functions {
-    pub fn new(too_many_arguments_threshold: u64, too_many_lines_threshold: u64) -> Self {
+    pub fn new(too_many_arguments_threshold: u64, too_many_lines_threshold: u64, large_error_threshold: u64) -> Self {
         Self {
             too_many_arguments_threshold,
             too_many_lines_threshold,
+            large_error_threshold,
         }
     }
 }
@@ -240,6 +285,7 @@ impl_lint_pass!(Functions => [
     DOUBLE_MUST_USE,
     MUST_USE_CANDIDATE,
     RESULT_UNIT_ERR,
+    RESULT_LARGE_ERR,
 ]);
 
 impl<'tcx> LateLintPass<'tcx> for Functions {
@@ -259,18 +305,18 @@ impl<'tcx> LateLintPass<'tcx> for Functions {
 
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) {
         must_use::check_item(cx, item);
-        result_unit_err::check_item(cx, item);
+        result::check_item(cx, item, self.large_error_threshold);
     }
 
     fn check_impl_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::ImplItem<'_>) {
         must_use::check_impl_item(cx, item);
-        result_unit_err::check_impl_item(cx, item);
+        result::check_impl_item(cx, item, self.large_error_threshold);
     }
 
     fn check_trait_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::TraitItem<'_>) {
         too_many_arguments::check_trait_item(cx, item, self.too_many_arguments_threshold);
         not_unsafe_ptr_arg_deref::check_trait_item(cx, item);
         must_use::check_trait_item(cx, item);
-        result_unit_err::check_trait_item(cx, item);
+        result::check_trait_item(cx, item, self.large_error_threshold);
     }
 }
diff --git a/clippy_lints/src/functions/result.rs b/clippy_lints/src/functions/result.rs
new file mode 100644
index 00000000000..af520a493ed
--- /dev/null
+++ b/clippy_lints/src/functions/result.rs
@@ -0,0 +1,100 @@
+use rustc_errors::Diagnostic;
+use rustc_hir as hir;
+use rustc_lint::{LateContext, LintContext};
+use rustc_middle::lint::in_external_macro;
+use rustc_middle::ty::{self, Ty};
+use rustc_span::{sym, Span};
+use rustc_typeck::hir_ty_to_ty;
+
+use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_then};
+use clippy_utils::trait_ref_of_method;
+use clippy_utils::ty::{approx_ty_size, is_type_diagnostic_item};
+
+use super::{RESULT_LARGE_ERR, RESULT_UNIT_ERR};
+
+/// The type of the `Err`-variant in a `std::result::Result` returned by the
+/// given `FnDecl`
+fn result_err_ty<'tcx>(
+    cx: &LateContext<'tcx>,
+    decl: &hir::FnDecl<'tcx>,
+    item_span: Span,
+) -> Option<(&'tcx hir::Ty<'tcx>, Ty<'tcx>)> {
+    if !in_external_macro(cx.sess(), item_span)
+        && let hir::FnRetTy::Return(hir_ty) = decl.output
+        && let ty = hir_ty_to_ty(cx.tcx, hir_ty)
+        && is_type_diagnostic_item(cx, ty, sym::Result)
+        && let ty::Adt(_, substs) = ty.kind()
+    {
+        let err_ty = substs.type_at(1);
+        Some((hir_ty, err_ty))
+    } else {
+        None
+    }
+}
+
+pub(super) fn check_item<'tcx>(cx: &LateContext<'tcx>, item: &hir::Item<'tcx>, large_err_threshold: u64) {
+    if let hir::ItemKind::Fn(ref sig, _generics, _) = item.kind
+        && let Some((hir_ty, err_ty)) = result_err_ty(cx, sig.decl, item.span)
+    {
+        if cx.access_levels.is_exported(item.def_id) {
+            let fn_header_span = item.span.with_hi(sig.decl.output.span().hi());
+            check_result_unit_err(cx, err_ty, fn_header_span);
+        }
+        check_result_large_err(cx, err_ty, hir_ty.span, large_err_threshold);
+    }
+}
+
+pub(super) fn check_impl_item<'tcx>(cx: &LateContext<'tcx>, item: &hir::ImplItem<'tcx>, large_err_threshold: u64) {
+    // Don't lint if method is a trait's implementation, we can't do anything about those
+    if let hir::ImplItemKind::Fn(ref sig, _) = item.kind
+        && let Some((hir_ty, err_ty)) = result_err_ty(cx, sig.decl, item.span)
+        && trait_ref_of_method(cx, item.def_id).is_none()
+    {
+        if cx.access_levels.is_exported(item.def_id) {
+            let fn_header_span = item.span.with_hi(sig.decl.output.span().hi());
+            check_result_unit_err(cx, err_ty, fn_header_span);
+        }
+        check_result_large_err(cx, err_ty, hir_ty.span, large_err_threshold);
+    }
+}
+
+pub(super) fn check_trait_item<'tcx>(cx: &LateContext<'tcx>, item: &hir::TraitItem<'tcx>, large_err_threshold: u64) {
+    if let hir::TraitItemKind::Fn(ref sig, _) = item.kind {
+        let fn_header_span = item.span.with_hi(sig.decl.output.span().hi());
+        if let Some((hir_ty, err_ty)) = result_err_ty(cx, sig.decl, item.span) {
+            if cx.access_levels.is_exported(item.def_id) {
+                check_result_unit_err(cx, err_ty, fn_header_span);
+            }
+            check_result_large_err(cx, err_ty, hir_ty.span, large_err_threshold);
+        }
+    }
+}
+
+fn check_result_unit_err(cx: &LateContext<'_>, err_ty: Ty<'_>, fn_header_span: Span) {
+    if err_ty.is_unit() {
+        span_lint_and_help(
+            cx,
+            RESULT_UNIT_ERR,
+            fn_header_span,
+            "this returns a `Result<_, ()>`",
+            None,
+            "use a custom `Error` type instead",
+        );
+    }
+}
+
+fn check_result_large_err<'tcx>(cx: &LateContext<'tcx>, err_ty: Ty<'tcx>, hir_ty_span: Span, large_err_threshold: u64) {
+    let ty_size = approx_ty_size(cx, err_ty);
+    if ty_size >= large_err_threshold {
+        span_lint_and_then(
+            cx,
+            RESULT_LARGE_ERR,
+            hir_ty_span,
+            "the `Err`-variant returned from this function is very large",
+            |diag: &mut Diagnostic| {
+                diag.span_label(hir_ty_span, format!("the `Err`-variant is at least {ty_size} bytes"));
+                diag.help(format!("try reducing the size of `{err_ty}`, for example by boxing large elements or replacing it with `Box<{err_ty}>`"));
+            },
+        );
+    }
+}
diff --git a/clippy_lints/src/functions/result_unit_err.rs b/clippy_lints/src/functions/result_unit_err.rs
deleted file mode 100644
index 2e63a1f920d..00000000000
--- a/clippy_lints/src/functions/result_unit_err.rs
+++ /dev/null
@@ -1,66 +0,0 @@
-use rustc_hir as hir;
-use rustc_lint::{LateContext, LintContext};
-use rustc_middle::lint::in_external_macro;
-use rustc_middle::ty;
-use rustc_span::{sym, Span};
-use rustc_typeck::hir_ty_to_ty;
-
-use if_chain::if_chain;
-
-use clippy_utils::diagnostics::span_lint_and_help;
-use clippy_utils::trait_ref_of_method;
-use clippy_utils::ty::is_type_diagnostic_item;
-
-use super::RESULT_UNIT_ERR;
-
-pub(super) fn check_item(cx: &LateContext<'_>, item: &hir::Item<'_>) {
-    if let hir::ItemKind::Fn(ref sig, _generics, _) = item.kind {
-        let is_public = cx.access_levels.is_exported(item.def_id);
-        let fn_header_span = item.span.with_hi(sig.decl.output.span().hi());
-        if is_public {
-            check_result_unit_err(cx, sig.decl, item.span, fn_header_span);
-        }
-    }
-}
-
-pub(super) fn check_impl_item(cx: &LateContext<'_>, item: &hir::ImplItem<'_>) {
-    if let hir::ImplItemKind::Fn(ref sig, _) = item.kind {
-        let is_public = cx.access_levels.is_exported(item.def_id);
-        let fn_header_span = item.span.with_hi(sig.decl.output.span().hi());
-        if is_public && trait_ref_of_method(cx, item.def_id).is_none() {
-            check_result_unit_err(cx, sig.decl, item.span, fn_header_span);
-        }
-    }
-}
-
-pub(super) fn check_trait_item(cx: &LateContext<'_>, item: &hir::TraitItem<'_>) {
-    if let hir::TraitItemKind::Fn(ref sig, _) = item.kind {
-        let is_public = cx.access_levels.is_exported(item.def_id);
-        let fn_header_span = item.span.with_hi(sig.decl.output.span().hi());
-        if is_public {
-            check_result_unit_err(cx, sig.decl, item.span, fn_header_span);
-        }
-    }
-}
-
-fn check_result_unit_err(cx: &LateContext<'_>, decl: &hir::FnDecl<'_>, item_span: Span, fn_header_span: Span) {
-    if_chain! {
-        if !in_external_macro(cx.sess(), item_span);
-        if let hir::FnRetTy::Return(ty) = decl.output;
-        let ty = hir_ty_to_ty(cx.tcx, ty);
-        if is_type_diagnostic_item(cx, ty, sym::Result);
-        if let ty::Adt(_, substs) = ty.kind();
-        let err_ty = substs.type_at(1);
-        if err_ty.is_unit();
-        then {
-            span_lint_and_help(
-                cx,
-                RESULT_UNIT_ERR,
-                fn_header_span,
-                "this returns a `Result<_, ()>`",
-                None,
-                "use a custom `Error` type instead",
-            );
-        }
-    }
-}
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 700762fa3ef..134cbbf7b5c 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -80,6 +80,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(functions::DOUBLE_MUST_USE),
     LintId::of(functions::MUST_USE_UNIT),
     LintId::of(functions::NOT_UNSAFE_PTR_ARG_DEREF),
+    LintId::of(functions::RESULT_LARGE_ERR),
     LintId::of(functions::RESULT_UNIT_ERR),
     LintId::of(functions::TOO_MANY_ARGUMENTS),
     LintId::of(if_let_mutex::IF_LET_MUTEX),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index ee94165d2ed..fd20e016578 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -171,6 +171,7 @@ store.register_lints(&[
     functions::MUST_USE_CANDIDATE,
     functions::MUST_USE_UNIT,
     functions::NOT_UNSAFE_PTR_ARG_DEREF,
+    functions::RESULT_LARGE_ERR,
     functions::RESULT_UNIT_ERR,
     functions::TOO_MANY_ARGUMENTS,
     functions::TOO_MANY_LINES,
diff --git a/clippy_lints/src/lib.register_perf.rs b/clippy_lints/src/lib.register_perf.rs
index 531fc47f8fa..195ce41e31e 100644
--- a/clippy_lints/src/lib.register_perf.rs
+++ b/clippy_lints/src/lib.register_perf.rs
@@ -7,6 +7,7 @@ store.register_group(true, "clippy::perf", Some("clippy_perf"), vec![
     LintId::of(escape::BOXED_LOCAL),
     LintId::of(format_args::FORMAT_IN_FORMAT_ARGS),
     LintId::of(format_args::TO_STRING_IN_FORMAT_ARGS),
+    LintId::of(functions::RESULT_LARGE_ERR),
     LintId::of(large_const_arrays::LARGE_CONST_ARRAYS),
     LintId::of(large_enum_variant::LARGE_ENUM_VARIANT),
     LintId::of(loops::MANUAL_MEMCPY),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 05d4dbd6859..178e57aaf61 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -668,10 +668,12 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(move || Box::new(disallowed_names::DisallowedNames::new(disallowed_names.clone())));
     let too_many_arguments_threshold = conf.too_many_arguments_threshold;
     let too_many_lines_threshold = conf.too_many_lines_threshold;
+    let large_error_threshold = conf.large_error_threshold;
     store.register_late_pass(move || {
         Box::new(functions::Functions::new(
             too_many_arguments_threshold,
             too_many_lines_threshold,
+            large_error_threshold,
         ))
     });
     let doc_valid_idents = conf.doc_valid_idents.iter().cloned().collect::<FxHashSet<_>>();
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 47b72f4783e..84e65d5fa0b 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -379,6 +379,10 @@ define_Conf! {
     ///
     /// Whether `dbg!` should be allowed in test functions
     (allow_dbg_in_tests: bool = false),
+    /// Lint: RESULT_LARGE_ERR
+    ///
+    /// The maximum size of the `Err`-variant in a `Result` returned from a function
+    (large_error_threshold: u64 = 128),
 }
 
 /// Search for the configuration file.
diff --git a/clippy_utils/src/ty.rs b/clippy_utils/src/ty.rs
index 00182e739b8..5a7f9568441 100644
--- a/clippy_utils/src/ty.rs
+++ b/clippy_utils/src/ty.rs
@@ -831,3 +831,53 @@ pub fn ty_is_fn_once_param<'tcx>(tcx: TyCtxt<'_>, ty: Ty<'tcx>, predicates: &'tc
         })
         .unwrap_or(false)
 }
+
+/// Comes up with an "at least" guesstimate for the type's size, not taking into
+/// account the layout of type parameters.
+pub fn approx_ty_size<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> u64 {
+    use rustc_middle::ty::layout::LayoutOf;
+    if !is_normalizable(cx, cx.param_env, ty) {
+        return 0;
+    }
+    match (cx.layout_of(ty).map(|layout| layout.size.bytes()), ty.kind()) {
+        (Ok(size), _) => size,
+        (Err(_), ty::Tuple(list)) => list.as_substs().types().map(|t| approx_ty_size(cx, t)).sum(),
+        (Err(_), ty::Array(t, n)) => {
+            n.try_eval_usize(cx.tcx, cx.param_env).unwrap_or_default() * approx_ty_size(cx, *t)
+        },
+        (Err(_), ty::Adt(def, subst)) if def.is_struct() => def
+            .variants()
+            .iter()
+            .map(|v| {
+                v.fields
+                    .iter()
+                    .map(|field| approx_ty_size(cx, field.ty(cx.tcx, subst)))
+                    .sum::<u64>()
+            })
+            .sum(),
+        (Err(_), ty::Adt(def, subst)) if def.is_enum() => def
+            .variants()
+            .iter()
+            .map(|v| {
+                v.fields
+                    .iter()
+                    .map(|field| approx_ty_size(cx, field.ty(cx.tcx, subst)))
+                    .sum::<u64>()
+            })
+            .max()
+            .unwrap_or_default(),
+        (Err(_), ty::Adt(def, subst)) if def.is_union() => def
+            .variants()
+            .iter()
+            .map(|v| {
+                v.fields
+                    .iter()
+                    .map(|field| approx_ty_size(cx, field.ty(cx.tcx, subst)))
+                    .max()
+                    .unwrap_or_default()
+            })
+            .max()
+            .unwrap_or_default(),
+        (Err(_), _) => 0,
+    }
+}
diff --git a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
index 9f8e778b3b9..a52a0b5289f 100644
--- a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
+++ b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
@@ -19,6 +19,7 @@ error: error reading Clippy's configuration file `$DIR/clippy.toml`: unknown fie
            enforced-import-renames
            enum-variant-name-threshold
            enum-variant-size-threshold
+           large-error-threshold
            literal-representation-threshold
            max-fn-params-bools
            max-include-file-size
diff --git a/tests/ui/result_large_err.rs b/tests/ui/result_large_err.rs
new file mode 100644
index 00000000000..78d8f76fe66
--- /dev/null
+++ b/tests/ui/result_large_err.rs
@@ -0,0 +1,98 @@
+#![warn(clippy::result_large_err)]
+
+pub fn small_err() -> Result<(), u128> {
+    Ok(())
+}
+
+pub fn large_err() -> Result<(), [u8; 512]> {
+    Ok(())
+}
+
+pub struct FullyDefinedLargeError {
+    _foo: u128,
+    _bar: [u8; 100],
+    _foobar: [u8; 120],
+}
+
+impl FullyDefinedLargeError {
+    pub fn ret() -> Result<(), Self> {
+        Ok(())
+    }
+}
+
+pub fn struct_error() -> Result<(), FullyDefinedLargeError> {
+    Ok(())
+}
+
+type Fdlr<T> = std::result::Result<T, FullyDefinedLargeError>;
+pub fn large_err_via_type_alias<T>(x: T) -> Fdlr<T> {
+    Ok(x)
+}
+
+pub fn param_small_error<R>() -> Result<(), (R, u128)> {
+    Ok(())
+}
+
+pub fn param_large_error<R>() -> Result<(), (u128, R, FullyDefinedLargeError)> {
+    Ok(())
+}
+
+pub enum LargeErrorVariants<T> {
+    _Small(u8),
+    _Omg([u8; 512]),
+    _Param(T),
+}
+
+impl LargeErrorVariants<()> {
+    pub fn large_enum_error() -> Result<(), Self> {
+        Ok(())
+    }
+}
+
+trait TraitForcesLargeError {
+    fn large_error() -> Result<(), [u8; 512]> {
+        Ok(())
+    }
+}
+
+struct TraitImpl;
+
+impl TraitForcesLargeError for TraitImpl {
+    // Should not lint
+    fn large_error() -> Result<(), [u8; 512]> {
+        Ok(())
+    }
+}
+
+pub union FullyDefinedUnionError {
+    _maybe: u8,
+    _or_even: [[u8; 16]; 32],
+}
+
+pub fn large_union_err() -> Result<(), FullyDefinedUnionError> {
+    Ok(())
+}
+
+pub union UnionError<T: Copy> {
+    _maybe: T,
+    _or_perhaps_even: (T, [u8; 512]),
+}
+
+pub fn param_large_union<T: Copy>() -> Result<(), UnionError<T>> {
+    Ok(())
+}
+
+pub struct ArrayError<T, U> {
+    _large_array: [T; 32],
+    _other_stuff: U,
+}
+
+pub fn array_error_subst<U>() -> Result<(), ArrayError<i32, U>> {
+    Ok(())
+}
+
+pub fn array_error<T, U>() -> Result<(), ArrayError<(i32, T), U>> {
+    Ok(())
+}
+
+fn main() {}
diff --git a/tests/ui/result_large_err.stderr b/tests/ui/result_large_err.stderr
new file mode 100644
index 00000000000..0f1f39d72cb
--- /dev/null
+++ b/tests/ui/result_large_err.stderr
@@ -0,0 +1,91 @@
+error: the `Err`-variant returned from this function is very large
+  --> $DIR/result_large_err.rs:7:23
+   |
+LL | pub fn large_err() -> Result<(), [u8; 512]> {
+   |                       ^^^^^^^^^^^^^^^^^^^^^ the `Err`-variant is at least 512 bytes
+   |
+   = note: `-D clippy::result-large-err` implied by `-D warnings`
+   = help: try reducing the size of `[u8; 512]`, for example by boxing large elements or replacing it with `Box<[u8; 512]>`
+
+error: the `Err`-variant returned from this function is very large
+  --> $DIR/result_large_err.rs:18:21
+   |
+LL |     pub fn ret() -> Result<(), Self> {
+   |                     ^^^^^^^^^^^^^^^^ the `Err`-variant is at least 240 bytes
+   |
+   = help: try reducing the size of `FullyDefinedLargeError`, for example by boxing large elements or replacing it with `Box<FullyDefinedLargeError>`
+
+error: the `Err`-variant returned from this function is very large
+  --> $DIR/result_large_err.rs:23:26
+   |
+LL | pub fn struct_error() -> Result<(), FullyDefinedLargeError> {
+   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the `Err`-variant is at least 240 bytes
+   |
+   = help: try reducing the size of `FullyDefinedLargeError`, for example by boxing large elements or replacing it with `Box<FullyDefinedLargeError>`
+
+error: the `Err`-variant returned from this function is very large
+  --> $DIR/result_large_err.rs:28:45
+   |
+LL | pub fn large_err_via_type_alias<T>(x: T) -> Fdlr<T> {
+   |                                             ^^^^^^^ the `Err`-variant is at least 240 bytes
+   |
+   = help: try reducing the size of `FullyDefinedLargeError`, for example by boxing large elements or replacing it with `Box<FullyDefinedLargeError>`
+
+error: the `Err`-variant returned from this function is very large
+  --> $DIR/result_large_err.rs:36:34
+   |
+LL | pub fn param_large_error<R>() -> Result<(), (u128, R, FullyDefinedLargeError)> {
+   |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the `Err`-variant is at least 256 bytes
+   |
+   = help: try reducing the size of `(u128, R, FullyDefinedLargeError)`, for example by boxing large elements or replacing it with `Box<(u128, R, FullyDefinedLargeError)>`
+
+error: the `Err`-variant returned from this function is very large
+  --> $DIR/result_large_err.rs:47:34
+   |
+LL |     pub fn large_enum_error() -> Result<(), Self> {
+   |                                  ^^^^^^^^^^^^^^^^ the `Err`-variant is at least 513 bytes
+   |
+   = help: try reducing the size of `LargeErrorVariants<()>`, for example by boxing large elements or replacing it with `Box<LargeErrorVariants<()>>`
+
+error: the `Err`-variant returned from this function is very large
+  --> $DIR/result_large_err.rs:53:25
+   |
+LL |     fn large_error() -> Result<(), [u8; 512]> {
+   |                         ^^^^^^^^^^^^^^^^^^^^^ the `Err`-variant is at least 512 bytes
+   |
+   = help: try reducing the size of `[u8; 512]`, for example by boxing large elements or replacing it with `Box<[u8; 512]>`
+
+error: the `Err`-variant returned from this function is very large
+  --> $DIR/result_large_err.rs:72:29
+   |
+LL | pub fn large_union_err() -> Result<(), FullyDefinedUnionError> {
+   |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the `Err`-variant is at least 512 bytes
+   |
+   = help: try reducing the size of `FullyDefinedUnionError`, for example by boxing large elements or replacing it with `Box<FullyDefinedUnionError>`
+
+error: the `Err`-variant returned from this function is very large
+  --> $DIR/result_large_err.rs:81:40
+   |
+LL | pub fn param_large_union<T: Copy>() -> Result<(), UnionError<T>> {
+   |                                        ^^^^^^^^^^^^^^^^^^^^^^^^^ the `Err`-variant is at least 512 bytes
+   |
+   = help: try reducing the size of `UnionError<T>`, for example by boxing large elements or replacing it with `Box<UnionError<T>>`
+
+error: the `Err`-variant returned from this function is very large
+  --> $DIR/result_large_err.rs:90:34
+   |
+LL | pub fn array_error_subst<U>() -> Result<(), ArrayError<i32, U>> {
+   |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the `Err`-variant is at least 128 bytes
+   |
+   = help: try reducing the size of `ArrayError<i32, U>`, for example by boxing large elements or replacing it with `Box<ArrayError<i32, U>>`
+
+error: the `Err`-variant returned from this function is very large
+  --> $DIR/result_large_err.rs:94:31
+   |
+LL | pub fn array_error<T, U>() -> Result<(), ArrayError<(i32, T), U>> {
+   |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the `Err`-variant is at least 128 bytes
+   |
+   = help: try reducing the size of `ArrayError<(i32, T), U>`, for example by boxing large elements or replacing it with `Box<ArrayError<(i32, T), U>>`
+
+error: aborting due to 11 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 28a055dceacd61d1a0faad075d69f71dfd439678 Mon Sep 17 00:00:00 2001
From: Tim Siegel <siegeltr@gmail.com>
Date: Wed, 31 Aug 2022 09:09:11 -0400
Subject: match_wild_err_arm: Fix typo in note text

---
 clippy_lints/src/matches/match_wild_err_arm.rs | 2 +-
 tests/ui/match_wild_err_arm.edition2018.stderr | 8 ++++----
 tests/ui/match_wild_err_arm.edition2021.stderr | 8 ++++----
 3 files changed, 9 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/match_wild_err_arm.rs b/clippy_lints/src/matches/match_wild_err_arm.rs
index bc16f17b619..a3aa2e4b389 100644
--- a/clippy_lints/src/matches/match_wild_err_arm.rs
+++ b/clippy_lints/src/matches/match_wild_err_arm.rs
@@ -40,7 +40,7 @@ pub(crate) fn check<'tcx>(cx: &LateContext<'tcx>, ex: &Expr<'tcx>, arms: &[Arm<'
                                 arm.pat.span,
                                 &format!("`Err({})` matches all errors", ident_bind_name),
                                 None,
-                                "match each error separately or use the error output, or use `.except(msg)` if the error case is unreachable",
+                                "match each error separately or use the error output, or use `.expect(msg)` if the error case is unreachable",
                             );
                         }
                     }
diff --git a/tests/ui/match_wild_err_arm.edition2018.stderr b/tests/ui/match_wild_err_arm.edition2018.stderr
index 2a4012039ba..2d66daea804 100644
--- a/tests/ui/match_wild_err_arm.edition2018.stderr
+++ b/tests/ui/match_wild_err_arm.edition2018.stderr
@@ -5,7 +5,7 @@ LL |         Err(_) => panic!("err"),
    |         ^^^^^^
    |
    = note: `-D clippy::match-wild-err-arm` implied by `-D warnings`
-   = note: match each error separately or use the error output, or use `.except(msg)` if the error case is unreachable
+   = note: match each error separately or use the error output, or use `.expect(msg)` if the error case is unreachable
 
 error: `Err(_)` matches all errors
   --> $DIR/match_wild_err_arm.rs:20:9
@@ -13,7 +13,7 @@ error: `Err(_)` matches all errors
 LL |         Err(_) => panic!(),
    |         ^^^^^^
    |
-   = note: match each error separately or use the error output, or use `.except(msg)` if the error case is unreachable
+   = note: match each error separately or use the error output, or use `.expect(msg)` if the error case is unreachable
 
 error: `Err(_)` matches all errors
   --> $DIR/match_wild_err_arm.rs:26:9
@@ -21,7 +21,7 @@ error: `Err(_)` matches all errors
 LL |         Err(_) => {
    |         ^^^^^^
    |
-   = note: match each error separately or use the error output, or use `.except(msg)` if the error case is unreachable
+   = note: match each error separately or use the error output, or use `.expect(msg)` if the error case is unreachable
 
 error: `Err(_e)` matches all errors
   --> $DIR/match_wild_err_arm.rs:34:9
@@ -29,7 +29,7 @@ error: `Err(_e)` matches all errors
 LL |         Err(_e) => panic!(),
    |         ^^^^^^^
    |
-   = note: match each error separately or use the error output, or use `.except(msg)` if the error case is unreachable
+   = note: match each error separately or use the error output, or use `.expect(msg)` if the error case is unreachable
 
 error: aborting due to 4 previous errors
 
diff --git a/tests/ui/match_wild_err_arm.edition2021.stderr b/tests/ui/match_wild_err_arm.edition2021.stderr
index 2a4012039ba..2d66daea804 100644
--- a/tests/ui/match_wild_err_arm.edition2021.stderr
+++ b/tests/ui/match_wild_err_arm.edition2021.stderr
@@ -5,7 +5,7 @@ LL |         Err(_) => panic!("err"),
    |         ^^^^^^
    |
    = note: `-D clippy::match-wild-err-arm` implied by `-D warnings`
-   = note: match each error separately or use the error output, or use `.except(msg)` if the error case is unreachable
+   = note: match each error separately or use the error output, or use `.expect(msg)` if the error case is unreachable
 
 error: `Err(_)` matches all errors
   --> $DIR/match_wild_err_arm.rs:20:9
@@ -13,7 +13,7 @@ error: `Err(_)` matches all errors
 LL |         Err(_) => panic!(),
    |         ^^^^^^
    |
-   = note: match each error separately or use the error output, or use `.except(msg)` if the error case is unreachable
+   = note: match each error separately or use the error output, or use `.expect(msg)` if the error case is unreachable
 
 error: `Err(_)` matches all errors
   --> $DIR/match_wild_err_arm.rs:26:9
@@ -21,7 +21,7 @@ error: `Err(_)` matches all errors
 LL |         Err(_) => {
    |         ^^^^^^
    |
-   = note: match each error separately or use the error output, or use `.except(msg)` if the error case is unreachable
+   = note: match each error separately or use the error output, or use `.expect(msg)` if the error case is unreachable
 
 error: `Err(_e)` matches all errors
   --> $DIR/match_wild_err_arm.rs:34:9
@@ -29,7 +29,7 @@ error: `Err(_e)` matches all errors
 LL |         Err(_e) => panic!(),
    |         ^^^^^^^
    |
-   = note: match each error separately or use the error output, or use `.except(msg)` if the error case is unreachable
+   = note: match each error separately or use the error output, or use `.expect(msg)` if the error case is unreachable
 
 error: aborting due to 4 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From d4a0785464f567c8781f15819f8be74a95b0a3f0 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Wed, 31 Aug 2022 23:24:29 -0400
Subject: Correctly handle unescape warnings

---
 clippy_dev/src/update_lints.rs   |  6 +++++-
 clippy_lints/src/write.rs        |  6 +++++-
 clippy_utils/src/macros.rs       |  6 ++++--
 tests/ui/crashes/ice-9405.rs     | 11 +++++++++++
 tests/ui/crashes/ice-9405.stderr | 11 +++++++++++
 5 files changed, 36 insertions(+), 4 deletions(-)
 create mode 100644 tests/ui/crashes/ice-9405.rs
 create mode 100644 tests/ui/crashes/ice-9405.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_dev/src/update_lints.rs b/clippy_dev/src/update_lints.rs
index c503142e5e4..28bec872c08 100644
--- a/clippy_dev/src/update_lints.rs
+++ b/clippy_dev/src/update_lints.rs
@@ -977,7 +977,11 @@ fn remove_line_splices(s: &str) -> String {
         .and_then(|s| s.strip_suffix('"'))
         .unwrap_or_else(|| panic!("expected quoted string, found `{}`", s));
     let mut res = String::with_capacity(s.len());
-    unescape::unescape_literal(s, unescape::Mode::Str, &mut |range, _| res.push_str(&s[range]));
+    unescape::unescape_literal(s, unescape::Mode::Str, &mut |range, ch| {
+        if ch.is_ok() {
+            res.push_str(&s[range]);
+        }
+    });
     res
 }
 
diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs
index 5533840b166..abd681c5307 100644
--- a/clippy_lints/src/write.rs
+++ b/clippy_lints/src/write.rs
@@ -805,7 +805,11 @@ fn check_newlines(fmtstr: &StrLit) -> bool {
     let contents = fmtstr.symbol.as_str();
 
     let mut cb = |r: Range<usize>, c: Result<char, EscapeError>| {
-        let c = c.unwrap();
+        let c = match c {
+            Ok(c) => c,
+            Err(e) if !e.is_fatal() => return,
+            Err(e) => panic!("{:?}", e),
+        };
 
         if r.end == contents.len() && c == '\n' && !last_was_cr && !has_internal_newline {
             should_lint = true;
diff --git a/clippy_utils/src/macros.rs b/clippy_utils/src/macros.rs
index e5ca3545540..6b7d5e9aea8 100644
--- a/clippy_utils/src/macros.rs
+++ b/clippy_utils/src/macros.rs
@@ -389,8 +389,10 @@ impl FormatString {
         };
 
         let mut unescaped = String::with_capacity(inner.len());
-        unescape_literal(inner, mode, &mut |_, ch| {
-            unescaped.push(ch.unwrap());
+        unescape_literal(inner, mode, &mut |_, ch| match ch {
+            Ok(ch) => unescaped.push(ch),
+            Err(e) if !e.is_fatal() => (),
+            Err(e) => panic!("{:?}", e),
         });
 
         let mut parts = Vec::new();
diff --git a/tests/ui/crashes/ice-9405.rs b/tests/ui/crashes/ice-9405.rs
new file mode 100644
index 00000000000..e2d274aeb04
--- /dev/null
+++ b/tests/ui/crashes/ice-9405.rs
@@ -0,0 +1,11 @@
+#![warn(clippy::useless_format)]
+#![allow(clippy::print_literal)]
+
+fn main() {
+    println!(
+        "\
+
+            {}",
+        "multiple skipped lines"
+    );
+}
diff --git a/tests/ui/crashes/ice-9405.stderr b/tests/ui/crashes/ice-9405.stderr
new file mode 100644
index 00000000000..9a6e410f21e
--- /dev/null
+++ b/tests/ui/crashes/ice-9405.stderr
@@ -0,0 +1,11 @@
+warning: multiple lines skipped by escaped newline
+  --> $DIR/ice-9405.rs:6:10
+   |
+LL |           "/
+   |  __________^
+LL | |
+LL | |             {}",
+   | |____________^ skipping everything up to and including this point
+
+warning: 1 warning emitted
+
-- 
cgit 1.4.1-3-g733a5


From 6e14e60af45ebc79f06eeeb75004e77de4658a80 Mon Sep 17 00:00:00 2001
From: Lukas Lueg <lukas.lueg@gmail.com>
Date: Wed, 31 Aug 2022 21:08:33 +0200
Subject: Fix {subopt,imprec}_float not lint const.*(const)

Fixes #9402
Fixes #9201
---
 clippy_lints/src/floating_point_arithmetic.rs | 30 ++++++++--------
 tests/ui/floating_point_powf.fixed            |  5 +++
 tests/ui/floating_point_powf.rs               |  5 +++
 tests/ui/floating_point_powf.stderr           | 50 ++++++++++++++++++++-------
 4 files changed, 62 insertions(+), 28 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/floating_point_arithmetic.rs b/clippy_lints/src/floating_point_arithmetic.rs
index bb50e8fcabb..9120507f48c 100644
--- a/clippy_lints/src/floating_point_arithmetic.rs
+++ b/clippy_lints/src/floating_point_arithmetic.rs
@@ -238,23 +238,23 @@ fn get_integer_from_float_constant(value: &Constant) -> Option<i32> {
 fn check_powf(cx: &LateContext<'_>, expr: &Expr<'_>, args: &[Expr<'_>]) {
     // Check receiver
     if let Some((value, _)) = constant(cx, cx.typeck_results(), &args[0]) {
-        let method = if F32(f32_consts::E) == value || F64(f64_consts::E) == value {
-            "exp"
+        if let Some(method) = if F32(f32_consts::E) == value || F64(f64_consts::E) == value {
+            Some("exp")
         } else if F32(2.0) == value || F64(2.0) == value {
-            "exp2"
+            Some("exp2")
         } else {
-            return;
-        };
-
-        span_lint_and_sugg(
-            cx,
-            SUBOPTIMAL_FLOPS,
-            expr.span,
-            "exponent for bases 2 and e can be computed more accurately",
-            "consider using",
-            format!("{}.{}()", prepare_receiver_sugg(cx, &args[1]), method),
-            Applicability::MachineApplicable,
-        );
+            None
+        } {
+            span_lint_and_sugg(
+                cx,
+                SUBOPTIMAL_FLOPS,
+                expr.span,
+                "exponent for bases 2 and e can be computed more accurately",
+                "consider using",
+                format!("{}.{}()", prepare_receiver_sugg(cx, &args[1]), method),
+                Applicability::MachineApplicable,
+            );
+        }
     }
 
     // Check argument
diff --git a/tests/ui/floating_point_powf.fixed b/tests/ui/floating_point_powf.fixed
index 7efe10a10f9..e7ef45634df 100644
--- a/tests/ui/floating_point_powf.fixed
+++ b/tests/ui/floating_point_powf.fixed
@@ -18,6 +18,11 @@ fn main() {
     let _ = x.powi(-16_777_215);
     let _ = (x as f32).powi(-16_777_215);
     let _ = (x as f32).powi(3);
+    let _ = (1.5_f32 + 1.0).cbrt();
+    let _ = 1.5_f64.cbrt();
+    let _ = 1.5_f64.sqrt();
+    let _ = 1.5_f64.powi(3);
+
     // Cases where the lint shouldn't be applied
     let _ = x.powf(2.1);
     let _ = x.powf(-2.1);
diff --git a/tests/ui/floating_point_powf.rs b/tests/ui/floating_point_powf.rs
index 445080417f2..d749aa2d48a 100644
--- a/tests/ui/floating_point_powf.rs
+++ b/tests/ui/floating_point_powf.rs
@@ -18,6 +18,11 @@ fn main() {
     let _ = x.powf(-16_777_215.0);
     let _ = (x as f32).powf(-16_777_215.0);
     let _ = (x as f32).powf(3.0);
+    let _ = (1.5_f32 + 1.0).powf(1.0 / 3.0);
+    let _ = 1.5_f64.powf(1.0 / 3.0);
+    let _ = 1.5_f64.powf(1.0 / 2.0);
+    let _ = 1.5_f64.powf(3.0);
+
     // Cases where the lint shouldn't be applied
     let _ = x.powf(2.1);
     let _ = x.powf(-2.1);
diff --git a/tests/ui/floating_point_powf.stderr b/tests/ui/floating_point_powf.stderr
index 6ee696e6ada..e9693de8fc9 100644
--- a/tests/ui/floating_point_powf.stderr
+++ b/tests/ui/floating_point_powf.stderr
@@ -92,77 +92,101 @@ error: exponentiation with integer powers can be computed more efficiently
 LL |     let _ = (x as f32).powf(3.0);
    |             ^^^^^^^^^^^^^^^^^^^^ help: consider using: `(x as f32).powi(3)`
 
+error: cube-root of a number can be computed more accurately
+  --> $DIR/floating_point_powf.rs:21:13
+   |
+LL |     let _ = (1.5_f32 + 1.0).powf(1.0 / 3.0);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(1.5_f32 + 1.0).cbrt()`
+
+error: cube-root of a number can be computed more accurately
+  --> $DIR/floating_point_powf.rs:22:13
+   |
+LL |     let _ = 1.5_f64.powf(1.0 / 3.0);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `1.5_f64.cbrt()`
+
+error: square-root of a number can be computed more efficiently and accurately
+  --> $DIR/floating_point_powf.rs:23:13
+   |
+LL |     let _ = 1.5_f64.powf(1.0 / 2.0);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `1.5_f64.sqrt()`
+
+error: exponentiation with integer powers can be computed more efficiently
+  --> $DIR/floating_point_powf.rs:24:13
+   |
+LL |     let _ = 1.5_f64.powf(3.0);
+   |             ^^^^^^^^^^^^^^^^^ help: consider using: `1.5_f64.powi(3)`
+
 error: exponent for bases 2 and e can be computed more accurately
-  --> $DIR/floating_point_powf.rs:28:13
+  --> $DIR/floating_point_powf.rs:33:13
    |
 LL |     let _ = 2f64.powf(x);
    |             ^^^^^^^^^^^^ help: consider using: `x.exp2()`
 
 error: exponent for bases 2 and e can be computed more accurately
-  --> $DIR/floating_point_powf.rs:29:13
+  --> $DIR/floating_point_powf.rs:34:13
    |
 LL |     let _ = 2f64.powf(3.1);
    |             ^^^^^^^^^^^^^^ help: consider using: `3.1f64.exp2()`
 
 error: exponent for bases 2 and e can be computed more accurately
-  --> $DIR/floating_point_powf.rs:30:13
+  --> $DIR/floating_point_powf.rs:35:13
    |
 LL |     let _ = 2f64.powf(-3.1);
    |             ^^^^^^^^^^^^^^^ help: consider using: `(-3.1f64).exp2()`
 
 error: exponent for bases 2 and e can be computed more accurately
-  --> $DIR/floating_point_powf.rs:31:13
+  --> $DIR/floating_point_powf.rs:36:13
    |
 LL |     let _ = std::f64::consts::E.powf(x);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.exp()`
 
 error: exponent for bases 2 and e can be computed more accurately
-  --> $DIR/floating_point_powf.rs:32:13
+  --> $DIR/floating_point_powf.rs:37:13
    |
 LL |     let _ = std::f64::consts::E.powf(3.1);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `3.1f64.exp()`
 
 error: exponent for bases 2 and e can be computed more accurately
-  --> $DIR/floating_point_powf.rs:33:13
+  --> $DIR/floating_point_powf.rs:38:13
    |
 LL |     let _ = std::f64::consts::E.powf(-3.1);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(-3.1f64).exp()`
 
 error: square-root of a number can be computed more efficiently and accurately
-  --> $DIR/floating_point_powf.rs:34:13
+  --> $DIR/floating_point_powf.rs:39:13
    |
 LL |     let _ = x.powf(1.0 / 2.0);
    |             ^^^^^^^^^^^^^^^^^ help: consider using: `x.sqrt()`
 
 error: cube-root of a number can be computed more accurately
-  --> $DIR/floating_point_powf.rs:35:13
+  --> $DIR/floating_point_powf.rs:40:13
    |
 LL |     let _ = x.powf(1.0 / 3.0);
    |             ^^^^^^^^^^^^^^^^^ help: consider using: `x.cbrt()`
 
 error: exponentiation with integer powers can be computed more efficiently
-  --> $DIR/floating_point_powf.rs:36:13
+  --> $DIR/floating_point_powf.rs:41:13
    |
 LL |     let _ = x.powf(3.0);
    |             ^^^^^^^^^^^ help: consider using: `x.powi(3)`
 
 error: exponentiation with integer powers can be computed more efficiently
-  --> $DIR/floating_point_powf.rs:37:13
+  --> $DIR/floating_point_powf.rs:42:13
    |
 LL |     let _ = x.powf(-2.0);
    |             ^^^^^^^^^^^^ help: consider using: `x.powi(-2)`
 
 error: exponentiation with integer powers can be computed more efficiently
-  --> $DIR/floating_point_powf.rs:38:13
+  --> $DIR/floating_point_powf.rs:43:13
    |
 LL |     let _ = x.powf(-2_147_483_648.0);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.powi(-2_147_483_648)`
 
 error: exponentiation with integer powers can be computed more efficiently
-  --> $DIR/floating_point_powf.rs:39:13
+  --> $DIR/floating_point_powf.rs:44:13
    |
 LL |     let _ = x.powf(2_147_483_647.0);
    |             ^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.powi(2_147_483_647)`
 
-error: aborting due to 27 previous errors
+error: aborting due to 31 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From b1f86a49ea0119e66ee7dced613c91824d56c6d0 Mon Sep 17 00:00:00 2001
From: Dmitrii Lavrov <d.lavrov@proscom.ru>
Date: Thu, 30 Jun 2022 16:57:15 +0300
Subject: New lint `bool_to_int_with_if`

---
 CHANGELOG.md                               |   1 +
 clippy_lints/src/bool_to_int_with_if.rs    | 125 +++++++++++++++++++++++++++++
 clippy_lints/src/lib.register_all.rs       |   1 +
 clippy_lints/src/lib.register_lints.rs     |   1 +
 clippy_lints/src/lib.register_style.rs     |   1 +
 clippy_lints/src/lib.rs                    |   2 +
 clippy_lints/src/matches/single_match.rs   |   8 +-
 clippy_lints/src/only_used_in_recursion.rs |  12 +--
 tests/ui/author/struct.rs                  |   7 +-
 tests/ui/bool_to_int_with_if.fixed         |  85 ++++++++++++++++++++
 tests/ui/bool_to_int_with_if.rs            | 109 +++++++++++++++++++++++++
 tests/ui/bool_to_int_with_if.stderr        |  84 +++++++++++++++++++
 12 files changed, 419 insertions(+), 17 deletions(-)
 create mode 100644 clippy_lints/src/bool_to_int_with_if.rs
 create mode 100644 tests/ui/bool_to_int_with_if.fixed
 create mode 100644 tests/ui/bool_to_int_with_if.rs
 create mode 100644 tests/ui/bool_to_int_with_if.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index c488c142e46..257add86b6e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3603,6 +3603,7 @@ Released 2018-09-13
 [`blocks_in_if_conditions`]: https://rust-lang.github.io/rust-clippy/master/index.html#blocks_in_if_conditions
 [`bool_assert_comparison`]: https://rust-lang.github.io/rust-clippy/master/index.html#bool_assert_comparison
 [`bool_comparison`]: https://rust-lang.github.io/rust-clippy/master/index.html#bool_comparison
+[`bool_to_int_with_if`]: https://rust-lang.github.io/rust-clippy/master/index.html#bool_to_int_with_if
 [`borrow_as_ptr`]: https://rust-lang.github.io/rust-clippy/master/index.html#borrow_as_ptr
 [`borrow_deref_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#borrow_deref_ref
 [`borrow_interior_mutable_const`]: https://rust-lang.github.io/rust-clippy/master/index.html#borrow_interior_mutable_const
diff --git a/clippy_lints/src/bool_to_int_with_if.rs b/clippy_lints/src/bool_to_int_with_if.rs
new file mode 100644
index 00000000000..a4b8cbb0d82
--- /dev/null
+++ b/clippy_lints/src/bool_to_int_with_if.rs
@@ -0,0 +1,125 @@
+use rustc_ast::{ExprPrecedence, LitKind};
+use rustc_hir::{Block, ExprKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+use clippy_utils::{diagnostics::span_lint_and_then, is_else_clause, source::snippet_block_with_applicability};
+use rustc_errors::Applicability;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Instead of using an if statement to convert a bool to an int,
+    /// this lint suggests using a `from()` function or an `as` coercion.
+    ///
+    /// ### Why is this bad?
+    /// Coercion or `from()` is idiomatic way to convert bool to a number.
+    /// Both methods are guaranteed to return 1 for true, and 0 for false.
+    ///
+    /// See https://doc.rust-lang.org/std/primitive.bool.html#impl-From%3Cbool%3E
+    ///
+    /// ### Example
+    /// ```rust
+    /// # let condition = false;
+    /// if condition {
+    ///     1_i64
+    /// } else {
+    ///     0
+    /// };
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// # let condition = false;
+    /// i64::from(condition);
+    /// ```
+    /// or
+    /// ```rust
+    /// # let condition = false;
+    /// condition as i64;
+    /// ```
+    #[clippy::version = "1.65.0"]
+    pub BOOL_TO_INT_WITH_IF,
+    style,
+    "using if to convert bool to int"
+}
+declare_lint_pass!(BoolToIntWithIf => [BOOL_TO_INT_WITH_IF]);
+
+impl<'tcx> LateLintPass<'tcx> for BoolToIntWithIf {
+    fn check_expr(&mut self, ctx: &LateContext<'tcx>, expr: &'tcx rustc_hir::Expr<'tcx>) {
+        if !expr.span.from_expansion() {
+            check_if_else(ctx, expr);
+        }
+    }
+}
+
+fn check_if_else<'tcx>(ctx: &LateContext<'tcx>, expr: &'tcx rustc_hir::Expr<'tcx>) {
+    if let ExprKind::If(check, then, Some(else_)) = expr.kind
+        && let Some(then_lit) = int_literal(then)
+        && let Some(else_lit) = int_literal(else_)
+        && check_int_literal_equals_val(then_lit, 1)
+        && check_int_literal_equals_val(else_lit, 0)
+    {
+        let mut applicability = Applicability::MachineApplicable;
+        let snippet = snippet_block_with_applicability(ctx, check.span, "..", None, &mut applicability);
+        let snippet_with_braces = {
+            let need_parens = should_have_parentheses(check);
+            let (left_paren, right_paren) = if need_parens {("(", ")")} else {("", "")};
+            format!("{left_paren}{snippet}{right_paren}")
+        };
+
+        let ty = ctx.typeck_results().expr_ty(then_lit); // then and else must be of same type
+
+        let suggestion = {
+            let wrap_in_curly = is_else_clause(ctx.tcx, expr);
+            let (left_curly, right_curly) = if wrap_in_curly {("{", "}")} else {("", "")};
+            format!(
+                "{left_curly}{ty}::from({snippet}){right_curly}"
+            )
+        }; // when used in else clause if statement should be wrapped in curly braces
+
+        span_lint_and_then(ctx,
+            BOOL_TO_INT_WITH_IF,
+            expr.span,
+            "boolean to int conversion using if",
+            |diag| {
+            diag.span_suggestion(
+                expr.span,
+                "replace with from",
+                suggestion,
+                applicability,
+            );
+            diag.note(format!("`{snippet_with_braces} as {ty}` or `{snippet_with_braces}.into()` can also be valid options"));
+        });
+    };
+}
+
+// If block contains only a int literal expression, return literal expression
+fn int_literal<'tcx>(expr: &'tcx rustc_hir::Expr<'tcx>) -> Option<&'tcx rustc_hir::Expr<'tcx>> {
+    if let ExprKind::Block(block, _) = expr.kind
+        && let Block {
+            stmts: [],       // Shouldn't lint if statements with side effects
+            expr: Some(expr),
+            ..
+        } = block
+        && let ExprKind::Lit(lit) = &expr.kind
+        && let LitKind::Int(_, _) = lit.node
+    {
+        Some(expr)
+    } else {
+        None
+    }
+}
+
+fn check_int_literal_equals_val<'tcx>(expr: &'tcx rustc_hir::Expr<'tcx>, expected_value: u128) -> bool {
+    if let ExprKind::Lit(lit) = &expr.kind
+        && let LitKind::Int(val, _) = lit.node
+        && val == expected_value
+    {
+        true
+    } else {
+        false
+    }
+}
+
+fn should_have_parentheses<'tcx>(check: &'tcx rustc_hir::Expr<'tcx>) -> bool {
+    check.precedence().order() < ExprPrecedence::Cast.order()
+}
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 134cbbf7b5c..1f85382347a 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -17,6 +17,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(await_holding_invalid::AWAIT_HOLDING_REFCELL_REF),
     LintId::of(blocks_in_if_conditions::BLOCKS_IN_IF_CONDITIONS),
     LintId::of(bool_assert_comparison::BOOL_ASSERT_COMPARISON),
+    LintId::of(bool_to_int_with_if::BOOL_TO_INT_WITH_IF),
     LintId::of(booleans::NONMINIMAL_BOOL),
     LintId::of(booleans::OVERLY_COMPLEX_BOOL_EXPR),
     LintId::of(borrow_deref_ref::BORROW_DEREF_REF),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index fd20e016578..13b573beea1 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -56,6 +56,7 @@ store.register_lints(&[
     await_holding_invalid::AWAIT_HOLDING_REFCELL_REF,
     blocks_in_if_conditions::BLOCKS_IN_IF_CONDITIONS,
     bool_assert_comparison::BOOL_ASSERT_COMPARISON,
+    bool_to_int_with_if::BOOL_TO_INT_WITH_IF,
     booleans::NONMINIMAL_BOOL,
     booleans::OVERLY_COMPLEX_BOOL_EXPR,
     borrow_deref_ref::BORROW_DEREF_REF,
diff --git a/clippy_lints/src/lib.register_style.rs b/clippy_lints/src/lib.register_style.rs
index b5cb078e7a3..05d2ec2e9e1 100644
--- a/clippy_lints/src/lib.register_style.rs
+++ b/clippy_lints/src/lib.register_style.rs
@@ -6,6 +6,7 @@ store.register_group(true, "clippy::style", Some("clippy_style"), vec![
     LintId::of(assertions_on_constants::ASSERTIONS_ON_CONSTANTS),
     LintId::of(blocks_in_if_conditions::BLOCKS_IN_IF_CONDITIONS),
     LintId::of(bool_assert_comparison::BOOL_ASSERT_COMPARISON),
+    LintId::of(bool_to_int_with_if::BOOL_TO_INT_WITH_IF),
     LintId::of(casts::FN_TO_NUMERIC_CAST),
     LintId::of(casts::FN_TO_NUMERIC_CAST_WITH_TRUNCATION),
     LintId::of(collapsible_if::COLLAPSIBLE_ELSE_IF),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 178e57aaf61..a26e129f094 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -178,6 +178,7 @@ mod attrs;
 mod await_holding_invalid;
 mod blocks_in_if_conditions;
 mod bool_assert_comparison;
+mod bool_to_int_with_if;
 mod booleans;
 mod borrow_deref_ref;
 mod cargo;
@@ -900,6 +901,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(manual_string_new::ManualStringNew));
     store.register_late_pass(|| Box::new(unused_peekable::UnusedPeekable));
     store.register_early_pass(|| Box::new(multi_assignments::MultiAssignments));
+    store.register_late_pass(|| Box::new(bool_to_int_with_if::BoolToIntWithIf));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/matches/single_match.rs b/clippy_lints/src/matches/single_match.rs
index 92091a0c339..52632e88b1b 100644
--- a/clippy_lints/src/matches/single_match.rs
+++ b/clippy_lints/src/matches/single_match.rs
@@ -201,12 +201,8 @@ fn form_exhaustive_matches<'a>(cx: &LateContext<'a>, ty: Ty<'a>, left: &Pat<'_>,
             // in the arms, so we need to evaluate the correct offsets here in order to iterate in
             // both arms at the same time.
             let len = max(
-                left_in.len() + {
-                    if left_pos.is_some() { 1 } else { 0 }
-                },
-                right_in.len() + {
-                    if right_pos.is_some() { 1 } else { 0 }
-                },
+                left_in.len() + usize::from(left_pos.is_some()),
+                right_in.len() + usize::from(right_pos.is_some()),
             );
             let mut left_pos = left_pos.unwrap_or(usize::MAX);
             let mut right_pos = right_pos.unwrap_or(usize::MAX);
diff --git a/clippy_lints/src/only_used_in_recursion.rs b/clippy_lints/src/only_used_in_recursion.rs
index 774a3540d1e..c55478b3441 100644
--- a/clippy_lints/src/only_used_in_recursion.rs
+++ b/clippy_lints/src/only_used_in_recursion.rs
@@ -234,11 +234,7 @@ impl<'tcx> LateLintPass<'tcx> for OnlyUsedInRecursion {
             })) => (
                 def_id.to_def_id(),
                 FnKind::TraitFn,
-                if sig.decl.implicit_self.has_implicit_self() {
-                    1
-                } else {
-                    0
-                },
+                usize::from(sig.decl.implicit_self.has_implicit_self()),
             ),
             Some(Node::ImplItem(&ImplItem {
                 kind: ImplItemKind::Fn(ref sig, _),
@@ -253,11 +249,7 @@ impl<'tcx> LateLintPass<'tcx> for OnlyUsedInRecursion {
                     (
                         trait_item_id,
                         FnKind::ImplTraitFn(cx.tcx.erase_regions(trait_ref.substs) as *const _ as usize),
-                        if sig.decl.implicit_self.has_implicit_self() {
-                            1
-                        } else {
-                            0
-                        },
+                        usize::from(sig.decl.implicit_self.has_implicit_self()),
                     )
                 } else {
                     (def_id.to_def_id(), FnKind::Fn, 0)
diff --git a/tests/ui/author/struct.rs b/tests/ui/author/struct.rs
index 5fdf3433a37..a99bdfc1313 100644
--- a/tests/ui/author/struct.rs
+++ b/tests/ui/author/struct.rs
@@ -1,4 +1,9 @@
-#[allow(clippy::unnecessary_operation, clippy::single_match)]
+#![allow(
+    clippy::unnecessary_operation,
+    clippy::single_match,
+    clippy::no_effect,
+    clippy::bool_to_int_with_if
+)]
 fn main() {
     struct Test {
         field: u32,
diff --git a/tests/ui/bool_to_int_with_if.fixed b/tests/ui/bool_to_int_with_if.fixed
new file mode 100644
index 00000000000..9c1098dc4c1
--- /dev/null
+++ b/tests/ui/bool_to_int_with_if.fixed
@@ -0,0 +1,85 @@
+// run-rustfix
+
+#![warn(clippy::bool_to_int_with_if)]
+#![allow(unused, dead_code, clippy::unnecessary_operation, clippy::no_effect)]
+
+fn main() {
+    let a = true;
+    let b = false;
+
+    let x = 1;
+    let y = 2;
+
+    // Should lint
+    // precedence
+    i32::from(a);
+    i32::from(!a);
+    i32::from(a || b);
+    i32::from(cond(a, b));
+    i32::from(x + y < 4);
+
+    // if else if
+    if a {
+        123
+    } else {i32::from(b)};
+
+    // Shouldn't lint
+
+    if a {
+        1
+    } else if b {
+        0
+    } else {
+        3
+    };
+
+    if a {
+        3
+    } else if b {
+        1
+    } else {
+        -2
+    };
+
+    if a {
+        3
+    } else {
+        0
+    };
+    if a {
+        side_effect();
+        1
+    } else {
+        0
+    };
+    if a {
+        1
+    } else {
+        side_effect();
+        0
+    };
+
+    // multiple else ifs
+    if a {
+        123
+    } else if b {
+        1
+    } else if a | b {
+        0
+    } else {
+        123
+    };
+
+    some_fn(a);
+}
+
+// Lint returns and type inference
+fn some_fn(a: bool) -> u8 {
+    u8::from(a)
+}
+
+fn side_effect() {}
+
+fn cond(a: bool, b: bool) -> bool {
+    a || b
+}
diff --git a/tests/ui/bool_to_int_with_if.rs b/tests/ui/bool_to_int_with_if.rs
new file mode 100644
index 00000000000..0c967dac6e2
--- /dev/null
+++ b/tests/ui/bool_to_int_with_if.rs
@@ -0,0 +1,109 @@
+// run-rustfix
+
+#![warn(clippy::bool_to_int_with_if)]
+#![allow(unused, dead_code, clippy::unnecessary_operation, clippy::no_effect)]
+
+fn main() {
+    let a = true;
+    let b = false;
+
+    let x = 1;
+    let y = 2;
+
+    // Should lint
+    // precedence
+    if a {
+        1
+    } else {
+        0
+    };
+    if !a {
+        1
+    } else {
+        0
+    };
+    if a || b {
+        1
+    } else {
+        0
+    };
+    if cond(a, b) {
+        1
+    } else {
+        0
+    };
+    if x + y < 4 {
+        1
+    } else {
+        0
+    };
+
+    // if else if
+    if a {
+        123
+    } else if b {
+        1
+    } else {
+        0
+    };
+
+    // Shouldn't lint
+
+    if a {
+        1
+    } else if b {
+        0
+    } else {
+        3
+    };
+
+    if a {
+        3
+    } else if b {
+        1
+    } else {
+        -2
+    };
+
+    if a {
+        3
+    } else {
+        0
+    };
+    if a {
+        side_effect();
+        1
+    } else {
+        0
+    };
+    if a {
+        1
+    } else {
+        side_effect();
+        0
+    };
+
+    // multiple else ifs
+    if a {
+        123
+    } else if b {
+        1
+    } else if a | b {
+        0
+    } else {
+        123
+    };
+
+    some_fn(a);
+}
+
+// Lint returns and type inference
+fn some_fn(a: bool) -> u8 {
+    if a { 1 } else { 0 }
+}
+
+fn side_effect() {}
+
+fn cond(a: bool, b: bool) -> bool {
+    a || b
+}
diff --git a/tests/ui/bool_to_int_with_if.stderr b/tests/ui/bool_to_int_with_if.stderr
new file mode 100644
index 00000000000..8647a9cffbe
--- /dev/null
+++ b/tests/ui/bool_to_int_with_if.stderr
@@ -0,0 +1,84 @@
+error: boolean to int conversion using if
+  --> $DIR/bool_to_int_with_if.rs:15:5
+   |
+LL | /     if a {
+LL | |         1
+LL | |     } else {
+LL | |         0
+LL | |     };
+   | |_____^ help: replace with from: `i32::from(a)`
+   |
+   = note: `-D clippy::bool-to-int-with-if` implied by `-D warnings`
+   = note: `a as i32` or `a.into()` can also be valid options
+
+error: boolean to int conversion using if
+  --> $DIR/bool_to_int_with_if.rs:20:5
+   |
+LL | /     if !a {
+LL | |         1
+LL | |     } else {
+LL | |         0
+LL | |     };
+   | |_____^ help: replace with from: `i32::from(!a)`
+   |
+   = note: `!a as i32` or `!a.into()` can also be valid options
+
+error: boolean to int conversion using if
+  --> $DIR/bool_to_int_with_if.rs:25:5
+   |
+LL | /     if a || b {
+LL | |         1
+LL | |     } else {
+LL | |         0
+LL | |     };
+   | |_____^ help: replace with from: `i32::from(a || b)`
+   |
+   = note: `(a || b) as i32` or `(a || b).into()` can also be valid options
+
+error: boolean to int conversion using if
+  --> $DIR/bool_to_int_with_if.rs:30:5
+   |
+LL | /     if cond(a, b) {
+LL | |         1
+LL | |     } else {
+LL | |         0
+LL | |     };
+   | |_____^ help: replace with from: `i32::from(cond(a, b))`
+   |
+   = note: `cond(a, b) as i32` or `cond(a, b).into()` can also be valid options
+
+error: boolean to int conversion using if
+  --> $DIR/bool_to_int_with_if.rs:35:5
+   |
+LL | /     if x + y < 4 {
+LL | |         1
+LL | |     } else {
+LL | |         0
+LL | |     };
+   | |_____^ help: replace with from: `i32::from(x + y < 4)`
+   |
+   = note: `(x + y < 4) as i32` or `(x + y < 4).into()` can also be valid options
+
+error: boolean to int conversion using if
+  --> $DIR/bool_to_int_with_if.rs:44:12
+   |
+LL |       } else if b {
+   |  ____________^
+LL | |         1
+LL | |     } else {
+LL | |         0
+LL | |     };
+   | |_____^ help: replace with from: `{i32::from(b)}`
+   |
+   = note: `b as i32` or `b.into()` can also be valid options
+
+error: boolean to int conversion using if
+  --> $DIR/bool_to_int_with_if.rs:102:5
+   |
+LL |     if a { 1 } else { 0 }
+   |     ^^^^^^^^^^^^^^^^^^^^^ help: replace with from: `u8::from(a)`
+   |
+   = note: `a as u8` or `a.into()` can also be valid options
+
+error: aborting due to 7 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From bd70ccf915482503b193d8d53e00dcdc6197676a Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Fri, 2 Sep 2022 13:40:35 -0400
Subject: Don't use `hir_ty_to_ty` in `result_large_err` as it sometimes leaves
 late-bound lifetimes.

---
 clippy_lints/src/functions/result.rs | 10 +++++-----
 tests/ui/crashes/ice-9414.rs         |  8 ++++++++
 2 files changed, 13 insertions(+), 5 deletions(-)
 create mode 100644 tests/ui/crashes/ice-9414.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/functions/result.rs b/clippy_lints/src/functions/result.rs
index af520a493ed..9591405cb06 100644
--- a/clippy_lints/src/functions/result.rs
+++ b/clippy_lints/src/functions/result.rs
@@ -4,7 +4,6 @@ use rustc_lint::{LateContext, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::{self, Ty};
 use rustc_span::{sym, Span};
-use rustc_typeck::hir_ty_to_ty;
 
 use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_then};
 use clippy_utils::trait_ref_of_method;
@@ -17,11 +16,12 @@ use super::{RESULT_LARGE_ERR, RESULT_UNIT_ERR};
 fn result_err_ty<'tcx>(
     cx: &LateContext<'tcx>,
     decl: &hir::FnDecl<'tcx>,
+    id: hir::def_id::LocalDefId,
     item_span: Span,
 ) -> Option<(&'tcx hir::Ty<'tcx>, Ty<'tcx>)> {
     if !in_external_macro(cx.sess(), item_span)
         && let hir::FnRetTy::Return(hir_ty) = decl.output
-        && let ty = hir_ty_to_ty(cx.tcx, hir_ty)
+        && let ty = cx.tcx.erase_late_bound_regions(cx.tcx.fn_sig(id).output())
         && is_type_diagnostic_item(cx, ty, sym::Result)
         && let ty::Adt(_, substs) = ty.kind()
     {
@@ -34,7 +34,7 @@ fn result_err_ty<'tcx>(
 
 pub(super) fn check_item<'tcx>(cx: &LateContext<'tcx>, item: &hir::Item<'tcx>, large_err_threshold: u64) {
     if let hir::ItemKind::Fn(ref sig, _generics, _) = item.kind
-        && let Some((hir_ty, err_ty)) = result_err_ty(cx, sig.decl, item.span)
+        && let Some((hir_ty, err_ty)) = result_err_ty(cx, sig.decl, item.def_id, item.span)
     {
         if cx.access_levels.is_exported(item.def_id) {
             let fn_header_span = item.span.with_hi(sig.decl.output.span().hi());
@@ -47,7 +47,7 @@ pub(super) fn check_item<'tcx>(cx: &LateContext<'tcx>, item: &hir::Item<'tcx>, l
 pub(super) fn check_impl_item<'tcx>(cx: &LateContext<'tcx>, item: &hir::ImplItem<'tcx>, large_err_threshold: u64) {
     // Don't lint if method is a trait's implementation, we can't do anything about those
     if let hir::ImplItemKind::Fn(ref sig, _) = item.kind
-        && let Some((hir_ty, err_ty)) = result_err_ty(cx, sig.decl, item.span)
+        && let Some((hir_ty, err_ty)) = result_err_ty(cx, sig.decl, item.def_id, item.span)
         && trait_ref_of_method(cx, item.def_id).is_none()
     {
         if cx.access_levels.is_exported(item.def_id) {
@@ -61,7 +61,7 @@ pub(super) fn check_impl_item<'tcx>(cx: &LateContext<'tcx>, item: &hir::ImplItem
 pub(super) fn check_trait_item<'tcx>(cx: &LateContext<'tcx>, item: &hir::TraitItem<'tcx>, large_err_threshold: u64) {
     if let hir::TraitItemKind::Fn(ref sig, _) = item.kind {
         let fn_header_span = item.span.with_hi(sig.decl.output.span().hi());
-        if let Some((hir_ty, err_ty)) = result_err_ty(cx, sig.decl, item.span) {
+        if let Some((hir_ty, err_ty)) = result_err_ty(cx, sig.decl, item.def_id, item.span) {
             if cx.access_levels.is_exported(item.def_id) {
                 check_result_unit_err(cx, err_ty, fn_header_span);
             }
diff --git a/tests/ui/crashes/ice-9414.rs b/tests/ui/crashes/ice-9414.rs
new file mode 100644
index 00000000000..02cf5d5c240
--- /dev/null
+++ b/tests/ui/crashes/ice-9414.rs
@@ -0,0 +1,8 @@
+#![warn(clippy::result_large_err)]
+
+trait T {}
+fn f(_: &u32) -> Result<(), *const (dyn '_ + T)> {
+    Ok(())
+}
+
+fn main() {}
-- 
cgit 1.4.1-3-g733a5


From ffc75af4cd01740e9daac43ff24d777525e506c1 Mon Sep 17 00:00:00 2001
From: Lukas Lueg <lukas.lueg@gmail.com>
Date: Fri, 2 Sep 2022 20:28:00 +0200
Subject: Fix `mut_mutex_lock` for Mutex behind imm deref

Fixes #9415
---
 clippy_lints/src/methods/mut_mutex_lock.rs | 3 ++-
 tests/ui/mut_mutex_lock.fixed              | 7 +++++++
 tests/ui/mut_mutex_lock.rs                 | 7 +++++++
 3 files changed, 16 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mut_mutex_lock.rs b/clippy_lints/src/methods/mut_mutex_lock.rs
index bd8458a222e..b9593b3687d 100644
--- a/clippy_lints/src/methods/mut_mutex_lock.rs
+++ b/clippy_lints/src/methods/mut_mutex_lock.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::{expr_custom_deref_adjustment, ty::is_type_diagnostic_item};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, Mutability};
@@ -11,6 +11,7 @@ use super::MUT_MUTEX_LOCK;
 
 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, ex: &'tcx Expr<'tcx>, recv: &'tcx Expr<'tcx>, name_span: Span) {
     if_chain! {
+        if matches!(expr_custom_deref_adjustment(cx, recv), None | Some(Mutability::Mut));
         if let ty::Ref(_, _, Mutability::Mut) = cx.typeck_results().expr_ty(recv).kind();
         if let Some(method_id) = cx.typeck_results().type_dependent_def_id(ex.hir_id);
         if let Some(impl_id) = cx.tcx.impl_of_method(method_id);
diff --git a/tests/ui/mut_mutex_lock.fixed b/tests/ui/mut_mutex_lock.fixed
index 36bc52e3374..ecad10a8290 100644
--- a/tests/ui/mut_mutex_lock.fixed
+++ b/tests/ui/mut_mutex_lock.fixed
@@ -18,4 +18,11 @@ fn no_owned_mutex_lock() {
     *value += 1;
 }
 
+fn issue9415() {
+    let mut arc_mutex = Arc::new(Mutex::new(42_u8));
+    let arc_mutex: &mut Arc<Mutex<u8>> = &mut arc_mutex;
+    let mut guard = arc_mutex.lock().unwrap();
+    *guard += 1;
+}
+
 fn main() {}
diff --git a/tests/ui/mut_mutex_lock.rs b/tests/ui/mut_mutex_lock.rs
index ea60df5ae1b..f2b1d6fbfbc 100644
--- a/tests/ui/mut_mutex_lock.rs
+++ b/tests/ui/mut_mutex_lock.rs
@@ -18,4 +18,11 @@ fn no_owned_mutex_lock() {
     *value += 1;
 }
 
+fn issue9415() {
+    let mut arc_mutex = Arc::new(Mutex::new(42_u8));
+    let arc_mutex: &mut Arc<Mutex<u8>> = &mut arc_mutex;
+    let mut guard = arc_mutex.lock().unwrap();
+    *guard += 1;
+}
+
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 584000a792b1016677fe4e0e78706d14a8034eb2 Mon Sep 17 00:00:00 2001
From: Lukas Lueg <lukas.lueg@gmail.com>
Date: Tue, 30 Aug 2022 22:27:21 +0200
Subject: Use `approx_ty_size` for `large_enum_variant`

---
 clippy_lints/src/large_enum_variant.rs |  96 ++++++++-----
 src/docs/large_enum_variant.txt        |   7 +-
 tests/ui/large_enum_variant.rs         |  24 ++++
 tests/ui/large_enum_variant.stderr     | 256 ++++++++++++++++++++++-----------
 tests/ui/result_large_err.rs           |   1 +
 tests/ui/result_large_err.stderr       |  22 +--
 6 files changed, 267 insertions(+), 139 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/large_enum_variant.rs b/clippy_lints/src/large_enum_variant.rs
index c58df126d62..eb13d0869c0 100644
--- a/clippy_lints/src/large_enum_variant.rs
+++ b/clippy_lints/src/large_enum_variant.rs
@@ -1,13 +1,12 @@
 //! lint when there is a large size difference between variants on an enum
 
 use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::{diagnostics::span_lint_and_then, ty::is_copy};
+use clippy_utils::{diagnostics::span_lint_and_then, ty::approx_ty_size, ty::is_copy};
 use rustc_errors::Applicability;
 use rustc_hir::{Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::lint::in_external_macro;
-use rustc_middle::ty::layout::LayoutOf;
-use rustc_middle::ty::{Adt, Ty};
+use rustc_middle::ty::{Adt, AdtDef, GenericArg, List, Ty};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::Span;
 
@@ -17,7 +16,7 @@ declare_clippy_lint! {
     /// `enum`s.
     ///
     /// ### Why is this bad?
-    /// Enum size is bounded by the largest variant. Having a
+    /// Enum size is bounded by the largest variant. Having one
     /// large variant can penalize the memory layout of that enum.
     ///
     /// ### Known problems
@@ -33,8 +32,9 @@ declare_clippy_lint! {
     /// use case it may be possible to store the large data in an auxiliary
     /// structure (e.g. Arena or ECS).
     ///
-    /// The lint will ignore generic types if the layout depends on the
-    /// generics, even if the size difference will be large anyway.
+    /// The lint will ignore the impact of generic types to the type layout by
+    /// assuming every type parameter is zero-sized. Depending on your use case,
+    /// this may lead to a false positive.
     ///
     /// ### Example
     /// ```rust
@@ -83,6 +83,38 @@ struct VariantInfo {
     fields_size: Vec<FieldInfo>,
 }
 
+fn variants_size<'tcx>(
+    cx: &LateContext<'tcx>,
+    adt: AdtDef<'tcx>,
+    subst: &'tcx List<GenericArg<'tcx>>,
+) -> Vec<VariantInfo> {
+    let mut variants_size = adt
+        .variants()
+        .iter()
+        .enumerate()
+        .map(|(i, variant)| {
+            let mut fields_size = variant
+                .fields
+                .iter()
+                .enumerate()
+                .map(|(i, f)| FieldInfo {
+                    ind: i,
+                    size: approx_ty_size(cx, f.ty(cx.tcx, subst)),
+                })
+                .collect::<Vec<_>>();
+            fields_size.sort_by(|a, b| (a.size.cmp(&b.size)));
+
+            VariantInfo {
+                ind: i,
+                size: fields_size.iter().map(|info| info.size).sum(),
+                fields_size,
+            }
+        })
+        .collect::<Vec<_>>();
+    variants_size.sort_by(|a, b| (b.size.cmp(&a.size)));
+    variants_size
+}
+
 impl_lint_pass!(LargeEnumVariant => [LARGE_ENUM_VARIANT]);
 
 impl<'tcx> LateLintPass<'tcx> for LargeEnumVariant {
@@ -92,36 +124,14 @@ impl<'tcx> LateLintPass<'tcx> for LargeEnumVariant {
         }
         if let ItemKind::Enum(ref def, _) = item.kind {
             let ty = cx.tcx.type_of(item.def_id);
-            let adt = ty.ty_adt_def().expect("already checked whether this is an enum");
+            let (adt, subst) = match ty.kind() {
+                Adt(adt, subst) => (adt, subst),
+                _ => panic!("already checked whether this is an enum"),
+            };
             if adt.variants().len() <= 1 {
                 return;
             }
-            let mut variants_size: Vec<VariantInfo> = Vec::new();
-            for (i, variant) in adt.variants().iter().enumerate() {
-                let mut fields_size = Vec::new();
-                for (i, f) in variant.fields.iter().enumerate() {
-                    let ty = cx.tcx.type_of(f.did);
-                    // don't lint variants which have a field of generic type.
-                    match cx.layout_of(ty) {
-                        Ok(l) => {
-                            let fsize = l.size.bytes();
-                            fields_size.push(FieldInfo { ind: i, size: fsize });
-                        },
-                        Err(_) => {
-                            return;
-                        },
-                    }
-                }
-                let size: u64 = fields_size.iter().map(|info| info.size).sum();
-
-                variants_size.push(VariantInfo {
-                    ind: i,
-                    size,
-                    fields_size,
-                });
-            }
-
-            variants_size.sort_by(|a, b| (b.size.cmp(&a.size)));
+            let variants_size = variants_size(cx, *adt, subst);
 
             let mut difference = variants_size[0].size - variants_size[1].size;
             if difference > self.maximum_size_difference_allowed {
@@ -129,20 +139,30 @@ impl<'tcx> LateLintPass<'tcx> for LargeEnumVariant {
                 span_lint_and_then(
                     cx,
                     LARGE_ENUM_VARIANT,
-                    def.variants[variants_size[0].ind].span,
+                    item.span,
                     "large size difference between variants",
                     |diag| {
+                        diag.span_label(
+                            item.span,
+                            format!("the entire enum is at least {} bytes", approx_ty_size(cx, ty)),
+                        );
                         diag.span_label(
                             def.variants[variants_size[0].ind].span,
-                            &format!("this variant is {} bytes", variants_size[0].size),
+                            format!("the largest variant contains at least {} bytes", variants_size[0].size),
                         );
-                        diag.span_note(
+                        diag.span_label(
                             def.variants[variants_size[1].ind].span,
-                            &format!("and the second-largest variant is {} bytes:", variants_size[1].size),
+                            &if variants_size[1].fields_size.is_empty() {
+                                "the second-largest variant carries no data at all".to_owned()
+                            } else {
+                                format!(
+                                    "the second-largest variant contains at least {} bytes",
+                                    variants_size[1].size
+                                )
+                            },
                         );
 
                         let fields = def.variants[variants_size[0].ind].data.fields();
-                        variants_size[0].fields_size.sort_by(|a, b| (a.size.cmp(&b.size)));
                         let mut applicability = Applicability::MaybeIncorrect;
                         if is_copy(cx, ty) || maybe_copy(cx, ty) {
                             diag.span_note(
diff --git a/src/docs/large_enum_variant.txt b/src/docs/large_enum_variant.txt
index 787e8e027e1..1f95430790d 100644
--- a/src/docs/large_enum_variant.txt
+++ b/src/docs/large_enum_variant.txt
@@ -3,7 +3,7 @@ Checks for large size differences between variants on
 `enum`s.
 
 ### Why is this bad?
-Enum size is bounded by the largest variant. Having a
+Enum size is bounded by the largest variant. Having one
 large variant can penalize the memory layout of that enum.
 
 ### Known problems
@@ -19,8 +19,9 @@ still be `Clone`, but that is worse ergonomically. Depending on the
 use case it may be possible to store the large data in an auxiliary
 structure (e.g. Arena or ECS).
 
-The lint will ignore generic types if the layout depends on the
-generics, even if the size difference will be large anyway.
+The lint will ignore the impact of generic types to the type layout by
+assuming every type parameter is zero-sized. Depending on your use case,
+this may lead to a false positive.
 
 ### Example
 ```
diff --git a/tests/ui/large_enum_variant.rs b/tests/ui/large_enum_variant.rs
index 23152a13322..717009e4c4c 100644
--- a/tests/ui/large_enum_variant.rs
+++ b/tests/ui/large_enum_variant.rs
@@ -130,6 +130,30 @@ impl<T: Copy> Clone for SomeGenericPossiblyCopyEnum<T> {
 
 impl<T: Copy> Copy for SomeGenericPossiblyCopyEnum<T> {}
 
+enum LargeEnumWithGenerics<T> {
+    Small,
+    Large((T, [u8; 512])),
+}
+
+struct Foo<T> {
+    foo: T,
+}
+
+enum WithGenerics {
+    Large([Foo<u64>; 64]),
+    Small(u8),
+}
+
+enum PossiblyLargeEnumWithConst<const U: usize> {
+    SmallBuffer([u8; 4]),
+    MightyBuffer([u16; U]),
+}
+
+enum LargeEnumOfConst {
+    Ok,
+    Error(PossiblyLargeEnumWithConst<256>),
+}
+
 fn main() {
     large_enum_variant!();
 }
diff --git a/tests/ui/large_enum_variant.stderr b/tests/ui/large_enum_variant.stderr
index 0248327262d..e1ed2460e08 100644
--- a/tests/ui/large_enum_variant.stderr
+++ b/tests/ui/large_enum_variant.stderr
@@ -1,143 +1,177 @@
 error: large size difference between variants
-  --> $DIR/large_enum_variant.rs:12:5
+  --> $DIR/large_enum_variant.rs:10:1
    |
-LL |     B([i32; 8000]),
-   |     ^^^^^^^^^^^^^^ this variant is 32000 bytes
+LL | / enum LargeEnum {
+LL | |     A(i32),
+   | |     ------ the second-largest variant contains at least 4 bytes
+LL | |     B([i32; 8000]),
+   | |     -------------- the largest variant contains at least 32000 bytes
+LL | | }
+   | |_^ the entire enum is at least 32004 bytes
    |
    = note: `-D clippy::large-enum-variant` implied by `-D warnings`
-note: and the second-largest variant is 4 bytes:
-  --> $DIR/large_enum_variant.rs:11:5
-   |
-LL |     A(i32),
-   |     ^^^^^^
 help: consider boxing the large fields to reduce the total size of the enum
    |
 LL |     B(Box<[i32; 8000]>),
    |       ~~~~~~~~~~~~~~~~
 
 error: large size difference between variants
-  --> $DIR/large_enum_variant.rs:36:5
-   |
-LL |     ContainingLargeEnum(LargeEnum),
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this variant is 32004 bytes
+  --> $DIR/large_enum_variant.rs:34:1
    |
-note: and the second-largest variant is 8 bytes:
-  --> $DIR/large_enum_variant.rs:35:5
+LL | / enum LargeEnum2 {
+LL | |     VariantOk(i32, u32),
+   | |     ------------------- the second-largest variant contains at least 8 bytes
+LL | |     ContainingLargeEnum(LargeEnum),
+   | |     ------------------------------ the largest variant contains at least 32004 bytes
+LL | | }
+   | |_^ the entire enum is at least 32008 bytes
    |
-LL |     VariantOk(i32, u32),
-   |     ^^^^^^^^^^^^^^^^^^^
 help: consider boxing the large fields to reduce the total size of the enum
    |
 LL |     ContainingLargeEnum(Box<LargeEnum>),
    |                         ~~~~~~~~~~~~~~
 
 error: large size difference between variants
-  --> $DIR/large_enum_variant.rs:40:5
-   |
-LL |     ContainingMoreThanOneField(i32, [i32; 8000], [i32; 9500]),
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this variant is 70004 bytes
+  --> $DIR/large_enum_variant.rs:39:1
    |
-note: and the second-largest variant is 8 bytes:
-  --> $DIR/large_enum_variant.rs:42:5
+LL | / enum LargeEnum3 {
+LL | |     ContainingMoreThanOneField(i32, [i32; 8000], [i32; 9500]),
+   | |     --------------------------------------------------------- the largest variant contains at least 70004 bytes
+LL | |     VoidVariant,
+LL | |     StructLikeLittle { x: i32, y: i32 },
+   | |     ----------------------------------- the second-largest variant contains at least 8 bytes
+LL | | }
+   | |_^ the entire enum is at least 70008 bytes
    |
-LL |     StructLikeLittle { x: i32, y: i32 },
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 help: consider boxing the large fields to reduce the total size of the enum
    |
 LL |     ContainingMoreThanOneField(i32, Box<[i32; 8000]>, Box<[i32; 9500]>),
    |                                     ~~~~~~~~~~~~~~~~  ~~~~~~~~~~~~~~~~
 
 error: large size difference between variants
-  --> $DIR/large_enum_variant.rs:47:5
+  --> $DIR/large_enum_variant.rs:45:1
    |
-LL |     StructLikeLarge { x: [i32; 8000], y: i32 },
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this variant is 32004 bytes
+LL | / enum LargeEnum4 {
+LL | |     VariantOk(i32, u32),
+   | |     ------------------- the second-largest variant contains at least 8 bytes
+LL | |     StructLikeLarge { x: [i32; 8000], y: i32 },
+   | |     ------------------------------------------ the largest variant contains at least 32004 bytes
+LL | | }
+   | |_^ the entire enum is at least 32008 bytes
    |
-note: and the second-largest variant is 8 bytes:
-  --> $DIR/large_enum_variant.rs:46:5
-   |
-LL |     VariantOk(i32, u32),
-   |     ^^^^^^^^^^^^^^^^^^^
 help: consider boxing the large fields to reduce the total size of the enum
    |
 LL |     StructLikeLarge { x: Box<[i32; 8000]>, y: i32 },
    |                          ~~~~~~~~~~~~~~~~
 
 error: large size difference between variants
-  --> $DIR/large_enum_variant.rs:52:5
-   |
-LL |     StructLikeLarge2 { x: [i32; 8000] },
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this variant is 32000 bytes
+  --> $DIR/large_enum_variant.rs:50:1
    |
-note: and the second-largest variant is 8 bytes:
-  --> $DIR/large_enum_variant.rs:51:5
+LL | / enum LargeEnum5 {
+LL | |     VariantOk(i32, u32),
+   | |     ------------------- the second-largest variant contains at least 8 bytes
+LL | |     StructLikeLarge2 { x: [i32; 8000] },
+   | |     ----------------------------------- the largest variant contains at least 32000 bytes
+LL | | }
+   | |_^ the entire enum is at least 32004 bytes
    |
-LL |     VariantOk(i32, u32),
-   |     ^^^^^^^^^^^^^^^^^^^
 help: consider boxing the large fields to reduce the total size of the enum
    |
 LL |     StructLikeLarge2 { x: Box<[i32; 8000]> },
    |                           ~~~~~~~~~~~~~~~~
 
 error: large size difference between variants
-  --> $DIR/large_enum_variant.rs:68:5
-   |
-LL |     B([u8; 1255]),
-   |     ^^^^^^^^^^^^^ this variant is 1255 bytes
+  --> $DIR/large_enum_variant.rs:66:1
    |
-note: and the second-largest variant is 200 bytes:
-  --> $DIR/large_enum_variant.rs:69:5
+LL | / enum LargeEnum7 {
+LL | |     A,
+LL | |     B([u8; 1255]),
+   | |     ------------- the largest variant contains at least 1255 bytes
+LL | |     C([u8; 200]),
+   | |     ------------ the second-largest variant contains at least 200 bytes
+LL | | }
+   | |_^ the entire enum is at least 1256 bytes
    |
-LL |     C([u8; 200]),
-   |     ^^^^^^^^^^^^
 help: consider boxing the large fields to reduce the total size of the enum
    |
 LL |     B(Box<[u8; 1255]>),
    |       ~~~~~~~~~~~~~~~
 
 error: large size difference between variants
-  --> $DIR/large_enum_variant.rs:74:5
+  --> $DIR/large_enum_variant.rs:72:1
    |
-LL |     ContainingMoreThanOneField([i32; 8000], [i32; 2], [i32; 9500], [i32; 30]),
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this variant is 70128 bytes
+LL | / enum LargeEnum8 {
+LL | |     VariantOk(i32, u32),
+   | |     ------------------- the second-largest variant contains at least 8 bytes
+LL | |     ContainingMoreThanOneField([i32; 8000], [i32; 2], [i32; 9500], [i32; 30]),
+   | |     ------------------------------------------------------------------------- the largest variant contains at least 70128 bytes
+LL | | }
+   | |_^ the entire enum is at least 70132 bytes
    |
-note: and the second-largest variant is 8 bytes:
-  --> $DIR/large_enum_variant.rs:73:5
-   |
-LL |     VariantOk(i32, u32),
-   |     ^^^^^^^^^^^^^^^^^^^
 help: consider boxing the large fields to reduce the total size of the enum
    |
 LL |     ContainingMoreThanOneField(Box<[i32; 8000]>, [i32; 2], Box<[i32; 9500]>, [i32; 30]),
    |                                ~~~~~~~~~~~~~~~~            ~~~~~~~~~~~~~~~~
 
 error: large size difference between variants
-  --> $DIR/large_enum_variant.rs:79:5
+  --> $DIR/large_enum_variant.rs:77:1
+   |
+LL | / enum LargeEnum9 {
+LL | |     A(Struct<()>),
+   | |     ------------- the second-largest variant contains at least 4 bytes
+LL | |     B(Struct2),
+   | |     ---------- the largest variant contains at least 32000 bytes
+LL | | }
+   | |_^ the entire enum is at least 32004 bytes
+   |
+help: consider boxing the large fields to reduce the total size of the enum
    |
-LL |     B(Struct2),
-   |     ^^^^^^^^^^ this variant is 32000 bytes
+LL |     B(Box<Struct2>),
+   |       ~~~~~~~~~~~~
+
+error: large size difference between variants
+  --> $DIR/large_enum_variant.rs:82:1
    |
-note: and the second-largest variant is 4 bytes:
-  --> $DIR/large_enum_variant.rs:78:5
+LL | / enum LargeEnumOk2<T> {
+LL | |     A(T),
+   | |     ---- the second-largest variant contains at least 0 bytes
+LL | |     B(Struct2),
+   | |     ---------- the largest variant contains at least 32000 bytes
+LL | | }
+   | |_^ the entire enum is at least 32000 bytes
    |
-LL |     A(Struct<()>),
-   |     ^^^^^^^^^^^^^
 help: consider boxing the large fields to reduce the total size of the enum
    |
 LL |     B(Box<Struct2>),
    |       ~~~~~~~~~~~~
 
 error: large size difference between variants
-  --> $DIR/large_enum_variant.rs:104:5
+  --> $DIR/large_enum_variant.rs:87:1
    |
-LL |     B([u128; 4000]),
-   |     ^^^^^^^^^^^^^^^ this variant is 64000 bytes
+LL | / enum LargeEnumOk3<T> {
+LL | |     A(Struct<T>),
+   | |     ------------ the second-largest variant contains at least 4 bytes
+LL | |     B(Struct2),
+   | |     ---------- the largest variant contains at least 32000 bytes
+LL | | }
+   | |_^ the entire enum is at least 32000 bytes
+   |
+help: consider boxing the large fields to reduce the total size of the enum
    |
-note: and the second-largest variant is 1 bytes:
-  --> $DIR/large_enum_variant.rs:103:5
+LL |     B(Box<Struct2>),
+   |       ~~~~~~~~~~~~
+
+error: large size difference between variants
+  --> $DIR/large_enum_variant.rs:102:1
+   |
+LL | / enum CopyableLargeEnum {
+LL | |     A(bool),
+   | |     ------- the second-largest variant contains at least 1 bytes
+LL | |     B([u128; 4000]),
+   | |     --------------- the largest variant contains at least 64000 bytes
+LL | | }
+   | |_^ the entire enum is at least 64008 bytes
    |
-LL |     A(bool),
-   |     ^^^^^^^
 note: boxing a variant would require the type no longer be `Copy`
   --> $DIR/large_enum_variant.rs:102:6
    |
@@ -150,16 +184,16 @@ LL |     B([u128; 4000]),
    |     ^^^^^^^^^^^^^^^
 
 error: large size difference between variants
-  --> $DIR/large_enum_variant.rs:109:5
+  --> $DIR/large_enum_variant.rs:107:1
    |
-LL |     B([u128; 4000]),
-   |     ^^^^^^^^^^^^^^^ this variant is 64000 bytes
-   |
-note: and the second-largest variant is 1 bytes:
-  --> $DIR/large_enum_variant.rs:108:5
+LL | / enum ManuallyCopyLargeEnum {
+LL | |     A(bool),
+   | |     ------- the second-largest variant contains at least 1 bytes
+LL | |     B([u128; 4000]),
+   | |     --------------- the largest variant contains at least 64000 bytes
+LL | | }
+   | |_^ the entire enum is at least 64008 bytes
    |
-LL |     A(bool),
-   |     ^^^^^^^
 note: boxing a variant would require the type no longer be `Copy`
   --> $DIR/large_enum_variant.rs:107:6
    |
@@ -172,16 +206,16 @@ LL |     B([u128; 4000]),
    |     ^^^^^^^^^^^^^^^
 
 error: large size difference between variants
-  --> $DIR/large_enum_variant.rs:122:5
+  --> $DIR/large_enum_variant.rs:120:1
    |
-LL |     B([u64; 4000]),
-   |     ^^^^^^^^^^^^^^ this variant is 32000 bytes
-   |
-note: and the second-largest variant is 1 bytes:
-  --> $DIR/large_enum_variant.rs:121:5
+LL | / enum SomeGenericPossiblyCopyEnum<T> {
+LL | |     A(bool, std::marker::PhantomData<T>),
+   | |     ------------------------------------ the second-largest variant contains at least 1 bytes
+LL | |     B([u64; 4000]),
+   | |     -------------- the largest variant contains at least 32000 bytes
+LL | | }
+   | |_^ the entire enum is at least 32008 bytes
    |
-LL |     A(bool, std::marker::PhantomData<T>),
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 note: boxing a variant would require the type no longer be `Copy`
   --> $DIR/large_enum_variant.rs:120:6
    |
@@ -193,5 +227,53 @@ help: consider boxing the large fields to reduce the total size of the enum
 LL |     B([u64; 4000]),
    |     ^^^^^^^^^^^^^^
 
-error: aborting due to 11 previous errors
+error: large size difference between variants
+  --> $DIR/large_enum_variant.rs:133:1
+   |
+LL | / enum LargeEnumWithGenerics<T> {
+LL | |     Small,
+   | |     ----- the second-largest variant carries no data at all
+LL | |     Large((T, [u8; 512])),
+   | |     --------------------- the largest variant contains at least 512 bytes
+LL | | }
+   | |_^ the entire enum is at least 512 bytes
+   |
+help: consider boxing the large fields to reduce the total size of the enum
+   |
+LL |     Large(Box<(T, [u8; 512])>),
+   |           ~~~~~~~~~~~~~~~~~~~
+
+error: large size difference between variants
+  --> $DIR/large_enum_variant.rs:142:1
+   |
+LL | / enum WithGenerics {
+LL | |     Large([Foo<u64>; 64]),
+   | |     --------------------- the largest variant contains at least 512 bytes
+LL | |     Small(u8),
+   | |     --------- the second-largest variant contains at least 1 bytes
+LL | | }
+   | |_^ the entire enum is at least 520 bytes
+   |
+help: consider boxing the large fields to reduce the total size of the enum
+   |
+LL |     Large(Box<[Foo<u64>; 64]>),
+   |           ~~~~~~~~~~~~~~~~~~~
+
+error: large size difference between variants
+  --> $DIR/large_enum_variant.rs:152:1
+   |
+LL | / enum LargeEnumOfConst {
+LL | |     Ok,
+   | |     -- the second-largest variant carries no data at all
+LL | |     Error(PossiblyLargeEnumWithConst<256>),
+   | |     -------------------------------------- the largest variant contains at least 514 bytes
+LL | | }
+   | |_^ the entire enum is at least 514 bytes
+   |
+help: consider boxing the large fields to reduce the total size of the enum
+   |
+LL |     Error(Box<PossiblyLargeEnumWithConst<256>>),
+   |           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+error: aborting due to 16 previous errors
 
diff --git a/tests/ui/result_large_err.rs b/tests/ui/result_large_err.rs
index 78d8f76fe66..f7df3b85655 100644
--- a/tests/ui/result_large_err.rs
+++ b/tests/ui/result_large_err.rs
@@ -1,4 +1,5 @@
 #![warn(clippy::result_large_err)]
+#![allow(clippy::large_enum_variant)]
 
 pub fn small_err() -> Result<(), u128> {
     Ok(())
diff --git a/tests/ui/result_large_err.stderr b/tests/ui/result_large_err.stderr
index 0f1f39d72cb..ef19f2854ab 100644
--- a/tests/ui/result_large_err.stderr
+++ b/tests/ui/result_large_err.stderr
@@ -1,5 +1,5 @@
 error: the `Err`-variant returned from this function is very large
-  --> $DIR/result_large_err.rs:7:23
+  --> $DIR/result_large_err.rs:8:23
    |
 LL | pub fn large_err() -> Result<(), [u8; 512]> {
    |                       ^^^^^^^^^^^^^^^^^^^^^ the `Err`-variant is at least 512 bytes
@@ -8,7 +8,7 @@ LL | pub fn large_err() -> Result<(), [u8; 512]> {
    = help: try reducing the size of `[u8; 512]`, for example by boxing large elements or replacing it with `Box<[u8; 512]>`
 
 error: the `Err`-variant returned from this function is very large
-  --> $DIR/result_large_err.rs:18:21
+  --> $DIR/result_large_err.rs:19:21
    |
 LL |     pub fn ret() -> Result<(), Self> {
    |                     ^^^^^^^^^^^^^^^^ the `Err`-variant is at least 240 bytes
@@ -16,7 +16,7 @@ LL |     pub fn ret() -> Result<(), Self> {
    = help: try reducing the size of `FullyDefinedLargeError`, for example by boxing large elements or replacing it with `Box<FullyDefinedLargeError>`
 
 error: the `Err`-variant returned from this function is very large
-  --> $DIR/result_large_err.rs:23:26
+  --> $DIR/result_large_err.rs:24:26
    |
 LL | pub fn struct_error() -> Result<(), FullyDefinedLargeError> {
    |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the `Err`-variant is at least 240 bytes
@@ -24,7 +24,7 @@ LL | pub fn struct_error() -> Result<(), FullyDefinedLargeError> {
    = help: try reducing the size of `FullyDefinedLargeError`, for example by boxing large elements or replacing it with `Box<FullyDefinedLargeError>`
 
 error: the `Err`-variant returned from this function is very large
-  --> $DIR/result_large_err.rs:28:45
+  --> $DIR/result_large_err.rs:29:45
    |
 LL | pub fn large_err_via_type_alias<T>(x: T) -> Fdlr<T> {
    |                                             ^^^^^^^ the `Err`-variant is at least 240 bytes
@@ -32,7 +32,7 @@ LL | pub fn large_err_via_type_alias<T>(x: T) -> Fdlr<T> {
    = help: try reducing the size of `FullyDefinedLargeError`, for example by boxing large elements or replacing it with `Box<FullyDefinedLargeError>`
 
 error: the `Err`-variant returned from this function is very large
-  --> $DIR/result_large_err.rs:36:34
+  --> $DIR/result_large_err.rs:37:34
    |
 LL | pub fn param_large_error<R>() -> Result<(), (u128, R, FullyDefinedLargeError)> {
    |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the `Err`-variant is at least 256 bytes
@@ -40,7 +40,7 @@ LL | pub fn param_large_error<R>() -> Result<(), (u128, R, FullyDefinedLargeErro
    = help: try reducing the size of `(u128, R, FullyDefinedLargeError)`, for example by boxing large elements or replacing it with `Box<(u128, R, FullyDefinedLargeError)>`
 
 error: the `Err`-variant returned from this function is very large
-  --> $DIR/result_large_err.rs:47:34
+  --> $DIR/result_large_err.rs:48:34
    |
 LL |     pub fn large_enum_error() -> Result<(), Self> {
    |                                  ^^^^^^^^^^^^^^^^ the `Err`-variant is at least 513 bytes
@@ -48,7 +48,7 @@ LL |     pub fn large_enum_error() -> Result<(), Self> {
    = help: try reducing the size of `LargeErrorVariants<()>`, for example by boxing large elements or replacing it with `Box<LargeErrorVariants<()>>`
 
 error: the `Err`-variant returned from this function is very large
-  --> $DIR/result_large_err.rs:53:25
+  --> $DIR/result_large_err.rs:54:25
    |
 LL |     fn large_error() -> Result<(), [u8; 512]> {
    |                         ^^^^^^^^^^^^^^^^^^^^^ the `Err`-variant is at least 512 bytes
@@ -56,7 +56,7 @@ LL |     fn large_error() -> Result<(), [u8; 512]> {
    = help: try reducing the size of `[u8; 512]`, for example by boxing large elements or replacing it with `Box<[u8; 512]>`
 
 error: the `Err`-variant returned from this function is very large
-  --> $DIR/result_large_err.rs:72:29
+  --> $DIR/result_large_err.rs:73:29
    |
 LL | pub fn large_union_err() -> Result<(), FullyDefinedUnionError> {
    |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the `Err`-variant is at least 512 bytes
@@ -64,7 +64,7 @@ LL | pub fn large_union_err() -> Result<(), FullyDefinedUnionError> {
    = help: try reducing the size of `FullyDefinedUnionError`, for example by boxing large elements or replacing it with `Box<FullyDefinedUnionError>`
 
 error: the `Err`-variant returned from this function is very large
-  --> $DIR/result_large_err.rs:81:40
+  --> $DIR/result_large_err.rs:82:40
    |
 LL | pub fn param_large_union<T: Copy>() -> Result<(), UnionError<T>> {
    |                                        ^^^^^^^^^^^^^^^^^^^^^^^^^ the `Err`-variant is at least 512 bytes
@@ -72,7 +72,7 @@ LL | pub fn param_large_union<T: Copy>() -> Result<(), UnionError<T>> {
    = help: try reducing the size of `UnionError<T>`, for example by boxing large elements or replacing it with `Box<UnionError<T>>`
 
 error: the `Err`-variant returned from this function is very large
-  --> $DIR/result_large_err.rs:90:34
+  --> $DIR/result_large_err.rs:91:34
    |
 LL | pub fn array_error_subst<U>() -> Result<(), ArrayError<i32, U>> {
    |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the `Err`-variant is at least 128 bytes
@@ -80,7 +80,7 @@ LL | pub fn array_error_subst<U>() -> Result<(), ArrayError<i32, U>> {
    = help: try reducing the size of `ArrayError<i32, U>`, for example by boxing large elements or replacing it with `Box<ArrayError<i32, U>>`
 
 error: the `Err`-variant returned from this function is very large
-  --> $DIR/result_large_err.rs:94:31
+  --> $DIR/result_large_err.rs:95:31
    |
 LL | pub fn array_error<T, U>() -> Result<(), ArrayError<(i32, T), U>> {
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the `Err`-variant is at least 128 bytes
-- 
cgit 1.4.1-3-g733a5


From 750a2d57bde6fca3bbd856410fe4fb54c4c068dc Mon Sep 17 00:00:00 2001
From: Michael Wright <mikerite@lavabit.com>
Date: Sat, 3 Sep 2022 17:00:44 +0200
Subject: Fix `unnecessary_to_owned` false positive

Fixes #9351.

Note that this commit reworks that fix for #9317. The change
is to check that the type implements `AsRef<str>` before regarding
`to_string` as an equivalent of `to_owned`. This was suggested
by Jarcho in the #9317 issue comments.

The benefit of this is that it moves some complexity out of
`check_other_call_arg` and simplifies the module as a whole.
---
 clippy_lints/src/methods/unnecessary_to_owned.rs | 205 +++++++++++++++--------
 tests/ui/unnecessary_to_owned.fixed              |  60 +++++++
 tests/ui/unnecessary_to_owned.rs                 |  60 +++++++
 tests/ui/unnecessary_to_owned.stderr             |   8 +-
 4 files changed, 262 insertions(+), 71 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/unnecessary_to_owned.rs b/clippy_lints/src/methods/unnecessary_to_owned.rs
index 44bf8435294..d59b26c3144 100644
--- a/clippy_lints/src/methods/unnecessary_to_owned.rs
+++ b/clippy_lints/src/methods/unnecessary_to_owned.rs
@@ -1,21 +1,25 @@
 use super::implicit_clone::is_clone_like;
 use super::unnecessary_iter_cloned::{self, is_into_iter};
+use crate::rustc_middle::ty::Subst;
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_opt;
-use clippy_utils::ty::{
-    get_associated_type, get_iterator_item_ty, implements_trait, is_copy, is_type_diagnostic_item, peel_mid_ty_refs,
-};
-use clippy_utils::{fn_def_id, get_parent_expr, is_diag_item_method, is_diag_trait_item};
+use clippy_utils::ty::{get_associated_type, get_iterator_item_ty, implements_trait, is_copy, peel_mid_ty_refs};
+use clippy_utils::visitors::find_all_ret_expressions;
+use clippy_utils::{fn_def_id, get_parent_expr, is_diag_item_method, is_diag_trait_item, return_ty};
 use clippy_utils::{meets_msrv, msrvs};
 use rustc_errors::Applicability;
-use rustc_hir::{def_id::DefId, BorrowKind, Expr, ExprKind};
+use rustc_hir::{def_id::DefId, BorrowKind, Expr, ExprKind, ItemKind, Node};
+use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::LateContext;
 use rustc_middle::mir::Mutability;
 use rustc_middle::ty::adjustment::{Adjust, Adjustment, OverloadedDeref};
 use rustc_middle::ty::subst::{GenericArg, GenericArgKind, SubstsRef};
-use rustc_middle::ty::{self, PredicateKind, ProjectionPredicate, TraitPredicate, Ty};
+use rustc_middle::ty::EarlyBinder;
+use rustc_middle::ty::{self, ParamTy, PredicateKind, ProjectionPredicate, TraitPredicate, Ty};
 use rustc_semver::RustcVersion;
 use rustc_span::{sym, Symbol};
+use rustc_trait_selection::traits::{query::evaluate_obligation::InferCtxtExt as _, Obligation, ObligationCause};
+use rustc_typeck::check::{FnCtxt, Inherited};
 use std::cmp::max;
 
 use super::UNNECESSARY_TO_OWNED;
@@ -33,7 +37,7 @@ pub fn check<'tcx>(
         then {
             if is_cloned_or_copied(cx, method_name, method_def_id) {
                 unnecessary_iter_cloned::check(cx, expr, method_name, receiver);
-            } else if is_to_owned_like(cx, method_name, method_def_id) {
+            } else if is_to_owned_like(cx, expr, method_name, method_def_id) {
                 // At this point, we know the call is of a `to_owned`-like function. The functions
                 // `check_addr_of_expr` and `check_call_arg` determine whether the call is unnecessary
                 // based on its context, that is, whether it is a referent in an `AddrOf` expression, an
@@ -245,12 +249,12 @@ fn check_other_call_arg<'tcx>(
 ) -> bool {
     if_chain! {
         if let Some((maybe_call, maybe_arg)) = skip_addr_of_ancestors(cx, expr);
-        if let Some((callee_def_id, call_substs, call_args)) = get_callee_substs_and_args(cx, maybe_call);
+        if let Some((callee_def_id, _, call_args)) = get_callee_substs_and_args(cx, maybe_call);
         let fn_sig = cx.tcx.fn_sig(callee_def_id).skip_binder();
         if let Some(i) = call_args.iter().position(|arg| arg.hir_id == maybe_arg.hir_id);
         if let Some(input) = fn_sig.inputs().get(i);
         let (input, n_refs) = peel_mid_ty_refs(*input);
-        if let (trait_predicates, projection_predicates) = get_input_traits_and_projections(cx, callee_def_id, input);
+        if let (trait_predicates, _) = get_input_traits_and_projections(cx, callee_def_id, input);
         if let Some(sized_def_id) = cx.tcx.lang_items().sized_trait();
         if let [trait_predicate] = trait_predicates
             .iter()
@@ -258,52 +262,13 @@ fn check_other_call_arg<'tcx>(
             .collect::<Vec<_>>()[..];
         if let Some(deref_trait_id) = cx.tcx.get_diagnostic_item(sym::Deref);
         if let Some(as_ref_trait_id) = cx.tcx.get_diagnostic_item(sym::AsRef);
+        if trait_predicate.def_id() == deref_trait_id || trait_predicate.def_id() == as_ref_trait_id;
         let receiver_ty = cx.typeck_results().expr_ty(receiver);
-        // If the callee has type parameters, they could appear in `projection_predicate.ty` or the
-        // types of `trait_predicate.trait_ref.substs`.
-        if if trait_predicate.def_id() == deref_trait_id {
-            if let [projection_predicate] = projection_predicates[..] {
-                let normalized_ty =
-                    cx.tcx
-                        .subst_and_normalize_erasing_regions(call_substs, cx.param_env, projection_predicate.term);
-                implements_trait(cx, receiver_ty, deref_trait_id, &[])
-                    && get_associated_type(cx, receiver_ty, deref_trait_id, "Target")
-                        .map_or(false, |ty| ty::Term::Ty(ty) == normalized_ty)
-            } else {
-                false
-            }
-        } else if trait_predicate.def_id() == as_ref_trait_id {
-            let composed_substs = compose_substs(
-                cx,
-                &trait_predicate.trait_ref.substs.iter().skip(1).collect::<Vec<_>>()[..],
-                call_substs,
-            );
-            // if `expr` is a `String` and generic target is [u8], skip
-            // (https://github.com/rust-lang/rust-clippy/issues/9317).
-            if let [subst] = composed_substs[..]
-                && let GenericArgKind::Type(arg_ty) = subst.unpack()
-                && arg_ty.is_slice()
-                && let inner_ty = arg_ty.builtin_index().unwrap()
-                && let ty::Uint(ty::UintTy::U8) = inner_ty.kind()
-                && let self_ty = cx.typeck_results().expr_ty(expr).peel_refs()
-                && is_type_diagnostic_item(cx, self_ty, sym::String) {
-                false
-            } else {
-                implements_trait(cx, receiver_ty, as_ref_trait_id, &composed_substs)
-            }
-        } else {
-            false
-        };
+        if can_change_type(cx, maybe_arg, receiver_ty);
         // We can't add an `&` when the trait is `Deref` because `Target = &T` won't match
         // `Target = T`.
         if n_refs > 0 || is_copy(cx, receiver_ty) || trait_predicate.def_id() != deref_trait_id;
         let n_refs = max(n_refs, if is_copy(cx, receiver_ty) { 0 } else { 1 });
-        // If the trait is `AsRef` and the input type variable `T` occurs in the output type, then
-        // `T` must not be instantiated with a reference
-        // (https://github.com/rust-lang/rust-clippy/issues/8507).
-        if (n_refs == 0 && !receiver_ty.is_ref())
-            || trait_predicate.def_id() != as_ref_trait_id
-            || !fn_sig.output().contains(input);
         if let Some(receiver_snippet) = snippet_opt(cx, receiver.span);
         then {
             span_lint_and_sugg(
@@ -389,22 +354,102 @@ fn get_input_traits_and_projections<'tcx>(
     (trait_predicates, projection_predicates)
 }
 
-/// Composes two substitutions by applying the latter to the types of the former.
-fn compose_substs<'tcx>(
-    cx: &LateContext<'tcx>,
-    left: &[GenericArg<'tcx>],
-    right: SubstsRef<'tcx>,
-) -> Vec<GenericArg<'tcx>> {
-    left.iter()
-        .map(|arg| {
-            if let GenericArgKind::Type(arg_ty) = arg.unpack() {
-                let normalized_ty = cx.tcx.subst_and_normalize_erasing_regions(right, cx.param_env, arg_ty);
-                GenericArg::from(normalized_ty)
-            } else {
-                *arg
+fn can_change_type<'a>(cx: &LateContext<'a>, mut expr: &'a Expr<'a>, mut ty: Ty<'a>) -> bool {
+    for (_, node) in cx.tcx.hir().parent_iter(expr.hir_id) {
+        match node {
+            Node::Stmt(_) => return true,
+            Node::Block(..) => continue,
+            Node::Item(item) => {
+                if let ItemKind::Fn(_, _, body_id) = &item.kind
+                && let output_ty = return_ty(cx, item.hir_id())
+                && let local_def_id = cx.tcx.hir().local_def_id(item.hir_id())
+                && Inherited::build(cx.tcx, local_def_id).enter(|inherited| {
+                    let fn_ctxt = FnCtxt::new(&inherited, cx.param_env, item.hir_id());
+                    fn_ctxt.can_coerce(ty, output_ty)
+                }) {
+                    if has_lifetime(output_ty) && has_lifetime(ty) {
+                        return false;
+                    }
+                    let body = cx.tcx.hir().body(*body_id);
+                    let body_expr = &body.value;
+                    let mut count = 0;
+                    return find_all_ret_expressions(cx, body_expr, |_| { count += 1; count <= 1 });
+                }
             }
-        })
-        .collect()
+            Node::Expr(parent_expr) => {
+                if let Some((callee_def_id, call_substs, call_args)) = get_callee_substs_and_args(cx, parent_expr) {
+                    let fn_sig = cx.tcx.fn_sig(callee_def_id).skip_binder();
+                    if let Some(arg_index) = call_args.iter().position(|arg| arg.hir_id == expr.hir_id)
+                        && let Some(param_ty) = fn_sig.inputs().get(arg_index)
+                        && let ty::Param(ParamTy { index: param_index , ..}) = param_ty.kind()
+                    {
+                        if fn_sig
+                            .inputs()
+                            .iter()
+                            .enumerate()
+                            .filter(|(i, _)| *i != arg_index)
+                            .any(|(_, ty)| ty.contains(*param_ty))
+                        {
+                            return false;
+                        }
+
+                        let mut trait_predicates = cx.tcx.param_env(callee_def_id)
+                            .caller_bounds().iter().filter(|predicate| {
+                            if let PredicateKind::Trait(trait_predicate) =  predicate.kind().skip_binder()
+                                && trait_predicate.trait_ref.self_ty() == *param_ty {
+                                    true
+                                } else {
+                                false
+                            }
+                        });
+
+                        let new_subst = cx.tcx.mk_substs(
+                            call_substs.iter()
+                                .enumerate()
+                                .map(|(i, t)|
+                                     if i == (*param_index as usize) {
+                                         GenericArg::from(ty)
+                                     } else {
+                                         t
+                                     }));
+
+                        if trait_predicates.any(|predicate| {
+                            let predicate = EarlyBinder(predicate).subst(cx.tcx, new_subst);
+                            let obligation = Obligation::new(ObligationCause::dummy(), cx.param_env, predicate);
+                            !cx.tcx
+                                .infer_ctxt()
+                                .enter(|infcx| infcx.predicate_must_hold_modulo_regions(&obligation))
+                        }) {
+                            return false;
+                        }
+
+                        let output_ty = fn_sig.output();
+                        if output_ty.contains(*param_ty) {
+                            if let Ok(new_ty)  = cx.tcx.try_subst_and_normalize_erasing_regions(
+                                new_subst, cx.param_env, output_ty) {
+                                expr = parent_expr;
+                                ty = new_ty;
+                                continue;
+                            }
+                            return false;
+                        }
+
+                        return true;
+                    }
+                } else if let ExprKind::Block(..) = parent_expr.kind {
+                    continue;
+                }
+                return false;
+            },
+            _ => return false,
+        }
+    }
+
+    false
+}
+
+fn has_lifetime(ty: Ty<'_>) -> bool {
+    ty.walk().any(|t| matches!(t.unpack(), GenericArgKind::Lifetime(_)))
 }
 
 /// Returns true if the named method is `Iterator::cloned` or `Iterator::copied`.
@@ -415,10 +460,10 @@ fn is_cloned_or_copied(cx: &LateContext<'_>, method_name: Symbol, method_def_id:
 
 /// Returns true if the named method can be used to convert the receiver to its "owned"
 /// representation.
-fn is_to_owned_like(cx: &LateContext<'_>, method_name: Symbol, method_def_id: DefId) -> bool {
+fn is_to_owned_like<'a>(cx: &LateContext<'a>, call_expr: &Expr<'a>, method_name: Symbol, method_def_id: DefId) -> bool {
     is_clone_like(cx, method_name.as_str(), method_def_id)
         || is_cow_into_owned(cx, method_name, method_def_id)
-        || is_to_string(cx, method_name, method_def_id)
+        || is_to_string_on_string_like(cx, call_expr, method_name, method_def_id)
 }
 
 /// Returns true if the named method is `Cow::into_owned`.
@@ -426,7 +471,27 @@ fn is_cow_into_owned(cx: &LateContext<'_>, method_name: Symbol, method_def_id: D
     method_name.as_str() == "into_owned" && is_diag_item_method(cx, method_def_id, sym::Cow)
 }
 
-/// Returns true if the named method is `ToString::to_string`.
-fn is_to_string(cx: &LateContext<'_>, method_name: Symbol, method_def_id: DefId) -> bool {
-    method_name == sym::to_string && is_diag_trait_item(cx, method_def_id, sym::ToString)
+/// Returns true if the named method is `ToString::to_string` and it's called on a type that
+/// is string-like i.e. implements `AsRef<str>` or `Deref<str>`.
+fn is_to_string_on_string_like<'a>(
+    cx: &LateContext<'_>,
+    call_expr: &'a Expr<'a>,
+    method_name: Symbol,
+    method_def_id: DefId,
+) -> bool {
+    if method_name != sym::to_string || !is_diag_trait_item(cx, method_def_id, sym::ToString) {
+        return false;
+    }
+
+    if let Some(substs) = cx.typeck_results().node_substs_opt(call_expr.hir_id)
+        && let [generic_arg] = substs.as_slice()
+        && let GenericArgKind::Type(ty) = generic_arg.unpack()
+        && let Some(deref_trait_id) = cx.tcx.get_diagnostic_item(sym::Deref)
+        && let Some(as_ref_trait_id) = cx.tcx.get_diagnostic_item(sym::AsRef)
+        && (implements_trait(cx, ty, deref_trait_id, &[cx.tcx.types.str_.into()]) ||
+            implements_trait(cx, ty, as_ref_trait_id, &[cx.tcx.types.str_.into()])) {
+            true
+        } else {
+            false
+        }
 }
diff --git a/tests/ui/unnecessary_to_owned.fixed b/tests/ui/unnecessary_to_owned.fixed
index 9cd5bc73b1e..a920c63b199 100644
--- a/tests/ui/unnecessary_to_owned.fixed
+++ b/tests/ui/unnecessary_to_owned.fixed
@@ -357,3 +357,63 @@ mod issue_9317 {
         consume(b.to_string());
     }
 }
+
+mod issue_9351 {
+    #![allow(dead_code)]
+
+    use std::ops::Deref;
+    use std::path::{Path, PathBuf};
+
+    fn require_deref_path<T: Deref<Target = std::path::Path>>(x: T) -> T {
+        x
+    }
+
+    fn generic_arg_used_elsewhere<T: AsRef<Path>>(_x: T, _y: T) {}
+
+    fn id<T: AsRef<str>>(x: T) -> T {
+        x
+    }
+
+    fn predicates_are_satisfied(_x: impl std::fmt::Write) {}
+
+    // Should lint
+    fn single_return() -> impl AsRef<str> {
+        id("abc")
+    }
+
+    // Should not lint
+    fn multiple_returns(b: bool) -> impl AsRef<str> {
+        if b {
+            return String::new();
+        }
+
+        id("abc".to_string())
+    }
+
+    struct S1(String);
+
+    // Should not lint
+    fn fields1() -> S1 {
+        S1(id("abc".to_string()))
+    }
+
+    struct S2 {
+        s: String,
+    }
+
+    // Should not lint
+    fn fields2() {
+        let mut s = S2 { s: "abc".into() };
+        s.s = id("abc".to_string());
+    }
+
+    pub fn main() {
+        let path = std::path::Path::new("x");
+        let path_buf = path.to_owned();
+
+        // Should not lint.
+        let _x: PathBuf = require_deref_path(path.to_owned());
+        generic_arg_used_elsewhere(path.to_owned(), path_buf);
+        predicates_are_satisfied(id("abc".to_string()));
+    }
+}
diff --git a/tests/ui/unnecessary_to_owned.rs b/tests/ui/unnecessary_to_owned.rs
index 7f62ba3ab5d..2128bdacdda 100644
--- a/tests/ui/unnecessary_to_owned.rs
+++ b/tests/ui/unnecessary_to_owned.rs
@@ -357,3 +357,63 @@ mod issue_9317 {
         consume(b.to_string());
     }
 }
+
+mod issue_9351 {
+    #![allow(dead_code)]
+
+    use std::ops::Deref;
+    use std::path::{Path, PathBuf};
+
+    fn require_deref_path<T: Deref<Target = std::path::Path>>(x: T) -> T {
+        x
+    }
+
+    fn generic_arg_used_elsewhere<T: AsRef<Path>>(_x: T, _y: T) {}
+
+    fn id<T: AsRef<str>>(x: T) -> T {
+        x
+    }
+
+    fn predicates_are_satisfied(_x: impl std::fmt::Write) {}
+
+    // Should lint
+    fn single_return() -> impl AsRef<str> {
+        id("abc".to_string())
+    }
+
+    // Should not lint
+    fn multiple_returns(b: bool) -> impl AsRef<str> {
+        if b {
+            return String::new();
+        }
+
+        id("abc".to_string())
+    }
+
+    struct S1(String);
+
+    // Should not lint
+    fn fields1() -> S1 {
+        S1(id("abc".to_string()))
+    }
+
+    struct S2 {
+        s: String,
+    }
+
+    // Should not lint
+    fn fields2() {
+        let mut s = S2 { s: "abc".into() };
+        s.s = id("abc".to_string());
+    }
+
+    pub fn main() {
+        let path = std::path::Path::new("x");
+        let path_buf = path.to_owned();
+
+        // Should not lint.
+        let _x: PathBuf = require_deref_path(path.to_owned());
+        generic_arg_used_elsewhere(path.to_owned(), path_buf);
+        predicates_are_satisfied(id("abc".to_string()));
+    }
+}
diff --git a/tests/ui/unnecessary_to_owned.stderr b/tests/ui/unnecessary_to_owned.stderr
index 243b4599dba..7deb90b06f3 100644
--- a/tests/ui/unnecessary_to_owned.stderr
+++ b/tests/ui/unnecessary_to_owned.stderr
@@ -509,5 +509,11 @@ error: unnecessary use of `to_string`
 LL |         Box::new(build(y.to_string()))
    |                        ^^^^^^^^^^^^^ help: use: `y`
 
-error: aborting due to 78 previous errors
+error: unnecessary use of `to_string`
+  --> $DIR/unnecessary_to_owned.rs:381:12
+   |
+LL |         id("abc".to_string())
+   |            ^^^^^^^^^^^^^^^^^ help: use: `"abc"`
+
+error: aborting due to 79 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 2cc20e32451cd6ee3b1336616d6ef7990de96009 Mon Sep 17 00:00:00 2001
From: kraktus <56031107+kraktus@users.noreply.github.com>
Date: Sun, 4 Sep 2022 16:29:30 +0200
Subject: fix wording for `derivable_impls`

---
 clippy_lints/src/derivable_impls.rs | 2 +-
 src/docs/derivable_impls.txt        | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/derivable_impls.rs b/clippy_lints/src/derivable_impls.rs
index 4d7f4076d7b..ef9eeecc6a9 100644
--- a/clippy_lints/src/derivable_impls.rs
+++ b/clippy_lints/src/derivable_impls.rs
@@ -40,7 +40,7 @@ declare_clippy_lint! {
     ///
     /// ### Known problems
     /// Derive macros [sometimes use incorrect bounds](https://github.com/rust-lang/rust/issues/26925)
-    /// in generic types and the user defined `impl` maybe is more generalized or
+    /// in generic types and the user defined `impl` may be more generalized or
     /// specialized than what derive will produce. This lint can't detect the manual `impl`
     /// has exactly equal bounds, and therefore this lint is disabled for types with
     /// generic parameters.
diff --git a/src/docs/derivable_impls.txt b/src/docs/derivable_impls.txt
index 8e4a80a672c..5cee43956cc 100644
--- a/src/docs/derivable_impls.txt
+++ b/src/docs/derivable_impls.txt
@@ -29,7 +29,7 @@ struct Foo {
 
 ### Known problems
 Derive macros [sometimes use incorrect bounds](https://github.com/rust-lang/rust/issues/26925)
-in generic types and the user defined `impl` maybe is more generalized or
+in generic types and the user defined `impl` may be more generalized or
 specialized than what derive will produce. This lint can't detect the manual `impl`
 has exactly equal bounds, and therefore this lint is disabled for types with
 generic parameters.
\ No newline at end of file
-- 
cgit 1.4.1-3-g733a5


From f0e586c2511019a58ad3e56be16bba76dfc7eba8 Mon Sep 17 00:00:00 2001
From: relrelb <relrelbachar@gmail.com>
Date: Tue, 16 Aug 2022 23:26:03 +0300
Subject: Suggest `Entry::or_default` for
 `Entry::or_insert(Default::default())`

Unlike past similar work done in #6228, expand the existing `or_fun_call`
lint to detect `or_insert` calls with a `T::new()` or `T::default()`
argument, much like currently done for `unwrap_or` calls. In that case,
suggest the use of `or_default`, which is more idiomatic.

Note that even with this change, `or_insert_with(T::default)` calls
aren't detected as candidates for `or_default()`, in the same manner
that currently `unwrap_or_else(T::default)` calls aren't detected as
candidates for `unwrap_or_default()`.

Also, as a nearby cleanup, change `KNOW_TYPES` from `static` to `const`,
since as far as I understand it's preferred (should Clippy have a lint
for that?).

Fixes #3812.
---
 clippy_lints/src/methods/mod.rs         |  5 +++--
 clippy_lints/src/methods/or_fun_call.rs | 13 +++++++++----
 src/docs/or_fun_call.txt                |  5 +++--
 tests/ui/or_fun_call.fixed              |  8 ++++----
 tests/ui/or_fun_call.stderr             | 26 +++++++++++++++++++++++++-
 5 files changed, 44 insertions(+), 13 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index a0d190a58af..b7d2d980db8 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -825,8 +825,9 @@ declare_clippy_lint! {
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for calls to `.or(foo(..))`, `.unwrap_or(foo(..))`,
-    /// etc., and suggests to use `or_else`, `unwrap_or_else`, etc., or
-    /// `unwrap_or_default` instead.
+    /// `.or_insert(foo(..))` etc., and suggests to use `.or_else(|| foo(..))`,
+    /// `.unwrap_or_else(|| foo(..))`, `.unwrap_or_default()` or `.or_default()`
+    /// etc. instead.
     ///
     /// ### Why is this bad?
     /// The function will always be called and potentially
diff --git a/clippy_lints/src/methods/or_fun_call.rs b/clippy_lints/src/methods/or_fun_call.rs
index 6af134019a4..c97f714680e 100644
--- a/clippy_lints/src/methods/or_fun_call.rs
+++ b/clippy_lints/src/methods/or_fun_call.rs
@@ -22,7 +22,8 @@ pub(super) fn check<'tcx>(
     name: &str,
     args: &'tcx [hir::Expr<'_>],
 ) {
-    /// Checks for `unwrap_or(T::new())` or `unwrap_or(T::default())`.
+    /// Checks for `unwrap_or(T::new())`, `unwrap_or(T::default())`,
+    /// `or_insert(T::new())` or `or_insert(T::default())`.
     #[allow(clippy::too_many_arguments)]
     fn check_unwrap_or_default(
         cx: &LateContext<'_>,
@@ -42,7 +43,11 @@ pub(super) fn check<'tcx>(
 
         if_chain! {
             if !or_has_args;
-            if name == "unwrap_or";
+            if let Some(sugg) = match name {
+                "unwrap_or" => Some("unwrap_or_default"),
+                "or_insert" => Some("or_default"),
+                _ => None,
+            };
             if let hir::ExprKind::Path(ref qpath) = fun.kind;
             if let Some(default_trait_id) = cx.tcx.get_diagnostic_item(sym::Default);
             let path = last_path_segment(qpath).ident.name;
@@ -58,7 +63,7 @@ pub(super) fn check<'tcx>(
                     method_span.with_hi(span.hi()),
                     &format!("use of `{}` followed by a call to `{}`", name, path),
                     "try this",
-                    "unwrap_or_default()".to_string(),
+                    format!("{}()", sugg),
                     Applicability::MachineApplicable,
                 );
 
@@ -82,7 +87,7 @@ pub(super) fn check<'tcx>(
         fun_span: Option<Span>,
     ) {
         // (path, fn_has_argument, methods, suffix)
-        static KNOW_TYPES: [(&[&str], bool, &[&str], &str); 4] = [
+        const KNOW_TYPES: [(&[&str], bool, &[&str], &str); 4] = [
             (&paths::BTREEMAP_ENTRY, false, &["or_insert"], "with"),
             (&paths::HASHMAP_ENTRY, false, &["or_insert"], "with"),
             (&paths::OPTION, false, &["map_or", "ok_or", "or", "unwrap_or"], "else"),
diff --git a/src/docs/or_fun_call.txt b/src/docs/or_fun_call.txt
index 5605e96c98e..6ce77cc268c 100644
--- a/src/docs/or_fun_call.txt
+++ b/src/docs/or_fun_call.txt
@@ -1,7 +1,8 @@
 ### What it does
 Checks for calls to `.or(foo(..))`, `.unwrap_or(foo(..))`,
-etc., and suggests to use `or_else`, `unwrap_or_else`, etc., or
-`unwrap_or_default` instead.
+`.or_insert(foo(..))` etc., and suggests to use `.or_else(|| foo(..))`,
+`.unwrap_or_else(|| foo(..))`, `.unwrap_or_default()` or `.or_default()`
+etc. instead.
 
 ### Why is this bad?
 The function will always be called and potentially
diff --git a/tests/ui/or_fun_call.fixed b/tests/ui/or_fun_call.fixed
index 18ea4e55029..5991188ab63 100644
--- a/tests/ui/or_fun_call.fixed
+++ b/tests/ui/or_fun_call.fixed
@@ -79,16 +79,16 @@ fn or_fun_call() {
     without_default.unwrap_or_else(Foo::new);
 
     let mut map = HashMap::<u64, String>::new();
-    map.entry(42).or_insert(String::new());
+    map.entry(42).or_default();
 
     let mut map_vec = HashMap::<u64, Vec<i32>>::new();
-    map_vec.entry(42).or_insert(vec![]);
+    map_vec.entry(42).or_default();
 
     let mut btree = BTreeMap::<u64, String>::new();
-    btree.entry(42).or_insert(String::new());
+    btree.entry(42).or_default();
 
     let mut btree_vec = BTreeMap::<u64, Vec<i32>>::new();
-    btree_vec.entry(42).or_insert(vec![]);
+    btree_vec.entry(42).or_default();
 
     let stringy = Some(String::new());
     let _ = stringy.unwrap_or_default();
diff --git a/tests/ui/or_fun_call.stderr b/tests/ui/or_fun_call.stderr
index 887f23ac976..e3dab4cb147 100644
--- a/tests/ui/or_fun_call.stderr
+++ b/tests/ui/or_fun_call.stderr
@@ -66,6 +66,30 @@ error: use of `unwrap_or` followed by a function call
 LL |     without_default.unwrap_or(Foo::new());
    |                     ^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(Foo::new)`
 
+error: use of `or_insert` followed by a call to `new`
+  --> $DIR/or_fun_call.rs:82:19
+   |
+LL |     map.entry(42).or_insert(String::new());
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `or_default()`
+
+error: use of `or_insert` followed by a call to `new`
+  --> $DIR/or_fun_call.rs:85:23
+   |
+LL |     map_vec.entry(42).or_insert(vec![]);
+   |                       ^^^^^^^^^^^^^^^^^ help: try this: `or_default()`
+
+error: use of `or_insert` followed by a call to `new`
+  --> $DIR/or_fun_call.rs:88:21
+   |
+LL |     btree.entry(42).or_insert(String::new());
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `or_default()`
+
+error: use of `or_insert` followed by a call to `new`
+  --> $DIR/or_fun_call.rs:91:25
+   |
+LL |     btree_vec.entry(42).or_insert(vec![]);
+   |                         ^^^^^^^^^^^^^^^^^ help: try this: `or_default()`
+
 error: use of `unwrap_or` followed by a call to `new`
   --> $DIR/or_fun_call.rs:94:21
    |
@@ -132,5 +156,5 @@ error: use of `unwrap_or` followed by a call to `new`
 LL |         .unwrap_or(String::new());
    |          ^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_default()`
 
-error: aborting due to 22 previous errors
+error: aborting due to 26 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From b21d9d307b5fdb1e423d786f9899757b42957b07 Mon Sep 17 00:00:00 2001
From: xphoniex <xphoniex@users.noreply.github.com>
Date: Tue, 6 Sep 2022 04:38:29 +0000
Subject: Suggest `unwrap_or_default` when closure returns `"".to_string`

Signed-off-by: xphoniex <xphoniex@users.noreply.github.com>
---
 clippy_lints/src/methods/unwrap_or_else_default.rs | 24 ++++++++++++++++++++--
 tests/ui/unwrap_or_else_default.fixed              |  3 +++
 tests/ui/unwrap_or_else_default.rs                 |  3 +++
 tests/ui/unwrap_or_else_default.stderr             |  8 +++++++-
 4 files changed, 35 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/unwrap_or_else_default.rs b/clippy_lints/src/methods/unwrap_or_else_default.rs
index f3af281d6ca..d3630b7d08e 100644
--- a/clippy_lints/src/methods/unwrap_or_else_default.rs
+++ b/clippy_lints/src/methods/unwrap_or_else_default.rs
@@ -5,10 +5,11 @@ use clippy_utils::{
     diagnostics::span_lint_and_sugg, is_default_equivalent_call, source::snippet_with_applicability,
     ty::is_type_diagnostic_item,
 };
+use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
-use rustc_span::sym;
+use rustc_span::{sym, symbol};
 
 pub(super) fn check<'tcx>(
     cx: &LateContext<'tcx>,
@@ -25,7 +26,7 @@ pub(super) fn check<'tcx>(
 
     if_chain! {
         if is_option || is_result;
-        if is_default_equivalent_call(cx, u_arg);
+        if closure_body_returns_empty_to_string(cx, u_arg) || is_default_equivalent_call(cx, u_arg);
         then {
             let mut applicability = Applicability::MachineApplicable;
 
@@ -44,3 +45,22 @@ pub(super) fn check<'tcx>(
         }
     }
 }
+
+fn closure_body_returns_empty_to_string(cx: &LateContext<'_>, e: &hir::Expr<'_>) -> bool {
+    if let hir::ExprKind::Closure(&hir::Closure { body, .. }) = e.kind {
+        let body = cx.tcx.hir().body(body);
+
+        if body.params.is_empty()
+            && let hir::Expr{ kind, .. } = &body.value
+            && let hir::ExprKind::MethodCall(hir::PathSegment {ident, ..}, [self_arg], _) = kind
+            && ident == &symbol::Ident::from_str("to_string")
+            && let hir::Expr{ kind, .. } = self_arg
+            && let hir::ExprKind::Lit(lit) = kind
+            && let LitKind::Str(symbol::kw::Empty, _) = lit.node
+        {
+            return true;
+        }
+    }
+
+    false
+}
diff --git a/tests/ui/unwrap_or_else_default.fixed b/tests/ui/unwrap_or_else_default.fixed
index c2b9bd2c881..84f779569ff 100644
--- a/tests/ui/unwrap_or_else_default.fixed
+++ b/tests/ui/unwrap_or_else_default.fixed
@@ -69,6 +69,9 @@ fn unwrap_or_else_default() {
 
     let with_default_type: Option<Vec<u64>> = None;
     with_default_type.unwrap_or_default();
+
+    let empty_string = None::<String>;
+    empty_string.unwrap_or_default();
 }
 
 fn main() {}
diff --git a/tests/ui/unwrap_or_else_default.rs b/tests/ui/unwrap_or_else_default.rs
index d55664990ae..1735bd5808e 100644
--- a/tests/ui/unwrap_or_else_default.rs
+++ b/tests/ui/unwrap_or_else_default.rs
@@ -69,6 +69,9 @@ fn unwrap_or_else_default() {
 
     let with_default_type: Option<Vec<u64>> = None;
     with_default_type.unwrap_or_else(Vec::new);
+
+    let empty_string = None::<String>;
+    empty_string.unwrap_or_else(|| "".to_string());
 }
 
 fn main() {}
diff --git a/tests/ui/unwrap_or_else_default.stderr b/tests/ui/unwrap_or_else_default.stderr
index 53e31d85edf..d2b9212223f 100644
--- a/tests/ui/unwrap_or_else_default.stderr
+++ b/tests/ui/unwrap_or_else_default.stderr
@@ -30,5 +30,11 @@ error: use of `.unwrap_or_else(..)` to construct default value
 LL |     with_default_type.unwrap_or_else(Vec::new);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `with_default_type.unwrap_or_default()`
 
-error: aborting due to 5 previous errors
+error: use of `.unwrap_or_else(..)` to construct default value
+  --> $DIR/unwrap_or_else_default.rs:74:5
+   |
+LL |     empty_string.unwrap_or_else(|| "".to_string());
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `empty_string.unwrap_or_default()`
+
+error: aborting due to 6 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 0d078c9fd6881a011713d810773aec03e17d793f Mon Sep 17 00:00:00 2001
From: Caio <c410.f3r@gmail.com>
Date: Wed, 7 Sep 2022 10:00:45 -0300
Subject: [Arithmetic] Consider literals

---
 clippy_lints/src/operators/arithmetic.rs | 118 ++++++++++++++++++++++---------
 clippy_lints/src/operators/mod.rs        |  22 +++---
 src/docs/arithmetic.txt                  |  21 +++---
 tests/ui/arithmetic.fixed                |  27 -------
 tests/ui/arithmetic.rs                   |  38 ++++++++--
 tests/ui/arithmetic.stderr               |  22 ++++++
 6 files changed, 168 insertions(+), 80 deletions(-)
 delete mode 100644 tests/ui/arithmetic.fixed
 create mode 100644 tests/ui/arithmetic.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/operators/arithmetic.rs b/clippy_lints/src/operators/arithmetic.rs
index 800cf249f5c..27eef92deef 100644
--- a/clippy_lints/src/operators/arithmetic.rs
+++ b/clippy_lints/src/operators/arithmetic.rs
@@ -5,13 +5,21 @@
 
 use super::ARITHMETIC;
 use clippy_utils::{consts::constant_simple, diagnostics::span_lint};
+use rustc_ast as ast;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::Ty;
 use rustc_session::impl_lint_pass;
-use rustc_span::source_map::Span;
+use rustc_span::source_map::{Span, Spanned};
 
-const HARD_CODED_ALLOWED: &[&str] = &["std::num::Saturating", "std::string::String", "std::num::Wrapping"];
+const HARD_CODED_ALLOWED: &[&str] = &[
+    "f32",
+    "f64",
+    "std::num::Saturating",
+    "std::string::String",
+    "std::num::Wrapping",
+];
 
 #[derive(Debug)]
 pub struct Arithmetic {
@@ -34,6 +42,27 @@ impl Arithmetic {
         }
     }
 
+    /// Checks assign operators (+=, -=, *=, /=) of integers in a non-constant environment that
+    /// won't overflow.
+    fn has_valid_assign_op(op: &Spanned<hir::BinOpKind>, rhs: &hir::Expr<'_>, rhs_refs: Ty<'_>) -> bool {
+        if !Self::is_literal_integer(rhs, rhs_refs) {
+            return false;
+        }
+        if let hir::BinOpKind::Div | hir::BinOpKind::Mul = op.node
+            && let hir::ExprKind::Lit(ref lit) = rhs.kind
+            && let ast::LitKind::Int(1, _) = lit.node
+        {
+            return true;
+        }
+        false
+    }
+
+    /// Checks "raw" binary operators (+, -, *, /) of integers in a non-constant environment
+    /// already handled by the CTFE.
+    fn has_valid_bin_op(lhs: &hir::Expr<'_>, lhs_refs: Ty<'_>, rhs: &hir::Expr<'_>, rhs_refs: Ty<'_>) -> bool {
+        Self::is_literal_integer(lhs, lhs_refs) && Self::is_literal_integer(rhs, rhs_refs)
+    }
+
     /// Checks if the given `expr` has any of the inner `allowed` elements.
     fn is_allowed_ty(&self, cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> bool {
         self.allowed.contains(
@@ -46,40 +75,66 @@ impl Arithmetic {
         )
     }
 
+    /// Explicit integers like `1` or `i32::MAX`. Does not take into consideration references.
+    fn is_literal_integer(expr: &hir::Expr<'_>, expr_refs: Ty<'_>) -> bool {
+        let is_integral = expr_refs.is_integral();
+        let is_literal = matches!(expr.kind, hir::ExprKind::Lit(_));
+        is_integral && is_literal
+    }
+
     fn issue_lint(&mut self, cx: &LateContext<'_>, expr: &hir::Expr<'_>) {
         span_lint(cx, ARITHMETIC, expr.span, "arithmetic detected");
         self.expr_span = Some(expr.span);
     }
+
+    /// Manages when the lint should be triggered. Operations in constant environments, hard coded
+    /// types, custom allowed types and non-constant operations that won't overflow are ignored.
+    fn manage_bin_ops(
+        &mut self,
+        cx: &LateContext<'_>,
+        expr: &hir::Expr<'_>,
+        op: &Spanned<hir::BinOpKind>,
+        lhs: &hir::Expr<'_>,
+        rhs: &hir::Expr<'_>,
+    ) {
+        if constant_simple(cx, cx.typeck_results(), expr).is_some() {
+            return;
+        }
+        if !matches!(
+            op.node,
+            hir::BinOpKind::Add
+                | hir::BinOpKind::Sub
+                | hir::BinOpKind::Mul
+                | hir::BinOpKind::Div
+                | hir::BinOpKind::Rem
+                | hir::BinOpKind::Shl
+                | hir::BinOpKind::Shr
+        ) {
+            return;
+        };
+        if self.is_allowed_ty(cx, lhs) || self.is_allowed_ty(cx, rhs) {
+            return;
+        }
+        let lhs_refs = cx.typeck_results().expr_ty(lhs).peel_refs();
+        let rhs_refs = cx.typeck_results().expr_ty(rhs).peel_refs();
+        let has_valid_assign_op = Self::has_valid_assign_op(op, rhs, rhs_refs);
+        if has_valid_assign_op || Self::has_valid_bin_op(lhs, lhs_refs, rhs, rhs_refs) {
+            return;
+        }
+        self.issue_lint(cx, expr);
+    }
 }
 
 impl<'tcx> LateLintPass<'tcx> for Arithmetic {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
-        if self.expr_span.is_some() {
-            return;
-        }
-        if let Some(span) = self.const_span && span.contains(expr.span) {
+        if self.expr_span.is_some() || self.const_span.map_or(false, |sp| sp.contains(expr.span)) {
             return;
         }
         match &expr.kind {
             hir::ExprKind::Binary(op, lhs, rhs) | hir::ExprKind::AssignOp(op, lhs, rhs) => {
-                let (
-                    hir::BinOpKind::Add
-                    | hir::BinOpKind::Sub
-                    | hir::BinOpKind::Mul
-                    | hir::BinOpKind::Div
-                    | hir::BinOpKind::Rem
-                    | hir::BinOpKind::Shl
-                    | hir::BinOpKind::Shr
-                ) = op.node else {
-                    return;
-                };
-                if self.is_allowed_ty(cx, lhs) || self.is_allowed_ty(cx, rhs) {
-                    return;
-                }
-                self.issue_lint(cx, expr);
+                self.manage_bin_ops(cx, expr, op, lhs, rhs);
             },
             hir::ExprKind::Unary(hir::UnOp::Neg, _) => {
-                // CTFE already takes care of things like `-1` that do not overflow.
                 if constant_simple(cx, cx.typeck_results(), expr).is_none() {
                     self.issue_lint(cx, expr);
                 }
@@ -89,16 +144,15 @@ impl<'tcx> LateLintPass<'tcx> for Arithmetic {
     }
 
     fn check_body(&mut self, cx: &LateContext<'_>, body: &hir::Body<'_>) {
-        let body_owner = cx.tcx.hir().body_owner_def_id(body.id());
-        match cx.tcx.hir().body_owner_kind(body_owner) {
-            hir::BodyOwnerKind::Const | hir::BodyOwnerKind::Static(_) => {
-                let body_span = cx.tcx.def_span(body_owner);
-                if let Some(span) = self.const_span && span.contains(body_span) {
-                    return;
-                }
-                self.const_span = Some(body_span);
-            },
-            hir::BodyOwnerKind::Closure | hir::BodyOwnerKind::Fn => {},
+        let body_owner = cx.tcx.hir().body_owner(body.id());
+        let body_owner_def_id = cx.tcx.hir().local_def_id(body_owner);
+        let body_owner_kind = cx.tcx.hir().body_owner_kind(body_owner_def_id);
+        if let hir::BodyOwnerKind::Const | hir::BodyOwnerKind::Static(_) = body_owner_kind {
+            let body_span = cx.tcx.hir().span_with_body(body_owner);
+            if let Some(span) = self.const_span && span.contains(body_span) {
+                return;
+            }
+            self.const_span = Some(body_span);
         }
     }
 
diff --git a/clippy_lints/src/operators/mod.rs b/clippy_lints/src/operators/mod.rs
index bb6d99406b4..c7b0633b79c 100644
--- a/clippy_lints/src/operators/mod.rs
+++ b/clippy_lints/src/operators/mod.rs
@@ -61,25 +61,29 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for any kind of arithmetic operation of any type.
+    /// Checks any kind of arithmetic operation of any type.
     ///
     /// Operators like `+`, `-`, `*` or `<<` are usually capable of overflowing according to the [Rust
     /// Reference](https://doc.rust-lang.org/reference/expressions/operator-expr.html#overflow),
-    /// or can panic (`/`, `%`). Known safe built-in types like `Wrapping` or `Saturing` are filtered
-    /// away.
+    /// or can panic (`/`, `%`).
+    ///
+    /// Known safe built-in types like `Wrapping` or `Saturing`, floats, operations in constant
+    /// environments, allowed types and non-constant operations that won't overflow are ignored.
     ///
     /// ### Why is this bad?
-    /// Integer overflow will trigger a panic in debug builds or will wrap in
-    /// release mode. Division by zero will cause a panic in either mode. In some applications one
-    /// wants explicitly checked, wrapping or saturating arithmetic.
+    /// For integers, overflow will trigger a panic in debug builds or wrap the result in
+    /// release mode; division by zero will cause a panic in either mode. As a result, it is
+    /// desirable to explicitly call checked, wrapping or saturating arithmetic methods.
     ///
     /// #### Example
     /// ```rust
-    /// # let a = 0;
-    /// a + 1;
+    /// // `n` can be any number, including `i32::MAX`.
+    /// fn foo(n: i32) -> i32 {
+    ///   n + 1
+    /// }
     /// ```
     ///
-    /// Third-party types also tend to overflow.
+    /// Third-party types can also overflow or present unwanted side-effects.
     ///
     /// #### Example
     /// ```ignore,rust
diff --git a/src/docs/arithmetic.txt b/src/docs/arithmetic.txt
index 0b3f07d9505..f04125060fb 100644
--- a/src/docs/arithmetic.txt
+++ b/src/docs/arithmetic.txt
@@ -1,22 +1,27 @@
 ### What it does
-Checks for any kind of arithmetic operation of any type.
+Checks any kind of arithmetic operation of any type.
 
 Operators like `+`, `-`, `*` or `<<` are usually capable of overflowing according to the [Rust
 Reference](https://doc.rust-lang.org/reference/expressions/operator-expr.html#overflow),
-or can panic (`/`, `%`). Known safe built-in types like `Wrapping` or `Saturing` are filtered
-away.
+or can panic (`/`, `%`).
+
+Known safe built-in types like `Wrapping` or `Saturing`, floats, operations in constant
+environments, allowed types and non-constant operations that won't overflow are ignored.
 
 ### Why is this bad?
-Integer overflow will trigger a panic in debug builds or will wrap in
-release mode. Division by zero will cause a panic in either mode. In some applications one
-wants explicitly checked, wrapping or saturating arithmetic.
+For integers, overflow will trigger a panic in debug builds or wrap the result in
+release mode; division by zero will cause a panic in either mode. As a result, it is
+desirable to explicitly call checked, wrapping or saturating arithmetic methods.
 
 #### Example
 ```
-a + 1;
+// `n` can be any number, including `i32::MAX`.
+fn foo(n: i32) -> i32 {
+  n + 1
+}
 ```
 
-Third-party types also tend to overflow.
+Third-party types can also overflow or present unwanted side-effects.
 
 #### Example
 ```
diff --git a/tests/ui/arithmetic.fixed b/tests/ui/arithmetic.fixed
deleted file mode 100644
index a2a1c4394c2..00000000000
--- a/tests/ui/arithmetic.fixed
+++ /dev/null
@@ -1,27 +0,0 @@
-// run-rustfix
-
-#![allow(clippy::unnecessary_owned_empty_strings)]
-#![feature(saturating_int_impl)]
-#![warn(clippy::arithmetic)]
-
-use core::num::{Saturating, Wrapping};
-
-pub fn hard_coded_allowed() {
-    let _ = Saturating(0u32) + Saturating(0u32);
-    let _ = String::new() + "";
-    let _ = Wrapping(0u32) + Wrapping(0u32);
-
-    let saturating: Saturating<u32> = Saturating(0u32);
-    let string: String = String::new();
-    let wrapping: Wrapping<u32> = Wrapping(0u32);
-
-    let inferred_saturating = saturating + saturating;
-    let inferred_string = string + "";
-    let inferred_wrapping = wrapping + wrapping;
-
-    let _ = inferred_saturating + inferred_saturating;
-    let _ = inferred_string + "";
-    let _ = inferred_wrapping + inferred_wrapping;
-}
-
-fn main() {}
diff --git a/tests/ui/arithmetic.rs b/tests/ui/arithmetic.rs
index a2a1c4394c2..a9ac46e9a19 100644
--- a/tests/ui/arithmetic.rs
+++ b/tests/ui/arithmetic.rs
@@ -1,12 +1,13 @@
-// run-rustfix
-
-#![allow(clippy::unnecessary_owned_empty_strings)]
-#![feature(saturating_int_impl)]
+#![allow(clippy::assign_op_pattern, clippy::unnecessary_owned_empty_strings)]
+#![feature(inline_const, saturating_int_impl)]
 #![warn(clippy::arithmetic)]
 
 use core::num::{Saturating, Wrapping};
 
 pub fn hard_coded_allowed() {
+    let _ = 1f32 + 1f32;
+    let _ = 1f64 + 1f64;
+
     let _ = Saturating(0u32) + Saturating(0u32);
     let _ = String::new() + "";
     let _ = Wrapping(0u32) + Wrapping(0u32);
@@ -24,4 +25,33 @@ pub fn hard_coded_allowed() {
     let _ = inferred_wrapping + inferred_wrapping;
 }
 
+#[rustfmt::skip]
+pub fn non_overflowing_ops() {
+    const _: i32 = { let mut n = 1; n += 1; n };
+    let _ = const { let mut n = 1; n += 1; n };
+
+    const _: i32 = { let mut n = 1; n = n + 1; n };
+    let _ = const { let mut n = 1; n = n + 1; n };
+
+    const _: i32 = { let mut n = 1; n = 1 + n; n };
+    let _ = const { let mut n = 1; n = 1 + n; n };
+
+    const _: i32 = 1 + 1;
+    let _ = 1 + 1;
+    let _ = const { 1 + 1 };
+
+    let mut _a = 1;
+    _a *= 1;
+    _a /= 1;
+}
+
+#[rustfmt::skip]
+pub fn overflowing_ops() {
+    let mut _a = 1; _a += 1;
+
+    let mut _b = 1; _b = _b + 1;
+
+    let mut _c = 1; _c = 1 + _c;
+}
+
 fn main() {}
diff --git a/tests/ui/arithmetic.stderr b/tests/ui/arithmetic.stderr
new file mode 100644
index 00000000000..a51cf6ba600
--- /dev/null
+++ b/tests/ui/arithmetic.stderr
@@ -0,0 +1,22 @@
+error: arithmetic detected
+  --> $DIR/arithmetic.rs:50:21
+   |
+LL |     let mut _a = 1; _a += 1;
+   |                     ^^^^^^^
+   |
+   = note: `-D clippy::arithmetic` implied by `-D warnings`
+
+error: arithmetic detected
+  --> $DIR/arithmetic.rs:52:26
+   |
+LL |     let mut _b = 1; _b = _b + 1;
+   |                          ^^^^^^
+
+error: arithmetic detected
+  --> $DIR/arithmetic.rs:54:26
+   |
+LL |     let mut _c = 1; _c = 1 + _c;
+   |                          ^^^^^^
+
+error: aborting due to 3 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 15859323ea424b4fb9556d9d45c8b5d374e57f9e Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Wed, 7 Sep 2022 15:26:44 -0400
Subject: Fix hang in `vec_init_then_push`

---
 clippy_lints/src/vec_init_then_push.rs | 2 +-
 tests/ui/vec_init_then_push.rs         | 6 ++++++
 tests/ui/vec_init_then_push.stderr     | 9 ++++++++-
 3 files changed, 15 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/vec_init_then_push.rs b/clippy_lints/src/vec_init_then_push.rs
index 35db45e2b0c..d77a21d668e 100644
--- a/clippy_lints/src/vec_init_then_push.rs
+++ b/clippy_lints/src/vec_init_then_push.rs
@@ -86,7 +86,7 @@ impl VecPushSearcher {
                 },
                 ExprKind::Unary(UnOp::Deref, _) | ExprKind::Index(..) if !needs_mut => {
                     let mut last_place = parent;
-                    while let Some(parent) = get_parent_expr(cx, parent) {
+                    while let Some(parent) = get_parent_expr(cx, last_place) {
                         if matches!(parent.kind, ExprKind::Unary(UnOp::Deref, _) | ExprKind::Field(..))
                             || matches!(parent.kind, ExprKind::Index(e, _) if e.hir_id == last_place.hir_id)
                         {
diff --git a/tests/ui/vec_init_then_push.rs b/tests/ui/vec_init_then_push.rs
index 531745424a7..8dd098a5b54 100644
--- a/tests/ui/vec_init_then_push.rs
+++ b/tests/ui/vec_init_then_push.rs
@@ -104,3 +104,9 @@ fn _cond_push_with_large_start(x: bool) -> Vec<u32> {
 
     v2
 }
+
+fn f() {
+    let mut v = Vec::new();
+    v.push((0i32, 0i32));
+    let y = v[0].0.abs();
+}
diff --git a/tests/ui/vec_init_then_push.stderr b/tests/ui/vec_init_then_push.stderr
index 50b029fc337..a9da1c52019 100644
--- a/tests/ui/vec_init_then_push.stderr
+++ b/tests/ui/vec_init_then_push.stderr
@@ -62,5 +62,12 @@ LL | |     v2.push(1);
 LL | |     v2.push(0);
    | |_______________^ help: consider using the `vec![]` macro: `let mut v2 = vec![..];`
 
-error: aborting due to 7 previous errors
+error: calls to `push` immediately after creation
+  --> $DIR/vec_init_then_push.rs:109:5
+   |
+LL | /     let mut v = Vec::new();
+LL | |     v.push((0i32, 0i32));
+   | |_________________________^ help: consider using the `vec![]` macro: `let v = vec![..];`
+
+error: aborting due to 8 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 51d8b6c6643abb048987bd0befdeb6f46db0f6b5 Mon Sep 17 00:00:00 2001
From: Caio <c410.f3r@gmail.com>
Date: Thu, 8 Sep 2022 12:04:55 -0300
Subject: Rename the `arithmetic` lint

---
 CHANGELOG.md                                       |   2 +-
 clippy_lints/src/lib.register_lints.rs             |   2 +-
 clippy_lints/src/lib.register_restriction.rs       |   2 +-
 clippy_lints/src/lib.rs                            |   8 +-
 clippy_lints/src/operators/arithmetic.rs           | 173 ---------------------
 .../src/operators/arithmetic_side_effects.rs       | 173 +++++++++++++++++++++
 clippy_lints/src/operators/mod.rs                  |  10 +-
 clippy_lints/src/utils/conf.rs                     |   2 +-
 src/docs.rs                                        |   2 +-
 src/docs/arithmetic.txt                            |  33 ----
 src/docs/arithmetic_side_effects.txt               |  33 ++++
 .../arithmetic_allowed/arithmetic_allowed.rs       |  24 ---
 tests/ui-toml/arithmetic_allowed/clippy.toml       |   1 -
 .../arithmetic_side_effects_allowed.rs             |  24 +++
 .../arithmetic_side_effects_allowed/clippy.toml    |   1 +
 .../toml_unknown_key/conf_unknown_key.stderr       |   2 +-
 tests/ui/arithmetic.rs                             |  57 -------
 tests/ui/arithmetic.stderr                         |  22 ---
 tests/ui/arithmetic_side_effects.rs                |  57 +++++++
 tests/ui/arithmetic_side_effects.stderr            |  22 +++
 20 files changed, 327 insertions(+), 323 deletions(-)
 delete mode 100644 clippy_lints/src/operators/arithmetic.rs
 create mode 100644 clippy_lints/src/operators/arithmetic_side_effects.rs
 delete mode 100644 src/docs/arithmetic.txt
 create mode 100644 src/docs/arithmetic_side_effects.txt
 delete mode 100644 tests/ui-toml/arithmetic_allowed/arithmetic_allowed.rs
 delete mode 100644 tests/ui-toml/arithmetic_allowed/clippy.toml
 create mode 100644 tests/ui-toml/arithmetic_side_effects_allowed/arithmetic_side_effects_allowed.rs
 create mode 100644 tests/ui-toml/arithmetic_side_effects_allowed/clippy.toml
 delete mode 100644 tests/ui/arithmetic.rs
 delete mode 100644 tests/ui/arithmetic.stderr
 create mode 100644 tests/ui/arithmetic_side_effects.rs
 create mode 100644 tests/ui/arithmetic_side_effects.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 257add86b6e..d847e4c7494 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3583,7 +3583,7 @@ Released 2018-09-13
 [`almost_complete_letter_range`]: https://rust-lang.github.io/rust-clippy/master/index.html#almost_complete_letter_range
 [`almost_swapped`]: https://rust-lang.github.io/rust-clippy/master/index.html#almost_swapped
 [`approx_constant`]: https://rust-lang.github.io/rust-clippy/master/index.html#approx_constant
-[`arithmetic`]: https://rust-lang.github.io/rust-clippy/master/index.html#arithmetic
+[`arithmetic_side_effects`]: https://rust-lang.github.io/rust-clippy/master/index.html#arithmetic_side_effects
 [`as_conversions`]: https://rust-lang.github.io/rust-clippy/master/index.html#as_conversions
 [`as_underscore`]: https://rust-lang.github.io/rust-clippy/master/index.html#as_underscore
 [`assertions_on_constants`]: https://rust-lang.github.io/rust-clippy/master/index.html#assertions_on_constants
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 13b573beea1..962e6722006 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -437,7 +437,7 @@ store.register_lints(&[
     octal_escapes::OCTAL_ESCAPES,
     only_used_in_recursion::ONLY_USED_IN_RECURSION,
     operators::ABSURD_EXTREME_COMPARISONS,
-    operators::ARITHMETIC,
+    operators::ARITHMETIC_SIDE_EFFECTS,
     operators::ASSIGN_OP_PATTERN,
     operators::BAD_BIT_MASK,
     operators::CMP_NAN,
diff --git a/clippy_lints/src/lib.register_restriction.rs b/clippy_lints/src/lib.register_restriction.rs
index dd1e1e1a8e3..6eb9b3d3b9b 100644
--- a/clippy_lints/src/lib.register_restriction.rs
+++ b/clippy_lints/src/lib.register_restriction.rs
@@ -50,7 +50,7 @@ store.register_group(true, "clippy::restriction", Some("clippy_restriction"), ve
     LintId::of(mixed_read_write_in_expression::MIXED_READ_WRITE_IN_EXPRESSION),
     LintId::of(module_style::MOD_MODULE_FILES),
     LintId::of(module_style::SELF_NAMED_MODULE_FILES),
-    LintId::of(operators::ARITHMETIC),
+    LintId::of(operators::ARITHMETIC_SIDE_EFFECTS),
     LintId::of(operators::FLOAT_ARITHMETIC),
     LintId::of(operators::FLOAT_CMP_CONST),
     LintId::of(operators::INTEGER_ARITHMETIC),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index a26e129f094..7633bf347c3 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -544,8 +544,12 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         store.register_late_pass(|| Box::new(utils::internal_lints::MsrvAttrImpl));
     }
 
-    let arithmetic_allowed = conf.arithmetic_allowed.clone();
-    store.register_late_pass(move || Box::new(operators::arithmetic::Arithmetic::new(arithmetic_allowed.clone())));
+    let arithmetic_side_effects_allowed = conf.arithmetic_side_effects_allowed.clone();
+    store.register_late_pass(move || {
+        Box::new(operators::arithmetic_side_effects::ArithmeticSideEffects::new(
+            arithmetic_side_effects_allowed.clone(),
+        ))
+    });
     store.register_late_pass(|| Box::new(utils::dump_hir::DumpHir));
     store.register_late_pass(|| Box::new(utils::author::Author));
     let await_holding_invalid_types = conf.await_holding_invalid_types.clone();
diff --git a/clippy_lints/src/operators/arithmetic.rs b/clippy_lints/src/operators/arithmetic.rs
deleted file mode 100644
index 27eef92deef..00000000000
--- a/clippy_lints/src/operators/arithmetic.rs
+++ /dev/null
@@ -1,173 +0,0 @@
-#![allow(
-    // False positive
-    clippy::match_same_arms
-)]
-
-use super::ARITHMETIC;
-use clippy_utils::{consts::constant_simple, diagnostics::span_lint};
-use rustc_ast as ast;
-use rustc_data_structures::fx::FxHashSet;
-use rustc_hir as hir;
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty::Ty;
-use rustc_session::impl_lint_pass;
-use rustc_span::source_map::{Span, Spanned};
-
-const HARD_CODED_ALLOWED: &[&str] = &[
-    "f32",
-    "f64",
-    "std::num::Saturating",
-    "std::string::String",
-    "std::num::Wrapping",
-];
-
-#[derive(Debug)]
-pub struct Arithmetic {
-    allowed: FxHashSet<String>,
-    // Used to check whether expressions are constants, such as in enum discriminants and consts
-    const_span: Option<Span>,
-    expr_span: Option<Span>,
-}
-
-impl_lint_pass!(Arithmetic => [ARITHMETIC]);
-
-impl Arithmetic {
-    #[must_use]
-    pub fn new(mut allowed: FxHashSet<String>) -> Self {
-        allowed.extend(HARD_CODED_ALLOWED.iter().copied().map(String::from));
-        Self {
-            allowed,
-            const_span: None,
-            expr_span: None,
-        }
-    }
-
-    /// Checks assign operators (+=, -=, *=, /=) of integers in a non-constant environment that
-    /// won't overflow.
-    fn has_valid_assign_op(op: &Spanned<hir::BinOpKind>, rhs: &hir::Expr<'_>, rhs_refs: Ty<'_>) -> bool {
-        if !Self::is_literal_integer(rhs, rhs_refs) {
-            return false;
-        }
-        if let hir::BinOpKind::Div | hir::BinOpKind::Mul = op.node
-            && let hir::ExprKind::Lit(ref lit) = rhs.kind
-            && let ast::LitKind::Int(1, _) = lit.node
-        {
-            return true;
-        }
-        false
-    }
-
-    /// Checks "raw" binary operators (+, -, *, /) of integers in a non-constant environment
-    /// already handled by the CTFE.
-    fn has_valid_bin_op(lhs: &hir::Expr<'_>, lhs_refs: Ty<'_>, rhs: &hir::Expr<'_>, rhs_refs: Ty<'_>) -> bool {
-        Self::is_literal_integer(lhs, lhs_refs) && Self::is_literal_integer(rhs, rhs_refs)
-    }
-
-    /// Checks if the given `expr` has any of the inner `allowed` elements.
-    fn is_allowed_ty(&self, cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> bool {
-        self.allowed.contains(
-            cx.typeck_results()
-                .expr_ty(expr)
-                .to_string()
-                .split('<')
-                .next()
-                .unwrap_or_default(),
-        )
-    }
-
-    /// Explicit integers like `1` or `i32::MAX`. Does not take into consideration references.
-    fn is_literal_integer(expr: &hir::Expr<'_>, expr_refs: Ty<'_>) -> bool {
-        let is_integral = expr_refs.is_integral();
-        let is_literal = matches!(expr.kind, hir::ExprKind::Lit(_));
-        is_integral && is_literal
-    }
-
-    fn issue_lint(&mut self, cx: &LateContext<'_>, expr: &hir::Expr<'_>) {
-        span_lint(cx, ARITHMETIC, expr.span, "arithmetic detected");
-        self.expr_span = Some(expr.span);
-    }
-
-    /// Manages when the lint should be triggered. Operations in constant environments, hard coded
-    /// types, custom allowed types and non-constant operations that won't overflow are ignored.
-    fn manage_bin_ops(
-        &mut self,
-        cx: &LateContext<'_>,
-        expr: &hir::Expr<'_>,
-        op: &Spanned<hir::BinOpKind>,
-        lhs: &hir::Expr<'_>,
-        rhs: &hir::Expr<'_>,
-    ) {
-        if constant_simple(cx, cx.typeck_results(), expr).is_some() {
-            return;
-        }
-        if !matches!(
-            op.node,
-            hir::BinOpKind::Add
-                | hir::BinOpKind::Sub
-                | hir::BinOpKind::Mul
-                | hir::BinOpKind::Div
-                | hir::BinOpKind::Rem
-                | hir::BinOpKind::Shl
-                | hir::BinOpKind::Shr
-        ) {
-            return;
-        };
-        if self.is_allowed_ty(cx, lhs) || self.is_allowed_ty(cx, rhs) {
-            return;
-        }
-        let lhs_refs = cx.typeck_results().expr_ty(lhs).peel_refs();
-        let rhs_refs = cx.typeck_results().expr_ty(rhs).peel_refs();
-        let has_valid_assign_op = Self::has_valid_assign_op(op, rhs, rhs_refs);
-        if has_valid_assign_op || Self::has_valid_bin_op(lhs, lhs_refs, rhs, rhs_refs) {
-            return;
-        }
-        self.issue_lint(cx, expr);
-    }
-}
-
-impl<'tcx> LateLintPass<'tcx> for Arithmetic {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
-        if self.expr_span.is_some() || self.const_span.map_or(false, |sp| sp.contains(expr.span)) {
-            return;
-        }
-        match &expr.kind {
-            hir::ExprKind::Binary(op, lhs, rhs) | hir::ExprKind::AssignOp(op, lhs, rhs) => {
-                self.manage_bin_ops(cx, expr, op, lhs, rhs);
-            },
-            hir::ExprKind::Unary(hir::UnOp::Neg, _) => {
-                if constant_simple(cx, cx.typeck_results(), expr).is_none() {
-                    self.issue_lint(cx, expr);
-                }
-            },
-            _ => {},
-        }
-    }
-
-    fn check_body(&mut self, cx: &LateContext<'_>, body: &hir::Body<'_>) {
-        let body_owner = cx.tcx.hir().body_owner(body.id());
-        let body_owner_def_id = cx.tcx.hir().local_def_id(body_owner);
-        let body_owner_kind = cx.tcx.hir().body_owner_kind(body_owner_def_id);
-        if let hir::BodyOwnerKind::Const | hir::BodyOwnerKind::Static(_) = body_owner_kind {
-            let body_span = cx.tcx.hir().span_with_body(body_owner);
-            if let Some(span) = self.const_span && span.contains(body_span) {
-                return;
-            }
-            self.const_span = Some(body_span);
-        }
-    }
-
-    fn check_body_post(&mut self, cx: &LateContext<'_>, body: &hir::Body<'_>) {
-        let body_owner = cx.tcx.hir().body_owner(body.id());
-        let body_span = cx.tcx.hir().span(body_owner);
-        if let Some(span) = self.const_span && span.contains(body_span) {
-            return;
-        }
-        self.const_span = None;
-    }
-
-    fn check_expr_post(&mut self, _: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
-        if Some(expr.span) == self.expr_span {
-            self.expr_span = None;
-        }
-    }
-}
diff --git a/clippy_lints/src/operators/arithmetic_side_effects.rs b/clippy_lints/src/operators/arithmetic_side_effects.rs
new file mode 100644
index 00000000000..83b69fbb311
--- /dev/null
+++ b/clippy_lints/src/operators/arithmetic_side_effects.rs
@@ -0,0 +1,173 @@
+#![allow(
+    // False positive
+    clippy::match_same_arms
+)]
+
+use super::ARITHMETIC_SIDE_EFFECTS;
+use clippy_utils::{consts::constant_simple, diagnostics::span_lint};
+use rustc_ast as ast;
+use rustc_data_structures::fx::FxHashSet;
+use rustc_hir as hir;
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::Ty;
+use rustc_session::impl_lint_pass;
+use rustc_span::source_map::{Span, Spanned};
+
+const HARD_CODED_ALLOWED: &[&str] = &[
+    "f32",
+    "f64",
+    "std::num::Saturating",
+    "std::string::String",
+    "std::num::Wrapping",
+];
+
+#[derive(Debug)]
+pub struct ArithmeticSideEffects {
+    allowed: FxHashSet<String>,
+    // Used to check whether expressions are constants, such as in enum discriminants and consts
+    const_span: Option<Span>,
+    expr_span: Option<Span>,
+}
+
+impl_lint_pass!(ArithmeticSideEffects => [ARITHMETIC_SIDE_EFFECTS]);
+
+impl ArithmeticSideEffects {
+    #[must_use]
+    pub fn new(mut allowed: FxHashSet<String>) -> Self {
+        allowed.extend(HARD_CODED_ALLOWED.iter().copied().map(String::from));
+        Self {
+            allowed,
+            const_span: None,
+            expr_span: None,
+        }
+    }
+
+    /// Checks assign operators (+=, -=, *=, /=) of integers in a non-constant environment that
+    /// won't overflow.
+    fn has_valid_assign_op(op: &Spanned<hir::BinOpKind>, rhs: &hir::Expr<'_>, rhs_refs: Ty<'_>) -> bool {
+        if !Self::is_literal_integer(rhs, rhs_refs) {
+            return false;
+        }
+        if let hir::BinOpKind::Div | hir::BinOpKind::Mul = op.node
+            && let hir::ExprKind::Lit(ref lit) = rhs.kind
+            && let ast::LitKind::Int(1, _) = lit.node
+        {
+            return true;
+        }
+        false
+    }
+
+    /// Checks "raw" binary operators (+, -, *, /) of integers in a non-constant environment
+    /// already handled by the CTFE.
+    fn has_valid_bin_op(lhs: &hir::Expr<'_>, lhs_refs: Ty<'_>, rhs: &hir::Expr<'_>, rhs_refs: Ty<'_>) -> bool {
+        Self::is_literal_integer(lhs, lhs_refs) && Self::is_literal_integer(rhs, rhs_refs)
+    }
+
+    /// Checks if the given `expr` has any of the inner `allowed` elements.
+    fn is_allowed_ty(&self, cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> bool {
+        self.allowed.contains(
+            cx.typeck_results()
+                .expr_ty(expr)
+                .to_string()
+                .split('<')
+                .next()
+                .unwrap_or_default(),
+        )
+    }
+
+    /// Explicit integers like `1` or `i32::MAX`. Does not take into consideration references.
+    fn is_literal_integer(expr: &hir::Expr<'_>, expr_refs: Ty<'_>) -> bool {
+        let is_integral = expr_refs.is_integral();
+        let is_literal = matches!(expr.kind, hir::ExprKind::Lit(_));
+        is_integral && is_literal
+    }
+
+    fn issue_lint(&mut self, cx: &LateContext<'_>, expr: &hir::Expr<'_>) {
+        span_lint(cx, ARITHMETIC_SIDE_EFFECTS, expr.span, "arithmetic detected");
+        self.expr_span = Some(expr.span);
+    }
+
+    /// Manages when the lint should be triggered. Operations in constant environments, hard coded
+    /// types, custom allowed types and non-constant operations that won't overflow are ignored.
+    fn manage_bin_ops(
+        &mut self,
+        cx: &LateContext<'_>,
+        expr: &hir::Expr<'_>,
+        op: &Spanned<hir::BinOpKind>,
+        lhs: &hir::Expr<'_>,
+        rhs: &hir::Expr<'_>,
+    ) {
+        if constant_simple(cx, cx.typeck_results(), expr).is_some() {
+            return;
+        }
+        if !matches!(
+            op.node,
+            hir::BinOpKind::Add
+                | hir::BinOpKind::Sub
+                | hir::BinOpKind::Mul
+                | hir::BinOpKind::Div
+                | hir::BinOpKind::Rem
+                | hir::BinOpKind::Shl
+                | hir::BinOpKind::Shr
+        ) {
+            return;
+        };
+        if self.is_allowed_ty(cx, lhs) || self.is_allowed_ty(cx, rhs) {
+            return;
+        }
+        let lhs_refs = cx.typeck_results().expr_ty(lhs).peel_refs();
+        let rhs_refs = cx.typeck_results().expr_ty(rhs).peel_refs();
+        let has_valid_assign_op = Self::has_valid_assign_op(op, rhs, rhs_refs);
+        if has_valid_assign_op || Self::has_valid_bin_op(lhs, lhs_refs, rhs, rhs_refs) {
+            return;
+        }
+        self.issue_lint(cx, expr);
+    }
+}
+
+impl<'tcx> LateLintPass<'tcx> for ArithmeticSideEffects {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
+        if self.expr_span.is_some() || self.const_span.map_or(false, |sp| sp.contains(expr.span)) {
+            return;
+        }
+        match &expr.kind {
+            hir::ExprKind::Binary(op, lhs, rhs) | hir::ExprKind::AssignOp(op, lhs, rhs) => {
+                self.manage_bin_ops(cx, expr, op, lhs, rhs);
+            },
+            hir::ExprKind::Unary(hir::UnOp::Neg, _) => {
+                if constant_simple(cx, cx.typeck_results(), expr).is_none() {
+                    self.issue_lint(cx, expr);
+                }
+            },
+            _ => {},
+        }
+    }
+
+    fn check_body(&mut self, cx: &LateContext<'_>, body: &hir::Body<'_>) {
+        let body_owner = cx.tcx.hir().body_owner(body.id());
+        let body_owner_def_id = cx.tcx.hir().local_def_id(body_owner);
+        let body_owner_kind = cx.tcx.hir().body_owner_kind(body_owner_def_id);
+        if let hir::BodyOwnerKind::Const | hir::BodyOwnerKind::Static(_) = body_owner_kind {
+            let body_span = cx.tcx.hir().span_with_body(body_owner);
+            if let Some(span) = self.const_span && span.contains(body_span) {
+                return;
+            }
+            self.const_span = Some(body_span);
+        }
+    }
+
+    fn check_body_post(&mut self, cx: &LateContext<'_>, body: &hir::Body<'_>) {
+        let body_owner = cx.tcx.hir().body_owner(body.id());
+        let body_span = cx.tcx.hir().span(body_owner);
+        if let Some(span) = self.const_span && span.contains(body_span) {
+            return;
+        }
+        self.const_span = None;
+    }
+
+    fn check_expr_post(&mut self, _: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
+        if Some(expr.span) == self.expr_span {
+            self.expr_span = None;
+        }
+    }
+}
diff --git a/clippy_lints/src/operators/mod.rs b/clippy_lints/src/operators/mod.rs
index c7b0633b79c..c32b4df4f75 100644
--- a/clippy_lints/src/operators/mod.rs
+++ b/clippy_lints/src/operators/mod.rs
@@ -21,7 +21,7 @@ mod ptr_eq;
 mod self_assignment;
 mod verbose_bit_mask;
 
-pub(crate) mod arithmetic;
+pub(crate) mod arithmetic_side_effects;
 
 use rustc_hir::{Body, Expr, ExprKind, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
@@ -92,11 +92,11 @@ declare_clippy_lint! {
     /// ```
     ///
     /// ### Allowed types
-    /// Custom allowed types can be specified through the "arithmetic-allowed" filter.
+    /// Custom allowed types can be specified through the "arithmetic-side-effects-allowed" filter.
     #[clippy::version = "1.64.0"]
-    pub ARITHMETIC,
+    pub ARITHMETIC_SIDE_EFFECTS,
     restriction,
-    "any arithmetic expression that could overflow or panic"
+    "any arithmetic expression that can cause side effects like overflows or panics"
 }
 
 declare_clippy_lint! {
@@ -789,7 +789,7 @@ pub struct Operators {
 }
 impl_lint_pass!(Operators => [
     ABSURD_EXTREME_COMPARISONS,
-    ARITHMETIC,
+    ARITHMETIC_SIDE_EFFECTS,
     INTEGER_ARITHMETIC,
     FLOAT_ARITHMETIC,
     ASSIGN_OP_PATTERN,
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 84e65d5fa0b..a8500beb257 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -208,7 +208,7 @@ define_Conf! {
     /// Lint: Arithmetic.
     ///
     /// Suppress checking of the passed type names.
-    (arithmetic_allowed: rustc_data_structures::fx::FxHashSet<String> = <_>::default()),
+    (arithmetic_side_effects_allowed: rustc_data_structures::fx::FxHashSet<String> = <_>::default()),
     /// Lint: ENUM_VARIANT_NAMES, LARGE_TYPES_PASSED_BY_VALUE, TRIVIALLY_COPY_PASS_BY_REF, UNNECESSARY_WRAPS, UNUSED_SELF, UPPER_CASE_ACRONYMS, WRONG_SELF_CONVENTION, BOX_COLLECTION, REDUNDANT_ALLOCATION, RC_BUFFER, VEC_BOX, OPTION_OPTION, LINKEDLIST, RC_MUTEX.
     ///
     /// Suppress lints whenever the suggested change would cause breakage for other crates.
diff --git a/src/docs.rs b/src/docs.rs
index 69243bf4d9c..f3a5048e7fa 100644
--- a/src/docs.rs
+++ b/src/docs.rs
@@ -26,7 +26,7 @@ docs! {
     "almost_complete_letter_range",
     "almost_swapped",
     "approx_constant",
-    "arithmetic",
+    "arithmetic_side_effects",
     "as_conversions",
     "as_underscore",
     "assertions_on_constants",
diff --git a/src/docs/arithmetic.txt b/src/docs/arithmetic.txt
deleted file mode 100644
index f04125060fb..00000000000
--- a/src/docs/arithmetic.txt
+++ /dev/null
@@ -1,33 +0,0 @@
-### What it does
-Checks any kind of arithmetic operation of any type.
-
-Operators like `+`, `-`, `*` or `<<` are usually capable of overflowing according to the [Rust
-Reference](https://doc.rust-lang.org/reference/expressions/operator-expr.html#overflow),
-or can panic (`/`, `%`).
-
-Known safe built-in types like `Wrapping` or `Saturing`, floats, operations in constant
-environments, allowed types and non-constant operations that won't overflow are ignored.
-
-### Why is this bad?
-For integers, overflow will trigger a panic in debug builds or wrap the result in
-release mode; division by zero will cause a panic in either mode. As a result, it is
-desirable to explicitly call checked, wrapping or saturating arithmetic methods.
-
-#### Example
-```
-// `n` can be any number, including `i32::MAX`.
-fn foo(n: i32) -> i32 {
-  n + 1
-}
-```
-
-Third-party types can also overflow or present unwanted side-effects.
-
-#### Example
-```
-use rust_decimal::Decimal;
-let _n = Decimal::MAX + Decimal::MAX;
-```
-
-### Allowed types
-Custom allowed types can be specified through the "arithmetic-allowed" filter.
\ No newline at end of file
diff --git a/src/docs/arithmetic_side_effects.txt b/src/docs/arithmetic_side_effects.txt
new file mode 100644
index 00000000000..6c7d51a4989
--- /dev/null
+++ b/src/docs/arithmetic_side_effects.txt
@@ -0,0 +1,33 @@
+### What it does
+Checks any kind of arithmetic operation of any type.
+
+Operators like `+`, `-`, `*` or `<<` are usually capable of overflowing according to the [Rust
+Reference](https://doc.rust-lang.org/reference/expressions/operator-expr.html#overflow),
+or can panic (`/`, `%`).
+
+Known safe built-in types like `Wrapping` or `Saturing`, floats, operations in constant
+environments, allowed types and non-constant operations that won't overflow are ignored.
+
+### Why is this bad?
+For integers, overflow will trigger a panic in debug builds or wrap the result in
+release mode; division by zero will cause a panic in either mode. As a result, it is
+desirable to explicitly call checked, wrapping or saturating arithmetic methods.
+
+#### Example
+```
+// `n` can be any number, including `i32::MAX`.
+fn foo(n: i32) -> i32 {
+  n + 1
+}
+```
+
+Third-party types can also overflow or present unwanted side-effects.
+
+#### Example
+```
+use rust_decimal::Decimal;
+let _n = Decimal::MAX + Decimal::MAX;
+```
+
+### Allowed types
+Custom allowed types can be specified through the "arithmetic-side-effects-allowed" filter.
\ No newline at end of file
diff --git a/tests/ui-toml/arithmetic_allowed/arithmetic_allowed.rs b/tests/ui-toml/arithmetic_allowed/arithmetic_allowed.rs
deleted file mode 100644
index 195fabdbf71..00000000000
--- a/tests/ui-toml/arithmetic_allowed/arithmetic_allowed.rs
+++ /dev/null
@@ -1,24 +0,0 @@
-#![warn(clippy::arithmetic)]
-
-use core::ops::Add;
-
-#[derive(Clone, Copy)]
-struct Point {
-    x: i32,
-    y: i32,
-}
-
-impl Add for Point {
-    type Output = Self;
-
-    fn add(self, other: Self) -> Self {
-        todo!()
-    }
-}
-
-fn main() {
-    let _ = Point { x: 1, y: 0 } + Point { x: 2, y: 3 };
-
-    let point: Point = Point { x: 1, y: 0 };
-    let _ = point + point;
-}
diff --git a/tests/ui-toml/arithmetic_allowed/clippy.toml b/tests/ui-toml/arithmetic_allowed/clippy.toml
deleted file mode 100644
index cc40570b12a..00000000000
--- a/tests/ui-toml/arithmetic_allowed/clippy.toml
+++ /dev/null
@@ -1 +0,0 @@
-arithmetic-allowed = ["Point"]
diff --git a/tests/ui-toml/arithmetic_side_effects_allowed/arithmetic_side_effects_allowed.rs b/tests/ui-toml/arithmetic_side_effects_allowed/arithmetic_side_effects_allowed.rs
new file mode 100644
index 00000000000..1aed09b7c7b
--- /dev/null
+++ b/tests/ui-toml/arithmetic_side_effects_allowed/arithmetic_side_effects_allowed.rs
@@ -0,0 +1,24 @@
+#![warn(clippy::arithmetic_side_effects)]
+
+use core::ops::Add;
+
+#[derive(Clone, Copy)]
+struct Point {
+    x: i32,
+    y: i32,
+}
+
+impl Add for Point {
+    type Output = Self;
+
+    fn add(self, other: Self) -> Self {
+        todo!()
+    }
+}
+
+fn main() {
+    let _ = Point { x: 1, y: 0 } + Point { x: 2, y: 3 };
+
+    let point: Point = Point { x: 1, y: 0 };
+    let _ = point + point;
+}
diff --git a/tests/ui-toml/arithmetic_side_effects_allowed/clippy.toml b/tests/ui-toml/arithmetic_side_effects_allowed/clippy.toml
new file mode 100644
index 00000000000..e736256f29a
--- /dev/null
+++ b/tests/ui-toml/arithmetic_side_effects_allowed/clippy.toml
@@ -0,0 +1 @@
+arithmetic-side-effects-allowed = ["Point"]
diff --git a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
index a52a0b5289f..f27f78d15d3 100644
--- a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
+++ b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
@@ -3,7 +3,7 @@ error: error reading Clippy's configuration file `$DIR/clippy.toml`: unknown fie
            allow-expect-in-tests
            allow-unwrap-in-tests
            allowed-scripts
-           arithmetic-allowed
+           arithmetic-side-effects-allowed
            array-size-threshold
            avoid-breaking-exported-api
            await-holding-invalid-types
diff --git a/tests/ui/arithmetic.rs b/tests/ui/arithmetic.rs
deleted file mode 100644
index a9ac46e9a19..00000000000
--- a/tests/ui/arithmetic.rs
+++ /dev/null
@@ -1,57 +0,0 @@
-#![allow(clippy::assign_op_pattern, clippy::unnecessary_owned_empty_strings)]
-#![feature(inline_const, saturating_int_impl)]
-#![warn(clippy::arithmetic)]
-
-use core::num::{Saturating, Wrapping};
-
-pub fn hard_coded_allowed() {
-    let _ = 1f32 + 1f32;
-    let _ = 1f64 + 1f64;
-
-    let _ = Saturating(0u32) + Saturating(0u32);
-    let _ = String::new() + "";
-    let _ = Wrapping(0u32) + Wrapping(0u32);
-
-    let saturating: Saturating<u32> = Saturating(0u32);
-    let string: String = String::new();
-    let wrapping: Wrapping<u32> = Wrapping(0u32);
-
-    let inferred_saturating = saturating + saturating;
-    let inferred_string = string + "";
-    let inferred_wrapping = wrapping + wrapping;
-
-    let _ = inferred_saturating + inferred_saturating;
-    let _ = inferred_string + "";
-    let _ = inferred_wrapping + inferred_wrapping;
-}
-
-#[rustfmt::skip]
-pub fn non_overflowing_ops() {
-    const _: i32 = { let mut n = 1; n += 1; n };
-    let _ = const { let mut n = 1; n += 1; n };
-
-    const _: i32 = { let mut n = 1; n = n + 1; n };
-    let _ = const { let mut n = 1; n = n + 1; n };
-
-    const _: i32 = { let mut n = 1; n = 1 + n; n };
-    let _ = const { let mut n = 1; n = 1 + n; n };
-
-    const _: i32 = 1 + 1;
-    let _ = 1 + 1;
-    let _ = const { 1 + 1 };
-
-    let mut _a = 1;
-    _a *= 1;
-    _a /= 1;
-}
-
-#[rustfmt::skip]
-pub fn overflowing_ops() {
-    let mut _a = 1; _a += 1;
-
-    let mut _b = 1; _b = _b + 1;
-
-    let mut _c = 1; _c = 1 + _c;
-}
-
-fn main() {}
diff --git a/tests/ui/arithmetic.stderr b/tests/ui/arithmetic.stderr
deleted file mode 100644
index a51cf6ba600..00000000000
--- a/tests/ui/arithmetic.stderr
+++ /dev/null
@@ -1,22 +0,0 @@
-error: arithmetic detected
-  --> $DIR/arithmetic.rs:50:21
-   |
-LL |     let mut _a = 1; _a += 1;
-   |                     ^^^^^^^
-   |
-   = note: `-D clippy::arithmetic` implied by `-D warnings`
-
-error: arithmetic detected
-  --> $DIR/arithmetic.rs:52:26
-   |
-LL |     let mut _b = 1; _b = _b + 1;
-   |                          ^^^^^^
-
-error: arithmetic detected
-  --> $DIR/arithmetic.rs:54:26
-   |
-LL |     let mut _c = 1; _c = 1 + _c;
-   |                          ^^^^^^
-
-error: aborting due to 3 previous errors
-
diff --git a/tests/ui/arithmetic_side_effects.rs b/tests/ui/arithmetic_side_effects.rs
new file mode 100644
index 00000000000..f5390c74642
--- /dev/null
+++ b/tests/ui/arithmetic_side_effects.rs
@@ -0,0 +1,57 @@
+#![allow(clippy::assign_op_pattern, clippy::unnecessary_owned_empty_strings)]
+#![feature(inline_const, saturating_int_impl)]
+#![warn(clippy::arithmetic_side_effects)]
+
+use core::num::{Saturating, Wrapping};
+
+pub fn hard_coded_allowed() {
+    let _ = 1f32 + 1f32;
+    let _ = 1f64 + 1f64;
+
+    let _ = Saturating(0u32) + Saturating(0u32);
+    let _ = String::new() + "";
+    let _ = Wrapping(0u32) + Wrapping(0u32);
+
+    let saturating: Saturating<u32> = Saturating(0u32);
+    let string: String = String::new();
+    let wrapping: Wrapping<u32> = Wrapping(0u32);
+
+    let inferred_saturating = saturating + saturating;
+    let inferred_string = string + "";
+    let inferred_wrapping = wrapping + wrapping;
+
+    let _ = inferred_saturating + inferred_saturating;
+    let _ = inferred_string + "";
+    let _ = inferred_wrapping + inferred_wrapping;
+}
+
+#[rustfmt::skip]
+pub fn non_overflowing_ops() {
+    const _: i32 = { let mut n = 1; n += 1; n };
+    let _ = const { let mut n = 1; n += 1; n };
+
+    const _: i32 = { let mut n = 1; n = n + 1; n };
+    let _ = const { let mut n = 1; n = n + 1; n };
+
+    const _: i32 = { let mut n = 1; n = 1 + n; n };
+    let _ = const { let mut n = 1; n = 1 + n; n };
+
+    const _: i32 = 1 + 1;
+    let _ = 1 + 1;
+    let _ = const { 1 + 1 };
+
+    let mut _a = 1;
+    _a *= 1;
+    _a /= 1;
+}
+
+#[rustfmt::skip]
+pub fn overflowing_ops() {
+    let mut _a = 1; _a += 1;
+
+    let mut _b = 1; _b = _b + 1;
+
+    let mut _c = 1; _c = 1 + _c;
+}
+
+fn main() {}
diff --git a/tests/ui/arithmetic_side_effects.stderr b/tests/ui/arithmetic_side_effects.stderr
new file mode 100644
index 00000000000..6c4c8bdec0f
--- /dev/null
+++ b/tests/ui/arithmetic_side_effects.stderr
@@ -0,0 +1,22 @@
+error: arithmetic detected
+  --> $DIR/arithmetic_side_effects.rs:50:21
+   |
+LL |     let mut _a = 1; _a += 1;
+   |                     ^^^^^^^
+   |
+   = note: `-D clippy::arithmetic-side-effects` implied by `-D warnings`
+
+error: arithmetic detected
+  --> $DIR/arithmetic_side_effects.rs:52:26
+   |
+LL |     let mut _b = 1; _b = _b + 1;
+   |                          ^^^^^^
+
+error: arithmetic detected
+  --> $DIR/arithmetic_side_effects.rs:54:26
+   |
+LL |     let mut _c = 1; _c = 1 + _c;
+   |                          ^^^^^^
+
+error: aborting due to 3 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From a6d8afd958e35cb0f424de8be11c42116133e23a Mon Sep 17 00:00:00 2001
From: Michael Wright <mikerite@lavabit.com>
Date: Thu, 8 Sep 2022 20:04:43 +0200
Subject: Fix `range_{plus,minus}_one` bad suggestions

Fixes #9431.

The current `range_plus_one` and `range_minus_one` suggestions
are completely incorrect when macros are involved.

This commit resolves this by disabling the lints for any range
expression that is expanded from a macro. The reasons for this
are that it is very difficult to create a correct suggestion in
this case and that false negatives are less important for
pedantic lints.
---
 clippy_lints/src/ranges.rs           | 11 +++--------
 tests/ui/range_plus_minus_one.fixed  | 19 +++++++++++++++++++
 tests/ui/range_plus_minus_one.rs     | 19 +++++++++++++++++++
 tests/ui/range_plus_minus_one.stderr | 18 +++++++++---------
 4 files changed, 50 insertions(+), 17 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/ranges.rs b/clippy_lints/src/ranges.rs
index 490f345d297..918d624eec6 100644
--- a/clippy_lints/src/ranges.rs
+++ b/clippy_lints/src/ranges.rs
@@ -350,6 +350,7 @@ fn check_range_bounds<'a>(cx: &'a LateContext<'_>, ex: &'a Expr<'_>) -> Option<R
 // exclusive range plus one: `x..(y+1)`
 fn check_exclusive_range_plus_one(cx: &LateContext<'_>, expr: &Expr<'_>) {
     if_chain! {
+        if expr.span.can_be_used_for_suggestions();
         if let Some(higher::Range {
             start,
             end: Some(end),
@@ -357,14 +358,7 @@ fn check_exclusive_range_plus_one(cx: &LateContext<'_>, expr: &Expr<'_>) {
         }) = higher::Range::hir(expr);
         if let Some(y) = y_plus_one(cx, end);
         then {
-            let span = if expr.span.from_expansion() {
-                expr.span
-                    .ctxt()
-                    .outer_expn_data()
-                    .call_site
-            } else {
-                expr.span
-            };
+            let span = expr.span;
             span_lint_and_then(
                 cx,
                 RANGE_PLUS_ONE,
@@ -399,6 +393,7 @@ fn check_exclusive_range_plus_one(cx: &LateContext<'_>, expr: &Expr<'_>) {
 // inclusive range minus one: `x..=(y-1)`
 fn check_inclusive_range_minus_one(cx: &LateContext<'_>, expr: &Expr<'_>) {
     if_chain! {
+        if expr.span.can_be_used_for_suggestions();
         if let Some(higher::Range { start, end: Some(end), limits: RangeLimits::Closed }) = higher::Range::hir(expr);
         if let Some(y) = y_minus_one(cx, end);
         then {
diff --git a/tests/ui/range_plus_minus_one.fixed b/tests/ui/range_plus_minus_one.fixed
index 40d7791df28..a16a3e54d45 100644
--- a/tests/ui/range_plus_minus_one.fixed
+++ b/tests/ui/range_plus_minus_one.fixed
@@ -6,6 +6,22 @@ fn f() -> usize {
     42
 }
 
+macro_rules! macro_plus_one {
+    ($m: literal) => {
+        for i in 0..$m + 1 {
+            println!("{}", i);
+        }
+    };
+}
+
+macro_rules! macro_minus_one {
+    ($m: literal) => {
+        for i in 0..=$m - 1 {
+            println!("{}", i);
+        }
+    };
+}
+
 #[warn(clippy::range_plus_one)]
 #[warn(clippy::range_minus_one)]
 fn main() {
@@ -39,4 +55,7 @@ fn main() {
 
     let mut vec: Vec<()> = std::vec::Vec::new();
     vec.drain(..);
+
+    macro_plus_one!(5);
+    macro_minus_one!(5);
 }
diff --git a/tests/ui/range_plus_minus_one.rs b/tests/ui/range_plus_minus_one.rs
index a8ddd9b5f75..bd6cb4d21be 100644
--- a/tests/ui/range_plus_minus_one.rs
+++ b/tests/ui/range_plus_minus_one.rs
@@ -6,6 +6,22 @@ fn f() -> usize {
     42
 }
 
+macro_rules! macro_plus_one {
+    ($m: literal) => {
+        for i in 0..$m + 1 {
+            println!("{}", i);
+        }
+    };
+}
+
+macro_rules! macro_minus_one {
+    ($m: literal) => {
+        for i in 0..=$m - 1 {
+            println!("{}", i);
+        }
+    };
+}
+
 #[warn(clippy::range_plus_one)]
 #[warn(clippy::range_minus_one)]
 fn main() {
@@ -39,4 +55,7 @@ fn main() {
 
     let mut vec: Vec<()> = std::vec::Vec::new();
     vec.drain(..);
+
+    macro_plus_one!(5);
+    macro_minus_one!(5);
 }
diff --git a/tests/ui/range_plus_minus_one.stderr b/tests/ui/range_plus_minus_one.stderr
index fb4f1658597..0223696243b 100644
--- a/tests/ui/range_plus_minus_one.stderr
+++ b/tests/ui/range_plus_minus_one.stderr
@@ -1,5 +1,5 @@
 error: an inclusive range would be more readable
-  --> $DIR/range_plus_minus_one.rs:15:14
+  --> $DIR/range_plus_minus_one.rs:31:14
    |
 LL |     for _ in 0..3 + 1 {}
    |              ^^^^^^^^ help: use: `0..=3`
@@ -7,25 +7,25 @@ LL |     for _ in 0..3 + 1 {}
    = note: `-D clippy::range-plus-one` implied by `-D warnings`
 
 error: an inclusive range would be more readable
-  --> $DIR/range_plus_minus_one.rs:18:14
+  --> $DIR/range_plus_minus_one.rs:34:14
    |
 LL |     for _ in 0..1 + 5 {}
    |              ^^^^^^^^ help: use: `0..=5`
 
 error: an inclusive range would be more readable
-  --> $DIR/range_plus_minus_one.rs:21:14
+  --> $DIR/range_plus_minus_one.rs:37:14
    |
 LL |     for _ in 1..1 + 1 {}
    |              ^^^^^^^^ help: use: `1..=1`
 
 error: an inclusive range would be more readable
-  --> $DIR/range_plus_minus_one.rs:27:14
+  --> $DIR/range_plus_minus_one.rs:43:14
    |
 LL |     for _ in 0..(1 + f()) {}
    |              ^^^^^^^^^^^^ help: use: `0..=f()`
 
 error: an exclusive range would be more readable
-  --> $DIR/range_plus_minus_one.rs:31:13
+  --> $DIR/range_plus_minus_one.rs:47:13
    |
 LL |     let _ = ..=11 - 1;
    |             ^^^^^^^^^ help: use: `..11`
@@ -33,25 +33,25 @@ LL |     let _ = ..=11 - 1;
    = note: `-D clippy::range-minus-one` implied by `-D warnings`
 
 error: an exclusive range would be more readable
-  --> $DIR/range_plus_minus_one.rs:32:13
+  --> $DIR/range_plus_minus_one.rs:48:13
    |
 LL |     let _ = ..=(11 - 1);
    |             ^^^^^^^^^^^ help: use: `..11`
 
 error: an inclusive range would be more readable
-  --> $DIR/range_plus_minus_one.rs:33:13
+  --> $DIR/range_plus_minus_one.rs:49:13
    |
 LL |     let _ = (1..11 + 1);
    |             ^^^^^^^^^^^ help: use: `(1..=11)`
 
 error: an inclusive range would be more readable
-  --> $DIR/range_plus_minus_one.rs:34:13
+  --> $DIR/range_plus_minus_one.rs:50:13
    |
 LL |     let _ = (f() + 1)..(f() + 1);
    |             ^^^^^^^^^^^^^^^^^^^^ help: use: `((f() + 1)..=f())`
 
 error: an inclusive range would be more readable
-  --> $DIR/range_plus_minus_one.rs:38:14
+  --> $DIR/range_plus_minus_one.rs:54:14
    |
 LL |     for _ in 1..ONE + ONE {}
    |              ^^^^^^^^^^^^ help: use: `1..=ONE`
-- 
cgit 1.4.1-3-g733a5


From 6fc6d87fd069470893b6a539a46fa1e2f10ae906 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Tue, 30 Aug 2022 12:20:49 +0000
Subject: Migrate write.rs to a late pass

---
 clippy_lints/src/format.rs                         |   2 +-
 clippy_lints/src/format_args.rs                    |   2 +-
 clippy_lints/src/lib.register_all.rs               |   1 -
 clippy_lints/src/lib.register_lints.rs             |   1 -
 clippy_lints/src/lib.register_suspicious.rs        |   1 -
 clippy_lints/src/lib.rs                            |   3 +-
 clippy_lints/src/renamed_lints.rs                  |   1 +
 clippy_lints/src/utils/conf.rs                     |   2 +-
 clippy_lints/src/write.rs                          | 787 +++++++--------------
 clippy_utils/src/macros.rs                         |  11 +-
 src/docs.rs                                        |   1 -
 src/docs/positional_named_format_parameters.txt    |  15 -
 src/docs/print_literal.txt                         |   4 -
 src/docs/print_stderr.txt                          |   8 +-
 src/docs/print_stdout.txt                          |   8 +-
 src/docs/write_literal.txt                         |   4 -
 tests/ui/eprint_with_newline.rs                    |  10 +-
 tests/ui/eprint_with_newline.stderr                |  18 +-
 tests/ui/format.fixed                              |   4 -
 tests/ui/format.rs                                 |   4 -
 tests/ui/format.stderr                             |  44 +-
 tests/ui/positional_named_format_parameters.fixed  |  56 --
 tests/ui/positional_named_format_parameters.rs     |  56 --
 tests/ui/positional_named_format_parameters.stderr | 418 -----------
 tests/ui/print_literal.rs                          |   2 +
 tests/ui/print_literal.stderr                      |  56 +-
 tests/ui/print_with_newline.rs                     |  10 +-
 tests/ui/print_with_newline.stderr                 |  18 +-
 tests/ui/println_empty_string.stderr               |  24 +-
 tests/ui/rename.fixed                              |   2 +
 tests/ui/rename.rs                                 |   2 +
 tests/ui/rename.stderr                             |  82 ++-
 tests/ui/write_literal.rs                          |   2 +
 tests/ui/write_literal.stderr                      |  56 +-
 tests/ui/write_literal_2.rs                        |   9 +-
 tests/ui/write_literal_2.stderr                    |  80 ++-
 tests/ui/write_with_newline.rs                     |   8 +
 tests/ui/write_with_newline.stderr                 |  38 +-
 tests/ui/writeln_empty_string.stderr               |  12 +-
 39 files changed, 554 insertions(+), 1308 deletions(-)
 delete mode 100644 src/docs/positional_named_format_parameters.txt
 delete mode 100644 tests/ui/positional_named_format_parameters.fixed
 delete mode 100644 tests/ui/positional_named_format_parameters.rs
 delete mode 100644 tests/ui/positional_named_format_parameters.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/format.rs b/clippy_lints/src/format.rs
index 0c5851cdbed..f10d8256953 100644
--- a/clippy_lints/src/format.rs
+++ b/clippy_lints/src/format.rs
@@ -71,12 +71,12 @@ impl<'tcx> LateLintPass<'tcx> for UselessFormat {
             let value = arg.param.value;
             if_chain! {
                 if format_args.format_string.parts == [kw::Empty];
+                if arg.format.is_default();
                 if match cx.typeck_results().expr_ty(value).peel_refs().kind() {
                     ty::Adt(adt, _) => cx.tcx.is_diagnostic_item(sym::String, adt.did()),
                     ty::Str => true,
                     _ => false,
                 };
-                if !arg.format.has_string_formatting();
                 then {
                     let is_new_string = match value.kind {
                         ExprKind::Binary(..) => true,
diff --git a/clippy_lints/src/format_args.rs b/clippy_lints/src/format_args.rs
index 97024be16fa..e1c46fd0bfd 100644
--- a/clippy_lints/src/format_args.rs
+++ b/clippy_lints/src/format_args.rs
@@ -77,7 +77,7 @@ impl<'tcx> LateLintPass<'tcx> for FormatArgs {
             if let ExpnKind::Macro(_, name) = outermost_expn_data.kind;
             then {
                 for arg in &format_args.args {
-                    if arg.format.has_string_formatting() {
+                    if !arg.format.is_default() {
                         continue;
                     }
                     if is_aliased(&format_args, arg.param.value.hir_id) {
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 1f85382347a..39ab175341f 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -352,7 +352,6 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(useless_conversion::USELESS_CONVERSION),
     LintId::of(vec::USELESS_VEC),
     LintId::of(vec_init_then_push::VEC_INIT_THEN_PUSH),
-    LintId::of(write::POSITIONAL_NAMED_FORMAT_PARAMETERS),
     LintId::of(write::PRINTLN_EMPTY_STRING),
     LintId::of(write::PRINT_LITERAL),
     LintId::of(write::PRINT_WITH_NEWLINE),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 962e6722006..c16f2d86ae0 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -595,7 +595,6 @@ store.register_lints(&[
     vec_init_then_push::VEC_INIT_THEN_PUSH,
     wildcard_imports::ENUM_GLOB_USE,
     wildcard_imports::WILDCARD_IMPORTS,
-    write::POSITIONAL_NAMED_FORMAT_PARAMETERS,
     write::PRINTLN_EMPTY_STRING,
     write::PRINT_LITERAL,
     write::PRINT_STDERR,
diff --git a/clippy_lints/src/lib.register_suspicious.rs b/clippy_lints/src/lib.register_suspicious.rs
index 8f131bbf98b..f463ad9f6d2 100644
--- a/clippy_lints/src/lib.register_suspicious.rs
+++ b/clippy_lints/src/lib.register_suspicious.rs
@@ -36,5 +36,4 @@ store.register_group(true, "clippy::suspicious", Some("clippy_suspicious"), vec!
     LintId::of(suspicious_trait_impl::SUSPICIOUS_OP_ASSIGN_IMPL),
     LintId::of(swap_ptr_to_ref::SWAP_PTR_TO_REF),
     LintId::of(unused_peekable::UNUSED_PEEKABLE),
-    LintId::of(write::POSITIONAL_NAMED_FORMAT_PARAMETERS),
 ])
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index ec96999896e..83fdc15c9f0 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -40,7 +40,6 @@ extern crate rustc_lint;
 extern crate rustc_middle;
 extern crate rustc_mir_dataflow;
 extern crate rustc_parse;
-extern crate rustc_parse_format;
 extern crate rustc_session;
 extern crate rustc_span;
 extern crate rustc_target;
@@ -425,7 +424,6 @@ pub fn register_pre_expansion_lints(store: &mut rustc_lint::LintStore, sess: &Se
         })
     });
 
-    store.register_pre_expansion_pass(|| Box::new(write::Write::default()));
     store.register_pre_expansion_pass(move || Box::new(attrs::EarlyAttributes { msrv }));
 }
 
@@ -879,6 +877,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
             ignore_publish: cargo_ignore_publish,
         })
     });
+    store.register_late_pass(|| Box::new(write::Write::default()));
     store.register_early_pass(|| Box::new(crate_in_macro_def::CrateInMacroDef));
     store.register_early_pass(|| Box::new(empty_structs_with_brackets::EmptyStructsWithBrackets));
     store.register_late_pass(|| Box::new(unnecessary_owned_empty_strings::UnnecessaryOwnedEmptyStrings));
diff --git a/clippy_lints/src/renamed_lints.rs b/clippy_lints/src/renamed_lints.rs
index 6bea6dc0773..d320eea1c37 100644
--- a/clippy_lints/src/renamed_lints.rs
+++ b/clippy_lints/src/renamed_lints.rs
@@ -36,6 +36,7 @@ pub static RENAMED_LINTS: &[(&str, &str)] = &[
     ("clippy::invalid_ref", "invalid_value"),
     ("clippy::mem_discriminant_non_enum", "enum_intrinsics_non_enums"),
     ("clippy::panic_params", "non_fmt_panics"),
+    ("clippy::positional_named_format_parameters", "named_arguments_used_positionally"),
     ("clippy::temporary_cstring_as_ptr", "temporary_cstring_as_ptr"),
     ("clippy::unknown_clippy_lints", "unknown_lints"),
     ("clippy::unused_label", "unused_labels"),
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index a8500beb257..2be3fa99c81 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -476,7 +476,7 @@ pub fn format_error(error: Box<dyn Error>) -> String {
 
             let mut msg = String::from(prefix);
             for row in 0..rows {
-                write!(msg, "\n").unwrap();
+                writeln!(msg).unwrap();
                 for (column, column_width) in column_widths.iter().copied().enumerate() {
                     let index = column * rows + row;
                     let field = fields.get(index).copied().unwrap_or_default();
diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs
index 640a09a7a91..06e7d701701 100644
--- a/clippy_lints/src/write.rs
+++ b/clippy_lints/src/write.rs
@@ -1,20 +1,12 @@
-use std::borrow::Cow;
-use std::iter;
-use std::ops::{Deref, Range};
-
-use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg, span_lint_and_then};
-use clippy_utils::source::{snippet, snippet_opt, snippet_with_applicability};
-use rustc_ast::ast::{Expr, ExprKind, Impl, Item, ItemKind, MacCall, Path, StrLit, StrStyle};
-use rustc_ast::ptr::P;
-use rustc_ast::token::{self, LitKind};
-use rustc_ast::tokenstream::TokenStream;
-use rustc_errors::{Applicability, DiagnosticBuilder};
-use rustc_lexer::unescape::{self, EscapeError};
-use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
-use rustc_parse::parser;
+use clippy_utils::diagnostics::{span_lint, span_lint_and_then};
+use clippy_utils::macros::{root_macro_call_first_node, FormatArgsExpn, MacroCall};
+use clippy_utils::source::snippet_opt;
+use rustc_ast::LitKind;
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind, HirIdMap, Impl, Item, ItemKind};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::symbol::{kw, Symbol};
-use rustc_span::{sym, BytePos, InnerSpan, Span, DUMMY_SP};
+use rustc_span::{sym, BytePos, Span};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -74,13 +66,7 @@ declare_clippy_lint! {
     /// application and might forget to remove those prints afterward.
     ///
     /// ### Known problems
-    /// * Only catches `print!` and `println!` calls.
-    /// * The lint level is unaffected by crate attributes. The level can still
-    ///   be set for functions, modules and other items. To change the level for
-    ///   the entire crate, please use command line flags. More information and a
-    ///   configuration example can be found in [clippy#6610].
-    ///
-    /// [clippy#6610]: https://github.com/rust-lang/rust-clippy/issues/6610#issuecomment-977120558
+    /// Only catches `print!` and `println!` calls.
     ///
     /// ### Example
     /// ```rust
@@ -102,13 +88,7 @@ declare_clippy_lint! {
     /// application and might forget to remove those prints afterward.
     ///
     /// ### Known problems
-    /// * Only catches `eprint!` and `eprintln!` calls.
-    /// * The lint level is unaffected by crate attributes. The level can still
-    ///   be set for functions, modules and other items. To change the level for
-    ///   the entire crate, please use command line flags. More information and a
-    ///   configuration example can be found in [clippy#6610].
-    ///
-    /// [clippy#6610]: https://github.com/rust-lang/rust-clippy/issues/6610#issuecomment-977120558
+    /// Only catches `eprint!` and `eprintln!` calls.
     ///
     /// ### Example
     /// ```rust
@@ -149,10 +129,6 @@ declare_clippy_lint! {
     /// (c.f., https://github.com/matthiaskrgr/rust-str-bench) and unnecessary
     /// (i.e., just put the literal in the format string)
     ///
-    /// ### Known problems
-    /// Will also warn with macro calls as arguments that expand to literals
-    /// -- e.g., `println!("{}", env!("FOO"))`.
-    ///
     /// ### Example
     /// ```rust
     /// println!("{}", "foo");
@@ -234,10 +210,6 @@ declare_clippy_lint! {
     /// (c.f., https://github.com/matthiaskrgr/rust-str-bench) and unnecessary
     /// (i.e., just put the literal in the format string)
     ///
-    /// ### Known problems
-    /// Will also warn with macro calls as arguments that expand to literals
-    /// -- e.g., `writeln!(buf, "{}", env!("FOO"))`.
-    ///
     /// ### Example
     /// ```rust
     /// # use std::fmt::Write;
@@ -257,28 +229,6 @@ declare_clippy_lint! {
     "writing a literal with a format string"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// This lint warns when a named parameter in a format string is used as a positional one.
-    ///
-    /// ### Why is this bad?
-    /// It may be confused for an assignment and obfuscates which parameter is being used.
-    ///
-    /// ### Example
-    /// ```rust
-    /// println!("{}", x = 10);
-    /// ```
-    ///
-    /// Use instead:
-    /// ```rust
-    /// println!("{x}", x = 10);
-    /// ```
-    #[clippy::version = "1.63.0"]
-    pub POSITIONAL_NAMED_FORMAT_PARAMETERS,
-    suspicious,
-    "named parameter in a format string is used positionally"
-}
-
 #[derive(Default)]
 pub struct Write {
     in_debug_impl: bool,
@@ -294,537 +244,308 @@ impl_lint_pass!(Write => [
     WRITE_WITH_NEWLINE,
     WRITELN_EMPTY_STRING,
     WRITE_LITERAL,
-    POSITIONAL_NAMED_FORMAT_PARAMETERS,
 ]);
 
-impl EarlyLintPass for Write {
-    fn check_item(&mut self, _: &EarlyContext<'_>, item: &Item) {
-        if let ItemKind::Impl(box Impl {
-            of_trait: Some(trait_ref),
-            ..
-        }) = &item.kind
-        {
-            let trait_name = trait_ref
-                .path
-                .segments
-                .iter()
-                .last()
-                .expect("path has at least one segment")
-                .ident
-                .name;
-            if trait_name == sym::Debug {
-                self.in_debug_impl = true;
-            }
+impl<'tcx> LateLintPass<'tcx> for Write {
+    fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
+        if is_debug_impl(cx, item) {
+            self.in_debug_impl = true;
         }
     }
 
-    fn check_item_post(&mut self, _: &EarlyContext<'_>, _: &Item) {
-        self.in_debug_impl = false;
+    fn check_item_post(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
+        if is_debug_impl(cx, item) {
+            self.in_debug_impl = false;
+        }
     }
 
-    fn check_mac(&mut self, cx: &EarlyContext<'_>, mac: &MacCall) {
-        fn is_build_script(cx: &EarlyContext<'_>) -> bool {
-            // Cargo sets the crate name for build scripts to `build_script_build`
-            cx.sess()
-                .opts
-                .crate_name
-                .as_ref()
-                .map_or(false, |crate_name| crate_name == "build_script_build")
-        }
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        let Some(macro_call) = root_macro_call_first_node(cx, expr) else { return };
+        let Some(diag_name) = cx.tcx.get_diagnostic_name(macro_call.def_id) else { return };
+        let Some(name) = diag_name.as_str().strip_suffix("_macro") else { return };
 
-        if mac.path == sym!(print) {
-            if !is_build_script(cx) {
-                span_lint(cx, PRINT_STDOUT, mac.span(), "use of `print!`");
-            }
-            self.lint_print_with_newline(cx, mac);
-        } else if mac.path == sym!(println) {
-            if !is_build_script(cx) {
-                span_lint(cx, PRINT_STDOUT, mac.span(), "use of `println!`");
-            }
-            self.lint_println_empty_string(cx, mac);
-        } else if mac.path == sym!(eprint) {
-            span_lint(cx, PRINT_STDERR, mac.span(), "use of `eprint!`");
-            self.lint_print_with_newline(cx, mac);
-        } else if mac.path == sym!(eprintln) {
-            span_lint(cx, PRINT_STDERR, mac.span(), "use of `eprintln!`");
-            self.lint_println_empty_string(cx, mac);
-        } else if mac.path == sym!(write) {
-            if let (Some(fmt_str), dest) = self.check_tts(cx, mac.args.inner_tokens(), true) {
-                if check_newlines(&fmt_str) {
-                    let (nl_span, only_nl) = newline_span(&fmt_str);
-                    let nl_span = match (dest, only_nl) {
-                        // Special case of `write!(buf, "\n")`: Mark everything from the end of
-                        // `buf` for removal so no trailing comma [`writeln!(buf, )`] remains.
-                        (Some(dest_expr), true) => nl_span.with_lo(dest_expr.span.hi()),
-                        _ => nl_span,
-                    };
-                    span_lint_and_then(
-                        cx,
-                        WRITE_WITH_NEWLINE,
-                        mac.span(),
-                        "using `write!()` with a format string that ends in a single newline",
-                        |err| {
-                            err.multipart_suggestion(
-                                "use `writeln!()` instead",
-                                vec![(mac.path.span, String::from("writeln")), (nl_span, String::new())],
-                                Applicability::MachineApplicable,
-                            );
-                        },
-                    );
-                }
-            }
-        } else if mac.path == sym!(writeln) {
-            if let (Some(fmt_str), expr) = self.check_tts(cx, mac.args.inner_tokens(), true) {
-                if fmt_str.symbol == kw::Empty {
-                    let mut applicability = Applicability::MachineApplicable;
-                    let suggestion = if let Some(e) = expr {
-                        snippet_with_applicability(cx, e.span, "v", &mut applicability)
-                    } else {
-                        applicability = Applicability::HasPlaceholders;
-                        Cow::Borrowed("v")
-                    };
-
-                    span_lint_and_sugg(
-                        cx,
-                        WRITELN_EMPTY_STRING,
-                        mac.span(),
-                        format!("using `writeln!({}, \"\")`", suggestion).as_str(),
-                        "replace it with",
-                        format!("writeln!({})", suggestion),
-                        applicability,
-                    );
+        let is_build_script = cx
+            .sess()
+            .opts
+            .crate_name
+            .as_ref()
+            .map_or(false, |crate_name| crate_name == "build_script_build");
+
+        match diag_name {
+            sym::print_macro | sym::println_macro => {
+                if !is_build_script {
+                    span_lint(cx, PRINT_STDOUT, macro_call.span, &format!("use of `{name}!`"));
                 }
-            }
+            },
+            sym::eprint_macro | sym::eprintln_macro => {
+                span_lint(cx, PRINT_STDERR, macro_call.span, &format!("use of `{name}!`"));
+            },
+            sym::write_macro | sym::writeln_macro => {},
+            _ => return,
         }
-    }
-}
 
-/// Given a format string that ends in a newline and its span, calculates the span of the
-/// newline, or the format string itself if the format string consists solely of a newline.
-/// Return this and a boolean indicating whether it only consisted of a newline.
-fn newline_span(fmtstr: &StrLit) -> (Span, bool) {
-    let sp = fmtstr.span;
-    let contents = fmtstr.symbol.as_str();
+        let Some(format_args) = FormatArgsExpn::find_nested(cx, expr, macro_call.expn) else { return };
 
-    if contents == r"\n" {
-        return (sp, true);
-    }
-
-    let newline_sp_hi = sp.hi()
-        - match fmtstr.style {
-            StrStyle::Cooked => BytePos(1),
-            StrStyle::Raw(hashes) => BytePos((1 + hashes).into()),
-        };
+        // ignore `writeln!(w)` and `write!(v, some_macro!())`
+        if format_args.format_string.span.from_expansion() {
+            return;
+        }
 
-    let newline_sp_len = if contents.ends_with('\n') {
-        BytePos(1)
-    } else if contents.ends_with(r"\n") {
-        BytePos(2)
-    } else {
-        panic!("expected format string to contain a newline");
-    };
+        match diag_name {
+            sym::print_macro | sym::eprint_macro | sym::write_macro => {
+                check_newline(cx, &format_args, &macro_call, name);
+            },
+            sym::println_macro | sym::eprintln_macro | sym::writeln_macro => {
+                check_empty_string(cx, &format_args, &macro_call, name);
+            },
+            _ => {},
+        }
 
-    (sp.with_lo(newline_sp_hi - newline_sp_len).with_hi(newline_sp_hi), false)
-}
+        check_literal(cx, &format_args, name);
 
-/// Stores a list of replacement spans for each argument, but only if all the replacements used an
-/// empty format string.
-#[derive(Default)]
-struct SimpleFormatArgs {
-    unnamed: Vec<Vec<Span>>,
-    complex_unnamed: Vec<Vec<Span>>,
-    named: Vec<(Symbol, Vec<Span>)>,
+        if !self.in_debug_impl {
+            for arg in &format_args.args {
+                if arg.format.r#trait == sym::Debug {
+                    span_lint(cx, USE_DEBUG, arg.span, "use of `Debug`-based formatting");
+                }
+            }
+        }
+    }
 }
-impl SimpleFormatArgs {
-    fn get_unnamed(&self) -> impl Iterator<Item = &[Span]> {
-        self.unnamed.iter().map(|x| match x.as_slice() {
-            // Ignore the dummy span added from out of order format arguments.
-            [DUMMY_SP] => &[],
-            x => x,
-        })
+fn is_debug_impl(cx: &LateContext<'_>, item: &Item<'_>) -> bool {
+    if let ItemKind::Impl(Impl { of_trait: Some(trait_ref), .. }) = &item.kind
+        && let Some(trait_id) = trait_ref.trait_def_id()
+    {
+        cx.tcx.is_diagnostic_item(sym::Debug, trait_id)
+    } else {
+        false
     }
+}
 
-    fn get_complex_unnamed(&self) -> impl Iterator<Item = &[Span]> {
-        self.complex_unnamed.iter().map(Vec::as_slice)
-    }
+fn check_newline(cx: &LateContext<'_>, format_args: &FormatArgsExpn<'_>, macro_call: &MacroCall, name: &str) {
+    let format_string_parts = &format_args.format_string.parts;
+    let mut format_string_span = format_args.format_string.span;
 
-    fn get_named(&self, n: &Path) -> &[Span] {
-        self.named.iter().find(|x| *n == x.0).map_or(&[], |x| x.1.as_slice())
-    }
+    let Some(last) = format_string_parts.last() else { return };
 
-    fn push(&mut self, arg: rustc_parse_format::Argument<'_>, span: Span) {
-        use rustc_parse_format::{
-            AlignUnknown, ArgumentImplicitlyIs, ArgumentIs, ArgumentNamed, CountImplied, FormatSpec,
-        };
+    let count_vertical_whitespace = || {
+        format_string_parts
+            .iter()
+            .flat_map(|part| part.as_str().chars())
+            .filter(|ch| matches!(ch, '\r' | '\n'))
+            .count()
+    };
 
-        const SIMPLE: FormatSpec<'_> = FormatSpec {
-            fill: None,
-            align: AlignUnknown,
-            flags: 0,
-            precision: CountImplied,
-            precision_span: None,
-            width: CountImplied,
-            width_span: None,
-            ty: "",
-            ty_span: None,
-        };
+    if last.as_str().ends_with('\n')
+        // ignore format strings with other internal vertical whitespace
+        && count_vertical_whitespace() == 1
 
-        match arg.position {
-            ArgumentIs(n) | ArgumentImplicitlyIs(n) => {
-                if self.unnamed.len() <= n {
-                    // Use a dummy span to mark all unseen arguments.
-                    self.unnamed.resize_with(n, || vec![DUMMY_SP]);
-                    if arg.format == SIMPLE {
-                        self.unnamed.push(vec![span]);
-                    } else {
-                        self.unnamed.push(Vec::new());
-                    }
-                } else {
-                    let args = &mut self.unnamed[n];
-                    match (args.as_mut_slice(), arg.format == SIMPLE) {
-                        // A non-empty format string has been seen already.
-                        ([], _) => (),
-                        // Replace the dummy span, if it exists.
-                        ([dummy @ DUMMY_SP], true) => *dummy = span,
-                        ([_, ..], true) => args.push(span),
-                        ([_, ..], false) => *args = Vec::new(),
-                    }
-                }
-            },
-            ArgumentNamed(n) => {
-                let n = Symbol::intern(n);
-                if let Some(x) = self.named.iter_mut().find(|x| x.0 == n) {
-                    match x.1.as_slice() {
-                        // A non-empty format string has been seen already.
-                        [] => (),
-                        [_, ..] if arg.format == SIMPLE => x.1.push(span),
-                        [_, ..] => x.1 = Vec::new(),
-                    }
-                } else if arg.format == SIMPLE {
-                    self.named.push((n, vec![span]));
-                } else {
-                    self.named.push((n, Vec::new()));
-                }
-            },
-        };
-    }
+        // ignore trailing arguments: `print!("Issue\n{}", 1265);`
+        && format_string_parts.len() > format_args.args.len()
+    {
+        let lint = if name == "write" {
+            format_string_span = expand_past_previous_comma(cx, format_string_span);
 
-    fn push_to_complex(&mut self, span: Span, position: usize) {
-        if self.complex_unnamed.len() <= position {
-            self.complex_unnamed.resize_with(position, Vec::new);
-            self.complex_unnamed.push(vec![span]);
+            WRITE_WITH_NEWLINE
         } else {
-            let args: &mut Vec<Span> = &mut self.complex_unnamed[position];
-            args.push(span);
-        }
-    }
-
-    fn push_complex(
-        &mut self,
-        cx: &EarlyContext<'_>,
-        arg: rustc_parse_format::Argument<'_>,
-        str_lit_span: Span,
-        fmt_span: Span,
-    ) {
-        use rustc_parse_format::{ArgumentImplicitlyIs, ArgumentIs, CountIsParam, CountIsStar};
-
-        let snippet = snippet_opt(cx, fmt_span);
-
-        let end = snippet
-            .as_ref()
-            .and_then(|s| s.find(':'))
-            .or_else(|| fmt_span.hi().0.checked_sub(fmt_span.lo().0 + 1).map(|u| u as usize));
-
-        if let (ArgumentIs(n) | ArgumentImplicitlyIs(n), Some(end)) = (arg.position, end) {
-            let span = fmt_span.from_inner(InnerSpan::new(1, end));
-            self.push_to_complex(span, n);
+            PRINT_WITH_NEWLINE
         };
 
-        if let (CountIsParam(n) | CountIsStar(n), Some(span)) = (arg.format.precision, arg.format.precision_span) {
-            // We need to do this hack as precision spans should be converted from .* to .foo$
-            let hack = if snippet.as_ref().and_then(|s| s.find('*')).is_some() {
-                0
-            } else {
-                1
-            };
+        span_lint_and_then(
+            cx,
+            lint,
+            macro_call.span,
+            &format!("using `{name}!()` with a format string that ends in a single newline"),
+            |diag| {
+                let name_span = cx.sess().source_map().span_until_char(macro_call.span, '!');
+                let Some(format_snippet) = snippet_opt(cx, format_string_span) else { return };
+
+                if format_string_parts.len() == 1 && last.as_str() == "\n" {
+                    // print!("\n"), write!(f, "\n")
+
+                    diag.multipart_suggestion(
+                        &format!("use `{name}ln!` instead"),
+                        vec![(name_span, format!("{name}ln")), (format_string_span, String::new())],
+                        Applicability::MachineApplicable,
+                    );
+                } else if format_snippet.ends_with("\\n\"") {
+                    // print!("...\n"), write!(f, "...\n")
 
-            let span = str_lit_span.from_inner(InnerSpan {
-                start: span.start + 1,
-                end: span.end - hack,
-            });
-            self.push_to_complex(span, n);
-        };
+                    let hi = format_string_span.hi();
+                    let newline_span = format_string_span.with_lo(hi - BytePos(3)).with_hi(hi - BytePos(1));
 
-        if let (CountIsParam(n), Some(span)) = (arg.format.width, arg.format.width_span) {
-            let span = str_lit_span.from_inner(InnerSpan {
-                start: span.start,
-                end: span.end - 1,
-            });
-            self.push_to_complex(span, n);
-        };
+                    diag.multipart_suggestion(
+                        &format!("use `{name}ln!` instead"),
+                        vec![(name_span, format!("{name}ln")), (newline_span, String::new())],
+                        Applicability::MachineApplicable,
+                    );
+                }
+            },
+        );
     }
 }
 
-impl Write {
-    /// Parses a format string into a collection of spans for each argument. This only keeps track
-    /// of empty format arguments. Will also lint usages of debug format strings outside of debug
-    /// impls.
-    fn parse_fmt_string(&self, cx: &EarlyContext<'_>, str_lit: &StrLit) -> Option<SimpleFormatArgs> {
-        use rustc_parse_format::{ParseMode, Parser, Piece};
-
-        let str_sym = str_lit.symbol_unescaped.as_str();
-        let style = match str_lit.style {
-            StrStyle::Cooked => None,
-            StrStyle::Raw(n) => Some(n as usize),
-        };
-
-        let mut parser = Parser::new(str_sym, style, snippet_opt(cx, str_lit.span), false, ParseMode::Format);
-        let mut args = SimpleFormatArgs::default();
+fn check_empty_string(cx: &LateContext<'_>, format_args: &FormatArgsExpn<'_>, macro_call: &MacroCall, name: &str) {
+    if let [part] = &format_args.format_string.parts[..]
+        && let mut span = format_args.format_string.span
+        && part.as_str() == "\n"
+    {
+        let lint = if name == "writeln" {
+            span = expand_past_previous_comma(cx, span);
 
-        while let Some(arg) = parser.next() {
-            let arg = match arg {
-                Piece::String(_) => continue,
-                Piece::NextArgument(arg) => arg,
-            };
-            let span = parser
-                .arg_places
-                .last()
-                .map_or(DUMMY_SP, |&x| str_lit.span.from_inner(InnerSpan::new(x.start, x.end)));
-
-            if !self.in_debug_impl && arg.format.ty == "?" {
-                // FIXME: modify rustc's fmt string parser to give us the current span
-                span_lint(cx, USE_DEBUG, span, "use of `Debug`-based formatting");
-            }
-            args.push(arg, span);
-            args.push_complex(cx, arg, str_lit.span, span);
-        }
-
-        parser.errors.is_empty().then_some(args)
-    }
-
-    /// Checks the arguments of `print[ln]!` and `write[ln]!` calls. It will return a tuple of two
-    /// `Option`s. The first `Option` of the tuple is the macro's format string. It includes
-    /// the contents of the string, whether it's a raw string, and the span of the literal in the
-    /// source. The second `Option` in the tuple is, in the `write[ln]!` case, the expression the
-    /// `format_str` should be written to.
-    ///
-    /// Example:
-    ///
-    /// Calling this function on
-    /// ```rust
-    /// # use std::fmt::Write;
-    /// # let mut buf = String::new();
-    /// # let something = "something";
-    /// writeln!(buf, "string to write: {}", something);
-    /// ```
-    /// will return
-    /// ```rust,ignore
-    /// (Some("string to write: {}"), Some(buf))
-    /// ```
-    fn check_tts<'a>(&self, cx: &EarlyContext<'a>, tts: TokenStream, is_write: bool) -> (Option<StrLit>, Option<Expr>) {
-        let mut parser = parser::Parser::new(&cx.sess().parse_sess, tts, false, None);
-        let expr = if is_write {
-            match parser
-                .parse_expr()
-                .map(rustc_ast::ptr::P::into_inner)
-                .map_err(DiagnosticBuilder::cancel)
-            {
-                // write!(e, ...)
-                Ok(p) if parser.eat(&token::Comma) => Some(p),
-                // write!(e) or error
-                e => return (None, e.ok()),
-            }
+            WRITELN_EMPTY_STRING
         } else {
-            None
+            PRINTLN_EMPTY_STRING
         };
 
-        let fmtstr = match parser.parse_str_lit() {
-            Ok(fmtstr) => fmtstr,
-            Err(_) => return (None, expr),
-        };
+        span_lint_and_then(
+            cx,
+            lint,
+            macro_call.span,
+            &format!("empty string literal in `{name}!`"),
+            |diag| {
+                diag.span_suggestion(
+                    span,
+                    "remove the empty string",
+                    String::new(),
+                    Applicability::MachineApplicable,
+                );
+            },
+        );
+    }
+}
 
-        let args = match self.parse_fmt_string(cx, &fmtstr) {
-            Some(args) => args,
-            None => return (Some(fmtstr), expr),
-        };
+fn check_literal(cx: &LateContext<'_>, format_args: &FormatArgsExpn<'_>, name: &str) {
+    let mut counts = HirIdMap::<usize>::default();
+    for param in format_args.params() {
+        *counts.entry(param.value.hir_id).or_default() += 1;
+    }
 
-        let lint = if is_write { WRITE_LITERAL } else { PRINT_LITERAL };
-        let mut unnamed_args = args.get_unnamed();
-        let mut complex_unnamed_args = args.get_complex_unnamed();
-        loop {
-            if !parser.eat(&token::Comma) {
-                return (Some(fmtstr), expr);
-            }
+    for arg in &format_args.args {
+        let value = arg.param.value;
 
-            let comma_span = parser.prev_token.span;
-            let token_expr = if let Ok(expr) = parser.parse_expr().map_err(DiagnosticBuilder::cancel) {
-                expr
-            } else {
-                return (Some(fmtstr), None);
-            };
-            let complex_unnamed_arg = complex_unnamed_args.next();
-
-            let (fmt_spans, lit) = match &token_expr.kind {
-                ExprKind::Lit(lit) => (unnamed_args.next().unwrap_or(&[]), lit),
-                ExprKind::Assign(lhs, rhs, _) => {
-                    if let Some(span) = complex_unnamed_arg {
-                        for x in span {
-                            Self::report_positional_named_param(cx, *x, lhs, rhs);
-                        }
-                    }
-                    match (&lhs.kind, &rhs.kind) {
-                        (ExprKind::Path(_, p), ExprKind::Lit(lit)) => (args.get_named(p), lit),
-                        _ => continue,
+        if counts[&value.hir_id] == 1
+            && arg.format.is_default()
+            && let ExprKind::Lit(lit) = &value.kind
+            && !value.span.from_expansion()
+            && let Some(value_string) = snippet_opt(cx, value.span)
+        {
+            let (replacement, replace_raw) = match lit.node {
+                LitKind::Str(..) => extract_str_literal(&value_string),
+                LitKind::Char(ch) => (
+                    match ch {
+                        '"' => "\\\"",
+                        '\'' => "'",
+                        _ => &value_string[1..value_string.len() - 1],
                     }
-                },
-                _ => {
-                    unnamed_args.next();
-                    continue;
-                },
+                    .to_string(),
+                    false,
+                ),
+                LitKind::Bool(b) => (b.to_string(), false),
+                _ => continue,
+            };
+
+            let lint = if name.starts_with("write") {
+                WRITE_LITERAL
+            } else {
+                PRINT_LITERAL
             };
 
-            let replacement: String = match lit.token_lit.kind {
-                LitKind::StrRaw(_) | LitKind::ByteStrRaw(_) if matches!(fmtstr.style, StrStyle::Raw(_)) => {
-                    lit.token_lit.symbol.as_str().replace('{', "{{").replace('}', "}}")
+            let format_string_is_raw = format_args.format_string.style.is_some();
+            let replacement = match (format_string_is_raw, replace_raw) {
+                (false, false) => Some(replacement),
+                (false, true) => Some(replacement.replace('"', "\\\"").replace('\\', "\\\\")),
+                (true, false) => match conservative_unescape(&replacement) {
+                    Ok(unescaped) => Some(unescaped),
+                    Err(UnescapeErr::Lint) => None,
+                    Err(UnescapeErr::Ignore) => continue,
                 },
-                LitKind::Str | LitKind::ByteStr if matches!(fmtstr.style, StrStyle::Cooked) => {
-                    lit.token_lit.symbol.as_str().replace('{', "{{").replace('}', "}}")
+                (true, true) => {
+                    if replacement.contains(['#', '"']) {
+                        None
+                    } else {
+                        Some(replacement)
+                    }
                 },
-                LitKind::StrRaw(_)
-                | LitKind::Str
-                | LitKind::ByteStrRaw(_)
-                | LitKind::ByteStr
-                | LitKind::Integer
-                | LitKind::Float
-                | LitKind::Err => continue,
-                LitKind::Byte | LitKind::Char => match lit.token_lit.symbol.as_str() {
-                    "\"" if matches!(fmtstr.style, StrStyle::Cooked) => "\\\"",
-                    "\"" if matches!(fmtstr.style, StrStyle::Raw(0)) => continue,
-                    "\\\\" if matches!(fmtstr.style, StrStyle::Raw(_)) => "\\",
-                    "\\'" => "'",
-                    "{" => "{{",
-                    "}" => "}}",
-                    x if matches!(fmtstr.style, StrStyle::Raw(_)) && x.starts_with('\\') => continue,
-                    x => x,
-                }
-                .into(),
-                LitKind::Bool => lit.token_lit.symbol.as_str().deref().into(),
             };
 
-            if !fmt_spans.is_empty() {
-                span_lint_and_then(
-                    cx,
-                    lint,
-                    token_expr.span,
-                    "literal with an empty format string",
-                    |diag| {
+            span_lint_and_then(
+                cx,
+                lint,
+                value.span,
+                "literal with an empty format string",
+                |diag| {
+                    if let Some(replacement) = replacement {
+                        // `format!("{}", "a")`, `format!("{named}", named = "b")
+                        //              ~~~~~                      ~~~~~~~~~~~~~
+                        let value_span = expand_past_previous_comma(cx, value.span);
+
+                        let replacement = replacement.replace('{', "{{").replace('}', "}}");
                         diag.multipart_suggestion(
                             "try this",
-                            iter::once((comma_span.to(token_expr.span), String::new()))
-                                .chain(fmt_spans.iter().copied().zip(iter::repeat(replacement)))
-                                .collect(),
+                            vec![(arg.span, replacement), (value_span, String::new())],
                             Applicability::MachineApplicable,
                         );
-                    },
-                );
-            }
-        }
-    }
-
-    fn report_positional_named_param(cx: &EarlyContext<'_>, span: Span, lhs: &P<Expr>, _rhs: &P<Expr>) {
-        if let ExprKind::Path(_, _p) = &lhs.kind {
-            let mut applicability = Applicability::MachineApplicable;
-            let name = snippet_with_applicability(cx, lhs.span, "name", &mut applicability);
-            // We need to do this hack as precision spans should be converted from .* to .foo$
-            let hack = snippet(cx, span, "").contains('*');
-
-            span_lint_and_sugg(
-                cx,
-                POSITIONAL_NAMED_FORMAT_PARAMETERS,
-                span,
-                &format!("named parameter {} is used as a positional parameter", name),
-                "replace it with",
-                if hack {
-                    format!("{}$", name)
-                } else {
-                    format!("{}", name)
+                    }
                 },
-                applicability,
             );
-        };
-    }
-
-    fn lint_println_empty_string(&self, cx: &EarlyContext<'_>, mac: &MacCall) {
-        if let (Some(fmt_str), _) = self.check_tts(cx, mac.args.inner_tokens(), false) {
-            if fmt_str.symbol == kw::Empty {
-                let name = mac.path.segments[0].ident.name;
-                span_lint_and_sugg(
-                    cx,
-                    PRINTLN_EMPTY_STRING,
-                    mac.span(),
-                    &format!("using `{}!(\"\")`", name),
-                    "replace it with",
-                    format!("{}!()", name),
-                    Applicability::MachineApplicable,
-                );
-            }
-        }
-    }
-
-    fn lint_print_with_newline(&self, cx: &EarlyContext<'_>, mac: &MacCall) {
-        if let (Some(fmt_str), _) = self.check_tts(cx, mac.args.inner_tokens(), false) {
-            if check_newlines(&fmt_str) {
-                let name = mac.path.segments[0].ident.name;
-                let suggested = format!("{}ln", name);
-                span_lint_and_then(
-                    cx,
-                    PRINT_WITH_NEWLINE,
-                    mac.span(),
-                    &format!("using `{}!()` with a format string that ends in a single newline", name),
-                    |err| {
-                        err.multipart_suggestion(
-                            &format!("use `{}!` instead", suggested),
-                            vec![(mac.path.span, suggested), (newline_span(&fmt_str).0, String::new())],
-                            Applicability::MachineApplicable,
-                        );
-                    },
-                );
-            }
         }
     }
 }
 
-/// Checks if the format string contains a single newline that terminates it.
+/// Removes the raw marker, `#`s and quotes from a str, and returns if the literal is raw
 ///
-/// Literal and escaped newlines are both checked (only literal for raw strings).
-fn check_newlines(fmtstr: &StrLit) -> bool {
-    let mut has_internal_newline = false;
-    let mut last_was_cr = false;
-    let mut should_lint = false;
-
-    let contents = fmtstr.symbol.as_str();
-
-    let mut cb = |r: Range<usize>, c: Result<char, EscapeError>| {
-        let c = match c {
-            Ok(c) => c,
-            Err(e) if !e.is_fatal() => return,
-            Err(e) => panic!("{:?}", e),
-        };
-
-        if r.end == contents.len() && c == '\n' && !last_was_cr && !has_internal_newline {
-            should_lint = true;
-        } else {
-            last_was_cr = c == '\r';
-            if c == '\n' {
-                has_internal_newline = true;
-            }
-        }
+/// `r#"a"#` -> (`a`, true)
+///
+/// `"b"` -> (`b`, false)
+fn extract_str_literal(literal: &str) -> (String, bool) {
+    let (literal, raw) = match literal.strip_prefix('r') {
+        Some(stripped) => (stripped.trim_matches('#'), true),
+        None => (literal, false),
     };
 
-    match fmtstr.style {
-        StrStyle::Cooked => unescape::unescape_literal(contents, unescape::Mode::Str, &mut cb),
-        StrStyle::Raw(_) => unescape::unescape_literal(contents, unescape::Mode::RawStr, &mut cb),
+    (literal[1..literal.len() - 1].to_string(), raw)
+}
+
+enum UnescapeErr {
+    /// Should still be linted, can be manually resolved by author, e.g.
+    ///
+    /// ```ignore
+    /// print!(r"{}", '"');
+    /// ```
+    Lint,
+    /// Should not be linted, e.g.
+    ///
+    /// ```ignore
+    /// print!(r"{}", '\r');
+    /// ```
+    Ignore,
+}
+
+/// Unescape a normal string into a raw string
+fn conservative_unescape(literal: &str) -> Result<String, UnescapeErr> {
+    let mut unescaped = String::with_capacity(literal.len());
+    let mut chars = literal.chars();
+    let mut err = false;
+
+    while let Some(ch) = chars.next() {
+        match ch {
+            '#' => err = true,
+            '\\' => match chars.next() {
+                Some('\\') => unescaped.push('\\'),
+                Some('"') => err = true,
+                _ => return Err(UnescapeErr::Ignore),
+            },
+            _ => unescaped.push(ch),
+        }
     }
 
-    should_lint
+    if err { Err(UnescapeErr::Lint) } else { Ok(unescaped) }
+}
+
+// Expand from `writeln!(o, "")` to `writeln!(o, "")`
+//                          ^^                 ^^^^
+fn expand_past_previous_comma(cx: &LateContext<'_>, span: Span) -> Span {
+    let extended = cx.sess().source_map().span_extend_to_prev_char(span, ',', true);
+    extended.with_lo(extended.lo() - BytePos(1))
 }
diff --git a/clippy_utils/src/macros.rs b/clippy_utils/src/macros.rs
index bd89ff977f8..8855b739480 100644
--- a/clippy_utils/src/macros.rs
+++ b/clippy_utils/src/macros.rs
@@ -711,9 +711,14 @@ impl<'tcx> FormatSpec<'tcx> {
         })
     }
 
-    /// Returns true if this format spec would change the contents of a string when formatted
-    pub fn has_string_formatting(&self) -> bool {
-        self.r#trait != sym::Display || !self.width.is_implied() || !self.precision.is_implied()
+    /// Returns true if this format spec is unchanged from the default. e.g. returns true for `{}`,
+    /// `{foo}` and `{2}`, but false for `{:?}`, `{foo:5}` and `{3:.5}`
+    pub fn is_default(&self) -> bool {
+        self.r#trait == sym::Display
+            && self.width.is_implied()
+            && self.precision.is_implied()
+            && self.align == Alignment::AlignUnknown
+            && self.flags == 0
     }
 }
 
diff --git a/src/docs.rs b/src/docs.rs
index f3a5048e7fa..9f6f1fb4727 100644
--- a/src/docs.rs
+++ b/src/docs.rs
@@ -391,7 +391,6 @@ docs! {
     "partialeq_to_none",
     "path_buf_push_overwrite",
     "pattern_type_mismatch",
-    "positional_named_format_parameters",
     "possible_missing_comma",
     "precedence",
     "print_in_format_impl",
diff --git a/src/docs/positional_named_format_parameters.txt b/src/docs/positional_named_format_parameters.txt
deleted file mode 100644
index e391d240667..00000000000
--- a/src/docs/positional_named_format_parameters.txt
+++ /dev/null
@@ -1,15 +0,0 @@
-### What it does
-This lint warns when a named parameter in a format string is used as a positional one.
-
-### Why is this bad?
-It may be confused for an assignment and obfuscates which parameter is being used.
-
-### Example
-```
-println!("{}", x = 10);
-```
-
-Use instead:
-```
-println!("{x}", x = 10);
-```
\ No newline at end of file
diff --git a/src/docs/print_literal.txt b/src/docs/print_literal.txt
index 160073414f9..a6252a68780 100644
--- a/src/docs/print_literal.txt
+++ b/src/docs/print_literal.txt
@@ -6,10 +6,6 @@ Using literals as `println!` args is inefficient
 (c.f., https://github.com/matthiaskrgr/rust-str-bench) and unnecessary
 (i.e., just put the literal in the format string)
 
-### Known problems
-Will also warn with macro calls as arguments that expand to literals
--- e.g., `println!("{}", env!("FOO"))`.
-
 ### Example
 ```
 println!("{}", "foo");
diff --git a/src/docs/print_stderr.txt b/src/docs/print_stderr.txt
index fc14511cd6a..9c6edeeef12 100644
--- a/src/docs/print_stderr.txt
+++ b/src/docs/print_stderr.txt
@@ -7,13 +7,7 @@ People often print on *stderr* while debugging an
 application and might forget to remove those prints afterward.
 
 ### Known problems
-* Only catches `eprint!` and `eprintln!` calls.
-* The lint level is unaffected by crate attributes. The level can still
-  be set for functions, modules and other items. To change the level for
-  the entire crate, please use command line flags. More information and a
-  configuration example can be found in [clippy#6610].
-
-[clippy#6610]: https://github.com/rust-lang/rust-clippy/issues/6610#issuecomment-977120558
+Only catches `eprint!` and `eprintln!` calls.
 
 ### Example
 ```
diff --git a/src/docs/print_stdout.txt b/src/docs/print_stdout.txt
index 6c9a4b98e1e..d2cbd811d1b 100644
--- a/src/docs/print_stdout.txt
+++ b/src/docs/print_stdout.txt
@@ -7,13 +7,7 @@ People often print on *stdout* while debugging an
 application and might forget to remove those prints afterward.
 
 ### Known problems
-* Only catches `print!` and `println!` calls.
-* The lint level is unaffected by crate attributes. The level can still
-  be set for functions, modules and other items. To change the level for
-  the entire crate, please use command line flags. More information and a
-  configuration example can be found in [clippy#6610].
-
-[clippy#6610]: https://github.com/rust-lang/rust-clippy/issues/6610#issuecomment-977120558
+Only catches `print!` and `println!` calls.
 
 ### Example
 ```
diff --git a/src/docs/write_literal.txt b/src/docs/write_literal.txt
index 9c41a48f9f7..a7a884d0871 100644
--- a/src/docs/write_literal.txt
+++ b/src/docs/write_literal.txt
@@ -6,10 +6,6 @@ Using literals as `writeln!` args is inefficient
 (c.f., https://github.com/matthiaskrgr/rust-str-bench) and unnecessary
 (i.e., just put the literal in the format string)
 
-### Known problems
-Will also warn with macro calls as arguments that expand to literals
--- e.g., `writeln!(buf, "{}", env!("FOO"))`.
-
 ### Example
 ```
 writeln!(buf, "{}", "foo");
diff --git a/tests/ui/eprint_with_newline.rs b/tests/ui/eprint_with_newline.rs
index 8df32649ad9..de5e121be87 100644
--- a/tests/ui/eprint_with_newline.rs
+++ b/tests/ui/eprint_with_newline.rs
@@ -45,5 +45,13 @@ fn main() {
     eprint!("\r\n");
     eprint!("foo\r\n");
     eprint!("\\r\n"); //~ ERROR
-    eprint!("foo\rbar\n") // ~ ERROR
+    eprint!("foo\rbar\n");
+
+    // Ignore expanded format strings
+    macro_rules! newline {
+        () => {
+            "\n"
+        };
+    }
+    eprint!(newline!());
 }
diff --git a/tests/ui/eprint_with_newline.stderr b/tests/ui/eprint_with_newline.stderr
index f137787bff0..0eefb9f0ca9 100644
--- a/tests/ui/eprint_with_newline.stderr
+++ b/tests/ui/eprint_with_newline.stderr
@@ -83,7 +83,7 @@ LL | |     );
 help: use `eprintln!` instead
    |
 LL ~     eprintln!(
-LL ~         ""
+LL ~         
    |
 
 error: using `eprint!()` with a format string that ends in a single newline
@@ -98,7 +98,7 @@ LL | |     );
 help: use `eprintln!` instead
    |
 LL ~     eprintln!(
-LL ~         r""
+LL ~         
    |
 
 error: using `eprint!()` with a format string that ends in a single newline
@@ -113,17 +113,5 @@ LL -     eprint!("/r/n"); //~ ERROR
 LL +     eprintln!("/r"); //~ ERROR
    |
 
-error: using `eprint!()` with a format string that ends in a single newline
-  --> $DIR/eprint_with_newline.rs:48:5
-   |
-LL |     eprint!("foo/rbar/n") // ~ ERROR
-   |     ^^^^^^^^^^^^^^^^^^^^^
-   |
-help: use `eprintln!` instead
-   |
-LL -     eprint!("foo/rbar/n") // ~ ERROR
-LL +     eprintln!("foo/rbar") // ~ ERROR
-   |
-
-error: aborting due to 10 previous errors
+error: aborting due to 9 previous errors
 
diff --git a/tests/ui/format.fixed b/tests/ui/format.fixed
index b56d6aec508..e0c5f692740 100644
--- a/tests/ui/format.fixed
+++ b/tests/ui/format.fixed
@@ -28,8 +28,6 @@ fn main() {
     format!("{:?}", "foo"); // Don't warn about `Debug`.
     format!("{:8}", "foo");
     format!("{:width$}", "foo", width = 8);
-    "foo".to_string(); // Warn when the format makes no difference.
-    "foo".to_string(); // Warn when the format makes no difference.
     format!("foo {}", "bar");
     format!("{} bar", "foo");
 
@@ -38,8 +36,6 @@ fn main() {
     format!("{:?}", arg); // Don't warn about debug.
     format!("{:8}", arg);
     format!("{:width$}", arg, width = 8);
-    arg.to_string(); // Warn when the format makes no difference.
-    arg.to_string(); // Warn when the format makes no difference.
     format!("foo {}", arg);
     format!("{} bar", arg);
 
diff --git a/tests/ui/format.rs b/tests/ui/format.rs
index 4c1a3a840ed..ff83cd64bf0 100644
--- a/tests/ui/format.rs
+++ b/tests/ui/format.rs
@@ -30,8 +30,6 @@ fn main() {
     format!("{:?}", "foo"); // Don't warn about `Debug`.
     format!("{:8}", "foo");
     format!("{:width$}", "foo", width = 8);
-    format!("{:+}", "foo"); // Warn when the format makes no difference.
-    format!("{:<}", "foo"); // Warn when the format makes no difference.
     format!("foo {}", "bar");
     format!("{} bar", "foo");
 
@@ -40,8 +38,6 @@ fn main() {
     format!("{:?}", arg); // Don't warn about debug.
     format!("{:8}", arg);
     format!("{:width$}", arg, width = 8);
-    format!("{:+}", arg); // Warn when the format makes no difference.
-    format!("{:<}", arg); // Warn when the format makes no difference.
     format!("foo {}", arg);
     format!("{} bar", arg);
 
diff --git a/tests/ui/format.stderr b/tests/ui/format.stderr
index 6c35caeb034..0ef0ac655d3 100644
--- a/tests/ui/format.stderr
+++ b/tests/ui/format.stderr
@@ -46,82 +46,58 @@ LL |     format!("{}", "foo");
    |     ^^^^^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `"foo".to_string()`
 
 error: useless use of `format!`
-  --> $DIR/format.rs:33:5
-   |
-LL |     format!("{:+}", "foo"); // Warn when the format makes no difference.
-   |     ^^^^^^^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `"foo".to_string()`
-
-error: useless use of `format!`
-  --> $DIR/format.rs:34:5
-   |
-LL |     format!("{:<}", "foo"); // Warn when the format makes no difference.
-   |     ^^^^^^^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `"foo".to_string()`
-
-error: useless use of `format!`
-  --> $DIR/format.rs:39:5
+  --> $DIR/format.rs:37:5
    |
 LL |     format!("{}", arg);
    |     ^^^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `arg.to_string()`
 
 error: useless use of `format!`
-  --> $DIR/format.rs:43:5
-   |
-LL |     format!("{:+}", arg); // Warn when the format makes no difference.
-   |     ^^^^^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `arg.to_string()`
-
-error: useless use of `format!`
-  --> $DIR/format.rs:44:5
-   |
-LL |     format!("{:<}", arg); // Warn when the format makes no difference.
-   |     ^^^^^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `arg.to_string()`
-
-error: useless use of `format!`
-  --> $DIR/format.rs:71:5
+  --> $DIR/format.rs:67:5
    |
 LL |     format!("{}", 42.to_string());
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `42.to_string()`
 
 error: useless use of `format!`
-  --> $DIR/format.rs:73:5
+  --> $DIR/format.rs:69:5
    |
 LL |     format!("{}", x.display().to_string());
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `x.display().to_string()`
 
 error: useless use of `format!`
-  --> $DIR/format.rs:77:18
+  --> $DIR/format.rs:73:18
    |
 LL |     let _ = Some(format!("{}", a + "bar"));
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `a + "bar"`
 
 error: useless use of `format!`
-  --> $DIR/format.rs:81:22
+  --> $DIR/format.rs:77:22
    |
 LL |     let _s: String = format!("{}", &*v.join("/n"));
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `(&*v.join("/n")).to_string()`
 
 error: useless use of `format!`
-  --> $DIR/format.rs:87:13
+  --> $DIR/format.rs:83:13
    |
 LL |     let _ = format!("{x}");
    |             ^^^^^^^^^^^^^^ help: consider using `.to_string()`: `x.to_string()`
 
 error: useless use of `format!`
-  --> $DIR/format.rs:89:13
+  --> $DIR/format.rs:85:13
    |
 LL |     let _ = format!("{y}", y = x);
    |             ^^^^^^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `x.to_string()`
 
 error: useless use of `format!`
-  --> $DIR/format.rs:93:13
+  --> $DIR/format.rs:89:13
    |
 LL |     let _ = format!("{abc}");
    |             ^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `abc.to_string()`
 
 error: useless use of `format!`
-  --> $DIR/format.rs:95:13
+  --> $DIR/format.rs:91:13
    |
 LL |     let _ = format!("{xx}");
    |             ^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `xx.to_string()`
 
-error: aborting due to 19 previous errors
+error: aborting due to 15 previous errors
 
diff --git a/tests/ui/positional_named_format_parameters.fixed b/tests/ui/positional_named_format_parameters.fixed
deleted file mode 100644
index 4170e109820..00000000000
--- a/tests/ui/positional_named_format_parameters.fixed
+++ /dev/null
@@ -1,56 +0,0 @@
-// run-rustfix
-#![allow(unused_must_use)]
-#![allow(named_arguments_used_positionally)] // Unstable at time of writing.
-#![warn(clippy::positional_named_format_parameters)]
-
-use std::io::Write;
-
-fn main() {
-    let mut v = Vec::new();
-    let hello = "Hello";
-
-    println!("{hello:.foo$}", foo = 2);
-    writeln!(v, "{hello:.foo$}", foo = 2);
-
-    // Warnings
-    println!("{zero} {one:?}", zero = 0, one = 1);
-    println!("This is a test {zero} {one:?}", zero = 0, one = 1);
-    println!("Hello {one} is {two:.zero$}", zero = 5, one = hello, two = 0.01);
-    println!("Hello {one:zero$}!", zero = 5, one = 1);
-    println!("Hello {zero:one$}!", zero = 4, one = 1);
-    println!("Hello {zero:0one$}!", zero = 4, one = 1);
-    println!("Hello is {one:.zero$}", zero = 5, one = 0.01);
-    println!("Hello is {one:<6.zero$}", zero = 5, one = 0.01);
-    println!("{zero}, `{two:>8.one$}` has 3", zero = hello, one = 3, two = hello);
-    println!("Hello {one} is {two:.zero$}", zero = 5, one = hello, two = 0.01);
-    println!("Hello {world} {world}!", world = 5);
-
-    writeln!(v, "{zero} {one:?}", zero = 0, one = 1);
-    writeln!(v, "This is a test {zero} {one:?}", zero = 0, one = 1);
-    writeln!(v, "Hello {one} is {two:.zero$}", zero = 5, one = hello, two = 0.01);
-    writeln!(v, "Hello {one:zero$}!", zero = 4, one = 1);
-    writeln!(v, "Hello {zero:one$}!", zero = 4, one = 1);
-    writeln!(v, "Hello {zero:0one$}!", zero = 4, one = 1);
-    writeln!(v, "Hello is {one:.zero$}", zero = 3, one = 0.01);
-    writeln!(v, "Hello is {one:<6.zero$}", zero = 2, one = 0.01);
-    writeln!(v, "{zero}, `{two:>8.one$}` has 3", zero = hello, one = 3, two = hello);
-    writeln!(v, "Hello {one} is {two:.zero$}", zero = 1, one = hello, two = 0.01);
-    writeln!(v, "Hello {world} {world}!", world = 0);
-
-    // Tests from other files
-    println!("{w:w$}", w = 1);
-    println!("{p:.p$}", p = 1);
-    println!("{v}", v = 1);
-    println!("{v:v$}", v = 1);
-    println!("{v:v$}", v = 1);
-    println!("{v:v$.v$}", v = 1);
-    println!("{v:v$.v$}", v = 1);
-    println!("{v:v$.v$}", v = 1);
-    println!("{v:v$.v$}", v = 1);
-    println!("{v:v$.v$}", v = 1);
-    println!("{v:v$.v$}", v = 1);
-    println!("{v:v$.v$}", v = 1);
-    println!("{w:w$}", w = 1);
-    println!("{p:.p$}", p = 1);
-    println!("{:p$.w$}", 1, w = 1, p = 1);
-}
diff --git a/tests/ui/positional_named_format_parameters.rs b/tests/ui/positional_named_format_parameters.rs
deleted file mode 100644
index 553d8494ecc..00000000000
--- a/tests/ui/positional_named_format_parameters.rs
+++ /dev/null
@@ -1,56 +0,0 @@
-// run-rustfix
-#![allow(unused_must_use)]
-#![allow(named_arguments_used_positionally)] // Unstable at time of writing.
-#![warn(clippy::positional_named_format_parameters)]
-
-use std::io::Write;
-
-fn main() {
-    let mut v = Vec::new();
-    let hello = "Hello";
-
-    println!("{hello:.foo$}", foo = 2);
-    writeln!(v, "{hello:.foo$}", foo = 2);
-
-    // Warnings
-    println!("{} {1:?}", zero = 0, one = 1);
-    println!("This is a test { } {000001:?}", zero = 0, one = 1);
-    println!("Hello {1} is {2:.0$}", zero = 5, one = hello, two = 0.01);
-    println!("Hello {1:0$}!", zero = 5, one = 1);
-    println!("Hello {0:1$}!", zero = 4, one = 1);
-    println!("Hello {0:01$}!", zero = 4, one = 1);
-    println!("Hello is {1:.*}", zero = 5, one = 0.01);
-    println!("Hello is {:<6.*}", zero = 5, one = 0.01);
-    println!("{}, `{two:>8.*}` has 3", zero = hello, one = 3, two = hello);
-    println!("Hello {1} is {2:.0$}", zero = 5, one = hello, two = 0.01);
-    println!("Hello {world} {}!", world = 5);
-
-    writeln!(v, "{} {1:?}", zero = 0, one = 1);
-    writeln!(v, "This is a test { } {000001:?}", zero = 0, one = 1);
-    writeln!(v, "Hello {1} is {2:.0$}", zero = 5, one = hello, two = 0.01);
-    writeln!(v, "Hello {1:0$}!", zero = 4, one = 1);
-    writeln!(v, "Hello {0:1$}!", zero = 4, one = 1);
-    writeln!(v, "Hello {0:01$}!", zero = 4, one = 1);
-    writeln!(v, "Hello is {1:.*}", zero = 3, one = 0.01);
-    writeln!(v, "Hello is {:<6.*}", zero = 2, one = 0.01);
-    writeln!(v, "{}, `{two:>8.*}` has 3", zero = hello, one = 3, two = hello);
-    writeln!(v, "Hello {1} is {2:.0$}", zero = 1, one = hello, two = 0.01);
-    writeln!(v, "Hello {world} {}!", world = 0);
-
-    // Tests from other files
-    println!("{:w$}", w = 1);
-    println!("{:.p$}", p = 1);
-    println!("{}", v = 1);
-    println!("{:0$}", v = 1);
-    println!("{0:0$}", v = 1);
-    println!("{:0$.0$}", v = 1);
-    println!("{0:0$.0$}", v = 1);
-    println!("{0:0$.v$}", v = 1);
-    println!("{0:v$.0$}", v = 1);
-    println!("{v:0$.0$}", v = 1);
-    println!("{v:v$.0$}", v = 1);
-    println!("{v:0$.v$}", v = 1);
-    println!("{:w$}", w = 1);
-    println!("{:.p$}", p = 1);
-    println!("{:p$.w$}", 1, w = 1, p = 1);
-}
diff --git a/tests/ui/positional_named_format_parameters.stderr b/tests/ui/positional_named_format_parameters.stderr
deleted file mode 100644
index 48ddb6d67ad..00000000000
--- a/tests/ui/positional_named_format_parameters.stderr
+++ /dev/null
@@ -1,418 +0,0 @@
-error: named parameter zero is used as a positional parameter
-  --> $DIR/positional_named_format_parameters.rs:16:16
-   |
-LL |     println!("{} {1:?}", zero = 0, one = 1);
-   |                ^ help: replace it with: `zero`
-   |
-   = note: `-D clippy::positional-named-format-parameters` implied by `-D warnings`
-
-error: named parameter one is used as a positional parameter
-  --> $DIR/positional_named_format_parameters.rs:16:19
-   |
-LL |     println!("{} {1:?}", zero = 0, one = 1);
-   |                   ^ help: replace it with: `one`
-
-error: named parameter zero is used as a positional parameter
-  --> $DIR/positional_named_format_parameters.rs:17:31
-   |
-LL |     println!("This is a test { } {000001:?}", zero = 0, one = 1);
-   |                               ^ help: replace it with: `zero`
-
-error: named parameter one is used as a positional parameter
-  --> $DIR/positional_named_format_parameters.rs:17:35
-   |
-LL |     println!("This is a test { } {000001:?}", zero = 0, one = 1);
-   |                                   ^^^^^^ help: replace it with: `one`
-
-error: named parameter zero is used as a positional parameter
-  --> $DIR/positional_named_format_parameters.rs:18:32
-   |
-LL |     println!("Hello {1} is {2:.0$}", zero = 5, one = hello, two = 0.01);
-   |                                ^ help: replace it with: `zero`
-
-error: named parameter one is used as a positional parameter
-  --> $DIR/positional_named_format_parameters.rs:18:22
-   |
-LL |     println!("Hello {1} is {2:.0$}", zero = 5, one = hello, two = 0.01);
-   |                      ^ help: replace it with: `one`
-
-error: named parameter two is used as a positional parameter
-  --> $DIR/positional_named_format_parameters.rs:18:29
-   |
-LL |     println!("Hello {1} is {2:.0$}", zero = 5, one = hello, two = 0.01);
-   |                             ^ help: replace it with: `two`
-
-error: named parameter zero is used as a positional parameter
-  --> $DIR/positional_named_format_parameters.rs:19:24
-   |
-LL |     println!("Hello {1:0$}!", zero = 5, one = 1);
-   |                        ^ help: replace it with: `zero`
-
-error: named parameter one is used as a positional parameter
-  --> $DIR/positional_named_format_parameters.rs:19:22
-   |
-LL |     println!("Hello {1:0$}!", zero = 5, one = 1);
-   |                      ^ help: replace it with: `one`
-
-error: named parameter zero is used as a positional parameter
-  --> $DIR/positional_named_format_parameters.rs:20:22
-   |
-LL |     println!("Hello {0:1$}!", zero = 4, one = 1);
-   |                      ^ help: replace it with: `zero`
-
-error: named parameter one is used as a positional parameter
-  --> $DIR/positional_named_format_parameters.rs:20:24
-   |
-LL |     println!("Hello {0:1$}!", zero = 4, one = 1);
-   |                        ^ help: replace it with: `one`
-
-error: named parameter zero is used as a positional parameter
-  --> $DIR/positional_named_format_parameters.rs:21:22
-   |
-LL |     println!("Hello {0:01$}!", zero = 4, one = 1);
-   |                      ^ help: replace it with: `zero`
-
-error: named parameter one is used as a positional parameter
-  --> $DIR/positional_named_format_parameters.rs:21:25
-   |
-LL |     println!("Hello {0:01$}!", zero = 4, one = 1);
-   |                         ^ help: replace it with: `one`
-
-error: named parameter zero is used as a positional parameter
-  --> $DIR/positional_named_format_parameters.rs:22:28
-   |
-LL |     println!("Hello is {1:.*}", zero = 5, one = 0.01);
-   |                            ^ help: replace it with: `zero$`
-
-error: named parameter one is used as a positional parameter
-  --> $DIR/positional_named_format_parameters.rs:22:25
-   |
-LL |     println!("Hello is {1:.*}", zero = 5, one = 0.01);
-   |                         ^ help: replace it with: `one`
-
-error: named parameter zero is used as a positional parameter
-  --> $DIR/positional_named_format_parameters.rs:23:29
-   |
-LL |     println!("Hello is {:<6.*}", zero = 5, one = 0.01);
-   |                             ^ help: replace it with: `zero$`
-
-error: named parameter one is used as a positional parameter
-  --> $DIR/positional_named_format_parameters.rs:23:25
-   |
-LL |     println!("Hello is {:<6.*}", zero = 5, one = 0.01);
-   |                         ^ help: replace it with: `one`
-
-error: named parameter zero is used as a positional parameter
-  --> $DIR/positional_named_format_parameters.rs:24:16
-   |
-LL |     println!("{}, `{two:>8.*}` has 3", zero = hello, one = 3, two = hello);
-   |                ^ help: replace it with: `zero`
-
-error: named parameter one is used as a positional parameter
-  --> $DIR/positional_named_format_parameters.rs:24:28
-   |
-LL |     println!("{}, `{two:>8.*}` has 3", zero = hello, one = 3, two = hello);
-   |                            ^ help: replace it with: `one$`
-
-error: named parameter zero is used as a positional parameter
-  --> $DIR/positional_named_format_parameters.rs:25:32
-   |
-LL |     println!("Hello {1} is {2:.0$}", zero = 5, one = hello, two = 0.01);
-   |                                ^ help: replace it with: `zero`
-
-error: named parameter one is used as a positional parameter
-  --> $DIR/positional_named_format_parameters.rs:25:22
-   |
-LL |     println!("Hello {1} is {2:.0$}", zero = 5, one = hello, two = 0.01);
-   |                      ^ help: replace it with: `one`
-
-error: named parameter two is used as a positional parameter
-  --> $DIR/positional_named_format_parameters.rs:25:29
-   |
-LL |     println!("Hello {1} is {2:.0$}", zero = 5, one = hello, two = 0.01);
-   |                             ^ help: replace it with: `two`
-
-error: named parameter world is used as a positional parameter
-  --> $DIR/positional_named_format_parameters.rs:26:30
-   |
-LL |     println!("Hello {world} {}!", world = 5);
-   |                              ^ help: replace it with: `world`
-
-error: named parameter zero is used as a positional parameter
-  --> $DIR/positional_named_format_parameters.rs:28:19
-   |
-LL |     writeln!(v, "{} {1:?}", zero = 0, one = 1);
-   |                   ^ help: replace it with: `zero`
-
-error: named parameter one is used as a positional parameter
-  --> $DIR/positional_named_format_parameters.rs:28:22
-   |
-LL |     writeln!(v, "{} {1:?}", zero = 0, one = 1);
-   |                      ^ help: replace it with: `one`
-
-error: named parameter zero is used as a positional parameter
-  --> $DIR/positional_named_format_parameters.rs:29:34
-   |
-LL |     writeln!(v, "This is a test { } {000001:?}", zero = 0, one = 1);
-   |                                  ^ help: replace it with: `zero`
-
-error: named parameter one is used as a positional parameter
-  --> $DIR/positional_named_format_parameters.rs:29:38
-   |
-LL |     writeln!(v, "This is a test { } {000001:?}", zero = 0, one = 1);
-   |                                      ^^^^^^ help: replace it with: `one`
-
-error: named parameter zero is used as a positional parameter
-  --> $DIR/positional_named_format_parameters.rs:30:35
-   |
-LL |     writeln!(v, "Hello {1} is {2:.0$}", zero = 5, one = hello, two = 0.01);
-   |                                   ^ help: replace it with: `zero`
-
-error: named parameter one is used as a positional parameter
-  --> $DIR/positional_named_format_parameters.rs:30:25
-   |
-LL |     writeln!(v, "Hello {1} is {2:.0$}", zero = 5, one = hello, two = 0.01);
-   |                         ^ help: replace it with: `one`
-
-error: named parameter two is used as a positional parameter
-  --> $DIR/positional_named_format_parameters.rs:30:32
-   |
-LL |     writeln!(v, "Hello {1} is {2:.0$}", zero = 5, one = hello, two = 0.01);
-   |                                ^ help: replace it with: `two`
-
-error: named parameter zero is used as a positional parameter
-  --> $DIR/positional_named_format_parameters.rs:31:27
-   |
-LL |     writeln!(v, "Hello {1:0$}!", zero = 4, one = 1);
-   |                           ^ help: replace it with: `zero`
-
-error: named parameter one is used as a positional parameter
-  --> $DIR/positional_named_format_parameters.rs:31:25
-   |
-LL |     writeln!(v, "Hello {1:0$}!", zero = 4, one = 1);
-   |                         ^ help: replace it with: `one`
-
-error: named parameter zero is used as a positional parameter
-  --> $DIR/positional_named_format_parameters.rs:32:25
-   |
-LL |     writeln!(v, "Hello {0:1$}!", zero = 4, one = 1);
-   |                         ^ help: replace it with: `zero`
-
-error: named parameter one is used as a positional parameter
-  --> $DIR/positional_named_format_parameters.rs:32:27
-   |
-LL |     writeln!(v, "Hello {0:1$}!", zero = 4, one = 1);
-   |                           ^ help: replace it with: `one`
-
-error: named parameter zero is used as a positional parameter
-  --> $DIR/positional_named_format_parameters.rs:33:25
-   |
-LL |     writeln!(v, "Hello {0:01$}!", zero = 4, one = 1);
-   |                         ^ help: replace it with: `zero`
-
-error: named parameter one is used as a positional parameter
-  --> $DIR/positional_named_format_parameters.rs:33:28
-   |
-LL |     writeln!(v, "Hello {0:01$}!", zero = 4, one = 1);
-   |                            ^ help: replace it with: `one`
-
-error: named parameter zero is used as a positional parameter
-  --> $DIR/positional_named_format_parameters.rs:34:31
-   |
-LL |     writeln!(v, "Hello is {1:.*}", zero = 3, one = 0.01);
-   |                               ^ help: replace it with: `zero$`
-
-error: named parameter one is used as a positional parameter
-  --> $DIR/positional_named_format_parameters.rs:34:28
-   |
-LL |     writeln!(v, "Hello is {1:.*}", zero = 3, one = 0.01);
-   |                            ^ help: replace it with: `one`
-
-error: named parameter zero is used as a positional parameter
-  --> $DIR/positional_named_format_parameters.rs:35:32
-   |
-LL |     writeln!(v, "Hello is {:<6.*}", zero = 2, one = 0.01);
-   |                                ^ help: replace it with: `zero$`
-
-error: named parameter one is used as a positional parameter
-  --> $DIR/positional_named_format_parameters.rs:35:28
-   |
-LL |     writeln!(v, "Hello is {:<6.*}", zero = 2, one = 0.01);
-   |                            ^ help: replace it with: `one`
-
-error: named parameter zero is used as a positional parameter
-  --> $DIR/positional_named_format_parameters.rs:36:19
-   |
-LL |     writeln!(v, "{}, `{two:>8.*}` has 3", zero = hello, one = 3, two = hello);
-   |                   ^ help: replace it with: `zero`
-
-error: named parameter one is used as a positional parameter
-  --> $DIR/positional_named_format_parameters.rs:36:31
-   |
-LL |     writeln!(v, "{}, `{two:>8.*}` has 3", zero = hello, one = 3, two = hello);
-   |                               ^ help: replace it with: `one$`
-
-error: named parameter zero is used as a positional parameter
-  --> $DIR/positional_named_format_parameters.rs:37:35
-   |
-LL |     writeln!(v, "Hello {1} is {2:.0$}", zero = 1, one = hello, two = 0.01);
-   |                                   ^ help: replace it with: `zero`
-
-error: named parameter one is used as a positional parameter
-  --> $DIR/positional_named_format_parameters.rs:37:25
-   |
-LL |     writeln!(v, "Hello {1} is {2:.0$}", zero = 1, one = hello, two = 0.01);
-   |                         ^ help: replace it with: `one`
-
-error: named parameter two is used as a positional parameter
-  --> $DIR/positional_named_format_parameters.rs:37:32
-   |
-LL |     writeln!(v, "Hello {1} is {2:.0$}", zero = 1, one = hello, two = 0.01);
-   |                                ^ help: replace it with: `two`
-
-error: named parameter world is used as a positional parameter
-  --> $DIR/positional_named_format_parameters.rs:38:33
-   |
-LL |     writeln!(v, "Hello {world} {}!", world = 0);
-   |                                 ^ help: replace it with: `world`
-
-error: named parameter w is used as a positional parameter
-  --> $DIR/positional_named_format_parameters.rs:41:16
-   |
-LL |     println!("{:w$}", w = 1);
-   |                ^ help: replace it with: `w`
-
-error: named parameter p is used as a positional parameter
-  --> $DIR/positional_named_format_parameters.rs:42:16
-   |
-LL |     println!("{:.p$}", p = 1);
-   |                ^ help: replace it with: `p`
-
-error: named parameter v is used as a positional parameter
-  --> $DIR/positional_named_format_parameters.rs:43:16
-   |
-LL |     println!("{}", v = 1);
-   |                ^ help: replace it with: `v`
-
-error: named parameter v is used as a positional parameter
-  --> $DIR/positional_named_format_parameters.rs:44:16
-   |
-LL |     println!("{:0$}", v = 1);
-   |                ^ help: replace it with: `v`
-
-error: named parameter v is used as a positional parameter
-  --> $DIR/positional_named_format_parameters.rs:44:17
-   |
-LL |     println!("{:0$}", v = 1);
-   |                 ^ help: replace it with: `v`
-
-error: named parameter v is used as a positional parameter
-  --> $DIR/positional_named_format_parameters.rs:45:16
-   |
-LL |     println!("{0:0$}", v = 1);
-   |                ^ help: replace it with: `v`
-
-error: named parameter v is used as a positional parameter
-  --> $DIR/positional_named_format_parameters.rs:45:18
-   |
-LL |     println!("{0:0$}", v = 1);
-   |                  ^ help: replace it with: `v`
-
-error: named parameter v is used as a positional parameter
-  --> $DIR/positional_named_format_parameters.rs:46:16
-   |
-LL |     println!("{:0$.0$}", v = 1);
-   |                ^ help: replace it with: `v`
-
-error: named parameter v is used as a positional parameter
-  --> $DIR/positional_named_format_parameters.rs:46:20
-   |
-LL |     println!("{:0$.0$}", v = 1);
-   |                    ^ help: replace it with: `v`
-
-error: named parameter v is used as a positional parameter
-  --> $DIR/positional_named_format_parameters.rs:46:17
-   |
-LL |     println!("{:0$.0$}", v = 1);
-   |                 ^ help: replace it with: `v`
-
-error: named parameter v is used as a positional parameter
-  --> $DIR/positional_named_format_parameters.rs:47:16
-   |
-LL |     println!("{0:0$.0$}", v = 1);
-   |                ^ help: replace it with: `v`
-
-error: named parameter v is used as a positional parameter
-  --> $DIR/positional_named_format_parameters.rs:47:21
-   |
-LL |     println!("{0:0$.0$}", v = 1);
-   |                     ^ help: replace it with: `v`
-
-error: named parameter v is used as a positional parameter
-  --> $DIR/positional_named_format_parameters.rs:47:18
-   |
-LL |     println!("{0:0$.0$}", v = 1);
-   |                  ^ help: replace it with: `v`
-
-error: named parameter v is used as a positional parameter
-  --> $DIR/positional_named_format_parameters.rs:48:16
-   |
-LL |     println!("{0:0$.v$}", v = 1);
-   |                ^ help: replace it with: `v`
-
-error: named parameter v is used as a positional parameter
-  --> $DIR/positional_named_format_parameters.rs:48:18
-   |
-LL |     println!("{0:0$.v$}", v = 1);
-   |                  ^ help: replace it with: `v`
-
-error: named parameter v is used as a positional parameter
-  --> $DIR/positional_named_format_parameters.rs:49:16
-   |
-LL |     println!("{0:v$.0$}", v = 1);
-   |                ^ help: replace it with: `v`
-
-error: named parameter v is used as a positional parameter
-  --> $DIR/positional_named_format_parameters.rs:49:21
-   |
-LL |     println!("{0:v$.0$}", v = 1);
-   |                     ^ help: replace it with: `v`
-
-error: named parameter v is used as a positional parameter
-  --> $DIR/positional_named_format_parameters.rs:50:21
-   |
-LL |     println!("{v:0$.0$}", v = 1);
-   |                     ^ help: replace it with: `v`
-
-error: named parameter v is used as a positional parameter
-  --> $DIR/positional_named_format_parameters.rs:50:18
-   |
-LL |     println!("{v:0$.0$}", v = 1);
-   |                  ^ help: replace it with: `v`
-
-error: named parameter v is used as a positional parameter
-  --> $DIR/positional_named_format_parameters.rs:51:21
-   |
-LL |     println!("{v:v$.0$}", v = 1);
-   |                     ^ help: replace it with: `v`
-
-error: named parameter v is used as a positional parameter
-  --> $DIR/positional_named_format_parameters.rs:52:18
-   |
-LL |     println!("{v:0$.v$}", v = 1);
-   |                  ^ help: replace it with: `v`
-
-error: named parameter w is used as a positional parameter
-  --> $DIR/positional_named_format_parameters.rs:53:16
-   |
-LL |     println!("{:w$}", w = 1);
-   |                ^ help: replace it with: `w`
-
-error: named parameter p is used as a positional parameter
-  --> $DIR/positional_named_format_parameters.rs:54:16
-   |
-LL |     println!("{:.p$}", p = 1);
-   |                ^ help: replace it with: `p`
-
-error: aborting due to 69 previous errors
-
diff --git a/tests/ui/print_literal.rs b/tests/ui/print_literal.rs
index 8665a3bb28a..3f6639c1458 100644
--- a/tests/ui/print_literal.rs
+++ b/tests/ui/print_literal.rs
@@ -20,11 +20,13 @@ fn main() {
     println!("{} of {:b} people know binary, the other half doesn't", 1, 2);
     println!("10 / 4 is {}", 2.5);
     println!("2 + 1 = {}", 3);
+    println!("From expansion {}", stringify!(not a string literal));
 
     // these should throw warnings
     print!("Hello {}", "world");
     println!("Hello {} {}", world, "world");
     println!("Hello {}", "world");
+    println!("{} {:.4}", "a literal", 5);
 
     // positional args don't change the fact
     // that we're using a literal -- this should
diff --git a/tests/ui/print_literal.stderr b/tests/ui/print_literal.stderr
index 72aae075603..23e6dbc3e34 100644
--- a/tests/ui/print_literal.stderr
+++ b/tests/ui/print_literal.stderr
@@ -1,5 +1,5 @@
 error: literal with an empty format string
-  --> $DIR/print_literal.rs:25:24
+  --> $DIR/print_literal.rs:26:24
    |
 LL |     print!("Hello {}", "world");
    |                        ^^^^^^^
@@ -12,7 +12,7 @@ LL +     print!("Hello world");
    |
 
 error: literal with an empty format string
-  --> $DIR/print_literal.rs:26:36
+  --> $DIR/print_literal.rs:27:36
    |
 LL |     println!("Hello {} {}", world, "world");
    |                                    ^^^^^^^
@@ -24,7 +24,7 @@ LL +     println!("Hello {} world", world);
    |
 
 error: literal with an empty format string
-  --> $DIR/print_literal.rs:27:26
+  --> $DIR/print_literal.rs:28:26
    |
 LL |     println!("Hello {}", "world");
    |                          ^^^^^^^
@@ -36,7 +36,19 @@ LL +     println!("Hello world");
    |
 
 error: literal with an empty format string
-  --> $DIR/print_literal.rs:32:25
+  --> $DIR/print_literal.rs:29:26
+   |
+LL |     println!("{} {:.4}", "a literal", 5);
+   |                          ^^^^^^^^^^^
+   |
+help: try this
+   |
+LL -     println!("{} {:.4}", "a literal", 5);
+LL +     println!("a literal {:.4}", 5);
+   |
+
+error: literal with an empty format string
+  --> $DIR/print_literal.rs:34:25
    |
 LL |     println!("{0} {1}", "hello", "world");
    |                         ^^^^^^^
@@ -48,7 +60,7 @@ LL +     println!("hello {1}", "world");
    |
 
 error: literal with an empty format string
-  --> $DIR/print_literal.rs:32:34
+  --> $DIR/print_literal.rs:34:34
    |
 LL |     println!("{0} {1}", "hello", "world");
    |                                  ^^^^^^^
@@ -60,34 +72,34 @@ LL +     println!("{0} world", "hello");
    |
 
 error: literal with an empty format string
-  --> $DIR/print_literal.rs:33:25
+  --> $DIR/print_literal.rs:35:34
    |
 LL |     println!("{1} {0}", "hello", "world");
-   |                         ^^^^^^^
+   |                                  ^^^^^^^
    |
 help: try this
    |
 LL -     println!("{1} {0}", "hello", "world");
-LL +     println!("{1} hello", "world");
+LL +     println!("world {0}", "hello");
    |
 
 error: literal with an empty format string
-  --> $DIR/print_literal.rs:33:34
+  --> $DIR/print_literal.rs:35:25
    |
 LL |     println!("{1} {0}", "hello", "world");
-   |                                  ^^^^^^^
+   |                         ^^^^^^^
    |
 help: try this
    |
 LL -     println!("{1} {0}", "hello", "world");
-LL +     println!("world {0}", "hello");
+LL +     println!("{1} hello", "world");
    |
 
 error: literal with an empty format string
-  --> $DIR/print_literal.rs:36:29
+  --> $DIR/print_literal.rs:38:35
    |
 LL |     println!("{foo} {bar}", foo = "hello", bar = "world");
-   |                             ^^^^^^^^^^^^^
+   |                                   ^^^^^^^
    |
 help: try this
    |
@@ -96,10 +108,10 @@ LL +     println!("hello {bar}", bar = "world");
    |
 
 error: literal with an empty format string
-  --> $DIR/print_literal.rs:36:44
+  --> $DIR/print_literal.rs:38:50
    |
 LL |     println!("{foo} {bar}", foo = "hello", bar = "world");
-   |                                            ^^^^^^^^^^^^^
+   |                                                  ^^^^^^^
    |
 help: try this
    |
@@ -108,28 +120,28 @@ LL +     println!("{foo} world", foo = "hello");
    |
 
 error: literal with an empty format string
-  --> $DIR/print_literal.rs:37:29
+  --> $DIR/print_literal.rs:39:50
    |
 LL |     println!("{bar} {foo}", foo = "hello", bar = "world");
-   |                             ^^^^^^^^^^^^^
+   |                                                  ^^^^^^^
    |
 help: try this
    |
 LL -     println!("{bar} {foo}", foo = "hello", bar = "world");
-LL +     println!("{bar} hello", bar = "world");
+LL +     println!("world {foo}", foo = "hello");
    |
 
 error: literal with an empty format string
-  --> $DIR/print_literal.rs:37:44
+  --> $DIR/print_literal.rs:39:35
    |
 LL |     println!("{bar} {foo}", foo = "hello", bar = "world");
-   |                                            ^^^^^^^^^^^^^
+   |                                   ^^^^^^^
    |
 help: try this
    |
 LL -     println!("{bar} {foo}", foo = "hello", bar = "world");
-LL +     println!("world {foo}", foo = "hello");
+LL +     println!("{bar} hello", bar = "world");
    |
 
-error: aborting due to 11 previous errors
+error: aborting due to 12 previous errors
 
diff --git a/tests/ui/print_with_newline.rs b/tests/ui/print_with_newline.rs
index a43a1fc4f52..b8c29d207ad 100644
--- a/tests/ui/print_with_newline.rs
+++ b/tests/ui/print_with_newline.rs
@@ -48,5 +48,13 @@ fn main() {
     print!("\r\n");
     print!("foo\r\n");
     print!("\\r\n"); //~ ERROR
-    print!("foo\rbar\n") // ~ ERROR
+    print!("foo\rbar\n");
+
+    // Ignore expanded format strings
+    macro_rules! newline {
+        () => {
+            "\n"
+        };
+    }
+    print!(newline!());
 }
diff --git a/tests/ui/print_with_newline.stderr b/tests/ui/print_with_newline.stderr
index edbaa1cdf97..b9f5675faec 100644
--- a/tests/ui/print_with_newline.stderr
+++ b/tests/ui/print_with_newline.stderr
@@ -83,7 +83,7 @@ LL | |     );
 help: use `println!` instead
    |
 LL ~     println!(
-LL ~         ""
+LL ~         
    |
 
 error: using `print!()` with a format string that ends in a single newline
@@ -98,7 +98,7 @@ LL | |     );
 help: use `println!` instead
    |
 LL ~     println!(
-LL ~         r""
+LL ~         
    |
 
 error: using `print!()` with a format string that ends in a single newline
@@ -113,17 +113,5 @@ LL -     print!("/r/n"); //~ ERROR
 LL +     println!("/r"); //~ ERROR
    |
 
-error: using `print!()` with a format string that ends in a single newline
-  --> $DIR/print_with_newline.rs:51:5
-   |
-LL |     print!("foo/rbar/n") // ~ ERROR
-   |     ^^^^^^^^^^^^^^^^^^^^
-   |
-help: use `println!` instead
-   |
-LL -     print!("foo/rbar/n") // ~ ERROR
-LL +     println!("foo/rbar") // ~ ERROR
-   |
-
-error: aborting due to 10 previous errors
+error: aborting due to 9 previous errors
 
diff --git a/tests/ui/println_empty_string.stderr b/tests/ui/println_empty_string.stderr
index 17fe4ea7479..3cc8bb947bd 100644
--- a/tests/ui/println_empty_string.stderr
+++ b/tests/ui/println_empty_string.stderr
@@ -1,28 +1,36 @@
-error: using `println!("")`
+error: empty string literal in `println!`
   --> $DIR/println_empty_string.rs:6:5
    |
 LL |     println!("");
-   |     ^^^^^^^^^^^^ help: replace it with: `println!()`
+   |     ^^^^^^^^^--^
+   |              |
+   |              help: remove the empty string
    |
    = note: `-D clippy::println-empty-string` implied by `-D warnings`
 
-error: using `println!("")`
+error: empty string literal in `println!`
   --> $DIR/println_empty_string.rs:9:14
    |
 LL |         _ => println!(""),
-   |              ^^^^^^^^^^^^ help: replace it with: `println!()`
+   |              ^^^^^^^^^--^
+   |                       |
+   |                       help: remove the empty string
 
-error: using `eprintln!("")`
+error: empty string literal in `eprintln!`
   --> $DIR/println_empty_string.rs:13:5
    |
 LL |     eprintln!("");
-   |     ^^^^^^^^^^^^^ help: replace it with: `eprintln!()`
+   |     ^^^^^^^^^^--^
+   |               |
+   |               help: remove the empty string
 
-error: using `eprintln!("")`
+error: empty string literal in `eprintln!`
   --> $DIR/println_empty_string.rs:16:14
    |
 LL |         _ => eprintln!(""),
-   |              ^^^^^^^^^^^^^ help: replace it with: `eprintln!()`
+   |              ^^^^^^^^^^--^
+   |                        |
+   |                        help: remove the empty string
 
 error: aborting due to 4 previous errors
 
diff --git a/tests/ui/rename.fixed b/tests/ui/rename.fixed
index 9cbad2269a0..a6e7bdba77c 100644
--- a/tests/ui/rename.fixed
+++ b/tests/ui/rename.fixed
@@ -32,6 +32,7 @@
 #![allow(invalid_value)]
 #![allow(enum_intrinsics_non_enums)]
 #![allow(non_fmt_panics)]
+#![allow(named_arguments_used_positionally)]
 #![allow(temporary_cstring_as_ptr)]
 #![allow(unknown_lints)]
 #![allow(unused_labels)]
@@ -69,6 +70,7 @@
 #![warn(invalid_value)]
 #![warn(enum_intrinsics_non_enums)]
 #![warn(non_fmt_panics)]
+#![warn(named_arguments_used_positionally)]
 #![warn(temporary_cstring_as_ptr)]
 #![warn(unknown_lints)]
 #![warn(unused_labels)]
diff --git a/tests/ui/rename.rs b/tests/ui/rename.rs
index 9153c0dab02..e8f57597d02 100644
--- a/tests/ui/rename.rs
+++ b/tests/ui/rename.rs
@@ -32,6 +32,7 @@
 #![allow(invalid_value)]
 #![allow(enum_intrinsics_non_enums)]
 #![allow(non_fmt_panics)]
+#![allow(named_arguments_used_positionally)]
 #![allow(temporary_cstring_as_ptr)]
 #![allow(unknown_lints)]
 #![allow(unused_labels)]
@@ -69,6 +70,7 @@
 #![warn(clippy::invalid_ref)]
 #![warn(clippy::mem_discriminant_non_enum)]
 #![warn(clippy::panic_params)]
+#![warn(clippy::positional_named_format_parameters)]
 #![warn(clippy::temporary_cstring_as_ptr)]
 #![warn(clippy::unknown_clippy_lints)]
 #![warn(clippy::unused_label)]
diff --git a/tests/ui/rename.stderr b/tests/ui/rename.stderr
index 9c03ea914bb..31865a7f66d 100644
--- a/tests/ui/rename.stderr
+++ b/tests/ui/rename.stderr
@@ -1,5 +1,5 @@
 error: lint `clippy::blacklisted_name` has been renamed to `clippy::disallowed_names`
-  --> $DIR/rename.rs:38:9
+  --> $DIR/rename.rs:39:9
    |
 LL | #![warn(clippy::blacklisted_name)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::disallowed_names`
@@ -7,220 +7,226 @@ LL | #![warn(clippy::blacklisted_name)]
    = note: `-D renamed-and-removed-lints` implied by `-D warnings`
 
 error: lint `clippy::block_in_if_condition_expr` has been renamed to `clippy::blocks_in_if_conditions`
-  --> $DIR/rename.rs:39:9
+  --> $DIR/rename.rs:40:9
    |
 LL | #![warn(clippy::block_in_if_condition_expr)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::blocks_in_if_conditions`
 
 error: lint `clippy::block_in_if_condition_stmt` has been renamed to `clippy::blocks_in_if_conditions`
-  --> $DIR/rename.rs:40:9
+  --> $DIR/rename.rs:41:9
    |
 LL | #![warn(clippy::block_in_if_condition_stmt)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::blocks_in_if_conditions`
 
 error: lint `clippy::box_vec` has been renamed to `clippy::box_collection`
-  --> $DIR/rename.rs:41:9
+  --> $DIR/rename.rs:42:9
    |
 LL | #![warn(clippy::box_vec)]
    |         ^^^^^^^^^^^^^^^ help: use the new name: `clippy::box_collection`
 
 error: lint `clippy::const_static_lifetime` has been renamed to `clippy::redundant_static_lifetimes`
-  --> $DIR/rename.rs:42:9
+  --> $DIR/rename.rs:43:9
    |
 LL | #![warn(clippy::const_static_lifetime)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::redundant_static_lifetimes`
 
 error: lint `clippy::cyclomatic_complexity` has been renamed to `clippy::cognitive_complexity`
-  --> $DIR/rename.rs:43:9
+  --> $DIR/rename.rs:44:9
    |
 LL | #![warn(clippy::cyclomatic_complexity)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::cognitive_complexity`
 
 error: lint `clippy::disallowed_method` has been renamed to `clippy::disallowed_methods`
-  --> $DIR/rename.rs:44:9
+  --> $DIR/rename.rs:45:9
    |
 LL | #![warn(clippy::disallowed_method)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::disallowed_methods`
 
 error: lint `clippy::disallowed_type` has been renamed to `clippy::disallowed_types`
-  --> $DIR/rename.rs:45:9
+  --> $DIR/rename.rs:46:9
    |
 LL | #![warn(clippy::disallowed_type)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::disallowed_types`
 
 error: lint `clippy::eval_order_dependence` has been renamed to `clippy::mixed_read_write_in_expression`
-  --> $DIR/rename.rs:46:9
+  --> $DIR/rename.rs:47:9
    |
 LL | #![warn(clippy::eval_order_dependence)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::mixed_read_write_in_expression`
 
 error: lint `clippy::for_loop_over_option` has been renamed to `clippy::for_loops_over_fallibles`
-  --> $DIR/rename.rs:47:9
+  --> $DIR/rename.rs:48:9
    |
 LL | #![warn(clippy::for_loop_over_option)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::for_loops_over_fallibles`
 
 error: lint `clippy::for_loop_over_result` has been renamed to `clippy::for_loops_over_fallibles`
-  --> $DIR/rename.rs:48:9
+  --> $DIR/rename.rs:49:9
    |
 LL | #![warn(clippy::for_loop_over_result)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::for_loops_over_fallibles`
 
 error: lint `clippy::identity_conversion` has been renamed to `clippy::useless_conversion`
-  --> $DIR/rename.rs:49:9
+  --> $DIR/rename.rs:50:9
    |
 LL | #![warn(clippy::identity_conversion)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::useless_conversion`
 
 error: lint `clippy::if_let_some_result` has been renamed to `clippy::match_result_ok`
-  --> $DIR/rename.rs:50:9
+  --> $DIR/rename.rs:51:9
    |
 LL | #![warn(clippy::if_let_some_result)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::match_result_ok`
 
 error: lint `clippy::logic_bug` has been renamed to `clippy::overly_complex_bool_expr`
-  --> $DIR/rename.rs:51:9
+  --> $DIR/rename.rs:52:9
    |
 LL | #![warn(clippy::logic_bug)]
    |         ^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::overly_complex_bool_expr`
 
 error: lint `clippy::new_without_default_derive` has been renamed to `clippy::new_without_default`
-  --> $DIR/rename.rs:52:9
+  --> $DIR/rename.rs:53:9
    |
 LL | #![warn(clippy::new_without_default_derive)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::new_without_default`
 
 error: lint `clippy::option_and_then_some` has been renamed to `clippy::bind_instead_of_map`
-  --> $DIR/rename.rs:53:9
+  --> $DIR/rename.rs:54:9
    |
 LL | #![warn(clippy::option_and_then_some)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::bind_instead_of_map`
 
 error: lint `clippy::option_expect_used` has been renamed to `clippy::expect_used`
-  --> $DIR/rename.rs:54:9
+  --> $DIR/rename.rs:55:9
    |
 LL | #![warn(clippy::option_expect_used)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::expect_used`
 
 error: lint `clippy::option_map_unwrap_or` has been renamed to `clippy::map_unwrap_or`
-  --> $DIR/rename.rs:55:9
+  --> $DIR/rename.rs:56:9
    |
 LL | #![warn(clippy::option_map_unwrap_or)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::map_unwrap_or`
 
 error: lint `clippy::option_map_unwrap_or_else` has been renamed to `clippy::map_unwrap_or`
-  --> $DIR/rename.rs:56:9
+  --> $DIR/rename.rs:57:9
    |
 LL | #![warn(clippy::option_map_unwrap_or_else)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::map_unwrap_or`
 
 error: lint `clippy::option_unwrap_used` has been renamed to `clippy::unwrap_used`
-  --> $DIR/rename.rs:57:9
+  --> $DIR/rename.rs:58:9
    |
 LL | #![warn(clippy::option_unwrap_used)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::unwrap_used`
 
 error: lint `clippy::ref_in_deref` has been renamed to `clippy::needless_borrow`
-  --> $DIR/rename.rs:58:9
+  --> $DIR/rename.rs:59:9
    |
 LL | #![warn(clippy::ref_in_deref)]
    |         ^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::needless_borrow`
 
 error: lint `clippy::result_expect_used` has been renamed to `clippy::expect_used`
-  --> $DIR/rename.rs:59:9
+  --> $DIR/rename.rs:60:9
    |
 LL | #![warn(clippy::result_expect_used)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::expect_used`
 
 error: lint `clippy::result_map_unwrap_or_else` has been renamed to `clippy::map_unwrap_or`
-  --> $DIR/rename.rs:60:9
+  --> $DIR/rename.rs:61:9
    |
 LL | #![warn(clippy::result_map_unwrap_or_else)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::map_unwrap_or`
 
 error: lint `clippy::result_unwrap_used` has been renamed to `clippy::unwrap_used`
-  --> $DIR/rename.rs:61:9
+  --> $DIR/rename.rs:62:9
    |
 LL | #![warn(clippy::result_unwrap_used)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::unwrap_used`
 
 error: lint `clippy::single_char_push_str` has been renamed to `clippy::single_char_add_str`
-  --> $DIR/rename.rs:62:9
+  --> $DIR/rename.rs:63:9
    |
 LL | #![warn(clippy::single_char_push_str)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::single_char_add_str`
 
 error: lint `clippy::stutter` has been renamed to `clippy::module_name_repetitions`
-  --> $DIR/rename.rs:63:9
+  --> $DIR/rename.rs:64:9
    |
 LL | #![warn(clippy::stutter)]
    |         ^^^^^^^^^^^^^^^ help: use the new name: `clippy::module_name_repetitions`
 
 error: lint `clippy::to_string_in_display` has been renamed to `clippy::recursive_format_impl`
-  --> $DIR/rename.rs:64:9
+  --> $DIR/rename.rs:65:9
    |
 LL | #![warn(clippy::to_string_in_display)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::recursive_format_impl`
 
 error: lint `clippy::zero_width_space` has been renamed to `clippy::invisible_characters`
-  --> $DIR/rename.rs:65:9
+  --> $DIR/rename.rs:66:9
    |
 LL | #![warn(clippy::zero_width_space)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::invisible_characters`
 
 error: lint `clippy::drop_bounds` has been renamed to `drop_bounds`
-  --> $DIR/rename.rs:66:9
+  --> $DIR/rename.rs:67:9
    |
 LL | #![warn(clippy::drop_bounds)]
    |         ^^^^^^^^^^^^^^^^^^^ help: use the new name: `drop_bounds`
 
 error: lint `clippy::into_iter_on_array` has been renamed to `array_into_iter`
-  --> $DIR/rename.rs:67:9
+  --> $DIR/rename.rs:68:9
    |
 LL | #![warn(clippy::into_iter_on_array)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `array_into_iter`
 
 error: lint `clippy::invalid_atomic_ordering` has been renamed to `invalid_atomic_ordering`
-  --> $DIR/rename.rs:68:9
+  --> $DIR/rename.rs:69:9
    |
 LL | #![warn(clippy::invalid_atomic_ordering)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `invalid_atomic_ordering`
 
 error: lint `clippy::invalid_ref` has been renamed to `invalid_value`
-  --> $DIR/rename.rs:69:9
+  --> $DIR/rename.rs:70:9
    |
 LL | #![warn(clippy::invalid_ref)]
    |         ^^^^^^^^^^^^^^^^^^^ help: use the new name: `invalid_value`
 
 error: lint `clippy::mem_discriminant_non_enum` has been renamed to `enum_intrinsics_non_enums`
-  --> $DIR/rename.rs:70:9
+  --> $DIR/rename.rs:71:9
    |
 LL | #![warn(clippy::mem_discriminant_non_enum)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `enum_intrinsics_non_enums`
 
 error: lint `clippy::panic_params` has been renamed to `non_fmt_panics`
-  --> $DIR/rename.rs:71:9
+  --> $DIR/rename.rs:72:9
    |
 LL | #![warn(clippy::panic_params)]
    |         ^^^^^^^^^^^^^^^^^^^^ help: use the new name: `non_fmt_panics`
 
+error: lint `clippy::positional_named_format_parameters` has been renamed to `named_arguments_used_positionally`
+  --> $DIR/rename.rs:73:9
+   |
+LL | #![warn(clippy::positional_named_format_parameters)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `named_arguments_used_positionally`
+
 error: lint `clippy::temporary_cstring_as_ptr` has been renamed to `temporary_cstring_as_ptr`
-  --> $DIR/rename.rs:72:9
+  --> $DIR/rename.rs:74:9
    |
 LL | #![warn(clippy::temporary_cstring_as_ptr)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `temporary_cstring_as_ptr`
 
 error: lint `clippy::unknown_clippy_lints` has been renamed to `unknown_lints`
-  --> $DIR/rename.rs:73:9
+  --> $DIR/rename.rs:75:9
    |
 LL | #![warn(clippy::unknown_clippy_lints)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `unknown_lints`
 
 error: lint `clippy::unused_label` has been renamed to `unused_labels`
-  --> $DIR/rename.rs:74:9
+  --> $DIR/rename.rs:76:9
    |
 LL | #![warn(clippy::unused_label)]
    |         ^^^^^^^^^^^^^^^^^^^^ help: use the new name: `unused_labels`
 
-error: aborting due to 37 previous errors
+error: aborting due to 38 previous errors
 
diff --git a/tests/ui/write_literal.rs b/tests/ui/write_literal.rs
index 44669174411..5892818aa9a 100644
--- a/tests/ui/write_literal.rs
+++ b/tests/ui/write_literal.rs
@@ -25,11 +25,13 @@ fn main() {
     writeln!(v, "{} of {:b} people know binary, the other half doesn't", 1, 2);
     writeln!(v, "10 / 4 is {}", 2.5);
     writeln!(v, "2 + 1 = {}", 3);
+    writeln!(v, "From expansion {}", stringify!(not a string literal));
 
     // these should throw warnings
     write!(v, "Hello {}", "world");
     writeln!(v, "Hello {} {}", world, "world");
     writeln!(v, "Hello {}", "world");
+    writeln!(v, "{} {:.4}", "a literal", 5);
 
     // positional args don't change the fact
     // that we're using a literal -- this should
diff --git a/tests/ui/write_literal.stderr b/tests/ui/write_literal.stderr
index 3c5ec91d3e0..1e306ae28a2 100644
--- a/tests/ui/write_literal.stderr
+++ b/tests/ui/write_literal.stderr
@@ -1,5 +1,5 @@
 error: literal with an empty format string
-  --> $DIR/write_literal.rs:30:27
+  --> $DIR/write_literal.rs:31:27
    |
 LL |     write!(v, "Hello {}", "world");
    |                           ^^^^^^^
@@ -12,7 +12,7 @@ LL +     write!(v, "Hello world");
    |
 
 error: literal with an empty format string
-  --> $DIR/write_literal.rs:31:39
+  --> $DIR/write_literal.rs:32:39
    |
 LL |     writeln!(v, "Hello {} {}", world, "world");
    |                                       ^^^^^^^
@@ -24,7 +24,7 @@ LL +     writeln!(v, "Hello {} world", world);
    |
 
 error: literal with an empty format string
-  --> $DIR/write_literal.rs:32:29
+  --> $DIR/write_literal.rs:33:29
    |
 LL |     writeln!(v, "Hello {}", "world");
    |                             ^^^^^^^
@@ -36,7 +36,19 @@ LL +     writeln!(v, "Hello world");
    |
 
 error: literal with an empty format string
-  --> $DIR/write_literal.rs:37:28
+  --> $DIR/write_literal.rs:34:29
+   |
+LL |     writeln!(v, "{} {:.4}", "a literal", 5);
+   |                             ^^^^^^^^^^^
+   |
+help: try this
+   |
+LL -     writeln!(v, "{} {:.4}", "a literal", 5);
+LL +     writeln!(v, "a literal {:.4}", 5);
+   |
+
+error: literal with an empty format string
+  --> $DIR/write_literal.rs:39:28
    |
 LL |     writeln!(v, "{0} {1}", "hello", "world");
    |                            ^^^^^^^
@@ -48,7 +60,7 @@ LL +     writeln!(v, "hello {1}", "world");
    |
 
 error: literal with an empty format string
-  --> $DIR/write_literal.rs:37:37
+  --> $DIR/write_literal.rs:39:37
    |
 LL |     writeln!(v, "{0} {1}", "hello", "world");
    |                                     ^^^^^^^
@@ -60,34 +72,34 @@ LL +     writeln!(v, "{0} world", "hello");
    |
 
 error: literal with an empty format string
-  --> $DIR/write_literal.rs:38:28
+  --> $DIR/write_literal.rs:40:37
    |
 LL |     writeln!(v, "{1} {0}", "hello", "world");
-   |                            ^^^^^^^
+   |                                     ^^^^^^^
    |
 help: try this
    |
 LL -     writeln!(v, "{1} {0}", "hello", "world");
-LL +     writeln!(v, "{1} hello", "world");
+LL +     writeln!(v, "world {0}", "hello");
    |
 
 error: literal with an empty format string
-  --> $DIR/write_literal.rs:38:37
+  --> $DIR/write_literal.rs:40:28
    |
 LL |     writeln!(v, "{1} {0}", "hello", "world");
-   |                                     ^^^^^^^
+   |                            ^^^^^^^
    |
 help: try this
    |
 LL -     writeln!(v, "{1} {0}", "hello", "world");
-LL +     writeln!(v, "world {0}", "hello");
+LL +     writeln!(v, "{1} hello", "world");
    |
 
 error: literal with an empty format string
-  --> $DIR/write_literal.rs:41:32
+  --> $DIR/write_literal.rs:43:38
    |
 LL |     writeln!(v, "{foo} {bar}", foo = "hello", bar = "world");
-   |                                ^^^^^^^^^^^^^
+   |                                      ^^^^^^^
    |
 help: try this
    |
@@ -96,10 +108,10 @@ LL +     writeln!(v, "hello {bar}", bar = "world");
    |
 
 error: literal with an empty format string
-  --> $DIR/write_literal.rs:41:47
+  --> $DIR/write_literal.rs:43:53
    |
 LL |     writeln!(v, "{foo} {bar}", foo = "hello", bar = "world");
-   |                                               ^^^^^^^^^^^^^
+   |                                                     ^^^^^^^
    |
 help: try this
    |
@@ -108,28 +120,28 @@ LL +     writeln!(v, "{foo} world", foo = "hello");
    |
 
 error: literal with an empty format string
-  --> $DIR/write_literal.rs:42:32
+  --> $DIR/write_literal.rs:44:53
    |
 LL |     writeln!(v, "{bar} {foo}", foo = "hello", bar = "world");
-   |                                ^^^^^^^^^^^^^
+   |                                                     ^^^^^^^
    |
 help: try this
    |
 LL -     writeln!(v, "{bar} {foo}", foo = "hello", bar = "world");
-LL +     writeln!(v, "{bar} hello", bar = "world");
+LL +     writeln!(v, "world {foo}", foo = "hello");
    |
 
 error: literal with an empty format string
-  --> $DIR/write_literal.rs:42:47
+  --> $DIR/write_literal.rs:44:38
    |
 LL |     writeln!(v, "{bar} {foo}", foo = "hello", bar = "world");
-   |                                               ^^^^^^^^^^^^^
+   |                                      ^^^^^^^
    |
 help: try this
    |
 LL -     writeln!(v, "{bar} {foo}", foo = "hello", bar = "world");
-LL +     writeln!(v, "world {foo}", foo = "hello");
+LL +     writeln!(v, "{bar} hello", bar = "world");
    |
 
-error: aborting due to 11 previous errors
+error: aborting due to 12 previous errors
 
diff --git a/tests/ui/write_literal_2.rs b/tests/ui/write_literal_2.rs
index ba0d7be5eaa..55a11daa1d3 100644
--- a/tests/ui/write_literal_2.rs
+++ b/tests/ui/write_literal_2.rs
@@ -10,7 +10,7 @@ fn main() {
     writeln!(v, r"{}", r"{hello}");
     writeln!(v, "{}", '\'');
     writeln!(v, "{}", '"');
-    writeln!(v, r"{}", '"'); // don't lint
+    writeln!(v, r"{}", '"');
     writeln!(v, r"{}", '\'');
     writeln!(
         v,
@@ -24,4 +24,11 @@ fn main() {
         {} \\ {}",
         "1", "2", "3",
     );
+    writeln!(v, "{}", "\\");
+    writeln!(v, r"{}", "\\");
+    writeln!(v, r#"{}"#, "\\");
+    writeln!(v, "{}", r"\");
+    writeln!(v, "{}", "\r");
+    writeln!(v, r#"{}{}"#, '#', '"'); // hard mode
+    writeln!(v, r"{}", "\r"); // should not lint
 }
diff --git a/tests/ui/write_literal_2.stderr b/tests/ui/write_literal_2.stderr
index 9ff297069c4..d5956db9ff0 100644
--- a/tests/ui/write_literal_2.stderr
+++ b/tests/ui/write_literal_2.stderr
@@ -47,6 +47,12 @@ LL -     writeln!(v, "{}", '"');
 LL +     writeln!(v, "/"");
    |
 
+error: literal with an empty format string
+  --> $DIR/write_literal_2.rs:13:24
+   |
+LL |     writeln!(v, r"{}", '"');
+   |                        ^^^
+
 error: literal with an empty format string
   --> $DIR/write_literal_2.rs:14:24
    |
@@ -108,5 +114,77 @@ LL ~         {} / 3",
 LL ~         "1", "2",
    |
 
-error: aborting due to 9 previous errors
+error: literal with an empty format string
+  --> $DIR/write_literal_2.rs:27:23
+   |
+LL |     writeln!(v, "{}", "/");
+   |                       ^^^^
+   |
+help: try this
+   |
+LL -     writeln!(v, "{}", "/");
+LL +     writeln!(v, "/");
+   |
+
+error: literal with an empty format string
+  --> $DIR/write_literal_2.rs:28:24
+   |
+LL |     writeln!(v, r"{}", "/");
+   |                        ^^^^
+   |
+help: try this
+   |
+LL -     writeln!(v, r"{}", "/");
+LL +     writeln!(v, r"/");
+   |
+
+error: literal with an empty format string
+  --> $DIR/write_literal_2.rs:29:26
+   |
+LL |     writeln!(v, r#"{}"#, "/");
+   |                          ^^^^
+   |
+help: try this
+   |
+LL -     writeln!(v, r#"{}"#, "/");
+LL +     writeln!(v, r#"/"#);
+   |
+
+error: literal with an empty format string
+  --> $DIR/write_literal_2.rs:30:23
+   |
+LL |     writeln!(v, "{}", r"/");
+   |                       ^^^^
+   |
+help: try this
+   |
+LL -     writeln!(v, "{}", r"/");
+LL +     writeln!(v, "/");
+   |
+
+error: literal with an empty format string
+  --> $DIR/write_literal_2.rs:31:23
+   |
+LL |     writeln!(v, "{}", "/r");
+   |                       ^^^^
+   |
+help: try this
+   |
+LL -     writeln!(v, "{}", "/r");
+LL +     writeln!(v, "/r");
+   |
+
+error: literal with an empty format string
+  --> $DIR/write_literal_2.rs:32:28
+   |
+LL |     writeln!(v, r#"{}{}"#, '#', '"'); // hard mode
+   |                            ^^^
+
+error: literal with an empty format string
+  --> $DIR/write_literal_2.rs:32:33
+   |
+LL |     writeln!(v, r#"{}{}"#, '#', '"'); // hard mode
+   |                                 ^^^
+
+error: aborting due to 17 previous errors
 
diff --git a/tests/ui/write_with_newline.rs b/tests/ui/write_with_newline.rs
index 446d6914d34..b79364c8758 100644
--- a/tests/ui/write_with_newline.rs
+++ b/tests/ui/write_with_newline.rs
@@ -56,4 +56,12 @@ fn main() {
     write!(v, "foo\r\n");
     write!(v, "\\r\n"); //~ ERROR
     write!(v, "foo\rbar\n");
+
+    // Ignore expanded format strings
+    macro_rules! newline {
+        () => {
+            "\n"
+        };
+    }
+    write!(v, newline!());
 }
diff --git a/tests/ui/write_with_newline.stderr b/tests/ui/write_with_newline.stderr
index 5f55431be0b..2baaea166d8 100644
--- a/tests/ui/write_with_newline.stderr
+++ b/tests/ui/write_with_newline.stderr
@@ -5,7 +5,7 @@ LL |     write!(v, "Hello/n");
    |     ^^^^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::write-with-newline` implied by `-D warnings`
-help: use `writeln!()` instead
+help: use `writeln!` instead
    |
 LL -     write!(v, "Hello/n");
 LL +     writeln!(v, "Hello");
@@ -17,7 +17,7 @@ error: using `write!()` with a format string that ends in a single newline
 LL |     write!(v, "Hello {}/n", "world");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-help: use `writeln!()` instead
+help: use `writeln!` instead
    |
 LL -     write!(v, "Hello {}/n", "world");
 LL +     writeln!(v, "Hello {}", "world");
@@ -29,7 +29,7 @@ error: using `write!()` with a format string that ends in a single newline
 LL |     write!(v, "Hello {} {}/n", "world", "#2");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-help: use `writeln!()` instead
+help: use `writeln!` instead
    |
 LL -     write!(v, "Hello {} {}/n", "world", "#2");
 LL +     writeln!(v, "Hello {} {}", "world", "#2");
@@ -41,7 +41,7 @@ error: using `write!()` with a format string that ends in a single newline
 LL |     write!(v, "{}/n", 1265);
    |     ^^^^^^^^^^^^^^^^^^^^^^^
    |
-help: use `writeln!()` instead
+help: use `writeln!` instead
    |
 LL -     write!(v, "{}/n", 1265);
 LL +     writeln!(v, "{}", 1265);
@@ -53,7 +53,7 @@ error: using `write!()` with a format string that ends in a single newline
 LL |     write!(v, "/n");
    |     ^^^^^^^^^^^^^^^
    |
-help: use `writeln!()` instead
+help: use `writeln!` instead
    |
 LL -     write!(v, "/n");
 LL +     writeln!(v);
@@ -65,7 +65,7 @@ error: using `write!()` with a format string that ends in a single newline
 LL |     write!(v, "//n"); // should fail
    |     ^^^^^^^^^^^^^^^^^
    |
-help: use `writeln!()` instead
+help: use `writeln!` instead
    |
 LL -     write!(v, "//n"); // should fail
 LL +     writeln!(v, "/"); // should fail
@@ -81,11 +81,10 @@ LL | | "
 LL | |     );
    | |_____^
    |
-help: use `writeln!()` instead
+help: use `writeln!` instead
    |
 LL ~     writeln!(
-LL |         v,
-LL ~         ""
+LL ~         v
    |
 
 error: using `write!()` with a format string that ends in a single newline
@@ -98,11 +97,10 @@ LL | | "
 LL | |     );
    | |_____^
    |
-help: use `writeln!()` instead
+help: use `writeln!` instead
    |
 LL ~     writeln!(
-LL |         v,
-LL ~         r""
+LL ~         v
    |
 
 error: using `write!()` with a format string that ends in a single newline
@@ -111,23 +109,11 @@ error: using `write!()` with a format string that ends in a single newline
 LL |     write!(v, "/r/n"); //~ ERROR
    |     ^^^^^^^^^^^^^^^^^^
    |
-help: use `writeln!()` instead
+help: use `writeln!` instead
    |
 LL -     write!(v, "/r/n"); //~ ERROR
 LL +     writeln!(v, "/r"); //~ ERROR
    |
 
-error: using `write!()` with a format string that ends in a single newline
-  --> $DIR/write_with_newline.rs:58:5
-   |
-LL |     write!(v, "foo/rbar/n");
-   |     ^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: use `writeln!()` instead
-   |
-LL -     write!(v, "foo/rbar/n");
-LL +     writeln!(v, "foo/rbar");
-   |
-
-error: aborting due to 10 previous errors
+error: aborting due to 9 previous errors
 
diff --git a/tests/ui/writeln_empty_string.stderr b/tests/ui/writeln_empty_string.stderr
index ac65aadfc0e..25e69ec48e7 100644
--- a/tests/ui/writeln_empty_string.stderr
+++ b/tests/ui/writeln_empty_string.stderr
@@ -1,16 +1,20 @@
-error: using `writeln!(v, "")`
+error: empty string literal in `writeln!`
   --> $DIR/writeln_empty_string.rs:11:5
    |
 LL |     writeln!(v, "");
-   |     ^^^^^^^^^^^^^^^ help: replace it with: `writeln!(v)`
+   |     ^^^^^^^^^^----^
+   |               |
+   |               help: remove the empty string
    |
    = note: `-D clippy::writeln-empty-string` implied by `-D warnings`
 
-error: using `writeln!(suggestion, "")`
+error: empty string literal in `writeln!`
   --> $DIR/writeln_empty_string.rs:14:5
    |
 LL |     writeln!(suggestion, "");
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `writeln!(suggestion)`
+   |     ^^^^^^^^^^^^^^^^^^^----^
+   |                        |
+   |                        help: remove the empty string
 
 error: aborting due to 2 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From cd69d86c89a5f230f799ae4a52d2a0f6a9fdec45 Mon Sep 17 00:00:00 2001
From: kraktus <kraktus@users.noreply.github.com>
Date: Sat, 10 Sep 2022 10:30:19 +0200
Subject: `assertions_on_result_states` fix suggestion when `assert!` not in a
 statement

---
 clippy_lints/src/assertions_on_result_states.rs | 13 ++++++++-----
 tests/ui/assertions_on_result_states.fixed      |  6 ++++++
 tests/ui/assertions_on_result_states.rs         |  6 ++++++
 tests/ui/assertions_on_result_states.stderr     |  8 +++++++-
 4 files changed, 27 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/assertions_on_result_states.rs b/clippy_lints/src/assertions_on_result_states.rs
index 7cd198ace86..63664d66662 100644
--- a/clippy_lints/src/assertions_on_result_states.rs
+++ b/clippy_lints/src/assertions_on_result_states.rs
@@ -1,9 +1,9 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::macros::{find_assert_args, root_macro_call_first_node, PanicExpn};
-use clippy_utils::path_res;
 use clippy_utils::source::snippet_with_context;
 use clippy_utils::ty::{implements_trait, is_copy, is_type_diagnostic_item};
 use clippy_utils::usage::local_used_after_expr;
+use clippy_utils::{is_expr_final_block_expr, path_res};
 use rustc_errors::Applicability;
 use rustc_hir::def::Res;
 use rustc_hir::{Expr, ExprKind};
@@ -58,6 +58,7 @@ impl<'tcx> LateLintPass<'tcx> for AssertionsOnResultStates {
                     return;
                 }
             }
+            let semicolon = if is_expr_final_block_expr(cx.tcx, e) {";"} else {""};
             let mut app = Applicability::MachineApplicable;
             match method_segment.ident.as_str() {
                 "is_ok" if type_suitable_to_unwrap(cx, substs.type_at(1)) => {
@@ -68,8 +69,9 @@ impl<'tcx> LateLintPass<'tcx> for AssertionsOnResultStates {
                         "called `assert!` with `Result::is_ok`",
                         "replace with",
                         format!(
-                            "{}.unwrap()",
-                            snippet_with_context(cx, recv.span, condition.span.ctxt(), "..", &mut app).0
+                            "{}.unwrap(){}",
+                            snippet_with_context(cx, recv.span, condition.span.ctxt(), "..", &mut app).0,
+                            semicolon
                         ),
                         app,
                     );
@@ -82,8 +84,9 @@ impl<'tcx> LateLintPass<'tcx> for AssertionsOnResultStates {
                         "called `assert!` with `Result::is_err`",
                         "replace with",
                         format!(
-                            "{}.unwrap_err()",
-                            snippet_with_context(cx, recv.span, condition.span.ctxt(), "..", &mut app).0
+                            "{}.unwrap_err(){}",
+                            snippet_with_context(cx, recv.span, condition.span.ctxt(), "..", &mut app).0,
+                            semicolon
                         ),
                         app,
                     );
diff --git a/tests/ui/assertions_on_result_states.fixed b/tests/ui/assertions_on_result_states.fixed
index 795f435f24c..2bb755290c5 100644
--- a/tests/ui/assertions_on_result_states.fixed
+++ b/tests/ui/assertions_on_result_states.fixed
@@ -75,3 +75,9 @@ fn main() {
     let r: Result<Foo, Foo> = Err(Foo);
     assert!(r.is_err());
 }
+
+#[allow(dead_code)]
+fn issue9450() {
+    let res: Result<i32, i32> = Ok(1);
+    res.unwrap_err();
+}
diff --git a/tests/ui/assertions_on_result_states.rs b/tests/ui/assertions_on_result_states.rs
index 1101aec1e1b..d8a9bd2f1c4 100644
--- a/tests/ui/assertions_on_result_states.rs
+++ b/tests/ui/assertions_on_result_states.rs
@@ -75,3 +75,9 @@ fn main() {
     let r: Result<Foo, Foo> = Err(Foo);
     assert!(r.is_err());
 }
+
+#[allow(dead_code)]
+fn issue9450() {
+    let res: Result<i32, i32> = Ok(1);
+    assert!(res.is_err())
+}
diff --git a/tests/ui/assertions_on_result_states.stderr b/tests/ui/assertions_on_result_states.stderr
index 97a5f3dfca4..298d63c9c34 100644
--- a/tests/ui/assertions_on_result_states.stderr
+++ b/tests/ui/assertions_on_result_states.stderr
@@ -36,5 +36,11 @@ error: called `assert!` with `Result::is_err`
 LL |     assert!(r.is_err());
    |     ^^^^^^^^^^^^^^^^^^^ help: replace with: `r.unwrap_err()`
 
-error: aborting due to 6 previous errors
+error: called `assert!` with `Result::is_err`
+  --> $DIR/assertions_on_result_states.rs:82:5
+   |
+LL |     assert!(res.is_err())
+   |     ^^^^^^^^^^^^^^^^^^^^^ help: replace with: `res.unwrap_err();`
+
+error: aborting due to 7 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From bdb13cd887c9068262e230bd38730d360a7db0c5 Mon Sep 17 00:00:00 2001
From: kraktus <kraktus@users.noreply.github.com>
Date: Sat, 10 Sep 2022 10:39:51 +0200
Subject: refactor: move `has_debug_impl` to `clippy_utils::ty`

---
 clippy_lints/src/assertions_on_result_states.rs |  9 +--------
 clippy_lints/src/methods/err_expect.rs          | 11 ++---------
 clippy_lints/src/methods/ok_expect.rs           | 11 ++---------
 clippy_utils/src/ty.rs                          |  7 +++++++
 4 files changed, 12 insertions(+), 26 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/assertions_on_result_states.rs b/clippy_lints/src/assertions_on_result_states.rs
index 63664d66662..656dc5feeb5 100644
--- a/clippy_lints/src/assertions_on_result_states.rs
+++ b/clippy_lints/src/assertions_on_result_states.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::macros::{find_assert_args, root_macro_call_first_node, PanicExpn};
 use clippy_utils::source::snippet_with_context;
-use clippy_utils::ty::{implements_trait, is_copy, is_type_diagnostic_item};
+use clippy_utils::ty::{has_debug_impl, is_copy, is_type_diagnostic_item};
 use clippy_utils::usage::local_used_after_expr;
 use clippy_utils::{is_expr_final_block_expr, path_res};
 use rustc_errors::Applicability;
@@ -97,13 +97,6 @@ impl<'tcx> LateLintPass<'tcx> for AssertionsOnResultStates {
     }
 }
 
-/// This checks whether a given type is known to implement Debug.
-fn has_debug_impl<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
-    cx.tcx
-        .get_diagnostic_item(sym::Debug)
-        .map_or(false, |debug| implements_trait(cx, ty, debug, &[]))
-}
-
 fn type_suitable_to_unwrap<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
     has_debug_impl(cx, ty) && !ty.is_unit() && !ty.is_never()
 }
diff --git a/clippy_lints/src/methods/err_expect.rs b/clippy_lints/src/methods/err_expect.rs
index 570a1b87358..720d9a68c85 100644
--- a/clippy_lints/src/methods/err_expect.rs
+++ b/clippy_lints/src/methods/err_expect.rs
@@ -1,6 +1,6 @@
 use super::ERR_EXPECT;
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::ty::implements_trait;
+use clippy_utils::ty::has_debug_impl;
 use clippy_utils::{meets_msrv, msrvs, ty::is_type_diagnostic_item};
 use rustc_errors::Applicability;
 use rustc_lint::LateContext;
@@ -28,7 +28,7 @@ pub(super) fn check(
         // Tests if the T type in a `Result<T, E>` is not None
         if let Some(data_type) = get_data_type(cx, result_type);
         // Tests if the T type in a `Result<T, E>` implements debug
-        if has_debug_impl(data_type, cx);
+        if has_debug_impl(cx, data_type);
 
         then {
             span_lint_and_sugg(
@@ -51,10 +51,3 @@ fn get_data_type<'a>(cx: &LateContext<'_>, ty: Ty<'a>) -> Option<Ty<'a>> {
         _ => None,
     }
 }
-
-/// Given a type, very if the Debug trait has been impl'd
-fn has_debug_impl<'tcx>(ty: Ty<'tcx>, cx: &LateContext<'tcx>) -> bool {
-    cx.tcx
-        .get_diagnostic_item(sym::Debug)
-        .map_or(false, |debug| implements_trait(cx, ty, debug, &[]))
-}
diff --git a/clippy_lints/src/methods/ok_expect.rs b/clippy_lints/src/methods/ok_expect.rs
index d64a9f320d9..646fc4a7bcf 100644
--- a/clippy_lints/src/methods/ok_expect.rs
+++ b/clippy_lints/src/methods/ok_expect.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_help;
-use clippy_utils::ty::{implements_trait, is_type_diagnostic_item};
+use clippy_utils::ty::{has_debug_impl, is_type_diagnostic_item};
 use if_chain::if_chain;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
@@ -15,7 +15,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr
         if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(recv), sym::Result);
         let result_type = cx.typeck_results().expr_ty(recv);
         if let Some(error_type) = get_error_type(cx, result_type);
-        if has_debug_impl(error_type, cx);
+        if has_debug_impl(cx, error_type);
 
         then {
             span_lint_and_help(
@@ -37,10 +37,3 @@ fn get_error_type<'a>(cx: &LateContext<'_>, ty: Ty<'a>) -> Option<Ty<'a>> {
         _ => None,
     }
 }
-
-/// This checks whether a given type is known to implement Debug.
-fn has_debug_impl<'tcx>(ty: Ty<'tcx>, cx: &LateContext<'tcx>) -> bool {
-    cx.tcx
-        .get_diagnostic_item(sym::Debug)
-        .map_or(false, |debug| implements_trait(cx, ty, debug, &[]))
-}
diff --git a/clippy_utils/src/ty.rs b/clippy_utils/src/ty.rs
index 5a7f9568441..b3eb6d05544 100644
--- a/clippy_utils/src/ty.rs
+++ b/clippy_utils/src/ty.rs
@@ -31,6 +31,13 @@ pub fn is_copy<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
     ty.is_copy_modulo_regions(cx.tcx.at(DUMMY_SP), cx.param_env)
 }
 
+/// This checks whether a given type is known to implement Debug.
+pub fn has_debug_impl<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
+    cx.tcx
+        .get_diagnostic_item(sym::Debug)
+        .map_or(false, |debug| implements_trait(cx, ty, debug, &[]))
+}
+
 /// Checks whether a type can be partially moved.
 pub fn can_partially_move_ty<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
     if has_drop(cx, ty) || is_copy(cx, ty) {
-- 
cgit 1.4.1-3-g733a5


From 0958f9486ba0cb8ecd0093ff3100af45d19529f3 Mon Sep 17 00:00:00 2001
From: kraktus <kraktus@users.noreply.github.com>
Date: Mon, 3 Oct 2022 13:57:42 +0200
Subject: Add `manual_filter` lint for `Option`

Share much of its implementation with `manual_map` and should greatly benefit from its previous feedback.
---
 CHANGELOG.md                                |   1 +
 clippy_lints/src/lib.register_all.rs        |   1 +
 clippy_lints/src/lib.register_complexity.rs |   1 +
 clippy_lints/src/lib.register_lints.rs      |   1 +
 clippy_lints/src/matches/manual_filter.rs   | 181 +++++++++++++++++++++
 clippy_lints/src/matches/manual_map.rs      | 213 ++++++++++++++++--------
 clippy_lints/src/matches/mod.rs             |  39 +++++
 clippy_utils/src/sugg.rs                    |   6 +-
 src/docs.rs                                 |   1 +
 src/docs/manual_filter.txt                  |  21 +++
 tests/ui/manual_filter.fixed                | 119 ++++++++++++++
 tests/ui/manual_filter.rs                   | 243 ++++++++++++++++++++++++++++
 tests/ui/manual_filter.stderr               | 191 ++++++++++++++++++++++
 13 files changed, 951 insertions(+), 67 deletions(-)
 create mode 100644 clippy_lints/src/matches/manual_filter.rs
 create mode 100644 src/docs/manual_filter.txt
 create mode 100644 tests/ui/manual_filter.fixed
 create mode 100644 tests/ui/manual_filter.rs
 create mode 100644 tests/ui/manual_filter.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9f12a673596..cab2808ee3b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3986,6 +3986,7 @@ Released 2018-09-13
 [`manual_async_fn`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_async_fn
 [`manual_bits`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_bits
 [`manual_clamp`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_clamp
+[`manual_filter`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_filter
 [`manual_filter_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_filter_map
 [`manual_find`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_find
 [`manual_find_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_find_map
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 9ad2a88eb26..21d686fcdf5 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -135,6 +135,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(match_result_ok::MATCH_RESULT_OK),
     LintId::of(matches::COLLAPSIBLE_MATCH),
     LintId::of(matches::INFALLIBLE_DESTRUCTURING_MATCH),
+    LintId::of(matches::MANUAL_FILTER),
     LintId::of(matches::MANUAL_MAP),
     LintId::of(matches::MANUAL_UNWRAP_OR),
     LintId::of(matches::MATCH_AS_REF),
diff --git a/clippy_lints/src/lib.register_complexity.rs b/clippy_lints/src/lib.register_complexity.rs
index a58d066fa6b..e3849e5a626 100644
--- a/clippy_lints/src/lib.register_complexity.rs
+++ b/clippy_lints/src/lib.register_complexity.rs
@@ -27,6 +27,7 @@ store.register_group(true, "clippy::complexity", Some("clippy_complexity"), vec!
     LintId::of(manual_strip::MANUAL_STRIP),
     LintId::of(map_unit_fn::OPTION_MAP_UNIT_FN),
     LintId::of(map_unit_fn::RESULT_MAP_UNIT_FN),
+    LintId::of(matches::MANUAL_FILTER),
     LintId::of(matches::MANUAL_UNWRAP_OR),
     LintId::of(matches::MATCH_AS_REF),
     LintId::of(matches::MATCH_SINGLE_BINDING),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 307ec40f40b..70defe3bcbd 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -257,6 +257,7 @@ store.register_lints(&[
     match_result_ok::MATCH_RESULT_OK,
     matches::COLLAPSIBLE_MATCH,
     matches::INFALLIBLE_DESTRUCTURING_MATCH,
+    matches::MANUAL_FILTER,
     matches::MANUAL_MAP,
     matches::MANUAL_UNWRAP_OR,
     matches::MATCH_AS_REF,
diff --git a/clippy_lints/src/matches/manual_filter.rs b/clippy_lints/src/matches/manual_filter.rs
new file mode 100644
index 00000000000..9931f1268ab
--- /dev/null
+++ b/clippy_lints/src/matches/manual_filter.rs
@@ -0,0 +1,181 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::{is_res_lang_ctor, path_res, path_to_local_id};
+use rustc_hir::intravisit::{walk_expr, Visitor};
+use rustc_hir::LangItem::OptionSome;
+use rustc_hir::{Arm, Block, BlockCheckMode, Expr, ExprKind, HirId, Pat, PatKind, UnsafeSource};
+use rustc_lint::LateContext;
+use rustc_span::{sym, SyntaxContext};
+
+use super::manual_map::{check_with, SomeExpr};
+use super::MANUAL_FILTER;
+
+#[derive(Default)]
+struct NeedsUnsafeBlock(pub bool);
+
+impl<'tcx> Visitor<'tcx> for NeedsUnsafeBlock {
+    fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) {
+        match expr.kind {
+            ExprKind::Block(
+                Block {
+                    rules: BlockCheckMode::UnsafeBlock(UnsafeSource::UserProvided),
+                    ..
+                },
+                _,
+            ) => {
+                self.0 = true;
+            },
+            _ => walk_expr(self, expr),
+        }
+    }
+}
+
+// Function called on the `expr` of `[&+]Some((ref | ref mut) x) => <expr>`
+// Need to check if it's of the `if <cond> {<then_expr>} else {<else_expr>}`
+// AND that only one `then/else_expr` resolves to `Some(x)` while the other resolves to `None`
+// return `cond` if
+fn get_cond_expr<'tcx>(
+    cx: &LateContext<'tcx>,
+    pat: &Pat<'_>,
+    expr: &'tcx Expr<'_>,
+    ctxt: SyntaxContext,
+) -> Option<SomeExpr<'tcx>> {
+    if_chain! {
+        if let Some(block_expr) = peels_blocks_incl_unsafe_opt(expr);
+        if let ExprKind::If(cond, then_expr, Some(else_expr)) = block_expr.kind;
+        if let PatKind::Binding(_,target, ..) = pat.kind;
+        if let (then_visitor, else_visitor)
+            = (handle_if_or_else_expr(cx, target, ctxt, then_expr),
+                handle_if_or_else_expr(cx, target, ctxt, else_expr));
+        if then_visitor != else_visitor; // check that one expr resolves to `Some(x)`, the other to `None`
+        then {
+            let mut needs_unsafe_block = NeedsUnsafeBlock::default();
+            needs_unsafe_block.visit_expr(expr);
+            return Some(SomeExpr {
+                    expr: peels_blocks_incl_unsafe(cond.peel_drop_temps()),
+                    needs_unsafe_block: needs_unsafe_block.0,
+                    needs_negated: !then_visitor // if the `then_expr` resolves to `None`, need to negate the cond
+                })
+            }
+    };
+    None
+}
+
+fn peels_blocks_incl_unsafe_opt<'a>(expr: &'a Expr<'a>) -> Option<&'a Expr<'a>> {
+    // we don't want to use `peel_blocks` here because we don't care if the block is unsafe, it's
+    // checked by `NeedsUnsafeBlock`
+    if let ExprKind::Block(block, None) = expr.kind {
+        if block.stmts.is_empty() {
+            return block.expr;
+        }
+    };
+    None
+}
+
+fn peels_blocks_incl_unsafe<'a>(expr: &'a Expr<'a>) -> &'a Expr<'a> {
+    peels_blocks_incl_unsafe_opt(expr).unwrap_or(expr)
+}
+
+// function called for each <ifelse> expression:
+// Some(x) => if <cond> {
+//    <ifelse>
+// } else {
+//    <ifelse>
+// }
+// Returns true if <ifelse> resolves to `Some(x)`, `false` otherwise
+fn handle_if_or_else_expr<'tcx>(
+    cx: &LateContext<'_>,
+    target: HirId,
+    ctxt: SyntaxContext,
+    if_or_else_expr: &'tcx Expr<'_>,
+) -> bool {
+    if let Some(inner_expr) = peels_blocks_incl_unsafe_opt(if_or_else_expr) {
+        // there can be not statements in the block as they would be removed when switching to `.filter`
+        if let ExprKind::Call(callee, [arg]) = inner_expr.kind {
+            return ctxt == if_or_else_expr.span.ctxt()
+                && is_res_lang_ctor(cx, path_res(cx, callee), OptionSome)
+                && path_to_local_id(arg, target);
+        }
+    };
+    false
+}
+
+// given the closure: `|<pattern>| <expr>`
+// returns `|&<pattern>| <expr>`
+fn add_ampersand_if_copy(body_str: String, has_copy_trait: bool) -> String {
+    if has_copy_trait {
+        let mut with_ampersand = body_str;
+        with_ampersand.insert(1, '&');
+        with_ampersand
+    } else {
+        body_str
+    }
+}
+
+pub(super) fn check_match<'tcx>(
+    cx: &LateContext<'tcx>,
+    scrutinee: &'tcx Expr<'_>,
+    arms: &'tcx [Arm<'_>],
+    expr: &'tcx Expr<'_>,
+) {
+    let ty = cx.typeck_results().expr_ty(expr);
+    if_chain! {
+        if is_type_diagnostic_item(cx, ty, sym::Option);
+        if arms.len() == 2;
+        if arms[0].guard.is_none();
+        if arms[1].guard.is_none();
+        then {
+            check(cx, expr, scrutinee, arms[0].pat, arms[0].body, Some(arms[1].pat), arms[1].body)
+        }
+    }
+}
+
+pub(super) fn check_if_let<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx Expr<'_>,
+    let_pat: &'tcx Pat<'_>,
+    let_expr: &'tcx Expr<'_>,
+    then_expr: &'tcx Expr<'_>,
+    else_expr: &'tcx Expr<'_>,
+) {
+    check(cx, expr, let_expr, let_pat, then_expr, None, else_expr);
+}
+
+fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx Expr<'_>,
+    scrutinee: &'tcx Expr<'_>,
+    then_pat: &'tcx Pat<'_>,
+    then_body: &'tcx Expr<'_>,
+    else_pat: Option<&'tcx Pat<'_>>,
+    else_body: &'tcx Expr<'_>,
+) {
+    if let Some(sugg_info) = check_with(
+        cx,
+        expr,
+        scrutinee,
+        then_pat,
+        then_body,
+        else_pat,
+        else_body,
+        get_cond_expr,
+    ) {
+        let body_str = add_ampersand_if_copy(sugg_info.body_str, sugg_info.scrutinee_impl_copy);
+        span_lint_and_sugg(
+            cx,
+            MANUAL_FILTER,
+            expr.span,
+            "manual implementation of `Option::filter`",
+            "try this",
+            if sugg_info.needs_brackets {
+                format!(
+                    "{{ {}{}.filter({body_str}) }}",
+                    sugg_info.scrutinee_str, sugg_info.as_ref_str
+                )
+            } else {
+                format!("{}{}.filter({body_str})", sugg_info.scrutinee_str, sugg_info.as_ref_str)
+            },
+            sugg_info.app,
+        );
+    }
+}
diff --git a/clippy_lints/src/matches/manual_map.rs b/clippy_lints/src/matches/manual_map.rs
index 76f5e1c941c..2b6a07c5d74 100644
--- a/clippy_lints/src/matches/manual_map.rs
+++ b/clippy_lints/src/matches/manual_map.rs
@@ -1,10 +1,11 @@
+use super::MANUAL_MAP;
 use crate::{map_unit_fn::OPTION_MAP_UNIT_FN, matches::MATCH_AS_REF};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::{snippet_with_applicability, snippet_with_context};
-use clippy_utils::ty::{is_type_diagnostic_item, peel_mid_ty_refs_is_mutable, type_is_unsafe_function};
+use clippy_utils::ty::{is_copy, is_type_diagnostic_item, peel_mid_ty_refs_is_mutable, type_is_unsafe_function};
 use clippy_utils::{
     can_move_expr_to_closure, is_else_clause, is_lint_allowed, is_res_lang_ctor, path_res, path_to_local_id,
-    peel_blocks, peel_hir_expr_refs, peel_hir_expr_while, CaptureKind,
+    peel_blocks, peel_hir_expr_refs, peel_hir_expr_while, sugg::Sugg, CaptureKind,
 };
 use rustc_ast::util::parser::PREC_POSTFIX;
 use rustc_errors::Applicability;
@@ -16,8 +17,6 @@ use rustc_hir::{
 use rustc_lint::LateContext;
 use rustc_span::{sym, SyntaxContext};
 
-use super::MANUAL_MAP;
-
 pub(super) fn check_match<'tcx>(
     cx: &LateContext<'tcx>,
     expr: &'tcx Expr<'_>,
@@ -43,7 +42,6 @@ pub(super) fn check_if_let<'tcx>(
     check(cx, expr, let_expr, let_pat, then_expr, None, else_expr);
 }
 
-#[expect(clippy::too_many_lines)]
 fn check<'tcx>(
     cx: &LateContext<'tcx>,
     expr: &'tcx Expr<'_>,
@@ -53,12 +51,59 @@ fn check<'tcx>(
     else_pat: Option<&'tcx Pat<'_>>,
     else_body: &'tcx Expr<'_>,
 ) {
+    if let Some(sugg_info) = check_with(
+        cx,
+        expr,
+        scrutinee,
+        then_pat,
+        then_body,
+        else_pat,
+        else_body,
+        get_some_expr,
+    ) {
+        span_lint_and_sugg(
+            cx,
+            MANUAL_MAP,
+            expr.span,
+            "manual implementation of `Option::map`",
+            "try this",
+            if sugg_info.needs_brackets {
+                format!(
+                    "{{ {}{}.map({}) }}",
+                    sugg_info.scrutinee_str, sugg_info.as_ref_str, sugg_info.body_str
+                )
+            } else {
+                format!(
+                    "{}{}.map({})",
+                    sugg_info.scrutinee_str, sugg_info.as_ref_str, sugg_info.body_str
+                )
+            },
+            sugg_info.app,
+        );
+    }
+}
+
+#[expect(clippy::too_many_arguments)]
+#[expect(clippy::too_many_lines)]
+pub(super) fn check_with<'tcx, F>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx Expr<'_>,
+    scrutinee: &'tcx Expr<'_>,
+    then_pat: &'tcx Pat<'_>,
+    then_body: &'tcx Expr<'_>,
+    else_pat: Option<&'tcx Pat<'_>>,
+    else_body: &'tcx Expr<'_>,
+    get_some_expr_fn: F,
+) -> Option<SuggInfo<'tcx>>
+where
+    F: Fn(&LateContext<'tcx>, &'tcx Pat<'_>, &'tcx Expr<'_>, SyntaxContext) -> Option<SomeExpr<'tcx>>,
+{
     let (scrutinee_ty, ty_ref_count, ty_mutability) =
         peel_mid_ty_refs_is_mutable(cx.typeck_results().expr_ty(scrutinee));
     if !(is_type_diagnostic_item(cx, scrutinee_ty, sym::Option)
         && is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(expr), sym::Option))
     {
-        return;
+        return None;
     }
 
     let expr_ctxt = expr.span.ctxt();
@@ -78,29 +123,29 @@ fn check<'tcx>(
         (Some(OptionPat::Some { pattern, ref_count }), Some(OptionPat::None)) if is_none_expr(cx, else_body) => {
             (then_body, pattern, ref_count, false)
         },
-        _ => return,
+        _ => return None,
     };
 
     // Top level or patterns aren't allowed in closures.
     if matches!(some_pat.kind, PatKind::Or(_)) {
-        return;
+        return None;
     }
 
-    let some_expr = match get_some_expr(cx, some_expr, false, expr_ctxt) {
+    let some_expr = match get_some_expr_fn(cx, some_pat, some_expr, expr_ctxt) {
         Some(expr) => expr,
-        None => return,
+        None => return None,
     };
 
     // These two lints will go back and forth with each other.
     if cx.typeck_results().expr_ty(some_expr.expr) == cx.tcx.types.unit
         && !is_lint_allowed(cx, OPTION_MAP_UNIT_FN, expr.hir_id)
     {
-        return;
+        return None;
     }
 
     // `map` won't perform any adjustments.
     if !cx.typeck_results().expr_adjustments(some_expr.expr).is_empty() {
-        return;
+        return None;
     }
 
     // Determine which binding mode to use.
@@ -125,16 +170,16 @@ fn check<'tcx>(
                 });
                 if let ExprKind::Path(QPath::Resolved(None, Path { res: Res::Local(l), .. })) = e.kind {
                     match captures.get(l) {
-                        Some(CaptureKind::Value | CaptureKind::Ref(Mutability::Mut)) => return,
+                        Some(CaptureKind::Value | CaptureKind::Ref(Mutability::Mut)) => return None,
                         Some(CaptureKind::Ref(Mutability::Not)) if binding_ref_mutability == Mutability::Mut => {
-                            return;
+                            return None;
                         },
                         Some(CaptureKind::Ref(Mutability::Not)) | None => (),
                     }
                 }
             }
         },
-        None => return,
+        None => return None,
     };
 
     let mut app = Applicability::MachineApplicable;
@@ -149,6 +194,7 @@ fn check<'tcx>(
         scrutinee_str.into()
     };
 
+    let closure_expr_snip = some_expr.to_snippet_with_context(cx, expr_ctxt, &mut app);
     let body_str = if let PatKind::Binding(annotation, id, some_binding, None) = some_pat.kind {
         if_chain! {
             if !some_expr.needs_unsafe_block;
@@ -161,7 +207,7 @@ fn check<'tcx>(
                     && !is_lint_allowed(cx, MATCH_AS_REF, expr.hir_id)
                     && binding_ref.is_some()
                 {
-                    return;
+                    return None;
                 }
 
                 // `ref` and `ref mut` annotations were handled earlier.
@@ -170,41 +216,47 @@ fn check<'tcx>(
                 } else {
                     ""
                 };
-                let expr_snip = snippet_with_context(cx, some_expr.expr.span, expr_ctxt, "..", &mut app).0;
+
                 if some_expr.needs_unsafe_block {
-                    format!("|{annotation}{some_binding}| unsafe {{ {expr_snip} }}")
+                    format!("|{annotation}{some_binding}| unsafe {{ {closure_expr_snip} }}")
                 } else {
-                    format!("|{annotation}{some_binding}| {expr_snip}")
+                    format!("|{annotation}{some_binding}| {closure_expr_snip}")
                 }
             }
         }
     } else if !is_wild_none && explicit_ref.is_none() {
         // TODO: handle explicit reference annotations.
         let pat_snip = snippet_with_context(cx, some_pat.span, expr_ctxt, "..", &mut app).0;
-        let expr_snip = snippet_with_context(cx, some_expr.expr.span, expr_ctxt, "..", &mut app).0;
         if some_expr.needs_unsafe_block {
-            format!("|{pat_snip}| unsafe {{ {expr_snip} }}")
+            format!("|{pat_snip}| unsafe {{ {closure_expr_snip} }}")
         } else {
-            format!("|{pat_snip}| {expr_snip}")
+            format!("|{pat_snip}| {closure_expr_snip}")
         }
     } else {
         // Refutable bindings and mixed reference annotations can't be handled by `map`.
-        return;
+        return None;
     };
 
-    span_lint_and_sugg(
-        cx,
-        MANUAL_MAP,
-        expr.span,
-        "manual implementation of `Option::map`",
-        "try this",
-        if else_pat.is_none() && is_else_clause(cx.tcx, expr) {
-            format!("{{ {scrutinee_str}{as_ref_str}.map({body_str}) }}")
-        } else {
-            format!("{scrutinee_str}{as_ref_str}.map({body_str})")
-        },
+    // relies on the fact that Option<T>: Copy where T: copy
+    let scrutinee_impl_copy = is_copy(cx, scrutinee_ty);
+
+    Some(SuggInfo {
+        needs_brackets: else_pat.is_none() && is_else_clause(cx.tcx, expr),
+        scrutinee_impl_copy,
+        scrutinee_str,
+        as_ref_str,
+        body_str,
         app,
-    );
+    })
+}
+
+pub struct SuggInfo<'a> {
+    pub needs_brackets: bool,
+    pub scrutinee_impl_copy: bool,
+    pub scrutinee_str: String,
+    pub as_ref_str: &'a str,
+    pub body_str: String,
+    pub app: Applicability,
 }
 
 // Checks whether the expression could be passed as a function, or whether a closure is needed.
@@ -222,7 +274,8 @@ fn can_pass_as_func<'tcx>(cx: &LateContext<'tcx>, binding: HirId, expr: &'tcx Ex
     }
 }
 
-enum OptionPat<'a> {
+#[derive(Debug)]
+pub(super) enum OptionPat<'a> {
     Wild,
     None,
     Some {
@@ -234,14 +287,39 @@ enum OptionPat<'a> {
     },
 }
 
-struct SomeExpr<'tcx> {
-    expr: &'tcx Expr<'tcx>,
-    needs_unsafe_block: bool,
+pub(super) struct SomeExpr<'tcx> {
+    pub expr: &'tcx Expr<'tcx>,
+    pub needs_unsafe_block: bool,
+    pub needs_negated: bool, // for `manual_filter` lint
+}
+
+impl<'tcx> SomeExpr<'tcx> {
+    pub fn new_no_negated(expr: &'tcx Expr<'tcx>, needs_unsafe_block: bool) -> Self {
+        Self {
+            expr,
+            needs_unsafe_block,
+            needs_negated: false,
+        }
+    }
+
+    pub fn to_snippet_with_context(
+        &self,
+        cx: &LateContext<'tcx>,
+        ctxt: SyntaxContext,
+        app: &mut Applicability,
+    ) -> Sugg<'tcx> {
+        let sugg = Sugg::hir_with_context(cx, self.expr, ctxt, "..", app);
+        if self.needs_negated { !sugg } else { sugg }
+    }
 }
 
 // Try to parse into a recognized `Option` pattern.
 // i.e. `_`, `None`, `Some(..)`, or a reference to any of those.
-fn try_parse_pattern<'tcx>(cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>, ctxt: SyntaxContext) -> Option<OptionPat<'tcx>> {
+pub(super) fn try_parse_pattern<'tcx>(
+    cx: &LateContext<'tcx>,
+    pat: &'tcx Pat<'_>,
+    ctxt: SyntaxContext,
+) -> Option<OptionPat<'tcx>> {
     fn f<'tcx>(
         cx: &LateContext<'tcx>,
         pat: &'tcx Pat<'_>,
@@ -268,36 +346,41 @@ fn try_parse_pattern<'tcx>(cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>, ctxt: Syn
 // Checks for an expression wrapped by the `Some` constructor. Returns the contained expression.
 fn get_some_expr<'tcx>(
     cx: &LateContext<'tcx>,
+    _: &'tcx Pat<'_>,
     expr: &'tcx Expr<'_>,
-    needs_unsafe_block: bool,
     ctxt: SyntaxContext,
 ) -> Option<SomeExpr<'tcx>> {
-    // TODO: Allow more complex expressions.
-    match expr.kind {
-        ExprKind::Call(callee, [arg])
-            if ctxt == expr.span.ctxt() && is_res_lang_ctor(cx, path_res(cx, callee), OptionSome) =>
-        {
-            Some(SomeExpr {
-                expr: arg,
-                needs_unsafe_block,
-            })
-        },
-        ExprKind::Block(
-            Block {
-                stmts: [],
-                expr: Some(expr),
-                rules,
-                ..
+    fn get_some_expr_internal<'tcx>(
+        cx: &LateContext<'tcx>,
+        expr: &'tcx Expr<'_>,
+        needs_unsafe_block: bool,
+        ctxt: SyntaxContext,
+    ) -> Option<SomeExpr<'tcx>> {
+        // TODO: Allow more complex expressions.
+        match expr.kind {
+            ExprKind::Call(callee, [arg])
+                if ctxt == expr.span.ctxt() && is_res_lang_ctor(cx, path_res(cx, callee), OptionSome) =>
+            {
+                Some(SomeExpr::new_no_negated(arg, needs_unsafe_block))
             },
-            _,
-        ) => get_some_expr(
-            cx,
-            expr,
-            needs_unsafe_block || *rules == BlockCheckMode::UnsafeBlock(UnsafeSource::UserProvided),
-            ctxt,
-        ),
-        _ => None,
+            ExprKind::Block(
+                Block {
+                    stmts: [],
+                    expr: Some(expr),
+                    rules,
+                    ..
+                },
+                _,
+            ) => get_some_expr_internal(
+                cx,
+                expr,
+                needs_unsafe_block || *rules == BlockCheckMode::UnsafeBlock(UnsafeSource::UserProvided),
+                ctxt,
+            ),
+            _ => None,
+        }
     }
+    get_some_expr_internal(cx, expr, false, ctxt)
 }
 
 // Checks for the `None` value.
diff --git a/clippy_lints/src/matches/mod.rs b/clippy_lints/src/matches/mod.rs
index e6b183fc05f..cf1bd7a12ad 100644
--- a/clippy_lints/src/matches/mod.rs
+++ b/clippy_lints/src/matches/mod.rs
@@ -1,5 +1,6 @@
 mod collapsible_match;
 mod infallible_destructuring_match;
+mod manual_filter;
 mod manual_map;
 mod manual_unwrap_or;
 mod match_as_ref;
@@ -898,6 +899,34 @@ declare_clippy_lint! {
     "reimplementation of `map`"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usages of `match` which could be implemented using `filter`
+    ///
+    /// ### Why is this bad?
+    /// Using the `filter` method is clearer and more concise.
+    ///
+    /// ### Example
+    /// ```rust
+    /// match Some(0) {
+    ///     Some(x) => if x % 2 == 0 {
+    ///                     Some(x)
+    ///                } else {
+    ///                     None
+    ///                 },
+    ///     None => None,
+    /// };
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// Some(0).filter(|&x| x % 2 == 0);
+    /// ```
+    #[clippy::version = "1.65.0"]
+    pub MANUAL_FILTER,
+    complexity,
+    "reimplentation of `filter`"
+}
+
 #[derive(Default)]
 pub struct Matches {
     msrv: Option<RustcVersion>,
@@ -939,6 +968,7 @@ impl_lint_pass!(Matches => [
     SIGNIFICANT_DROP_IN_SCRUTINEE,
     TRY_ERR,
     MANUAL_MAP,
+    MANUAL_FILTER,
 ]);
 
 impl<'tcx> LateLintPass<'tcx> for Matches {
@@ -988,6 +1018,7 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
                     if !in_constant(cx, expr.hir_id) {
                         manual_unwrap_or::check(cx, expr, ex, arms);
                         manual_map::check_match(cx, expr, ex, arms);
+                        manual_filter::check_match(cx, ex, arms, expr);
                     }
 
                     if self.infallible_destructuring_match_linted {
@@ -1014,6 +1045,14 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
                     }
                     if !in_constant(cx, expr.hir_id) {
                         manual_map::check_if_let(cx, expr, if_let.let_pat, if_let.let_expr, if_let.if_then, else_expr);
+                        manual_filter::check_if_let(
+                            cx,
+                            expr,
+                            if_let.let_pat,
+                            if_let.let_expr,
+                            if_let.if_then,
+                            else_expr,
+                        );
                     }
                 }
                 redundant_pattern_match::check_if_let(
diff --git a/clippy_utils/src/sugg.rs b/clippy_utils/src/sugg.rs
index ef836e84829..e88542b77a6 100644
--- a/clippy_utils/src/sugg.rs
+++ b/clippy_utils/src/sugg.rs
@@ -1,7 +1,9 @@
 //! Contains utility functions to generate suggestions.
 #![deny(clippy::missing_docs_in_private_items)]
 
-use crate::source::{snippet, snippet_opt, snippet_with_applicability, snippet_with_macro_callsite};
+use crate::source::{
+    snippet, snippet_opt, snippet_with_applicability, snippet_with_context, snippet_with_macro_callsite,
+};
 use crate::ty::expr_sig;
 use crate::{get_parent_expr_for_hir, higher};
 use rustc_ast::util::parser::AssocOp;
@@ -110,7 +112,7 @@ impl<'a> Sugg<'a> {
         if expr.span.ctxt() == ctxt {
             Self::hir_from_snippet(expr, |span| snippet(cx, span, default))
         } else {
-            let snip = snippet_with_applicability(cx, expr.span, default, applicability);
+            let snip = snippet_with_context(cx, expr.span, ctxt, default, applicability).0;
             Sugg::NonParen(snip)
         }
     }
diff --git a/src/docs.rs b/src/docs.rs
index 39540e4b048..d24342076b6 100644
--- a/src/docs.rs
+++ b/src/docs.rs
@@ -256,6 +256,7 @@ docs! {
     "manual_async_fn",
     "manual_bits",
     "manual_clamp",
+    "manual_filter",
     "manual_filter_map",
     "manual_find",
     "manual_find_map",
diff --git a/src/docs/manual_filter.txt b/src/docs/manual_filter.txt
new file mode 100644
index 00000000000..19a4d9319d9
--- /dev/null
+++ b/src/docs/manual_filter.txt
@@ -0,0 +1,21 @@
+### What it does
+Checks for usages of `match` which could be implemented using `filter`
+
+### Why is this bad?
+Using the `filter` method is clearer and more concise.
+
+### Example
+```
+match Some(0) {
+    Some(x) => if x % 2 == 0 {
+                    Some(x)
+               } else {
+                    None
+                },
+    None => None,
+};
+```
+Use instead:
+```
+Some(0).filter(|&x| x % 2 == 0);
+```
\ No newline at end of file
diff --git a/tests/ui/manual_filter.fixed b/tests/ui/manual_filter.fixed
new file mode 100644
index 00000000000..3553291b87d
--- /dev/null
+++ b/tests/ui/manual_filter.fixed
@@ -0,0 +1,119 @@
+// run-rustfix
+
+#![warn(clippy::manual_filter)]
+#![allow(unused_variables, dead_code)]
+
+fn main() {
+    Some(0).filter(|&x| x <= 0);
+
+    Some(1).filter(|&x| x <= 0);
+
+    Some(2).filter(|&x| x <= 0);
+
+    Some(3).filter(|&x| x > 0);
+
+    let y = Some(4);
+    y.filter(|&x| x <= 0);
+
+    Some(5).filter(|&x| x > 0);
+
+    Some(6).as_ref().filter(|&x| x > &0);
+
+    let external_cond = true;
+    Some(String::new()).filter(|x| external_cond);
+
+    Some(7).filter(|&x| external_cond);
+
+    Some(8).filter(|&x| x != 0);
+
+    Some(9).filter(|&x| x > 10 && x < 100);
+
+    const fn f1() {
+        // Don't lint, `.filter` is not const
+        match Some(10) {
+            Some(x) => {
+                if x > 10 && x < 100 {
+                    Some(x)
+                } else {
+                    None
+                }
+            },
+            None => None,
+        };
+    }
+
+    #[allow(clippy::blocks_in_if_conditions)]
+    Some(11).filter(|&x| {
+                println!("foo");
+                x > 10 && x < 100
+            });
+
+    match Some(12) {
+        // Don't Lint, statement is lost by `.filter`
+        Some(x) => {
+            if x > 10 && x < 100 {
+                println!("foo");
+                Some(x)
+            } else {
+                None
+            }
+        },
+        None => None,
+    };
+
+    match Some(13) {
+        // Don't Lint, because of `None => Some(1)`
+        Some(x) => {
+            if x > 10 && x < 100 {
+                println!("foo");
+                Some(x)
+            } else {
+                None
+            }
+        },
+        None => Some(1),
+    };
+
+    unsafe fn f(x: u32) -> bool {
+        true
+    }
+    let _ = Some(14).filter(|&x| unsafe { f(x) });
+    let _ = Some(15).filter(|&x| unsafe { f(x) });
+
+    #[allow(clippy::redundant_pattern_matching)]
+    if let Some(_) = Some(16) {
+        Some(16)
+    } else { Some(16).filter(|&x| x % 2 == 0) };
+
+    match Some((17, 17)) {
+        // Not linted for now could be
+        Some((x, y)) => {
+            if y != x {
+                Some((x, y))
+            } else {
+                None
+            }
+        },
+        None => None,
+    };
+
+    struct NamedTuple {
+        pub x: u8,
+        pub y: (i32, u32),
+    }
+
+    match Some(NamedTuple {
+        // Not linted for now could be
+        x: 17,
+        y: (18, 19),
+    }) {
+        Some(NamedTuple { x, y }) => {
+            if y.1 != x as u32 {
+                Some(NamedTuple { x, y })
+            } else {
+                None
+            }
+        },
+        None => None,
+    };
+}
diff --git a/tests/ui/manual_filter.rs b/tests/ui/manual_filter.rs
new file mode 100644
index 00000000000..aa9f90f752b
--- /dev/null
+++ b/tests/ui/manual_filter.rs
@@ -0,0 +1,243 @@
+// run-rustfix
+
+#![warn(clippy::manual_filter)]
+#![allow(unused_variables, dead_code)]
+
+fn main() {
+    match Some(0) {
+        None => None,
+        Some(x) => {
+            if x > 0 {
+                None
+            } else {
+                Some(x)
+            }
+        },
+    };
+
+    match Some(1) {
+        Some(x) => {
+            if x > 0 {
+                None
+            } else {
+                Some(x)
+            }
+        },
+        None => None,
+    };
+
+    match Some(2) {
+        Some(x) => {
+            if x > 0 {
+                None
+            } else {
+                Some(x)
+            }
+        },
+        _ => None,
+    };
+
+    match Some(3) {
+        Some(x) => {
+            if x > 0 {
+                Some(x)
+            } else {
+                None
+            }
+        },
+        None => None,
+    };
+
+    let y = Some(4);
+    match y {
+        // Some(4)
+        None => None,
+        Some(x) => {
+            if x > 0 {
+                None
+            } else {
+                Some(x)
+            }
+        },
+    };
+
+    match Some(5) {
+        Some(x) => {
+            if x > 0 {
+                Some(x)
+            } else {
+                None
+            }
+        },
+        _ => None,
+    };
+
+    match Some(6) {
+        Some(ref x) => {
+            if x > &0 {
+                Some(x)
+            } else {
+                None
+            }
+        },
+        _ => None,
+    };
+
+    let external_cond = true;
+    match Some(String::new()) {
+        Some(x) => {
+            if external_cond {
+                Some(x)
+            } else {
+                None
+            }
+        },
+        _ => None,
+    };
+
+    if let Some(x) = Some(7) {
+        if external_cond { Some(x) } else { None }
+    } else {
+        None
+    };
+
+    match &Some(8) {
+        &Some(x) => {
+            if x != 0 {
+                Some(x)
+            } else {
+                None
+            }
+        },
+        _ => None,
+    };
+
+    match Some(9) {
+        Some(x) => {
+            if x > 10 && x < 100 {
+                Some(x)
+            } else {
+                None
+            }
+        },
+        None => None,
+    };
+
+    const fn f1() {
+        // Don't lint, `.filter` is not const
+        match Some(10) {
+            Some(x) => {
+                if x > 10 && x < 100 {
+                    Some(x)
+                } else {
+                    None
+                }
+            },
+            None => None,
+        };
+    }
+
+    #[allow(clippy::blocks_in_if_conditions)]
+    match Some(11) {
+        // Lint, statement is preserved by `.filter`
+        Some(x) => {
+            if {
+                println!("foo");
+                x > 10 && x < 100
+            } {
+                Some(x)
+            } else {
+                None
+            }
+        },
+        None => None,
+    };
+
+    match Some(12) {
+        // Don't Lint, statement is lost by `.filter`
+        Some(x) => {
+            if x > 10 && x < 100 {
+                println!("foo");
+                Some(x)
+            } else {
+                None
+            }
+        },
+        None => None,
+    };
+
+    match Some(13) {
+        // Don't Lint, because of `None => Some(1)`
+        Some(x) => {
+            if x > 10 && x < 100 {
+                println!("foo");
+                Some(x)
+            } else {
+                None
+            }
+        },
+        None => Some(1),
+    };
+
+    unsafe fn f(x: u32) -> bool {
+        true
+    }
+    let _ = match Some(14) {
+        Some(x) => {
+            if unsafe { f(x) } {
+                Some(x)
+            } else {
+                None
+            }
+        },
+        None => None,
+    };
+    let _ = match Some(15) {
+        Some(x) => unsafe {
+            if f(x) { Some(x) } else { None }
+        },
+        None => None,
+    };
+
+    #[allow(clippy::redundant_pattern_matching)]
+    if let Some(_) = Some(16) {
+        Some(16)
+    } else if let Some(x) = Some(16) {
+        // Lint starting from here
+        if x % 2 == 0 { Some(x) } else { None }
+    } else {
+        None
+    };
+
+    match Some((17, 17)) {
+        // Not linted for now could be
+        Some((x, y)) => {
+            if y != x {
+                Some((x, y))
+            } else {
+                None
+            }
+        },
+        None => None,
+    };
+
+    struct NamedTuple {
+        pub x: u8,
+        pub y: (i32, u32),
+    }
+
+    match Some(NamedTuple {
+        // Not linted for now could be
+        x: 17,
+        y: (18, 19),
+    }) {
+        Some(NamedTuple { x, y }) => {
+            if y.1 != x as u32 {
+                Some(NamedTuple { x, y })
+            } else {
+                None
+            }
+        },
+        None => None,
+    };
+}
diff --git a/tests/ui/manual_filter.stderr b/tests/ui/manual_filter.stderr
new file mode 100644
index 00000000000..53dea922930
--- /dev/null
+++ b/tests/ui/manual_filter.stderr
@@ -0,0 +1,191 @@
+error: manual implementation of `Option::filter`
+  --> $DIR/manual_filter.rs:7:5
+   |
+LL | /     match Some(0) {
+LL | |         None => None,
+LL | |         Some(x) => {
+LL | |             if x > 0 {
+...  |
+LL | |         },
+LL | |     };
+   | |_____^ help: try this: `Some(0).filter(|&x| x <= 0)`
+   |
+   = note: `-D clippy::manual-filter` implied by `-D warnings`
+
+error: manual implementation of `Option::filter`
+  --> $DIR/manual_filter.rs:18:5
+   |
+LL | /     match Some(1) {
+LL | |         Some(x) => {
+LL | |             if x > 0 {
+LL | |                 None
+...  |
+LL | |         None => None,
+LL | |     };
+   | |_____^ help: try this: `Some(1).filter(|&x| x <= 0)`
+
+error: manual implementation of `Option::filter`
+  --> $DIR/manual_filter.rs:29:5
+   |
+LL | /     match Some(2) {
+LL | |         Some(x) => {
+LL | |             if x > 0 {
+LL | |                 None
+...  |
+LL | |         _ => None,
+LL | |     };
+   | |_____^ help: try this: `Some(2).filter(|&x| x <= 0)`
+
+error: manual implementation of `Option::filter`
+  --> $DIR/manual_filter.rs:40:5
+   |
+LL | /     match Some(3) {
+LL | |         Some(x) => {
+LL | |             if x > 0 {
+LL | |                 Some(x)
+...  |
+LL | |         None => None,
+LL | |     };
+   | |_____^ help: try this: `Some(3).filter(|&x| x > 0)`
+
+error: manual implementation of `Option::filter`
+  --> $DIR/manual_filter.rs:52:5
+   |
+LL | /     match y {
+LL | |         // Some(4)
+LL | |         None => None,
+LL | |         Some(x) => {
+...  |
+LL | |         },
+LL | |     };
+   | |_____^ help: try this: `y.filter(|&x| x <= 0)`
+
+error: manual implementation of `Option::filter`
+  --> $DIR/manual_filter.rs:64:5
+   |
+LL | /     match Some(5) {
+LL | |         Some(x) => {
+LL | |             if x > 0 {
+LL | |                 Some(x)
+...  |
+LL | |         _ => None,
+LL | |     };
+   | |_____^ help: try this: `Some(5).filter(|&x| x > 0)`
+
+error: manual implementation of `Option::filter`
+  --> $DIR/manual_filter.rs:75:5
+   |
+LL | /     match Some(6) {
+LL | |         Some(ref x) => {
+LL | |             if x > &0 {
+LL | |                 Some(x)
+...  |
+LL | |         _ => None,
+LL | |     };
+   | |_____^ help: try this: `Some(6).as_ref().filter(|&x| x > &0)`
+
+error: manual implementation of `Option::filter`
+  --> $DIR/manual_filter.rs:87:5
+   |
+LL | /     match Some(String::new()) {
+LL | |         Some(x) => {
+LL | |             if external_cond {
+LL | |                 Some(x)
+...  |
+LL | |         _ => None,
+LL | |     };
+   | |_____^ help: try this: `Some(String::new()).filter(|x| external_cond)`
+
+error: manual implementation of `Option::filter`
+  --> $DIR/manual_filter.rs:98:5
+   |
+LL | /     if let Some(x) = Some(7) {
+LL | |         if external_cond { Some(x) } else { None }
+LL | |     } else {
+LL | |         None
+LL | |     };
+   | |_____^ help: try this: `Some(7).filter(|&x| external_cond)`
+
+error: manual implementation of `Option::filter`
+  --> $DIR/manual_filter.rs:104:5
+   |
+LL | /     match &Some(8) {
+LL | |         &Some(x) => {
+LL | |             if x != 0 {
+LL | |                 Some(x)
+...  |
+LL | |         _ => None,
+LL | |     };
+   | |_____^ help: try this: `Some(8).filter(|&x| x != 0)`
+
+error: manual implementation of `Option::filter`
+  --> $DIR/manual_filter.rs:115:5
+   |
+LL | /     match Some(9) {
+LL | |         Some(x) => {
+LL | |             if x > 10 && x < 100 {
+LL | |                 Some(x)
+...  |
+LL | |         None => None,
+LL | |     };
+   | |_____^ help: try this: `Some(9).filter(|&x| x > 10 && x < 100)`
+
+error: manual implementation of `Option::filter`
+  --> $DIR/manual_filter.rs:141:5
+   |
+LL | /     match Some(11) {
+LL | |         // Lint, statement is preserved by `.filter`
+LL | |         Some(x) => {
+LL | |             if {
+...  |
+LL | |         None => None,
+LL | |     };
+   | |_____^
+   |
+help: try this
+   |
+LL ~     Some(11).filter(|&x| {
+LL +                 println!("foo");
+LL +                 x > 10 && x < 100
+LL ~             });
+   |
+
+error: manual implementation of `Option::filter`
+  --> $DIR/manual_filter.rs:185:13
+   |
+LL |       let _ = match Some(14) {
+   |  _____________^
+LL | |         Some(x) => {
+LL | |             if unsafe { f(x) } {
+LL | |                 Some(x)
+...  |
+LL | |         None => None,
+LL | |     };
+   | |_____^ help: try this: `Some(14).filter(|&x| unsafe { f(x) })`
+
+error: manual implementation of `Option::filter`
+  --> $DIR/manual_filter.rs:195:13
+   |
+LL |       let _ = match Some(15) {
+   |  _____________^
+LL | |         Some(x) => unsafe {
+LL | |             if f(x) { Some(x) } else { None }
+LL | |         },
+LL | |         None => None,
+LL | |     };
+   | |_____^ help: try this: `Some(15).filter(|&x| unsafe { f(x) })`
+
+error: manual implementation of `Option::filter`
+  --> $DIR/manual_filter.rs:205:12
+   |
+LL |       } else if let Some(x) = Some(16) {
+   |  ____________^
+LL | |         // Lint starting from here
+LL | |         if x % 2 == 0 { Some(x) } else { None }
+LL | |     } else {
+LL | |         None
+LL | |     };
+   | |_____^ help: try this: `{ Some(16).filter(|&x| x % 2 == 0) }`
+
+error: aborting due to 15 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From c433d542cf64304d2f701c42165bbb4ae55c0309 Mon Sep 17 00:00:00 2001
From: kraktus <kraktus@users.noreply.github.com>
Date: Sat, 10 Sep 2022 11:36:31 +0200
Subject: Do not lint `use_self` in proc macro expansion

---
 clippy_lints/src/use_self.rs | 5 +++--
 tests/ui/use_self.fixed      | 9 +++++++++
 tests/ui/use_self.rs         | 9 +++++++++
 3 files changed, 21 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/use_self.rs b/clippy_lints/src/use_self.rs
index 486ea5e5ccf..d1c00341818 100644
--- a/clippy_lints/src/use_self.rs
+++ b/clippy_lints/src/use_self.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::ty::same_type_and_consts;
-use clippy_utils::{meets_msrv, msrvs};
+use clippy_utils::{is_from_proc_macro, meets_msrv, msrvs};
 use if_chain::if_chain;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Applicability;
@@ -87,7 +87,7 @@ impl_lint_pass!(UseSelf => [USE_SELF]);
 const SEGMENTS_MSG: &str = "segments should be composed of at least 1 element";
 
 impl<'tcx> LateLintPass<'tcx> for UseSelf {
-    fn check_item(&mut self, _cx: &LateContext<'_>, item: &Item<'_>) {
+    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &Item<'tcx>) {
         if matches!(item.kind, ItemKind::OpaqueTy(_)) {
             // skip over `ItemKind::OpaqueTy` in order to lint `foo() -> impl <..>`
             return;
@@ -103,6 +103,7 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
             if parameters.as_ref().map_or(true, |params| {
                 !params.parenthesized && !params.args.iter().any(|arg| matches!(arg, GenericArg::Lifetime(_)))
             });
+            if !is_from_proc_macro(cx, item); // expensive, should be last check
             then {
                 StackItem::Check {
                     impl_id: item.def_id,
diff --git a/tests/ui/use_self.fixed b/tests/ui/use_self.fixed
index 4f80aaecc90..37986187da1 100644
--- a/tests/ui/use_self.fixed
+++ b/tests/ui/use_self.fixed
@@ -608,3 +608,12 @@ mod issue8845 {
         }
     }
 }
+
+mod issue6902 {
+    use serde::Serialize;
+
+    #[derive(Serialize)]
+    pub enum Foo {
+        Bar = 1,
+    }
+}
diff --git a/tests/ui/use_self.rs b/tests/ui/use_self.rs
index 52da72db53c..1b2b3337c92 100644
--- a/tests/ui/use_self.rs
+++ b/tests/ui/use_self.rs
@@ -608,3 +608,12 @@ mod issue8845 {
         }
     }
 }
+
+mod issue6902 {
+    use serde::Serialize;
+
+    #[derive(Serialize)]
+    pub enum Foo {
+        Bar = 1,
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 59ee6a89a3e6dc9547002e014470573647f22a8f Mon Sep 17 00:00:00 2001
From: kraktus <kraktus@users.noreply.github.com>
Date: Sat, 10 Sep 2022 11:47:07 +0200
Subject: Remove duplicate context check

---
 clippy_lints/src/use_self.rs | 3 ---
 1 file changed, 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/use_self.rs b/clippy_lints/src/use_self.rs
index d1c00341818..44ab9bca795 100644
--- a/clippy_lints/src/use_self.rs
+++ b/clippy_lints/src/use_self.rs
@@ -214,9 +214,6 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
                 hir_ty_to_ty(cx.tcx, hir_ty)
             };
             if same_type_and_consts(ty, cx.tcx.type_of(impl_id));
-            let hir = cx.tcx.hir();
-            // prevents false positive on `#[derive(serde::Deserialize)]`
-            if !hir.span(hir.get_parent_node(hir_ty.hir_id)).in_derive_expansion();
             then {
                 span_lint(cx, hir_ty.span);
             }
-- 
cgit 1.4.1-3-g733a5


From d50f366612e982afa92897e676e6dbf587e9518c Mon Sep 17 00:00:00 2001
From: kraktus <kraktus@users.noreply.github.com>
Date: Sat, 10 Sep 2022 19:48:14 +0200
Subject: Do not expand macro in `nonminimal_bool` suggestions

---
 clippy_lints/src/booleans.rs    | 2 +-
 tests/ui/nonminimal_bool.rs     | 6 ++++++
 tests/ui/nonminimal_bool.stderr | 8 +++++++-
 3 files changed, 14 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/booleans.rs b/clippy_lints/src/booleans.rs
index 656d639f0ef..03d262d5a59 100644
--- a/clippy_lints/src/booleans.rs
+++ b/clippy_lints/src/booleans.rs
@@ -237,7 +237,7 @@ impl<'a, 'tcx, 'v> SuggestContext<'a, 'tcx, 'v> {
                 }
             },
             &Term(n) => {
-                let snip = snippet_opt(self.cx, self.terminals[n as usize].span)?;
+                let snip = snippet_opt(self.cx, self.terminals[n as usize].span.source_callsite())?;
                 self.output.push_str(&snip);
             },
         }
diff --git a/tests/ui/nonminimal_bool.rs b/tests/ui/nonminimal_bool.rs
index 24ae62bb058..e9b4367ca65 100644
--- a/tests/ui/nonminimal_bool.rs
+++ b/tests/ui/nonminimal_bool.rs
@@ -57,3 +57,9 @@ fn check_expect() {
     #[expect(clippy::nonminimal_bool)]
     let _ = !!a;
 }
+
+fn issue9428() {
+    if matches!(true, true) && true {
+        println!("foo");
+    }
+}
diff --git a/tests/ui/nonminimal_bool.stderr b/tests/ui/nonminimal_bool.stderr
index fc6a5ce1dc2..91b5805aa97 100644
--- a/tests/ui/nonminimal_bool.stderr
+++ b/tests/ui/nonminimal_bool.stderr
@@ -107,5 +107,11 @@ LL |     let _ = !(a == b || c == d);
 LL |     let _ = a != b && c != d;
    |             ~~~~~~~~~~~~~~~~
 
-error: aborting due to 12 previous errors
+error: this boolean expression can be simplified
+  --> $DIR/nonminimal_bool.rs:62:8
+   |
+LL |     if matches!(true, true) && true {
+   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `matches!(true, true)`
+
+error: aborting due to 13 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 86d18b50ed64fa5dd6313d595ad4c53d6eb610a2 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Sun, 11 Sep 2022 12:17:51 +0000
Subject: Fix `unused_peekable` closure and `f(&mut peekable)` false positives

---
 clippy_lints/src/unused_peekable.rs | 36 +++++++++++++++++++++---------------
 tests/ui/unused_peekable.rs         | 33 +++++++++++++++++++++++++++++----
 2 files changed, 50 insertions(+), 19 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unused_peekable.rs b/clippy_lints/src/unused_peekable.rs
index cfc181e435b..13b08df16a5 100644
--- a/clippy_lints/src/unused_peekable.rs
+++ b/clippy_lints/src/unused_peekable.rs
@@ -6,6 +6,7 @@ use rustc_hir::intravisit::{walk_expr, Visitor};
 use rustc_hir::lang_items::LangItem;
 use rustc_hir::{Block, Expr, ExprKind, HirId, Local, Node, PatKind, PathSegment, StmtKind};
 use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::hir::nested_filter::OnlyBodies;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::sym;
 
@@ -109,8 +110,14 @@ impl<'a, 'tcx> PeekableVisitor<'a, 'tcx> {
     }
 }
 
-impl<'tcx> Visitor<'_> for PeekableVisitor<'_, 'tcx> {
-    fn visit_expr(&mut self, ex: &'_ Expr<'_>) {
+impl<'tcx> Visitor<'tcx> for PeekableVisitor<'_, 'tcx> {
+    type NestedFilter = OnlyBodies;
+
+    fn nested_visit_map(&mut self) -> Self::Map {
+        self.cx.tcx.hir()
+    }
+
+    fn visit_expr(&mut self, ex: &'tcx Expr<'tcx>) {
         if self.found_peek_call {
             return;
         }
@@ -136,12 +143,11 @@ impl<'tcx> Visitor<'_> for PeekableVisitor<'_, 'tcx> {
                                     return;
                                 }
 
-                                if args.iter().any(|arg| {
-                                    matches!(arg.kind, ExprKind::Path(_)) && arg_is_mut_peekable(self.cx, arg)
-                                }) {
+                                if args.iter().any(|arg| arg_is_mut_peekable(self.cx, arg)) {
                                     self.found_peek_call = true;
-                                    return;
                                 }
+
+                                return;
                             },
                             // Catch anything taking a Peekable mutably
                             ExprKind::MethodCall(
@@ -190,21 +196,21 @@ impl<'tcx> Visitor<'_> for PeekableVisitor<'_, 'tcx> {
                     Node::Local(Local { init: Some(init), .. }) => {
                         if arg_is_mut_peekable(self.cx, init) {
                             self.found_peek_call = true;
-                            return;
                         }
 
-                        break;
+                        return;
                     },
-                    Node::Stmt(stmt) => match stmt.kind {
-                        StmtKind::Expr(_) | StmtKind::Semi(_) => {},
-                        _ => {
-                            self.found_peek_call = true;
-                            return;
-                        },
+                    Node::Stmt(stmt) => {
+                        match stmt.kind {
+                            StmtKind::Local(_) | StmtKind::Item(_) => self.found_peek_call = true,
+                            StmtKind::Expr(_) | StmtKind::Semi(_) => {},
+                        }
+
+                        return;
                     },
                     Node::Block(_) | Node::ExprField(_) => {},
                     _ => {
-                        break;
+                        return;
                     },
                 }
             }
diff --git a/tests/ui/unused_peekable.rs b/tests/ui/unused_peekable.rs
index 153457e3671..7374dfdf92e 100644
--- a/tests/ui/unused_peekable.rs
+++ b/tests/ui/unused_peekable.rs
@@ -57,12 +57,22 @@ fn valid() {
     impl PeekableConsumer {
         fn consume(&self, _: Peekable<Empty<u32>>) {}
         fn consume_mut_ref(&self, _: &mut Peekable<Empty<u32>>) {}
+        fn consume_assoc(_: Peekable<Empty<u32>>) {}
+        fn consume_assoc_mut_ref(_: &mut Peekable<Empty<u32>>) {}
     }
-
     let peekable_consumer = PeekableConsumer;
-    let mut passed_along_to_method = std::iter::empty::<u32>().peekable();
-    peekable_consumer.consume_mut_ref(&mut passed_along_to_method);
-    peekable_consumer.consume(passed_along_to_method);
+
+    let peekable = std::iter::empty::<u32>().peekable();
+    peekable_consumer.consume(peekable);
+
+    let mut peekable = std::iter::empty::<u32>().peekable();
+    peekable_consumer.consume_mut_ref(&mut peekable);
+
+    let peekable = std::iter::empty::<u32>().peekable();
+    PeekableConsumer::consume_assoc(peekable);
+
+    let mut peekable = std::iter::empty::<u32>().peekable();
+    PeekableConsumer::consume_assoc_mut_ref(&mut peekable);
 
     // `peek` called in another block
     let mut peekable_in_block = std::iter::empty::<u32>().peekable();
@@ -141,4 +151,19 @@ fn valid() {
     {
         peekable_last_expr.peek();
     }
+
+    let mut peek_in_closure = std::iter::empty::<u32>().peekable();
+    let _ = || {
+        let _ = peek_in_closure.peek();
+    };
+
+    trait PeekTrait {}
+    impl<I> PeekTrait for Peekable<I> where I: Iterator {}
+
+    let mut peekable = std::iter::empty::<u32>().peekable();
+    let _dyn = &mut peekable as &mut dyn PeekTrait;
+
+    fn takes_dyn(_: &mut dyn PeekTrait) {}
+    let mut peekable = std::iter::empty::<u32>().peekable();
+    takes_dyn(&mut peekable);
 }
-- 
cgit 1.4.1-3-g733a5


From 6f41a44c3e587354061ff3081470b7b214395196 Mon Sep 17 00:00:00 2001
From: Lukas Lueg <lukas.lueg@gmail.com>
Date: Sun, 11 Sep 2022 16:24:33 +0200
Subject: Dont lint `large_stack_array` inside static items

Fixes #9460
---
 clippy_lints/src/large_stack_arrays.rs | 50 ++++++++++++++++------------------
 tests/ui/large_stack_arrays.rs         |  6 ++++
 tests/ui/large_stack_arrays.stderr     |  8 +++---
 3 files changed, 34 insertions(+), 30 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/large_stack_arrays.rs b/clippy_lints/src/large_stack_arrays.rs
index 0acbd81aec3..5857d81ab1f 100644
--- a/clippy_lints/src/large_stack_arrays.rs
+++ b/clippy_lints/src/large_stack_arrays.rs
@@ -1,7 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::source::snippet;
-use if_chain::if_chain;
-use rustc_hir::{Expr, ExprKind};
+use rustc_hir::{Expr, ExprKind, Item, ItemKind, Node};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::layout::LayoutOf;
 use rustc_middle::ty::{self, ConstKind};
@@ -39,29 +38,28 @@ impl_lint_pass!(LargeStackArrays => [LARGE_STACK_ARRAYS]);
 
 impl<'tcx> LateLintPass<'tcx> for LargeStackArrays {
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
-        if_chain! {
-            if let ExprKind::Repeat(_, _) = expr.kind;
-            if let ty::Array(element_type, cst) = cx.typeck_results().expr_ty(expr).kind();
-            if let ConstKind::Value(ty::ValTree::Leaf(element_count)) = cst.kind();
-            if let Ok(element_count) = element_count.try_to_machine_usize(cx.tcx);
-            if let Ok(element_size) = cx.layout_of(*element_type).map(|l| l.size.bytes());
-            if self.maximum_allowed_size < element_count * element_size;
-            then {
-                span_lint_and_help(
-                    cx,
-                    LARGE_STACK_ARRAYS,
-                    expr.span,
-                    &format!(
-                        "allocating a local array larger than {} bytes",
-                        self.maximum_allowed_size
-                    ),
-                    None,
-                    &format!(
-                        "consider allocating on the heap with `vec!{}.into_boxed_slice()`",
-                        snippet(cx, expr.span, "[...]")
-                    ),
-                );
-            }
-        }
+        if let ExprKind::Repeat(_, _) = expr.kind
+          && let ty::Array(element_type, cst) = cx.typeck_results().expr_ty(expr).kind()
+          && let ConstKind::Value(ty::ValTree::Leaf(element_count)) = cst.kind()
+          && let Ok(element_count) = element_count.try_to_machine_usize(cx.tcx)
+          && let Ok(element_size) = cx.layout_of(*element_type).map(|l| l.size.bytes())
+          && !cx.tcx.hir().parent_iter(expr.hir_id)
+              .any(|(_, node)| matches!(node, Node::Item(Item { kind: ItemKind::Static(..), .. })))
+          && self.maximum_allowed_size < element_count * element_size {
+              span_lint_and_help(
+                  cx,
+                  LARGE_STACK_ARRAYS,
+                  expr.span,
+                  &format!(
+                      "allocating a local array larger than {} bytes",
+                      self.maximum_allowed_size
+                  ),
+                  None,
+                  &format!(
+                      "consider allocating on the heap with `vec!{}.into_boxed_slice()`",
+                      snippet(cx, expr.span, "[...]")
+                  ),
+              );
+          }
     }
 }
diff --git a/tests/ui/large_stack_arrays.rs b/tests/ui/large_stack_arrays.rs
index d9161bfcf15..6790765f803 100644
--- a/tests/ui/large_stack_arrays.rs
+++ b/tests/ui/large_stack_arrays.rs
@@ -12,6 +12,12 @@ enum E {
     T(u32),
 }
 
+pub static DOESNOTLINT: [u8; 512_001] = [0; 512_001];
+pub static DOESNOTLINT2: [u8; 512_001] = {
+    let x = 0;
+    [x; 512_001]
+};
+
 fn main() {
     let bad = (
         [0u32; 20_000_000],
diff --git a/tests/ui/large_stack_arrays.stderr b/tests/ui/large_stack_arrays.stderr
index 58c0a77c1c8..0d91b65b428 100644
--- a/tests/ui/large_stack_arrays.stderr
+++ b/tests/ui/large_stack_arrays.stderr
@@ -1,5 +1,5 @@
 error: allocating a local array larger than 512000 bytes
-  --> $DIR/large_stack_arrays.rs:17:9
+  --> $DIR/large_stack_arrays.rs:23:9
    |
 LL |         [0u32; 20_000_000],
    |         ^^^^^^^^^^^^^^^^^^
@@ -8,7 +8,7 @@ LL |         [0u32; 20_000_000],
    = help: consider allocating on the heap with `vec![0u32; 20_000_000].into_boxed_slice()`
 
 error: allocating a local array larger than 512000 bytes
-  --> $DIR/large_stack_arrays.rs:18:9
+  --> $DIR/large_stack_arrays.rs:24:9
    |
 LL |         [S { data: [0; 32] }; 5000],
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -16,7 +16,7 @@ LL |         [S { data: [0; 32] }; 5000],
    = help: consider allocating on the heap with `vec![S { data: [0; 32] }; 5000].into_boxed_slice()`
 
 error: allocating a local array larger than 512000 bytes
-  --> $DIR/large_stack_arrays.rs:19:9
+  --> $DIR/large_stack_arrays.rs:25:9
    |
 LL |         [Some(""); 20_000_000],
    |         ^^^^^^^^^^^^^^^^^^^^^^
@@ -24,7 +24,7 @@ LL |         [Some(""); 20_000_000],
    = help: consider allocating on the heap with `vec![Some(""); 20_000_000].into_boxed_slice()`
 
 error: allocating a local array larger than 512000 bytes
-  --> $DIR/large_stack_arrays.rs:20:9
+  --> $DIR/large_stack_arrays.rs:26:9
    |
 LL |         [E::T(0); 5000],
    |         ^^^^^^^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From 178f5029705b7713829b3435c0d933cfb6c303ed Mon Sep 17 00:00:00 2001
From: "S. van Dijk" <pyhrr0@protonmail.com>
Date: Sun, 11 Sep 2022 20:15:35 +0200
Subject: Stop lint from checking code expanded from macros.

---
 clippy_lints/src/almost_complete_letter_range.rs | 1 +
 1 file changed, 1 insertion(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/almost_complete_letter_range.rs b/clippy_lints/src/almost_complete_letter_range.rs
index 59a7c535400..2036dca0032 100644
--- a/clippy_lints/src/almost_complete_letter_range.rs
+++ b/clippy_lints/src/almost_complete_letter_range.rs
@@ -79,6 +79,7 @@ fn check_range(cx: &EarlyContext<'_>, span: Span, start: &Expr, end: &Expr, sugg
             (LitKind::Byte(b'a') | LitKind::Char('a'), LitKind::Byte(b'z') | LitKind::Char('z'))
             | (LitKind::Byte(b'A') | LitKind::Char('A'), LitKind::Byte(b'Z') | LitKind::Char('Z'))
         )
+        && !span.from_expansion()
     {
         span_lint_and_then(
             cx,
-- 
cgit 1.4.1-3-g733a5


From 69c7d2cca29f6810744714bbd2c15cbe166c0741 Mon Sep 17 00:00:00 2001
From: "S. van Dijk" <pyhrr0@protonmail.com>
Date: Tue, 13 Sep 2022 09:51:32 +0200
Subject: Only ignore external macros.

---
 clippy_lints/src/almost_complete_letter_range.rs |  3 +-
 tests/ui/almost_complete_letter_range.fixed      | 10 ++++--
 tests/ui/almost_complete_letter_range.rs         |  8 ++++-
 tests/ui/almost_complete_letter_range.stderr     | 39 ++++++++++++++++--------
 tests/ui/auxiliary/macro_rules.rs                |  7 +++++
 5 files changed, 50 insertions(+), 17 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/almost_complete_letter_range.rs b/clippy_lints/src/almost_complete_letter_range.rs
index 2036dca0032..073e4af1318 100644
--- a/clippy_lints/src/almost_complete_letter_range.rs
+++ b/clippy_lints/src/almost_complete_letter_range.rs
@@ -4,6 +4,7 @@ use clippy_utils::{meets_msrv, msrvs};
 use rustc_ast::ast::{Expr, ExprKind, LitKind, Pat, PatKind, RangeEnd, RangeLimits};
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
+use rustc_middle::lint::in_external_macro;
 use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::Span;
@@ -79,7 +80,7 @@ fn check_range(cx: &EarlyContext<'_>, span: Span, start: &Expr, end: &Expr, sugg
             (LitKind::Byte(b'a') | LitKind::Char('a'), LitKind::Byte(b'z') | LitKind::Char('z'))
             | (LitKind::Byte(b'A') | LitKind::Char('A'), LitKind::Byte(b'Z') | LitKind::Char('Z'))
         )
-        && !span.from_expansion()
+        && !in_external_macro(cx.sess(), span)
     {
         span_lint_and_then(
             cx,
diff --git a/tests/ui/almost_complete_letter_range.fixed b/tests/ui/almost_complete_letter_range.fixed
index 0e3f644ca45..079b7c000dc 100644
--- a/tests/ui/almost_complete_letter_range.fixed
+++ b/tests/ui/almost_complete_letter_range.fixed
@@ -1,5 +1,6 @@
 // run-rustfix
 // edition:2018
+// aux-build:macro_rules.rs
 
 #![feature(custom_inner_attributes)]
 #![feature(exclusive_range_pattern)]
@@ -8,6 +9,9 @@
 #![allow(ellipsis_inclusive_range_patterns)]
 #![allow(clippy::needless_parens_on_range_literals)]
 
+#[macro_use]
+extern crate macro_rules;
+
 macro_rules! a {
     () => {
         'a'
@@ -16,7 +20,7 @@ macro_rules! a {
 
 macro_rules! b {
     () => {
-        let _ = 'a'..'z';
+        let _ = 'a'..='z';
     };
 }
 
@@ -37,7 +41,6 @@ fn main() {
     let _ = b'B'..b'Z';
 
     let _ = a!()..='z';
-    b!();
 
     let _ = match 0u8 {
         b'a'..=b'z' if true => 1,
@@ -54,6 +57,9 @@ fn main() {
         'B'..'Z' => 4,
         _ => 5,
     };
+
+    almost_complete_letter_range!();
+    b!();
 }
 
 fn _under_msrv() {
diff --git a/tests/ui/almost_complete_letter_range.rs b/tests/ui/almost_complete_letter_range.rs
index 60402bf39ed..a66900a976e 100644
--- a/tests/ui/almost_complete_letter_range.rs
+++ b/tests/ui/almost_complete_letter_range.rs
@@ -1,5 +1,6 @@
 // run-rustfix
 // edition:2018
+// aux-build:macro_rules.rs
 
 #![feature(custom_inner_attributes)]
 #![feature(exclusive_range_pattern)]
@@ -8,6 +9,9 @@
 #![allow(ellipsis_inclusive_range_patterns)]
 #![allow(clippy::needless_parens_on_range_literals)]
 
+#[macro_use]
+extern crate macro_rules;
+
 macro_rules! a {
     () => {
         'a'
@@ -37,7 +41,6 @@ fn main() {
     let _ = b'B'..b'Z';
 
     let _ = a!()..'z';
-    b!();
 
     let _ = match 0u8 {
         b'a'..b'z' if true => 1,
@@ -54,6 +57,9 @@ fn main() {
         'B'..'Z' => 4,
         _ => 5,
     };
+
+    almost_complete_letter_range!();
+    b!();
 }
 
 fn _under_msrv() {
diff --git a/tests/ui/almost_complete_letter_range.stderr b/tests/ui/almost_complete_letter_range.stderr
index 71acae690d3..3de44c72c1b 100644
--- a/tests/ui/almost_complete_letter_range.stderr
+++ b/tests/ui/almost_complete_letter_range.stderr
@@ -1,5 +1,5 @@
 error: almost complete ascii letter range
-  --> $DIR/almost_complete_letter_range.rs:26:17
+  --> $DIR/almost_complete_letter_range.rs:30:17
    |
 LL |         let _ = ('a') ..'z';
    |                 ^^^^^^--^^^
@@ -9,7 +9,7 @@ LL |         let _ = ('a') ..'z';
    = note: `-D clippy::almost-complete-letter-range` implied by `-D warnings`
 
 error: almost complete ascii letter range
-  --> $DIR/almost_complete_letter_range.rs:27:17
+  --> $DIR/almost_complete_letter_range.rs:31:17
    |
 LL |         let _ = 'A' .. ('Z');
    |                 ^^^^--^^^^^^
@@ -17,7 +17,7 @@ LL |         let _ = 'A' .. ('Z');
    |                     help: use an inclusive range: `..=`
 
 error: almost complete ascii letter range
-  --> $DIR/almost_complete_letter_range.rs:33:13
+  --> $DIR/almost_complete_letter_range.rs:37:13
    |
 LL |     let _ = (b'a')..(b'z');
    |             ^^^^^^--^^^^^^
@@ -25,7 +25,7 @@ LL |     let _ = (b'a')..(b'z');
    |                   help: use an inclusive range: `..=`
 
 error: almost complete ascii letter range
-  --> $DIR/almost_complete_letter_range.rs:34:13
+  --> $DIR/almost_complete_letter_range.rs:38:13
    |
 LL |     let _ = b'A'..b'Z';
    |             ^^^^--^^^^
@@ -33,7 +33,7 @@ LL |     let _ = b'A'..b'Z';
    |                 help: use an inclusive range: `..=`
 
 error: almost complete ascii letter range
-  --> $DIR/almost_complete_letter_range.rs:39:13
+  --> $DIR/almost_complete_letter_range.rs:43:13
    |
 LL |     let _ = a!()..'z';
    |             ^^^^--^^^
@@ -41,7 +41,7 @@ LL |     let _ = a!()..'z';
    |                 help: use an inclusive range: `..=`
 
 error: almost complete ascii letter range
-  --> $DIR/almost_complete_letter_range.rs:43:9
+  --> $DIR/almost_complete_letter_range.rs:46:9
    |
 LL |         b'a'..b'z' if true => 1,
    |         ^^^^--^^^^
@@ -49,7 +49,7 @@ LL |         b'a'..b'z' if true => 1,
    |             help: use an inclusive range: `..=`
 
 error: almost complete ascii letter range
-  --> $DIR/almost_complete_letter_range.rs:44:9
+  --> $DIR/almost_complete_letter_range.rs:47:9
    |
 LL |         b'A'..b'Z' if true => 2,
    |         ^^^^--^^^^
@@ -57,7 +57,7 @@ LL |         b'A'..b'Z' if true => 2,
    |             help: use an inclusive range: `..=`
 
 error: almost complete ascii letter range
-  --> $DIR/almost_complete_letter_range.rs:51:9
+  --> $DIR/almost_complete_letter_range.rs:54:9
    |
 LL |         'a'..'z' if true => 1,
    |         ^^^--^^^
@@ -65,7 +65,7 @@ LL |         'a'..'z' if true => 1,
    |            help: use an inclusive range: `..=`
 
 error: almost complete ascii letter range
-  --> $DIR/almost_complete_letter_range.rs:52:9
+  --> $DIR/almost_complete_letter_range.rs:55:9
    |
 LL |         'A'..'Z' if true => 2,
    |         ^^^--^^^
@@ -73,7 +73,20 @@ LL |         'A'..'Z' if true => 2,
    |            help: use an inclusive range: `..=`
 
 error: almost complete ascii letter range
-  --> $DIR/almost_complete_letter_range.rs:62:9
+  --> $DIR/almost_complete_letter_range.rs:23:17
+   |
+LL |         let _ = 'a'..'z';
+   |                 ^^^--^^^
+   |                    |
+   |                    help: use an inclusive range: `..=`
+...
+LL |     b!();
+   |     ---- in this macro invocation
+   |
+   = note: this error originates in the macro `b` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: almost complete ascii letter range
+  --> $DIR/almost_complete_letter_range.rs:68:9
    |
 LL |         'a'..'z' => 1,
    |         ^^^--^^^
@@ -81,7 +94,7 @@ LL |         'a'..'z' => 1,
    |            help: use an inclusive range: `...`
 
 error: almost complete ascii letter range
-  --> $DIR/almost_complete_letter_range.rs:69:13
+  --> $DIR/almost_complete_letter_range.rs:75:13
    |
 LL |     let _ = 'a'..'z';
    |             ^^^--^^^
@@ -89,12 +102,12 @@ LL |     let _ = 'a'..'z';
    |                help: use an inclusive range: `..=`
 
 error: almost complete ascii letter range
-  --> $DIR/almost_complete_letter_range.rs:71:9
+  --> $DIR/almost_complete_letter_range.rs:77:9
    |
 LL |         'a'..'z' => 1,
    |         ^^^--^^^
    |            |
    |            help: use an inclusive range: `..=`
 
-error: aborting due to 12 previous errors
+error: aborting due to 13 previous errors
 
diff --git a/tests/ui/auxiliary/macro_rules.rs b/tests/ui/auxiliary/macro_rules.rs
index 83a0af6b87a..ef3ca9aea38 100644
--- a/tests/ui/auxiliary/macro_rules.rs
+++ b/tests/ui/auxiliary/macro_rules.rs
@@ -140,3 +140,10 @@ macro_rules! manual_rem_euclid {
 macro_rules! equatable_if_let {
     ($a:ident) => {{ if let 2 = $a {} }};
 }
+
+#[macro_export]
+macro_rules! almost_complete_letter_range {
+    () => {
+        let _ = 'a'..'z';
+    };
+}
-- 
cgit 1.4.1-3-g733a5


From 6f13203b2d305d052140f9a836975b43e7aea5bb Mon Sep 17 00:00:00 2001
From: kraktus <kraktus@users.noreply.github.com>
Date: Mon, 5 Sep 2022 12:04:54 +0200
Subject: Make `derivable_impls` machine applicable

---
 clippy_lints/src/derivable_impls.rs |  24 +++-
 tests/ui/derivable_impls.fixed      | 213 ++++++++++++++++++++++++++++++++++++
 tests/ui/derivable_impls.rs         |   4 +
 tests/ui/derivable_impls.stderr     |  56 +++++++---
 4 files changed, 278 insertions(+), 19 deletions(-)
 create mode 100644 tests/ui/derivable_impls.fixed

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/derivable_impls.rs b/clippy_lints/src/derivable_impls.rs
index ef9eeecc6a9..06ae5abeaeb 100644
--- a/clippy_lints/src/derivable_impls.rs
+++ b/clippy_lints/src/derivable_impls.rs
@@ -1,5 +1,6 @@
-use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::{is_default_equivalent, peel_blocks};
+use rustc_errors::Applicability;
 use rustc_hir::{
     def::{DefKind, Res},
     Body, Expr, ExprKind, GenericArg, Impl, ImplItemKind, Item, ItemKind, Node, PathSegment, QPath, TyKind,
@@ -100,15 +101,28 @@ impl<'tcx> LateLintPass<'tcx> for DerivableImpls {
                     ExprKind::Struct(_, fields, _) => fields.iter().all(|ef| is_default_equivalent(cx, ef.expr)),
                     _ => false,
                 };
+
                 if should_emit {
-                    let path_string = cx.tcx.def_path_str(adt_def.did());
-                    span_lint_and_help(
+                    let struct_span = cx.tcx.def_span(adt_def.did());
+                    span_lint_and_then(
                         cx,
                         DERIVABLE_IMPLS,
                         item.span,
                         "this `impl` can be derived",
-                        None,
-                        &format!("try annotating `{}` with `#[derive(Default)]`", path_string),
+                        |diag| {
+                            diag.span_suggestion_hidden(
+                                item.span,
+                                "remove the manual implementation...",
+                                String::new(),
+                                Applicability::MachineApplicable
+                            );
+                            diag.span_suggestion(
+                                struct_span.shrink_to_lo(),
+                                "...and instead derive it",
+                                "#[derive(Default)]\n".to_string(),
+                                Applicability::MachineApplicable
+                            );
+                        }
                     );
                 }
             }
diff --git a/tests/ui/derivable_impls.fixed b/tests/ui/derivable_impls.fixed
new file mode 100644
index 00000000000..7dcdfb0937e
--- /dev/null
+++ b/tests/ui/derivable_impls.fixed
@@ -0,0 +1,213 @@
+// run-rustfix
+
+#![allow(dead_code)]
+
+use std::collections::HashMap;
+
+#[derive(Default)]
+struct FooDefault<'a> {
+    a: bool,
+    b: i32,
+    c: u64,
+    d: Vec<i32>,
+    e: FooND1,
+    f: FooND2,
+    g: HashMap<i32, i32>,
+    h: (i32, Vec<i32>),
+    i: [Vec<i32>; 3],
+    j: [i32; 5],
+    k: Option<i32>,
+    l: &'a [i32],
+}
+
+
+
+#[derive(Default)]
+struct TupleDefault(bool, i32, u64);
+
+
+
+struct FooND1 {
+    a: bool,
+}
+
+impl std::default::Default for FooND1 {
+    fn default() -> Self {
+        Self { a: true }
+    }
+}
+
+struct FooND2 {
+    a: i32,
+}
+
+impl std::default::Default for FooND2 {
+    fn default() -> Self {
+        Self { a: 5 }
+    }
+}
+
+struct FooNDNew {
+    a: bool,
+}
+
+impl FooNDNew {
+    fn new() -> Self {
+        Self { a: true }
+    }
+}
+
+impl Default for FooNDNew {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+struct FooNDVec(Vec<i32>);
+
+impl Default for FooNDVec {
+    fn default() -> Self {
+        Self(vec![5, 12])
+    }
+}
+
+#[derive(Default)]
+struct StrDefault<'a>(&'a str);
+
+
+
+#[derive(Default)]
+struct AlreadyDerived(i32, bool);
+
+macro_rules! mac {
+    () => {
+        0
+    };
+    ($e:expr) => {
+        struct X(u32);
+        impl Default for X {
+            fn default() -> Self {
+                Self($e)
+            }
+        }
+    };
+}
+
+mac!(0);
+
+#[derive(Default)]
+struct Y(u32);
+
+
+struct RustIssue26925<T> {
+    a: Option<T>,
+}
+
+// We should watch out for cases where a manual impl is needed because a
+// derive adds different type bounds (https://github.com/rust-lang/rust/issues/26925).
+// For example, a struct with Option<T> does not require T: Default, but a derive adds
+// that type bound anyways. So until #26925 get fixed we should disable lint
+// for the following case
+impl<T> Default for RustIssue26925<T> {
+    fn default() -> Self {
+        Self { a: None }
+    }
+}
+
+struct SpecializedImpl<A, B> {
+    a: A,
+    b: B,
+}
+
+impl<T: Default> Default for SpecializedImpl<T, T> {
+    fn default() -> Self {
+        Self {
+            a: T::default(),
+            b: T::default(),
+        }
+    }
+}
+
+#[derive(Default)]
+struct WithoutSelfCurly {
+    a: bool,
+}
+
+
+
+#[derive(Default)]
+struct WithoutSelfParan(bool);
+
+
+
+// https://github.com/rust-lang/rust-clippy/issues/7655
+
+pub struct SpecializedImpl2<T> {
+    v: Vec<T>,
+}
+
+impl Default for SpecializedImpl2<String> {
+    fn default() -> Self {
+        Self { v: Vec::new() }
+    }
+}
+
+// https://github.com/rust-lang/rust-clippy/issues/7654
+
+pub struct Color {
+    pub r: u8,
+    pub g: u8,
+    pub b: u8,
+}
+
+/// `#000000`
+impl Default for Color {
+    fn default() -> Self {
+        Color { r: 0, g: 0, b: 0 }
+    }
+}
+
+pub struct Color2 {
+    pub r: u8,
+    pub g: u8,
+    pub b: u8,
+}
+
+impl Default for Color2 {
+    /// `#000000`
+    fn default() -> Self {
+        Self { r: 0, g: 0, b: 0 }
+    }
+}
+
+#[derive(Default)]
+pub struct RepeatDefault1 {
+    a: [i8; 32],
+}
+
+
+
+pub struct RepeatDefault2 {
+    a: [i8; 33],
+}
+
+impl Default for RepeatDefault2 {
+    fn default() -> Self {
+        RepeatDefault2 { a: [0; 33] }
+    }
+}
+
+// https://github.com/rust-lang/rust-clippy/issues/7753
+
+pub enum IntOrString {
+    Int(i32),
+    String(String),
+}
+
+impl Default for IntOrString {
+    fn default() -> Self {
+        IntOrString::Int(0)
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/derivable_impls.rs b/tests/ui/derivable_impls.rs
index a6412004726..625cbcdde23 100644
--- a/tests/ui/derivable_impls.rs
+++ b/tests/ui/derivable_impls.rs
@@ -1,3 +1,7 @@
+// run-rustfix
+
+#![allow(dead_code)]
+
 use std::collections::HashMap;
 
 struct FooDefault<'a> {
diff --git a/tests/ui/derivable_impls.stderr b/tests/ui/derivable_impls.stderr
index 49fb471a219..c1db5a58b1f 100644
--- a/tests/ui/derivable_impls.stderr
+++ b/tests/ui/derivable_impls.stderr
@@ -1,5 +1,5 @@
 error: this `impl` can be derived
-  --> $DIR/derivable_impls.rs:18:1
+  --> $DIR/derivable_impls.rs:22:1
    |
 LL | / impl std::default::Default for FooDefault<'_> {
 LL | |     fn default() -> Self {
@@ -11,10 +11,14 @@ LL | | }
    | |_^
    |
    = note: `-D clippy::derivable-impls` implied by `-D warnings`
-   = help: try annotating `FooDefault` with `#[derive(Default)]`
+   = help: remove the manual implementation...
+help: ...and instead derive it
+   |
+LL | #[derive(Default)]
+   |
 
 error: this `impl` can be derived
-  --> $DIR/derivable_impls.rs:39:1
+  --> $DIR/derivable_impls.rs:43:1
    |
 LL | / impl std::default::Default for TupleDefault {
 LL | |     fn default() -> Self {
@@ -23,10 +27,14 @@ LL | |     }
 LL | | }
    | |_^
    |
-   = help: try annotating `TupleDefault` with `#[derive(Default)]`
+   = help: remove the manual implementation...
+help: ...and instead derive it
+   |
+LL | #[derive(Default)]
+   |
 
 error: this `impl` can be derived
-  --> $DIR/derivable_impls.rs:91:1
+  --> $DIR/derivable_impls.rs:95:1
    |
 LL | / impl Default for StrDefault<'_> {
 LL | |     fn default() -> Self {
@@ -35,10 +43,14 @@ LL | |     }
 LL | | }
    | |_^
    |
-   = help: try annotating `StrDefault` with `#[derive(Default)]`
+   = help: remove the manual implementation...
+help: ...and instead derive it
+   |
+LL | #[derive(Default)]
+   |
 
 error: this `impl` can be derived
-  --> $DIR/derivable_impls.rs:117:1
+  --> $DIR/derivable_impls.rs:121:1
    |
 LL | / impl Default for Y {
 LL | |     fn default() -> Self {
@@ -47,10 +59,14 @@ LL | |     }
 LL | | }
    | |_^
    |
-   = help: try annotating `Y` with `#[derive(Default)]`
+   = help: remove the manual implementation...
+help: ...and instead derive it
+   |
+LL | #[derive(Default)]
+   |
 
 error: this `impl` can be derived
-  --> $DIR/derivable_impls.rs:156:1
+  --> $DIR/derivable_impls.rs:160:1
    |
 LL | / impl Default for WithoutSelfCurly {
 LL | |     fn default() -> Self {
@@ -59,10 +75,14 @@ LL | |     }
 LL | | }
    | |_^
    |
-   = help: try annotating `WithoutSelfCurly` with `#[derive(Default)]`
+   = help: remove the manual implementation...
+help: ...and instead derive it
+   |
+LL | #[derive(Default)]
+   |
 
 error: this `impl` can be derived
-  --> $DIR/derivable_impls.rs:164:1
+  --> $DIR/derivable_impls.rs:168:1
    |
 LL | / impl Default for WithoutSelfParan {
 LL | |     fn default() -> Self {
@@ -71,10 +91,14 @@ LL | |     }
 LL | | }
    | |_^
    |
-   = help: try annotating `WithoutSelfParan` with `#[derive(Default)]`
+   = help: remove the manual implementation...
+help: ...and instead derive it
+   |
+LL | #[derive(Default)]
+   |
 
 error: this `impl` can be derived
-  --> $DIR/derivable_impls.rs:214:1
+  --> $DIR/derivable_impls.rs:218:1
    |
 LL | / impl Default for RepeatDefault1 {
 LL | |     fn default() -> Self {
@@ -83,7 +107,11 @@ LL | |     }
 LL | | }
    | |_^
    |
-   = help: try annotating `RepeatDefault1` with `#[derive(Default)]`
+   = help: remove the manual implementation...
+help: ...and instead derive it
+   |
+LL | #[derive(Default)]
+   |
 
 error: aborting due to 7 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 611c905482d407581c104ba9d331d612f6f56461 Mon Sep 17 00:00:00 2001
From: Caio <c410.f3r@gmail.com>
Date: Tue, 13 Sep 2022 15:50:24 -0300
Subject: [arithmetic-side-effects] More non-overflowing ops

---
 .../src/operators/arithmetic_side_effects.rs       | 16 +++++++-
 tests/ui/arithmetic_side_effects.rs                | 20 +++++++++-
 tests/ui/arithmetic_side_effects.stderr            | 44 ++++++++++++++++++++--
 3 files changed, 72 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/operators/arithmetic_side_effects.rs b/clippy_lints/src/operators/arithmetic_side_effects.rs
index 83b69fbb311..21c2b76439b 100644
--- a/clippy_lints/src/operators/arithmetic_side_effects.rs
+++ b/clippy_lints/src/operators/arithmetic_side_effects.rs
@@ -48,9 +48,21 @@ impl ArithmeticSideEffects {
         if !Self::is_literal_integer(rhs, rhs_refs) {
             return false;
         }
-        if let hir::BinOpKind::Div | hir::BinOpKind::Mul = op.node
+        if let hir::BinOpKind::Add | hir::BinOpKind::Sub = op.node
             && let hir::ExprKind::Lit(ref lit) = rhs.kind
-            && let ast::LitKind::Int(1, _) = lit.node
+            && let ast::LitKind::Int(0, _) = lit.node
+        {
+            return true;
+        }
+        if let hir::BinOpKind::Div | hir::BinOpKind::Rem = op.node
+            && let hir::ExprKind::Lit(ref lit) = rhs.kind
+            && !matches!(lit.node, ast::LitKind::Int(0, _))
+        {
+            return true;
+        }
+        if let hir::BinOpKind::Mul = op.node
+            && let hir::ExprKind::Lit(ref lit) = rhs.kind
+            && let ast::LitKind::Int(0 | 1, _) = lit.node
         {
             return true;
         }
diff --git a/tests/ui/arithmetic_side_effects.rs b/tests/ui/arithmetic_side_effects.rs
index f5390c74642..a51c2514283 100644
--- a/tests/ui/arithmetic_side_effects.rs
+++ b/tests/ui/arithmetic_side_effects.rs
@@ -1,4 +1,8 @@
-#![allow(clippy::assign_op_pattern, clippy::unnecessary_owned_empty_strings)]
+#![allow(
+    clippy::assign_op_pattern,
+    unconditional_panic,
+    clippy::unnecessary_owned_empty_strings
+)]
 #![feature(inline_const, saturating_int_impl)]
 #![warn(clippy::arithmetic_side_effects)]
 
@@ -41,8 +45,12 @@ pub fn non_overflowing_ops() {
     let _ = const { 1 + 1 };
 
     let mut _a = 1;
+    _a += 0;
+    _a -= 0;
+    _a /= 99;
+    _a %= 99;
+    _a *= 0;
     _a *= 1;
-    _a /= 1;
 }
 
 #[rustfmt::skip]
@@ -52,6 +60,14 @@ pub fn overflowing_ops() {
     let mut _b = 1; _b = _b + 1;
 
     let mut _c = 1; _c = 1 + _c;
+
+    let mut _a = 1;
+    _a += 1;
+    _a -= 1;
+    _a /= 0;
+    _a %= 0;
+    _a *= 2;
+    _a *= 3;
 }
 
 fn main() {}
diff --git a/tests/ui/arithmetic_side_effects.stderr b/tests/ui/arithmetic_side_effects.stderr
index 6c4c8bdec0f..6652a1f8ca8 100644
--- a/tests/ui/arithmetic_side_effects.stderr
+++ b/tests/ui/arithmetic_side_effects.stderr
@@ -1,5 +1,5 @@
 error: arithmetic detected
-  --> $DIR/arithmetic_side_effects.rs:50:21
+  --> $DIR/arithmetic_side_effects.rs:58:21
    |
 LL |     let mut _a = 1; _a += 1;
    |                     ^^^^^^^
@@ -7,16 +7,52 @@ LL |     let mut _a = 1; _a += 1;
    = note: `-D clippy::arithmetic-side-effects` implied by `-D warnings`
 
 error: arithmetic detected
-  --> $DIR/arithmetic_side_effects.rs:52:26
+  --> $DIR/arithmetic_side_effects.rs:60:26
    |
 LL |     let mut _b = 1; _b = _b + 1;
    |                          ^^^^^^
 
 error: arithmetic detected
-  --> $DIR/arithmetic_side_effects.rs:54:26
+  --> $DIR/arithmetic_side_effects.rs:62:26
    |
 LL |     let mut _c = 1; _c = 1 + _c;
    |                          ^^^^^^
 
-error: aborting due to 3 previous errors
+error: arithmetic detected
+  --> $DIR/arithmetic_side_effects.rs:65:5
+   |
+LL |     _a += 1;
+   |     ^^^^^^^
+
+error: arithmetic detected
+  --> $DIR/arithmetic_side_effects.rs:66:5
+   |
+LL |     _a -= 1;
+   |     ^^^^^^^
+
+error: arithmetic detected
+  --> $DIR/arithmetic_side_effects.rs:67:5
+   |
+LL |     _a /= 0;
+   |     ^^^^^^^
+
+error: arithmetic detected
+  --> $DIR/arithmetic_side_effects.rs:68:5
+   |
+LL |     _a %= 0;
+   |     ^^^^^^^
+
+error: arithmetic detected
+  --> $DIR/arithmetic_side_effects.rs:69:5
+   |
+LL |     _a *= 2;
+   |     ^^^^^^^
+
+error: arithmetic detected
+  --> $DIR/arithmetic_side_effects.rs:70:5
+   |
+LL |     _a *= 3;
+   |     ^^^^^^^
+
+error: aborting due to 9 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From e9722feef35587a83a359dbc22bf515fae4ccf66 Mon Sep 17 00:00:00 2001
From: Wim Looman <git@nemo157.com>
Date: Tue, 13 Sep 2022 21:27:01 +0200
Subject: Make module-style lints resilient to --remap-path-prefix

---
 clippy_lints/src/module_style.rs                            |  6 +++---
 tests/ui-cargo/module_style/fail_mod_remap/Cargo.toml       |  9 +++++++++
 tests/ui-cargo/module_style/fail_mod_remap/src/bad.rs       |  1 +
 tests/ui-cargo/module_style/fail_mod_remap/src/bad/inner.rs |  1 +
 tests/ui-cargo/module_style/fail_mod_remap/src/main.rs      |  7 +++++++
 tests/ui-cargo/module_style/fail_mod_remap/src/main.stderr  | 11 +++++++++++
 6 files changed, 32 insertions(+), 3 deletions(-)
 create mode 100644 tests/ui-cargo/module_style/fail_mod_remap/Cargo.toml
 create mode 100644 tests/ui-cargo/module_style/fail_mod_remap/src/bad.rs
 create mode 100644 tests/ui-cargo/module_style/fail_mod_remap/src/bad/inner.rs
 create mode 100644 tests/ui-cargo/module_style/fail_mod_remap/src/main.rs
 create mode 100644 tests/ui-cargo/module_style/fail_mod_remap/src/main.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/module_style.rs b/clippy_lints/src/module_style.rs
index 0a393657267..22071ab3044 100644
--- a/clippy_lints/src/module_style.rs
+++ b/clippy_lints/src/module_style.rs
@@ -2,7 +2,7 @@ use rustc_ast::ast;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_lint::{EarlyContext, EarlyLintPass, Level, LintContext};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::{FileName, RealFileName, SourceFile, Span, SyntaxContext};
+use rustc_span::{FileName, SourceFile, Span, SyntaxContext};
 use std::ffi::OsStr;
 use std::path::{Component, Path};
 
@@ -79,7 +79,7 @@ impl EarlyLintPass for ModStyle {
 
         let files = cx.sess().source_map().files();
 
-        let RealFileName::LocalPath(trim_to_src) = &cx.sess().opts.working_dir else { return };
+        let Some(trim_to_src) = cx.sess().opts.working_dir.local_path() else { return };
 
         // `folder_segments` is all unique folder path segments `path/to/foo.rs` gives
         // `[path, to]` but not foo
@@ -90,7 +90,7 @@ impl EarlyLintPass for ModStyle {
         // `{ foo => path/to/foo.rs, .. }
         let mut file_map = FxHashMap::default();
         for file in files.iter() {
-            if let FileName::Real(RealFileName::LocalPath(lp)) = &file.name {
+            if let FileName::Real(name) = &file.name && let Some(lp) = name.local_path() {
                 let path = if lp.is_relative() {
                     lp
                 } else if let Ok(relative) = lp.strip_prefix(trim_to_src) {
diff --git a/tests/ui-cargo/module_style/fail_mod_remap/Cargo.toml b/tests/ui-cargo/module_style/fail_mod_remap/Cargo.toml
new file mode 100644
index 00000000000..a822fad388f
--- /dev/null
+++ b/tests/ui-cargo/module_style/fail_mod_remap/Cargo.toml
@@ -0,0 +1,9 @@
+[package]
+name = "fail-mod-remap"
+version = "0.1.0"
+edition = "2018"
+publish = false
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
diff --git a/tests/ui-cargo/module_style/fail_mod_remap/src/bad.rs b/tests/ui-cargo/module_style/fail_mod_remap/src/bad.rs
new file mode 100644
index 00000000000..509aad18622
--- /dev/null
+++ b/tests/ui-cargo/module_style/fail_mod_remap/src/bad.rs
@@ -0,0 +1 @@
+pub mod inner;
diff --git a/tests/ui-cargo/module_style/fail_mod_remap/src/bad/inner.rs b/tests/ui-cargo/module_style/fail_mod_remap/src/bad/inner.rs
new file mode 100644
index 00000000000..8b137891791
--- /dev/null
+++ b/tests/ui-cargo/module_style/fail_mod_remap/src/bad/inner.rs
@@ -0,0 +1 @@
+
diff --git a/tests/ui-cargo/module_style/fail_mod_remap/src/main.rs b/tests/ui-cargo/module_style/fail_mod_remap/src/main.rs
new file mode 100644
index 00000000000..ba4c8c873dd
--- /dev/null
+++ b/tests/ui-cargo/module_style/fail_mod_remap/src/main.rs
@@ -0,0 +1,7 @@
+// compile-flags: --remap-path-prefix {{src-base}}=/remapped
+
+#![warn(clippy::self_named_module_files)]
+
+mod bad;
+
+fn main() {}
diff --git a/tests/ui-cargo/module_style/fail_mod_remap/src/main.stderr b/tests/ui-cargo/module_style/fail_mod_remap/src/main.stderr
new file mode 100644
index 00000000000..46991ff662e
--- /dev/null
+++ b/tests/ui-cargo/module_style/fail_mod_remap/src/main.stderr
@@ -0,0 +1,11 @@
+error: `mod.rs` files are required, found `bad.rs`
+  --> /remapped/module_style/fail_mod_remap/src/bad.rs:1:1
+   |
+LL | pub mod inner;
+   | ^
+   |
+   = note: `-D clippy::self-named-module-files` implied by `-D warnings`
+   = help: move `bad.rs` to `bad/mod.rs`
+
+error: aborting due to previous error
+
-- 
cgit 1.4.1-3-g733a5


From 1eb41804a28b8e9b7643a61f3c224a06aba1f433 Mon Sep 17 00:00:00 2001
From: Jacob Kiesel <kieseljake@gmail.com>
Date: Tue, 13 Sep 2022 23:50:47 -0600
Subject: `bool_to_int_with_if` inverse case patch

---
 clippy_lints/src/bool_to_int_with_if.rs | 28 +++++++++++++++++++------
 tests/ui/bool_to_int_with_if.fixed      |  6 ++++++
 tests/ui/bool_to_int_with_if.rs         | 14 +++++++++++++
 tests/ui/bool_to_int_with_if.stderr     | 37 +++++++++++++++++++++++++++------
 4 files changed, 73 insertions(+), 12 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/bool_to_int_with_if.rs b/clippy_lints/src/bool_to_int_with_if.rs
index a4b8cbb0d82..bea74279e03 100644
--- a/clippy_lints/src/bool_to_int_with_if.rs
+++ b/clippy_lints/src/bool_to_int_with_if.rs
@@ -55,15 +55,28 @@ fn check_if_else<'tcx>(ctx: &LateContext<'tcx>, expr: &'tcx rustc_hir::Expr<'tcx
     if let ExprKind::If(check, then, Some(else_)) = expr.kind
         && let Some(then_lit) = int_literal(then)
         && let Some(else_lit) = int_literal(else_)
-        && check_int_literal_equals_val(then_lit, 1)
-        && check_int_literal_equals_val(else_lit, 0)
     {
+        let inverted = if
+            check_int_literal_equals_val(then_lit, 1)
+            && check_int_literal_equals_val(else_lit, 0) {
+            false
+        } else if
+            check_int_literal_equals_val(then_lit, 0)
+            && check_int_literal_equals_val(else_lit, 1) {
+            true
+        } else {
+            // Expression isn't boolean, exit
+            return;
+        };
         let mut applicability = Applicability::MachineApplicable;
         let snippet = snippet_block_with_applicability(ctx, check.span, "..", None, &mut applicability);
+
+        let invert = if inverted { "!" } else { "" };
+        let need_parens = should_have_parentheses(check);
+
         let snippet_with_braces = {
-            let need_parens = should_have_parentheses(check);
             let (left_paren, right_paren) = if need_parens {("(", ")")} else {("", "")};
-            format!("{left_paren}{snippet}{right_paren}")
+            format!("{invert}{left_paren}{snippet}{right_paren}")
         };
 
         let ty = ctx.typeck_results().expr_ty(then_lit); // then and else must be of same type
@@ -71,11 +84,14 @@ fn check_if_else<'tcx>(ctx: &LateContext<'tcx>, expr: &'tcx rustc_hir::Expr<'tcx
         let suggestion = {
             let wrap_in_curly = is_else_clause(ctx.tcx, expr);
             let (left_curly, right_curly) = if wrap_in_curly {("{", "}")} else {("", "")};
+            let (left_paren, right_paren) = if inverted && need_parens {("(", ")")} else {("", "")};
             format!(
-                "{left_curly}{ty}::from({snippet}){right_curly}"
+                "{left_curly}{ty}::from({invert}{left_paren}{snippet}{right_paren}){right_curly}"
             )
         }; // when used in else clause if statement should be wrapped in curly braces
 
+        let (inverted_left_paren, inverted_right_paren) = if inverted {("(", ")")} else {("", "")};
+
         span_lint_and_then(ctx,
             BOOL_TO_INT_WITH_IF,
             expr.span,
@@ -87,7 +103,7 @@ fn check_if_else<'tcx>(ctx: &LateContext<'tcx>, expr: &'tcx rustc_hir::Expr<'tcx
                 suggestion,
                 applicability,
             );
-            diag.note(format!("`{snippet_with_braces} as {ty}` or `{snippet_with_braces}.into()` can also be valid options"));
+            diag.note(format!("`{snippet_with_braces} as {ty}` or `{inverted_left_paren}{snippet_with_braces}{inverted_right_paren}.into()` can also be valid options"));
         });
     };
 }
diff --git a/tests/ui/bool_to_int_with_if.fixed b/tests/ui/bool_to_int_with_if.fixed
index 9c1098dc4c1..c48dc941b84 100644
--- a/tests/ui/bool_to_int_with_if.fixed
+++ b/tests/ui/bool_to_int_with_if.fixed
@@ -14,6 +14,7 @@ fn main() {
     // precedence
     i32::from(a);
     i32::from(!a);
+    i32::from(!a);
     i32::from(a || b);
     i32::from(cond(a, b));
     i32::from(x + y < 4);
@@ -23,6 +24,11 @@ fn main() {
         123
     } else {i32::from(b)};
 
+    // if else if inverted
+    if a {
+        123
+    } else {i32::from(!b)};
+
     // Shouldn't lint
 
     if a {
diff --git a/tests/ui/bool_to_int_with_if.rs b/tests/ui/bool_to_int_with_if.rs
index 0c967dac6e2..5d9496f0177 100644
--- a/tests/ui/bool_to_int_with_if.rs
+++ b/tests/ui/bool_to_int_with_if.rs
@@ -17,6 +17,11 @@ fn main() {
     } else {
         0
     };
+    if a {
+        0
+    } else {
+        1
+    };
     if !a {
         1
     } else {
@@ -47,6 +52,15 @@ fn main() {
         0
     };
 
+    // if else if inverted
+    if a {
+        123
+    } else if b {
+        0
+    } else {
+        1
+    };
+
     // Shouldn't lint
 
     if a {
diff --git a/tests/ui/bool_to_int_with_if.stderr b/tests/ui/bool_to_int_with_if.stderr
index 8647a9cffbe..cc3e0395aa4 100644
--- a/tests/ui/bool_to_int_with_if.stderr
+++ b/tests/ui/bool_to_int_with_if.stderr
@@ -14,6 +14,18 @@ LL | |     };
 error: boolean to int conversion using if
   --> $DIR/bool_to_int_with_if.rs:20:5
    |
+LL | /     if a {
+LL | |         0
+LL | |     } else {
+LL | |         1
+LL | |     };
+   | |_____^ help: replace with from: `i32::from(!a)`
+   |
+   = note: `!a as i32` or `(!a).into()` can also be valid options
+
+error: boolean to int conversion using if
+  --> $DIR/bool_to_int_with_if.rs:25:5
+   |
 LL | /     if !a {
 LL | |         1
 LL | |     } else {
@@ -24,7 +36,7 @@ LL | |     };
    = note: `!a as i32` or `!a.into()` can also be valid options
 
 error: boolean to int conversion using if
-  --> $DIR/bool_to_int_with_if.rs:25:5
+  --> $DIR/bool_to_int_with_if.rs:30:5
    |
 LL | /     if a || b {
 LL | |         1
@@ -36,7 +48,7 @@ LL | |     };
    = note: `(a || b) as i32` or `(a || b).into()` can also be valid options
 
 error: boolean to int conversion using if
-  --> $DIR/bool_to_int_with_if.rs:30:5
+  --> $DIR/bool_to_int_with_if.rs:35:5
    |
 LL | /     if cond(a, b) {
 LL | |         1
@@ -48,7 +60,7 @@ LL | |     };
    = note: `cond(a, b) as i32` or `cond(a, b).into()` can also be valid options
 
 error: boolean to int conversion using if
-  --> $DIR/bool_to_int_with_if.rs:35:5
+  --> $DIR/bool_to_int_with_if.rs:40:5
    |
 LL | /     if x + y < 4 {
 LL | |         1
@@ -60,7 +72,7 @@ LL | |     };
    = note: `(x + y < 4) as i32` or `(x + y < 4).into()` can also be valid options
 
 error: boolean to int conversion using if
-  --> $DIR/bool_to_int_with_if.rs:44:12
+  --> $DIR/bool_to_int_with_if.rs:49:12
    |
 LL |       } else if b {
    |  ____________^
@@ -73,12 +85,25 @@ LL | |     };
    = note: `b as i32` or `b.into()` can also be valid options
 
 error: boolean to int conversion using if
-  --> $DIR/bool_to_int_with_if.rs:102:5
+  --> $DIR/bool_to_int_with_if.rs:58:12
+   |
+LL |       } else if b {
+   |  ____________^
+LL | |         0
+LL | |     } else {
+LL | |         1
+LL | |     };
+   | |_____^ help: replace with from: `{i32::from(!b)}`
+   |
+   = note: `!b as i32` or `(!b).into()` can also be valid options
+
+error: boolean to int conversion using if
+  --> $DIR/bool_to_int_with_if.rs:116:5
    |
 LL |     if a { 1 } else { 0 }
    |     ^^^^^^^^^^^^^^^^^^^^^ help: replace with from: `u8::from(a)`
    |
    = note: `a as u8` or `a.into()` can also be valid options
 
-error: aborting due to 7 previous errors
+error: aborting due to 9 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 992560087025370e2a0397a67106b0852e238b4e Mon Sep 17 00:00:00 2001
From: Jacob Kiesel <kieseljake@gmail.com>
Date: Wed, 14 Sep 2022 00:27:56 -0600
Subject: dogfood inverse bool_to_int_with_if

---
 clippy_lints/src/dereference.rs                  | 7 ++-----
 clippy_lints/src/methods/unnecessary_to_owned.rs | 2 +-
 tests/ui/len_without_is_empty.rs                 | 2 +-
 3 files changed, 4 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index 88e28018e5d..d1b25a0f1b5 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -297,13 +297,10 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing {
                         if !is_lint_allowed(cx, EXPLICIT_DEREF_METHODS, expr.hir_id)
                             && position.lint_explicit_deref() =>
                     {
+                        let ty_changed_count = usize::from(!deref_method_same_type(expr_ty, typeck.expr_ty(sub_expr)));
                         self.state = Some((
                             State::DerefMethod {
-                                ty_changed_count: if deref_method_same_type(expr_ty, typeck.expr_ty(sub_expr)) {
-                                    0
-                                } else {
-                                    1
-                                },
+                                ty_changed_count,
                                 is_final_ufcs: matches!(expr.kind, ExprKind::Call(..)),
                                 target_mut,
                             },
diff --git a/clippy_lints/src/methods/unnecessary_to_owned.rs b/clippy_lints/src/methods/unnecessary_to_owned.rs
index 763bfafecef..b32e5d8d421 100644
--- a/clippy_lints/src/methods/unnecessary_to_owned.rs
+++ b/clippy_lints/src/methods/unnecessary_to_owned.rs
@@ -269,7 +269,7 @@ fn check_other_call_arg<'tcx>(
         // We can't add an `&` when the trait is `Deref` because `Target = &T` won't match
         // `Target = T`.
         if n_refs > 0 || is_copy(cx, receiver_ty) || trait_predicate.def_id() != deref_trait_id;
-        let n_refs = max(n_refs, if is_copy(cx, receiver_ty) { 0 } else { 1 });
+        let n_refs = max(n_refs, usize::from(!is_copy(cx, receiver_ty)));
         if let Some(receiver_snippet) = snippet_opt(cx, receiver.span);
         then {
             span_lint_and_sugg(
diff --git a/tests/ui/len_without_is_empty.rs b/tests/ui/len_without_is_empty.rs
index 1e938e72b57..78397c2af34 100644
--- a/tests/ui/len_without_is_empty.rs
+++ b/tests/ui/len_without_is_empty.rs
@@ -274,7 +274,7 @@ impl AsyncLen {
     }
 
     pub async fn len(&self) -> usize {
-        if self.async_task().await { 0 } else { 1 }
+        usize::from(!self.async_task().await)
     }
 
     pub async fn is_empty(&self) -> bool {
-- 
cgit 1.4.1-3-g733a5


From 4ffdce09b6bbbeb6462f13cd2a3da311578a679f Mon Sep 17 00:00:00 2001
From: Jacob Kiesel <kieseljake@live.com>
Date: Wed, 14 Sep 2022 13:28:54 -0600
Subject: refactor: use clippy_utils::Sugg instead of direct string ops

---
 clippy_lints/src/bool_to_int_with_if.rs | 37 ++++++++++++++-------------------
 tests/ui/bool_to_int_with_if.fixed      |  4 ++--
 tests/ui/bool_to_int_with_if.stderr     |  6 +++---
 3 files changed, 21 insertions(+), 26 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/bool_to_int_with_if.rs b/clippy_lints/src/bool_to_int_with_if.rs
index bea74279e03..51e98cda845 100644
--- a/clippy_lints/src/bool_to_int_with_if.rs
+++ b/clippy_lints/src/bool_to_int_with_if.rs
@@ -1,9 +1,9 @@
-use rustc_ast::{ExprPrecedence, LitKind};
+use rustc_ast::LitKind;
 use rustc_hir::{Block, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
-use clippy_utils::{diagnostics::span_lint_and_then, is_else_clause, source::snippet_block_with_applicability};
+use clippy_utils::{diagnostics::span_lint_and_then, is_else_clause, sugg::Sugg};
 use rustc_errors::Applicability;
 
 declare_clippy_lint! {
@@ -69,28 +69,27 @@ fn check_if_else<'tcx>(ctx: &LateContext<'tcx>, expr: &'tcx rustc_hir::Expr<'tcx
             return;
         };
         let mut applicability = Applicability::MachineApplicable;
-        let snippet = snippet_block_with_applicability(ctx, check.span, "..", None, &mut applicability);
-
-        let invert = if inverted { "!" } else { "" };
-        let need_parens = should_have_parentheses(check);
-
-        let snippet_with_braces = {
-            let (left_paren, right_paren) = if need_parens {("(", ")")} else {("", "")};
-            format!("{invert}{left_paren}{snippet}{right_paren}")
+        let snippet = {
+            let mut sugg = Sugg::hir_with_applicability(ctx, check, "..", &mut applicability);
+            if inverted {
+                sugg = !sugg;
+            }
+            sugg
         };
 
         let ty = ctx.typeck_results().expr_ty(then_lit); // then and else must be of same type
 
         let suggestion = {
             let wrap_in_curly = is_else_clause(ctx.tcx, expr);
-            let (left_curly, right_curly) = if wrap_in_curly {("{", "}")} else {("", "")};
-            let (left_paren, right_paren) = if inverted && need_parens {("(", ")")} else {("", "")};
-            format!(
-                "{left_curly}{ty}::from({invert}{left_paren}{snippet}{right_paren}){right_curly}"
-            )
+            let mut s = Sugg::NonParen(format!("{ty}::from({snippet})").into());
+            if wrap_in_curly {
+                s = s.blockify();
+            }
+            s
         }; // when used in else clause if statement should be wrapped in curly braces
 
-        let (inverted_left_paren, inverted_right_paren) = if inverted {("(", ")")} else {("", "")};
+        let into_snippet = snippet.clone().maybe_par();
+        let as_snippet = snippet.as_ty(ty);
 
         span_lint_and_then(ctx,
             BOOL_TO_INT_WITH_IF,
@@ -103,7 +102,7 @@ fn check_if_else<'tcx>(ctx: &LateContext<'tcx>, expr: &'tcx rustc_hir::Expr<'tcx
                 suggestion,
                 applicability,
             );
-            diag.note(format!("`{snippet_with_braces} as {ty}` or `{inverted_left_paren}{snippet_with_braces}{inverted_right_paren}.into()` can also be valid options"));
+            diag.note(format!("`{as_snippet}` or `{into_snippet}.into()` can also be valid options"));
         });
     };
 }
@@ -135,7 +134,3 @@ fn check_int_literal_equals_val<'tcx>(expr: &'tcx rustc_hir::Expr<'tcx>, expecte
         false
     }
 }
-
-fn should_have_parentheses<'tcx>(check: &'tcx rustc_hir::Expr<'tcx>) -> bool {
-    check.precedence().order() < ExprPrecedence::Cast.order()
-}
diff --git a/tests/ui/bool_to_int_with_if.fixed b/tests/ui/bool_to_int_with_if.fixed
index c48dc941b84..2c8339cdd7f 100644
--- a/tests/ui/bool_to_int_with_if.fixed
+++ b/tests/ui/bool_to_int_with_if.fixed
@@ -22,12 +22,12 @@ fn main() {
     // if else if
     if a {
         123
-    } else {i32::from(b)};
+    } else { i32::from(b) };
 
     // if else if inverted
     if a {
         123
-    } else {i32::from(!b)};
+    } else { i32::from(!b) };
 
     // Shouldn't lint
 
diff --git a/tests/ui/bool_to_int_with_if.stderr b/tests/ui/bool_to_int_with_if.stderr
index cc3e0395aa4..e695440f668 100644
--- a/tests/ui/bool_to_int_with_if.stderr
+++ b/tests/ui/bool_to_int_with_if.stderr
@@ -33,7 +33,7 @@ LL | |         0
 LL | |     };
    | |_____^ help: replace with from: `i32::from(!a)`
    |
-   = note: `!a as i32` or `!a.into()` can also be valid options
+   = note: `!a as i32` or `(!a).into()` can also be valid options
 
 error: boolean to int conversion using if
   --> $DIR/bool_to_int_with_if.rs:30:5
@@ -80,7 +80,7 @@ LL | |         1
 LL | |     } else {
 LL | |         0
 LL | |     };
-   | |_____^ help: replace with from: `{i32::from(b)}`
+   | |_____^ help: replace with from: `{ i32::from(b) }`
    |
    = note: `b as i32` or `b.into()` can also be valid options
 
@@ -93,7 +93,7 @@ LL | |         0
 LL | |     } else {
 LL | |         1
 LL | |     };
-   | |_____^ help: replace with from: `{i32::from(!b)}`
+   | |_____^ help: replace with from: `{ i32::from(!b) }`
    |
    = note: `!b as i32` or `(!b).into()` can also be valid options
 
-- 
cgit 1.4.1-3-g733a5


From 5afc261c66896ed3d14f9d9eccbc7a1090d379d3 Mon Sep 17 00:00:00 2001
From: Kartavya Vashishtha <sendtokartavya@gmail.com>
Date: Tue, 30 Aug 2022 00:09:25 +0530
Subject: Add iter_kv_map lint

---
 CHANGELOG.md                                |   1 +
 clippy_lints/src/lib.register_all.rs        |   1 +
 clippy_lints/src/lib.register_complexity.rs |   1 +
 clippy_lints/src/lib.register_lints.rs      |   1 +
 clippy_lints/src/methods/iter_kv_map.rs     |  87 ++++++++++++++++
 clippy_lints/src/methods/mod.rs             |  36 +++++++
 src/docs.rs                                 |   1 +
 src/docs/iter_kv_map.txt                    |  22 +++++
 tests/ui/iter_kv_map.fixed                  |  65 ++++++++++++
 tests/ui/iter_kv_map.rs                     |  65 ++++++++++++
 tests/ui/iter_kv_map.stderr                 | 148 ++++++++++++++++++++++++++++
 11 files changed, 428 insertions(+)
 create mode 100644 clippy_lints/src/methods/iter_kv_map.rs
 create mode 100644 src/docs/iter_kv_map.txt
 create mode 100644 tests/ui/iter_kv_map.fixed
 create mode 100644 tests/ui/iter_kv_map.rs
 create mode 100644 tests/ui/iter_kv_map.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index d847e4c7494..044cbff4b78 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3800,6 +3800,7 @@ Released 2018-09-13
 [`items_after_statements`]: https://rust-lang.github.io/rust-clippy/master/index.html#items_after_statements
 [`iter_cloned_collect`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_cloned_collect
 [`iter_count`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_count
+[`iter_kv_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_kv_map
 [`iter_next_loop`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_next_loop
 [`iter_next_slice`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_next_slice
 [`iter_not_returning_iterator`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_not_returning_iterator
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 1f85382347a..3e9af5a4d45 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -171,6 +171,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(methods::ITERATOR_STEP_BY_ZERO),
     LintId::of(methods::ITER_CLONED_COLLECT),
     LintId::of(methods::ITER_COUNT),
+    LintId::of(methods::ITER_KV_MAP),
     LintId::of(methods::ITER_NEXT_SLICE),
     LintId::of(methods::ITER_NTH),
     LintId::of(methods::ITER_NTH_ZERO),
diff --git a/clippy_lints/src/lib.register_complexity.rs b/clippy_lints/src/lib.register_complexity.rs
index aa247352f88..185189a6af5 100644
--- a/clippy_lints/src/lib.register_complexity.rs
+++ b/clippy_lints/src/lib.register_complexity.rs
@@ -40,6 +40,7 @@ store.register_group(true, "clippy::complexity", Some("clippy_complexity"), vec!
     LintId::of(methods::GET_LAST_WITH_LEN),
     LintId::of(methods::INSPECT_FOR_EACH),
     LintId::of(methods::ITER_COUNT),
+    LintId::of(methods::ITER_KV_MAP),
     LintId::of(methods::MANUAL_FILTER_MAP),
     LintId::of(methods::MANUAL_FIND_MAP),
     LintId::of(methods::MANUAL_SPLIT_ONCE),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 962e6722006..446bc762fb4 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -313,6 +313,7 @@ store.register_lints(&[
     methods::ITERATOR_STEP_BY_ZERO,
     methods::ITER_CLONED_COLLECT,
     methods::ITER_COUNT,
+    methods::ITER_KV_MAP,
     methods::ITER_NEXT_SLICE,
     methods::ITER_NTH,
     methods::ITER_NTH_ZERO,
diff --git a/clippy_lints/src/methods/iter_kv_map.rs b/clippy_lints/src/methods/iter_kv_map.rs
new file mode 100644
index 00000000000..a7eecabd684
--- /dev/null
+++ b/clippy_lints/src/methods/iter_kv_map.rs
@@ -0,0 +1,87 @@
+#![allow(unused_imports)]
+
+use super::ITER_KV_MAP;
+use clippy_utils::diagnostics::{multispan_sugg, span_lint_and_sugg, span_lint_and_then};
+use clippy_utils::source::{snippet, snippet_with_applicability};
+use clippy_utils::sugg;
+use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::visitors::is_local_used;
+use rustc_hir::{BindingAnnotation, Body, BorrowKind, Expr, ExprKind, Mutability, Pat, PatKind};
+use rustc_lint::{LateContext, LintContext};
+use rustc_middle::ty;
+use rustc_span::sym;
+use rustc_span::Span;
+
+/// lint use of:
+/// - `hashmap.iter().map(|(_, v)| v)`
+/// - `hashmap.into_iter().map(|(_, v)| v)`
+/// on `HashMaps` and `BTreeMaps` in std
+
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    map_type: &'tcx str,     // iter / into_iter
+    expr: &'tcx Expr<'tcx>,  // .iter().map(|(_, v_| v))
+    recv: &'tcx Expr<'tcx>,  // hashmap
+    m_arg: &'tcx Expr<'tcx>, // |(_, v)| v
+) {
+    if_chain! {
+        if !expr.span.from_expansion();
+        if let ExprKind::Closure(c) = m_arg.kind;
+        if let Body {params: [p], value: body_expr, generator_kind: _ } = cx.tcx.hir().body(c.body);
+        if let PatKind::Tuple([key_pat, val_pat], _) = p.pat.kind;
+
+        let (replacement_kind, binded_ident) = match (&key_pat.kind, &val_pat.kind) {
+            (key, PatKind::Binding(_, _, value, _)) if pat_is_wild(cx, key, m_arg) => ("value", value),
+            (PatKind::Binding(_, _, key, _), value) if pat_is_wild(cx, value, m_arg) => ("key", key),
+            _ => return,
+        };
+
+        let ty = cx.typeck_results().expr_ty(recv);
+        if is_type_diagnostic_item(cx, ty, sym::HashMap) || is_type_diagnostic_item(cx, ty, sym::BTreeMap);
+
+        then {
+            let mut applicability = rustc_errors::Applicability::MachineApplicable;
+            let recv_snippet = snippet_with_applicability(cx, recv.span, "map", &mut applicability);
+            let into_prefix = if map_type == "into_iter" {"into_"} else {""};
+
+            if_chain! {
+                if let ExprKind::Path(rustc_hir::QPath::Resolved(_, path)) = body_expr.kind;
+                if let [local_ident] = path.segments;
+                if local_ident.ident.as_str() == binded_ident.as_str();
+
+                then {
+                    span_lint_and_sugg(
+                        cx,
+                        ITER_KV_MAP,
+                        expr.span,
+                        &format!("iterating on a map's {}s", replacement_kind),
+                        "try",
+                        format!("{}.{}{}s()", recv_snippet, into_prefix, replacement_kind),
+                        applicability,
+                    );
+                } else {
+                    span_lint_and_sugg(
+                        cx,
+                        ITER_KV_MAP,
+                        expr.span,
+                        &format!("iterating on a map's {}s", replacement_kind),
+                        "try",
+                        format!("{}.{}{}s().map(|{}| {})", recv_snippet, into_prefix, replacement_kind, binded_ident,
+                            snippet_with_applicability(cx, body_expr.span, "/* body */", &mut applicability)),
+                        applicability,
+                    );
+                }
+            }
+        }
+    }
+}
+
+/// Returns `true` if the pattern is a `PatWild`, or is an ident prefixed with `_`
+/// that is not locally used.
+fn pat_is_wild<'tcx>(cx: &LateContext<'tcx>, pat: &'tcx PatKind<'_>, body: &'tcx Expr<'_>) -> bool {
+    match *pat {
+        PatKind::Wild => true,
+        PatKind::Binding(_, id, ident, None) if ident.as_str().starts_with('_') => !is_local_used(cx, body, id),
+        _ => false,
+    }
+}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 41942b20ea1..cdde4c54d63 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -35,6 +35,7 @@ mod into_iter_on_ref;
 mod is_digit_ascii_radix;
 mod iter_cloned_collect;
 mod iter_count;
+mod iter_kv_map;
 mod iter_next_slice;
 mod iter_nth;
 mod iter_nth_zero;
@@ -3036,6 +3037,37 @@ declare_clippy_lint! {
     "use of `File::read_to_end` or `File::read_to_string`"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    ///
+    /// Checks for iterating a map (`HashMap` or `BTreeMap`) and
+    /// ignoring either the keys or values.
+    ///
+    /// ### Why is this bad?
+    ///
+    /// Readability. There are `keys` and `values` methods that
+    /// can be used to express that we only need the keys or the values.
+    ///
+    /// ### Example
+    ///
+    /// ```
+    /// # use std::collections::HashMap;
+    /// let map: HashMap<u32, u32> = HashMap::new();
+    /// let values = map.iter().map(|(_, value)| value).collect::<Vec<_>>();
+    /// ```
+    ///
+    /// Use instead:
+    /// ```
+    /// # use std::collections::HashMap;
+    /// let map: HashMap<u32, u32> = HashMap::new();
+    /// let values = map.values().collect::<Vec<_>>();
+    /// ```
+    #[clippy::version = "1.65.0"]
+    pub ITER_KV_MAP,
+    complexity,
+    "iterating on map using `iter` when `keys` or `values` would do"
+}
+
 pub struct Methods {
     avoid_breaking_exported_api: bool,
     msrv: Option<RustcVersion>,
@@ -3159,6 +3191,7 @@ impl_lint_pass!(Methods => [
     UNNECESSARY_SORT_BY,
     VEC_RESIZE_TO_ZERO,
     VERBOSE_FILE_READS,
+    ITER_KV_MAP,
 ]);
 
 /// Extracts a method call name, args, and `Span` of the method name.
@@ -3498,6 +3531,9 @@ impl Methods {
                 (name @ ("map" | "map_err"), [m_arg]) => {
                     if name == "map" {
                         map_clone::check(cx, expr, recv, m_arg, self.msrv);
+                        if let Some((map_name @ ("iter" | "into_iter"), recv2, _, _)) = method_call(recv) {
+                            iter_kv_map::check(cx, map_name, expr, recv2, m_arg);
+                        }
                     } else {
                         map_err_ignore::check(cx, expr, m_arg);
                     }
diff --git a/src/docs.rs b/src/docs.rs
index f3a5048e7fa..036dd007856 100644
--- a/src/docs.rs
+++ b/src/docs.rs
@@ -221,6 +221,7 @@ docs! {
     "items_after_statements",
     "iter_cloned_collect",
     "iter_count",
+    "iter_kv_map",
     "iter_next_loop",
     "iter_next_slice",
     "iter_not_returning_iterator",
diff --git a/src/docs/iter_kv_map.txt b/src/docs/iter_kv_map.txt
new file mode 100644
index 00000000000..a063c8195ef
--- /dev/null
+++ b/src/docs/iter_kv_map.txt
@@ -0,0 +1,22 @@
+### What it does
+
+Checks for iterating a map (`HashMap` or `BTreeMap`) and
+ignoring either the keys or values.
+
+### Why is this bad?
+
+Readability. There are `keys` and `values` methods that
+can be used to express that we only need the keys or the values.
+
+### Example
+
+```
+let map: HashMap<u32, u32> = HashMap::new();
+let values = map.iter().map(|(_, value)| value).collect::<Vec<_>>();
+```
+
+Use instead:
+```
+let map: HashMap<u32, u32> = HashMap::new();
+let values = map.values().collect::<Vec<_>>();
+```
\ No newline at end of file
diff --git a/tests/ui/iter_kv_map.fixed b/tests/ui/iter_kv_map.fixed
new file mode 100644
index 00000000000..cf1292ecc23
--- /dev/null
+++ b/tests/ui/iter_kv_map.fixed
@@ -0,0 +1,65 @@
+// run-rustfix
+
+#![warn(clippy::iter_kv_map)]
+#![allow(clippy::redundant_clone)]
+#![allow(clippy::suspicious_map)]
+
+use std::collections::{BTreeMap, HashMap};
+
+fn main() {
+    let get_key = |(key, _val)| key;
+
+    let map: HashMap<u32, u32> = HashMap::new();
+
+    let _ = map.keys().collect::<Vec<_>>();
+    let _ = map.values().collect::<Vec<_>>();
+    let _ = map.values().map(|v| v + 2).collect::<Vec<_>>();
+    let _ = map.values().map(|val| {val}).collect::<Vec<_>>();
+
+    let _ = map.clone().into_keys().collect::<Vec<_>>();
+    let _ = map.clone().into_keys().map(|key| key + 2).collect::<Vec<_>>();
+
+    let _ = map.clone().into_values().collect::<Vec<_>>();
+    let _ = map.clone().into_values().map(|val| val + 2).collect::<Vec<_>>();
+
+    let _ = map.clone().values().collect::<Vec<_>>();
+    map.keys().filter(|x| *x % 2 == 0).count();
+
+    // Don't lint
+    map.iter().filter(|(_, val)| *val % 2 == 0).map(|(key, _)| key).count();
+    map.iter().map(get_key).collect::<Vec<_>>();
+
+    // Linting the following could be an improvement to the lint
+    // map.iter().filter_map(|(_, val)| (val % 2 == 0).then(val * 17)).count();
+
+    // Lint
+    map.keys().map(|key| key * 9).count();
+    map.values().map(|value| value * 17).count();
+
+    let map: BTreeMap<u32, u32> = BTreeMap::new();
+
+    let _ = map.keys().collect::<Vec<_>>();
+    let _ = map.values().collect::<Vec<_>>();
+    let _ = map.values().map(|v| v + 2).collect::<Vec<_>>();
+    let _ = map.values().map(|val| {val}).collect::<Vec<_>>();
+
+    let _ = map.clone().into_keys().collect::<Vec<_>>();
+    let _ = map.clone().into_keys().map(|key| key + 2).collect::<Vec<_>>();
+
+    let _ = map.clone().into_values().collect::<Vec<_>>();
+    let _ = map.clone().into_values().map(|val| val + 2).collect::<Vec<_>>();
+
+    let _ = map.clone().values().collect::<Vec<_>>();
+    map.keys().filter(|x| *x % 2 == 0).count();
+
+    // Don't lint
+    map.iter().filter(|(_, val)| *val % 2 == 0).map(|(key, _)| key).count();
+    map.iter().map(get_key).collect::<Vec<_>>();
+
+    // Linting the following could be an improvement to the lint
+    // map.iter().filter_map(|(_, val)| (val % 2 == 0).then(val * 17)).count();
+
+    // Lint
+    map.keys().map(|key| key * 9).count();
+    map.values().map(|value| value * 17).count();
+}
diff --git a/tests/ui/iter_kv_map.rs b/tests/ui/iter_kv_map.rs
new file mode 100644
index 00000000000..b27e559e8e5
--- /dev/null
+++ b/tests/ui/iter_kv_map.rs
@@ -0,0 +1,65 @@
+// run-rustfix
+
+#![warn(clippy::iter_kv_map)]
+#![allow(clippy::redundant_clone)]
+#![allow(clippy::suspicious_map)]
+
+use std::collections::{BTreeMap, HashMap};
+
+fn main() {
+    let get_key = |(key, _val)| key;
+
+    let map: HashMap<u32, u32> = HashMap::new();
+
+    let _ = map.iter().map(|(key, _)| key).collect::<Vec<_>>();
+    let _ = map.iter().map(|(_, value)| value).collect::<Vec<_>>();
+    let _ = map.iter().map(|(_, v)| v + 2).collect::<Vec<_>>();
+    let _ = map.iter().map(|(_, val)| val).collect::<Vec<_>>();
+
+    let _ = map.clone().into_iter().map(|(key, _)| key).collect::<Vec<_>>();
+    let _ = map.clone().into_iter().map(|(key, _)| key + 2).collect::<Vec<_>>();
+
+    let _ = map.clone().into_iter().map(|(_, val)| val).collect::<Vec<_>>();
+    let _ = map.clone().into_iter().map(|(_, val)| val + 2).collect::<Vec<_>>();
+
+    let _ = map.clone().iter().map(|(_, val)| val).collect::<Vec<_>>();
+    map.iter().map(|(key, _)| key).filter(|x| *x % 2 == 0).count();
+
+    // Don't lint
+    map.iter().filter(|(_, val)| *val % 2 == 0).map(|(key, _)| key).count();
+    map.iter().map(get_key).collect::<Vec<_>>();
+
+    // Linting the following could be an improvement to the lint
+    // map.iter().filter_map(|(_, val)| (val % 2 == 0).then(val * 17)).count();
+
+    // Lint
+    map.iter().map(|(key, _value)| key * 9).count();
+    map.iter().map(|(_key, value)| value * 17).count();
+
+    let map: BTreeMap<u32, u32> = BTreeMap::new();
+
+    let _ = map.iter().map(|(key, _)| key).collect::<Vec<_>>();
+    let _ = map.iter().map(|(_, value)| value).collect::<Vec<_>>();
+    let _ = map.iter().map(|(_, v)| v + 2).collect::<Vec<_>>();
+    let _ = map.iter().map(|(_, val)| val).collect::<Vec<_>>();
+
+    let _ = map.clone().into_iter().map(|(key, _)| key).collect::<Vec<_>>();
+    let _ = map.clone().into_iter().map(|(key, _)| key + 2).collect::<Vec<_>>();
+
+    let _ = map.clone().into_iter().map(|(_, val)| val).collect::<Vec<_>>();
+    let _ = map.clone().into_iter().map(|(_, val)| val + 2).collect::<Vec<_>>();
+
+    let _ = map.clone().iter().map(|(_, val)| val).collect::<Vec<_>>();
+    map.iter().map(|(key, _)| key).filter(|x| *x % 2 == 0).count();
+
+    // Don't lint
+    map.iter().filter(|(_, val)| *val % 2 == 0).map(|(key, _)| key).count();
+    map.iter().map(get_key).collect::<Vec<_>>();
+
+    // Linting the following could be an improvement to the lint
+    // map.iter().filter_map(|(_, val)| (val % 2 == 0).then(val * 17)).count();
+
+    // Lint
+    map.iter().map(|(key, _value)| key * 9).count();
+    map.iter().map(|(_key, value)| value * 17).count();
+}
diff --git a/tests/ui/iter_kv_map.stderr b/tests/ui/iter_kv_map.stderr
new file mode 100644
index 00000000000..a6697e423e7
--- /dev/null
+++ b/tests/ui/iter_kv_map.stderr
@@ -0,0 +1,148 @@
+error: iterating on a map's keys
+  --> $DIR/iter_kv_map.rs:14:13
+   |
+LL |     let _ = map.iter().map(|(key, _)| key).collect::<Vec<_>>();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.keys()`
+   |
+   = note: `-D clippy::iter-kv-map` implied by `-D warnings`
+
+error: iterating on a map's values
+  --> $DIR/iter_kv_map.rs:15:13
+   |
+LL |     let _ = map.iter().map(|(_, value)| value).collect::<Vec<_>>();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.values()`
+
+error: iterating on a map's values
+  --> $DIR/iter_kv_map.rs:16:13
+   |
+LL |     let _ = map.iter().map(|(_, v)| v + 2).collect::<Vec<_>>();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.values().map(|v| v + 2)`
+
+error: iterating on a map's values
+  --> $DIR/iter_kv_map.rs:17:13
+   |
+LL |     let _ = map.iter().map(|(_, val)| {val}).collect::<Vec<_>>();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.values().map(|val| {val})`
+
+error: iterating on a map's keys
+  --> $DIR/iter_kv_map.rs:19:13
+   |
+LL |     let _ = map.clone().into_iter().map(|(key, _)| key).collect::<Vec<_>>();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.clone().into_keys()`
+
+error: iterating on a map's keys
+  --> $DIR/iter_kv_map.rs:20:13
+   |
+LL |     let _ = map.clone().into_iter().map(|(key, _)| key + 2).collect::<Vec<_>>();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.clone().into_keys().map(|key| key + 2)`
+
+error: iterating on a map's values
+  --> $DIR/iter_kv_map.rs:22:13
+   |
+LL |     let _ = map.clone().into_iter().map(|(_, val)| val).collect::<Vec<_>>();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.clone().into_values()`
+
+error: iterating on a map's values
+  --> $DIR/iter_kv_map.rs:23:13
+   |
+LL |     let _ = map.clone().into_iter().map(|(_, val)| val + 2).collect::<Vec<_>>();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.clone().into_values().map(|val| val + 2)`
+
+error: iterating on a map's values
+  --> $DIR/iter_kv_map.rs:25:13
+   |
+LL |     let _ = map.clone().iter().map(|(_, val)| val).collect::<Vec<_>>();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.clone().values()`
+
+error: iterating on a map's keys
+  --> $DIR/iter_kv_map.rs:26:5
+   |
+LL |     map.iter().map(|(key, _)| key).filter(|x| *x % 2 == 0).count();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.keys()`
+
+error: iterating on a map's keys
+  --> $DIR/iter_kv_map.rs:36:5
+   |
+LL |     map.iter().map(|(key, _value)| key * 9).count();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.keys().map(|key| key * 9)`
+
+error: iterating on a map's values
+  --> $DIR/iter_kv_map.rs:37:5
+   |
+LL |     map.iter().map(|(_key, value)| value * 17).count();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.values().map(|value| value * 17)`
+
+error: iterating on a map's keys
+  --> $DIR/iter_kv_map.rs:41:13
+   |
+LL |     let _ = map.iter().map(|(key, _)| key).collect::<Vec<_>>();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.keys()`
+
+error: iterating on a map's values
+  --> $DIR/iter_kv_map.rs:42:13
+   |
+LL |     let _ = map.iter().map(|(_, value)| value).collect::<Vec<_>>();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.values()`
+
+error: iterating on a map's values
+  --> $DIR/iter_kv_map.rs:43:13
+   |
+LL |     let _ = map.iter().map(|(_, v)| v + 2).collect::<Vec<_>>();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.values().map(|v| v + 2)`
+
+error: iterating on a map's values
+  --> $DIR/iter_kv_map.rs:44:13
+   |
+LL |     let _ = map.iter().map(|(_, val)| {val}).collect::<Vec<_>>();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.values().map(|val| {val})`
+
+error: iterating on a map's keys
+  --> $DIR/iter_kv_map.rs:46:13
+   |
+LL |     let _ = map.clone().into_iter().map(|(key, _)| key).collect::<Vec<_>>();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.clone().into_keys()`
+
+error: iterating on a map's keys
+  --> $DIR/iter_kv_map.rs:47:13
+   |
+LL |     let _ = map.clone().into_iter().map(|(key, _)| key + 2).collect::<Vec<_>>();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.clone().into_keys().map(|key| key + 2)`
+
+error: iterating on a map's values
+  --> $DIR/iter_kv_map.rs:49:13
+   |
+LL |     let _ = map.clone().into_iter().map(|(_, val)| val).collect::<Vec<_>>();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.clone().into_values()`
+
+error: iterating on a map's values
+  --> $DIR/iter_kv_map.rs:50:13
+   |
+LL |     let _ = map.clone().into_iter().map(|(_, val)| val + 2).collect::<Vec<_>>();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.clone().into_values().map(|val| val + 2)`
+
+error: iterating on a map's values
+  --> $DIR/iter_kv_map.rs:52:13
+   |
+LL |     let _ = map.clone().iter().map(|(_, val)| val).collect::<Vec<_>>();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.clone().values()`
+
+error: iterating on a map's keys
+  --> $DIR/iter_kv_map.rs:53:5
+   |
+LL |     map.iter().map(|(key, _)| key).filter(|x| *x % 2 == 0).count();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.keys()`
+
+error: iterating on a map's keys
+  --> $DIR/iter_kv_map.rs:63:5
+   |
+LL |     map.iter().map(|(key, _value)| key * 9).count();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.keys().map(|key| key * 9)`
+
+error: iterating on a map's values
+  --> $DIR/iter_kv_map.rs:64:5
+   |
+LL |     map.iter().map(|(_key, value)| value * 17).count();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.values().map(|value| value * 17)`
+
+error: aborting due to 24 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From dba5adae6e626e0d709be1146fae19b6801e1655 Mon Sep 17 00:00:00 2001
From: Caio <c410.f3r@gmail.com>
Date: Thu, 15 Sep 2022 13:28:18 -0300
Subject: [arithmetic-side-effects] Finish non-overflowing ops

---
 .../src/operators/arithmetic_side_effects.rs       | 41 +++++-----
 tests/ui/arithmetic_side_effects.rs                | 74 +++++++++++------
 tests/ui/arithmetic_side_effects.stderr            | 94 ++++++++++++++--------
 3 files changed, 127 insertions(+), 82 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/operators/arithmetic_side_effects.rs b/clippy_lints/src/operators/arithmetic_side_effects.rs
index 21c2b76439b..4629ea1f65b 100644
--- a/clippy_lints/src/operators/arithmetic_side_effects.rs
+++ b/clippy_lints/src/operators/arithmetic_side_effects.rs
@@ -42,26 +42,23 @@ impl ArithmeticSideEffects {
         }
     }
 
-    /// Checks assign operators (+=, -=, *=, /=) of integers in a non-constant environment that
-    /// won't overflow.
-    fn has_valid_assign_op(op: &Spanned<hir::BinOpKind>, rhs: &hir::Expr<'_>, rhs_refs: Ty<'_>) -> bool {
-        if !Self::is_literal_integer(rhs, rhs_refs) {
-            return false;
-        }
+    /// Assuming that `expr` is a literal integer, checks assign operators (+=, -=, *=, /=) in a
+    /// non-constant environment that won't overflow.
+    fn has_valid_assign_op(op: &Spanned<hir::BinOpKind>, expr: &hir::Expr<'_>) -> bool {
         if let hir::BinOpKind::Add | hir::BinOpKind::Sub = op.node
-            && let hir::ExprKind::Lit(ref lit) = rhs.kind
+            && let hir::ExprKind::Lit(ref lit) = expr.kind
             && let ast::LitKind::Int(0, _) = lit.node
         {
             return true;
         }
         if let hir::BinOpKind::Div | hir::BinOpKind::Rem = op.node
-            && let hir::ExprKind::Lit(ref lit) = rhs.kind
+            && let hir::ExprKind::Lit(ref lit) = expr.kind
             && !matches!(lit.node, ast::LitKind::Int(0, _))
         {
             return true;
         }
         if let hir::BinOpKind::Mul = op.node
-            && let hir::ExprKind::Lit(ref lit) = rhs.kind
+            && let hir::ExprKind::Lit(ref lit) = expr.kind
             && let ast::LitKind::Int(0 | 1, _) = lit.node
         {
             return true;
@@ -69,12 +66,6 @@ impl ArithmeticSideEffects {
         false
     }
 
-    /// Checks "raw" binary operators (+, -, *, /) of integers in a non-constant environment
-    /// already handled by the CTFE.
-    fn has_valid_bin_op(lhs: &hir::Expr<'_>, lhs_refs: Ty<'_>, rhs: &hir::Expr<'_>, rhs_refs: Ty<'_>) -> bool {
-        Self::is_literal_integer(lhs, lhs_refs) && Self::is_literal_integer(rhs, rhs_refs)
-    }
-
     /// Checks if the given `expr` has any of the inner `allowed` elements.
     fn is_allowed_ty(&self, cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> bool {
         self.allowed.contains(
@@ -95,7 +86,8 @@ impl ArithmeticSideEffects {
     }
 
     fn issue_lint(&mut self, cx: &LateContext<'_>, expr: &hir::Expr<'_>) {
-        span_lint(cx, ARITHMETIC_SIDE_EFFECTS, expr.span, "arithmetic detected");
+        let msg = "arithmetic operation that can potentially result in unexpected side-effects";
+        span_lint(cx, ARITHMETIC_SIDE_EFFECTS, expr.span, msg);
         self.expr_span = Some(expr.span);
     }
 
@@ -127,13 +119,18 @@ impl ArithmeticSideEffects {
         if self.is_allowed_ty(cx, lhs) || self.is_allowed_ty(cx, rhs) {
             return;
         }
-        let lhs_refs = cx.typeck_results().expr_ty(lhs).peel_refs();
-        let rhs_refs = cx.typeck_results().expr_ty(rhs).peel_refs();
-        let has_valid_assign_op = Self::has_valid_assign_op(op, rhs, rhs_refs);
-        if has_valid_assign_op || Self::has_valid_bin_op(lhs, lhs_refs, rhs, rhs_refs) {
-            return;
+        let has_valid_op = match (
+            Self::is_literal_integer(lhs, cx.typeck_results().expr_ty(rhs).peel_refs()),
+            Self::is_literal_integer(rhs, cx.typeck_results().expr_ty(rhs).peel_refs()),
+        ) {
+            (true, true) => true,
+            (true, false) => Self::has_valid_assign_op(op, lhs),
+            (false, true) => Self::has_valid_assign_op(op, rhs),
+            (false, false) => false,
+        };
+        if !has_valid_op {
+            self.issue_lint(cx, expr);
         }
-        self.issue_lint(cx, expr);
     }
 }
 
diff --git a/tests/ui/arithmetic_side_effects.rs b/tests/ui/arithmetic_side_effects.rs
index a51c2514283..c07425be50a 100644
--- a/tests/ui/arithmetic_side_effects.rs
+++ b/tests/ui/arithmetic_side_effects.rs
@@ -1,7 +1,10 @@
 #![allow(
     clippy::assign_op_pattern,
-    unconditional_panic,
-    clippy::unnecessary_owned_empty_strings
+    clippy::erasing_op,
+    clippy::identity_op,
+    clippy::unnecessary_owned_empty_strings,
+    arithmetic_overflow,
+    unconditional_panic
 )]
 #![feature(inline_const, saturating_int_impl)]
 #![warn(clippy::arithmetic_side_effects)]
@@ -30,7 +33,7 @@ pub fn hard_coded_allowed() {
 }
 
 #[rustfmt::skip]
-pub fn non_overflowing_ops() {
+pub fn non_overflowing_const_ops() {
     const _: i32 = { let mut n = 1; n += 1; n };
     let _ = const { let mut n = 1; n += 1; n };
 
@@ -41,33 +44,54 @@ pub fn non_overflowing_ops() {
     let _ = const { let mut n = 1; n = 1 + n; n };
 
     const _: i32 = 1 + 1;
-    let _ = 1 + 1;
     let _ = const { 1 + 1 };
+}
 
-    let mut _a = 1;
-    _a += 0;
-    _a -= 0;
-    _a /= 99;
-    _a %= 99;
-    _a *= 0;
-    _a *= 1;
+pub fn non_overflowing_runtime_ops() {
+    let mut _n = i32::MAX;
+
+    // Assign
+    _n += 0;
+    _n -= 0;
+    _n /= 99;
+    _n %= 99;
+    _n *= 0;
+    _n *= 1;
+
+    // Binary
+    _n = _n + 0;
+    _n = 0 + _n;
+    _n = _n - 0;
+    _n = 0 - _n;
+    _n = _n / 99;
+    _n = _n % 99;
+    _n = _n * 0;
+    _n = 0 * _n;
+    _n = _n * 1;
+    _n = 1 * _n;
+    _n = 23 + 85;
 }
 
 #[rustfmt::skip]
-pub fn overflowing_ops() {
-    let mut _a = 1; _a += 1;
-
-    let mut _b = 1; _b = _b + 1;
-
-    let mut _c = 1; _c = 1 + _c;
-
-    let mut _a = 1;
-    _a += 1;
-    _a -= 1;
-    _a /= 0;
-    _a %= 0;
-    _a *= 2;
-    _a *= 3;
+pub fn overflowing_runtime_ops() {
+    let mut _n = i32::MAX;
+
+    // Assign
+    _n += 1;
+    _n -= 1;
+    _n /= 0;
+    _n %= 0;
+    _n *= 2;
+
+    // Binary
+    _n = _n + 1;
+    _n = 1 + _n;
+    _n = _n - 1;
+    _n = 1 - _n;
+    _n = _n / 0;
+    _n = _n % 0;
+    _n = _n * 2;
+    _n = 2 * _n;
 }
 
 fn main() {}
diff --git a/tests/ui/arithmetic_side_effects.stderr b/tests/ui/arithmetic_side_effects.stderr
index 6652a1f8ca8..2f953d26699 100644
--- a/tests/ui/arithmetic_side_effects.stderr
+++ b/tests/ui/arithmetic_side_effects.stderr
@@ -1,58 +1,82 @@
-error: arithmetic detected
-  --> $DIR/arithmetic_side_effects.rs:58:21
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:80:5
    |
-LL |     let mut _a = 1; _a += 1;
-   |                     ^^^^^^^
+LL |     _n += 1;
+   |     ^^^^^^^
    |
    = note: `-D clippy::arithmetic-side-effects` implied by `-D warnings`
 
-error: arithmetic detected
-  --> $DIR/arithmetic_side_effects.rs:60:26
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:81:5
    |
-LL |     let mut _b = 1; _b = _b + 1;
-   |                          ^^^^^^
+LL |     _n -= 1;
+   |     ^^^^^^^
 
-error: arithmetic detected
-  --> $DIR/arithmetic_side_effects.rs:62:26
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:82:5
    |
-LL |     let mut _c = 1; _c = 1 + _c;
-   |                          ^^^^^^
+LL |     _n /= 0;
+   |     ^^^^^^^
 
-error: arithmetic detected
-  --> $DIR/arithmetic_side_effects.rs:65:5
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:83:5
    |
-LL |     _a += 1;
+LL |     _n %= 0;
    |     ^^^^^^^
 
-error: arithmetic detected
-  --> $DIR/arithmetic_side_effects.rs:66:5
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:84:5
    |
-LL |     _a -= 1;
+LL |     _n *= 2;
    |     ^^^^^^^
 
-error: arithmetic detected
-  --> $DIR/arithmetic_side_effects.rs:67:5
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:87:10
    |
-LL |     _a /= 0;
-   |     ^^^^^^^
+LL |     _n = _n + 1;
+   |          ^^^^^^
 
-error: arithmetic detected
-  --> $DIR/arithmetic_side_effects.rs:68:5
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:88:10
    |
-LL |     _a %= 0;
-   |     ^^^^^^^
+LL |     _n = 1 + _n;
+   |          ^^^^^^
 
-error: arithmetic detected
-  --> $DIR/arithmetic_side_effects.rs:69:5
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:89:10
    |
-LL |     _a *= 2;
-   |     ^^^^^^^
+LL |     _n = _n - 1;
+   |          ^^^^^^
 
-error: arithmetic detected
-  --> $DIR/arithmetic_side_effects.rs:70:5
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:90:10
    |
-LL |     _a *= 3;
-   |     ^^^^^^^
+LL |     _n = 1 - _n;
+   |          ^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:91:10
+   |
+LL |     _n = _n / 0;
+   |          ^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:92:10
+   |
+LL |     _n = _n % 0;
+   |          ^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:93:10
+   |
+LL |     _n = _n * 2;
+   |          ^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:94:10
+   |
+LL |     _n = 2 * _n;
+   |          ^^^^^^
 
-error: aborting due to 9 previous errors
+error: aborting due to 13 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 8bfe3db531993eef4c5de43e48c40d55f803e94d Mon Sep 17 00:00:00 2001
From: Caio <c410.f3r@gmail.com>
Date: Thu, 15 Sep 2022 13:40:49 -0300
Subject: Typo

---
 clippy_lints/src/operators/arithmetic_side_effects.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/operators/arithmetic_side_effects.rs b/clippy_lints/src/operators/arithmetic_side_effects.rs
index 4629ea1f65b..0070eef52e4 100644
--- a/clippy_lints/src/operators/arithmetic_side_effects.rs
+++ b/clippy_lints/src/operators/arithmetic_side_effects.rs
@@ -120,7 +120,7 @@ impl ArithmeticSideEffects {
             return;
         }
         let has_valid_op = match (
-            Self::is_literal_integer(lhs, cx.typeck_results().expr_ty(rhs).peel_refs()),
+            Self::is_literal_integer(lhs, cx.typeck_results().expr_ty(lhs).peel_refs()),
             Self::is_literal_integer(rhs, cx.typeck_results().expr_ty(rhs).peel_refs()),
         ) {
             (true, true) => true,
-- 
cgit 1.4.1-3-g733a5


From b7bef4c8a4029d231fae492bb3cf5d334c19fd0a Mon Sep 17 00:00:00 2001
From: Caio <c410.f3r@gmail.com>
Date: Fri, 16 Sep 2022 17:01:29 -0300
Subject: Change method's name

---
 clippy_lints/src/operators/arithmetic_side_effects.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/operators/arithmetic_side_effects.rs b/clippy_lints/src/operators/arithmetic_side_effects.rs
index 0070eef52e4..d24c57c0a4b 100644
--- a/clippy_lints/src/operators/arithmetic_side_effects.rs
+++ b/clippy_lints/src/operators/arithmetic_side_effects.rs
@@ -42,9 +42,9 @@ impl ArithmeticSideEffects {
         }
     }
 
-    /// Assuming that `expr` is a literal integer, checks assign operators (+=, -=, *=, /=) in a
+    /// Assuming that `expr` is a literal integer, checks operators (+=, -=, *, /) in a
     /// non-constant environment that won't overflow.
-    fn has_valid_assign_op(op: &Spanned<hir::BinOpKind>, expr: &hir::Expr<'_>) -> bool {
+    fn has_valid_op(op: &Spanned<hir::BinOpKind>, expr: &hir::Expr<'_>) -> bool {
         if let hir::BinOpKind::Add | hir::BinOpKind::Sub = op.node
             && let hir::ExprKind::Lit(ref lit) = expr.kind
             && let ast::LitKind::Int(0, _) = lit.node
@@ -124,8 +124,8 @@ impl ArithmeticSideEffects {
             Self::is_literal_integer(rhs, cx.typeck_results().expr_ty(rhs).peel_refs()),
         ) {
             (true, true) => true,
-            (true, false) => Self::has_valid_assign_op(op, lhs),
-            (false, true) => Self::has_valid_assign_op(op, rhs),
+            (true, false) => Self::has_valid_op(op, lhs),
+            (false, true) => Self::has_valid_op(op, rhs),
             (false, false) => false,
         };
         if !has_valid_op {
-- 
cgit 1.4.1-3-g733a5


From 3ca6b9d03193128e00d48101306d6d3cefc2f241 Mon Sep 17 00:00:00 2001
From: kraktus <kraktus@users.noreply.github.com>
Date: Fri, 16 Sep 2022 22:02:09 +0200
Subject: Silence [`question_mark`] in const context

---
 clippy_lints/src/question_mark.rs | 10 ++++++----
 tests/ui/question_mark.fixed      |  9 +++++++++
 tests/ui/question_mark.rs         |  9 +++++++++
 3 files changed, 24 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/question_mark.rs b/clippy_lints/src/question_mark.rs
index f4f1fd336df..565c48f7284 100644
--- a/clippy_lints/src/question_mark.rs
+++ b/clippy_lints/src/question_mark.rs
@@ -3,8 +3,8 @@ use clippy_utils::higher;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::{
-    eq_expr_value, get_parent_node, is_else_clause, is_lang_ctor, path_to_local, path_to_local_id, peel_blocks,
-    peel_blocks_with_stmt,
+    eq_expr_value, get_parent_node, in_constant, is_else_clause, is_lang_ctor, path_to_local, path_to_local_id,
+    peel_blocks, peel_blocks_with_stmt,
 };
 use if_chain::if_chain;
 use rustc_errors::Applicability;
@@ -223,7 +223,9 @@ fn expr_return_none_or_err(
 
 impl<'tcx> LateLintPass<'tcx> for QuestionMark {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        check_is_none_or_err_and_early_return(cx, expr);
-        check_if_let_some_or_err_and_early_return(cx, expr);
+        if !in_constant(cx, expr.hir_id) {
+            check_is_none_or_err_and_early_return(cx, expr);
+            check_if_let_some_or_err_and_early_return(cx, expr);
+        }
     }
 }
diff --git a/tests/ui/question_mark.fixed b/tests/ui/question_mark.fixed
index 57f23bd1916..993389232cc 100644
--- a/tests/ui/question_mark.fixed
+++ b/tests/ui/question_mark.fixed
@@ -223,3 +223,12 @@ fn pattern() -> Result<(), PatternedError> {
 }
 
 fn main() {}
+
+// should not lint, `?` operator not available in const context
+const fn issue9175(option: Option<()>) -> Option<()> {
+    if option.is_none() {
+        return None;
+    }
+    //stuff
+    Some(())
+}
diff --git a/tests/ui/question_mark.rs b/tests/ui/question_mark.rs
index 436f027c215..9ae0d88829a 100644
--- a/tests/ui/question_mark.rs
+++ b/tests/ui/question_mark.rs
@@ -259,3 +259,12 @@ fn pattern() -> Result<(), PatternedError> {
 }
 
 fn main() {}
+
+// should not lint, `?` operator not available in const context
+const fn issue9175(option: Option<()>) -> Option<()> {
+    if option.is_none() {
+        return None;
+    }
+    //stuff
+    Some(())
+}
-- 
cgit 1.4.1-3-g733a5


From 88a57963da0d55f5a27c7b3dfe899d972136659c Mon Sep 17 00:00:00 2001
From: kraktus <kraktus@users.noreply.github.com>
Date: Sat, 17 Sep 2022 15:33:38 +0200
Subject: [`drop_copy`]: Do not lint idiomatic in match arm

---
 clippy_lints/src/drop_forget_ref.rs | 28 +++++++++++++++++++++++----
 tests/ui/drop_forget_copy.rs        | 20 +++++++++++++++++++
 tests/ui/drop_forget_copy.stderr    | 38 ++++++++++++++++++++++++++++++++++++-
 3 files changed, 81 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/drop_forget_ref.rs b/clippy_lints/src/drop_forget_ref.rs
index b35f0b8ca52..de94b87cc40 100644
--- a/clippy_lints/src/drop_forget_ref.rs
+++ b/clippy_lints/src/drop_forget_ref.rs
@@ -1,7 +1,8 @@
 use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_note};
+use clippy_utils::get_parent_node;
 use clippy_utils::is_must_use_func_call;
 use clippy_utils::ty::{is_copy, is_must_use_ty, is_type_lang_item};
-use rustc_hir::{Expr, ExprKind, LangItem};
+use rustc_hir::{Arm, Expr, ExprKind, LangItem, Node};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::sym;
@@ -202,11 +203,13 @@ impl<'tcx> LateLintPass<'tcx> for DropForgetRef {
             && let Some(fn_name) = cx.tcx.get_diagnostic_name(def_id)
         {
             let arg_ty = cx.typeck_results().expr_ty(arg);
+            let is_copy = is_copy(cx, arg_ty);
+            let drop_is_only_expr_in_arm = and_only_expr_in_arm(cx, arg, expr);
             let (lint, msg) = match fn_name {
                 sym::mem_drop if arg_ty.is_ref() => (DROP_REF, DROP_REF_SUMMARY),
                 sym::mem_forget if arg_ty.is_ref() => (FORGET_REF, FORGET_REF_SUMMARY),
-                sym::mem_drop if is_copy(cx, arg_ty) => (DROP_COPY, DROP_COPY_SUMMARY),
-                sym::mem_forget if is_copy(cx, arg_ty) => (FORGET_COPY, FORGET_COPY_SUMMARY),
+                sym::mem_drop if is_copy && !drop_is_only_expr_in_arm => (DROP_COPY, DROP_COPY_SUMMARY),
+                sym::mem_forget if is_copy => (FORGET_COPY, FORGET_COPY_SUMMARY),
                 sym::mem_drop if is_type_lang_item(cx, arg_ty, LangItem::ManuallyDrop) => {
                     span_lint_and_help(
                         cx,
@@ -221,7 +224,9 @@ impl<'tcx> LateLintPass<'tcx> for DropForgetRef {
                 sym::mem_drop
                     if !(arg_ty.needs_drop(cx.tcx, cx.param_env)
                         || is_must_use_func_call(cx, arg)
-                        || is_must_use_ty(cx, arg_ty)) =>
+                        || is_must_use_ty(cx, arg_ty)
+                        || drop_is_only_expr_in_arm
+                        ) =>
                 {
                     (DROP_NON_DROP, DROP_NON_DROP_SUMMARY)
                 },
@@ -241,3 +246,18 @@ impl<'tcx> LateLintPass<'tcx> for DropForgetRef {
         }
     }
 }
+
+// dropping returned value of a function like in the following snippet is considered idiomatic, see
+// #9482 for examples match <var> {
+//     <pat> => drop(fn_with_side_effect_and_returning_some_value()),
+//     ..
+// }
+fn and_only_expr_in_arm<'tcx>(cx: &LateContext<'tcx>, arg: &'tcx Expr<'_>, drop_expr: &'tcx Expr<'_>) -> bool {
+    if matches!(arg.kind, ExprKind::Call(..) | ExprKind::MethodCall(..)) {
+        let parent_node = get_parent_node(cx.tcx, drop_expr.hir_id);
+        if let Some(Node::Arm(Arm { body, .. })) = &parent_node {
+            return body.hir_id == drop_expr.hir_id;
+        }
+    }
+    false
+}
diff --git a/tests/ui/drop_forget_copy.rs b/tests/ui/drop_forget_copy.rs
index 7c7a9ecff67..a7276dd59f4 100644
--- a/tests/ui/drop_forget_copy.rs
+++ b/tests/ui/drop_forget_copy.rs
@@ -64,3 +64,23 @@ fn main() {
     let a5 = a1.clone();
     forget(a5);
 }
+
+#[allow(unused)]
+#[allow(clippy::unit_cmp)]
+fn issue9482(x: u8) {
+    fn println_and<T>(t: T) -> T {
+        println!("foo");
+        t
+    }
+
+    match x {
+        0 => drop(println_and(12)), // Don't lint (copy type), we only care about side-effects
+        1 => drop(println_and(String::new())), // Don't lint (no copy type), we only care about side-effects
+        2 => {
+            drop(println_and(13)); // Lint, even if we only care about the side-effect, it's already in a block
+        },
+        3 if drop(println_and(14)) == () => (), // Lint, idiomatic use is only in body of `Arm`
+        4 => drop(2),                           // Lint, not a fn/method call
+        _ => (),
+    }
+}
diff --git a/tests/ui/drop_forget_copy.stderr b/tests/ui/drop_forget_copy.stderr
index 88228afae89..ec7dd2f08f1 100644
--- a/tests/ui/drop_forget_copy.stderr
+++ b/tests/ui/drop_forget_copy.stderr
@@ -72,5 +72,41 @@ note: argument has type `SomeStruct`
 LL |     forget(s4);
    |            ^^
 
-error: aborting due to 6 previous errors
+error: calls to `std::mem::drop` with a value that implements `Copy`. Dropping a copy leaves the original intact
+  --> $DIR/drop_forget_copy.rs:80:13
+   |
+LL |             drop(println_and(13)); // Lint, even if we only care about the side-effect, it's already in a block
+   |             ^^^^^^^^^^^^^^^^^^^^^
+   |
+note: argument has type `i32`
+  --> $DIR/drop_forget_copy.rs:80:18
+   |
+LL |             drop(println_and(13)); // Lint, even if we only care about the side-effect, it's already in a block
+   |                  ^^^^^^^^^^^^^^^
+
+error: calls to `std::mem::drop` with a value that implements `Copy`. Dropping a copy leaves the original intact
+  --> $DIR/drop_forget_copy.rs:82:14
+   |
+LL |         3 if drop(println_and(14)) == () => (), // Lint, idiomatic use is only in body of `Arm`
+   |              ^^^^^^^^^^^^^^^^^^^^^
+   |
+note: argument has type `i32`
+  --> $DIR/drop_forget_copy.rs:82:19
+   |
+LL |         3 if drop(println_and(14)) == () => (), // Lint, idiomatic use is only in body of `Arm`
+   |                   ^^^^^^^^^^^^^^^
+
+error: calls to `std::mem::drop` with a value that implements `Copy`. Dropping a copy leaves the original intact
+  --> $DIR/drop_forget_copy.rs:83:14
+   |
+LL |         4 => drop(2),                           // Lint, not a fn/method call
+   |              ^^^^^^^
+   |
+note: argument has type `i32`
+  --> $DIR/drop_forget_copy.rs:83:19
+   |
+LL |         4 => drop(2),                           // Lint, not a fn/method call
+   |                   ^
+
+error: aborting due to 9 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From d1dbdcf332e1a91666999d25ee6a0900512dda82 Mon Sep 17 00:00:00 2001
From: kraktus <kraktus@users.noreply.github.com>
Date: Sun, 18 Sep 2022 20:41:41 +0200
Subject: refactor `needless_return`

---
 clippy_lints/src/returns.rs | 111 +++++++++++++++++++-------------------------
 1 file changed, 47 insertions(+), 64 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
index 91553240e3c..63c8811f62d 100644
--- a/clippy_lints/src/returns.rs
+++ b/clippy_lints/src/returns.rs
@@ -72,6 +72,28 @@ enum RetReplacement {
     Unit,
 }
 
+impl RetReplacement {
+    fn sugg_help(&self) -> &'static str {
+        match *self {
+            Self::Empty => "remove `return`",
+            Self::Block => "replace `return` with an empty block",
+            Self::Unit => "replace `return` with a unit value",
+
+        }
+    }
+}
+
+impl ToString for RetReplacement {
+    fn to_string(&self) -> String {
+        match *self {
+            Self::Empty => "",
+            Self::Block => "{}",
+            Self::Unit => "()",
+        }
+        .to_string()
+    }
+}
+
 declare_lint_pass!(Return => [LET_AND_RETURN, NEEDLESS_RETURN]);
 
 impl<'tcx> LateLintPass<'tcx> for Return {
@@ -221,74 +243,35 @@ fn emit_return_lint(
     if ret_span.from_expansion() {
         return;
     }
-    match inner_span {
-        Some(inner_span) => {
-            let mut applicability = Applicability::MachineApplicable;
-            span_lint_hir_and_then(
-                cx,
-                NEEDLESS_RETURN,
-                emission_place,
-                ret_span,
-                "unneeded `return` statement",
-                |diag| {
-                    let (snippet, _) = snippet_with_context(cx, inner_span, ret_span.ctxt(), "..", &mut applicability);
-                    diag.span_suggestion(ret_span, "remove `return`", snippet, applicability);
-                },
-            );
-        },
-        None => match replacement {
-            RetReplacement::Empty => {
-                span_lint_hir_and_then(
-                    cx,
-                    NEEDLESS_RETURN,
-                    emission_place,
-                    ret_span,
-                    "unneeded `return` statement",
-                    |diag| {
-                        diag.span_suggestion(
-                            ret_span,
-                            "remove `return`",
-                            String::new(),
-                            Applicability::MachineApplicable,
-                        );
-                    },
-                );
-            },
-            RetReplacement::Block => {
-                span_lint_hir_and_then(
-                    cx,
-                    NEEDLESS_RETURN,
-                    emission_place,
-                    ret_span,
-                    "unneeded `return` statement",
-                    |diag| {
-                        diag.span_suggestion(
-                            ret_span,
-                            "replace `return` with an empty block",
-                            "{}".to_string(),
-                            Applicability::MachineApplicable,
-                        );
-                    },
-                );
+    if let Some(inner_span) = inner_span {
+        let mut applicability = Applicability::MachineApplicable;
+        span_lint_hir_and_then(
+            cx,
+            NEEDLESS_RETURN,
+            emission_place,
+            ret_span,
+            "unneeded `return` statement",
+            |diag| {
+                let (snippet, _) = snippet_with_context(cx, inner_span, ret_span.ctxt(), "..", &mut applicability);
+                diag.span_suggestion(ret_span, "remove `return`", snippet, applicability);
             },
-            RetReplacement::Unit => {
-                span_lint_hir_and_then(
-                    cx,
-                    NEEDLESS_RETURN,
-                    emission_place,
+        );
+    } else {
+        span_lint_hir_and_then(
+            cx,
+            NEEDLESS_RETURN,
+            emission_place,
+            ret_span,
+            "unneeded `return` statement",
+            |diag| {
+                diag.span_suggestion(
                     ret_span,
-                    "unneeded `return` statement",
-                    |diag| {
-                        diag.span_suggestion(
-                            ret_span,
-                            "replace `return` with a unit value",
-                            "()".to_string(),
-                            Applicability::MachineApplicable,
-                        );
-                    },
+                    replacement.sugg_help(),
+                    replacement.to_string(),
+                    Applicability::MachineApplicable,
                 );
             },
-        },
+        )
     }
 }
 
-- 
cgit 1.4.1-3-g733a5


From bf8870eeadf4ce73c5e7dfed071fbc41231aa324 Mon Sep 17 00:00:00 2001
From: kraktus <kraktus@users.noreply.github.com>
Date: Sun, 18 Sep 2022 21:06:06 +0200
Subject: further refactor of `needless_return`

---
 clippy_lints/src/returns.rs | 55 ++++++++++++++++++---------------------------
 1 file changed, 22 insertions(+), 33 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
index 63c8811f62d..e4692a8d84b 100644
--- a/clippy_lints/src/returns.rs
+++ b/clippy_lints/src/returns.rs
@@ -78,7 +78,6 @@ impl RetReplacement {
             Self::Empty => "remove `return`",
             Self::Block => "replace `return` with an empty block",
             Self::Unit => "replace `return` with a unit value",
-
         }
     }
 }
@@ -161,37 +160,33 @@ impl<'tcx> LateLintPass<'tcx> for Return {
                 } else {
                     RetReplacement::Empty
                 };
-                check_final_expr(cx, body.value, Some(body.value.span), replacement);
+                check_final_expr(cx, body.value, body.value.span, replacement);
             },
             FnKind::ItemFn(..) | FnKind::Method(..) => {
-                if let ExprKind::Block(block, _) = body.value.kind {
-                    check_block_return(cx, block);
-                }
+                check_block_return(cx, &body.value.kind);
             },
         }
     }
 }
 
-fn check_block_return<'tcx>(cx: &LateContext<'tcx>, block: &Block<'tcx>) {
-    if let Some(expr) = block.expr {
-        check_final_expr(cx, expr, Some(expr.span), RetReplacement::Empty);
-    } else if let Some(stmt) = block.stmts.iter().last() {
-        match stmt.kind {
-            StmtKind::Expr(expr) | StmtKind::Semi(expr) => {
-                check_final_expr(cx, expr, Some(stmt.span), RetReplacement::Empty);
-            },
-            _ => (),
+// if `expr` is a block, check if there are needless returns in it
+fn check_block_return<'tcx>(cx: &LateContext<'tcx>, expr_kind: &ExprKind<'tcx>) {
+    if let ExprKind::Block(block, _) = expr_kind {
+        if let Some(block_expr) = block.expr {
+            check_final_expr(cx, block_expr, block_expr.span, RetReplacement::Empty);
+        } else if let Some(stmt) = block.stmts.iter().last() {
+            match stmt.kind {
+                StmtKind::Expr(expr) | StmtKind::Semi(expr) => {
+                    check_final_expr(cx, expr, stmt.span, RetReplacement::Empty);
+                },
+                _ => (),
+            }
         }
     }
 }
 
-fn check_final_expr<'tcx>(
-    cx: &LateContext<'tcx>,
-    expr: &'tcx Expr<'tcx>,
-    span: Option<Span>,
-    replacement: RetReplacement,
-) {
-    match expr.kind {
+fn check_final_expr<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, span: Span, replacement: RetReplacement) {
+    match &expr.peel_drop_temps().kind {
         // simple return is always "bad"
         ExprKind::Ret(ref inner) => {
             if cx.tcx.hir().attrs(expr.hir_id).is_empty() {
@@ -200,23 +195,17 @@ fn check_final_expr<'tcx>(
                     emit_return_lint(
                         cx,
                         inner.map_or(expr.hir_id, |inner| inner.hir_id),
-                        span.expect("`else return` is not possible"),
+                        span,
                         inner.as_ref().map(|i| i.span),
                         replacement,
                     );
                 }
             }
         },
-        // a whole block? check it!
-        ExprKind::Block(block, _) => {
-            check_block_return(cx, block);
-        },
         ExprKind::If(_, then, else_clause_opt) => {
-            if let ExprKind::Block(ifblock, _) = then.kind {
-                check_block_return(cx, ifblock);
-            }
+            check_block_return(cx, &then.kind);
             if let Some(else_clause) = else_clause_opt {
-                check_final_expr(cx, else_clause, None, RetReplacement::Empty);
+                check_block_return(cx, &else_clause.kind)
             }
         },
         // a match expr, check all arms
@@ -225,11 +214,11 @@ fn check_final_expr<'tcx>(
         // (except for unit type functions) so we don't match it
         ExprKind::Match(_, arms, MatchSource::Normal) => {
             for arm in arms.iter() {
-                check_final_expr(cx, arm.body, Some(arm.body.span), RetReplacement::Unit);
+                check_final_expr(cx, arm.body, arm.body.span, RetReplacement::Unit);
             }
         },
-        ExprKind::DropTemps(expr) => check_final_expr(cx, expr, None, RetReplacement::Empty),
-        _ => (),
+        // if it's a whole block, check it
+        other_expr_kind => check_block_return(cx, &other_expr_kind),
     }
 }
 
-- 
cgit 1.4.1-3-g733a5


From 15ec5d26084fe13c984b4e6c2933e048e070680c Mon Sep 17 00:00:00 2001
From: kraktus <kraktus@users.noreply.github.com>
Date: Sun, 18 Sep 2022 21:26:23 +0200
Subject: further refactor

---
 clippy_lints/src/returns.rs | 51 +++++++++++++++++++--------------------------
 1 file changed, 22 insertions(+), 29 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
index e4692a8d84b..26b6898e588 100644
--- a/clippy_lints/src/returns.rs
+++ b/clippy_lints/src/returns.rs
@@ -232,36 +232,29 @@ fn emit_return_lint(
     if ret_span.from_expansion() {
         return;
     }
-    if let Some(inner_span) = inner_span {
-        let mut applicability = Applicability::MachineApplicable;
-        span_lint_hir_and_then(
-            cx,
-            NEEDLESS_RETURN,
-            emission_place,
-            ret_span,
-            "unneeded `return` statement",
-            |diag| {
-                let (snippet, _) = snippet_with_context(cx, inner_span, ret_span.ctxt(), "..", &mut applicability);
-                diag.span_suggestion(ret_span, "remove `return`", snippet, applicability);
-            },
-        );
+    let mut applicability = Applicability::MachineApplicable;
+    let return_replacement = inner_span.map_or_else(
+        || replacement.to_string(),
+        |inner_span| {
+            let (snippet, _) = snippet_with_context(cx, inner_span, ret_span.ctxt(), "..", &mut applicability);
+            snippet.to_string()
+        },
+    );
+    let sugg_help = if inner_span.is_some() {
+        "remove `return`"
     } else {
-        span_lint_hir_and_then(
-            cx,
-            NEEDLESS_RETURN,
-            emission_place,
-            ret_span,
-            "unneeded `return` statement",
-            |diag| {
-                diag.span_suggestion(
-                    ret_span,
-                    replacement.sugg_help(),
-                    replacement.to_string(),
-                    Applicability::MachineApplicable,
-                );
-            },
-        )
-    }
+        replacement.sugg_help()
+    };
+    span_lint_hir_and_then(
+        cx,
+        NEEDLESS_RETURN,
+        emission_place,
+        ret_span,
+        "unneeded `return` statement",
+        |diag| {
+            diag.span_suggestion(ret_span, sugg_help, return_replacement, applicability);
+        },
+    );
 }
 
 fn last_statement_borrows<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
-- 
cgit 1.4.1-3-g733a5


From 23d1d07861457a42a401ea512b11614952339497 Mon Sep 17 00:00:00 2001
From: kraktus <kraktus@users.noreply.github.com>
Date: Mon, 19 Sep 2022 07:43:16 +0200
Subject: small refactor

---
 clippy_lints/src/returns.rs | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
index 26b6898e588..721c5f64a90 100644
--- a/clippy_lints/src/returns.rs
+++ b/clippy_lints/src/returns.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_hir_and_then;
+use clippy_utils::diagnostics::{span_lint_hir_and_then, span_lint_and_then};
 use clippy_utils::source::{snippet_opt, snippet_with_context};
 use clippy_utils::{fn_def_id, path_to_local_id};
 use if_chain::if_chain;
@@ -194,7 +194,6 @@ fn check_final_expr<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, span:
                 if !borrows {
                     emit_return_lint(
                         cx,
-                        inner.map_or(expr.hir_id, |inner| inner.hir_id),
                         span,
                         inner.as_ref().map(|i| i.span),
                         replacement,
@@ -224,7 +223,6 @@ fn check_final_expr<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, span:
 
 fn emit_return_lint(
     cx: &LateContext<'_>,
-    emission_place: HirId,
     ret_span: Span,
     inner_span: Option<Span>,
     replacement: RetReplacement,
@@ -245,10 +243,9 @@ fn emit_return_lint(
     } else {
         replacement.sugg_help()
     };
-    span_lint_hir_and_then(
+    span_lint_and_then(
         cx,
         NEEDLESS_RETURN,
-        emission_place,
         ret_span,
         "unneeded `return` statement",
         |diag| {
-- 
cgit 1.4.1-3-g733a5


From 5c0cb0deaa116755bfb3f1fd05314c96f64959c9 Mon Sep 17 00:00:00 2001
From: kraktus <kraktus@users.noreply.github.com>
Date: Mon, 19 Sep 2022 12:07:53 +0200
Subject: [`needless_return`] Recursively remove unneeded semicolons

---
 clippy_lints/src/returns.rs     |  65 ++++++++------
 tests/ui/needless_return.fixed  |  27 ++++++
 tests/ui/needless_return.rs     |  27 ++++++
 tests/ui/needless_return.stderr | 189 ++++++++++++++++++++++++++++++++--------
 4 files changed, 244 insertions(+), 64 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
index 721c5f64a90..f7ceb415a79 100644
--- a/clippy_lints/src/returns.rs
+++ b/clippy_lints/src/returns.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::{span_lint_hir_and_then, span_lint_and_then};
+use clippy_utils::diagnostics::{span_lint_and_then, span_lint_hir_and_then};
 use clippy_utils::source::{snippet_opt, snippet_with_context};
 use clippy_utils::{fn_def_id, path_to_local_id};
 use if_chain::if_chain;
@@ -9,7 +9,7 @@ use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::subst::GenericArgKind;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::source_map::Span;
+use rustc_span::source_map::{Span, DUMMY_SP};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -73,8 +73,8 @@ enum RetReplacement {
 }
 
 impl RetReplacement {
-    fn sugg_help(&self) -> &'static str {
-        match *self {
+    fn sugg_help(self) -> &'static str {
+        match self {
             Self::Empty => "remove `return`",
             Self::Block => "replace `return` with an empty block",
             Self::Unit => "replace `return` with a unit value",
@@ -160,24 +160,30 @@ impl<'tcx> LateLintPass<'tcx> for Return {
                 } else {
                     RetReplacement::Empty
                 };
-                check_final_expr(cx, body.value, body.value.span, replacement);
+                check_final_expr(cx, body.value, vec![], replacement);
             },
             FnKind::ItemFn(..) | FnKind::Method(..) => {
-                check_block_return(cx, &body.value.kind);
+                check_block_return(cx, &body.value.kind, vec![]);
             },
         }
     }
 }
 
 // if `expr` is a block, check if there are needless returns in it
-fn check_block_return<'tcx>(cx: &LateContext<'tcx>, expr_kind: &ExprKind<'tcx>) {
+fn check_block_return<'tcx>(cx: &LateContext<'tcx>, expr_kind: &ExprKind<'tcx>, semi_spans: Vec<Span>) {
     if let ExprKind::Block(block, _) = expr_kind {
         if let Some(block_expr) = block.expr {
-            check_final_expr(cx, block_expr, block_expr.span, RetReplacement::Empty);
+            check_final_expr(cx, block_expr, semi_spans, RetReplacement::Empty);
         } else if let Some(stmt) = block.stmts.iter().last() {
             match stmt.kind {
-                StmtKind::Expr(expr) | StmtKind::Semi(expr) => {
-                    check_final_expr(cx, expr, stmt.span, RetReplacement::Empty);
+                StmtKind::Expr(expr) => {
+                    check_final_expr(cx, expr, semi_spans, RetReplacement::Empty);
+                },
+                StmtKind::Semi(semi_expr) => {
+                    let mut semi_spans_and_this_one = semi_spans;
+                    // we only want the span containing the semicolon so we can remove it later. From `entry.rs:382`
+                    semi_spans_and_this_one.push(stmt.span.trim_start(semi_expr.span).unwrap_or(DUMMY_SP));
+                    check_final_expr(cx, semi_expr, semi_spans_and_this_one, RetReplacement::Empty);
                 },
                 _ => (),
             }
@@ -185,8 +191,15 @@ fn check_block_return<'tcx>(cx: &LateContext<'tcx>, expr_kind: &ExprKind<'tcx>)
     }
 }
 
-fn check_final_expr<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, span: Span, replacement: RetReplacement) {
-    match &expr.peel_drop_temps().kind {
+fn check_final_expr<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx Expr<'tcx>,
+    semi_spans: Vec<Span>, /* containing all the places where we would need to remove semicolons if finding an
+                            * needless return */
+    replacement: RetReplacement,
+) {
+    let peeled_drop_expr = expr.peel_drop_temps();
+    match &peeled_drop_expr.kind {
         // simple return is always "bad"
         ExprKind::Ret(ref inner) => {
             if cx.tcx.hir().attrs(expr.hir_id).is_empty() {
@@ -194,7 +207,8 @@ fn check_final_expr<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, span:
                 if !borrows {
                     emit_return_lint(
                         cx,
-                        span,
+                        peeled_drop_expr.span,
+                        semi_spans,
                         inner.as_ref().map(|i| i.span),
                         replacement,
                     );
@@ -202,9 +216,9 @@ fn check_final_expr<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, span:
             }
         },
         ExprKind::If(_, then, else_clause_opt) => {
-            check_block_return(cx, &then.kind);
+            check_block_return(cx, &then.kind, semi_spans.clone());
             if let Some(else_clause) = else_clause_opt {
-                check_block_return(cx, &else_clause.kind)
+                check_block_return(cx, &else_clause.kind, semi_spans);
             }
         },
         // a match expr, check all arms
@@ -213,17 +227,18 @@ fn check_final_expr<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, span:
         // (except for unit type functions) so we don't match it
         ExprKind::Match(_, arms, MatchSource::Normal) => {
             for arm in arms.iter() {
-                check_final_expr(cx, arm.body, arm.body.span, RetReplacement::Unit);
+                check_final_expr(cx, arm.body, semi_spans.clone(), RetReplacement::Unit);
             }
         },
         // if it's a whole block, check it
-        other_expr_kind => check_block_return(cx, &other_expr_kind),
+        other_expr_kind => check_block_return(cx, other_expr_kind, semi_spans),
     }
 }
 
 fn emit_return_lint(
     cx: &LateContext<'_>,
     ret_span: Span,
+    semi_spans: Vec<Span>,
     inner_span: Option<Span>,
     replacement: RetReplacement,
 ) {
@@ -243,15 +258,13 @@ fn emit_return_lint(
     } else {
         replacement.sugg_help()
     };
-    span_lint_and_then(
-        cx,
-        NEEDLESS_RETURN,
-        ret_span,
-        "unneeded `return` statement",
-        |diag| {
-            diag.span_suggestion(ret_span, sugg_help, return_replacement, applicability);
-        },
-    );
+    span_lint_and_then(cx, NEEDLESS_RETURN, ret_span, "unneeded `return` statement", |diag| {
+        diag.span_suggestion_hidden(ret_span, sugg_help, return_replacement, applicability);
+        // for each parent statement, we need to remove the semicolon
+        for semi_stmt_span in semi_spans {
+            diag.tool_only_span_suggestion(semi_stmt_span, "remove this semicolon", "", applicability);
+        }
+    });
 }
 
 fn last_statement_borrows<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
diff --git a/tests/ui/needless_return.fixed b/tests/ui/needless_return.fixed
index 87c8fc03b3c..a5e28b9b1a4 100644
--- a/tests/ui/needless_return.fixed
+++ b/tests/ui/needless_return.fixed
@@ -233,4 +233,31 @@ fn issue_9361() -> i32 {
     return 1 + 2;
 }
 
+fn issue8336(x: i32) -> bool {
+    if x > 0 {
+        println!("something");
+        true
+    } else {
+        false
+    }
+}
+
+fn issue8156(x: u8) -> u64 {
+    match x {
+        80 => {
+            10
+        },
+        _ => {
+            100
+        },
+    }
+}
+
+// Ideally the compiler should throw `unused_braces` in this case
+fn issue9192() -> i32 {
+    {
+        0
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/needless_return.rs b/tests/ui/needless_return.rs
index 5a86e656255..49fd49c7293 100644
--- a/tests/ui/needless_return.rs
+++ b/tests/ui/needless_return.rs
@@ -233,4 +233,31 @@ fn issue_9361() -> i32 {
     return 1 + 2;
 }
 
+fn issue8336(x: i32) -> bool {
+    if x > 0 {
+        println!("something");
+        return true;
+    } else {
+        return false;
+    };
+}
+
+fn issue8156(x: u8) -> u64 {
+    match x {
+        80 => {
+            return 10;
+        },
+        _ => {
+            return 100;
+        },
+    };
+}
+
+// Ideally the compiler should throw `unused_braces` in this case
+fn issue9192() -> i32 {
+    {
+        return 0;
+    };
+}
+
 fn main() {}
diff --git a/tests/ui/needless_return.stderr b/tests/ui/needless_return.stderr
index 83ff0763869..d8dba766bf4 100644
--- a/tests/ui/needless_return.stderr
+++ b/tests/ui/needless_return.stderr
@@ -2,225 +2,338 @@ error: unneeded `return` statement
   --> $DIR/needless_return.rs:27:5
    |
 LL |     return true;
-   |     ^^^^^^^^^^^^ help: remove `return`: `true`
+   |     ^^^^^^^^^^^
    |
    = note: `-D clippy::needless-return` implied by `-D warnings`
+   = help: remove `return`
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:31:5
    |
 LL |     return true;
-   |     ^^^^^^^^^^^^ help: remove `return`: `true`
+   |     ^^^^^^^^^^^
+   |
+   = help: remove `return`
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:36:9
    |
 LL |         return true;
-   |         ^^^^^^^^^^^^ help: remove `return`: `true`
+   |         ^^^^^^^^^^^
+   |
+   = help: remove `return`
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:38:9
    |
 LL |         return false;
-   |         ^^^^^^^^^^^^^ help: remove `return`: `false`
+   |         ^^^^^^^^^^^^
+   |
+   = help: remove `return`
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:44:17
    |
 LL |         true => return false,
-   |                 ^^^^^^^^^^^^ help: remove `return`: `false`
+   |                 ^^^^^^^^^^^^
+   |
+   = help: remove `return`
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:46:13
    |
 LL |             return true;
-   |             ^^^^^^^^^^^^ help: remove `return`: `true`
+   |             ^^^^^^^^^^^
+   |
+   = help: remove `return`
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:53:9
    |
 LL |         return true;
-   |         ^^^^^^^^^^^^ help: remove `return`: `true`
+   |         ^^^^^^^^^^^
+   |
+   = help: remove `return`
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:55:16
    |
 LL |     let _ = || return true;
-   |                ^^^^^^^^^^^ help: remove `return`: `true`
+   |                ^^^^^^^^^^^
+   |
+   = help: remove `return`
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:59:5
    |
 LL |     return the_answer!();
-   |     ^^^^^^^^^^^^^^^^^^^^^ help: remove `return`: `the_answer!()`
+   |     ^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: remove `return`
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:63:5
    |
 LL |     return;
-   |     ^^^^^^^ help: remove `return`
+   |     ^^^^^^
+   |
+   = help: remove `return`
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:68:9
    |
 LL |         return;
-   |         ^^^^^^^ help: remove `return`
+   |         ^^^^^^
+   |
+   = help: remove `return`
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:70:9
    |
 LL |         return;
-   |         ^^^^^^^ help: remove `return`
+   |         ^^^^^^
+   |
+   = help: remove `return`
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:77:14
    |
 LL |         _ => return,
-   |              ^^^^^^ help: replace `return` with a unit value: `()`
+   |              ^^^^^^
+   |
+   = help: replace `return` with a unit value
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:86:13
    |
 LL |             return;
-   |             ^^^^^^^ help: remove `return`
+   |             ^^^^^^
+   |
+   = help: remove `return`
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:88:14
    |
 LL |         _ => return,
-   |              ^^^^^^ help: replace `return` with a unit value: `()`
+   |              ^^^^^^
+   |
+   = help: replace `return` with a unit value
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:101:9
    |
 LL |         return String::from("test");
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove `return`: `String::from("test")`
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: remove `return`
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:103:9
    |
 LL |         return String::new();
-   |         ^^^^^^^^^^^^^^^^^^^^^ help: remove `return`: `String::new()`
+   |         ^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: remove `return`
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:125:32
    |
 LL |         bar.unwrap_or_else(|_| return)
-   |                                ^^^^^^ help: replace `return` with an empty block: `{}`
+   |                                ^^^^^^
+   |
+   = help: replace `return` with an empty block
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:130:13
    |
 LL |             return;
-   |             ^^^^^^^ help: remove `return`
+   |             ^^^^^^
+   |
+   = help: remove `return`
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:132:20
    |
 LL |         let _ = || return;
-   |                    ^^^^^^ help: replace `return` with an empty block: `{}`
+   |                    ^^^^^^
+   |
+   = help: replace `return` with an empty block
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:138:32
    |
 LL |         res.unwrap_or_else(|_| return Foo)
-   |                                ^^^^^^^^^^ help: remove `return`: `Foo`
+   |                                ^^^^^^^^^^
+   |
+   = help: remove `return`
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:147:5
    |
 LL |     return true;
-   |     ^^^^^^^^^^^^ help: remove `return`: `true`
+   |     ^^^^^^^^^^^
+   |
+   = help: remove `return`
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:151:5
    |
 LL |     return true;
-   |     ^^^^^^^^^^^^ help: remove `return`: `true`
+   |     ^^^^^^^^^^^
+   |
+   = help: remove `return`
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:156:9
    |
 LL |         return true;
-   |         ^^^^^^^^^^^^ help: remove `return`: `true`
+   |         ^^^^^^^^^^^
+   |
+   = help: remove `return`
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:158:9
    |
 LL |         return false;
-   |         ^^^^^^^^^^^^^ help: remove `return`: `false`
+   |         ^^^^^^^^^^^^
+   |
+   = help: remove `return`
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:164:17
    |
 LL |         true => return false,
-   |                 ^^^^^^^^^^^^ help: remove `return`: `false`
+   |                 ^^^^^^^^^^^^
+   |
+   = help: remove `return`
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:166:13
    |
 LL |             return true;
-   |             ^^^^^^^^^^^^ help: remove `return`: `true`
+   |             ^^^^^^^^^^^
+   |
+   = help: remove `return`
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:173:9
    |
 LL |         return true;
-   |         ^^^^^^^^^^^^ help: remove `return`: `true`
+   |         ^^^^^^^^^^^
+   |
+   = help: remove `return`
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:175:16
    |
 LL |     let _ = || return true;
-   |                ^^^^^^^^^^^ help: remove `return`: `true`
+   |                ^^^^^^^^^^^
+   |
+   = help: remove `return`
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:179:5
    |
 LL |     return the_answer!();
-   |     ^^^^^^^^^^^^^^^^^^^^^ help: remove `return`: `the_answer!()`
+   |     ^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: remove `return`
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:183:5
    |
 LL |     return;
-   |     ^^^^^^^ help: remove `return`
+   |     ^^^^^^
+   |
+   = help: remove `return`
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:188:9
    |
 LL |         return;
-   |         ^^^^^^^ help: remove `return`
+   |         ^^^^^^
+   |
+   = help: remove `return`
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:190:9
    |
 LL |         return;
-   |         ^^^^^^^ help: remove `return`
+   |         ^^^^^^
+   |
+   = help: remove `return`
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:197:14
    |
 LL |         _ => return,
-   |              ^^^^^^ help: replace `return` with a unit value: `()`
+   |              ^^^^^^
+   |
+   = help: replace `return` with a unit value
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:210:9
    |
 LL |         return String::from("test");
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove `return`: `String::from("test")`
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: remove `return`
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:212:9
    |
 LL |         return String::new();
-   |         ^^^^^^^^^^^^^^^^^^^^^ help: remove `return`: `String::new()`
+   |         ^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: remove `return`
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:228:5
    |
 LL |     return format!("Hello {}", "world!");
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove `return`: `format!("Hello {}", "world!")`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: remove `return`
+
+error: unneeded `return` statement
+  --> $DIR/needless_return.rs:239:9
+   |
+LL |         return true;
+   |         ^^^^^^^^^^^
+   |
+   = help: remove `return`
+
+error: unneeded `return` statement
+  --> $DIR/needless_return.rs:241:9
+   |
+LL |         return false;
+   |         ^^^^^^^^^^^^
+   |
+   = help: remove `return`
+
+error: unneeded `return` statement
+  --> $DIR/needless_return.rs:248:13
+   |
+LL |             return 10;
+   |             ^^^^^^^^^
+   |
+   = help: remove `return`
+
+error: unneeded `return` statement
+  --> $DIR/needless_return.rs:251:13
+   |
+LL |             return 100;
+   |             ^^^^^^^^^^
+   |
+   = help: remove `return`
+
+error: unneeded `return` statement
+  --> $DIR/needless_return.rs:259:9
+   |
+LL |         return 0;
+   |         ^^^^^^^^
+   |
+   = help: remove `return`
 
-error: aborting due to 37 previous errors
+error: aborting due to 42 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From d63aeceaa1f4f175ad63456e691395912460ef41 Mon Sep 17 00:00:00 2001
From: Yotam Ofek <yotam.ofek@gmail.com>
Date: Mon, 19 Sep 2022 10:02:17 +0000
Subject: [`never_loop`]: Fix FP with let..else statements.

---
 clippy_lints/src/loops/never_loop.rs | 31 +++++++++++++++++++++----------
 tests/ui/never_loop.rs               | 27 +++++++++++++++++++++++++++
 tests/ui/never_loop.stderr           | 33 +++++++++++++++++++++++----------
 3 files changed, 71 insertions(+), 20 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/never_loop.rs b/clippy_lints/src/loops/never_loop.rs
index 116e589cad6..2386f4f4f4e 100644
--- a/clippy_lints/src/loops/never_loop.rs
+++ b/clippy_lints/src/loops/never_loop.rs
@@ -42,6 +42,7 @@ pub(super) fn check(
     }
 }
 
+#[derive(Copy, Clone)]
 enum NeverLoopResult {
     // A break/return always get triggered but not necessarily for the main loop.
     AlwaysBreak,
@@ -51,8 +52,8 @@ enum NeverLoopResult {
 }
 
 #[must_use]
-fn absorb_break(arg: &NeverLoopResult) -> NeverLoopResult {
-    match *arg {
+fn absorb_break(arg: NeverLoopResult) -> NeverLoopResult {
+    match arg {
         NeverLoopResult::AlwaysBreak | NeverLoopResult::Otherwise => NeverLoopResult::Otherwise,
         NeverLoopResult::MayContinueMainLoop => NeverLoopResult::MayContinueMainLoop,
     }
@@ -92,19 +93,29 @@ fn combine_branches(b1: NeverLoopResult, b2: NeverLoopResult) -> NeverLoopResult
 }
 
 fn never_loop_block(block: &Block<'_>, main_loop_id: HirId) -> NeverLoopResult {
-    let mut iter = block.stmts.iter().filter_map(stmt_to_expr).chain(block.expr);
+    let mut iter = block
+        .stmts
+        .iter()
+        .filter_map(stmt_to_expr)
+        .chain(block.expr.map(|expr| (expr, None)));
     never_loop_expr_seq(&mut iter, main_loop_id)
 }
 
-fn never_loop_expr_seq<'a, T: Iterator<Item = &'a Expr<'a>>>(es: &mut T, main_loop_id: HirId) -> NeverLoopResult {
-    es.map(|e| never_loop_expr(e, main_loop_id))
-        .fold(NeverLoopResult::Otherwise, combine_seq)
+fn never_loop_expr_seq<'a, T: Iterator<Item = (&'a Expr<'a>, Option<&'a Block<'a>>)>>(
+    es: &mut T,
+    main_loop_id: HirId,
+) -> NeverLoopResult {
+    es.map(|(e, els)| {
+        let e = never_loop_expr(e, main_loop_id);
+        els.map_or(e, |els| combine_branches(e, never_loop_block(els, main_loop_id)))
+    })
+    .fold(NeverLoopResult::Otherwise, combine_seq)
 }
 
-fn stmt_to_expr<'tcx>(stmt: &Stmt<'tcx>) -> Option<&'tcx Expr<'tcx>> {
+fn stmt_to_expr<'tcx>(stmt: &Stmt<'tcx>) -> Option<(&'tcx Expr<'tcx>, Option<&'tcx Block<'tcx>>)> {
     match stmt.kind {
-        StmtKind::Semi(e, ..) | StmtKind::Expr(e, ..) => Some(e),
-        StmtKind::Local(local) => local.init,
+        StmtKind::Semi(e, ..) | StmtKind::Expr(e, ..) => Some((e, None)),
+        StmtKind::Local(local) => local.init.map(|init| (init, local.els)),
         StmtKind::Item(..) => None,
     }
 }
@@ -139,7 +150,7 @@ fn never_loop_expr(expr: &Expr<'_>, main_loop_id: HirId) -> NeverLoopResult {
         | ExprKind::Index(e1, e2) => never_loop_expr_all(&mut [e1, e2].iter().copied(), main_loop_id),
         ExprKind::Loop(b, _, _, _) => {
             // Break can come from the inner loop so remove them.
-            absorb_break(&never_loop_block(b, main_loop_id))
+            absorb_break(never_loop_block(b, main_loop_id))
         },
         ExprKind::If(e, e2, e3) => {
             let e1 = never_loop_expr(e, main_loop_id);
diff --git a/tests/ui/never_loop.rs b/tests/ui/never_loop.rs
index 0a21589dd0d..fc60b440766 100644
--- a/tests/ui/never_loop.rs
+++ b/tests/ui/never_loop.rs
@@ -1,3 +1,4 @@
+#![feature(let_else)]
 #![allow(
     clippy::single_match,
     unused_assignments,
@@ -203,6 +204,32 @@ pub fn test17() {
     };
 }
 
+// Issue #9356: `continue` in else branch of let..else
+pub fn test18() {
+    let x = Some(0);
+    let y = 0;
+    // might loop
+    let _ = loop {
+        let Some(x) = x else {
+            if y > 0 {
+                continue;
+            } else {
+                return;
+            }
+        };
+
+        break x;
+    };
+    // never loops
+    let _ = loop {
+        let Some(x) = x else {
+            return;
+        };
+
+        break x;
+    };
+}
+
 fn main() {
     test1();
     test2();
diff --git a/tests/ui/never_loop.stderr b/tests/ui/never_loop.stderr
index f49b23924ef..1709e7512eb 100644
--- a/tests/ui/never_loop.stderr
+++ b/tests/ui/never_loop.stderr
@@ -1,5 +1,5 @@
 error: this loop never actually loops
-  --> $DIR/never_loop.rs:10:5
+  --> $DIR/never_loop.rs:11:5
    |
 LL | /     loop {
 LL | |         // clippy::never_loop
@@ -13,7 +13,7 @@ LL | |     }
    = note: `#[deny(clippy::never_loop)]` on by default
 
 error: this loop never actually loops
-  --> $DIR/never_loop.rs:32:5
+  --> $DIR/never_loop.rs:33:5
    |
 LL | /     loop {
 LL | |         // never loops
@@ -23,7 +23,7 @@ LL | |     }
    | |_____^
 
 error: this loop never actually loops
-  --> $DIR/never_loop.rs:52:5
+  --> $DIR/never_loop.rs:53:5
    |
 LL | /     loop {
 LL | |         // never loops
@@ -35,7 +35,7 @@ LL | |     }
    | |_____^
 
 error: this loop never actually loops
-  --> $DIR/never_loop.rs:54:9
+  --> $DIR/never_loop.rs:55:9
    |
 LL | /         while i == 0 {
 LL | |             // never loops
@@ -44,7 +44,7 @@ LL | |         }
    | |_________^
 
 error: this loop never actually loops
-  --> $DIR/never_loop.rs:66:9
+  --> $DIR/never_loop.rs:67:9
    |
 LL | /         loop {
 LL | |             // never loops
@@ -56,7 +56,7 @@ LL | |         }
    | |_________^
 
 error: this loop never actually loops
-  --> $DIR/never_loop.rs:102:5
+  --> $DIR/never_loop.rs:103:5
    |
 LL | /     while let Some(y) = x {
 LL | |         // never loops
@@ -65,7 +65,7 @@ LL | |     }
    | |_____^
 
 error: this loop never actually loops
-  --> $DIR/never_loop.rs:109:5
+  --> $DIR/never_loop.rs:110:5
    |
 LL | /     for x in 0..10 {
 LL | |         // never loops
@@ -82,7 +82,7 @@ LL |     if let Some(x) = (0..10).next() {
    |     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 error: this loop never actually loops
-  --> $DIR/never_loop.rs:157:5
+  --> $DIR/never_loop.rs:158:5
    |
 LL | /     'outer: while a {
 LL | |         // never loops
@@ -94,12 +94,25 @@ LL | |     }
    | |_____^
 
 error: this loop never actually loops
-  --> $DIR/never_loop.rs:172:9
+  --> $DIR/never_loop.rs:173:9
    |
 LL | /         while false {
 LL | |             break 'label;
 LL | |         }
    | |_________^
 
-error: aborting due to 9 previous errors
+error: this loop never actually loops
+  --> $DIR/never_loop.rs:224:13
+   |
+LL |       let _ = loop {
+   |  _____________^
+LL | |         let Some(x) = x else {
+LL | |             return;
+LL | |         };
+LL | |
+LL | |         break x;
+LL | |     };
+   | |_____^
+
+error: aborting due to 10 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 25584c0c6704623c8c5a3195b59bf068862f8bba Mon Sep 17 00:00:00 2001
From: Jonas Platte <jplatte+git@posteo.de>
Date: Tue, 13 Sep 2022 12:08:17 +0200
Subject: Add matches! checking to nonstandard_macro_braces

---
 clippy_lints/src/nonstandard_macro_braces.rs       |  4 +++
 .../conf_nonstandard_macro_braces.rs               |  1 +
 .../conf_nonstandard_macro_braces.stderr           | 30 +++++++++++++++-------
 3 files changed, 26 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/nonstandard_macro_braces.rs b/clippy_lints/src/nonstandard_macro_braces.rs
index 4722c031006..f86dfb6b8df 100644
--- a/clippy_lints/src/nonstandard_macro_braces.rs
+++ b/clippy_lints/src/nonstandard_macro_braces.rs
@@ -184,6 +184,10 @@ fn macro_braces(conf: FxHashSet<MacroMatcher>) -> FxHashMap<String, (String, Str
             name: "vec",
             braces: ("[", "]"),
         ),
+        macro_matcher!(
+            name: "matches",
+            braces: ("(", ")"),
+        ),
     ]
     .into_iter()
     .collect::<FxHashMap<_, _>>();
diff --git a/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.rs b/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.rs
index 5b4adc868df..ed8161acc0e 100644
--- a/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.rs
+++ b/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.rs
@@ -42,6 +42,7 @@ macro_rules! printlnfoo {
 fn main() {
     let _ = vec! {1, 2, 3};
     let _ = format!["ugh {} stop being such a good compiler", "hello"];
+    let _ = matches!{{}, ()};
     let _ = quote!(let x = 1;);
     let _ = quote::quote!(match match match);
     let _ = test!(); // trigger when macro def is inside our own crate
diff --git a/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.stderr b/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.stderr
index 039b23b1bdb..d80ad49f308 100644
--- a/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.stderr
+++ b/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.stderr
@@ -23,26 +23,38 @@ help: consider writing `format!("ugh () stop being such a good compiler", "hello
 LL |     let _ = format!["ugh {} stop being such a good compiler", "hello"];
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: use of irregular braces for `quote!` macro
+error: use of irregular braces for `matches!` macro
+  --> $DIR/conf_nonstandard_macro_braces.rs:45:13
+   |
+LL |     let _ = matches!{{}, ()};
+   |             ^^^^^^^^^^^^^^^^
+   |
+help: consider writing `matches!((), ())`
   --> $DIR/conf_nonstandard_macro_braces.rs:45:13
    |
+LL |     let _ = matches!{{}, ()};
+   |             ^^^^^^^^^^^^^^^^
+
+error: use of irregular braces for `quote!` macro
+  --> $DIR/conf_nonstandard_macro_braces.rs:46:13
+   |
 LL |     let _ = quote!(let x = 1;);
    |             ^^^^^^^^^^^^^^^^^^
    |
 help: consider writing `quote! {let x = 1;}`
-  --> $DIR/conf_nonstandard_macro_braces.rs:45:13
+  --> $DIR/conf_nonstandard_macro_braces.rs:46:13
    |
 LL |     let _ = quote!(let x = 1;);
    |             ^^^^^^^^^^^^^^^^^^
 
 error: use of irregular braces for `quote::quote!` macro
-  --> $DIR/conf_nonstandard_macro_braces.rs:46:13
+  --> $DIR/conf_nonstandard_macro_braces.rs:47:13
    |
 LL |     let _ = quote::quote!(match match match);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: consider writing `quote::quote! {match match match}`
-  --> $DIR/conf_nonstandard_macro_braces.rs:46:13
+  --> $DIR/conf_nonstandard_macro_braces.rs:47:13
    |
 LL |     let _ = quote::quote!(match match match);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -67,28 +79,28 @@ LL |     let _ = test!(); // trigger when macro def is inside our own crate
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: use of irregular braces for `type_pos!` macro
-  --> $DIR/conf_nonstandard_macro_braces.rs:55:12
+  --> $DIR/conf_nonstandard_macro_braces.rs:56:12
    |
 LL |     let _: type_pos!(usize) = vec![];
    |            ^^^^^^^^^^^^^^^^
    |
 help: consider writing `type_pos![usize]`
-  --> $DIR/conf_nonstandard_macro_braces.rs:55:12
+  --> $DIR/conf_nonstandard_macro_braces.rs:56:12
    |
 LL |     let _: type_pos!(usize) = vec![];
    |            ^^^^^^^^^^^^^^^^
 
 error: use of irregular braces for `eprint!` macro
-  --> $DIR/conf_nonstandard_macro_braces.rs:57:5
+  --> $DIR/conf_nonstandard_macro_braces.rs:58:5
    |
 LL |     eprint!("test if user config overrides defaults");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: consider writing `eprint!["test if user config overrides defaults"]`
-  --> $DIR/conf_nonstandard_macro_braces.rs:57:5
+  --> $DIR/conf_nonstandard_macro_braces.rs:58:5
    |
 LL |     eprint!("test if user config overrides defaults");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 7 previous errors
+error: aborting due to 8 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From e279f22a91ea633d88da154631a494eb09812829 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Tue, 20 Sep 2022 12:14:18 +0200
Subject: Changelog for Rust 1.64 :apple:

---
 CHANGELOG.md                                      | 154 +++++++++++++++++++++-
 clippy_lints/src/default_instead_of_iter_empty.rs |   2 +-
 clippy_lints/src/dereference.rs                   |   2 +-
 clippy_lints/src/loops/mod.rs                     |   2 +-
 clippy_lints/src/manual_rem_euclid.rs             |   2 +-
 clippy_lints/src/manual_retain.rs                 |   2 +-
 6 files changed, 157 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 044cbff4b78..a56be486217 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,11 +6,161 @@ document.
 
 ## Unreleased / In Rust Nightly
 
-[d7b5cbf0...master](https://github.com/rust-lang/rust-clippy/compare/d7b5cbf0...master)
+[3c7e7dbc...master](https://github.com/rust-lang/rust-clippy/compare/3c7e7dbc...master)
+
+## Rust 1.64
+
+Current stable, released 2022-09-22
+
+[d7b5cbf0...3c7e7dbc](https://github.com/rust-lang/rust-clippy/compare/d7b5cbf0...3c7e7dbc)
+
+### New Lints
+
+* [`arithmetic_side_effects`]
+  [#9130](https://github.com/rust-lang/rust-clippy/pull/9130)
+* [`invalid_utf8_in_unchecked`]
+  [#9105](https://github.com/rust-lang/rust-clippy/pull/9105)
+* [`assertions_on_result_states`]
+  [#9225](https://github.com/rust-lang/rust-clippy/pull/9225)
+* [`manual_find`]
+  [#8649](https://github.com/rust-lang/rust-clippy/pull/8649)
+* [`manual_retain`]
+  [#8972](https://github.com/rust-lang/rust-clippy/pull/8972)
+* [`default_instead_of_iter_empty`]
+  [#8989](https://github.com/rust-lang/rust-clippy/pull/8989)
+* [`manual_rem_euclid`]
+  [#9031](https://github.com/rust-lang/rust-clippy/pull/9031)
+* [`obfuscated_if_else`]
+  [#9148](https://github.com/rust-lang/rust-clippy/pull/9148)
+* [`std_instead_of_core`]
+  [#9103](https://github.com/rust-lang/rust-clippy/pull/9103)
+* [`std_instead_of_alloc`]
+  [#9103](https://github.com/rust-lang/rust-clippy/pull/9103)
+* [`alloc_instead_of_core`]
+  [#9103](https://github.com/rust-lang/rust-clippy/pull/9103)
+* [`explicit_auto_deref`]
+  [#8355](https://github.com/rust-lang/rust-clippy/pull/8355)
+
+
+### Moves and Deprecations
+
+* Moved [`format_push_string`] to `restriction` (now allow-by-default)
+  [#9161](https://github.com/rust-lang/rust-clippy/pull/9161)
+
+### Enhancements
+
+* [`significant_drop_in_scrutinee`]: Now gives more context in the lint message
+  [#8981](https://github.com/rust-lang/rust-clippy/pull/8981)
+* [`single_match`], [`single_match_else`]: Now catches more `Option` cases
+  [#8985](https://github.com/rust-lang/rust-clippy/pull/8985)
+* [`unused_async`]: Now works for async methods
+  [#9025](https://github.com/rust-lang/rust-clippy/pull/9025)
+* [`manual_filter_map`], [`manual_find_map`]: Now lint more expressions
+  [#8958](https://github.com/rust-lang/rust-clippy/pull/8958)
+* [`question_mark`]: Now works for simple `if let` expressions
+  [#8356](https://github.com/rust-lang/rust-clippy/pull/8356)
+* [`undocumented_unsafe_blocks`]: Now finds comments before the start of closures
+  [#9117](https://github.com/rust-lang/rust-clippy/pull/9117)
+* [`trait_duplication_in_bounds`]: Now catches duplicate bounds in where clauses
+  [#8703](https://github.com/rust-lang/rust-clippy/pull/8703)
+* [`shadow_reuse`], [`shadow_same`], [`shadow_unrelated`]: Now lint in const blocks
+  [#9124](https://github.com/rust-lang/rust-clippy/pull/9124)
+* [`slow_vector_initialization`]: Now detects cases with `vec.capacity()`
+  [#8953](https://github.com/rust-lang/rust-clippy/pull/8953)
+* [`unused_self`]: Now respects the `avoid-breaking-exported-api` config option
+  [#9199](https://github.com/rust-lang/rust-clippy/pull/9199)
+* [`box_collection`]: Now supports all std collections
+  [#9170](https://github.com/rust-lang/rust-clippy/pull/9170)
+
+### False Positive Fixes
+
+* [`significant_drop_in_scrutinee`]: Now ignores calls to `IntoIterator::into_iter`
+  [#9140](https://github.com/rust-lang/rust-clippy/pull/9140)
+* [`while_let_loop`]: Now ignores cases when the significant drop order would change
+  [#8981](https://github.com/rust-lang/rust-clippy/pull/8981)
+* [`branches_sharing_code`]: Now ignores cases where moved variables have a significant
+  drop or variable modifications can affect the conditions
+  [#9138](https://github.com/rust-lang/rust-clippy/pull/9138)
+* [`let_underscore_lock`]: Now ignores bindings that aren't locked
+  [#8990](https://github.com/rust-lang/rust-clippy/pull/8990)
+* [`trivially_copy_pass_by_ref`]: Now tracks lifetimes and ignores cases where unsafe
+  pointers are used
+  [#8639](https://github.com/rust-lang/rust-clippy/pull/8639)
+* [`let_unit_value`]: No longer ignores `#[allow]` attributes on the value
+  [#9082](https://github.com/rust-lang/rust-clippy/pull/9082)
+* [`declare_interior_mutable_const`]: Now ignores the `thread_local!` macro
+  [#9015](https://github.com/rust-lang/rust-clippy/pull/9015)
+* [`if_same_then_else`]: Now ignores branches with `todo!` and `unimplemented!`
+  [#9006](https://github.com/rust-lang/rust-clippy/pull/9006)
+* [`enum_variant_names`]: Now ignores names with `_` prefixes
+  [#9032](https://github.com/rust-lang/rust-clippy/pull/9032)
+* [`let_unit_value`]: Now ignores cases, where the unit type is manually specified
+  [#9056](https://github.com/rust-lang/rust-clippy/pull/9056)
+* [`match_same_arms`]: Now ignores branches with `todo!`
+  [#9207](https://github.com/rust-lang/rust-clippy/pull/9207)
+* [`assign_op_pattern`]: Ignores cases that break borrowing rules
+  [#9214](https://github.com/rust-lang/rust-clippy/pull/9214)
+* [`extra_unused_lifetimes`]: No longer triggers in derive macros
+  [#9037](https://github.com/rust-lang/rust-clippy/pull/9037)
+* [`mismatching_type_param_order`]: Now ignores complicated generic parameters
+  [#9146](https://github.com/rust-lang/rust-clippy/pull/9146)
+* [`equatable_if_let`]: No longer lints in macros
+  [#9074](https://github.com/rust-lang/rust-clippy/pull/9074)
+* [`new_without_default`]: Now ignores generics and lifetime parameters on `fn new`
+  [#9115](https://github.com/rust-lang/rust-clippy/pull/9115)
+* [`needless_borrow`]: Now ignores cases that result in the execution of different traits
+  [#9096](https://github.com/rust-lang/rust-clippy/pull/9096)
+* [`declare_interior_mutable_const`]: No longer triggers in thread-local initializers
+  [#9246](https://github.com/rust-lang/rust-clippy/pull/9246)
+
+### Suggestion Fixes/Improvements
+
+* [`type_repetition_in_bounds`]: The suggestion now works with maybe bounds
+  [#9132](https://github.com/rust-lang/rust-clippy/pull/9132)
+* [`transmute_ptr_to_ref`]: Now suggests `pointer::cast` when possible
+  [#8939](https://github.com/rust-lang/rust-clippy/pull/8939)
+* [`useless_format`]: Now suggests the correct variable name
+  [#9237](https://github.com/rust-lang/rust-clippy/pull/9237)
+* [`or_fun_call`]: The lint emission will now only span over the `unwrap_or` call
+  [#9144](https://github.com/rust-lang/rust-clippy/pull/9144)
+* [`neg_multiply`]: Now suggests adding parentheses around suggestion if needed
+  [#9026](https://github.com/rust-lang/rust-clippy/pull/9026)
+* [`unnecessary_lazy_evaluations`]: Now suggest for `bool::then_some` for lazy evaluation
+  [#9099](https://github.com/rust-lang/rust-clippy/pull/9099)
+* [`manual_flatten`]: Improved message for long code snippets
+  [#9156](https://github.com/rust-lang/rust-clippy/pull/9156)
+* [`explicit_counter_loop`]: The suggestion is now machine applicable
+  [#9149](https://github.com/rust-lang/rust-clippy/pull/9149)
+* [`needless_borrow`]: Now keeps parentheses around fields, when needed
+  [#9210](https://github.com/rust-lang/rust-clippy/pull/9210)
+* [`while_let_on_iterator`]: The suggestion now works in `FnOnce` closures
+  [#9134](https://github.com/rust-lang/rust-clippy/pull/9134)
+
+### ICE Fixes
+
+* Fix ICEs related to `#![feature(generic_const_exprs)]` usage
+  [#9241](https://github.com/rust-lang/rust-clippy/pull/9241)
+* Fix ICEs related to reference lints
+  [#9093](https://github.com/rust-lang/rust-clippy/pull/9093)
+* [`question_mark`]: Fix ICE on zero field tuple structs
+  [#9244](https://github.com/rust-lang/rust-clippy/pull/9244)
+
+### Documentation Improvements
+
+* [`needless_option_take`]: Now includes a "What it does" and "Why is this bad?" section.
+  [#9022](https://github.com/rust-lang/rust-clippy/pull/9022)
+
+### Others
+
+* Using `--cap-lints=allow` and only `--force-warn`ing some will now work with Clippy's driver
+  [#9036](https://github.com/rust-lang/rust-clippy/pull/9036)
+* Clippy now tries to read the `rust-version` from `Cargo.toml` to identify the
+  minimum supported rust version
+  [#8774](https://github.com/rust-lang/rust-clippy/pull/8774)
 
 ## Rust 1.63
 
-Current stable, released 2022-08-11
+Released 2022-08-11
 
 [7c21f91b...d7b5cbf0](https://github.com/rust-lang/rust-clippy/compare/7c21f91b...d7b5cbf0)
 
diff --git a/clippy_lints/src/default_instead_of_iter_empty.rs b/clippy_lints/src/default_instead_of_iter_empty.rs
index 3c996d3d2ae..1ad929864b2 100644
--- a/clippy_lints/src/default_instead_of_iter_empty.rs
+++ b/clippy_lints/src/default_instead_of_iter_empty.rs
@@ -23,7 +23,7 @@ declare_clippy_lint! {
     /// let _ = std::iter::empty::<usize>();
     /// let iter: std::iter::Empty<usize> = std::iter::empty();
     /// ```
-    #[clippy::version = "1.63.0"]
+    #[clippy::version = "1.64.0"]
     pub DEFAULT_INSTEAD_OF_ITER_EMPTY,
     style,
     "check `std::iter::Empty::default()` and replace with `std::iter::empty()`"
diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index d1b25a0f1b5..b965d27afce 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -135,7 +135,7 @@ declare_clippy_lint! {
     /// let x = String::new();
     /// let y: &str = &x;
     /// ```
-    #[clippy::version = "1.60.0"]
+    #[clippy::version = "1.64.0"]
     pub EXPLICIT_AUTO_DEREF,
     complexity,
     "dereferencing when the compiler would automatically dereference"
diff --git a/clippy_lints/src/loops/mod.rs b/clippy_lints/src/loops/mod.rs
index 74f3bda9f43..c0a0444485e 100644
--- a/clippy_lints/src/loops/mod.rs
+++ b/clippy_lints/src/loops/mod.rs
@@ -635,7 +635,7 @@ declare_clippy_lint! {
     ///     arr.into_iter().find(|&el| el == 1)
     /// }
     /// ```
-    #[clippy::version = "1.61.0"]
+    #[clippy::version = "1.64.0"]
     pub MANUAL_FIND,
     complexity,
     "manual implementation of `Iterator::find`"
diff --git a/clippy_lints/src/manual_rem_euclid.rs b/clippy_lints/src/manual_rem_euclid.rs
index 95cc6bdbd8b..6f25a2ed8e4 100644
--- a/clippy_lints/src/manual_rem_euclid.rs
+++ b/clippy_lints/src/manual_rem_euclid.rs
@@ -27,7 +27,7 @@ declare_clippy_lint! {
     /// let x: i32 = 24;
     /// let rem = x.rem_euclid(4);
     /// ```
-    #[clippy::version = "1.63.0"]
+    #[clippy::version = "1.64.0"]
     pub MANUAL_REM_EUCLID,
     complexity,
     "manually reimplementing `rem_euclid`"
diff --git a/clippy_lints/src/manual_retain.rs b/clippy_lints/src/manual_retain.rs
index f28c37d3dca..8476197bd12 100644
--- a/clippy_lints/src/manual_retain.rs
+++ b/clippy_lints/src/manual_retain.rs
@@ -43,7 +43,7 @@ declare_clippy_lint! {
     /// let mut vec = vec![0, 1, 2];
     /// vec.retain(|x| x % 2 == 0);
     /// ```
-    #[clippy::version = "1.63.0"]
+    #[clippy::version = "1.64.0"]
     pub MANUAL_RETAIN,
     perf,
     "`retain()` is simpler and the same functionalitys"
-- 
cgit 1.4.1-3-g733a5


From a783d542073497b658d0e57960b612e2f6e0734a Mon Sep 17 00:00:00 2001
From: Michael Wright <mikerite@lavabit.com>
Date: Wed, 21 Sep 2022 07:02:52 +0200
Subject: Fix ICE in `unnecessary_to_owned`

Fixes #9504

Compiler generated call `into_iter` nodes return empty substs
which we need when checking it's predicates. Handle this by
simply exitting when we encounter one. This change introduces
false negatives in place of the ICEs.
---
 clippy_lints/src/methods/unnecessary_to_owned.rs | 6 +++++-
 tests/ui/unnecessary_to_owned.fixed              | 9 +++++++++
 tests/ui/unnecessary_to_owned.rs                 | 9 +++++++++
 3 files changed, 23 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/unnecessary_to_owned.rs b/clippy_lints/src/methods/unnecessary_to_owned.rs
index b32e5d8d421..8e9ed33e009 100644
--- a/clippy_lints/src/methods/unnecessary_to_owned.rs
+++ b/clippy_lints/src/methods/unnecessary_to_owned.rs
@@ -8,7 +8,7 @@ use clippy_utils::visitors::find_all_ret_expressions;
 use clippy_utils::{fn_def_id, get_parent_expr, is_diag_item_method, is_diag_trait_item, return_ty};
 use clippy_utils::{meets_msrv, msrvs};
 use rustc_errors::Applicability;
-use rustc_hir::{def_id::DefId, BorrowKind, Expr, ExprKind, ItemKind, Node};
+use rustc_hir::{def_id::DefId, BorrowKind, Expr, ExprKind, ItemKind, LangItem, Node};
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::LateContext;
 use rustc_middle::mir::Mutability;
@@ -380,6 +380,10 @@ fn can_change_type<'a>(cx: &LateContext<'a>, mut expr: &'a Expr<'a>, mut ty: Ty<
             Node::Expr(parent_expr) => {
                 if let Some((callee_def_id, call_substs, recv, call_args)) = get_callee_substs_and_args(cx, parent_expr)
                 {
+                    if cx.tcx.lang_items().require(LangItem::IntoFutureIntoFuture) == Ok(callee_def_id) {
+                        return false;
+                    }
+
                     let fn_sig = cx.tcx.fn_sig(callee_def_id).skip_binder();
                     if let Some(arg_index) = recv.into_iter().chain(call_args).position(|arg| arg.hir_id == expr.hir_id)
                         && let Some(param_ty) = fn_sig.inputs().get(arg_index)
diff --git a/tests/ui/unnecessary_to_owned.fixed b/tests/ui/unnecessary_to_owned.fixed
index a920c63b199..f97583aa22f 100644
--- a/tests/ui/unnecessary_to_owned.fixed
+++ b/tests/ui/unnecessary_to_owned.fixed
@@ -417,3 +417,12 @@ mod issue_9351 {
         predicates_are_satisfied(id("abc".to_string()));
     }
 }
+
+mod issue_9504 {
+    #![allow(dead_code)]
+
+    async fn foo<S: AsRef<str>>(_: S) {}
+    async fn bar() {
+        foo(std::path::PathBuf::new().to_string_lossy().to_string()).await;
+    }
+}
diff --git a/tests/ui/unnecessary_to_owned.rs b/tests/ui/unnecessary_to_owned.rs
index 2128bdacdda..aa5394a5657 100644
--- a/tests/ui/unnecessary_to_owned.rs
+++ b/tests/ui/unnecessary_to_owned.rs
@@ -417,3 +417,12 @@ mod issue_9351 {
         predicates_are_satisfied(id("abc".to_string()));
     }
 }
+
+mod issue_9504 {
+    #![allow(dead_code)]
+
+    async fn foo<S: AsRef<str>>(_: S) {}
+    async fn bar() {
+        foo(std::path::PathBuf::new().to_string_lossy().to_string()).await;
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 4c5f23082aff7c55d32de9869c0c40df94eeae37 Mon Sep 17 00:00:00 2001
From: Caio <c410.f3r@gmail.com>
Date: Wed, 21 Sep 2022 15:02:37 -0300
Subject: [arithmetic-side-effects] Consider references

---
 .../src/operators/arithmetic_side_effects.rs       |  59 +++++++----
 tests/ui/arithmetic_side_effects.rs                |  40 +++++++-
 tests/ui/arithmetic_side_effects.stderr            | 114 ++++++++++++++++++---
 3 files changed, 172 insertions(+), 41 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/operators/arithmetic_side_effects.rs b/clippy_lints/src/operators/arithmetic_side_effects.rs
index d24c57c0a4b..c8a374d90b5 100644
--- a/clippy_lints/src/operators/arithmetic_side_effects.rs
+++ b/clippy_lints/src/operators/arithmetic_side_effects.rs
@@ -9,7 +9,6 @@ use rustc_ast as ast;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty::Ty;
 use rustc_session::impl_lint_pass;
 use rustc_span::source_map::{Span, Spanned};
 
@@ -78,28 +77,47 @@ impl ArithmeticSideEffects {
         )
     }
 
-    /// Explicit integers like `1` or `i32::MAX`. Does not take into consideration references.
-    fn is_literal_integer(expr: &hir::Expr<'_>, expr_refs: Ty<'_>) -> bool {
-        let is_integral = expr_refs.is_integral();
-        let is_literal = matches!(expr.kind, hir::ExprKind::Lit(_));
-        is_integral && is_literal
-    }
-
+    // Common entry-point to avoid code duplication.
     fn issue_lint(&mut self, cx: &LateContext<'_>, expr: &hir::Expr<'_>) {
         let msg = "arithmetic operation that can potentially result in unexpected side-effects";
         span_lint(cx, ARITHMETIC_SIDE_EFFECTS, expr.span, msg);
         self.expr_span = Some(expr.span);
     }
 
+    /// * If `expr` is a literal integer like `1` or `i32::MAX`, returns itself.
+    /// * Is `expr` is a literal integer reference like `&199`, returns the literal integer without
+    ///   references.
+    /// * If `expr` is anything else, returns `None`.
+    fn literal_integer<'expr, 'tcx>(
+        cx: &LateContext<'tcx>,
+        expr: &'expr hir::Expr<'tcx>,
+    ) -> Option<&'expr hir::Expr<'tcx>> {
+        let expr_refs = cx.typeck_results().expr_ty(expr).peel_refs();
+
+        if !expr_refs.is_integral() {
+            return None;
+        }
+
+        if matches!(expr.kind, hir::ExprKind::Lit(_)) {
+            return Some(expr);
+        }
+
+        if let hir::ExprKind::AddrOf(.., inn) = expr.kind && let hir::ExprKind::Lit(_) = inn.kind {
+            return Some(inn)
+        }
+
+        None
+    }
+
     /// Manages when the lint should be triggered. Operations in constant environments, hard coded
     /// types, custom allowed types and non-constant operations that won't overflow are ignored.
-    fn manage_bin_ops(
+    fn manage_bin_ops<'tcx>(
         &mut self,
-        cx: &LateContext<'_>,
-        expr: &hir::Expr<'_>,
+        cx: &LateContext<'tcx>,
+        expr: &hir::Expr<'tcx>,
         op: &Spanned<hir::BinOpKind>,
-        lhs: &hir::Expr<'_>,
-        rhs: &hir::Expr<'_>,
+        lhs: &hir::Expr<'tcx>,
+        rhs: &hir::Expr<'tcx>,
     ) {
         if constant_simple(cx, cx.typeck_results(), expr).is_some() {
             return;
@@ -119,14 +137,11 @@ impl ArithmeticSideEffects {
         if self.is_allowed_ty(cx, lhs) || self.is_allowed_ty(cx, rhs) {
             return;
         }
-        let has_valid_op = match (
-            Self::is_literal_integer(lhs, cx.typeck_results().expr_ty(lhs).peel_refs()),
-            Self::is_literal_integer(rhs, cx.typeck_results().expr_ty(rhs).peel_refs()),
-        ) {
-            (true, true) => true,
-            (true, false) => Self::has_valid_op(op, lhs),
-            (false, true) => Self::has_valid_op(op, rhs),
-            (false, false) => false,
+        let has_valid_op = match (Self::literal_integer(cx, lhs), Self::literal_integer(cx, rhs)) {
+            (None, None) => false,
+            (None, Some(local_expr)) => Self::has_valid_op(op, local_expr),
+            (Some(local_expr), None) => Self::has_valid_op(op, local_expr),
+            (Some(_), Some(_)) => true,
         };
         if !has_valid_op {
             self.issue_lint(cx, expr);
@@ -135,7 +150,7 @@ impl ArithmeticSideEffects {
 }
 
 impl<'tcx> LateLintPass<'tcx> for ArithmeticSideEffects {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &hir::Expr<'tcx>) {
         if self.expr_span.is_some() || self.const_span.map_or(false, |sp| sp.contains(expr.span)) {
             return;
         }
diff --git a/tests/ui/arithmetic_side_effects.rs b/tests/ui/arithmetic_side_effects.rs
index dd24f5aa592..6741e148547 100644
--- a/tests/ui/arithmetic_side_effects.rs
+++ b/tests/ui/arithmetic_side_effects.rs
@@ -2,11 +2,12 @@
     clippy::assign_op_pattern,
     clippy::erasing_op,
     clippy::identity_op,
+    clippy::op_ref,
     clippy::unnecessary_owned_empty_strings,
     arithmetic_overflow,
     unconditional_panic
 )]
-#![feature(inline_const, saturating_int_impl)]
+#![feature(const_mut_refs, inline_const, saturating_int_impl)]
 #![warn(clippy::arithmetic_side_effects)]
 
 use core::num::{Saturating, Wrapping};
@@ -79,33 +80,50 @@ pub fn const_ops_should_not_trigger_the_lint() {
     const _: i32 = 1 + 1;
     let _ = const { 1 + 1 };
 
-    const _: i32 = { let mut n = -1; n = -(-1); n = -n; n };
-    let _ = const { let mut n = -1; n = -(-1); n = -n; n };
+    const _: i32 = { let mut n = 1; n = -1; n = -(-1); n = -n; n };
+    let _ = const { let mut n = 1; n = -1; n = -(-1); n = -n; n };
 }
 
-pub fn non_overflowing_runtime_ops_or_ops_already_handled_by_the_compiler() {
+pub fn non_overflowing_ops_or_ops_already_handled_by_the_compiler_should_not_trigger_the_lint() {
     let mut _n = i32::MAX;
 
     // Assign
     _n += 0;
+    _n += &0;
     _n -= 0;
+    _n -= &0;
     _n /= 99;
+    _n /= &99;
     _n %= 99;
+    _n %= &99;
     _n *= 0;
+    _n *= &0;
     _n *= 1;
+    _n *= &1;
 
     // Binary
     _n = _n + 0;
+    _n = _n + &0;
     _n = 0 + _n;
+    _n = &0 + _n;
     _n = _n - 0;
+    _n = _n - &0;
     _n = 0 - _n;
+    _n = &0 - _n;
     _n = _n / 99;
+    _n = _n / &99;
     _n = _n % 99;
+    _n = _n % &99;
     _n = _n * 0;
+    _n = _n * &0;
     _n = 0 * _n;
+    _n = &0 * _n;
     _n = _n * 1;
+    _n = _n * &1;
     _n = 1 * _n;
+    _n = &1 * _n;
     _n = 23 + 85;
+    _n = &23 + &85;
 
     // Unary
     _n = -1;
@@ -117,23 +135,37 @@ pub fn overflowing_runtime_ops() {
 
     // Assign
     _n += 1;
+    _n += &1;
     _n -= 1;
+    _n -= &1;
     _n /= 0;
+    _n /= &0;
     _n %= 0;
+    _n %= &0;
     _n *= 2;
+    _n *= &2;
 
     // Binary
     _n = _n + 1;
+    _n = _n + &1;
     _n = 1 + _n;
+    _n = &1 + _n;
     _n = _n - 1;
+    _n = _n - &1;
     _n = 1 - _n;
+    _n = &1 - _n;
     _n = _n / 0;
+    _n = _n / &0;
     _n = _n % 0;
+    _n = _n % &0;
     _n = _n * 2;
+    _n = _n * &2;
     _n = 2 * _n;
+    _n = &2 * _n;
 
     // Unary
     _n = -_n;
+    _n = -&_n;
 }
 
 fn main() {}
diff --git a/tests/ui/arithmetic_side_effects.stderr b/tests/ui/arithmetic_side_effects.stderr
index a2a856efbff..4dce13b624b 100644
--- a/tests/ui/arithmetic_side_effects.stderr
+++ b/tests/ui/arithmetic_side_effects.stderr
@@ -1,5 +1,5 @@
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:119:5
+  --> $DIR/arithmetic_side_effects.rs:137:5
    |
 LL |     _n += 1;
    |     ^^^^^^^
@@ -7,82 +7,166 @@ LL |     _n += 1;
    = note: `-D clippy::arithmetic-side-effects` implied by `-D warnings`
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:120:5
+  --> $DIR/arithmetic_side_effects.rs:138:5
+   |
+LL |     _n += &1;
+   |     ^^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:139:5
    |
 LL |     _n -= 1;
    |     ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:121:5
+  --> $DIR/arithmetic_side_effects.rs:140:5
+   |
+LL |     _n -= &1;
+   |     ^^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:141:5
    |
 LL |     _n /= 0;
    |     ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:122:5
+  --> $DIR/arithmetic_side_effects.rs:142:5
+   |
+LL |     _n /= &0;
+   |     ^^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:143:5
    |
 LL |     _n %= 0;
    |     ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:123:5
+  --> $DIR/arithmetic_side_effects.rs:144:5
+   |
+LL |     _n %= &0;
+   |     ^^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:145:5
    |
 LL |     _n *= 2;
    |     ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:126:10
+  --> $DIR/arithmetic_side_effects.rs:146:5
+   |
+LL |     _n *= &2;
+   |     ^^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:149:10
    |
 LL |     _n = _n + 1;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:127:10
+  --> $DIR/arithmetic_side_effects.rs:150:10
+   |
+LL |     _n = _n + &1;
+   |          ^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:151:10
    |
 LL |     _n = 1 + _n;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:128:10
+  --> $DIR/arithmetic_side_effects.rs:152:10
+   |
+LL |     _n = &1 + _n;
+   |          ^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:153:10
    |
 LL |     _n = _n - 1;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:129:10
+  --> $DIR/arithmetic_side_effects.rs:154:10
+   |
+LL |     _n = _n - &1;
+   |          ^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:155:10
    |
 LL |     _n = 1 - _n;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:130:10
+  --> $DIR/arithmetic_side_effects.rs:156:10
+   |
+LL |     _n = &1 - _n;
+   |          ^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:157:10
    |
 LL |     _n = _n / 0;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:131:10
+  --> $DIR/arithmetic_side_effects.rs:158:10
+   |
+LL |     _n = _n / &0;
+   |          ^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:159:10
    |
 LL |     _n = _n % 0;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:132:10
+  --> $DIR/arithmetic_side_effects.rs:160:10
+   |
+LL |     _n = _n % &0;
+   |          ^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:161:10
    |
 LL |     _n = _n * 2;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:133:10
+  --> $DIR/arithmetic_side_effects.rs:162:10
+   |
+LL |     _n = _n * &2;
+   |          ^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:163:10
    |
 LL |     _n = 2 * _n;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:136:10
+  --> $DIR/arithmetic_side_effects.rs:164:10
+   |
+LL |     _n = &2 * _n;
+   |          ^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:167:10
    |
 LL |     _n = -_n;
    |          ^^^
 
-error: aborting due to 14 previous errors
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:168:10
+   |
+LL |     _n = -&_n;
+   |          ^^^^
+
+error: aborting due to 28 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From a390115c6f0e40001e87a8fd6fdaf864ddd81cf4 Mon Sep 17 00:00:00 2001
From: kraktus <kraktus@users.noreply.github.com>
Date: Mon, 19 Sep 2022 18:08:28 +0200
Subject: [`nonstandard_macro_braces`] Do not modify macro arguments

Also simplify the lint by not caring about code format which should be `rustfmt` job, and turn the lint into machine Applicable
---
 clippy_lints/src/nonstandard_macro_braces.rs       | 71 +++++++++----------
 .../conf_nonstandard_macro_braces.fixed            | 62 +++++++++++++++++
 .../conf_nonstandard_macro_braces.rs               |  1 +
 .../conf_nonstandard_macro_braces.stderr           | 81 +++++-----------------
 4 files changed, 111 insertions(+), 104 deletions(-)
 create mode 100644 tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.fixed

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/nonstandard_macro_braces.rs b/clippy_lints/src/nonstandard_macro_braces.rs
index f86dfb6b8df..5e38a95c40b 100644
--- a/clippy_lints/src/nonstandard_macro_braces.rs
+++ b/clippy_lints/src/nonstandard_macro_braces.rs
@@ -3,16 +3,17 @@ use std::{
     hash::{Hash, Hasher},
 };
 
-use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_opt;
 use if_chain::if_chain;
 use rustc_ast::ast;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
+use rustc_errors::Applicability;
 use rustc_hir::def_id::DefId;
 use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::hygiene::{ExpnKind, MacroKind};
-use rustc_span::{Span, Symbol};
+use rustc_span::Span;
 use serde::{de, Deserialize};
 
 declare_clippy_lint! {
@@ -39,8 +40,8 @@ declare_clippy_lint! {
 
 const BRACES: &[(&str, &str)] = &[("(", ")"), ("{", "}"), ("[", "]")];
 
-/// The (name, (open brace, close brace), source snippet)
-type MacroInfo<'a> = (Symbol, &'a (String, String), String);
+/// The (callsite span, (open brace, close brace), source snippet)
+type MacroInfo<'a> = (Span, &'a (String, String), String);
 
 #[derive(Clone, Debug, Default)]
 pub struct MacroBraces {
@@ -62,33 +63,29 @@ impl_lint_pass!(MacroBraces => [NONSTANDARD_MACRO_BRACES]);
 
 impl EarlyLintPass for MacroBraces {
     fn check_item(&mut self, cx: &EarlyContext<'_>, item: &ast::Item) {
-        if let Some((name, braces, snip)) = is_offending_macro(cx, item.span, self) {
-            let span = item.span.ctxt().outer_expn_data().call_site;
-            emit_help(cx, snip, braces, name, span);
+        if let Some((span, braces, snip)) = is_offending_macro(cx, item.span, self) {
+            emit_help(cx, &snip, braces, span);
             self.done.insert(span);
         }
     }
 
     fn check_stmt(&mut self, cx: &EarlyContext<'_>, stmt: &ast::Stmt) {
-        if let Some((name, braces, snip)) = is_offending_macro(cx, stmt.span, self) {
-            let span = stmt.span.ctxt().outer_expn_data().call_site;
-            emit_help(cx, snip, braces, name, span);
+        if let Some((span, braces, snip)) = is_offending_macro(cx, stmt.span, self) {
+            emit_help(cx, &snip, braces, span);
             self.done.insert(span);
         }
     }
 
     fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &ast::Expr) {
-        if let Some((name, braces, snip)) = is_offending_macro(cx, expr.span, self) {
-            let span = expr.span.ctxt().outer_expn_data().call_site;
-            emit_help(cx, snip, braces, name, span);
+        if let Some((span, braces, snip)) = is_offending_macro(cx, expr.span, self) {
+            emit_help(cx, &snip, braces, span);
             self.done.insert(span);
         }
     }
 
     fn check_ty(&mut self, cx: &EarlyContext<'_>, ty: &ast::Ty) {
-        if let Some((name, braces, snip)) = is_offending_macro(cx, ty.span, self) {
-            let span = ty.span.ctxt().outer_expn_data().call_site;
-            emit_help(cx, snip, braces, name, span);
+        if let Some((span, braces, snip)) = is_offending_macro(cx, ty.span, self) {
+            emit_help(cx, &snip, braces, span);
             self.done.insert(span);
         }
     }
@@ -102,11 +99,12 @@ fn is_offending_macro<'a>(cx: &EarlyContext<'_>, span: Span, mac_braces: &'a Mac
                 .last()
                 .map_or(false, |e| e.macro_def_id.map_or(false, DefId::is_local))
     };
+    let span_call_site = span.ctxt().outer_expn_data().call_site;
     if_chain! {
         if let ExpnKind::Macro(MacroKind::Bang, mac_name) = span.ctxt().outer_expn_data().kind;
         let name = mac_name.as_str();
         if let Some(braces) = mac_braces.macro_braces.get(name);
-        if let Some(snip) = snippet_opt(cx, span.ctxt().outer_expn_data().call_site);
+        if let Some(snip) = snippet_opt(cx, span_call_site);
         // we must check only invocation sites
         // https://github.com/rust-lang/rust-clippy/issues/7422
         if snip.starts_with(&format!("{}!", name));
@@ -114,36 +112,31 @@ fn is_offending_macro<'a>(cx: &EarlyContext<'_>, span: Span, mac_braces: &'a Mac
         // make formatting consistent
         let c = snip.replace(' ', "");
         if !c.starts_with(&format!("{}!{}", name, braces.0));
-        if !mac_braces.done.contains(&span.ctxt().outer_expn_data().call_site);
+        if !mac_braces.done.contains(&span_call_site);
         then {
-            Some((mac_name, braces, snip))
+            Some((span_call_site, braces, snip))
         } else {
             None
         }
     }
 }
 
-fn emit_help(cx: &EarlyContext<'_>, snip: String, braces: &(String, String), name: Symbol, span: Span) {
-    let with_space = &format!("! {}", braces.0);
-    let without_space = &format!("!{}", braces.0);
-    let mut help = snip;
-    for b in BRACES.iter().filter(|b| b.0 != braces.0) {
-        help = help.replace(b.0, &braces.0).replace(b.1, &braces.1);
-        // Only `{` traditionally has space before the brace
-        if braces.0 != "{" && help.contains(with_space) {
-            help = help.replace(with_space, without_space);
-        } else if braces.0 == "{" && help.contains(without_space) {
-            help = help.replace(without_space, with_space);
-        }
+fn emit_help(cx: &EarlyContext<'_>, snip: &str, braces: &(String, String), span: Span) {
+    if let Some((macro_name, macro_args_str)) = snip.split_once('!') {
+        let mut macro_args = macro_args_str.trim().to_string();
+        // now remove the wrong braces
+        macro_args.remove(0);
+        macro_args.pop();
+        span_lint_and_sugg(
+            cx,
+            NONSTANDARD_MACRO_BRACES,
+            span,
+            &format!("use of irregular braces for `{}!` macro", macro_name),
+            "consider writing",
+            format!("{}!{}{}{}", macro_name, braces.0, macro_args, braces.1),
+            Applicability::MachineApplicable,
+        );
     }
-    span_lint_and_help(
-        cx,
-        NONSTANDARD_MACRO_BRACES,
-        span,
-        &format!("use of irregular braces for `{}!` macro", name),
-        Some(span),
-        &format!("consider writing `{}`", help),
-    );
 }
 
 fn macro_braces(conf: FxHashSet<MacroMatcher>) -> FxHashMap<String, (String, String)> {
diff --git a/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.fixed b/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.fixed
new file mode 100644
index 00000000000..01d135764df
--- /dev/null
+++ b/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.fixed
@@ -0,0 +1,62 @@
+// aux-build:proc_macro_derive.rs
+// run-rustfix
+
+#![warn(clippy::nonstandard_macro_braces)]
+
+extern crate proc_macro_derive;
+extern crate quote;
+
+use quote::quote;
+
+#[derive(proc_macro_derive::DeriveSomething)]
+pub struct S;
+
+proc_macro_derive::foo_bar!();
+
+#[rustfmt::skip]
+macro_rules! test {
+    () => {
+        vec![0, 0, 0]
+    };
+}
+
+#[rustfmt::skip]
+macro_rules! test2 {
+    ($($arg:tt)*) => {
+        format_args!($($arg)*)
+    };
+}
+
+macro_rules! type_pos {
+    ($what:ty) => {
+        Vec<$what>
+    };
+}
+
+macro_rules! printlnfoo {
+    ($thing:expr) => {
+        println!("{}", $thing)
+    };
+}
+
+#[rustfmt::skip]
+fn main() {
+    let _ = vec![1, 2, 3];
+    let _ = format!("ugh {} stop being such a good compiler", "hello");
+    let _ = matches!({}, ());
+    let _ = quote!{let x = 1;};
+    let _ = quote::quote!{match match match};
+    let _ = test!(); // trigger when macro def is inside our own crate
+    let _ = vec![1,2,3];
+
+    let _ = quote::quote! {true || false};
+    let _ = vec! [0 ,0 ,0];
+    let _ = format!("fds{}fds", 10);
+    let _ = test2!["{}{}{}", 1, 2, 3];
+
+    let _: type_pos![usize] = vec![];
+
+    eprint!["test if user config overrides defaults"];
+
+    printlnfoo!["test if printlnfoo is triggered by println"];
+}
diff --git a/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.rs b/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.rs
index ed8161acc0e..72883e8270c 100644
--- a/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.rs
+++ b/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.rs
@@ -1,4 +1,5 @@
 // aux-build:proc_macro_derive.rs
+// run-rustfix
 
 #![warn(clippy::nonstandard_macro_braces)]
 
diff --git a/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.stderr b/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.stderr
index d80ad49f308..7ae3815978c 100644
--- a/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.stderr
+++ b/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.stderr
@@ -1,106 +1,57 @@
 error: use of irregular braces for `vec!` macro
-  --> $DIR/conf_nonstandard_macro_braces.rs:43:13
+  --> $DIR/conf_nonstandard_macro_braces.rs:44:13
    |
 LL |     let _ = vec! {1, 2, 3};
-   |             ^^^^^^^^^^^^^^
+   |             ^^^^^^^^^^^^^^ help: consider writing: `vec![1, 2, 3]`
    |
    = note: `-D clippy::nonstandard-macro-braces` implied by `-D warnings`
-help: consider writing `vec![1, 2, 3]`
-  --> $DIR/conf_nonstandard_macro_braces.rs:43:13
-   |
-LL |     let _ = vec! {1, 2, 3};
-   |             ^^^^^^^^^^^^^^
 
 error: use of irregular braces for `format!` macro
-  --> $DIR/conf_nonstandard_macro_braces.rs:44:13
-   |
-LL |     let _ = format!["ugh {} stop being such a good compiler", "hello"];
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: consider writing `format!("ugh () stop being such a good compiler", "hello")`
-  --> $DIR/conf_nonstandard_macro_braces.rs:44:13
+  --> $DIR/conf_nonstandard_macro_braces.rs:45:13
    |
 LL |     let _ = format!["ugh {} stop being such a good compiler", "hello"];
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `format!("ugh {} stop being such a good compiler", "hello")`
 
 error: use of irregular braces for `matches!` macro
-  --> $DIR/conf_nonstandard_macro_braces.rs:45:13
-   |
-LL |     let _ = matches!{{}, ()};
-   |             ^^^^^^^^^^^^^^^^
-   |
-help: consider writing `matches!((), ())`
-  --> $DIR/conf_nonstandard_macro_braces.rs:45:13
+  --> $DIR/conf_nonstandard_macro_braces.rs:46:13
    |
 LL |     let _ = matches!{{}, ()};
-   |             ^^^^^^^^^^^^^^^^
+   |             ^^^^^^^^^^^^^^^^ help: consider writing: `matches!({}, ())`
 
 error: use of irregular braces for `quote!` macro
-  --> $DIR/conf_nonstandard_macro_braces.rs:46:13
-   |
-LL |     let _ = quote!(let x = 1;);
-   |             ^^^^^^^^^^^^^^^^^^
-   |
-help: consider writing `quote! {let x = 1;}`
-  --> $DIR/conf_nonstandard_macro_braces.rs:46:13
+  --> $DIR/conf_nonstandard_macro_braces.rs:47:13
    |
 LL |     let _ = quote!(let x = 1;);
-   |             ^^^^^^^^^^^^^^^^^^
+   |             ^^^^^^^^^^^^^^^^^^ help: consider writing: `quote!{let x = 1;}`
 
 error: use of irregular braces for `quote::quote!` macro
-  --> $DIR/conf_nonstandard_macro_braces.rs:47:13
+  --> $DIR/conf_nonstandard_macro_braces.rs:48:13
    |
 LL |     let _ = quote::quote!(match match match);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: consider writing `quote::quote! {match match match}`
-  --> $DIR/conf_nonstandard_macro_braces.rs:47:13
-   |
-LL |     let _ = quote::quote!(match match match);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `quote::quote!{match match match}`
 
 error: use of irregular braces for `vec!` macro
-  --> $DIR/conf_nonstandard_macro_braces.rs:18:9
+  --> $DIR/conf_nonstandard_macro_braces.rs:19:9
    |
 LL |         vec!{0, 0, 0}
-   |         ^^^^^^^^^^^^^
+   |         ^^^^^^^^^^^^^ help: consider writing: `vec![0, 0, 0]`
 ...
 LL |     let _ = test!(); // trigger when macro def is inside our own crate
    |             ------- in this macro invocation
    |
-help: consider writing `vec![0, 0, 0]`
-  --> $DIR/conf_nonstandard_macro_braces.rs:18:9
-   |
-LL |         vec!{0, 0, 0}
-   |         ^^^^^^^^^^^^^
-...
-LL |     let _ = test!(); // trigger when macro def is inside our own crate
-   |             ------- in this macro invocation
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: use of irregular braces for `type_pos!` macro
-  --> $DIR/conf_nonstandard_macro_braces.rs:56:12
+  --> $DIR/conf_nonstandard_macro_braces.rs:57:12
    |
 LL |     let _: type_pos!(usize) = vec![];
-   |            ^^^^^^^^^^^^^^^^
-   |
-help: consider writing `type_pos![usize]`
-  --> $DIR/conf_nonstandard_macro_braces.rs:56:12
-   |
-LL |     let _: type_pos!(usize) = vec![];
-   |            ^^^^^^^^^^^^^^^^
+   |            ^^^^^^^^^^^^^^^^ help: consider writing: `type_pos![usize]`
 
 error: use of irregular braces for `eprint!` macro
-  --> $DIR/conf_nonstandard_macro_braces.rs:58:5
-   |
-LL |     eprint!("test if user config overrides defaults");
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: consider writing `eprint!["test if user config overrides defaults"]`
-  --> $DIR/conf_nonstandard_macro_braces.rs:58:5
+  --> $DIR/conf_nonstandard_macro_braces.rs:59:5
    |
 LL |     eprint!("test if user config overrides defaults");
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `eprint!["test if user config overrides defaults"]`
 
 error: aborting due to 8 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From cda754739471869a12d7055466180e4fec702dba Mon Sep 17 00:00:00 2001
From: kraktus <kraktus@users.noreply.github.com>
Date: Thu, 22 Sep 2022 16:33:14 +0200
Subject: Make `semicolon_span` code more refactor-tolerant

---
 clippy_lints/src/returns.rs | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
index f7ceb415a79..f758f4cff8b 100644
--- a/clippy_lints/src/returns.rs
+++ b/clippy_lints/src/returns.rs
@@ -9,7 +9,7 @@ use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::subst::GenericArgKind;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::source_map::{Span, DUMMY_SP};
+use rustc_span::source_map::Span;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -182,8 +182,10 @@ fn check_block_return<'tcx>(cx: &LateContext<'tcx>, expr_kind: &ExprKind<'tcx>,
                 StmtKind::Semi(semi_expr) => {
                     let mut semi_spans_and_this_one = semi_spans;
                     // we only want the span containing the semicolon so we can remove it later. From `entry.rs:382`
-                    semi_spans_and_this_one.push(stmt.span.trim_start(semi_expr.span).unwrap_or(DUMMY_SP));
-                    check_final_expr(cx, semi_expr, semi_spans_and_this_one, RetReplacement::Empty);
+                    if let Some(semicolon_span) = stmt.span.trim_start(semi_expr.span) {
+                        semi_spans_and_this_one.push(semicolon_span);
+                        check_final_expr(cx, semi_expr, semi_spans_and_this_one, RetReplacement::Empty);
+                    }
                 },
                 _ => (),
             }
-- 
cgit 1.4.1-3-g733a5


From 49319b4206cbde83e0113c024b09275677ab8d74 Mon Sep 17 00:00:00 2001
From: Alessandro Decina <alessandro.d@gmail.com>
Date: Fri, 23 Sep 2022 00:06:13 +0100
Subject: uninit_vec: special case set_len(0)

set_len(0) does not create uninitialized elements. Fixes a false positive with
the following pattern:

    fn copy_slice_into_vec(dst: &mut Vec<u8>, src: &[u8]) {
        dst.reserve(src.len().saturating_sub(dst.len()));
        unsafe {
            dst.set_len(0);
            std::ptr::copy_nonoverlapping(src.as_ptr(), dst.as_mut_ptr(), src.len());
            dst.set_len(src.len());
        }
    }
---
 clippy_lints/src/uninit_vec.rs | 18 ++++++++++++++++--
 tests/ui/uninit_vec.rs         |  6 ++++++
 2 files changed, 22 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/uninit_vec.rs b/clippy_lints/src/uninit_vec.rs
index 3f99bd3f315..bde7c318f44 100644
--- a/clippy_lints/src/uninit_vec.rs
+++ b/clippy_lints/src/uninit_vec.rs
@@ -2,6 +2,7 @@ use clippy_utils::diagnostics::{span_lint, span_lint_and_then};
 use clippy_utils::higher::{get_vec_init_kind, VecInitKind};
 use clippy_utils::ty::{is_type_diagnostic_item, is_uninit_value_valid_for_ty};
 use clippy_utils::{is_lint_allowed, path_to_local_id, peel_hir_expr_while, SpanlessEq};
+use rustc_ast::ast::LitKind;
 use rustc_hir::{Block, Expr, ExprKind, HirId, PatKind, PathSegment, Stmt, StmtKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::lint::in_external_macro;
@@ -211,9 +212,12 @@ fn extract_set_len_self<'tcx>(cx: &LateContext<'_>, expr: &'tcx Expr<'_>) -> Opt
         }
     });
     match expr.kind {
-        ExprKind::MethodCall(path, self_expr, [_], _) => {
+        ExprKind::MethodCall(path, self_expr, [arg], _) => {
             let self_type = cx.typeck_results().expr_ty(self_expr).peel_refs();
-            if is_type_diagnostic_item(cx, self_type, sym::Vec) && path.ident.name.as_str() == "set_len" {
+            if is_type_diagnostic_item(cx, self_type, sym::Vec)
+                && path.ident.name.as_str() == "set_len"
+                && !is_literal_zero(arg)
+            {
                 Some((self_expr, expr.span))
             } else {
                 None
@@ -222,3 +226,13 @@ fn extract_set_len_self<'tcx>(cx: &LateContext<'_>, expr: &'tcx Expr<'_>) -> Opt
         _ => None,
     }
 }
+
+fn is_literal_zero(arg: &Expr<'_>) -> bool {
+    if let ExprKind::Lit(lit) = &arg.kind
+        && let LitKind::Int(0, _) = lit.node
+    {
+        true
+    } else {
+        false
+    }
+}
diff --git a/tests/ui/uninit_vec.rs b/tests/ui/uninit_vec.rs
index dc150cf28f2..194e4fc157e 100644
--- a/tests/ui/uninit_vec.rs
+++ b/tests/ui/uninit_vec.rs
@@ -91,4 +91,10 @@ fn main() {
         vec1.set_len(200);
         vec2.set_len(200);
     }
+
+    // set_len(0) should not be detected
+    let mut vec: Vec<u8> = Vec::with_capacity(1000);
+    unsafe {
+        vec.set_len(0);
+    }
 }
-- 
cgit 1.4.1-3-g733a5


From e67b2bf732876eeb26e0d2fbc4b6c55e1a9f9317 Mon Sep 17 00:00:00 2001
From: Yuri Astrakhan <YuriAstrakhan@gmail.com>
Date: Fri, 23 Sep 2022 13:42:59 -0400
Subject: Apply uninlined_format-args to clippy_lints

This change is needed for the uninlined_format-args lint to be merged.
See https://github.com/rust-lang/rust-clippy/pull/9233
---
 clippy_lints/src/approx_const.rs                   |  4 +--
 clippy_lints/src/asm_syntax.rs                     |  2 +-
 clippy_lints/src/assertions_on_constants.rs        |  4 +--
 clippy_lints/src/assertions_on_result_states.rs    | 10 +++---
 clippy_lints/src/attrs.rs                          |  7 ++--
 clippy_lints/src/bool_assert_comparison.rs         |  4 +--
 clippy_lints/src/booleans.rs                       |  5 ++-
 clippy_lints/src/cargo/common_metadata.rs          |  2 +-
 clippy_lints/src/cargo/feature_name.rs             |  4 +--
 clippy_lints/src/cargo/mod.rs                      |  4 +--
 clippy_lints/src/cargo/multiple_crate_versions.rs  |  2 +-
 clippy_lints/src/casts/borrow_as_ptr.rs            |  2 +-
 clippy_lints/src/casts/cast_lossless.rs            | 12 ++-----
 clippy_lints/src/casts/cast_possible_truncation.rs | 16 +++------
 clippy_lints/src/casts/cast_possible_wrap.rs       |  5 +--
 clippy_lints/src/casts/cast_ptr_alignment.rs       |  4 +--
 clippy_lints/src/casts/cast_sign_loss.rs           |  5 +--
 .../src/casts/cast_slice_different_sizes.rs        |  4 +--
 clippy_lints/src/casts/char_lit_as_u8.rs           |  2 +-
 clippy_lints/src/casts/fn_to_numeric_cast.rs       |  4 +--
 clippy_lints/src/casts/fn_to_numeric_cast_any.rs   |  4 +--
 .../casts/fn_to_numeric_cast_with_truncation.rs    |  7 ++--
 clippy_lints/src/casts/ptr_as_ptr.rs               |  4 +--
 clippy_lints/src/casts/unnecessary_cast.rs         |  9 ++---
 clippy_lints/src/checked_conversions.rs            |  2 +-
 clippy_lints/src/cognitive_complexity.rs           |  3 +-
 clippy_lints/src/default.rs                        | 17 ++++-----
 clippy_lints/src/default_numeric_fallback.rs       |  4 +--
 clippy_lints/src/dereference.rs                    | 14 ++++----
 clippy_lints/src/disallowed_methods.rs             |  2 +-
 clippy_lints/src/disallowed_script_idents.rs       |  3 +-
 clippy_lints/src/disallowed_types.rs               |  4 +--
 clippy_lints/src/doc.rs                            |  2 +-
 clippy_lints/src/drop_forget_ref.rs                |  2 +-
 clippy_lints/src/entry.rs                          | 28 ++++-----------
 clippy_lints/src/enum_variants.rs                  |  7 ++--
 clippy_lints/src/equatable_if_let.rs               |  3 +-
 clippy_lints/src/eta_reduction.rs                  |  4 +--
 clippy_lints/src/exhaustive_items.rs               |  2 +-
 clippy_lints/src/explicit_write.rs                 |  8 ++---
 clippy_lints/src/float_literal.rs                  |  6 ++--
 clippy_lints/src/floating_point_arithmetic.rs      |  7 ++--
 clippy_lints/src/format.rs                         |  2 +-
 clippy_lints/src/format_args.rs                    | 17 ++++-----
 clippy_lints/src/format_impl.rs                    |  6 ++--
 clippy_lints/src/formatting.rs                     | 25 +++++---------
 clippy_lints/src/from_str_radix_10.rs              |  2 +-
 clippy_lints/src/functions/must_use.rs             |  2 +-
 clippy_lints/src/functions/too_many_arguments.rs   |  5 +--
 clippy_lints/src/functions/too_many_lines.rs       |  5 +--
 clippy_lints/src/if_then_some_else_none.rs         |  9 +++--
 clippy_lints/src/implicit_hasher.rs                |  7 ++--
 clippy_lints/src/implicit_return.rs                |  4 +--
 clippy_lints/src/implicit_saturating_sub.rs        |  2 +-
 .../src/inconsistent_struct_constructor.rs         |  6 ++--
 clippy_lints/src/index_refutable_slice.rs          |  4 +--
 clippy_lints/src/inherent_to_string.rs             | 12 +++----
 clippy_lints/src/inline_fn_without_body.rs         |  2 +-
 clippy_lints/src/int_plus_one.rs                   |  4 +--
 clippy_lints/src/iter_not_returning_iterator.rs    |  5 +--
 clippy_lints/src/len_zero.rs                       | 35 ++++++++-----------
 clippy_lints/src/let_if_seq.rs                     |  3 +-
 clippy_lints/src/lib.rs                            | 11 +++---
 clippy_lints/src/literal_representation.rs         |  2 +-
 clippy_lints/src/loops/explicit_counter_loop.rs    | 14 +++-----
 clippy_lints/src/loops/explicit_iter_loop.rs       |  2 +-
 clippy_lints/src/loops/for_kv_map.rs               |  4 +--
 clippy_lints/src/loops/manual_flatten.rs           |  2 +-
 clippy_lints/src/loops/manual_memcpy.rs            | 13 ++-----
 clippy_lints/src/loops/needless_collect.rs         |  6 ++--
 clippy_lints/src/loops/needless_range_loop.rs      | 10 +++---
 clippy_lints/src/loops/never_loop.rs               |  6 +---
 clippy_lints/src/loops/same_item_push.rs           |  5 +--
 clippy_lints/src/loops/utils.rs                    |  3 +-
 clippy_lints/src/loops/while_let_on_iterator.rs    |  2 +-
 clippy_lints/src/macro_use.rs                      |  6 ++--
 clippy_lints/src/manual_async_fn.rs                |  6 ++--
 clippy_lints/src/manual_non_exhaustive.rs          |  4 +--
 clippy_lints/src/manual_retain.rs                  | 14 +++-----
 clippy_lints/src/manual_strip.rs                   |  9 +++--
 clippy_lints/src/map_unit_fn.rs                    |  5 +--
 clippy_lints/src/match_result_ok.rs                |  6 ++--
 clippy_lints/src/matches/manual_map.rs             | 14 ++++----
 clippy_lints/src/matches/manual_unwrap_or.rs       |  6 ++--
 clippy_lints/src/matches/match_as_ref.rs           |  6 ++--
 clippy_lints/src/matches/match_like_matches.rs     |  5 ++-
 clippy_lints/src/matches/match_same_arms.rs        |  2 +-
 clippy_lints/src/matches/match_single_binding.rs   | 28 ++++++---------
 .../src/matches/match_str_case_mismatch.rs         |  4 +--
 clippy_lints/src/matches/match_wild_err_arm.rs     |  2 +-
 .../src/matches/redundant_pattern_match.rs         |  8 ++---
 .../src/matches/significant_drop_in_scrutinee.rs   |  6 ++--
 clippy_lints/src/matches/single_match.rs           |  6 ++--
 clippy_lints/src/matches/try_err.rs                |  4 +--
 clippy_lints/src/methods/bind_instead_of_map.rs    |  2 +-
 clippy_lints/src/methods/bytes_nth.rs              |  2 +-
 clippy_lints/src/methods/chars_cmp.rs              |  5 ++-
 clippy_lints/src/methods/chars_cmp_with_unwrap.rs  |  5 ++-
 clippy_lints/src/methods/clone_on_copy.rs          | 13 ++++---
 clippy_lints/src/methods/clone_on_ref_ptr.rs       |  2 +-
 clippy_lints/src/methods/expect_fun_call.rs        | 11 +++---
 clippy_lints/src/methods/filetype_is_file.rs       |  4 +--
 clippy_lints/src/methods/filter_map_next.rs        |  2 +-
 clippy_lints/src/methods/filter_next.rs            |  2 +-
 .../src/methods/from_iter_instead_of_collect.rs    |  6 ++--
 clippy_lints/src/methods/get_first.rs              |  4 +--
 clippy_lints/src/methods/get_unwrap.rs             | 11 ++----
 clippy_lints/src/methods/implicit_clone.rs         |  6 ++--
 clippy_lints/src/methods/inefficient_to_string.rs  |  7 ++--
 clippy_lints/src/methods/into_iter_on_ref.rs       |  3 +-
 clippy_lints/src/methods/is_digit_ascii_radix.rs   |  7 ++--
 clippy_lints/src/methods/iter_cloned_collect.rs    |  4 +--
 clippy_lints/src/methods/iter_count.rs             |  2 +-
 clippy_lints/src/methods/iter_kv_map.rs            |  8 ++---
 clippy_lints/src/methods/iter_next_slice.rs        |  2 +-
 clippy_lints/src/methods/iter_nth.rs               |  4 +--
 clippy_lints/src/methods/iter_with_drain.rs        |  2 +-
 clippy_lints/src/methods/manual_ok_or.rs           |  4 +--
 .../src/methods/manual_saturating_arithmetic.rs    |  5 ++-
 clippy_lints/src/methods/manual_str_repeat.rs      |  2 +-
 clippy_lints/src/methods/map_clone.rs              |  5 ++-
 clippy_lints/src/methods/map_flatten.rs            |  9 ++---
 clippy_lints/src/methods/map_identity.rs           |  2 +-
 clippy_lints/src/methods/map_unwrap_or.rs          |  2 +-
 clippy_lints/src/methods/option_as_ref_deref.rs    |  9 +++--
 clippy_lints/src/methods/option_map_or_none.rs     |  6 ++--
 clippy_lints/src/methods/option_map_unwrap_or.rs   |  9 +++--
 clippy_lints/src/methods/or_fun_call.rs            | 10 +++---
 clippy_lints/src/methods/search_is_some.rs         | 14 +++-----
 .../src/methods/single_char_insert_string.rs       |  2 +-
 .../src/methods/single_char_push_string.rs         |  2 +-
 clippy_lints/src/methods/stable_sort_primitive.rs  |  4 +--
 clippy_lints/src/methods/string_extend_chars.rs    |  3 +-
 clippy_lints/src/methods/suspicious_splitn.rs      |  4 +--
 clippy_lints/src/methods/suspicious_to_owned.rs    |  4 +--
 clippy_lints/src/methods/unnecessary_filter_map.rs |  2 +-
 clippy_lints/src/methods/unnecessary_fold.rs       |  7 ++--
 .../src/methods/unnecessary_iter_cloned.rs         |  2 +-
 clippy_lints/src/methods/unnecessary_lazy_eval.rs  |  4 +--
 clippy_lints/src/methods/unnecessary_to_owned.rs   | 21 ++++++------
 clippy_lints/src/methods/useless_asref.rs          |  2 +-
 clippy_lints/src/methods/wrong_self_convention.rs  | 15 ++++----
 clippy_lints/src/misc.rs                           | 18 ++++------
 clippy_lints/src/misc_early/literal_suffix.rs      |  8 ++---
 clippy_lints/src/misc_early/mod.rs                 |  5 ++-
 .../src/misc_early/unneeded_field_pattern.rs       |  4 +--
 clippy_lints/src/mismatching_type_param_order.rs   |  7 ++--
 clippy_lints/src/missing_doc.rs                    |  2 +-
 clippy_lints/src/missing_enforced_import_rename.rs |  4 +--
 clippy_lints/src/missing_inline.rs                 |  2 +-
 clippy_lints/src/mut_reference.rs                  |  2 +-
 clippy_lints/src/mutable_debug_assertion.rs        |  5 +--
 clippy_lints/src/mutex_atomic.rs                   |  5 ++-
 clippy_lints/src/needless_continue.rs              | 14 +++-----
 clippy_lints/src/needless_late_init.rs             | 10 +++---
 clippy_lints/src/needless_pass_by_value.rs         |  4 +--
 clippy_lints/src/needless_question_mark.rs         |  2 +-
 clippy_lints/src/neg_multiply.rs                   |  4 +--
 clippy_lints/src/new_without_default.rs            |  7 ++--
 clippy_lints/src/non_expressive_names.rs           |  5 +--
 clippy_lints/src/nonstandard_macro_braces.rs       | 12 +++----
 clippy_lints/src/octal_escapes.rs                  |  2 +-
 .../src/operators/absurd_extreme_comparisons.rs    |  5 ++-
 clippy_lints/src/operators/assign_op_pattern.rs    |  2 +-
 clippy_lints/src/operators/bit_mask.rs             | 40 +++++-----------------
 clippy_lints/src/operators/cmp_owned.rs            | 10 +++---
 clippy_lints/src/operators/duration_subsec.rs      |  7 ++--
 clippy_lints/src/operators/eq_op.rs                |  2 +-
 .../src/operators/misrefactored_assign_op.rs       | 12 +++----
 .../src/operators/needless_bitwise_bool.rs         |  2 +-
 clippy_lints/src/operators/ptr_eq.rs               |  2 +-
 clippy_lints/src/operators/self_assignment.rs      |  2 +-
 clippy_lints/src/operators/verbose_bit_mask.rs     |  2 +-
 clippy_lints/src/option_if_let_else.rs             |  2 +-
 clippy_lints/src/pass_by_ref_or_value.rs           |  4 +--
 clippy_lints/src/ptr.rs                            |  2 +-
 clippy_lints/src/ptr_offset_with_cast.rs           |  4 +--
 clippy_lints/src/question_mark.rs                  |  7 ++--
 clippy_lints/src/ranges.rs                         | 16 ++++-----
 clippy_lints/src/read_zero_byte_vec.rs             |  3 +-
 clippy_lints/src/redundant_pub_crate.rs            |  2 +-
 clippy_lints/src/redundant_slicing.rs              |  8 ++---
 clippy_lints/src/redundant_static_lifetimes.rs     |  2 +-
 clippy_lints/src/regex.rs                          |  4 +--
 clippy_lints/src/same_name_method.rs               |  4 +--
 clippy_lints/src/semicolon_if_nothing_returned.rs  |  2 +-
 clippy_lints/src/slow_vector_initialization.rs     |  2 +-
 clippy_lints/src/strings.rs                        |  6 ++--
 clippy_lints/src/strlen_on_c_strings.rs            |  2 +-
 clippy_lints/src/suspicious_operation_groupings.rs |  9 ++---
 clippy_lints/src/swap.rs                           | 19 +++++-----
 clippy_lints/src/swap_ptr_to_ref.rs                |  2 +-
 clippy_lints/src/to_digit_is_some.rs               |  4 +--
 clippy_lints/src/trait_bounds.rs                   |  3 +-
 .../src/transmute/crosspointer_transmute.rs        | 10 ++----
 .../src/transmute/transmute_float_to_int.rs        |  4 +--
 .../src/transmute/transmute_int_to_bool.rs         |  2 +-
 .../src/transmute/transmute_int_to_char.rs         |  4 +--
 .../src/transmute/transmute_int_to_float.rs        |  4 +--
 .../src/transmute/transmute_num_to_bytes.rs        |  4 +--
 clippy_lints/src/transmute/transmute_ptr_to_ref.rs | 18 ++++------
 clippy_lints/src/transmute/transmute_ref_to_ref.rs |  2 +-
 .../src/transmute/transmute_undefined_repr.rs      | 23 ++++++-------
 .../transmutes_expressible_as_ptr_casts.rs         |  5 +--
 .../src/transmute/unsound_collection_transmute.rs  |  5 +--
 clippy_lints/src/transmute/useless_transmute.rs    |  2 +-
 clippy_lints/src/transmute/wrong_transmute.rs      |  2 +-
 clippy_lints/src/types/borrowed_box.rs             |  6 ++--
 clippy_lints/src/types/box_collection.rs           |  2 +-
 clippy_lints/src/types/rc_buffer.rs                |  4 +--
 clippy_lints/src/types/redundant_allocation.rs     | 29 +++++-----------
 clippy_lints/src/unit_return_expecting_ord.rs      |  6 ++--
 clippy_lints/src/unit_types/unit_arg.rs            |  7 ++--
 clippy_lints/src/unit_types/unit_cmp.rs            |  7 ++--
 clippy_lints/src/unnecessary_self_imports.rs       |  2 +-
 clippy_lints/src/unnecessary_wraps.rs              |  7 ++--
 clippy_lints/src/unsafe_removed_from_name.rs       |  5 +--
 clippy_lints/src/unused_rounding.rs                |  4 +--
 clippy_lints/src/unwrap.rs                         |  7 ++--
 clippy_lints/src/upper_case_acronyms.rs            |  2 +-
 clippy_lints/src/useless_conversion.rs             | 10 +++---
 clippy_lints/src/utils/author.rs                   |  2 +-
 clippy_lints/src/utils/conf.rs                     |  9 ++---
 clippy_lints/src/wildcard_imports.rs               |  2 +-
 clippy_lints/src/zero_div_zero.rs                  |  3 +-
 225 files changed, 557 insertions(+), 842 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/approx_const.rs b/clippy_lints/src/approx_const.rs
index 159f3b0cd01..724490fb495 100644
--- a/clippy_lints/src/approx_const.rs
+++ b/clippy_lints/src/approx_const.rs
@@ -92,7 +92,7 @@ impl ApproxConstant {
                         cx,
                         APPROX_CONSTANT,
                         e.span,
-                        &format!("approximate value of `{}::consts::{}` found", module, &name),
+                        &format!("approximate value of `{module}::consts::{}` found", &name),
                         None,
                         "consider using the constant directly",
                     );
@@ -126,7 +126,7 @@ fn is_approx_const(constant: f64, value: &str, min_digits: usize) -> bool {
         // The value is a truncated constant
         true
     } else {
-        let round_const = format!("{:.*}", value.len() - 2, constant);
+        let round_const = format!("{constant:.*}", value.len() - 2);
         value == round_const
     }
 }
diff --git a/clippy_lints/src/asm_syntax.rs b/clippy_lints/src/asm_syntax.rs
index f419781dbc8..ad31d708f64 100644
--- a/clippy_lints/src/asm_syntax.rs
+++ b/clippy_lints/src/asm_syntax.rs
@@ -44,7 +44,7 @@ fn check_expr_asm_syntax(lint: &'static Lint, cx: &EarlyContext<'_>, expr: &Expr
                 cx,
                 lint,
                 expr.span,
-                &format!("{} x86 assembly syntax used", style),
+                &format!("{style} x86 assembly syntax used"),
                 None,
                 &format!("use {} x86 assembly syntax", !style),
             );
diff --git a/clippy_lints/src/assertions_on_constants.rs b/clippy_lints/src/assertions_on_constants.rs
index 2705ffffdcb..a36df55d0bd 100644
--- a/clippy_lints/src/assertions_on_constants.rs
+++ b/clippy_lints/src/assertions_on_constants.rs
@@ -60,9 +60,9 @@ impl<'tcx> LateLintPass<'tcx> for AssertionsOnConstants {
                 cx,
                 ASSERTIONS_ON_CONSTANTS,
                 macro_call.span,
-                &format!("`assert!(false{})` should probably be replaced", assert_arg),
+                &format!("`assert!(false{assert_arg})` should probably be replaced"),
                 None,
-                &format!("use `panic!({})` or `unreachable!({0})`", panic_arg),
+                &format!("use `panic!({panic_arg})` or `unreachable!({panic_arg})`"),
             );
         }
     }
diff --git a/clippy_lints/src/assertions_on_result_states.rs b/clippy_lints/src/assertions_on_result_states.rs
index 656dc5feeb5..f6d6c23bb6e 100644
--- a/clippy_lints/src/assertions_on_result_states.rs
+++ b/clippy_lints/src/assertions_on_result_states.rs
@@ -69,9 +69,8 @@ impl<'tcx> LateLintPass<'tcx> for AssertionsOnResultStates {
                         "called `assert!` with `Result::is_ok`",
                         "replace with",
                         format!(
-                            "{}.unwrap(){}",
-                            snippet_with_context(cx, recv.span, condition.span.ctxt(), "..", &mut app).0,
-                            semicolon
+                            "{}.unwrap(){semicolon}",
+                            snippet_with_context(cx, recv.span, condition.span.ctxt(), "..", &mut app).0
                         ),
                         app,
                     );
@@ -84,9 +83,8 @@ impl<'tcx> LateLintPass<'tcx> for AssertionsOnResultStates {
                         "called `assert!` with `Result::is_err`",
                         "replace with",
                         format!(
-                            "{}.unwrap_err(){}",
-                            snippet_with_context(cx, recv.span, condition.span.ctxt(), "..", &mut app).0,
-                            semicolon
+                            "{}.unwrap_err(){semicolon}",
+                            snippet_with_context(cx, recv.span, condition.span.ctxt(), "..", &mut app).0
                         ),
                         app,
                     );
diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs
index 732dc2b4330..5f45c69d7f9 100644
--- a/clippy_lints/src/attrs.rs
+++ b/clippy_lints/src/attrs.rs
@@ -541,10 +541,7 @@ fn check_attrs(cx: &LateContext<'_>, span: Span, name: Symbol, attrs: &[Attribut
                     cx,
                     INLINE_ALWAYS,
                     attr.span,
-                    &format!(
-                        "you have declared `#[inline(always)]` on `{}`. This is usually a bad idea",
-                        name
-                    ),
+                    &format!("you have declared `#[inline(always)]` on `{name}`. This is usually a bad idea"),
                 );
             }
         }
@@ -720,7 +717,7 @@ fn check_mismatched_target_os(cx: &EarlyContext<'_>, attr: &Attribute) {
                 let mut unix_suggested = false;
 
                 for (os, span) in mismatched {
-                    let sugg = format!("target_os = \"{}\"", os);
+                    let sugg = format!("target_os = \"{os}\"");
                     diag.span_suggestion(span, "try", sugg, Applicability::MaybeIncorrect);
 
                     if !unix_suggested && is_unix(os) {
diff --git a/clippy_lints/src/bool_assert_comparison.rs b/clippy_lints/src/bool_assert_comparison.rs
index 95abe8aa59f..4bd55c1429c 100644
--- a/clippy_lints/src/bool_assert_comparison.rs
+++ b/clippy_lints/src/bool_assert_comparison.rs
@@ -98,9 +98,9 @@ impl<'tcx> LateLintPass<'tcx> for BoolAssertComparison {
             cx,
             BOOL_ASSERT_COMPARISON,
             macro_call.span,
-            &format!("used `{}!` with a literal bool", macro_name),
+            &format!("used `{macro_name}!` with a literal bool"),
             "replace it with",
-            format!("{}!(..)", non_eq_mac),
+            format!("{non_eq_mac}!(..)"),
             Applicability::MaybeIncorrect,
         );
     }
diff --git a/clippy_lints/src/booleans.rs b/clippy_lints/src/booleans.rs
index 03d262d5a59..2a15cbc7a3c 100644
--- a/clippy_lints/src/booleans.rs
+++ b/clippy_lints/src/booleans.rs
@@ -263,9 +263,8 @@ fn simplify_not(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<String> {
             }
             .and_then(|op| {
                 Some(format!(
-                    "{}{}{}",
+                    "{}{op}{}",
                     snippet_opt(cx, lhs.span)?,
-                    op,
                     snippet_opt(cx, rhs.span)?
                 ))
             })
@@ -285,7 +284,7 @@ fn simplify_not(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<String> {
                     let path: &str = path.ident.name.as_str();
                     a == path
                 })
-                .and_then(|(_, neg_method)| Some(format!("{}.{}()", snippet_opt(cx, receiver.span)?, neg_method)))
+                .and_then(|(_, neg_method)| Some(format!("{}.{neg_method}()", snippet_opt(cx, receiver.span)?)))
         },
         _ => None,
     }
diff --git a/clippy_lints/src/cargo/common_metadata.rs b/clippy_lints/src/cargo/common_metadata.rs
index e0442dda479..805121bcced 100644
--- a/clippy_lints/src/cargo/common_metadata.rs
+++ b/clippy_lints/src/cargo/common_metadata.rs
@@ -40,7 +40,7 @@ pub(super) fn check(cx: &LateContext<'_>, metadata: &Metadata, ignore_publish: b
 }
 
 fn missing_warning(cx: &LateContext<'_>, package: &cargo_metadata::Package, field: &str) {
-    let message = format!("package `{}` is missing `{}` metadata", package.name, field);
+    let message = format!("package `{}` is missing `{field}` metadata", package.name);
     span_lint(cx, CARGO_COMMON_METADATA, DUMMY_SP, &message);
 }
 
diff --git a/clippy_lints/src/cargo/feature_name.rs b/clippy_lints/src/cargo/feature_name.rs
index 79a469a4258..37c169dbd95 100644
--- a/clippy_lints/src/cargo/feature_name.rs
+++ b/clippy_lints/src/cargo/feature_name.rs
@@ -57,10 +57,8 @@ fn lint(cx: &LateContext<'_>, feature: &str, substring: &str, is_prefix: bool) {
         },
         DUMMY_SP,
         &format!(
-            "the \"{}\" {} in the feature name \"{}\" is {}",
-            substring,
+            "the \"{substring}\" {} in the feature name \"{feature}\" is {}",
             if is_prefix { "prefix" } else { "suffix" },
-            feature,
             if is_negative { "negative" } else { "redundant" }
         ),
         None,
diff --git a/clippy_lints/src/cargo/mod.rs b/clippy_lints/src/cargo/mod.rs
index 9f45db86a09..3a872e54c9a 100644
--- a/clippy_lints/src/cargo/mod.rs
+++ b/clippy_lints/src/cargo/mod.rs
@@ -196,7 +196,7 @@ impl LateLintPass<'_> for Cargo {
                 },
                 Err(e) => {
                     for lint in NO_DEPS_LINTS {
-                        span_lint(cx, lint, DUMMY_SP, &format!("could not read cargo metadata: {}", e));
+                        span_lint(cx, lint, DUMMY_SP, &format!("could not read cargo metadata: {e}"));
                     }
                 },
             }
@@ -212,7 +212,7 @@ impl LateLintPass<'_> for Cargo {
                 },
                 Err(e) => {
                     for lint in WITH_DEPS_LINTS {
-                        span_lint(cx, lint, DUMMY_SP, &format!("could not read cargo metadata: {}", e));
+                        span_lint(cx, lint, DUMMY_SP, &format!("could not read cargo metadata: {e}"));
                     }
                 },
             }
diff --git a/clippy_lints/src/cargo/multiple_crate_versions.rs b/clippy_lints/src/cargo/multiple_crate_versions.rs
index 76fd0819a39..f9b17d45e9f 100644
--- a/clippy_lints/src/cargo/multiple_crate_versions.rs
+++ b/clippy_lints/src/cargo/multiple_crate_versions.rs
@@ -37,7 +37,7 @@ pub(super) fn check(cx: &LateContext<'_>, metadata: &Metadata) {
                         cx,
                         MULTIPLE_CRATE_VERSIONS,
                         DUMMY_SP,
-                        &format!("multiple versions for dependency `{}`: {}", name, versions),
+                        &format!("multiple versions for dependency `{name}`: {versions}"),
                     );
                 }
             }
diff --git a/clippy_lints/src/casts/borrow_as_ptr.rs b/clippy_lints/src/casts/borrow_as_ptr.rs
index 6e1f8cd64f0..294d22d34de 100644
--- a/clippy_lints/src/casts/borrow_as_ptr.rs
+++ b/clippy_lints/src/casts/borrow_as_ptr.rs
@@ -30,7 +30,7 @@ pub(super) fn check<'tcx>(
             expr.span,
             "borrow as raw pointer",
             "try",
-            format!("{}::ptr::{}!({})", core_or_std, macro_name, snip),
+            format!("{core_or_std}::ptr::{macro_name}!({snip})"),
             Applicability::MachineApplicable,
         );
     }
diff --git a/clippy_lints/src/casts/cast_lossless.rs b/clippy_lints/src/casts/cast_lossless.rs
index 938458e30ca..13c403234da 100644
--- a/clippy_lints/src/casts/cast_lossless.rs
+++ b/clippy_lints/src/casts/cast_lossless.rs
@@ -41,15 +41,9 @@ pub(super) fn check(
     );
 
     let message = if cast_from.is_bool() {
-        format!(
-            "casting `{0:}` to `{1:}` is more cleanly stated with `{1:}::from(_)`",
-            cast_from, cast_to
-        )
+        format!("casting `{cast_from:}` to `{cast_to:}` is more cleanly stated with `{cast_to:}::from(_)`")
     } else {
-        format!(
-            "casting `{}` to `{}` may become silently lossy if you later change the type",
-            cast_from, cast_to
-        )
+        format!("casting `{cast_from}` to `{cast_to}` may become silently lossy if you later change the type")
     };
 
     span_lint_and_sugg(
@@ -58,7 +52,7 @@ pub(super) fn check(
         expr.span,
         &message,
         "try",
-        format!("{}::from({})", cast_to, sugg),
+        format!("{cast_to}::from({sugg})"),
         applicability,
     );
 }
diff --git a/clippy_lints/src/casts/cast_possible_truncation.rs b/clippy_lints/src/casts/cast_possible_truncation.rs
index 406547a4454..88deb4565eb 100644
--- a/clippy_lints/src/casts/cast_possible_truncation.rs
+++ b/clippy_lints/src/casts/cast_possible_truncation.rs
@@ -103,10 +103,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_expr: &Expr<'_>,
                 return;
             }
 
-            format!(
-                "casting `{}` to `{}` may truncate the value{}",
-                cast_from, cast_to, suffix,
-            )
+            format!("casting `{cast_from}` to `{cast_to}` may truncate the value{suffix}",)
         },
 
         (ty::Adt(def, _), true) if def.is_enum() => {
@@ -142,20 +139,17 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_expr: &Expr<'_>,
                     CAST_ENUM_TRUNCATION,
                     expr.span,
                     &format!(
-                        "casting `{}::{}` to `{}` will truncate the value{}",
-                        cast_from, variant.name, cast_to, suffix,
+                        "casting `{cast_from}::{}` to `{cast_to}` will truncate the value{suffix}",
+                        variant.name,
                     ),
                 );
                 return;
             }
-            format!(
-                "casting `{}` to `{}` may truncate the value{}",
-                cast_from, cast_to, suffix,
-            )
+            format!("casting `{cast_from}` to `{cast_to}` may truncate the value{suffix}",)
         },
 
         (ty::Float(_), true) => {
-            format!("casting `{}` to `{}` may truncate the value", cast_from, cast_to)
+            format!("casting `{cast_from}` to `{cast_to}` may truncate the value")
         },
 
         (ty::Float(FloatTy::F64), false) if matches!(cast_to.kind(), &ty::Float(FloatTy::F32)) => {
diff --git a/clippy_lints/src/casts/cast_possible_wrap.rs b/clippy_lints/src/casts/cast_possible_wrap.rs
index 2c5c1d7cb46..28ecdea7ea0 100644
--- a/clippy_lints/src/casts/cast_possible_wrap.rs
+++ b/clippy_lints/src/casts/cast_possible_wrap.rs
@@ -35,10 +35,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_from: Ty<'_>, ca
             cx,
             CAST_POSSIBLE_WRAP,
             expr.span,
-            &format!(
-                "casting `{}` to `{}` may wrap around the value{}",
-                cast_from, cast_to, suffix,
-            ),
+            &format!("casting `{cast_from}` to `{cast_to}` may wrap around the value{suffix}",),
         );
     }
 }
diff --git a/clippy_lints/src/casts/cast_ptr_alignment.rs b/clippy_lints/src/casts/cast_ptr_alignment.rs
index da7b12f6726..97054a0d101 100644
--- a/clippy_lints/src/casts/cast_ptr_alignment.rs
+++ b/clippy_lints/src/casts/cast_ptr_alignment.rs
@@ -49,9 +49,7 @@ fn lint_cast_ptr_alignment<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, cast_f
             CAST_PTR_ALIGNMENT,
             expr.span,
             &format!(
-                "casting from `{}` to a more-strictly-aligned pointer (`{}`) ({} < {} bytes)",
-                cast_from,
-                cast_to,
+                "casting from `{cast_from}` to a more-strictly-aligned pointer (`{cast_to}`) ({} < {} bytes)",
                 from_layout.align.abi.bytes(),
                 to_layout.align.abi.bytes(),
             ),
diff --git a/clippy_lints/src/casts/cast_sign_loss.rs b/clippy_lints/src/casts/cast_sign_loss.rs
index 5b59350be04..a20a97d4e56 100644
--- a/clippy_lints/src/casts/cast_sign_loss.rs
+++ b/clippy_lints/src/casts/cast_sign_loss.rs
@@ -14,10 +14,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_op: &Expr<'_>, c
             cx,
             CAST_SIGN_LOSS,
             expr.span,
-            &format!(
-                "casting `{}` to `{}` may lose the sign of the value",
-                cast_from, cast_to
-            ),
+            &format!("casting `{cast_from}` to `{cast_to}` may lose the sign of the value"),
         );
     }
 }
diff --git a/clippy_lints/src/casts/cast_slice_different_sizes.rs b/clippy_lints/src/casts/cast_slice_different_sizes.rs
index 027c660ce3b..d31d10d22b9 100644
--- a/clippy_lints/src/casts/cast_slice_different_sizes.rs
+++ b/clippy_lints/src/casts/cast_slice_different_sizes.rs
@@ -35,8 +35,8 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>, msrv: Optio
                     CAST_SLICE_DIFFERENT_SIZES,
                     expr.span,
                     &format!(
-                        "casting between raw pointers to `[{}]` (element size {}) and `[{}]` (element size {}) does not adjust the count",
-                        start_ty.ty, from_size, end_ty.ty, to_size,
+                        "casting between raw pointers to `[{}]` (element size {from_size}) and `[{}]` (element size {to_size}) does not adjust the count",
+                        start_ty.ty, end_ty.ty,
                     ),
                     |diag| {
                         let ptr_snippet = source::snippet(cx, left_cast.span, "..");
diff --git a/clippy_lints/src/casts/char_lit_as_u8.rs b/clippy_lints/src/casts/char_lit_as_u8.rs
index 7cc406018db..82e07c98a7e 100644
--- a/clippy_lints/src/casts/char_lit_as_u8.rs
+++ b/clippy_lints/src/casts/char_lit_as_u8.rs
@@ -31,7 +31,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>) {
                         diag.span_suggestion(
                             expr.span,
                             "use a byte literal instead",
-                            format!("b{}", snippet),
+                            format!("b{snippet}"),
                             applicability,
                         );
                     }
diff --git a/clippy_lints/src/casts/fn_to_numeric_cast.rs b/clippy_lints/src/casts/fn_to_numeric_cast.rs
index 35350d8a25b..a26bfab4e7c 100644
--- a/clippy_lints/src/casts/fn_to_numeric_cast.rs
+++ b/clippy_lints/src/casts/fn_to_numeric_cast.rs
@@ -25,9 +25,9 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_expr: &Expr<'_>,
                     cx,
                     FN_TO_NUMERIC_CAST,
                     expr.span,
-                    &format!("casting function pointer `{}` to `{}`", from_snippet, cast_to),
+                    &format!("casting function pointer `{from_snippet}` to `{cast_to}`"),
                     "try",
-                    format!("{} as usize", from_snippet),
+                    format!("{from_snippet} as usize"),
                     applicability,
                 );
             }
diff --git a/clippy_lints/src/casts/fn_to_numeric_cast_any.rs b/clippy_lints/src/casts/fn_to_numeric_cast_any.rs
index 03621887a34..75654129408 100644
--- a/clippy_lints/src/casts/fn_to_numeric_cast_any.rs
+++ b/clippy_lints/src/casts/fn_to_numeric_cast_any.rs
@@ -23,9 +23,9 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_expr: &Expr<'_>,
                 cx,
                 FN_TO_NUMERIC_CAST_ANY,
                 expr.span,
-                &format!("casting function pointer `{}` to `{}`", from_snippet, cast_to),
+                &format!("casting function pointer `{from_snippet}` to `{cast_to}`"),
                 "did you mean to invoke the function?",
-                format!("{}() as {}", from_snippet, cast_to),
+                format!("{from_snippet}() as {cast_to}"),
                 applicability,
             );
         },
diff --git a/clippy_lints/src/casts/fn_to_numeric_cast_with_truncation.rs b/clippy_lints/src/casts/fn_to_numeric_cast_with_truncation.rs
index 6287f479b5b..556be1d1506 100644
--- a/clippy_lints/src/casts/fn_to_numeric_cast_with_truncation.rs
+++ b/clippy_lints/src/casts/fn_to_numeric_cast_with_truncation.rs
@@ -24,12 +24,9 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_expr: &Expr<'_>,
                     cx,
                     FN_TO_NUMERIC_CAST_WITH_TRUNCATION,
                     expr.span,
-                    &format!(
-                        "casting function pointer `{}` to `{}`, which truncates the value",
-                        from_snippet, cast_to
-                    ),
+                    &format!("casting function pointer `{from_snippet}` to `{cast_to}`, which truncates the value"),
                     "try",
-                    format!("{} as usize", from_snippet),
+                    format!("{from_snippet} as usize"),
                     applicability,
                 );
             }
diff --git a/clippy_lints/src/casts/ptr_as_ptr.rs b/clippy_lints/src/casts/ptr_as_ptr.rs
index 46d45d09661..c2b9253ec35 100644
--- a/clippy_lints/src/casts/ptr_as_ptr.rs
+++ b/clippy_lints/src/casts/ptr_as_ptr.rs
@@ -33,7 +33,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, msrv: Option<RustcVer
             let turbofish = match &cast_to_hir_ty.kind {
                     TyKind::Infer => Cow::Borrowed(""),
                     TyKind::Ptr(mut_ty) if matches!(mut_ty.ty.kind, TyKind::Infer) => Cow::Borrowed(""),
-                    _ => Cow::Owned(format!("::<{}>", to_pointee_ty)),
+                    _ => Cow::Owned(format!("::<{to_pointee_ty}>")),
                 };
             span_lint_and_sugg(
                 cx,
@@ -41,7 +41,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, msrv: Option<RustcVer
                 expr.span,
                 "`as` casting between raw pointers without changing its mutability",
                 "try `pointer::cast`, a safer alternative",
-                format!("{}.cast{}()", cast_expr_sugg.maybe_par(), turbofish),
+                format!("{}.cast{turbofish}()", cast_expr_sugg.maybe_par()),
                 applicability,
             );
         }
diff --git a/clippy_lints/src/casts/unnecessary_cast.rs b/clippy_lints/src/casts/unnecessary_cast.rs
index 19d2e6e1d12..ea29f5d12c6 100644
--- a/clippy_lints/src/casts/unnecessary_cast.rs
+++ b/clippy_lints/src/casts/unnecessary_cast.rs
@@ -71,10 +71,7 @@ pub(super) fn check<'tcx>(
                         cx,
                         UNNECESSARY_CAST,
                         expr.span,
-                        &format!(
-                            "casting to the same type is unnecessary (`{}` -> `{}`)",
-                            cast_from, cast_to
-                        ),
+                        &format!("casting to the same type is unnecessary (`{cast_from}` -> `{cast_to}`)"),
                         "try",
                         literal_str,
                         Applicability::MachineApplicable,
@@ -101,9 +98,9 @@ fn lint_unnecessary_cast(cx: &LateContext<'_>, expr: &Expr<'_>, literal_str: &st
         cx,
         UNNECESSARY_CAST,
         expr.span,
-        &format!("casting {} literal to `{}` is unnecessary", literal_kind_name, cast_to),
+        &format!("casting {literal_kind_name} literal to `{cast_to}` is unnecessary"),
         "try",
-        format!("{}_{}", matchless.trim_end_matches('.'), cast_to),
+        format!("{}_{cast_to}", matchless.trim_end_matches('.')),
         Applicability::MachineApplicable,
     );
 }
diff --git a/clippy_lints/src/checked_conversions.rs b/clippy_lints/src/checked_conversions.rs
index 37b2fdcff09..1d113c7cbee 100644
--- a/clippy_lints/src/checked_conversions.rs
+++ b/clippy_lints/src/checked_conversions.rs
@@ -82,7 +82,7 @@ impl<'tcx> LateLintPass<'tcx> for CheckedConversions {
                     item.span,
                     "checked cast can be simplified",
                     "try",
-                    format!("{}::try_from({}).is_ok()", to_type, snippet),
+                    format!("{to_type}::try_from({snippet}).is_ok()"),
                     applicability,
                 );
             }
diff --git a/clippy_lints/src/cognitive_complexity.rs b/clippy_lints/src/cognitive_complexity.rs
index 33c44f8b2db..fed04ae7f3d 100644
--- a/clippy_lints/src/cognitive_complexity.rs
+++ b/clippy_lints/src/cognitive_complexity.rs
@@ -107,8 +107,7 @@ impl CognitiveComplexity {
                 COGNITIVE_COMPLEXITY,
                 fn_span,
                 &format!(
-                    "the function has a cognitive complexity of ({}/{})",
-                    rust_cc,
+                    "the function has a cognitive complexity of ({rust_cc}/{})",
                     self.limit.limit()
                 ),
                 None,
diff --git a/clippy_lints/src/default.rs b/clippy_lints/src/default.rs
index 74f7df61177..cb6800c8ba2 100644
--- a/clippy_lints/src/default.rs
+++ b/clippy_lints/src/default.rs
@@ -105,7 +105,7 @@ impl<'tcx> LateLintPass<'tcx> for Default {
                     cx,
                     DEFAULT_TRAIT_ACCESS,
                     expr.span,
-                    &format!("calling `{}` is more clear than this expression", replacement),
+                    &format!("calling `{replacement}` is more clear than this expression"),
                     "try",
                     replacement,
                     Applicability::Unspecified, // First resolve the TODO above
@@ -210,7 +210,7 @@ impl<'tcx> LateLintPass<'tcx> for Default {
                     .map(|(field, rhs)| {
                         // extract and store the assigned value for help message
                         let value_snippet = snippet_with_macro_callsite(cx, rhs.span, "..");
-                        format!("{}: {}", field, value_snippet)
+                        format!("{field}: {value_snippet}")
                     })
                     .collect::<Vec<String>>()
                     .join(", ");
@@ -227,7 +227,7 @@ impl<'tcx> LateLintPass<'tcx> for Default {
                             .map(ToString::to_string)
                             .collect::<Vec<_>>()
                             .join(", ");
-                        format!("{}::<{}>", adt_def_ty_name, &tys_str)
+                        format!("{adt_def_ty_name}::<{}>", &tys_str)
                     } else {
                         binding_type.to_string()
                     }
@@ -235,12 +235,12 @@ impl<'tcx> LateLintPass<'tcx> for Default {
 
                 let sugg = if ext_with_default {
                     if field_list.is_empty() {
-                        format!("{}::default()", binding_type)
+                        format!("{binding_type}::default()")
                     } else {
-                        format!("{} {{ {}, ..Default::default() }}", binding_type, field_list)
+                        format!("{binding_type} {{ {field_list}, ..Default::default() }}")
                     }
                 } else {
-                    format!("{} {{ {} }}", binding_type, field_list)
+                    format!("{binding_type} {{ {field_list} }}")
                 };
 
                 // span lint once per statement that binds default
@@ -250,10 +250,7 @@ impl<'tcx> LateLintPass<'tcx> for Default {
                     first_assign.unwrap().span,
                     "field assignment outside of initializer for an instance created with Default::default()",
                     Some(local.span),
-                    &format!(
-                        "consider initializing the variable with `{}` and removing relevant reassignments",
-                        sugg
-                    ),
+                    &format!("consider initializing the variable with `{sugg}` and removing relevant reassignments"),
                 );
                 self.reassigned_linted.insert(span);
             }
diff --git a/clippy_lints/src/default_numeric_fallback.rs b/clippy_lints/src/default_numeric_fallback.rs
index be02f328e98..3ed9cd36a22 100644
--- a/clippy_lints/src/default_numeric_fallback.rs
+++ b/clippy_lints/src/default_numeric_fallback.rs
@@ -95,8 +95,8 @@ impl<'a, 'tcx> NumericFallbackVisitor<'a, 'tcx> {
                         src
                     } else {
                         match lit.node {
-                            LitKind::Int(src, _) => format!("{}", src),
-                            LitKind::Float(src, _) => format!("{}", src),
+                            LitKind::Int(src, _) => format!("{src}"),
+                            LitKind::Float(src, _) => format!("{src}"),
                             _ => return,
                         }
                     };
diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index b965d27afce..e272283152d 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -1308,7 +1308,7 @@ fn report<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, state: State, data
             };
 
             let expr_str = if !expr_is_macro_call && is_final_ufcs && expr.precedence().order() < PREC_PREFIX {
-                format!("({})", expr_str)
+                format!("({expr_str})")
             } else {
                 expr_str.into_owned()
             };
@@ -1322,7 +1322,7 @@ fn report<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, state: State, data
                     Mutability::Mut => "explicit `deref_mut` method call",
                 },
                 "try this",
-                format!("{}{}{}", addr_of_str, deref_str, expr_str),
+                format!("{addr_of_str}{deref_str}{expr_str}"),
                 app,
             );
         },
@@ -1336,7 +1336,7 @@ fn report<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, state: State, data
                     && !has_enclosing_paren(&snip)
                     && (expr.precedence().order() < data.position.precedence() || calls_field)
                 {
-                    format!("({})", snip)
+                    format!("({snip})")
                 } else {
                     snip.into()
                 };
@@ -1379,9 +1379,9 @@ fn report<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, state: State, data
                     let (snip, snip_is_macro) = snippet_with_context(cx, expr.span, data.span.ctxt(), "..", &mut app);
                     let sugg =
                         if !snip_is_macro && expr.precedence().order() < precedence && !has_enclosing_paren(&snip) {
-                            format!("{}({})", prefix, snip)
+                            format!("{prefix}({snip})")
                         } else {
-                            format!("{}{}", prefix, snip)
+                            format!("{prefix}{snip}")
                         };
                     diag.span_suggestion(data.span, "try this", sugg, app);
                 },
@@ -1460,14 +1460,14 @@ impl Dereferencing {
                             } else {
                                 pat.always_deref = false;
                                 let snip = snippet_with_context(cx, e.span, parent.span.ctxt(), "..", &mut pat.app).0;
-                                pat.replacements.push((e.span, format!("&{}", snip)));
+                                pat.replacements.push((e.span, format!("&{snip}")));
                             }
                         },
                         _ if !e.span.from_expansion() => {
                             // Double reference might be needed at this point.
                             pat.always_deref = false;
                             let snip = snippet_with_applicability(cx, e.span, "..", &mut pat.app);
-                            pat.replacements.push((e.span, format!("&{}", snip)));
+                            pat.replacements.push((e.span, format!("&{snip}")));
                         },
                         // Edge case for macros. The span of the identifier will usually match the context of the
                         // binding, but not if the identifier was created in a macro. e.g. `concat_idents` and proc
diff --git a/clippy_lints/src/disallowed_methods.rs b/clippy_lints/src/disallowed_methods.rs
index 53973ab792a..b02f87c07db 100644
--- a/clippy_lints/src/disallowed_methods.rs
+++ b/clippy_lints/src/disallowed_methods.rs
@@ -106,7 +106,7 @@ impl<'tcx> LateLintPass<'tcx> for DisallowedMethods {
                 reason: Some(reason), ..
             } = conf
             {
-                diag.note(&format!("{} (from clippy.toml)", reason));
+                diag.note(&format!("{reason} (from clippy.toml)"));
             }
         });
     }
diff --git a/clippy_lints/src/disallowed_script_idents.rs b/clippy_lints/src/disallowed_script_idents.rs
index 0c27c3f9255..084190f0013 100644
--- a/clippy_lints/src/disallowed_script_idents.rs
+++ b/clippy_lints/src/disallowed_script_idents.rs
@@ -99,8 +99,7 @@ impl EarlyLintPass for DisallowedScriptIdents {
                         DISALLOWED_SCRIPT_IDENTS,
                         span,
                         &format!(
-                            "identifier `{}` has a Unicode script that is not allowed by configuration: {}",
-                            symbol_str,
+                            "identifier `{symbol_str}` has a Unicode script that is not allowed by configuration: {}",
                             script.full_name()
                         ),
                     );
diff --git a/clippy_lints/src/disallowed_types.rs b/clippy_lints/src/disallowed_types.rs
index 14f89edce61..53451238d9a 100644
--- a/clippy_lints/src/disallowed_types.rs
+++ b/clippy_lints/src/disallowed_types.rs
@@ -92,7 +92,7 @@ impl<'tcx> LateLintPass<'tcx> for DisallowedTypes {
                 conf::DisallowedType::Simple(path) => (path, None),
                 conf::DisallowedType::WithReason { path, reason } => (
                     path,
-                    reason.as_ref().map(|reason| format!("{} (from clippy.toml)", reason)),
+                    reason.as_ref().map(|reason| format!("{reason} (from clippy.toml)")),
                 ),
             };
             let segs: Vec<_> = path.split("::").collect();
@@ -130,7 +130,7 @@ fn emit(cx: &LateContext<'_>, name: &str, span: Span, reason: Option<&str>) {
         cx,
         DISALLOWED_TYPES,
         span,
-        &format!("`{}` is not allowed according to config", name),
+        &format!("`{name}` is not allowed according to config"),
         |diag| {
             if let Some(reason) = reason {
                 diag.note(reason);
diff --git a/clippy_lints/src/doc.rs b/clippy_lints/src/doc.rs
index eb158d850fa..fa50a2d1a2c 100644
--- a/clippy_lints/src/doc.rs
+++ b/clippy_lints/src/doc.rs
@@ -790,7 +790,7 @@ fn check_word(cx: &LateContext<'_>, word: &str, span: Span) {
                 diag.span_suggestion_with_style(
                     span,
                     "try",
-                    format!("`{}`", snippet),
+                    format!("`{snippet}`"),
                     applicability,
                     // always show the suggestion in a separate line, since the
                     // inline presentation adds another pair of backticks
diff --git a/clippy_lints/src/drop_forget_ref.rs b/clippy_lints/src/drop_forget_ref.rs
index b35f0b8ca52..0ee07fbcc75 100644
--- a/clippy_lints/src/drop_forget_ref.rs
+++ b/clippy_lints/src/drop_forget_ref.rs
@@ -236,7 +236,7 @@ impl<'tcx> LateLintPass<'tcx> for DropForgetRef {
                 expr.span,
                 msg,
                 Some(arg.span),
-                &format!("argument has type `{}`", arg_ty),
+                &format!("argument has type `{arg_ty}`"),
             );
         }
     }
diff --git a/clippy_lints/src/entry.rs b/clippy_lints/src/entry.rs
index e70df3f53c7..9c834cf0144 100644
--- a/clippy_lints/src/entry.rs
+++ b/clippy_lints/src/entry.rs
@@ -113,13 +113,8 @@ impl<'tcx> LateLintPass<'tcx> for HashMapPass {
                     ),
                 };
                 format!(
-                    "if let {}::{} = {}.entry({}) {} else {}",
+                    "if let {}::{entry_kind} = {map_str}.entry({key_str}) {then_str} else {else_str}",
                     map_ty.entry_path(),
-                    entry_kind,
-                    map_str,
-                    key_str,
-                    then_str,
-                    else_str,
                 )
             } else {
                 // if .. { insert } else { insert }
@@ -137,16 +132,11 @@ impl<'tcx> LateLintPass<'tcx> for HashMapPass {
                 let indent_str = snippet_indent(cx, expr.span);
                 let indent_str = indent_str.as_deref().unwrap_or("");
                 format!(
-                    "match {}.entry({}) {{\n{indent}    {entry}::{} => {}\n\
-                        {indent}    {entry}::{} => {}\n{indent}}}",
-                    map_str,
-                    key_str,
-                    then_entry,
+                    "match {map_str}.entry({key_str}) {{\n{indent_str}    {entry}::{then_entry} => {}\n\
+                        {indent_str}    {entry}::{else_entry} => {}\n{indent_str}}}",
                     reindent_multiline(then_str.into(), true, Some(4 + indent_str.len())),
-                    else_entry,
                     reindent_multiline(else_str.into(), true, Some(4 + indent_str.len())),
                     entry = map_ty.entry_path(),
-                    indent = indent_str,
                 )
             }
         } else {
@@ -163,20 +153,16 @@ impl<'tcx> LateLintPass<'tcx> for HashMapPass {
                     then_search.snippet_occupied(cx, then_expr.span, &mut app)
                 };
                 format!(
-                    "if let {}::{} = {}.entry({}) {}",
+                    "if let {}::{entry_kind} = {map_str}.entry({key_str}) {body_str}",
                     map_ty.entry_path(),
-                    entry_kind,
-                    map_str,
-                    key_str,
-                    body_str,
                 )
             } else if let Some(insertion) = then_search.as_single_insertion() {
                 let value_str = snippet_with_context(cx, insertion.value.span, then_expr.span.ctxt(), "..", &mut app).0;
                 if contains_expr.negated {
                     if insertion.value.can_have_side_effects() {
-                        format!("{}.entry({}).or_insert_with(|| {});", map_str, key_str, value_str)
+                        format!("{map_str}.entry({key_str}).or_insert_with(|| {value_str});")
                     } else {
-                        format!("{}.entry({}).or_insert({});", map_str, key_str, value_str)
+                        format!("{map_str}.entry({key_str}).or_insert({value_str});")
                     }
                 } else {
                     // TODO: suggest using `if let Some(v) = map.get_mut(k) { .. }` here.
@@ -186,7 +172,7 @@ impl<'tcx> LateLintPass<'tcx> for HashMapPass {
             } else {
                 let block_str = then_search.snippet_closure(cx, then_expr.span, &mut app);
                 if contains_expr.negated {
-                    format!("{}.entry({}).or_insert_with(|| {});", map_str, key_str, block_str)
+                    format!("{map_str}.entry({key_str}).or_insert_with(|| {block_str});")
                 } else {
                     // TODO: suggest using `if let Some(v) = map.get_mut(k) { .. }` here.
                     // This would need to be a different lint.
diff --git a/clippy_lints/src/enum_variants.rs b/clippy_lints/src/enum_variants.rs
index cd36f9fcd72..d8c6b4e39ae 100644
--- a/clippy_lints/src/enum_variants.rs
+++ b/clippy_lints/src/enum_variants.rs
@@ -202,12 +202,11 @@ fn check_variant(cx: &LateContext<'_>, threshold: u64, def: &EnumDef<'_>, item_n
         cx,
         ENUM_VARIANT_NAMES,
         span,
-        &format!("all variants have the same {}fix: `{}`", what, value),
+        &format!("all variants have the same {what}fix: `{value}`"),
         None,
         &format!(
-            "remove the {}fixes and use full paths to \
-             the variants instead of glob imports",
-            what
+            "remove the {what}fixes and use full paths to \
+             the variants instead of glob imports"
         ),
     );
 }
diff --git a/clippy_lints/src/equatable_if_let.rs b/clippy_lints/src/equatable_if_let.rs
index fdfb821ac78..7917d83c0b9 100644
--- a/clippy_lints/src/equatable_if_let.rs
+++ b/clippy_lints/src/equatable_if_let.rs
@@ -91,9 +91,8 @@ impl<'tcx> LateLintPass<'tcx> for PatternEquality {
                     "this pattern matching can be expressed using equality",
                     "try",
                     format!(
-                        "{} == {}",
+                        "{} == {pat_str}",
                         snippet_with_context(cx, let_expr.init.span, expr.span.ctxt(), "..", &mut applicability).0,
-                        pat_str,
                     ),
                     applicability,
                 );
diff --git a/clippy_lints/src/eta_reduction.rs b/clippy_lints/src/eta_reduction.rs
index 53bc617a4f5..0f9f94a6b54 100644
--- a/clippy_lints/src/eta_reduction.rs
+++ b/clippy_lints/src/eta_reduction.rs
@@ -130,7 +130,7 @@ impl<'tcx> LateLintPass<'tcx> for EtaReduction {
 
                             then {
                                 // Mutable closure is used after current expr; we cannot consume it.
-                                snippet = format!("&mut {}", snippet);
+                                snippet = format!("&mut {snippet}");
                             }
                         }
                         diag.span_suggestion(
@@ -158,7 +158,7 @@ impl<'tcx> LateLintPass<'tcx> for EtaReduction {
                     diag.span_suggestion(
                         expr.span,
                         "replace the closure with the method itself",
-                        format!("{}::{}", name, path.ident.name),
+                        format!("{name}::{}", path.ident.name),
                         Applicability::MachineApplicable,
                     );
                 })
diff --git a/clippy_lints/src/exhaustive_items.rs b/clippy_lints/src/exhaustive_items.rs
index 173d41b4b05..218e40f2b5f 100644
--- a/clippy_lints/src/exhaustive_items.rs
+++ b/clippy_lints/src/exhaustive_items.rs
@@ -97,7 +97,7 @@ impl LateLintPass<'_> for ExhaustiveItems {
                     item.span,
                     msg,
                     |diag| {
-                        let sugg = format!("#[non_exhaustive]\n{}", indent);
+                        let sugg = format!("#[non_exhaustive]\n{indent}");
                         diag.span_suggestion(suggestion_span,
                                              "try adding #[non_exhaustive]",
                                              sugg,
diff --git a/clippy_lints/src/explicit_write.rs b/clippy_lints/src/explicit_write.rs
index b9ed4af0219..c0ea6f338a2 100644
--- a/clippy_lints/src/explicit_write.rs
+++ b/clippy_lints/src/explicit_write.rs
@@ -80,12 +80,12 @@ impl<'tcx> LateLintPass<'tcx> for ExplicitWrite {
                 // used.
                 let (used, sugg_mac) = if let Some(macro_name) = calling_macro {
                     (
-                        format!("{}!({}(), ...)", macro_name, dest_name),
+                        format!("{macro_name}!({dest_name}(), ...)"),
                         macro_name.replace("write", "print"),
                     )
                 } else {
                     (
-                        format!("{}().write_fmt(...)", dest_name),
+                        format!("{dest_name}().write_fmt(...)"),
                         "print".into(),
                     )
                 };
@@ -100,9 +100,9 @@ impl<'tcx> LateLintPass<'tcx> for ExplicitWrite {
                     cx,
                     EXPLICIT_WRITE,
                     expr.span,
-                    &format!("use of `{}.unwrap()`", used),
+                    &format!("use of `{used}.unwrap()`"),
                     "try this",
-                    format!("{}{}!({})", prefix, sugg_mac, inputs_snippet),
+                    format!("{prefix}{sugg_mac}!({inputs_snippet})"),
                     applicability,
                 )
             }
diff --git a/clippy_lints/src/float_literal.rs b/clippy_lints/src/float_literal.rs
index f2e07980963..6fee7fb308c 100644
--- a/clippy_lints/src/float_literal.rs
+++ b/clippy_lints/src/float_literal.rs
@@ -173,9 +173,9 @@ impl FloatFormat {
         T: fmt::UpperExp + fmt::LowerExp + fmt::Display,
     {
         match self {
-            Self::LowerExp => format!("{:e}", f),
-            Self::UpperExp => format!("{:E}", f),
-            Self::Normal => format!("{}", f),
+            Self::LowerExp => format!("{f:e}"),
+            Self::UpperExp => format!("{f:E}"),
+            Self::Normal => format!("{f}"),
         }
     }
 }
diff --git a/clippy_lints/src/floating_point_arithmetic.rs b/clippy_lints/src/floating_point_arithmetic.rs
index ba53a967880..e71afec12a7 100644
--- a/clippy_lints/src/floating_point_arithmetic.rs
+++ b/clippy_lints/src/floating_point_arithmetic.rs
@@ -142,8 +142,7 @@ fn prepare_receiver_sugg<'a>(cx: &LateContext<'_>, mut expr: &'a Expr<'a>) -> Su
         if let ast::LitKind::Float(sym, ast::LitFloatType::Unsuffixed) = lit.node;
         then {
             let op = format!(
-                "{}{}{}",
-                suggestion,
+                "{suggestion}{}{}",
                 // Check for float literals without numbers following the decimal
                 // separator such as `2.` and adds a trailing zero
                 if sym.as_str().ends_with('.') {
@@ -172,7 +171,7 @@ fn check_log_base(cx: &LateContext<'_>, expr: &Expr<'_>, receiver: &Expr<'_>, ar
             expr.span,
             "logarithm for bases 2, 10 and e can be computed more accurately",
             "consider using",
-            format!("{}.{}()", Sugg::hir(cx, receiver, "..").maybe_par(), method),
+            format!("{}.{method}()", Sugg::hir(cx, receiver, "..").maybe_par()),
             Applicability::MachineApplicable,
         );
     }
@@ -251,7 +250,7 @@ fn check_powf(cx: &LateContext<'_>, expr: &Expr<'_>, receiver: &Expr<'_>, args:
                 expr.span,
                 "exponent for bases 2 and e can be computed more accurately",
                 "consider using",
-                format!("{}.{}()", prepare_receiver_sugg(cx, &args[0]), method),
+                format!("{}.{method}()", prepare_receiver_sugg(cx, &args[0])),
                 Applicability::MachineApplicable,
             );
         }
diff --git a/clippy_lints/src/format.rs b/clippy_lints/src/format.rs
index f10d8256953..bc0c68f535a 100644
--- a/clippy_lints/src/format.rs
+++ b/clippy_lints/src/format.rs
@@ -62,7 +62,7 @@ impl<'tcx> LateLintPass<'tcx> for UselessFormat {
                 [_] => {
                     // Simulate macro expansion, converting {{ and }} to { and }.
                     let s_expand = format_args.format_string.snippet.replace("{{", "{").replace("}}", "}");
-                    let sugg = format!("{}.to_string()", s_expand);
+                    let sugg = format!("{s_expand}.to_string()");
                     span_useless_format(cx, call_site, sugg, applicability);
                 },
                 [..] => {},
diff --git a/clippy_lints/src/format_args.rs b/clippy_lints/src/format_args.rs
index e1c46fd0bfd..192f6258aa5 100644
--- a/clippy_lints/src/format_args.rs
+++ b/clippy_lints/src/format_args.rs
@@ -112,11 +112,10 @@ fn check_format_in_format_args(cx: &LateContext<'_>, call_site: Span, name: Symb
         cx,
         FORMAT_IN_FORMAT_ARGS,
         call_site,
-        &format!("`format!` in `{}!` args", name),
+        &format!("`format!` in `{name}!` args"),
         |diag| {
             diag.help(&format!(
-                "combine the `format!(..)` arguments with the outer `{}!(..)` call",
-                name
+                "combine the `format!(..)` arguments with the outer `{name}!(..)` call"
             ));
             diag.help("or consider changing `format!` to `format_args!`");
         },
@@ -144,8 +143,7 @@ fn check_to_string_in_format_args(cx: &LateContext<'_>, name: Symbol, value: &Ex
                     TO_STRING_IN_FORMAT_ARGS,
                     value.span.with_lo(receiver.span.hi()),
                     &format!(
-                        "`to_string` applied to a type that implements `Display` in `{}!` args",
-                        name
+                        "`to_string` applied to a type that implements `Display` in `{name}!` args"
                     ),
                     "remove this",
                     String::new(),
@@ -157,16 +155,13 @@ fn check_to_string_in_format_args(cx: &LateContext<'_>, name: Symbol, value: &Ex
                     TO_STRING_IN_FORMAT_ARGS,
                     value.span,
                     &format!(
-                        "`to_string` applied to a type that implements `Display` in `{}!` args",
-                        name
+                        "`to_string` applied to a type that implements `Display` in `{name}!` args"
                     ),
                     "use this",
                     format!(
-                        "{}{:*>width$}{}",
+                        "{}{:*>n_needed_derefs$}{receiver_snippet}",
                         if needs_ref { "&" } else { "" },
-                        "",
-                        receiver_snippet,
-                        width = n_needed_derefs
+                        ""
                     ),
                     Applicability::MachineApplicable,
                 );
diff --git a/clippy_lints/src/format_impl.rs b/clippy_lints/src/format_impl.rs
index b628fd9f758..ed1342a5465 100644
--- a/clippy_lints/src/format_impl.rs
+++ b/clippy_lints/src/format_impl.rs
@@ -214,12 +214,12 @@ fn check_print_in_format_impl(cx: &LateContext<'_>, expr: &Expr<'_>, impl_trait:
                 cx,
                 PRINT_IN_FORMAT_IMPL,
                 macro_call.span,
-                &format!("use of `{}!` in `{}` impl", name, impl_trait.name),
+                &format!("use of `{name}!` in `{}` impl", impl_trait.name),
                 "replace with",
                 if let Some(formatter_name) = impl_trait.formatter_name {
-                    format!("{}!({}, ..)", replacement, formatter_name)
+                    format!("{replacement}!({formatter_name}, ..)")
                 } else {
-                    format!("{}!(..)", replacement)
+                    format!("{replacement}!(..)")
                 },
                 Applicability::HasPlaceholders,
             );
diff --git a/clippy_lints/src/formatting.rs b/clippy_lints/src/formatting.rs
index 01cefe4af85..a866a68987d 100644
--- a/clippy_lints/src/formatting.rs
+++ b/clippy_lints/src/formatting.rs
@@ -154,11 +154,10 @@ fn check_assign(cx: &EarlyContext<'_>, expr: &Expr) {
                             eqop_span,
                             &format!(
                                 "this looks like you are trying to use `.. {op}= ..`, but you \
-                                 really are doing `.. = ({op} ..)`",
-                                op = op
+                                 really are doing `.. = ({op} ..)`"
                             ),
                             None,
-                            &format!("to remove this lint, use either `{op}=` or `= {op}`", op = op),
+                            &format!("to remove this lint, use either `{op}=` or `= {op}`"),
                         );
                     }
                 }
@@ -191,16 +190,12 @@ fn check_unop(cx: &EarlyContext<'_>, expr: &Expr) {
                 SUSPICIOUS_UNARY_OP_FORMATTING,
                 eqop_span,
                 &format!(
-                    "by not having a space between `{binop}` and `{unop}` it looks like \
-                     `{binop}{unop}` is a single operator",
-                    binop = binop_str,
-                    unop = unop_str
+                    "by not having a space between `{binop_str}` and `{unop_str}` it looks like \
+                     `{binop_str}{unop_str}` is a single operator"
                 ),
                 None,
                 &format!(
-                    "put a space between `{binop}` and `{unop}` and remove the space after `{unop}`",
-                    binop = binop_str,
-                    unop = unop_str
+                    "put a space between `{binop_str}` and `{unop_str}` and remove the space after `{unop_str}`"
                 ),
             );
         }
@@ -246,12 +241,11 @@ fn check_else(cx: &EarlyContext<'_>, expr: &Expr) {
                 cx,
                 SUSPICIOUS_ELSE_FORMATTING,
                 else_span,
-                &format!("this is an `else {}` but the formatting might hide it", else_desc),
+                &format!("this is an `else {else_desc}` but the formatting might hide it"),
                 None,
                 &format!(
                     "to remove this lint, remove the `else` or remove the new line between \
-                     `else` and `{}`",
-                    else_desc,
+                     `else` and `{else_desc}`",
                 ),
             );
         }
@@ -320,11 +314,10 @@ fn check_missing_else(cx: &EarlyContext<'_>, first: &Expr, second: &Expr) {
                 cx,
                 SUSPICIOUS_ELSE_FORMATTING,
                 else_span,
-                &format!("this looks like {} but the `else` is missing", looks_like),
+                &format!("this looks like {looks_like} but the `else` is missing"),
                 None,
                 &format!(
-                    "to remove this lint, add the missing `else` or add a new line before {}",
-                    next_thing,
+                    "to remove this lint, add the missing `else` or add a new line before {next_thing}",
                 ),
             );
         }
diff --git a/clippy_lints/src/from_str_radix_10.rs b/clippy_lints/src/from_str_radix_10.rs
index 74941d817be..2a82473be8c 100644
--- a/clippy_lints/src/from_str_radix_10.rs
+++ b/clippy_lints/src/from_str_radix_10.rs
@@ -88,7 +88,7 @@ impl<'tcx> LateLintPass<'tcx> for FromStrRadix10 {
                     exp.span,
                     "this call to `from_str_radix` can be replaced with a call to `str::parse`",
                     "try",
-                    format!("{}.parse::<{}>()", sugg, prim_ty.name_str()),
+                    format!("{sugg}.parse::<{}>()", prim_ty.name_str()),
                     Applicability::MaybeIncorrect
                 );
             }
diff --git a/clippy_lints/src/functions/must_use.rs b/clippy_lints/src/functions/must_use.rs
index 00a4937763e..09b97bacd65 100644
--- a/clippy_lints/src/functions/must_use.rs
+++ b/clippy_lints/src/functions/must_use.rs
@@ -143,7 +143,7 @@ fn check_must_use_candidate<'tcx>(
             diag.span_suggestion(
                 fn_span,
                 "add the attribute",
-                format!("#[must_use] {}", snippet),
+                format!("#[must_use] {snippet}"),
                 Applicability::MachineApplicable,
             );
         }
diff --git a/clippy_lints/src/functions/too_many_arguments.rs b/clippy_lints/src/functions/too_many_arguments.rs
index 5c8d8b8e755..1e08922a616 100644
--- a/clippy_lints/src/functions/too_many_arguments.rs
+++ b/clippy_lints/src/functions/too_many_arguments.rs
@@ -59,10 +59,7 @@ fn check_arg_number(cx: &LateContext<'_>, decl: &hir::FnDecl<'_>, fn_span: Span,
             cx,
             TOO_MANY_ARGUMENTS,
             fn_span,
-            &format!(
-                "this function has too many arguments ({}/{})",
-                args, too_many_arguments_threshold
-            ),
+            &format!("this function has too many arguments ({args}/{too_many_arguments_threshold})"),
         );
     }
 }
diff --git a/clippy_lints/src/functions/too_many_lines.rs b/clippy_lints/src/functions/too_many_lines.rs
index 54bdea7ea25..f83f8b40f94 100644
--- a/clippy_lints/src/functions/too_many_lines.rs
+++ b/clippy_lints/src/functions/too_many_lines.rs
@@ -78,10 +78,7 @@ pub(super) fn check_fn(
             cx,
             TOO_MANY_LINES,
             span,
-            &format!(
-                "this function has too many lines ({}/{})",
-                line_count, too_many_lines_threshold
-            ),
+            &format!("this function has too many lines ({line_count}/{too_many_lines_threshold})"),
         );
     }
 }
diff --git a/clippy_lints/src/if_then_some_else_none.rs b/clippy_lints/src/if_then_some_else_none.rs
index 11c43247868..0800e0644f7 100644
--- a/clippy_lints/src/if_then_some_else_none.rs
+++ b/clippy_lints/src/if_then_some_else_none.rs
@@ -84,7 +84,7 @@ impl<'tcx> LateLintPass<'tcx> for IfThenSomeElseNone {
         {
             let cond_snip = snippet_with_macro_callsite(cx, cond.span, "[condition]");
             let cond_snip = if matches!(cond.kind, ExprKind::Unary(_, _) | ExprKind::Binary(_, _, _)) {
-                format!("({})", cond_snip)
+                format!("({cond_snip})")
             } else {
                 cond_snip.into_owned()
             };
@@ -92,7 +92,7 @@ impl<'tcx> LateLintPass<'tcx> for IfThenSomeElseNone {
             let mut method_body = if then_block.stmts.is_empty() {
                 arg_snip.into_owned()
             } else {
-                format!("{{ /* snippet */ {} }}", arg_snip)
+                format!("{{ /* snippet */ {arg_snip} }}")
             };
             let method_name = if switch_to_eager_eval(cx, expr) && meets_msrv(self.msrv, msrvs::BOOL_THEN_SOME) {
                 "then_some"
@@ -102,14 +102,13 @@ impl<'tcx> LateLintPass<'tcx> for IfThenSomeElseNone {
             };
 
             let help = format!(
-                "consider using `bool::{}` like: `{}.{}({})`",
-                method_name, cond_snip, method_name, method_body,
+                "consider using `bool::{method_name}` like: `{cond_snip}.{method_name}({method_body})`",
             );
             span_lint_and_help(
                 cx,
                 IF_THEN_SOME_ELSE_NONE,
                 expr.span,
-                &format!("this could be simplified with `bool::{}`", method_name),
+                &format!("this could be simplified with `bool::{method_name}`"),
                 None,
                 &help,
             );
diff --git a/clippy_lints/src/implicit_hasher.rs b/clippy_lints/src/implicit_hasher.rs
index 4f9680f60fe..067af79152f 100644
--- a/clippy_lints/src/implicit_hasher.rs
+++ b/clippy_lints/src/implicit_hasher.rs
@@ -89,8 +89,7 @@ impl<'tcx> LateLintPass<'tcx> for ImplicitHasher {
                     (
                         generics_suggestion_span,
                         format!(
-                            "<{}{}S: ::std::hash::BuildHasher{}>",
-                            generics_snip,
+                            "<{generics_snip}{}S: ::std::hash::BuildHasher{}>",
                             if generics_snip.is_empty() { "" } else { ", " },
                             if vis.suggestions.is_empty() {
                                 ""
@@ -263,8 +262,8 @@ impl<'tcx> ImplicitHasherType<'tcx> {
 
     fn type_arguments(&self) -> String {
         match *self {
-            ImplicitHasherType::HashMap(.., ref k, ref v) => format!("{}, {}", k, v),
-            ImplicitHasherType::HashSet(.., ref t) => format!("{}", t),
+            ImplicitHasherType::HashMap(.., ref k, ref v) => format!("{k}, {v}"),
+            ImplicitHasherType::HashSet(.., ref t) => format!("{t}"),
         }
     }
 
diff --git a/clippy_lints/src/implicit_return.rs b/clippy_lints/src/implicit_return.rs
index feec8ec2e23..cfc988da233 100644
--- a/clippy_lints/src/implicit_return.rs
+++ b/clippy_lints/src/implicit_return.rs
@@ -53,7 +53,7 @@ fn lint_return(cx: &LateContext<'_>, emission_place: HirId, span: Span) {
         span,
         "missing `return` statement",
         |diag| {
-            diag.span_suggestion(span, "add `return` as shown", format!("return {}", snip), app);
+            diag.span_suggestion(span, "add `return` as shown", format!("return {snip}"), app);
         },
     );
 }
@@ -71,7 +71,7 @@ fn lint_break(cx: &LateContext<'_>, emission_place: HirId, break_span: Span, exp
             diag.span_suggestion(
                 break_span,
                 "change `break` to `return` as shown",
-                format!("return {}", snip),
+                format!("return {snip}"),
                 app,
             );
         },
diff --git a/clippy_lints/src/implicit_saturating_sub.rs b/clippy_lints/src/implicit_saturating_sub.rs
index 46654bc61e0..f0dbe17d83a 100644
--- a/clippy_lints/src/implicit_saturating_sub.rs
+++ b/clippy_lints/src/implicit_saturating_sub.rs
@@ -170,7 +170,7 @@ fn print_lint_and_sugg(cx: &LateContext<'_>, var_name: &str, expr: &Expr<'_>) {
         expr.span,
         "implicitly performing saturating subtraction",
         "try",
-        format!("{} = {}.saturating_sub({});", var_name, var_name, '1'),
+        format!("{var_name} = {var_name}.saturating_sub({});", '1'),
         Applicability::MachineApplicable,
     );
 }
diff --git a/clippy_lints/src/inconsistent_struct_constructor.rs b/clippy_lints/src/inconsistent_struct_constructor.rs
index 14b22d2b50d..e2f2d3d42e6 100644
--- a/clippy_lints/src/inconsistent_struct_constructor.rs
+++ b/clippy_lints/src/inconsistent_struct_constructor.rs
@@ -90,7 +90,7 @@ impl<'tcx> LateLintPass<'tcx> for InconsistentStructConstructor {
                 let mut fields_snippet = String::new();
                 let (last_ident, idents) = ordered_fields.split_last().unwrap();
                 for ident in idents {
-                    let _ = write!(fields_snippet, "{}, ", ident);
+                    let _ = write!(fields_snippet, "{ident}, ");
                 }
                 fields_snippet.push_str(&last_ident.to_string());
 
@@ -100,10 +100,8 @@ impl<'tcx> LateLintPass<'tcx> for InconsistentStructConstructor {
                         String::new()
                     };
 
-                let sugg = format!("{} {{ {}{} }}",
+                let sugg = format!("{} {{ {fields_snippet}{base_snippet} }}",
                     snippet(cx, qpath.span(), ".."),
-                    fields_snippet,
-                    base_snippet,
                     );
 
                 span_lint_and_sugg(
diff --git a/clippy_lints/src/index_refutable_slice.rs b/clippy_lints/src/index_refutable_slice.rs
index 0dd7f5bf000..c7b5badaae5 100644
--- a/clippy_lints/src/index_refutable_slice.rs
+++ b/clippy_lints/src/index_refutable_slice.rs
@@ -139,14 +139,14 @@ fn lint_slice(cx: &LateContext<'_>, slice: &SliceLintInformation) {
         .map(|(index, _)| *index)
         .collect::<FxHashSet<_>>();
 
-    let value_name = |index| format!("{}_{}", slice.ident.name, index);
+    let value_name = |index| format!("{}_{index}", slice.ident.name);
 
     if let Some(max_index) = used_indices.iter().max() {
         let opt_ref = if slice.needs_ref { "ref " } else { "" };
         let pat_sugg_idents = (0..=*max_index)
             .map(|index| {
                 if used_indices.contains(&index) {
-                    format!("{}{}", opt_ref, value_name(index))
+                    format!("{opt_ref}{}", value_name(index))
                 } else {
                     "_".to_string()
                 }
diff --git a/clippy_lints/src/inherent_to_string.rs b/clippy_lints/src/inherent_to_string.rs
index 17d867aacb5..f171ae2649d 100644
--- a/clippy_lints/src/inherent_to_string.rs
+++ b/clippy_lints/src/inherent_to_string.rs
@@ -131,23 +131,19 @@ fn show_lint(cx: &LateContext<'_>, item: &ImplItem<'_>) {
             INHERENT_TO_STRING_SHADOW_DISPLAY,
             item.span,
             &format!(
-                "type `{}` implements inherent method `to_string(&self) -> String` which shadows the implementation of `Display`",
-                self_type
+                "type `{self_type}` implements inherent method `to_string(&self) -> String` which shadows the implementation of `Display`"
             ),
             None,
-            &format!("remove the inherent method from type `{}`", self_type),
+            &format!("remove the inherent method from type `{self_type}`"),
         );
     } else {
         span_lint_and_help(
             cx,
             INHERENT_TO_STRING,
             item.span,
-            &format!(
-                "implementation of inherent method `to_string(&self) -> String` for type `{}`",
-                self_type
-            ),
+            &format!("implementation of inherent method `to_string(&self) -> String` for type `{self_type}`"),
             None,
-            &format!("implement trait `Display` for type `{}` instead", self_type),
+            &format!("implement trait `Display` for type `{self_type}` instead"),
         );
     }
 }
diff --git a/clippy_lints/src/inline_fn_without_body.rs b/clippy_lints/src/inline_fn_without_body.rs
index dd7177e0131..d609a5ca4d4 100644
--- a/clippy_lints/src/inline_fn_without_body.rs
+++ b/clippy_lints/src/inline_fn_without_body.rs
@@ -51,7 +51,7 @@ fn check_attrs(cx: &LateContext<'_>, name: Symbol, attrs: &[Attribute]) {
             cx,
             INLINE_FN_WITHOUT_BODY,
             attr.span,
-            &format!("use of `#[inline]` on trait method `{}` which has no body", name),
+            &format!("use of `#[inline]` on trait method `{name}` which has no body"),
             |diag| {
                 diag.suggest_remove_item(cx, attr.span, "remove", Applicability::MachineApplicable);
             },
diff --git a/clippy_lints/src/int_plus_one.rs b/clippy_lints/src/int_plus_one.rs
index 9a944def3eb..33491da3fc5 100644
--- a/clippy_lints/src/int_plus_one.rs
+++ b/clippy_lints/src/int_plus_one.rs
@@ -138,8 +138,8 @@ impl IntPlusOne {
         if let Some(snippet) = snippet_opt(cx, node.span) {
             if let Some(other_side_snippet) = snippet_opt(cx, other_side.span) {
                 let rec = match side {
-                    Side::Lhs => Some(format!("{} {} {}", snippet, binop_string, other_side_snippet)),
-                    Side::Rhs => Some(format!("{} {} {}", other_side_snippet, binop_string, snippet)),
+                    Side::Lhs => Some(format!("{snippet} {binop_string} {other_side_snippet}")),
+                    Side::Rhs => Some(format!("{other_side_snippet} {binop_string} {snippet}")),
                 };
                 return rec;
             }
diff --git a/clippy_lints/src/iter_not_returning_iterator.rs b/clippy_lints/src/iter_not_returning_iterator.rs
index b56d87c5348..78815ea5a0a 100644
--- a/clippy_lints/src/iter_not_returning_iterator.rs
+++ b/clippy_lints/src/iter_not_returning_iterator.rs
@@ -80,10 +80,7 @@ fn check_sig(cx: &LateContext<'_>, name: &str, sig: &FnSig<'_>, fn_id: LocalDefI
                 cx,
                 ITER_NOT_RETURNING_ITERATOR,
                 sig.span,
-                &format!(
-                    "this method is named `{}` but its return type does not implement `Iterator`",
-                    name
-                ),
+                &format!("this method is named `{name}` but its return type does not implement `Iterator`"),
             );
         }
     }
diff --git a/clippy_lints/src/len_zero.rs b/clippy_lints/src/len_zero.rs
index 7ae8ef830fa..e94292b9fac 100644
--- a/clippy_lints/src/len_zero.rs
+++ b/clippy_lints/src/len_zero.rs
@@ -278,15 +278,13 @@ impl<'tcx> LenOutput<'tcx> {
             _ => "",
         };
         match self {
-            Self::Integral => format!("expected signature: `({}self) -> bool`", self_ref),
-            Self::Option(_) => format!(
-                "expected signature: `({}self) -> bool` or `({}self) -> Option<bool>",
-                self_ref, self_ref
-            ),
-            Self::Result(..) => format!(
-                "expected signature: `({}self) -> bool` or `({}self) -> Result<bool>",
-                self_ref, self_ref
-            ),
+            Self::Integral => format!("expected signature: `({self_ref}self) -> bool`"),
+            Self::Option(_) => {
+                format!("expected signature: `({self_ref}self) -> bool` or `({self_ref}self) -> Option<bool>")
+            },
+            Self::Result(..) => {
+                format!("expected signature: `({self_ref}self) -> bool` or `({self_ref}self) -> Result<bool>")
+            },
         }
     }
 }
@@ -326,8 +324,7 @@ fn check_for_is_empty<'tcx>(
     let (msg, is_empty_span, self_kind) = match is_empty {
         None => (
             format!(
-                "{} `{}` has a public `len` method, but no `is_empty` method",
-                item_kind,
+                "{item_kind} `{}` has a public `len` method, but no `is_empty` method",
                 item_name.as_str(),
             ),
             None,
@@ -335,8 +332,7 @@ fn check_for_is_empty<'tcx>(
         ),
         Some(is_empty) if !cx.access_levels.is_exported(is_empty.def_id.expect_local()) => (
             format!(
-                "{} `{}` has a public `len` method, but a private `is_empty` method",
-                item_kind,
+                "{item_kind} `{}` has a public `len` method, but a private `is_empty` method",
                 item_name.as_str(),
             ),
             Some(cx.tcx.def_span(is_empty.def_id)),
@@ -348,8 +344,7 @@ fn check_for_is_empty<'tcx>(
         {
             (
                 format!(
-                    "{} `{}` has a public `len` method, but the `is_empty` method has an unexpected signature",
-                    item_kind,
+                    "{item_kind} `{}` has a public `len` method, but the `is_empty` method has an unexpected signature",
                     item_name.as_str(),
                 ),
                 Some(cx.tcx.def_span(is_empty.def_id)),
@@ -419,10 +414,9 @@ fn check_len(
                 LEN_ZERO,
                 span,
                 &format!("length comparison to {}", if compare_to == 0 { "zero" } else { "one" }),
-                &format!("using `{}is_empty` is clearer and more explicit", op),
+                &format!("using `{op}is_empty` is clearer and more explicit"),
                 format!(
-                    "{}{}.is_empty()",
-                    op,
+                    "{op}{}.is_empty()",
                     snippet_with_applicability(cx, receiver.span, "_", &mut applicability)
                 ),
                 applicability,
@@ -439,10 +433,9 @@ fn check_empty_expr(cx: &LateContext<'_>, span: Span, lit1: &Expr<'_>, lit2: &Ex
             COMPARISON_TO_EMPTY,
             span,
             "comparison to empty slice",
-            &format!("using `{}is_empty` is clearer and more explicit", op),
+            &format!("using `{op}is_empty` is clearer and more explicit"),
             format!(
-                "{}{}.is_empty()",
-                op,
+                "{op}{}.is_empty()",
                 snippet_with_applicability(cx, lit1.span, "_", &mut applicability)
             ),
             applicability,
diff --git a/clippy_lints/src/let_if_seq.rs b/clippy_lints/src/let_if_seq.rs
index 10fc0f4018e..13071d64441 100644
--- a/clippy_lints/src/let_if_seq.rs
+++ b/clippy_lints/src/let_if_seq.rs
@@ -106,8 +106,7 @@ impl<'tcx> LateLintPass<'tcx> for LetIfSeq {
                     // use mutably after the `if`
 
                     let sug = format!(
-                        "let {mut}{name} = if {cond} {{{then} {value} }} else {{{else} {default} }};",
-                        mut=mutability,
+                        "let {mutability}{name} = if {cond} {{{then} {value} }} else {{{else} {default} }};",
                         name=ident.name,
                         cond=snippet(cx, cond.span, "_"),
                         then=if then.stmts.len() > 1 { " ..;" } else { "" },
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 83fdc15c9f0..8a2a1682eca 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -417,8 +417,7 @@ pub fn register_pre_expansion_lints(store: &mut rustc_lint::LintStore, sess: &Se
     let msrv = conf.msrv.as_ref().and_then(|s| {
         parse_msrv(s, None, None).or_else(|| {
             sess.err(&format!(
-                "error reading Clippy's configuration file. `{}` is not a valid Rust version",
-                s
+                "error reading Clippy's configuration file. `{s}` is not a valid Rust version"
             ));
             None
         })
@@ -434,8 +433,7 @@ fn read_msrv(conf: &Conf, sess: &Session) -> Option<RustcVersion> {
     let clippy_msrv = conf.msrv.as_ref().and_then(|s| {
         parse_msrv(s, None, None).or_else(|| {
             sess.err(&format!(
-                "error reading Clippy's configuration file. `{}` is not a valid Rust version",
-                s
+                "error reading Clippy's configuration file. `{s}` is not a valid Rust version"
             ));
             None
         })
@@ -446,8 +444,7 @@ fn read_msrv(conf: &Conf, sess: &Session) -> Option<RustcVersion> {
             // if both files have an msrv, let's compare them and emit a warning if they differ
             if clippy_msrv != cargo_msrv {
                 sess.warn(&format!(
-                    "the MSRV in `clippy.toml` and `Cargo.toml` differ; using `{}` from `clippy.toml`",
-                    clippy_msrv
+                    "the MSRV in `clippy.toml` and `Cargo.toml` differ; using `{clippy_msrv}` from `clippy.toml`"
                 ));
             }
 
@@ -466,7 +463,7 @@ pub fn read_conf(sess: &Session) -> Conf {
         Ok(Some(path)) => path,
         Ok(None) => return Conf::default(),
         Err(error) => {
-            sess.struct_err(&format!("error finding Clippy's configuration file: {}", error))
+            sess.struct_err(&format!("error finding Clippy's configuration file: {error}"))
                 .emit();
             return Conf::default();
         },
diff --git a/clippy_lints/src/literal_representation.rs b/clippy_lints/src/literal_representation.rs
index fb2104861c8..25f19b9c6e6 100644
--- a/clippy_lints/src/literal_representation.rs
+++ b/clippy_lints/src/literal_representation.rs
@@ -478,7 +478,7 @@ impl DecimalLiteralRepresentation {
             if num_lit.radix == Radix::Decimal;
             if val >= u128::from(self.threshold);
             then {
-                let hex = format!("{:#X}", val);
+                let hex = format!("{val:#X}");
                 let num_lit = NumericLiteral::new(&hex, num_lit.suffix, false);
                 let _ = Self::do_lint(num_lit.integer).map_err(|warning_type| {
                     warning_type.display(num_lit.format(), cx, lit.span);
diff --git a/clippy_lints/src/loops/explicit_counter_loop.rs b/clippy_lints/src/loops/explicit_counter_loop.rs
index 8e3ab26a947..14f22348132 100644
--- a/clippy_lints/src/loops/explicit_counter_loop.rs
+++ b/clippy_lints/src/loops/explicit_counter_loop.rs
@@ -44,11 +44,10 @@ pub(super) fn check<'tcx>(
                                 cx,
                                 EXPLICIT_COUNTER_LOOP,
                                 span,
-                                &format!("the variable `{}` is used as a loop counter", name),
+                                &format!("the variable `{name}` is used as a loop counter"),
                                 "consider using",
                                 format!(
-                                    "for ({}, {}) in {}.enumerate()",
-                                    name,
+                                    "for ({name}, {}) in {}.enumerate()",
                                     snippet_with_applicability(cx, pat.span, "item", &mut applicability),
                                     make_iterator_snippet(cx, arg, &mut applicability),
                                 ),
@@ -65,24 +64,21 @@ pub(super) fn check<'tcx>(
                         cx,
                         EXPLICIT_COUNTER_LOOP,
                         span,
-                        &format!("the variable `{}` is used as a loop counter", name),
+                        &format!("the variable `{name}` is used as a loop counter"),
                         |diag| {
                             diag.span_suggestion(
                                 span,
                                 "consider using",
                                 format!(
-                                    "for ({}, {}) in (0_{}..).zip({})",
-                                    name,
+                                    "for ({name}, {}) in (0_{int_name}..).zip({})",
                                     snippet_with_applicability(cx, pat.span, "item", &mut applicability),
-                                    int_name,
                                     make_iterator_snippet(cx, arg, &mut applicability),
                                 ),
                                 applicability,
                             );
 
                             diag.note(&format!(
-                                "`{}` is of type `{}`, making it ineligible for `Iterator::enumerate`",
-                                name, int_name
+                                "`{name}` is of type `{int_name}`, making it ineligible for `Iterator::enumerate`"
                             ));
                         },
                     );
diff --git a/clippy_lints/src/loops/explicit_iter_loop.rs b/clippy_lints/src/loops/explicit_iter_loop.rs
index 5f5beccd030..b1f2941622a 100644
--- a/clippy_lints/src/loops/explicit_iter_loop.rs
+++ b/clippy_lints/src/loops/explicit_iter_loop.rs
@@ -41,7 +41,7 @@ pub(super) fn check(cx: &LateContext<'_>, self_arg: &Expr<'_>, arg: &Expr<'_>, m
         "it is more concise to loop over references to containers instead of using explicit \
          iteration methods",
         "to write this more concisely, try",
-        format!("&{}{}", muta, object),
+        format!("&{muta}{object}"),
         applicability,
     );
 }
diff --git a/clippy_lints/src/loops/for_kv_map.rs b/clippy_lints/src/loops/for_kv_map.rs
index bee0e1d7683..ed620460dbe 100644
--- a/clippy_lints/src/loops/for_kv_map.rs
+++ b/clippy_lints/src/loops/for_kv_map.rs
@@ -38,7 +38,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>, arg: &'tcx
                     cx,
                     FOR_KV_MAP,
                     arg_span,
-                    &format!("you seem to want to iterate on a map's {}s", kind),
+                    &format!("you seem to want to iterate on a map's {kind}s"),
                     |diag| {
                         let map = sugg::Sugg::hir(cx, arg, "map");
                         multispan_sugg(
@@ -46,7 +46,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>, arg: &'tcx
                             "use the corresponding method",
                             vec![
                                 (pat_span, snippet(cx, new_pat_span, kind).into_owned()),
-                                (arg_span, format!("{}.{}s{}()", map.maybe_par(), kind, mutbl)),
+                                (arg_span, format!("{}.{kind}s{mutbl}()", map.maybe_par())),
                             ],
                         );
                     },
diff --git a/clippy_lints/src/loops/manual_flatten.rs b/clippy_lints/src/loops/manual_flatten.rs
index 1d6ddf4b99f..1b36d452647 100644
--- a/clippy_lints/src/loops/manual_flatten.rs
+++ b/clippy_lints/src/loops/manual_flatten.rs
@@ -38,7 +38,7 @@ pub(super) fn check<'tcx>(
         then {
             let if_let_type = if some_ctor { "Some" } else { "Ok" };
             // Prepare the error message
-            let msg = format!("unnecessary `if let` since only the `{}` variant of the iterator element is used", if_let_type);
+            let msg = format!("unnecessary `if let` since only the `{if_let_type}` variant of the iterator element is used");
 
             // Prepare the help message
             let mut applicability = Applicability::MaybeIncorrect;
diff --git a/clippy_lints/src/loops/manual_memcpy.rs b/clippy_lints/src/loops/manual_memcpy.rs
index 3fc569af89e..c87fc4f90e2 100644
--- a/clippy_lints/src/loops/manual_memcpy.rs
+++ b/clippy_lints/src/loops/manual_memcpy.rs
@@ -177,13 +177,7 @@ fn build_manual_memcpy_suggestion<'tcx>(
     let dst = if dst_offset == sugg::EMPTY && dst_limit == sugg::EMPTY {
         dst_base_str
     } else {
-        format!(
-            "{}[{}..{}]",
-            dst_base_str,
-            dst_offset.maybe_par(),
-            dst_limit.maybe_par()
-        )
-        .into()
+        format!("{dst_base_str}[{}..{}]", dst_offset.maybe_par(), dst_limit.maybe_par()).into()
     };
 
     let method_str = if is_copy(cx, elem_ty) {
@@ -193,10 +187,7 @@ fn build_manual_memcpy_suggestion<'tcx>(
     };
 
     format!(
-        "{}.{}(&{}[{}..{}]);",
-        dst,
-        method_str,
-        src_base_str,
+        "{dst}.{method_str}(&{src_base_str}[{}..{}]);",
         src_offset.maybe_par(),
         src_limit.maybe_par()
     )
diff --git a/clippy_lints/src/loops/needless_collect.rs b/clippy_lints/src/loops/needless_collect.rs
index 6e6faa79adc..66f9e28596e 100644
--- a/clippy_lints/src/loops/needless_collect.rs
+++ b/clippy_lints/src/loops/needless_collect.rs
@@ -45,7 +45,7 @@ fn check_needless_collect_direct_usage<'tcx>(expr: &'tcx Expr<'_>, cx: &LateCont
                         let (arg, pred) = contains_arg
                             .strip_prefix('&')
                             .map_or(("&x", &*contains_arg), |s| ("x", s));
-                        format!("any(|{}| x == {})", arg, pred)
+                        format!("any(|{arg}| x == {pred})")
                     }
                     _ => return,
                 }
@@ -141,9 +141,9 @@ impl IterFunction {
             IterFunctionKind::Contains(span) => {
                 let s = snippet(cx, *span, "..");
                 if let Some(stripped) = s.strip_prefix('&') {
-                    format!(".any(|x| x == {})", stripped)
+                    format!(".any(|x| x == {stripped})")
                 } else {
-                    format!(".any(|x| x == *{})", s)
+                    format!(".any(|x| x == *{s})")
                 }
             },
         }
diff --git a/clippy_lints/src/loops/needless_range_loop.rs b/clippy_lints/src/loops/needless_range_loop.rs
index 8ab640051b6..00cfc6d49f1 100644
--- a/clippy_lints/src/loops/needless_range_loop.rs
+++ b/clippy_lints/src/loops/needless_range_loop.rs
@@ -145,7 +145,7 @@ pub(super) fn check<'tcx>(
                         cx,
                         NEEDLESS_RANGE_LOOP,
                         arg.span,
-                        &format!("the loop variable `{}` is used to index `{}`", ident.name, indexed),
+                        &format!("the loop variable `{}` is used to index `{indexed}`", ident.name),
                         |diag| {
                             multispan_sugg(
                                 diag,
@@ -154,7 +154,7 @@ pub(super) fn check<'tcx>(
                                     (pat.span, format!("({}, <item>)", ident.name)),
                                     (
                                         arg.span,
-                                        format!("{}.{}().enumerate(){}{}", indexed, method, method_1, method_2),
+                                        format!("{indexed}.{method}().enumerate(){method_1}{method_2}"),
                                     ),
                                 ],
                             );
@@ -162,16 +162,16 @@ pub(super) fn check<'tcx>(
                     );
                 } else {
                     let repl = if starts_at_zero && take_is_empty {
-                        format!("&{}{}", ref_mut, indexed)
+                        format!("&{ref_mut}{indexed}")
                     } else {
-                        format!("{}.{}(){}{}", indexed, method, method_1, method_2)
+                        format!("{indexed}.{method}(){method_1}{method_2}")
                     };
 
                     span_lint_and_then(
                         cx,
                         NEEDLESS_RANGE_LOOP,
                         arg.span,
-                        &format!("the loop variable `{}` is only used to index `{}`", ident.name, indexed),
+                        &format!("the loop variable `{}` is only used to index `{indexed}`", ident.name),
                         |diag| {
                             multispan_sugg(
                                 diag,
diff --git a/clippy_lints/src/loops/never_loop.rs b/clippy_lints/src/loops/never_loop.rs
index 2386f4f4f4e..16b00ad6637 100644
--- a/clippy_lints/src/loops/never_loop.rs
+++ b/clippy_lints/src/loops/never_loop.rs
@@ -222,9 +222,5 @@ fn for_to_if_let_sugg(cx: &LateContext<'_>, iterator: &Expr<'_>, pat: &Pat<'_>)
     let pat_snippet = snippet(cx, pat.span, "_");
     let iter_snippet = make_iterator_snippet(cx, iterator, &mut Applicability::Unspecified);
 
-    format!(
-        "if let Some({pat}) = {iter}.next()",
-        pat = pat_snippet,
-        iter = iter_snippet
-    )
+    format!("if let Some({pat_snippet}) = {iter_snippet}.next()")
 }
diff --git a/clippy_lints/src/loops/same_item_push.rs b/clippy_lints/src/loops/same_item_push.rs
index aeefe6e33fb..07edee46fa6 100644
--- a/clippy_lints/src/loops/same_item_push.rs
+++ b/clippy_lints/src/loops/same_item_push.rs
@@ -30,10 +30,7 @@ pub(super) fn check<'tcx>(
             vec.span,
             "it looks like the same item is being pushed into this Vec",
             None,
-            &format!(
-                "try using vec![{};SIZE] or {}.resize(NEW_SIZE, {})",
-                item_str, vec_str, item_str
-            ),
+            &format!("try using vec![{item_str};SIZE] or {vec_str}.resize(NEW_SIZE, {item_str})"),
         );
     }
 
diff --git a/clippy_lints/src/loops/utils.rs b/clippy_lints/src/loops/utils.rs
index 4801a84eb92..b332e8a923b 100644
--- a/clippy_lints/src/loops/utils.rs
+++ b/clippy_lints/src/loops/utils.rs
@@ -344,9 +344,8 @@ pub(super) fn make_iterator_snippet(cx: &LateContext<'_>, arg: &Expr<'_>, applic
                     _ => arg,
                 };
                 format!(
-                    "{}.{}()",
+                    "{}.{method_name}()",
                     sugg::Sugg::hir_with_applicability(cx, caller, "_", applic_ref).maybe_par(),
-                    method_name,
                 )
             },
             _ => format!(
diff --git a/clippy_lints/src/loops/while_let_on_iterator.rs b/clippy_lints/src/loops/while_let_on_iterator.rs
index deb21894f36..1c6f0264cb5 100644
--- a/clippy_lints/src/loops/while_let_on_iterator.rs
+++ b/clippy_lints/src/loops/while_let_on_iterator.rs
@@ -67,7 +67,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         expr.span.with_hi(scrutinee_expr.span.hi()),
         "this loop could be written as a `for` loop",
         "try",
-        format!("for {} in {}{}", loop_var, iterator, by_ref),
+        format!("for {loop_var} in {iterator}{by_ref}"),
         applicability,
     );
 }
diff --git a/clippy_lints/src/macro_use.rs b/clippy_lints/src/macro_use.rs
index 6b78c162065..f5617a905ff 100644
--- a/clippy_lints/src/macro_use.rs
+++ b/clippy_lints/src/macro_use.rs
@@ -190,9 +190,9 @@ impl<'tcx> LateLintPass<'tcx> for MacroUseImports {
         let mut suggestions = vec![];
         for ((root, span, hir_id), path) in used {
             if path.len() == 1 {
-                suggestions.push((span, format!("{}::{}", root, path[0]), hir_id));
+                suggestions.push((span, format!("{root}::{}", path[0]), hir_id));
             } else {
-                suggestions.push((span, format!("{}::{{{}}}", root, path.join(", ")), hir_id));
+                suggestions.push((span, format!("{root}::{{{}}}", path.join(", ")), hir_id));
             }
         }
 
@@ -200,7 +200,7 @@ impl<'tcx> LateLintPass<'tcx> for MacroUseImports {
         // such as `std::prelude::v1::foo` or some other macro that expands to an import.
         if self.mac_refs.is_empty() {
             for (span, import, hir_id) in suggestions {
-                let help = format!("use {};", import);
+                let help = format!("use {import};");
                 span_lint_hir_and_then(
                     cx,
                     MACRO_USE_IMPORTS,
diff --git a/clippy_lints/src/manual_async_fn.rs b/clippy_lints/src/manual_async_fn.rs
index 2502c8f880d..ddd9f34cbc4 100644
--- a/clippy_lints/src/manual_async_fn.rs
+++ b/clippy_lints/src/manual_async_fn.rs
@@ -74,11 +74,11 @@ impl<'tcx> LateLintPass<'tcx> for ManualAsyncFn {
                             if let Some(ret_pos) = position_before_rarrow(&header_snip);
                             if let Some((ret_sugg, ret_snip)) = suggested_ret(cx, output);
                             then {
-                                let help = format!("make the function `async` and {}", ret_sugg);
+                                let help = format!("make the function `async` and {ret_sugg}");
                                 diag.span_suggestion(
                                     header_span,
                                     &help,
-                                    format!("async {}{}", &header_snip[..ret_pos], ret_snip),
+                                    format!("async {}{ret_snip}", &header_snip[..ret_pos]),
                                     Applicability::MachineApplicable
                                 );
 
@@ -196,7 +196,7 @@ fn suggested_ret(cx: &LateContext<'_>, output: &Ty<'_>) -> Option<(&'static str,
         },
         _ => {
             let sugg = "return the output of the future directly";
-            snippet_opt(cx, output.span).map(|snip| (sugg, format!(" -> {}", snip)))
+            snippet_opt(cx, output.span).map(|snip| (sugg, format!(" -> {snip}")))
         },
     }
 }
diff --git a/clippy_lints/src/manual_non_exhaustive.rs b/clippy_lints/src/manual_non_exhaustive.rs
index 2b04475c7a9..7d4f0b02112 100644
--- a/clippy_lints/src/manual_non_exhaustive.rs
+++ b/clippy_lints/src/manual_non_exhaustive.rs
@@ -133,7 +133,7 @@ impl EarlyLintPass for ManualNonExhaustiveStruct {
                             diag.span_suggestion(
                                 header_span,
                                 "add the attribute",
-                                format!("#[non_exhaustive] {}", snippet),
+                                format!("#[non_exhaustive] {snippet}"),
                                 Applicability::Unspecified,
                             );
                         }
@@ -207,7 +207,7 @@ impl<'tcx> LateLintPass<'tcx> for ManualNonExhaustiveEnum {
                             diag.span_suggestion(
                                 header_span,
                                 "add the attribute",
-                                format!("#[non_exhaustive] {}", snippet),
+                                format!("#[non_exhaustive] {snippet}"),
                                 Applicability::Unspecified,
                             );
                     }
diff --git a/clippy_lints/src/manual_retain.rs b/clippy_lints/src/manual_retain.rs
index 8476197bd12..570fe736818 100644
--- a/clippy_lints/src/manual_retain.rs
+++ b/clippy_lints/src/manual_retain.rs
@@ -153,7 +153,7 @@ fn suggest(cx: &LateContext<'_>, parent_expr: &hir::Expr<'_>, left_expr: &hir::E
         && let [filter_params] = filter_body.params
         && let Some(sugg) = match filter_params.pat.kind {
             hir::PatKind::Binding(_, _, filter_param_ident, None) => {
-                Some(format!("{}.retain(|{}| {})", snippet(cx, left_expr.span, ".."), filter_param_ident, snippet(cx, filter_body.value.span, "..")))
+                Some(format!("{}.retain(|{filter_param_ident}| {})", snippet(cx, left_expr.span, ".."), snippet(cx, filter_body.value.span, "..")))
             },
             hir::PatKind::Tuple([key_pat, value_pat], _) => {
                 make_sugg(cx, key_pat, value_pat, left_expr, filter_body)
@@ -161,7 +161,7 @@ fn suggest(cx: &LateContext<'_>, parent_expr: &hir::Expr<'_>, left_expr: &hir::E
             hir::PatKind::Ref(pat, _) => {
                 match pat.kind {
                     hir::PatKind::Binding(_, _, filter_param_ident, None) => {
-                        Some(format!("{}.retain(|{}| {})", snippet(cx, left_expr.span, ".."), filter_param_ident, snippet(cx, filter_body.value.span, "..")))
+                        Some(format!("{}.retain(|{filter_param_ident}| {})", snippet(cx, left_expr.span, ".."), snippet(cx, filter_body.value.span, "..")))
                     },
                     _ => None
                 }
@@ -190,23 +190,19 @@ fn make_sugg(
     match (&key_pat.kind, &value_pat.kind) {
         (hir::PatKind::Binding(_, _, key_param_ident, None), hir::PatKind::Binding(_, _, value_param_ident, None)) => {
             Some(format!(
-                "{}.retain(|{}, &mut {}| {})",
+                "{}.retain(|{key_param_ident}, &mut {value_param_ident}| {})",
                 snippet(cx, left_expr.span, ".."),
-                key_param_ident,
-                value_param_ident,
                 snippet(cx, filter_body.value.span, "..")
             ))
         },
         (hir::PatKind::Binding(_, _, key_param_ident, None), hir::PatKind::Wild) => Some(format!(
-            "{}.retain(|{}, _| {})",
+            "{}.retain(|{key_param_ident}, _| {})",
             snippet(cx, left_expr.span, ".."),
-            key_param_ident,
             snippet(cx, filter_body.value.span, "..")
         )),
         (hir::PatKind::Wild, hir::PatKind::Binding(_, _, value_param_ident, None)) => Some(format!(
-            "{}.retain(|_, &mut {}| {})",
+            "{}.retain(|_, &mut {value_param_ident}| {})",
             snippet(cx, left_expr.span, ".."),
-            value_param_ident,
             snippet(cx, filter_body.value.span, "..")
         )),
         _ => None,
diff --git a/clippy_lints/src/manual_strip.rs b/clippy_lints/src/manual_strip.rs
index 7941c8c9c7e..0976940afac 100644
--- a/clippy_lints/src/manual_strip.rs
+++ b/clippy_lints/src/manual_strip.rs
@@ -108,15 +108,14 @@ impl<'tcx> LateLintPass<'tcx> for ManualStrip {
                     };
 
                     let test_span = expr.span.until(then.span);
-                    span_lint_and_then(cx, MANUAL_STRIP, strippings[0], &format!("stripping a {} manually", kind_word), |diag| {
-                        diag.span_note(test_span, &format!("the {} was tested here", kind_word));
+                    span_lint_and_then(cx, MANUAL_STRIP, strippings[0], &format!("stripping a {kind_word} manually"), |diag| {
+                        diag.span_note(test_span, &format!("the {kind_word} was tested here"));
                         multispan_sugg(
                             diag,
-                            &format!("try using the `strip_{}` method", kind_word),
+                            &format!("try using the `strip_{kind_word}` method"),
                             vec![(test_span,
-                                  format!("if let Some(<stripped>) = {}.strip_{}({}) ",
+                                  format!("if let Some(<stripped>) = {}.strip_{kind_word}({}) ",
                                           snippet(cx, target_arg.span, ".."),
-                                          kind_word,
                                           snippet(cx, pattern.span, "..")))]
                             .into_iter().chain(strippings.into_iter().map(|span| (span, "<stripped>".into()))),
                         );
diff --git a/clippy_lints/src/map_unit_fn.rs b/clippy_lints/src/map_unit_fn.rs
index 33d74481529..df5684541e9 100644
--- a/clippy_lints/src/map_unit_fn.rs
+++ b/clippy_lints/src/map_unit_fn.rs
@@ -194,10 +194,7 @@ fn let_binding_name(cx: &LateContext<'_>, var_arg: &hir::Expr<'_>) -> String {
 
 #[must_use]
 fn suggestion_msg(function_type: &str, map_type: &str) -> String {
-    format!(
-        "called `map(f)` on an `{0}` value where `f` is a {1} that returns the unit type `()`",
-        map_type, function_type
-    )
+    format!("called `map(f)` on an `{map_type}` value where `f` is a {function_type} that returns the unit type `()`")
 }
 
 fn lint_map_unit_fn(
diff --git a/clippy_lints/src/match_result_ok.rs b/clippy_lints/src/match_result_ok.rs
index 8588ab1ed8d..a020282d234 100644
--- a/clippy_lints/src/match_result_ok.rs
+++ b/clippy_lints/src/match_result_ok.rs
@@ -70,9 +70,7 @@ impl<'tcx> LateLintPass<'tcx> for MatchResultOk {
                 let some_expr_string = snippet_with_applicability(cx, y[0].span, "", &mut applicability);
                 let trimmed_ok = snippet_with_applicability(cx, let_expr.span.until(ok_path.ident.span), "", &mut applicability);
                 let sugg = format!(
-                    "{} let Ok({}) = {}",
-                    ifwhile,
-                    some_expr_string,
+                    "{ifwhile} let Ok({some_expr_string}) = {}",
                     trimmed_ok.trim().trim_end_matches('.'),
                 );
                 span_lint_and_sugg(
@@ -80,7 +78,7 @@ impl<'tcx> LateLintPass<'tcx> for MatchResultOk {
                     MATCH_RESULT_OK,
                     expr.span.with_hi(let_expr.span.hi()),
                     "matching on `Some` with `ok()` is redundant",
-                    &format!("consider matching on `Ok({})` and removing the call to `ok` instead", some_expr_string),
+                    &format!("consider matching on `Ok({some_expr_string})` and removing the call to `ok` instead"),
                     sugg,
                     applicability,
                 );
diff --git a/clippy_lints/src/matches/manual_map.rs b/clippy_lints/src/matches/manual_map.rs
index b0198e856d5..96b8339550c 100644
--- a/clippy_lints/src/matches/manual_map.rs
+++ b/clippy_lints/src/matches/manual_map.rs
@@ -144,7 +144,7 @@ fn check<'tcx>(
     let scrutinee = peel_hir_expr_refs(scrutinee).0;
     let (scrutinee_str, _) = snippet_with_context(cx, scrutinee.span, expr_ctxt, "..", &mut app);
     let scrutinee_str = if scrutinee.span.ctxt() == expr.span.ctxt() && scrutinee.precedence().order() < PREC_POSTFIX {
-        format!("({})", scrutinee_str)
+        format!("({scrutinee_str})")
     } else {
         scrutinee_str.into()
     };
@@ -172,9 +172,9 @@ fn check<'tcx>(
                 };
                 let expr_snip = snippet_with_context(cx, some_expr.expr.span, expr_ctxt, "..", &mut app).0;
                 if some_expr.needs_unsafe_block {
-                    format!("|{}{}| unsafe {{ {} }}", annotation, some_binding, expr_snip)
+                    format!("|{annotation}{some_binding}| unsafe {{ {expr_snip} }}")
                 } else {
-                    format!("|{}{}| {}", annotation, some_binding, expr_snip)
+                    format!("|{annotation}{some_binding}| {expr_snip}")
                 }
             }
         }
@@ -183,9 +183,9 @@ fn check<'tcx>(
         let pat_snip = snippet_with_context(cx, some_pat.span, expr_ctxt, "..", &mut app).0;
         let expr_snip = snippet_with_context(cx, some_expr.expr.span, expr_ctxt, "..", &mut app).0;
         if some_expr.needs_unsafe_block {
-            format!("|{}| unsafe {{ {} }}", pat_snip, expr_snip)
+            format!("|{pat_snip}| unsafe {{ {expr_snip} }}")
         } else {
-            format!("|{}| {}", pat_snip, expr_snip)
+            format!("|{pat_snip}| {expr_snip}")
         }
     } else {
         // Refutable bindings and mixed reference annotations can't be handled by `map`.
@@ -199,9 +199,9 @@ fn check<'tcx>(
         "manual implementation of `Option::map`",
         "try this",
         if else_pat.is_none() && is_else_clause(cx.tcx, expr) {
-            format!("{{ {}{}.map({}) }}", scrutinee_str, as_ref_str, body_str)
+            format!("{{ {scrutinee_str}{as_ref_str}.map({body_str}) }}")
         } else {
-            format!("{}{}.map({})", scrutinee_str, as_ref_str, body_str)
+            format!("{scrutinee_str}{as_ref_str}.map({body_str})")
         },
         app,
     );
diff --git a/clippy_lints/src/matches/manual_unwrap_or.rs b/clippy_lints/src/matches/manual_unwrap_or.rs
index e1111c80f2f..2fe7fe98a2e 100644
--- a/clippy_lints/src/matches/manual_unwrap_or.rs
+++ b/clippy_lints/src/matches/manual_unwrap_or.rs
@@ -42,12 +42,10 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>, scrutinee:
             span_lint_and_sugg(
                 cx,
                 MANUAL_UNWRAP_OR, expr.span,
-                &format!("this pattern reimplements `{}::unwrap_or`", ty_name),
+                &format!("this pattern reimplements `{ty_name}::unwrap_or`"),
                 "replace with",
                 format!(
-                    "{}.unwrap_or({})",
-                    suggestion,
-                    reindented_or_body,
+                    "{suggestion}.unwrap_or({reindented_or_body})",
                 ),
                 Applicability::MachineApplicable,
             );
diff --git a/clippy_lints/src/matches/match_as_ref.rs b/clippy_lints/src/matches/match_as_ref.rs
index 91d17f481e2..39d30212f36 100644
--- a/clippy_lints/src/matches/match_as_ref.rs
+++ b/clippy_lints/src/matches/match_as_ref.rs
@@ -45,13 +45,11 @@ pub(crate) fn check(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>], expr:
                 cx,
                 MATCH_AS_REF,
                 expr.span,
-                &format!("use `{}()` instead", suggestion),
+                &format!("use `{suggestion}()` instead"),
                 "try this",
                 format!(
-                    "{}.{}(){}",
+                    "{}.{suggestion}(){cast}",
                     snippet_with_applicability(cx, ex.span, "_", &mut applicability),
-                    suggestion,
-                    cast,
                 ),
                 applicability,
             );
diff --git a/clippy_lints/src/matches/match_like_matches.rs b/clippy_lints/src/matches/match_like_matches.rs
index 34cc082687e..107fad32393 100644
--- a/clippy_lints/src/matches/match_like_matches.rs
+++ b/clippy_lints/src/matches/match_like_matches.rs
@@ -112,7 +112,7 @@ where
                     .join(" | ")
             };
             let pat_and_guard = if let Some(Guard::If(g)) = first_guard {
-                format!("{} if {}", pat, snippet_with_applicability(cx, g.span, "..", &mut applicability))
+                format!("{pat} if {}", snippet_with_applicability(cx, g.span, "..", &mut applicability))
             } else {
                 pat
             };
@@ -131,10 +131,9 @@ where
                 &format!("{} expression looks like `matches!` macro", if is_if_let { "if let .. else" } else { "match" }),
                 "try this",
                 format!(
-                    "{}matches!({}, {})",
+                    "{}matches!({}, {pat_and_guard})",
                     if b0 { "" } else { "!" },
                     snippet_with_applicability(cx, ex_new.span, "..", &mut applicability),
-                    pat_and_guard,
                 ),
                 applicability,
             );
diff --git a/clippy_lints/src/matches/match_same_arms.rs b/clippy_lints/src/matches/match_same_arms.rs
index e32ef9933af..3e11016602b 100644
--- a/clippy_lints/src/matches/match_same_arms.rs
+++ b/clippy_lints/src/matches/match_same_arms.rs
@@ -135,7 +135,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>]) {
                     diag.span_suggestion(
                         keep_arm.pat.span,
                         "try merging the arm patterns",
-                        format!("{} | {}", keep_pat_snip, move_pat_snip),
+                        format!("{keep_pat_snip} | {move_pat_snip}"),
                         Applicability::MaybeIncorrect,
                     )
                     .help("or try changing either arm body")
diff --git a/clippy_lints/src/matches/match_single_binding.rs b/clippy_lints/src/matches/match_single_binding.rs
index 5ae4a65acaf..68682cedf1d 100644
--- a/clippy_lints/src/matches/match_single_binding.rs
+++ b/clippy_lints/src/matches/match_single_binding.rs
@@ -75,12 +75,11 @@ pub(crate) fn check<'a>(cx: &LateContext<'a>, ex: &Expr<'a>, arms: &[Arm<'_>], e
                 Some(AssignmentExpr::Local { span, pat_span }) => (
                     span,
                     format!(
-                        "let {} = {};\n{}let {} = {};",
+                        "let {} = {};\n{}let {} = {snippet_body};",
                         snippet_with_applicability(cx, bind_names, "..", &mut applicability),
                         snippet_with_applicability(cx, matched_vars, "..", &mut applicability),
                         " ".repeat(indent_of(cx, expr.span).unwrap_or(0)),
-                        snippet_with_applicability(cx, pat_span, "..", &mut applicability),
-                        snippet_body
+                        snippet_with_applicability(cx, pat_span, "..", &mut applicability)
                     ),
                 ),
                 None => {
@@ -110,10 +109,8 @@ pub(crate) fn check<'a>(cx: &LateContext<'a>, ex: &Expr<'a>, arms: &[Arm<'_>], e
             if ex.can_have_side_effects() {
                 let indent = " ".repeat(indent_of(cx, expr.span).unwrap_or(0));
                 let sugg = format!(
-                    "{};\n{}{}",
-                    snippet_with_applicability(cx, ex.span, "..", &mut applicability),
-                    indent,
-                    snippet_body
+                    "{};\n{indent}{snippet_body}",
+                    snippet_with_applicability(cx, ex.span, "..", &mut applicability)
                 );
 
                 span_lint_and_sugg(
@@ -178,10 +175,10 @@ fn sugg_with_curlies<'a>(
     let (mut cbrace_start, mut cbrace_end) = (String::new(), String::new());
     if let Some(parent_expr) = get_parent_expr(cx, match_expr) {
         if let ExprKind::Closure { .. } = parent_expr.kind {
-            cbrace_end = format!("\n{}}}", indent);
+            cbrace_end = format!("\n{indent}}}");
             // Fix body indent due to the closure
             indent = " ".repeat(indent_of(cx, bind_names).unwrap_or(0));
-            cbrace_start = format!("{{\n{}", indent);
+            cbrace_start = format!("{{\n{indent}");
         }
     }
 
@@ -190,10 +187,10 @@ fn sugg_with_curlies<'a>(
     let parent_node_id = cx.tcx.hir().get_parent_node(match_expr.hir_id);
     if let Node::Arm(arm) = &cx.tcx.hir().get(parent_node_id) {
         if let ExprKind::Match(..) = arm.body.kind {
-            cbrace_end = format!("\n{}}}", indent);
+            cbrace_end = format!("\n{indent}}}");
             // Fix body indent due to the match
             indent = " ".repeat(indent_of(cx, bind_names).unwrap_or(0));
-            cbrace_start = format!("{{\n{}", indent);
+            cbrace_start = format!("{{\n{indent}");
         }
     }
 
@@ -204,13 +201,8 @@ fn sugg_with_curlies<'a>(
     });
 
     format!(
-        "{}let {} = {};\n{}{}{}{}",
-        cbrace_start,
+        "{cbrace_start}let {} = {};\n{indent}{assignment_str}{snippet_body}{cbrace_end}",
         snippet_with_applicability(cx, bind_names, "..", applicability),
-        snippet_with_applicability(cx, matched_vars, "..", applicability),
-        indent,
-        assignment_str,
-        snippet_body,
-        cbrace_end
+        snippet_with_applicability(cx, matched_vars, "..", applicability)
     )
 }
diff --git a/clippy_lints/src/matches/match_str_case_mismatch.rs b/clippy_lints/src/matches/match_str_case_mismatch.rs
index 1e80b6cf2d8..6647322caa3 100644
--- a/clippy_lints/src/matches/match_str_case_mismatch.rs
+++ b/clippy_lints/src/matches/match_str_case_mismatch.rs
@@ -118,8 +118,8 @@ fn lint(cx: &LateContext<'_>, case_method: &CaseMethod, bad_case_span: Span, bad
         MATCH_STR_CASE_MISMATCH,
         bad_case_span,
         "this `match` arm has a differing case than its expression",
-        &format!("consider changing the case of this arm to respect `{}`", method_str),
-        format!("\"{}\"", suggestion),
+        &format!("consider changing the case of this arm to respect `{method_str}`"),
+        format!("\"{suggestion}\""),
         Applicability::MachineApplicable,
     );
 }
diff --git a/clippy_lints/src/matches/match_wild_err_arm.rs b/clippy_lints/src/matches/match_wild_err_arm.rs
index a3aa2e4b389..42f1e2629d4 100644
--- a/clippy_lints/src/matches/match_wild_err_arm.rs
+++ b/clippy_lints/src/matches/match_wild_err_arm.rs
@@ -38,7 +38,7 @@ pub(crate) fn check<'tcx>(cx: &LateContext<'tcx>, ex: &Expr<'tcx>, arms: &[Arm<'
                             span_lint_and_note(cx,
                                 MATCH_WILD_ERR_ARM,
                                 arm.pat.span,
-                                &format!("`Err({})` matches all errors", ident_bind_name),
+                                &format!("`Err({ident_bind_name})` matches all errors"),
                                 None,
                                 "match each error separately or use the error output, or use `.expect(msg)` if the error case is unreachable",
                             );
diff --git a/clippy_lints/src/matches/redundant_pattern_match.rs b/clippy_lints/src/matches/redundant_pattern_match.rs
index f7443471e31..343b1d058b4 100644
--- a/clippy_lints/src/matches/redundant_pattern_match.rs
+++ b/clippy_lints/src/matches/redundant_pattern_match.rs
@@ -138,7 +138,7 @@ fn find_sugg_for_if_let<'tcx>(
         cx,
         REDUNDANT_PATTERN_MATCHING,
         let_pat.span,
-        &format!("redundant pattern matching, consider using `{}`", good_method),
+        &format!("redundant pattern matching, consider using `{good_method}`"),
         |diag| {
             // if/while let ... = ... { ... }
             // ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -162,7 +162,7 @@ fn find_sugg_for_if_let<'tcx>(
                 .maybe_par()
                 .to_string();
 
-            diag.span_suggestion(span, "try this", format!("{} {}.{}", keyword, sugg, good_method), app);
+            diag.span_suggestion(span, "try this", format!("{keyword} {sugg}.{good_method}"), app);
 
             if needs_drop {
                 diag.note("this will change drop order of the result, as well as all temporaries");
@@ -252,12 +252,12 @@ pub(super) fn check_match<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, op
                 cx,
                 REDUNDANT_PATTERN_MATCHING,
                 expr.span,
-                &format!("redundant pattern matching, consider using `{}`", good_method),
+                &format!("redundant pattern matching, consider using `{good_method}`"),
                 |diag| {
                     diag.span_suggestion(
                         span,
                         "try this",
-                        format!("{}.{}", snippet(cx, result_expr.span, "_"), good_method),
+                        format!("{}.{good_method}", snippet(cx, result_expr.span, "_")),
                         Applicability::MaybeIncorrect, // snippet
                     );
                 },
diff --git a/clippy_lints/src/matches/significant_drop_in_scrutinee.rs b/clippy_lints/src/matches/significant_drop_in_scrutinee.rs
index 86a9df03497..85269e533a0 100644
--- a/clippy_lints/src/matches/significant_drop_in_scrutinee.rs
+++ b/clippy_lints/src/matches/significant_drop_in_scrutinee.rs
@@ -50,13 +50,13 @@ fn set_diagnostic<'tcx>(diag: &mut Diagnostic, cx: &LateContext<'tcx>, expr: &'t
     let trailing_indent = " ".repeat(indent_of(cx, found.found_span).unwrap_or(0));
 
     let replacement = if found.lint_suggestion == LintSuggestion::MoveAndDerefToCopy {
-        format!("let value = *{};\n{}", original, trailing_indent)
+        format!("let value = *{original};\n{trailing_indent}")
     } else if found.is_unit_return_val {
         // If the return value of the expression to be moved is unit, then we don't need to
         // capture the result in a temporary -- we can just replace it completely with `()`.
-        format!("{};\n{}", original, trailing_indent)
+        format!("{original};\n{trailing_indent}")
     } else {
-        format!("let value = {};\n{}", original, trailing_indent)
+        format!("let value = {original};\n{trailing_indent}")
     };
 
     let suggestion_message = if found.lint_suggestion == LintSuggestion::MoveOnly {
diff --git a/clippy_lints/src/matches/single_match.rs b/clippy_lints/src/matches/single_match.rs
index 38df69eeb37..6314959f818 100644
--- a/clippy_lints/src/matches/single_match.rs
+++ b/clippy_lints/src/matches/single_match.rs
@@ -99,23 +99,21 @@ fn report_single_pattern(
 
             let msg = "you seem to be trying to use `match` for an equality check. Consider using `if`";
             let sugg = format!(
-                "if {} == {}{} {}{}",
+                "if {} == {}{} {}{els_str}",
                 snippet(cx, ex.span, ".."),
                 // PartialEq for different reference counts may not exist.
                 "&".repeat(ref_count_diff),
                 snippet(cx, arms[0].pat.span, ".."),
                 expr_block(cx, arms[0].body, None, "..", Some(expr.span)),
-                els_str,
             );
             (msg, sugg)
         } else {
             let msg = "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`";
             let sugg = format!(
-                "if let {} = {} {}{}",
+                "if let {} = {} {}{els_str}",
                 snippet(cx, arms[0].pat.span, ".."),
                 snippet(cx, ex.span, ".."),
                 expr_block(cx, arms[0].body, None, "..", Some(expr.span)),
-                els_str,
             );
             (msg, sugg)
         }
diff --git a/clippy_lints/src/matches/try_err.rs b/clippy_lints/src/matches/try_err.rs
index 663277d1136..a3ec1ff2482 100644
--- a/clippy_lints/src/matches/try_err.rs
+++ b/clippy_lints/src/matches/try_err.rs
@@ -61,9 +61,9 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, scrutine
                 "return "
             };
             let suggestion = if err_ty == expr_err_ty {
-                format!("{}{}{}{}", ret_prefix, prefix, origin_snippet, suffix)
+                format!("{ret_prefix}{prefix}{origin_snippet}{suffix}")
             } else {
-                format!("{}{}{}.into(){}", ret_prefix, prefix, origin_snippet, suffix)
+                format!("{ret_prefix}{prefix}{origin_snippet}.into(){suffix}")
             };
 
             span_lint_and_sugg(
diff --git a/clippy_lints/src/methods/bind_instead_of_map.rs b/clippy_lints/src/methods/bind_instead_of_map.rs
index 22f5635a5bc..cc26b0f7fa8 100644
--- a/clippy_lints/src/methods/bind_instead_of_map.rs
+++ b/clippy_lints/src/methods/bind_instead_of_map.rs
@@ -85,7 +85,7 @@ pub(crate) trait BindInsteadOfMap {
 
                 let closure_args_snip = snippet(cx, closure_args_span, "..");
                 let option_snip = snippet(cx, recv.span, "..");
-                let note = format!("{}.{}({} {})", option_snip, Self::GOOD_METHOD_NAME, closure_args_snip, some_inner_snip);
+                let note = format!("{option_snip}.{}({closure_args_snip} {some_inner_snip})", Self::GOOD_METHOD_NAME);
                 span_lint_and_sugg(
                     cx,
                     BIND_INSTEAD_OF_MAP,
diff --git a/clippy_lints/src/methods/bytes_nth.rs b/clippy_lints/src/methods/bytes_nth.rs
index 44857d61fef..2e96346be97 100644
--- a/clippy_lints/src/methods/bytes_nth.rs
+++ b/clippy_lints/src/methods/bytes_nth.rs
@@ -22,7 +22,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, recv: &'tcx E
         cx,
         BYTES_NTH,
         expr.span,
-        &format!("called `.bytes().nth()` on a `{}`", caller_type),
+        &format!("called `.bytes().nth()` on a `{caller_type}`"),
         "try",
         format!(
             "{}.as_bytes().get({})",
diff --git a/clippy_lints/src/methods/chars_cmp.rs b/clippy_lints/src/methods/chars_cmp.rs
index b2bc1ad5c9e..56b7fbb9d4b 100644
--- a/clippy_lints/src/methods/chars_cmp.rs
+++ b/clippy_lints/src/methods/chars_cmp.rs
@@ -33,12 +33,11 @@ pub(super) fn check(
                 cx,
                 lint,
                 info.expr.span,
-                &format!("you should use the `{}` method", suggest),
+                &format!("you should use the `{suggest}` method"),
                 "like this",
-                format!("{}{}.{}({})",
+                format!("{}{}.{suggest}({})",
                         if info.eq { "" } else { "!" },
                         snippet_with_applicability(cx, args[0].0.span, "..", &mut applicability),
-                        suggest,
                         snippet_with_applicability(cx, arg_char.span, "..", &mut applicability)),
                 applicability,
             );
diff --git a/clippy_lints/src/methods/chars_cmp_with_unwrap.rs b/clippy_lints/src/methods/chars_cmp_with_unwrap.rs
index b85bfec2b12..7e808760663 100644
--- a/clippy_lints/src/methods/chars_cmp_with_unwrap.rs
+++ b/clippy_lints/src/methods/chars_cmp_with_unwrap.rs
@@ -26,12 +26,11 @@ pub(super) fn check<'tcx>(
                 cx,
                 lint,
                 info.expr.span,
-                &format!("you should use the `{}` method", suggest),
+                &format!("you should use the `{suggest}` method"),
                 "like this",
-                format!("{}{}.{}('{}')",
+                format!("{}{}.{suggest}('{}')",
                         if info.eq { "" } else { "!" },
                         snippet_with_applicability(cx, args[0].0.span, "..", &mut applicability),
-                        suggest,
                         c.escape_default()),
                 applicability,
             );
diff --git a/clippy_lints/src/methods/clone_on_copy.rs b/clippy_lints/src/methods/clone_on_copy.rs
index 7ab6b84c207..7c7938dd2e8 100644
--- a/clippy_lints/src/methods/clone_on_copy.rs
+++ b/clippy_lints/src/methods/clone_on_copy.rs
@@ -49,8 +49,7 @@ pub(super) fn check(
                 expr.span,
                 &format!(
                     "using `clone` on a double-reference; \
-                    this will copy the reference of type `{}` instead of cloning the inner type",
-                    ty
+                    this will copy the reference of type `{ty}` instead of cloning the inner type"
                 ),
                 |diag| {
                     if let Some(snip) = sugg::Sugg::hir_opt(cx, arg) {
@@ -62,11 +61,11 @@ pub(super) fn check(
                         }
                         let refs = "&".repeat(n + 1);
                         let derefs = "*".repeat(n);
-                        let explicit = format!("<{}{}>::clone({})", refs, ty, snip);
+                        let explicit = format!("<{refs}{ty}>::clone({snip})");
                         diag.span_suggestion(
                             expr.span,
                             "try dereferencing it",
-                            format!("{}({}{}).clone()", refs, derefs, snip.deref()),
+                            format!("{refs}({derefs}{}).clone()", snip.deref()),
                             Applicability::MaybeIncorrect,
                         );
                         diag.span_suggestion(
@@ -121,16 +120,16 @@ pub(super) fn check(
         let (help, sugg) = if deref_count == 0 {
             ("try removing the `clone` call", snip.into())
         } else if parent_is_suffix_expr {
-            ("try dereferencing it", format!("({}{})", "*".repeat(deref_count), snip))
+            ("try dereferencing it", format!("({}{snip})", "*".repeat(deref_count)))
         } else {
-            ("try dereferencing it", format!("{}{}", "*".repeat(deref_count), snip))
+            ("try dereferencing it", format!("{}{snip}", "*".repeat(deref_count)))
         };
 
         span_lint_and_sugg(
             cx,
             CLONE_ON_COPY,
             expr.span,
-            &format!("using `clone` on type `{}` which implements the `Copy` trait", ty),
+            &format!("using `clone` on type `{ty}` which implements the `Copy` trait"),
             help,
             sugg,
             app,
diff --git a/clippy_lints/src/methods/clone_on_ref_ptr.rs b/clippy_lints/src/methods/clone_on_ref_ptr.rs
index f82ca891200..355f53532e2 100644
--- a/clippy_lints/src/methods/clone_on_ref_ptr.rs
+++ b/clippy_lints/src/methods/clone_on_ref_ptr.rs
@@ -41,7 +41,7 @@ pub(super) fn check(
             expr.span,
             "using `.clone()` on a ref-counted pointer",
             "try this",
-            format!("{}::<{}>::clone(&{})", caller_type, subst.type_at(0), snippet),
+            format!("{caller_type}::<{}>::clone(&{snippet})", subst.type_at(0)),
             Applicability::Unspecified, // Sometimes unnecessary ::<_> after Rc/Arc/Weak
         );
     }
diff --git a/clippy_lints/src/methods/expect_fun_call.rs b/clippy_lints/src/methods/expect_fun_call.rs
index bd846d71d46..d0cf411dfd3 100644
--- a/clippy_lints/src/methods/expect_fun_call.rs
+++ b/clippy_lints/src/methods/expect_fun_call.rs
@@ -143,9 +143,9 @@ pub(super) fn check<'tcx>(
             cx,
             EXPECT_FUN_CALL,
             span_replace_word,
-            &format!("use of `{}` followed by a function call", name),
+            &format!("use of `{name}` followed by a function call"),
             "try this",
-            format!("unwrap_or_else({} panic!({}))", closure_args, sugg),
+            format!("unwrap_or_else({closure_args} panic!({sugg}))"),
             applicability,
         );
         return;
@@ -160,12 +160,9 @@ pub(super) fn check<'tcx>(
         cx,
         EXPECT_FUN_CALL,
         span_replace_word,
-        &format!("use of `{}` followed by a function call", name),
+        &format!("use of `{name}` followed by a function call"),
         "try this",
-        format!(
-            "unwrap_or_else({} {{ panic!(\"{{}}\", {}) }})",
-            closure_args, arg_root_snippet
-        ),
+        format!("unwrap_or_else({closure_args} {{ panic!(\"{{}}\", {arg_root_snippet}) }})"),
         applicability,
     );
 }
diff --git a/clippy_lints/src/methods/filetype_is_file.rs b/clippy_lints/src/methods/filetype_is_file.rs
index 7b2967feb0f..60f8283c3e0 100644
--- a/clippy_lints/src/methods/filetype_is_file.rs
+++ b/clippy_lints/src/methods/filetype_is_file.rs
@@ -35,7 +35,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr
             span = expr.span;
         }
     }
-    let lint_msg = format!("`{}FileType::is_file()` only {} regular files", lint_unary, verb);
-    let help_msg = format!("use `{}FileType::is_dir()` instead", help_unary);
+    let lint_msg = format!("`{lint_unary}FileType::is_file()` only {verb} regular files");
+    let help_msg = format!("use `{help_unary}FileType::is_dir()` instead");
     span_lint_and_help(cx, FILETYPE_IS_FILE, span, &lint_msg, None, &help_msg);
 }
diff --git a/clippy_lints/src/methods/filter_map_next.rs b/clippy_lints/src/methods/filter_map_next.rs
index 38ec4d8e3ab..ddf8a1f09b8 100644
--- a/clippy_lints/src/methods/filter_map_next.rs
+++ b/clippy_lints/src/methods/filter_map_next.rs
@@ -32,7 +32,7 @@ pub(super) fn check<'tcx>(
                 expr.span,
                 msg,
                 "try this",
-                format!("{}.find_map({})", iter_snippet, filter_snippet),
+                format!("{iter_snippet}.find_map({filter_snippet})"),
                 Applicability::MachineApplicable,
             );
         } else {
diff --git a/clippy_lints/src/methods/filter_next.rs b/clippy_lints/src/methods/filter_next.rs
index bcf8d93b602..edcec0fc101 100644
--- a/clippy_lints/src/methods/filter_next.rs
+++ b/clippy_lints/src/methods/filter_next.rs
@@ -32,7 +32,7 @@ pub(super) fn check<'tcx>(
                 expr.span,
                 msg,
                 "try this",
-                format!("{}.find({})", iter_snippet, filter_snippet),
+                format!("{iter_snippet}.find({filter_snippet})"),
                 Applicability::MachineApplicable,
             );
         } else {
diff --git a/clippy_lints/src/methods/from_iter_instead_of_collect.rs b/clippy_lints/src/methods/from_iter_instead_of_collect.rs
index 6436e28a63c..66dfce3682b 100644
--- a/clippy_lints/src/methods/from_iter_instead_of_collect.rs
+++ b/clippy_lints/src/methods/from_iter_instead_of_collect.rs
@@ -23,7 +23,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::Exp
             // `expr` implements `FromIterator` trait
             let iter_expr = sugg::Sugg::hir(cx, &args[0], "..").maybe_par();
             let turbofish = extract_turbofish(cx, expr, ty);
-            let sugg = format!("{}.collect::<{}>()", iter_expr, turbofish);
+            let sugg = format!("{iter_expr}.collect::<{turbofish}>()");
             span_lint_and_sugg(
                 cx,
                 FROM_ITER_INSTEAD_OF_COLLECT,
@@ -63,7 +63,7 @@ fn extract_turbofish(cx: &LateContext<'_>, expr: &hir::Expr<'_>, ty: Ty<'_>) ->
                             if e == type_specifier { None } else { Some((*e).to_string()) }
                         }).collect::<Vec<_>>();
                         // join and add the type specifier at the end (i.e.: `collections::BTreeSet<u32>`)
-                        format!("{}{}", without_ts.join("::"), type_specifier)
+                        format!("{}{type_specifier}", without_ts.join("::"))
                     } else {
                         // type is not explicitly specified so wildcards are needed
                         // i.e.: 2 wildcards in `std::collections::BTreeMap<&i32, &char>`
@@ -72,7 +72,7 @@ fn extract_turbofish(cx: &LateContext<'_>, expr: &hir::Expr<'_>, ty: Ty<'_>) ->
                         let end = ty_str.find('>').unwrap_or(ty_str.len());
                         let nb_wildcard = ty_str[start..end].split(',').count();
                         let wildcards = format!("_{}", ", _".repeat(nb_wildcard - 1));
-                        format!("{}<{}>", elements.join("::"), wildcards)
+                        format!("{}<{wildcards}>", elements.join("::"))
                     }
                 }
             }
diff --git a/clippy_lints/src/methods/get_first.rs b/clippy_lints/src/methods/get_first.rs
index 4de77de7404..cb17af608a3 100644
--- a/clippy_lints/src/methods/get_first.rs
+++ b/clippy_lints/src/methods/get_first.rs
@@ -29,9 +29,9 @@ pub(super) fn check<'tcx>(
                 cx,
                 GET_FIRST,
                 expr.span,
-                &format!("accessing first element with `{0}.get(0)`", slice_name),
+                &format!("accessing first element with `{slice_name}.get(0)`"),
                 "try",
-                format!("{}.first()", slice_name),
+                format!("{slice_name}.first()"),
                 app,
             );
         }
diff --git a/clippy_lints/src/methods/get_unwrap.rs b/clippy_lints/src/methods/get_unwrap.rs
index 18e08d6ee23..ffc3a4d780e 100644
--- a/clippy_lints/src/methods/get_unwrap.rs
+++ b/clippy_lints/src/methods/get_unwrap.rs
@@ -71,16 +71,11 @@ pub(super) fn check<'tcx>(
         cx,
         GET_UNWRAP,
         span,
-        &format!(
-            "called `.get{0}().unwrap()` on a {1}. Using `[]` is more clear and more concise",
-            mut_str, caller_type
-        ),
+        &format!("called `.get{mut_str}().unwrap()` on a {caller_type}. Using `[]` is more clear and more concise"),
         "try this",
         format!(
-            "{}{}[{}]",
-            borrow_str,
-            snippet_with_applicability(cx, recv.span, "..", &mut applicability),
-            get_args_str
+            "{borrow_str}{}[{get_args_str}]",
+            snippet_with_applicability(cx, recv.span, "..", &mut applicability)
         ),
         applicability,
     );
diff --git a/clippy_lints/src/methods/implicit_clone.rs b/clippy_lints/src/methods/implicit_clone.rs
index 9651a52be4e..429cdc1918d 100644
--- a/clippy_lints/src/methods/implicit_clone.rs
+++ b/clippy_lints/src/methods/implicit_clone.rs
@@ -26,12 +26,12 @@ pub fn check(cx: &LateContext<'_>, method_name: &str, expr: &hir::Expr<'_>, recv
                 cx,
                 IMPLICIT_CLONE,
                 expr.span,
-                &format!("implicitly cloning a `{}` by calling `{}` on its dereferenced type", ty_name, method_name),
+                &format!("implicitly cloning a `{ty_name}` by calling `{method_name}` on its dereferenced type"),
                 "consider using",
                 if ref_count > 1 {
-                    format!("({}{}).clone()", "*".repeat(ref_count - 1), recv_snip)
+                    format!("({}{recv_snip}).clone()", "*".repeat(ref_count - 1))
                 } else {
-                    format!("{}.clone()", recv_snip)
+                    format!("{recv_snip}.clone()")
                 },
                 app,
             );
diff --git a/clippy_lints/src/methods/inefficient_to_string.rs b/clippy_lints/src/methods/inefficient_to_string.rs
index e1c9b5248a8..e5dc3711b0b 100644
--- a/clippy_lints/src/methods/inefficient_to_string.rs
+++ b/clippy_lints/src/methods/inefficient_to_string.rs
@@ -34,18 +34,17 @@ pub fn check<'tcx>(
                 cx,
                 INEFFICIENT_TO_STRING,
                 expr.span,
-                &format!("calling `to_string` on `{}`", arg_ty),
+                &format!("calling `to_string` on `{arg_ty}`"),
                 |diag| {
                     diag.help(&format!(
-                        "`{}` implements `ToString` through a slower blanket impl, but `{}` has a fast specialization of `ToString`",
-                        self_ty, deref_self_ty
+                        "`{self_ty}` implements `ToString` through a slower blanket impl, but `{deref_self_ty}` has a fast specialization of `ToString`"
                     ));
                     let mut applicability = Applicability::MachineApplicable;
                     let arg_snippet = snippet_with_applicability(cx, receiver.span, "..", &mut applicability);
                     diag.span_suggestion(
                         expr.span,
                         "try dereferencing the receiver",
-                        format!("({}{}).to_string()", "*".repeat(deref_count), arg_snippet),
+                        format!("({}{arg_snippet}).to_string()", "*".repeat(deref_count)),
                         applicability,
                     );
                 },
diff --git a/clippy_lints/src/methods/into_iter_on_ref.rs b/clippy_lints/src/methods/into_iter_on_ref.rs
index 11e76841e9f..be56b63506a 100644
--- a/clippy_lints/src/methods/into_iter_on_ref.rs
+++ b/clippy_lints/src/methods/into_iter_on_ref.rs
@@ -30,8 +30,7 @@ pub(super) fn check(
                 INTO_ITER_ON_REF,
                 method_span,
                 &format!(
-                    "this `.into_iter()` call is equivalent to `.{}()` and will not consume the `{}`",
-                    method_name, kind,
+                    "this `.into_iter()` call is equivalent to `.{method_name}()` and will not consume the `{kind}`",
                 ),
                 "call directly",
                 method_name.to_string(),
diff --git a/clippy_lints/src/methods/is_digit_ascii_radix.rs b/clippy_lints/src/methods/is_digit_ascii_radix.rs
index aa176dcc8b4..304024e8066 100644
--- a/clippy_lints/src/methods/is_digit_ascii_radix.rs
+++ b/clippy_lints/src/methods/is_digit_ascii_radix.rs
@@ -37,12 +37,11 @@ pub(super) fn check<'tcx>(
             cx,
             IS_DIGIT_ASCII_RADIX,
             expr.span,
-            &format!("use of `char::is_digit` with literal radix of {}", num),
+            &format!("use of `char::is_digit` with literal radix of {num}"),
             "try",
             format!(
-                "{}.{}()",
-                snippet_with_applicability(cx, self_arg.span, "..", &mut applicability),
-                replacement
+                "{}.{replacement}()",
+                snippet_with_applicability(cx, self_arg.span, "..", &mut applicability)
             ),
             applicability,
         );
diff --git a/clippy_lints/src/methods/iter_cloned_collect.rs b/clippy_lints/src/methods/iter_cloned_collect.rs
index 30d56113c6c..bde6f92b076 100644
--- a/clippy_lints/src/methods/iter_cloned_collect.rs
+++ b/clippy_lints/src/methods/iter_cloned_collect.rs
@@ -20,8 +20,8 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, method_name: &str, expr: &hir:
                 cx,
                 ITER_CLONED_COLLECT,
                 to_replace,
-                &format!("called `iter().{}().collect()` on a slice to create a `Vec`. Calling `to_vec()` is both faster and \
-                more readable", method_name),
+                &format!("called `iter().{method_name}().collect()` on a slice to create a `Vec`. Calling `to_vec()` is both faster and \
+                more readable"),
                 "try",
                 ".to_vec()".to_string(),
                 Applicability::MachineApplicable,
diff --git a/clippy_lints/src/methods/iter_count.rs b/clippy_lints/src/methods/iter_count.rs
index 052be3d8ee7..bcddc7c786a 100644
--- a/clippy_lints/src/methods/iter_count.rs
+++ b/clippy_lints/src/methods/iter_count.rs
@@ -37,7 +37,7 @@ pub(crate) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, recv: &'tcx E
         cx,
         ITER_COUNT,
         expr.span,
-        &format!("called `.{}().count()` on a `{}`", iter_method, caller_type),
+        &format!("called `.{iter_method}().count()` on a `{caller_type}`"),
         "try",
         format!(
             "{}.len()",
diff --git a/clippy_lints/src/methods/iter_kv_map.rs b/clippy_lints/src/methods/iter_kv_map.rs
index a7eecabd684..2244ebfb129 100644
--- a/clippy_lints/src/methods/iter_kv_map.rs
+++ b/clippy_lints/src/methods/iter_kv_map.rs
@@ -54,9 +54,9 @@ pub(super) fn check<'tcx>(
                         cx,
                         ITER_KV_MAP,
                         expr.span,
-                        &format!("iterating on a map's {}s", replacement_kind),
+                        &format!("iterating on a map's {replacement_kind}s"),
                         "try",
-                        format!("{}.{}{}s()", recv_snippet, into_prefix, replacement_kind),
+                        format!("{recv_snippet}.{into_prefix}{replacement_kind}s()"),
                         applicability,
                     );
                 } else {
@@ -64,9 +64,9 @@ pub(super) fn check<'tcx>(
                         cx,
                         ITER_KV_MAP,
                         expr.span,
-                        &format!("iterating on a map's {}s", replacement_kind),
+                        &format!("iterating on a map's {replacement_kind}s"),
                         "try",
-                        format!("{}.{}{}s().map(|{}| {})", recv_snippet, into_prefix, replacement_kind, binded_ident,
+                        format!("{recv_snippet}.{into_prefix}{replacement_kind}s().map(|{binded_ident}| {})",
                             snippet_with_applicability(cx, body_expr.span, "/* body */", &mut applicability)),
                         applicability,
                     );
diff --git a/clippy_lints/src/methods/iter_next_slice.rs b/clippy_lints/src/methods/iter_next_slice.rs
index b8d1dabe007..83c1bf20346 100644
--- a/clippy_lints/src/methods/iter_next_slice.rs
+++ b/clippy_lints/src/methods/iter_next_slice.rs
@@ -37,7 +37,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, cal
                 let suggest = if start_idx == 0 {
                     format!("{}.first()", snippet_with_applicability(cx, caller_var.span, "..", &mut applicability))
                 } else {
-                    format!("{}.get({})", snippet_with_applicability(cx, caller_var.span, "..", &mut applicability), start_idx)
+                    format!("{}.get({start_idx})", snippet_with_applicability(cx, caller_var.span, "..", &mut applicability))
                 };
                 span_lint_and_sugg(
                     cx,
diff --git a/clippy_lints/src/methods/iter_nth.rs b/clippy_lints/src/methods/iter_nth.rs
index 80ca4c94219..ceee12784cb 100644
--- a/clippy_lints/src/methods/iter_nth.rs
+++ b/clippy_lints/src/methods/iter_nth.rs
@@ -32,8 +32,8 @@ pub(super) fn check<'tcx>(
         cx,
         ITER_NTH,
         expr.span,
-        &format!("called `.iter{0}().nth()` on a {1}", mut_str, caller_type),
+        &format!("called `.iter{mut_str}().nth()` on a {caller_type}"),
         None,
-        &format!("calling `.get{}()` is both faster and more readable", mut_str),
+        &format!("calling `.get{mut_str}()` is both faster and more readable"),
     );
 }
diff --git a/clippy_lints/src/methods/iter_with_drain.rs b/clippy_lints/src/methods/iter_with_drain.rs
index a669cbbbcc6..3da230e12d7 100644
--- a/clippy_lints/src/methods/iter_with_drain.rs
+++ b/clippy_lints/src/methods/iter_with_drain.rs
@@ -22,7 +22,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'_>, span
             cx,
             ITER_WITH_DRAIN,
             span.with_hi(expr.span.hi()),
-            &format!("`drain(..)` used on a `{}`", ty_name),
+            &format!("`drain(..)` used on a `{ty_name}`"),
             "try this",
             "into_iter()".to_string(),
             Applicability::MaybeIncorrect,
diff --git a/clippy_lints/src/methods/manual_ok_or.rs b/clippy_lints/src/methods/manual_ok_or.rs
index ffd2f4a38b8..c5c0ace7729 100644
--- a/clippy_lints/src/methods/manual_ok_or.rs
+++ b/clippy_lints/src/methods/manual_ok_or.rs
@@ -37,9 +37,7 @@ pub(super) fn check<'tcx>(
                 "this pattern reimplements `Option::ok_or`",
                 "replace with",
                 format!(
-                    "{}.ok_or({})",
-                    recv_snippet,
-                    reindented_err_arg_snippet
+                    "{recv_snippet}.ok_or({reindented_err_arg_snippet})"
                 ),
                 Applicability::MachineApplicable,
             );
diff --git a/clippy_lints/src/methods/manual_saturating_arithmetic.rs b/clippy_lints/src/methods/manual_saturating_arithmetic.rs
index 0fe510beaa0..ec694cf6882 100644
--- a/clippy_lints/src/methods/manual_saturating_arithmetic.rs
+++ b/clippy_lints/src/methods/manual_saturating_arithmetic.rs
@@ -57,11 +57,10 @@ pub fn check(
         super::MANUAL_SATURATING_ARITHMETIC,
         expr.span,
         "manual saturating arithmetic",
-        &format!("try using `saturating_{}`", arith),
+        &format!("try using `saturating_{arith}`"),
         format!(
-            "{}.saturating_{}({})",
+            "{}.saturating_{arith}({})",
             snippet_with_applicability(cx, arith_lhs.span, "..", &mut applicability),
-            arith,
             snippet_with_applicability(cx, arith_rhs.span, "..", &mut applicability),
         ),
         applicability,
diff --git a/clippy_lints/src/methods/manual_str_repeat.rs b/clippy_lints/src/methods/manual_str_repeat.rs
index 46d2fc493f8..67e504af161 100644
--- a/clippy_lints/src/methods/manual_str_repeat.rs
+++ b/clippy_lints/src/methods/manual_str_repeat.rs
@@ -91,7 +91,7 @@ pub(super) fn check(
                 collect_expr.span,
                 "manual implementation of `str::repeat` using iterators",
                 "try this",
-                format!("{}.repeat({})", val_str, count_snip),
+                format!("{val_str}.repeat({count_snip})"),
                 app
             )
         }
diff --git a/clippy_lints/src/methods/map_clone.rs b/clippy_lints/src/methods/map_clone.rs
index 8261ef5e1ce..7ce14ec080b 100644
--- a/clippy_lints/src/methods/map_clone.rs
+++ b/clippy_lints/src/methods/map_clone.rs
@@ -111,11 +111,10 @@ fn lint_explicit_closure(cx: &LateContext<'_>, replace: Span, root: Span, is_cop
         MAP_CLONE,
         replace,
         message,
-        &format!("consider calling the dedicated `{}` method", sugg_method),
+        &format!("consider calling the dedicated `{sugg_method}` method"),
         format!(
-            "{}.{}()",
+            "{}.{sugg_method}()",
             snippet_with_applicability(cx, root, "..", &mut applicability),
-            sugg_method,
         ),
         applicability,
     );
diff --git a/clippy_lints/src/methods/map_flatten.rs b/clippy_lints/src/methods/map_flatten.rs
index 13853dec99d..361ffcb5ef3 100644
--- a/clippy_lints/src/methods/map_flatten.rs
+++ b/clippy_lints/src/methods/map_flatten.rs
@@ -20,12 +20,9 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'_>, map_
             cx,
             MAP_FLATTEN,
             expr.span.with_lo(map_span.lo()),
-            &format!("called `map(..).flatten()` on `{}`", caller_ty_name),
-            &format!(
-                "try replacing `map` with `{}` and remove the `.flatten()`",
-                method_to_use
-            ),
-            format!("{}({})", method_to_use, closure_snippet),
+            &format!("called `map(..).flatten()` on `{caller_ty_name}`"),
+            &format!("try replacing `map` with `{method_to_use}` and remove the `.flatten()`"),
+            format!("{method_to_use}({closure_snippet})"),
             applicability,
         );
     }
diff --git a/clippy_lints/src/methods/map_identity.rs b/clippy_lints/src/methods/map_identity.rs
index 862a9578e6f..0f25ef82ed4 100644
--- a/clippy_lints/src/methods/map_identity.rs
+++ b/clippy_lints/src/methods/map_identity.rs
@@ -30,7 +30,7 @@ pub(super) fn check(
                 MAP_IDENTITY,
                 sugg_span,
                 "unnecessary map of the identity function",
-                &format!("remove the call to `{}`", name),
+                &format!("remove the call to `{name}`"),
                 String::new(),
                 Applicability::MachineApplicable,
             )
diff --git a/clippy_lints/src/methods/map_unwrap_or.rs b/clippy_lints/src/methods/map_unwrap_or.rs
index 4a8e7ce4ddb..74fdead216b 100644
--- a/clippy_lints/src/methods/map_unwrap_or.rs
+++ b/clippy_lints/src/methods/map_unwrap_or.rs
@@ -65,7 +65,7 @@ pub(super) fn check<'tcx>(
                 expr.span,
                 msg,
                 "try this",
-                format!("{}.map_or_else({}, {})", var_snippet, unwrap_snippet, map_snippet),
+                format!("{var_snippet}.map_or_else({unwrap_snippet}, {map_snippet})"),
                 Applicability::MachineApplicable,
             );
             return true;
diff --git a/clippy_lints/src/methods/option_as_ref_deref.rs b/clippy_lints/src/methods/option_as_ref_deref.rs
index c409268de76..6fb92d1c663 100644
--- a/clippy_lints/src/methods/option_as_ref_deref.rs
+++ b/clippy_lints/src/methods/option_as_ref_deref.rs
@@ -98,13 +98,12 @@ pub(super) fn check<'tcx>(
             format!(".as_ref().map({})", snippet(cx, map_arg.span, ".."))
         };
         let method_hint = if is_mut { "as_deref_mut" } else { "as_deref" };
-        let hint = format!("{}.{}()", snippet(cx, as_ref_recv.span, ".."), method_hint);
-        let suggestion = format!("try using {} instead", method_hint);
+        let hint = format!("{}.{method_hint}()", snippet(cx, as_ref_recv.span, ".."));
+        let suggestion = format!("try using {method_hint} instead");
 
         let msg = format!(
-            "called `{0}` on an Option value. This can be done more directly \
-            by calling `{1}` instead",
-            current_method, hint
+            "called `{current_method}` on an Option value. This can be done more directly \
+            by calling `{hint}` instead"
         );
         span_lint_and_sugg(
             cx,
diff --git a/clippy_lints/src/methods/option_map_or_none.rs b/clippy_lints/src/methods/option_map_or_none.rs
index 6657cdccd01..76572425346 100644
--- a/clippy_lints/src/methods/option_map_or_none.rs
+++ b/clippy_lints/src/methods/option_map_or_none.rs
@@ -87,7 +87,7 @@ pub(super) fn check<'tcx>(
                     expr.span,
                     msg,
                     "try using `map` instead",
-                    format!("{0}.map({1} {2})", self_snippet, arg_snippet,func_snippet),
+                    format!("{self_snippet}.map({arg_snippet} {func_snippet})"),
                     Applicability::MachineApplicable,
                 );
             }
@@ -102,7 +102,7 @@ pub(super) fn check<'tcx>(
             expr.span,
             msg,
             "try using `and_then` instead",
-            format!("{0}.and_then({1})", self_snippet, func_snippet),
+            format!("{self_snippet}.and_then({func_snippet})"),
             Applicability::MachineApplicable,
         );
     } else if f_arg_is_some {
@@ -115,7 +115,7 @@ pub(super) fn check<'tcx>(
             expr.span,
             msg,
             "try using `ok` instead",
-            format!("{0}.ok()", self_snippet),
+            format!("{self_snippet}.ok()"),
             Applicability::MachineApplicable,
         );
     }
diff --git a/clippy_lints/src/methods/option_map_unwrap_or.rs b/clippy_lints/src/methods/option_map_unwrap_or.rs
index 3c4002a3aef..30421a6dd5a 100644
--- a/clippy_lints/src/methods/option_map_unwrap_or.rs
+++ b/clippy_lints/src/methods/option_map_unwrap_or.rs
@@ -65,9 +65,8 @@ pub(super) fn check<'tcx>(
             "map_or(<a>, <f>)"
         };
         let msg = &format!(
-            "called `map(<f>).unwrap_or({})` on an `Option` value. \
-            This can be done more directly by calling `{}` instead",
-            arg, suggest
+            "called `map(<f>).unwrap_or({arg})` on an `Option` value. \
+            This can be done more directly by calling `{suggest}` instead"
         );
 
         span_lint_and_then(cx, MAP_UNWRAP_OR, expr.span, msg, |diag| {
@@ -82,10 +81,10 @@ pub(super) fn check<'tcx>(
             ];
 
             if !unwrap_snippet_none {
-                suggestion.push((map_arg_span.with_hi(map_arg_span.lo()), format!("{}, ", unwrap_snippet)));
+                suggestion.push((map_arg_span.with_hi(map_arg_span.lo()), format!("{unwrap_snippet}, ")));
             }
 
-            diag.multipart_suggestion(&format!("use `{}` instead", suggest), suggestion, applicability);
+            diag.multipart_suggestion(&format!("use `{suggest}` instead"), suggestion, applicability);
         });
     }
 }
diff --git a/clippy_lints/src/methods/or_fun_call.rs b/clippy_lints/src/methods/or_fun_call.rs
index b43b9258c47..6a35024d036 100644
--- a/clippy_lints/src/methods/or_fun_call.rs
+++ b/clippy_lints/src/methods/or_fun_call.rs
@@ -62,9 +62,9 @@ pub(super) fn check<'tcx>(
                     cx,
                     OR_FUN_CALL,
                     method_span.with_hi(span.hi()),
-                    &format!("use of `{}` followed by a call to `{}`", name, path),
+                    &format!("use of `{name}` followed by a call to `{path}`"),
                     "try this",
-                    format!("{}()", sugg),
+                    format!("{sugg}()"),
                     Applicability::MachineApplicable,
                 );
 
@@ -131,7 +131,7 @@ pub(super) fn check<'tcx>(
 
                     if use_lambda {
                         let l_arg = if fn_has_arguments { "_" } else { "" };
-                        format!("|{}| {}", l_arg, snippet).into()
+                        format!("|{l_arg}| {snippet}").into()
                     } else {
                         snippet
                     }
@@ -141,9 +141,9 @@ pub(super) fn check<'tcx>(
                     cx,
                     OR_FUN_CALL,
                     span_replace_word,
-                    &format!("use of `{}` followed by a function call", name),
+                    &format!("use of `{name}` followed by a function call"),
                     "try this",
-                    format!("{}_{}({})", name, suffix, sugg),
+                    format!("{name}_{suffix}({sugg})"),
                     Applicability::HasPlaceholders,
                 );
             }
diff --git a/clippy_lints/src/methods/search_is_some.rs b/clippy_lints/src/methods/search_is_some.rs
index 7572ba3fe9a..324c9c17b5a 100644
--- a/clippy_lints/src/methods/search_is_some.rs
+++ b/clippy_lints/src/methods/search_is_some.rs
@@ -30,10 +30,7 @@ pub(super) fn check<'tcx>(
     let option_check_method = if is_some { "is_some" } else { "is_none" };
     // lint if caller of search is an Iterator
     if is_trait_method(cx, is_some_recv, sym::Iterator) {
-        let msg = format!(
-            "called `{}()` after searching an `Iterator` with `{}`",
-            option_check_method, search_method
-        );
+        let msg = format!("called `{option_check_method}()` after searching an `Iterator` with `{search_method}`");
         let search_snippet = snippet(cx, search_arg.span, "..");
         if search_snippet.lines().count() <= 1 {
             // suggest `any(|x| ..)` instead of `any(|&x| ..)` for `find(|&x| ..).is_some()`
@@ -86,8 +83,7 @@ pub(super) fn check<'tcx>(
                     &msg,
                     "use `!_.any()` instead",
                     format!(
-                        "!{}.any({})",
-                        iter,
+                        "!{iter}.any({})",
                         any_search_snippet.as_ref().map_or(&*search_snippet, String::as_str)
                     ),
                     applicability,
@@ -119,7 +115,7 @@ pub(super) fn check<'tcx>(
             if is_string_or_str_slice(search_recv);
             if is_string_or_str_slice(search_arg);
             then {
-                let msg = format!("called `{}()` after calling `find()` on a string", option_check_method);
+                let msg = format!("called `{option_check_method}()` after calling `find()` on a string");
                 match option_check_method {
                     "is_some" => {
                         let mut applicability = Applicability::MachineApplicable;
@@ -130,7 +126,7 @@ pub(super) fn check<'tcx>(
                             method_span.with_hi(expr.span.hi()),
                             &msg,
                             "use `contains()` instead",
-                            format!("contains({})", find_arg),
+                            format!("contains({find_arg})"),
                             applicability,
                         );
                     },
@@ -144,7 +140,7 @@ pub(super) fn check<'tcx>(
                             expr.span,
                             &msg,
                             "use `!_.contains()` instead",
-                            format!("!{}.contains({})", string, find_arg),
+                            format!("!{string}.contains({find_arg})"),
                             applicability,
                         );
                     },
diff --git a/clippy_lints/src/methods/single_char_insert_string.rs b/clippy_lints/src/methods/single_char_insert_string.rs
index 18b6b5be175..44a7ad394fa 100644
--- a/clippy_lints/src/methods/single_char_insert_string.rs
+++ b/clippy_lints/src/methods/single_char_insert_string.rs
@@ -14,7 +14,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, receiver: &hir::
         let base_string_snippet =
             snippet_with_applicability(cx, receiver.span.source_callsite(), "_", &mut applicability);
         let pos_arg = snippet_with_applicability(cx, args[0].span, "..", &mut applicability);
-        let sugg = format!("{}.insert({}, {})", base_string_snippet, pos_arg, extension_string);
+        let sugg = format!("{base_string_snippet}.insert({pos_arg}, {extension_string})");
         span_lint_and_sugg(
             cx,
             SINGLE_CHAR_ADD_STR,
diff --git a/clippy_lints/src/methods/single_char_push_string.rs b/clippy_lints/src/methods/single_char_push_string.rs
index 9ea6751956a..0698bd6a0c5 100644
--- a/clippy_lints/src/methods/single_char_push_string.rs
+++ b/clippy_lints/src/methods/single_char_push_string.rs
@@ -13,7 +13,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, receiver: &hir::
     if let Some(extension_string) = get_hint_if_single_char_arg(cx, &args[0], &mut applicability) {
         let base_string_snippet =
             snippet_with_applicability(cx, receiver.span.source_callsite(), "..", &mut applicability);
-        let sugg = format!("{}.push({})", base_string_snippet, extension_string);
+        let sugg = format!("{base_string_snippet}.push({extension_string})");
         span_lint_and_sugg(
             cx,
             SINGLE_CHAR_ADD_STR,
diff --git a/clippy_lints/src/methods/stable_sort_primitive.rs b/clippy_lints/src/methods/stable_sort_primitive.rs
index 91951c65bb3..09c8ca4cbe4 100644
--- a/clippy_lints/src/methods/stable_sort_primitive.rs
+++ b/clippy_lints/src/methods/stable_sort_primitive.rs
@@ -17,11 +17,11 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>, recv: &'tcx
             cx,
             STABLE_SORT_PRIMITIVE,
             e.span,
-            &format!("used `sort` on primitive type `{}`", slice_type),
+            &format!("used `sort` on primitive type `{slice_type}`"),
             |diag| {
                 let mut app = Applicability::MachineApplicable;
                 let recv_snip = snippet_with_context(cx, recv.span, e.span.ctxt(), "..", &mut app).0;
-                diag.span_suggestion(e.span, "try", format!("{}.sort_unstable()", recv_snip), app);
+                diag.span_suggestion(e.span, "try", format!("{recv_snip}.sort_unstable()"), app);
                 diag.note(
                     "an unstable sort typically performs faster without any observable difference for this data type",
                 );
diff --git a/clippy_lints/src/methods/string_extend_chars.rs b/clippy_lints/src/methods/string_extend_chars.rs
index 143dcee3505..6974260f70d 100644
--- a/clippy_lints/src/methods/string_extend_chars.rs
+++ b/clippy_lints/src/methods/string_extend_chars.rs
@@ -34,9 +34,8 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr
             "calling `.extend(_.chars())`",
             "try this",
             format!(
-                "{}.push_str({}{})",
+                "{}.push_str({ref_str}{})",
                 snippet_with_applicability(cx, recv.span, "..", &mut applicability),
-                ref_str,
                 snippet_with_applicability(cx, target.span, "..", &mut applicability)
             ),
             applicability,
diff --git a/clippy_lints/src/methods/suspicious_splitn.rs b/clippy_lints/src/methods/suspicious_splitn.rs
index 55567d8625e..219a9edd657 100644
--- a/clippy_lints/src/methods/suspicious_splitn.rs
+++ b/clippy_lints/src/methods/suspicious_splitn.rs
@@ -24,10 +24,10 @@ pub(super) fn check(cx: &LateContext<'_>, method_name: &str, expr: &Expr<'_>, se
             }
 
             let (msg, note_msg) = if count == 0 {
-                (format!("`{}` called with `0` splits", method_name),
+                (format!("`{method_name}` called with `0` splits"),
                 "the resulting iterator will always return `None`")
             } else {
-                (format!("`{}` called with `1` split", method_name),
+                (format!("`{method_name}` called with `1` split"),
                 if self_ty.is_slice() {
                     "the resulting iterator will always return the entire slice followed by `None`"
                 } else {
diff --git a/clippy_lints/src/methods/suspicious_to_owned.rs b/clippy_lints/src/methods/suspicious_to_owned.rs
index 6b306fbf008..15c1c618c51 100644
--- a/clippy_lints/src/methods/suspicious_to_owned.rs
+++ b/clippy_lints/src/methods/suspicious_to_owned.rs
@@ -24,9 +24,9 @@ pub fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr<'_>) -
                 cx,
                 SUSPICIOUS_TO_OWNED,
                 expr.span,
-                &format!("this `to_owned` call clones the {0} itself and does not cause the {0} contents to become owned", input_type),
+                &format!("this `to_owned` call clones the {input_type} itself and does not cause the {input_type} contents to become owned"),
                 "consider using, depending on intent",
-                format!("{0}.clone()` or `{0}.into_owned()", recv_snip),
+                format!("{recv_snip}.clone()` or `{recv_snip}.into_owned()"),
                 app,
             );
             return true;
diff --git a/clippy_lints/src/methods/unnecessary_filter_map.rs b/clippy_lints/src/methods/unnecessary_filter_map.rs
index 4e8c201f470..ee16982d524 100644
--- a/clippy_lints/src/methods/unnecessary_filter_map.rs
+++ b/clippy_lints/src/methods/unnecessary_filter_map.rs
@@ -54,7 +54,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, arg: &hir::Expr<
                 UNNECESSARY_FIND_MAP
             },
             expr.span,
-            &format!("this `.{}` can be written more simply using `.{}`", name, sugg),
+            &format!("this `.{name}` can be written more simply using `.{sugg}`"),
         );
     }
 }
diff --git a/clippy_lints/src/methods/unnecessary_fold.rs b/clippy_lints/src/methods/unnecessary_fold.rs
index c17ef6809f9..aa87dead38f 100644
--- a/clippy_lints/src/methods/unnecessary_fold.rs
+++ b/clippy_lints/src/methods/unnecessary_fold.rs
@@ -49,15 +49,12 @@ pub(super) fn check(
                 let mut applicability = Applicability::MachineApplicable;
                 let sugg = if replacement_has_args {
                     format!(
-                        "{replacement}(|{s}| {r})",
-                        replacement = replacement_method_name,
-                        s = second_arg_ident,
+                        "{replacement_method_name}(|{second_arg_ident}| {r})",
                         r = snippet_with_applicability(cx, right_expr.span, "EXPR", &mut applicability),
                     )
                 } else {
                     format!(
-                        "{replacement}()",
-                        replacement = replacement_method_name,
+                        "{replacement_method_name}()",
                     )
                 };
 
diff --git a/clippy_lints/src/methods/unnecessary_iter_cloned.rs b/clippy_lints/src/methods/unnecessary_iter_cloned.rs
index 95138c0e25b..1966a85f7a7 100644
--- a/clippy_lints/src/methods/unnecessary_iter_cloned.rs
+++ b/clippy_lints/src/methods/unnecessary_iter_cloned.rs
@@ -68,7 +68,7 @@ pub fn check_for_loop_iter(
                 cx,
                 UNNECESSARY_TO_OWNED,
                 expr.span,
-                &format!("unnecessary use of `{}`", method_name),
+                &format!("unnecessary use of `{method_name}`"),
                 |diag| {
                     // If `check_into_iter_call_arg` called `check_for_loop_iter` because a call to
                     // a `to_owned`-like function was removed, then the next suggestion may be
diff --git a/clippy_lints/src/methods/unnecessary_lazy_eval.rs b/clippy_lints/src/methods/unnecessary_lazy_eval.rs
index a187a8d6016..ec9859fa298 100644
--- a/clippy_lints/src/methods/unnecessary_lazy_eval.rs
+++ b/clippy_lints/src/methods/unnecessary_lazy_eval.rs
@@ -58,8 +58,8 @@ pub(super) fn check<'tcx>(
                     span_lint_and_then(cx, UNNECESSARY_LAZY_EVALUATIONS, expr.span, msg, |diag| {
                         diag.span_suggestion(
                             span,
-                            &format!("use `{}(..)` instead", simplify_using),
-                            format!("{}({})", simplify_using, snippet(cx, body_expr.span, "..")),
+                            &format!("use `{simplify_using}(..)` instead"),
+                            format!("{simplify_using}({})", snippet(cx, body_expr.span, "..")),
                             applicability,
                         );
                     });
diff --git a/clippy_lints/src/methods/unnecessary_to_owned.rs b/clippy_lints/src/methods/unnecessary_to_owned.rs
index 8e9ed33e009..d27831327ac 100644
--- a/clippy_lints/src/methods/unnecessary_to_owned.rs
+++ b/clippy_lints/src/methods/unnecessary_to_owned.rs
@@ -133,12 +133,11 @@ fn check_addr_of_expr(
                     cx,
                     UNNECESSARY_TO_OWNED,
                     parent.span,
-                    &format!("unnecessary use of `{}`", method_name),
+                    &format!("unnecessary use of `{method_name}`"),
                     "use",
                     format!(
-                        "{:&>width$}{}",
+                        "{:&>width$}{receiver_snippet}",
                         "",
-                        receiver_snippet,
                         width = n_target_refs - n_receiver_refs
                     ),
                     Applicability::MachineApplicable,
@@ -155,7 +154,7 @@ fn check_addr_of_expr(
                             cx,
                             UNNECESSARY_TO_OWNED,
                             parent.span,
-                            &format!("unnecessary use of `{}`", method_name),
+                            &format!("unnecessary use of `{method_name}`"),
                             "use",
                             receiver_snippet,
                             Applicability::MachineApplicable,
@@ -165,7 +164,7 @@ fn check_addr_of_expr(
                             cx,
                             UNNECESSARY_TO_OWNED,
                             expr.span.with_lo(receiver.span.hi()),
-                            &format!("unnecessary use of `{}`", method_name),
+                            &format!("unnecessary use of `{method_name}`"),
                             "remove this",
                             String::new(),
                             Applicability::MachineApplicable,
@@ -182,9 +181,9 @@ fn check_addr_of_expr(
                         cx,
                         UNNECESSARY_TO_OWNED,
                         parent.span,
-                        &format!("unnecessary use of `{}`", method_name),
+                        &format!("unnecessary use of `{method_name}`"),
                         "use",
-                        format!("{}.as_ref()", receiver_snippet),
+                        format!("{receiver_snippet}.as_ref()"),
                         Applicability::MachineApplicable,
                     );
                     return true;
@@ -229,9 +228,9 @@ fn check_into_iter_call_arg(
                 cx,
                 UNNECESSARY_TO_OWNED,
                 parent.span,
-                &format!("unnecessary use of `{}`", method_name),
+                &format!("unnecessary use of `{method_name}`"),
                 "use",
-                format!("{}.iter().{}()", receiver_snippet, cloned_or_copied),
+                format!("{receiver_snippet}.iter().{cloned_or_copied}()"),
                 Applicability::MaybeIncorrect,
             );
             return true;
@@ -276,9 +275,9 @@ fn check_other_call_arg<'tcx>(
                 cx,
                 UNNECESSARY_TO_OWNED,
                 maybe_arg.span,
-                &format!("unnecessary use of `{}`", method_name),
+                &format!("unnecessary use of `{method_name}`"),
                 "use",
-                format!("{:&>width$}{}", "", receiver_snippet, width = n_refs),
+                format!("{:&>n_refs$}{receiver_snippet}", ""),
                 Applicability::MachineApplicable,
             );
             return true;
diff --git a/clippy_lints/src/methods/useless_asref.rs b/clippy_lints/src/methods/useless_asref.rs
index ca5d33ee8b0..0380a82411a 100644
--- a/clippy_lints/src/methods/useless_asref.rs
+++ b/clippy_lints/src/methods/useless_asref.rs
@@ -35,7 +35,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, call_name: &str,
                 cx,
                 USELESS_ASREF,
                 expr.span,
-                &format!("this call to `{}` does nothing", call_name),
+                &format!("this call to `{call_name}` does nothing"),
                 "try this",
                 snippet_with_applicability(cx, recvr.span, "..", &mut applicability).to_string(),
                 applicability,
diff --git a/clippy_lints/src/methods/wrong_self_convention.rs b/clippy_lints/src/methods/wrong_self_convention.rs
index 4b368d3ffae..1fbf783b886 100644
--- a/clippy_lints/src/methods/wrong_self_convention.rs
+++ b/clippy_lints/src/methods/wrong_self_convention.rs
@@ -61,20 +61,20 @@ impl Convention {
 impl fmt::Display for Convention {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
         match *self {
-            Self::Eq(this) => format!("`{}`", this).fmt(f),
-            Self::StartsWith(this) => format!("`{}*`", this).fmt(f),
-            Self::EndsWith(this) => format!("`*{}`", this).fmt(f),
-            Self::NotEndsWith(this) => format!("`~{}`", this).fmt(f),
+            Self::Eq(this) => format!("`{this}`").fmt(f),
+            Self::StartsWith(this) => format!("`{this}*`").fmt(f),
+            Self::EndsWith(this) => format!("`*{this}`").fmt(f),
+            Self::NotEndsWith(this) => format!("`~{this}`").fmt(f),
             Self::IsSelfTypeCopy(is_true) => {
                 format!("`self` type is{} `Copy`", if is_true { "" } else { " not" }).fmt(f)
             },
             Self::ImplementsTrait(is_true) => {
                 let (negation, s_suffix) = if is_true { ("", "s") } else { (" does not", "") };
-                format!("method{} implement{} a trait", negation, s_suffix).fmt(f)
+                format!("method{negation} implement{s_suffix} a trait").fmt(f)
             },
             Self::IsTraitItem(is_true) => {
                 let suffix = if is_true { " is" } else { " is not" };
-                format!("method{} a trait item", suffix).fmt(f)
+                format!("method{suffix} a trait item").fmt(f)
             },
         }
     }
@@ -138,8 +138,7 @@ pub(super) fn check<'tcx>(
                 WRONG_SELF_CONVENTION,
                 first_arg_span,
                 &format!(
-                    "{} usually take {}",
-                    suggestion,
+                    "{suggestion} usually take {}",
                     &self_kinds
                         .iter()
                         .map(|k| k.description())
diff --git a/clippy_lints/src/misc.rs b/clippy_lints/src/misc.rs
index ea245edd770..381458b91e6 100644
--- a/clippy_lints/src/misc.rs
+++ b/clippy_lints/src/misc.rs
@@ -178,7 +178,7 @@ impl<'tcx> LateLintPass<'tcx> for MiscLints {
                     ("", sugg_init.addr())
                 };
                 let tyopt = if let Some(ty) = local.ty {
-                    format!(": &{mutopt}{ty}", mutopt=mutopt, ty=snippet(cx, ty.span, ".."))
+                    format!(": &{mutopt}{ty}", ty=snippet(cx, ty.span, ".."))
                 } else {
                     String::new()
                 };
@@ -195,8 +195,6 @@ impl<'tcx> LateLintPass<'tcx> for MiscLints {
                             format!(
                                 "let {name}{tyopt} = {initref};",
                                 name=snippet(cx, name.span, ".."),
-                                tyopt=tyopt,
-                                initref=initref,
                             ),
                             Applicability::MachineApplicable,
                         );
@@ -222,8 +220,7 @@ impl<'tcx> LateLintPass<'tcx> for MiscLints {
                             stmt.span,
                             "replace it with",
                             format!(
-                                "if {} {{ {}; }}",
-                                sugg,
+                                "if {sugg} {{ {}; }}",
                                 &snippet(cx, b.span, ".."),
                             ),
                             Applicability::MachineApplicable, // snippet
@@ -275,9 +272,8 @@ impl<'tcx> LateLintPass<'tcx> for MiscLints {
                 USED_UNDERSCORE_BINDING,
                 expr.span,
                 &format!(
-                    "used binding `{}` which is prefixed with an underscore. A leading \
-                     underscore signals that a binding will not be used",
-                    binding
+                    "used binding `{binding}` which is prefixed with an underscore. A leading \
+                     underscore signals that a binding will not be used"
                 ),
             );
         }
@@ -328,12 +324,12 @@ fn check_cast(cx: &LateContext<'_>, span: Span, e: &Expr<'_>, ty: &hir::Ty<'_>)
             };
 
             let (sugg, appl) = if let TyKind::Infer = mut_ty.ty.kind {
-                (format!("{}()", sugg_fn), Applicability::MachineApplicable)
+                (format!("{sugg_fn}()"), Applicability::MachineApplicable)
             } else if let Some(mut_ty_snip) = snippet_opt(cx, mut_ty.ty.span) {
-                (format!("{}::<{}>()", sugg_fn, mut_ty_snip), Applicability::MachineApplicable)
+                (format!("{sugg_fn}::<{mut_ty_snip}>()"), Applicability::MachineApplicable)
             } else {
                 // `MaybeIncorrect` as type inference may not work with the suggested code
-                (format!("{}()", sugg_fn), Applicability::MaybeIncorrect)
+                (format!("{sugg_fn}()"), Applicability::MaybeIncorrect)
             };
             span_lint_and_sugg(cx, ZERO_PTR, span, msg, "try", sugg, appl);
         }
diff --git a/clippy_lints/src/misc_early/literal_suffix.rs b/clippy_lints/src/misc_early/literal_suffix.rs
index 1165c19a0cf..62c6ca32d31 100644
--- a/clippy_lints/src/misc_early/literal_suffix.rs
+++ b/clippy_lints/src/misc_early/literal_suffix.rs
@@ -18,9 +18,9 @@ pub(super) fn check(cx: &EarlyContext<'_>, lit: &Lit, lit_snip: &str, suffix: &s
                 cx,
                 SEPARATED_LITERAL_SUFFIX,
                 lit.span,
-                &format!("{} type suffix should not be separated by an underscore", sugg_type),
+                &format!("{sugg_type} type suffix should not be separated by an underscore"),
                 "remove the underscore",
-                format!("{}{}", &lit_snip[..maybe_last_sep_idx], suffix),
+                format!("{}{suffix}", &lit_snip[..maybe_last_sep_idx]),
                 Applicability::MachineApplicable,
             );
         } else {
@@ -28,9 +28,9 @@ pub(super) fn check(cx: &EarlyContext<'_>, lit: &Lit, lit_snip: &str, suffix: &s
                 cx,
                 UNSEPARATED_LITERAL_SUFFIX,
                 lit.span,
-                &format!("{} type suffix should be separated by an underscore", sugg_type),
+                &format!("{sugg_type} type suffix should be separated by an underscore"),
                 "add an underscore",
-                format!("{}_{}", &lit_snip[..=maybe_last_sep_idx], suffix),
+                format!("{}_{suffix}", &lit_snip[..=maybe_last_sep_idx]),
                 Applicability::MachineApplicable,
             );
         }
diff --git a/clippy_lints/src/misc_early/mod.rs b/clippy_lints/src/misc_early/mod.rs
index 704918c0b97..c8227ca4450 100644
--- a/clippy_lints/src/misc_early/mod.rs
+++ b/clippy_lints/src/misc_early/mod.rs
@@ -357,9 +357,8 @@ impl EarlyLintPass for MiscEarlyLints {
                             DUPLICATE_UNDERSCORE_ARGUMENT,
                             *correspondence,
                             &format!(
-                                "`{}` already exists, having another argument having almost the same \
-                                 name makes code comprehension and documentation more difficult",
-                                arg_name
+                                "`{arg_name}` already exists, having another argument having almost the same \
+                                 name makes code comprehension and documentation more difficult"
                             ),
                         );
                     }
diff --git a/clippy_lints/src/misc_early/unneeded_field_pattern.rs b/clippy_lints/src/misc_early/unneeded_field_pattern.rs
index fff533167ed..676e5d40bb7 100644
--- a/clippy_lints/src/misc_early/unneeded_field_pattern.rs
+++ b/clippy_lints/src/misc_early/unneeded_field_pattern.rs
@@ -27,7 +27,7 @@ pub(super) fn check(cx: &EarlyContext<'_>, pat: &Pat) {
                 pat.span,
                 "all the struct fields are matched to a wildcard pattern, consider using `..`",
                 None,
-                &format!("try with `{} {{ .. }}` instead", type_name),
+                &format!("try with `{type_name} {{ .. }}` instead"),
             );
             return;
         }
@@ -63,7 +63,7 @@ pub(super) fn check(cx: &EarlyContext<'_>, pat: &Pat) {
                             "you matched a field with a wildcard pattern, consider using `..` \
                              instead",
                             None,
-                            &format!("try with `{} {{ {}, .. }}`", type_name, normal[..].join(", ")),
+                            &format!("try with `{type_name} {{ {}, .. }}`", normal[..].join(", ")),
                         );
                     }
                 }
diff --git a/clippy_lints/src/mismatching_type_param_order.rs b/clippy_lints/src/mismatching_type_param_order.rs
index 020efeaebf0..6dd76a6531e 100644
--- a/clippy_lints/src/mismatching_type_param_order.rs
+++ b/clippy_lints/src/mismatching_type_param_order.rs
@@ -91,10 +91,9 @@ impl<'tcx> LateLintPass<'tcx> for TypeParamMismatch {
                 let type_name = segment.ident;
                 for (i, (impl_param_name, impl_param_span)) in impl_params.iter().enumerate() {
                     if mismatch_param_name(i, impl_param_name, &type_param_names_hashmap) {
-                        let msg = format!("`{}` has a similarly named generic type parameter `{}` in its declaration, but in a different order",
-                                          type_name, impl_param_name);
-                        let help = format!("try `{}`, or a name that does not conflict with `{}`'s generic params",
-                                           type_param_names[i], type_name);
+                        let msg = format!("`{type_name}` has a similarly named generic type parameter `{impl_param_name}` in its declaration, but in a different order");
+                        let help = format!("try `{}`, or a name that does not conflict with `{type_name}`'s generic params",
+                                           type_param_names[i]);
                         span_lint_and_help(
                             cx,
                             MISMATCHING_TYPE_PARAM_ORDER,
diff --git a/clippy_lints/src/missing_doc.rs b/clippy_lints/src/missing_doc.rs
index ee81f72a0e7..97c8fb17638 100644
--- a/clippy_lints/src/missing_doc.rs
+++ b/clippy_lints/src/missing_doc.rs
@@ -104,7 +104,7 @@ impl MissingDoc {
                 cx,
                 MISSING_DOCS_IN_PRIVATE_ITEMS,
                 sp,
-                &format!("missing documentation for {} {}", article, desc),
+                &format!("missing documentation for {article} {desc}"),
             );
         }
     }
diff --git a/clippy_lints/src/missing_enforced_import_rename.rs b/clippy_lints/src/missing_enforced_import_rename.rs
index 3d0a2382283..697e6fd24dd 100644
--- a/clippy_lints/src/missing_enforced_import_rename.rs
+++ b/clippy_lints/src/missing_enforced_import_rename.rs
@@ -90,9 +90,7 @@ impl LateLintPass<'_> for ImportRename {
                     "this import should be renamed",
                     "try",
                     format!(
-                        "{} as {}",
-                        import,
-                        name,
+                        "{import} as {name}",
                     ),
                     Applicability::MachineApplicable,
                 );
diff --git a/clippy_lints/src/missing_inline.rs b/clippy_lints/src/missing_inline.rs
index 07bc2ca5d3c..18c45120091 100644
--- a/clippy_lints/src/missing_inline.rs
+++ b/clippy_lints/src/missing_inline.rs
@@ -65,7 +65,7 @@ fn check_missing_inline_attrs(cx: &LateContext<'_>, attrs: &[ast::Attribute], sp
             cx,
             MISSING_INLINE_IN_PUBLIC_ITEMS,
             sp,
-            &format!("missing `#[inline]` for {}", desc),
+            &format!("missing `#[inline]` for {desc}"),
         );
     }
 }
diff --git a/clippy_lints/src/mut_reference.rs b/clippy_lints/src/mut_reference.rs
index 82dc03ef5c5..463da11774a 100644
--- a/clippy_lints/src/mut_reference.rs
+++ b/clippy_lints/src/mut_reference.rs
@@ -88,7 +88,7 @@ fn check_arguments<'tcx>(
                                 cx,
                                 UNNECESSARY_MUT_PASSED,
                                 argument.span,
-                                &format!("the {} `{}` doesn't need a mutable reference", fn_kind, name),
+                                &format!("the {fn_kind} `{name}` doesn't need a mutable reference"),
                             );
                         }
                     },
diff --git a/clippy_lints/src/mutable_debug_assertion.rs b/clippy_lints/src/mutable_debug_assertion.rs
index 321db08dfe8..3ef0c663459 100644
--- a/clippy_lints/src/mutable_debug_assertion.rs
+++ b/clippy_lints/src/mutable_debug_assertion.rs
@@ -56,10 +56,7 @@ impl<'tcx> LateLintPass<'tcx> for DebugAssertWithMutCall {
                     cx,
                     DEBUG_ASSERT_WITH_MUT_CALL,
                     span,
-                    &format!(
-                        "do not call a function with mutable arguments inside of `{}!`",
-                        macro_name
-                    ),
+                    &format!("do not call a function with mutable arguments inside of `{macro_name}!`"),
                 );
             }
         }
diff --git a/clippy_lints/src/mutex_atomic.rs b/clippy_lints/src/mutex_atomic.rs
index a98577093ed..09cb5333176 100644
--- a/clippy_lints/src/mutex_atomic.rs
+++ b/clippy_lints/src/mutex_atomic.rs
@@ -84,9 +84,8 @@ impl<'tcx> LateLintPass<'tcx> for Mutex {
                 let mutex_param = subst.type_at(0);
                 if let Some(atomic_name) = get_atomic_name(mutex_param) {
                     let msg = format!(
-                        "consider using an `{}` instead of a `Mutex` here; if you just want the locking \
-                         behavior and not the internal type, consider using `Mutex<()>`",
-                        atomic_name
+                        "consider using an `{atomic_name}` instead of a `Mutex` here; if you just want the locking \
+                         behavior and not the internal type, consider using `Mutex<()>`"
                     );
                     match *mutex_param.kind() {
                         ty::Uint(t) if t != ty::UintTy::Usize => span_lint(cx, MUTEX_INTEGER, expr.span, &msg),
diff --git a/clippy_lints/src/needless_continue.rs b/clippy_lints/src/needless_continue.rs
index 98a3bce1ff3..6f0e755466e 100644
--- a/clippy_lints/src/needless_continue.rs
+++ b/clippy_lints/src/needless_continue.rs
@@ -309,7 +309,7 @@ fn emit_warning<'a>(cx: &EarlyContext<'_>, data: &'a LintData<'_>, header: &str,
         expr.span,
         message,
         None,
-        &format!("{}\n{}", header, snip),
+        &format!("{header}\n{snip}"),
     );
 }
 
@@ -322,10 +322,7 @@ fn suggestion_snippet_for_continue_inside_if<'a>(cx: &EarlyContext<'_>, data: &'
 
     let indent_if = indent_of(cx, data.if_expr.span).unwrap_or(0);
     format!(
-        "{indent}if {} {}\n{indent}{}",
-        cond_code,
-        continue_code,
-        else_code,
+        "{indent}if {cond_code} {continue_code}\n{indent}{else_code}",
         indent = " ".repeat(indent_if),
     )
 }
@@ -349,7 +346,7 @@ fn suggestion_snippet_for_continue_inside_else<'a>(cx: &EarlyContext<'_>, data:
             let span = cx.sess().source_map().stmt_span(stmt.span, data.loop_block.span);
             let snip = snippet_block(cx, span, "..", None).into_owned();
             snip.lines()
-                .map(|line| format!("{}{}", " ".repeat(indent), line))
+                .map(|line| format!("{}{line}", " ".repeat(indent)))
                 .collect::<Vec<_>>()
                 .join("\n")
         })
@@ -358,10 +355,7 @@ fn suggestion_snippet_for_continue_inside_else<'a>(cx: &EarlyContext<'_>, data:
 
     let indent_if = indent_of(cx, data.if_expr.span).unwrap_or(0);
     format!(
-        "{indent_if}if {} {}\n{indent}// merged code follows:\n{}\n{indent_if}}}",
-        cond_code,
-        block_code,
-        to_annex,
+        "{indent_if}if {cond_code} {block_code}\n{indent}// merged code follows:\n{to_annex}\n{indent_if}}}",
         indent = " ".repeat(indent),
         indent_if = " ".repeat(indent_if),
     )
diff --git a/clippy_lints/src/needless_late_init.rs b/clippy_lints/src/needless_late_init.rs
index de99f1d7078..cbad53f4450 100644
--- a/clippy_lints/src/needless_late_init.rs
+++ b/clippy_lints/src/needless_late_init.rs
@@ -287,7 +287,7 @@ fn check<'tcx>(
 
                     diag.span_suggestion(
                         assign.lhs_span,
-                        &format!("declare `{}` here", binding_name),
+                        &format!("declare `{binding_name}` here"),
                         let_snippet,
                         Applicability::MachineApplicable,
                     );
@@ -307,8 +307,8 @@ fn check<'tcx>(
 
                     diag.span_suggestion_verbose(
                         usage.stmt.span.shrink_to_lo(),
-                        &format!("declare `{}` here", binding_name),
-                        format!("{} = ", let_snippet),
+                        &format!("declare `{binding_name}` here"),
+                        format!("{let_snippet} = "),
                         applicability,
                     );
 
@@ -338,8 +338,8 @@ fn check<'tcx>(
 
                     diag.span_suggestion_verbose(
                         usage.stmt.span.shrink_to_lo(),
-                        &format!("declare `{}` here", binding_name),
-                        format!("{} = ", let_snippet),
+                        &format!("declare `{binding_name}` here"),
+                        format!("{let_snippet} = "),
                         applicability,
                     );
 
diff --git a/clippy_lints/src/needless_pass_by_value.rs b/clippy_lints/src/needless_pass_by_value.rs
index 6d17c7a7346..d7e6e7de2cc 100644
--- a/clippy_lints/src/needless_pass_by_value.rs
+++ b/clippy_lints/src/needless_pass_by_value.rs
@@ -236,7 +236,7 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByValue {
                                         snippet_opt(cx, span)
                                             .map_or(
                                                 "change the call to".into(),
-                                                |x| Cow::from(format!("change `{}` to", x)),
+                                                |x| Cow::from(format!("change `{x}` to")),
                                             )
                                             .as_ref(),
                                         suggestion,
@@ -266,7 +266,7 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByValue {
                                         snippet_opt(cx, span)
                                             .map_or(
                                                 "change the call to".into(),
-                                                |x| Cow::from(format!("change `{}` to", x))
+                                                |x| Cow::from(format!("change `{x}` to"))
                                             )
                                             .as_ref(),
                                         suggestion,
diff --git a/clippy_lints/src/needless_question_mark.rs b/clippy_lints/src/needless_question_mark.rs
index 8f85b00596c..59b6492e112 100644
--- a/clippy_lints/src/needless_question_mark.rs
+++ b/clippy_lints/src/needless_question_mark.rs
@@ -134,7 +134,7 @@ fn check(cx: &LateContext<'_>, expr: &Expr<'_>) {
                 NEEDLESS_QUESTION_MARK,
                 expr.span,
                 "question mark operator is useless here",
-                &format!("try removing question mark and `{}`", sugg_remove),
+                &format!("try removing question mark and `{sugg_remove}`"),
                 format!("{}", snippet(cx, inner_expr.span, r#""...""#)),
                 Applicability::MachineApplicable,
             );
diff --git a/clippy_lints/src/neg_multiply.rs b/clippy_lints/src/neg_multiply.rs
index b087cfb36b1..fb9a4abd0b4 100644
--- a/clippy_lints/src/neg_multiply.rs
+++ b/clippy_lints/src/neg_multiply.rs
@@ -62,9 +62,9 @@ fn check_mul(cx: &LateContext<'_>, span: Span, lit: &Expr<'_>, exp: &Expr<'_>) {
             let mut applicability = Applicability::MachineApplicable;
             let snip = snippet_with_applicability(cx, exp.span, "..", &mut applicability);
             let suggestion = if exp.precedence().order() < PREC_PREFIX && !has_enclosing_paren(&snip) {
-                format!("-({})", snip)
+                format!("-({snip})")
             } else {
-                format!("-{}", snip)
+                format!("-{snip}")
             };
             span_lint_and_sugg(
                     cx,
diff --git a/clippy_lints/src/new_without_default.rs b/clippy_lints/src/new_without_default.rs
index 5c45ee6d94a..cfd24e9b2d3 100644
--- a/clippy_lints/src/new_without_default.rs
+++ b/clippy_lints/src/new_without_default.rs
@@ -136,8 +136,7 @@ impl<'tcx> LateLintPass<'tcx> for NewWithoutDefault {
                                     id,
                                     impl_item.span,
                                     &format!(
-                                        "you should consider adding a `Default` implementation for `{}`",
-                                        self_type_snip
+                                        "you should consider adding a `Default` implementation for `{self_type_snip}`"
                                     ),
                                     |diag| {
                                         diag.suggest_prepend_item(
@@ -161,9 +160,9 @@ impl<'tcx> LateLintPass<'tcx> for NewWithoutDefault {
 fn create_new_without_default_suggest_msg(self_type_snip: &str, generics_sugg: &str) -> String {
     #[rustfmt::skip]
     format!(
-"impl{} Default for {} {{
+"impl{generics_sugg} Default for {self_type_snip} {{
     fn default() -> Self {{
         Self::new()
     }}
-}}", generics_sugg, self_type_snip)
+}}")
 }
diff --git a/clippy_lints/src/non_expressive_names.rs b/clippy_lints/src/non_expressive_names.rs
index b96af06b8d7..03fddd207ec 100644
--- a/clippy_lints/src/non_expressive_names.rs
+++ b/clippy_lints/src/non_expressive_names.rs
@@ -108,10 +108,7 @@ impl<'a, 'tcx> SimilarNamesLocalVisitor<'a, 'tcx> {
                 self.cx,
                 MANY_SINGLE_CHAR_NAMES,
                 span,
-                &format!(
-                    "{} bindings with single-character names in scope",
-                    num_single_char_names
-                ),
+                &format!("{num_single_char_names} bindings with single-character names in scope"),
             );
         }
     }
diff --git a/clippy_lints/src/nonstandard_macro_braces.rs b/clippy_lints/src/nonstandard_macro_braces.rs
index 5e38a95c40b..0ca0befc135 100644
--- a/clippy_lints/src/nonstandard_macro_braces.rs
+++ b/clippy_lints/src/nonstandard_macro_braces.rs
@@ -107,11 +107,11 @@ fn is_offending_macro<'a>(cx: &EarlyContext<'_>, span: Span, mac_braces: &'a Mac
         if let Some(snip) = snippet_opt(cx, span_call_site);
         // we must check only invocation sites
         // https://github.com/rust-lang/rust-clippy/issues/7422
-        if snip.starts_with(&format!("{}!", name));
+        if snip.starts_with(&format!("{name}!"));
         if unnested_or_local();
         // make formatting consistent
         let c = snip.replace(' ', "");
-        if !c.starts_with(&format!("{}!{}", name, braces.0));
+        if !c.starts_with(&format!("{name}!{}", braces.0));
         if !mac_braces.done.contains(&span_call_site);
         then {
             Some((span_call_site, braces, snip))
@@ -131,9 +131,9 @@ fn emit_help(cx: &EarlyContext<'_>, snip: &str, braces: &(String, String), span:
             cx,
             NONSTANDARD_MACRO_BRACES,
             span,
-            &format!("use of irregular braces for `{}!` macro", macro_name),
+            &format!("use of irregular braces for `{macro_name}!` macro"),
             "consider writing",
-            format!("{}!{}{}{}", macro_name, braces.0, macro_args, braces.1),
+            format!("{macro_name}!{}{macro_args}{}", braces.0, braces.1),
             Applicability::MachineApplicable,
         );
     }
@@ -266,9 +266,7 @@ impl<'de> Deserialize<'de> for MacroMatcher {
                         .iter()
                         .find(|b| b.0 == brace)
                         .map(|(o, c)| ((*o).to_owned(), (*c).to_owned()))
-                        .ok_or_else(|| {
-                            de::Error::custom(&format!("expected one of `(`, `{{`, `[` found `{}`", brace))
-                        })?,
+                        .ok_or_else(|| de::Error::custom(&format!("expected one of `(`, `{{`, `[` found `{brace}`")))?,
                 })
             }
         }
diff --git a/clippy_lints/src/octal_escapes.rs b/clippy_lints/src/octal_escapes.rs
index bffbf20b4d2..f380a506582 100644
--- a/clippy_lints/src/octal_escapes.rs
+++ b/clippy_lints/src/octal_escapes.rs
@@ -102,7 +102,7 @@ fn check_lit(cx: &EarlyContext<'_>, lit: &Lit, span: Span, is_string: bool) {
         // construct a replacement escape
         // the maximum value is \077, or \x3f, so u8 is sufficient here
         if let Ok(n) = u8::from_str_radix(&contents[from + 1..to], 8) {
-            write!(suggest_1, "\\x{:02x}", n).unwrap();
+            write!(suggest_1, "\\x{n:02x}").unwrap();
         }
 
         // append the null byte as \x00 and the following digits literally
diff --git a/clippy_lints/src/operators/absurd_extreme_comparisons.rs b/clippy_lints/src/operators/absurd_extreme_comparisons.rs
index 1ec4240afef..d29ca37eaeb 100644
--- a/clippy_lints/src/operators/absurd_extreme_comparisons.rs
+++ b/clippy_lints/src/operators/absurd_extreme_comparisons.rs
@@ -34,13 +34,12 @@ pub(super) fn check<'tcx>(
         };
 
         let help = format!(
-            "because `{}` is the {} value for this type, {}",
+            "because `{}` is the {} value for this type, {conclusion}",
             snippet(cx, culprit.expr.span, "x"),
             match culprit.which {
                 ExtremeType::Minimum => "minimum",
                 ExtremeType::Maximum => "maximum",
-            },
-            conclusion
+            }
         );
 
         span_lint_and_help(cx, ABSURD_EXTREME_COMPARISONS, expr.span, msg, None, &help);
diff --git a/clippy_lints/src/operators/assign_op_pattern.rs b/clippy_lints/src/operators/assign_op_pattern.rs
index 945a09a647c..cb5abfb809e 100644
--- a/clippy_lints/src/operators/assign_op_pattern.rs
+++ b/clippy_lints/src/operators/assign_op_pattern.rs
@@ -55,7 +55,7 @@ pub(super) fn check<'tcx>(
                                 diag.span_suggestion(
                                     expr.span,
                                     "replace it with",
-                                    format!("{} {}= {}", snip_a, op.node.as_str(), snip_r),
+                                    format!("{snip_a} {}= {snip_r}", op.node.as_str()),
                                     Applicability::MachineApplicable,
                                 );
                             }
diff --git a/clippy_lints/src/operators/bit_mask.rs b/clippy_lints/src/operators/bit_mask.rs
index 74387fbc87b..1369b3e7462 100644
--- a/clippy_lints/src/operators/bit_mask.rs
+++ b/clippy_lints/src/operators/bit_mask.rs
@@ -64,10 +64,7 @@ fn check_bit_mask(
                             cx,
                             BAD_BIT_MASK,
                             span,
-                            &format!(
-                                "incompatible bit mask: `_ & {}` can never be equal to `{}`",
-                                mask_value, cmp_value
-                            ),
+                            &format!("incompatible bit mask: `_ & {mask_value}` can never be equal to `{cmp_value}`"),
                         );
                     }
                 } else if mask_value == 0 {
@@ -80,10 +77,7 @@ fn check_bit_mask(
                         cx,
                         BAD_BIT_MASK,
                         span,
-                        &format!(
-                            "incompatible bit mask: `_ | {}` can never be equal to `{}`",
-                            mask_value, cmp_value
-                        ),
+                        &format!("incompatible bit mask: `_ | {mask_value}` can never be equal to `{cmp_value}`"),
                     );
                 }
             },
@@ -96,10 +90,7 @@ fn check_bit_mask(
                         cx,
                         BAD_BIT_MASK,
                         span,
-                        &format!(
-                            "incompatible bit mask: `_ & {}` will always be lower than `{}`",
-                            mask_value, cmp_value
-                        ),
+                        &format!("incompatible bit mask: `_ & {mask_value}` will always be lower than `{cmp_value}`"),
                     );
                 } else if mask_value == 0 {
                     span_lint(cx, BAD_BIT_MASK, span, "&-masking with zero");
@@ -111,10 +102,7 @@ fn check_bit_mask(
                         cx,
                         BAD_BIT_MASK,
                         span,
-                        &format!(
-                            "incompatible bit mask: `_ | {}` will never be lower than `{}`",
-                            mask_value, cmp_value
-                        ),
+                        &format!("incompatible bit mask: `_ | {mask_value}` will never be lower than `{cmp_value}`"),
                     );
                 } else {
                     check_ineffective_lt(cx, span, mask_value, cmp_value, "|");
@@ -130,10 +118,7 @@ fn check_bit_mask(
                         cx,
                         BAD_BIT_MASK,
                         span,
-                        &format!(
-                            "incompatible bit mask: `_ & {}` will never be higher than `{}`",
-                            mask_value, cmp_value
-                        ),
+                        &format!("incompatible bit mask: `_ & {mask_value}` will never be higher than `{cmp_value}`"),
                     );
                 } else if mask_value == 0 {
                     span_lint(cx, BAD_BIT_MASK, span, "&-masking with zero");
@@ -145,10 +130,7 @@ fn check_bit_mask(
                         cx,
                         BAD_BIT_MASK,
                         span,
-                        &format!(
-                            "incompatible bit mask: `_ | {}` will always be higher than `{}`",
-                            mask_value, cmp_value
-                        ),
+                        &format!("incompatible bit mask: `_ | {mask_value}` will always be higher than `{cmp_value}`"),
                     );
                 } else {
                     check_ineffective_gt(cx, span, mask_value, cmp_value, "|");
@@ -167,10 +149,7 @@ fn check_ineffective_lt(cx: &LateContext<'_>, span: Span, m: u128, c: u128, op:
             cx,
             INEFFECTIVE_BIT_MASK,
             span,
-            &format!(
-                "ineffective bit mask: `x {} {}` compared to `{}`, is the same as x compared directly",
-                op, m, c
-            ),
+            &format!("ineffective bit mask: `x {op} {m}` compared to `{c}`, is the same as x compared directly"),
         );
     }
 }
@@ -181,10 +160,7 @@ fn check_ineffective_gt(cx: &LateContext<'_>, span: Span, m: u128, c: u128, op:
             cx,
             INEFFECTIVE_BIT_MASK,
             span,
-            &format!(
-                "ineffective bit mask: `x {} {}` compared to `{}`, is the same as x compared directly",
-                op, m, c
-            ),
+            &format!("ineffective bit mask: `x {op} {m}` compared to `{c}`, is the same as x compared directly"),
         );
     }
 }
diff --git a/clippy_lints/src/operators/cmp_owned.rs b/clippy_lints/src/operators/cmp_owned.rs
index 638a514ff9b..c9c777f1bd8 100644
--- a/clippy_lints/src/operators/cmp_owned.rs
+++ b/clippy_lints/src/operators/cmp_owned.rs
@@ -99,7 +99,7 @@ fn check_op(cx: &LateContext<'_>, expr: &Expr<'_>, other: &Expr<'_>, left: bool)
             let expr_snip;
             let eq_impl;
             if with_deref.is_implemented() {
-                expr_snip = format!("*{}", arg_snip);
+                expr_snip = format!("*{arg_snip}");
                 eq_impl = with_deref;
             } else {
                 expr_snip = arg_snip.to_string();
@@ -121,17 +121,15 @@ fn check_op(cx: &LateContext<'_>, expr: &Expr<'_>, other: &Expr<'_>, left: bool)
                 };
                 if eq_impl.ty_eq_other {
                     hint = format!(
-                        "{}{}{}",
-                        expr_snip,
+                        "{expr_snip}{}{}",
                         snippet(cx, cmp_span, ".."),
                         snippet(cx, other.span, "..")
                     );
                 } else {
                     hint = format!(
-                        "{}{}{}",
+                        "{}{}{expr_snip}",
                         snippet(cx, other.span, ".."),
-                        snippet(cx, cmp_span, ".."),
-                        expr_snip
+                        snippet(cx, cmp_span, "..")
                     );
                 }
             }
diff --git a/clippy_lints/src/operators/duration_subsec.rs b/clippy_lints/src/operators/duration_subsec.rs
index 827a2b26709..49e662cacb0 100644
--- a/clippy_lints/src/operators/duration_subsec.rs
+++ b/clippy_lints/src/operators/duration_subsec.rs
@@ -31,12 +31,11 @@ pub(crate) fn check<'tcx>(
             cx,
             DURATION_SUBSEC,
             expr.span,
-            &format!("calling `{}()` is more concise than this calculation", suggested_fn),
+            &format!("calling `{suggested_fn}()` is more concise than this calculation"),
             "try",
             format!(
-                "{}.{}()",
-                snippet_with_applicability(cx, self_arg.span, "_", &mut applicability),
-                suggested_fn
+                "{}.{suggested_fn}()",
+                snippet_with_applicability(cx, self_arg.span, "_", &mut applicability)
             ),
             applicability,
         );
diff --git a/clippy_lints/src/operators/eq_op.rs b/clippy_lints/src/operators/eq_op.rs
index 44cf0bb0612..67913f7392c 100644
--- a/clippy_lints/src/operators/eq_op.rs
+++ b/clippy_lints/src/operators/eq_op.rs
@@ -22,7 +22,7 @@ pub(crate) fn check_assert<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
             cx,
             EQ_OP,
             lhs.span.to(rhs.span),
-            &format!("identical args used in this `{}!` macro call", macro_name),
+            &format!("identical args used in this `{macro_name}!` macro call"),
         );
     }
 }
diff --git a/clippy_lints/src/operators/misrefactored_assign_op.rs b/clippy_lints/src/operators/misrefactored_assign_op.rs
index 0024384d927..ae805147f07 100644
--- a/clippy_lints/src/operators/misrefactored_assign_op.rs
+++ b/clippy_lints/src/operators/misrefactored_assign_op.rs
@@ -47,18 +47,14 @@ fn lint_misrefactored_assign_op(
             if let (Some(snip_a), Some(snip_r)) = (snippet_opt(cx, assignee.span), snippet_opt(cx, rhs_other.span)) {
                 let a = &sugg::Sugg::hir(cx, assignee, "..");
                 let r = &sugg::Sugg::hir(cx, rhs, "..");
-                let long = format!("{} = {}", snip_a, sugg::make_binop(op.into(), a, r));
+                let long = format!("{snip_a} = {}", sugg::make_binop(op.into(), a, r));
                 diag.span_suggestion(
                     expr.span,
                     &format!(
-                        "did you mean `{} = {} {} {}` or `{}`? Consider replacing it with",
-                        snip_a,
-                        snip_a,
-                        op.as_str(),
-                        snip_r,
-                        long
+                        "did you mean `{snip_a} = {snip_a} {} {snip_r}` or `{long}`? Consider replacing it with",
+                        op.as_str()
                     ),
-                    format!("{} {}= {}", snip_a, op.as_str(), snip_r),
+                    format!("{snip_a} {}= {snip_r}", op.as_str()),
                     Applicability::MaybeIncorrect,
                 );
                 diag.span_suggestion(
diff --git a/clippy_lints/src/operators/needless_bitwise_bool.rs b/clippy_lints/src/operators/needless_bitwise_bool.rs
index e902235a014..ab5fb178700 100644
--- a/clippy_lints/src/operators/needless_bitwise_bool.rs
+++ b/clippy_lints/src/operators/needless_bitwise_bool.rs
@@ -27,7 +27,7 @@ pub(super) fn check(cx: &LateContext<'_>, e: &Expr<'_>, op: BinOpKind, lhs: &Exp
                 if let Some(lhs_snip) = snippet_opt(cx, lhs.span)
                     && let Some(rhs_snip) = snippet_opt(cx, rhs.span)
                 {
-                    let sugg = format!("{} {} {}", lhs_snip, op_str, rhs_snip);
+                    let sugg = format!("{lhs_snip} {op_str} {rhs_snip}");
                     diag.span_suggestion(e.span, "try", sugg, Applicability::MachineApplicable);
                 }
             },
diff --git a/clippy_lints/src/operators/ptr_eq.rs b/clippy_lints/src/operators/ptr_eq.rs
index 1aefc2741c2..1229c202f5a 100644
--- a/clippy_lints/src/operators/ptr_eq.rs
+++ b/clippy_lints/src/operators/ptr_eq.rs
@@ -34,7 +34,7 @@ pub(super) fn check<'tcx>(
                     expr.span,
                     LINT_MSG,
                     "try",
-                    format!("std::ptr::eq({}, {})", left_snip, right_snip),
+                    format!("std::ptr::eq({left_snip}, {right_snip})"),
                     Applicability::MachineApplicable,
                     );
             }
diff --git a/clippy_lints/src/operators/self_assignment.rs b/clippy_lints/src/operators/self_assignment.rs
index 9d6bec05bf0..7c9d5320a3a 100644
--- a/clippy_lints/src/operators/self_assignment.rs
+++ b/clippy_lints/src/operators/self_assignment.rs
@@ -14,7 +14,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>, lhs: &'tcx
             cx,
             SELF_ASSIGNMENT,
             e.span,
-            &format!("self-assignment of `{}` to `{}`", rhs, lhs),
+            &format!("self-assignment of `{rhs}` to `{lhs}`"),
         );
     }
 }
diff --git a/clippy_lints/src/operators/verbose_bit_mask.rs b/clippy_lints/src/operators/verbose_bit_mask.rs
index ff85fd55429..fbf65e92b32 100644
--- a/clippy_lints/src/operators/verbose_bit_mask.rs
+++ b/clippy_lints/src/operators/verbose_bit_mask.rs
@@ -35,7 +35,7 @@ pub(super) fn check<'tcx>(
                 diag.span_suggestion(
                     e.span,
                     "try",
-                    format!("{}.trailing_zeros() >= {}", sugg, n.count_ones()),
+                    format!("{sugg}.trailing_zeros() >= {}", n.count_ones()),
                     Applicability::MaybeIncorrect,
                 );
             },
diff --git a/clippy_lints/src/option_if_let_else.rs b/clippy_lints/src/option_if_let_else.rs
index 0315678bf97..256d2450001 100644
--- a/clippy_lints/src/option_if_let_else.rs
+++ b/clippy_lints/src/option_if_let_else.rs
@@ -163,7 +163,7 @@ fn try_get_option_occurence<'tcx>(
             return Some(OptionOccurence {
                 option: format_option_in_sugg(cx, cond_expr, as_ref, as_mut),
                 method_sugg: method_sugg.to_string(),
-                some_expr: format!("|{}{}| {}", capture_mut, capture_name, Sugg::hir_with_macro_callsite(cx, some_body, "..")),
+                some_expr: format!("|{capture_mut}{capture_name}| {}", Sugg::hir_with_macro_callsite(cx, some_body, "..")),
                 none_expr: format!("{}{}", if method_sugg == "map_or" { "" } else { "|| " }, Sugg::hir_with_macro_callsite(cx, none_body, "..")),
             });
         }
diff --git a/clippy_lints/src/pass_by_ref_or_value.rs b/clippy_lints/src/pass_by_ref_or_value.rs
index 0960b050c24..152e0c5ec9a 100644
--- a/clippy_lints/src/pass_by_ref_or_value.rs
+++ b/clippy_lints/src/pass_by_ref_or_value.rs
@@ -209,7 +209,7 @@ impl<'tcx> PassByRefOrValue {
                             cx,
                             TRIVIALLY_COPY_PASS_BY_REF,
                             input.span,
-                            &format!("this argument ({} byte) is passed by reference, but would be more efficient if passed by value (limit: {} byte)", size, self.ref_min_size),
+                            &format!("this argument ({size} byte) is passed by reference, but would be more efficient if passed by value (limit: {} byte)", self.ref_min_size),
                             "consider passing by value instead",
                             value_type,
                             Applicability::Unspecified,
@@ -237,7 +237,7 @@ impl<'tcx> PassByRefOrValue {
                                 cx,
                                 LARGE_TYPES_PASSED_BY_VALUE,
                                 input.span,
-                                &format!("this argument ({} byte) is passed by value, but might be more efficient if passed by reference (limit: {} byte)", size, self.value_max_size),
+                                &format!("this argument ({size} byte) is passed by value, but might be more efficient if passed by reference (limit: {} byte)", self.value_max_size),
                                 "consider passing by reference instead",
                                 format!("&{}", snippet(cx, input.span, "_")),
                                 Applicability::MaybeIncorrect,
diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs
index 41d1baba64f..85e0710eb50 100644
--- a/clippy_lints/src/ptr.rs
+++ b/clippy_lints/src/ptr.rs
@@ -463,7 +463,7 @@ fn check_fn_args<'cx, 'tcx: 'cx>(
                                     diag.span_suggestion(
                                         hir_ty.span,
                                         "change this to",
-                                        format!("&{}{}", mutability.prefix_str(), ty_name),
+                                        format!("&{}{ty_name}", mutability.prefix_str()),
                                         Applicability::Unspecified,
                                     );
                                 }
diff --git a/clippy_lints/src/ptr_offset_with_cast.rs b/clippy_lints/src/ptr_offset_with_cast.rs
index 4dc65da3ea1..b0a5d1a6758 100644
--- a/clippy_lints/src/ptr_offset_with_cast.rs
+++ b/clippy_lints/src/ptr_offset_with_cast.rs
@@ -60,7 +60,7 @@ impl<'tcx> LateLintPass<'tcx> for PtrOffsetWithCast {
             None => return,
         };
 
-        let msg = format!("use of `{}` with a `usize` casted to an `isize`", method);
+        let msg = format!("use of `{method}` with a `usize` casted to an `isize`");
         if let Some(sugg) = build_suggestion(cx, method, receiver_expr, cast_lhs_expr) {
             span_lint_and_sugg(
                 cx,
@@ -124,7 +124,7 @@ fn build_suggestion<'tcx>(
 ) -> Option<String> {
     let receiver = snippet_opt(cx, receiver_expr.span)?;
     let cast_lhs = snippet_opt(cx, cast_lhs_expr.span)?;
-    Some(format!("{}.{}({})", receiver, method.suggestion(), cast_lhs))
+    Some(format!("{receiver}.{}({cast_lhs})", method.suggestion()))
 }
 
 #[derive(Copy, Clone)]
diff --git a/clippy_lints/src/question_mark.rs b/clippy_lints/src/question_mark.rs
index f4f1fd336df..d53614722aa 100644
--- a/clippy_lints/src/question_mark.rs
+++ b/clippy_lints/src/question_mark.rs
@@ -97,12 +97,12 @@ fn check_is_none_or_err_and_early_return<'tcx>(cx: &LateContext<'tcx>, expr: &Ex
                 !matches!(caller.kind, ExprKind::Call(..) | ExprKind::MethodCall(..));
             let sugg = if let Some(else_inner) = r#else {
                 if eq_expr_value(cx, caller, peel_blocks(else_inner)) {
-                    format!("Some({}?)", receiver_str)
+                    format!("Some({receiver_str}?)")
                 } else {
                     return;
                 }
             } else {
-                format!("{}{}?;", receiver_str, if by_ref { ".as_ref()" } else { "" })
+                format!("{receiver_str}{}?;", if by_ref { ".as_ref()" } else { "" })
             };
 
             span_lint_and_sugg(
@@ -134,8 +134,7 @@ fn check_if_let_some_or_err_and_early_return<'tcx>(cx: &LateContext<'tcx>, expr:
             let receiver_str = snippet_with_applicability(cx, let_expr.span, "..", &mut applicability);
             let requires_semi = matches!(get_parent_node(cx.tcx, expr.hir_id), Some(Node::Stmt(_)));
             let sugg = format!(
-                "{}{}?{}",
-                receiver_str,
+                "{receiver_str}{}?{}",
                 if by_ref == ByRef::Yes { ".as_ref()" } else { "" },
                 if requires_semi { ";" } else { "" }
             );
diff --git a/clippy_lints/src/ranges.rs b/clippy_lints/src/ranges.rs
index 918d624eec6..c6fbb5e805a 100644
--- a/clippy_lints/src/ranges.rs
+++ b/clippy_lints/src/ranges.rs
@@ -243,9 +243,9 @@ fn check_possible_range_contains(
                 cx,
                 MANUAL_RANGE_CONTAINS,
                 span,
-                &format!("manual `{}::contains` implementation", range_type),
+                &format!("manual `{range_type}::contains` implementation"),
                 "use",
-                format!("({}{}{}{}).contains(&{})", lo, space, range_op, hi, name),
+                format!("({lo}{space}{range_op}{hi}).contains(&{name})"),
                 applicability,
             );
         } else if !combine_and && ord == Some(l.ord) {
@@ -273,9 +273,9 @@ fn check_possible_range_contains(
                 cx,
                 MANUAL_RANGE_CONTAINS,
                 span,
-                &format!("manual `!{}::contains` implementation", range_type),
+                &format!("manual `!{range_type}::contains` implementation"),
                 "use",
-                format!("!({}{}{}{}).contains(&{})", lo, space, range_op, hi, name),
+                format!("!({lo}{space}{range_op}{hi}).contains(&{name})"),
                 applicability,
             );
         }
@@ -372,14 +372,14 @@ fn check_exclusive_range_plus_one(cx: &LateContext<'_>, expr: &Expr<'_>) {
                             diag.span_suggestion(
                                 span,
                                 "use",
-                                format!("({}..={})", start, end),
+                                format!("({start}..={end})"),
                                 Applicability::MaybeIncorrect,
                             );
                         } else {
                             diag.span_suggestion(
                                 span,
                                 "use",
-                                format!("{}..={}", start, end),
+                                format!("{start}..={end}"),
                                 Applicability::MachineApplicable, // snippet
                             );
                         }
@@ -408,7 +408,7 @@ fn check_inclusive_range_minus_one(cx: &LateContext<'_>, expr: &Expr<'_>) {
                     diag.span_suggestion(
                         expr.span,
                         "use",
-                        format!("{}..{}", start, end),
+                        format!("{start}..{end}"),
                         Applicability::MachineApplicable, // snippet
                     );
                 },
@@ -486,7 +486,7 @@ fn check_reversed_empty_range(cx: &LateContext<'_>, expr: &Expr<'_>) {
                                 expr.span,
                                 "consider using the following if you are attempting to iterate over this \
                                  range in reverse",
-                                format!("({}{}{}).rev()", end_snippet, dots, start_snippet),
+                                format!("({end_snippet}{dots}{start_snippet}).rev()"),
                                 Applicability::MaybeIncorrect,
                             );
                         }
diff --git a/clippy_lints/src/read_zero_byte_vec.rs b/clippy_lints/src/read_zero_byte_vec.rs
index 94dec191103..ae80b6f1269 100644
--- a/clippy_lints/src/read_zero_byte_vec.rs
+++ b/clippy_lints/src/read_zero_byte_vec.rs
@@ -101,9 +101,8 @@ impl<'tcx> LateLintPass<'tcx> for ReadZeroByteVec {
                                 next_stmt_span,
                                 "reading zero byte data to `Vec`",
                                 "try",
-                                format!("{}.resize({}, 0); {}",
+                                format!("{}.resize({len}, 0); {}",
                                     ident.as_str(),
-                                    len,
                                     snippet(cx, next_stmt_span, "..")
                                 ),
                                 applicability,
diff --git a/clippy_lints/src/redundant_pub_crate.rs b/clippy_lints/src/redundant_pub_crate.rs
index 323326381d4..9c71a3daeee 100644
--- a/clippy_lints/src/redundant_pub_crate.rs
+++ b/clippy_lints/src/redundant_pub_crate.rs
@@ -56,7 +56,7 @@ impl<'tcx> LateLintPass<'tcx> for RedundantPubCrate {
                     cx,
                     REDUNDANT_PUB_CRATE,
                     span,
-                    &format!("pub(crate) {} inside private module", descr),
+                    &format!("pub(crate) {descr} inside private module"),
                     |diag| {
                         diag.span_suggestion(
                             item.vis_span,
diff --git a/clippy_lints/src/redundant_slicing.rs b/clippy_lints/src/redundant_slicing.rs
index 8693ca9af83..245a02ea26e 100644
--- a/clippy_lints/src/redundant_slicing.rs
+++ b/clippy_lints/src/redundant_slicing.rs
@@ -127,9 +127,9 @@ impl<'tcx> LateLintPass<'tcx> for RedundantSlicing {
 
                     let snip = snippet_with_context(cx, indexed.span, ctxt, "..", &mut app).0;
                     let sugg = if (deref_count != 0 || !reborrow_str.is_empty()) && needs_parens_for_prefix {
-                        format!("({}{}{})", reborrow_str, "*".repeat(deref_count), snip)
+                        format!("({reborrow_str}{}{snip})", "*".repeat(deref_count))
                     } else {
-                        format!("{}{}{}", reborrow_str, "*".repeat(deref_count), snip)
+                        format!("{reborrow_str}{}{snip}", "*".repeat(deref_count))
                     };
 
                     (lint, help_str, sugg)
@@ -141,9 +141,9 @@ impl<'tcx> LateLintPass<'tcx> for RedundantSlicing {
                         if deref_ty == expr_ty {
                             let snip = snippet_with_context(cx, indexed.span, ctxt, "..", &mut app).0;
                             let sugg = if needs_parens_for_prefix {
-                                format!("(&{}{}*{})", mutability.prefix_str(), "*".repeat(indexed_ref_count), snip)
+                                format!("(&{}{}*{snip})", mutability.prefix_str(), "*".repeat(indexed_ref_count))
                             } else {
-                                format!("&{}{}*{}", mutability.prefix_str(), "*".repeat(indexed_ref_count), snip)
+                                format!("&{}{}*{snip}", mutability.prefix_str(), "*".repeat(indexed_ref_count))
                             };
                             (DEREF_BY_SLICING_LINT, "dereference the original value instead", sugg)
                         } else {
diff --git a/clippy_lints/src/redundant_static_lifetimes.rs b/clippy_lints/src/redundant_static_lifetimes.rs
index 2d751c27467..60ba62c4a43 100644
--- a/clippy_lints/src/redundant_static_lifetimes.rs
+++ b/clippy_lints/src/redundant_static_lifetimes.rs
@@ -67,7 +67,7 @@ impl RedundantStaticLifetimes {
                         TyKind::Path(..) | TyKind::Slice(..) | TyKind::Array(..) | TyKind::Tup(..) => {
                             if lifetime.ident.name == rustc_span::symbol::kw::StaticLifetime {
                                 let snip = snippet(cx, borrow_type.ty.span, "<type>");
-                                let sugg = format!("&{}", snip);
+                                let sugg = format!("&{snip}");
                                 span_lint_and_then(
                                     cx,
                                     REDUNDANT_STATIC_LIFETIMES,
diff --git a/clippy_lints/src/regex.rs b/clippy_lints/src/regex.rs
index 6bcae0da8f4..1fda58fa54d 100644
--- a/clippy_lints/src/regex.rs
+++ b/clippy_lints/src/regex.rs
@@ -172,7 +172,7 @@ fn check_regex<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, utf8: bool) {
                     );
                 },
                 Err(e) => {
-                    span_lint(cx, INVALID_REGEX, expr.span, &format!("regex syntax error: {}", e));
+                    span_lint(cx, INVALID_REGEX, expr.span, &format!("regex syntax error: {e}"));
                 },
             }
         }
@@ -200,7 +200,7 @@ fn check_regex<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, utf8: bool) {
                 );
             },
             Err(e) => {
-                span_lint(cx, INVALID_REGEX, expr.span, &format!("regex syntax error: {}", e));
+                span_lint(cx, INVALID_REGEX, expr.span, &format!("regex syntax error: {e}"));
             },
         }
     }
diff --git a/clippy_lints/src/same_name_method.rs b/clippy_lints/src/same_name_method.rs
index 73f8e083b29..dead36e3bea 100644
--- a/clippy_lints/src/same_name_method.rs
+++ b/clippy_lints/src/same_name_method.rs
@@ -108,7 +108,7 @@ impl<'tcx> LateLintPass<'tcx> for SameNameMethod {
                                     |diag| {
                                         diag.span_note(
                                             trait_method_span,
-                                            &format!("existing `{}` defined here", method_name),
+                                            &format!("existing `{method_name}` defined here"),
                                         );
                                     },
                                 );
@@ -151,7 +151,7 @@ impl<'tcx> LateLintPass<'tcx> for SameNameMethod {
                                         // iterate on trait_spans?
                                         diag.span_note(
                                             trait_spans[0],
-                                            &format!("existing `{}` defined here", method_name),
+                                            &format!("existing `{method_name}` defined here"),
                                         );
                                     },
                                 );
diff --git a/clippy_lints/src/semicolon_if_nothing_returned.rs b/clippy_lints/src/semicolon_if_nothing_returned.rs
index 729694da46d..66638eed998 100644
--- a/clippy_lints/src/semicolon_if_nothing_returned.rs
+++ b/clippy_lints/src/semicolon_if_nothing_returned.rs
@@ -54,7 +54,7 @@ impl<'tcx> LateLintPass<'tcx> for SemicolonIfNothingReturned {
                 }
 
                 let sugg = sugg::Sugg::hir_with_macro_callsite(cx, expr, "..");
-                let suggestion = format!("{0};", sugg);
+                let suggestion = format!("{sugg};");
                 span_lint_and_sugg(
                     cx,
                     SEMICOLON_IF_NOTHING_RETURNED,
diff --git a/clippy_lints/src/slow_vector_initialization.rs b/clippy_lints/src/slow_vector_initialization.rs
index c07aa00a127..e57ab8cd7a3 100644
--- a/clippy_lints/src/slow_vector_initialization.rs
+++ b/clippy_lints/src/slow_vector_initialization.rs
@@ -174,7 +174,7 @@ impl SlowVectorInit {
             diag.span_suggestion(
                 vec_alloc.allocation_expr.span,
                 "consider replace allocation with",
-                format!("vec![0; {}]", len_expr),
+                format!("vec![0; {len_expr}]"),
                 Applicability::Unspecified,
             );
         });
diff --git a/clippy_lints/src/strings.rs b/clippy_lints/src/strings.rs
index 662d399ca53..d356c99c8fc 100644
--- a/clippy_lints/src/strings.rs
+++ b/clippy_lints/src/strings.rs
@@ -284,7 +284,7 @@ impl<'tcx> LateLintPass<'tcx> for StringLitAsBytes {
                     e.span,
                     "calling a slice of `as_bytes()` with `from_utf8` should be not necessary",
                     "try",
-                    format!("Some(&{}[{}])", snippet_app, snippet(cx, right.span, "..")),
+                    format!("Some(&{snippet_app}[{}])", snippet(cx, right.span, "..")),
                     applicability
                 )
             }
@@ -500,8 +500,8 @@ impl<'tcx> LateLintPass<'tcx> for TrimSplitWhitespace {
                     cx,
                     TRIM_SPLIT_WHITESPACE,
                     trim_span.with_hi(split_ws_span.lo()),
-                    &format!("found call to `str::{}` before `str::split_whitespace`", trim_fn_name),
-                    &format!("remove `{}()`", trim_fn_name),
+                    &format!("found call to `str::{trim_fn_name}` before `str::split_whitespace`"),
+                    &format!("remove `{trim_fn_name}()`"),
                     String::new(),
                     Applicability::MachineApplicable,
                 );
diff --git a/clippy_lints/src/strlen_on_c_strings.rs b/clippy_lints/src/strlen_on_c_strings.rs
index 78403d9fdb7..03324c66e8e 100644
--- a/clippy_lints/src/strlen_on_c_strings.rs
+++ b/clippy_lints/src/strlen_on_c_strings.rs
@@ -79,7 +79,7 @@ impl<'tcx> LateLintPass<'tcx> for StrlenOnCStrings {
                     span,
                     "using `libc::strlen` on a `CString` or `CStr` value",
                     "try this",
-                    format!("{}.{}().len()", val_name, method_name),
+                    format!("{val_name}.{method_name}().len()"),
                     app,
                 );
             }
diff --git a/clippy_lints/src/suspicious_operation_groupings.rs b/clippy_lints/src/suspicious_operation_groupings.rs
index 5d36f0f5ff8..eef9bdc7849 100644
--- a/clippy_lints/src/suspicious_operation_groupings.rs
+++ b/clippy_lints/src/suspicious_operation_groupings.rs
@@ -326,8 +326,7 @@ fn replace_left_sugg(
     applicability: &mut Applicability,
 ) -> String {
     format!(
-        "{} {} {}",
-        left_suggestion,
+        "{left_suggestion} {} {}",
         binop.op.to_string(),
         snippet_with_applicability(cx, binop.right.span, "..", applicability),
     )
@@ -340,10 +339,9 @@ fn replace_right_sugg(
     applicability: &mut Applicability,
 ) -> String {
     format!(
-        "{} {} {}",
+        "{} {} {right_suggestion}",
         snippet_with_applicability(cx, binop.left.span, "..", applicability),
         binop.op.to_string(),
-        right_suggestion,
     )
 }
 
@@ -676,9 +674,8 @@ fn suggestion_with_swapped_ident(
         }
 
         Some(format!(
-            "{}{}{}",
+            "{}{new_ident}{}",
             snippet_with_applicability(cx, expr.span.with_hi(current_ident.span.lo()), "..", applicability),
-            new_ident,
             snippet_with_applicability(cx, expr.span.with_lo(current_ident.span.hi()), "..", applicability),
         ))
     })
diff --git a/clippy_lints/src/swap.rs b/clippy_lints/src/swap.rs
index 1885f3ca414..f46c21e1265 100644
--- a/clippy_lints/src/swap.rs
+++ b/clippy_lints/src/swap.rs
@@ -96,7 +96,7 @@ fn generate_swap_warning(cx: &LateContext<'_>, e1: &Expr<'_>, e2: &Expr<'_>, spa
                             cx,
                             MANUAL_SWAP,
                             span,
-                            &format!("this looks like you are swapping elements of `{}` manually", slice),
+                            &format!("this looks like you are swapping elements of `{slice}` manually"),
                             "try",
                             format!(
                                 "{}.swap({}, {})",
@@ -121,16 +121,16 @@ fn generate_swap_warning(cx: &LateContext<'_>, e1: &Expr<'_>, e2: &Expr<'_>, spa
         cx,
         MANUAL_SWAP,
         span,
-        &format!("this looks like you are swapping `{}` and `{}` manually", first, second),
+        &format!("this looks like you are swapping `{first}` and `{second}` manually"),
         |diag| {
             diag.span_suggestion(
                 span,
                 "try",
-                format!("{}::mem::swap({}, {})", sugg, first.mut_addr(), second.mut_addr()),
+                format!("{sugg}::mem::swap({}, {})", first.mut_addr(), second.mut_addr()),
                 applicability,
             );
             if !is_xor_based {
-                diag.note(&format!("or maybe you should use `{}::mem::replace`?", sugg));
+                diag.note(&format!("or maybe you should use `{sugg}::mem::replace`?"));
             }
         },
     );
@@ -182,7 +182,7 @@ fn check_suspicious_swap(cx: &LateContext<'_>, block: &Block<'_>) {
                 let rhs0 = Sugg::hir_opt(cx, rhs0);
                 let (what, lhs, rhs) = if let (Some(first), Some(second)) = (lhs0, rhs0) {
                     (
-                        format!(" `{}` and `{}`", first, second),
+                        format!(" `{first}` and `{second}`"),
                         first.mut_addr().to_string(),
                         second.mut_addr().to_string(),
                     )
@@ -196,22 +196,19 @@ fn check_suspicious_swap(cx: &LateContext<'_>, block: &Block<'_>) {
                 span_lint_and_then(cx,
                     ALMOST_SWAPPED,
                     span,
-                    &format!("this looks like you are trying to swap{}", what),
+                    &format!("this looks like you are trying to swap{what}"),
                     |diag| {
                         if !what.is_empty() {
                             diag.span_suggestion(
                                 span,
                                 "try",
                                 format!(
-                                    "{}::mem::swap({}, {})",
-                                    sugg,
-                                    lhs,
-                                    rhs,
+                                    "{sugg}::mem::swap({lhs}, {rhs})",
                                 ),
                                 Applicability::MaybeIncorrect,
                             );
                             diag.note(
-                                &format!("or maybe you should use `{}::mem::replace`?", sugg)
+                                &format!("or maybe you should use `{sugg}::mem::replace`?")
                             );
                         }
                     });
diff --git a/clippy_lints/src/swap_ptr_to_ref.rs b/clippy_lints/src/swap_ptr_to_ref.rs
index 3cbbda80f3a..d085dda3582 100644
--- a/clippy_lints/src/swap_ptr_to_ref.rs
+++ b/clippy_lints/src/swap_ptr_to_ref.rs
@@ -58,7 +58,7 @@ impl LateLintPass<'_> for SwapPtrToRef {
                         let mut app = Applicability::MachineApplicable;
                         let snip1 = snippet_with_context(cx, arg1_span.unwrap_or(arg1.span), ctxt, "..", &mut app).0;
                         let snip2 = snippet_with_context(cx, arg2_span.unwrap_or(arg2.span), ctxt, "..", &mut app).0;
-                        diag.span_suggestion(e.span, "use ptr::swap", format!("core::ptr::swap({}, {})", snip1, snip2), app);
+                        diag.span_suggestion(e.span, "use ptr::swap", format!("core::ptr::swap({snip1}, {snip2})"), app);
                     }
                 }
             );
diff --git a/clippy_lints/src/to_digit_is_some.rs b/clippy_lints/src/to_digit_is_some.rs
index 651201f34ed..2512500a6be 100644
--- a/clippy_lints/src/to_digit_is_some.rs
+++ b/clippy_lints/src/to_digit_is_some.rs
@@ -84,9 +84,9 @@ impl<'tcx> LateLintPass<'tcx> for ToDigitIsSome {
                         "use of `.to_digit(..).is_some()`",
                         "try this",
                         if is_method_call {
-                            format!("{}.is_digit({})", char_arg_snip, radix_snip)
+                            format!("{char_arg_snip}.is_digit({radix_snip})")
                         } else {
-                            format!("char::is_digit({}, {})", char_arg_snip, radix_snip)
+                            format!("char::is_digit({char_arg_snip}, {radix_snip})")
                         },
                         applicability,
                     );
diff --git a/clippy_lints/src/trait_bounds.rs b/clippy_lints/src/trait_bounds.rs
index a25be93b8d6..bb146441f87 100644
--- a/clippy_lints/src/trait_bounds.rs
+++ b/clippy_lints/src/trait_bounds.rs
@@ -215,9 +215,8 @@ impl TraitBounds {
                         .map(|(_, _, span)| snippet_with_applicability(cx, span, "..", &mut applicability))
                         .join(" + ");
                     let hint_string = format!(
-                        "consider combining the bounds: `{}: {}`",
+                        "consider combining the bounds: `{}: {trait_bounds}`",
                         snippet(cx, p.bounded_ty.span, "_"),
-                        trait_bounds,
                     );
                     span_lint_and_help(
                         cx,
diff --git a/clippy_lints/src/transmute/crosspointer_transmute.rs b/clippy_lints/src/transmute/crosspointer_transmute.rs
index 25d0543c861..c4b9d82fc73 100644
--- a/clippy_lints/src/transmute/crosspointer_transmute.rs
+++ b/clippy_lints/src/transmute/crosspointer_transmute.rs
@@ -13,10 +13,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>, from_ty: Ty
                 cx,
                 CROSSPOINTER_TRANSMUTE,
                 e.span,
-                &format!(
-                    "transmute from a type (`{}`) to the type that it points to (`{}`)",
-                    from_ty, to_ty
-                ),
+                &format!("transmute from a type (`{from_ty}`) to the type that it points to (`{to_ty}`)"),
             );
             true
         },
@@ -25,10 +22,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>, from_ty: Ty
                 cx,
                 CROSSPOINTER_TRANSMUTE,
                 e.span,
-                &format!(
-                    "transmute from a type (`{}`) to a pointer to that type (`{}`)",
-                    from_ty, to_ty
-                ),
+                &format!("transmute from a type (`{from_ty}`) to a pointer to that type (`{to_ty}`)"),
             );
             true
         },
diff --git a/clippy_lints/src/transmute/transmute_float_to_int.rs b/clippy_lints/src/transmute/transmute_float_to_int.rs
index 1bde977cfa2..5ecba512b0f 100644
--- a/clippy_lints/src/transmute/transmute_float_to_int.rs
+++ b/clippy_lints/src/transmute/transmute_float_to_int.rs
@@ -24,7 +24,7 @@ pub(super) fn check<'tcx>(
                 cx,
                 TRANSMUTE_FLOAT_TO_INT,
                 e.span,
-                &format!("transmute from a `{}` to a `{}`", from_ty, to_ty),
+                &format!("transmute from a `{from_ty}` to a `{to_ty}`"),
                 |diag| {
                     let mut sugg = sugg::Sugg::hir(cx, arg, "..");
 
@@ -38,7 +38,7 @@ pub(super) fn check<'tcx>(
                         if let ExprKind::Lit(lit) = &arg.kind;
                         if let ast::LitKind::Float(_, ast::LitFloatType::Unsuffixed) = lit.node;
                         then {
-                            let op = format!("{}{}", sugg, float_ty.name_str()).into();
+                            let op = format!("{sugg}{}", float_ty.name_str()).into();
                             match sugg {
                                 sugg::Sugg::MaybeParen(_) => sugg = sugg::Sugg::MaybeParen(op),
                                 _ => sugg = sugg::Sugg::NonParen(op)
diff --git a/clippy_lints/src/transmute/transmute_int_to_bool.rs b/clippy_lints/src/transmute/transmute_int_to_bool.rs
index 8c50b58ca4b..58227c53de2 100644
--- a/clippy_lints/src/transmute/transmute_int_to_bool.rs
+++ b/clippy_lints/src/transmute/transmute_int_to_bool.rs
@@ -23,7 +23,7 @@ pub(super) fn check<'tcx>(
                 cx,
                 TRANSMUTE_INT_TO_BOOL,
                 e.span,
-                &format!("transmute from a `{}` to a `bool`", from_ty),
+                &format!("transmute from a `{from_ty}` to a `bool`"),
                 |diag| {
                     let arg = sugg::Sugg::hir(cx, arg, "..");
                     let zero = sugg::Sugg::NonParen(Cow::from("0"));
diff --git a/clippy_lints/src/transmute/transmute_int_to_char.rs b/clippy_lints/src/transmute/transmute_int_to_char.rs
index 9e1823c373b..7d31c375f8c 100644
--- a/clippy_lints/src/transmute/transmute_int_to_char.rs
+++ b/clippy_lints/src/transmute/transmute_int_to_char.rs
@@ -23,7 +23,7 @@ pub(super) fn check<'tcx>(
                 cx,
                 TRANSMUTE_INT_TO_CHAR,
                 e.span,
-                &format!("transmute from a `{}` to a `char`", from_ty),
+                &format!("transmute from a `{from_ty}` to a `char`"),
                 |diag| {
                     let arg = sugg::Sugg::hir(cx, arg, "..");
                     let arg = if let ty::Int(_) = from_ty.kind() {
@@ -34,7 +34,7 @@ pub(super) fn check<'tcx>(
                     diag.span_suggestion(
                         e.span,
                         "consider using",
-                        format!("std::char::from_u32({}).unwrap()", arg),
+                        format!("std::char::from_u32({arg}).unwrap()"),
                         Applicability::Unspecified,
                     );
                 },
diff --git a/clippy_lints/src/transmute/transmute_int_to_float.rs b/clippy_lints/src/transmute/transmute_int_to_float.rs
index b8703052e6c..cc3422edbbf 100644
--- a/clippy_lints/src/transmute/transmute_int_to_float.rs
+++ b/clippy_lints/src/transmute/transmute_int_to_float.rs
@@ -22,7 +22,7 @@ pub(super) fn check<'tcx>(
                 cx,
                 TRANSMUTE_INT_TO_FLOAT,
                 e.span,
-                &format!("transmute from a `{}` to a `{}`", from_ty, to_ty),
+                &format!("transmute from a `{from_ty}` to a `{to_ty}`"),
                 |diag| {
                     let arg = sugg::Sugg::hir(cx, arg, "..");
                     let arg = if let ty::Int(int_ty) = from_ty.kind() {
@@ -36,7 +36,7 @@ pub(super) fn check<'tcx>(
                     diag.span_suggestion(
                         e.span,
                         "consider using",
-                        format!("{}::from_bits({})", to_ty, arg),
+                        format!("{to_ty}::from_bits({arg})"),
                         Applicability::Unspecified,
                     );
                 },
diff --git a/clippy_lints/src/transmute/transmute_num_to_bytes.rs b/clippy_lints/src/transmute/transmute_num_to_bytes.rs
index 52d193d11e1..009d5a7c8ae 100644
--- a/clippy_lints/src/transmute/transmute_num_to_bytes.rs
+++ b/clippy_lints/src/transmute/transmute_num_to_bytes.rs
@@ -31,13 +31,13 @@ pub(super) fn check<'tcx>(
                 cx,
                 TRANSMUTE_NUM_TO_BYTES,
                 e.span,
-                &format!("transmute from a `{}` to a `{}`", from_ty, to_ty),
+                &format!("transmute from a `{from_ty}` to a `{to_ty}`"),
                 |diag| {
                     let arg = sugg::Sugg::hir(cx, arg, "..");
                     diag.span_suggestion(
                         e.span,
                         "consider using `to_ne_bytes()`",
-                        format!("{}.to_ne_bytes()", arg),
+                        format!("{arg}.to_ne_bytes()"),
                         Applicability::Unspecified,
                     );
                 },
diff --git a/clippy_lints/src/transmute/transmute_ptr_to_ref.rs b/clippy_lints/src/transmute/transmute_ptr_to_ref.rs
index 5eb03275b8e..12d0b866e1c 100644
--- a/clippy_lints/src/transmute/transmute_ptr_to_ref.rs
+++ b/clippy_lints/src/transmute/transmute_ptr_to_ref.rs
@@ -25,10 +25,7 @@ pub(super) fn check<'tcx>(
                 cx,
                 TRANSMUTE_PTR_TO_REF,
                 e.span,
-                &format!(
-                    "transmute from a pointer type (`{}`) to a reference type (`{}`)",
-                    from_ty, to_ty
-                ),
+                &format!("transmute from a pointer type (`{from_ty}`) to a reference type (`{to_ty}`)"),
                 |diag| {
                     let arg = sugg::Sugg::hir(cx, arg, "..");
                     let (deref, cast) = if *mutbl == Mutability::Mut {
@@ -41,26 +38,25 @@ pub(super) fn check<'tcx>(
                     let sugg = if let Some(ty) = get_explicit_type(path) {
                         let ty_snip = snippet_with_applicability(cx, ty.span, "..", &mut app);
                         if meets_msrv(msrv, msrvs::POINTER_CAST) {
-                            format!("{}{}.cast::<{}>()", deref, arg.maybe_par(), ty_snip)
+                            format!("{deref}{}.cast::<{ty_snip}>()", arg.maybe_par())
                         } else if from_ptr_ty.has_erased_regions() {
-                            sugg::make_unop(deref, arg.as_ty(format!("{} () as {} {}", cast, cast, ty_snip)))
-                                .to_string()
+                            sugg::make_unop(deref, arg.as_ty(format!("{cast} () as {cast} {ty_snip}"))).to_string()
                         } else {
-                            sugg::make_unop(deref, arg.as_ty(format!("{} {}", cast, ty_snip))).to_string()
+                            sugg::make_unop(deref, arg.as_ty(format!("{cast} {ty_snip}"))).to_string()
                         }
                     } else if from_ptr_ty.ty == *to_ref_ty {
                         if from_ptr_ty.has_erased_regions() {
                             if meets_msrv(msrv, msrvs::POINTER_CAST) {
-                                format!("{}{}.cast::<{}>()", deref, arg.maybe_par(), to_ref_ty)
+                                format!("{deref}{}.cast::<{to_ref_ty}>()", arg.maybe_par())
                             } else {
-                                sugg::make_unop(deref, arg.as_ty(format!("{} () as {} {}", cast, cast, to_ref_ty)))
+                                sugg::make_unop(deref, arg.as_ty(format!("{cast} () as {cast} {to_ref_ty}")))
                                     .to_string()
                             }
                         } else {
                             sugg::make_unop(deref, arg).to_string()
                         }
                     } else {
-                        sugg::make_unop(deref, arg.as_ty(format!("{} {}", cast, to_ref_ty))).to_string()
+                        sugg::make_unop(deref, arg.as_ty(format!("{cast} {to_ref_ty}"))).to_string()
                     };
 
                     diag.span_suggestion(e.span, "try", sugg, app);
diff --git a/clippy_lints/src/transmute/transmute_ref_to_ref.rs b/clippy_lints/src/transmute/transmute_ref_to_ref.rs
index 707a11d361c..afb7f2e1326 100644
--- a/clippy_lints/src/transmute/transmute_ref_to_ref.rs
+++ b/clippy_lints/src/transmute/transmute_ref_to_ref.rs
@@ -38,7 +38,7 @@ pub(super) fn check<'tcx>(
                     cx,
                     TRANSMUTE_BYTES_TO_STR,
                     e.span,
-                    &format!("transmute from a `{}` to a `{}`", from_ty, to_ty),
+                    &format!("transmute from a `{from_ty}` to a `{to_ty}`"),
                     "consider using",
                     if const_context {
                         format!("std::str::from_utf8_unchecked{postfix}({snippet})")
diff --git a/clippy_lints/src/transmute/transmute_undefined_repr.rs b/clippy_lints/src/transmute/transmute_undefined_repr.rs
index b6d7d9f5b42..cac620cf8e8 100644
--- a/clippy_lints/src/transmute/transmute_undefined_repr.rs
+++ b/clippy_lints/src/transmute/transmute_undefined_repr.rs
@@ -75,10 +75,10 @@ pub(super) fn check<'tcx>(
                     cx,
                     TRANSMUTE_UNDEFINED_REPR,
                     e.span,
-                    &format!("transmute from `{}` which has an undefined layout", from_ty_orig),
+                    &format!("transmute from `{from_ty_orig}` which has an undefined layout"),
                     |diag| {
                         if from_ty_orig.peel_refs() != from_ty.peel_refs() {
-                            diag.note(&format!("the contained type `{}` has an undefined layout", from_ty));
+                            diag.note(&format!("the contained type `{from_ty}` has an undefined layout"));
                         }
                     },
                 );
@@ -89,10 +89,10 @@ pub(super) fn check<'tcx>(
                     cx,
                     TRANSMUTE_UNDEFINED_REPR,
                     e.span,
-                    &format!("transmute to `{}` which has an undefined layout", to_ty_orig),
+                    &format!("transmute to `{to_ty_orig}` which has an undefined layout"),
                     |diag| {
                         if to_ty_orig.peel_refs() != to_ty.peel_refs() {
-                            diag.note(&format!("the contained type `{}` has an undefined layout", to_ty));
+                            diag.note(&format!("the contained type `{to_ty}` has an undefined layout"));
                         }
                     },
                 );
@@ -116,8 +116,7 @@ pub(super) fn check<'tcx>(
                     TRANSMUTE_UNDEFINED_REPR,
                     e.span,
                     &format!(
-                        "transmute from `{}` to `{}`, both of which have an undefined layout",
-                        from_ty_orig, to_ty_orig
+                        "transmute from `{from_ty_orig}` to `{to_ty_orig}`, both of which have an undefined layout"
                     ),
                     |diag| {
                         if let Some(same_adt_did) = same_adt_did {
@@ -127,10 +126,10 @@ pub(super) fn check<'tcx>(
                             ));
                         } else {
                             if from_ty_orig.peel_refs() != from_ty {
-                                diag.note(&format!("the contained type `{}` has an undefined layout", from_ty));
+                                diag.note(&format!("the contained type `{from_ty}` has an undefined layout"));
                             }
                             if to_ty_orig.peel_refs() != to_ty {
-                                diag.note(&format!("the contained type `{}` has an undefined layout", to_ty));
+                                diag.note(&format!("the contained type `{to_ty}` has an undefined layout"));
                             }
                         }
                     },
@@ -145,10 +144,10 @@ pub(super) fn check<'tcx>(
                     cx,
                     TRANSMUTE_UNDEFINED_REPR,
                     e.span,
-                    &format!("transmute from `{}` which has an undefined layout", from_ty_orig),
+                    &format!("transmute from `{from_ty_orig}` which has an undefined layout"),
                     |diag| {
                         if from_ty_orig.peel_refs() != from_ty {
-                            diag.note(&format!("the contained type `{}` has an undefined layout", from_ty));
+                            diag.note(&format!("the contained type `{from_ty}` has an undefined layout"));
                         }
                     },
                 );
@@ -162,10 +161,10 @@ pub(super) fn check<'tcx>(
                     cx,
                     TRANSMUTE_UNDEFINED_REPR,
                     e.span,
-                    &format!("transmute into `{}` which has an undefined layout", to_ty_orig),
+                    &format!("transmute into `{to_ty_orig}` which has an undefined layout"),
                     |diag| {
                         if to_ty_orig.peel_refs() != to_ty {
-                            diag.note(&format!("the contained type `{}` has an undefined layout", to_ty));
+                            diag.note(&format!("the contained type `{to_ty}` has an undefined layout"));
                         }
                     },
                 );
diff --git a/clippy_lints/src/transmute/transmutes_expressible_as_ptr_casts.rs b/clippy_lints/src/transmute/transmutes_expressible_as_ptr_casts.rs
index 626d7cd46fc..6b444922a7c 100644
--- a/clippy_lints/src/transmute/transmutes_expressible_as_ptr_casts.rs
+++ b/clippy_lints/src/transmute/transmutes_expressible_as_ptr_casts.rs
@@ -21,10 +21,7 @@ pub(super) fn check<'tcx>(
             cx,
             TRANSMUTES_EXPRESSIBLE_AS_PTR_CASTS,
             e.span,
-            &format!(
-                "transmute from `{}` to `{}` which could be expressed as a pointer cast instead",
-                from_ty, to_ty
-            ),
+            &format!("transmute from `{from_ty}` to `{to_ty}` which could be expressed as a pointer cast instead"),
             |diag| {
                 if let Some(arg) = sugg::Sugg::hir_opt(cx, arg) {
                     let sugg = arg.as_ty(&to_ty.to_string()).to_string();
diff --git a/clippy_lints/src/transmute/unsound_collection_transmute.rs b/clippy_lints/src/transmute/unsound_collection_transmute.rs
index 831b0d450d2..b1445311b71 100644
--- a/clippy_lints/src/transmute/unsound_collection_transmute.rs
+++ b/clippy_lints/src/transmute/unsound_collection_transmute.rs
@@ -37,10 +37,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>, from_ty: Ty
                     cx,
                     UNSOUND_COLLECTION_TRANSMUTE,
                     e.span,
-                    &format!(
-                        "transmute from `{}` to `{}` with mismatched layout is unsound",
-                        from_ty, to_ty
-                    ),
+                    &format!("transmute from `{from_ty}` to `{to_ty}` with mismatched layout is unsound"),
                 );
                 true
             } else {
diff --git a/clippy_lints/src/transmute/useless_transmute.rs b/clippy_lints/src/transmute/useless_transmute.rs
index 8122cd716e0..f919bbd5afc 100644
--- a/clippy_lints/src/transmute/useless_transmute.rs
+++ b/clippy_lints/src/transmute/useless_transmute.rs
@@ -21,7 +21,7 @@ pub(super) fn check<'tcx>(
                 cx,
                 USELESS_TRANSMUTE,
                 e.span,
-                &format!("transmute from a type (`{}`) to itself", from_ty),
+                &format!("transmute from a type (`{from_ty}`) to itself"),
             );
             true
         },
diff --git a/clippy_lints/src/transmute/wrong_transmute.rs b/clippy_lints/src/transmute/wrong_transmute.rs
index 2118f3d6950..d1965565b92 100644
--- a/clippy_lints/src/transmute/wrong_transmute.rs
+++ b/clippy_lints/src/transmute/wrong_transmute.rs
@@ -13,7 +13,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>, from_ty: Ty
                 cx,
                 WRONG_TRANSMUTE,
                 e.span,
-                &format!("transmute from a `{}` to a pointer", from_ty),
+                &format!("transmute from a `{from_ty}` to a pointer"),
             );
             true
         },
diff --git a/clippy_lints/src/types/borrowed_box.rs b/clippy_lints/src/types/borrowed_box.rs
index 94945b2e1a9..0a779b37860 100644
--- a/clippy_lints/src/types/borrowed_box.rs
+++ b/clippy_lints/src/types/borrowed_box.rs
@@ -49,15 +49,15 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, lt: &Lifetime, m
                     let inner_snippet = snippet(cx, inner.span, "..");
                     let suggestion = match &inner.kind {
                         TyKind::TraitObject(bounds, lt_bound, _) if bounds.len() > 1 || !lt_bound.is_elided() => {
-                            format!("&{}({})", ltopt, &inner_snippet)
+                            format!("&{ltopt}({})", &inner_snippet)
                         },
                         TyKind::Path(qpath)
                             if get_bounds_if_impl_trait(cx, qpath, inner.hir_id)
                                 .map_or(false, |bounds| bounds.len() > 1) =>
                         {
-                            format!("&{}({})", ltopt, &inner_snippet)
+                            format!("&{ltopt}({})", &inner_snippet)
                         },
-                        _ => format!("&{}{}", ltopt, &inner_snippet),
+                        _ => format!("&{ltopt}{}", &inner_snippet),
                     };
                     span_lint_and_sugg(
                         cx,
diff --git a/clippy_lints/src/types/box_collection.rs b/clippy_lints/src/types/box_collection.rs
index ba51404d214..08020ce6638 100644
--- a/clippy_lints/src/types/box_collection.rs
+++ b/clippy_lints/src/types/box_collection.rs
@@ -16,7 +16,7 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_
                 _ => "<..>",
             };
 
-            let box_content = format!("{outer}{generic}", outer = item_type);
+            let box_content = format!("{item_type}{generic}");
             span_lint_and_help(
                 cx,
                 BOX_COLLECTION,
diff --git a/clippy_lints/src/types/rc_buffer.rs b/clippy_lints/src/types/rc_buffer.rs
index 4d72a29e8c7..6b9de64e24c 100644
--- a/clippy_lints/src/types/rc_buffer.rs
+++ b/clippy_lints/src/types/rc_buffer.rs
@@ -17,7 +17,7 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_
                 hir_ty.span,
                 "usage of `Rc<T>` when T is a buffer type",
                 "try",
-                format!("Rc<{}>", alternate),
+                format!("Rc<{alternate}>"),
                 Applicability::MachineApplicable,
             );
         } else {
@@ -57,7 +57,7 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_
                 hir_ty.span,
                 "usage of `Arc<T>` when T is a buffer type",
                 "try",
-                format!("Arc<{}>", alternate),
+                format!("Arc<{alternate}>"),
                 Applicability::MachineApplicable,
             );
         } else if let Some(ty) = qpath_generic_tys(qpath).next() {
diff --git a/clippy_lints/src/types/redundant_allocation.rs b/clippy_lints/src/types/redundant_allocation.rs
index a1312fcda0b..b95f0213e0c 100644
--- a/clippy_lints/src/types/redundant_allocation.rs
+++ b/clippy_lints/src/types/redundant_allocation.rs
@@ -27,13 +27,11 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_
             cx,
             REDUNDANT_ALLOCATION,
             hir_ty.span,
-            &format!("usage of `{}<{}>`", outer_sym, generic_snippet),
+            &format!("usage of `{outer_sym}<{generic_snippet}>`"),
             |diag| {
-                diag.span_suggestion(hir_ty.span, "try", format!("{}", generic_snippet), applicability);
+                diag.span_suggestion(hir_ty.span, "try", format!("{generic_snippet}"), applicability);
                 diag.note(&format!(
-                    "`{generic}` is already a pointer, `{outer}<{generic}>` allocates a pointer on the heap",
-                    outer = outer_sym,
-                    generic = generic_snippet
+                    "`{generic_snippet}` is already a pointer, `{outer_sym}<{generic_snippet}>` allocates a pointer on the heap"
                 ));
             },
         );
@@ -72,19 +70,16 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_
             cx,
             REDUNDANT_ALLOCATION,
             hir_ty.span,
-            &format!("usage of `{}<{}<{}>>`", outer_sym, inner_sym, generic_snippet),
+            &format!("usage of `{outer_sym}<{inner_sym}<{generic_snippet}>>`"),
             |diag| {
                 diag.span_suggestion(
                     hir_ty.span,
                     "try",
-                    format!("{}<{}>", outer_sym, generic_snippet),
+                    format!("{outer_sym}<{generic_snippet}>"),
                     applicability,
                 );
                 diag.note(&format!(
-                    "`{inner}<{generic}>` is already on the heap, `{outer}<{inner}<{generic}>>` makes an extra allocation",
-                    outer = outer_sym,
-                    inner = inner_sym,
-                    generic = generic_snippet
+                    "`{inner_sym}<{generic_snippet}>` is already on the heap, `{outer_sym}<{inner_sym}<{generic_snippet}>>` makes an extra allocation"
                 ));
             },
         );
@@ -94,19 +89,13 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_
             cx,
             REDUNDANT_ALLOCATION,
             hir_ty.span,
-            &format!("usage of `{}<{}<{}>>`", outer_sym, inner_sym, generic_snippet),
+            &format!("usage of `{outer_sym}<{inner_sym}<{generic_snippet}>>`"),
             |diag| {
                 diag.note(&format!(
-                    "`{inner}<{generic}>` is already on the heap, `{outer}<{inner}<{generic}>>` makes an extra allocation",
-                    outer = outer_sym,
-                    inner = inner_sym,
-                    generic = generic_snippet
+                    "`{inner_sym}<{generic_snippet}>` is already on the heap, `{outer_sym}<{inner_sym}<{generic_snippet}>>` makes an extra allocation"
                 ));
                 diag.help(&format!(
-                    "consider using just `{outer}<{generic}>` or `{inner}<{generic}>`",
-                    outer = outer_sym,
-                    inner = inner_sym,
-                    generic = generic_snippet
+                    "consider using just `{outer_sym}<{generic_snippet}>` or `{inner_sym}<{generic_snippet}>`"
                 ));
             },
         );
diff --git a/clippy_lints/src/unit_return_expecting_ord.rs b/clippy_lints/src/unit_return_expecting_ord.rs
index c0a4f3fbacd..57aff5367dd 100644
--- a/clippy_lints/src/unit_return_expecting_ord.rs
+++ b/clippy_lints/src/unit_return_expecting_ord.rs
@@ -157,8 +157,7 @@ impl<'tcx> LateLintPass<'tcx> for UnitReturnExpectingOrd {
                                 span,
                                 &format!(
                                     "this closure returns \
-                                   the unit type which also implements {}",
-                                    trait_name
+                                   the unit type which also implements {trait_name}"
                                 ),
                             );
                         },
@@ -169,8 +168,7 @@ impl<'tcx> LateLintPass<'tcx> for UnitReturnExpectingOrd {
                                 span,
                                 &format!(
                                     "this closure returns \
-                                   the unit type which also implements {}",
-                                    trait_name
+                                   the unit type which also implements {trait_name}"
                                 ),
                                 Some(last_semi),
                                 "probably caused by this trailing semicolon",
diff --git a/clippy_lints/src/unit_types/unit_arg.rs b/clippy_lints/src/unit_types/unit_arg.rs
index a6f777abc6e..f6d3fb00f4e 100644
--- a/clippy_lints/src/unit_types/unit_arg.rs
+++ b/clippy_lints/src/unit_types/unit_arg.rs
@@ -74,7 +74,7 @@ fn lint_unit_args(cx: &LateContext<'_>, expr: &Expr<'_>, args_to_recover: &[&Exp
         cx,
         UNIT_ARG,
         expr.span,
-        &format!("passing {}unit value{} to a function", singular, plural),
+        &format!("passing {singular}unit value{plural} to a function"),
         |db| {
             let mut or = "";
             args_to_recover
@@ -129,7 +129,7 @@ fn lint_unit_args(cx: &LateContext<'_>, expr: &Expr<'_>, args_to_recover: &[&Exp
 
                 if arg_snippets_without_empty_blocks.is_empty() {
                     db.multipart_suggestion(
-                        &format!("use {}unit literal{} instead", singular, plural),
+                        &format!("use {singular}unit literal{plural} instead"),
                         args_to_recover
                             .iter()
                             .map(|arg| (arg.span, "()".to_string()))
@@ -143,8 +143,7 @@ fn lint_unit_args(cx: &LateContext<'_>, expr: &Expr<'_>, args_to_recover: &[&Exp
                     db.span_suggestion(
                         expr.span,
                         &format!(
-                            "{}move the expression{} in front of the call and replace {} with the unit literal `()`",
-                            or, empty_or_s, it_or_them
+                            "{or}move the expression{empty_or_s} in front of the call and replace {it_or_them} with the unit literal `()`"
                         ),
                         sugg,
                         applicability,
diff --git a/clippy_lints/src/unit_types/unit_cmp.rs b/clippy_lints/src/unit_types/unit_cmp.rs
index 1dd8895ebd0..226495dcbda 100644
--- a/clippy_lints/src/unit_types/unit_cmp.rs
+++ b/clippy_lints/src/unit_types/unit_cmp.rs
@@ -22,7 +22,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>) {
                 cx,
                 UNIT_CMP,
                 macro_call.span,
-                &format!("`{}` of unit values detected. This will always {}", macro_name, result),
+                &format!("`{macro_name}` of unit values detected. This will always {result}"),
             );
         }
         return;
@@ -40,9 +40,8 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>) {
                 UNIT_CMP,
                 expr.span,
                 &format!(
-                    "{}-comparison of unit values detected. This will always be {}",
-                    op.as_str(),
-                    result
+                    "{}-comparison of unit values detected. This will always be {result}",
+                    op.as_str()
                 ),
             );
         }
diff --git a/clippy_lints/src/unnecessary_self_imports.rs b/clippy_lints/src/unnecessary_self_imports.rs
index 839a4bdab09..bc0dd263d88 100644
--- a/clippy_lints/src/unnecessary_self_imports.rs
+++ b/clippy_lints/src/unnecessary_self_imports.rs
@@ -57,7 +57,7 @@ impl EarlyLintPass for UnnecessarySelfImports {
                             format!(
                                 "{}{};",
                                 last_segment.ident,
-                                if let UseTreeKind::Simple(Some(alias), ..) = self_tree.kind { format!(" as {}", alias) } else { String::new() },
+                                if let UseTreeKind::Simple(Some(alias), ..) = self_tree.kind { format!(" as {alias}") } else { String::new() },
                             ),
                             Applicability::MaybeIncorrect,
                         );
diff --git a/clippy_lints/src/unnecessary_wraps.rs b/clippy_lints/src/unnecessary_wraps.rs
index 2c40827db0e..83ef3b0fac8 100644
--- a/clippy_lints/src/unnecessary_wraps.rs
+++ b/clippy_lints/src/unnecessary_wraps.rs
@@ -153,11 +153,8 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryWraps {
                 )
             } else {
                 (
-                    format!(
-                        "this function's return value is unnecessarily wrapped by `{}`",
-                        return_type_label
-                    ),
-                    format!("remove `{}` from the return type...", return_type_label),
+                    format!("this function's return value is unnecessarily wrapped by `{return_type_label}`"),
+                    format!("remove `{return_type_label}` from the return type..."),
                     inner_type.to_string(),
                     "...and then change returning expressions",
                 )
diff --git a/clippy_lints/src/unsafe_removed_from_name.rs b/clippy_lints/src/unsafe_removed_from_name.rs
index 64f7a055cd9..32cd4681201 100644
--- a/clippy_lints/src/unsafe_removed_from_name.rs
+++ b/clippy_lints/src/unsafe_removed_from_name.rs
@@ -65,10 +65,7 @@ fn unsafe_to_safe_check(old_name: Ident, new_name: Ident, cx: &EarlyContext<'_>,
             cx,
             UNSAFE_REMOVED_FROM_NAME,
             span,
-            &format!(
-                "removed `unsafe` from the name of `{}` in use as `{}`",
-                old_str, new_str
-            ),
+            &format!("removed `unsafe` from the name of `{old_str}` in use as `{new_str}`"),
         );
     }
 }
diff --git a/clippy_lints/src/unused_rounding.rs b/clippy_lints/src/unused_rounding.rs
index b8a5d4ea8c9..3164937293b 100644
--- a/clippy_lints/src/unused_rounding.rs
+++ b/clippy_lints/src/unused_rounding.rs
@@ -58,8 +58,8 @@ impl EarlyLintPass for UnusedRounding {
                 cx,
                 UNUSED_ROUNDING,
                 expr.span,
-                &format!("used the `{}` method with a whole number float", method_name),
-                &format!("remove the `{}` method call", method_name),
+                &format!("used the `{method_name}` method with a whole number float"),
+                &format!("remove the `{method_name}` method call"),
                 float,
                 Applicability::MachineApplicable,
             );
diff --git a/clippy_lints/src/unwrap.rs b/clippy_lints/src/unwrap.rs
index 7e451b7b7a4..45e2f550236 100644
--- a/clippy_lints/src/unwrap.rs
+++ b/clippy_lints/src/unwrap.rs
@@ -257,9 +257,8 @@ impl<'a, 'tcx> Visitor<'tcx> for UnwrappableVariablesVisitor<'a, 'tcx> {
                             expr.hir_id,
                             expr.span,
                             &format!(
-                                "called `{}` on `{}` after checking its variant with `{}`",
+                                "called `{}` on `{unwrappable_variable_name}` after checking its variant with `{}`",
                                 method_name.ident.name,
-                                unwrappable_variable_name,
                                 unwrappable.check_name.ident.as_str(),
                             ),
                             |diag| {
@@ -268,9 +267,7 @@ impl<'a, 'tcx> Visitor<'tcx> for UnwrappableVariablesVisitor<'a, 'tcx> {
                                         unwrappable.check.span.with_lo(unwrappable.if_expr.span.lo()),
                                         "try",
                                         format!(
-                                            "if let {} = {}",
-                                            suggested_pattern,
-                                            unwrappable_variable_name,
+                                            "if let {suggested_pattern} = {unwrappable_variable_name}",
                                         ),
                                         // We don't track how the unwrapped value is used inside the
                                         // block or suggest deleting the unwrap, so we can't offer a
diff --git a/clippy_lints/src/upper_case_acronyms.rs b/clippy_lints/src/upper_case_acronyms.rs
index 02bf09ed506..378cc427f5a 100644
--- a/clippy_lints/src/upper_case_acronyms.rs
+++ b/clippy_lints/src/upper_case_acronyms.rs
@@ -93,7 +93,7 @@ fn check_ident(cx: &LateContext<'_>, ident: &Ident, be_aggressive: bool) {
             cx,
             UPPER_CASE_ACRONYMS,
             span,
-            &format!("name `{}` contains a capitalized acronym", ident),
+            &format!("name `{ident}` contains a capitalized acronym"),
             "consider making the acronym lowercase, except the initial letter",
             corrected,
             Applicability::MaybeIncorrect,
diff --git a/clippy_lints/src/useless_conversion.rs b/clippy_lints/src/useless_conversion.rs
index f1b6463ad0f..50c5a832430 100644
--- a/clippy_lints/src/useless_conversion.rs
+++ b/clippy_lints/src/useless_conversion.rs
@@ -74,7 +74,7 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
                             cx,
                             USELESS_CONVERSION,
                             e.span,
-                            &format!("useless conversion to the same type: `{}`", b),
+                            &format!("useless conversion to the same type: `{b}`"),
                             "consider removing `.into()`",
                             sugg,
                             Applicability::MachineApplicable, // snippet
@@ -97,7 +97,7 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
                             cx,
                             USELESS_CONVERSION,
                             e.span,
-                            &format!("useless conversion to the same type: `{}`", b),
+                            &format!("useless conversion to the same type: `{b}`"),
                             "consider removing `.into_iter()`",
                             sugg,
                             Applicability::MachineApplicable, // snippet
@@ -118,7 +118,7 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
                             cx,
                             USELESS_CONVERSION,
                             e.span,
-                            &format!("useless conversion to the same type: `{}`", b),
+                            &format!("useless conversion to the same type: `{b}`"),
                             None,
                             "consider removing `.try_into()`",
                         );
@@ -146,7 +146,7 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
                                     cx,
                                     USELESS_CONVERSION,
                                     e.span,
-                                    &format!("useless conversion to the same type: `{}`", b),
+                                    &format!("useless conversion to the same type: `{b}`"),
                                     None,
                                     &hint,
                                 );
@@ -165,7 +165,7 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
                                     cx,
                                     USELESS_CONVERSION,
                                     e.span,
-                                    &format!("useless conversion to the same type: `{}`", b),
+                                    &format!("useless conversion to the same type: `{b}`"),
                                     &sugg_msg,
                                     sugg.to_string(),
                                     Applicability::MachineApplicable, // snippet
diff --git a/clippy_lints/src/utils/author.rs b/clippy_lints/src/utils/author.rs
index 4003fff27c0..65576b7203f 100644
--- a/clippy_lints/src/utils/author.rs
+++ b/clippy_lints/src/utils/author.rs
@@ -739,7 +739,7 @@ fn path_to_string(path: &QPath<'_>) -> String {
                     *s += ", ";
                     write!(s, "{:?}", segment.ident.as_str()).unwrap();
                 },
-                other => write!(s, "/* unimplemented: {:?}*/", other).unwrap(),
+                other => write!(s, "/* unimplemented: {other:?}*/").unwrap(),
             },
             QPath::LangItem(..) => panic!("path_to_string: called for lang item qpath"),
         }
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 2be3fa99c81..6f5a638be12 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -482,16 +482,13 @@ pub fn format_error(error: Box<dyn Error>) -> String {
                     let field = fields.get(index).copied().unwrap_or_default();
                     write!(
                         msg,
-                        "{:separator_width$}{:field_width$}",
-                        " ",
-                        field,
-                        separator_width = SEPARATOR_WIDTH,
-                        field_width = column_width
+                        "{:SEPARATOR_WIDTH$}{field:column_width$}",
+                        " "
                     )
                     .unwrap();
                 }
             }
-            write!(msg, "\n{}", suffix).unwrap();
+            write!(msg, "\n{suffix}").unwrap();
             msg
         } else {
             s
diff --git a/clippy_lints/src/wildcard_imports.rs b/clippy_lints/src/wildcard_imports.rs
index 5418eca382d..33138551011 100644
--- a/clippy_lints/src/wildcard_imports.rs
+++ b/clippy_lints/src/wildcard_imports.rs
@@ -173,7 +173,7 @@ impl LateLintPass<'_> for WildcardImports {
                 let sugg = if braced_glob {
                     imports_string
                 } else {
-                    format!("{}::{}", import_source_snippet, imports_string)
+                    format!("{import_source_snippet}::{imports_string}")
                 };
 
                 let (lint, message) = if let Res::Def(DefKind::Enum, _) = use_path.res {
diff --git a/clippy_lints/src/zero_div_zero.rs b/clippy_lints/src/zero_div_zero.rs
index 50d3c079fe6..9b3de35dbd3 100644
--- a/clippy_lints/src/zero_div_zero.rs
+++ b/clippy_lints/src/zero_div_zero.rs
@@ -57,8 +57,7 @@ impl<'tcx> LateLintPass<'tcx> for ZeroDiv {
                     "constant division of `0.0` with `0.0` will always result in NaN",
                     None,
                     &format!(
-                        "consider using `{}::NAN` if you would like a constant representing NaN",
-                        float_type,
+                        "consider using `{float_type}::NAN` if you would like a constant representing NaN",
                     ),
                 );
             }
-- 
cgit 1.4.1-3-g733a5


From cc6b375cd3edcee65adc6a7aa3e45a7a50fe8112 Mon Sep 17 00:00:00 2001
From: Yuri Astrakhan <YuriAstrakhan@gmail.com>
Date: Fri, 23 Sep 2022 22:20:42 -0400
Subject: fallout2: rework clippy_dev & _lints fmt inlining

* Inline format args where possible
* simplify a few complex macros into format str
* use formatdoc!() instead format!(indoc!(...))
---
 clippy_dev/src/fmt.rs                              |   6 +-
 clippy_dev/src/new_lint.rs                         | 167 +++++++++------------
 clippy_dev/src/serve.rs                            |   4 +-
 clippy_dev/src/setup/git_hook.rs                   |   7 +-
 clippy_dev/src/setup/intellij.rs                   |  25 ++-
 clippy_dev/src/setup/vscode.rs                     |  19 +--
 clippy_dev/src/update_lints.rs                     |  98 ++++++------
 clippy_lints/src/utils/internal_lints.rs           |  24 +--
 .../src/utils/internal_lints/metadata_collector.rs |  97 ++++--------
 9 files changed, 181 insertions(+), 266 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_dev/src/fmt.rs b/clippy_dev/src/fmt.rs
index 357cf6fc43a..25623144181 100644
--- a/clippy_dev/src/fmt.rs
+++ b/clippy_dev/src/fmt.rs
@@ -82,16 +82,16 @@ pub fn run(check: bool, verbose: bool) {
     fn output_err(err: CliError) {
         match err {
             CliError::CommandFailed(command, stderr) => {
-                eprintln!("error: A command failed! `{}`\nstderr: {}", command, stderr);
+                eprintln!("error: A command failed! `{command}`\nstderr: {stderr}");
             },
             CliError::IoError(err) => {
-                eprintln!("error: {}", err);
+                eprintln!("error: {err}");
             },
             CliError::RustfmtNotInstalled => {
                 eprintln!("error: rustfmt nightly is not installed.");
             },
             CliError::WalkDirError(err) => {
-                eprintln!("error: {}", err);
+                eprintln!("error: {err}");
             },
             CliError::IntellijSetupActive => {
                 eprintln!(
diff --git a/clippy_dev/src/new_lint.rs b/clippy_dev/src/new_lint.rs
index 9a68c6e775d..cbb2ec7c836 100644
--- a/clippy_dev/src/new_lint.rs
+++ b/clippy_dev/src/new_lint.rs
@@ -1,5 +1,5 @@
 use crate::clippy_project_root;
-use indoc::{indoc, writedoc};
+use indoc::{formatdoc, writedoc};
 use std::fmt::Write as _;
 use std::fs::{self, OpenOptions};
 use std::io::prelude::*;
@@ -23,7 +23,7 @@ impl<T> Context for io::Result<T> {
         match self {
             Ok(t) => Ok(t),
             Err(e) => {
-                let message = format!("{}: {}", text.as_ref(), e);
+                let message = format!("{}: {e}", text.as_ref());
                 Err(io::Error::new(ErrorKind::Other, message))
             },
         }
@@ -72,7 +72,7 @@ fn create_lint(lint: &LintData<'_>, enable_msrv: bool) -> io::Result<()> {
         let lint_contents = get_lint_file_contents(lint, enable_msrv);
         let lint_path = format!("clippy_lints/src/{}.rs", lint.name);
         write_file(lint.project_root.join(&lint_path), lint_contents.as_bytes())?;
-        println!("Generated lint file: `{}`", lint_path);
+        println!("Generated lint file: `{lint_path}`");
 
         Ok(())
     }
@@ -86,7 +86,7 @@ fn create_test(lint: &LintData<'_>) -> io::Result<()> {
 
         path.push("src");
         fs::create_dir(&path)?;
-        let header = format!("// compile-flags: --crate-name={}", lint_name);
+        let header = format!("// compile-flags: --crate-name={lint_name}");
         write_file(path.join("main.rs"), get_test_file_contents(lint_name, Some(&header)))?;
 
         Ok(())
@@ -106,7 +106,7 @@ fn create_test(lint: &LintData<'_>) -> io::Result<()> {
         let test_contents = get_test_file_contents(lint.name, None);
         write_file(lint.project_root.join(&test_path), test_contents)?;
 
-        println!("Generated test file: `{}`", test_path);
+        println!("Generated test file: `{test_path}`");
     }
 
     Ok(())
@@ -184,38 +184,36 @@ pub(crate) fn get_stabilization_version() -> String {
 }
 
 fn get_test_file_contents(lint_name: &str, header_commands: Option<&str>) -> String {
-    let mut contents = format!(
-        indoc! {"
-            #![allow(unused)]
-            #![warn(clippy::{})]
-
-            fn main() {{
-                // test code goes here
-            }}
-        "},
-        lint_name
+    let mut contents = formatdoc!(
+        r#"
+        #![allow(unused)]
+        #![warn(clippy::{lint_name})]
+
+        fn main() {{
+            // test code goes here
+        }}
+    "#
     );
 
     if let Some(header) = header_commands {
-        contents = format!("{}\n{}", header, contents);
+        contents = format!("{header}\n{contents}");
     }
 
     contents
 }
 
 fn get_manifest_contents(lint_name: &str, hint: &str) -> String {
-    format!(
-        indoc! {r#"
-            # {}
-
-            [package]
-            name = "{}"
-            version = "0.1.0"
-            publish = false
-
-            [workspace]
-        "#},
-        hint, lint_name
+    formatdoc!(
+        r#"
+        # {hint}
+
+        [package]
+        name = "{lint_name}"
+        version = "0.1.0"
+        publish = false
+
+        [workspace]
+    "#
     )
 }
 
@@ -236,76 +234,61 @@ fn get_lint_file_contents(lint: &LintData<'_>, enable_msrv: bool) -> String {
     let name_upper = lint_name.to_uppercase();
 
     result.push_str(&if enable_msrv {
-        format!(
-            indoc! {"
-                use clippy_utils::msrvs;
-                {pass_import}
-                use rustc_lint::{{{context_import}, {pass_type}, LintContext}};
-                use rustc_semver::RustcVersion;
-                use rustc_session::{{declare_tool_lint, impl_lint_pass}};
+        formatdoc!(
+            r#"
+            use clippy_utils::msrvs;
+            {pass_import}
+            use rustc_lint::{{{context_import}, {pass_type}, LintContext}};
+            use rustc_semver::RustcVersion;
+            use rustc_session::{{declare_tool_lint, impl_lint_pass}};
 
-            "},
-            pass_type = pass_type,
-            pass_import = pass_import,
-            context_import = context_import,
+        "#
         )
     } else {
-        format!(
-            indoc! {"
-                {pass_import}
-                use rustc_lint::{{{context_import}, {pass_type}}};
-                use rustc_session::{{declare_lint_pass, declare_tool_lint}};
-
-            "},
-            pass_import = pass_import,
-            pass_type = pass_type,
-            context_import = context_import
+        formatdoc!(
+            r#"
+            {pass_import}
+            use rustc_lint::{{{context_import}, {pass_type}}};
+            use rustc_session::{{declare_lint_pass, declare_tool_lint}};
+
+        "#
         )
     });
 
     let _ = write!(result, "{}", get_lint_declaration(&name_upper, category));
 
     result.push_str(&if enable_msrv {
-        format!(
-            indoc! {"
-                pub struct {name_camel} {{
-                    msrv: Option<RustcVersion>,
-                }}
+        formatdoc!(
+            r#"
+            pub struct {name_camel} {{
+                msrv: Option<RustcVersion>,
+            }}
 
-                impl {name_camel} {{
-                    #[must_use]
-                    pub fn new(msrv: Option<RustcVersion>) -> Self {{
-                        Self {{ msrv }}
-                    }}
+            impl {name_camel} {{
+                #[must_use]
+                pub fn new(msrv: Option<RustcVersion>) -> Self {{
+                    Self {{ msrv }}
                 }}
+            }}
 
-                impl_lint_pass!({name_camel} => [{name_upper}]);
+            impl_lint_pass!({name_camel} => [{name_upper}]);
 
-                impl {pass_type}{pass_lifetimes} for {name_camel} {{
-                    extract_msrv_attr!({context_import});
-                }}
+            impl {pass_type}{pass_lifetimes} for {name_camel} {{
+                extract_msrv_attr!({context_import});
+            }}
 
-                // TODO: Add MSRV level to `clippy_utils/src/msrvs.rs` if needed.
-                // TODO: Add MSRV test to `tests/ui/min_rust_version_attr.rs`.
-                // TODO: Update msrv config comment in `clippy_lints/src/utils/conf.rs`
-            "},
-            pass_type = pass_type,
-            pass_lifetimes = pass_lifetimes,
-            name_upper = name_upper,
-            name_camel = name_camel,
-            context_import = context_import,
+            // TODO: Add MSRV level to `clippy_utils/src/msrvs.rs` if needed.
+            // TODO: Add MSRV test to `tests/ui/min_rust_version_attr.rs`.
+            // TODO: Update msrv config comment in `clippy_lints/src/utils/conf.rs`
+        "#
         )
     } else {
-        format!(
-            indoc! {"
-                declare_lint_pass!({name_camel} => [{name_upper}]);
+        formatdoc!(
+            r#"
+            declare_lint_pass!({name_camel} => [{name_upper}]);
 
-                impl {pass_type}{pass_lifetimes} for {name_camel} {{}}
-            "},
-            pass_type = pass_type,
-            pass_lifetimes = pass_lifetimes,
-            name_upper = name_upper,
-            name_camel = name_camel,
+            impl {pass_type}{pass_lifetimes} for {name_camel} {{}}
+        "#
         )
     });
 
@@ -313,8 +296,8 @@ fn get_lint_file_contents(lint: &LintData<'_>, enable_msrv: bool) -> String {
 }
 
 fn get_lint_declaration(name_upper: &str, category: &str) -> String {
-    format!(
-        indoc! {r#"
+    formatdoc!(
+        r#"
             declare_clippy_lint! {{
                 /// ### What it does
                 ///
@@ -328,15 +311,13 @@ fn get_lint_declaration(name_upper: &str, category: &str) -> String {
                 /// ```rust
                 /// // example code which does not raise clippy warning
                 /// ```
-                #[clippy::version = "{version}"]
+                #[clippy::version = "{}"]
                 pub {name_upper},
                 {category},
                 "default lint description"
             }}
-        "#},
-        version = get_stabilization_version(),
-        name_upper = name_upper,
-        category = category,
+        "#,
+        get_stabilization_version(),
     )
 }
 
@@ -350,7 +331,7 @@ fn create_lint_for_ty(lint: &LintData<'_>, enable_msrv: bool, ty: &str) -> io::R
         _ => {},
     }
 
-    let ty_dir = lint.project_root.join(format!("clippy_lints/src/{}", ty));
+    let ty_dir = lint.project_root.join(format!("clippy_lints/src/{ty}"));
     assert!(
         ty_dir.exists() && ty_dir.is_dir(),
         "Directory `{}` does not exist!",
@@ -410,10 +391,10 @@ fn create_lint_for_ty(lint: &LintData<'_>, enable_msrv: bool, ty: &str) -> io::R
     }
 
     write_file(lint_file_path.as_path(), lint_file_contents)?;
-    println!("Generated lint file: `clippy_lints/src/{}/{}.rs`", ty, lint.name);
+    println!("Generated lint file: `clippy_lints/src/{ty}/{}.rs`", lint.name);
     println!(
-        "Be sure to add a call to `{}::check` in `clippy_lints/src/{}/mod.rs`!",
-        lint.name, ty
+        "Be sure to add a call to `{}::check` in `clippy_lints/src/{ty}/mod.rs`!",
+        lint.name
     );
 
     Ok(())
@@ -540,7 +521,7 @@ fn setup_mod_file(path: &Path, lint: &LintData<'_>) -> io::Result<&'static str>
         .chain(std::iter::once(&*lint_name_upper))
         .filter(|s| !s.is_empty())
     {
-        let _ = write!(new_arr_content, "\n    {},", ident);
+        let _ = write!(new_arr_content, "\n    {ident},");
     }
     new_arr_content.push('\n');
 
diff --git a/clippy_dev/src/serve.rs b/clippy_dev/src/serve.rs
index f15f24da946..2e0794f12fa 100644
--- a/clippy_dev/src/serve.rs
+++ b/clippy_dev/src/serve.rs
@@ -10,8 +10,8 @@ use std::time::{Duration, SystemTime};
 /// Panics if the python commands could not be spawned
 pub fn run(port: u16, lint: Option<&String>) -> ! {
     let mut url = Some(match lint {
-        None => format!("http://localhost:{}", port),
-        Some(lint) => format!("http://localhost:{}/#{}", port, lint),
+        None => format!("http://localhost:{port}"),
+        Some(lint) => format!("http://localhost:{port}/#{lint}"),
     });
 
     loop {
diff --git a/clippy_dev/src/setup/git_hook.rs b/clippy_dev/src/setup/git_hook.rs
index 3fbb77d5923..1de5b1940ba 100644
--- a/clippy_dev/src/setup/git_hook.rs
+++ b/clippy_dev/src/setup/git_hook.rs
@@ -30,10 +30,7 @@ pub fn install_hook(force_override: bool) {
             println!("info: the hook can be removed with `cargo dev remove git-hook`");
             println!("git hook successfully installed");
         },
-        Err(err) => eprintln!(
-            "error: unable to copy `{}` to `{}` ({})",
-            HOOK_SOURCE_FILE, HOOK_TARGET_FILE, err
-        ),
+        Err(err) => eprintln!("error: unable to copy `{HOOK_SOURCE_FILE}` to `{HOOK_TARGET_FILE}` ({err})"),
     }
 }
 
@@ -77,7 +74,7 @@ pub fn remove_hook() {
 
 fn delete_git_hook_file(path: &Path) -> bool {
     if let Err(err) = fs::remove_file(path) {
-        eprintln!("error: unable to delete existing pre-commit git hook ({})", err);
+        eprintln!("error: unable to delete existing pre-commit git hook ({err})");
         false
     } else {
         true
diff --git a/clippy_dev/src/setup/intellij.rs b/clippy_dev/src/setup/intellij.rs
index bf741e6d121..b64e79733eb 100644
--- a/clippy_dev/src/setup/intellij.rs
+++ b/clippy_dev/src/setup/intellij.rs
@@ -60,7 +60,7 @@ fn check_and_get_rustc_dir(rustc_path: &str) -> Result<PathBuf, ()> {
                 path = absolute_path;
             },
             Err(err) => {
-                eprintln!("error: unable to get the absolute path of rustc ({})", err);
+                eprintln!("error: unable to get the absolute path of rustc ({err})");
                 return Err(());
             },
         };
@@ -103,14 +103,14 @@ fn inject_deps_into_project(rustc_source_dir: &Path, project: &ClippyProjectInfo
 fn read_project_file(file_path: &str) -> Result<String, ()> {
     let path = Path::new(file_path);
     if !path.exists() {
-        eprintln!("error: unable to find the file `{}`", file_path);
+        eprintln!("error: unable to find the file `{file_path}`");
         return Err(());
     }
 
     match fs::read_to_string(path) {
         Ok(content) => Ok(content),
         Err(err) => {
-            eprintln!("error: the file `{}` could not be read ({})", file_path, err);
+            eprintln!("error: the file `{file_path}` could not be read ({err})");
             Err(())
         },
     }
@@ -124,10 +124,7 @@ fn inject_deps_into_manifest(
 ) -> std::io::Result<()> {
     // do not inject deps if we have already done so
     if cargo_toml.contains(RUSTC_PATH_SECTION) {
-        eprintln!(
-            "warn: dependencies are already setup inside {}, skipping file",
-            manifest_path
-        );
+        eprintln!("warn: dependencies are already setup inside {manifest_path}, skipping file");
         return Ok(());
     }
 
@@ -142,11 +139,7 @@ fn inject_deps_into_manifest(
 
     let new_deps = extern_crates.map(|dep| {
         // format the dependencies that are going to be put inside the Cargo.toml
-        format!(
-            "{dep} = {{ path = \"{source_path}/{dep}\" }}\n",
-            dep = dep,
-            source_path = rustc_source_dir.display()
-        )
+        format!("{dep} = {{ path = \"{}/{dep}\" }}\n", rustc_source_dir.display())
     });
 
     // format a new [dependencies]-block with the new deps we need to inject
@@ -163,11 +156,11 @@ fn inject_deps_into_manifest(
     // etc
     let new_manifest = cargo_toml.replacen("[dependencies]\n", &all_deps, 1);
 
-    // println!("{}", new_manifest);
+    // println!("{new_manifest}");
     let mut file = File::create(manifest_path)?;
     file.write_all(new_manifest.as_bytes())?;
 
-    println!("info: successfully setup dependencies inside {}", manifest_path);
+    println!("info: successfully setup dependencies inside {manifest_path}");
 
     Ok(())
 }
@@ -214,8 +207,8 @@ fn remove_rustc_src_from_project(project: &ClippyProjectInfo) -> bool {
         },
         Err(err) => {
             eprintln!(
-                "error: unable to open file `{}` to remove rustc dependencies for {} ({})",
-                project.cargo_file, project.name, err
+                "error: unable to open file `{}` to remove rustc dependencies for {} ({err})",
+                project.cargo_file, project.name
             );
             false
         },
diff --git a/clippy_dev/src/setup/vscode.rs b/clippy_dev/src/setup/vscode.rs
index d59001b2c66..dbcdc9b59e5 100644
--- a/clippy_dev/src/setup/vscode.rs
+++ b/clippy_dev/src/setup/vscode.rs
@@ -17,10 +17,7 @@ pub fn install_tasks(force_override: bool) {
             println!("info: the task file can be removed with `cargo dev remove vscode-tasks`");
             println!("vscode tasks successfully installed");
         },
-        Err(err) => eprintln!(
-            "error: unable to copy `{}` to `{}` ({})",
-            TASK_SOURCE_FILE, TASK_TARGET_FILE, err
-        ),
+        Err(err) => eprintln!("error: unable to copy `{TASK_SOURCE_FILE}` to `{TASK_TARGET_FILE}` ({err})"),
     }
 }
 
@@ -44,23 +41,17 @@ fn check_install_precondition(force_override: bool) -> bool {
                 return delete_vs_task_file(path);
             }
 
-            eprintln!(
-                "error: there is already a `task.json` file inside the `{}` directory",
-                VSCODE_DIR
-            );
+            eprintln!("error: there is already a `task.json` file inside the `{VSCODE_DIR}` directory");
             println!("info: use the `--force-override` flag to override the existing `task.json` file");
             return false;
         }
     } else {
         match fs::create_dir(vs_dir_path) {
             Ok(_) => {
-                println!("info: created `{}` directory for clippy", VSCODE_DIR);
+                println!("info: created `{VSCODE_DIR}` directory for clippy");
             },
             Err(err) => {
-                eprintln!(
-                    "error: the task target directory `{}` could not be created ({})",
-                    VSCODE_DIR, err
-                );
+                eprintln!("error: the task target directory `{VSCODE_DIR}` could not be created ({err})");
             },
         }
     }
@@ -82,7 +73,7 @@ pub fn remove_tasks() {
 
 fn delete_vs_task_file(path: &Path) -> bool {
     if let Err(err) = fs::remove_file(path) {
-        eprintln!("error: unable to delete the existing `tasks.json` file ({})", err);
+        eprintln!("error: unable to delete the existing `tasks.json` file ({err})");
         return false;
     }
 
diff --git a/clippy_dev/src/update_lints.rs b/clippy_dev/src/update_lints.rs
index b95061bf81a..93955bee3f4 100644
--- a/clippy_dev/src/update_lints.rs
+++ b/clippy_dev/src/update_lints.rs
@@ -86,7 +86,7 @@ fn generate_lint_files(
                 )
                 .sorted()
             {
-                writeln!(res, "[`{}`]: {}#{}", lint, DOCS_LINK, lint).unwrap();
+                writeln!(res, "[`{lint}`]: {DOCS_LINK}#{lint}").unwrap();
             }
         },
     );
@@ -99,7 +99,7 @@ fn generate_lint_files(
         "// end lints modules, do not remove this comment, it’s used in `update_lints`",
         |res| {
             for lint_mod in usable_lints.iter().map(|l| &l.module).unique().sorted() {
-                writeln!(res, "mod {};", lint_mod).unwrap();
+                writeln!(res, "mod {lint_mod};").unwrap();
             }
         },
     );
@@ -129,7 +129,7 @@ fn generate_lint_files(
     for (lint_group, lints) in Lint::by_lint_group(usable_lints.into_iter().chain(internal_lints)) {
         let content = gen_lint_group_list(&lint_group, lints.iter());
         process_file(
-            &format!("clippy_lints/src/lib.register_{}.rs", lint_group),
+            &format!("clippy_lints/src/lib.register_{lint_group}.rs"),
             update_mode,
             &content,
         );
@@ -190,9 +190,9 @@ fn print_lint_names(header: &str, lints: &BTreeSet<String>) -> bool {
     if lints.is_empty() {
         return false;
     }
-    println!("{}", header);
+    println!("{header}");
     for lint in lints.iter().sorted() {
-        println!("    {}", lint);
+        println!("    {lint}");
     }
     println!();
     true
@@ -205,16 +205,16 @@ pub fn print_lints() {
     let grouped_by_lint_group = Lint::by_lint_group(usable_lints.into_iter());
 
     for (lint_group, mut lints) in grouped_by_lint_group {
-        println!("\n## {}", lint_group);
+        println!("\n## {lint_group}");
 
         lints.sort_by_key(|l| l.name.clone());
 
         for lint in lints {
-            println!("* [{}]({}#{}) ({})", lint.name, DOCS_LINK, lint.name, lint.desc);
+            println!("* [{}]({DOCS_LINK}#{}) ({})", lint.name, lint.name, lint.desc);
         }
     }
 
-    println!("there are {} lints", usable_lint_count);
+    println!("there are {usable_lint_count} lints");
 }
 
 /// Runs the `rename_lint` command.
@@ -235,10 +235,10 @@ pub fn print_lints() {
 #[allow(clippy::too_many_lines)]
 pub fn rename(old_name: &str, new_name: &str, uplift: bool) {
     if let Some((prefix, _)) = old_name.split_once("::") {
-        panic!("`{}` should not contain the `{}` prefix", old_name, prefix);
+        panic!("`{old_name}` should not contain the `{prefix}` prefix");
     }
     if let Some((prefix, _)) = new_name.split_once("::") {
-        panic!("`{}` should not contain the `{}` prefix", new_name, prefix);
+        panic!("`{new_name}` should not contain the `{prefix}` prefix");
     }
 
     let (mut lints, deprecated_lints, mut renamed_lints) = gather_all();
@@ -251,14 +251,14 @@ pub fn rename(old_name: &str, new_name: &str, uplift: bool) {
             found_new_name = true;
         }
     }
-    let old_lint_index = old_lint_index.unwrap_or_else(|| panic!("could not find lint `{}`", old_name));
+    let old_lint_index = old_lint_index.unwrap_or_else(|| panic!("could not find lint `{old_name}`"));
 
     let lint = RenamedLint {
-        old_name: format!("clippy::{}", old_name),
+        old_name: format!("clippy::{old_name}"),
         new_name: if uplift {
             new_name.into()
         } else {
-            format!("clippy::{}", new_name)
+            format!("clippy::{new_name}")
         },
     };
 
@@ -266,13 +266,11 @@ pub fn rename(old_name: &str, new_name: &str, uplift: bool) {
     // case.
     assert!(
         !renamed_lints.iter().any(|l| lint.old_name == l.old_name),
-        "`{}` has already been renamed",
-        old_name
+        "`{old_name}` has already been renamed"
     );
     assert!(
         !deprecated_lints.iter().any(|l| lint.old_name == l.name),
-        "`{}` has already been deprecated",
-        old_name
+        "`{old_name}` has already been deprecated"
     );
 
     // Update all lint level attributes. (`clippy::lint_name`)
@@ -309,14 +307,12 @@ pub fn rename(old_name: &str, new_name: &str, uplift: bool) {
     if uplift {
         write_file(Path::new("tests/ui/rename.rs"), &gen_renamed_lints_test(&renamed_lints));
         println!(
-            "`{}` has be uplifted. All the code inside `clippy_lints` related to it needs to be removed manually.",
-            old_name
+            "`{old_name}` has be uplifted. All the code inside `clippy_lints` related to it needs to be removed manually."
         );
     } else if found_new_name {
         write_file(Path::new("tests/ui/rename.rs"), &gen_renamed_lints_test(&renamed_lints));
         println!(
-            "`{}` is already defined. The old linting code inside `clippy_lints` needs to be updated/removed manually.",
-            new_name
+            "`{new_name}` is already defined. The old linting code inside `clippy_lints` needs to be updated/removed manually."
         );
     } else {
         // Rename the lint struct and source files sharing a name with the lint.
@@ -327,16 +323,16 @@ pub fn rename(old_name: &str, new_name: &str, uplift: bool) {
 
         // Rename test files. only rename `.stderr` and `.fixed` files if the new test name doesn't exist.
         if try_rename_file(
-            Path::new(&format!("tests/ui/{}.rs", old_name)),
-            Path::new(&format!("tests/ui/{}.rs", new_name)),
+            Path::new(&format!("tests/ui/{old_name}.rs")),
+            Path::new(&format!("tests/ui/{new_name}.rs")),
         ) {
             try_rename_file(
-                Path::new(&format!("tests/ui/{}.stderr", old_name)),
-                Path::new(&format!("tests/ui/{}.stderr", new_name)),
+                Path::new(&format!("tests/ui/{old_name}.stderr")),
+                Path::new(&format!("tests/ui/{new_name}.stderr")),
             );
             try_rename_file(
-                Path::new(&format!("tests/ui/{}.fixed", old_name)),
-                Path::new(&format!("tests/ui/{}.fixed", new_name)),
+                Path::new(&format!("tests/ui/{old_name}.fixed")),
+                Path::new(&format!("tests/ui/{new_name}.fixed")),
             );
         }
 
@@ -344,8 +340,8 @@ pub fn rename(old_name: &str, new_name: &str, uplift: bool) {
         let replacements;
         let replacements = if lint.module == old_name
             && try_rename_file(
-                Path::new(&format!("clippy_lints/src/{}.rs", old_name)),
-                Path::new(&format!("clippy_lints/src/{}.rs", new_name)),
+                Path::new(&format!("clippy_lints/src/{old_name}.rs")),
+                Path::new(&format!("clippy_lints/src/{new_name}.rs")),
             ) {
             // Edit the module name in the lint list. Note there could be multiple lints.
             for lint in lints.iter_mut().filter(|l| l.module == old_name) {
@@ -356,14 +352,14 @@ pub fn rename(old_name: &str, new_name: &str, uplift: bool) {
         } else if !lint.module.contains("::")
             // Catch cases like `methods/lint_name.rs` where the lint is stored in `methods/mod.rs`
             && try_rename_file(
-                Path::new(&format!("clippy_lints/src/{}/{}.rs", lint.module, old_name)),
-                Path::new(&format!("clippy_lints/src/{}/{}.rs", lint.module, new_name)),
+                Path::new(&format!("clippy_lints/src/{}/{old_name}.rs", lint.module)),
+                Path::new(&format!("clippy_lints/src/{}/{new_name}.rs", lint.module)),
             )
         {
             // Edit the module name in the lint list. Note there could be multiple lints, or none.
-            let renamed_mod = format!("{}::{}", lint.module, old_name);
+            let renamed_mod = format!("{}::{old_name}", lint.module);
             for lint in lints.iter_mut().filter(|l| l.module == renamed_mod) {
-                lint.module = format!("{}::{}", lint.module, new_name);
+                lint.module = format!("{}::{new_name}", lint.module);
             }
             replacements = [(&*old_name_upper, &*new_name_upper), (old_name, new_name)];
             replacements.as_slice()
@@ -379,7 +375,7 @@ pub fn rename(old_name: &str, new_name: &str, uplift: bool) {
         }
 
         generate_lint_files(UpdateMode::Change, &lints, &deprecated_lints, &renamed_lints);
-        println!("{} has been successfully renamed", old_name);
+        println!("{old_name} has been successfully renamed");
     }
 
     println!("note: `cargo uitest` still needs to be run to update the test results");
@@ -408,7 +404,7 @@ pub fn deprecate(name: &str, reason: Option<&String>) {
         });
 
         generate_lint_files(UpdateMode::Change, &lints, &deprecated_lints, &renamed_lints);
-        println!("info: `{}` has successfully been deprecated", name);
+        println!("info: `{name}` has successfully been deprecated");
 
         if reason == DEFAULT_DEPRECATION_REASON {
             println!("note: the deprecation reason must be updated in `clippy_lints/src/deprecated_lints.rs`");
@@ -421,7 +417,7 @@ pub fn deprecate(name: &str, reason: Option<&String>) {
     let name_upper = name.to_uppercase();
 
     let (mut lints, deprecated_lints, renamed_lints) = gather_all();
-    let Some(lint) = lints.iter().find(|l| l.name == name_lower) else { eprintln!("error: failed to find lint `{}`", name); return; };
+    let Some(lint) = lints.iter().find(|l| l.name == name_lower) else { eprintln!("error: failed to find lint `{name}`"); return; };
 
     let mod_path = {
         let mut mod_path = PathBuf::from(format!("clippy_lints/src/{}", lint.module));
@@ -450,7 +446,7 @@ fn remove_lint_declaration(name: &str, path: &Path, lints: &mut Vec<Lint>) -> io
     }
 
     fn remove_test_assets(name: &str) {
-        let test_file_stem = format!("tests/ui/{}", name);
+        let test_file_stem = format!("tests/ui/{name}");
         let path = Path::new(&test_file_stem);
 
         // Some lints have their own directories, delete them
@@ -512,8 +508,7 @@ fn remove_lint_declaration(name: &str, path: &Path, lints: &mut Vec<Lint>) -> io
                     fs::read_to_string(path).unwrap_or_else(|_| panic!("failed to read `{}`", path.to_string_lossy()));
 
                 eprintln!(
-                    "warn: you will have to manually remove any code related to `{}` from `{}`",
-                    name,
+                    "warn: you will have to manually remove any code related to `{name}` from `{}`",
                     path.display()
                 );
 
@@ -528,7 +523,7 @@ fn remove_lint_declaration(name: &str, path: &Path, lints: &mut Vec<Lint>) -> io
                 content.replace_range(lint.declaration_range.clone(), "");
 
                 // Remove the module declaration (mod xyz;)
-                let mod_decl = format!("\nmod {};", name);
+                let mod_decl = format!("\nmod {name};");
                 content = content.replacen(&mod_decl, "", 1);
 
                 remove_impl_lint_pass(&lint.name.to_uppercase(), &mut content);
@@ -621,13 +616,13 @@ fn round_to_fifty(count: usize) -> usize {
 fn process_file(path: impl AsRef<Path>, update_mode: UpdateMode, content: &str) {
     if update_mode == UpdateMode::Check {
         let old_content =
-            fs::read_to_string(&path).unwrap_or_else(|e| panic!("Cannot read from {}: {}", path.as_ref().display(), e));
+            fs::read_to_string(&path).unwrap_or_else(|e| panic!("Cannot read from {}: {e}", path.as_ref().display()));
         if content != old_content {
             exit_with_failure();
         }
     } else {
         fs::write(&path, content.as_bytes())
-            .unwrap_or_else(|e| panic!("Cannot write to {}: {}", path.as_ref().display(), e));
+            .unwrap_or_else(|e| panic!("Cannot write to {}: {e}", path.as_ref().display()));
     }
 }
 
@@ -731,11 +726,10 @@ fn gen_lint_group_list<'a>(group_name: &str, lints: impl Iterator<Item = &'a Lin
 
     let _ = writeln!(
         output,
-        "store.register_group(true, \"clippy::{0}\", Some(\"clippy_{0}\"), vec![",
-        group_name
+        "store.register_group(true, \"clippy::{group_name}\", Some(\"clippy_{group_name}\"), vec![",
     );
     for (module, name) in details {
-        let _ = writeln!(output, "    LintId::of({}::{}),", module, name);
+        let _ = writeln!(output, "    LintId::of({module}::{name}),");
     }
     output.push_str("])\n");
 
@@ -783,7 +777,7 @@ fn gen_register_lint_list<'a>(
         if !is_public {
             output.push_str("    #[cfg(feature = \"internal\")]\n");
         }
-        let _ = writeln!(output, "    {}::{},", module_name, lint_name);
+        let _ = writeln!(output, "    {module_name}::{lint_name},");
     }
     output.push_str("])\n");
 
@@ -841,7 +835,7 @@ fn gather_all() -> (Vec<Lint>, Vec<DeprecatedLint>, Vec<RenamedLint>) {
     for (rel_path, file) in clippy_lints_src_files() {
         let path = file.path();
         let contents =
-            fs::read_to_string(path).unwrap_or_else(|e| panic!("Cannot read from `{}`: {}", path.display(), e));
+            fs::read_to_string(path).unwrap_or_else(|e| panic!("Cannot read from `{}`: {e}", path.display()));
         let module = rel_path
             .components()
             .map(|c| c.as_os_str().to_str().unwrap())
@@ -1050,7 +1044,7 @@ fn remove_line_splices(s: &str) -> String {
         .trim_matches('#')
         .strip_prefix('"')
         .and_then(|s| s.strip_suffix('"'))
-        .unwrap_or_else(|| panic!("expected quoted string, found `{}`", s));
+        .unwrap_or_else(|| panic!("expected quoted string, found `{s}`"));
     let mut res = String::with_capacity(s.len());
     unescape::unescape_literal(s, unescape::Mode::Str, &mut |range, ch| {
         if ch.is_ok() {
@@ -1076,10 +1070,10 @@ fn replace_region_in_file(
     end: &str,
     write_replacement: impl FnMut(&mut String),
 ) {
-    let contents = fs::read_to_string(path).unwrap_or_else(|e| panic!("Cannot read from `{}`: {}", path.display(), e));
+    let contents = fs::read_to_string(path).unwrap_or_else(|e| panic!("Cannot read from `{}`: {e}", path.display()));
     let new_contents = match replace_region_in_text(&contents, start, end, write_replacement) {
         Ok(x) => x,
-        Err(delim) => panic!("Couldn't find `{}` in file `{}`", delim, path.display()),
+        Err(delim) => panic!("Couldn't find `{delim}` in file `{}`", path.display()),
     };
 
     match update_mode {
@@ -1087,7 +1081,7 @@ fn replace_region_in_file(
         UpdateMode::Check => (),
         UpdateMode::Change => {
             if let Err(e) = fs::write(path, new_contents.as_bytes()) {
-                panic!("Cannot write to `{}`: {}", path.display(), e);
+                panic!("Cannot write to `{}`: {e}", path.display());
             }
         },
     }
@@ -1135,7 +1129,7 @@ fn try_rename_file(old_name: &Path, new_name: &Path) -> bool {
 
 #[allow(clippy::needless_pass_by_value)]
 fn panic_file(error: io::Error, name: &Path, action: &str) -> ! {
-    panic!("failed to {} file `{}`: {}", action, name.display(), error)
+    panic!("failed to {action} file `{}`: {error}", name.display())
 }
 
 fn rewrite_file(path: &Path, f: impl FnOnce(&str) -> Option<String>) {
diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs
index 17d9a041857..5332779c1c0 100644
--- a/clippy_lints/src/utils/internal_lints.rs
+++ b/clippy_lints/src/utils/internal_lints.rs
@@ -530,7 +530,7 @@ impl<'tcx> LateLintPass<'tcx> for LintWithoutLintPass {
                     cx,
                     LINT_WITHOUT_LINT_PASS,
                     lint_span,
-                    &format!("the lint `{}` is not added to any `LintPass`", lint_name),
+                    &format!("the lint `{lint_name}` is not added to any `LintPass`"),
                 );
             }
         }
@@ -666,7 +666,7 @@ impl<'tcx> LateLintPass<'tcx> for CompilerLintFunctions {
                     path.ident.span,
                     "usage of a compiler lint function",
                     None,
-                    &format!("please use the Clippy variant of this function: `{}`", sugg),
+                    &format!("please use the Clippy variant of this function: `{sugg}`"),
                 );
             }
         }
@@ -854,13 +854,8 @@ fn suggest_help(
         "this call is collapsible",
         "collapse into",
         format!(
-            "span_lint_and_help({}, {}, {}, {}, {}, {})",
-            and_then_snippets.cx,
-            and_then_snippets.lint,
-            and_then_snippets.span,
-            and_then_snippets.msg,
-            &option_span,
-            help
+            "span_lint_and_help({}, {}, {}, {}, {}, {help})",
+            and_then_snippets.cx, and_then_snippets.lint, and_then_snippets.span, and_then_snippets.msg, &option_span,
         ),
         Applicability::MachineApplicable,
     );
@@ -886,13 +881,8 @@ fn suggest_note(
         "this call is collapsible",
         "collapse into",
         format!(
-            "span_lint_and_note({}, {}, {}, {}, {}, {})",
-            and_then_snippets.cx,
-            and_then_snippets.lint,
-            and_then_snippets.span,
-            and_then_snippets.msg,
-            note_span,
-            note
+            "span_lint_and_note({}, {}, {}, {}, {note_span}, {note})",
+            and_then_snippets.cx, and_then_snippets.lint, and_then_snippets.span, and_then_snippets.msg,
         ),
         Applicability::MachineApplicable,
     );
@@ -927,7 +917,7 @@ impl<'tcx> LateLintPass<'tcx> for MatchTypeOnDiagItem {
                     expr.span,
                     "usage of `clippy_utils::ty::match_type()` on a type diagnostic item",
                     "try",
-                    format!("clippy_utils::ty::is_type_diagnostic_item({}, {}, sym::{})", cx_snippet, ty_snippet, item_name),
+                    format!("clippy_utils::ty::is_type_diagnostic_item({cx_snippet}, {ty_snippet}, sym::{item_name})"),
                     Applicability::MaybeIncorrect,
                 );
             }
diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index 342f627e382..c84191bb010 100644
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -64,46 +64,6 @@ const DEFAULT_LINT_LEVELS: &[(&str, &str)] = &[
 /// This prefix is in front of the lint groups in the lint store. The prefix will be trimmed
 /// to only keep the actual lint group in the output.
 const CLIPPY_LINT_GROUP_PREFIX: &str = "clippy::";
-
-/// This template will be used to format the configuration section in the lint documentation.
-/// The `configurations` parameter will be replaced with one or multiple formatted
-/// `ClippyConfiguration` instances. See `CONFIGURATION_VALUE_TEMPLATE` for further customizations
-macro_rules! CONFIGURATION_SECTION_TEMPLATE {
-    () => {
-        r#"
-### Configuration
-This lint has the following configuration variables:
-
-{configurations}
-"#
-    };
-}
-/// This template will be used to format an individual `ClippyConfiguration` instance in the
-/// lint documentation.
-///
-/// The format function will provide strings for the following parameters: `name`, `ty`, `doc` and
-/// `default`
-macro_rules! CONFIGURATION_VALUE_TEMPLATE {
-    () => {
-        "* `{name}`: `{ty}`: {doc} (defaults to `{default}`)\n"
-    };
-}
-
-macro_rules! RENAMES_SECTION_TEMPLATE {
-    () => {
-        r#"
-### Past names
-
-{names}
-"#
-    };
-}
-macro_rules! RENAME_VALUE_TEMPLATE {
-    () => {
-        "* `{name}`\n"
-    };
-}
-
 const LINT_EMISSION_FUNCTIONS: [&[&str]; 7] = [
     &["clippy_utils", "diagnostics", "span_lint"],
     &["clippy_utils", "diagnostics", "span_lint_and_help"],
@@ -205,7 +165,16 @@ impl MetadataCollector {
             .filter(|config| config.lints.iter().any(|lint| lint == lint_name))
             .map(ToString::to_string)
             .reduce(|acc, x| acc + &x)
-            .map(|configurations| format!(CONFIGURATION_SECTION_TEMPLATE!(), configurations = configurations))
+            .map(|configurations| {
+                format!(
+                    r#"
+### Configuration
+This lint has the following configuration variables:
+
+{configurations}
+"#
+                )
+            })
     }
 }
 
@@ -291,16 +260,13 @@ fn replace_produces(lint_name: &str, docs: &mut String, clippy_project_root: &Pa
                             continue;
                         }
 
-                        panic!("lint `{}` has an unterminated code block", lint_name)
+                        panic!("lint `{lint_name}` has an unterminated code block")
                     }
 
                     break;
                 },
                 Some(line) if line.trim_start() == "{{produces}}" => {
-                    panic!(
-                        "lint `{}` has marker {{{{produces}}}} with an ignored or missing code block",
-                        lint_name
-                    )
+                    panic!("lint `{lint_name}` has marker {{{{produces}}}} with an ignored or missing code block")
                 },
                 Some(line) => {
                     let line = line.trim();
@@ -319,7 +285,7 @@ fn replace_produces(lint_name: &str, docs: &mut String, clippy_project_root: &Pa
             match lines.next() {
                 Some(line) if line.trim_start() == "```" => break,
                 Some(line) => example.push(line),
-                None => panic!("lint `{}` has an unterminated code block", lint_name),
+                None => panic!("lint `{lint_name}` has an unterminated code block"),
             }
         }
 
@@ -336,10 +302,9 @@ fn replace_produces(lint_name: &str, docs: &mut String, clippy_project_root: &Pa
                             <summary>Produces</summary>\n\
                             \n\
                             ```text\n\
-                            {}\n\
+                            {output}\n\
                             ```\n\
-                        </details>",
-                            output
+                        </details>"
                         ),
                     );
 
@@ -394,7 +359,7 @@ fn get_lint_output(lint_name: &str, example: &[&mut String], clippy_project_root
         panic!("failed to write to `{}`: {e}", file.as_path().to_string_lossy());
     }
 
-    let prefixed_name = format!("{}{lint_name}", CLIPPY_LINT_GROUP_PREFIX);
+    let prefixed_name = format!("{CLIPPY_LINT_GROUP_PREFIX}{lint_name}");
 
     let mut cmd = Command::new("cargo");
 
@@ -417,7 +382,7 @@ fn get_lint_output(lint_name: &str, example: &[&mut String], clippy_project_root
     let output = cmd
         .arg(file.as_path())
         .output()
-        .unwrap_or_else(|e| panic!("failed to run `{:?}`: {e}", cmd));
+        .unwrap_or_else(|e| panic!("failed to run `{cmd:?}`: {e}"));
 
     let tmp_file_path = file.to_string_lossy();
     let stderr = std::str::from_utf8(&output.stderr).unwrap();
@@ -441,8 +406,7 @@ fn get_lint_output(lint_name: &str, example: &[&mut String], clippy_project_root
         let rendered: Vec<&str> = msgs.iter().filter_map(|msg| msg["rendered"].as_str()).collect();
         let non_json: Vec<&str> = stderr.lines().filter(|line| !line.starts_with('{')).collect();
         panic!(
-            "did not find lint `{}` in output of example, got:\n{}\n{}",
-            lint_name,
+            "did not find lint `{lint_name}` in output of example, got:\n{}\n{}",
             non_json.join("\n"),
             rendered.join("\n")
         );
@@ -588,13 +552,10 @@ fn to_kebab(config_name: &str) -> String {
 
 impl fmt::Display for ClippyConfiguration {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> fmt::Result {
-        write!(
+        writeln!(
             f,
-            CONFIGURATION_VALUE_TEMPLATE!(),
-            name = self.name,
-            ty = self.config_type,
-            doc = self.doc,
-            default = self.default
+            "* `{}`: `{}`: {} (defaults to `{}`)",
+            self.name, self.config_type, self.doc, self.default
         )
     }
 }
@@ -811,7 +772,7 @@ fn get_lint_group_and_level_or_lint(
                 lint_collection_error_item(
                     cx,
                     item,
-                    &format!("Unable to determine lint level for found group `{}`", group),
+                    &format!("Unable to determine lint level for found group `{group}`"),
                 );
                 None
             }
@@ -869,7 +830,7 @@ fn collect_renames(lints: &mut Vec<LintMetadata>) {
                         if name == lint_name;
                         if let Some(past_name) = k.strip_prefix(CLIPPY_LINT_GROUP_PREFIX);
                         then {
-                            write!(collected, RENAME_VALUE_TEMPLATE!(), name = past_name).unwrap();
+                            writeln!(collected, "* `{past_name}`").unwrap();
                             names.push(past_name.to_string());
                         }
                     }
@@ -882,7 +843,15 @@ fn collect_renames(lints: &mut Vec<LintMetadata>) {
         }
 
         if !collected.is_empty() {
-            write!(&mut lint.docs, RENAMES_SECTION_TEMPLATE!(), names = collected).unwrap();
+            write!(
+                &mut lint.docs,
+                r#"
+### Past names
+
+{collected}
+"#
+            )
+            .unwrap();
         }
     }
 }
@@ -895,7 +864,7 @@ fn lint_collection_error_item(cx: &LateContext<'_>, item: &Item<'_>, message: &s
         cx,
         INTERNAL_METADATA_COLLECTOR,
         item.ident.span,
-        &format!("metadata collection error for `{}`: {}", item.ident.name, message),
+        &format!("metadata collection error for `{}`: {message}", item.ident.name),
     );
 }
 
-- 
cgit 1.4.1-3-g733a5


From 1141c553d8b443bdebc95e2fc13b04bd02031733 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sat, 24 Sep 2022 17:07:35 -0400
Subject: Fix ICE in `needless_pass_by_value` with unsized `dyn Fn`

---
 clippy_lints/src/needless_pass_by_value.rs | 3 ++-
 tests/ui/crashes/ice-9459.rs               | 5 +++++
 2 files changed, 7 insertions(+), 1 deletion(-)
 create mode 100644 tests/ui/crashes/ice-9459.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/needless_pass_by_value.rs b/clippy_lints/src/needless_pass_by_value.rs
index d7e6e7de2cc..924d4f91970 100644
--- a/clippy_lints/src/needless_pass_by_value.rs
+++ b/clippy_lints/src/needless_pass_by_value.rs
@@ -18,7 +18,7 @@ use rustc_middle::mir::FakeReadCause;
 use rustc_middle::ty::{self, TypeVisitable};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::symbol::kw;
-use rustc_span::{sym, Span};
+use rustc_span::{sym, Span, DUMMY_SP};
 use rustc_target::spec::abi::Abi;
 use rustc_trait_selection::traits;
 use rustc_trait_selection::traits::misc::can_type_implement_copy;
@@ -186,6 +186,7 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByValue {
                 if !is_self(arg);
                 if !ty.is_mutable_ptr();
                 if !is_copy(cx, ty);
+                if ty.is_sized(cx.tcx.at(DUMMY_SP), cx.param_env);
                 if !allowed_traits.iter().any(|&t| implements_trait(cx, ty, t, &[]));
                 if !implements_borrow_trait;
                 if !all_borrowable_trait;
diff --git a/tests/ui/crashes/ice-9459.rs b/tests/ui/crashes/ice-9459.rs
new file mode 100644
index 00000000000..55615124fcf
--- /dev/null
+++ b/tests/ui/crashes/ice-9459.rs
@@ -0,0 +1,5 @@
+#![feature(unsized_fn_params)]
+
+pub fn f0(_f: dyn FnOnce()) {}
+
+fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 93945a54a1a98bb6d7e268aa09cbe8eac34f3c99 Mon Sep 17 00:00:00 2001
From: alex-semenyuk <alexsemenyuk88@gmail.com>
Date: Sun, 25 Sep 2022 13:00:25 +0300
Subject: Please move derive_partial_eq_without_eq to nursery

---
 clippy_lints/src/derive.rs               | 2 +-
 clippy_lints/src/lib.register_all.rs     | 1 -
 clippy_lints/src/lib.register_nursery.rs | 1 +
 clippy_lints/src/lib.register_style.rs   | 1 -
 4 files changed, 2 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/derive.rs b/clippy_lints/src/derive.rs
index 9ca443b7dff..8d907743339 100644
--- a/clippy_lints/src/derive.rs
+++ b/clippy_lints/src/derive.rs
@@ -191,7 +191,7 @@ declare_clippy_lint! {
     /// ```
     #[clippy::version = "1.63.0"]
     pub DERIVE_PARTIAL_EQ_WITHOUT_EQ,
-    style,
+    nursery,
     "deriving `PartialEq` on a type that can implement `Eq`, without implementing `Eq`"
 }
 
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index ae57a9a24a7..d22cfcd8125 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -44,7 +44,6 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(derivable_impls::DERIVABLE_IMPLS),
     LintId::of(derive::DERIVE_HASH_XOR_EQ),
     LintId::of(derive::DERIVE_ORD_XOR_PARTIAL_ORD),
-    LintId::of(derive::DERIVE_PARTIAL_EQ_WITHOUT_EQ),
     LintId::of(disallowed_methods::DISALLOWED_METHODS),
     LintId::of(disallowed_names::DISALLOWED_NAMES),
     LintId::of(disallowed_types::DISALLOWED_TYPES),
diff --git a/clippy_lints/src/lib.register_nursery.rs b/clippy_lints/src/lib.register_nursery.rs
index 7171c655ccc..34835e22896 100644
--- a/clippy_lints/src/lib.register_nursery.rs
+++ b/clippy_lints/src/lib.register_nursery.rs
@@ -6,6 +6,7 @@ store.register_group(true, "clippy::nursery", Some("clippy_nursery"), vec![
     LintId::of(attrs::EMPTY_LINE_AFTER_OUTER_ATTR),
     LintId::of(cognitive_complexity::COGNITIVE_COMPLEXITY),
     LintId::of(copies::BRANCHES_SHARING_CODE),
+    LintId::of(derive::DERIVE_PARTIAL_EQ_WITHOUT_EQ),
     LintId::of(equatable_if_let::EQUATABLE_IF_LET),
     LintId::of(fallible_impl_from::FALLIBLE_IMPL_FROM),
     LintId::of(floating_point_arithmetic::IMPRECISE_FLOPS),
diff --git a/clippy_lints/src/lib.register_style.rs b/clippy_lints/src/lib.register_style.rs
index 05d2ec2e9e1..ab7c4034b0e 100644
--- a/clippy_lints/src/lib.register_style.rs
+++ b/clippy_lints/src/lib.register_style.rs
@@ -15,7 +15,6 @@ store.register_group(true, "clippy::style", Some("clippy_style"), vec![
     LintId::of(default::FIELD_REASSIGN_WITH_DEFAULT),
     LintId::of(default_instead_of_iter_empty::DEFAULT_INSTEAD_OF_ITER_EMPTY),
     LintId::of(dereference::NEEDLESS_BORROW),
-    LintId::of(derive::DERIVE_PARTIAL_EQ_WITHOUT_EQ),
     LintId::of(disallowed_methods::DISALLOWED_METHODS),
     LintId::of(disallowed_names::DISALLOWED_NAMES),
     LintId::of(disallowed_types::DISALLOWED_TYPES),
-- 
cgit 1.4.1-3-g733a5


From b180d954d600a8c9b98ee31d0298ce1b13b6291f Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sun, 25 Sep 2022 17:37:56 -0400
Subject: Don't lint `*_interior_mutable_const` on unions due to potential ICE.

---
 clippy_lints/src/non_copy_const.rs | 3 +++
 tests/ui/crashes/ice-9445.rs       | 3 +++
 2 files changed, 6 insertions(+)
 create mode 100644 tests/ui/crashes/ice-9445.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/non_copy_const.rs b/clippy_lints/src/non_copy_const.rs
index 72c86f28bbc..ea76ce2c573 100644
--- a/clippy_lints/src/non_copy_const.rs
+++ b/clippy_lints/src/non_copy_const.rs
@@ -149,6 +149,9 @@ fn is_value_unfrozen_raw<'tcx>(
             // the fact that we have to dig into every structs to search enums
             // leads us to the point checking `UnsafeCell` directly is the only option.
             ty::Adt(ty_def, ..) if ty_def.is_unsafe_cell() => true,
+            // As of 2022-09-08 miri doesn't track which union field is active so there's no safe way to check the
+            // contained value.
+            ty::Adt(def, ..) if def.is_union() => false,
             ty::Array(..) | ty::Adt(..) | ty::Tuple(..) => {
                 let val = cx.tcx.destructure_mir_constant(cx.param_env, val);
                 val.fields.iter().any(|field| inner(cx, *field))
diff --git a/tests/ui/crashes/ice-9445.rs b/tests/ui/crashes/ice-9445.rs
new file mode 100644
index 00000000000..c67b22f6f8c
--- /dev/null
+++ b/tests/ui/crashes/ice-9445.rs
@@ -0,0 +1,3 @@
+const UNINIT: core::mem::MaybeUninit<core::cell::Cell<&'static ()>> = core::mem::MaybeUninit::uninit();
+
+fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 5a71bbdf3faeedfe5227aecc2a97e566cbbbaf70 Mon Sep 17 00:00:00 2001
From: Yuri Astrakhan <YuriAstrakhan@gmail.com>
Date: Wed, 14 Sep 2022 12:25:48 -0400
Subject: new uninlined_format_args lint to inline explicit arguments

Implement https://github.com/rust-lang/rust-clippy/issues/8368 - a new
lint to inline format arguments such as `print!("{}", var)` into
`print!("{var}")`.

code | suggestion | comment
---|---|---
`print!("{}", var)` | `print!("{var}")` |  simple variables
`print!("{0}", var)` | `print!("{var}")` |  positional variables
`print!("{v}", v=var)` | `print!("{var}")` |  named variables
`print!("{0} {0}", var)` | `print!("{var} {var}")` |  aliased variables
`print!("{0:1$}", var, width)` | `print!("{var:width$}")` |  width
support
`print!("{0:.1$}", var, prec)` | `print!("{var:.prec$}")` |  precision
support
`print!("{:.*}", prec, var)` | `print!("{var:.prec$}")` |  asterisk
support

code | suggestion | comment
---|---|---
`print!("{0}={1}", var, 1+2)` | `print!("{var}={0}", 1+2)` | Format
string uses an indexed argument that cannot be inlined.  Supporting this
case requires re-indexing of the format string.

changelog: [`uninlined_format_args`]: A new lint to inline format
arguments, i.e. `print!("{}", var)` into `print!("{var}")`
---
 CHANGELOG.md                              |   1 +
 clippy_lints/src/format_args.rs           | 140 ++++-
 clippy_lints/src/lib.register_lints.rs    |   1 +
 clippy_lints/src/lib.register_pedantic.rs |   1 +
 clippy_lints/src/lib.rs                   |   2 +-
 clippy_lints/src/utils/conf.rs            |   2 +-
 clippy_lints/src/write.rs                 |  11 +-
 clippy_utils/src/macros.rs                |  69 ++-
 clippy_utils/src/msrvs.rs                 |   1 +
 clippy_utils/src/source.rs                |  10 +
 src/docs.rs                               |   1 +
 src/docs/uninlined_format_args.txt        |  36 ++
 tests/ui/uninlined_format_args.fixed      | 168 ++++++
 tests/ui/uninlined_format_args.rs         | 171 ++++++
 tests/ui/uninlined_format_args.stderr     | 866 ++++++++++++++++++++++++++++++
 15 files changed, 1451 insertions(+), 29 deletions(-)
 create mode 100644 src/docs/uninlined_format_args.txt
 create mode 100644 tests/ui/uninlined_format_args.fixed
 create mode 100644 tests/ui/uninlined_format_args.rs
 create mode 100644 tests/ui/uninlined_format_args.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index a56be486217..325b9bd8469 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4274,6 +4274,7 @@ Released 2018-09-13
 [`unimplemented`]: https://rust-lang.github.io/rust-clippy/master/index.html#unimplemented
 [`uninit_assumed_init`]: https://rust-lang.github.io/rust-clippy/master/index.html#uninit_assumed_init
 [`uninit_vec`]: https://rust-lang.github.io/rust-clippy/master/index.html#uninit_vec
+[`uninlined_format_args`]: https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
 [`unit_arg`]: https://rust-lang.github.io/rust-clippy/master/index.html#unit_arg
 [`unit_cmp`]: https://rust-lang.github.io/rust-clippy/master/index.html#unit_cmp
 [`unit_hash`]: https://rust-lang.github.io/rust-clippy/master/index.html#unit_hash
diff --git a/clippy_lints/src/format_args.rs b/clippy_lints/src/format_args.rs
index 192f6258aa5..89d81bdd485 100644
--- a/clippy_lints/src/format_args.rs
+++ b/clippy_lints/src/format_args.rs
@@ -1,16 +1,18 @@
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
-use clippy_utils::is_diag_trait_item;
-use clippy_utils::macros::{is_format_macro, FormatArgsExpn};
-use clippy_utils::source::snippet_opt;
+use clippy_utils::macros::FormatParamKind::{Implicit, Named, Numbered, Starred};
+use clippy_utils::macros::{is_format_macro, FormatArgsExpn, FormatParam, FormatParamUsage};
+use clippy_utils::source::{expand_past_previous_comma, snippet_opt};
 use clippy_utils::ty::implements_trait;
+use clippy_utils::{is_diag_trait_item, meets_msrv, msrvs};
 use if_chain::if_chain;
 use itertools::Itertools;
 use rustc_errors::Applicability;
-use rustc_hir::{Expr, ExprKind, HirId};
+use rustc_hir::{Expr, ExprKind, HirId, Path, QPath};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::adjustment::{Adjust, Adjustment};
 use rustc_middle::ty::Ty;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_semver::RustcVersion;
+use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::{sym, ExpnData, ExpnKind, Span, Symbol};
 
 declare_clippy_lint! {
@@ -64,7 +66,67 @@ declare_clippy_lint! {
     "`to_string` applied to a type that implements `Display` in format args"
 }
 
-declare_lint_pass!(FormatArgs => [FORMAT_IN_FORMAT_ARGS, TO_STRING_IN_FORMAT_ARGS]);
+declare_clippy_lint! {
+    /// ### What it does
+    /// Detect when a variable is not inlined in a format string,
+    /// and suggests to inline it.
+    ///
+    /// ### Why is this bad?
+    /// Non-inlined code is slightly more difficult to read and understand,
+    /// as it requires arguments to be matched against the format string.
+    /// The inlined syntax, where allowed, is simpler.
+    ///
+    /// ### Example
+    /// ```rust
+    /// # let var = 42;
+    /// # let width = 1;
+    /// # let prec = 2;
+    /// format!("{}", var);
+    /// format!("{v:?}", v = var);
+    /// format!("{0} {0}", var);
+    /// format!("{0:1$}", var, width);
+    /// format!("{:.*}", prec, var);
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// # let var = 42;
+    /// # let width = 1;
+    /// # let prec = 2;
+    /// format!("{var}");
+    /// format!("{var:?}");
+    /// format!("{var} {var}");
+    /// format!("{var:width$}");
+    /// format!("{var:.prec$}");
+    /// ```
+    ///
+    /// ### Known Problems
+    ///
+    /// There may be a false positive if the format string is expanded from certain proc macros:
+    ///
+    /// ```ignore
+    /// println!(indoc!("{}"), var);
+    /// ```
+    ///
+    /// If a format string contains a numbered argument that cannot be inlined
+    /// nothing will be suggested, e.g. `println!("{0}={1}", var, 1+2)`.
+    #[clippy::version = "1.65.0"]
+    pub UNINLINED_FORMAT_ARGS,
+    pedantic,
+    "using non-inlined variables in `format!` calls"
+}
+
+impl_lint_pass!(FormatArgs => [FORMAT_IN_FORMAT_ARGS, UNINLINED_FORMAT_ARGS, TO_STRING_IN_FORMAT_ARGS]);
+
+pub struct FormatArgs {
+    msrv: Option<RustcVersion>,
+}
+
+impl FormatArgs {
+    #[must_use]
+    pub fn new(msrv: Option<RustcVersion>) -> Self {
+        Self { msrv }
+    }
+}
 
 impl<'tcx> LateLintPass<'tcx> for FormatArgs {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
@@ -86,9 +148,73 @@ impl<'tcx> LateLintPass<'tcx> for FormatArgs {
                     check_format_in_format_args(cx, outermost_expn_data.call_site, name, arg.param.value);
                     check_to_string_in_format_args(cx, name, arg.param.value);
                 }
+                if meets_msrv(self.msrv, msrvs::FORMAT_ARGS_CAPTURE) {
+                    check_uninlined_args(cx, &format_args, outermost_expn_data.call_site);
+                }
             }
         }
     }
+
+    extract_msrv_attr!(LateContext);
+}
+
+fn check_uninlined_args(cx: &LateContext<'_>, args: &FormatArgsExpn<'_>, call_site: Span) {
+    if args.format_string.span.from_expansion() {
+        return;
+    }
+
+    let mut fixes = Vec::new();
+    // If any of the arguments are referenced by an index number,
+    // and that argument is not a simple variable and cannot be inlined,
+    // we cannot remove any other arguments in the format string,
+    // because the index numbers might be wrong after inlining.
+    // Example of an un-inlinable format:  print!("{}{1}", foo, 2)
+    if !args.params().all(|p| check_one_arg(cx, &p, &mut fixes)) || fixes.is_empty() {
+        return;
+    }
+
+    // FIXME: Properly ignore a rare case where the format string is wrapped in a macro.
+    // Example:  `format!(indoc!("{}"), foo);`
+    // If inlined, they will cause a compilation error:
+    //     > to avoid ambiguity, `format_args!` cannot capture variables
+    //     > when the format string is expanded from a macro
+    // @Alexendoo explanation:
+    //     > indoc! is a proc macro that is producing a string literal with its span
+    //     > set to its input it's not marked as from expansion, and since it's compatible
+    //     > tokenization wise clippy_utils::is_from_proc_macro wouldn't catch it either
+    // This might be a relatively expensive test, so do it only we are ready to replace.
+    // See more examples in tests/ui/uninlined_format_args.rs
+
+    span_lint_and_then(
+        cx,
+        UNINLINED_FORMAT_ARGS,
+        call_site,
+        "variables can be used directly in the `format!` string",
+        |diag| {
+            diag.multipart_suggestion("change this to", fixes, Applicability::MachineApplicable);
+        },
+    );
+}
+
+fn check_one_arg(cx: &LateContext<'_>, param: &FormatParam<'_>, fixes: &mut Vec<(Span, String)>) -> bool {
+    if matches!(param.kind, Implicit | Starred | Named(_) | Numbered)
+        && let ExprKind::Path(QPath::Resolved(None, path)) = param.value.kind
+        && let Path { span, segments, .. } = path
+        && let [segment] = segments
+    {
+        let replacement = match param.usage {
+            FormatParamUsage::Argument => segment.ident.name.to_string(),
+            FormatParamUsage::Width => format!("{}$", segment.ident.name),
+            FormatParamUsage::Precision => format!(".{}$", segment.ident.name),
+        };
+        fixes.push((param.span, replacement));
+        let arg_span = expand_past_previous_comma(cx, *span);
+        fixes.push((arg_span, String::new()));
+        true  // successful inlining, continue checking
+    } else {
+        // if we can't inline a numbered argument, we can't continue
+        param.kind != Numbered
+    }
 }
 
 fn outermost_expn_data(expn_data: ExpnData) -> ExpnData {
@@ -170,7 +296,7 @@ fn check_to_string_in_format_args(cx: &LateContext<'_>, name: Symbol, value: &Ex
     }
 }
 
-// Returns true if `hir_id` is referred to by multiple format params
+/// Returns true if `hir_id` is referred to by multiple format params
 fn is_aliased(args: &FormatArgsExpn<'_>, hir_id: HirId) -> bool {
     args.params()
         .filter(|param| param.value.hir_id == hir_id)
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 02fcc8de507..c6ac0178ffa 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -159,6 +159,7 @@ store.register_lints(&[
     format::USELESS_FORMAT,
     format_args::FORMAT_IN_FORMAT_ARGS,
     format_args::TO_STRING_IN_FORMAT_ARGS,
+    format_args::UNINLINED_FORMAT_ARGS,
     format_impl::PRINT_IN_FORMAT_IMPL,
     format_impl::RECURSIVE_FORMAT_IMPL,
     format_push_string::FORMAT_PUSH_STRING,
diff --git a/clippy_lints/src/lib.register_pedantic.rs b/clippy_lints/src/lib.register_pedantic.rs
index 03c3c202e0a..4eaabfbcc5f 100644
--- a/clippy_lints/src/lib.register_pedantic.rs
+++ b/clippy_lints/src/lib.register_pedantic.rs
@@ -29,6 +29,7 @@ store.register_group(true, "clippy::pedantic", Some("clippy_pedantic"), vec![
     LintId::of(eta_reduction::REDUNDANT_CLOSURE_FOR_METHOD_CALLS),
     LintId::of(excessive_bools::FN_PARAMS_EXCESSIVE_BOOLS),
     LintId::of(excessive_bools::STRUCT_EXCESSIVE_BOOLS),
+    LintId::of(format_args::UNINLINED_FORMAT_ARGS),
     LintId::of(functions::MUST_USE_CANDIDATE),
     LintId::of(functions::TOO_MANY_LINES),
     LintId::of(if_not_else::IF_NOT_ELSE),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 8a2a1682eca..73349ace882 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -855,7 +855,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         ))
     });
     store.register_late_pass(move || Box::new(undocumented_unsafe_blocks::UndocumentedUnsafeBlocks));
-    store.register_late_pass(move || Box::new(format_args::FormatArgs));
+    store.register_late_pass(move || Box::new(format_args::FormatArgs::new(msrv)));
     store.register_late_pass(|| Box::new(trailing_empty_array::TrailingEmptyArray));
     store.register_early_pass(|| Box::new(octal_escapes::OctalEscapes));
     store.register_late_pass(|| Box::new(needless_late_init::NeedlessLateInit));
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 6f5a638be12..a8265b50f27 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -213,7 +213,7 @@ define_Conf! {
     ///
     /// Suppress lints whenever the suggested change would cause breakage for other crates.
     (avoid_breaking_exported_api: bool = true),
-    /// Lint: MANUAL_SPLIT_ONCE, MANUAL_STR_REPEAT, CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR, IF_THEN_SOME_ELSE_NONE, APPROX_CONSTANT, DEPRECATED_CFG_ATTR, INDEX_REFUTABLE_SLICE, MAP_CLONE, BORROW_AS_PTR, MANUAL_BITS, ERR_EXPECT, CAST_ABS_TO_UNSIGNED.
+    /// Lint: MANUAL_SPLIT_ONCE, MANUAL_STR_REPEAT, CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR, IF_THEN_SOME_ELSE_NONE, APPROX_CONSTANT, DEPRECATED_CFG_ATTR, INDEX_REFUTABLE_SLICE, MAP_CLONE, BORROW_AS_PTR, MANUAL_BITS, ERR_EXPECT, CAST_ABS_TO_UNSIGNED, UNINLINED_FORMAT_ARGS.
     ///
     /// The minimum rust version that the project supports
     (msrv: Option<String> = None),
diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs
index 06e7d701701..3d3686604b7 100644
--- a/clippy_lints/src/write.rs
+++ b/clippy_lints/src/write.rs
@@ -1,12 +1,12 @@
 use clippy_utils::diagnostics::{span_lint, span_lint_and_then};
 use clippy_utils::macros::{root_macro_call_first_node, FormatArgsExpn, MacroCall};
-use clippy_utils::source::snippet_opt;
+use clippy_utils::source::{expand_past_previous_comma, snippet_opt};
 use rustc_ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, HirIdMap, Impl, Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::{sym, BytePos, Span};
+use rustc_span::{sym, BytePos};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -542,10 +542,3 @@ fn conservative_unescape(literal: &str) -> Result<String, UnescapeErr> {
 
     if err { Err(UnescapeErr::Lint) } else { Ok(unescaped) }
 }
-
-// Expand from `writeln!(o, "")` to `writeln!(o, "")`
-//                          ^^                 ^^^^
-fn expand_past_previous_comma(cx: &LateContext<'_>, span: Span) -> Span {
-    let extended = cx.sess().source_map().span_extend_to_prev_char(span, ',', true);
-    extended.with_lo(extended.lo() - BytePos(1))
-}
diff --git a/clippy_utils/src/macros.rs b/clippy_utils/src/macros.rs
index b9e6462a55e..079c8f50f12 100644
--- a/clippy_utils/src/macros.rs
+++ b/clippy_utils/src/macros.rs
@@ -545,19 +545,32 @@ fn span_from_inner(base: SpanData, inner: rpf::InnerSpan) -> Span {
     )
 }
 
+/// How a format parameter is used in the format string
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub enum FormatParamKind {
     /// An implicit parameter , such as `{}` or `{:?}`.
     Implicit,
-    /// A parameter with an explicit number, or an asterisk precision. e.g. `{1}`, `{0:?}`,
-    /// `{:.0$}` or `{:.*}`.
+    /// A parameter with an explicit number, e.g. `{1}`, `{0:?}`, or `{:.0$}`
     Numbered,
+    /// A parameter with an asterisk precision. e.g. `{:.*}`.
+    Starred,
     /// A named parameter with a named `value_arg`, such as the `x` in `format!("{x}", x = 1)`.
     Named(Symbol),
     /// An implicit named parameter, such as the `y` in `format!("{y}")`.
     NamedInline(Symbol),
 }
 
+/// Where a format parameter is being used in the format string
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub enum FormatParamUsage {
+    /// Appears as an argument, e.g. `format!("{}", foo)`
+    Argument,
+    /// Appears as a width, e.g. `format!("{:width$}", foo, width = 1)`
+    Width,
+    /// Appears as a precision, e.g. `format!("{:.precision$}", foo, precision = 1)`
+    Precision,
+}
+
 /// A `FormatParam` is any place in a `FormatArgument` that refers to a supplied value, e.g.
 ///
 /// ```
@@ -573,6 +586,8 @@ pub struct FormatParam<'tcx> {
     pub value: &'tcx Expr<'tcx>,
     /// How this parameter refers to its `value`.
     pub kind: FormatParamKind,
+    /// Where this format param is being used - argument/width/precision
+    pub usage: FormatParamUsage,
     /// Span of the parameter, may be zero width. Includes the whitespace of implicit parameters.
     ///
     /// ```text
@@ -585,6 +600,7 @@ pub struct FormatParam<'tcx> {
 impl<'tcx> FormatParam<'tcx> {
     fn new(
         mut kind: FormatParamKind,
+        usage: FormatParamUsage,
         position: usize,
         inner: rpf::InnerSpan,
         values: &FormatArgsValues<'tcx>,
@@ -599,7 +615,12 @@ impl<'tcx> FormatParam<'tcx> {
             kind = FormatParamKind::NamedInline(name);
         }
 
-        Some(Self { value, kind, span })
+        Some(Self {
+            value,
+            kind,
+            usage,
+            span,
+        })
     }
 }
 
@@ -618,6 +639,7 @@ pub enum Count<'tcx> {
 
 impl<'tcx> Count<'tcx> {
     fn new(
+        usage: FormatParamUsage,
         count: rpf::Count<'_>,
         position: Option<usize>,
         inner: Option<rpf::InnerSpan>,
@@ -625,15 +647,27 @@ impl<'tcx> Count<'tcx> {
     ) -> Option<Self> {
         Some(match count {
             rpf::Count::CountIs(val) => Self::Is(val, span_from_inner(values.format_string_span, inner?)),
-            rpf::Count::CountIsName(name, span) => Self::Param(FormatParam::new(
+            rpf::Count::CountIsName(name, _) => Self::Param(FormatParam::new(
                 FormatParamKind::Named(Symbol::intern(name)),
+                usage,
                 position?,
-                span,
+                inner?,
+                values,
+            )?),
+            rpf::Count::CountIsParam(_) => Self::Param(FormatParam::new(
+                FormatParamKind::Numbered,
+                usage,
+                position?,
+                inner?,
+                values,
+            )?),
+            rpf::Count::CountIsStar(_) => Self::Param(FormatParam::new(
+                FormatParamKind::Starred,
+                usage,
+                position?,
+                inner?,
                 values,
             )?),
-            rpf::Count::CountIsParam(_) | rpf::Count::CountIsStar(_) => {
-                Self::Param(FormatParam::new(FormatParamKind::Numbered, position?, inner?, values)?)
-            },
             rpf::Count::CountImplied => Self::Implied,
         })
     }
@@ -676,8 +710,20 @@ impl<'tcx> FormatSpec<'tcx> {
             fill: spec.fill,
             align: spec.align,
             flags: spec.flags,
-            precision: Count::new(spec.precision, positions.precision, spec.precision_span, values)?,
-            width: Count::new(spec.width, positions.width, spec.width_span, values)?,
+            precision: Count::new(
+                FormatParamUsage::Precision,
+                spec.precision,
+                positions.precision,
+                spec.precision_span,
+                values,
+            )?,
+            width: Count::new(
+                FormatParamUsage::Width,
+                spec.width,
+                positions.width,
+                spec.width_span,
+                values,
+            )?,
             r#trait: match spec.ty {
                 "" => sym::Display,
                 "?" => sym::Debug,
@@ -723,7 +769,7 @@ pub struct FormatArg<'tcx> {
 pub struct FormatArgsExpn<'tcx> {
     /// The format string literal.
     pub format_string: FormatString,
-    // The format arguments, such as `{:?}`.
+    /// The format arguments, such as `{:?}`.
     pub args: Vec<FormatArg<'tcx>>,
     /// Has an added newline due to `println!()`/`writeln!()`/etc. The last format string part will
     /// include this added newline.
@@ -797,6 +843,7 @@ impl<'tcx> FormatArgsExpn<'tcx> {
                                 // NamedInline is handled by `FormatParam::new()`
                                 rpf::Position::ArgumentNamed(name) => FormatParamKind::Named(Symbol::intern(name)),
                             },
+                            FormatParamUsage::Argument,
                             position.value,
                             parsed_arg.position_span,
                             &values,
diff --git a/clippy_utils/src/msrvs.rs b/clippy_utils/src/msrvs.rs
index 62020e21c81..904091c57e8 100644
--- a/clippy_utils/src/msrvs.rs
+++ b/clippy_utils/src/msrvs.rs
@@ -13,6 +13,7 @@ macro_rules! msrv_aliases {
 // names may refer to stabilized feature flags or library items
 msrv_aliases! {
     1,62,0 { BOOL_THEN_SOME }
+    1,58,0 { FORMAT_ARGS_CAPTURE }
     1,53,0 { OR_PATTERNS, MANUAL_BITS, BTREE_MAP_RETAIN, BTREE_SET_RETAIN, ARRAY_INTO_ITERATOR }
     1,52,0 { STR_SPLIT_ONCE, REM_EUCLID_CONST }
     1,51,0 { BORROW_AS_PTR, UNSIGNED_ABS }
diff --git a/clippy_utils/src/source.rs b/clippy_utils/src/source.rs
index 64c3f70efa5..d28bd92d708 100644
--- a/clippy_utils/src/source.rs
+++ b/clippy_utils/src/source.rs
@@ -392,6 +392,16 @@ pub fn trim_span(sm: &SourceMap, span: Span) -> Span {
     .span()
 }
 
+/// Expand a span to include a preceding comma
+/// ```rust,ignore
+/// writeln!(o, "")   ->   writeln!(o, "")
+///             ^^                   ^^^^
+/// ```
+pub fn expand_past_previous_comma(cx: &LateContext<'_>, span: Span) -> Span {
+    let extended = cx.sess().source_map().span_extend_to_prev_char(span, ',', true);
+    extended.with_lo(extended.lo() - BytePos(1))
+}
+
 #[cfg(test)]
 mod test {
     use super::{reindent_multiline, without_block_comments};
diff --git a/src/docs.rs b/src/docs.rs
index 6c89b4dde37..a501b56ffbe 100644
--- a/src/docs.rs
+++ b/src/docs.rs
@@ -521,6 +521,7 @@ docs! {
     "unimplemented",
     "uninit_assumed_init",
     "uninit_vec",
+    "uninlined_format_args",
     "unit_arg",
     "unit_cmp",
     "unit_hash",
diff --git a/src/docs/uninlined_format_args.txt b/src/docs/uninlined_format_args.txt
new file mode 100644
index 00000000000..3d2966c84db
--- /dev/null
+++ b/src/docs/uninlined_format_args.txt
@@ -0,0 +1,36 @@
+### What it does
+Detect when a variable is not inlined in a format string,
+and suggests to inline it.
+
+### Why is this bad?
+Non-inlined code is slightly more difficult to read and understand,
+as it requires arguments to be matched against the format string.
+The inlined syntax, where allowed, is simpler.
+
+### Example
+```
+format!("{}", var);
+format!("{v:?}", v = var);
+format!("{0} {0}", var);
+format!("{0:1$}", var, width);
+format!("{:.*}", prec, var);
+```
+Use instead:
+```
+format!("{var}");
+format!("{var:?}");
+format!("{var} {var}");
+format!("{var:width$}");
+format!("{var:.prec$}");
+```
+
+### Known Problems
+
+There may be a false positive if the format string is expanded from certain proc macros:
+
+```
+println!(indoc!("{}"), var);
+```
+
+If a format string contains a numbered argument that cannot be inlined
+nothing will be suggested, e.g. `println!("{0}={1}", var, 1+2)`.
\ No newline at end of file
diff --git a/tests/ui/uninlined_format_args.fixed b/tests/ui/uninlined_format_args.fixed
new file mode 100644
index 00000000000..bade0ed8ad6
--- /dev/null
+++ b/tests/ui/uninlined_format_args.fixed
@@ -0,0 +1,168 @@
+// run-rustfix
+
+#![allow(clippy::eq_op)]
+#![allow(clippy::format_in_format_args)]
+#![allow(clippy::print_literal)]
+#![allow(named_arguments_used_positionally)]
+#![allow(unused_variables, unused_imports, unused_macros)]
+#![warn(clippy::uninlined_format_args)]
+#![feature(custom_inner_attributes)]
+
+macro_rules! no_param_str {
+    () => {
+        "{}"
+    };
+}
+
+macro_rules! pass_through {
+    ($expr:expr) => {
+        $expr
+    };
+}
+
+macro_rules! my_println {
+   ($($args:tt),*) => {{
+        println!($($args),*)
+    }};
+}
+
+macro_rules! my_println_args {
+    ($($args:tt),*) => {{
+        println!("foo: {}", format_args!($($args),*))
+    }};
+}
+
+fn tester(fn_arg: i32) {
+    let local_i32 = 1;
+    let local_f64 = 2.0;
+    let local_opt: Option<i32> = Some(3);
+    let width = 4;
+    let prec = 5;
+    let val = 6;
+
+    // make sure this file hasn't been corrupted with tabs converted to spaces
+    // let _ = '	';  // <- this is a single tab character
+    let _: &[u8; 3] = b"	 	"; // <- <tab><space><tab>
+
+    println!("val='{local_i32}'");
+    println!("val='{local_i32}'"); // 3 spaces
+    println!("val='{local_i32}'"); // tab
+    println!("val='{local_i32}'"); // space+tab
+    println!("val='{local_i32}'"); // tab+space
+    println!(
+        "val='{local_i32}'"
+    );
+    println!("{local_i32}");
+    println!("{fn_arg}");
+    println!("{local_i32:?}");
+    println!("{local_i32:#?}");
+    println!("{local_i32:4}");
+    println!("{local_i32:04}");
+    println!("{local_i32:<3}");
+    println!("{local_i32:#010x}");
+    println!("{local_f64:.1}");
+    println!("Hello {} is {local_f64:.local_i32$}", "x");
+    println!("Hello {local_i32} is {local_f64:.*}", 5);
+    println!("Hello {local_i32} is {local_f64:.*}", 5);
+    println!("{local_i32} {local_f64}");
+    println!("{local_i32}, {}", local_opt.unwrap());
+    println!("{val}");
+    println!("{val}");
+    println!("{} {1}", local_i32, 42);
+    println!("val='{local_i32}'");
+    println!("val='{local_i32}'");
+    println!("val='{local_i32}'");
+    println!("val='{fn_arg}'");
+    println!("{local_i32}");
+    println!("{local_i32:?}");
+    println!("{local_i32:#?}");
+    println!("{local_i32:04}");
+    println!("{local_i32:<3}");
+    println!("{local_i32:#010x}");
+    println!("{local_f64:.1}");
+    println!("{local_i32} {local_i32}");
+    println!("{local_f64} {local_i32} {local_i32} {local_f64}");
+    println!("{local_i32} {local_f64}");
+    println!("{local_f64} {local_i32}");
+    println!("{local_f64} {local_i32} {local_f64} {local_i32}");
+    println!("{1} {0}", "str", local_i32);
+    println!("{local_i32}");
+    println!("{local_i32:width$}");
+    println!("{local_i32:width$}");
+    println!("{local_i32:.prec$}");
+    println!("{local_i32:.prec$}");
+    println!("{val:val$}");
+    println!("{val:val$}");
+    println!("{val:val$.val$}");
+    println!("{val:val$.val$}");
+    println!("{val:val$.val$}");
+    println!("{val:val$.val$}");
+    println!("{val:val$.val$}");
+    println!("{val:val$.val$}");
+    println!("{val:val$.val$}");
+    println!("{val:val$.val$}");
+    println!("{width:width$}");
+    println!("{local_i32:width$}");
+    println!("{width:width$}");
+    println!("{local_i32:width$}");
+    println!("{prec:.prec$}");
+    println!("{local_i32:.prec$}");
+    println!("{prec:.prec$}");
+    println!("{local_i32:.prec$}");
+    println!("{width:width$.prec$}");
+    println!("{width:width$.prec$}");
+    println!("{local_f64:width$.prec$}");
+    println!("{local_f64:width$.prec$} {local_f64} {width} {prec}");
+    println!(
+        "{local_i32:width$.prec$} {local_i32:prec$.width$} {width:local_i32$.prec$} {width:prec$.local_i32$} {prec:local_i32$.width$} {prec:width$.local_i32$}",
+    );
+    println!(
+        "{0:1$.2$} {0:2$.1$} {1:0$.2$} {1:2$.0$} {2:0$.1$} {2:1$.0$} {3}",
+        local_i32,
+        width,
+        prec,
+        1 + 2
+    );
+    println!("Width = {local_i32}, value with width = {local_f64:local_i32$}");
+    println!("{local_i32:width$.prec$}");
+    println!("{width:width$.prec$}");
+    println!("{}", format!("{local_i32}"));
+    my_println!("{}", local_i32);
+    my_println_args!("{}", local_i32);
+
+    // these should NOT be modified by the lint
+    println!(concat!("nope ", "{}"), local_i32);
+    println!("val='{local_i32}'");
+    println!("val='{local_i32 }'");
+    println!("val='{local_i32	}'"); // with tab
+    println!("val='{local_i32\n}'");
+    println!("{}", usize::MAX);
+    println!("{}", local_opt.unwrap());
+    println!(
+        "val='{local_i32
+    }'"
+    );
+    println!(no_param_str!(), local_i32);
+
+    // FIXME: bugs!
+    // println!(pass_through!("foo={local_i32}"), local_i32 = local_i32);
+    // println!(pass_through!("foo={}"), local_i32);
+    // println!(indoc!("foo={}"), local_i32);
+    // printdoc!("foo={}", local_i32);
+}
+
+fn main() {
+    tester(42);
+}
+
+fn _under_msrv() {
+    #![clippy::msrv = "1.57"]
+    let local_i32 = 1;
+    println!("don't expand='{}'", local_i32);
+}
+
+fn _meets_msrv() {
+    #![clippy::msrv = "1.58"]
+    let local_i32 = 1;
+    println!("expand='{local_i32}'");
+}
diff --git a/tests/ui/uninlined_format_args.rs b/tests/ui/uninlined_format_args.rs
new file mode 100644
index 00000000000..ac958f9e5b6
--- /dev/null
+++ b/tests/ui/uninlined_format_args.rs
@@ -0,0 +1,171 @@
+// run-rustfix
+
+#![allow(clippy::eq_op)]
+#![allow(clippy::format_in_format_args)]
+#![allow(clippy::print_literal)]
+#![allow(named_arguments_used_positionally)]
+#![allow(unused_variables, unused_imports, unused_macros)]
+#![warn(clippy::uninlined_format_args)]
+#![feature(custom_inner_attributes)]
+
+macro_rules! no_param_str {
+    () => {
+        "{}"
+    };
+}
+
+macro_rules! pass_through {
+    ($expr:expr) => {
+        $expr
+    };
+}
+
+macro_rules! my_println {
+   ($($args:tt),*) => {{
+        println!($($args),*)
+    }};
+}
+
+macro_rules! my_println_args {
+    ($($args:tt),*) => {{
+        println!("foo: {}", format_args!($($args),*))
+    }};
+}
+
+fn tester(fn_arg: i32) {
+    let local_i32 = 1;
+    let local_f64 = 2.0;
+    let local_opt: Option<i32> = Some(3);
+    let width = 4;
+    let prec = 5;
+    let val = 6;
+
+    // make sure this file hasn't been corrupted with tabs converted to spaces
+    // let _ = '	';  // <- this is a single tab character
+    let _: &[u8; 3] = b"	 	"; // <- <tab><space><tab>
+
+    println!("val='{}'", local_i32);
+    println!("val='{   }'", local_i32); // 3 spaces
+    println!("val='{	}'", local_i32); // tab
+    println!("val='{ 	}'", local_i32); // space+tab
+    println!("val='{	 }'", local_i32); // tab+space
+    println!(
+        "val='{
+    }'",
+        local_i32
+    );
+    println!("{}", local_i32);
+    println!("{}", fn_arg);
+    println!("{:?}", local_i32);
+    println!("{:#?}", local_i32);
+    println!("{:4}", local_i32);
+    println!("{:04}", local_i32);
+    println!("{:<3}", local_i32);
+    println!("{:#010x}", local_i32);
+    println!("{:.1}", local_f64);
+    println!("Hello {} is {:.*}", "x", local_i32, local_f64);
+    println!("Hello {} is {:.*}", local_i32, 5, local_f64);
+    println!("Hello {} is {2:.*}", local_i32, 5, local_f64);
+    println!("{} {}", local_i32, local_f64);
+    println!("{}, {}", local_i32, local_opt.unwrap());
+    println!("{}", val);
+    println!("{}", v = val);
+    println!("{} {1}", local_i32, 42);
+    println!("val='{\t }'", local_i32);
+    println!("val='{\n }'", local_i32);
+    println!("val='{local_i32}'", local_i32 = local_i32);
+    println!("val='{local_i32}'", local_i32 = fn_arg);
+    println!("{0}", local_i32);
+    println!("{0:?}", local_i32);
+    println!("{0:#?}", local_i32);
+    println!("{0:04}", local_i32);
+    println!("{0:<3}", local_i32);
+    println!("{0:#010x}", local_i32);
+    println!("{0:.1}", local_f64);
+    println!("{0} {0}", local_i32);
+    println!("{1} {} {0} {}", local_i32, local_f64);
+    println!("{0} {1}", local_i32, local_f64);
+    println!("{1} {0}", local_i32, local_f64);
+    println!("{1} {0} {1} {0}", local_i32, local_f64);
+    println!("{1} {0}", "str", local_i32);
+    println!("{v}", v = local_i32);
+    println!("{local_i32:0$}", width);
+    println!("{local_i32:w$}", w = width);
+    println!("{local_i32:.0$}", prec);
+    println!("{local_i32:.p$}", p = prec);
+    println!("{:0$}", v = val);
+    println!("{0:0$}", v = val);
+    println!("{:0$.0$}", v = val);
+    println!("{0:0$.0$}", v = val);
+    println!("{0:0$.v$}", v = val);
+    println!("{0:v$.0$}", v = val);
+    println!("{v:0$.0$}", v = val);
+    println!("{v:v$.0$}", v = val);
+    println!("{v:0$.v$}", v = val);
+    println!("{v:v$.v$}", v = val);
+    println!("{:0$}", width);
+    println!("{:1$}", local_i32, width);
+    println!("{:w$}", w = width);
+    println!("{:w$}", local_i32, w = width);
+    println!("{:.0$}", prec);
+    println!("{:.1$}", local_i32, prec);
+    println!("{:.p$}", p = prec);
+    println!("{:.p$}", local_i32, p = prec);
+    println!("{:0$.1$}", width, prec);
+    println!("{:0$.w$}", width, w = prec);
+    println!("{:1$.2$}", local_f64, width, prec);
+    println!("{:1$.2$} {0} {1} {2}", local_f64, width, prec);
+    println!(
+        "{0:1$.2$} {0:2$.1$} {1:0$.2$} {1:2$.0$} {2:0$.1$} {2:1$.0$}",
+        local_i32, width, prec,
+    );
+    println!(
+        "{0:1$.2$} {0:2$.1$} {1:0$.2$} {1:2$.0$} {2:0$.1$} {2:1$.0$} {3}",
+        local_i32,
+        width,
+        prec,
+        1 + 2
+    );
+    println!("Width = {}, value with width = {:0$}", local_i32, local_f64);
+    println!("{:w$.p$}", local_i32, w = width, p = prec);
+    println!("{:w$.p$}", w = width, p = prec);
+    println!("{}", format!("{}", local_i32));
+    my_println!("{}", local_i32);
+    my_println_args!("{}", local_i32);
+
+    // these should NOT be modified by the lint
+    println!(concat!("nope ", "{}"), local_i32);
+    println!("val='{local_i32}'");
+    println!("val='{local_i32 }'");
+    println!("val='{local_i32	}'"); // with tab
+    println!("val='{local_i32\n}'");
+    println!("{}", usize::MAX);
+    println!("{}", local_opt.unwrap());
+    println!(
+        "val='{local_i32
+    }'"
+    );
+    println!(no_param_str!(), local_i32);
+
+    // FIXME: bugs!
+    // println!(pass_through!("foo={local_i32}"), local_i32 = local_i32);
+    // println!(pass_through!("foo={}"), local_i32);
+    // println!(indoc!("foo={}"), local_i32);
+    // printdoc!("foo={}", local_i32);
+}
+
+fn main() {
+    tester(42);
+}
+
+fn _under_msrv() {
+    #![clippy::msrv = "1.57"]
+    let local_i32 = 1;
+    println!("don't expand='{}'", local_i32);
+}
+
+fn _meets_msrv() {
+    #![clippy::msrv = "1.58"]
+    let local_i32 = 1;
+    println!("expand='{}'", local_i32);
+}
diff --git a/tests/ui/uninlined_format_args.stderr b/tests/ui/uninlined_format_args.stderr
new file mode 100644
index 00000000000..7e652d0354f
--- /dev/null
+++ b/tests/ui/uninlined_format_args.stderr
@@ -0,0 +1,866 @@
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:47:5
+   |
+LL |     println!("val='{}'", local_i32);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::uninlined-format-args` implied by `-D warnings`
+help: change this to
+   |
+LL -     println!("val='{}'", local_i32);
+LL +     println!("val='{local_i32}'");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:48:5
+   |
+LL |     println!("val='{   }'", local_i32); // 3 spaces
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("val='{   }'", local_i32); // 3 spaces
+LL +     println!("val='{local_i32}'"); // 3 spaces
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:49:5
+   |
+LL |     println!("val='{    }'", local_i32); // tab
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("val='{    }'", local_i32); // tab
+LL +     println!("val='{local_i32}'"); // tab
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:50:5
+   |
+LL |     println!("val='{     }'", local_i32); // space+tab
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("val='{     }'", local_i32); // space+tab
+LL +     println!("val='{local_i32}'"); // space+tab
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:51:5
+   |
+LL |     println!("val='{     }'", local_i32); // tab+space
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("val='{     }'", local_i32); // tab+space
+LL +     println!("val='{local_i32}'"); // tab+space
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:52:5
+   |
+LL | /     println!(
+LL | |         "val='{
+LL | |     }'",
+LL | |         local_i32
+LL | |     );
+   | |_____^
+   |
+help: change this to
+   |
+LL -         "val='{
+LL +         "val='{local_i32}'"
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:57:5
+   |
+LL |     println!("{}", local_i32);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{}", local_i32);
+LL +     println!("{local_i32}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:58:5
+   |
+LL |     println!("{}", fn_arg);
+   |     ^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{}", fn_arg);
+LL +     println!("{fn_arg}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:59:5
+   |
+LL |     println!("{:?}", local_i32);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{:?}", local_i32);
+LL +     println!("{local_i32:?}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:60:5
+   |
+LL |     println!("{:#?}", local_i32);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{:#?}", local_i32);
+LL +     println!("{local_i32:#?}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:61:5
+   |
+LL |     println!("{:4}", local_i32);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{:4}", local_i32);
+LL +     println!("{local_i32:4}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:62:5
+   |
+LL |     println!("{:04}", local_i32);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{:04}", local_i32);
+LL +     println!("{local_i32:04}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:63:5
+   |
+LL |     println!("{:<3}", local_i32);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{:<3}", local_i32);
+LL +     println!("{local_i32:<3}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:64:5
+   |
+LL |     println!("{:#010x}", local_i32);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{:#010x}", local_i32);
+LL +     println!("{local_i32:#010x}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:65:5
+   |
+LL |     println!("{:.1}", local_f64);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{:.1}", local_f64);
+LL +     println!("{local_f64:.1}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:66:5
+   |
+LL |     println!("Hello {} is {:.*}", "x", local_i32, local_f64);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("Hello {} is {:.*}", "x", local_i32, local_f64);
+LL +     println!("Hello {} is {local_f64:.local_i32$}", "x");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:67:5
+   |
+LL |     println!("Hello {} is {:.*}", local_i32, 5, local_f64);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("Hello {} is {:.*}", local_i32, 5, local_f64);
+LL +     println!("Hello {local_i32} is {local_f64:.*}", 5);
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:68:5
+   |
+LL |     println!("Hello {} is {2:.*}", local_i32, 5, local_f64);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("Hello {} is {2:.*}", local_i32, 5, local_f64);
+LL +     println!("Hello {local_i32} is {local_f64:.*}", 5);
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:69:5
+   |
+LL |     println!("{} {}", local_i32, local_f64);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{} {}", local_i32, local_f64);
+LL +     println!("{local_i32} {local_f64}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:70:5
+   |
+LL |     println!("{}, {}", local_i32, local_opt.unwrap());
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{}, {}", local_i32, local_opt.unwrap());
+LL +     println!("{local_i32}, {}", local_opt.unwrap());
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:71:5
+   |
+LL |     println!("{}", val);
+   |     ^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{}", val);
+LL +     println!("{val}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:72:5
+   |
+LL |     println!("{}", v = val);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{}", v = val);
+LL +     println!("{val}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:74:5
+   |
+LL |     println!("val='{/t }'", local_i32);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("val='{/t }'", local_i32);
+LL +     println!("val='{local_i32}'");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:75:5
+   |
+LL |     println!("val='{/n }'", local_i32);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("val='{/n }'", local_i32);
+LL +     println!("val='{local_i32}'");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:76:5
+   |
+LL |     println!("val='{local_i32}'", local_i32 = local_i32);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("val='{local_i32}'", local_i32 = local_i32);
+LL +     println!("val='{local_i32}'");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:77:5
+   |
+LL |     println!("val='{local_i32}'", local_i32 = fn_arg);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("val='{local_i32}'", local_i32 = fn_arg);
+LL +     println!("val='{fn_arg}'");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:78:5
+   |
+LL |     println!("{0}", local_i32);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{0}", local_i32);
+LL +     println!("{local_i32}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:79:5
+   |
+LL |     println!("{0:?}", local_i32);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{0:?}", local_i32);
+LL +     println!("{local_i32:?}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:80:5
+   |
+LL |     println!("{0:#?}", local_i32);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{0:#?}", local_i32);
+LL +     println!("{local_i32:#?}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:81:5
+   |
+LL |     println!("{0:04}", local_i32);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{0:04}", local_i32);
+LL +     println!("{local_i32:04}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:82:5
+   |
+LL |     println!("{0:<3}", local_i32);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{0:<3}", local_i32);
+LL +     println!("{local_i32:<3}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:83:5
+   |
+LL |     println!("{0:#010x}", local_i32);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{0:#010x}", local_i32);
+LL +     println!("{local_i32:#010x}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:84:5
+   |
+LL |     println!("{0:.1}", local_f64);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{0:.1}", local_f64);
+LL +     println!("{local_f64:.1}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:85:5
+   |
+LL |     println!("{0} {0}", local_i32);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{0} {0}", local_i32);
+LL +     println!("{local_i32} {local_i32}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:86:5
+   |
+LL |     println!("{1} {} {0} {}", local_i32, local_f64);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{1} {} {0} {}", local_i32, local_f64);
+LL +     println!("{local_f64} {local_i32} {local_i32} {local_f64}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:87:5
+   |
+LL |     println!("{0} {1}", local_i32, local_f64);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{0} {1}", local_i32, local_f64);
+LL +     println!("{local_i32} {local_f64}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:88:5
+   |
+LL |     println!("{1} {0}", local_i32, local_f64);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{1} {0}", local_i32, local_f64);
+LL +     println!("{local_f64} {local_i32}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:89:5
+   |
+LL |     println!("{1} {0} {1} {0}", local_i32, local_f64);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{1} {0} {1} {0}", local_i32, local_f64);
+LL +     println!("{local_f64} {local_i32} {local_f64} {local_i32}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:91:5
+   |
+LL |     println!("{v}", v = local_i32);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{v}", v = local_i32);
+LL +     println!("{local_i32}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:92:5
+   |
+LL |     println!("{local_i32:0$}", width);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{local_i32:0$}", width);
+LL +     println!("{local_i32:width$}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:93:5
+   |
+LL |     println!("{local_i32:w$}", w = width);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{local_i32:w$}", w = width);
+LL +     println!("{local_i32:width$}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:94:5
+   |
+LL |     println!("{local_i32:.0$}", prec);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{local_i32:.0$}", prec);
+LL +     println!("{local_i32:.prec$}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:95:5
+   |
+LL |     println!("{local_i32:.p$}", p = prec);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{local_i32:.p$}", p = prec);
+LL +     println!("{local_i32:.prec$}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:96:5
+   |
+LL |     println!("{:0$}", v = val);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{:0$}", v = val);
+LL +     println!("{val:val$}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:97:5
+   |
+LL |     println!("{0:0$}", v = val);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{0:0$}", v = val);
+LL +     println!("{val:val$}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:98:5
+   |
+LL |     println!("{:0$.0$}", v = val);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{:0$.0$}", v = val);
+LL +     println!("{val:val$.val$}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:99:5
+   |
+LL |     println!("{0:0$.0$}", v = val);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{0:0$.0$}", v = val);
+LL +     println!("{val:val$.val$}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:100:5
+   |
+LL |     println!("{0:0$.v$}", v = val);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{0:0$.v$}", v = val);
+LL +     println!("{val:val$.val$}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:101:5
+   |
+LL |     println!("{0:v$.0$}", v = val);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{0:v$.0$}", v = val);
+LL +     println!("{val:val$.val$}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:102:5
+   |
+LL |     println!("{v:0$.0$}", v = val);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{v:0$.0$}", v = val);
+LL +     println!("{val:val$.val$}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:103:5
+   |
+LL |     println!("{v:v$.0$}", v = val);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{v:v$.0$}", v = val);
+LL +     println!("{val:val$.val$}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:104:5
+   |
+LL |     println!("{v:0$.v$}", v = val);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{v:0$.v$}", v = val);
+LL +     println!("{val:val$.val$}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:105:5
+   |
+LL |     println!("{v:v$.v$}", v = val);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{v:v$.v$}", v = val);
+LL +     println!("{val:val$.val$}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:106:5
+   |
+LL |     println!("{:0$}", width);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{:0$}", width);
+LL +     println!("{width:width$}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:107:5
+   |
+LL |     println!("{:1$}", local_i32, width);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{:1$}", local_i32, width);
+LL +     println!("{local_i32:width$}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:108:5
+   |
+LL |     println!("{:w$}", w = width);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{:w$}", w = width);
+LL +     println!("{width:width$}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:109:5
+   |
+LL |     println!("{:w$}", local_i32, w = width);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{:w$}", local_i32, w = width);
+LL +     println!("{local_i32:width$}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:110:5
+   |
+LL |     println!("{:.0$}", prec);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{:.0$}", prec);
+LL +     println!("{prec:.prec$}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:111:5
+   |
+LL |     println!("{:.1$}", local_i32, prec);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{:.1$}", local_i32, prec);
+LL +     println!("{local_i32:.prec$}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:112:5
+   |
+LL |     println!("{:.p$}", p = prec);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{:.p$}", p = prec);
+LL +     println!("{prec:.prec$}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:113:5
+   |
+LL |     println!("{:.p$}", local_i32, p = prec);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{:.p$}", local_i32, p = prec);
+LL +     println!("{local_i32:.prec$}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:114:5
+   |
+LL |     println!("{:0$.1$}", width, prec);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{:0$.1$}", width, prec);
+LL +     println!("{width:width$.prec$}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:115:5
+   |
+LL |     println!("{:0$.w$}", width, w = prec);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{:0$.w$}", width, w = prec);
+LL +     println!("{width:width$.prec$}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:116:5
+   |
+LL |     println!("{:1$.2$}", local_f64, width, prec);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{:1$.2$}", local_f64, width, prec);
+LL +     println!("{local_f64:width$.prec$}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:117:5
+   |
+LL |     println!("{:1$.2$} {0} {1} {2}", local_f64, width, prec);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{:1$.2$} {0} {1} {2}", local_f64, width, prec);
+LL +     println!("{local_f64:width$.prec$} {local_f64} {width} {prec}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:118:5
+   |
+LL | /     println!(
+LL | |         "{0:1$.2$} {0:2$.1$} {1:0$.2$} {1:2$.0$} {2:0$.1$} {2:1$.0$}",
+LL | |         local_i32, width, prec,
+LL | |     );
+   | |_____^
+   |
+help: change this to
+   |
+LL ~         "{local_i32:width$.prec$} {local_i32:prec$.width$} {width:local_i32$.prec$} {width:prec$.local_i32$} {prec:local_i32$.width$} {prec:width$.local_i32$}", width, prec,
+LL ~         "{0:1$.2$} {0:2$.1$} {1:0$.2$} {1:2$.0$} {2:0$.1$} {2:1$.0$}", width, prec,
+LL ~         "{0:1$.2$} {0:2$.1$} {1:0$.2$} {1:2$.0$} {2:0$.1$} {2:1$.0$}", width, prec,
+LL ~         "{0:1$.2$} {0:2$.1$} {1:0$.2$} {1:2$.0$} {2:0$.1$} {2:1$.0$}", width, prec,
+LL ~         "{0:1$.2$} {0:2$.1$} {1:0$.2$} {1:2$.0$} {2:0$.1$} {2:1$.0$}", width, prec,
+LL ~         "{0:1$.2$} {0:2$.1$} {1:0$.2$} {1:2$.0$} {2:0$.1$} {2:1$.0$}",
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:129:5
+   |
+LL |     println!("Width = {}, value with width = {:0$}", local_i32, local_f64);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("Width = {}, value with width = {:0$}", local_i32, local_f64);
+LL +     println!("Width = {local_i32}, value with width = {local_f64:local_i32$}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:130:5
+   |
+LL |     println!("{:w$.p$}", local_i32, w = width, p = prec);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{:w$.p$}", local_i32, w = width, p = prec);
+LL +     println!("{local_i32:width$.prec$}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:131:5
+   |
+LL |     println!("{:w$.p$}", w = width, p = prec);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{:w$.p$}", w = width, p = prec);
+LL +     println!("{width:width$.prec$}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:132:20
+   |
+LL |     println!("{}", format!("{}", local_i32));
+   |                    ^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{}", format!("{}", local_i32));
+LL +     println!("{}", format!("{local_i32}"));
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:170:5
+   |
+LL |     println!("expand='{}'", local_i32);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("expand='{}'", local_i32);
+LL +     println!("expand='{local_i32}'");
+   |
+
+error: aborting due to 71 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 14abb8395c4ae09475539dbc55ba89dd533981d9 Mon Sep 17 00:00:00 2001
From: Philip Craig <689193+philipcraig@users.noreply.github.com>
Date: Tue, 27 Sep 2022 09:32:55 +0100
Subject: fix typo "Saturing" -> "Saturating"

---
 clippy_lints/src/operators/mod.rs    | 2 +-
 src/docs/arithmetic_side_effects.txt | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/operators/mod.rs b/clippy_lints/src/operators/mod.rs
index c32b4df4f75..b8a20d5ebe9 100644
--- a/clippy_lints/src/operators/mod.rs
+++ b/clippy_lints/src/operators/mod.rs
@@ -67,7 +67,7 @@ declare_clippy_lint! {
     /// Reference](https://doc.rust-lang.org/reference/expressions/operator-expr.html#overflow),
     /// or can panic (`/`, `%`).
     ///
-    /// Known safe built-in types like `Wrapping` or `Saturing`, floats, operations in constant
+    /// Known safe built-in types like `Wrapping` or `Saturating`, floats, operations in constant
     /// environments, allowed types and non-constant operations that won't overflow are ignored.
     ///
     /// ### Why is this bad?
diff --git a/src/docs/arithmetic_side_effects.txt b/src/docs/arithmetic_side_effects.txt
index 6c7d51a4989..4ae8bce88ad 100644
--- a/src/docs/arithmetic_side_effects.txt
+++ b/src/docs/arithmetic_side_effects.txt
@@ -5,7 +5,7 @@ Operators like `+`, `-`, `*` or `<<` are usually capable of overflowing accordin
 Reference](https://doc.rust-lang.org/reference/expressions/operator-expr.html#overflow),
 or can panic (`/`, `%`).
 
-Known safe built-in types like `Wrapping` or `Saturing`, floats, operations in constant
+Known safe built-in types like `Wrapping` or `Saturating`, floats, operations in constant
 environments, allowed types and non-constant operations that won't overflow are ignored.
 
 ### Why is this bad?
-- 
cgit 1.4.1-3-g733a5


From 63f441ec855f0de342ccc2b9ff90776c633ca9e6 Mon Sep 17 00:00:00 2001
From: Andre Bogus <bogusandre@gmail.com>
Date: Wed, 21 Sep 2022 23:43:49 +0200
Subject: add `box-default` lint

---
 CHANGELOG.md                           |  1 +
 clippy_lints/src/box_default.rs        | 61 ++++++++++++++++++++++++++++++++++
 clippy_lints/src/lib.register_all.rs   |  1 +
 clippy_lints/src/lib.register_lints.rs |  1 +
 clippy_lints/src/lib.register_perf.rs  |  1 +
 clippy_lints/src/lib.rs                | 30 +++++++++--------
 src/docs.rs                            |  1 +
 src/docs/box_default.txt               | 23 +++++++++++++
 tests/ui/box_collection.rs             |  4 +--
 tests/ui/box_default.rs                | 31 +++++++++++++++++
 tests/ui/box_default.stderr            | 59 ++++++++++++++++++++++++++++++++
 11 files changed, 197 insertions(+), 16 deletions(-)
 create mode 100644 clippy_lints/src/box_default.rs
 create mode 100644 src/docs/box_default.txt
 create mode 100644 tests/ui/box_default.rs
 create mode 100644 tests/ui/box_default.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 044cbff4b78..f1e2e6f462d 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3609,6 +3609,7 @@ Released 2018-09-13
 [`borrow_interior_mutable_const`]: https://rust-lang.github.io/rust-clippy/master/index.html#borrow_interior_mutable_const
 [`borrowed_box`]: https://rust-lang.github.io/rust-clippy/master/index.html#borrowed_box
 [`box_collection`]: https://rust-lang.github.io/rust-clippy/master/index.html#box_collection
+[`box_default`]: https://rust-lang.github.io/rust-clippy/master/index.html#box_default
 [`box_vec`]: https://rust-lang.github.io/rust-clippy/master/index.html#box_vec
 [`boxed_local`]: https://rust-lang.github.io/rust-clippy/master/index.html#boxed_local
 [`branches_sharing_code`]: https://rust-lang.github.io/rust-clippy/master/index.html#branches_sharing_code
diff --git a/clippy_lints/src/box_default.rs b/clippy_lints/src/box_default.rs
new file mode 100644
index 00000000000..792183ac408
--- /dev/null
+++ b/clippy_lints/src/box_default.rs
@@ -0,0 +1,61 @@
+use clippy_utils::{diagnostics::span_lint_and_help, is_default_equivalent, path_def_id};
+use rustc_hir::{Expr, ExprKind, QPath};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_middle::lint::in_external_macro;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::sym;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// checks for `Box::new(T::default())`, which is better written as
+    /// `Box::<T>::default()`.
+    ///
+    /// ### Why is this bad?
+    /// First, it's more complex, involving two calls instead of one.
+    /// Second, `Box::default()` can be faster
+    /// [in certain cases](https://nnethercote.github.io/perf-book/standard-library-types.html#box).
+    ///
+    /// ### Known problems
+    /// The lint may miss some cases (e.g. Box::new(String::from(""))).
+    /// On the other hand, it will trigger on cases where the `default`
+    /// code comes from a macro that does something different based on
+    /// e.g. target operating system.
+    ///
+    /// ### Example
+    /// ```rust
+    /// let x: Box<String> = Box::new(Default::default());
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// let x: Box<String> = Box::default();
+    /// ```
+    #[clippy::version = "1.65.0"]
+    pub BOX_DEFAULT,
+    perf,
+    "Using Box::new(T::default()) instead of Box::default()"
+}
+
+declare_lint_pass!(BoxDefault => [BOX_DEFAULT]);
+
+impl LateLintPass<'_> for BoxDefault {
+    fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
+        if let ExprKind::Call(box_new, [arg]) = expr.kind
+            && let ExprKind::Path(QPath::TypeRelative(ty, seg)) = box_new.kind
+            && let ExprKind::Call(..) = arg.kind
+            && !in_external_macro(cx.sess(), expr.span)
+            && expr.span.eq_ctxt(arg.span)
+            && seg.ident.name == sym::new
+            && path_def_id(cx, ty) == cx.tcx.lang_items().owned_box()
+            && is_default_equivalent(cx, arg)
+        {
+            span_lint_and_help(
+                cx,
+                BOX_DEFAULT,
+                expr.span,
+                "`Box::new(_)` of default value",
+                None,
+                "use `Box::default()` instead",
+            );
+        }
+    }
+}
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index ae57a9a24a7..33490d1ccc5 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -21,6 +21,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(booleans::NONMINIMAL_BOOL),
     LintId::of(booleans::OVERLY_COMPLEX_BOOL_EXPR),
     LintId::of(borrow_deref_ref::BORROW_DEREF_REF),
+    LintId::of(box_default::BOX_DEFAULT),
     LintId::of(casts::CAST_ABS_TO_UNSIGNED),
     LintId::of(casts::CAST_ENUM_CONSTRUCTOR),
     LintId::of(casts::CAST_ENUM_TRUNCATION),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 02fcc8de507..93ea32fa069 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -60,6 +60,7 @@ store.register_lints(&[
     booleans::NONMINIMAL_BOOL,
     booleans::OVERLY_COMPLEX_BOOL_EXPR,
     borrow_deref_ref::BORROW_DEREF_REF,
+    box_default::BOX_DEFAULT,
     cargo::CARGO_COMMON_METADATA,
     cargo::MULTIPLE_CRATE_VERSIONS,
     cargo::NEGATIVE_FEATURE_NAMES,
diff --git a/clippy_lints/src/lib.register_perf.rs b/clippy_lints/src/lib.register_perf.rs
index 195ce41e31e..8e927470e02 100644
--- a/clippy_lints/src/lib.register_perf.rs
+++ b/clippy_lints/src/lib.register_perf.rs
@@ -3,6 +3,7 @@
 // Manual edits will be overwritten.
 
 store.register_group(true, "clippy::perf", Some("clippy_perf"), vec![
+    LintId::of(box_default::BOX_DEFAULT),
     LintId::of(entry::MAP_ENTRY),
     LintId::of(escape::BOXED_LOCAL),
     LintId::of(format_args::FORMAT_IN_FORMAT_ARGS),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 83fdc15c9f0..7bd49b11090 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -181,6 +181,7 @@ mod bool_assert_comparison;
 mod bool_to_int_with_if;
 mod booleans;
 mod borrow_deref_ref;
+mod box_default;
 mod cargo;
 mod casts;
 mod checked_conversions;
@@ -536,8 +537,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         store.register_late_pass(|| Box::new(utils::internal_lints::CompilerLintFunctions::new()));
         store.register_late_pass(|| Box::new(utils::internal_lints::IfChainStyle));
         store.register_late_pass(|| Box::new(utils::internal_lints::InvalidPaths));
-        store.register_late_pass(|| Box::new(utils::internal_lints::InterningDefinedSymbol::default()));
-        store.register_late_pass(|| Box::new(utils::internal_lints::LintWithoutLintPass::default()));
+        store.register_late_pass(|| Box::<utils::internal_lints::InterningDefinedSymbol>::default());
+        store.register_late_pass(|| Box::<utils::internal_lints::LintWithoutLintPass>::default());
         store.register_late_pass(|| Box::new(utils::internal_lints::MatchTypeOnDiagItem));
         store.register_late_pass(|| Box::new(utils::internal_lints::OuterExpnDataPass));
         store.register_late_pass(|| Box::new(utils::internal_lints::MsrvAttrImpl));
@@ -630,10 +631,10 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
             msrv,
         ))
     });
-    store.register_late_pass(|| Box::new(shadow::Shadow::default()));
+    store.register_late_pass(|| Box::<shadow::Shadow>::default());
     store.register_late_pass(|| Box::new(unit_types::UnitTypes));
     store.register_late_pass(|| Box::new(loops::Loops));
-    store.register_late_pass(|| Box::new(main_recursion::MainRecursion::default()));
+    store.register_late_pass(|| Box::<main_recursion::MainRecursion>::default());
     store.register_late_pass(|| Box::new(lifetimes::Lifetimes));
     store.register_late_pass(|| Box::new(entry::HashMapPass));
     store.register_late_pass(|| Box::new(minmax::MinMaxPass));
@@ -667,7 +668,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(format::UselessFormat));
     store.register_late_pass(|| Box::new(swap::Swap));
     store.register_late_pass(|| Box::new(overflow_check_conditional::OverflowCheckConditional));
-    store.register_late_pass(|| Box::new(new_without_default::NewWithoutDefault::default()));
+    store.register_late_pass(|| Box::<new_without_default::NewWithoutDefault>::default());
     let disallowed_names = conf.disallowed_names.iter().cloned().collect::<FxHashSet<_>>();
     store.register_late_pass(move || Box::new(disallowed_names::DisallowedNames::new(disallowed_names.clone())));
     let too_many_arguments_threshold = conf.too_many_arguments_threshold;
@@ -706,7 +707,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(ref_option_ref::RefOptionRef));
     store.register_late_pass(|| Box::new(infinite_iter::InfiniteIter));
     store.register_late_pass(|| Box::new(inline_fn_without_body::InlineFnWithoutBody));
-    store.register_late_pass(|| Box::new(useless_conversion::UselessConversion::default()));
+    store.register_late_pass(|| Box::<useless_conversion::UselessConversion>::default());
     store.register_late_pass(|| Box::new(implicit_hasher::ImplicitHasher));
     store.register_late_pass(|| Box::new(fallible_impl_from::FallibleImplFrom));
     store.register_late_pass(|| Box::new(question_mark::QuestionMark));
@@ -776,7 +777,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
             upper_case_acronyms_aggressive,
         ))
     });
-    store.register_late_pass(|| Box::new(default::Default::default()));
+    store.register_late_pass(|| Box::<default::Default>::default());
     store.register_late_pass(move || Box::new(unused_self::UnusedSelf::new(avoid_breaking_exported_api)));
     store.register_late_pass(|| Box::new(mutable_debug_assertion::DebugAssertWithMutCall));
     store.register_late_pass(|| Box::new(exit::Exit));
@@ -799,7 +800,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_early_pass(|| Box::new(option_env_unwrap::OptionEnvUnwrap));
     let warn_on_all_wildcard_imports = conf.warn_on_all_wildcard_imports;
     store.register_late_pass(move || Box::new(wildcard_imports::WildcardImports::new(warn_on_all_wildcard_imports)));
-    store.register_late_pass(|| Box::new(redundant_pub_crate::RedundantPubCrate::default()));
+    store.register_late_pass(|| Box::<redundant_pub_crate::RedundantPubCrate>::default());
     store.register_late_pass(|| Box::new(unnamed_address::UnnamedAddress));
     store.register_late_pass(move || Box::new(dereference::Dereferencing::new(msrv)));
     store.register_late_pass(|| Box::new(option_if_let_else::OptionIfLetElse));
@@ -817,7 +818,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     });
     let macro_matcher = conf.standard_macro_braces.iter().cloned().collect::<FxHashSet<_>>();
     store.register_early_pass(move || Box::new(nonstandard_macro_braces::MacroBraces::new(&macro_matcher)));
-    store.register_late_pass(|| Box::new(macro_use::MacroUseImports::default()));
+    store.register_late_pass(|| Box::<macro_use::MacroUseImports>::default());
     store.register_late_pass(|| Box::new(pattern_type_mismatch::PatternTypeMismatch));
     store.register_late_pass(|| Box::new(unwrap_in_result::UnwrapInResult));
     store.register_late_pass(|| Box::new(semicolon_if_nothing_returned::SemicolonIfNothingReturned));
@@ -830,7 +831,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| Box::new(strings::StrToString));
     store.register_late_pass(|| Box::new(strings::StringToString));
     store.register_late_pass(|| Box::new(zero_sized_map_values::ZeroSizedMapValues));
-    store.register_late_pass(|| Box::new(vec_init_then_push::VecInitThenPush::default()));
+    store.register_late_pass(|| Box::<vec_init_then_push::VecInitThenPush>::default());
     store.register_late_pass(|| Box::new(redundant_slicing::RedundantSlicing));
     store.register_late_pass(|| Box::new(from_str_radix_10::FromStrRadix10));
     store.register_late_pass(move || Box::new(if_then_some_else_none::IfThenSomeElseNone::new(msrv)));
@@ -868,7 +869,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(move || Box::new(manual_bits::ManualBits::new(msrv)));
     store.register_late_pass(|| Box::new(default_union_representation::DefaultUnionRepresentation));
     store.register_early_pass(|| Box::new(doc_link_with_quotes::DocLinkWithQuotes));
-    store.register_late_pass(|| Box::new(only_used_in_recursion::OnlyUsedInRecursion::default()));
+    store.register_late_pass(|| Box::<only_used_in_recursion::OnlyUsedInRecursion>::default());
     let allow_dbg_in_tests = conf.allow_dbg_in_tests;
     store.register_late_pass(move || Box::new(dbg_macro::DbgMacro::new(allow_dbg_in_tests)));
     let cargo_ignore_publish = conf.cargo_ignore_publish;
@@ -877,7 +878,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
             ignore_publish: cargo_ignore_publish,
         })
     });
-    store.register_late_pass(|| Box::new(write::Write::default()));
+    store.register_late_pass(|| Box::<write::Write>::default());
     store.register_early_pass(|| Box::new(crate_in_macro_def::CrateInMacroDef));
     store.register_early_pass(|| Box::new(empty_structs_with_brackets::EmptyStructsWithBrackets));
     store.register_late_pass(|| Box::new(unnecessary_owned_empty_strings::UnnecessaryOwnedEmptyStrings));
@@ -887,7 +888,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(move || Box::new(large_include_file::LargeIncludeFile::new(max_include_file_size)));
     store.register_late_pass(|| Box::new(strings::TrimSplitWhitespace));
     store.register_late_pass(|| Box::new(rc_clone_in_vec_init::RcCloneInVecInit));
-    store.register_early_pass(|| Box::new(duplicate_mod::DuplicateMod::default()));
+    store.register_early_pass(|| Box::<duplicate_mod::DuplicateMod>::default());
     store.register_early_pass(|| Box::new(unused_rounding::UnusedRounding));
     store.register_early_pass(move || Box::new(almost_complete_letter_range::AlmostCompleteLetterRange::new(msrv)));
     store.register_late_pass(|| Box::new(swap_ptr_to_ref::SwapPtrToRef));
@@ -899,13 +900,14 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     let verbose_bit_mask_threshold = conf.verbose_bit_mask_threshold;
     store.register_late_pass(move || Box::new(operators::Operators::new(verbose_bit_mask_threshold)));
     store.register_late_pass(|| Box::new(invalid_utf8_in_unchecked::InvalidUtf8InUnchecked));
-    store.register_late_pass(|| Box::new(std_instead_of_core::StdReexports::default()));
+    store.register_late_pass(|| Box::<std_instead_of_core::StdReexports>::default());
     store.register_late_pass(|| Box::new(manual_instant_elapsed::ManualInstantElapsed));
     store.register_late_pass(|| Box::new(partialeq_to_none::PartialeqToNone));
     store.register_late_pass(|| Box::new(manual_string_new::ManualStringNew));
     store.register_late_pass(|| Box::new(unused_peekable::UnusedPeekable));
     store.register_early_pass(|| Box::new(multi_assignments::MultiAssignments));
     store.register_late_pass(|| Box::new(bool_to_int_with_if::BoolToIntWithIf));
+    store.register_late_pass(|| Box::new(box_default::BoxDefault));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/src/docs.rs b/src/docs.rs
index 6c89b4dde37..8ffe1281f65 100644
--- a/src/docs.rs
+++ b/src/docs.rs
@@ -48,6 +48,7 @@ docs! {
     "borrow_interior_mutable_const",
     "borrowed_box",
     "box_collection",
+    "box_default",
     "boxed_local",
     "branches_sharing_code",
     "builtin_type_shadow",
diff --git a/src/docs/box_default.txt b/src/docs/box_default.txt
new file mode 100644
index 00000000000..ffac894d0c5
--- /dev/null
+++ b/src/docs/box_default.txt
@@ -0,0 +1,23 @@
+### What it does
+checks for `Box::new(T::default())`, which is better written as
+`Box::<T>::default()`.
+
+### Why is this bad?
+First, it's more complex, involving two calls instead of one.
+Second, `Box::default()` can be faster
+[in certain cases](https://nnethercote.github.io/perf-book/standard-library-types.html#box).
+
+### Known problems
+The lint may miss some cases (e.g. Box::new(String::from(""))).
+On the other hand, it will trigger on cases where the `default`
+code comes from a macro that does something different based on
+e.g. target operating system.
+
+### Example
+```
+let x: Box<String> = Box::new(Default::default());
+```
+Use instead:
+```
+let x: Box<String> = Box::default();
+```
\ No newline at end of file
diff --git a/tests/ui/box_collection.rs b/tests/ui/box_collection.rs
index 0780c8f0586..4c9947b9ae7 100644
--- a/tests/ui/box_collection.rs
+++ b/tests/ui/box_collection.rs
@@ -15,7 +15,7 @@ macro_rules! boxit {
 }
 
 fn test_macro() {
-    boxit!(Vec::new(), Vec<u8>);
+    boxit!(vec![1], Vec<u8>);
 }
 
 fn test1(foo: Box<Vec<bool>>) {}
@@ -50,7 +50,7 @@ fn test_local_not_linted() {
 pub fn pub_test(foo: Box<Vec<bool>>) {}
 
 pub fn pub_test_ret() -> Box<Vec<bool>> {
-    Box::new(Vec::new())
+    Box::default()
 }
 
 fn main() {}
diff --git a/tests/ui/box_default.rs b/tests/ui/box_default.rs
new file mode 100644
index 00000000000..dc522705bc6
--- /dev/null
+++ b/tests/ui/box_default.rs
@@ -0,0 +1,31 @@
+#![warn(clippy::box_default)]
+
+#[derive(Default)]
+struct ImplementsDefault;
+
+struct OwnDefault;
+
+impl OwnDefault {
+    fn default() -> Self {
+        Self
+    }
+}
+
+macro_rules! outer {
+    ($e: expr) => {
+        $e
+    };
+}
+
+fn main() {
+    let _string: Box<String> = Box::new(Default::default());
+    let _byte = Box::new(u8::default());
+    let _vec = Box::new(Vec::<u8>::new());
+    let _impl = Box::new(ImplementsDefault::default());
+    let _impl2 = Box::new(<ImplementsDefault as Default>::default());
+    let _impl3: Box<ImplementsDefault> = Box::new(Default::default());
+    let _own = Box::new(OwnDefault::default()); // should not lint
+    let _in_macro = outer!(Box::new(String::new()));
+    // false negative: default is from different expansion
+    let _vec2: Box<Vec<ImplementsDefault>> = Box::new(vec![]);
+}
diff --git a/tests/ui/box_default.stderr b/tests/ui/box_default.stderr
new file mode 100644
index 00000000000..341766a502b
--- /dev/null
+++ b/tests/ui/box_default.stderr
@@ -0,0 +1,59 @@
+error: `Box::new(_)` of default value
+  --> $DIR/box_default.rs:21:32
+   |
+LL |     let _string: Box<String> = Box::new(Default::default());
+   |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::box-default` implied by `-D warnings`
+   = help: use `Box::default()` instead
+
+error: `Box::new(_)` of default value
+  --> $DIR/box_default.rs:22:17
+   |
+LL |     let _byte = Box::new(u8::default());
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use `Box::default()` instead
+
+error: `Box::new(_)` of default value
+  --> $DIR/box_default.rs:23:16
+   |
+LL |     let _vec = Box::new(Vec::<u8>::new());
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use `Box::default()` instead
+
+error: `Box::new(_)` of default value
+  --> $DIR/box_default.rs:24:17
+   |
+LL |     let _impl = Box::new(ImplementsDefault::default());
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use `Box::default()` instead
+
+error: `Box::new(_)` of default value
+  --> $DIR/box_default.rs:25:18
+   |
+LL |     let _impl2 = Box::new(<ImplementsDefault as Default>::default());
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use `Box::default()` instead
+
+error: `Box::new(_)` of default value
+  --> $DIR/box_default.rs:26:42
+   |
+LL |     let _impl3: Box<ImplementsDefault> = Box::new(Default::default());
+   |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use `Box::default()` instead
+
+error: `Box::new(_)` of default value
+  --> $DIR/box_default.rs:28:28
+   |
+LL |     let _in_macro = outer!(Box::new(String::new()));
+   |                            ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use `Box::default()` instead
+
+error: aborting due to 7 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 5b0f46a9d90ed2c7d26b2760dddee7399b379612 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Tue, 27 Sep 2022 18:21:14 +0000
Subject: Don't lint unstable moves in `std_instead_of_core`

Such as the currently unstable `core::error`
---
 clippy_lints/src/std_instead_of_core.rs | 22 ++++++++++++++++++++++
 tests/ui/std_instead_of_core.rs         |  6 ++++++
 tests/ui/std_instead_of_core.stderr     | 16 ++++++++++++----
 3 files changed, 40 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/std_instead_of_core.rs b/clippy_lints/src/std_instead_of_core.rs
index ffd63cc687a..d6b336bef94 100644
--- a/clippy_lints/src/std_instead_of_core.rs
+++ b/clippy_lints/src/std_instead_of_core.rs
@@ -1,6 +1,8 @@
 use clippy_utils::diagnostics::span_lint_and_help;
+use rustc_hir::def_id::DefId;
 use rustc_hir::{def::Res, HirId, Path, PathSegment};
 use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::DefIdTree;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::{sym, symbol::kw, Span};
 
@@ -94,6 +96,7 @@ impl<'tcx> LateLintPass<'tcx> for StdReexports {
     fn check_path(&mut self, cx: &LateContext<'tcx>, path: &Path<'tcx>, _: HirId) {
         if let Res::Def(_, def_id) = path.res
             && let Some(first_segment) = get_first_segment(path)
+            && is_stable(cx, def_id)
         {
             let (lint, msg, help) = match first_segment.ident.name {
                 sym::std => match cx.tcx.crate_name(def_id.krate) {
@@ -146,3 +149,22 @@ fn get_first_segment<'tcx>(path: &Path<'tcx>) -> Option<&'tcx PathSegment<'tcx>>
         _ => None,
     }
 }
+
+/// Checks if all ancestors of `def_id` are stable, to avoid linting
+/// [unstable moves](https://github.com/rust-lang/rust/pull/95956)
+fn is_stable(cx: &LateContext<'_>, mut def_id: DefId) -> bool {
+    loop {
+        if cx
+            .tcx
+            .lookup_stability(def_id)
+            .map_or(false, |stability| stability.is_unstable())
+        {
+            return false;
+        }
+
+        match cx.tcx.opt_parent(def_id) {
+            Some(parent) => def_id = parent,
+            None => return true,
+        }
+    }
+}
diff --git a/tests/ui/std_instead_of_core.rs b/tests/ui/std_instead_of_core.rs
index 6b27475de4c..75b114ba0ae 100644
--- a/tests/ui/std_instead_of_core.rs
+++ b/tests/ui/std_instead_of_core.rs
@@ -24,6 +24,12 @@ fn std_instead_of_core() {
     let cell_absolute = ::std::cell::Cell::new(8u32);
 
     let _ = std::env!("PATH");
+
+    // do not lint until `error_in_core` is stable
+    use std::error::Error;
+
+    // lint items re-exported from private modules, `core::iter::traits::iterator::Iterator`
+    use std::iter::Iterator;
 }
 
 #[warn(clippy::std_instead_of_alloc)]
diff --git a/tests/ui/std_instead_of_core.stderr b/tests/ui/std_instead_of_core.stderr
index bc49dabf586..e9ead4db5f9 100644
--- a/tests/ui/std_instead_of_core.stderr
+++ b/tests/ui/std_instead_of_core.stderr
@@ -63,9 +63,17 @@ LL |     let cell_absolute = ::std::cell::Cell::new(8u32);
    |
    = help: consider importing the item from `core`
 
-error: used import from `std` instead of `alloc`
+error: used import from `std` instead of `core`
   --> $DIR/std_instead_of_core.rs:32:9
    |
+LL |     use std::iter::Iterator;
+   |         ^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider importing the item from `core`
+
+error: used import from `std` instead of `alloc`
+  --> $DIR/std_instead_of_core.rs:38:9
+   |
 LL |     use std::vec;
    |         ^^^^^^^^
    |
@@ -73,7 +81,7 @@ LL |     use std::vec;
    = help: consider importing the item from `alloc`
 
 error: used import from `std` instead of `alloc`
-  --> $DIR/std_instead_of_core.rs:33:9
+  --> $DIR/std_instead_of_core.rs:39:9
    |
 LL |     use std::vec::Vec;
    |         ^^^^^^^^^^^^^
@@ -81,7 +89,7 @@ LL |     use std::vec::Vec;
    = help: consider importing the item from `alloc`
 
 error: used import from `alloc` instead of `core`
-  --> $DIR/std_instead_of_core.rs:38:9
+  --> $DIR/std_instead_of_core.rs:44:9
    |
 LL |     use alloc::slice::from_ref;
    |         ^^^^^^^^^^^^^^^^^^^^^^
@@ -89,5 +97,5 @@ LL |     use alloc::slice::from_ref;
    = note: `-D clippy::alloc-instead-of-core` implied by `-D warnings`
    = help: consider importing the item from `core`
 
-error: aborting due to 11 previous errors
+error: aborting due to 12 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 187c27e6b0c756db340e4acdb18b9aae7fd1a1df Mon Sep 17 00:00:00 2001
From: kraktus <kraktus@users.noreply.github.com>
Date: Tue, 27 Sep 2022 21:01:23 +0200
Subject: rename `and_only_expr_in_arm` -> `is_single_call_in_arm`

---
 clippy_lints/src/drop_forget_ref.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/drop_forget_ref.rs b/clippy_lints/src/drop_forget_ref.rs
index de94b87cc40..81d04935d89 100644
--- a/clippy_lints/src/drop_forget_ref.rs
+++ b/clippy_lints/src/drop_forget_ref.rs
@@ -204,11 +204,11 @@ impl<'tcx> LateLintPass<'tcx> for DropForgetRef {
         {
             let arg_ty = cx.typeck_results().expr_ty(arg);
             let is_copy = is_copy(cx, arg_ty);
-            let drop_is_only_expr_in_arm = and_only_expr_in_arm(cx, arg, expr);
+            let drop_is_single_call_in_arm = is_single_call_in_arm(cx, arg, expr);
             let (lint, msg) = match fn_name {
                 sym::mem_drop if arg_ty.is_ref() => (DROP_REF, DROP_REF_SUMMARY),
                 sym::mem_forget if arg_ty.is_ref() => (FORGET_REF, FORGET_REF_SUMMARY),
-                sym::mem_drop if is_copy && !drop_is_only_expr_in_arm => (DROP_COPY, DROP_COPY_SUMMARY),
+                sym::mem_drop if is_copy && !drop_is_single_call_in_arm => (DROP_COPY, DROP_COPY_SUMMARY),
                 sym::mem_forget if is_copy => (FORGET_COPY, FORGET_COPY_SUMMARY),
                 sym::mem_drop if is_type_lang_item(cx, arg_ty, LangItem::ManuallyDrop) => {
                     span_lint_and_help(
@@ -225,7 +225,7 @@ impl<'tcx> LateLintPass<'tcx> for DropForgetRef {
                     if !(arg_ty.needs_drop(cx.tcx, cx.param_env)
                         || is_must_use_func_call(cx, arg)
                         || is_must_use_ty(cx, arg_ty)
-                        || drop_is_only_expr_in_arm
+                        || drop_is_single_call_in_arm
                         ) =>
                 {
                     (DROP_NON_DROP, DROP_NON_DROP_SUMMARY)
@@ -252,7 +252,7 @@ impl<'tcx> LateLintPass<'tcx> for DropForgetRef {
 //     <pat> => drop(fn_with_side_effect_and_returning_some_value()),
 //     ..
 // }
-fn and_only_expr_in_arm<'tcx>(cx: &LateContext<'tcx>, arg: &'tcx Expr<'_>, drop_expr: &'tcx Expr<'_>) -> bool {
+fn is_single_call_in_arm<'tcx>(cx: &LateContext<'tcx>, arg: &'tcx Expr<'_>, drop_expr: &'tcx Expr<'_>) -> bool {
     if matches!(arg.kind, ExprKind::Call(..) | ExprKind::MethodCall(..)) {
         let parent_node = get_parent_node(cx.tcx, drop_expr.hir_id);
         if let Some(Node::Arm(Arm { body, .. })) = &parent_node {
-- 
cgit 1.4.1-3-g733a5


From 14ba4fba11e0e38d35c63559553380d8fde4517a Mon Sep 17 00:00:00 2001
From: kraktus <kraktus@users.noreply.github.com>
Date: Sat, 17 Sep 2022 13:59:02 +0200
Subject: fix [`needless_borrow`] and [`explicit_auto_deref`] false positive on
 unions

---
 clippy_lints/src/dereference.rs | 37 +++++++++++++++++++++++++++++--------
 tests/ui/needless_borrow.fixed  | 29 +++++++++++++++++++++++++++++
 tests/ui/needless_borrow.rs     | 29 +++++++++++++++++++++++++++++
 3 files changed, 87 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index d1b25a0f1b5..99212b45ed5 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -184,6 +184,7 @@ impl Dereferencing {
     }
 }
 
+#[derive(Debug)]
 struct StateData {
     /// Span of the top level expression
     span: Span,
@@ -191,12 +192,14 @@ struct StateData {
     position: Position,
 }
 
+#[derive(Debug)]
 struct DerefedBorrow {
     count: usize,
     msg: &'static str,
     snip_expr: Option<HirId>,
 }
 
+#[derive(Debug)]
 enum State {
     // Any number of deref method calls.
     DerefMethod {
@@ -276,10 +279,12 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing {
             (None, kind) => {
                 let expr_ty = typeck.expr_ty(expr);
                 let (position, adjustments) = walk_parents(cx, expr, self.msrv);
-
                 match kind {
                     RefOp::Deref => {
-                        if let Position::FieldAccess(name) = position
+                        if let Position::FieldAccess {
+                            name,
+                            of_union: false,
+                        } = position
                             && !ty_contains_field(typeck.expr_ty(sub_expr), name)
                         {
                             self.state = Some((
@@ -451,7 +456,7 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing {
             (Some((State::DerefedBorrow(state), data)), RefOp::Deref) => {
                 let position = data.position;
                 report(cx, expr, State::DerefedBorrow(state), data);
-                if let Position::FieldAccess(name) = position
+                if let Position::FieldAccess{name, ..} = position
                     && !ty_contains_field(typeck.expr_ty(sub_expr), name)
                 {
                     self.state = Some((
@@ -616,14 +621,17 @@ fn deref_method_same_type<'tcx>(result_ty: Ty<'tcx>, arg_ty: Ty<'tcx>) -> bool {
 }
 
 /// The position of an expression relative to it's parent.
-#[derive(Clone, Copy)]
+#[derive(Clone, Copy, Debug)]
 enum Position {
     MethodReceiver,
     /// The method is defined on a reference type. e.g. `impl Foo for &T`
     MethodReceiverRefImpl,
     Callee,
     ImplArg(HirId),
-    FieldAccess(Symbol),
+    FieldAccess {
+        name: Symbol,
+        of_union: bool,
+    }, // union fields cannot be auto borrowed
     Postfix,
     Deref,
     /// Any other location which will trigger auto-deref to a specific time.
@@ -645,7 +653,10 @@ impl Position {
     }
 
     fn can_auto_borrow(self) -> bool {
-        matches!(self, Self::MethodReceiver | Self::FieldAccess(_) | Self::Callee)
+        matches!(
+            self,
+            Self::MethodReceiver | Self::FieldAccess { of_union: false, .. } | Self::Callee
+        )
     }
 
     fn lint_explicit_deref(self) -> bool {
@@ -657,7 +668,7 @@ impl Position {
             Self::MethodReceiver
             | Self::MethodReceiverRefImpl
             | Self::Callee
-            | Self::FieldAccess(_)
+            | Self::FieldAccess { .. }
             | Self::Postfix => PREC_POSTFIX,
             Self::ImplArg(_) | Self::Deref => PREC_PREFIX,
             Self::DerefStable(p, _) | Self::ReborrowStable(p) | Self::Other(p) => p,
@@ -844,7 +855,10 @@ fn walk_parents<'tcx>(
                         }
                     })
                 },
-                ExprKind::Field(child, name) if child.hir_id == e.hir_id => Some(Position::FieldAccess(name.name)),
+                ExprKind::Field(child, name) if child.hir_id == e.hir_id => Some(Position::FieldAccess {
+                    name: name.name,
+                    of_union: is_union(cx.typeck_results(), child),
+                }),
                 ExprKind::Unary(UnOp::Deref, child) if child.hir_id == e.hir_id => Some(Position::Deref),
                 ExprKind::Match(child, _, MatchSource::TryDesugar | MatchSource::AwaitDesugar)
                 | ExprKind::Index(child, _)
@@ -865,6 +879,13 @@ fn walk_parents<'tcx>(
     (position, adjustments)
 }
 
+fn is_union<'tcx>(typeck: &'tcx TypeckResults<'_>, path_expr: &'tcx Expr<'_>) -> bool {
+    typeck
+        .expr_ty_adjusted(path_expr)
+        .ty_adt_def()
+        .map_or(false, rustc_middle::ty::AdtDef::is_union)
+}
+
 fn closure_result_position<'tcx>(
     cx: &LateContext<'tcx>,
     closure: &'tcx Closure<'_>,
diff --git a/tests/ui/needless_borrow.fixed b/tests/ui/needless_borrow.fixed
index 8cf93bd2481..6914f9183c7 100644
--- a/tests/ui/needless_borrow.fixed
+++ b/tests/ui/needless_borrow.fixed
@@ -298,3 +298,32 @@ mod meets_msrv {
         let _ = std::process::Command::new("ls").args(["-a", "-l"]).status().unwrap();
     }
 }
+
+#[allow(unused)]
+fn issue9383() {
+    // Should not lint because unions need explicit deref when accessing field
+    use std::mem::ManuallyDrop;
+
+    union Coral {
+        crab: ManuallyDrop<Vec<i32>>,
+    }
+
+    union Ocean {
+        coral: ManuallyDrop<Coral>,
+    }
+
+    let mut ocean = Ocean {
+        coral: ManuallyDrop::new(Coral {
+            crab: ManuallyDrop::new(vec![1, 2, 3]),
+        }),
+    };
+
+    unsafe {
+        ManuallyDrop::drop(&mut (&mut ocean.coral).crab);
+
+        (*ocean.coral).crab = ManuallyDrop::new(vec![4, 5, 6]);
+        ManuallyDrop::drop(&mut (*ocean.coral).crab);
+
+        ManuallyDrop::drop(&mut ocean.coral);
+    }
+}
diff --git a/tests/ui/needless_borrow.rs b/tests/ui/needless_borrow.rs
index fd9b2a11df9..e2a609fa5d2 100644
--- a/tests/ui/needless_borrow.rs
+++ b/tests/ui/needless_borrow.rs
@@ -298,3 +298,32 @@ mod meets_msrv {
         let _ = std::process::Command::new("ls").args(&["-a", "-l"]).status().unwrap();
     }
 }
+
+#[allow(unused)]
+fn issue9383() {
+    // Should not lint because unions need explicit deref when accessing field
+    use std::mem::ManuallyDrop;
+
+    union Coral {
+        crab: ManuallyDrop<Vec<i32>>,
+    }
+
+    union Ocean {
+        coral: ManuallyDrop<Coral>,
+    }
+
+    let mut ocean = Ocean {
+        coral: ManuallyDrop::new(Coral {
+            crab: ManuallyDrop::new(vec![1, 2, 3]),
+        }),
+    };
+
+    unsafe {
+        ManuallyDrop::drop(&mut (&mut ocean.coral).crab);
+
+        (*ocean.coral).crab = ManuallyDrop::new(vec![4, 5, 6]);
+        ManuallyDrop::drop(&mut (*ocean.coral).crab);
+
+        ManuallyDrop::drop(&mut ocean.coral);
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 72898355429c278ea994758805a92e611aecb430 Mon Sep 17 00:00:00 2001
From: kraktus <kraktus@users.noreply.github.com>
Date: Tue, 27 Sep 2022 22:24:14 +0200
Subject: [`should_implement_trait`] Also lint `default` method

---
 clippy_lints/src/methods/mod.rs                 | 83 +++++++++++--------------
 tests/ui/should_impl_trait/method_list_1.stderr | 12 +++-
 2 files changed, 49 insertions(+), 46 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index cdde4c54d63..c43f822e3a3 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3255,65 +3255,59 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
         let self_ty = cx.tcx.type_of(item.def_id);
 
         let implements_trait = matches!(item.kind, hir::ItemKind::Impl(hir::Impl { of_trait: Some(_), .. }));
-        if_chain! {
-            if let hir::ImplItemKind::Fn(ref sig, id) = impl_item.kind;
-            if let Some(first_arg) = iter_input_pats(sig.decl, cx.tcx.hir().body(id)).next();
-
+        if let hir::ImplItemKind::Fn(ref sig, id) = impl_item.kind {
             let method_sig = cx.tcx.fn_sig(impl_item.def_id);
             let method_sig = cx.tcx.erase_late_bound_regions(method_sig);
-
-            let first_arg_ty = method_sig.inputs().iter().next();
-
-            // check conventions w.r.t. conversion method names and predicates
-            if let Some(first_arg_ty) = first_arg_ty;
-
-            then {
-                // if this impl block implements a trait, lint in trait definition instead
-                if !implements_trait && cx.access_levels.is_exported(impl_item.def_id) {
-                    // check missing trait implementations
-                    for method_config in &TRAIT_METHODS {
-                        if name == method_config.method_name &&
-                            sig.decl.inputs.len() == method_config.param_count &&
-                            method_config.output_type.matches(&sig.decl.output) &&
-                            method_config.self_kind.matches(cx, self_ty, *first_arg_ty) &&
-                            fn_header_equals(method_config.fn_header, sig.header) &&
-                            method_config.lifetime_param_cond(impl_item)
-                        {
-                            span_lint_and_help(
-                                cx,
-                                SHOULD_IMPLEMENT_TRAIT,
-                                impl_item.span,
-                                &format!(
-                                    "method `{}` can be confused for the standard trait method `{}::{}`",
-                                    method_config.method_name,
-                                    method_config.trait_name,
-                                    method_config.method_name
-                                ),
-                                None,
-                                &format!(
-                                    "consider implementing the trait `{}` or choosing a less ambiguous method name",
-                                    method_config.trait_name
-                                )
-                            );
-                        }
+            let first_arg_ty_opt = method_sig.inputs().iter().next().copied();
+            // if this impl block implements a trait, lint in trait definition instead
+            if !implements_trait && cx.access_levels.is_exported(impl_item.def_id) {
+                // check missing trait implementations
+                for method_config in &TRAIT_METHODS {
+                    if name == method_config.method_name
+                        && sig.decl.inputs.len() == method_config.param_count
+                        && method_config.output_type.matches(&sig.decl.output)
+                        // in case there is no first arg, since we already have checked the number of arguments
+                        // it's should be always true
+                        && first_arg_ty_opt.map_or(true, |first_arg_ty| method_config
+                            .self_kind.matches(cx, self_ty, first_arg_ty)
+                            )
+                        && fn_header_equals(method_config.fn_header, sig.header)
+                        && method_config.lifetime_param_cond(impl_item)
+                    {
+                        span_lint_and_help(
+                            cx,
+                            SHOULD_IMPLEMENT_TRAIT,
+                            impl_item.span,
+                            &format!(
+                                "method `{}` can be confused for the standard trait method `{}::{}`",
+                                method_config.method_name, method_config.trait_name, method_config.method_name
+                            ),
+                            None,
+                            &format!(
+                                "consider implementing the trait `{}` or choosing a less ambiguous method name",
+                                method_config.trait_name
+                            ),
+                        );
                     }
                 }
+            }
 
-                if sig.decl.implicit_self.has_implicit_self()
+            if sig.decl.implicit_self.has_implicit_self()
                     && !(self.avoid_breaking_exported_api
-                        && cx.access_levels.is_exported(impl_item.def_id))
+                    && cx.access_levels.is_exported(impl_item.def_id))
+                    && let Some(first_arg) = iter_input_pats(sig.decl, cx.tcx.hir().body(id)).next()
+                    && let Some(first_arg_ty) = first_arg_ty_opt
                 {
                     wrong_self_convention::check(
                         cx,
                         name,
                         self_ty,
-                        *first_arg_ty,
+                        first_arg_ty,
                         first_arg.pat.span,
                         implements_trait,
                         false
                     );
                 }
-            }
         }
 
         // if this impl block implements a trait, lint in trait definition instead
@@ -3799,7 +3793,6 @@ const TRAIT_METHODS: [ShouldImplTraitCase; 30] = [
     ShouldImplTraitCase::new("std::borrow::BorrowMut", "borrow_mut",  1,  FN_HEADER,  SelfKind::RefMut,  OutType::Ref, true),
     ShouldImplTraitCase::new("std::clone::Clone", "clone",  1,  FN_HEADER,  SelfKind::Ref,  OutType::Any, true),
     ShouldImplTraitCase::new("std::cmp::Ord", "cmp",  2,  FN_HEADER,  SelfKind::Ref,  OutType::Any, true),
-    // FIXME: default doesn't work
     ShouldImplTraitCase::new("std::default::Default", "default",  0,  FN_HEADER,  SelfKind::No,  OutType::Any, true),
     ShouldImplTraitCase::new("std::ops::Deref", "deref",  1,  FN_HEADER,  SelfKind::Ref,  OutType::Ref, true),
     ShouldImplTraitCase::new("std::ops::DerefMut", "deref_mut",  1,  FN_HEADER,  SelfKind::RefMut,  OutType::Ref, true),
@@ -3827,7 +3820,7 @@ enum SelfKind {
     Value,
     Ref,
     RefMut,
-    No,
+    No, // When we want the first argument type to be different than `Self`
 }
 
 impl SelfKind {
diff --git a/tests/ui/should_impl_trait/method_list_1.stderr b/tests/ui/should_impl_trait/method_list_1.stderr
index 2b7d4628c3f..e6daedc5654 100644
--- a/tests/ui/should_impl_trait/method_list_1.stderr
+++ b/tests/ui/should_impl_trait/method_list_1.stderr
@@ -99,6 +99,16 @@ LL | |     }
    |
    = help: consider implementing the trait `std::cmp::Ord` or choosing a less ambiguous method name
 
+error: method `default` can be confused for the standard trait method `std::default::Default::default`
+  --> $DIR/method_list_1.rs:65:5
+   |
+LL | /     pub fn default() -> Self {
+LL | |         unimplemented!()
+LL | |     }
+   | |_____^
+   |
+   = help: consider implementing the trait `std::default::Default` or choosing a less ambiguous method name
+
 error: method `deref` can be confused for the standard trait method `std::ops::Deref::deref`
   --> $DIR/method_list_1.rs:69:5
    |
@@ -139,5 +149,5 @@ LL | |     }
    |
    = help: consider implementing the trait `std::ops::Drop` or choosing a less ambiguous method name
 
-error: aborting due to 14 previous errors
+error: aborting due to 15 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 8ba081c59734c48a6f3dea6fdf35767da5652a3b Mon Sep 17 00:00:00 2001
From: alex-semenyuk <alexsemenyuk88@gmail.com>
Date: Wed, 28 Sep 2022 23:01:11 +0300
Subject: Fix typo

---
 clippy_lints/src/option_if_let_else.rs | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/option_if_let_else.rs b/clippy_lints/src/option_if_let_else.rs
index 256d2450001..2c1e3b855d5 100644
--- a/clippy_lints/src/option_if_let_else.rs
+++ b/clippy_lints/src/option_if_let_else.rs
@@ -88,7 +88,7 @@ declare_lint_pass!(OptionIfLetElse => [OPTION_IF_LET_ELSE]);
 ///     None/_ => {..}
 /// }
 /// ```
-struct OptionOccurence {
+struct OptionOccurrence {
     option: String,
     method_sugg: String,
     some_expr: String,
@@ -109,13 +109,13 @@ fn format_option_in_sugg(cx: &LateContext<'_>, cond_expr: &Expr<'_>, as_ref: boo
     )
 }
 
-fn try_get_option_occurence<'tcx>(
+fn try_get_option_occurrence<'tcx>(
     cx: &LateContext<'tcx>,
     pat: &Pat<'tcx>,
     expr: &Expr<'_>,
     if_then: &'tcx Expr<'_>,
     if_else: &'tcx Expr<'_>,
-) -> Option<OptionOccurence> {
+) -> Option<OptionOccurrence> {
     let cond_expr = match expr.kind {
         ExprKind::Unary(UnOp::Deref, inner_expr) | ExprKind::AddrOf(_, _, inner_expr) => inner_expr,
         _ => expr,
@@ -160,7 +160,7 @@ fn try_get_option_occurence<'tcx>(
                 }
             }
 
-            return Some(OptionOccurence {
+            return Some(OptionOccurrence {
                 option: format_option_in_sugg(cx, cond_expr, as_ref, as_mut),
                 method_sugg: method_sugg.to_string(),
                 some_expr: format!("|{capture_mut}{capture_name}| {}", Sugg::hir_with_macro_callsite(cx, some_body, "..")),
@@ -182,9 +182,9 @@ fn try_get_inner_pat<'tcx>(cx: &LateContext<'tcx>, pat: &Pat<'tcx>) -> Option<&'
 }
 
 /// If this expression is the option if let/else construct we're detecting, then
-/// this function returns an `OptionOccurence` struct with details if
+/// this function returns an `OptionOccurrence` struct with details if
 /// this construct is found, or None if this construct is not found.
-fn detect_option_if_let_else<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>) -> Option<OptionOccurence> {
+fn detect_option_if_let_else<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>) -> Option<OptionOccurrence> {
     if let Some(higher::IfLet {
         let_pat,
         let_expr,
@@ -193,16 +193,16 @@ fn detect_option_if_let_else<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>) ->
     }) = higher::IfLet::hir(cx, expr)
     {
         if !is_else_clause(cx.tcx, expr) {
-            return try_get_option_occurence(cx, let_pat, let_expr, if_then, if_else);
+            return try_get_option_occurrence(cx, let_pat, let_expr, if_then, if_else);
         }
     }
     None
 }
 
-fn detect_option_match<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>) -> Option<OptionOccurence> {
+fn detect_option_match<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>) -> Option<OptionOccurrence> {
     if let ExprKind::Match(ex, arms, MatchSource::Normal) = expr.kind {
         if let Some((let_pat, if_then, if_else)) = try_convert_match(cx, arms) {
-            return try_get_option_occurence(cx, let_pat, ex, if_then, if_else);
+            return try_get_option_occurrence(cx, let_pat, ex, if_then, if_else);
         }
     }
     None
-- 
cgit 1.4.1-3-g733a5


From 67af127f243e5a3abcdf95f395b1029560a63ac1 Mon Sep 17 00:00:00 2001
From: Philipp Krones <hello@philkrones.com>
Date: Wed, 28 Sep 2022 14:31:29 +0200
Subject: Fix dogfood

---
 clippy_lints/src/equatable_if_let.rs                |  2 +-
 clippy_lints/src/lifetimes.rs                       |  2 +-
 clippy_lints/src/matches/redundant_pattern_match.rs | 12 ++++++------
 clippy_lints/src/ptr.rs                             |  2 +-
 clippy_lints/src/types/mod.rs                       |  2 +-
 clippy_utils/src/hir_utils.rs                       |  4 ++--
 6 files changed, 12 insertions(+), 12 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/equatable_if_let.rs b/clippy_lints/src/equatable_if_let.rs
index f5aa0dcf9a4..b40cb7cddaf 100644
--- a/clippy_lints/src/equatable_if_let.rs
+++ b/clippy_lints/src/equatable_if_let.rs
@@ -51,7 +51,7 @@ fn unary_pattern(pat: &Pat<'_>) -> bool {
             false
         },
         PatKind::Struct(_, a, etc) => !etc && a.iter().all(|x| unary_pattern(x.pat)),
-        PatKind::Tuple(a, etc) | PatKind::TupleStruct(_, a, etc) => !etc.as_opt_usize().is_some() && array_rec(a),
+        PatKind::Tuple(a, etc) | PatKind::TupleStruct(_, a, etc) => etc.as_opt_usize().is_none() && array_rec(a),
         PatKind::Ref(x, _) | PatKind::Box(x) => unary_pattern(x),
         PatKind::Path(_) | PatKind::Lit(_) => true,
     }
diff --git a/clippy_lints/src/lifetimes.rs b/clippy_lints/src/lifetimes.rs
index aef253303a8..13878eda0f1 100644
--- a/clippy_lints/src/lifetimes.rs
+++ b/clippy_lints/src/lifetimes.rs
@@ -461,7 +461,7 @@ impl<'a, 'tcx> Visitor<'tcx> for RefVisitor<'a, 'tcx> {
                 sub_visitor.visit_fn_decl(decl);
                 self.nested_elision_site_lts.append(&mut sub_visitor.all_lts());
             },
-            TyKind::TraitObject(bounds, ref lt, _) => {
+            TyKind::TraitObject(bounds, lt, _) => {
                 if !lt.is_elided() {
                     self.unelided_trait_object_lifetime = true;
                 }
diff --git a/clippy_lints/src/matches/redundant_pattern_match.rs b/clippy_lints/src/matches/redundant_pattern_match.rs
index 11495cca97d..6d6aa43df2a 100644
--- a/clippy_lints/src/matches/redundant_pattern_match.rs
+++ b/clippy_lints/src/matches/redundant_pattern_match.rs
@@ -308,15 +308,15 @@ fn find_good_method_for_match<'a>(
     should_be_left: &'a str,
     should_be_right: &'a str,
 ) -> Option<&'a str> {
-    let pat_left = arms[0].pat;
-    let pat_right = arms[1].pat;
+    let first_pat = arms[0].pat;
+    let second_pat = arms[1].pat;
 
-    let body_node_pair = if (is_pat_variant(cx, pat_left, path_left, expected_item_left))
-        && (is_pat_variant(cx, pat_right, path_right, expected_item_right))
+    let body_node_pair = if (is_pat_variant(cx, first_pat, path_left, expected_item_left))
+        && (is_pat_variant(cx, second_pat, path_right, expected_item_right))
     {
         (&arms[0].body.kind, &arms[1].body.kind)
-    } else if (is_pat_variant(cx, pat_left, path_left, expected_item_right))
-        && (is_pat_variant(cx, pat_right, path_right, expected_item_left))
+    } else if (is_pat_variant(cx, first_pat, path_left, expected_item_right))
+        && (is_pat_variant(cx, second_pat, path_right, expected_item_left))
     {
         (&arms[1].body.kind, &arms[0].body.kind)
     } else {
diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs
index 85e0710eb50..d296a150b46 100644
--- a/clippy_lints/src/ptr.rs
+++ b/clippy_lints/src/ptr.rs
@@ -669,7 +669,7 @@ fn check_ptr_arg_usage<'tcx>(cx: &LateContext<'tcx>, body: &'tcx Body<'_>, args:
 }
 
 fn get_rptr_lm<'tcx>(ty: &'tcx hir::Ty<'tcx>) -> Option<(&'tcx Lifetime, Mutability, Span)> {
-    if let TyKind::Rptr(ref lt, ref m) = ty.kind {
+    if let TyKind::Rptr(lt, ref m) = ty.kind {
         Some((lt, m.mutbl, ty.span))
     } else {
         None
diff --git a/clippy_lints/src/types/mod.rs b/clippy_lints/src/types/mod.rs
index b81d2c1cbc4..79c31efb9fc 100644
--- a/clippy_lints/src/types/mod.rs
+++ b/clippy_lints/src/types/mod.rs
@@ -537,7 +537,7 @@ impl Types {
                     QPath::LangItem(..) => {},
                 }
             },
-            TyKind::Rptr(ref lt, ref mut_ty) => {
+            TyKind::Rptr(lt, ref mut_ty) => {
                 context.is_nested_call = true;
                 if !borrowed_box::check(cx, hir_ty, lt, mut_ty) {
                     self.check_ty(cx, mut_ty.ty, context);
diff --git a/clippy_utils/src/hir_utils.rs b/clippy_utils/src/hir_utils.rs
index 7212d9cd744..cf24ec8b67b 100644
--- a/clippy_utils/src/hir_utils.rs
+++ b/clippy_utils/src/hir_utils.rs
@@ -962,7 +962,7 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> {
                 mut_ty.mutbl.hash(&mut self.s);
             },
             TyKind::Rptr(lifetime, ref mut_ty) => {
-                self.hash_lifetime(*lifetime);
+                self.hash_lifetime(lifetime);
                 self.hash_ty(mut_ty.ty);
                 mut_ty.mutbl.hash(&mut self.s);
             },
@@ -992,7 +992,7 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> {
                 in_trait.hash(&mut self.s);
             },
             TyKind::TraitObject(_, lifetime, _) => {
-                self.hash_lifetime(*lifetime);
+                self.hash_lifetime(lifetime);
             },
             TyKind::Typeof(anon_const) => {
                 self.hash_body(anon_const.body);
-- 
cgit 1.4.1-3-g733a5


From 6ec7759c3bff136c1d39bbe0bc8a68ac8b438a55 Mon Sep 17 00:00:00 2001
From: kraktus <kraktus@users.noreply.github.com>
Date: Thu, 29 Sep 2022 13:45:40 +0200
Subject: [`unnecessary_lazy_eval`] Do not lint in external macros

---
 clippy_lints/src/methods/unnecessary_lazy_eval.rs |  6 +-
 tests/ui/unnecessary_lazy_eval.fixed              | 10 ++++
 tests/ui/unnecessary_lazy_eval.rs                 | 10 ++++
 tests/ui/unnecessary_lazy_eval.stderr             | 68 +++++++++++------------
 4 files changed, 59 insertions(+), 35 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/unnecessary_lazy_eval.rs b/clippy_lints/src/methods/unnecessary_lazy_eval.rs
index ec9859fa298..0e73459ad65 100644
--- a/clippy_lints/src/methods/unnecessary_lazy_eval.rs
+++ b/clippy_lints/src/methods/unnecessary_lazy_eval.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{eager_or_lazy, usage};
+use clippy_utils::{eager_or_lazy, is_from_proc_macro, usage};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
@@ -18,6 +18,10 @@ pub(super) fn check<'tcx>(
     arg: &'tcx hir::Expr<'_>,
     simplify_using: &str,
 ) {
+    if is_from_proc_macro(cx, expr) {
+        return;
+    }
+
     let is_option = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(recv), sym::Option);
     let is_result = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(recv), sym::Result);
     let is_bool = cx.typeck_results().expr_ty(recv).is_bool();
diff --git a/tests/ui/unnecessary_lazy_eval.fixed b/tests/ui/unnecessary_lazy_eval.fixed
index 878537050d4..ce4a82e0217 100644
--- a/tests/ui/unnecessary_lazy_eval.fixed
+++ b/tests/ui/unnecessary_lazy_eval.fixed
@@ -1,9 +1,13 @@
 // run-rustfix
+// aux-build: proc_macro_with_span.rs
 #![warn(clippy::unnecessary_lazy_evaluations)]
 #![allow(clippy::redundant_closure)]
 #![allow(clippy::bind_instead_of_map)]
 #![allow(clippy::map_identity)]
 
+extern crate proc_macro_with_span;
+use proc_macro_with_span::with_span;
+
 struct Deep(Option<usize>);
 
 #[derive(Copy, Clone)]
@@ -141,3 +145,9 @@ fn main() {
     let _: Result<usize, usize> = res.and_then(|x| Err(x));
     let _: Result<usize, usize> = res.or_else(|err| Ok(err));
 }
+
+#[allow(unused)]
+fn issue9485() {
+    // should not lint, is in proc macro
+    with_span!(span Some(42).unwrap_or_else(|| 2););
+}
diff --git a/tests/ui/unnecessary_lazy_eval.rs b/tests/ui/unnecessary_lazy_eval.rs
index f70cf332460..59cdf662854 100644
--- a/tests/ui/unnecessary_lazy_eval.rs
+++ b/tests/ui/unnecessary_lazy_eval.rs
@@ -1,9 +1,13 @@
 // run-rustfix
+// aux-build: proc_macro_with_span.rs
 #![warn(clippy::unnecessary_lazy_evaluations)]
 #![allow(clippy::redundant_closure)]
 #![allow(clippy::bind_instead_of_map)]
 #![allow(clippy::map_identity)]
 
+extern crate proc_macro_with_span;
+use proc_macro_with_span::with_span;
+
 struct Deep(Option<usize>);
 
 #[derive(Copy, Clone)]
@@ -141,3 +145,9 @@ fn main() {
     let _: Result<usize, usize> = res.and_then(|x| Err(x));
     let _: Result<usize, usize> = res.or_else(|err| Ok(err));
 }
+
+#[allow(unused)]
+fn issue9485() {
+    // should not lint, is in proc macro
+    with_span!(span Some(42).unwrap_or_else(|| 2););
+}
diff --git a/tests/ui/unnecessary_lazy_eval.stderr b/tests/ui/unnecessary_lazy_eval.stderr
index b46fbf56c4b..8a9ece4aa7e 100644
--- a/tests/ui/unnecessary_lazy_eval.stderr
+++ b/tests/ui/unnecessary_lazy_eval.stderr
@@ -1,5 +1,5 @@
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:44:13
+  --> $DIR/unnecessary_lazy_eval.rs:48:13
    |
 LL |     let _ = opt.unwrap_or_else(|| 2);
    |             ^^^^--------------------
@@ -9,7 +9,7 @@ LL |     let _ = opt.unwrap_or_else(|| 2);
    = note: `-D clippy::unnecessary-lazy-evaluations` implied by `-D warnings`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:45:13
+  --> $DIR/unnecessary_lazy_eval.rs:49:13
    |
 LL |     let _ = opt.unwrap_or_else(|| astronomers_pi);
    |             ^^^^---------------------------------
@@ -17,7 +17,7 @@ LL |     let _ = opt.unwrap_or_else(|| astronomers_pi);
    |                 help: use `unwrap_or(..)` instead: `unwrap_or(astronomers_pi)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:46:13
+  --> $DIR/unnecessary_lazy_eval.rs:50:13
    |
 LL |     let _ = opt.unwrap_or_else(|| ext_str.some_field);
    |             ^^^^-------------------------------------
@@ -25,7 +25,7 @@ LL |     let _ = opt.unwrap_or_else(|| ext_str.some_field);
    |                 help: use `unwrap_or(..)` instead: `unwrap_or(ext_str.some_field)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:48:13
+  --> $DIR/unnecessary_lazy_eval.rs:52:13
    |
 LL |     let _ = opt.and_then(|_| ext_opt);
    |             ^^^^---------------------
@@ -33,7 +33,7 @@ LL |     let _ = opt.and_then(|_| ext_opt);
    |                 help: use `and(..)` instead: `and(ext_opt)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:49:13
+  --> $DIR/unnecessary_lazy_eval.rs:53:13
    |
 LL |     let _ = opt.or_else(|| ext_opt);
    |             ^^^^-------------------
@@ -41,7 +41,7 @@ LL |     let _ = opt.or_else(|| ext_opt);
    |                 help: use `or(..)` instead: `or(ext_opt)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:50:13
+  --> $DIR/unnecessary_lazy_eval.rs:54:13
    |
 LL |     let _ = opt.or_else(|| None);
    |             ^^^^----------------
@@ -49,7 +49,7 @@ LL |     let _ = opt.or_else(|| None);
    |                 help: use `or(..)` instead: `or(None)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:51:13
+  --> $DIR/unnecessary_lazy_eval.rs:55:13
    |
 LL |     let _ = opt.get_or_insert_with(|| 2);
    |             ^^^^------------------------
@@ -57,7 +57,7 @@ LL |     let _ = opt.get_or_insert_with(|| 2);
    |                 help: use `get_or_insert(..)` instead: `get_or_insert(2)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:52:13
+  --> $DIR/unnecessary_lazy_eval.rs:56:13
    |
 LL |     let _ = opt.ok_or_else(|| 2);
    |             ^^^^----------------
@@ -65,7 +65,7 @@ LL |     let _ = opt.ok_or_else(|| 2);
    |                 help: use `ok_or(..)` instead: `ok_or(2)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:53:13
+  --> $DIR/unnecessary_lazy_eval.rs:57:13
    |
 LL |     let _ = nested_tuple_opt.unwrap_or_else(|| Some((1, 2)));
    |             ^^^^^^^^^^^^^^^^^-------------------------------
@@ -73,7 +73,7 @@ LL |     let _ = nested_tuple_opt.unwrap_or_else(|| Some((1, 2)));
    |                              help: use `unwrap_or(..)` instead: `unwrap_or(Some((1, 2)))`
 
 error: unnecessary closure used with `bool::then`
-  --> $DIR/unnecessary_lazy_eval.rs:54:13
+  --> $DIR/unnecessary_lazy_eval.rs:58:13
    |
 LL |     let _ = cond.then(|| astronomers_pi);
    |             ^^^^^-----------------------
@@ -81,7 +81,7 @@ LL |     let _ = cond.then(|| astronomers_pi);
    |                  help: use `then_some(..)` instead: `then_some(astronomers_pi)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:57:13
+  --> $DIR/unnecessary_lazy_eval.rs:61:13
    |
 LL |     let _ = Some(10).unwrap_or_else(|| 2);
    |             ^^^^^^^^^--------------------
@@ -89,7 +89,7 @@ LL |     let _ = Some(10).unwrap_or_else(|| 2);
    |                      help: use `unwrap_or(..)` instead: `unwrap_or(2)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:58:13
+  --> $DIR/unnecessary_lazy_eval.rs:62:13
    |
 LL |     let _ = Some(10).and_then(|_| ext_opt);
    |             ^^^^^^^^^---------------------
@@ -97,7 +97,7 @@ LL |     let _ = Some(10).and_then(|_| ext_opt);
    |                      help: use `and(..)` instead: `and(ext_opt)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:59:28
+  --> $DIR/unnecessary_lazy_eval.rs:63:28
    |
 LL |     let _: Option<usize> = None.or_else(|| ext_opt);
    |                            ^^^^^-------------------
@@ -105,7 +105,7 @@ LL |     let _: Option<usize> = None.or_else(|| ext_opt);
    |                                 help: use `or(..)` instead: `or(ext_opt)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:60:13
+  --> $DIR/unnecessary_lazy_eval.rs:64:13
    |
 LL |     let _ = None.get_or_insert_with(|| 2);
    |             ^^^^^------------------------
@@ -113,7 +113,7 @@ LL |     let _ = None.get_or_insert_with(|| 2);
    |                  help: use `get_or_insert(..)` instead: `get_or_insert(2)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:61:35
+  --> $DIR/unnecessary_lazy_eval.rs:65:35
    |
 LL |     let _: Result<usize, usize> = None.ok_or_else(|| 2);
    |                                   ^^^^^----------------
@@ -121,7 +121,7 @@ LL |     let _: Result<usize, usize> = None.ok_or_else(|| 2);
    |                                        help: use `ok_or(..)` instead: `ok_or(2)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:62:28
+  --> $DIR/unnecessary_lazy_eval.rs:66:28
    |
 LL |     let _: Option<usize> = None.or_else(|| None);
    |                            ^^^^^----------------
@@ -129,7 +129,7 @@ LL |     let _: Option<usize> = None.or_else(|| None);
    |                                 help: use `or(..)` instead: `or(None)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:65:13
+  --> $DIR/unnecessary_lazy_eval.rs:69:13
    |
 LL |     let _ = deep.0.unwrap_or_else(|| 2);
    |             ^^^^^^^--------------------
@@ -137,7 +137,7 @@ LL |     let _ = deep.0.unwrap_or_else(|| 2);
    |                    help: use `unwrap_or(..)` instead: `unwrap_or(2)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:66:13
+  --> $DIR/unnecessary_lazy_eval.rs:70:13
    |
 LL |     let _ = deep.0.and_then(|_| ext_opt);
    |             ^^^^^^^---------------------
@@ -145,7 +145,7 @@ LL |     let _ = deep.0.and_then(|_| ext_opt);
    |                    help: use `and(..)` instead: `and(ext_opt)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:67:13
+  --> $DIR/unnecessary_lazy_eval.rs:71:13
    |
 LL |     let _ = deep.0.or_else(|| None);
    |             ^^^^^^^----------------
@@ -153,7 +153,7 @@ LL |     let _ = deep.0.or_else(|| None);
    |                    help: use `or(..)` instead: `or(None)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:68:13
+  --> $DIR/unnecessary_lazy_eval.rs:72:13
    |
 LL |     let _ = deep.0.get_or_insert_with(|| 2);
    |             ^^^^^^^------------------------
@@ -161,7 +161,7 @@ LL |     let _ = deep.0.get_or_insert_with(|| 2);
    |                    help: use `get_or_insert(..)` instead: `get_or_insert(2)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:69:13
+  --> $DIR/unnecessary_lazy_eval.rs:73:13
    |
 LL |     let _ = deep.0.ok_or_else(|| 2);
    |             ^^^^^^^----------------
@@ -169,7 +169,7 @@ LL |     let _ = deep.0.ok_or_else(|| 2);
    |                    help: use `ok_or(..)` instead: `ok_or(2)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:92:28
+  --> $DIR/unnecessary_lazy_eval.rs:96:28
    |
 LL |     let _: Option<usize> = None.or_else(|| Some(3));
    |                            ^^^^^-------------------
@@ -177,7 +177,7 @@ LL |     let _: Option<usize> = None.or_else(|| Some(3));
    |                                 help: use `or(..)` instead: `or(Some(3))`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:93:13
+  --> $DIR/unnecessary_lazy_eval.rs:97:13
    |
 LL |     let _ = deep.0.or_else(|| Some(3));
    |             ^^^^^^^-------------------
@@ -185,7 +185,7 @@ LL |     let _ = deep.0.or_else(|| Some(3));
    |                    help: use `or(..)` instead: `or(Some(3))`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:94:13
+  --> $DIR/unnecessary_lazy_eval.rs:98:13
    |
 LL |     let _ = opt.or_else(|| Some(3));
    |             ^^^^-------------------
@@ -193,7 +193,7 @@ LL |     let _ = opt.or_else(|| Some(3));
    |                 help: use `or(..)` instead: `or(Some(3))`
 
 error: unnecessary closure used to substitute value for `Result::Err`
-  --> $DIR/unnecessary_lazy_eval.rs:100:13
+  --> $DIR/unnecessary_lazy_eval.rs:104:13
    |
 LL |     let _ = res2.unwrap_or_else(|_| 2);
    |             ^^^^^---------------------
@@ -201,7 +201,7 @@ LL |     let _ = res2.unwrap_or_else(|_| 2);
    |                  help: use `unwrap_or(..)` instead: `unwrap_or(2)`
 
 error: unnecessary closure used to substitute value for `Result::Err`
-  --> $DIR/unnecessary_lazy_eval.rs:101:13
+  --> $DIR/unnecessary_lazy_eval.rs:105:13
    |
 LL |     let _ = res2.unwrap_or_else(|_| astronomers_pi);
    |             ^^^^^----------------------------------
@@ -209,7 +209,7 @@ LL |     let _ = res2.unwrap_or_else(|_| astronomers_pi);
    |                  help: use `unwrap_or(..)` instead: `unwrap_or(astronomers_pi)`
 
 error: unnecessary closure used to substitute value for `Result::Err`
-  --> $DIR/unnecessary_lazy_eval.rs:102:13
+  --> $DIR/unnecessary_lazy_eval.rs:106:13
    |
 LL |     let _ = res2.unwrap_or_else(|_| ext_str.some_field);
    |             ^^^^^--------------------------------------
@@ -217,7 +217,7 @@ LL |     let _ = res2.unwrap_or_else(|_| ext_str.some_field);
    |                  help: use `unwrap_or(..)` instead: `unwrap_or(ext_str.some_field)`
 
 error: unnecessary closure used to substitute value for `Result::Err`
-  --> $DIR/unnecessary_lazy_eval.rs:124:35
+  --> $DIR/unnecessary_lazy_eval.rs:128:35
    |
 LL |     let _: Result<usize, usize> = res.and_then(|_| Err(2));
    |                                   ^^^^--------------------
@@ -225,7 +225,7 @@ LL |     let _: Result<usize, usize> = res.and_then(|_| Err(2));
    |                                       help: use `and(..)` instead: `and(Err(2))`
 
 error: unnecessary closure used to substitute value for `Result::Err`
-  --> $DIR/unnecessary_lazy_eval.rs:125:35
+  --> $DIR/unnecessary_lazy_eval.rs:129:35
    |
 LL |     let _: Result<usize, usize> = res.and_then(|_| Err(astronomers_pi));
    |                                   ^^^^---------------------------------
@@ -233,7 +233,7 @@ LL |     let _: Result<usize, usize> = res.and_then(|_| Err(astronomers_pi));
    |                                       help: use `and(..)` instead: `and(Err(astronomers_pi))`
 
 error: unnecessary closure used to substitute value for `Result::Err`
-  --> $DIR/unnecessary_lazy_eval.rs:126:35
+  --> $DIR/unnecessary_lazy_eval.rs:130:35
    |
 LL |     let _: Result<usize, usize> = res.and_then(|_| Err(ext_str.some_field));
    |                                   ^^^^-------------------------------------
@@ -241,7 +241,7 @@ LL |     let _: Result<usize, usize> = res.and_then(|_| Err(ext_str.some_field))
    |                                       help: use `and(..)` instead: `and(Err(ext_str.some_field))`
 
 error: unnecessary closure used to substitute value for `Result::Err`
-  --> $DIR/unnecessary_lazy_eval.rs:128:35
+  --> $DIR/unnecessary_lazy_eval.rs:132:35
    |
 LL |     let _: Result<usize, usize> = res.or_else(|_| Ok(2));
    |                                   ^^^^------------------
@@ -249,7 +249,7 @@ LL |     let _: Result<usize, usize> = res.or_else(|_| Ok(2));
    |                                       help: use `or(..)` instead: `or(Ok(2))`
 
 error: unnecessary closure used to substitute value for `Result::Err`
-  --> $DIR/unnecessary_lazy_eval.rs:129:35
+  --> $DIR/unnecessary_lazy_eval.rs:133:35
    |
 LL |     let _: Result<usize, usize> = res.or_else(|_| Ok(astronomers_pi));
    |                                   ^^^^-------------------------------
@@ -257,7 +257,7 @@ LL |     let _: Result<usize, usize> = res.or_else(|_| Ok(astronomers_pi));
    |                                       help: use `or(..)` instead: `or(Ok(astronomers_pi))`
 
 error: unnecessary closure used to substitute value for `Result::Err`
-  --> $DIR/unnecessary_lazy_eval.rs:130:35
+  --> $DIR/unnecessary_lazy_eval.rs:134:35
    |
 LL |     let _: Result<usize, usize> = res.or_else(|_| Ok(ext_str.some_field));
    |                                   ^^^^-----------------------------------
@@ -265,7 +265,7 @@ LL |     let _: Result<usize, usize> = res.or_else(|_| Ok(ext_str.some_field));
    |                                       help: use `or(..)` instead: `or(Ok(ext_str.some_field))`
 
 error: unnecessary closure used to substitute value for `Result::Err`
-  --> $DIR/unnecessary_lazy_eval.rs:131:35
+  --> $DIR/unnecessary_lazy_eval.rs:135:35
    |
 LL |       let _: Result<usize, usize> = res.
    |  ___________________________________^
-- 
cgit 1.4.1-3-g733a5


From 416da1264c48aa38c6ae8c6f6aefffa49ae3b21f Mon Sep 17 00:00:00 2001
From: Evan Typanski <evantypanski@gmail.com>
Date: Thu, 29 Sep 2022 19:31:32 -0400
Subject: [`redundant_closure`] Add `&mut` to more cases

---
 clippy_lints/src/eta_reduction.rs | 14 +++++---------
 tests/ui/eta.fixed                | 11 +++++++++++
 tests/ui/eta.rs                   | 11 +++++++++++
 tests/ui/eta.stderr               | 14 +++++++++++++-
 4 files changed, 40 insertions(+), 10 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/eta_reduction.rs b/clippy_lints/src/eta_reduction.rs
index 710fceceae5..a5c6512a5e7 100644
--- a/clippy_lints/src/eta_reduction.rs
+++ b/clippy_lints/src/eta_reduction.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::higher::VecArgs;
 use clippy_utils::source::snippet_opt;
-use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::ty::{implements_trait, is_type_diagnostic_item};
 use clippy_utils::usage::local_used_after_expr;
 use clippy_utils::{higher, is_adjusted, path_to_local, path_to_local_id};
 use if_chain::if_chain;
@@ -11,7 +11,7 @@ use rustc_hir::{Closure, Expr, ExprKind, Param, PatKind, Unsafety};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::adjustment::{Adjust, Adjustment, AutoBorrow};
 use rustc_middle::ty::binding::BindingMode;
-use rustc_middle::ty::{self, ClosureKind, Ty, TypeVisitable};
+use rustc_middle::ty::{self, Ty, TypeVisitable};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::symbol::sym;
 
@@ -122,15 +122,11 @@ impl<'tcx> LateLintPass<'tcx> for EtaReduction {
             then {
                 span_lint_and_then(cx, REDUNDANT_CLOSURE, expr.span, "redundant closure", |diag| {
                     if let Some(mut snippet) = snippet_opt(cx, callee.span) {
-                        if_chain! {
-                            if let ty::Closure(_, substs) = callee_ty.peel_refs().kind();
-                            if substs.as_closure().kind() == ClosureKind::FnMut;
-                            if path_to_local(callee).map_or(false, |l| local_used_after_expr(cx, l, expr));
-
-                            then {
+                        if let Some(fn_mut_id) = cx.tcx.lang_items().fn_mut_trait() &&
+                            implements_trait(cx, callee_ty.peel_refs(), fn_mut_id, &[]) &&
+                            path_to_local(callee).map_or(false, |l| local_used_after_expr(cx, l, expr)) {
                                 // Mutable closure is used after current expr; we cannot consume it.
                                 snippet = format!("&mut {snippet}");
-                            }
                         }
                         diag.span_suggestion(
                             expr.span,
diff --git a/tests/ui/eta.fixed b/tests/ui/eta.fixed
index f8d559bf226..112bb4b4817 100644
--- a/tests/ui/eta.fixed
+++ b/tests/ui/eta.fixed
@@ -303,3 +303,14 @@ fn not_general_enough() {
     fn f(_: impl FnMut(&Path) -> std::io::Result<()>) {}
     f(|path| std::fs::remove_file(path));
 }
+
+// https://github.com/rust-lang/rust-clippy/issues/9369
+pub fn mutable_impl_fn_mut(mut f: impl FnMut()) {
+    fn takes_fn_mut(_: impl FnMut()) {}
+    takes_fn_mut(&mut f);
+
+    fn takes_fn_once(_: impl FnOnce()) {}
+    takes_fn_once(&mut f);
+
+    f();
+}
diff --git a/tests/ui/eta.rs b/tests/ui/eta.rs
index f0fb55a1e5f..970144e06dd 100644
--- a/tests/ui/eta.rs
+++ b/tests/ui/eta.rs
@@ -303,3 +303,14 @@ fn not_general_enough() {
     fn f(_: impl FnMut(&Path) -> std::io::Result<()>) {}
     f(|path| std::fs::remove_file(path));
 }
+
+// https://github.com/rust-lang/rust-clippy/issues/9369
+pub fn mutable_impl_fn_mut(mut f: impl FnMut()) {
+    fn takes_fn_mut(_: impl FnMut()) {}
+    takes_fn_mut(|| f());
+
+    fn takes_fn_once(_: impl FnOnce()) {}
+    takes_fn_once(|| f());
+
+    f();
+}
diff --git a/tests/ui/eta.stderr b/tests/ui/eta.stderr
index bf2e97e744a..f7ead7257f6 100644
--- a/tests/ui/eta.stderr
+++ b/tests/ui/eta.stderr
@@ -116,5 +116,17 @@ error: redundant closure
 LL |         Some(1).map(|n| in_loop(n));
    |                     ^^^^^^^^^^^^^^ help: replace the closure with the function itself: `in_loop`
 
-error: aborting due to 19 previous errors
+error: redundant closure
+  --> $DIR/eta.rs:310:18
+   |
+LL |     takes_fn_mut(|| f());
+   |                  ^^^^^^ help: replace the closure with the function itself: `&mut f`
+
+error: redundant closure
+  --> $DIR/eta.rs:313:19
+   |
+LL |     takes_fn_once(|| f());
+   |                   ^^^^^^ help: replace the closure with the function itself: `&mut f`
+
+error: aborting due to 21 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 85b8ff7f38149caefd60fd79dc156dc3d18c3c7c Mon Sep 17 00:00:00 2001
From: Evan Typanski <evantypanski@gmail.com>
Date: Fri, 30 Sep 2022 11:36:55 -0400
Subject: Fix style in `if let` chain

Co-authored-by: Alex Macleod <alex@macleod.io>
---
 clippy_lints/src/eta_reduction.rs | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/eta_reduction.rs b/clippy_lints/src/eta_reduction.rs
index a5c6512a5e7..3732410e71e 100644
--- a/clippy_lints/src/eta_reduction.rs
+++ b/clippy_lints/src/eta_reduction.rs
@@ -122,9 +122,10 @@ impl<'tcx> LateLintPass<'tcx> for EtaReduction {
             then {
                 span_lint_and_then(cx, REDUNDANT_CLOSURE, expr.span, "redundant closure", |diag| {
                     if let Some(mut snippet) = snippet_opt(cx, callee.span) {
-                        if let Some(fn_mut_id) = cx.tcx.lang_items().fn_mut_trait() &&
-                            implements_trait(cx, callee_ty.peel_refs(), fn_mut_id, &[]) &&
-                            path_to_local(callee).map_or(false, |l| local_used_after_expr(cx, l, expr)) {
+                        if let Some(fn_mut_id) = cx.tcx.lang_items().fn_mut_trait()
+                            && implements_trait(cx, callee_ty.peel_refs(), fn_mut_id, &[])
+                            && path_to_local(callee).map_or(false, |l| local_used_after_expr(cx, l, expr))
+                        {
                                 // Mutable closure is used after current expr; we cannot consume it.
                                 snippet = format!("&mut {snippet}");
                         }
-- 
cgit 1.4.1-3-g733a5


From 4876882b29a1535779593d321fcb886a0c26c594 Mon Sep 17 00:00:00 2001
From: Caio <c410.f3r@gmail.com>
Date: Fri, 30 Sep 2022 15:30:40 -0300
Subject: Fix #9544

---
 .../src/operators/arithmetic_side_effects.rs       |  37 ++--
 tests/ui/arithmetic_side_effects.rs                |  53 +++++-
 tests/ui/arithmetic_side_effects.stderr            | 202 ++++++++++++++++++---
 3 files changed, 243 insertions(+), 49 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/operators/arithmetic_side_effects.rs b/clippy_lints/src/operators/arithmetic_side_effects.rs
index c8a374d90b5..d871b72db8f 100644
--- a/clippy_lints/src/operators/arithmetic_side_effects.rs
+++ b/clippy_lints/src/operators/arithmetic_side_effects.rs
@@ -16,8 +16,9 @@ const HARD_CODED_ALLOWED: &[&str] = &[
     "f32",
     "f64",
     "std::num::Saturating",
-    "std::string::String",
     "std::num::Wrapping",
+    "std::string::String",
+    "&str",
 ];
 
 #[derive(Debug)]
@@ -77,6 +78,11 @@ impl ArithmeticSideEffects {
         )
     }
 
+    // For example, 8i32 or &i64::MAX.
+    fn is_integral<'expr, 'tcx>(cx: &LateContext<'tcx>, expr: &'expr hir::Expr<'tcx>) -> bool {
+        cx.typeck_results().expr_ty(expr).peel_refs().is_integral()
+    }
+
     // Common entry-point to avoid code duplication.
     fn issue_lint(&mut self, cx: &LateContext<'_>, expr: &hir::Expr<'_>) {
         let msg = "arithmetic operation that can potentially result in unexpected side-effects";
@@ -88,24 +94,13 @@ impl ArithmeticSideEffects {
     /// * Is `expr` is a literal integer reference like `&199`, returns the literal integer without
     ///   references.
     /// * If `expr` is anything else, returns `None`.
-    fn literal_integer<'expr, 'tcx>(
-        cx: &LateContext<'tcx>,
-        expr: &'expr hir::Expr<'tcx>,
-    ) -> Option<&'expr hir::Expr<'tcx>> {
-        let expr_refs = cx.typeck_results().expr_ty(expr).peel_refs();
-
-        if !expr_refs.is_integral() {
-            return None;
-        }
-
+    fn literal_integer<'expr, 'tcx>(expr: &'expr hir::Expr<'tcx>) -> Option<&'expr hir::Expr<'tcx>> {
         if matches!(expr.kind, hir::ExprKind::Lit(_)) {
             return Some(expr);
         }
-
         if let hir::ExprKind::AddrOf(.., inn) = expr.kind && let hir::ExprKind::Lit(_) = inn.kind {
             return Some(inn)
         }
-
         None
     }
 
@@ -134,14 +129,18 @@ impl ArithmeticSideEffects {
         ) {
             return;
         };
-        if self.is_allowed_ty(cx, lhs) || self.is_allowed_ty(cx, rhs) {
+        if self.is_allowed_ty(cx, lhs) && self.is_allowed_ty(cx, rhs) {
             return;
         }
-        let has_valid_op = match (Self::literal_integer(cx, lhs), Self::literal_integer(cx, rhs)) {
-            (None, None) => false,
-            (None, Some(local_expr)) => Self::has_valid_op(op, local_expr),
-            (Some(local_expr), None) => Self::has_valid_op(op, local_expr),
-            (Some(_), Some(_)) => true,
+        let has_valid_op = if Self::is_integral(cx, lhs) && Self::is_integral(cx, rhs) {
+            match (Self::literal_integer(lhs), Self::literal_integer(rhs)) {
+                (None, None) => false,
+                (None, Some(local_expr)) => Self::has_valid_op(op, local_expr),
+                (Some(local_expr), None) => Self::has_valid_op(op, local_expr),
+                (Some(_), Some(_)) => true,
+            }
+        } else {
+            false
         };
         if !has_valid_op {
             self.issue_lint(cx, expr);
diff --git a/tests/ui/arithmetic_side_effects.rs b/tests/ui/arithmetic_side_effects.rs
index 6741e148547..c9c0f8be653 100644
--- a/tests/ui/arithmetic_side_effects.rs
+++ b/tests/ui/arithmetic_side_effects.rs
@@ -12,6 +12,31 @@
 
 use core::num::{Saturating, Wrapping};
 
+pub struct Custom;
+
+macro_rules! impl_arith {
+    ( $( $_trait:ident, $ty:ty, $method:ident; )* ) => {
+        $(
+            impl core::ops::$_trait<$ty> for Custom {
+                type Output = Self;
+                fn $method(self, _: $ty) -> Self::Output { Self }
+            }
+        )*
+    }
+}
+
+impl_arith!(
+    Add, i32, add;
+    Div, i32, div;
+    Mul, i32, mul;
+    Sub, i32, sub;
+
+    Add, f64, add;
+    Div, f64, div;
+    Mul, f64, mul;
+    Sub, f64, sub;
+);
+
 pub fn association_with_structures_should_not_trigger_the_lint() {
     enum Foo {
         Bar = -2,
@@ -130,7 +155,7 @@ pub fn non_overflowing_ops_or_ops_already_handled_by_the_compiler_should_not_tri
     _n = -(-1);
 }
 
-pub fn overflowing_runtime_ops() {
+pub fn runtime_ops() {
     let mut _n = i32::MAX;
 
     // Assign
@@ -163,6 +188,32 @@ pub fn overflowing_runtime_ops() {
     _n = 2 * _n;
     _n = &2 * _n;
 
+    // Custom
+    let _ = Custom + 0;
+    let _ = Custom + 1;
+    let _ = Custom + 2;
+    let _ = Custom + 0.0;
+    let _ = Custom + 1.0;
+    let _ = Custom + 2.0;
+    let _ = Custom - 0;
+    let _ = Custom - 1;
+    let _ = Custom - 2;
+    let _ = Custom - 0.0;
+    let _ = Custom - 1.0;
+    let _ = Custom - 2.0;
+    let _ = Custom / 0;
+    let _ = Custom / 1;
+    let _ = Custom / 2;
+    let _ = Custom / 0.0;
+    let _ = Custom / 1.0;
+    let _ = Custom / 2.0;
+    let _ = Custom * 0;
+    let _ = Custom * 1;
+    let _ = Custom * 2;
+    let _ = Custom * 0.0;
+    let _ = Custom * 1.0;
+    let _ = Custom * 2.0;
+
     // Unary
     _n = -_n;
     _n = -&_n;
diff --git a/tests/ui/arithmetic_side_effects.stderr b/tests/ui/arithmetic_side_effects.stderr
index 4dce13b624b..7870c942e7d 100644
--- a/tests/ui/arithmetic_side_effects.stderr
+++ b/tests/ui/arithmetic_side_effects.stderr
@@ -1,5 +1,5 @@
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:137:5
+  --> $DIR/arithmetic_side_effects.rs:162:5
    |
 LL |     _n += 1;
    |     ^^^^^^^
@@ -7,166 +7,310 @@ LL |     _n += 1;
    = note: `-D clippy::arithmetic-side-effects` implied by `-D warnings`
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:138:5
+  --> $DIR/arithmetic_side_effects.rs:163:5
    |
 LL |     _n += &1;
    |     ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:139:5
+  --> $DIR/arithmetic_side_effects.rs:164:5
    |
 LL |     _n -= 1;
    |     ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:140:5
+  --> $DIR/arithmetic_side_effects.rs:165:5
    |
 LL |     _n -= &1;
    |     ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:141:5
+  --> $DIR/arithmetic_side_effects.rs:166:5
    |
 LL |     _n /= 0;
    |     ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:142:5
+  --> $DIR/arithmetic_side_effects.rs:167:5
    |
 LL |     _n /= &0;
    |     ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:143:5
+  --> $DIR/arithmetic_side_effects.rs:168:5
    |
 LL |     _n %= 0;
    |     ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:144:5
+  --> $DIR/arithmetic_side_effects.rs:169:5
    |
 LL |     _n %= &0;
    |     ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:145:5
+  --> $DIR/arithmetic_side_effects.rs:170:5
    |
 LL |     _n *= 2;
    |     ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:146:5
+  --> $DIR/arithmetic_side_effects.rs:171:5
    |
 LL |     _n *= &2;
    |     ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:149:10
+  --> $DIR/arithmetic_side_effects.rs:174:10
    |
 LL |     _n = _n + 1;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:150:10
+  --> $DIR/arithmetic_side_effects.rs:175:10
    |
 LL |     _n = _n + &1;
    |          ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:151:10
+  --> $DIR/arithmetic_side_effects.rs:176:10
    |
 LL |     _n = 1 + _n;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:152:10
+  --> $DIR/arithmetic_side_effects.rs:177:10
    |
 LL |     _n = &1 + _n;
    |          ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:153:10
+  --> $DIR/arithmetic_side_effects.rs:178:10
    |
 LL |     _n = _n - 1;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:154:10
+  --> $DIR/arithmetic_side_effects.rs:179:10
    |
 LL |     _n = _n - &1;
    |          ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:155:10
+  --> $DIR/arithmetic_side_effects.rs:180:10
    |
 LL |     _n = 1 - _n;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:156:10
+  --> $DIR/arithmetic_side_effects.rs:181:10
    |
 LL |     _n = &1 - _n;
    |          ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:157:10
+  --> $DIR/arithmetic_side_effects.rs:182:10
    |
 LL |     _n = _n / 0;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:158:10
+  --> $DIR/arithmetic_side_effects.rs:183:10
    |
 LL |     _n = _n / &0;
    |          ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:159:10
+  --> $DIR/arithmetic_side_effects.rs:184:10
    |
 LL |     _n = _n % 0;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:160:10
+  --> $DIR/arithmetic_side_effects.rs:185:10
    |
 LL |     _n = _n % &0;
    |          ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:161:10
+  --> $DIR/arithmetic_side_effects.rs:186:10
    |
 LL |     _n = _n * 2;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:162:10
+  --> $DIR/arithmetic_side_effects.rs:187:10
    |
 LL |     _n = _n * &2;
    |          ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:163:10
+  --> $DIR/arithmetic_side_effects.rs:188:10
    |
 LL |     _n = 2 * _n;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:164:10
+  --> $DIR/arithmetic_side_effects.rs:189:10
    |
 LL |     _n = &2 * _n;
    |          ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:167:10
+  --> $DIR/arithmetic_side_effects.rs:192:13
+   |
+LL |     let _ = Custom + 0;
+   |             ^^^^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:193:13
+   |
+LL |     let _ = Custom + 1;
+   |             ^^^^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:194:13
+   |
+LL |     let _ = Custom + 2;
+   |             ^^^^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:195:13
+   |
+LL |     let _ = Custom + 0.0;
+   |             ^^^^^^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:196:13
+   |
+LL |     let _ = Custom + 1.0;
+   |             ^^^^^^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:197:13
+   |
+LL |     let _ = Custom + 2.0;
+   |             ^^^^^^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:198:13
+   |
+LL |     let _ = Custom - 0;
+   |             ^^^^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:199:13
+   |
+LL |     let _ = Custom - 1;
+   |             ^^^^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:200:13
+   |
+LL |     let _ = Custom - 2;
+   |             ^^^^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:201:13
+   |
+LL |     let _ = Custom - 0.0;
+   |             ^^^^^^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:202:13
+   |
+LL |     let _ = Custom - 1.0;
+   |             ^^^^^^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:203:13
+   |
+LL |     let _ = Custom - 2.0;
+   |             ^^^^^^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:204:13
+   |
+LL |     let _ = Custom / 0;
+   |             ^^^^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:205:13
+   |
+LL |     let _ = Custom / 1;
+   |             ^^^^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:206:13
+   |
+LL |     let _ = Custom / 2;
+   |             ^^^^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:207:13
+   |
+LL |     let _ = Custom / 0.0;
+   |             ^^^^^^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:208:13
+   |
+LL |     let _ = Custom / 1.0;
+   |             ^^^^^^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:209:13
+   |
+LL |     let _ = Custom / 2.0;
+   |             ^^^^^^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:210:13
+   |
+LL |     let _ = Custom * 0;
+   |             ^^^^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:211:13
+   |
+LL |     let _ = Custom * 1;
+   |             ^^^^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:212:13
+   |
+LL |     let _ = Custom * 2;
+   |             ^^^^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:213:13
+   |
+LL |     let _ = Custom * 0.0;
+   |             ^^^^^^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:214:13
+   |
+LL |     let _ = Custom * 1.0;
+   |             ^^^^^^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:215:13
+   |
+LL |     let _ = Custom * 2.0;
+   |             ^^^^^^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:218:10
    |
 LL |     _n = -_n;
    |          ^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:168:10
+  --> $DIR/arithmetic_side_effects.rs:219:10
    |
 LL |     _n = -&_n;
    |          ^^^^
 
-error: aborting due to 28 previous errors
+error: aborting due to 52 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 3757a0e903b781fe77092e166210c2089594c929 Mon Sep 17 00:00:00 2001
From: Andre Bogus <bogusandre@gmail.com>
Date: Sat, 1 Oct 2022 11:57:34 +0200
Subject: avoid doc-link-with-quotes in code blocks

---
 clippy_lints/src/doc.rs                   | 70 ++++++++++++++++++++++++-------
 clippy_lints/src/doc_link_with_quotes.rs  | 60 --------------------------
 clippy_lints/src/lib.register_lints.rs    |  2 +-
 clippy_lints/src/lib.register_pedantic.rs |  2 +-
 clippy_lints/src/lib.rs                   |  2 -
 tests/ui/doc_link_with_quotes.rs          |  7 +++-
 tests/ui/doc_link_with_quotes.stderr      |  6 +--
 7 files changed, 67 insertions(+), 82 deletions(-)
 delete mode 100644 clippy_lints/src/doc_link_with_quotes.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/doc.rs b/clippy_lints/src/doc.rs
index fd143a9d77c..36dc7e3396b 100644
--- a/clippy_lints/src/doc.rs
+++ b/clippy_lints/src/doc.rs
@@ -198,6 +198,29 @@ declare_clippy_lint! {
     "presence of `fn main() {` in code examples"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Detects the syntax `['foo']` in documentation comments (notice quotes instead of backticks)
+    /// outside of code blocks
+    /// ### Why is this bad?
+    /// It is likely a typo when defining an intra-doc link
+    ///
+    /// ### Example
+    /// ```rust
+    /// /// See also: ['foo']
+    /// fn bar() {}
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// /// See also: [`foo`]
+    /// fn bar() {}
+    /// ```
+    #[clippy::version = "1.63.0"]
+    pub DOC_LINK_WITH_QUOTES,
+    pedantic,
+    "possible typo for an intra-doc link"
+}
+
 #[expect(clippy::module_name_repetitions)]
 #[derive(Clone)]
 pub struct DocMarkdown {
@@ -214,9 +237,14 @@ impl DocMarkdown {
     }
 }
 
-impl_lint_pass!(DocMarkdown =>
-    [DOC_MARKDOWN, MISSING_SAFETY_DOC, MISSING_ERRORS_DOC, MISSING_PANICS_DOC, NEEDLESS_DOCTEST_MAIN]
-);
+impl_lint_pass!(DocMarkdown => [
+    DOC_LINK_WITH_QUOTES,
+    DOC_MARKDOWN,
+    MISSING_SAFETY_DOC,
+    MISSING_ERRORS_DOC,
+    MISSING_PANICS_DOC,
+    NEEDLESS_DOCTEST_MAIN
+]);
 
 impl<'tcx> LateLintPass<'tcx> for DocMarkdown {
     fn check_crate(&mut self, cx: &LateContext<'tcx>) {
@@ -432,7 +460,7 @@ pub fn strip_doc_comment_decoration(doc: &str, comment_kind: CommentKind, span:
     (no_stars, sizes)
 }
 
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, Default)]
 struct DocHeaders {
     safety: bool,
     errors: bool,
@@ -476,11 +504,7 @@ fn check_attrs<'a>(cx: &LateContext<'_>, valid_idents: &FxHashSet<String>, attrs
     }
 
     if doc.is_empty() {
-        return DocHeaders {
-            safety: false,
-            errors: false,
-            panics: false,
-        };
+        return DocHeaders::default();
     }
 
     let mut cb = fake_broken_link_callback;
@@ -521,11 +545,7 @@ fn check_doc<'a, Events: Iterator<Item = (pulldown_cmark::Event<'a>, Range<usize
     use pulldown_cmark::Tag::{CodeBlock, Heading, Item, Link, Paragraph};
     use pulldown_cmark::{CodeBlockKind, CowStr};
 
-    let mut headers = DocHeaders {
-        safety: false,
-        errors: false,
-        panics: false,
-    };
+    let mut headers = DocHeaders::default();
     let mut in_code = false;
     let mut in_link = None;
     let mut in_heading = false;
@@ -612,6 +632,7 @@ fn check_doc<'a, Events: Iterator<Item = (pulldown_cmark::Event<'a>, Range<usize
                         check_code(cx, &text, edition, span);
                     }
                 } else {
+                    check_link_quotes(cx, in_link.is_some(), trimmed_text, span, &range, begin, text.len());
                     // Adjust for the beginning of the current `Event`
                     let span = span.with_lo(span.lo() + BytePos::from_usize(range.start - begin));
                     text_to_check.push((text, span));
@@ -622,6 +643,27 @@ fn check_doc<'a, Events: Iterator<Item = (pulldown_cmark::Event<'a>, Range<usize
     headers
 }
 
+fn check_link_quotes(
+    cx: &LateContext<'_>,
+    in_link: bool,
+    trimmed_text: &str,
+    span: Span,
+    range: &Range<usize>,
+    begin: usize,
+    text_len: usize,
+) {
+    if in_link && trimmed_text.starts_with('\'') && trimmed_text.ends_with('\'') {
+        // fix the span to only point at the text within the link
+        let lo = span.lo() + BytePos::from_usize(range.start - begin);
+        span_lint(
+            cx,
+            DOC_LINK_WITH_QUOTES,
+            span.with_lo(lo).with_hi(lo + BytePos::from_usize(text_len)),
+            "possible intra-doc link using quotes instead of backticks",
+        );
+    }
+}
+
 fn get_current_span(spans: &[(usize, Span)], idx: usize) -> (usize, Span) {
     let index = match spans.binary_search_by(|c| c.0.cmp(&idx)) {
         Ok(o) => o,
diff --git a/clippy_lints/src/doc_link_with_quotes.rs b/clippy_lints/src/doc_link_with_quotes.rs
deleted file mode 100644
index 0ff1d2755da..00000000000
--- a/clippy_lints/src/doc_link_with_quotes.rs
+++ /dev/null
@@ -1,60 +0,0 @@
-use clippy_utils::diagnostics::span_lint;
-use itertools::Itertools;
-use rustc_ast::{AttrKind, Attribute};
-use rustc_lint::{EarlyContext, EarlyLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Detects the syntax `['foo']` in documentation comments (notice quotes instead of backticks)
-    /// outside of code blocks
-    /// ### Why is this bad?
-    /// It is likely a typo when defining an intra-doc link
-    ///
-    /// ### Example
-    /// ```rust
-    /// /// See also: ['foo']
-    /// fn bar() {}
-    /// ```
-    /// Use instead:
-    /// ```rust
-    /// /// See also: [`foo`]
-    /// fn bar() {}
-    /// ```
-    #[clippy::version = "1.63.0"]
-    pub DOC_LINK_WITH_QUOTES,
-    pedantic,
-    "possible typo for an intra-doc link"
-}
-declare_lint_pass!(DocLinkWithQuotes => [DOC_LINK_WITH_QUOTES]);
-
-impl EarlyLintPass for DocLinkWithQuotes {
-    fn check_attribute(&mut self, ctx: &EarlyContext<'_>, attr: &Attribute) {
-        if let AttrKind::DocComment(_, symbol) = attr.kind {
-            if contains_quote_link(symbol.as_str()) {
-                span_lint(
-                    ctx,
-                    DOC_LINK_WITH_QUOTES,
-                    attr.span,
-                    "possible intra-doc link using quotes instead of backticks",
-                );
-            }
-        }
-    }
-}
-
-fn contains_quote_link(s: &str) -> bool {
-    let mut in_backticks = false;
-    let mut found_opening = false;
-
-    for c in s.chars().tuple_windows::<(char, char)>() {
-        match c {
-            ('`', _) => in_backticks = !in_backticks,
-            ('[', '\'') if !in_backticks => found_opening = true,
-            ('\'', ']') if !in_backticks && found_opening => return true,
-            _ => {},
-        }
-    }
-
-    false
-}
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index ee08d802ccf..0d850f1d924 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -118,12 +118,12 @@ store.register_lints(&[
     disallowed_names::DISALLOWED_NAMES,
     disallowed_script_idents::DISALLOWED_SCRIPT_IDENTS,
     disallowed_types::DISALLOWED_TYPES,
+    doc::DOC_LINK_WITH_QUOTES,
     doc::DOC_MARKDOWN,
     doc::MISSING_ERRORS_DOC,
     doc::MISSING_PANICS_DOC,
     doc::MISSING_SAFETY_DOC,
     doc::NEEDLESS_DOCTEST_MAIN,
-    doc_link_with_quotes::DOC_LINK_WITH_QUOTES,
     double_parens::DOUBLE_PARENS,
     drop_forget_ref::DROP_COPY,
     drop_forget_ref::DROP_NON_DROP,
diff --git a/clippy_lints/src/lib.register_pedantic.rs b/clippy_lints/src/lib.register_pedantic.rs
index 4eaabfbcc5f..dd3e2b7d29c 100644
--- a/clippy_lints/src/lib.register_pedantic.rs
+++ b/clippy_lints/src/lib.register_pedantic.rs
@@ -20,10 +20,10 @@ store.register_group(true, "clippy::pedantic", Some("clippy_pedantic"), vec![
     LintId::of(dereference::REF_BINDING_TO_REFERENCE),
     LintId::of(derive::EXPL_IMPL_CLONE_ON_COPY),
     LintId::of(derive::UNSAFE_DERIVE_DESERIALIZE),
+    LintId::of(doc::DOC_LINK_WITH_QUOTES),
     LintId::of(doc::DOC_MARKDOWN),
     LintId::of(doc::MISSING_ERRORS_DOC),
     LintId::of(doc::MISSING_PANICS_DOC),
-    LintId::of(doc_link_with_quotes::DOC_LINK_WITH_QUOTES),
     LintId::of(empty_enum::EMPTY_ENUM),
     LintId::of(enum_variants::MODULE_NAME_REPETITIONS),
     LintId::of(eta_reduction::REDUNDANT_CLOSURE_FOR_METHOD_CALLS),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index fde8aa9f921..c5f0fd5fe5e 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -204,7 +204,6 @@ mod disallowed_names;
 mod disallowed_script_idents;
 mod disallowed_types;
 mod doc;
-mod doc_link_with_quotes;
 mod double_parens;
 mod drop_forget_ref;
 mod duplicate_mod;
@@ -864,7 +863,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_early_pass(|| Box::new(single_char_lifetime_names::SingleCharLifetimeNames));
     store.register_late_pass(move |_| Box::new(manual_bits::ManualBits::new(msrv)));
     store.register_late_pass(|_| Box::new(default_union_representation::DefaultUnionRepresentation));
-    store.register_early_pass(|| Box::new(doc_link_with_quotes::DocLinkWithQuotes));
     store.register_late_pass(|_| Box::<only_used_in_recursion::OnlyUsedInRecursion>::default());
     let allow_dbg_in_tests = conf.allow_dbg_in_tests;
     store.register_late_pass(move |_| Box::new(dbg_macro::DbgMacro::new(allow_dbg_in_tests)));
diff --git a/tests/ui/doc_link_with_quotes.rs b/tests/ui/doc_link_with_quotes.rs
index ab52fb1a4a6..17c04c34e24 100644
--- a/tests/ui/doc_link_with_quotes.rs
+++ b/tests/ui/doc_link_with_quotes.rs
@@ -4,9 +4,14 @@ fn main() {
     foo()
 }
 
-/// Calls ['bar']
+/// Calls ['bar'] uselessly
 pub fn foo() {
     bar()
 }
 
+/// # Examples
+/// This demonstrates issue \#8961
+/// ```
+/// let _ = vec!['w', 'a', 't'];
+/// ```
 pub fn bar() {}
diff --git a/tests/ui/doc_link_with_quotes.stderr b/tests/ui/doc_link_with_quotes.stderr
index bf6d57d8afe..ea730e667d6 100644
--- a/tests/ui/doc_link_with_quotes.stderr
+++ b/tests/ui/doc_link_with_quotes.stderr
@@ -1,8 +1,8 @@
 error: possible intra-doc link using quotes instead of backticks
-  --> $DIR/doc_link_with_quotes.rs:7:1
+  --> $DIR/doc_link_with_quotes.rs:7:12
    |
-LL | /// Calls ['bar']
-   | ^^^^^^^^^^^^^^^^^
+LL | /// Calls ['bar'] uselessly
+   |            ^^^^^
    |
    = note: `-D clippy::doc-link-with-quotes` implied by `-D warnings`
 
-- 
cgit 1.4.1-3-g733a5


From eef5d477b59a3b68bca9c1f3a5334229fc0ad9b6 Mon Sep 17 00:00:00 2001
From: Andre Bogus <bogusandre@gmail.com>
Date: Sat, 1 Oct 2022 17:55:22 +0200
Subject: use `is_integer_literal` more

---
 clippy_lints/src/bool_to_int_with_if.rs            | 21 ++---------
 clippy_lints/src/checked_conversions.rs            | 14 ++------
 clippy_lints/src/from_str_radix_10.rs              |  4 +--
 clippy_lints/src/implicit_saturating_sub.rs        | 18 +++-------
 clippy_lints/src/methods/get_last_with_len.rs      |  6 ++--
 clippy_lints/src/misc.rs                           |  6 ++--
 .../src/operators/arithmetic_side_effects.rs       | 28 ++++++---------
 clippy_lints/src/operators/numeric_arithmetic.rs   |  9 +++--
 clippy_lints/src/slow_vector_initialization.rs     | 12 +++----
 clippy_lints/src/transmute/transmuting_null.rs     | 41 ++++++++--------------
 clippy_lints/src/uninit_vec.rs                     | 15 ++------
 11 files changed, 52 insertions(+), 122 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/bool_to_int_with_if.rs b/clippy_lints/src/bool_to_int_with_if.rs
index 51e98cda845..001d74c2605 100644
--- a/clippy_lints/src/bool_to_int_with_if.rs
+++ b/clippy_lints/src/bool_to_int_with_if.rs
@@ -3,7 +3,7 @@ use rustc_hir::{Block, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
-use clippy_utils::{diagnostics::span_lint_and_then, is_else_clause, sugg::Sugg};
+use clippy_utils::{diagnostics::span_lint_and_then, is_else_clause, is_integer_literal, sugg::Sugg};
 use rustc_errors::Applicability;
 
 declare_clippy_lint! {
@@ -56,13 +56,9 @@ fn check_if_else<'tcx>(ctx: &LateContext<'tcx>, expr: &'tcx rustc_hir::Expr<'tcx
         && let Some(then_lit) = int_literal(then)
         && let Some(else_lit) = int_literal(else_)
     {
-        let inverted = if
-            check_int_literal_equals_val(then_lit, 1)
-            && check_int_literal_equals_val(else_lit, 0) {
+        let inverted = if is_integer_literal(then_lit, 1) && is_integer_literal(else_lit, 0) {
             false
-        } else if
-            check_int_literal_equals_val(then_lit, 0)
-            && check_int_literal_equals_val(else_lit, 1) {
+        } else if is_integer_literal(then_lit, 0) && is_integer_literal(else_lit, 1) {
             true
         } else {
             // Expression isn't boolean, exit
@@ -123,14 +119,3 @@ fn int_literal<'tcx>(expr: &'tcx rustc_hir::Expr<'tcx>) -> Option<&'tcx rustc_hi
         None
     }
 }
-
-fn check_int_literal_equals_val<'tcx>(expr: &'tcx rustc_hir::Expr<'tcx>, expected_value: u128) -> bool {
-    if let ExprKind::Lit(lit) = &expr.kind
-        && let LitKind::Int(val, _) = lit.node
-        && val == expected_value
-    {
-        true
-    } else {
-        false
-    }
-}
diff --git a/clippy_lints/src/checked_conversions.rs b/clippy_lints/src/checked_conversions.rs
index 1d113c7cbee..78e9921f036 100644
--- a/clippy_lints/src/checked_conversions.rs
+++ b/clippy_lints/src/checked_conversions.rs
@@ -2,9 +2,8 @@
 
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::{in_constant, meets_msrv, msrvs, SpanlessEq};
+use clippy_utils::{in_constant, is_integer_literal, meets_msrv, msrvs, SpanlessEq};
 use if_chain::if_chain;
-use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOp, BinOpKind, Expr, ExprKind, QPath, TyKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
@@ -223,16 +222,7 @@ fn check_lower_bound<'tcx>(expr: &'tcx Expr<'tcx>) -> Option<Conversion<'tcx>> {
 
 /// Check for `expr >= 0`
 fn check_lower_bound_zero<'a>(candidate: &'a Expr<'_>, check: &'a Expr<'_>) -> Option<Conversion<'a>> {
-    if_chain! {
-        if let ExprKind::Lit(ref lit) = &check.kind;
-        if let LitKind::Int(0, _) = &lit.node;
-
-        then {
-            Some(Conversion::new_any(candidate))
-        } else {
-            None
-        }
-    }
+    is_integer_literal(check, 0).then(|| Conversion::new_any(candidate))
 }
 
 /// Check for `expr >= (to_type::MIN as from_type)`
diff --git a/clippy_lints/src/from_str_radix_10.rs b/clippy_lints/src/from_str_radix_10.rs
index 2a82473be8c..cf8b7acd66d 100644
--- a/clippy_lints/src/from_str_radix_10.rs
+++ b/clippy_lints/src/from_str_radix_10.rs
@@ -1,4 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::is_integer_literal;
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
@@ -60,8 +61,7 @@ impl<'tcx> LateLintPass<'tcx> for FromStrRadix10 {
             if pathseg.ident.name.as_str() == "from_str_radix";
 
             // check if the second argument is a primitive `10`
-            if let ExprKind::Lit(lit) = &radix.kind;
-            if let rustc_ast::ast::LitKind::Int(10, _) = lit.node;
+            if is_integer_literal(radix, 10);
 
             then {
                 let expr = if let ExprKind::AddrOf(_, _, expr) = &src.kind {
diff --git a/clippy_lints/src/implicit_saturating_sub.rs b/clippy_lints/src/implicit_saturating_sub.rs
index f0dbe17d83a..48edbf6ae57 100644
--- a/clippy_lints/src/implicit_saturating_sub.rs
+++ b/clippy_lints/src/implicit_saturating_sub.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::{higher, peel_blocks_with_stmt, SpanlessEq};
+use clippy_utils::{higher, is_integer_literal, peel_blocks_with_stmt, SpanlessEq};
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
@@ -131,17 +131,8 @@ impl<'tcx> LateLintPass<'tcx> for ImplicitSaturatingSub {
 fn subtracts_one<'a>(cx: &LateContext<'_>, expr: &'a Expr<'a>) -> Option<&'a Expr<'a>> {
     match peel_blocks_with_stmt(expr).kind {
         ExprKind::AssignOp(ref op1, target, value) => {
-            if_chain! {
-                if BinOpKind::Sub == op1.node;
-                // Check if literal being subtracted is one
-                if let ExprKind::Lit(ref lit1) = value.kind;
-                if let LitKind::Int(1, _) = lit1.node;
-                then {
-                    Some(target)
-                } else {
-                    None
-                }
-            }
+            // Check if literal being subtracted is one
+            (BinOpKind::Sub == op1.node && is_integer_literal(value, 1)).then_some(target)
         },
         ExprKind::Assign(target, value, _) => {
             if_chain! {
@@ -150,8 +141,7 @@ fn subtracts_one<'a>(cx: &LateContext<'_>, expr: &'a Expr<'a>) -> Option<&'a Exp
 
                 if SpanlessEq::new(cx).eq_expr(left1, target);
 
-                if let ExprKind::Lit(ref lit1) = right1.kind;
-                if let LitKind::Int(1, _) = lit1.node;
+                if is_integer_literal(right1, 1);
                 then {
                     Some(target)
                 } else {
diff --git a/clippy_lints/src/methods/get_last_with_len.rs b/clippy_lints/src/methods/get_last_with_len.rs
index 02aada87202..3bdc154df04 100644
--- a/clippy_lints/src/methods/get_last_with_len.rs
+++ b/clippy_lints/src/methods/get_last_with_len.rs
@@ -1,7 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::SpanlessEq;
-use rustc_ast::LitKind;
+use clippy_utils::{is_integer_literal, SpanlessEq};
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::LateContext;
@@ -26,8 +25,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'_>, arg:
         && lhs_path.ident.name == sym::len
 
         // RHS of subtraction is 1
-        && let ExprKind::Lit(rhs_lit) = &rhs.kind
-        && let LitKind::Int(1, ..) = rhs_lit.node
+        && is_integer_literal(rhs, 1)
 
         // check that recv == lhs_recv `recv.get(lhs_recv.len() - 1)`
         && SpanlessEq::new(cx).eq_expr(recv, lhs_recv)
diff --git a/clippy_lints/src/misc.rs b/clippy_lints/src/misc.rs
index 381458b91e6..516dee20f8b 100644
--- a/clippy_lints/src/misc.rs
+++ b/clippy_lints/src/misc.rs
@@ -1,7 +1,6 @@
 use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg, span_lint_hir_and_then};
 use clippy_utils::source::{snippet, snippet_opt};
 use if_chain::if_chain;
-use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::{
@@ -15,7 +14,7 @@ use rustc_span::hygiene::DesugaringKind;
 use rustc_span::source_map::{ExpnKind, Span};
 
 use clippy_utils::sugg::Sugg;
-use clippy_utils::{get_parent_expr, in_constant, iter_input_pats, last_path_segment, SpanlessEq};
+use clippy_utils::{get_parent_expr, in_constant, is_integer_literal, iter_input_pats, last_path_segment, SpanlessEq};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -314,8 +313,7 @@ fn non_macro_local(cx: &LateContext<'_>, res: def::Res) -> bool {
 fn check_cast(cx: &LateContext<'_>, span: Span, e: &Expr<'_>, ty: &hir::Ty<'_>) {
     if_chain! {
         if let TyKind::Ptr(ref mut_ty) = ty.kind;
-        if let ExprKind::Lit(ref lit) = e.kind;
-        if let LitKind::Int(0, _) = lit.node;
+        if is_integer_literal(e, 0);
         if !in_constant(cx, e.hir_id);
         then {
             let (msg, sugg_fn) = match mut_ty.mutbl {
diff --git a/clippy_lints/src/operators/arithmetic_side_effects.rs b/clippy_lints/src/operators/arithmetic_side_effects.rs
index c8a374d90b5..1f22fbd5387 100644
--- a/clippy_lints/src/operators/arithmetic_side_effects.rs
+++ b/clippy_lints/src/operators/arithmetic_side_effects.rs
@@ -44,25 +44,19 @@ impl ArithmeticSideEffects {
     /// Assuming that `expr` is a literal integer, checks operators (+=, -=, *, /) in a
     /// non-constant environment that won't overflow.
     fn has_valid_op(op: &Spanned<hir::BinOpKind>, expr: &hir::Expr<'_>) -> bool {
-        if let hir::BinOpKind::Add | hir::BinOpKind::Sub = op.node
-            && let hir::ExprKind::Lit(ref lit) = expr.kind
-            && let ast::LitKind::Int(0, _) = lit.node
+        if let hir::ExprKind::Lit(ref lit) = expr.kind &&
+            let ast::LitKind::Int(value, _) = lit.node
         {
-            return true;
-        }
-        if let hir::BinOpKind::Div | hir::BinOpKind::Rem = op.node
-            && let hir::ExprKind::Lit(ref lit) = expr.kind
-            && !matches!(lit.node, ast::LitKind::Int(0, _))
-        {
-            return true;
-        }
-        if let hir::BinOpKind::Mul = op.node
-            && let hir::ExprKind::Lit(ref lit) = expr.kind
-            && let ast::LitKind::Int(0 | 1, _) = lit.node
-        {
-            return true;
+            match (&op.node, value) {
+                (hir::BinOpKind::Add | hir::BinOpKind::Sub, 0) |
+                (hir::BinOpKind::Mul, 0 | 1) => true,
+                (hir::BinOpKind::Div | hir::BinOpKind::Rem, 0) => false,
+                (hir::BinOpKind::Div | hir::BinOpKind::Rem, _) => true,
+                _ => false,
+            }
+        } else {
+            false
         }
-        false
     }
 
     /// Checks if the given `expr` has any of the inner `allowed` elements.
diff --git a/clippy_lints/src/operators/numeric_arithmetic.rs b/clippy_lints/src/operators/numeric_arithmetic.rs
index b6097710dc6..0830a106f55 100644
--- a/clippy_lints/src/operators/numeric_arithmetic.rs
+++ b/clippy_lints/src/operators/numeric_arithmetic.rs
@@ -1,5 +1,6 @@
 use clippy_utils::consts::constant_simple;
 use clippy_utils::diagnostics::span_lint;
+use clippy_utils::is_integer_literal;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
 use rustc_span::source_map::Span;
@@ -50,11 +51,9 @@ impl Context {
                 hir::BinOpKind::Div | hir::BinOpKind::Rem => match &r.kind {
                     hir::ExprKind::Lit(_lit) => (),
                     hir::ExprKind::Unary(hir::UnOp::Neg, expr) => {
-                        if let hir::ExprKind::Lit(lit) = &expr.kind {
-                            if let rustc_ast::ast::LitKind::Int(1, _) = lit.node {
-                                span_lint(cx, INTEGER_ARITHMETIC, expr.span, "integer arithmetic detected");
-                                self.expr_id = Some(expr.hir_id);
-                            }
+                        if is_integer_literal(expr, 1) {
+                            span_lint(cx, INTEGER_ARITHMETIC, expr.span, "integer arithmetic detected");
+                            self.expr_id = Some(expr.hir_id);
                         }
                     },
                     _ => {
diff --git a/clippy_lints/src/slow_vector_initialization.rs b/clippy_lints/src/slow_vector_initialization.rs
index e57ab8cd7a3..6e5d88e1b59 100644
--- a/clippy_lints/src/slow_vector_initialization.rs
+++ b/clippy_lints/src/slow_vector_initialization.rs
@@ -1,9 +1,10 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{get_enclosing_block, is_expr_path_def_path, path_to_local, path_to_local_id, paths, SpanlessEq};
+use clippy_utils::{
+    get_enclosing_block, is_expr_path_def_path, is_integer_literal, path_to_local, path_to_local_id, paths, SpanlessEq,
+};
 use if_chain::if_chain;
-use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_block, walk_expr, walk_stmt, Visitor};
 use rustc_hir::{BindingAnnotation, Block, Expr, ExprKind, HirId, PatKind, QPath, Stmt, StmtKind};
@@ -219,8 +220,7 @@ impl<'a, 'tcx> VectorInitializationVisitor<'a, 'tcx> {
             && path_to_local_id(self_arg, self.vec_alloc.local_id)
             && path.ident.name == sym!(resize)
             // Check that is filled with 0
-            && let ExprKind::Lit(ref lit) = fill_arg.kind
-            && let LitKind::Int(0, _) = lit.node {
+            && is_integer_literal(fill_arg, 0) {
                 // Check that len expression is equals to `with_capacity` expression
                 if SpanlessEq::new(self.cx).eq_expr(len_arg, self.vec_alloc.len_expr) {
                     self.slow_expression = Some(InitializationType::Resize(expr));
@@ -255,9 +255,7 @@ impl<'a, 'tcx> VectorInitializationVisitor<'a, 'tcx> {
         if_chain! {
             if let ExprKind::Call(fn_expr, [repeat_arg]) = expr.kind;
             if is_expr_path_def_path(self.cx, fn_expr, &paths::ITER_REPEAT);
-            if let ExprKind::Lit(ref lit) = repeat_arg.kind;
-            if let LitKind::Int(0, _) = lit.node;
-
+            if is_integer_literal(repeat_arg, 0);
             then {
                 true
             } else {
diff --git a/clippy_lints/src/transmute/transmuting_null.rs b/clippy_lints/src/transmute/transmuting_null.rs
index d8e349af7af..19ce5ae72c2 100644
--- a/clippy_lints/src/transmute/transmuting_null.rs
+++ b/clippy_lints/src/transmute/transmuting_null.rs
@@ -1,8 +1,6 @@
 use clippy_utils::consts::{constant_context, Constant};
 use clippy_utils::diagnostics::span_lint;
-use clippy_utils::is_path_diagnostic_item;
-use if_chain::if_chain;
-use rustc_ast::LitKind;
+use clippy_utils::{is_integer_literal, is_path_diagnostic_item};
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::LateContext;
 use rustc_middle::ty::Ty;
@@ -19,37 +17,28 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, arg: &'t
 
     // Catching transmute over constants that resolve to `null`.
     let mut const_eval_context = constant_context(cx, cx.typeck_results());
-    if_chain! {
-        if let ExprKind::Path(ref _qpath) = arg.kind;
-        if let Some(Constant::RawPtr(x)) = const_eval_context.expr(arg);
-        if x == 0;
-        then {
-            span_lint(cx, TRANSMUTING_NULL, expr.span, LINT_MSG);
-            return true;
-        }
+    if let ExprKind::Path(ref _qpath) = arg.kind &&
+        let Some(Constant::RawPtr(x)) = const_eval_context.expr(arg) &&
+        x == 0
+    {
+        span_lint(cx, TRANSMUTING_NULL, expr.span, LINT_MSG);
+        return true;
     }
 
     // Catching:
     // `std::mem::transmute(0 as *const i32)`
-    if_chain! {
-        if let ExprKind::Cast(inner_expr, _cast_ty) = arg.kind;
-        if let ExprKind::Lit(ref lit) = inner_expr.kind;
-        if let LitKind::Int(0, _) = lit.node;
-        then {
-            span_lint(cx, TRANSMUTING_NULL, expr.span, LINT_MSG);
-            return true;
-        }
+    if let ExprKind::Cast(inner_expr, _cast_ty) = arg.kind && is_integer_literal(inner_expr, 0) {
+        span_lint(cx, TRANSMUTING_NULL, expr.span, LINT_MSG);
+        return true;
     }
 
     // Catching:
     // `std::mem::transmute(std::ptr::null::<i32>())`
-    if_chain! {
-        if let ExprKind::Call(func1, []) = arg.kind;
-        if is_path_diagnostic_item(cx, func1, sym::ptr_null);
-        then {
-            span_lint(cx, TRANSMUTING_NULL, expr.span, LINT_MSG);
-            return true;
-        }
+    if let ExprKind::Call(func1, []) = arg.kind &&
+        is_path_diagnostic_item(cx, func1, sym::ptr_null)
+    {
+        span_lint(cx, TRANSMUTING_NULL, expr.span, LINT_MSG);
+        return true;
     }
 
     // FIXME:
diff --git a/clippy_lints/src/uninit_vec.rs b/clippy_lints/src/uninit_vec.rs
index bde7c318f44..1ab0162a881 100644
--- a/clippy_lints/src/uninit_vec.rs
+++ b/clippy_lints/src/uninit_vec.rs
@@ -1,8 +1,7 @@
 use clippy_utils::diagnostics::{span_lint, span_lint_and_then};
 use clippy_utils::higher::{get_vec_init_kind, VecInitKind};
 use clippy_utils::ty::{is_type_diagnostic_item, is_uninit_value_valid_for_ty};
-use clippy_utils::{is_lint_allowed, path_to_local_id, peel_hir_expr_while, SpanlessEq};
-use rustc_ast::ast::LitKind;
+use clippy_utils::{is_integer_literal, is_lint_allowed, path_to_local_id, peel_hir_expr_while, SpanlessEq};
 use rustc_hir::{Block, Expr, ExprKind, HirId, PatKind, PathSegment, Stmt, StmtKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::lint::in_external_macro;
@@ -216,7 +215,7 @@ fn extract_set_len_self<'tcx>(cx: &LateContext<'_>, expr: &'tcx Expr<'_>) -> Opt
             let self_type = cx.typeck_results().expr_ty(self_expr).peel_refs();
             if is_type_diagnostic_item(cx, self_type, sym::Vec)
                 && path.ident.name.as_str() == "set_len"
-                && !is_literal_zero(arg)
+                && !is_integer_literal(arg, 0)
             {
                 Some((self_expr, expr.span))
             } else {
@@ -226,13 +225,3 @@ fn extract_set_len_self<'tcx>(cx: &LateContext<'_>, expr: &'tcx Expr<'_>) -> Opt
         _ => None,
     }
 }
-
-fn is_literal_zero(arg: &Expr<'_>) -> bool {
-    if let ExprKind::Lit(lit) = &arg.kind
-        && let LitKind::Int(0, _) = lit.node
-    {
-        true
-    } else {
-        false
-    }
-}
-- 
cgit 1.4.1-3-g733a5


From b91dc035106f4c203d67d2a0db0077c7a887224b Mon Sep 17 00:00:00 2001
From: Nilstrieb <48135649+Nilstrieb@users.noreply.github.com>
Date: Sat, 1 Oct 2022 18:59:17 +0200
Subject: Add `as_ptr_cast_mut` lint

This lint detects calls to a `&self`-taking `as_ptr` method, where
the result is then immediately cast to a `*mut T`. Code like this
is probably invalid, as that pointer will not have write permissions,
and `*mut T` is usually used to write through.
---
 CHANGELOG.md                              |  1 +
 clippy_lints/src/casts/as_ptr_cast_mut.rs | 38 +++++++++++++++++++++++++++++++
 clippy_lints/src/casts/mod.rs             | 31 ++++++++++++++++++++++++-
 clippy_lints/src/lib.register_lints.rs    |  1 +
 clippy_lints/src/lib.register_nursery.rs  |  1 +
 src/docs.rs                               |  1 +
 src/docs/as_ptr_cast_mut.txt              | 19 ++++++++++++++++
 tests/ui/as_ptr_cast_mut.rs               | 37 ++++++++++++++++++++++++++++++
 tests/ui/as_ptr_cast_mut.stderr           | 16 +++++++++++++
 9 files changed, 144 insertions(+), 1 deletion(-)
 create mode 100644 clippy_lints/src/casts/as_ptr_cast_mut.rs
 create mode 100644 src/docs/as_ptr_cast_mut.txt
 create mode 100644 tests/ui/as_ptr_cast_mut.rs
 create mode 100644 tests/ui/as_ptr_cast_mut.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index ef6140152ff..754d5f506d4 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3735,6 +3735,7 @@ Released 2018-09-13
 [`approx_constant`]: https://rust-lang.github.io/rust-clippy/master/index.html#approx_constant
 [`arithmetic_side_effects`]: https://rust-lang.github.io/rust-clippy/master/index.html#arithmetic_side_effects
 [`as_conversions`]: https://rust-lang.github.io/rust-clippy/master/index.html#as_conversions
+[`as_ptr_cast_mut`]: https://rust-lang.github.io/rust-clippy/master/index.html#as_ptr_cast_mut
 [`as_underscore`]: https://rust-lang.github.io/rust-clippy/master/index.html#as_underscore
 [`assertions_on_constants`]: https://rust-lang.github.io/rust-clippy/master/index.html#assertions_on_constants
 [`assertions_on_result_states`]: https://rust-lang.github.io/rust-clippy/master/index.html#assertions_on_result_states
diff --git a/clippy_lints/src/casts/as_ptr_cast_mut.rs b/clippy_lints/src/casts/as_ptr_cast_mut.rs
new file mode 100644
index 00000000000..9409f4844f5
--- /dev/null
+++ b/clippy_lints/src/casts/as_ptr_cast_mut.rs
@@ -0,0 +1,38 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet_opt;
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind};
+use rustc_lint::LateContext;
+use rustc_middle::{
+    mir::Mutability,
+    ty::{self, Ty, TypeAndMut},
+};
+
+use super::AS_PTR_CAST_MUT;
+
+pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_expr: &Expr<'_>, cast_to: Ty<'_>) {
+    if let ty::RawPtr(ptrty @ TypeAndMut { mutbl: Mutability::Mut, .. }) = cast_to.kind()
+        && let ty::RawPtr(TypeAndMut { mutbl: Mutability::Not, .. }) =
+            cx.typeck_results().node_type(cast_expr.hir_id).kind()
+        && let ExprKind::MethodCall(method_name, receiver, [], _) = cast_expr.peel_blocks().kind
+        && method_name.ident.name == rustc_span::sym::as_ptr
+        && let Some(as_ptr_did) = cx.typeck_results().type_dependent_def_id(cast_expr.peel_blocks().hir_id)
+        && let as_ptr_sig = cx.tcx.fn_sig(as_ptr_did)
+        && let Some(first_param_ty) = as_ptr_sig.skip_binder().inputs().iter().next()
+        && let ty::Ref(_, _, Mutability::Not) = first_param_ty.kind()
+        && let Some(recv) = snippet_opt(cx, receiver.span)
+    {
+        // `as_mut_ptr` might not exist
+        let applicability = Applicability::MaybeIncorrect;
+
+        span_lint_and_sugg(
+            cx,
+            AS_PTR_CAST_MUT,
+            expr.span,
+            &format!("casting the result of `as_ptr` to *{ptrty}"),
+            "replace with",
+            format!("{recv}.as_mut_ptr()"),
+            applicability
+        );
+    }
+}
diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index cc5d346b954..fb0bd4d30f7 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -1,3 +1,4 @@
+mod as_ptr_cast_mut;
 mod as_underscore;
 mod borrow_as_ptr;
 mod cast_abs_to_unsigned;
@@ -596,6 +597,32 @@ declare_clippy_lint! {
     "casting a slice created from a pointer and length to a slice pointer"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for the result of a `&self`-taking `as_ptr` being cast to a mutable pointer
+    ///
+    /// ### Why is this bad?
+    /// Since `as_ptr` took a `&self`, the pointer won't have write permissions, making it
+    /// unlikely that having it as a mutable pointer is correct.
+    ///
+    /// ### Example
+    /// ```rust
+    /// let string = String::with_capacity(1);
+    /// let ptr = string.as_ptr() as *mut _;
+    /// unsafe { ptr.write(4) }; // UNDEFINED BEHAVIOUR
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// let mut string = String::with_capacity(1);
+    /// let string = string.as_mut_ptr();
+    /// unsafe { ptr.write(4) };
+    /// ```
+    #[clippy::version = "1.66.0"]
+    pub AS_PTR_CAST_MUT,
+    nursery,
+    "casting the result of the `&self`-taking as_ptr to a mutabe point"
+}
+
 pub struct Casts {
     msrv: Option<RustcVersion>,
 }
@@ -627,7 +654,8 @@ impl_lint_pass!(Casts => [
     CAST_ABS_TO_UNSIGNED,
     AS_UNDERSCORE,
     BORROW_AS_PTR,
-    CAST_SLICE_FROM_RAW_PARTS
+    CAST_SLICE_FROM_RAW_PARTS,
+    AS_PTR_CAST_MUT,
 ]);
 
 impl<'tcx> LateLintPass<'tcx> for Casts {
@@ -653,6 +681,7 @@ impl<'tcx> LateLintPass<'tcx> for Casts {
                 return;
             }
             cast_slice_from_raw_parts::check(cx, expr, cast_expr, cast_to, self.msrv);
+            as_ptr_cast_mut::check(cx, expr, cast_expr, cast_to);
             fn_to_numeric_cast_any::check(cx, expr, cast_expr, cast_from, cast_to);
             fn_to_numeric_cast::check(cx, expr, cast_expr, cast_from, cast_to);
             fn_to_numeric_cast_with_truncation::check(cx, expr, cast_expr, cast_from, cast_to);
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index ee08d802ccf..2c849701365 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -66,6 +66,7 @@ store.register_lints(&[
     cargo::NEGATIVE_FEATURE_NAMES,
     cargo::REDUNDANT_FEATURE_NAMES,
     cargo::WILDCARD_DEPENDENCIES,
+    casts::AS_PTR_CAST_MUT,
     casts::AS_UNDERSCORE,
     casts::BORROW_AS_PTR,
     casts::CAST_ABS_TO_UNSIGNED,
diff --git a/clippy_lints/src/lib.register_nursery.rs b/clippy_lints/src/lib.register_nursery.rs
index 87be0052028..a75bc81b222 100644
--- a/clippy_lints/src/lib.register_nursery.rs
+++ b/clippy_lints/src/lib.register_nursery.rs
@@ -4,6 +4,7 @@
 
 store.register_group(true, "clippy::nursery", Some("clippy_nursery"), vec![
     LintId::of(attrs::EMPTY_LINE_AFTER_OUTER_ATTR),
+    LintId::of(casts::AS_PTR_CAST_MUT),
     LintId::of(cognitive_complexity::COGNITIVE_COMPLEXITY),
     LintId::of(copies::BRANCHES_SHARING_CODE),
     LintId::of(derive::DERIVE_PARTIAL_EQ_WITHOUT_EQ),
diff --git a/src/docs.rs b/src/docs.rs
index 166be0618ff..c3cbd2942d8 100644
--- a/src/docs.rs
+++ b/src/docs.rs
@@ -28,6 +28,7 @@ docs! {
     "approx_constant",
     "arithmetic_side_effects",
     "as_conversions",
+    "as_ptr_cast_mut",
     "as_underscore",
     "assertions_on_constants",
     "assertions_on_result_states",
diff --git a/src/docs/as_ptr_cast_mut.txt b/src/docs/as_ptr_cast_mut.txt
new file mode 100644
index 00000000000..0192a0b686f
--- /dev/null
+++ b/src/docs/as_ptr_cast_mut.txt
@@ -0,0 +1,19 @@
+### What it does
+Checks for the result of a `&self`-taking `as_ptr` being cast to a mutable pointer
+
+### Why is this bad?
+Since `as_ptr` took a `&self`, the pointer won't have write permissions, making it
+unlikely that having it as a mutable pointer is correct.
+
+### Example
+```
+let string = String::with_capacity(1);
+let ptr = string.as_ptr() as *mut _;
+unsafe { ptr.write(4) }; // UNDEFINED BEHAVIOUR
+```
+Use instead:
+```
+let mut string = String::with_capacity(1);
+let string = string.as_mut_ptr();
+unsafe { ptr.write(4) };
+```
\ No newline at end of file
diff --git a/tests/ui/as_ptr_cast_mut.rs b/tests/ui/as_ptr_cast_mut.rs
new file mode 100644
index 00000000000..0d1d9258433
--- /dev/null
+++ b/tests/ui/as_ptr_cast_mut.rs
@@ -0,0 +1,37 @@
+#![allow(unused)]
+#![warn(clippy::as_ptr_cast_mut)]
+#![allow(clippy::wrong_self_convention)]
+
+struct MutPtrWrapper(Vec<u8>);
+impl MutPtrWrapper {
+    fn as_ptr(&mut self) -> *const u8 {
+        self.0.as_mut_ptr() as *const u8
+    }
+}
+
+struct Covariant<T>(*const T);
+impl<T> Covariant<T> {
+    fn as_ptr(self) -> *const T {
+        self.0
+    }
+}
+
+fn main() {
+    let mut string = String::new();
+    let _ = string.as_ptr() as *mut u8;
+    let _: *mut i8 = string.as_ptr() as *mut _;
+    let _ = string.as_ptr() as *const i8;
+    let _ = string.as_mut_ptr();
+    let _ = string.as_mut_ptr() as *mut u8;
+    let _ = string.as_mut_ptr() as *const u8;
+
+    let nn = std::ptr::NonNull::new(4 as *mut u8).unwrap();
+    let _ = nn.as_ptr() as *mut u8;
+
+    let mut wrap = MutPtrWrapper(Vec::new());
+    let _ = wrap.as_ptr() as *mut u8;
+
+    let mut local = 4;
+    let ref_with_write_perm = Covariant(std::ptr::addr_of_mut!(local) as *const _);
+    let _ = ref_with_write_perm.as_ptr() as *mut u8;
+}
diff --git a/tests/ui/as_ptr_cast_mut.stderr b/tests/ui/as_ptr_cast_mut.stderr
new file mode 100644
index 00000000000..2189c3d2f85
--- /dev/null
+++ b/tests/ui/as_ptr_cast_mut.stderr
@@ -0,0 +1,16 @@
+error: casting the result of `as_ptr` to *mut u8
+  --> $DIR/as_ptr_cast_mut.rs:21:13
+   |
+LL |     let _ = string.as_ptr() as *mut u8;
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `string.as_mut_ptr()`
+   |
+   = note: `-D clippy::as-ptr-cast-mut` implied by `-D warnings`
+
+error: casting the result of `as_ptr` to *mut i8
+  --> $DIR/as_ptr_cast_mut.rs:22:22
+   |
+LL |     let _: *mut i8 = string.as_ptr() as *mut _;
+   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `string.as_mut_ptr()`
+
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 169ef781f9ddc9954a2e1aa58351cd14983c9ae6 Mon Sep 17 00:00:00 2001
From: Nilstrieb <48135649+Nilstrieb@users.noreply.github.com>
Date: Sat, 1 Oct 2022 20:10:43 +0200
Subject: Improve wording

---
 clippy_lints/src/casts/mod.rs | 6 +++---
 src/docs/as_ptr_cast_mut.txt  | 4 ++--
 2 files changed, 5 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index fb0bd4d30f7..9a48e8d064a 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -602,8 +602,8 @@ declare_clippy_lint! {
     /// Checks for the result of a `&self`-taking `as_ptr` being cast to a mutable pointer
     ///
     /// ### Why is this bad?
-    /// Since `as_ptr` took a `&self`, the pointer won't have write permissions, making it
-    /// unlikely that having it as a mutable pointer is correct.
+    /// Since `as_ptr` takes a `&self`, the pointer won't have write permissions unless interior
+    /// mutability is used, making it unlikely that having it as a mutable pointer is correct.
     ///
     /// ### Example
     /// ```rust
@@ -620,7 +620,7 @@ declare_clippy_lint! {
     #[clippy::version = "1.66.0"]
     pub AS_PTR_CAST_MUT,
     nursery,
-    "casting the result of the `&self`-taking as_ptr to a mutabe point"
+    "casting the result of the `&self`-taking `as_ptr` to a mutabe pointer"
 }
 
 pub struct Casts {
diff --git a/src/docs/as_ptr_cast_mut.txt b/src/docs/as_ptr_cast_mut.txt
index 0192a0b686f..83332a2559d 100644
--- a/src/docs/as_ptr_cast_mut.txt
+++ b/src/docs/as_ptr_cast_mut.txt
@@ -2,8 +2,8 @@
 Checks for the result of a `&self`-taking `as_ptr` being cast to a mutable pointer
 
 ### Why is this bad?
-Since `as_ptr` took a `&self`, the pointer won't have write permissions, making it
-unlikely that having it as a mutable pointer is correct.
+Since `as_ptr` takes a `&self`, the pointer won't have write permissions unless interior
+mutability is used, making it unlikely that having it as a mutable pointer is correct.
 
 ### Example
 ```
-- 
cgit 1.4.1-3-g733a5


From 2b944d0c38ebfb99252ccfcb6200db28a217ee07 Mon Sep 17 00:00:00 2001
From: Nilstrieb <48135649+Nilstrieb@users.noreply.github.com>
Date: Sat, 1 Oct 2022 20:31:54 +0200
Subject: Fix example

---
 clippy_lints/src/casts/mod.rs | 4 ++--
 src/docs/as_ptr_cast_mut.txt  | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index 9a48e8d064a..b8f0dedf5ed 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -608,13 +608,13 @@ declare_clippy_lint! {
     /// ### Example
     /// ```rust
     /// let string = String::with_capacity(1);
-    /// let ptr = string.as_ptr() as *mut _;
+    /// let ptr = string.as_ptr() as *mut u8;
     /// unsafe { ptr.write(4) }; // UNDEFINED BEHAVIOUR
     /// ```
     /// Use instead:
     /// ```rust
     /// let mut string = String::with_capacity(1);
-    /// let string = string.as_mut_ptr();
+    /// let ptr = string.as_mut_ptr();
     /// unsafe { ptr.write(4) };
     /// ```
     #[clippy::version = "1.66.0"]
diff --git a/src/docs/as_ptr_cast_mut.txt b/src/docs/as_ptr_cast_mut.txt
index 83332a2559d..228dde996bb 100644
--- a/src/docs/as_ptr_cast_mut.txt
+++ b/src/docs/as_ptr_cast_mut.txt
@@ -8,12 +8,12 @@ mutability is used, making it unlikely that having it as a mutable pointer is co
 ### Example
 ```
 let string = String::with_capacity(1);
-let ptr = string.as_ptr() as *mut _;
+let ptr = string.as_ptr() as *mut u8;
 unsafe { ptr.write(4) }; // UNDEFINED BEHAVIOUR
 ```
 Use instead:
 ```
 let mut string = String::with_capacity(1);
-let string = string.as_mut_ptr();
+let ptr = string.as_mut_ptr();
 unsafe { ptr.write(4) };
 ```
\ No newline at end of file
-- 
cgit 1.4.1-3-g733a5


From b22118457245cdd074daaaaea950ec49397f8712 Mon Sep 17 00:00:00 2001
From: Jacob Kiesel <kieseljake@live.com>
Date: Thu, 15 Sep 2022 20:50:28 -0600
Subject: Implement manual_clamp lint

---
 CHANGELOG.md                                |   1 +
 clippy_lints/src/lib.register_all.rs        |   1 +
 clippy_lints/src/lib.register_complexity.rs |   1 +
 clippy_lints/src/lib.register_lints.rs      |   1 +
 clippy_lints/src/lib.rs                     |   2 +
 clippy_lints/src/manual_clamp.rs            | 715 ++++++++++++++++++++++++++++
 clippy_lints/src/utils/conf.rs              |   2 +-
 clippy_utils/src/msrvs.rs                   |   2 +-
 src/docs.rs                                 |   1 +
 src/docs/manual_clamp.txt                   |  46 ++
 tests/ui/manual_clamp.rs                    | 304 ++++++++++++
 tests/ui/manual_clamp.stderr                | 375 +++++++++++++++
 tests/ui/min_max.rs                         |   1 +
 tests/ui/min_max.stderr                     |  26 +-
 tests/ui/min_rust_version_attr.rs           |  12 +
 tests/ui/min_rust_version_attr.stderr       |   8 +-
 16 files changed, 1479 insertions(+), 19 deletions(-)
 create mode 100644 clippy_lints/src/manual_clamp.rs
 create mode 100644 src/docs/manual_clamp.txt
 create mode 100644 tests/ui/manual_clamp.rs
 create mode 100644 tests/ui/manual_clamp.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index ef6140152ff..9f12a673596 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3985,6 +3985,7 @@ Released 2018-09-13
 [`manual_assert`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_assert
 [`manual_async_fn`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_async_fn
 [`manual_bits`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_bits
+[`manual_clamp`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_clamp
 [`manual_filter_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_filter_map
 [`manual_find`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_find
 [`manual_find_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_find_map
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 435411642a7..9ad2a88eb26 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -125,6 +125,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(main_recursion::MAIN_RECURSION),
     LintId::of(manual_async_fn::MANUAL_ASYNC_FN),
     LintId::of(manual_bits::MANUAL_BITS),
+    LintId::of(manual_clamp::MANUAL_CLAMP),
     LintId::of(manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE),
     LintId::of(manual_rem_euclid::MANUAL_REM_EUCLID),
     LintId::of(manual_retain::MANUAL_RETAIN),
diff --git a/clippy_lints/src/lib.register_complexity.rs b/clippy_lints/src/lib.register_complexity.rs
index 185189a6af5..a58d066fa6b 100644
--- a/clippy_lints/src/lib.register_complexity.rs
+++ b/clippy_lints/src/lib.register_complexity.rs
@@ -22,6 +22,7 @@ store.register_group(true, "clippy::complexity", Some("clippy_complexity"), vec!
     LintId::of(loops::MANUAL_FLATTEN),
     LintId::of(loops::SINGLE_ELEMENT_LOOP),
     LintId::of(loops::WHILE_LET_LOOP),
+    LintId::of(manual_clamp::MANUAL_CLAMP),
     LintId::of(manual_rem_euclid::MANUAL_REM_EUCLID),
     LintId::of(manual_strip::MANUAL_STRIP),
     LintId::of(map_unit_fn::OPTION_MAP_UNIT_FN),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index ee08d802ccf..f3ddac49ace 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -245,6 +245,7 @@ store.register_lints(&[
     manual_assert::MANUAL_ASSERT,
     manual_async_fn::MANUAL_ASYNC_FN,
     manual_bits::MANUAL_BITS,
+    manual_clamp::MANUAL_CLAMP,
     manual_instant_elapsed::MANUAL_INSTANT_ELAPSED,
     manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE,
     manual_rem_euclid::MANUAL_REM_EUCLID,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index fde8aa9f921..4da3c9ece66 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -268,6 +268,7 @@ mod main_recursion;
 mod manual_assert;
 mod manual_async_fn;
 mod manual_bits;
+mod manual_clamp;
 mod manual_instant_elapsed;
 mod manual_non_exhaustive;
 mod manual_rem_euclid;
@@ -899,6 +900,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::<std_instead_of_core::StdReexports>::default());
     store.register_late_pass(|_| Box::new(manual_instant_elapsed::ManualInstantElapsed));
     store.register_late_pass(|_| Box::new(partialeq_to_none::PartialeqToNone));
+    store.register_late_pass(move |_| Box::new(manual_clamp::ManualClamp::new(msrv)));
     store.register_late_pass(|_| Box::new(manual_string_new::ManualStringNew));
     store.register_late_pass(|_| Box::new(unused_peekable::UnusedPeekable));
     store.register_early_pass(|| Box::new(multi_assignments::MultiAssignments));
diff --git a/clippy_lints/src/manual_clamp.rs b/clippy_lints/src/manual_clamp.rs
new file mode 100644
index 00000000000..ac5c24ee604
--- /dev/null
+++ b/clippy_lints/src/manual_clamp.rs
@@ -0,0 +1,715 @@
+use itertools::Itertools;
+use rustc_errors::Diagnostic;
+use rustc_hir::{
+    def::Res, Arm, BinOpKind, Block, Expr, ExprKind, Guard, HirId, PatKind, PathSegment, PrimTy, QPath, StmtKind,
+};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::Ty;
+use rustc_semver::RustcVersion;
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::{symbol::sym, Span};
+use std::ops::Deref;
+
+use clippy_utils::{
+    diagnostics::{span_lint_and_then, span_lint_hir_and_then},
+    eq_expr_value, get_trait_def_id,
+    higher::If,
+    is_diag_trait_item, is_trait_method, meets_msrv, msrvs, path_res, path_to_local_id, paths, peel_blocks,
+    peel_blocks_with_stmt,
+    sugg::Sugg,
+    ty::implements_trait,
+    visitors::is_const_evaluatable,
+    MaybePath,
+};
+use rustc_errors::Applicability;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Identifies good opportunities for a clamp function from std or core, and suggests using it.
+    ///
+    /// ### Why is this bad?
+    /// clamp is much shorter, easier to read, and doesn't use any control flow.
+    ///
+    /// ### Known issue(s)
+    /// If the clamped variable is NaN this suggestion will cause the code to propagate NaN
+    /// rather than returning either `max` or `min`.
+    ///
+    /// `clamp` functions will panic if `max < min`, `max.is_nan()`, or `min.is_nan()`.
+    /// Some may consider panicking in these situations to be desirable, but it also may
+    /// introduce panicking where there wasn't any before.
+    ///
+    /// ### Examples
+    /// ```rust
+    /// # let (input, min, max) = (0, -2, 1);
+    /// if input > max {
+    ///     max
+    /// } else if input < min {
+    ///     min
+    /// } else {
+    ///     input
+    /// }
+    /// # ;
+    /// ```
+    ///
+    /// ```rust
+    /// # let (input, min, max) = (0, -2, 1);
+    /// input.max(min).min(max)
+    /// # ;
+    /// ```
+    ///
+    /// ```rust
+    /// # let (input, min, max) = (0, -2, 1);
+    /// match input {
+    ///     x if x > max => max,
+    ///     x if x < min => min,
+    ///     x => x,
+    /// }
+    /// # ;
+    /// ```
+    ///
+    /// ```rust
+    /// # let (input, min, max) = (0, -2, 1);
+    /// let mut x = input;
+    /// if x < min { x = min; }
+    /// if x > max { x = max; }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// # let (input, min, max) = (0, -2, 1);
+    /// input.clamp(min, max)
+    /// # ;
+    /// ```
+    #[clippy::version = "1.66.0"]
+    pub MANUAL_CLAMP,
+    complexity,
+    "using a clamp pattern instead of the clamp function"
+}
+impl_lint_pass!(ManualClamp => [MANUAL_CLAMP]);
+
+pub struct ManualClamp {
+    msrv: Option<RustcVersion>,
+}
+
+impl ManualClamp {
+    pub fn new(msrv: Option<RustcVersion>) -> Self {
+        Self { msrv }
+    }
+}
+
+#[derive(Debug)]
+struct ClampSuggestion<'tcx> {
+    params: InputMinMax<'tcx>,
+    span: Span,
+    make_assignment: Option<&'tcx Expr<'tcx>>,
+    hir_with_ignore_attr: Option<HirId>,
+}
+
+#[derive(Debug)]
+struct InputMinMax<'tcx> {
+    input: &'tcx Expr<'tcx>,
+    min: &'tcx Expr<'tcx>,
+    max: &'tcx Expr<'tcx>,
+    is_float: bool,
+}
+
+impl<'tcx> LateLintPass<'tcx> for ManualClamp {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
+        if !meets_msrv(self.msrv, msrvs::CLAMP) {
+            return;
+        }
+        if !expr.span.from_expansion() {
+            let suggestion = is_if_elseif_else_pattern(cx, expr)
+                .or_else(|| is_max_min_pattern(cx, expr))
+                .or_else(|| is_call_max_min_pattern(cx, expr))
+                .or_else(|| is_match_pattern(cx, expr))
+                .or_else(|| is_if_elseif_pattern(cx, expr));
+            if let Some(suggestion) = suggestion {
+                emit_suggestion(cx, &suggestion);
+            }
+        }
+    }
+
+    fn check_block(&mut self, cx: &LateContext<'tcx>, block: &'tcx Block<'tcx>) {
+        if !meets_msrv(self.msrv, msrvs::CLAMP) {
+            return;
+        }
+        for suggestion in is_two_if_pattern(cx, block) {
+            emit_suggestion(cx, &suggestion);
+        }
+    }
+    extract_msrv_attr!(LateContext);
+}
+
+fn emit_suggestion<'tcx>(cx: &LateContext<'tcx>, suggestion: &ClampSuggestion<'tcx>) {
+    let ClampSuggestion {
+        params: InputMinMax {
+            input,
+            min,
+            max,
+            is_float,
+        },
+        span,
+        make_assignment,
+        hir_with_ignore_attr,
+    } = suggestion;
+    let input = Sugg::hir(cx, input, "..").maybe_par();
+    let min = Sugg::hir(cx, min, "..");
+    let max = Sugg::hir(cx, max, "..");
+    let semicolon = if make_assignment.is_some() { ";" } else { "" };
+    let assignment = if let Some(assignment) = make_assignment {
+        let assignment = Sugg::hir(cx, assignment, "..");
+        format!("{assignment} = ")
+    } else {
+        String::new()
+    };
+    let suggestion = format!("{assignment}{input}.clamp({min}, {max}){semicolon}");
+    let msg = "clamp-like pattern without using clamp function";
+    let lint_builder = |d: &mut Diagnostic| {
+        d.span_suggestion(*span, "replace with clamp", suggestion, Applicability::MaybeIncorrect);
+        if *is_float {
+            d.note("clamp will panic if max < min, min.is_nan(), or max.is_nan()")
+                .note("clamp returns NaN if the input is NaN");
+        } else {
+            d.note("clamp will panic if max < min");
+        }
+    };
+    if let Some(hir_id) = hir_with_ignore_attr {
+        span_lint_hir_and_then(cx, MANUAL_CLAMP, *hir_id, *span, msg, lint_builder);
+    } else {
+        span_lint_and_then(cx, MANUAL_CLAMP, *span, msg, lint_builder);
+    }
+}
+
+#[derive(Debug, Copy, Clone, Eq, PartialEq)]
+enum TypeClampability {
+    Float,
+    Ord,
+}
+
+impl TypeClampability {
+    fn is_clampable<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Option<TypeClampability> {
+        if ty.is_floating_point() {
+            Some(TypeClampability::Float)
+        } else if get_trait_def_id(cx, &paths::ORD).map_or(false, |id| implements_trait(cx, ty, id, &[])) {
+            Some(TypeClampability::Ord)
+        } else {
+            None
+        }
+    }
+
+    fn is_float(self) -> bool {
+        matches!(self, TypeClampability::Float)
+    }
+}
+
+/// Targets patterns like
+///
+/// ```
+/// # let (input, min, max) = (0, -3, 12);
+///
+/// if input < min {
+///     min
+/// } else if input > max {
+///     max
+/// } else {
+///     input
+/// }
+/// # ;
+/// ```
+fn is_if_elseif_else_pattern<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> Option<ClampSuggestion<'tcx>> {
+    if let Some(If {
+        cond,
+        then,
+        r#else: Some(else_if),
+    }) = If::hir(expr)
+    && let Some(If {
+        cond: else_if_cond,
+        then: else_if_then,
+        r#else: Some(else_body),
+    }) = If::hir(peel_blocks(else_if))
+    {
+        let params = is_clamp_meta_pattern(
+            cx,
+            &BinaryOp::new(peel_blocks(cond))?,
+            &BinaryOp::new(peel_blocks(else_if_cond))?,
+            peel_blocks(then),
+            peel_blocks(else_if_then),
+            None,
+        )?;
+        // Contents of the else should be the resolved input.
+        if !eq_expr_value(cx, params.input, peel_blocks(else_body)) {
+            return None;
+        }
+        Some(ClampSuggestion {
+            params,
+            span: expr.span,
+            make_assignment: None,
+            hir_with_ignore_attr: None,
+        })
+    } else {
+        None
+    }
+}
+
+/// Targets patterns like
+///
+/// ```
+/// # let (input, min_value, max_value) = (0, -3, 12);
+///
+/// input.max(min_value).min(max_value)
+/// # ;
+/// ```
+fn is_max_min_pattern<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> Option<ClampSuggestion<'tcx>> {
+    if let ExprKind::MethodCall(seg_second, receiver, [arg_second], _) = &expr.kind
+        && (cx.typeck_results().expr_ty_adjusted(receiver).is_floating_point() || is_trait_method(cx, expr, sym::Ord))
+        && let ExprKind::MethodCall(seg_first, input, [arg_first], _) = &receiver.kind
+        && (cx.typeck_results().expr_ty_adjusted(input).is_floating_point() || is_trait_method(cx, receiver, sym::Ord))
+    {
+        let is_float = cx.typeck_results().expr_ty_adjusted(input).is_floating_point();
+        let (min, max) = match (seg_first.ident.as_str(), seg_second.ident.as_str()) {
+            ("min", "max") => (arg_second, arg_first),
+            ("max", "min") => (arg_first, arg_second),
+            _ => return None,
+        };
+        Some(ClampSuggestion {
+            params: InputMinMax { input, min, max, is_float },
+            span: expr.span,
+            make_assignment: None,
+            hir_with_ignore_attr: None,
+        })
+    } else {
+        None
+    }
+}
+
+/// Targets patterns like
+///
+/// ```
+/// # let (input, min_value, max_value) = (0, -3, 12);
+/// # use std::cmp::{max, min};
+/// min(max(input, min_value), max_value)
+/// # ;
+/// ```
+fn is_call_max_min_pattern<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> Option<ClampSuggestion<'tcx>> {
+    fn segment<'tcx>(cx: &LateContext<'_>, func: &Expr<'tcx>) -> Option<FunctionType<'tcx>> {
+        match func.kind {
+            ExprKind::Path(QPath::Resolved(None, path)) => {
+                let id = path.res.opt_def_id()?;
+                match cx.tcx.get_diagnostic_name(id) {
+                    Some(sym::cmp_min) => Some(FunctionType::CmpMin),
+                    Some(sym::cmp_max) => Some(FunctionType::CmpMax),
+                    _ if is_diag_trait_item(cx, id, sym::Ord) => {
+                        Some(FunctionType::OrdOrFloat(path.segments.last().expect("infallible")))
+                    },
+                    _ => None,
+                }
+            },
+            ExprKind::Path(QPath::TypeRelative(ty, seg)) => {
+                matches!(path_res(cx, ty), Res::PrimTy(PrimTy::Float(_))).then(|| FunctionType::OrdOrFloat(seg))
+            },
+            _ => None,
+        }
+    }
+
+    enum FunctionType<'tcx> {
+        CmpMin,
+        CmpMax,
+        OrdOrFloat(&'tcx PathSegment<'tcx>),
+    }
+
+    fn check<'tcx>(
+        cx: &LateContext<'tcx>,
+        outer_fn: &'tcx Expr<'tcx>,
+        inner_call: &'tcx Expr<'tcx>,
+        outer_arg: &'tcx Expr<'tcx>,
+        span: Span,
+    ) -> Option<ClampSuggestion<'tcx>> {
+        if let ExprKind::Call(inner_fn, &[ref first, ref second]) = &inner_call.kind
+            && let Some(inner_seg) = segment(cx, inner_fn)
+            && let Some(outer_seg) = segment(cx, outer_fn)
+        {
+            let (input, inner_arg) = match (is_const_evaluatable(cx, first), is_const_evaluatable(cx, second)) {
+                (true, false) => (second, first),
+                (false, true) => (first, second),
+                _ => return None,
+            };
+            let is_float = cx.typeck_results().expr_ty_adjusted(input).is_floating_point();
+            let (min, max) = match (inner_seg, outer_seg) {
+                (FunctionType::CmpMin, FunctionType::CmpMax) => (outer_arg, inner_arg),
+                (FunctionType::CmpMax, FunctionType::CmpMin) => (inner_arg, outer_arg),
+                (FunctionType::OrdOrFloat(first_segment), FunctionType::OrdOrFloat(second_segment)) => {
+                    match (first_segment.ident.as_str(), second_segment.ident.as_str()) {
+                        ("min", "max") => (outer_arg, inner_arg),
+                        ("max", "min") => (inner_arg, outer_arg),
+                        _ => return None,
+                    }
+                }
+                _ => return None,
+            };
+            Some(ClampSuggestion {
+                params: InputMinMax { input, min, max, is_float },
+                span,
+                make_assignment: None,
+                hir_with_ignore_attr: None,
+            })
+        } else {
+            None
+        }
+    }
+
+    if let ExprKind::Call(outer_fn, [first, second]) = &expr.kind {
+        check(cx, outer_fn, first, second, expr.span).or_else(|| check(cx, outer_fn, second, first, expr.span))
+    } else {
+        None
+    }
+}
+
+/// Targets patterns like
+///
+/// ```
+/// # let (input, min, max) = (0, -3, 12);
+///
+/// match input {
+///     input if input > max => max,
+///     input if input < min => min,
+///     input => input,
+/// }
+/// # ;
+/// ```
+fn is_match_pattern<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> Option<ClampSuggestion<'tcx>> {
+    if let ExprKind::Match(value, &[ref first_arm, ref second_arm, ref last_arm], rustc_hir::MatchSource::Normal) =
+        &expr.kind
+    {
+        // Find possible min/max branches
+        let minmax_values = |a: &'tcx Arm<'tcx>| {
+            if let PatKind::Binding(_, var_hir_id, _, None) = &a.pat.kind
+            && let Some(Guard::If(e)) = a.guard {
+                Some((e, var_hir_id, a.body))
+            } else {
+                None
+            }
+        };
+        let (first, first_hir_id, first_expr) = minmax_values(first_arm)?;
+        let (second, second_hir_id, second_expr) = minmax_values(second_arm)?;
+        let first = BinaryOp::new(first)?;
+        let second = BinaryOp::new(second)?;
+        if let PatKind::Binding(_, binding, _, None) = &last_arm.pat.kind
+            && path_to_local_id(peel_blocks_with_stmt(last_arm.body), *binding)
+            && last_arm.guard.is_none()
+        {
+            // Proceed as normal
+        } else {
+            return None;
+        }
+        if let Some(params) = is_clamp_meta_pattern(
+            cx,
+            &first,
+            &second,
+            first_expr,
+            second_expr,
+            Some((*first_hir_id, *second_hir_id)),
+        ) {
+            return Some(ClampSuggestion {
+                params: InputMinMax {
+                    input: value,
+                    min: params.min,
+                    max: params.max,
+                    is_float: params.is_float,
+                },
+                span: expr.span,
+                make_assignment: None,
+                hir_with_ignore_attr: None,
+            });
+        }
+    }
+    None
+}
+
+/// Targets patterns like
+///
+/// ```
+/// # let (input, min, max) = (0, -3, 12);
+///
+/// let mut x = input;
+/// if x < min { x = min; }
+/// if x > max { x = max; }
+/// ```
+fn is_two_if_pattern<'tcx>(cx: &LateContext<'tcx>, block: &'tcx Block<'tcx>) -> Vec<ClampSuggestion<'tcx>> {
+    block_stmt_with_last(block)
+        .tuple_windows()
+        .filter_map(|(maybe_set_first, maybe_set_second)| {
+            if let StmtKind::Expr(first_expr) = *maybe_set_first
+                && let StmtKind::Expr(second_expr) = *maybe_set_second
+                && let Some(If { cond: first_cond, then: first_then, r#else: None }) = If::hir(first_expr)
+                && let Some(If { cond: second_cond, then: second_then, r#else: None }) = If::hir(second_expr)
+                && let ExprKind::Assign(
+                    maybe_input_first_path,
+                    maybe_min_max_first,
+                    _
+                ) = peel_blocks_with_stmt(first_then).kind
+                && let ExprKind::Assign(
+                    maybe_input_second_path,
+                    maybe_min_max_second,
+                    _
+                ) = peel_blocks_with_stmt(second_then).kind
+                && eq_expr_value(cx, maybe_input_first_path, maybe_input_second_path)
+                && let Some(first_bin) = BinaryOp::new(first_cond)
+                && let Some(second_bin) = BinaryOp::new(second_cond)
+                && let Some(input_min_max) = is_clamp_meta_pattern(
+                    cx,
+                    &first_bin,
+                    &second_bin,
+                    maybe_min_max_first,
+                    maybe_min_max_second,
+                    None
+                )
+            {
+                Some(ClampSuggestion {
+                    params: InputMinMax {
+                        input: maybe_input_first_path,
+                        min: input_min_max.min,
+                        max: input_min_max.max,
+                        is_float: input_min_max.is_float,
+                    },
+                    span: first_expr.span.to(second_expr.span),
+                    make_assignment: Some(maybe_input_first_path),
+                    hir_with_ignore_attr: Some(first_expr.hir_id()),
+                })
+            } else {
+                None
+            }
+        })
+        .collect()
+}
+
+/// Targets patterns like
+///
+/// ```
+/// # let (mut input, min, max) = (0, -3, 12);
+///
+/// if input < min {
+///     input = min;
+/// } else if input > max {
+///     input = max;
+/// }
+/// ```
+fn is_if_elseif_pattern<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> Option<ClampSuggestion<'tcx>> {
+    if let Some(If {
+        cond,
+        then,
+        r#else: Some(else_if),
+    }) = If::hir(expr)
+        && let Some(If {
+            cond: else_if_cond,
+            then: else_if_then,
+            r#else: None,
+        }) = If::hir(peel_blocks(else_if))
+        && let ExprKind::Assign(
+            maybe_input_first_path,
+            maybe_min_max_first,
+            _
+        ) = peel_blocks_with_stmt(then).kind
+        && let ExprKind::Assign(
+            maybe_input_second_path,
+            maybe_min_max_second,
+            _
+        ) = peel_blocks_with_stmt(else_if_then).kind
+    {
+        let params = is_clamp_meta_pattern(
+            cx,
+            &BinaryOp::new(peel_blocks(cond))?,
+            &BinaryOp::new(peel_blocks(else_if_cond))?,
+            peel_blocks(maybe_min_max_first),
+            peel_blocks(maybe_min_max_second),
+            None,
+        )?;
+        if !eq_expr_value(cx, maybe_input_first_path, maybe_input_second_path) {
+            return None;
+        }
+        Some(ClampSuggestion {
+            params,
+            span: expr.span,
+            make_assignment: Some(maybe_input_first_path),
+            hir_with_ignore_attr: None,
+        })
+    } else {
+        None
+    }
+}
+
+/// `ExprKind::Binary` but more narrowly typed
+#[derive(Debug, Clone, Copy)]
+struct BinaryOp<'tcx> {
+    op: BinOpKind,
+    left: &'tcx Expr<'tcx>,
+    right: &'tcx Expr<'tcx>,
+}
+
+impl<'tcx> BinaryOp<'tcx> {
+    fn new(e: &'tcx Expr<'tcx>) -> Option<BinaryOp<'tcx>> {
+        match &e.kind {
+            ExprKind::Binary(op, left, right) => Some(BinaryOp {
+                op: op.node,
+                left,
+                right,
+            }),
+            _ => None,
+        }
+    }
+
+    fn flip(&self) -> Self {
+        Self {
+            op: match self.op {
+                BinOpKind::Le => BinOpKind::Ge,
+                BinOpKind::Lt => BinOpKind::Gt,
+                BinOpKind::Ge => BinOpKind::Le,
+                BinOpKind::Gt => BinOpKind::Lt,
+                other => other,
+            },
+            left: self.right,
+            right: self.left,
+        }
+    }
+}
+
+/// The clamp meta pattern is a pattern shared between many (but not all) patterns.
+/// In summary, this pattern consists of two if statements that meet many criteria,
+/// - binary operators that are one of [`>`, `<`, `>=`, `<=`].
+/// - Both binary statements must have a shared argument
+///     - Which can appear on the left or right side of either statement
+///     - The binary operators must define a finite range for the shared argument. To put this in
+///       the terms of Rust `std` library, the following ranges are acceptable
+///         - `Range`
+///         - `RangeInclusive`
+///       And all other range types are not accepted. For the purposes of `clamp` it's irrelevant
+///       whether the range is inclusive or not, the output is the same.
+/// - The result of each if statement must be equal to the argument unique to that if statement. The
+///   result can not be the shared argument in either case.
+fn is_clamp_meta_pattern<'tcx>(
+    cx: &LateContext<'tcx>,
+    first_bin: &BinaryOp<'tcx>,
+    second_bin: &BinaryOp<'tcx>,
+    first_expr: &'tcx Expr<'tcx>,
+    second_expr: &'tcx Expr<'tcx>,
+    // This parameters is exclusively for the match pattern.
+    // It exists because the variable bindings used in that pattern
+    // refer to the variable bound in the match arm, not the variable
+    // bound outside of it. Fortunately due to context we know this has to
+    // be the input variable, not the min or max.
+    input_hir_ids: Option<(HirId, HirId)>,
+) -> Option<InputMinMax<'tcx>> {
+    fn check<'tcx>(
+        cx: &LateContext<'tcx>,
+        first_bin: &BinaryOp<'tcx>,
+        second_bin: &BinaryOp<'tcx>,
+        first_expr: &'tcx Expr<'tcx>,
+        second_expr: &'tcx Expr<'tcx>,
+        input_hir_ids: Option<(HirId, HirId)>,
+        is_float: bool,
+    ) -> Option<InputMinMax<'tcx>> {
+        match (&first_bin.op, &second_bin.op) {
+            (BinOpKind::Ge | BinOpKind::Gt, BinOpKind::Le | BinOpKind::Lt) => {
+                let (min, max) = (second_expr, first_expr);
+                let refers_to_input = match input_hir_ids {
+                    Some((first_hir_id, second_hir_id)) => {
+                        path_to_local_id(peel_blocks(first_bin.left), first_hir_id)
+                            && path_to_local_id(peel_blocks(second_bin.left), second_hir_id)
+                    },
+                    None => eq_expr_value(cx, first_bin.left, second_bin.left),
+                };
+                (refers_to_input
+                    && eq_expr_value(cx, first_bin.right, first_expr)
+                    && eq_expr_value(cx, second_bin.right, second_expr))
+                .then_some(InputMinMax {
+                    input: first_bin.left,
+                    min,
+                    max,
+                    is_float,
+                })
+            },
+            _ => None,
+        }
+    }
+    // First filter out any expressions with side effects
+    let exprs = [
+        first_bin.left,
+        first_bin.right,
+        second_bin.left,
+        second_bin.right,
+        first_expr,
+        second_expr,
+    ];
+    let clampability = TypeClampability::is_clampable(cx, cx.typeck_results().expr_ty(first_expr))?;
+    let is_float = clampability.is_float();
+    if exprs.iter().any(|e| peel_blocks(e).can_have_side_effects()) {
+        return None;
+    }
+    if !(is_ord_op(first_bin.op) && is_ord_op(second_bin.op)) {
+        return None;
+    }
+    let cases = [
+        (*first_bin, *second_bin),
+        (first_bin.flip(), second_bin.flip()),
+        (first_bin.flip(), *second_bin),
+        (*first_bin, second_bin.flip()),
+    ];
+
+    cases.into_iter().find_map(|(first, second)| {
+        check(cx, &first, &second, first_expr, second_expr, input_hir_ids, is_float).or_else(|| {
+            check(
+                cx,
+                &second,
+                &first,
+                second_expr,
+                first_expr,
+                input_hir_ids.map(|(l, r)| (r, l)),
+                is_float,
+            )
+        })
+    })
+}
+
+fn block_stmt_with_last<'tcx>(block: &'tcx Block<'tcx>) -> impl Iterator<Item = MaybeBorrowedStmtKind<'tcx>> {
+    block
+        .stmts
+        .iter()
+        .map(|s| MaybeBorrowedStmtKind::Borrowed(&s.kind))
+        .chain(
+            block
+                .expr
+                .as_ref()
+                .map(|e| MaybeBorrowedStmtKind::Owned(StmtKind::Expr(e))),
+        )
+}
+
+fn is_ord_op(op: BinOpKind) -> bool {
+    matches!(op, BinOpKind::Ge | BinOpKind::Gt | BinOpKind::Le | BinOpKind::Lt)
+}
+
+/// Really similar to Cow, but doesn't have a `Clone` requirement.
+#[derive(Debug)]
+enum MaybeBorrowedStmtKind<'a> {
+    Borrowed(&'a StmtKind<'a>),
+    Owned(StmtKind<'a>),
+}
+
+impl<'a> Clone for MaybeBorrowedStmtKind<'a> {
+    fn clone(&self) -> Self {
+        match self {
+            Self::Borrowed(t) => Self::Borrowed(t),
+            Self::Owned(StmtKind::Expr(e)) => Self::Owned(StmtKind::Expr(e)),
+            Self::Owned(_) => unreachable!("Owned should only ever contain a StmtKind::Expr."),
+        }
+    }
+}
+
+impl<'a> Deref for MaybeBorrowedStmtKind<'a> {
+    type Target = StmtKind<'a>;
+
+    fn deref(&self) -> &Self::Target {
+        match self {
+            Self::Borrowed(t) => t,
+            Self::Owned(t) => t,
+        }
+    }
+}
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index a8265b50f27..2b336e87ef7 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -213,7 +213,7 @@ define_Conf! {
     ///
     /// Suppress lints whenever the suggested change would cause breakage for other crates.
     (avoid_breaking_exported_api: bool = true),
-    /// Lint: MANUAL_SPLIT_ONCE, MANUAL_STR_REPEAT, CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR, IF_THEN_SOME_ELSE_NONE, APPROX_CONSTANT, DEPRECATED_CFG_ATTR, INDEX_REFUTABLE_SLICE, MAP_CLONE, BORROW_AS_PTR, MANUAL_BITS, ERR_EXPECT, CAST_ABS_TO_UNSIGNED, UNINLINED_FORMAT_ARGS.
+    /// Lint: MANUAL_SPLIT_ONCE, MANUAL_STR_REPEAT, CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR, IF_THEN_SOME_ELSE_NONE, APPROX_CONSTANT, DEPRECATED_CFG_ATTR, INDEX_REFUTABLE_SLICE, MAP_CLONE, BORROW_AS_PTR, MANUAL_BITS, ERR_EXPECT, CAST_ABS_TO_UNSIGNED, UNINLINED_FORMAT_ARGS, MANUAL_CLAMP.
     ///
     /// The minimum rust version that the project supports
     (msrv: Option<String> = None),
diff --git a/clippy_utils/src/msrvs.rs b/clippy_utils/src/msrvs.rs
index 904091c57e8..8b843732a23 100644
--- a/clippy_utils/src/msrvs.rs
+++ b/clippy_utils/src/msrvs.rs
@@ -17,7 +17,7 @@ msrv_aliases! {
     1,53,0 { OR_PATTERNS, MANUAL_BITS, BTREE_MAP_RETAIN, BTREE_SET_RETAIN, ARRAY_INTO_ITERATOR }
     1,52,0 { STR_SPLIT_ONCE, REM_EUCLID_CONST }
     1,51,0 { BORROW_AS_PTR, UNSIGNED_ABS }
-    1,50,0 { BOOL_THEN }
+    1,50,0 { BOOL_THEN, CLAMP }
     1,47,0 { TAU }
     1,46,0 { CONST_IF_MATCH }
     1,45,0 { STR_STRIP_PREFIX }
diff --git a/src/docs.rs b/src/docs.rs
index 166be0618ff..39540e4b048 100644
--- a/src/docs.rs
+++ b/src/docs.rs
@@ -255,6 +255,7 @@ docs! {
     "manual_assert",
     "manual_async_fn",
     "manual_bits",
+    "manual_clamp",
     "manual_filter_map",
     "manual_find",
     "manual_find_map",
diff --git a/src/docs/manual_clamp.txt b/src/docs/manual_clamp.txt
new file mode 100644
index 00000000000..8993f6683ad
--- /dev/null
+++ b/src/docs/manual_clamp.txt
@@ -0,0 +1,46 @@
+### What it does
+Identifies good opportunities for a clamp function from std or core, and suggests using it.
+
+### Why is this bad?
+clamp is much shorter, easier to read, and doesn't use any control flow.
+
+### Known issue(s)
+If the clamped variable is NaN this suggestion will cause the code to propagate NaN
+rather than returning either `max` or `min`.
+
+`clamp` functions will panic if `max < min`, `max.is_nan()`, or `min.is_nan()`.
+Some may consider panicking in these situations to be desirable, but it also may
+introduce panicking where there wasn't any before.
+
+### Examples
+```
+if input > max {
+    max
+} else if input < min {
+    min
+} else {
+    input
+}
+```
+
+```
+input.max(min).min(max)
+```
+
+```
+match input {
+    x if x > max => max,
+    x if x < min => min,
+    x => x,
+}
+```
+
+```
+let mut x = input;
+if x < min { x = min; }
+if x > max { x = max; }
+```
+Use instead:
+```
+input.clamp(min, max)
+```
\ No newline at end of file
diff --git a/tests/ui/manual_clamp.rs b/tests/ui/manual_clamp.rs
new file mode 100644
index 00000000000..54fd888af99
--- /dev/null
+++ b/tests/ui/manual_clamp.rs
@@ -0,0 +1,304 @@
+#![warn(clippy::manual_clamp)]
+#![allow(
+    unused,
+    dead_code,
+    clippy::unnecessary_operation,
+    clippy::no_effect,
+    clippy::if_same_then_else
+)]
+
+use std::cmp::{max as cmp_max, min as cmp_min};
+
+const CONST_MAX: i32 = 10;
+const CONST_MIN: i32 = 4;
+
+const CONST_F64_MAX: f64 = 10.0;
+const CONST_F64_MIN: f64 = 4.0;
+
+fn main() {
+    let (input, min, max) = (0, -2, 3);
+    // Lint
+    let x0 = if max < input {
+        max
+    } else if min > input {
+        min
+    } else {
+        input
+    };
+
+    let x1 = if input > max {
+        max
+    } else if input < min {
+        min
+    } else {
+        input
+    };
+
+    let x2 = if input < min {
+        min
+    } else if input > max {
+        max
+    } else {
+        input
+    };
+
+    let x3 = if min > input {
+        min
+    } else if max < input {
+        max
+    } else {
+        input
+    };
+
+    let x4 = input.max(min).min(max);
+
+    let x5 = input.min(max).max(min);
+
+    let x6 = match input {
+        x if x > max => max,
+        x if x < min => min,
+        x => x,
+    };
+
+    let x7 = match input {
+        x if x < min => min,
+        x if x > max => max,
+        x => x,
+    };
+
+    let x8 = match input {
+        x if max < x => max,
+        x if min > x => min,
+        x => x,
+    };
+
+    let mut x9 = input;
+    if x9 < min {
+        x9 = min;
+    }
+    if x9 > max {
+        x9 = max;
+    }
+
+    let x10 = match input {
+        x if min > x => min,
+        x if max < x => max,
+        x => x,
+    };
+
+    let mut x11 = input;
+    let _ = 1;
+    if x11 > max {
+        x11 = max;
+    }
+    if x11 < min {
+        x11 = min;
+    }
+
+    let mut x12 = input;
+    if min > x12 {
+        x12 = min;
+    }
+    if max < x12 {
+        x12 = max;
+    }
+
+    let mut x13 = input;
+    if max < x13 {
+        x13 = max;
+    }
+    if min > x13 {
+        x13 = min;
+    }
+
+    let x14 = if input > CONST_MAX {
+        CONST_MAX
+    } else if input < CONST_MIN {
+        CONST_MIN
+    } else {
+        input
+    };
+    {
+        let (input, min, max) = (0.0f64, -2.0, 3.0);
+        let x15 = if input > max {
+            max
+        } else if input < min {
+            min
+        } else {
+            input
+        };
+    }
+    {
+        let input: i32 = cmp_min_max(1);
+        // These can only be detected if exactly one of the arguments to the inner function is const.
+        let x16 = cmp_max(cmp_min(input, CONST_MAX), CONST_MIN);
+        let x17 = cmp_min(cmp_max(input, CONST_MIN), CONST_MAX);
+        let x18 = cmp_max(CONST_MIN, cmp_min(input, CONST_MAX));
+        let x19 = cmp_min(CONST_MAX, cmp_max(input, CONST_MIN));
+        let x20 = cmp_max(cmp_min(CONST_MAX, input), CONST_MIN);
+        let x21 = cmp_min(cmp_max(CONST_MIN, input), CONST_MAX);
+        let x22 = cmp_max(CONST_MIN, cmp_min(CONST_MAX, input));
+        let x23 = cmp_min(CONST_MAX, cmp_max(CONST_MIN, input));
+        let input: f64 = cmp_min_max(1) as f64;
+        let x24 = f64::max(f64::min(input, CONST_F64_MAX), CONST_F64_MIN);
+        let x25 = f64::min(f64::max(input, CONST_F64_MIN), CONST_F64_MAX);
+        let x26 = f64::max(CONST_F64_MIN, f64::min(input, CONST_F64_MAX));
+        let x27 = f64::min(CONST_F64_MAX, f64::max(input, CONST_F64_MIN));
+        let x28 = f64::max(f64::min(CONST_F64_MAX, input), CONST_F64_MIN);
+        let x29 = f64::min(f64::max(CONST_F64_MIN, input), CONST_F64_MAX);
+        let x30 = f64::max(CONST_F64_MIN, f64::min(CONST_F64_MAX, input));
+        let x31 = f64::min(CONST_F64_MAX, f64::max(CONST_F64_MIN, input));
+    }
+    let mut x32 = input;
+    if x32 < min {
+        x32 = min;
+    } else if x32 > max {
+        x32 = max;
+    }
+
+    // It's important this be the last set of statements
+    let mut x33 = input;
+    if max < x33 {
+        x33 = max;
+    }
+    if min > x33 {
+        x33 = min;
+    }
+}
+
+// This code intentionally nonsense.
+fn no_lint() {
+    let (input, min, max) = (0, -2, 3);
+    let x0 = if max < input {
+        max
+    } else if min > input {
+        max
+    } else {
+        min
+    };
+
+    let x1 = if input > max {
+        max
+    } else if input > min {
+        min
+    } else {
+        max
+    };
+
+    let x2 = if max < min {
+        min
+    } else if input > max {
+        input
+    } else {
+        input
+    };
+
+    let x3 = if min > input {
+        input
+    } else if max < input {
+        max
+    } else {
+        max
+    };
+
+    let x6 = match input {
+        x if x < max => x,
+        x if x < min => x,
+        x => x,
+    };
+
+    let x7 = match input {
+        x if x < min => max,
+        x if x > max => min,
+        x => x,
+    };
+
+    let x8 = match input {
+        x if max > x => max,
+        x if min > x => min,
+        x => x,
+    };
+
+    let mut x9 = input;
+    if x9 > min {
+        x9 = min;
+    }
+    if x9 > max {
+        x9 = max;
+    }
+
+    let x10 = match input {
+        x if min > x => min,
+        x if max < x => max,
+        x => min,
+    };
+
+    let mut x11 = input;
+    if x11 > max {
+        x11 = min;
+    }
+    if x11 < min {
+        x11 = max;
+    }
+
+    let mut x12 = input;
+    if min > x12 {
+        x12 = max * 3;
+    }
+    if max < x12 {
+        x12 = min;
+    }
+
+    let mut x13 = input;
+    if max < x13 {
+        let x13 = max;
+    }
+    if min > x13 {
+        x13 = min;
+    }
+    let mut x14 = input;
+    if x14 < min {
+        x14 = 3;
+    } else if x14 > max {
+        x14 = max;
+    }
+    {
+        let input: i32 = cmp_min_max(1);
+        // These can only be detected if exactly one of the arguments to the inner function is const.
+        let x16 = cmp_max(cmp_max(input, CONST_MAX), CONST_MIN);
+        let x17 = cmp_min(cmp_min(input, CONST_MIN), CONST_MAX);
+        let x18 = cmp_max(CONST_MIN, cmp_max(input, CONST_MAX));
+        let x19 = cmp_min(CONST_MAX, cmp_min(input, CONST_MIN));
+        let x20 = cmp_max(cmp_max(CONST_MAX, input), CONST_MIN);
+        let x21 = cmp_min(cmp_min(CONST_MIN, input), CONST_MAX);
+        let x22 = cmp_max(CONST_MIN, cmp_max(CONST_MAX, input));
+        let x23 = cmp_min(CONST_MAX, cmp_min(CONST_MIN, input));
+        let input: f64 = cmp_min_max(1) as f64;
+        let x24 = f64::max(f64::max(input, CONST_F64_MAX), CONST_F64_MIN);
+        let x25 = f64::min(f64::min(input, CONST_F64_MIN), CONST_F64_MAX);
+        let x26 = f64::max(CONST_F64_MIN, f64::max(input, CONST_F64_MAX));
+        let x27 = f64::min(CONST_F64_MAX, f64::min(input, CONST_F64_MIN));
+        let x28 = f64::max(f64::max(CONST_F64_MAX, input), CONST_F64_MIN);
+        let x29 = f64::min(f64::min(CONST_F64_MIN, input), CONST_F64_MAX);
+        let x30 = f64::max(CONST_F64_MIN, f64::max(CONST_F64_MAX, input));
+        let x31 = f64::min(CONST_F64_MAX, f64::min(CONST_F64_MIN, input));
+        let x32 = f64::min(CONST_F64_MAX, f64::min(CONST_F64_MIN, CONST_F64_MAX));
+    }
+}
+
+fn dont_tell_me_what_to_do() {
+    let (input, min, max) = (0, -2, 3);
+    let mut x_never = input;
+    #[allow(clippy::manual_clamp)]
+    if x_never < min {
+        x_never = min;
+    }
+    if x_never > max {
+        x_never = max;
+    }
+}
+
+/// Just to ensure this isn't const evaled
+fn cmp_min_max(input: i32) -> i32 {
+    input * 3
+}
diff --git a/tests/ui/manual_clamp.stderr b/tests/ui/manual_clamp.stderr
new file mode 100644
index 00000000000..25650483595
--- /dev/null
+++ b/tests/ui/manual_clamp.stderr
@@ -0,0 +1,375 @@
+error: clamp-like pattern without using clamp function
+  --> $DIR/manual_clamp.rs:76:5
+   |
+LL | /     if x9 < min {
+LL | |         x9 = min;
+LL | |     }
+LL | |     if x9 > max {
+LL | |         x9 = max;
+LL | |     }
+   | |_____^ help: replace with clamp: `x9 = x9.clamp(min, max);`
+   |
+   = note: `-D clippy::manual-clamp` implied by `-D warnings`
+   = note: clamp will panic if max < min
+
+error: clamp-like pattern without using clamp function
+  --> $DIR/manual_clamp.rs:91:5
+   |
+LL | /     if x11 > max {
+LL | |         x11 = max;
+LL | |     }
+LL | |     if x11 < min {
+LL | |         x11 = min;
+LL | |     }
+   | |_____^ help: replace with clamp: `x11 = x11.clamp(min, max);`
+   |
+   = note: clamp will panic if max < min
+
+error: clamp-like pattern without using clamp function
+  --> $DIR/manual_clamp.rs:99:5
+   |
+LL | /     if min > x12 {
+LL | |         x12 = min;
+LL | |     }
+LL | |     if max < x12 {
+LL | |         x12 = max;
+LL | |     }
+   | |_____^ help: replace with clamp: `x12 = x12.clamp(min, max);`
+   |
+   = note: clamp will panic if max < min
+
+error: clamp-like pattern without using clamp function
+  --> $DIR/manual_clamp.rs:107:5
+   |
+LL | /     if max < x13 {
+LL | |         x13 = max;
+LL | |     }
+LL | |     if min > x13 {
+LL | |         x13 = min;
+LL | |     }
+   | |_____^ help: replace with clamp: `x13 = x13.clamp(min, max);`
+   |
+   = note: clamp will panic if max < min
+
+error: clamp-like pattern without using clamp function
+  --> $DIR/manual_clamp.rs:161:5
+   |
+LL | /     if max < x33 {
+LL | |         x33 = max;
+LL | |     }
+LL | |     if min > x33 {
+LL | |         x33 = min;
+LL | |     }
+   | |_____^ help: replace with clamp: `x33 = x33.clamp(min, max);`
+   |
+   = note: clamp will panic if max < min
+
+error: clamp-like pattern without using clamp function
+  --> $DIR/manual_clamp.rs:21:14
+   |
+LL |       let x0 = if max < input {
+   |  ______________^
+LL | |         max
+LL | |     } else if min > input {
+LL | |         min
+LL | |     } else {
+LL | |         input
+LL | |     };
+   | |_____^ help: replace with clamp: `input.clamp(min, max)`
+   |
+   = note: clamp will panic if max < min
+
+error: clamp-like pattern without using clamp function
+  --> $DIR/manual_clamp.rs:29:14
+   |
+LL |       let x1 = if input > max {
+   |  ______________^
+LL | |         max
+LL | |     } else if input < min {
+LL | |         min
+LL | |     } else {
+LL | |         input
+LL | |     };
+   | |_____^ help: replace with clamp: `input.clamp(min, max)`
+   |
+   = note: clamp will panic if max < min
+
+error: clamp-like pattern without using clamp function
+  --> $DIR/manual_clamp.rs:37:14
+   |
+LL |       let x2 = if input < min {
+   |  ______________^
+LL | |         min
+LL | |     } else if input > max {
+LL | |         max
+LL | |     } else {
+LL | |         input
+LL | |     };
+   | |_____^ help: replace with clamp: `input.clamp(min, max)`
+   |
+   = note: clamp will panic if max < min
+
+error: clamp-like pattern without using clamp function
+  --> $DIR/manual_clamp.rs:45:14
+   |
+LL |       let x3 = if min > input {
+   |  ______________^
+LL | |         min
+LL | |     } else if max < input {
+LL | |         max
+LL | |     } else {
+LL | |         input
+LL | |     };
+   | |_____^ help: replace with clamp: `input.clamp(min, max)`
+   |
+   = note: clamp will panic if max < min
+
+error: clamp-like pattern without using clamp function
+  --> $DIR/manual_clamp.rs:53:14
+   |
+LL |     let x4 = input.max(min).min(max);
+   |              ^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(min, max)`
+   |
+   = note: clamp will panic if max < min
+
+error: clamp-like pattern without using clamp function
+  --> $DIR/manual_clamp.rs:55:14
+   |
+LL |     let x5 = input.min(max).max(min);
+   |              ^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(min, max)`
+   |
+   = note: clamp will panic if max < min
+
+error: clamp-like pattern without using clamp function
+  --> $DIR/manual_clamp.rs:57:14
+   |
+LL |       let x6 = match input {
+   |  ______________^
+LL | |         x if x > max => max,
+LL | |         x if x < min => min,
+LL | |         x => x,
+LL | |     };
+   | |_____^ help: replace with clamp: `input.clamp(min, max)`
+   |
+   = note: clamp will panic if max < min
+
+error: clamp-like pattern without using clamp function
+  --> $DIR/manual_clamp.rs:63:14
+   |
+LL |       let x7 = match input {
+   |  ______________^
+LL | |         x if x < min => min,
+LL | |         x if x > max => max,
+LL | |         x => x,
+LL | |     };
+   | |_____^ help: replace with clamp: `input.clamp(min, max)`
+   |
+   = note: clamp will panic if max < min
+
+error: clamp-like pattern without using clamp function
+  --> $DIR/manual_clamp.rs:69:14
+   |
+LL |       let x8 = match input {
+   |  ______________^
+LL | |         x if max < x => max,
+LL | |         x if min > x => min,
+LL | |         x => x,
+LL | |     };
+   | |_____^ help: replace with clamp: `input.clamp(min, max)`
+   |
+   = note: clamp will panic if max < min
+
+error: clamp-like pattern without using clamp function
+  --> $DIR/manual_clamp.rs:83:15
+   |
+LL |       let x10 = match input {
+   |  _______________^
+LL | |         x if min > x => min,
+LL | |         x if max < x => max,
+LL | |         x => x,
+LL | |     };
+   | |_____^ help: replace with clamp: `input.clamp(min, max)`
+   |
+   = note: clamp will panic if max < min
+
+error: clamp-like pattern without using clamp function
+  --> $DIR/manual_clamp.rs:114:15
+   |
+LL |       let x14 = if input > CONST_MAX {
+   |  _______________^
+LL | |         CONST_MAX
+LL | |     } else if input < CONST_MIN {
+LL | |         CONST_MIN
+LL | |     } else {
+LL | |         input
+LL | |     };
+   | |_____^ help: replace with clamp: `input.clamp(CONST_MIN, CONST_MAX)`
+   |
+   = note: clamp will panic if max < min
+
+error: clamp-like pattern without using clamp function
+  --> $DIR/manual_clamp.rs:123:19
+   |
+LL |           let x15 = if input > max {
+   |  ___________________^
+LL | |             max
+LL | |         } else if input < min {
+LL | |             min
+LL | |         } else {
+LL | |             input
+LL | |         };
+   | |_________^ help: replace with clamp: `input.clamp(min, max)`
+   |
+   = note: clamp will panic if max < min, min.is_nan(), or max.is_nan()
+   = note: clamp returns NaN if the input is NaN
+
+error: clamp-like pattern without using clamp function
+  --> $DIR/manual_clamp.rs:134:19
+   |
+LL |         let x16 = cmp_max(cmp_min(input, CONST_MAX), CONST_MIN);
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_MIN, CONST_MAX)`
+   |
+   = note: clamp will panic if max < min
+
+error: clamp-like pattern without using clamp function
+  --> $DIR/manual_clamp.rs:135:19
+   |
+LL |         let x17 = cmp_min(cmp_max(input, CONST_MIN), CONST_MAX);
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_MIN, CONST_MAX)`
+   |
+   = note: clamp will panic if max < min
+
+error: clamp-like pattern without using clamp function
+  --> $DIR/manual_clamp.rs:136:19
+   |
+LL |         let x18 = cmp_max(CONST_MIN, cmp_min(input, CONST_MAX));
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_MIN, CONST_MAX)`
+   |
+   = note: clamp will panic if max < min
+
+error: clamp-like pattern without using clamp function
+  --> $DIR/manual_clamp.rs:137:19
+   |
+LL |         let x19 = cmp_min(CONST_MAX, cmp_max(input, CONST_MIN));
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_MIN, CONST_MAX)`
+   |
+   = note: clamp will panic if max < min
+
+error: clamp-like pattern without using clamp function
+  --> $DIR/manual_clamp.rs:138:19
+   |
+LL |         let x20 = cmp_max(cmp_min(CONST_MAX, input), CONST_MIN);
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_MIN, CONST_MAX)`
+   |
+   = note: clamp will panic if max < min
+
+error: clamp-like pattern without using clamp function
+  --> $DIR/manual_clamp.rs:139:19
+   |
+LL |         let x21 = cmp_min(cmp_max(CONST_MIN, input), CONST_MAX);
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_MIN, CONST_MAX)`
+   |
+   = note: clamp will panic if max < min
+
+error: clamp-like pattern without using clamp function
+  --> $DIR/manual_clamp.rs:140:19
+   |
+LL |         let x22 = cmp_max(CONST_MIN, cmp_min(CONST_MAX, input));
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_MIN, CONST_MAX)`
+   |
+   = note: clamp will panic if max < min
+
+error: clamp-like pattern without using clamp function
+  --> $DIR/manual_clamp.rs:141:19
+   |
+LL |         let x23 = cmp_min(CONST_MAX, cmp_max(CONST_MIN, input));
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_MIN, CONST_MAX)`
+   |
+   = note: clamp will panic if max < min
+
+error: clamp-like pattern without using clamp function
+  --> $DIR/manual_clamp.rs:143:19
+   |
+LL |         let x24 = f64::max(f64::min(input, CONST_F64_MAX), CONST_F64_MIN);
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_F64_MIN, CONST_F64_MAX)`
+   |
+   = note: clamp will panic if max < min, min.is_nan(), or max.is_nan()
+   = note: clamp returns NaN if the input is NaN
+
+error: clamp-like pattern without using clamp function
+  --> $DIR/manual_clamp.rs:144:19
+   |
+LL |         let x25 = f64::min(f64::max(input, CONST_F64_MIN), CONST_F64_MAX);
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_F64_MIN, CONST_F64_MAX)`
+   |
+   = note: clamp will panic if max < min, min.is_nan(), or max.is_nan()
+   = note: clamp returns NaN if the input is NaN
+
+error: clamp-like pattern without using clamp function
+  --> $DIR/manual_clamp.rs:145:19
+   |
+LL |         let x26 = f64::max(CONST_F64_MIN, f64::min(input, CONST_F64_MAX));
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_F64_MIN, CONST_F64_MAX)`
+   |
+   = note: clamp will panic if max < min, min.is_nan(), or max.is_nan()
+   = note: clamp returns NaN if the input is NaN
+
+error: clamp-like pattern without using clamp function
+  --> $DIR/manual_clamp.rs:146:19
+   |
+LL |         let x27 = f64::min(CONST_F64_MAX, f64::max(input, CONST_F64_MIN));
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_F64_MIN, CONST_F64_MAX)`
+   |
+   = note: clamp will panic if max < min, min.is_nan(), or max.is_nan()
+   = note: clamp returns NaN if the input is NaN
+
+error: clamp-like pattern without using clamp function
+  --> $DIR/manual_clamp.rs:147:19
+   |
+LL |         let x28 = f64::max(f64::min(CONST_F64_MAX, input), CONST_F64_MIN);
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_F64_MIN, CONST_F64_MAX)`
+   |
+   = note: clamp will panic if max < min, min.is_nan(), or max.is_nan()
+   = note: clamp returns NaN if the input is NaN
+
+error: clamp-like pattern without using clamp function
+  --> $DIR/manual_clamp.rs:148:19
+   |
+LL |         let x29 = f64::min(f64::max(CONST_F64_MIN, input), CONST_F64_MAX);
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_F64_MIN, CONST_F64_MAX)`
+   |
+   = note: clamp will panic if max < min, min.is_nan(), or max.is_nan()
+   = note: clamp returns NaN if the input is NaN
+
+error: clamp-like pattern without using clamp function
+  --> $DIR/manual_clamp.rs:149:19
+   |
+LL |         let x30 = f64::max(CONST_F64_MIN, f64::min(CONST_F64_MAX, input));
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_F64_MIN, CONST_F64_MAX)`
+   |
+   = note: clamp will panic if max < min, min.is_nan(), or max.is_nan()
+   = note: clamp returns NaN if the input is NaN
+
+error: clamp-like pattern without using clamp function
+  --> $DIR/manual_clamp.rs:150:19
+   |
+LL |         let x31 = f64::min(CONST_F64_MAX, f64::max(CONST_F64_MIN, input));
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_F64_MIN, CONST_F64_MAX)`
+   |
+   = note: clamp will panic if max < min, min.is_nan(), or max.is_nan()
+   = note: clamp returns NaN if the input is NaN
+
+error: clamp-like pattern without using clamp function
+  --> $DIR/manual_clamp.rs:153:5
+   |
+LL | /     if x32 < min {
+LL | |         x32 = min;
+LL | |     } else if x32 > max {
+LL | |         x32 = max;
+LL | |     }
+   | |_____^ help: replace with clamp: `x32 = x32.clamp(min, max);`
+   |
+   = note: clamp will panic if max < min
+
+error: aborting due to 34 previous errors
+
diff --git a/tests/ui/min_max.rs b/tests/ui/min_max.rs
index b2bc97f4744..24e52afd691 100644
--- a/tests/ui/min_max.rs
+++ b/tests/ui/min_max.rs
@@ -1,4 +1,5 @@
 #![warn(clippy::all)]
+#![allow(clippy::manual_clamp)]
 
 use std::cmp::max as my_max;
 use std::cmp::min as my_min;
diff --git a/tests/ui/min_max.stderr b/tests/ui/min_max.stderr
index c70b77eabbd..069d9068657 100644
--- a/tests/ui/min_max.stderr
+++ b/tests/ui/min_max.stderr
@@ -1,5 +1,5 @@
 error: this `min`/`max` combination leads to constant result
-  --> $DIR/min_max.rs:23:5
+  --> $DIR/min_max.rs:24:5
    |
 LL |     min(1, max(3, x));
    |     ^^^^^^^^^^^^^^^^^
@@ -7,73 +7,73 @@ LL |     min(1, max(3, x));
    = note: `-D clippy::min-max` implied by `-D warnings`
 
 error: this `min`/`max` combination leads to constant result
-  --> $DIR/min_max.rs:24:5
+  --> $DIR/min_max.rs:25:5
    |
 LL |     min(max(3, x), 1);
    |     ^^^^^^^^^^^^^^^^^
 
 error: this `min`/`max` combination leads to constant result
-  --> $DIR/min_max.rs:25:5
+  --> $DIR/min_max.rs:26:5
    |
 LL |     max(min(x, 1), 3);
    |     ^^^^^^^^^^^^^^^^^
 
 error: this `min`/`max` combination leads to constant result
-  --> $DIR/min_max.rs:26:5
+  --> $DIR/min_max.rs:27:5
    |
 LL |     max(3, min(x, 1));
    |     ^^^^^^^^^^^^^^^^^
 
 error: this `min`/`max` combination leads to constant result
-  --> $DIR/min_max.rs:28:5
+  --> $DIR/min_max.rs:29:5
    |
 LL |     my_max(3, my_min(x, 1));
    |     ^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this `min`/`max` combination leads to constant result
-  --> $DIR/min_max.rs:38:5
+  --> $DIR/min_max.rs:39:5
    |
 LL |     min("Apple", max("Zoo", s));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this `min`/`max` combination leads to constant result
-  --> $DIR/min_max.rs:39:5
+  --> $DIR/min_max.rs:40:5
    |
 LL |     max(min(s, "Apple"), "Zoo");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this `min`/`max` combination leads to constant result
-  --> $DIR/min_max.rs:44:5
+  --> $DIR/min_max.rs:45:5
    |
 LL |     x.min(1).max(3);
    |     ^^^^^^^^^^^^^^^
 
 error: this `min`/`max` combination leads to constant result
-  --> $DIR/min_max.rs:45:5
+  --> $DIR/min_max.rs:46:5
    |
 LL |     x.max(3).min(1);
    |     ^^^^^^^^^^^^^^^
 
 error: this `min`/`max` combination leads to constant result
-  --> $DIR/min_max.rs:46:5
+  --> $DIR/min_max.rs:47:5
    |
 LL |     f.max(3f32).min(1f32);
    |     ^^^^^^^^^^^^^^^^^^^^^
 
 error: this `min`/`max` combination leads to constant result
-  --> $DIR/min_max.rs:52:5
+  --> $DIR/min_max.rs:53:5
    |
 LL |     max(x.min(1), 3);
    |     ^^^^^^^^^^^^^^^^
 
 error: this `min`/`max` combination leads to constant result
-  --> $DIR/min_max.rs:55:5
+  --> $DIR/min_max.rs:56:5
    |
 LL |     s.max("Zoo").min("Apple");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this `min`/`max` combination leads to constant result
-  --> $DIR/min_max.rs:56:5
+  --> $DIR/min_max.rs:57:5
    |
 LL |     s.min("Apple").max("Zoo");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/min_rust_version_attr.rs b/tests/ui/min_rust_version_attr.rs
index 44e407bd1ab..c4c6391bb4c 100644
--- a/tests/ui/min_rust_version_attr.rs
+++ b/tests/ui/min_rust_version_attr.rs
@@ -160,6 +160,17 @@ fn manual_rem_euclid() {
     let _: i32 = ((x % 4) + 4) % 4;
 }
 
+fn manual_clamp() {
+    let (input, min, max) = (0, -1, 2);
+    let _ = if input < min {
+        min
+    } else if input > max {
+        max
+    } else {
+        input
+    };
+}
+
 fn main() {
     filter_map_next();
     checked_conversion();
@@ -180,6 +191,7 @@ fn main() {
     err_expect();
     cast_abs_to_unsigned();
     manual_rem_euclid();
+    manual_clamp();
 }
 
 mod just_under_msrv {
diff --git a/tests/ui/min_rust_version_attr.stderr b/tests/ui/min_rust_version_attr.stderr
index b1c23b539ff..faabb0e4386 100644
--- a/tests/ui/min_rust_version_attr.stderr
+++ b/tests/ui/min_rust_version_attr.stderr
@@ -1,12 +1,12 @@
 error: stripping a prefix manually
-  --> $DIR/min_rust_version_attr.rs:204:24
+  --> $DIR/min_rust_version_attr.rs:216:24
    |
 LL |             assert_eq!(s["hello, ".len()..].to_uppercase(), "WORLD!");
    |                        ^^^^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::manual-strip` implied by `-D warnings`
 note: the prefix was tested here
-  --> $DIR/min_rust_version_attr.rs:203:9
+  --> $DIR/min_rust_version_attr.rs:215:9
    |
 LL |         if s.starts_with("hello, ") {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -17,13 +17,13 @@ LL ~             assert_eq!(<stripped>.to_uppercase(), "WORLD!");
    |
 
 error: stripping a prefix manually
-  --> $DIR/min_rust_version_attr.rs:216:24
+  --> $DIR/min_rust_version_attr.rs:228:24
    |
 LL |             assert_eq!(s["hello, ".len()..].to_uppercase(), "WORLD!");
    |                        ^^^^^^^^^^^^^^^^^^^^
    |
 note: the prefix was tested here
-  --> $DIR/min_rust_version_attr.rs:215:9
+  --> $DIR/min_rust_version_attr.rs:227:9
    |
 LL |         if s.starts_with("hello, ") {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From a834ac980066a294537ba0787a01e943a1b7a308 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Sat, 1 Oct 2022 22:25:01 +0000
Subject: Only run x86 asm doctests on x86

---
 clippy_lints/src/asm_syntax.rs | 4 ++++
 1 file changed, 4 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/asm_syntax.rs b/clippy_lints/src/asm_syntax.rs
index ad31d708f64..9717aa9e981 100644
--- a/clippy_lints/src/asm_syntax.rs
+++ b/clippy_lints/src/asm_syntax.rs
@@ -64,6 +64,7 @@ declare_clippy_lint! {
     ///
     /// ```rust,no_run
     /// # #![feature(asm)]
+    /// # #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
     /// # unsafe { let ptr = "".as_ptr();
     /// # use std::arch::asm;
     /// asm!("lea {}, [{}]", lateout(reg) _, in(reg) ptr);
@@ -72,6 +73,7 @@ declare_clippy_lint! {
     /// Use instead:
     /// ```rust,no_run
     /// # #![feature(asm)]
+    /// # #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
     /// # unsafe { let ptr = "".as_ptr();
     /// # use std::arch::asm;
     /// asm!("lea ({}), {}", in(reg) ptr, lateout(reg) _, options(att_syntax));
@@ -103,6 +105,7 @@ declare_clippy_lint! {
     ///
     /// ```rust,no_run
     /// # #![feature(asm)]
+    /// # #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
     /// # unsafe { let ptr = "".as_ptr();
     /// # use std::arch::asm;
     /// asm!("lea ({}), {}", in(reg) ptr, lateout(reg) _, options(att_syntax));
@@ -111,6 +114,7 @@ declare_clippy_lint! {
     /// Use instead:
     /// ```rust,no_run
     /// # #![feature(asm)]
+    /// # #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
     /// # unsafe { let ptr = "".as_ptr();
     /// # use std::arch::asm;
     /// asm!("lea {}, [{}]", lateout(reg) _, in(reg) ptr);
-- 
cgit 1.4.1-3-g733a5


From 52a68dc097cc8064a7464598bca959f2706aab18 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Sat, 1 Oct 2022 21:54:22 +0000
Subject: lint nested patterns and slice patterns in
 `needless_borrowed_reference`

---
 clippy_lints/src/manual_clamp.rs          |   6 +-
 clippy_lints/src/map_unit_fn.rs           |   4 +-
 clippy_lints/src/methods/manual_ok_or.rs  |   2 +-
 clippy_lints/src/needless_borrowed_ref.rs | 121 +++++++++++++++++++-----------
 src/docs/needless_borrowed_reference.txt  |  18 ++---
 tests/ui/needless_borrowed_ref.fixed      |  41 +++++++---
 tests/ui/needless_borrowed_ref.rs         |  41 +++++++---
 tests/ui/needless_borrowed_ref.stderr     | 121 +++++++++++++++++++++++++++++-
 8 files changed, 266 insertions(+), 88 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_clamp.rs b/clippy_lints/src/manual_clamp.rs
index ac5c24ee604..ece4df95505 100644
--- a/clippy_lints/src/manual_clamp.rs
+++ b/clippy_lints/src/manual_clamp.rs
@@ -324,7 +324,7 @@ fn is_call_max_min_pattern<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>)
         outer_arg: &'tcx Expr<'tcx>,
         span: Span,
     ) -> Option<ClampSuggestion<'tcx>> {
-        if let ExprKind::Call(inner_fn, &[ref first, ref second]) = &inner_call.kind
+        if let ExprKind::Call(inner_fn, [first, second]) = &inner_call.kind
             && let Some(inner_seg) = segment(cx, inner_fn)
             && let Some(outer_seg) = segment(cx, outer_fn)
         {
@@ -377,9 +377,7 @@ fn is_call_max_min_pattern<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>)
 /// # ;
 /// ```
 fn is_match_pattern<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> Option<ClampSuggestion<'tcx>> {
-    if let ExprKind::Match(value, &[ref first_arm, ref second_arm, ref last_arm], rustc_hir::MatchSource::Normal) =
-        &expr.kind
-    {
+    if let ExprKind::Match(value, [first_arm, second_arm, last_arm], rustc_hir::MatchSource::Normal) = &expr.kind {
         // Find possible min/max branches
         let minmax_values = |a: &'tcx Arm<'tcx>| {
             if let PatKind::Binding(_, var_hir_id, _, None) = &a.pat.kind
diff --git a/clippy_lints/src/map_unit_fn.rs b/clippy_lints/src/map_unit_fn.rs
index df5684541e9..32da37a862d 100644
--- a/clippy_lints/src/map_unit_fn.rs
+++ b/clippy_lints/src/map_unit_fn.rs
@@ -131,12 +131,12 @@ fn reduce_unit_expression<'a>(cx: &LateContext<'_>, expr: &'a hir::Expr<'_>) ->
         },
         hir::ExprKind::Block(block, _) => {
             match (block.stmts, block.expr.as_ref()) {
-                (&[], Some(inner_expr)) => {
+                ([], Some(inner_expr)) => {
                     // If block only contains an expression,
                     // reduce `{ X }` to `X`
                     reduce_unit_expression(cx, inner_expr)
                 },
-                (&[ref inner_stmt], None) => {
+                ([inner_stmt], None) => {
                     // If block only contains statements,
                     // reduce `{ X; }` to `X` or `X;`
                     match inner_stmt.kind {
diff --git a/clippy_lints/src/methods/manual_ok_or.rs b/clippy_lints/src/methods/manual_ok_or.rs
index c5c0ace7729..d9fb4382181 100644
--- a/clippy_lints/src/methods/manual_ok_or.rs
+++ b/clippy_lints/src/methods/manual_ok_or.rs
@@ -55,7 +55,7 @@ fn is_ok_wrapping(cx: &LateContext<'_>, map_expr: &Expr<'_>) -> bool {
         if let ExprKind::Closure(&Closure { body, .. }) = map_expr.kind;
         let body = cx.tcx.hir().body(body);
         if let PatKind::Binding(_, param_id, ..) = body.params[0].pat.kind;
-        if let ExprKind::Call(Expr { kind: ExprKind::Path(ok_path), .. }, &[ref ok_arg]) = body.value.kind;
+        if let ExprKind::Call(Expr { kind: ExprKind::Path(ok_path), .. }, [ok_arg]) = body.value.kind;
         if is_lang_ctor(cx, ok_path, ResultOk);
         then { path_to_local_id(ok_arg, param_id) } else { false }
     }
diff --git a/clippy_lints/src/needless_borrowed_ref.rs b/clippy_lints/src/needless_borrowed_ref.rs
index b8855e5adbf..10c3ff026b6 100644
--- a/clippy_lints/src/needless_borrowed_ref.rs
+++ b/clippy_lints/src/needless_borrowed_ref.rs
@@ -1,6 +1,4 @@
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::source::snippet_with_applicability;
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{BindingAnnotation, Mutability, Node, Pat, PatKind};
 use rustc_lint::{LateContext, LateLintPass};
@@ -8,36 +6,26 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for bindings that destructure a reference and borrow the inner
+    /// Checks for bindings that needlessly destructure a reference and borrow the inner
     /// value with `&ref`.
     ///
     /// ### Why is this bad?
     /// This pattern has no effect in almost all cases.
     ///
-    /// ### Known problems
-    /// In some cases, `&ref` is needed to avoid a lifetime mismatch error.
-    /// Example:
-    /// ```rust
-    /// fn foo(a: &Option<String>, b: &Option<String>) {
-    ///     match (a, b) {
-    ///         (None, &ref c) | (&ref c, None) => (),
-    ///         (&Some(ref c), _) => (),
-    ///     };
-    /// }
-    /// ```
-    ///
     /// ### Example
     /// ```rust
     /// let mut v = Vec::<String>::new();
-    /// # #[allow(unused)]
     /// v.iter_mut().filter(|&ref a| a.is_empty());
+    ///
+    /// if let &[ref first, ref second] = v.as_slice() {}
     /// ```
     ///
     /// Use instead:
     /// ```rust
     /// let mut v = Vec::<String>::new();
-    /// # #[allow(unused)]
     /// v.iter_mut().filter(|a| a.is_empty());
+    ///
+    /// if let [first, second] = v.as_slice() {}
     /// ```
     #[clippy::version = "pre 1.29.0"]
     pub NEEDLESS_BORROWED_REFERENCE,
@@ -54,34 +42,83 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessBorrowedRef {
             return;
         }
 
-        if_chain! {
-            // Only lint immutable refs, because `&mut ref T` may be useful.
-            if let PatKind::Ref(sub_pat, Mutability::Not) = pat.kind;
+        // Do not lint patterns that are part of an OR `|` pattern, the binding mode must match in all arms
+        for (_, node) in cx.tcx.hir().parent_iter(pat.hir_id) {
+            let Node::Pat(pat) = node else { break };
+
+            if matches!(pat.kind, PatKind::Or(_)) {
+                return;
+            }
+        }
+
+        // Only lint immutable refs, because `&mut ref T` may be useful.
+        let PatKind::Ref(sub_pat, Mutability::Not) = pat.kind else { return };
 
+        match sub_pat.kind {
             // Check sub_pat got a `ref` keyword (excluding `ref mut`).
-            if let PatKind::Binding(BindingAnnotation::REF, .., spanned_name, _) = sub_pat.kind;
-            let parent_id = cx.tcx.hir().get_parent_node(pat.hir_id);
-            if let Some(parent_node) = cx.tcx.hir().find(parent_id);
-            then {
-                // do not recurse within patterns, as they may have other references
-                // XXXManishearth we can relax this constraint if we only check patterns
-                // with a single ref pattern inside them
-                if let Node::Pat(_) = parent_node {
-                    return;
+            PatKind::Binding(BindingAnnotation::REF, _, ident, None) => {
+                span_lint_and_then(
+                    cx,
+                    NEEDLESS_BORROWED_REFERENCE,
+                    pat.span,
+                    "this pattern takes a reference on something that is being dereferenced",
+                    |diag| {
+                        // `&ref ident`
+                        //  ^^^^^
+                        let span = pat.span.until(ident.span);
+                        diag.span_suggestion_verbose(
+                            span,
+                            "try removing the `&ref` part",
+                            String::new(),
+                            Applicability::MachineApplicable,
+                        );
+                    },
+                );
+            },
+            // Slices where each element is `ref`: `&[ref a, ref b, ..., ref z]`
+            PatKind::Slice(
+                before,
+                None
+                | Some(Pat {
+                    kind: PatKind::Wild, ..
+                }),
+                after,
+            ) => {
+                let mut suggestions = Vec::new();
+
+                for element_pat in itertools::chain(before, after) {
+                    if let PatKind::Binding(BindingAnnotation::REF, _, ident, None) = element_pat.kind {
+                        // `&[..., ref ident, ...]`
+                        //         ^^^^
+                        let span = element_pat.span.until(ident.span);
+                        suggestions.push((span, String::new()));
+                    } else {
+                        return;
+                    }
                 }
-                let mut applicability = Applicability::MachineApplicable;
-                span_lint_and_then(cx, NEEDLESS_BORROWED_REFERENCE, pat.span,
-                                   "this pattern takes a reference on something that is being de-referenced",
-                                   |diag| {
-                                       let hint = snippet_with_applicability(cx, spanned_name.span, "..", &mut applicability).into_owned();
-                                       diag.span_suggestion(
-                                           pat.span,
-                                           "try removing the `&ref` part and just keep",
-                                           hint,
-                                           applicability,
-                                       );
-                                   });
-            }
+
+                if !suggestions.is_empty() {
+                    span_lint_and_then(
+                        cx,
+                        NEEDLESS_BORROWED_REFERENCE,
+                        pat.span,
+                        "dereferencing a slice pattern where every element takes a reference",
+                        |diag| {
+                            // `&[...]`
+                            //  ^
+                            let span = pat.span.until(sub_pat.span);
+                            suggestions.push((span, String::new()));
+
+                            diag.multipart_suggestion(
+                                "try removing the `&` and `ref` parts",
+                                suggestions,
+                                Applicability::MachineApplicable,
+                            );
+                        },
+                    );
+                }
+            },
+            _ => {},
         }
     }
 }
diff --git a/src/docs/needless_borrowed_reference.txt b/src/docs/needless_borrowed_reference.txt
index 55faa0cf571..152459ba1c9 100644
--- a/src/docs/needless_borrowed_reference.txt
+++ b/src/docs/needless_borrowed_reference.txt
@@ -1,30 +1,22 @@
 ### What it does
-Checks for bindings that destructure a reference and borrow the inner
+Checks for bindings that needlessly destructure a reference and borrow the inner
 value with `&ref`.
 
 ### Why is this bad?
 This pattern has no effect in almost all cases.
 
-### Known problems
-In some cases, `&ref` is needed to avoid a lifetime mismatch error.
-Example:
-```
-fn foo(a: &Option<String>, b: &Option<String>) {
-    match (a, b) {
-        (None, &ref c) | (&ref c, None) => (),
-        (&Some(ref c), _) => (),
-    };
-}
-```
-
 ### Example
 ```
 let mut v = Vec::<String>::new();
 v.iter_mut().filter(|&ref a| a.is_empty());
+
+if let &[ref first, ref second] = v.as_slice() {}
 ```
 
 Use instead:
 ```
 let mut v = Vec::<String>::new();
 v.iter_mut().filter(|a| a.is_empty());
+
+if let [first, second] = v.as_slice() {}
 ```
\ No newline at end of file
diff --git a/tests/ui/needless_borrowed_ref.fixed b/tests/ui/needless_borrowed_ref.fixed
index a0937a2c5f6..bcb4eb2dd48 100644
--- a/tests/ui/needless_borrowed_ref.fixed
+++ b/tests/ui/needless_borrowed_ref.fixed
@@ -1,17 +1,38 @@
 // run-rustfix
 
-#[warn(clippy::needless_borrowed_reference)]
-#[allow(unused_variables)]
-fn main() {
+#![warn(clippy::needless_borrowed_reference)]
+#![allow(unused, clippy::needless_borrow)]
+
+fn main() {}
+
+fn should_lint(array: [u8; 4], slice: &[u8], slice_of_refs: &[&u8], vec: Vec<u8>) {
     let mut v = Vec::<String>::new();
     let _ = v.iter_mut().filter(|a| a.is_empty());
-    //                            ^ should be linted
 
     let var = 3;
     let thingy = Some(&var);
-    if let Some(&ref v) = thingy {
-        //          ^ should be linted
-    }
+    if let Some(v) = thingy {}
+
+    if let &[a, ref b] = slice_of_refs {}
+
+    let [a, ..] = &array;
+    let [a, b, ..] = &array;
+
+    if let [a, b] = slice {}
+    if let [a, b] = &vec[..] {}
+
+    if let [a, b, ..] = slice {}
+    if let [a, .., b] = slice {}
+    if let [.., a, b] = slice {}
+}
+
+fn should_not_lint(array: [u8; 4], slice: &[u8], slice_of_refs: &[&u8], vec: Vec<u8>) {
+    if let [ref a] = slice {}
+    if let &[ref a, b] = slice {}
+    if let &[ref a, .., b] = slice {}
+
+    // must not be removed as variables must be bound consistently across | patterns
+    if let (&[ref a], _) | ([], ref a) = (slice_of_refs, &1u8) {}
 
     let mut var2 = 5;
     let thingy2 = Some(&mut var2);
@@ -28,17 +49,15 @@ fn main() {
     }
 }
 
-#[allow(dead_code)]
 enum Animal {
     Cat(u64),
     Dog(u64),
 }
 
-#[allow(unused_variables)]
-#[allow(dead_code)]
 fn foo(a: &Animal, b: &Animal) {
     match (a, b) {
-        (&Animal::Cat(v), &ref k) | (&ref k, &Animal::Cat(v)) => (), // lifetime mismatch error if there is no '&ref'
+        // lifetime mismatch error if there is no '&ref' before `feature(nll)` stabilization in 1.63
+        (&Animal::Cat(v), &ref k) | (&ref k, &Animal::Cat(v)) => (),
         //                  ^    and   ^ should **not** be linted
         (&Animal::Dog(ref a), &Animal::Dog(_)) => (), //              ^ should **not** be linted
     }
diff --git a/tests/ui/needless_borrowed_ref.rs b/tests/ui/needless_borrowed_ref.rs
index 500ac448f0d..f6de1a6d83d 100644
--- a/tests/ui/needless_borrowed_ref.rs
+++ b/tests/ui/needless_borrowed_ref.rs
@@ -1,17 +1,38 @@
 // run-rustfix
 
-#[warn(clippy::needless_borrowed_reference)]
-#[allow(unused_variables)]
-fn main() {
+#![warn(clippy::needless_borrowed_reference)]
+#![allow(unused, clippy::needless_borrow)]
+
+fn main() {}
+
+fn should_lint(array: [u8; 4], slice: &[u8], slice_of_refs: &[&u8], vec: Vec<u8>) {
     let mut v = Vec::<String>::new();
     let _ = v.iter_mut().filter(|&ref a| a.is_empty());
-    //                            ^ should be linted
 
     let var = 3;
     let thingy = Some(&var);
-    if let Some(&ref v) = thingy {
-        //          ^ should be linted
-    }
+    if let Some(&ref v) = thingy {}
+
+    if let &[&ref a, ref b] = slice_of_refs {}
+
+    let &[ref a, ..] = &array;
+    let &[ref a, ref b, ..] = &array;
+
+    if let &[ref a, ref b] = slice {}
+    if let &[ref a, ref b] = &vec[..] {}
+
+    if let &[ref a, ref b, ..] = slice {}
+    if let &[ref a, .., ref b] = slice {}
+    if let &[.., ref a, ref b] = slice {}
+}
+
+fn should_not_lint(array: [u8; 4], slice: &[u8], slice_of_refs: &[&u8], vec: Vec<u8>) {
+    if let [ref a] = slice {}
+    if let &[ref a, b] = slice {}
+    if let &[ref a, .., b] = slice {}
+
+    // must not be removed as variables must be bound consistently across | patterns
+    if let (&[ref a], _) | ([], ref a) = (slice_of_refs, &1u8) {}
 
     let mut var2 = 5;
     let thingy2 = Some(&mut var2);
@@ -28,17 +49,15 @@ fn main() {
     }
 }
 
-#[allow(dead_code)]
 enum Animal {
     Cat(u64),
     Dog(u64),
 }
 
-#[allow(unused_variables)]
-#[allow(dead_code)]
 fn foo(a: &Animal, b: &Animal) {
     match (a, b) {
-        (&Animal::Cat(v), &ref k) | (&ref k, &Animal::Cat(v)) => (), // lifetime mismatch error if there is no '&ref'
+        // lifetime mismatch error if there is no '&ref' before `feature(nll)` stabilization in 1.63
+        (&Animal::Cat(v), &ref k) | (&ref k, &Animal::Cat(v)) => (),
         //                  ^    and   ^ should **not** be linted
         (&Animal::Dog(ref a), &Animal::Dog(_)) => (), //              ^ should **not** be linted
     }
diff --git a/tests/ui/needless_borrowed_ref.stderr b/tests/ui/needless_borrowed_ref.stderr
index 0a5cfb3db0b..7453542e673 100644
--- a/tests/ui/needless_borrowed_ref.stderr
+++ b/tests/ui/needless_borrowed_ref.stderr
@@ -1,10 +1,123 @@
-error: this pattern takes a reference on something that is being de-referenced
-  --> $DIR/needless_borrowed_ref.rs:7:34
+error: this pattern takes a reference on something that is being dereferenced
+  --> $DIR/needless_borrowed_ref.rs:10:34
    |
 LL |     let _ = v.iter_mut().filter(|&ref a| a.is_empty());
-   |                                  ^^^^^^ help: try removing the `&ref` part and just keep: `a`
+   |                                  ^^^^^^
    |
    = note: `-D clippy::needless-borrowed-reference` implied by `-D warnings`
+help: try removing the `&ref` part
+   |
+LL -     let _ = v.iter_mut().filter(|&ref a| a.is_empty());
+LL +     let _ = v.iter_mut().filter(|a| a.is_empty());
+   |
+
+error: this pattern takes a reference on something that is being dereferenced
+  --> $DIR/needless_borrowed_ref.rs:14:17
+   |
+LL |     if let Some(&ref v) = thingy {}
+   |                 ^^^^^^
+   |
+help: try removing the `&ref` part
+   |
+LL -     if let Some(&ref v) = thingy {}
+LL +     if let Some(v) = thingy {}
+   |
+
+error: this pattern takes a reference on something that is being dereferenced
+  --> $DIR/needless_borrowed_ref.rs:16:14
+   |
+LL |     if let &[&ref a, ref b] = slice_of_refs {}
+   |              ^^^^^^
+   |
+help: try removing the `&ref` part
+   |
+LL -     if let &[&ref a, ref b] = slice_of_refs {}
+LL +     if let &[a, ref b] = slice_of_refs {}
+   |
+
+error: dereferencing a slice pattern where every element takes a reference
+  --> $DIR/needless_borrowed_ref.rs:18:9
+   |
+LL |     let &[ref a, ..] = &array;
+   |         ^^^^^^^^^^^^
+   |
+help: try removing the `&` and `ref` parts
+   |
+LL -     let &[ref a, ..] = &array;
+LL +     let [a, ..] = &array;
+   |
+
+error: dereferencing a slice pattern where every element takes a reference
+  --> $DIR/needless_borrowed_ref.rs:19:9
+   |
+LL |     let &[ref a, ref b, ..] = &array;
+   |         ^^^^^^^^^^^^^^^^^^^
+   |
+help: try removing the `&` and `ref` parts
+   |
+LL -     let &[ref a, ref b, ..] = &array;
+LL +     let [a, b, ..] = &array;
+   |
+
+error: dereferencing a slice pattern where every element takes a reference
+  --> $DIR/needless_borrowed_ref.rs:21:12
+   |
+LL |     if let &[ref a, ref b] = slice {}
+   |            ^^^^^^^^^^^^^^^
+   |
+help: try removing the `&` and `ref` parts
+   |
+LL -     if let &[ref a, ref b] = slice {}
+LL +     if let [a, b] = slice {}
+   |
+
+error: dereferencing a slice pattern where every element takes a reference
+  --> $DIR/needless_borrowed_ref.rs:22:12
+   |
+LL |     if let &[ref a, ref b] = &vec[..] {}
+   |            ^^^^^^^^^^^^^^^
+   |
+help: try removing the `&` and `ref` parts
+   |
+LL -     if let &[ref a, ref b] = &vec[..] {}
+LL +     if let [a, b] = &vec[..] {}
+   |
+
+error: dereferencing a slice pattern where every element takes a reference
+  --> $DIR/needless_borrowed_ref.rs:24:12
+   |
+LL |     if let &[ref a, ref b, ..] = slice {}
+   |            ^^^^^^^^^^^^^^^^^^^
+   |
+help: try removing the `&` and `ref` parts
+   |
+LL -     if let &[ref a, ref b, ..] = slice {}
+LL +     if let [a, b, ..] = slice {}
+   |
+
+error: dereferencing a slice pattern where every element takes a reference
+  --> $DIR/needless_borrowed_ref.rs:25:12
+   |
+LL |     if let &[ref a, .., ref b] = slice {}
+   |            ^^^^^^^^^^^^^^^^^^^
+   |
+help: try removing the `&` and `ref` parts
+   |
+LL -     if let &[ref a, .., ref b] = slice {}
+LL +     if let [a, .., b] = slice {}
+   |
+
+error: dereferencing a slice pattern where every element takes a reference
+  --> $DIR/needless_borrowed_ref.rs:26:12
+   |
+LL |     if let &[.., ref a, ref b] = slice {}
+   |            ^^^^^^^^^^^^^^^^^^^
+   |
+help: try removing the `&` and `ref` parts
+   |
+LL -     if let &[.., ref a, ref b] = slice {}
+LL +     if let [.., a, b] = slice {}
+   |
 
-error: aborting due to previous error
+error: aborting due to 10 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 90b446fd387a3c405b4dc3c5c2bd0bfce4a6fb21 Mon Sep 17 00:00:00 2001
From: kraktus <kraktus@users.noreply.github.com>
Date: Sun, 2 Oct 2022 14:30:26 +0200
Subject: [`unnecessary_cast`] add parenthesis when negative number uses a
 method

---
 clippy_lints/src/casts/unnecessary_cast.rs | 33 ++++++++++++++++++++++--------
 tests/ui/unnecessary_cast.fixed            |  6 ++++++
 tests/ui/unnecessary_cast.rs               |  6 ++++++
 tests/ui/unnecessary_cast.stderr           | 14 ++++++++++++-
 4 files changed, 50 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/unnecessary_cast.rs b/clippy_lints/src/casts/unnecessary_cast.rs
index ea29f5d12c6..031cedb9072 100644
--- a/clippy_lints/src/casts/unnecessary_cast.rs
+++ b/clippy_lints/src/casts/unnecessary_cast.rs
@@ -1,4 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::get_parent_expr;
 use clippy_utils::numeric_literal::NumericLiteral;
 use clippy_utils::source::snippet_opt;
 use if_chain::if_chain;
@@ -85,22 +86,38 @@ pub(super) fn check<'tcx>(
     false
 }
 
-fn lint_unnecessary_cast(cx: &LateContext<'_>, expr: &Expr<'_>, literal_str: &str, cast_from: Ty<'_>, cast_to: Ty<'_>) {
+fn lint_unnecessary_cast(
+    cx: &LateContext<'_>,
+    expr: &Expr<'_>,
+    raw_literal_str: &str,
+    cast_from: Ty<'_>,
+    cast_to: Ty<'_>,
+) {
     let literal_kind_name = if cast_from.is_integral() { "integer" } else { "float" };
-    let replaced_literal;
-    let matchless = if literal_str.contains(['(', ')']) {
-        replaced_literal = literal_str.replace(['(', ')'], "");
-        &replaced_literal
-    } else {
-        literal_str
+    // first we remove all matches so `-(1)` become `-1`, and remove trailing dots, so `1.` become `1`
+    let literal_str = raw_literal_str
+        .replace(['(', ')'], "")
+        .trim_end_matches('.')
+        .to_string();
+    // we know need to check if the parent is a method call, to add parenthesis accordingly (eg:
+    // (-1).foo() instead of -1.foo())
+    let sugg = if let Some(parent_expr) = get_parent_expr(cx, expr)
+        && let ExprKind::MethodCall(..) = parent_expr.kind
+        && literal_str.starts_with('-')
+        {
+            format!("({literal_str}_{cast_to})")
+
+        } else {
+            format!("{literal_str}_{cast_to}")
     };
+
     span_lint_and_sugg(
         cx,
         UNNECESSARY_CAST,
         expr.span,
         &format!("casting {literal_kind_name} literal to `{cast_to}` is unnecessary"),
         "try",
-        format!("{}_{cast_to}", matchless.trim_end_matches('.')),
+        sugg,
         Applicability::MachineApplicable,
     );
 }
diff --git a/tests/ui/unnecessary_cast.fixed b/tests/ui/unnecessary_cast.fixed
index ee9f157342d..70ec3e94380 100644
--- a/tests/ui/unnecessary_cast.fixed
+++ b/tests/ui/unnecessary_cast.fixed
@@ -97,4 +97,10 @@ mod fixable {
 
         let _ = -(1 + 1) as i64;
     }
+
+    fn issue_9563() {
+        let _: f64 = (-8.0_f64).exp();
+        #[allow(clippy::precedence)]
+        let _: f64 = -8.0_f64.exp(); // should suggest `-8.0_f64.exp()` here not to change code behavior
+    }
 }
diff --git a/tests/ui/unnecessary_cast.rs b/tests/ui/unnecessary_cast.rs
index 5b70412424c..36c1a87fab6 100644
--- a/tests/ui/unnecessary_cast.rs
+++ b/tests/ui/unnecessary_cast.rs
@@ -97,4 +97,10 @@ mod fixable {
 
         let _ = -(1 + 1) as i64;
     }
+
+    fn issue_9563() {
+        let _: f64 = (-8.0 as f64).exp();
+        #[allow(clippy::precedence)]
+        let _: f64 = -(8.0 as f64).exp(); // should suggest `-8.0_f64.exp()` here not to change code behavior
+    }
 }
diff --git a/tests/ui/unnecessary_cast.stderr b/tests/ui/unnecessary_cast.stderr
index f7829ff3b0e..a52b92c339c 100644
--- a/tests/ui/unnecessary_cast.stderr
+++ b/tests/ui/unnecessary_cast.stderr
@@ -162,5 +162,17 @@ error: casting integer literal to `i64` is unnecessary
 LL |         let _: i64 = -(1) as i64;
    |                      ^^^^^^^^^^^ help: try: `-1_i64`
 
-error: aborting due to 27 previous errors
+error: casting float literal to `f64` is unnecessary
+  --> $DIR/unnecessary_cast.rs:102:22
+   |
+LL |         let _: f64 = (-8.0 as f64).exp();
+   |                      ^^^^^^^^^^^^^ help: try: `(-8.0_f64)`
+
+error: casting float literal to `f64` is unnecessary
+  --> $DIR/unnecessary_cast.rs:104:23
+   |
+LL |         let _: f64 = -(8.0 as f64).exp(); // should suggest `-8.0_f64.exp()` here not to change code behavior
+   |                       ^^^^^^^^^^^^ help: try: `8.0_f64`
+
+error: aborting due to 29 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 2c04c1a188124402e85d78bc78c4e07bf87014d0 Mon Sep 17 00:00:00 2001
From: kraktus <kraktus@users.noreply.github.com>
Date: Wed, 14 Sep 2022 11:58:41 +0200
Subject: [`manual_assert`]: Preserve comments in the suggestion

---
 clippy_lints/src/manual_assert.rs         | 40 +++++++++-----
 clippy_utils/src/lib.rs                   | 23 ++++++++
 tests/ui/manual_assert.edition2018.fixed  | 16 +++++-
 tests/ui/manual_assert.edition2018.stderr | 90 +++++++++++++++++++++++++------
 tests/ui/manual_assert.edition2021.fixed  | 16 +++++-
 tests/ui/manual_assert.edition2021.stderr | 90 +++++++++++++++++++++++++------
 tests/ui/manual_assert.rs                 | 13 +++++
 7 files changed, 237 insertions(+), 51 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_assert.rs b/clippy_lints/src/manual_assert.rs
index 26b53ab5d68..9934c06e723 100644
--- a/clippy_lints/src/manual_assert.rs
+++ b/clippy_lints/src/manual_assert.rs
@@ -1,9 +1,10 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
+use crate::rustc_lint::LintContext;
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::macros::{root_macro_call, FormatArgsExpn};
 use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::{peel_blocks_with_stmt, sugg};
+use clippy_utils::{peel_blocks_with_stmt, span_extract_comment, sugg};
 use rustc_errors::Applicability;
-use rustc_hir::{Expr, ExprKind, UnOp};
+use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::sym;
@@ -50,20 +51,33 @@ impl<'tcx> LateLintPass<'tcx> for ManualAssert {
                 let mut applicability = Applicability::MachineApplicable;
                 let format_args_snip = snippet_with_applicability(cx, format_args.inputs_span(), "..", &mut applicability);
                 let cond = cond.peel_drop_temps();
-                let (cond, not) = match cond.kind {
-                    ExprKind::Unary(UnOp::Not, e) => (e, ""),
-                    _ => (cond, "!"),
-                };
-                let cond_sugg = sugg::Sugg::hir_with_applicability(cx, cond, "..", &mut applicability).maybe_par();
-                let sugg = format!("assert!({not}{cond_sugg}, {format_args_snip});");
-                span_lint_and_sugg(
+                let mut comments = span_extract_comment(cx.sess().source_map(), expr.span);
+                if !comments.is_empty() {
+                    comments += "\n";
+                }
+                // we need to negate the <cond> expression because `assert!` panics when <cond> is `false`, wherease original pattern panicked when evaluating to `true`
+                let cond_sugg = !sugg::Sugg::hir_with_applicability(cx, cond, "..", &mut applicability);
+                let sugg = format!("assert!({cond_sugg}, {format_args_snip});");
+                // we show to the user the suggestion without the comments, but when applicating the fix, include the comments in the block
+                span_lint_and_then(
                     cx,
                     MANUAL_ASSERT,
                     expr.span,
                     "only a `panic!` in `if`-then statement",
-                    "try",
-                    sugg,
-                    Applicability::MachineApplicable,
+                    |diag| {
+                        // comments can be noisy, do not show them to the user
+                        diag.tool_only_span_suggestion(
+                                    expr.span.shrink_to_lo(),
+                                    "add comments back",
+                                    comments,
+                                    applicability);
+                        diag.span_suggestion(
+                                    expr.span,
+                                    "try instead",
+                                    sugg,
+                                    applicability);
+                                     }
+
                 );
             }
         }
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index c2c52d08a3c..d67ceaec035 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -2295,6 +2295,29 @@ pub fn span_contains_comment(sm: &SourceMap, span: Span) -> bool {
     });
 }
 
+/// Return all the comments a given span contains
+/// Comments are returned wrapped with their relevant delimiters
+pub fn span_extract_comment(sm: &SourceMap, span: Span) -> String {
+    let snippet = sm.span_to_snippet(span).unwrap_or_default();
+    let mut comments_buf: Vec<String> = Vec::new();
+    let mut index: usize = 0;
+
+    for token in tokenize(&snippet) {
+        let token_range = index..(index + token.len as usize);
+        index += token.len as usize;
+        match token.kind {
+            TokenKind::BlockComment { .. } | TokenKind::LineComment { .. } => {
+                if let Some(comment) = snippet.get(token_range) {
+                    comments_buf.push(comment.to_string());
+                }
+            },
+            _ => (),
+        }
+    }
+
+    comments_buf.join("\n")
+}
+
 macro_rules! op_utils {
     ($($name:ident $assign:ident)*) => {
         /// Binary operation traits like `LangItem::Add`
diff --git a/tests/ui/manual_assert.edition2018.fixed b/tests/ui/manual_assert.edition2018.fixed
index 65598f1eacc..b5ccc07e49e 100644
--- a/tests/ui/manual_assert.edition2018.fixed
+++ b/tests/ui/manual_assert.edition2018.fixed
@@ -5,6 +5,7 @@
 
 #![warn(clippy::manual_assert)]
 #![allow(clippy::nonminimal_bool)]
+#![allow(dead_code)]
 
 macro_rules! one {
     () => {
@@ -27,8 +28,8 @@ fn main() {
     {
         panic!("qaqaq{:?}", a);
     }
-    assert!(a.is_empty(), "qaqaq{:?}", a);
-    assert!(a.is_empty(), "qwqwq");
+    assert!(!(!a.is_empty()), "qaqaq{:?}", a);
+    assert!(!(!a.is_empty()), "qwqwq");
     if a.len() == 3 {
         println!("qwq");
         println!("qwq");
@@ -50,3 +51,14 @@ fn main() {
     assert!(!(a.is_empty() || !b.is_empty()), "panic5");
     assert!(!a.is_empty(), "with expansion {}", one!());
 }
+
+fn issue7730() {
+    // Suggestion should preserve comment
+    // comment
+/* this is a
+        multiline
+        comment */
+/// Doc comment
+// comment after `panic!`
+assert!(!true, "panic with comment");
+}
diff --git a/tests/ui/manual_assert.edition2018.stderr b/tests/ui/manual_assert.edition2018.stderr
index a0f31afd6eb..df22e0114be 100644
--- a/tests/ui/manual_assert.edition2018.stderr
+++ b/tests/ui/manual_assert.edition2018.stderr
@@ -1,68 +1,124 @@
 error: only a `panic!` in `if`-then statement
-  --> $DIR/manual_assert.rs:30:5
+  --> $DIR/manual_assert.rs:31:5
    |
 LL | /     if !a.is_empty() {
 LL | |         panic!("qaqaq{:?}", a);
 LL | |     }
-   | |_____^ help: try: `assert!(a.is_empty(), "qaqaq{:?}", a);`
+   | |_____^
    |
    = note: `-D clippy::manual-assert` implied by `-D warnings`
+help: try instead
+   |
+LL |     assert!(!(!a.is_empty()), "qaqaq{:?}", a);
+   |
 
 error: only a `panic!` in `if`-then statement
-  --> $DIR/manual_assert.rs:33:5
+  --> $DIR/manual_assert.rs:34:5
    |
 LL | /     if !a.is_empty() {
 LL | |         panic!("qwqwq");
 LL | |     }
-   | |_____^ help: try: `assert!(a.is_empty(), "qwqwq");`
+   | |_____^
+   |
+help: try instead
+   |
+LL |     assert!(!(!a.is_empty()), "qwqwq");
+   |
 
 error: only a `panic!` in `if`-then statement
-  --> $DIR/manual_assert.rs:50:5
+  --> $DIR/manual_assert.rs:51:5
    |
 LL | /     if b.is_empty() {
 LL | |         panic!("panic1");
 LL | |     }
-   | |_____^ help: try: `assert!(!b.is_empty(), "panic1");`
+   | |_____^
+   |
+help: try instead
+   |
+LL |     assert!(!b.is_empty(), "panic1");
+   |
 
 error: only a `panic!` in `if`-then statement
-  --> $DIR/manual_assert.rs:53:5
+  --> $DIR/manual_assert.rs:54:5
    |
 LL | /     if b.is_empty() && a.is_empty() {
 LL | |         panic!("panic2");
 LL | |     }
-   | |_____^ help: try: `assert!(!(b.is_empty() && a.is_empty()), "panic2");`
+   | |_____^
+   |
+help: try instead
+   |
+LL |     assert!(!(b.is_empty() && a.is_empty()), "panic2");
+   |
 
 error: only a `panic!` in `if`-then statement
-  --> $DIR/manual_assert.rs:56:5
+  --> $DIR/manual_assert.rs:57:5
    |
 LL | /     if a.is_empty() && !b.is_empty() {
 LL | |         panic!("panic3");
 LL | |     }
-   | |_____^ help: try: `assert!(!(a.is_empty() && !b.is_empty()), "panic3");`
+   | |_____^
+   |
+help: try instead
+   |
+LL |     assert!(!(a.is_empty() && !b.is_empty()), "panic3");
+   |
 
 error: only a `panic!` in `if`-then statement
-  --> $DIR/manual_assert.rs:59:5
+  --> $DIR/manual_assert.rs:60:5
    |
 LL | /     if b.is_empty() || a.is_empty() {
 LL | |         panic!("panic4");
 LL | |     }
-   | |_____^ help: try: `assert!(!(b.is_empty() || a.is_empty()), "panic4");`
+   | |_____^
+   |
+help: try instead
+   |
+LL |     assert!(!(b.is_empty() || a.is_empty()), "panic4");
+   |
 
 error: only a `panic!` in `if`-then statement
-  --> $DIR/manual_assert.rs:62:5
+  --> $DIR/manual_assert.rs:63:5
    |
 LL | /     if a.is_empty() || !b.is_empty() {
 LL | |         panic!("panic5");
 LL | |     }
-   | |_____^ help: try: `assert!(!(a.is_empty() || !b.is_empty()), "panic5");`
+   | |_____^
+   |
+help: try instead
+   |
+LL |     assert!(!(a.is_empty() || !b.is_empty()), "panic5");
+   |
 
 error: only a `panic!` in `if`-then statement
-  --> $DIR/manual_assert.rs:65:5
+  --> $DIR/manual_assert.rs:66:5
    |
 LL | /     if a.is_empty() {
 LL | |         panic!("with expansion {}", one!())
 LL | |     }
-   | |_____^ help: try: `assert!(!a.is_empty(), "with expansion {}", one!());`
+   | |_____^
+   |
+help: try instead
+   |
+LL |     assert!(!a.is_empty(), "with expansion {}", one!());
+   |
+
+error: only a `panic!` in `if`-then statement
+  --> $DIR/manual_assert.rs:73:5
+   |
+LL | /     if true {
+LL | |         // comment
+LL | |         /* this is a
+LL | |         multiline
+...  |
+LL | |         panic!("panic with comment") // comment after `panic!`
+LL | |     }
+   | |_____^
+   |
+help: try instead
+   |
+LL |     assert!(!true, "panic with comment");
+   |
 
-error: aborting due to 8 previous errors
+error: aborting due to 9 previous errors
 
diff --git a/tests/ui/manual_assert.edition2021.fixed b/tests/ui/manual_assert.edition2021.fixed
index 65598f1eacc..b5ccc07e49e 100644
--- a/tests/ui/manual_assert.edition2021.fixed
+++ b/tests/ui/manual_assert.edition2021.fixed
@@ -5,6 +5,7 @@
 
 #![warn(clippy::manual_assert)]
 #![allow(clippy::nonminimal_bool)]
+#![allow(dead_code)]
 
 macro_rules! one {
     () => {
@@ -27,8 +28,8 @@ fn main() {
     {
         panic!("qaqaq{:?}", a);
     }
-    assert!(a.is_empty(), "qaqaq{:?}", a);
-    assert!(a.is_empty(), "qwqwq");
+    assert!(!(!a.is_empty()), "qaqaq{:?}", a);
+    assert!(!(!a.is_empty()), "qwqwq");
     if a.len() == 3 {
         println!("qwq");
         println!("qwq");
@@ -50,3 +51,14 @@ fn main() {
     assert!(!(a.is_empty() || !b.is_empty()), "panic5");
     assert!(!a.is_empty(), "with expansion {}", one!());
 }
+
+fn issue7730() {
+    // Suggestion should preserve comment
+    // comment
+/* this is a
+        multiline
+        comment */
+/// Doc comment
+// comment after `panic!`
+assert!(!true, "panic with comment");
+}
diff --git a/tests/ui/manual_assert.edition2021.stderr b/tests/ui/manual_assert.edition2021.stderr
index a0f31afd6eb..df22e0114be 100644
--- a/tests/ui/manual_assert.edition2021.stderr
+++ b/tests/ui/manual_assert.edition2021.stderr
@@ -1,68 +1,124 @@
 error: only a `panic!` in `if`-then statement
-  --> $DIR/manual_assert.rs:30:5
+  --> $DIR/manual_assert.rs:31:5
    |
 LL | /     if !a.is_empty() {
 LL | |         panic!("qaqaq{:?}", a);
 LL | |     }
-   | |_____^ help: try: `assert!(a.is_empty(), "qaqaq{:?}", a);`
+   | |_____^
    |
    = note: `-D clippy::manual-assert` implied by `-D warnings`
+help: try instead
+   |
+LL |     assert!(!(!a.is_empty()), "qaqaq{:?}", a);
+   |
 
 error: only a `panic!` in `if`-then statement
-  --> $DIR/manual_assert.rs:33:5
+  --> $DIR/manual_assert.rs:34:5
    |
 LL | /     if !a.is_empty() {
 LL | |         panic!("qwqwq");
 LL | |     }
-   | |_____^ help: try: `assert!(a.is_empty(), "qwqwq");`
+   | |_____^
+   |
+help: try instead
+   |
+LL |     assert!(!(!a.is_empty()), "qwqwq");
+   |
 
 error: only a `panic!` in `if`-then statement
-  --> $DIR/manual_assert.rs:50:5
+  --> $DIR/manual_assert.rs:51:5
    |
 LL | /     if b.is_empty() {
 LL | |         panic!("panic1");
 LL | |     }
-   | |_____^ help: try: `assert!(!b.is_empty(), "panic1");`
+   | |_____^
+   |
+help: try instead
+   |
+LL |     assert!(!b.is_empty(), "panic1");
+   |
 
 error: only a `panic!` in `if`-then statement
-  --> $DIR/manual_assert.rs:53:5
+  --> $DIR/manual_assert.rs:54:5
    |
 LL | /     if b.is_empty() && a.is_empty() {
 LL | |         panic!("panic2");
 LL | |     }
-   | |_____^ help: try: `assert!(!(b.is_empty() && a.is_empty()), "panic2");`
+   | |_____^
+   |
+help: try instead
+   |
+LL |     assert!(!(b.is_empty() && a.is_empty()), "panic2");
+   |
 
 error: only a `panic!` in `if`-then statement
-  --> $DIR/manual_assert.rs:56:5
+  --> $DIR/manual_assert.rs:57:5
    |
 LL | /     if a.is_empty() && !b.is_empty() {
 LL | |         panic!("panic3");
 LL | |     }
-   | |_____^ help: try: `assert!(!(a.is_empty() && !b.is_empty()), "panic3");`
+   | |_____^
+   |
+help: try instead
+   |
+LL |     assert!(!(a.is_empty() && !b.is_empty()), "panic3");
+   |
 
 error: only a `panic!` in `if`-then statement
-  --> $DIR/manual_assert.rs:59:5
+  --> $DIR/manual_assert.rs:60:5
    |
 LL | /     if b.is_empty() || a.is_empty() {
 LL | |         panic!("panic4");
 LL | |     }
-   | |_____^ help: try: `assert!(!(b.is_empty() || a.is_empty()), "panic4");`
+   | |_____^
+   |
+help: try instead
+   |
+LL |     assert!(!(b.is_empty() || a.is_empty()), "panic4");
+   |
 
 error: only a `panic!` in `if`-then statement
-  --> $DIR/manual_assert.rs:62:5
+  --> $DIR/manual_assert.rs:63:5
    |
 LL | /     if a.is_empty() || !b.is_empty() {
 LL | |         panic!("panic5");
 LL | |     }
-   | |_____^ help: try: `assert!(!(a.is_empty() || !b.is_empty()), "panic5");`
+   | |_____^
+   |
+help: try instead
+   |
+LL |     assert!(!(a.is_empty() || !b.is_empty()), "panic5");
+   |
 
 error: only a `panic!` in `if`-then statement
-  --> $DIR/manual_assert.rs:65:5
+  --> $DIR/manual_assert.rs:66:5
    |
 LL | /     if a.is_empty() {
 LL | |         panic!("with expansion {}", one!())
 LL | |     }
-   | |_____^ help: try: `assert!(!a.is_empty(), "with expansion {}", one!());`
+   | |_____^
+   |
+help: try instead
+   |
+LL |     assert!(!a.is_empty(), "with expansion {}", one!());
+   |
+
+error: only a `panic!` in `if`-then statement
+  --> $DIR/manual_assert.rs:73:5
+   |
+LL | /     if true {
+LL | |         // comment
+LL | |         /* this is a
+LL | |         multiline
+...  |
+LL | |         panic!("panic with comment") // comment after `panic!`
+LL | |     }
+   | |_____^
+   |
+help: try instead
+   |
+LL |     assert!(!true, "panic with comment");
+   |
 
-error: aborting due to 8 previous errors
+error: aborting due to 9 previous errors
 
diff --git a/tests/ui/manual_assert.rs b/tests/ui/manual_assert.rs
index 4d2706dd621..e9dd81a758a 100644
--- a/tests/ui/manual_assert.rs
+++ b/tests/ui/manual_assert.rs
@@ -5,6 +5,7 @@
 
 #![warn(clippy::manual_assert)]
 #![allow(clippy::nonminimal_bool)]
+#![allow(dead_code)]
 
 macro_rules! one {
     () => {
@@ -66,3 +67,15 @@ fn main() {
         panic!("with expansion {}", one!())
     }
 }
+
+fn issue7730() {
+    // Suggestion should preserve comment
+    if true {
+        // comment
+        /* this is a
+        multiline
+        comment */
+        /// Doc comment
+        panic!("panic with comment") // comment after `panic!`
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From a35734c172ba95a6d8758c7c5bb6601bcd3a5485 Mon Sep 17 00:00:00 2001
From: kraktus <kraktus@users.noreply.github.com>
Date: Fri, 16 Sep 2022 21:38:56 +0200
Subject: revert `manual_assert` suggestion refactor

Because `Sugg` helper does not simplify multiple negations
---
 clippy_lints/src/manual_assert.rs         | 11 +++++++----
 tests/ui/manual_assert.edition2018.fixed  |  4 ++--
 tests/ui/manual_assert.edition2018.stderr |  4 ++--
 tests/ui/manual_assert.edition2021.fixed  |  4 ++--
 tests/ui/manual_assert.edition2021.stderr |  4 ++--
 5 files changed, 15 insertions(+), 12 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_assert.rs b/clippy_lints/src/manual_assert.rs
index 9934c06e723..cbc9c4ca6ad 100644
--- a/clippy_lints/src/manual_assert.rs
+++ b/clippy_lints/src/manual_assert.rs
@@ -4,7 +4,7 @@ use clippy_utils::macros::{root_macro_call, FormatArgsExpn};
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::{peel_blocks_with_stmt, span_extract_comment, sugg};
 use rustc_errors::Applicability;
-use rustc_hir::{Expr, ExprKind};
+use rustc_hir::{Expr, ExprKind, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::sym;
@@ -55,9 +55,12 @@ impl<'tcx> LateLintPass<'tcx> for ManualAssert {
                 if !comments.is_empty() {
                     comments += "\n";
                 }
-                // we need to negate the <cond> expression because `assert!` panics when <cond> is `false`, wherease original pattern panicked when evaluating to `true`
-                let cond_sugg = !sugg::Sugg::hir_with_applicability(cx, cond, "..", &mut applicability);
-                let sugg = format!("assert!({cond_sugg}, {format_args_snip});");
+                let (cond, not) = match cond.kind {
+                     ExprKind::Unary(UnOp::Not, e) => (e, ""),
+                     _ => (cond, "!"),
+                 };
+                let cond_sugg = sugg::Sugg::hir_with_applicability(cx, cond, "..", &mut applicability).maybe_par();
+                let sugg = format!("assert!({not}{cond_sugg}, {format_args_snip});");
                 // we show to the user the suggestion without the comments, but when applicating the fix, include the comments in the block
                 span_lint_and_then(
                     cx,
diff --git a/tests/ui/manual_assert.edition2018.fixed b/tests/ui/manual_assert.edition2018.fixed
index b5ccc07e49e..81e38e1bf79 100644
--- a/tests/ui/manual_assert.edition2018.fixed
+++ b/tests/ui/manual_assert.edition2018.fixed
@@ -28,8 +28,8 @@ fn main() {
     {
         panic!("qaqaq{:?}", a);
     }
-    assert!(!(!a.is_empty()), "qaqaq{:?}", a);
-    assert!(!(!a.is_empty()), "qwqwq");
+    assert!(a.is_empty(), "qaqaq{:?}", a);
+    assert!(a.is_empty(), "qwqwq");
     if a.len() == 3 {
         println!("qwq");
         println!("qwq");
diff --git a/tests/ui/manual_assert.edition2018.stderr b/tests/ui/manual_assert.edition2018.stderr
index df22e0114be..e71bf428382 100644
--- a/tests/ui/manual_assert.edition2018.stderr
+++ b/tests/ui/manual_assert.edition2018.stderr
@@ -9,7 +9,7 @@ LL | |     }
    = note: `-D clippy::manual-assert` implied by `-D warnings`
 help: try instead
    |
-LL |     assert!(!(!a.is_empty()), "qaqaq{:?}", a);
+LL |     assert!(a.is_empty(), "qaqaq{:?}", a);
    |
 
 error: only a `panic!` in `if`-then statement
@@ -22,7 +22,7 @@ LL | |     }
    |
 help: try instead
    |
-LL |     assert!(!(!a.is_empty()), "qwqwq");
+LL |     assert!(a.is_empty(), "qwqwq");
    |
 
 error: only a `panic!` in `if`-then statement
diff --git a/tests/ui/manual_assert.edition2021.fixed b/tests/ui/manual_assert.edition2021.fixed
index b5ccc07e49e..81e38e1bf79 100644
--- a/tests/ui/manual_assert.edition2021.fixed
+++ b/tests/ui/manual_assert.edition2021.fixed
@@ -28,8 +28,8 @@ fn main() {
     {
         panic!("qaqaq{:?}", a);
     }
-    assert!(!(!a.is_empty()), "qaqaq{:?}", a);
-    assert!(!(!a.is_empty()), "qwqwq");
+    assert!(a.is_empty(), "qaqaq{:?}", a);
+    assert!(a.is_empty(), "qwqwq");
     if a.len() == 3 {
         println!("qwq");
         println!("qwq");
diff --git a/tests/ui/manual_assert.edition2021.stderr b/tests/ui/manual_assert.edition2021.stderr
index df22e0114be..e71bf428382 100644
--- a/tests/ui/manual_assert.edition2021.stderr
+++ b/tests/ui/manual_assert.edition2021.stderr
@@ -9,7 +9,7 @@ LL | |     }
    = note: `-D clippy::manual-assert` implied by `-D warnings`
 help: try instead
    |
-LL |     assert!(!(!a.is_empty()), "qaqaq{:?}", a);
+LL |     assert!(a.is_empty(), "qaqaq{:?}", a);
    |
 
 error: only a `panic!` in `if`-then statement
@@ -22,7 +22,7 @@ LL | |     }
    |
 help: try instead
    |
-LL |     assert!(!(!a.is_empty()), "qwqwq");
+LL |     assert!(a.is_empty(), "qwqwq");
    |
 
 error: only a `panic!` in `if`-then statement
-- 
cgit 1.4.1-3-g733a5


From 22be60b4f07bcfc8e72976b4d9f2cd1f9cae29d5 Mon Sep 17 00:00:00 2001
From: kraktus <kraktus@users.noreply.github.com>
Date: Sun, 2 Oct 2022 12:35:02 +0200
Subject: fix indentation

---
 clippy_lints/src/manual_assert.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_assert.rs b/clippy_lints/src/manual_assert.rs
index cbc9c4ca6ad..825ec84b4a8 100644
--- a/clippy_lints/src/manual_assert.rs
+++ b/clippy_lints/src/manual_assert.rs
@@ -56,9 +56,9 @@ impl<'tcx> LateLintPass<'tcx> for ManualAssert {
                     comments += "\n";
                 }
                 let (cond, not) = match cond.kind {
-                     ExprKind::Unary(UnOp::Not, e) => (e, ""),
-                     _ => (cond, "!"),
-                 };
+                    ExprKind::Unary(UnOp::Not, e) => (e, ""),
+                    _ => (cond, "!"),
+                };
                 let cond_sugg = sugg::Sugg::hir_with_applicability(cx, cond, "..", &mut applicability).maybe_par();
                 let sugg = format!("assert!({not}{cond_sugg}, {format_args_snip});");
                 // we show to the user the suggestion without the comments, but when applicating the fix, include the comments in the block
-- 
cgit 1.4.1-3-g733a5


From 081f73954b24e87bbbd95ed20f9a504680b21d46 Mon Sep 17 00:00:00 2001
From: TennyZhuang <zty0826@gmail.com>
Date: Sun, 2 Oct 2022 17:12:08 +0800
Subject: let unnecessary_cast work for trivial non_literal expressions

Signed-off-by: TennyZhuang <zty0826@gmail.com>
---
 clippy_lints/src/casts/unnecessary_cast.rs | 15 ++++++++++++++-
 tests/ui/unnecessary_cast.fixed            |  8 ++++++++
 tests/ui/unnecessary_cast.rs               |  8 ++++++++
 tests/ui/unnecessary_cast.stderr           |  8 +++++++-
 4 files changed, 37 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/unnecessary_cast.rs b/clippy_lints/src/casts/unnecessary_cast.rs
index 031cedb9072..071fab1165d 100644
--- a/clippy_lints/src/casts/unnecessary_cast.rs
+++ b/clippy_lints/src/casts/unnecessary_cast.rs
@@ -31,8 +31,10 @@ pub(super) fn check<'tcx>(
         }
     }
 
+    let cast_str = snippet_opt(cx, cast_expr.span).unwrap_or_default();
+
     if let Some(lit) = get_numeric_literal(cast_expr) {
-        let literal_str = snippet_opt(cx, cast_expr.span).unwrap_or_default();
+        let literal_str = cast_str;
 
         if_chain! {
             if let LitKind::Int(n, _) = lit.node;
@@ -81,6 +83,17 @@ pub(super) fn check<'tcx>(
                 }
             },
         }
+    } else if cast_from.kind() == cast_to.kind() && !in_external_macro(cx.sess(), expr.span) {
+        span_lint_and_sugg(
+            cx,
+            UNNECESSARY_CAST,
+            expr.span,
+            &format!("casting to the same type is unnecessary (`{cast_from}` -> `{cast_to}`)"),
+            "try",
+            cast_str,
+            Applicability::MachineApplicable,
+        );
+        return true;
     }
 
     false
diff --git a/tests/ui/unnecessary_cast.fixed b/tests/ui/unnecessary_cast.fixed
index 70ec3e94380..94dc9642726 100644
--- a/tests/ui/unnecessary_cast.fixed
+++ b/tests/ui/unnecessary_cast.fixed
@@ -103,4 +103,12 @@ mod fixable {
         #[allow(clippy::precedence)]
         let _: f64 = -8.0_f64.exp(); // should suggest `-8.0_f64.exp()` here not to change code behavior
     }
+
+    fn issue_9562_non_literal() {
+        fn foo() -> f32 {
+            0.
+        }
+
+        let _num = foo();
+    }
 }
diff --git a/tests/ui/unnecessary_cast.rs b/tests/ui/unnecessary_cast.rs
index 36c1a87fab6..e5150256f69 100644
--- a/tests/ui/unnecessary_cast.rs
+++ b/tests/ui/unnecessary_cast.rs
@@ -103,4 +103,12 @@ mod fixable {
         #[allow(clippy::precedence)]
         let _: f64 = -(8.0 as f64).exp(); // should suggest `-8.0_f64.exp()` here not to change code behavior
     }
+
+    fn issue_9562_non_literal() {
+        fn foo() -> f32 {
+            0.
+        }
+
+        let _num = foo() as f32;
+    }
 }
diff --git a/tests/ui/unnecessary_cast.stderr b/tests/ui/unnecessary_cast.stderr
index a52b92c339c..e5c3dd5e53f 100644
--- a/tests/ui/unnecessary_cast.stderr
+++ b/tests/ui/unnecessary_cast.stderr
@@ -174,5 +174,11 @@ error: casting float literal to `f64` is unnecessary
 LL |         let _: f64 = -(8.0 as f64).exp(); // should suggest `-8.0_f64.exp()` here not to change code behavior
    |                       ^^^^^^^^^^^^ help: try: `8.0_f64`
 
-error: aborting due to 29 previous errors
+error: casting to the same type is unnecessary (`f32` -> `f32`)
+  --> $DIR/unnecessary_cast.rs:112:20
+   |
+LL |         let _num = foo() as f32;
+   |                    ^^^^^^^^^^^^ help: try: `foo()`
+
+error: aborting due to 30 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From bff811bfdf117ac737d44452c8aa645dd516f8a0 Mon Sep 17 00:00:00 2001
From: TennyZhuang <zty0826@gmail.com>
Date: Sun, 2 Oct 2022 18:41:13 +0800
Subject: extract common codes

Signed-off-by: TennyZhuang <zty0826@gmail.com>
---
 clippy_lints/src/casts/unnecessary_cast.rs | 28 ++++++++++------------------
 1 file changed, 10 insertions(+), 18 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/unnecessary_cast.rs b/clippy_lints/src/casts/unnecessary_cast.rs
index 071fab1165d..610e8f712f4 100644
--- a/clippy_lints/src/casts/unnecessary_cast.rs
+++ b/clippy_lints/src/casts/unnecessary_cast.rs
@@ -34,7 +34,7 @@ pub(super) fn check<'tcx>(
     let cast_str = snippet_opt(cx, cast_expr.span).unwrap_or_default();
 
     if let Some(lit) = get_numeric_literal(cast_expr) {
-        let literal_str = cast_str;
+        let literal_str = &cast_str;
 
         if_chain! {
             if let LitKind::Int(n, _) = lit.node;
@@ -52,10 +52,12 @@ pub(super) fn check<'tcx>(
 
         match lit.node {
             LitKind::Int(_, LitIntType::Unsuffixed) if cast_to.is_integral() => {
-                lint_unnecessary_cast(cx, expr, &literal_str, cast_from, cast_to);
+                lint_unnecessary_cast(cx, expr, literal_str, cast_from, cast_to);
+                return true;
             },
             LitKind::Float(_, LitFloatType::Unsuffixed) if cast_to.is_floating_point() => {
-                lint_unnecessary_cast(cx, expr, &literal_str, cast_from, cast_to);
+                lint_unnecessary_cast(cx, expr, literal_str, cast_from, cast_to);
+                return true;
             },
             LitKind::Int(_, LitIntType::Unsuffixed) | LitKind::Float(_, LitFloatType::Unsuffixed) => {},
             LitKind::Int(_, LitIntType::Signed(_) | LitIntType::Unsigned(_))
@@ -65,25 +67,15 @@ pub(super) fn check<'tcx>(
                 if let Some(src) = snippet_opt(cx, cast_expr.span) {
                     if let Some(num_lit) = NumericLiteral::from_lit_kind(&src, &lit.node) {
                         lint_unnecessary_cast(cx, expr, num_lit.integer, cast_from, cast_to);
+                        return true;
                     }
                 }
             },
-            _ => {
-                if cast_from.kind() == cast_to.kind() && !in_external_macro(cx.sess(), expr.span) {
-                    span_lint_and_sugg(
-                        cx,
-                        UNNECESSARY_CAST,
-                        expr.span,
-                        &format!("casting to the same type is unnecessary (`{cast_from}` -> `{cast_to}`)"),
-                        "try",
-                        literal_str,
-                        Applicability::MachineApplicable,
-                    );
-                    return true;
-                }
-            },
+            _ => {},
         }
-    } else if cast_from.kind() == cast_to.kind() && !in_external_macro(cx.sess(), expr.span) {
+    }
+
+    if cast_from.kind() == cast_to.kind() && !in_external_macro(cx.sess(), expr.span) {
         span_lint_and_sugg(
             cx,
             UNNECESSARY_CAST,
-- 
cgit 1.4.1-3-g733a5


From c9b93143d52ed3393602db29c1e31db03e0fdab2 Mon Sep 17 00:00:00 2001
From: TennyZhuang <zty0826@gmail.com>
Date: Sun, 2 Oct 2022 19:04:33 +0800
Subject: fix some logics

Signed-off-by: TennyZhuang <zty0826@gmail.com>
---
 clippy_lints/src/casts/unnecessary_cast.rs | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/unnecessary_cast.rs b/clippy_lints/src/casts/unnecessary_cast.rs
index 610e8f712f4..21ed7f4844c 100644
--- a/clippy_lints/src/casts/unnecessary_cast.rs
+++ b/clippy_lints/src/casts/unnecessary_cast.rs
@@ -53,13 +53,15 @@ pub(super) fn check<'tcx>(
         match lit.node {
             LitKind::Int(_, LitIntType::Unsuffixed) if cast_to.is_integral() => {
                 lint_unnecessary_cast(cx, expr, literal_str, cast_from, cast_to);
-                return true;
+                return false;
             },
             LitKind::Float(_, LitFloatType::Unsuffixed) if cast_to.is_floating_point() => {
                 lint_unnecessary_cast(cx, expr, literal_str, cast_from, cast_to);
-                return true;
+                return false;
+            },
+            LitKind::Int(_, LitIntType::Unsuffixed) | LitKind::Float(_, LitFloatType::Unsuffixed) => {
+                return false;
             },
-            LitKind::Int(_, LitIntType::Unsuffixed) | LitKind::Float(_, LitFloatType::Unsuffixed) => {},
             LitKind::Int(_, LitIntType::Signed(_) | LitIntType::Unsigned(_))
             | LitKind::Float(_, LitFloatType::Suffixed(_))
                 if cast_from.kind() == cast_to.kind() =>
-- 
cgit 1.4.1-3-g733a5


From b89ac0cefcc19b99a5af902ced053344a8054568 Mon Sep 17 00:00:00 2001
From: kraktus <kraktus@users.noreply.github.com>
Date: Mon, 3 Oct 2022 14:11:54 +0200
Subject: refactor `manual_filter`

Move common functions to `manual_utils.rs`, better arm matching, use clippy utils `contains_unsafe_block`
---
 clippy_lints/src/matches/manual_filter.rs |  76 +++-----
 clippy_lints/src/matches/manual_map.rs    | 287 +-----------------------------
 clippy_lints/src/matches/manual_utils.rs  | 278 +++++++++++++++++++++++++++++
 clippy_lints/src/matches/mod.rs           |   1 +
 clippy_utils/src/sugg.rs                  |   2 +-
 5 files changed, 311 insertions(+), 333 deletions(-)
 create mode 100644 clippy_lints/src/matches/manual_utils.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/manual_filter.rs b/clippy_lints/src/matches/manual_filter.rs
index 9931f1268ab..66ba1f6f9c5 100644
--- a/clippy_lints/src/matches/manual_filter.rs
+++ b/clippy_lints/src/matches/manual_filter.rs
@@ -1,39 +1,20 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::visitors::contains_unsafe_block;
 use clippy_utils::{is_res_lang_ctor, path_res, path_to_local_id};
-use rustc_hir::intravisit::{walk_expr, Visitor};
+
 use rustc_hir::LangItem::OptionSome;
-use rustc_hir::{Arm, Block, BlockCheckMode, Expr, ExprKind, HirId, Pat, PatKind, UnsafeSource};
+use rustc_hir::{Arm, Expr, ExprKind, HirId, Pat, PatKind};
 use rustc_lint::LateContext;
 use rustc_span::{sym, SyntaxContext};
 
-use super::manual_map::{check_with, SomeExpr};
+use super::manual_utils::{check_with, SomeExpr};
 use super::MANUAL_FILTER;
 
-#[derive(Default)]
-struct NeedsUnsafeBlock(pub bool);
-
-impl<'tcx> Visitor<'tcx> for NeedsUnsafeBlock {
-    fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) {
-        match expr.kind {
-            ExprKind::Block(
-                Block {
-                    rules: BlockCheckMode::UnsafeBlock(UnsafeSource::UserProvided),
-                    ..
-                },
-                _,
-            ) => {
-                self.0 = true;
-            },
-            _ => walk_expr(self, expr),
-        }
-    }
-}
-
-// Function called on the `expr` of `[&+]Some((ref | ref mut) x) => <expr>`
-// Need to check if it's of the `if <cond> {<then_expr>} else {<else_expr>}`
+// Function called on the <expr> of `[&+]Some((ref | ref mut) x) => <expr>`
+// Need to check if it's of the form `<expr>=if <cond> {<then_expr>} else {<else_expr>}`
 // AND that only one `then/else_expr` resolves to `Some(x)` while the other resolves to `None`
-// return `cond` if
+// return the `cond` expression if so.
 fn get_cond_expr<'tcx>(
     cx: &LateContext<'tcx>,
     pat: &Pat<'_>,
@@ -45,15 +26,13 @@ fn get_cond_expr<'tcx>(
         if let ExprKind::If(cond, then_expr, Some(else_expr)) = block_expr.kind;
         if let PatKind::Binding(_,target, ..) = pat.kind;
         if let (then_visitor, else_visitor)
-            = (handle_if_or_else_expr(cx, target, ctxt, then_expr),
-                handle_if_or_else_expr(cx, target, ctxt, else_expr));
+            = (is_some_expr(cx, target, ctxt, then_expr),
+                is_some_expr(cx, target, ctxt, else_expr));
         if then_visitor != else_visitor; // check that one expr resolves to `Some(x)`, the other to `None`
         then {
-            let mut needs_unsafe_block = NeedsUnsafeBlock::default();
-            needs_unsafe_block.visit_expr(expr);
             return Some(SomeExpr {
                     expr: peels_blocks_incl_unsafe(cond.peel_drop_temps()),
-                    needs_unsafe_block: needs_unsafe_block.0,
+                    needs_unsafe_block: contains_unsafe_block(cx, expr),
                     needs_negated: !then_visitor // if the `then_expr` resolves to `None`, need to negate the cond
                 })
             }
@@ -63,7 +42,7 @@ fn get_cond_expr<'tcx>(
 
 fn peels_blocks_incl_unsafe_opt<'a>(expr: &'a Expr<'a>) -> Option<&'a Expr<'a>> {
     // we don't want to use `peel_blocks` here because we don't care if the block is unsafe, it's
-    // checked by `NeedsUnsafeBlock`
+    // checked by `contains_unsafe_block`
     if let ExprKind::Block(block, None) = expr.kind {
         if block.stmts.is_empty() {
             return block.expr;
@@ -76,23 +55,18 @@ fn peels_blocks_incl_unsafe<'a>(expr: &'a Expr<'a>) -> &'a Expr<'a> {
     peels_blocks_incl_unsafe_opt(expr).unwrap_or(expr)
 }
 
-// function called for each <ifelse> expression:
+// function called for each <expr> expression:
 // Some(x) => if <cond> {
-//    <ifelse>
+//    <expr>
 // } else {
-//    <ifelse>
+//    <expr>
 // }
-// Returns true if <ifelse> resolves to `Some(x)`, `false` otherwise
-fn handle_if_or_else_expr<'tcx>(
-    cx: &LateContext<'_>,
-    target: HirId,
-    ctxt: SyntaxContext,
-    if_or_else_expr: &'tcx Expr<'_>,
-) -> bool {
-    if let Some(inner_expr) = peels_blocks_incl_unsafe_opt(if_or_else_expr) {
+// Returns true if <expr> resolves to `Some(x)`, `false` otherwise
+fn is_some_expr<'tcx>(cx: &LateContext<'_>, target: HirId, ctxt: SyntaxContext, expr: &'tcx Expr<'_>) -> bool {
+    if let Some(inner_expr) = peels_blocks_incl_unsafe_opt(expr) {
         // there can be not statements in the block as they would be removed when switching to `.filter`
         if let ExprKind::Call(callee, [arg]) = inner_expr.kind {
-            return ctxt == if_or_else_expr.span.ctxt()
+            return ctxt == expr.span.ctxt()
                 && is_res_lang_ctor(cx, path_res(cx, callee), OptionSome)
                 && path_to_local_id(arg, target);
         }
@@ -119,15 +93,13 @@ pub(super) fn check_match<'tcx>(
     expr: &'tcx Expr<'_>,
 ) {
     let ty = cx.typeck_results().expr_ty(expr);
-    if_chain! {
-        if is_type_diagnostic_item(cx, ty, sym::Option);
-        if arms.len() == 2;
-        if arms[0].guard.is_none();
-        if arms[1].guard.is_none();
-        then {
-            check(cx, expr, scrutinee, arms[0].pat, arms[0].body, Some(arms[1].pat), arms[1].body)
+    if is_type_diagnostic_item(cx, ty, sym::Option)
+    && let [first_arm, second_arm] = arms
+    && first_arm.guard.is_none()
+    && second_arm.guard.is_none()
+         {
+            check(cx, expr, scrutinee, first_arm.pat, first_arm.body, Some(second_arm.pat), second_arm.body);
         }
-    }
 }
 
 pub(super) fn check_if_let<'tcx>(
diff --git a/clippy_lints/src/matches/manual_map.rs b/clippy_lints/src/matches/manual_map.rs
index 2b6a07c5d74..aaba239677f 100644
--- a/clippy_lints/src/matches/manual_map.rs
+++ b/clippy_lints/src/matches/manual_map.rs
@@ -1,21 +1,13 @@
+use super::manual_utils::{check_with, SomeExpr};
 use super::MANUAL_MAP;
-use crate::{map_unit_fn::OPTION_MAP_UNIT_FN, matches::MATCH_AS_REF};
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::source::{snippet_with_applicability, snippet_with_context};
-use clippy_utils::ty::{is_copy, is_type_diagnostic_item, peel_mid_ty_refs_is_mutable, type_is_unsafe_function};
-use clippy_utils::{
-    can_move_expr_to_closure, is_else_clause, is_lint_allowed, is_res_lang_ctor, path_res, path_to_local_id,
-    peel_blocks, peel_hir_expr_refs, peel_hir_expr_while, sugg::Sugg, CaptureKind,
-};
-use rustc_ast::util::parser::PREC_POSTFIX;
-use rustc_errors::Applicability;
-use rustc_hir::LangItem::{OptionNone, OptionSome};
-use rustc_hir::{
-    def::Res, Arm, BindingAnnotation, Block, BlockCheckMode, Expr, ExprKind, HirId, Mutability, Pat, PatKind, Path,
-    QPath, UnsafeSource,
-};
+
+use clippy_utils::{is_res_lang_ctor, path_res};
+
+use rustc_hir::LangItem::OptionSome;
+use rustc_hir::{Arm, Block, BlockCheckMode, Expr, ExprKind, Pat, UnsafeSource};
 use rustc_lint::LateContext;
-use rustc_span::{sym, SyntaxContext};
+use rustc_span::SyntaxContext;
 
 pub(super) fn check_match<'tcx>(
     cx: &LateContext<'tcx>,
@@ -83,266 +75,6 @@ fn check<'tcx>(
     }
 }
 
-#[expect(clippy::too_many_arguments)]
-#[expect(clippy::too_many_lines)]
-pub(super) fn check_with<'tcx, F>(
-    cx: &LateContext<'tcx>,
-    expr: &'tcx Expr<'_>,
-    scrutinee: &'tcx Expr<'_>,
-    then_pat: &'tcx Pat<'_>,
-    then_body: &'tcx Expr<'_>,
-    else_pat: Option<&'tcx Pat<'_>>,
-    else_body: &'tcx Expr<'_>,
-    get_some_expr_fn: F,
-) -> Option<SuggInfo<'tcx>>
-where
-    F: Fn(&LateContext<'tcx>, &'tcx Pat<'_>, &'tcx Expr<'_>, SyntaxContext) -> Option<SomeExpr<'tcx>>,
-{
-    let (scrutinee_ty, ty_ref_count, ty_mutability) =
-        peel_mid_ty_refs_is_mutable(cx.typeck_results().expr_ty(scrutinee));
-    if !(is_type_diagnostic_item(cx, scrutinee_ty, sym::Option)
-        && is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(expr), sym::Option))
-    {
-        return None;
-    }
-
-    let expr_ctxt = expr.span.ctxt();
-    let (some_expr, some_pat, pat_ref_count, is_wild_none) = match (
-        try_parse_pattern(cx, then_pat, expr_ctxt),
-        else_pat.map_or(Some(OptionPat::Wild), |p| try_parse_pattern(cx, p, expr_ctxt)),
-    ) {
-        (Some(OptionPat::Wild), Some(OptionPat::Some { pattern, ref_count })) if is_none_expr(cx, then_body) => {
-            (else_body, pattern, ref_count, true)
-        },
-        (Some(OptionPat::None), Some(OptionPat::Some { pattern, ref_count })) if is_none_expr(cx, then_body) => {
-            (else_body, pattern, ref_count, false)
-        },
-        (Some(OptionPat::Some { pattern, ref_count }), Some(OptionPat::Wild)) if is_none_expr(cx, else_body) => {
-            (then_body, pattern, ref_count, true)
-        },
-        (Some(OptionPat::Some { pattern, ref_count }), Some(OptionPat::None)) if is_none_expr(cx, else_body) => {
-            (then_body, pattern, ref_count, false)
-        },
-        _ => return None,
-    };
-
-    // Top level or patterns aren't allowed in closures.
-    if matches!(some_pat.kind, PatKind::Or(_)) {
-        return None;
-    }
-
-    let some_expr = match get_some_expr_fn(cx, some_pat, some_expr, expr_ctxt) {
-        Some(expr) => expr,
-        None => return None,
-    };
-
-    // These two lints will go back and forth with each other.
-    if cx.typeck_results().expr_ty(some_expr.expr) == cx.tcx.types.unit
-        && !is_lint_allowed(cx, OPTION_MAP_UNIT_FN, expr.hir_id)
-    {
-        return None;
-    }
-
-    // `map` won't perform any adjustments.
-    if !cx.typeck_results().expr_adjustments(some_expr.expr).is_empty() {
-        return None;
-    }
-
-    // Determine which binding mode to use.
-    let explicit_ref = some_pat.contains_explicit_ref_binding();
-    let binding_ref = explicit_ref.or_else(|| (ty_ref_count != pat_ref_count).then_some(ty_mutability));
-
-    let as_ref_str = match binding_ref {
-        Some(Mutability::Mut) => ".as_mut()",
-        Some(Mutability::Not) => ".as_ref()",
-        None => "",
-    };
-
-    match can_move_expr_to_closure(cx, some_expr.expr) {
-        Some(captures) => {
-            // Check if captures the closure will need conflict with borrows made in the scrutinee.
-            // TODO: check all the references made in the scrutinee expression. This will require interacting
-            // with the borrow checker. Currently only `<local>[.<field>]*` is checked for.
-            if let Some(binding_ref_mutability) = binding_ref {
-                let e = peel_hir_expr_while(scrutinee, |e| match e.kind {
-                    ExprKind::Field(e, _) | ExprKind::AddrOf(_, _, e) => Some(e),
-                    _ => None,
-                });
-                if let ExprKind::Path(QPath::Resolved(None, Path { res: Res::Local(l), .. })) = e.kind {
-                    match captures.get(l) {
-                        Some(CaptureKind::Value | CaptureKind::Ref(Mutability::Mut)) => return None,
-                        Some(CaptureKind::Ref(Mutability::Not)) if binding_ref_mutability == Mutability::Mut => {
-                            return None;
-                        },
-                        Some(CaptureKind::Ref(Mutability::Not)) | None => (),
-                    }
-                }
-            }
-        },
-        None => return None,
-    };
-
-    let mut app = Applicability::MachineApplicable;
-
-    // Remove address-of expressions from the scrutinee. Either `as_ref` will be called, or
-    // it's being passed by value.
-    let scrutinee = peel_hir_expr_refs(scrutinee).0;
-    let (scrutinee_str, _) = snippet_with_context(cx, scrutinee.span, expr_ctxt, "..", &mut app);
-    let scrutinee_str = if scrutinee.span.ctxt() == expr.span.ctxt() && scrutinee.precedence().order() < PREC_POSTFIX {
-        format!("({scrutinee_str})")
-    } else {
-        scrutinee_str.into()
-    };
-
-    let closure_expr_snip = some_expr.to_snippet_with_context(cx, expr_ctxt, &mut app);
-    let body_str = if let PatKind::Binding(annotation, id, some_binding, None) = some_pat.kind {
-        if_chain! {
-            if !some_expr.needs_unsafe_block;
-            if let Some(func) = can_pass_as_func(cx, id, some_expr.expr);
-            if func.span.ctxt() == some_expr.expr.span.ctxt();
-            then {
-                snippet_with_applicability(cx, func.span, "..", &mut app).into_owned()
-            } else {
-                if path_to_local_id(some_expr.expr, id)
-                    && !is_lint_allowed(cx, MATCH_AS_REF, expr.hir_id)
-                    && binding_ref.is_some()
-                {
-                    return None;
-                }
-
-                // `ref` and `ref mut` annotations were handled earlier.
-                let annotation = if matches!(annotation, BindingAnnotation::MUT) {
-                    "mut "
-                } else {
-                    ""
-                };
-
-                if some_expr.needs_unsafe_block {
-                    format!("|{annotation}{some_binding}| unsafe {{ {closure_expr_snip} }}")
-                } else {
-                    format!("|{annotation}{some_binding}| {closure_expr_snip}")
-                }
-            }
-        }
-    } else if !is_wild_none && explicit_ref.is_none() {
-        // TODO: handle explicit reference annotations.
-        let pat_snip = snippet_with_context(cx, some_pat.span, expr_ctxt, "..", &mut app).0;
-        if some_expr.needs_unsafe_block {
-            format!("|{pat_snip}| unsafe {{ {closure_expr_snip} }}")
-        } else {
-            format!("|{pat_snip}| {closure_expr_snip}")
-        }
-    } else {
-        // Refutable bindings and mixed reference annotations can't be handled by `map`.
-        return None;
-    };
-
-    // relies on the fact that Option<T>: Copy where T: copy
-    let scrutinee_impl_copy = is_copy(cx, scrutinee_ty);
-
-    Some(SuggInfo {
-        needs_brackets: else_pat.is_none() && is_else_clause(cx.tcx, expr),
-        scrutinee_impl_copy,
-        scrutinee_str,
-        as_ref_str,
-        body_str,
-        app,
-    })
-}
-
-pub struct SuggInfo<'a> {
-    pub needs_brackets: bool,
-    pub scrutinee_impl_copy: bool,
-    pub scrutinee_str: String,
-    pub as_ref_str: &'a str,
-    pub body_str: String,
-    pub app: Applicability,
-}
-
-// Checks whether the expression could be passed as a function, or whether a closure is needed.
-// Returns the function to be passed to `map` if it exists.
-fn can_pass_as_func<'tcx>(cx: &LateContext<'tcx>, binding: HirId, expr: &'tcx Expr<'_>) -> Option<&'tcx Expr<'tcx>> {
-    match expr.kind {
-        ExprKind::Call(func, [arg])
-            if path_to_local_id(arg, binding)
-                && cx.typeck_results().expr_adjustments(arg).is_empty()
-                && !type_is_unsafe_function(cx, cx.typeck_results().expr_ty(func).peel_refs()) =>
-        {
-            Some(func)
-        },
-        _ => None,
-    }
-}
-
-#[derive(Debug)]
-pub(super) enum OptionPat<'a> {
-    Wild,
-    None,
-    Some {
-        // The pattern contained in the `Some` tuple.
-        pattern: &'a Pat<'a>,
-        // The number of references before the `Some` tuple.
-        // e.g. `&&Some(_)` has a ref count of 2.
-        ref_count: usize,
-    },
-}
-
-pub(super) struct SomeExpr<'tcx> {
-    pub expr: &'tcx Expr<'tcx>,
-    pub needs_unsafe_block: bool,
-    pub needs_negated: bool, // for `manual_filter` lint
-}
-
-impl<'tcx> SomeExpr<'tcx> {
-    pub fn new_no_negated(expr: &'tcx Expr<'tcx>, needs_unsafe_block: bool) -> Self {
-        Self {
-            expr,
-            needs_unsafe_block,
-            needs_negated: false,
-        }
-    }
-
-    pub fn to_snippet_with_context(
-        &self,
-        cx: &LateContext<'tcx>,
-        ctxt: SyntaxContext,
-        app: &mut Applicability,
-    ) -> Sugg<'tcx> {
-        let sugg = Sugg::hir_with_context(cx, self.expr, ctxt, "..", app);
-        if self.needs_negated { !sugg } else { sugg }
-    }
-}
-
-// Try to parse into a recognized `Option` pattern.
-// i.e. `_`, `None`, `Some(..)`, or a reference to any of those.
-pub(super) fn try_parse_pattern<'tcx>(
-    cx: &LateContext<'tcx>,
-    pat: &'tcx Pat<'_>,
-    ctxt: SyntaxContext,
-) -> Option<OptionPat<'tcx>> {
-    fn f<'tcx>(
-        cx: &LateContext<'tcx>,
-        pat: &'tcx Pat<'_>,
-        ref_count: usize,
-        ctxt: SyntaxContext,
-    ) -> Option<OptionPat<'tcx>> {
-        match pat.kind {
-            PatKind::Wild => Some(OptionPat::Wild),
-            PatKind::Ref(pat, _) => f(cx, pat, ref_count + 1, ctxt),
-            PatKind::Path(ref qpath) if is_res_lang_ctor(cx, cx.qpath_res(qpath, pat.hir_id), OptionNone) => {
-                Some(OptionPat::None)
-            },
-            PatKind::TupleStruct(ref qpath, [pattern], _)
-                if is_res_lang_ctor(cx, cx.qpath_res(qpath, pat.hir_id), OptionSome) && pat.span.ctxt() == ctxt =>
-            {
-                Some(OptionPat::Some { pattern, ref_count })
-            },
-            _ => None,
-        }
-    }
-    f(cx, pat, 0, ctxt)
-}
-
 // Checks for an expression wrapped by the `Some` constructor. Returns the contained expression.
 fn get_some_expr<'tcx>(
     cx: &LateContext<'tcx>,
@@ -382,8 +114,3 @@ fn get_some_expr<'tcx>(
     }
     get_some_expr_internal(cx, expr, false, ctxt)
 }
-
-// Checks for the `None` value.
-fn is_none_expr(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-    is_res_lang_ctor(cx, path_res(cx, peel_blocks(expr)), OptionNone)
-}
diff --git a/clippy_lints/src/matches/manual_utils.rs b/clippy_lints/src/matches/manual_utils.rs
new file mode 100644
index 00000000000..792908aa7df
--- /dev/null
+++ b/clippy_lints/src/matches/manual_utils.rs
@@ -0,0 +1,278 @@
+use crate::{map_unit_fn::OPTION_MAP_UNIT_FN, matches::MATCH_AS_REF};
+use clippy_utils::source::{snippet_with_applicability, snippet_with_context};
+use clippy_utils::ty::{is_copy, is_type_diagnostic_item, peel_mid_ty_refs_is_mutable, type_is_unsafe_function};
+use clippy_utils::{
+    can_move_expr_to_closure, is_else_clause, is_lint_allowed, is_res_lang_ctor, path_res, path_to_local_id,
+    peel_blocks, peel_hir_expr_refs, peel_hir_expr_while, sugg::Sugg, CaptureKind,
+};
+use rustc_ast::util::parser::PREC_POSTFIX;
+use rustc_errors::Applicability;
+use rustc_hir::LangItem::{OptionNone, OptionSome};
+use rustc_hir::{def::Res, BindingAnnotation, Expr, ExprKind, HirId, Mutability, Pat, PatKind, Path, QPath};
+use rustc_lint::LateContext;
+use rustc_span::{sym, SyntaxContext};
+
+#[expect(clippy::too_many_arguments)]
+#[expect(clippy::too_many_lines)]
+pub(super) fn check_with<'tcx, F>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx Expr<'_>,
+    scrutinee: &'tcx Expr<'_>,
+    then_pat: &'tcx Pat<'_>,
+    then_body: &'tcx Expr<'_>,
+    else_pat: Option<&'tcx Pat<'_>>,
+    else_body: &'tcx Expr<'_>,
+    get_some_expr_fn: F,
+) -> Option<SuggInfo<'tcx>>
+where
+    F: Fn(&LateContext<'tcx>, &'tcx Pat<'_>, &'tcx Expr<'_>, SyntaxContext) -> Option<SomeExpr<'tcx>>,
+{
+    let (scrutinee_ty, ty_ref_count, ty_mutability) =
+        peel_mid_ty_refs_is_mutable(cx.typeck_results().expr_ty(scrutinee));
+    if !(is_type_diagnostic_item(cx, scrutinee_ty, sym::Option)
+        && is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(expr), sym::Option))
+    {
+        return None;
+    }
+
+    let expr_ctxt = expr.span.ctxt();
+    let (some_expr, some_pat, pat_ref_count, is_wild_none) = match (
+        try_parse_pattern(cx, then_pat, expr_ctxt),
+        else_pat.map_or(Some(OptionPat::Wild), |p| try_parse_pattern(cx, p, expr_ctxt)),
+    ) {
+        (Some(OptionPat::Wild), Some(OptionPat::Some { pattern, ref_count })) if is_none_expr(cx, then_body) => {
+            (else_body, pattern, ref_count, true)
+        },
+        (Some(OptionPat::None), Some(OptionPat::Some { pattern, ref_count })) if is_none_expr(cx, then_body) => {
+            (else_body, pattern, ref_count, false)
+        },
+        (Some(OptionPat::Some { pattern, ref_count }), Some(OptionPat::Wild)) if is_none_expr(cx, else_body) => {
+            (then_body, pattern, ref_count, true)
+        },
+        (Some(OptionPat::Some { pattern, ref_count }), Some(OptionPat::None)) if is_none_expr(cx, else_body) => {
+            (then_body, pattern, ref_count, false)
+        },
+        _ => return None,
+    };
+
+    // Top level or patterns aren't allowed in closures.
+    if matches!(some_pat.kind, PatKind::Or(_)) {
+        return None;
+    }
+
+    let some_expr = match get_some_expr_fn(cx, some_pat, some_expr, expr_ctxt) {
+        Some(expr) => expr,
+        None => return None,
+    };
+
+    // These two lints will go back and forth with each other.
+    if cx.typeck_results().expr_ty(some_expr.expr) == cx.tcx.types.unit
+        && !is_lint_allowed(cx, OPTION_MAP_UNIT_FN, expr.hir_id)
+    {
+        return None;
+    }
+
+    // `map` won't perform any adjustments.
+    if !cx.typeck_results().expr_adjustments(some_expr.expr).is_empty() {
+        return None;
+    }
+
+    // Determine which binding mode to use.
+    let explicit_ref = some_pat.contains_explicit_ref_binding();
+    let binding_ref = explicit_ref.or_else(|| (ty_ref_count != pat_ref_count).then_some(ty_mutability));
+
+    let as_ref_str = match binding_ref {
+        Some(Mutability::Mut) => ".as_mut()",
+        Some(Mutability::Not) => ".as_ref()",
+        None => "",
+    };
+
+    match can_move_expr_to_closure(cx, some_expr.expr) {
+        Some(captures) => {
+            // Check if captures the closure will need conflict with borrows made in the scrutinee.
+            // TODO: check all the references made in the scrutinee expression. This will require interacting
+            // with the borrow checker. Currently only `<local>[.<field>]*` is checked for.
+            if let Some(binding_ref_mutability) = binding_ref {
+                let e = peel_hir_expr_while(scrutinee, |e| match e.kind {
+                    ExprKind::Field(e, _) | ExprKind::AddrOf(_, _, e) => Some(e),
+                    _ => None,
+                });
+                if let ExprKind::Path(QPath::Resolved(None, Path { res: Res::Local(l), .. })) = e.kind {
+                    match captures.get(l) {
+                        Some(CaptureKind::Value | CaptureKind::Ref(Mutability::Mut)) => return None,
+                        Some(CaptureKind::Ref(Mutability::Not)) if binding_ref_mutability == Mutability::Mut => {
+                            return None;
+                        },
+                        Some(CaptureKind::Ref(Mutability::Not)) | None => (),
+                    }
+                }
+            }
+        },
+        None => return None,
+    };
+
+    let mut app = Applicability::MachineApplicable;
+
+    // Remove address-of expressions from the scrutinee. Either `as_ref` will be called, or
+    // it's being passed by value.
+    let scrutinee = peel_hir_expr_refs(scrutinee).0;
+    let (scrutinee_str, _) = snippet_with_context(cx, scrutinee.span, expr_ctxt, "..", &mut app);
+    let scrutinee_str = if scrutinee.span.ctxt() == expr.span.ctxt() && scrutinee.precedence().order() < PREC_POSTFIX {
+        format!("({scrutinee_str})")
+    } else {
+        scrutinee_str.into()
+    };
+
+    let closure_expr_snip = some_expr.to_snippet_with_context(cx, expr_ctxt, &mut app);
+    let body_str = if let PatKind::Binding(annotation, id, some_binding, None) = some_pat.kind {
+        if_chain! {
+            if !some_expr.needs_unsafe_block;
+            if let Some(func) = can_pass_as_func(cx, id, some_expr.expr);
+            if func.span.ctxt() == some_expr.expr.span.ctxt();
+            then {
+                snippet_with_applicability(cx, func.span, "..", &mut app).into_owned()
+            } else {
+                if path_to_local_id(some_expr.expr, id)
+                    && !is_lint_allowed(cx, MATCH_AS_REF, expr.hir_id)
+                    && binding_ref.is_some()
+                {
+                    return None;
+                }
+
+                // `ref` and `ref mut` annotations were handled earlier.
+                let annotation = if matches!(annotation, BindingAnnotation::MUT) {
+                    "mut "
+                } else {
+                    ""
+                };
+
+                if some_expr.needs_unsafe_block {
+                    format!("|{annotation}{some_binding}| unsafe {{ {closure_expr_snip} }}")
+                } else {
+                    format!("|{annotation}{some_binding}| {closure_expr_snip}")
+                }
+            }
+        }
+    } else if !is_wild_none && explicit_ref.is_none() {
+        // TODO: handle explicit reference annotations.
+        let pat_snip = snippet_with_context(cx, some_pat.span, expr_ctxt, "..", &mut app).0;
+        if some_expr.needs_unsafe_block {
+            format!("|{pat_snip}| unsafe {{ {closure_expr_snip} }}")
+        } else {
+            format!("|{pat_snip}| {closure_expr_snip}")
+        }
+    } else {
+        // Refutable bindings and mixed reference annotations can't be handled by `map`.
+        return None;
+    };
+
+    // relies on the fact that Option<T>: Copy where T: copy
+    let scrutinee_impl_copy = is_copy(cx, scrutinee_ty);
+
+    Some(SuggInfo {
+        needs_brackets: else_pat.is_none() && is_else_clause(cx.tcx, expr),
+        scrutinee_impl_copy,
+        scrutinee_str,
+        as_ref_str,
+        body_str,
+        app,
+    })
+}
+
+pub struct SuggInfo<'a> {
+    pub needs_brackets: bool,
+    pub scrutinee_impl_copy: bool,
+    pub scrutinee_str: String,
+    pub as_ref_str: &'a str,
+    pub body_str: String,
+    pub app: Applicability,
+}
+
+// Checks whether the expression could be passed as a function, or whether a closure is needed.
+// Returns the function to be passed to `map` if it exists.
+fn can_pass_as_func<'tcx>(cx: &LateContext<'tcx>, binding: HirId, expr: &'tcx Expr<'_>) -> Option<&'tcx Expr<'tcx>> {
+    match expr.kind {
+        ExprKind::Call(func, [arg])
+            if path_to_local_id(arg, binding)
+                && cx.typeck_results().expr_adjustments(arg).is_empty()
+                && !type_is_unsafe_function(cx, cx.typeck_results().expr_ty(func).peel_refs()) =>
+        {
+            Some(func)
+        },
+        _ => None,
+    }
+}
+
+#[derive(Debug)]
+pub(super) enum OptionPat<'a> {
+    Wild,
+    None,
+    Some {
+        // The pattern contained in the `Some` tuple.
+        pattern: &'a Pat<'a>,
+        // The number of references before the `Some` tuple.
+        // e.g. `&&Some(_)` has a ref count of 2.
+        ref_count: usize,
+    },
+}
+
+pub(super) struct SomeExpr<'tcx> {
+    pub expr: &'tcx Expr<'tcx>,
+    pub needs_unsafe_block: bool,
+    pub needs_negated: bool, // for `manual_filter` lint
+}
+
+impl<'tcx> SomeExpr<'tcx> {
+    pub fn new_no_negated(expr: &'tcx Expr<'tcx>, needs_unsafe_block: bool) -> Self {
+        Self {
+            expr,
+            needs_unsafe_block,
+            needs_negated: false,
+        }
+    }
+
+    pub fn to_snippet_with_context(
+        &self,
+        cx: &LateContext<'tcx>,
+        ctxt: SyntaxContext,
+        app: &mut Applicability,
+    ) -> Sugg<'tcx> {
+        let sugg = Sugg::hir_with_context(cx, self.expr, ctxt, "..", app);
+        if self.needs_negated { !sugg } else { sugg }
+    }
+}
+
+// Try to parse into a recognized `Option` pattern.
+// i.e. `_`, `None`, `Some(..)`, or a reference to any of those.
+pub(super) fn try_parse_pattern<'tcx>(
+    cx: &LateContext<'tcx>,
+    pat: &'tcx Pat<'_>,
+    ctxt: SyntaxContext,
+) -> Option<OptionPat<'tcx>> {
+    fn f<'tcx>(
+        cx: &LateContext<'tcx>,
+        pat: &'tcx Pat<'_>,
+        ref_count: usize,
+        ctxt: SyntaxContext,
+    ) -> Option<OptionPat<'tcx>> {
+        match pat.kind {
+            PatKind::Wild => Some(OptionPat::Wild),
+            PatKind::Ref(pat, _) => f(cx, pat, ref_count + 1, ctxt),
+            PatKind::Path(ref qpath) if is_res_lang_ctor(cx, cx.qpath_res(qpath, pat.hir_id), OptionNone) => {
+                Some(OptionPat::None)
+            },
+            PatKind::TupleStruct(ref qpath, [pattern], _)
+                if is_res_lang_ctor(cx, cx.qpath_res(qpath, pat.hir_id), OptionSome) && pat.span.ctxt() == ctxt =>
+            {
+                Some(OptionPat::Some { pattern, ref_count })
+            },
+            _ => None,
+        }
+    }
+    f(cx, pat, 0, ctxt)
+}
+
+// Checks for the `None` value.
+fn is_none_expr(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+    is_res_lang_ctor(cx, path_res(cx, peel_blocks(expr)), OptionNone)
+}
diff --git a/clippy_lints/src/matches/mod.rs b/clippy_lints/src/matches/mod.rs
index cf1bd7a12ad..c472d628098 100644
--- a/clippy_lints/src/matches/mod.rs
+++ b/clippy_lints/src/matches/mod.rs
@@ -3,6 +3,7 @@ mod infallible_destructuring_match;
 mod manual_filter;
 mod manual_map;
 mod manual_unwrap_or;
+mod manual_utils;
 mod match_as_ref;
 mod match_bool;
 mod match_like_matches;
diff --git a/clippy_utils/src/sugg.rs b/clippy_utils/src/sugg.rs
index e88542b77a6..f25bced0c2b 100644
--- a/clippy_utils/src/sugg.rs
+++ b/clippy_utils/src/sugg.rs
@@ -112,7 +112,7 @@ impl<'a> Sugg<'a> {
         if expr.span.ctxt() == ctxt {
             Self::hir_from_snippet(expr, |span| snippet(cx, span, default))
         } else {
-            let snip = snippet_with_context(cx, expr.span, ctxt, default, applicability).0;
+            let (snip, _) = snippet_with_context(cx, expr.span, ctxt, default, applicability);
             Sugg::NonParen(snip)
         }
     }
-- 
cgit 1.4.1-3-g733a5


From 830fdf2b56d2a2f0f8e8135e05ec30b08e54ad3a Mon Sep 17 00:00:00 2001
From: kraktus <kraktus@users.noreply.github.com>
Date: Sun, 2 Oct 2022 17:45:44 +0200
Subject: update rust version introduction

---
 clippy_lints/src/matches/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/mod.rs b/clippy_lints/src/matches/mod.rs
index c472d628098..7d8171ead89 100644
--- a/clippy_lints/src/matches/mod.rs
+++ b/clippy_lints/src/matches/mod.rs
@@ -922,7 +922,7 @@ declare_clippy_lint! {
     /// ```rust
     /// Some(0).filter(|&x| x % 2 == 0);
     /// ```
-    #[clippy::version = "1.65.0"]
+    #[clippy::version = "1.66.0"]
     pub MANUAL_FILTER,
     complexity,
     "reimplentation of `filter`"
-- 
cgit 1.4.1-3-g733a5


From 8e7af6b42961d6a4b6857c06aa5139a985e0009d Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Tue, 28 Jun 2022 22:34:02 -0400
Subject: Replace `is_lang_ctor` with `is_res_lang_ctor`

---
 clippy_lints/src/if_then_some_else_none.rs         | 10 +--
 clippy_lints/src/loops/manual_find.rs              |  9 ++-
 clippy_lints/src/loops/manual_flatten.rs           | 12 ++--
 clippy_lints/src/loops/while_let_on_iterator.rs    | 10 ++-
 clippy_lints/src/matches/collapsible_match.rs      |  6 +-
 clippy_lints/src/matches/manual_map.rs             | 30 ++++-----
 clippy_lints/src/matches/manual_unwrap_or.rs       | 16 +++--
 clippy_lints/src/matches/match_as_ref.rs           | 12 ++--
 clippy_lints/src/matches/needless_match.rs         |  7 +--
 .../src/matches/redundant_pattern_match.rs         | 23 ++++---
 clippy_lints/src/matches/try_err.rs                |  5 +-
 clippy_lints/src/mem_replace.rs                    | 72 ++++++++++------------
 .../methods/iter_on_single_or_empty_collections.rs | 27 ++------
 clippy_lints/src/methods/manual_ok_or.rs           | 34 +++++-----
 clippy_lints/src/methods/option_map_or_none.rs     | 16 +----
 clippy_lints/src/methods/or_then_unwrap.rs         |  5 +-
 clippy_lints/src/methods/unnecessary_filter_map.rs | 20 +++---
 clippy_lints/src/needless_question_mark.rs         | 14 +++--
 clippy_lints/src/option_if_let_else.rs             | 10 +--
 clippy_lints/src/partialeq_to_none.rs              |  5 +-
 clippy_lints/src/question_mark.rs                  | 24 +++++---
 clippy_lints/src/unnecessary_wraps.rs              |  6 +-
 clippy_utils/src/lib.rs                            | 34 ++++++----
 23 files changed, 205 insertions(+), 202 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/if_then_some_else_none.rs b/clippy_lints/src/if_then_some_else_none.rs
index 0800e0644f7..0d6718c168a 100644
--- a/clippy_lints/src/if_then_some_else_none.rs
+++ b/clippy_lints/src/if_then_some_else_none.rs
@@ -1,7 +1,9 @@
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::eager_or_lazy::switch_to_eager_eval;
 use clippy_utils::source::snippet_with_macro_callsite;
-use clippy_utils::{contains_return, higher, is_else_clause, is_lang_ctor, meets_msrv, msrvs, peel_blocks};
+use clippy_utils::{
+    contains_return, higher, is_else_clause, is_res_lang_ctor, meets_msrv, msrvs, path_res, peel_blocks,
+};
 use rustc_hir::LangItem::{OptionNone, OptionSome};
 use rustc_hir::{Expr, ExprKind, Stmt, StmtKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
@@ -76,10 +78,8 @@ impl<'tcx> LateLintPass<'tcx> for IfThenSomeElseNone {
             && let ExprKind::Block(then_block, _) = then.kind
             && let Some(then_expr) = then_block.expr
             && let ExprKind::Call(then_call, [then_arg]) = then_expr.kind
-            && let ExprKind::Path(ref then_call_qpath) = then_call.kind
-            && is_lang_ctor(cx, then_call_qpath, OptionSome)
-            && let ExprKind::Path(ref qpath) = peel_blocks(els).kind
-            && is_lang_ctor(cx, qpath, OptionNone)
+            && is_res_lang_ctor(cx, path_res(cx, then_call), OptionSome)
+            && is_res_lang_ctor(cx, path_res(cx, peel_blocks(els)), OptionNone)
             && !stmts_contains_early_return(then_block.stmts)
         {
             let cond_snip = snippet_with_macro_callsite(cx, cond.span, "[condition]");
diff --git a/clippy_lints/src/loops/manual_find.rs b/clippy_lints/src/loops/manual_find.rs
index 09b2376d5c0..4bb9936e9cd 100644
--- a/clippy_lints/src/loops/manual_find.rs
+++ b/clippy_lints/src/loops/manual_find.rs
@@ -1,7 +1,7 @@
 use super::utils::make_iterator_snippet;
 use super::MANUAL_FIND;
 use clippy_utils::{
-    diagnostics::span_lint_and_then, higher, is_lang_ctor, path_res, peel_blocks_with_stmt,
+    diagnostics::span_lint_and_then, higher, is_res_lang_ctor, path_res, peel_blocks_with_stmt,
     source::snippet_with_applicability, ty::implements_trait,
 };
 use if_chain::if_chain;
@@ -30,8 +30,8 @@ pub(super) fn check<'tcx>(
         if let [stmt] = block.stmts;
         if let StmtKind::Semi(semi) = stmt.kind;
         if let ExprKind::Ret(Some(ret_value)) = semi.kind;
-        if let ExprKind::Call(Expr { kind: ExprKind::Path(ctor), .. }, [inner_ret]) = ret_value.kind;
-        if is_lang_ctor(cx, ctor, LangItem::OptionSome);
+        if let ExprKind::Call(ctor, [inner_ret]) = ret_value.kind;
+        if is_res_lang_ctor(cx, path_res(cx, ctor), LangItem::OptionSome);
         if path_res(cx, inner_ret) == Res::Local(binding_id);
         if let Some((last_stmt, last_ret)) = last_stmt_and_ret(cx, expr);
         then {
@@ -143,8 +143,7 @@ fn last_stmt_and_ret<'tcx>(
         if let Some((_, Node::Block(block))) = parent_iter.next();
         if let Some((last_stmt, last_ret)) = extract(block);
         if last_stmt.hir_id == node_hir;
-        if let ExprKind::Path(path) = &last_ret.kind;
-        if is_lang_ctor(cx, path, LangItem::OptionNone);
+        if is_res_lang_ctor(cx, path_res(cx, last_ret), LangItem::OptionNone);
         if let Some((_, Node::Expr(_block))) = parent_iter.next();
         // This includes the function header
         if let Some((_, func)) = parent_iter.next();
diff --git a/clippy_lints/src/loops/manual_flatten.rs b/clippy_lints/src/loops/manual_flatten.rs
index 1b36d452647..8c27c09404b 100644
--- a/clippy_lints/src/loops/manual_flatten.rs
+++ b/clippy_lints/src/loops/manual_flatten.rs
@@ -3,13 +3,13 @@ use super::MANUAL_FLATTEN;
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::higher;
 use clippy_utils::visitors::is_local_used;
-use clippy_utils::{is_lang_ctor, path_to_local_id, peel_blocks_with_stmt};
+use clippy_utils::{path_to_local_id, peel_blocks_with_stmt};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
-use rustc_hir::LangItem::{OptionSome, ResultOk};
+use rustc_hir::def::{DefKind, Res};
 use rustc_hir::{Expr, Pat, PatKind};
 use rustc_lint::LateContext;
-use rustc_middle::ty;
+use rustc_middle::ty::{self, DefIdTree};
 use rustc_span::source_map::Span;
 
 /// Check for unnecessary `if let` usage in a for loop where only the `Some` or `Ok` variant of the
@@ -30,8 +30,10 @@ pub(super) fn check<'tcx>(
         if path_to_local_id(let_expr, pat_hir_id);
         // Ensure the `if let` statement is for the `Some` variant of `Option` or the `Ok` variant of `Result`
         if let PatKind::TupleStruct(ref qpath, _, _) = let_pat.kind;
-        let some_ctor = is_lang_ctor(cx, qpath, OptionSome);
-        let ok_ctor = is_lang_ctor(cx, qpath, ResultOk);
+        if let Res::Def(DefKind::Ctor(..), ctor_id) = cx.qpath_res(qpath, let_pat.hir_id);
+        if let Some(variant_id) = cx.tcx.opt_parent(ctor_id);
+        let some_ctor = cx.tcx.lang_items().option_some_variant() == Some(variant_id);
+        let ok_ctor = cx.tcx.lang_items().result_ok_variant() == Some(variant_id);
         if some_ctor || ok_ctor;
         // Ensure expr in `if let` is not used afterwards
         if !is_local_used(cx, if_then, pat_hir_id);
diff --git a/clippy_lints/src/loops/while_let_on_iterator.rs b/clippy_lints/src/loops/while_let_on_iterator.rs
index 1c6f0264cb5..153f97e4e66 100644
--- a/clippy_lints/src/loops/while_let_on_iterator.rs
+++ b/clippy_lints/src/loops/while_let_on_iterator.rs
@@ -3,13 +3,12 @@ use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::higher;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::{
-    get_enclosing_loop_or_multi_call_closure, is_refutable, is_trait_method, match_def_path, paths,
-    visitors::is_res_used,
+    get_enclosing_loop_or_multi_call_closure, is_refutable, is_res_lang_ctor, is_trait_method, visitors::is_res_used,
 };
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_expr, Visitor};
-use rustc_hir::{def::Res, Closure, Expr, ExprKind, HirId, Local, Mutability, PatKind, QPath, UnOp};
+use rustc_hir::{def::Res, Closure, Expr, ExprKind, HirId, LangItem, Local, Mutability, PatKind, UnOp};
 use rustc_lint::LateContext;
 use rustc_middle::hir::nested_filter::OnlyBodies;
 use rustc_middle::ty::adjustment::Adjust;
@@ -19,9 +18,8 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
     let (scrutinee_expr, iter_expr_struct, iter_expr, some_pat, loop_expr) = if_chain! {
         if let Some(higher::WhileLet { if_then, let_pat, let_expr }) = higher::WhileLet::hir(expr);
         // check for `Some(..)` pattern
-        if let PatKind::TupleStruct(QPath::Resolved(None, pat_path), some_pat, _) = let_pat.kind;
-        if let Res::Def(_, pat_did) = pat_path.res;
-        if match_def_path(cx, pat_did, &paths::OPTION_SOME);
+        if let PatKind::TupleStruct(ref pat_path, some_pat, _) = let_pat.kind;
+        if is_res_lang_ctor(cx, cx.qpath_res(pat_path, let_pat.hir_id), LangItem::OptionSome);
         // check for call to `Iterator::next`
         if let ExprKind::MethodCall(method_name, iter_expr, [], _) = let_expr.kind;
         if method_name.ident.name == sym::next;
diff --git a/clippy_lints/src/matches/collapsible_match.rs b/clippy_lints/src/matches/collapsible_match.rs
index 07021f1bcad..fd14d868df3 100644
--- a/clippy_lints/src/matches/collapsible_match.rs
+++ b/clippy_lints/src/matches/collapsible_match.rs
@@ -1,7 +1,9 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::higher::IfLetOrMatch;
 use clippy_utils::visitors::is_local_used;
-use clippy_utils::{is_lang_ctor, is_unit_expr, path_to_local, peel_blocks_with_stmt, peel_ref_operators, SpanlessEq};
+use clippy_utils::{
+    is_res_lang_ctor, is_unit_expr, path_to_local, peel_blocks_with_stmt, peel_ref_operators, SpanlessEq,
+};
 use if_chain::if_chain;
 use rustc_errors::MultiSpan;
 use rustc_hir::LangItem::OptionNone;
@@ -110,7 +112,7 @@ fn arm_is_wild_like(cx: &LateContext<'_>, arm: &Arm<'_>) -> bool {
     }
     match arm.pat.kind {
         PatKind::Binding(..) | PatKind::Wild => true,
-        PatKind::Path(ref qpath) => is_lang_ctor(cx, qpath, OptionNone),
+        PatKind::Path(ref qpath) => is_res_lang_ctor(cx, cx.qpath_res(qpath, arm.pat.hir_id), OptionNone),
         _ => false,
     }
 }
diff --git a/clippy_lints/src/matches/manual_map.rs b/clippy_lints/src/matches/manual_map.rs
index 96b8339550c..76f5e1c941c 100644
--- a/clippy_lints/src/matches/manual_map.rs
+++ b/clippy_lints/src/matches/manual_map.rs
@@ -3,8 +3,8 @@ use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::{snippet_with_applicability, snippet_with_context};
 use clippy_utils::ty::{is_type_diagnostic_item, peel_mid_ty_refs_is_mutable, type_is_unsafe_function};
 use clippy_utils::{
-    can_move_expr_to_closure, is_else_clause, is_lang_ctor, is_lint_allowed, path_to_local_id, peel_blocks,
-    peel_hir_expr_refs, peel_hir_expr_while, CaptureKind,
+    can_move_expr_to_closure, is_else_clause, is_lint_allowed, is_res_lang_ctor, path_res, path_to_local_id,
+    peel_blocks, peel_hir_expr_refs, peel_hir_expr_while, CaptureKind,
 };
 use rustc_ast::util::parser::PREC_POSTFIX;
 use rustc_errors::Applicability;
@@ -251,9 +251,11 @@ fn try_parse_pattern<'tcx>(cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>, ctxt: Syn
         match pat.kind {
             PatKind::Wild => Some(OptionPat::Wild),
             PatKind::Ref(pat, _) => f(cx, pat, ref_count + 1, ctxt),
-            PatKind::Path(ref qpath) if is_lang_ctor(cx, qpath, OptionNone) => Some(OptionPat::None),
+            PatKind::Path(ref qpath) if is_res_lang_ctor(cx, cx.qpath_res(qpath, pat.hir_id), OptionNone) => {
+                Some(OptionPat::None)
+            },
             PatKind::TupleStruct(ref qpath, [pattern], _)
-                if is_lang_ctor(cx, qpath, OptionSome) && pat.span.ctxt() == ctxt =>
+                if is_res_lang_ctor(cx, cx.qpath_res(qpath, pat.hir_id), OptionSome) && pat.span.ctxt() == ctxt =>
             {
                 Some(OptionPat::Some { pattern, ref_count })
             },
@@ -272,16 +274,14 @@ fn get_some_expr<'tcx>(
 ) -> Option<SomeExpr<'tcx>> {
     // TODO: Allow more complex expressions.
     match expr.kind {
-        ExprKind::Call(
-            Expr {
-                kind: ExprKind::Path(ref qpath),
-                ..
-            },
-            [arg],
-        ) if ctxt == expr.span.ctxt() && is_lang_ctor(cx, qpath, OptionSome) => Some(SomeExpr {
-            expr: arg,
-            needs_unsafe_block,
-        }),
+        ExprKind::Call(callee, [arg])
+            if ctxt == expr.span.ctxt() && is_res_lang_ctor(cx, path_res(cx, callee), OptionSome) =>
+        {
+            Some(SomeExpr {
+                expr: arg,
+                needs_unsafe_block,
+            })
+        },
         ExprKind::Block(
             Block {
                 stmts: [],
@@ -302,5 +302,5 @@ fn get_some_expr<'tcx>(
 
 // Checks for the `None` value.
 fn is_none_expr(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-    matches!(peel_blocks(expr).kind, ExprKind::Path(ref qpath) if is_lang_ctor(cx, qpath, OptionNone))
+    is_res_lang_ctor(cx, path_res(cx, peel_blocks(expr)), OptionNone)
 }
diff --git a/clippy_lints/src/matches/manual_unwrap_or.rs b/clippy_lints/src/matches/manual_unwrap_or.rs
index 2fe7fe98a2e..587c926dc01 100644
--- a/clippy_lints/src/matches/manual_unwrap_or.rs
+++ b/clippy_lints/src/matches/manual_unwrap_or.rs
@@ -3,12 +3,14 @@ use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::{indent_of, reindent_multiline, snippet_opt};
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::usage::contains_return_break_continue_macro;
-use clippy_utils::{is_lang_ctor, path_to_local_id, sugg};
+use clippy_utils::{is_res_lang_ctor, path_to_local_id, sugg};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
-use rustc_hir::LangItem::{OptionNone, OptionSome, ResultErr, ResultOk};
+use rustc_hir::def::{DefKind, Res};
+use rustc_hir::LangItem::{OptionNone, ResultErr};
 use rustc_hir::{Arm, Expr, PatKind};
 use rustc_lint::LateContext;
+use rustc_middle::ty::DefIdTree;
 use rustc_span::sym;
 
 use super::MANUAL_UNWRAP_OR;
@@ -59,15 +61,19 @@ fn applicable_or_arm<'a>(cx: &LateContext<'_>, arms: &'a [Arm<'a>]) -> Option<&'
         if arms.iter().all(|arm| arm.guard.is_none());
         if let Some((idx, or_arm)) = arms.iter().enumerate().find(|(_, arm)| {
             match arm.pat.kind {
-                PatKind::Path(ref qpath) => is_lang_ctor(cx, qpath, OptionNone),
+                PatKind::Path(ref qpath) => is_res_lang_ctor(cx, cx.qpath_res(qpath, arm.pat.hir_id), OptionNone),
                 PatKind::TupleStruct(ref qpath, [pat], _) =>
-                    matches!(pat.kind, PatKind::Wild) && is_lang_ctor(cx, qpath, ResultErr),
+                    matches!(pat.kind, PatKind::Wild)
+                        && is_res_lang_ctor(cx, cx.qpath_res(qpath, arm.pat.hir_id), ResultErr),
                 _ => false,
             }
         });
         let unwrap_arm = &arms[1 - idx];
         if let PatKind::TupleStruct(ref qpath, [unwrap_pat], _) = unwrap_arm.pat.kind;
-        if is_lang_ctor(cx, qpath, OptionSome) || is_lang_ctor(cx, qpath, ResultOk);
+        if let Res::Def(DefKind::Ctor(..), ctor_id) = cx.qpath_res(qpath, unwrap_arm.pat.hir_id);
+        if let Some(variant_id) = cx.tcx.opt_parent(ctor_id);
+        if cx.tcx.lang_items().option_some_variant() == Some(variant_id)
+            || cx.tcx.lang_items().result_ok_variant() == Some(variant_id);
         if let PatKind::Binding(_, binding_hir_id, ..) = unwrap_pat.kind;
         if path_to_local_id(unwrap_arm.body, binding_hir_id);
         if cx.typeck_results().expr_adjustments(unwrap_arm.body).is_empty();
diff --git a/clippy_lints/src/matches/match_as_ref.rs b/clippy_lints/src/matches/match_as_ref.rs
index 39d30212f36..2818f030b7a 100644
--- a/clippy_lints/src/matches/match_as_ref.rs
+++ b/clippy_lints/src/matches/match_as_ref.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::{is_lang_ctor, peel_blocks};
+use clippy_utils::{is_res_lang_ctor, path_res, peel_blocks};
 use rustc_errors::Applicability;
 use rustc_hir::{Arm, BindingAnnotation, ByRef, Expr, ExprKind, LangItem, Mutability, PatKind, QPath};
 use rustc_lint::LateContext;
@@ -59,18 +59,20 @@ pub(crate) fn check(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>], expr:
 
 // Checks if arm has the form `None => None`
 fn is_none_arm(cx: &LateContext<'_>, arm: &Arm<'_>) -> bool {
-    matches!(arm.pat.kind, PatKind::Path(ref qpath) if is_lang_ctor(cx, qpath, LangItem::OptionNone))
+    matches!(
+        arm.pat.kind,
+        PatKind::Path(ref qpath) if is_res_lang_ctor(cx, cx.qpath_res(qpath, arm.pat.hir_id), LangItem::OptionNone)
+    )
 }
 
 // Checks if arm has the form `Some(ref v) => Some(v)` (checks for `ref` and `ref mut`)
 fn is_ref_some_arm(cx: &LateContext<'_>, arm: &Arm<'_>) -> Option<Mutability> {
     if_chain! {
         if let PatKind::TupleStruct(ref qpath, [first_pat, ..], _) = arm.pat.kind;
-        if is_lang_ctor(cx, qpath, LangItem::OptionSome);
+        if is_res_lang_ctor(cx, cx.qpath_res(qpath, arm.pat.hir_id), LangItem::OptionSome);
         if let PatKind::Binding(BindingAnnotation(ByRef::Yes, mutabl), .., ident, _) = first_pat.kind;
         if let ExprKind::Call(e, [arg]) = peel_blocks(arm.body).kind;
-        if let ExprKind::Path(ref some_path) = e.kind;
-        if is_lang_ctor(cx, some_path, LangItem::OptionSome);
+        if is_res_lang_ctor(cx, path_res(cx, e), LangItem::OptionSome);
         if let ExprKind::Path(QPath::Resolved(_, path2)) = arg.kind;
         if path2.segments.len() == 1 && ident.name == path2.segments[0].ident.name;
         then {
diff --git a/clippy_lints/src/matches/needless_match.rs b/clippy_lints/src/matches/needless_match.rs
index 9cbffbe61f1..c4f6852aedc 100644
--- a/clippy_lints/src/matches/needless_match.rs
+++ b/clippy_lints/src/matches/needless_match.rs
@@ -3,7 +3,7 @@ use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::{is_type_diagnostic_item, same_type_and_consts};
 use clippy_utils::{
-    eq_expr_value, get_parent_expr_for_hir, get_parent_node, higher, is_else_clause, is_lang_ctor, over,
+    eq_expr_value, get_parent_expr_for_hir, get_parent_node, higher, is_else_clause, is_res_lang_ctor, over, path_res,
     peel_blocks_with_stmt,
 };
 use rustc_errors::Applicability;
@@ -112,10 +112,7 @@ fn check_if_let_inner(cx: &LateContext<'_>, if_let: &higher::IfLet<'_>) -> bool
             let ret = strip_return(else_expr);
             let let_expr_ty = cx.typeck_results().expr_ty(if_let.let_expr);
             if is_type_diagnostic_item(cx, let_expr_ty, sym::Option) {
-                if let ExprKind::Path(ref qpath) = ret.kind {
-                    return is_lang_ctor(cx, qpath, OptionNone) || eq_expr_value(cx, if_let.let_expr, ret);
-                }
-                return false;
+                return is_res_lang_ctor(cx, path_res(cx, ret), OptionNone) || eq_expr_value(cx, if_let.let_expr, ret);
             }
             return eq_expr_value(cx, if_let.let_expr, ret);
         }
diff --git a/clippy_lints/src/matches/redundant_pattern_match.rs b/clippy_lints/src/matches/redundant_pattern_match.rs
index 6d6aa43df2a..81bebff34c8 100644
--- a/clippy_lints/src/matches/redundant_pattern_match.rs
+++ b/clippy_lints/src/matches/redundant_pattern_match.rs
@@ -4,10 +4,11 @@ use clippy_utils::source::snippet;
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::{is_type_diagnostic_item, needs_ordered_drop};
 use clippy_utils::visitors::any_temporaries_need_ordered_drop;
-use clippy_utils::{higher, is_lang_ctor, is_trait_method};
+use clippy_utils::{higher, is_trait_method};
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
+use rustc_hir::def::{DefKind, Res};
 use rustc_hir::LangItem::{self, OptionNone, OptionSome, PollPending, PollReady, ResultErr, ResultOk};
 use rustc_hir::{Arm, Expr, ExprKind, Node, Pat, PatKind, QPath, UnOp};
 use rustc_lint::LateContext;
@@ -87,15 +88,21 @@ fn find_sugg_for_if_let<'tcx>(
             }
         },
         PatKind::Path(ref path) => {
-            let method = if is_lang_ctor(cx, path, OptionNone) {
-                "is_none()"
-            } else if is_lang_ctor(cx, path, PollPending) {
-                "is_pending()"
+            if let Res::Def(DefKind::Ctor(..), ctor_id) = cx.qpath_res(path, check_pat.hir_id)
+                && let Some(variant_id) = cx.tcx.opt_parent(ctor_id)
+            {
+                let method = if cx.tcx.lang_items().option_none_variant() == Some(variant_id) {
+                    "is_none()"
+                } else if cx.tcx.lang_items().poll_pending_variant() == Some(variant_id) {
+                    "is_pending()"
+                } else {
+                    return;
+                };
+                // `None` and `Pending` don't have an inner type.
+                (method, cx.tcx.types.unit)
             } else {
                 return;
-            };
-            // `None` and `Pending` don't have an inner type.
-            (method, cx.tcx.types.unit)
+            }
         },
         _ => return,
     };
diff --git a/clippy_lints/src/matches/try_err.rs b/clippy_lints/src/matches/try_err.rs
index a3ec1ff2482..c6cba81d871 100644
--- a/clippy_lints/src/matches/try_err.rs
+++ b/clippy_lints/src/matches/try_err.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{get_parent_expr, is_lang_ctor, match_def_path, paths};
+use clippy_utils::{get_parent_expr, is_res_lang_ctor, match_def_path, path_res, paths};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::LangItem::ResultErr;
@@ -27,8 +27,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, scrutine
         if let ExprKind::Path(ref match_fun_path) = match_fun.kind;
         if matches!(match_fun_path, QPath::LangItem(LangItem::TryTraitBranch, ..));
         if let ExprKind::Call(err_fun, [err_arg, ..]) = try_arg.kind;
-        if let ExprKind::Path(ref err_fun_path) = err_fun.kind;
-        if is_lang_ctor(cx, err_fun_path, ResultErr);
+        if is_res_lang_ctor(cx, path_res(cx, err_fun), ResultErr);
         if let Some(return_ty) = find_return_type(cx, &expr.kind);
         then {
             let prefix;
diff --git a/clippy_lints/src/mem_replace.rs b/clippy_lints/src/mem_replace.rs
index cad3ea2a176..0c4d9f100f7 100644
--- a/clippy_lints/src/mem_replace.rs
+++ b/clippy_lints/src/mem_replace.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::{snippet, snippet_with_applicability};
 use clippy_utils::ty::is_non_aggregate_primitive_type;
-use clippy_utils::{is_default_equivalent, is_lang_ctor, meets_msrv, msrvs};
+use clippy_utils::{is_default_equivalent, is_res_lang_ctor, meets_msrv, msrvs, path_res};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::LangItem::OptionNone;
@@ -102,40 +102,38 @@ impl_lint_pass!(MemReplace =>
     [MEM_REPLACE_OPTION_WITH_NONE, MEM_REPLACE_WITH_UNINIT, MEM_REPLACE_WITH_DEFAULT]);
 
 fn check_replace_option_with_none(cx: &LateContext<'_>, src: &Expr<'_>, dest: &Expr<'_>, expr_span: Span) {
-    if let ExprKind::Path(ref replacement_qpath) = src.kind {
-        // Check that second argument is `Option::None`
-        if is_lang_ctor(cx, replacement_qpath, OptionNone) {
-            // Since this is a late pass (already type-checked),
-            // and we already know that the second argument is an
-            // `Option`, we do not need to check the first
-            // argument's type. All that's left is to get
-            // replacee's path.
-            let replaced_path = match dest.kind {
-                ExprKind::AddrOf(BorrowKind::Ref, Mutability::Mut, replaced) => {
-                    if let ExprKind::Path(QPath::Resolved(None, replaced_path)) = replaced.kind {
-                        replaced_path
-                    } else {
-                        return;
-                    }
-                },
-                ExprKind::Path(QPath::Resolved(None, replaced_path)) => replaced_path,
-                _ => return,
-            };
+    // Check that second argument is `Option::None`
+    if is_res_lang_ctor(cx, path_res(cx, src), OptionNone) {
+        // Since this is a late pass (already type-checked),
+        // and we already know that the second argument is an
+        // `Option`, we do not need to check the first
+        // argument's type. All that's left is to get
+        // replacee's path.
+        let replaced_path = match dest.kind {
+            ExprKind::AddrOf(BorrowKind::Ref, Mutability::Mut, replaced) => {
+                if let ExprKind::Path(QPath::Resolved(None, replaced_path)) = replaced.kind {
+                    replaced_path
+                } else {
+                    return;
+                }
+            },
+            ExprKind::Path(QPath::Resolved(None, replaced_path)) => replaced_path,
+            _ => return,
+        };
 
-            let mut applicability = Applicability::MachineApplicable;
-            span_lint_and_sugg(
-                cx,
-                MEM_REPLACE_OPTION_WITH_NONE,
-                expr_span,
-                "replacing an `Option` with `None`",
-                "consider `Option::take()` instead",
-                format!(
-                    "{}.take()",
-                    snippet_with_applicability(cx, replaced_path.span, "", &mut applicability)
-                ),
-                applicability,
-            );
-        }
+        let mut applicability = Applicability::MachineApplicable;
+        span_lint_and_sugg(
+            cx,
+            MEM_REPLACE_OPTION_WITH_NONE,
+            expr_span,
+            "replacing an `Option` with `None`",
+            "consider `Option::take()` instead",
+            format!(
+                "{}.take()",
+                snippet_with_applicability(cx, replaced_path.span, "", &mut applicability)
+            ),
+            applicability,
+        );
     }
 }
 
@@ -203,10 +201,8 @@ fn check_replace_with_default(cx: &LateContext<'_>, src: &Expr<'_>, dest: &Expr<
         return;
     }
     // disable lint for Option since it is covered in another lint
-    if let ExprKind::Path(q) = &src.kind {
-        if is_lang_ctor(cx, q, OptionNone) {
-            return;
-        }
+    if is_res_lang_ctor(cx, path_res(cx, src), OptionNone) {
+        return;
     }
     if is_default_equivalent(cx, src) && !in_external_macro(cx.tcx.sess, expr_span) {
         span_lint_and_then(
diff --git a/clippy_lints/src/methods/iter_on_single_or_empty_collections.rs b/clippy_lints/src/methods/iter_on_single_or_empty_collections.rs
index cea7b0d82ff..4f73b3ec422 100644
--- a/clippy_lints/src/methods/iter_on_single_or_empty_collections.rs
+++ b/clippy_lints/src/methods/iter_on_single_or_empty_collections.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet;
-use clippy_utils::{get_expr_use_or_unification_node, is_lang_ctor, is_no_std_crate};
+use clippy_utils::{get_expr_use_or_unification_node, is_no_std_crate, is_res_lang_ctor, path_res};
 
 use rustc_errors::Applicability;
 use rustc_hir::LangItem::{OptionNone, OptionSome};
@@ -26,26 +26,11 @@ impl IterType {
 }
 
 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, method_name: &str, recv: &Expr<'_>) {
-    let item = match &recv.kind {
-        ExprKind::Array(v) if v.len() <= 1 => v.first(),
-        ExprKind::Path(p) => {
-            if is_lang_ctor(cx, p, OptionNone) {
-                None
-            } else {
-                return;
-            }
-        },
-        ExprKind::Call(f, some_args) if some_args.len() == 1 => {
-            if let ExprKind::Path(p) = &f.kind {
-                if is_lang_ctor(cx, p, OptionSome) {
-                    Some(&some_args[0])
-                } else {
-                    return;
-                }
-            } else {
-                return;
-            }
-        },
+    let item = match recv.kind {
+        ExprKind::Array([]) => None,
+        ExprKind::Array([e]) => Some(e),
+        ExprKind::Path(ref p) if is_res_lang_ctor(cx, cx.qpath_res(p, recv.hir_id), OptionNone) => None,
+        ExprKind::Call(f, [arg]) if is_res_lang_ctor(cx, path_res(cx, f), OptionSome) => Some(arg),
         _ => return,
     };
     let iter_type = match method_name {
diff --git a/clippy_lints/src/methods/manual_ok_or.rs b/clippy_lints/src/methods/manual_ok_or.rs
index d9fb4382181..5b758f1e654 100644
--- a/clippy_lints/src/methods/manual_ok_or.rs
+++ b/clippy_lints/src/methods/manual_ok_or.rs
@@ -1,11 +1,11 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::{indent_of, reindent_multiline, snippet_opt};
 use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{is_lang_ctor, path_to_local_id};
+use clippy_utils::{is_res_lang_ctor, path_res, path_to_local_id};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::LangItem::{ResultErr, ResultOk};
-use rustc_hir::{Closure, Expr, ExprKind, PatKind};
+use rustc_hir::{Expr, ExprKind, PatKind};
 use rustc_lint::LateContext;
 use rustc_span::symbol::sym;
 
@@ -22,8 +22,8 @@ pub(super) fn check<'tcx>(
         if let Some(method_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
         if let Some(impl_id) = cx.tcx.impl_of_method(method_id);
         if is_type_diagnostic_item(cx, cx.tcx.type_of(impl_id), sym::Option);
-        if let ExprKind::Call(Expr { kind: ExprKind::Path(err_path), .. }, [err_arg]) = or_expr.kind;
-        if is_lang_ctor(cx, err_path, ResultErr);
+        if let ExprKind::Call(err_path, [err_arg]) = or_expr.kind;
+        if is_res_lang_ctor(cx, path_res(cx, err_path), ResultErr);
         if is_ok_wrapping(cx, map_expr);
         if let Some(recv_snippet) = snippet_opt(cx, recv.span);
         if let Some(err_arg_snippet) = snippet_opt(cx, err_arg.span);
@@ -46,17 +46,19 @@ pub(super) fn check<'tcx>(
 }
 
 fn is_ok_wrapping(cx: &LateContext<'_>, map_expr: &Expr<'_>) -> bool {
-    if let ExprKind::Path(ref qpath) = map_expr.kind {
-        if is_lang_ctor(cx, qpath, ResultOk) {
-            return true;
-        }
-    }
-    if_chain! {
-        if let ExprKind::Closure(&Closure { body, .. }) = map_expr.kind;
-        let body = cx.tcx.hir().body(body);
-        if let PatKind::Binding(_, param_id, ..) = body.params[0].pat.kind;
-        if let ExprKind::Call(Expr { kind: ExprKind::Path(ok_path), .. }, [ok_arg]) = body.value.kind;
-        if is_lang_ctor(cx, ok_path, ResultOk);
-        then { path_to_local_id(ok_arg, param_id) } else { false }
+    match map_expr.kind {
+        ExprKind::Path(ref qpath) if is_res_lang_ctor(cx, cx.qpath_res(qpath, map_expr.hir_id), ResultOk) => true,
+        ExprKind::Closure(closure) => {
+            let body = cx.tcx.hir().body(closure.body);
+            if let PatKind::Binding(_, param_id, ..) = body.params[0].pat.kind
+                && let ExprKind::Call(callee, [ok_arg]) = body.value.kind
+                && is_res_lang_ctor(cx, path_res(cx, callee), ResultOk)
+            {
+                path_to_local_id(ok_arg, param_id)
+            } else {
+                false
+            }
+        },
+        _ => false,
     }
 }
diff --git a/clippy_lints/src/methods/option_map_or_none.rs b/clippy_lints/src/methods/option_map_or_none.rs
index 76572425346..3a23ecc50dc 100644
--- a/clippy_lints/src/methods/option_map_or_none.rs
+++ b/clippy_lints/src/methods/option_map_or_none.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{is_lang_ctor, path_def_id};
+use clippy_utils::{is_res_lang_ctor, path_def_id, path_res};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_hir::LangItem::{OptionNone, OptionSome};
@@ -51,22 +51,12 @@ pub(super) fn check<'tcx>(
         return;
     }
 
-    let default_arg_is_none = if let hir::ExprKind::Path(ref qpath) = def_arg.kind {
-        is_lang_ctor(cx, qpath, OptionNone)
-    } else {
-        return;
-    };
-
-    if !default_arg_is_none {
+    if !is_res_lang_ctor(cx, path_res(cx, def_arg), OptionNone) {
         // nothing to lint!
         return;
     }
 
-    let f_arg_is_some = if let hir::ExprKind::Path(ref qpath) = map_arg.kind {
-        is_lang_ctor(cx, qpath, OptionSome)
-    } else {
-        false
-    };
+    let f_arg_is_some = is_res_lang_ctor(cx, path_res(cx, map_arg), OptionSome);
 
     if is_option {
         let self_snippet = snippet(cx, recv.span, "..");
diff --git a/clippy_lints/src/methods/or_then_unwrap.rs b/clippy_lints/src/methods/or_then_unwrap.rs
index be5768c3545..55ba6e262df 100644
--- a/clippy_lints/src/methods/or_then_unwrap.rs
+++ b/clippy_lints/src/methods/or_then_unwrap.rs
@@ -1,6 +1,6 @@
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{diagnostics::span_lint_and_sugg, is_lang_ctor};
+use clippy_utils::{diagnostics::span_lint_and_sugg, is_res_lang_ctor, path_res};
 use rustc_errors::Applicability;
 use rustc_hir::{lang_items::LangItem, Expr, ExprKind};
 use rustc_lint::LateContext;
@@ -58,8 +58,7 @@ pub(super) fn check<'tcx>(
 
 fn get_content_if_ctor_matches(cx: &LateContext<'_>, expr: &Expr<'_>, item: LangItem) -> Option<Span> {
     if let ExprKind::Call(some_expr, [arg]) = expr.kind
-        && let ExprKind::Path(qpath) = &some_expr.kind
-        && is_lang_ctor(cx, qpath, item)
+        && is_res_lang_ctor(cx, path_res(cx, some_expr), item)
     {
         Some(arg.span)
     } else {
diff --git a/clippy_lints/src/methods/unnecessary_filter_map.rs b/clippy_lints/src/methods/unnecessary_filter_map.rs
index ee16982d524..50434a5658a 100644
--- a/clippy_lints/src/methods/unnecessary_filter_map.rs
+++ b/clippy_lints/src/methods/unnecessary_filter_map.rs
@@ -2,7 +2,7 @@ use super::utils::clone_or_copy_needed;
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::ty::is_copy;
 use clippy_utils::usage::mutated_variables;
-use clippy_utils::{is_lang_ctor, is_trait_method, path_to_local_id};
+use clippy_utils::{is_res_lang_ctor, is_trait_method, path_res, path_to_local_id};
 use rustc_hir as hir;
 use rustc_hir::intravisit::{walk_expr, Visitor};
 use rustc_hir::LangItem::{OptionNone, OptionSome};
@@ -61,15 +61,13 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, arg: &hir::Expr<
 
 // returns (found_mapping, found_filtering)
 fn check_expression<'tcx>(cx: &LateContext<'tcx>, arg_id: hir::HirId, expr: &'tcx hir::Expr<'_>) -> (bool, bool) {
-    match &expr.kind {
+    match expr.kind {
         hir::ExprKind::Call(func, args) => {
-            if let hir::ExprKind::Path(ref path) = func.kind {
-                if is_lang_ctor(cx, path, OptionSome) {
-                    if path_to_local_id(&args[0], arg_id) {
-                        return (false, false);
-                    }
-                    return (true, false);
+            if is_res_lang_ctor(cx, path_res(cx, func), OptionSome) {
+                if path_to_local_id(&args[0], arg_id) {
+                    return (false, false);
                 }
+                return (true, false);
             }
             (true, true)
         },
@@ -80,7 +78,7 @@ fn check_expression<'tcx>(cx: &LateContext<'tcx>, arg_id: hir::HirId, expr: &'tc
         hir::ExprKind::Match(_, arms, _) => {
             let mut found_mapping = false;
             let mut found_filtering = false;
-            for arm in *arms {
+            for arm in arms {
                 let (m, f) = check_expression(cx, arg_id, arm.body);
                 found_mapping |= m;
                 found_filtering |= f;
@@ -93,7 +91,9 @@ fn check_expression<'tcx>(cx: &LateContext<'tcx>, arg_id: hir::HirId, expr: &'tc
             let else_check = check_expression(cx, arg_id, else_arm);
             (if_check.0 | else_check.0, if_check.1 | else_check.1)
         },
-        hir::ExprKind::Path(path) if is_lang_ctor(cx, path, OptionNone) => (false, true),
+        hir::ExprKind::Path(ref path) if is_res_lang_ctor(cx, cx.qpath_res(path, expr.hir_id), OptionNone) => {
+            (false, true)
+        },
         _ => (true, true),
     }
 }
diff --git a/clippy_lints/src/needless_question_mark.rs b/clippy_lints/src/needless_question_mark.rs
index 59b6492e112..97c8cfbd3eb 100644
--- a/clippy_lints/src/needless_question_mark.rs
+++ b/clippy_lints/src/needless_question_mark.rs
@@ -1,11 +1,12 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::is_lang_ctor;
+use clippy_utils::path_res;
 use clippy_utils::source::snippet;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
-use rustc_hir::LangItem::{OptionSome, ResultOk};
+use rustc_hir::def::{DefKind, Res};
 use rustc_hir::{AsyncGeneratorKind, Block, Body, Expr, ExprKind, GeneratorKind, LangItem, MatchSource, QPath};
 use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::DefIdTree;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
@@ -112,11 +113,12 @@ impl LateLintPass<'_> for NeedlessQuestionMark {
 
 fn check(cx: &LateContext<'_>, expr: &Expr<'_>) {
     if_chain! {
-        if let ExprKind::Call(path, [arg]) = &expr.kind;
-        if let ExprKind::Path(ref qpath) = &path.kind;
-        let sugg_remove = if is_lang_ctor(cx, qpath, OptionSome) {
+        if let ExprKind::Call(path, [arg]) = expr.kind;
+        if let Res::Def(DefKind::Ctor(..), ctor_id) = path_res(cx, path);
+        if let Some(variant_id) = cx.tcx.opt_parent(ctor_id);
+        let sugg_remove = if cx.tcx.lang_items().option_some_variant() == Some(variant_id) {
             "Some()"
-        } else if is_lang_ctor(cx, qpath, ResultOk) {
+        } else if cx.tcx.lang_items().result_ok_variant() == Some(variant_id) {
             "Ok()"
         } else {
             return;
diff --git a/clippy_lints/src/option_if_let_else.rs b/clippy_lints/src/option_if_let_else.rs
index 2c1e3b855d5..4eb42da1fed 100644
--- a/clippy_lints/src/option_if_let_else.rs
+++ b/clippy_lints/src/option_if_let_else.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::sugg::Sugg;
 use clippy_utils::{
-    can_move_expr_to_closure, eager_or_lazy, higher, in_constant, is_else_clause, is_lang_ctor, peel_blocks,
+    can_move_expr_to_closure, eager_or_lazy, higher, in_constant, is_else_clause, is_res_lang_ctor, peel_blocks,
     peel_hir_expr_while, CaptureKind,
 };
 use if_chain::if_chain;
@@ -174,7 +174,8 @@ fn try_get_option_occurrence<'tcx>(
 
 fn try_get_inner_pat<'tcx>(cx: &LateContext<'tcx>, pat: &Pat<'tcx>) -> Option<&'tcx Pat<'tcx>> {
     if let PatKind::TupleStruct(ref qpath, [inner_pat], ..) = pat.kind {
-        if is_lang_ctor(cx, qpath, OptionSome) || is_lang_ctor(cx, qpath, ResultOk) {
+        let res = cx.qpath_res(qpath, pat.hir_id);
+        if is_res_lang_ctor(cx, res, OptionSome) || is_res_lang_ctor(cx, res, ResultOk) {
             return Some(inner_pat);
         }
     }
@@ -226,9 +227,10 @@ fn try_convert_match<'tcx>(
 
 fn is_none_or_err_arm(cx: &LateContext<'_>, arm: &Arm<'_>) -> bool {
     match arm.pat.kind {
-        PatKind::Path(ref qpath) => is_lang_ctor(cx, qpath, OptionNone),
+        PatKind::Path(ref qpath) => is_res_lang_ctor(cx, cx.qpath_res(qpath, arm.pat.hir_id), OptionNone),
         PatKind::TupleStruct(ref qpath, [first_pat], _) => {
-            is_lang_ctor(cx, qpath, ResultErr) && matches!(first_pat.kind, PatKind::Wild)
+            is_res_lang_ctor(cx, cx.qpath_res(qpath, arm.pat.hir_id), ResultErr)
+                && matches!(first_pat.kind, PatKind::Wild)
         },
         PatKind::Wild => true,
         _ => false,
diff --git a/clippy_lints/src/partialeq_to_none.rs b/clippy_lints/src/partialeq_to_none.rs
index 000b0ba7a14..6810a243175 100644
--- a/clippy_lints/src/partialeq_to_none.rs
+++ b/clippy_lints/src/partialeq_to_none.rs
@@ -1,5 +1,5 @@
 use clippy_utils::{
-    diagnostics::span_lint_and_sugg, is_lang_ctor, peel_hir_expr_refs, peel_ref_operators, sugg,
+    diagnostics::span_lint_and_sugg, is_res_lang_ctor, path_res, peel_hir_expr_refs, peel_ref_operators, sugg,
     ty::is_type_diagnostic_item,
 };
 use rustc_errors::Applicability;
@@ -54,8 +54,7 @@ impl<'tcx> LateLintPass<'tcx> for PartialeqToNone {
         // If the expression is a literal `Option::None`
         let is_none_ctor = |expr: &Expr<'_>| {
             !expr.span.from_expansion()
-                && matches!(&peel_hir_expr_refs(expr).0.kind,
-            ExprKind::Path(p) if is_lang_ctor(cx, p, LangItem::OptionNone))
+                && is_res_lang_ctor(cx, path_res(cx, peel_hir_expr_refs(expr).0), LangItem::OptionNone)
         };
 
         let mut applicability = Applicability::MachineApplicable;
diff --git a/clippy_lints/src/question_mark.rs b/clippy_lints/src/question_mark.rs
index 0b3d5d17480..328371fd602 100644
--- a/clippy_lints/src/question_mark.rs
+++ b/clippy_lints/src/question_mark.rs
@@ -3,11 +3,12 @@ use clippy_utils::higher;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::{
-    eq_expr_value, get_parent_node, in_constant, is_else_clause, is_lang_ctor, path_to_local, path_to_local_id,
+    eq_expr_value, get_parent_node, in_constant, is_else_clause, is_res_lang_ctor, path_to_local, path_to_local_id,
     peel_blocks, peel_blocks_with_stmt,
 };
 use if_chain::if_chain;
 use rustc_errors::Applicability;
+use rustc_hir::def::Res;
 use rustc_hir::LangItem::{OptionNone, OptionSome, ResultErr, ResultOk};
 use rustc_hir::{BindingAnnotation, ByRef, Expr, ExprKind, Node, PatKind, PathSegment, QPath};
 use rustc_lint::{LateContext, LateLintPass};
@@ -58,7 +59,7 @@ enum IfBlockType<'hir> {
     /// Contains: let_pat_qpath (Xxx), let_pat_type, let_pat_sym (a), let_expr (b), if_then (c),
     /// if_else (d)
     IfLet(
-        &'hir QPath<'hir>,
+        Res,
         Ty<'hir>,
         Symbol,
         &'hir Expr<'hir>,
@@ -126,7 +127,14 @@ fn check_if_let_some_or_err_and_early_return<'tcx>(cx: &LateContext<'tcx>, expr:
         if ddpos.as_opt_usize().is_none();
         if let PatKind::Binding(BindingAnnotation(by_ref, _), bind_id, ident, None) = field.kind;
         let caller_ty = cx.typeck_results().expr_ty(let_expr);
-        let if_block = IfBlockType::IfLet(path1, caller_ty, ident.name, let_expr, if_then, if_else);
+        let if_block = IfBlockType::IfLet(
+            cx.qpath_res(path1, let_pat.hir_id),
+            caller_ty,
+            ident.name,
+            let_expr,
+            if_then,
+            if_else
+        );
         if (is_early_return(sym::Option, cx, &if_block) && path_to_local_id(peel_blocks(if_then), bind_id))
             || is_early_return(sym::Result, cx, &if_block);
         if if_else.map(|e| eq_expr_value(cx, let_expr, peel_blocks(e))).filter(|e| *e).is_none();
@@ -165,21 +173,21 @@ fn is_early_return(smbl: Symbol, cx: &LateContext<'_>, if_block: &IfBlockType<'_
                     _ => false,
                 }
         },
-        IfBlockType::IfLet(qpath, let_expr_ty, let_pat_sym, let_expr, if_then, if_else) => {
+        IfBlockType::IfLet(res, let_expr_ty, let_pat_sym, let_expr, if_then, if_else) => {
             is_type_diagnostic_item(cx, let_expr_ty, smbl)
                 && match smbl {
                     sym::Option => {
                         // We only need to check `if let Some(x) = option` not `if let None = option`,
                         // because the later one will be suggested as `if option.is_none()` thus causing conflict.
-                        is_lang_ctor(cx, qpath, OptionSome)
+                        is_res_lang_ctor(cx, res, OptionSome)
                             && if_else.is_some()
                             && expr_return_none_or_err(smbl, cx, if_else.unwrap(), let_expr, None)
                     },
                     sym::Result => {
-                        (is_lang_ctor(cx, qpath, ResultOk)
+                        (is_res_lang_ctor(cx, res, ResultOk)
                             && if_else.is_some()
                             && expr_return_none_or_err(smbl, cx, if_else.unwrap(), let_expr, Some(let_pat_sym)))
-                            || is_lang_ctor(cx, qpath, ResultErr)
+                            || is_res_lang_ctor(cx, res, ResultErr)
                                 && expr_return_none_or_err(smbl, cx, if_then, let_expr, Some(let_pat_sym))
                     },
                     _ => false,
@@ -198,7 +206,7 @@ fn expr_return_none_or_err(
     match peel_blocks_with_stmt(expr).kind {
         ExprKind::Ret(Some(ret_expr)) => expr_return_none_or_err(smbl, cx, ret_expr, cond_expr, err_sym),
         ExprKind::Path(ref qpath) => match smbl {
-            sym::Option => is_lang_ctor(cx, qpath, OptionNone),
+            sym::Option => is_res_lang_ctor(cx, cx.qpath_res(qpath, expr.hir_id), OptionNone),
             sym::Result => path_to_local(expr).is_some() && path_to_local(expr) == path_to_local(cond_expr),
             _ => false,
         },
diff --git a/clippy_lints/src/unnecessary_wraps.rs b/clippy_lints/src/unnecessary_wraps.rs
index 83ef3b0fac8..7211e6864f3 100644
--- a/clippy_lints/src/unnecessary_wraps.rs
+++ b/clippy_lints/src/unnecessary_wraps.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet;
-use clippy_utils::{contains_return, is_lang_ctor, return_ty, visitors::find_all_ret_expressions};
+use clippy_utils::{contains_return, is_res_lang_ctor, path_res, return_ty, visitors::find_all_ret_expressions};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::FnKind;
@@ -120,9 +120,7 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryWraps {
                 if !ret_expr.span.from_expansion();
                 // Check if a function call.
                 if let ExprKind::Call(func, [arg]) = ret_expr.kind;
-                // Check if OPTION_SOME or RESULT_OK, depending on return type.
-                if let ExprKind::Path(qpath) = &func.kind;
-                if is_lang_ctor(cx, qpath, lang_item);
+                if is_res_lang_ctor(cx, path_res(cx, func), lang_item);
                 // Make sure the function argument does not contain a return expression.
                 if !contains_return(arg);
                 then {
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index d67ceaec035..c7cc5d04c85 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -238,17 +238,27 @@ pub fn in_constant(cx: &LateContext<'_>, id: HirId) -> bool {
     }
 }
 
-/// Checks if a `QPath` resolves to a constructor of a `LangItem`.
+/// Checks if a `Res` refers to a constructor of a `LangItem`
 /// For example, use this to check whether a function call or a pattern is `Some(..)`.
-pub fn is_lang_ctor(cx: &LateContext<'_>, qpath: &QPath<'_>, lang_item: LangItem) -> bool {
-    if let QPath::Resolved(_, path) = qpath {
-        if let Res::Def(DefKind::Ctor(..), ctor_id) = path.res {
-            if let Ok(item_id) = cx.tcx.lang_items().require(lang_item) {
-                return cx.tcx.parent(ctor_id) == item_id;
-            }
-        }
+pub fn is_res_lang_ctor(cx: &LateContext<'_>, res: Res, lang_item: LangItem) -> bool {
+    if let Res::Def(DefKind::Ctor(..), id) = res
+        && let Ok(lang_id) = cx.tcx.lang_items().require(lang_item)
+        && let Some(id) = cx.tcx.opt_parent(id)
+    {
+        id == lang_id
+    } else {
+        false
+    }
+}
+
+pub fn is_res_diagnostic_ctor(cx: &LateContext<'_>, res: Res, diag_item: Symbol) -> bool {
+    if let Res::Def(DefKind::Ctor(..), id) = res
+        && let Some(id) = cx.tcx.opt_parent(id)
+    {
+        cx.tcx.is_diagnostic_item(diag_item, id)
+    } else {
+        false
     }
-    false
 }
 
 pub fn is_unit_expr(expr: &Expr<'_>) -> bool {
@@ -738,7 +748,7 @@ pub fn is_default_equivalent(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
             }
         },
         ExprKind::Call(repl_func, _) => is_default_equivalent_call(cx, repl_func),
-        ExprKind::Path(qpath) => is_lang_ctor(cx, qpath, OptionNone),
+        ExprKind::Path(qpath) => is_res_lang_ctor(cx, cx.qpath_res(qpath, e.hir_id), OptionNone),
         ExprKind::AddrOf(rustc_hir::BorrowKind::Ref, _, expr) => matches!(expr.kind, ExprKind::Array([])),
         _ => false,
     }
@@ -1553,7 +1563,7 @@ pub fn is_try<'tcx>(cx: &LateContext<'_>, expr: &'tcx Expr<'tcx>) -> Option<&'tc
         if_chain! {
             if let PatKind::TupleStruct(ref path, pat, ddpos) = arm.pat.kind;
             if ddpos.as_opt_usize().is_none();
-            if is_lang_ctor(cx, path, ResultOk);
+            if is_res_lang_ctor(cx, cx.qpath_res(path, arm.pat.hir_id), ResultOk);
             if let PatKind::Binding(_, hir_id, _, None) = pat[0].kind;
             if path_to_local_id(arm.body, hir_id);
             then {
@@ -1565,7 +1575,7 @@ pub fn is_try<'tcx>(cx: &LateContext<'_>, expr: &'tcx Expr<'tcx>) -> Option<&'tc
 
     fn is_err(cx: &LateContext<'_>, arm: &Arm<'_>) -> bool {
         if let PatKind::TupleStruct(ref path, _, _) = arm.pat.kind {
-            is_lang_ctor(cx, path, ResultErr)
+            is_res_lang_ctor(cx, cx.qpath_res(path, arm.pat.hir_id), ResultErr)
         } else {
             false
         }
-- 
cgit 1.4.1-3-g733a5


From 162aa19793f21c99cf7ec2a8c080ee2f8843f7db Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Thu, 11 Nov 2021 14:15:01 -0500
Subject: Fix and improve internal lint checking for `match_type` usages

* Check for `const`s and `static`s from external crates
* Check for `LangItem`s
* Handle inherent functions which have the same name as a field
* Also check the following functions:
    * `match_trait_method`
    * `match_def_path`
    * `is_expr_path_def_path`
    * `is_qpath_def_path`
* Handle checking for a constructor to a diagnostic item or `LangItem`
---
 clippy_lints/src/await_holding_invalid.rs          |   8 +-
 clippy_lints/src/infinite_iter.rs                  |  15 +-
 clippy_lints/src/inherent_to_string.rs             |   7 +-
 clippy_lints/src/lib.register_internal.rs          |   2 +-
 clippy_lints/src/lib.register_lints.rs             |   4 +-
 clippy_lints/src/lib.rs                            |   2 +-
 clippy_lints/src/manual_retain.rs                  |   2 +-
 clippy_lints/src/methods/filetype_is_file.rs       |   7 +-
 clippy_lints/src/methods/inefficient_to_string.rs  |   2 +-
 clippy_lints/src/methods/manual_str_repeat.rs      |   8 +-
 clippy_lints/src/methods/useless_asref.rs          |   5 +-
 clippy_lints/src/minmax.rs                         |   4 +-
 clippy_lints/src/non_octal_unix_permissions.rs     |   5 +-
 clippy_lints/src/slow_vector_initialization.rs     |   4 +-
 .../src/unnecessary_owned_empty_strings.rs         |   4 +-
 clippy_lints/src/unused_io_amount.rs               |   7 +-
 clippy_lints/src/useless_conversion.rs             |   4 +-
 clippy_lints/src/utils/internal_lints.rs           | 277 ++++++++++++++++-----
 clippy_utils/src/lib.rs                            |  47 ++++
 clippy_utils/src/paths.rs                          |   3 -
 tests/ui-internal/auxiliary/paths.rs               |   2 +
 tests/ui-internal/match_type_on_diag_item.rs       |  39 ---
 tests/ui-internal/match_type_on_diag_item.stderr   |  27 --
 tests/ui-internal/unnecessary_def_path.fixed       |  62 +++++
 tests/ui-internal/unnecessary_def_path.rs          |  62 +++++
 tests/ui-internal/unnecessary_def_path.stderr      | 101 ++++++++
 26 files changed, 534 insertions(+), 176 deletions(-)
 create mode 100644 tests/ui-internal/auxiliary/paths.rs
 delete mode 100644 tests/ui-internal/match_type_on_diag_item.rs
 delete mode 100644 tests/ui-internal/match_type_on_diag_item.stderr
 create mode 100644 tests/ui-internal/unnecessary_def_path.fixed
 create mode 100644 tests/ui-internal/unnecessary_def_path.rs
 create mode 100644 tests/ui-internal/unnecessary_def_path.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/await_holding_invalid.rs b/clippy_lints/src/await_holding_invalid.rs
index 1761360fb28..24a3588ecf1 100644
--- a/clippy_lints/src/await_holding_invalid.rs
+++ b/clippy_lints/src/await_holding_invalid.rs
@@ -6,7 +6,7 @@ use rustc_hir::{def::Res, AsyncGeneratorKind, Body, BodyId, GeneratorKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::GeneratorInteriorTypeCause;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::Span;
+use rustc_span::{sym, Span};
 
 use crate::utils::conf::DisallowedType;
 
@@ -276,9 +276,9 @@ fn emit_invalid_type(cx: &LateContext<'_>, span: Span, disallowed: &DisallowedTy
 }
 
 fn is_mutex_guard(cx: &LateContext<'_>, def_id: DefId) -> bool {
-    match_def_path(cx, def_id, &paths::MUTEX_GUARD)
-        || match_def_path(cx, def_id, &paths::RWLOCK_READ_GUARD)
-        || match_def_path(cx, def_id, &paths::RWLOCK_WRITE_GUARD)
+    cx.tcx.is_diagnostic_item(sym::MutexGuard, def_id)
+        || cx.tcx.is_diagnostic_item(sym::RwLockReadGuard, def_id)
+        || cx.tcx.is_diagnostic_item(sym::RwLockWriteGuard, def_id)
         || match_def_path(cx, def_id, &paths::PARKING_LOT_MUTEX_GUARD)
         || match_def_path(cx, def_id, &paths::PARKING_LOT_RWLOCK_READ_GUARD)
         || match_def_path(cx, def_id, &paths::PARKING_LOT_RWLOCK_WRITE_GUARD)
diff --git a/clippy_lints/src/infinite_iter.rs b/clippy_lints/src/infinite_iter.rs
index 8c2c96fa105..d1d2db27c6f 100644
--- a/clippy_lints/src/infinite_iter.rs
+++ b/clippy_lints/src/infinite_iter.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint;
+use clippy_utils::higher;
 use clippy_utils::ty::{implements_trait, is_type_diagnostic_item};
-use clippy_utils::{higher, match_def_path, path_def_id, paths};
 use rustc_hir::{BorrowKind, Closure, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -168,9 +168,16 @@ fn is_infinite(cx: &LateContext<'_>, expr: &Expr<'_>) -> Finiteness {
         },
         ExprKind::Block(block, _) => block.expr.as_ref().map_or(Finite, |e| is_infinite(cx, e)),
         ExprKind::Box(e) | ExprKind::AddrOf(BorrowKind::Ref, _, e) => is_infinite(cx, e),
-        ExprKind::Call(path, _) => path_def_id(cx, path)
-            .map_or(false, |id| match_def_path(cx, id, &paths::ITER_REPEAT))
-            .into(),
+        ExprKind::Call(path, _) => {
+            if let ExprKind::Path(ref qpath) = path.kind {
+                cx.qpath_res(qpath, path.hir_id)
+                    .opt_def_id()
+                    .map_or(false, |id| cx.tcx.is_diagnostic_item(sym::iter_repeat, id))
+                    .into()
+            } else {
+                Finite
+            }
+        },
         ExprKind::Struct(..) => higher::Range::hir(expr).map_or(false, |r| r.end.is_none()).into(),
         _ => Finite,
     }
diff --git a/clippy_lints/src/inherent_to_string.rs b/clippy_lints/src/inherent_to_string.rs
index d0e603dcf4e..676136df572 100644
--- a/clippy_lints/src/inherent_to_string.rs
+++ b/clippy_lints/src/inherent_to_string.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::ty::{implements_trait, is_type_diagnostic_item};
-use clippy_utils::{get_trait_def_id, paths, return_ty, trait_ref_of_method};
+use clippy_utils::{return_ty, trait_ref_of_method};
 use if_chain::if_chain;
 use rustc_hir::{GenericParamKind, ImplItem, ImplItemKind};
 use rustc_lint::{LateContext, LateLintPass};
@@ -118,7 +118,10 @@ impl<'tcx> LateLintPass<'tcx> for InherentToString {
 }
 
 fn show_lint(cx: &LateContext<'_>, item: &ImplItem<'_>) {
-    let display_trait_id = get_trait_def_id(cx, &paths::DISPLAY_TRAIT).expect("Failed to get trait ID of `Display`!");
+    let display_trait_id = cx
+        .tcx
+        .get_diagnostic_item(sym::Display)
+        .expect("Failed to get trait ID of `Display`!");
 
     // Get the real type of 'self'
     let self_type = cx.tcx.fn_sig(item.def_id).input(0);
diff --git a/clippy_lints/src/lib.register_internal.rs b/clippy_lints/src/lib.register_internal.rs
index be63646a12f..71dfdab369b 100644
--- a/clippy_lints/src/lib.register_internal.rs
+++ b/clippy_lints/src/lib.register_internal.rs
@@ -13,10 +13,10 @@ store.register_group(true, "clippy::internal", Some("clippy_internal"), vec![
     LintId::of(utils::internal_lints::INVALID_CLIPPY_VERSION_ATTRIBUTE),
     LintId::of(utils::internal_lints::INVALID_PATHS),
     LintId::of(utils::internal_lints::LINT_WITHOUT_LINT_PASS),
-    LintId::of(utils::internal_lints::MATCH_TYPE_ON_DIAGNOSTIC_ITEM),
     LintId::of(utils::internal_lints::MISSING_CLIPPY_VERSION_ATTRIBUTE),
     LintId::of(utils::internal_lints::MISSING_MSRV_ATTR_IMPL),
     LintId::of(utils::internal_lints::OUTER_EXPN_EXPN_DATA),
     LintId::of(utils::internal_lints::PRODUCE_ICE),
+    LintId::of(utils::internal_lints::UNNECESSARY_DEF_PATH),
     LintId::of(utils::internal_lints::UNNECESSARY_SYMBOL_STR),
 ])
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index b8a20de9768..307ec40f40b 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -24,8 +24,6 @@ store.register_lints(&[
     #[cfg(feature = "internal")]
     utils::internal_lints::LINT_WITHOUT_LINT_PASS,
     #[cfg(feature = "internal")]
-    utils::internal_lints::MATCH_TYPE_ON_DIAGNOSTIC_ITEM,
-    #[cfg(feature = "internal")]
     utils::internal_lints::MISSING_CLIPPY_VERSION_ATTRIBUTE,
     #[cfg(feature = "internal")]
     utils::internal_lints::MISSING_MSRV_ATTR_IMPL,
@@ -34,6 +32,8 @@ store.register_lints(&[
     #[cfg(feature = "internal")]
     utils::internal_lints::PRODUCE_ICE,
     #[cfg(feature = "internal")]
+    utils::internal_lints::UNNECESSARY_DEF_PATH,
+    #[cfg(feature = "internal")]
     utils::internal_lints::UNNECESSARY_SYMBOL_STR,
     almost_complete_letter_range::ALMOST_COMPLETE_LETTER_RANGE,
     approx_const::APPROX_CONSTANT,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 05a9e13c9fb..3b78e492baa 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -535,7 +535,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         store.register_late_pass(|_| Box::new(utils::internal_lints::InvalidPaths));
         store.register_late_pass(|_| Box::<utils::internal_lints::InterningDefinedSymbol>::default());
         store.register_late_pass(|_| Box::<utils::internal_lints::LintWithoutLintPass>::default());
-        store.register_late_pass(|_| Box::new(utils::internal_lints::MatchTypeOnDiagItem));
+        store.register_late_pass(|_| Box::new(utils::internal_lints::UnnecessaryDefPath));
         store.register_late_pass(|_| Box::new(utils::internal_lints::OuterExpnDataPass));
         store.register_late_pass(|_| Box::new(utils::internal_lints::MsrvAttrImpl));
     }
diff --git a/clippy_lints/src/manual_retain.rs b/clippy_lints/src/manual_retain.rs
index 570fe736818..3181bc86d17 100644
--- a/clippy_lints/src/manual_retain.rs
+++ b/clippy_lints/src/manual_retain.rs
@@ -92,7 +92,7 @@ fn check_into_iter(
         && match_def_path(cx, filter_def_id, &paths::CORE_ITER_FILTER)
         && let hir::ExprKind::MethodCall(_, struct_expr, [], _) = &into_iter_expr.kind
         && let Some(into_iter_def_id) = cx.typeck_results().type_dependent_def_id(into_iter_expr.hir_id)
-        && match_def_path(cx, into_iter_def_id, &paths::CORE_ITER_INTO_ITER)
+        && cx.tcx.lang_items().require(hir::LangItem::IntoIterIntoIter).ok() == Some(into_iter_def_id)
         && match_acceptable_type(cx, left_expr, msrv)
         && SpanlessEq::new(cx).eq_expr(left_expr, struct_expr) {
         suggest(cx, parent_expr, left_expr, target_expr);
diff --git a/clippy_lints/src/methods/filetype_is_file.rs b/clippy_lints/src/methods/filetype_is_file.rs
index 60f8283c3e0..3fef53739fb 100644
--- a/clippy_lints/src/methods/filetype_is_file.rs
+++ b/clippy_lints/src/methods/filetype_is_file.rs
@@ -1,17 +1,18 @@
 use clippy_utils::diagnostics::span_lint_and_help;
-use clippy_utils::ty::match_type;
-use clippy_utils::{get_parent_expr, paths};
+use clippy_utils::get_parent_expr;
+use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
 use rustc_span::source_map::Span;
+use rustc_span::sym;
 
 use super::FILETYPE_IS_FILE;
 
 pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr<'_>) {
     let ty = cx.typeck_results().expr_ty(recv);
 
-    if !match_type(cx, ty, &paths::FILE_TYPE) {
+    if !is_type_diagnostic_item(cx, ty, sym::FileType) {
         return;
     }
 
diff --git a/clippy_lints/src/methods/inefficient_to_string.rs b/clippy_lints/src/methods/inefficient_to_string.rs
index e5dc3711b0b..ede3b8bb74e 100644
--- a/clippy_lints/src/methods/inefficient_to_string.rs
+++ b/clippy_lints/src/methods/inefficient_to_string.rs
@@ -65,7 +65,7 @@ fn specializes_tostring(cx: &LateContext<'_>, ty: Ty<'_>) -> bool {
     }
 
     if let ty::Adt(adt, substs) = ty.kind() {
-        match_def_path(cx, adt.did(), &paths::COW) && substs.type_at(1).is_str()
+        cx.tcx.is_diagnostic_item(sym::Cow, adt.did()) && substs.type_at(1).is_str()
     } else {
         false
     }
diff --git a/clippy_lints/src/methods/manual_str_repeat.rs b/clippy_lints/src/methods/manual_str_repeat.rs
index 67e504af161..8b6b8f1bf16 100644
--- a/clippy_lints/src/methods/manual_str_repeat.rs
+++ b/clippy_lints/src/methods/manual_str_repeat.rs
@@ -1,8 +1,8 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::is_path_diagnostic_item;
 use clippy_utils::source::{snippet_with_applicability, snippet_with_context};
 use clippy_utils::sugg::Sugg;
-use clippy_utils::ty::{is_type_diagnostic_item, is_type_lang_item, match_type};
-use clippy_utils::{is_expr_path_def_path, paths};
+use clippy_utils::ty::{is_type_diagnostic_item, is_type_lang_item};
 use if_chain::if_chain;
 use rustc_ast::LitKind;
 use rustc_errors::Applicability;
@@ -38,7 +38,7 @@ fn parse_repeat_arg(cx: &LateContext<'_>, e: &Expr<'_>) -> Option<RepeatKind> {
         let ty = cx.typeck_results().expr_ty(e);
         if is_type_diagnostic_item(cx, ty, sym::String)
             || (is_type_lang_item(cx, ty, LangItem::OwnedBox) && get_ty_param(ty).map_or(false, Ty::is_str))
-            || (match_type(cx, ty, &paths::COW) && get_ty_param(ty).map_or(false, Ty::is_str))
+            || (is_type_diagnostic_item(cx, ty, sym::Cow) && get_ty_param(ty).map_or(false, Ty::is_str))
         {
             Some(RepeatKind::String)
         } else {
@@ -57,7 +57,7 @@ pub(super) fn check(
 ) {
     if_chain! {
         if let ExprKind::Call(repeat_fn, [repeat_arg]) = take_self_arg.kind;
-        if is_expr_path_def_path(cx, repeat_fn, &paths::ITER_REPEAT);
+        if is_path_diagnostic_item(cx, repeat_fn, sym::iter_repeat);
         if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(collect_expr), sym::String);
         if let Some(collect_id) = cx.typeck_results().type_dependent_def_id(collect_expr.hir_id);
         if let Some(take_id) = cx.typeck_results().type_dependent_def_id(take_expr.hir_id);
diff --git a/clippy_lints/src/methods/useless_asref.rs b/clippy_lints/src/methods/useless_asref.rs
index 0380a82411a..c1139d84e2f 100644
--- a/clippy_lints/src/methods/useless_asref.rs
+++ b/clippy_lints/src/methods/useless_asref.rs
@@ -1,11 +1,12 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::walk_ptrs_ty_depth;
-use clippy_utils::{get_parent_expr, match_trait_method, paths};
+use clippy_utils::{get_parent_expr, is_trait_method};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
+use rustc_span::sym;
 
 use super::USELESS_ASREF;
 
@@ -13,7 +14,7 @@ use super::USELESS_ASREF;
 pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, call_name: &str, recvr: &hir::Expr<'_>) {
     // when we get here, we've already checked that the call name is "as_ref" or "as_mut"
     // check if the call is to the actual `AsRef` or `AsMut` trait
-    if match_trait_method(cx, expr, &paths::ASREF_TRAIT) || match_trait_method(cx, expr, &paths::ASMUT_TRAIT) {
+    if is_trait_method(cx, expr, sym::AsRef) || is_trait_method(cx, expr, sym::AsMut) {
         // check if the type after `as_ref` or `as_mut` is the same as before
         let rcv_ty = cx.typeck_results().expr_ty(recvr);
         let res_ty = cx.typeck_results().expr_ty(expr);
diff --git a/clippy_lints/src/minmax.rs b/clippy_lints/src/minmax.rs
index 4d8579135fc..4f967755bfa 100644
--- a/clippy_lints/src/minmax.rs
+++ b/clippy_lints/src/minmax.rs
@@ -1,6 +1,6 @@
 use clippy_utils::consts::{constant_simple, Constant};
 use clippy_utils::diagnostics::span_lint;
-use clippy_utils::{match_trait_method, paths};
+use clippy_utils::is_trait_method;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -83,7 +83,7 @@ fn min_max<'a>(cx: &LateContext<'_>, expr: &'a Expr<'a>) -> Option<(MinMax, Cons
             }
         },
         ExprKind::MethodCall(path, receiver, args @ [_], _) => {
-            if cx.typeck_results().expr_ty(receiver).is_floating_point() || match_trait_method(cx, expr, &paths::ORD) {
+            if cx.typeck_results().expr_ty(receiver).is_floating_point() || is_trait_method(cx, expr, sym::Ord) {
                 if path.ident.name == sym!(max) {
                     fetch_const(cx, Some(receiver), args, MinMax::Max)
                 } else if path.ident.name == sym!(min) {
diff --git a/clippy_lints/src/non_octal_unix_permissions.rs b/clippy_lints/src/non_octal_unix_permissions.rs
index 25fb4f0f4cf..1a765b14892 100644
--- a/clippy_lints/src/non_octal_unix_permissions.rs
+++ b/clippy_lints/src/non_octal_unix_permissions.rs
@@ -1,12 +1,13 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::{snippet_opt, snippet_with_applicability};
-use clippy_utils::ty::match_type;
+use clippy_utils::ty::{is_type_diagnostic_item, match_type};
 use clippy_utils::{match_def_path, paths};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::sym;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -49,7 +50,7 @@ impl<'tcx> LateLintPass<'tcx> for NonOctalUnixPermissions {
                 if_chain! {
                     if (path.ident.name == sym!(mode)
                         && (match_type(cx, obj_ty, &paths::OPEN_OPTIONS)
-                            || match_type(cx, obj_ty, &paths::DIR_BUILDER)))
+                            || is_type_diagnostic_item(cx, obj_ty, sym::DirBuilder)))
                         || (path.ident.name == sym!(set_mode) && match_type(cx, obj_ty, &paths::PERMISSIONS));
                     if let ExprKind::Lit(_) = param.kind;
 
diff --git a/clippy_lints/src/slow_vector_initialization.rs b/clippy_lints/src/slow_vector_initialization.rs
index 6e5d88e1b59..76039923151 100644
--- a/clippy_lints/src/slow_vector_initialization.rs
+++ b/clippy_lints/src/slow_vector_initialization.rs
@@ -2,7 +2,7 @@ use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::{
-    get_enclosing_block, is_expr_path_def_path, is_integer_literal, path_to_local, path_to_local_id, paths, SpanlessEq,
+    get_enclosing_block, is_integer_literal, is_path_diagnostic_item, path_to_local, path_to_local_id, SpanlessEq,
 };
 use if_chain::if_chain;
 use rustc_errors::Applicability;
@@ -254,7 +254,7 @@ impl<'a, 'tcx> VectorInitializationVisitor<'a, 'tcx> {
     fn is_repeat_zero(&self, expr: &Expr<'_>) -> bool {
         if_chain! {
             if let ExprKind::Call(fn_expr, [repeat_arg]) = expr.kind;
-            if is_expr_path_def_path(self.cx, fn_expr, &paths::ITER_REPEAT);
+            if is_path_diagnostic_item(self.cx, fn_expr, sym::iter_repeat);
             if is_integer_literal(repeat_arg, 0);
             then {
                 true
diff --git a/clippy_lints/src/unnecessary_owned_empty_strings.rs b/clippy_lints/src/unnecessary_owned_empty_strings.rs
index 8a4f4c0ad97..016aacbf9da 100644
--- a/clippy_lints/src/unnecessary_owned_empty_strings.rs
+++ b/clippy_lints/src/unnecessary_owned_empty_strings.rs
@@ -3,7 +3,7 @@ use clippy_utils::{match_def_path, paths};
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
-use rustc_hir::{BorrowKind, Expr, ExprKind, Mutability};
+use rustc_hir::{BorrowKind, Expr, ExprKind, LangItem, Mutability};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -55,7 +55,7 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryOwnedEmptyStrings {
                         );
                 } else {
                     if_chain! {
-                        if match_def_path(cx, fun_def_id, &paths::FROM_FROM);
+                        if cx.tcx.lang_items().require(LangItem::FromFrom).ok() == Some(fun_def_id);
                         if let [.., last_arg] = args;
                         if let ExprKind::Lit(spanned) = &last_arg.kind;
                         if let LitKind::Str(symbol, _) = spanned.node;
diff --git a/clippy_lints/src/unused_io_amount.rs b/clippy_lints/src/unused_io_amount.rs
index b38d71784fc..8bcdff66331 100644
--- a/clippy_lints/src/unused_io_amount.rs
+++ b/clippy_lints/src/unused_io_amount.rs
@@ -1,8 +1,9 @@
 use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
-use clippy_utils::{is_try, match_trait_method, paths};
+use clippy_utils::{is_trait_method, is_try, match_trait_method, paths};
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::sym;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -116,13 +117,13 @@ fn check_method_call(cx: &LateContext<'_>, call: &hir::Expr<'_>, expr: &hir::Exp
             match_trait_method(cx, call, &paths::FUTURES_IO_ASYNCREADEXT)
                 || match_trait_method(cx, call, &paths::TOKIO_IO_ASYNCREADEXT)
         } else {
-            match_trait_method(cx, call, &paths::IO_READ)
+            is_trait_method(cx, call, sym::IoRead)
         };
         let write_trait = if is_await {
             match_trait_method(cx, call, &paths::FUTURES_IO_ASYNCWRITEEXT)
                 || match_trait_method(cx, call, &paths::TOKIO_IO_ASYNCWRITEEXT)
         } else {
-            match_trait_method(cx, call, &paths::IO_WRITE)
+            is_trait_method(cx, call, sym::IoWrite)
         };
 
         match (read_trait, write_trait, symbol, is_await) {
diff --git a/clippy_lints/src/useless_conversion.rs b/clippy_lints/src/useless_conversion.rs
index 50c5a832430..a82643a59f9 100644
--- a/clippy_lints/src/useless_conversion.rs
+++ b/clippy_lints/src/useless_conversion.rs
@@ -5,7 +5,7 @@ use clippy_utils::ty::{is_type_diagnostic_item, same_type_and_consts};
 use clippy_utils::{get_parent_expr, is_trait_method, match_def_path, paths};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
-use rustc_hir::{Expr, ExprKind, HirId, MatchSource};
+use rustc_hir::{Expr, ExprKind, HirId, LangItem, MatchSource};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
@@ -154,7 +154,7 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
                         }
 
                         if_chain! {
-                            if match_def_path(cx, def_id, &paths::FROM_FROM);
+                            if cx.tcx.lang_items().require(LangItem::FromFrom).ok() == Some(def_id);
                             if same_type_and_consts(a, b);
 
                             then {
diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs
index bc3f920a087..6309a04c73d 100644
--- a/clippy_lints/src/utils/internal_lints.rs
+++ b/clippy_lints/src/utils/internal_lints.rs
@@ -2,11 +2,11 @@ use crate::utils::internal_lints::metadata_collector::is_deprecated_lint;
 use clippy_utils::consts::{constant_simple, Constant};
 use clippy_utils::diagnostics::{span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::macros::root_macro_call_first_node;
-use clippy_utils::source::snippet;
+use clippy_utils::source::{snippet, snippet_with_applicability};
 use clippy_utils::ty::match_type;
 use clippy_utils::{
-    def_path_res, higher, is_else_clause, is_expn_of, is_expr_path_def_path, is_lint_allowed, match_def_path,
-    method_calls, paths, peel_blocks_with_stmt, SpanlessEq,
+    def_path_res, higher, is_else_clause, is_expn_of, is_expr_path_def_path, is_lint_allowed, match_any_def_paths,
+    match_def_path, method_calls, paths, peel_blocks_with_stmt, peel_hir_expr_refs, SpanlessEq,
 };
 use if_chain::if_chain;
 use rustc_ast as ast;
@@ -20,21 +20,24 @@ use rustc_hir::def_id::DefId;
 use rustc_hir::hir_id::CRATE_HIR_ID;
 use rustc_hir::intravisit::Visitor;
 use rustc_hir::{
-    BinOpKind, Block, Closure, Expr, ExprKind, HirId, Item, Local, MutTy, Mutability, Node, Path, Stmt, StmtKind, Ty,
+    BinOpKind, Block, Closure, Expr, ExprKind, HirId, Item, Local, MutTy, Mutability, Node, Path, Stmt, StmtKind,
     TyKind, UnOp,
 };
 use rustc_hir_analysis::hir_ty_to_ty;
 use rustc_lint::{EarlyContext, EarlyLintPass, LateContext, LateLintPass, LintContext};
 use rustc_middle::hir::nested_filter;
-use rustc_middle::mir::interpret::ConstValue;
-use rustc_middle::ty::{self, fast_reject::SimplifiedTypeGen, subst::GenericArgKind, FloatTy};
+use rustc_middle::mir::interpret::{Allocation, ConstValue, GlobalAlloc};
+use rustc_middle::ty::{
+    self, fast_reject::SimplifiedTypeGen, subst::GenericArgKind, AssocKind, DefIdTree, FloatTy, Ty,
+};
 use rustc_semver::RustcVersion;
 use rustc_session::{declare_lint_pass, declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::Spanned;
-use rustc_span::symbol::Symbol;
+use rustc_span::symbol::{Ident, Symbol};
 use rustc_span::{sym, BytePos, Span};
 
 use std::borrow::{Borrow, Cow};
+use std::str;
 
 #[cfg(feature = "internal")]
 pub mod metadata_collector;
@@ -226,11 +229,11 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for calls to `utils::match_type()` on a type diagnostic item
-    /// and suggests to use `utils::is_type_diagnostic_item()` instead.
+    /// Checks for usages of def paths when a diagnostic item or a `LangItem` could be used.
     ///
     /// ### Why is this bad?
-    /// `utils::is_type_diagnostic_item()` does not require hardcoded paths.
+    /// The path for an item is subject to change and is less efficient to look up than a
+    /// diagnostic item or a `LangItem`.
     ///
     /// ### Example
     /// ```rust,ignore
@@ -241,9 +244,9 @@ declare_clippy_lint! {
     /// ```rust,ignore
     /// utils::is_type_diagnostic_item(cx, ty, sym::Vec)
     /// ```
-    pub MATCH_TYPE_ON_DIAGNOSTIC_ITEM,
+    pub UNNECESSARY_DEF_PATH,
     internal,
-    "using `utils::match_type()` instead of `utils::is_type_diagnostic_item()`"
+    "using a def path when a diagnostic item or a `LangItem` is available"
 }
 
 declare_clippy_lint! {
@@ -537,7 +540,7 @@ impl<'tcx> LateLintPass<'tcx> for LintWithoutLintPass {
     }
 }
 
-fn is_lint_ref_type<'tcx>(cx: &LateContext<'tcx>, ty: &Ty<'_>) -> bool {
+fn is_lint_ref_type<'tcx>(cx: &LateContext<'tcx>, ty: &hir::Ty<'_>) -> bool {
     if let TyKind::Rptr(
         _,
         MutTy {
@@ -888,89 +891,225 @@ fn suggest_note(
     );
 }
 
-declare_lint_pass!(MatchTypeOnDiagItem => [MATCH_TYPE_ON_DIAGNOSTIC_ITEM]);
+declare_lint_pass!(UnnecessaryDefPath => [UNNECESSARY_DEF_PATH]);
 
-impl<'tcx> LateLintPass<'tcx> for MatchTypeOnDiagItem {
+#[allow(clippy::too_many_lines)]
+impl<'tcx> LateLintPass<'tcx> for UnnecessaryDefPath {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
-        if is_lint_allowed(cx, MATCH_TYPE_ON_DIAGNOSTIC_ITEM, expr.hir_id) {
+        enum Item {
+            LangItem(Symbol),
+            DiagnosticItem(Symbol),
+        }
+        static PATHS: &[&[&str]] = &[
+            &["clippy_utils", "match_def_path"],
+            &["clippy_utils", "match_trait_method"],
+            &["clippy_utils", "ty", "match_type"],
+            &["clippy_utils", "is_expr_path_def_path"],
+        ];
+
+        if is_lint_allowed(cx, UNNECESSARY_DEF_PATH, expr.hir_id) {
             return;
         }
 
         if_chain! {
-            // Check if this is a call to utils::match_type()
-            if let ExprKind::Call(fn_path, [context, ty, ty_path]) = expr.kind;
-            if is_expr_path_def_path(cx, fn_path, &["clippy_utils", "ty", "match_type"]);
+            if let ExprKind::Call(func, [cx_arg, def_arg, args@..]) = expr.kind;
+            if let ExprKind::Path(path) = &func.kind;
+            if let Some(id) = cx.qpath_res(path, func.hir_id).opt_def_id();
+            if let Some(which_path) = match_any_def_paths(cx, id, PATHS);
+            let item_arg = if which_path == 4 { &args[1] } else { &args[0] };
             // Extract the path to the matched type
-            if let Some(segments) = path_to_matched_type(cx, ty_path);
-            let segments: Vec<&str> = segments.iter().map(Symbol::as_str).collect();
-            if let Some(ty_did) = def_path_res(cx, &segments[..]).opt_def_id();
-            // Check if the matched type is a diagnostic item
-            if let Some(item_name) = cx.tcx.get_diagnostic_name(ty_did);
+            if let Some(segments) = path_to_matched_type(cx, item_arg);
+            let segments: Vec<&str> = segments.iter().map(|sym| &**sym).collect();
+            if let Some(def_id) = def_path_res(cx, &segments[..]).opt_def_id();
             then {
-                // TODO: check paths constants from external crates.
-                let cx_snippet = snippet(cx, context.span, "_");
-                let ty_snippet = snippet(cx, ty.span, "_");
+                // def_path_res will match field names before anything else, but for this we want to match
+                // inherent functions first.
+                let def_id = if cx.tcx.def_kind(def_id) == DefKind::Field {
+                    let method_name = *segments.last().unwrap();
+                    cx.tcx.def_key(def_id).parent
+                        .and_then(|parent_idx|
+                            cx.tcx.inherent_impls(DefId { index: parent_idx, krate: def_id.krate }).iter()
+                                .find_map(|impl_id| cx.tcx.associated_items(*impl_id)
+                                    .find_by_name_and_kind(
+                                        cx.tcx,
+                                        Ident::from_str(method_name),
+                                        AssocKind::Fn,
+                                        *impl_id,
+                                    )
+                                )
+                        )
+                        .map_or(def_id, |item| item.def_id)
+                } else {
+                    def_id
+                };
 
-                span_lint_and_sugg(
+                // Check if the target item is a diagnostic item or LangItem.
+                let (msg, item) = if let Some(item_name)
+                    = cx.tcx.diagnostic_items(def_id.krate).id_to_name.get(&def_id)
+                {
+                    (
+                        "use of a def path to a diagnostic item",
+                        Item::DiagnosticItem(*item_name),
+                    )
+                } else if let Some(lang_item) = cx.tcx.lang_items().items().iter().position(|id| *id == Some(def_id)) {
+                    let lang_items = def_path_res(cx, &["rustc_hir", "lang_items", "LangItem"]).def_id();
+                    let item_name = cx.tcx.adt_def(lang_items).variants().iter().nth(lang_item).unwrap().name;
+                    (
+                        "use of a def path to a `LangItem`",
+                        Item::LangItem(item_name),
+                    )
+                } else {
+                    return;
+                };
+
+                let has_ctor = match cx.tcx.def_kind(def_id) {
+                    DefKind::Struct => {
+                        let variant = cx.tcx.adt_def(def_id).non_enum_variant();
+                        variant.ctor_def_id.is_some() && variant.fields.iter().all(|f| f.vis.is_public())
+                    }
+                    DefKind::Variant => {
+                        let variant = cx.tcx.adt_def(cx.tcx.parent(def_id)).variant_with_id(def_id);
+                        variant.ctor_def_id.is_some() && variant.fields.iter().all(|f| f.vis.is_public())
+                    }
+                    _ => false,
+                };
+
+                let mut app = Applicability::MachineApplicable;
+                let cx_snip = snippet_with_applicability(cx, cx_arg.span, "..", &mut app);
+                let def_snip = snippet_with_applicability(cx, def_arg.span, "..", &mut app);
+                let (sugg, with_note) = match (which_path, item) {
+                    // match_def_path
+                    (0, Item::DiagnosticItem(item)) =>
+                        (format!("{cx_snip}.tcx.is_diagnostic_item(sym::{item}, {def_snip})"), has_ctor),
+                    (0, Item::LangItem(item)) => (
+                        format!("{cx_snip}.tcx.lang_items().require(LangItem::{item}).ok() == Some({def_snip})"),
+                        has_ctor
+                    ),
+                    // match_trait_method
+                    (1, Item::DiagnosticItem(item)) =>
+                        (format!("is_trait_method({cx_snip}, {def_snip}, sym::{item})"), false),
+                    // match_type
+                    (2, Item::DiagnosticItem(item)) =>
+                        (format!("is_type_diagnostic_item({cx_snip}, {def_snip}, sym::{item})"), false),
+                    (2, Item::LangItem(item)) =>
+                        (format!("is_type_lang_item({cx_snip}, {def_snip}, LangItem::{item})"), false),
+                    // is_expr_path_def_path
+                    (3, Item::DiagnosticItem(item)) if has_ctor => (
+                        format!(
+                            "is_res_diag_ctor({cx_snip}, path_res({cx_snip}, {def_snip}), sym::{item})",
+                        ),
+                        false,
+                    ),
+                    (3, Item::LangItem(item)) if has_ctor => (
+                        format!(
+                            "is_res_lang_ctor({cx_snip}, path_res({cx_snip}, {def_snip}), LangItem::{item})",
+                        ),
+                        false,
+                    ),
+                    (3, Item::DiagnosticItem(item)) =>
+                        (format!("is_path_diagnostic_item({cx_snip}, {def_snip}, sym::{item})"), false),
+                    (3, Item::LangItem(item)) => (
+                        format!(
+                            "path_res({cx_snip}, {def_snip}).opt_def_id()\
+                                .map_or(false, |id| {cx_snip}.tcx.lang_items().require(LangItem::{item}).ok() == Some(id))",
+                        ),
+                        false,
+                    ),
+                    _ => return,
+                };
+
+                span_lint_and_then(
                     cx,
-                    MATCH_TYPE_ON_DIAGNOSTIC_ITEM,
+                    UNNECESSARY_DEF_PATH,
                     expr.span,
-                    "usage of `clippy_utils::ty::match_type()` on a type diagnostic item",
-                    "try",
-                    format!("clippy_utils::ty::is_type_diagnostic_item({cx_snippet}, {ty_snippet}, sym::{item_name})"),
-                    Applicability::MaybeIncorrect,
+                    msg,
+                    |diag| {
+                        diag.span_suggestion(expr.span, "try", sugg, app);
+                        if with_note {
+                            diag.help(
+                                "if this `DefId` came from a constructor expression or pattern then the \
+                                    parent `DefId` should be used instead"
+                            );
+                        }
+                    },
                 );
             }
         }
     }
 }
 
-fn path_to_matched_type(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> Option<Vec<Symbol>> {
-    use rustc_hir::ItemKind;
-
-    match &expr.kind {
-        ExprKind::AddrOf(.., expr) => return path_to_matched_type(cx, expr),
-        ExprKind::Path(qpath) => match cx.qpath_res(qpath, expr.hir_id) {
+fn path_to_matched_type(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> Option<Vec<String>> {
+    match peel_hir_expr_refs(expr).0.kind {
+        ExprKind::Path(ref qpath) => match cx.qpath_res(qpath, expr.hir_id) {
             Res::Local(hir_id) => {
                 let parent_id = cx.tcx.hir().get_parent_node(hir_id);
-                if let Some(Node::Local(local)) = cx.tcx.hir().find(parent_id) {
-                    if let Some(init) = local.init {
-                        return path_to_matched_type(cx, init);
-                    }
+                if let Some(Node::Local(Local { init: Some(init), .. })) = cx.tcx.hir().find(parent_id) {
+                    path_to_matched_type(cx, init)
+                } else {
+                    None
                 }
             },
-            Res::Def(DefKind::Const | DefKind::Static(..), def_id) => {
-                if let Some(Node::Item(item)) = cx.tcx.hir().get_if_local(def_id) {
-                    if let ItemKind::Const(.., body_id) | ItemKind::Static(.., body_id) = item.kind {
-                        let body = cx.tcx.hir().body(body_id);
-                        return path_to_matched_type(cx, body.value);
-                    }
-                }
+            Res::Def(DefKind::Static(_), def_id) => read_mir_alloc_def_path(
+                cx,
+                cx.tcx.eval_static_initializer(def_id).ok()?.inner(),
+                cx.tcx.type_of(def_id),
+            ),
+            Res::Def(DefKind::Const, def_id) => match cx.tcx.const_eval_poly(def_id).ok()? {
+                ConstValue::ByRef { alloc, offset } if offset.bytes() == 0 => {
+                    read_mir_alloc_def_path(cx, alloc.inner(), cx.tcx.type_of(def_id))
+                },
+                _ => None,
             },
-            _ => {},
+            _ => None,
         },
-        ExprKind::Array(exprs) => {
-            let segments: Vec<Symbol> = exprs
-                .iter()
-                .filter_map(|expr| {
-                    if let ExprKind::Lit(lit) = &expr.kind {
-                        if let LitKind::Str(sym, _) = lit.node {
-                            return Some(sym);
-                        }
+        ExprKind::Array(exprs) => exprs
+            .iter()
+            .map(|expr| {
+                if let ExprKind::Lit(lit) = &expr.kind {
+                    if let LitKind::Str(sym, _) = lit.node {
+                        return Some((*sym.as_str()).to_owned());
                     }
+                }
 
-                    None
-                })
-                .collect();
-
-            if segments.len() == exprs.len() {
-                return Some(segments);
-            }
-        },
-        _ => {},
+                None
+            })
+            .collect(),
+        _ => None,
     }
+}
 
-    None
+fn read_mir_alloc_def_path<'tcx>(cx: &LateContext<'tcx>, alloc: &'tcx Allocation, ty: Ty<'_>) -> Option<Vec<String>> {
+    let (alloc, ty) = if let ty::Ref(_, ty, Mutability::Not) = *ty.kind() {
+        let &alloc = alloc.provenance().values().next()?;
+        if let GlobalAlloc::Memory(alloc) = cx.tcx.global_alloc(alloc) {
+            (alloc.inner(), ty)
+        } else {
+            return None;
+        }
+    } else {
+        (alloc, ty)
+    };
+
+    if let ty::Array(ty, _) | ty::Slice(ty) = *ty.kind()
+        && let ty::Ref(_, ty, Mutability::Not) = *ty.kind()
+        && ty.is_str()
+    {
+        alloc
+            .provenance()
+            .values()
+            .map(|&alloc| {
+                if let GlobalAlloc::Memory(alloc) = cx.tcx.global_alloc(alloc) {
+                    let alloc = alloc.inner();
+                    str::from_utf8(alloc.inspect_with_uninit_and_ptr_outside_interpreter(0..alloc.len()))
+                        .ok().map(ToOwned::to_owned)
+                } else {
+                    None
+                }
+            })
+            .collect()
+    } else {
+        None
+    }
 }
 
 // This is not a complete resolver for paths. It works on all the paths currently used in the paths
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index c7cc5d04c85..8f67fa109fc 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -261,6 +261,46 @@ pub fn is_res_diagnostic_ctor(cx: &LateContext<'_>, res: Res, diag_item: Symbol)
     }
 }
 
+/// Checks if a `QPath` resolves to a constructor of a diagnostic item.
+pub fn is_diagnostic_ctor(cx: &LateContext<'_>, qpath: &QPath<'_>, diagnostic_item: Symbol) -> bool {
+    if let QPath::Resolved(_, path) = qpath {
+        if let Res::Def(DefKind::Ctor(..), ctor_id) = path.res {
+            return cx.tcx.is_diagnostic_item(diagnostic_item, cx.tcx.parent(ctor_id));
+        }
+    }
+    false
+}
+
+/// Checks if the `DefId` matches the given diagnostic item or it's constructor.
+pub fn is_diagnostic_item_or_ctor(cx: &LateContext<'_>, did: DefId, item: Symbol) -> bool {
+    let did = match cx.tcx.def_kind(did) {
+        DefKind::Ctor(..) => cx.tcx.parent(did),
+        // Constructors for types in external crates seem to have `DefKind::Variant`
+        DefKind::Variant => match cx.tcx.opt_parent(did) {
+            Some(did) if matches!(cx.tcx.def_kind(did), DefKind::Variant) => did,
+            _ => did,
+        },
+        _ => did,
+    };
+
+    cx.tcx.is_diagnostic_item(item, did)
+}
+
+/// Checks if the `DefId` matches the given `LangItem` or it's constructor.
+pub fn is_lang_item_or_ctor(cx: &LateContext<'_>, did: DefId, item: LangItem) -> bool {
+    let did = match cx.tcx.def_kind(did) {
+        DefKind::Ctor(..) => cx.tcx.parent(did),
+        // Constructors for types in external crates seem to have `DefKind::Variant`
+        DefKind::Variant => match cx.tcx.opt_parent(did) {
+            Some(did) if matches!(cx.tcx.def_kind(did), DefKind::Variant) => did,
+            _ => did,
+        },
+        _ => did,
+    };
+
+    cx.tcx.lang_items().require(item).map_or(false, |id| id == did)
+}
+
 pub fn is_unit_expr(expr: &Expr<'_>) -> bool {
     matches!(
         expr.kind,
@@ -496,6 +536,13 @@ pub fn def_path_res(cx: &LateContext<'_>, path: &[&str]) -> Res {
                 .copied()
                 .find(|assoc_def_id| tcx.item_name(*assoc_def_id).as_str() == name)
                 .map(|assoc_def_id| Res::Def(tcx.def_kind(assoc_def_id), assoc_def_id)),
+            DefKind::Struct | DefKind::Union => tcx
+                .adt_def(def_id)
+                .non_enum_variant()
+                .fields
+                .iter()
+                .find(|f| f.name.as_str() == name)
+                .map(|f| Res::Def(DefKind::Field, f.did)),
             _ => None,
         }
     }
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index 07170e2df12..13938645fc3 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -34,7 +34,6 @@ pub const DEFAULT_TRAIT_METHOD: [&str; 4] = ["core", "default", "Default", "defa
 pub const DEREF_MUT_TRAIT_METHOD: [&str; 5] = ["core", "ops", "deref", "DerefMut", "deref_mut"];
 /// Preferably use the diagnostic item `sym::deref_method` where possible
 pub const DEREF_TRAIT_METHOD: [&str; 5] = ["core", "ops", "deref", "Deref", "deref"];
-pub const DIR_BUILDER: [&str; 3] = ["std", "fs", "DirBuilder"];
 pub const DISPLAY_TRAIT: [&str; 3] = ["core", "fmt", "Display"];
 #[cfg(feature = "internal")]
 pub const EARLY_CONTEXT: [&str; 2] = ["rustc_lint", "EarlyContext"];
@@ -64,8 +63,6 @@ pub const IDENT_AS_STR: [&str; 4] = ["rustc_span", "symbol", "Ident", "as_str"];
 pub const INDEX: [&str; 3] = ["core", "ops", "Index"];
 pub const INDEX_MUT: [&str; 3] = ["core", "ops", "IndexMut"];
 pub const INSERT_STR: [&str; 4] = ["alloc", "string", "String", "insert_str"];
-pub const IO_READ: [&str; 3] = ["std", "io", "Read"];
-pub const IO_WRITE: [&str; 3] = ["std", "io", "Write"];
 pub const ITER_COUNT: [&str; 6] = ["core", "iter", "traits", "iterator", "Iterator", "count"];
 pub const ITER_EMPTY: [&str; 5] = ["core", "iter", "sources", "empty", "Empty"];
 pub const ITER_REPEAT: [&str; 5] = ["core", "iter", "sources", "repeat", "repeat"];
diff --git a/tests/ui-internal/auxiliary/paths.rs b/tests/ui-internal/auxiliary/paths.rs
new file mode 100644
index 00000000000..52fcaec4df3
--- /dev/null
+++ b/tests/ui-internal/auxiliary/paths.rs
@@ -0,0 +1,2 @@
+pub static OPTION: [&str; 3] = ["core", "option", "Option"];
+pub const RESULT: &[&str] = &["core", "result", "Result"];
diff --git a/tests/ui-internal/match_type_on_diag_item.rs b/tests/ui-internal/match_type_on_diag_item.rs
deleted file mode 100644
index 4b41ff15e80..00000000000
--- a/tests/ui-internal/match_type_on_diag_item.rs
+++ /dev/null
@@ -1,39 +0,0 @@
-#![deny(clippy::internal)]
-#![allow(clippy::missing_clippy_version_attribute)]
-#![feature(rustc_private)]
-
-extern crate clippy_utils;
-extern crate rustc_hir;
-extern crate rustc_lint;
-extern crate rustc_middle;
-
-#[macro_use]
-extern crate rustc_session;
-use clippy_utils::{paths, ty::match_type};
-use rustc_hir::Expr;
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty::Ty;
-
-declare_lint! {
-    pub TEST_LINT,
-    Warn,
-    ""
-}
-
-declare_lint_pass!(Pass => [TEST_LINT]);
-
-static OPTION: [&str; 3] = ["core", "option", "Option"];
-
-impl<'tcx> LateLintPass<'tcx> for Pass {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr) {
-        let ty = cx.typeck_results().expr_ty(expr);
-
-        let _ = match_type(cx, ty, &OPTION);
-        let _ = match_type(cx, ty, &["core", "result", "Result"]);
-
-        let rc_path = &["alloc", "rc", "Rc"];
-        let _ = clippy_utils::ty::match_type(cx, ty, rc_path);
-    }
-}
-
-fn main() {}
diff --git a/tests/ui-internal/match_type_on_diag_item.stderr b/tests/ui-internal/match_type_on_diag_item.stderr
deleted file mode 100644
index e3cb6b6c22e..00000000000
--- a/tests/ui-internal/match_type_on_diag_item.stderr
+++ /dev/null
@@ -1,27 +0,0 @@
-error: usage of `clippy_utils::ty::match_type()` on a type diagnostic item
-  --> $DIR/match_type_on_diag_item.rs:31:17
-   |
-LL |         let _ = match_type(cx, ty, &OPTION);
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `clippy_utils::ty::is_type_diagnostic_item(cx, ty, sym::Option)`
-   |
-note: the lint level is defined here
-  --> $DIR/match_type_on_diag_item.rs:1:9
-   |
-LL | #![deny(clippy::internal)]
-   |         ^^^^^^^^^^^^^^^^
-   = note: `#[deny(clippy::match_type_on_diagnostic_item)]` implied by `#[deny(clippy::internal)]`
-
-error: usage of `clippy_utils::ty::match_type()` on a type diagnostic item
-  --> $DIR/match_type_on_diag_item.rs:32:17
-   |
-LL |         let _ = match_type(cx, ty, &["core", "result", "Result"]);
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `clippy_utils::ty::is_type_diagnostic_item(cx, ty, sym::Result)`
-
-error: usage of `clippy_utils::ty::match_type()` on a type diagnostic item
-  --> $DIR/match_type_on_diag_item.rs:35:17
-   |
-LL |         let _ = clippy_utils::ty::match_type(cx, ty, rc_path);
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `clippy_utils::ty::is_type_diagnostic_item(cx, ty, sym::Rc)`
-
-error: aborting due to 3 previous errors
-
diff --git a/tests/ui-internal/unnecessary_def_path.fixed b/tests/ui-internal/unnecessary_def_path.fixed
new file mode 100644
index 00000000000..4c050332f2c
--- /dev/null
+++ b/tests/ui-internal/unnecessary_def_path.fixed
@@ -0,0 +1,62 @@
+// run-rustfix
+// aux-build:paths.rs
+#![deny(clippy::internal)]
+#![feature(rustc_private)]
+
+extern crate clippy_utils;
+extern crate paths;
+extern crate rustc_hir;
+extern crate rustc_lint;
+extern crate rustc_middle;
+extern crate rustc_span;
+
+#[allow(unused)]
+use clippy_utils::ty::{is_type_diagnostic_item, is_type_lang_item, match_type};
+#[allow(unused)]
+use clippy_utils::{
+    is_expr_path_def_path, is_path_diagnostic_item, is_res_diagnostic_ctor, is_res_lang_ctor, is_trait_method,
+    match_def_path, match_trait_method, path_res,
+};
+
+#[allow(unused)]
+use rustc_hir::LangItem;
+#[allow(unused)]
+use rustc_span::sym;
+
+use rustc_hir::def_id::DefId;
+use rustc_hir::Expr;
+use rustc_lint::LateContext;
+use rustc_middle::ty::Ty;
+
+#[allow(unused)]
+static OPTION: [&str; 3] = ["core", "option", "Option"];
+#[allow(unused)]
+const RESULT: &[&str] = &["core", "result", "Result"];
+
+fn _f<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>, did: DefId, expr: &Expr<'_>) {
+    let _ = is_type_diagnostic_item(cx, ty, sym::Option);
+    let _ = is_type_diagnostic_item(cx, ty, sym::Result);
+    let _ = is_type_diagnostic_item(cx, ty, sym::Result);
+
+    #[allow(unused)]
+    let rc_path = &["alloc", "rc", "Rc"];
+    let _ = is_type_diagnostic_item(cx, ty, sym::Rc);
+
+    let _ = is_type_diagnostic_item(cx, ty, sym::Option);
+    let _ = is_type_diagnostic_item(cx, ty, sym::Result);
+
+    let _ = is_type_lang_item(cx, ty, LangItem::OwnedBox);
+    let _ = is_type_diagnostic_item(cx, ty, sym::maybe_uninit_uninit);
+
+    let _ = cx.tcx.lang_items().require(LangItem::OwnedBox).ok() == Some(did);
+    let _ = cx.tcx.is_diagnostic_item(sym::Option, did);
+    let _ = cx.tcx.lang_items().require(LangItem::OptionSome).ok() == Some(did);
+
+    let _ = is_trait_method(cx, expr, sym::AsRef);
+
+    let _ = is_path_diagnostic_item(cx, expr, sym::Option);
+    let _ = path_res(cx, expr).opt_def_id().map_or(false, |id| cx.tcx.lang_items().require(LangItem::IteratorNext).ok() == Some(id));
+    let _ = is_res_lang_ctor(cx, path_res(cx, expr), LangItem::OptionSome);
+}
+
+fn main() {}
diff --git a/tests/ui-internal/unnecessary_def_path.rs b/tests/ui-internal/unnecessary_def_path.rs
new file mode 100644
index 00000000000..6506f1f164a
--- /dev/null
+++ b/tests/ui-internal/unnecessary_def_path.rs
@@ -0,0 +1,62 @@
+// run-rustfix
+// aux-build:paths.rs
+#![deny(clippy::internal)]
+#![feature(rustc_private)]
+
+extern crate clippy_utils;
+extern crate paths;
+extern crate rustc_hir;
+extern crate rustc_lint;
+extern crate rustc_middle;
+extern crate rustc_span;
+
+#[allow(unused)]
+use clippy_utils::ty::{is_type_diagnostic_item, is_type_lang_item, match_type};
+#[allow(unused)]
+use clippy_utils::{
+    is_expr_path_def_path, is_path_diagnostic_item, is_res_diagnostic_ctor, is_res_lang_ctor, is_trait_method,
+    match_def_path, match_trait_method, path_res,
+};
+
+#[allow(unused)]
+use rustc_hir::LangItem;
+#[allow(unused)]
+use rustc_span::sym;
+
+use rustc_hir::def_id::DefId;
+use rustc_hir::Expr;
+use rustc_lint::LateContext;
+use rustc_middle::ty::Ty;
+
+#[allow(unused)]
+static OPTION: [&str; 3] = ["core", "option", "Option"];
+#[allow(unused)]
+const RESULT: &[&str] = &["core", "result", "Result"];
+
+fn _f<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>, did: DefId, expr: &Expr<'_>) {
+    let _ = match_type(cx, ty, &OPTION);
+    let _ = match_type(cx, ty, RESULT);
+    let _ = match_type(cx, ty, &["core", "result", "Result"]);
+
+    #[allow(unused)]
+    let rc_path = &["alloc", "rc", "Rc"];
+    let _ = clippy_utils::ty::match_type(cx, ty, rc_path);
+
+    let _ = match_type(cx, ty, &paths::OPTION);
+    let _ = match_type(cx, ty, paths::RESULT);
+
+    let _ = match_type(cx, ty, &["alloc", "boxed", "Box"]);
+    let _ = match_type(cx, ty, &["core", "mem", "maybe_uninit", "MaybeUninit", "uninit"]);
+
+    let _ = match_def_path(cx, did, &["alloc", "boxed", "Box"]);
+    let _ = match_def_path(cx, did, &["core", "option", "Option"]);
+    let _ = match_def_path(cx, did, &["core", "option", "Option", "Some"]);
+
+    let _ = match_trait_method(cx, expr, &["core", "convert", "AsRef"]);
+
+    let _ = is_expr_path_def_path(cx, expr, &["core", "option", "Option"]);
+    let _ = is_expr_path_def_path(cx, expr, &["core", "iter", "traits", "Iterator", "next"]);
+    let _ = is_expr_path_def_path(cx, expr, &["core", "option", "Option", "Some"]);
+}
+
+fn main() {}
diff --git a/tests/ui-internal/unnecessary_def_path.stderr b/tests/ui-internal/unnecessary_def_path.stderr
new file mode 100644
index 00000000000..a99a8f71fa6
--- /dev/null
+++ b/tests/ui-internal/unnecessary_def_path.stderr
@@ -0,0 +1,101 @@
+error: use of a def path to a diagnostic item
+  --> $DIR/unnecessary_def_path.rs:37:13
+   |
+LL |     let _ = match_type(cx, ty, &OPTION);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `is_type_diagnostic_item(cx, ty, sym::Option)`
+   |
+note: the lint level is defined here
+  --> $DIR/unnecessary_def_path.rs:3:9
+   |
+LL | #![deny(clippy::internal)]
+   |         ^^^^^^^^^^^^^^^^
+   = note: `#[deny(clippy::unnecessary_def_path)]` implied by `#[deny(clippy::internal)]`
+
+error: use of a def path to a diagnostic item
+  --> $DIR/unnecessary_def_path.rs:38:13
+   |
+LL |     let _ = match_type(cx, ty, RESULT);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `is_type_diagnostic_item(cx, ty, sym::Result)`
+
+error: use of a def path to a diagnostic item
+  --> $DIR/unnecessary_def_path.rs:39:13
+   |
+LL |     let _ = match_type(cx, ty, &["core", "result", "Result"]);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `is_type_diagnostic_item(cx, ty, sym::Result)`
+
+error: use of a def path to a diagnostic item
+  --> $DIR/unnecessary_def_path.rs:43:13
+   |
+LL |     let _ = clippy_utils::ty::match_type(cx, ty, rc_path);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `is_type_diagnostic_item(cx, ty, sym::Rc)`
+
+error: use of a def path to a diagnostic item
+  --> $DIR/unnecessary_def_path.rs:45:13
+   |
+LL |     let _ = match_type(cx, ty, &paths::OPTION);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `is_type_diagnostic_item(cx, ty, sym::Option)`
+
+error: use of a def path to a diagnostic item
+  --> $DIR/unnecessary_def_path.rs:46:13
+   |
+LL |     let _ = match_type(cx, ty, paths::RESULT);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `is_type_diagnostic_item(cx, ty, sym::Result)`
+
+error: use of a def path to a `LangItem`
+  --> $DIR/unnecessary_def_path.rs:48:13
+   |
+LL |     let _ = match_type(cx, ty, &["alloc", "boxed", "Box"]);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `is_type_lang_item(cx, ty, LangItem::OwnedBox)`
+
+error: use of a def path to a diagnostic item
+  --> $DIR/unnecessary_def_path.rs:49:13
+   |
+LL |     let _ = match_type(cx, ty, &["core", "mem", "maybe_uninit", "MaybeUninit", "uninit"]);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `is_type_diagnostic_item(cx, ty, sym::maybe_uninit_uninit)`
+
+error: use of a def path to a `LangItem`
+  --> $DIR/unnecessary_def_path.rs:51:13
+   |
+LL |     let _ = match_def_path(cx, did, &["alloc", "boxed", "Box"]);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `cx.tcx.lang_items().require(LangItem::OwnedBox).ok() == Some(did)`
+
+error: use of a def path to a diagnostic item
+  --> $DIR/unnecessary_def_path.rs:52:13
+   |
+LL |     let _ = match_def_path(cx, did, &["core", "option", "Option"]);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `cx.tcx.is_diagnostic_item(sym::Option, did)`
+
+error: use of a def path to a `LangItem`
+  --> $DIR/unnecessary_def_path.rs:53:13
+   |
+LL |     let _ = match_def_path(cx, did, &["core", "option", "Option", "Some"]);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `cx.tcx.lang_items().require(LangItem::OptionSome).ok() == Some(did)`
+   |
+   = help: if this `DefId` came from a constructor expression or pattern then the parent `DefId` should be used instead
+
+error: use of a def path to a diagnostic item
+  --> $DIR/unnecessary_def_path.rs:55:13
+   |
+LL |     let _ = match_trait_method(cx, expr, &["core", "convert", "AsRef"]);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `is_trait_method(cx, expr, sym::AsRef)`
+
+error: use of a def path to a diagnostic item
+  --> $DIR/unnecessary_def_path.rs:57:13
+   |
+LL |     let _ = is_expr_path_def_path(cx, expr, &["core", "option", "Option"]);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `is_path_diagnostic_item(cx, expr, sym::Option)`
+
+error: use of a def path to a `LangItem`
+  --> $DIR/unnecessary_def_path.rs:58:13
+   |
+LL |     let _ = is_expr_path_def_path(cx, expr, &["core", "iter", "traits", "Iterator", "next"]);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `path_res(cx, expr).opt_def_id().map_or(false, |id| cx.tcx.lang_items().require(LangItem::IteratorNext).ok() == Some(id))`
+
+error: use of a def path to a `LangItem`
+  --> $DIR/unnecessary_def_path.rs:59:13
+   |
+LL |     let _ = is_expr_path_def_path(cx, expr, &["core", "option", "Option", "Some"]);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `is_res_lang_ctor(cx, path_res(cx, expr), LangItem::OptionSome)`
+
+error: aborting due to 15 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 649d443646e8ca6efad73643dcc11b488ae60a79 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Thu, 28 Apr 2022 13:29:44 -0400
Subject: Replace `expr_visitor` with `for_each_expr`

---
 clippy_lints/src/implicit_return.rs    |  12 +--
 clippy_lints/src/methods/str_splitn.rs |  20 ++--
 clippy_lints/src/needless_late_init.rs |  34 +++----
 clippy_lints/src/panic_in_result_fn.rs |  19 ++--
 clippy_lints/src/read_zero_byte_vec.rs |  40 ++++----
 clippy_utils/src/lib.rs                |  19 ++--
 clippy_utils/src/macros.rs             |  79 +++++++---------
 clippy_utils/src/ptr.rs                |  37 ++++----
 clippy_utils/src/usage.rs              |  49 ++++------
 clippy_utils/src/visitors.rs           | 164 +++++++++++++++------------------
 10 files changed, 206 insertions(+), 267 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/implicit_return.rs b/clippy_lints/src/implicit_return.rs
index cfc988da233..946d04eff6f 100644
--- a/clippy_lints/src/implicit_return.rs
+++ b/clippy_lints/src/implicit_return.rs
@@ -2,10 +2,11 @@ use clippy_utils::{
     diagnostics::span_lint_hir_and_then,
     get_async_fn_body, is_async_fn,
     source::{snippet_with_applicability, snippet_with_context, walk_span_to_context},
-    visitors::expr_visitor_no_bodies,
+    visitors::for_each_expr,
 };
+use core::ops::ControlFlow;
 use rustc_errors::Applicability;
-use rustc_hir::intravisit::{FnKind, Visitor};
+use rustc_hir::intravisit::FnKind;
 use rustc_hir::{Block, Body, Expr, ExprKind, FnDecl, FnRetTy, HirId};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
@@ -152,7 +153,7 @@ fn lint_implicit_returns(
 
         ExprKind::Loop(block, ..) => {
             let mut add_return = false;
-            expr_visitor_no_bodies(|e| {
+            let _: Option<!> = for_each_expr(block, |e| {
                 if let ExprKind::Break(dest, sub_expr) = e.kind {
                     if dest.target_id.ok() == Some(expr.hir_id) {
                         if call_site_span.is_none() && e.span.ctxt() == ctxt {
@@ -167,9 +168,8 @@ fn lint_implicit_returns(
                         }
                     }
                 }
-                true
-            })
-            .visit_block(block);
+                ControlFlow::Continue(())
+            });
             if add_return {
                 #[expect(clippy::option_if_let_else)]
                 if let Some(span) = call_site_span {
diff --git a/clippy_lints/src/methods/str_splitn.rs b/clippy_lints/src/methods/str_splitn.rs
index 9ca4d65550d..ae3594bd36c 100644
--- a/clippy_lints/src/methods/str_splitn.rs
+++ b/clippy_lints/src/methods/str_splitn.rs
@@ -2,11 +2,11 @@ use clippy_utils::consts::{constant, Constant};
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::snippet_with_context;
 use clippy_utils::usage::local_used_after_expr;
-use clippy_utils::visitors::expr_visitor;
+use clippy_utils::visitors::{for_each_expr_with_closures, Descend};
 use clippy_utils::{is_diag_item_method, match_def_path, meets_msrv, msrvs, path_to_local_id, paths};
+use core::ops::ControlFlow;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
-use rustc_hir::intravisit::Visitor;
 use rustc_hir::{
     BindingAnnotation, Expr, ExprKind, HirId, LangItem, Local, MatchSource, Node, Pat, PatKind, QPath, Stmt, StmtKind,
 };
@@ -211,7 +211,7 @@ fn indirect_usage<'tcx>(
     binding: HirId,
     ctxt: SyntaxContext,
 ) -> Option<IndirectUsage<'tcx>> {
-    if let StmtKind::Local(Local {
+    if let StmtKind::Local(&Local {
         pat: Pat {
             kind: PatKind::Binding(BindingAnnotation::NONE, _, ident, None),
             ..
@@ -222,14 +222,12 @@ fn indirect_usage<'tcx>(
     }) = stmt.kind
     {
         let mut path_to_binding = None;
-        expr_visitor(cx, |expr| {
-            if path_to_local_id(expr, binding) {
-                path_to_binding = Some(expr);
+        let _: Option<!> = for_each_expr_with_closures(cx, init_expr, |e| {
+            if path_to_local_id(e, binding) {
+                path_to_binding = Some(e);
             }
-
-            path_to_binding.is_none()
-        })
-        .visit_expr(init_expr);
+            ControlFlow::Continue(Descend::from(path_to_binding.is_none()))
+        });
 
         let mut parents = cx.tcx.hir().parent_iter(path_to_binding?.hir_id);
         let iter_usage = parse_iter_usage(cx, ctxt, &mut parents)?;
@@ -250,7 +248,7 @@ fn indirect_usage<'tcx>(
             ..
         } = iter_usage
         {
-            if parent_id == *local_hir_id {
+            if parent_id == local_hir_id {
                 return Some(IndirectUsage {
                     name: ident.name,
                     span: stmt.span,
diff --git a/clippy_lints/src/needless_late_init.rs b/clippy_lints/src/needless_late_init.rs
index cbad53f4450..9d26e590086 100644
--- a/clippy_lints/src/needless_late_init.rs
+++ b/clippy_lints/src/needless_late_init.rs
@@ -2,9 +2,9 @@ use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::path_to_local;
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::needs_ordered_drop;
-use clippy_utils::visitors::{expr_visitor, expr_visitor_no_bodies, is_local_used};
+use clippy_utils::visitors::{for_each_expr, for_each_expr_with_closures, is_local_used};
+use core::ops::ControlFlow;
 use rustc_errors::{Applicability, MultiSpan};
-use rustc_hir::intravisit::Visitor;
 use rustc_hir::{
     BindingAnnotation, Block, Expr, ExprKind, HirId, Local, LocalSource, MatchSource, Node, Pat, PatKind, Stmt,
     StmtKind,
@@ -64,31 +64,25 @@ declare_clippy_lint! {
 declare_lint_pass!(NeedlessLateInit => [NEEDLESS_LATE_INIT]);
 
 fn contains_assign_expr<'tcx>(cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'tcx>) -> bool {
-    let mut seen = false;
-    expr_visitor(cx, |expr| {
-        if let ExprKind::Assign(..) = expr.kind {
-            seen = true;
+    for_each_expr_with_closures(cx, stmt, |e| {
+        if matches!(e.kind, ExprKind::Assign(..)) {
+            ControlFlow::Break(())
+        } else {
+            ControlFlow::Continue(())
         }
-
-        !seen
     })
-    .visit_stmt(stmt);
-
-    seen
+    .is_some()
 }
 
 fn contains_let(cond: &Expr<'_>) -> bool {
-    let mut seen = false;
-    expr_visitor_no_bodies(|expr| {
-        if let ExprKind::Let(_) = expr.kind {
-            seen = true;
+    for_each_expr(cond, |e| {
+        if matches!(e.kind, ExprKind::Let(_)) {
+            ControlFlow::Break(())
+        } else {
+            ControlFlow::Continue(())
         }
-
-        !seen
     })
-    .visit_expr(cond);
-
-    seen
+    .is_some()
 }
 
 fn stmt_needs_ordered_drop(cx: &LateContext<'_>, stmt: &Stmt<'_>) -> bool {
diff --git a/clippy_lints/src/panic_in_result_fn.rs b/clippy_lints/src/panic_in_result_fn.rs
index 4aa0d9227ab..efec12489a9 100644
--- a/clippy_lints/src/panic_in_result_fn.rs
+++ b/clippy_lints/src/panic_in_result_fn.rs
@@ -2,9 +2,10 @@ use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::macros::root_macro_call_first_node;
 use clippy_utils::return_ty;
 use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::visitors::expr_visitor_no_bodies;
+use clippy_utils::visitors::{for_each_expr, Descend};
+use core::ops::ControlFlow;
 use rustc_hir as hir;
-use rustc_hir::intravisit::{FnKind, Visitor};
+use rustc_hir::intravisit::FnKind;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::{sym, Span};
@@ -58,18 +59,20 @@ impl<'tcx> LateLintPass<'tcx> for PanicInResultFn {
 
 fn lint_impl_body<'tcx>(cx: &LateContext<'tcx>, impl_span: Span, body: &'tcx hir::Body<'tcx>) {
     let mut panics = Vec::new();
-    expr_visitor_no_bodies(|expr| {
-        let Some(macro_call) = root_macro_call_first_node(cx, expr) else { return true };
+    let _: Option<!> = for_each_expr(body.value, |e| {
+        let Some(macro_call) = root_macro_call_first_node(cx, e) else {
+            return ControlFlow::Continue(Descend::Yes);
+        };
         if matches!(
             cx.tcx.item_name(macro_call.def_id).as_str(),
             "unimplemented" | "unreachable" | "panic" | "todo" | "assert" | "assert_eq" | "assert_ne"
         ) {
             panics.push(macro_call.span);
-            return false;
+            ControlFlow::Continue(Descend::No)
+        } else {
+            ControlFlow::Continue(Descend::Yes)
         }
-        true
-    })
-    .visit_expr(body.value);
+    });
     if !panics.is_empty() {
         span_lint_and_then(
             cx,
diff --git a/clippy_lints/src/read_zero_byte_vec.rs b/clippy_lints/src/read_zero_byte_vec.rs
index ae80b6f1269..fa107858863 100644
--- a/clippy_lints/src/read_zero_byte_vec.rs
+++ b/clippy_lints/src/read_zero_byte_vec.rs
@@ -2,9 +2,10 @@ use clippy_utils::{
     diagnostics::{span_lint, span_lint_and_sugg},
     higher::{get_vec_init_kind, VecInitKind},
     source::snippet,
-    visitors::expr_visitor_no_bodies,
+    visitors::for_each_expr,
 };
-use hir::{intravisit::Visitor, ExprKind, Local, PatKind, PathSegment, QPath, StmtKind};
+use core::ops::ControlFlow;
+use hir::{Expr, ExprKind, Local, PatKind, PathSegment, QPath, StmtKind};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass};
@@ -58,10 +59,8 @@ impl<'tcx> LateLintPass<'tcx> for ReadZeroByteVec {
                 && let PatKind::Binding(_, _, ident, _) = pat.kind
                 && let Some(vec_init_kind) = get_vec_init_kind(cx, init)
             {
-                // finds use of `_.read(&mut v)`
-                let mut read_found = false;
-                let mut visitor = expr_visitor_no_bodies(|expr| {
-                    if let ExprKind::MethodCall(path, _self, [arg], _) = expr.kind
+                let visitor = |expr: &Expr<'_>| {
+                    if let ExprKind::MethodCall(path, _, [arg], _) = expr.kind
                         && let PathSegment { ident: read_or_read_exact, .. } = *path
                         && matches!(read_or_read_exact.as_str(), "read" | "read_exact")
                         && let ExprKind::AddrOf(_, hir::Mutability::Mut, inner) = arg.kind
@@ -69,27 +68,22 @@ impl<'tcx> LateLintPass<'tcx> for ReadZeroByteVec {
                         && let [inner_seg] = inner_path.segments
                         && ident.name == inner_seg.ident.name
                     {
-                        read_found = true;
+                        ControlFlow::Break(())
+                    } else {
+                        ControlFlow::Continue(())
                     }
-                    !read_found
-                });
+                };
 
-                let next_stmt_span;
-                if idx == block.stmts.len() - 1 {
+                let (read_found, next_stmt_span) =
+                if let Some(next_stmt) = block.stmts.get(idx + 1) {
+                    // case { .. stmt; stmt; .. }
+                    (for_each_expr(next_stmt, visitor).is_some(), next_stmt.span)
+                } else if let Some(e) = block.expr {
                     // case { .. stmt; expr }
-                    if let Some(e) = block.expr {
-                        visitor.visit_expr(e);
-                        next_stmt_span = e.span;
-                    } else {
-                        return;
-                    }
+                    (for_each_expr(e, visitor).is_some(), e.span)
                 } else {
-                    // case { .. stmt; stmt; .. }
-                    let next_stmt = &block.stmts[idx + 1];
-                    visitor.visit_stmt(next_stmt);
-                    next_stmt_span = next_stmt.span;
-                }
-                drop(visitor);
+                    return
+                };
 
                 if read_found && !next_stmt_span.from_expansion() {
                     let applicability = Applicability::MaybeIncorrect;
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 8f67fa109fc..3caa6380e09 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -3,6 +3,7 @@
 #![feature(control_flow_enum)]
 #![feature(let_chains)]
 #![feature(lint_reasons)]
+#![feature(never_type)]
 #![feature(once_cell)]
 #![feature(rustc_private)]
 #![recursion_limit = "512"]
@@ -65,6 +66,7 @@ pub use self::hir_utils::{
     both, count_eq, eq_expr_value, hash_expr, hash_stmt, over, HirEqInterExpr, SpanlessEq, SpanlessHash,
 };
 
+use core::ops::ControlFlow;
 use std::collections::hash_map::Entry;
 use std::hash::BuildHasherDefault;
 use std::sync::OnceLock;
@@ -113,7 +115,7 @@ use rustc_target::abi::Integer;
 
 use crate::consts::{constant, Constant};
 use crate::ty::{can_partially_move_ty, expr_sig, is_copy, is_recursively_primitive_type, ty_is_fn_once_param};
-use crate::visitors::expr_visitor_no_bodies;
+use crate::visitors::for_each_expr;
 
 pub fn parse_msrv(msrv: &str, sess: Option<&Session>, span: Option<Span>) -> Option<RustcVersion> {
     if let Ok(version) = RustcVersion::parse(msrv) {
@@ -1193,17 +1195,14 @@ pub fn contains_name(name: Symbol, expr: &Expr<'_>) -> bool {
 
 /// Returns `true` if `expr` contains a return expression
 pub fn contains_return(expr: &hir::Expr<'_>) -> bool {
-    let mut found = false;
-    expr_visitor_no_bodies(|expr| {
-        if !found {
-            if let hir::ExprKind::Ret(..) = &expr.kind {
-                found = true;
-            }
+    for_each_expr(expr, |e| {
+        if matches!(e.kind, hir::ExprKind::Ret(..)) {
+            ControlFlow::Break(())
+        } else {
+            ControlFlow::Continue(())
         }
-        !found
     })
-    .visit_expr(expr);
-    found
+    .is_some()
 }
 
 /// Extends the span to the beginning of the spans line, incl. whitespaces.
diff --git a/clippy_utils/src/macros.rs b/clippy_utils/src/macros.rs
index 079c8f50f12..c0b87cd175e 100644
--- a/clippy_utils/src/macros.rs
+++ b/clippy_utils/src/macros.rs
@@ -2,7 +2,7 @@
 
 use crate::is_path_diagnostic_item;
 use crate::source::snippet_opt;
-use crate::visitors::expr_visitor_no_bodies;
+use crate::visitors::{for_each_expr, Descend};
 
 use arrayvec::ArrayVec;
 use itertools::{izip, Either, Itertools};
@@ -270,20 +270,19 @@ fn find_assert_args_inner<'a, const N: usize>(
     };
     let mut args = ArrayVec::new();
     let mut panic_expn = None;
-    expr_visitor_no_bodies(|e| {
+    let _: Option<!> = for_each_expr(expr, |e| {
         if args.is_full() {
             if panic_expn.is_none() && e.span.ctxt() != expr.span.ctxt() {
                 panic_expn = PanicExpn::parse(cx, e);
             }
-            panic_expn.is_none()
+            ControlFlow::Continue(Descend::from(panic_expn.is_none()))
         } else if is_assert_arg(cx, e, expn) {
             args.push(e);
-            false
+            ControlFlow::Continue(Descend::No)
         } else {
-            true
+            ControlFlow::Continue(Descend::Yes)
         }
-    })
-    .visit_expr(expr);
+    });
     let args = args.into_inner().ok()?;
     // if no `panic!(..)` is found, use `PanicExpn::Empty`
     // to indicate that the default assertion message is used
@@ -297,22 +296,19 @@ fn find_assert_within_debug_assert<'a>(
     expn: ExpnId,
     assert_name: Symbol,
 ) -> Option<(&'a Expr<'a>, ExpnId)> {
-    let mut found = None;
-    expr_visitor_no_bodies(|e| {
-        if found.is_some() || !e.span.from_expansion() {
-            return false;
+    for_each_expr(expr, |e| {
+        if !e.span.from_expansion() {
+            return ControlFlow::Continue(Descend::No);
         }
         let e_expn = e.span.ctxt().outer_expn();
         if e_expn == expn {
-            return true;
-        }
-        if e_expn.expn_data().macro_def_id.map(|id| cx.tcx.item_name(id)) == Some(assert_name) {
-            found = Some((e, e_expn));
+            ControlFlow::Continue(Descend::Yes)
+        } else if e_expn.expn_data().macro_def_id.map(|id| cx.tcx.item_name(id)) == Some(assert_name) {
+            ControlFlow::Break((e, e_expn))
+        } else {
+            ControlFlow::Continue(Descend::No)
         }
-        false
     })
-    .visit_expr(expr);
-    found
 }
 
 fn is_assert_arg(cx: &LateContext<'_>, expr: &Expr<'_>, assert_expn: ExpnId) -> bool {
@@ -396,16 +392,14 @@ impl FormatString {
         });
 
         let mut parts = Vec::new();
-        expr_visitor_no_bodies(|expr| {
-            if let ExprKind::Lit(lit) = &expr.kind {
-                if let LitKind::Str(symbol, _) = lit.node {
-                    parts.push(symbol);
-                }
+        let _: Option<!> = for_each_expr(pieces, |expr| {
+            if let ExprKind::Lit(lit) = &expr.kind
+                && let LitKind::Str(symbol, _) = lit.node
+            {
+                parts.push(symbol);
             }
-
-            true
-        })
-        .visit_expr(pieces);
+            ControlFlow::Continue(())
+        });
 
         Some(Self {
             span,
@@ -431,7 +425,7 @@ impl<'tcx> FormatArgsValues<'tcx> {
     fn new(args: &'tcx Expr<'tcx>, format_string_span: SpanData) -> Self {
         let mut pos_to_value_index = Vec::new();
         let mut value_args = Vec::new();
-        expr_visitor_no_bodies(|expr| {
+        let _: Option<!> = for_each_expr(args, |expr| {
             if expr.span.ctxt() == args.span.ctxt() {
                 // ArgumentV1::new_<format_trait>(<val>)
                 // ArgumentV1::from_usize(<val>)
@@ -453,16 +447,13 @@ impl<'tcx> FormatArgsValues<'tcx> {
 
                     pos_to_value_index.push(val_idx);
                 }
-
-                true
+                ControlFlow::Continue(Descend::Yes)
             } else {
                 // assume that any expr with a differing span is a value
                 value_args.push(expr);
-
-                false
+                ControlFlow::Continue(Descend::No)
             }
-        })
-        .visit_expr(args);
+        });
 
         Self {
             value_args,
@@ -866,22 +857,18 @@ impl<'tcx> FormatArgsExpn<'tcx> {
     }
 
     pub fn find_nested(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, expn_id: ExpnId) -> Option<Self> {
-        let mut format_args = None;
-        expr_visitor_no_bodies(|e| {
-            if format_args.is_some() {
-                return false;
-            }
+        for_each_expr(expr, |e| {
             let e_ctxt = e.span.ctxt();
             if e_ctxt == expr.span.ctxt() {
-                return true;
-            }
-            if e_ctxt.outer_expn().is_descendant_of(expn_id) {
-                format_args = FormatArgsExpn::parse(cx, e);
+                ControlFlow::Continue(Descend::Yes)
+            } else if e_ctxt.outer_expn().is_descendant_of(expn_id)
+                && let Some(args) = FormatArgsExpn::parse(cx, e)
+            {
+                ControlFlow::Break(args)
+            } else {
+                ControlFlow::Continue(Descend::No)
             }
-            false
         })
-        .visit_expr(expr);
-        format_args
     }
 
     /// Source callsite span of all inputs
diff --git a/clippy_utils/src/ptr.rs b/clippy_utils/src/ptr.rs
index 0226f74906b..88837d8a143 100644
--- a/clippy_utils/src/ptr.rs
+++ b/clippy_utils/src/ptr.rs
@@ -1,7 +1,7 @@
 use crate::source::snippet;
-use crate::visitors::expr_visitor_no_bodies;
+use crate::visitors::{for_each_expr, Descend};
 use crate::{path_to_local_id, strip_pat_refs};
-use rustc_hir::intravisit::Visitor;
+use core::ops::ControlFlow;
 use rustc_hir::{Body, BodyId, ExprKind, HirId, PatKind};
 use rustc_lint::LateContext;
 use rustc_span::Span;
@@ -30,28 +30,23 @@ fn extract_clone_suggestions<'tcx>(
     replace: &[(&'static str, &'static str)],
     body: &'tcx Body<'_>,
 ) -> Option<Vec<(Span, Cow<'static, str>)>> {
-    let mut abort = false;
     let mut spans = Vec::new();
-    expr_visitor_no_bodies(|expr| {
-        if abort {
-            return false;
-        }
-        if let ExprKind::MethodCall(seg, recv, [], _) = expr.kind {
-            if path_to_local_id(recv, id) {
-                if seg.ident.name.as_str() == "capacity" {
-                    abort = true;
-                    return false;
-                }
-                for &(fn_name, suffix) in replace {
-                    if seg.ident.name.as_str() == fn_name {
-                        spans.push((expr.span, snippet(cx, recv.span, "_") + suffix));
-                        return false;
-                    }
+    for_each_expr(body, |e| {
+        if let ExprKind::MethodCall(seg, recv, [], _) = e.kind
+            && path_to_local_id(recv, id)
+        {
+            if seg.ident.as_str() == "capacity" {
+                return ControlFlow::Break(());
+            }
+            for &(fn_name, suffix) in replace {
+                if seg.ident.as_str() == fn_name {
+                    spans.push((e.span, snippet(cx, recv.span, "_") + suffix));
+                    return ControlFlow::Continue(Descend::No);
                 }
             }
         }
-        !abort
+        ControlFlow::Continue(Descend::Yes)
     })
-    .visit_body(body);
-    if abort { None } else { Some(spans) }
+    .is_none()
+    .then_some(spans)
 }
diff --git a/clippy_utils/src/usage.rs b/clippy_utils/src/usage.rs
index 3221b82aed4..b5ec3fef3e0 100644
--- a/clippy_utils/src/usage.rs
+++ b/clippy_utils/src/usage.rs
@@ -1,5 +1,6 @@
 use crate as utils;
-use crate::visitors::{expr_visitor, expr_visitor_no_bodies};
+use crate::visitors::{for_each_expr, for_each_expr_with_closures, Descend};
+use core::ops::ControlFlow;
 use rustc_hir as hir;
 use rustc_hir::intravisit::{self, Visitor};
 use rustc_hir::HirIdSet;
@@ -148,28 +149,17 @@ impl<'a, 'tcx> intravisit::Visitor<'tcx> for BindingUsageFinder<'a, 'tcx> {
 }
 
 pub fn contains_return_break_continue_macro(expression: &Expr<'_>) -> bool {
-    let mut seen_return_break_continue = false;
-    expr_visitor_no_bodies(|ex| {
-        if seen_return_break_continue {
-            return false;
-        }
-        match &ex.kind {
-            ExprKind::Ret(..) | ExprKind::Break(..) | ExprKind::Continue(..) => {
-                seen_return_break_continue = true;
-            },
+    for_each_expr(expression, |e| {
+        match e.kind {
+            ExprKind::Ret(..) | ExprKind::Break(..) | ExprKind::Continue(..) => ControlFlow::Break(()),
             // Something special could be done here to handle while or for loop
             // desugaring, as this will detect a break if there's a while loop
             // or a for loop inside the expression.
-            _ => {
-                if ex.span.from_expansion() {
-                    seen_return_break_continue = true;
-                }
-            },
+            _ if e.span.from_expansion() => ControlFlow::Break(()),
+            _ => ControlFlow::Continue(()),
         }
-        !seen_return_break_continue
     })
-    .visit_expr(expression);
-    seen_return_break_continue
+    .is_some()
 }
 
 pub fn local_used_after_expr(cx: &LateContext<'_>, local_id: HirId, after: &Expr<'_>) -> bool {
@@ -200,23 +190,16 @@ pub fn local_used_after_expr(cx: &LateContext<'_>, local_id: HirId, after: &Expr
         return true;
     }
 
-    let mut used_after_expr = false;
     let mut past_expr = false;
-    expr_visitor(cx, |expr| {
-        if used_after_expr {
-            return false;
-        }
-
-        if expr.hir_id == after.hir_id {
+    for_each_expr_with_closures(cx, block, |e| {
+        if e.hir_id == after.hir_id {
             past_expr = true;
-            return false;
-        }
-
-        if past_expr && utils::path_to_local_id(expr, local_id) {
-            used_after_expr = true;
+            ControlFlow::Continue(Descend::No)
+        } else if past_expr && utils::path_to_local_id(e, local_id) {
+            ControlFlow::Break(())
+        } else {
+            ControlFlow::Continue(Descend::Yes)
         }
-        !used_after_expr
     })
-    .visit_block(block);
-    used_after_expr
+    .is_some()
 }
diff --git a/clippy_utils/src/visitors.rs b/clippy_utils/src/visitors.rs
index 232d571902b..d4294f18fd5 100644
--- a/clippy_utils/src/visitors.rs
+++ b/clippy_utils/src/visitors.rs
@@ -5,14 +5,13 @@ use rustc_hir as hir;
 use rustc_hir::def::{CtorKind, DefKind, Res};
 use rustc_hir::intravisit::{self, walk_block, walk_expr, Visitor};
 use rustc_hir::{
-    Arm, Block, BlockCheckMode, Body, BodyId, Expr, ExprKind, HirId, ItemId, ItemKind, Let, Pat, QPath, Stmt, UnOp,
-    UnsafeSource, Unsafety,
+    AnonConst, Arm, Block, BlockCheckMode, Body, BodyId, Expr, ExprKind, HirId, ItemId, ItemKind, Let, Pat, QPath,
+    Stmt, UnOp, UnsafeSource, Unsafety,
 };
 use rustc_lint::LateContext;
-use rustc_middle::hir::map::Map;
 use rustc_middle::hir::nested_filter;
 use rustc_middle::ty::adjustment::Adjust;
-use rustc_middle::ty::{self, Ty, TypeckResults};
+use rustc_middle::ty::{self, Ty, TyCtxt, TypeckResults};
 use rustc_span::Span;
 
 mod internal {
@@ -48,6 +47,26 @@ impl Continue for Descend {
     }
 }
 
+/// A type which can be visited.
+pub trait Visitable<'tcx> {
+    /// Calls the corresponding `visit_*` function on the visitor.
+    fn visit<V: Visitor<'tcx>>(self, visitor: &mut V);
+}
+macro_rules! visitable_ref {
+    ($t:ident, $f:ident) => {
+        impl<'tcx> Visitable<'tcx> for &'tcx $t<'tcx> {
+            fn visit<V: Visitor<'tcx>>(self, visitor: &mut V) {
+                visitor.$f(self);
+            }
+        }
+    };
+}
+visitable_ref!(Arm, visit_arm);
+visitable_ref!(Block, visit_block);
+visitable_ref!(Body, visit_body);
+visitable_ref!(Expr, visit_expr);
+visitable_ref!(Stmt, visit_stmt);
+
 /// Calls the given function once for each expression contained. This does not enter any bodies or
 /// nested items.
 pub fn for_each_expr<'tcx, B, C: Continue>(
@@ -82,57 +101,63 @@ pub fn for_each_expr<'tcx, B, C: Continue>(
     v.res
 }
 
-/// Convenience method for creating a `Visitor` with just `visit_expr` overridden and nested
-/// bodies (i.e. closures) are visited.
-/// If the callback returns `true`, the expr just provided to the callback is walked.
-#[must_use]
-pub fn expr_visitor<'tcx>(cx: &LateContext<'tcx>, f: impl FnMut(&'tcx Expr<'tcx>) -> bool) -> impl Visitor<'tcx> {
-    struct V<'tcx, F> {
-        hir: Map<'tcx>,
+/// Calls the given function once for each expression contained. This will enter bodies, but not
+/// nested items.
+pub fn for_each_expr_with_closures<'tcx, B, C: Continue>(
+    cx: &LateContext<'tcx>,
+    node: impl Visitable<'tcx>,
+    f: impl FnMut(&'tcx Expr<'tcx>) -> ControlFlow<B, C>,
+) -> Option<B> {
+    struct V<'tcx, B, F> {
+        tcx: TyCtxt<'tcx>,
         f: F,
+        res: Option<B>,
     }
-    impl<'tcx, F: FnMut(&'tcx Expr<'tcx>) -> bool> Visitor<'tcx> for V<'tcx, F> {
+    impl<'tcx, B, C: Continue, F: FnMut(&'tcx Expr<'tcx>) -> ControlFlow<B, C>> Visitor<'tcx> for V<'tcx, B, F> {
         type NestedFilter = nested_filter::OnlyBodies;
         fn nested_visit_map(&mut self) -> Self::Map {
-            self.hir
+            self.tcx.hir()
         }
 
-        fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) {
-            if (self.f)(expr) {
-                walk_expr(self, expr);
+        fn visit_expr(&mut self, e: &'tcx Expr<'tcx>) {
+            if self.res.is_some() {
+                return;
             }
-        }
-    }
-    V { hir: cx.tcx.hir(), f }
-}
-
-/// Convenience method for creating a `Visitor` with just `visit_expr` overridden and nested
-/// bodies (i.e. closures) are not visited.
-/// If the callback returns `true`, the expr just provided to the callback is walked.
-#[must_use]
-pub fn expr_visitor_no_bodies<'tcx>(f: impl FnMut(&'tcx Expr<'tcx>) -> bool) -> impl Visitor<'tcx> {
-    struct V<F>(F);
-    impl<'tcx, F: FnMut(&'tcx Expr<'tcx>) -> bool> Visitor<'tcx> for V<F> {
-        fn visit_expr(&mut self, e: &'tcx Expr<'_>) {
-            if (self.0)(e) {
-                walk_expr(self, e);
+            match (self.f)(e) {
+                ControlFlow::Continue(c) if c.descend() => walk_expr(self, e),
+                ControlFlow::Break(b) => self.res = Some(b),
+                ControlFlow::Continue(_) => (),
             }
         }
+
+        // Only walk closures
+        fn visit_anon_const(&mut self, _: &'tcx AnonConst) {}
+        // Avoid unnecessary `walk_*` calls.
+        fn visit_ty(&mut self, _: &'tcx hir::Ty<'tcx>) {}
+        fn visit_pat(&mut self, _: &'tcx Pat<'tcx>) {}
+        fn visit_qpath(&mut self, _: &'tcx QPath<'tcx>, _: HirId, _: Span) {}
+        // Avoid monomorphising all `visit_*` functions.
+        fn visit_nested_item(&mut self, _: ItemId) {}
     }
-    V(f)
+    let mut v = V {
+        tcx: cx.tcx,
+        f,
+        res: None,
+    };
+    node.visit(&mut v);
+    v.res
 }
 
 /// returns `true` if expr contains match expr desugared from try
 fn contains_try(expr: &hir::Expr<'_>) -> bool {
-    let mut found = false;
-    expr_visitor_no_bodies(|e| {
-        if !found {
-            found = matches!(e.kind, hir::ExprKind::Match(_, _, hir::MatchSource::TryDesugar));
+    for_each_expr(expr, |e| {
+        if matches!(e.kind, hir::ExprKind::Match(_, _, hir::MatchSource::TryDesugar)) {
+            ControlFlow::Break(())
+        } else {
+            ControlFlow::Continue(())
         }
-        !found
     })
-    .visit_expr(expr);
-    found
+    .is_some()
 }
 
 pub fn find_all_ret_expressions<'hir, F>(_cx: &LateContext<'_>, expr: &'hir hir::Expr<'hir>, callback: F) -> bool
@@ -228,68 +253,29 @@ where
     }
 }
 
-/// A type which can be visited.
-pub trait Visitable<'tcx> {
-    /// Calls the corresponding `visit_*` function on the visitor.
-    fn visit<V: Visitor<'tcx>>(self, visitor: &mut V);
-}
-macro_rules! visitable_ref {
-    ($t:ident, $f:ident) => {
-        impl<'tcx> Visitable<'tcx> for &'tcx $t<'tcx> {
-            fn visit<V: Visitor<'tcx>>(self, visitor: &mut V) {
-                visitor.$f(self);
-            }
-        }
-    };
-}
-visitable_ref!(Arm, visit_arm);
-visitable_ref!(Block, visit_block);
-visitable_ref!(Body, visit_body);
-visitable_ref!(Expr, visit_expr);
-visitable_ref!(Stmt, visit_stmt);
-
-// impl<'tcx, I: IntoIterator> Visitable<'tcx> for I
-// where
-//     I::Item: Visitable<'tcx>,
-// {
-//     fn visit<V: Visitor<'tcx>>(self, visitor: &mut V) {
-//         for x in self {
-//             x.visit(visitor);
-//         }
-//     }
-// }
-
 /// Checks if the given resolved path is used in the given body.
 pub fn is_res_used(cx: &LateContext<'_>, res: Res, body: BodyId) -> bool {
-    let mut found = false;
-    expr_visitor(cx, |e| {
-        if found {
-            return false;
-        }
-
+    for_each_expr_with_closures(cx, cx.tcx.hir().body(body).value, |e| {
         if let ExprKind::Path(p) = &e.kind {
             if cx.qpath_res(p, e.hir_id) == res {
-                found = true;
+                return ControlFlow::Break(());
             }
         }
-        !found
+        ControlFlow::Continue(())
     })
-    .visit_expr(cx.tcx.hir().body(body).value);
-    found
+    .is_some()
 }
 
 /// Checks if the given local is used.
 pub fn is_local_used<'tcx>(cx: &LateContext<'tcx>, visitable: impl Visitable<'tcx>, id: HirId) -> bool {
-    let mut is_used = false;
-    let mut visitor = expr_visitor(cx, |expr| {
-        if !is_used {
-            is_used = path_to_local_id(expr, id);
+    for_each_expr_with_closures(cx, visitable, |e| {
+        if path_to_local_id(e, id) {
+            ControlFlow::Break(())
+        } else {
+            ControlFlow::Continue(())
         }
-        !is_used
-    });
-    visitable.visit(&mut visitor);
-    drop(visitor);
-    is_used
+    })
+    .is_some()
 }
 
 /// Checks if the given expression is a constant.
-- 
cgit 1.4.1-3-g733a5


From 38236a713512d0a70d1f03e995201d9bac63c882 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Fri, 29 Apr 2022 00:09:55 -0400
Subject: Use `for_each_expr` in place of some visitors

---
 clippy_lints/src/blocks_in_if_conditions.rs        | 68 +++++++---------
 clippy_lints/src/cognitive_complexity.rs           | 63 +++++++--------
 clippy_lints/src/functions/must_use.rs             | 77 ++++++++----------
 .../src/functions/not_unsafe_ptr_arg_deref.rs      | 91 ++++++++--------------
 clippy_lints/src/methods/unnecessary_filter_map.rs | 51 ++++--------
 clippy_lints/src/operators/assign_op_pattern.rs    | 39 ++++------
 clippy_lints/src/returns.rs                        | 39 ++++------
 clippy_lints/src/suspicious_trait_impl.rs          | 33 ++++----
 clippy_lints/src/unwrap_in_result.rs               | 72 +++++++----------
 9 files changed, 205 insertions(+), 328 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/blocks_in_if_conditions.rs b/clippy_lints/src/blocks_in_if_conditions.rs
index 4df4d6ddf41..569bf27c3e7 100644
--- a/clippy_lints/src/blocks_in_if_conditions.rs
+++ b/clippy_lints/src/blocks_in_if_conditions.rs
@@ -3,10 +3,11 @@ use clippy_utils::get_parent_expr;
 use clippy_utils::higher;
 use clippy_utils::source::snippet_block_with_applicability;
 use clippy_utils::ty::implements_trait;
+use clippy_utils::visitors::{for_each_expr, Descend};
+use core::ops::ControlFlow;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
-use rustc_hir::intravisit::{walk_expr, Visitor};
-use rustc_hir::{BlockCheckMode, Closure, Expr, ExprKind};
+use rustc_hir::{BlockCheckMode, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -44,39 +45,6 @@ declare_clippy_lint! {
 
 declare_lint_pass!(BlocksInIfConditions => [BLOCKS_IN_IF_CONDITIONS]);
 
-struct ExVisitor<'a, 'tcx> {
-    found_block: Option<&'tcx Expr<'tcx>>,
-    cx: &'a LateContext<'tcx>,
-}
-
-impl<'a, 'tcx> Visitor<'tcx> for ExVisitor<'a, 'tcx> {
-    fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) {
-        if let ExprKind::Closure(&Closure { body, .. }) = expr.kind {
-            // do not lint if the closure is called using an iterator (see #1141)
-            if_chain! {
-                if let Some(parent) = get_parent_expr(self.cx, expr);
-                if let ExprKind::MethodCall(_, self_arg, ..) = &parent.kind;
-                let caller = self.cx.typeck_results().expr_ty(self_arg);
-                if let Some(iter_id) = self.cx.tcx.get_diagnostic_item(sym::Iterator);
-                if implements_trait(self.cx, caller, iter_id, &[]);
-                then {
-                    return;
-                }
-            }
-
-            let body = self.cx.tcx.hir().body(body);
-            let ex = &body.value;
-            if let ExprKind::Block(block, _) = ex.kind {
-                if !body.value.span.from_expansion() && !block.stmts.is_empty() {
-                    self.found_block = Some(ex);
-                    return;
-                }
-            }
-        }
-        walk_expr(self, expr);
-    }
-}
-
 const BRACED_EXPR_MESSAGE: &str = "omit braces around single expression condition";
 const COMPLEX_BLOCK_MESSAGE: &str = "in an `if` condition, avoid complex blocks or closures with blocks; \
                                     instead, move the block or closure higher and bind it with a `let`";
@@ -144,11 +112,31 @@ impl<'tcx> LateLintPass<'tcx> for BlocksInIfConditions {
                     }
                 }
             } else {
-                let mut visitor = ExVisitor { found_block: None, cx };
-                walk_expr(&mut visitor, cond);
-                if let Some(block) = visitor.found_block {
-                    span_lint(cx, BLOCKS_IN_IF_CONDITIONS, block.span, COMPLEX_BLOCK_MESSAGE);
-                }
+                let _: Option<!> = for_each_expr(cond, |e| {
+                    if let ExprKind::Closure(closure) = e.kind {
+                        // do not lint if the closure is called using an iterator (see #1141)
+                        if_chain! {
+                            if let Some(parent) = get_parent_expr(cx, e);
+                            if let ExprKind::MethodCall(_, self_arg, _, _) = &parent.kind;
+                            let caller = cx.typeck_results().expr_ty(self_arg);
+                            if let Some(iter_id) = cx.tcx.get_diagnostic_item(sym::Iterator);
+                            if implements_trait(cx, caller, iter_id, &[]);
+                            then {
+                                return ControlFlow::Continue(Descend::No);
+                            }
+                        }
+
+                        let body = cx.tcx.hir().body(closure.body);
+                        let ex = &body.value;
+                        if let ExprKind::Block(block, _) = ex.kind {
+                            if !body.value.span.from_expansion() && !block.stmts.is_empty() {
+                                span_lint(cx, BLOCKS_IN_IF_CONDITIONS, ex.span, COMPLEX_BLOCK_MESSAGE);
+                                return ControlFlow::Continue(Descend::No);
+                            }
+                        }
+                    }
+                    ControlFlow::Continue(Descend::Yes)
+                });
             }
         }
     }
diff --git a/clippy_lints/src/cognitive_complexity.rs b/clippy_lints/src/cognitive_complexity.rs
index fed04ae7f3d..77af3b53d63 100644
--- a/clippy_lints/src/cognitive_complexity.rs
+++ b/clippy_lints/src/cognitive_complexity.rs
@@ -3,10 +3,12 @@
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::visitors::for_each_expr;
 use clippy_utils::LimitStack;
+use core::ops::ControlFlow;
 use rustc_ast::ast::Attribute;
-use rustc_hir::intravisit::{walk_expr, FnKind, Visitor};
-use rustc_hir::{Body, Expr, ExprKind, FnDecl, HirId};
+use rustc_hir::intravisit::FnKind;
+use rustc_hir::{Body, ExprKind, FnDecl, HirId};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::Span;
@@ -61,11 +63,27 @@ impl CognitiveComplexity {
             return;
         }
 
-        let expr = &body.value;
+        let expr = body.value;
+
+        let mut cc = 1u64;
+        let mut returns = 0u64;
+        let _: Option<!> = for_each_expr(expr, |e| {
+            match e.kind {
+                ExprKind::If(_, _, _) => {
+                    cc += 1;
+                },
+                ExprKind::Match(_, arms, _) => {
+                    if arms.len() > 1 {
+                        cc += 1;
+                    }
+                    cc += arms.iter().filter(|arm| arm.guard.is_some()).count() as u64;
+                },
+                ExprKind::Ret(_) => returns += 1,
+                _ => {},
+            }
+            ControlFlow::Continue(())
+        });
 
-        let mut helper = CcHelper { cc: 1, returns: 0 };
-        helper.visit_expr(expr);
-        let CcHelper { cc, returns } = helper;
         let ret_ty = cx.typeck_results().node_type(expr.hir_id);
         let ret_adjust = if is_type_diagnostic_item(cx, ret_ty, sym::Result) {
             returns
@@ -74,13 +92,12 @@ impl CognitiveComplexity {
             (returns / 2)
         };
 
-        let mut rust_cc = cc;
         // prevent degenerate cases where unreachable code contains `return` statements
-        if rust_cc >= ret_adjust {
-            rust_cc -= ret_adjust;
+        if cc >= ret_adjust {
+            cc -= ret_adjust;
         }
 
-        if rust_cc > self.limit.limit() {
+        if cc > self.limit.limit() {
             let fn_span = match kind {
                 FnKind::ItemFn(ident, _, _) | FnKind::Method(ident, _) => ident.span,
                 FnKind::Closure => {
@@ -107,7 +124,7 @@ impl CognitiveComplexity {
                 COGNITIVE_COMPLEXITY,
                 fn_span,
                 &format!(
-                    "the function has a cognitive complexity of ({rust_cc}/{})",
+                    "the function has a cognitive complexity of ({cc}/{})",
                     self.limit.limit()
                 ),
                 None,
@@ -140,27 +157,3 @@ impl<'tcx> LateLintPass<'tcx> for CognitiveComplexity {
         self.limit.pop_attrs(cx.sess(), attrs, "cognitive_complexity");
     }
 }
-
-struct CcHelper {
-    cc: u64,
-    returns: u64,
-}
-
-impl<'tcx> Visitor<'tcx> for CcHelper {
-    fn visit_expr(&mut self, e: &'tcx Expr<'_>) {
-        walk_expr(self, e);
-        match e.kind {
-            ExprKind::If(_, _, _) => {
-                self.cc += 1;
-            },
-            ExprKind::Match(_, arms, _) => {
-                if arms.len() > 1 {
-                    self.cc += 1;
-                }
-                self.cc += arms.iter().filter(|arm| arm.guard.is_some()).count() as u64;
-            },
-            ExprKind::Ret(_) => self.returns += 1,
-            _ => {},
-        }
-    }
-}
diff --git a/clippy_lints/src/functions/must_use.rs b/clippy_lints/src/functions/must_use.rs
index 977c8ee594f..d263804f32c 100644
--- a/clippy_lints/src/functions/must_use.rs
+++ b/clippy_lints/src/functions/must_use.rs
@@ -1,7 +1,7 @@
 use rustc_ast::ast::Attribute;
 use rustc_errors::Applicability;
 use rustc_hir::def_id::{DefIdSet, LocalDefId};
-use rustc_hir::{self as hir, def::Res, intravisit, QPath};
+use rustc_hir::{self as hir, def::Res, QPath};
 use rustc_lint::{LateContext, LintContext};
 use rustc_middle::{
     lint::in_external_macro,
@@ -13,8 +13,11 @@ use clippy_utils::attrs::is_proc_macro;
 use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_then};
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::is_must_use_ty;
+use clippy_utils::visitors::for_each_expr;
 use clippy_utils::{match_def_path, return_ty, trait_ref_of_method};
 
+use core::ops::ControlFlow;
+
 use super::{DOUBLE_MUST_USE, MUST_USE_CANDIDATE, MUST_USE_UNIT};
 
 pub(super) fn check_item<'tcx>(cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) {
@@ -200,79 +203,65 @@ fn is_mutable_ty<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>, span: Span, tys: &m
     }
 }
 
-struct StaticMutVisitor<'a, 'tcx> {
-    cx: &'a LateContext<'tcx>,
-    mutates_static: bool,
+fn is_mutated_static(e: &hir::Expr<'_>) -> bool {
+    use hir::ExprKind::{Field, Index, Path};
+
+    match e.kind {
+        Path(QPath::Resolved(_, path)) => !matches!(path.res, Res::Local(_)),
+        Path(_) => true,
+        Field(inner, _) | Index(inner, _) => is_mutated_static(inner),
+        _ => false,
+    }
 }
 
-impl<'a, 'tcx> intravisit::Visitor<'tcx> for StaticMutVisitor<'a, 'tcx> {
-    fn visit_expr(&mut self, expr: &'tcx hir::Expr<'_>) {
+fn mutates_static<'tcx>(cx: &LateContext<'tcx>, body: &'tcx hir::Body<'_>) -> bool {
+    for_each_expr(body.value, |e| {
         use hir::ExprKind::{AddrOf, Assign, AssignOp, Call, MethodCall};
 
-        if self.mutates_static {
-            return;
-        }
-        match expr.kind {
+        match e.kind {
             Call(_, args) => {
                 let mut tys = DefIdSet::default();
                 for arg in args {
-                    if self.cx.tcx.has_typeck_results(arg.hir_id.owner.to_def_id())
+                    if cx.tcx.has_typeck_results(arg.hir_id.owner.to_def_id())
                         && is_mutable_ty(
-                            self.cx,
-                            self.cx.tcx.typeck(arg.hir_id.owner.def_id).expr_ty(arg),
+                            cx,
+                            cx.tcx.typeck(arg.hir_id.owner.def_id).expr_ty(arg),
                             arg.span,
                             &mut tys,
                         )
                         && is_mutated_static(arg)
                     {
-                        self.mutates_static = true;
-                        return;
+                        return ControlFlow::Break(());
                     }
                     tys.clear();
                 }
+                ControlFlow::Continue(())
             },
             MethodCall(_, receiver, args, _) => {
                 let mut tys = DefIdSet::default();
                 for arg in std::iter::once(receiver).chain(args.iter()) {
-                    if self.cx.tcx.has_typeck_results(arg.hir_id.owner.to_def_id())
+                    if cx.tcx.has_typeck_results(arg.hir_id.owner.to_def_id())
                         && is_mutable_ty(
-                            self.cx,
-                            self.cx.tcx.typeck(arg.hir_id.owner.def_id).expr_ty(arg),
+                            cx,
+                            cx.tcx.typeck(arg.hir_id.owner.def_id).expr_ty(arg),
                             arg.span,
                             &mut tys,
                         )
                         && is_mutated_static(arg)
                     {
-                        self.mutates_static = true;
-                        return;
+                        return ControlFlow::Break(());
                     }
                     tys.clear();
                 }
+                ControlFlow::Continue(())
             },
-            Assign(target, ..) | AssignOp(_, target, _) | AddrOf(_, hir::Mutability::Mut, target) => {
-                self.mutates_static |= is_mutated_static(target);
+            Assign(target, ..) | AssignOp(_, target, _) | AddrOf(_, hir::Mutability::Mut, target)
+                if is_mutated_static(target) =>
+            {
+                ControlFlow::Break(())
             },
-            _ => {},
+            _ => ControlFlow::Continue(()),
         }
-    }
-}
-
-fn is_mutated_static(e: &hir::Expr<'_>) -> bool {
-    use hir::ExprKind::{Field, Index, Path};
-
-    match e.kind {
-        Path(QPath::Resolved(_, path)) => !matches!(path.res, Res::Local(_)),
-        Path(_) => true,
-        Field(inner, _) | Index(inner, _) => is_mutated_static(inner),
-        _ => false,
-    }
-}
-
-fn mutates_static<'tcx>(cx: &LateContext<'tcx>, body: &'tcx hir::Body<'_>) -> bool {
-    let mut v = StaticMutVisitor {
-        cx,
-        mutates_static: false,
-    };
-    intravisit::walk_expr(&mut v, body.value);
-    v.mutates_static
+    })
+    .is_some()
 }
diff --git a/clippy_lints/src/functions/not_unsafe_ptr_arg_deref.rs b/clippy_lints/src/functions/not_unsafe_ptr_arg_deref.rs
index 0b50431fbaa..b7595d101e0 100644
--- a/clippy_lints/src/functions/not_unsafe_ptr_arg_deref.rs
+++ b/clippy_lints/src/functions/not_unsafe_ptr_arg_deref.rs
@@ -5,8 +5,11 @@ use rustc_span::def_id::LocalDefId;
 
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::ty::type_is_unsafe_function;
+use clippy_utils::visitors::for_each_expr_with_closures;
 use clippy_utils::{iter_input_pats, path_to_local};
 
+use core::ops::ControlFlow;
+
 use super::NOT_UNSAFE_PTR_ARG_DEREF;
 
 pub(super) fn check_fn<'tcx>(
@@ -39,21 +42,34 @@ fn check_raw_ptr<'tcx>(
     body: &'tcx hir::Body<'tcx>,
     def_id: LocalDefId,
 ) {
-    let expr = &body.value;
     if unsafety == hir::Unsafety::Normal && cx.access_levels.is_exported(def_id) {
         let raw_ptrs = iter_input_pats(decl, body)
             .filter_map(|arg| raw_ptr_arg(cx, arg))
             .collect::<HirIdSet>();
 
         if !raw_ptrs.is_empty() {
-            let typeck_results = cx.tcx.typeck_body(body.id());
-            let mut v = DerefVisitor {
-                cx,
-                ptrs: raw_ptrs,
-                typeck_results,
-            };
-
-            intravisit::walk_expr(&mut v, expr);
+            let typeck = cx.tcx.typeck_body(body.id());
+            let _: Option<!> = for_each_expr_with_closures(cx, body.value, |e| {
+                match e.kind {
+                    hir::ExprKind::Call(f, args) if type_is_unsafe_function(cx, typeck.expr_ty(f)) => {
+                        for arg in args {
+                            check_arg(cx, &raw_ptrs, arg);
+                        }
+                    },
+                    hir::ExprKind::MethodCall(_, recv, args, _) => {
+                        let def_id = typeck.type_dependent_def_id(e.hir_id).unwrap();
+                        if cx.tcx.fn_sig(def_id).skip_binder().unsafety == hir::Unsafety::Unsafe {
+                            check_arg(cx, &raw_ptrs, recv);
+                            for arg in args {
+                                check_arg(cx, &raw_ptrs, arg);
+                            }
+                        }
+                    },
+                    hir::ExprKind::Unary(hir::UnOp::Deref, ptr) => check_arg(cx, &raw_ptrs, ptr),
+                    _ => (),
+                }
+                ControlFlow::Continue(())
+            });
         }
     }
 }
@@ -70,54 +86,13 @@ fn raw_ptr_arg(cx: &LateContext<'_>, arg: &hir::Param<'_>) -> Option<hir::HirId>
     }
 }
 
-struct DerefVisitor<'a, 'tcx> {
-    cx: &'a LateContext<'tcx>,
-    ptrs: HirIdSet,
-    typeck_results: &'a ty::TypeckResults<'tcx>,
-}
-
-impl<'a, 'tcx> intravisit::Visitor<'tcx> for DerefVisitor<'a, 'tcx> {
-    fn visit_expr(&mut self, expr: &'tcx hir::Expr<'_>) {
-        match expr.kind {
-            hir::ExprKind::Call(f, args) => {
-                let ty = self.typeck_results.expr_ty(f);
-
-                if type_is_unsafe_function(self.cx, ty) {
-                    for arg in args {
-                        self.check_arg(arg);
-                    }
-                }
-            },
-            hir::ExprKind::MethodCall(_, receiver, args, _) => {
-                let def_id = self.typeck_results.type_dependent_def_id(expr.hir_id).unwrap();
-                let base_type = self.cx.tcx.type_of(def_id);
-
-                if type_is_unsafe_function(self.cx, base_type) {
-                    self.check_arg(receiver);
-                    for arg in args {
-                        self.check_arg(arg);
-                    }
-                }
-            },
-            hir::ExprKind::Unary(hir::UnOp::Deref, ptr) => self.check_arg(ptr),
-            _ => (),
-        }
-
-        intravisit::walk_expr(self, expr);
-    }
-}
-
-impl<'a, 'tcx> DerefVisitor<'a, 'tcx> {
-    fn check_arg(&self, ptr: &hir::Expr<'_>) {
-        if let Some(id) = path_to_local(ptr) {
-            if self.ptrs.contains(&id) {
-                span_lint(
-                    self.cx,
-                    NOT_UNSAFE_PTR_ARG_DEREF,
-                    ptr.span,
-                    "this public function might dereference a raw pointer but is not marked `unsafe`",
-                );
-            }
-        }
+fn check_arg(cx: &LateContext<'_>, raw_ptrs: &HirIdSet, arg: &hir::Expr<'_>) {
+    if path_to_local(arg).map_or(false, |id| raw_ptrs.contains(&id)) {
+        span_lint(
+            cx,
+            NOT_UNSAFE_PTR_ARG_DEREF,
+            arg.span,
+            "this public function might dereference a raw pointer but is not marked `unsafe`",
+        );
     }
 }
diff --git a/clippy_lints/src/methods/unnecessary_filter_map.rs b/clippy_lints/src/methods/unnecessary_filter_map.rs
index 50434a5658a..1cef6226ad4 100644
--- a/clippy_lints/src/methods/unnecessary_filter_map.rs
+++ b/clippy_lints/src/methods/unnecessary_filter_map.rs
@@ -2,9 +2,10 @@ use super::utils::clone_or_copy_needed;
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::ty::is_copy;
 use clippy_utils::usage::mutated_variables;
+use clippy_utils::visitors::{for_each_expr, Descend};
 use clippy_utils::{is_res_lang_ctor, is_trait_method, path_res, path_to_local_id};
+use core::ops::ControlFlow;
 use rustc_hir as hir;
-use rustc_hir::intravisit::{walk_expr, Visitor};
 use rustc_hir::LangItem::{OptionNone, OptionSome};
 use rustc_lint::LateContext;
 use rustc_middle::ty;
@@ -13,7 +14,7 @@ use rustc_span::sym;
 use super::UNNECESSARY_FILTER_MAP;
 use super::UNNECESSARY_FIND_MAP;
 
-pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, arg: &hir::Expr<'_>, name: &str) {
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'tcx>, arg: &'tcx hir::Expr<'tcx>, name: &str) {
     if !is_trait_method(cx, expr, sym::Iterator) {
         return;
     }
@@ -26,10 +27,16 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, arg: &hir::Expr<
 
         let (mut found_mapping, mut found_filtering) = check_expression(cx, arg_id, body.value);
 
-        let mut return_visitor = ReturnVisitor::new(cx, arg_id);
-        return_visitor.visit_expr(body.value);
-        found_mapping |= return_visitor.found_mapping;
-        found_filtering |= return_visitor.found_filtering;
+        let _: Option<!> = for_each_expr(body.value, |e| {
+            if let hir::ExprKind::Ret(Some(e)) = &e.kind {
+                let (found_mapping_res, found_filtering_res) = check_expression(cx, arg_id, e);
+                found_mapping |= found_mapping_res;
+                found_filtering |= found_filtering_res;
+                ControlFlow::Continue(Descend::No)
+            } else {
+                ControlFlow::Continue(Descend::Yes)
+            }
+        });
 
         let in_ty = cx.typeck_results().node_type(body.params[0].hir_id);
         let sugg = if !found_filtering {
@@ -97,35 +104,3 @@ fn check_expression<'tcx>(cx: &LateContext<'tcx>, arg_id: hir::HirId, expr: &'tc
         _ => (true, true),
     }
 }
-
-struct ReturnVisitor<'a, 'tcx> {
-    cx: &'a LateContext<'tcx>,
-    arg_id: hir::HirId,
-    // Found a non-None return that isn't Some(input)
-    found_mapping: bool,
-    // Found a return that isn't Some
-    found_filtering: bool,
-}
-
-impl<'a, 'tcx> ReturnVisitor<'a, 'tcx> {
-    fn new(cx: &'a LateContext<'tcx>, arg_id: hir::HirId) -> ReturnVisitor<'a, 'tcx> {
-        ReturnVisitor {
-            cx,
-            arg_id,
-            found_mapping: false,
-            found_filtering: false,
-        }
-    }
-}
-
-impl<'a, 'tcx> Visitor<'tcx> for ReturnVisitor<'a, 'tcx> {
-    fn visit_expr(&mut self, expr: &'tcx hir::Expr<'_>) {
-        if let hir::ExprKind::Ret(Some(expr)) = &expr.kind {
-            let (found_mapping, found_filtering) = check_expression(self.cx, self.arg_id, expr);
-            self.found_mapping |= found_mapping;
-            self.found_filtering |= found_filtering;
-        } else {
-            walk_expr(self, expr);
-        }
-    }
-}
diff --git a/clippy_lints/src/operators/assign_op_pattern.rs b/clippy_lints/src/operators/assign_op_pattern.rs
index 2d5d5d143ff..26bca7c306a 100644
--- a/clippy_lints/src/operators/assign_op_pattern.rs
+++ b/clippy_lints/src/operators/assign_op_pattern.rs
@@ -2,11 +2,12 @@ use clippy_utils::binop_traits;
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::implements_trait;
+use clippy_utils::visitors::for_each_expr;
 use clippy_utils::{eq_expr_value, trait_ref_of_method};
+use core::ops::ControlFlow;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
-use rustc_hir::intravisit::{walk_expr, Visitor};
 use rustc_hir_analysis::expr_use_visitor::{Delegate, ExprUseVisitor, PlaceBase, PlaceWithHirId};
 use rustc_lint::LateContext;
 use rustc_middle::mir::FakeReadCause;
@@ -65,15 +66,19 @@ pub(super) fn check<'tcx>(
             }
         };
 
-        let mut visitor = ExprVisitor {
-            assignee,
-            counter: 0,
-            cx,
-        };
-
-        walk_expr(&mut visitor, e);
+        let mut found = false;
+        let found_multiple = for_each_expr(e, |e| {
+            if eq_expr_value(cx, assignee, e) {
+                if found {
+                    return ControlFlow::Break(());
+                }
+                found = true;
+            }
+            ControlFlow::Continue(())
+        })
+        .is_some();
 
-        if visitor.counter == 1 {
+        if found && !found_multiple {
             // a = a op b
             if eq_expr_value(cx, assignee, l) {
                 lint(assignee, r);
@@ -98,22 +103,6 @@ pub(super) fn check<'tcx>(
     }
 }
 
-struct ExprVisitor<'a, 'tcx> {
-    assignee: &'a hir::Expr<'a>,
-    counter: u8,
-    cx: &'a LateContext<'tcx>,
-}
-
-impl<'a, 'tcx> Visitor<'tcx> for ExprVisitor<'a, 'tcx> {
-    fn visit_expr(&mut self, expr: &'tcx hir::Expr<'_>) {
-        if eq_expr_value(self.cx, self.assignee, expr) {
-            self.counter += 1;
-        }
-
-        walk_expr(self, expr);
-    }
-}
-
 fn imm_borrows_in_expr(cx: &LateContext<'_>, e: &hir::Expr<'_>) -> hir::HirIdSet {
     struct S(hir::HirIdSet);
     impl Delegate<'_> for S {
diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
index f758f4cff8b..2b2a41d1601 100644
--- a/clippy_lints/src/returns.rs
+++ b/clippy_lints/src/returns.rs
@@ -1,9 +1,11 @@
 use clippy_utils::diagnostics::{span_lint_and_then, span_lint_hir_and_then};
 use clippy_utils::source::{snippet_opt, snippet_with_context};
+use clippy_utils::visitors::{for_each_expr, Descend};
 use clippy_utils::{fn_def_id, path_to_local_id};
+use core::ops::ControlFlow;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
-use rustc_hir::intravisit::{walk_expr, FnKind, Visitor};
+use rustc_hir::intravisit::FnKind;
 use rustc_hir::{Block, Body, Expr, ExprKind, FnDecl, HirId, MatchSource, PatKind, StmtKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
@@ -270,33 +272,20 @@ fn emit_return_lint(
 }
 
 fn last_statement_borrows<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
-    let mut visitor = BorrowVisitor { cx, borrows: false };
-    walk_expr(&mut visitor, expr);
-    visitor.borrows
-}
-
-struct BorrowVisitor<'a, 'tcx> {
-    cx: &'a LateContext<'tcx>,
-    borrows: bool,
-}
-
-impl<'tcx> Visitor<'tcx> for BorrowVisitor<'_, 'tcx> {
-    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
-        if self.borrows || expr.span.from_expansion() {
-            return;
-        }
-
-        if let Some(def_id) = fn_def_id(self.cx, expr) {
-            self.borrows = self
-                .cx
+    for_each_expr(expr, |e| {
+        if let Some(def_id) = fn_def_id(cx, e)
+            && cx
                 .tcx
                 .fn_sig(def_id)
-                .output()
                 .skip_binder()
+                .output()
                 .walk()
-                .any(|arg| matches!(arg.unpack(), GenericArgKind::Lifetime(_)));
+                .any(|arg| matches!(arg.unpack(), GenericArgKind::Lifetime(_)))
+        {
+            ControlFlow::Break(())
+        } else {
+            ControlFlow::Continue(Descend::from(!expr.span.from_expansion()))
         }
-
-        walk_expr(self, expr);
-    }
+    })
+    .is_some()
 }
diff --git a/clippy_lints/src/suspicious_trait_impl.rs b/clippy_lints/src/suspicious_trait_impl.rs
index d47ed459387..b57b484bdc8 100644
--- a/clippy_lints/src/suspicious_trait_impl.rs
+++ b/clippy_lints/src/suspicious_trait_impl.rs
@@ -1,8 +1,9 @@
 use clippy_utils::diagnostics::span_lint;
+use clippy_utils::visitors::for_each_expr;
 use clippy_utils::{binop_traits, trait_ref_of_method, BINOP_TRAITS, OP_ASSIGN_TRAITS};
+use core::ops::ControlFlow;
 use if_chain::if_chain;
 use rustc_hir as hir;
-use rustc_hir::intravisit::{walk_expr, Visitor};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
@@ -92,25 +93,17 @@ impl<'tcx> LateLintPass<'tcx> for SuspiciousImpl {
 }
 
 fn count_binops(expr: &hir::Expr<'_>) -> u32 {
-    let mut visitor = BinaryExprVisitor::default();
-    visitor.visit_expr(expr);
-    visitor.nb_binops
-}
-
-#[derive(Default)]
-struct BinaryExprVisitor {
-    nb_binops: u32,
-}
-
-impl<'tcx> Visitor<'tcx> for BinaryExprVisitor {
-    fn visit_expr(&mut self, expr: &'tcx hir::Expr<'_>) {
-        match expr.kind {
+    let mut count = 0u32;
+    let _: Option<!> = for_each_expr(expr, |e| {
+        if matches!(
+            e.kind,
             hir::ExprKind::Binary(..)
-            | hir::ExprKind::Unary(hir::UnOp::Not | hir::UnOp::Neg, _)
-            | hir::ExprKind::AssignOp(..) => self.nb_binops += 1,
-            _ => {},
+                | hir::ExprKind::Unary(hir::UnOp::Not | hir::UnOp::Neg, _)
+                | hir::ExprKind::AssignOp(..)
+        ) {
+            count += 1;
         }
-
-        walk_expr(self, expr);
-    }
+        ControlFlow::Continue(())
+    });
+    count
 }
diff --git a/clippy_lints/src/unwrap_in_result.rs b/clippy_lints/src/unwrap_in_result.rs
index baa53ba664f..a69719b127b 100644
--- a/clippy_lints/src/unwrap_in_result.rs
+++ b/clippy_lints/src/unwrap_in_result.rs
@@ -1,12 +1,12 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::visitors::for_each_expr;
 use clippy_utils::{method_chain_args, return_ty};
+use core::ops::ControlFlow;
 use if_chain::if_chain;
 use rustc_hir as hir;
-use rustc_hir::intravisit::{self, Visitor};
-use rustc_hir::{Expr, ImplItemKind};
+use rustc_hir::ImplItemKind;
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::{sym, Span};
 
@@ -73,51 +73,37 @@ impl<'tcx> LateLintPass<'tcx> for UnwrapInResult {
     }
 }
 
-struct FindExpectUnwrap<'a, 'tcx> {
-    lcx: &'a LateContext<'tcx>,
-    typeck_results: &'tcx ty::TypeckResults<'tcx>,
-    result: Vec<Span>,
-}
-
-impl<'a, 'tcx> Visitor<'tcx> for FindExpectUnwrap<'a, 'tcx> {
-    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
-        // check for `expect`
-        if let Some(arglists) = method_chain_args(expr, &["expect"]) {
-            let receiver_ty = self.typeck_results.expr_ty(arglists[0].0).peel_refs();
-            if is_type_diagnostic_item(self.lcx, receiver_ty, sym::Option)
-                || is_type_diagnostic_item(self.lcx, receiver_ty, sym::Result)
-            {
-                self.result.push(expr.span);
+fn lint_impl_body<'tcx>(cx: &LateContext<'tcx>, impl_span: Span, impl_item: &'tcx hir::ImplItem<'_>) {
+    if let ImplItemKind::Fn(_, body_id) = impl_item.kind {
+        let body = cx.tcx.hir().body(body_id);
+        let typeck = cx.tcx.typeck(impl_item.def_id.def_id);
+        let mut result = Vec::new();
+        let _: Option<!> = for_each_expr(body.value, |e| {
+            // check for `expect`
+            if let Some(arglists) = method_chain_args(e, &["expect"]) {
+                let receiver_ty = typeck.expr_ty(arglists[0].0).peel_refs();
+                if is_type_diagnostic_item(cx, receiver_ty, sym::Option)
+                    || is_type_diagnostic_item(cx, receiver_ty, sym::Result)
+                {
+                    result.push(e.span);
+                }
             }
-        }
 
-        // check for `unwrap`
-        if let Some(arglists) = method_chain_args(expr, &["unwrap"]) {
-            let receiver_ty = self.typeck_results.expr_ty(arglists[0].0).peel_refs();
-            if is_type_diagnostic_item(self.lcx, receiver_ty, sym::Option)
-                || is_type_diagnostic_item(self.lcx, receiver_ty, sym::Result)
-            {
-                self.result.push(expr.span);
+            // check for `unwrap`
+            if let Some(arglists) = method_chain_args(e, &["unwrap"]) {
+                let receiver_ty = typeck.expr_ty(arglists[0].0).peel_refs();
+                if is_type_diagnostic_item(cx, receiver_ty, sym::Option)
+                    || is_type_diagnostic_item(cx, receiver_ty, sym::Result)
+                {
+                    result.push(e.span);
+                }
             }
-        }
 
-        // and check sub-expressions
-        intravisit::walk_expr(self, expr);
-    }
-}
-
-fn lint_impl_body<'tcx>(cx: &LateContext<'tcx>, impl_span: Span, impl_item: &'tcx hir::ImplItem<'_>) {
-    if let ImplItemKind::Fn(_, body_id) = impl_item.kind {
-        let body = cx.tcx.hir().body(body_id);
-        let mut fpu = FindExpectUnwrap {
-            lcx: cx,
-            typeck_results: cx.tcx.typeck(impl_item.def_id.def_id),
-            result: Vec::new(),
-        };
-        fpu.visit_expr(body.value);
+            ControlFlow::Continue(())
+        });
 
         // if we've found one, lint
-        if !fpu.result.is_empty() {
+        if !result.is_empty() {
             span_lint_and_then(
                 cx,
                 UNWRAP_IN_RESULT,
@@ -125,7 +111,7 @@ fn lint_impl_body<'tcx>(cx: &LateContext<'tcx>, impl_span: Span, impl_item: &'tc
                 "used unwrap or expect in a function that returns result or option",
                 move |diag| {
                     diag.help("unwrap and expect should not be used in a function that returns result or option");
-                    diag.span_note(fpu.result, "potential non-recoverable error(s)");
+                    diag.span_note(result, "potential non-recoverable error(s)");
                 },
             );
         }
-- 
cgit 1.4.1-3-g733a5


From bf18768219549a502d33d6821e691aeb0abfe69f Mon Sep 17 00:00:00 2001
From: TennyZhuang <zty0826@gmail.com>
Date: Mon, 3 Oct 2022 10:11:57 +0800
Subject: let upper_case_acronyms check the enum name

Signed-off-by: TennyZhuang <zty0826@gmail.com>
---
 clippy_lints/src/upper_case_acronyms.rs |  1 +
 tests/ui/upper_case_acronyms.rs         |  9 +++++++++
 tests/ui/upper_case_acronyms.stderr     | 14 +++++++++++++-
 3 files changed, 23 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/upper_case_acronyms.rs b/clippy_lints/src/upper_case_acronyms.rs
index 2ab58f06d6b..654ea306793 100644
--- a/clippy_lints/src/upper_case_acronyms.rs
+++ b/clippy_lints/src/upper_case_acronyms.rs
@@ -114,6 +114,7 @@ impl LateLintPass<'_> for UpperCaseAcronyms {
                 check_ident(cx, &it.ident, self.upper_case_acronyms_aggressive);
             },
             ItemKind::Enum(ref enumdef, _) => {
+                check_ident(cx, &it.ident, self.upper_case_acronyms_aggressive);
                 // check enum variants separately because again we only want to lint on private enums and
                 // the fn check_variant does not know about the vis of the enum of its variants
                 enumdef
diff --git a/tests/ui/upper_case_acronyms.rs b/tests/ui/upper_case_acronyms.rs
index 48bb9e54b12..9b7c2f28e1c 100644
--- a/tests/ui/upper_case_acronyms.rs
+++ b/tests/ui/upper_case_acronyms.rs
@@ -38,4 +38,13 @@ enum ParseErrorPrivate<T> {
     Parse(T, String),
 }
 
+// do lint here
+struct JSON;
+
+// do lint here
+enum YAML {
+    Num(u32),
+    Str(String),
+}
+
 fn main() {}
diff --git a/tests/ui/upper_case_acronyms.stderr b/tests/ui/upper_case_acronyms.stderr
index 250b196a99e..74082ec16dd 100644
--- a/tests/ui/upper_case_acronyms.stderr
+++ b/tests/ui/upper_case_acronyms.stderr
@@ -54,5 +54,17 @@ error: name `WASD` contains a capitalized acronym
 LL |     WASD(u8),
    |     ^^^^ help: consider making the acronym lowercase, except the initial letter: `Wasd`
 
-error: aborting due to 9 previous errors
+error: name `JSON` contains a capitalized acronym
+  --> $DIR/upper_case_acronyms.rs:42:8
+   |
+LL | struct JSON;
+   |        ^^^^ help: consider making the acronym lowercase, except the initial letter: `Json`
+
+error: name `YAML` contains a capitalized acronym
+  --> $DIR/upper_case_acronyms.rs:45:6
+   |
+LL | enum YAML {
+   |      ^^^^ help: consider making the acronym lowercase, except the initial letter: `Yaml`
+
+error: aborting due to 11 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 7747032b774de25cb9e1cf672a9244f17eb234cb Mon Sep 17 00:00:00 2001
From: Elliot Bobrow <elliotgreybobrow@gmail.com>
Date: Sun, 2 Oct 2022 21:00:51 -0700
Subject: `suboptimal_flops` lint for multiply and subtract

---
 clippy_lints/src/floating_point_arithmetic.rs | 48 ++++++++++++++++++++-------
 tests/ui/floating_point_mul_add.fixed         |  2 ++
 tests/ui/floating_point_mul_add.rs            |  2 ++
 tests/ui/floating_point_mul_add.stderr        | 30 ++++++++++++-----
 tests/ui/floating_point_powi.fixed            |  2 ++
 tests/ui/floating_point_powi.rs               |  2 ++
 tests/ui/floating_point_powi.stderr           | 20 ++++++++---
 7 files changed, 81 insertions(+), 25 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/floating_point_arithmetic.rs b/clippy_lints/src/floating_point_arithmetic.rs
index e71afec12a7..0ed30196475 100644
--- a/clippy_lints/src/floating_point_arithmetic.rs
+++ b/clippy_lints/src/floating_point_arithmetic.rs
@@ -311,7 +311,8 @@ fn check_powi(cx: &LateContext<'_>, expr: &Expr<'_>, receiver: &Expr<'_>, args:
 
                 if let ExprKind::Binary(
                     Spanned {
-                        node: BinOpKind::Add, ..
+                        node: op @ (BinOpKind::Add | BinOpKind::Sub),
+                        ..
                     },
                     lhs,
                     rhs,
@@ -319,6 +320,16 @@ fn check_powi(cx: &LateContext<'_>, expr: &Expr<'_>, receiver: &Expr<'_>, args:
                 {
                     let other_addend = if lhs.hir_id == expr.hir_id { rhs } else { lhs };
 
+                    // Negate expr if original code has subtraction and expr is on the right side
+                    let maybe_neg_sugg = |expr, hir_id| {
+                        let sugg = Sugg::hir(cx, expr, "..");
+                        if matches!(op, BinOpKind::Sub) && hir_id == rhs.hir_id {
+                            format!("-{sugg}")
+                        } else {
+                            sugg.to_string()
+                        }
+                    };
+
                     span_lint_and_sugg(
                         cx,
                         SUBOPTIMAL_FLOPS,
@@ -328,8 +339,8 @@ fn check_powi(cx: &LateContext<'_>, expr: &Expr<'_>, receiver: &Expr<'_>, args:
                         format!(
                             "{}.mul_add({}, {})",
                             Sugg::hir(cx, receiver, "..").maybe_par(),
-                            Sugg::hir(cx, receiver, ".."),
-                            Sugg::hir(cx, other_addend, ".."),
+                            maybe_neg_sugg(receiver, expr.hir_id),
+                            maybe_neg_sugg(other_addend, other_addend.hir_id),
                         ),
                         Applicability::MachineApplicable,
                     );
@@ -443,7 +454,8 @@ fn is_float_mul_expr<'a>(cx: &LateContext<'_>, expr: &'a Expr<'a>) -> Option<(&'
 fn check_mul_add(cx: &LateContext<'_>, expr: &Expr<'_>) {
     if let ExprKind::Binary(
         Spanned {
-            node: BinOpKind::Add, ..
+            node: op @ (BinOpKind::Add | BinOpKind::Sub),
+            ..
         },
         lhs,
         rhs,
@@ -457,10 +469,27 @@ fn check_mul_add(cx: &LateContext<'_>, expr: &Expr<'_>) {
             }
         }
 
+        let maybe_neg_sugg = |expr| {
+            let sugg = Sugg::hir(cx, expr, "..");
+            if let BinOpKind::Sub = op {
+                format!("-{sugg}")
+            } else {
+                sugg.to_string()
+            }
+        };
+
         let (recv, arg1, arg2) = if let Some((inner_lhs, inner_rhs)) = is_float_mul_expr(cx, lhs) {
-            (inner_lhs, inner_rhs, rhs)
+            (
+                inner_lhs,
+                Sugg::hir(cx, inner_rhs, "..").to_string(),
+                maybe_neg_sugg(rhs),
+            )
         } else if let Some((inner_lhs, inner_rhs)) = is_float_mul_expr(cx, rhs) {
-            (inner_lhs, inner_rhs, lhs)
+            (
+                inner_lhs,
+                maybe_neg_sugg(inner_rhs),
+                Sugg::hir(cx, lhs, "..").to_string(),
+            )
         } else {
             return;
         };
@@ -471,12 +500,7 @@ fn check_mul_add(cx: &LateContext<'_>, expr: &Expr<'_>) {
             expr.span,
             "multiply and add expressions can be calculated more efficiently and accurately",
             "consider using",
-            format!(
-                "{}.mul_add({}, {})",
-                prepare_receiver_sugg(cx, recv),
-                Sugg::hir(cx, arg1, ".."),
-                Sugg::hir(cx, arg2, ".."),
-            ),
+            format!("{}.mul_add({arg1}, {arg2})", prepare_receiver_sugg(cx, recv)),
             Applicability::MachineApplicable,
         );
     }
diff --git a/tests/ui/floating_point_mul_add.fixed b/tests/ui/floating_point_mul_add.fixed
index 169ec02f82b..d3e536ba350 100644
--- a/tests/ui/floating_point_mul_add.fixed
+++ b/tests/ui/floating_point_mul_add.fixed
@@ -19,7 +19,9 @@ fn main() {
     let d: f64 = 0.0001;
 
     let _ = a.mul_add(b, c);
+    let _ = a.mul_add(b, -c);
     let _ = a.mul_add(b, c);
+    let _ = a.mul_add(-b, c);
     let _ = 2.0f64.mul_add(4.0, a);
     let _ = 2.0f64.mul_add(4., a);
 
diff --git a/tests/ui/floating_point_mul_add.rs b/tests/ui/floating_point_mul_add.rs
index 5338d4fc2b7..5d4a9e35cfc 100644
--- a/tests/ui/floating_point_mul_add.rs
+++ b/tests/ui/floating_point_mul_add.rs
@@ -19,7 +19,9 @@ fn main() {
     let d: f64 = 0.0001;
 
     let _ = a * b + c;
+    let _ = a * b - c;
     let _ = c + a * b;
+    let _ = c - a * b;
     let _ = a + 2.0 * 4.0;
     let _ = a + 2. * 4.;
 
diff --git a/tests/ui/floating_point_mul_add.stderr b/tests/ui/floating_point_mul_add.stderr
index e637bbf90ca..a79ae94e8d4 100644
--- a/tests/ui/floating_point_mul_add.stderr
+++ b/tests/ui/floating_point_mul_add.stderr
@@ -9,56 +9,68 @@ LL |     let _ = a * b + c;
 error: multiply and add expressions can be calculated more efficiently and accurately
   --> $DIR/floating_point_mul_add.rs:22:13
    |
+LL |     let _ = a * b - c;
+   |             ^^^^^^^^^ help: consider using: `a.mul_add(b, -c)`
+
+error: multiply and add expressions can be calculated more efficiently and accurately
+  --> $DIR/floating_point_mul_add.rs:23:13
+   |
 LL |     let _ = c + a * b;
    |             ^^^^^^^^^ help: consider using: `a.mul_add(b, c)`
 
 error: multiply and add expressions can be calculated more efficiently and accurately
-  --> $DIR/floating_point_mul_add.rs:23:13
+  --> $DIR/floating_point_mul_add.rs:24:13
+   |
+LL |     let _ = c - a * b;
+   |             ^^^^^^^^^ help: consider using: `a.mul_add(-b, c)`
+
+error: multiply and add expressions can be calculated more efficiently and accurately
+  --> $DIR/floating_point_mul_add.rs:25:13
    |
 LL |     let _ = a + 2.0 * 4.0;
    |             ^^^^^^^^^^^^^ help: consider using: `2.0f64.mul_add(4.0, a)`
 
 error: multiply and add expressions can be calculated more efficiently and accurately
-  --> $DIR/floating_point_mul_add.rs:24:13
+  --> $DIR/floating_point_mul_add.rs:26:13
    |
 LL |     let _ = a + 2. * 4.;
    |             ^^^^^^^^^^^ help: consider using: `2.0f64.mul_add(4., a)`
 
 error: multiply and add expressions can be calculated more efficiently and accurately
-  --> $DIR/floating_point_mul_add.rs:26:13
+  --> $DIR/floating_point_mul_add.rs:28:13
    |
 LL |     let _ = (a * b) + c;
    |             ^^^^^^^^^^^ help: consider using: `a.mul_add(b, c)`
 
 error: multiply and add expressions can be calculated more efficiently and accurately
-  --> $DIR/floating_point_mul_add.rs:27:13
+  --> $DIR/floating_point_mul_add.rs:29:13
    |
 LL |     let _ = c + (a * b);
    |             ^^^^^^^^^^^ help: consider using: `a.mul_add(b, c)`
 
 error: multiply and add expressions can be calculated more efficiently and accurately
-  --> $DIR/floating_point_mul_add.rs:28:13
+  --> $DIR/floating_point_mul_add.rs:30:13
    |
 LL |     let _ = a * b * c + d;
    |             ^^^^^^^^^^^^^ help: consider using: `(a * b).mul_add(c, d)`
 
 error: multiply and add expressions can be calculated more efficiently and accurately
-  --> $DIR/floating_point_mul_add.rs:30:13
+  --> $DIR/floating_point_mul_add.rs:32:13
    |
 LL |     let _ = a.mul_add(b, c) * a.mul_add(b, c) + a.mul_add(b, c) + c;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `a.mul_add(b, c).mul_add(a.mul_add(b, c), a.mul_add(b, c))`
 
 error: multiply and add expressions can be calculated more efficiently and accurately
-  --> $DIR/floating_point_mul_add.rs:31:13
+  --> $DIR/floating_point_mul_add.rs:33:13
    |
 LL |     let _ = 1234.567_f64 * 45.67834_f64 + 0.0004_f64;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `1234.567_f64.mul_add(45.67834_f64, 0.0004_f64)`
 
 error: multiply and add expressions can be calculated more efficiently and accurately
-  --> $DIR/floating_point_mul_add.rs:33:13
+  --> $DIR/floating_point_mul_add.rs:35:13
    |
 LL |     let _ = (a * a + b).sqrt();
    |             ^^^^^^^^^^^ help: consider using: `a.mul_add(a, b)`
 
-error: aborting due to 10 previous errors
+error: aborting due to 12 previous errors
 
diff --git a/tests/ui/floating_point_powi.fixed b/tests/ui/floating_point_powi.fixed
index 5758db7c6c8..cc337038888 100644
--- a/tests/ui/floating_point_powi.fixed
+++ b/tests/ui/floating_point_powi.fixed
@@ -7,7 +7,9 @@ fn main() {
 
     let y = 4f32;
     let _ = x.mul_add(x, y);
+    let _ = x.mul_add(x, -y);
     let _ = y.mul_add(y, x);
+    let _ = y.mul_add(-y, x);
     let _ = (y as f32).mul_add(y as f32, x);
     let _ = x.mul_add(x, y).sqrt();
     let _ = y.mul_add(y, x).sqrt();
diff --git a/tests/ui/floating_point_powi.rs b/tests/ui/floating_point_powi.rs
index 5926bf1b000..5950902178c 100644
--- a/tests/ui/floating_point_powi.rs
+++ b/tests/ui/floating_point_powi.rs
@@ -7,7 +7,9 @@ fn main() {
 
     let y = 4f32;
     let _ = x.powi(2) + y;
+    let _ = x.powi(2) - y;
     let _ = x + y.powi(2);
+    let _ = x - y.powi(2);
     let _ = x + (y as f32).powi(2);
     let _ = (x.powi(2) + y).sqrt();
     let _ = (x + y.powi(2)).sqrt();
diff --git a/tests/ui/floating_point_powi.stderr b/tests/ui/floating_point_powi.stderr
index a3c74544212..643b70739cd 100644
--- a/tests/ui/floating_point_powi.stderr
+++ b/tests/ui/floating_point_powi.stderr
@@ -9,26 +9,38 @@ LL |     let _ = x.powi(2) + y;
 error: multiply and add expressions can be calculated more efficiently and accurately
   --> $DIR/floating_point_powi.rs:10:13
    |
+LL |     let _ = x.powi(2) - y;
+   |             ^^^^^^^^^^^^^ help: consider using: `x.mul_add(x, -y)`
+
+error: multiply and add expressions can be calculated more efficiently and accurately
+  --> $DIR/floating_point_powi.rs:11:13
+   |
 LL |     let _ = x + y.powi(2);
    |             ^^^^^^^^^^^^^ help: consider using: `y.mul_add(y, x)`
 
 error: multiply and add expressions can be calculated more efficiently and accurately
-  --> $DIR/floating_point_powi.rs:11:13
+  --> $DIR/floating_point_powi.rs:12:13
+   |
+LL |     let _ = x - y.powi(2);
+   |             ^^^^^^^^^^^^^ help: consider using: `y.mul_add(-y, x)`
+
+error: multiply and add expressions can be calculated more efficiently and accurately
+  --> $DIR/floating_point_powi.rs:13:13
    |
 LL |     let _ = x + (y as f32).powi(2);
    |             ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(y as f32).mul_add(y as f32, x)`
 
 error: multiply and add expressions can be calculated more efficiently and accurately
-  --> $DIR/floating_point_powi.rs:12:13
+  --> $DIR/floating_point_powi.rs:14:13
    |
 LL |     let _ = (x.powi(2) + y).sqrt();
    |             ^^^^^^^^^^^^^^^ help: consider using: `x.mul_add(x, y)`
 
 error: multiply and add expressions can be calculated more efficiently and accurately
-  --> $DIR/floating_point_powi.rs:13:13
+  --> $DIR/floating_point_powi.rs:15:13
    |
 LL |     let _ = (x + y.powi(2)).sqrt();
    |             ^^^^^^^^^^^^^^^ help: consider using: `y.mul_add(y, x)`
 
-error: aborting due to 5 previous errors
+error: aborting due to 7 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From f1c831ad176b853d074563acda9c58566233e123 Mon Sep 17 00:00:00 2001
From: royrustdev <royrustdev@gmail.com>
Date: Wed, 28 Sep 2022 19:47:13 +0530
Subject: add `implicit_saturating_add` lint

---
 CHANGELOG.md                                |   1 +
 clippy_lints/src/implicit_saturating_add.rs | 114 ++++++++++++++++
 clippy_lints/src/lib.register_all.rs        |   1 +
 clippy_lints/src/lib.register_lints.rs      |   1 +
 clippy_lints/src/lib.register_style.rs      |   1 +
 clippy_lints/src/lib.rs                     |   2 +
 src/docs.rs                                 |   1 +
 src/docs/implicit_saturating_add.txt        |  20 +++
 tests/ui/implicit_saturating_add.fixed      | 106 +++++++++++++++
 tests/ui/implicit_saturating_add.rs         | 154 ++++++++++++++++++++++
 tests/ui/implicit_saturating_add.stderr     | 197 ++++++++++++++++++++++++++++
 11 files changed, 598 insertions(+)
 create mode 100644 clippy_lints/src/implicit_saturating_add.rs
 create mode 100644 src/docs/implicit_saturating_add.txt
 create mode 100644 tests/ui/implicit_saturating_add.fixed
 create mode 100644 tests/ui/implicit_saturating_add.rs
 create mode 100644 tests/ui/implicit_saturating_add.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9f12a673596..bfeb009727b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3917,6 +3917,7 @@ Released 2018-09-13
 [`implicit_clone`]: https://rust-lang.github.io/rust-clippy/master/index.html#implicit_clone
 [`implicit_hasher`]: https://rust-lang.github.io/rust-clippy/master/index.html#implicit_hasher
 [`implicit_return`]: https://rust-lang.github.io/rust-clippy/master/index.html#implicit_return
+[`implicit_saturating_add`]: https://rust-lang.github.io/rust-clippy/master/index.html#implicit_saturating_add
 [`implicit_saturating_sub`]: https://rust-lang.github.io/rust-clippy/master/index.html#implicit_saturating_sub
 [`imprecise_flops`]: https://rust-lang.github.io/rust-clippy/master/index.html#imprecise_flops
 [`inconsistent_digit_grouping`]: https://rust-lang.github.io/rust-clippy/master/index.html#inconsistent_digit_grouping
diff --git a/clippy_lints/src/implicit_saturating_add.rs b/clippy_lints/src/implicit_saturating_add.rs
new file mode 100644
index 00000000000..bf1351829c6
--- /dev/null
+++ b/clippy_lints/src/implicit_saturating_add.rs
@@ -0,0 +1,114 @@
+use clippy_utils::consts::{constant, Constant};
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::get_parent_expr;
+use clippy_utils::source::snippet_with_applicability;
+use if_chain::if_chain;
+use rustc_ast::ast::{LitIntType, LitKind};
+use rustc_errors::Applicability;
+use rustc_hir::{BinOpKind, Block, Expr, ExprKind, Stmt, StmtKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::{Int, IntTy, Ty, Uint, UintTy};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for implicit saturating addition.
+    ///
+    /// ### Why is this bad?
+    /// The built-in function is more readable and may be faster.
+    ///
+    /// ### Example
+    /// ```rust
+    ///let mut u:u32 = 7000;
+    ///
+    /// if u != u32::MAX {
+    ///     u += 1;
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    ///let mut u:u32 = 7000;
+    ///
+    /// u = u.saturating_add(1);
+    /// ```
+    #[clippy::version = "1.65.0"]
+    pub IMPLICIT_SATURATING_ADD,
+    style,
+    "Perform saturating addition instead of implicitly checking max bound of data type"
+}
+declare_lint_pass!(ImplicitSaturatingAdd => [IMPLICIT_SATURATING_ADD]);
+
+impl<'tcx> LateLintPass<'tcx> for ImplicitSaturatingAdd {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
+        if_chain! {
+            if let ExprKind::If(cond, then, None) = expr.kind;
+            if let ExprKind::DropTemps(expr1) = cond.kind;
+            if let Some((c, op_node, l)) = get_const(cx, expr1);
+            if let BinOpKind::Ne | BinOpKind::Lt = op_node;
+            if let ExprKind::Block(block, None) = then.kind;
+            if let Block {
+                stmts:
+                    [Stmt
+                        { kind: StmtKind::Expr(ex) | StmtKind::Semi(ex), .. }],
+                        expr: None, ..} |
+                        Block { stmts: [], expr: Some(ex), ..} = block;
+            if let ExprKind::AssignOp(op1, target, value) = ex.kind;
+            let ty = cx.typeck_results().expr_ty(target);
+            if Some(c) == get_int_max(ty);
+            if clippy_utils::SpanlessEq::new(cx).eq_expr(l, target);
+            if BinOpKind::Add == op1.node;
+            if let ExprKind::Lit(ref lit) = value.kind;
+            if let LitKind::Int(1, LitIntType::Unsuffixed) = lit.node;
+            if block.expr.is_none();
+            then {
+                let mut app = Applicability::MachineApplicable;
+                let code = snippet_with_applicability(cx, target.span, "_", &mut app);
+                let sugg = if let Some(parent) = get_parent_expr(cx, expr) && let ExprKind::If(_cond, _then, Some(else_)) = parent.kind && else_.hir_id == expr.hir_id {format!("{{{code} = {code}.saturating_add(1); }}")} else {format!("{code} = {code}.saturating_add(1);")};
+                span_lint_and_sugg(cx, IMPLICIT_SATURATING_ADD, expr.span, "manual saturating add detected", "use instead", sugg, app);
+            }
+        }
+    }
+}
+
+fn get_int_max(ty: Ty<'_>) -> Option<u128> {
+    match ty.peel_refs().kind() {
+        Int(IntTy::I8) => i8::max_value().try_into().ok(),
+        Int(IntTy::I16) => i16::max_value().try_into().ok(),
+        Int(IntTy::I32) => i32::max_value().try_into().ok(),
+        Int(IntTy::I64) => i64::max_value().try_into().ok(),
+        Int(IntTy::I128) => i128::max_value().try_into().ok(),
+        Int(IntTy::Isize) => isize::max_value().try_into().ok(),
+        Uint(UintTy::U8) => u8::max_value().try_into().ok(),
+        Uint(UintTy::U16) => u16::max_value().try_into().ok(),
+        Uint(UintTy::U32) => u32::max_value().try_into().ok(),
+        Uint(UintTy::U64) => u64::max_value().try_into().ok(),
+        Uint(UintTy::U128) => Some(u128::max_value()),
+        Uint(UintTy::Usize) => usize::max_value().try_into().ok(),
+        _ => None,
+    }
+}
+
+fn get_const<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>) -> Option<(u128, BinOpKind, &'tcx Expr<'tcx>)> {
+    if let ExprKind::Binary(op, l, r) = expr.kind {
+        let tr = cx.typeck_results();
+        if let Some((Constant::Int(c), _)) = constant(cx, tr, r) {
+            return Some((c, op.node, l));
+        };
+        if let Some((Constant::Int(c), _)) = constant(cx, tr, l) {
+            return Some((c, invert_op(op.node)?, r));
+        }
+    }
+    None
+}
+
+fn invert_op(op: BinOpKind) -> Option<BinOpKind> {
+    use rustc_hir::BinOpKind::{Ge, Gt, Le, Lt, Ne};
+    match op {
+        Lt => Some(Gt),
+        Le => Some(Ge),
+        Ne => Some(Ne),
+        Ge => Some(Le),
+        Gt => Some(Lt),
+        _ => None,
+    }
+}
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 9ad2a88eb26..642d7070fb6 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -85,6 +85,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(functions::RESULT_UNIT_ERR),
     LintId::of(functions::TOO_MANY_ARGUMENTS),
     LintId::of(if_let_mutex::IF_LET_MUTEX),
+    LintId::of(implicit_saturating_add::IMPLICIT_SATURATING_ADD),
     LintId::of(indexing_slicing::OUT_OF_BOUNDS_INDEXING),
     LintId::of(infinite_iter::INFINITE_ITER),
     LintId::of(inherent_to_string::INHERENT_TO_STRING),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 307ec40f40b..08eb6c2b39b 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -184,6 +184,7 @@ store.register_lints(&[
     if_then_some_else_none::IF_THEN_SOME_ELSE_NONE,
     implicit_hasher::IMPLICIT_HASHER,
     implicit_return::IMPLICIT_RETURN,
+    implicit_saturating_add::IMPLICIT_SATURATING_ADD,
     implicit_saturating_sub::IMPLICIT_SATURATING_SUB,
     inconsistent_struct_constructor::INCONSISTENT_STRUCT_CONSTRUCTOR,
     index_refutable_slice::INDEX_REFUTABLE_SLICE,
diff --git a/clippy_lints/src/lib.register_style.rs b/clippy_lints/src/lib.register_style.rs
index ab7c4034b0e..6d5483bc701 100644
--- a/clippy_lints/src/lib.register_style.rs
+++ b/clippy_lints/src/lib.register_style.rs
@@ -29,6 +29,7 @@ store.register_group(true, "clippy::style", Some("clippy_style"), vec![
     LintId::of(functions::DOUBLE_MUST_USE),
     LintId::of(functions::MUST_USE_UNIT),
     LintId::of(functions::RESULT_UNIT_ERR),
+    LintId::of(implicit_saturating_add::IMPLICIT_SATURATING_ADD),
     LintId::of(inherent_to_string::INHERENT_TO_STRING),
     LintId::of(init_numbered_fields::INIT_NUMBERED_FIELDS),
     LintId::of(len_zero::COMPARISON_TO_EMPTY),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 3b78e492baa..e5d26ac22a7 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -238,6 +238,7 @@ mod if_not_else;
 mod if_then_some_else_none;
 mod implicit_hasher;
 mod implicit_return;
+mod implicit_saturating_add;
 mod implicit_saturating_sub;
 mod inconsistent_struct_constructor;
 mod index_refutable_slice;
@@ -904,6 +905,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_early_pass(|| Box::new(multi_assignments::MultiAssignments));
     store.register_late_pass(|_| Box::new(bool_to_int_with_if::BoolToIntWithIf));
     store.register_late_pass(|_| Box::new(box_default::BoxDefault));
+    store.register_late_pass(|_| Box::new(implicit_saturating_add::ImplicitSaturatingAdd));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/src/docs.rs b/src/docs.rs
index 39540e4b048..1b727e1a100 100644
--- a/src/docs.rs
+++ b/src/docs.rs
@@ -191,6 +191,7 @@ docs! {
     "implicit_clone",
     "implicit_hasher",
     "implicit_return",
+    "implicit_saturating_add",
     "implicit_saturating_sub",
     "imprecise_flops",
     "inconsistent_digit_grouping",
diff --git a/src/docs/implicit_saturating_add.txt b/src/docs/implicit_saturating_add.txt
new file mode 100644
index 00000000000..5883a5363e2
--- /dev/null
+++ b/src/docs/implicit_saturating_add.txt
@@ -0,0 +1,20 @@
+### What it does
+Checks for implicit saturating addition.
+
+### Why is this bad?
+The built-in function is more readable and may be faster.
+
+### Example
+```
+let mut u:u32 = 7000;
+
+if u != u32::MAX {
+    u += 1;
+}
+```
+Use instead:
+```
+let mut u:u32 = 7000;
+
+u = u.saturating_add(1);
+```
\ No newline at end of file
diff --git a/tests/ui/implicit_saturating_add.fixed b/tests/ui/implicit_saturating_add.fixed
new file mode 100644
index 00000000000..7d363d59a6f
--- /dev/null
+++ b/tests/ui/implicit_saturating_add.fixed
@@ -0,0 +1,106 @@
+// run-rustfix
+
+#![allow(unused)]
+#![warn(clippy::implicit_saturating_add)]
+
+fn main() {
+    let mut u_8: u8 = 255;
+    let mut u_16: u16 = 500;
+    let mut u_32: u32 = 7000;
+    let mut u_64: u64 = 7000;
+    let mut i_8: i8 = 30;
+    let mut i_16: i16 = 500;
+    let mut i_32: i32 = 7000;
+    let mut i_64: i64 = 7000;
+
+    if i_8 < 42 {
+        i_8 += 1;
+    }
+    if i_8 != 42 {
+        i_8 += 1;
+    }
+
+    u_8 = u_8.saturating_add(1);
+
+    u_8 = u_8.saturating_add(1);
+
+    if u_8 < 15 {
+        u_8 += 1;
+    }
+
+    u_16 = u_16.saturating_add(1);
+
+    u_16 = u_16.saturating_add(1);
+
+    u_16 = u_16.saturating_add(1);
+
+    u_32 = u_32.saturating_add(1);
+
+    u_32 = u_32.saturating_add(1);
+
+    u_32 = u_32.saturating_add(1);
+
+    u_64 = u_64.saturating_add(1);
+
+    u_64 = u_64.saturating_add(1);
+
+    u_64 = u_64.saturating_add(1);
+
+    i_8 = i_8.saturating_add(1);
+
+    i_8 = i_8.saturating_add(1);
+
+    i_8 = i_8.saturating_add(1);
+
+    i_16 = i_16.saturating_add(1);
+
+    i_16 = i_16.saturating_add(1);
+
+    i_16 = i_16.saturating_add(1);
+
+    i_32 = i_32.saturating_add(1);
+
+    i_32 = i_32.saturating_add(1);
+
+    i_32 = i_32.saturating_add(1);
+
+    i_64 = i_64.saturating_add(1);
+
+    i_64 = i_64.saturating_add(1);
+
+    i_64 = i_64.saturating_add(1);
+
+    if i_64 < 42 {
+        i_64 += 1;
+    }
+
+    if 42 > i_64 {
+        i_64 += 1;
+    }
+
+    let a = 12;
+    let mut b = 8;
+
+    if a < u8::MAX {
+        b += 1;
+    }
+
+    if u8::MAX > a {
+        b += 1;
+    }
+
+    if u_32 < u32::MAX {
+        u_32 += 1;
+    } else {
+        println!("don't lint this");
+    }
+
+    if u_32 < u32::MAX {
+        println!("don't lint this");
+        u_32 += 1;
+    }
+
+    if u_32 < 42 {
+        println!("brace yourself!");
+    } else {u_32 = u_32.saturating_add(1); }
+}
diff --git a/tests/ui/implicit_saturating_add.rs b/tests/ui/implicit_saturating_add.rs
new file mode 100644
index 00000000000..31a5916277f
--- /dev/null
+++ b/tests/ui/implicit_saturating_add.rs
@@ -0,0 +1,154 @@
+// run-rustfix
+
+#![allow(unused)]
+#![warn(clippy::implicit_saturating_add)]
+
+fn main() {
+    let mut u_8: u8 = 255;
+    let mut u_16: u16 = 500;
+    let mut u_32: u32 = 7000;
+    let mut u_64: u64 = 7000;
+    let mut i_8: i8 = 30;
+    let mut i_16: i16 = 500;
+    let mut i_32: i32 = 7000;
+    let mut i_64: i64 = 7000;
+
+    if i_8 < 42 {
+        i_8 += 1;
+    }
+    if i_8 != 42 {
+        i_8 += 1;
+    }
+
+    if u_8 != u8::MAX {
+        u_8 += 1;
+    }
+
+    if u_8 < u8::MAX {
+        u_8 += 1;
+    }
+
+    if u_8 < 15 {
+        u_8 += 1;
+    }
+
+    if u_16 != u16::MAX {
+        u_16 += 1;
+    }
+
+    if u_16 < u16::MAX {
+        u_16 += 1;
+    }
+
+    if u16::MAX > u_16 {
+        u_16 += 1;
+    }
+
+    if u_32 != u32::MAX {
+        u_32 += 1;
+    }
+
+    if u_32 < u32::MAX {
+        u_32 += 1;
+    }
+
+    if u32::MAX > u_32 {
+        u_32 += 1;
+    }
+
+    if u_64 != u64::MAX {
+        u_64 += 1;
+    }
+
+    if u_64 < u64::MAX {
+        u_64 += 1;
+    }
+
+    if u64::MAX > u_64 {
+        u_64 += 1;
+    }
+
+    if i_8 != i8::MAX {
+        i_8 += 1;
+    }
+
+    if i_8 < i8::MAX {
+        i_8 += 1;
+    }
+
+    if i8::MAX > i_8 {
+        i_8 += 1;
+    }
+
+    if i_16 != i16::MAX {
+        i_16 += 1;
+    }
+
+    if i_16 < i16::MAX {
+        i_16 += 1;
+    }
+
+    if i16::MAX > i_16 {
+        i_16 += 1;
+    }
+
+    if i_32 != i32::MAX {
+        i_32 += 1;
+    }
+
+    if i_32 < i32::MAX {
+        i_32 += 1;
+    }
+
+    if i32::MAX > i_32 {
+        i_32 += 1;
+    }
+
+    if i_64 != i64::MAX {
+        i_64 += 1;
+    }
+
+    if i_64 < i64::MAX {
+        i_64 += 1;
+    }
+
+    if i64::MAX > i_64 {
+        i_64 += 1;
+    }
+
+    if i_64 < 42 {
+        i_64 += 1;
+    }
+
+    if 42 > i_64 {
+        i_64 += 1;
+    }
+
+    let a = 12;
+    let mut b = 8;
+
+    if a < u8::MAX {
+        b += 1;
+    }
+
+    if u8::MAX > a {
+        b += 1;
+    }
+
+    if u_32 < u32::MAX {
+        u_32 += 1;
+    } else {
+        println!("don't lint this");
+    }
+
+    if u_32 < u32::MAX {
+        println!("don't lint this");
+        u_32 += 1;
+    }
+
+    if u_32 < 42 {
+        println!("brace yourself!");
+    } else if u_32 < u32::MAX {
+        u_32 += 1;
+    }
+}
diff --git a/tests/ui/implicit_saturating_add.stderr b/tests/ui/implicit_saturating_add.stderr
new file mode 100644
index 00000000000..42ae1b48885
--- /dev/null
+++ b/tests/ui/implicit_saturating_add.stderr
@@ -0,0 +1,197 @@
+error: manual saturating add detected
+  --> $DIR/implicit_saturating_add.rs:23:5
+   |
+LL | /     if u_8 != u8::MAX {
+LL | |         u_8 += 1;
+LL | |     }
+   | |_____^ help: use instead: `u_8 = u_8.saturating_add(1);`
+   |
+   = note: `-D clippy::implicit-saturating-add` implied by `-D warnings`
+
+error: manual saturating add detected
+  --> $DIR/implicit_saturating_add.rs:27:5
+   |
+LL | /     if u_8 < u8::MAX {
+LL | |         u_8 += 1;
+LL | |     }
+   | |_____^ help: use instead: `u_8 = u_8.saturating_add(1);`
+
+error: manual saturating add detected
+  --> $DIR/implicit_saturating_add.rs:35:5
+   |
+LL | /     if u_16 != u16::MAX {
+LL | |         u_16 += 1;
+LL | |     }
+   | |_____^ help: use instead: `u_16 = u_16.saturating_add(1);`
+
+error: manual saturating add detected
+  --> $DIR/implicit_saturating_add.rs:39:5
+   |
+LL | /     if u_16 < u16::MAX {
+LL | |         u_16 += 1;
+LL | |     }
+   | |_____^ help: use instead: `u_16 = u_16.saturating_add(1);`
+
+error: manual saturating add detected
+  --> $DIR/implicit_saturating_add.rs:43:5
+   |
+LL | /     if u16::MAX > u_16 {
+LL | |         u_16 += 1;
+LL | |     }
+   | |_____^ help: use instead: `u_16 = u_16.saturating_add(1);`
+
+error: manual saturating add detected
+  --> $DIR/implicit_saturating_add.rs:47:5
+   |
+LL | /     if u_32 != u32::MAX {
+LL | |         u_32 += 1;
+LL | |     }
+   | |_____^ help: use instead: `u_32 = u_32.saturating_add(1);`
+
+error: manual saturating add detected
+  --> $DIR/implicit_saturating_add.rs:51:5
+   |
+LL | /     if u_32 < u32::MAX {
+LL | |         u_32 += 1;
+LL | |     }
+   | |_____^ help: use instead: `u_32 = u_32.saturating_add(1);`
+
+error: manual saturating add detected
+  --> $DIR/implicit_saturating_add.rs:55:5
+   |
+LL | /     if u32::MAX > u_32 {
+LL | |         u_32 += 1;
+LL | |     }
+   | |_____^ help: use instead: `u_32 = u_32.saturating_add(1);`
+
+error: manual saturating add detected
+  --> $DIR/implicit_saturating_add.rs:59:5
+   |
+LL | /     if u_64 != u64::MAX {
+LL | |         u_64 += 1;
+LL | |     }
+   | |_____^ help: use instead: `u_64 = u_64.saturating_add(1);`
+
+error: manual saturating add detected
+  --> $DIR/implicit_saturating_add.rs:63:5
+   |
+LL | /     if u_64 < u64::MAX {
+LL | |         u_64 += 1;
+LL | |     }
+   | |_____^ help: use instead: `u_64 = u_64.saturating_add(1);`
+
+error: manual saturating add detected
+  --> $DIR/implicit_saturating_add.rs:67:5
+   |
+LL | /     if u64::MAX > u_64 {
+LL | |         u_64 += 1;
+LL | |     }
+   | |_____^ help: use instead: `u_64 = u_64.saturating_add(1);`
+
+error: manual saturating add detected
+  --> $DIR/implicit_saturating_add.rs:71:5
+   |
+LL | /     if i_8 != i8::MAX {
+LL | |         i_8 += 1;
+LL | |     }
+   | |_____^ help: use instead: `i_8 = i_8.saturating_add(1);`
+
+error: manual saturating add detected
+  --> $DIR/implicit_saturating_add.rs:75:5
+   |
+LL | /     if i_8 < i8::MAX {
+LL | |         i_8 += 1;
+LL | |     }
+   | |_____^ help: use instead: `i_8 = i_8.saturating_add(1);`
+
+error: manual saturating add detected
+  --> $DIR/implicit_saturating_add.rs:79:5
+   |
+LL | /     if i8::MAX > i_8 {
+LL | |         i_8 += 1;
+LL | |     }
+   | |_____^ help: use instead: `i_8 = i_8.saturating_add(1);`
+
+error: manual saturating add detected
+  --> $DIR/implicit_saturating_add.rs:83:5
+   |
+LL | /     if i_16 != i16::MAX {
+LL | |         i_16 += 1;
+LL | |     }
+   | |_____^ help: use instead: `i_16 = i_16.saturating_add(1);`
+
+error: manual saturating add detected
+  --> $DIR/implicit_saturating_add.rs:87:5
+   |
+LL | /     if i_16 < i16::MAX {
+LL | |         i_16 += 1;
+LL | |     }
+   | |_____^ help: use instead: `i_16 = i_16.saturating_add(1);`
+
+error: manual saturating add detected
+  --> $DIR/implicit_saturating_add.rs:91:5
+   |
+LL | /     if i16::MAX > i_16 {
+LL | |         i_16 += 1;
+LL | |     }
+   | |_____^ help: use instead: `i_16 = i_16.saturating_add(1);`
+
+error: manual saturating add detected
+  --> $DIR/implicit_saturating_add.rs:95:5
+   |
+LL | /     if i_32 != i32::MAX {
+LL | |         i_32 += 1;
+LL | |     }
+   | |_____^ help: use instead: `i_32 = i_32.saturating_add(1);`
+
+error: manual saturating add detected
+  --> $DIR/implicit_saturating_add.rs:99:5
+   |
+LL | /     if i_32 < i32::MAX {
+LL | |         i_32 += 1;
+LL | |     }
+   | |_____^ help: use instead: `i_32 = i_32.saturating_add(1);`
+
+error: manual saturating add detected
+  --> $DIR/implicit_saturating_add.rs:103:5
+   |
+LL | /     if i32::MAX > i_32 {
+LL | |         i_32 += 1;
+LL | |     }
+   | |_____^ help: use instead: `i_32 = i_32.saturating_add(1);`
+
+error: manual saturating add detected
+  --> $DIR/implicit_saturating_add.rs:107:5
+   |
+LL | /     if i_64 != i64::MAX {
+LL | |         i_64 += 1;
+LL | |     }
+   | |_____^ help: use instead: `i_64 = i_64.saturating_add(1);`
+
+error: manual saturating add detected
+  --> $DIR/implicit_saturating_add.rs:111:5
+   |
+LL | /     if i_64 < i64::MAX {
+LL | |         i_64 += 1;
+LL | |     }
+   | |_____^ help: use instead: `i_64 = i_64.saturating_add(1);`
+
+error: manual saturating add detected
+  --> $DIR/implicit_saturating_add.rs:115:5
+   |
+LL | /     if i64::MAX > i_64 {
+LL | |         i_64 += 1;
+LL | |     }
+   | |_____^ help: use instead: `i_64 = i_64.saturating_add(1);`
+
+error: manual saturating add detected
+  --> $DIR/implicit_saturating_add.rs:151:12
+   |
+LL |       } else if u_32 < u32::MAX {
+   |  ____________^
+LL | |         u_32 += 1;
+LL | |     }
+   | |_____^ help: use instead: `{u_32 = u_32.saturating_add(1); }`
+
+error: aborting due to 24 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 99363fef657f399eca30b49df5f7b68d8b8a0ee8 Mon Sep 17 00:00:00 2001
From: Caio <c410.f3r@gmail.com>
Date: Mon, 3 Oct 2022 18:36:12 -0300
Subject: Address comments

---
 .../src/operators/arithmetic_side_effects.rs       | 24 ++++++++++------------
 tests/ui/arithmetic_side_effects.stderr            | 24 +++++++++++++++++++---
 2 files changed, 32 insertions(+), 16 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/operators/arithmetic_side_effects.rs b/clippy_lints/src/operators/arithmetic_side_effects.rs
index d871b72db8f..fc2a828bfc0 100644
--- a/clippy_lints/src/operators/arithmetic_side_effects.rs
+++ b/clippy_lints/src/operators/arithmetic_side_effects.rs
@@ -9,6 +9,7 @@ use rustc_ast as ast;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::Ty;
 use rustc_session::impl_lint_pass;
 use rustc_span::source_map::{Span, Spanned};
 
@@ -67,20 +68,14 @@ impl ArithmeticSideEffects {
     }
 
     /// Checks if the given `expr` has any of the inner `allowed` elements.
-    fn is_allowed_ty(&self, cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> bool {
-        self.allowed.contains(
-            cx.typeck_results()
-                .expr_ty(expr)
-                .to_string()
-                .split('<')
-                .next()
-                .unwrap_or_default(),
-        )
+    fn is_allowed_ty(&self, ty: Ty<'_>) -> bool {
+        self.allowed
+            .contains(ty.to_string().split('<').next().unwrap_or_default())
     }
 
     // For example, 8i32 or &i64::MAX.
-    fn is_integral<'expr, 'tcx>(cx: &LateContext<'tcx>, expr: &'expr hir::Expr<'tcx>) -> bool {
-        cx.typeck_results().expr_ty(expr).peel_refs().is_integral()
+    fn is_integral(ty: Ty<'_>) -> bool {
+        ty.peel_refs().is_integral()
     }
 
     // Common entry-point to avoid code duplication.
@@ -129,10 +124,13 @@ impl ArithmeticSideEffects {
         ) {
             return;
         };
-        if self.is_allowed_ty(cx, lhs) && self.is_allowed_ty(cx, rhs) {
+        let lhs_ty = cx.typeck_results().expr_ty(lhs);
+        let rhs_ty = cx.typeck_results().expr_ty(rhs);
+        let lhs_and_rhs_have_the_same_ty = lhs_ty == rhs_ty;
+        if lhs_and_rhs_have_the_same_ty && self.is_allowed_ty(lhs_ty) && self.is_allowed_ty(rhs_ty) {
             return;
         }
-        let has_valid_op = if Self::is_integral(cx, lhs) && Self::is_integral(cx, rhs) {
+        let has_valid_op = if Self::is_integral(lhs_ty) && Self::is_integral(rhs_ty) {
             match (Self::literal_integer(lhs), Self::literal_integer(rhs)) {
                 (None, None) => false,
                 (None, Some(local_expr)) => Self::has_valid_op(op, local_expr),
diff --git a/tests/ui/arithmetic_side_effects.stderr b/tests/ui/arithmetic_side_effects.stderr
index 7870c942e7d..8cabd05c2f9 100644
--- a/tests/ui/arithmetic_side_effects.stderr
+++ b/tests/ui/arithmetic_side_effects.stderr
@@ -1,10 +1,28 @@
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:78:13
+   |
+LL |     let _ = String::new() + "";
+   |             ^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::arithmetic-side-effects` implied by `-D warnings`
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:86:27
+   |
+LL |     let inferred_string = string + "";
+   |                           ^^^^^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:90:13
+   |
+LL |     let _ = inferred_string + "";
+   |             ^^^^^^^^^^^^^^^^^^^^
+
 error: arithmetic operation that can potentially result in unexpected side-effects
   --> $DIR/arithmetic_side_effects.rs:162:5
    |
 LL |     _n += 1;
    |     ^^^^^^^
-   |
-   = note: `-D clippy::arithmetic-side-effects` implied by `-D warnings`
 
 error: arithmetic operation that can potentially result in unexpected side-effects
   --> $DIR/arithmetic_side_effects.rs:163:5
@@ -312,5 +330,5 @@ error: arithmetic operation that can potentially result in unexpected side-effec
 LL |     _n = -&_n;
    |          ^^^^
 
-error: aborting due to 52 previous errors
+error: aborting due to 55 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 2a6a98f95be4d630bac368b0bbd622749e999eb3 Mon Sep 17 00:00:00 2001
From: Caio <c410.f3r@gmail.com>
Date: Mon, 3 Oct 2022 19:49:03 -0300
Subject: [arithmetic-side-effects] Do not ignore literal references

---
 .../src/operators/arithmetic_side_effects.rs       |  45 +++++---
 tests/ui/arithmetic_side_effects.rs                |   4 +-
 tests/ui/arithmetic_side_effects.stderr            | 124 ++++++++++++---------
 3 files changed, 103 insertions(+), 70 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/operators/arithmetic_side_effects.rs b/clippy_lints/src/operators/arithmetic_side_effects.rs
index 9ba9cc1c517..54cbcd35587 100644
--- a/clippy_lints/src/operators/arithmetic_side_effects.rs
+++ b/clippy_lints/src/operators/arithmetic_side_effects.rs
@@ -1,8 +1,3 @@
-#![allow(
-    // False positive
-    clippy::match_same_arms
-)]
-
 use super::ARITHMETIC_SIDE_EFFECTS;
 use clippy_utils::{consts::constant_simple, diagnostics::span_lint};
 use rustc_ast as ast;
@@ -14,12 +9,12 @@ use rustc_session::impl_lint_pass;
 use rustc_span::source_map::{Span, Spanned};
 
 const HARD_CODED_ALLOWED: &[&str] = &[
+    "&str",
     "f32",
     "f64",
     "std::num::Saturating",
     "std::num::Wrapping",
     "std::string::String",
-    "&str",
 ];
 
 #[derive(Debug)]
@@ -79,16 +74,13 @@ impl ArithmeticSideEffects {
         self.expr_span = Some(expr.span);
     }
 
-    /// * If `expr` is a literal integer like `1` or `i32::MAX`, returns itself.
-    /// * Is `expr` is a literal integer reference like `&199`, returns the literal integer without
-    ///   references.
-    /// * If `expr` is anything else, returns `None`.
-    fn literal_integer<'expr, 'tcx>(expr: &'expr hir::Expr<'tcx>) -> Option<&'expr hir::Expr<'tcx>> {
+    /// If `expr` does not match any variant of [LiteralIntegerTy], returns `None`.
+    fn literal_integer<'expr, 'tcx>(expr: &'expr hir::Expr<'tcx>) -> Option<LiteralIntegerTy<'expr, 'tcx>> {
         if matches!(expr.kind, hir::ExprKind::Lit(_)) {
-            return Some(expr);
+            return Some(LiteralIntegerTy::Value(expr));
         }
         if let hir::ExprKind::AddrOf(.., inn) = expr.kind && let hir::ExprKind::Lit(_) = inn.kind {
-            return Some(inn)
+            return Some(LiteralIntegerTy::Ref(inn));
         }
         None
     }
@@ -127,9 +119,10 @@ impl ArithmeticSideEffects {
         let has_valid_op = if Self::is_integral(lhs_ty) && Self::is_integral(rhs_ty) {
             match (Self::literal_integer(lhs), Self::literal_integer(rhs)) {
                 (None, None) => false,
-                (None, Some(local_expr)) => Self::has_valid_op(op, local_expr),
-                (Some(local_expr), None) => Self::has_valid_op(op, local_expr),
-                (Some(_), Some(_)) => true,
+                (None, Some(lit_int_ty)) => Self::has_valid_op(op, lit_int_ty.into()),
+                (Some(lit_int_ty), None) => Self::has_valid_op(op, lit_int_ty.into()),
+                (Some(LiteralIntegerTy::Value(_)), Some(LiteralIntegerTy::Value(_))) => true,
+                (Some(_), Some(_)) => false,
             }
         } else {
             false
@@ -186,3 +179,23 @@ impl<'tcx> LateLintPass<'tcx> for ArithmeticSideEffects {
         }
     }
 }
+
+/// Tells if an expression is a integer passed by value or by reference.
+///
+/// If [LiteralIntegerTy::Ref], then the contained value will be `hir::ExprKind::Lit` rather
+/// than `hirExprKind::Addr`.
+enum LiteralIntegerTy<'expr, 'tcx> {
+    /// For example, `&199`
+    Ref(&'expr hir::Expr<'tcx>),
+    /// For example, `1` or `i32::MAX`
+    Value(&'expr hir::Expr<'tcx>),
+}
+
+impl<'expr, 'tcx> From<LiteralIntegerTy<'expr, 'tcx>> for &'expr hir::Expr<'tcx> {
+    fn from(from: LiteralIntegerTy<'expr, 'tcx>) -> Self {
+        match from {
+            LiteralIntegerTy::Ref(elem) => elem,
+            LiteralIntegerTy::Value(elem) => elem,
+        }
+    }
+}
diff --git a/tests/ui/arithmetic_side_effects.rs b/tests/ui/arithmetic_side_effects.rs
index c9c0f8be653..b25e68f1306 100644
--- a/tests/ui/arithmetic_side_effects.rs
+++ b/tests/ui/arithmetic_side_effects.rs
@@ -148,7 +148,6 @@ pub fn non_overflowing_ops_or_ops_already_handled_by_the_compiler_should_not_tri
     _n = 1 * _n;
     _n = &1 * _n;
     _n = 23 + 85;
-    _n = &23 + &85;
 
     // Unary
     _n = -1;
@@ -187,6 +186,9 @@ pub fn runtime_ops() {
     _n = _n * &2;
     _n = 2 * _n;
     _n = &2 * _n;
+    _n = 23 + &85;
+    _n = &23 + 85;
+    _n = &23 + &85;
 
     // Custom
     let _ = Custom + 0;
diff --git a/tests/ui/arithmetic_side_effects.stderr b/tests/ui/arithmetic_side_effects.stderr
index 8cabd05c2f9..0f06e22bae9 100644
--- a/tests/ui/arithmetic_side_effects.stderr
+++ b/tests/ui/arithmetic_side_effects.stderr
@@ -19,316 +19,334 @@ LL |     let _ = inferred_string + "";
    |             ^^^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:162:5
+  --> $DIR/arithmetic_side_effects.rs:161:5
    |
 LL |     _n += 1;
    |     ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:163:5
+  --> $DIR/arithmetic_side_effects.rs:162:5
    |
 LL |     _n += &1;
    |     ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:164:5
+  --> $DIR/arithmetic_side_effects.rs:163:5
    |
 LL |     _n -= 1;
    |     ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:165:5
+  --> $DIR/arithmetic_side_effects.rs:164:5
    |
 LL |     _n -= &1;
    |     ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:166:5
+  --> $DIR/arithmetic_side_effects.rs:165:5
    |
 LL |     _n /= 0;
    |     ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:167:5
+  --> $DIR/arithmetic_side_effects.rs:166:5
    |
 LL |     _n /= &0;
    |     ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:168:5
+  --> $DIR/arithmetic_side_effects.rs:167:5
    |
 LL |     _n %= 0;
    |     ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:169:5
+  --> $DIR/arithmetic_side_effects.rs:168:5
    |
 LL |     _n %= &0;
    |     ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:170:5
+  --> $DIR/arithmetic_side_effects.rs:169:5
    |
 LL |     _n *= 2;
    |     ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:171:5
+  --> $DIR/arithmetic_side_effects.rs:170:5
    |
 LL |     _n *= &2;
    |     ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:174:10
+  --> $DIR/arithmetic_side_effects.rs:173:10
    |
 LL |     _n = _n + 1;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:175:10
+  --> $DIR/arithmetic_side_effects.rs:174:10
    |
 LL |     _n = _n + &1;
    |          ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:176:10
+  --> $DIR/arithmetic_side_effects.rs:175:10
    |
 LL |     _n = 1 + _n;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:177:10
+  --> $DIR/arithmetic_side_effects.rs:176:10
    |
 LL |     _n = &1 + _n;
    |          ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:178:10
+  --> $DIR/arithmetic_side_effects.rs:177:10
    |
 LL |     _n = _n - 1;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:179:10
+  --> $DIR/arithmetic_side_effects.rs:178:10
    |
 LL |     _n = _n - &1;
    |          ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:180:10
+  --> $DIR/arithmetic_side_effects.rs:179:10
    |
 LL |     _n = 1 - _n;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:181:10
+  --> $DIR/arithmetic_side_effects.rs:180:10
    |
 LL |     _n = &1 - _n;
    |          ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:182:10
+  --> $DIR/arithmetic_side_effects.rs:181:10
    |
 LL |     _n = _n / 0;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:183:10
+  --> $DIR/arithmetic_side_effects.rs:182:10
    |
 LL |     _n = _n / &0;
    |          ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:184:10
+  --> $DIR/arithmetic_side_effects.rs:183:10
    |
 LL |     _n = _n % 0;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:185:10
+  --> $DIR/arithmetic_side_effects.rs:184:10
    |
 LL |     _n = _n % &0;
    |          ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:186:10
+  --> $DIR/arithmetic_side_effects.rs:185:10
    |
 LL |     _n = _n * 2;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:187:10
+  --> $DIR/arithmetic_side_effects.rs:186:10
    |
 LL |     _n = _n * &2;
    |          ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:188:10
+  --> $DIR/arithmetic_side_effects.rs:187:10
    |
 LL |     _n = 2 * _n;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:189:10
+  --> $DIR/arithmetic_side_effects.rs:188:10
    |
 LL |     _n = &2 * _n;
    |          ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:192:13
+  --> $DIR/arithmetic_side_effects.rs:189:10
+   |
+LL |     _n = 23 + &85;
+   |          ^^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:190:10
+   |
+LL |     _n = &23 + 85;
+   |          ^^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:191:10
+   |
+LL |     _n = &23 + &85;
+   |          ^^^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:194:13
    |
 LL |     let _ = Custom + 0;
    |             ^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:193:13
+  --> $DIR/arithmetic_side_effects.rs:195:13
    |
 LL |     let _ = Custom + 1;
    |             ^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:194:13
+  --> $DIR/arithmetic_side_effects.rs:196:13
    |
 LL |     let _ = Custom + 2;
    |             ^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:195:13
+  --> $DIR/arithmetic_side_effects.rs:197:13
    |
 LL |     let _ = Custom + 0.0;
    |             ^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:196:13
+  --> $DIR/arithmetic_side_effects.rs:198:13
    |
 LL |     let _ = Custom + 1.0;
    |             ^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:197:13
+  --> $DIR/arithmetic_side_effects.rs:199:13
    |
 LL |     let _ = Custom + 2.0;
    |             ^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:198:13
+  --> $DIR/arithmetic_side_effects.rs:200:13
    |
 LL |     let _ = Custom - 0;
    |             ^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:199:13
+  --> $DIR/arithmetic_side_effects.rs:201:13
    |
 LL |     let _ = Custom - 1;
    |             ^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:200:13
+  --> $DIR/arithmetic_side_effects.rs:202:13
    |
 LL |     let _ = Custom - 2;
    |             ^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:201:13
+  --> $DIR/arithmetic_side_effects.rs:203:13
    |
 LL |     let _ = Custom - 0.0;
    |             ^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:202:13
+  --> $DIR/arithmetic_side_effects.rs:204:13
    |
 LL |     let _ = Custom - 1.0;
    |             ^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:203:13
+  --> $DIR/arithmetic_side_effects.rs:205:13
    |
 LL |     let _ = Custom - 2.0;
    |             ^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:204:13
+  --> $DIR/arithmetic_side_effects.rs:206:13
    |
 LL |     let _ = Custom / 0;
    |             ^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:205:13
+  --> $DIR/arithmetic_side_effects.rs:207:13
    |
 LL |     let _ = Custom / 1;
    |             ^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:206:13
+  --> $DIR/arithmetic_side_effects.rs:208:13
    |
 LL |     let _ = Custom / 2;
    |             ^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:207:13
+  --> $DIR/arithmetic_side_effects.rs:209:13
    |
 LL |     let _ = Custom / 0.0;
    |             ^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:208:13
+  --> $DIR/arithmetic_side_effects.rs:210:13
    |
 LL |     let _ = Custom / 1.0;
    |             ^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:209:13
+  --> $DIR/arithmetic_side_effects.rs:211:13
    |
 LL |     let _ = Custom / 2.0;
    |             ^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:210:13
+  --> $DIR/arithmetic_side_effects.rs:212:13
    |
 LL |     let _ = Custom * 0;
    |             ^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:211:13
+  --> $DIR/arithmetic_side_effects.rs:213:13
    |
 LL |     let _ = Custom * 1;
    |             ^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:212:13
+  --> $DIR/arithmetic_side_effects.rs:214:13
    |
 LL |     let _ = Custom * 2;
    |             ^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:213:13
+  --> $DIR/arithmetic_side_effects.rs:215:13
    |
 LL |     let _ = Custom * 0.0;
    |             ^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:214:13
+  --> $DIR/arithmetic_side_effects.rs:216:13
    |
 LL |     let _ = Custom * 1.0;
    |             ^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:215:13
+  --> $DIR/arithmetic_side_effects.rs:217:13
    |
 LL |     let _ = Custom * 2.0;
    |             ^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:218:10
+  --> $DIR/arithmetic_side_effects.rs:220:10
    |
 LL |     _n = -_n;
    |          ^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:219:10
+  --> $DIR/arithmetic_side_effects.rs:221:10
    |
 LL |     _n = -&_n;
    |          ^^^^
 
-error: aborting due to 55 previous errors
+error: aborting due to 58 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From a44914fcd32eb3c0c3ff65f10b8b062e0b11b6f5 Mon Sep 17 00:00:00 2001
From: Caio <c410.f3r@gmail.com>
Date: Mon, 3 Oct 2022 20:10:00 -0300
Subject: Dogfood

---
 .../src/operators/arithmetic_side_effects.rs        | 21 +++++++++------------
 1 file changed, 9 insertions(+), 12 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/operators/arithmetic_side_effects.rs b/clippy_lints/src/operators/arithmetic_side_effects.rs
index 54cbcd35587..8827daaa3ee 100644
--- a/clippy_lints/src/operators/arithmetic_side_effects.rs
+++ b/clippy_lints/src/operators/arithmetic_side_effects.rs
@@ -45,10 +45,10 @@ impl ArithmeticSideEffects {
             let ast::LitKind::Int(value, _) = lit.node
         {
             match (&op.node, value) {
-                (hir::BinOpKind::Add | hir::BinOpKind::Sub, 0) |
-                (hir::BinOpKind::Mul, 0 | 1) => true,
                 (hir::BinOpKind::Div | hir::BinOpKind::Rem, 0) => false,
-                (hir::BinOpKind::Div | hir::BinOpKind::Rem, _) => true,
+                (hir::BinOpKind::Add | hir::BinOpKind::Sub, 0)
+                    | (hir::BinOpKind::Div | hir::BinOpKind::Rem, _)
+                    | (hir::BinOpKind::Mul, 0 | 1) => true,
                 _ => false,
             }
         } else {
@@ -74,7 +74,7 @@ impl ArithmeticSideEffects {
         self.expr_span = Some(expr.span);
     }
 
-    /// If `expr` does not match any variant of [LiteralIntegerTy], returns `None`.
+    /// If `expr` does not match any variant of `LiteralIntegerTy`, returns `None`.
     fn literal_integer<'expr, 'tcx>(expr: &'expr hir::Expr<'tcx>) -> Option<LiteralIntegerTy<'expr, 'tcx>> {
         if matches!(expr.kind, hir::ExprKind::Lit(_)) {
             return Some(LiteralIntegerTy::Value(expr));
@@ -118,11 +118,9 @@ impl ArithmeticSideEffects {
         }
         let has_valid_op = if Self::is_integral(lhs_ty) && Self::is_integral(rhs_ty) {
             match (Self::literal_integer(lhs), Self::literal_integer(rhs)) {
-                (None, None) => false,
-                (None, Some(lit_int_ty)) => Self::has_valid_op(op, lit_int_ty.into()),
-                (Some(lit_int_ty), None) => Self::has_valid_op(op, lit_int_ty.into()),
+                (None, Some(lit_int_ty)) | (Some(lit_int_ty), None) => Self::has_valid_op(op, lit_int_ty.into()),
                 (Some(LiteralIntegerTy::Value(_)), Some(LiteralIntegerTy::Value(_))) => true,
-                (Some(_), Some(_)) => false,
+                (None, None) | (Some(_), Some(_)) => false,
             }
         } else {
             false
@@ -180,9 +178,9 @@ impl<'tcx> LateLintPass<'tcx> for ArithmeticSideEffects {
     }
 }
 
-/// Tells if an expression is a integer passed by value or by reference.
+/// Tells if an expression is a integer declared by value or by reference.
 ///
-/// If [LiteralIntegerTy::Ref], then the contained value will be `hir::ExprKind::Lit` rather
+/// If `LiteralIntegerTy::Ref`, then the contained value will be `hir::ExprKind::Lit` rather
 /// than `hirExprKind::Addr`.
 enum LiteralIntegerTy<'expr, 'tcx> {
     /// For example, `&199`
@@ -194,8 +192,7 @@ enum LiteralIntegerTy<'expr, 'tcx> {
 impl<'expr, 'tcx> From<LiteralIntegerTy<'expr, 'tcx>> for &'expr hir::Expr<'tcx> {
     fn from(from: LiteralIntegerTy<'expr, 'tcx>) -> Self {
         match from {
-            LiteralIntegerTy::Ref(elem) => elem,
-            LiteralIntegerTy::Value(elem) => elem,
+            LiteralIntegerTy::Ref(elem) | LiteralIntegerTy::Value(elem) => elem,
         }
     }
 }
-- 
cgit 1.4.1-3-g733a5


From 14f9f2b69d5306936296ce7a2e0db7809fd6a113 Mon Sep 17 00:00:00 2001
From: Andy-Python-Programmer <andypythonappdeveloper@gmail.com>
Date: Wed, 5 Oct 2022 18:59:01 +1100
Subject: lint::unsafe_removed_from_name: fix false positive result when
 allowed

* Allowing `unsafe_removed_from_name` on imports produces a false
positive on `useless_attribute`.

Fixes: #9197

Signed-off-by: Andy-Python-Programmer <andypythonappdeveloper@gmail.com>
---
 clippy_lints/src/attrs.rs            | 3 ++-
 tests/ui/unsafe_removed_from_name.rs | 3 +++
 2 files changed, 5 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs
index 5f45c69d7f9..0bd1f8b784e 100644
--- a/clippy_lints/src/attrs.rs
+++ b/clippy_lints/src/attrs.rs
@@ -357,7 +357,8 @@ impl<'tcx> LateLintPass<'tcx> for Attributes {
                                                     "wildcard_imports"
                                                         | "enum_glob_use"
                                                         | "redundant_pub_crate"
-                                                        | "macro_use_imports",
+                                                        | "macro_use_imports"
+                                                        | "unsafe_removed_from_name",
                                                 )
                                             })
                                         {
diff --git a/tests/ui/unsafe_removed_from_name.rs b/tests/ui/unsafe_removed_from_name.rs
index cde4e96d668..d29888ac62f 100644
--- a/tests/ui/unsafe_removed_from_name.rs
+++ b/tests/ui/unsafe_removed_from_name.rs
@@ -24,4 +24,7 @@ use mod_with_some_unsafe_things::Unsafe as LieAboutModSafety;
 use mod_with_some_unsafe_things::Safe as IPromiseItsSafeThisTime;
 use mod_with_some_unsafe_things::Unsafe as SuperUnsafeModThing;
 
+#[allow(clippy::unsafe_removed_from_name)]
+use mod_with_some_unsafe_things::Unsafe as SuperSafeThing;
+
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 86c86c37429e95aee45846262bb50239a69be546 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Wed, 5 Oct 2022 13:44:01 +0000
Subject: Add `disallowed_macros` lint

---
 CHANGELOG.md                                       |   1 +
 clippy_lints/src/await_holding_invalid.rs          |  34 ++---
 clippy_lints/src/disallowed_macros.rs              | 151 +++++++++++++++++++++
 clippy_lints/src/disallowed_methods.rs             |  15 +-
 clippy_lints/src/disallowed_types.rs               |  20 ++-
 clippy_lints/src/lib.register_all.rs               |   1 +
 clippy_lints/src/lib.register_lints.rs             |   1 +
 clippy_lints/src/lib.register_style.rs             |   1 +
 clippy_lints/src/lib.rs                            |   3 +
 clippy_lints/src/missing_enforced_import_rename.rs |   3 +-
 clippy_lints/src/utils/conf.rs                     |  30 ++--
 clippy_lints/src/utils/internal_lints.rs           |  10 +-
 clippy_utils/src/lib.rs                            | 105 ++++++++------
 src/docs.rs                                        |   1 +
 src/docs/disallowed_macros.txt                     |  36 +++++
 .../ui-toml/disallowed_macros/auxiliary/macros.rs  |  32 +++++
 tests/ui-toml/disallowed_macros/clippy.toml        |  11 ++
 .../ui-toml/disallowed_macros/disallowed_macros.rs |  39 ++++++
 .../disallowed_macros/disallowed_macros.stderr     |  84 ++++++++++++
 tests/ui-toml/toml_disallowed_methods/clippy.toml  |   1 +
 .../conf_disallowed_methods.rs                     |   6 +
 .../conf_disallowed_methods.stderr                 |  24 ++--
 .../toml_unknown_key/conf_unknown_key.stderr       |   1 +
 23 files changed, 500 insertions(+), 110 deletions(-)
 create mode 100644 clippy_lints/src/disallowed_macros.rs
 create mode 100644 src/docs/disallowed_macros.txt
 create mode 100644 tests/ui-toml/disallowed_macros/auxiliary/macros.rs
 create mode 100644 tests/ui-toml/disallowed_macros/clippy.toml
 create mode 100644 tests/ui-toml/disallowed_macros/disallowed_macros.rs
 create mode 100644 tests/ui-toml/disallowed_macros/disallowed_macros.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index bfeb009727b..42615179f70 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3820,6 +3820,7 @@ Released 2018-09-13
 [`derive_hash_xor_eq`]: https://rust-lang.github.io/rust-clippy/master/index.html#derive_hash_xor_eq
 [`derive_ord_xor_partial_ord`]: https://rust-lang.github.io/rust-clippy/master/index.html#derive_ord_xor_partial_ord
 [`derive_partial_eq_without_eq`]: https://rust-lang.github.io/rust-clippy/master/index.html#derive_partial_eq_without_eq
+[`disallowed_macros`]: https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_macros
 [`disallowed_method`]: https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_method
 [`disallowed_methods`]: https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_methods
 [`disallowed_names`]: https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_names
diff --git a/clippy_lints/src/await_holding_invalid.rs b/clippy_lints/src/await_holding_invalid.rs
index 24a3588ecf1..34717811866 100644
--- a/clippy_lints/src/await_holding_invalid.rs
+++ b/clippy_lints/src/await_holding_invalid.rs
@@ -1,14 +1,15 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::{match_def_path, paths};
 use rustc_data_structures::fx::FxHashMap;
+use rustc_hir::def::{Namespace, Res};
 use rustc_hir::def_id::DefId;
-use rustc_hir::{def::Res, AsyncGeneratorKind, Body, BodyId, GeneratorKind};
+use rustc_hir::{AsyncGeneratorKind, Body, BodyId, GeneratorKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::GeneratorInteriorTypeCause;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::{sym, Span};
 
-use crate::utils::conf::DisallowedType;
+use crate::utils::conf::DisallowedPath;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -171,12 +172,12 @@ impl_lint_pass!(AwaitHolding => [AWAIT_HOLDING_LOCK, AWAIT_HOLDING_REFCELL_REF,
 
 #[derive(Debug)]
 pub struct AwaitHolding {
-    conf_invalid_types: Vec<DisallowedType>,
-    def_ids: FxHashMap<DefId, DisallowedType>,
+    conf_invalid_types: Vec<DisallowedPath>,
+    def_ids: FxHashMap<DefId, DisallowedPath>,
 }
 
 impl AwaitHolding {
-    pub(crate) fn new(conf_invalid_types: Vec<DisallowedType>) -> Self {
+    pub(crate) fn new(conf_invalid_types: Vec<DisallowedPath>) -> Self {
         Self {
             conf_invalid_types,
             def_ids: FxHashMap::default(),
@@ -187,11 +188,8 @@ impl AwaitHolding {
 impl LateLintPass<'_> for AwaitHolding {
     fn check_crate(&mut self, cx: &LateContext<'_>) {
         for conf in &self.conf_invalid_types {
-            let path = match conf {
-                DisallowedType::Simple(path) | DisallowedType::WithReason { path, .. } => path,
-            };
-            let segs: Vec<_> = path.split("::").collect();
-            if let Res::Def(_, id) = clippy_utils::def_path_res(cx, &segs) {
+            let segs: Vec<_> = conf.path().split("::").collect();
+            if let Res::Def(_, id) = clippy_utils::def_path_res(cx, &segs, Some(Namespace::TypeNS)) {
                 self.def_ids.insert(id, conf.clone());
             }
         }
@@ -256,20 +254,18 @@ impl AwaitHolding {
     }
 }
 
-fn emit_invalid_type(cx: &LateContext<'_>, span: Span, disallowed: &DisallowedType) {
-    let (type_name, reason) = match disallowed {
-        DisallowedType::Simple(path) => (path, &None),
-        DisallowedType::WithReason { path, reason } => (path, reason),
-    };
-
+fn emit_invalid_type(cx: &LateContext<'_>, span: Span, disallowed: &DisallowedPath) {
     span_lint_and_then(
         cx,
         AWAIT_HOLDING_INVALID_TYPE,
         span,
-        &format!("`{type_name}` may not be held across an `await` point per `clippy.toml`",),
+        &format!(
+            "`{}` may not be held across an `await` point per `clippy.toml`",
+            disallowed.path()
+        ),
         |diag| {
-            if let Some(reason) = reason {
-                diag.note(reason.clone());
+            if let Some(reason) = disallowed.reason() {
+                diag.note(reason);
             }
         },
     );
diff --git a/clippy_lints/src/disallowed_macros.rs b/clippy_lints/src/disallowed_macros.rs
new file mode 100644
index 00000000000..5ab7144e290
--- /dev/null
+++ b/clippy_lints/src/disallowed_macros.rs
@@ -0,0 +1,151 @@
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::macros::macro_backtrace;
+use rustc_data_structures::fx::FxHashSet;
+use rustc_hir::def::{Namespace, Res};
+use rustc_hir::def_id::DefIdMap;
+use rustc_hir::{Expr, ForeignItem, HirId, ImplItem, Item, Pat, Path, Stmt, TraitItem, Ty};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::{ExpnId, Span};
+
+use crate::utils::conf;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Denies the configured macros in clippy.toml
+    ///
+    /// Note: Even though this lint is warn-by-default, it will only trigger if
+    /// macros are defined in the clippy.toml file.
+    ///
+    /// ### Why is this bad?
+    /// Some macros are undesirable in certain contexts, and it's beneficial to
+    /// lint for them as needed.
+    ///
+    /// ### Example
+    /// An example clippy.toml configuration:
+    /// ```toml
+    /// # clippy.toml
+    /// disallowed-macros = [
+    ///     # Can use a string as the path of the disallowed macro.
+    ///     "std::print",
+    ///     # Can also use an inline table with a `path` key.
+    ///     { path = "std::println" },
+    ///     # When using an inline table, can add a `reason` for why the macro
+    ///     # is disallowed.
+    ///     { path = "serde::Serialize", reason = "no serializing" },
+    /// ]
+    /// ```
+    /// ```
+    /// use serde::Serialize;
+    ///
+    /// // Example code where clippy issues a warning
+    /// println!("warns");
+    ///
+    /// // The diagnostic will contain the message "no serializing"
+    /// #[derive(Serialize)]
+    /// struct Data {
+    ///     name: String,
+    ///     value: usize,
+    /// }
+    /// ```
+    #[clippy::version = "1.65.0"]
+    pub DISALLOWED_MACROS,
+    style,
+    "use of a disallowed macro"
+}
+
+pub struct DisallowedMacros {
+    conf_disallowed: Vec<conf::DisallowedPath>,
+    disallowed: DefIdMap<usize>,
+    seen: FxHashSet<ExpnId>,
+}
+
+impl DisallowedMacros {
+    pub fn new(conf_disallowed: Vec<conf::DisallowedPath>) -> Self {
+        Self {
+            conf_disallowed,
+            disallowed: DefIdMap::default(),
+            seen: FxHashSet::default(),
+        }
+    }
+
+    fn check(&mut self, cx: &LateContext<'_>, span: Span) {
+        if self.conf_disallowed.is_empty() {
+            return;
+        }
+
+        for mac in macro_backtrace(span) {
+            if !self.seen.insert(mac.expn) {
+                return;
+            }
+
+            if let Some(&index) = self.disallowed.get(&mac.def_id) {
+                let conf = &self.conf_disallowed[index];
+
+                span_lint_and_then(
+                    cx,
+                    DISALLOWED_MACROS,
+                    mac.span,
+                    &format!("use of a disallowed macro `{}`", conf.path()),
+                    |diag| {
+                        if let Some(reason) = conf.reason() {
+                            diag.note(&format!("{reason} (from clippy.toml)"));
+                        }
+                    },
+                );
+            }
+        }
+    }
+}
+
+impl_lint_pass!(DisallowedMacros => [DISALLOWED_MACROS]);
+
+impl LateLintPass<'_> for DisallowedMacros {
+    fn check_crate(&mut self, cx: &LateContext<'_>) {
+        for (index, conf) in self.conf_disallowed.iter().enumerate() {
+            let segs: Vec<_> = conf.path().split("::").collect();
+            if let Res::Def(_, id) = clippy_utils::def_path_res(cx, &segs, Some(Namespace::MacroNS)) {
+                self.disallowed.insert(id, index);
+            }
+        }
+    }
+
+    fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
+        self.check(cx, expr.span);
+    }
+
+    fn check_stmt(&mut self, cx: &LateContext<'_>, stmt: &Stmt<'_>) {
+        self.check(cx, stmt.span);
+    }
+
+    fn check_ty(&mut self, cx: &LateContext<'_>, ty: &Ty<'_>) {
+        self.check(cx, ty.span);
+    }
+
+    fn check_pat(&mut self, cx: &LateContext<'_>, pat: &Pat<'_>) {
+        self.check(cx, pat.span);
+    }
+
+    fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
+        self.check(cx, item.span);
+        self.check(cx, item.vis_span);
+    }
+
+    fn check_foreign_item(&mut self, cx: &LateContext<'_>, item: &ForeignItem<'_>) {
+        self.check(cx, item.span);
+        self.check(cx, item.vis_span);
+    }
+
+    fn check_impl_item(&mut self, cx: &LateContext<'_>, item: &ImplItem<'_>) {
+        self.check(cx, item.span);
+        self.check(cx, item.vis_span);
+    }
+
+    fn check_trait_item(&mut self, cx: &LateContext<'_>, item: &TraitItem<'_>) {
+        self.check(cx, item.span);
+    }
+
+    fn check_path(&mut self, cx: &LateContext<'_>, path: &Path<'_>, _: HirId) {
+        self.check(cx, path.span);
+    }
+}
diff --git a/clippy_lints/src/disallowed_methods.rs b/clippy_lints/src/disallowed_methods.rs
index b02f87c07db..1a381f92c03 100644
--- a/clippy_lints/src/disallowed_methods.rs
+++ b/clippy_lints/src/disallowed_methods.rs
@@ -1,7 +1,9 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::{fn_def_id, get_parent_expr, path_def_id};
 
-use rustc_hir::{def::Res, def_id::DefIdMap, Expr, ExprKind};
+use rustc_hir::def::{Namespace, Res};
+use rustc_hir::def_id::DefIdMap;
+use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 
@@ -58,12 +60,12 @@ declare_clippy_lint! {
 
 #[derive(Clone, Debug)]
 pub struct DisallowedMethods {
-    conf_disallowed: Vec<conf::DisallowedMethod>,
+    conf_disallowed: Vec<conf::DisallowedPath>,
     disallowed: DefIdMap<usize>,
 }
 
 impl DisallowedMethods {
-    pub fn new(conf_disallowed: Vec<conf::DisallowedMethod>) -> Self {
+    pub fn new(conf_disallowed: Vec<conf::DisallowedPath>) -> Self {
         Self {
             conf_disallowed,
             disallowed: DefIdMap::default(),
@@ -77,7 +79,7 @@ impl<'tcx> LateLintPass<'tcx> for DisallowedMethods {
     fn check_crate(&mut self, cx: &LateContext<'_>) {
         for (index, conf) in self.conf_disallowed.iter().enumerate() {
             let segs: Vec<_> = conf.path().split("::").collect();
-            if let Res::Def(_, id) = clippy_utils::def_path_res(cx, &segs) {
+            if let Res::Def(_, id) = clippy_utils::def_path_res(cx, &segs, Some(Namespace::ValueNS)) {
                 self.disallowed.insert(id, index);
             }
         }
@@ -102,10 +104,7 @@ impl<'tcx> LateLintPass<'tcx> for DisallowedMethods {
         };
         let msg = format!("use of a disallowed method `{}`", conf.path());
         span_lint_and_then(cx, DISALLOWED_METHODS, expr.span, &msg, |diag| {
-            if let conf::DisallowedMethod::WithReason {
-                reason: Some(reason), ..
-            } = conf
-            {
+            if let Some(reason) = conf.reason() {
                 diag.note(&format!("{reason} (from clippy.toml)"));
             }
         });
diff --git a/clippy_lints/src/disallowed_types.rs b/clippy_lints/src/disallowed_types.rs
index debcd75ae75..c7131fc164d 100644
--- a/clippy_lints/src/disallowed_types.rs
+++ b/clippy_lints/src/disallowed_types.rs
@@ -1,7 +1,9 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 
 use rustc_data_structures::fx::FxHashMap;
-use rustc_hir::{def::Res, def_id::DefId, Item, ItemKind, PolyTraitRef, PrimTy, Ty, TyKind, UseKind};
+use rustc_hir::def::{Namespace, Res};
+use rustc_hir::def_id::DefId;
+use rustc_hir::{Item, ItemKind, PolyTraitRef, PrimTy, Ty, TyKind, UseKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::Span;
@@ -50,13 +52,13 @@ declare_clippy_lint! {
 }
 #[derive(Clone, Debug)]
 pub struct DisallowedTypes {
-    conf_disallowed: Vec<conf::DisallowedType>,
+    conf_disallowed: Vec<conf::DisallowedPath>,
     def_ids: FxHashMap<DefId, Option<String>>,
     prim_tys: FxHashMap<PrimTy, Option<String>>,
 }
 
 impl DisallowedTypes {
-    pub fn new(conf_disallowed: Vec<conf::DisallowedType>) -> Self {
+    pub fn new(conf_disallowed: Vec<conf::DisallowedPath>) -> Self {
         Self {
             conf_disallowed,
             def_ids: FxHashMap::default(),
@@ -86,15 +88,9 @@ impl_lint_pass!(DisallowedTypes => [DISALLOWED_TYPES]);
 impl<'tcx> LateLintPass<'tcx> for DisallowedTypes {
     fn check_crate(&mut self, cx: &LateContext<'_>) {
         for conf in &self.conf_disallowed {
-            let (path, reason) = match conf {
-                conf::DisallowedType::Simple(path) => (path, None),
-                conf::DisallowedType::WithReason { path, reason } => (
-                    path,
-                    reason.as_ref().map(|reason| format!("{reason} (from clippy.toml)")),
-                ),
-            };
-            let segs: Vec<_> = path.split("::").collect();
-            match clippy_utils::def_path_res(cx, &segs) {
+            let segs: Vec<_> = conf.path().split("::").collect();
+            let reason = conf.reason().map(|reason| format!("{reason} (from clippy.toml)"));
+            match clippy_utils::def_path_res(cx, &segs, Some(Namespace::TypeNS)) {
                 Res::Def(_, id) => {
                     self.def_ids.insert(id, reason);
                 },
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 642d7070fb6..5d26e4b3360 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -45,6 +45,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(derivable_impls::DERIVABLE_IMPLS),
     LintId::of(derive::DERIVE_HASH_XOR_EQ),
     LintId::of(derive::DERIVE_ORD_XOR_PARTIAL_ORD),
+    LintId::of(disallowed_macros::DISALLOWED_MACROS),
     LintId::of(disallowed_methods::DISALLOWED_METHODS),
     LintId::of(disallowed_names::DISALLOWED_NAMES),
     LintId::of(disallowed_types::DISALLOWED_TYPES),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 08eb6c2b39b..05d927dbea7 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -114,6 +114,7 @@ store.register_lints(&[
     derive::DERIVE_PARTIAL_EQ_WITHOUT_EQ,
     derive::EXPL_IMPL_CLONE_ON_COPY,
     derive::UNSAFE_DERIVE_DESERIALIZE,
+    disallowed_macros::DISALLOWED_MACROS,
     disallowed_methods::DISALLOWED_METHODS,
     disallowed_names::DISALLOWED_NAMES,
     disallowed_script_idents::DISALLOWED_SCRIPT_IDENTS,
diff --git a/clippy_lints/src/lib.register_style.rs b/clippy_lints/src/lib.register_style.rs
index 6d5483bc701..8e1390167dc 100644
--- a/clippy_lints/src/lib.register_style.rs
+++ b/clippy_lints/src/lib.register_style.rs
@@ -15,6 +15,7 @@ store.register_group(true, "clippy::style", Some("clippy_style"), vec![
     LintId::of(default::FIELD_REASSIGN_WITH_DEFAULT),
     LintId::of(default_instead_of_iter_empty::DEFAULT_INSTEAD_OF_ITER_EMPTY),
     LintId::of(dereference::NEEDLESS_BORROW),
+    LintId::of(disallowed_macros::DISALLOWED_MACROS),
     LintId::of(disallowed_methods::DISALLOWED_METHODS),
     LintId::of(disallowed_names::DISALLOWED_NAMES),
     LintId::of(disallowed_types::DISALLOWED_TYPES),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index e5d26ac22a7..2dcefd78763 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -199,6 +199,7 @@ mod default_union_representation;
 mod dereference;
 mod derivable_impls;
 mod derive;
+mod disallowed_macros;
 mod disallowed_methods;
 mod disallowed_names;
 mod disallowed_script_idents;
@@ -820,6 +821,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(unwrap_in_result::UnwrapInResult));
     store.register_late_pass(|_| Box::new(semicolon_if_nothing_returned::SemicolonIfNothingReturned));
     store.register_late_pass(|_| Box::new(async_yields_async::AsyncYieldsAsync));
+    let disallowed_macros = conf.disallowed_macros.clone();
+    store.register_late_pass(move |_| Box::new(disallowed_macros::DisallowedMacros::new(disallowed_macros.clone())));
     let disallowed_methods = conf.disallowed_methods.clone();
     store.register_late_pass(move |_| Box::new(disallowed_methods::DisallowedMethods::new(disallowed_methods.clone())));
     store.register_early_pass(|| Box::new(asm_syntax::InlineAsmX86AttSyntax));
diff --git a/clippy_lints/src/missing_enforced_import_rename.rs b/clippy_lints/src/missing_enforced_import_rename.rs
index 697e6fd24dd..872679f25ab 100644
--- a/clippy_lints/src/missing_enforced_import_rename.rs
+++ b/clippy_lints/src/missing_enforced_import_rename.rs
@@ -58,7 +58,8 @@ impl_lint_pass!(ImportRename => [MISSING_ENFORCED_IMPORT_RENAMES]);
 impl LateLintPass<'_> for ImportRename {
     fn check_crate(&mut self, cx: &LateContext<'_>) {
         for Rename { path, rename } in &self.conf_renames {
-            if let Res::Def(_, id) = clippy_utils::def_path_res(cx, &path.split("::").collect::<Vec<_>>()) {
+            let segs = path.split("::").collect::<Vec<_>>();
+            if let Res::Def(_, id) = clippy_utils::def_path_res(cx, &segs, None) {
                 self.renames.insert(id, Symbol::intern(rename));
             }
         }
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 2b336e87ef7..668123e4d6e 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -39,28 +39,28 @@ pub struct Rename {
     pub rename: String,
 }
 
-/// A single disallowed method, used by the `DISALLOWED_METHODS` lint.
 #[derive(Clone, Debug, Deserialize)]
 #[serde(untagged)]
-pub enum DisallowedMethod {
+pub enum DisallowedPath {
     Simple(String),
     WithReason { path: String, reason: Option<String> },
 }
 
-impl DisallowedMethod {
+impl DisallowedPath {
     pub fn path(&self) -> &str {
         let (Self::Simple(path) | Self::WithReason { path, .. }) = self;
 
         path
     }
-}
 
-/// A single disallowed type, used by the `DISALLOWED_TYPES` lint.
-#[derive(Clone, Debug, Deserialize)]
-#[serde(untagged)]
-pub enum DisallowedType {
-    Simple(String),
-    WithReason { path: String, reason: Option<String> },
+    pub fn reason(&self) -> Option<&str> {
+        match self {
+            Self::WithReason {
+                reason: Some(reason), ..
+            } => Some(reason),
+            _ => None,
+        }
+    }
 }
 
 /// Conf with parse errors
@@ -315,14 +315,18 @@ define_Conf! {
     ///
     /// Whether to allow certain wildcard imports (prelude, super in tests).
     (warn_on_all_wildcard_imports: bool = false),
+    /// Lint: DISALLOWED_MACROS.
+    ///
+    /// The list of disallowed macros, written as fully qualified paths.
+    (disallowed_macros: Vec<crate::utils::conf::DisallowedPath> = Vec::new()),
     /// Lint: DISALLOWED_METHODS.
     ///
     /// The list of disallowed methods, written as fully qualified paths.
-    (disallowed_methods: Vec<crate::utils::conf::DisallowedMethod> = Vec::new()),
+    (disallowed_methods: Vec<crate::utils::conf::DisallowedPath> = Vec::new()),
     /// Lint: DISALLOWED_TYPES.
     ///
     /// The list of disallowed types, written as fully qualified paths.
-    (disallowed_types: Vec<crate::utils::conf::DisallowedType> = Vec::new()),
+    (disallowed_types: Vec<crate::utils::conf::DisallowedPath> = Vec::new()),
     /// Lint: UNREADABLE_LITERAL.
     ///
     /// Should the fraction of a decimal be linted to include separators.
@@ -362,7 +366,7 @@ define_Conf! {
     /// For example, `[_, _, _, e, ..]` is a slice pattern with 4 elements.
     (max_suggested_slice_pattern_length: u64 = 3),
     /// Lint: AWAIT_HOLDING_INVALID_TYPE
-    (await_holding_invalid_types: Vec<crate::utils::conf::DisallowedType> = Vec::new()),
+    (await_holding_invalid_types: Vec<crate::utils::conf::DisallowedPath> = Vec::new()),
     /// Lint: LARGE_INCLUDE_FILE.
     ///
     /// The maximum size of a file included via `include_bytes!()` or `include_str!()`, in bytes
diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs
index 6309a04c73d..85bcbc7ad23 100644
--- a/clippy_lints/src/utils/internal_lints.rs
+++ b/clippy_lints/src/utils/internal_lints.rs
@@ -15,7 +15,7 @@ use rustc_ast::visit::FnKind;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
-use rustc_hir::def::{DefKind, Res};
+use rustc_hir::def::{DefKind, Namespace, Res};
 use rustc_hir::def_id::DefId;
 use rustc_hir::hir_id::CRATE_HIR_ID;
 use rustc_hir::intravisit::Visitor;
@@ -920,7 +920,7 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryDefPath {
             // Extract the path to the matched type
             if let Some(segments) = path_to_matched_type(cx, item_arg);
             let segments: Vec<&str> = segments.iter().map(|sym| &**sym).collect();
-            if let Some(def_id) = def_path_res(cx, &segments[..]).opt_def_id();
+            if let Some(def_id) = def_path_res(cx, &segments[..], None).opt_def_id();
             then {
                 // def_path_res will match field names before anything else, but for this we want to match
                 // inherent functions first.
@@ -952,7 +952,7 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryDefPath {
                         Item::DiagnosticItem(*item_name),
                     )
                 } else if let Some(lang_item) = cx.tcx.lang_items().items().iter().position(|id| *id == Some(def_id)) {
-                    let lang_items = def_path_res(cx, &["rustc_hir", "lang_items", "LangItem"]).def_id();
+                    let lang_items = def_path_res(cx, &["rustc_hir", "lang_items", "LangItem"], Some(Namespace::TypeNS)).def_id();
                     let item_name = cx.tcx.adt_def(lang_items).variants().iter().nth(lang_item).unwrap().name;
                     (
                         "use of a def path to a `LangItem`",
@@ -1115,7 +1115,7 @@ fn read_mir_alloc_def_path<'tcx>(cx: &LateContext<'tcx>, alloc: &'tcx Allocation
 // This is not a complete resolver for paths. It works on all the paths currently used in the paths
 // module.  That's all it does and all it needs to do.
 pub fn check_path(cx: &LateContext<'_>, path: &[&str]) -> bool {
-    if def_path_res(cx, path) != Res::Err {
+    if def_path_res(cx, path, None) != Res::Err {
         return true;
     }
 
@@ -1206,7 +1206,7 @@ impl<'tcx> LateLintPass<'tcx> for InterningDefinedSymbol {
         }
 
         for &module in &[&paths::KW_MODULE, &paths::SYM_MODULE] {
-            if let Some(def_id) = def_path_res(cx, module).opt_def_id() {
+            if let Some(def_id) = def_path_res(cx, module, None).opt_def_id() {
                 for item in cx.tcx.module_children(def_id).iter() {
                     if_chain! {
                         if let Res::Def(DefKind::Const, item_def_id) = item.res;
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 3caa6380e09..39198519329 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -78,7 +78,7 @@ use rustc_ast::Attribute;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_data_structures::unhash::UnhashMap;
 use rustc_hir as hir;
-use rustc_hir::def::{DefKind, Res};
+use rustc_hir::def::{DefKind, Namespace, Res};
 use rustc_hir::def_id::{CrateNum, DefId, LocalDefId};
 use rustc_hir::hir_id::{HirIdMap, HirIdSet};
 use rustc_hir::intravisit::{walk_expr, FnKind, Visitor};
@@ -522,15 +522,49 @@ pub fn path_def_id<'tcx>(cx: &LateContext<'_>, maybe_path: &impl MaybePath<'tcx>
     path_res(cx, maybe_path).opt_def_id()
 }
 
-/// Resolves a def path like `std::vec::Vec`.
+fn find_primitive<'tcx>(tcx: TyCtxt<'tcx>, name: &str) -> impl Iterator<Item = DefId> + 'tcx {
+    let single = |ty| tcx.incoherent_impls(ty).iter().copied();
+    let empty = || [].iter().copied();
+    match name {
+        "bool" => single(BoolSimplifiedType),
+        "char" => single(CharSimplifiedType),
+        "str" => single(StrSimplifiedType),
+        "array" => single(ArraySimplifiedType),
+        "slice" => single(SliceSimplifiedType),
+        // FIXME: rustdoc documents these two using just `pointer`.
+        //
+        // Maybe this is something we should do here too.
+        "const_ptr" => single(PtrSimplifiedType(Mutability::Not)),
+        "mut_ptr" => single(PtrSimplifiedType(Mutability::Mut)),
+        "isize" => single(IntSimplifiedType(IntTy::Isize)),
+        "i8" => single(IntSimplifiedType(IntTy::I8)),
+        "i16" => single(IntSimplifiedType(IntTy::I16)),
+        "i32" => single(IntSimplifiedType(IntTy::I32)),
+        "i64" => single(IntSimplifiedType(IntTy::I64)),
+        "i128" => single(IntSimplifiedType(IntTy::I128)),
+        "usize" => single(UintSimplifiedType(UintTy::Usize)),
+        "u8" => single(UintSimplifiedType(UintTy::U8)),
+        "u16" => single(UintSimplifiedType(UintTy::U16)),
+        "u32" => single(UintSimplifiedType(UintTy::U32)),
+        "u64" => single(UintSimplifiedType(UintTy::U64)),
+        "u128" => single(UintSimplifiedType(UintTy::U128)),
+        "f32" => single(FloatSimplifiedType(FloatTy::F32)),
+        "f64" => single(FloatSimplifiedType(FloatTy::F64)),
+        _ => empty(),
+    }
+}
+
+/// Resolves a def path like `std::vec::Vec`. `namespace_hint` can be supplied to disambiguate
+/// between `std::vec` the module and `std::vec` the macro
+///
 /// This function is expensive and should be used sparingly.
-pub fn def_path_res(cx: &LateContext<'_>, path: &[&str]) -> Res {
-    fn item_child_by_name(tcx: TyCtxt<'_>, def_id: DefId, name: &str) -> Option<Res> {
+pub fn def_path_res(cx: &LateContext<'_>, path: &[&str], namespace_hint: Option<Namespace>) -> Res {
+    fn item_child_by_name(tcx: TyCtxt<'_>, def_id: DefId, name: &str, matches_ns: impl Fn(Res) -> bool) -> Option<Res> {
         match tcx.def_kind(def_id) {
             DefKind::Mod | DefKind::Enum | DefKind::Trait => tcx
                 .module_children(def_id)
                 .iter()
-                .find(|item| item.ident.name.as_str() == name)
+                .find(|item| item.ident.name.as_str() == name && matches_ns(item.res.expect_non_local()))
                 .map(|child| child.res.expect_non_local()),
             DefKind::Impl => tcx
                 .associated_item_def_ids(def_id)
@@ -548,37 +582,7 @@ pub fn def_path_res(cx: &LateContext<'_>, path: &[&str]) -> Res {
             _ => None,
         }
     }
-    fn find_primitive<'tcx>(tcx: TyCtxt<'tcx>, name: &str) -> impl Iterator<Item = DefId> + 'tcx {
-        let single = |ty| tcx.incoherent_impls(ty).iter().copied();
-        let empty = || [].iter().copied();
-        match name {
-            "bool" => single(BoolSimplifiedType),
-            "char" => single(CharSimplifiedType),
-            "str" => single(StrSimplifiedType),
-            "array" => single(ArraySimplifiedType),
-            "slice" => single(SliceSimplifiedType),
-            // FIXME: rustdoc documents these two using just `pointer`.
-            //
-            // Maybe this is something we should do here too.
-            "const_ptr" => single(PtrSimplifiedType(Mutability::Not)),
-            "mut_ptr" => single(PtrSimplifiedType(Mutability::Mut)),
-            "isize" => single(IntSimplifiedType(IntTy::Isize)),
-            "i8" => single(IntSimplifiedType(IntTy::I8)),
-            "i16" => single(IntSimplifiedType(IntTy::I16)),
-            "i32" => single(IntSimplifiedType(IntTy::I32)),
-            "i64" => single(IntSimplifiedType(IntTy::I64)),
-            "i128" => single(IntSimplifiedType(IntTy::I128)),
-            "usize" => single(UintSimplifiedType(UintTy::Usize)),
-            "u8" => single(UintSimplifiedType(UintTy::U8)),
-            "u16" => single(UintSimplifiedType(UintTy::U16)),
-            "u32" => single(UintSimplifiedType(UintTy::U32)),
-            "u64" => single(UintSimplifiedType(UintTy::U64)),
-            "u128" => single(UintSimplifiedType(UintTy::U128)),
-            "f32" => single(FloatSimplifiedType(FloatTy::F32)),
-            "f64" => single(FloatSimplifiedType(FloatTy::F64)),
-            _ => empty(),
-        }
-    }
+
     fn find_crate(tcx: TyCtxt<'_>, name: &str) -> Option<DefId> {
         tcx.crates(())
             .iter()
@@ -587,32 +591,45 @@ pub fn def_path_res(cx: &LateContext<'_>, path: &[&str]) -> Res {
             .map(CrateNum::as_def_id)
     }
 
-    let (base, first, path) = match *path {
-        [base, first, ref path @ ..] => (base, first, path),
+    let (base, path) = match *path {
         [primitive] => {
             return PrimTy::from_name(Symbol::intern(primitive)).map_or(Res::Err, Res::PrimTy);
         },
+        [base, ref path @ ..] => (base, path),
         _ => return Res::Err,
     };
     let tcx = cx.tcx;
     let starts = find_primitive(tcx, base)
         .chain(find_crate(tcx, base))
-        .filter_map(|id| item_child_by_name(tcx, id, first));
+        .map(|id| Res::Def(tcx.def_kind(id), id));
 
     for first in starts {
         let last = path
             .iter()
             .copied()
+            .enumerate()
             // for each segment, find the child item
-            .try_fold(first, |res, segment| {
+            .try_fold(first, |res, (idx, segment)| {
+                let matches_ns = |res: Res| {
+                    // If at the last segment in the path, respect the namespace hint
+                    if idx == path.len() - 1 {
+                        match namespace_hint {
+                            Some(ns) => res.matches_ns(ns),
+                            None => true,
+                        }
+                    } else {
+                        res.matches_ns(Namespace::TypeNS)
+                    }
+                };
+
                 let def_id = res.def_id();
-                if let Some(item) = item_child_by_name(tcx, def_id, segment) {
+                if let Some(item) = item_child_by_name(tcx, def_id, segment, matches_ns) {
                     Some(item)
                 } else if matches!(res, Res::Def(DefKind::Enum | DefKind::Struct, _)) {
                     // it is not a child item so check inherent impl items
                     tcx.inherent_impls(def_id)
                         .iter()
-                        .find_map(|&impl_def_id| item_child_by_name(tcx, impl_def_id, segment))
+                        .find_map(|&impl_def_id| item_child_by_name(tcx, impl_def_id, segment, matches_ns))
                 } else {
                     None
                 }
@@ -628,8 +645,10 @@ pub fn def_path_res(cx: &LateContext<'_>, path: &[&str]) -> Res {
 
 /// Convenience function to get the `DefId` of a trait by path.
 /// It could be a trait or trait alias.
+///
+/// This function is expensive and should be used sparingly.
 pub fn get_trait_def_id(cx: &LateContext<'_>, path: &[&str]) -> Option<DefId> {
-    match def_path_res(cx, path) {
+    match def_path_res(cx, path, Some(Namespace::TypeNS)) {
         Res::Def(DefKind::Trait | DefKind::TraitAlias, trait_id) => Some(trait_id),
         _ => None,
     }
diff --git a/src/docs.rs b/src/docs.rs
index 1b727e1a100..3bf488ab477 100644
--- a/src/docs.rs
+++ b/src/docs.rs
@@ -106,6 +106,7 @@ docs! {
     "derive_hash_xor_eq",
     "derive_ord_xor_partial_ord",
     "derive_partial_eq_without_eq",
+    "disallowed_macros",
     "disallowed_methods",
     "disallowed_names",
     "disallowed_script_idents",
diff --git a/src/docs/disallowed_macros.txt b/src/docs/disallowed_macros.txt
new file mode 100644
index 00000000000..96fa15afabf
--- /dev/null
+++ b/src/docs/disallowed_macros.txt
@@ -0,0 +1,36 @@
+### What it does
+Denies the configured macros in clippy.toml
+
+Note: Even though this lint is warn-by-default, it will only trigger if
+macros are defined in the clippy.toml file.
+
+### Why is this bad?
+Some macros are undesirable in certain contexts, and it's beneficial to
+lint for them as needed.
+
+### Example
+An example clippy.toml configuration:
+```
+disallowed-macros = [
+    # Can use a string as the path of the disallowed macro.
+    "std::print",
+    # Can also use an inline table with a `path` key.
+    { path = "std::println" },
+    # When using an inline table, can add a `reason` for why the macro
+    # is disallowed.
+    { path = "serde::Serialize", reason = "no serializing" },
+]
+```
+```
+use serde::Serialize;
+
+// Example code where clippy issues a warning
+println!("warns");
+
+// The diagnostic will contain the message "no serializing"
+#[derive(Serialize)]
+struct Data {
+    name: String,
+    value: usize,
+}
+```
\ No newline at end of file
diff --git a/tests/ui-toml/disallowed_macros/auxiliary/macros.rs b/tests/ui-toml/disallowed_macros/auxiliary/macros.rs
new file mode 100644
index 00000000000..fcaeace0e98
--- /dev/null
+++ b/tests/ui-toml/disallowed_macros/auxiliary/macros.rs
@@ -0,0 +1,32 @@
+#[macro_export]
+macro_rules! expr {
+    () => {
+        1
+    };
+}
+
+#[macro_export]
+macro_rules! stmt {
+    () => {
+        let _x = ();
+    };
+}
+
+#[macro_export]
+macro_rules! ty {
+    () => { &'static str };
+}
+
+#[macro_export]
+macro_rules! pat {
+    () => {
+        _
+    };
+}
+
+#[macro_export]
+macro_rules! item {
+    () => {
+        const ITEM: usize = 1;
+    };
+}
diff --git a/tests/ui-toml/disallowed_macros/clippy.toml b/tests/ui-toml/disallowed_macros/clippy.toml
new file mode 100644
index 00000000000..c8fe8be9a77
--- /dev/null
+++ b/tests/ui-toml/disallowed_macros/clippy.toml
@@ -0,0 +1,11 @@
+disallowed-macros = [
+    "std::println",
+    "std::vec",
+    { path = "std::cfg" },
+    { path = "serde::Serialize", reason = "no serializing" },
+    "macros::expr",
+    "macros::stmt",
+    "macros::ty",
+    "macros::pat",
+    "macros::item",
+]
diff --git a/tests/ui-toml/disallowed_macros/disallowed_macros.rs b/tests/ui-toml/disallowed_macros/disallowed_macros.rs
new file mode 100644
index 00000000000..2bb5376076e
--- /dev/null
+++ b/tests/ui-toml/disallowed_macros/disallowed_macros.rs
@@ -0,0 +1,39 @@
+// aux-build:macros.rs
+
+#![allow(unused)]
+
+extern crate macros;
+
+use serde::Serialize;
+
+fn main() {
+    println!("one");
+    println!("two");
+    cfg!(unix);
+    vec![1, 2, 3];
+
+    #[derive(Serialize)]
+    struct Derive;
+
+    let _ = macros::expr!();
+    macros::stmt!();
+    let macros::pat!() = 1;
+    let _: macros::ty!() = "";
+    macros::item!();
+
+    eprintln!("allowed");
+}
+
+struct S;
+
+impl S {
+    macros::item!();
+}
+
+trait Y {
+    macros::item!();
+}
+
+impl Y for S {
+    macros::item!();
+}
diff --git a/tests/ui-toml/disallowed_macros/disallowed_macros.stderr b/tests/ui-toml/disallowed_macros/disallowed_macros.stderr
new file mode 100644
index 00000000000..aed9feb6f79
--- /dev/null
+++ b/tests/ui-toml/disallowed_macros/disallowed_macros.stderr
@@ -0,0 +1,84 @@
+error: use of a disallowed macro `std::println`
+  --> $DIR/disallowed_macros.rs:10:5
+   |
+LL |     println!("one");
+   |     ^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::disallowed-macros` implied by `-D warnings`
+
+error: use of a disallowed macro `std::println`
+  --> $DIR/disallowed_macros.rs:11:5
+   |
+LL |     println!("two");
+   |     ^^^^^^^^^^^^^^^
+
+error: use of a disallowed macro `std::cfg`
+  --> $DIR/disallowed_macros.rs:12:5
+   |
+LL |     cfg!(unix);
+   |     ^^^^^^^^^^
+
+error: use of a disallowed macro `std::vec`
+  --> $DIR/disallowed_macros.rs:13:5
+   |
+LL |     vec![1, 2, 3];
+   |     ^^^^^^^^^^^^^
+
+error: use of a disallowed macro `serde::Serialize`
+  --> $DIR/disallowed_macros.rs:15:14
+   |
+LL |     #[derive(Serialize)]
+   |              ^^^^^^^^^
+   |
+   = note: no serializing (from clippy.toml)
+
+error: use of a disallowed macro `macros::expr`
+  --> $DIR/disallowed_macros.rs:18:13
+   |
+LL |     let _ = macros::expr!();
+   |             ^^^^^^^^^^^^^^^
+
+error: use of a disallowed macro `macros::stmt`
+  --> $DIR/disallowed_macros.rs:19:5
+   |
+LL |     macros::stmt!();
+   |     ^^^^^^^^^^^^^^^
+
+error: use of a disallowed macro `macros::pat`
+  --> $DIR/disallowed_macros.rs:20:9
+   |
+LL |     let macros::pat!() = 1;
+   |         ^^^^^^^^^^^^^^
+
+error: use of a disallowed macro `macros::ty`
+  --> $DIR/disallowed_macros.rs:21:12
+   |
+LL |     let _: macros::ty!() = "";
+   |            ^^^^^^^^^^^^^
+
+error: use of a disallowed macro `macros::item`
+  --> $DIR/disallowed_macros.rs:22:5
+   |
+LL |     macros::item!();
+   |     ^^^^^^^^^^^^^^^
+
+error: use of a disallowed macro `macros::item`
+  --> $DIR/disallowed_macros.rs:30:5
+   |
+LL |     macros::item!();
+   |     ^^^^^^^^^^^^^^^
+
+error: use of a disallowed macro `macros::item`
+  --> $DIR/disallowed_macros.rs:34:5
+   |
+LL |     macros::item!();
+   |     ^^^^^^^^^^^^^^^
+
+error: use of a disallowed macro `macros::item`
+  --> $DIR/disallowed_macros.rs:38:5
+   |
+LL |     macros::item!();
+   |     ^^^^^^^^^^^^^^^
+
+error: aborting due to 13 previous errors
+
diff --git a/tests/ui-toml/toml_disallowed_methods/clippy.toml b/tests/ui-toml/toml_disallowed_methods/clippy.toml
index c902d21123d..28774db625b 100644
--- a/tests/ui-toml/toml_disallowed_methods/clippy.toml
+++ b/tests/ui-toml/toml_disallowed_methods/clippy.toml
@@ -3,6 +3,7 @@ disallowed-methods = [
     "std::iter::Iterator::sum",
     "f32::clamp",
     "slice::sort_unstable",
+    "futures::stream::select_all",
     # can give path and reason with an inline table
     { path = "regex::Regex::is_match", reason = "no matching allowed" },
     # can use an inline table but omit reason
diff --git a/tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.rs b/tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.rs
index 3397fa1ec69..b483f160028 100644
--- a/tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.rs
+++ b/tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.rs
@@ -1,6 +1,9 @@
 #![warn(clippy::disallowed_methods)]
 
+extern crate futures;
 extern crate regex;
+
+use futures::stream::{empty, select_all};
 use regex::Regex;
 
 fn main() {
@@ -20,4 +23,7 @@ fn main() {
 
     let in_call = Box::new(f32::clamp);
     let in_method_call = ["^", "$"].into_iter().map(Regex::new);
+
+    // resolve ambiguity between `futures::stream::select_all` the module and the function
+    let same_name_as_module = select_all(vec![empty::<()>()]);
 }
diff --git a/tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.stderr b/tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.stderr
index 5cbb567546c..6d78c32e127 100644
--- a/tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.stderr
+++ b/tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.stderr
@@ -1,5 +1,5 @@
 error: use of a disallowed method `regex::Regex::new`
-  --> $DIR/conf_disallowed_methods.rs:7:14
+  --> $DIR/conf_disallowed_methods.rs:10:14
    |
 LL |     let re = Regex::new(r"ab.*c").unwrap();
    |              ^^^^^^^^^^^^^^^^^^^^
@@ -7,7 +7,7 @@ LL |     let re = Regex::new(r"ab.*c").unwrap();
    = note: `-D clippy::disallowed-methods` implied by `-D warnings`
 
 error: use of a disallowed method `regex::Regex::is_match`
-  --> $DIR/conf_disallowed_methods.rs:8:5
+  --> $DIR/conf_disallowed_methods.rs:11:5
    |
 LL |     re.is_match("abc");
    |     ^^^^^^^^^^^^^^^^^^
@@ -15,40 +15,46 @@ LL |     re.is_match("abc");
    = note: no matching allowed (from clippy.toml)
 
 error: use of a disallowed method `std::iter::Iterator::sum`
-  --> $DIR/conf_disallowed_methods.rs:11:5
+  --> $DIR/conf_disallowed_methods.rs:14:5
    |
 LL |     a.iter().sum::<i32>();
    |     ^^^^^^^^^^^^^^^^^^^^^
 
 error: use of a disallowed method `slice::sort_unstable`
-  --> $DIR/conf_disallowed_methods.rs:13:5
+  --> $DIR/conf_disallowed_methods.rs:16:5
    |
 LL |     a.sort_unstable();
    |     ^^^^^^^^^^^^^^^^^
 
 error: use of a disallowed method `f32::clamp`
-  --> $DIR/conf_disallowed_methods.rs:15:13
+  --> $DIR/conf_disallowed_methods.rs:18:13
    |
 LL |     let _ = 2.0f32.clamp(3.0f32, 4.0f32);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: use of a disallowed method `regex::Regex::new`
-  --> $DIR/conf_disallowed_methods.rs:18:61
+  --> $DIR/conf_disallowed_methods.rs:21:61
    |
 LL |     let indirect: fn(&str) -> Result<Regex, regex::Error> = Regex::new;
    |                                                             ^^^^^^^^^^
 
 error: use of a disallowed method `f32::clamp`
-  --> $DIR/conf_disallowed_methods.rs:21:28
+  --> $DIR/conf_disallowed_methods.rs:24:28
    |
 LL |     let in_call = Box::new(f32::clamp);
    |                            ^^^^^^^^^^
 
 error: use of a disallowed method `regex::Regex::new`
-  --> $DIR/conf_disallowed_methods.rs:22:53
+  --> $DIR/conf_disallowed_methods.rs:25:53
    |
 LL |     let in_method_call = ["^", "$"].into_iter().map(Regex::new);
    |                                                     ^^^^^^^^^^
 
-error: aborting due to 8 previous errors
+error: use of a disallowed method `futures::stream::select_all`
+  --> $DIR/conf_disallowed_methods.rs:28:31
+   |
+LL |     let same_name_as_module = select_all(vec![empty::<()>()]);
+   |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 9 previous errors
 
diff --git a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
index f27f78d15d3..82ee8054132 100644
--- a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
+++ b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
@@ -11,6 +11,7 @@ error: error reading Clippy's configuration file `$DIR/clippy.toml`: unknown fie
            cargo-ignore-publish
            cognitive-complexity-threshold
            cyclomatic-complexity-threshold
+           disallowed-macros
            disallowed-methods
            disallowed-names
            disallowed-types
-- 
cgit 1.4.1-3-g733a5


From 9226066bcb40745dbb91965c3d5d9210294b1c88 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Wed, 5 Oct 2022 16:10:52 +0000
Subject: FormatArgsExpn: Find comma spans and ignore weird proc macro spans

---
 clippy_lints/src/format_args.rs       |  13 ++-
 clippy_lints/src/write.rs             |   6 +-
 clippy_utils/src/macros.rs            | 109 ++++++++++++++++++++-
 tests/ui/expect_fun_call.fixed        |   6 ++
 tests/ui/expect_fun_call.rs           |   6 ++
 tests/ui/expect_fun_call.stderr       |  14 ++-
 tests/ui/uninlined_format_args.fixed  |  22 ++---
 tests/ui/uninlined_format_args.rs     |  24 ++---
 tests/ui/uninlined_format_args.stderr | 172 ++++++++++++++++++++--------------
 9 files changed, 262 insertions(+), 110 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/format_args.rs b/clippy_lints/src/format_args.rs
index 89d81bdd485..88502b72618 100644
--- a/clippy_lints/src/format_args.rs
+++ b/clippy_lints/src/format_args.rs
@@ -1,13 +1,13 @@
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::macros::FormatParamKind::{Implicit, Named, Numbered, Starred};
 use clippy_utils::macros::{is_format_macro, FormatArgsExpn, FormatParam, FormatParamUsage};
-use clippy_utils::source::{expand_past_previous_comma, snippet_opt};
+use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::implements_trait;
 use clippy_utils::{is_diag_trait_item, meets_msrv, msrvs};
 use if_chain::if_chain;
 use itertools::Itertools;
 use rustc_errors::Applicability;
-use rustc_hir::{Expr, ExprKind, HirId, Path, QPath};
+use rustc_hir::{Expr, ExprKind, HirId, QPath};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::adjustment::{Adjust, Adjustment};
 use rustc_middle::ty::Ty;
@@ -169,7 +169,7 @@ fn check_uninlined_args(cx: &LateContext<'_>, args: &FormatArgsExpn<'_>, call_si
     // we cannot remove any other arguments in the format string,
     // because the index numbers might be wrong after inlining.
     // Example of an un-inlinable format:  print!("{}{1}", foo, 2)
-    if !args.params().all(|p| check_one_arg(cx, &p, &mut fixes)) || fixes.is_empty() {
+    if !args.params().all(|p| check_one_arg(args, &p, &mut fixes)) || fixes.is_empty() {
         return;
     }
 
@@ -196,11 +196,11 @@ fn check_uninlined_args(cx: &LateContext<'_>, args: &FormatArgsExpn<'_>, call_si
     );
 }
 
-fn check_one_arg(cx: &LateContext<'_>, param: &FormatParam<'_>, fixes: &mut Vec<(Span, String)>) -> bool {
+fn check_one_arg(args: &FormatArgsExpn<'_>, param: &FormatParam<'_>, fixes: &mut Vec<(Span, String)>) -> bool {
     if matches!(param.kind, Implicit | Starred | Named(_) | Numbered)
         && let ExprKind::Path(QPath::Resolved(None, path)) = param.value.kind
-        && let Path { span, segments, .. } = path
-        && let [segment] = segments
+        && let [segment] = path.segments
+        && let Some(arg_span) = args.value_with_prev_comma_span(param.value.hir_id)
     {
         let replacement = match param.usage {
             FormatParamUsage::Argument => segment.ident.name.to_string(),
@@ -208,7 +208,6 @@ fn check_one_arg(cx: &LateContext<'_>, param: &FormatParam<'_>, fixes: &mut Vec<
             FormatParamUsage::Precision => format!(".{}$", segment.ident.name),
         };
         fixes.push((param.span, replacement));
-        let arg_span = expand_past_previous_comma(cx, *span);
         fixes.push((arg_span, String::new()));
         true  // successful inlining, continue checking
     } else {
diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs
index 3d3686604b7..36574198f91 100644
--- a/clippy_lints/src/write.rs
+++ b/clippy_lints/src/write.rs
@@ -475,11 +475,11 @@ fn check_literal(cx: &LateContext<'_>, format_args: &FormatArgsExpn<'_>, name: &
                 value.span,
                 "literal with an empty format string",
                 |diag| {
-                    if let Some(replacement) = replacement {
+                    if let Some(replacement) = replacement
                         // `format!("{}", "a")`, `format!("{named}", named = "b")
                         //              ~~~~~                      ~~~~~~~~~~~~~
-                        let value_span = expand_past_previous_comma(cx, value.span);
-
+                        && let Some(value_span) = format_args.value_with_prev_comma_span(value.hir_id)
+                    {
                         let replacement = replacement.replace('{', "{{").replace('}', "}}");
                         diag.multipart_suggestion(
                             "try this",
diff --git a/clippy_utils/src/macros.rs b/clippy_utils/src/macros.rs
index dda21b90390..dd0ce1da657 100644
--- a/clippy_utils/src/macros.rs
+++ b/clippy_utils/src/macros.rs
@@ -16,6 +16,7 @@ use rustc_parse_format::{self as rpf, Alignment};
 use rustc_span::def_id::DefId;
 use rustc_span::hygiene::{self, MacroKind, SyntaxContext};
 use rustc_span::{sym, BytePos, ExpnData, ExpnId, ExpnKind, Pos, Span, SpanData, Symbol};
+use std::iter::{once, zip};
 use std::ops::ControlFlow;
 
 const FORMAT_MACRO_DIAG_ITEMS: &[Symbol] = &[
@@ -412,7 +413,8 @@ impl FormatString {
 }
 
 struct FormatArgsValues<'tcx> {
-    /// See `FormatArgsExpn::value_args`
+    /// Values passed after the format string and implicit captures. `[1, z + 2, x]` for
+    /// `format!("{x} {} {y}", 1, z + 2)`.
     value_args: Vec<&'tcx Expr<'tcx>>,
     /// Maps an `rt::v1::Argument::position` or an `rt::v1::Count::Param` to its index in
     /// `value_args`
@@ -765,12 +767,82 @@ pub struct FormatArgsExpn<'tcx> {
     /// Has an added newline due to `println!()`/`writeln!()`/etc. The last format string part will
     /// include this added newline.
     pub newline: bool,
-    /// Values passed after the format string and implicit captures. `[1, z + 2, x]` for
+    /// Spans of the commas between the format string and explicit values, excluding any trailing
+    /// comma
+    ///
+    /// ```ignore
+    /// format!("..", 1, 2, 3,)
+    /// //          ^  ^  ^
+    /// ```
+    comma_spans: Vec<Span>,
+    /// Explicit values passed after the format string, ignoring implicit captures. `[1, z + 2]` for
     /// `format!("{x} {} {y}", 1, z + 2)`.
-    value_args: Vec<&'tcx Expr<'tcx>>,
+    explicit_values: Vec<&'tcx Expr<'tcx>>,
 }
 
 impl<'tcx> FormatArgsExpn<'tcx> {
+    /// Gets the spans of the commas inbetween the format string and explicit args, not including
+    /// any trailing comma
+    ///
+    /// ```ignore
+    /// format!("{} {}", a, b)
+    /// //             ^  ^
+    /// ```
+    ///
+    /// Ensures that the format string and values aren't coming from a proc macro that sets the
+    /// output span to that of its input
+    fn comma_spans(cx: &LateContext<'_>, explicit_values: &[&Expr<'_>], fmt_span: Span) -> Option<Vec<Span>> {
+        // `format!("{} {} {c}", "one", "two", c = "three")`
+        //                       ^^^^^  ^^^^^      ^^^^^^^
+        let value_spans = explicit_values
+            .iter()
+            .map(|val| hygiene::walk_chain(val.span, fmt_span.ctxt()));
+
+        // `format!("{} {} {c}", "one", "two", c = "three")`
+        //                     ^^     ^^     ^^^^^^
+        let between_spans = once(fmt_span)
+            .chain(value_spans)
+            .tuple_windows()
+            .map(|(start, end)| start.between(end));
+
+        let mut comma_spans = Vec::new();
+        for between_span in between_spans {
+            let mut offset = 0;
+            let mut seen_comma = false;
+
+            for token in tokenize(&snippet_opt(cx, between_span)?) {
+                match token.kind {
+                    TokenKind::LineComment { .. } | TokenKind::BlockComment { .. } | TokenKind::Whitespace => {},
+                    TokenKind::Comma if !seen_comma => {
+                        seen_comma = true;
+
+                        let base = between_span.data();
+                        comma_spans.push(Span::new(
+                            base.lo + BytePos(offset),
+                            base.lo + BytePos(offset + 1),
+                            base.ctxt,
+                            base.parent,
+                        ));
+                    },
+                    // named arguments, `start_val, name = end_val`
+                    //                            ^^^^^^^^^ between_span
+                    TokenKind::Ident | TokenKind::Eq if seen_comma => {},
+                    // An unexpected token usually indicates the format string or a value came from a proc macro output
+                    // that sets the span of its output to an input, e.g. `println!(some_proc_macro!("input"), ..)` that
+                    // emits a string literal with the span set to that of `"input"`
+                    _ => return None,
+                }
+                offset += token.len;
+            }
+
+            if !seen_comma {
+                return None;
+            }
+        }
+
+        Some(comma_spans)
+    }
+
     pub fn parse(cx: &LateContext<'_>, expr: &'tcx Expr<'tcx>) -> Option<Self> {
         let macro_name = macro_backtrace(expr.span)
             .map(|macro_call| cx.tcx.item_name(macro_call.def_id))
@@ -845,11 +917,22 @@ impl<'tcx> FormatArgsExpn<'tcx> {
                 })
                 .collect::<Option<Vec<_>>>()?;
 
+            let mut explicit_values = values.value_args;
+            // remove values generated for implicitly captured vars
+            let len = explicit_values
+                .iter()
+                .take_while(|val| !format_string.span.contains(val.span))
+                .count();
+            explicit_values.truncate(len);
+
+            let comma_spans = Self::comma_spans(cx, &explicit_values, format_string.span)?;
+
             Some(Self {
                 format_string,
                 args,
-                value_args: values.value_args,
                 newline,
+                comma_spans,
+                explicit_values,
             })
         } else {
             None
@@ -875,7 +958,7 @@ impl<'tcx> FormatArgsExpn<'tcx> {
 
     /// Source callsite span of all inputs
     pub fn inputs_span(&self) -> Span {
-        match *self.value_args {
+        match *self.explicit_values {
             [] => self.format_string.span,
             [.., last] => self
                 .format_string
@@ -884,6 +967,22 @@ impl<'tcx> FormatArgsExpn<'tcx> {
         }
     }
 
+    /// Get the span of a value expanded to the previous comma, e.g. for the value `10`
+    ///
+    /// ```ignore
+    /// format("{}.{}", 10, 11)
+    /// //            ^^^^
+    /// ```
+    pub fn value_with_prev_comma_span(&self, value_id: HirId) -> Option<Span> {
+        for (comma_span, value) in zip(&self.comma_spans, &self.explicit_values) {
+            if value.hir_id == value_id {
+                return Some(comma_span.to(hygiene::walk_chain(value.span, comma_span.ctxt())));
+            }
+        }
+
+        None
+    }
+
     /// Iterator of all format params, both values and those referenced by `width`/`precision`s.
     pub fn params(&'tcx self) -> impl Iterator<Item = FormatParam<'tcx>> {
         self.args
diff --git a/tests/ui/expect_fun_call.fixed b/tests/ui/expect_fun_call.fixed
index c118403b773..15172ae345c 100644
--- a/tests/ui/expect_fun_call.fixed
+++ b/tests/ui/expect_fun_call.fixed
@@ -100,4 +100,10 @@ fn main() {
         let opt_ref = &opt;
         opt_ref.unwrap_or_else(|| panic!("{:?}", opt_ref));
     }
+
+    let format_capture: Option<i32> = None;
+    format_capture.unwrap_or_else(|| panic!("{error_code}"));
+
+    let format_capture_and_value: Option<i32> = None;
+    format_capture_and_value.unwrap_or_else(|| panic!("{error_code}, {}", 1));
 }
diff --git a/tests/ui/expect_fun_call.rs b/tests/ui/expect_fun_call.rs
index 7f4a8bc7aa6..0f448d00417 100644
--- a/tests/ui/expect_fun_call.rs
+++ b/tests/ui/expect_fun_call.rs
@@ -100,4 +100,10 @@ fn main() {
         let opt_ref = &opt;
         opt_ref.expect(&format!("{:?}", opt_ref));
     }
+
+    let format_capture: Option<i32> = None;
+    format_capture.expect(&format!("{error_code}"));
+
+    let format_capture_and_value: Option<i32> = None;
+    format_capture_and_value.expect(&format!("{error_code}, {}", 1));
 }
diff --git a/tests/ui/expect_fun_call.stderr b/tests/ui/expect_fun_call.stderr
index e76c03ecf16..cb55e32aee0 100644
--- a/tests/ui/expect_fun_call.stderr
+++ b/tests/ui/expect_fun_call.stderr
@@ -78,5 +78,17 @@ error: use of `expect` followed by a function call
 LL |         opt_ref.expect(&format!("{:?}", opt_ref));
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|| panic!("{:?}", opt_ref))`
 
-error: aborting due to 13 previous errors
+error: use of `expect` followed by a function call
+  --> $DIR/expect_fun_call.rs:105:20
+   |
+LL |     format_capture.expect(&format!("{error_code}"));
+   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|| panic!("{error_code}"))`
+
+error: use of `expect` followed by a function call
+  --> $DIR/expect_fun_call.rs:108:30
+   |
+LL |     format_capture_and_value.expect(&format!("{error_code}, {}", 1));
+   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|| panic!("{error_code}, {}", 1))`
+
+error: aborting due to 15 previous errors
 
diff --git a/tests/ui/uninlined_format_args.fixed b/tests/ui/uninlined_format_args.fixed
index 931916819ce..dcf10ed60a2 100644
--- a/tests/ui/uninlined_format_args.fixed
+++ b/tests/ui/uninlined_format_args.fixed
@@ -1,21 +1,19 @@
+// aux-build:proc_macro_with_span.rs
 // run-rustfix
 #![feature(custom_inner_attributes)]
 #![warn(clippy::uninlined_format_args)]
 #![allow(named_arguments_used_positionally, unused_imports, unused_macros, unused_variables)]
 #![allow(clippy::eq_op, clippy::format_in_format_args, clippy::print_literal)]
 
+extern crate proc_macro_with_span;
+use proc_macro_with_span::with_span;
+
 macro_rules! no_param_str {
     () => {
         "{}"
     };
 }
 
-macro_rules! pass_through {
-    ($expr:expr) => {
-        $expr
-    };
-}
-
 macro_rules! my_println {
    ($($args:tt),*) => {{
         println!($($args),*)
@@ -140,11 +138,13 @@ fn tester(fn_arg: i32) {
     );
     println!(no_param_str!(), local_i32);
 
-    // FIXME: bugs!
-    // println!(pass_through!("foo={local_i32}"), local_i32 = local_i32);
-    // println!(pass_through!("foo={}"), local_i32);
-    // println!(indoc!("foo={}"), local_i32);
-    // printdoc!("foo={}", local_i32);
+    println!(
+        "{val}",
+    );
+    println!("{val}");
+
+    println!(with_span!("{0} {1}" "{1} {0}"), local_i32, local_f64);
+    println!("{}", with_span!(span val));
 }
 
 fn main() {
diff --git a/tests/ui/uninlined_format_args.rs b/tests/ui/uninlined_format_args.rs
index 0a908677514..924191f4324 100644
--- a/tests/ui/uninlined_format_args.rs
+++ b/tests/ui/uninlined_format_args.rs
@@ -1,21 +1,19 @@
+// aux-build:proc_macro_with_span.rs
 // run-rustfix
 #![feature(custom_inner_attributes)]
 #![warn(clippy::uninlined_format_args)]
 #![allow(named_arguments_used_positionally, unused_imports, unused_macros, unused_variables)]
 #![allow(clippy::eq_op, clippy::format_in_format_args, clippy::print_literal)]
 
+extern crate proc_macro_with_span;
+use proc_macro_with_span::with_span;
+
 macro_rules! no_param_str {
     () => {
         "{}"
     };
 }
 
-macro_rules! pass_through {
-    ($expr:expr) => {
-        $expr
-    };
-}
-
 macro_rules! my_println {
    ($($args:tt),*) => {{
         println!($($args),*)
@@ -143,11 +141,15 @@ fn tester(fn_arg: i32) {
     );
     println!(no_param_str!(), local_i32);
 
-    // FIXME: bugs!
-    // println!(pass_through!("foo={local_i32}"), local_i32 = local_i32);
-    // println!(pass_through!("foo={}"), local_i32);
-    // println!(indoc!("foo={}"), local_i32);
-    // printdoc!("foo={}", local_i32);
+    println!(
+        "{}",
+        // comment with a comma , in it
+        val,
+    );
+    println!("{}", /* comment with a comma , in it */ val);
+
+    println!(with_span!("{0} {1}" "{1} {0}"), local_i32, local_f64);
+    println!("{}", with_span!(span val));
 }
 
 fn main() {
diff --git a/tests/ui/uninlined_format_args.stderr b/tests/ui/uninlined_format_args.stderr
index 6c8f3f43348..1b4dada28da 100644
--- a/tests/ui/uninlined_format_args.stderr
+++ b/tests/ui/uninlined_format_args.stderr
@@ -1,5 +1,5 @@
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:43:5
+  --> $DIR/uninlined_format_args.rs:41:5
    |
 LL |     println!("val='{}'", local_i32);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -12,7 +12,7 @@ LL +     println!("val='{local_i32}'");
    |
 
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:44:5
+  --> $DIR/uninlined_format_args.rs:42:5
    |
 LL |     println!("val='{   }'", local_i32); // 3 spaces
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -24,7 +24,7 @@ LL +     println!("val='{local_i32}'"); // 3 spaces
    |
 
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:45:5
+  --> $DIR/uninlined_format_args.rs:43:5
    |
 LL |     println!("val='{    }'", local_i32); // tab
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -36,7 +36,7 @@ LL +     println!("val='{local_i32}'"); // tab
    |
 
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:46:5
+  --> $DIR/uninlined_format_args.rs:44:5
    |
 LL |     println!("val='{     }'", local_i32); // space+tab
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -48,7 +48,7 @@ LL +     println!("val='{local_i32}'"); // space+tab
    |
 
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:47:5
+  --> $DIR/uninlined_format_args.rs:45:5
    |
 LL |     println!("val='{     }'", local_i32); // tab+space
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -60,7 +60,7 @@ LL +     println!("val='{local_i32}'"); // tab+space
    |
 
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:48:5
+  --> $DIR/uninlined_format_args.rs:46:5
    |
 LL | /     println!(
 LL | |         "val='{
@@ -76,7 +76,7 @@ LL +         "val='{local_i32}'"
    |
 
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:53:5
+  --> $DIR/uninlined_format_args.rs:51:5
    |
 LL |     println!("{}", local_i32);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -88,7 +88,7 @@ LL +     println!("{local_i32}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:54:5
+  --> $DIR/uninlined_format_args.rs:52:5
    |
 LL |     println!("{}", fn_arg);
    |     ^^^^^^^^^^^^^^^^^^^^^^
@@ -100,7 +100,7 @@ LL +     println!("{fn_arg}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:55:5
+  --> $DIR/uninlined_format_args.rs:53:5
    |
 LL |     println!("{:?}", local_i32);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -112,7 +112,7 @@ LL +     println!("{local_i32:?}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:56:5
+  --> $DIR/uninlined_format_args.rs:54:5
    |
 LL |     println!("{:#?}", local_i32);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -124,7 +124,7 @@ LL +     println!("{local_i32:#?}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:57:5
+  --> $DIR/uninlined_format_args.rs:55:5
    |
 LL |     println!("{:4}", local_i32);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -136,7 +136,7 @@ LL +     println!("{local_i32:4}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:58:5
+  --> $DIR/uninlined_format_args.rs:56:5
    |
 LL |     println!("{:04}", local_i32);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -148,7 +148,7 @@ LL +     println!("{local_i32:04}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:59:5
+  --> $DIR/uninlined_format_args.rs:57:5
    |
 LL |     println!("{:<3}", local_i32);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -160,7 +160,7 @@ LL +     println!("{local_i32:<3}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:60:5
+  --> $DIR/uninlined_format_args.rs:58:5
    |
 LL |     println!("{:#010x}", local_i32);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -172,7 +172,7 @@ LL +     println!("{local_i32:#010x}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:61:5
+  --> $DIR/uninlined_format_args.rs:59:5
    |
 LL |     println!("{:.1}", local_f64);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -184,7 +184,7 @@ LL +     println!("{local_f64:.1}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:62:5
+  --> $DIR/uninlined_format_args.rs:60:5
    |
 LL |     println!("Hello {} is {:.*}", "x", local_i32, local_f64);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -196,7 +196,7 @@ LL +     println!("Hello {} is {local_f64:.local_i32$}", "x");
    |
 
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:63:5
+  --> $DIR/uninlined_format_args.rs:61:5
    |
 LL |     println!("Hello {} is {:.*}", local_i32, 5, local_f64);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -208,7 +208,7 @@ LL +     println!("Hello {local_i32} is {local_f64:.*}", 5);
    |
 
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:64:5
+  --> $DIR/uninlined_format_args.rs:62:5
    |
 LL |     println!("Hello {} is {2:.*}", local_i32, 5, local_f64);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -220,7 +220,7 @@ LL +     println!("Hello {local_i32} is {local_f64:.*}", 5);
    |
 
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:65:5
+  --> $DIR/uninlined_format_args.rs:63:5
    |
 LL |     println!("{} {}", local_i32, local_f64);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -232,7 +232,7 @@ LL +     println!("{local_i32} {local_f64}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:66:5
+  --> $DIR/uninlined_format_args.rs:64:5
    |
 LL |     println!("{}, {}", local_i32, local_opt.unwrap());
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -244,7 +244,7 @@ LL +     println!("{local_i32}, {}", local_opt.unwrap());
    |
 
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:67:5
+  --> $DIR/uninlined_format_args.rs:65:5
    |
 LL |     println!("{}", val);
    |     ^^^^^^^^^^^^^^^^^^^
@@ -256,7 +256,7 @@ LL +     println!("{val}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:68:5
+  --> $DIR/uninlined_format_args.rs:66:5
    |
 LL |     println!("{}", v = val);
    |     ^^^^^^^^^^^^^^^^^^^^^^^
@@ -268,7 +268,7 @@ LL +     println!("{val}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:70:5
+  --> $DIR/uninlined_format_args.rs:68:5
    |
 LL |     println!("val='{/t }'", local_i32);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -280,7 +280,7 @@ LL +     println!("val='{local_i32}'");
    |
 
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:71:5
+  --> $DIR/uninlined_format_args.rs:69:5
    |
 LL |     println!("val='{/n }'", local_i32);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -292,7 +292,7 @@ LL +     println!("val='{local_i32}'");
    |
 
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:72:5
+  --> $DIR/uninlined_format_args.rs:70:5
    |
 LL |     println!("val='{local_i32}'", local_i32 = local_i32);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -304,7 +304,7 @@ LL +     println!("val='{local_i32}'");
    |
 
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:73:5
+  --> $DIR/uninlined_format_args.rs:71:5
    |
 LL |     println!("val='{local_i32}'", local_i32 = fn_arg);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -316,7 +316,7 @@ LL +     println!("val='{fn_arg}'");
    |
 
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:74:5
+  --> $DIR/uninlined_format_args.rs:72:5
    |
 LL |     println!("{0}", local_i32);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -328,7 +328,7 @@ LL +     println!("{local_i32}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:75:5
+  --> $DIR/uninlined_format_args.rs:73:5
    |
 LL |     println!("{0:?}", local_i32);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -340,7 +340,7 @@ LL +     println!("{local_i32:?}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:76:5
+  --> $DIR/uninlined_format_args.rs:74:5
    |
 LL |     println!("{0:#?}", local_i32);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -352,7 +352,7 @@ LL +     println!("{local_i32:#?}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:77:5
+  --> $DIR/uninlined_format_args.rs:75:5
    |
 LL |     println!("{0:04}", local_i32);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -364,7 +364,7 @@ LL +     println!("{local_i32:04}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:78:5
+  --> $DIR/uninlined_format_args.rs:76:5
    |
 LL |     println!("{0:<3}", local_i32);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -376,7 +376,7 @@ LL +     println!("{local_i32:<3}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:79:5
+  --> $DIR/uninlined_format_args.rs:77:5
    |
 LL |     println!("{0:#010x}", local_i32);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -388,7 +388,7 @@ LL +     println!("{local_i32:#010x}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:80:5
+  --> $DIR/uninlined_format_args.rs:78:5
    |
 LL |     println!("{0:.1}", local_f64);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -400,7 +400,7 @@ LL +     println!("{local_f64:.1}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:81:5
+  --> $DIR/uninlined_format_args.rs:79:5
    |
 LL |     println!("{0} {0}", local_i32);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -412,7 +412,7 @@ LL +     println!("{local_i32} {local_i32}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:82:5
+  --> $DIR/uninlined_format_args.rs:80:5
    |
 LL |     println!("{1} {} {0} {}", local_i32, local_f64);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -424,7 +424,7 @@ LL +     println!("{local_f64} {local_i32} {local_i32} {local_f64}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:83:5
+  --> $DIR/uninlined_format_args.rs:81:5
    |
 LL |     println!("{0} {1}", local_i32, local_f64);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -436,7 +436,7 @@ LL +     println!("{local_i32} {local_f64}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:84:5
+  --> $DIR/uninlined_format_args.rs:82:5
    |
 LL |     println!("{1} {0}", local_i32, local_f64);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -448,7 +448,7 @@ LL +     println!("{local_f64} {local_i32}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:85:5
+  --> $DIR/uninlined_format_args.rs:83:5
    |
 LL |     println!("{1} {0} {1} {0}", local_i32, local_f64);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -460,7 +460,7 @@ LL +     println!("{local_f64} {local_i32} {local_f64} {local_i32}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:87:5
+  --> $DIR/uninlined_format_args.rs:85:5
    |
 LL |     println!("{v}", v = local_i32);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -472,7 +472,7 @@ LL +     println!("{local_i32}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:88:5
+  --> $DIR/uninlined_format_args.rs:86:5
    |
 LL |     println!("{local_i32:0$}", width);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -484,7 +484,7 @@ LL +     println!("{local_i32:width$}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:89:5
+  --> $DIR/uninlined_format_args.rs:87:5
    |
 LL |     println!("{local_i32:w$}", w = width);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -496,7 +496,7 @@ LL +     println!("{local_i32:width$}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:90:5
+  --> $DIR/uninlined_format_args.rs:88:5
    |
 LL |     println!("{local_i32:.0$}", prec);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -508,7 +508,7 @@ LL +     println!("{local_i32:.prec$}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:91:5
+  --> $DIR/uninlined_format_args.rs:89:5
    |
 LL |     println!("{local_i32:.p$}", p = prec);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -520,7 +520,7 @@ LL +     println!("{local_i32:.prec$}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:92:5
+  --> $DIR/uninlined_format_args.rs:90:5
    |
 LL |     println!("{:0$}", v = val);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -532,7 +532,7 @@ LL +     println!("{val:val$}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:93:5
+  --> $DIR/uninlined_format_args.rs:91:5
    |
 LL |     println!("{0:0$}", v = val);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -544,7 +544,7 @@ LL +     println!("{val:val$}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:94:5
+  --> $DIR/uninlined_format_args.rs:92:5
    |
 LL |     println!("{:0$.0$}", v = val);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -556,7 +556,7 @@ LL +     println!("{val:val$.val$}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:95:5
+  --> $DIR/uninlined_format_args.rs:93:5
    |
 LL |     println!("{0:0$.0$}", v = val);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -568,7 +568,7 @@ LL +     println!("{val:val$.val$}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:96:5
+  --> $DIR/uninlined_format_args.rs:94:5
    |
 LL |     println!("{0:0$.v$}", v = val);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -580,7 +580,7 @@ LL +     println!("{val:val$.val$}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:97:5
+  --> $DIR/uninlined_format_args.rs:95:5
    |
 LL |     println!("{0:v$.0$}", v = val);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -592,7 +592,7 @@ LL +     println!("{val:val$.val$}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:98:5
+  --> $DIR/uninlined_format_args.rs:96:5
    |
 LL |     println!("{v:0$.0$}", v = val);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -604,7 +604,7 @@ LL +     println!("{val:val$.val$}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:99:5
+  --> $DIR/uninlined_format_args.rs:97:5
    |
 LL |     println!("{v:v$.0$}", v = val);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -616,7 +616,7 @@ LL +     println!("{val:val$.val$}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:100:5
+  --> $DIR/uninlined_format_args.rs:98:5
    |
 LL |     println!("{v:0$.v$}", v = val);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -628,7 +628,7 @@ LL +     println!("{val:val$.val$}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:101:5
+  --> $DIR/uninlined_format_args.rs:99:5
    |
 LL |     println!("{v:v$.v$}", v = val);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -640,7 +640,7 @@ LL +     println!("{val:val$.val$}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:102:5
+  --> $DIR/uninlined_format_args.rs:100:5
    |
 LL |     println!("{:0$}", width);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -652,7 +652,7 @@ LL +     println!("{width:width$}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:103:5
+  --> $DIR/uninlined_format_args.rs:101:5
    |
 LL |     println!("{:1$}", local_i32, width);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -664,7 +664,7 @@ LL +     println!("{local_i32:width$}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:104:5
+  --> $DIR/uninlined_format_args.rs:102:5
    |
 LL |     println!("{:w$}", w = width);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -676,7 +676,7 @@ LL +     println!("{width:width$}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:105:5
+  --> $DIR/uninlined_format_args.rs:103:5
    |
 LL |     println!("{:w$}", local_i32, w = width);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -688,7 +688,7 @@ LL +     println!("{local_i32:width$}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:106:5
+  --> $DIR/uninlined_format_args.rs:104:5
    |
 LL |     println!("{:.0$}", prec);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -700,7 +700,7 @@ LL +     println!("{prec:.prec$}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:107:5
+  --> $DIR/uninlined_format_args.rs:105:5
    |
 LL |     println!("{:.1$}", local_i32, prec);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -712,7 +712,7 @@ LL +     println!("{local_i32:.prec$}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:108:5
+  --> $DIR/uninlined_format_args.rs:106:5
    |
 LL |     println!("{:.p$}", p = prec);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -724,7 +724,7 @@ LL +     println!("{prec:.prec$}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:109:5
+  --> $DIR/uninlined_format_args.rs:107:5
    |
 LL |     println!("{:.p$}", local_i32, p = prec);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -736,7 +736,7 @@ LL +     println!("{local_i32:.prec$}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:110:5
+  --> $DIR/uninlined_format_args.rs:108:5
    |
 LL |     println!("{:0$.1$}", width, prec);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -748,7 +748,7 @@ LL +     println!("{width:width$.prec$}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:111:5
+  --> $DIR/uninlined_format_args.rs:109:5
    |
 LL |     println!("{:0$.w$}", width, w = prec);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -760,7 +760,7 @@ LL +     println!("{width:width$.prec$}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:112:5
+  --> $DIR/uninlined_format_args.rs:110:5
    |
 LL |     println!("{:1$.2$}", local_f64, width, prec);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -772,7 +772,7 @@ LL +     println!("{local_f64:width$.prec$}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:113:5
+  --> $DIR/uninlined_format_args.rs:111:5
    |
 LL |     println!("{:1$.2$} {0} {1} {2}", local_f64, width, prec);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -784,7 +784,7 @@ LL +     println!("{local_f64:width$.prec$} {local_f64} {width} {prec}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:114:5
+  --> $DIR/uninlined_format_args.rs:112:5
    |
 LL | /     println!(
 LL | |         "{0:1$.2$} {0:2$.1$} {1:0$.2$} {1:2$.0$} {2:0$.1$} {2:1$.0$}",
@@ -803,7 +803,7 @@ LL ~         "{0:1$.2$} {0:2$.1$} {1:0$.2$} {1:2$.0$} {2:0$.1$} {2:1$.0$}",
    |
 
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:125:5
+  --> $DIR/uninlined_format_args.rs:123:5
    |
 LL |     println!("Width = {}, value with width = {:0$}", local_i32, local_f64);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -815,7 +815,7 @@ LL +     println!("Width = {local_i32}, value with width = {local_f64:local_i32$
    |
 
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:126:5
+  --> $DIR/uninlined_format_args.rs:124:5
    |
 LL |     println!("{:w$.p$}", local_i32, w = width, p = prec);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -827,7 +827,7 @@ LL +     println!("{local_i32:width$.prec$}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:127:5
+  --> $DIR/uninlined_format_args.rs:125:5
    |
 LL |     println!("{:w$.p$}", w = width, p = prec);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -839,7 +839,7 @@ LL +     println!("{width:width$.prec$}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:128:20
+  --> $DIR/uninlined_format_args.rs:126:20
    |
 LL |     println!("{}", format!("{}", local_i32));
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -851,7 +851,35 @@ LL +     println!("{}", format!("{local_i32}"));
    |
 
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:166:5
+  --> $DIR/uninlined_format_args.rs:144:5
+   |
+LL | /     println!(
+LL | |         "{}",
+LL | |         // comment with a comma , in it
+LL | |         val,
+LL | |     );
+   | |_____^
+   |
+help: change this to
+   |
+LL -         "{}",
+LL +         "{val}",
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:149:5
+   |
+LL |     println!("{}", /* comment with a comma , in it */ val);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{}", /* comment with a comma , in it */ val);
+LL +     println!("{val}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:168:5
    |
 LL |     println!("expand='{}'", local_i32);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -862,5 +890,5 @@ LL -     println!("expand='{}'", local_i32);
 LL +     println!("expand='{local_i32}'");
    |
 
-error: aborting due to 71 previous errors
+error: aborting due to 73 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 9e70a0ff12547f0764041c9cff8adf617d7762c5 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Wed, 5 Oct 2022 17:17:57 +0000
Subject: Replace if_chain with let chains in `clippy::author` output

---
 clippy_lints/src/utils/author.rs  | 117 +++++++++++-----------
 tests/ui/author.stdout            |  24 +++--
 tests/ui/author/blocks.stdout     | 116 +++++++++++-----------
 tests/ui/author/call.stdout       |  28 +++---
 tests/ui/author/if.stdout         |  92 +++++++++--------
 tests/ui/author/issue_3849.stdout |  24 +++--
 tests/ui/author/loop.stdout       | 202 ++++++++++++++++++--------------------
 tests/ui/author/matches.stdout    |  72 +++++++-------
 tests/ui/author/repeat.stdout     |  20 ++--
 tests/ui/author/struct.stdout     | 112 ++++++++++-----------
 10 files changed, 387 insertions(+), 420 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/author.rs b/clippy_lints/src/utils/author.rs
index e069de8cb5c..0c052d86eda 100644
--- a/clippy_lints/src/utils/author.rs
+++ b/clippy_lints/src/utils/author.rs
@@ -12,6 +12,7 @@ use rustc_hir::{
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::symbol::{Ident, Symbol};
+use std::cell::Cell;
 use std::fmt::{Display, Formatter, Write as _};
 
 declare_clippy_lint! {
@@ -37,15 +38,13 @@ declare_clippy_lint! {
     ///
     /// ```rust,ignore
     /// // ./tests/ui/new_lint.stdout
-    /// if_chain! {
-    ///     if let ExprKind::If(ref cond, ref then, None) = item.kind,
-    ///     if let ExprKind::Binary(BinOp::Eq, ref left, ref right) = cond.kind,
-    ///     if let ExprKind::Path(ref path) = left.kind,
-    ///     if let ExprKind::Lit(ref lit) = right.kind,
-    ///     if let LitKind::Int(42, _) = lit.node,
-    ///     then {
-    ///         // report your lint here
-    ///     }
+    /// if ExprKind::If(ref cond, ref then, None) = item.kind
+    ///     && let ExprKind::Binary(BinOp::Eq, ref left, ref right) = cond.kind
+    ///     && let ExprKind::Path(ref path) = left.kind
+    ///     && let ExprKind::Lit(ref lit) = right.kind
+    ///     && let LitKind::Int(42, _) = lit.node
+    /// {
+    ///     // report your lint here
     /// }
     /// ```
     pub LINT_AUTHOR,
@@ -91,15 +90,16 @@ macro_rules! field {
     };
 }
 
-fn prelude() {
-    println!("if_chain! {{");
-}
-
-fn done() {
-    println!("    then {{");
-    println!("        // report your lint here");
-    println!("    }}");
-    println!("}}");
+/// Print a condition of a let chain, `chain!(self, "let Some(x) = y")` will print
+/// `if let Some(x) = y` on the first call and `    && let Some(x) = y` thereafter
+macro_rules! chain {
+    ($self:ident, $($t:tt)*) => {
+        if $self.first.take() {
+            println!("if {}", format_args!($($t)*));
+        } else {
+            println!("    && {}", format_args!($($t)*));
+        }
+    }
 }
 
 impl<'tcx> LateLintPass<'tcx> for Author {
@@ -149,9 +149,10 @@ fn check_item(cx: &LateContext<'_>, hir_id: HirId) {
 
 fn check_node(cx: &LateContext<'_>, hir_id: HirId, f: impl Fn(&PrintVisitor<'_, '_>)) {
     if has_attr(cx, hir_id) {
-        prelude();
         f(&PrintVisitor::new(cx));
-        done();
+        println!("{{");
+        println!("    // report your lint here");
+        println!("}}");
     }
 }
 
@@ -195,7 +196,9 @@ struct PrintVisitor<'a, 'tcx> {
     cx: &'a LateContext<'tcx>,
     /// Fields are the current index that needs to be appended to pattern
     /// binding names
-    ids: std::cell::Cell<FxHashMap<&'static str, u32>>,
+    ids: Cell<FxHashMap<&'static str, u32>>,
+    /// Currently at the first condition in the if chain
+    first: Cell<bool>,
 }
 
 #[allow(clippy::unused_self)]
@@ -203,7 +206,8 @@ impl<'a, 'tcx> PrintVisitor<'a, 'tcx> {
     fn new(cx: &'a LateContext<'tcx>) -> Self {
         Self {
             cx,
-            ids: std::cell::Cell::default(),
+            ids: Cell::default(),
+            first: Cell::new(true),
         }
     }
 
@@ -226,10 +230,10 @@ impl<'a, 'tcx> PrintVisitor<'a, 'tcx> {
 
     fn option<T: Copy>(&self, option: &Binding<Option<T>>, name: &'static str, f: impl Fn(&Binding<T>)) {
         match option.value {
-            None => out!("if {option}.is_none();"),
+            None => chain!(self, "{option}.is_none()"),
             Some(value) => {
                 let value = &self.bind(name, value);
-                out!("if let Some({value}) = {option};");
+                chain!(self, "let Some({value}) = {option}");
                 f(value);
             },
         }
@@ -237,9 +241,9 @@ impl<'a, 'tcx> PrintVisitor<'a, 'tcx> {
 
     fn slice<T>(&self, slice: &Binding<&[T]>, f: impl Fn(&Binding<&T>)) {
         if slice.value.is_empty() {
-            out!("if {slice}.is_empty();");
+            chain!(self, "{slice}.is_empty()");
         } else {
-            out!("if {slice}.len() == {};", slice.value.len());
+            chain!(self, "{slice}.len() == {}", slice.value.len());
             for (i, value) in slice.value.iter().enumerate() {
                 let name = format!("{slice}[{i}]");
                 f(&Binding { name, value });
@@ -254,23 +258,23 @@ impl<'a, 'tcx> PrintVisitor<'a, 'tcx> {
     }
 
     fn ident(&self, ident: &Binding<Ident>) {
-        out!("if {ident}.as_str() == {:?};", ident.value.as_str());
+        chain!(self, "{ident}.as_str() == {:?}", ident.value.as_str());
     }
 
     fn symbol(&self, symbol: &Binding<Symbol>) {
-        out!("if {symbol}.as_str() == {:?};", symbol.value.as_str());
+        chain!(self, "{symbol}.as_str() == {:?}", symbol.value.as_str());
     }
 
     fn qpath(&self, qpath: &Binding<&QPath<'_>>) {
         if let QPath::LangItem(lang_item, ..) = *qpath.value {
-            out!("if matches!({qpath}, QPath::LangItem(LangItem::{lang_item:?}, _));");
+            chain!(self, "matches!({qpath}, QPath::LangItem(LangItem::{lang_item:?}, _))");
         } else {
-            out!("if match_qpath({qpath}, &[{}]);", path_to_string(qpath.value));
+            chain!(self, "match_qpath({qpath}, &[{}])", path_to_string(qpath.value));
         }
     }
 
     fn lit(&self, lit: &Binding<&Lit>) {
-        let kind = |kind| out!("if let LitKind::{kind} = {lit}.node;");
+        let kind = |kind| chain!(self, "let LitKind::{kind} = {lit}.node");
         macro_rules! kind {
             ($($t:tt)*) => (kind(format_args!($($t)*)));
         }
@@ -298,7 +302,7 @@ impl<'a, 'tcx> PrintVisitor<'a, 'tcx> {
             LitKind::ByteStr(ref vec) => {
                 bind!(self, vec);
                 kind!("ByteStr(ref {vec})");
-                out!("if let [{:?}] = **{vec};", vec.value);
+                chain!(self, "let [{:?}] = **{vec}", vec.value);
             },
             LitKind::Str(s, _) => {
                 bind!(self, s);
@@ -311,15 +315,15 @@ impl<'a, 'tcx> PrintVisitor<'a, 'tcx> {
     fn arm(&self, arm: &Binding<&hir::Arm<'_>>) {
         self.pat(field!(arm.pat));
         match arm.value.guard {
-            None => out!("if {arm}.guard.is_none();"),
+            None => chain!(self, "{arm}.guard.is_none()"),
             Some(hir::Guard::If(expr)) => {
                 bind!(self, expr);
-                out!("if let Some(Guard::If({expr})) = {arm}.guard;");
+                chain!(self, "let Some(Guard::If({expr})) = {arm}.guard");
                 self.expr(expr);
             },
             Some(hir::Guard::IfLet(let_expr)) => {
                 bind!(self, let_expr);
-                out!("if let Some(Guard::IfLet({let_expr}) = {arm}.guard;");
+                chain!(self, "let Some(Guard::IfLet({let_expr}) = {arm}.guard");
                 self.pat(field!(let_expr.pat));
                 self.expr(field!(let_expr.init));
             },
@@ -331,9 +335,10 @@ impl<'a, 'tcx> PrintVisitor<'a, 'tcx> {
     fn expr(&self, expr: &Binding<&hir::Expr<'_>>) {
         if let Some(higher::While { condition, body }) = higher::While::hir(expr.value) {
             bind!(self, condition, body);
-            out!(
-                "if let Some(higher::While {{ condition: {condition}, body: {body} }}) \
-                = higher::While::hir({expr});"
+            chain!(
+                self,
+                "let Some(higher::While {{ condition: {condition}, body: {body} }}) \
+                = higher::While::hir({expr})"
             );
             self.expr(condition);
             self.expr(body);
@@ -347,9 +352,10 @@ impl<'a, 'tcx> PrintVisitor<'a, 'tcx> {
         }) = higher::WhileLet::hir(expr.value)
         {
             bind!(self, let_pat, let_expr, if_then);
-            out!(
-                "if let Some(higher::WhileLet {{ let_pat: {let_pat}, let_expr: {let_expr}, if_then: {if_then} }}) \
-                = higher::WhileLet::hir({expr});"
+            chain!(
+                self,
+                "let Some(higher::WhileLet {{ let_pat: {let_pat}, let_expr: {let_expr}, if_then: {if_then} }}) \
+                = higher::WhileLet::hir({expr})"
             );
             self.pat(let_pat);
             self.expr(let_expr);
@@ -359,9 +365,10 @@ impl<'a, 'tcx> PrintVisitor<'a, 'tcx> {
 
         if let Some(higher::ForLoop { pat, arg, body, .. }) = higher::ForLoop::hir(expr.value) {
             bind!(self, pat, arg, body);
-            out!(
-                "if let Some(higher::ForLoop {{ pat: {pat}, arg: {arg}, body: {body}, .. }}) \
-                = higher::ForLoop::hir({expr});"
+            chain!(
+                self,
+                "let Some(higher::ForLoop {{ pat: {pat}, arg: {arg}, body: {body}, .. }}) \
+                = higher::ForLoop::hir({expr})"
             );
             self.pat(pat);
             self.expr(arg);
@@ -369,7 +376,7 @@ impl<'a, 'tcx> PrintVisitor<'a, 'tcx> {
             return;
         }
 
-        let kind = |kind| out!("if let ExprKind::{kind} = {expr}.kind;");
+        let kind = |kind| chain!(self, "let ExprKind::{kind} = {expr}.kind");
         macro_rules! kind {
             ($($t:tt)*) => (kind(format_args!($($t)*)));
         }
@@ -383,7 +390,7 @@ impl<'a, 'tcx> PrintVisitor<'a, 'tcx> {
                 // if it's a path
                 if let Some(TyKind::Path(ref qpath)) = let_expr.value.ty.as_ref().map(|ty| &ty.kind) {
                     bind!(self, qpath);
-                    out!("if let TyKind::Path(ref {qpath}) = {let_expr}.ty.kind;");
+                    chain!(self, "let TyKind::Path(ref {qpath}) = {let_expr}.ty.kind");
                     self.qpath(qpath);
                 }
                 self.expr(field!(let_expr.init));
@@ -419,7 +426,7 @@ impl<'a, 'tcx> PrintVisitor<'a, 'tcx> {
             ExprKind::Binary(op, left, right) => {
                 bind!(self, op, left, right);
                 kind!("Binary({op}, {left}, {right})");
-                out!("if BinOpKind::{:?} == {op}.node;", op.value.node);
+                chain!(self, "BinOpKind::{:?} == {op}.node", op.value.node);
                 self.expr(left);
                 self.expr(right);
             },
@@ -438,7 +445,7 @@ impl<'a, 'tcx> PrintVisitor<'a, 'tcx> {
                 kind!("Cast({expr}, {cast_ty})");
                 if let TyKind::Path(ref qpath) = cast_ty.value.kind {
                     bind!(self, qpath);
-                    out!("if let TyKind::Path(ref {qpath}) = {cast_ty}.kind;");
+                    chain!(self, "let TyKind::Path(ref {qpath}) = {cast_ty}.kind");
                     self.qpath(qpath);
                 }
                 self.expr(expr);
@@ -485,7 +492,7 @@ impl<'a, 'tcx> PrintVisitor<'a, 'tcx> {
 
                 bind!(self, fn_decl, body_id);
                 kind!("Closure(CaptureBy::{capture_clause:?}, {fn_decl}, {body_id}, _, {movability})");
-                out!("if let {ret_ty} = {fn_decl}.output;");
+                chain!(self, "let {ret_ty} = {fn_decl}.output");
                 self.body(body_id);
             },
             ExprKind::Yield(sub, source) => {
@@ -509,7 +516,7 @@ impl<'a, 'tcx> PrintVisitor<'a, 'tcx> {
             ExprKind::AssignOp(op, target, value) => {
                 bind!(self, op, target, value);
                 kind!("AssignOp({op}, {target}, {value})");
-                out!("if BinOpKind::{:?} == {op}.node;", op.value.node);
+                chain!(self, "BinOpKind::{:?} == {op}.node", op.value.node);
                 self.expr(target);
                 self.expr(value);
             },
@@ -573,10 +580,10 @@ impl<'a, 'tcx> PrintVisitor<'a, 'tcx> {
                 kind!("Repeat({value}, {length})");
                 self.expr(value);
                 match length.value {
-                    ArrayLen::Infer(..) => out!("if let ArrayLen::Infer(..) = length;"),
+                    ArrayLen::Infer(..) => chain!(self, "let ArrayLen::Infer(..) = length"),
                     ArrayLen::Body(anon_const) => {
                         bind!(self, anon_const);
-                        out!("if let ArrayLen::Body({anon_const}) = {length};");
+                        chain!(self, "let ArrayLen::Body({anon_const}) = {length}");
                         self.body(field!(anon_const.body));
                     },
                 }
@@ -600,12 +607,12 @@ impl<'a, 'tcx> PrintVisitor<'a, 'tcx> {
     fn body(&self, body_id: &Binding<hir::BodyId>) {
         let expr = self.cx.tcx.hir().body(body_id.value).value;
         bind!(self, expr);
-        out!("let {expr} = &cx.tcx.hir().body({body_id}).value;");
+        chain!(self, "{expr} = &cx.tcx.hir().body({body_id}).value");
         self.expr(expr);
     }
 
     fn pat(&self, pat: &Binding<&hir::Pat<'_>>) {
-        let kind = |kind| out!("if let PatKind::{kind} = {pat}.kind;");
+        let kind = |kind| chain!(self, "let PatKind::{kind} = {pat}.kind");
         macro_rules! kind {
             ($($t:tt)*) => (kind(format_args!($($t)*)));
         }
@@ -688,7 +695,7 @@ impl<'a, 'tcx> PrintVisitor<'a, 'tcx> {
     }
 
     fn stmt(&self, stmt: &Binding<&hir::Stmt<'_>>) {
-        let kind = |kind| out!("if let StmtKind::{kind} = {stmt}.kind;");
+        let kind = |kind| chain!(self, "let StmtKind::{kind} = {stmt}.kind");
         macro_rules! kind {
             ($($t:tt)*) => (kind(format_args!($($t)*)));
         }
diff --git a/tests/ui/author.stdout b/tests/ui/author.stdout
index 597318a556b..27ad538f24d 100644
--- a/tests/ui/author.stdout
+++ b/tests/ui/author.stdout
@@ -1,14 +1,12 @@
-if_chain! {
-    if let StmtKind::Local(local) = stmt.kind;
-    if let Some(init) = local.init;
-    if let ExprKind::Cast(expr, cast_ty) = init.kind;
-    if let TyKind::Path(ref qpath) = cast_ty.kind;
-    if match_qpath(qpath, &["char"]);
-    if let ExprKind::Lit(ref lit) = expr.kind;
-    if let LitKind::Int(69, LitIntType::Unsuffixed) = lit.node;
-    if let PatKind::Binding(BindingAnnotation::NONE, _, name, None) = local.pat.kind;
-    if name.as_str() == "x";
-    then {
-        // report your lint here
-    }
+if let StmtKind::Local(local) = stmt.kind
+    && let Some(init) = local.init
+    && let ExprKind::Cast(expr, cast_ty) = init.kind
+    && let TyKind::Path(ref qpath) = cast_ty.kind
+    && match_qpath(qpath, &["char"])
+    && let ExprKind::Lit(ref lit) = expr.kind
+    && let LitKind::Int(69, LitIntType::Unsuffixed) = lit.node
+    && let PatKind::Binding(BindingAnnotation::NONE, _, name, None) = local.pat.kind
+    && name.as_str() == "x"
+{
+    // report your lint here
 }
diff --git a/tests/ui/author/blocks.stdout b/tests/ui/author/blocks.stdout
index a529981e2e6..9de0550d81d 100644
--- a/tests/ui/author/blocks.stdout
+++ b/tests/ui/author/blocks.stdout
@@ -1,64 +1,58 @@
-if_chain! {
-    if let ExprKind::Block(block, None) = expr.kind;
-    if block.stmts.len() == 3;
-    if let StmtKind::Local(local) = block.stmts[0].kind;
-    if let Some(init) = local.init;
-    if let ExprKind::Lit(ref lit) = init.kind;
-    if let LitKind::Int(42, LitIntType::Signed(IntTy::I32)) = lit.node;
-    if let PatKind::Binding(BindingAnnotation::NONE, _, name, None) = local.pat.kind;
-    if name.as_str() == "x";
-    if let StmtKind::Local(local1) = block.stmts[1].kind;
-    if let Some(init1) = local1.init;
-    if let ExprKind::Lit(ref lit1) = init1.kind;
-    if let LitKind::Float(_, LitFloatType::Suffixed(FloatTy::F32)) = lit1.node;
-    if let PatKind::Binding(BindingAnnotation::NONE, _, name1, None) = local1.pat.kind;
-    if name1.as_str() == "_t";
-    if let StmtKind::Semi(e) = block.stmts[2].kind;
-    if let ExprKind::Unary(UnOp::Neg, inner) = e.kind;
-    if let ExprKind::Path(ref qpath) = inner.kind;
-    if match_qpath(qpath, &["x"]);
-    if block.expr.is_none();
-    then {
-        // report your lint here
-    }
+if let ExprKind::Block(block, None) = expr.kind
+    && block.stmts.len() == 3
+    && let StmtKind::Local(local) = block.stmts[0].kind
+    && let Some(init) = local.init
+    && let ExprKind::Lit(ref lit) = init.kind
+    && let LitKind::Int(42, LitIntType::Signed(IntTy::I32)) = lit.node
+    && let PatKind::Binding(BindingAnnotation::NONE, _, name, None) = local.pat.kind
+    && name.as_str() == "x"
+    && let StmtKind::Local(local1) = block.stmts[1].kind
+    && let Some(init1) = local1.init
+    && let ExprKind::Lit(ref lit1) = init1.kind
+    && let LitKind::Float(_, LitFloatType::Suffixed(FloatTy::F32)) = lit1.node
+    && let PatKind::Binding(BindingAnnotation::NONE, _, name1, None) = local1.pat.kind
+    && name1.as_str() == "_t"
+    && let StmtKind::Semi(e) = block.stmts[2].kind
+    && let ExprKind::Unary(UnOp::Neg, inner) = e.kind
+    && let ExprKind::Path(ref qpath) = inner.kind
+    && match_qpath(qpath, &["x"])
+    && block.expr.is_none()
+{
+    // report your lint here
 }
-if_chain! {
-    if let ExprKind::Block(block, None) = expr.kind;
-    if block.stmts.len() == 1;
-    if let StmtKind::Local(local) = block.stmts[0].kind;
-    if let Some(init) = local.init;
-    if let ExprKind::Call(func, args) = init.kind;
-    if let ExprKind::Path(ref qpath) = func.kind;
-    if match_qpath(qpath, &["String", "new"]);
-    if args.is_empty();
-    if let PatKind::Binding(BindingAnnotation::NONE, _, name, None) = local.pat.kind;
-    if name.as_str() == "expr";
-    if let Some(trailing_expr) = block.expr;
-    if let ExprKind::Call(func1, args1) = trailing_expr.kind;
-    if let ExprKind::Path(ref qpath1) = func1.kind;
-    if match_qpath(qpath1, &["drop"]);
-    if args1.len() == 1;
-    if let ExprKind::Path(ref qpath2) = args1[0].kind;
-    if match_qpath(qpath2, &["expr"]);
-    then {
-        // report your lint here
-    }
+if let ExprKind::Block(block, None) = expr.kind
+    && block.stmts.len() == 1
+    && let StmtKind::Local(local) = block.stmts[0].kind
+    && let Some(init) = local.init
+    && let ExprKind::Call(func, args) = init.kind
+    && let ExprKind::Path(ref qpath) = func.kind
+    && match_qpath(qpath, &["String", "new"])
+    && args.is_empty()
+    && let PatKind::Binding(BindingAnnotation::NONE, _, name, None) = local.pat.kind
+    && name.as_str() == "expr"
+    && let Some(trailing_expr) = block.expr
+    && let ExprKind::Call(func1, args1) = trailing_expr.kind
+    && let ExprKind::Path(ref qpath1) = func1.kind
+    && match_qpath(qpath1, &["drop"])
+    && args1.len() == 1
+    && let ExprKind::Path(ref qpath2) = args1[0].kind
+    && match_qpath(qpath2, &["expr"])
+{
+    // report your lint here
 }
-if_chain! {
-    if let ExprKind::Closure(CaptureBy::Value, fn_decl, body_id, _, None) = expr.kind;
-    if let FnRetTy::DefaultReturn(_) = fn_decl.output;
-    let expr1 = &cx.tcx.hir().body(body_id).value;
-    if let ExprKind::Call(func, args) = expr1.kind;
-    if let ExprKind::Path(ref qpath) = func.kind;
-    if matches!(qpath, QPath::LangItem(LangItem::FromGenerator, _));
-    if args.len() == 1;
-    if let ExprKind::Closure(CaptureBy::Value, fn_decl1, body_id1, _, Some(Movability::Static)) = args[0].kind;
-    if let FnRetTy::DefaultReturn(_) = fn_decl1.output;
-    let expr2 = &cx.tcx.hir().body(body_id1).value;
-    if let ExprKind::Block(block, None) = expr2.kind;
-    if block.stmts.is_empty();
-    if block.expr.is_none();
-    then {
-        // report your lint here
-    }
+if let ExprKind::Closure(CaptureBy::Value, fn_decl, body_id, _, None) = expr.kind
+    && let FnRetTy::DefaultReturn(_) = fn_decl.output
+    && expr1 = &cx.tcx.hir().body(body_id).value
+    && let ExprKind::Call(func, args) = expr1.kind
+    && let ExprKind::Path(ref qpath) = func.kind
+    && matches!(qpath, QPath::LangItem(LangItem::FromGenerator, _))
+    && args.len() == 1
+    && let ExprKind::Closure(CaptureBy::Value, fn_decl1, body_id1, _, Some(Movability::Static)) = args[0].kind
+    && let FnRetTy::DefaultReturn(_) = fn_decl1.output
+    && expr2 = &cx.tcx.hir().body(body_id1).value
+    && let ExprKind::Block(block, None) = expr2.kind
+    && block.stmts.is_empty()
+    && block.expr.is_none()
+{
+    // report your lint here
 }
diff --git a/tests/ui/author/call.stdout b/tests/ui/author/call.stdout
index 266312d63e5..f040f6330a6 100644
--- a/tests/ui/author/call.stdout
+++ b/tests/ui/author/call.stdout
@@ -1,16 +1,14 @@
-if_chain! {
-    if let StmtKind::Local(local) = stmt.kind;
-    if let Some(init) = local.init;
-    if let ExprKind::Call(func, args) = init.kind;
-    if let ExprKind::Path(ref qpath) = func.kind;
-    if match_qpath(qpath, &["{{root}}", "std", "cmp", "min"]);
-    if args.len() == 2;
-    if let ExprKind::Lit(ref lit) = args[0].kind;
-    if let LitKind::Int(3, LitIntType::Unsuffixed) = lit.node;
-    if let ExprKind::Lit(ref lit1) = args[1].kind;
-    if let LitKind::Int(4, LitIntType::Unsuffixed) = lit1.node;
-    if let PatKind::Wild = local.pat.kind;
-    then {
-        // report your lint here
-    }
+if let StmtKind::Local(local) = stmt.kind
+    && let Some(init) = local.init
+    && let ExprKind::Call(func, args) = init.kind
+    && let ExprKind::Path(ref qpath) = func.kind
+    && match_qpath(qpath, &["{{root}}", "std", "cmp", "min"])
+    && args.len() == 2
+    && let ExprKind::Lit(ref lit) = args[0].kind
+    && let LitKind::Int(3, LitIntType::Unsuffixed) = lit.node
+    && let ExprKind::Lit(ref lit1) = args[1].kind
+    && let LitKind::Int(4, LitIntType::Unsuffixed) = lit1.node
+    && let PatKind::Wild = local.pat.kind
+{
+    // report your lint here
 }
diff --git a/tests/ui/author/if.stdout b/tests/ui/author/if.stdout
index 8d92849b366..5d79618820d 100644
--- a/tests/ui/author/if.stdout
+++ b/tests/ui/author/if.stdout
@@ -1,50 +1,46 @@
-if_chain! {
-    if let StmtKind::Local(local) = stmt.kind;
-    if let Some(init) = local.init;
-    if let ExprKind::If(cond, then, Some(else_expr)) = init.kind;
-    if let ExprKind::DropTemps(expr) = cond.kind;
-    if let ExprKind::Lit(ref lit) = expr.kind;
-    if let LitKind::Bool(true) = lit.node;
-    if let ExprKind::Block(block, None) = then.kind;
-    if block.stmts.len() == 1;
-    if let StmtKind::Semi(e) = block.stmts[0].kind;
-    if let ExprKind::Binary(op, left, right) = e.kind;
-    if BinOpKind::Eq == op.node;
-    if let ExprKind::Lit(ref lit1) = left.kind;
-    if let LitKind::Int(1, LitIntType::Unsuffixed) = lit1.node;
-    if let ExprKind::Lit(ref lit2) = right.kind;
-    if let LitKind::Int(1, LitIntType::Unsuffixed) = lit2.node;
-    if block.expr.is_none();
-    if let ExprKind::Block(block1, None) = else_expr.kind;
-    if block1.stmts.len() == 1;
-    if let StmtKind::Semi(e1) = block1.stmts[0].kind;
-    if let ExprKind::Binary(op1, left1, right1) = e1.kind;
-    if BinOpKind::Eq == op1.node;
-    if let ExprKind::Lit(ref lit3) = left1.kind;
-    if let LitKind::Int(2, LitIntType::Unsuffixed) = lit3.node;
-    if let ExprKind::Lit(ref lit4) = right1.kind;
-    if let LitKind::Int(2, LitIntType::Unsuffixed) = lit4.node;
-    if block1.expr.is_none();
-    if let PatKind::Wild = local.pat.kind;
-    then {
-        // report your lint here
-    }
+if let StmtKind::Local(local) = stmt.kind
+    && let Some(init) = local.init
+    && let ExprKind::If(cond, then, Some(else_expr)) = init.kind
+    && let ExprKind::DropTemps(expr) = cond.kind
+    && let ExprKind::Lit(ref lit) = expr.kind
+    && let LitKind::Bool(true) = lit.node
+    && let ExprKind::Block(block, None) = then.kind
+    && block.stmts.len() == 1
+    && let StmtKind::Semi(e) = block.stmts[0].kind
+    && let ExprKind::Binary(op, left, right) = e.kind
+    && BinOpKind::Eq == op.node
+    && let ExprKind::Lit(ref lit1) = left.kind
+    && let LitKind::Int(1, LitIntType::Unsuffixed) = lit1.node
+    && let ExprKind::Lit(ref lit2) = right.kind
+    && let LitKind::Int(1, LitIntType::Unsuffixed) = lit2.node
+    && block.expr.is_none()
+    && let ExprKind::Block(block1, None) = else_expr.kind
+    && block1.stmts.len() == 1
+    && let StmtKind::Semi(e1) = block1.stmts[0].kind
+    && let ExprKind::Binary(op1, left1, right1) = e1.kind
+    && BinOpKind::Eq == op1.node
+    && let ExprKind::Lit(ref lit3) = left1.kind
+    && let LitKind::Int(2, LitIntType::Unsuffixed) = lit3.node
+    && let ExprKind::Lit(ref lit4) = right1.kind
+    && let LitKind::Int(2, LitIntType::Unsuffixed) = lit4.node
+    && block1.expr.is_none()
+    && let PatKind::Wild = local.pat.kind
+{
+    // report your lint here
 }
-if_chain! {
-    if let ExprKind::If(cond, then, Some(else_expr)) = expr.kind;
-    if let ExprKind::Let(let_expr) = cond.kind;
-    if let PatKind::Lit(lit_expr) = let_expr.pat.kind;
-    if let ExprKind::Lit(ref lit) = lit_expr.kind;
-    if let LitKind::Bool(true) = lit.node;
-    if let ExprKind::Path(ref qpath) = let_expr.init.kind;
-    if match_qpath(qpath, &["a"]);
-    if let ExprKind::Block(block, None) = then.kind;
-    if block.stmts.is_empty();
-    if block.expr.is_none();
-    if let ExprKind::Block(block1, None) = else_expr.kind;
-    if block1.stmts.is_empty();
-    if block1.expr.is_none();
-    then {
-        // report your lint here
-    }
+if let ExprKind::If(cond, then, Some(else_expr)) = expr.kind
+    && let ExprKind::Let(let_expr) = cond.kind
+    && let PatKind::Lit(lit_expr) = let_expr.pat.kind
+    && let ExprKind::Lit(ref lit) = lit_expr.kind
+    && let LitKind::Bool(true) = lit.node
+    && let ExprKind::Path(ref qpath) = let_expr.init.kind
+    && match_qpath(qpath, &["a"])
+    && let ExprKind::Block(block, None) = then.kind
+    && block.stmts.is_empty()
+    && block.expr.is_none()
+    && let ExprKind::Block(block1, None) = else_expr.kind
+    && block1.stmts.is_empty()
+    && block1.expr.is_none()
+{
+    // report your lint here
 }
diff --git a/tests/ui/author/issue_3849.stdout b/tests/ui/author/issue_3849.stdout
index bce4bc70273..32a3127b85a 100644
--- a/tests/ui/author/issue_3849.stdout
+++ b/tests/ui/author/issue_3849.stdout
@@ -1,14 +1,12 @@
-if_chain! {
-    if let StmtKind::Local(local) = stmt.kind;
-    if let Some(init) = local.init;
-    if let ExprKind::Call(func, args) = init.kind;
-    if let ExprKind::Path(ref qpath) = func.kind;
-    if match_qpath(qpath, &["std", "mem", "transmute"]);
-    if args.len() == 1;
-    if let ExprKind::Path(ref qpath1) = args[0].kind;
-    if match_qpath(qpath1, &["ZPTR"]);
-    if let PatKind::Wild = local.pat.kind;
-    then {
-        // report your lint here
-    }
+if let StmtKind::Local(local) = stmt.kind
+    && let Some(init) = local.init
+    && let ExprKind::Call(func, args) = init.kind
+    && let ExprKind::Path(ref qpath) = func.kind
+    && match_qpath(qpath, &["std", "mem", "transmute"])
+    && args.len() == 1
+    && let ExprKind::Path(ref qpath1) = args[0].kind
+    && match_qpath(qpath1, &["ZPTR"])
+    && let PatKind::Wild = local.pat.kind
+{
+    // report your lint here
 }
diff --git a/tests/ui/author/loop.stdout b/tests/ui/author/loop.stdout
index ceb53fcd496..94a6436ed54 100644
--- a/tests/ui/author/loop.stdout
+++ b/tests/ui/author/loop.stdout
@@ -1,113 +1,101 @@
-if_chain! {
-    if let Some(higher::ForLoop { pat: pat, arg: arg, body: body, .. }) = higher::ForLoop::hir(expr);
-    if let PatKind::Binding(BindingAnnotation::NONE, _, name, None) = pat.kind;
-    if name.as_str() == "y";
-    if let ExprKind::Struct(qpath, fields, None) = arg.kind;
-    if matches!(qpath, QPath::LangItem(LangItem::Range, _));
-    if fields.len() == 2;
-    if fields[0].ident.as_str() == "start";
-    if let ExprKind::Lit(ref lit) = fields[0].expr.kind;
-    if let LitKind::Int(0, LitIntType::Unsuffixed) = lit.node;
-    if fields[1].ident.as_str() == "end";
-    if let ExprKind::Lit(ref lit1) = fields[1].expr.kind;
-    if let LitKind::Int(10, LitIntType::Unsuffixed) = lit1.node;
-    if let ExprKind::Block(block, None) = body.kind;
-    if block.stmts.len() == 1;
-    if let StmtKind::Local(local) = block.stmts[0].kind;
-    if let Some(init) = local.init;
-    if let ExprKind::Path(ref qpath1) = init.kind;
-    if match_qpath(qpath1, &["y"]);
-    if let PatKind::Binding(BindingAnnotation::NONE, _, name1, None) = local.pat.kind;
-    if name1.as_str() == "z";
-    if block.expr.is_none();
-    then {
-        // report your lint here
-    }
+if let Some(higher::ForLoop { pat: pat, arg: arg, body: body, .. }) = higher::ForLoop::hir(expr)
+    && let PatKind::Binding(BindingAnnotation::NONE, _, name, None) = pat.kind
+    && name.as_str() == "y"
+    && let ExprKind::Struct(qpath, fields, None) = arg.kind
+    && matches!(qpath, QPath::LangItem(LangItem::Range, _))
+    && fields.len() == 2
+    && fields[0].ident.as_str() == "start"
+    && let ExprKind::Lit(ref lit) = fields[0].expr.kind
+    && let LitKind::Int(0, LitIntType::Unsuffixed) = lit.node
+    && fields[1].ident.as_str() == "end"
+    && let ExprKind::Lit(ref lit1) = fields[1].expr.kind
+    && let LitKind::Int(10, LitIntType::Unsuffixed) = lit1.node
+    && let ExprKind::Block(block, None) = body.kind
+    && block.stmts.len() == 1
+    && let StmtKind::Local(local) = block.stmts[0].kind
+    && let Some(init) = local.init
+    && let ExprKind::Path(ref qpath1) = init.kind
+    && match_qpath(qpath1, &["y"])
+    && let PatKind::Binding(BindingAnnotation::NONE, _, name1, None) = local.pat.kind
+    && name1.as_str() == "z"
+    && block.expr.is_none()
+{
+    // report your lint here
 }
-if_chain! {
-    if let Some(higher::ForLoop { pat: pat, arg: arg, body: body, .. }) = higher::ForLoop::hir(expr);
-    if let PatKind::Wild = pat.kind;
-    if let ExprKind::Struct(qpath, fields, None) = arg.kind;
-    if matches!(qpath, QPath::LangItem(LangItem::Range, _));
-    if fields.len() == 2;
-    if fields[0].ident.as_str() == "start";
-    if let ExprKind::Lit(ref lit) = fields[0].expr.kind;
-    if let LitKind::Int(0, LitIntType::Unsuffixed) = lit.node;
-    if fields[1].ident.as_str() == "end";
-    if let ExprKind::Lit(ref lit1) = fields[1].expr.kind;
-    if let LitKind::Int(10, LitIntType::Unsuffixed) = lit1.node;
-    if let ExprKind::Block(block, None) = body.kind;
-    if block.stmts.len() == 1;
-    if let StmtKind::Semi(e) = block.stmts[0].kind;
-    if let ExprKind::Break(destination, None) = e.kind;
-    if destination.label.is_none();
-    if block.expr.is_none();
-    then {
-        // report your lint here
-    }
+if let Some(higher::ForLoop { pat: pat, arg: arg, body: body, .. }) = higher::ForLoop::hir(expr)
+    && let PatKind::Wild = pat.kind
+    && let ExprKind::Struct(qpath, fields, None) = arg.kind
+    && matches!(qpath, QPath::LangItem(LangItem::Range, _))
+    && fields.len() == 2
+    && fields[0].ident.as_str() == "start"
+    && let ExprKind::Lit(ref lit) = fields[0].expr.kind
+    && let LitKind::Int(0, LitIntType::Unsuffixed) = lit.node
+    && fields[1].ident.as_str() == "end"
+    && let ExprKind::Lit(ref lit1) = fields[1].expr.kind
+    && let LitKind::Int(10, LitIntType::Unsuffixed) = lit1.node
+    && let ExprKind::Block(block, None) = body.kind
+    && block.stmts.len() == 1
+    && let StmtKind::Semi(e) = block.stmts[0].kind
+    && let ExprKind::Break(destination, None) = e.kind
+    && destination.label.is_none()
+    && block.expr.is_none()
+{
+    // report your lint here
 }
-if_chain! {
-    if let Some(higher::ForLoop { pat: pat, arg: arg, body: body, .. }) = higher::ForLoop::hir(expr);
-    if let PatKind::Wild = pat.kind;
-    if let ExprKind::Struct(qpath, fields, None) = arg.kind;
-    if matches!(qpath, QPath::LangItem(LangItem::Range, _));
-    if fields.len() == 2;
-    if fields[0].ident.as_str() == "start";
-    if let ExprKind::Lit(ref lit) = fields[0].expr.kind;
-    if let LitKind::Int(0, LitIntType::Unsuffixed) = lit.node;
-    if fields[1].ident.as_str() == "end";
-    if let ExprKind::Lit(ref lit1) = fields[1].expr.kind;
-    if let LitKind::Int(10, LitIntType::Unsuffixed) = lit1.node;
-    if let ExprKind::Block(block, None) = body.kind;
-    if block.stmts.len() == 1;
-    if let StmtKind::Semi(e) = block.stmts[0].kind;
-    if let ExprKind::Break(destination, None) = e.kind;
-    if let Some(label) = destination.label;
-    if label.ident.as_str() == "'label";
-    if block.expr.is_none();
-    then {
-        // report your lint here
-    }
+if let Some(higher::ForLoop { pat: pat, arg: arg, body: body, .. }) = higher::ForLoop::hir(expr)
+    && let PatKind::Wild = pat.kind
+    && let ExprKind::Struct(qpath, fields, None) = arg.kind
+    && matches!(qpath, QPath::LangItem(LangItem::Range, _))
+    && fields.len() == 2
+    && fields[0].ident.as_str() == "start"
+    && let ExprKind::Lit(ref lit) = fields[0].expr.kind
+    && let LitKind::Int(0, LitIntType::Unsuffixed) = lit.node
+    && fields[1].ident.as_str() == "end"
+    && let ExprKind::Lit(ref lit1) = fields[1].expr.kind
+    && let LitKind::Int(10, LitIntType::Unsuffixed) = lit1.node
+    && let ExprKind::Block(block, None) = body.kind
+    && block.stmts.len() == 1
+    && let StmtKind::Semi(e) = block.stmts[0].kind
+    && let ExprKind::Break(destination, None) = e.kind
+    && let Some(label) = destination.label
+    && label.ident.as_str() == "'label"
+    && block.expr.is_none()
+{
+    // report your lint here
 }
-if_chain! {
-    if let Some(higher::While { condition: condition, body: body }) = higher::While::hir(expr);
-    if let ExprKind::Path(ref qpath) = condition.kind;
-    if match_qpath(qpath, &["a"]);
-    if let ExprKind::Block(block, None) = body.kind;
-    if block.stmts.len() == 1;
-    if let StmtKind::Semi(e) = block.stmts[0].kind;
-    if let ExprKind::Break(destination, None) = e.kind;
-    if destination.label.is_none();
-    if block.expr.is_none();
-    then {
-        // report your lint here
-    }
+if let Some(higher::While { condition: condition, body: body }) = higher::While::hir(expr)
+    && let ExprKind::Path(ref qpath) = condition.kind
+    && match_qpath(qpath, &["a"])
+    && let ExprKind::Block(block, None) = body.kind
+    && block.stmts.len() == 1
+    && let StmtKind::Semi(e) = block.stmts[0].kind
+    && let ExprKind::Break(destination, None) = e.kind
+    && destination.label.is_none()
+    && block.expr.is_none()
+{
+    // report your lint here
 }
-if_chain! {
-    if let Some(higher::WhileLet { let_pat: let_pat, let_expr: let_expr, if_then: if_then }) = higher::WhileLet::hir(expr);
-    if let PatKind::Lit(lit_expr) = let_pat.kind;
-    if let ExprKind::Lit(ref lit) = lit_expr.kind;
-    if let LitKind::Bool(true) = lit.node;
-    if let ExprKind::Path(ref qpath) = let_expr.kind;
-    if match_qpath(qpath, &["a"]);
-    if let ExprKind::Block(block, None) = if_then.kind;
-    if block.stmts.len() == 1;
-    if let StmtKind::Semi(e) = block.stmts[0].kind;
-    if let ExprKind::Break(destination, None) = e.kind;
-    if destination.label.is_none();
-    if block.expr.is_none();
-    then {
-        // report your lint here
-    }
+if let Some(higher::WhileLet { let_pat: let_pat, let_expr: let_expr, if_then: if_then }) = higher::WhileLet::hir(expr)
+    && let PatKind::Lit(lit_expr) = let_pat.kind
+    && let ExprKind::Lit(ref lit) = lit_expr.kind
+    && let LitKind::Bool(true) = lit.node
+    && let ExprKind::Path(ref qpath) = let_expr.kind
+    && match_qpath(qpath, &["a"])
+    && let ExprKind::Block(block, None) = if_then.kind
+    && block.stmts.len() == 1
+    && let StmtKind::Semi(e) = block.stmts[0].kind
+    && let ExprKind::Break(destination, None) = e.kind
+    && destination.label.is_none()
+    && block.expr.is_none()
+{
+    // report your lint here
 }
-if_chain! {
-    if let ExprKind::Loop(body, None, LoopSource::Loop, _) = expr.kind;
-    if body.stmts.len() == 1;
-    if let StmtKind::Semi(e) = body.stmts[0].kind;
-    if let ExprKind::Break(destination, None) = e.kind;
-    if destination.label.is_none();
-    if body.expr.is_none();
-    then {
-        // report your lint here
-    }
+if let ExprKind::Loop(body, None, LoopSource::Loop, _) = expr.kind
+    && body.stmts.len() == 1
+    && let StmtKind::Semi(e) = body.stmts[0].kind
+    && let ExprKind::Break(destination, None) = e.kind
+    && destination.label.is_none()
+    && body.expr.is_none()
+{
+    // report your lint here
 }
diff --git a/tests/ui/author/matches.stdout b/tests/ui/author/matches.stdout
index 2cf69a035b4..88e2ca656a4 100644
--- a/tests/ui/author/matches.stdout
+++ b/tests/ui/author/matches.stdout
@@ -1,38 +1,36 @@
-if_chain! {
-    if let StmtKind::Local(local) = stmt.kind;
-    if let Some(init) = local.init;
-    if let ExprKind::Match(scrutinee, arms, MatchSource::Normal) = init.kind;
-    if let ExprKind::Lit(ref lit) = scrutinee.kind;
-    if let LitKind::Int(42, LitIntType::Unsuffixed) = lit.node;
-    if arms.len() == 3;
-    if let PatKind::Lit(lit_expr) = arms[0].pat.kind;
-    if let ExprKind::Lit(ref lit1) = lit_expr.kind;
-    if let LitKind::Int(16, LitIntType::Unsuffixed) = lit1.node;
-    if arms[0].guard.is_none();
-    if let ExprKind::Lit(ref lit2) = arms[0].body.kind;
-    if let LitKind::Int(5, LitIntType::Unsuffixed) = lit2.node;
-    if let PatKind::Lit(lit_expr1) = arms[1].pat.kind;
-    if let ExprKind::Lit(ref lit3) = lit_expr1.kind;
-    if let LitKind::Int(17, LitIntType::Unsuffixed) = lit3.node;
-    if arms[1].guard.is_none();
-    if let ExprKind::Block(block, None) = arms[1].body.kind;
-    if block.stmts.len() == 1;
-    if let StmtKind::Local(local1) = block.stmts[0].kind;
-    if let Some(init1) = local1.init;
-    if let ExprKind::Lit(ref lit4) = init1.kind;
-    if let LitKind::Int(3, LitIntType::Unsuffixed) = lit4.node;
-    if let PatKind::Binding(BindingAnnotation::NONE, _, name, None) = local1.pat.kind;
-    if name.as_str() == "x";
-    if let Some(trailing_expr) = block.expr;
-    if let ExprKind::Path(ref qpath) = trailing_expr.kind;
-    if match_qpath(qpath, &["x"]);
-    if let PatKind::Wild = arms[2].pat.kind;
-    if arms[2].guard.is_none();
-    if let ExprKind::Lit(ref lit5) = arms[2].body.kind;
-    if let LitKind::Int(1, LitIntType::Unsuffixed) = lit5.node;
-    if let PatKind::Binding(BindingAnnotation::NONE, _, name1, None) = local.pat.kind;
-    if name1.as_str() == "a";
-    then {
-        // report your lint here
-    }
+if let StmtKind::Local(local) = stmt.kind
+    && let Some(init) = local.init
+    && let ExprKind::Match(scrutinee, arms, MatchSource::Normal) = init.kind
+    && let ExprKind::Lit(ref lit) = scrutinee.kind
+    && let LitKind::Int(42, LitIntType::Unsuffixed) = lit.node
+    && arms.len() == 3
+    && let PatKind::Lit(lit_expr) = arms[0].pat.kind
+    && let ExprKind::Lit(ref lit1) = lit_expr.kind
+    && let LitKind::Int(16, LitIntType::Unsuffixed) = lit1.node
+    && arms[0].guard.is_none()
+    && let ExprKind::Lit(ref lit2) = arms[0].body.kind
+    && let LitKind::Int(5, LitIntType::Unsuffixed) = lit2.node
+    && let PatKind::Lit(lit_expr1) = arms[1].pat.kind
+    && let ExprKind::Lit(ref lit3) = lit_expr1.kind
+    && let LitKind::Int(17, LitIntType::Unsuffixed) = lit3.node
+    && arms[1].guard.is_none()
+    && let ExprKind::Block(block, None) = arms[1].body.kind
+    && block.stmts.len() == 1
+    && let StmtKind::Local(local1) = block.stmts[0].kind
+    && let Some(init1) = local1.init
+    && let ExprKind::Lit(ref lit4) = init1.kind
+    && let LitKind::Int(3, LitIntType::Unsuffixed) = lit4.node
+    && let PatKind::Binding(BindingAnnotation::NONE, _, name, None) = local1.pat.kind
+    && name.as_str() == "x"
+    && let Some(trailing_expr) = block.expr
+    && let ExprKind::Path(ref qpath) = trailing_expr.kind
+    && match_qpath(qpath, &["x"])
+    && let PatKind::Wild = arms[2].pat.kind
+    && arms[2].guard.is_none()
+    && let ExprKind::Lit(ref lit5) = arms[2].body.kind
+    && let LitKind::Int(1, LitIntType::Unsuffixed) = lit5.node
+    && let PatKind::Binding(BindingAnnotation::NONE, _, name1, None) = local.pat.kind
+    && name1.as_str() == "a"
+{
+    // report your lint here
 }
diff --git a/tests/ui/author/repeat.stdout b/tests/ui/author/repeat.stdout
index 471bbce4f41..c2a369610cc 100644
--- a/tests/ui/author/repeat.stdout
+++ b/tests/ui/author/repeat.stdout
@@ -1,12 +1,10 @@
-if_chain! {
-    if let ExprKind::Repeat(value, length) = expr.kind;
-    if let ExprKind::Lit(ref lit) = value.kind;
-    if let LitKind::Int(1, LitIntType::Unsigned(UintTy::U8)) = lit.node;
-    if let ArrayLen::Body(anon_const) = length;
-    let expr1 = &cx.tcx.hir().body(anon_const.body).value;
-    if let ExprKind::Lit(ref lit1) = expr1.kind;
-    if let LitKind::Int(5, LitIntType::Unsuffixed) = lit1.node;
-    then {
-        // report your lint here
-    }
+if let ExprKind::Repeat(value, length) = expr.kind
+    && let ExprKind::Lit(ref lit) = value.kind
+    && let LitKind::Int(1, LitIntType::Unsigned(UintTy::U8)) = lit.node
+    && let ArrayLen::Body(anon_const) = length
+    && expr1 = &cx.tcx.hir().body(anon_const.body).value
+    && let ExprKind::Lit(ref lit1) = expr1.kind
+    && let LitKind::Int(5, LitIntType::Unsuffixed) = lit1.node
+{
+    // report your lint here
 }
diff --git a/tests/ui/author/struct.stdout b/tests/ui/author/struct.stdout
index b5bbc9e213c..0b332d5e7d0 100644
--- a/tests/ui/author/struct.stdout
+++ b/tests/ui/author/struct.stdout
@@ -1,64 +1,56 @@
-if_chain! {
-    if let ExprKind::Struct(qpath, fields, None) = expr.kind;
-    if match_qpath(qpath, &["Test"]);
-    if fields.len() == 1;
-    if fields[0].ident.as_str() == "field";
-    if let ExprKind::If(cond, then, Some(else_expr)) = fields[0].expr.kind;
-    if let ExprKind::DropTemps(expr1) = cond.kind;
-    if let ExprKind::Lit(ref lit) = expr1.kind;
-    if let LitKind::Bool(true) = lit.node;
-    if let ExprKind::Block(block, None) = then.kind;
-    if block.stmts.is_empty();
-    if let Some(trailing_expr) = block.expr;
-    if let ExprKind::Lit(ref lit1) = trailing_expr.kind;
-    if let LitKind::Int(1, LitIntType::Unsuffixed) = lit1.node;
-    if let ExprKind::Block(block1, None) = else_expr.kind;
-    if block1.stmts.is_empty();
-    if let Some(trailing_expr1) = block1.expr;
-    if let ExprKind::Lit(ref lit2) = trailing_expr1.kind;
-    if let LitKind::Int(0, LitIntType::Unsuffixed) = lit2.node;
-    then {
-        // report your lint here
-    }
+if let ExprKind::Struct(qpath, fields, None) = expr.kind
+    && match_qpath(qpath, &["Test"])
+    && fields.len() == 1
+    && fields[0].ident.as_str() == "field"
+    && let ExprKind::If(cond, then, Some(else_expr)) = fields[0].expr.kind
+    && let ExprKind::DropTemps(expr1) = cond.kind
+    && let ExprKind::Lit(ref lit) = expr1.kind
+    && let LitKind::Bool(true) = lit.node
+    && let ExprKind::Block(block, None) = then.kind
+    && block.stmts.is_empty()
+    && let Some(trailing_expr) = block.expr
+    && let ExprKind::Lit(ref lit1) = trailing_expr.kind
+    && let LitKind::Int(1, LitIntType::Unsuffixed) = lit1.node
+    && let ExprKind::Block(block1, None) = else_expr.kind
+    && block1.stmts.is_empty()
+    && let Some(trailing_expr1) = block1.expr
+    && let ExprKind::Lit(ref lit2) = trailing_expr1.kind
+    && let LitKind::Int(0, LitIntType::Unsuffixed) = lit2.node
+{
+    // report your lint here
 }
-if_chain! {
-    if let PatKind::Struct(ref qpath, fields, false) = arm.pat.kind;
-    if match_qpath(qpath, &["Test"]);
-    if fields.len() == 1;
-    if fields[0].ident.as_str() == "field";
-    if let PatKind::Lit(lit_expr) = fields[0].pat.kind;
-    if let ExprKind::Lit(ref lit) = lit_expr.kind;
-    if let LitKind::Int(1, LitIntType::Unsuffixed) = lit.node;
-    if arm.guard.is_none();
-    if let ExprKind::Block(block, None) = arm.body.kind;
-    if block.stmts.is_empty();
-    if block.expr.is_none();
-    then {
-        // report your lint here
-    }
+if let PatKind::Struct(ref qpath, fields, false) = arm.pat.kind
+    && match_qpath(qpath, &["Test"])
+    && fields.len() == 1
+    && fields[0].ident.as_str() == "field"
+    && let PatKind::Lit(lit_expr) = fields[0].pat.kind
+    && let ExprKind::Lit(ref lit) = lit_expr.kind
+    && let LitKind::Int(1, LitIntType::Unsuffixed) = lit.node
+    && arm.guard.is_none()
+    && let ExprKind::Block(block, None) = arm.body.kind
+    && block.stmts.is_empty()
+    && block.expr.is_none()
+{
+    // report your lint here
 }
-if_chain! {
-    if let PatKind::TupleStruct(ref qpath, fields, None) = arm.pat.kind;
-    if match_qpath(qpath, &["TestTuple"]);
-    if fields.len() == 1;
-    if let PatKind::Lit(lit_expr) = fields[0].kind;
-    if let ExprKind::Lit(ref lit) = lit_expr.kind;
-    if let LitKind::Int(1, LitIntType::Unsuffixed) = lit.node;
-    if arm.guard.is_none();
-    if let ExprKind::Block(block, None) = arm.body.kind;
-    if block.stmts.is_empty();
-    if block.expr.is_none();
-    then {
-        // report your lint here
-    }
+if let PatKind::TupleStruct(ref qpath, fields, None) = arm.pat.kind
+    && match_qpath(qpath, &["TestTuple"])
+    && fields.len() == 1
+    && let PatKind::Lit(lit_expr) = fields[0].kind
+    && let ExprKind::Lit(ref lit) = lit_expr.kind
+    && let LitKind::Int(1, LitIntType::Unsuffixed) = lit.node
+    && arm.guard.is_none()
+    && let ExprKind::Block(block, None) = arm.body.kind
+    && block.stmts.is_empty()
+    && block.expr.is_none()
+{
+    // report your lint here
 }
-if_chain! {
-    if let ExprKind::MethodCall(method_name, receiver, args, _) = expr.kind;
-    if method_name.ident.as_str() == "test";
-    if let ExprKind::Path(ref qpath) = receiver.kind;
-    if match_qpath(qpath, &["test_method_call"]);
-    if args.is_empty();
-    then {
-        // report your lint here
-    }
+if let ExprKind::MethodCall(method_name, receiver, args, _) = expr.kind
+    && method_name.ident.as_str() == "test"
+    && let ExprKind::Path(ref qpath) = receiver.kind
+    && match_qpath(qpath, &["test_method_call"])
+    && args.is_empty()
+{
+    // report your lint here
 }
-- 
cgit 1.4.1-3-g733a5


From c251f8d8dd010ac454deec0a39e7a6f3c19204c3 Mon Sep 17 00:00:00 2001
From: Yuri Astrakhan <YuriAstrakhan@gmail.com>
Date: Thu, 6 Oct 2022 08:54:07 -0400
Subject: lint: fix a few comments

---
 clippy_lints/src/format_args.rs | 12 ------------
 clippy_utils/src/macros.rs      |  2 +-
 2 files changed, 1 insertion(+), 13 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/format_args.rs b/clippy_lints/src/format_args.rs
index 88502b72618..d4bb357fb4f 100644
--- a/clippy_lints/src/format_args.rs
+++ b/clippy_lints/src/format_args.rs
@@ -173,18 +173,6 @@ fn check_uninlined_args(cx: &LateContext<'_>, args: &FormatArgsExpn<'_>, call_si
         return;
     }
 
-    // FIXME: Properly ignore a rare case where the format string is wrapped in a macro.
-    // Example:  `format!(indoc!("{}"), foo);`
-    // If inlined, they will cause a compilation error:
-    //     > to avoid ambiguity, `format_args!` cannot capture variables
-    //     > when the format string is expanded from a macro
-    // @Alexendoo explanation:
-    //     > indoc! is a proc macro that is producing a string literal with its span
-    //     > set to its input it's not marked as from expansion, and since it's compatible
-    //     > tokenization wise clippy_utils::is_from_proc_macro wouldn't catch it either
-    // This might be a relatively expensive test, so do it only we are ready to replace.
-    // See more examples in tests/ui/uninlined_format_args.rs
-
     span_lint_and_then(
         cx,
         UNINLINED_FORMAT_ARGS,
diff --git a/clippy_utils/src/macros.rs b/clippy_utils/src/macros.rs
index dd0ce1da657..5a63c290a31 100644
--- a/clippy_utils/src/macros.rs
+++ b/clippy_utils/src/macros.rs
@@ -414,7 +414,7 @@ impl FormatString {
 
 struct FormatArgsValues<'tcx> {
     /// Values passed after the format string and implicit captures. `[1, z + 2, x]` for
-    /// `format!("{x} {} {y}", 1, z + 2)`.
+    /// `format!("{x} {} {}", 1, z + 2)`.
     value_args: Vec<&'tcx Expr<'tcx>>,
     /// Maps an `rt::v1::Argument::position` or an `rt::v1::Count::Param` to its index in
     /// `value_args`
-- 
cgit 1.4.1-3-g733a5


From cfd6c8d19d1db6f2da66415dd60a82f2c706363e Mon Sep 17 00:00:00 2001
From: Yuri Astrakhan <YuriAstrakhan@gmail.com>
Date: Thu, 6 Oct 2022 09:12:37 -0400
Subject: Add a temporary workaround for  multiline formart arg inlining

per suggestion in
https://github.com/rust-lang/rust/pull/102729#discussion_r988990080

workaround for an internal crash when handling multi-line format
argument inlining.
---
 clippy_lints/src/format_args.rs       |  7 ++++-
 tests/ui/uninlined_format_args.fixed  | 11 ++++++--
 tests/ui/uninlined_format_args.stderr | 53 +----------------------------------
 3 files changed, 15 insertions(+), 56 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/format_args.rs b/clippy_lints/src/format_args.rs
index d4bb357fb4f..45ed21e066a 100644
--- a/clippy_lints/src/format_args.rs
+++ b/clippy_lints/src/format_args.rs
@@ -8,7 +8,7 @@ use if_chain::if_chain;
 use itertools::Itertools;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, HirId, QPath};
-use rustc_lint::{LateContext, LateLintPass};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::ty::adjustment::{Adjust, Adjustment};
 use rustc_middle::ty::Ty;
 use rustc_semver::RustcVersion;
@@ -173,6 +173,11 @@ fn check_uninlined_args(cx: &LateContext<'_>, args: &FormatArgsExpn<'_>, call_si
         return;
     }
 
+    // Temporarily ignore multiline spans: https://github.com/rust-lang/rust/pull/102729#discussion_r988704308
+    if fixes.iter().any(|(span, _)| cx.sess().source_map().is_multiline(*span)) {
+        return;
+    }
+
     span_lint_and_then(
         cx,
         UNINLINED_FORMAT_ARGS,
diff --git a/tests/ui/uninlined_format_args.fixed b/tests/ui/uninlined_format_args.fixed
index dcf10ed60a2..3ca7a401902 100644
--- a/tests/ui/uninlined_format_args.fixed
+++ b/tests/ui/uninlined_format_args.fixed
@@ -44,7 +44,9 @@ fn tester(fn_arg: i32) {
     println!("val='{local_i32}'"); // space+tab
     println!("val='{local_i32}'"); // tab+space
     println!(
-        "val='{local_i32}'"
+        "val='{
+    }'",
+        local_i32
     );
     println!("{local_i32}");
     println!("{fn_arg}");
@@ -108,7 +110,8 @@ fn tester(fn_arg: i32) {
     println!("{local_f64:width$.prec$}");
     println!("{local_f64:width$.prec$} {local_f64} {width} {prec}");
     println!(
-        "{local_i32:width$.prec$} {local_i32:prec$.width$} {width:local_i32$.prec$} {width:prec$.local_i32$} {prec:local_i32$.width$} {prec:width$.local_i32$}",
+        "{0:1$.2$} {0:2$.1$} {1:0$.2$} {1:2$.0$} {2:0$.1$} {2:1$.0$}",
+        local_i32, width, prec,
     );
     println!(
         "{0:1$.2$} {0:2$.1$} {1:0$.2$} {1:2$.0$} {2:0$.1$} {2:1$.0$} {3}",
@@ -139,7 +142,9 @@ fn tester(fn_arg: i32) {
     println!(no_param_str!(), local_i32);
 
     println!(
-        "{val}",
+        "{}",
+        // comment with a comma , in it
+        val,
     );
     println!("{val}");
 
diff --git a/tests/ui/uninlined_format_args.stderr b/tests/ui/uninlined_format_args.stderr
index 1b4dada28da..d1a77492634 100644
--- a/tests/ui/uninlined_format_args.stderr
+++ b/tests/ui/uninlined_format_args.stderr
@@ -59,22 +59,6 @@ LL -     println!("val='{     }'", local_i32); // tab+space
 LL +     println!("val='{local_i32}'"); // tab+space
    |
 
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:46:5
-   |
-LL | /     println!(
-LL | |         "val='{
-LL | |     }'",
-LL | |         local_i32
-LL | |     );
-   | |_____^
-   |
-help: change this to
-   |
-LL -         "val='{
-LL +         "val='{local_i32}'"
-   |
-
 error: variables can be used directly in the `format!` string
   --> $DIR/uninlined_format_args.rs:51:5
    |
@@ -783,25 +767,6 @@ LL -     println!("{:1$.2$} {0} {1} {2}", local_f64, width, prec);
 LL +     println!("{local_f64:width$.prec$} {local_f64} {width} {prec}");
    |
 
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:112:5
-   |
-LL | /     println!(
-LL | |         "{0:1$.2$} {0:2$.1$} {1:0$.2$} {1:2$.0$} {2:0$.1$} {2:1$.0$}",
-LL | |         local_i32, width, prec,
-LL | |     );
-   | |_____^
-   |
-help: change this to
-   |
-LL ~         "{local_i32:width$.prec$} {local_i32:prec$.width$} {width:local_i32$.prec$} {width:prec$.local_i32$} {prec:local_i32$.width$} {prec:width$.local_i32$}", width, prec,
-LL ~         "{0:1$.2$} {0:2$.1$} {1:0$.2$} {1:2$.0$} {2:0$.1$} {2:1$.0$}", width, prec,
-LL ~         "{0:1$.2$} {0:2$.1$} {1:0$.2$} {1:2$.0$} {2:0$.1$} {2:1$.0$}", width, prec,
-LL ~         "{0:1$.2$} {0:2$.1$} {1:0$.2$} {1:2$.0$} {2:0$.1$} {2:1$.0$}", width, prec,
-LL ~         "{0:1$.2$} {0:2$.1$} {1:0$.2$} {1:2$.0$} {2:0$.1$} {2:1$.0$}", width, prec,
-LL ~         "{0:1$.2$} {0:2$.1$} {1:0$.2$} {1:2$.0$} {2:0$.1$} {2:1$.0$}",
-   |
-
 error: variables can be used directly in the `format!` string
   --> $DIR/uninlined_format_args.rs:123:5
    |
@@ -850,22 +815,6 @@ LL -     println!("{}", format!("{}", local_i32));
 LL +     println!("{}", format!("{local_i32}"));
    |
 
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:144:5
-   |
-LL | /     println!(
-LL | |         "{}",
-LL | |         // comment with a comma , in it
-LL | |         val,
-LL | |     );
-   | |_____^
-   |
-help: change this to
-   |
-LL -         "{}",
-LL +         "{val}",
-   |
-
 error: variables can be used directly in the `format!` string
   --> $DIR/uninlined_format_args.rs:149:5
    |
@@ -890,5 +839,5 @@ LL -     println!("expand='{}'", local_i32);
 LL +     println!("expand='{local_i32}'");
    |
 
-error: aborting due to 73 previous errors
+error: aborting due to 70 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From d3c041a08696b722da3276846e0064dd03742940 Mon Sep 17 00:00:00 2001
From: Andre Bogus <bogusandre@gmail.com>
Date: Mon, 3 Oct 2022 17:29:38 +0200
Subject: extend `box-default` lint, add suggestion

---
 clippy_lints/src/box_default.rs | 94 +++++++++++++++++++++++++++++++++++------
 clippy_utils/src/lib.rs         | 26 +++++++++++-
 src/docs/box_default.txt        |  6 ---
 tests/ui/box_default.fixed      | 43 +++++++++++++++++++
 tests/ui/box_default.rs         | 14 +++++-
 tests/ui/box_default.stderr     | 77 +++++++++++++++++++++------------
 6 files changed, 212 insertions(+), 48 deletions(-)
 create mode 100644 tests/ui/box_default.fixed

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/box_default.rs b/clippy_lints/src/box_default.rs
index 792183ac408..f35a79dcc73 100644
--- a/clippy_lints/src/box_default.rs
+++ b/clippy_lints/src/box_default.rs
@@ -1,5 +1,12 @@
-use clippy_utils::{diagnostics::span_lint_and_help, is_default_equivalent, path_def_id};
-use rustc_hir::{Expr, ExprKind, QPath};
+use clippy_utils::{
+    diagnostics::span_lint_and_sugg, get_parent_node, is_default_equivalent, macros::macro_backtrace, match_path,
+    path_def_id, paths, ty::expr_sig,
+};
+use rustc_errors::Applicability;
+use rustc_hir::{
+    intravisit::{walk_ty, Visitor},
+    Block, Expr, ExprKind, Local, Node, QPath, TyKind,
+};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -15,12 +22,6 @@ declare_clippy_lint! {
     /// Second, `Box::default()` can be faster
     /// [in certain cases](https://nnethercote.github.io/perf-book/standard-library-types.html#box).
     ///
-    /// ### Known problems
-    /// The lint may miss some cases (e.g. Box::new(String::from(""))).
-    /// On the other hand, it will trigger on cases where the `default`
-    /// code comes from a macro that does something different based on
-    /// e.g. target operating system.
-    ///
     /// ### Example
     /// ```rust
     /// let x: Box<String> = Box::new(Default::default());
@@ -41,21 +42,88 @@ impl LateLintPass<'_> for BoxDefault {
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
         if let ExprKind::Call(box_new, [arg]) = expr.kind
             && let ExprKind::Path(QPath::TypeRelative(ty, seg)) = box_new.kind
-            && let ExprKind::Call(..) = arg.kind
+            && let ExprKind::Call(arg_path, ..) = arg.kind
             && !in_external_macro(cx.sess(), expr.span)
-            && expr.span.eq_ctxt(arg.span)
+            && (expr.span.eq_ctxt(arg.span) || is_vec_expn(cx, arg))
             && seg.ident.name == sym::new
             && path_def_id(cx, ty) == cx.tcx.lang_items().owned_box()
             && is_default_equivalent(cx, arg)
         {
-            span_lint_and_help(
+            let arg_ty = cx.typeck_results().expr_ty(arg);
+            span_lint_and_sugg(
                 cx,
                 BOX_DEFAULT,
                 expr.span,
                 "`Box::new(_)` of default value",
-                None,
-                "use `Box::default()` instead",
+                "try",
+                if is_plain_default(arg_path) || given_type(cx, expr) {
+                    "Box::default()".into()
+                } else {
+                    format!("Box::<{arg_ty}>::default()")
+                },
+                Applicability::MachineApplicable
             );
         }
     }
 }
+
+fn is_plain_default(arg_path: &Expr<'_>) -> bool {
+    // we need to match the actual path so we don't match e.g. "u8::default"
+    if let ExprKind::Path(QPath::Resolved(None, path)) = &arg_path.kind {
+        // avoid generic parameters
+        match_path(path, &paths::DEFAULT_TRAIT_METHOD) && path.segments.iter().all(|seg| seg.args.is_none())
+    } else {
+        false
+    }
+}
+
+fn is_vec_expn(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+    macro_backtrace(expr.span)
+        .next()
+        .map_or(false, |call| cx.tcx.is_diagnostic_item(sym::vec_macro, call.def_id))
+}
+
+#[derive(Default)]
+struct InferVisitor(bool);
+
+impl<'tcx> Visitor<'tcx> for InferVisitor {
+    fn visit_ty(&mut self, t: &rustc_hir::Ty<'_>) {
+        self.0 |= matches!(t.kind, TyKind::Infer);
+        if !self.0 {
+            walk_ty(self, t);
+        }
+    }
+}
+
+fn given_type(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+    match get_parent_node(cx.tcx, expr.hir_id) {
+        Some(Node::Local(Local { ty: Some(ty), .. })) => {
+            let mut v = InferVisitor::default();
+            v.visit_ty(ty);
+            !v.0
+        },
+        Some(
+            Node::Expr(Expr {
+                kind: ExprKind::Call(path, args),
+                ..
+            }) | Node::Block(Block {
+                expr:
+                    Some(Expr {
+                        kind: ExprKind::Call(path, args),
+                        ..
+                    }),
+                ..
+            }),
+        ) => {
+            if let Some(index) = args.iter().position(|arg| arg.hir_id == expr.hir_id) &&
+                let Some(sig) = expr_sig(cx, path) &&
+                let Some(input) = sig.input(index)
+            {
+                input.no_bound_vars().is_some()
+            } else {
+                false
+            }
+        },
+        _ => false,
+    }
+}
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 42374fdd7ba..e6492d76260 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -815,13 +815,37 @@ pub fn is_default_equivalent(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
                 false
             }
         },
-        ExprKind::Call(repl_func, _) => is_default_equivalent_call(cx, repl_func),
+        ExprKind::Call(repl_func, []) => is_default_equivalent_call(cx, repl_func),
+        ExprKind::Call(from_func, [ref arg]) => is_default_equivalent_from(cx, from_func, arg),
         ExprKind::Path(qpath) => is_res_lang_ctor(cx, cx.qpath_res(qpath, e.hir_id), OptionNone),
         ExprKind::AddrOf(rustc_hir::BorrowKind::Ref, _, expr) => matches!(expr.kind, ExprKind::Array([])),
         _ => false,
     }
 }
 
+fn is_default_equivalent_from(cx: &LateContext<'_>, from_func: &Expr<'_>, arg: &Expr<'_>) -> bool {
+    if let ExprKind::Path(QPath::TypeRelative(ty, seg)) = from_func.kind &&
+        seg.ident.name == sym::from
+    {
+        match arg.kind {
+            ExprKind::Lit(hir::Lit {
+                node: LitKind::Str(ref sym, _),
+                ..
+            }) => return sym.is_empty() && is_path_diagnostic_item(cx, ty, sym::String),
+            ExprKind::Array([]) => return is_path_diagnostic_item(cx, ty, sym::Vec),
+            ExprKind::Repeat(_, ArrayLen::Body(len)) => {
+                if let ExprKind::Lit(ref const_lit) = cx.tcx.hir().body(len.body).value.kind &&
+                    let LitKind::Int(v, _) = const_lit.node
+                {
+                        return v == 0 && is_path_diagnostic_item(cx, ty, sym::Vec);
+                }
+            }
+            _ => (),
+        }
+    }
+    false
+}
+
 /// Checks if the top level expression can be moved into a closure as is.
 /// Currently checks for:
 /// * Break/Continue outside the given loop HIR ids.
diff --git a/src/docs/box_default.txt b/src/docs/box_default.txt
index ffac894d0c5..1c670c77333 100644
--- a/src/docs/box_default.txt
+++ b/src/docs/box_default.txt
@@ -7,12 +7,6 @@ First, it's more complex, involving two calls instead of one.
 Second, `Box::default()` can be faster
 [in certain cases](https://nnethercote.github.io/perf-book/standard-library-types.html#box).
 
-### Known problems
-The lint may miss some cases (e.g. Box::new(String::from(""))).
-On the other hand, it will trigger on cases where the `default`
-code comes from a macro that does something different based on
-e.g. target operating system.
-
 ### Example
 ```
 let x: Box<String> = Box::new(Default::default());
diff --git a/tests/ui/box_default.fixed b/tests/ui/box_default.fixed
new file mode 100644
index 00000000000..7fbb272ce5a
--- /dev/null
+++ b/tests/ui/box_default.fixed
@@ -0,0 +1,43 @@
+// run-rustfix
+#![warn(clippy::box_default)]
+
+#[derive(Default)]
+struct ImplementsDefault;
+
+struct OwnDefault;
+
+impl OwnDefault {
+    fn default() -> Self {
+        Self
+    }
+}
+
+macro_rules! outer {
+    ($e: expr) => {
+        $e
+    };
+}
+
+fn main() {
+    let _string: Box<String> = Box::default();
+    let _byte = Box::<u8>::default();
+    let _vec = Box::<std::vec::Vec<u8>>::default();
+    let _impl = Box::<ImplementsDefault>::default();
+    let _impl2 = Box::<ImplementsDefault>::default();
+    let _impl3: Box<ImplementsDefault> = Box::default();
+    let _own = Box::new(OwnDefault::default()); // should not lint
+    let _in_macro = outer!(Box::<std::string::String>::default());
+    let _string_default = outer!(Box::<std::string::String>::default());
+    let _vec2: Box<Vec<ImplementsDefault>> = Box::default();
+    let _vec3: Box<Vec<bool>> = Box::default();
+    let _vec4: Box<_> = Box::<std::vec::Vec<bool>>::default();
+    let _more = ret_ty_fn();
+    call_ty_fn(Box::default());
+}
+
+fn ret_ty_fn() -> Box<bool> {
+    Box::<bool>::default()
+}
+
+#[allow(clippy::boxed_local)]
+fn call_ty_fn(_b: Box<u8>) {}
diff --git a/tests/ui/box_default.rs b/tests/ui/box_default.rs
index dc522705bc6..64c4f3887af 100644
--- a/tests/ui/box_default.rs
+++ b/tests/ui/box_default.rs
@@ -1,3 +1,4 @@
+// run-rustfix
 #![warn(clippy::box_default)]
 
 #[derive(Default)]
@@ -26,6 +27,17 @@ fn main() {
     let _impl3: Box<ImplementsDefault> = Box::new(Default::default());
     let _own = Box::new(OwnDefault::default()); // should not lint
     let _in_macro = outer!(Box::new(String::new()));
-    // false negative: default is from different expansion
+    let _string_default = outer!(Box::new(String::from("")));
     let _vec2: Box<Vec<ImplementsDefault>> = Box::new(vec![]);
+    let _vec3: Box<Vec<bool>> = Box::new(Vec::from([]));
+    let _vec4: Box<_> = Box::new(Vec::from([false; 0]));
+    let _more = ret_ty_fn();
+    call_ty_fn(Box::new(u8::default()));
 }
+
+fn ret_ty_fn() -> Box<bool> {
+    Box::new(bool::default())
+}
+
+#[allow(clippy::boxed_local)]
+fn call_ty_fn(_b: Box<u8>) {}
diff --git a/tests/ui/box_default.stderr b/tests/ui/box_default.stderr
index b2030e95acb..313255fc950 100644
--- a/tests/ui/box_default.stderr
+++ b/tests/ui/box_default.stderr
@@ -1,59 +1,82 @@
 error: `Box::new(_)` of default value
-  --> $DIR/box_default.rs:21:32
+  --> $DIR/box_default.rs:22:32
    |
 LL |     let _string: Box<String> = Box::new(Default::default());
-   |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Box::default()`
    |
-   = help: use `Box::default()` instead
    = note: `-D clippy::box-default` implied by `-D warnings`
 
 error: `Box::new(_)` of default value
-  --> $DIR/box_default.rs:22:17
+  --> $DIR/box_default.rs:23:17
    |
 LL |     let _byte = Box::new(u8::default());
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: use `Box::default()` instead
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Box::<u8>::default()`
 
 error: `Box::new(_)` of default value
-  --> $DIR/box_default.rs:23:16
+  --> $DIR/box_default.rs:24:16
    |
 LL |     let _vec = Box::new(Vec::<u8>::new());
-   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: use `Box::default()` instead
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Box::<std::vec::Vec<u8>>::default()`
 
 error: `Box::new(_)` of default value
-  --> $DIR/box_default.rs:24:17
+  --> $DIR/box_default.rs:25:17
    |
 LL |     let _impl = Box::new(ImplementsDefault::default());
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: use `Box::default()` instead
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Box::<ImplementsDefault>::default()`
 
 error: `Box::new(_)` of default value
-  --> $DIR/box_default.rs:25:18
+  --> $DIR/box_default.rs:26:18
    |
 LL |     let _impl2 = Box::new(<ImplementsDefault as Default>::default());
-   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: use `Box::default()` instead
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Box::<ImplementsDefault>::default()`
 
 error: `Box::new(_)` of default value
-  --> $DIR/box_default.rs:26:42
+  --> $DIR/box_default.rs:27:42
    |
 LL |     let _impl3: Box<ImplementsDefault> = Box::new(Default::default());
-   |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: use `Box::default()` instead
+   |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Box::default()`
 
 error: `Box::new(_)` of default value
-  --> $DIR/box_default.rs:28:28
+  --> $DIR/box_default.rs:29:28
    |
 LL |     let _in_macro = outer!(Box::new(String::new()));
-   |                            ^^^^^^^^^^^^^^^^^^^^^^^
+   |                            ^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Box::<std::string::String>::default()`
+
+error: `Box::new(_)` of default value
+  --> $DIR/box_default.rs:30:34
+   |
+LL |     let _string_default = outer!(Box::new(String::from("")));
+   |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Box::<std::string::String>::default()`
+
+error: `Box::new(_)` of default value
+  --> $DIR/box_default.rs:31:46
+   |
+LL |     let _vec2: Box<Vec<ImplementsDefault>> = Box::new(vec![]);
+   |                                              ^^^^^^^^^^^^^^^^ help: try: `Box::default()`
+
+error: `Box::new(_)` of default value
+  --> $DIR/box_default.rs:32:33
+   |
+LL |     let _vec3: Box<Vec<bool>> = Box::new(Vec::from([]));
+   |                                 ^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Box::default()`
+
+error: `Box::new(_)` of default value
+  --> $DIR/box_default.rs:33:25
+   |
+LL |     let _vec4: Box<_> = Box::new(Vec::from([false; 0]));
+   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Box::<std::vec::Vec<bool>>::default()`
+
+error: `Box::new(_)` of default value
+  --> $DIR/box_default.rs:35:16
+   |
+LL |     call_ty_fn(Box::new(u8::default()));
+   |                ^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Box::default()`
+
+error: `Box::new(_)` of default value
+  --> $DIR/box_default.rs:39:5
    |
-   = help: use `Box::default()` instead
+LL |     Box::new(bool::default())
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Box::<bool>::default()`
 
-error: aborting due to 7 previous errors
+error: aborting due to 13 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 493684888f0f68b43d46d70b89c2f2a75091601f Mon Sep 17 00:00:00 2001
From: Yuri Astrakhan <YuriAstrakhan@gmail.com>
Date: Thu, 6 Oct 2022 12:12:55 -0400
Subject: Change uninlined_format_args into a style lint

---
 clippy_lints/src/format_args.rs           | 2 +-
 clippy_lints/src/lib.register_all.rs      | 1 +
 clippy_lints/src/lib.register_pedantic.rs | 1 -
 clippy_lints/src/lib.register_style.rs    | 1 +
 4 files changed, 3 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/format_args.rs b/clippy_lints/src/format_args.rs
index 45ed21e066a..f8da7f22278 100644
--- a/clippy_lints/src/format_args.rs
+++ b/clippy_lints/src/format_args.rs
@@ -111,7 +111,7 @@ declare_clippy_lint! {
     /// nothing will be suggested, e.g. `println!("{0}={1}", var, 1+2)`.
     #[clippy::version = "1.65.0"]
     pub UNINLINED_FORMAT_ARGS,
-    pedantic,
+    style,
     "using non-inlined variables in `format!` calls"
 }
 
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 5d26e4b3360..d09ee644370 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -71,6 +71,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(format::USELESS_FORMAT),
     LintId::of(format_args::FORMAT_IN_FORMAT_ARGS),
     LintId::of(format_args::TO_STRING_IN_FORMAT_ARGS),
+    LintId::of(format_args::UNINLINED_FORMAT_ARGS),
     LintId::of(format_impl::PRINT_IN_FORMAT_IMPL),
     LintId::of(format_impl::RECURSIVE_FORMAT_IMPL),
     LintId::of(formatting::POSSIBLE_MISSING_COMMA),
diff --git a/clippy_lints/src/lib.register_pedantic.rs b/clippy_lints/src/lib.register_pedantic.rs
index dd3e2b7d29c..1b9d575f3e4 100644
--- a/clippy_lints/src/lib.register_pedantic.rs
+++ b/clippy_lints/src/lib.register_pedantic.rs
@@ -29,7 +29,6 @@ store.register_group(true, "clippy::pedantic", Some("clippy_pedantic"), vec![
     LintId::of(eta_reduction::REDUNDANT_CLOSURE_FOR_METHOD_CALLS),
     LintId::of(excessive_bools::FN_PARAMS_EXCESSIVE_BOOLS),
     LintId::of(excessive_bools::STRUCT_EXCESSIVE_BOOLS),
-    LintId::of(format_args::UNINLINED_FORMAT_ARGS),
     LintId::of(functions::MUST_USE_CANDIDATE),
     LintId::of(functions::TOO_MANY_LINES),
     LintId::of(if_not_else::IF_NOT_ELSE),
diff --git a/clippy_lints/src/lib.register_style.rs b/clippy_lints/src/lib.register_style.rs
index 8e1390167dc..81fefb84e0d 100644
--- a/clippy_lints/src/lib.register_style.rs
+++ b/clippy_lints/src/lib.register_style.rs
@@ -25,6 +25,7 @@ store.register_group(true, "clippy::style", Some("clippy_style"), vec![
     LintId::of(enum_variants::MODULE_INCEPTION),
     LintId::of(eta_reduction::REDUNDANT_CLOSURE),
     LintId::of(float_literal::EXCESSIVE_PRECISION),
+    LintId::of(format_args::UNINLINED_FORMAT_ARGS),
     LintId::of(from_over_into::FROM_OVER_INTO),
     LintId::of(from_str_radix_10::FROM_STR_RADIX_10),
     LintId::of(functions::DOUBLE_MUST_USE),
-- 
cgit 1.4.1-3-g733a5


From 23b16998c35674e74511bfe70a7324ca12119976 Mon Sep 17 00:00:00 2001
From: Evan Typanski <evantypanski@gmail.com>
Date: Thu, 6 Oct 2022 15:14:55 -0400
Subject: Add curlies to scrutinees with side effects

---
 clippy_lints/src/matches/match_single_binding.rs | 31 +++++++++++++++++-------
 tests/ui/match_single_binding.fixed              |  9 +++++++
 tests/ui/match_single_binding.rs                 |  8 ++++++
 tests/ui/match_single_binding.stderr             | 19 ++++++++++++++-
 4 files changed, 57 insertions(+), 10 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/match_single_binding.rs b/clippy_lints/src/matches/match_single_binding.rs
index 68682cedf1d..b64c4588748 100644
--- a/clippy_lints/src/matches/match_single_binding.rs
+++ b/clippy_lints/src/matches/match_single_binding.rs
@@ -58,6 +58,7 @@ pub(crate) fn check<'a>(cx: &LateContext<'a>, ex: &Expr<'a>, arms: &[Arm<'_>], e
                         &snippet_body,
                         &mut applicability,
                         Some(span),
+                        false,
                     );
 
                     span_lint_and_sugg(
@@ -90,6 +91,7 @@ pub(crate) fn check<'a>(cx: &LateContext<'a>, ex: &Expr<'a>, arms: &[Arm<'_>], e
                         &snippet_body,
                         &mut applicability,
                         None,
+                        false,
                     );
                     (expr.span, sugg)
                 },
@@ -107,10 +109,14 @@ pub(crate) fn check<'a>(cx: &LateContext<'a>, ex: &Expr<'a>, arms: &[Arm<'_>], e
         },
         PatKind::Wild => {
             if ex.can_have_side_effects() {
-                let indent = " ".repeat(indent_of(cx, expr.span).unwrap_or(0));
-                let sugg = format!(
-                    "{};\n{indent}{snippet_body}",
-                    snippet_with_applicability(cx, ex.span, "..", &mut applicability)
+                let sugg = sugg_with_curlies(
+                    cx,
+                    (ex, expr),
+                    (bind_names, matched_vars),
+                    &snippet_body,
+                    &mut applicability,
+                    None,
+                    true,
                 );
 
                 span_lint_and_sugg(
@@ -169,6 +175,7 @@ fn sugg_with_curlies<'a>(
     snippet_body: &str,
     applicability: &mut Applicability,
     assignment: Option<Span>,
+    needs_var_binding: bool,
 ) -> String {
     let mut indent = " ".repeat(indent_of(cx, ex.span).unwrap_or(0));
 
@@ -200,9 +207,15 @@ fn sugg_with_curlies<'a>(
         s
     });
 
-    format!(
-        "{cbrace_start}let {} = {};\n{indent}{assignment_str}{snippet_body}{cbrace_end}",
-        snippet_with_applicability(cx, bind_names, "..", applicability),
-        snippet_with_applicability(cx, matched_vars, "..", applicability)
-    )
+    let scrutinee = if needs_var_binding {
+        snippet_with_applicability(cx, matched_vars, "..", applicability).to_string()
+    } else {
+        format!(
+            "let {} = {}",
+            snippet_with_applicability(cx, bind_names, "..", applicability),
+            snippet_with_applicability(cx, matched_vars, "..", applicability)
+        )
+    };
+
+    format!("{cbrace_start}{scrutinee};\n{indent}{assignment_str}{snippet_body}{cbrace_end}")
 }
diff --git a/tests/ui/match_single_binding.fixed b/tests/ui/match_single_binding.fixed
index 951f552eb32..a6e315e4773 100644
--- a/tests/ui/match_single_binding.fixed
+++ b/tests/ui/match_single_binding.fixed
@@ -124,3 +124,12 @@ fn issue_8723() {
 
     let _ = val;
 }
+
+#[allow(dead_code)]
+fn issue_9575() {
+    fn side_effects() {}
+    let _ = || {
+        side_effects();
+        println!("Needs curlies");
+    };
+}
diff --git a/tests/ui/match_single_binding.rs b/tests/ui/match_single_binding.rs
index 19c0fee8fd6..cecbd703e56 100644
--- a/tests/ui/match_single_binding.rs
+++ b/tests/ui/match_single_binding.rs
@@ -140,3 +140,11 @@ fn issue_8723() {
 
     let _ = val;
 }
+
+#[allow(dead_code)]
+fn issue_9575() {
+    fn side_effects() {}
+    let _ = || match side_effects() {
+        _ => println!("Needs curlies"),
+    };
+}
diff --git a/tests/ui/match_single_binding.stderr b/tests/ui/match_single_binding.stderr
index 5d4e7314b21..2b9ec7ee702 100644
--- a/tests/ui/match_single_binding.stderr
+++ b/tests/ui/match_single_binding.stderr
@@ -196,5 +196,22 @@ LL +         suf
 LL ~     };
    |
 
-error: aborting due to 13 previous errors
+error: this match could be replaced by its scrutinee and body
+  --> $DIR/match_single_binding.rs:147:16
+   |
+LL |       let _ = || match side_effects() {
+   |  ________________^
+LL | |         _ => println!("Needs curlies"),
+LL | |     };
+   | |_____^
+   |
+help: consider using the scrutinee and body instead
+   |
+LL ~     let _ = || {
+LL +         side_effects();
+LL +         println!("Needs curlies");
+LL ~     };
+   |
+
+error: aborting due to 14 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 39164acf6e62a3ff55d6c210acc1095d9ccc95bb Mon Sep 17 00:00:00 2001
From: Evan Typanski <evantypanski@gmail.com>
Date: Thu, 6 Oct 2022 15:36:28 -0400
Subject: Fix flipped variable that made it through

---
 clippy_lints/src/matches/match_single_binding.rs | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/match_single_binding.rs b/clippy_lints/src/matches/match_single_binding.rs
index b64c4588748..1bf8d4e96ad 100644
--- a/clippy_lints/src/matches/match_single_binding.rs
+++ b/clippy_lints/src/matches/match_single_binding.rs
@@ -58,7 +58,7 @@ pub(crate) fn check<'a>(cx: &LateContext<'a>, ex: &Expr<'a>, arms: &[Arm<'_>], e
                         &snippet_body,
                         &mut applicability,
                         Some(span),
-                        false,
+                        true,
                     );
 
                     span_lint_and_sugg(
@@ -91,7 +91,7 @@ pub(crate) fn check<'a>(cx: &LateContext<'a>, ex: &Expr<'a>, arms: &[Arm<'_>], e
                         &snippet_body,
                         &mut applicability,
                         None,
-                        false,
+                        true,
                     );
                     (expr.span, sugg)
                 },
@@ -116,7 +116,7 @@ pub(crate) fn check<'a>(cx: &LateContext<'a>, ex: &Expr<'a>, arms: &[Arm<'_>], e
                     &snippet_body,
                     &mut applicability,
                     None,
-                    true,
+                    false,
                 );
 
                 span_lint_and_sugg(
@@ -208,13 +208,13 @@ fn sugg_with_curlies<'a>(
     });
 
     let scrutinee = if needs_var_binding {
-        snippet_with_applicability(cx, matched_vars, "..", applicability).to_string()
-    } else {
         format!(
             "let {} = {}",
             snippet_with_applicability(cx, bind_names, "..", applicability),
             snippet_with_applicability(cx, matched_vars, "..", applicability)
         )
+    } else {
+        snippet_with_applicability(cx, matched_vars, "..", applicability).to_string()
     };
 
     format!("{cbrace_start}{scrutinee};\n{indent}{assignment_str}{snippet_body}{cbrace_end}")
-- 
cgit 1.4.1-3-g733a5


From 037f698147eeb97699c06a270e8774d2f7a6fbbc Mon Sep 17 00:00:00 2001
From: Samuel Moelius <samuel.moelius@trailofbits.com>
Date: Thu, 25 Aug 2022 00:14:21 +0000
Subject: `needless_borrow` uses `used_exactly_once`

---
 clippy_lints/src/dereference.rs             |  99 +++++-
 clippy_lints/src/lib.rs                     |   1 -
 clippy_lints/src/redundant_clone.rs         | 454 +++-------------------------
 clippy_utils/src/lib.rs                     |   3 +
 clippy_utils/src/mir/maybe_storage_live.rs  |  52 ++++
 clippy_utils/src/mir/mod.rs                 | 165 ++++++++++
 clippy_utils/src/mir/possible_borrower.rs   | 241 +++++++++++++++
 clippy_utils/src/mir/possible_origin.rs     |  59 ++++
 clippy_utils/src/mir/transitive_relation.rs |  29 ++
 clippy_utils/src/paths.rs                   |   6 -
 tests/ui/needless_borrow.fixed              |  62 +++-
 tests/ui/needless_borrow.rs                 |  60 +++-
 tests/ui/needless_borrow.stderr             |  96 ++++--
 tests/ui/unnecessary_to_owned.fixed         |   2 +-
 tests/ui/unnecessary_to_owned.rs            |   2 +-
 15 files changed, 855 insertions(+), 476 deletions(-)
 create mode 100644 clippy_utils/src/mir/maybe_storage_live.rs
 create mode 100644 clippy_utils/src/mir/mod.rs
 create mode 100644 clippy_utils/src/mir/possible_borrower.rs
 create mode 100644 clippy_utils/src/mir/possible_origin.rs
 create mode 100644 clippy_utils/src/mir/transitive_relation.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index 3cd8f236e7a..45ee2fce4e4 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -1,4 +1,5 @@
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_hir_and_then};
+use clippy_utils::mir::{enclosing_mir, expr_local, local_assignments, used_exactly_once, PossibleBorrowerMap};
 use clippy_utils::source::{snippet_with_applicability, snippet_with_context};
 use clippy_utils::sugg::has_enclosing_paren;
 use clippy_utils::ty::{expr_sig, is_copy, peel_mid_ty_refs, ty_sig, variant_of_res};
@@ -11,13 +12,16 @@ use rustc_data_structures::fx::FxIndexMap;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_ty, Visitor};
 use rustc_hir::{
-    self as hir, def_id::DefId, BindingAnnotation, Body, BodyId, BorrowKind, Closure, Expr, ExprKind, FnRetTy,
-    GenericArg, HirId, ImplItem, ImplItemKind, Item, ItemKind, Local, MatchSource, Mutability, Node, Pat, PatKind,
-    Path, QPath, TraitItem, TraitItemKind, TyKind, UnOp,
+    self as hir,
+    def_id::{DefId, LocalDefId},
+    BindingAnnotation, Body, BodyId, BorrowKind, Closure, Expr, ExprKind, FnRetTy, GenericArg, HirId, ImplItem,
+    ImplItemKind, Item, ItemKind, Local, MatchSource, Mutability, Node, Pat, PatKind, Path, QPath, TraitItem,
+    TraitItemKind, TyKind, UnOp,
 };
 use rustc_index::bit_set::BitSet;
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::mir::{Rvalue, StatementKind};
 use rustc_middle::ty::adjustment::{Adjust, Adjustment, AutoBorrow, AutoBorrowMutability};
 use rustc_middle::ty::{
     self, Binder, BoundVariableKind, EarlyBinder, FnSig, GenericArgKind, List, ParamTy, PredicateKind,
@@ -141,7 +145,7 @@ declare_clippy_lint! {
     "dereferencing when the compiler would automatically dereference"
 }
 
-impl_lint_pass!(Dereferencing => [
+impl_lint_pass!(Dereferencing<'_> => [
     EXPLICIT_DEREF_METHODS,
     NEEDLESS_BORROW,
     REF_BINDING_TO_REFERENCE,
@@ -149,7 +153,7 @@ impl_lint_pass!(Dereferencing => [
 ]);
 
 #[derive(Default)]
-pub struct Dereferencing {
+pub struct Dereferencing<'tcx> {
     state: Option<(State, StateData)>,
 
     // While parsing a `deref` method call in ufcs form, the path to the function is itself an
@@ -170,11 +174,16 @@ pub struct Dereferencing {
     /// e.g. `m!(x) | Foo::Bar(ref x)`
     ref_locals: FxIndexMap<HirId, Option<RefPat>>,
 
+    /// Stack of (body owner, `PossibleBorrowerMap`) pairs. Used by
+    /// `needless_borrow_impl_arg_position` to determine when a borrowed expression can instead
+    /// be moved.
+    possible_borrowers: Vec<(LocalDefId, PossibleBorrowerMap<'tcx, 'tcx>)>,
+
     // `IntoIterator` for arrays requires Rust 1.53.
     msrv: Option<RustcVersion>,
 }
 
-impl Dereferencing {
+impl<'tcx> Dereferencing<'tcx> {
     #[must_use]
     pub fn new(msrv: Option<RustcVersion>) -> Self {
         Self {
@@ -244,7 +253,7 @@ struct RefPat {
     hir_id: HirId,
 }
 
-impl<'tcx> LateLintPass<'tcx> for Dereferencing {
+impl<'tcx> LateLintPass<'tcx> for Dereferencing<'tcx> {
     #[expect(clippy::too_many_lines)]
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         // Skip path expressions from deref calls. e.g. `Deref::deref(e)`
@@ -278,7 +287,7 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing {
         match (self.state.take(), kind) {
             (None, kind) => {
                 let expr_ty = typeck.expr_ty(expr);
-                let (position, adjustments) = walk_parents(cx, expr, self.msrv);
+                let (position, adjustments) = walk_parents(cx, &mut self.possible_borrowers, expr, self.msrv);
                 match kind {
                     RefOp::Deref => {
                         if let Position::FieldAccess {
@@ -550,6 +559,12 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing {
     }
 
     fn check_body_post(&mut self, cx: &LateContext<'tcx>, body: &'tcx Body<'_>) {
+        if self.possible_borrowers.last().map_or(false, |&(local_def_id, _)| {
+            local_def_id == cx.tcx.hir().body_owner_def_id(body.id())
+        }) {
+            self.possible_borrowers.pop();
+        }
+
         if Some(body.id()) == self.current_body {
             for pat in self.ref_locals.drain(..).filter_map(|(_, x)| x) {
                 let replacements = pat.replacements;
@@ -682,6 +697,7 @@ impl Position {
 #[expect(clippy::too_many_lines)]
 fn walk_parents<'tcx>(
     cx: &LateContext<'tcx>,
+    possible_borrowers: &mut Vec<(LocalDefId, PossibleBorrowerMap<'tcx, 'tcx>)>,
     e: &'tcx Expr<'_>,
     msrv: Option<RustcVersion>,
 ) -> (Position, &'tcx [Adjustment<'tcx>]) {
@@ -796,7 +812,16 @@ fn walk_parents<'tcx>(
                             Some(hir_ty) => binding_ty_auto_deref_stability(cx, hir_ty, precedence, ty.bound_vars()),
                             None => {
                                 if let ty::Param(param_ty) = ty.skip_binder().kind() {
-                                    needless_borrow_impl_arg_position(cx, parent, i, *param_ty, e, precedence, msrv)
+                                    needless_borrow_impl_arg_position(
+                                        cx,
+                                        possible_borrowers,
+                                        parent,
+                                        i,
+                                        *param_ty,
+                                        e,
+                                        precedence,
+                                        msrv,
+                                    )
                                 } else {
                                     ty_auto_deref_stability(cx, cx.tcx.erase_late_bound_regions(ty), precedence)
                                         .position_for_arg()
@@ -844,7 +869,16 @@ fn walk_parents<'tcx>(
                     args.iter().position(|arg| arg.hir_id == child_id).map(|i| {
                         let ty = cx.tcx.fn_sig(id).skip_binder().inputs()[i + 1];
                         if let ty::Param(param_ty) = ty.kind() {
-                            needless_borrow_impl_arg_position(cx, parent, i + 1, *param_ty, e, precedence, msrv)
+                            needless_borrow_impl_arg_position(
+                                cx,
+                                possible_borrowers,
+                                parent,
+                                i + 1,
+                                *param_ty,
+                                e,
+                                precedence,
+                                msrv,
+                            )
                         } else {
                             ty_auto_deref_stability(
                                 cx,
@@ -1018,8 +1052,10 @@ fn ty_contains_infer(ty: &hir::Ty<'_>) -> bool {
 // If the conditions are met, returns `Some(Position::ImplArg(..))`; otherwise, returns `None`.
 //   The "is copyable" condition is to avoid the case where removing the `&` means `e` would have to
 // be moved, but it cannot be.
+#[expect(clippy::too_many_arguments)]
 fn needless_borrow_impl_arg_position<'tcx>(
     cx: &LateContext<'tcx>,
+    possible_borrowers: &mut Vec<(LocalDefId, PossibleBorrowerMap<'tcx, 'tcx>)>,
     parent: &Expr<'tcx>,
     arg_index: usize,
     param_ty: ParamTy,
@@ -1082,10 +1118,13 @@ fn needless_borrow_impl_arg_position<'tcx>(
     // elements are modified each time `check_referent` is called.
     let mut substs_with_referent_ty = substs_with_expr_ty.to_vec();
 
-    let mut check_referent = |referent| {
+    let mut check_reference_and_referent = |reference, referent| {
         let referent_ty = cx.typeck_results().expr_ty(referent);
 
-        if !is_copy(cx, referent_ty) {
+        if !is_copy(cx, referent_ty)
+            && (referent_ty.has_significant_drop(cx.tcx, cx.param_env)
+                || !referent_used_exactly_once(cx, possible_borrowers, reference))
+        {
             return false;
         }
 
@@ -1127,7 +1166,7 @@ fn needless_borrow_impl_arg_position<'tcx>(
 
     let mut needless_borrow = false;
     while let ExprKind::AddrOf(_, _, referent) = expr.kind {
-        if !check_referent(referent) {
+        if !check_reference_and_referent(expr, referent) {
             break;
         }
         expr = referent;
@@ -1155,6 +1194,36 @@ fn has_ref_mut_self_method(cx: &LateContext<'_>, trait_def_id: DefId) -> bool {
         })
 }
 
+fn referent_used_exactly_once<'a, 'tcx>(
+    cx: &'a LateContext<'tcx>,
+    possible_borrowers: &mut Vec<(LocalDefId, PossibleBorrowerMap<'tcx, 'tcx>)>,
+    reference: &Expr<'tcx>,
+) -> bool {
+    let mir = enclosing_mir(cx.tcx, reference.hir_id);
+    if let Some(local) = expr_local(cx.tcx, reference)
+        && let [location] = *local_assignments(mir, local).as_slice()
+        && let StatementKind::Assign(box (_, Rvalue::Ref(_, _, place))) =
+            mir.basic_blocks[location.block].statements[location.statement_index].kind
+        && !place.has_deref()
+    {
+        let body_owner_local_def_id = cx.tcx.hir().enclosing_body_owner(reference.hir_id);
+        if possible_borrowers
+            .last()
+            .map_or(true, |&(local_def_id, _)| local_def_id != body_owner_local_def_id)
+        {
+            possible_borrowers.push((body_owner_local_def_id, PossibleBorrowerMap::new(cx, mir)));
+        }
+        let possible_borrower = &mut possible_borrowers.last_mut().unwrap().1;
+        // If `only_borrowers` were used here, the `copyable_iterator::warn` test would fail. The reason is
+        // that `PossibleBorrowerVisitor::visit_terminator` considers `place.local` a possible borrower of
+        // itself. See the comment in that method for an explanation as to why.
+        possible_borrower.bounded_borrowers(&[local], &[local, place.local], place.local, location)
+            && used_exactly_once(mir, place.local).unwrap_or(false)
+    } else {
+        false
+    }
+}
+
 // Iteratively replaces `param_ty` with `new_ty` in `substs`, and similarly for each resulting
 // projected type that is a type parameter. Returns `false` if replacing the types would have an
 // effect on the function signature beyond substituting `new_ty` for `param_ty`.
@@ -1439,8 +1508,8 @@ fn report<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, state: State, data
     }
 }
 
-impl Dereferencing {
-    fn check_local_usage<'tcx>(&mut self, cx: &LateContext<'tcx>, e: &Expr<'tcx>, local: HirId) {
+impl<'tcx> Dereferencing<'tcx> {
+    fn check_local_usage(&mut self, cx: &LateContext<'tcx>, e: &Expr<'tcx>, local: HirId) {
         if let Some(outer_pat) = self.ref_locals.get_mut(&local) {
             if let Some(pat) = outer_pat {
                 // Check for auto-deref
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 2dcefd78763..d9dfb4fc4e0 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -38,7 +38,6 @@ extern crate rustc_infer;
 extern crate rustc_lexer;
 extern crate rustc_lint;
 extern crate rustc_middle;
-extern crate rustc_mir_dataflow;
 extern crate rustc_parse;
 extern crate rustc_session;
 extern crate rustc_span;
diff --git a/clippy_lints/src/redundant_clone.rs b/clippy_lints/src/redundant_clone.rs
index 9fd86331ec7..aedbe08e3e4 100644
--- a/clippy_lints/src/redundant_clone.rs
+++ b/clippy_lints/src/redundant_clone.rs
@@ -1,25 +1,18 @@
 use clippy_utils::diagnostics::{span_lint_hir, span_lint_hir_and_then};
+use clippy_utils::mir::{visit_local_usage, LocalUsage, PossibleBorrowerMap};
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::{has_drop, is_copy, is_type_diagnostic_item, walk_ptrs_ty_depth};
 use clippy_utils::{fn_has_unsatisfiable_preds, match_def_path, paths};
 use if_chain::if_chain;
-use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::{def_id, Body, FnDecl, HirId};
-use rustc_index::bit_set::{BitSet, HybridBitSet};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::mir::{
-    self, traversal,
-    visit::{MutatingUseContext, NonMutatingUseContext, PlaceContext, Visitor as _},
-    Mutability,
-};
-use rustc_middle::ty::{self, visit::TypeVisitor, Ty};
-use rustc_mir_dataflow::{Analysis, AnalysisDomain, CallReturnPlaces, GenKill, GenKillAnalysis, ResultsCursor};
+use rustc_middle::mir;
+use rustc_middle::ty::{self, Ty};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::{BytePos, Span};
 use rustc_span::sym;
-use std::ops::ControlFlow;
 
 macro_rules! unwrap_or_continue {
     ($x:expr) => {
@@ -89,21 +82,7 @@ impl<'tcx> LateLintPass<'tcx> for RedundantClone {
 
         let mir = cx.tcx.optimized_mir(def_id.to_def_id());
 
-        let possible_origin = {
-            let mut vis = PossibleOriginVisitor::new(mir);
-            vis.visit_body(mir);
-            vis.into_map(cx)
-        };
-        let maybe_storage_live_result = MaybeStorageLive
-            .into_engine(cx.tcx, mir)
-            .pass_name("redundant_clone")
-            .iterate_to_fixpoint()
-            .into_results_cursor(mir);
-        let mut possible_borrower = {
-            let mut vis = PossibleBorrowerVisitor::new(cx, mir, possible_origin);
-            vis.visit_body(mir);
-            vis.into_map(cx, maybe_storage_live_result)
-        };
+        let mut possible_borrower = PossibleBorrowerMap::new(cx, mir);
 
         for (bb, bbdata) in mir.basic_blocks.iter_enumerated() {
             let terminator = bbdata.terminator();
@@ -374,403 +353,40 @@ struct CloneUsage {
     /// Whether the clone value is mutated.
     clone_consumed_or_mutated: bool,
 }
-fn visit_clone_usage(cloned: mir::Local, clone: mir::Local, mir: &mir::Body<'_>, bb: mir::BasicBlock) -> CloneUsage {
-    struct V {
-        cloned: mir::Local,
-        clone: mir::Local,
-        result: CloneUsage,
-    }
-    impl<'tcx> mir::visit::Visitor<'tcx> for V {
-        fn visit_basic_block_data(&mut self, block: mir::BasicBlock, data: &mir::BasicBlockData<'tcx>) {
-            let statements = &data.statements;
-            for (statement_index, statement) in statements.iter().enumerate() {
-                self.visit_statement(statement, mir::Location { block, statement_index });
-            }
-
-            self.visit_terminator(
-                data.terminator(),
-                mir::Location {
-                    block,
-                    statement_index: statements.len(),
-                },
-            );
-        }
-
-        fn visit_place(&mut self, place: &mir::Place<'tcx>, ctx: PlaceContext, loc: mir::Location) {
-            let local = place.local;
-
-            if local == self.cloned
-                && !matches!(
-                    ctx,
-                    PlaceContext::MutatingUse(MutatingUseContext::Drop) | PlaceContext::NonUse(_)
-                )
-            {
-                self.result.cloned_used = true;
-                self.result.cloned_consume_or_mutate_loc = self.result.cloned_consume_or_mutate_loc.or_else(|| {
-                    matches!(
-                        ctx,
-                        PlaceContext::NonMutatingUse(NonMutatingUseContext::Move)
-                            | PlaceContext::MutatingUse(MutatingUseContext::Borrow)
-                    )
-                    .then(|| loc)
-                });
-            } else if local == self.clone {
-                match ctx {
-                    PlaceContext::NonMutatingUse(NonMutatingUseContext::Move)
-                    | PlaceContext::MutatingUse(MutatingUseContext::Borrow) => {
-                        self.result.clone_consumed_or_mutated = true;
-                    },
-                    _ => {},
-                }
-            }
-        }
-    }
-
-    let init = CloneUsage {
-        cloned_used: false,
-        cloned_consume_or_mutate_loc: None,
-        // Consider non-temporary clones consumed.
-        // TODO: Actually check for mutation of non-temporaries.
-        clone_consumed_or_mutated: mir.local_kind(clone) != mir::LocalKind::Temp,
-    };
-    traversal::ReversePostorder::new(mir, bb)
-        .skip(1)
-        .fold(init, |usage, (tbb, tdata)| {
-            // Short-circuit
-            if (usage.cloned_used && usage.clone_consumed_or_mutated) ||
-                // Give up on loops
-                tdata.terminator().successors().any(|s| s == bb)
-            {
-                return CloneUsage {
-                    cloned_used: true,
-                    clone_consumed_or_mutated: true,
-                    ..usage
-                };
-            }
-
-            let mut v = V {
-                cloned,
-                clone,
-                result: usage,
-            };
-            v.visit_basic_block_data(tbb, tdata);
-            v.result
-        })
-}
-
-/// Determines liveness of each local purely based on `StorageLive`/`Dead`.
-#[derive(Copy, Clone)]
-struct MaybeStorageLive;
-
-impl<'tcx> AnalysisDomain<'tcx> for MaybeStorageLive {
-    type Domain = BitSet<mir::Local>;
-    const NAME: &'static str = "maybe_storage_live";
-
-    fn bottom_value(&self, body: &mir::Body<'tcx>) -> Self::Domain {
-        // bottom = dead
-        BitSet::new_empty(body.local_decls.len())
-    }
-
-    fn initialize_start_block(&self, body: &mir::Body<'tcx>, state: &mut Self::Domain) {
-        for arg in body.args_iter() {
-            state.insert(arg);
-        }
-    }
-}
-
-impl<'tcx> GenKillAnalysis<'tcx> for MaybeStorageLive {
-    type Idx = mir::Local;
-
-    fn statement_effect(&self, trans: &mut impl GenKill<Self::Idx>, stmt: &mir::Statement<'tcx>, _: mir::Location) {
-        match stmt.kind {
-            mir::StatementKind::StorageLive(l) => trans.gen(l),
-            mir::StatementKind::StorageDead(l) => trans.kill(l),
-            _ => (),
-        }
-    }
-
-    fn terminator_effect(
-        &self,
-        _trans: &mut impl GenKill<Self::Idx>,
-        _terminator: &mir::Terminator<'tcx>,
-        _loc: mir::Location,
-    ) {
-    }
-
-    fn call_return_effect(
-        &self,
-        _trans: &mut impl GenKill<Self::Idx>,
-        _block: mir::BasicBlock,
-        _return_places: CallReturnPlaces<'_, 'tcx>,
-    ) {
-        // Nothing to do when a call returns successfully
-    }
-}
-
-/// Collects the possible borrowers of each local.
-/// For example, `b = &a; c = &a;` will make `b` and (transitively) `c`
-/// possible borrowers of `a`.
-struct PossibleBorrowerVisitor<'a, 'tcx> {
-    possible_borrower: TransitiveRelation,
-    body: &'a mir::Body<'tcx>,
-    cx: &'a LateContext<'tcx>,
-    possible_origin: FxHashMap<mir::Local, HybridBitSet<mir::Local>>,
-}
-
-impl<'a, 'tcx> PossibleBorrowerVisitor<'a, 'tcx> {
-    fn new(
-        cx: &'a LateContext<'tcx>,
-        body: &'a mir::Body<'tcx>,
-        possible_origin: FxHashMap<mir::Local, HybridBitSet<mir::Local>>,
-    ) -> Self {
-        Self {
-            possible_borrower: TransitiveRelation::default(),
-            cx,
-            body,
-            possible_origin,
-        }
-    }
-
-    fn into_map(
-        self,
-        cx: &LateContext<'tcx>,
-        maybe_live: ResultsCursor<'tcx, 'tcx, MaybeStorageLive>,
-    ) -> PossibleBorrowerMap<'a, 'tcx> {
-        let mut map = FxHashMap::default();
-        for row in (1..self.body.local_decls.len()).map(mir::Local::from_usize) {
-            if is_copy(cx, self.body.local_decls[row].ty) {
-                continue;
-            }
-
-            let mut borrowers = self.possible_borrower.reachable_from(row, self.body.local_decls.len());
-            borrowers.remove(mir::Local::from_usize(0));
-            if !borrowers.is_empty() {
-                map.insert(row, borrowers);
-            }
-        }
-
-        let bs = BitSet::new_empty(self.body.local_decls.len());
-        PossibleBorrowerMap {
-            map,
-            maybe_live,
-            bitset: (bs.clone(), bs),
-        }
-    }
-}
-
-impl<'a, 'tcx> mir::visit::Visitor<'tcx> for PossibleBorrowerVisitor<'a, 'tcx> {
-    fn visit_assign(&mut self, place: &mir::Place<'tcx>, rvalue: &mir::Rvalue<'_>, _location: mir::Location) {
-        let lhs = place.local;
-        match rvalue {
-            mir::Rvalue::Ref(_, _, borrowed) => {
-                self.possible_borrower.add(borrowed.local, lhs);
-            },
-            other => {
-                if ContainsRegion
-                    .visit_ty(place.ty(&self.body.local_decls, self.cx.tcx).ty)
-                    .is_continue()
-                {
-                    return;
-                }
-                rvalue_locals(other, |rhs| {
-                    if lhs != rhs {
-                        self.possible_borrower.add(rhs, lhs);
-                    }
-                });
-            },
-        }
-    }
-
-    fn visit_terminator(&mut self, terminator: &mir::Terminator<'_>, _loc: mir::Location) {
-        if let mir::TerminatorKind::Call {
-            args,
-            destination: mir::Place { local: dest, .. },
-            ..
-        } = &terminator.kind
-        {
-            // TODO add doc
-            // If the call returns something with lifetimes,
-            // let's conservatively assume the returned value contains lifetime of all the arguments.
-            // For example, given `let y: Foo<'a> = foo(x)`, `y` is considered to be a possible borrower of `x`.
-
-            let mut immutable_borrowers = vec![];
-            let mut mutable_borrowers = vec![];
-
-            for op in args {
-                match op {
-                    mir::Operand::Copy(p) | mir::Operand::Move(p) => {
-                        if let ty::Ref(_, _, Mutability::Mut) = self.body.local_decls[p.local].ty.kind() {
-                            mutable_borrowers.push(p.local);
-                        } else {
-                            immutable_borrowers.push(p.local);
-                        }
-                    },
-                    mir::Operand::Constant(..) => (),
-                }
-            }
-
-            let mut mutable_variables: Vec<mir::Local> = mutable_borrowers
-                .iter()
-                .filter_map(|r| self.possible_origin.get(r))
-                .flat_map(HybridBitSet::iter)
-                .collect();
-
-            if ContainsRegion.visit_ty(self.body.local_decls[*dest].ty).is_break() {
-                mutable_variables.push(*dest);
-            }
-
-            for y in mutable_variables {
-                for x in &immutable_borrowers {
-                    self.possible_borrower.add(*x, y);
-                }
-                for x in &mutable_borrowers {
-                    self.possible_borrower.add(*x, y);
-                }
-            }
-        }
-    }
-}
-
-/// Collect possible borrowed for every `&mut` local.
-/// For example, `_1 = &mut _2` generate _1: {_2,...}
-/// Known Problems: not sure all borrowed are tracked
-struct PossibleOriginVisitor<'a, 'tcx> {
-    possible_origin: TransitiveRelation,
-    body: &'a mir::Body<'tcx>,
-}
-
-impl<'a, 'tcx> PossibleOriginVisitor<'a, 'tcx> {
-    fn new(body: &'a mir::Body<'tcx>) -> Self {
-        Self {
-            possible_origin: TransitiveRelation::default(),
-            body,
-        }
-    }
-
-    fn into_map(self, cx: &LateContext<'tcx>) -> FxHashMap<mir::Local, HybridBitSet<mir::Local>> {
-        let mut map = FxHashMap::default();
-        for row in (1..self.body.local_decls.len()).map(mir::Local::from_usize) {
-            if is_copy(cx, self.body.local_decls[row].ty) {
-                continue;
-            }
-
-            let mut borrowers = self.possible_origin.reachable_from(row, self.body.local_decls.len());
-            borrowers.remove(mir::Local::from_usize(0));
-            if !borrowers.is_empty() {
-                map.insert(row, borrowers);
-            }
-        }
-        map
-    }
-}
-
-impl<'a, 'tcx> mir::visit::Visitor<'tcx> for PossibleOriginVisitor<'a, 'tcx> {
-    fn visit_assign(&mut self, place: &mir::Place<'tcx>, rvalue: &mir::Rvalue<'_>, _location: mir::Location) {
-        let lhs = place.local;
-        match rvalue {
-            // Only consider `&mut`, which can modify origin place
-            mir::Rvalue::Ref(_, rustc_middle::mir::BorrowKind::Mut { .. }, borrowed) |
-            // _2: &mut _;
-            // _3 = move _2
-            mir::Rvalue::Use(mir::Operand::Move(borrowed))  |
-            // _3 = move _2 as &mut _;
-            mir::Rvalue::Cast(_, mir::Operand::Move(borrowed), _)
-                => {
-                self.possible_origin.add(lhs, borrowed.local);
-            },
-            _ => {},
-        }
-    }
-}
-
-struct ContainsRegion;
-
-impl TypeVisitor<'_> for ContainsRegion {
-    type BreakTy = ();
-
-    fn visit_region(&mut self, _: ty::Region<'_>) -> ControlFlow<Self::BreakTy> {
-        ControlFlow::BREAK
-    }
-}
-
-fn rvalue_locals(rvalue: &mir::Rvalue<'_>, mut visit: impl FnMut(mir::Local)) {
-    use rustc_middle::mir::Rvalue::{Aggregate, BinaryOp, Cast, CheckedBinaryOp, Repeat, UnaryOp, Use};
-
-    let mut visit_op = |op: &mir::Operand<'_>| match op {
-        mir::Operand::Copy(p) | mir::Operand::Move(p) => visit(p.local),
-        mir::Operand::Constant(..) => (),
-    };
 
-    match rvalue {
-        Use(op) | Repeat(op, _) | Cast(_, op, _) | UnaryOp(_, op) => visit_op(op),
-        Aggregate(_, ops) => ops.iter().for_each(visit_op),
-        BinaryOp(_, box (lhs, rhs)) | CheckedBinaryOp(_, box (lhs, rhs)) => {
-            visit_op(lhs);
-            visit_op(rhs);
+fn visit_clone_usage(cloned: mir::Local, clone: mir::Local, mir: &mir::Body<'_>, bb: mir::BasicBlock) -> CloneUsage {
+    if let Some((
+        LocalUsage {
+            local_use_locs: cloned_use_locs,
+            local_consume_or_mutate_locs: cloned_consume_or_mutate_locs,
         },
-        _ => (),
-    }
-}
-
-/// Result of `PossibleBorrowerVisitor`.
-struct PossibleBorrowerMap<'a, 'tcx> {
-    /// Mapping `Local -> its possible borrowers`
-    map: FxHashMap<mir::Local, HybridBitSet<mir::Local>>,
-    maybe_live: ResultsCursor<'a, 'tcx, MaybeStorageLive>,
-    // Caches to avoid allocation of `BitSet` on every query
-    bitset: (BitSet<mir::Local>, BitSet<mir::Local>),
-}
-
-impl PossibleBorrowerMap<'_, '_> {
-    /// Returns true if the set of borrowers of `borrowed` living at `at` matches with `borrowers`.
-    fn only_borrowers(&mut self, borrowers: &[mir::Local], borrowed: mir::Local, at: mir::Location) -> bool {
-        self.maybe_live.seek_after_primary_effect(at);
-
-        self.bitset.0.clear();
-        let maybe_live = &mut self.maybe_live;
-        if let Some(bitset) = self.map.get(&borrowed) {
-            for b in bitset.iter().filter(move |b| maybe_live.contains(*b)) {
-                self.bitset.0.insert(b);
-            }
-        } else {
-            return false;
-        }
-
-        self.bitset.1.clear();
-        for b in borrowers {
-            self.bitset.1.insert(*b);
+        LocalUsage {
+            local_use_locs: _,
+            local_consume_or_mutate_locs: clone_consume_or_mutate_locs,
+        },
+    )) = visit_local_usage(
+        &[cloned, clone],
+        mir,
+        mir::Location {
+            block: bb,
+            statement_index: mir.basic_blocks[bb].statements.len(),
+        },
+    )
+    .map(|mut vec| (vec.remove(0), vec.remove(0)))
+    {
+        CloneUsage {
+            cloned_used: !cloned_use_locs.is_empty(),
+            cloned_consume_or_mutate_loc: cloned_consume_or_mutate_locs.first().copied(),
+            // Consider non-temporary clones consumed.
+            // TODO: Actually check for mutation of non-temporaries.
+            clone_consumed_or_mutated: mir.local_kind(clone) != mir::LocalKind::Temp
+                || !clone_consume_or_mutate_locs.is_empty(),
         }
-
-        self.bitset.0 == self.bitset.1
-    }
-
-    fn local_is_alive_at(&mut self, local: mir::Local, at: mir::Location) -> bool {
-        self.maybe_live.seek_after_primary_effect(at);
-        self.maybe_live.contains(local)
-    }
-}
-
-#[derive(Default)]
-struct TransitiveRelation {
-    relations: FxHashMap<mir::Local, Vec<mir::Local>>,
-}
-impl TransitiveRelation {
-    fn add(&mut self, a: mir::Local, b: mir::Local) {
-        self.relations.entry(a).or_default().push(b);
-    }
-
-    fn reachable_from(&self, a: mir::Local, domain_size: usize) -> HybridBitSet<mir::Local> {
-        let mut seen = HybridBitSet::new_empty(domain_size);
-        let mut stack = vec![a];
-        while let Some(u) = stack.pop() {
-            if let Some(edges) = self.relations.get(&u) {
-                for &v in edges {
-                    if seen.insert(v) {
-                        stack.push(v);
-                    }
-                }
-            }
+    } else {
+        CloneUsage {
+            cloned_used: true,
+            cloned_consume_or_mutate_loc: None,
+            clone_consumed_or_mutated: true,
         }
-        seen
     }
 }
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 42374fdd7ba..3597c58e072 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -25,10 +25,12 @@ extern crate rustc_data_structures;
 extern crate rustc_errors;
 extern crate rustc_hir;
 extern crate rustc_hir_analysis;
+extern crate rustc_index;
 extern crate rustc_infer;
 extern crate rustc_lexer;
 extern crate rustc_lint;
 extern crate rustc_middle;
+extern crate rustc_mir_dataflow;
 extern crate rustc_parse_format;
 extern crate rustc_session;
 extern crate rustc_span;
@@ -48,6 +50,7 @@ pub mod eager_or_lazy;
 pub mod higher;
 mod hir_utils;
 pub mod macros;
+pub mod mir;
 pub mod msrvs;
 pub mod numeric_literal;
 pub mod paths;
diff --git a/clippy_utils/src/mir/maybe_storage_live.rs b/clippy_utils/src/mir/maybe_storage_live.rs
new file mode 100644
index 00000000000..d262b335d99
--- /dev/null
+++ b/clippy_utils/src/mir/maybe_storage_live.rs
@@ -0,0 +1,52 @@
+use rustc_index::bit_set::BitSet;
+use rustc_middle::mir;
+use rustc_mir_dataflow::{AnalysisDomain, CallReturnPlaces, GenKill, GenKillAnalysis};
+
+/// Determines liveness of each local purely based on `StorageLive`/`Dead`.
+#[derive(Copy, Clone)]
+pub(super) struct MaybeStorageLive;
+
+impl<'tcx> AnalysisDomain<'tcx> for MaybeStorageLive {
+    type Domain = BitSet<mir::Local>;
+    const NAME: &'static str = "maybe_storage_live";
+
+    fn bottom_value(&self, body: &mir::Body<'tcx>) -> Self::Domain {
+        // bottom = dead
+        BitSet::new_empty(body.local_decls.len())
+    }
+
+    fn initialize_start_block(&self, body: &mir::Body<'tcx>, state: &mut Self::Domain) {
+        for arg in body.args_iter() {
+            state.insert(arg);
+        }
+    }
+}
+
+impl<'tcx> GenKillAnalysis<'tcx> for MaybeStorageLive {
+    type Idx = mir::Local;
+
+    fn statement_effect(&self, trans: &mut impl GenKill<Self::Idx>, stmt: &mir::Statement<'tcx>, _: mir::Location) {
+        match stmt.kind {
+            mir::StatementKind::StorageLive(l) => trans.gen(l),
+            mir::StatementKind::StorageDead(l) => trans.kill(l),
+            _ => (),
+        }
+    }
+
+    fn terminator_effect(
+        &self,
+        _trans: &mut impl GenKill<Self::Idx>,
+        _terminator: &mir::Terminator<'tcx>,
+        _loc: mir::Location,
+    ) {
+    }
+
+    fn call_return_effect(
+        &self,
+        _trans: &mut impl GenKill<Self::Idx>,
+        _block: mir::BasicBlock,
+        _return_places: CallReturnPlaces<'_, 'tcx>,
+    ) {
+        // Nothing to do when a call returns successfully
+    }
+}
diff --git a/clippy_utils/src/mir/mod.rs b/clippy_utils/src/mir/mod.rs
new file mode 100644
index 00000000000..c8aa6f3e595
--- /dev/null
+++ b/clippy_utils/src/mir/mod.rs
@@ -0,0 +1,165 @@
+use rustc_hir::{Expr, HirId};
+use rustc_middle::mir::visit::{MutatingUseContext, NonMutatingUseContext, PlaceContext, Visitor};
+use rustc_middle::mir::{
+    traversal, Body, InlineAsmOperand, Local, Location, Place, StatementKind, TerminatorKind, START_BLOCK,
+};
+use rustc_middle::ty::TyCtxt;
+
+mod maybe_storage_live;
+
+mod possible_borrower;
+pub use possible_borrower::PossibleBorrowerMap;
+
+mod possible_origin;
+
+mod transitive_relation;
+
+#[derive(Clone, Debug, Default)]
+pub struct LocalUsage {
+    /// The locations where the local is used, if any.
+    pub local_use_locs: Vec<Location>,
+    /// The locations where the local is consumed or mutated, if any.
+    pub local_consume_or_mutate_locs: Vec<Location>,
+}
+
+pub fn visit_local_usage(locals: &[Local], mir: &Body<'_>, location: Location) -> Option<Vec<LocalUsage>> {
+    let init = vec![
+        LocalUsage {
+            local_use_locs: Vec::new(),
+            local_consume_or_mutate_locs: Vec::new(),
+        };
+        locals.len()
+    ];
+
+    traversal::ReversePostorder::new(mir, location.block).try_fold(init, |usage, (tbb, tdata)| {
+        // Give up on loops
+        if tdata.terminator().successors().any(|s| s == location.block) {
+            return None;
+        }
+
+        let mut v = V {
+            locals,
+            location,
+            results: usage,
+        };
+        v.visit_basic_block_data(tbb, tdata);
+        Some(v.results)
+    })
+}
+
+struct V<'a> {
+    locals: &'a [Local],
+    location: Location,
+    results: Vec<LocalUsage>,
+}
+
+impl<'a, 'tcx> Visitor<'tcx> for V<'a> {
+    fn visit_place(&mut self, place: &Place<'tcx>, ctx: PlaceContext, loc: Location) {
+        if loc.block == self.location.block && loc.statement_index <= self.location.statement_index {
+            return;
+        }
+
+        let local = place.local;
+
+        for (i, self_local) in self.locals.iter().enumerate() {
+            if local == *self_local {
+                if !matches!(
+                    ctx,
+                    PlaceContext::MutatingUse(MutatingUseContext::Drop) | PlaceContext::NonUse(_)
+                ) {
+                    self.results[i].local_use_locs.push(loc);
+                }
+                if matches!(
+                    ctx,
+                    PlaceContext::NonMutatingUse(NonMutatingUseContext::Move)
+                        | PlaceContext::MutatingUse(MutatingUseContext::Borrow)
+                ) {
+                    self.results[i].local_consume_or_mutate_locs.push(loc);
+                }
+            }
+        }
+    }
+}
+
+/// Convenience wrapper around `visit_local_usage`.
+pub fn used_exactly_once(mir: &rustc_middle::mir::Body<'_>, local: rustc_middle::mir::Local) -> Option<bool> {
+    visit_local_usage(
+        &[local],
+        mir,
+        Location {
+            block: START_BLOCK,
+            statement_index: 0,
+        },
+    )
+    .map(|mut vec| {
+        let LocalUsage { local_use_locs, .. } = vec.remove(0);
+        local_use_locs
+            .into_iter()
+            .filter(|location| !is_local_assignment(mir, local, *location))
+            .count()
+            == 1
+    })
+}
+
+/// Returns the `mir::Body` containing the node associated with `hir_id`.
+#[allow(clippy::module_name_repetitions)]
+pub fn enclosing_mir(tcx: TyCtxt<'_>, hir_id: HirId) -> &Body<'_> {
+    let body_owner_local_def_id = tcx.hir().enclosing_body_owner(hir_id);
+    tcx.optimized_mir(body_owner_local_def_id.to_def_id())
+}
+
+/// Tries to determine the `Local` corresponding to `expr`, if any.
+/// This function is expensive and should be used sparingly.
+pub fn expr_local(tcx: TyCtxt<'_>, expr: &Expr<'_>) -> Option<Local> {
+    let mir = enclosing_mir(tcx, expr.hir_id);
+    mir.local_decls.iter_enumerated().find_map(|(local, local_decl)| {
+        if local_decl.source_info.span == expr.span {
+            Some(local)
+        } else {
+            None
+        }
+    })
+}
+
+/// Returns a vector of `mir::Location` where `local` is assigned. Each statement referred to has
+/// kind `StatementKind::Assign`.
+pub fn local_assignments(mir: &Body<'_>, local: Local) -> Vec<Location> {
+    let mut locations = Vec::new();
+    for (block, data) in mir.basic_blocks.iter_enumerated() {
+        for statement_index in 0..=data.statements.len() {
+            let location = Location { block, statement_index };
+            if is_local_assignment(mir, local, location) {
+                locations.push(location);
+            }
+        }
+    }
+    locations
+}
+
+// `is_local_assignment` is based on `is_place_assignment`:
+// https://github.com/rust-lang/rust/blob/b7413511dc85ec01ef4b91785f86614589ac6103/compiler/rustc_middle/src/mir/visit.rs#L1350
+fn is_local_assignment(mir: &Body<'_>, local: Local, location: Location) -> bool {
+    let Location { block, statement_index } = location;
+    let basic_block = &mir.basic_blocks[block];
+    if statement_index < basic_block.statements.len() {
+        let statement = &basic_block.statements[statement_index];
+        if let StatementKind::Assign(box (place, _)) = statement.kind {
+            place.as_local() == Some(local)
+        } else {
+            false
+        }
+    } else {
+        let terminator = basic_block.terminator();
+        match &terminator.kind {
+            TerminatorKind::Call { destination, .. } => destination.as_local() == Some(local),
+            TerminatorKind::InlineAsm { operands, .. } => operands.iter().any(|operand| {
+                if let InlineAsmOperand::Out { place: Some(place), .. } = operand {
+                    place.as_local() == Some(local)
+                } else {
+                    false
+                }
+            }),
+            _ => false,
+        }
+    }
+}
diff --git a/clippy_utils/src/mir/possible_borrower.rs b/clippy_utils/src/mir/possible_borrower.rs
new file mode 100644
index 00000000000..25717bf3d2f
--- /dev/null
+++ b/clippy_utils/src/mir/possible_borrower.rs
@@ -0,0 +1,241 @@
+use super::{
+    maybe_storage_live::MaybeStorageLive, possible_origin::PossibleOriginVisitor,
+    transitive_relation::TransitiveRelation,
+};
+use crate::ty::is_copy;
+use rustc_data_structures::fx::FxHashMap;
+use rustc_index::bit_set::{BitSet, HybridBitSet};
+use rustc_lint::LateContext;
+use rustc_middle::mir::{self, visit::Visitor as _, Mutability};
+use rustc_middle::ty::{self, visit::TypeVisitor};
+use rustc_mir_dataflow::{Analysis, ResultsCursor};
+use std::ops::ControlFlow;
+
+/// Collects the possible borrowers of each local.
+/// For example, `b = &a; c = &a;` will make `b` and (transitively) `c`
+/// possible borrowers of `a`.
+#[allow(clippy::module_name_repetitions)]
+struct PossibleBorrowerVisitor<'a, 'b, 'tcx> {
+    possible_borrower: TransitiveRelation,
+    body: &'b mir::Body<'tcx>,
+    cx: &'a LateContext<'tcx>,
+    possible_origin: FxHashMap<mir::Local, HybridBitSet<mir::Local>>,
+}
+
+impl<'a, 'b, 'tcx> PossibleBorrowerVisitor<'a, 'b, 'tcx> {
+    fn new(
+        cx: &'a LateContext<'tcx>,
+        body: &'b mir::Body<'tcx>,
+        possible_origin: FxHashMap<mir::Local, HybridBitSet<mir::Local>>,
+    ) -> Self {
+        Self {
+            possible_borrower: TransitiveRelation::default(),
+            cx,
+            body,
+            possible_origin,
+        }
+    }
+
+    fn into_map(
+        self,
+        cx: &'a LateContext<'tcx>,
+        maybe_live: ResultsCursor<'b, 'tcx, MaybeStorageLive>,
+    ) -> PossibleBorrowerMap<'b, 'tcx> {
+        let mut map = FxHashMap::default();
+        for row in (1..self.body.local_decls.len()).map(mir::Local::from_usize) {
+            if is_copy(cx, self.body.local_decls[row].ty) {
+                continue;
+            }
+
+            let mut borrowers = self.possible_borrower.reachable_from(row, self.body.local_decls.len());
+            borrowers.remove(mir::Local::from_usize(0));
+            if !borrowers.is_empty() {
+                map.insert(row, borrowers);
+            }
+        }
+
+        let bs = BitSet::new_empty(self.body.local_decls.len());
+        PossibleBorrowerMap {
+            map,
+            maybe_live,
+            bitset: (bs.clone(), bs),
+        }
+    }
+}
+
+impl<'a, 'b, 'tcx> mir::visit::Visitor<'tcx> for PossibleBorrowerVisitor<'a, 'b, 'tcx> {
+    fn visit_assign(&mut self, place: &mir::Place<'tcx>, rvalue: &mir::Rvalue<'_>, _location: mir::Location) {
+        let lhs = place.local;
+        match rvalue {
+            mir::Rvalue::Ref(_, _, borrowed) => {
+                self.possible_borrower.add(borrowed.local, lhs);
+            },
+            other => {
+                if ContainsRegion
+                    .visit_ty(place.ty(&self.body.local_decls, self.cx.tcx).ty)
+                    .is_continue()
+                {
+                    return;
+                }
+                rvalue_locals(other, |rhs| {
+                    if lhs != rhs {
+                        self.possible_borrower.add(rhs, lhs);
+                    }
+                });
+            },
+        }
+    }
+
+    fn visit_terminator(&mut self, terminator: &mir::Terminator<'_>, _loc: mir::Location) {
+        if let mir::TerminatorKind::Call {
+            args,
+            destination: mir::Place { local: dest, .. },
+            ..
+        } = &terminator.kind
+        {
+            // TODO add doc
+            // If the call returns something with lifetimes,
+            // let's conservatively assume the returned value contains lifetime of all the arguments.
+            // For example, given `let y: Foo<'a> = foo(x)`, `y` is considered to be a possible borrower of `x`.
+
+            let mut immutable_borrowers = vec![];
+            let mut mutable_borrowers = vec![];
+
+            for op in args {
+                match op {
+                    mir::Operand::Copy(p) | mir::Operand::Move(p) => {
+                        if let ty::Ref(_, _, Mutability::Mut) = self.body.local_decls[p.local].ty.kind() {
+                            mutable_borrowers.push(p.local);
+                        } else {
+                            immutable_borrowers.push(p.local);
+                        }
+                    },
+                    mir::Operand::Constant(..) => (),
+                }
+            }
+
+            let mut mutable_variables: Vec<mir::Local> = mutable_borrowers
+                .iter()
+                .filter_map(|r| self.possible_origin.get(r))
+                .flat_map(HybridBitSet::iter)
+                .collect();
+
+            if ContainsRegion.visit_ty(self.body.local_decls[*dest].ty).is_break() {
+                mutable_variables.push(*dest);
+            }
+
+            for y in mutable_variables {
+                for x in &immutable_borrowers {
+                    self.possible_borrower.add(*x, y);
+                }
+                for x in &mutable_borrowers {
+                    self.possible_borrower.add(*x, y);
+                }
+            }
+        }
+    }
+}
+
+struct ContainsRegion;
+
+impl TypeVisitor<'_> for ContainsRegion {
+    type BreakTy = ();
+
+    fn visit_region(&mut self, _: ty::Region<'_>) -> ControlFlow<Self::BreakTy> {
+        ControlFlow::BREAK
+    }
+}
+
+fn rvalue_locals(rvalue: &mir::Rvalue<'_>, mut visit: impl FnMut(mir::Local)) {
+    use rustc_middle::mir::Rvalue::{Aggregate, BinaryOp, Cast, CheckedBinaryOp, Repeat, UnaryOp, Use};
+
+    let mut visit_op = |op: &mir::Operand<'_>| match op {
+        mir::Operand::Copy(p) | mir::Operand::Move(p) => visit(p.local),
+        mir::Operand::Constant(..) => (),
+    };
+
+    match rvalue {
+        Use(op) | Repeat(op, _) | Cast(_, op, _) | UnaryOp(_, op) => visit_op(op),
+        Aggregate(_, ops) => ops.iter().for_each(visit_op),
+        BinaryOp(_, box (lhs, rhs)) | CheckedBinaryOp(_, box (lhs, rhs)) => {
+            visit_op(lhs);
+            visit_op(rhs);
+        },
+        _ => (),
+    }
+}
+
+/// Result of `PossibleBorrowerVisitor`.
+#[allow(clippy::module_name_repetitions)]
+pub struct PossibleBorrowerMap<'b, 'tcx> {
+    /// Mapping `Local -> its possible borrowers`
+    pub map: FxHashMap<mir::Local, HybridBitSet<mir::Local>>,
+    maybe_live: ResultsCursor<'b, 'tcx, MaybeStorageLive>,
+    // Caches to avoid allocation of `BitSet` on every query
+    pub bitset: (BitSet<mir::Local>, BitSet<mir::Local>),
+}
+
+impl<'a, 'b, 'tcx> PossibleBorrowerMap<'b, 'tcx> {
+    pub fn new(cx: &'a LateContext<'tcx>, mir: &'b mir::Body<'tcx>) -> Self {
+        let possible_origin = {
+            let mut vis = PossibleOriginVisitor::new(mir);
+            vis.visit_body(mir);
+            vis.into_map(cx)
+        };
+        let maybe_storage_live_result = MaybeStorageLive
+            .into_engine(cx.tcx, mir)
+            .pass_name("redundant_clone")
+            .iterate_to_fixpoint()
+            .into_results_cursor(mir);
+        let mut vis = PossibleBorrowerVisitor::new(cx, mir, possible_origin);
+        vis.visit_body(mir);
+        vis.into_map(cx, maybe_storage_live_result)
+    }
+
+    /// Returns true if the set of borrowers of `borrowed` living at `at` matches with `borrowers`.
+    pub fn only_borrowers(&mut self, borrowers: &[mir::Local], borrowed: mir::Local, at: mir::Location) -> bool {
+        self.bounded_borrowers(borrowers, borrowers, borrowed, at)
+    }
+
+    /// Returns true if the set of borrowers of `borrowed` living at `at` includes at least `below`
+    /// but no more than `above`.
+    pub fn bounded_borrowers(
+        &mut self,
+        below: &[mir::Local],
+        above: &[mir::Local],
+        borrowed: mir::Local,
+        at: mir::Location,
+    ) -> bool {
+        self.maybe_live.seek_after_primary_effect(at);
+
+        self.bitset.0.clear();
+        let maybe_live = &mut self.maybe_live;
+        if let Some(bitset) = self.map.get(&borrowed) {
+            for b in bitset.iter().filter(move |b| maybe_live.contains(*b)) {
+                self.bitset.0.insert(b);
+            }
+        } else {
+            return false;
+        }
+
+        self.bitset.1.clear();
+        for b in below {
+            self.bitset.1.insert(*b);
+        }
+
+        if !self.bitset.0.superset(&self.bitset.1) {
+            return false;
+        }
+
+        for b in above {
+            self.bitset.0.remove(*b);
+        }
+
+        self.bitset.0.is_empty()
+    }
+
+    pub fn local_is_alive_at(&mut self, local: mir::Local, at: mir::Location) -> bool {
+        self.maybe_live.seek_after_primary_effect(at);
+        self.maybe_live.contains(local)
+    }
+}
diff --git a/clippy_utils/src/mir/possible_origin.rs b/clippy_utils/src/mir/possible_origin.rs
new file mode 100644
index 00000000000..8e7513d740a
--- /dev/null
+++ b/clippy_utils/src/mir/possible_origin.rs
@@ -0,0 +1,59 @@
+use super::transitive_relation::TransitiveRelation;
+use crate::ty::is_copy;
+use rustc_data_structures::fx::FxHashMap;
+use rustc_index::bit_set::HybridBitSet;
+use rustc_lint::LateContext;
+use rustc_middle::mir;
+
+/// Collect possible borrowed for every `&mut` local.
+/// For example, `_1 = &mut _2` generate _1: {_2,...}
+/// Known Problems: not sure all borrowed are tracked
+#[allow(clippy::module_name_repetitions)]
+pub(super) struct PossibleOriginVisitor<'a, 'tcx> {
+    possible_origin: TransitiveRelation,
+    body: &'a mir::Body<'tcx>,
+}
+
+impl<'a, 'tcx> PossibleOriginVisitor<'a, 'tcx> {
+    pub fn new(body: &'a mir::Body<'tcx>) -> Self {
+        Self {
+            possible_origin: TransitiveRelation::default(),
+            body,
+        }
+    }
+
+    pub fn into_map(self, cx: &LateContext<'tcx>) -> FxHashMap<mir::Local, HybridBitSet<mir::Local>> {
+        let mut map = FxHashMap::default();
+        for row in (1..self.body.local_decls.len()).map(mir::Local::from_usize) {
+            if is_copy(cx, self.body.local_decls[row].ty) {
+                continue;
+            }
+
+            let mut borrowers = self.possible_origin.reachable_from(row, self.body.local_decls.len());
+            borrowers.remove(mir::Local::from_usize(0));
+            if !borrowers.is_empty() {
+                map.insert(row, borrowers);
+            }
+        }
+        map
+    }
+}
+
+impl<'a, 'tcx> mir::visit::Visitor<'tcx> for PossibleOriginVisitor<'a, 'tcx> {
+    fn visit_assign(&mut self, place: &mir::Place<'tcx>, rvalue: &mir::Rvalue<'_>, _location: mir::Location) {
+        let lhs = place.local;
+        match rvalue {
+            // Only consider `&mut`, which can modify origin place
+            mir::Rvalue::Ref(_, rustc_middle::mir::BorrowKind::Mut { .. }, borrowed) |
+            // _2: &mut _;
+            // _3 = move _2
+            mir::Rvalue::Use(mir::Operand::Move(borrowed))  |
+            // _3 = move _2 as &mut _;
+            mir::Rvalue::Cast(_, mir::Operand::Move(borrowed), _)
+                => {
+                self.possible_origin.add(lhs, borrowed.local);
+            },
+            _ => {},
+        }
+    }
+}
diff --git a/clippy_utils/src/mir/transitive_relation.rs b/clippy_utils/src/mir/transitive_relation.rs
new file mode 100644
index 00000000000..7fe2960739f
--- /dev/null
+++ b/clippy_utils/src/mir/transitive_relation.rs
@@ -0,0 +1,29 @@
+use rustc_data_structures::fx::FxHashMap;
+use rustc_index::bit_set::HybridBitSet;
+use rustc_middle::mir;
+
+#[derive(Default)]
+pub(super) struct TransitiveRelation {
+    relations: FxHashMap<mir::Local, Vec<mir::Local>>,
+}
+
+impl TransitiveRelation {
+    pub fn add(&mut self, a: mir::Local, b: mir::Local) {
+        self.relations.entry(a).or_default().push(b);
+    }
+
+    pub fn reachable_from(&self, a: mir::Local, domain_size: usize) -> HybridBitSet<mir::Local> {
+        let mut seen = HybridBitSet::new_empty(domain_size);
+        let mut stack = vec![a];
+        while let Some(u) = stack.pop() {
+            if let Some(edges) = self.relations.get(&u) {
+                for &v in edges {
+                    if seen.insert(v) {
+                        stack.push(v);
+                    }
+                }
+            }
+        }
+        seen
+    }
+}
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index 13938645fc3..78adc453654 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -119,17 +119,11 @@ pub const RANGE_ARGUMENT_TRAIT: [&str; 3] = ["core", "ops", "RangeBounds"];
 pub const RC_PTR_EQ: [&str; 4] = ["alloc", "rc", "Rc", "ptr_eq"];
 pub const REFCELL_REF: [&str; 3] = ["core", "cell", "Ref"];
 pub const REFCELL_REFMUT: [&str; 3] = ["core", "cell", "RefMut"];
-#[expect(clippy::invalid_paths)] // internal lints do not know about all external crates
 pub const REGEX_BUILDER_NEW: [&str; 5] = ["regex", "re_builder", "unicode", "RegexBuilder", "new"];
-#[expect(clippy::invalid_paths)] // internal lints do not know about all external crates
 pub const REGEX_BYTES_BUILDER_NEW: [&str; 5] = ["regex", "re_builder", "bytes", "RegexBuilder", "new"];
-#[expect(clippy::invalid_paths)] // internal lints do not know about all external crates
 pub const REGEX_BYTES_NEW: [&str; 4] = ["regex", "re_bytes", "Regex", "new"];
-#[expect(clippy::invalid_paths)] // internal lints do not know about all external crates
 pub const REGEX_BYTES_SET_NEW: [&str; 5] = ["regex", "re_set", "bytes", "RegexSet", "new"];
-#[expect(clippy::invalid_paths)] // internal lints do not know about all external crates
 pub const REGEX_NEW: [&str; 4] = ["regex", "re_unicode", "Regex", "new"];
-#[expect(clippy::invalid_paths)] // internal lints do not know about all external crates
 pub const REGEX_SET_NEW: [&str; 5] = ["regex", "re_set", "unicode", "RegexSet", "new"];
 /// Preferably use the diagnostic item `sym::Result` where possible
 pub const RESULT: [&str; 3] = ["core", "result", "Result"];
diff --git a/tests/ui/needless_borrow.fixed b/tests/ui/needless_borrow.fixed
index aa2687159ef..340e89d2db1 100644
--- a/tests/ui/needless_borrow.fixed
+++ b/tests/ui/needless_borrow.fixed
@@ -3,7 +3,11 @@
 
 #[warn(clippy::all, clippy::needless_borrow)]
 #[allow(unused_variables)]
-#[allow(clippy::uninlined_format_args, clippy::unnecessary_mut_passed)]
+#[allow(
+    clippy::uninlined_format_args,
+    clippy::unnecessary_mut_passed,
+    clippy::unnecessary_to_owned
+)]
 fn main() {
     let a = 5;
     let ref_a = &a;
@@ -134,6 +138,7 @@ fn main() {
     multiple_constraints([[""]]);
     multiple_constraints_normalizes_to_same(X, X);
     let _ = Some("").unwrap_or("");
+    let _ = std::fs::write("x", "".to_string());
 
     only_sized(&""); // Don't lint. `Sized` is only bound
     let _ = std::any::Any::type_id(&""); // Don't lint. `Any` is only bound
@@ -276,8 +281,9 @@ mod copyable_iterator {
     fn dont_warn(mut x: Iter) {
         takes_iter(&mut x);
     }
+    #[allow(unused_mut)]
     fn warn(mut x: &mut Iter) {
-        takes_iter(&mut x)
+        takes_iter(x)
     }
 }
 
@@ -327,3 +333,55 @@ fn issue9383() {
         ManuallyDrop::drop(&mut ocean.coral);
     }
 }
+
+#[allow(dead_code)]
+fn closure_test() {
+    let env = "env".to_owned();
+    let arg = "arg".to_owned();
+    let f = |arg| {
+        let loc = "loc".to_owned();
+        let _ = std::fs::write("x", &env); // Don't lint. In environment
+        let _ = std::fs::write("x", arg);
+        let _ = std::fs::write("x", loc);
+    };
+    let _ = std::fs::write("x", &env); // Don't lint. Borrowed by `f`
+    f(arg);
+}
+
+#[allow(dead_code)]
+mod significant_drop {
+    #[derive(Debug)]
+    struct X;
+
+    #[derive(Debug)]
+    struct Y;
+
+    impl Drop for Y {
+        fn drop(&mut self) {}
+    }
+
+    fn foo(x: X, y: Y) {
+        debug(x);
+        debug(&y); // Don't lint. Has significant drop
+    }
+
+    fn debug(_: impl std::fmt::Debug) {}
+}
+
+#[allow(dead_code)]
+mod used_exactly_once {
+    fn foo(x: String) {
+        use_x(x);
+    }
+    fn use_x(_: impl AsRef<str>) {}
+}
+
+#[allow(dead_code)]
+mod used_more_than_once {
+    fn foo(x: String) {
+        use_x(&x);
+        use_x_again(&x);
+    }
+    fn use_x(_: impl AsRef<str>) {}
+    fn use_x_again(_: impl AsRef<str>) {}
+}
diff --git a/tests/ui/needless_borrow.rs b/tests/ui/needless_borrow.rs
index d41251e8f6a..c93711ac8e2 100644
--- a/tests/ui/needless_borrow.rs
+++ b/tests/ui/needless_borrow.rs
@@ -3,7 +3,11 @@
 
 #[warn(clippy::all, clippy::needless_borrow)]
 #[allow(unused_variables)]
-#[allow(clippy::uninlined_format_args, clippy::unnecessary_mut_passed)]
+#[allow(
+    clippy::uninlined_format_args,
+    clippy::unnecessary_mut_passed,
+    clippy::unnecessary_to_owned
+)]
 fn main() {
     let a = 5;
     let ref_a = &a;
@@ -134,6 +138,7 @@ fn main() {
     multiple_constraints(&[[""]]);
     multiple_constraints_normalizes_to_same(&X, X);
     let _ = Some("").unwrap_or(&"");
+    let _ = std::fs::write("x", &"".to_string());
 
     only_sized(&""); // Don't lint. `Sized` is only bound
     let _ = std::any::Any::type_id(&""); // Don't lint. `Any` is only bound
@@ -276,6 +281,7 @@ mod copyable_iterator {
     fn dont_warn(mut x: Iter) {
         takes_iter(&mut x);
     }
+    #[allow(unused_mut)]
     fn warn(mut x: &mut Iter) {
         takes_iter(&mut x)
     }
@@ -327,3 +333,55 @@ fn issue9383() {
         ManuallyDrop::drop(&mut ocean.coral);
     }
 }
+
+#[allow(dead_code)]
+fn closure_test() {
+    let env = "env".to_owned();
+    let arg = "arg".to_owned();
+    let f = |arg| {
+        let loc = "loc".to_owned();
+        let _ = std::fs::write("x", &env); // Don't lint. In environment
+        let _ = std::fs::write("x", &arg);
+        let _ = std::fs::write("x", &loc);
+    };
+    let _ = std::fs::write("x", &env); // Don't lint. Borrowed by `f`
+    f(arg);
+}
+
+#[allow(dead_code)]
+mod significant_drop {
+    #[derive(Debug)]
+    struct X;
+
+    #[derive(Debug)]
+    struct Y;
+
+    impl Drop for Y {
+        fn drop(&mut self) {}
+    }
+
+    fn foo(x: X, y: Y) {
+        debug(&x);
+        debug(&y); // Don't lint. Has significant drop
+    }
+
+    fn debug(_: impl std::fmt::Debug) {}
+}
+
+#[allow(dead_code)]
+mod used_exactly_once {
+    fn foo(x: String) {
+        use_x(&x);
+    }
+    fn use_x(_: impl AsRef<str>) {}
+}
+
+#[allow(dead_code)]
+mod used_more_than_once {
+    fn foo(x: String) {
+        use_x(&x);
+        use_x_again(&x);
+    }
+    fn use_x(_: impl AsRef<str>) {}
+    fn use_x_again(_: impl AsRef<str>) {}
+}
diff --git a/tests/ui/needless_borrow.stderr b/tests/ui/needless_borrow.stderr
index 5af68706d4b..8b593268bec 100644
--- a/tests/ui/needless_borrow.stderr
+++ b/tests/ui/needless_borrow.stderr
@@ -1,5 +1,5 @@
 error: this expression creates a reference which is immediately dereferenced by the compiler
-  --> $DIR/needless_borrow.rs:11:15
+  --> $DIR/needless_borrow.rs:15:15
    |
 LL |     let _ = x(&&a); // warn
    |               ^^^ help: change this to: `&a`
@@ -7,172 +7,208 @@ LL |     let _ = x(&&a); // warn
    = note: `-D clippy::needless-borrow` implied by `-D warnings`
 
 error: this expression creates a reference which is immediately dereferenced by the compiler
-  --> $DIR/needless_borrow.rs:15:13
+  --> $DIR/needless_borrow.rs:19:13
    |
 LL |     mut_ref(&mut &mut b); // warn
    |             ^^^^^^^^^^^ help: change this to: `&mut b`
 
 error: this expression creates a reference which is immediately dereferenced by the compiler
-  --> $DIR/needless_borrow.rs:27:13
+  --> $DIR/needless_borrow.rs:31:13
    |
 LL |             &&a
    |             ^^^ help: change this to: `&a`
 
 error: this expression creates a reference which is immediately dereferenced by the compiler
-  --> $DIR/needless_borrow.rs:29:15
+  --> $DIR/needless_borrow.rs:33:15
    |
 LL |         46 => &&a,
    |               ^^^ help: change this to: `&a`
 
 error: this expression creates a reference which is immediately dereferenced by the compiler
-  --> $DIR/needless_borrow.rs:35:27
+  --> $DIR/needless_borrow.rs:39:27
    |
 LL |                     break &ref_a;
    |                           ^^^^^^ help: change this to: `ref_a`
 
 error: this expression creates a reference which is immediately dereferenced by the compiler
-  --> $DIR/needless_borrow.rs:42:15
+  --> $DIR/needless_borrow.rs:46:15
    |
 LL |     let _ = x(&&&a);
    |               ^^^^ help: change this to: `&a`
 
 error: this expression creates a reference which is immediately dereferenced by the compiler
-  --> $DIR/needless_borrow.rs:43:15
+  --> $DIR/needless_borrow.rs:47:15
    |
 LL |     let _ = x(&mut &&a);
    |               ^^^^^^^^ help: change this to: `&a`
 
 error: this expression creates a reference which is immediately dereferenced by the compiler
-  --> $DIR/needless_borrow.rs:44:15
+  --> $DIR/needless_borrow.rs:48:15
    |
 LL |     let _ = x(&&&mut b);
    |               ^^^^^^^^ help: change this to: `&mut b`
 
 error: this expression creates a reference which is immediately dereferenced by the compiler
-  --> $DIR/needless_borrow.rs:45:15
+  --> $DIR/needless_borrow.rs:49:15
    |
 LL |     let _ = x(&&ref_a);
    |               ^^^^^^^ help: change this to: `ref_a`
 
 error: this expression creates a reference which is immediately dereferenced by the compiler
-  --> $DIR/needless_borrow.rs:48:11
+  --> $DIR/needless_borrow.rs:52:11
    |
 LL |         x(&b);
    |           ^^ help: change this to: `b`
 
 error: this expression creates a reference which is immediately dereferenced by the compiler
-  --> $DIR/needless_borrow.rs:55:13
+  --> $DIR/needless_borrow.rs:59:13
    |
 LL |     mut_ref(&mut x);
    |             ^^^^^^ help: change this to: `x`
 
 error: this expression creates a reference which is immediately dereferenced by the compiler
-  --> $DIR/needless_borrow.rs:56:13
+  --> $DIR/needless_borrow.rs:60:13
    |
 LL |     mut_ref(&mut &mut x);
    |             ^^^^^^^^^^^ help: change this to: `x`
 
 error: this expression creates a reference which is immediately dereferenced by the compiler
-  --> $DIR/needless_borrow.rs:57:23
+  --> $DIR/needless_borrow.rs:61:23
    |
 LL |     let y: &mut i32 = &mut x;
    |                       ^^^^^^ help: change this to: `x`
 
 error: this expression creates a reference which is immediately dereferenced by the compiler
-  --> $DIR/needless_borrow.rs:58:23
+  --> $DIR/needless_borrow.rs:62:23
    |
 LL |     let y: &mut i32 = &mut &mut x;
    |                       ^^^^^^^^^^^ help: change this to: `x`
 
 error: this expression creates a reference which is immediately dereferenced by the compiler
-  --> $DIR/needless_borrow.rs:67:14
+  --> $DIR/needless_borrow.rs:71:14
    |
 LL |         0 => &mut x,
    |              ^^^^^^ help: change this to: `x`
 
 error: this expression creates a reference which is immediately dereferenced by the compiler
-  --> $DIR/needless_borrow.rs:73:14
+  --> $DIR/needless_borrow.rs:77:14
    |
 LL |         0 => &mut x,
    |              ^^^^^^ help: change this to: `x`
 
 error: this expression borrows a value the compiler would automatically borrow
-  --> $DIR/needless_borrow.rs:85:13
+  --> $DIR/needless_borrow.rs:89:13
    |
 LL |     let _ = (&x).0;
    |             ^^^^ help: change this to: `x`
 
 error: this expression borrows a value the compiler would automatically borrow
-  --> $DIR/needless_borrow.rs:87:22
+  --> $DIR/needless_borrow.rs:91:22
    |
 LL |     let _ = unsafe { (&*x).0 };
    |                      ^^^^^ help: change this to: `(*x)`
 
 error: this expression creates a reference which is immediately dereferenced by the compiler
-  --> $DIR/needless_borrow.rs:97:5
+  --> $DIR/needless_borrow.rs:101:5
    |
 LL |     (&&()).foo();
    |     ^^^^^^ help: change this to: `(&())`
 
 error: this expression creates a reference which is immediately dereferenced by the compiler
-  --> $DIR/needless_borrow.rs:106:5
+  --> $DIR/needless_borrow.rs:110:5
    |
 LL |     (&&5).foo();
    |     ^^^^^ help: change this to: `(&5)`
 
 error: the borrowed expression implements the required traits
-  --> $DIR/needless_borrow.rs:131:51
+  --> $DIR/needless_borrow.rs:135:51
    |
 LL |     let _ = std::process::Command::new("ls").args(&["-a", "-l"]).status().unwrap();
    |                                                   ^^^^^^^^^^^^^ help: change this to: `["-a", "-l"]`
 
 error: the borrowed expression implements the required traits
-  --> $DIR/needless_borrow.rs:132:44
+  --> $DIR/needless_borrow.rs:136:44
    |
 LL |     let _ = std::path::Path::new(".").join(&&".");
    |                                            ^^^^^ help: change this to: `"."`
 
 error: the borrowed expression implements the required traits
-  --> $DIR/needless_borrow.rs:133:23
+  --> $DIR/needless_borrow.rs:137:23
    |
 LL |     deref_target_is_x(&X);
    |                       ^^ help: change this to: `X`
 
 error: the borrowed expression implements the required traits
-  --> $DIR/needless_borrow.rs:134:26
+  --> $DIR/needless_borrow.rs:138:26
    |
 LL |     multiple_constraints(&[[""]]);
    |                          ^^^^^^^ help: change this to: `[[""]]`
 
 error: the borrowed expression implements the required traits
-  --> $DIR/needless_borrow.rs:135:45
+  --> $DIR/needless_borrow.rs:139:45
    |
 LL |     multiple_constraints_normalizes_to_same(&X, X);
    |                                             ^^ help: change this to: `X`
 
 error: this expression creates a reference which is immediately dereferenced by the compiler
-  --> $DIR/needless_borrow.rs:136:32
+  --> $DIR/needless_borrow.rs:140:32
    |
 LL |     let _ = Some("").unwrap_or(&"");
    |                                ^^^ help: change this to: `""`
 
+error: the borrowed expression implements the required traits
+  --> $DIR/needless_borrow.rs:141:33
+   |
+LL |     let _ = std::fs::write("x", &"".to_string());
+   |                                 ^^^^^^^^^^^^^^^ help: change this to: `"".to_string()`
+
 error: this expression borrows a value the compiler would automatically borrow
-  --> $DIR/needless_borrow.rs:187:13
+  --> $DIR/needless_borrow.rs:192:13
    |
 LL |             (&self.f)()
    |             ^^^^^^^^^ help: change this to: `(self.f)`
 
 error: this expression borrows a value the compiler would automatically borrow
-  --> $DIR/needless_borrow.rs:196:13
+  --> $DIR/needless_borrow.rs:201:13
    |
 LL |             (&mut self.f)()
    |             ^^^^^^^^^^^^^ help: change this to: `(self.f)`
 
 error: the borrowed expression implements the required traits
-  --> $DIR/needless_borrow.rs:298:55
+  --> $DIR/needless_borrow.rs:286:20
+   |
+LL |         takes_iter(&mut x)
+   |                    ^^^^^^ help: change this to: `x`
+
+error: the borrowed expression implements the required traits
+  --> $DIR/needless_borrow.rs:304:55
    |
 LL |         let _ = std::process::Command::new("ls").args(&["-a", "-l"]).status().unwrap();
    |                                                       ^^^^^^^^^^^^^ help: change this to: `["-a", "-l"]`
 
-error: aborting due to 29 previous errors
+error: the borrowed expression implements the required traits
+  --> $DIR/needless_borrow.rs:344:37
+   |
+LL |         let _ = std::fs::write("x", &arg);
+   |                                     ^^^^ help: change this to: `arg`
+
+error: the borrowed expression implements the required traits
+  --> $DIR/needless_borrow.rs:345:37
+   |
+LL |         let _ = std::fs::write("x", &loc);
+   |                                     ^^^^ help: change this to: `loc`
+
+error: the borrowed expression implements the required traits
+  --> $DIR/needless_borrow.rs:364:15
+   |
+LL |         debug(&x);
+   |               ^^ help: change this to: `x`
+
+error: the borrowed expression implements the required traits
+  --> $DIR/needless_borrow.rs:374:15
+   |
+LL |         use_x(&x);
+   |               ^^ help: change this to: `x`
+
+error: aborting due to 35 previous errors
 
diff --git a/tests/ui/unnecessary_to_owned.fixed b/tests/ui/unnecessary_to_owned.fixed
index f97583aa22f..fe09aad06bc 100644
--- a/tests/ui/unnecessary_to_owned.fixed
+++ b/tests/ui/unnecessary_to_owned.fixed
@@ -1,6 +1,6 @@
 // run-rustfix
 
-#![allow(clippy::ptr_arg)]
+#![allow(clippy::needless_borrow, clippy::ptr_arg)]
 #![warn(clippy::unnecessary_to_owned)]
 #![feature(custom_inner_attributes)]
 
diff --git a/tests/ui/unnecessary_to_owned.rs b/tests/ui/unnecessary_to_owned.rs
index aa5394a5657..3de6d0903c0 100644
--- a/tests/ui/unnecessary_to_owned.rs
+++ b/tests/ui/unnecessary_to_owned.rs
@@ -1,6 +1,6 @@
 // run-rustfix
 
-#![allow(clippy::ptr_arg)]
+#![allow(clippy::needless_borrow, clippy::ptr_arg)]
 #![warn(clippy::unnecessary_to_owned)]
 #![feature(custom_inner_attributes)]
 
-- 
cgit 1.4.1-3-g733a5


From 9cc8da222b3893bc13bc13c8827e93f8ea246854 Mon Sep 17 00:00:00 2001
From: Samuel Moelius <sam@moeli.us>
Date: Fri, 7 Oct 2022 05:07:09 -0400
Subject: Fix adjacent code

---
 clippy_dev/src/serve.rs                      |  2 +-
 clippy_dev/src/update_lints.rs               |  2 +-
 clippy_lints/src/lib.rs                      |  8 ++++----
 clippy_lints/src/nonstandard_macro_braces.rs |  2 +-
 clippy_utils/src/attrs.rs                    |  2 +-
 clippy_utils/src/lib.rs                      |  2 +-
 lintcheck/src/main.rs                        | 30 ++++++++++++----------------
 tests/compile-test.rs                        |  2 +-
 tests/versioncheck.rs                        |  2 +-
 9 files changed, 24 insertions(+), 28 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_dev/src/serve.rs b/clippy_dev/src/serve.rs
index 2e0794f12fa..535c25e69f1 100644
--- a/clippy_dev/src/serve.rs
+++ b/clippy_dev/src/serve.rs
@@ -49,7 +49,7 @@ fn mtime(path: impl AsRef<Path>) -> SystemTime {
             .into_iter()
             .flatten()
             .flatten()
-            .map(|entry| mtime(&entry.path()))
+            .map(|entry| mtime(entry.path()))
             .max()
             .unwrap_or(SystemTime::UNIX_EPOCH)
     } else {
diff --git a/clippy_dev/src/update_lints.rs b/clippy_dev/src/update_lints.rs
index 0eb443167ec..8d1bfacd1dc 100644
--- a/clippy_dev/src/update_lints.rs
+++ b/clippy_dev/src/update_lints.rs
@@ -128,7 +128,7 @@ fn generate_lint_files(
     for (lint_group, lints) in Lint::by_lint_group(usable_lints.into_iter().chain(internal_lints)) {
         let content = gen_lint_group_list(&lint_group, lints.iter());
         process_file(
-            &format!("clippy_lints/src/lib.register_{lint_group}.rs"),
+            format!("clippy_lints/src/lib.register_{lint_group}.rs"),
             update_mode,
             &content,
         );
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index d9dfb4fc4e0..ebb0f14fef5 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -417,7 +417,7 @@ pub fn register_pre_expansion_lints(store: &mut rustc_lint::LintStore, sess: &Se
 
     let msrv = conf.msrv.as_ref().and_then(|s| {
         parse_msrv(s, None, None).or_else(|| {
-            sess.err(&format!(
+            sess.err(format!(
                 "error reading Clippy's configuration file. `{s}` is not a valid Rust version"
             ));
             None
@@ -433,7 +433,7 @@ fn read_msrv(conf: &Conf, sess: &Session) -> Option<RustcVersion> {
         .and_then(|v| parse_msrv(&v, None, None));
     let clippy_msrv = conf.msrv.as_ref().and_then(|s| {
         parse_msrv(s, None, None).or_else(|| {
-            sess.err(&format!(
+            sess.err(format!(
                 "error reading Clippy's configuration file. `{s}` is not a valid Rust version"
             ));
             None
@@ -444,7 +444,7 @@ fn read_msrv(conf: &Conf, sess: &Session) -> Option<RustcVersion> {
         if let Some(clippy_msrv) = clippy_msrv {
             // if both files have an msrv, let's compare them and emit a warning if they differ
             if clippy_msrv != cargo_msrv {
-                sess.warn(&format!(
+                sess.warn(format!(
                     "the MSRV in `clippy.toml` and `Cargo.toml` differ; using `{clippy_msrv}` from `clippy.toml`"
                 ));
             }
@@ -473,7 +473,7 @@ pub fn read_conf(sess: &Session) -> Conf {
     let TryConf { conf, errors, warnings } = utils::conf::read(&file_name);
     // all conf errors are non-fatal, we just use the default conf in case of error
     for error in errors {
-        sess.err(&format!(
+        sess.err(format!(
             "error reading Clippy's configuration file `{}`: {}",
             file_name.display(),
             format_error(error)
diff --git a/clippy_lints/src/nonstandard_macro_braces.rs b/clippy_lints/src/nonstandard_macro_braces.rs
index 0ca0befc135..6c909e5ed73 100644
--- a/clippy_lints/src/nonstandard_macro_braces.rs
+++ b/clippy_lints/src/nonstandard_macro_braces.rs
@@ -266,7 +266,7 @@ impl<'de> Deserialize<'de> for MacroMatcher {
                         .iter()
                         .find(|b| b.0 == brace)
                         .map(|(o, c)| ((*o).to_owned(), (*c).to_owned()))
-                        .ok_or_else(|| de::Error::custom(&format!("expected one of `(`, `{{`, `[` found `{brace}`")))?,
+                        .ok_or_else(|| de::Error::custom(format!("expected one of `(`, `{{`, `[` found `{brace}`")))?,
                 })
             }
         }
diff --git a/clippy_utils/src/attrs.rs b/clippy_utils/src/attrs.rs
index d9b22664fd2..cd8575c90e8 100644
--- a/clippy_utils/src/attrs.rs
+++ b/clippy_utils/src/attrs.rs
@@ -136,7 +136,7 @@ pub fn get_unique_inner_attr(sess: &Session, attrs: &[ast::Attribute], name: &'s
                     .emit();
             },
             ast::AttrStyle::Outer => {
-                sess.span_err(attr.span, &format!("`{name}` cannot be an outer attribute"));
+                sess.span_err(attr.span, format!("`{name}` cannot be an outer attribute"));
             },
         }
     }
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 3597c58e072..5c8ffffc8c8 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -125,7 +125,7 @@ pub fn parse_msrv(msrv: &str, sess: Option<&Session>, span: Option<Span>) -> Opt
         return Some(version);
     } else if let Some(sess) = sess {
         if let Some(span) = span {
-            sess.span_err(span, &format!("`{msrv}` is not a valid Rust version"));
+            sess.span_err(span, format!("`{msrv}` is not a valid Rust version"));
         }
     }
     None
diff --git a/lintcheck/src/main.rs b/lintcheck/src/main.rs
index cc2b3e1acec..95b20d7f024 100644
--- a/lintcheck/src/main.rs
+++ b/lintcheck/src/main.rs
@@ -345,7 +345,7 @@ impl Crate {
                 clippy_args.push(opt);
             }
         } else {
-            clippy_args.extend(&["-Wclippy::pedantic", "-Wclippy::cargo"])
+            clippy_args.extend(["-Wclippy::pedantic", "-Wclippy::cargo"])
         }
 
         if lint_filter.is_empty() {
@@ -457,15 +457,11 @@ fn build_clippy() {
 /// Read a `lintcheck_crates.toml` file
 fn read_crates(toml_path: &Path) -> (Vec<CrateSource>, RecursiveOptions) {
     let toml_content: String =
-        std::fs::read_to_string(&toml_path).unwrap_or_else(|_| panic!("Failed to read {}", toml_path.display()));
+        std::fs::read_to_string(toml_path).unwrap_or_else(|_| panic!("Failed to read {}", toml_path.display()));
     let crate_list: SourceList =
         toml::from_str(&toml_content).unwrap_or_else(|e| panic!("Failed to parse {}: \n{}", toml_path.display(), e));
     // parse the hashmap of the toml file into a list of crates
-    let tomlcrates: Vec<TomlCrate> = crate_list
-        .crates
-        .into_iter()
-        .map(|(_cratename, tomlcrate)| tomlcrate)
-        .collect();
+    let tomlcrates: Vec<TomlCrate> = crate_list.crates.into_values().collect();
 
     // flatten TomlCrates into CrateSources (one TomlCrates may represent several versions of a crate =>
     // multiple Cratesources)
@@ -602,10 +598,10 @@ fn main() {
     ) {
         let shared_target_dir = "target/lintcheck/shared_target_dir";
         // if we get an Err here, the shared target dir probably does simply not exist
-        if let Ok(metadata) = std::fs::metadata(&shared_target_dir) {
+        if let Ok(metadata) = std::fs::metadata(shared_target_dir) {
             if metadata.is_dir() {
                 println!("Clippy is newer than lint check logs, clearing lintcheck shared target dir...");
-                std::fs::remove_dir_all(&shared_target_dir)
+                std::fs::remove_dir_all(shared_target_dir)
                     .expect("failed to remove target/lintcheck/shared_target_dir");
             }
         }
@@ -779,7 +775,7 @@ fn read_stats_from_file(file_path: &Path) -> HashMap<String, usize> {
 fn print_stats(old_stats: HashMap<String, usize>, new_stats: HashMap<&String, usize>, lint_filter: &Vec<String>) {
     let same_in_both_hashmaps = old_stats
         .iter()
-        .filter(|(old_key, old_val)| new_stats.get::<&String>(&old_key) == Some(old_val))
+        .filter(|(old_key, old_val)| new_stats.get::<&String>(old_key) == Some(old_val))
         .map(|(k, v)| (k.to_string(), *v))
         .collect::<Vec<(String, usize)>>();
 
@@ -797,7 +793,7 @@ fn print_stats(old_stats: HashMap<String, usize>, new_stats: HashMap<&String, us
     // list all new counts  (key is in new stats but not in old stats)
     new_stats_deduped
         .iter()
-        .filter(|(new_key, _)| old_stats_deduped.get::<str>(&new_key).is_none())
+        .filter(|(new_key, _)| old_stats_deduped.get::<str>(new_key).is_none())
         .for_each(|(new_key, new_value)| {
             println!("{} 0 => {}", new_key, new_value);
         });
@@ -805,16 +801,16 @@ fn print_stats(old_stats: HashMap<String, usize>, new_stats: HashMap<&String, us
     // list all changed counts (key is in both maps but value differs)
     new_stats_deduped
         .iter()
-        .filter(|(new_key, _new_val)| old_stats_deduped.get::<str>(&new_key).is_some())
+        .filter(|(new_key, _new_val)| old_stats_deduped.get::<str>(new_key).is_some())
         .for_each(|(new_key, new_val)| {
-            let old_val = old_stats_deduped.get::<str>(&new_key).unwrap();
+            let old_val = old_stats_deduped.get::<str>(new_key).unwrap();
             println!("{} {} => {}", new_key, old_val, new_val);
         });
 
     // list all gone counts (key is in old status but not in new stats)
     old_stats_deduped
         .iter()
-        .filter(|(old_key, _)| new_stats_deduped.get::<&String>(&old_key).is_none())
+        .filter(|(old_key, _)| new_stats_deduped.get::<&String>(old_key).is_none())
         .filter(|(old_key, _)| lint_filter.is_empty() || lint_filter.contains(old_key))
         .for_each(|(old_key, old_value)| {
             println!("{} {} => 0", old_key, old_value);
@@ -832,12 +828,12 @@ fn create_dirs(krate_download_dir: &Path, extract_dir: &Path) {
             panic!("cannot create lintcheck target dir");
         }
     });
-    std::fs::create_dir(&krate_download_dir).unwrap_or_else(|err| {
+    std::fs::create_dir(krate_download_dir).unwrap_or_else(|err| {
         if err.kind() != ErrorKind::AlreadyExists {
             panic!("cannot create crate download dir");
         }
     });
-    std::fs::create_dir(&extract_dir).unwrap_or_else(|err| {
+    std::fs::create_dir(extract_dir).unwrap_or_else(|err| {
         if err.kind() != ErrorKind::AlreadyExists {
             panic!("cannot create crate extraction dir");
         }
@@ -863,7 +859,7 @@ fn lintcheck_test() {
         "lintcheck/test_sources.toml",
     ];
     let status = std::process::Command::new("cargo")
-        .args(&args)
+        .args(args)
         .current_dir("..") // repo root
         .status();
     //.output();
diff --git a/tests/compile-test.rs b/tests/compile-test.rs
index fa769222d1a..c10ee969c01 100644
--- a/tests/compile-test.rs
+++ b/tests/compile-test.rs
@@ -283,7 +283,7 @@ fn run_ui_cargo() {
                 env::set_current_dir(&src_path)?;
 
                 let cargo_toml_path = case.path().join("Cargo.toml");
-                let cargo_content = fs::read(&cargo_toml_path)?;
+                let cargo_content = fs::read(cargo_toml_path)?;
                 let cargo_parsed: toml::Value = toml::from_str(
                     std::str::from_utf8(&cargo_content).expect("`Cargo.toml` is not a valid utf-8 file!"),
                 )
diff --git a/tests/versioncheck.rs b/tests/versioncheck.rs
index 9e07769a8e4..a6d8d0307ce 100644
--- a/tests/versioncheck.rs
+++ b/tests/versioncheck.rs
@@ -48,7 +48,7 @@ fn check_that_clippy_has_the_same_major_version_as_rustc() {
     // `RUSTC_REAL` if Clippy is build in the Rust repo with `./x.py`.
     let rustc = std::env::var("RUSTC_REAL").unwrap_or_else(|_| "rustc".to_string());
     let rustc_version = String::from_utf8(
-        std::process::Command::new(&rustc)
+        std::process::Command::new(rustc)
             .arg("--version")
             .output()
             .expect("failed to run `rustc --version`")
-- 
cgit 1.4.1-3-g733a5


From 6f4546a4be7b65da15b3170d72d3339ed1d2aeec Mon Sep 17 00:00:00 2001
From: kraktus <kraktus@users.noreply.github.com>
Date: Sat, 8 Oct 2022 16:15:18 +0200
Subject: [`unnecessary_cast`] Do not lint negative hexadecimal literals when
 cast as float

Floats cannot be expressed as hexadecimal literals
---
 clippy_lints/src/casts/unnecessary_cast.rs | 3 ---
 clippy_utils/src/numeric_literal.rs        | 7 ++++---
 tests/ui/unnecessary_cast.fixed            | 4 ++++
 tests/ui/unnecessary_cast.rs               | 4 ++++
 4 files changed, 12 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/unnecessary_cast.rs b/clippy_lints/src/casts/unnecessary_cast.rs
index 21ed7f4844c..c8596987e4d 100644
--- a/clippy_lints/src/casts/unnecessary_cast.rs
+++ b/clippy_lints/src/casts/unnecessary_cast.rs
@@ -59,9 +59,6 @@ pub(super) fn check<'tcx>(
                 lint_unnecessary_cast(cx, expr, literal_str, cast_from, cast_to);
                 return false;
             },
-            LitKind::Int(_, LitIntType::Unsuffixed) | LitKind::Float(_, LitFloatType::Unsuffixed) => {
-                return false;
-            },
             LitKind::Int(_, LitIntType::Signed(_) | LitIntType::Unsigned(_))
             | LitKind::Float(_, LitFloatType::Suffixed(_))
                 if cast_from.kind() == cast_to.kind() =>
diff --git a/clippy_utils/src/numeric_literal.rs b/clippy_utils/src/numeric_literal.rs
index 80098d9766c..c5dcd7b31f5 100644
--- a/clippy_utils/src/numeric_literal.rs
+++ b/clippy_utils/src/numeric_literal.rs
@@ -69,12 +69,13 @@ impl<'a> NumericLiteral<'a> {
 
     #[must_use]
     pub fn new(lit: &'a str, suffix: Option<&'a str>, float: bool) -> Self {
+        let unsigned_lit = lit.trim_start_matches('-');
         // Determine delimiter for radix prefix, if present, and radix.
-        let radix = if lit.starts_with("0x") {
+        let radix = if unsigned_lit.starts_with("0x") {
             Radix::Hexadecimal
-        } else if lit.starts_with("0b") {
+        } else if unsigned_lit.starts_with("0b") {
             Radix::Binary
-        } else if lit.starts_with("0o") {
+        } else if unsigned_lit.starts_with("0o") {
             Radix::Octal
         } else {
             Radix::Decimal
diff --git a/tests/ui/unnecessary_cast.fixed b/tests/ui/unnecessary_cast.fixed
index 94dc9642726..ec8c6abfab9 100644
--- a/tests/ui/unnecessary_cast.fixed
+++ b/tests/ui/unnecessary_cast.fixed
@@ -111,4 +111,8 @@ mod fixable {
 
         let _num = foo();
     }
+
+    fn issue_9603() {
+        let _: f32 = -0x400 as f32;
+    }
 }
diff --git a/tests/ui/unnecessary_cast.rs b/tests/ui/unnecessary_cast.rs
index e5150256f69..5213cdc269b 100644
--- a/tests/ui/unnecessary_cast.rs
+++ b/tests/ui/unnecessary_cast.rs
@@ -111,4 +111,8 @@ mod fixable {
 
         let _num = foo() as f32;
     }
+
+    fn issue_9603() {
+        let _: f32 = -0x400 as f32;
+    }
 }
-- 
cgit 1.4.1-3-g733a5


From bd61fdbd5f4f436c3bf5886f757ce6a2d45b40df Mon Sep 17 00:00:00 2001
From: Andre Bogus <bogusandre@gmail.com>
Date: Mon, 10 Oct 2022 13:05:07 +0200
Subject: fix `box-default` ignoring trait objects' types

---
 clippy_lints/src/box_default.rs |  2 +-
 tests/ui/box_default.fixed      | 16 +++++++++++++++-
 tests/ui/box_default.rs         | 16 +++++++++++++++-
 tests/ui/box_default.stderr     |  8 +++++++-
 4 files changed, 38 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/box_default.rs b/clippy_lints/src/box_default.rs
index f35a79dcc73..4c0ccd08ef2 100644
--- a/clippy_lints/src/box_default.rs
+++ b/clippy_lints/src/box_default.rs
@@ -88,7 +88,7 @@ struct InferVisitor(bool);
 
 impl<'tcx> Visitor<'tcx> for InferVisitor {
     fn visit_ty(&mut self, t: &rustc_hir::Ty<'_>) {
-        self.0 |= matches!(t.kind, TyKind::Infer);
+        self.0 |= matches!(t.kind, TyKind::Infer | TyKind::OpaqueDef(..) | TyKind::TraitObject(..));
         if !self.0 {
             walk_ty(self, t);
         }
diff --git a/tests/ui/box_default.fixed b/tests/ui/box_default.fixed
index 7fbb272ce5a..911fa856aa0 100644
--- a/tests/ui/box_default.fixed
+++ b/tests/ui/box_default.fixed
@@ -40,4 +40,18 @@ fn ret_ty_fn() -> Box<bool> {
 }
 
 #[allow(clippy::boxed_local)]
-fn call_ty_fn(_b: Box<u8>) {}
+fn call_ty_fn(_b: Box<u8>) {
+    issue_9621_dyn_trait();
+}
+
+use std::io::{Read, Result};
+
+impl Read for ImplementsDefault {
+    fn read(&mut self, _: &mut [u8]) -> Result<usize> {
+        Ok(0)
+    }
+}
+
+fn issue_9621_dyn_trait() {
+    let _: Box<dyn Read> = Box::<ImplementsDefault>::default();
+}
diff --git a/tests/ui/box_default.rs b/tests/ui/box_default.rs
index 64c4f3887af..20019c2ee5a 100644
--- a/tests/ui/box_default.rs
+++ b/tests/ui/box_default.rs
@@ -40,4 +40,18 @@ fn ret_ty_fn() -> Box<bool> {
 }
 
 #[allow(clippy::boxed_local)]
-fn call_ty_fn(_b: Box<u8>) {}
+fn call_ty_fn(_b: Box<u8>) {
+    issue_9621_dyn_trait();
+}
+
+use std::io::{Read, Result};
+
+impl Read for ImplementsDefault {
+    fn read(&mut self, _: &mut [u8]) -> Result<usize> {
+        Ok(0)
+    }
+}
+
+fn issue_9621_dyn_trait() {
+    let _: Box<dyn Read> = Box::new(ImplementsDefault::default());
+}
diff --git a/tests/ui/box_default.stderr b/tests/ui/box_default.stderr
index 313255fc950..5ea410331af 100644
--- a/tests/ui/box_default.stderr
+++ b/tests/ui/box_default.stderr
@@ -78,5 +78,11 @@ error: `Box::new(_)` of default value
 LL |     Box::new(bool::default())
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Box::<bool>::default()`
 
-error: aborting due to 13 previous errors
+error: `Box::new(_)` of default value
+  --> $DIR/box_default.rs:56:28
+   |
+LL |     let _: Box<dyn Read> = Box::new(ImplementsDefault::default());
+   |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Box::<ImplementsDefault>::default()`
+
+error: aborting due to 14 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From f48d13f8d1b442c38755cfe87c28f56e1dca10cc Mon Sep 17 00:00:00 2001
From: est31 <MTest31@outlook.com>
Date: Mon, 10 Oct 2022 22:37:42 +0200
Subject: Replace manual let else patterns with let else

---
 clippy_dev/src/setup/intellij.rs                     | 17 +++++------------
 clippy_dev/src/update_lints.rs                       |  8 +++-----
 clippy_lints/src/derive.rs                           |  5 +----
 clippy_lints/src/disallowed_methods.rs               |  5 ++---
 clippy_lints/src/entry.rs                            | 20 ++++++++------------
 clippy_lints/src/eta_reduction.rs                    |  5 ++---
 clippy_lints/src/functions/too_many_lines.rs         |  5 ++---
 clippy_lints/src/invalid_upcast_comparisons.rs       |  4 +---
 clippy_lints/src/large_enum_variant.rs               |  5 ++---
 clippy_lints/src/loops/while_let_on_iterator.rs      |  5 ++---
 clippy_lints/src/matches/manual_utils.rs             |  5 ++---
 clippy_lints/src/matches/match_same_arms.rs          |  6 ++----
 clippy_lints/src/methods/into_iter_on_ref.rs         |  5 ++---
 .../src/methods/manual_saturating_arithmetic.rs      | 10 ++--------
 clippy_lints/src/methods/mod.rs                      |  5 ++---
 clippy_lints/src/methods/str_splitn.rs               |  4 +---
 clippy_lints/src/misc_early/literal_suffix.rs        |  4 +---
 .../src/misc_early/mixed_case_hex_literals.rs        |  4 +---
 clippy_lints/src/mismatching_type_param_order.rs     |  5 ++---
 clippy_lints/src/mixed_read_write_in_expression.rs   |  5 +----
 clippy_lints/src/needless_for_each.rs                |  5 ++---
 clippy_lints/src/non_copy_const.rs                   |  5 ++---
 clippy_lints/src/non_octal_unix_permissions.rs       | 17 +++++------------
 clippy_lints/src/ptr.rs                              |  9 +++------
 clippy_lints/src/ptr_offset_with_cast.rs             | 10 ++++------
 clippy_lints/src/shadow.rs                           |  5 +----
 clippy_lints/src/types/rc_buffer.rs                  | 10 ++--------
 clippy_lints/src/types/redundant_allocation.rs       |  5 ++---
 clippy_lints/src/unnested_or_patterns.rs             |  5 ++---
 clippy_lints/src/unused_io_amount.rs                 |  5 ++---
 clippy_lints/src/useless_conversion.rs               |  5 ++---
 clippy_lints/src/utils/internal_lints.rs             | 10 ++--------
 32 files changed, 73 insertions(+), 150 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_dev/src/setup/intellij.rs b/clippy_dev/src/setup/intellij.rs
index b64e79733eb..efdb158c21e 100644
--- a/clippy_dev/src/setup/intellij.rs
+++ b/clippy_dev/src/setup/intellij.rs
@@ -36,9 +36,8 @@ impl ClippyProjectInfo {
 }
 
 pub fn setup_rustc_src(rustc_path: &str) {
-    let rustc_source_dir = match check_and_get_rustc_dir(rustc_path) {
-        Ok(path) => path,
-        Err(_) => return,
+    let Ok(rustc_source_dir) = check_and_get_rustc_dir(rustc_path) else {
+        return
     };
 
     for project in CLIPPY_PROJECTS {
@@ -172,14 +171,10 @@ pub fn remove_rustc_src() {
 }
 
 fn remove_rustc_src_from_project(project: &ClippyProjectInfo) -> bool {
-    let mut cargo_content = if let Ok(content) = read_project_file(project.cargo_file) {
-        content
-    } else {
+    let Ok(mut cargo_content) = read_project_file(project.cargo_file) else {
         return false;
     };
-    let section_start = if let Some(section_start) = cargo_content.find(RUSTC_PATH_SECTION) {
-        section_start
-    } else {
+    let Some(section_start) = cargo_content.find(RUSTC_PATH_SECTION) else {
         println!(
             "info: dependencies could not be found in `{}` for {}, skipping file",
             project.cargo_file, project.name
@@ -187,9 +182,7 @@ fn remove_rustc_src_from_project(project: &ClippyProjectInfo) -> bool {
         return true;
     };
 
-    let end_point = if let Some(end_point) = cargo_content.find(DEPENDENCIES_SECTION) {
-        end_point
-    } else {
+    let Some(end_point) = cargo_content.find(DEPENDENCIES_SECTION) else {
         eprintln!(
             "error: the end of the rustc dependencies section could not be found in `{}`",
             project.cargo_file
diff --git a/clippy_dev/src/update_lints.rs b/clippy_dev/src/update_lints.rs
index 8d1bfacd1dc..e690bc369cd 100644
--- a/clippy_dev/src/update_lints.rs
+++ b/clippy_dev/src/update_lints.rs
@@ -869,13 +869,11 @@ fn clippy_lints_src_files() -> impl Iterator<Item = (PathBuf, DirEntry)> {
 macro_rules! match_tokens {
     ($iter:ident, $($token:ident $({$($fields:tt)*})? $(($capture:ident))?)*) => {
          {
-            $($(let $capture =)? if let Some(LintDeclSearchResult {
+            $(#[allow(clippy::redundant_pattern)] let Some(LintDeclSearchResult {
                     token_kind: TokenKind::$token $({$($fields)*})?,
-                    content: _x,
+                    content: $($capture @)? _,
                     ..
-            }) = $iter.next() {
-                _x
-            } else {
+            }) = $iter.next() else {
                 continue;
             };)*
             #[allow(clippy::unused_unit)]
diff --git a/clippy_lints/src/derive.rs b/clippy_lints/src/derive.rs
index 3fac93dcc90..fad984d05ca 100644
--- a/clippy_lints/src/derive.rs
+++ b/clippy_lints/src/derive.rs
@@ -339,10 +339,7 @@ fn check_copy_clone<'tcx>(cx: &LateContext<'tcx>, item: &Item<'_>, trait_ref: &h
         Some(id) if trait_ref.trait_def_id() == Some(id) => id,
         _ => return,
     };
-    let copy_id = match cx.tcx.lang_items().copy_trait() {
-        Some(id) => id,
-        None => return,
-    };
+    let Some(copy_id) = cx.tcx.lang_items().copy_trait() else { return };
     let (ty_adt, ty_subs) = match *ty.kind() {
         // Unions can't derive clone.
         ty::Adt(adt, subs) if !adt.is_union() => (adt, subs),
diff --git a/clippy_lints/src/disallowed_methods.rs b/clippy_lints/src/disallowed_methods.rs
index 1a381f92c03..6ac85606d9c 100644
--- a/clippy_lints/src/disallowed_methods.rs
+++ b/clippy_lints/src/disallowed_methods.rs
@@ -94,9 +94,8 @@ impl<'tcx> LateLintPass<'tcx> for DisallowedMethods {
         } else {
             path_def_id(cx, expr)
         };
-        let def_id = match uncalled_path.or_else(|| fn_def_id(cx, expr)) {
-            Some(def_id) => def_id,
-            None => return,
+        let Some(def_id) = uncalled_path.or_else(|| fn_def_id(cx, expr)) else {
+            return
         };
         let conf = match self.disallowed.get(&def_id) {
             Some(&index) => &self.conf_disallowed[index],
diff --git a/clippy_lints/src/entry.rs b/clippy_lints/src/entry.rs
index 9c834cf0144..b44e6243588 100644
--- a/clippy_lints/src/entry.rs
+++ b/clippy_lints/src/entry.rs
@@ -65,28 +65,24 @@ declare_lint_pass!(HashMapPass => [MAP_ENTRY]);
 impl<'tcx> LateLintPass<'tcx> for HashMapPass {
     #[expect(clippy::too_many_lines)]
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        let (cond_expr, then_expr, else_expr) = match higher::If::hir(expr) {
-            Some(higher::If { cond, then, r#else }) => (cond, then, r#else),
-            _ => return,
+        let Some(higher::If { cond: cond_expr, then: then_expr, r#else: else_expr }) = higher::If::hir(expr) else {
+            return
         };
 
-        let (map_ty, contains_expr) = match try_parse_contains(cx, cond_expr) {
-            Some(x) => x,
-            None => return,
+        let Some((map_ty, contains_expr)) = try_parse_contains(cx, cond_expr) else {
+            return
         };
 
-        let then_search = match find_insert_calls(cx, &contains_expr, then_expr) {
-            Some(x) => x,
-            None => return,
+        let Some(then_search) = find_insert_calls(cx, &contains_expr, then_expr) else {
+            return
         };
 
         let mut app = Applicability::MachineApplicable;
         let map_str = snippet_with_context(cx, contains_expr.map.span, contains_expr.call_ctxt, "..", &mut app).0;
         let key_str = snippet_with_context(cx, contains_expr.key.span, contains_expr.call_ctxt, "..", &mut app).0;
         let sugg = if let Some(else_expr) = else_expr {
-            let else_search = match find_insert_calls(cx, &contains_expr, else_expr) {
-                Some(search) => search,
-                None => return,
+            let Some(else_search) = find_insert_calls(cx, &contains_expr, else_expr) else {
+                return;
             };
 
             if then_search.edits.is_empty() && else_search.edits.is_empty() {
diff --git a/clippy_lints/src/eta_reduction.rs b/clippy_lints/src/eta_reduction.rs
index 3732410e71e..7b9786d7e57 100644
--- a/clippy_lints/src/eta_reduction.rs
+++ b/clippy_lints/src/eta_reduction.rs
@@ -213,9 +213,8 @@ fn check_sig<'tcx>(cx: &LateContext<'tcx>, closure_ty: Ty<'tcx>, call_ty: Ty<'tc
     if !closure_ty.has_late_bound_regions() {
         return true;
     }
-    let substs = match closure_ty.kind() {
-        ty::Closure(_, substs) => substs,
-        _ => return false,
+    let ty::Closure(_, substs) = closure_ty.kind() else {
+        return false;
     };
     let closure_sig = cx.tcx.signature_unclosure(substs.as_closure().sig(), Unsafety::Normal);
     cx.tcx.erase_late_bound_regions(closure_sig) == cx.tcx.erase_late_bound_regions(call_sig)
diff --git a/clippy_lints/src/functions/too_many_lines.rs b/clippy_lints/src/functions/too_many_lines.rs
index f83f8b40f94..bd473ac7e51 100644
--- a/clippy_lints/src/functions/too_many_lines.rs
+++ b/clippy_lints/src/functions/too_many_lines.rs
@@ -22,9 +22,8 @@ pub(super) fn check_fn(
         return;
     }
 
-    let code_snippet = match snippet_opt(cx, body.value.span) {
-        Some(s) => s,
-        _ => return,
+    let Some(code_snippet) = snippet_opt(cx, body.value.span) else {
+        return
     };
     let mut line_count: u64 = 0;
     let mut in_comment = false;
diff --git a/clippy_lints/src/invalid_upcast_comparisons.rs b/clippy_lints/src/invalid_upcast_comparisons.rs
index 36e03e50a8e..0ef77e03de9 100644
--- a/clippy_lints/src/invalid_upcast_comparisons.rs
+++ b/clippy_lints/src/invalid_upcast_comparisons.rs
@@ -145,9 +145,7 @@ impl<'tcx> LateLintPass<'tcx> for InvalidUpcastComparisons {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if let ExprKind::Binary(ref cmp, lhs, rhs) = expr.kind {
             let normalized = comparisons::normalize_comparison(cmp.node, lhs, rhs);
-            let (rel, normalized_lhs, normalized_rhs) = if let Some(val) = normalized {
-                val
-            } else {
+            let Some((rel, normalized_lhs, normalized_rhs)) = normalized else {
                 return;
             };
 
diff --git a/clippy_lints/src/large_enum_variant.rs b/clippy_lints/src/large_enum_variant.rs
index eb13d0869c0..8ed7e4bb196 100644
--- a/clippy_lints/src/large_enum_variant.rs
+++ b/clippy_lints/src/large_enum_variant.rs
@@ -124,9 +124,8 @@ impl<'tcx> LateLintPass<'tcx> for LargeEnumVariant {
         }
         if let ItemKind::Enum(ref def, _) = item.kind {
             let ty = cx.tcx.type_of(item.def_id);
-            let (adt, subst) = match ty.kind() {
-                Adt(adt, subst) => (adt, subst),
-                _ => panic!("already checked whether this is an enum"),
+            let Adt(adt, subst) = ty.kind() else {
+                panic!("already checked whether this is an enum")
             };
             if adt.variants().len() <= 1 {
                 return;
diff --git a/clippy_lints/src/loops/while_let_on_iterator.rs b/clippy_lints/src/loops/while_let_on_iterator.rs
index 153f97e4e66..55989f8a446 100644
--- a/clippy_lints/src/loops/while_let_on_iterator.rs
+++ b/clippy_lints/src/loops/while_let_on_iterator.rs
@@ -331,9 +331,8 @@ fn needs_mutable_borrow(cx: &LateContext<'_>, iter_expr: &IterExpr, loop_expr: &
     }
 
     if let Some(e) = get_enclosing_loop_or_multi_call_closure(cx, loop_expr) {
-        let local_id = match iter_expr.path {
-            Res::Local(id) => id,
-            _ => return true,
+        let Res::Local(local_id) = iter_expr.path else {
+            return true
         };
         let mut v = NestedLoopVisitor {
             cx,
diff --git a/clippy_lints/src/matches/manual_utils.rs b/clippy_lints/src/matches/manual_utils.rs
index 792908aa7df..5b7644a5383 100644
--- a/clippy_lints/src/matches/manual_utils.rs
+++ b/clippy_lints/src/matches/manual_utils.rs
@@ -60,9 +60,8 @@ where
         return None;
     }
 
-    let some_expr = match get_some_expr_fn(cx, some_pat, some_expr, expr_ctxt) {
-        Some(expr) => expr,
-        None => return None,
+    let Some(some_expr) = get_some_expr_fn(cx, some_pat, some_expr, expr_ctxt) else {
+        return None;
     };
 
     // These two lints will go back and forth with each other.
diff --git a/clippy_lints/src/matches/match_same_arms.rs b/clippy_lints/src/matches/match_same_arms.rs
index 37049f83577..168c1e4d2e6 100644
--- a/clippy_lints/src/matches/match_same_arms.rs
+++ b/clippy_lints/src/matches/match_same_arms.rs
@@ -221,7 +221,6 @@ fn iter_matching_struct_fields<'a>(
 
 #[expect(clippy::similar_names)]
 impl<'a> NormalizedPat<'a> {
-    #[expect(clippy::too_many_lines)]
     fn from_pat(cx: &LateContext<'_>, arena: &'a DroplessArena, pat: &'a Pat<'_>) -> Self {
         match pat.kind {
             PatKind::Wild | PatKind::Binding(.., None) => Self::Wild,
@@ -235,9 +234,8 @@ impl<'a> NormalizedPat<'a> {
                 Self::Struct(cx.qpath_res(path, pat.hir_id).opt_def_id(), fields)
             },
             PatKind::TupleStruct(ref path, pats, wild_idx) => {
-                let adt = match cx.typeck_results().pat_ty(pat).ty_adt_def() {
-                    Some(x) => x,
-                    None => return Self::Wild,
+                let Some(adt) = cx.typeck_results().pat_ty(pat).ty_adt_def() else {
+                    return Self::Wild
                 };
                 let (var_id, variant) = if adt.is_enum() {
                     match cx.qpath_res(path, pat.hir_id).opt_def_id() {
diff --git a/clippy_lints/src/methods/into_iter_on_ref.rs b/clippy_lints/src/methods/into_iter_on_ref.rs
index be56b63506a..8adf9e37059 100644
--- a/clippy_lints/src/methods/into_iter_on_ref.rs
+++ b/clippy_lints/src/methods/into_iter_on_ref.rs
@@ -42,9 +42,8 @@ pub(super) fn check(
 
 fn ty_has_iter_method(cx: &LateContext<'_>, self_ref_ty: Ty<'_>) -> Option<(Symbol, &'static str)> {
     has_iter_method(cx, self_ref_ty).map(|ty_name| {
-        let mutbl = match self_ref_ty.kind() {
-            ty::Ref(_, _, mutbl) => mutbl,
-            _ => unreachable!(),
+        let ty::Ref(_, _, mutbl) = self_ref_ty.kind() else {
+            unreachable!()
         };
         let method_name = match mutbl {
             hir::Mutability::Not => "iter",
diff --git a/clippy_lints/src/methods/manual_saturating_arithmetic.rs b/clippy_lints/src/methods/manual_saturating_arithmetic.rs
index ec694cf6882..b80541b8647 100644
--- a/clippy_lints/src/methods/manual_saturating_arithmetic.rs
+++ b/clippy_lints/src/methods/manual_saturating_arithmetic.rs
@@ -21,11 +21,7 @@ pub fn check(
         return;
     }
 
-    let mm = if let Some(mm) = is_min_or_max(cx, unwrap_arg) {
-        mm
-    } else {
-        return;
-    };
+    let Some(mm) = is_min_or_max(cx, unwrap_arg) else { return };
 
     if ty.is_signed() {
         use self::{
@@ -33,9 +29,7 @@ pub fn check(
             Sign::{Neg, Pos},
         };
 
-        let sign = if let Some(sign) = lit_sign(arith_rhs) {
-            sign
-        } else {
+        let Some(sign) = lit_sign(arith_rhs) else {
             return;
         };
 
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index cfcf9596c50..78c1b33ed97 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3851,9 +3851,8 @@ impl SelfKind {
                 hir::Mutability::Mut => &paths::ASMUT_TRAIT,
             };
 
-            let trait_def_id = match get_trait_def_id(cx, trait_path) {
-                Some(did) => did,
-                None => return false,
+            let Some(trait_def_id) = get_trait_def_id(cx, trait_path) else {
+                return false
             };
             implements_trait(cx, ty, trait_def_id, &[parent_ty.into()])
         }
diff --git a/clippy_lints/src/methods/str_splitn.rs b/clippy_lints/src/methods/str_splitn.rs
index ae3594bd36c..1acac59144c 100644
--- a/clippy_lints/src/methods/str_splitn.rs
+++ b/clippy_lints/src/methods/str_splitn.rs
@@ -289,9 +289,7 @@ fn parse_iter_usage<'tcx>(
 ) -> Option<IterUsage> {
     let (kind, span) = match iter.next() {
         Some((_, Node::Expr(e))) if e.span.ctxt() == ctxt => {
-            let (name, args) = if let ExprKind::MethodCall(name, _, [args @ ..], _) = e.kind {
-                (name, args)
-            } else {
+            let ExprKind::MethodCall(name, _, [args @ ..], _) = e.kind else {
                 return None;
             };
             let did = cx.typeck_results().type_dependent_def_id(e.hir_id)?;
diff --git a/clippy_lints/src/misc_early/literal_suffix.rs b/clippy_lints/src/misc_early/literal_suffix.rs
index 62c6ca32d31..27e7f8505eb 100644
--- a/clippy_lints/src/misc_early/literal_suffix.rs
+++ b/clippy_lints/src/misc_early/literal_suffix.rs
@@ -6,9 +6,7 @@ use rustc_lint::EarlyContext;
 use super::{SEPARATED_LITERAL_SUFFIX, UNSEPARATED_LITERAL_SUFFIX};
 
 pub(super) fn check(cx: &EarlyContext<'_>, lit: &Lit, lit_snip: &str, suffix: &str, sugg_type: &str) {
-    let maybe_last_sep_idx = if let Some(val) = lit_snip.len().checked_sub(suffix.len() + 1) {
-        val
-    } else {
+    let Some(maybe_last_sep_idx) = lit_snip.len().checked_sub(suffix.len() + 1) else {
         return; // It's useless so shouldn't lint.
     };
     // Do not lint when literal is unsuffixed.
diff --git a/clippy_lints/src/misc_early/mixed_case_hex_literals.rs b/clippy_lints/src/misc_early/mixed_case_hex_literals.rs
index 80e24213100..263ee1e945a 100644
--- a/clippy_lints/src/misc_early/mixed_case_hex_literals.rs
+++ b/clippy_lints/src/misc_early/mixed_case_hex_literals.rs
@@ -5,9 +5,7 @@ use rustc_lint::EarlyContext;
 use super::MIXED_CASE_HEX_LITERALS;
 
 pub(super) fn check(cx: &EarlyContext<'_>, lit: &Lit, suffix: &str, lit_snip: &str) {
-    let maybe_last_sep_idx = if let Some(val) = lit_snip.len().checked_sub(suffix.len() + 1) {
-        val
-    } else {
+    let Some(maybe_last_sep_idx) = lit_snip.len().checked_sub(suffix.len() + 1) else {
         return; // It's useless so shouldn't lint.
     };
     if maybe_last_sep_idx <= 2 {
diff --git a/clippy_lints/src/mismatching_type_param_order.rs b/clippy_lints/src/mismatching_type_param_order.rs
index 6dd76a6531e..9de4b56b77b 100644
--- a/clippy_lints/src/mismatching_type_param_order.rs
+++ b/clippy_lints/src/mismatching_type_param_order.rs
@@ -70,9 +70,8 @@ impl<'tcx> LateLintPass<'tcx> for TypeParamMismatch {
 
                 // find the type that the Impl is for
                 // only lint on struct/enum/union for now
-                let defid = match path.res {
-                    Res::Def(DefKind::Struct | DefKind::Enum | DefKind::Union, defid) => defid,
-                    _ => return,
+                let Res::Def(DefKind::Struct | DefKind::Enum | DefKind::Union, defid) = path.res else {
+                    return
                 };
 
                 // get the names of the generic parameters in the type
diff --git a/clippy_lints/src/mixed_read_write_in_expression.rs b/clippy_lints/src/mixed_read_write_in_expression.rs
index a2419c277e9..6752976348f 100644
--- a/clippy_lints/src/mixed_read_write_in_expression.rs
+++ b/clippy_lints/src/mixed_read_write_in_expression.rs
@@ -190,10 +190,7 @@ fn check_for_unsequenced_reads(vis: &mut ReadVisitor<'_, '_>) {
         if parent_id == cur_id {
             break;
         }
-        let parent_node = match map.find(parent_id) {
-            Some(parent) => parent,
-            None => break,
-        };
+        let Some(parent_node) = map.find(parent_id) else { break };
 
         let stop_early = match parent_node {
             Node::Expr(expr) => check_expr(vis, expr),
diff --git a/clippy_lints/src/needless_for_each.rs b/clippy_lints/src/needless_for_each.rs
index 3233d87c073..c3b633fd6a0 100644
--- a/clippy_lints/src/needless_for_each.rs
+++ b/clippy_lints/src/needless_for_each.rs
@@ -49,9 +49,8 @@ declare_lint_pass!(NeedlessForEach => [NEEDLESS_FOR_EACH]);
 
 impl<'tcx> LateLintPass<'tcx> for NeedlessForEach {
     fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) {
-        let expr = match stmt.kind {
-            StmtKind::Expr(expr) | StmtKind::Semi(expr) => expr,
-            _ => return,
+        let (StmtKind::Expr(expr) | StmtKind::Semi(expr)) = stmt.kind else {
+             return
         };
 
         if_chain! {
diff --git a/clippy_lints/src/non_copy_const.rs b/clippy_lints/src/non_copy_const.rs
index 2c839d029c6..a6742824bc5 100644
--- a/clippy_lints/src/non_copy_const.rs
+++ b/clippy_lints/src/non_copy_const.rs
@@ -357,9 +357,8 @@ impl<'tcx> LateLintPass<'tcx> for NonCopyConst {
             }
 
             // Make sure it is a const item.
-            let item_def_id = match cx.qpath_res(qpath, expr.hir_id) {
-                Res::Def(DefKind::Const | DefKind::AssocConst, did) => did,
-                _ => return,
+            let Res::Def(DefKind::Const | DefKind::AssocConst, item_def_id) = cx.qpath_res(qpath, expr.hir_id) else {
+                return
             };
 
             // Climb up to resolve any field access and explicit referencing.
diff --git a/clippy_lints/src/non_octal_unix_permissions.rs b/clippy_lints/src/non_octal_unix_permissions.rs
index 1a765b14892..2ecb0487484 100644
--- a/clippy_lints/src/non_octal_unix_permissions.rs
+++ b/clippy_lints/src/non_octal_unix_permissions.rs
@@ -55,9 +55,8 @@ impl<'tcx> LateLintPass<'tcx> for NonOctalUnixPermissions {
                     if let ExprKind::Lit(_) = param.kind;
 
                     then {
-                        let snip = match snippet_opt(cx, param.span) {
-                            Some(s) => s,
-                            _ => return,
+                        let Some(snip) = snippet_opt(cx, param.span) else {
+                            return
                         };
 
                         if !snip.starts_with("0o") {
@@ -72,16 +71,10 @@ impl<'tcx> LateLintPass<'tcx> for NonOctalUnixPermissions {
                     if let Some(def_id) = cx.qpath_res(path, func.hir_id).opt_def_id();
                     if match_def_path(cx, def_id, &paths::PERMISSIONS_FROM_MODE);
                     if let ExprKind::Lit(_) = param.kind;
-
+                    if let Some(snip) = snippet_opt(cx, param.span);
+                    if !snip.starts_with("0o");
                     then {
-                        let snip = match snippet_opt(cx, param.span) {
-                            Some(s) => s,
-                            _ => return,
-                        };
-
-                        if !snip.starts_with("0o") {
-                            show_error(cx, param);
-                        }
+                        show_error(cx, param);
                     }
                 }
             },
diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs
index d296a150b46..2d80236327a 100644
--- a/clippy_lints/src/ptr.rs
+++ b/clippy_lints/src/ptr.rs
@@ -552,9 +552,8 @@ fn check_ptr_arg_usage<'tcx>(cx: &LateContext<'tcx>, body: &'tcx Body<'_>, args:
             }
 
             // Check if this is local we care about
-            let args_idx = match path_to_local(e).and_then(|id| self.bindings.get(&id)) {
-                Some(&i) => i,
-                None => return walk_expr(self, e),
+            let Some(&args_idx) = path_to_local(e).and_then(|id| self.bindings.get(&id)) else {
+                return walk_expr(self, e);
             };
             let args = &self.args[args_idx];
             let result = &mut self.results[args_idx];
@@ -609,9 +608,7 @@ fn check_ptr_arg_usage<'tcx>(cx: &LateContext<'tcx>, body: &'tcx Body<'_>, args:
                             }
                         }
 
-                        let id = if let Some(x) = self.cx.typeck_results().type_dependent_def_id(e.hir_id) {
-                            x
-                        } else {
+                        let Some(id) = self.cx.typeck_results().type_dependent_def_id(e.hir_id) else {
                             set_skip_flag();
                             return;
                         };
diff --git a/clippy_lints/src/ptr_offset_with_cast.rs b/clippy_lints/src/ptr_offset_with_cast.rs
index b0a5d1a6758..72dda67c72b 100644
--- a/clippy_lints/src/ptr_offset_with_cast.rs
+++ b/clippy_lints/src/ptr_offset_with_cast.rs
@@ -49,15 +49,13 @@ declare_lint_pass!(PtrOffsetWithCast => [PTR_OFFSET_WITH_CAST]);
 impl<'tcx> LateLintPass<'tcx> for PtrOffsetWithCast {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         // Check if the expressions is a ptr.offset or ptr.wrapping_offset method call
-        let (receiver_expr, arg_expr, method) = match expr_as_ptr_offset_call(cx, expr) {
-            Some(call_arg) => call_arg,
-            None => return,
+        let Some((receiver_expr, arg_expr, method)) = expr_as_ptr_offset_call(cx, expr) else {
+            return
         };
 
         // Check if the argument to the method call is a cast from usize
-        let cast_lhs_expr = match expr_as_cast_from_usize(cx, arg_expr) {
-            Some(cast_lhs_expr) => cast_lhs_expr,
-            None => return,
+        let Some(cast_lhs_expr) = expr_as_cast_from_usize(cx, arg_expr) else {
+            return
         };
 
         let msg = format!("use of `{method}` with a `usize` casted to an `isize`");
diff --git a/clippy_lints/src/shadow.rs b/clippy_lints/src/shadow.rs
index 5dcdab5b8ab..87f966ced0d 100644
--- a/clippy_lints/src/shadow.rs
+++ b/clippy_lints/src/shadow.rs
@@ -106,10 +106,7 @@ impl_lint_pass!(Shadow => [SHADOW_SAME, SHADOW_REUSE, SHADOW_UNRELATED]);
 
 impl<'tcx> LateLintPass<'tcx> for Shadow {
     fn check_pat(&mut self, cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>) {
-        let (id, ident) = match pat.kind {
-            PatKind::Binding(_, hir_id, ident, _) => (hir_id, ident),
-            _ => return,
-        };
+        let PatKind::Binding(_, id, ident, _) = pat.kind else { return };
 
         if pat.span.desugaring_kind().is_some() {
             return;
diff --git a/clippy_lints/src/types/rc_buffer.rs b/clippy_lints/src/types/rc_buffer.rs
index 6b9de64e24c..e39fdc1ea70 100644
--- a/clippy_lints/src/types/rc_buffer.rs
+++ b/clippy_lints/src/types/rc_buffer.rs
@@ -26,10 +26,7 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_
             if !cx.tcx.is_diagnostic_item(sym::Vec, id) {
                 return false;
             }
-            let qpath = match &ty.kind {
-                TyKind::Path(qpath) => qpath,
-                _ => return false,
-            };
+            let TyKind::Path(qpath) = &ty.kind else { return false };
             let inner_span = match qpath_generic_tys(qpath).next() {
                 Some(ty) => ty.span,
                 None => return false,
@@ -65,10 +62,7 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_
             if !cx.tcx.is_diagnostic_item(sym::Vec, id) {
                 return false;
             }
-            let qpath = match &ty.kind {
-                TyKind::Path(qpath) => qpath,
-                _ => return false,
-            };
+            let TyKind::Path(qpath) = &ty.kind else { return false };
             let inner_span = match qpath_generic_tys(qpath).next() {
                 Some(ty) => ty.span,
                 None => return false,
diff --git a/clippy_lints/src/types/redundant_allocation.rs b/clippy_lints/src/types/redundant_allocation.rs
index ecb67200539..92d2c48a589 100644
--- a/clippy_lints/src/types/redundant_allocation.rs
+++ b/clippy_lints/src/types/redundant_allocation.rs
@@ -47,9 +47,8 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_
         _ => return false,
     };
 
-    let inner_qpath = match &ty.kind {
-        TyKind::Path(inner_qpath) => inner_qpath,
-        _ => return false,
+    let TyKind::Path(inner_qpath) = &ty.kind else {
+        return false
     };
     let inner_span = match qpath_generic_tys(inner_qpath).next() {
         Some(ty) => {
diff --git a/clippy_lints/src/unnested_or_patterns.rs b/clippy_lints/src/unnested_or_patterns.rs
index fb73c386640..b305dae7608 100644
--- a/clippy_lints/src/unnested_or_patterns.rs
+++ b/clippy_lints/src/unnested_or_patterns.rs
@@ -163,9 +163,8 @@ fn unnest_or_patterns(pat: &mut P<Pat>) -> bool {
             noop_visit_pat(p, self);
 
             // Don't have an or-pattern? Just quit early on.
-            let alternatives = match &mut p.kind {
-                Or(ps) => ps,
-                _ => return,
+            let Or(alternatives) = &mut p.kind else {
+                return
             };
 
             // Collapse or-patterns directly nested in or-patterns.
diff --git a/clippy_lints/src/unused_io_amount.rs b/clippy_lints/src/unused_io_amount.rs
index 8bcdff66331..92053cec59f 100644
--- a/clippy_lints/src/unused_io_amount.rs
+++ b/clippy_lints/src/unused_io_amount.rs
@@ -47,9 +47,8 @@ declare_lint_pass!(UnusedIoAmount => [UNUSED_IO_AMOUNT]);
 
 impl<'tcx> LateLintPass<'tcx> for UnusedIoAmount {
     fn check_stmt(&mut self, cx: &LateContext<'_>, s: &hir::Stmt<'_>) {
-        let expr = match s.kind {
-            hir::StmtKind::Semi(expr) | hir::StmtKind::Expr(expr) => expr,
-            _ => return,
+        let (hir::StmtKind::Semi(expr) | hir::StmtKind::Expr(expr)) = s.kind else {
+            return
         };
 
         match expr.kind {
diff --git a/clippy_lints/src/useless_conversion.rs b/clippy_lints/src/useless_conversion.rs
index a82643a59f9..1f69db1cbca 100644
--- a/clippy_lints/src/useless_conversion.rs
+++ b/clippy_lints/src/useless_conversion.rs
@@ -55,9 +55,8 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
 
         match e.kind {
             ExprKind::Match(_, arms, MatchSource::TryDesugar) => {
-                let e = match arms[0].body.kind {
-                    ExprKind::Ret(Some(e)) | ExprKind::Break(_, Some(e)) => e,
-                    _ => return,
+                let (ExprKind::Ret(Some(e)) | ExprKind::Break(_, Some(e))) = arms[0].body.kind else {
+                     return
                 };
                 if let ExprKind::Call(_, [arg, ..]) = e.kind {
                     self.try_desugar_arm.push(arg.hir_id);
diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs
index 85bcbc7ad23..0d908bf2a83 100644
--- a/clippy_lints/src/utils/internal_lints.rs
+++ b/clippy_lints/src/utils/internal_lints.rs
@@ -1402,18 +1402,12 @@ impl<'tcx> LateLintPass<'tcx> for IfChainStyle {
         } else {
             return;
         };
-        let then_block = match then.kind {
-            ExprKind::Block(block, _) => block,
-            _ => return,
-        };
+        let ExprKind::Block(then_block, _) = then.kind else { return };
         let if_chain_span = is_expn_of(expr.span, "if_chain");
         if !els {
             check_nested_if_chains(cx, expr, then_block, if_chain_span);
         }
-        let if_chain_span = match if_chain_span {
-            None => return,
-            Some(span) => span,
-        };
+        let Some(if_chain_span) = if_chain_span else { return };
         // check for `if a && b;`
         if_chain! {
             if let ExprKind::Binary(op, _, _) = cond.kind;
-- 
cgit 1.4.1-3-g733a5


From 9ebd6916125e9181d1ce340a159e9403afc99188 Mon Sep 17 00:00:00 2001
From: Cody <cody@codyq.dev>
Date: Mon, 10 Oct 2022 23:37:09 -0500
Subject: Fix allow_attributes_without_reason applying to external crate macros

Previously the `clippy::allow_attributes_without_reason` lint would
apply to external crate macros. Many macros in the Rust ecosystem
include these `allow` attributes without adding a reason, making this
lint pretty much unusable in any sizable Rust project.

This commit fixes that by adding a check to the lint if the attribute is
from an external crate macro and returning early.
---
 clippy_lints/src/attrs.rs | 5 +++++
 1 file changed, 5 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs
index 0bd1f8b784e..bed9cf565f3 100644
--- a/clippy_lints/src/attrs.rs
+++ b/clippy_lints/src/attrs.rs
@@ -464,6 +464,11 @@ fn check_lint_reason(cx: &LateContext<'_>, name: Symbol, items: &[NestedMetaItem
         return;
     }
 
+    // Check if the attribute is in an external macro and therefore out of the developer's control
+    if in_external_macro(cx.sess(), attr.span) {
+        return;
+    }
+
     span_lint_and_help(
         cx,
         ALLOW_ATTRIBUTES_WITHOUT_REASON,
-- 
cgit 1.4.1-3-g733a5


From 74ba7e1b99034ef7ad183b8b3d41f6e5063fbdf0 Mon Sep 17 00:00:00 2001
From: Yuri Astrakhan <YuriAstrakhan@gmail.com>
Date: Sat, 8 Oct 2022 04:49:00 -0400
Subject: Handle panic! inline_format-arg before ed2021

---
 clippy_lints/src/format_args.rs            | 12 +++++--
 tests/ui/uninlined_format_args.fixed       | 13 ++++++++
 tests/ui/uninlined_format_args.rs          | 13 ++++++++
 tests/ui/uninlined_format_args.stderr      | 40 +++++++++++++++++++++--
 tests/ui/uninlined_format_args_2018.fixed  | 27 ++++++++++++++++
 tests/ui/uninlined_format_args_2018.rs     | 27 ++++++++++++++++
 tests/ui/uninlined_format_args_2018.stderr | 15 +++++++++
 tests/ui/uninlined_format_args_2021.fixed  | 23 ++++++++++++++
 tests/ui/uninlined_format_args_2021.rs     | 23 ++++++++++++++
 tests/ui/uninlined_format_args_2021.stderr | 51 ++++++++++++++++++++++++++++++
 10 files changed, 239 insertions(+), 5 deletions(-)
 create mode 100644 tests/ui/uninlined_format_args_2018.fixed
 create mode 100644 tests/ui/uninlined_format_args_2018.rs
 create mode 100644 tests/ui/uninlined_format_args_2018.stderr
 create mode 100644 tests/ui/uninlined_format_args_2021.fixed
 create mode 100644 tests/ui/uninlined_format_args_2021.rs
 create mode 100644 tests/ui/uninlined_format_args_2021.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/format_args.rs b/clippy_lints/src/format_args.rs
index 45ed21e066a..97d2973cce8 100644
--- a/clippy_lints/src/format_args.rs
+++ b/clippy_lints/src/format_args.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::macros::FormatParamKind::{Implicit, Named, Numbered, Starred};
-use clippy_utils::macros::{is_format_macro, FormatArgsExpn, FormatParam, FormatParamUsage};
+use clippy_utils::macros::{is_format_macro, is_panic, FormatArgsExpn, FormatParam, FormatParamUsage};
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::implements_trait;
 use clippy_utils::{is_diag_trait_item, meets_msrv, msrvs};
@@ -13,6 +13,8 @@ use rustc_middle::ty::adjustment::{Adjust, Adjustment};
 use rustc_middle::ty::Ty;
 use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::def_id::DefId;
+use rustc_span::edition::Edition::Edition2021;
 use rustc_span::{sym, ExpnData, ExpnKind, Span, Symbol};
 
 declare_clippy_lint! {
@@ -149,7 +151,7 @@ impl<'tcx> LateLintPass<'tcx> for FormatArgs {
                     check_to_string_in_format_args(cx, name, arg.param.value);
                 }
                 if meets_msrv(self.msrv, msrvs::FORMAT_ARGS_CAPTURE) {
-                    check_uninlined_args(cx, &format_args, outermost_expn_data.call_site);
+                    check_uninlined_args(cx, &format_args, outermost_expn_data.call_site, macro_def_id);
                 }
             }
         }
@@ -158,10 +160,14 @@ impl<'tcx> LateLintPass<'tcx> for FormatArgs {
     extract_msrv_attr!(LateContext);
 }
 
-fn check_uninlined_args(cx: &LateContext<'_>, args: &FormatArgsExpn<'_>, call_site: Span) {
+fn check_uninlined_args(cx: &LateContext<'_>, args: &FormatArgsExpn<'_>, call_site: Span, def_id: DefId) {
     if args.format_string.span.from_expansion() {
         return;
     }
+    if call_site.edition() < Edition2021 && is_panic(cx, def_id) {
+        // panic! before 2021 edition considers a single string argument as non-format
+        return;
+    }
 
     let mut fixes = Vec::new();
     // If any of the arguments are referenced by an index number,
diff --git a/tests/ui/uninlined_format_args.fixed b/tests/ui/uninlined_format_args.fixed
index 3ca7a401902..10627447975 100644
--- a/tests/ui/uninlined_format_args.fixed
+++ b/tests/ui/uninlined_format_args.fixed
@@ -150,6 +150,19 @@ fn tester(fn_arg: i32) {
 
     println!(with_span!("{0} {1}" "{1} {0}"), local_i32, local_f64);
     println!("{}", with_span!(span val));
+
+    if local_i32 > 0 {
+        panic!("p1 {local_i32}");
+    }
+    if local_i32 > 0 {
+        panic!("p2 {local_i32}");
+    }
+    if local_i32 > 0 {
+        panic!("p3 {local_i32}");
+    }
+    if local_i32 > 0 {
+        panic!("p4 {local_i32}");
+    }
 }
 
 fn main() {
diff --git a/tests/ui/uninlined_format_args.rs b/tests/ui/uninlined_format_args.rs
index 924191f4324..8e495ebd083 100644
--- a/tests/ui/uninlined_format_args.rs
+++ b/tests/ui/uninlined_format_args.rs
@@ -150,6 +150,19 @@ fn tester(fn_arg: i32) {
 
     println!(with_span!("{0} {1}" "{1} {0}"), local_i32, local_f64);
     println!("{}", with_span!(span val));
+
+    if local_i32 > 0 {
+        panic!("p1 {}", local_i32);
+    }
+    if local_i32 > 0 {
+        panic!("p2 {0}", local_i32);
+    }
+    if local_i32 > 0 {
+        panic!("p3 {local_i32}", local_i32 = local_i32);
+    }
+    if local_i32 > 0 {
+        panic!("p4 {local_i32}");
+    }
 }
 
 fn main() {
diff --git a/tests/ui/uninlined_format_args.stderr b/tests/ui/uninlined_format_args.stderr
index d1a77492634..2ce3b7fa960 100644
--- a/tests/ui/uninlined_format_args.stderr
+++ b/tests/ui/uninlined_format_args.stderr
@@ -828,7 +828,43 @@ LL +     println!("{val}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:168:5
+  --> $DIR/uninlined_format_args.rs:155:9
+   |
+LL |         panic!("p1 {}", local_i32);
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -         panic!("p1 {}", local_i32);
+LL +         panic!("p1 {local_i32}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:158:9
+   |
+LL |         panic!("p2 {0}", local_i32);
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -         panic!("p2 {0}", local_i32);
+LL +         panic!("p2 {local_i32}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:161:9
+   |
+LL |         panic!("p3 {local_i32}", local_i32 = local_i32);
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -         panic!("p3 {local_i32}", local_i32 = local_i32);
+LL +         panic!("p3 {local_i32}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:181:5
    |
 LL |     println!("expand='{}'", local_i32);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -839,5 +875,5 @@ LL -     println!("expand='{}'", local_i32);
 LL +     println!("expand='{local_i32}'");
    |
 
-error: aborting due to 70 previous errors
+error: aborting due to 73 previous errors
 
diff --git a/tests/ui/uninlined_format_args_2018.fixed b/tests/ui/uninlined_format_args_2018.fixed
new file mode 100644
index 00000000000..2acccc25dd2
--- /dev/null
+++ b/tests/ui/uninlined_format_args_2018.fixed
@@ -0,0 +1,27 @@
+// run-rustfix
+// edition:2018
+
+#![warn(clippy::uninlined_format_args)]
+
+fn main() {
+    let var = 1;
+
+    println!("val='{var}'");
+
+    if var > 0 {
+        panic!("p1 {}", var);
+    }
+    if var > 0 {
+        panic!("p2 {0}", var);
+    }
+    if var > 0 {
+        panic!("p3 {var}", var = var);
+    }
+
+    #[allow(non_fmt_panics)]
+    {
+        if var > 0 {
+            panic!("p4 {var}");
+        }
+    }
+}
diff --git a/tests/ui/uninlined_format_args_2018.rs b/tests/ui/uninlined_format_args_2018.rs
new file mode 100644
index 00000000000..e3c91778202
--- /dev/null
+++ b/tests/ui/uninlined_format_args_2018.rs
@@ -0,0 +1,27 @@
+// run-rustfix
+// edition:2018
+
+#![warn(clippy::uninlined_format_args)]
+
+fn main() {
+    let var = 1;
+
+    println!("val='{}'", var);
+
+    if var > 0 {
+        panic!("p1 {}", var);
+    }
+    if var > 0 {
+        panic!("p2 {0}", var);
+    }
+    if var > 0 {
+        panic!("p3 {var}", var = var);
+    }
+
+    #[allow(non_fmt_panics)]
+    {
+        if var > 0 {
+            panic!("p4 {var}");
+        }
+    }
+}
diff --git a/tests/ui/uninlined_format_args_2018.stderr b/tests/ui/uninlined_format_args_2018.stderr
new file mode 100644
index 00000000000..43e21326d32
--- /dev/null
+++ b/tests/ui/uninlined_format_args_2018.stderr
@@ -0,0 +1,15 @@
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args_2018.rs:9:5
+   |
+LL |     println!("val='{}'", var);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::uninlined-format-args` implied by `-D warnings`
+help: change this to
+   |
+LL -     println!("val='{}'", var);
+LL +     println!("val='{var}'");
+   |
+
+error: aborting due to previous error
+
diff --git a/tests/ui/uninlined_format_args_2021.fixed b/tests/ui/uninlined_format_args_2021.fixed
new file mode 100644
index 00000000000..0a9a4ee407e
--- /dev/null
+++ b/tests/ui/uninlined_format_args_2021.fixed
@@ -0,0 +1,23 @@
+// run-rustfix
+// edition:2021
+
+#![warn(clippy::uninlined_format_args)]
+
+fn main() {
+    let var = 1;
+
+    println!("val='{var}'");
+
+    if var > 0 {
+        panic!("p1 {var}");
+    }
+    if var > 0 {
+        panic!("p2 {var}");
+    }
+    if var > 0 {
+        panic!("p3 {var}");
+    }
+    if var > 0 {
+        panic!("p4 {var}");
+    }
+}
diff --git a/tests/ui/uninlined_format_args_2021.rs b/tests/ui/uninlined_format_args_2021.rs
new file mode 100644
index 00000000000..960b159dc36
--- /dev/null
+++ b/tests/ui/uninlined_format_args_2021.rs
@@ -0,0 +1,23 @@
+// run-rustfix
+// edition:2021
+
+#![warn(clippy::uninlined_format_args)]
+
+fn main() {
+    let var = 1;
+
+    println!("val='{}'", var);
+
+    if var > 0 {
+        panic!("p1 {}", var);
+    }
+    if var > 0 {
+        panic!("p2 {0}", var);
+    }
+    if var > 0 {
+        panic!("p3 {var}", var = var);
+    }
+    if var > 0 {
+        panic!("p4 {var}");
+    }
+}
diff --git a/tests/ui/uninlined_format_args_2021.stderr b/tests/ui/uninlined_format_args_2021.stderr
new file mode 100644
index 00000000000..bc2572650cc
--- /dev/null
+++ b/tests/ui/uninlined_format_args_2021.stderr
@@ -0,0 +1,51 @@
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args_2021.rs:9:5
+   |
+LL |     println!("val='{}'", var);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::uninlined-format-args` implied by `-D warnings`
+help: change this to
+   |
+LL -     println!("val='{}'", var);
+LL +     println!("val='{var}'");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args_2021.rs:12:9
+   |
+LL |         panic!("p1 {}", var);
+   |         ^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -         panic!("p1 {}", var);
+LL +         panic!("p1 {var}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args_2021.rs:15:9
+   |
+LL |         panic!("p2 {0}", var);
+   |         ^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -         panic!("p2 {0}", var);
+LL +         panic!("p2 {var}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args_2021.rs:18:9
+   |
+LL |         panic!("p3 {var}", var = var);
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -         panic!("p3 {var}", var = var);
+LL +         panic!("p3 {var}");
+   |
+
+error: aborting due to 4 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From ac6d2ba11e5c23cce18d2ee324034a6e7e7fab84 Mon Sep 17 00:00:00 2001
From: royrustdev <royrustdev@gmail.com>
Date: Mon, 3 Oct 2022 20:29:59 +0530
Subject: add tests in `implicit_saturating_sub` lint

---
 clippy_lints/src/implicit_saturating_sub.rs |  2 +-
 clippy_lints/src/lib.register_all.rs        |  1 +
 clippy_lints/src/lib.register_pedantic.rs   |  1 -
 clippy_lints/src/lib.register_style.rs      |  1 +
 tests/ui/implicit_saturating_sub.fixed      | 50 +++++++++++++++++++++++++++++
 tests/ui/implicit_saturating_sub.rs         | 50 +++++++++++++++++++++++++++++
 tests/ui/implicit_saturating_sub.stderr     | 46 +++++++++++++-------------
 7 files changed, 126 insertions(+), 25 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/implicit_saturating_sub.rs b/clippy_lints/src/implicit_saturating_sub.rs
index 48edbf6ae57..29d59c26d92 100644
--- a/clippy_lints/src/implicit_saturating_sub.rs
+++ b/clippy_lints/src/implicit_saturating_sub.rs
@@ -35,7 +35,7 @@ declare_clippy_lint! {
     /// ```
     #[clippy::version = "1.44.0"]
     pub IMPLICIT_SATURATING_SUB,
-    pedantic,
+    style,
     "Perform saturating subtraction instead of implicitly checking lower bound of data type"
 }
 
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 642d7070fb6..ee3b15e4d79 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -86,6 +86,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(functions::TOO_MANY_ARGUMENTS),
     LintId::of(if_let_mutex::IF_LET_MUTEX),
     LintId::of(implicit_saturating_add::IMPLICIT_SATURATING_ADD),
+    LintId::of(implicit_saturating_sub::IMPLICIT_SATURATING_SUB),
     LintId::of(indexing_slicing::OUT_OF_BOUNDS_INDEXING),
     LintId::of(infinite_iter::INFINITE_ITER),
     LintId::of(inherent_to_string::INHERENT_TO_STRING),
diff --git a/clippy_lints/src/lib.register_pedantic.rs b/clippy_lints/src/lib.register_pedantic.rs
index dd3e2b7d29c..cd4461aa2ae 100644
--- a/clippy_lints/src/lib.register_pedantic.rs
+++ b/clippy_lints/src/lib.register_pedantic.rs
@@ -34,7 +34,6 @@ store.register_group(true, "clippy::pedantic", Some("clippy_pedantic"), vec![
     LintId::of(functions::TOO_MANY_LINES),
     LintId::of(if_not_else::IF_NOT_ELSE),
     LintId::of(implicit_hasher::IMPLICIT_HASHER),
-    LintId::of(implicit_saturating_sub::IMPLICIT_SATURATING_SUB),
     LintId::of(inconsistent_struct_constructor::INCONSISTENT_STRUCT_CONSTRUCTOR),
     LintId::of(infinite_iter::MAYBE_INFINITE_ITER),
     LintId::of(invalid_upcast_comparisons::INVALID_UPCAST_COMPARISONS),
diff --git a/clippy_lints/src/lib.register_style.rs b/clippy_lints/src/lib.register_style.rs
index 6d5483bc701..08ec2bede4a 100644
--- a/clippy_lints/src/lib.register_style.rs
+++ b/clippy_lints/src/lib.register_style.rs
@@ -30,6 +30,7 @@ store.register_group(true, "clippy::style", Some("clippy_style"), vec![
     LintId::of(functions::MUST_USE_UNIT),
     LintId::of(functions::RESULT_UNIT_ERR),
     LintId::of(implicit_saturating_add::IMPLICIT_SATURATING_ADD),
+    LintId::of(implicit_saturating_sub::IMPLICIT_SATURATING_SUB),
     LintId::of(inherent_to_string::INHERENT_TO_STRING),
     LintId::of(init_numbered_fields::INIT_NUMBERED_FIELDS),
     LintId::of(len_zero::COMPARISON_TO_EMPTY),
diff --git a/tests/ui/implicit_saturating_sub.fixed b/tests/ui/implicit_saturating_sub.fixed
index e6f57e9267e..93df81b1a7f 100644
--- a/tests/ui/implicit_saturating_sub.fixed
+++ b/tests/ui/implicit_saturating_sub.fixed
@@ -2,6 +2,21 @@
 #![allow(unused_assignments, unused_mut, clippy::assign_op_pattern)]
 #![warn(clippy::implicit_saturating_sub)]
 
+use std::cmp::PartialEq;
+use std::ops::SubAssign;
+// Mock type
+struct Mock;
+
+impl PartialEq<u32> for Mock {
+    fn eq(&self, _: &u32) -> bool {
+        true
+    }
+}
+
+impl SubAssign<u32> for Mock {
+    fn sub_assign(&mut self, _: u32) {}
+}
+
 fn main() {
     // Tests for unsigned integers
 
@@ -165,4 +180,39 @@ fn main() {
     } else {
         println!("side effect");
     }
+
+    // Extended tests
+    let mut m = Mock;
+    let mut u_32 = 3000;
+    let a = 200;
+    let mut _b = 8;
+
+    if m != 0 {
+        m -= 1;
+    }
+
+    if a > 0 {
+        _b -= 1;
+    }
+
+    if 0 > a {
+        _b -= 1;
+    }
+
+    if u_32 > 0 {
+        u_32 -= 1;
+    } else {
+        println!("don't lint this");
+    }
+
+    if u_32 > 0 {
+        println!("don't lint this");
+        u_32 -= 1;
+    }
+
+    if u_32 > 42 {
+        println!("brace yourself!");
+    } else if u_32 > 0 {
+        u_32 -= 1;
+    }
 }
diff --git a/tests/ui/implicit_saturating_sub.rs b/tests/ui/implicit_saturating_sub.rs
index 8bb28d149c6..8340bc8264d 100644
--- a/tests/ui/implicit_saturating_sub.rs
+++ b/tests/ui/implicit_saturating_sub.rs
@@ -2,6 +2,21 @@
 #![allow(unused_assignments, unused_mut, clippy::assign_op_pattern)]
 #![warn(clippy::implicit_saturating_sub)]
 
+use std::cmp::PartialEq;
+use std::ops::SubAssign;
+// Mock type
+struct Mock;
+
+impl PartialEq<u32> for Mock {
+    fn eq(&self, _: &u32) -> bool {
+        true
+    }
+}
+
+impl SubAssign<u32> for Mock {
+    fn sub_assign(&mut self, _: u32) {}
+}
+
 fn main() {
     // Tests for unsigned integers
 
@@ -211,4 +226,39 @@ fn main() {
     } else {
         println!("side effect");
     }
+
+    // Extended tests
+    let mut m = Mock;
+    let mut u_32 = 3000;
+    let a = 200;
+    let mut _b = 8;
+
+    if m != 0 {
+        m -= 1;
+    }
+
+    if a > 0 {
+        _b -= 1;
+    }
+
+    if 0 > a {
+        _b -= 1;
+    }
+
+    if u_32 > 0 {
+        u_32 -= 1;
+    } else {
+        println!("don't lint this");
+    }
+
+    if u_32 > 0 {
+        println!("don't lint this");
+        u_32 -= 1;
+    }
+
+    if u_32 > 42 {
+        println!("brace yourself!");
+    } else if u_32 > 0 {
+        u_32 -= 1;
+    }
 }
diff --git a/tests/ui/implicit_saturating_sub.stderr b/tests/ui/implicit_saturating_sub.stderr
index 5bb9a606422..5e589d931e4 100644
--- a/tests/ui/implicit_saturating_sub.stderr
+++ b/tests/ui/implicit_saturating_sub.stderr
@@ -1,5 +1,5 @@
 error: implicitly performing saturating subtraction
-  --> $DIR/implicit_saturating_sub.rs:13:5
+  --> $DIR/implicit_saturating_sub.rs:28:5
    |
 LL | /     if u_8 > 0 {
 LL | |         u_8 = u_8 - 1;
@@ -9,7 +9,7 @@ LL | |     }
    = note: `-D clippy::implicit-saturating-sub` implied by `-D warnings`
 
 error: implicitly performing saturating subtraction
-  --> $DIR/implicit_saturating_sub.rs:20:13
+  --> $DIR/implicit_saturating_sub.rs:35:13
    |
 LL | /             if u_8 > 0 {
 LL | |                 u_8 -= 1;
@@ -17,7 +17,7 @@ LL | |             }
    | |_____________^ help: try: `u_8 = u_8.saturating_sub(1);`
 
 error: implicitly performing saturating subtraction
-  --> $DIR/implicit_saturating_sub.rs:34:5
+  --> $DIR/implicit_saturating_sub.rs:49:5
    |
 LL | /     if u_16 > 0 {
 LL | |         u_16 -= 1;
@@ -25,7 +25,7 @@ LL | |     }
    | |_____^ help: try: `u_16 = u_16.saturating_sub(1);`
 
 error: implicitly performing saturating subtraction
-  --> $DIR/implicit_saturating_sub.rs:44:5
+  --> $DIR/implicit_saturating_sub.rs:59:5
    |
 LL | /     if u_32 != 0 {
 LL | |         u_32 -= 1;
@@ -33,7 +33,7 @@ LL | |     }
    | |_____^ help: try: `u_32 = u_32.saturating_sub(1);`
 
 error: implicitly performing saturating subtraction
-  --> $DIR/implicit_saturating_sub.rs:65:5
+  --> $DIR/implicit_saturating_sub.rs:80:5
    |
 LL | /     if u_64 > 0 {
 LL | |         u_64 -= 1;
@@ -41,7 +41,7 @@ LL | |     }
    | |_____^ help: try: `u_64 = u_64.saturating_sub(1);`
 
 error: implicitly performing saturating subtraction
-  --> $DIR/implicit_saturating_sub.rs:70:5
+  --> $DIR/implicit_saturating_sub.rs:85:5
    |
 LL | /     if 0 < u_64 {
 LL | |         u_64 -= 1;
@@ -49,7 +49,7 @@ LL | |     }
    | |_____^ help: try: `u_64 = u_64.saturating_sub(1);`
 
 error: implicitly performing saturating subtraction
-  --> $DIR/implicit_saturating_sub.rs:75:5
+  --> $DIR/implicit_saturating_sub.rs:90:5
    |
 LL | /     if 0 != u_64 {
 LL | |         u_64 -= 1;
@@ -57,7 +57,7 @@ LL | |     }
    | |_____^ help: try: `u_64 = u_64.saturating_sub(1);`
 
 error: implicitly performing saturating subtraction
-  --> $DIR/implicit_saturating_sub.rs:96:5
+  --> $DIR/implicit_saturating_sub.rs:111:5
    |
 LL | /     if u_usize > 0 {
 LL | |         u_usize -= 1;
@@ -65,7 +65,7 @@ LL | |     }
    | |_____^ help: try: `u_usize = u_usize.saturating_sub(1);`
 
 error: implicitly performing saturating subtraction
-  --> $DIR/implicit_saturating_sub.rs:108:5
+  --> $DIR/implicit_saturating_sub.rs:123:5
    |
 LL | /     if i_8 > i8::MIN {
 LL | |         i_8 -= 1;
@@ -73,7 +73,7 @@ LL | |     }
    | |_____^ help: try: `i_8 = i_8.saturating_sub(1);`
 
 error: implicitly performing saturating subtraction
-  --> $DIR/implicit_saturating_sub.rs:113:5
+  --> $DIR/implicit_saturating_sub.rs:128:5
    |
 LL | /     if i_8 > i8::MIN {
 LL | |         i_8 -= 1;
@@ -81,7 +81,7 @@ LL | |     }
    | |_____^ help: try: `i_8 = i_8.saturating_sub(1);`
 
 error: implicitly performing saturating subtraction
-  --> $DIR/implicit_saturating_sub.rs:118:5
+  --> $DIR/implicit_saturating_sub.rs:133:5
    |
 LL | /     if i_8 != i8::MIN {
 LL | |         i_8 -= 1;
@@ -89,7 +89,7 @@ LL | |     }
    | |_____^ help: try: `i_8 = i_8.saturating_sub(1);`
 
 error: implicitly performing saturating subtraction
-  --> $DIR/implicit_saturating_sub.rs:123:5
+  --> $DIR/implicit_saturating_sub.rs:138:5
    |
 LL | /     if i_8 != i8::MIN {
 LL | |         i_8 -= 1;
@@ -97,7 +97,7 @@ LL | |     }
    | |_____^ help: try: `i_8 = i_8.saturating_sub(1);`
 
 error: implicitly performing saturating subtraction
-  --> $DIR/implicit_saturating_sub.rs:133:5
+  --> $DIR/implicit_saturating_sub.rs:148:5
    |
 LL | /     if i_16 > i16::MIN {
 LL | |         i_16 -= 1;
@@ -105,7 +105,7 @@ LL | |     }
    | |_____^ help: try: `i_16 = i_16.saturating_sub(1);`
 
 error: implicitly performing saturating subtraction
-  --> $DIR/implicit_saturating_sub.rs:138:5
+  --> $DIR/implicit_saturating_sub.rs:153:5
    |
 LL | /     if i_16 > i16::MIN {
 LL | |         i_16 -= 1;
@@ -113,7 +113,7 @@ LL | |     }
    | |_____^ help: try: `i_16 = i_16.saturating_sub(1);`
 
 error: implicitly performing saturating subtraction
-  --> $DIR/implicit_saturating_sub.rs:143:5
+  --> $DIR/implicit_saturating_sub.rs:158:5
    |
 LL | /     if i_16 != i16::MIN {
 LL | |         i_16 -= 1;
@@ -121,7 +121,7 @@ LL | |     }
    | |_____^ help: try: `i_16 = i_16.saturating_sub(1);`
 
 error: implicitly performing saturating subtraction
-  --> $DIR/implicit_saturating_sub.rs:148:5
+  --> $DIR/implicit_saturating_sub.rs:163:5
    |
 LL | /     if i_16 != i16::MIN {
 LL | |         i_16 -= 1;
@@ -129,7 +129,7 @@ LL | |     }
    | |_____^ help: try: `i_16 = i_16.saturating_sub(1);`
 
 error: implicitly performing saturating subtraction
-  --> $DIR/implicit_saturating_sub.rs:158:5
+  --> $DIR/implicit_saturating_sub.rs:173:5
    |
 LL | /     if i_32 > i32::MIN {
 LL | |         i_32 -= 1;
@@ -137,7 +137,7 @@ LL | |     }
    | |_____^ help: try: `i_32 = i_32.saturating_sub(1);`
 
 error: implicitly performing saturating subtraction
-  --> $DIR/implicit_saturating_sub.rs:163:5
+  --> $DIR/implicit_saturating_sub.rs:178:5
    |
 LL | /     if i_32 > i32::MIN {
 LL | |         i_32 -= 1;
@@ -145,7 +145,7 @@ LL | |     }
    | |_____^ help: try: `i_32 = i_32.saturating_sub(1);`
 
 error: implicitly performing saturating subtraction
-  --> $DIR/implicit_saturating_sub.rs:168:5
+  --> $DIR/implicit_saturating_sub.rs:183:5
    |
 LL | /     if i_32 != i32::MIN {
 LL | |         i_32 -= 1;
@@ -153,7 +153,7 @@ LL | |     }
    | |_____^ help: try: `i_32 = i_32.saturating_sub(1);`
 
 error: implicitly performing saturating subtraction
-  --> $DIR/implicit_saturating_sub.rs:173:5
+  --> $DIR/implicit_saturating_sub.rs:188:5
    |
 LL | /     if i_32 != i32::MIN {
 LL | |         i_32 -= 1;
@@ -161,7 +161,7 @@ LL | |     }
    | |_____^ help: try: `i_32 = i_32.saturating_sub(1);`
 
 error: implicitly performing saturating subtraction
-  --> $DIR/implicit_saturating_sub.rs:183:5
+  --> $DIR/implicit_saturating_sub.rs:198:5
    |
 LL | /     if i64::MIN < i_64 {
 LL | |         i_64 -= 1;
@@ -169,7 +169,7 @@ LL | |     }
    | |_____^ help: try: `i_64 = i_64.saturating_sub(1);`
 
 error: implicitly performing saturating subtraction
-  --> $DIR/implicit_saturating_sub.rs:188:5
+  --> $DIR/implicit_saturating_sub.rs:203:5
    |
 LL | /     if i64::MIN != i_64 {
 LL | |         i_64 -= 1;
@@ -177,7 +177,7 @@ LL | |     }
    | |_____^ help: try: `i_64 = i_64.saturating_sub(1);`
 
 error: implicitly performing saturating subtraction
-  --> $DIR/implicit_saturating_sub.rs:193:5
+  --> $DIR/implicit_saturating_sub.rs:208:5
    |
 LL | /     if i64::MIN < i_64 {
 LL | |         i_64 -= 1;
-- 
cgit 1.4.1-3-g733a5


From 31006b42279fabd80b9b6803a1a2076b431ff443 Mon Sep 17 00:00:00 2001
From: royrustdev <royrustdev@gmail.com>
Date: Wed, 12 Oct 2022 16:41:48 +0530
Subject: update Applicability of `rc_buffer` from `MachineApplicable` to
 `Unspecified`

---
 clippy_lints/src/types/rc_buffer.rs | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types/rc_buffer.rs b/clippy_lints/src/types/rc_buffer.rs
index e39fdc1ea70..fa567b9b2d2 100644
--- a/clippy_lints/src/types/rc_buffer.rs
+++ b/clippy_lints/src/types/rc_buffer.rs
@@ -9,6 +9,7 @@ use rustc_span::symbol::sym;
 use super::RC_BUFFER;
 
 pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_>, def_id: DefId) -> bool {
+    let app = Applicability::Unspecified;
     if cx.tcx.is_diagnostic_item(sym::Rc, def_id) {
         if let Some(alternate) = match_buffer_type(cx, qpath) {
             span_lint_and_sugg(
@@ -18,7 +19,7 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_
                 "usage of `Rc<T>` when T is a buffer type",
                 "try",
                 format!("Rc<{alternate}>"),
-                Applicability::MachineApplicable,
+                app,
             );
         } else {
             let Some(ty) = qpath_generic_tys(qpath).next() else { return false };
@@ -31,7 +32,7 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_
                 Some(ty) => ty.span,
                 None => return false,
             };
-            let mut applicability = Applicability::MachineApplicable;
+            let mut applicability = app;
             span_lint_and_sugg(
                 cx,
                 RC_BUFFER,
@@ -42,7 +43,7 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_
                     "Rc<[{}]>",
                     snippet_with_applicability(cx, inner_span, "..", &mut applicability)
                 ),
-                Applicability::MachineApplicable,
+                app,
             );
             return true;
         }
@@ -55,7 +56,7 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_
                 "usage of `Arc<T>` when T is a buffer type",
                 "try",
                 format!("Arc<{alternate}>"),
-                Applicability::MachineApplicable,
+                app,
             );
         } else if let Some(ty) = qpath_generic_tys(qpath).next() {
             let Some(id) = path_def_id(cx, ty) else { return false };
@@ -67,7 +68,7 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_
                 Some(ty) => ty.span,
                 None => return false,
             };
-            let mut applicability = Applicability::MachineApplicable;
+            let mut applicability = app;
             span_lint_and_sugg(
                 cx,
                 RC_BUFFER,
@@ -78,7 +79,7 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_
                     "Arc<[{}]>",
                     snippet_with_applicability(cx, inner_span, "..", &mut applicability)
                 ),
-                Applicability::MachineApplicable,
+                app,
             );
             return true;
         }
-- 
cgit 1.4.1-3-g733a5


From e4c80f2bba2e365968c529af2c622c09ee01e26a Mon Sep 17 00:00:00 2001
From: Andre Bogus <bogusandre@gmail.com>
Date: Sat, 8 Oct 2022 23:33:23 +0200
Subject: add `cast-nan-to-int` lint

---
 CHANGELOG.md                                |  1 +
 clippy_lints/src/casts/cast_nan_to_int.rs   | 28 ++++++++++++++++
 clippy_lints/src/casts/mod.rs               | 26 +++++++++++++++
 clippy_lints/src/lib.register_all.rs        |  1 +
 clippy_lints/src/lib.register_lints.rs      |  1 +
 clippy_lints/src/lib.register_suspicious.rs |  1 +
 src/docs.rs                                 |  1 +
 src/docs/cast_nan_to_int.txt                | 15 +++++++++
 tests/ui/cast_nan_to_int.rs                 | 18 ++++++++++
 tests/ui/cast_nan_to_int.stderr             | 51 +++++++++++++++++++++++++++++
 10 files changed, 143 insertions(+)
 create mode 100644 clippy_lints/src/casts/cast_nan_to_int.rs
 create mode 100644 src/docs/cast_nan_to_int.txt
 create mode 100644 tests/ui/cast_nan_to_int.rs
 create mode 100644 tests/ui/cast_nan_to_int.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 8babfc8d63c..f593966c045 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3773,6 +3773,7 @@ Released 2018-09-13
 [`cast_enum_constructor`]: https://rust-lang.github.io/rust-clippy/master/index.html#cast_enum_constructor
 [`cast_enum_truncation`]: https://rust-lang.github.io/rust-clippy/master/index.html#cast_enum_truncation
 [`cast_lossless`]: https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
+[`cast_nan_to_int`]: https://rust-lang.github.io/rust-clippy/master/index.html#cast_nan_to_int
 [`cast_possible_truncation`]: https://rust-lang.github.io/rust-clippy/master/index.html#cast_possible_truncation
 [`cast_possible_wrap`]: https://rust-lang.github.io/rust-clippy/master/index.html#cast_possible_wrap
 [`cast_precision_loss`]: https://rust-lang.github.io/rust-clippy/master/index.html#cast_precision_loss
diff --git a/clippy_lints/src/casts/cast_nan_to_int.rs b/clippy_lints/src/casts/cast_nan_to_int.rs
new file mode 100644
index 00000000000..322dc41b3a1
--- /dev/null
+++ b/clippy_lints/src/casts/cast_nan_to_int.rs
@@ -0,0 +1,28 @@
+use super::CAST_NAN_TO_INT;
+
+use clippy_utils::consts::{constant, Constant};
+use clippy_utils::diagnostics::span_lint_and_note;
+use rustc_hir::Expr;
+use rustc_lint::LateContext;
+use rustc_middle::ty::Ty;
+
+pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_expr: &Expr<'_>, from_ty: Ty<'_>, to_ty: Ty<'_>) {
+    if from_ty.is_floating_point() && to_ty.is_integral() && is_known_nan(cx, cast_expr) {
+        span_lint_and_note(
+            cx,
+            CAST_NAN_TO_INT,
+            expr.span,
+            &format!("casting a known NaN to {to_ty}"),
+            None,
+            "this always evaluates to 0",
+        );
+    }
+}
+
+fn is_known_nan(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
+    match constant(cx, cx.typeck_results(), e) {
+        Some((Constant::F64(n), _)) => n.is_nan(),
+        Some((Constant::F32(n), _)) => n.is_nan(),
+        _ => false,
+    }
+}
diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index b8f0dedf5ed..b72c4c772f1 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -4,6 +4,7 @@ mod borrow_as_ptr;
 mod cast_abs_to_unsigned;
 mod cast_enum_constructor;
 mod cast_lossless;
+mod cast_nan_to_int;
 mod cast_possible_truncation;
 mod cast_possible_wrap;
 mod cast_precision_loss;
@@ -570,6 +571,7 @@ declare_clippy_lint! {
     pedantic,
     "borrowing just to cast to a raw pointer"
 }
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for a raw slice being cast to a slice pointer
@@ -623,6 +625,28 @@ declare_clippy_lint! {
     "casting the result of the `&self`-taking `as_ptr` to a mutabe pointer"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for a known NaN float being cast to an integer
+    ///
+    /// ### Why is this bad?
+    /// NaNs are cast into zero, so one could simply use this and make the
+    /// code more readable. The lint could also hint at a programmer error.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// let _: (0.0_f32 / 0.0) as u64;
+    /// ```
+    /// Use instead:
+    /// ```rust,ignore
+    /// let _: = 0_u64;
+    /// ```
+    #[clippy::version = "1.64.0"]
+    pub CAST_NAN_TO_INT,
+    suspicious,
+    "casting a known floating-point NaN into an integer"
+}
+
 pub struct Casts {
     msrv: Option<RustcVersion>,
 }
@@ -656,6 +680,7 @@ impl_lint_pass!(Casts => [
     BORROW_AS_PTR,
     CAST_SLICE_FROM_RAW_PARTS,
     AS_PTR_CAST_MUT,
+    CAST_NAN_TO_INT,
 ]);
 
 impl<'tcx> LateLintPass<'tcx> for Casts {
@@ -693,6 +718,7 @@ impl<'tcx> LateLintPass<'tcx> for Casts {
                     cast_precision_loss::check(cx, expr, cast_from, cast_to);
                     cast_sign_loss::check(cx, expr, cast_expr, cast_from, cast_to);
                     cast_abs_to_unsigned::check(cx, expr, cast_expr, cast_from, cast_to, self.msrv);
+                    cast_nan_to_int::check(cx, expr, cast_expr, cast_from, cast_to);
                 }
                 cast_lossless::check(cx, expr, cast_expr, cast_from, cast_to, self.msrv);
                 cast_enum_constructor::check(cx, expr, cast_expr, cast_from);
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 758f9936064..a2f54c74d72 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -25,6 +25,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(casts::CAST_ABS_TO_UNSIGNED),
     LintId::of(casts::CAST_ENUM_CONSTRUCTOR),
     LintId::of(casts::CAST_ENUM_TRUNCATION),
+    LintId::of(casts::CAST_NAN_TO_INT),
     LintId::of(casts::CAST_REF_TO_MUT),
     LintId::of(casts::CAST_SLICE_DIFFERENT_SIZES),
     LintId::of(casts::CAST_SLICE_FROM_RAW_PARTS),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 546685c8175..de1253c8510 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -73,6 +73,7 @@ store.register_lints(&[
     casts::CAST_ENUM_CONSTRUCTOR,
     casts::CAST_ENUM_TRUNCATION,
     casts::CAST_LOSSLESS,
+    casts::CAST_NAN_TO_INT,
     casts::CAST_POSSIBLE_TRUNCATION,
     casts::CAST_POSSIBLE_WRAP,
     casts::CAST_PRECISION_LOSS,
diff --git a/clippy_lints/src/lib.register_suspicious.rs b/clippy_lints/src/lib.register_suspicious.rs
index 6125d0f7a86..ef5cc9ad7f9 100644
--- a/clippy_lints/src/lib.register_suspicious.rs
+++ b/clippy_lints/src/lib.register_suspicious.rs
@@ -11,6 +11,7 @@ store.register_group(true, "clippy::suspicious", Some("clippy_suspicious"), vec!
     LintId::of(casts::CAST_ABS_TO_UNSIGNED),
     LintId::of(casts::CAST_ENUM_CONSTRUCTOR),
     LintId::of(casts::CAST_ENUM_TRUNCATION),
+    LintId::of(casts::CAST_NAN_TO_INT),
     LintId::of(casts::CAST_SLICE_FROM_RAW_PARTS),
     LintId::of(crate_in_macro_def::CRATE_IN_MACRO_DEF),
     LintId::of(drop_forget_ref::DROP_NON_DROP),
diff --git a/src/docs.rs b/src/docs.rs
index 971d57ccb6f..41c31f91bca 100644
--- a/src/docs.rs
+++ b/src/docs.rs
@@ -61,6 +61,7 @@ docs! {
     "cast_enum_constructor",
     "cast_enum_truncation",
     "cast_lossless",
+    "cast_nan_to_int",
     "cast_possible_truncation",
     "cast_possible_wrap",
     "cast_precision_loss",
diff --git a/src/docs/cast_nan_to_int.txt b/src/docs/cast_nan_to_int.txt
new file mode 100644
index 00000000000..122f5da0c92
--- /dev/null
+++ b/src/docs/cast_nan_to_int.txt
@@ -0,0 +1,15 @@
+### What it does
+Checks for a known NaN float being cast to an integer
+
+### Why is this bad?
+NaNs are cast into zero, so one could simply use this and make the
+code more readable. The lint could also hint at a programmer error.
+
+### Example
+```
+let _: (0.0_f32 / 0.0) as u64;
+```
+Use instead:
+```
+let _: = 0_u64;
+```
\ No newline at end of file
diff --git a/tests/ui/cast_nan_to_int.rs b/tests/ui/cast_nan_to_int.rs
new file mode 100644
index 00000000000..287c5aa216b
--- /dev/null
+++ b/tests/ui/cast_nan_to_int.rs
@@ -0,0 +1,18 @@
+#![warn(clippy::cast_nan_to_int)]
+#![allow(clippy::eq_op)]
+
+fn main() {
+    let _ = (0.0_f32 / -0.0) as usize;
+    let _ = (f64::INFINITY * -0.0) as usize;
+    let _ = (0.0 * f32::INFINITY) as usize;
+
+    let _ = (f64::INFINITY + f64::NEG_INFINITY) as usize;
+    let _ = (f32::INFINITY - f32::INFINITY) as usize;
+    let _ = (f32::INFINITY / f32::NEG_INFINITY) as usize;
+
+    // those won't be linted:
+    let _ = (1.0_f32 / 0.0) as usize;
+    let _ = (f32::INFINITY * f32::NEG_INFINITY) as usize;
+    let _ = (f32::INFINITY - f32::NEG_INFINITY) as usize;
+    let _ = (f64::INFINITY - 0.0) as usize;
+}
diff --git a/tests/ui/cast_nan_to_int.stderr b/tests/ui/cast_nan_to_int.stderr
new file mode 100644
index 00000000000..3539be75a19
--- /dev/null
+++ b/tests/ui/cast_nan_to_int.stderr
@@ -0,0 +1,51 @@
+error: casting a known NaN to usize
+  --> $DIR/cast_nan_to_int.rs:5:13
+   |
+LL |     let _ = (0.0_f32 / -0.0) as usize;
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: this always evaluates to 0
+   = note: `-D clippy::cast-nan-to-int` implied by `-D warnings`
+
+error: casting a known NaN to usize
+  --> $DIR/cast_nan_to_int.rs:6:13
+   |
+LL |     let _ = (f64::INFINITY * -0.0) as usize;
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: this always evaluates to 0
+
+error: casting a known NaN to usize
+  --> $DIR/cast_nan_to_int.rs:7:13
+   |
+LL |     let _ = (0.0 * f32::INFINITY) as usize;
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: this always evaluates to 0
+
+error: casting a known NaN to usize
+  --> $DIR/cast_nan_to_int.rs:9:13
+   |
+LL |     let _ = (f64::INFINITY + f64::NEG_INFINITY) as usize;
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: this always evaluates to 0
+
+error: casting a known NaN to usize
+  --> $DIR/cast_nan_to_int.rs:10:13
+   |
+LL |     let _ = (f32::INFINITY - f32::INFINITY) as usize;
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: this always evaluates to 0
+
+error: casting a known NaN to usize
+  --> $DIR/cast_nan_to_int.rs:11:13
+   |
+LL |     let _ = (f32::INFINITY / f32::NEG_INFINITY) as usize;
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: this always evaluates to 0
+
+error: aborting due to 6 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 524ec2e12577d652875c68c3f205e8530451ba48 Mon Sep 17 00:00:00 2001
From: Samuel Moelius <sam@moeli.us>
Date: Tue, 11 Oct 2022 19:41:44 -0400
Subject: Fix bug in `referent_used_exactly_once`

---
 clippy_lints/src/dereference.rs | 8 ++++----
 clippy_utils/src/mir/mod.rs     | 3 +--
 2 files changed, 5 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index 45ee2fce4e4..82fc41d3a82 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -1194,16 +1194,16 @@ fn has_ref_mut_self_method(cx: &LateContext<'_>, trait_def_id: DefId) -> bool {
         })
 }
 
-fn referent_used_exactly_once<'a, 'tcx>(
-    cx: &'a LateContext<'tcx>,
+fn referent_used_exactly_once<'tcx>(
+    cx: &LateContext<'tcx>,
     possible_borrowers: &mut Vec<(LocalDefId, PossibleBorrowerMap<'tcx, 'tcx>)>,
     reference: &Expr<'tcx>,
 ) -> bool {
     let mir = enclosing_mir(cx.tcx, reference.hir_id);
     if let Some(local) = expr_local(cx.tcx, reference)
         && let [location] = *local_assignments(mir, local).as_slice()
-        && let StatementKind::Assign(box (_, Rvalue::Ref(_, _, place))) =
-            mir.basic_blocks[location.block].statements[location.statement_index].kind
+        && let Some(statement) = mir.basic_blocks[location.block].statements.get(location.statement_index)
+        && let StatementKind::Assign(box (_, Rvalue::Ref(_, _, place))) = statement.kind
         && !place.has_deref()
     {
         let body_owner_local_def_id = cx.tcx.hir().enclosing_body_owner(reference.hir_id);
diff --git a/clippy_utils/src/mir/mod.rs b/clippy_utils/src/mir/mod.rs
index c8aa6f3e595..818e603f665 100644
--- a/clippy_utils/src/mir/mod.rs
+++ b/clippy_utils/src/mir/mod.rs
@@ -121,8 +121,7 @@ pub fn expr_local(tcx: TyCtxt<'_>, expr: &Expr<'_>) -> Option<Local> {
     })
 }
 
-/// Returns a vector of `mir::Location` where `local` is assigned. Each statement referred to has
-/// kind `StatementKind::Assign`.
+/// Returns a vector of `mir::Location` where `local` is assigned.
 pub fn local_assignments(mir: &Body<'_>, local: Local) -> Vec<Location> {
     let mut locations = Vec::new();
     for (block, data) in mir.basic_blocks.iter_enumerated() {
-- 
cgit 1.4.1-3-g733a5


From e51e9308d58be45bffaf05c66af71681aaafd431 Mon Sep 17 00:00:00 2001
From: kraktus <kraktus@users.noreply.github.com>
Date: Wed, 12 Oct 2022 12:04:41 +0200
Subject: `default_numeric_fallback` do not lint on constants

---
 clippy_lints/src/default_numeric_fallback.rs | 27 ++++++++++++----------
 tests/ui/default_numeric_fallback_f64.fixed  |  9 ++++++++
 tests/ui/default_numeric_fallback_f64.rs     |  9 ++++++++
 tests/ui/default_numeric_fallback_f64.stderr | 34 ++++++++++++++++------------
 tests/ui/default_numeric_fallback_i32.fixed  | 10 ++++++++
 tests/ui/default_numeric_fallback_i32.rs     | 10 ++++++++
 tests/ui/default_numeric_fallback_i32.stderr | 34 ++++++++++++++++------------
 7 files changed, 93 insertions(+), 40 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/default_numeric_fallback.rs b/clippy_lints/src/default_numeric_fallback.rs
index 3ed9cd36a22..8b5c9d25dc8 100644
--- a/clippy_lints/src/default_numeric_fallback.rs
+++ b/clippy_lints/src/default_numeric_fallback.rs
@@ -1,12 +1,12 @@
 use clippy_utils::diagnostics::span_lint_hir_and_then;
-use clippy_utils::numeric_literal;
 use clippy_utils::source::snippet_opt;
+use clippy_utils::{get_parent_node, numeric_literal};
 use if_chain::if_chain;
 use rustc_ast::ast::{LitFloatType, LitIntType, LitKind};
 use rustc_errors::Applicability;
 use rustc_hir::{
     intravisit::{walk_expr, walk_stmt, Visitor},
-    Body, Expr, ExprKind, HirId, Lit, Stmt, StmtKind,
+    Body, Expr, ExprKind, HirId, ItemKind, Lit, Node, Stmt, StmtKind,
 };
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::{
@@ -55,7 +55,12 @@ declare_lint_pass!(DefaultNumericFallback => [DEFAULT_NUMERIC_FALLBACK]);
 
 impl<'tcx> LateLintPass<'tcx> for DefaultNumericFallback {
     fn check_body(&mut self, cx: &LateContext<'tcx>, body: &'tcx Body<'_>) {
-        let mut visitor = NumericFallbackVisitor::new(cx);
+        let is_parent_const = if let Some(Node::Item(item)) = get_parent_node(cx.tcx, body.id().hir_id) {
+            matches!(item.kind, ItemKind::Const(..))
+        } else {
+            false
+        };
+        let mut visitor = NumericFallbackVisitor::new(cx, is_parent_const);
         visitor.visit_body(body);
     }
 }
@@ -68,9 +73,13 @@ struct NumericFallbackVisitor<'a, 'tcx> {
 }
 
 impl<'a, 'tcx> NumericFallbackVisitor<'a, 'tcx> {
-    fn new(cx: &'a LateContext<'tcx>) -> Self {
+    fn new(cx: &'a LateContext<'tcx>, is_parent_const: bool) -> Self {
         Self {
-            ty_bounds: vec![TyBound::Nothing],
+            ty_bounds: vec![if is_parent_const {
+                TyBound::Any
+            } else {
+                TyBound::Nothing
+            }],
             cx,
         }
     }
@@ -192,13 +201,7 @@ impl<'a, 'tcx> Visitor<'tcx> for NumericFallbackVisitor<'a, 'tcx> {
 
     fn visit_stmt(&mut self, stmt: &'tcx Stmt<'_>) {
         match stmt.kind {
-            StmtKind::Local(local) => {
-                if local.ty.is_some() {
-                    self.ty_bounds.push(TyBound::Any);
-                } else {
-                    self.ty_bounds.push(TyBound::Nothing);
-                }
-            },
+            StmtKind::Local(local) if local.ty.is_some() => self.ty_bounds.push(TyBound::Any),
 
             _ => self.ty_bounds.push(TyBound::Nothing),
         }
diff --git a/tests/ui/default_numeric_fallback_f64.fixed b/tests/ui/default_numeric_fallback_f64.fixed
index a28bff76755..a370ccc7696 100644
--- a/tests/ui/default_numeric_fallback_f64.fixed
+++ b/tests/ui/default_numeric_fallback_f64.fixed
@@ -33,6 +33,7 @@ mod basic_expr {
         let x: [f64; 3] = [1., 2., 3.];
         let x: (f64, f64) = if true { (1., 2.) } else { (3., 4.) };
         let x: _ = 1.;
+        const X: f32 = 1.;
     }
 }
 
@@ -59,6 +60,14 @@ mod nested_local {
             // Should NOT lint this because this literal is bound to `_` of outer `Local`.
             2.
         };
+
+        const X: f32 = {
+            // Should lint this because this literal is not bound to any types.
+            let y = 1.0_f64;
+
+            // Should NOT lint this because this literal is bound to `_` of outer `Local`.
+            1.
+        };
     }
 }
 
diff --git a/tests/ui/default_numeric_fallback_f64.rs b/tests/ui/default_numeric_fallback_f64.rs
index b48435cc7b2..2476fe95141 100644
--- a/tests/ui/default_numeric_fallback_f64.rs
+++ b/tests/ui/default_numeric_fallback_f64.rs
@@ -33,6 +33,7 @@ mod basic_expr {
         let x: [f64; 3] = [1., 2., 3.];
         let x: (f64, f64) = if true { (1., 2.) } else { (3., 4.) };
         let x: _ = 1.;
+        const X: f32 = 1.;
     }
 }
 
@@ -59,6 +60,14 @@ mod nested_local {
             // Should NOT lint this because this literal is bound to `_` of outer `Local`.
             2.
         };
+
+        const X: f32 = {
+            // Should lint this because this literal is not bound to any types.
+            let y = 1.;
+
+            // Should NOT lint this because this literal is bound to `_` of outer `Local`.
+            1.
+        };
     }
 }
 
diff --git a/tests/ui/default_numeric_fallback_f64.stderr b/tests/ui/default_numeric_fallback_f64.stderr
index f8b6c7746ed..5df2f642388 100644
--- a/tests/ui/default_numeric_fallback_f64.stderr
+++ b/tests/ui/default_numeric_fallback_f64.stderr
@@ -61,79 +61,85 @@ LL |             _ => 1.,
    |                  ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_f64.rs:43:21
+  --> $DIR/default_numeric_fallback_f64.rs:44:21
    |
 LL |             let y = 1.;
    |                     ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_f64.rs:51:21
+  --> $DIR/default_numeric_fallback_f64.rs:52:21
    |
 LL |             let y = 1.;
    |                     ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_f64.rs:57:21
+  --> $DIR/default_numeric_fallback_f64.rs:58:21
    |
 LL |             let y = 1.;
    |                     ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_f64.rs:69:9
+  --> $DIR/default_numeric_fallback_f64.rs:66:21
+   |
+LL |             let y = 1.;
+   |                     ^^ help: consider adding suffix: `1.0_f64`
+
+error: default numeric fallback might occur
+  --> $DIR/default_numeric_fallback_f64.rs:78:9
    |
 LL |         1.
    |         ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_f64.rs:75:27
+  --> $DIR/default_numeric_fallback_f64.rs:84:27
    |
 LL |         let f = || -> _ { 1. };
    |                           ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_f64.rs:79:29
+  --> $DIR/default_numeric_fallback_f64.rs:88:29
    |
 LL |         let f = || -> f64 { 1. };
    |                             ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_f64.rs:93:21
+  --> $DIR/default_numeric_fallback_f64.rs:102:21
    |
 LL |         generic_arg(1.);
    |                     ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_f64.rs:96:32
+  --> $DIR/default_numeric_fallback_f64.rs:105:32
    |
 LL |         let x: _ = generic_arg(1.);
    |                                ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_f64.rs:114:28
+  --> $DIR/default_numeric_fallback_f64.rs:123:28
    |
 LL |         GenericStruct { x: 1. };
    |                            ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_f64.rs:117:36
+  --> $DIR/default_numeric_fallback_f64.rs:126:36
    |
 LL |         let _ = GenericStruct { x: 1. };
    |                                    ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_f64.rs:135:24
+  --> $DIR/default_numeric_fallback_f64.rs:144:24
    |
 LL |         GenericEnum::X(1.);
    |                        ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_f64.rs:155:23
+  --> $DIR/default_numeric_fallback_f64.rs:164:23
    |
 LL |         s.generic_arg(1.);
    |                       ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_f64.rs:162:21
+  --> $DIR/default_numeric_fallback_f64.rs:171:21
    |
 LL |             let x = 22.;
    |                     ^^^ help: consider adding suffix: `22.0_f64`
@@ -143,5 +149,5 @@ LL |         internal_macro!();
    |
    = note: this error originates in the macro `internal_macro` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to 23 previous errors
+error: aborting due to 24 previous errors
 
diff --git a/tests/ui/default_numeric_fallback_i32.fixed b/tests/ui/default_numeric_fallback_i32.fixed
index 55451cf2f7d..3f4994f0453 100644
--- a/tests/ui/default_numeric_fallback_i32.fixed
+++ b/tests/ui/default_numeric_fallback_i32.fixed
@@ -33,6 +33,8 @@ mod basic_expr {
         let x: [i32; 3] = [1, 2, 3];
         let x: (i32, i32) = if true { (1, 2) } else { (3, 4) };
         let x: _ = 1;
+        let x: u64 = 1;
+        const CONST_X: i8 = 1;
     }
 }
 
@@ -59,6 +61,14 @@ mod nested_local {
             // Should NOT lint this because this literal is bound to `_` of outer `Local`.
             2
         };
+
+        const CONST_X: i32 = {
+            // Should lint this because this literal is not bound to any types.
+            let y = 1_i32;
+
+            // Should NOT lint this because this literal is bound to `_` of outer `Local`.
+            1
+        };
     }
 }
 
diff --git a/tests/ui/default_numeric_fallback_i32.rs b/tests/ui/default_numeric_fallback_i32.rs
index 62d72f2feba..2df0e09787f 100644
--- a/tests/ui/default_numeric_fallback_i32.rs
+++ b/tests/ui/default_numeric_fallback_i32.rs
@@ -33,6 +33,8 @@ mod basic_expr {
         let x: [i32; 3] = [1, 2, 3];
         let x: (i32, i32) = if true { (1, 2) } else { (3, 4) };
         let x: _ = 1;
+        let x: u64 = 1;
+        const CONST_X: i8 = 1;
     }
 }
 
@@ -59,6 +61,14 @@ mod nested_local {
             // Should NOT lint this because this literal is bound to `_` of outer `Local`.
             2
         };
+
+        const CONST_X: i32 = {
+            // Should lint this because this literal is not bound to any types.
+            let y = 1;
+
+            // Should NOT lint this because this literal is bound to `_` of outer `Local`.
+            1
+        };
     }
 }
 
diff --git a/tests/ui/default_numeric_fallback_i32.stderr b/tests/ui/default_numeric_fallback_i32.stderr
index f7c5e724c40..6f219c3fc2b 100644
--- a/tests/ui/default_numeric_fallback_i32.stderr
+++ b/tests/ui/default_numeric_fallback_i32.stderr
@@ -73,79 +73,85 @@ LL |             _ => 2,
    |                  ^ help: consider adding suffix: `2_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:43:21
+  --> $DIR/default_numeric_fallback_i32.rs:45:21
    |
 LL |             let y = 1;
    |                     ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:51:21
+  --> $DIR/default_numeric_fallback_i32.rs:53:21
    |
 LL |             let y = 1;
    |                     ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:57:21
+  --> $DIR/default_numeric_fallback_i32.rs:59:21
    |
 LL |             let y = 1;
    |                     ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:69:9
+  --> $DIR/default_numeric_fallback_i32.rs:67:21
+   |
+LL |             let y = 1;
+   |                     ^ help: consider adding suffix: `1_i32`
+
+error: default numeric fallback might occur
+  --> $DIR/default_numeric_fallback_i32.rs:79:9
    |
 LL |         1
    |         ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:75:27
+  --> $DIR/default_numeric_fallback_i32.rs:85:27
    |
 LL |         let f = || -> _ { 1 };
    |                           ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:79:29
+  --> $DIR/default_numeric_fallback_i32.rs:89:29
    |
 LL |         let f = || -> i32 { 1 };
    |                             ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:93:21
+  --> $DIR/default_numeric_fallback_i32.rs:103:21
    |
 LL |         generic_arg(1);
    |                     ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:96:32
+  --> $DIR/default_numeric_fallback_i32.rs:106:32
    |
 LL |         let x: _ = generic_arg(1);
    |                                ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:114:28
+  --> $DIR/default_numeric_fallback_i32.rs:124:28
    |
 LL |         GenericStruct { x: 1 };
    |                            ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:117:36
+  --> $DIR/default_numeric_fallback_i32.rs:127:36
    |
 LL |         let _ = GenericStruct { x: 1 };
    |                                    ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:135:24
+  --> $DIR/default_numeric_fallback_i32.rs:145:24
    |
 LL |         GenericEnum::X(1);
    |                        ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:155:23
+  --> $DIR/default_numeric_fallback_i32.rs:165:23
    |
 LL |         s.generic_arg(1);
    |                       ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:162:21
+  --> $DIR/default_numeric_fallback_i32.rs:172:21
    |
 LL |             let x = 22;
    |                     ^^ help: consider adding suffix: `22_i32`
@@ -155,5 +161,5 @@ LL |         internal_macro!();
    |
    = note: this error originates in the macro `internal_macro` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to 25 previous errors
+error: aborting due to 26 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 36b2685977bdd731a0ef28e12bf8ef0334507d9e Mon Sep 17 00:00:00 2001
From: kraktus <kraktus@users.noreply.github.com>
Date: Wed, 12 Oct 2022 23:00:52 +0200
Subject: refactor `default_numeric_fallback`

We only need to store if the literal binding has an explicit type bound or not
---
 clippy_lints/src/default_numeric_fallback.rs | 45 +++++++++++-----------------
 1 file changed, 18 insertions(+), 27 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/default_numeric_fallback.rs b/clippy_lints/src/default_numeric_fallback.rs
index 8b5c9d25dc8..199f8e10e54 100644
--- a/clippy_lints/src/default_numeric_fallback.rs
+++ b/clippy_lints/src/default_numeric_fallback.rs
@@ -67,7 +67,7 @@ impl<'tcx> LateLintPass<'tcx> for DefaultNumericFallback {
 
 struct NumericFallbackVisitor<'a, 'tcx> {
     /// Stack manages type bound of exprs. The top element holds current expr type.
-    ty_bounds: Vec<TyBound<'tcx>>,
+    ty_bounds: Vec<ExplicitTyBound>,
 
     cx: &'a LateContext<'tcx>,
 }
@@ -76,9 +76,9 @@ impl<'a, 'tcx> NumericFallbackVisitor<'a, 'tcx> {
     fn new(cx: &'a LateContext<'tcx>, is_parent_const: bool) -> Self {
         Self {
             ty_bounds: vec![if is_parent_const {
-                TyBound::Any
+                ExplicitTyBound(true)
             } else {
-                TyBound::Nothing
+                ExplicitTyBound(false)
             }],
             cx,
         }
@@ -88,10 +88,10 @@ impl<'a, 'tcx> NumericFallbackVisitor<'a, 'tcx> {
     fn check_lit(&self, lit: &Lit, lit_ty: Ty<'tcx>, emit_hir_id: HirId) {
         if_chain! {
                 if !in_external_macro(self.cx.sess(), lit.span);
-                if let Some(ty_bound) = self.ty_bounds.last();
+                if let Some(explicit_ty_bounds) = self.ty_bounds.last();
                 if matches!(lit.node,
                             LitKind::Int(_, LitIntType::Unsuffixed) | LitKind::Float(_, LitFloatType::Unsuffixed));
-                if !ty_bound.is_numeric();
+                if !explicit_ty_bounds.0;
                 then {
                     let (suffix, is_float) = match lit_ty.kind() {
                         ty::Int(IntTy::I32) => ("i32", false),
@@ -132,7 +132,7 @@ impl<'a, 'tcx> Visitor<'tcx> for NumericFallbackVisitor<'a, 'tcx> {
                 if let Some(fn_sig) = fn_sig_opt(self.cx, func.hir_id) {
                     for (expr, bound) in iter::zip(*args, fn_sig.skip_binder().inputs()) {
                         // Push found arg type, then visit arg.
-                        self.ty_bounds.push(TyBound::Ty(*bound));
+                        self.ty_bounds.push((*bound).into());
                         self.visit_expr(expr);
                         self.ty_bounds.pop();
                     }
@@ -144,7 +144,7 @@ impl<'a, 'tcx> Visitor<'tcx> for NumericFallbackVisitor<'a, 'tcx> {
                 if let Some(def_id) = self.cx.typeck_results().type_dependent_def_id(expr.hir_id) {
                     let fn_sig = self.cx.tcx.fn_sig(def_id).skip_binder();
                     for (expr, bound) in iter::zip(std::iter::once(*receiver).chain(args.iter()), fn_sig.inputs()) {
-                        self.ty_bounds.push(TyBound::Ty(*bound));
+                        self.ty_bounds.push((*bound).into());
                         self.visit_expr(expr);
                         self.ty_bounds.pop();
                     }
@@ -178,7 +178,7 @@ impl<'a, 'tcx> Visitor<'tcx> for NumericFallbackVisitor<'a, 'tcx> {
 
                         // Visit base with no bound.
                         if let Some(base) = base {
-                            self.ty_bounds.push(TyBound::Nothing);
+                            self.ty_bounds.push(ExplicitTyBound(false));
                             self.visit_expr(base);
                             self.ty_bounds.pop();
                         }
@@ -201,9 +201,10 @@ impl<'a, 'tcx> Visitor<'tcx> for NumericFallbackVisitor<'a, 'tcx> {
 
     fn visit_stmt(&mut self, stmt: &'tcx Stmt<'_>) {
         match stmt.kind {
-            StmtKind::Local(local) if local.ty.is_some() => self.ty_bounds.push(TyBound::Any),
+            // we cannot check the exact type since it's a hir::Ty which does not implement `is_numeric`
+            StmtKind::Local(local) => self.ty_bounds.push(ExplicitTyBound(local.ty.is_some())),
 
-            _ => self.ty_bounds.push(TyBound::Nothing),
+            _ => self.ty_bounds.push(ExplicitTyBound(false)),
         }
 
         walk_stmt(self, stmt);
@@ -221,28 +222,18 @@ fn fn_sig_opt<'tcx>(cx: &LateContext<'tcx>, hir_id: HirId) -> Option<PolyFnSig<'
     }
 }
 
+/// Wrapper around a `bool` to make the meaning of the value clearer
 #[derive(Debug, Clone, Copy)]
-enum TyBound<'tcx> {
-    Any,
-    Ty(Ty<'tcx>),
-    Nothing,
-}
+struct ExplicitTyBound(pub bool);
 
-impl<'tcx> TyBound<'tcx> {
-    fn is_numeric(self) -> bool {
-        match self {
-            TyBound::Any => true,
-            TyBound::Ty(t) => t.is_numeric(),
-            TyBound::Nothing => false,
-        }
+impl<'tcx> From<Ty<'tcx>> for ExplicitTyBound {
+    fn from(v: Ty<'tcx>) -> Self {
+        Self(v.is_numeric())
     }
 }
 
-impl<'tcx> From<Option<Ty<'tcx>>> for TyBound<'tcx> {
+impl<'tcx> From<Option<Ty<'tcx>>> for ExplicitTyBound {
     fn from(v: Option<Ty<'tcx>>) -> Self {
-        match v {
-            Some(t) => TyBound::Ty(t),
-            None => TyBound::Nothing,
-        }
+        Self(v.map_or(false, Ty::is_numeric))
     }
 }
-- 
cgit 1.4.1-3-g733a5


From 771790404391b31c5c45a7e314703eff12226903 Mon Sep 17 00:00:00 2001
From: Yuri Astrakhan <YuriAstrakhan@gmail.com>
Date: Tue, 4 Oct 2022 00:07:12 -0400
Subject: Fix to_string_in_format_args in parens

Fix suggestions like

```
print!("error: something failed at {}", (Location::caller().to_string()));
```

where the parenthesis enclose some portion of the value.
---
 clippy_lints/src/format_args.rs |  4 +--
 tests/ui/format_args.fixed      |  3 +++
 tests/ui/format_args.rs         |  3 +++
 tests/ui/format_args.stderr     | 60 ++++++++++++++++++++++++-----------------
 4 files changed, 44 insertions(+), 26 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/format_args.rs b/clippy_lints/src/format_args.rs
index 88502b72618..0bb9f2902aa 100644
--- a/clippy_lints/src/format_args.rs
+++ b/clippy_lints/src/format_args.rs
@@ -250,7 +250,7 @@ fn check_format_in_format_args(cx: &LateContext<'_>, call_site: Span, name: Symb
 fn check_to_string_in_format_args(cx: &LateContext<'_>, name: Symbol, value: &Expr<'_>) {
     if_chain! {
         if !value.span.from_expansion();
-        if let ExprKind::MethodCall(_, receiver, [], _) = value.kind;
+        if let ExprKind::MethodCall(_, receiver, [], to_string_span) = value.kind;
         if let Some(method_def_id) = cx.typeck_results().type_dependent_def_id(value.hir_id);
         if is_diag_trait_item(cx, method_def_id, sym::ToString);
         let receiver_ty = cx.typeck_results().expr_ty(receiver);
@@ -266,7 +266,7 @@ fn check_to_string_in_format_args(cx: &LateContext<'_>, name: Symbol, value: &Ex
                 span_lint_and_sugg(
                     cx,
                     TO_STRING_IN_FORMAT_ARGS,
-                    value.span.with_lo(receiver.span.hi()),
+                    to_string_span.with_lo(receiver.span.hi()),
                     &format!(
                         "`to_string` applied to a type that implements `Display` in `{name}!` args"
                     ),
diff --git a/tests/ui/format_args.fixed b/tests/ui/format_args.fixed
index 24cf0847dd5..825e122be5a 100644
--- a/tests/ui/format_args.fixed
+++ b/tests/ui/format_args.fixed
@@ -3,6 +3,7 @@
 #![allow(unused)]
 #![allow(
     clippy::assertions_on_constants,
+    clippy::double_parens,
     clippy::eq_op,
     clippy::print_literal,
     clippy::uninlined_format_args
@@ -114,6 +115,8 @@ fn main() {
     println!("error: something failed at {}", my_other_macro!());
     // https://github.com/rust-lang/rust-clippy/issues/7903
     println!("{foo}{foo:?}", foo = "foo".to_string());
+    print!("{}", (Location::caller()));
+    print!("{}", ((Location::caller())));
 }
 
 fn issue8643(vendor_id: usize, product_id: usize, name: &str) {
diff --git a/tests/ui/format_args.rs b/tests/ui/format_args.rs
index 753babf0afd..a41e53389e5 100644
--- a/tests/ui/format_args.rs
+++ b/tests/ui/format_args.rs
@@ -3,6 +3,7 @@
 #![allow(unused)]
 #![allow(
     clippy::assertions_on_constants,
+    clippy::double_parens,
     clippy::eq_op,
     clippy::print_literal,
     clippy::uninlined_format_args
@@ -114,6 +115,8 @@ fn main() {
     println!("error: something failed at {}", my_other_macro!());
     // https://github.com/rust-lang/rust-clippy/issues/7903
     println!("{foo}{foo:?}", foo = "foo".to_string());
+    print!("{}", (Location::caller().to_string()));
+    print!("{}", ((Location::caller()).to_string()));
 }
 
 fn issue8643(vendor_id: usize, product_id: usize, name: &str) {
diff --git a/tests/ui/format_args.stderr b/tests/ui/format_args.stderr
index 68b0bb9e089..f1832b97019 100644
--- a/tests/ui/format_args.stderr
+++ b/tests/ui/format_args.stderr
@@ -1,5 +1,5 @@
 error: `to_string` applied to a type that implements `Display` in `format!` args
-  --> $DIR/format_args.rs:76:72
+  --> $DIR/format_args.rs:77:72
    |
 LL |     let _ = format!("error: something failed at {}", Location::caller().to_string());
    |                                                                        ^^^^^^^^^^^^ help: remove this
@@ -7,136 +7,148 @@ LL |     let _ = format!("error: something failed at {}", Location::caller().to_
    = note: `-D clippy::to-string-in-format-args` implied by `-D warnings`
 
 error: `to_string` applied to a type that implements `Display` in `write!` args
-  --> $DIR/format_args.rs:80:27
+  --> $DIR/format_args.rs:81:27
    |
 LL |         Location::caller().to_string()
    |                           ^^^^^^^^^^^^ help: remove this
 
 error: `to_string` applied to a type that implements `Display` in `writeln!` args
-  --> $DIR/format_args.rs:85:27
+  --> $DIR/format_args.rs:86:27
    |
 LL |         Location::caller().to_string()
    |                           ^^^^^^^^^^^^ help: remove this
 
 error: `to_string` applied to a type that implements `Display` in `print!` args
-  --> $DIR/format_args.rs:87:63
+  --> $DIR/format_args.rs:88:63
    |
 LL |     print!("error: something failed at {}", Location::caller().to_string());
    |                                                               ^^^^^^^^^^^^ help: remove this
 
 error: `to_string` applied to a type that implements `Display` in `println!` args
-  --> $DIR/format_args.rs:88:65
+  --> $DIR/format_args.rs:89:65
    |
 LL |     println!("error: something failed at {}", Location::caller().to_string());
    |                                                                 ^^^^^^^^^^^^ help: remove this
 
 error: `to_string` applied to a type that implements `Display` in `eprint!` args
-  --> $DIR/format_args.rs:89:64
+  --> $DIR/format_args.rs:90:64
    |
 LL |     eprint!("error: something failed at {}", Location::caller().to_string());
    |                                                                ^^^^^^^^^^^^ help: remove this
 
 error: `to_string` applied to a type that implements `Display` in `eprintln!` args
-  --> $DIR/format_args.rs:90:66
+  --> $DIR/format_args.rs:91:66
    |
 LL |     eprintln!("error: something failed at {}", Location::caller().to_string());
    |                                                                  ^^^^^^^^^^^^ help: remove this
 
 error: `to_string` applied to a type that implements `Display` in `format_args!` args
-  --> $DIR/format_args.rs:91:77
+  --> $DIR/format_args.rs:92:77
    |
 LL |     let _ = format_args!("error: something failed at {}", Location::caller().to_string());
    |                                                                             ^^^^^^^^^^^^ help: remove this
 
 error: `to_string` applied to a type that implements `Display` in `assert!` args
-  --> $DIR/format_args.rs:92:70
+  --> $DIR/format_args.rs:93:70
    |
 LL |     assert!(true, "error: something failed at {}", Location::caller().to_string());
    |                                                                      ^^^^^^^^^^^^ help: remove this
 
 error: `to_string` applied to a type that implements `Display` in `assert_eq!` args
-  --> $DIR/format_args.rs:93:73
+  --> $DIR/format_args.rs:94:73
    |
 LL |     assert_eq!(0, 0, "error: something failed at {}", Location::caller().to_string());
    |                                                                         ^^^^^^^^^^^^ help: remove this
 
 error: `to_string` applied to a type that implements `Display` in `assert_ne!` args
-  --> $DIR/format_args.rs:94:73
+  --> $DIR/format_args.rs:95:73
    |
 LL |     assert_ne!(0, 0, "error: something failed at {}", Location::caller().to_string());
    |                                                                         ^^^^^^^^^^^^ help: remove this
 
 error: `to_string` applied to a type that implements `Display` in `panic!` args
-  --> $DIR/format_args.rs:95:63
+  --> $DIR/format_args.rs:96:63
    |
 LL |     panic!("error: something failed at {}", Location::caller().to_string());
    |                                                               ^^^^^^^^^^^^ help: remove this
 
 error: `to_string` applied to a type that implements `Display` in `println!` args
-  --> $DIR/format_args.rs:96:20
+  --> $DIR/format_args.rs:97:20
    |
 LL |     println!("{}", X(1).to_string());
    |                    ^^^^^^^^^^^^^^^^ help: use this: `*X(1)`
 
 error: `to_string` applied to a type that implements `Display` in `println!` args
-  --> $DIR/format_args.rs:97:20
+  --> $DIR/format_args.rs:98:20
    |
 LL |     println!("{}", Y(&X(1)).to_string());
    |                    ^^^^^^^^^^^^^^^^^^^^ help: use this: `***Y(&X(1))`
 
 error: `to_string` applied to a type that implements `Display` in `println!` args
-  --> $DIR/format_args.rs:98:24
+  --> $DIR/format_args.rs:99:24
    |
 LL |     println!("{}", Z(1).to_string());
    |                        ^^^^^^^^^^^^ help: remove this
 
 error: `to_string` applied to a type that implements `Display` in `println!` args
-  --> $DIR/format_args.rs:99:20
+  --> $DIR/format_args.rs:100:20
    |
 LL |     println!("{}", x.to_string());
    |                    ^^^^^^^^^^^^^ help: use this: `**x`
 
 error: `to_string` applied to a type that implements `Display` in `println!` args
-  --> $DIR/format_args.rs:100:20
+  --> $DIR/format_args.rs:101:20
    |
 LL |     println!("{}", x_ref.to_string());
    |                    ^^^^^^^^^^^^^^^^^ help: use this: `***x_ref`
 
 error: `to_string` applied to a type that implements `Display` in `println!` args
-  --> $DIR/format_args.rs:102:39
+  --> $DIR/format_args.rs:103:39
    |
 LL |     println!("{foo}{bar}", foo = "foo".to_string(), bar = "bar");
    |                                       ^^^^^^^^^^^^ help: remove this
 
 error: `to_string` applied to a type that implements `Display` in `println!` args
-  --> $DIR/format_args.rs:103:52
+  --> $DIR/format_args.rs:104:52
    |
 LL |     println!("{foo}{bar}", foo = "foo", bar = "bar".to_string());
    |                                                    ^^^^^^^^^^^^ help: remove this
 
 error: `to_string` applied to a type that implements `Display` in `println!` args
-  --> $DIR/format_args.rs:104:39
+  --> $DIR/format_args.rs:105:39
    |
 LL |     println!("{foo}{bar}", bar = "bar".to_string(), foo = "foo");
    |                                       ^^^^^^^^^^^^ help: remove this
 
 error: `to_string` applied to a type that implements `Display` in `println!` args
-  --> $DIR/format_args.rs:105:52
+  --> $DIR/format_args.rs:106:52
    |
 LL |     println!("{foo}{bar}", bar = "bar", foo = "foo".to_string());
    |                                                    ^^^^^^^^^^^^ help: remove this
 
+error: `to_string` applied to a type that implements `Display` in `print!` args
+  --> $DIR/format_args.rs:118:37
+   |
+LL |     print!("{}", (Location::caller().to_string()));
+   |                                     ^^^^^^^^^^^^ help: remove this
+
+error: `to_string` applied to a type that implements `Display` in `print!` args
+  --> $DIR/format_args.rs:119:39
+   |
+LL |     print!("{}", ((Location::caller()).to_string()));
+   |                                       ^^^^^^^^^^^^ help: remove this
+
 error: `to_string` applied to a type that implements `Display` in `format!` args
-  --> $DIR/format_args.rs:144:38
+  --> $DIR/format_args.rs:147:38
    |
 LL |         let x = format!("{} {}", a, b.to_string());
    |                                      ^^^^^^^^^^^^ help: remove this
 
 error: `to_string` applied to a type that implements `Display` in `println!` args
-  --> $DIR/format_args.rs:158:24
+  --> $DIR/format_args.rs:161:24
    |
 LL |         println!("{}", original[..10].to_string());
    |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use this: `&original[..10]`
 
-error: aborting due to 23 previous errors
+error: aborting due to 25 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 344b7bca860ff9559b60d54350312e4ac1e88481 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Fri, 14 Oct 2022 13:21:59 -0400
Subject: Don't lint `ptr_arg` when used as an incompatible trait object

---
 clippy_lints/src/ptr.rs | 46 +++++++++++++++++++++++++++++++++++++++++++++-
 tests/ui/ptr_arg.rs     | 30 +++++++++++++++++++++++++++++-
 tests/ui/ptr_arg.stderr | 20 +++++++++++++++++++-
 3 files changed, 93 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs
index 2d80236327a..b589ac4a122 100644
--- a/clippy_lints/src/ptr.rs
+++ b/clippy_lints/src/ptr.rs
@@ -15,13 +15,17 @@ use rustc_hir::{
     ImplItemKind, ItemKind, Lifetime, LifetimeName, Mutability, Node, Param, ParamName, PatKind, QPath, TraitFn,
     TraitItem, TraitItemKind, TyKind, Unsafety,
 };
+use rustc_infer::infer::TyCtxtInferExt;
+use rustc_infer::traits::{Obligation, ObligationCause};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::nested_filter;
-use rustc_middle::ty::{self, Ty};
+use rustc_middle::ty::{self, Binder, ExistentialPredicate, List, PredicateKind, Ty};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
 use rustc_span::sym;
 use rustc_span::symbol::Symbol;
+use rustc_trait_selection::infer::InferCtxtExt as _;
+use rustc_trait_selection::traits::query::evaluate_obligation::InferCtxtExt as _;
 use std::fmt;
 use std::iter;
 
@@ -384,6 +388,17 @@ enum DerefTy<'tcx> {
     Slice(Option<Span>, Ty<'tcx>),
 }
 impl<'tcx> DerefTy<'tcx> {
+    fn ty(&self, cx: &LateContext<'tcx>) -> Ty<'tcx> {
+        match *self {
+            Self::Str => cx.tcx.types.str_,
+            Self::Path => cx.tcx.mk_adt(
+                cx.tcx.adt_def(cx.tcx.get_diagnostic_item(sym::Path).unwrap()),
+                List::empty(),
+            ),
+            Self::Slice(_, ty) => cx.tcx.mk_slice(ty),
+        }
+    }
+
     fn argless_str(&self) -> &'static str {
         match *self {
             Self::Str => "str",
@@ -581,6 +596,7 @@ fn check_ptr_arg_usage<'tcx>(cx: &LateContext<'tcx>, body: &'tcx Body<'_>, args:
                         let i = expr_args.iter().position(|arg| arg.hir_id == child_id).unwrap_or(0);
                         if expr_sig(self.cx, f).and_then(|sig| sig.input(i)).map_or(true, |ty| {
                             match *ty.skip_binder().peel_refs().kind() {
+                                ty::Dynamic(preds, _, _) => !matches_preds(self.cx, args.deref_ty.ty(self.cx), preds),
                                 ty::Param(_) => true,
                                 ty::Adt(def, _) => def.did() == args.ty_did,
                                 _ => false,
@@ -614,6 +630,9 @@ fn check_ptr_arg_usage<'tcx>(cx: &LateContext<'tcx>, body: &'tcx Body<'_>, args:
                         };
 
                         match *self.cx.tcx.fn_sig(id).skip_binder().inputs()[i].peel_refs().kind() {
+                            ty::Dynamic(preds, _, _) if !matches_preds(self.cx, args.deref_ty.ty(self.cx), preds) => {
+                                set_skip_flag();
+                            },
                             ty::Param(_) => {
                                 set_skip_flag();
                             },
@@ -665,6 +684,31 @@ fn check_ptr_arg_usage<'tcx>(cx: &LateContext<'tcx>, body: &'tcx Body<'_>, args:
     v.results
 }
 
+fn matches_preds<'tcx>(
+    cx: &LateContext<'tcx>,
+    ty: Ty<'tcx>,
+    preds: &'tcx [Binder<'tcx, ExistentialPredicate<'tcx>>],
+) -> bool {
+    cx.tcx.infer_ctxt().enter(|infcx| {
+        preds.iter().all(|&p| match cx.tcx.erase_late_bound_regions(p) {
+            ExistentialPredicate::Trait(p) => infcx
+                .type_implements_trait(p.def_id, ty, p.substs, cx.param_env)
+                .must_apply_modulo_regions(),
+            ExistentialPredicate::Projection(p) => infcx.predicate_must_hold_modulo_regions(&Obligation::new(
+                ObligationCause::dummy(),
+                cx.param_env,
+                cx.tcx.mk_predicate(Binder::bind_with_vars(
+                    PredicateKind::Projection(p.with_self_ty(cx.tcx, ty)),
+                    List::empty(),
+                )),
+            )),
+            ExistentialPredicate::AutoTrait(p) => infcx
+                .type_implements_trait(p, ty, List::empty(), cx.param_env)
+                .must_apply_modulo_regions(),
+        })
+    })
+}
+
 fn get_rptr_lm<'tcx>(ty: &'tcx hir::Ty<'tcx>) -> Option<(&'tcx Lifetime, Mutability, Span)> {
     if let TyKind::Rptr(lt, ref m) = ty.kind {
         Some((lt, m.mutbl, ty.span))
diff --git a/tests/ui/ptr_arg.rs b/tests/ui/ptr_arg.rs
index fd15001e540..5f54101ca15 100644
--- a/tests/ui/ptr_arg.rs
+++ b/tests/ui/ptr_arg.rs
@@ -3,7 +3,7 @@
 #![warn(clippy::ptr_arg)]
 
 use std::borrow::Cow;
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 
 fn do_vec(x: &Vec<i64>) {
     //Nothing here
@@ -207,3 +207,31 @@ fn cow_conditional_to_mut(a: &mut Cow<str>) {
         a.to_mut().push_str("foo");
     }
 }
+
+// Issue #9542
+fn dyn_trait_ok(a: &mut Vec<u32>, b: &mut String, c: &mut PathBuf) {
+    trait T {}
+    impl<U> T for Vec<U> {}
+    impl T for String {}
+    impl T for PathBuf {}
+    fn takes_dyn(_: &mut dyn T) {}
+
+    takes_dyn(a);
+    takes_dyn(b);
+    takes_dyn(c);
+}
+
+fn dyn_trait(a: &mut Vec<u32>, b: &mut String, c: &mut PathBuf) {
+    trait T {}
+    impl<U> T for Vec<U> {}
+    impl<U> T for [U] {}
+    impl T for String {}
+    impl T for str {}
+    impl T for PathBuf {}
+    impl T for Path {}
+    fn takes_dyn(_: &mut dyn T) {}
+
+    takes_dyn(a);
+    takes_dyn(b);
+    takes_dyn(c);
+}
diff --git a/tests/ui/ptr_arg.stderr b/tests/ui/ptr_arg.stderr
index d64b5f454a5..6b4de98ce88 100644
--- a/tests/ui/ptr_arg.stderr
+++ b/tests/ui/ptr_arg.stderr
@@ -162,5 +162,23 @@ error: writing `&mut Vec` instead of `&mut [_]` involves a new object where a sl
 LL | fn mut_vec_slice_methods(v: &mut Vec<u32>) {
    |                             ^^^^^^^^^^^^^ help: change this to: `&mut [u32]`
 
-error: aborting due to 17 previous errors
+error: writing `&mut Vec` instead of `&mut [_]` involves a new object where a slice will do
+  --> $DIR/ptr_arg.rs:224:17
+   |
+LL | fn dyn_trait(a: &mut Vec<u32>, b: &mut String, c: &mut PathBuf) {
+   |                 ^^^^^^^^^^^^^ help: change this to: `&mut [u32]`
+
+error: writing `&mut String` instead of `&mut str` involves a new object where a slice will do
+  --> $DIR/ptr_arg.rs:224:35
+   |
+LL | fn dyn_trait(a: &mut Vec<u32>, b: &mut String, c: &mut PathBuf) {
+   |                                   ^^^^^^^^^^^ help: change this to: `&mut str`
+
+error: writing `&mut PathBuf` instead of `&mut Path` involves a new object where a slice will do
+  --> $DIR/ptr_arg.rs:224:51
+   |
+LL | fn dyn_trait(a: &mut Vec<u32>, b: &mut String, c: &mut PathBuf) {
+   |                                                   ^^^^^^^^^^^^ help: change this to: `&mut Path`
+
+error: aborting due to 20 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 4b8df8dc92c9e29ded57e1efa4d11d641e4b0ba7 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Fri, 14 Oct 2022 22:50:23 +0000
Subject: Add a suggestion and a note about orphan rules for `from_over_into`

---
 clippy_lints/src/from_over_into.rs       | 176 +++++++++++++++++++++++++++----
 tests/ui/from_over_into.fixed            |  62 +++++++++++
 tests/ui/from_over_into.rs               |  41 +++++++
 tests/ui/from_over_into.stderr           |  57 +++++++++-
 tests/ui/from_over_into_unfixable.rs     |  35 ++++++
 tests/ui/from_over_into_unfixable.stderr |  29 +++++
 6 files changed, 375 insertions(+), 25 deletions(-)
 create mode 100644 tests/ui/from_over_into.fixed
 create mode 100644 tests/ui/from_over_into_unfixable.rs
 create mode 100644 tests/ui/from_over_into_unfixable.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/from_over_into.rs b/clippy_lints/src/from_over_into.rs
index 5d25c1d0634..95eda4ea882 100644
--- a/clippy_lints/src/from_over_into.rs
+++ b/clippy_lints/src/from_over_into.rs
@@ -1,11 +1,19 @@
-use clippy_utils::diagnostics::span_lint_and_help;
-use clippy_utils::{meets_msrv, msrvs};
-use if_chain::if_chain;
-use rustc_hir as hir;
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::macros::span_is_local;
+use clippy_utils::source::snippet_opt;
+use clippy_utils::{meets_msrv, msrvs, path_def_id};
+use rustc_errors::Applicability;
+use rustc_hir::intravisit::{walk_path, Visitor};
+use rustc_hir::{
+    GenericArg, GenericArgs, HirId, Impl, ImplItemKind, ImplItemRef, Item, ItemKind, PatKind, Path, PathSegment, Ty,
+    TyKind,
+};
 use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::hir::nested_filter::OnlyBodies;
 use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::symbol::sym;
+use rustc_span::symbol::{kw, sym};
+use rustc_span::{Span, Symbol};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -54,28 +62,152 @@ impl FromOverInto {
 impl_lint_pass!(FromOverInto => [FROM_OVER_INTO]);
 
 impl<'tcx> LateLintPass<'tcx> for FromOverInto {
-    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) {
-        if !meets_msrv(self.msrv, msrvs::RE_REBALANCING_COHERENCE) {
+    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
+        if !meets_msrv(self.msrv, msrvs::RE_REBALANCING_COHERENCE) || !span_is_local(item.span) {
             return;
         }
 
-        if_chain! {
-            if let hir::ItemKind::Impl{ .. } = &item.kind;
-            if let Some(impl_trait_ref) = cx.tcx.impl_trait_ref(item.def_id);
-            if cx.tcx.is_diagnostic_item(sym::Into, impl_trait_ref.def_id);
-
-            then {
-                span_lint_and_help(
-                    cx,
-                    FROM_OVER_INTO,
-                    cx.tcx.sess.source_map().guess_head_span(item.span),
-                    "an implementation of `From` is preferred since it gives you `Into<_>` for free where the reverse isn't true",
-                    None,
-                    &format!("consider to implement `From<{}>` instead", impl_trait_ref.self_ty()),
-                );
-            }
+        if let ItemKind::Impl(Impl {
+            of_trait: Some(hir_trait_ref),
+            self_ty,
+            items: [impl_item_ref],
+            ..
+        }) = item.kind
+            && let Some(into_trait_seg) = hir_trait_ref.path.segments.last()
+            // `impl Into<target_ty> for self_ty`
+            && let Some(GenericArgs { args: [GenericArg::Type(target_ty)], .. }) = into_trait_seg.args
+            && let Some(middle_trait_ref) = cx.tcx.impl_trait_ref(item.def_id)
+            && cx.tcx.is_diagnostic_item(sym::Into, middle_trait_ref.def_id)
+        {
+            span_lint_and_then(
+                cx,
+                FROM_OVER_INTO,
+                cx.tcx.sess.source_map().guess_head_span(item.span),
+                "an implementation of `From` is preferred since it gives you `Into<_>` for free where the reverse isn't true",
+                |diag| {
+                    // If the target type is likely foreign mention the orphan rules as it's a common source of confusion
+                    if path_def_id(cx, target_ty.peel_refs()).map_or(true, |id| !id.is_local()) {
+                        diag.help(
+                            "`impl From<Local> for Foreign` is allowed by the orphan rules, for more information see\n\
+                            https://doc.rust-lang.org/reference/items/implementations.html#trait-implementation-coherence"
+                        );
+                    }
+
+                    let message = format!("replace the `Into` implentation with `From<{}>`", middle_trait_ref.self_ty());
+                    if let Some(suggestions) = convert_to_from(cx, into_trait_seg, target_ty, self_ty, impl_item_ref) {
+                        diag.multipart_suggestion(message, suggestions, Applicability::MachineApplicable);
+                    } else {
+                        diag.help(message);
+                    }
+                },
+            );
         }
     }
 
     extract_msrv_attr!(LateContext);
 }
+
+/// Finds the occurences of `Self` and `self`
+struct SelfFinder<'a, 'tcx> {
+    cx: &'a LateContext<'tcx>,
+    /// Occurences of `Self`
+    upper: Vec<Span>,
+    /// Occurences of `self`
+    lower: Vec<Span>,
+    /// If any of the `self`/`Self` usages were from an expansion, or the body contained a binding
+    /// already named `val`
+    invalid: bool,
+}
+
+impl<'a, 'tcx> Visitor<'tcx> for SelfFinder<'a, 'tcx> {
+    type NestedFilter = OnlyBodies;
+
+    fn nested_visit_map(&mut self) -> Self::Map {
+        self.cx.tcx.hir()
+    }
+
+    fn visit_path(&mut self, path: &'tcx Path<'tcx>, _id: HirId) {
+        for segment in path.segments {
+            match segment.ident.name {
+                kw::SelfLower => self.lower.push(segment.ident.span),
+                kw::SelfUpper => self.upper.push(segment.ident.span),
+                _ => continue,
+            }
+        }
+
+        self.invalid |= path.span.from_expansion();
+        if !self.invalid {
+            walk_path(self, path);
+        }
+    }
+
+    fn visit_name(&mut self, name: Symbol) {
+        if name == sym::val {
+            self.invalid = true;
+        }
+    }
+}
+
+fn convert_to_from(
+    cx: &LateContext<'_>,
+    into_trait_seg: &PathSegment<'_>,
+    target_ty: &Ty<'_>,
+    self_ty: &Ty<'_>,
+    impl_item_ref: &ImplItemRef,
+) -> Option<Vec<(Span, String)>> {
+    let impl_item = cx.tcx.hir().impl_item(impl_item_ref.id);
+    let ImplItemKind::Fn(ref sig, body_id) = impl_item.kind else { return None };
+    let body = cx.tcx.hir().body(body_id);
+    let [input] = body.params else { return None };
+    let PatKind::Binding(.., self_ident, None) = input.pat.kind else { return None };
+
+    let from = snippet_opt(cx, self_ty.span)?;
+    let into = snippet_opt(cx, target_ty.span)?;
+
+    let mut suggestions = vec![
+        // impl Into<T> for U  ->  impl From<T> for U
+        //      ~~~~                    ~~~~
+        (into_trait_seg.ident.span, String::from("From")),
+        // impl Into<T> for U  ->  impl Into<U> for U
+        //           ~                       ~
+        (target_ty.span, from.clone()),
+        // impl Into<T> for U  ->  impl Into<T> for T
+        //                  ~                       ~
+        (self_ty.span, into),
+        // fn into(self) -> T  ->  fn from(self) -> T
+        //    ~~~~                    ~~~~
+        (impl_item.ident.span, String::from("from")),
+        // fn into([mut] self) -> T  ->  fn into([mut] v: T) -> T
+        //               ~~~~                          ~~~~
+        (self_ident.span, format!("val: {from}")),
+        // fn into(self) -> T  ->  fn into(self) -> Self
+        //                  ~                       ~~~~
+        (sig.decl.output.span(), String::from("Self")),
+    ];
+
+    let mut finder = SelfFinder {
+        cx,
+        upper: Vec::new(),
+        lower: Vec::new(),
+        invalid: false,
+    };
+    finder.visit_expr(body.value);
+
+    if finder.invalid {
+        return None;
+    }
+
+    // don't try to replace e.g. `Self::default()` with `&[T]::default()`
+    if !finder.upper.is_empty() && !matches!(self_ty.kind, TyKind::Path(_)) {
+        return None;
+    }
+
+    for span in finder.upper {
+        suggestions.push((span, from.clone()));
+    }
+    for span in finder.lower {
+        suggestions.push((span, String::from("val")));
+    }
+
+    Some(suggestions)
+}
diff --git a/tests/ui/from_over_into.fixed b/tests/ui/from_over_into.fixed
new file mode 100644
index 00000000000..e66dc43b047
--- /dev/null
+++ b/tests/ui/from_over_into.fixed
@@ -0,0 +1,62 @@
+// run-rustfix
+
+#![warn(clippy::from_over_into)]
+#![allow(unused)]
+
+// this should throw an error
+struct StringWrapper(String);
+
+impl From<String> for StringWrapper {
+    fn from(val: String) -> Self {
+        StringWrapper(val)
+    }
+}
+
+struct SelfType(String);
+
+impl From<String> for SelfType {
+    fn from(val: String) -> Self {
+        SelfType(String::new())
+    }
+}
+
+#[derive(Default)]
+struct X;
+
+impl X {
+    const FOO: &'static str = "a";
+}
+
+struct SelfKeywords;
+
+impl From<X> for SelfKeywords {
+    fn from(val: X) -> Self {
+        let _ = X::default();
+        let _ = X::FOO;
+        let _: X = val;
+
+        SelfKeywords
+    }
+}
+
+struct ExplicitPaths(bool);
+
+impl core::convert::From<crate::ExplicitPaths> for bool {
+    fn from(mut val: crate::ExplicitPaths) -> Self {
+        let in_closure = || val.0;
+
+        val.0 = false;
+        val.0
+    }
+}
+
+// this is fine
+struct A(String);
+
+impl From<String> for A {
+    fn from(s: String) -> A {
+        A(s)
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/from_over_into.rs b/tests/ui/from_over_into.rs
index 292d0924fb1..74c7be6af79 100644
--- a/tests/ui/from_over_into.rs
+++ b/tests/ui/from_over_into.rs
@@ -1,4 +1,7 @@
+// run-rustfix
+
 #![warn(clippy::from_over_into)]
+#![allow(unused)]
 
 // this should throw an error
 struct StringWrapper(String);
@@ -9,6 +12,44 @@ impl Into<StringWrapper> for String {
     }
 }
 
+struct SelfType(String);
+
+impl Into<SelfType> for String {
+    fn into(self) -> SelfType {
+        SelfType(Self::new())
+    }
+}
+
+#[derive(Default)]
+struct X;
+
+impl X {
+    const FOO: &'static str = "a";
+}
+
+struct SelfKeywords;
+
+impl Into<SelfKeywords> for X {
+    fn into(self) -> SelfKeywords {
+        let _ = Self::default();
+        let _ = Self::FOO;
+        let _: Self = self;
+
+        SelfKeywords
+    }
+}
+
+struct ExplicitPaths(bool);
+
+impl core::convert::Into<bool> for crate::ExplicitPaths {
+    fn into(mut self) -> bool {
+        let in_closure = || self.0;
+
+        self.0 = false;
+        self.0
+    }
+}
+
 // this is fine
 struct A(String);
 
diff --git a/tests/ui/from_over_into.stderr b/tests/ui/from_over_into.stderr
index 469adadd219..6cf83e25807 100644
--- a/tests/ui/from_over_into.stderr
+++ b/tests/ui/from_over_into.stderr
@@ -1,11 +1,62 @@
 error: an implementation of `From` is preferred since it gives you `Into<_>` for free where the reverse isn't true
-  --> $DIR/from_over_into.rs:6:1
+  --> $DIR/from_over_into.rs:9:1
    |
 LL | impl Into<StringWrapper> for String {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: consider to implement `From<std::string::String>` instead
    = note: `-D clippy::from-over-into` implied by `-D warnings`
+help: replace the `Into` implentation with `From<std::string::String>`
+   |
+LL ~ impl From<String> for StringWrapper {
+LL ~     fn from(val: String) -> Self {
+LL ~         StringWrapper(val)
+   |
+
+error: an implementation of `From` is preferred since it gives you `Into<_>` for free where the reverse isn't true
+  --> $DIR/from_over_into.rs:17:1
+   |
+LL | impl Into<SelfType> for String {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: replace the `Into` implentation with `From<std::string::String>`
+   |
+LL ~ impl From<String> for SelfType {
+LL ~     fn from(val: String) -> Self {
+LL ~         SelfType(String::new())
+   |
+
+error: an implementation of `From` is preferred since it gives you `Into<_>` for free where the reverse isn't true
+  --> $DIR/from_over_into.rs:32:1
+   |
+LL | impl Into<SelfKeywords> for X {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: replace the `Into` implentation with `From<X>`
+   |
+LL ~ impl From<X> for SelfKeywords {
+LL ~     fn from(val: X) -> Self {
+LL ~         let _ = X::default();
+LL ~         let _ = X::FOO;
+LL ~         let _: X = val;
+   |
+
+error: an implementation of `From` is preferred since it gives you `Into<_>` for free where the reverse isn't true
+  --> $DIR/from_over_into.rs:44:1
+   |
+LL | impl core::convert::Into<bool> for crate::ExplicitPaths {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: `impl From<Local> for Foreign` is allowed by the orphan rules, for more information see
+           https://doc.rust-lang.org/reference/items/implementations.html#trait-implementation-coherence
+help: replace the `Into` implentation with `From<ExplicitPaths>`
+   |
+LL ~ impl core::convert::From<crate::ExplicitPaths> for bool {
+LL ~     fn from(mut val: crate::ExplicitPaths) -> Self {
+LL ~         let in_closure = || val.0;
+LL | 
+LL ~         val.0 = false;
+LL ~         val.0
+   |
 
-error: aborting due to previous error
+error: aborting due to 4 previous errors
 
diff --git a/tests/ui/from_over_into_unfixable.rs b/tests/ui/from_over_into_unfixable.rs
new file mode 100644
index 00000000000..3b280b7488a
--- /dev/null
+++ b/tests/ui/from_over_into_unfixable.rs
@@ -0,0 +1,35 @@
+#![warn(clippy::from_over_into)]
+
+struct InMacro(String);
+
+macro_rules! in_macro {
+    ($e:ident) => {
+        $e
+    };
+}
+
+impl Into<InMacro> for String {
+    fn into(self) -> InMacro {
+        InMacro(in_macro!(self))
+    }
+}
+
+struct WeirdUpperSelf;
+
+impl Into<WeirdUpperSelf> for &'static [u8] {
+    fn into(self) -> WeirdUpperSelf {
+        let _ = Self::default();
+        WeirdUpperSelf
+    }
+}
+
+struct ContainsVal;
+
+impl Into<u8> for ContainsVal {
+    fn into(self) -> u8 {
+        let val = 1;
+        val + 1
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/from_over_into_unfixable.stderr b/tests/ui/from_over_into_unfixable.stderr
new file mode 100644
index 00000000000..6f6ce351921
--- /dev/null
+++ b/tests/ui/from_over_into_unfixable.stderr
@@ -0,0 +1,29 @@
+error: an implementation of `From` is preferred since it gives you `Into<_>` for free where the reverse isn't true
+  --> $DIR/from_over_into_unfixable.rs:11:1
+   |
+LL | impl Into<InMacro> for String {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: replace the `Into` implentation with `From<std::string::String>`
+   = note: `-D clippy::from-over-into` implied by `-D warnings`
+
+error: an implementation of `From` is preferred since it gives you `Into<_>` for free where the reverse isn't true
+  --> $DIR/from_over_into_unfixable.rs:19:1
+   |
+LL | impl Into<WeirdUpperSelf> for &'static [u8] {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: replace the `Into` implentation with `From<&'static [u8]>`
+
+error: an implementation of `From` is preferred since it gives you `Into<_>` for free where the reverse isn't true
+  --> $DIR/from_over_into_unfixable.rs:28:1
+   |
+LL | impl Into<u8> for ContainsVal {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: `impl From<Local> for Foreign` is allowed by the orphan rules, for more information see
+           https://doc.rust-lang.org/reference/items/implementations.html#trait-implementation-coherence
+   = help: replace the `Into` implentation with `From<ContainsVal>`
+
+error: aborting due to 3 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From dfd3525cff90fe2363494559499276ca07d2aef7 Mon Sep 17 00:00:00 2001
From: Samuel Moelius <sam@moeli.us>
Date: Fri, 30 Sep 2022 21:10:10 -0400
Subject: Separate internal lints by pass

---
 clippy_lints/src/lib.register_internal.rs          |   32 +-
 clippy_lints/src/lib.register_lints.rs             |   32 +-
 clippy_lints/src/lib.rs                            |   28 +-
 clippy_lints/src/utils/internal_lints.rs           | 1570 +-------------------
 .../utils/internal_lints/clippy_lints_internal.rs  |   49 +
 .../src/utils/internal_lints/collapsible_calls.rs  |  240 +++
 .../internal_lints/compiler_lint_functions.rs      |   78 +
 .../src/utils/internal_lints/if_chain_style.rs     |  161 ++
 .../internal_lints/interning_defined_symbol.rs     |  239 +++
 .../src/utils/internal_lints/invalid_paths.rs      |  105 ++
 .../utils/internal_lints/lint_without_lint_pass.rs |  346 +++++
 .../src/utils/internal_lints/metadata_collector.rs |    2 +-
 .../src/utils/internal_lints/msrv_attr_impl.rs     |   63 +
 .../utils/internal_lints/outer_expn_data_pass.rs   |   62 +
 .../src/utils/internal_lints/produce_ice.rs        |   37 +
 .../utils/internal_lints/unnecessary_def_path.rs   |  260 ++++
 tests/ui-internal/custom_ice_message.stderr        |    2 +-
 17 files changed, 1702 insertions(+), 1604 deletions(-)
 create mode 100644 clippy_lints/src/utils/internal_lints/clippy_lints_internal.rs
 create mode 100644 clippy_lints/src/utils/internal_lints/collapsible_calls.rs
 create mode 100644 clippy_lints/src/utils/internal_lints/compiler_lint_functions.rs
 create mode 100644 clippy_lints/src/utils/internal_lints/if_chain_style.rs
 create mode 100644 clippy_lints/src/utils/internal_lints/interning_defined_symbol.rs
 create mode 100644 clippy_lints/src/utils/internal_lints/invalid_paths.rs
 create mode 100644 clippy_lints/src/utils/internal_lints/lint_without_lint_pass.rs
 create mode 100644 clippy_lints/src/utils/internal_lints/msrv_attr_impl.rs
 create mode 100644 clippy_lints/src/utils/internal_lints/outer_expn_data_pass.rs
 create mode 100644 clippy_lints/src/utils/internal_lints/produce_ice.rs
 create mode 100644 clippy_lints/src/utils/internal_lints/unnecessary_def_path.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.register_internal.rs b/clippy_lints/src/lib.register_internal.rs
index 71dfdab369b..40c94c6e8d3 100644
--- a/clippy_lints/src/lib.register_internal.rs
+++ b/clippy_lints/src/lib.register_internal.rs
@@ -3,20 +3,20 @@
 // Manual edits will be overwritten.
 
 store.register_group(true, "clippy::internal", Some("clippy_internal"), vec![
-    LintId::of(utils::internal_lints::CLIPPY_LINTS_INTERNAL),
-    LintId::of(utils::internal_lints::COLLAPSIBLE_SPAN_LINT_CALLS),
-    LintId::of(utils::internal_lints::COMPILER_LINT_FUNCTIONS),
-    LintId::of(utils::internal_lints::DEFAULT_DEPRECATION_REASON),
-    LintId::of(utils::internal_lints::DEFAULT_LINT),
-    LintId::of(utils::internal_lints::IF_CHAIN_STYLE),
-    LintId::of(utils::internal_lints::INTERNING_DEFINED_SYMBOL),
-    LintId::of(utils::internal_lints::INVALID_CLIPPY_VERSION_ATTRIBUTE),
-    LintId::of(utils::internal_lints::INVALID_PATHS),
-    LintId::of(utils::internal_lints::LINT_WITHOUT_LINT_PASS),
-    LintId::of(utils::internal_lints::MISSING_CLIPPY_VERSION_ATTRIBUTE),
-    LintId::of(utils::internal_lints::MISSING_MSRV_ATTR_IMPL),
-    LintId::of(utils::internal_lints::OUTER_EXPN_EXPN_DATA),
-    LintId::of(utils::internal_lints::PRODUCE_ICE),
-    LintId::of(utils::internal_lints::UNNECESSARY_DEF_PATH),
-    LintId::of(utils::internal_lints::UNNECESSARY_SYMBOL_STR),
+    LintId::of(utils::internal_lints::clippy_lints_internal::CLIPPY_LINTS_INTERNAL),
+    LintId::of(utils::internal_lints::collapsible_calls::COLLAPSIBLE_SPAN_LINT_CALLS),
+    LintId::of(utils::internal_lints::compiler_lint_functions::COMPILER_LINT_FUNCTIONS),
+    LintId::of(utils::internal_lints::if_chain_style::IF_CHAIN_STYLE),
+    LintId::of(utils::internal_lints::interning_defined_symbol::INTERNING_DEFINED_SYMBOL),
+    LintId::of(utils::internal_lints::interning_defined_symbol::UNNECESSARY_SYMBOL_STR),
+    LintId::of(utils::internal_lints::invalid_paths::INVALID_PATHS),
+    LintId::of(utils::internal_lints::lint_without_lint_pass::DEFAULT_DEPRECATION_REASON),
+    LintId::of(utils::internal_lints::lint_without_lint_pass::DEFAULT_LINT),
+    LintId::of(utils::internal_lints::lint_without_lint_pass::INVALID_CLIPPY_VERSION_ATTRIBUTE),
+    LintId::of(utils::internal_lints::lint_without_lint_pass::LINT_WITHOUT_LINT_PASS),
+    LintId::of(utils::internal_lints::lint_without_lint_pass::MISSING_CLIPPY_VERSION_ATTRIBUTE),
+    LintId::of(utils::internal_lints::msrv_attr_impl::MISSING_MSRV_ATTR_IMPL),
+    LintId::of(utils::internal_lints::outer_expn_data_pass::OUTER_EXPN_EXPN_DATA),
+    LintId::of(utils::internal_lints::produce_ice::PRODUCE_ICE),
+    LintId::of(utils::internal_lints::unnecessary_def_path::UNNECESSARY_DEF_PATH),
 ])
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index de1253c8510..5609a4dc9ea 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -4,37 +4,37 @@
 
 store.register_lints(&[
     #[cfg(feature = "internal")]
-    utils::internal_lints::CLIPPY_LINTS_INTERNAL,
+    utils::internal_lints::clippy_lints_internal::CLIPPY_LINTS_INTERNAL,
     #[cfg(feature = "internal")]
-    utils::internal_lints::COLLAPSIBLE_SPAN_LINT_CALLS,
+    utils::internal_lints::collapsible_calls::COLLAPSIBLE_SPAN_LINT_CALLS,
     #[cfg(feature = "internal")]
-    utils::internal_lints::COMPILER_LINT_FUNCTIONS,
+    utils::internal_lints::compiler_lint_functions::COMPILER_LINT_FUNCTIONS,
     #[cfg(feature = "internal")]
-    utils::internal_lints::DEFAULT_DEPRECATION_REASON,
+    utils::internal_lints::if_chain_style::IF_CHAIN_STYLE,
     #[cfg(feature = "internal")]
-    utils::internal_lints::DEFAULT_LINT,
+    utils::internal_lints::interning_defined_symbol::INTERNING_DEFINED_SYMBOL,
     #[cfg(feature = "internal")]
-    utils::internal_lints::IF_CHAIN_STYLE,
+    utils::internal_lints::interning_defined_symbol::UNNECESSARY_SYMBOL_STR,
     #[cfg(feature = "internal")]
-    utils::internal_lints::INTERNING_DEFINED_SYMBOL,
+    utils::internal_lints::invalid_paths::INVALID_PATHS,
     #[cfg(feature = "internal")]
-    utils::internal_lints::INVALID_CLIPPY_VERSION_ATTRIBUTE,
+    utils::internal_lints::lint_without_lint_pass::DEFAULT_DEPRECATION_REASON,
     #[cfg(feature = "internal")]
-    utils::internal_lints::INVALID_PATHS,
+    utils::internal_lints::lint_without_lint_pass::DEFAULT_LINT,
     #[cfg(feature = "internal")]
-    utils::internal_lints::LINT_WITHOUT_LINT_PASS,
+    utils::internal_lints::lint_without_lint_pass::INVALID_CLIPPY_VERSION_ATTRIBUTE,
     #[cfg(feature = "internal")]
-    utils::internal_lints::MISSING_CLIPPY_VERSION_ATTRIBUTE,
+    utils::internal_lints::lint_without_lint_pass::LINT_WITHOUT_LINT_PASS,
     #[cfg(feature = "internal")]
-    utils::internal_lints::MISSING_MSRV_ATTR_IMPL,
+    utils::internal_lints::lint_without_lint_pass::MISSING_CLIPPY_VERSION_ATTRIBUTE,
     #[cfg(feature = "internal")]
-    utils::internal_lints::OUTER_EXPN_EXPN_DATA,
+    utils::internal_lints::msrv_attr_impl::MISSING_MSRV_ATTR_IMPL,
     #[cfg(feature = "internal")]
-    utils::internal_lints::PRODUCE_ICE,
+    utils::internal_lints::outer_expn_data_pass::OUTER_EXPN_EXPN_DATA,
     #[cfg(feature = "internal")]
-    utils::internal_lints::UNNECESSARY_DEF_PATH,
+    utils::internal_lints::produce_ice::PRODUCE_ICE,
     #[cfg(feature = "internal")]
-    utils::internal_lints::UNNECESSARY_SYMBOL_STR,
+    utils::internal_lints::unnecessary_def_path::UNNECESSARY_DEF_PATH,
     almost_complete_letter_range::ALMOST_COMPLETE_LETTER_RANGE,
     approx_const::APPROX_CONSTANT,
     as_conversions::AS_CONVERSIONS,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index ebb0f14fef5..b2ee58ec7ff 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -528,17 +528,23 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     // all the internal lints
     #[cfg(feature = "internal")]
     {
-        store.register_early_pass(|| Box::new(utils::internal_lints::ClippyLintsInternal));
-        store.register_early_pass(|| Box::new(utils::internal_lints::ProduceIce));
-        store.register_late_pass(|_| Box::new(utils::internal_lints::CollapsibleCalls));
-        store.register_late_pass(|_| Box::new(utils::internal_lints::CompilerLintFunctions::new()));
-        store.register_late_pass(|_| Box::new(utils::internal_lints::IfChainStyle));
-        store.register_late_pass(|_| Box::new(utils::internal_lints::InvalidPaths));
-        store.register_late_pass(|_| Box::<utils::internal_lints::InterningDefinedSymbol>::default());
-        store.register_late_pass(|_| Box::<utils::internal_lints::LintWithoutLintPass>::default());
-        store.register_late_pass(|_| Box::new(utils::internal_lints::UnnecessaryDefPath));
-        store.register_late_pass(|_| Box::new(utils::internal_lints::OuterExpnDataPass));
-        store.register_late_pass(|_| Box::new(utils::internal_lints::MsrvAttrImpl));
+        store.register_early_pass(|| Box::new(utils::internal_lints::clippy_lints_internal::ClippyLintsInternal));
+        store.register_early_pass(|| Box::new(utils::internal_lints::produce_ice::ProduceIce));
+        store.register_late_pass(|_| Box::new(utils::internal_lints::collapsible_calls::CollapsibleCalls));
+        store.register_late_pass(|_| {
+            Box::new(utils::internal_lints::compiler_lint_functions::CompilerLintFunctions::new())
+        });
+        store.register_late_pass(|_| Box::new(utils::internal_lints::if_chain_style::IfChainStyle));
+        store.register_late_pass(|_| Box::new(utils::internal_lints::invalid_paths::InvalidPaths));
+        store.register_late_pass(|_| {
+            Box::<utils::internal_lints::interning_defined_symbol::InterningDefinedSymbol>::default()
+        });
+        store.register_late_pass(|_| {
+            Box::<utils::internal_lints::lint_without_lint_pass::LintWithoutLintPass>::default()
+        });
+        store.register_late_pass(|_| Box::new(utils::internal_lints::unnecessary_def_path::UnnecessaryDefPath));
+        store.register_late_pass(|_| Box::new(utils::internal_lints::outer_expn_data_pass::OuterExpnDataPass));
+        store.register_late_pass(|_| Box::new(utils::internal_lints::msrv_attr_impl::MsrvAttrImpl));
     }
 
     let arithmetic_side_effects_allowed = conf.arithmetic_side_effects_allowed.clone();
diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs
index 0d908bf2a83..71f6c9909dd 100644
--- a/clippy_lints/src/utils/internal_lints.rs
+++ b/clippy_lints/src/utils/internal_lints.rs
@@ -1,1560 +1,12 @@
-use crate::utils::internal_lints::metadata_collector::is_deprecated_lint;
-use clippy_utils::consts::{constant_simple, Constant};
-use clippy_utils::diagnostics::{span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then};
-use clippy_utils::macros::root_macro_call_first_node;
-use clippy_utils::source::{snippet, snippet_with_applicability};
-use clippy_utils::ty::match_type;
-use clippy_utils::{
-    def_path_res, higher, is_else_clause, is_expn_of, is_expr_path_def_path, is_lint_allowed, match_any_def_paths,
-    match_def_path, method_calls, paths, peel_blocks_with_stmt, peel_hir_expr_refs, SpanlessEq,
-};
-use if_chain::if_chain;
-use rustc_ast as ast;
-use rustc_ast::ast::{Crate, ItemKind, LitKind, ModKind, NodeId};
-use rustc_ast::visit::FnKind;
-use rustc_data_structures::fx::{FxHashMap, FxHashSet};
-use rustc_errors::Applicability;
-use rustc_hir as hir;
-use rustc_hir::def::{DefKind, Namespace, Res};
-use rustc_hir::def_id::DefId;
-use rustc_hir::hir_id::CRATE_HIR_ID;
-use rustc_hir::intravisit::Visitor;
-use rustc_hir::{
-    BinOpKind, Block, Closure, Expr, ExprKind, HirId, Item, Local, MutTy, Mutability, Node, Path, Stmt, StmtKind,
-    TyKind, UnOp,
-};
-use rustc_hir_analysis::hir_ty_to_ty;
-use rustc_lint::{EarlyContext, EarlyLintPass, LateContext, LateLintPass, LintContext};
-use rustc_middle::hir::nested_filter;
-use rustc_middle::mir::interpret::{Allocation, ConstValue, GlobalAlloc};
-use rustc_middle::ty::{
-    self, fast_reject::SimplifiedTypeGen, subst::GenericArgKind, AssocKind, DefIdTree, FloatTy, Ty,
-};
-use rustc_semver::RustcVersion;
-use rustc_session::{declare_lint_pass, declare_tool_lint, impl_lint_pass};
-use rustc_span::source_map::Spanned;
-use rustc_span::symbol::{Ident, Symbol};
-use rustc_span::{sym, BytePos, Span};
-
-use std::borrow::{Borrow, Cow};
-use std::str;
-
-#[cfg(feature = "internal")]
+pub mod clippy_lints_internal;
+pub mod collapsible_calls;
+pub mod compiler_lint_functions;
+pub mod if_chain_style;
+pub mod interning_defined_symbol;
+pub mod invalid_paths;
+pub mod lint_without_lint_pass;
 pub mod metadata_collector;
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for various things we like to keep tidy in clippy.
-    ///
-    /// ### Why is this bad?
-    /// We like to pretend we're an example of tidy code.
-    ///
-    /// ### Example
-    /// Wrong ordering of the util::paths constants.
-    pub CLIPPY_LINTS_INTERNAL,
-    internal,
-    "various things that will negatively affect your clippy experience"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Ensures every lint is associated to a `LintPass`.
-    ///
-    /// ### Why is this bad?
-    /// The compiler only knows lints via a `LintPass`. Without
-    /// putting a lint to a `LintPass::get_lints()`'s return, the compiler will not
-    /// know the name of the lint.
-    ///
-    /// ### Known problems
-    /// Only checks for lints associated using the
-    /// `declare_lint_pass!`, `impl_lint_pass!`, and `lint_array!` macros.
-    ///
-    /// ### Example
-    /// ```rust,ignore
-    /// declare_lint! { pub LINT_1, ... }
-    /// declare_lint! { pub LINT_2, ... }
-    /// declare_lint! { pub FORGOTTEN_LINT, ... }
-    /// // ...
-    /// declare_lint_pass!(Pass => [LINT_1, LINT_2]);
-    /// // missing FORGOTTEN_LINT
-    /// ```
-    pub LINT_WITHOUT_LINT_PASS,
-    internal,
-    "declaring a lint without associating it in a LintPass"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for calls to `cx.span_lint*` and suggests to use the `utils::*`
-    /// variant of the function.
-    ///
-    /// ### Why is this bad?
-    /// The `utils::*` variants also add a link to the Clippy documentation to the
-    /// warning/error messages.
-    ///
-    /// ### Example
-    /// ```rust,ignore
-    /// cx.span_lint(LINT_NAME, "message");
-    /// ```
-    ///
-    /// Use instead:
-    /// ```rust,ignore
-    /// utils::span_lint(cx, LINT_NAME, "message");
-    /// ```
-    pub COMPILER_LINT_FUNCTIONS,
-    internal,
-    "usage of the lint functions of the compiler instead of the utils::* variant"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for calls to `cx.outer().expn_data()` and suggests to use
-    /// the `cx.outer_expn_data()`
-    ///
-    /// ### Why is this bad?
-    /// `cx.outer_expn_data()` is faster and more concise.
-    ///
-    /// ### Example
-    /// ```rust,ignore
-    /// expr.span.ctxt().outer().expn_data()
-    /// ```
-    ///
-    /// Use instead:
-    /// ```rust,ignore
-    /// expr.span.ctxt().outer_expn_data()
-    /// ```
-    pub OUTER_EXPN_EXPN_DATA,
-    internal,
-    "using `cx.outer_expn().expn_data()` instead of `cx.outer_expn_data()`"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Not an actual lint. This lint is only meant for testing our customized internal compiler
-    /// error message by calling `panic`.
-    ///
-    /// ### Why is this bad?
-    /// ICE in large quantities can damage your teeth
-    ///
-    /// ### Example
-    /// ```rust,ignore
-    /// 🍦🍦🍦🍦🍦
-    /// ```
-    pub PRODUCE_ICE,
-    internal,
-    "this message should not appear anywhere as we ICE before and don't emit the lint"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for cases of an auto-generated lint without an updated description,
-    /// i.e. `default lint description`.
-    ///
-    /// ### Why is this bad?
-    /// Indicates that the lint is not finished.
-    ///
-    /// ### Example
-    /// ```rust,ignore
-    /// declare_lint! { pub COOL_LINT, nursery, "default lint description" }
-    /// ```
-    ///
-    /// Use instead:
-    /// ```rust,ignore
-    /// declare_lint! { pub COOL_LINT, nursery, "a great new lint" }
-    /// ```
-    pub DEFAULT_LINT,
-    internal,
-    "found 'default lint description' in a lint declaration"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Lints `span_lint_and_then` function calls, where the
-    /// closure argument has only one statement and that statement is a method
-    /// call to `span_suggestion`, `span_help`, `span_note` (using the same
-    /// span), `help` or `note`.
-    ///
-    /// These usages of `span_lint_and_then` should be replaced with one of the
-    /// wrapper functions `span_lint_and_sugg`, span_lint_and_help`, or
-    /// `span_lint_and_note`.
-    ///
-    /// ### Why is this bad?
-    /// Using the wrapper `span_lint_and_*` functions, is more
-    /// convenient, readable and less error prone.
-    ///
-    /// ### Example
-    /// ```rust,ignore
-    /// span_lint_and_then(cx, TEST_LINT, expr.span, lint_msg, |diag| {
-    ///     diag.span_suggestion(
-    ///         expr.span,
-    ///         help_msg,
-    ///         sugg.to_string(),
-    ///         Applicability::MachineApplicable,
-    ///     );
-    /// });
-    /// span_lint_and_then(cx, TEST_LINT, expr.span, lint_msg, |diag| {
-    ///     diag.span_help(expr.span, help_msg);
-    /// });
-    /// span_lint_and_then(cx, TEST_LINT, expr.span, lint_msg, |diag| {
-    ///     diag.help(help_msg);
-    /// });
-    /// span_lint_and_then(cx, TEST_LINT, expr.span, lint_msg, |diag| {
-    ///     diag.span_note(expr.span, note_msg);
-    /// });
-    /// span_lint_and_then(cx, TEST_LINT, expr.span, lint_msg, |diag| {
-    ///     diag.note(note_msg);
-    /// });
-    /// ```
-    ///
-    /// Use instead:
-    /// ```rust,ignore
-    /// span_lint_and_sugg(
-    ///     cx,
-    ///     TEST_LINT,
-    ///     expr.span,
-    ///     lint_msg,
-    ///     help_msg,
-    ///     sugg.to_string(),
-    ///     Applicability::MachineApplicable,
-    /// );
-    /// span_lint_and_help(cx, TEST_LINT, expr.span, lint_msg, Some(expr.span), help_msg);
-    /// span_lint_and_help(cx, TEST_LINT, expr.span, lint_msg, None, help_msg);
-    /// span_lint_and_note(cx, TEST_LINT, expr.span, lint_msg, Some(expr.span), note_msg);
-    /// span_lint_and_note(cx, TEST_LINT, expr.span, lint_msg, None, note_msg);
-    /// ```
-    pub COLLAPSIBLE_SPAN_LINT_CALLS,
-    internal,
-    "found collapsible `span_lint_and_then` calls"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for usages of def paths when a diagnostic item or a `LangItem` could be used.
-    ///
-    /// ### Why is this bad?
-    /// The path for an item is subject to change and is less efficient to look up than a
-    /// diagnostic item or a `LangItem`.
-    ///
-    /// ### Example
-    /// ```rust,ignore
-    /// utils::match_type(cx, ty, &paths::VEC)
-    /// ```
-    ///
-    /// Use instead:
-    /// ```rust,ignore
-    /// utils::is_type_diagnostic_item(cx, ty, sym::Vec)
-    /// ```
-    pub UNNECESSARY_DEF_PATH,
-    internal,
-    "using a def path when a diagnostic item or a `LangItem` is available"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks the paths module for invalid paths.
-    ///
-    /// ### Why is this bad?
-    /// It indicates a bug in the code.
-    ///
-    /// ### Example
-    /// None.
-    pub INVALID_PATHS,
-    internal,
-    "invalid path"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for interning symbols that have already been pre-interned and defined as constants.
-    ///
-    /// ### Why is this bad?
-    /// It's faster and easier to use the symbol constant.
-    ///
-    /// ### Example
-    /// ```rust,ignore
-    /// let _ = sym!(f32);
-    /// ```
-    ///
-    /// Use instead:
-    /// ```rust,ignore
-    /// let _ = sym::f32;
-    /// ```
-    pub INTERNING_DEFINED_SYMBOL,
-    internal,
-    "interning a symbol that is pre-interned and defined as a constant"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for unnecessary conversion from Symbol to a string.
-    ///
-    /// ### Why is this bad?
-    /// It's faster use symbols directly instead of strings.
-    ///
-    /// ### Example
-    /// ```rust,ignore
-    /// symbol.as_str() == "clippy";
-    /// ```
-    ///
-    /// Use instead:
-    /// ```rust,ignore
-    /// symbol == sym::clippy;
-    /// ```
-    pub UNNECESSARY_SYMBOL_STR,
-    internal,
-    "unnecessary conversion between Symbol and string"
-}
-
-declare_clippy_lint! {
-    /// Finds unidiomatic usage of `if_chain!`
-    pub IF_CHAIN_STYLE,
-    internal,
-    "non-idiomatic `if_chain!` usage"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for invalid `clippy::version` attributes.
-    ///
-    /// Valid values are:
-    /// * "pre 1.29.0"
-    /// * any valid semantic version
-    pub INVALID_CLIPPY_VERSION_ATTRIBUTE,
-    internal,
-    "found an invalid `clippy::version` attribute"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for declared clippy lints without the `clippy::version` attribute.
-    ///
-    pub MISSING_CLIPPY_VERSION_ATTRIBUTE,
-    internal,
-    "found clippy lint without `clippy::version` attribute"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Check that the `extract_msrv_attr!` macro is used, when a lint has a MSRV.
-    ///
-    pub MISSING_MSRV_ATTR_IMPL,
-    internal,
-    "checking if all necessary steps were taken when adding a MSRV to a lint"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for cases of an auto-generated deprecated lint without an updated reason,
-    /// i.e. `"default deprecation note"`.
-    ///
-    /// ### Why is this bad?
-    /// Indicates that the documentation is incomplete.
-    ///
-    /// ### Example
-    /// ```rust,ignore
-    /// declare_deprecated_lint! {
-    ///     /// ### What it does
-    ///     /// Nothing. This lint has been deprecated.
-    ///     ///
-    ///     /// ### Deprecation reason
-    ///     /// TODO
-    ///     #[clippy::version = "1.63.0"]
-    ///     pub COOL_LINT,
-    ///     "default deprecation note"
-    /// }
-    /// ```
-    ///
-    /// Use instead:
-    /// ```rust,ignore
-    /// declare_deprecated_lint! {
-    ///     /// ### What it does
-    ///     /// Nothing. This lint has been deprecated.
-    ///     ///
-    ///     /// ### Deprecation reason
-    ///     /// This lint has been replaced by `cooler_lint`
-    ///     #[clippy::version = "1.63.0"]
-    ///     pub COOL_LINT,
-    ///     "this lint has been replaced by `cooler_lint`"
-    /// }
-    /// ```
-    pub DEFAULT_DEPRECATION_REASON,
-    internal,
-    "found 'default deprecation note' in a deprecated lint declaration"
-}
-
-declare_lint_pass!(ClippyLintsInternal => [CLIPPY_LINTS_INTERNAL]);
-
-impl EarlyLintPass for ClippyLintsInternal {
-    fn check_crate(&mut self, cx: &EarlyContext<'_>, krate: &Crate) {
-        if let Some(utils) = krate.items.iter().find(|item| item.ident.name.as_str() == "utils") {
-            if let ItemKind::Mod(_, ModKind::Loaded(ref items, ..)) = utils.kind {
-                if let Some(paths) = items.iter().find(|item| item.ident.name.as_str() == "paths") {
-                    if let ItemKind::Mod(_, ModKind::Loaded(ref items, ..)) = paths.kind {
-                        let mut last_name: Option<&str> = None;
-                        for item in items {
-                            let name = item.ident.as_str();
-                            if let Some(last_name) = last_name {
-                                if *last_name > *name {
-                                    span_lint(
-                                        cx,
-                                        CLIPPY_LINTS_INTERNAL,
-                                        item.span,
-                                        "this constant should be before the previous constant due to lexical \
-                                         ordering",
-                                    );
-                                }
-                            }
-                            last_name = Some(name);
-                        }
-                    }
-                }
-            }
-        }
-    }
-}
-
-#[derive(Clone, Debug, Default)]
-pub struct LintWithoutLintPass {
-    declared_lints: FxHashMap<Symbol, Span>,
-    registered_lints: FxHashSet<Symbol>,
-}
-
-impl_lint_pass!(LintWithoutLintPass => [DEFAULT_LINT, LINT_WITHOUT_LINT_PASS, INVALID_CLIPPY_VERSION_ATTRIBUTE, MISSING_CLIPPY_VERSION_ATTRIBUTE, DEFAULT_DEPRECATION_REASON]);
-
-impl<'tcx> LateLintPass<'tcx> for LintWithoutLintPass {
-    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
-        if is_lint_allowed(cx, DEFAULT_LINT, item.hir_id())
-            || is_lint_allowed(cx, DEFAULT_DEPRECATION_REASON, item.hir_id())
-        {
-            return;
-        }
-
-        if let hir::ItemKind::Static(ty, Mutability::Not, body_id) = item.kind {
-            let is_lint_ref_ty = is_lint_ref_type(cx, ty);
-            if is_deprecated_lint(cx, ty) || is_lint_ref_ty {
-                check_invalid_clippy_version_attribute(cx, item);
-
-                let expr = &cx.tcx.hir().body(body_id).value;
-                let fields;
-                if is_lint_ref_ty {
-                    if let ExprKind::AddrOf(_, _, inner_exp) = expr.kind
-                        && let ExprKind::Struct(_, struct_fields, _) = inner_exp.kind {
-                            fields = struct_fields;
-                    } else {
-                        return;
-                    }
-                } else if let ExprKind::Struct(_, struct_fields, _) = expr.kind {
-                    fields = struct_fields;
-                } else {
-                    return;
-                }
-
-                let field = fields
-                    .iter()
-                    .find(|f| f.ident.as_str() == "desc")
-                    .expect("lints must have a description field");
-
-                if let ExprKind::Lit(Spanned {
-                    node: LitKind::Str(ref sym, _),
-                    ..
-                }) = field.expr.kind
-                {
-                    let sym_str = sym.as_str();
-                    if is_lint_ref_ty {
-                        if sym_str == "default lint description" {
-                            span_lint(
-                                cx,
-                                DEFAULT_LINT,
-                                item.span,
-                                &format!("the lint `{}` has the default lint description", item.ident.name),
-                            );
-                        }
-
-                        self.declared_lints.insert(item.ident.name, item.span);
-                    } else if sym_str == "default deprecation note" {
-                        span_lint(
-                            cx,
-                            DEFAULT_DEPRECATION_REASON,
-                            item.span,
-                            &format!("the lint `{}` has the default deprecation reason", item.ident.name),
-                        );
-                    }
-                }
-            }
-        } else if let Some(macro_call) = root_macro_call_first_node(cx, item) {
-            if !matches!(
-                cx.tcx.item_name(macro_call.def_id).as_str(),
-                "impl_lint_pass" | "declare_lint_pass"
-            ) {
-                return;
-            }
-            if let hir::ItemKind::Impl(hir::Impl {
-                of_trait: None,
-                items: impl_item_refs,
-                ..
-            }) = item.kind
-            {
-                let mut collector = LintCollector {
-                    output: &mut self.registered_lints,
-                    cx,
-                };
-                let body_id = cx.tcx.hir().body_owned_by(
-                    cx.tcx.hir().local_def_id(
-                        impl_item_refs
-                            .iter()
-                            .find(|iiref| iiref.ident.as_str() == "get_lints")
-                            .expect("LintPass needs to implement get_lints")
-                            .id
-                            .hir_id(),
-                    ),
-                );
-                collector.visit_expr(cx.tcx.hir().body(body_id).value);
-            }
-        }
-    }
-
-    fn check_crate_post(&mut self, cx: &LateContext<'tcx>) {
-        if is_lint_allowed(cx, LINT_WITHOUT_LINT_PASS, CRATE_HIR_ID) {
-            return;
-        }
-
-        for (lint_name, &lint_span) in &self.declared_lints {
-            // When using the `declare_tool_lint!` macro, the original `lint_span`'s
-            // file points to "<rustc macros>".
-            // `compiletest-rs` thinks that's an error in a different file and
-            // just ignores it. This causes the test in compile-fail/lint_pass
-            // not able to capture the error.
-            // Therefore, we need to climb the macro expansion tree and find the
-            // actual span that invoked `declare_tool_lint!`:
-            let lint_span = lint_span.ctxt().outer_expn_data().call_site;
-
-            if !self.registered_lints.contains(lint_name) {
-                span_lint(
-                    cx,
-                    LINT_WITHOUT_LINT_PASS,
-                    lint_span,
-                    &format!("the lint `{lint_name}` is not added to any `LintPass`"),
-                );
-            }
-        }
-    }
-}
-
-fn is_lint_ref_type<'tcx>(cx: &LateContext<'tcx>, ty: &hir::Ty<'_>) -> bool {
-    if let TyKind::Rptr(
-        _,
-        MutTy {
-            ty: inner,
-            mutbl: Mutability::Not,
-        },
-    ) = ty.kind
-    {
-        if let TyKind::Path(ref path) = inner.kind {
-            if let Res::Def(DefKind::Struct, def_id) = cx.qpath_res(path, inner.hir_id) {
-                return match_def_path(cx, def_id, &paths::LINT);
-            }
-        }
-    }
-
-    false
-}
-
-fn check_invalid_clippy_version_attribute(cx: &LateContext<'_>, item: &'_ Item<'_>) {
-    if let Some(value) = extract_clippy_version_value(cx, item) {
-        // The `sym!` macro doesn't work as it only expects a single token.
-        // It's better to keep it this way and have a direct `Symbol::intern` call here.
-        if value == Symbol::intern("pre 1.29.0") {
-            return;
-        }
-
-        if RustcVersion::parse(value.as_str()).is_err() {
-            span_lint_and_help(
-                cx,
-                INVALID_CLIPPY_VERSION_ATTRIBUTE,
-                item.span,
-                "this item has an invalid `clippy::version` attribute",
-                None,
-                "please use a valid semantic version, see `doc/adding_lints.md`",
-            );
-        }
-    } else {
-        span_lint_and_help(
-            cx,
-            MISSING_CLIPPY_VERSION_ATTRIBUTE,
-            item.span,
-            "this lint is missing the `clippy::version` attribute or version value",
-            None,
-            "please use a `clippy::version` attribute, see `doc/adding_lints.md`",
-        );
-    }
-}
-
-/// This function extracts the version value of a `clippy::version` attribute if the given value has
-/// one
-fn extract_clippy_version_value(cx: &LateContext<'_>, item: &'_ Item<'_>) -> Option<Symbol> {
-    let attrs = cx.tcx.hir().attrs(item.hir_id());
-    attrs.iter().find_map(|attr| {
-        if_chain! {
-            // Identify attribute
-            if let ast::AttrKind::Normal(ref attr_kind) = &attr.kind;
-            if let [tool_name, attr_name] = &attr_kind.item.path.segments[..];
-            if tool_name.ident.name == sym::clippy;
-            if attr_name.ident.name == sym::version;
-            if let Some(version) = attr.value_str();
-            then {
-                Some(version)
-            } else {
-                None
-            }
-        }
-    })
-}
-
-struct LintCollector<'a, 'tcx> {
-    output: &'a mut FxHashSet<Symbol>,
-    cx: &'a LateContext<'tcx>,
-}
-
-impl<'a, 'tcx> Visitor<'tcx> for LintCollector<'a, 'tcx> {
-    type NestedFilter = nested_filter::All;
-
-    fn visit_path(&mut self, path: &'tcx Path<'_>, _: HirId) {
-        if path.segments.len() == 1 {
-            self.output.insert(path.segments[0].ident.name);
-        }
-    }
-
-    fn nested_visit_map(&mut self) -> Self::Map {
-        self.cx.tcx.hir()
-    }
-}
-
-#[derive(Clone, Default)]
-pub struct CompilerLintFunctions {
-    map: FxHashMap<&'static str, &'static str>,
-}
-
-impl CompilerLintFunctions {
-    #[must_use]
-    pub fn new() -> Self {
-        let mut map = FxHashMap::default();
-        map.insert("span_lint", "utils::span_lint");
-        map.insert("struct_span_lint", "utils::span_lint");
-        map.insert("lint", "utils::span_lint");
-        map.insert("span_lint_note", "utils::span_lint_and_note");
-        map.insert("span_lint_help", "utils::span_lint_and_help");
-        Self { map }
-    }
-}
-
-impl_lint_pass!(CompilerLintFunctions => [COMPILER_LINT_FUNCTIONS]);
-
-impl<'tcx> LateLintPass<'tcx> for CompilerLintFunctions {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if is_lint_allowed(cx, COMPILER_LINT_FUNCTIONS, expr.hir_id) {
-            return;
-        }
-
-        if_chain! {
-            if let ExprKind::MethodCall(path, self_arg, _, _) = &expr.kind;
-            let fn_name = path.ident;
-            if let Some(sugg) = self.map.get(fn_name.as_str());
-            let ty = cx.typeck_results().expr_ty(self_arg).peel_refs();
-            if match_type(cx, ty, &paths::EARLY_CONTEXT)
-                || match_type(cx, ty, &paths::LATE_CONTEXT);
-            then {
-                span_lint_and_help(
-                    cx,
-                    COMPILER_LINT_FUNCTIONS,
-                    path.ident.span,
-                    "usage of a compiler lint function",
-                    None,
-                    &format!("please use the Clippy variant of this function: `{sugg}`"),
-                );
-            }
-        }
-    }
-}
-
-declare_lint_pass!(OuterExpnDataPass => [OUTER_EXPN_EXPN_DATA]);
-
-impl<'tcx> LateLintPass<'tcx> for OuterExpnDataPass {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
-        if is_lint_allowed(cx, OUTER_EXPN_EXPN_DATA, expr.hir_id) {
-            return;
-        }
-
-        let (method_names, arg_lists, spans) = method_calls(expr, 2);
-        let method_names: Vec<&str> = method_names.iter().map(Symbol::as_str).collect();
-        if_chain! {
-            if let ["expn_data", "outer_expn"] = method_names.as_slice();
-            let (self_arg, args)= arg_lists[1];
-            if args.is_empty();
-            let self_ty = cx.typeck_results().expr_ty(self_arg).peel_refs();
-            if match_type(cx, self_ty, &paths::SYNTAX_CONTEXT);
-            then {
-                span_lint_and_sugg(
-                    cx,
-                    OUTER_EXPN_EXPN_DATA,
-                    spans[1].with_hi(expr.span.hi()),
-                    "usage of `outer_expn().expn_data()`",
-                    "try",
-                    "outer_expn_data()".to_string(),
-                    Applicability::MachineApplicable,
-                );
-            }
-        }
-    }
-}
-
-declare_lint_pass!(ProduceIce => [PRODUCE_ICE]);
-
-impl EarlyLintPass for ProduceIce {
-    fn check_fn(&mut self, _: &EarlyContext<'_>, fn_kind: FnKind<'_>, _: Span, _: NodeId) {
-        assert!(!is_trigger_fn(fn_kind), "Would you like some help with that?");
-    }
-}
-
-fn is_trigger_fn(fn_kind: FnKind<'_>) -> bool {
-    match fn_kind {
-        FnKind::Fn(_, ident, ..) => ident.name.as_str() == "it_looks_like_you_are_trying_to_kill_clippy",
-        FnKind::Closure(..) => false,
-    }
-}
-
-declare_lint_pass!(CollapsibleCalls => [COLLAPSIBLE_SPAN_LINT_CALLS]);
-
-impl<'tcx> LateLintPass<'tcx> for CollapsibleCalls {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
-        if is_lint_allowed(cx, COLLAPSIBLE_SPAN_LINT_CALLS, expr.hir_id) {
-            return;
-        }
-
-        if_chain! {
-            if let ExprKind::Call(func, and_then_args) = expr.kind;
-            if is_expr_path_def_path(cx, func, &["clippy_utils", "diagnostics", "span_lint_and_then"]);
-            if and_then_args.len() == 5;
-            if let ExprKind::Closure(&Closure { body, .. }) = &and_then_args[4].kind;
-            let body = cx.tcx.hir().body(body);
-            let only_expr = peel_blocks_with_stmt(body.value);
-            if let ExprKind::MethodCall(ps, recv, span_call_args, _) = &only_expr.kind;
-            if let ExprKind::Path(..) = recv.kind;
-            then {
-                let and_then_snippets = get_and_then_snippets(cx, and_then_args);
-                let mut sle = SpanlessEq::new(cx).deny_side_effects();
-                match ps.ident.as_str() {
-                    "span_suggestion" if sle.eq_expr(&and_then_args[2], &span_call_args[0]) => {
-                        suggest_suggestion(cx, expr, &and_then_snippets, &span_suggestion_snippets(cx, span_call_args));
-                    },
-                    "span_help" if sle.eq_expr(&and_then_args[2], &span_call_args[0]) => {
-                        let help_snippet = snippet(cx, span_call_args[1].span, r#""...""#);
-                        suggest_help(cx, expr, &and_then_snippets, help_snippet.borrow(), true);
-                    },
-                    "span_note" if sle.eq_expr(&and_then_args[2], &span_call_args[0]) => {
-                        let note_snippet = snippet(cx, span_call_args[1].span, r#""...""#);
-                        suggest_note(cx, expr, &and_then_snippets, note_snippet.borrow(), true);
-                    },
-                    "help" => {
-                        let help_snippet = snippet(cx, span_call_args[0].span, r#""...""#);
-                        suggest_help(cx, expr, &and_then_snippets, help_snippet.borrow(), false);
-                    }
-                    "note" => {
-                        let note_snippet = snippet(cx, span_call_args[0].span, r#""...""#);
-                        suggest_note(cx, expr, &and_then_snippets, note_snippet.borrow(), false);
-                    }
-                    _  => (),
-                }
-            }
-        }
-    }
-}
-
-struct AndThenSnippets<'a> {
-    cx: Cow<'a, str>,
-    lint: Cow<'a, str>,
-    span: Cow<'a, str>,
-    msg: Cow<'a, str>,
-}
-
-fn get_and_then_snippets<'a, 'hir>(cx: &LateContext<'_>, and_then_snippets: &'hir [Expr<'hir>]) -> AndThenSnippets<'a> {
-    let cx_snippet = snippet(cx, and_then_snippets[0].span, "cx");
-    let lint_snippet = snippet(cx, and_then_snippets[1].span, "..");
-    let span_snippet = snippet(cx, and_then_snippets[2].span, "span");
-    let msg_snippet = snippet(cx, and_then_snippets[3].span, r#""...""#);
-
-    AndThenSnippets {
-        cx: cx_snippet,
-        lint: lint_snippet,
-        span: span_snippet,
-        msg: msg_snippet,
-    }
-}
-
-struct SpanSuggestionSnippets<'a> {
-    help: Cow<'a, str>,
-    sugg: Cow<'a, str>,
-    applicability: Cow<'a, str>,
-}
-
-fn span_suggestion_snippets<'a, 'hir>(
-    cx: &LateContext<'_>,
-    span_call_args: &'hir [Expr<'hir>],
-) -> SpanSuggestionSnippets<'a> {
-    let help_snippet = snippet(cx, span_call_args[1].span, r#""...""#);
-    let sugg_snippet = snippet(cx, span_call_args[2].span, "..");
-    let applicability_snippet = snippet(cx, span_call_args[3].span, "Applicability::MachineApplicable");
-
-    SpanSuggestionSnippets {
-        help: help_snippet,
-        sugg: sugg_snippet,
-        applicability: applicability_snippet,
-    }
-}
-
-fn suggest_suggestion(
-    cx: &LateContext<'_>,
-    expr: &Expr<'_>,
-    and_then_snippets: &AndThenSnippets<'_>,
-    span_suggestion_snippets: &SpanSuggestionSnippets<'_>,
-) {
-    span_lint_and_sugg(
-        cx,
-        COLLAPSIBLE_SPAN_LINT_CALLS,
-        expr.span,
-        "this call is collapsible",
-        "collapse into",
-        format!(
-            "span_lint_and_sugg({}, {}, {}, {}, {}, {}, {})",
-            and_then_snippets.cx,
-            and_then_snippets.lint,
-            and_then_snippets.span,
-            and_then_snippets.msg,
-            span_suggestion_snippets.help,
-            span_suggestion_snippets.sugg,
-            span_suggestion_snippets.applicability
-        ),
-        Applicability::MachineApplicable,
-    );
-}
-
-fn suggest_help(
-    cx: &LateContext<'_>,
-    expr: &Expr<'_>,
-    and_then_snippets: &AndThenSnippets<'_>,
-    help: &str,
-    with_span: bool,
-) {
-    let option_span = if with_span {
-        format!("Some({})", and_then_snippets.span)
-    } else {
-        "None".to_string()
-    };
-
-    span_lint_and_sugg(
-        cx,
-        COLLAPSIBLE_SPAN_LINT_CALLS,
-        expr.span,
-        "this call is collapsible",
-        "collapse into",
-        format!(
-            "span_lint_and_help({}, {}, {}, {}, {}, {help})",
-            and_then_snippets.cx, and_then_snippets.lint, and_then_snippets.span, and_then_snippets.msg, &option_span,
-        ),
-        Applicability::MachineApplicable,
-    );
-}
-
-fn suggest_note(
-    cx: &LateContext<'_>,
-    expr: &Expr<'_>,
-    and_then_snippets: &AndThenSnippets<'_>,
-    note: &str,
-    with_span: bool,
-) {
-    let note_span = if with_span {
-        format!("Some({})", and_then_snippets.span)
-    } else {
-        "None".to_string()
-    };
-
-    span_lint_and_sugg(
-        cx,
-        COLLAPSIBLE_SPAN_LINT_CALLS,
-        expr.span,
-        "this call is collapsible",
-        "collapse into",
-        format!(
-            "span_lint_and_note({}, {}, {}, {}, {note_span}, {note})",
-            and_then_snippets.cx, and_then_snippets.lint, and_then_snippets.span, and_then_snippets.msg,
-        ),
-        Applicability::MachineApplicable,
-    );
-}
-
-declare_lint_pass!(UnnecessaryDefPath => [UNNECESSARY_DEF_PATH]);
-
-#[allow(clippy::too_many_lines)]
-impl<'tcx> LateLintPass<'tcx> for UnnecessaryDefPath {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
-        enum Item {
-            LangItem(Symbol),
-            DiagnosticItem(Symbol),
-        }
-        static PATHS: &[&[&str]] = &[
-            &["clippy_utils", "match_def_path"],
-            &["clippy_utils", "match_trait_method"],
-            &["clippy_utils", "ty", "match_type"],
-            &["clippy_utils", "is_expr_path_def_path"],
-        ];
-
-        if is_lint_allowed(cx, UNNECESSARY_DEF_PATH, expr.hir_id) {
-            return;
-        }
-
-        if_chain! {
-            if let ExprKind::Call(func, [cx_arg, def_arg, args@..]) = expr.kind;
-            if let ExprKind::Path(path) = &func.kind;
-            if let Some(id) = cx.qpath_res(path, func.hir_id).opt_def_id();
-            if let Some(which_path) = match_any_def_paths(cx, id, PATHS);
-            let item_arg = if which_path == 4 { &args[1] } else { &args[0] };
-            // Extract the path to the matched type
-            if let Some(segments) = path_to_matched_type(cx, item_arg);
-            let segments: Vec<&str> = segments.iter().map(|sym| &**sym).collect();
-            if let Some(def_id) = def_path_res(cx, &segments[..], None).opt_def_id();
-            then {
-                // def_path_res will match field names before anything else, but for this we want to match
-                // inherent functions first.
-                let def_id = if cx.tcx.def_kind(def_id) == DefKind::Field {
-                    let method_name = *segments.last().unwrap();
-                    cx.tcx.def_key(def_id).parent
-                        .and_then(|parent_idx|
-                            cx.tcx.inherent_impls(DefId { index: parent_idx, krate: def_id.krate }).iter()
-                                .find_map(|impl_id| cx.tcx.associated_items(*impl_id)
-                                    .find_by_name_and_kind(
-                                        cx.tcx,
-                                        Ident::from_str(method_name),
-                                        AssocKind::Fn,
-                                        *impl_id,
-                                    )
-                                )
-                        )
-                        .map_or(def_id, |item| item.def_id)
-                } else {
-                    def_id
-                };
-
-                // Check if the target item is a diagnostic item or LangItem.
-                let (msg, item) = if let Some(item_name)
-                    = cx.tcx.diagnostic_items(def_id.krate).id_to_name.get(&def_id)
-                {
-                    (
-                        "use of a def path to a diagnostic item",
-                        Item::DiagnosticItem(*item_name),
-                    )
-                } else if let Some(lang_item) = cx.tcx.lang_items().items().iter().position(|id| *id == Some(def_id)) {
-                    let lang_items = def_path_res(cx, &["rustc_hir", "lang_items", "LangItem"], Some(Namespace::TypeNS)).def_id();
-                    let item_name = cx.tcx.adt_def(lang_items).variants().iter().nth(lang_item).unwrap().name;
-                    (
-                        "use of a def path to a `LangItem`",
-                        Item::LangItem(item_name),
-                    )
-                } else {
-                    return;
-                };
-
-                let has_ctor = match cx.tcx.def_kind(def_id) {
-                    DefKind::Struct => {
-                        let variant = cx.tcx.adt_def(def_id).non_enum_variant();
-                        variant.ctor_def_id.is_some() && variant.fields.iter().all(|f| f.vis.is_public())
-                    }
-                    DefKind::Variant => {
-                        let variant = cx.tcx.adt_def(cx.tcx.parent(def_id)).variant_with_id(def_id);
-                        variant.ctor_def_id.is_some() && variant.fields.iter().all(|f| f.vis.is_public())
-                    }
-                    _ => false,
-                };
-
-                let mut app = Applicability::MachineApplicable;
-                let cx_snip = snippet_with_applicability(cx, cx_arg.span, "..", &mut app);
-                let def_snip = snippet_with_applicability(cx, def_arg.span, "..", &mut app);
-                let (sugg, with_note) = match (which_path, item) {
-                    // match_def_path
-                    (0, Item::DiagnosticItem(item)) =>
-                        (format!("{cx_snip}.tcx.is_diagnostic_item(sym::{item}, {def_snip})"), has_ctor),
-                    (0, Item::LangItem(item)) => (
-                        format!("{cx_snip}.tcx.lang_items().require(LangItem::{item}).ok() == Some({def_snip})"),
-                        has_ctor
-                    ),
-                    // match_trait_method
-                    (1, Item::DiagnosticItem(item)) =>
-                        (format!("is_trait_method({cx_snip}, {def_snip}, sym::{item})"), false),
-                    // match_type
-                    (2, Item::DiagnosticItem(item)) =>
-                        (format!("is_type_diagnostic_item({cx_snip}, {def_snip}, sym::{item})"), false),
-                    (2, Item::LangItem(item)) =>
-                        (format!("is_type_lang_item({cx_snip}, {def_snip}, LangItem::{item})"), false),
-                    // is_expr_path_def_path
-                    (3, Item::DiagnosticItem(item)) if has_ctor => (
-                        format!(
-                            "is_res_diag_ctor({cx_snip}, path_res({cx_snip}, {def_snip}), sym::{item})",
-                        ),
-                        false,
-                    ),
-                    (3, Item::LangItem(item)) if has_ctor => (
-                        format!(
-                            "is_res_lang_ctor({cx_snip}, path_res({cx_snip}, {def_snip}), LangItem::{item})",
-                        ),
-                        false,
-                    ),
-                    (3, Item::DiagnosticItem(item)) =>
-                        (format!("is_path_diagnostic_item({cx_snip}, {def_snip}, sym::{item})"), false),
-                    (3, Item::LangItem(item)) => (
-                        format!(
-                            "path_res({cx_snip}, {def_snip}).opt_def_id()\
-                                .map_or(false, |id| {cx_snip}.tcx.lang_items().require(LangItem::{item}).ok() == Some(id))",
-                        ),
-                        false,
-                    ),
-                    _ => return,
-                };
-
-                span_lint_and_then(
-                    cx,
-                    UNNECESSARY_DEF_PATH,
-                    expr.span,
-                    msg,
-                    |diag| {
-                        diag.span_suggestion(expr.span, "try", sugg, app);
-                        if with_note {
-                            diag.help(
-                                "if this `DefId` came from a constructor expression or pattern then the \
-                                    parent `DefId` should be used instead"
-                            );
-                        }
-                    },
-                );
-            }
-        }
-    }
-}
-
-fn path_to_matched_type(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> Option<Vec<String>> {
-    match peel_hir_expr_refs(expr).0.kind {
-        ExprKind::Path(ref qpath) => match cx.qpath_res(qpath, expr.hir_id) {
-            Res::Local(hir_id) => {
-                let parent_id = cx.tcx.hir().get_parent_node(hir_id);
-                if let Some(Node::Local(Local { init: Some(init), .. })) = cx.tcx.hir().find(parent_id) {
-                    path_to_matched_type(cx, init)
-                } else {
-                    None
-                }
-            },
-            Res::Def(DefKind::Static(_), def_id) => read_mir_alloc_def_path(
-                cx,
-                cx.tcx.eval_static_initializer(def_id).ok()?.inner(),
-                cx.tcx.type_of(def_id),
-            ),
-            Res::Def(DefKind::Const, def_id) => match cx.tcx.const_eval_poly(def_id).ok()? {
-                ConstValue::ByRef { alloc, offset } if offset.bytes() == 0 => {
-                    read_mir_alloc_def_path(cx, alloc.inner(), cx.tcx.type_of(def_id))
-                },
-                _ => None,
-            },
-            _ => None,
-        },
-        ExprKind::Array(exprs) => exprs
-            .iter()
-            .map(|expr| {
-                if let ExprKind::Lit(lit) = &expr.kind {
-                    if let LitKind::Str(sym, _) = lit.node {
-                        return Some((*sym.as_str()).to_owned());
-                    }
-                }
-
-                None
-            })
-            .collect(),
-        _ => None,
-    }
-}
-
-fn read_mir_alloc_def_path<'tcx>(cx: &LateContext<'tcx>, alloc: &'tcx Allocation, ty: Ty<'_>) -> Option<Vec<String>> {
-    let (alloc, ty) = if let ty::Ref(_, ty, Mutability::Not) = *ty.kind() {
-        let &alloc = alloc.provenance().values().next()?;
-        if let GlobalAlloc::Memory(alloc) = cx.tcx.global_alloc(alloc) {
-            (alloc.inner(), ty)
-        } else {
-            return None;
-        }
-    } else {
-        (alloc, ty)
-    };
-
-    if let ty::Array(ty, _) | ty::Slice(ty) = *ty.kind()
-        && let ty::Ref(_, ty, Mutability::Not) = *ty.kind()
-        && ty.is_str()
-    {
-        alloc
-            .provenance()
-            .values()
-            .map(|&alloc| {
-                if let GlobalAlloc::Memory(alloc) = cx.tcx.global_alloc(alloc) {
-                    let alloc = alloc.inner();
-                    str::from_utf8(alloc.inspect_with_uninit_and_ptr_outside_interpreter(0..alloc.len()))
-                        .ok().map(ToOwned::to_owned)
-                } else {
-                    None
-                }
-            })
-            .collect()
-    } else {
-        None
-    }
-}
-
-// This is not a complete resolver for paths. It works on all the paths currently used in the paths
-// module.  That's all it does and all it needs to do.
-pub fn check_path(cx: &LateContext<'_>, path: &[&str]) -> bool {
-    if def_path_res(cx, path, None) != Res::Err {
-        return true;
-    }
-
-    // Some implementations can't be found by `path_to_res`, particularly inherent
-    // implementations of native types. Check lang items.
-    let path_syms: Vec<_> = path.iter().map(|p| Symbol::intern(p)).collect();
-    let lang_items = cx.tcx.lang_items();
-    // This list isn't complete, but good enough for our current list of paths.
-    let incoherent_impls = [
-        SimplifiedTypeGen::FloatSimplifiedType(FloatTy::F32),
-        SimplifiedTypeGen::FloatSimplifiedType(FloatTy::F64),
-        SimplifiedTypeGen::SliceSimplifiedType,
-        SimplifiedTypeGen::StrSimplifiedType,
-    ]
-    .iter()
-    .flat_map(|&ty| cx.tcx.incoherent_impls(ty));
-    for item_def_id in lang_items.items().iter().flatten().chain(incoherent_impls) {
-        let lang_item_path = cx.get_def_path(*item_def_id);
-        if path_syms.starts_with(&lang_item_path) {
-            if let [item] = &path_syms[lang_item_path.len()..] {
-                if matches!(
-                    cx.tcx.def_kind(*item_def_id),
-                    DefKind::Mod | DefKind::Enum | DefKind::Trait
-                ) {
-                    for child in cx.tcx.module_children(*item_def_id) {
-                        if child.ident.name == *item {
-                            return true;
-                        }
-                    }
-                } else {
-                    for child in cx.tcx.associated_item_def_ids(*item_def_id) {
-                        if cx.tcx.item_name(*child) == *item {
-                            return true;
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    false
-}
-
-declare_lint_pass!(InvalidPaths => [INVALID_PATHS]);
-
-impl<'tcx> LateLintPass<'tcx> for InvalidPaths {
-    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
-        let local_def_id = &cx.tcx.parent_module(item.hir_id());
-        let mod_name = &cx.tcx.item_name(local_def_id.to_def_id());
-        if_chain! {
-            if mod_name.as_str() == "paths";
-            if let hir::ItemKind::Const(ty, body_id) = item.kind;
-            let ty = hir_ty_to_ty(cx.tcx, ty);
-            if let ty::Array(el_ty, _) = &ty.kind();
-            if let ty::Ref(_, el_ty, _) = &el_ty.kind();
-            if el_ty.is_str();
-            let body = cx.tcx.hir().body(body_id);
-            let typeck_results = cx.tcx.typeck_body(body_id);
-            if let Some(Constant::Vec(path)) = constant_simple(cx, typeck_results, body.value);
-            let path: Vec<&str> = path.iter().map(|x| {
-                    if let Constant::Str(s) = x {
-                        s.as_str()
-                    } else {
-                        // We checked the type of the constant above
-                        unreachable!()
-                    }
-                }).collect();
-            if !check_path(cx, &path[..]);
-            then {
-                span_lint(cx, INVALID_PATHS, item.span, "invalid path");
-            }
-        }
-    }
-}
-
-#[derive(Default)]
-pub struct InterningDefinedSymbol {
-    // Maps the symbol value to the constant DefId.
-    symbol_map: FxHashMap<u32, DefId>,
-}
-
-impl_lint_pass!(InterningDefinedSymbol => [INTERNING_DEFINED_SYMBOL, UNNECESSARY_SYMBOL_STR]);
-
-impl<'tcx> LateLintPass<'tcx> for InterningDefinedSymbol {
-    fn check_crate(&mut self, cx: &LateContext<'_>) {
-        if !self.symbol_map.is_empty() {
-            return;
-        }
-
-        for &module in &[&paths::KW_MODULE, &paths::SYM_MODULE] {
-            if let Some(def_id) = def_path_res(cx, module, None).opt_def_id() {
-                for item in cx.tcx.module_children(def_id).iter() {
-                    if_chain! {
-                        if let Res::Def(DefKind::Const, item_def_id) = item.res;
-                        let ty = cx.tcx.type_of(item_def_id);
-                        if match_type(cx, ty, &paths::SYMBOL);
-                        if let Ok(ConstValue::Scalar(value)) = cx.tcx.const_eval_poly(item_def_id);
-                        if let Ok(value) = value.to_u32();
-                        then {
-                            self.symbol_map.insert(value, item_def_id);
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if_chain! {
-            if let ExprKind::Call(func, [arg]) = &expr.kind;
-            if let ty::FnDef(def_id, _) = cx.typeck_results().expr_ty(func).kind();
-            if match_def_path(cx, *def_id, &paths::SYMBOL_INTERN);
-            if let Some(Constant::Str(arg)) = constant_simple(cx, cx.typeck_results(), arg);
-            let value = Symbol::intern(&arg).as_u32();
-            if let Some(&def_id) = self.symbol_map.get(&value);
-            then {
-                span_lint_and_sugg(
-                    cx,
-                    INTERNING_DEFINED_SYMBOL,
-                    is_expn_of(expr.span, "sym").unwrap_or(expr.span),
-                    "interning a defined symbol",
-                    "try",
-                    cx.tcx.def_path_str(def_id),
-                    Applicability::MachineApplicable,
-                );
-            }
-        }
-        if let ExprKind::Binary(op, left, right) = expr.kind {
-            if matches!(op.node, BinOpKind::Eq | BinOpKind::Ne) {
-                let data = [
-                    (left, self.symbol_str_expr(left, cx)),
-                    (right, self.symbol_str_expr(right, cx)),
-                ];
-                match data {
-                    // both operands are a symbol string
-                    [(_, Some(left)), (_, Some(right))] => {
-                        span_lint_and_sugg(
-                            cx,
-                            UNNECESSARY_SYMBOL_STR,
-                            expr.span,
-                            "unnecessary `Symbol` to string conversion",
-                            "try",
-                            format!(
-                                "{} {} {}",
-                                left.as_symbol_snippet(cx),
-                                op.node.as_str(),
-                                right.as_symbol_snippet(cx),
-                            ),
-                            Applicability::MachineApplicable,
-                        );
-                    },
-                    // one of the operands is a symbol string
-                    [(expr, Some(symbol)), _] | [_, (expr, Some(symbol))] => {
-                        // creating an owned string for comparison
-                        if matches!(symbol, SymbolStrExpr::Expr { is_to_owned: true, .. }) {
-                            span_lint_and_sugg(
-                                cx,
-                                UNNECESSARY_SYMBOL_STR,
-                                expr.span,
-                                "unnecessary string allocation",
-                                "try",
-                                format!("{}.as_str()", symbol.as_symbol_snippet(cx)),
-                                Applicability::MachineApplicable,
-                            );
-                        }
-                    },
-                    // nothing found
-                    [(_, None), (_, None)] => {},
-                }
-            }
-        }
-    }
-}
-
-impl InterningDefinedSymbol {
-    fn symbol_str_expr<'tcx>(&self, expr: &'tcx Expr<'tcx>, cx: &LateContext<'tcx>) -> Option<SymbolStrExpr<'tcx>> {
-        static IDENT_STR_PATHS: &[&[&str]] = &[&paths::IDENT_AS_STR, &paths::TO_STRING_METHOD];
-        static SYMBOL_STR_PATHS: &[&[&str]] = &[
-            &paths::SYMBOL_AS_STR,
-            &paths::SYMBOL_TO_IDENT_STRING,
-            &paths::TO_STRING_METHOD,
-        ];
-        let call = if_chain! {
-            if let ExprKind::AddrOf(_, _, e) = expr.kind;
-            if let ExprKind::Unary(UnOp::Deref, e) = e.kind;
-            then { e } else { expr }
-        };
-        if_chain! {
-            // is a method call
-            if let ExprKind::MethodCall(_, item, [], _) = call.kind;
-            if let Some(did) = cx.typeck_results().type_dependent_def_id(call.hir_id);
-            let ty = cx.typeck_results().expr_ty(item);
-            // ...on either an Ident or a Symbol
-            if let Some(is_ident) = if match_type(cx, ty, &paths::SYMBOL) {
-                Some(false)
-            } else if match_type(cx, ty, &paths::IDENT) {
-                Some(true)
-            } else {
-                None
-            };
-            // ...which converts it to a string
-            let paths = if is_ident { IDENT_STR_PATHS } else { SYMBOL_STR_PATHS };
-            if let Some(path) = paths.iter().find(|path| match_def_path(cx, did, path));
-            then {
-                let is_to_owned = path.last().unwrap().ends_with("string");
-                return Some(SymbolStrExpr::Expr {
-                    item,
-                    is_ident,
-                    is_to_owned,
-                });
-            }
-        }
-        // is a string constant
-        if let Some(Constant::Str(s)) = constant_simple(cx, cx.typeck_results(), expr) {
-            let value = Symbol::intern(&s).as_u32();
-            // ...which matches a symbol constant
-            if let Some(&def_id) = self.symbol_map.get(&value) {
-                return Some(SymbolStrExpr::Const(def_id));
-            }
-        }
-        None
-    }
-}
-
-enum SymbolStrExpr<'tcx> {
-    /// a string constant with a corresponding symbol constant
-    Const(DefId),
-    /// a "symbol to string" expression like `symbol.as_str()`
-    Expr {
-        /// part that evaluates to `Symbol` or `Ident`
-        item: &'tcx Expr<'tcx>,
-        is_ident: bool,
-        /// whether an owned `String` is created like `to_ident_string()`
-        is_to_owned: bool,
-    },
-}
-
-impl<'tcx> SymbolStrExpr<'tcx> {
-    /// Returns a snippet that evaluates to a `Symbol` and is const if possible
-    fn as_symbol_snippet(&self, cx: &LateContext<'_>) -> Cow<'tcx, str> {
-        match *self {
-            Self::Const(def_id) => cx.tcx.def_path_str(def_id).into(),
-            Self::Expr { item, is_ident, .. } => {
-                let mut snip = snippet(cx, item.span.source_callsite(), "..");
-                if is_ident {
-                    // get `Ident.name`
-                    snip.to_mut().push_str(".name");
-                }
-                snip
-            },
-        }
-    }
-}
-
-declare_lint_pass!(IfChainStyle => [IF_CHAIN_STYLE]);
-
-impl<'tcx> LateLintPass<'tcx> for IfChainStyle {
-    fn check_block(&mut self, cx: &LateContext<'tcx>, block: &'tcx hir::Block<'_>) {
-        let (local, after, if_chain_span) = if_chain! {
-            if let [Stmt { kind: StmtKind::Local(local), .. }, after @ ..] = block.stmts;
-            if let Some(if_chain_span) = is_expn_of(block.span, "if_chain");
-            then { (local, after, if_chain_span) } else { return }
-        };
-        if is_first_if_chain_expr(cx, block.hir_id, if_chain_span) {
-            span_lint(
-                cx,
-                IF_CHAIN_STYLE,
-                if_chain_local_span(cx, local, if_chain_span),
-                "`let` expression should be above the `if_chain!`",
-            );
-        } else if local.span.ctxt() == block.span.ctxt() && is_if_chain_then(after, block.expr, if_chain_span) {
-            span_lint(
-                cx,
-                IF_CHAIN_STYLE,
-                if_chain_local_span(cx, local, if_chain_span),
-                "`let` expression should be inside `then { .. }`",
-            );
-        }
-    }
-
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
-        let (cond, then, els) = if let Some(higher::IfOrIfLet { cond, r#else, then }) = higher::IfOrIfLet::hir(expr) {
-            (cond, then, r#else.is_some())
-        } else {
-            return;
-        };
-        let ExprKind::Block(then_block, _) = then.kind else { return };
-        let if_chain_span = is_expn_of(expr.span, "if_chain");
-        if !els {
-            check_nested_if_chains(cx, expr, then_block, if_chain_span);
-        }
-        let Some(if_chain_span) = if_chain_span else { return };
-        // check for `if a && b;`
-        if_chain! {
-            if let ExprKind::Binary(op, _, _) = cond.kind;
-            if op.node == BinOpKind::And;
-            if cx.sess().source_map().is_multiline(cond.span);
-            then {
-                span_lint(cx, IF_CHAIN_STYLE, cond.span, "`if a && b;` should be `if a; if b;`");
-            }
-        }
-        if is_first_if_chain_expr(cx, expr.hir_id, if_chain_span)
-            && is_if_chain_then(then_block.stmts, then_block.expr, if_chain_span)
-        {
-            span_lint(cx, IF_CHAIN_STYLE, expr.span, "`if_chain!` only has one `if`");
-        }
-    }
-}
-
-fn check_nested_if_chains(
-    cx: &LateContext<'_>,
-    if_expr: &Expr<'_>,
-    then_block: &Block<'_>,
-    if_chain_span: Option<Span>,
-) {
-    #[rustfmt::skip]
-    let (head, tail) = match *then_block {
-        Block { stmts, expr: Some(tail), .. } => (stmts, tail),
-        Block {
-            stmts: &[
-                ref head @ ..,
-                Stmt { kind: StmtKind::Expr(tail) | StmtKind::Semi(tail), .. }
-            ],
-            ..
-        } => (head, tail),
-        _ => return,
-    };
-    if_chain! {
-        if let Some(higher::IfOrIfLet { r#else: None, .. }) = higher::IfOrIfLet::hir(tail);
-        let sm = cx.sess().source_map();
-        if head
-            .iter()
-            .all(|stmt| matches!(stmt.kind, StmtKind::Local(..)) && !sm.is_multiline(stmt.span));
-        if if_chain_span.is_some() || !is_else_clause(cx.tcx, if_expr);
-        then {} else { return }
-    }
-    let (span, msg) = match (if_chain_span, is_expn_of(tail.span, "if_chain")) {
-        (None, Some(_)) => (if_expr.span, "this `if` can be part of the inner `if_chain!`"),
-        (Some(_), None) => (tail.span, "this `if` can be part of the outer `if_chain!`"),
-        (Some(a), Some(b)) if a != b => (b, "this `if_chain!` can be merged with the outer `if_chain!`"),
-        _ => return,
-    };
-    span_lint_and_then(cx, IF_CHAIN_STYLE, span, msg, |diag| {
-        let (span, msg) = match head {
-            [] => return,
-            [stmt] => (stmt.span, "this `let` statement can also be in the `if_chain!`"),
-            [a, .., b] => (
-                a.span.to(b.span),
-                "these `let` statements can also be in the `if_chain!`",
-            ),
-        };
-        diag.span_help(span, msg);
-    });
-}
-
-fn is_first_if_chain_expr(cx: &LateContext<'_>, hir_id: HirId, if_chain_span: Span) -> bool {
-    cx.tcx
-        .hir()
-        .parent_iter(hir_id)
-        .find(|(_, node)| {
-            #[rustfmt::skip]
-            !matches!(node, Node::Expr(Expr { kind: ExprKind::Block(..), .. }) | Node::Stmt(_))
-        })
-        .map_or(false, |(id, _)| {
-            is_expn_of(cx.tcx.hir().span(id), "if_chain") != Some(if_chain_span)
-        })
-}
-
-/// Checks a trailing slice of statements and expression of a `Block` to see if they are part
-/// of the `then {..}` portion of an `if_chain!`
-fn is_if_chain_then(stmts: &[Stmt<'_>], expr: Option<&Expr<'_>>, if_chain_span: Span) -> bool {
-    let span = if let [stmt, ..] = stmts {
-        stmt.span
-    } else if let Some(expr) = expr {
-        expr.span
-    } else {
-        // empty `then {}`
-        return true;
-    };
-    is_expn_of(span, "if_chain").map_or(true, |span| span != if_chain_span)
-}
-
-/// Creates a `Span` for `let x = ..;` in an `if_chain!` call.
-fn if_chain_local_span(cx: &LateContext<'_>, local: &Local<'_>, if_chain_span: Span) -> Span {
-    let mut span = local.pat.span;
-    if let Some(init) = local.init {
-        span = span.to(init.span);
-    }
-    span.adjust(if_chain_span.ctxt().outer_expn());
-    let sm = cx.sess().source_map();
-    let span = sm.span_extend_to_prev_str(span, "let", false, true).unwrap_or(span);
-    let span = sm.span_extend_to_next_char(span, ';', false);
-    Span::new(
-        span.lo() - BytePos(3),
-        span.hi() + BytePos(1),
-        span.ctxt(),
-        span.parent(),
-    )
-}
-
-declare_lint_pass!(MsrvAttrImpl => [MISSING_MSRV_ATTR_IMPL]);
-
-impl LateLintPass<'_> for MsrvAttrImpl {
-    fn check_item(&mut self, cx: &LateContext<'_>, item: &hir::Item<'_>) {
-        if_chain! {
-            if let hir::ItemKind::Impl(hir::Impl {
-                of_trait: Some(lint_pass_trait_ref),
-                self_ty,
-                items,
-                ..
-            }) = &item.kind;
-            if let Some(lint_pass_trait_def_id) = lint_pass_trait_ref.trait_def_id();
-            let is_late_pass = match_def_path(cx, lint_pass_trait_def_id, &paths::LATE_LINT_PASS);
-            if is_late_pass || match_def_path(cx, lint_pass_trait_def_id, &paths::EARLY_LINT_PASS);
-            let self_ty = hir_ty_to_ty(cx.tcx, self_ty);
-            if let ty::Adt(self_ty_def, _) = self_ty.kind();
-            if self_ty_def.is_struct();
-            if self_ty_def.all_fields().any(|f| {
-                cx.tcx
-                    .type_of(f.did)
-                    .walk()
-                    .filter(|t| matches!(t.unpack(), GenericArgKind::Type(_)))
-                    .any(|t| match_type(cx, t.expect_ty(), &paths::RUSTC_VERSION))
-            });
-            if !items.iter().any(|item| item.ident.name == sym!(enter_lint_attrs));
-            then {
-                let context = if is_late_pass { "LateContext" } else { "EarlyContext" };
-                let lint_pass = if is_late_pass { "LateLintPass" } else { "EarlyLintPass" };
-                let span = cx.sess().source_map().span_through_char(item.span, '{');
-                span_lint_and_sugg(
-                    cx,
-                    MISSING_MSRV_ATTR_IMPL,
-                    span,
-                    &format!("`extract_msrv_attr!` macro missing from `{lint_pass}` implementation"),
-                    &format!("add `extract_msrv_attr!({context})` to the `{lint_pass}` implementation"),
-                    format!("{}\n    extract_msrv_attr!({context});", snippet(cx, span, "..")),
-                    Applicability::MachineApplicable,
-                );
-            }
-        }
-    }
-}
+pub mod msrv_attr_impl;
+pub mod outer_expn_data_pass;
+pub mod produce_ice;
+pub mod unnecessary_def_path;
diff --git a/clippy_lints/src/utils/internal_lints/clippy_lints_internal.rs b/clippy_lints/src/utils/internal_lints/clippy_lints_internal.rs
new file mode 100644
index 00000000000..da9514dd15e
--- /dev/null
+++ b/clippy_lints/src/utils/internal_lints/clippy_lints_internal.rs
@@ -0,0 +1,49 @@
+use clippy_utils::diagnostics::span_lint;
+use rustc_ast::ast::{Crate, ItemKind, ModKind};
+use rustc_lint::{EarlyContext, EarlyLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for various things we like to keep tidy in clippy.
+    ///
+    /// ### Why is this bad?
+    /// We like to pretend we're an example of tidy code.
+    ///
+    /// ### Example
+    /// Wrong ordering of the util::paths constants.
+    pub CLIPPY_LINTS_INTERNAL,
+    internal,
+    "various things that will negatively affect your clippy experience"
+}
+
+declare_lint_pass!(ClippyLintsInternal => [CLIPPY_LINTS_INTERNAL]);
+
+impl EarlyLintPass for ClippyLintsInternal {
+    fn check_crate(&mut self, cx: &EarlyContext<'_>, krate: &Crate) {
+        if let Some(utils) = krate.items.iter().find(|item| item.ident.name.as_str() == "utils") {
+            if let ItemKind::Mod(_, ModKind::Loaded(ref items, ..)) = utils.kind {
+                if let Some(paths) = items.iter().find(|item| item.ident.name.as_str() == "paths") {
+                    if let ItemKind::Mod(_, ModKind::Loaded(ref items, ..)) = paths.kind {
+                        let mut last_name: Option<&str> = None;
+                        for item in items {
+                            let name = item.ident.as_str();
+                            if let Some(last_name) = last_name {
+                                if *last_name > *name {
+                                    span_lint(
+                                        cx,
+                                        CLIPPY_LINTS_INTERNAL,
+                                        item.span,
+                                        "this constant should be before the previous constant due to lexical \
+                                         ordering",
+                                    );
+                                }
+                            }
+                            last_name = Some(name);
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/clippy_lints/src/utils/internal_lints/collapsible_calls.rs b/clippy_lints/src/utils/internal_lints/collapsible_calls.rs
new file mode 100644
index 00000000000..c9089aecfa5
--- /dev/null
+++ b/clippy_lints/src/utils/internal_lints/collapsible_calls.rs
@@ -0,0 +1,240 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet;
+use clippy_utils::{is_expr_path_def_path, is_lint_allowed, peel_blocks_with_stmt, SpanlessEq};
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir as hir;
+use rustc_hir::{Closure, Expr, ExprKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+use std::borrow::{Borrow, Cow};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Lints `span_lint_and_then` function calls, where the
+    /// closure argument has only one statement and that statement is a method
+    /// call to `span_suggestion`, `span_help`, `span_note` (using the same
+    /// span), `help` or `note`.
+    ///
+    /// These usages of `span_lint_and_then` should be replaced with one of the
+    /// wrapper functions `span_lint_and_sugg`, span_lint_and_help`, or
+    /// `span_lint_and_note`.
+    ///
+    /// ### Why is this bad?
+    /// Using the wrapper `span_lint_and_*` functions, is more
+    /// convenient, readable and less error prone.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// span_lint_and_then(cx, TEST_LINT, expr.span, lint_msg, |diag| {
+    ///     diag.span_suggestion(
+    ///         expr.span,
+    ///         help_msg,
+    ///         sugg.to_string(),
+    ///         Applicability::MachineApplicable,
+    ///     );
+    /// });
+    /// span_lint_and_then(cx, TEST_LINT, expr.span, lint_msg, |diag| {
+    ///     diag.span_help(expr.span, help_msg);
+    /// });
+    /// span_lint_and_then(cx, TEST_LINT, expr.span, lint_msg, |diag| {
+    ///     diag.help(help_msg);
+    /// });
+    /// span_lint_and_then(cx, TEST_LINT, expr.span, lint_msg, |diag| {
+    ///     diag.span_note(expr.span, note_msg);
+    /// });
+    /// span_lint_and_then(cx, TEST_LINT, expr.span, lint_msg, |diag| {
+    ///     diag.note(note_msg);
+    /// });
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust,ignore
+    /// span_lint_and_sugg(
+    ///     cx,
+    ///     TEST_LINT,
+    ///     expr.span,
+    ///     lint_msg,
+    ///     help_msg,
+    ///     sugg.to_string(),
+    ///     Applicability::MachineApplicable,
+    /// );
+    /// span_lint_and_help(cx, TEST_LINT, expr.span, lint_msg, Some(expr.span), help_msg);
+    /// span_lint_and_help(cx, TEST_LINT, expr.span, lint_msg, None, help_msg);
+    /// span_lint_and_note(cx, TEST_LINT, expr.span, lint_msg, Some(expr.span), note_msg);
+    /// span_lint_and_note(cx, TEST_LINT, expr.span, lint_msg, None, note_msg);
+    /// ```
+    pub COLLAPSIBLE_SPAN_LINT_CALLS,
+    internal,
+    "found collapsible `span_lint_and_then` calls"
+}
+
+declare_lint_pass!(CollapsibleCalls => [COLLAPSIBLE_SPAN_LINT_CALLS]);
+
+impl<'tcx> LateLintPass<'tcx> for CollapsibleCalls {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
+        if is_lint_allowed(cx, COLLAPSIBLE_SPAN_LINT_CALLS, expr.hir_id) {
+            return;
+        }
+
+        if_chain! {
+            if let ExprKind::Call(func, and_then_args) = expr.kind;
+            if is_expr_path_def_path(cx, func, &["clippy_utils", "diagnostics", "span_lint_and_then"]);
+            if and_then_args.len() == 5;
+            if let ExprKind::Closure(&Closure { body, .. }) = &and_then_args[4].kind;
+            let body = cx.tcx.hir().body(body);
+            let only_expr = peel_blocks_with_stmt(body.value);
+            if let ExprKind::MethodCall(ps, recv, span_call_args, _) = &only_expr.kind;
+            if let ExprKind::Path(..) = recv.kind;
+            then {
+                let and_then_snippets = get_and_then_snippets(cx, and_then_args);
+                let mut sle = SpanlessEq::new(cx).deny_side_effects();
+                match ps.ident.as_str() {
+                    "span_suggestion" if sle.eq_expr(&and_then_args[2], &span_call_args[0]) => {
+                        suggest_suggestion(cx, expr, &and_then_snippets, &span_suggestion_snippets(cx, span_call_args));
+                    },
+                    "span_help" if sle.eq_expr(&and_then_args[2], &span_call_args[0]) => {
+                        let help_snippet = snippet(cx, span_call_args[1].span, r#""...""#);
+                        suggest_help(cx, expr, &and_then_snippets, help_snippet.borrow(), true);
+                    },
+                    "span_note" if sle.eq_expr(&and_then_args[2], &span_call_args[0]) => {
+                        let note_snippet = snippet(cx, span_call_args[1].span, r#""...""#);
+                        suggest_note(cx, expr, &and_then_snippets, note_snippet.borrow(), true);
+                    },
+                    "help" => {
+                        let help_snippet = snippet(cx, span_call_args[0].span, r#""...""#);
+                        suggest_help(cx, expr, &and_then_snippets, help_snippet.borrow(), false);
+                    }
+                    "note" => {
+                        let note_snippet = snippet(cx, span_call_args[0].span, r#""...""#);
+                        suggest_note(cx, expr, &and_then_snippets, note_snippet.borrow(), false);
+                    }
+                    _  => (),
+                }
+            }
+        }
+    }
+}
+
+struct AndThenSnippets<'a> {
+    cx: Cow<'a, str>,
+    lint: Cow<'a, str>,
+    span: Cow<'a, str>,
+    msg: Cow<'a, str>,
+}
+
+fn get_and_then_snippets<'a, 'hir>(cx: &LateContext<'_>, and_then_snippets: &'hir [Expr<'hir>]) -> AndThenSnippets<'a> {
+    let cx_snippet = snippet(cx, and_then_snippets[0].span, "cx");
+    let lint_snippet = snippet(cx, and_then_snippets[1].span, "..");
+    let span_snippet = snippet(cx, and_then_snippets[2].span, "span");
+    let msg_snippet = snippet(cx, and_then_snippets[3].span, r#""...""#);
+
+    AndThenSnippets {
+        cx: cx_snippet,
+        lint: lint_snippet,
+        span: span_snippet,
+        msg: msg_snippet,
+    }
+}
+
+struct SpanSuggestionSnippets<'a> {
+    help: Cow<'a, str>,
+    sugg: Cow<'a, str>,
+    applicability: Cow<'a, str>,
+}
+
+fn span_suggestion_snippets<'a, 'hir>(
+    cx: &LateContext<'_>,
+    span_call_args: &'hir [Expr<'hir>],
+) -> SpanSuggestionSnippets<'a> {
+    let help_snippet = snippet(cx, span_call_args[1].span, r#""...""#);
+    let sugg_snippet = snippet(cx, span_call_args[2].span, "..");
+    let applicability_snippet = snippet(cx, span_call_args[3].span, "Applicability::MachineApplicable");
+
+    SpanSuggestionSnippets {
+        help: help_snippet,
+        sugg: sugg_snippet,
+        applicability: applicability_snippet,
+    }
+}
+
+fn suggest_suggestion(
+    cx: &LateContext<'_>,
+    expr: &Expr<'_>,
+    and_then_snippets: &AndThenSnippets<'_>,
+    span_suggestion_snippets: &SpanSuggestionSnippets<'_>,
+) {
+    span_lint_and_sugg(
+        cx,
+        COLLAPSIBLE_SPAN_LINT_CALLS,
+        expr.span,
+        "this call is collapsible",
+        "collapse into",
+        format!(
+            "span_lint_and_sugg({}, {}, {}, {}, {}, {}, {})",
+            and_then_snippets.cx,
+            and_then_snippets.lint,
+            and_then_snippets.span,
+            and_then_snippets.msg,
+            span_suggestion_snippets.help,
+            span_suggestion_snippets.sugg,
+            span_suggestion_snippets.applicability
+        ),
+        Applicability::MachineApplicable,
+    );
+}
+
+fn suggest_help(
+    cx: &LateContext<'_>,
+    expr: &Expr<'_>,
+    and_then_snippets: &AndThenSnippets<'_>,
+    help: &str,
+    with_span: bool,
+) {
+    let option_span = if with_span {
+        format!("Some({})", and_then_snippets.span)
+    } else {
+        "None".to_string()
+    };
+
+    span_lint_and_sugg(
+        cx,
+        COLLAPSIBLE_SPAN_LINT_CALLS,
+        expr.span,
+        "this call is collapsible",
+        "collapse into",
+        format!(
+            "span_lint_and_help({}, {}, {}, {}, {}, {help})",
+            and_then_snippets.cx, and_then_snippets.lint, and_then_snippets.span, and_then_snippets.msg, &option_span,
+        ),
+        Applicability::MachineApplicable,
+    );
+}
+
+fn suggest_note(
+    cx: &LateContext<'_>,
+    expr: &Expr<'_>,
+    and_then_snippets: &AndThenSnippets<'_>,
+    note: &str,
+    with_span: bool,
+) {
+    let note_span = if with_span {
+        format!("Some({})", and_then_snippets.span)
+    } else {
+        "None".to_string()
+    };
+
+    span_lint_and_sugg(
+        cx,
+        COLLAPSIBLE_SPAN_LINT_CALLS,
+        expr.span,
+        "this call is collapsible",
+        "collapse into",
+        format!(
+            "span_lint_and_note({}, {}, {}, {}, {note_span}, {note})",
+            and_then_snippets.cx, and_then_snippets.lint, and_then_snippets.span, and_then_snippets.msg,
+        ),
+        Applicability::MachineApplicable,
+    );
+}
diff --git a/clippy_lints/src/utils/internal_lints/compiler_lint_functions.rs b/clippy_lints/src/utils/internal_lints/compiler_lint_functions.rs
new file mode 100644
index 00000000000..67357a5cb6b
--- /dev/null
+++ b/clippy_lints/src/utils/internal_lints/compiler_lint_functions.rs
@@ -0,0 +1,78 @@
+use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::ty::match_type;
+use clippy_utils::{is_lint_allowed, paths};
+use if_chain::if_chain;
+use rustc_data_structures::fx::FxHashMap;
+use rustc_hir::{Expr, ExprKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for calls to `cx.span_lint*` and suggests to use the `utils::*`
+    /// variant of the function.
+    ///
+    /// ### Why is this bad?
+    /// The `utils::*` variants also add a link to the Clippy documentation to the
+    /// warning/error messages.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// cx.span_lint(LINT_NAME, "message");
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust,ignore
+    /// utils::span_lint(cx, LINT_NAME, "message");
+    /// ```
+    pub COMPILER_LINT_FUNCTIONS,
+    internal,
+    "usage of the lint functions of the compiler instead of the utils::* variant"
+}
+
+#[derive(Clone, Default)]
+pub struct CompilerLintFunctions {
+    map: FxHashMap<&'static str, &'static str>,
+}
+
+impl CompilerLintFunctions {
+    #[must_use]
+    pub fn new() -> Self {
+        let mut map = FxHashMap::default();
+        map.insert("span_lint", "utils::span_lint");
+        map.insert("struct_span_lint", "utils::span_lint");
+        map.insert("lint", "utils::span_lint");
+        map.insert("span_lint_note", "utils::span_lint_and_note");
+        map.insert("span_lint_help", "utils::span_lint_and_help");
+        Self { map }
+    }
+}
+
+impl_lint_pass!(CompilerLintFunctions => [COMPILER_LINT_FUNCTIONS]);
+
+impl<'tcx> LateLintPass<'tcx> for CompilerLintFunctions {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        if is_lint_allowed(cx, COMPILER_LINT_FUNCTIONS, expr.hir_id) {
+            return;
+        }
+
+        if_chain! {
+            if let ExprKind::MethodCall(path, self_arg, _, _) = &expr.kind;
+            let fn_name = path.ident;
+            if let Some(sugg) = self.map.get(fn_name.as_str());
+            let ty = cx.typeck_results().expr_ty(self_arg).peel_refs();
+            if match_type(cx, ty, &paths::EARLY_CONTEXT)
+                || match_type(cx, ty, &paths::LATE_CONTEXT);
+            then {
+                span_lint_and_help(
+                    cx,
+                    COMPILER_LINT_FUNCTIONS,
+                    path.ident.span,
+                    "usage of a compiler lint function",
+                    None,
+                    &format!("please use the Clippy variant of this function: `{sugg}`"),
+                );
+            }
+        }
+    }
+}
diff --git a/clippy_lints/src/utils/internal_lints/if_chain_style.rs b/clippy_lints/src/utils/internal_lints/if_chain_style.rs
new file mode 100644
index 00000000000..a863fdc9d50
--- /dev/null
+++ b/clippy_lints/src/utils/internal_lints/if_chain_style.rs
@@ -0,0 +1,161 @@
+use clippy_utils::diagnostics::{span_lint, span_lint_and_then};
+use clippy_utils::{higher, is_else_clause, is_expn_of};
+use if_chain::if_chain;
+use rustc_hir as hir;
+use rustc_hir::{BinOpKind, Block, Expr, ExprKind, HirId, Local, Node, Stmt, StmtKind};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::{BytePos, Span};
+
+declare_clippy_lint! {
+    /// Finds unidiomatic usage of `if_chain!`
+    pub IF_CHAIN_STYLE,
+    internal,
+    "non-idiomatic `if_chain!` usage"
+}
+
+declare_lint_pass!(IfChainStyle => [IF_CHAIN_STYLE]);
+
+impl<'tcx> LateLintPass<'tcx> for IfChainStyle {
+    fn check_block(&mut self, cx: &LateContext<'tcx>, block: &'tcx hir::Block<'_>) {
+        let (local, after, if_chain_span) = if_chain! {
+            if let [Stmt { kind: StmtKind::Local(local), .. }, after @ ..] = block.stmts;
+            if let Some(if_chain_span) = is_expn_of(block.span, "if_chain");
+            then { (local, after, if_chain_span) } else { return }
+        };
+        if is_first_if_chain_expr(cx, block.hir_id, if_chain_span) {
+            span_lint(
+                cx,
+                IF_CHAIN_STYLE,
+                if_chain_local_span(cx, local, if_chain_span),
+                "`let` expression should be above the `if_chain!`",
+            );
+        } else if local.span.ctxt() == block.span.ctxt() && is_if_chain_then(after, block.expr, if_chain_span) {
+            span_lint(
+                cx,
+                IF_CHAIN_STYLE,
+                if_chain_local_span(cx, local, if_chain_span),
+                "`let` expression should be inside `then { .. }`",
+            );
+        }
+    }
+
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
+        let (cond, then, els) = if let Some(higher::IfOrIfLet { cond, r#else, then }) = higher::IfOrIfLet::hir(expr) {
+            (cond, then, r#else.is_some())
+        } else {
+            return;
+        };
+        let ExprKind::Block(then_block, _) = then.kind else { return };
+        let if_chain_span = is_expn_of(expr.span, "if_chain");
+        if !els {
+            check_nested_if_chains(cx, expr, then_block, if_chain_span);
+        }
+        let Some(if_chain_span) = if_chain_span else { return };
+        // check for `if a && b;`
+        if_chain! {
+            if let ExprKind::Binary(op, _, _) = cond.kind;
+            if op.node == BinOpKind::And;
+            if cx.sess().source_map().is_multiline(cond.span);
+            then {
+                span_lint(cx, IF_CHAIN_STYLE, cond.span, "`if a && b;` should be `if a; if b;`");
+            }
+        }
+        if is_first_if_chain_expr(cx, expr.hir_id, if_chain_span)
+            && is_if_chain_then(then_block.stmts, then_block.expr, if_chain_span)
+        {
+            span_lint(cx, IF_CHAIN_STYLE, expr.span, "`if_chain!` only has one `if`");
+        }
+    }
+}
+
+fn check_nested_if_chains(
+    cx: &LateContext<'_>,
+    if_expr: &Expr<'_>,
+    then_block: &Block<'_>,
+    if_chain_span: Option<Span>,
+) {
+    #[rustfmt::skip]
+    let (head, tail) = match *then_block {
+        Block { stmts, expr: Some(tail), .. } => (stmts, tail),
+        Block {
+            stmts: &[
+                ref head @ ..,
+                Stmt { kind: StmtKind::Expr(tail) | StmtKind::Semi(tail), .. }
+            ],
+            ..
+        } => (head, tail),
+        _ => return,
+    };
+    if_chain! {
+        if let Some(higher::IfOrIfLet { r#else: None, .. }) = higher::IfOrIfLet::hir(tail);
+        let sm = cx.sess().source_map();
+        if head
+            .iter()
+            .all(|stmt| matches!(stmt.kind, StmtKind::Local(..)) && !sm.is_multiline(stmt.span));
+        if if_chain_span.is_some() || !is_else_clause(cx.tcx, if_expr);
+        then {} else { return }
+    }
+    let (span, msg) = match (if_chain_span, is_expn_of(tail.span, "if_chain")) {
+        (None, Some(_)) => (if_expr.span, "this `if` can be part of the inner `if_chain!`"),
+        (Some(_), None) => (tail.span, "this `if` can be part of the outer `if_chain!`"),
+        (Some(a), Some(b)) if a != b => (b, "this `if_chain!` can be merged with the outer `if_chain!`"),
+        _ => return,
+    };
+    span_lint_and_then(cx, IF_CHAIN_STYLE, span, msg, |diag| {
+        let (span, msg) = match head {
+            [] => return,
+            [stmt] => (stmt.span, "this `let` statement can also be in the `if_chain!`"),
+            [a, .., b] => (
+                a.span.to(b.span),
+                "these `let` statements can also be in the `if_chain!`",
+            ),
+        };
+        diag.span_help(span, msg);
+    });
+}
+
+fn is_first_if_chain_expr(cx: &LateContext<'_>, hir_id: HirId, if_chain_span: Span) -> bool {
+    cx.tcx
+        .hir()
+        .parent_iter(hir_id)
+        .find(|(_, node)| {
+            #[rustfmt::skip]
+            !matches!(node, Node::Expr(Expr { kind: ExprKind::Block(..), .. }) | Node::Stmt(_))
+        })
+        .map_or(false, |(id, _)| {
+            is_expn_of(cx.tcx.hir().span(id), "if_chain") != Some(if_chain_span)
+        })
+}
+
+/// Checks a trailing slice of statements and expression of a `Block` to see if they are part
+/// of the `then {..}` portion of an `if_chain!`
+fn is_if_chain_then(stmts: &[Stmt<'_>], expr: Option<&Expr<'_>>, if_chain_span: Span) -> bool {
+    let span = if let [stmt, ..] = stmts {
+        stmt.span
+    } else if let Some(expr) = expr {
+        expr.span
+    } else {
+        // empty `then {}`
+        return true;
+    };
+    is_expn_of(span, "if_chain").map_or(true, |span| span != if_chain_span)
+}
+
+/// Creates a `Span` for `let x = ..;` in an `if_chain!` call.
+fn if_chain_local_span(cx: &LateContext<'_>, local: &Local<'_>, if_chain_span: Span) -> Span {
+    let mut span = local.pat.span;
+    if let Some(init) = local.init {
+        span = span.to(init.span);
+    }
+    span.adjust(if_chain_span.ctxt().outer_expn());
+    let sm = cx.sess().source_map();
+    let span = sm.span_extend_to_prev_str(span, "let", false, true).unwrap_or(span);
+    let span = sm.span_extend_to_next_char(span, ';', false);
+    Span::new(
+        span.lo() - BytePos(3),
+        span.hi() + BytePos(1),
+        span.ctxt(),
+        span.parent(),
+    )
+}
diff --git a/clippy_lints/src/utils/internal_lints/interning_defined_symbol.rs b/clippy_lints/src/utils/internal_lints/interning_defined_symbol.rs
new file mode 100644
index 00000000000..096b601572b
--- /dev/null
+++ b/clippy_lints/src/utils/internal_lints/interning_defined_symbol.rs
@@ -0,0 +1,239 @@
+use clippy_utils::consts::{constant_simple, Constant};
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet;
+use clippy_utils::ty::match_type;
+use clippy_utils::{def_path_res, is_expn_of, match_def_path, paths};
+use if_chain::if_chain;
+use rustc_data_structures::fx::FxHashMap;
+use rustc_errors::Applicability;
+use rustc_hir::def::{DefKind, Res};
+use rustc_hir::def_id::DefId;
+use rustc_hir::{BinOpKind, Expr, ExprKind, UnOp};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::mir::interpret::ConstValue;
+use rustc_middle::ty::{self};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::symbol::Symbol;
+
+use std::borrow::Cow;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for interning symbols that have already been pre-interned and defined as constants.
+    ///
+    /// ### Why is this bad?
+    /// It's faster and easier to use the symbol constant.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// let _ = sym!(f32);
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust,ignore
+    /// let _ = sym::f32;
+    /// ```
+    pub INTERNING_DEFINED_SYMBOL,
+    internal,
+    "interning a symbol that is pre-interned and defined as a constant"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for unnecessary conversion from Symbol to a string.
+    ///
+    /// ### Why is this bad?
+    /// It's faster use symbols directly instead of strings.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// symbol.as_str() == "clippy";
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust,ignore
+    /// symbol == sym::clippy;
+    /// ```
+    pub UNNECESSARY_SYMBOL_STR,
+    internal,
+    "unnecessary conversion between Symbol and string"
+}
+
+#[derive(Default)]
+pub struct InterningDefinedSymbol {
+    // Maps the symbol value to the constant DefId.
+    symbol_map: FxHashMap<u32, DefId>,
+}
+
+impl_lint_pass!(InterningDefinedSymbol => [INTERNING_DEFINED_SYMBOL, UNNECESSARY_SYMBOL_STR]);
+
+impl<'tcx> LateLintPass<'tcx> for InterningDefinedSymbol {
+    fn check_crate(&mut self, cx: &LateContext<'_>) {
+        if !self.symbol_map.is_empty() {
+            return;
+        }
+
+        for &module in &[&paths::KW_MODULE, &paths::SYM_MODULE] {
+            if let Some(def_id) = def_path_res(cx, module, None).opt_def_id() {
+                for item in cx.tcx.module_children(def_id).iter() {
+                    if_chain! {
+                        if let Res::Def(DefKind::Const, item_def_id) = item.res;
+                        let ty = cx.tcx.type_of(item_def_id);
+                        if match_type(cx, ty, &paths::SYMBOL);
+                        if let Ok(ConstValue::Scalar(value)) = cx.tcx.const_eval_poly(item_def_id);
+                        if let Ok(value) = value.to_u32();
+                        then {
+                            self.symbol_map.insert(value, item_def_id);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        if_chain! {
+            if let ExprKind::Call(func, [arg]) = &expr.kind;
+            if let ty::FnDef(def_id, _) = cx.typeck_results().expr_ty(func).kind();
+            if match_def_path(cx, *def_id, &paths::SYMBOL_INTERN);
+            if let Some(Constant::Str(arg)) = constant_simple(cx, cx.typeck_results(), arg);
+            let value = Symbol::intern(&arg).as_u32();
+            if let Some(&def_id) = self.symbol_map.get(&value);
+            then {
+                span_lint_and_sugg(
+                    cx,
+                    INTERNING_DEFINED_SYMBOL,
+                    is_expn_of(expr.span, "sym").unwrap_or(expr.span),
+                    "interning a defined symbol",
+                    "try",
+                    cx.tcx.def_path_str(def_id),
+                    Applicability::MachineApplicable,
+                );
+            }
+        }
+        if let ExprKind::Binary(op, left, right) = expr.kind {
+            if matches!(op.node, BinOpKind::Eq | BinOpKind::Ne) {
+                let data = [
+                    (left, self.symbol_str_expr(left, cx)),
+                    (right, self.symbol_str_expr(right, cx)),
+                ];
+                match data {
+                    // both operands are a symbol string
+                    [(_, Some(left)), (_, Some(right))] => {
+                        span_lint_and_sugg(
+                            cx,
+                            UNNECESSARY_SYMBOL_STR,
+                            expr.span,
+                            "unnecessary `Symbol` to string conversion",
+                            "try",
+                            format!(
+                                "{} {} {}",
+                                left.as_symbol_snippet(cx),
+                                op.node.as_str(),
+                                right.as_symbol_snippet(cx),
+                            ),
+                            Applicability::MachineApplicable,
+                        );
+                    },
+                    // one of the operands is a symbol string
+                    [(expr, Some(symbol)), _] | [_, (expr, Some(symbol))] => {
+                        // creating an owned string for comparison
+                        if matches!(symbol, SymbolStrExpr::Expr { is_to_owned: true, .. }) {
+                            span_lint_and_sugg(
+                                cx,
+                                UNNECESSARY_SYMBOL_STR,
+                                expr.span,
+                                "unnecessary string allocation",
+                                "try",
+                                format!("{}.as_str()", symbol.as_symbol_snippet(cx)),
+                                Applicability::MachineApplicable,
+                            );
+                        }
+                    },
+                    // nothing found
+                    [(_, None), (_, None)] => {},
+                }
+            }
+        }
+    }
+}
+
+impl InterningDefinedSymbol {
+    fn symbol_str_expr<'tcx>(&self, expr: &'tcx Expr<'tcx>, cx: &LateContext<'tcx>) -> Option<SymbolStrExpr<'tcx>> {
+        static IDENT_STR_PATHS: &[&[&str]] = &[&paths::IDENT_AS_STR, &paths::TO_STRING_METHOD];
+        static SYMBOL_STR_PATHS: &[&[&str]] = &[
+            &paths::SYMBOL_AS_STR,
+            &paths::SYMBOL_TO_IDENT_STRING,
+            &paths::TO_STRING_METHOD,
+        ];
+        let call = if_chain! {
+            if let ExprKind::AddrOf(_, _, e) = expr.kind;
+            if let ExprKind::Unary(UnOp::Deref, e) = e.kind;
+            then { e } else { expr }
+        };
+        if_chain! {
+            // is a method call
+            if let ExprKind::MethodCall(_, item, [], _) = call.kind;
+            if let Some(did) = cx.typeck_results().type_dependent_def_id(call.hir_id);
+            let ty = cx.typeck_results().expr_ty(item);
+            // ...on either an Ident or a Symbol
+            if let Some(is_ident) = if match_type(cx, ty, &paths::SYMBOL) {
+                Some(false)
+            } else if match_type(cx, ty, &paths::IDENT) {
+                Some(true)
+            } else {
+                None
+            };
+            // ...which converts it to a string
+            let paths = if is_ident { IDENT_STR_PATHS } else { SYMBOL_STR_PATHS };
+            if let Some(path) = paths.iter().find(|path| match_def_path(cx, did, path));
+            then {
+                let is_to_owned = path.last().unwrap().ends_with("string");
+                return Some(SymbolStrExpr::Expr {
+                    item,
+                    is_ident,
+                    is_to_owned,
+                });
+            }
+        }
+        // is a string constant
+        if let Some(Constant::Str(s)) = constant_simple(cx, cx.typeck_results(), expr) {
+            let value = Symbol::intern(&s).as_u32();
+            // ...which matches a symbol constant
+            if let Some(&def_id) = self.symbol_map.get(&value) {
+                return Some(SymbolStrExpr::Const(def_id));
+            }
+        }
+        None
+    }
+}
+
+enum SymbolStrExpr<'tcx> {
+    /// a string constant with a corresponding symbol constant
+    Const(DefId),
+    /// a "symbol to string" expression like `symbol.as_str()`
+    Expr {
+        /// part that evaluates to `Symbol` or `Ident`
+        item: &'tcx Expr<'tcx>,
+        is_ident: bool,
+        /// whether an owned `String` is created like `to_ident_string()`
+        is_to_owned: bool,
+    },
+}
+
+impl<'tcx> SymbolStrExpr<'tcx> {
+    /// Returns a snippet that evaluates to a `Symbol` and is const if possible
+    fn as_symbol_snippet(&self, cx: &LateContext<'_>) -> Cow<'tcx, str> {
+        match *self {
+            Self::Const(def_id) => cx.tcx.def_path_str(def_id).into(),
+            Self::Expr { item, is_ident, .. } => {
+                let mut snip = snippet(cx, item.span.source_callsite(), "..");
+                if is_ident {
+                    // get `Ident.name`
+                    snip.to_mut().push_str(".name");
+                }
+                snip
+            },
+        }
+    }
+}
diff --git a/clippy_lints/src/utils/internal_lints/invalid_paths.rs b/clippy_lints/src/utils/internal_lints/invalid_paths.rs
new file mode 100644
index 00000000000..57eb3f49d06
--- /dev/null
+++ b/clippy_lints/src/utils/internal_lints/invalid_paths.rs
@@ -0,0 +1,105 @@
+use clippy_utils::consts::{constant_simple, Constant};
+use clippy_utils::def_path_res;
+use clippy_utils::diagnostics::span_lint;
+use if_chain::if_chain;
+use rustc_hir as hir;
+use rustc_hir::def::{DefKind, Res};
+use rustc_hir::Item;
+use rustc_hir_analysis::hir_ty_to_ty;
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::{self, fast_reject::SimplifiedTypeGen, FloatTy};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::symbol::Symbol;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks the paths module for invalid paths.
+    ///
+    /// ### Why is this bad?
+    /// It indicates a bug in the code.
+    ///
+    /// ### Example
+    /// None.
+    pub INVALID_PATHS,
+    internal,
+    "invalid path"
+}
+
+// This is not a complete resolver for paths. It works on all the paths currently used in the paths
+// module.  That's all it does and all it needs to do.
+pub fn check_path(cx: &LateContext<'_>, path: &[&str]) -> bool {
+    if def_path_res(cx, path, None) != Res::Err {
+        return true;
+    }
+
+    // Some implementations can't be found by `path_to_res`, particularly inherent
+    // implementations of native types. Check lang items.
+    let path_syms: Vec<_> = path.iter().map(|p| Symbol::intern(p)).collect();
+    let lang_items = cx.tcx.lang_items();
+    // This list isn't complete, but good enough for our current list of paths.
+    let incoherent_impls = [
+        SimplifiedTypeGen::FloatSimplifiedType(FloatTy::F32),
+        SimplifiedTypeGen::FloatSimplifiedType(FloatTy::F64),
+        SimplifiedTypeGen::SliceSimplifiedType,
+        SimplifiedTypeGen::StrSimplifiedType,
+    ]
+    .iter()
+    .flat_map(|&ty| cx.tcx.incoherent_impls(ty));
+    for item_def_id in lang_items.items().iter().flatten().chain(incoherent_impls) {
+        let lang_item_path = cx.get_def_path(*item_def_id);
+        if path_syms.starts_with(&lang_item_path) {
+            if let [item] = &path_syms[lang_item_path.len()..] {
+                if matches!(
+                    cx.tcx.def_kind(*item_def_id),
+                    DefKind::Mod | DefKind::Enum | DefKind::Trait
+                ) {
+                    for child in cx.tcx.module_children(*item_def_id) {
+                        if child.ident.name == *item {
+                            return true;
+                        }
+                    }
+                } else {
+                    for child in cx.tcx.associated_item_def_ids(*item_def_id) {
+                        if cx.tcx.item_name(*child) == *item {
+                            return true;
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    false
+}
+
+declare_lint_pass!(InvalidPaths => [INVALID_PATHS]);
+
+impl<'tcx> LateLintPass<'tcx> for InvalidPaths {
+    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
+        let local_def_id = &cx.tcx.parent_module(item.hir_id());
+        let mod_name = &cx.tcx.item_name(local_def_id.to_def_id());
+        if_chain! {
+            if mod_name.as_str() == "paths";
+            if let hir::ItemKind::Const(ty, body_id) = item.kind;
+            let ty = hir_ty_to_ty(cx.tcx, ty);
+            if let ty::Array(el_ty, _) = &ty.kind();
+            if let ty::Ref(_, el_ty, _) = &el_ty.kind();
+            if el_ty.is_str();
+            let body = cx.tcx.hir().body(body_id);
+            let typeck_results = cx.tcx.typeck_body(body_id);
+            if let Some(Constant::Vec(path)) = constant_simple(cx, typeck_results, body.value);
+            let path: Vec<&str> = path.iter().map(|x| {
+                    if let Constant::Str(s) = x {
+                        s.as_str()
+                    } else {
+                        // We checked the type of the constant above
+                        unreachable!()
+                    }
+                }).collect();
+            if !check_path(cx, &path[..]);
+            then {
+                span_lint(cx, INVALID_PATHS, item.span, "invalid path");
+            }
+        }
+    }
+}
diff --git a/clippy_lints/src/utils/internal_lints/lint_without_lint_pass.rs b/clippy_lints/src/utils/internal_lints/lint_without_lint_pass.rs
new file mode 100644
index 00000000000..06dfc6e4360
--- /dev/null
+++ b/clippy_lints/src/utils/internal_lints/lint_without_lint_pass.rs
@@ -0,0 +1,346 @@
+use crate::utils::internal_lints::metadata_collector::is_deprecated_lint;
+use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
+use clippy_utils::macros::root_macro_call_first_node;
+use clippy_utils::{is_lint_allowed, match_def_path, paths};
+use if_chain::if_chain;
+use rustc_ast as ast;
+use rustc_ast::ast::LitKind;
+use rustc_data_structures::fx::{FxHashMap, FxHashSet};
+use rustc_hir as hir;
+use rustc_hir::def::{DefKind, Res};
+use rustc_hir::hir_id::CRATE_HIR_ID;
+use rustc_hir::intravisit::Visitor;
+use rustc_hir::{ExprKind, HirId, Item, MutTy, Mutability, Path, TyKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::hir::nested_filter;
+use rustc_semver::RustcVersion;
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::source_map::Spanned;
+use rustc_span::symbol::Symbol;
+use rustc_span::{sym, Span};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Ensures every lint is associated to a `LintPass`.
+    ///
+    /// ### Why is this bad?
+    /// The compiler only knows lints via a `LintPass`. Without
+    /// putting a lint to a `LintPass::get_lints()`'s return, the compiler will not
+    /// know the name of the lint.
+    ///
+    /// ### Known problems
+    /// Only checks for lints associated using the
+    /// `declare_lint_pass!`, `impl_lint_pass!`, and `lint_array!` macros.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// declare_lint! { pub LINT_1, ... }
+    /// declare_lint! { pub LINT_2, ... }
+    /// declare_lint! { pub FORGOTTEN_LINT, ... }
+    /// // ...
+    /// declare_lint_pass!(Pass => [LINT_1, LINT_2]);
+    /// // missing FORGOTTEN_LINT
+    /// ```
+    pub LINT_WITHOUT_LINT_PASS,
+    internal,
+    "declaring a lint without associating it in a LintPass"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for cases of an auto-generated lint without an updated description,
+    /// i.e. `default lint description`.
+    ///
+    /// ### Why is this bad?
+    /// Indicates that the lint is not finished.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// declare_lint! { pub COOL_LINT, nursery, "default lint description" }
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust,ignore
+    /// declare_lint! { pub COOL_LINT, nursery, "a great new lint" }
+    /// ```
+    pub DEFAULT_LINT,
+    internal,
+    "found 'default lint description' in a lint declaration"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for invalid `clippy::version` attributes.
+    ///
+    /// Valid values are:
+    /// * "pre 1.29.0"
+    /// * any valid semantic version
+    pub INVALID_CLIPPY_VERSION_ATTRIBUTE,
+    internal,
+    "found an invalid `clippy::version` attribute"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for declared clippy lints without the `clippy::version` attribute.
+    ///
+    pub MISSING_CLIPPY_VERSION_ATTRIBUTE,
+    internal,
+    "found clippy lint without `clippy::version` attribute"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for cases of an auto-generated deprecated lint without an updated reason,
+    /// i.e. `"default deprecation note"`.
+    ///
+    /// ### Why is this bad?
+    /// Indicates that the documentation is incomplete.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// declare_deprecated_lint! {
+    ///     /// ### What it does
+    ///     /// Nothing. This lint has been deprecated.
+    ///     ///
+    ///     /// ### Deprecation reason
+    ///     /// TODO
+    ///     #[clippy::version = "1.63.0"]
+    ///     pub COOL_LINT,
+    ///     "default deprecation note"
+    /// }
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust,ignore
+    /// declare_deprecated_lint! {
+    ///     /// ### What it does
+    ///     /// Nothing. This lint has been deprecated.
+    ///     ///
+    ///     /// ### Deprecation reason
+    ///     /// This lint has been replaced by `cooler_lint`
+    ///     #[clippy::version = "1.63.0"]
+    ///     pub COOL_LINT,
+    ///     "this lint has been replaced by `cooler_lint`"
+    /// }
+    /// ```
+    pub DEFAULT_DEPRECATION_REASON,
+    internal,
+    "found 'default deprecation note' in a deprecated lint declaration"
+}
+
+#[derive(Clone, Debug, Default)]
+pub struct LintWithoutLintPass {
+    declared_lints: FxHashMap<Symbol, Span>,
+    registered_lints: FxHashSet<Symbol>,
+}
+
+impl_lint_pass!(LintWithoutLintPass => [DEFAULT_LINT, LINT_WITHOUT_LINT_PASS, INVALID_CLIPPY_VERSION_ATTRIBUTE, MISSING_CLIPPY_VERSION_ATTRIBUTE, DEFAULT_DEPRECATION_REASON]);
+
+impl<'tcx> LateLintPass<'tcx> for LintWithoutLintPass {
+    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
+        if is_lint_allowed(cx, DEFAULT_LINT, item.hir_id())
+            || is_lint_allowed(cx, DEFAULT_DEPRECATION_REASON, item.hir_id())
+        {
+            return;
+        }
+
+        if let hir::ItemKind::Static(ty, Mutability::Not, body_id) = item.kind {
+            let is_lint_ref_ty = is_lint_ref_type(cx, ty);
+            if is_deprecated_lint(cx, ty) || is_lint_ref_ty {
+                check_invalid_clippy_version_attribute(cx, item);
+
+                let expr = &cx.tcx.hir().body(body_id).value;
+                let fields;
+                if is_lint_ref_ty {
+                    if let ExprKind::AddrOf(_, _, inner_exp) = expr.kind
+                        && let ExprKind::Struct(_, struct_fields, _) = inner_exp.kind {
+                            fields = struct_fields;
+                    } else {
+                        return;
+                    }
+                } else if let ExprKind::Struct(_, struct_fields, _) = expr.kind {
+                    fields = struct_fields;
+                } else {
+                    return;
+                }
+
+                let field = fields
+                    .iter()
+                    .find(|f| f.ident.as_str() == "desc")
+                    .expect("lints must have a description field");
+
+                if let ExprKind::Lit(Spanned {
+                    node: LitKind::Str(ref sym, _),
+                    ..
+                }) = field.expr.kind
+                {
+                    let sym_str = sym.as_str();
+                    if is_lint_ref_ty {
+                        if sym_str == "default lint description" {
+                            span_lint(
+                                cx,
+                                DEFAULT_LINT,
+                                item.span,
+                                &format!("the lint `{}` has the default lint description", item.ident.name),
+                            );
+                        }
+
+                        self.declared_lints.insert(item.ident.name, item.span);
+                    } else if sym_str == "default deprecation note" {
+                        span_lint(
+                            cx,
+                            DEFAULT_DEPRECATION_REASON,
+                            item.span,
+                            &format!("the lint `{}` has the default deprecation reason", item.ident.name),
+                        );
+                    }
+                }
+            }
+        } else if let Some(macro_call) = root_macro_call_first_node(cx, item) {
+            if !matches!(
+                cx.tcx.item_name(macro_call.def_id).as_str(),
+                "impl_lint_pass" | "declare_lint_pass"
+            ) {
+                return;
+            }
+            if let hir::ItemKind::Impl(hir::Impl {
+                of_trait: None,
+                items: impl_item_refs,
+                ..
+            }) = item.kind
+            {
+                let mut collector = LintCollector {
+                    output: &mut self.registered_lints,
+                    cx,
+                };
+                let body_id = cx.tcx.hir().body_owned_by(
+                    cx.tcx.hir().local_def_id(
+                        impl_item_refs
+                            .iter()
+                            .find(|iiref| iiref.ident.as_str() == "get_lints")
+                            .expect("LintPass needs to implement get_lints")
+                            .id
+                            .hir_id(),
+                    ),
+                );
+                collector.visit_expr(cx.tcx.hir().body(body_id).value);
+            }
+        }
+    }
+
+    fn check_crate_post(&mut self, cx: &LateContext<'tcx>) {
+        if is_lint_allowed(cx, LINT_WITHOUT_LINT_PASS, CRATE_HIR_ID) {
+            return;
+        }
+
+        for (lint_name, &lint_span) in &self.declared_lints {
+            // When using the `declare_tool_lint!` macro, the original `lint_span`'s
+            // file points to "<rustc macros>".
+            // `compiletest-rs` thinks that's an error in a different file and
+            // just ignores it. This causes the test in compile-fail/lint_pass
+            // not able to capture the error.
+            // Therefore, we need to climb the macro expansion tree and find the
+            // actual span that invoked `declare_tool_lint!`:
+            let lint_span = lint_span.ctxt().outer_expn_data().call_site;
+
+            if !self.registered_lints.contains(lint_name) {
+                span_lint(
+                    cx,
+                    LINT_WITHOUT_LINT_PASS,
+                    lint_span,
+                    &format!("the lint `{lint_name}` is not added to any `LintPass`"),
+                );
+            }
+        }
+    }
+}
+
+pub(super) fn is_lint_ref_type<'tcx>(cx: &LateContext<'tcx>, ty: &hir::Ty<'_>) -> bool {
+    if let TyKind::Rptr(
+        _,
+        MutTy {
+            ty: inner,
+            mutbl: Mutability::Not,
+        },
+    ) = ty.kind
+    {
+        if let TyKind::Path(ref path) = inner.kind {
+            if let Res::Def(DefKind::Struct, def_id) = cx.qpath_res(path, inner.hir_id) {
+                return match_def_path(cx, def_id, &paths::LINT);
+            }
+        }
+    }
+
+    false
+}
+
+fn check_invalid_clippy_version_attribute(cx: &LateContext<'_>, item: &'_ Item<'_>) {
+    if let Some(value) = extract_clippy_version_value(cx, item) {
+        // The `sym!` macro doesn't work as it only expects a single token.
+        // It's better to keep it this way and have a direct `Symbol::intern` call here.
+        if value == Symbol::intern("pre 1.29.0") {
+            return;
+        }
+
+        if RustcVersion::parse(value.as_str()).is_err() {
+            span_lint_and_help(
+                cx,
+                INVALID_CLIPPY_VERSION_ATTRIBUTE,
+                item.span,
+                "this item has an invalid `clippy::version` attribute",
+                None,
+                "please use a valid semantic version, see `doc/adding_lints.md`",
+            );
+        }
+    } else {
+        span_lint_and_help(
+            cx,
+            MISSING_CLIPPY_VERSION_ATTRIBUTE,
+            item.span,
+            "this lint is missing the `clippy::version` attribute or version value",
+            None,
+            "please use a `clippy::version` attribute, see `doc/adding_lints.md`",
+        );
+    }
+}
+
+/// This function extracts the version value of a `clippy::version` attribute if the given value has
+/// one
+pub(super) fn extract_clippy_version_value(cx: &LateContext<'_>, item: &'_ Item<'_>) -> Option<Symbol> {
+    let attrs = cx.tcx.hir().attrs(item.hir_id());
+    attrs.iter().find_map(|attr| {
+        if_chain! {
+            // Identify attribute
+            if let ast::AttrKind::Normal(ref attr_kind) = &attr.kind;
+            if let [tool_name, attr_name] = &attr_kind.item.path.segments[..];
+            if tool_name.ident.name == sym::clippy;
+            if attr_name.ident.name == sym::version;
+            if let Some(version) = attr.value_str();
+            then {
+                Some(version)
+            } else {
+                None
+            }
+        }
+    })
+}
+
+struct LintCollector<'a, 'tcx> {
+    output: &'a mut FxHashSet<Symbol>,
+    cx: &'a LateContext<'tcx>,
+}
+
+impl<'a, 'tcx> Visitor<'tcx> for LintCollector<'a, 'tcx> {
+    type NestedFilter = nested_filter::All;
+
+    fn visit_path(&mut self, path: &'tcx Path<'_>, _: HirId) {
+        if path.segments.len() == 1 {
+            self.output.insert(path.segments[0].ident.name);
+        }
+    }
+
+    fn nested_visit_map(&mut self) -> Self::Map {
+        self.cx.tcx.hir()
+    }
+}
diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index c84191bb010..8efe170a1e5 100644
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -8,7 +8,7 @@
 //! a simple mistake)
 
 use crate::renamed_lints::RENAMED_LINTS;
-use crate::utils::internal_lints::{extract_clippy_version_value, is_lint_ref_type};
+use crate::utils::internal_lints::lint_without_lint_pass::{extract_clippy_version_value, is_lint_ref_type};
 
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::ty::{match_type, walk_ptrs_ty_depth};
diff --git a/clippy_lints/src/utils/internal_lints/msrv_attr_impl.rs b/clippy_lints/src/utils/internal_lints/msrv_attr_impl.rs
new file mode 100644
index 00000000000..1e994e3f2b1
--- /dev/null
+++ b/clippy_lints/src/utils/internal_lints/msrv_attr_impl.rs
@@ -0,0 +1,63 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet;
+use clippy_utils::ty::match_type;
+use clippy_utils::{match_def_path, paths};
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir as hir;
+use rustc_hir_analysis::hir_ty_to_ty;
+use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_middle::ty::{self, subst::GenericArgKind};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Check that the `extract_msrv_attr!` macro is used, when a lint has a MSRV.
+    ///
+    pub MISSING_MSRV_ATTR_IMPL,
+    internal,
+    "checking if all necessary steps were taken when adding a MSRV to a lint"
+}
+
+declare_lint_pass!(MsrvAttrImpl => [MISSING_MSRV_ATTR_IMPL]);
+
+impl LateLintPass<'_> for MsrvAttrImpl {
+    fn check_item(&mut self, cx: &LateContext<'_>, item: &hir::Item<'_>) {
+        if_chain! {
+            if let hir::ItemKind::Impl(hir::Impl {
+                of_trait: Some(lint_pass_trait_ref),
+                self_ty,
+                items,
+                ..
+            }) = &item.kind;
+            if let Some(lint_pass_trait_def_id) = lint_pass_trait_ref.trait_def_id();
+            let is_late_pass = match_def_path(cx, lint_pass_trait_def_id, &paths::LATE_LINT_PASS);
+            if is_late_pass || match_def_path(cx, lint_pass_trait_def_id, &paths::EARLY_LINT_PASS);
+            let self_ty = hir_ty_to_ty(cx.tcx, self_ty);
+            if let ty::Adt(self_ty_def, _) = self_ty.kind();
+            if self_ty_def.is_struct();
+            if self_ty_def.all_fields().any(|f| {
+                cx.tcx
+                    .type_of(f.did)
+                    .walk()
+                    .filter(|t| matches!(t.unpack(), GenericArgKind::Type(_)))
+                    .any(|t| match_type(cx, t.expect_ty(), &paths::RUSTC_VERSION))
+            });
+            if !items.iter().any(|item| item.ident.name == sym!(enter_lint_attrs));
+            then {
+                let context = if is_late_pass { "LateContext" } else { "EarlyContext" };
+                let lint_pass = if is_late_pass { "LateLintPass" } else { "EarlyLintPass" };
+                let span = cx.sess().source_map().span_through_char(item.span, '{');
+                span_lint_and_sugg(
+                    cx,
+                    MISSING_MSRV_ATTR_IMPL,
+                    span,
+                    &format!("`extract_msrv_attr!` macro missing from `{lint_pass}` implementation"),
+                    &format!("add `extract_msrv_attr!({context})` to the `{lint_pass}` implementation"),
+                    format!("{}\n    extract_msrv_attr!({context});", snippet(cx, span, "..")),
+                    Applicability::MachineApplicable,
+                );
+            }
+        }
+    }
+}
diff --git a/clippy_lints/src/utils/internal_lints/outer_expn_data_pass.rs b/clippy_lints/src/utils/internal_lints/outer_expn_data_pass.rs
new file mode 100644
index 00000000000..3bc05d69579
--- /dev/null
+++ b/clippy_lints/src/utils/internal_lints/outer_expn_data_pass.rs
@@ -0,0 +1,62 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::ty::match_type;
+use clippy_utils::{is_lint_allowed, method_calls, paths};
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir as hir;
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::symbol::Symbol;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for calls to `cx.outer().expn_data()` and suggests to use
+    /// the `cx.outer_expn_data()`
+    ///
+    /// ### Why is this bad?
+    /// `cx.outer_expn_data()` is faster and more concise.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// expr.span.ctxt().outer().expn_data()
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust,ignore
+    /// expr.span.ctxt().outer_expn_data()
+    /// ```
+    pub OUTER_EXPN_EXPN_DATA,
+    internal,
+    "using `cx.outer_expn().expn_data()` instead of `cx.outer_expn_data()`"
+}
+
+declare_lint_pass!(OuterExpnDataPass => [OUTER_EXPN_EXPN_DATA]);
+
+impl<'tcx> LateLintPass<'tcx> for OuterExpnDataPass {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
+        if is_lint_allowed(cx, OUTER_EXPN_EXPN_DATA, expr.hir_id) {
+            return;
+        }
+
+        let (method_names, arg_lists, spans) = method_calls(expr, 2);
+        let method_names: Vec<&str> = method_names.iter().map(Symbol::as_str).collect();
+        if_chain! {
+            if let ["expn_data", "outer_expn"] = method_names.as_slice();
+            let (self_arg, args)= arg_lists[1];
+            if args.is_empty();
+            let self_ty = cx.typeck_results().expr_ty(self_arg).peel_refs();
+            if match_type(cx, self_ty, &paths::SYNTAX_CONTEXT);
+            then {
+                span_lint_and_sugg(
+                    cx,
+                    OUTER_EXPN_EXPN_DATA,
+                    spans[1].with_hi(expr.span.hi()),
+                    "usage of `outer_expn().expn_data()`",
+                    "try",
+                    "outer_expn_data()".to_string(),
+                    Applicability::MachineApplicable,
+                );
+            }
+        }
+    }
+}
diff --git a/clippy_lints/src/utils/internal_lints/produce_ice.rs b/clippy_lints/src/utils/internal_lints/produce_ice.rs
new file mode 100644
index 00000000000..5899b94e16b
--- /dev/null
+++ b/clippy_lints/src/utils/internal_lints/produce_ice.rs
@@ -0,0 +1,37 @@
+use rustc_ast::ast::NodeId;
+use rustc_ast::visit::FnKind;
+use rustc_lint::{EarlyContext, EarlyLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::Span;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Not an actual lint. This lint is only meant for testing our customized internal compiler
+    /// error message by calling `panic`.
+    ///
+    /// ### Why is this bad?
+    /// ICE in large quantities can damage your teeth
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// 🍦🍦🍦🍦🍦
+    /// ```
+    pub PRODUCE_ICE,
+    internal,
+    "this message should not appear anywhere as we ICE before and don't emit the lint"
+}
+
+declare_lint_pass!(ProduceIce => [PRODUCE_ICE]);
+
+impl EarlyLintPass for ProduceIce {
+    fn check_fn(&mut self, _: &EarlyContext<'_>, fn_kind: FnKind<'_>, _: Span, _: NodeId) {
+        assert!(!is_trigger_fn(fn_kind), "Would you like some help with that?");
+    }
+}
+
+fn is_trigger_fn(fn_kind: FnKind<'_>) -> bool {
+    match fn_kind {
+        FnKind::Fn(_, ident, ..) => ident.name.as_str() == "it_looks_like_you_are_trying_to_kill_clippy",
+        FnKind::Closure(..) => false,
+    }
+}
diff --git a/clippy_lints/src/utils/internal_lints/unnecessary_def_path.rs b/clippy_lints/src/utils/internal_lints/unnecessary_def_path.rs
new file mode 100644
index 00000000000..9b524d5b07a
--- /dev/null
+++ b/clippy_lints/src/utils/internal_lints/unnecessary_def_path.rs
@@ -0,0 +1,260 @@
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::{def_path_res, is_lint_allowed, match_any_def_paths, peel_hir_expr_refs};
+use if_chain::if_chain;
+use rustc_ast::ast::LitKind;
+use rustc_errors::Applicability;
+use rustc_hir as hir;
+use rustc_hir::def::{DefKind, Namespace, Res};
+use rustc_hir::def_id::DefId;
+use rustc_hir::{ExprKind, Local, Mutability, Node};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::mir::interpret::{Allocation, ConstValue, GlobalAlloc};
+use rustc_middle::ty::{self, AssocKind, DefIdTree, Ty};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::symbol::{Ident, Symbol};
+
+use std::str;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usages of def paths when a diagnostic item or a `LangItem` could be used.
+    ///
+    /// ### Why is this bad?
+    /// The path for an item is subject to change and is less efficient to look up than a
+    /// diagnostic item or a `LangItem`.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// utils::match_type(cx, ty, &paths::VEC)
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust,ignore
+    /// utils::is_type_diagnostic_item(cx, ty, sym::Vec)
+    /// ```
+    pub UNNECESSARY_DEF_PATH,
+    internal,
+    "using a def path when a diagnostic item or a `LangItem` is available"
+}
+
+declare_lint_pass!(UnnecessaryDefPath => [UNNECESSARY_DEF_PATH]);
+
+#[allow(clippy::too_many_lines)]
+impl<'tcx> LateLintPass<'tcx> for UnnecessaryDefPath {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
+        enum Item {
+            LangItem(Symbol),
+            DiagnosticItem(Symbol),
+        }
+        static PATHS: &[&[&str]] = &[
+            &["clippy_utils", "match_def_path"],
+            &["clippy_utils", "match_trait_method"],
+            &["clippy_utils", "ty", "match_type"],
+            &["clippy_utils", "is_expr_path_def_path"],
+        ];
+
+        if is_lint_allowed(cx, UNNECESSARY_DEF_PATH, expr.hir_id) {
+            return;
+        }
+
+        if_chain! {
+            if let ExprKind::Call(func, [cx_arg, def_arg, args@..]) = expr.kind;
+            if let ExprKind::Path(path) = &func.kind;
+            if let Some(id) = cx.qpath_res(path, func.hir_id).opt_def_id();
+            if let Some(which_path) = match_any_def_paths(cx, id, PATHS);
+            let item_arg = if which_path == 4 { &args[1] } else { &args[0] };
+            // Extract the path to the matched type
+            if let Some(segments) = path_to_matched_type(cx, item_arg);
+            let segments: Vec<&str> = segments.iter().map(|sym| &**sym).collect();
+            if let Some(def_id) = def_path_res(cx, &segments[..], None).opt_def_id();
+            then {
+                // def_path_res will match field names before anything else, but for this we want to match
+                // inherent functions first.
+                let def_id = if cx.tcx.def_kind(def_id) == DefKind::Field {
+                    let method_name = *segments.last().unwrap();
+                    cx.tcx.def_key(def_id).parent
+                        .and_then(|parent_idx|
+                            cx.tcx.inherent_impls(DefId { index: parent_idx, krate: def_id.krate }).iter()
+                                .find_map(|impl_id| cx.tcx.associated_items(*impl_id)
+                                    .find_by_name_and_kind(
+                                        cx.tcx,
+                                        Ident::from_str(method_name),
+                                        AssocKind::Fn,
+                                        *impl_id,
+                                    )
+                                )
+                        )
+                        .map_or(def_id, |item| item.def_id)
+                } else {
+                    def_id
+                };
+
+                // Check if the target item is a diagnostic item or LangItem.
+                let (msg, item) = if let Some(item_name)
+                    = cx.tcx.diagnostic_items(def_id.krate).id_to_name.get(&def_id)
+                {
+                    (
+                        "use of a def path to a diagnostic item",
+                        Item::DiagnosticItem(*item_name),
+                    )
+                } else if let Some(lang_item) = cx.tcx.lang_items().items().iter().position(|id| *id == Some(def_id)) {
+                    let lang_items = def_path_res(cx, &["rustc_hir", "lang_items", "LangItem"], Some(Namespace::TypeNS)).def_id();
+                    let item_name = cx.tcx.adt_def(lang_items).variants().iter().nth(lang_item).unwrap().name;
+                    (
+                        "use of a def path to a `LangItem`",
+                        Item::LangItem(item_name),
+                    )
+                } else {
+                    return;
+                };
+
+                let has_ctor = match cx.tcx.def_kind(def_id) {
+                    DefKind::Struct => {
+                        let variant = cx.tcx.adt_def(def_id).non_enum_variant();
+                        variant.ctor_def_id.is_some() && variant.fields.iter().all(|f| f.vis.is_public())
+                    }
+                    DefKind::Variant => {
+                        let variant = cx.tcx.adt_def(cx.tcx.parent(def_id)).variant_with_id(def_id);
+                        variant.ctor_def_id.is_some() && variant.fields.iter().all(|f| f.vis.is_public())
+                    }
+                    _ => false,
+                };
+
+                let mut app = Applicability::MachineApplicable;
+                let cx_snip = snippet_with_applicability(cx, cx_arg.span, "..", &mut app);
+                let def_snip = snippet_with_applicability(cx, def_arg.span, "..", &mut app);
+                let (sugg, with_note) = match (which_path, item) {
+                    // match_def_path
+                    (0, Item::DiagnosticItem(item)) =>
+                        (format!("{cx_snip}.tcx.is_diagnostic_item(sym::{item}, {def_snip})"), has_ctor),
+                    (0, Item::LangItem(item)) => (
+                        format!("{cx_snip}.tcx.lang_items().require(LangItem::{item}).ok() == Some({def_snip})"),
+                        has_ctor
+                    ),
+                    // match_trait_method
+                    (1, Item::DiagnosticItem(item)) =>
+                        (format!("is_trait_method({cx_snip}, {def_snip}, sym::{item})"), false),
+                    // match_type
+                    (2, Item::DiagnosticItem(item)) =>
+                        (format!("is_type_diagnostic_item({cx_snip}, {def_snip}, sym::{item})"), false),
+                    (2, Item::LangItem(item)) =>
+                        (format!("is_type_lang_item({cx_snip}, {def_snip}, LangItem::{item})"), false),
+                    // is_expr_path_def_path
+                    (3, Item::DiagnosticItem(item)) if has_ctor => (
+                        format!(
+                            "is_res_diag_ctor({cx_snip}, path_res({cx_snip}, {def_snip}), sym::{item})",
+                        ),
+                        false,
+                    ),
+                    (3, Item::LangItem(item)) if has_ctor => (
+                        format!(
+                            "is_res_lang_ctor({cx_snip}, path_res({cx_snip}, {def_snip}), LangItem::{item})",
+                        ),
+                        false,
+                    ),
+                    (3, Item::DiagnosticItem(item)) =>
+                        (format!("is_path_diagnostic_item({cx_snip}, {def_snip}, sym::{item})"), false),
+                    (3, Item::LangItem(item)) => (
+                        format!(
+                            "path_res({cx_snip}, {def_snip}).opt_def_id()\
+                                .map_or(false, |id| {cx_snip}.tcx.lang_items().require(LangItem::{item}).ok() == Some(id))",
+                        ),
+                        false,
+                    ),
+                    _ => return,
+                };
+
+                span_lint_and_then(
+                    cx,
+                    UNNECESSARY_DEF_PATH,
+                    expr.span,
+                    msg,
+                    |diag| {
+                        diag.span_suggestion(expr.span, "try", sugg, app);
+                        if with_note {
+                            diag.help(
+                                "if this `DefId` came from a constructor expression or pattern then the \
+                                    parent `DefId` should be used instead"
+                            );
+                        }
+                    },
+                );
+            }
+        }
+    }
+}
+
+fn path_to_matched_type(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> Option<Vec<String>> {
+    match peel_hir_expr_refs(expr).0.kind {
+        ExprKind::Path(ref qpath) => match cx.qpath_res(qpath, expr.hir_id) {
+            Res::Local(hir_id) => {
+                let parent_id = cx.tcx.hir().get_parent_node(hir_id);
+                if let Some(Node::Local(Local { init: Some(init), .. })) = cx.tcx.hir().find(parent_id) {
+                    path_to_matched_type(cx, init)
+                } else {
+                    None
+                }
+            },
+            Res::Def(DefKind::Static(_), def_id) => read_mir_alloc_def_path(
+                cx,
+                cx.tcx.eval_static_initializer(def_id).ok()?.inner(),
+                cx.tcx.type_of(def_id),
+            ),
+            Res::Def(DefKind::Const, def_id) => match cx.tcx.const_eval_poly(def_id).ok()? {
+                ConstValue::ByRef { alloc, offset } if offset.bytes() == 0 => {
+                    read_mir_alloc_def_path(cx, alloc.inner(), cx.tcx.type_of(def_id))
+                },
+                _ => None,
+            },
+            _ => None,
+        },
+        ExprKind::Array(exprs) => exprs
+            .iter()
+            .map(|expr| {
+                if let ExprKind::Lit(lit) = &expr.kind {
+                    if let LitKind::Str(sym, _) = lit.node {
+                        return Some((*sym.as_str()).to_owned());
+                    }
+                }
+
+                None
+            })
+            .collect(),
+        _ => None,
+    }
+}
+
+fn read_mir_alloc_def_path<'tcx>(cx: &LateContext<'tcx>, alloc: &'tcx Allocation, ty: Ty<'_>) -> Option<Vec<String>> {
+    let (alloc, ty) = if let ty::Ref(_, ty, Mutability::Not) = *ty.kind() {
+        let &alloc = alloc.provenance().values().next()?;
+        if let GlobalAlloc::Memory(alloc) = cx.tcx.global_alloc(alloc) {
+            (alloc.inner(), ty)
+        } else {
+            return None;
+        }
+    } else {
+        (alloc, ty)
+    };
+
+    if let ty::Array(ty, _) | ty::Slice(ty) = *ty.kind()
+        && let ty::Ref(_, ty, Mutability::Not) = *ty.kind()
+        && ty.is_str()
+    {
+        alloc
+            .provenance()
+            .values()
+            .map(|&alloc| {
+                if let GlobalAlloc::Memory(alloc) = cx.tcx.global_alloc(alloc) {
+                    let alloc = alloc.inner();
+                    str::from_utf8(alloc.inspect_with_uninit_and_ptr_outside_interpreter(0..alloc.len()))
+                        .ok().map(ToOwned::to_owned)
+                } else {
+                    None
+                }
+            })
+            .collect()
+    } else {
+        None
+    }
+}
diff --git a/tests/ui-internal/custom_ice_message.stderr b/tests/ui-internal/custom_ice_message.stderr
index a1b8e2ee162..07c5941013c 100644
--- a/tests/ui-internal/custom_ice_message.stderr
+++ b/tests/ui-internal/custom_ice_message.stderr
@@ -1,4 +1,4 @@
-thread 'rustc' panicked at 'Would you like some help with that?', clippy_lints/src/utils/internal_lints.rs
+thread 'rustc' panicked at 'Would you like some help with that?', clippy_lints/src/utils/internal_lints/produce_ice.rs:28:9
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
 
 error: internal compiler error: unexpected panic
-- 
cgit 1.4.1-3-g733a5


From c84ac4cee96f13b0abe8dc1f1b2d4e9406f80791 Mon Sep 17 00:00:00 2001
From: Samuel Moelius <sam@moeli.us>
Date: Fri, 30 Sep 2022 21:10:10 -0400
Subject: Move some things around

---
 .../internal_lints/compiler_lint_functions.rs      |  4 +-
 .../src/utils/internal_lints/invalid_paths.rs      | 64 +++++++++++-----------
 2 files changed, 34 insertions(+), 34 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/internal_lints/compiler_lint_functions.rs b/clippy_lints/src/utils/internal_lints/compiler_lint_functions.rs
index 67357a5cb6b..d7e4a2c4422 100644
--- a/clippy_lints/src/utils/internal_lints/compiler_lint_functions.rs
+++ b/clippy_lints/src/utils/internal_lints/compiler_lint_functions.rs
@@ -30,6 +30,8 @@ declare_clippy_lint! {
     "usage of the lint functions of the compiler instead of the utils::* variant"
 }
 
+impl_lint_pass!(CompilerLintFunctions => [COMPILER_LINT_FUNCTIONS]);
+
 #[derive(Clone, Default)]
 pub struct CompilerLintFunctions {
     map: FxHashMap<&'static str, &'static str>,
@@ -48,8 +50,6 @@ impl CompilerLintFunctions {
     }
 }
 
-impl_lint_pass!(CompilerLintFunctions => [COMPILER_LINT_FUNCTIONS]);
-
 impl<'tcx> LateLintPass<'tcx> for CompilerLintFunctions {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if is_lint_allowed(cx, COMPILER_LINT_FUNCTIONS, expr.hir_id) {
diff --git a/clippy_lints/src/utils/internal_lints/invalid_paths.rs b/clippy_lints/src/utils/internal_lints/invalid_paths.rs
index 57eb3f49d06..04f1952e813 100644
--- a/clippy_lints/src/utils/internal_lints/invalid_paths.rs
+++ b/clippy_lints/src/utils/internal_lints/invalid_paths.rs
@@ -25,6 +25,38 @@ declare_clippy_lint! {
     "invalid path"
 }
 
+declare_lint_pass!(InvalidPaths => [INVALID_PATHS]);
+
+impl<'tcx> LateLintPass<'tcx> for InvalidPaths {
+    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
+        let local_def_id = &cx.tcx.parent_module(item.hir_id());
+        let mod_name = &cx.tcx.item_name(local_def_id.to_def_id());
+        if_chain! {
+            if mod_name.as_str() == "paths";
+            if let hir::ItemKind::Const(ty, body_id) = item.kind;
+            let ty = hir_ty_to_ty(cx.tcx, ty);
+            if let ty::Array(el_ty, _) = &ty.kind();
+            if let ty::Ref(_, el_ty, _) = &el_ty.kind();
+            if el_ty.is_str();
+            let body = cx.tcx.hir().body(body_id);
+            let typeck_results = cx.tcx.typeck_body(body_id);
+            if let Some(Constant::Vec(path)) = constant_simple(cx, typeck_results, body.value);
+            let path: Vec<&str> = path.iter().map(|x| {
+                    if let Constant::Str(s) = x {
+                        s.as_str()
+                    } else {
+                        // We checked the type of the constant above
+                        unreachable!()
+                    }
+                }).collect();
+            if !check_path(cx, &path[..]);
+            then {
+                span_lint(cx, INVALID_PATHS, item.span, "invalid path");
+            }
+        }
+    }
+}
+
 // This is not a complete resolver for paths. It works on all the paths currently used in the paths
 // module.  That's all it does and all it needs to do.
 pub fn check_path(cx: &LateContext<'_>, path: &[&str]) -> bool {
@@ -71,35 +103,3 @@ pub fn check_path(cx: &LateContext<'_>, path: &[&str]) -> bool {
 
     false
 }
-
-declare_lint_pass!(InvalidPaths => [INVALID_PATHS]);
-
-impl<'tcx> LateLintPass<'tcx> for InvalidPaths {
-    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
-        let local_def_id = &cx.tcx.parent_module(item.hir_id());
-        let mod_name = &cx.tcx.item_name(local_def_id.to_def_id());
-        if_chain! {
-            if mod_name.as_str() == "paths";
-            if let hir::ItemKind::Const(ty, body_id) = item.kind;
-            let ty = hir_ty_to_ty(cx.tcx, ty);
-            if let ty::Array(el_ty, _) = &ty.kind();
-            if let ty::Ref(_, el_ty, _) = &el_ty.kind();
-            if el_ty.is_str();
-            let body = cx.tcx.hir().body(body_id);
-            let typeck_results = cx.tcx.typeck_body(body_id);
-            if let Some(Constant::Vec(path)) = constant_simple(cx, typeck_results, body.value);
-            let path: Vec<&str> = path.iter().map(|x| {
-                    if let Constant::Str(s) = x {
-                        s.as_str()
-                    } else {
-                        // We checked the type of the constant above
-                        unreachable!()
-                    }
-                }).collect();
-            if !check_path(cx, &path[..]);
-            then {
-                span_lint(cx, INVALID_PATHS, item.span, "invalid path");
-            }
-        }
-    }
-}
-- 
cgit 1.4.1-3-g733a5


From 8611a0bb5cc401f90162449eaa82295ef5f70d68 Mon Sep 17 00:00:00 2001
From: Samuel Moelius <sam@moeli.us>
Date: Sat, 1 Oct 2022 04:48:01 -0400
Subject: Expand `unnecessary_def_path` lint

---
 clippy_lints/src/lib.rs                            |   2 +-
 .../utils/internal_lints/unnecessary_def_path.rs   | 181 +++++++++++++++------
 tests/ui-internal/unnecessary_def_path.fixed       |   6 +-
 tests/ui-internal/unnecessary_def_path.rs          |   6 +-
 .../unnecessary_def_path_hardcoded_path.rs         |  16 ++
 .../unnecessary_def_path_hardcoded_path.stderr     |  27 +++
 6 files changed, 182 insertions(+), 56 deletions(-)
 create mode 100644 tests/ui-internal/unnecessary_def_path_hardcoded_path.rs
 create mode 100644 tests/ui-internal/unnecessary_def_path_hardcoded_path.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index b2ee58ec7ff..893410dbfdc 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -542,7 +542,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         store.register_late_pass(|_| {
             Box::<utils::internal_lints::lint_without_lint_pass::LintWithoutLintPass>::default()
         });
-        store.register_late_pass(|_| Box::new(utils::internal_lints::unnecessary_def_path::UnnecessaryDefPath));
+        store.register_late_pass(|_| Box::<utils::internal_lints::unnecessary_def_path::UnnecessaryDefPath>::default());
         store.register_late_pass(|_| Box::new(utils::internal_lints::outer_expn_data_pass::OuterExpnDataPass));
         store.register_late_pass(|_| Box::new(utils::internal_lints::msrv_attr_impl::MsrvAttrImpl));
     }
diff --git a/clippy_lints/src/utils/internal_lints/unnecessary_def_path.rs b/clippy_lints/src/utils/internal_lints/unnecessary_def_path.rs
index 9b524d5b07a..0a3852c98ee 100644
--- a/clippy_lints/src/utils/internal_lints/unnecessary_def_path.rs
+++ b/clippy_lints/src/utils/internal_lints/unnecessary_def_path.rs
@@ -1,18 +1,20 @@
-use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_then};
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::{def_path_res, is_lint_allowed, match_any_def_paths, peel_hir_expr_refs};
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
+use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_hir::def::{DefKind, Namespace, Res};
 use rustc_hir::def_id::DefId;
-use rustc_hir::{ExprKind, Local, Mutability, Node};
+use rustc_hir::{Expr, ExprKind, Local, Mutability, Node};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::mir::interpret::{Allocation, ConstValue, GlobalAlloc};
 use rustc_middle::ty::{self, AssocKind, DefIdTree, Ty};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::symbol::{Ident, Symbol};
+use rustc_span::Span;
 
 use std::str;
 
@@ -38,11 +40,56 @@ declare_clippy_lint! {
     "using a def path when a diagnostic item or a `LangItem` is available"
 }
 
-declare_lint_pass!(UnnecessaryDefPath => [UNNECESSARY_DEF_PATH]);
+impl_lint_pass!(UnnecessaryDefPath => [UNNECESSARY_DEF_PATH]);
+
+#[derive(Default)]
+pub struct UnnecessaryDefPath {
+    array_def_ids: FxHashSet<(DefId, Span)>,
+    linted_def_ids: FxHashSet<DefId>,
+}
 
-#[allow(clippy::too_many_lines)]
 impl<'tcx> LateLintPass<'tcx> for UnnecessaryDefPath {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
+        if is_lint_allowed(cx, UNNECESSARY_DEF_PATH, expr.hir_id) {
+            return;
+        }
+
+        match expr.kind {
+            ExprKind::Call(func, args) => self.check_call(cx, func, args, expr.span),
+            ExprKind::Array(elements) => self.check_array(cx, elements, expr.span),
+            _ => {},
+        }
+    }
+
+    fn check_crate_post(&mut self, cx: &LateContext<'tcx>) {
+        for &(def_id, span) in &self.array_def_ids {
+            if self.linted_def_ids.contains(&def_id) {
+                continue;
+            }
+
+            let (msg, sugg) = if let Some(sym) = cx.tcx.get_diagnostic_name(def_id) {
+                ("diagnostic item", format!("sym::{sym}"))
+            } else if let Some(sym) = get_lang_item_name(cx, def_id) {
+                ("language item", format!("LangItem::{sym}"))
+            } else {
+                continue;
+            };
+
+            span_lint_and_help(
+                cx,
+                UNNECESSARY_DEF_PATH,
+                span,
+                &format!("hardcoded path to a {msg}"),
+                None,
+                &format!("convert all references to use `{sugg}`"),
+            );
+        }
+    }
+}
+
+impl UnnecessaryDefPath {
+    #[allow(clippy::too_many_lines)]
+    fn check_call(&mut self, cx: &LateContext<'_>, func: &Expr<'_>, args: &[Expr<'_>], span: Span) {
         enum Item {
             LangItem(Symbol),
             DiagnosticItem(Symbol),
@@ -54,12 +101,8 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryDefPath {
             &["clippy_utils", "is_expr_path_def_path"],
         ];
 
-        if is_lint_allowed(cx, UNNECESSARY_DEF_PATH, expr.hir_id) {
-            return;
-        }
-
         if_chain! {
-            if let ExprKind::Call(func, [cx_arg, def_arg, args@..]) = expr.kind;
+            if let [cx_arg, def_arg, args@..] = args;
             if let ExprKind::Path(path) = &func.kind;
             if let Some(id) = cx.qpath_res(path, func.hir_id).opt_def_id();
             if let Some(which_path) = match_any_def_paths(cx, id, PATHS);
@@ -67,29 +110,8 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryDefPath {
             // Extract the path to the matched type
             if let Some(segments) = path_to_matched_type(cx, item_arg);
             let segments: Vec<&str> = segments.iter().map(|sym| &**sym).collect();
-            if let Some(def_id) = def_path_res(cx, &segments[..], None).opt_def_id();
+            if let Some(def_id) = inherent_def_path_res(cx, &segments[..]);
             then {
-                // def_path_res will match field names before anything else, but for this we want to match
-                // inherent functions first.
-                let def_id = if cx.tcx.def_kind(def_id) == DefKind::Field {
-                    let method_name = *segments.last().unwrap();
-                    cx.tcx.def_key(def_id).parent
-                        .and_then(|parent_idx|
-                            cx.tcx.inherent_impls(DefId { index: parent_idx, krate: def_id.krate }).iter()
-                                .find_map(|impl_id| cx.tcx.associated_items(*impl_id)
-                                    .find_by_name_and_kind(
-                                        cx.tcx,
-                                        Ident::from_str(method_name),
-                                        AssocKind::Fn,
-                                        *impl_id,
-                                    )
-                                )
-                        )
-                        .map_or(def_id, |item| item.def_id)
-                } else {
-                    def_id
-                };
-
                 // Check if the target item is a diagnostic item or LangItem.
                 let (msg, item) = if let Some(item_name)
                     = cx.tcx.diagnostic_items(def_id.krate).id_to_name.get(&def_id)
@@ -98,9 +120,7 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryDefPath {
                         "use of a def path to a diagnostic item",
                         Item::DiagnosticItem(*item_name),
                     )
-                } else if let Some(lang_item) = cx.tcx.lang_items().items().iter().position(|id| *id == Some(def_id)) {
-                    let lang_items = def_path_res(cx, &["rustc_hir", "lang_items", "LangItem"], Some(Namespace::TypeNS)).def_id();
-                    let item_name = cx.tcx.adt_def(lang_items).variants().iter().nth(lang_item).unwrap().name;
+                } else if let Some(item_name) = get_lang_item_name(cx, def_id) {
                     (
                         "use of a def path to a `LangItem`",
                         Item::LangItem(item_name),
@@ -168,10 +188,10 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryDefPath {
                 span_lint_and_then(
                     cx,
                     UNNECESSARY_DEF_PATH,
-                    expr.span,
+                    span,
                     msg,
                     |diag| {
-                        diag.span_suggestion(expr.span, "try", sugg, app);
+                        diag.span_suggestion(span, "try", sugg, app);
                         if with_note {
                             diag.help(
                                 "if this `DefId` came from a constructor expression or pattern then the \
@@ -180,9 +200,19 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryDefPath {
                         }
                     },
                 );
+
+                self.linted_def_ids.insert(def_id);
             }
         }
     }
+
+    fn check_array(&mut self, cx: &LateContext<'_>, elements: &[Expr<'_>], span: Span) {
+        let Some(path) = path_from_array(elements) else { return };
+
+        if let Some(def_id) = inherent_def_path_res(cx, &path.iter().map(AsRef::as_ref).collect::<Vec<_>>()) {
+            self.array_def_ids.insert((def_id, span));
+        }
+    }
 }
 
 fn path_to_matched_type(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> Option<Vec<String>> {
@@ -209,18 +239,7 @@ fn path_to_matched_type(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> Option<Ve
             },
             _ => None,
         },
-        ExprKind::Array(exprs) => exprs
-            .iter()
-            .map(|expr| {
-                if let ExprKind::Lit(lit) = &expr.kind {
-                    if let LitKind::Str(sym, _) = lit.node {
-                        return Some((*sym.as_str()).to_owned());
-                    }
-                }
-
-                None
-            })
-            .collect(),
+        ExprKind::Array(exprs) => path_from_array(exprs),
         _ => None,
     }
 }
@@ -258,3 +277,67 @@ fn read_mir_alloc_def_path<'tcx>(cx: &LateContext<'tcx>, alloc: &'tcx Allocation
         None
     }
 }
+
+fn path_from_array(exprs: &[Expr<'_>]) -> Option<Vec<String>> {
+    exprs
+        .iter()
+        .map(|expr| {
+            if let ExprKind::Lit(lit) = &expr.kind {
+                if let LitKind::Str(sym, _) = lit.node {
+                    return Some((*sym.as_str()).to_owned());
+                }
+            }
+
+            None
+        })
+        .collect()
+}
+
+// def_path_res will match field names before anything else, but for this we want to match
+// inherent functions first.
+fn inherent_def_path_res(cx: &LateContext<'_>, segments: &[&str]) -> Option<DefId> {
+    def_path_res(cx, segments, None).opt_def_id().map(|def_id| {
+        if cx.tcx.def_kind(def_id) == DefKind::Field {
+            let method_name = *segments.last().unwrap();
+            cx.tcx
+                .def_key(def_id)
+                .parent
+                .and_then(|parent_idx| {
+                    cx.tcx
+                        .inherent_impls(DefId {
+                            index: parent_idx,
+                            krate: def_id.krate,
+                        })
+                        .iter()
+                        .find_map(|impl_id| {
+                            cx.tcx.associated_items(*impl_id).find_by_name_and_kind(
+                                cx.tcx,
+                                Ident::from_str(method_name),
+                                AssocKind::Fn,
+                                *impl_id,
+                            )
+                        })
+                })
+                .map_or(def_id, |item| item.def_id)
+        } else {
+            def_id
+        }
+    })
+}
+
+fn get_lang_item_name(cx: &LateContext<'_>, def_id: DefId) -> Option<Symbol> {
+    if let Some(lang_item) = cx.tcx.lang_items().items().iter().position(|id| *id == Some(def_id)) {
+        let lang_items = def_path_res(cx, &["rustc_hir", "lang_items", "LangItem"], Some(Namespace::TypeNS)).def_id();
+        let item_name = cx
+            .tcx
+            .adt_def(lang_items)
+            .variants()
+            .iter()
+            .nth(lang_item)
+            .unwrap()
+            .name;
+        Some(item_name)
+    } else {
+        None
+    }
+}
diff --git a/tests/ui-internal/unnecessary_def_path.fixed b/tests/ui-internal/unnecessary_def_path.fixed
index 4c050332f2c..cbbb4652306 100644
--- a/tests/ui-internal/unnecessary_def_path.fixed
+++ b/tests/ui-internal/unnecessary_def_path.fixed
@@ -28,9 +28,9 @@ use rustc_hir::Expr;
 use rustc_lint::LateContext;
 use rustc_middle::ty::Ty;
 
-#[allow(unused)]
+#[allow(unused, clippy::unnecessary_def_path)]
 static OPTION: [&str; 3] = ["core", "option", "Option"];
-#[allow(unused)]
+#[allow(unused, clippy::unnecessary_def_path)]
 const RESULT: &[&str] = &["core", "result", "Result"];
 
 fn _f<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>, did: DefId, expr: &Expr<'_>) {
@@ -38,7 +38,7 @@ fn _f<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>, did: DefId, expr: &Expr<'_>) {
     let _ = is_type_diagnostic_item(cx, ty, sym::Result);
     let _ = is_type_diagnostic_item(cx, ty, sym::Result);
 
-    #[allow(unused)]
+    #[allow(unused, clippy::unnecessary_def_path)]
     let rc_path = &["alloc", "rc", "Rc"];
     let _ = is_type_diagnostic_item(cx, ty, sym::Rc);
 
diff --git a/tests/ui-internal/unnecessary_def_path.rs b/tests/ui-internal/unnecessary_def_path.rs
index 6506f1f164a..f17fed6c653 100644
--- a/tests/ui-internal/unnecessary_def_path.rs
+++ b/tests/ui-internal/unnecessary_def_path.rs
@@ -28,9 +28,9 @@ use rustc_hir::Expr;
 use rustc_lint::LateContext;
 use rustc_middle::ty::Ty;
 
-#[allow(unused)]
+#[allow(unused, clippy::unnecessary_def_path)]
 static OPTION: [&str; 3] = ["core", "option", "Option"];
-#[allow(unused)]
+#[allow(unused, clippy::unnecessary_def_path)]
 const RESULT: &[&str] = &["core", "result", "Result"];
 
 fn _f<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>, did: DefId, expr: &Expr<'_>) {
@@ -38,7 +38,7 @@ fn _f<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>, did: DefId, expr: &Expr<'_>) {
     let _ = match_type(cx, ty, RESULT);
     let _ = match_type(cx, ty, &["core", "result", "Result"]);
 
-    #[allow(unused)]
+    #[allow(unused, clippy::unnecessary_def_path)]
     let rc_path = &["alloc", "rc", "Rc"];
     let _ = clippy_utils::ty::match_type(cx, ty, rc_path);
 
diff --git a/tests/ui-internal/unnecessary_def_path_hardcoded_path.rs b/tests/ui-internal/unnecessary_def_path_hardcoded_path.rs
new file mode 100644
index 00000000000..b5ff3a54205
--- /dev/null
+++ b/tests/ui-internal/unnecessary_def_path_hardcoded_path.rs
@@ -0,0 +1,16 @@
+#![feature(rustc_private)]
+#![allow(unused)]
+#![warn(clippy::unnecessary_def_path)]
+
+extern crate rustc_hir;
+
+use rustc_hir::LangItem;
+
+fn main() {
+    const DEREF_TRAIT: [&str; 4] = ["core", "ops", "deref", "Deref"];
+    const DEREF_MUT_TRAIT: [&str; 4] = ["core", "ops", "deref", "DerefMut"];
+    const DEREF_TRAIT_METHOD: [&str; 5] = ["core", "ops", "deref", "Deref", "deref"];
+
+    // Don't lint, not yet a diagnostic or language item
+    const DEREF_MUT_TRAIT_METHOD: [&str; 5] = ["core", "ops", "deref", "DerefMut", "deref_mut"];
+}
diff --git a/tests/ui-internal/unnecessary_def_path_hardcoded_path.stderr b/tests/ui-internal/unnecessary_def_path_hardcoded_path.stderr
new file mode 100644
index 00000000000..af46d87bf67
--- /dev/null
+++ b/tests/ui-internal/unnecessary_def_path_hardcoded_path.stderr
@@ -0,0 +1,27 @@
+error: hardcoded path to a language item
+  --> $DIR/unnecessary_def_path_hardcoded_path.rs:11:40
+   |
+LL |     const DEREF_MUT_TRAIT: [&str; 4] = ["core", "ops", "deref", "DerefMut"];
+   |                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: convert all references to use `LangItem::DerefMut`
+   = note: `-D clippy::unnecessary-def-path` implied by `-D warnings`
+
+error: hardcoded path to a diagnostic item
+  --> $DIR/unnecessary_def_path_hardcoded_path.rs:12:43
+   |
+LL |     const DEREF_TRAIT_METHOD: [&str; 5] = ["core", "ops", "deref", "Deref", "deref"];
+   |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: convert all references to use `sym::deref_method`
+
+error: hardcoded path to a diagnostic item
+  --> $DIR/unnecessary_def_path_hardcoded_path.rs:10:36
+   |
+LL |     const DEREF_TRAIT: [&str; 4] = ["core", "ops", "deref", "Deref"];
+   |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: convert all references to use `sym::Deref`
+
+error: aborting due to 3 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 2e5e3560e917f2c3adceda6bc40806868c98e04e Mon Sep 17 00:00:00 2001
From: Samuel Moelius <sam@moeli.us>
Date: Sat, 1 Oct 2022 04:56:55 -0400
Subject: Fix adjacent code

---
 clippy_lints/src/booleans.rs                    |  6 +++--
 clippy_lints/src/comparison_chain.rs            |  8 +++++--
 clippy_lints/src/functions/must_use.rs          | 10 +++++----
 clippy_lints/src/let_underscore.rs              | 15 ++++++++-----
 clippy_lints/src/loops/needless_range_loop.rs   | 11 ++++++---
 clippy_lints/src/manual_async_fn.rs             |  9 +++++---
 clippy_lints/src/manual_clamp.rs                | 10 ++++++---
 clippy_lints/src/matches/single_match.rs        | 11 +++++----
 clippy_lints/src/methods/mod.rs                 | 12 +++++-----
 clippy_lints/src/methods/option_as_ref_deref.rs | 20 +++++++++--------
 clippy_lints/src/methods/or_fun_call.rs         | 18 +++++++--------
 clippy_lints/src/neg_cmp_op_on_partial_ord.rs   |  4 ++--
 clippy_lints/src/operators/cmp_owned.rs         | 18 ++++++++-------
 clippy_lints/src/unit_return_expecting_ord.rs   |  5 ++---
 clippy_utils/src/lib.rs                         | 17 ++++++++++++++
 clippy_utils/src/paths.rs                       | 30 -------------------------
 tests/ui-internal/invalid_paths.rs              |  2 +-
 17 files changed, 108 insertions(+), 98 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/booleans.rs b/clippy_lints/src/booleans.rs
index 2a15cbc7a3c..08164c0b654 100644
--- a/clippy_lints/src/booleans.rs
+++ b/clippy_lints/src/booleans.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_hir_and_then};
+use clippy_utils::eq_expr_value;
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::{implements_trait, is_type_diagnostic_item};
-use clippy_utils::{eq_expr_value, get_trait_def_id, paths};
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
@@ -483,7 +483,9 @@ impl<'a, 'tcx> Visitor<'tcx> for NonminimalBoolVisitor<'a, 'tcx> {
 
 fn implements_ord<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>) -> bool {
     let ty = cx.typeck_results().expr_ty(expr);
-    get_trait_def_id(cx, &paths::ORD).map_or(false, |id| implements_trait(cx, ty, id, &[]))
+    cx.tcx
+        .get_diagnostic_item(sym::Ord)
+        .map_or(false, |id| implements_trait(cx, ty, id, &[]))
 }
 
 struct NotSimplificationVisitor<'a, 'tcx> {
diff --git a/clippy_lints/src/comparison_chain.rs b/clippy_lints/src/comparison_chain.rs
index a05b41eb3ab..0fe973b49a3 100644
--- a/clippy_lints/src/comparison_chain.rs
+++ b/clippy_lints/src/comparison_chain.rs
@@ -1,9 +1,10 @@
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::ty::implements_trait;
-use clippy_utils::{get_trait_def_id, if_sequence, in_constant, is_else_clause, paths, SpanlessEq};
+use clippy_utils::{if_sequence, in_constant, is_else_clause, SpanlessEq};
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::sym;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -106,7 +107,10 @@ impl<'tcx> LateLintPass<'tcx> for ComparisonChain {
 
                 // Check that the type being compared implements `core::cmp::Ord`
                 let ty = cx.typeck_results().expr_ty(lhs1);
-                let is_ord = get_trait_def_id(cx, &paths::ORD).map_or(false, |id| implements_trait(cx, ty, id, &[]));
+                let is_ord = cx
+                    .tcx
+                    .get_diagnostic_item(sym::Ord)
+                    .map_or(false, |id| implements_trait(cx, ty, id, &[]));
 
                 if !is_ord {
                     return;
diff --git a/clippy_lints/src/functions/must_use.rs b/clippy_lints/src/functions/must_use.rs
index d263804f32c..3064b6c9d22 100644
--- a/clippy_lints/src/functions/must_use.rs
+++ b/clippy_lints/src/functions/must_use.rs
@@ -7,14 +7,14 @@ use rustc_middle::{
     lint::in_external_macro,
     ty::{self, Ty},
 };
-use rustc_span::{sym, Span};
+use rustc_span::{sym, Span, Symbol};
 
 use clippy_utils::attrs::is_proc_macro;
 use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_then};
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::is_must_use_ty;
 use clippy_utils::visitors::for_each_expr;
-use clippy_utils::{match_def_path, return_ty, trait_ref_of_method};
+use clippy_utils::{return_ty, trait_ref_of_method};
 
 use core::ops::ControlFlow;
 
@@ -181,7 +181,7 @@ fn is_mutable_pat(cx: &LateContext<'_>, pat: &hir::Pat<'_>, tys: &mut DefIdSet)
     }
 }
 
-static KNOWN_WRAPPER_TYS: &[&[&str]] = &[&["alloc", "rc", "Rc"], &["std", "sync", "Arc"]];
+static KNOWN_WRAPPER_TYS: &[Symbol] = &[sym::Rc, sym::Arc];
 
 fn is_mutable_ty<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>, span: Span, tys: &mut DefIdSet) -> bool {
     match *ty.kind() {
@@ -189,7 +189,9 @@ fn is_mutable_ty<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>, span: Span, tys: &m
         ty::Bool | ty::Char | ty::Int(_) | ty::Uint(_) | ty::Float(_) | ty::Str => false,
         ty::Adt(adt, substs) => {
             tys.insert(adt.did()) && !ty.is_freeze(cx.tcx.at(span), cx.param_env)
-                || KNOWN_WRAPPER_TYS.iter().any(|path| match_def_path(cx, adt.did(), path))
+                || KNOWN_WRAPPER_TYS
+                    .iter()
+                    .any(|&sym| cx.tcx.is_diagnostic_item(sym, adt.did()))
                     && substs.types().any(|ty| is_mutable_ty(cx, ty, span, tys))
         },
         ty::Tuple(substs) => substs.iter().any(|ty| is_mutable_ty(cx, ty, span, tys)),
diff --git a/clippy_lints/src/let_underscore.rs b/clippy_lints/src/let_underscore.rs
index 176787497eb..6d50dcc8806 100644
--- a/clippy_lints/src/let_underscore.rs
+++ b/clippy_lints/src/let_underscore.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_help;
-use clippy_utils::ty::{is_must_use_ty, match_type};
+use clippy_utils::ty::{is_must_use_ty, is_type_diagnostic_item, match_type};
 use clippy_utils::{is_must_use_func_call, paths};
 use if_chain::if_chain;
 use rustc_hir::{Local, PatKind};
@@ -7,6 +7,7 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::subst::GenericArgKind;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::{sym, Symbol};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -99,10 +100,9 @@ declare_clippy_lint! {
 
 declare_lint_pass!(LetUnderscore => [LET_UNDERSCORE_MUST_USE, LET_UNDERSCORE_LOCK, LET_UNDERSCORE_DROP]);
 
-const SYNC_GUARD_PATHS: [&[&str]; 6] = [
-    &paths::MUTEX_GUARD,
-    &paths::RWLOCK_READ_GUARD,
-    &paths::RWLOCK_WRITE_GUARD,
+const SYNC_GUARD_SYMS: [Symbol; 3] = [sym::MutexGuard, sym::RwLockReadGuard, sym::RwLockWriteGuard];
+
+const SYNC_GUARD_PATHS: [&[&str]; 3] = [
     &paths::PARKING_LOT_MUTEX_GUARD,
     &paths::PARKING_LOT_RWLOCK_READ_GUARD,
     &paths::PARKING_LOT_RWLOCK_WRITE_GUARD,
@@ -121,7 +121,10 @@ impl<'tcx> LateLintPass<'tcx> for LetUnderscore {
                 let init_ty = cx.typeck_results().expr_ty(init);
                 let contains_sync_guard = init_ty.walk().any(|inner| match inner.unpack() {
                     GenericArgKind::Type(inner_ty) => {
-                        SYNC_GUARD_PATHS.iter().any(|path| match_type(cx, inner_ty, path))
+                        SYNC_GUARD_SYMS
+                            .iter()
+                            .any(|&sym| is_type_diagnostic_item(cx, inner_ty, sym))
+                            || SYNC_GUARD_PATHS.iter().any(|path| match_type(cx, inner_ty, path))
                     },
 
                     GenericArgKind::Lifetime(_) | GenericArgKind::Const(_) => false,
diff --git a/clippy_lints/src/loops/needless_range_loop.rs b/clippy_lints/src/loops/needless_range_loop.rs
index 00cfc6d49f1..2b1c5688e82 100644
--- a/clippy_lints/src/loops/needless_range_loop.rs
+++ b/clippy_lints/src/loops/needless_range_loop.rs
@@ -3,7 +3,7 @@ use clippy_utils::diagnostics::{multispan_sugg, span_lint_and_then};
 use clippy_utils::source::snippet;
 use clippy_utils::ty::has_iter_method;
 use clippy_utils::visitors::is_local_used;
-use clippy_utils::{contains_name, higher, is_integer_const, match_trait_method, paths, sugg, SpanlessEq};
+use clippy_utils::{contains_name, higher, is_integer_const, sugg, SpanlessEq};
 use if_chain::if_chain;
 use rustc_ast::ast;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
@@ -302,8 +302,13 @@ impl<'a, 'tcx> Visitor<'tcx> for VarVisitor<'a, 'tcx> {
         if_chain! {
             // a range index op
             if let ExprKind::MethodCall(meth, args_0, [args_1, ..], _) = &expr.kind;
-            if (meth.ident.name == sym::index && match_trait_method(self.cx, expr, &paths::INDEX))
-                || (meth.ident.name == sym::index_mut && match_trait_method(self.cx, expr, &paths::INDEX_MUT));
+            if let Some(trait_id) = self
+                .cx
+                .typeck_results()
+                .type_dependent_def_id(expr.hir_id)
+                .and_then(|def_id| self.cx.tcx.trait_of_item(def_id));
+            if (meth.ident.name == sym::index && self.cx.tcx.lang_items().index_trait() == Some(trait_id))
+                || (meth.ident.name == sym::index_mut && self.cx.tcx.lang_items().index_mut_trait() == Some(trait_id));
             if !self.check(args_1, args_0, expr);
             then { return }
         }
diff --git a/clippy_lints/src/manual_async_fn.rs b/clippy_lints/src/manual_async_fn.rs
index 9a0a26c0991..570d83c7ea8 100644
--- a/clippy_lints/src/manual_async_fn.rs
+++ b/clippy_lints/src/manual_async_fn.rs
@@ -1,6 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::match_function_call;
-use clippy_utils::paths::FUTURE_FROM_GENERATOR;
+use clippy_utils::match_function_call_with_def_id;
 use clippy_utils::source::{position_before_rarrow, snippet_block, snippet_opt};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
@@ -175,7 +174,11 @@ fn captures_all_lifetimes(inputs: &[Ty<'_>], output_lifetimes: &[LifetimeName])
 fn desugared_async_block<'tcx>(cx: &LateContext<'tcx>, block: &'tcx Block<'tcx>) -> Option<&'tcx Body<'tcx>> {
     if_chain! {
         if let Some(block_expr) = block.expr;
-        if let Some(args) = match_function_call(cx, block_expr, &FUTURE_FROM_GENERATOR);
+        if let Some(args) = cx
+            .tcx
+            .lang_items()
+            .from_generator_fn()
+            .and_then(|def_id| match_function_call_with_def_id(cx, block_expr, def_id));
         if args.len() == 1;
         if let Expr{kind: ExprKind::Closure(&Closure { body, .. }), ..} = args[0];
         let closure_body = cx.tcx.hir().body(body);
diff --git a/clippy_lints/src/manual_clamp.rs b/clippy_lints/src/manual_clamp.rs
index ece4df95505..02dc8755dd6 100644
--- a/clippy_lints/src/manual_clamp.rs
+++ b/clippy_lints/src/manual_clamp.rs
@@ -12,9 +12,9 @@ use std::ops::Deref;
 
 use clippy_utils::{
     diagnostics::{span_lint_and_then, span_lint_hir_and_then},
-    eq_expr_value, get_trait_def_id,
+    eq_expr_value,
     higher::If,
-    is_diag_trait_item, is_trait_method, meets_msrv, msrvs, path_res, path_to_local_id, paths, peel_blocks,
+    is_diag_trait_item, is_trait_method, meets_msrv, msrvs, path_res, path_to_local_id, peel_blocks,
     peel_blocks_with_stmt,
     sugg::Sugg,
     ty::implements_trait,
@@ -190,7 +190,11 @@ impl TypeClampability {
     fn is_clampable<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Option<TypeClampability> {
         if ty.is_floating_point() {
             Some(TypeClampability::Float)
-        } else if get_trait_def_id(cx, &paths::ORD).map_or(false, |id| implements_trait(cx, ty, id, &[])) {
+        } else if cx
+            .tcx
+            .get_diagnostic_item(sym::Ord)
+            .map_or(false, |id| implements_trait(cx, ty, id, &[]))
+        {
             Some(TypeClampability::Ord)
         } else {
             None
diff --git a/clippy_lints/src/matches/single_match.rs b/clippy_lints/src/matches/single_match.rs
index d496107ffd6..e5a15b2e1a1 100644
--- a/clippy_lints/src/matches/single_match.rs
+++ b/clippy_lints/src/matches/single_match.rs
@@ -1,14 +1,13 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::{expr_block, snippet};
-use clippy_utils::ty::{implements_trait, match_type, peel_mid_ty_refs};
-use clippy_utils::{
-    is_lint_allowed, is_unit_expr, is_wild, paths, peel_blocks, peel_hir_pat_refs, peel_n_hir_expr_refs,
-};
+use clippy_utils::ty::{implements_trait, is_type_diagnostic_item, peel_mid_ty_refs};
+use clippy_utils::{is_lint_allowed, is_unit_expr, is_wild, peel_blocks, peel_hir_pat_refs, peel_n_hir_expr_refs};
 use core::cmp::max;
 use rustc_errors::Applicability;
 use rustc_hir::{Arm, BindingAnnotation, Block, Expr, ExprKind, Pat, PatKind};
 use rustc_lint::LateContext;
 use rustc_middle::ty::{self, Ty};
+use rustc_span::sym;
 
 use super::{MATCH_BOOL, SINGLE_MATCH, SINGLE_MATCH_ELSE};
 
@@ -156,10 +155,10 @@ fn pat_in_candidate_enum<'a>(cx: &LateContext<'a>, ty: Ty<'a>, pat: &Pat<'_>) ->
 /// Returns `true` if the given type is an enum we know won't be expanded in the future
 fn in_candidate_enum<'a>(cx: &LateContext<'a>, ty: Ty<'_>) -> bool {
     // list of candidate `Enum`s we know will never get any more members
-    let candidates = [&paths::COW, &paths::OPTION, &paths::RESULT];
+    let candidates = [sym::Cow, sym::Option, sym::Result];
 
     for candidate_ty in candidates {
-        if match_type(cx, ty, candidate_ty) {
+        if is_type_diagnostic_item(cx, ty, candidate_ty) {
             return true;
         }
     }
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 78c1b33ed97..b0677d1a3ae 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -102,9 +102,7 @@ use bind_instead_of_map::BindInsteadOfMap;
 use clippy_utils::consts::{constant, Constant};
 use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
 use clippy_utils::ty::{contains_adt_constructor, implements_trait, is_copy, is_type_diagnostic_item};
-use clippy_utils::{
-    contains_return, get_trait_def_id, is_trait_method, iter_input_pats, meets_msrv, msrvs, paths, return_ty,
-};
+use clippy_utils::{contains_return, is_trait_method, iter_input_pats, meets_msrv, msrvs, return_ty};
 use if_chain::if_chain;
 use rustc_hir as hir;
 use rustc_hir::def::Res;
@@ -3846,12 +3844,12 @@ impl SelfKind {
                 return m == mutability && t == parent_ty;
             }
 
-            let trait_path = match mutability {
-                hir::Mutability::Not => &paths::ASREF_TRAIT,
-                hir::Mutability::Mut => &paths::ASMUT_TRAIT,
+            let trait_sym = match mutability {
+                hir::Mutability::Not => sym::AsRef,
+                hir::Mutability::Mut => sym::AsMut,
             };
 
-            let Some(trait_def_id) = get_trait_def_id(cx, trait_path) else {
+            let Some(trait_def_id) = cx.tcx.get_diagnostic_item(trait_sym) else {
                 return false
             };
             implements_trait(cx, ty, trait_def_id, &[parent_ty.into()])
diff --git a/clippy_lints/src/methods/option_as_ref_deref.rs b/clippy_lints/src/methods/option_as_ref_deref.rs
index 6fb92d1c663..742483e6b2e 100644
--- a/clippy_lints/src/methods/option_as_ref_deref.rs
+++ b/clippy_lints/src/methods/option_as_ref_deref.rs
@@ -32,8 +32,7 @@ pub(super) fn check<'tcx>(
         return;
     }
 
-    let deref_aliases: [&[&str]; 9] = [
-        &paths::DEREF_TRAIT_METHOD,
+    let deref_aliases: [&[&str]; 8] = [
         &paths::DEREF_MUT_TRAIT_METHOD,
         &paths::CSTRING_AS_C_STR,
         &paths::OS_STRING_AS_OS_STR,
@@ -45,12 +44,14 @@ pub(super) fn check<'tcx>(
     ];
 
     let is_deref = match map_arg.kind {
-        hir::ExprKind::Path(ref expr_qpath) => cx
-            .qpath_res(expr_qpath, map_arg.hir_id)
-            .opt_def_id()
-            .map_or(false, |fun_def_id| {
-                deref_aliases.iter().any(|path| match_def_path(cx, fun_def_id, path))
-            }),
+        hir::ExprKind::Path(ref expr_qpath) => {
+            cx.qpath_res(expr_qpath, map_arg.hir_id)
+                .opt_def_id()
+                .map_or(false, |fun_def_id| {
+                    cx.tcx.is_diagnostic_item(sym::deref_method, fun_def_id)
+                        || deref_aliases.iter().any(|path| match_def_path(cx, fun_def_id, path))
+                })
+        },
         hir::ExprKind::Closure(&hir::Closure { body, .. }) => {
             let closure_body = cx.tcx.hir().body(body);
             let closure_expr = peel_blocks(closure_body.value);
@@ -68,7 +69,8 @@ pub(super) fn check<'tcx>(
                         if let [ty::adjustment::Adjust::Deref(None), ty::adjustment::Adjust::Borrow(_)] = *adj;
                         then {
                             let method_did = cx.typeck_results().type_dependent_def_id(closure_expr.hir_id).unwrap();
-                            deref_aliases.iter().any(|path| match_def_path(cx, method_did, path))
+                            cx.tcx.is_diagnostic_item(sym::deref_method, method_did)
+                                || deref_aliases.iter().any(|path| match_def_path(cx, method_did, path))
                         } else {
                             false
                         }
diff --git a/clippy_lints/src/methods/or_fun_call.rs b/clippy_lints/src/methods/or_fun_call.rs
index 6a35024d036..6e10445659e 100644
--- a/clippy_lints/src/methods/or_fun_call.rs
+++ b/clippy_lints/src/methods/or_fun_call.rs
@@ -1,14 +1,14 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::eager_or_lazy::switch_to_lazy_eval;
 use clippy_utils::source::{snippet, snippet_with_macro_callsite};
-use clippy_utils::ty::{implements_trait, match_type};
-use clippy_utils::{contains_return, is_trait_item, last_path_segment, paths};
+use clippy_utils::ty::{implements_trait, is_type_diagnostic_item};
+use clippy_utils::{contains_return, is_trait_item, last_path_segment};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
 use rustc_span::source_map::Span;
-use rustc_span::symbol::{kw, sym};
+use rustc_span::symbol::{kw, sym, Symbol};
 use std::borrow::Cow;
 
 use super::OR_FUN_CALL;
@@ -88,11 +88,11 @@ pub(super) fn check<'tcx>(
         fun_span: Option<Span>,
     ) {
         // (path, fn_has_argument, methods, suffix)
-        const KNOW_TYPES: [(&[&str], bool, &[&str], &str); 4] = [
-            (&paths::BTREEMAP_ENTRY, false, &["or_insert"], "with"),
-            (&paths::HASHMAP_ENTRY, false, &["or_insert"], "with"),
-            (&paths::OPTION, false, &["map_or", "ok_or", "or", "unwrap_or"], "else"),
-            (&paths::RESULT, true, &["or", "unwrap_or"], "else"),
+        const KNOW_TYPES: [(Symbol, bool, &[&str], &str); 4] = [
+            (sym::BTreeEntry, false, &["or_insert"], "with"),
+            (sym::HashMapEntry, false, &["or_insert"], "with"),
+            (sym::Option, false, &["map_or", "ok_or", "or", "unwrap_or"], "else"),
+            (sym::Result, true, &["or", "unwrap_or"], "else"),
         ];
 
         if_chain! {
@@ -104,7 +104,7 @@ pub(super) fn check<'tcx>(
             let self_ty = cx.typeck_results().expr_ty(self_expr);
 
             if let Some(&(_, fn_has_arguments, poss, suffix)) =
-                KNOW_TYPES.iter().find(|&&i| match_type(cx, self_ty, i.0));
+                KNOW_TYPES.iter().find(|&&i| is_type_diagnostic_item(cx, self_ty, i.0));
 
             if poss.contains(&name);
 
diff --git a/clippy_lints/src/neg_cmp_op_on_partial_ord.rs b/clippy_lints/src/neg_cmp_op_on_partial_ord.rs
index a7e0e35787c..c949cede8e1 100644
--- a/clippy_lints/src/neg_cmp_op_on_partial_ord.rs
+++ b/clippy_lints/src/neg_cmp_op_on_partial_ord.rs
@@ -1,11 +1,11 @@
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::ty::implements_trait;
-use clippy_utils::{self, get_trait_def_id, paths};
 use if_chain::if_chain;
 use rustc_hir::{BinOpKind, Expr, ExprKind, UnOp};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::sym;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -58,7 +58,7 @@ impl<'tcx> LateLintPass<'tcx> for NoNegCompOpForPartialOrd {
                 let ty = cx.typeck_results().expr_ty(left);
 
                 let implements_ord = {
-                    if let Some(id) = get_trait_def_id(cx, &paths::ORD) {
+                    if let Some(id) = cx.tcx.get_diagnostic_item(sym::Ord) {
                         implements_trait(cx, ty, id, &[])
                     } else {
                         return;
diff --git a/clippy_lints/src/operators/cmp_owned.rs b/clippy_lints/src/operators/cmp_owned.rs
index c9c777f1bd8..24aeb82a37f 100644
--- a/clippy_lints/src/operators/cmp_owned.rs
+++ b/clippy_lints/src/operators/cmp_owned.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::{implements_trait, is_copy};
-use clippy_utils::{match_any_def_paths, path_def_id, paths};
+use clippy_utils::{match_def_path, path_def_id, paths};
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind, UnOp};
 use rustc_lint::LateContext;
@@ -49,13 +49,15 @@ fn check_op(cx: &LateContext<'_>, expr: &Expr<'_>, other: &Expr<'_>, left: bool)
             (arg, arg.span)
         },
         ExprKind::Call(path, [arg])
-            if path_def_id(cx, path)
-                .and_then(|id| match_any_def_paths(cx, id, &[&paths::FROM_STR_METHOD, &paths::FROM_FROM]))
-                .map_or(false, |idx| match idx {
-                    0 => true,
-                    1 => !is_copy(cx, typeck.expr_ty(expr)),
-                    _ => false,
-                }) =>
+            if path_def_id(cx, path).map_or(false, |id| {
+                if match_def_path(cx, id, &paths::FROM_STR_METHOD) {
+                    true
+                } else if cx.tcx.lang_items().from_fn() == Some(id) {
+                    !is_copy(cx, typeck.expr_ty(expr))
+                } else {
+                    false
+                }
+            }) =>
         {
             (arg, arg.span)
         },
diff --git a/clippy_lints/src/unit_return_expecting_ord.rs b/clippy_lints/src/unit_return_expecting_ord.rs
index 57aff5367dd..fc2ee9e5a4d 100644
--- a/clippy_lints/src/unit_return_expecting_ord.rs
+++ b/clippy_lints/src/unit_return_expecting_ord.rs
@@ -1,5 +1,4 @@
 use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
-use clippy_utils::{get_trait_def_id, paths};
 use if_chain::if_chain;
 use rustc_hir::def_id::DefId;
 use rustc_hir::{Closure, Expr, ExprKind, StmtKind};
@@ -7,7 +6,7 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
 use rustc_middle::ty::{GenericPredicates, PredicateKind, ProjectionPredicate, TraitPredicate};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::{BytePos, Span};
+use rustc_span::{sym, BytePos, Span};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -80,7 +79,7 @@ fn get_args_to_check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> Ve
         let fn_sig = cx.tcx.fn_sig(def_id);
         let generics = cx.tcx.predicates_of(def_id);
         let fn_mut_preds = get_trait_predicates_for_trait_id(cx, generics, cx.tcx.lang_items().fn_mut_trait());
-        let ord_preds = get_trait_predicates_for_trait_id(cx, generics, get_trait_def_id(cx, &paths::ORD));
+        let ord_preds = get_trait_predicates_for_trait_id(cx, generics, cx.tcx.get_diagnostic_item(sym::Ord));
         let partial_ord_preds =
             get_trait_predicates_for_trait_id(cx, generics, cx.tcx.lang_items().partial_ord_trait());
         // Trying to call erase_late_bound_regions on fn_sig.inputs() gives the following error
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index dbe75b43cb2..cbc2fde69d1 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -1766,6 +1766,7 @@ pub fn any_parent_is_automatically_derived(tcx: TyCtxt<'_>, node: HirId) -> bool
 /// ```rust,ignore
 /// if let Some(args) = match_function_call(cx, cmp_max_call, &paths::CMP_MAX);
 /// ```
+/// This function is deprecated. Use [`match_function_call_with_def_id`].
 pub fn match_function_call<'tcx>(
     cx: &LateContext<'tcx>,
     expr: &'tcx Expr<'_>,
@@ -1783,6 +1784,22 @@ pub fn match_function_call<'tcx>(
     None
 }
 
+pub fn match_function_call_with_def_id<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx Expr<'_>,
+    fun_def_id: DefId,
+) -> Option<&'tcx [Expr<'tcx>]> {
+    if_chain! {
+        if let ExprKind::Call(fun, args) = expr.kind;
+        if let ExprKind::Path(ref qpath) = fun.kind;
+        if cx.qpath_res(qpath, fun.hir_id).opt_def_id() == Some(fun_def_id);
+        then {
+            return Some(args);
+        }
+    };
+    None
+}
+
 /// Checks if the given `DefId` matches any of the paths. Returns the index of matching path, if
 /// any.
 ///
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index 78adc453654..bc851473430 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -16,25 +16,17 @@ pub const APPLICABILITY_VALUES: [[&str; 3]; 4] = [
 #[cfg(feature = "internal")]
 pub const DIAGNOSTIC_BUILDER: [&str; 3] = ["rustc_errors", "diagnostic_builder", "DiagnosticBuilder"];
 pub const ARC_PTR_EQ: [&str; 4] = ["alloc", "sync", "Arc", "ptr_eq"];
-pub const ASMUT_TRAIT: [&str; 3] = ["core", "convert", "AsMut"];
-pub const ASREF_TRAIT: [&str; 3] = ["core", "convert", "AsRef"];
 pub const BTREEMAP_CONTAINS_KEY: [&str; 6] = ["alloc", "collections", "btree", "map", "BTreeMap", "contains_key"];
-pub const BTREEMAP_ENTRY: [&str; 6] = ["alloc", "collections", "btree", "map", "entry", "Entry"];
 pub const BTREEMAP_INSERT: [&str; 6] = ["alloc", "collections", "btree", "map", "BTreeMap", "insert"];
 pub const BTREESET_ITER: [&str; 6] = ["alloc", "collections", "btree", "set", "BTreeSet", "iter"];
 pub const CLONE_TRAIT_METHOD: [&str; 4] = ["core", "clone", "Clone", "clone"];
-pub const COW: [&str; 3] = ["alloc", "borrow", "Cow"];
 pub const CORE_ITER_COLLECT: [&str; 6] = ["core", "iter", "traits", "iterator", "Iterator", "collect"];
 pub const CORE_ITER_CLONED: [&str; 6] = ["core", "iter", "traits", "iterator", "Iterator", "cloned"];
 pub const CORE_ITER_COPIED: [&str; 6] = ["core", "iter", "traits", "iterator", "Iterator", "copied"];
 pub const CORE_ITER_FILTER: [&str; 6] = ["core", "iter", "traits", "iterator", "Iterator", "filter"];
-pub const CORE_ITER_INTO_ITER: [&str; 6] = ["core", "iter", "traits", "collect", "IntoIterator", "into_iter"];
 pub const CSTRING_AS_C_STR: [&str; 5] = ["alloc", "ffi", "c_str", "CString", "as_c_str"];
 pub const DEFAULT_TRAIT_METHOD: [&str; 4] = ["core", "default", "Default", "default"];
 pub const DEREF_MUT_TRAIT_METHOD: [&str; 5] = ["core", "ops", "deref", "DerefMut", "deref_mut"];
-/// Preferably use the diagnostic item `sym::deref_method` where possible
-pub const DEREF_TRAIT_METHOD: [&str; 5] = ["core", "ops", "deref", "Deref", "deref"];
-pub const DISPLAY_TRAIT: [&str; 3] = ["core", "fmt", "Display"];
 #[cfg(feature = "internal")]
 pub const EARLY_CONTEXT: [&str; 2] = ["rustc_lint", "EarlyContext"];
 #[cfg(feature = "internal")]
@@ -42,30 +34,22 @@ pub const EARLY_LINT_PASS: [&str; 3] = ["rustc_lint", "passes", "EarlyLintPass"]
 pub const EXIT: [&str; 3] = ["std", "process", "exit"];
 pub const F32_EPSILON: [&str; 4] = ["core", "f32", "<impl f32>", "EPSILON"];
 pub const F64_EPSILON: [&str; 4] = ["core", "f64", "<impl f64>", "EPSILON"];
-pub const FILE: [&str; 3] = ["std", "fs", "File"];
-pub const FILE_TYPE: [&str; 3] = ["std", "fs", "FileType"];
-pub const FROM_FROM: [&str; 4] = ["core", "convert", "From", "from"];
 pub const FROM_ITERATOR_METHOD: [&str; 6] = ["core", "iter", "traits", "collect", "FromIterator", "from_iter"];
 pub const FROM_STR_METHOD: [&str; 5] = ["core", "str", "traits", "FromStr", "from_str"];
-pub const FUTURE_FROM_GENERATOR: [&str; 3] = ["core", "future", "from_generator"];
 #[expect(clippy::invalid_paths)] // internal lints do not know about all external crates
 pub const FUTURES_IO_ASYNCREADEXT: [&str; 3] = ["futures_util", "io", "AsyncReadExt"];
 #[expect(clippy::invalid_paths)] // internal lints do not know about all external crates
 pub const FUTURES_IO_ASYNCWRITEEXT: [&str; 3] = ["futures_util", "io", "AsyncWriteExt"];
 pub const HASHMAP_CONTAINS_KEY: [&str; 6] = ["std", "collections", "hash", "map", "HashMap", "contains_key"];
-pub const HASHMAP_ENTRY: [&str; 5] = ["std", "collections", "hash", "map", "Entry"];
 pub const HASHMAP_INSERT: [&str; 6] = ["std", "collections", "hash", "map", "HashMap", "insert"];
 pub const HASHSET_ITER: [&str; 6] = ["std", "collections", "hash", "set", "HashSet", "iter"];
 #[cfg(feature = "internal")]
 pub const IDENT: [&str; 3] = ["rustc_span", "symbol", "Ident"];
 #[cfg(feature = "internal")]
 pub const IDENT_AS_STR: [&str; 4] = ["rustc_span", "symbol", "Ident", "as_str"];
-pub const INDEX: [&str; 3] = ["core", "ops", "Index"];
-pub const INDEX_MUT: [&str; 3] = ["core", "ops", "IndexMut"];
 pub const INSERT_STR: [&str; 4] = ["alloc", "string", "String", "insert_str"];
 pub const ITER_COUNT: [&str; 6] = ["core", "iter", "traits", "iterator", "Iterator", "count"];
 pub const ITER_EMPTY: [&str; 5] = ["core", "iter", "sources", "empty", "Empty"];
-pub const ITER_REPEAT: [&str; 5] = ["core", "iter", "sources", "repeat", "repeat"];
 pub const ITERTOOLS_NEXT_TUPLE: [&str; 3] = ["itertools", "Itertools", "next_tuple"];
 #[cfg(feature = "internal")]
 pub const KW_MODULE: [&str; 3] = ["rustc_span", "symbol", "kw"];
@@ -76,13 +60,7 @@ pub const LATE_LINT_PASS: [&str; 3] = ["rustc_lint", "passes", "LateLintPass"];
 #[cfg(feature = "internal")]
 pub const LINT: [&str; 2] = ["rustc_lint_defs", "Lint"];
 pub const MEM_SWAP: [&str; 3] = ["core", "mem", "swap"];
-pub const MUTEX_GUARD: [&str; 4] = ["std", "sync", "mutex", "MutexGuard"];
 pub const OPEN_OPTIONS: [&str; 3] = ["std", "fs", "OpenOptions"];
-/// Preferably use the diagnostic item `sym::Option` where possible
-pub const OPTION: [&str; 3] = ["core", "option", "Option"];
-pub const OPTION_NONE: [&str; 4] = ["core", "option", "Option", "None"];
-pub const OPTION_SOME: [&str; 4] = ["core", "option", "Option", "Some"];
-pub const ORD: [&str; 3] = ["core", "cmp", "Ord"];
 pub const OS_STRING_AS_OS_STR: [&str; 5] = ["std", "ffi", "os_str", "OsString", "as_os_str"];
 pub const OS_STR_TO_OS_STRING: [&str; 5] = ["std", "ffi", "os_str", "OsStr", "to_os_string"];
 pub const PARKING_LOT_MUTEX_GUARD: [&str; 3] = ["lock_api", "mutex", "MutexGuard"];
@@ -95,8 +73,6 @@ pub const PERMISSIONS: [&str; 3] = ["std", "fs", "Permissions"];
 #[cfg_attr(not(unix), allow(clippy::invalid_paths))]
 pub const PERMISSIONS_FROM_MODE: [&str; 6] = ["std", "os", "unix", "fs", "PermissionsExt", "from_mode"];
 pub const POLL: [&str; 4] = ["core", "task", "poll", "Poll"];
-pub const POLL_PENDING: [&str; 5] = ["core", "task", "poll", "Poll", "Pending"];
-pub const POLL_READY: [&str; 5] = ["core", "task", "poll", "Poll", "Ready"];
 pub const PTR_COPY: [&str; 3] = ["core", "intrinsics", "copy"];
 pub const PTR_COPY_NONOVERLAPPING: [&str; 3] = ["core", "intrinsics", "copy_nonoverlapping"];
 pub const PTR_EQ: [&str; 3] = ["core", "ptr", "eq"];
@@ -125,14 +101,8 @@ pub const REGEX_BYTES_NEW: [&str; 4] = ["regex", "re_bytes", "Regex", "new"];
 pub const REGEX_BYTES_SET_NEW: [&str; 5] = ["regex", "re_set", "bytes", "RegexSet", "new"];
 pub const REGEX_NEW: [&str; 4] = ["regex", "re_unicode", "Regex", "new"];
 pub const REGEX_SET_NEW: [&str; 5] = ["regex", "re_set", "unicode", "RegexSet", "new"];
-/// Preferably use the diagnostic item `sym::Result` where possible
-pub const RESULT: [&str; 3] = ["core", "result", "Result"];
-pub const RESULT_ERR: [&str; 4] = ["core", "result", "Result", "Err"];
-pub const RESULT_OK: [&str; 4] = ["core", "result", "Result", "Ok"];
 #[cfg(feature = "internal")]
 pub const RUSTC_VERSION: [&str; 2] = ["rustc_semver", "RustcVersion"];
-pub const RWLOCK_READ_GUARD: [&str; 4] = ["std", "sync", "rwlock", "RwLockReadGuard"];
-pub const RWLOCK_WRITE_GUARD: [&str; 4] = ["std", "sync", "rwlock", "RwLockWriteGuard"];
 pub const SERDE_DESERIALIZE: [&str; 3] = ["serde", "de", "Deserialize"];
 pub const SERDE_DE_VISITOR: [&str; 3] = ["serde", "de", "Visitor"];
 pub const SLICE_FROM_RAW_PARTS: [&str; 4] = ["core", "slice", "raw", "from_raw_parts"];
diff --git a/tests/ui-internal/invalid_paths.rs b/tests/ui-internal/invalid_paths.rs
index b823ff7fe37..9a9790a4bae 100644
--- a/tests/ui-internal/invalid_paths.rs
+++ b/tests/ui-internal/invalid_paths.rs
@@ -1,5 +1,5 @@
 #![warn(clippy::internal)]
-#![allow(clippy::missing_clippy_version_attribute)]
+#![allow(clippy::missing_clippy_version_attribute, clippy::unnecessary_def_path)]
 
 mod paths {
     // Good path
-- 
cgit 1.4.1-3-g733a5


From 5dc54c60660b2e37c2978c38df9298edcc2988f2 Mon Sep 17 00:00:00 2001
From: Samuel Moelius <sam@moeli.us>
Date: Sun, 9 Oct 2022 07:01:49 -0400
Subject: Format affected files

---
 clippy_lints/src/let_underscore.rs                 |  8 +--
 clippy_lints/src/loops/needless_range_loop.rs      | 24 +++++---
 clippy_lints/src/manual_async_fn.rs                |  9 ++-
 clippy_lints/src/methods/mod.rs                    | 10 +++-
 clippy_lints/src/methods/or_fun_call.rs            |  5 +-
 clippy_lints/src/neg_cmp_op_on_partial_ord.rs      |  4 +-
 clippy_lints/src/unit_return_expecting_ord.rs      | 12 ++--
 .../src/utils/internal_lints/collapsible_calls.rs  | 13 ++--
 .../internal_lints/compiler_lint_functions.rs      |  3 +-
 .../src/utils/internal_lints/if_chain_style.rs     |  5 +-
 .../src/utils/internal_lints/invalid_paths.rs      |  7 ++-
 .../utils/internal_lints/lint_without_lint_pass.rs |  6 +-
 .../src/utils/internal_lints/metadata_collector.rs |  6 +-
 .../utils/internal_lints/outer_expn_data_pass.rs   |  2 +-
 .../utils/internal_lints/unnecessary_def_path.rs   | 70 +++++++++++-----------
 15 files changed, 104 insertions(+), 80 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/let_underscore.rs b/clippy_lints/src/let_underscore.rs
index 6d50dcc8806..b7798b1c1d7 100644
--- a/clippy_lints/src/let_underscore.rs
+++ b/clippy_lints/src/let_underscore.rs
@@ -137,7 +137,7 @@ impl<'tcx> LateLintPass<'tcx> for LetUnderscore {
                         "non-binding let on a synchronization lock",
                         None,
                         "consider using an underscore-prefixed named \
-                            binding or dropping explicitly with `std::mem::drop`"
+                            binding or dropping explicitly with `std::mem::drop`",
                     );
                 } else if init_ty.needs_drop(cx.tcx, cx.param_env) {
                     span_lint_and_help(
@@ -147,7 +147,7 @@ impl<'tcx> LateLintPass<'tcx> for LetUnderscore {
                         "non-binding `let` on a type that implements `Drop`",
                         None,
                         "consider using an underscore-prefixed named \
-                            binding or dropping explicitly with `std::mem::drop`"
+                            binding or dropping explicitly with `std::mem::drop`",
                     );
                 } else if is_must_use_ty(cx, cx.typeck_results().expr_ty(init)) {
                     span_lint_and_help(
@@ -156,7 +156,7 @@ impl<'tcx> LateLintPass<'tcx> for LetUnderscore {
                         local.span,
                         "non-binding let on an expression with `#[must_use]` type",
                         None,
-                        "consider explicitly using expression value"
+                        "consider explicitly using expression value",
                     );
                 } else if is_must_use_func_call(cx, init) {
                     span_lint_and_help(
@@ -165,7 +165,7 @@ impl<'tcx> LateLintPass<'tcx> for LetUnderscore {
                         local.span,
                         "non-binding let on a result of a `#[must_use]` function",
                         None,
-                        "consider explicitly using function result"
+                        "consider explicitly using function result",
                     );
                 }
             }
diff --git a/clippy_lints/src/loops/needless_range_loop.rs b/clippy_lints/src/loops/needless_range_loop.rs
index 2b1c5688e82..27ba27202bf 100644
--- a/clippy_lints/src/loops/needless_range_loop.rs
+++ b/clippy_lints/src/loops/needless_range_loop.rs
@@ -263,7 +263,8 @@ impl<'a, 'tcx> VarVisitor<'a, 'tcx> {
                 match res {
                     Res::Local(hir_id) => {
                         let parent_def_id = self.cx.tcx.hir().get_parent_item(expr.hir_id);
-                        let extent = self.cx
+                        let extent = self
+                            .cx
                             .tcx
                             .region_scope_tree(parent_def_id)
                             .var_scope(hir_id.local_id)
@@ -274,11 +275,12 @@ impl<'a, 'tcx> VarVisitor<'a, 'tcx> {
                                 (Some(extent), self.cx.typeck_results().node_type(seqexpr.hir_id)),
                             );
                         } else {
-                            self.indexed_indirectly.insert(seqvar.segments[0].ident.name, Some(extent));
+                            self.indexed_indirectly
+                                .insert(seqvar.segments[0].ident.name, Some(extent));
                         }
-                        return false;  // no need to walk further *on the variable*
-                    }
-                    Res::Def(DefKind::Static (_)| DefKind::Const, ..) => {
+                        return false; // no need to walk further *on the variable*
+                    },
+                    Res::Def(DefKind::Static(_) | DefKind::Const, ..) => {
                         if index_used_directly {
                             self.indexed_directly.insert(
                                 seqvar.segments[0].ident.name,
@@ -287,8 +289,8 @@ impl<'a, 'tcx> VarVisitor<'a, 'tcx> {
                         } else {
                             self.indexed_indirectly.insert(seqvar.segments[0].ident.name, None);
                         }
-                        return false;  // no need to walk further *on the variable*
-                    }
+                        return false; // no need to walk further *on the variable*
+                    },
                     _ => (),
                 }
             }
@@ -310,14 +312,18 @@ impl<'a, 'tcx> Visitor<'tcx> for VarVisitor<'a, 'tcx> {
             if (meth.ident.name == sym::index && self.cx.tcx.lang_items().index_trait() == Some(trait_id))
                 || (meth.ident.name == sym::index_mut && self.cx.tcx.lang_items().index_mut_trait() == Some(trait_id));
             if !self.check(args_1, args_0, expr);
-            then { return }
+            then {
+                return;
+            }
         }
 
         if_chain! {
             // an index op
             if let ExprKind::Index(seqexpr, idx) = expr.kind;
             if !self.check(idx, seqexpr, expr);
-            then { return }
+            then {
+                return;
+            }
         }
 
         if_chain! {
diff --git a/clippy_lints/src/manual_async_fn.rs b/clippy_lints/src/manual_async_fn.rs
index 570d83c7ea8..090f9f8ff73 100644
--- a/clippy_lints/src/manual_async_fn.rs
+++ b/clippy_lints/src/manual_async_fn.rs
@@ -139,9 +139,9 @@ fn future_output_ty<'tcx>(trait_ref: &'tcx TraitRef<'tcx>) -> Option<&'tcx Ty<'t
         if args.bindings.len() == 1;
         let binding = &args.bindings[0];
         if binding.ident.name == sym::Output;
-        if let TypeBindingKind::Equality{term: Term::Ty(output)} = binding.kind;
+        if let TypeBindingKind::Equality { term: Term::Ty(output) } = binding.kind;
         then {
-            return Some(output)
+            return Some(output);
         }
     }
 
@@ -180,7 +180,10 @@ fn desugared_async_block<'tcx>(cx: &LateContext<'tcx>, block: &'tcx Block<'tcx>)
             .from_generator_fn()
             .and_then(|def_id| match_function_call_with_def_id(cx, block_expr, def_id));
         if args.len() == 1;
-        if let Expr{kind: ExprKind::Closure(&Closure { body, .. }), ..} = args[0];
+        if let Expr {
+            kind: ExprKind::Closure(&Closure { body, .. }),
+            ..
+        } = args[0];
         let closure_body = cx.tcx.hir().body(body);
         if closure_body.generator_kind == Some(GeneratorKind::Async(AsyncGeneratorKind::Block));
         then {
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index b0677d1a3ae..fb92779be2a 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3370,7 +3370,9 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             then {
                 let first_arg_span = first_arg_ty.span;
                 let first_arg_ty = hir_ty_to_ty(cx.tcx, first_arg_ty);
-                let self_ty = TraitRef::identity(cx.tcx, item.def_id.to_def_id()).self_ty().skip_binder();
+                let self_ty = TraitRef::identity(cx.tcx, item.def_id.to_def_id())
+                    .self_ty()
+                    .skip_binder();
                 wrong_self_convention::check(
                     cx,
                     item.ident.name.as_str(),
@@ -3378,7 +3380,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
                     first_arg_ty,
                     first_arg_span,
                     false,
-                    true
+                    true,
                 );
             }
         }
@@ -3387,7 +3389,9 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             if item.ident.name == sym::new;
             if let TraitItemKind::Fn(_, _) = item.kind;
             let ret_ty = return_ty(cx, item.hir_id());
-            let self_ty = TraitRef::identity(cx.tcx, item.def_id.to_def_id()).self_ty().skip_binder();
+            let self_ty = TraitRef::identity(cx.tcx, item.def_id.to_def_id())
+                .self_ty()
+                .skip_binder();
             if !ret_ty.contains(self_ty);
 
             then {
diff --git a/clippy_lints/src/methods/or_fun_call.rs b/clippy_lints/src/methods/or_fun_call.rs
index 6e10445659e..991d3dd538b 100644
--- a/clippy_lints/src/methods/or_fun_call.rs
+++ b/clippy_lints/src/methods/or_fun_call.rs
@@ -121,10 +121,9 @@ pub(super) fn check<'tcx>(
                             macro_expanded_snipped = snippet(cx, snippet_span, "..");
                             match macro_expanded_snipped.strip_prefix("$crate::vec::") {
                                 Some(stripped) => Cow::from(stripped),
-                                None => macro_expanded_snipped
+                                None => macro_expanded_snipped,
                             }
-                        }
-                        else {
+                        } else {
                             not_macro_argument_snippet
                         }
                     };
diff --git a/clippy_lints/src/neg_cmp_op_on_partial_ord.rs b/clippy_lints/src/neg_cmp_op_on_partial_ord.rs
index c949cede8e1..5c2b96f5b2c 100644
--- a/clippy_lints/src/neg_cmp_op_on_partial_ord.rs
+++ b/clippy_lints/src/neg_cmp_op_on_partial_ord.rs
@@ -47,14 +47,12 @@ declare_lint_pass!(NoNegCompOpForPartialOrd => [NEG_CMP_OP_ON_PARTIAL_ORD]);
 impl<'tcx> LateLintPass<'tcx> for NoNegCompOpForPartialOrd {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if_chain! {
-
             if !in_external_macro(cx.sess(), expr.span);
             if let ExprKind::Unary(UnOp::Not, inner) = expr.kind;
             if let ExprKind::Binary(ref op, left, _) = inner.kind;
             if let BinOpKind::Le | BinOpKind::Ge | BinOpKind::Lt | BinOpKind::Gt = op.node;
 
             then {
-
                 let ty = cx.typeck_results().expr_ty(left);
 
                 let implements_ord = {
@@ -81,7 +79,7 @@ impl<'tcx> LateLintPass<'tcx> for NoNegCompOpForPartialOrd {
                         "the use of negated comparison operators on partially ordered \
                         types produces code that is hard to read and refactor, please \
                         consider using the `partial_cmp` method instead, to make it \
-                        clear that the two values could be incomparable"
+                        clear that the two values could be incomparable",
                     );
                 }
             }
diff --git a/clippy_lints/src/unit_return_expecting_ord.rs b/clippy_lints/src/unit_return_expecting_ord.rs
index fc2ee9e5a4d..1307288623f 100644
--- a/clippy_lints/src/unit_return_expecting_ord.rs
+++ b/clippy_lints/src/unit_return_expecting_ord.rs
@@ -98,11 +98,15 @@ fn get_args_to_check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> Ve
                         if trait_pred.self_ty() == inp;
                         if let Some(return_ty_pred) = get_projection_pred(cx, generics, *trait_pred);
                         then {
-                            if ord_preds.iter().any(|ord| Some(ord.self_ty()) == return_ty_pred.term.ty()) {
+                            if ord_preds
+                                .iter()
+                                .any(|ord| Some(ord.self_ty()) == return_ty_pred.term.ty())
+                            {
                                 args_to_check.push((i, "Ord".to_string()));
-                            } else if partial_ord_preds.iter().any(|pord| {
-                                pord.self_ty() == return_ty_pred.term.ty().unwrap()
-                            }) {
+                            } else if partial_ord_preds
+                                .iter()
+                                .any(|pord| pord.self_ty() == return_ty_pred.term.ty().unwrap())
+                            {
                                 args_to_check.push((i, "PartialOrd".to_string()));
                             }
                         }
diff --git a/clippy_lints/src/utils/internal_lints/collapsible_calls.rs b/clippy_lints/src/utils/internal_lints/collapsible_calls.rs
index c9089aecfa5..d7666b77f6e 100644
--- a/clippy_lints/src/utils/internal_lints/collapsible_calls.rs
+++ b/clippy_lints/src/utils/internal_lints/collapsible_calls.rs
@@ -92,7 +92,12 @@ impl<'tcx> LateLintPass<'tcx> for CollapsibleCalls {
                 let mut sle = SpanlessEq::new(cx).deny_side_effects();
                 match ps.ident.as_str() {
                     "span_suggestion" if sle.eq_expr(&and_then_args[2], &span_call_args[0]) => {
-                        suggest_suggestion(cx, expr, &and_then_snippets, &span_suggestion_snippets(cx, span_call_args));
+                        suggest_suggestion(
+                            cx,
+                            expr,
+                            &and_then_snippets,
+                            &span_suggestion_snippets(cx, span_call_args),
+                        );
                     },
                     "span_help" if sle.eq_expr(&and_then_args[2], &span_call_args[0]) => {
                         let help_snippet = snippet(cx, span_call_args[1].span, r#""...""#);
@@ -105,12 +110,12 @@ impl<'tcx> LateLintPass<'tcx> for CollapsibleCalls {
                     "help" => {
                         let help_snippet = snippet(cx, span_call_args[0].span, r#""...""#);
                         suggest_help(cx, expr, &and_then_snippets, help_snippet.borrow(), false);
-                    }
+                    },
                     "note" => {
                         let note_snippet = snippet(cx, span_call_args[0].span, r#""...""#);
                         suggest_note(cx, expr, &and_then_snippets, note_snippet.borrow(), false);
-                    }
-                    _  => (),
+                    },
+                    _ => (),
                 }
             }
         }
diff --git a/clippy_lints/src/utils/internal_lints/compiler_lint_functions.rs b/clippy_lints/src/utils/internal_lints/compiler_lint_functions.rs
index d7e4a2c4422..cacd05262a2 100644
--- a/clippy_lints/src/utils/internal_lints/compiler_lint_functions.rs
+++ b/clippy_lints/src/utils/internal_lints/compiler_lint_functions.rs
@@ -61,8 +61,7 @@ impl<'tcx> LateLintPass<'tcx> for CompilerLintFunctions {
             let fn_name = path.ident;
             if let Some(sugg) = self.map.get(fn_name.as_str());
             let ty = cx.typeck_results().expr_ty(self_arg).peel_refs();
-            if match_type(cx, ty, &paths::EARLY_CONTEXT)
-                || match_type(cx, ty, &paths::LATE_CONTEXT);
+            if match_type(cx, ty, &paths::EARLY_CONTEXT) || match_type(cx, ty, &paths::LATE_CONTEXT);
             then {
                 span_lint_and_help(
                     cx,
diff --git a/clippy_lints/src/utils/internal_lints/if_chain_style.rs b/clippy_lints/src/utils/internal_lints/if_chain_style.rs
index a863fdc9d50..883a5c08e5c 100644
--- a/clippy_lints/src/utils/internal_lints/if_chain_style.rs
+++ b/clippy_lints/src/utils/internal_lints/if_chain_style.rs
@@ -94,7 +94,10 @@ fn check_nested_if_chains(
             .iter()
             .all(|stmt| matches!(stmt.kind, StmtKind::Local(..)) && !sm.is_multiline(stmt.span));
         if if_chain_span.is_some() || !is_else_clause(cx.tcx, if_expr);
-        then {} else { return }
+        then {
+        } else {
+            return;
+        }
     }
     let (span, msg) = match (if_chain_span, is_expn_of(tail.span, "if_chain")) {
         (None, Some(_)) => (if_expr.span, "this `if` can be part of the inner `if_chain!`"),
diff --git a/clippy_lints/src/utils/internal_lints/invalid_paths.rs b/clippy_lints/src/utils/internal_lints/invalid_paths.rs
index 04f1952e813..25532dd4e26 100644
--- a/clippy_lints/src/utils/internal_lints/invalid_paths.rs
+++ b/clippy_lints/src/utils/internal_lints/invalid_paths.rs
@@ -41,14 +41,17 @@ impl<'tcx> LateLintPass<'tcx> for InvalidPaths {
             let body = cx.tcx.hir().body(body_id);
             let typeck_results = cx.tcx.typeck_body(body_id);
             if let Some(Constant::Vec(path)) = constant_simple(cx, typeck_results, body.value);
-            let path: Vec<&str> = path.iter().map(|x| {
+            let path: Vec<&str> = path
+                .iter()
+                .map(|x| {
                     if let Constant::Str(s) = x {
                         s.as_str()
                     } else {
                         // We checked the type of the constant above
                         unreachable!()
                     }
-                }).collect();
+                })
+                .collect();
             if !check_path(cx, &path[..]);
             then {
                 span_lint(cx, INVALID_PATHS, item.span, "invalid path");
diff --git a/clippy_lints/src/utils/internal_lints/lint_without_lint_pass.rs b/clippy_lints/src/utils/internal_lints/lint_without_lint_pass.rs
index 06dfc6e4360..0dac64376b0 100644
--- a/clippy_lints/src/utils/internal_lints/lint_without_lint_pass.rs
+++ b/clippy_lints/src/utils/internal_lints/lint_without_lint_pass.rs
@@ -317,11 +317,7 @@ pub(super) fn extract_clippy_version_value(cx: &LateContext<'_>, item: &'_ Item<
             if tool_name.ident.name == sym::clippy;
             if attr_name.ident.name == sym::version;
             if let Some(version) = attr.value_str();
-            then {
-                Some(version)
-            } else {
-                None
-            }
+            then { Some(version) } else { None }
         }
     })
 }
diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index 8efe170a1e5..d06a616e4b3 100644
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -532,7 +532,11 @@ fn parse_config_field_doc(doc_comment: &str) -> Option<(Vec<String>, String)> {
 
             // Extract lints
             doc_comment.make_ascii_lowercase();
-            let lints: Vec<String> = doc_comment.split_off(DOC_START.len()).split(", ").map(str::to_string).collect();
+            let lints: Vec<String> = doc_comment
+                .split_off(DOC_START.len())
+                .split(", ")
+                .map(str::to_string)
+                .collect();
 
             // Format documentation correctly
             // split off leading `.` from lint name list and indent for correct formatting
diff --git a/clippy_lints/src/utils/internal_lints/outer_expn_data_pass.rs b/clippy_lints/src/utils/internal_lints/outer_expn_data_pass.rs
index 3bc05d69579..2b13fad8066 100644
--- a/clippy_lints/src/utils/internal_lints/outer_expn_data_pass.rs
+++ b/clippy_lints/src/utils/internal_lints/outer_expn_data_pass.rs
@@ -42,7 +42,7 @@ impl<'tcx> LateLintPass<'tcx> for OuterExpnDataPass {
         let method_names: Vec<&str> = method_names.iter().map(Symbol::as_str).collect();
         if_chain! {
             if let ["expn_data", "outer_expn"] = method_names.as_slice();
-            let (self_arg, args)= arg_lists[1];
+            let (self_arg, args) = arg_lists[1];
             if args.is_empty();
             let self_ty = cx.typeck_results().expr_ty(self_arg).peel_refs();
             if match_type(cx, self_ty, &paths::SYNTAX_CONTEXT);
diff --git a/clippy_lints/src/utils/internal_lints/unnecessary_def_path.rs b/clippy_lints/src/utils/internal_lints/unnecessary_def_path.rs
index 0a3852c98ee..4cf76f53625 100644
--- a/clippy_lints/src/utils/internal_lints/unnecessary_def_path.rs
+++ b/clippy_lints/src/utils/internal_lints/unnecessary_def_path.rs
@@ -102,7 +102,7 @@ impl UnnecessaryDefPath {
         ];
 
         if_chain! {
-            if let [cx_arg, def_arg, args@..] = args;
+            if let [cx_arg, def_arg, args @ ..] = args;
             if let ExprKind::Path(path) = &func.kind;
             if let Some(id) = cx.qpath_res(path, func.hir_id).opt_def_id();
             if let Some(which_path) = match_any_def_paths(cx, id, PATHS);
@@ -113,6 +113,7 @@ impl UnnecessaryDefPath {
             if let Some(def_id) = inherent_def_path_res(cx, &segments[..]);
             then {
                 // Check if the target item is a diagnostic item or LangItem.
+                #[rustfmt::skip]
                 let (msg, item) = if let Some(item_name)
                     = cx.tcx.diagnostic_items(def_id.krate).id_to_name.get(&def_id)
                 {
@@ -133,11 +134,11 @@ impl UnnecessaryDefPath {
                     DefKind::Struct => {
                         let variant = cx.tcx.adt_def(def_id).non_enum_variant();
                         variant.ctor_def_id.is_some() && variant.fields.iter().all(|f| f.vis.is_public())
-                    }
+                    },
                     DefKind::Variant => {
                         let variant = cx.tcx.adt_def(cx.tcx.parent(def_id)).variant_with_id(def_id);
                         variant.ctor_def_id.is_some() && variant.fields.iter().all(|f| f.vis.is_public())
-                    }
+                    },
                     _ => false,
                 };
 
@@ -146,35 +147,40 @@ impl UnnecessaryDefPath {
                 let def_snip = snippet_with_applicability(cx, def_arg.span, "..", &mut app);
                 let (sugg, with_note) = match (which_path, item) {
                     // match_def_path
-                    (0, Item::DiagnosticItem(item)) =>
-                        (format!("{cx_snip}.tcx.is_diagnostic_item(sym::{item}, {def_snip})"), has_ctor),
+                    (0, Item::DiagnosticItem(item)) => (
+                        format!("{cx_snip}.tcx.is_diagnostic_item(sym::{item}, {def_snip})"),
+                        has_ctor,
+                    ),
                     (0, Item::LangItem(item)) => (
                         format!("{cx_snip}.tcx.lang_items().require(LangItem::{item}).ok() == Some({def_snip})"),
-                        has_ctor
+                        has_ctor,
                     ),
                     // match_trait_method
-                    (1, Item::DiagnosticItem(item)) =>
-                        (format!("is_trait_method({cx_snip}, {def_snip}, sym::{item})"), false),
+                    (1, Item::DiagnosticItem(item)) => {
+                        (format!("is_trait_method({cx_snip}, {def_snip}, sym::{item})"), false)
+                    },
                     // match_type
-                    (2, Item::DiagnosticItem(item)) =>
-                        (format!("is_type_diagnostic_item({cx_snip}, {def_snip}, sym::{item})"), false),
-                    (2, Item::LangItem(item)) =>
-                        (format!("is_type_lang_item({cx_snip}, {def_snip}, LangItem::{item})"), false),
+                    (2, Item::DiagnosticItem(item)) => (
+                        format!("is_type_diagnostic_item({cx_snip}, {def_snip}, sym::{item})"),
+                        false,
+                    ),
+                    (2, Item::LangItem(item)) => (
+                        format!("is_type_lang_item({cx_snip}, {def_snip}, LangItem::{item})"),
+                        false,
+                    ),
                     // is_expr_path_def_path
                     (3, Item::DiagnosticItem(item)) if has_ctor => (
-                        format!(
-                            "is_res_diag_ctor({cx_snip}, path_res({cx_snip}, {def_snip}), sym::{item})",
-                        ),
+                        format!("is_res_diag_ctor({cx_snip}, path_res({cx_snip}, {def_snip}), sym::{item})",),
                         false,
                     ),
                     (3, Item::LangItem(item)) if has_ctor => (
-                        format!(
-                            "is_res_lang_ctor({cx_snip}, path_res({cx_snip}, {def_snip}), LangItem::{item})",
-                        ),
+                        format!("is_res_lang_ctor({cx_snip}, path_res({cx_snip}, {def_snip}), LangItem::{item})",),
+                        false,
+                    ),
+                    (3, Item::DiagnosticItem(item)) => (
+                        format!("is_path_diagnostic_item({cx_snip}, {def_snip}, sym::{item})"),
                         false,
                     ),
-                    (3, Item::DiagnosticItem(item)) =>
-                        (format!("is_path_diagnostic_item({cx_snip}, {def_snip}, sym::{item})"), false),
                     (3, Item::LangItem(item)) => (
                         format!(
                             "path_res({cx_snip}, {def_snip}).opt_def_id()\
@@ -185,21 +191,15 @@ impl UnnecessaryDefPath {
                     _ => return,
                 };
 
-                span_lint_and_then(
-                    cx,
-                    UNNECESSARY_DEF_PATH,
-                    span,
-                    msg,
-                    |diag| {
-                        diag.span_suggestion(span, "try", sugg, app);
-                        if with_note {
-                            diag.help(
-                                "if this `DefId` came from a constructor expression or pattern then the \
-                                    parent `DefId` should be used instead"
-                            );
-                        }
-                    },
-                );
+                span_lint_and_then(cx, UNNECESSARY_DEF_PATH, span, msg, |diag| {
+                    diag.span_suggestion(span, "try", sugg, app);
+                    if with_note {
+                        diag.help(
+                            "if this `DefId` came from a constructor expression or pattern then the \
+                                    parent `DefId` should be used instead",
+                        );
+                    }
+                });
 
                 self.linted_def_ids.insert(def_id);
             }
-- 
cgit 1.4.1-3-g733a5


From d38175f27188274bf5d6c1e433907bc50281c616 Mon Sep 17 00:00:00 2001
From: kraktus <kraktus@users.noreply.github.com>
Date: Sat, 15 Oct 2022 14:57:08 +0200
Subject: `explicit_ty_bound` code golf

---
 clippy_lints/src/default_numeric_fallback.rs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/default_numeric_fallback.rs b/clippy_lints/src/default_numeric_fallback.rs
index 199f8e10e54..03460689e19 100644
--- a/clippy_lints/src/default_numeric_fallback.rs
+++ b/clippy_lints/src/default_numeric_fallback.rs
@@ -88,10 +88,9 @@ impl<'a, 'tcx> NumericFallbackVisitor<'a, 'tcx> {
     fn check_lit(&self, lit: &Lit, lit_ty: Ty<'tcx>, emit_hir_id: HirId) {
         if_chain! {
                 if !in_external_macro(self.cx.sess(), lit.span);
-                if let Some(explicit_ty_bounds) = self.ty_bounds.last();
+                if matches!(self.ty_bounds.last(), Some(ExplicitTyBound(false)));
                 if matches!(lit.node,
                             LitKind::Int(_, LitIntType::Unsuffixed) | LitKind::Float(_, LitFloatType::Unsuffixed));
-                if !explicit_ty_bounds.0;
                 then {
                     let (suffix, is_float) = match lit_ty.kind() {
                         ty::Int(IntTy::I32) => ("i32", false),
-- 
cgit 1.4.1-3-g733a5


From 2e3342af4a00eb7677e3b7a1d110d773226fc43f Mon Sep 17 00:00:00 2001
From: kraktus <kraktus@users.noreply.github.com>
Date: Sat, 15 Oct 2022 15:10:50 +0200
Subject: [`zero_prefixed_literal`] Do not advise to use octal form if not
 possible

---
 .../src/misc_early/zero_prefixed_literal.rs        | 18 ++++++-----
 tests/ui/literals.rs                               |  7 +++++
 tests/ui/literals.stderr                           | 35 +++++++++++++++++++++-
 3 files changed, 52 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/misc_early/zero_prefixed_literal.rs b/clippy_lints/src/misc_early/zero_prefixed_literal.rs
index 4963bba82f2..9ead43ea4a4 100644
--- a/clippy_lints/src/misc_early/zero_prefixed_literal.rs
+++ b/clippy_lints/src/misc_early/zero_prefixed_literal.rs
@@ -6,6 +6,7 @@ use rustc_lint::EarlyContext;
 use super::ZERO_PREFIXED_LITERAL;
 
 pub(super) fn check(cx: &EarlyContext<'_>, lit: &Lit, lit_snip: &str) {
+    let trimmed_lit_snip = lit_snip.trim_start_matches(|c| c == '_' || c == '0');
     span_lint_and_then(
         cx,
         ZERO_PREFIXED_LITERAL,
@@ -15,15 +16,18 @@ pub(super) fn check(cx: &EarlyContext<'_>, lit: &Lit, lit_snip: &str) {
             diag.span_suggestion(
                 lit.span,
                 "if you mean to use a decimal constant, remove the `0` to avoid confusion",
-                lit_snip.trim_start_matches(|c| c == '_' || c == '0').to_string(),
-                Applicability::MaybeIncorrect,
-            );
-            diag.span_suggestion(
-                lit.span,
-                "if you mean to use an octal constant, use `0o`",
-                format!("0o{}", lit_snip.trim_start_matches(|c| c == '_' || c == '0')),
+                trimmed_lit_snip.to_string(),
                 Applicability::MaybeIncorrect,
             );
+            // do not advise to use octal form if the literal cannot be expressed in base 8.
+            if !lit_snip.contains(|c| c == '8' || c == '9') {
+                diag.span_suggestion(
+                    lit.span,
+                    "if you mean to use an octal constant, use `0o`",
+                    format!("0o{trimmed_lit_snip}"),
+                    Applicability::MaybeIncorrect,
+                );
+            }
         },
     );
 }
diff --git a/tests/ui/literals.rs b/tests/ui/literals.rs
index 0cadd5a3da1..1a646e49ce3 100644
--- a/tests/ui/literals.rs
+++ b/tests/ui/literals.rs
@@ -40,3 +40,10 @@ fn main() {
     let ok26 = 0x6_A0_BF;
     let ok27 = 0b1_0010_0101;
 }
+
+fn issue9651() {
+    // lint but octal form is not possible here
+    let _ = 08;
+    let _ = 09;
+    let _ = 089;
+}
diff --git a/tests/ui/literals.stderr b/tests/ui/literals.stderr
index 365b2407473..603d47bacca 100644
--- a/tests/ui/literals.stderr
+++ b/tests/ui/literals.stderr
@@ -135,5 +135,38 @@ error: digits of hex or binary literal not grouped by four
 LL |     let fail25 = 0b01_100_101;
    |                  ^^^^^^^^^^^^ help: consider: `0b0110_0101`
 
-error: aborting due to 18 previous errors
+error: this is a decimal constant
+  --> $DIR/literals.rs:46:13
+   |
+LL |     let _ = 08;
+   |             ^^
+   |
+help: if you mean to use a decimal constant, remove the `0` to avoid confusion
+   |
+LL |     let _ = 8;
+   |             ~
+
+error: this is a decimal constant
+  --> $DIR/literals.rs:47:13
+   |
+LL |     let _ = 09;
+   |             ^^
+   |
+help: if you mean to use a decimal constant, remove the `0` to avoid confusion
+   |
+LL |     let _ = 9;
+   |             ~
+
+error: this is a decimal constant
+  --> $DIR/literals.rs:48:13
+   |
+LL |     let _ = 089;
+   |             ^^^
+   |
+help: if you mean to use a decimal constant, remove the `0` to avoid confusion
+   |
+LL |     let _ = 89;
+   |             ~~
+
+error: aborting due to 21 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From f8ae2f580774c0d7743c5c6adf8e246735a28c92 Mon Sep 17 00:00:00 2001
From: Andre Bogus <bogusandre@gmail.com>
Date: Sat, 15 Oct 2022 23:19:43 +0200
Subject: fix `box-default` linting `no_std` non-boxes

---
 clippy_lints/src/box_default.rs |  2 +-
 tests/ui/box_default_no_std.rs  | 33 +++++++++++++++++++++++++++++++++
 2 files changed, 34 insertions(+), 1 deletion(-)
 create mode 100644 tests/ui/box_default_no_std.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/box_default.rs b/clippy_lints/src/box_default.rs
index f35a79dcc73..bb0307e8856 100644
--- a/clippy_lints/src/box_default.rs
+++ b/clippy_lints/src/box_default.rs
@@ -46,7 +46,7 @@ impl LateLintPass<'_> for BoxDefault {
             && !in_external_macro(cx.sess(), expr.span)
             && (expr.span.eq_ctxt(arg.span) || is_vec_expn(cx, arg))
             && seg.ident.name == sym::new
-            && path_def_id(cx, ty) == cx.tcx.lang_items().owned_box()
+            && path_def_id(cx, ty).map_or(false, |id| Some(id) == cx.tcx.lang_items().owned_box())
             && is_default_equivalent(cx, arg)
         {
             let arg_ty = cx.typeck_results().expr_ty(arg);
diff --git a/tests/ui/box_default_no_std.rs b/tests/ui/box_default_no_std.rs
new file mode 100644
index 00000000000..4326abc9a54
--- /dev/null
+++ b/tests/ui/box_default_no_std.rs
@@ -0,0 +1,33 @@
+#![feature(lang_items, start, libc)]
+#![warn(clippy::box_default)]
+#![no_std]
+
+pub struct NotBox<T> {
+    _value: T,
+}
+
+impl<T> NotBox<T> {
+    pub fn new(value: T) -> Self {
+        Self { _value: value }
+    }
+}
+
+impl<T: Default> Default for NotBox<T> {
+    fn default() -> Self {
+        Self::new(T::default())
+    }
+}
+
+#[start]
+fn main(_argc: isize, _argv: *const *const u8) -> isize {
+    let _p = NotBox::new(isize::default());
+    0
+}
+
+#[panic_handler]
+fn panic(_info: &core::panic::PanicInfo) -> ! {
+    loop {}
+}
+
+#[lang = "eh_personality"]
+extern "C" fn eh_personality() {}
-- 
cgit 1.4.1-3-g733a5


From 7ac97b69fc81fcd5cbd2a7c862187f6a6c6ea354 Mon Sep 17 00:00:00 2001
From: TennyZhuang <zty0826@gmail.com>
Date: Sun, 16 Oct 2022 16:02:23 +0800
Subject: Add new lint `partial_pub_fields`

Signed-off-by: TennyZhuang <zty0826@gmail.com>
---
 CHANGELOG.md                                 |  1 +
 clippy_lints/src/lib.register_lints.rs       |  1 +
 clippy_lints/src/lib.register_restriction.rs |  1 +
 clippy_lints/src/lib.rs                      |  2 +
 clippy_lints/src/partial_pub_fields.rs       | 81 ++++++++++++++++++++++++++++
 src/docs.rs                                  |  1 +
 src/docs/partial_pub_fields.txt              | 27 ++++++++++
 tests/ui/partial_pub_fields.rs               | 20 +++++++
 tests/ui/partial_pub_fields.stderr           | 19 +++++++
 9 files changed, 153 insertions(+)
 create mode 100644 clippy_lints/src/partial_pub_fields.rs
 create mode 100644 src/docs/partial_pub_fields.txt
 create mode 100644 tests/ui/partial_pub_fields.rs
 create mode 100644 tests/ui/partial_pub_fields.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index f593966c045..1e0ff5db0ee 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4134,6 +4134,7 @@ Released 2018-09-13
 [`panic_in_result_fn`]: https://rust-lang.github.io/rust-clippy/master/index.html#panic_in_result_fn
 [`panic_params`]: https://rust-lang.github.io/rust-clippy/master/index.html#panic_params
 [`panicking_unwrap`]: https://rust-lang.github.io/rust-clippy/master/index.html#panicking_unwrap
+[`partial_pub_fields`]: https://rust-lang.github.io/rust-clippy/master/index.html#partial_pub_fields
 [`partialeq_ne_impl`]: https://rust-lang.github.io/rust-clippy/master/index.html#partialeq_ne_impl
 [`partialeq_to_none`]: https://rust-lang.github.io/rust-clippy/master/index.html#partialeq_to_none
 [`path_buf_push_overwrite`]: https://rust-lang.github.io/rust-clippy/master/index.html#path_buf_push_overwrite
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index de1253c8510..799c62743aa 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -479,6 +479,7 @@ store.register_lints(&[
     panic_unimplemented::TODO,
     panic_unimplemented::UNIMPLEMENTED,
     panic_unimplemented::UNREACHABLE,
+    partial_pub_fields::PARTIAL_PUB_FIELDS,
     partialeq_ne_impl::PARTIALEQ_NE_IMPL,
     partialeq_to_none::PARTIALEQ_TO_NONE,
     pass_by_ref_or_value::LARGE_TYPES_PASSED_BY_VALUE,
diff --git a/clippy_lints/src/lib.register_restriction.rs b/clippy_lints/src/lib.register_restriction.rs
index 6eb9b3d3b9b..9edced28408 100644
--- a/clippy_lints/src/lib.register_restriction.rs
+++ b/clippy_lints/src/lib.register_restriction.rs
@@ -61,6 +61,7 @@ store.register_group(true, "clippy::restriction", Some("clippy_restriction"), ve
     LintId::of(panic_unimplemented::TODO),
     LintId::of(panic_unimplemented::UNIMPLEMENTED),
     LintId::of(panic_unimplemented::UNREACHABLE),
+    LintId::of(partial_pub_fields::PARTIAL_PUB_FIELDS),
     LintId::of(pattern_type_mismatch::PATTERN_TYPE_MISMATCH),
     LintId::of(pub_use::PUB_USE),
     LintId::of(redundant_slicing::DEREF_BY_SLICING),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index ebb0f14fef5..bf5688829e2 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -324,6 +324,7 @@ mod option_if_let_else;
 mod overflow_check_conditional;
 mod panic_in_result_fn;
 mod panic_unimplemented;
+mod partial_pub_fields;
 mod partialeq_ne_impl;
 mod partialeq_to_none;
 mod pass_by_ref_or_value;
@@ -908,6 +909,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(bool_to_int_with_if::BoolToIntWithIf));
     store.register_late_pass(|_| Box::new(box_default::BoxDefault));
     store.register_late_pass(|_| Box::new(implicit_saturating_add::ImplicitSaturatingAdd));
+    store.register_early_pass(|| Box::new(partial_pub_fields::PartialPubFields));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/partial_pub_fields.rs b/clippy_lints/src/partial_pub_fields.rs
new file mode 100644
index 00000000000..085ee08afca
--- /dev/null
+++ b/clippy_lints/src/partial_pub_fields.rs
@@ -0,0 +1,81 @@
+use clippy_utils::diagnostics::span_lint_and_help;
+use rustc_ast::ast::*;
+use rustc_lint::{EarlyContext, EarlyLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks whether partial fields of a struct are public.
+    ///
+    /// Either make all fields of a type public, or make none of them public
+    ///
+    /// ### Why is this bad?
+    /// Most types should either be:
+    /// * Abstract data types: complex objects with opaque implementation which guard
+    /// interior invariants and expose intentionally limited API to the outside world.
+    /// * Data: relatively simple objects which group a bunch of related attributes together.
+    ///
+    /// ### Example
+    /// ```rust
+    /// pub struct Color {
+    ///     pub r,
+    ///     pub g,
+    ///     b,
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// pub struct Color {
+    ///     pub r,
+    ///     pub g,
+    ///     pub b,
+    /// }
+    /// ```
+    #[clippy::version = "1.66.0"]
+    pub PARTIAL_PUB_FIELDS,
+    restriction,
+    "partial fields of a struct are public"
+}
+declare_lint_pass!(PartialPubFields => [PARTIAL_PUB_FIELDS]);
+
+impl EarlyLintPass for PartialPubFields {
+    fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {
+        let ItemKind::Struct(ref st, _) = item.kind else {
+            return;
+        };
+
+        let mut fields = st.fields().iter();
+        let Some(first_field) = fields.next() else {
+            // Empty struct.
+            return;
+        };
+        let all_pub = first_field.vis.kind.is_pub();
+        let all_priv = !all_pub;
+
+        let msg = "mixed usage of pub and non-pub fields";
+
+        for field in fields {
+            if all_priv && field.vis.kind.is_pub() {
+                span_lint_and_help(
+                    cx,
+                    &PARTIAL_PUB_FIELDS,
+                    field.vis.span,
+                    msg,
+                    None,
+                    "consider using private field here",
+                );
+                return;
+            } else if all_pub && !field.vis.kind.is_pub() {
+                span_lint_and_help(
+                    cx,
+                    &PARTIAL_PUB_FIELDS,
+                    field.vis.span,
+                    msg,
+                    None,
+                    "consider using public field here",
+                );
+                return;
+            }
+        }
+    }
+}
diff --git a/src/docs.rs b/src/docs.rs
index 41c31f91bca..b8b4286b488 100644
--- a/src/docs.rs
+++ b/src/docs.rs
@@ -395,6 +395,7 @@ docs! {
     "panic",
     "panic_in_result_fn",
     "panicking_unwrap",
+    "partial_pub_fields",
     "partialeq_ne_impl",
     "partialeq_to_none",
     "path_buf_push_overwrite",
diff --git a/src/docs/partial_pub_fields.txt b/src/docs/partial_pub_fields.txt
new file mode 100644
index 00000000000..a332ec8c28a
--- /dev/null
+++ b/src/docs/partial_pub_fields.txt
@@ -0,0 +1,27 @@
+### What it does
+Checks whether partial fields of a struct are public.
+
+Either make all fields of a type public, or make none of them public
+
+### Why is this bad?
+Most types should either be:
+* Abstract data types: complex objects with opaque implementation which guard
+interior invariants and expose intentionally limited API to the outside world.
+* Data: relatively simple objects which group a bunch of related attributes together.
+
+### Example
+```
+pub struct Color {
+    pub r,
+    pub g,
+    b,
+}
+```
+Use instead:
+```
+pub struct Color {
+    pub r,
+    pub g,
+    pub b,
+}
+```
\ No newline at end of file
diff --git a/tests/ui/partial_pub_fields.rs b/tests/ui/partial_pub_fields.rs
new file mode 100644
index 00000000000..e1a4b482799
--- /dev/null
+++ b/tests/ui/partial_pub_fields.rs
@@ -0,0 +1,20 @@
+#![allow(unused)]
+#![warn(clippy::partial_pub_fields)]
+
+fn main() {
+    // test code goes here
+
+    use std::collections::HashMap;
+
+    #[derive(Default)]
+    pub struct FileSet {
+        files: HashMap<String, u32>,
+        pub paths: HashMap<u32, String>,
+    }
+
+    pub struct Color {
+        pub r: u8,
+        pub g: u8,
+        b: u8,
+    }
+}
diff --git a/tests/ui/partial_pub_fields.stderr b/tests/ui/partial_pub_fields.stderr
new file mode 100644
index 00000000000..f7f23c85a67
--- /dev/null
+++ b/tests/ui/partial_pub_fields.stderr
@@ -0,0 +1,19 @@
+error: mixed usage of pub and non-pub fields
+  --> $DIR/partial_pub_fields.rs:12:9
+   |
+LL |         pub paths: HashMap<u32, String>,
+   |         ^^^
+   |
+   = help: consider using private field here
+   = note: `-D clippy::partial-pub-fields` implied by `-D warnings`
+
+error: mixed usage of pub and non-pub fields
+  --> $DIR/partial_pub_fields.rs:18:9
+   |
+LL |         b: u8,
+   |         ^
+   |
+   = help: consider using public field here
+
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From b10882ab9153733249f95d63150724aa5f50ce59 Mon Sep 17 00:00:00 2001
From: TennyZhuang <zty0826@gmail.com>
Date: Sun, 16 Oct 2022 16:21:48 +0800
Subject: fix dogfood

Signed-off-by: TennyZhuang <zty0826@gmail.com>
---
 clippy_lints/src/partial_pub_fields.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/partial_pub_fields.rs b/clippy_lints/src/partial_pub_fields.rs
index 085ee08afca..42f892e3652 100644
--- a/clippy_lints/src/partial_pub_fields.rs
+++ b/clippy_lints/src/partial_pub_fields.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_help;
-use rustc_ast::ast::*;
+use rustc_ast::ast::{Item, ItemKind};
 use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
@@ -58,7 +58,7 @@ impl EarlyLintPass for PartialPubFields {
             if all_priv && field.vis.kind.is_pub() {
                 span_lint_and_help(
                     cx,
-                    &PARTIAL_PUB_FIELDS,
+                    PARTIAL_PUB_FIELDS,
                     field.vis.span,
                     msg,
                     None,
@@ -68,7 +68,7 @@ impl EarlyLintPass for PartialPubFields {
             } else if all_pub && !field.vis.kind.is_pub() {
                 span_lint_and_help(
                     cx,
-                    &PARTIAL_PUB_FIELDS,
+                    PARTIAL_PUB_FIELDS,
                     field.vis.span,
                     msg,
                     None,
-- 
cgit 1.4.1-3-g733a5


From 360b48b1ab97471c0d122732a027b65f46980447 Mon Sep 17 00:00:00 2001
From: TennyZhuang <zty0826@gmail.com>
Date: Sun, 16 Oct 2022 17:10:27 +0800
Subject: fix a doctest

Signed-off-by: TennyZhuang <zty0826@gmail.com>
---
 clippy_lints/src/partial_pub_fields.rs | 12 ++++++------
 src/docs/partial_pub_fields.txt        | 12 ++++++------
 2 files changed, 12 insertions(+), 12 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/partial_pub_fields.rs b/clippy_lints/src/partial_pub_fields.rs
index 42f892e3652..f60d9d65b12 100644
--- a/clippy_lints/src/partial_pub_fields.rs
+++ b/clippy_lints/src/partial_pub_fields.rs
@@ -18,17 +18,17 @@ declare_clippy_lint! {
     /// ### Example
     /// ```rust
     /// pub struct Color {
-    ///     pub r,
-    ///     pub g,
-    ///     b,
+    ///     pub r: u8,
+    ///     pub g: u8,
+    ///     b: u8,
     /// }
     /// ```
     /// Use instead:
     /// ```rust
     /// pub struct Color {
-    ///     pub r,
-    ///     pub g,
-    ///     pub b,
+    ///     pub r: u8,
+    ///     pub g: u8,
+    ///     pub b: u8,
     /// }
     /// ```
     #[clippy::version = "1.66.0"]
diff --git a/src/docs/partial_pub_fields.txt b/src/docs/partial_pub_fields.txt
index a332ec8c28a..b529adf1547 100644
--- a/src/docs/partial_pub_fields.txt
+++ b/src/docs/partial_pub_fields.txt
@@ -12,16 +12,16 @@ interior invariants and expose intentionally limited API to the outside world.
 ### Example
 ```
 pub struct Color {
-    pub r,
-    pub g,
-    b,
+    pub r: u8,
+    pub g: u8,
+    b: u8,
 }
 ```
 Use instead:
 ```
 pub struct Color {
-    pub r,
-    pub g,
-    pub b,
+    pub r: u8,
+    pub g: u8,
+    pub b: u8,
 }
 ```
\ No newline at end of file
-- 
cgit 1.4.1-3-g733a5


From 136c2cdb910938103a762cdde177b1633bdbf99a Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Thu, 13 Oct 2022 12:13:54 +0000
Subject: Add `unused_format_specs` lint

---
 CHANGELOG.md                                  |   1 +
 clippy_lints/src/format_args.rs               | 151 ++++++++++++++++++++++----
 clippy_lints/src/lib.register_all.rs          |   1 +
 clippy_lints/src/lib.register_complexity.rs   |   1 +
 clippy_lints/src/lib.register_lints.rs        |   1 +
 clippy_utils/src/macros.rs                    |  43 +++++++-
 src/docs.rs                                   |   1 +
 src/docs/unused_format_specs.txt              |  24 ++++
 tests/ui/unused_format_specs.fixed            |  18 +++
 tests/ui/unused_format_specs.rs               |  18 +++
 tests/ui/unused_format_specs.stderr           |  54 +++++++++
 tests/ui/unused_format_specs_unfixable.rs     |  30 +++++
 tests/ui/unused_format_specs_unfixable.stderr |  69 ++++++++++++
 13 files changed, 384 insertions(+), 28 deletions(-)
 create mode 100644 src/docs/unused_format_specs.txt
 create mode 100644 tests/ui/unused_format_specs.fixed
 create mode 100644 tests/ui/unused_format_specs.rs
 create mode 100644 tests/ui/unused_format_specs.stderr
 create mode 100644 tests/ui/unused_format_specs_unfixable.rs
 create mode 100644 tests/ui/unused_format_specs_unfixable.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index f593966c045..5b2f96ed1ff 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4315,6 +4315,7 @@ Released 2018-09-13
 [`unstable_as_slice`]: https://rust-lang.github.io/rust-clippy/master/index.html#unstable_as_slice
 [`unused_async`]: https://rust-lang.github.io/rust-clippy/master/index.html#unused_async
 [`unused_collect`]: https://rust-lang.github.io/rust-clippy/master/index.html#unused_collect
+[`unused_format_specs`]: https://rust-lang.github.io/rust-clippy/master/index.html#unused_format_specs
 [`unused_io_amount`]: https://rust-lang.github.io/rust-clippy/master/index.html#unused_io_amount
 [`unused_label`]: https://rust-lang.github.io/rust-clippy/master/index.html#unused_label
 [`unused_peekable`]: https://rust-lang.github.io/rust-clippy/master/index.html#unused_peekable
diff --git a/clippy_lints/src/format_args.rs b/clippy_lints/src/format_args.rs
index 4f06fc8fa5a..4c4a1e06cd4 100644
--- a/clippy_lints/src/format_args.rs
+++ b/clippy_lints/src/format_args.rs
@@ -1,8 +1,10 @@
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::macros::FormatParamKind::{Implicit, Named, Numbered, Starred};
-use clippy_utils::macros::{is_format_macro, is_panic, FormatArgsExpn, FormatParam, FormatParamUsage};
+use clippy_utils::macros::{
+    is_format_macro, is_panic, root_macro_call, Count, FormatArg, FormatArgsExpn, FormatParam, FormatParamUsage,
+};
 use clippy_utils::source::snippet_opt;
-use clippy_utils::ty::implements_trait;
+use clippy_utils::ty::{implements_trait, is_type_diagnostic_item};
 use clippy_utils::{is_diag_trait_item, meets_msrv, msrvs};
 use if_chain::if_chain;
 use itertools::Itertools;
@@ -117,7 +119,43 @@ declare_clippy_lint! {
     "using non-inlined variables in `format!` calls"
 }
 
-impl_lint_pass!(FormatArgs => [FORMAT_IN_FORMAT_ARGS, UNINLINED_FORMAT_ARGS, TO_STRING_IN_FORMAT_ARGS]);
+declare_clippy_lint! {
+    /// ### What it does
+    /// Detects [formatting parameters] that have no effect on the output of
+    /// `format!()`, `println!()` or similar macros.
+    ///
+    /// ### Why is this bad?
+    /// Shorter format specifiers are easier to read, it may also indicate that
+    /// an expected formatting operation such as adding padding isn't happening.
+    ///
+    /// ### Example
+    /// ```rust
+    /// println!("{:.}", 1.0);
+    ///
+    /// println!("not padded: {:5}", format_args!("..."));
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// println!("{}", 1.0);
+    ///
+    /// println!("not padded: {}", format_args!("..."));
+    /// // OR
+    /// println!("padded: {:5}", format!("..."));
+    /// ```
+    ///
+    /// [formatting parameters]: https://doc.rust-lang.org/std/fmt/index.html#formatting-parameters
+    #[clippy::version = "1.66.0"]
+    pub UNUSED_FORMAT_SPECS,
+    complexity,
+    "use of a format specifier that has no effect"
+}
+
+impl_lint_pass!(FormatArgs => [
+    FORMAT_IN_FORMAT_ARGS,
+    TO_STRING_IN_FORMAT_ARGS,
+    UNINLINED_FORMAT_ARGS,
+    UNUSED_FORMAT_SPECS,
+]);
 
 pub struct FormatArgs {
     msrv: Option<RustcVersion>,
@@ -132,27 +170,26 @@ impl FormatArgs {
 
 impl<'tcx> LateLintPass<'tcx> for FormatArgs {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
-        if_chain! {
-            if let Some(format_args) = FormatArgsExpn::parse(cx, expr);
-            let expr_expn_data = expr.span.ctxt().outer_expn_data();
-            let outermost_expn_data = outermost_expn_data(expr_expn_data);
-            if let Some(macro_def_id) = outermost_expn_data.macro_def_id;
-            if is_format_macro(cx, macro_def_id);
-            if let ExpnKind::Macro(_, name) = outermost_expn_data.kind;
-            then {
-                for arg in &format_args.args {
-                    if !arg.format.is_default() {
-                        continue;
-                    }
-                    if is_aliased(&format_args, arg.param.value.hir_id) {
-                        continue;
-                    }
-                    check_format_in_format_args(cx, outermost_expn_data.call_site, name, arg.param.value);
-                    check_to_string_in_format_args(cx, name, arg.param.value);
+        if let Some(format_args) = FormatArgsExpn::parse(cx, expr)
+            && let expr_expn_data = expr.span.ctxt().outer_expn_data()
+            && let outermost_expn_data = outermost_expn_data(expr_expn_data)
+            && let Some(macro_def_id) = outermost_expn_data.macro_def_id
+            && is_format_macro(cx, macro_def_id)
+            && let ExpnKind::Macro(_, name) = outermost_expn_data.kind
+        {
+            for arg in &format_args.args {
+                check_unused_format_specifier(cx, arg);
+                if !arg.format.is_default() {
+                    continue;
                 }
-                if meets_msrv(self.msrv, msrvs::FORMAT_ARGS_CAPTURE) {
-                    check_uninlined_args(cx, &format_args, outermost_expn_data.call_site, macro_def_id);
+                if is_aliased(&format_args, arg.param.value.hir_id) {
+                    continue;
                 }
+                check_format_in_format_args(cx, outermost_expn_data.call_site, name, arg.param.value);
+                check_to_string_in_format_args(cx, name, arg.param.value);
+            }
+            if meets_msrv(self.msrv, msrvs::FORMAT_ARGS_CAPTURE) {
+                check_uninlined_args(cx, &format_args, outermost_expn_data.call_site, macro_def_id);
             }
         }
     }
@@ -160,6 +197,76 @@ impl<'tcx> LateLintPass<'tcx> for FormatArgs {
     extract_msrv_attr!(LateContext);
 }
 
+fn check_unused_format_specifier(cx: &LateContext<'_>, arg: &FormatArg<'_>) {
+    let param_ty = cx.typeck_results().expr_ty(arg.param.value).peel_refs();
+
+    if let Count::Implied(Some(mut span)) = arg.format.precision
+        && !span.is_empty()
+    {
+        span_lint_and_then(
+            cx,
+            UNUSED_FORMAT_SPECS,
+            span,
+            "empty precision specifier has no effect",
+            |diag| {
+                if param_ty.is_floating_point() {
+                    diag.note("a precision specifier is not required to format floats");
+                }
+
+                if arg.format.is_default() {
+                    // If there's no other specifiers remove the `:` too
+                    span = arg.format_span();
+                }
+
+                diag.span_suggestion_verbose(span, "remove the `.`", "", Applicability::MachineApplicable);
+            },
+        );
+    }
+
+    if is_type_diagnostic_item(cx, param_ty, sym::Arguments) && !arg.format.is_default_for_trait() {
+        span_lint_and_then(
+            cx,
+            UNUSED_FORMAT_SPECS,
+            arg.span,
+            "format specifiers have no effect on `format_args!()`",
+            |diag| {
+                let mut suggest_format = |spec, span| {
+                    let message = format!("for the {spec} to apply consider using `format!()`");
+
+                    if let Some(mac_call) = root_macro_call(arg.param.value.span)
+                        && cx.tcx.is_diagnostic_item(sym::format_args_macro, mac_call.def_id)
+                        && arg.span.eq_ctxt(mac_call.span)
+                    {
+                        diag.span_suggestion(
+                            cx.sess().source_map().span_until_char(mac_call.span, '!'),
+                            message,
+                            "format",
+                            Applicability::MaybeIncorrect,
+                        );
+                    } else if let Some(span) = span {
+                        diag.span_help(span, message);
+                    }
+                };
+
+                if !arg.format.width.is_implied() {
+                    suggest_format("width", arg.format.width.span());
+                }
+
+                if !arg.format.precision.is_implied() {
+                    suggest_format("precision", arg.format.precision.span());
+                }
+
+                diag.span_suggestion_verbose(
+                    arg.format_span(),
+                    "if the current behavior is intentional, remove the format specifiers",
+                    "",
+                    Applicability::MaybeIncorrect,
+                );
+            },
+        );
+    }
+}
+
 fn check_uninlined_args(cx: &LateContext<'_>, args: &FormatArgsExpn<'_>, call_site: Span, def_id: DefId) {
     if args.format_string.span.from_expansion() {
         return;
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index 04f0da4b2fe..987131ab727 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -73,6 +73,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(format_args::FORMAT_IN_FORMAT_ARGS),
     LintId::of(format_args::TO_STRING_IN_FORMAT_ARGS),
     LintId::of(format_args::UNINLINED_FORMAT_ARGS),
+    LintId::of(format_args::UNUSED_FORMAT_SPECS),
     LintId::of(format_impl::PRINT_IN_FORMAT_IMPL),
     LintId::of(format_impl::RECURSIVE_FORMAT_IMPL),
     LintId::of(formatting::POSSIBLE_MISSING_COMMA),
diff --git a/clippy_lints/src/lib.register_complexity.rs b/clippy_lints/src/lib.register_complexity.rs
index e3849e5a626..8be9dc4baf1 100644
--- a/clippy_lints/src/lib.register_complexity.rs
+++ b/clippy_lints/src/lib.register_complexity.rs
@@ -13,6 +13,7 @@ store.register_group(true, "clippy::complexity", Some("clippy_complexity"), vec!
     LintId::of(double_parens::DOUBLE_PARENS),
     LintId::of(explicit_write::EXPLICIT_WRITE),
     LintId::of(format::USELESS_FORMAT),
+    LintId::of(format_args::UNUSED_FORMAT_SPECS),
     LintId::of(functions::TOO_MANY_ARGUMENTS),
     LintId::of(int_plus_one::INT_PLUS_ONE),
     LintId::of(lifetimes::EXTRA_UNUSED_LIFETIMES),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index de1253c8510..049ebdc926e 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -164,6 +164,7 @@ store.register_lints(&[
     format_args::FORMAT_IN_FORMAT_ARGS,
     format_args::TO_STRING_IN_FORMAT_ARGS,
     format_args::UNINLINED_FORMAT_ARGS,
+    format_args::UNUSED_FORMAT_SPECS,
     format_impl::PRINT_IN_FORMAT_IMPL,
     format_impl::RECURSIVE_FORMAT_IMPL,
     format_push_string::FORMAT_PUSH_STRING,
diff --git a/clippy_utils/src/macros.rs b/clippy_utils/src/macros.rs
index 5a63c290a31..9a682fbe604 100644
--- a/clippy_utils/src/macros.rs
+++ b/clippy_utils/src/macros.rs
@@ -627,7 +627,7 @@ pub enum Count<'tcx> {
     /// `FormatParamKind::Numbered`.
     Param(FormatParam<'tcx>),
     /// Not specified.
-    Implied,
+    Implied(Option<Span>),
 }
 
 impl<'tcx> Count<'tcx> {
@@ -638,8 +638,10 @@ impl<'tcx> Count<'tcx> {
         inner: Option<rpf::InnerSpan>,
         values: &FormatArgsValues<'tcx>,
     ) -> Option<Self> {
+        let span = inner.map(|inner| span_from_inner(values.format_string_span, inner));
+
         Some(match count {
-            rpf::Count::CountIs(val) => Self::Is(val, span_from_inner(values.format_string_span, inner?)),
+            rpf::Count::CountIs(val) => Self::Is(val, span?),
             rpf::Count::CountIsName(name, _) => Self::Param(FormatParam::new(
                 FormatParamKind::Named(Symbol::intern(name)),
                 usage,
@@ -661,12 +663,12 @@ impl<'tcx> Count<'tcx> {
                 inner?,
                 values,
             )?),
-            rpf::Count::CountImplied => Self::Implied,
+            rpf::Count::CountImplied => Self::Implied(span),
         })
     }
 
     pub fn is_implied(self) -> bool {
-        matches!(self, Count::Implied)
+        matches!(self, Count::Implied(_))
     }
 
     pub fn param(self) -> Option<FormatParam<'tcx>> {
@@ -675,6 +677,14 @@ impl<'tcx> Count<'tcx> {
             _ => None,
         }
     }
+
+    pub fn span(self) -> Option<Span> {
+        match self {
+            Count::Is(_, span) => Some(span),
+            Count::Param(param) => Some(param.span),
+            Count::Implied(span) => span,
+        }
+    }
 }
 
 /// Specification for the formatting of an argument in the format string. See
@@ -738,8 +748,13 @@ impl<'tcx> FormatSpec<'tcx> {
     /// Returns true if this format spec is unchanged from the default. e.g. returns true for `{}`,
     /// `{foo}` and `{2}`, but false for `{:?}`, `{foo:5}` and `{3:.5}`
     pub fn is_default(&self) -> bool {
-        self.r#trait == sym::Display
-            && self.width.is_implied()
+        self.r#trait == sym::Display && self.is_default_for_trait()
+    }
+
+    /// Has no other formatting specifiers than setting the format trait. returns true for `{}`,
+    /// `{foo}`, `{:?}`, but false for `{foo:5}`, `{3:.5?}`
+    pub fn is_default_for_trait(&self) -> bool {
+        self.width.is_implied()
             && self.precision.is_implied()
             && self.align == Alignment::AlignUnknown
             && self.flags == 0
@@ -757,6 +772,22 @@ pub struct FormatArg<'tcx> {
     pub span: Span,
 }
 
+impl<'tcx> FormatArg<'tcx> {
+    /// Span of the `:` and format specifiers
+    ///
+    /// ```ignore
+    /// format!("{:.}"), format!("{foo:.}")
+    ///           ^^                  ^^
+    /// ```
+    pub fn format_span(&self) -> Span {
+        let base = self.span.data();
+
+        // `base.hi` is `{...}|`, subtract 1 byte (the length of '}') so that it points before the closing
+        // brace `{...|}`
+        Span::new(self.param.span.hi(), base.hi - BytePos(1), base.ctxt, base.parent)
+    }
+}
+
 /// A parsed `format_args!` expansion.
 #[derive(Debug)]
 pub struct FormatArgsExpn<'tcx> {
diff --git a/src/docs.rs b/src/docs.rs
index 41c31f91bca..33ea8488375 100644
--- a/src/docs.rs
+++ b/src/docs.rs
@@ -557,6 +557,7 @@ docs! {
     "unseparated_literal_suffix",
     "unsound_collection_transmute",
     "unused_async",
+    "unused_format_specs",
     "unused_io_amount",
     "unused_peekable",
     "unused_rounding",
diff --git a/src/docs/unused_format_specs.txt b/src/docs/unused_format_specs.txt
new file mode 100644
index 00000000000..77be3a2fb17
--- /dev/null
+++ b/src/docs/unused_format_specs.txt
@@ -0,0 +1,24 @@
+### What it does
+Detects [formatting parameters] that have no effect on the output of
+`format!()`, `println!()` or similar macros.
+
+### Why is this bad?
+Shorter format specifiers are easier to read, it may also indicate that
+an expected formatting operation such as adding padding isn't happening.
+
+### Example
+```
+println!("{:.}", 1.0);
+
+println!("not padded: {:5}", format_args!("..."));
+```
+Use instead:
+```
+println!("{}", 1.0);
+
+println!("not padded: {}", format_args!("..."));
+// OR
+println!("padded: {:5}", format!("..."));
+```
+
+[formatting parameters]: https://doc.rust-lang.org/std/fmt/index.html#formatting-parameters
\ No newline at end of file
diff --git a/tests/ui/unused_format_specs.fixed b/tests/ui/unused_format_specs.fixed
new file mode 100644
index 00000000000..2930722b42d
--- /dev/null
+++ b/tests/ui/unused_format_specs.fixed
@@ -0,0 +1,18 @@
+// run-rustfix
+
+#![warn(clippy::unused_format_specs)]
+#![allow(unused)]
+
+fn main() {
+    let f = 1.0f64;
+    println!("{}", 1.0);
+    println!("{f} {f:?}");
+
+    println!("{}", 1);
+}
+
+fn should_not_lint() {
+    let f = 1.0f64;
+    println!("{:.1}", 1.0);
+    println!("{f:.w$} {f:.*?}", 3, w = 2);
+}
diff --git a/tests/ui/unused_format_specs.rs b/tests/ui/unused_format_specs.rs
new file mode 100644
index 00000000000..ee192a000d4
--- /dev/null
+++ b/tests/ui/unused_format_specs.rs
@@ -0,0 +1,18 @@
+// run-rustfix
+
+#![warn(clippy::unused_format_specs)]
+#![allow(unused)]
+
+fn main() {
+    let f = 1.0f64;
+    println!("{:.}", 1.0);
+    println!("{f:.} {f:.?}");
+
+    println!("{:.}", 1);
+}
+
+fn should_not_lint() {
+    let f = 1.0f64;
+    println!("{:.1}", 1.0);
+    println!("{f:.w$} {f:.*?}", 3, w = 2);
+}
diff --git a/tests/ui/unused_format_specs.stderr b/tests/ui/unused_format_specs.stderr
new file mode 100644
index 00000000000..7231c17e74c
--- /dev/null
+++ b/tests/ui/unused_format_specs.stderr
@@ -0,0 +1,54 @@
+error: empty precision specifier has no effect
+  --> $DIR/unused_format_specs.rs:8:17
+   |
+LL |     println!("{:.}", 1.0);
+   |                 ^
+   |
+   = note: a precision specifier is not required to format floats
+   = note: `-D clippy::unused-format-specs` implied by `-D warnings`
+help: remove the `.`
+   |
+LL -     println!("{:.}", 1.0);
+LL +     println!("{}", 1.0);
+   |
+
+error: empty precision specifier has no effect
+  --> $DIR/unused_format_specs.rs:9:18
+   |
+LL |     println!("{f:.} {f:.?}");
+   |                  ^
+   |
+   = note: a precision specifier is not required to format floats
+help: remove the `.`
+   |
+LL -     println!("{f:.} {f:.?}");
+LL +     println!("{f} {f:.?}");
+   |
+
+error: empty precision specifier has no effect
+  --> $DIR/unused_format_specs.rs:9:24
+   |
+LL |     println!("{f:.} {f:.?}");
+   |                        ^
+   |
+   = note: a precision specifier is not required to format floats
+help: remove the `.`
+   |
+LL -     println!("{f:.} {f:.?}");
+LL +     println!("{f:.} {f:?}");
+   |
+
+error: empty precision specifier has no effect
+  --> $DIR/unused_format_specs.rs:11:17
+   |
+LL |     println!("{:.}", 1);
+   |                 ^
+   |
+help: remove the `.`
+   |
+LL -     println!("{:.}", 1);
+LL +     println!("{}", 1);
+   |
+
+error: aborting due to 4 previous errors
+
diff --git a/tests/ui/unused_format_specs_unfixable.rs b/tests/ui/unused_format_specs_unfixable.rs
new file mode 100644
index 00000000000..78601a3483d
--- /dev/null
+++ b/tests/ui/unused_format_specs_unfixable.rs
@@ -0,0 +1,30 @@
+#![warn(clippy::unused_format_specs)]
+#![allow(unused)]
+
+macro_rules! format_args_from_macro {
+    () => {
+        format_args!("from macro")
+    };
+}
+
+fn main() {
+    // prints `.`, not `     .`
+    println!("{:5}.", format_args!(""));
+    //prints `abcde`, not `abc`
+    println!("{:.3}", format_args!("abcde"));
+
+    println!("{:5}.", format_args_from_macro!());
+
+    let args = format_args!("");
+    println!("{args:5}");
+}
+
+fn should_not_lint() {
+    println!("{}", format_args!(""));
+    // Technically the same as `{}`, but the `format_args` docs specifically mention that you can use
+    // debug formatting so allow it
+    println!("{:?}", format_args!(""));
+
+    let args = format_args!("");
+    println!("{args}");
+}
diff --git a/tests/ui/unused_format_specs_unfixable.stderr b/tests/ui/unused_format_specs_unfixable.stderr
new file mode 100644
index 00000000000..9f1890282e6
--- /dev/null
+++ b/tests/ui/unused_format_specs_unfixable.stderr
@@ -0,0 +1,69 @@
+error: format specifiers have no effect on `format_args!()`
+  --> $DIR/unused_format_specs_unfixable.rs:12:15
+   |
+LL |     println!("{:5}.", format_args!(""));
+   |               ^^^^
+   |
+   = note: `-D clippy::unused-format-specs` implied by `-D warnings`
+help: for the width to apply consider using `format!()`
+   |
+LL |     println!("{:5}.", format!(""));
+   |                       ~~~~~~
+help: if the current behavior is intentional, remove the format specifiers
+   |
+LL -     println!("{:5}.", format_args!(""));
+LL +     println!("{}.", format_args!(""));
+   |
+
+error: format specifiers have no effect on `format_args!()`
+  --> $DIR/unused_format_specs_unfixable.rs:14:15
+   |
+LL |     println!("{:.3}", format_args!("abcde"));
+   |               ^^^^^
+   |
+help: for the precision to apply consider using `format!()`
+   |
+LL |     println!("{:.3}", format!("abcde"));
+   |                       ~~~~~~
+help: if the current behavior is intentional, remove the format specifiers
+   |
+LL -     println!("{:.3}", format_args!("abcde"));
+LL +     println!("{}", format_args!("abcde"));
+   |
+
+error: format specifiers have no effect on `format_args!()`
+  --> $DIR/unused_format_specs_unfixable.rs:16:15
+   |
+LL |     println!("{:5}.", format_args_from_macro!());
+   |               ^^^^
+   |
+help: for the width to apply consider using `format!()`
+  --> $DIR/unused_format_specs_unfixable.rs:16:17
+   |
+LL |     println!("{:5}.", format_args_from_macro!());
+   |                 ^
+help: if the current behavior is intentional, remove the format specifiers
+   |
+LL -     println!("{:5}.", format_args_from_macro!());
+LL +     println!("{}.", format_args_from_macro!());
+   |
+
+error: format specifiers have no effect on `format_args!()`
+  --> $DIR/unused_format_specs_unfixable.rs:19:15
+   |
+LL |     println!("{args:5}");
+   |               ^^^^^^^^
+   |
+help: for the width to apply consider using `format!()`
+  --> $DIR/unused_format_specs_unfixable.rs:19:21
+   |
+LL |     println!("{args:5}");
+   |                     ^
+help: if the current behavior is intentional, remove the format specifiers
+   |
+LL -     println!("{args:5}");
+LL +     println!("{args}");
+   |
+
+error: aborting due to 4 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 1da1ff6b3c01bef0fbdcfae278480717bb54582c Mon Sep 17 00:00:00 2001
From: royrustdev <royrustdev@gmail.com>
Date: Wed, 12 Oct 2022 18:01:08 +0530
Subject: Update Applicability of `redundant_allocation` lint from
 `MachineApplicable` to `Unspecified`

---
 clippy_lints/src/types/redundant_allocation.rs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types/redundant_allocation.rs b/clippy_lints/src/types/redundant_allocation.rs
index 92d2c48a589..7883353e3fe 100644
--- a/clippy_lints/src/types/redundant_allocation.rs
+++ b/clippy_lints/src/types/redundant_allocation.rs
@@ -10,6 +10,7 @@ use rustc_span::symbol::sym;
 use super::{utils, REDUNDANT_ALLOCATION};
 
 pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_>, def_id: DefId) -> bool {
+    let mut applicability = Applicability::MaybeIncorrect;
     let outer_sym = if Some(def_id) == cx.tcx.lang_items().owned_box() {
         "Box"
     } else if cx.tcx.is_diagnostic_item(sym::Rc, def_id) {
@@ -21,7 +22,6 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_
     };
 
     if let Some(span) = utils::match_borrows_parameter(cx, qpath) {
-        let mut applicability = Applicability::MaybeIncorrect;
         let generic_snippet = snippet_with_applicability(cx, span, "..", &mut applicability);
         span_lint_and_then(
             cx,
@@ -63,7 +63,6 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_
         None => return false,
     };
     if inner_sym == outer_sym {
-        let mut applicability = Applicability::MaybeIncorrect;
         let generic_snippet = snippet_with_applicability(cx, inner_span, "..", &mut applicability);
         span_lint_and_then(
             cx,
-- 
cgit 1.4.1-3-g733a5


From b6a860e0ed7a76b1834c9618842d299e4501d2ff Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Mon, 17 Oct 2022 21:59:27 +0000
Subject: Add `missing_trait_methods` lint

---
 CHANGELOG.md                                 |  1 +
 clippy_lints/src/lib.register_lints.rs       |  1 +
 clippy_lints/src/lib.register_restriction.rs |  1 +
 clippy_lints/src/lib.rs                      |  2 +
 clippy_lints/src/missing_trait_methods.rs    | 98 ++++++++++++++++++++++++++++
 src/docs.rs                                  |  1 +
 src/docs/missing_trait_methods.txt           | 40 ++++++++++++
 tests/ui/missing_trait_methods.rs            | 50 ++++++++++++++
 tests/ui/missing_trait_methods.stderr        | 27 ++++++++
 9 files changed, 221 insertions(+)
 create mode 100644 clippy_lints/src/missing_trait_methods.rs
 create mode 100644 src/docs/missing_trait_methods.txt
 create mode 100644 tests/ui/missing_trait_methods.rs
 create mode 100644 tests/ui/missing_trait_methods.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 1e0ff5db0ee..a9476e8373e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4049,6 +4049,7 @@ Released 2018-09-13
 [`missing_panics_doc`]: https://rust-lang.github.io/rust-clippy/master/index.html#missing_panics_doc
 [`missing_safety_doc`]: https://rust-lang.github.io/rust-clippy/master/index.html#missing_safety_doc
 [`missing_spin_loop`]: https://rust-lang.github.io/rust-clippy/master/index.html#missing_spin_loop
+[`missing_trait_methods`]: https://rust-lang.github.io/rust-clippy/master/index.html#missing_trait_methods
 [`mistyped_literal_suffixes`]: https://rust-lang.github.io/rust-clippy/master/index.html#mistyped_literal_suffixes
 [`mixed_case_hex_literals`]: https://rust-lang.github.io/rust-clippy/master/index.html#mixed_case_hex_literals
 [`mixed_read_write_in_expression`]: https://rust-lang.github.io/rust-clippy/master/index.html#mixed_read_write_in_expression
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index c188e9057f1..03bfc7de56e 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -407,6 +407,7 @@ store.register_lints(&[
     missing_doc::MISSING_DOCS_IN_PRIVATE_ITEMS,
     missing_enforced_import_rename::MISSING_ENFORCED_IMPORT_RENAMES,
     missing_inline::MISSING_INLINE_IN_PUBLIC_ITEMS,
+    missing_trait_methods::MISSING_TRAIT_METHODS,
     mixed_read_write_in_expression::DIVERGING_SUB_EXPRESSION,
     mixed_read_write_in_expression::MIXED_READ_WRITE_IN_EXPRESSION,
     module_style::MOD_MODULE_FILES,
diff --git a/clippy_lints/src/lib.register_restriction.rs b/clippy_lints/src/lib.register_restriction.rs
index 9edced28408..f62d57af5b4 100644
--- a/clippy_lints/src/lib.register_restriction.rs
+++ b/clippy_lints/src/lib.register_restriction.rs
@@ -47,6 +47,7 @@ store.register_group(true, "clippy::restriction", Some("clippy_restriction"), ve
     LintId::of(missing_doc::MISSING_DOCS_IN_PRIVATE_ITEMS),
     LintId::of(missing_enforced_import_rename::MISSING_ENFORCED_IMPORT_RENAMES),
     LintId::of(missing_inline::MISSING_INLINE_IN_PUBLIC_ITEMS),
+    LintId::of(missing_trait_methods::MISSING_TRAIT_METHODS),
     LintId::of(mixed_read_write_in_expression::MIXED_READ_WRITE_IN_EXPRESSION),
     LintId::of(module_style::MOD_MODULE_FILES),
     LintId::of(module_style::SELF_NAMED_MODULE_FILES),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index b9185b8a514..9418e0e1135 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -289,6 +289,7 @@ mod missing_const_for_fn;
 mod missing_doc;
 mod missing_enforced_import_rename;
 mod missing_inline;
+mod missing_trait_methods;
 mod mixed_read_write_in_expression;
 mod module_style;
 mod multi_assignments;
@@ -916,6 +917,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(box_default::BoxDefault));
     store.register_late_pass(|_| Box::new(implicit_saturating_add::ImplicitSaturatingAdd));
     store.register_early_pass(|| Box::new(partial_pub_fields::PartialPubFields));
+    store.register_late_pass(|_| Box::new(missing_trait_methods::MissingTraitMethods));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/missing_trait_methods.rs b/clippy_lints/src/missing_trait_methods.rs
new file mode 100644
index 00000000000..68af8a672f6
--- /dev/null
+++ b/clippy_lints/src/missing_trait_methods.rs
@@ -0,0 +1,98 @@
+use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::is_lint_allowed;
+use clippy_utils::macros::span_is_local;
+use rustc_hir::def_id::DefIdMap;
+use rustc_hir::{Impl, Item, ItemKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::AssocItem;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks if a provided method is used implicitly by a trait
+    /// implementation. A usage example would be a wrapper where every method
+    /// should perform some operation before delegating to the inner type's
+    /// implemenation.
+    ///
+    /// This lint should typically be enabled on a specific trait `impl` item
+    /// rather than globally.
+    ///
+    /// ### Why is this bad?
+    /// Indicates that a method is missing.
+    ///
+    /// ### Example
+    /// ```rust
+    /// trait Trait {
+    ///     fn required();
+    ///
+    ///     fn provided() {}
+    /// }
+    ///
+    /// # struct Type;
+    /// #[warn(clippy::missing_trait_methods)]
+    /// impl Trait for Type {
+    ///     fn required() { /* ... */ }
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// trait Trait {
+    ///     fn required();
+    ///
+    ///     fn provided() {}
+    /// }
+    ///
+    /// # struct Type;
+    /// #[warn(clippy::missing_trait_methods)]
+    /// impl Trait for Type {
+    ///     fn required() { /* ... */ }
+    ///
+    ///     fn provided() { /* ... */ }
+    /// }
+    /// ```
+    #[clippy::version = "1.66.0"]
+    pub MISSING_TRAIT_METHODS,
+    restriction,
+    "trait implementation uses default provided method"
+}
+declare_lint_pass!(MissingTraitMethods => [MISSING_TRAIT_METHODS]);
+
+impl<'tcx> LateLintPass<'tcx> for MissingTraitMethods {
+    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
+        if !is_lint_allowed(cx, MISSING_TRAIT_METHODS, item.hir_id())
+            && span_is_local(item.span)
+            && let ItemKind::Impl(Impl {
+                items,
+                of_trait: Some(trait_ref),
+                ..
+            }) = item.kind
+            && let Some(trait_id) = trait_ref.trait_def_id()
+        {
+            let mut provided: DefIdMap<&AssocItem> = cx
+                .tcx
+                .provided_trait_methods(trait_id)
+                .map(|assoc| (assoc.def_id, assoc))
+                .collect();
+
+            for impl_item in *items {
+                if let Some(def_id) = impl_item.trait_item_def_id {
+                    provided.remove(&def_id);
+                }
+            }
+
+            for assoc in provided.values() {
+                let source_map = cx.tcx.sess.source_map();
+                let definition_span = source_map.guess_head_span(cx.tcx.def_span(assoc.def_id));
+
+                span_lint_and_help(
+                    cx,
+                    MISSING_TRAIT_METHODS,
+                    source_map.guess_head_span(item.span),
+                    &format!("missing trait method provided by default: `{}`", assoc.name),
+                    Some(definition_span),
+                    "implement the method",
+                );
+            }
+        }
+    }
+}
diff --git a/src/docs.rs b/src/docs.rs
index b8b4286b488..8aaa61d2967 100644
--- a/src/docs.rs
+++ b/src/docs.rs
@@ -317,6 +317,7 @@ docs! {
     "missing_panics_doc",
     "missing_safety_doc",
     "missing_spin_loop",
+    "missing_trait_methods",
     "mistyped_literal_suffixes",
     "mixed_case_hex_literals",
     "mixed_read_write_in_expression",
diff --git a/src/docs/missing_trait_methods.txt b/src/docs/missing_trait_methods.txt
new file mode 100644
index 00000000000..788ad764f8c
--- /dev/null
+++ b/src/docs/missing_trait_methods.txt
@@ -0,0 +1,40 @@
+### What it does
+Checks if a provided method is used implicitly by a trait
+implementation. A usage example would be a wrapper where every method
+should perform some operation before delegating to the inner type's
+implemenation.
+
+This lint should typically be enabled on a specific trait `impl` item
+rather than globally.
+
+### Why is this bad?
+Indicates that a method is missing.
+
+### Example
+```
+trait Trait {
+    fn required();
+
+    fn provided() {}
+}
+
+#[warn(clippy::missing_trait_methods)]
+impl Trait for Type {
+    fn required() { /* ... */ }
+}
+```
+Use instead:
+```
+trait Trait {
+    fn required();
+
+    fn provided() {}
+}
+
+#[warn(clippy::missing_trait_methods)]
+impl Trait for Type {
+    fn required() { /* ... */ }
+
+    fn provided() { /* ... */ }
+}
+```
\ No newline at end of file
diff --git a/tests/ui/missing_trait_methods.rs b/tests/ui/missing_trait_methods.rs
new file mode 100644
index 00000000000..8df885919a3
--- /dev/null
+++ b/tests/ui/missing_trait_methods.rs
@@ -0,0 +1,50 @@
+#![allow(unused, clippy::needless_lifetimes)]
+#![warn(clippy::missing_trait_methods)]
+
+trait A {
+    fn provided() {}
+}
+
+trait B {
+    fn required();
+
+    fn a(_: usize) -> usize {
+        1
+    }
+
+    fn b<'a, T: AsRef<[u8]>>(a: &'a T) -> &'a [u8] {
+        a.as_ref()
+    }
+}
+
+struct Partial;
+
+impl A for Partial {}
+
+impl B for Partial {
+    fn required() {}
+
+    fn a(_: usize) -> usize {
+        2
+    }
+}
+
+struct Complete;
+
+impl A for Complete {
+    fn provided() {}
+}
+
+impl B for Complete {
+    fn required() {}
+
+    fn a(_: usize) -> usize {
+        2
+    }
+
+    fn b<T: AsRef<[u8]>>(a: &T) -> &[u8] {
+        a.as_ref()
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/missing_trait_methods.stderr b/tests/ui/missing_trait_methods.stderr
new file mode 100644
index 00000000000..0c5205e1965
--- /dev/null
+++ b/tests/ui/missing_trait_methods.stderr
@@ -0,0 +1,27 @@
+error: missing trait method provided by default: `provided`
+  --> $DIR/missing_trait_methods.rs:22:1
+   |
+LL | impl A for Partial {}
+   | ^^^^^^^^^^^^^^^^^^
+   |
+help: implement the method
+  --> $DIR/missing_trait_methods.rs:5:5
+   |
+LL |     fn provided() {}
+   |     ^^^^^^^^^^^^^
+   = note: `-D clippy::missing-trait-methods` implied by `-D warnings`
+
+error: missing trait method provided by default: `b`
+  --> $DIR/missing_trait_methods.rs:24:1
+   |
+LL | impl B for Partial {
+   | ^^^^^^^^^^^^^^^^^^
+   |
+help: implement the method
+  --> $DIR/missing_trait_methods.rs:15:5
+   |
+LL |     fn b<'a, T: AsRef<[u8]>>(a: &'a T) -> &'a [u8] {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 615b7617ed3ba1ea44575a9072b17a4bdfb565b2 Mon Sep 17 00:00:00 2001
From: kraktus <kraktus@users.noreply.github.com>
Date: Fri, 21 Oct 2022 13:48:41 +0200
Subject: `ref_option_ref` do not lint when inner reference is mutable

As it makes the `Option` Non Copy
---
 clippy_lints/src/ref_option_ref.rs | 3 ++-
 tests/ui/ref_option_ref.rs         | 5 +++++
 2 files changed, 7 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/ref_option_ref.rs b/clippy_lints/src/ref_option_ref.rs
index 42514f861be..f21b3ea6c3b 100644
--- a/clippy_lints/src/ref_option_ref.rs
+++ b/clippy_lints/src/ref_option_ref.rs
@@ -52,7 +52,8 @@ impl<'tcx> LateLintPass<'tcx> for RefOptionRef {
                 GenericArg::Type(inner_ty) => Some(inner_ty),
                 _ => None,
             });
-            if let TyKind::Rptr(_, _) = inner_ty.kind;
+            if let TyKind::Rptr(_, ref inner_mut_ty) = inner_ty.kind;
+            if inner_mut_ty.mutbl == Mutability::Not;
 
             then {
                 span_lint_and_sugg(
diff --git a/tests/ui/ref_option_ref.rs b/tests/ui/ref_option_ref.rs
index 2df45c927d7..e487799e152 100644
--- a/tests/ui/ref_option_ref.rs
+++ b/tests/ui/ref_option_ref.rs
@@ -45,3 +45,8 @@ impl RefOptTrait for u32 {
 fn main() {
     let x: &Option<&u32> = &None;
 }
+
+fn issue9682(arg: &Option<&mut String>) {
+    // Should not lint, as the inner ref is mutable making it non `Copy`
+    println!("{arg:?}");
+}
-- 
cgit 1.4.1-3-g733a5


From 487c6fc9adc02e835fde35451f016296450b1c33 Mon Sep 17 00:00:00 2001
From: kraktus <kraktus@users.noreply.github.com>
Date: Fri, 21 Oct 2022 14:51:13 +0200
Subject: [`collapsible_match`] specify field name when destructuring structs

---
 clippy_lints/src/matches/collapsible_match.rs | 23 ++++++++++++++----
 tests/ui/collapsible_match.rs                 | 21 +++++++++++++++++
 tests/ui/collapsible_match.stderr             | 34 ++++++++++++++++++++++++++-
 3 files changed, 72 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/collapsible_match.rs b/clippy_lints/src/matches/collapsible_match.rs
index fd14d868df3..33a052c41a3 100644
--- a/clippy_lints/src/matches/collapsible_match.rs
+++ b/clippy_lints/src/matches/collapsible_match.rs
@@ -1,5 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::higher::IfLetOrMatch;
+use clippy_utils::source::snippet;
 use clippy_utils::visitors::is_local_used;
 use clippy_utils::{
     is_res_lang_ctor, is_unit_expr, path_to_local, peel_blocks_with_stmt, peel_ref_operators, SpanlessEq,
@@ -63,7 +64,8 @@ fn check_arm<'tcx>(
         if !pat_contains_or(inner_then_pat);
         // the binding must come from the pattern of the containing match arm
         // ..<local>.. => match <local> { .. }
-        if let Some(binding_span) = find_pat_binding(outer_pat, binding_id);
+        if let (Some(binding_span), is_innermost_parent_pat_struct)
+            = find_pat_binding_and_is_innermost_parent_pat_struct(outer_pat, binding_id);
         // the "else" branches must be equal
         if match (outer_else_body, inner_else_body) {
             (None, None) => true,
@@ -88,6 +90,13 @@ fn check_arm<'tcx>(
                 if matches!(inner, IfLetOrMatch::Match(..)) { "match" } else { "if let" },
                 if outer_is_match { "match" } else { "if let" },
             );
+            // collapsing patterns need an explicit field name in struct pattern matching
+            // ex: Struct {x: Some(1)}
+            let replace_msg = if is_innermost_parent_pat_struct {
+                format!(", prefixed by {}:", snippet(cx, binding_span, "their field name"))
+            } else {
+                String::new()
+            };
             span_lint_and_then(
                 cx,
                 COLLAPSIBLE_MATCH,
@@ -96,7 +105,7 @@ fn check_arm<'tcx>(
                 |diag| {
                     let mut help_span = MultiSpan::from_spans(vec![binding_span, inner_then_pat.span]);
                     help_span.push_span_label(binding_span, "replace this binding");
-                    help_span.push_span_label(inner_then_pat.span, "with this pattern");
+                    help_span.push_span_label(inner_then_pat.span, format!("with this pattern{replace_msg}"));
                     diag.span_help(help_span, "the outer pattern can be modified to include the inner pattern");
                 },
             );
@@ -117,8 +126,9 @@ fn arm_is_wild_like(cx: &LateContext<'_>, arm: &Arm<'_>) -> bool {
     }
 }
 
-fn find_pat_binding(pat: &Pat<'_>, hir_id: HirId) -> Option<Span> {
+fn find_pat_binding_and_is_innermost_parent_pat_struct(pat: &Pat<'_>, hir_id: HirId) -> (Option<Span>, bool) {
     let mut span = None;
+    let mut is_innermost_parent_pat_struct = false;
     pat.walk_short(|p| match &p.kind {
         // ignore OR patterns
         PatKind::Or(_) => false,
@@ -129,9 +139,12 @@ fn find_pat_binding(pat: &Pat<'_>, hir_id: HirId) -> Option<Span> {
             }
             !found
         },
-        _ => true,
+        _ => {
+            is_innermost_parent_pat_struct = matches!(p.kind, PatKind::Struct(..));
+            true
+        },
     });
-    span
+    (span, is_innermost_parent_pat_struct)
 }
 
 fn pat_contains_or(pat: &Pat<'_>) -> bool {
diff --git a/tests/ui/collapsible_match.rs b/tests/ui/collapsible_match.rs
index 7d53e08345d..1d7a7284641 100644
--- a/tests/ui/collapsible_match.rs
+++ b/tests/ui/collapsible_match.rs
@@ -253,6 +253,27 @@ fn negative_cases(res_opt: Result<Option<u32>, String>, res_res: Result<Result<u
     };
 }
 
+pub enum Issue9647 {
+    A { a: Option<Option<u8>>, b: () },
+    B,
+}
+
+pub fn test_1(x: Issue9647) {
+    if let Issue9647::A { a, .. } = x {
+        if let Some(u) = a {
+            println!("{u:?}")
+        }
+    }
+}
+
+pub fn test_2(x: Issue9647) {
+    if let Issue9647::A { a: Some(a), .. } = x {
+        if let Some(u) = a {
+            println!("{u}")
+        }
+    }
+}
+
 fn make<T>() -> T {
     unimplemented!()
 }
diff --git a/tests/ui/collapsible_match.stderr b/tests/ui/collapsible_match.stderr
index 2580bef5809..0294be60b43 100644
--- a/tests/ui/collapsible_match.stderr
+++ b/tests/ui/collapsible_match.stderr
@@ -175,5 +175,37 @@ LL |         Some(val) => match val {
 LL |             Some(n) => foo(n),
    |             ^^^^^^^ with this pattern
 
-error: aborting due to 10 previous errors
+error: this `if let` can be collapsed into the outer `if let`
+  --> $DIR/collapsible_match.rs:263:9
+   |
+LL | /         if let Some(u) = a {
+LL | |             println!("{u:?}")
+LL | |         }
+   | |_________^
+   |
+help: the outer pattern can be modified to include the inner pattern
+  --> $DIR/collapsible_match.rs:262:27
+   |
+LL |     if let Issue9647::A { a, .. } = x {
+   |                           ^ replace this binding
+LL |         if let Some(u) = a {
+   |                ^^^^^^^ with this pattern, prefixed by a:
+
+error: this `if let` can be collapsed into the outer `if let`
+  --> $DIR/collapsible_match.rs:271:9
+   |
+LL | /         if let Some(u) = a {
+LL | |             println!("{u}")
+LL | |         }
+   | |_________^
+   |
+help: the outer pattern can be modified to include the inner pattern
+  --> $DIR/collapsible_match.rs:270:35
+   |
+LL |     if let Issue9647::A { a: Some(a), .. } = x {
+   |                                   ^ replace this binding
+LL |         if let Some(u) = a {
+   |                ^^^^^^^ with this pattern
+
+error: aborting due to 12 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 655175494574265257f52f4f7a1e7eabd85cbe77 Mon Sep 17 00:00:00 2001
From: kraktus <kraktus@users.noreply.github.com>
Date: Fri, 21 Oct 2022 15:27:25 +0200
Subject: [`unwrap_used`], [`expect_used`] do not lint in `test` cfg

---
 clippy_lints/src/methods/expect_used.rs      |  4 ++--
 clippy_lints/src/methods/unwrap_used.rs      |  4 ++--
 clippy_lints/src/utils/conf.rs               |  4 ++--
 tests/ui-toml/expect_used/expect_used.rs     | 23 ++++++++++++++---------
 tests/ui-toml/unwrap_used/unwrap_used.rs     | 21 +++++++++++++++++----
 tests/ui-toml/unwrap_used/unwrap_used.stderr |  6 +++---
 6 files changed, 40 insertions(+), 22 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/expect_used.rs b/clippy_lints/src/methods/expect_used.rs
index d59fefa1ddc..0d3c8928046 100644
--- a/clippy_lints/src/methods/expect_used.rs
+++ b/clippy_lints/src/methods/expect_used.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_help;
-use clippy_utils::is_in_test_function;
+use clippy_utils::is_in_cfg_test;
 use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
@@ -27,7 +27,7 @@ pub(super) fn check(
 
     let method = if is_err { "expect_err" } else { "expect" };
 
-    if allow_expect_in_tests && is_in_test_function(cx.tcx, expr.hir_id) {
+    if allow_expect_in_tests && is_in_cfg_test(cx.tcx, expr.hir_id) {
         return;
     }
 
diff --git a/clippy_lints/src/methods/unwrap_used.rs b/clippy_lints/src/methods/unwrap_used.rs
index ee17f2d7889..d11830a24b6 100644
--- a/clippy_lints/src/methods/unwrap_used.rs
+++ b/clippy_lints/src/methods/unwrap_used.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{is_in_test_function, is_lint_allowed};
+use clippy_utils::{is_in_cfg_test, is_lint_allowed};
 use rustc_hir as hir;
 use rustc_lint::LateContext;
 use rustc_span::sym;
@@ -27,7 +27,7 @@ pub(super) fn check(
 
     let method_suffix = if is_err { "_err" } else { "" };
 
-    if allow_unwrap_in_tests && is_in_test_function(cx.tcx, expr.hir_id) {
+    if allow_unwrap_in_tests && is_in_cfg_test(cx.tcx, expr.hir_id) {
         return;
     }
 
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 668123e4d6e..199dfafebf3 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -373,11 +373,11 @@ define_Conf! {
     (max_include_file_size: u64 = 1_000_000),
     /// Lint: EXPECT_USED.
     ///
-    /// Whether `expect` should be allowed in test functions
+    /// Whether `expect` should be allowed in test cfg
     (allow_expect_in_tests: bool = false),
     /// Lint: UNWRAP_USED.
     ///
-    /// Whether `unwrap` should be allowed in test functions
+    /// Whether `unwrap` should be allowed in test cfg
     (allow_unwrap_in_tests: bool = false),
     /// Lint: DBG_MACRO.
     ///
diff --git a/tests/ui-toml/expect_used/expect_used.rs b/tests/ui-toml/expect_used/expect_used.rs
index 22dcd3ae9d6..bff97d97df7 100644
--- a/tests/ui-toml/expect_used/expect_used.rs
+++ b/tests/ui-toml/expect_used/expect_used.rs
@@ -16,14 +16,19 @@ fn main() {
     expect_result();
 }
 
-#[test]
-fn test_expect_option() {
-    let opt = Some(0);
-    let _ = opt.expect("");
-}
+#[cfg(test)]
+mod issue9612 {
+    // should not lint in `#[cfg(test)]` modules
+    #[test]
+    fn test_fn() {
+        let _a: u8 = 2.try_into().unwrap();
+        let _a: u8 = 3.try_into().expect("");
 
-#[test]
-fn test_expect_result() {
-    let res: Result<u8, ()> = Ok(0);
-    let _ = res.expect("");
+        util();
+    }
+
+    fn util() {
+        let _a: u8 = 4.try_into().unwrap();
+        let _a: u8 = 5.try_into().expect("");
+    }
 }
diff --git a/tests/ui-toml/unwrap_used/unwrap_used.rs b/tests/ui-toml/unwrap_used/unwrap_used.rs
index 0e82fb20e45..bc8e8c1f070 100644
--- a/tests/ui-toml/unwrap_used/unwrap_used.rs
+++ b/tests/ui-toml/unwrap_used/unwrap_used.rs
@@ -66,8 +66,21 @@ fn main() {
     }
 }
 
-#[test]
-fn test() {
-    let boxed_slice: Box<[u8]> = Box::new([0, 1, 2, 3]);
-    let _ = boxed_slice.get(1).unwrap();
+#[cfg(test)]
+mod issue9612 {
+    // should not lint in `#[cfg(test)]` modules
+    #[test]
+    fn test_fn() {
+        let _a: u8 = 2.try_into().unwrap();
+        let _a: u8 = 3.try_into().expect("");
+
+        util();
+    }
+
+    fn util() {
+        let _a: u8 = 4.try_into().unwrap();
+        let _a: u8 = 5.try_into().expect("");
+        // should still warn
+        let _ = Box::new([0]).get(1).unwrap();
+    }
 }
diff --git a/tests/ui-toml/unwrap_used/unwrap_used.stderr b/tests/ui-toml/unwrap_used/unwrap_used.stderr
index 681b5eaf54d..2bca88660e1 100644
--- a/tests/ui-toml/unwrap_used/unwrap_used.stderr
+++ b/tests/ui-toml/unwrap_used/unwrap_used.stderr
@@ -188,10 +188,10 @@ LL |         let _ = some_vec.get_mut(0..1).unwrap().to_vec();
    = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
 
 error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more concise
-  --> $DIR/unwrap_used.rs:72:13
+  --> $DIR/unwrap_used.rs:84:17
    |
-LL |     let _ = boxed_slice.get(1).unwrap();
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&boxed_slice[1]`
+LL |         let _ = Box::new([0]).get(1).unwrap();
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&Box::new([0])[1]`
 
 error: aborting due to 27 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From a0c82d2bcce1b636c02bb6bf942c05af8dc3ac9a Mon Sep 17 00:00:00 2001
From: kraktus <56031107+kraktus@users.noreply.github.com>
Date: Sat, 22 Oct 2022 21:07:05 +0200
Subject: Explicitly mention [cfg(test)]

Co-authored-by: llogiq <bogusandre@gmail.com>
---
 clippy_lints/src/utils/conf.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 199dfafebf3..a10de31556c 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -373,7 +373,7 @@ define_Conf! {
     (max_include_file_size: u64 = 1_000_000),
     /// Lint: EXPECT_USED.
     ///
-    /// Whether `expect` should be allowed in test cfg
+    /// Whether `expect` should be allowed within `#[cfg(test)]`
     (allow_expect_in_tests: bool = false),
     /// Lint: UNWRAP_USED.
     ///
-- 
cgit 1.4.1-3-g733a5


From ff893366c1ac355822aa644c0ed43930eb605fb4 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Sun, 23 Oct 2022 13:45:26 +0000
Subject: Mark `let_underscore_drop` as uplifted

---
 clippy_lints/src/let_underscore.rs        | 138 +++++++++---------------------
 clippy_lints/src/lib.register_lints.rs    |   1 -
 clippy_lints/src/lib.register_pedantic.rs |   1 -
 clippy_lints/src/renamed_lints.rs         |   5 +-
 lintcheck/src/main.rs                     |   2 +-
 src/docs.rs                               |   1 -
 src/docs/let_underscore_drop.txt          |  29 -------
 tests/ui/let_underscore_drop.rs           |  28 ------
 tests/ui/let_underscore_drop.stderr       |  27 ------
 tests/ui/map_flatten_fixable.fixed        |   1 -
 tests/ui/map_flatten_fixable.rs           |   1 -
 tests/ui/map_flatten_fixable.stderr       |  18 ++--
 tests/ui/rename.fixed                     |   8 +-
 tests/ui/rename.rs                        |   8 +-
 tests/ui/rename.stderr                    | 106 ++++++++++++-----------
 15 files changed, 121 insertions(+), 253 deletions(-)
 delete mode 100644 src/docs/let_underscore_drop.txt
 delete mode 100644 tests/ui/let_underscore_drop.rs
 delete mode 100644 tests/ui/let_underscore_drop.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/let_underscore.rs b/clippy_lints/src/let_underscore.rs
index b7798b1c1d7..448688a3028 100644
--- a/clippy_lints/src/let_underscore.rs
+++ b/clippy_lints/src/let_underscore.rs
@@ -1,7 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::ty::{is_must_use_ty, is_type_diagnostic_item, match_type};
 use clippy_utils::{is_must_use_func_call, paths};
-use if_chain::if_chain;
 use rustc_hir::{Local, PatKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::lint::in_external_macro;
@@ -60,45 +59,7 @@ declare_clippy_lint! {
     "non-binding let on a synchronization lock"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for `let _ = <expr>`
-    /// where expr has a type that implements `Drop`
-    ///
-    /// ### Why is this bad?
-    /// This statement immediately drops the initializer
-    /// expression instead of extending its lifetime to the end of the scope, which
-    /// is often not intended. To extend the expression's lifetime to the end of the
-    /// scope, use an underscore-prefixed name instead (i.e. _var). If you want to
-    /// explicitly drop the expression, `std::mem::drop` conveys your intention
-    /// better and is less error-prone.
-    ///
-    /// ### Example
-    /// ```rust
-    /// # struct DroppableItem;
-    /// {
-    ///     let _ = DroppableItem;
-    ///     //                   ^ dropped here
-    ///     /* more code */
-    /// }
-    /// ```
-    ///
-    /// Use instead:
-    /// ```rust
-    /// # struct DroppableItem;
-    /// {
-    ///     let _droppable = DroppableItem;
-    ///     /* more code */
-    ///     // dropped at end of scope
-    /// }
-    /// ```
-    #[clippy::version = "1.50.0"]
-    pub LET_UNDERSCORE_DROP,
-    pedantic,
-    "non-binding let on a type that implements `Drop`"
-}
-
-declare_lint_pass!(LetUnderscore => [LET_UNDERSCORE_MUST_USE, LET_UNDERSCORE_LOCK, LET_UNDERSCORE_DROP]);
+declare_lint_pass!(LetUnderscore => [LET_UNDERSCORE_MUST_USE, LET_UNDERSCORE_LOCK]);
 
 const SYNC_GUARD_SYMS: [Symbol; 3] = [sym::MutexGuard, sym::RwLockReadGuard, sym::RwLockWriteGuard];
 
@@ -110,64 +71,49 @@ const SYNC_GUARD_PATHS: [&[&str]; 3] = [
 
 impl<'tcx> LateLintPass<'tcx> for LetUnderscore {
     fn check_local(&mut self, cx: &LateContext<'_>, local: &Local<'_>) {
-        if in_external_macro(cx.tcx.sess, local.span) {
-            return;
-        }
+        if !in_external_macro(cx.tcx.sess, local.span)
+            && let PatKind::Wild = local.pat.kind
+            && let Some(init) = local.init
+        {
+            let init_ty = cx.typeck_results().expr_ty(init);
+            let contains_sync_guard = init_ty.walk().any(|inner| match inner.unpack() {
+                GenericArgKind::Type(inner_ty) => {
+                    SYNC_GUARD_SYMS
+                        .iter()
+                        .any(|&sym| is_type_diagnostic_item(cx, inner_ty, sym))
+                        || SYNC_GUARD_PATHS.iter().any(|path| match_type(cx, inner_ty, path))
+                },
 
-        if_chain! {
-            if let PatKind::Wild = local.pat.kind;
-            if let Some(init) = local.init;
-            then {
-                let init_ty = cx.typeck_results().expr_ty(init);
-                let contains_sync_guard = init_ty.walk().any(|inner| match inner.unpack() {
-                    GenericArgKind::Type(inner_ty) => {
-                        SYNC_GUARD_SYMS
-                            .iter()
-                            .any(|&sym| is_type_diagnostic_item(cx, inner_ty, sym))
-                            || SYNC_GUARD_PATHS.iter().any(|path| match_type(cx, inner_ty, path))
-                    },
-
-                    GenericArgKind::Lifetime(_) | GenericArgKind::Const(_) => false,
-                });
-                if contains_sync_guard {
-                    span_lint_and_help(
-                        cx,
-                        LET_UNDERSCORE_LOCK,
-                        local.span,
-                        "non-binding let on a synchronization lock",
-                        None,
-                        "consider using an underscore-prefixed named \
-                            binding or dropping explicitly with `std::mem::drop`",
-                    );
-                } else if init_ty.needs_drop(cx.tcx, cx.param_env) {
-                    span_lint_and_help(
-                        cx,
-                        LET_UNDERSCORE_DROP,
-                        local.span,
-                        "non-binding `let` on a type that implements `Drop`",
-                        None,
-                        "consider using an underscore-prefixed named \
+                GenericArgKind::Lifetime(_) | GenericArgKind::Const(_) => false,
+            });
+            if contains_sync_guard {
+                span_lint_and_help(
+                    cx,
+                    LET_UNDERSCORE_LOCK,
+                    local.span,
+                    "non-binding let on a synchronization lock",
+                    None,
+                    "consider using an underscore-prefixed named \
                             binding or dropping explicitly with `std::mem::drop`",
-                    );
-                } else if is_must_use_ty(cx, cx.typeck_results().expr_ty(init)) {
-                    span_lint_and_help(
-                        cx,
-                        LET_UNDERSCORE_MUST_USE,
-                        local.span,
-                        "non-binding let on an expression with `#[must_use]` type",
-                        None,
-                        "consider explicitly using expression value",
-                    );
-                } else if is_must_use_func_call(cx, init) {
-                    span_lint_and_help(
-                        cx,
-                        LET_UNDERSCORE_MUST_USE,
-                        local.span,
-                        "non-binding let on a result of a `#[must_use]` function",
-                        None,
-                        "consider explicitly using function result",
-                    );
-                }
+                );
+            } else if is_must_use_ty(cx, cx.typeck_results().expr_ty(init)) {
+                span_lint_and_help(
+                    cx,
+                    LET_UNDERSCORE_MUST_USE,
+                    local.span,
+                    "non-binding let on an expression with `#[must_use]` type",
+                    None,
+                    "consider explicitly using expression value",
+                );
+            } else if is_must_use_func_call(cx, init) {
+                span_lint_and_help(
+                    cx,
+                    LET_UNDERSCORE_MUST_USE,
+                    local.span,
+                    "non-binding let on a result of a `#[must_use]` function",
+                    None,
+                    "consider explicitly using function result",
+                );
             }
         }
     }
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 800e3a87671..44d3fec8bd2 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -214,7 +214,6 @@ store.register_lints(&[
     len_zero::LEN_WITHOUT_IS_EMPTY,
     len_zero::LEN_ZERO,
     let_if_seq::USELESS_LET_IF_SEQ,
-    let_underscore::LET_UNDERSCORE_DROP,
     let_underscore::LET_UNDERSCORE_LOCK,
     let_underscore::LET_UNDERSCORE_MUST_USE,
     lifetimes::EXTRA_UNUSED_LIFETIMES,
diff --git a/clippy_lints/src/lib.register_pedantic.rs b/clippy_lints/src/lib.register_pedantic.rs
index 2ead71a68fa..768b3347c2a 100644
--- a/clippy_lints/src/lib.register_pedantic.rs
+++ b/clippy_lints/src/lib.register_pedantic.rs
@@ -39,7 +39,6 @@ store.register_group(true, "clippy::pedantic", Some("clippy_pedantic"), vec![
     LintId::of(items_after_statements::ITEMS_AFTER_STATEMENTS),
     LintId::of(iter_not_returning_iterator::ITER_NOT_RETURNING_ITERATOR),
     LintId::of(large_stack_arrays::LARGE_STACK_ARRAYS),
-    LintId::of(let_underscore::LET_UNDERSCORE_DROP),
     LintId::of(literal_representation::LARGE_DIGIT_GROUPS),
     LintId::of(literal_representation::UNREADABLE_LITERAL),
     LintId::of(loops::EXPLICIT_INTO_ITER_LOOP),
diff --git a/clippy_lints/src/renamed_lints.rs b/clippy_lints/src/renamed_lints.rs
index 76d6ad0b23e..8e214218f23 100644
--- a/clippy_lints/src/renamed_lints.rs
+++ b/clippy_lints/src/renamed_lints.rs
@@ -11,8 +11,6 @@ pub static RENAMED_LINTS: &[(&str, &str)] = &[
     ("clippy::disallowed_method", "clippy::disallowed_methods"),
     ("clippy::disallowed_type", "clippy::disallowed_types"),
     ("clippy::eval_order_dependence", "clippy::mixed_read_write_in_expression"),
-    ("clippy::for_loop_over_option", "for_loops_over_fallibles"),
-    ("clippy::for_loop_over_result", "for_loops_over_fallibles"),
     ("clippy::identity_conversion", "clippy::useless_conversion"),
     ("clippy::if_let_some_result", "clippy::match_result_ok"),
     ("clippy::logic_bug", "clippy::overly_complex_bool_expr"),
@@ -31,10 +29,13 @@ pub static RENAMED_LINTS: &[(&str, &str)] = &[
     ("clippy::to_string_in_display", "clippy::recursive_format_impl"),
     ("clippy::zero_width_space", "clippy::invisible_characters"),
     ("clippy::drop_bounds", "drop_bounds"),
+    ("clippy::for_loop_over_option", "for_loops_over_fallibles"),
+    ("clippy::for_loop_over_result", "for_loops_over_fallibles"),
     ("clippy::for_loops_over_fallibles", "for_loops_over_fallibles"),
     ("clippy::into_iter_on_array", "array_into_iter"),
     ("clippy::invalid_atomic_ordering", "invalid_atomic_ordering"),
     ("clippy::invalid_ref", "invalid_value"),
+    ("clippy::let_underscore_drop", "let_underscore_drop"),
     ("clippy::mem_discriminant_non_enum", "enum_intrinsics_non_enums"),
     ("clippy::panic_params", "non_fmt_panics"),
     ("clippy::positional_named_format_parameters", "named_arguments_used_positionally"),
diff --git a/lintcheck/src/main.rs b/lintcheck/src/main.rs
index 54c1b80c42d..8385a4744ca 100644
--- a/lintcheck/src/main.rs
+++ b/lintcheck/src/main.rs
@@ -678,7 +678,7 @@ fn main() {
         .unwrap();
 
     let server = config.recursive.then(|| {
-        fs::remove_dir_all("target/lintcheck/shared_target_dir/recursive").unwrap_or_default();
+        let _ = fs::remove_dir_all("target/lintcheck/shared_target_dir/recursive");
 
         LintcheckServer::spawn(recursive_options)
     });
diff --git a/src/docs.rs b/src/docs.rs
index c033ad294a3..e9aa6e88097 100644
--- a/src/docs.rs
+++ b/src/docs.rs
@@ -247,7 +247,6 @@ docs! {
     "len_without_is_empty",
     "len_zero",
     "let_and_return",
-    "let_underscore_drop",
     "let_underscore_lock",
     "let_underscore_must_use",
     "let_unit_value",
diff --git a/src/docs/let_underscore_drop.txt b/src/docs/let_underscore_drop.txt
deleted file mode 100644
index 29ce9bf50ce..00000000000
--- a/src/docs/let_underscore_drop.txt
+++ /dev/null
@@ -1,29 +0,0 @@
-### What it does
-Checks for `let _ = <expr>`
-where expr has a type that implements `Drop`
-
-### Why is this bad?
-This statement immediately drops the initializer
-expression instead of extending its lifetime to the end of the scope, which
-is often not intended. To extend the expression's lifetime to the end of the
-scope, use an underscore-prefixed name instead (i.e. _var). If you want to
-explicitly drop the expression, `std::mem::drop` conveys your intention
-better and is less error-prone.
-
-### Example
-```
-{
-    let _ = DroppableItem;
-    //                   ^ dropped here
-    /* more code */
-}
-```
-
-Use instead:
-```
-{
-    let _droppable = DroppableItem;
-    /* more code */
-    // dropped at end of scope
-}
-```
\ No newline at end of file
diff --git a/tests/ui/let_underscore_drop.rs b/tests/ui/let_underscore_drop.rs
deleted file mode 100644
index 11b50492ab2..00000000000
--- a/tests/ui/let_underscore_drop.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-#![warn(clippy::let_underscore_drop)]
-#![allow(clippy::let_unit_value)]
-
-struct Droppable;
-
-impl Drop for Droppable {
-    fn drop(&mut self) {}
-}
-
-fn main() {
-    let unit = ();
-    let boxed = Box::new(());
-    let droppable = Droppable;
-    let optional = Some(Droppable);
-
-    let _ = ();
-    let _ = Box::new(());
-    let _ = Droppable;
-    let _ = Some(Droppable);
-
-    // no lint for reference
-    let _ = droppable_ref();
-}
-
-#[must_use]
-fn droppable_ref() -> &'static mut Droppable {
-    unimplemented!()
-}
diff --git a/tests/ui/let_underscore_drop.stderr b/tests/ui/let_underscore_drop.stderr
deleted file mode 100644
index 324b7cd431d..00000000000
--- a/tests/ui/let_underscore_drop.stderr
+++ /dev/null
@@ -1,27 +0,0 @@
-error: non-binding `let` on a type that implements `Drop`
-  --> $DIR/let_underscore_drop.rs:17:5
-   |
-LL |     let _ = Box::new(());
-   |     ^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: consider using an underscore-prefixed named binding or dropping explicitly with `std::mem::drop`
-   = note: `-D clippy::let-underscore-drop` implied by `-D warnings`
-
-error: non-binding `let` on a type that implements `Drop`
-  --> $DIR/let_underscore_drop.rs:18:5
-   |
-LL |     let _ = Droppable;
-   |     ^^^^^^^^^^^^^^^^^^
-   |
-   = help: consider using an underscore-prefixed named binding or dropping explicitly with `std::mem::drop`
-
-error: non-binding `let` on a type that implements `Drop`
-  --> $DIR/let_underscore_drop.rs:19:5
-   |
-LL |     let _ = Some(Droppable);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: consider using an underscore-prefixed named binding or dropping explicitly with `std::mem::drop`
-
-error: aborting due to 3 previous errors
-
diff --git a/tests/ui/map_flatten_fixable.fixed b/tests/ui/map_flatten_fixable.fixed
index 312819a0a2c..53628ef6531 100644
--- a/tests/ui/map_flatten_fixable.fixed
+++ b/tests/ui/map_flatten_fixable.fixed
@@ -1,7 +1,6 @@
 // run-rustfix
 
 #![warn(clippy::all, clippy::pedantic)]
-#![allow(clippy::let_underscore_drop)]
 #![allow(clippy::missing_docs_in_private_items)]
 #![allow(clippy::map_identity)]
 #![allow(clippy::redundant_closure)]
diff --git a/tests/ui/map_flatten_fixable.rs b/tests/ui/map_flatten_fixable.rs
index 3fbf4f9a1b0..76016c8ed3c 100644
--- a/tests/ui/map_flatten_fixable.rs
+++ b/tests/ui/map_flatten_fixable.rs
@@ -1,7 +1,6 @@
 // run-rustfix
 
 #![warn(clippy::all, clippy::pedantic)]
-#![allow(clippy::let_underscore_drop)]
 #![allow(clippy::missing_docs_in_private_items)]
 #![allow(clippy::map_identity)]
 #![allow(clippy::redundant_closure)]
diff --git a/tests/ui/map_flatten_fixable.stderr b/tests/ui/map_flatten_fixable.stderr
index c91f0b9ae94..b6b0c4d09c3 100644
--- a/tests/ui/map_flatten_fixable.stderr
+++ b/tests/ui/map_flatten_fixable.stderr
@@ -1,5 +1,5 @@
 error: called `map(..).flatten()` on `Iterator`
-  --> $DIR/map_flatten_fixable.rs:18:47
+  --> $DIR/map_flatten_fixable.rs:17:47
    |
 LL |     let _: Vec<_> = vec![5_i8; 6].into_iter().map(option_id).flatten().collect();
    |                                               ^^^^^^^^^^^^^^^^^^^^^^^^ help: try replacing `map` with `filter_map` and remove the `.flatten()`: `filter_map(option_id)`
@@ -7,43 +7,43 @@ LL |     let _: Vec<_> = vec![5_i8; 6].into_iter().map(option_id).flatten().coll
    = note: `-D clippy::map-flatten` implied by `-D warnings`
 
 error: called `map(..).flatten()` on `Iterator`
-  --> $DIR/map_flatten_fixable.rs:19:47
+  --> $DIR/map_flatten_fixable.rs:18:47
    |
 LL |     let _: Vec<_> = vec![5_i8; 6].into_iter().map(option_id_ref).flatten().collect();
    |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try replacing `map` with `filter_map` and remove the `.flatten()`: `filter_map(option_id_ref)`
 
 error: called `map(..).flatten()` on `Iterator`
-  --> $DIR/map_flatten_fixable.rs:20:47
+  --> $DIR/map_flatten_fixable.rs:19:47
    |
 LL |     let _: Vec<_> = vec![5_i8; 6].into_iter().map(option_id_closure).flatten().collect();
    |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try replacing `map` with `filter_map` and remove the `.flatten()`: `filter_map(option_id_closure)`
 
 error: called `map(..).flatten()` on `Iterator`
-  --> $DIR/map_flatten_fixable.rs:21:47
+  --> $DIR/map_flatten_fixable.rs:20:47
    |
 LL |     let _: Vec<_> = vec![5_i8; 6].into_iter().map(|x| x.checked_add(1)).flatten().collect();
    |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try replacing `map` with `filter_map` and remove the `.flatten()`: `filter_map(|x| x.checked_add(1))`
 
 error: called `map(..).flatten()` on `Iterator`
-  --> $DIR/map_flatten_fixable.rs:24:47
+  --> $DIR/map_flatten_fixable.rs:23:47
    |
 LL |     let _: Vec<_> = vec![5_i8; 6].into_iter().map(|x| 0..x).flatten().collect();
    |                                               ^^^^^^^^^^^^^^^^^^^^^^^ help: try replacing `map` with `flat_map` and remove the `.flatten()`: `flat_map(|x| 0..x)`
 
 error: called `map(..).flatten()` on `Option`
-  --> $DIR/map_flatten_fixable.rs:27:40
+  --> $DIR/map_flatten_fixable.rs:26:40
    |
 LL |     let _: Option<_> = (Some(Some(1))).map(|x| x).flatten();
    |                                        ^^^^^^^^^^^^^^^^^^^^ help: try replacing `map` with `and_then` and remove the `.flatten()`: `and_then(|x| x)`
 
 error: called `map(..).flatten()` on `Result`
-  --> $DIR/map_flatten_fixable.rs:30:42
+  --> $DIR/map_flatten_fixable.rs:29:42
    |
 LL |     let _: Result<_, &str> = (Ok(Ok(1))).map(|x| x).flatten();
    |                                          ^^^^^^^^^^^^^^^^^^^^ help: try replacing `map` with `and_then` and remove the `.flatten()`: `and_then(|x| x)`
 
 error: called `map(..).flatten()` on `Iterator`
-  --> $DIR/map_flatten_fixable.rs:39:10
+  --> $DIR/map_flatten_fixable.rs:38:10
    |
 LL |           .map(|n| match n {
    |  __________^
@@ -72,7 +72,7 @@ LL ~         });
    |
 
 error: called `map(..).flatten()` on `Option`
-  --> $DIR/map_flatten_fixable.rs:59:10
+  --> $DIR/map_flatten_fixable.rs:58:10
    |
 LL |           .map(|_| {
    |  __________^
diff --git a/tests/ui/rename.fixed b/tests/ui/rename.fixed
index 8beae8dee08..689928f0479 100644
--- a/tests/ui/rename.fixed
+++ b/tests/ui/rename.fixed
@@ -12,7 +12,6 @@
 #![allow(clippy::disallowed_methods)]
 #![allow(clippy::disallowed_types)]
 #![allow(clippy::mixed_read_write_in_expression)]
-#![allow(for_loops_over_fallibles)]
 #![allow(clippy::useless_conversion)]
 #![allow(clippy::match_result_ok)]
 #![allow(clippy::overly_complex_bool_expr)]
@@ -27,9 +26,11 @@
 #![allow(clippy::recursive_format_impl)]
 #![allow(clippy::invisible_characters)]
 #![allow(drop_bounds)]
+#![allow(for_loops_over_fallibles)]
 #![allow(array_into_iter)]
 #![allow(invalid_atomic_ordering)]
 #![allow(invalid_value)]
+#![allow(let_underscore_drop)]
 #![allow(enum_intrinsics_non_enums)]
 #![allow(non_fmt_panics)]
 #![allow(named_arguments_used_positionally)]
@@ -45,8 +46,6 @@
 #![warn(clippy::disallowed_methods)]
 #![warn(clippy::disallowed_types)]
 #![warn(clippy::mixed_read_write_in_expression)]
-#![warn(for_loops_over_fallibles)]
-#![warn(for_loops_over_fallibles)]
 #![warn(clippy::useless_conversion)]
 #![warn(clippy::match_result_ok)]
 #![warn(clippy::overly_complex_bool_expr)]
@@ -66,9 +65,12 @@
 #![warn(clippy::invisible_characters)]
 #![warn(drop_bounds)]
 #![warn(for_loops_over_fallibles)]
+#![warn(for_loops_over_fallibles)]
+#![warn(for_loops_over_fallibles)]
 #![warn(array_into_iter)]
 #![warn(invalid_atomic_ordering)]
 #![warn(invalid_value)]
+#![warn(let_underscore_drop)]
 #![warn(enum_intrinsics_non_enums)]
 #![warn(non_fmt_panics)]
 #![warn(named_arguments_used_positionally)]
diff --git a/tests/ui/rename.rs b/tests/ui/rename.rs
index 9e665047baa..b74aa650ffd 100644
--- a/tests/ui/rename.rs
+++ b/tests/ui/rename.rs
@@ -12,7 +12,6 @@
 #![allow(clippy::disallowed_methods)]
 #![allow(clippy::disallowed_types)]
 #![allow(clippy::mixed_read_write_in_expression)]
-#![allow(for_loops_over_fallibles)]
 #![allow(clippy::useless_conversion)]
 #![allow(clippy::match_result_ok)]
 #![allow(clippy::overly_complex_bool_expr)]
@@ -27,9 +26,11 @@
 #![allow(clippy::recursive_format_impl)]
 #![allow(clippy::invisible_characters)]
 #![allow(drop_bounds)]
+#![allow(for_loops_over_fallibles)]
 #![allow(array_into_iter)]
 #![allow(invalid_atomic_ordering)]
 #![allow(invalid_value)]
+#![allow(let_underscore_drop)]
 #![allow(enum_intrinsics_non_enums)]
 #![allow(non_fmt_panics)]
 #![allow(named_arguments_used_positionally)]
@@ -45,8 +46,6 @@
 #![warn(clippy::disallowed_method)]
 #![warn(clippy::disallowed_type)]
 #![warn(clippy::eval_order_dependence)]
-#![warn(clippy::for_loop_over_option)]
-#![warn(clippy::for_loop_over_result)]
 #![warn(clippy::identity_conversion)]
 #![warn(clippy::if_let_some_result)]
 #![warn(clippy::logic_bug)]
@@ -65,10 +64,13 @@
 #![warn(clippy::to_string_in_display)]
 #![warn(clippy::zero_width_space)]
 #![warn(clippy::drop_bounds)]
+#![warn(clippy::for_loop_over_option)]
+#![warn(clippy::for_loop_over_result)]
 #![warn(clippy::for_loops_over_fallibles)]
 #![warn(clippy::into_iter_on_array)]
 #![warn(clippy::invalid_atomic_ordering)]
 #![warn(clippy::invalid_ref)]
+#![warn(clippy::let_underscore_drop)]
 #![warn(clippy::mem_discriminant_non_enum)]
 #![warn(clippy::panic_params)]
 #![warn(clippy::positional_named_format_parameters)]
diff --git a/tests/ui/rename.stderr b/tests/ui/rename.stderr
index 63eb565185f..622a32c5908 100644
--- a/tests/ui/rename.stderr
+++ b/tests/ui/rename.stderr
@@ -1,5 +1,5 @@
 error: lint `clippy::blacklisted_name` has been renamed to `clippy::disallowed_names`
-  --> $DIR/rename.rs:39:9
+  --> $DIR/rename.rs:40:9
    |
 LL | #![warn(clippy::blacklisted_name)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::disallowed_names`
@@ -7,232 +7,238 @@ LL | #![warn(clippy::blacklisted_name)]
    = note: `-D renamed-and-removed-lints` implied by `-D warnings`
 
 error: lint `clippy::block_in_if_condition_expr` has been renamed to `clippy::blocks_in_if_conditions`
-  --> $DIR/rename.rs:40:9
+  --> $DIR/rename.rs:41:9
    |
 LL | #![warn(clippy::block_in_if_condition_expr)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::blocks_in_if_conditions`
 
 error: lint `clippy::block_in_if_condition_stmt` has been renamed to `clippy::blocks_in_if_conditions`
-  --> $DIR/rename.rs:41:9
+  --> $DIR/rename.rs:42:9
    |
 LL | #![warn(clippy::block_in_if_condition_stmt)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::blocks_in_if_conditions`
 
 error: lint `clippy::box_vec` has been renamed to `clippy::box_collection`
-  --> $DIR/rename.rs:42:9
+  --> $DIR/rename.rs:43:9
    |
 LL | #![warn(clippy::box_vec)]
    |         ^^^^^^^^^^^^^^^ help: use the new name: `clippy::box_collection`
 
 error: lint `clippy::const_static_lifetime` has been renamed to `clippy::redundant_static_lifetimes`
-  --> $DIR/rename.rs:43:9
+  --> $DIR/rename.rs:44:9
    |
 LL | #![warn(clippy::const_static_lifetime)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::redundant_static_lifetimes`
 
 error: lint `clippy::cyclomatic_complexity` has been renamed to `clippy::cognitive_complexity`
-  --> $DIR/rename.rs:44:9
+  --> $DIR/rename.rs:45:9
    |
 LL | #![warn(clippy::cyclomatic_complexity)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::cognitive_complexity`
 
 error: lint `clippy::disallowed_method` has been renamed to `clippy::disallowed_methods`
-  --> $DIR/rename.rs:45:9
+  --> $DIR/rename.rs:46:9
    |
 LL | #![warn(clippy::disallowed_method)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::disallowed_methods`
 
 error: lint `clippy::disallowed_type` has been renamed to `clippy::disallowed_types`
-  --> $DIR/rename.rs:46:9
+  --> $DIR/rename.rs:47:9
    |
 LL | #![warn(clippy::disallowed_type)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::disallowed_types`
 
 error: lint `clippy::eval_order_dependence` has been renamed to `clippy::mixed_read_write_in_expression`
-  --> $DIR/rename.rs:47:9
+  --> $DIR/rename.rs:48:9
    |
 LL | #![warn(clippy::eval_order_dependence)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::mixed_read_write_in_expression`
 
-error: lint `clippy::for_loop_over_option` has been renamed to `for_loops_over_fallibles`
-  --> $DIR/rename.rs:48:9
-   |
-LL | #![warn(clippy::for_loop_over_option)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `for_loops_over_fallibles`
-
-error: lint `clippy::for_loop_over_result` has been renamed to `for_loops_over_fallibles`
-  --> $DIR/rename.rs:49:9
-   |
-LL | #![warn(clippy::for_loop_over_result)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `for_loops_over_fallibles`
-
 error: lint `clippy::identity_conversion` has been renamed to `clippy::useless_conversion`
-  --> $DIR/rename.rs:50:9
+  --> $DIR/rename.rs:49:9
    |
 LL | #![warn(clippy::identity_conversion)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::useless_conversion`
 
 error: lint `clippy::if_let_some_result` has been renamed to `clippy::match_result_ok`
-  --> $DIR/rename.rs:51:9
+  --> $DIR/rename.rs:50:9
    |
 LL | #![warn(clippy::if_let_some_result)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::match_result_ok`
 
 error: lint `clippy::logic_bug` has been renamed to `clippy::overly_complex_bool_expr`
-  --> $DIR/rename.rs:52:9
+  --> $DIR/rename.rs:51:9
    |
 LL | #![warn(clippy::logic_bug)]
    |         ^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::overly_complex_bool_expr`
 
 error: lint `clippy::new_without_default_derive` has been renamed to `clippy::new_without_default`
-  --> $DIR/rename.rs:53:9
+  --> $DIR/rename.rs:52:9
    |
 LL | #![warn(clippy::new_without_default_derive)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::new_without_default`
 
 error: lint `clippy::option_and_then_some` has been renamed to `clippy::bind_instead_of_map`
-  --> $DIR/rename.rs:54:9
+  --> $DIR/rename.rs:53:9
    |
 LL | #![warn(clippy::option_and_then_some)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::bind_instead_of_map`
 
 error: lint `clippy::option_expect_used` has been renamed to `clippy::expect_used`
-  --> $DIR/rename.rs:55:9
+  --> $DIR/rename.rs:54:9
    |
 LL | #![warn(clippy::option_expect_used)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::expect_used`
 
 error: lint `clippy::option_map_unwrap_or` has been renamed to `clippy::map_unwrap_or`
-  --> $DIR/rename.rs:56:9
+  --> $DIR/rename.rs:55:9
    |
 LL | #![warn(clippy::option_map_unwrap_or)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::map_unwrap_or`
 
 error: lint `clippy::option_map_unwrap_or_else` has been renamed to `clippy::map_unwrap_or`
-  --> $DIR/rename.rs:57:9
+  --> $DIR/rename.rs:56:9
    |
 LL | #![warn(clippy::option_map_unwrap_or_else)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::map_unwrap_or`
 
 error: lint `clippy::option_unwrap_used` has been renamed to `clippy::unwrap_used`
-  --> $DIR/rename.rs:58:9
+  --> $DIR/rename.rs:57:9
    |
 LL | #![warn(clippy::option_unwrap_used)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::unwrap_used`
 
 error: lint `clippy::ref_in_deref` has been renamed to `clippy::needless_borrow`
-  --> $DIR/rename.rs:59:9
+  --> $DIR/rename.rs:58:9
    |
 LL | #![warn(clippy::ref_in_deref)]
    |         ^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::needless_borrow`
 
 error: lint `clippy::result_expect_used` has been renamed to `clippy::expect_used`
-  --> $DIR/rename.rs:60:9
+  --> $DIR/rename.rs:59:9
    |
 LL | #![warn(clippy::result_expect_used)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::expect_used`
 
 error: lint `clippy::result_map_unwrap_or_else` has been renamed to `clippy::map_unwrap_or`
-  --> $DIR/rename.rs:61:9
+  --> $DIR/rename.rs:60:9
    |
 LL | #![warn(clippy::result_map_unwrap_or_else)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::map_unwrap_or`
 
 error: lint `clippy::result_unwrap_used` has been renamed to `clippy::unwrap_used`
-  --> $DIR/rename.rs:62:9
+  --> $DIR/rename.rs:61:9
    |
 LL | #![warn(clippy::result_unwrap_used)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::unwrap_used`
 
 error: lint `clippy::single_char_push_str` has been renamed to `clippy::single_char_add_str`
-  --> $DIR/rename.rs:63:9
+  --> $DIR/rename.rs:62:9
    |
 LL | #![warn(clippy::single_char_push_str)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::single_char_add_str`
 
 error: lint `clippy::stutter` has been renamed to `clippy::module_name_repetitions`
-  --> $DIR/rename.rs:64:9
+  --> $DIR/rename.rs:63:9
    |
 LL | #![warn(clippy::stutter)]
    |         ^^^^^^^^^^^^^^^ help: use the new name: `clippy::module_name_repetitions`
 
 error: lint `clippy::to_string_in_display` has been renamed to `clippy::recursive_format_impl`
-  --> $DIR/rename.rs:65:9
+  --> $DIR/rename.rs:64:9
    |
 LL | #![warn(clippy::to_string_in_display)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::recursive_format_impl`
 
 error: lint `clippy::zero_width_space` has been renamed to `clippy::invisible_characters`
-  --> $DIR/rename.rs:66:9
+  --> $DIR/rename.rs:65:9
    |
 LL | #![warn(clippy::zero_width_space)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::invisible_characters`
 
 error: lint `clippy::drop_bounds` has been renamed to `drop_bounds`
-  --> $DIR/rename.rs:67:9
+  --> $DIR/rename.rs:66:9
    |
 LL | #![warn(clippy::drop_bounds)]
    |         ^^^^^^^^^^^^^^^^^^^ help: use the new name: `drop_bounds`
 
-error: lint `clippy::for_loops_over_fallibles` has been renamed to `for_loops_over_fallibles`
+error: lint `clippy::for_loop_over_option` has been renamed to `for_loops_over_fallibles`
+  --> $DIR/rename.rs:67:9
+   |
+LL | #![warn(clippy::for_loop_over_option)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `for_loops_over_fallibles`
+
+error: lint `clippy::for_loop_over_result` has been renamed to `for_loops_over_fallibles`
   --> $DIR/rename.rs:68:9
    |
+LL | #![warn(clippy::for_loop_over_result)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `for_loops_over_fallibles`
+
+error: lint `clippy::for_loops_over_fallibles` has been renamed to `for_loops_over_fallibles`
+  --> $DIR/rename.rs:69:9
+   |
 LL | #![warn(clippy::for_loops_over_fallibles)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `for_loops_over_fallibles`
 
 error: lint `clippy::into_iter_on_array` has been renamed to `array_into_iter`
-  --> $DIR/rename.rs:69:9
+  --> $DIR/rename.rs:70:9
    |
 LL | #![warn(clippy::into_iter_on_array)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `array_into_iter`
 
 error: lint `clippy::invalid_atomic_ordering` has been renamed to `invalid_atomic_ordering`
-  --> $DIR/rename.rs:70:9
+  --> $DIR/rename.rs:71:9
    |
 LL | #![warn(clippy::invalid_atomic_ordering)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `invalid_atomic_ordering`
 
 error: lint `clippy::invalid_ref` has been renamed to `invalid_value`
-  --> $DIR/rename.rs:71:9
+  --> $DIR/rename.rs:72:9
    |
 LL | #![warn(clippy::invalid_ref)]
    |         ^^^^^^^^^^^^^^^^^^^ help: use the new name: `invalid_value`
 
+error: lint `clippy::let_underscore_drop` has been renamed to `let_underscore_drop`
+  --> $DIR/rename.rs:73:9
+   |
+LL | #![warn(clippy::let_underscore_drop)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `let_underscore_drop`
+
 error: lint `clippy::mem_discriminant_non_enum` has been renamed to `enum_intrinsics_non_enums`
-  --> $DIR/rename.rs:72:9
+  --> $DIR/rename.rs:74:9
    |
 LL | #![warn(clippy::mem_discriminant_non_enum)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `enum_intrinsics_non_enums`
 
 error: lint `clippy::panic_params` has been renamed to `non_fmt_panics`
-  --> $DIR/rename.rs:73:9
+  --> $DIR/rename.rs:75:9
    |
 LL | #![warn(clippy::panic_params)]
    |         ^^^^^^^^^^^^^^^^^^^^ help: use the new name: `non_fmt_panics`
 
 error: lint `clippy::positional_named_format_parameters` has been renamed to `named_arguments_used_positionally`
-  --> $DIR/rename.rs:74:9
+  --> $DIR/rename.rs:76:9
    |
 LL | #![warn(clippy::positional_named_format_parameters)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `named_arguments_used_positionally`
 
 error: lint `clippy::temporary_cstring_as_ptr` has been renamed to `temporary_cstring_as_ptr`
-  --> $DIR/rename.rs:75:9
+  --> $DIR/rename.rs:77:9
    |
 LL | #![warn(clippy::temporary_cstring_as_ptr)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `temporary_cstring_as_ptr`
 
 error: lint `clippy::unknown_clippy_lints` has been renamed to `unknown_lints`
-  --> $DIR/rename.rs:76:9
+  --> $DIR/rename.rs:78:9
    |
 LL | #![warn(clippy::unknown_clippy_lints)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `unknown_lints`
 
 error: lint `clippy::unused_label` has been renamed to `unused_labels`
-  --> $DIR/rename.rs:77:9
+  --> $DIR/rename.rs:79:9
    |
 LL | #![warn(clippy::unused_label)]
    |         ^^^^^^^^^^^^^^^^^^^^ help: use the new name: `unused_labels`
 
-error: aborting due to 39 previous errors
+error: aborting due to 40 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 9306540f611c322178695efa7b1be8d14e6372dd Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Sun, 23 Oct 2022 14:04:50 +0000
Subject: Remove overlap between rustc and clippy `let_underscore_lock` lint

---
 clippy_lints/src/let_underscore.rs  | 18 ++++--------
 src/docs/let_underscore_lock.txt    |  5 ++--
 tests/ui/let_underscore_lock.rs     | 31 +++++++++++---------
 tests/ui/let_underscore_lock.stderr | 58 ++++---------------------------------
 4 files changed, 30 insertions(+), 82 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/let_underscore.rs b/clippy_lints/src/let_underscore.rs
index 448688a3028..cfc1a21ea87 100644
--- a/clippy_lints/src/let_underscore.rs
+++ b/clippy_lints/src/let_underscore.rs
@@ -1,12 +1,11 @@
 use clippy_utils::diagnostics::span_lint_and_help;
-use clippy_utils::ty::{is_must_use_ty, is_type_diagnostic_item, match_type};
+use clippy_utils::ty::{is_must_use_ty, match_type};
 use clippy_utils::{is_must_use_func_call, paths};
 use rustc_hir::{Local, PatKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::subst::GenericArgKind;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::{sym, Symbol};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -34,8 +33,9 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for `let _ = sync_lock`.
-    /// This supports `mutex` and `rwlock` in `std::sync` and `parking_lot`.
+    /// Checks for `let _ = sync_lock`. This supports `mutex` and `rwlock` in
+    /// `parking_lot`. For `std` locks see the `rustc` lint
+    /// [`let_underscore_lock`](https://doc.rust-lang.org/nightly/rustc/lints/listing/deny-by-default.html#let-underscore-lock)
     ///
     /// ### Why is this bad?
     /// This statement immediately drops the lock instead of
@@ -61,8 +61,6 @@ declare_clippy_lint! {
 
 declare_lint_pass!(LetUnderscore => [LET_UNDERSCORE_MUST_USE, LET_UNDERSCORE_LOCK]);
 
-const SYNC_GUARD_SYMS: [Symbol; 3] = [sym::MutexGuard, sym::RwLockReadGuard, sym::RwLockWriteGuard];
-
 const SYNC_GUARD_PATHS: [&[&str]; 3] = [
     &paths::PARKING_LOT_MUTEX_GUARD,
     &paths::PARKING_LOT_RWLOCK_READ_GUARD,
@@ -77,13 +75,7 @@ impl<'tcx> LateLintPass<'tcx> for LetUnderscore {
         {
             let init_ty = cx.typeck_results().expr_ty(init);
             let contains_sync_guard = init_ty.walk().any(|inner| match inner.unpack() {
-                GenericArgKind::Type(inner_ty) => {
-                    SYNC_GUARD_SYMS
-                        .iter()
-                        .any(|&sym| is_type_diagnostic_item(cx, inner_ty, sym))
-                        || SYNC_GUARD_PATHS.iter().any(|path| match_type(cx, inner_ty, path))
-                },
-
+                GenericArgKind::Type(inner_ty) => SYNC_GUARD_PATHS.iter().any(|path| match_type(cx, inner_ty, path)),
                 GenericArgKind::Lifetime(_) | GenericArgKind::Const(_) => false,
             });
             if contains_sync_guard {
diff --git a/src/docs/let_underscore_lock.txt b/src/docs/let_underscore_lock.txt
index bd8217fb58b..88394a0a267 100644
--- a/src/docs/let_underscore_lock.txt
+++ b/src/docs/let_underscore_lock.txt
@@ -1,6 +1,7 @@
 ### What it does
-Checks for `let _ = sync_lock`.
-This supports `mutex` and `rwlock` in `std::sync` and `parking_lot`.
+Checks for `let _ = sync_lock`. This supports `mutex` and `rwlock` in
+`parking_lot`. For `std` locks see the `rustc` lint
+[`let_underscore_lock`](https://doc.rust-lang.org/nightly/rustc/lints/listing/deny-by-default.html#let-underscore-lock)
 
 ### Why is this bad?
 This statement immediately drops the lock instead of
diff --git a/tests/ui/let_underscore_lock.rs b/tests/ui/let_underscore_lock.rs
index 7a7c4e92499..4dff4d766bc 100644
--- a/tests/ui/let_underscore_lock.rs
+++ b/tests/ui/let_underscore_lock.rs
@@ -3,20 +3,6 @@
 extern crate parking_lot;
 
 fn main() {
-    let m = std::sync::Mutex::new(());
-    let rw = std::sync::RwLock::new(());
-
-    let _ = m.lock();
-    let _ = rw.read();
-    let _ = rw.write();
-    let _ = m.try_lock();
-    let _ = rw.try_read();
-    let _ = rw.try_write();
-
-    // These shouldn't throw an error.
-    let _ = m;
-    let _ = rw;
-
     use parking_lot::{lock_api::RawMutex, Mutex, RwLock};
 
     let p_m: Mutex<()> = Mutex::const_new(RawMutex::INIT, ());
@@ -34,3 +20,20 @@ fn main() {
     let _ = p_m1;
     let _ = p_rw;
 }
+
+fn uplifted() {
+    // shouldn't lint std locks as they were uplifted as rustc's `let_underscore_lock`
+
+    let m = std::sync::Mutex::new(());
+    let rw = std::sync::RwLock::new(());
+
+    let _ = m.lock();
+    let _ = rw.read();
+    let _ = rw.write();
+    let _ = m.try_lock();
+    let _ = rw.try_read();
+    let _ = rw.try_write();
+
+    let _ = m;
+    let _ = rw;
+}
diff --git a/tests/ui/let_underscore_lock.stderr b/tests/ui/let_underscore_lock.stderr
index d7779e7b6c4..89350b92e82 100644
--- a/tests/ui/let_underscore_lock.stderr
+++ b/tests/ui/let_underscore_lock.stderr
@@ -1,62 +1,14 @@
 error: non-binding let on a synchronization lock
   --> $DIR/let_underscore_lock.rs:9:5
    |
-LL |     let _ = m.lock();
-   |     ^^^^^^^^^^^^^^^^^
-   |
-   = help: consider using an underscore-prefixed named binding or dropping explicitly with `std::mem::drop`
-   = note: `-D clippy::let-underscore-lock` implied by `-D warnings`
-
-error: non-binding let on a synchronization lock
-  --> $DIR/let_underscore_lock.rs:10:5
-   |
-LL |     let _ = rw.read();
-   |     ^^^^^^^^^^^^^^^^^^
-   |
-   = help: consider using an underscore-prefixed named binding or dropping explicitly with `std::mem::drop`
-
-error: non-binding let on a synchronization lock
-  --> $DIR/let_underscore_lock.rs:11:5
-   |
-LL |     let _ = rw.write();
-   |     ^^^^^^^^^^^^^^^^^^^
-   |
-   = help: consider using an underscore-prefixed named binding or dropping explicitly with `std::mem::drop`
-
-error: non-binding let on a synchronization lock
-  --> $DIR/let_underscore_lock.rs:12:5
-   |
-LL |     let _ = m.try_lock();
-   |     ^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: consider using an underscore-prefixed named binding or dropping explicitly with `std::mem::drop`
-
-error: non-binding let on a synchronization lock
-  --> $DIR/let_underscore_lock.rs:13:5
-   |
-LL |     let _ = rw.try_read();
-   |     ^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: consider using an underscore-prefixed named binding or dropping explicitly with `std::mem::drop`
-
-error: non-binding let on a synchronization lock
-  --> $DIR/let_underscore_lock.rs:14:5
-   |
-LL |     let _ = rw.try_write();
-   |     ^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: consider using an underscore-prefixed named binding or dropping explicitly with `std::mem::drop`
-
-error: non-binding let on a synchronization lock
-  --> $DIR/let_underscore_lock.rs:23:5
-   |
 LL |     let _ = p_m.lock();
    |     ^^^^^^^^^^^^^^^^^^^
    |
    = help: consider using an underscore-prefixed named binding or dropping explicitly with `std::mem::drop`
+   = note: `-D clippy::let-underscore-lock` implied by `-D warnings`
 
 error: non-binding let on a synchronization lock
-  --> $DIR/let_underscore_lock.rs:26:5
+  --> $DIR/let_underscore_lock.rs:12:5
    |
 LL |     let _ = p_m1.lock();
    |     ^^^^^^^^^^^^^^^^^^^^
@@ -64,7 +16,7 @@ LL |     let _ = p_m1.lock();
    = help: consider using an underscore-prefixed named binding or dropping explicitly with `std::mem::drop`
 
 error: non-binding let on a synchronization lock
-  --> $DIR/let_underscore_lock.rs:29:5
+  --> $DIR/let_underscore_lock.rs:15:5
    |
 LL |     let _ = p_rw.read();
    |     ^^^^^^^^^^^^^^^^^^^^
@@ -72,12 +24,12 @@ LL |     let _ = p_rw.read();
    = help: consider using an underscore-prefixed named binding or dropping explicitly with `std::mem::drop`
 
 error: non-binding let on a synchronization lock
-  --> $DIR/let_underscore_lock.rs:30:5
+  --> $DIR/let_underscore_lock.rs:16:5
    |
 LL |     let _ = p_rw.write();
    |     ^^^^^^^^^^^^^^^^^^^^^
    |
    = help: consider using an underscore-prefixed named binding or dropping explicitly with `std::mem::drop`
 
-error: aborting due to 10 previous errors
+error: aborting due to 4 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From a41cb7adbeaa1dae9cf5f371bc02061c63caaf81 Mon Sep 17 00:00:00 2001
From: koka <koka.code@gmail.com>
Date: Sat, 22 Oct 2022 16:36:36 +0900
Subject: fix: support `map_or` for `or_fun_call` lint

* add `rest_arg` to pass second argument from `map_or(U, F)`
* extract some procedures into closure

refac: rename rest_arg/second_arg

refac: organize function argument order

* put `second_arg` next to `arg` argument
---
 clippy_lints/src/methods/or_fun_call.rs | 57 ++++++++++++++++++++++++---------
 tests/ui/manual_ok_or.fixed             |  1 +
 tests/ui/manual_ok_or.rs                |  1 +
 tests/ui/manual_ok_or.stderr            |  8 ++---
 tests/ui/or_fun_call.fixed              | 16 +++++++++
 tests/ui/or_fun_call.rs                 | 16 +++++++++
 tests/ui/or_fun_call.stderr             | 14 +++++++-
 7 files changed, 92 insertions(+), 21 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/or_fun_call.rs b/clippy_lints/src/methods/or_fun_call.rs
index 991d3dd538b..4460f38fcc1 100644
--- a/clippy_lints/src/methods/or_fun_call.rs
+++ b/clippy_lints/src/methods/or_fun_call.rs
@@ -83,6 +83,8 @@ pub(super) fn check<'tcx>(
         method_span: Span,
         self_expr: &hir::Expr<'_>,
         arg: &'tcx hir::Expr<'_>,
+        // `Some` if fn has second argument
+        second_arg: Option<&hir::Expr<'_>>,
         span: Span,
         // None if lambda is required
         fun_span: Option<Span>,
@@ -109,30 +111,40 @@ pub(super) fn check<'tcx>(
             if poss.contains(&name);
 
             then {
-                let macro_expanded_snipped;
-                let sugg: Cow<'_, str> = {
+                let sugg = {
                     let (snippet_span, use_lambda) = match (fn_has_arguments, fun_span) {
                         (false, Some(fun_span)) => (fun_span, false),
                         _ => (arg.span, true),
                     };
-                    let snippet = {
-                        let not_macro_argument_snippet = snippet_with_macro_callsite(cx, snippet_span, "..");
-                        if not_macro_argument_snippet == "vec![]" {
-                            macro_expanded_snipped = snippet(cx, snippet_span, "..");
+
+                    let format_span = |span: Span| {
+                        let not_macro_argument_snippet = snippet_with_macro_callsite(cx, span, "..");
+                        let snip = if not_macro_argument_snippet == "vec![]" {
+                            let macro_expanded_snipped = snippet(cx, snippet_span, "..");
                             match macro_expanded_snipped.strip_prefix("$crate::vec::") {
-                                Some(stripped) => Cow::from(stripped),
+                                Some(stripped) => Cow::Owned(stripped.to_owned()),
                                 None => macro_expanded_snipped,
                             }
                         } else {
                             not_macro_argument_snippet
-                        }
+                        };
+
+                        snip.to_string()
                     };
 
-                    if use_lambda {
+                    let snip = format_span(snippet_span);
+                    let snip = if use_lambda {
                         let l_arg = if fn_has_arguments { "_" } else { "" };
-                        format!("|{l_arg}| {snippet}").into()
+                        format!("|{l_arg}| {snip}")
                     } else {
-                        snippet
+                        snip
+                    };
+
+                    if let Some(f) = second_arg {
+                        let f = format_span(f.span);
+                        format!("{snip}, {f}")
+                    } else {
+                        snip
                     }
                 };
                 let span_replace_word = method_span.with_hi(span.hi());
@@ -149,8 +161,8 @@ pub(super) fn check<'tcx>(
         }
     }
 
-    if let [arg] = args {
-        let inner_arg = if let hir::ExprKind::Block(
+    let extract_inner_arg = |arg: &'tcx hir::Expr<'_>| {
+        if let hir::ExprKind::Block(
             hir::Block {
                 stmts: [],
                 expr: Some(expr),
@@ -162,19 +174,32 @@ pub(super) fn check<'tcx>(
             expr
         } else {
             arg
-        };
+        }
+    };
+
+    if let [arg] = args {
+        let inner_arg = extract_inner_arg(arg);
         match inner_arg.kind {
             hir::ExprKind::Call(fun, or_args) => {
                 let or_has_args = !or_args.is_empty();
                 if !check_unwrap_or_default(cx, name, fun, arg, or_has_args, expr.span, method_span) {
                     let fun_span = if or_has_args { None } else { Some(fun.span) };
-                    check_general_case(cx, name, method_span, receiver, arg, expr.span, fun_span);
+                    check_general_case(cx, name, method_span, receiver, arg, None, expr.span, fun_span);
                 }
             },
             hir::ExprKind::Index(..) | hir::ExprKind::MethodCall(..) => {
-                check_general_case(cx, name, method_span, receiver, arg, expr.span, None);
+                check_general_case(cx, name, method_span, receiver, arg, None, expr.span, None);
             },
             _ => (),
         }
     }
+
+    // `map_or` takes two arguments
+    if let [arg, lambda] = args {
+        let inner_arg = extract_inner_arg(arg);
+        if let hir::ExprKind::Call(fun, or_args) = inner_arg.kind {
+            let fun_span = if or_args.is_empty() { Some(fun.span) } else { None };
+            check_general_case(cx, name, method_span, receiver, arg, Some(lambda), expr.span, fun_span);
+        }
+    }
 }
diff --git a/tests/ui/manual_ok_or.fixed b/tests/ui/manual_ok_or.fixed
index d864f855453..fc8511626b3 100644
--- a/tests/ui/manual_ok_or.fixed
+++ b/tests/ui/manual_ok_or.fixed
@@ -1,5 +1,6 @@
 // run-rustfix
 #![warn(clippy::manual_ok_or)]
+#![allow(clippy::or_fun_call)]
 #![allow(clippy::disallowed_names)]
 #![allow(clippy::redundant_closure)]
 #![allow(dead_code)]
diff --git a/tests/ui/manual_ok_or.rs b/tests/ui/manual_ok_or.rs
index 6264768460e..b5303d33f5f 100644
--- a/tests/ui/manual_ok_or.rs
+++ b/tests/ui/manual_ok_or.rs
@@ -1,5 +1,6 @@
 // run-rustfix
 #![warn(clippy::manual_ok_or)]
+#![allow(clippy::or_fun_call)]
 #![allow(clippy::disallowed_names)]
 #![allow(clippy::redundant_closure)]
 #![allow(dead_code)]
diff --git a/tests/ui/manual_ok_or.stderr b/tests/ui/manual_ok_or.stderr
index 65459a09738..b4a17f143e3 100644
--- a/tests/ui/manual_ok_or.stderr
+++ b/tests/ui/manual_ok_or.stderr
@@ -1,5 +1,5 @@
 error: this pattern reimplements `Option::ok_or`
-  --> $DIR/manual_ok_or.rs:11:5
+  --> $DIR/manual_ok_or.rs:12:5
    |
 LL |     foo.map_or(Err("error"), |v| Ok(v));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `foo.ok_or("error")`
@@ -7,19 +7,19 @@ LL |     foo.map_or(Err("error"), |v| Ok(v));
    = note: `-D clippy::manual-ok-or` implied by `-D warnings`
 
 error: this pattern reimplements `Option::ok_or`
-  --> $DIR/manual_ok_or.rs:14:5
+  --> $DIR/manual_ok_or.rs:15:5
    |
 LL |     foo.map_or(Err("error"), Ok);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `foo.ok_or("error")`
 
 error: this pattern reimplements `Option::ok_or`
-  --> $DIR/manual_ok_or.rs:17:5
+  --> $DIR/manual_ok_or.rs:18:5
    |
 LL |     None::<i32>.map_or(Err("error"), |v| Ok(v));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `None::<i32>.ok_or("error")`
 
 error: this pattern reimplements `Option::ok_or`
-  --> $DIR/manual_ok_or.rs:21:5
+  --> $DIR/manual_ok_or.rs:22:5
    |
 LL | /     foo.map_or(Err::<i32, &str>(
 LL | |         &format!(
diff --git a/tests/ui/or_fun_call.fixed b/tests/ui/or_fun_call.fixed
index 23b1aa8bebd..be9a65506e1 100644
--- a/tests/ui/or_fun_call.fixed
+++ b/tests/ui/or_fun_call.fixed
@@ -236,4 +236,20 @@ mod issue9608 {
     }
 }
 
+mod issue8993 {
+    fn g() -> i32 {
+        3
+    }
+
+    fn f(n: i32) -> i32 {
+        n
+    }
+
+    fn test_map_or() {
+        let _ = Some(4).map_or_else(g, |v| v);
+        let _ = Some(4).map_or_else(g, f);
+        let _ = Some(4).map_or(0, f);
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/or_fun_call.rs b/tests/ui/or_fun_call.rs
index 039998f22dd..628c9704638 100644
--- a/tests/ui/or_fun_call.rs
+++ b/tests/ui/or_fun_call.rs
@@ -236,4 +236,20 @@ mod issue9608 {
     }
 }
 
+mod issue8993 {
+    fn g() -> i32 {
+        3
+    }
+
+    fn f(n: i32) -> i32 {
+        n
+    }
+
+    fn test_map_or() {
+        let _ = Some(4).map_or(g(), |v| v);
+        let _ = Some(4).map_or(g(), f);
+        let _ = Some(4).map_or(0, f);
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/or_fun_call.stderr b/tests/ui/or_fun_call.stderr
index 113ba150c61..ba3001db7a5 100644
--- a/tests/ui/or_fun_call.stderr
+++ b/tests/ui/or_fun_call.stderr
@@ -156,5 +156,17 @@ error: use of `unwrap_or` followed by a call to `new`
 LL |         .unwrap_or(String::new());
    |          ^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_default()`
 
-error: aborting due to 26 previous errors
+error: use of `map_or` followed by a function call
+  --> $DIR/or_fun_call.rs:249:25
+   |
+LL |         let _ = Some(4).map_or(g(), |v| v);
+   |                         ^^^^^^^^^^^^^^^^^^ help: try this: `map_or_else(g, |v| v)`
+
+error: use of `map_or` followed by a function call
+  --> $DIR/or_fun_call.rs:250:25
+   |
+LL |         let _ = Some(4).map_or(g(), f);
+   |                         ^^^^^^^^^^^^^^ help: try this: `map_or_else(g, f)`
+
+error: aborting due to 28 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From b083a39190721829a72779021011da8483dc0df8 Mon Sep 17 00:00:00 2001
From: royrustdev <royrustdev@gmail.com>
Date: Sat, 22 Oct 2022 15:33:12 +0530
Subject: add `boxed_void` lint

---
 CHANGELOG.md                                |  1 +
 clippy_lints/src/from_raw_with_void_ptr.rs  | 57 +++++++++++++++++++++++++++++
 clippy_lints/src/lib.register_all.rs        |  1 +
 clippy_lints/src/lib.register_lints.rs      |  1 +
 clippy_lints/src/lib.register_suspicious.rs |  1 +
 clippy_lints/src/lib.rs                     |  2 +
 src/docs.rs                                 |  1 +
 src/docs/from_raw_with_void_ptr.txt         | 22 +++++++++++
 tests/ui/from_raw_with_void_ptr.rs          | 16 ++++++++
 tests/ui/from_raw_with_void_ptr.stderr      | 15 ++++++++
 10 files changed, 117 insertions(+)
 create mode 100644 clippy_lints/src/from_raw_with_void_ptr.rs
 create mode 100644 src/docs/from_raw_with_void_ptr.txt
 create mode 100644 tests/ui/from_raw_with_void_ptr.rs
 create mode 100644 tests/ui/from_raw_with_void_ptr.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 2d7bda27e4f..cb5a4d4a577 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3903,6 +3903,7 @@ Released 2018-09-13
 [`format_push_string`]: https://rust-lang.github.io/rust-clippy/master/index.html#format_push_string
 [`from_iter_instead_of_collect`]: https://rust-lang.github.io/rust-clippy/master/index.html#from_iter_instead_of_collect
 [`from_over_into`]: https://rust-lang.github.io/rust-clippy/master/index.html#from_over_into
+[`from_raw_with_void_ptr`]: https://rust-lang.github.io/rust-clippy/master/index.html#from_raw_with_void_ptr
 [`from_str_radix_10`]: https://rust-lang.github.io/rust-clippy/master/index.html#from_str_radix_10
 [`future_not_send`]: https://rust-lang.github.io/rust-clippy/master/index.html#future_not_send
 [`get_first`]: https://rust-lang.github.io/rust-clippy/master/index.html#get_first
diff --git a/clippy_lints/src/from_raw_with_void_ptr.rs b/clippy_lints/src/from_raw_with_void_ptr.rs
new file mode 100644
index 00000000000..63c3c5f601d
--- /dev/null
+++ b/clippy_lints/src/from_raw_with_void_ptr.rs
@@ -0,0 +1,57 @@
+use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::path_def_id;
+use clippy_utils::ty::is_c_void;
+use rustc_hir::{Expr, ExprKind, QPath};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::RawPtr;
+use rustc_middle::ty::TypeAndMut;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks if we're passing a `c_void` raw pointer to `Box::from_raw(_)`
+    ///
+    /// ### Why is this bad?
+    /// However, it is easy to run into the pitfall of calling from_raw with the c_void pointer.
+    /// Note that the definition of, say, Box::from_raw is:
+    ///
+    /// `pub unsafe fn from_raw(raw: *mut T) -> Box<T>`
+    ///
+    /// meaning that if you pass a *mut c_void you will get a Box<c_void>.
+    /// Per the safety requirements in the documentation, for this to be safe,
+    /// c_void would need to have the same memory layout as the original type, which is often not the case.
+    ///
+    /// ### Example
+    /// ```rust
+    /// # use std::ffi::c_void;
+    /// let ptr = Box::into_raw(Box::new(42usize)) as *mut c_void;
+    /// let _ = unsafe { Box::from_raw(ptr) };
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// # use std::ffi::c_void;
+    /// # let ptr = Box::into_raw(Box::new(42usize)) as *mut c_void;
+    /// let _ = unsafe { Box::from_raw(ptr as *mut usize) };
+    /// ```
+    ///
+    #[clippy::version = "1.66.0"]
+    pub FROM_RAW_WITH_VOID_PTR,
+    suspicious,
+    "creating a `Box` from a raw void pointer"
+}
+declare_lint_pass!(FromRawWithVoidPtr => [FROM_RAW_WITH_VOID_PTR]);
+
+impl LateLintPass<'_> for FromRawWithVoidPtr {
+    fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
+        if let ExprKind::Call(box_from_raw, [arg]) = expr.kind
+        && let ExprKind::Path(QPath::TypeRelative(ty, seg)) = box_from_raw.kind
+        && seg.ident.name == sym!(from_raw)
+        // FIXME: This lint is also applicable to other types, like `Rc`, `Arc` and `Weak`.
+        && path_def_id(cx, ty).map_or(false, |id| Some(id) == cx.tcx.lang_items().owned_box())
+        && let arg_kind = cx.typeck_results().expr_ty(arg).kind()
+        && let RawPtr(TypeAndMut { ty, .. }) = arg_kind
+        && is_c_void(cx, *ty) {
+            span_lint_and_help(cx, FROM_RAW_WITH_VOID_PTR, expr.span, "creating a `Box` from a raw void pointer", Some(arg.span), "cast this to a pointer of the actual type");
+        }
+    }
+}
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
index f5ad52ba189..34fded26cfc 100644
--- a/clippy_lints/src/lib.register_all.rs
+++ b/clippy_lints/src/lib.register_all.rs
@@ -81,6 +81,7 @@ store.register_group(true, "clippy::all", Some("clippy_all"), vec![
     LintId::of(formatting::SUSPICIOUS_ELSE_FORMATTING),
     LintId::of(formatting::SUSPICIOUS_UNARY_OP_FORMATTING),
     LintId::of(from_over_into::FROM_OVER_INTO),
+    LintId::of(from_raw_with_void_ptr::FROM_RAW_WITH_VOID_PTR),
     LintId::of(from_str_radix_10::FROM_STR_RADIX_10),
     LintId::of(functions::DOUBLE_MUST_USE),
     LintId::of(functions::MUST_USE_UNIT),
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
index 800e3a87671..33696fff4f4 100644
--- a/clippy_lints/src/lib.register_lints.rs
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -173,6 +173,7 @@ store.register_lints(&[
     formatting::SUSPICIOUS_ELSE_FORMATTING,
     formatting::SUSPICIOUS_UNARY_OP_FORMATTING,
     from_over_into::FROM_OVER_INTO,
+    from_raw_with_void_ptr::FROM_RAW_WITH_VOID_PTR,
     from_str_radix_10::FROM_STR_RADIX_10,
     functions::DOUBLE_MUST_USE,
     functions::MUST_USE_CANDIDATE,
diff --git a/clippy_lints/src/lib.register_suspicious.rs b/clippy_lints/src/lib.register_suspicious.rs
index b70c4bb73e5..61af098c59a 100644
--- a/clippy_lints/src/lib.register_suspicious.rs
+++ b/clippy_lints/src/lib.register_suspicious.rs
@@ -21,6 +21,7 @@ store.register_group(true, "clippy::suspicious", Some("clippy_suspicious"), vec!
     LintId::of(formatting::SUSPICIOUS_ASSIGNMENT_FORMATTING),
     LintId::of(formatting::SUSPICIOUS_ELSE_FORMATTING),
     LintId::of(formatting::SUSPICIOUS_UNARY_OP_FORMATTING),
+    LintId::of(from_raw_with_void_ptr::FROM_RAW_WITH_VOID_PTR),
     LintId::of(loops::EMPTY_LOOP),
     LintId::of(loops::MUT_RANGE_BOUND),
     LintId::of(methods::NO_EFFECT_REPLACE),
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 8723eb7943c..28248d01b64 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -230,6 +230,7 @@ mod format_impl;
 mod format_push_string;
 mod formatting;
 mod from_over_into;
+mod from_raw_with_void_ptr;
 mod from_str_radix_10;
 mod functions;
 mod future_not_send;
@@ -918,6 +919,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(implicit_saturating_add::ImplicitSaturatingAdd));
     store.register_early_pass(|| Box::new(partial_pub_fields::PartialPubFields));
     store.register_late_pass(|_| Box::new(missing_trait_methods::MissingTraitMethods));
+    store.register_late_pass(|_| Box::new(from_raw_with_void_ptr::FromRawWithVoidPtr));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/src/docs.rs b/src/docs.rs
index c033ad294a3..9b12282f926 100644
--- a/src/docs.rs
+++ b/src/docs.rs
@@ -179,6 +179,7 @@ docs! {
     "format_push_string",
     "from_iter_instead_of_collect",
     "from_over_into",
+    "from_raw_with_void_ptr",
     "from_str_radix_10",
     "future_not_send",
     "get_first",
diff --git a/src/docs/from_raw_with_void_ptr.txt b/src/docs/from_raw_with_void_ptr.txt
new file mode 100644
index 00000000000..755fff23955
--- /dev/null
+++ b/src/docs/from_raw_with_void_ptr.txt
@@ -0,0 +1,22 @@
+### What it does
+Checks if we're passing a `c_void` raw pointer to `Box::from_raw(_)`
+
+### Why is this bad?
+However, it is easy to run into the pitfall of calling from_raw with the c_void pointer.
+Note that the definition of, say, Box::from_raw is:
+
+`pub unsafe fn from_raw(raw: *mut T) -> Box<T>`
+
+meaning that if you pass a *mut c_void you will get a Box<c_void>.
+Per the safety requirements in the documentation, for this to be safe,
+c_void would need to have the same memory layout as the original type, which is often not the case.
+
+### Example
+```
+let ptr = Box::into_raw(Box::new(42usize)) as *mut c_void;
+let _ = unsafe { Box::from_raw(ptr) };
+```
+Use instead:
+```
+let _ = unsafe { Box::from_raw(ptr as *mut usize) };
+```
diff --git a/tests/ui/from_raw_with_void_ptr.rs b/tests/ui/from_raw_with_void_ptr.rs
new file mode 100644
index 00000000000..de5a8d60092
--- /dev/null
+++ b/tests/ui/from_raw_with_void_ptr.rs
@@ -0,0 +1,16 @@
+#![warn(clippy::from_raw_with_void_ptr)]
+
+use std::ffi::c_void;
+
+fn main() {
+    // must lint
+    let ptr = Box::into_raw(Box::new(42usize)) as *mut c_void;
+    let _ = unsafe { Box::from_raw(ptr) };
+
+    // shouldn't be linted
+    let _ = unsafe { Box::from_raw(ptr as *mut usize) };
+
+    // shouldn't be linted
+    let should_not_lint_ptr = Box::into_raw(Box::new(12u8)) as *mut u8;
+    let _ = unsafe { Box::from_raw(should_not_lint_ptr as *mut u8) };
+}
diff --git a/tests/ui/from_raw_with_void_ptr.stderr b/tests/ui/from_raw_with_void_ptr.stderr
new file mode 100644
index 00000000000..9e8e3e44546
--- /dev/null
+++ b/tests/ui/from_raw_with_void_ptr.stderr
@@ -0,0 +1,15 @@
+error: creating a `Box` from a raw void pointer
+  --> $DIR/from_raw_with_void_ptr.rs:8:22
+   |
+LL |     let _ = unsafe { Box::from_raw(ptr) };
+   |                      ^^^^^^^^^^^^^^^^^^
+   |
+help: cast this to a pointer of the actual type
+  --> $DIR/from_raw_with_void_ptr.rs:8:36
+   |
+LL |     let _ = unsafe { Box::from_raw(ptr) };
+   |                                    ^^^
+   = note: `-D clippy::from-raw-with-void-ptr` implied by `-D warnings`
+
+error: aborting due to previous error
+
-- 
cgit 1.4.1-3-g733a5


From a201518a8a1f52c8893fdd3bcd259e2258fbb4d9 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Sun, 23 Oct 2022 20:32:26 +0000
Subject: Generate lint categories and explanations with `declare_clippy_lint`

Changes it to be a proc_macro rather than macro_rules
---
 clippy_dev/src/update_lints.rs               | 253 ++---------
 clippy_lints/Cargo.toml                      |   1 +
 clippy_lints/src/declared_lints.rs           | 620 +++++++++++++++++++++++++++
 clippy_lints/src/lib.register_all.rs         | 370 ----------------
 clippy_lints/src/lib.register_cargo.rs       |  11 -
 clippy_lints/src/lib.register_complexity.rs  | 111 -----
 clippy_lints/src/lib.register_correctness.rs |  78 ----
 clippy_lints/src/lib.register_internal.rs    |  22 -
 clippy_lints/src/lib.register_lints.rs       | 620 ---------------------------
 clippy_lints/src/lib.register_nursery.rs     |  41 --
 clippy_lints/src/lib.register_pedantic.rs    | 100 -----
 clippy_lints/src/lib.register_perf.rs        |  34 --
 clippy_lints/src/lib.register_restriction.rs |  90 ----
 clippy_lints/src/lib.register_style.rs       | 132 ------
 clippy_lints/src/lib.register_suspicious.rs  |  39 --
 clippy_lints/src/lib.rs                      | 231 +++++-----
 declare_clippy_lint/Cargo.toml               |  13 +
 declare_clippy_lint/src/lib.rs               | 173 ++++++++
 src/docs.rs                                  | 606 --------------------------
 src/main.rs                                  |   4 +-
 tests/versioncheck.rs                        |  15 +-
 21 files changed, 958 insertions(+), 2606 deletions(-)
 create mode 100644 clippy_lints/src/declared_lints.rs
 delete mode 100644 clippy_lints/src/lib.register_all.rs
 delete mode 100644 clippy_lints/src/lib.register_cargo.rs
 delete mode 100644 clippy_lints/src/lib.register_complexity.rs
 delete mode 100644 clippy_lints/src/lib.register_correctness.rs
 delete mode 100644 clippy_lints/src/lib.register_internal.rs
 delete mode 100644 clippy_lints/src/lib.register_lints.rs
 delete mode 100644 clippy_lints/src/lib.register_nursery.rs
 delete mode 100644 clippy_lints/src/lib.register_pedantic.rs
 delete mode 100644 clippy_lints/src/lib.register_perf.rs
 delete mode 100644 clippy_lints/src/lib.register_restriction.rs
 delete mode 100644 clippy_lints/src/lib.register_style.rs
 delete mode 100644 clippy_lints/src/lib.register_suspicious.rs
 create mode 100644 declare_clippy_lint/Cargo.toml
 create mode 100644 declare_clippy_lint/src/lib.rs
 delete mode 100644 src/docs.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_dev/src/update_lints.rs b/clippy_dev/src/update_lints.rs
index e690bc369cd..3cdbb42d44d 100644
--- a/clippy_dev/src/update_lints.rs
+++ b/clippy_dev/src/update_lints.rs
@@ -3,7 +3,7 @@ use aho_corasick::AhoCorasickBuilder;
 use indoc::writedoc;
 use itertools::Itertools;
 use rustc_lexer::{tokenize, unescape, LiteralKind, TokenKind};
-use std::collections::{BTreeSet, HashMap, HashSet};
+use std::collections::{HashMap, HashSet};
 use std::ffi::OsStr;
 use std::fmt::Write;
 use std::fs::{self, OpenOptions};
@@ -104,9 +104,9 @@ fn generate_lint_files(
     );
 
     process_file(
-        "clippy_lints/src/lib.register_lints.rs",
+        "clippy_lints/src/declared_lints.rs",
         update_mode,
-        &gen_register_lint_list(internal_lints.iter(), usable_lints.iter()),
+        &gen_declared_lints(internal_lints.iter(), usable_lints.iter()),
     );
     process_file(
         "clippy_lints/src/lib.deprecated.rs",
@@ -114,26 +114,6 @@ fn generate_lint_files(
         &gen_deprecated(deprecated_lints),
     );
 
-    let all_group_lints = usable_lints.iter().filter(|l| {
-        matches!(
-            &*l.group,
-            "correctness" | "suspicious" | "style" | "complexity" | "perf"
-        )
-    });
-    let content = gen_lint_group_list("all", all_group_lints);
-    process_file("clippy_lints/src/lib.register_all.rs", update_mode, &content);
-
-    update_docs(update_mode, &usable_lints);
-
-    for (lint_group, lints) in Lint::by_lint_group(usable_lints.into_iter().chain(internal_lints)) {
-        let content = gen_lint_group_list(&lint_group, lints.iter());
-        process_file(
-            format!("clippy_lints/src/lib.register_{lint_group}.rs"),
-            update_mode,
-            &content,
-        );
-    }
-
     let content = gen_deprecated_lints_test(deprecated_lints);
     process_file("tests/ui/deprecated.rs", update_mode, &content);
 
@@ -141,62 +121,6 @@ fn generate_lint_files(
     process_file("tests/ui/rename.rs", update_mode, &content);
 }
 
-fn update_docs(update_mode: UpdateMode, usable_lints: &[Lint]) {
-    replace_region_in_file(update_mode, Path::new("src/docs.rs"), "docs! {\n", "\n}\n", |res| {
-        for name in usable_lints.iter().map(|lint| lint.name.clone()).sorted() {
-            writeln!(res, r#"    "{name}","#).unwrap();
-        }
-    });
-
-    if update_mode == UpdateMode::Check {
-        let mut extra = BTreeSet::new();
-        let mut lint_names = usable_lints
-            .iter()
-            .map(|lint| lint.name.clone())
-            .collect::<BTreeSet<_>>();
-        for file in std::fs::read_dir("src/docs").unwrap() {
-            let filename = file.unwrap().file_name().into_string().unwrap();
-            if let Some(name) = filename.strip_suffix(".txt") {
-                if !lint_names.remove(name) {
-                    extra.insert(name.to_string());
-                }
-            }
-        }
-
-        let failed = print_lint_names("extra lint docs:", &extra) | print_lint_names("missing lint docs:", &lint_names);
-
-        if failed {
-            exit_with_failure();
-        }
-    } else {
-        if std::fs::remove_dir_all("src/docs").is_err() {
-            eprintln!("could not remove src/docs directory");
-        }
-        if std::fs::create_dir("src/docs").is_err() {
-            eprintln!("could not recreate src/docs directory");
-        }
-    }
-    for lint in usable_lints {
-        process_file(
-            Path::new("src/docs").join(lint.name.clone() + ".txt"),
-            update_mode,
-            &lint.documentation,
-        );
-    }
-}
-
-fn print_lint_names(header: &str, lints: &BTreeSet<String>) -> bool {
-    if lints.is_empty() {
-        return false;
-    }
-    println!("{header}");
-    for lint in lints.iter().sorted() {
-        println!("    {lint}");
-    }
-    println!();
-    true
-}
-
 pub fn print_lints() {
     let (lint_list, _, _) = gather_all();
     let usable_lints = Lint::usable_lints(&lint_list);
@@ -641,26 +565,17 @@ struct Lint {
     desc: String,
     module: String,
     declaration_range: Range<usize>,
-    documentation: String,
 }
 
 impl Lint {
     #[must_use]
-    fn new(
-        name: &str,
-        group: &str,
-        desc: &str,
-        module: &str,
-        declaration_range: Range<usize>,
-        documentation: String,
-    ) -> Self {
+    fn new(name: &str, group: &str, desc: &str, module: &str, declaration_range: Range<usize>) -> Self {
         Self {
             name: name.to_lowercase(),
             group: group.into(),
             desc: remove_line_splices(desc),
             module: module.into(),
             declaration_range,
-            documentation,
         }
     }
 
@@ -716,25 +631,6 @@ impl RenamedLint {
     }
 }
 
-/// Generates the code for registering a group
-fn gen_lint_group_list<'a>(group_name: &str, lints: impl Iterator<Item = &'a Lint>) -> String {
-    let mut details: Vec<_> = lints.map(|l| (&l.module, l.name.to_uppercase())).collect();
-    details.sort_unstable();
-
-    let mut output = GENERATED_FILE_COMMENT.to_string();
-
-    let _ = writeln!(
-        output,
-        "store.register_group(true, \"clippy::{group_name}\", Some(\"clippy_{group_name}\"), vec![",
-    );
-    for (module, name) in details {
-        let _ = writeln!(output, "    LintId::of({module}::{name}),");
-    }
-    output.push_str("])\n");
-
-    output
-}
-
 /// Generates the `register_removed` code
 #[must_use]
 fn gen_deprecated(lints: &[DeprecatedLint]) -> String {
@@ -759,7 +655,7 @@ fn gen_deprecated(lints: &[DeprecatedLint]) -> String {
 
 /// Generates the code for registering lints
 #[must_use]
-fn gen_register_lint_list<'a>(
+fn gen_declared_lints<'a>(
     internal_lints: impl Iterator<Item = &'a Lint>,
     usable_lints: impl Iterator<Item = &'a Lint>,
 ) -> String {
@@ -770,15 +666,15 @@ fn gen_register_lint_list<'a>(
     details.sort_unstable();
 
     let mut output = GENERATED_FILE_COMMENT.to_string();
-    output.push_str("store.register_lints(&[\n");
+    output.push_str("pub(crate) static LINTS: &[&crate::LintInfo] = &[\n");
 
     for (is_public, module_name, lint_name) in details {
         if !is_public {
             output.push_str("    #[cfg(feature = \"internal\")]\n");
         }
-        let _ = writeln!(output, "    {module_name}::{lint_name},");
+        let _ = writeln!(output, "    crate::{module_name}::{lint_name}_INFO,");
     }
-    output.push_str("])\n");
+    output.push_str("];\n");
 
     output
 }
@@ -910,35 +806,26 @@ fn parse_contents(contents: &str, module: &str, lints: &mut Vec<Lint>) {
          }| token_kind == &TokenKind::Ident && *content == "declare_clippy_lint",
     ) {
         let start = range.start;
-        let mut docs = String::with_capacity(128);
-        let mut iter = iter.by_ref().filter(|t| !matches!(t.token_kind, TokenKind::Whitespace));
+        let mut iter = iter
+            .by_ref()
+            .filter(|t| !matches!(t.token_kind, TokenKind::Whitespace | TokenKind::LineComment { .. }));
         // matches `!{`
         match_tokens!(iter, Bang OpenBrace);
-        let mut in_code = false;
-        while let Some(t) = iter.next() {
-            match t.token_kind {
-                TokenKind::LineComment { .. } => {
-                    if let Some(line) = t.content.strip_prefix("/// ").or_else(|| t.content.strip_prefix("///")) {
-                        if line.starts_with("```") {
-                            docs += "```\n";
-                            in_code = !in_code;
-                        } else if !(in_code && line.starts_with("# ")) {
-                            docs += line;
-                            docs.push('\n');
-                        }
-                    }
-                },
-                TokenKind::Pound => {
-                    match_tokens!(iter, OpenBracket Ident Colon Colon Ident Eq Literal{..} CloseBracket Ident);
-                    break;
-                },
-                TokenKind::Ident => {
-                    break;
-                },
-                _ => {},
-            }
+        match iter.next() {
+            // #[clippy::version = "version"] pub
+            Some(LintDeclSearchResult {
+                token_kind: TokenKind::Pound,
+                ..
+            }) => {
+                match_tokens!(iter, OpenBracket Ident Colon Colon Ident Eq Literal{..} CloseBracket Ident);
+            },
+            // pub
+            Some(LintDeclSearchResult {
+                token_kind: TokenKind::Ident,
+                ..
+            }) => (),
+            _ => continue,
         }
-        docs.pop(); // remove final newline
 
         let (name, group, desc) = match_tokens!(
             iter,
@@ -956,7 +843,7 @@ fn parse_contents(contents: &str, module: &str, lints: &mut Vec<Lint>) {
             ..
         }) = iter.next()
         {
-            lints.push(Lint::new(name, group, desc, module, start..range.end, docs));
+            lints.push(Lint::new(name, group, desc, module, start..range.end));
         }
     }
 }
@@ -1186,7 +1073,6 @@ mod tests {
                 "\"really long text\"",
                 "module_name",
                 Range::default(),
-                String::new(),
             ),
             Lint::new(
                 "doc_markdown",
@@ -1194,7 +1080,6 @@ mod tests {
                 "\"single line\"",
                 "module_name",
                 Range::default(),
-                String::new(),
             ),
         ];
         assert_eq!(expected, result);
@@ -1234,7 +1119,6 @@ mod tests {
                 "\"abc\"",
                 "module_name",
                 Range::default(),
-                String::new(),
             ),
             Lint::new(
                 "should_assert_eq2",
@@ -1242,7 +1126,6 @@ mod tests {
                 "\"abc\"",
                 "module_name",
                 Range::default(),
-                String::new(),
             ),
             Lint::new(
                 "should_assert_eq2",
@@ -1250,7 +1133,6 @@ mod tests {
                 "\"abc\"",
                 "module_name",
                 Range::default(),
-                String::new(),
             ),
         ];
         let expected = vec![Lint::new(
@@ -1259,7 +1141,6 @@ mod tests {
             "\"abc\"",
             "module_name",
             Range::default(),
-            String::new(),
         )];
         assert_eq!(expected, Lint::usable_lints(&lints));
     }
@@ -1267,51 +1148,22 @@ mod tests {
     #[test]
     fn test_by_lint_group() {
         let lints = vec![
-            Lint::new(
-                "should_assert_eq",
-                "group1",
-                "\"abc\"",
-                "module_name",
-                Range::default(),
-                String::new(),
-            ),
+            Lint::new("should_assert_eq", "group1", "\"abc\"", "module_name", Range::default()),
             Lint::new(
                 "should_assert_eq2",
                 "group2",
                 "\"abc\"",
                 "module_name",
                 Range::default(),
-                String::new(),
-            ),
-            Lint::new(
-                "incorrect_match",
-                "group1",
-                "\"abc\"",
-                "module_name",
-                Range::default(),
-                String::new(),
             ),
+            Lint::new("incorrect_match", "group1", "\"abc\"", "module_name", Range::default()),
         ];
         let mut expected: HashMap<String, Vec<Lint>> = HashMap::new();
         expected.insert(
             "group1".to_string(),
             vec![
-                Lint::new(
-                    "should_assert_eq",
-                    "group1",
-                    "\"abc\"",
-                    "module_name",
-                    Range::default(),
-                    String::new(),
-                ),
-                Lint::new(
-                    "incorrect_match",
-                    "group1",
-                    "\"abc\"",
-                    "module_name",
-                    Range::default(),
-                    String::new(),
-                ),
+                Lint::new("should_assert_eq", "group1", "\"abc\"", "module_name", Range::default()),
+                Lint::new("incorrect_match", "group1", "\"abc\"", "module_name", Range::default()),
             ],
         );
         expected.insert(
@@ -1322,7 +1174,6 @@ mod tests {
                 "\"abc\"",
                 "module_name",
                 Range::default(),
-                String::new(),
             )],
         );
         assert_eq!(expected, Lint::by_lint_group(lints.into_iter()));
@@ -1357,48 +1208,4 @@ mod tests {
 
         assert_eq!(expected, gen_deprecated(&lints));
     }
-
-    #[test]
-    fn test_gen_lint_group_list() {
-        let lints = vec![
-            Lint::new(
-                "abc",
-                "group1",
-                "\"abc\"",
-                "module_name",
-                Range::default(),
-                String::new(),
-            ),
-            Lint::new(
-                "should_assert_eq",
-                "group1",
-                "\"abc\"",
-                "module_name",
-                Range::default(),
-                String::new(),
-            ),
-            Lint::new(
-                "internal",
-                "internal_style",
-                "\"abc\"",
-                "module_name",
-                Range::default(),
-                String::new(),
-            ),
-        ];
-        let expected = GENERATED_FILE_COMMENT.to_string()
-            + &[
-                "store.register_group(true, \"clippy::group1\", Some(\"clippy_group1\"), vec![",
-                "    LintId::of(module_name::ABC),",
-                "    LintId::of(module_name::INTERNAL),",
-                "    LintId::of(module_name::SHOULD_ASSERT_EQ),",
-                "])",
-            ]
-            .join("\n")
-            + "\n";
-
-        let result = gen_lint_group_list("group1", lints.iter());
-
-        assert_eq!(expected, result);
-    }
 }
diff --git a/clippy_lints/Cargo.toml b/clippy_lints/Cargo.toml
index 1ff976f48f6..5368932b352 100644
--- a/clippy_lints/Cargo.toml
+++ b/clippy_lints/Cargo.toml
@@ -11,6 +11,7 @@ edition = "2021"
 [dependencies]
 cargo_metadata = "0.14"
 clippy_utils = { path = "../clippy_utils" }
+declare_clippy_lint = { path = "../declare_clippy_lint" }
 if_chain = "1.0"
 itertools = "0.10.1"
 pulldown-cmark = { version = "0.9", default-features = false }
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
new file mode 100644
index 00000000000..c6ae0bddc5a
--- /dev/null
+++ b/clippy_lints/src/declared_lints.rs
@@ -0,0 +1,620 @@
+// This file was generated by `cargo dev update_lints`.
+// Use that command to update this file and do not edit by hand.
+// Manual edits will be overwritten.
+
+pub(crate) static LINTS: &[&crate::LintInfo] = &[
+    #[cfg(feature = "internal")]
+    crate::utils::internal_lints::clippy_lints_internal::CLIPPY_LINTS_INTERNAL_INFO,
+    #[cfg(feature = "internal")]
+    crate::utils::internal_lints::collapsible_calls::COLLAPSIBLE_SPAN_LINT_CALLS_INFO,
+    #[cfg(feature = "internal")]
+    crate::utils::internal_lints::compiler_lint_functions::COMPILER_LINT_FUNCTIONS_INFO,
+    #[cfg(feature = "internal")]
+    crate::utils::internal_lints::if_chain_style::IF_CHAIN_STYLE_INFO,
+    #[cfg(feature = "internal")]
+    crate::utils::internal_lints::interning_defined_symbol::INTERNING_DEFINED_SYMBOL_INFO,
+    #[cfg(feature = "internal")]
+    crate::utils::internal_lints::interning_defined_symbol::UNNECESSARY_SYMBOL_STR_INFO,
+    #[cfg(feature = "internal")]
+    crate::utils::internal_lints::invalid_paths::INVALID_PATHS_INFO,
+    #[cfg(feature = "internal")]
+    crate::utils::internal_lints::lint_without_lint_pass::DEFAULT_DEPRECATION_REASON_INFO,
+    #[cfg(feature = "internal")]
+    crate::utils::internal_lints::lint_without_lint_pass::DEFAULT_LINT_INFO,
+    #[cfg(feature = "internal")]
+    crate::utils::internal_lints::lint_without_lint_pass::INVALID_CLIPPY_VERSION_ATTRIBUTE_INFO,
+    #[cfg(feature = "internal")]
+    crate::utils::internal_lints::lint_without_lint_pass::LINT_WITHOUT_LINT_PASS_INFO,
+    #[cfg(feature = "internal")]
+    crate::utils::internal_lints::lint_without_lint_pass::MISSING_CLIPPY_VERSION_ATTRIBUTE_INFO,
+    #[cfg(feature = "internal")]
+    crate::utils::internal_lints::msrv_attr_impl::MISSING_MSRV_ATTR_IMPL_INFO,
+    #[cfg(feature = "internal")]
+    crate::utils::internal_lints::outer_expn_data_pass::OUTER_EXPN_EXPN_DATA_INFO,
+    #[cfg(feature = "internal")]
+    crate::utils::internal_lints::produce_ice::PRODUCE_ICE_INFO,
+    #[cfg(feature = "internal")]
+    crate::utils::internal_lints::unnecessary_def_path::UNNECESSARY_DEF_PATH_INFO,
+    crate::almost_complete_letter_range::ALMOST_COMPLETE_LETTER_RANGE_INFO,
+    crate::approx_const::APPROX_CONSTANT_INFO,
+    crate::as_conversions::AS_CONVERSIONS_INFO,
+    crate::asm_syntax::INLINE_ASM_X86_ATT_SYNTAX_INFO,
+    crate::asm_syntax::INLINE_ASM_X86_INTEL_SYNTAX_INFO,
+    crate::assertions_on_constants::ASSERTIONS_ON_CONSTANTS_INFO,
+    crate::assertions_on_result_states::ASSERTIONS_ON_RESULT_STATES_INFO,
+    crate::async_yields_async::ASYNC_YIELDS_ASYNC_INFO,
+    crate::attrs::ALLOW_ATTRIBUTES_WITHOUT_REASON_INFO,
+    crate::attrs::BLANKET_CLIPPY_RESTRICTION_LINTS_INFO,
+    crate::attrs::DEPRECATED_CFG_ATTR_INFO,
+    crate::attrs::DEPRECATED_SEMVER_INFO,
+    crate::attrs::EMPTY_LINE_AFTER_OUTER_ATTR_INFO,
+    crate::attrs::INLINE_ALWAYS_INFO,
+    crate::attrs::MISMATCHED_TARGET_OS_INFO,
+    crate::attrs::USELESS_ATTRIBUTE_INFO,
+    crate::await_holding_invalid::AWAIT_HOLDING_INVALID_TYPE_INFO,
+    crate::await_holding_invalid::AWAIT_HOLDING_LOCK_INFO,
+    crate::await_holding_invalid::AWAIT_HOLDING_REFCELL_REF_INFO,
+    crate::blocks_in_if_conditions::BLOCKS_IN_IF_CONDITIONS_INFO,
+    crate::bool_assert_comparison::BOOL_ASSERT_COMPARISON_INFO,
+    crate::bool_to_int_with_if::BOOL_TO_INT_WITH_IF_INFO,
+    crate::booleans::NONMINIMAL_BOOL_INFO,
+    crate::booleans::OVERLY_COMPLEX_BOOL_EXPR_INFO,
+    crate::borrow_deref_ref::BORROW_DEREF_REF_INFO,
+    crate::box_default::BOX_DEFAULT_INFO,
+    crate::cargo::CARGO_COMMON_METADATA_INFO,
+    crate::cargo::MULTIPLE_CRATE_VERSIONS_INFO,
+    crate::cargo::NEGATIVE_FEATURE_NAMES_INFO,
+    crate::cargo::REDUNDANT_FEATURE_NAMES_INFO,
+    crate::cargo::WILDCARD_DEPENDENCIES_INFO,
+    crate::casts::AS_PTR_CAST_MUT_INFO,
+    crate::casts::AS_UNDERSCORE_INFO,
+    crate::casts::BORROW_AS_PTR_INFO,
+    crate::casts::CAST_ABS_TO_UNSIGNED_INFO,
+    crate::casts::CAST_ENUM_CONSTRUCTOR_INFO,
+    crate::casts::CAST_ENUM_TRUNCATION_INFO,
+    crate::casts::CAST_LOSSLESS_INFO,
+    crate::casts::CAST_NAN_TO_INT_INFO,
+    crate::casts::CAST_POSSIBLE_TRUNCATION_INFO,
+    crate::casts::CAST_POSSIBLE_WRAP_INFO,
+    crate::casts::CAST_PRECISION_LOSS_INFO,
+    crate::casts::CAST_PTR_ALIGNMENT_INFO,
+    crate::casts::CAST_REF_TO_MUT_INFO,
+    crate::casts::CAST_SIGN_LOSS_INFO,
+    crate::casts::CAST_SLICE_DIFFERENT_SIZES_INFO,
+    crate::casts::CAST_SLICE_FROM_RAW_PARTS_INFO,
+    crate::casts::CHAR_LIT_AS_U8_INFO,
+    crate::casts::FN_TO_NUMERIC_CAST_INFO,
+    crate::casts::FN_TO_NUMERIC_CAST_ANY_INFO,
+    crate::casts::FN_TO_NUMERIC_CAST_WITH_TRUNCATION_INFO,
+    crate::casts::PTR_AS_PTR_INFO,
+    crate::casts::UNNECESSARY_CAST_INFO,
+    crate::checked_conversions::CHECKED_CONVERSIONS_INFO,
+    crate::cognitive_complexity::COGNITIVE_COMPLEXITY_INFO,
+    crate::collapsible_if::COLLAPSIBLE_ELSE_IF_INFO,
+    crate::collapsible_if::COLLAPSIBLE_IF_INFO,
+    crate::comparison_chain::COMPARISON_CHAIN_INFO,
+    crate::copies::BRANCHES_SHARING_CODE_INFO,
+    crate::copies::IFS_SAME_COND_INFO,
+    crate::copies::IF_SAME_THEN_ELSE_INFO,
+    crate::copies::SAME_FUNCTIONS_IN_IF_CONDITION_INFO,
+    crate::copy_iterator::COPY_ITERATOR_INFO,
+    crate::crate_in_macro_def::CRATE_IN_MACRO_DEF_INFO,
+    crate::create_dir::CREATE_DIR_INFO,
+    crate::dbg_macro::DBG_MACRO_INFO,
+    crate::default::DEFAULT_TRAIT_ACCESS_INFO,
+    crate::default::FIELD_REASSIGN_WITH_DEFAULT_INFO,
+    crate::default_instead_of_iter_empty::DEFAULT_INSTEAD_OF_ITER_EMPTY_INFO,
+    crate::default_numeric_fallback::DEFAULT_NUMERIC_FALLBACK_INFO,
+    crate::default_union_representation::DEFAULT_UNION_REPRESENTATION_INFO,
+    crate::dereference::EXPLICIT_AUTO_DEREF_INFO,
+    crate::dereference::EXPLICIT_DEREF_METHODS_INFO,
+    crate::dereference::NEEDLESS_BORROW_INFO,
+    crate::dereference::REF_BINDING_TO_REFERENCE_INFO,
+    crate::derivable_impls::DERIVABLE_IMPLS_INFO,
+    crate::derive::DERIVE_HASH_XOR_EQ_INFO,
+    crate::derive::DERIVE_ORD_XOR_PARTIAL_ORD_INFO,
+    crate::derive::DERIVE_PARTIAL_EQ_WITHOUT_EQ_INFO,
+    crate::derive::EXPL_IMPL_CLONE_ON_COPY_INFO,
+    crate::derive::UNSAFE_DERIVE_DESERIALIZE_INFO,
+    crate::disallowed_macros::DISALLOWED_MACROS_INFO,
+    crate::disallowed_methods::DISALLOWED_METHODS_INFO,
+    crate::disallowed_names::DISALLOWED_NAMES_INFO,
+    crate::disallowed_script_idents::DISALLOWED_SCRIPT_IDENTS_INFO,
+    crate::disallowed_types::DISALLOWED_TYPES_INFO,
+    crate::doc::DOC_LINK_WITH_QUOTES_INFO,
+    crate::doc::DOC_MARKDOWN_INFO,
+    crate::doc::MISSING_ERRORS_DOC_INFO,
+    crate::doc::MISSING_PANICS_DOC_INFO,
+    crate::doc::MISSING_SAFETY_DOC_INFO,
+    crate::doc::NEEDLESS_DOCTEST_MAIN_INFO,
+    crate::double_parens::DOUBLE_PARENS_INFO,
+    crate::drop_forget_ref::DROP_COPY_INFO,
+    crate::drop_forget_ref::DROP_NON_DROP_INFO,
+    crate::drop_forget_ref::DROP_REF_INFO,
+    crate::drop_forget_ref::FORGET_COPY_INFO,
+    crate::drop_forget_ref::FORGET_NON_DROP_INFO,
+    crate::drop_forget_ref::FORGET_REF_INFO,
+    crate::drop_forget_ref::UNDROPPED_MANUALLY_DROPS_INFO,
+    crate::duplicate_mod::DUPLICATE_MOD_INFO,
+    crate::else_if_without_else::ELSE_IF_WITHOUT_ELSE_INFO,
+    crate::empty_drop::EMPTY_DROP_INFO,
+    crate::empty_enum::EMPTY_ENUM_INFO,
+    crate::empty_structs_with_brackets::EMPTY_STRUCTS_WITH_BRACKETS_INFO,
+    crate::entry::MAP_ENTRY_INFO,
+    crate::enum_clike::ENUM_CLIKE_UNPORTABLE_VARIANT_INFO,
+    crate::enum_variants::ENUM_VARIANT_NAMES_INFO,
+    crate::enum_variants::MODULE_INCEPTION_INFO,
+    crate::enum_variants::MODULE_NAME_REPETITIONS_INFO,
+    crate::equatable_if_let::EQUATABLE_IF_LET_INFO,
+    crate::escape::BOXED_LOCAL_INFO,
+    crate::eta_reduction::REDUNDANT_CLOSURE_INFO,
+    crate::eta_reduction::REDUNDANT_CLOSURE_FOR_METHOD_CALLS_INFO,
+    crate::excessive_bools::FN_PARAMS_EXCESSIVE_BOOLS_INFO,
+    crate::excessive_bools::STRUCT_EXCESSIVE_BOOLS_INFO,
+    crate::exhaustive_items::EXHAUSTIVE_ENUMS_INFO,
+    crate::exhaustive_items::EXHAUSTIVE_STRUCTS_INFO,
+    crate::exit::EXIT_INFO,
+    crate::explicit_write::EXPLICIT_WRITE_INFO,
+    crate::fallible_impl_from::FALLIBLE_IMPL_FROM_INFO,
+    crate::float_literal::EXCESSIVE_PRECISION_INFO,
+    crate::float_literal::LOSSY_FLOAT_LITERAL_INFO,
+    crate::floating_point_arithmetic::IMPRECISE_FLOPS_INFO,
+    crate::floating_point_arithmetic::SUBOPTIMAL_FLOPS_INFO,
+    crate::format::USELESS_FORMAT_INFO,
+    crate::format_args::FORMAT_IN_FORMAT_ARGS_INFO,
+    crate::format_args::TO_STRING_IN_FORMAT_ARGS_INFO,
+    crate::format_args::UNINLINED_FORMAT_ARGS_INFO,
+    crate::format_args::UNUSED_FORMAT_SPECS_INFO,
+    crate::format_impl::PRINT_IN_FORMAT_IMPL_INFO,
+    crate::format_impl::RECURSIVE_FORMAT_IMPL_INFO,
+    crate::format_push_string::FORMAT_PUSH_STRING_INFO,
+    crate::formatting::POSSIBLE_MISSING_COMMA_INFO,
+    crate::formatting::SUSPICIOUS_ASSIGNMENT_FORMATTING_INFO,
+    crate::formatting::SUSPICIOUS_ELSE_FORMATTING_INFO,
+    crate::formatting::SUSPICIOUS_UNARY_OP_FORMATTING_INFO,
+    crate::from_over_into::FROM_OVER_INTO_INFO,
+    crate::from_raw_with_void_ptr::FROM_RAW_WITH_VOID_PTR_INFO,
+    crate::from_str_radix_10::FROM_STR_RADIX_10_INFO,
+    crate::functions::DOUBLE_MUST_USE_INFO,
+    crate::functions::MUST_USE_CANDIDATE_INFO,
+    crate::functions::MUST_USE_UNIT_INFO,
+    crate::functions::NOT_UNSAFE_PTR_ARG_DEREF_INFO,
+    crate::functions::RESULT_LARGE_ERR_INFO,
+    crate::functions::RESULT_UNIT_ERR_INFO,
+    crate::functions::TOO_MANY_ARGUMENTS_INFO,
+    crate::functions::TOO_MANY_LINES_INFO,
+    crate::future_not_send::FUTURE_NOT_SEND_INFO,
+    crate::if_let_mutex::IF_LET_MUTEX_INFO,
+    crate::if_not_else::IF_NOT_ELSE_INFO,
+    crate::if_then_some_else_none::IF_THEN_SOME_ELSE_NONE_INFO,
+    crate::implicit_hasher::IMPLICIT_HASHER_INFO,
+    crate::implicit_return::IMPLICIT_RETURN_INFO,
+    crate::implicit_saturating_add::IMPLICIT_SATURATING_ADD_INFO,
+    crate::implicit_saturating_sub::IMPLICIT_SATURATING_SUB_INFO,
+    crate::inconsistent_struct_constructor::INCONSISTENT_STRUCT_CONSTRUCTOR_INFO,
+    crate::index_refutable_slice::INDEX_REFUTABLE_SLICE_INFO,
+    crate::indexing_slicing::INDEXING_SLICING_INFO,
+    crate::indexing_slicing::OUT_OF_BOUNDS_INDEXING_INFO,
+    crate::infinite_iter::INFINITE_ITER_INFO,
+    crate::infinite_iter::MAYBE_INFINITE_ITER_INFO,
+    crate::inherent_impl::MULTIPLE_INHERENT_IMPL_INFO,
+    crate::inherent_to_string::INHERENT_TO_STRING_INFO,
+    crate::inherent_to_string::INHERENT_TO_STRING_SHADOW_DISPLAY_INFO,
+    crate::init_numbered_fields::INIT_NUMBERED_FIELDS_INFO,
+    crate::inline_fn_without_body::INLINE_FN_WITHOUT_BODY_INFO,
+    crate::int_plus_one::INT_PLUS_ONE_INFO,
+    crate::invalid_upcast_comparisons::INVALID_UPCAST_COMPARISONS_INFO,
+    crate::invalid_utf8_in_unchecked::INVALID_UTF8_IN_UNCHECKED_INFO,
+    crate::items_after_statements::ITEMS_AFTER_STATEMENTS_INFO,
+    crate::iter_not_returning_iterator::ITER_NOT_RETURNING_ITERATOR_INFO,
+    crate::large_const_arrays::LARGE_CONST_ARRAYS_INFO,
+    crate::large_enum_variant::LARGE_ENUM_VARIANT_INFO,
+    crate::large_include_file::LARGE_INCLUDE_FILE_INFO,
+    crate::large_stack_arrays::LARGE_STACK_ARRAYS_INFO,
+    crate::len_zero::COMPARISON_TO_EMPTY_INFO,
+    crate::len_zero::LEN_WITHOUT_IS_EMPTY_INFO,
+    crate::len_zero::LEN_ZERO_INFO,
+    crate::let_if_seq::USELESS_LET_IF_SEQ_INFO,
+    crate::let_underscore::LET_UNDERSCORE_LOCK_INFO,
+    crate::let_underscore::LET_UNDERSCORE_MUST_USE_INFO,
+    crate::lifetimes::EXTRA_UNUSED_LIFETIMES_INFO,
+    crate::lifetimes::NEEDLESS_LIFETIMES_INFO,
+    crate::literal_representation::DECIMAL_LITERAL_REPRESENTATION_INFO,
+    crate::literal_representation::INCONSISTENT_DIGIT_GROUPING_INFO,
+    crate::literal_representation::LARGE_DIGIT_GROUPS_INFO,
+    crate::literal_representation::MISTYPED_LITERAL_SUFFIXES_INFO,
+    crate::literal_representation::UNREADABLE_LITERAL_INFO,
+    crate::literal_representation::UNUSUAL_BYTE_GROUPINGS_INFO,
+    crate::loops::EMPTY_LOOP_INFO,
+    crate::loops::EXPLICIT_COUNTER_LOOP_INFO,
+    crate::loops::EXPLICIT_INTO_ITER_LOOP_INFO,
+    crate::loops::EXPLICIT_ITER_LOOP_INFO,
+    crate::loops::FOR_KV_MAP_INFO,
+    crate::loops::ITER_NEXT_LOOP_INFO,
+    crate::loops::MANUAL_FIND_INFO,
+    crate::loops::MANUAL_FLATTEN_INFO,
+    crate::loops::MANUAL_MEMCPY_INFO,
+    crate::loops::MISSING_SPIN_LOOP_INFO,
+    crate::loops::MUT_RANGE_BOUND_INFO,
+    crate::loops::NEEDLESS_COLLECT_INFO,
+    crate::loops::NEEDLESS_RANGE_LOOP_INFO,
+    crate::loops::NEVER_LOOP_INFO,
+    crate::loops::SAME_ITEM_PUSH_INFO,
+    crate::loops::SINGLE_ELEMENT_LOOP_INFO,
+    crate::loops::WHILE_IMMUTABLE_CONDITION_INFO,
+    crate::loops::WHILE_LET_LOOP_INFO,
+    crate::loops::WHILE_LET_ON_ITERATOR_INFO,
+    crate::macro_use::MACRO_USE_IMPORTS_INFO,
+    crate::main_recursion::MAIN_RECURSION_INFO,
+    crate::manual_assert::MANUAL_ASSERT_INFO,
+    crate::manual_async_fn::MANUAL_ASYNC_FN_INFO,
+    crate::manual_bits::MANUAL_BITS_INFO,
+    crate::manual_clamp::MANUAL_CLAMP_INFO,
+    crate::manual_instant_elapsed::MANUAL_INSTANT_ELAPSED_INFO,
+    crate::manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE_INFO,
+    crate::manual_rem_euclid::MANUAL_REM_EUCLID_INFO,
+    crate::manual_retain::MANUAL_RETAIN_INFO,
+    crate::manual_string_new::MANUAL_STRING_NEW_INFO,
+    crate::manual_strip::MANUAL_STRIP_INFO,
+    crate::map_unit_fn::OPTION_MAP_UNIT_FN_INFO,
+    crate::map_unit_fn::RESULT_MAP_UNIT_FN_INFO,
+    crate::match_result_ok::MATCH_RESULT_OK_INFO,
+    crate::matches::COLLAPSIBLE_MATCH_INFO,
+    crate::matches::INFALLIBLE_DESTRUCTURING_MATCH_INFO,
+    crate::matches::MANUAL_FILTER_INFO,
+    crate::matches::MANUAL_MAP_INFO,
+    crate::matches::MANUAL_UNWRAP_OR_INFO,
+    crate::matches::MATCH_AS_REF_INFO,
+    crate::matches::MATCH_BOOL_INFO,
+    crate::matches::MATCH_LIKE_MATCHES_MACRO_INFO,
+    crate::matches::MATCH_ON_VEC_ITEMS_INFO,
+    crate::matches::MATCH_OVERLAPPING_ARM_INFO,
+    crate::matches::MATCH_REF_PATS_INFO,
+    crate::matches::MATCH_SAME_ARMS_INFO,
+    crate::matches::MATCH_SINGLE_BINDING_INFO,
+    crate::matches::MATCH_STR_CASE_MISMATCH_INFO,
+    crate::matches::MATCH_WILDCARD_FOR_SINGLE_VARIANTS_INFO,
+    crate::matches::MATCH_WILD_ERR_ARM_INFO,
+    crate::matches::NEEDLESS_MATCH_INFO,
+    crate::matches::REDUNDANT_PATTERN_MATCHING_INFO,
+    crate::matches::REST_PAT_IN_FULLY_BOUND_STRUCTS_INFO,
+    crate::matches::SIGNIFICANT_DROP_IN_SCRUTINEE_INFO,
+    crate::matches::SINGLE_MATCH_INFO,
+    crate::matches::SINGLE_MATCH_ELSE_INFO,
+    crate::matches::TRY_ERR_INFO,
+    crate::matches::WILDCARD_ENUM_MATCH_ARM_INFO,
+    crate::matches::WILDCARD_IN_OR_PATTERNS_INFO,
+    crate::mem_forget::MEM_FORGET_INFO,
+    crate::mem_replace::MEM_REPLACE_OPTION_WITH_NONE_INFO,
+    crate::mem_replace::MEM_REPLACE_WITH_DEFAULT_INFO,
+    crate::mem_replace::MEM_REPLACE_WITH_UNINIT_INFO,
+    crate::methods::BIND_INSTEAD_OF_MAP_INFO,
+    crate::methods::BYTES_COUNT_TO_LEN_INFO,
+    crate::methods::BYTES_NTH_INFO,
+    crate::methods::CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS_INFO,
+    crate::methods::CHARS_LAST_CMP_INFO,
+    crate::methods::CHARS_NEXT_CMP_INFO,
+    crate::methods::CLONED_INSTEAD_OF_COPIED_INFO,
+    crate::methods::CLONE_DOUBLE_REF_INFO,
+    crate::methods::CLONE_ON_COPY_INFO,
+    crate::methods::CLONE_ON_REF_PTR_INFO,
+    crate::methods::COLLAPSIBLE_STR_REPLACE_INFO,
+    crate::methods::ERR_EXPECT_INFO,
+    crate::methods::EXPECT_FUN_CALL_INFO,
+    crate::methods::EXPECT_USED_INFO,
+    crate::methods::EXTEND_WITH_DRAIN_INFO,
+    crate::methods::FILETYPE_IS_FILE_INFO,
+    crate::methods::FILTER_MAP_IDENTITY_INFO,
+    crate::methods::FILTER_MAP_NEXT_INFO,
+    crate::methods::FILTER_NEXT_INFO,
+    crate::methods::FLAT_MAP_IDENTITY_INFO,
+    crate::methods::FLAT_MAP_OPTION_INFO,
+    crate::methods::FROM_ITER_INSTEAD_OF_COLLECT_INFO,
+    crate::methods::GET_FIRST_INFO,
+    crate::methods::GET_LAST_WITH_LEN_INFO,
+    crate::methods::GET_UNWRAP_INFO,
+    crate::methods::IMPLICIT_CLONE_INFO,
+    crate::methods::INEFFICIENT_TO_STRING_INFO,
+    crate::methods::INSPECT_FOR_EACH_INFO,
+    crate::methods::INTO_ITER_ON_REF_INFO,
+    crate::methods::IS_DIGIT_ASCII_RADIX_INFO,
+    crate::methods::ITERATOR_STEP_BY_ZERO_INFO,
+    crate::methods::ITER_CLONED_COLLECT_INFO,
+    crate::methods::ITER_COUNT_INFO,
+    crate::methods::ITER_KV_MAP_INFO,
+    crate::methods::ITER_NEXT_SLICE_INFO,
+    crate::methods::ITER_NTH_INFO,
+    crate::methods::ITER_NTH_ZERO_INFO,
+    crate::methods::ITER_ON_EMPTY_COLLECTIONS_INFO,
+    crate::methods::ITER_ON_SINGLE_ITEMS_INFO,
+    crate::methods::ITER_OVEREAGER_CLONED_INFO,
+    crate::methods::ITER_SKIP_NEXT_INFO,
+    crate::methods::ITER_WITH_DRAIN_INFO,
+    crate::methods::MANUAL_FILTER_MAP_INFO,
+    crate::methods::MANUAL_FIND_MAP_INFO,
+    crate::methods::MANUAL_OK_OR_INFO,
+    crate::methods::MANUAL_SATURATING_ARITHMETIC_INFO,
+    crate::methods::MANUAL_SPLIT_ONCE_INFO,
+    crate::methods::MANUAL_STR_REPEAT_INFO,
+    crate::methods::MAP_CLONE_INFO,
+    crate::methods::MAP_COLLECT_RESULT_UNIT_INFO,
+    crate::methods::MAP_ERR_IGNORE_INFO,
+    crate::methods::MAP_FLATTEN_INFO,
+    crate::methods::MAP_IDENTITY_INFO,
+    crate::methods::MAP_UNWRAP_OR_INFO,
+    crate::methods::MUT_MUTEX_LOCK_INFO,
+    crate::methods::NAIVE_BYTECOUNT_INFO,
+    crate::methods::NEEDLESS_OPTION_AS_DEREF_INFO,
+    crate::methods::NEEDLESS_OPTION_TAKE_INFO,
+    crate::methods::NEEDLESS_SPLITN_INFO,
+    crate::methods::NEW_RET_NO_SELF_INFO,
+    crate::methods::NONSENSICAL_OPEN_OPTIONS_INFO,
+    crate::methods::NO_EFFECT_REPLACE_INFO,
+    crate::methods::OBFUSCATED_IF_ELSE_INFO,
+    crate::methods::OK_EXPECT_INFO,
+    crate::methods::OPTION_AS_REF_DEREF_INFO,
+    crate::methods::OPTION_FILTER_MAP_INFO,
+    crate::methods::OPTION_MAP_OR_NONE_INFO,
+    crate::methods::OR_FUN_CALL_INFO,
+    crate::methods::OR_THEN_UNWRAP_INFO,
+    crate::methods::PATH_BUF_PUSH_OVERWRITE_INFO,
+    crate::methods::RANGE_ZIP_WITH_LEN_INFO,
+    crate::methods::REPEAT_ONCE_INFO,
+    crate::methods::RESULT_MAP_OR_INTO_OPTION_INFO,
+    crate::methods::SEARCH_IS_SOME_INFO,
+    crate::methods::SHOULD_IMPLEMENT_TRAIT_INFO,
+    crate::methods::SINGLE_CHAR_ADD_STR_INFO,
+    crate::methods::SINGLE_CHAR_PATTERN_INFO,
+    crate::methods::SKIP_WHILE_NEXT_INFO,
+    crate::methods::STABLE_SORT_PRIMITIVE_INFO,
+    crate::methods::STRING_EXTEND_CHARS_INFO,
+    crate::methods::SUSPICIOUS_MAP_INFO,
+    crate::methods::SUSPICIOUS_SPLITN_INFO,
+    crate::methods::SUSPICIOUS_TO_OWNED_INFO,
+    crate::methods::UNINIT_ASSUMED_INIT_INFO,
+    crate::methods::UNIT_HASH_INFO,
+    crate::methods::UNNECESSARY_FILTER_MAP_INFO,
+    crate::methods::UNNECESSARY_FIND_MAP_INFO,
+    crate::methods::UNNECESSARY_FOLD_INFO,
+    crate::methods::UNNECESSARY_JOIN_INFO,
+    crate::methods::UNNECESSARY_LAZY_EVALUATIONS_INFO,
+    crate::methods::UNNECESSARY_SORT_BY_INFO,
+    crate::methods::UNNECESSARY_TO_OWNED_INFO,
+    crate::methods::UNWRAP_OR_ELSE_DEFAULT_INFO,
+    crate::methods::UNWRAP_USED_INFO,
+    crate::methods::USELESS_ASREF_INFO,
+    crate::methods::VEC_RESIZE_TO_ZERO_INFO,
+    crate::methods::VERBOSE_FILE_READS_INFO,
+    crate::methods::WRONG_SELF_CONVENTION_INFO,
+    crate::methods::ZST_OFFSET_INFO,
+    crate::minmax::MIN_MAX_INFO,
+    crate::misc::SHORT_CIRCUIT_STATEMENT_INFO,
+    crate::misc::TOPLEVEL_REF_ARG_INFO,
+    crate::misc::USED_UNDERSCORE_BINDING_INFO,
+    crate::misc::ZERO_PTR_INFO,
+    crate::misc_early::BUILTIN_TYPE_SHADOW_INFO,
+    crate::misc_early::DOUBLE_NEG_INFO,
+    crate::misc_early::DUPLICATE_UNDERSCORE_ARGUMENT_INFO,
+    crate::misc_early::MIXED_CASE_HEX_LITERALS_INFO,
+    crate::misc_early::REDUNDANT_PATTERN_INFO,
+    crate::misc_early::SEPARATED_LITERAL_SUFFIX_INFO,
+    crate::misc_early::UNNEEDED_FIELD_PATTERN_INFO,
+    crate::misc_early::UNNEEDED_WILDCARD_PATTERN_INFO,
+    crate::misc_early::UNSEPARATED_LITERAL_SUFFIX_INFO,
+    crate::misc_early::ZERO_PREFIXED_LITERAL_INFO,
+    crate::mismatching_type_param_order::MISMATCHING_TYPE_PARAM_ORDER_INFO,
+    crate::missing_const_for_fn::MISSING_CONST_FOR_FN_INFO,
+    crate::missing_doc::MISSING_DOCS_IN_PRIVATE_ITEMS_INFO,
+    crate::missing_enforced_import_rename::MISSING_ENFORCED_IMPORT_RENAMES_INFO,
+    crate::missing_inline::MISSING_INLINE_IN_PUBLIC_ITEMS_INFO,
+    crate::missing_trait_methods::MISSING_TRAIT_METHODS_INFO,
+    crate::mixed_read_write_in_expression::DIVERGING_SUB_EXPRESSION_INFO,
+    crate::mixed_read_write_in_expression::MIXED_READ_WRITE_IN_EXPRESSION_INFO,
+    crate::module_style::MOD_MODULE_FILES_INFO,
+    crate::module_style::SELF_NAMED_MODULE_FILES_INFO,
+    crate::multi_assignments::MULTI_ASSIGNMENTS_INFO,
+    crate::mut_key::MUTABLE_KEY_TYPE_INFO,
+    crate::mut_mut::MUT_MUT_INFO,
+    crate::mut_reference::UNNECESSARY_MUT_PASSED_INFO,
+    crate::mutable_debug_assertion::DEBUG_ASSERT_WITH_MUT_CALL_INFO,
+    crate::mutex_atomic::MUTEX_ATOMIC_INFO,
+    crate::mutex_atomic::MUTEX_INTEGER_INFO,
+    crate::needless_arbitrary_self_type::NEEDLESS_ARBITRARY_SELF_TYPE_INFO,
+    crate::needless_bool::BOOL_COMPARISON_INFO,
+    crate::needless_bool::NEEDLESS_BOOL_INFO,
+    crate::needless_borrowed_ref::NEEDLESS_BORROWED_REFERENCE_INFO,
+    crate::needless_continue::NEEDLESS_CONTINUE_INFO,
+    crate::needless_for_each::NEEDLESS_FOR_EACH_INFO,
+    crate::needless_late_init::NEEDLESS_LATE_INIT_INFO,
+    crate::needless_parens_on_range_literals::NEEDLESS_PARENS_ON_RANGE_LITERALS_INFO,
+    crate::needless_pass_by_value::NEEDLESS_PASS_BY_VALUE_INFO,
+    crate::needless_question_mark::NEEDLESS_QUESTION_MARK_INFO,
+    crate::needless_update::NEEDLESS_UPDATE_INFO,
+    crate::neg_cmp_op_on_partial_ord::NEG_CMP_OP_ON_PARTIAL_ORD_INFO,
+    crate::neg_multiply::NEG_MULTIPLY_INFO,
+    crate::new_without_default::NEW_WITHOUT_DEFAULT_INFO,
+    crate::no_effect::NO_EFFECT_INFO,
+    crate::no_effect::NO_EFFECT_UNDERSCORE_BINDING_INFO,
+    crate::no_effect::UNNECESSARY_OPERATION_INFO,
+    crate::non_copy_const::BORROW_INTERIOR_MUTABLE_CONST_INFO,
+    crate::non_copy_const::DECLARE_INTERIOR_MUTABLE_CONST_INFO,
+    crate::non_expressive_names::JUST_UNDERSCORES_AND_DIGITS_INFO,
+    crate::non_expressive_names::MANY_SINGLE_CHAR_NAMES_INFO,
+    crate::non_expressive_names::SIMILAR_NAMES_INFO,
+    crate::non_octal_unix_permissions::NON_OCTAL_UNIX_PERMISSIONS_INFO,
+    crate::non_send_fields_in_send_ty::NON_SEND_FIELDS_IN_SEND_TY_INFO,
+    crate::nonstandard_macro_braces::NONSTANDARD_MACRO_BRACES_INFO,
+    crate::octal_escapes::OCTAL_ESCAPES_INFO,
+    crate::only_used_in_recursion::ONLY_USED_IN_RECURSION_INFO,
+    crate::operators::ABSURD_EXTREME_COMPARISONS_INFO,
+    crate::operators::ARITHMETIC_SIDE_EFFECTS_INFO,
+    crate::operators::ASSIGN_OP_PATTERN_INFO,
+    crate::operators::BAD_BIT_MASK_INFO,
+    crate::operators::CMP_NAN_INFO,
+    crate::operators::CMP_OWNED_INFO,
+    crate::operators::DOUBLE_COMPARISONS_INFO,
+    crate::operators::DURATION_SUBSEC_INFO,
+    crate::operators::EQ_OP_INFO,
+    crate::operators::ERASING_OP_INFO,
+    crate::operators::FLOAT_ARITHMETIC_INFO,
+    crate::operators::FLOAT_CMP_INFO,
+    crate::operators::FLOAT_CMP_CONST_INFO,
+    crate::operators::FLOAT_EQUALITY_WITHOUT_ABS_INFO,
+    crate::operators::IDENTITY_OP_INFO,
+    crate::operators::INEFFECTIVE_BIT_MASK_INFO,
+    crate::operators::INTEGER_ARITHMETIC_INFO,
+    crate::operators::INTEGER_DIVISION_INFO,
+    crate::operators::MISREFACTORED_ASSIGN_OP_INFO,
+    crate::operators::MODULO_ARITHMETIC_INFO,
+    crate::operators::MODULO_ONE_INFO,
+    crate::operators::NEEDLESS_BITWISE_BOOL_INFO,
+    crate::operators::OP_REF_INFO,
+    crate::operators::PTR_EQ_INFO,
+    crate::operators::SELF_ASSIGNMENT_INFO,
+    crate::operators::VERBOSE_BIT_MASK_INFO,
+    crate::option_env_unwrap::OPTION_ENV_UNWRAP_INFO,
+    crate::option_if_let_else::OPTION_IF_LET_ELSE_INFO,
+    crate::overflow_check_conditional::OVERFLOW_CHECK_CONDITIONAL_INFO,
+    crate::panic_in_result_fn::PANIC_IN_RESULT_FN_INFO,
+    crate::panic_unimplemented::PANIC_INFO,
+    crate::panic_unimplemented::TODO_INFO,
+    crate::panic_unimplemented::UNIMPLEMENTED_INFO,
+    crate::panic_unimplemented::UNREACHABLE_INFO,
+    crate::partial_pub_fields::PARTIAL_PUB_FIELDS_INFO,
+    crate::partialeq_ne_impl::PARTIALEQ_NE_IMPL_INFO,
+    crate::partialeq_to_none::PARTIALEQ_TO_NONE_INFO,
+    crate::pass_by_ref_or_value::LARGE_TYPES_PASSED_BY_VALUE_INFO,
+    crate::pass_by_ref_or_value::TRIVIALLY_COPY_PASS_BY_REF_INFO,
+    crate::pattern_type_mismatch::PATTERN_TYPE_MISMATCH_INFO,
+    crate::precedence::PRECEDENCE_INFO,
+    crate::ptr::CMP_NULL_INFO,
+    crate::ptr::INVALID_NULL_PTR_USAGE_INFO,
+    crate::ptr::MUT_FROM_REF_INFO,
+    crate::ptr::PTR_ARG_INFO,
+    crate::ptr_offset_with_cast::PTR_OFFSET_WITH_CAST_INFO,
+    crate::pub_use::PUB_USE_INFO,
+    crate::question_mark::QUESTION_MARK_INFO,
+    crate::ranges::MANUAL_RANGE_CONTAINS_INFO,
+    crate::ranges::RANGE_MINUS_ONE_INFO,
+    crate::ranges::RANGE_PLUS_ONE_INFO,
+    crate::ranges::REVERSED_EMPTY_RANGES_INFO,
+    crate::rc_clone_in_vec_init::RC_CLONE_IN_VEC_INIT_INFO,
+    crate::read_zero_byte_vec::READ_ZERO_BYTE_VEC_INFO,
+    crate::redundant_clone::REDUNDANT_CLONE_INFO,
+    crate::redundant_closure_call::REDUNDANT_CLOSURE_CALL_INFO,
+    crate::redundant_else::REDUNDANT_ELSE_INFO,
+    crate::redundant_field_names::REDUNDANT_FIELD_NAMES_INFO,
+    crate::redundant_pub_crate::REDUNDANT_PUB_CRATE_INFO,
+    crate::redundant_slicing::DEREF_BY_SLICING_INFO,
+    crate::redundant_slicing::REDUNDANT_SLICING_INFO,
+    crate::redundant_static_lifetimes::REDUNDANT_STATIC_LIFETIMES_INFO,
+    crate::ref_option_ref::REF_OPTION_REF_INFO,
+    crate::reference::DEREF_ADDROF_INFO,
+    crate::regex::INVALID_REGEX_INFO,
+    crate::regex::TRIVIAL_REGEX_INFO,
+    crate::return_self_not_must_use::RETURN_SELF_NOT_MUST_USE_INFO,
+    crate::returns::LET_AND_RETURN_INFO,
+    crate::returns::NEEDLESS_RETURN_INFO,
+    crate::same_name_method::SAME_NAME_METHOD_INFO,
+    crate::self_named_constructors::SELF_NAMED_CONSTRUCTORS_INFO,
+    crate::semicolon_if_nothing_returned::SEMICOLON_IF_NOTHING_RETURNED_INFO,
+    crate::serde_api::SERDE_API_MISUSE_INFO,
+    crate::shadow::SHADOW_REUSE_INFO,
+    crate::shadow::SHADOW_SAME_INFO,
+    crate::shadow::SHADOW_UNRELATED_INFO,
+    crate::single_char_lifetime_names::SINGLE_CHAR_LIFETIME_NAMES_INFO,
+    crate::single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS_INFO,
+    crate::size_of_in_element_count::SIZE_OF_IN_ELEMENT_COUNT_INFO,
+    crate::slow_vector_initialization::SLOW_VECTOR_INITIALIZATION_INFO,
+    crate::std_instead_of_core::ALLOC_INSTEAD_OF_CORE_INFO,
+    crate::std_instead_of_core::STD_INSTEAD_OF_ALLOC_INFO,
+    crate::std_instead_of_core::STD_INSTEAD_OF_CORE_INFO,
+    crate::strings::STRING_ADD_INFO,
+    crate::strings::STRING_ADD_ASSIGN_INFO,
+    crate::strings::STRING_FROM_UTF8_AS_BYTES_INFO,
+    crate::strings::STRING_LIT_AS_BYTES_INFO,
+    crate::strings::STRING_SLICE_INFO,
+    crate::strings::STRING_TO_STRING_INFO,
+    crate::strings::STR_TO_STRING_INFO,
+    crate::strings::TRIM_SPLIT_WHITESPACE_INFO,
+    crate::strlen_on_c_strings::STRLEN_ON_C_STRINGS_INFO,
+    crate::suspicious_operation_groupings::SUSPICIOUS_OPERATION_GROUPINGS_INFO,
+    crate::suspicious_trait_impl::SUSPICIOUS_ARITHMETIC_IMPL_INFO,
+    crate::suspicious_trait_impl::SUSPICIOUS_OP_ASSIGN_IMPL_INFO,
+    crate::swap::ALMOST_SWAPPED_INFO,
+    crate::swap::MANUAL_SWAP_INFO,
+    crate::swap_ptr_to_ref::SWAP_PTR_TO_REF_INFO,
+    crate::tabs_in_doc_comments::TABS_IN_DOC_COMMENTS_INFO,
+    crate::temporary_assignment::TEMPORARY_ASSIGNMENT_INFO,
+    crate::to_digit_is_some::TO_DIGIT_IS_SOME_INFO,
+    crate::trailing_empty_array::TRAILING_EMPTY_ARRAY_INFO,
+    crate::trait_bounds::TRAIT_DUPLICATION_IN_BOUNDS_INFO,
+    crate::trait_bounds::TYPE_REPETITION_IN_BOUNDS_INFO,
+    crate::transmute::CROSSPOINTER_TRANSMUTE_INFO,
+    crate::transmute::TRANSMUTES_EXPRESSIBLE_AS_PTR_CASTS_INFO,
+    crate::transmute::TRANSMUTE_BYTES_TO_STR_INFO,
+    crate::transmute::TRANSMUTE_FLOAT_TO_INT_INFO,
+    crate::transmute::TRANSMUTE_INT_TO_BOOL_INFO,
+    crate::transmute::TRANSMUTE_INT_TO_CHAR_INFO,
+    crate::transmute::TRANSMUTE_INT_TO_FLOAT_INFO,
+    crate::transmute::TRANSMUTE_NUM_TO_BYTES_INFO,
+    crate::transmute::TRANSMUTE_PTR_TO_PTR_INFO,
+    crate::transmute::TRANSMUTE_PTR_TO_REF_INFO,
+    crate::transmute::TRANSMUTE_UNDEFINED_REPR_INFO,
+    crate::transmute::TRANSMUTING_NULL_INFO,
+    crate::transmute::UNSOUND_COLLECTION_TRANSMUTE_INFO,
+    crate::transmute::USELESS_TRANSMUTE_INFO,
+    crate::transmute::WRONG_TRANSMUTE_INFO,
+    crate::types::BORROWED_BOX_INFO,
+    crate::types::BOX_COLLECTION_INFO,
+    crate::types::LINKEDLIST_INFO,
+    crate::types::OPTION_OPTION_INFO,
+    crate::types::RC_BUFFER_INFO,
+    crate::types::RC_MUTEX_INFO,
+    crate::types::REDUNDANT_ALLOCATION_INFO,
+    crate::types::TYPE_COMPLEXITY_INFO,
+    crate::types::VEC_BOX_INFO,
+    crate::undocumented_unsafe_blocks::UNDOCUMENTED_UNSAFE_BLOCKS_INFO,
+    crate::unicode::INVISIBLE_CHARACTERS_INFO,
+    crate::unicode::NON_ASCII_LITERAL_INFO,
+    crate::unicode::UNICODE_NOT_NFC_INFO,
+    crate::uninit_vec::UNINIT_VEC_INFO,
+    crate::unit_return_expecting_ord::UNIT_RETURN_EXPECTING_ORD_INFO,
+    crate::unit_types::LET_UNIT_VALUE_INFO,
+    crate::unit_types::UNIT_ARG_INFO,
+    crate::unit_types::UNIT_CMP_INFO,
+    crate::unnamed_address::FN_ADDRESS_COMPARISONS_INFO,
+    crate::unnamed_address::VTABLE_ADDRESS_COMPARISONS_INFO,
+    crate::unnecessary_owned_empty_strings::UNNECESSARY_OWNED_EMPTY_STRINGS_INFO,
+    crate::unnecessary_self_imports::UNNECESSARY_SELF_IMPORTS_INFO,
+    crate::unnecessary_wraps::UNNECESSARY_WRAPS_INFO,
+    crate::unnested_or_patterns::UNNESTED_OR_PATTERNS_INFO,
+    crate::unsafe_removed_from_name::UNSAFE_REMOVED_FROM_NAME_INFO,
+    crate::unused_async::UNUSED_ASYNC_INFO,
+    crate::unused_io_amount::UNUSED_IO_AMOUNT_INFO,
+    crate::unused_peekable::UNUSED_PEEKABLE_INFO,
+    crate::unused_rounding::UNUSED_ROUNDING_INFO,
+    crate::unused_self::UNUSED_SELF_INFO,
+    crate::unused_unit::UNUSED_UNIT_INFO,
+    crate::unwrap::PANICKING_UNWRAP_INFO,
+    crate::unwrap::UNNECESSARY_UNWRAP_INFO,
+    crate::unwrap_in_result::UNWRAP_IN_RESULT_INFO,
+    crate::upper_case_acronyms::UPPER_CASE_ACRONYMS_INFO,
+    crate::use_self::USE_SELF_INFO,
+    crate::useless_conversion::USELESS_CONVERSION_INFO,
+    crate::vec::USELESS_VEC_INFO,
+    crate::vec_init_then_push::VEC_INIT_THEN_PUSH_INFO,
+    crate::wildcard_imports::ENUM_GLOB_USE_INFO,
+    crate::wildcard_imports::WILDCARD_IMPORTS_INFO,
+    crate::write::PRINTLN_EMPTY_STRING_INFO,
+    crate::write::PRINT_LITERAL_INFO,
+    crate::write::PRINT_STDERR_INFO,
+    crate::write::PRINT_STDOUT_INFO,
+    crate::write::PRINT_WITH_NEWLINE_INFO,
+    crate::write::USE_DEBUG_INFO,
+    crate::write::WRITELN_EMPTY_STRING_INFO,
+    crate::write::WRITE_LITERAL_INFO,
+    crate::write::WRITE_WITH_NEWLINE_INFO,
+    crate::zero_div_zero::ZERO_DIVIDED_BY_ZERO_INFO,
+    crate::zero_sized_map_values::ZERO_SIZED_MAP_VALUES_INFO,
+];
diff --git a/clippy_lints/src/lib.register_all.rs b/clippy_lints/src/lib.register_all.rs
deleted file mode 100644
index 34fded26cfc..00000000000
--- a/clippy_lints/src/lib.register_all.rs
+++ /dev/null
@@ -1,370 +0,0 @@
-// This file was generated by `cargo dev update_lints`.
-// Use that command to update this file and do not edit by hand.
-// Manual edits will be overwritten.
-
-store.register_group(true, "clippy::all", Some("clippy_all"), vec![
-    LintId::of(almost_complete_letter_range::ALMOST_COMPLETE_LETTER_RANGE),
-    LintId::of(approx_const::APPROX_CONSTANT),
-    LintId::of(assertions_on_constants::ASSERTIONS_ON_CONSTANTS),
-    LintId::of(async_yields_async::ASYNC_YIELDS_ASYNC),
-    LintId::of(attrs::BLANKET_CLIPPY_RESTRICTION_LINTS),
-    LintId::of(attrs::DEPRECATED_CFG_ATTR),
-    LintId::of(attrs::DEPRECATED_SEMVER),
-    LintId::of(attrs::MISMATCHED_TARGET_OS),
-    LintId::of(attrs::USELESS_ATTRIBUTE),
-    LintId::of(await_holding_invalid::AWAIT_HOLDING_INVALID_TYPE),
-    LintId::of(await_holding_invalid::AWAIT_HOLDING_LOCK),
-    LintId::of(await_holding_invalid::AWAIT_HOLDING_REFCELL_REF),
-    LintId::of(blocks_in_if_conditions::BLOCKS_IN_IF_CONDITIONS),
-    LintId::of(bool_assert_comparison::BOOL_ASSERT_COMPARISON),
-    LintId::of(bool_to_int_with_if::BOOL_TO_INT_WITH_IF),
-    LintId::of(booleans::NONMINIMAL_BOOL),
-    LintId::of(booleans::OVERLY_COMPLEX_BOOL_EXPR),
-    LintId::of(borrow_deref_ref::BORROW_DEREF_REF),
-    LintId::of(box_default::BOX_DEFAULT),
-    LintId::of(casts::CAST_ABS_TO_UNSIGNED),
-    LintId::of(casts::CAST_ENUM_CONSTRUCTOR),
-    LintId::of(casts::CAST_ENUM_TRUNCATION),
-    LintId::of(casts::CAST_NAN_TO_INT),
-    LintId::of(casts::CAST_REF_TO_MUT),
-    LintId::of(casts::CAST_SLICE_DIFFERENT_SIZES),
-    LintId::of(casts::CAST_SLICE_FROM_RAW_PARTS),
-    LintId::of(casts::CHAR_LIT_AS_U8),
-    LintId::of(casts::FN_TO_NUMERIC_CAST),
-    LintId::of(casts::FN_TO_NUMERIC_CAST_WITH_TRUNCATION),
-    LintId::of(casts::UNNECESSARY_CAST),
-    LintId::of(collapsible_if::COLLAPSIBLE_ELSE_IF),
-    LintId::of(collapsible_if::COLLAPSIBLE_IF),
-    LintId::of(comparison_chain::COMPARISON_CHAIN),
-    LintId::of(copies::IFS_SAME_COND),
-    LintId::of(copies::IF_SAME_THEN_ELSE),
-    LintId::of(crate_in_macro_def::CRATE_IN_MACRO_DEF),
-    LintId::of(default::FIELD_REASSIGN_WITH_DEFAULT),
-    LintId::of(default_instead_of_iter_empty::DEFAULT_INSTEAD_OF_ITER_EMPTY),
-    LintId::of(dereference::EXPLICIT_AUTO_DEREF),
-    LintId::of(dereference::NEEDLESS_BORROW),
-    LintId::of(derivable_impls::DERIVABLE_IMPLS),
-    LintId::of(derive::DERIVE_HASH_XOR_EQ),
-    LintId::of(derive::DERIVE_ORD_XOR_PARTIAL_ORD),
-    LintId::of(disallowed_macros::DISALLOWED_MACROS),
-    LintId::of(disallowed_methods::DISALLOWED_METHODS),
-    LintId::of(disallowed_names::DISALLOWED_NAMES),
-    LintId::of(disallowed_types::DISALLOWED_TYPES),
-    LintId::of(doc::MISSING_SAFETY_DOC),
-    LintId::of(doc::NEEDLESS_DOCTEST_MAIN),
-    LintId::of(double_parens::DOUBLE_PARENS),
-    LintId::of(drop_forget_ref::DROP_COPY),
-    LintId::of(drop_forget_ref::DROP_NON_DROP),
-    LintId::of(drop_forget_ref::DROP_REF),
-    LintId::of(drop_forget_ref::FORGET_COPY),
-    LintId::of(drop_forget_ref::FORGET_NON_DROP),
-    LintId::of(drop_forget_ref::FORGET_REF),
-    LintId::of(drop_forget_ref::UNDROPPED_MANUALLY_DROPS),
-    LintId::of(duplicate_mod::DUPLICATE_MOD),
-    LintId::of(entry::MAP_ENTRY),
-    LintId::of(enum_clike::ENUM_CLIKE_UNPORTABLE_VARIANT),
-    LintId::of(enum_variants::ENUM_VARIANT_NAMES),
-    LintId::of(enum_variants::MODULE_INCEPTION),
-    LintId::of(escape::BOXED_LOCAL),
-    LintId::of(eta_reduction::REDUNDANT_CLOSURE),
-    LintId::of(explicit_write::EXPLICIT_WRITE),
-    LintId::of(float_literal::EXCESSIVE_PRECISION),
-    LintId::of(format::USELESS_FORMAT),
-    LintId::of(format_args::FORMAT_IN_FORMAT_ARGS),
-    LintId::of(format_args::TO_STRING_IN_FORMAT_ARGS),
-    LintId::of(format_args::UNINLINED_FORMAT_ARGS),
-    LintId::of(format_args::UNUSED_FORMAT_SPECS),
-    LintId::of(format_impl::PRINT_IN_FORMAT_IMPL),
-    LintId::of(format_impl::RECURSIVE_FORMAT_IMPL),
-    LintId::of(formatting::POSSIBLE_MISSING_COMMA),
-    LintId::of(formatting::SUSPICIOUS_ASSIGNMENT_FORMATTING),
-    LintId::of(formatting::SUSPICIOUS_ELSE_FORMATTING),
-    LintId::of(formatting::SUSPICIOUS_UNARY_OP_FORMATTING),
-    LintId::of(from_over_into::FROM_OVER_INTO),
-    LintId::of(from_raw_with_void_ptr::FROM_RAW_WITH_VOID_PTR),
-    LintId::of(from_str_radix_10::FROM_STR_RADIX_10),
-    LintId::of(functions::DOUBLE_MUST_USE),
-    LintId::of(functions::MUST_USE_UNIT),
-    LintId::of(functions::NOT_UNSAFE_PTR_ARG_DEREF),
-    LintId::of(functions::RESULT_LARGE_ERR),
-    LintId::of(functions::RESULT_UNIT_ERR),
-    LintId::of(functions::TOO_MANY_ARGUMENTS),
-    LintId::of(if_let_mutex::IF_LET_MUTEX),
-    LintId::of(implicit_saturating_add::IMPLICIT_SATURATING_ADD),
-    LintId::of(implicit_saturating_sub::IMPLICIT_SATURATING_SUB),
-    LintId::of(indexing_slicing::OUT_OF_BOUNDS_INDEXING),
-    LintId::of(infinite_iter::INFINITE_ITER),
-    LintId::of(inherent_to_string::INHERENT_TO_STRING),
-    LintId::of(inherent_to_string::INHERENT_TO_STRING_SHADOW_DISPLAY),
-    LintId::of(init_numbered_fields::INIT_NUMBERED_FIELDS),
-    LintId::of(inline_fn_without_body::INLINE_FN_WITHOUT_BODY),
-    LintId::of(int_plus_one::INT_PLUS_ONE),
-    LintId::of(invalid_utf8_in_unchecked::INVALID_UTF8_IN_UNCHECKED),
-    LintId::of(large_const_arrays::LARGE_CONST_ARRAYS),
-    LintId::of(large_enum_variant::LARGE_ENUM_VARIANT),
-    LintId::of(len_zero::COMPARISON_TO_EMPTY),
-    LintId::of(len_zero::LEN_WITHOUT_IS_EMPTY),
-    LintId::of(len_zero::LEN_ZERO),
-    LintId::of(let_underscore::LET_UNDERSCORE_LOCK),
-    LintId::of(lifetimes::EXTRA_UNUSED_LIFETIMES),
-    LintId::of(lifetimes::NEEDLESS_LIFETIMES),
-    LintId::of(literal_representation::INCONSISTENT_DIGIT_GROUPING),
-    LintId::of(literal_representation::MISTYPED_LITERAL_SUFFIXES),
-    LintId::of(literal_representation::UNUSUAL_BYTE_GROUPINGS),
-    LintId::of(loops::EMPTY_LOOP),
-    LintId::of(loops::EXPLICIT_COUNTER_LOOP),
-    LintId::of(loops::FOR_KV_MAP),
-    LintId::of(loops::ITER_NEXT_LOOP),
-    LintId::of(loops::MANUAL_FIND),
-    LintId::of(loops::MANUAL_FLATTEN),
-    LintId::of(loops::MANUAL_MEMCPY),
-    LintId::of(loops::MISSING_SPIN_LOOP),
-    LintId::of(loops::MUT_RANGE_BOUND),
-    LintId::of(loops::NEEDLESS_COLLECT),
-    LintId::of(loops::NEEDLESS_RANGE_LOOP),
-    LintId::of(loops::NEVER_LOOP),
-    LintId::of(loops::SAME_ITEM_PUSH),
-    LintId::of(loops::SINGLE_ELEMENT_LOOP),
-    LintId::of(loops::WHILE_IMMUTABLE_CONDITION),
-    LintId::of(loops::WHILE_LET_LOOP),
-    LintId::of(loops::WHILE_LET_ON_ITERATOR),
-    LintId::of(main_recursion::MAIN_RECURSION),
-    LintId::of(manual_async_fn::MANUAL_ASYNC_FN),
-    LintId::of(manual_bits::MANUAL_BITS),
-    LintId::of(manual_clamp::MANUAL_CLAMP),
-    LintId::of(manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE),
-    LintId::of(manual_rem_euclid::MANUAL_REM_EUCLID),
-    LintId::of(manual_retain::MANUAL_RETAIN),
-    LintId::of(manual_strip::MANUAL_STRIP),
-    LintId::of(map_unit_fn::OPTION_MAP_UNIT_FN),
-    LintId::of(map_unit_fn::RESULT_MAP_UNIT_FN),
-    LintId::of(match_result_ok::MATCH_RESULT_OK),
-    LintId::of(matches::COLLAPSIBLE_MATCH),
-    LintId::of(matches::INFALLIBLE_DESTRUCTURING_MATCH),
-    LintId::of(matches::MANUAL_FILTER),
-    LintId::of(matches::MANUAL_MAP),
-    LintId::of(matches::MANUAL_UNWRAP_OR),
-    LintId::of(matches::MATCH_AS_REF),
-    LintId::of(matches::MATCH_LIKE_MATCHES_MACRO),
-    LintId::of(matches::MATCH_OVERLAPPING_ARM),
-    LintId::of(matches::MATCH_REF_PATS),
-    LintId::of(matches::MATCH_SINGLE_BINDING),
-    LintId::of(matches::MATCH_STR_CASE_MISMATCH),
-    LintId::of(matches::NEEDLESS_MATCH),
-    LintId::of(matches::REDUNDANT_PATTERN_MATCHING),
-    LintId::of(matches::SINGLE_MATCH),
-    LintId::of(matches::WILDCARD_IN_OR_PATTERNS),
-    LintId::of(mem_replace::MEM_REPLACE_OPTION_WITH_NONE),
-    LintId::of(mem_replace::MEM_REPLACE_WITH_DEFAULT),
-    LintId::of(mem_replace::MEM_REPLACE_WITH_UNINIT),
-    LintId::of(methods::BIND_INSTEAD_OF_MAP),
-    LintId::of(methods::BYTES_COUNT_TO_LEN),
-    LintId::of(methods::BYTES_NTH),
-    LintId::of(methods::CHARS_LAST_CMP),
-    LintId::of(methods::CHARS_NEXT_CMP),
-    LintId::of(methods::CLONE_DOUBLE_REF),
-    LintId::of(methods::CLONE_ON_COPY),
-    LintId::of(methods::COLLAPSIBLE_STR_REPLACE),
-    LintId::of(methods::ERR_EXPECT),
-    LintId::of(methods::EXPECT_FUN_CALL),
-    LintId::of(methods::EXTEND_WITH_DRAIN),
-    LintId::of(methods::FILTER_MAP_IDENTITY),
-    LintId::of(methods::FILTER_NEXT),
-    LintId::of(methods::FLAT_MAP_IDENTITY),
-    LintId::of(methods::GET_FIRST),
-    LintId::of(methods::GET_LAST_WITH_LEN),
-    LintId::of(methods::INSPECT_FOR_EACH),
-    LintId::of(methods::INTO_ITER_ON_REF),
-    LintId::of(methods::IS_DIGIT_ASCII_RADIX),
-    LintId::of(methods::ITERATOR_STEP_BY_ZERO),
-    LintId::of(methods::ITER_CLONED_COLLECT),
-    LintId::of(methods::ITER_COUNT),
-    LintId::of(methods::ITER_KV_MAP),
-    LintId::of(methods::ITER_NEXT_SLICE),
-    LintId::of(methods::ITER_NTH),
-    LintId::of(methods::ITER_NTH_ZERO),
-    LintId::of(methods::ITER_OVEREAGER_CLONED),
-    LintId::of(methods::ITER_SKIP_NEXT),
-    LintId::of(methods::MANUAL_FILTER_MAP),
-    LintId::of(methods::MANUAL_FIND_MAP),
-    LintId::of(methods::MANUAL_SATURATING_ARITHMETIC),
-    LintId::of(methods::MANUAL_SPLIT_ONCE),
-    LintId::of(methods::MANUAL_STR_REPEAT),
-    LintId::of(methods::MAP_CLONE),
-    LintId::of(methods::MAP_COLLECT_RESULT_UNIT),
-    LintId::of(methods::MAP_FLATTEN),
-    LintId::of(methods::MAP_IDENTITY),
-    LintId::of(methods::MUT_MUTEX_LOCK),
-    LintId::of(methods::NEEDLESS_OPTION_AS_DEREF),
-    LintId::of(methods::NEEDLESS_OPTION_TAKE),
-    LintId::of(methods::NEEDLESS_SPLITN),
-    LintId::of(methods::NEW_RET_NO_SELF),
-    LintId::of(methods::NONSENSICAL_OPEN_OPTIONS),
-    LintId::of(methods::NO_EFFECT_REPLACE),
-    LintId::of(methods::OBFUSCATED_IF_ELSE),
-    LintId::of(methods::OK_EXPECT),
-    LintId::of(methods::OPTION_AS_REF_DEREF),
-    LintId::of(methods::OPTION_FILTER_MAP),
-    LintId::of(methods::OPTION_MAP_OR_NONE),
-    LintId::of(methods::OR_FUN_CALL),
-    LintId::of(methods::OR_THEN_UNWRAP),
-    LintId::of(methods::RANGE_ZIP_WITH_LEN),
-    LintId::of(methods::REPEAT_ONCE),
-    LintId::of(methods::RESULT_MAP_OR_INTO_OPTION),
-    LintId::of(methods::SEARCH_IS_SOME),
-    LintId::of(methods::SHOULD_IMPLEMENT_TRAIT),
-    LintId::of(methods::SINGLE_CHAR_ADD_STR),
-    LintId::of(methods::SINGLE_CHAR_PATTERN),
-    LintId::of(methods::SKIP_WHILE_NEXT),
-    LintId::of(methods::STRING_EXTEND_CHARS),
-    LintId::of(methods::SUSPICIOUS_MAP),
-    LintId::of(methods::SUSPICIOUS_SPLITN),
-    LintId::of(methods::SUSPICIOUS_TO_OWNED),
-    LintId::of(methods::UNINIT_ASSUMED_INIT),
-    LintId::of(methods::UNIT_HASH),
-    LintId::of(methods::UNNECESSARY_FILTER_MAP),
-    LintId::of(methods::UNNECESSARY_FIND_MAP),
-    LintId::of(methods::UNNECESSARY_FOLD),
-    LintId::of(methods::UNNECESSARY_LAZY_EVALUATIONS),
-    LintId::of(methods::UNNECESSARY_SORT_BY),
-    LintId::of(methods::UNNECESSARY_TO_OWNED),
-    LintId::of(methods::UNWRAP_OR_ELSE_DEFAULT),
-    LintId::of(methods::USELESS_ASREF),
-    LintId::of(methods::VEC_RESIZE_TO_ZERO),
-    LintId::of(methods::WRONG_SELF_CONVENTION),
-    LintId::of(methods::ZST_OFFSET),
-    LintId::of(minmax::MIN_MAX),
-    LintId::of(misc::SHORT_CIRCUIT_STATEMENT),
-    LintId::of(misc::TOPLEVEL_REF_ARG),
-    LintId::of(misc::ZERO_PTR),
-    LintId::of(misc_early::BUILTIN_TYPE_SHADOW),
-    LintId::of(misc_early::DOUBLE_NEG),
-    LintId::of(misc_early::DUPLICATE_UNDERSCORE_ARGUMENT),
-    LintId::of(misc_early::MIXED_CASE_HEX_LITERALS),
-    LintId::of(misc_early::REDUNDANT_PATTERN),
-    LintId::of(misc_early::UNNEEDED_WILDCARD_PATTERN),
-    LintId::of(misc_early::ZERO_PREFIXED_LITERAL),
-    LintId::of(mixed_read_write_in_expression::DIVERGING_SUB_EXPRESSION),
-    LintId::of(multi_assignments::MULTI_ASSIGNMENTS),
-    LintId::of(mut_key::MUTABLE_KEY_TYPE),
-    LintId::of(mut_reference::UNNECESSARY_MUT_PASSED),
-    LintId::of(needless_arbitrary_self_type::NEEDLESS_ARBITRARY_SELF_TYPE),
-    LintId::of(needless_bool::BOOL_COMPARISON),
-    LintId::of(needless_bool::NEEDLESS_BOOL),
-    LintId::of(needless_borrowed_ref::NEEDLESS_BORROWED_REFERENCE),
-    LintId::of(needless_late_init::NEEDLESS_LATE_INIT),
-    LintId::of(needless_parens_on_range_literals::NEEDLESS_PARENS_ON_RANGE_LITERALS),
-    LintId::of(needless_question_mark::NEEDLESS_QUESTION_MARK),
-    LintId::of(needless_update::NEEDLESS_UPDATE),
-    LintId::of(neg_cmp_op_on_partial_ord::NEG_CMP_OP_ON_PARTIAL_ORD),
-    LintId::of(neg_multiply::NEG_MULTIPLY),
-    LintId::of(new_without_default::NEW_WITHOUT_DEFAULT),
-    LintId::of(no_effect::NO_EFFECT),
-    LintId::of(no_effect::UNNECESSARY_OPERATION),
-    LintId::of(non_copy_const::BORROW_INTERIOR_MUTABLE_CONST),
-    LintId::of(non_copy_const::DECLARE_INTERIOR_MUTABLE_CONST),
-    LintId::of(non_expressive_names::JUST_UNDERSCORES_AND_DIGITS),
-    LintId::of(non_octal_unix_permissions::NON_OCTAL_UNIX_PERMISSIONS),
-    LintId::of(octal_escapes::OCTAL_ESCAPES),
-    LintId::of(only_used_in_recursion::ONLY_USED_IN_RECURSION),
-    LintId::of(operators::ABSURD_EXTREME_COMPARISONS),
-    LintId::of(operators::ASSIGN_OP_PATTERN),
-    LintId::of(operators::BAD_BIT_MASK),
-    LintId::of(operators::CMP_NAN),
-    LintId::of(operators::CMP_OWNED),
-    LintId::of(operators::DOUBLE_COMPARISONS),
-    LintId::of(operators::DURATION_SUBSEC),
-    LintId::of(operators::EQ_OP),
-    LintId::of(operators::ERASING_OP),
-    LintId::of(operators::FLOAT_EQUALITY_WITHOUT_ABS),
-    LintId::of(operators::IDENTITY_OP),
-    LintId::of(operators::INEFFECTIVE_BIT_MASK),
-    LintId::of(operators::MISREFACTORED_ASSIGN_OP),
-    LintId::of(operators::MODULO_ONE),
-    LintId::of(operators::OP_REF),
-    LintId::of(operators::PTR_EQ),
-    LintId::of(operators::SELF_ASSIGNMENT),
-    LintId::of(option_env_unwrap::OPTION_ENV_UNWRAP),
-    LintId::of(overflow_check_conditional::OVERFLOW_CHECK_CONDITIONAL),
-    LintId::of(partialeq_ne_impl::PARTIALEQ_NE_IMPL),
-    LintId::of(partialeq_to_none::PARTIALEQ_TO_NONE),
-    LintId::of(precedence::PRECEDENCE),
-    LintId::of(ptr::CMP_NULL),
-    LintId::of(ptr::INVALID_NULL_PTR_USAGE),
-    LintId::of(ptr::MUT_FROM_REF),
-    LintId::of(ptr::PTR_ARG),
-    LintId::of(ptr_offset_with_cast::PTR_OFFSET_WITH_CAST),
-    LintId::of(question_mark::QUESTION_MARK),
-    LintId::of(ranges::MANUAL_RANGE_CONTAINS),
-    LintId::of(ranges::REVERSED_EMPTY_RANGES),
-    LintId::of(rc_clone_in_vec_init::RC_CLONE_IN_VEC_INIT),
-    LintId::of(read_zero_byte_vec::READ_ZERO_BYTE_VEC),
-    LintId::of(redundant_clone::REDUNDANT_CLONE),
-    LintId::of(redundant_closure_call::REDUNDANT_CLOSURE_CALL),
-    LintId::of(redundant_field_names::REDUNDANT_FIELD_NAMES),
-    LintId::of(redundant_slicing::REDUNDANT_SLICING),
-    LintId::of(redundant_static_lifetimes::REDUNDANT_STATIC_LIFETIMES),
-    LintId::of(reference::DEREF_ADDROF),
-    LintId::of(regex::INVALID_REGEX),
-    LintId::of(returns::LET_AND_RETURN),
-    LintId::of(returns::NEEDLESS_RETURN),
-    LintId::of(self_named_constructors::SELF_NAMED_CONSTRUCTORS),
-    LintId::of(serde_api::SERDE_API_MISUSE),
-    LintId::of(single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS),
-    LintId::of(size_of_in_element_count::SIZE_OF_IN_ELEMENT_COUNT),
-    LintId::of(slow_vector_initialization::SLOW_VECTOR_INITIALIZATION),
-    LintId::of(strings::STRING_FROM_UTF8_AS_BYTES),
-    LintId::of(strings::TRIM_SPLIT_WHITESPACE),
-    LintId::of(strlen_on_c_strings::STRLEN_ON_C_STRINGS),
-    LintId::of(suspicious_trait_impl::SUSPICIOUS_ARITHMETIC_IMPL),
-    LintId::of(suspicious_trait_impl::SUSPICIOUS_OP_ASSIGN_IMPL),
-    LintId::of(swap::ALMOST_SWAPPED),
-    LintId::of(swap::MANUAL_SWAP),
-    LintId::of(swap_ptr_to_ref::SWAP_PTR_TO_REF),
-    LintId::of(tabs_in_doc_comments::TABS_IN_DOC_COMMENTS),
-    LintId::of(temporary_assignment::TEMPORARY_ASSIGNMENT),
-    LintId::of(to_digit_is_some::TO_DIGIT_IS_SOME),
-    LintId::of(transmute::CROSSPOINTER_TRANSMUTE),
-    LintId::of(transmute::TRANSMUTES_EXPRESSIBLE_AS_PTR_CASTS),
-    LintId::of(transmute::TRANSMUTE_BYTES_TO_STR),
-    LintId::of(transmute::TRANSMUTE_FLOAT_TO_INT),
-    LintId::of(transmute::TRANSMUTE_INT_TO_BOOL),
-    LintId::of(transmute::TRANSMUTE_INT_TO_CHAR),
-    LintId::of(transmute::TRANSMUTE_INT_TO_FLOAT),
-    LintId::of(transmute::TRANSMUTE_NUM_TO_BYTES),
-    LintId::of(transmute::TRANSMUTE_PTR_TO_REF),
-    LintId::of(transmute::TRANSMUTING_NULL),
-    LintId::of(transmute::UNSOUND_COLLECTION_TRANSMUTE),
-    LintId::of(transmute::USELESS_TRANSMUTE),
-    LintId::of(transmute::WRONG_TRANSMUTE),
-    LintId::of(types::BORROWED_BOX),
-    LintId::of(types::BOX_COLLECTION),
-    LintId::of(types::REDUNDANT_ALLOCATION),
-    LintId::of(types::TYPE_COMPLEXITY),
-    LintId::of(types::VEC_BOX),
-    LintId::of(unicode::INVISIBLE_CHARACTERS),
-    LintId::of(uninit_vec::UNINIT_VEC),
-    LintId::of(unit_return_expecting_ord::UNIT_RETURN_EXPECTING_ORD),
-    LintId::of(unit_types::LET_UNIT_VALUE),
-    LintId::of(unit_types::UNIT_ARG),
-    LintId::of(unit_types::UNIT_CMP),
-    LintId::of(unnamed_address::FN_ADDRESS_COMPARISONS),
-    LintId::of(unnamed_address::VTABLE_ADDRESS_COMPARISONS),
-    LintId::of(unnecessary_owned_empty_strings::UNNECESSARY_OWNED_EMPTY_STRINGS),
-    LintId::of(unsafe_removed_from_name::UNSAFE_REMOVED_FROM_NAME),
-    LintId::of(unused_io_amount::UNUSED_IO_AMOUNT),
-    LintId::of(unused_unit::UNUSED_UNIT),
-    LintId::of(unwrap::PANICKING_UNWRAP),
-    LintId::of(unwrap::UNNECESSARY_UNWRAP),
-    LintId::of(upper_case_acronyms::UPPER_CASE_ACRONYMS),
-    LintId::of(useless_conversion::USELESS_CONVERSION),
-    LintId::of(vec::USELESS_VEC),
-    LintId::of(vec_init_then_push::VEC_INIT_THEN_PUSH),
-    LintId::of(write::PRINTLN_EMPTY_STRING),
-    LintId::of(write::PRINT_LITERAL),
-    LintId::of(write::PRINT_WITH_NEWLINE),
-    LintId::of(write::WRITELN_EMPTY_STRING),
-    LintId::of(write::WRITE_LITERAL),
-    LintId::of(write::WRITE_WITH_NEWLINE),
-    LintId::of(zero_div_zero::ZERO_DIVIDED_BY_ZERO),
-])
diff --git a/clippy_lints/src/lib.register_cargo.rs b/clippy_lints/src/lib.register_cargo.rs
deleted file mode 100644
index c890523fe5a..00000000000
--- a/clippy_lints/src/lib.register_cargo.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-// This file was generated by `cargo dev update_lints`.
-// Use that command to update this file and do not edit by hand.
-// Manual edits will be overwritten.
-
-store.register_group(true, "clippy::cargo", Some("clippy_cargo"), vec![
-    LintId::of(cargo::CARGO_COMMON_METADATA),
-    LintId::of(cargo::MULTIPLE_CRATE_VERSIONS),
-    LintId::of(cargo::NEGATIVE_FEATURE_NAMES),
-    LintId::of(cargo::REDUNDANT_FEATURE_NAMES),
-    LintId::of(cargo::WILDCARD_DEPENDENCIES),
-])
diff --git a/clippy_lints/src/lib.register_complexity.rs b/clippy_lints/src/lib.register_complexity.rs
deleted file mode 100644
index 8be9dc4baf1..00000000000
--- a/clippy_lints/src/lib.register_complexity.rs
+++ /dev/null
@@ -1,111 +0,0 @@
-// This file was generated by `cargo dev update_lints`.
-// Use that command to update this file and do not edit by hand.
-// Manual edits will be overwritten.
-
-store.register_group(true, "clippy::complexity", Some("clippy_complexity"), vec![
-    LintId::of(attrs::DEPRECATED_CFG_ATTR),
-    LintId::of(booleans::NONMINIMAL_BOOL),
-    LintId::of(borrow_deref_ref::BORROW_DEREF_REF),
-    LintId::of(casts::CHAR_LIT_AS_U8),
-    LintId::of(casts::UNNECESSARY_CAST),
-    LintId::of(dereference::EXPLICIT_AUTO_DEREF),
-    LintId::of(derivable_impls::DERIVABLE_IMPLS),
-    LintId::of(double_parens::DOUBLE_PARENS),
-    LintId::of(explicit_write::EXPLICIT_WRITE),
-    LintId::of(format::USELESS_FORMAT),
-    LintId::of(format_args::UNUSED_FORMAT_SPECS),
-    LintId::of(functions::TOO_MANY_ARGUMENTS),
-    LintId::of(int_plus_one::INT_PLUS_ONE),
-    LintId::of(lifetimes::EXTRA_UNUSED_LIFETIMES),
-    LintId::of(lifetimes::NEEDLESS_LIFETIMES),
-    LintId::of(loops::EXPLICIT_COUNTER_LOOP),
-    LintId::of(loops::MANUAL_FIND),
-    LintId::of(loops::MANUAL_FLATTEN),
-    LintId::of(loops::SINGLE_ELEMENT_LOOP),
-    LintId::of(loops::WHILE_LET_LOOP),
-    LintId::of(manual_clamp::MANUAL_CLAMP),
-    LintId::of(manual_rem_euclid::MANUAL_REM_EUCLID),
-    LintId::of(manual_strip::MANUAL_STRIP),
-    LintId::of(map_unit_fn::OPTION_MAP_UNIT_FN),
-    LintId::of(map_unit_fn::RESULT_MAP_UNIT_FN),
-    LintId::of(matches::MANUAL_FILTER),
-    LintId::of(matches::MANUAL_UNWRAP_OR),
-    LintId::of(matches::MATCH_AS_REF),
-    LintId::of(matches::MATCH_SINGLE_BINDING),
-    LintId::of(matches::NEEDLESS_MATCH),
-    LintId::of(matches::WILDCARD_IN_OR_PATTERNS),
-    LintId::of(methods::BIND_INSTEAD_OF_MAP),
-    LintId::of(methods::BYTES_COUNT_TO_LEN),
-    LintId::of(methods::CLONE_ON_COPY),
-    LintId::of(methods::FILTER_MAP_IDENTITY),
-    LintId::of(methods::FILTER_NEXT),
-    LintId::of(methods::FLAT_MAP_IDENTITY),
-    LintId::of(methods::GET_LAST_WITH_LEN),
-    LintId::of(methods::INSPECT_FOR_EACH),
-    LintId::of(methods::ITER_COUNT),
-    LintId::of(methods::ITER_KV_MAP),
-    LintId::of(methods::MANUAL_FILTER_MAP),
-    LintId::of(methods::MANUAL_FIND_MAP),
-    LintId::of(methods::MANUAL_SPLIT_ONCE),
-    LintId::of(methods::MAP_FLATTEN),
-    LintId::of(methods::MAP_IDENTITY),
-    LintId::of(methods::NEEDLESS_OPTION_AS_DEREF),
-    LintId::of(methods::NEEDLESS_OPTION_TAKE),
-    LintId::of(methods::NEEDLESS_SPLITN),
-    LintId::of(methods::OPTION_AS_REF_DEREF),
-    LintId::of(methods::OPTION_FILTER_MAP),
-    LintId::of(methods::OR_THEN_UNWRAP),
-    LintId::of(methods::RANGE_ZIP_WITH_LEN),
-    LintId::of(methods::REPEAT_ONCE),
-    LintId::of(methods::SEARCH_IS_SOME),
-    LintId::of(methods::SKIP_WHILE_NEXT),
-    LintId::of(methods::UNNECESSARY_FILTER_MAP),
-    LintId::of(methods::UNNECESSARY_FIND_MAP),
-    LintId::of(methods::UNNECESSARY_SORT_BY),
-    LintId::of(methods::USELESS_ASREF),
-    LintId::of(misc::SHORT_CIRCUIT_STATEMENT),
-    LintId::of(misc_early::UNNEEDED_WILDCARD_PATTERN),
-    LintId::of(misc_early::ZERO_PREFIXED_LITERAL),
-    LintId::of(mixed_read_write_in_expression::DIVERGING_SUB_EXPRESSION),
-    LintId::of(needless_arbitrary_self_type::NEEDLESS_ARBITRARY_SELF_TYPE),
-    LintId::of(needless_bool::BOOL_COMPARISON),
-    LintId::of(needless_bool::NEEDLESS_BOOL),
-    LintId::of(needless_borrowed_ref::NEEDLESS_BORROWED_REFERENCE),
-    LintId::of(needless_question_mark::NEEDLESS_QUESTION_MARK),
-    LintId::of(needless_update::NEEDLESS_UPDATE),
-    LintId::of(neg_cmp_op_on_partial_ord::NEG_CMP_OP_ON_PARTIAL_ORD),
-    LintId::of(no_effect::NO_EFFECT),
-    LintId::of(no_effect::UNNECESSARY_OPERATION),
-    LintId::of(only_used_in_recursion::ONLY_USED_IN_RECURSION),
-    LintId::of(operators::DOUBLE_COMPARISONS),
-    LintId::of(operators::DURATION_SUBSEC),
-    LintId::of(operators::IDENTITY_OP),
-    LintId::of(overflow_check_conditional::OVERFLOW_CHECK_CONDITIONAL),
-    LintId::of(partialeq_ne_impl::PARTIALEQ_NE_IMPL),
-    LintId::of(precedence::PRECEDENCE),
-    LintId::of(ptr_offset_with_cast::PTR_OFFSET_WITH_CAST),
-    LintId::of(redundant_closure_call::REDUNDANT_CLOSURE_CALL),
-    LintId::of(redundant_slicing::REDUNDANT_SLICING),
-    LintId::of(reference::DEREF_ADDROF),
-    LintId::of(strings::STRING_FROM_UTF8_AS_BYTES),
-    LintId::of(strlen_on_c_strings::STRLEN_ON_C_STRINGS),
-    LintId::of(swap::MANUAL_SWAP),
-    LintId::of(temporary_assignment::TEMPORARY_ASSIGNMENT),
-    LintId::of(transmute::CROSSPOINTER_TRANSMUTE),
-    LintId::of(transmute::TRANSMUTES_EXPRESSIBLE_AS_PTR_CASTS),
-    LintId::of(transmute::TRANSMUTE_BYTES_TO_STR),
-    LintId::of(transmute::TRANSMUTE_FLOAT_TO_INT),
-    LintId::of(transmute::TRANSMUTE_INT_TO_BOOL),
-    LintId::of(transmute::TRANSMUTE_INT_TO_CHAR),
-    LintId::of(transmute::TRANSMUTE_INT_TO_FLOAT),
-    LintId::of(transmute::TRANSMUTE_NUM_TO_BYTES),
-    LintId::of(transmute::TRANSMUTE_PTR_TO_REF),
-    LintId::of(transmute::USELESS_TRANSMUTE),
-    LintId::of(types::BORROWED_BOX),
-    LintId::of(types::TYPE_COMPLEXITY),
-    LintId::of(types::VEC_BOX),
-    LintId::of(unit_types::UNIT_ARG),
-    LintId::of(unwrap::UNNECESSARY_UNWRAP),
-    LintId::of(useless_conversion::USELESS_CONVERSION),
-    LintId::of(zero_div_zero::ZERO_DIVIDED_BY_ZERO),
-])
diff --git a/clippy_lints/src/lib.register_correctness.rs b/clippy_lints/src/lib.register_correctness.rs
deleted file mode 100644
index bb94037ec2e..00000000000
--- a/clippy_lints/src/lib.register_correctness.rs
+++ /dev/null
@@ -1,78 +0,0 @@
-// This file was generated by `cargo dev update_lints`.
-// Use that command to update this file and do not edit by hand.
-// Manual edits will be overwritten.
-
-store.register_group(true, "clippy::correctness", Some("clippy_correctness"), vec![
-    LintId::of(approx_const::APPROX_CONSTANT),
-    LintId::of(async_yields_async::ASYNC_YIELDS_ASYNC),
-    LintId::of(attrs::DEPRECATED_SEMVER),
-    LintId::of(attrs::MISMATCHED_TARGET_OS),
-    LintId::of(attrs::USELESS_ATTRIBUTE),
-    LintId::of(booleans::OVERLY_COMPLEX_BOOL_EXPR),
-    LintId::of(casts::CAST_REF_TO_MUT),
-    LintId::of(casts::CAST_SLICE_DIFFERENT_SIZES),
-    LintId::of(copies::IFS_SAME_COND),
-    LintId::of(copies::IF_SAME_THEN_ELSE),
-    LintId::of(derive::DERIVE_HASH_XOR_EQ),
-    LintId::of(derive::DERIVE_ORD_XOR_PARTIAL_ORD),
-    LintId::of(drop_forget_ref::DROP_COPY),
-    LintId::of(drop_forget_ref::DROP_REF),
-    LintId::of(drop_forget_ref::FORGET_COPY),
-    LintId::of(drop_forget_ref::FORGET_REF),
-    LintId::of(drop_forget_ref::UNDROPPED_MANUALLY_DROPS),
-    LintId::of(enum_clike::ENUM_CLIKE_UNPORTABLE_VARIANT),
-    LintId::of(format_impl::RECURSIVE_FORMAT_IMPL),
-    LintId::of(formatting::POSSIBLE_MISSING_COMMA),
-    LintId::of(functions::NOT_UNSAFE_PTR_ARG_DEREF),
-    LintId::of(if_let_mutex::IF_LET_MUTEX),
-    LintId::of(indexing_slicing::OUT_OF_BOUNDS_INDEXING),
-    LintId::of(infinite_iter::INFINITE_ITER),
-    LintId::of(inherent_to_string::INHERENT_TO_STRING_SHADOW_DISPLAY),
-    LintId::of(inline_fn_without_body::INLINE_FN_WITHOUT_BODY),
-    LintId::of(invalid_utf8_in_unchecked::INVALID_UTF8_IN_UNCHECKED),
-    LintId::of(let_underscore::LET_UNDERSCORE_LOCK),
-    LintId::of(literal_representation::MISTYPED_LITERAL_SUFFIXES),
-    LintId::of(loops::ITER_NEXT_LOOP),
-    LintId::of(loops::NEVER_LOOP),
-    LintId::of(loops::WHILE_IMMUTABLE_CONDITION),
-    LintId::of(matches::MATCH_STR_CASE_MISMATCH),
-    LintId::of(mem_replace::MEM_REPLACE_WITH_UNINIT),
-    LintId::of(methods::CLONE_DOUBLE_REF),
-    LintId::of(methods::ITERATOR_STEP_BY_ZERO),
-    LintId::of(methods::NONSENSICAL_OPEN_OPTIONS),
-    LintId::of(methods::SUSPICIOUS_SPLITN),
-    LintId::of(methods::UNINIT_ASSUMED_INIT),
-    LintId::of(methods::UNIT_HASH),
-    LintId::of(methods::VEC_RESIZE_TO_ZERO),
-    LintId::of(methods::ZST_OFFSET),
-    LintId::of(minmax::MIN_MAX),
-    LintId::of(non_octal_unix_permissions::NON_OCTAL_UNIX_PERMISSIONS),
-    LintId::of(operators::ABSURD_EXTREME_COMPARISONS),
-    LintId::of(operators::BAD_BIT_MASK),
-    LintId::of(operators::CMP_NAN),
-    LintId::of(operators::EQ_OP),
-    LintId::of(operators::ERASING_OP),
-    LintId::of(operators::INEFFECTIVE_BIT_MASK),
-    LintId::of(operators::MODULO_ONE),
-    LintId::of(operators::SELF_ASSIGNMENT),
-    LintId::of(option_env_unwrap::OPTION_ENV_UNWRAP),
-    LintId::of(ptr::INVALID_NULL_PTR_USAGE),
-    LintId::of(ptr::MUT_FROM_REF),
-    LintId::of(ranges::REVERSED_EMPTY_RANGES),
-    LintId::of(read_zero_byte_vec::READ_ZERO_BYTE_VEC),
-    LintId::of(regex::INVALID_REGEX),
-    LintId::of(serde_api::SERDE_API_MISUSE),
-    LintId::of(size_of_in_element_count::SIZE_OF_IN_ELEMENT_COUNT),
-    LintId::of(swap::ALMOST_SWAPPED),
-    LintId::of(transmute::TRANSMUTING_NULL),
-    LintId::of(transmute::UNSOUND_COLLECTION_TRANSMUTE),
-    LintId::of(transmute::WRONG_TRANSMUTE),
-    LintId::of(unicode::INVISIBLE_CHARACTERS),
-    LintId::of(uninit_vec::UNINIT_VEC),
-    LintId::of(unit_return_expecting_ord::UNIT_RETURN_EXPECTING_ORD),
-    LintId::of(unit_types::UNIT_CMP),
-    LintId::of(unnamed_address::FN_ADDRESS_COMPARISONS),
-    LintId::of(unnamed_address::VTABLE_ADDRESS_COMPARISONS),
-    LintId::of(unused_io_amount::UNUSED_IO_AMOUNT),
-    LintId::of(unwrap::PANICKING_UNWRAP),
-])
diff --git a/clippy_lints/src/lib.register_internal.rs b/clippy_lints/src/lib.register_internal.rs
deleted file mode 100644
index 40c94c6e8d3..00000000000
--- a/clippy_lints/src/lib.register_internal.rs
+++ /dev/null
@@ -1,22 +0,0 @@
-// This file was generated by `cargo dev update_lints`.
-// Use that command to update this file and do not edit by hand.
-// Manual edits will be overwritten.
-
-store.register_group(true, "clippy::internal", Some("clippy_internal"), vec![
-    LintId::of(utils::internal_lints::clippy_lints_internal::CLIPPY_LINTS_INTERNAL),
-    LintId::of(utils::internal_lints::collapsible_calls::COLLAPSIBLE_SPAN_LINT_CALLS),
-    LintId::of(utils::internal_lints::compiler_lint_functions::COMPILER_LINT_FUNCTIONS),
-    LintId::of(utils::internal_lints::if_chain_style::IF_CHAIN_STYLE),
-    LintId::of(utils::internal_lints::interning_defined_symbol::INTERNING_DEFINED_SYMBOL),
-    LintId::of(utils::internal_lints::interning_defined_symbol::UNNECESSARY_SYMBOL_STR),
-    LintId::of(utils::internal_lints::invalid_paths::INVALID_PATHS),
-    LintId::of(utils::internal_lints::lint_without_lint_pass::DEFAULT_DEPRECATION_REASON),
-    LintId::of(utils::internal_lints::lint_without_lint_pass::DEFAULT_LINT),
-    LintId::of(utils::internal_lints::lint_without_lint_pass::INVALID_CLIPPY_VERSION_ATTRIBUTE),
-    LintId::of(utils::internal_lints::lint_without_lint_pass::LINT_WITHOUT_LINT_PASS),
-    LintId::of(utils::internal_lints::lint_without_lint_pass::MISSING_CLIPPY_VERSION_ATTRIBUTE),
-    LintId::of(utils::internal_lints::msrv_attr_impl::MISSING_MSRV_ATTR_IMPL),
-    LintId::of(utils::internal_lints::outer_expn_data_pass::OUTER_EXPN_EXPN_DATA),
-    LintId::of(utils::internal_lints::produce_ice::PRODUCE_ICE),
-    LintId::of(utils::internal_lints::unnecessary_def_path::UNNECESSARY_DEF_PATH),
-])
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
deleted file mode 100644
index 6eaf17709a8..00000000000
--- a/clippy_lints/src/lib.register_lints.rs
+++ /dev/null
@@ -1,620 +0,0 @@
-// This file was generated by `cargo dev update_lints`.
-// Use that command to update this file and do not edit by hand.
-// Manual edits will be overwritten.
-
-store.register_lints(&[
-    #[cfg(feature = "internal")]
-    utils::internal_lints::clippy_lints_internal::CLIPPY_LINTS_INTERNAL,
-    #[cfg(feature = "internal")]
-    utils::internal_lints::collapsible_calls::COLLAPSIBLE_SPAN_LINT_CALLS,
-    #[cfg(feature = "internal")]
-    utils::internal_lints::compiler_lint_functions::COMPILER_LINT_FUNCTIONS,
-    #[cfg(feature = "internal")]
-    utils::internal_lints::if_chain_style::IF_CHAIN_STYLE,
-    #[cfg(feature = "internal")]
-    utils::internal_lints::interning_defined_symbol::INTERNING_DEFINED_SYMBOL,
-    #[cfg(feature = "internal")]
-    utils::internal_lints::interning_defined_symbol::UNNECESSARY_SYMBOL_STR,
-    #[cfg(feature = "internal")]
-    utils::internal_lints::invalid_paths::INVALID_PATHS,
-    #[cfg(feature = "internal")]
-    utils::internal_lints::lint_without_lint_pass::DEFAULT_DEPRECATION_REASON,
-    #[cfg(feature = "internal")]
-    utils::internal_lints::lint_without_lint_pass::DEFAULT_LINT,
-    #[cfg(feature = "internal")]
-    utils::internal_lints::lint_without_lint_pass::INVALID_CLIPPY_VERSION_ATTRIBUTE,
-    #[cfg(feature = "internal")]
-    utils::internal_lints::lint_without_lint_pass::LINT_WITHOUT_LINT_PASS,
-    #[cfg(feature = "internal")]
-    utils::internal_lints::lint_without_lint_pass::MISSING_CLIPPY_VERSION_ATTRIBUTE,
-    #[cfg(feature = "internal")]
-    utils::internal_lints::msrv_attr_impl::MISSING_MSRV_ATTR_IMPL,
-    #[cfg(feature = "internal")]
-    utils::internal_lints::outer_expn_data_pass::OUTER_EXPN_EXPN_DATA,
-    #[cfg(feature = "internal")]
-    utils::internal_lints::produce_ice::PRODUCE_ICE,
-    #[cfg(feature = "internal")]
-    utils::internal_lints::unnecessary_def_path::UNNECESSARY_DEF_PATH,
-    almost_complete_letter_range::ALMOST_COMPLETE_LETTER_RANGE,
-    approx_const::APPROX_CONSTANT,
-    as_conversions::AS_CONVERSIONS,
-    asm_syntax::INLINE_ASM_X86_ATT_SYNTAX,
-    asm_syntax::INLINE_ASM_X86_INTEL_SYNTAX,
-    assertions_on_constants::ASSERTIONS_ON_CONSTANTS,
-    assertions_on_result_states::ASSERTIONS_ON_RESULT_STATES,
-    async_yields_async::ASYNC_YIELDS_ASYNC,
-    attrs::ALLOW_ATTRIBUTES_WITHOUT_REASON,
-    attrs::BLANKET_CLIPPY_RESTRICTION_LINTS,
-    attrs::DEPRECATED_CFG_ATTR,
-    attrs::DEPRECATED_SEMVER,
-    attrs::EMPTY_LINE_AFTER_OUTER_ATTR,
-    attrs::INLINE_ALWAYS,
-    attrs::MISMATCHED_TARGET_OS,
-    attrs::USELESS_ATTRIBUTE,
-    await_holding_invalid::AWAIT_HOLDING_INVALID_TYPE,
-    await_holding_invalid::AWAIT_HOLDING_LOCK,
-    await_holding_invalid::AWAIT_HOLDING_REFCELL_REF,
-    blocks_in_if_conditions::BLOCKS_IN_IF_CONDITIONS,
-    bool_assert_comparison::BOOL_ASSERT_COMPARISON,
-    bool_to_int_with_if::BOOL_TO_INT_WITH_IF,
-    booleans::NONMINIMAL_BOOL,
-    booleans::OVERLY_COMPLEX_BOOL_EXPR,
-    borrow_deref_ref::BORROW_DEREF_REF,
-    box_default::BOX_DEFAULT,
-    cargo::CARGO_COMMON_METADATA,
-    cargo::MULTIPLE_CRATE_VERSIONS,
-    cargo::NEGATIVE_FEATURE_NAMES,
-    cargo::REDUNDANT_FEATURE_NAMES,
-    cargo::WILDCARD_DEPENDENCIES,
-    casts::AS_PTR_CAST_MUT,
-    casts::AS_UNDERSCORE,
-    casts::BORROW_AS_PTR,
-    casts::CAST_ABS_TO_UNSIGNED,
-    casts::CAST_ENUM_CONSTRUCTOR,
-    casts::CAST_ENUM_TRUNCATION,
-    casts::CAST_LOSSLESS,
-    casts::CAST_NAN_TO_INT,
-    casts::CAST_POSSIBLE_TRUNCATION,
-    casts::CAST_POSSIBLE_WRAP,
-    casts::CAST_PRECISION_LOSS,
-    casts::CAST_PTR_ALIGNMENT,
-    casts::CAST_REF_TO_MUT,
-    casts::CAST_SIGN_LOSS,
-    casts::CAST_SLICE_DIFFERENT_SIZES,
-    casts::CAST_SLICE_FROM_RAW_PARTS,
-    casts::CHAR_LIT_AS_U8,
-    casts::FN_TO_NUMERIC_CAST,
-    casts::FN_TO_NUMERIC_CAST_ANY,
-    casts::FN_TO_NUMERIC_CAST_WITH_TRUNCATION,
-    casts::PTR_AS_PTR,
-    casts::UNNECESSARY_CAST,
-    checked_conversions::CHECKED_CONVERSIONS,
-    cognitive_complexity::COGNITIVE_COMPLEXITY,
-    collapsible_if::COLLAPSIBLE_ELSE_IF,
-    collapsible_if::COLLAPSIBLE_IF,
-    comparison_chain::COMPARISON_CHAIN,
-    copies::BRANCHES_SHARING_CODE,
-    copies::IFS_SAME_COND,
-    copies::IF_SAME_THEN_ELSE,
-    copies::SAME_FUNCTIONS_IN_IF_CONDITION,
-    copy_iterator::COPY_ITERATOR,
-    crate_in_macro_def::CRATE_IN_MACRO_DEF,
-    create_dir::CREATE_DIR,
-    dbg_macro::DBG_MACRO,
-    default::DEFAULT_TRAIT_ACCESS,
-    default::FIELD_REASSIGN_WITH_DEFAULT,
-    default_instead_of_iter_empty::DEFAULT_INSTEAD_OF_ITER_EMPTY,
-    default_numeric_fallback::DEFAULT_NUMERIC_FALLBACK,
-    default_union_representation::DEFAULT_UNION_REPRESENTATION,
-    dereference::EXPLICIT_AUTO_DEREF,
-    dereference::EXPLICIT_DEREF_METHODS,
-    dereference::NEEDLESS_BORROW,
-    dereference::REF_BINDING_TO_REFERENCE,
-    derivable_impls::DERIVABLE_IMPLS,
-    derive::DERIVE_HASH_XOR_EQ,
-    derive::DERIVE_ORD_XOR_PARTIAL_ORD,
-    derive::DERIVE_PARTIAL_EQ_WITHOUT_EQ,
-    derive::EXPL_IMPL_CLONE_ON_COPY,
-    derive::UNSAFE_DERIVE_DESERIALIZE,
-    disallowed_macros::DISALLOWED_MACROS,
-    disallowed_methods::DISALLOWED_METHODS,
-    disallowed_names::DISALLOWED_NAMES,
-    disallowed_script_idents::DISALLOWED_SCRIPT_IDENTS,
-    disallowed_types::DISALLOWED_TYPES,
-    doc::DOC_LINK_WITH_QUOTES,
-    doc::DOC_MARKDOWN,
-    doc::MISSING_ERRORS_DOC,
-    doc::MISSING_PANICS_DOC,
-    doc::MISSING_SAFETY_DOC,
-    doc::NEEDLESS_DOCTEST_MAIN,
-    double_parens::DOUBLE_PARENS,
-    drop_forget_ref::DROP_COPY,
-    drop_forget_ref::DROP_NON_DROP,
-    drop_forget_ref::DROP_REF,
-    drop_forget_ref::FORGET_COPY,
-    drop_forget_ref::FORGET_NON_DROP,
-    drop_forget_ref::FORGET_REF,
-    drop_forget_ref::UNDROPPED_MANUALLY_DROPS,
-    duplicate_mod::DUPLICATE_MOD,
-    else_if_without_else::ELSE_IF_WITHOUT_ELSE,
-    empty_drop::EMPTY_DROP,
-    empty_enum::EMPTY_ENUM,
-    empty_structs_with_brackets::EMPTY_STRUCTS_WITH_BRACKETS,
-    entry::MAP_ENTRY,
-    enum_clike::ENUM_CLIKE_UNPORTABLE_VARIANT,
-    enum_variants::ENUM_VARIANT_NAMES,
-    enum_variants::MODULE_INCEPTION,
-    enum_variants::MODULE_NAME_REPETITIONS,
-    equatable_if_let::EQUATABLE_IF_LET,
-    escape::BOXED_LOCAL,
-    eta_reduction::REDUNDANT_CLOSURE,
-    eta_reduction::REDUNDANT_CLOSURE_FOR_METHOD_CALLS,
-    excessive_bools::FN_PARAMS_EXCESSIVE_BOOLS,
-    excessive_bools::STRUCT_EXCESSIVE_BOOLS,
-    exhaustive_items::EXHAUSTIVE_ENUMS,
-    exhaustive_items::EXHAUSTIVE_STRUCTS,
-    exit::EXIT,
-    explicit_write::EXPLICIT_WRITE,
-    fallible_impl_from::FALLIBLE_IMPL_FROM,
-    float_literal::EXCESSIVE_PRECISION,
-    float_literal::LOSSY_FLOAT_LITERAL,
-    floating_point_arithmetic::IMPRECISE_FLOPS,
-    floating_point_arithmetic::SUBOPTIMAL_FLOPS,
-    format::USELESS_FORMAT,
-    format_args::FORMAT_IN_FORMAT_ARGS,
-    format_args::TO_STRING_IN_FORMAT_ARGS,
-    format_args::UNINLINED_FORMAT_ARGS,
-    format_args::UNUSED_FORMAT_SPECS,
-    format_impl::PRINT_IN_FORMAT_IMPL,
-    format_impl::RECURSIVE_FORMAT_IMPL,
-    format_push_string::FORMAT_PUSH_STRING,
-    formatting::POSSIBLE_MISSING_COMMA,
-    formatting::SUSPICIOUS_ASSIGNMENT_FORMATTING,
-    formatting::SUSPICIOUS_ELSE_FORMATTING,
-    formatting::SUSPICIOUS_UNARY_OP_FORMATTING,
-    from_over_into::FROM_OVER_INTO,
-    from_raw_with_void_ptr::FROM_RAW_WITH_VOID_PTR,
-    from_str_radix_10::FROM_STR_RADIX_10,
-    functions::DOUBLE_MUST_USE,
-    functions::MUST_USE_CANDIDATE,
-    functions::MUST_USE_UNIT,
-    functions::NOT_UNSAFE_PTR_ARG_DEREF,
-    functions::RESULT_LARGE_ERR,
-    functions::RESULT_UNIT_ERR,
-    functions::TOO_MANY_ARGUMENTS,
-    functions::TOO_MANY_LINES,
-    future_not_send::FUTURE_NOT_SEND,
-    if_let_mutex::IF_LET_MUTEX,
-    if_not_else::IF_NOT_ELSE,
-    if_then_some_else_none::IF_THEN_SOME_ELSE_NONE,
-    implicit_hasher::IMPLICIT_HASHER,
-    implicit_return::IMPLICIT_RETURN,
-    implicit_saturating_add::IMPLICIT_SATURATING_ADD,
-    implicit_saturating_sub::IMPLICIT_SATURATING_SUB,
-    inconsistent_struct_constructor::INCONSISTENT_STRUCT_CONSTRUCTOR,
-    index_refutable_slice::INDEX_REFUTABLE_SLICE,
-    indexing_slicing::INDEXING_SLICING,
-    indexing_slicing::OUT_OF_BOUNDS_INDEXING,
-    infinite_iter::INFINITE_ITER,
-    infinite_iter::MAYBE_INFINITE_ITER,
-    inherent_impl::MULTIPLE_INHERENT_IMPL,
-    inherent_to_string::INHERENT_TO_STRING,
-    inherent_to_string::INHERENT_TO_STRING_SHADOW_DISPLAY,
-    init_numbered_fields::INIT_NUMBERED_FIELDS,
-    inline_fn_without_body::INLINE_FN_WITHOUT_BODY,
-    int_plus_one::INT_PLUS_ONE,
-    invalid_upcast_comparisons::INVALID_UPCAST_COMPARISONS,
-    invalid_utf8_in_unchecked::INVALID_UTF8_IN_UNCHECKED,
-    items_after_statements::ITEMS_AFTER_STATEMENTS,
-    iter_not_returning_iterator::ITER_NOT_RETURNING_ITERATOR,
-    large_const_arrays::LARGE_CONST_ARRAYS,
-    large_enum_variant::LARGE_ENUM_VARIANT,
-    large_include_file::LARGE_INCLUDE_FILE,
-    large_stack_arrays::LARGE_STACK_ARRAYS,
-    len_zero::COMPARISON_TO_EMPTY,
-    len_zero::LEN_WITHOUT_IS_EMPTY,
-    len_zero::LEN_ZERO,
-    let_if_seq::USELESS_LET_IF_SEQ,
-    let_underscore::LET_UNDERSCORE_LOCK,
-    let_underscore::LET_UNDERSCORE_MUST_USE,
-    lifetimes::EXTRA_UNUSED_LIFETIMES,
-    lifetimes::NEEDLESS_LIFETIMES,
-    literal_representation::DECIMAL_LITERAL_REPRESENTATION,
-    literal_representation::INCONSISTENT_DIGIT_GROUPING,
-    literal_representation::LARGE_DIGIT_GROUPS,
-    literal_representation::MISTYPED_LITERAL_SUFFIXES,
-    literal_representation::UNREADABLE_LITERAL,
-    literal_representation::UNUSUAL_BYTE_GROUPINGS,
-    loops::EMPTY_LOOP,
-    loops::EXPLICIT_COUNTER_LOOP,
-    loops::EXPLICIT_INTO_ITER_LOOP,
-    loops::EXPLICIT_ITER_LOOP,
-    loops::FOR_KV_MAP,
-    loops::ITER_NEXT_LOOP,
-    loops::MANUAL_FIND,
-    loops::MANUAL_FLATTEN,
-    loops::MANUAL_MEMCPY,
-    loops::MISSING_SPIN_LOOP,
-    loops::MUT_RANGE_BOUND,
-    loops::NEEDLESS_COLLECT,
-    loops::NEEDLESS_RANGE_LOOP,
-    loops::NEVER_LOOP,
-    loops::SAME_ITEM_PUSH,
-    loops::SINGLE_ELEMENT_LOOP,
-    loops::WHILE_IMMUTABLE_CONDITION,
-    loops::WHILE_LET_LOOP,
-    loops::WHILE_LET_ON_ITERATOR,
-    macro_use::MACRO_USE_IMPORTS,
-    main_recursion::MAIN_RECURSION,
-    manual_assert::MANUAL_ASSERT,
-    manual_async_fn::MANUAL_ASYNC_FN,
-    manual_bits::MANUAL_BITS,
-    manual_clamp::MANUAL_CLAMP,
-    manual_instant_elapsed::MANUAL_INSTANT_ELAPSED,
-    manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE,
-    manual_rem_euclid::MANUAL_REM_EUCLID,
-    manual_retain::MANUAL_RETAIN,
-    manual_string_new::MANUAL_STRING_NEW,
-    manual_strip::MANUAL_STRIP,
-    map_unit_fn::OPTION_MAP_UNIT_FN,
-    map_unit_fn::RESULT_MAP_UNIT_FN,
-    match_result_ok::MATCH_RESULT_OK,
-    matches::COLLAPSIBLE_MATCH,
-    matches::INFALLIBLE_DESTRUCTURING_MATCH,
-    matches::MANUAL_FILTER,
-    matches::MANUAL_MAP,
-    matches::MANUAL_UNWRAP_OR,
-    matches::MATCH_AS_REF,
-    matches::MATCH_BOOL,
-    matches::MATCH_LIKE_MATCHES_MACRO,
-    matches::MATCH_ON_VEC_ITEMS,
-    matches::MATCH_OVERLAPPING_ARM,
-    matches::MATCH_REF_PATS,
-    matches::MATCH_SAME_ARMS,
-    matches::MATCH_SINGLE_BINDING,
-    matches::MATCH_STR_CASE_MISMATCH,
-    matches::MATCH_WILDCARD_FOR_SINGLE_VARIANTS,
-    matches::MATCH_WILD_ERR_ARM,
-    matches::NEEDLESS_MATCH,
-    matches::REDUNDANT_PATTERN_MATCHING,
-    matches::REST_PAT_IN_FULLY_BOUND_STRUCTS,
-    matches::SIGNIFICANT_DROP_IN_SCRUTINEE,
-    matches::SINGLE_MATCH,
-    matches::SINGLE_MATCH_ELSE,
-    matches::TRY_ERR,
-    matches::WILDCARD_ENUM_MATCH_ARM,
-    matches::WILDCARD_IN_OR_PATTERNS,
-    mem_forget::MEM_FORGET,
-    mem_replace::MEM_REPLACE_OPTION_WITH_NONE,
-    mem_replace::MEM_REPLACE_WITH_DEFAULT,
-    mem_replace::MEM_REPLACE_WITH_UNINIT,
-    methods::BIND_INSTEAD_OF_MAP,
-    methods::BYTES_COUNT_TO_LEN,
-    methods::BYTES_NTH,
-    methods::CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS,
-    methods::CHARS_LAST_CMP,
-    methods::CHARS_NEXT_CMP,
-    methods::CLONED_INSTEAD_OF_COPIED,
-    methods::CLONE_DOUBLE_REF,
-    methods::CLONE_ON_COPY,
-    methods::CLONE_ON_REF_PTR,
-    methods::COLLAPSIBLE_STR_REPLACE,
-    methods::ERR_EXPECT,
-    methods::EXPECT_FUN_CALL,
-    methods::EXPECT_USED,
-    methods::EXTEND_WITH_DRAIN,
-    methods::FILETYPE_IS_FILE,
-    methods::FILTER_MAP_IDENTITY,
-    methods::FILTER_MAP_NEXT,
-    methods::FILTER_NEXT,
-    methods::FLAT_MAP_IDENTITY,
-    methods::FLAT_MAP_OPTION,
-    methods::FROM_ITER_INSTEAD_OF_COLLECT,
-    methods::GET_FIRST,
-    methods::GET_LAST_WITH_LEN,
-    methods::GET_UNWRAP,
-    methods::IMPLICIT_CLONE,
-    methods::INEFFICIENT_TO_STRING,
-    methods::INSPECT_FOR_EACH,
-    methods::INTO_ITER_ON_REF,
-    methods::IS_DIGIT_ASCII_RADIX,
-    methods::ITERATOR_STEP_BY_ZERO,
-    methods::ITER_CLONED_COLLECT,
-    methods::ITER_COUNT,
-    methods::ITER_KV_MAP,
-    methods::ITER_NEXT_SLICE,
-    methods::ITER_NTH,
-    methods::ITER_NTH_ZERO,
-    methods::ITER_ON_EMPTY_COLLECTIONS,
-    methods::ITER_ON_SINGLE_ITEMS,
-    methods::ITER_OVEREAGER_CLONED,
-    methods::ITER_SKIP_NEXT,
-    methods::ITER_WITH_DRAIN,
-    methods::MANUAL_FILTER_MAP,
-    methods::MANUAL_FIND_MAP,
-    methods::MANUAL_OK_OR,
-    methods::MANUAL_SATURATING_ARITHMETIC,
-    methods::MANUAL_SPLIT_ONCE,
-    methods::MANUAL_STR_REPEAT,
-    methods::MAP_CLONE,
-    methods::MAP_COLLECT_RESULT_UNIT,
-    methods::MAP_ERR_IGNORE,
-    methods::MAP_FLATTEN,
-    methods::MAP_IDENTITY,
-    methods::MAP_UNWRAP_OR,
-    methods::MUT_MUTEX_LOCK,
-    methods::NAIVE_BYTECOUNT,
-    methods::NEEDLESS_OPTION_AS_DEREF,
-    methods::NEEDLESS_OPTION_TAKE,
-    methods::NEEDLESS_SPLITN,
-    methods::NEW_RET_NO_SELF,
-    methods::NONSENSICAL_OPEN_OPTIONS,
-    methods::NO_EFFECT_REPLACE,
-    methods::OBFUSCATED_IF_ELSE,
-    methods::OK_EXPECT,
-    methods::OPTION_AS_REF_DEREF,
-    methods::OPTION_FILTER_MAP,
-    methods::OPTION_MAP_OR_NONE,
-    methods::OR_FUN_CALL,
-    methods::OR_THEN_UNWRAP,
-    methods::PATH_BUF_PUSH_OVERWRITE,
-    methods::RANGE_ZIP_WITH_LEN,
-    methods::REPEAT_ONCE,
-    methods::RESULT_MAP_OR_INTO_OPTION,
-    methods::SEARCH_IS_SOME,
-    methods::SHOULD_IMPLEMENT_TRAIT,
-    methods::SINGLE_CHAR_ADD_STR,
-    methods::SINGLE_CHAR_PATTERN,
-    methods::SKIP_WHILE_NEXT,
-    methods::STABLE_SORT_PRIMITIVE,
-    methods::STRING_EXTEND_CHARS,
-    methods::SUSPICIOUS_MAP,
-    methods::SUSPICIOUS_SPLITN,
-    methods::SUSPICIOUS_TO_OWNED,
-    methods::UNINIT_ASSUMED_INIT,
-    methods::UNIT_HASH,
-    methods::UNNECESSARY_FILTER_MAP,
-    methods::UNNECESSARY_FIND_MAP,
-    methods::UNNECESSARY_FOLD,
-    methods::UNNECESSARY_JOIN,
-    methods::UNNECESSARY_LAZY_EVALUATIONS,
-    methods::UNNECESSARY_SORT_BY,
-    methods::UNNECESSARY_TO_OWNED,
-    methods::UNWRAP_OR_ELSE_DEFAULT,
-    methods::UNWRAP_USED,
-    methods::USELESS_ASREF,
-    methods::VEC_RESIZE_TO_ZERO,
-    methods::VERBOSE_FILE_READS,
-    methods::WRONG_SELF_CONVENTION,
-    methods::ZST_OFFSET,
-    minmax::MIN_MAX,
-    misc::SHORT_CIRCUIT_STATEMENT,
-    misc::TOPLEVEL_REF_ARG,
-    misc::USED_UNDERSCORE_BINDING,
-    misc::ZERO_PTR,
-    misc_early::BUILTIN_TYPE_SHADOW,
-    misc_early::DOUBLE_NEG,
-    misc_early::DUPLICATE_UNDERSCORE_ARGUMENT,
-    misc_early::MIXED_CASE_HEX_LITERALS,
-    misc_early::REDUNDANT_PATTERN,
-    misc_early::SEPARATED_LITERAL_SUFFIX,
-    misc_early::UNNEEDED_FIELD_PATTERN,
-    misc_early::UNNEEDED_WILDCARD_PATTERN,
-    misc_early::UNSEPARATED_LITERAL_SUFFIX,
-    misc_early::ZERO_PREFIXED_LITERAL,
-    mismatching_type_param_order::MISMATCHING_TYPE_PARAM_ORDER,
-    missing_const_for_fn::MISSING_CONST_FOR_FN,
-    missing_doc::MISSING_DOCS_IN_PRIVATE_ITEMS,
-    missing_enforced_import_rename::MISSING_ENFORCED_IMPORT_RENAMES,
-    missing_inline::MISSING_INLINE_IN_PUBLIC_ITEMS,
-    missing_trait_methods::MISSING_TRAIT_METHODS,
-    mixed_read_write_in_expression::DIVERGING_SUB_EXPRESSION,
-    mixed_read_write_in_expression::MIXED_READ_WRITE_IN_EXPRESSION,
-    module_style::MOD_MODULE_FILES,
-    module_style::SELF_NAMED_MODULE_FILES,
-    multi_assignments::MULTI_ASSIGNMENTS,
-    mut_key::MUTABLE_KEY_TYPE,
-    mut_mut::MUT_MUT,
-    mut_reference::UNNECESSARY_MUT_PASSED,
-    mutable_debug_assertion::DEBUG_ASSERT_WITH_MUT_CALL,
-    mutex_atomic::MUTEX_ATOMIC,
-    mutex_atomic::MUTEX_INTEGER,
-    needless_arbitrary_self_type::NEEDLESS_ARBITRARY_SELF_TYPE,
-    needless_bool::BOOL_COMPARISON,
-    needless_bool::NEEDLESS_BOOL,
-    needless_borrowed_ref::NEEDLESS_BORROWED_REFERENCE,
-    needless_continue::NEEDLESS_CONTINUE,
-    needless_for_each::NEEDLESS_FOR_EACH,
-    needless_late_init::NEEDLESS_LATE_INIT,
-    needless_parens_on_range_literals::NEEDLESS_PARENS_ON_RANGE_LITERALS,
-    needless_pass_by_value::NEEDLESS_PASS_BY_VALUE,
-    needless_question_mark::NEEDLESS_QUESTION_MARK,
-    needless_update::NEEDLESS_UPDATE,
-    neg_cmp_op_on_partial_ord::NEG_CMP_OP_ON_PARTIAL_ORD,
-    neg_multiply::NEG_MULTIPLY,
-    new_without_default::NEW_WITHOUT_DEFAULT,
-    no_effect::NO_EFFECT,
-    no_effect::NO_EFFECT_UNDERSCORE_BINDING,
-    no_effect::UNNECESSARY_OPERATION,
-    non_copy_const::BORROW_INTERIOR_MUTABLE_CONST,
-    non_copy_const::DECLARE_INTERIOR_MUTABLE_CONST,
-    non_expressive_names::JUST_UNDERSCORES_AND_DIGITS,
-    non_expressive_names::MANY_SINGLE_CHAR_NAMES,
-    non_expressive_names::SIMILAR_NAMES,
-    non_octal_unix_permissions::NON_OCTAL_UNIX_PERMISSIONS,
-    non_send_fields_in_send_ty::NON_SEND_FIELDS_IN_SEND_TY,
-    nonstandard_macro_braces::NONSTANDARD_MACRO_BRACES,
-    octal_escapes::OCTAL_ESCAPES,
-    only_used_in_recursion::ONLY_USED_IN_RECURSION,
-    operators::ABSURD_EXTREME_COMPARISONS,
-    operators::ARITHMETIC_SIDE_EFFECTS,
-    operators::ASSIGN_OP_PATTERN,
-    operators::BAD_BIT_MASK,
-    operators::CMP_NAN,
-    operators::CMP_OWNED,
-    operators::DOUBLE_COMPARISONS,
-    operators::DURATION_SUBSEC,
-    operators::EQ_OP,
-    operators::ERASING_OP,
-    operators::FLOAT_ARITHMETIC,
-    operators::FLOAT_CMP,
-    operators::FLOAT_CMP_CONST,
-    operators::FLOAT_EQUALITY_WITHOUT_ABS,
-    operators::IDENTITY_OP,
-    operators::INEFFECTIVE_BIT_MASK,
-    operators::INTEGER_ARITHMETIC,
-    operators::INTEGER_DIVISION,
-    operators::MISREFACTORED_ASSIGN_OP,
-    operators::MODULO_ARITHMETIC,
-    operators::MODULO_ONE,
-    operators::NEEDLESS_BITWISE_BOOL,
-    operators::OP_REF,
-    operators::PTR_EQ,
-    operators::SELF_ASSIGNMENT,
-    operators::VERBOSE_BIT_MASK,
-    option_env_unwrap::OPTION_ENV_UNWRAP,
-    option_if_let_else::OPTION_IF_LET_ELSE,
-    overflow_check_conditional::OVERFLOW_CHECK_CONDITIONAL,
-    panic_in_result_fn::PANIC_IN_RESULT_FN,
-    panic_unimplemented::PANIC,
-    panic_unimplemented::TODO,
-    panic_unimplemented::UNIMPLEMENTED,
-    panic_unimplemented::UNREACHABLE,
-    partial_pub_fields::PARTIAL_PUB_FIELDS,
-    partialeq_ne_impl::PARTIALEQ_NE_IMPL,
-    partialeq_to_none::PARTIALEQ_TO_NONE,
-    pass_by_ref_or_value::LARGE_TYPES_PASSED_BY_VALUE,
-    pass_by_ref_or_value::TRIVIALLY_COPY_PASS_BY_REF,
-    pattern_type_mismatch::PATTERN_TYPE_MISMATCH,
-    precedence::PRECEDENCE,
-    ptr::CMP_NULL,
-    ptr::INVALID_NULL_PTR_USAGE,
-    ptr::MUT_FROM_REF,
-    ptr::PTR_ARG,
-    ptr_offset_with_cast::PTR_OFFSET_WITH_CAST,
-    pub_use::PUB_USE,
-    question_mark::QUESTION_MARK,
-    ranges::MANUAL_RANGE_CONTAINS,
-    ranges::RANGE_MINUS_ONE,
-    ranges::RANGE_PLUS_ONE,
-    ranges::REVERSED_EMPTY_RANGES,
-    rc_clone_in_vec_init::RC_CLONE_IN_VEC_INIT,
-    read_zero_byte_vec::READ_ZERO_BYTE_VEC,
-    redundant_clone::REDUNDANT_CLONE,
-    redundant_closure_call::REDUNDANT_CLOSURE_CALL,
-    redundant_else::REDUNDANT_ELSE,
-    redundant_field_names::REDUNDANT_FIELD_NAMES,
-    redundant_pub_crate::REDUNDANT_PUB_CRATE,
-    redundant_slicing::DEREF_BY_SLICING,
-    redundant_slicing::REDUNDANT_SLICING,
-    redundant_static_lifetimes::REDUNDANT_STATIC_LIFETIMES,
-    ref_option_ref::REF_OPTION_REF,
-    reference::DEREF_ADDROF,
-    regex::INVALID_REGEX,
-    regex::TRIVIAL_REGEX,
-    return_self_not_must_use::RETURN_SELF_NOT_MUST_USE,
-    returns::LET_AND_RETURN,
-    returns::NEEDLESS_RETURN,
-    same_name_method::SAME_NAME_METHOD,
-    self_named_constructors::SELF_NAMED_CONSTRUCTORS,
-    semicolon_if_nothing_returned::SEMICOLON_IF_NOTHING_RETURNED,
-    serde_api::SERDE_API_MISUSE,
-    shadow::SHADOW_REUSE,
-    shadow::SHADOW_SAME,
-    shadow::SHADOW_UNRELATED,
-    single_char_lifetime_names::SINGLE_CHAR_LIFETIME_NAMES,
-    single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS,
-    size_of_in_element_count::SIZE_OF_IN_ELEMENT_COUNT,
-    slow_vector_initialization::SLOW_VECTOR_INITIALIZATION,
-    std_instead_of_core::ALLOC_INSTEAD_OF_CORE,
-    std_instead_of_core::STD_INSTEAD_OF_ALLOC,
-    std_instead_of_core::STD_INSTEAD_OF_CORE,
-    strings::STRING_ADD,
-    strings::STRING_ADD_ASSIGN,
-    strings::STRING_FROM_UTF8_AS_BYTES,
-    strings::STRING_LIT_AS_BYTES,
-    strings::STRING_SLICE,
-    strings::STRING_TO_STRING,
-    strings::STR_TO_STRING,
-    strings::TRIM_SPLIT_WHITESPACE,
-    strlen_on_c_strings::STRLEN_ON_C_STRINGS,
-    suspicious_operation_groupings::SUSPICIOUS_OPERATION_GROUPINGS,
-    suspicious_trait_impl::SUSPICIOUS_ARITHMETIC_IMPL,
-    suspicious_trait_impl::SUSPICIOUS_OP_ASSIGN_IMPL,
-    swap::ALMOST_SWAPPED,
-    swap::MANUAL_SWAP,
-    swap_ptr_to_ref::SWAP_PTR_TO_REF,
-    tabs_in_doc_comments::TABS_IN_DOC_COMMENTS,
-    temporary_assignment::TEMPORARY_ASSIGNMENT,
-    to_digit_is_some::TO_DIGIT_IS_SOME,
-    trailing_empty_array::TRAILING_EMPTY_ARRAY,
-    trait_bounds::TRAIT_DUPLICATION_IN_BOUNDS,
-    trait_bounds::TYPE_REPETITION_IN_BOUNDS,
-    transmute::CROSSPOINTER_TRANSMUTE,
-    transmute::TRANSMUTES_EXPRESSIBLE_AS_PTR_CASTS,
-    transmute::TRANSMUTE_BYTES_TO_STR,
-    transmute::TRANSMUTE_FLOAT_TO_INT,
-    transmute::TRANSMUTE_INT_TO_BOOL,
-    transmute::TRANSMUTE_INT_TO_CHAR,
-    transmute::TRANSMUTE_INT_TO_FLOAT,
-    transmute::TRANSMUTE_NUM_TO_BYTES,
-    transmute::TRANSMUTE_PTR_TO_PTR,
-    transmute::TRANSMUTE_PTR_TO_REF,
-    transmute::TRANSMUTE_UNDEFINED_REPR,
-    transmute::TRANSMUTING_NULL,
-    transmute::UNSOUND_COLLECTION_TRANSMUTE,
-    transmute::USELESS_TRANSMUTE,
-    transmute::WRONG_TRANSMUTE,
-    types::BORROWED_BOX,
-    types::BOX_COLLECTION,
-    types::LINKEDLIST,
-    types::OPTION_OPTION,
-    types::RC_BUFFER,
-    types::RC_MUTEX,
-    types::REDUNDANT_ALLOCATION,
-    types::TYPE_COMPLEXITY,
-    types::VEC_BOX,
-    undocumented_unsafe_blocks::UNDOCUMENTED_UNSAFE_BLOCKS,
-    unicode::INVISIBLE_CHARACTERS,
-    unicode::NON_ASCII_LITERAL,
-    unicode::UNICODE_NOT_NFC,
-    uninit_vec::UNINIT_VEC,
-    unit_return_expecting_ord::UNIT_RETURN_EXPECTING_ORD,
-    unit_types::LET_UNIT_VALUE,
-    unit_types::UNIT_ARG,
-    unit_types::UNIT_CMP,
-    unnamed_address::FN_ADDRESS_COMPARISONS,
-    unnamed_address::VTABLE_ADDRESS_COMPARISONS,
-    unnecessary_owned_empty_strings::UNNECESSARY_OWNED_EMPTY_STRINGS,
-    unnecessary_self_imports::UNNECESSARY_SELF_IMPORTS,
-    unnecessary_wraps::UNNECESSARY_WRAPS,
-    unnested_or_patterns::UNNESTED_OR_PATTERNS,
-    unsafe_removed_from_name::UNSAFE_REMOVED_FROM_NAME,
-    unused_async::UNUSED_ASYNC,
-    unused_io_amount::UNUSED_IO_AMOUNT,
-    unused_peekable::UNUSED_PEEKABLE,
-    unused_rounding::UNUSED_ROUNDING,
-    unused_self::UNUSED_SELF,
-    unused_unit::UNUSED_UNIT,
-    unwrap::PANICKING_UNWRAP,
-    unwrap::UNNECESSARY_UNWRAP,
-    unwrap_in_result::UNWRAP_IN_RESULT,
-    upper_case_acronyms::UPPER_CASE_ACRONYMS,
-    use_self::USE_SELF,
-    useless_conversion::USELESS_CONVERSION,
-    vec::USELESS_VEC,
-    vec_init_then_push::VEC_INIT_THEN_PUSH,
-    wildcard_imports::ENUM_GLOB_USE,
-    wildcard_imports::WILDCARD_IMPORTS,
-    write::PRINTLN_EMPTY_STRING,
-    write::PRINT_LITERAL,
-    write::PRINT_STDERR,
-    write::PRINT_STDOUT,
-    write::PRINT_WITH_NEWLINE,
-    write::USE_DEBUG,
-    write::WRITELN_EMPTY_STRING,
-    write::WRITE_LITERAL,
-    write::WRITE_WITH_NEWLINE,
-    zero_div_zero::ZERO_DIVIDED_BY_ZERO,
-    zero_sized_map_values::ZERO_SIZED_MAP_VALUES,
-])
diff --git a/clippy_lints/src/lib.register_nursery.rs b/clippy_lints/src/lib.register_nursery.rs
deleted file mode 100644
index a75bc81b222..00000000000
--- a/clippy_lints/src/lib.register_nursery.rs
+++ /dev/null
@@ -1,41 +0,0 @@
-// This file was generated by `cargo dev update_lints`.
-// Use that command to update this file and do not edit by hand.
-// Manual edits will be overwritten.
-
-store.register_group(true, "clippy::nursery", Some("clippy_nursery"), vec![
-    LintId::of(attrs::EMPTY_LINE_AFTER_OUTER_ATTR),
-    LintId::of(casts::AS_PTR_CAST_MUT),
-    LintId::of(cognitive_complexity::COGNITIVE_COMPLEXITY),
-    LintId::of(copies::BRANCHES_SHARING_CODE),
-    LintId::of(derive::DERIVE_PARTIAL_EQ_WITHOUT_EQ),
-    LintId::of(equatable_if_let::EQUATABLE_IF_LET),
-    LintId::of(fallible_impl_from::FALLIBLE_IMPL_FROM),
-    LintId::of(floating_point_arithmetic::IMPRECISE_FLOPS),
-    LintId::of(floating_point_arithmetic::SUBOPTIMAL_FLOPS),
-    LintId::of(future_not_send::FUTURE_NOT_SEND),
-    LintId::of(index_refutable_slice::INDEX_REFUTABLE_SLICE),
-    LintId::of(let_if_seq::USELESS_LET_IF_SEQ),
-    LintId::of(matches::SIGNIFICANT_DROP_IN_SCRUTINEE),
-    LintId::of(methods::ITER_ON_EMPTY_COLLECTIONS),
-    LintId::of(methods::ITER_ON_SINGLE_ITEMS),
-    LintId::of(methods::ITER_WITH_DRAIN),
-    LintId::of(methods::PATH_BUF_PUSH_OVERWRITE),
-    LintId::of(missing_const_for_fn::MISSING_CONST_FOR_FN),
-    LintId::of(mutable_debug_assertion::DEBUG_ASSERT_WITH_MUT_CALL),
-    LintId::of(mutex_atomic::MUTEX_ATOMIC),
-    LintId::of(mutex_atomic::MUTEX_INTEGER),
-    LintId::of(non_send_fields_in_send_ty::NON_SEND_FIELDS_IN_SEND_TY),
-    LintId::of(nonstandard_macro_braces::NONSTANDARD_MACRO_BRACES),
-    LintId::of(option_if_let_else::OPTION_IF_LET_ELSE),
-    LintId::of(redundant_pub_crate::REDUNDANT_PUB_CRATE),
-    LintId::of(regex::TRIVIAL_REGEX),
-    LintId::of(strings::STRING_LIT_AS_BYTES),
-    LintId::of(suspicious_operation_groupings::SUSPICIOUS_OPERATION_GROUPINGS),
-    LintId::of(trailing_empty_array::TRAILING_EMPTY_ARRAY),
-    LintId::of(trait_bounds::TRAIT_DUPLICATION_IN_BOUNDS),
-    LintId::of(trait_bounds::TYPE_REPETITION_IN_BOUNDS),
-    LintId::of(transmute::TRANSMUTE_UNDEFINED_REPR),
-    LintId::of(unused_peekable::UNUSED_PEEKABLE),
-    LintId::of(unused_rounding::UNUSED_ROUNDING),
-    LintId::of(use_self::USE_SELF),
-])
diff --git a/clippy_lints/src/lib.register_pedantic.rs b/clippy_lints/src/lib.register_pedantic.rs
deleted file mode 100644
index 768b3347c2a..00000000000
--- a/clippy_lints/src/lib.register_pedantic.rs
+++ /dev/null
@@ -1,100 +0,0 @@
-// This file was generated by `cargo dev update_lints`.
-// Use that command to update this file and do not edit by hand.
-// Manual edits will be overwritten.
-
-store.register_group(true, "clippy::pedantic", Some("clippy_pedantic"), vec![
-    LintId::of(attrs::INLINE_ALWAYS),
-    LintId::of(casts::BORROW_AS_PTR),
-    LintId::of(casts::CAST_LOSSLESS),
-    LintId::of(casts::CAST_POSSIBLE_TRUNCATION),
-    LintId::of(casts::CAST_POSSIBLE_WRAP),
-    LintId::of(casts::CAST_PRECISION_LOSS),
-    LintId::of(casts::CAST_PTR_ALIGNMENT),
-    LintId::of(casts::CAST_SIGN_LOSS),
-    LintId::of(casts::PTR_AS_PTR),
-    LintId::of(checked_conversions::CHECKED_CONVERSIONS),
-    LintId::of(copies::SAME_FUNCTIONS_IN_IF_CONDITION),
-    LintId::of(copy_iterator::COPY_ITERATOR),
-    LintId::of(default::DEFAULT_TRAIT_ACCESS),
-    LintId::of(dereference::EXPLICIT_DEREF_METHODS),
-    LintId::of(dereference::REF_BINDING_TO_REFERENCE),
-    LintId::of(derive::EXPL_IMPL_CLONE_ON_COPY),
-    LintId::of(derive::UNSAFE_DERIVE_DESERIALIZE),
-    LintId::of(doc::DOC_LINK_WITH_QUOTES),
-    LintId::of(doc::DOC_MARKDOWN),
-    LintId::of(doc::MISSING_ERRORS_DOC),
-    LintId::of(doc::MISSING_PANICS_DOC),
-    LintId::of(empty_enum::EMPTY_ENUM),
-    LintId::of(enum_variants::MODULE_NAME_REPETITIONS),
-    LintId::of(eta_reduction::REDUNDANT_CLOSURE_FOR_METHOD_CALLS),
-    LintId::of(excessive_bools::FN_PARAMS_EXCESSIVE_BOOLS),
-    LintId::of(excessive_bools::STRUCT_EXCESSIVE_BOOLS),
-    LintId::of(functions::MUST_USE_CANDIDATE),
-    LintId::of(functions::TOO_MANY_LINES),
-    LintId::of(if_not_else::IF_NOT_ELSE),
-    LintId::of(implicit_hasher::IMPLICIT_HASHER),
-    LintId::of(inconsistent_struct_constructor::INCONSISTENT_STRUCT_CONSTRUCTOR),
-    LintId::of(infinite_iter::MAYBE_INFINITE_ITER),
-    LintId::of(invalid_upcast_comparisons::INVALID_UPCAST_COMPARISONS),
-    LintId::of(items_after_statements::ITEMS_AFTER_STATEMENTS),
-    LintId::of(iter_not_returning_iterator::ITER_NOT_RETURNING_ITERATOR),
-    LintId::of(large_stack_arrays::LARGE_STACK_ARRAYS),
-    LintId::of(literal_representation::LARGE_DIGIT_GROUPS),
-    LintId::of(literal_representation::UNREADABLE_LITERAL),
-    LintId::of(loops::EXPLICIT_INTO_ITER_LOOP),
-    LintId::of(loops::EXPLICIT_ITER_LOOP),
-    LintId::of(macro_use::MACRO_USE_IMPORTS),
-    LintId::of(manual_assert::MANUAL_ASSERT),
-    LintId::of(manual_instant_elapsed::MANUAL_INSTANT_ELAPSED),
-    LintId::of(manual_string_new::MANUAL_STRING_NEW),
-    LintId::of(matches::MATCH_BOOL),
-    LintId::of(matches::MATCH_ON_VEC_ITEMS),
-    LintId::of(matches::MATCH_SAME_ARMS),
-    LintId::of(matches::MATCH_WILDCARD_FOR_SINGLE_VARIANTS),
-    LintId::of(matches::MATCH_WILD_ERR_ARM),
-    LintId::of(matches::SINGLE_MATCH_ELSE),
-    LintId::of(methods::CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS),
-    LintId::of(methods::CLONED_INSTEAD_OF_COPIED),
-    LintId::of(methods::FILTER_MAP_NEXT),
-    LintId::of(methods::FLAT_MAP_OPTION),
-    LintId::of(methods::FROM_ITER_INSTEAD_OF_COLLECT),
-    LintId::of(methods::IMPLICIT_CLONE),
-    LintId::of(methods::INEFFICIENT_TO_STRING),
-    LintId::of(methods::MANUAL_OK_OR),
-    LintId::of(methods::MAP_UNWRAP_OR),
-    LintId::of(methods::NAIVE_BYTECOUNT),
-    LintId::of(methods::STABLE_SORT_PRIMITIVE),
-    LintId::of(methods::UNNECESSARY_JOIN),
-    LintId::of(misc::USED_UNDERSCORE_BINDING),
-    LintId::of(mismatching_type_param_order::MISMATCHING_TYPE_PARAM_ORDER),
-    LintId::of(mut_mut::MUT_MUT),
-    LintId::of(needless_continue::NEEDLESS_CONTINUE),
-    LintId::of(needless_for_each::NEEDLESS_FOR_EACH),
-    LintId::of(needless_pass_by_value::NEEDLESS_PASS_BY_VALUE),
-    LintId::of(no_effect::NO_EFFECT_UNDERSCORE_BINDING),
-    LintId::of(non_expressive_names::MANY_SINGLE_CHAR_NAMES),
-    LintId::of(non_expressive_names::SIMILAR_NAMES),
-    LintId::of(operators::FLOAT_CMP),
-    LintId::of(operators::NEEDLESS_BITWISE_BOOL),
-    LintId::of(operators::VERBOSE_BIT_MASK),
-    LintId::of(pass_by_ref_or_value::LARGE_TYPES_PASSED_BY_VALUE),
-    LintId::of(pass_by_ref_or_value::TRIVIALLY_COPY_PASS_BY_REF),
-    LintId::of(ranges::RANGE_MINUS_ONE),
-    LintId::of(ranges::RANGE_PLUS_ONE),
-    LintId::of(redundant_else::REDUNDANT_ELSE),
-    LintId::of(ref_option_ref::REF_OPTION_REF),
-    LintId::of(return_self_not_must_use::RETURN_SELF_NOT_MUST_USE),
-    LintId::of(semicolon_if_nothing_returned::SEMICOLON_IF_NOTHING_RETURNED),
-    LintId::of(strings::STRING_ADD_ASSIGN),
-    LintId::of(transmute::TRANSMUTE_PTR_TO_PTR),
-    LintId::of(types::LINKEDLIST),
-    LintId::of(types::OPTION_OPTION),
-    LintId::of(unicode::UNICODE_NOT_NFC),
-    LintId::of(unnecessary_wraps::UNNECESSARY_WRAPS),
-    LintId::of(unnested_or_patterns::UNNESTED_OR_PATTERNS),
-    LintId::of(unused_async::UNUSED_ASYNC),
-    LintId::of(unused_self::UNUSED_SELF),
-    LintId::of(wildcard_imports::ENUM_GLOB_USE),
-    LintId::of(wildcard_imports::WILDCARD_IMPORTS),
-    LintId::of(zero_sized_map_values::ZERO_SIZED_MAP_VALUES),
-])
diff --git a/clippy_lints/src/lib.register_perf.rs b/clippy_lints/src/lib.register_perf.rs
deleted file mode 100644
index 8e927470e02..00000000000
--- a/clippy_lints/src/lib.register_perf.rs
+++ /dev/null
@@ -1,34 +0,0 @@
-// This file was generated by `cargo dev update_lints`.
-// Use that command to update this file and do not edit by hand.
-// Manual edits will be overwritten.
-
-store.register_group(true, "clippy::perf", Some("clippy_perf"), vec![
-    LintId::of(box_default::BOX_DEFAULT),
-    LintId::of(entry::MAP_ENTRY),
-    LintId::of(escape::BOXED_LOCAL),
-    LintId::of(format_args::FORMAT_IN_FORMAT_ARGS),
-    LintId::of(format_args::TO_STRING_IN_FORMAT_ARGS),
-    LintId::of(functions::RESULT_LARGE_ERR),
-    LintId::of(large_const_arrays::LARGE_CONST_ARRAYS),
-    LintId::of(large_enum_variant::LARGE_ENUM_VARIANT),
-    LintId::of(loops::MANUAL_MEMCPY),
-    LintId::of(loops::MISSING_SPIN_LOOP),
-    LintId::of(loops::NEEDLESS_COLLECT),
-    LintId::of(manual_retain::MANUAL_RETAIN),
-    LintId::of(methods::COLLAPSIBLE_STR_REPLACE),
-    LintId::of(methods::EXPECT_FUN_CALL),
-    LintId::of(methods::EXTEND_WITH_DRAIN),
-    LintId::of(methods::ITER_NTH),
-    LintId::of(methods::ITER_OVEREAGER_CLONED),
-    LintId::of(methods::MANUAL_STR_REPEAT),
-    LintId::of(methods::OR_FUN_CALL),
-    LintId::of(methods::SINGLE_CHAR_PATTERN),
-    LintId::of(methods::UNNECESSARY_TO_OWNED),
-    LintId::of(operators::CMP_OWNED),
-    LintId::of(redundant_clone::REDUNDANT_CLONE),
-    LintId::of(slow_vector_initialization::SLOW_VECTOR_INITIALIZATION),
-    LintId::of(types::BOX_COLLECTION),
-    LintId::of(types::REDUNDANT_ALLOCATION),
-    LintId::of(vec::USELESS_VEC),
-    LintId::of(vec_init_then_push::VEC_INIT_THEN_PUSH),
-])
diff --git a/clippy_lints/src/lib.register_restriction.rs b/clippy_lints/src/lib.register_restriction.rs
deleted file mode 100644
index f62d57af5b4..00000000000
--- a/clippy_lints/src/lib.register_restriction.rs
+++ /dev/null
@@ -1,90 +0,0 @@
-// This file was generated by `cargo dev update_lints`.
-// Use that command to update this file and do not edit by hand.
-// Manual edits will be overwritten.
-
-store.register_group(true, "clippy::restriction", Some("clippy_restriction"), vec![
-    LintId::of(as_conversions::AS_CONVERSIONS),
-    LintId::of(asm_syntax::INLINE_ASM_X86_ATT_SYNTAX),
-    LintId::of(asm_syntax::INLINE_ASM_X86_INTEL_SYNTAX),
-    LintId::of(assertions_on_result_states::ASSERTIONS_ON_RESULT_STATES),
-    LintId::of(attrs::ALLOW_ATTRIBUTES_WITHOUT_REASON),
-    LintId::of(casts::AS_UNDERSCORE),
-    LintId::of(casts::FN_TO_NUMERIC_CAST_ANY),
-    LintId::of(create_dir::CREATE_DIR),
-    LintId::of(dbg_macro::DBG_MACRO),
-    LintId::of(default_numeric_fallback::DEFAULT_NUMERIC_FALLBACK),
-    LintId::of(default_union_representation::DEFAULT_UNION_REPRESENTATION),
-    LintId::of(disallowed_script_idents::DISALLOWED_SCRIPT_IDENTS),
-    LintId::of(else_if_without_else::ELSE_IF_WITHOUT_ELSE),
-    LintId::of(empty_drop::EMPTY_DROP),
-    LintId::of(empty_structs_with_brackets::EMPTY_STRUCTS_WITH_BRACKETS),
-    LintId::of(exhaustive_items::EXHAUSTIVE_ENUMS),
-    LintId::of(exhaustive_items::EXHAUSTIVE_STRUCTS),
-    LintId::of(exit::EXIT),
-    LintId::of(float_literal::LOSSY_FLOAT_LITERAL),
-    LintId::of(format_push_string::FORMAT_PUSH_STRING),
-    LintId::of(if_then_some_else_none::IF_THEN_SOME_ELSE_NONE),
-    LintId::of(implicit_return::IMPLICIT_RETURN),
-    LintId::of(indexing_slicing::INDEXING_SLICING),
-    LintId::of(inherent_impl::MULTIPLE_INHERENT_IMPL),
-    LintId::of(large_include_file::LARGE_INCLUDE_FILE),
-    LintId::of(let_underscore::LET_UNDERSCORE_MUST_USE),
-    LintId::of(literal_representation::DECIMAL_LITERAL_REPRESENTATION),
-    LintId::of(matches::REST_PAT_IN_FULLY_BOUND_STRUCTS),
-    LintId::of(matches::TRY_ERR),
-    LintId::of(matches::WILDCARD_ENUM_MATCH_ARM),
-    LintId::of(mem_forget::MEM_FORGET),
-    LintId::of(methods::CLONE_ON_REF_PTR),
-    LintId::of(methods::EXPECT_USED),
-    LintId::of(methods::FILETYPE_IS_FILE),
-    LintId::of(methods::GET_UNWRAP),
-    LintId::of(methods::MAP_ERR_IGNORE),
-    LintId::of(methods::UNWRAP_USED),
-    LintId::of(methods::VERBOSE_FILE_READS),
-    LintId::of(misc_early::SEPARATED_LITERAL_SUFFIX),
-    LintId::of(misc_early::UNNEEDED_FIELD_PATTERN),
-    LintId::of(misc_early::UNSEPARATED_LITERAL_SUFFIX),
-    LintId::of(missing_doc::MISSING_DOCS_IN_PRIVATE_ITEMS),
-    LintId::of(missing_enforced_import_rename::MISSING_ENFORCED_IMPORT_RENAMES),
-    LintId::of(missing_inline::MISSING_INLINE_IN_PUBLIC_ITEMS),
-    LintId::of(missing_trait_methods::MISSING_TRAIT_METHODS),
-    LintId::of(mixed_read_write_in_expression::MIXED_READ_WRITE_IN_EXPRESSION),
-    LintId::of(module_style::MOD_MODULE_FILES),
-    LintId::of(module_style::SELF_NAMED_MODULE_FILES),
-    LintId::of(operators::ARITHMETIC_SIDE_EFFECTS),
-    LintId::of(operators::FLOAT_ARITHMETIC),
-    LintId::of(operators::FLOAT_CMP_CONST),
-    LintId::of(operators::INTEGER_ARITHMETIC),
-    LintId::of(operators::INTEGER_DIVISION),
-    LintId::of(operators::MODULO_ARITHMETIC),
-    LintId::of(panic_in_result_fn::PANIC_IN_RESULT_FN),
-    LintId::of(panic_unimplemented::PANIC),
-    LintId::of(panic_unimplemented::TODO),
-    LintId::of(panic_unimplemented::UNIMPLEMENTED),
-    LintId::of(panic_unimplemented::UNREACHABLE),
-    LintId::of(partial_pub_fields::PARTIAL_PUB_FIELDS),
-    LintId::of(pattern_type_mismatch::PATTERN_TYPE_MISMATCH),
-    LintId::of(pub_use::PUB_USE),
-    LintId::of(redundant_slicing::DEREF_BY_SLICING),
-    LintId::of(same_name_method::SAME_NAME_METHOD),
-    LintId::of(shadow::SHADOW_REUSE),
-    LintId::of(shadow::SHADOW_SAME),
-    LintId::of(shadow::SHADOW_UNRELATED),
-    LintId::of(single_char_lifetime_names::SINGLE_CHAR_LIFETIME_NAMES),
-    LintId::of(std_instead_of_core::ALLOC_INSTEAD_OF_CORE),
-    LintId::of(std_instead_of_core::STD_INSTEAD_OF_ALLOC),
-    LintId::of(std_instead_of_core::STD_INSTEAD_OF_CORE),
-    LintId::of(strings::STRING_ADD),
-    LintId::of(strings::STRING_SLICE),
-    LintId::of(strings::STRING_TO_STRING),
-    LintId::of(strings::STR_TO_STRING),
-    LintId::of(types::RC_BUFFER),
-    LintId::of(types::RC_MUTEX),
-    LintId::of(undocumented_unsafe_blocks::UNDOCUMENTED_UNSAFE_BLOCKS),
-    LintId::of(unicode::NON_ASCII_LITERAL),
-    LintId::of(unnecessary_self_imports::UNNECESSARY_SELF_IMPORTS),
-    LintId::of(unwrap_in_result::UNWRAP_IN_RESULT),
-    LintId::of(write::PRINT_STDERR),
-    LintId::of(write::PRINT_STDOUT),
-    LintId::of(write::USE_DEBUG),
-])
diff --git a/clippy_lints/src/lib.register_style.rs b/clippy_lints/src/lib.register_style.rs
deleted file mode 100644
index 6894d69e928..00000000000
--- a/clippy_lints/src/lib.register_style.rs
+++ /dev/null
@@ -1,132 +0,0 @@
-// This file was generated by `cargo dev update_lints`.
-// Use that command to update this file and do not edit by hand.
-// Manual edits will be overwritten.
-
-store.register_group(true, "clippy::style", Some("clippy_style"), vec![
-    LintId::of(assertions_on_constants::ASSERTIONS_ON_CONSTANTS),
-    LintId::of(blocks_in_if_conditions::BLOCKS_IN_IF_CONDITIONS),
-    LintId::of(bool_assert_comparison::BOOL_ASSERT_COMPARISON),
-    LintId::of(bool_to_int_with_if::BOOL_TO_INT_WITH_IF),
-    LintId::of(casts::FN_TO_NUMERIC_CAST),
-    LintId::of(casts::FN_TO_NUMERIC_CAST_WITH_TRUNCATION),
-    LintId::of(collapsible_if::COLLAPSIBLE_ELSE_IF),
-    LintId::of(collapsible_if::COLLAPSIBLE_IF),
-    LintId::of(comparison_chain::COMPARISON_CHAIN),
-    LintId::of(default::FIELD_REASSIGN_WITH_DEFAULT),
-    LintId::of(default_instead_of_iter_empty::DEFAULT_INSTEAD_OF_ITER_EMPTY),
-    LintId::of(dereference::NEEDLESS_BORROW),
-    LintId::of(disallowed_macros::DISALLOWED_MACROS),
-    LintId::of(disallowed_methods::DISALLOWED_METHODS),
-    LintId::of(disallowed_names::DISALLOWED_NAMES),
-    LintId::of(disallowed_types::DISALLOWED_TYPES),
-    LintId::of(doc::MISSING_SAFETY_DOC),
-    LintId::of(doc::NEEDLESS_DOCTEST_MAIN),
-    LintId::of(enum_variants::ENUM_VARIANT_NAMES),
-    LintId::of(enum_variants::MODULE_INCEPTION),
-    LintId::of(eta_reduction::REDUNDANT_CLOSURE),
-    LintId::of(float_literal::EXCESSIVE_PRECISION),
-    LintId::of(format_args::UNINLINED_FORMAT_ARGS),
-    LintId::of(from_over_into::FROM_OVER_INTO),
-    LintId::of(from_str_radix_10::FROM_STR_RADIX_10),
-    LintId::of(functions::DOUBLE_MUST_USE),
-    LintId::of(functions::MUST_USE_UNIT),
-    LintId::of(functions::RESULT_UNIT_ERR),
-    LintId::of(implicit_saturating_add::IMPLICIT_SATURATING_ADD),
-    LintId::of(implicit_saturating_sub::IMPLICIT_SATURATING_SUB),
-    LintId::of(inherent_to_string::INHERENT_TO_STRING),
-    LintId::of(init_numbered_fields::INIT_NUMBERED_FIELDS),
-    LintId::of(len_zero::COMPARISON_TO_EMPTY),
-    LintId::of(len_zero::LEN_WITHOUT_IS_EMPTY),
-    LintId::of(len_zero::LEN_ZERO),
-    LintId::of(literal_representation::INCONSISTENT_DIGIT_GROUPING),
-    LintId::of(literal_representation::UNUSUAL_BYTE_GROUPINGS),
-    LintId::of(loops::FOR_KV_MAP),
-    LintId::of(loops::NEEDLESS_RANGE_LOOP),
-    LintId::of(loops::SAME_ITEM_PUSH),
-    LintId::of(loops::WHILE_LET_ON_ITERATOR),
-    LintId::of(main_recursion::MAIN_RECURSION),
-    LintId::of(manual_async_fn::MANUAL_ASYNC_FN),
-    LintId::of(manual_bits::MANUAL_BITS),
-    LintId::of(manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE),
-    LintId::of(match_result_ok::MATCH_RESULT_OK),
-    LintId::of(matches::COLLAPSIBLE_MATCH),
-    LintId::of(matches::INFALLIBLE_DESTRUCTURING_MATCH),
-    LintId::of(matches::MANUAL_MAP),
-    LintId::of(matches::MATCH_LIKE_MATCHES_MACRO),
-    LintId::of(matches::MATCH_OVERLAPPING_ARM),
-    LintId::of(matches::MATCH_REF_PATS),
-    LintId::of(matches::REDUNDANT_PATTERN_MATCHING),
-    LintId::of(matches::SINGLE_MATCH),
-    LintId::of(mem_replace::MEM_REPLACE_OPTION_WITH_NONE),
-    LintId::of(mem_replace::MEM_REPLACE_WITH_DEFAULT),
-    LintId::of(methods::BYTES_NTH),
-    LintId::of(methods::CHARS_LAST_CMP),
-    LintId::of(methods::CHARS_NEXT_CMP),
-    LintId::of(methods::ERR_EXPECT),
-    LintId::of(methods::GET_FIRST),
-    LintId::of(methods::INTO_ITER_ON_REF),
-    LintId::of(methods::IS_DIGIT_ASCII_RADIX),
-    LintId::of(methods::ITER_CLONED_COLLECT),
-    LintId::of(methods::ITER_NEXT_SLICE),
-    LintId::of(methods::ITER_NTH_ZERO),
-    LintId::of(methods::ITER_SKIP_NEXT),
-    LintId::of(methods::MANUAL_SATURATING_ARITHMETIC),
-    LintId::of(methods::MAP_CLONE),
-    LintId::of(methods::MAP_COLLECT_RESULT_UNIT),
-    LintId::of(methods::MUT_MUTEX_LOCK),
-    LintId::of(methods::NEW_RET_NO_SELF),
-    LintId::of(methods::OBFUSCATED_IF_ELSE),
-    LintId::of(methods::OK_EXPECT),
-    LintId::of(methods::OPTION_MAP_OR_NONE),
-    LintId::of(methods::RESULT_MAP_OR_INTO_OPTION),
-    LintId::of(methods::SHOULD_IMPLEMENT_TRAIT),
-    LintId::of(methods::SINGLE_CHAR_ADD_STR),
-    LintId::of(methods::STRING_EXTEND_CHARS),
-    LintId::of(methods::UNNECESSARY_FOLD),
-    LintId::of(methods::UNNECESSARY_LAZY_EVALUATIONS),
-    LintId::of(methods::UNWRAP_OR_ELSE_DEFAULT),
-    LintId::of(methods::WRONG_SELF_CONVENTION),
-    LintId::of(misc::TOPLEVEL_REF_ARG),
-    LintId::of(misc::ZERO_PTR),
-    LintId::of(misc_early::BUILTIN_TYPE_SHADOW),
-    LintId::of(misc_early::DOUBLE_NEG),
-    LintId::of(misc_early::DUPLICATE_UNDERSCORE_ARGUMENT),
-    LintId::of(misc_early::MIXED_CASE_HEX_LITERALS),
-    LintId::of(misc_early::REDUNDANT_PATTERN),
-    LintId::of(mut_reference::UNNECESSARY_MUT_PASSED),
-    LintId::of(needless_late_init::NEEDLESS_LATE_INIT),
-    LintId::of(needless_parens_on_range_literals::NEEDLESS_PARENS_ON_RANGE_LITERALS),
-    LintId::of(neg_multiply::NEG_MULTIPLY),
-    LintId::of(new_without_default::NEW_WITHOUT_DEFAULT),
-    LintId::of(non_copy_const::BORROW_INTERIOR_MUTABLE_CONST),
-    LintId::of(non_copy_const::DECLARE_INTERIOR_MUTABLE_CONST),
-    LintId::of(non_expressive_names::JUST_UNDERSCORES_AND_DIGITS),
-    LintId::of(operators::ASSIGN_OP_PATTERN),
-    LintId::of(operators::OP_REF),
-    LintId::of(operators::PTR_EQ),
-    LintId::of(partialeq_to_none::PARTIALEQ_TO_NONE),
-    LintId::of(ptr::CMP_NULL),
-    LintId::of(ptr::PTR_ARG),
-    LintId::of(question_mark::QUESTION_MARK),
-    LintId::of(ranges::MANUAL_RANGE_CONTAINS),
-    LintId::of(redundant_field_names::REDUNDANT_FIELD_NAMES),
-    LintId::of(redundant_static_lifetimes::REDUNDANT_STATIC_LIFETIMES),
-    LintId::of(returns::LET_AND_RETURN),
-    LintId::of(returns::NEEDLESS_RETURN),
-    LintId::of(self_named_constructors::SELF_NAMED_CONSTRUCTORS),
-    LintId::of(single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS),
-    LintId::of(strings::TRIM_SPLIT_WHITESPACE),
-    LintId::of(tabs_in_doc_comments::TABS_IN_DOC_COMMENTS),
-    LintId::of(to_digit_is_some::TO_DIGIT_IS_SOME),
-    LintId::of(unit_types::LET_UNIT_VALUE),
-    LintId::of(unnecessary_owned_empty_strings::UNNECESSARY_OWNED_EMPTY_STRINGS),
-    LintId::of(unsafe_removed_from_name::UNSAFE_REMOVED_FROM_NAME),
-    LintId::of(unused_unit::UNUSED_UNIT),
-    LintId::of(upper_case_acronyms::UPPER_CASE_ACRONYMS),
-    LintId::of(write::PRINTLN_EMPTY_STRING),
-    LintId::of(write::PRINT_LITERAL),
-    LintId::of(write::PRINT_WITH_NEWLINE),
-    LintId::of(write::WRITELN_EMPTY_STRING),
-    LintId::of(write::WRITE_LITERAL),
-    LintId::of(write::WRITE_WITH_NEWLINE),
-])
diff --git a/clippy_lints/src/lib.register_suspicious.rs b/clippy_lints/src/lib.register_suspicious.rs
deleted file mode 100644
index 61af098c59a..00000000000
--- a/clippy_lints/src/lib.register_suspicious.rs
+++ /dev/null
@@ -1,39 +0,0 @@
-// This file was generated by `cargo dev update_lints`.
-// Use that command to update this file and do not edit by hand.
-// Manual edits will be overwritten.
-
-store.register_group(true, "clippy::suspicious", Some("clippy_suspicious"), vec![
-    LintId::of(almost_complete_letter_range::ALMOST_COMPLETE_LETTER_RANGE),
-    LintId::of(attrs::BLANKET_CLIPPY_RESTRICTION_LINTS),
-    LintId::of(await_holding_invalid::AWAIT_HOLDING_INVALID_TYPE),
-    LintId::of(await_holding_invalid::AWAIT_HOLDING_LOCK),
-    LintId::of(await_holding_invalid::AWAIT_HOLDING_REFCELL_REF),
-    LintId::of(casts::CAST_ABS_TO_UNSIGNED),
-    LintId::of(casts::CAST_ENUM_CONSTRUCTOR),
-    LintId::of(casts::CAST_ENUM_TRUNCATION),
-    LintId::of(casts::CAST_NAN_TO_INT),
-    LintId::of(casts::CAST_SLICE_FROM_RAW_PARTS),
-    LintId::of(crate_in_macro_def::CRATE_IN_MACRO_DEF),
-    LintId::of(drop_forget_ref::DROP_NON_DROP),
-    LintId::of(drop_forget_ref::FORGET_NON_DROP),
-    LintId::of(duplicate_mod::DUPLICATE_MOD),
-    LintId::of(format_impl::PRINT_IN_FORMAT_IMPL),
-    LintId::of(formatting::SUSPICIOUS_ASSIGNMENT_FORMATTING),
-    LintId::of(formatting::SUSPICIOUS_ELSE_FORMATTING),
-    LintId::of(formatting::SUSPICIOUS_UNARY_OP_FORMATTING),
-    LintId::of(from_raw_with_void_ptr::FROM_RAW_WITH_VOID_PTR),
-    LintId::of(loops::EMPTY_LOOP),
-    LintId::of(loops::MUT_RANGE_BOUND),
-    LintId::of(methods::NO_EFFECT_REPLACE),
-    LintId::of(methods::SUSPICIOUS_MAP),
-    LintId::of(methods::SUSPICIOUS_TO_OWNED),
-    LintId::of(multi_assignments::MULTI_ASSIGNMENTS),
-    LintId::of(mut_key::MUTABLE_KEY_TYPE),
-    LintId::of(octal_escapes::OCTAL_ESCAPES),
-    LintId::of(operators::FLOAT_EQUALITY_WITHOUT_ABS),
-    LintId::of(operators::MISREFACTORED_ASSIGN_OP),
-    LintId::of(rc_clone_in_vec_init::RC_CLONE_IN_VEC_INIT),
-    LintId::of(suspicious_trait_impl::SUSPICIOUS_ARITHMETIC_IMPL),
-    LintId::of(suspicious_trait_impl::SUSPICIOUS_OP_ASSIGN_IMPL),
-    LintId::of(swap_ptr_to_ref::SWAP_PTR_TO_REF),
-])
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 28248d01b64..7837e04bca1 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -46,122 +46,21 @@ extern crate rustc_trait_selection;
 
 #[macro_use]
 extern crate clippy_utils;
+#[macro_use]
+extern crate declare_clippy_lint;
 
 use clippy_utils::parse_msrv;
 use rustc_data_structures::fx::FxHashSet;
-use rustc_lint::LintId;
+use rustc_lint::{Lint, LintId};
 use rustc_semver::RustcVersion;
 use rustc_session::Session;
 
-/// Macro used to declare a Clippy lint.
-///
-/// Every lint declaration consists of 4 parts:
-///
-/// 1. The documentation, which is used for the website
-/// 2. The `LINT_NAME`. See [lint naming][lint_naming] on lint naming conventions.
-/// 3. The `lint_level`, which is a mapping from *one* of our lint groups to `Allow`, `Warn` or
-///    `Deny`. The lint level here has nothing to do with what lint groups the lint is a part of.
-/// 4. The `description` that contains a short explanation on what's wrong with code where the
-///    lint is triggered.
-///
-/// Currently the categories `style`, `correctness`, `suspicious`, `complexity` and `perf` are
-/// enabled by default. As said in the README.md of this repository, if the lint level mapping
-/// changes, please update README.md.
-///
-/// # Example
-///
-/// ```
-/// #![feature(rustc_private)]
-/// extern crate rustc_session;
-/// use rustc_session::declare_tool_lint;
-/// use clippy_lints::declare_clippy_lint;
-///
-/// declare_clippy_lint! {
-///     /// ### What it does
-///     /// Checks for ... (describe what the lint matches).
-///     ///
-///     /// ### Why is this bad?
-///     /// Supply the reason for linting the code.
-///     ///
-///     /// ### Example
-///     /// ```rust
-///     /// Insert a short example of code that triggers the lint
-///     /// ```
-///     ///
-///     /// Use instead:
-///     /// ```rust
-///     /// Insert a short example of improved code that doesn't trigger the lint
-///     /// ```
-///     pub LINT_NAME,
-///     pedantic,
-///     "description"
-/// }
-/// ```
-/// [lint_naming]: https://rust-lang.github.io/rfcs/0344-conventions-galore.html#lints
-#[macro_export]
-macro_rules! declare_clippy_lint {
-    { $(#[$attr:meta])* pub $name:tt, style, $description:tt } => {
-        declare_tool_lint! {
-            $(#[$attr])* pub clippy::$name, Warn, $description, report_in_external_macro: true
-        }
-    };
-    { $(#[$attr:meta])* pub $name:tt, correctness, $description:tt } => {
-        declare_tool_lint! {
-            $(#[$attr])* pub clippy::$name, Deny, $description, report_in_external_macro: true
-        }
-    };
-    { $(#[$attr:meta])* pub $name:tt, suspicious, $description:tt } => {
-        declare_tool_lint! {
-            $(#[$attr])* pub clippy::$name, Warn, $description, report_in_external_macro: true
-        }
-    };
-    { $(#[$attr:meta])* pub $name:tt, complexity, $description:tt } => {
-        declare_tool_lint! {
-            $(#[$attr])* pub clippy::$name, Warn, $description, report_in_external_macro: true
-        }
-    };
-    { $(#[$attr:meta])* pub $name:tt, perf, $description:tt } => {
-        declare_tool_lint! {
-            $(#[$attr])* pub clippy::$name, Warn, $description, report_in_external_macro: true
-        }
-    };
-    { $(#[$attr:meta])* pub $name:tt, pedantic, $description:tt } => {
-        declare_tool_lint! {
-            $(#[$attr])* pub clippy::$name, Allow, $description, report_in_external_macro: true
-        }
-    };
-    { $(#[$attr:meta])* pub $name:tt, restriction, $description:tt } => {
-        declare_tool_lint! {
-            $(#[$attr])* pub clippy::$name, Allow, $description, report_in_external_macro: true
-        }
-    };
-    { $(#[$attr:meta])* pub $name:tt, cargo, $description:tt } => {
-        declare_tool_lint! {
-            $(#[$attr])* pub clippy::$name, Allow, $description, report_in_external_macro: true
-        }
-    };
-    { $(#[$attr:meta])* pub $name:tt, nursery, $description:tt } => {
-        declare_tool_lint! {
-            $(#[$attr])* pub clippy::$name, Allow, $description, report_in_external_macro: true
-        }
-    };
-    { $(#[$attr:meta])* pub $name:tt, internal, $description:tt } => {
-        declare_tool_lint! {
-            $(#[$attr])* pub clippy::$name, Allow, $description, report_in_external_macro: true
-        }
-    };
-    { $(#[$attr:meta])* pub $name:tt, internal_warn, $description:tt } => {
-        declare_tool_lint! {
-            $(#[$attr])* pub clippy::$name, Warn, $description, report_in_external_macro: true
-        }
-    };
-}
-
 #[cfg(feature = "internal")]
 pub mod deprecated_lints;
 #[cfg_attr(feature = "internal", allow(clippy::missing_clippy_version_attribute))]
 mod utils;
 
+mod declared_lints;
 mod renamed_lints;
 
 // begin lints modules, do not remove this comment, it’s used in `update_lints`
@@ -495,31 +394,121 @@ pub fn read_conf(sess: &Session) -> Conf {
     conf
 }
 
+#[derive(Default)]
+struct RegistrationGroups {
+    all: Vec<LintId>,
+    cargo: Vec<LintId>,
+    complexity: Vec<LintId>,
+    correctness: Vec<LintId>,
+    nursery: Vec<LintId>,
+    pedantic: Vec<LintId>,
+    perf: Vec<LintId>,
+    restriction: Vec<LintId>,
+    style: Vec<LintId>,
+    suspicious: Vec<LintId>,
+    #[cfg(feature = "internal")]
+    internal: Vec<LintId>,
+}
+
+impl RegistrationGroups {
+    #[rustfmt::skip]
+    fn register(self, store: &mut rustc_lint::LintStore) {
+        store.register_group(true, "clippy::all", Some("clippy_all"), self.all);
+        store.register_group(true, "clippy::cargo", Some("clippy_cargo"), self.cargo);
+        store.register_group(true, "clippy::complexity", Some("clippy_complexity"), self.complexity);
+        store.register_group(true, "clippy::correctness", Some("clippy_correctness"), self.correctness);
+        store.register_group(true, "clippy::nursery", Some("clippy_nursery"), self.nursery);
+        store.register_group(true, "clippy::pedantic", Some("clippy_pedantic"), self.pedantic);
+        store.register_group(true, "clippy::perf", Some("clippy_perf"), self.perf);
+        store.register_group(true, "clippy::restriction", Some("clippy_restriction"), self.restriction);
+        store.register_group(true, "clippy::style", Some("clippy_style"), self.style);
+        store.register_group(true, "clippy::suspicious", Some("clippy_suspicious"), self.suspicious);
+        #[cfg(feature = "internal")]
+        store.register_group(true, "clippy::internal", Some("clippy_internal"), self.internal);
+    }
+}
+
+#[derive(Copy, Clone)]
+pub(crate) enum LintCategory {
+    Cargo,
+    Complexity,
+    Correctness,
+    Nursery,
+    Pedantic,
+    Perf,
+    Restriction,
+    Style,
+    Suspicious,
+    #[cfg(feature = "internal")]
+    Internal,
+}
+#[allow(clippy::enum_glob_use)]
+use LintCategory::*;
+
+impl LintCategory {
+    fn is_all(self) -> bool {
+        matches!(self, Correctness | Suspicious | Style | Complexity | Perf)
+    }
+
+    fn group(self, groups: &mut RegistrationGroups) -> &mut Vec<LintId> {
+        match self {
+            Cargo => &mut groups.cargo,
+            Complexity => &mut groups.complexity,
+            Correctness => &mut groups.correctness,
+            Nursery => &mut groups.nursery,
+            Pedantic => &mut groups.pedantic,
+            Perf => &mut groups.perf,
+            Restriction => &mut groups.restriction,
+            Style => &mut groups.style,
+            Suspicious => &mut groups.suspicious,
+            #[cfg(feature = "internal")]
+            Internal => &mut groups.internal,
+        }
+    }
+}
+
+pub(crate) struct LintInfo {
+    /// Double reference to maintain pointer equality
+    lint: &'static &'static Lint,
+    category: LintCategory,
+    explanation: &'static str,
+}
+
+pub fn explain(name: &str) {
+    let target = format!("clippy::{}", name.to_ascii_uppercase());
+    match declared_lints::LINTS.iter().find(|info| info.lint.name == target) {
+        Some(info) => print!("{}", info.explanation),
+        None => println!("unknown lint: {name}"),
+    }
+}
+
+fn register_categories(store: &mut rustc_lint::LintStore) {
+    let mut groups = RegistrationGroups::default();
+
+    for LintInfo { lint, category, .. } in declared_lints::LINTS {
+        if category.is_all() {
+            groups.all.push(LintId::of(lint));
+        }
+
+        category.group(&mut groups).push(LintId::of(lint));
+    }
+
+    let lints: Vec<&'static Lint> = declared_lints::LINTS.iter().map(|info| *info.lint).collect();
+
+    store.register_lints(&lints);
+    groups.register(store);
+}
+
 /// Register all lints and lint groups with the rustc plugin registry
 ///
 /// Used in `./src/driver.rs`.
 #[expect(clippy::too_many_lines)]
 pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf: &Conf) {
     register_removed_non_tool_lints(store);
+    register_categories(store);
 
     include!("lib.deprecated.rs");
 
-    include!("lib.register_lints.rs");
-    include!("lib.register_restriction.rs");
-    include!("lib.register_pedantic.rs");
-
-    #[cfg(feature = "internal")]
-    include!("lib.register_internal.rs");
-
-    include!("lib.register_all.rs");
-    include!("lib.register_style.rs");
-    include!("lib.register_complexity.rs");
-    include!("lib.register_correctness.rs");
-    include!("lib.register_suspicious.rs");
-    include!("lib.register_perf.rs");
-    include!("lib.register_cargo.rs");
-    include!("lib.register_nursery.rs");
-
     #[cfg(feature = "internal")]
     {
         if std::env::var("ENABLE_METADATA_COLLECTION").eq(&Ok("1".to_string())) {
diff --git a/declare_clippy_lint/Cargo.toml b/declare_clippy_lint/Cargo.toml
new file mode 100644
index 00000000000..68bb0be67a7
--- /dev/null
+++ b/declare_clippy_lint/Cargo.toml
@@ -0,0 +1,13 @@
+[package]
+name = "declare_clippy_lint"
+version = "0.1.66"
+edition = "2021"
+publish = false
+
+[lib]
+proc-macro = true
+
+[dependencies]
+itertools = "0.10.1"
+quote = "1.0.21"
+syn = "1.0.100"
diff --git a/declare_clippy_lint/src/lib.rs b/declare_clippy_lint/src/lib.rs
new file mode 100644
index 00000000000..962766916dd
--- /dev/null
+++ b/declare_clippy_lint/src/lib.rs
@@ -0,0 +1,173 @@
+#![feature(let_chains)]
+#![cfg_attr(feature = "deny-warnings", deny(warnings))]
+
+use proc_macro::TokenStream;
+use quote::{format_ident, quote};
+use syn::parse::{Parse, ParseStream};
+use syn::{parse_macro_input, Attribute, Error, Ident, Lit, LitStr, Meta, Result, Token};
+
+fn parse_attr<const LEN: usize>(path: [&'static str; LEN], attr: &Attribute) -> Option<LitStr> {
+    if let Meta::NameValue(name_value) = attr.parse_meta().ok()? {
+        let path_idents = name_value.path.segments.iter().map(|segment| &segment.ident);
+
+        if itertools::equal(path_idents, path)
+            && let Lit::Str(lit) = name_value.lit
+        {
+            return Some(lit);
+        }
+    }
+
+    None
+}
+
+struct ClippyLint {
+    attrs: Vec<Attribute>,
+    explanation: String,
+    name: Ident,
+    category: Ident,
+    description: LitStr,
+}
+
+impl Parse for ClippyLint {
+    fn parse(input: ParseStream) -> Result<Self> {
+        let attrs = input.call(Attribute::parse_outer)?;
+
+        let mut in_code = false;
+        let mut explanation = String::new();
+        let mut version = None;
+        for attr in &attrs {
+            if let Some(lit) = parse_attr(["doc"], attr) {
+                let value = lit.value();
+                let line = value.strip_prefix(' ').unwrap_or(&value);
+
+                if line.starts_with("```") {
+                    explanation += "```\n";
+                    in_code = !in_code;
+                } else if !(in_code && line.starts_with("# ")) {
+                    explanation += line;
+                    explanation.push('\n');
+                }
+            } else if let Some(lit) = parse_attr(["clippy", "version"], attr) {
+                if let Some(duplicate) = version.replace(lit) {
+                    return Err(Error::new_spanned(duplicate, "duplicate clippy::version"));
+                }
+            } else {
+                return Err(Error::new_spanned(attr, "unexpected attribute"));
+            }
+        }
+
+        input.parse::<Token![pub]>()?;
+        let name = input.parse()?;
+        input.parse::<Token![,]>()?;
+
+        let category = input.parse()?;
+        input.parse::<Token![,]>()?;
+
+        let description = input.parse()?;
+
+        Ok(Self {
+            attrs,
+            explanation,
+            name,
+            category,
+            description,
+        })
+    }
+}
+
+/// Macro used to declare a Clippy lint.
+///
+/// Every lint declaration consists of 4 parts:
+///
+/// 1. The documentation, which is used for the website and `cargo clippy --explain`
+/// 2. The `LINT_NAME`. See [lint naming][lint_naming] on lint naming conventions.
+/// 3. The `lint_level`, which is a mapping from *one* of our lint groups to `Allow`, `Warn` or
+///    `Deny`. The lint level here has nothing to do with what lint groups the lint is a part of.
+/// 4. The `description` that contains a short explanation on what's wrong with code where the
+///    lint is triggered.
+///
+/// Currently the categories `style`, `correctness`, `suspicious`, `complexity` and `perf` are
+/// enabled by default. As said in the README.md of this repository, if the lint level mapping
+/// changes, please update README.md.
+///
+/// # Example
+///
+/// ```
+/// use rustc_session::declare_tool_lint;
+///
+/// declare_clippy_lint! {
+///     /// ### What it does
+///     /// Checks for ... (describe what the lint matches).
+///     ///
+///     /// ### Why is this bad?
+///     /// Supply the reason for linting the code.
+///     ///
+///     /// ### Example
+///     /// ```rust
+///     /// Insert a short example of code that triggers the lint
+///     /// ```
+///     ///
+///     /// Use instead:
+///     /// ```rust
+///     /// Insert a short example of improved code that doesn't trigger the lint
+///     /// ```
+///     #[clippy::version = "1.65.0"]
+///     pub LINT_NAME,
+///     pedantic,
+///     "description"
+/// }
+/// ```
+/// [lint_naming]: https://rust-lang.github.io/rfcs/0344-conventions-galore.html#lints
+#[proc_macro]
+pub fn declare_clippy_lint(input: TokenStream) -> TokenStream {
+    let ClippyLint {
+        attrs,
+        explanation,
+        name,
+        category,
+        description,
+    } = parse_macro_input!(input as ClippyLint);
+
+    let mut category = category.to_string();
+
+    let level = format_ident!(
+        "{}",
+        match category.as_str() {
+            "correctness" => "Deny",
+            "style" | "suspicious" | "complexity" | "perf" | "internal_warn" => "Warn",
+            "pedantic" | "restriction" | "cargo" | "nursery" | "internal" => "Allow",
+            _ => panic!("unknown category {category}"),
+        },
+    );
+
+    let info = if category == "internal_warn" {
+        None
+    } else {
+        let info_name = format_ident!("{name}_INFO");
+
+        (&mut category[0..1]).make_ascii_uppercase();
+        let category_variant = format_ident!("{category}");
+
+        Some(quote! {
+            pub(crate) static #info_name: &'static crate::LintInfo = &crate::LintInfo {
+                lint: &#name,
+                category: crate::LintCategory::#category_variant,
+                explanation: #explanation,
+            };
+        })
+    };
+
+    let output = quote! {
+        declare_tool_lint! {
+            #(#attrs)*
+            pub clippy::#name,
+            #level,
+            #description,
+            report_in_external_macro: true
+        }
+
+        #info
+    };
+
+    TokenStream::from(output)
+}
diff --git a/src/docs.rs b/src/docs.rs
deleted file mode 100644
index d9c34a6c049..00000000000
--- a/src/docs.rs
+++ /dev/null
@@ -1,606 +0,0 @@
-// autogenerated. Please look at /clippy_dev/src/update_lints.rs
-
-macro_rules! include_lint {
-    ($file_name: expr) => {
-        include_str!($file_name)
-    };
-}
-
-macro_rules! docs {
-    ($($lint_name: expr,)*) => {
-        pub fn explain(lint: &str) {
-            println!("{}", match lint {
-                $(
-                    $lint_name => include_lint!(concat!("docs/", concat!($lint_name, ".txt"))),
-                )*
-                _ => "unknown lint",
-            })
-        }
-    }
-}
-
-docs! {
-    "absurd_extreme_comparisons",
-    "alloc_instead_of_core",
-    "allow_attributes_without_reason",
-    "almost_complete_letter_range",
-    "almost_swapped",
-    "approx_constant",
-    "arithmetic_side_effects",
-    "as_conversions",
-    "as_ptr_cast_mut",
-    "as_underscore",
-    "assertions_on_constants",
-    "assertions_on_result_states",
-    "assign_op_pattern",
-    "async_yields_async",
-    "await_holding_invalid_type",
-    "await_holding_lock",
-    "await_holding_refcell_ref",
-    "bad_bit_mask",
-    "bind_instead_of_map",
-    "blanket_clippy_restriction_lints",
-    "blocks_in_if_conditions",
-    "bool_assert_comparison",
-    "bool_comparison",
-    "bool_to_int_with_if",
-    "borrow_as_ptr",
-    "borrow_deref_ref",
-    "borrow_interior_mutable_const",
-    "borrowed_box",
-    "box_collection",
-    "box_default",
-    "boxed_local",
-    "branches_sharing_code",
-    "builtin_type_shadow",
-    "bytes_count_to_len",
-    "bytes_nth",
-    "cargo_common_metadata",
-    "case_sensitive_file_extension_comparisons",
-    "cast_abs_to_unsigned",
-    "cast_enum_constructor",
-    "cast_enum_truncation",
-    "cast_lossless",
-    "cast_nan_to_int",
-    "cast_possible_truncation",
-    "cast_possible_wrap",
-    "cast_precision_loss",
-    "cast_ptr_alignment",
-    "cast_ref_to_mut",
-    "cast_sign_loss",
-    "cast_slice_different_sizes",
-    "cast_slice_from_raw_parts",
-    "char_lit_as_u8",
-    "chars_last_cmp",
-    "chars_next_cmp",
-    "checked_conversions",
-    "clone_double_ref",
-    "clone_on_copy",
-    "clone_on_ref_ptr",
-    "cloned_instead_of_copied",
-    "cmp_nan",
-    "cmp_null",
-    "cmp_owned",
-    "cognitive_complexity",
-    "collapsible_else_if",
-    "collapsible_if",
-    "collapsible_match",
-    "collapsible_str_replace",
-    "comparison_chain",
-    "comparison_to_empty",
-    "copy_iterator",
-    "crate_in_macro_def",
-    "create_dir",
-    "crosspointer_transmute",
-    "dbg_macro",
-    "debug_assert_with_mut_call",
-    "decimal_literal_representation",
-    "declare_interior_mutable_const",
-    "default_instead_of_iter_empty",
-    "default_numeric_fallback",
-    "default_trait_access",
-    "default_union_representation",
-    "deprecated_cfg_attr",
-    "deprecated_semver",
-    "deref_addrof",
-    "deref_by_slicing",
-    "derivable_impls",
-    "derive_hash_xor_eq",
-    "derive_ord_xor_partial_ord",
-    "derive_partial_eq_without_eq",
-    "disallowed_macros",
-    "disallowed_methods",
-    "disallowed_names",
-    "disallowed_script_idents",
-    "disallowed_types",
-    "diverging_sub_expression",
-    "doc_link_with_quotes",
-    "doc_markdown",
-    "double_comparisons",
-    "double_must_use",
-    "double_neg",
-    "double_parens",
-    "drop_copy",
-    "drop_non_drop",
-    "drop_ref",
-    "duplicate_mod",
-    "duplicate_underscore_argument",
-    "duration_subsec",
-    "else_if_without_else",
-    "empty_drop",
-    "empty_enum",
-    "empty_line_after_outer_attr",
-    "empty_loop",
-    "empty_structs_with_brackets",
-    "enum_clike_unportable_variant",
-    "enum_glob_use",
-    "enum_variant_names",
-    "eq_op",
-    "equatable_if_let",
-    "erasing_op",
-    "err_expect",
-    "excessive_precision",
-    "exhaustive_enums",
-    "exhaustive_structs",
-    "exit",
-    "expect_fun_call",
-    "expect_used",
-    "expl_impl_clone_on_copy",
-    "explicit_auto_deref",
-    "explicit_counter_loop",
-    "explicit_deref_methods",
-    "explicit_into_iter_loop",
-    "explicit_iter_loop",
-    "explicit_write",
-    "extend_with_drain",
-    "extra_unused_lifetimes",
-    "fallible_impl_from",
-    "field_reassign_with_default",
-    "filetype_is_file",
-    "filter_map_identity",
-    "filter_map_next",
-    "filter_next",
-    "flat_map_identity",
-    "flat_map_option",
-    "float_arithmetic",
-    "float_cmp",
-    "float_cmp_const",
-    "float_equality_without_abs",
-    "fn_address_comparisons",
-    "fn_params_excessive_bools",
-    "fn_to_numeric_cast",
-    "fn_to_numeric_cast_any",
-    "fn_to_numeric_cast_with_truncation",
-    "for_kv_map",
-    "forget_copy",
-    "forget_non_drop",
-    "forget_ref",
-    "format_in_format_args",
-    "format_push_string",
-    "from_iter_instead_of_collect",
-    "from_over_into",
-    "from_raw_with_void_ptr",
-    "from_str_radix_10",
-    "future_not_send",
-    "get_first",
-    "get_last_with_len",
-    "get_unwrap",
-    "identity_op",
-    "if_let_mutex",
-    "if_not_else",
-    "if_same_then_else",
-    "if_then_some_else_none",
-    "ifs_same_cond",
-    "implicit_clone",
-    "implicit_hasher",
-    "implicit_return",
-    "implicit_saturating_add",
-    "implicit_saturating_sub",
-    "imprecise_flops",
-    "inconsistent_digit_grouping",
-    "inconsistent_struct_constructor",
-    "index_refutable_slice",
-    "indexing_slicing",
-    "ineffective_bit_mask",
-    "inefficient_to_string",
-    "infallible_destructuring_match",
-    "infinite_iter",
-    "inherent_to_string",
-    "inherent_to_string_shadow_display",
-    "init_numbered_fields",
-    "inline_always",
-    "inline_asm_x86_att_syntax",
-    "inline_asm_x86_intel_syntax",
-    "inline_fn_without_body",
-    "inspect_for_each",
-    "int_plus_one",
-    "integer_arithmetic",
-    "integer_division",
-    "into_iter_on_ref",
-    "invalid_null_ptr_usage",
-    "invalid_regex",
-    "invalid_upcast_comparisons",
-    "invalid_utf8_in_unchecked",
-    "invisible_characters",
-    "is_digit_ascii_radix",
-    "items_after_statements",
-    "iter_cloned_collect",
-    "iter_count",
-    "iter_kv_map",
-    "iter_next_loop",
-    "iter_next_slice",
-    "iter_not_returning_iterator",
-    "iter_nth",
-    "iter_nth_zero",
-    "iter_on_empty_collections",
-    "iter_on_single_items",
-    "iter_overeager_cloned",
-    "iter_skip_next",
-    "iter_with_drain",
-    "iterator_step_by_zero",
-    "just_underscores_and_digits",
-    "large_const_arrays",
-    "large_digit_groups",
-    "large_enum_variant",
-    "large_include_file",
-    "large_stack_arrays",
-    "large_types_passed_by_value",
-    "len_without_is_empty",
-    "len_zero",
-    "let_and_return",
-    "let_underscore_lock",
-    "let_underscore_must_use",
-    "let_unit_value",
-    "linkedlist",
-    "lossy_float_literal",
-    "macro_use_imports",
-    "main_recursion",
-    "manual_assert",
-    "manual_async_fn",
-    "manual_bits",
-    "manual_clamp",
-    "manual_filter",
-    "manual_filter_map",
-    "manual_find",
-    "manual_find_map",
-    "manual_flatten",
-    "manual_instant_elapsed",
-    "manual_map",
-    "manual_memcpy",
-    "manual_non_exhaustive",
-    "manual_ok_or",
-    "manual_range_contains",
-    "manual_rem_euclid",
-    "manual_retain",
-    "manual_saturating_arithmetic",
-    "manual_split_once",
-    "manual_str_repeat",
-    "manual_string_new",
-    "manual_strip",
-    "manual_swap",
-    "manual_unwrap_or",
-    "many_single_char_names",
-    "map_clone",
-    "map_collect_result_unit",
-    "map_entry",
-    "map_err_ignore",
-    "map_flatten",
-    "map_identity",
-    "map_unwrap_or",
-    "match_as_ref",
-    "match_bool",
-    "match_like_matches_macro",
-    "match_on_vec_items",
-    "match_overlapping_arm",
-    "match_ref_pats",
-    "match_result_ok",
-    "match_same_arms",
-    "match_single_binding",
-    "match_str_case_mismatch",
-    "match_wild_err_arm",
-    "match_wildcard_for_single_variants",
-    "maybe_infinite_iter",
-    "mem_forget",
-    "mem_replace_option_with_none",
-    "mem_replace_with_default",
-    "mem_replace_with_uninit",
-    "min_max",
-    "mismatched_target_os",
-    "mismatching_type_param_order",
-    "misrefactored_assign_op",
-    "missing_const_for_fn",
-    "missing_docs_in_private_items",
-    "missing_enforced_import_renames",
-    "missing_errors_doc",
-    "missing_inline_in_public_items",
-    "missing_panics_doc",
-    "missing_safety_doc",
-    "missing_spin_loop",
-    "missing_trait_methods",
-    "mistyped_literal_suffixes",
-    "mixed_case_hex_literals",
-    "mixed_read_write_in_expression",
-    "mod_module_files",
-    "module_inception",
-    "module_name_repetitions",
-    "modulo_arithmetic",
-    "modulo_one",
-    "multi_assignments",
-    "multiple_crate_versions",
-    "multiple_inherent_impl",
-    "must_use_candidate",
-    "must_use_unit",
-    "mut_from_ref",
-    "mut_mut",
-    "mut_mutex_lock",
-    "mut_range_bound",
-    "mutable_key_type",
-    "mutex_atomic",
-    "mutex_integer",
-    "naive_bytecount",
-    "needless_arbitrary_self_type",
-    "needless_bitwise_bool",
-    "needless_bool",
-    "needless_borrow",
-    "needless_borrowed_reference",
-    "needless_collect",
-    "needless_continue",
-    "needless_doctest_main",
-    "needless_for_each",
-    "needless_late_init",
-    "needless_lifetimes",
-    "needless_match",
-    "needless_option_as_deref",
-    "needless_option_take",
-    "needless_parens_on_range_literals",
-    "needless_pass_by_value",
-    "needless_question_mark",
-    "needless_range_loop",
-    "needless_return",
-    "needless_splitn",
-    "needless_update",
-    "neg_cmp_op_on_partial_ord",
-    "neg_multiply",
-    "negative_feature_names",
-    "never_loop",
-    "new_ret_no_self",
-    "new_without_default",
-    "no_effect",
-    "no_effect_replace",
-    "no_effect_underscore_binding",
-    "non_ascii_literal",
-    "non_octal_unix_permissions",
-    "non_send_fields_in_send_ty",
-    "nonminimal_bool",
-    "nonsensical_open_options",
-    "nonstandard_macro_braces",
-    "not_unsafe_ptr_arg_deref",
-    "obfuscated_if_else",
-    "octal_escapes",
-    "ok_expect",
-    "only_used_in_recursion",
-    "op_ref",
-    "option_as_ref_deref",
-    "option_env_unwrap",
-    "option_filter_map",
-    "option_if_let_else",
-    "option_map_or_none",
-    "option_map_unit_fn",
-    "option_option",
-    "or_fun_call",
-    "or_then_unwrap",
-    "out_of_bounds_indexing",
-    "overflow_check_conditional",
-    "overly_complex_bool_expr",
-    "panic",
-    "panic_in_result_fn",
-    "panicking_unwrap",
-    "partial_pub_fields",
-    "partialeq_ne_impl",
-    "partialeq_to_none",
-    "path_buf_push_overwrite",
-    "pattern_type_mismatch",
-    "possible_missing_comma",
-    "precedence",
-    "print_in_format_impl",
-    "print_literal",
-    "print_stderr",
-    "print_stdout",
-    "print_with_newline",
-    "println_empty_string",
-    "ptr_arg",
-    "ptr_as_ptr",
-    "ptr_eq",
-    "ptr_offset_with_cast",
-    "pub_use",
-    "question_mark",
-    "range_minus_one",
-    "range_plus_one",
-    "range_zip_with_len",
-    "rc_buffer",
-    "rc_clone_in_vec_init",
-    "rc_mutex",
-    "read_zero_byte_vec",
-    "recursive_format_impl",
-    "redundant_allocation",
-    "redundant_clone",
-    "redundant_closure",
-    "redundant_closure_call",
-    "redundant_closure_for_method_calls",
-    "redundant_else",
-    "redundant_feature_names",
-    "redundant_field_names",
-    "redundant_pattern",
-    "redundant_pattern_matching",
-    "redundant_pub_crate",
-    "redundant_slicing",
-    "redundant_static_lifetimes",
-    "ref_binding_to_reference",
-    "ref_option_ref",
-    "repeat_once",
-    "rest_pat_in_fully_bound_structs",
-    "result_large_err",
-    "result_map_or_into_option",
-    "result_map_unit_fn",
-    "result_unit_err",
-    "return_self_not_must_use",
-    "reversed_empty_ranges",
-    "same_functions_in_if_condition",
-    "same_item_push",
-    "same_name_method",
-    "search_is_some",
-    "self_assignment",
-    "self_named_constructors",
-    "self_named_module_files",
-    "semicolon_if_nothing_returned",
-    "separated_literal_suffix",
-    "serde_api_misuse",
-    "shadow_reuse",
-    "shadow_same",
-    "shadow_unrelated",
-    "short_circuit_statement",
-    "should_implement_trait",
-    "significant_drop_in_scrutinee",
-    "similar_names",
-    "single_char_add_str",
-    "single_char_lifetime_names",
-    "single_char_pattern",
-    "single_component_path_imports",
-    "single_element_loop",
-    "single_match",
-    "single_match_else",
-    "size_of_in_element_count",
-    "skip_while_next",
-    "slow_vector_initialization",
-    "stable_sort_primitive",
-    "std_instead_of_alloc",
-    "std_instead_of_core",
-    "str_to_string",
-    "string_add",
-    "string_add_assign",
-    "string_extend_chars",
-    "string_from_utf8_as_bytes",
-    "string_lit_as_bytes",
-    "string_slice",
-    "string_to_string",
-    "strlen_on_c_strings",
-    "struct_excessive_bools",
-    "suboptimal_flops",
-    "suspicious_arithmetic_impl",
-    "suspicious_assignment_formatting",
-    "suspicious_else_formatting",
-    "suspicious_map",
-    "suspicious_op_assign_impl",
-    "suspicious_operation_groupings",
-    "suspicious_splitn",
-    "suspicious_to_owned",
-    "suspicious_unary_op_formatting",
-    "swap_ptr_to_ref",
-    "tabs_in_doc_comments",
-    "temporary_assignment",
-    "to_digit_is_some",
-    "to_string_in_format_args",
-    "todo",
-    "too_many_arguments",
-    "too_many_lines",
-    "toplevel_ref_arg",
-    "trailing_empty_array",
-    "trait_duplication_in_bounds",
-    "transmute_bytes_to_str",
-    "transmute_float_to_int",
-    "transmute_int_to_bool",
-    "transmute_int_to_char",
-    "transmute_int_to_float",
-    "transmute_num_to_bytes",
-    "transmute_ptr_to_ptr",
-    "transmute_ptr_to_ref",
-    "transmute_undefined_repr",
-    "transmutes_expressible_as_ptr_casts",
-    "transmuting_null",
-    "trim_split_whitespace",
-    "trivial_regex",
-    "trivially_copy_pass_by_ref",
-    "try_err",
-    "type_complexity",
-    "type_repetition_in_bounds",
-    "undocumented_unsafe_blocks",
-    "undropped_manually_drops",
-    "unicode_not_nfc",
-    "unimplemented",
-    "uninit_assumed_init",
-    "uninit_vec",
-    "uninlined_format_args",
-    "unit_arg",
-    "unit_cmp",
-    "unit_hash",
-    "unit_return_expecting_ord",
-    "unnecessary_cast",
-    "unnecessary_filter_map",
-    "unnecessary_find_map",
-    "unnecessary_fold",
-    "unnecessary_join",
-    "unnecessary_lazy_evaluations",
-    "unnecessary_mut_passed",
-    "unnecessary_operation",
-    "unnecessary_owned_empty_strings",
-    "unnecessary_self_imports",
-    "unnecessary_sort_by",
-    "unnecessary_to_owned",
-    "unnecessary_unwrap",
-    "unnecessary_wraps",
-    "unneeded_field_pattern",
-    "unneeded_wildcard_pattern",
-    "unnested_or_patterns",
-    "unreachable",
-    "unreadable_literal",
-    "unsafe_derive_deserialize",
-    "unsafe_removed_from_name",
-    "unseparated_literal_suffix",
-    "unsound_collection_transmute",
-    "unused_async",
-    "unused_format_specs",
-    "unused_io_amount",
-    "unused_peekable",
-    "unused_rounding",
-    "unused_self",
-    "unused_unit",
-    "unusual_byte_groupings",
-    "unwrap_in_result",
-    "unwrap_or_else_default",
-    "unwrap_used",
-    "upper_case_acronyms",
-    "use_debug",
-    "use_self",
-    "used_underscore_binding",
-    "useless_asref",
-    "useless_attribute",
-    "useless_conversion",
-    "useless_format",
-    "useless_let_if_seq",
-    "useless_transmute",
-    "useless_vec",
-    "vec_box",
-    "vec_init_then_push",
-    "vec_resize_to_zero",
-    "verbose_bit_mask",
-    "verbose_file_reads",
-    "vtable_address_comparisons",
-    "while_immutable_condition",
-    "while_let_loop",
-    "while_let_on_iterator",
-    "wildcard_dependencies",
-    "wildcard_enum_match_arm",
-    "wildcard_imports",
-    "wildcard_in_or_patterns",
-    "write_literal",
-    "write_with_newline",
-    "writeln_empty_string",
-    "wrong_self_convention",
-    "wrong_transmute",
-    "zero_divided_by_zero",
-    "zero_prefixed_literal",
-    "zero_ptr",
-    "zero_sized_map_values",
-    "zst_offset",
-
-}
diff --git a/src/main.rs b/src/main.rs
index fce3cdfc462..d418d2daa31 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -7,8 +7,6 @@ use std::env;
 use std::path::PathBuf;
 use std::process::{self, Command};
 
-mod docs;
-
 const CARGO_CLIPPY_HELP: &str = r#"Checks a package to catch common mistakes and improve your Rust code.
 
 Usage:
@@ -60,7 +58,7 @@ pub fn main() {
     if let Some(pos) = env::args().position(|a| a == "--explain") {
         if let Some(mut lint) = env::args().nth(pos + 1) {
             lint.make_ascii_lowercase();
-            docs::explain(&lint.strip_prefix("clippy::").unwrap_or(&lint).replace('-', "_"));
+            clippy_lints::explain(&lint.strip_prefix("clippy::").unwrap_or(&lint).replace('-', "_"));
         } else {
             show_help();
         }
diff --git a/tests/versioncheck.rs b/tests/versioncheck.rs
index a6d8d0307ce..7a85386a3df 100644
--- a/tests/versioncheck.rs
+++ b/tests/versioncheck.rs
@@ -6,7 +6,7 @@ use rustc_tools_util::VersionInfo;
 use std::fs;
 
 #[test]
-fn check_that_clippy_lints_and_clippy_utils_have_the_same_version_as_clippy() {
+fn consistent_clippy_crate_versions() {
     fn read_version(path: &str) -> String {
         let contents = fs::read_to_string(path).unwrap_or_else(|e| panic!("error reading `{path}`: {e:?}"));
         contents
@@ -24,11 +24,16 @@ fn check_that_clippy_lints_and_clippy_utils_have_the_same_version_as_clippy() {
     }
 
     let clippy_version = read_version("Cargo.toml");
-    let clippy_lints_version = read_version("clippy_lints/Cargo.toml");
-    let clippy_utils_version = read_version("clippy_utils/Cargo.toml");
 
-    assert_eq!(clippy_version, clippy_lints_version);
-    assert_eq!(clippy_version, clippy_utils_version);
+    let paths = [
+        "declare_clippy_lint/Cargo.toml",
+        "clippy_lints/Cargo.toml",
+        "clippy_utils/Cargo.toml",
+    ];
+
+    for path in paths {
+        assert_eq!(clippy_version, read_version(path), "{path} version differs");
+    }
 }
 
 #[test]
-- 
cgit 1.4.1-3-g733a5


From e49cde7500de100b4e30e86bff653d4f4660a496 Mon Sep 17 00:00:00 2001
From: Andreu Botella <andreu@andreubotella.com>
Date: Sun, 23 Oct 2022 21:14:52 +0200
Subject: Update `from_raw_with_void_ptr` to support types other than `Box`

This PR updates the `from_raw_with_void_ptr` lint, which covered
`Box::from_raw`, to also cover the `from_raw` static method of the
`Rc`, `Arc`, `alloc::rc::Weak` and `alloc::sync::Weak` types.

It also improves the description and error messages of this lint.

---

changelog: [`from_raw_with_void_ptr`]: Now works with the `Rc`, `Arc`, `alloc::rc::Weak` and `alloc::sync::Weak` types.
---
 clippy_lints/src/from_raw_with_void_ptr.rs | 48 +++++++++++++++++--------
 tests/ui/from_raw_with_void_ptr.rs         | 18 ++++++++++
 tests/ui/from_raw_with_void_ptr.stderr     | 58 +++++++++++++++++++++++++++---
 3 files changed, 105 insertions(+), 19 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/from_raw_with_void_ptr.rs b/clippy_lints/src/from_raw_with_void_ptr.rs
index 63c3c5f601d..00f5ba56496 100644
--- a/clippy_lints/src/from_raw_with_void_ptr.rs
+++ b/clippy_lints/src/from_raw_with_void_ptr.rs
@@ -1,25 +1,22 @@
 use clippy_utils::diagnostics::span_lint_and_help;
-use clippy_utils::path_def_id;
 use clippy_utils::ty::is_c_void;
+use clippy_utils::{match_def_path, path_def_id, paths};
+use rustc_hir::def_id::DefId;
 use rustc_hir::{Expr, ExprKind, QPath};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::RawPtr;
 use rustc_middle::ty::TypeAndMut;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::sym;
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks if we're passing a `c_void` raw pointer to `Box::from_raw(_)`
+    /// Checks if we're passing a `c_void` raw pointer to `{Box,Rc,Arc,Weak}::from_raw(_)`
     ///
     /// ### Why is this bad?
-    /// However, it is easy to run into the pitfall of calling from_raw with the c_void pointer.
-    /// Note that the definition of, say, Box::from_raw is:
-    ///
-    /// `pub unsafe fn from_raw(raw: *mut T) -> Box<T>`
-    ///
-    /// meaning that if you pass a *mut c_void you will get a Box<c_void>.
-    /// Per the safety requirements in the documentation, for this to be safe,
-    /// c_void would need to have the same memory layout as the original type, which is often not the case.
+    /// When dealing with `c_void` raw pointers in FFI, it is easy to run into the pitfall of calling `from_raw` with the `c_void` pointer.
+    /// The type signature of `Box::from_raw` is `fn from_raw(raw: *mut T) -> Box<T>`, so if you pass a `*mut c_void` you will get a `Box<c_void>` (and similarly for `Rc`, `Arc` and `Weak`).
+    /// For this to be safe, `c_void` would need to have the same memory layout as the original type, which is often not the case.
     ///
     /// ### Example
     /// ```rust
@@ -37,7 +34,7 @@ declare_clippy_lint! {
     #[clippy::version = "1.66.0"]
     pub FROM_RAW_WITH_VOID_PTR,
     suspicious,
-    "creating a `Box` from a raw void pointer"
+    "creating a `Box` from a void raw pointer"
 }
 declare_lint_pass!(FromRawWithVoidPtr => [FROM_RAW_WITH_VOID_PTR]);
 
@@ -46,12 +43,35 @@ impl LateLintPass<'_> for FromRawWithVoidPtr {
         if let ExprKind::Call(box_from_raw, [arg]) = expr.kind
         && let ExprKind::Path(QPath::TypeRelative(ty, seg)) = box_from_raw.kind
         && seg.ident.name == sym!(from_raw)
-        // FIXME: This lint is also applicable to other types, like `Rc`, `Arc` and `Weak`.
-        && path_def_id(cx, ty).map_or(false, |id| Some(id) == cx.tcx.lang_items().owned_box())
+        && let Some(type_str) = path_def_id(cx, ty).and_then(|id| def_id_matches_type(cx, id))
         && let arg_kind = cx.typeck_results().expr_ty(arg).kind()
         && let RawPtr(TypeAndMut { ty, .. }) = arg_kind
         && is_c_void(cx, *ty) {
-            span_lint_and_help(cx, FROM_RAW_WITH_VOID_PTR, expr.span, "creating a `Box` from a raw void pointer", Some(arg.span), "cast this to a pointer of the actual type");
+            let msg = format!("creating a `{type_str}` from a void raw pointer");
+            span_lint_and_help(cx, FROM_RAW_WITH_VOID_PTR, expr.span, &msg, Some(arg.span), "cast this to a pointer of the appropriate type");
+        }
+    }
+}
+
+/// Checks whether a `DefId` matches `Box`, `Rc`, `Arc`, or one of the `Weak` types.
+/// Returns a static string slice with the name of the type, if one was found.
+fn def_id_matches_type(cx: &LateContext<'_>, def_id: DefId) -> Option<&'static str> {
+    // Box
+    if Some(def_id) == cx.tcx.lang_items().owned_box() {
+        return Some("Box");
+    }
+
+    if let Some(symbol) = cx.tcx.get_diagnostic_name(def_id) {
+        if symbol == sym::Arc {
+            return Some("Arc");
+        } else if symbol == sym::Rc {
+            return Some("Rc");
         }
     }
+
+    if match_def_path(cx, def_id, &paths::WEAK_RC) || match_def_path(cx, def_id, &paths::WEAK_ARC) {
+        Some("Weak")
+    } else {
+        None
+    }
 }
diff --git a/tests/ui/from_raw_with_void_ptr.rs b/tests/ui/from_raw_with_void_ptr.rs
index de5a8d60092..8484da2415a 100644
--- a/tests/ui/from_raw_with_void_ptr.rs
+++ b/tests/ui/from_raw_with_void_ptr.rs
@@ -1,6 +1,8 @@
 #![warn(clippy::from_raw_with_void_ptr)]
 
 use std::ffi::c_void;
+use std::rc::Rc;
+use std::sync::Arc;
 
 fn main() {
     // must lint
@@ -13,4 +15,20 @@ fn main() {
     // shouldn't be linted
     let should_not_lint_ptr = Box::into_raw(Box::new(12u8)) as *mut u8;
     let _ = unsafe { Box::from_raw(should_not_lint_ptr as *mut u8) };
+
+    // must lint
+    let ptr = Rc::into_raw(Rc::new(42usize)) as *mut c_void;
+    let _ = unsafe { Rc::from_raw(ptr) };
+
+    // must lint
+    let ptr = Arc::into_raw(Arc::new(42usize)) as *mut c_void;
+    let _ = unsafe { Arc::from_raw(ptr) };
+
+    // must lint
+    let ptr = std::rc::Weak::into_raw(Rc::downgrade(&Rc::new(42usize))) as *mut c_void;
+    let _ = unsafe { std::rc::Weak::from_raw(ptr) };
+
+    // must lint
+    let ptr = std::sync::Weak::into_raw(Arc::downgrade(&Arc::new(42usize))) as *mut c_void;
+    let _ = unsafe { std::sync::Weak::from_raw(ptr) };
 }
diff --git a/tests/ui/from_raw_with_void_ptr.stderr b/tests/ui/from_raw_with_void_ptr.stderr
index 9e8e3e44546..96e4af12ba3 100644
--- a/tests/ui/from_raw_with_void_ptr.stderr
+++ b/tests/ui/from_raw_with_void_ptr.stderr
@@ -1,15 +1,63 @@
-error: creating a `Box` from a raw void pointer
-  --> $DIR/from_raw_with_void_ptr.rs:8:22
+error: creating a `Box` from a void raw pointer
+  --> $DIR/from_raw_with_void_ptr.rs:10:22
    |
 LL |     let _ = unsafe { Box::from_raw(ptr) };
    |                      ^^^^^^^^^^^^^^^^^^
    |
-help: cast this to a pointer of the actual type
-  --> $DIR/from_raw_with_void_ptr.rs:8:36
+help: cast this to a pointer of the appropriate type
+  --> $DIR/from_raw_with_void_ptr.rs:10:36
    |
 LL |     let _ = unsafe { Box::from_raw(ptr) };
    |                                    ^^^
    = note: `-D clippy::from-raw-with-void-ptr` implied by `-D warnings`
 
-error: aborting due to previous error
+error: creating a `Rc` from a void raw pointer
+  --> $DIR/from_raw_with_void_ptr.rs:21:22
+   |
+LL |     let _ = unsafe { Rc::from_raw(ptr) };
+   |                      ^^^^^^^^^^^^^^^^^
+   |
+help: cast this to a pointer of the appropriate type
+  --> $DIR/from_raw_with_void_ptr.rs:21:35
+   |
+LL |     let _ = unsafe { Rc::from_raw(ptr) };
+   |                                   ^^^
+
+error: creating a `Arc` from a void raw pointer
+  --> $DIR/from_raw_with_void_ptr.rs:25:22
+   |
+LL |     let _ = unsafe { Arc::from_raw(ptr) };
+   |                      ^^^^^^^^^^^^^^^^^^
+   |
+help: cast this to a pointer of the appropriate type
+  --> $DIR/from_raw_with_void_ptr.rs:25:36
+   |
+LL |     let _ = unsafe { Arc::from_raw(ptr) };
+   |                                    ^^^
+
+error: creating a `Weak` from a void raw pointer
+  --> $DIR/from_raw_with_void_ptr.rs:29:22
+   |
+LL |     let _ = unsafe { std::rc::Weak::from_raw(ptr) };
+   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: cast this to a pointer of the appropriate type
+  --> $DIR/from_raw_with_void_ptr.rs:29:46
+   |
+LL |     let _ = unsafe { std::rc::Weak::from_raw(ptr) };
+   |                                              ^^^
+
+error: creating a `Weak` from a void raw pointer
+  --> $DIR/from_raw_with_void_ptr.rs:33:22
+   |
+LL |     let _ = unsafe { std::sync::Weak::from_raw(ptr) };
+   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: cast this to a pointer of the appropriate type
+  --> $DIR/from_raw_with_void_ptr.rs:33:48
+   |
+LL |     let _ = unsafe { std::sync::Weak::from_raw(ptr) };
+   |                                                ^^^
+
+error: aborting due to 5 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 8d6ce3177bd5d4d05723dec1cdd869effc926fc3 Mon Sep 17 00:00:00 2001
From: Doru-Florin Blanzeanu <blanzeanu.doru@protonmail.com>
Date: Sun, 16 Oct 2022 19:31:03 +0000
Subject: Add new lint `rewind_instead_of_seek_to_start`

Signed-off-by: Doru-Florin Blanzeanu <blanzeanu.doru@protonmail.com>
---
 CHANGELOG.md                                       |  1 +
 clippy_lints/src/declared_lints.rs                 |  1 +
 clippy_lints/src/methods/mod.rs                    | 36 +++++++++
 .../src/methods/rewind_instead_of_seek_to_start.rs | 45 +++++++++++
 clippy_utils/src/paths.rs                          |  2 +
 src/docs/rewind_instead_of_seek_to_start.txt       | 22 +++++
 tests/ui/rewind_instead_of_seek_to_start.fixed     | 94 ++++++++++++++++++++++
 tests/ui/rewind_instead_of_seek_to_start.rs        | 94 ++++++++++++++++++++++
 tests/ui/rewind_instead_of_seek_to_start.stderr    | 16 ++++
 9 files changed, 311 insertions(+)
 create mode 100644 clippy_lints/src/methods/rewind_instead_of_seek_to_start.rs
 create mode 100644 src/docs/rewind_instead_of_seek_to_start.txt
 create mode 100644 tests/ui/rewind_instead_of_seek_to_start.fixed
 create mode 100644 tests/ui/rewind_instead_of_seek_to_start.rs
 create mode 100644 tests/ui/rewind_instead_of_seek_to_start.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index cb5a4d4a577..09f914fe0ca 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4195,6 +4195,7 @@ Released 2018-09-13
 [`result_unwrap_used`]: https://rust-lang.github.io/rust-clippy/master/index.html#result_unwrap_used
 [`return_self_not_must_use`]: https://rust-lang.github.io/rust-clippy/master/index.html#return_self_not_must_use
 [`reversed_empty_ranges`]: https://rust-lang.github.io/rust-clippy/master/index.html#reversed_empty_ranges
+[`rewind_instead_of_seek_to_start`]: https://rust-lang.github.io/rust-clippy/master/index.html#rewind_instead_of_seek_to_start
 [`same_functions_in_if_condition`]: https://rust-lang.github.io/rust-clippy/master/index.html#same_functions_in_if_condition
 [`same_item_push`]: https://rust-lang.github.io/rust-clippy/master/index.html#same_item_push
 [`same_name_method`]: https://rust-lang.github.io/rust-clippy/master/index.html#same_name_method
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index c6ae0bddc5a..ad482cfc2e7 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -361,6 +361,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::methods::RANGE_ZIP_WITH_LEN_INFO,
     crate::methods::REPEAT_ONCE_INFO,
     crate::methods::RESULT_MAP_OR_INTO_OPTION_INFO,
+    crate::methods::REWIND_INSTEAD_OF_SEEK_TO_START_INFO,
     crate::methods::SEARCH_IS_SOME_INFO,
     crate::methods::SHOULD_IMPLEMENT_TRAIT_INFO,
     crate::methods::SINGLE_CHAR_ADD_STR_INFO,
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index fb92779be2a..e794af7d64b 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -68,6 +68,7 @@ mod or_then_unwrap;
 mod path_buf_push_overwrite;
 mod range_zip_with_len;
 mod repeat_once;
+mod rewind_instead_of_seek_to_start;
 mod search_is_some;
 mod single_char_add_str;
 mod single_char_insert_string;
@@ -3066,6 +3067,37 @@ declare_clippy_lint! {
     "iterating on map using `iter` when `keys` or `values` would do"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    ///
+    /// Checks for jumps to the start of a stream that implements `Seek`
+    /// and uses the `seek` method providing `Start` as parameter.
+    ///
+    /// ### Why is this bad?
+    ///
+    /// Readability. There is a specific method that was implemented for
+    /// this exact scenario.
+    ///
+    /// ### Example
+    /// ```rust
+    /// # use std::io;
+    /// fn foo<T: io::Seek>(t: &mut T) {
+    ///     t.seek(io::SeekFrom::Start(0));
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// # use std::io;
+    /// fn foo<T: io::Seek>(t: &mut T) {
+    ///     t.rewind();
+    /// }
+    /// ```
+    #[clippy::version = "1.66.0"]
+    pub REWIND_INSTEAD_OF_SEEK_TO_START,
+    complexity,
+    "jumping to the start of stream using `seek` method"
+}
+
 pub struct Methods {
     avoid_breaking_exported_api: bool,
     msrv: Option<RustcVersion>,
@@ -3190,6 +3222,7 @@ impl_lint_pass!(Methods => [
     VEC_RESIZE_TO_ZERO,
     VERBOSE_FILE_READS,
     ITER_KV_MAP,
+    REWIND_INSTEAD_OF_SEEK_TO_START,
 ]);
 
 /// Extracts a method call name, args, and `Span` of the method name.
@@ -3604,6 +3637,9 @@ impl Methods {
                 ("resize", [count_arg, default_arg]) => {
                     vec_resize_to_zero::check(cx, expr, count_arg, default_arg, span);
                 },
+                ("seek", [arg]) => {
+                    rewind_instead_of_seek_to_start::check(cx, expr, recv, arg, span);
+                },
                 ("sort", []) => {
                     stable_sort_primitive::check(cx, expr, recv);
                 },
diff --git a/clippy_lints/src/methods/rewind_instead_of_seek_to_start.rs b/clippy_lints/src/methods/rewind_instead_of_seek_to_start.rs
new file mode 100644
index 00000000000..97b33dec843
--- /dev/null
+++ b/clippy_lints/src/methods/rewind_instead_of_seek_to_start.rs
@@ -0,0 +1,45 @@
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::ty::implements_trait;
+use clippy_utils::{get_trait_def_id, match_def_path, paths};
+use rustc_ast::ast::{LitIntType, LitKind};
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind};
+use rustc_lint::LateContext;
+use rustc_span::Span;
+
+use super::REWIND_INSTEAD_OF_SEEK_TO_START;
+
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx Expr<'_>,
+    recv: &'tcx Expr<'_>,
+    arg: &'tcx Expr<'_>,
+    name_span: Span,
+) {
+    // Get receiver type
+    let ty = cx.typeck_results().expr_ty(recv).peel_refs();
+
+    if let Some(seek_trait_id) = get_trait_def_id(cx, &paths::STD_IO_SEEK) &&
+        implements_trait(cx, ty, seek_trait_id, &[]) &&
+        let ExprKind::Call(func, args1) = arg.kind &&
+        let ExprKind::Path(ref path) = func.kind &&
+        let Some(def_id) = cx.qpath_res(path, func.hir_id).opt_def_id() &&
+        match_def_path(cx, def_id, &paths::STD_IO_SEEKFROM_START) &&
+        args1.len() == 1 &&
+        let ExprKind::Lit(ref lit) = args1[0].kind &&
+        let LitKind::Int(0, LitIntType::Unsuffixed) = lit.node
+    {
+        let method_call_span = expr.span.with_lo(name_span.lo());
+        span_lint_and_then(
+            cx,
+            REWIND_INSTEAD_OF_SEEK_TO_START,
+            method_call_span,
+            "used `seek` to go to the start of the stream",
+            |diag| {
+                let app = Applicability::MachineApplicable;
+
+                diag.span_suggestion(method_call_span, "replace with", "rewind()", app);
+            },
+        );
+    }
+}
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index bc851473430..e37c7e34c0c 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -115,6 +115,8 @@ pub const STDERR: [&str; 4] = ["std", "io", "stdio", "stderr"];
 pub const STDOUT: [&str; 4] = ["std", "io", "stdio", "stdout"];
 pub const CONVERT_IDENTITY: [&str; 3] = ["core", "convert", "identity"];
 pub const STD_FS_CREATE_DIR: [&str; 3] = ["std", "fs", "create_dir"];
+pub const STD_IO_SEEK: [&str; 3] = ["std", "io", "Seek"];
+pub const STD_IO_SEEKFROM_START: [&str; 4] = ["std", "io", "SeekFrom", "Start"];
 pub const STRING_AS_MUT_STR: [&str; 4] = ["alloc", "string", "String", "as_mut_str"];
 pub const STRING_AS_STR: [&str; 4] = ["alloc", "string", "String", "as_str"];
 pub const STRING_NEW: [&str; 4] = ["alloc", "string", "String", "new"];
diff --git a/src/docs/rewind_instead_of_seek_to_start.txt b/src/docs/rewind_instead_of_seek_to_start.txt
new file mode 100644
index 00000000000..bef11b2312a
--- /dev/null
+++ b/src/docs/rewind_instead_of_seek_to_start.txt
@@ -0,0 +1,22 @@
+### What it does
+
+Checks for jumps to the start of a stream that implements `Seek`
+and uses the `seek` method providing `Start` as parameter.
+
+### Why is this bad?
+
+Readability. There is a specific method that was implemented for
+this exact scenario.
+
+### Example
+```
+fn foo<T: io::Seek>(t: &mut T) {
+    t.seek(io::SeekFrom::Start(0));
+}
+```
+Use instead:
+```
+fn foo<T: io::Seek>(t: &mut T) {
+    t.rewind();
+}
+```
\ No newline at end of file
diff --git a/tests/ui/rewind_instead_of_seek_to_start.fixed b/tests/ui/rewind_instead_of_seek_to_start.fixed
new file mode 100644
index 00000000000..037a288b69b
--- /dev/null
+++ b/tests/ui/rewind_instead_of_seek_to_start.fixed
@@ -0,0 +1,94 @@
+// run-rustfix
+#![allow(unused)]
+#![warn(clippy::rewind_instead_of_seek_to_start)]
+
+use std::fs::OpenOptions;
+use std::io::{Read, Seek, SeekFrom, Write};
+
+struct StructWithSeekMethod {}
+
+impl StructWithSeekMethod {
+    fn seek(&mut self, from: SeekFrom) {}
+}
+
+trait MySeekTrait {
+    fn seek(&mut self, from: SeekFrom) {}
+}
+
+struct StructWithSeekTrait {}
+impl MySeekTrait for StructWithSeekTrait {}
+
+// This should NOT trigger clippy warning because
+// StructWithSeekMethod does not implement std::io::Seek;
+fn seek_to_start_false_method(t: &mut StructWithSeekMethod) {
+    t.seek(SeekFrom::Start(0));
+}
+
+// This should NOT trigger clippy warning because
+// StructWithSeekMethod does not implement std::io::Seek;
+fn seek_to_start_method_owned_false<T>(mut t: StructWithSeekMethod) {
+    t.seek(SeekFrom::Start(0));
+}
+
+// This should NOT trigger clippy warning because
+// StructWithSeekMethod does not implement std::io::Seek;
+fn seek_to_start_false_trait(t: &mut StructWithSeekTrait) {
+    t.seek(SeekFrom::Start(0));
+}
+
+// This should NOT trigger clippy warning because
+// StructWithSeekMethod does not implement std::io::Seek;
+fn seek_to_start_false_trait_owned<T>(mut t: StructWithSeekTrait) {
+    t.seek(SeekFrom::Start(0));
+}
+
+// This should NOT trigger clippy warning because
+// StructWithSeekMethod does not implement std::io::Seek;
+fn seek_to_start_false_trait_bound<T: MySeekTrait>(t: &mut T) {
+    t.seek(SeekFrom::Start(0));
+}
+
+// This should trigger clippy warning
+fn seek_to_start<T: Seek>(t: &mut T) {
+    t.rewind();
+}
+
+// This should trigger clippy warning
+fn owned_seek_to_start<T: Seek>(mut t: T) {
+    t.rewind();
+}
+
+// This should NOT trigger clippy warning because
+// it does not seek to start
+fn seek_to_5<T: Seek>(t: &mut T) {
+    t.seek(SeekFrom::Start(5));
+}
+
+// This should NOT trigger clippy warning because
+// it does not seek to start
+fn seek_to_end<T: Seek>(t: &mut T) {
+    t.seek(SeekFrom::End(0));
+}
+
+fn main() {
+    let mut f = OpenOptions::new()
+        .write(true)
+        .read(true)
+        .create(true)
+        .open("foo.txt")
+        .unwrap();
+
+    let mut my_struct_trait = StructWithSeekTrait {};
+    seek_to_start_false_trait_bound(&mut my_struct_trait);
+
+    let hello = "Hello!\n";
+    write!(f, "{hello}").unwrap();
+    seek_to_5(&mut f);
+    seek_to_end(&mut f);
+    seek_to_start(&mut f);
+
+    let mut buf = String::new();
+    f.read_to_string(&mut buf).unwrap();
+
+    assert_eq!(&buf, hello);
+}
diff --git a/tests/ui/rewind_instead_of_seek_to_start.rs b/tests/ui/rewind_instead_of_seek_to_start.rs
new file mode 100644
index 00000000000..2622425128d
--- /dev/null
+++ b/tests/ui/rewind_instead_of_seek_to_start.rs
@@ -0,0 +1,94 @@
+// run-rustfix
+#![allow(unused)]
+#![warn(clippy::rewind_instead_of_seek_to_start)]
+
+use std::fs::OpenOptions;
+use std::io::{Read, Seek, SeekFrom, Write};
+
+struct StructWithSeekMethod {}
+
+impl StructWithSeekMethod {
+    fn seek(&mut self, from: SeekFrom) {}
+}
+
+trait MySeekTrait {
+    fn seek(&mut self, from: SeekFrom) {}
+}
+
+struct StructWithSeekTrait {}
+impl MySeekTrait for StructWithSeekTrait {}
+
+// This should NOT trigger clippy warning because
+// StructWithSeekMethod does not implement std::io::Seek;
+fn seek_to_start_false_method(t: &mut StructWithSeekMethod) {
+    t.seek(SeekFrom::Start(0));
+}
+
+// This should NOT trigger clippy warning because
+// StructWithSeekMethod does not implement std::io::Seek;
+fn seek_to_start_method_owned_false<T>(mut t: StructWithSeekMethod) {
+    t.seek(SeekFrom::Start(0));
+}
+
+// This should NOT trigger clippy warning because
+// StructWithSeekMethod does not implement std::io::Seek;
+fn seek_to_start_false_trait(t: &mut StructWithSeekTrait) {
+    t.seek(SeekFrom::Start(0));
+}
+
+// This should NOT trigger clippy warning because
+// StructWithSeekMethod does not implement std::io::Seek;
+fn seek_to_start_false_trait_owned<T>(mut t: StructWithSeekTrait) {
+    t.seek(SeekFrom::Start(0));
+}
+
+// This should NOT trigger clippy warning because
+// StructWithSeekMethod does not implement std::io::Seek;
+fn seek_to_start_false_trait_bound<T: MySeekTrait>(t: &mut T) {
+    t.seek(SeekFrom::Start(0));
+}
+
+// This should trigger clippy warning
+fn seek_to_start<T: Seek>(t: &mut T) {
+    t.seek(SeekFrom::Start(0));
+}
+
+// This should trigger clippy warning
+fn owned_seek_to_start<T: Seek>(mut t: T) {
+    t.seek(SeekFrom::Start(0));
+}
+
+// This should NOT trigger clippy warning because
+// it does not seek to start
+fn seek_to_5<T: Seek>(t: &mut T) {
+    t.seek(SeekFrom::Start(5));
+}
+
+// This should NOT trigger clippy warning because
+// it does not seek to start
+fn seek_to_end<T: Seek>(t: &mut T) {
+    t.seek(SeekFrom::End(0));
+}
+
+fn main() {
+    let mut f = OpenOptions::new()
+        .write(true)
+        .read(true)
+        .create(true)
+        .open("foo.txt")
+        .unwrap();
+
+    let mut my_struct_trait = StructWithSeekTrait {};
+    seek_to_start_false_trait_bound(&mut my_struct_trait);
+
+    let hello = "Hello!\n";
+    write!(f, "{hello}").unwrap();
+    seek_to_5(&mut f);
+    seek_to_end(&mut f);
+    seek_to_start(&mut f);
+
+    let mut buf = String::new();
+    f.read_to_string(&mut buf).unwrap();
+
+    assert_eq!(&buf, hello);
+}
diff --git a/tests/ui/rewind_instead_of_seek_to_start.stderr b/tests/ui/rewind_instead_of_seek_to_start.stderr
new file mode 100644
index 00000000000..f985471ac05
--- /dev/null
+++ b/tests/ui/rewind_instead_of_seek_to_start.stderr
@@ -0,0 +1,16 @@
+error: used `seek` to go to the start of the stream
+  --> $DIR/rewind_instead_of_seek_to_start.rs:53:7
+   |
+LL |     t.seek(SeekFrom::Start(0));
+   |       ^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `rewind()`
+   |
+   = note: `-D clippy::rewind-instead-of-seek-to-start` implied by `-D warnings`
+
+error: used `seek` to go to the start of the stream
+  --> $DIR/rewind_instead_of_seek_to_start.rs:58:7
+   |
+LL |     t.seek(SeekFrom::Start(0));
+   |       ^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `rewind()`
+
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From b48a4668f4767412b3d9797ce3d6ee63f351caee Mon Sep 17 00:00:00 2001
From: Doru-Florin Blanzeanu <blanzeanu.doru@protonmail.com>
Date: Fri, 21 Oct 2022 16:08:04 +0000
Subject: Add msrv check for `rewind_instead_of_seek_to_start` lint

Signed-off-by: Doru-Florin Blanzeanu <blanzeanu.doru@protonmail.com>
---
 clippy_lints/src/methods/mod.rs                 |  4 ++-
 clippy_utils/src/msrvs.rs                       |  1 +
 tests/ui/rewind_instead_of_seek_to_start.fixed  | 43 +++++++++++++++++++++++++
 tests/ui/rewind_instead_of_seek_to_start.rs     | 43 +++++++++++++++++++++++++
 tests/ui/rewind_instead_of_seek_to_start.stderr | 12 +++++--
 5 files changed, 99 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index e794af7d64b..7b0a676e89e 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3638,7 +3638,9 @@ impl Methods {
                     vec_resize_to_zero::check(cx, expr, count_arg, default_arg, span);
                 },
                 ("seek", [arg]) => {
-                    rewind_instead_of_seek_to_start::check(cx, expr, recv, arg, span);
+                    if meets_msrv(self.msrv, msrvs::SEEK_REWIND) {
+                        rewind_instead_of_seek_to_start::check(cx, expr, recv, arg, span);
+                    }
                 },
                 ("sort", []) => {
                     stable_sort_primitive::check(cx, expr, recv);
diff --git a/clippy_utils/src/msrvs.rs b/clippy_utils/src/msrvs.rs
index 8b843732a23..6f77155ec3e 100644
--- a/clippy_utils/src/msrvs.rs
+++ b/clippy_utils/src/msrvs.rs
@@ -37,4 +37,5 @@ msrv_aliases! {
     1,18,0 { HASH_MAP_RETAIN, HASH_SET_RETAIN }
     1,17,0 { FIELD_INIT_SHORTHAND, STATIC_IN_CONST, EXPECT_ERR }
     1,16,0 { STR_REPEAT }
+    1,55,0 { SEEK_REWIND }
 }
diff --git a/tests/ui/rewind_instead_of_seek_to_start.fixed b/tests/ui/rewind_instead_of_seek_to_start.fixed
index 037a288b69b..36853780977 100644
--- a/tests/ui/rewind_instead_of_seek_to_start.fixed
+++ b/tests/ui/rewind_instead_of_seek_to_start.fixed
@@ -1,5 +1,6 @@
 // run-rustfix
 #![allow(unused)]
+#![feature(custom_inner_attributes)]
 #![warn(clippy::rewind_instead_of_seek_to_start)]
 
 use std::fs::OpenOptions;
@@ -92,3 +93,45 @@ fn main() {
 
     assert_eq!(&buf, hello);
 }
+
+fn msrv_1_54() {
+    #![clippy::msrv = "1.54"]
+
+    let mut f = OpenOptions::new()
+        .write(true)
+        .read(true)
+        .create(true)
+        .open("foo.txt")
+        .unwrap();
+
+    let hello = "Hello!\n";
+    write!(f, "{hello}").unwrap();
+
+    f.seek(SeekFrom::Start(0));
+
+    let mut buf = String::new();
+    f.read_to_string(&mut buf).unwrap();
+
+    assert_eq!(&buf, hello);
+}
+
+fn msrv_1_55() {
+    #![clippy::msrv = "1.55"]
+
+    let mut f = OpenOptions::new()
+        .write(true)
+        .read(true)
+        .create(true)
+        .open("foo.txt")
+        .unwrap();
+
+    let hello = "Hello!\n";
+    write!(f, "{hello}").unwrap();
+
+    f.rewind();
+
+    let mut buf = String::new();
+    f.read_to_string(&mut buf).unwrap();
+
+    assert_eq!(&buf, hello);
+}
diff --git a/tests/ui/rewind_instead_of_seek_to_start.rs b/tests/ui/rewind_instead_of_seek_to_start.rs
index 2622425128d..0d061b58fba 100644
--- a/tests/ui/rewind_instead_of_seek_to_start.rs
+++ b/tests/ui/rewind_instead_of_seek_to_start.rs
@@ -1,5 +1,6 @@
 // run-rustfix
 #![allow(unused)]
+#![feature(custom_inner_attributes)]
 #![warn(clippy::rewind_instead_of_seek_to_start)]
 
 use std::fs::OpenOptions;
@@ -92,3 +93,45 @@ fn main() {
 
     assert_eq!(&buf, hello);
 }
+
+fn msrv_1_54() {
+    #![clippy::msrv = "1.54"]
+
+    let mut f = OpenOptions::new()
+        .write(true)
+        .read(true)
+        .create(true)
+        .open("foo.txt")
+        .unwrap();
+
+    let hello = "Hello!\n";
+    write!(f, "{hello}").unwrap();
+
+    f.seek(SeekFrom::Start(0));
+
+    let mut buf = String::new();
+    f.read_to_string(&mut buf).unwrap();
+
+    assert_eq!(&buf, hello);
+}
+
+fn msrv_1_55() {
+    #![clippy::msrv = "1.55"]
+
+    let mut f = OpenOptions::new()
+        .write(true)
+        .read(true)
+        .create(true)
+        .open("foo.txt")
+        .unwrap();
+
+    let hello = "Hello!\n";
+    write!(f, "{hello}").unwrap();
+
+    f.seek(SeekFrom::Start(0));
+
+    let mut buf = String::new();
+    f.read_to_string(&mut buf).unwrap();
+
+    assert_eq!(&buf, hello);
+}
diff --git a/tests/ui/rewind_instead_of_seek_to_start.stderr b/tests/ui/rewind_instead_of_seek_to_start.stderr
index f985471ac05..e8086781084 100644
--- a/tests/ui/rewind_instead_of_seek_to_start.stderr
+++ b/tests/ui/rewind_instead_of_seek_to_start.stderr
@@ -1,5 +1,5 @@
 error: used `seek` to go to the start of the stream
-  --> $DIR/rewind_instead_of_seek_to_start.rs:53:7
+  --> $DIR/rewind_instead_of_seek_to_start.rs:54:7
    |
 LL |     t.seek(SeekFrom::Start(0));
    |       ^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `rewind()`
@@ -7,10 +7,16 @@ LL |     t.seek(SeekFrom::Start(0));
    = note: `-D clippy::rewind-instead-of-seek-to-start` implied by `-D warnings`
 
 error: used `seek` to go to the start of the stream
-  --> $DIR/rewind_instead_of_seek_to_start.rs:58:7
+  --> $DIR/rewind_instead_of_seek_to_start.rs:59:7
    |
 LL |     t.seek(SeekFrom::Start(0));
    |       ^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `rewind()`
 
-error: aborting due to 2 previous errors
+error: used `seek` to go to the start of the stream
+  --> $DIR/rewind_instead_of_seek_to_start.rs:131:7
+   |
+LL |     f.seek(SeekFrom::Start(0));
+   |       ^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `rewind()`
+
+error: aborting due to 3 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From e86e810889481d6f4284e6ec29224ed5fca490bd Mon Sep 17 00:00:00 2001
From: kraktus <kraktus@users.noreply.github.com>
Date: Mon, 24 Oct 2022 18:25:59 +0200
Subject: [`use_self`] fix FP when trait impl defined in macro

Found when working on `lintcheck --fix`
---
 clippy_lints/src/use_self.rs  |  1 +
 tests/ui/use_self_trait.fixed | 26 ++++++++++++++++++++++++++
 tests/ui/use_self_trait.rs    | 26 ++++++++++++++++++++++++++
 3 files changed, 53 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/use_self.rs b/clippy_lints/src/use_self.rs
index 65f1b546208..acf27c34e94 100644
--- a/clippy_lints/src/use_self.rs
+++ b/clippy_lints/src/use_self.rs
@@ -103,6 +103,7 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
             if parameters.as_ref().map_or(true, |params| {
                 !params.parenthesized && !params.args.iter().any(|arg| matches!(arg, GenericArg::Lifetime(_)))
             });
+            if !item.span.from_expansion();
             if !is_from_proc_macro(cx, item); // expensive, should be last check
             then {
                 StackItem::Check {
diff --git a/tests/ui/use_self_trait.fixed b/tests/ui/use_self_trait.fixed
index 9bcd692fb35..12adf1e41a6 100644
--- a/tests/ui/use_self_trait.fixed
+++ b/tests/ui/use_self_trait.fixed
@@ -112,4 +112,30 @@ impl NameTrait for u8 {
     }
 }
 
+mod impl_in_macro {
+    macro_rules! parse_ip_impl {
+        // minimized from serde=1.0.118
+        ($ty:ty) => {
+            impl FooTrait for $ty {
+                fn new() -> Self {
+                    <$ty>::bar()
+                }
+            }
+        };
+    }
+
+    struct Foo;
+
+    trait FooTrait {
+        fn new() -> Self;
+    }
+
+    impl Foo {
+        fn bar() -> Self {
+            Self
+        }
+    }
+    parse_ip_impl!(Foo); // Should not lint
+}
+
 fn main() {}
diff --git a/tests/ui/use_self_trait.rs b/tests/ui/use_self_trait.rs
index de305d40f33..49dbcddc1d8 100644
--- a/tests/ui/use_self_trait.rs
+++ b/tests/ui/use_self_trait.rs
@@ -112,4 +112,30 @@ impl NameTrait for u8 {
     }
 }
 
+mod impl_in_macro {
+    macro_rules! parse_ip_impl {
+        // minimized from serde=1.0.118
+        ($ty:ty) => {
+            impl FooTrait for $ty {
+                fn new() -> Self {
+                    <$ty>::bar()
+                }
+            }
+        };
+    }
+
+    struct Foo;
+
+    trait FooTrait {
+        fn new() -> Self;
+    }
+
+    impl Foo {
+        fn bar() -> Self {
+            Self
+        }
+    }
+    parse_ip_impl!(Foo); // Should not lint
+}
+
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From b9b9d6a751ca3a9ccdd64f50390361e339f5124f Mon Sep 17 00:00:00 2001
From: Doru-Florin Blanzeanu <blanzeanu.doru@protonmail.com>
Date: Mon, 24 Oct 2022 15:54:08 +0000
Subject: Change lint name to `seek_to_start_instead_of_rewind`

- This name makes more sense and highlights the issue

Signed-off-by: Doru-Florin Blanzeanu <blanzeanu.doru@protonmail.com>
---
 CHANGELOG.md                                       |   2 +-
 clippy_lints/src/declared_lints.rs                 |   2 +-
 clippy_lints/src/methods/mod.rs                    |   8 +-
 .../src/methods/rewind_instead_of_seek_to_start.rs |  45 -------
 .../src/methods/seek_to_start_instead_of_rewind.rs |  45 +++++++
 src/docs/rewind_instead_of_seek_to_start.txt       |  22 ----
 src/docs/seek_to_start_instead_of_rewind.txt       |  22 ++++
 tests/ui/rewind_instead_of_seek_to_start.fixed     | 137 ---------------------
 tests/ui/rewind_instead_of_seek_to_start.rs        | 137 ---------------------
 tests/ui/rewind_instead_of_seek_to_start.stderr    |  22 ----
 tests/ui/seek_to_start_instead_of_rewind.fixed     | 137 +++++++++++++++++++++
 tests/ui/seek_to_start_instead_of_rewind.rs        | 137 +++++++++++++++++++++
 tests/ui/seek_to_start_instead_of_rewind.stderr    |  22 ++++
 13 files changed, 369 insertions(+), 369 deletions(-)
 delete mode 100644 clippy_lints/src/methods/rewind_instead_of_seek_to_start.rs
 create mode 100644 clippy_lints/src/methods/seek_to_start_instead_of_rewind.rs
 delete mode 100644 src/docs/rewind_instead_of_seek_to_start.txt
 create mode 100644 src/docs/seek_to_start_instead_of_rewind.txt
 delete mode 100644 tests/ui/rewind_instead_of_seek_to_start.fixed
 delete mode 100644 tests/ui/rewind_instead_of_seek_to_start.rs
 delete mode 100644 tests/ui/rewind_instead_of_seek_to_start.stderr
 create mode 100644 tests/ui/seek_to_start_instead_of_rewind.fixed
 create mode 100644 tests/ui/seek_to_start_instead_of_rewind.rs
 create mode 100644 tests/ui/seek_to_start_instead_of_rewind.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 09f914fe0ca..ae9fc46a42f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4195,11 +4195,11 @@ Released 2018-09-13
 [`result_unwrap_used`]: https://rust-lang.github.io/rust-clippy/master/index.html#result_unwrap_used
 [`return_self_not_must_use`]: https://rust-lang.github.io/rust-clippy/master/index.html#return_self_not_must_use
 [`reversed_empty_ranges`]: https://rust-lang.github.io/rust-clippy/master/index.html#reversed_empty_ranges
-[`rewind_instead_of_seek_to_start`]: https://rust-lang.github.io/rust-clippy/master/index.html#rewind_instead_of_seek_to_start
 [`same_functions_in_if_condition`]: https://rust-lang.github.io/rust-clippy/master/index.html#same_functions_in_if_condition
 [`same_item_push`]: https://rust-lang.github.io/rust-clippy/master/index.html#same_item_push
 [`same_name_method`]: https://rust-lang.github.io/rust-clippy/master/index.html#same_name_method
 [`search_is_some`]: https://rust-lang.github.io/rust-clippy/master/index.html#search_is_some
+[`seek_to_start_instead_of_rewind`]: https://rust-lang.github.io/rust-clippy/master/index.html#seek_to_start_instead_of_rewind
 [`self_assignment`]: https://rust-lang.github.io/rust-clippy/master/index.html#self_assignment
 [`self_named_constructors`]: https://rust-lang.github.io/rust-clippy/master/index.html#self_named_constructors
 [`self_named_module_files`]: https://rust-lang.github.io/rust-clippy/master/index.html#self_named_module_files
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index ad482cfc2e7..5d963bb5488 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -361,8 +361,8 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::methods::RANGE_ZIP_WITH_LEN_INFO,
     crate::methods::REPEAT_ONCE_INFO,
     crate::methods::RESULT_MAP_OR_INTO_OPTION_INFO,
-    crate::methods::REWIND_INSTEAD_OF_SEEK_TO_START_INFO,
     crate::methods::SEARCH_IS_SOME_INFO,
+    crate::methods::SEEK_TO_START_INSTEAD_OF_REWIND_INFO,
     crate::methods::SHOULD_IMPLEMENT_TRAIT_INFO,
     crate::methods::SINGLE_CHAR_ADD_STR_INFO,
     crate::methods::SINGLE_CHAR_PATTERN_INFO,
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 7b0a676e89e..4fd1e3e54ae 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -68,8 +68,8 @@ mod or_then_unwrap;
 mod path_buf_push_overwrite;
 mod range_zip_with_len;
 mod repeat_once;
-mod rewind_instead_of_seek_to_start;
 mod search_is_some;
+mod seek_to_start_instead_of_rewind;
 mod single_char_add_str;
 mod single_char_insert_string;
 mod single_char_pattern;
@@ -3093,7 +3093,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     #[clippy::version = "1.66.0"]
-    pub REWIND_INSTEAD_OF_SEEK_TO_START,
+    pub SEEK_TO_START_INSTEAD_OF_REWIND,
     complexity,
     "jumping to the start of stream using `seek` method"
 }
@@ -3222,7 +3222,7 @@ impl_lint_pass!(Methods => [
     VEC_RESIZE_TO_ZERO,
     VERBOSE_FILE_READS,
     ITER_KV_MAP,
-    REWIND_INSTEAD_OF_SEEK_TO_START,
+    SEEK_TO_START_INSTEAD_OF_REWIND,
 ]);
 
 /// Extracts a method call name, args, and `Span` of the method name.
@@ -3639,7 +3639,7 @@ impl Methods {
                 },
                 ("seek", [arg]) => {
                     if meets_msrv(self.msrv, msrvs::SEEK_REWIND) {
-                        rewind_instead_of_seek_to_start::check(cx, expr, recv, arg, span);
+                        seek_to_start_instead_of_rewind::check(cx, expr, recv, arg, span);
                     }
                 },
                 ("sort", []) => {
diff --git a/clippy_lints/src/methods/rewind_instead_of_seek_to_start.rs b/clippy_lints/src/methods/rewind_instead_of_seek_to_start.rs
deleted file mode 100644
index 97b33dec843..00000000000
--- a/clippy_lints/src/methods/rewind_instead_of_seek_to_start.rs
+++ /dev/null
@@ -1,45 +0,0 @@
-use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::ty::implements_trait;
-use clippy_utils::{get_trait_def_id, match_def_path, paths};
-use rustc_ast::ast::{LitIntType, LitKind};
-use rustc_errors::Applicability;
-use rustc_hir::{Expr, ExprKind};
-use rustc_lint::LateContext;
-use rustc_span::Span;
-
-use super::REWIND_INSTEAD_OF_SEEK_TO_START;
-
-pub(super) fn check<'tcx>(
-    cx: &LateContext<'tcx>,
-    expr: &'tcx Expr<'_>,
-    recv: &'tcx Expr<'_>,
-    arg: &'tcx Expr<'_>,
-    name_span: Span,
-) {
-    // Get receiver type
-    let ty = cx.typeck_results().expr_ty(recv).peel_refs();
-
-    if let Some(seek_trait_id) = get_trait_def_id(cx, &paths::STD_IO_SEEK) &&
-        implements_trait(cx, ty, seek_trait_id, &[]) &&
-        let ExprKind::Call(func, args1) = arg.kind &&
-        let ExprKind::Path(ref path) = func.kind &&
-        let Some(def_id) = cx.qpath_res(path, func.hir_id).opt_def_id() &&
-        match_def_path(cx, def_id, &paths::STD_IO_SEEKFROM_START) &&
-        args1.len() == 1 &&
-        let ExprKind::Lit(ref lit) = args1[0].kind &&
-        let LitKind::Int(0, LitIntType::Unsuffixed) = lit.node
-    {
-        let method_call_span = expr.span.with_lo(name_span.lo());
-        span_lint_and_then(
-            cx,
-            REWIND_INSTEAD_OF_SEEK_TO_START,
-            method_call_span,
-            "used `seek` to go to the start of the stream",
-            |diag| {
-                let app = Applicability::MachineApplicable;
-
-                diag.span_suggestion(method_call_span, "replace with", "rewind()", app);
-            },
-        );
-    }
-}
diff --git a/clippy_lints/src/methods/seek_to_start_instead_of_rewind.rs b/clippy_lints/src/methods/seek_to_start_instead_of_rewind.rs
new file mode 100644
index 00000000000..7e3bed1e41a
--- /dev/null
+++ b/clippy_lints/src/methods/seek_to_start_instead_of_rewind.rs
@@ -0,0 +1,45 @@
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::ty::implements_trait;
+use clippy_utils::{get_trait_def_id, match_def_path, paths};
+use rustc_ast::ast::{LitIntType, LitKind};
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind};
+use rustc_lint::LateContext;
+use rustc_span::Span;
+
+use super::SEEK_TO_START_INSTEAD_OF_REWIND;
+
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx Expr<'_>,
+    recv: &'tcx Expr<'_>,
+    arg: &'tcx Expr<'_>,
+    name_span: Span,
+) {
+    // Get receiver type
+    let ty = cx.typeck_results().expr_ty(recv).peel_refs();
+
+    if let Some(seek_trait_id) = get_trait_def_id(cx, &paths::STD_IO_SEEK) &&
+        implements_trait(cx, ty, seek_trait_id, &[]) &&
+        let ExprKind::Call(func, args1) = arg.kind &&
+        let ExprKind::Path(ref path) = func.kind &&
+        let Some(def_id) = cx.qpath_res(path, func.hir_id).opt_def_id() &&
+        match_def_path(cx, def_id, &paths::STD_IO_SEEKFROM_START) &&
+        args1.len() == 1 &&
+        let ExprKind::Lit(ref lit) = args1[0].kind &&
+        let LitKind::Int(0, LitIntType::Unsuffixed) = lit.node
+    {
+        let method_call_span = expr.span.with_lo(name_span.lo());
+        span_lint_and_then(
+            cx,
+            SEEK_TO_START_INSTEAD_OF_REWIND,
+            method_call_span,
+            "used `seek` to go to the start of the stream",
+            |diag| {
+                let app = Applicability::MachineApplicable;
+
+                diag.span_suggestion(method_call_span, "replace with", "rewind()", app);
+            },
+        );
+    }
+}
diff --git a/src/docs/rewind_instead_of_seek_to_start.txt b/src/docs/rewind_instead_of_seek_to_start.txt
deleted file mode 100644
index bef11b2312a..00000000000
--- a/src/docs/rewind_instead_of_seek_to_start.txt
+++ /dev/null
@@ -1,22 +0,0 @@
-### What it does
-
-Checks for jumps to the start of a stream that implements `Seek`
-and uses the `seek` method providing `Start` as parameter.
-
-### Why is this bad?
-
-Readability. There is a specific method that was implemented for
-this exact scenario.
-
-### Example
-```
-fn foo<T: io::Seek>(t: &mut T) {
-    t.seek(io::SeekFrom::Start(0));
-}
-```
-Use instead:
-```
-fn foo<T: io::Seek>(t: &mut T) {
-    t.rewind();
-}
-```
\ No newline at end of file
diff --git a/src/docs/seek_to_start_instead_of_rewind.txt b/src/docs/seek_to_start_instead_of_rewind.txt
new file mode 100644
index 00000000000..bef11b2312a
--- /dev/null
+++ b/src/docs/seek_to_start_instead_of_rewind.txt
@@ -0,0 +1,22 @@
+### What it does
+
+Checks for jumps to the start of a stream that implements `Seek`
+and uses the `seek` method providing `Start` as parameter.
+
+### Why is this bad?
+
+Readability. There is a specific method that was implemented for
+this exact scenario.
+
+### Example
+```
+fn foo<T: io::Seek>(t: &mut T) {
+    t.seek(io::SeekFrom::Start(0));
+}
+```
+Use instead:
+```
+fn foo<T: io::Seek>(t: &mut T) {
+    t.rewind();
+}
+```
\ No newline at end of file
diff --git a/tests/ui/rewind_instead_of_seek_to_start.fixed b/tests/ui/rewind_instead_of_seek_to_start.fixed
deleted file mode 100644
index 36853780977..00000000000
--- a/tests/ui/rewind_instead_of_seek_to_start.fixed
+++ /dev/null
@@ -1,137 +0,0 @@
-// run-rustfix
-#![allow(unused)]
-#![feature(custom_inner_attributes)]
-#![warn(clippy::rewind_instead_of_seek_to_start)]
-
-use std::fs::OpenOptions;
-use std::io::{Read, Seek, SeekFrom, Write};
-
-struct StructWithSeekMethod {}
-
-impl StructWithSeekMethod {
-    fn seek(&mut self, from: SeekFrom) {}
-}
-
-trait MySeekTrait {
-    fn seek(&mut self, from: SeekFrom) {}
-}
-
-struct StructWithSeekTrait {}
-impl MySeekTrait for StructWithSeekTrait {}
-
-// This should NOT trigger clippy warning because
-// StructWithSeekMethod does not implement std::io::Seek;
-fn seek_to_start_false_method(t: &mut StructWithSeekMethod) {
-    t.seek(SeekFrom::Start(0));
-}
-
-// This should NOT trigger clippy warning because
-// StructWithSeekMethod does not implement std::io::Seek;
-fn seek_to_start_method_owned_false<T>(mut t: StructWithSeekMethod) {
-    t.seek(SeekFrom::Start(0));
-}
-
-// This should NOT trigger clippy warning because
-// StructWithSeekMethod does not implement std::io::Seek;
-fn seek_to_start_false_trait(t: &mut StructWithSeekTrait) {
-    t.seek(SeekFrom::Start(0));
-}
-
-// This should NOT trigger clippy warning because
-// StructWithSeekMethod does not implement std::io::Seek;
-fn seek_to_start_false_trait_owned<T>(mut t: StructWithSeekTrait) {
-    t.seek(SeekFrom::Start(0));
-}
-
-// This should NOT trigger clippy warning because
-// StructWithSeekMethod does not implement std::io::Seek;
-fn seek_to_start_false_trait_bound<T: MySeekTrait>(t: &mut T) {
-    t.seek(SeekFrom::Start(0));
-}
-
-// This should trigger clippy warning
-fn seek_to_start<T: Seek>(t: &mut T) {
-    t.rewind();
-}
-
-// This should trigger clippy warning
-fn owned_seek_to_start<T: Seek>(mut t: T) {
-    t.rewind();
-}
-
-// This should NOT trigger clippy warning because
-// it does not seek to start
-fn seek_to_5<T: Seek>(t: &mut T) {
-    t.seek(SeekFrom::Start(5));
-}
-
-// This should NOT trigger clippy warning because
-// it does not seek to start
-fn seek_to_end<T: Seek>(t: &mut T) {
-    t.seek(SeekFrom::End(0));
-}
-
-fn main() {
-    let mut f = OpenOptions::new()
-        .write(true)
-        .read(true)
-        .create(true)
-        .open("foo.txt")
-        .unwrap();
-
-    let mut my_struct_trait = StructWithSeekTrait {};
-    seek_to_start_false_trait_bound(&mut my_struct_trait);
-
-    let hello = "Hello!\n";
-    write!(f, "{hello}").unwrap();
-    seek_to_5(&mut f);
-    seek_to_end(&mut f);
-    seek_to_start(&mut f);
-
-    let mut buf = String::new();
-    f.read_to_string(&mut buf).unwrap();
-
-    assert_eq!(&buf, hello);
-}
-
-fn msrv_1_54() {
-    #![clippy::msrv = "1.54"]
-
-    let mut f = OpenOptions::new()
-        .write(true)
-        .read(true)
-        .create(true)
-        .open("foo.txt")
-        .unwrap();
-
-    let hello = "Hello!\n";
-    write!(f, "{hello}").unwrap();
-
-    f.seek(SeekFrom::Start(0));
-
-    let mut buf = String::new();
-    f.read_to_string(&mut buf).unwrap();
-
-    assert_eq!(&buf, hello);
-}
-
-fn msrv_1_55() {
-    #![clippy::msrv = "1.55"]
-
-    let mut f = OpenOptions::new()
-        .write(true)
-        .read(true)
-        .create(true)
-        .open("foo.txt")
-        .unwrap();
-
-    let hello = "Hello!\n";
-    write!(f, "{hello}").unwrap();
-
-    f.rewind();
-
-    let mut buf = String::new();
-    f.read_to_string(&mut buf).unwrap();
-
-    assert_eq!(&buf, hello);
-}
diff --git a/tests/ui/rewind_instead_of_seek_to_start.rs b/tests/ui/rewind_instead_of_seek_to_start.rs
deleted file mode 100644
index 0d061b58fba..00000000000
--- a/tests/ui/rewind_instead_of_seek_to_start.rs
+++ /dev/null
@@ -1,137 +0,0 @@
-// run-rustfix
-#![allow(unused)]
-#![feature(custom_inner_attributes)]
-#![warn(clippy::rewind_instead_of_seek_to_start)]
-
-use std::fs::OpenOptions;
-use std::io::{Read, Seek, SeekFrom, Write};
-
-struct StructWithSeekMethod {}
-
-impl StructWithSeekMethod {
-    fn seek(&mut self, from: SeekFrom) {}
-}
-
-trait MySeekTrait {
-    fn seek(&mut self, from: SeekFrom) {}
-}
-
-struct StructWithSeekTrait {}
-impl MySeekTrait for StructWithSeekTrait {}
-
-// This should NOT trigger clippy warning because
-// StructWithSeekMethod does not implement std::io::Seek;
-fn seek_to_start_false_method(t: &mut StructWithSeekMethod) {
-    t.seek(SeekFrom::Start(0));
-}
-
-// This should NOT trigger clippy warning because
-// StructWithSeekMethod does not implement std::io::Seek;
-fn seek_to_start_method_owned_false<T>(mut t: StructWithSeekMethod) {
-    t.seek(SeekFrom::Start(0));
-}
-
-// This should NOT trigger clippy warning because
-// StructWithSeekMethod does not implement std::io::Seek;
-fn seek_to_start_false_trait(t: &mut StructWithSeekTrait) {
-    t.seek(SeekFrom::Start(0));
-}
-
-// This should NOT trigger clippy warning because
-// StructWithSeekMethod does not implement std::io::Seek;
-fn seek_to_start_false_trait_owned<T>(mut t: StructWithSeekTrait) {
-    t.seek(SeekFrom::Start(0));
-}
-
-// This should NOT trigger clippy warning because
-// StructWithSeekMethod does not implement std::io::Seek;
-fn seek_to_start_false_trait_bound<T: MySeekTrait>(t: &mut T) {
-    t.seek(SeekFrom::Start(0));
-}
-
-// This should trigger clippy warning
-fn seek_to_start<T: Seek>(t: &mut T) {
-    t.seek(SeekFrom::Start(0));
-}
-
-// This should trigger clippy warning
-fn owned_seek_to_start<T: Seek>(mut t: T) {
-    t.seek(SeekFrom::Start(0));
-}
-
-// This should NOT trigger clippy warning because
-// it does not seek to start
-fn seek_to_5<T: Seek>(t: &mut T) {
-    t.seek(SeekFrom::Start(5));
-}
-
-// This should NOT trigger clippy warning because
-// it does not seek to start
-fn seek_to_end<T: Seek>(t: &mut T) {
-    t.seek(SeekFrom::End(0));
-}
-
-fn main() {
-    let mut f = OpenOptions::new()
-        .write(true)
-        .read(true)
-        .create(true)
-        .open("foo.txt")
-        .unwrap();
-
-    let mut my_struct_trait = StructWithSeekTrait {};
-    seek_to_start_false_trait_bound(&mut my_struct_trait);
-
-    let hello = "Hello!\n";
-    write!(f, "{hello}").unwrap();
-    seek_to_5(&mut f);
-    seek_to_end(&mut f);
-    seek_to_start(&mut f);
-
-    let mut buf = String::new();
-    f.read_to_string(&mut buf).unwrap();
-
-    assert_eq!(&buf, hello);
-}
-
-fn msrv_1_54() {
-    #![clippy::msrv = "1.54"]
-
-    let mut f = OpenOptions::new()
-        .write(true)
-        .read(true)
-        .create(true)
-        .open("foo.txt")
-        .unwrap();
-
-    let hello = "Hello!\n";
-    write!(f, "{hello}").unwrap();
-
-    f.seek(SeekFrom::Start(0));
-
-    let mut buf = String::new();
-    f.read_to_string(&mut buf).unwrap();
-
-    assert_eq!(&buf, hello);
-}
-
-fn msrv_1_55() {
-    #![clippy::msrv = "1.55"]
-
-    let mut f = OpenOptions::new()
-        .write(true)
-        .read(true)
-        .create(true)
-        .open("foo.txt")
-        .unwrap();
-
-    let hello = "Hello!\n";
-    write!(f, "{hello}").unwrap();
-
-    f.seek(SeekFrom::Start(0));
-
-    let mut buf = String::new();
-    f.read_to_string(&mut buf).unwrap();
-
-    assert_eq!(&buf, hello);
-}
diff --git a/tests/ui/rewind_instead_of_seek_to_start.stderr b/tests/ui/rewind_instead_of_seek_to_start.stderr
deleted file mode 100644
index e8086781084..00000000000
--- a/tests/ui/rewind_instead_of_seek_to_start.stderr
+++ /dev/null
@@ -1,22 +0,0 @@
-error: used `seek` to go to the start of the stream
-  --> $DIR/rewind_instead_of_seek_to_start.rs:54:7
-   |
-LL |     t.seek(SeekFrom::Start(0));
-   |       ^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `rewind()`
-   |
-   = note: `-D clippy::rewind-instead-of-seek-to-start` implied by `-D warnings`
-
-error: used `seek` to go to the start of the stream
-  --> $DIR/rewind_instead_of_seek_to_start.rs:59:7
-   |
-LL |     t.seek(SeekFrom::Start(0));
-   |       ^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `rewind()`
-
-error: used `seek` to go to the start of the stream
-  --> $DIR/rewind_instead_of_seek_to_start.rs:131:7
-   |
-LL |     f.seek(SeekFrom::Start(0));
-   |       ^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `rewind()`
-
-error: aborting due to 3 previous errors
-
diff --git a/tests/ui/seek_to_start_instead_of_rewind.fixed b/tests/ui/seek_to_start_instead_of_rewind.fixed
new file mode 100644
index 00000000000..464b6cdef63
--- /dev/null
+++ b/tests/ui/seek_to_start_instead_of_rewind.fixed
@@ -0,0 +1,137 @@
+// run-rustfix
+#![allow(unused)]
+#![feature(custom_inner_attributes)]
+#![warn(clippy::seek_to_start_instead_of_rewind)]
+
+use std::fs::OpenOptions;
+use std::io::{Read, Seek, SeekFrom, Write};
+
+struct StructWithSeekMethod {}
+
+impl StructWithSeekMethod {
+    fn seek(&mut self, from: SeekFrom) {}
+}
+
+trait MySeekTrait {
+    fn seek(&mut self, from: SeekFrom) {}
+}
+
+struct StructWithSeekTrait {}
+impl MySeekTrait for StructWithSeekTrait {}
+
+// This should NOT trigger clippy warning because
+// StructWithSeekMethod does not implement std::io::Seek;
+fn seek_to_start_false_method(t: &mut StructWithSeekMethod) {
+    t.seek(SeekFrom::Start(0));
+}
+
+// This should NOT trigger clippy warning because
+// StructWithSeekMethod does not implement std::io::Seek;
+fn seek_to_start_method_owned_false<T>(mut t: StructWithSeekMethod) {
+    t.seek(SeekFrom::Start(0));
+}
+
+// This should NOT trigger clippy warning because
+// StructWithSeekMethod does not implement std::io::Seek;
+fn seek_to_start_false_trait(t: &mut StructWithSeekTrait) {
+    t.seek(SeekFrom::Start(0));
+}
+
+// This should NOT trigger clippy warning because
+// StructWithSeekMethod does not implement std::io::Seek;
+fn seek_to_start_false_trait_owned<T>(mut t: StructWithSeekTrait) {
+    t.seek(SeekFrom::Start(0));
+}
+
+// This should NOT trigger clippy warning because
+// StructWithSeekMethod does not implement std::io::Seek;
+fn seek_to_start_false_trait_bound<T: MySeekTrait>(t: &mut T) {
+    t.seek(SeekFrom::Start(0));
+}
+
+// This should trigger clippy warning
+fn seek_to_start<T: Seek>(t: &mut T) {
+    t.rewind();
+}
+
+// This should trigger clippy warning
+fn owned_seek_to_start<T: Seek>(mut t: T) {
+    t.rewind();
+}
+
+// This should NOT trigger clippy warning because
+// it does not seek to start
+fn seek_to_5<T: Seek>(t: &mut T) {
+    t.seek(SeekFrom::Start(5));
+}
+
+// This should NOT trigger clippy warning because
+// it does not seek to start
+fn seek_to_end<T: Seek>(t: &mut T) {
+    t.seek(SeekFrom::End(0));
+}
+
+fn main() {
+    let mut f = OpenOptions::new()
+        .write(true)
+        .read(true)
+        .create(true)
+        .open("foo.txt")
+        .unwrap();
+
+    let mut my_struct_trait = StructWithSeekTrait {};
+    seek_to_start_false_trait_bound(&mut my_struct_trait);
+
+    let hello = "Hello!\n";
+    write!(f, "{hello}").unwrap();
+    seek_to_5(&mut f);
+    seek_to_end(&mut f);
+    seek_to_start(&mut f);
+
+    let mut buf = String::new();
+    f.read_to_string(&mut buf).unwrap();
+
+    assert_eq!(&buf, hello);
+}
+
+fn msrv_1_54() {
+    #![clippy::msrv = "1.54"]
+
+    let mut f = OpenOptions::new()
+        .write(true)
+        .read(true)
+        .create(true)
+        .open("foo.txt")
+        .unwrap();
+
+    let hello = "Hello!\n";
+    write!(f, "{hello}").unwrap();
+
+    f.seek(SeekFrom::Start(0));
+
+    let mut buf = String::new();
+    f.read_to_string(&mut buf).unwrap();
+
+    assert_eq!(&buf, hello);
+}
+
+fn msrv_1_55() {
+    #![clippy::msrv = "1.55"]
+
+    let mut f = OpenOptions::new()
+        .write(true)
+        .read(true)
+        .create(true)
+        .open("foo.txt")
+        .unwrap();
+
+    let hello = "Hello!\n";
+    write!(f, "{hello}").unwrap();
+
+    f.rewind();
+
+    let mut buf = String::new();
+    f.read_to_string(&mut buf).unwrap();
+
+    assert_eq!(&buf, hello);
+}
diff --git a/tests/ui/seek_to_start_instead_of_rewind.rs b/tests/ui/seek_to_start_instead_of_rewind.rs
new file mode 100644
index 00000000000..68e09bd7c1f
--- /dev/null
+++ b/tests/ui/seek_to_start_instead_of_rewind.rs
@@ -0,0 +1,137 @@
+// run-rustfix
+#![allow(unused)]
+#![feature(custom_inner_attributes)]
+#![warn(clippy::seek_to_start_instead_of_rewind)]
+
+use std::fs::OpenOptions;
+use std::io::{Read, Seek, SeekFrom, Write};
+
+struct StructWithSeekMethod {}
+
+impl StructWithSeekMethod {
+    fn seek(&mut self, from: SeekFrom) {}
+}
+
+trait MySeekTrait {
+    fn seek(&mut self, from: SeekFrom) {}
+}
+
+struct StructWithSeekTrait {}
+impl MySeekTrait for StructWithSeekTrait {}
+
+// This should NOT trigger clippy warning because
+// StructWithSeekMethod does not implement std::io::Seek;
+fn seek_to_start_false_method(t: &mut StructWithSeekMethod) {
+    t.seek(SeekFrom::Start(0));
+}
+
+// This should NOT trigger clippy warning because
+// StructWithSeekMethod does not implement std::io::Seek;
+fn seek_to_start_method_owned_false<T>(mut t: StructWithSeekMethod) {
+    t.seek(SeekFrom::Start(0));
+}
+
+// This should NOT trigger clippy warning because
+// StructWithSeekMethod does not implement std::io::Seek;
+fn seek_to_start_false_trait(t: &mut StructWithSeekTrait) {
+    t.seek(SeekFrom::Start(0));
+}
+
+// This should NOT trigger clippy warning because
+// StructWithSeekMethod does not implement std::io::Seek;
+fn seek_to_start_false_trait_owned<T>(mut t: StructWithSeekTrait) {
+    t.seek(SeekFrom::Start(0));
+}
+
+// This should NOT trigger clippy warning because
+// StructWithSeekMethod does not implement std::io::Seek;
+fn seek_to_start_false_trait_bound<T: MySeekTrait>(t: &mut T) {
+    t.seek(SeekFrom::Start(0));
+}
+
+// This should trigger clippy warning
+fn seek_to_start<T: Seek>(t: &mut T) {
+    t.seek(SeekFrom::Start(0));
+}
+
+// This should trigger clippy warning
+fn owned_seek_to_start<T: Seek>(mut t: T) {
+    t.seek(SeekFrom::Start(0));
+}
+
+// This should NOT trigger clippy warning because
+// it does not seek to start
+fn seek_to_5<T: Seek>(t: &mut T) {
+    t.seek(SeekFrom::Start(5));
+}
+
+// This should NOT trigger clippy warning because
+// it does not seek to start
+fn seek_to_end<T: Seek>(t: &mut T) {
+    t.seek(SeekFrom::End(0));
+}
+
+fn main() {
+    let mut f = OpenOptions::new()
+        .write(true)
+        .read(true)
+        .create(true)
+        .open("foo.txt")
+        .unwrap();
+
+    let mut my_struct_trait = StructWithSeekTrait {};
+    seek_to_start_false_trait_bound(&mut my_struct_trait);
+
+    let hello = "Hello!\n";
+    write!(f, "{hello}").unwrap();
+    seek_to_5(&mut f);
+    seek_to_end(&mut f);
+    seek_to_start(&mut f);
+
+    let mut buf = String::new();
+    f.read_to_string(&mut buf).unwrap();
+
+    assert_eq!(&buf, hello);
+}
+
+fn msrv_1_54() {
+    #![clippy::msrv = "1.54"]
+
+    let mut f = OpenOptions::new()
+        .write(true)
+        .read(true)
+        .create(true)
+        .open("foo.txt")
+        .unwrap();
+
+    let hello = "Hello!\n";
+    write!(f, "{hello}").unwrap();
+
+    f.seek(SeekFrom::Start(0));
+
+    let mut buf = String::new();
+    f.read_to_string(&mut buf).unwrap();
+
+    assert_eq!(&buf, hello);
+}
+
+fn msrv_1_55() {
+    #![clippy::msrv = "1.55"]
+
+    let mut f = OpenOptions::new()
+        .write(true)
+        .read(true)
+        .create(true)
+        .open("foo.txt")
+        .unwrap();
+
+    let hello = "Hello!\n";
+    write!(f, "{hello}").unwrap();
+
+    f.seek(SeekFrom::Start(0));
+
+    let mut buf = String::new();
+    f.read_to_string(&mut buf).unwrap();
+
+    assert_eq!(&buf, hello);
+}
diff --git a/tests/ui/seek_to_start_instead_of_rewind.stderr b/tests/ui/seek_to_start_instead_of_rewind.stderr
new file mode 100644
index 00000000000..de0eec5d909
--- /dev/null
+++ b/tests/ui/seek_to_start_instead_of_rewind.stderr
@@ -0,0 +1,22 @@
+error: used `seek` to go to the start of the stream
+  --> $DIR/seek_to_start_instead_of_rewind.rs:54:7
+   |
+LL |     t.seek(SeekFrom::Start(0));
+   |       ^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `rewind()`
+   |
+   = note: `-D clippy::seek-to-start-instead-of-rewind` implied by `-D warnings`
+
+error: used `seek` to go to the start of the stream
+  --> $DIR/seek_to_start_instead_of_rewind.rs:59:7
+   |
+LL |     t.seek(SeekFrom::Start(0));
+   |       ^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `rewind()`
+
+error: used `seek` to go to the start of the stream
+  --> $DIR/seek_to_start_instead_of_rewind.rs:131:7
+   |
+LL |     f.seek(SeekFrom::Start(0));
+   |       ^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `rewind()`
+
+error: aborting due to 3 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 0e360d0b210b945db8bca2b55d22a2d8eac45c4c Mon Sep 17 00:00:00 2001
From: JT <547158+jntrnr@users.noreply.github.com>
Date: Tue, 25 Oct 2022 06:03:51 +1300
Subject: Move needless_collect to nursery

---
 clippy_lints/src/loops/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/mod.rs b/clippy_lints/src/loops/mod.rs
index bcf278d9c83..821fe173023 100644
--- a/clippy_lints/src/loops/mod.rs
+++ b/clippy_lints/src/loops/mod.rs
@@ -223,7 +223,7 @@ declare_clippy_lint! {
     /// ```
     #[clippy::version = "1.30.0"]
     pub NEEDLESS_COLLECT,
-    perf,
+    nursery,
     "collecting an iterator when collect is not needed"
 }
 
-- 
cgit 1.4.1-3-g733a5


From f827be92fcdb225738a73051f75cb5e1243fe615 Mon Sep 17 00:00:00 2001
From: est31 <MTest31@outlook.com>
Date: Sun, 13 Feb 2022 03:11:06 +0100
Subject: Add lint to tell about let else pattern

---
 CHANGELOG.md                        |   1 +
 clippy_lints/src/declared_lints.rs  |   1 +
 clippy_lints/src/lib.rs             |   2 +
 clippy_lints/src/manual_let_else.rs | 160 ++++++++++++++++++++++++++++++++++
 clippy_lints/src/utils/conf.rs      |   2 +-
 clippy_utils/src/msrvs.rs           |   1 +
 src/docs/manual_let_else.txt        |  20 +++++
 tests/ui/manual_let_else.rs         | 167 ++++++++++++++++++++++++++++++++++++
 tests/ui/manual_let_else.stderr     | 104 ++++++++++++++++++++++
 9 files changed, 457 insertions(+), 1 deletion(-)
 create mode 100644 clippy_lints/src/manual_let_else.rs
 create mode 100644 src/docs/manual_let_else.txt
 create mode 100644 tests/ui/manual_let_else.rs
 create mode 100644 tests/ui/manual_let_else.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index cb5a4d4a577..b5a1d194794 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3997,6 +3997,7 @@ Released 2018-09-13
 [`manual_find_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_find_map
 [`manual_flatten`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_flatten
 [`manual_instant_elapsed`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_instant_elapsed
+[`manual_let_else`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_let_else
 [`manual_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_map
 [`manual_memcpy`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_memcpy
 [`manual_non_exhaustive`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_non_exhaustive
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index c6ae0bddc5a..2bb8dfee152 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -251,6 +251,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::manual_bits::MANUAL_BITS_INFO,
     crate::manual_clamp::MANUAL_CLAMP_INFO,
     crate::manual_instant_elapsed::MANUAL_INSTANT_ELAPSED_INFO,
+    crate::manual_let_else::MANUAL_LET_ELSE_INFO,
     crate::manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE_INFO,
     crate::manual_rem_euclid::MANUAL_REM_EUCLID_INFO,
     crate::manual_retain::MANUAL_RETAIN_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 7837e04bca1..b261beab793 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -170,6 +170,7 @@ mod manual_async_fn;
 mod manual_bits;
 mod manual_clamp;
 mod manual_instant_elapsed;
+mod manual_let_else;
 mod manual_non_exhaustive;
 mod manual_rem_euclid;
 mod manual_retain;
@@ -603,6 +604,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         ))
     });
     store.register_late_pass(move |_| Box::new(matches::Matches::new(msrv)));
+    store.register_late_pass(move |_| Box::new(manual_let_else::ManualLetElse::new(msrv)));
     store.register_early_pass(move || Box::new(manual_non_exhaustive::ManualNonExhaustiveStruct::new(msrv)));
     store.register_late_pass(move |_| Box::new(manual_non_exhaustive::ManualNonExhaustiveEnum::new(msrv)));
     store.register_late_pass(move |_| Box::new(manual_strip::ManualStrip::new(msrv)));
diff --git a/clippy_lints/src/manual_let_else.rs b/clippy_lints/src/manual_let_else.rs
new file mode 100644
index 00000000000..8983cd7ae1c
--- /dev/null
+++ b/clippy_lints/src/manual_let_else.rs
@@ -0,0 +1,160 @@
+use clippy_utils::diagnostics::span_lint;
+use clippy_utils::visitors::{for_each_expr, Descend};
+use clippy_utils::{higher, meets_msrv, msrvs, peel_blocks};
+use if_chain::if_chain;
+use rustc_hir::{Expr, ExprKind, Pat, QPath, Stmt, StmtKind};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_middle::lint::in_external_macro;
+use rustc_semver::RustcVersion;
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+use std::ops::ControlFlow;
+
+declare_clippy_lint! {
+    /// ### What it does
+    ///
+    /// Warn of cases where `let...else` could be used
+    ///
+    /// ### Why is this bad?
+    ///
+    /// `let...else` provides a standard construct for this pattern
+    /// that people can easily recognize. It's also more compact.
+    ///
+    /// ### Example
+    ///
+    /// ```rust
+    /// # let w = Some(0);
+    /// let v = if let Some(v) = w { v } else { return };
+    /// ```
+    ///
+    /// Could be written:
+    ///
+    /// ```rust
+    /// # #![feature(let_else)]
+    /// # fn main () {
+    /// # let w = Some(0);
+    /// let Some(v) = w else { return };
+    /// # }
+    /// ```
+    #[clippy::version = "1.67.0"]
+    pub MANUAL_LET_ELSE,
+    pedantic,
+    "manual implementation of a let...else statement"
+}
+
+pub struct ManualLetElse {
+    msrv: Option<RustcVersion>,
+}
+
+impl ManualLetElse {
+    #[must_use]
+    pub fn new(msrv: Option<RustcVersion>) -> Self {
+        Self { msrv }
+    }
+}
+
+impl_lint_pass!(ManualLetElse => [MANUAL_LET_ELSE]);
+
+impl<'tcx> LateLintPass<'tcx> for ManualLetElse {
+    fn check_stmt(&mut self, cx: &LateContext<'_>, stmt: &'tcx Stmt<'tcx>) {
+        if !meets_msrv(self.msrv, msrvs::LET_ELSE) {
+            return;
+        }
+
+        if in_external_macro(cx.sess(), stmt.span) {
+            return;
+        }
+
+        if_chain! {
+            if let StmtKind::Local(local) = stmt.kind;
+            if let Some(init) = local.init;
+            if let Some(higher::IfLet { let_pat, let_expr: _, if_then, if_else }) = higher::IfLet::hir(cx, init);
+            if if_then_simple_identity(let_pat, if_then);
+            if let Some(if_else) = if_else;
+            if expr_diverges(cx, if_else);
+            then {
+                span_lint(
+                    cx,
+                    MANUAL_LET_ELSE,
+                    stmt.span,
+                    "this could be rewritten as `let else`",
+                );
+            }
+        }
+    }
+
+    extract_msrv_attr!(LateContext);
+}
+
+fn expr_diverges(cx: &LateContext<'_>, expr: &'_ Expr<'_>) -> bool {
+    fn is_never(cx: &LateContext<'_>, expr: &'_ Expr<'_>) -> bool {
+        if let Some(ty) = cx.typeck_results().expr_ty_opt(expr) {
+            return ty.is_never();
+        }
+        false
+    }
+    // We can't just call is_never on expr and be done, because the type system
+    // sometimes coerces the ! type to something different before we can get
+    // our hands on it. So instead, we do a manual search. We do fall back to
+    // is_never in some places when there is no better alternative.
+    for_each_expr(expr, |ex| {
+        match ex.kind {
+            ExprKind::Continue(_) | ExprKind::Break(_, _) | ExprKind::Ret(_) => ControlFlow::Break(()),
+            ExprKind::Call(call, _) => {
+                if is_never(cx, ex) || is_never(cx, call) {
+                    return ControlFlow::Break(());
+                }
+                ControlFlow::Continue(Descend::Yes)
+            },
+            ExprKind::MethodCall(..) => {
+                if is_never(cx, ex) {
+                    return ControlFlow::Break(());
+                }
+                ControlFlow::Continue(Descend::Yes)
+            },
+            ExprKind::If(if_expr, if_then, if_else) => {
+                let else_diverges = if_else.map_or(false, |ex| expr_diverges(cx, ex));
+                let diverges = expr_diverges(cx, if_expr) || (else_diverges && expr_diverges(cx, if_then));
+                if diverges {
+                    return ControlFlow::Break(());
+                }
+                ControlFlow::Continue(Descend::No)
+            },
+            ExprKind::Match(match_expr, match_arms, _) => {
+                let diverges =
+                    expr_diverges(cx, match_expr) || match_arms.iter().all(|arm| expr_diverges(cx, arm.body));
+                if diverges {
+                    return ControlFlow::Break(());
+                }
+                ControlFlow::Continue(Descend::No)
+            },
+
+            // Don't continue into loops or labeled blocks, as they are breakable,
+            // and we'd have to start checking labels.
+            ExprKind::Block(_, Some(_)) | ExprKind::Loop(..) => ControlFlow::Continue(Descend::No),
+
+            // Default: descend
+            _ => ControlFlow::Continue(Descend::Yes),
+        }
+    })
+    .is_some()
+}
+
+/// Checks if the passed `if_then` is a simple identity
+fn if_then_simple_identity(let_pat: &'_ Pat<'_>, if_then: &'_ Expr<'_>) -> bool {
+    // TODO support patterns with multiple bindings and tuples, like:
+    //   let (foo, bar) = if let (Some(foo), bar) = g() { (foo, bar) } else { ... }
+    if_chain! {
+        if let ExprKind::Path(QPath::Resolved(_ty, path)) = &peel_blocks(if_then).kind;
+        if let [path_seg] = path.segments;
+        then {
+            let mut pat_bindings = Vec::new();
+            let_pat.each_binding(|_ann, _hir_id, _sp, ident| {
+                pat_bindings.push(ident);
+            });
+            if let [binding] = &pat_bindings[..] {
+                return path_seg.ident == *binding;
+            }
+        }
+    }
+    false
+}
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index a10de31556c..1aa86efd38f 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -213,7 +213,7 @@ define_Conf! {
     ///
     /// Suppress lints whenever the suggested change would cause breakage for other crates.
     (avoid_breaking_exported_api: bool = true),
-    /// Lint: MANUAL_SPLIT_ONCE, MANUAL_STR_REPEAT, CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR, IF_THEN_SOME_ELSE_NONE, APPROX_CONSTANT, DEPRECATED_CFG_ATTR, INDEX_REFUTABLE_SLICE, MAP_CLONE, BORROW_AS_PTR, MANUAL_BITS, ERR_EXPECT, CAST_ABS_TO_UNSIGNED, UNINLINED_FORMAT_ARGS, MANUAL_CLAMP.
+    /// Lint: MANUAL_SPLIT_ONCE, MANUAL_STR_REPEAT, CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR, IF_THEN_SOME_ELSE_NONE, APPROX_CONSTANT, DEPRECATED_CFG_ATTR, INDEX_REFUTABLE_SLICE, MAP_CLONE, BORROW_AS_PTR, MANUAL_BITS, ERR_EXPECT, CAST_ABS_TO_UNSIGNED, UNINLINED_FORMAT_ARGS, MANUAL_CLAMP, MANUAL_LET_ELSE.
     ///
     /// The minimum rust version that the project supports
     (msrv: Option<String> = None),
diff --git a/clippy_utils/src/msrvs.rs b/clippy_utils/src/msrvs.rs
index 8b843732a23..9780794fa99 100644
--- a/clippy_utils/src/msrvs.rs
+++ b/clippy_utils/src/msrvs.rs
@@ -12,6 +12,7 @@ macro_rules! msrv_aliases {
 
 // names may refer to stabilized feature flags or library items
 msrv_aliases! {
+    1,65,0 { LET_ELSE }
     1,62,0 { BOOL_THEN_SOME }
     1,58,0 { FORMAT_ARGS_CAPTURE }
     1,53,0 { OR_PATTERNS, MANUAL_BITS, BTREE_MAP_RETAIN, BTREE_SET_RETAIN, ARRAY_INTO_ITERATOR }
diff --git a/src/docs/manual_let_else.txt b/src/docs/manual_let_else.txt
new file mode 100644
index 00000000000..14166709f7f
--- /dev/null
+++ b/src/docs/manual_let_else.txt
@@ -0,0 +1,20 @@
+### What it does
+
+Warn of cases where `let...else` could be used
+
+### Why is this bad?
+
+`let...else` provides a standard construct for this pattern
+that people can easily recognize. It's also more compact.
+
+### Example
+
+```
+let v = if let Some(v) = w { v } else { return };
+```
+
+Could be written:
+
+```
+let Some(v) = w else { return };
+```
\ No newline at end of file
diff --git a/tests/ui/manual_let_else.rs b/tests/ui/manual_let_else.rs
new file mode 100644
index 00000000000..f2827e22500
--- /dev/null
+++ b/tests/ui/manual_let_else.rs
@@ -0,0 +1,167 @@
+#![allow(unused_braces, unused_variables, dead_code)]
+#![allow(
+    clippy::collapsible_else_if,
+    clippy::unused_unit,
+    clippy::never_loop,
+    clippy::let_unit_value
+)]
+#![warn(clippy::manual_let_else)]
+
+fn g() -> Option<()> {
+    None
+}
+
+fn main() {}
+
+fn fire() {
+    let v = if let Some(v_some) = g() { v_some } else { return };
+    let v = if let Some(v_some) = g() {
+        v_some
+    } else {
+        return;
+    };
+
+    let v = if let Some(v) = g() {
+        // Blocks around the identity should have no impact
+        {
+            { v }
+        }
+    } else {
+        // Some computation should still make it fire
+        g();
+        return;
+    };
+
+    // continue and break diverge
+    loop {
+        let v = if let Some(v_some) = g() { v_some } else { continue };
+        let v = if let Some(v_some) = g() { v_some } else { break };
+    }
+
+    // panic also diverges
+    let v = if let Some(v_some) = g() { v_some } else { panic!() };
+
+    // abort also diverges
+    let v = if let Some(v_some) = g() {
+        v_some
+    } else {
+        std::process::abort()
+    };
+
+    // If whose two branches diverge also diverges
+    let v = if let Some(v_some) = g() {
+        v_some
+    } else {
+        if true { return } else { panic!() }
+    };
+
+    // Top level else if
+    let v = if let Some(v_some) = g() {
+        v_some
+    } else if true {
+        return;
+    } else {
+        panic!("diverge");
+    };
+
+    // All match arms diverge
+    let v = if let Some(v_some) = g() {
+        v_some
+    } else {
+        match (g(), g()) {
+            (Some(_), None) => return,
+            (None, Some(_)) => {
+                if true {
+                    return;
+                } else {
+                    panic!();
+                }
+            },
+            _ => return,
+        }
+    };
+
+    // Tuples supported for the declared variables
+    let (v, w) = if let Some(v_some) = g().map(|v| (v, 42)) {
+        v_some
+    } else {
+        return;
+    };
+}
+
+fn not_fire() {
+    let v = if let Some(v_some) = g() {
+        // Nothing returned. Should not fire.
+    } else {
+        return;
+    };
+
+    let w = 0;
+    let v = if let Some(v_some) = g() {
+        // Different variable than v_some. Should not fire.
+        w
+    } else {
+        return;
+    };
+
+    let v = if let Some(v_some) = g() {
+        // Computation in then clause. Should not fire.
+        g();
+        v_some
+    } else {
+        return;
+    };
+
+    let v = if let Some(v_some) = g() {
+        v_some
+    } else {
+        if false {
+            return;
+        }
+        // This doesn't diverge. Should not fire.
+        ()
+    };
+
+    let v = if let Some(v_some) = g() {
+        v_some
+    } else {
+        // There is one match arm that doesn't diverge. Should not fire.
+        match (g(), g()) {
+            (Some(_), None) => return,
+            (None, Some(_)) => return,
+            (Some(_), Some(_)) => (),
+            _ => return,
+        }
+    };
+
+    let v = if let Some(v_some) = g() {
+        v_some
+    } else {
+        // loop with a break statement inside does not diverge.
+        loop {
+            break;
+        }
+    };
+
+
+    let v = if let Some(v_some) = g() {
+        v_some
+    } else {
+        enum Uninhabited {}
+        fn un() -> Uninhabited {
+            panic!()
+        }
+        // Don't lint if the type is uninhabited but not !
+        un()
+    };
+
+    fn question_mark() -> Option<()> {
+        let v = if let Some(v) = g() {
+            v
+        } else {
+            // Question mark does not diverge
+            g()?
+        };
+        Some(v)
+    }
+}
diff --git a/tests/ui/manual_let_else.stderr b/tests/ui/manual_let_else.stderr
new file mode 100644
index 00000000000..461de79f6b9
--- /dev/null
+++ b/tests/ui/manual_let_else.stderr
@@ -0,0 +1,104 @@
+error: this could be rewritten as `let else`
+  --> $DIR/manual_let_else.rs:17:5
+   |
+LL |     let v = if let Some(v_some) = g() { v_some } 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:18:5
+   |
+LL | /     let v = if let Some(v_some) = g() {
+LL | |         v_some
+LL | |     } else {
+LL | |         return;
+LL | |     };
+   | |______^
+
+error: this could be rewritten as `let else`
+  --> $DIR/manual_let_else.rs:24:5
+   |
+LL | /     let v = if let Some(v) = g() {
+LL | |         // Blocks around the identity should have no impact
+LL | |         {
+LL | |             { v }
+...  |
+LL | |         return;
+LL | |     };
+   | |______^
+
+error: this could be rewritten as `let else`
+  --> $DIR/manual_let_else.rs:37:9
+   |
+LL |         let v = if let Some(v_some) = g() { v_some } else { continue };
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: this could be rewritten as `let else`
+  --> $DIR/manual_let_else.rs:38:9
+   |
+LL |         let v = if let Some(v_some) = g() { v_some } else { break };
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: this could be rewritten as `let else`
+  --> $DIR/manual_let_else.rs:42:5
+   |
+LL |     let v = if let Some(v_some) = g() { v_some } else { panic!() };
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: this could be rewritten as `let else`
+  --> $DIR/manual_let_else.rs:45:5
+   |
+LL | /     let v = if let Some(v_some) = g() {
+LL | |         v_some
+LL | |     } else {
+LL | |         std::process::abort()
+LL | |     };
+   | |______^
+
+error: this could be rewritten as `let else`
+  --> $DIR/manual_let_else.rs:52:5
+   |
+LL | /     let v = if let Some(v_some) = g() {
+LL | |         v_some
+LL | |     } else {
+LL | |         if true { return } else { panic!() }
+LL | |     };
+   | |______^
+
+error: this could be rewritten as `let else`
+  --> $DIR/manual_let_else.rs:59:5
+   |
+LL | /     let v = if let Some(v_some) = g() {
+LL | |         v_some
+LL | |     } else if true {
+LL | |         return;
+LL | |     } else {
+LL | |         panic!("diverge");
+LL | |     };
+   | |______^
+
+error: this could be rewritten as `let else`
+  --> $DIR/manual_let_else.rs:68:5
+   |
+LL | /     let v = if let Some(v_some) = g() {
+LL | |         v_some
+LL | |     } else {
+LL | |         match (g(), g()) {
+...  |
+LL | |         }
+LL | |     };
+   | |______^
+
+error: this could be rewritten as `let else`
+  --> $DIR/manual_let_else.rs:85:5
+   |
+LL | /     let (v, w) = if let Some(v_some) = g().map(|v| (v, 42)) {
+LL | |         v_some
+LL | |     } else {
+LL | |         return;
+LL | |     };
+   | |______^
+
+error: aborting due to 11 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 2e01e6b4c2d5a84723738575df788823c608dce7 Mon Sep 17 00:00:00 2001
From: est31 <MTest31@outlook.com>
Date: Wed, 16 Feb 2022 02:10:42 +0100
Subject: Also support linting for match

---
 clippy_lints/src/manual_let_else.rs   | 112 ++++++++++++++++++++++++++--------
 tests/ui/manual_let_else.rs           |  28 ++++++++-
 tests/ui/manual_let_else.stderr       |  13 +++-
 tests/ui/manual_let_else_match.rs     |  93 ++++++++++++++++++++++++++++
 tests/ui/manual_let_else_match.stderr |  40 ++++++++++++
 5 files changed, 257 insertions(+), 29 deletions(-)
 create mode 100644 tests/ui/manual_let_else_match.rs
 create mode 100644 tests/ui/manual_let_else_match.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_let_else.rs b/clippy_lints/src/manual_let_else.rs
index 8983cd7ae1c..98510ee9acd 100644
--- a/clippy_lints/src/manual_let_else.rs
+++ b/clippy_lints/src/manual_let_else.rs
@@ -1,12 +1,14 @@
 use clippy_utils::diagnostics::span_lint;
+use clippy_utils::higher::IfLetOrMatch;
 use clippy_utils::visitors::{for_each_expr, Descend};
-use clippy_utils::{higher, meets_msrv, msrvs, peel_blocks};
+use clippy_utils::{meets_msrv, msrvs, peel_blocks};
 use if_chain::if_chain;
-use rustc_hir::{Expr, ExprKind, Pat, QPath, Stmt, StmtKind};
+use rustc_hir::{Expr, ExprKind, MatchSource, Pat, QPath, Stmt, StmtKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::Span;
 use std::ops::ControlFlow;
 
 declare_clippy_lint! {
@@ -56,29 +58,64 @@ impl_lint_pass!(ManualLetElse => [MANUAL_LET_ELSE]);
 
 impl<'tcx> LateLintPass<'tcx> for ManualLetElse {
     fn check_stmt(&mut self, cx: &LateContext<'_>, stmt: &'tcx Stmt<'tcx>) {
-        if !meets_msrv(self.msrv, msrvs::LET_ELSE) {
-            return;
-        }
-
-        if in_external_macro(cx.sess(), stmt.span) {
-            return;
-        }
-
-        if_chain! {
+        let if_let_or_match = if_chain! {
+            if meets_msrv(self.msrv, 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 let Some(higher::IfLet { let_pat, let_expr: _, if_then, if_else }) = higher::IfLet::hir(cx, init);
-            if if_then_simple_identity(let_pat, if_then);
-            if let Some(if_else) = if_else;
-            if expr_diverges(cx, if_else);
+            if !from_different_macros(init.span, stmt.span);
+            if let Some(if_let_or_match) = IfLetOrMatch::parse(cx, init);
             then {
-                span_lint(
-                    cx,
-                    MANUAL_LET_ELSE,
-                    stmt.span,
-                    "this could be rewritten as `let else`",
-                );
+                if_let_or_match
+            } else {
+                return;
             }
+        };
+
+        match if_let_or_match {
+            IfLetOrMatch::IfLet(_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 {
+                    span_lint(
+                        cx,
+                        MANUAL_LET_ELSE,
+                        stmt.span,
+                        "this could be rewritten as `let else`",
+                    );
+                }
+            },
+            IfLetOrMatch::Match(_match_expr, arms, source) => {
+                if source != MatchSource::Normal {
+                    return;
+                }
+                // Any other number than two arms doesn't (neccessarily)
+                // have a trivial mapping to let else.
+                if arms.len() != 2 {
+                    return;
+                }
+                // We iterate over both arms, trying to find one that is an identity,
+                // one that diverges. Our check needs to work regardless of the order
+                // of both arms.
+                let mut found_identity_arm = false;
+                let mut found_diverging_arm = false;
+                for arm in arms {
+                    // Guards don't give us an easy mapping to let else
+                    if arm.guard.is_some() {
+                        return;
+                    }
+                    if expr_is_simple_identity(arm.pat, arm.body) {
+                        found_identity_arm = true;
+                    } else if expr_diverges(cx, arm.body) && pat_has_no_bindings(arm.pat) {
+                        found_diverging_arm = true;
+                    }
+                }
+                if !(found_identity_arm && found_diverging_arm) {
+                    return;
+                }
+                span_lint(cx, MANUAL_LET_ELSE, stmt.span, "this could be rewritten as `let else`");
+            },
         }
     }
 
@@ -139,16 +176,39 @@ fn expr_diverges(cx: &LateContext<'_>, expr: &'_ Expr<'_>) -> bool {
     .is_some()
 }
 
-/// Checks if the passed `if_then` is a simple identity
-fn if_then_simple_identity(let_pat: &'_ Pat<'_>, if_then: &'_ Expr<'_>) -> bool {
+/// Returns true if the two spans come from different macro sites,
+/// or one comes from an invocation and the other is not from a macro at all.
+fn from_different_macros(span_a: Span, span_b: Span) -> bool {
+    // This pre-check is a speed up so that we don't build outer_expn_data unless needed.
+    match (span_a.from_expansion(), span_b.from_expansion()) {
+        (false, false) => return false,
+        (true, false) | (false, true) => return true,
+        // We need to determine if both are from the same macro
+        (true, true) => (),
+    }
+    let data_for_comparison = |sp: Span| {
+        let expn_data = sp.ctxt().outer_expn_data();
+        (expn_data.kind, expn_data.call_site)
+    };
+    data_for_comparison(span_a) != data_for_comparison(span_b)
+}
+
+fn pat_has_no_bindings(pat: &'_ Pat<'_>) -> bool {
+    let mut has_no_bindings = true;
+    pat.each_binding_or_first(&mut |_, _, _, _| has_no_bindings = false);
+    has_no_bindings
+}
+
+/// Checks if the passed block is a simple identity referring to bindings created by the pattern
+fn expr_is_simple_identity(pat: &'_ Pat<'_>, expr: &'_ Expr<'_>) -> bool {
     // TODO support patterns with multiple bindings and tuples, like:
-    //   let (foo, bar) = if let (Some(foo), bar) = g() { (foo, bar) } else { ... }
+    //   let ... = if let (Some(foo), bar) = g() { (foo, bar) } else { ... }
     if_chain! {
-        if let ExprKind::Path(QPath::Resolved(_ty, path)) = &peel_blocks(if_then).kind;
+        if let ExprKind::Path(QPath::Resolved(_ty, path)) = &peel_blocks(expr).kind;
         if let [path_seg] = path.segments;
         then {
             let mut pat_bindings = Vec::new();
-            let_pat.each_binding(|_ann, _hir_id, _sp, ident| {
+            pat.each_binding_or_first(&mut |_ann, _hir_id, _sp, ident| {
                 pat_bindings.push(ident);
             });
             if let [binding] = &pat_bindings[..] {
diff --git a/tests/ui/manual_let_else.rs b/tests/ui/manual_let_else.rs
index f2827e22500..782f9f394fe 100644
--- a/tests/ui/manual_let_else.rs
+++ b/tests/ui/manual_let_else.rs
@@ -2,8 +2,8 @@
 #![allow(
     clippy::collapsible_else_if,
     clippy::unused_unit,
-    clippy::never_loop,
-    clippy::let_unit_value
+    clippy::let_unit_value,
+    clippy::never_loop
 )]
 #![warn(clippy::manual_let_else)]
 
@@ -87,6 +87,14 @@ fn fire() {
     } else {
         return;
     };
+
+    // entirely inside macro lints
+    macro_rules! create_binding_if_some {
+        ($n:ident, $e:expr) => {
+            let $n = if let Some(v) = $e { v } else { return };
+        };
+    }
+    create_binding_if_some!(w, g());
 }
 
 fn not_fire() {
@@ -164,4 +172,20 @@ fn not_fire() {
         };
         Some(v)
     }
+
+    // Macro boundary inside let
+    macro_rules! some_or_return {
+        ($e:expr) => {
+            if let Some(v) = $e { v } else { return }
+        };
+    }
+    let v = some_or_return!(g());
+
+    // Also macro boundary inside let, but inside a macro
+    macro_rules! create_binding_if_some_nf {
+        ($n:ident, $e:expr) => {
+            let $n = some_or_return!($e);
+        };
+    }
+    create_binding_if_some_nf!(v, g());
 }
diff --git a/tests/ui/manual_let_else.stderr b/tests/ui/manual_let_else.stderr
index 461de79f6b9..9a2c548c5aa 100644
--- a/tests/ui/manual_let_else.stderr
+++ b/tests/ui/manual_let_else.stderr
@@ -100,5 +100,16 @@ LL | |         return;
 LL | |     };
    | |______^
 
-error: aborting due to 11 previous errors
+error: this could be rewritten as `let else`
+  --> $DIR/manual_let_else.rs:94:13
+   |
+LL |             let $n = if let Some(v) = $e { v } 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: aborting due to 12 previous errors
 
diff --git a/tests/ui/manual_let_else_match.rs b/tests/ui/manual_let_else_match.rs
new file mode 100644
index 00000000000..56da1db49f2
--- /dev/null
+++ b/tests/ui/manual_let_else_match.rs
@@ -0,0 +1,93 @@
+#![allow(unused_braces, unused_variables, dead_code)]
+#![allow(clippy::collapsible_else_if, clippy::let_unit_value)]
+#![warn(clippy::manual_let_else)]
+// Ensure that we don't conflict with match -> if let lints
+#![warn(clippy::single_match_else, clippy::single_match)]
+
+enum Variant {
+    Foo,
+    Bar(u32),
+    Baz(u32),
+}
+
+fn f() -> Result<u32, u32> {
+    Ok(0)
+}
+
+fn g() -> Option<()> {
+    None
+}
+
+fn h() -> Variant {
+    Variant::Foo
+}
+
+fn main() {}
+
+fn fire() {
+    let v = match g() {
+        Some(v_some) => v_some,
+        None => return,
+    };
+
+    let v = match g() {
+        Some(v_some) => v_some,
+        _ => return,
+    };
+
+    loop {
+        // More complex pattern for the identity arm
+        let v = match h() {
+            Variant::Foo => continue,
+            Variant::Bar(v) | Variant::Baz(v) => v,
+        };
+    }
+
+    // There is a _ in the diverging arm
+    // TODO also support unused bindings aka _v
+    let v = match f() {
+        Ok(v) => v,
+        Err(_) => return,
+    };
+}
+
+fn not_fire() {
+    // Multiple diverging arms
+    let v = match h() {
+        Variant::Foo => panic!(),
+        Variant::Bar(_v) => return,
+        Variant::Baz(v) => v,
+    };
+
+    // Multiple identity arms
+    let v = match h() {
+        Variant::Foo => panic!(),
+        Variant::Bar(v) => v,
+        Variant::Baz(v) => v,
+    };
+
+    // No diverging arm at all, only identity arms.
+    // This is no case for let else, but destructuring assignment.
+    let v = match f() {
+        Ok(v) => v,
+        Err(e) => e,
+    };
+
+    // The identity arm has a guard
+    let v = match h() {
+        Variant::Bar(v) if g().is_none() => v,
+        _ => return,
+    };
+
+    // The diverging arm has a guard
+    let v = match f() {
+        Err(v) if v > 0 => panic!(),
+        Ok(v) | Err(v) => v,
+    };
+
+    // The diverging arm creates a binding
+    let v = match f() {
+        Ok(v) => v,
+        Err(e) => panic!("error: {e}"),
+    };
+}
diff --git a/tests/ui/manual_let_else_match.stderr b/tests/ui/manual_let_else_match.stderr
new file mode 100644
index 00000000000..2dae1d15ad4
--- /dev/null
+++ b/tests/ui/manual_let_else_match.stderr
@@ -0,0 +1,40 @@
+error: this could be rewritten as `let else`
+  --> $DIR/manual_let_else_match.rs:28:5
+   |
+LL | /     let v = match g() {
+LL | |         Some(v_some) => v_some,
+LL | |         None => return,
+LL | |     };
+   | |______^
+   |
+   = note: `-D clippy::manual-let-else` implied by `-D warnings`
+
+error: this could be rewritten as `let else`
+  --> $DIR/manual_let_else_match.rs:33:5
+   |
+LL | /     let v = match g() {
+LL | |         Some(v_some) => v_some,
+LL | |         _ => return,
+LL | |     };
+   | |______^
+
+error: this could be rewritten as `let else`
+  --> $DIR/manual_let_else_match.rs:40:9
+   |
+LL | /         let v = match h() {
+LL | |             Variant::Foo => continue,
+LL | |             Variant::Bar(v) | Variant::Baz(v) => v,
+LL | |         };
+   | |__________^
+
+error: this could be rewritten as `let else`
+  --> $DIR/manual_let_else_match.rs:48:5
+   |
+LL | /     let v = match f() {
+LL | |         Ok(v) => v,
+LL | |         Err(_) => return,
+LL | |     };
+   | |______^
+
+error: aborting due to 4 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From c5a7696231ef60e77fdeb5068c729d63c0393547 Mon Sep 17 00:00:00 2001
From: est31 <MTest31@outlook.com>
Date: Fri, 18 Feb 2022 05:43:48 +0100
Subject: Support tuples

---
 clippy_lints/src/manual_let_else.rs | 38 +++++++++++++++++++++++++------------
 tests/ui/manual_let_else.rs         |  7 +++++++
 tests/ui/manual_let_else.stderr     | 14 ++++++++++++--
 3 files changed, 45 insertions(+), 14 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_let_else.rs b/clippy_lints/src/manual_let_else.rs
index 98510ee9acd..5e46abee42d 100644
--- a/clippy_lints/src/manual_let_else.rs
+++ b/clippy_lints/src/manual_let_else.rs
@@ -3,6 +3,7 @@ use clippy_utils::higher::IfLetOrMatch;
 use clippy_utils::visitors::{for_each_expr, Descend};
 use clippy_utils::{meets_msrv, msrvs, peel_blocks};
 use if_chain::if_chain;
+use rustc_data_structures::fx::FxHashSet;
 use rustc_hir::{Expr, ExprKind, MatchSource, Pat, QPath, Stmt, StmtKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
@@ -201,20 +202,33 @@ fn pat_has_no_bindings(pat: &'_ Pat<'_>) -> bool {
 
 /// Checks if the passed block is a simple identity referring to bindings created by the pattern
 fn expr_is_simple_identity(pat: &'_ Pat<'_>, expr: &'_ Expr<'_>) -> bool {
-    // TODO support patterns with multiple bindings and tuples, like:
+    // We support patterns with multiple bindings and tuples, like:
     //   let ... = if let (Some(foo), bar) = g() { (foo, bar) } else { ... }
-    if_chain! {
-        if let ExprKind::Path(QPath::Resolved(_ty, path)) = &peel_blocks(expr).kind;
-        if let [path_seg] = path.segments;
-        then {
-            let mut pat_bindings = Vec::new();
-            pat.each_binding_or_first(&mut |_ann, _hir_id, _sp, ident| {
-                pat_bindings.push(ident);
-            });
-            if let [binding] = &pat_bindings[..] {
-                return path_seg.ident == *binding;
+    let peeled = peel_blocks(expr);
+    let paths = match peeled.kind {
+        ExprKind::Tup(exprs) | ExprKind::Array(exprs) => exprs,
+        ExprKind::Path(_) => std::slice::from_ref(peeled),
+        _ => return false,
+    };
+    let mut pat_bindings = FxHashSet::default();
+    pat.each_binding_or_first(&mut |_ann, _hir_id, _sp, ident| {
+        pat_bindings.insert(ident);
+    });
+    if pat_bindings.len() < paths.len() {
+        return false;
+    }
+    for path in paths {
+        if_chain! {
+            if let ExprKind::Path(QPath::Resolved(_ty, path)) = path.kind;
+            if let [path_seg] = path.segments;
+            then {
+                if !pat_bindings.remove(&path_seg.ident) {
+                    return false;
+                }
+            } else {
+                return false;
             }
         }
     }
-    false
+    true
 }
diff --git a/tests/ui/manual_let_else.rs b/tests/ui/manual_let_else.rs
index 782f9f394fe..d69e580ff8f 100644
--- a/tests/ui/manual_let_else.rs
+++ b/tests/ui/manual_let_else.rs
@@ -88,6 +88,13 @@ fn fire() {
         return;
     };
 
+    // Tuples supported for the identity block and pattern
+    let v = if let (Some(v_some), w_some) = (g(), 0) {
+        (w_some, v_some)
+    } else {
+        return;
+    };
+
     // entirely inside macro lints
     macro_rules! create_binding_if_some {
         ($n:ident, $e:expr) => {
diff --git a/tests/ui/manual_let_else.stderr b/tests/ui/manual_let_else.stderr
index 9a2c548c5aa..97e6420d705 100644
--- a/tests/ui/manual_let_else.stderr
+++ b/tests/ui/manual_let_else.stderr
@@ -101,7 +101,17 @@ LL | |     };
    | |______^
 
 error: this could be rewritten as `let else`
-  --> $DIR/manual_let_else.rs:94:13
+  --> $DIR/manual_let_else.rs:92:5
+   |
+LL | /     let v = if let (Some(v_some), w_some) = (g(), 0) {
+LL | |         (w_some, v_some)
+LL | |     } else {
+LL | |         return;
+LL | |     };
+   | |______^
+
+error: this could be rewritten as `let else`
+  --> $DIR/manual_let_else.rs:101:13
    |
 LL |             let $n = if let Some(v) = $e { v } else { return };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -111,5 +121,5 @@ LL |     create_binding_if_some!(w, g());
    |
    = note: this error originates in the macro `create_binding_if_some` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to 12 previous errors
+error: aborting due to 13 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 5da7a176b778656d2e6f736f5a23ce6fdb73379d Mon Sep 17 00:00:00 2001
From: est31 <MTest31@outlook.com>
Date: Sat, 19 Feb 2022 07:15:20 +0100
Subject: Don't suggest let else in match if the else arm explicitly mentions
 non obvious paths

---
 clippy_lints/src/manual_let_else.rs   | 43 ++++++++++++++++++++----
 tests/ui/manual_let_else_match.rs     | 62 +++++++++++++++++++++++++----------
 tests/ui/manual_let_else_match.stderr | 30 +++++++++++++----
 3 files changed, 106 insertions(+), 29 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_let_else.rs b/clippy_lints/src/manual_let_else.rs
index 5e46abee42d..87bac8aabdc 100644
--- a/clippy_lints/src/manual_let_else.rs
+++ b/clippy_lints/src/manual_let_else.rs
@@ -1,14 +1,16 @@
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::higher::IfLetOrMatch;
+use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::visitors::{for_each_expr, Descend};
 use clippy_utils::{meets_msrv, msrvs, peel_blocks};
 use if_chain::if_chain;
 use rustc_data_structures::fx::FxHashSet;
-use rustc_hir::{Expr, ExprKind, MatchSource, Pat, QPath, Stmt, StmtKind};
+use rustc_hir::{Expr, ExprKind, MatchSource, Pat, PatKind, QPath, Stmt, StmtKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::symbol::sym;
 use rustc_span::Span;
 use std::ops::ControlFlow;
 
@@ -108,7 +110,7 @@ impl<'tcx> LateLintPass<'tcx> for ManualLetElse {
                     }
                     if expr_is_simple_identity(arm.pat, arm.body) {
                         found_identity_arm = true;
-                    } else if expr_diverges(cx, arm.body) && pat_has_no_bindings(arm.pat) {
+                    } else if expr_diverges(cx, arm.body) && pat_allowed_for_else(cx, arm.pat) {
                         found_diverging_arm = true;
                     }
                 }
@@ -194,10 +196,39 @@ fn from_different_macros(span_a: Span, span_b: Span) -> bool {
     data_for_comparison(span_a) != data_for_comparison(span_b)
 }
 
-fn pat_has_no_bindings(pat: &'_ Pat<'_>) -> bool {
-    let mut has_no_bindings = true;
-    pat.each_binding_or_first(&mut |_, _, _, _| has_no_bindings = false);
-    has_no_bindings
+fn pat_allowed_for_else(cx: &LateContext<'_>, pat: &'_ Pat<'_>) -> bool {
+    // Check whether the pattern contains any bindings, as the
+    // binding might potentially be used in the body.
+    // TODO: only look for *used* bindings.
+    let mut has_bindings = false;
+    pat.each_binding_or_first(&mut |_, _, _, _| has_bindings = true);
+    if has_bindings {
+        return false;
+    }
+
+    // Check whether any possibly "unknown" patterns are included,
+    // because users might not know which values some enum has.
+    // Well-known enums are excepted, as we assume people know them.
+    // We do a deep check, to be able to disallow Err(En::Foo(_))
+    // for usage of the En::Foo variant, as we disallow En::Foo(_),
+    // but we allow Err(_).
+    let typeck_results = cx.typeck_results();
+    let mut has_disallowed = false;
+    pat.walk_always(|pat| {
+        // Only do the check if the type is "spelled out" in the pattern
+        if !matches!(
+            pat.kind,
+            PatKind::Struct(..) | PatKind::TupleStruct(..) | PatKind::Path(..)
+        ) {
+            return;
+        };
+        let ty = typeck_results.pat_ty(pat);
+        // Option and Result are allowed, everything else isn't.
+        if !(is_type_diagnostic_item(cx, ty, sym::Option) || is_type_diagnostic_item(cx, ty, sym::Result)) {
+            has_disallowed = true;
+        }
+    });
+    !has_disallowed
 }
 
 /// Checks if the passed block is a simple identity referring to bindings created by the pattern
diff --git a/tests/ui/manual_let_else_match.rs b/tests/ui/manual_let_else_match.rs
index 56da1db49f2..93c86ca24fe 100644
--- a/tests/ui/manual_let_else_match.rs
+++ b/tests/ui/manual_let_else_match.rs
@@ -4,12 +4,6 @@
 // Ensure that we don't conflict with match -> if let lints
 #![warn(clippy::single_match_else, clippy::single_match)]
 
-enum Variant {
-    Foo,
-    Bar(u32),
-    Baz(u32),
-}
-
 fn f() -> Result<u32, u32> {
     Ok(0)
 }
@@ -18,7 +12,17 @@ fn g() -> Option<()> {
     None
 }
 
-fn h() -> Variant {
+fn h() -> (Option<()>, Option<()>) {
+    (None, None)
+}
+
+enum Variant {
+    Foo,
+    Bar(u32),
+    Baz(u32),
+}
+
+fn build_enum() -> Variant {
     Variant::Foo
 }
 
@@ -36,9 +40,14 @@ fn fire() {
     };
 
     loop {
-        // More complex pattern for the identity arm
+        // More complex pattern for the identity arm and diverging arm
         let v = match h() {
-            Variant::Foo => continue,
+            (Some(_), Some(_)) | (None, None) => continue,
+            (Some(v), None) | (None, Some(v)) => v,
+        };
+        // Custom enums are supported as long as the "else" arm is a simple _
+        let v = match build_enum() {
+            _ => continue,
             Variant::Bar(v) | Variant::Baz(v) => v,
         };
     }
@@ -49,21 +58,27 @@ fn fire() {
         Ok(v) => v,
         Err(_) => return,
     };
+
+    // Err(()) is an allowed pattern
+    let v = match f().map_err(|_| ()) {
+        Ok(v) => v,
+        Err(()) => return,
+    };
 }
 
 fn not_fire() {
     // Multiple diverging arms
     let v = match h() {
-        Variant::Foo => panic!(),
-        Variant::Bar(_v) => return,
-        Variant::Baz(v) => v,
+        _ => panic!(),
+        (None, Some(_v)) => return,
+        (Some(v), None) => v,
     };
 
     // Multiple identity arms
     let v = match h() {
-        Variant::Foo => panic!(),
-        Variant::Bar(v) => v,
-        Variant::Baz(v) => v,
+        _ => panic!(),
+        (None, Some(v)) => v,
+        (Some(v), None) => v,
     };
 
     // No diverging arm at all, only identity arms.
@@ -74,8 +89,8 @@ fn not_fire() {
     };
 
     // The identity arm has a guard
-    let v = match h() {
-        Variant::Bar(v) if g().is_none() => v,
+    let v = match g() {
+        Some(v) if g().is_none() => v,
         _ => return,
     };
 
@@ -90,4 +105,17 @@ fn not_fire() {
         Ok(v) => v,
         Err(e) => panic!("error: {e}"),
     };
+
+    // Custom enum where the diverging arm
+    // explicitly mentions the variant
+    let v = match build_enum() {
+        Variant::Foo => return,
+        Variant::Bar(v) | Variant::Baz(v) => v,
+    };
+
+    // The custom enum is surrounded by an Err()
+    let v = match Err(build_enum()) {
+        Ok(v) | Err(Variant::Bar(v) | Variant::Baz(v)) => v,
+        Err(Variant::Foo) => return,
+    };
 }
diff --git a/tests/ui/manual_let_else_match.stderr b/tests/ui/manual_let_else_match.stderr
index 2dae1d15ad4..a79afc6401d 100644
--- a/tests/ui/manual_let_else_match.stderr
+++ b/tests/ui/manual_let_else_match.stderr
@@ -1,5 +1,5 @@
 error: this could be rewritten as `let else`
-  --> $DIR/manual_let_else_match.rs:28:5
+  --> $DIR/manual_let_else_match.rs:32:5
    |
 LL | /     let v = match g() {
 LL | |         Some(v_some) => v_some,
@@ -10,7 +10,7 @@ LL | |     };
    = note: `-D clippy::manual-let-else` implied by `-D warnings`
 
 error: this could be rewritten as `let else`
-  --> $DIR/manual_let_else_match.rs:33:5
+  --> $DIR/manual_let_else_match.rs:37:5
    |
 LL | /     let v = match g() {
 LL | |         Some(v_some) => v_some,
@@ -19,16 +19,25 @@ LL | |     };
    | |______^
 
 error: this could be rewritten as `let else`
-  --> $DIR/manual_let_else_match.rs:40:9
+  --> $DIR/manual_let_else_match.rs:44:9
    |
 LL | /         let v = match h() {
-LL | |             Variant::Foo => continue,
+LL | |             (Some(_), Some(_)) | (None, None) => continue,
+LL | |             (Some(v), None) | (None, Some(v)) => v,
+LL | |         };
+   | |__________^
+
+error: this could be rewritten as `let else`
+  --> $DIR/manual_let_else_match.rs:49:9
+   |
+LL | /         let v = match build_enum() {
+LL | |             _ => continue,
 LL | |             Variant::Bar(v) | Variant::Baz(v) => v,
 LL | |         };
    | |__________^
 
 error: this could be rewritten as `let else`
-  --> $DIR/manual_let_else_match.rs:48:5
+  --> $DIR/manual_let_else_match.rs:57:5
    |
 LL | /     let v = match f() {
 LL | |         Ok(v) => v,
@@ -36,5 +45,14 @@ LL | |         Err(_) => return,
 LL | |     };
    | |______^
 
-error: aborting due to 4 previous errors
+error: this could be rewritten as `let else`
+  --> $DIR/manual_let_else_match.rs:63:5
+   |
+LL | /     let v = match f().map_err(|_| ()) {
+LL | |         Ok(v) => v,
+LL | |         Err(()) => return,
+LL | |     };
+   | |______^
+
+error: aborting due to 6 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 173a8e04807dbdcc714d7dec0da331ee86538131 Mon Sep 17 00:00:00 2001
From: est31 <MTest31@outlook.com>
Date: Thu, 6 Oct 2022 23:07:58 +0200
Subject: Replace from_different_macros with equivalent and simpler check

---
 clippy_lints/src/manual_let_else.rs | 20 +-------------------
 1 file changed, 1 insertion(+), 19 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_let_else.rs b/clippy_lints/src/manual_let_else.rs
index 87bac8aabdc..e366d6db774 100644
--- a/clippy_lints/src/manual_let_else.rs
+++ b/clippy_lints/src/manual_let_else.rs
@@ -11,7 +11,6 @@ use rustc_middle::lint::in_external_macro;
 use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::symbol::sym;
-use rustc_span::Span;
 use std::ops::ControlFlow;
 
 declare_clippy_lint! {
@@ -66,7 +65,7 @@ impl<'tcx> LateLintPass<'tcx> for ManualLetElse {
             if !in_external_macro(cx.sess(), stmt.span);
             if let StmtKind::Local(local) = stmt.kind;
             if let Some(init) = local.init;
-            if !from_different_macros(init.span, stmt.span);
+            if init.span.ctxt() == stmt.span.ctxt();
             if let Some(if_let_or_match) = IfLetOrMatch::parse(cx, init);
             then {
                 if_let_or_match
@@ -179,23 +178,6 @@ fn expr_diverges(cx: &LateContext<'_>, expr: &'_ Expr<'_>) -> bool {
     .is_some()
 }
 
-/// Returns true if the two spans come from different macro sites,
-/// or one comes from an invocation and the other is not from a macro at all.
-fn from_different_macros(span_a: Span, span_b: Span) -> bool {
-    // This pre-check is a speed up so that we don't build outer_expn_data unless needed.
-    match (span_a.from_expansion(), span_b.from_expansion()) {
-        (false, false) => return false,
-        (true, false) | (false, true) => return true,
-        // We need to determine if both are from the same macro
-        (true, true) => (),
-    }
-    let data_for_comparison = |sp: Span| {
-        let expn_data = sp.ctxt().outer_expn_data();
-        (expn_data.kind, expn_data.call_site)
-    };
-    data_for_comparison(span_a) != data_for_comparison(span_b)
-}
-
 fn pat_allowed_for_else(cx: &LateContext<'_>, pat: &'_ Pat<'_>) -> bool {
     // Check whether the pattern contains any bindings, as the
     // binding might potentially be used in the body.
-- 
cgit 1.4.1-3-g733a5


From 9bd70dbb8855580ca75d37211fce74adc8fda734 Mon Sep 17 00:00:00 2001
From: est31 <MTest31@outlook.com>
Date: Sat, 8 Oct 2022 02:50:30 +0200
Subject: Make the match checking configurable

---
 clippy_lints/src/lib.rs                            |  3 ++-
 clippy_lints/src/manual_let_else.rs                | 29 +++++++++++++++++++---
 clippy_lints/src/utils/conf.rs                     |  6 +++++
 .../toml_unknown_key/conf_unknown_key.stderr       |  1 +
 4 files changed, 34 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index b261beab793..5716ef71641 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -604,7 +604,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         ))
     });
     store.register_late_pass(move |_| Box::new(matches::Matches::new(msrv)));
-    store.register_late_pass(move |_| Box::new(manual_let_else::ManualLetElse::new(msrv)));
+    let matches_for_let_else = conf.matches_for_let_else;
+    store.register_late_pass(move |_| Box::new(manual_let_else::ManualLetElse::new(msrv, matches_for_let_else)));
     store.register_early_pass(move || Box::new(manual_non_exhaustive::ManualNonExhaustiveStruct::new(msrv)));
     store.register_late_pass(move |_| Box::new(manual_non_exhaustive::ManualNonExhaustiveEnum::new(msrv)));
     store.register_late_pass(move |_| Box::new(manual_strip::ManualStrip::new(msrv)));
diff --git a/clippy_lints/src/manual_let_else.rs b/clippy_lints/src/manual_let_else.rs
index e366d6db774..13a734818a7 100644
--- a/clippy_lints/src/manual_let_else.rs
+++ b/clippy_lints/src/manual_let_else.rs
@@ -11,6 +11,7 @@ use rustc_middle::lint::in_external_macro;
 use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::symbol::sym;
+use serde::Deserialize;
 use std::ops::ControlFlow;
 
 declare_clippy_lint! {
@@ -47,12 +48,16 @@ declare_clippy_lint! {
 
 pub struct ManualLetElse {
     msrv: Option<RustcVersion>,
+    matches_behaviour: MatchLintBehaviour,
 }
 
 impl ManualLetElse {
     #[must_use]
-    pub fn new(msrv: Option<RustcVersion>) -> Self {
-        Self { msrv }
+    pub fn new(msrv: Option<RustcVersion>, matches_behaviour: MatchLintBehaviour) -> Self {
+        Self {
+            msrv,
+            matches_behaviour,
+        }
     }
 }
 
@@ -89,6 +94,9 @@ impl<'tcx> LateLintPass<'tcx> for ManualLetElse {
                 }
             },
             IfLetOrMatch::Match(_match_expr, arms, source) => {
+                if self.matches_behaviour == MatchLintBehaviour::Never {
+                    return;
+                }
                 if source != MatchSource::Normal {
                     return;
                 }
@@ -97,6 +105,7 @@ impl<'tcx> LateLintPass<'tcx> for ManualLetElse {
                 if arms.len() != 2 {
                     return;
                 }
+                let check_types = self.matches_behaviour == MatchLintBehaviour::WellKnownTypes;
                 // We iterate over both arms, trying to find one that is an identity,
                 // one that diverges. Our check needs to work regardless of the order
                 // of both arms.
@@ -109,7 +118,7 @@ impl<'tcx> LateLintPass<'tcx> for ManualLetElse {
                     }
                     if expr_is_simple_identity(arm.pat, arm.body) {
                         found_identity_arm = true;
-                    } else if expr_diverges(cx, arm.body) && pat_allowed_for_else(cx, arm.pat) {
+                    } else if expr_diverges(cx, arm.body) && pat_allowed_for_else(cx, arm.pat, check_types) {
                         found_diverging_arm = true;
                     }
                 }
@@ -178,7 +187,7 @@ fn expr_diverges(cx: &LateContext<'_>, expr: &'_ Expr<'_>) -> bool {
     .is_some()
 }
 
-fn pat_allowed_for_else(cx: &LateContext<'_>, pat: &'_ Pat<'_>) -> bool {
+fn pat_allowed_for_else(cx: &LateContext<'_>, pat: &'_ Pat<'_>, check_types: bool) -> bool {
     // Check whether the pattern contains any bindings, as the
     // binding might potentially be used in the body.
     // TODO: only look for *used* bindings.
@@ -188,6 +197,11 @@ fn pat_allowed_for_else(cx: &LateContext<'_>, pat: &'_ Pat<'_>) -> bool {
         return false;
     }
 
+    // If we shouldn't check the types, exit early.
+    if !check_types {
+        return true;
+    }
+
     // Check whether any possibly "unknown" patterns are included,
     // because users might not know which values some enum has.
     // Well-known enums are excepted, as we assume people know them.
@@ -245,3 +259,10 @@ fn expr_is_simple_identity(pat: &'_ Pat<'_>, expr: &'_ Expr<'_>) -> bool {
     }
     true
 }
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Deserialize)]
+pub enum MatchLintBehaviour {
+    AllTypes,
+    WellKnownTypes,
+    Never,
+}
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 1aa86efd38f..ef6de7d333d 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -335,6 +335,12 @@ define_Conf! {
     ///
     /// Enables verbose mode. Triggers if there is more than one uppercase char next to each other
     (upper_case_acronyms_aggressive: bool = false),
+    /// Lint: MANUAL_LET_ELSE.
+    ///
+    /// Whether the matches should be considered by the lint, and whether there should
+    /// be filtering for common types.
+    (matches_for_let_else: crate::manual_let_else::MatchLintBehaviour =
+        crate::manual_let_else::MatchLintBehaviour::WellKnownTypes),
     /// Lint: _CARGO_COMMON_METADATA.
     ///
     /// For internal testing only, ignores the current `publish` settings in the Cargo manifest.
diff --git a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
index 82ee8054132..7db2e11225b 100644
--- a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
+++ b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
@@ -22,6 +22,7 @@ error: error reading Clippy's configuration file `$DIR/clippy.toml`: unknown fie
            enum-variant-size-threshold
            large-error-threshold
            literal-representation-threshold
+           matches-for-let-else
            max-fn-params-bools
            max-include-file-size
            max-struct-bools
-- 
cgit 1.4.1-3-g733a5


From a1db9311dc0ddb0dea68d2661442df2c6f4b382c Mon Sep 17 00:00:00 2001
From: est31 <MTest31@outlook.com>
Date: Mon, 10 Oct 2022 07:17:04 +0200
Subject: Make an attempt of creating suggestions

They aren't perfect but better than nothing
---
 clippy_lints/src/manual_let_else.rs   |  78 ++++++++++++++++---------
 tests/ui/manual_let_else.rs           |  11 ++--
 tests/ui/manual_let_else.stderr       | 106 ++++++++++++++++++++++++++++------
 tests/ui/manual_let_else_match.stderr |  24 ++++----
 4 files changed, 156 insertions(+), 63 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_let_else.rs b/clippy_lints/src/manual_let_else.rs
index 13a734818a7..8d743c86d6d 100644
--- a/clippy_lints/src/manual_let_else.rs
+++ b/clippy_lints/src/manual_let_else.rs
@@ -1,16 +1,19 @@
-use clippy_utils::diagnostics::span_lint;
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::higher::IfLetOrMatch;
+use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::visitors::{for_each_expr, Descend};
 use clippy_utils::{meets_msrv, msrvs, peel_blocks};
 use if_chain::if_chain;
 use rustc_data_structures::fx::FxHashSet;
+use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, MatchSource, Pat, PatKind, QPath, Stmt, StmtKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::symbol::sym;
+use rustc_span::Span;
 use serde::Deserialize;
 use std::ops::ControlFlow;
 
@@ -80,20 +83,15 @@ impl<'tcx> LateLintPass<'tcx> for ManualLetElse {
         };
 
         match if_let_or_match {
-            IfLetOrMatch::IfLet(_let_expr, let_pat, if_then, if_else) => if_chain! {
+            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 {
-                    span_lint(
-                        cx,
-                        MANUAL_LET_ELSE,
-                        stmt.span,
-                        "this could be rewritten as `let else`",
-                    );
+                    emit_manual_let_else(cx, stmt.span, if_let_expr, let_pat, if_else);
                 }
             },
-            IfLetOrMatch::Match(_match_expr, arms, source) => {
+            IfLetOrMatch::Match(match_expr, arms, source) => {
                 if self.matches_behaviour == MatchLintBehaviour::Never {
                     return;
                 }
@@ -105,27 +103,22 @@ impl<'tcx> LateLintPass<'tcx> for ManualLetElse {
                 if arms.len() != 2 {
                     return;
                 }
-                let check_types = self.matches_behaviour == MatchLintBehaviour::WellKnownTypes;
-                // We iterate over both arms, trying to find one that is an identity,
-                // one that diverges. Our check needs to work regardless of the order
-                // of both arms.
-                let mut found_identity_arm = false;
-                let mut found_diverging_arm = false;
-                for arm in arms {
-                    // Guards don't give us an easy mapping to let else
-                    if arm.guard.is_some() {
-                        return;
-                    }
-                    if expr_is_simple_identity(arm.pat, arm.body) {
-                        found_identity_arm = true;
-                    } else if expr_diverges(cx, arm.body) && pat_allowed_for_else(cx, arm.pat, check_types) {
-                        found_diverging_arm = true;
-                    }
+                // Guards don't give us an easy mapping either
+                if arms.iter().any(|arm| arm.guard.is_some()) {
+                    return;
                 }
-                if !(found_identity_arm && found_diverging_arm) {
+                let check_types = self.matches_behaviour == MatchLintBehaviour::WellKnownTypes;
+                let diverging_arm_opt = arms
+                    .iter()
+                    .enumerate()
+                    .find(|(_, arm)| expr_diverges(cx, arm.body) && pat_allowed_for_else(cx, arm.pat, check_types));
+                let Some((idx, diverging_arm)) = diverging_arm_opt else { return; };
+                let pat_arm = &arms[1 - idx];
+                if !expr_is_simple_identity(pat_arm.pat, pat_arm.body) {
                     return;
                 }
-                span_lint(cx, MANUAL_LET_ELSE, stmt.span, "this could be rewritten as `let else`");
+
+                emit_manual_let_else(cx, stmt.span, match_expr, pat_arm.pat, diverging_arm.body);
             },
         }
     }
@@ -133,6 +126,37 @@ impl<'tcx> LateLintPass<'tcx> for ManualLetElse {
     extract_msrv_attr!(LateContext);
 }
 
+fn emit_manual_let_else(cx: &LateContext<'_>, span: Span, expr: &Expr<'_>, pat: &Pat<'_>, else_body: &Expr<'_>) {
+    span_lint_and_then(
+        cx,
+        MANUAL_LET_ELSE,
+        span,
+        "this could be rewritten as `let...else`",
+        |diag| {
+            // This is far from perfect, for example there needs to be:
+            // * mut additions for the bindings
+            // * renamings of the bindings
+            // * unused binding collision detection with existing ones
+            // * putting patterns with at the top level | inside ()
+            // for this to be machine applicable.
+            let app = Applicability::HasPlaceholders;
+
+            if let Some(sn_pat) = snippet_opt(cx, pat.span) &&
+                let Some(sn_expr) = snippet_opt(cx, expr.span) &&
+                let Some(sn_else) = snippet_opt(cx, else_body.span)
+            {
+                let else_bl = if matches!(else_body.kind, ExprKind::Block(..)) {
+                    sn_else
+                } else {
+                    format!("{{ {sn_else} }}")
+                };
+                let sugg = format!("let {sn_pat} = {sn_expr} else {else_bl};");
+                diag.span_suggestion(span, "consider writing", sugg, app);
+            }
+        },
+    );
+}
+
 fn expr_diverges(cx: &LateContext<'_>, expr: &'_ Expr<'_>) -> bool {
     fn is_never(cx: &LateContext<'_>, expr: &'_ Expr<'_>) -> bool {
         if let Some(ty) = cx.typeck_results().expr_ty_opt(expr) {
diff --git a/tests/ui/manual_let_else.rs b/tests/ui/manual_let_else.rs
index d69e580ff8f..bd0ac69e46e 100644
--- a/tests/ui/manual_let_else.rs
+++ b/tests/ui/manual_let_else.rs
@@ -158,14 +158,13 @@ fn not_fire() {
         }
     };
 
-
-    let v = if let Some(v_some) = g() {
+    enum Uninhabited {}
+    fn un() -> Uninhabited {
+        panic!()
+    }
+    let v = if let Some(v_some) = None {
         v_some
     } else {
-        enum Uninhabited {}
-        fn un() -> Uninhabited {
-            panic!()
-        }
         // Don't lint if the type is uninhabited but not !
         un()
     };
diff --git a/tests/ui/manual_let_else.stderr b/tests/ui/manual_let_else.stderr
index 97e6420d705..e073276d20c 100644
--- a/tests/ui/manual_let_else.stderr
+++ b/tests/ui/manual_let_else.stderr
@@ -1,12 +1,12 @@
-error: this could be rewritten as `let else`
+error: this could be rewritten as `let...else`
   --> $DIR/manual_let_else.rs:17:5
    |
 LL |     let v = if let Some(v_some) = g() { v_some } else { return };
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let Some(v_some) = g() else { return };`
    |
    = note: `-D clippy::manual-let-else` implied by `-D warnings`
 
-error: this could be rewritten as `let else`
+error: this could be rewritten as `let...else`
   --> $DIR/manual_let_else.rs:18:5
    |
 LL | /     let v = if let Some(v_some) = g() {
@@ -15,8 +15,15 @@ LL | |     } else {
 LL | |         return;
 LL | |     };
    | |______^
+   |
+help: consider writing
+   |
+LL ~     let Some(v_some) = g() else {
+LL +         return;
+LL +     };
+   |
 
-error: this could be rewritten as `let else`
+error: this could be rewritten as `let...else`
   --> $DIR/manual_let_else.rs:24:5
    |
 LL | /     let v = if let Some(v) = g() {
@@ -27,26 +34,35 @@ LL | |             { v }
 LL | |         return;
 LL | |     };
    | |______^
+   |
+help: consider writing
+   |
+LL ~     let Some(v) = g() else {
+LL +         // Some computation should still make it fire
+LL +         g();
+LL +         return;
+LL +     };
+   |
 
-error: this could be rewritten as `let else`
+error: this could be rewritten as `let...else`
   --> $DIR/manual_let_else.rs:37:9
    |
 LL |         let v = if let Some(v_some) = g() { v_some } else { continue };
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let Some(v_some) = g() else { continue };`
 
-error: this could be rewritten as `let else`
+error: this could be rewritten as `let...else`
   --> $DIR/manual_let_else.rs:38:9
    |
 LL |         let v = if let Some(v_some) = g() { v_some } else { break };
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let Some(v_some) = g() else { break };`
 
-error: this could be rewritten as `let else`
+error: this could be rewritten as `let...else`
   --> $DIR/manual_let_else.rs:42:5
    |
 LL |     let v = if let Some(v_some) = g() { v_some } else { panic!() };
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let Some(v_some) = g() else { panic!() };`
 
-error: this could be rewritten as `let else`
+error: this could be rewritten as `let...else`
   --> $DIR/manual_let_else.rs:45:5
    |
 LL | /     let v = if let Some(v_some) = g() {
@@ -55,8 +71,15 @@ LL | |     } else {
 LL | |         std::process::abort()
 LL | |     };
    | |______^
+   |
+help: consider writing
+   |
+LL ~     let Some(v_some) = g() else {
+LL +         std::process::abort()
+LL +     };
+   |
 
-error: this could be rewritten as `let else`
+error: this could be rewritten as `let...else`
   --> $DIR/manual_let_else.rs:52:5
    |
 LL | /     let v = if let Some(v_some) = g() {
@@ -65,8 +88,15 @@ LL | |     } else {
 LL | |         if true { return } else { panic!() }
 LL | |     };
    | |______^
+   |
+help: consider writing
+   |
+LL ~     let Some(v_some) = g() else {
+LL +         if true { return } else { panic!() }
+LL +     };
+   |
 
-error: this could be rewritten as `let else`
+error: this could be rewritten as `let...else`
   --> $DIR/manual_let_else.rs:59:5
    |
 LL | /     let v = if let Some(v_some) = g() {
@@ -77,8 +107,17 @@ LL | |     } else {
 LL | |         panic!("diverge");
 LL | |     };
    | |______^
+   |
+help: consider writing
+   |
+LL ~     let Some(v_some) = g() else { if true {
+LL +         return;
+LL +     } else {
+LL +         panic!("diverge");
+LL +     } };
+   |
 
-error: this could be rewritten as `let else`
+error: this could be rewritten as `let...else`
   --> $DIR/manual_let_else.rs:68:5
    |
 LL | /     let v = if let Some(v_some) = g() {
@@ -89,8 +128,25 @@ LL | |         match (g(), g()) {
 LL | |         }
 LL | |     };
    | |______^
+   |
+help: consider writing
+   |
+LL ~     let Some(v_some) = g() else {
+LL +         match (g(), g()) {
+LL +             (Some(_), None) => return,
+LL +             (None, Some(_)) => {
+LL +                 if true {
+LL +                     return;
+LL +                 } else {
+LL +                     panic!();
+LL +                 }
+LL +             },
+LL +             _ => return,
+LL +         }
+LL +     };
+   |
 
-error: this could be rewritten as `let else`
+error: this could be rewritten as `let...else`
   --> $DIR/manual_let_else.rs:85:5
    |
 LL | /     let (v, w) = if let Some(v_some) = g().map(|v| (v, 42)) {
@@ -99,8 +155,15 @@ LL | |     } else {
 LL | |         return;
 LL | |     };
    | |______^
+   |
+help: consider writing
+   |
+LL ~     let Some(v_some) = g().map(|v| (v, 42)) else {
+LL +         return;
+LL +     };
+   |
 
-error: this could be rewritten as `let else`
+error: this could be rewritten as `let...else`
   --> $DIR/manual_let_else.rs:92:5
    |
 LL | /     let v = if let (Some(v_some), w_some) = (g(), 0) {
@@ -109,12 +172,19 @@ LL | |     } else {
 LL | |         return;
 LL | |     };
    | |______^
+   |
+help: consider writing
+   |
+LL ~     let (Some(v_some), w_some) = (g(), 0) else {
+LL +         return;
+LL +     };
+   |
 
-error: this could be rewritten as `let else`
+error: this could be rewritten as `let...else`
   --> $DIR/manual_let_else.rs:101:13
    |
 LL |             let $n = if let Some(v) = $e { v } else { return };
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let Some(v) = g() else { return };`
 ...
 LL |     create_binding_if_some!(w, g());
    |     ------------------------------- in this macro invocation
diff --git a/tests/ui/manual_let_else_match.stderr b/tests/ui/manual_let_else_match.stderr
index a79afc6401d..38be5ac5454 100644
--- a/tests/ui/manual_let_else_match.stderr
+++ b/tests/ui/manual_let_else_match.stderr
@@ -1,58 +1,58 @@
-error: this could be rewritten as `let else`
+error: this could be rewritten as `let...else`
   --> $DIR/manual_let_else_match.rs:32:5
    |
 LL | /     let v = match g() {
 LL | |         Some(v_some) => v_some,
 LL | |         None => return,
 LL | |     };
-   | |______^
+   | |______^ help: consider writing: `let Some(v_some) = g() else { return };`
    |
    = note: `-D clippy::manual-let-else` implied by `-D warnings`
 
-error: this could be rewritten as `let else`
+error: this could be rewritten as `let...else`
   --> $DIR/manual_let_else_match.rs:37:5
    |
 LL | /     let v = match g() {
 LL | |         Some(v_some) => v_some,
 LL | |         _ => return,
 LL | |     };
-   | |______^
+   | |______^ help: consider writing: `let Some(v_some) = g() else { return };`
 
-error: this could be rewritten as `let else`
+error: this could be rewritten as `let...else`
   --> $DIR/manual_let_else_match.rs:44:9
    |
 LL | /         let v = match h() {
 LL | |             (Some(_), Some(_)) | (None, None) => continue,
 LL | |             (Some(v), None) | (None, Some(v)) => v,
 LL | |         };
-   | |__________^
+   | |__________^ help: consider writing: `let (Some(v), None) | (None, Some(v)) = h() else { continue };`
 
-error: this could be rewritten as `let else`
+error: this could be rewritten as `let...else`
   --> $DIR/manual_let_else_match.rs:49:9
    |
 LL | /         let v = match build_enum() {
 LL | |             _ => continue,
 LL | |             Variant::Bar(v) | Variant::Baz(v) => v,
 LL | |         };
-   | |__________^
+   | |__________^ help: consider writing: `let Variant::Bar(v) | Variant::Baz(v) = build_enum() else { continue };`
 
-error: this could be rewritten as `let else`
+error: this could be rewritten as `let...else`
   --> $DIR/manual_let_else_match.rs:57:5
    |
 LL | /     let v = match f() {
 LL | |         Ok(v) => v,
 LL | |         Err(_) => return,
 LL | |     };
-   | |______^
+   | |______^ help: consider writing: `let Ok(v) = f() else { return };`
 
-error: this could be rewritten as `let else`
+error: this could be rewritten as `let...else`
   --> $DIR/manual_let_else_match.rs:63:5
    |
 LL | /     let v = match f().map_err(|_| ()) {
 LL | |         Ok(v) => v,
 LL | |         Err(()) => return,
 LL | |     };
-   | |______^
+   | |______^ help: consider writing: `let Ok(v) = f().map_err(|_| ()) else { return };`
 
 error: aborting due to 6 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 01e651f2feea84ce0b4551a71101f7b29bcc65cb Mon Sep 17 00:00:00 2001
From: oxalica <oxalicc@pm.me>
Date: Mon, 10 Oct 2022 16:00:33 +0200
Subject: Don't lint if the let is already a let-else

We cannot apply the lint for 3-branches like in the added example.
---
 clippy_lints/src/manual_let_else.rs | 1 +
 tests/ui/manual_let_else.rs         | 3 +++
 2 files changed, 4 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_let_else.rs b/clippy_lints/src/manual_let_else.rs
index 8d743c86d6d..8a915127c3c 100644
--- a/clippy_lints/src/manual_let_else.rs
+++ b/clippy_lints/src/manual_let_else.rs
@@ -73,6 +73,7 @@ impl<'tcx> LateLintPass<'tcx> for ManualLetElse {
             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 init.span.ctxt() == stmt.span.ctxt();
             if let Some(if_let_or_match) = IfLetOrMatch::parse(cx, init);
             then {
diff --git a/tests/ui/manual_let_else.rs b/tests/ui/manual_let_else.rs
index bd0ac69e46e..9e5df65b74d 100644
--- a/tests/ui/manual_let_else.rs
+++ b/tests/ui/manual_let_else.rs
@@ -194,4 +194,7 @@ fn not_fire() {
         };
     }
     create_binding_if_some_nf!(v, g());
+
+    // Already a let-else
+    let Some(a) = (if let Some(b) = Some(Some(())) { b } else { return }) else { panic!() };
 }
-- 
cgit 1.4.1-3-g733a5


From 748169deaa3c57e15e3a84bb90e033dddaa64e03 Mon Sep 17 00:00:00 2001
From: est31 <MTest31@outlook.com>
Date: Mon, 10 Oct 2022 21:51:24 +0200
Subject: Don't fire the lint if there is a type annotation

Sometimes type annotations are needed for type inferrence to work,
or because of coercions. We don't know this, and we also don't
want users to possibly repeat the entire pattern.
---
 clippy_lints/src/manual_let_else.rs | 1 +
 tests/ui/manual_let_else.rs         | 4 ++++
 2 files changed, 5 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_let_else.rs b/clippy_lints/src/manual_let_else.rs
index 8a915127c3c..521d02db80f 100644
--- a/clippy_lints/src/manual_let_else.rs
+++ b/clippy_lints/src/manual_let_else.rs
@@ -74,6 +74,7 @@ impl<'tcx> LateLintPass<'tcx> for ManualLetElse {
             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 {
diff --git a/tests/ui/manual_let_else.rs b/tests/ui/manual_let_else.rs
index 9e5df65b74d..9046c0affb5 100644
--- a/tests/ui/manual_let_else.rs
+++ b/tests/ui/manual_let_else.rs
@@ -197,4 +197,8 @@ fn not_fire() {
 
     // Already a let-else
     let Some(a) = (if let Some(b) = Some(Some(())) { b } else { return }) else { panic!() };
+
+    // If a type annotation is present, don't lint as
+    // expressing the type might be too hard
+    let v: () = if let Some(v_some) = g() { v_some } else { panic!() };
 }
-- 
cgit 1.4.1-3-g733a5


From 96ea5b2cd6c8a1c258d26ef8b39697689785478f Mon Sep 17 00:00:00 2001
From: est31 <MTest31@outlook.com>
Date: Wed, 12 Oct 2022 00:04:09 +0200
Subject: Fix dogfooding

---
 clippy_lints/src/dereference.rs |  4 +---
 clippy_utils/src/consts.rs      | 10 +++-------
 clippy_utils/src/hir_utils.rs   |  7 ++-----
 3 files changed, 6 insertions(+), 15 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index a95d9f5390d..7b5c10db4e1 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -274,9 +274,7 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing<'tcx> {
         }
 
         let typeck = cx.typeck_results();
-        let (kind, sub_expr) = if let Some(x) = try_parse_ref_op(cx.tcx, typeck, expr) {
-            x
-        } else {
+        let Some((kind, sub_expr)) = try_parse_ref_op(cx.tcx, typeck, expr) else {
             // The whole chain of reference operations has been seen
             if let Some((state, data)) = self.state.take() {
                 report(cx, expr, state, data);
diff --git a/clippy_utils/src/consts.rs b/clippy_utils/src/consts.rs
index 07e4ef6a2fe..f01afda72b2 100644
--- a/clippy_utils/src/consts.rs
+++ b/clippy_utils/src/consts.rs
@@ -147,9 +147,8 @@ impl Constant {
                 _ => None,
             },
             (&Self::Vec(ref l), &Self::Vec(ref r)) => {
-                let cmp_type = match *cmp_type.kind() {
-                    ty::Array(ty, _) | ty::Slice(ty) => ty,
-                    _ => return None,
+                let (ty::Array(cmp_type, _) | ty::Slice(cmp_type)) = *cmp_type.kind() else {
+                    return None
                 };
                 iter::zip(l, r)
                     .map(|(li, ri)| Self::partial_cmp(tcx, cmp_type, li, ri))
@@ -401,10 +400,7 @@ impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
         use self::Constant::{Int, F32, F64};
         match *o {
             Int(value) => {
-                let ity = match *ty.kind() {
-                    ty::Int(ity) => ity,
-                    _ => return None,
-                };
+                let ty::Int(ity) = *ty.kind() else { return None };
                 // sign extend
                 let value = sext(self.lcx.tcx, value, ity);
                 let value = value.checked_neg()?;
diff --git a/clippy_utils/src/hir_utils.rs b/clippy_utils/src/hir_utils.rs
index cf24ec8b67b..02b973e5b27 100644
--- a/clippy_utils/src/hir_utils.rs
+++ b/clippy_utils/src/hir_utils.rs
@@ -131,13 +131,10 @@ impl HirEqInterExpr<'_, '_, '_> {
             ([], None, [], None) => {
                 // For empty blocks, check to see if the tokens are equal. This will catch the case where a macro
                 // expanded to nothing, or the cfg attribute was used.
-                let (left, right) = match (
+                let (Some(left), Some(right)) = (
                     snippet_opt(self.inner.cx, left.span),
                     snippet_opt(self.inner.cx, right.span),
-                ) {
-                    (Some(left), Some(right)) => (left, right),
-                    _ => return true,
-                };
+                ) else { return true };
                 let mut left_pos = 0;
                 let left = tokenize(&left)
                     .map(|t| {
-- 
cgit 1.4.1-3-g733a5


From dcde480a667f24923c9895e3eb6e9a030d271299 Mon Sep 17 00:00:00 2001
From: est31 <MTest31@outlook.com>
Date: Sun, 16 Oct 2022 03:56:40 +0200
Subject: Also consider match guards for divergence check

Plus, add some tests for the divergence check.
---
 clippy_lints/src/manual_let_else.rs |  7 ++-
 tests/ui/manual_let_else.rs         | 33 +++++++++++++
 tests/ui/manual_let_else.stderr     | 96 +++++++++++++++++++++++++++++++------
 3 files changed, 120 insertions(+), 16 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_let_else.rs b/clippy_lints/src/manual_let_else.rs
index 521d02db80f..1846596fa4c 100644
--- a/clippy_lints/src/manual_let_else.rs
+++ b/clippy_lints/src/manual_let_else.rs
@@ -194,8 +194,11 @@ fn expr_diverges(cx: &LateContext<'_>, expr: &'_ Expr<'_>) -> bool {
                 ControlFlow::Continue(Descend::No)
             },
             ExprKind::Match(match_expr, match_arms, _) => {
-                let diverges =
-                    expr_diverges(cx, match_expr) || match_arms.iter().all(|arm| expr_diverges(cx, arm.body));
+                let diverges = expr_diverges(cx, match_expr)
+                    || match_arms.iter().all(|arm| {
+                        let guard_diverges = arm.guard.as_ref().map_or(false, |g| expr_diverges(cx, g.body()));
+                        guard_diverges || expr_diverges(cx, arm.body)
+                    });
                 if diverges {
                     return ControlFlow::Break(());
                 }
diff --git a/tests/ui/manual_let_else.rs b/tests/ui/manual_let_else.rs
index 9046c0affb5..2ef40e5911a 100644
--- a/tests/ui/manual_let_else.rs
+++ b/tests/ui/manual_let_else.rs
@@ -3,6 +3,7 @@
     clippy::collapsible_else_if,
     clippy::unused_unit,
     clippy::let_unit_value,
+    clippy::match_single_binding,
     clippy::never_loop
 )]
 #![warn(clippy::manual_let_else)]
@@ -55,6 +56,38 @@ fn fire() {
         if true { return } else { panic!() }
     };
 
+    // Diverging after an if still makes the block diverge:
+    let v = if let Some(v_some) = g() {
+        v_some
+    } else {
+        if true {}
+        panic!();
+    };
+
+    // A match diverges if all branches diverge:
+    // Note: the corresponding let-else requires a ; at the end of the match
+    // as otherwise the type checker does not turn it into a ! type.
+    let v = if let Some(v_some) = g() {
+        v_some
+    } else {
+        match () {
+            _ if panic!() => {},
+            _ => panic!(),
+        }
+    };
+
+    // An if's expression can cause divergence:
+    let v = if let Some(v_some) = g() { v_some } else { if panic!() {} };
+
+    // An expression of a match can cause divergence:
+    let v = if let Some(v_some) = g() {
+        v_some
+    } else {
+        match panic!() {
+            _ => {},
+        }
+    };
+
     // Top level else if
     let v = if let Some(v_some) = g() {
         v_some
diff --git a/tests/ui/manual_let_else.stderr b/tests/ui/manual_let_else.stderr
index e073276d20c..453b68b8bd0 100644
--- a/tests/ui/manual_let_else.stderr
+++ b/tests/ui/manual_let_else.stderr
@@ -1,5 +1,5 @@
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:17:5
+  --> $DIR/manual_let_else.rs:18:5
    |
 LL |     let v = if let Some(v_some) = g() { v_some } else { return };
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let Some(v_some) = g() else { return };`
@@ -7,7 +7,7 @@ LL |     let v = if let Some(v_some) = g() { v_some } 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:18:5
+  --> $DIR/manual_let_else.rs:19:5
    |
 LL | /     let v = if let Some(v_some) = g() {
 LL | |         v_some
@@ -24,7 +24,7 @@ LL +     };
    |
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:24:5
+  --> $DIR/manual_let_else.rs:25: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:37:9
+  --> $DIR/manual_let_else.rs:38:9
    |
 LL |         let v = if let Some(v_some) = g() { v_some } else { continue };
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let Some(v_some) = g() else { continue };`
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:38:9
+  --> $DIR/manual_let_else.rs:39:9
    |
 LL |         let v = if let Some(v_some) = g() { v_some } else { break };
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let Some(v_some) = g() else { break };`
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:42:5
+  --> $DIR/manual_let_else.rs:43:5
    |
 LL |     let v = if let Some(v_some) = g() { v_some } else { panic!() };
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let Some(v_some) = g() else { panic!() };`
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:45:5
+  --> $DIR/manual_let_else.rs:46:5
    |
 LL | /     let v = if let Some(v_some) = g() {
 LL | |         v_some
@@ -80,7 +80,7 @@ LL +     };
    |
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:52:5
+  --> $DIR/manual_let_else.rs:53:5
    |
 LL | /     let v = if let Some(v_some) = g() {
 LL | |         v_some
@@ -97,7 +97,75 @@ LL +     };
    |
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:59:5
+  --> $DIR/manual_let_else.rs:60:5
+   |
+LL | /     let v = if let Some(v_some) = g() {
+LL | |         v_some
+LL | |     } else {
+LL | |         if true {}
+LL | |         panic!();
+LL | |     };
+   | |______^
+   |
+help: consider writing
+   |
+LL ~     let Some(v_some) = g() else {
+LL +         if true {}
+LL +         panic!();
+LL +     };
+   |
+
+error: this could be rewritten as `let...else`
+  --> $DIR/manual_let_else.rs:70:5
+   |
+LL | /     let v = if let Some(v_some) = g() {
+LL | |         v_some
+LL | |     } else {
+LL | |         match () {
+...  |
+LL | |         }
+LL | |     };
+   | |______^
+   |
+help: consider writing
+   |
+LL ~     let Some(v_some) = g() else {
+LL +         match () {
+LL +             _ if panic!() => {},
+LL +             _ => panic!(),
+LL +         }
+LL +     };
+   |
+
+error: this could be rewritten as `let...else`
+  --> $DIR/manual_let_else.rs:80: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!() {} };`
+
+error: this could be rewritten as `let...else`
+  --> $DIR/manual_let_else.rs:83:5
+   |
+LL | /     let v = if let Some(v_some) = g() {
+LL | |         v_some
+LL | |     } else {
+LL | |         match panic!() {
+LL | |             _ => {},
+LL | |         }
+LL | |     };
+   | |______^
+   |
+help: consider writing
+   |
+LL ~     let Some(v_some) = g() else {
+LL +         match panic!() {
+LL +             _ => {},
+LL +         }
+LL +     };
+   |
+
+error: this could be rewritten as `let...else`
+  --> $DIR/manual_let_else.rs:92:5
    |
 LL | /     let v = if let Some(v_some) = g() {
 LL | |         v_some
@@ -118,7 +186,7 @@ LL +     } };
    |
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:68:5
+  --> $DIR/manual_let_else.rs:101:5
    |
 LL | /     let v = if let Some(v_some) = g() {
 LL | |         v_some
@@ -147,7 +215,7 @@ LL +     };
    |
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:85:5
+  --> $DIR/manual_let_else.rs:118:5
    |
 LL | /     let (v, w) = if let Some(v_some) = g().map(|v| (v, 42)) {
 LL | |         v_some
@@ -164,7 +232,7 @@ LL +     };
    |
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:92:5
+  --> $DIR/manual_let_else.rs:125:5
    |
 LL | /     let v = if let (Some(v_some), w_some) = (g(), 0) {
 LL | |         (w_some, v_some)
@@ -181,7 +249,7 @@ LL +     };
    |
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:101:13
+  --> $DIR/manual_let_else.rs:134:13
    |
 LL |             let $n = if let Some(v) = $e { v } else { return };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let Some(v) = g() else { return };`
@@ -191,5 +259,5 @@ LL |     create_binding_if_some!(w, g());
    |
    = note: this error originates in the macro `create_binding_if_some` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to 13 previous errors
+error: aborting due to 17 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From eba36e6d95aef2d6415327a27ab3a91069333b97 Mon Sep 17 00:00:00 2001
From: Andre Bogus <bogusandre@gmail.com>
Date: Thu, 20 Oct 2022 23:40:10 +0200
Subject: make arc-likes for `mutable-key` configurable

We had some false positives where people would create their own types
that had interior mutability unrelated to hash/eq. This addition lets
you configure this as e.g. `arc-like-types=["bytes::Bytes"]`
---
 clippy_lints/src/lib.rs                            |   3 +-
 clippy_lints/src/mut_key.rs                        | 158 +++++++++++++--------
 clippy_lints/src/utils/conf.rs                     |   7 +-
 clippy_utils/src/lib.rs                            |  42 +++++-
 tests/ui-toml/mut_key/clippy.toml                  |   1 +
 tests/ui-toml/mut_key/mut_key.rs                   |  53 +++++++
 .../toml_unknown_key/conf_unknown_key.stderr       |   1 +
 7 files changed, 199 insertions(+), 66 deletions(-)
 create mode 100644 tests/ui-toml/mut_key/clippy.toml
 create mode 100644 tests/ui-toml/mut_key/mut_key.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 28248d01b64..d08e38fa203 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -735,7 +735,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     let max_trait_bounds = conf.max_trait_bounds;
     store.register_late_pass(move |_| Box::new(trait_bounds::TraitBounds::new(max_trait_bounds)));
     store.register_late_pass(|_| Box::new(comparison_chain::ComparisonChain));
-    store.register_late_pass(|_| Box::new(mut_key::MutableKeyType));
+    let ignore_interior_mutability = conf.ignore_interior_mutability.clone();
+    store.register_late_pass(move |_| Box::new(mut_key::MutableKeyType::new(ignore_interior_mutability.clone())));
     store.register_early_pass(|| Box::new(reference::DerefAddrOf));
     store.register_early_pass(|| Box::new(double_parens::DoubleParens));
     store.register_late_pass(|_| Box::new(format_impl::FormatImpl::new()));
diff --git a/clippy_lints/src/mut_key.rs b/clippy_lints/src/mut_key.rs
index 25d6ca83a94..3d643e4e65c 100644
--- a/clippy_lints/src/mut_key.rs
+++ b/clippy_lints/src/mut_key.rs
@@ -1,10 +1,12 @@
 use clippy_utils::diagnostics::span_lint;
-use clippy_utils::trait_ref_of_method;
+use clippy_utils::{def_path_res, trait_ref_of_method};
+use rustc_data_structures::fx::FxHashSet;
 use rustc_hir as hir;
+use rustc_hir::def::Namespace;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::TypeVisitable;
 use rustc_middle::ty::{Adt, Array, Ref, Slice, Tuple, Ty};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::Span;
 use rustc_span::symbol::sym;
 use std::iter;
@@ -78,26 +80,44 @@ declare_clippy_lint! {
     "Check for mutable `Map`/`Set` key type"
 }
 
-declare_lint_pass!(MutableKeyType => [ MUTABLE_KEY_TYPE ]);
+#[derive(Clone)]
+pub struct MutableKeyType {
+    ignore_interior_mutability: Vec<String>,
+    ignore_mut_def_ids: FxHashSet<hir::def_id::DefId>,
+}
+
+impl_lint_pass!(MutableKeyType => [ MUTABLE_KEY_TYPE ]);
 
 impl<'tcx> LateLintPass<'tcx> for MutableKeyType {
+    fn check_crate(&mut self, cx: &LateContext<'tcx>) {
+        self.ignore_mut_def_ids.clear();
+        let mut path = Vec::new();
+        for ty in &self.ignore_interior_mutability {
+            path.extend(ty.split("::"));
+            if let Some(id) = def_path_res(cx, &path[..], Some(Namespace::TypeNS)).opt_def_id() {
+                self.ignore_mut_def_ids.insert(id);
+            }
+            path.clear();
+        }
+    }
+
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'tcx>) {
         if let hir::ItemKind::Fn(ref sig, ..) = item.kind {
-            check_sig(cx, item.hir_id(), sig.decl);
+            self.check_sig(cx, item.hir_id(), sig.decl);
         }
     }
 
     fn check_impl_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::ImplItem<'tcx>) {
         if let hir::ImplItemKind::Fn(ref sig, ..) = item.kind {
             if trait_ref_of_method(cx, item.def_id.def_id).is_none() {
-                check_sig(cx, item.hir_id(), sig.decl);
+                self.check_sig(cx, item.hir_id(), sig.decl);
             }
         }
     }
 
     fn check_trait_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::TraitItem<'tcx>) {
         if let hir::TraitItemKind::Fn(ref sig, ..) = item.kind {
-            check_sig(cx, item.hir_id(), sig.decl);
+            self.check_sig(cx, item.hir_id(), sig.decl);
         }
     }
 
@@ -105,71 +125,83 @@ impl<'tcx> LateLintPass<'tcx> for MutableKeyType {
         if let hir::PatKind::Wild = local.pat.kind {
             return;
         }
-        check_ty(cx, local.span, cx.typeck_results().pat_ty(local.pat));
+        self.check_ty_(cx, local.span, cx.typeck_results().pat_ty(local.pat));
     }
 }
 
-fn check_sig<'tcx>(cx: &LateContext<'tcx>, item_hir_id: hir::HirId, decl: &hir::FnDecl<'_>) {
-    let fn_def_id = cx.tcx.hir().local_def_id(item_hir_id);
-    let fn_sig = cx.tcx.fn_sig(fn_def_id);
-    for (hir_ty, ty) in iter::zip(decl.inputs, fn_sig.inputs().skip_binder()) {
-        check_ty(cx, hir_ty.span, *ty);
+impl MutableKeyType {
+    pub fn new(ignore_interior_mutability: Vec<String>) -> Self {
+        Self {
+            ignore_interior_mutability,
+            ignore_mut_def_ids: FxHashSet::default(),
+        }
     }
-    check_ty(cx, decl.output.span(), cx.tcx.erase_late_bound_regions(fn_sig.output()));
-}
 
-// We want to lint 1. sets or maps with 2. not immutable key types and 3. no unerased
-// generics (because the compiler cannot ensure immutability for unknown types).
-fn check_ty<'tcx>(cx: &LateContext<'tcx>, span: Span, ty: Ty<'tcx>) {
-    let ty = ty.peel_refs();
-    if let Adt(def, substs) = ty.kind() {
-        let is_keyed_type = [sym::HashMap, sym::BTreeMap, sym::HashSet, sym::BTreeSet]
-            .iter()
-            .any(|diag_item| cx.tcx.is_diagnostic_item(*diag_item, def.did()));
-        if is_keyed_type && is_interior_mutable_type(cx, substs.type_at(0), span) {
-            span_lint(cx, MUTABLE_KEY_TYPE, span, "mutable key type");
+    fn check_sig<'tcx>(&self, cx: &LateContext<'tcx>, item_hir_id: hir::HirId, decl: &hir::FnDecl<'_>) {
+        let fn_def_id = cx.tcx.hir().local_def_id(item_hir_id);
+        let fn_sig = cx.tcx.fn_sig(fn_def_id);
+        for (hir_ty, ty) in iter::zip(decl.inputs, fn_sig.inputs().skip_binder()) {
+            self.check_ty_(cx, hir_ty.span, *ty);
         }
+        self.check_ty_(cx, decl.output.span(), cx.tcx.erase_late_bound_regions(fn_sig.output()));
     }
-}
 
-/// Determines if a type contains interior mutability which would affect its implementation of
-/// [`Hash`] or [`Ord`].
-fn is_interior_mutable_type<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>, span: Span) -> bool {
-    match *ty.kind() {
-        Ref(_, inner_ty, mutbl) => mutbl == hir::Mutability::Mut || is_interior_mutable_type(cx, inner_ty, span),
-        Slice(inner_ty) => is_interior_mutable_type(cx, inner_ty, span),
-        Array(inner_ty, size) => {
-            size.try_eval_usize(cx.tcx, cx.param_env).map_or(true, |u| u != 0)
-                && is_interior_mutable_type(cx, inner_ty, span)
-        },
-        Tuple(fields) => fields.iter().any(|ty| is_interior_mutable_type(cx, ty, span)),
-        Adt(def, substs) => {
-            // Special case for collections in `std` who's impl of `Hash` or `Ord` delegates to
-            // that of their type parameters.  Note: we don't include `HashSet` and `HashMap`
-            // because they have no impl for `Hash` or `Ord`.
-            let is_std_collection = [
-                sym::Option,
-                sym::Result,
-                sym::LinkedList,
-                sym::Vec,
-                sym::VecDeque,
-                sym::BTreeMap,
-                sym::BTreeSet,
-                sym::Rc,
-                sym::Arc,
-            ]
-            .iter()
-            .any(|diag_item| cx.tcx.is_diagnostic_item(*diag_item, def.did()));
-            let is_box = Some(def.did()) == cx.tcx.lang_items().owned_box();
-            if is_std_collection || is_box {
-                // The type is mutable if any of its type parameters are
-                substs.types().any(|ty| is_interior_mutable_type(cx, ty, span))
-            } else {
-                !ty.has_escaping_bound_vars()
-                    && cx.tcx.layout_of(cx.param_env.and(ty)).is_ok()
-                    && !ty.is_freeze(cx.tcx.at(span), cx.param_env)
+    // We want to lint 1. sets or maps with 2. not immutable key types and 3. no unerased
+    // generics (because the compiler cannot ensure immutability for unknown types).
+    fn check_ty_<'tcx>(&self, cx: &LateContext<'tcx>, span: Span, ty: Ty<'tcx>) {
+        let ty = ty.peel_refs();
+        if let Adt(def, substs) = ty.kind() {
+            let is_keyed_type = [sym::HashMap, sym::BTreeMap, sym::HashSet, sym::BTreeSet]
+                .iter()
+                .any(|diag_item| cx.tcx.is_diagnostic_item(*diag_item, def.did()));
+            if is_keyed_type && self.is_interior_mutable_type(cx, substs.type_at(0), span) {
+                span_lint(cx, MUTABLE_KEY_TYPE, span, "mutable key type");
             }
-        },
-        _ => false,
+        }
+    }
+
+    /// Determines if a type contains interior mutability which would affect its implementation of
+    /// [`Hash`] or [`Ord`].
+    fn is_interior_mutable_type<'tcx>(&self, cx: &LateContext<'tcx>, ty: Ty<'tcx>, span: Span) -> bool {
+        match *ty.kind() {
+            Ref(_, inner_ty, mutbl) => {
+                mutbl == hir::Mutability::Mut || self.is_interior_mutable_type(cx, inner_ty, span)
+            },
+            Slice(inner_ty) => self.is_interior_mutable_type(cx, inner_ty, span),
+            Array(inner_ty, size) => {
+                size.try_eval_usize(cx.tcx, cx.param_env).map_or(true, |u| u != 0)
+                    && self.is_interior_mutable_type(cx, inner_ty, span)
+            },
+            Tuple(fields) => fields.iter().any(|ty| self.is_interior_mutable_type(cx, ty, span)),
+            Adt(def, substs) => {
+                // Special case for collections in `std` who's impl of `Hash` or `Ord` delegates to
+                // that of their type parameters.  Note: we don't include `HashSet` and `HashMap`
+                // because they have no impl for `Hash` or `Ord`.
+                let def_id = def.did();
+                let is_std_collection = [
+                    sym::Option,
+                    sym::Result,
+                    sym::LinkedList,
+                    sym::Vec,
+                    sym::VecDeque,
+                    sym::BTreeMap,
+                    sym::BTreeSet,
+                    sym::Rc,
+                    sym::Arc,
+                ]
+                .iter()
+                .any(|diag_item| cx.tcx.is_diagnostic_item(*diag_item, def_id));
+                let is_box = Some(def_id) == cx.tcx.lang_items().owned_box();
+                if is_std_collection || is_box || self.ignore_mut_def_ids.contains(&def_id) {
+                    // The type is mutable if any of its type parameters are
+                    substs.types().any(|ty| self.is_interior_mutable_type(cx, ty, span))
+                } else {
+                    !ty.has_escaping_bound_vars()
+                        && cx.tcx.layout_of(cx.param_env.and(ty)).is_ok()
+                        && !ty.is_freeze(cx.tcx.at(span), cx.param_env)
+                }
+            },
+            _ => false,
+        }
     }
 }
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index a10de31556c..eb5b4f09bf4 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -383,10 +383,15 @@ define_Conf! {
     ///
     /// Whether `dbg!` should be allowed in test functions
     (allow_dbg_in_tests: bool = false),
-    /// Lint: RESULT_LARGE_ERR
+    /// Lint: RESULT_LARGE_ERR.
     ///
     /// The maximum size of the `Err`-variant in a `Result` returned from a function
     (large_error_threshold: u64 = 128),
+    /// Lint: MUTABLE_KEY.
+    ///
+    /// A list of paths to types that should be treated like `Arc`, i.e. ignored but
+    /// for the generic parameters for determining interior mutability
+    (ignore_interior_mutability: Vec<String> = Vec::from(["bytes::Bytes".into()])),
 }
 
 /// Search for the configuration file.
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 14b1b6eacc6..dda4660fb7a 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -598,7 +598,13 @@ pub fn def_path_res(cx: &LateContext<'_>, path: &[&str], namespace_hint: Option<
         [primitive] => {
             return PrimTy::from_name(Symbol::intern(primitive)).map_or(Res::Err, Res::PrimTy);
         },
-        [base, ref path @ ..] => (base, path),
+        [base, ref path @ ..] => {
+            let crate_name = cx.sess().opts.crate_name.as_deref();
+            if Some(base) == crate_name {
+                return def_path_res_local(cx, path);
+            }
+            (base, path)
+        },
         _ => return Res::Err,
     };
     let tcx = cx.tcx;
@@ -642,7 +648,41 @@ pub fn def_path_res(cx: &LateContext<'_>, path: &[&str], namespace_hint: Option<
             return last;
         }
     }
+    Res::Err
+}
 
+fn def_path_res_local(cx: &LateContext<'_>, mut path: &[&str]) -> Res {
+    let map = cx.tcx.hir();
+    let mut ids = map.root_module().item_ids;
+    while let Some(&segment) = path.first() {
+        let mut next_ids = None;
+        for i in ids {
+            if let Some(Node::Item(hir::Item {
+                ident,
+                kind,
+                def_id: item_def_id,
+                ..
+            })) = map.find(i.hir_id())
+            {
+                if ident.name.as_str() == segment {
+                    path = &path[1..];
+                    if path.is_empty() {
+                        let def_id = item_def_id.to_def_id();
+                        return Res::Def(cx.tcx.def_kind(def_id), def_id);
+                    }
+                    if let ItemKind::Mod(m) = kind {
+                        next_ids = Some(m.item_ids);
+                    };
+                    break;
+                }
+            }
+        }
+        if let Some(next_ids) = next_ids {
+            ids = next_ids;
+        } else {
+            break;
+        }
+    }
     Res::Err
 }
 
diff --git a/tests/ui-toml/mut_key/clippy.toml b/tests/ui-toml/mut_key/clippy.toml
new file mode 100644
index 00000000000..6d33e192ee8
--- /dev/null
+++ b/tests/ui-toml/mut_key/clippy.toml
@@ -0,0 +1 @@
+ignore-interior-mutability = ["mut_key::Counted"]
\ No newline at end of file
diff --git a/tests/ui-toml/mut_key/mut_key.rs b/tests/ui-toml/mut_key/mut_key.rs
new file mode 100644
index 00000000000..667c51cb4a3
--- /dev/null
+++ b/tests/ui-toml/mut_key/mut_key.rs
@@ -0,0 +1,53 @@
+// compile-flags: --crate-name mut_key
+
+#![warn(clippy::mutable_key_type)]
+
+use std::cmp::{Eq, PartialEq};
+use std::collections::{HashMap, HashSet};
+use std::hash::{Hash, Hasher};
+use std::ops::Deref;
+use std::sync::atomic::{AtomicUsize, Ordering};
+
+struct Counted<T> {
+    count: AtomicUsize,
+    val: T,
+}
+
+impl<T: Clone> Clone for Counted<T> {
+    fn clone(&self) -> Self {
+        Self {
+            count: AtomicUsize::new(0),
+            val: self.val.clone(),
+        }
+    }
+}
+
+impl<T: PartialEq> PartialEq for Counted<T> {
+    fn eq(&self, other: &Self) -> bool {
+        self.val == other.val
+    }
+}
+impl<T: PartialEq + Eq> Eq for Counted<T> {}
+
+impl<T: Hash> Hash for Counted<T> {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.val.hash(state);
+    }
+}
+
+impl<T> Deref for Counted<T> {
+    type Target = T;
+
+    fn deref(&self) -> &T {
+        self.count.fetch_add(1, Ordering::AcqRel);
+        &self.val
+    }
+}
+
+// This is not linted because `"mut_key::Counted"` is in
+// `arc_like_types` in `clippy.toml`
+fn should_not_take_this_arg(_v: HashSet<Counted<String>>) {}
+
+fn main() {
+    should_not_take_this_arg(HashSet::new());
+}
diff --git a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
index 82ee8054132..70022370bb4 100644
--- a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
+++ b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
@@ -20,6 +20,7 @@ error: error reading Clippy's configuration file `$DIR/clippy.toml`: unknown fie
            enforced-import-renames
            enum-variant-name-threshold
            enum-variant-size-threshold
+           ignore-interior-mutability
            large-error-threshold
            literal-representation-threshold
            max-fn-params-bools
-- 
cgit 1.4.1-3-g733a5


From 6efb3a2b9ac9e0477b6b222c051c15c98233b424 Mon Sep 17 00:00:00 2001
From: koka <koka.code@gmail.com>
Date: Tue, 25 Oct 2022 12:26:06 +0900
Subject: feat: add new lint `seek_from_current`

addresses https://github.com/rust-lang/rust-clippy/issues/7886
added `seek_from_current` complexity lint.
it checks use of `Seek#seek` with `SeekFrom::Current(0)` and
suggests `Seek#stream_position` method

fix: add msrv

fix: register LintInfo

fix: remove unnecessary files

fix: add test for msrv

fix: remove

fix

fix: remove docs
---
 CHANGELOG.md                                  |  1 +
 clippy_lints/src/declared_lints.rs            |  1 +
 clippy_lints/src/methods/mod.rs               | 48 +++++++++++++++++++++++++++
 clippy_lints/src/methods/seek_from_current.rs | 48 +++++++++++++++++++++++++++
 clippy_utils/src/msrvs.rs                     |  2 +-
 clippy_utils/src/paths.rs                     |  1 +
 tests/ui/seek_from_current.fixed              | 26 +++++++++++++++
 tests/ui/seek_from_current.rs                 | 26 +++++++++++++++
 tests/ui/seek_from_current.stderr             | 10 ++++++
 9 files changed, 162 insertions(+), 1 deletion(-)
 create mode 100644 clippy_lints/src/methods/seek_from_current.rs
 create mode 100644 tests/ui/seek_from_current.fixed
 create mode 100644 tests/ui/seek_from_current.rs
 create mode 100644 tests/ui/seek_from_current.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 7e91365c69a..b47e80f6979 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4200,6 +4200,7 @@ Released 2018-09-13
 [`same_item_push`]: https://rust-lang.github.io/rust-clippy/master/index.html#same_item_push
 [`same_name_method`]: https://rust-lang.github.io/rust-clippy/master/index.html#same_name_method
 [`search_is_some`]: https://rust-lang.github.io/rust-clippy/master/index.html#search_is_some
+[`seek_from_current`]: https://rust-lang.github.io/rust-clippy/master/index.html#seek_from_current
 [`seek_to_start_instead_of_rewind`]: https://rust-lang.github.io/rust-clippy/master/index.html#seek_to_start_instead_of_rewind
 [`self_assignment`]: https://rust-lang.github.io/rust-clippy/master/index.html#self_assignment
 [`self_named_constructors`]: https://rust-lang.github.io/rust-clippy/master/index.html#self_named_constructors
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index a903d46b2a4..fff26307e34 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -363,6 +363,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::methods::REPEAT_ONCE_INFO,
     crate::methods::RESULT_MAP_OR_INTO_OPTION_INFO,
     crate::methods::SEARCH_IS_SOME_INFO,
+    crate::methods::SEEK_FROM_CURRENT_INFO,
     crate::methods::SEEK_TO_START_INSTEAD_OF_REWIND_INFO,
     crate::methods::SHOULD_IMPLEMENT_TRAIT_INFO,
     crate::methods::SINGLE_CHAR_ADD_STR_INFO,
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 4fd1e3e54ae..b29c7d9f253 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -69,6 +69,7 @@ mod path_buf_push_overwrite;
 mod range_zip_with_len;
 mod repeat_once;
 mod search_is_some;
+mod seek_from_current;
 mod seek_to_start_instead_of_rewind;
 mod single_char_add_str;
 mod single_char_insert_string;
@@ -3067,6 +3068,49 @@ declare_clippy_lint! {
     "iterating on map using `iter` when `keys` or `values` would do"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    ///
+    /// Checks an argument of `seek` method of `Seek` trait
+    /// and if it start seek from `SeekFrom::Current(0)`, suggests `stream_position` instead.
+    ///
+    /// ### Why is this bad?
+    ///
+    /// Readability. Use dedicated method.
+    ///
+    /// ### Example
+    ///
+    /// ```rust
+    /// use std::fs::File;
+    /// use std::io::{self, Write, Seek, SeekFrom};
+    ///
+    /// fn main() -> io::Result<()> {
+    ///     let mut f = File::create("foo.txt")?;
+    ///     f.write_all(b"Hello")?;
+    ///     eprintln!("Written {} bytes", f.seek(SeekFrom::Current(0))?);
+    ///
+    ///     Ok(())
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// use std::fs::File;
+    /// use std::io::{self, Write, Seek, SeekFrom};
+    ///
+    /// fn main() -> io::Result<()> {
+    ///     let mut f = File::create("foo.txt")?;
+    ///     f.write_all(b"Hello")?;
+    ///     eprintln!("Written {} bytes", f.stream_position()?);
+    ///
+    ///     Ok(())
+    /// }
+    /// ```
+    #[clippy::version = "1.66.0"]
+    pub SEEK_FROM_CURRENT,
+    complexity,
+    "use dedicated method for seek from current position"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     ///
@@ -3222,6 +3266,7 @@ impl_lint_pass!(Methods => [
     VEC_RESIZE_TO_ZERO,
     VERBOSE_FILE_READS,
     ITER_KV_MAP,
+    SEEK_FROM_CURRENT,
     SEEK_TO_START_INSTEAD_OF_REWIND,
 ]);
 
@@ -3638,6 +3683,9 @@ impl Methods {
                     vec_resize_to_zero::check(cx, expr, count_arg, default_arg, span);
                 },
                 ("seek", [arg]) => {
+                    if meets_msrv(self.msrv, msrvs::SEEK_FROM_CURRENT) {
+                        seek_from_current::check(cx, expr, recv, arg);
+                    }
                     if meets_msrv(self.msrv, msrvs::SEEK_REWIND) {
                         seek_to_start_instead_of_rewind::check(cx, expr, recv, arg, span);
                     }
diff --git a/clippy_lints/src/methods/seek_from_current.rs b/clippy_lints/src/methods/seek_from_current.rs
new file mode 100644
index 00000000000..361a3082f94
--- /dev/null
+++ b/clippy_lints/src/methods/seek_from_current.rs
@@ -0,0 +1,48 @@
+use rustc_ast::ast::{LitIntType, LitKind};
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind};
+use rustc_lint::LateContext;
+
+use clippy_utils::{
+    diagnostics::span_lint_and_sugg, get_trait_def_id, match_def_path, paths, source::snippet_with_applicability,
+    ty::implements_trait,
+};
+
+use super::SEEK_FROM_CURRENT;
+
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, recv: &'tcx Expr<'_>, arg: &'tcx Expr<'_>) {
+    let ty = cx.typeck_results().expr_ty(recv);
+
+    if let Some(def_id) = get_trait_def_id(cx, &paths::STD_IO_SEEK) {
+        if implements_trait(cx, ty, def_id, &[]) && arg_is_seek_from_current(cx, arg) {
+            let mut applicability = Applicability::MachineApplicable;
+            let snip = snippet_with_applicability(cx, recv.span, "..", &mut applicability);
+
+            span_lint_and_sugg(
+                cx,
+                SEEK_FROM_CURRENT,
+                expr.span,
+                "using `SeekFrom::Current` to start from current position",
+                "replace with",
+                format!("{snip}.stream_position()"),
+                applicability,
+            );
+        }
+    }
+}
+
+fn arg_is_seek_from_current<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> bool {
+    if let ExprKind::Call(f, args) = expr.kind &&
+        let ExprKind::Path(ref path) = f.kind &&
+        let Some(def_id) = cx.qpath_res(path, f.hir_id).opt_def_id() &&
+        match_def_path(cx, def_id, &paths::STD_IO_SEEK_FROM_CURRENT) {
+        // check if argument of `SeekFrom::Current` is `0`
+        if args.len() == 1 &&
+            let ExprKind::Lit(ref lit) = args[0].kind &&
+            let LitKind::Int(0, LitIntType::Unsuffixed) = lit.node {
+            return true
+        }
+    }
+
+    false
+}
diff --git a/clippy_utils/src/msrvs.rs b/clippy_utils/src/msrvs.rs
index 04b504d044d..9a672e2ddfd 100644
--- a/clippy_utils/src/msrvs.rs
+++ b/clippy_utils/src/msrvs.rs
@@ -17,7 +17,7 @@ msrv_aliases! {
     1,58,0 { FORMAT_ARGS_CAPTURE }
     1,53,0 { OR_PATTERNS, MANUAL_BITS, BTREE_MAP_RETAIN, BTREE_SET_RETAIN, ARRAY_INTO_ITERATOR }
     1,52,0 { STR_SPLIT_ONCE, REM_EUCLID_CONST }
-    1,51,0 { BORROW_AS_PTR, UNSIGNED_ABS }
+    1,51,0 { BORROW_AS_PTR, SEEK_FROM_CURRENT, UNSIGNED_ABS }
     1,50,0 { BOOL_THEN, CLAMP }
     1,47,0 { TAU }
     1,46,0 { CONST_IF_MATCH }
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index e37c7e34c0c..6c09c146082 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -116,6 +116,7 @@ pub const STDOUT: [&str; 4] = ["std", "io", "stdio", "stdout"];
 pub const CONVERT_IDENTITY: [&str; 3] = ["core", "convert", "identity"];
 pub const STD_FS_CREATE_DIR: [&str; 3] = ["std", "fs", "create_dir"];
 pub const STD_IO_SEEK: [&str; 3] = ["std", "io", "Seek"];
+pub const STD_IO_SEEK_FROM_CURRENT: [&str; 4] = ["std", "io", "SeekFrom", "Current"];
 pub const STD_IO_SEEKFROM_START: [&str; 4] = ["std", "io", "SeekFrom", "Start"];
 pub const STRING_AS_MUT_STR: [&str; 4] = ["alloc", "string", "String", "as_mut_str"];
 pub const STRING_AS_STR: [&str; 4] = ["alloc", "string", "String", "as_str"];
diff --git a/tests/ui/seek_from_current.fixed b/tests/ui/seek_from_current.fixed
new file mode 100644
index 00000000000..4b5303324bc
--- /dev/null
+++ b/tests/ui/seek_from_current.fixed
@@ -0,0 +1,26 @@
+// run-rustfix
+#![warn(clippy::seek_from_current)]
+#![feature(custom_inner_attributes)]
+
+use std::fs::File;
+use std::io::{self, Seek, SeekFrom, Write};
+
+fn _msrv_1_50() -> io::Result<()> {
+    #![clippy::msrv = "1.50"]
+    let mut f = File::create("foo.txt")?;
+    f.write_all(b"Hi!")?;
+    f.seek(SeekFrom::Current(0))?;
+    f.seek(SeekFrom::Current(1))?;
+    Ok(())
+}
+
+fn _msrv_1_51() -> io::Result<()> {
+    #![clippy::msrv = "1.51"]
+    let mut f = File::create("foo.txt")?;
+    f.write_all(b"Hi!")?;
+    f.stream_position()?;
+    f.seek(SeekFrom::Current(1))?;
+    Ok(())
+}
+
+fn main() {}
diff --git a/tests/ui/seek_from_current.rs b/tests/ui/seek_from_current.rs
new file mode 100644
index 00000000000..f93639261a1
--- /dev/null
+++ b/tests/ui/seek_from_current.rs
@@ -0,0 +1,26 @@
+// run-rustfix
+#![warn(clippy::seek_from_current)]
+#![feature(custom_inner_attributes)]
+
+use std::fs::File;
+use std::io::{self, Seek, SeekFrom, Write};
+
+fn _msrv_1_50() -> io::Result<()> {
+    #![clippy::msrv = "1.50"]
+    let mut f = File::create("foo.txt")?;
+    f.write_all(b"Hi!")?;
+    f.seek(SeekFrom::Current(0))?;
+    f.seek(SeekFrom::Current(1))?;
+    Ok(())
+}
+
+fn _msrv_1_51() -> io::Result<()> {
+    #![clippy::msrv = "1.51"]
+    let mut f = File::create("foo.txt")?;
+    f.write_all(b"Hi!")?;
+    f.seek(SeekFrom::Current(0))?;
+    f.seek(SeekFrom::Current(1))?;
+    Ok(())
+}
+
+fn main() {}
diff --git a/tests/ui/seek_from_current.stderr b/tests/ui/seek_from_current.stderr
new file mode 100644
index 00000000000..db1125b53cd
--- /dev/null
+++ b/tests/ui/seek_from_current.stderr
@@ -0,0 +1,10 @@
+error: using `SeekFrom::Current` to start from current position
+  --> $DIR/seek_from_current.rs:21:5
+   |
+LL |     f.seek(SeekFrom::Current(0))?;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `f.stream_position()`
+   |
+   = note: `-D clippy::seek-from-current` implied by `-D warnings`
+
+error: aborting due to previous error
+
-- 
cgit 1.4.1-3-g733a5


From bd8369089c38c190533b41ce76b073f5478f17d4 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Tue, 25 Oct 2022 11:32:49 +0000
Subject: Track `clippy.toml` and `Cargo.toml` in `file_depinfo`

Causes cargo to re-run clippy when those paths are modified

Also tracks the path to `clippy-driver` in debug mode to remove the
workarounds in `cargo dev lint` and `lintcheck`
---
 clippy_dev/Cargo.toml          |  1 -
 clippy_dev/src/lint.rs         |  8 --------
 clippy_lints/src/lib.rs        | 11 +++++++----
 clippy_lints/src/utils/conf.rs |  4 ++++
 lintcheck/src/main.rs          | 45 ------------------------------------------
 src/driver.rs                  | 37 +++++++++++++++++++++++++++++++++-
 6 files changed, 47 insertions(+), 59 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_dev/Cargo.toml b/clippy_dev/Cargo.toml
index 2ac3b4fe2ed..510c7e852af 100644
--- a/clippy_dev/Cargo.toml
+++ b/clippy_dev/Cargo.toml
@@ -10,7 +10,6 @@ indoc = "1.0"
 itertools = "0.10.1"
 opener = "0.5"
 shell-escape = "0.1"
-tempfile = "3.2"
 walkdir = "2.3"
 
 [features]
diff --git a/clippy_dev/src/lint.rs b/clippy_dev/src/lint.rs
index 71005449b4d..aafd0f71a59 100644
--- a/clippy_dev/src/lint.rs
+++ b/clippy_dev/src/lint.rs
@@ -36,20 +36,12 @@ pub fn run<'a>(path: &str, args: impl Iterator<Item = &'a String>) {
     } else {
         exit_if_err(Command::new("cargo").arg("build").status());
 
-        // Run in a tempdir as changes to clippy do not retrigger linting
-        let target = tempfile::Builder::new()
-            .prefix("clippy")
-            .tempdir()
-            .expect("failed to create tempdir");
-
         let status = Command::new(cargo_clippy_path())
             .arg("clippy")
             .args(args)
             .current_dir(path)
-            .env("CARGO_TARGET_DIR", target.as_ref())
             .status();
 
-        target.close().expect("failed to remove tempdir");
         exit_if_err(status);
     }
 }
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 7837e04bca1..85a28d1fd9e 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -49,6 +49,9 @@ extern crate clippy_utils;
 #[macro_use]
 extern crate declare_clippy_lint;
 
+use std::io;
+use std::path::PathBuf;
+
 use clippy_utils::parse_msrv;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_lint::{Lint, LintId};
@@ -303,8 +306,8 @@ mod zero_div_zero;
 mod zero_sized_map_values;
 // end lints modules, do not remove this comment, it’s used in `update_lints`
 
-pub use crate::utils::conf::Conf;
 use crate::utils::conf::{format_error, TryConf};
+pub use crate::utils::conf::{lookup_conf_file, Conf};
 
 /// Register all pre expansion lints
 ///
@@ -361,8 +364,8 @@ fn read_msrv(conf: &Conf, sess: &Session) -> Option<RustcVersion> {
 }
 
 #[doc(hidden)]
-pub fn read_conf(sess: &Session) -> Conf {
-    let file_name = match utils::conf::lookup_conf_file() {
+pub fn read_conf(sess: &Session, path: &io::Result<Option<PathBuf>>) -> Conf {
+    let file_name = match path {
         Ok(Some(path)) => path,
         Ok(None) => return Conf::default(),
         Err(error) => {
@@ -372,7 +375,7 @@ pub fn read_conf(sess: &Session) -> Conf {
         },
     };
 
-    let TryConf { conf, errors, warnings } = utils::conf::read(&file_name);
+    let TryConf { conf, errors, warnings } = utils::conf::read(file_name);
     // all conf errors are non-fatal, we just use the default conf in case of error
     for error in errors {
         sess.err(format!(
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index a10de31556c..65788f51a26 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -390,6 +390,10 @@ define_Conf! {
 }
 
 /// Search for the configuration file.
+///
+/// # Errors
+///
+/// Returns any unexpected filesystem error encountered when searching for the config file
 pub fn lookup_conf_file() -> io::Result<Option<PathBuf>> {
     /// Possible filename to search for.
     const CONFIG_FILE_NAMES: [&str; 2] = [".clippy.toml", "clippy.toml"];
diff --git a/lintcheck/src/main.rs b/lintcheck/src/main.rs
index 8385a4744ca..ee8ab7c1d7c 100644
--- a/lintcheck/src/main.rs
+++ b/lintcheck/src/main.rs
@@ -544,34 +544,6 @@ fn gather_stats(clippy_warnings: &[ClippyWarning]) -> (String, HashMap<&String,
     (stats_string, counter)
 }
 
-/// check if the latest modification of the logfile is older than the modification date of the
-/// clippy binary, if this is true, we should clean the lintchec shared target directory and recheck
-fn lintcheck_needs_rerun(lintcheck_logs_path: &Path, paths: [&Path; 2]) -> bool {
-    if !lintcheck_logs_path.exists() {
-        return true;
-    }
-
-    let clippy_modified: std::time::SystemTime = {
-        let [cargo, driver] = paths.map(|p| {
-            std::fs::metadata(p)
-                .expect("failed to get metadata of file")
-                .modified()
-                .expect("failed to get modification date")
-        });
-        // the oldest modification of either of the binaries
-        std::cmp::max(cargo, driver)
-    };
-
-    let logs_modified: std::time::SystemTime = std::fs::metadata(lintcheck_logs_path)
-        .expect("failed to get metadata of file")
-        .modified()
-        .expect("failed to get modification date");
-
-    // time is represented in seconds since X
-    // logs_modified 2 and clippy_modified 5 means clippy binary is older and we need to recheck
-    logs_modified < clippy_modified
-}
-
 #[allow(clippy::too_many_lines)]
 fn main() {
     // We're being executed as a `RUSTC_WRAPPER` as part of `--recursive`
@@ -594,23 +566,6 @@ fn main() {
     let cargo_clippy_path = fs::canonicalize(format!("target/debug/cargo-clippy{EXE_SUFFIX}")).unwrap();
     let clippy_driver_path = fs::canonicalize(format!("target/debug/clippy-driver{EXE_SUFFIX}")).unwrap();
 
-    // if the clippy bin is newer than our logs, throw away target dirs to force clippy to
-    // refresh the logs
-    if lintcheck_needs_rerun(
-        &config.lintcheck_results_path,
-        [&cargo_clippy_path, &clippy_driver_path],
-    ) {
-        let shared_target_dir = "target/lintcheck/shared_target_dir";
-        // if we get an Err here, the shared target dir probably does simply not exist
-        if let Ok(metadata) = std::fs::metadata(shared_target_dir) {
-            if metadata.is_dir() {
-                println!("Clippy is newer than lint check logs, clearing lintcheck shared target dir...");
-                std::fs::remove_dir_all(shared_target_dir)
-                    .expect("failed to remove target/lintcheck/shared_target_dir");
-            }
-        }
-    }
-
     // assert that clippy is found
     assert!(
         cargo_clippy_path.is_file(),
diff --git a/src/driver.rs b/src/driver.rs
index b12208ac62a..2601cab8c85 100644
--- a/src/driver.rs
+++ b/src/driver.rs
@@ -1,4 +1,5 @@
 #![feature(rustc_private)]
+#![feature(let_chains)]
 #![feature(once_cell)]
 #![cfg_attr(feature = "deny-warnings", deny(warnings))]
 // warn on lints, that are included in `rust-lang/rust`s bootstrap
@@ -71,6 +72,32 @@ fn track_clippy_args(parse_sess: &mut ParseSess, args_env_var: &Option<String>)
     ));
 }
 
+/// Track files that may be accessed at runtime in `file_depinfo` so that cargo will re-run clippy
+/// when any of them are modified
+fn track_files(parse_sess: &mut ParseSess, conf_path_string: Option<String>) {
+    let file_depinfo = parse_sess.file_depinfo.get_mut();
+
+    // Used by `clippy::cargo` lints and to determine the MSRV. `cargo clippy` executes `clippy-driver`
+    // with the current directory set to `CARGO_MANIFEST_DIR` so a relative path is fine
+    if Path::new("Cargo.toml").exists() {
+        file_depinfo.insert(Symbol::intern("Cargo.toml"));
+    }
+
+    // `clippy.toml`
+    if let Some(path) = conf_path_string {
+        file_depinfo.insert(Symbol::intern(&path));
+    }
+
+    // During development track the `clippy-driver` executable so that cargo will re-run clippy whenever
+    // it is rebuilt
+    if cfg!(debug_assertions)
+        && let Ok(current_exe) = env::current_exe()
+        && let Some(current_exe) = current_exe.to_str()
+    {
+        file_depinfo.insert(Symbol::intern(current_exe));
+    }
+}
+
 struct DefaultCallbacks;
 impl rustc_driver::Callbacks for DefaultCallbacks {}
 
@@ -97,10 +124,18 @@ impl rustc_driver::Callbacks for ClippyCallbacks {
     // JUSTIFICATION: necessary in clippy driver to set `mir_opt_level`
     #[allow(rustc::bad_opt_access)]
     fn config(&mut self, config: &mut interface::Config) {
+        let conf_path = clippy_lints::lookup_conf_file();
+        let conf_path_string = if let Ok(Some(path)) = &conf_path {
+            path.to_str().map(String::from)
+        } else {
+            None
+        };
+
         let previous = config.register_lints.take();
         let clippy_args_var = self.clippy_args_var.take();
         config.parse_sess_created = Some(Box::new(move |parse_sess| {
             track_clippy_args(parse_sess, &clippy_args_var);
+            track_files(parse_sess, conf_path_string);
         }));
         config.register_lints = Some(Box::new(move |sess, lint_store| {
             // technically we're ~guaranteed that this is none but might as well call anything that
@@ -109,7 +144,7 @@ impl rustc_driver::Callbacks for ClippyCallbacks {
                 (previous)(sess, lint_store);
             }
 
-            let conf = clippy_lints::read_conf(sess);
+            let conf = clippy_lints::read_conf(sess, &conf_path);
             clippy_lints::register_plugins(lint_store, sess, &conf);
             clippy_lints::register_pre_expansion_lints(lint_store, sess, &conf);
             clippy_lints::register_renamed(lint_store);
-- 
cgit 1.4.1-3-g733a5


From 32ded577797fe4a3691e751ecf59b74c6160c47c Mon Sep 17 00:00:00 2001
From: Alex <blyxyas@gmail.com>
Date: Fri, 21 Oct 2022 19:46:47 +0200
Subject: Just lint changes

---
 CHANGELOG.md                                   |   1 +
 clippy_lints/src/lib.register_lints.rs         | 621 +++++++++++++++++++++++++
 clippy_lints/src/lib.register_restriction.rs   |  91 ++++
 clippy_lints/src/lib.rs                        |   2 +
 clippy_lints/src/suspicious_xor_used_as_pow.rs |  53 +++
 src/docs.rs                                    | 607 ++++++++++++++++++++++++
 src/docs/suspicious_xor_used_as_pow.txt        |  12 +
 tests/ui/eq_op.rs                              |   1 +
 tests/ui/eq_op.stderr                          |  56 +--
 tests/ui/suspicious_xor_used_as_pow.rs         |  34 ++
 tests/ui/suspicious_xor_used_as_pow.stderr     |  51 ++
 11 files changed, 1501 insertions(+), 28 deletions(-)
 create mode 100644 clippy_lints/src/lib.register_lints.rs
 create mode 100644 clippy_lints/src/lib.register_restriction.rs
 create mode 100644 clippy_lints/src/suspicious_xor_used_as_pow.rs
 create mode 100644 src/docs.rs
 create mode 100644 src/docs/suspicious_xor_used_as_pow.txt
 create mode 100644 tests/ui/suspicious_xor_used_as_pow.rs
 create mode 100644 tests/ui/suspicious_xor_used_as_pow.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 7e91365c69a..10111be596a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4250,6 +4250,7 @@ Released 2018-09-13
 [`suspicious_splitn`]: https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_splitn
 [`suspicious_to_owned`]: https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_to_owned
 [`suspicious_unary_op_formatting`]: https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_unary_op_formatting
+[`suspicious_xor_used_as_pow`]: https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_xor_used_as_pow
 [`swap_ptr_to_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#swap_ptr_to_ref
 [`tabs_in_doc_comments`]: https://rust-lang.github.io/rust-clippy/master/index.html#tabs_in_doc_comments
 [`temporary_assignment`]: https://rust-lang.github.io/rust-clippy/master/index.html#temporary_assignment
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
new file mode 100644
index 00000000000..3d4e05b335d
--- /dev/null
+++ b/clippy_lints/src/lib.register_lints.rs
@@ -0,0 +1,621 @@
+// This file was generated by `cargo dev update_lints`.
+// Use that command to update this file and do not edit by hand.
+// Manual edits will be overwritten.
+
+store.register_lints(&[
+    #[cfg(feature = "internal")]
+    utils::internal_lints::clippy_lints_internal::CLIPPY_LINTS_INTERNAL,
+    #[cfg(feature = "internal")]
+    utils::internal_lints::collapsible_calls::COLLAPSIBLE_SPAN_LINT_CALLS,
+    #[cfg(feature = "internal")]
+    utils::internal_lints::compiler_lint_functions::COMPILER_LINT_FUNCTIONS,
+    #[cfg(feature = "internal")]
+    utils::internal_lints::if_chain_style::IF_CHAIN_STYLE,
+    #[cfg(feature = "internal")]
+    utils::internal_lints::interning_defined_symbol::INTERNING_DEFINED_SYMBOL,
+    #[cfg(feature = "internal")]
+    utils::internal_lints::interning_defined_symbol::UNNECESSARY_SYMBOL_STR,
+    #[cfg(feature = "internal")]
+    utils::internal_lints::invalid_paths::INVALID_PATHS,
+    #[cfg(feature = "internal")]
+    utils::internal_lints::lint_without_lint_pass::DEFAULT_DEPRECATION_REASON,
+    #[cfg(feature = "internal")]
+    utils::internal_lints::lint_without_lint_pass::DEFAULT_LINT,
+    #[cfg(feature = "internal")]
+    utils::internal_lints::lint_without_lint_pass::INVALID_CLIPPY_VERSION_ATTRIBUTE,
+    #[cfg(feature = "internal")]
+    utils::internal_lints::lint_without_lint_pass::LINT_WITHOUT_LINT_PASS,
+    #[cfg(feature = "internal")]
+    utils::internal_lints::lint_without_lint_pass::MISSING_CLIPPY_VERSION_ATTRIBUTE,
+    #[cfg(feature = "internal")]
+    utils::internal_lints::msrv_attr_impl::MISSING_MSRV_ATTR_IMPL,
+    #[cfg(feature = "internal")]
+    utils::internal_lints::outer_expn_data_pass::OUTER_EXPN_EXPN_DATA,
+    #[cfg(feature = "internal")]
+    utils::internal_lints::produce_ice::PRODUCE_ICE,
+    #[cfg(feature = "internal")]
+    utils::internal_lints::unnecessary_def_path::UNNECESSARY_DEF_PATH,
+    almost_complete_letter_range::ALMOST_COMPLETE_LETTER_RANGE,
+    approx_const::APPROX_CONSTANT,
+    as_conversions::AS_CONVERSIONS,
+    asm_syntax::INLINE_ASM_X86_ATT_SYNTAX,
+    asm_syntax::INLINE_ASM_X86_INTEL_SYNTAX,
+    assertions_on_constants::ASSERTIONS_ON_CONSTANTS,
+    assertions_on_result_states::ASSERTIONS_ON_RESULT_STATES,
+    async_yields_async::ASYNC_YIELDS_ASYNC,
+    attrs::ALLOW_ATTRIBUTES_WITHOUT_REASON,
+    attrs::BLANKET_CLIPPY_RESTRICTION_LINTS,
+    attrs::DEPRECATED_CFG_ATTR,
+    attrs::DEPRECATED_SEMVER,
+    attrs::EMPTY_LINE_AFTER_OUTER_ATTR,
+    attrs::INLINE_ALWAYS,
+    attrs::MISMATCHED_TARGET_OS,
+    attrs::USELESS_ATTRIBUTE,
+    await_holding_invalid::AWAIT_HOLDING_INVALID_TYPE,
+    await_holding_invalid::AWAIT_HOLDING_LOCK,
+    await_holding_invalid::AWAIT_HOLDING_REFCELL_REF,
+    blocks_in_if_conditions::BLOCKS_IN_IF_CONDITIONS,
+    bool_assert_comparison::BOOL_ASSERT_COMPARISON,
+    bool_to_int_with_if::BOOL_TO_INT_WITH_IF,
+    booleans::NONMINIMAL_BOOL,
+    booleans::OVERLY_COMPLEX_BOOL_EXPR,
+    borrow_deref_ref::BORROW_DEREF_REF,
+    box_default::BOX_DEFAULT,
+    cargo::CARGO_COMMON_METADATA,
+    cargo::MULTIPLE_CRATE_VERSIONS,
+    cargo::NEGATIVE_FEATURE_NAMES,
+    cargo::REDUNDANT_FEATURE_NAMES,
+    cargo::WILDCARD_DEPENDENCIES,
+    casts::AS_PTR_CAST_MUT,
+    casts::AS_UNDERSCORE,
+    casts::BORROW_AS_PTR,
+    casts::CAST_ABS_TO_UNSIGNED,
+    casts::CAST_ENUM_CONSTRUCTOR,
+    casts::CAST_ENUM_TRUNCATION,
+    casts::CAST_LOSSLESS,
+    casts::CAST_NAN_TO_INT,
+    casts::CAST_POSSIBLE_TRUNCATION,
+    casts::CAST_POSSIBLE_WRAP,
+    casts::CAST_PRECISION_LOSS,
+    casts::CAST_PTR_ALIGNMENT,
+    casts::CAST_REF_TO_MUT,
+    casts::CAST_SIGN_LOSS,
+    casts::CAST_SLICE_DIFFERENT_SIZES,
+    casts::CAST_SLICE_FROM_RAW_PARTS,
+    casts::CHAR_LIT_AS_U8,
+    casts::FN_TO_NUMERIC_CAST,
+    casts::FN_TO_NUMERIC_CAST_ANY,
+    casts::FN_TO_NUMERIC_CAST_WITH_TRUNCATION,
+    casts::PTR_AS_PTR,
+    casts::UNNECESSARY_CAST,
+    checked_conversions::CHECKED_CONVERSIONS,
+    cognitive_complexity::COGNITIVE_COMPLEXITY,
+    collapsible_if::COLLAPSIBLE_ELSE_IF,
+    collapsible_if::COLLAPSIBLE_IF,
+    comparison_chain::COMPARISON_CHAIN,
+    copies::BRANCHES_SHARING_CODE,
+    copies::IFS_SAME_COND,
+    copies::IF_SAME_THEN_ELSE,
+    copies::SAME_FUNCTIONS_IN_IF_CONDITION,
+    copy_iterator::COPY_ITERATOR,
+    crate_in_macro_def::CRATE_IN_MACRO_DEF,
+    create_dir::CREATE_DIR,
+    dbg_macro::DBG_MACRO,
+    default::DEFAULT_TRAIT_ACCESS,
+    default::FIELD_REASSIGN_WITH_DEFAULT,
+    default_instead_of_iter_empty::DEFAULT_INSTEAD_OF_ITER_EMPTY,
+    default_numeric_fallback::DEFAULT_NUMERIC_FALLBACK,
+    default_union_representation::DEFAULT_UNION_REPRESENTATION,
+    dereference::EXPLICIT_AUTO_DEREF,
+    dereference::EXPLICIT_DEREF_METHODS,
+    dereference::NEEDLESS_BORROW,
+    dereference::REF_BINDING_TO_REFERENCE,
+    derivable_impls::DERIVABLE_IMPLS,
+    derive::DERIVE_HASH_XOR_EQ,
+    derive::DERIVE_ORD_XOR_PARTIAL_ORD,
+    derive::DERIVE_PARTIAL_EQ_WITHOUT_EQ,
+    derive::EXPL_IMPL_CLONE_ON_COPY,
+    derive::UNSAFE_DERIVE_DESERIALIZE,
+    disallowed_macros::DISALLOWED_MACROS,
+    disallowed_methods::DISALLOWED_METHODS,
+    disallowed_names::DISALLOWED_NAMES,
+    disallowed_script_idents::DISALLOWED_SCRIPT_IDENTS,
+    disallowed_types::DISALLOWED_TYPES,
+    doc::DOC_LINK_WITH_QUOTES,
+    doc::DOC_MARKDOWN,
+    doc::MISSING_ERRORS_DOC,
+    doc::MISSING_PANICS_DOC,
+    doc::MISSING_SAFETY_DOC,
+    doc::NEEDLESS_DOCTEST_MAIN,
+    double_parens::DOUBLE_PARENS,
+    drop_forget_ref::DROP_COPY,
+    drop_forget_ref::DROP_NON_DROP,
+    drop_forget_ref::DROP_REF,
+    drop_forget_ref::FORGET_COPY,
+    drop_forget_ref::FORGET_NON_DROP,
+    drop_forget_ref::FORGET_REF,
+    drop_forget_ref::UNDROPPED_MANUALLY_DROPS,
+    duplicate_mod::DUPLICATE_MOD,
+    else_if_without_else::ELSE_IF_WITHOUT_ELSE,
+    empty_drop::EMPTY_DROP,
+    empty_enum::EMPTY_ENUM,
+    empty_structs_with_brackets::EMPTY_STRUCTS_WITH_BRACKETS,
+    entry::MAP_ENTRY,
+    enum_clike::ENUM_CLIKE_UNPORTABLE_VARIANT,
+    enum_variants::ENUM_VARIANT_NAMES,
+    enum_variants::MODULE_INCEPTION,
+    enum_variants::MODULE_NAME_REPETITIONS,
+    equatable_if_let::EQUATABLE_IF_LET,
+    escape::BOXED_LOCAL,
+    eta_reduction::REDUNDANT_CLOSURE,
+    eta_reduction::REDUNDANT_CLOSURE_FOR_METHOD_CALLS,
+    excessive_bools::FN_PARAMS_EXCESSIVE_BOOLS,
+    excessive_bools::STRUCT_EXCESSIVE_BOOLS,
+    exhaustive_items::EXHAUSTIVE_ENUMS,
+    exhaustive_items::EXHAUSTIVE_STRUCTS,
+    exit::EXIT,
+    explicit_write::EXPLICIT_WRITE,
+    fallible_impl_from::FALLIBLE_IMPL_FROM,
+    float_literal::EXCESSIVE_PRECISION,
+    float_literal::LOSSY_FLOAT_LITERAL,
+    floating_point_arithmetic::IMPRECISE_FLOPS,
+    floating_point_arithmetic::SUBOPTIMAL_FLOPS,
+    format::USELESS_FORMAT,
+    format_args::FORMAT_IN_FORMAT_ARGS,
+    format_args::TO_STRING_IN_FORMAT_ARGS,
+    format_args::UNINLINED_FORMAT_ARGS,
+    format_args::UNUSED_FORMAT_SPECS,
+    format_impl::PRINT_IN_FORMAT_IMPL,
+    format_impl::RECURSIVE_FORMAT_IMPL,
+    format_push_string::FORMAT_PUSH_STRING,
+    formatting::POSSIBLE_MISSING_COMMA,
+    formatting::SUSPICIOUS_ASSIGNMENT_FORMATTING,
+    formatting::SUSPICIOUS_ELSE_FORMATTING,
+    formatting::SUSPICIOUS_UNARY_OP_FORMATTING,
+    from_over_into::FROM_OVER_INTO,
+    from_str_radix_10::FROM_STR_RADIX_10,
+    functions::DOUBLE_MUST_USE,
+    functions::MUST_USE_CANDIDATE,
+    functions::MUST_USE_UNIT,
+    functions::NOT_UNSAFE_PTR_ARG_DEREF,
+    functions::RESULT_LARGE_ERR,
+    functions::RESULT_UNIT_ERR,
+    functions::TOO_MANY_ARGUMENTS,
+    functions::TOO_MANY_LINES,
+    future_not_send::FUTURE_NOT_SEND,
+    if_let_mutex::IF_LET_MUTEX,
+    if_not_else::IF_NOT_ELSE,
+    if_then_some_else_none::IF_THEN_SOME_ELSE_NONE,
+    implicit_hasher::IMPLICIT_HASHER,
+    implicit_return::IMPLICIT_RETURN,
+    implicit_saturating_add::IMPLICIT_SATURATING_ADD,
+    implicit_saturating_sub::IMPLICIT_SATURATING_SUB,
+    inconsistent_struct_constructor::INCONSISTENT_STRUCT_CONSTRUCTOR,
+    index_refutable_slice::INDEX_REFUTABLE_SLICE,
+    indexing_slicing::INDEXING_SLICING,
+    indexing_slicing::OUT_OF_BOUNDS_INDEXING,
+    infinite_iter::INFINITE_ITER,
+    infinite_iter::MAYBE_INFINITE_ITER,
+    inherent_impl::MULTIPLE_INHERENT_IMPL,
+    inherent_to_string::INHERENT_TO_STRING,
+    inherent_to_string::INHERENT_TO_STRING_SHADOW_DISPLAY,
+    init_numbered_fields::INIT_NUMBERED_FIELDS,
+    inline_fn_without_body::INLINE_FN_WITHOUT_BODY,
+    int_plus_one::INT_PLUS_ONE,
+    invalid_upcast_comparisons::INVALID_UPCAST_COMPARISONS,
+    invalid_utf8_in_unchecked::INVALID_UTF8_IN_UNCHECKED,
+    items_after_statements::ITEMS_AFTER_STATEMENTS,
+    iter_not_returning_iterator::ITER_NOT_RETURNING_ITERATOR,
+    large_const_arrays::LARGE_CONST_ARRAYS,
+    large_enum_variant::LARGE_ENUM_VARIANT,
+    large_include_file::LARGE_INCLUDE_FILE,
+    large_stack_arrays::LARGE_STACK_ARRAYS,
+    len_zero::COMPARISON_TO_EMPTY,
+    len_zero::LEN_WITHOUT_IS_EMPTY,
+    len_zero::LEN_ZERO,
+    let_if_seq::USELESS_LET_IF_SEQ,
+    let_underscore::LET_UNDERSCORE_DROP,
+    let_underscore::LET_UNDERSCORE_LOCK,
+    let_underscore::LET_UNDERSCORE_MUST_USE,
+    lifetimes::EXTRA_UNUSED_LIFETIMES,
+    lifetimes::NEEDLESS_LIFETIMES,
+    literal_representation::DECIMAL_LITERAL_REPRESENTATION,
+    literal_representation::INCONSISTENT_DIGIT_GROUPING,
+    literal_representation::LARGE_DIGIT_GROUPS,
+    literal_representation::MISTYPED_LITERAL_SUFFIXES,
+    literal_representation::UNREADABLE_LITERAL,
+    literal_representation::UNUSUAL_BYTE_GROUPINGS,
+    loops::EMPTY_LOOP,
+    loops::EXPLICIT_COUNTER_LOOP,
+    loops::EXPLICIT_INTO_ITER_LOOP,
+    loops::EXPLICIT_ITER_LOOP,
+    loops::FOR_KV_MAP,
+    loops::ITER_NEXT_LOOP,
+    loops::MANUAL_FIND,
+    loops::MANUAL_FLATTEN,
+    loops::MANUAL_MEMCPY,
+    loops::MISSING_SPIN_LOOP,
+    loops::MUT_RANGE_BOUND,
+    loops::NEEDLESS_COLLECT,
+    loops::NEEDLESS_RANGE_LOOP,
+    loops::NEVER_LOOP,
+    loops::SAME_ITEM_PUSH,
+    loops::SINGLE_ELEMENT_LOOP,
+    loops::WHILE_IMMUTABLE_CONDITION,
+    loops::WHILE_LET_LOOP,
+    loops::WHILE_LET_ON_ITERATOR,
+    macro_use::MACRO_USE_IMPORTS,
+    main_recursion::MAIN_RECURSION,
+    manual_assert::MANUAL_ASSERT,
+    manual_async_fn::MANUAL_ASYNC_FN,
+    manual_bits::MANUAL_BITS,
+    manual_clamp::MANUAL_CLAMP,
+    manual_instant_elapsed::MANUAL_INSTANT_ELAPSED,
+    manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE,
+    manual_rem_euclid::MANUAL_REM_EUCLID,
+    manual_retain::MANUAL_RETAIN,
+    manual_string_new::MANUAL_STRING_NEW,
+    manual_strip::MANUAL_STRIP,
+    map_unit_fn::OPTION_MAP_UNIT_FN,
+    map_unit_fn::RESULT_MAP_UNIT_FN,
+    match_result_ok::MATCH_RESULT_OK,
+    matches::COLLAPSIBLE_MATCH,
+    matches::INFALLIBLE_DESTRUCTURING_MATCH,
+    matches::MANUAL_FILTER,
+    matches::MANUAL_MAP,
+    matches::MANUAL_UNWRAP_OR,
+    matches::MATCH_AS_REF,
+    matches::MATCH_BOOL,
+    matches::MATCH_LIKE_MATCHES_MACRO,
+    matches::MATCH_ON_VEC_ITEMS,
+    matches::MATCH_OVERLAPPING_ARM,
+    matches::MATCH_REF_PATS,
+    matches::MATCH_SAME_ARMS,
+    matches::MATCH_SINGLE_BINDING,
+    matches::MATCH_STR_CASE_MISMATCH,
+    matches::MATCH_WILDCARD_FOR_SINGLE_VARIANTS,
+    matches::MATCH_WILD_ERR_ARM,
+    matches::NEEDLESS_MATCH,
+    matches::REDUNDANT_PATTERN_MATCHING,
+    matches::REST_PAT_IN_FULLY_BOUND_STRUCTS,
+    matches::SIGNIFICANT_DROP_IN_SCRUTINEE,
+    matches::SINGLE_MATCH,
+    matches::SINGLE_MATCH_ELSE,
+    matches::TRY_ERR,
+    matches::WILDCARD_ENUM_MATCH_ARM,
+    matches::WILDCARD_IN_OR_PATTERNS,
+    mem_forget::MEM_FORGET,
+    mem_replace::MEM_REPLACE_OPTION_WITH_NONE,
+    mem_replace::MEM_REPLACE_WITH_DEFAULT,
+    mem_replace::MEM_REPLACE_WITH_UNINIT,
+    methods::BIND_INSTEAD_OF_MAP,
+    methods::BYTES_COUNT_TO_LEN,
+    methods::BYTES_NTH,
+    methods::CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS,
+    methods::CHARS_LAST_CMP,
+    methods::CHARS_NEXT_CMP,
+    methods::CLONED_INSTEAD_OF_COPIED,
+    methods::CLONE_DOUBLE_REF,
+    methods::CLONE_ON_COPY,
+    methods::CLONE_ON_REF_PTR,
+    methods::COLLAPSIBLE_STR_REPLACE,
+    methods::ERR_EXPECT,
+    methods::EXPECT_FUN_CALL,
+    methods::EXPECT_USED,
+    methods::EXTEND_WITH_DRAIN,
+    methods::FILETYPE_IS_FILE,
+    methods::FILTER_MAP_IDENTITY,
+    methods::FILTER_MAP_NEXT,
+    methods::FILTER_NEXT,
+    methods::FLAT_MAP_IDENTITY,
+    methods::FLAT_MAP_OPTION,
+    methods::FROM_ITER_INSTEAD_OF_COLLECT,
+    methods::GET_FIRST,
+    methods::GET_LAST_WITH_LEN,
+    methods::GET_UNWRAP,
+    methods::IMPLICIT_CLONE,
+    methods::INEFFICIENT_TO_STRING,
+    methods::INSPECT_FOR_EACH,
+    methods::INTO_ITER_ON_REF,
+    methods::IS_DIGIT_ASCII_RADIX,
+    methods::ITERATOR_STEP_BY_ZERO,
+    methods::ITER_CLONED_COLLECT,
+    methods::ITER_COUNT,
+    methods::ITER_KV_MAP,
+    methods::ITER_NEXT_SLICE,
+    methods::ITER_NTH,
+    methods::ITER_NTH_ZERO,
+    methods::ITER_ON_EMPTY_COLLECTIONS,
+    methods::ITER_ON_SINGLE_ITEMS,
+    methods::ITER_OVEREAGER_CLONED,
+    methods::ITER_SKIP_NEXT,
+    methods::ITER_WITH_DRAIN,
+    methods::MANUAL_FILTER_MAP,
+    methods::MANUAL_FIND_MAP,
+    methods::MANUAL_OK_OR,
+    methods::MANUAL_SATURATING_ARITHMETIC,
+    methods::MANUAL_SPLIT_ONCE,
+    methods::MANUAL_STR_REPEAT,
+    methods::MAP_CLONE,
+    methods::MAP_COLLECT_RESULT_UNIT,
+    methods::MAP_ERR_IGNORE,
+    methods::MAP_FLATTEN,
+    methods::MAP_IDENTITY,
+    methods::MAP_UNWRAP_OR,
+    methods::MUT_MUTEX_LOCK,
+    methods::NAIVE_BYTECOUNT,
+    methods::NEEDLESS_OPTION_AS_DEREF,
+    methods::NEEDLESS_OPTION_TAKE,
+    methods::NEEDLESS_SPLITN,
+    methods::NEW_RET_NO_SELF,
+    methods::NONSENSICAL_OPEN_OPTIONS,
+    methods::NO_EFFECT_REPLACE,
+    methods::OBFUSCATED_IF_ELSE,
+    methods::OK_EXPECT,
+    methods::OPTION_AS_REF_DEREF,
+    methods::OPTION_FILTER_MAP,
+    methods::OPTION_MAP_OR_NONE,
+    methods::OR_FUN_CALL,
+    methods::OR_THEN_UNWRAP,
+    methods::PATH_BUF_PUSH_OVERWRITE,
+    methods::RANGE_ZIP_WITH_LEN,
+    methods::REPEAT_ONCE,
+    methods::RESULT_MAP_OR_INTO_OPTION,
+    methods::SEARCH_IS_SOME,
+    methods::SHOULD_IMPLEMENT_TRAIT,
+    methods::SINGLE_CHAR_ADD_STR,
+    methods::SINGLE_CHAR_PATTERN,
+    methods::SKIP_WHILE_NEXT,
+    methods::STABLE_SORT_PRIMITIVE,
+    methods::STRING_EXTEND_CHARS,
+    methods::SUSPICIOUS_MAP,
+    methods::SUSPICIOUS_SPLITN,
+    methods::SUSPICIOUS_TO_OWNED,
+    methods::UNINIT_ASSUMED_INIT,
+    methods::UNIT_HASH,
+    methods::UNNECESSARY_FILTER_MAP,
+    methods::UNNECESSARY_FIND_MAP,
+    methods::UNNECESSARY_FOLD,
+    methods::UNNECESSARY_JOIN,
+    methods::UNNECESSARY_LAZY_EVALUATIONS,
+    methods::UNNECESSARY_SORT_BY,
+    methods::UNNECESSARY_TO_OWNED,
+    methods::UNWRAP_OR_ELSE_DEFAULT,
+    methods::UNWRAP_USED,
+    methods::USELESS_ASREF,
+    methods::VEC_RESIZE_TO_ZERO,
+    methods::VERBOSE_FILE_READS,
+    methods::WRONG_SELF_CONVENTION,
+    methods::ZST_OFFSET,
+    minmax::MIN_MAX,
+    misc::SHORT_CIRCUIT_STATEMENT,
+    misc::TOPLEVEL_REF_ARG,
+    misc::USED_UNDERSCORE_BINDING,
+    misc::ZERO_PTR,
+    misc_early::BUILTIN_TYPE_SHADOW,
+    misc_early::DOUBLE_NEG,
+    misc_early::DUPLICATE_UNDERSCORE_ARGUMENT,
+    misc_early::MIXED_CASE_HEX_LITERALS,
+    misc_early::REDUNDANT_PATTERN,
+    misc_early::SEPARATED_LITERAL_SUFFIX,
+    misc_early::UNNEEDED_FIELD_PATTERN,
+    misc_early::UNNEEDED_WILDCARD_PATTERN,
+    misc_early::UNSEPARATED_LITERAL_SUFFIX,
+    misc_early::ZERO_PREFIXED_LITERAL,
+    mismatching_type_param_order::MISMATCHING_TYPE_PARAM_ORDER,
+    missing_const_for_fn::MISSING_CONST_FOR_FN,
+    missing_doc::MISSING_DOCS_IN_PRIVATE_ITEMS,
+    missing_enforced_import_rename::MISSING_ENFORCED_IMPORT_RENAMES,
+    missing_inline::MISSING_INLINE_IN_PUBLIC_ITEMS,
+    missing_trait_methods::MISSING_TRAIT_METHODS,
+    mixed_read_write_in_expression::DIVERGING_SUB_EXPRESSION,
+    mixed_read_write_in_expression::MIXED_READ_WRITE_IN_EXPRESSION,
+    module_style::MOD_MODULE_FILES,
+    module_style::SELF_NAMED_MODULE_FILES,
+    multi_assignments::MULTI_ASSIGNMENTS,
+    mut_key::MUTABLE_KEY_TYPE,
+    mut_mut::MUT_MUT,
+    mut_reference::UNNECESSARY_MUT_PASSED,
+    mutable_debug_assertion::DEBUG_ASSERT_WITH_MUT_CALL,
+    mutex_atomic::MUTEX_ATOMIC,
+    mutex_atomic::MUTEX_INTEGER,
+    needless_arbitrary_self_type::NEEDLESS_ARBITRARY_SELF_TYPE,
+    needless_bool::BOOL_COMPARISON,
+    needless_bool::NEEDLESS_BOOL,
+    needless_borrowed_ref::NEEDLESS_BORROWED_REFERENCE,
+    needless_continue::NEEDLESS_CONTINUE,
+    needless_for_each::NEEDLESS_FOR_EACH,
+    needless_late_init::NEEDLESS_LATE_INIT,
+    needless_parens_on_range_literals::NEEDLESS_PARENS_ON_RANGE_LITERALS,
+    needless_pass_by_value::NEEDLESS_PASS_BY_VALUE,
+    needless_question_mark::NEEDLESS_QUESTION_MARK,
+    needless_update::NEEDLESS_UPDATE,
+    neg_cmp_op_on_partial_ord::NEG_CMP_OP_ON_PARTIAL_ORD,
+    neg_multiply::NEG_MULTIPLY,
+    new_without_default::NEW_WITHOUT_DEFAULT,
+    no_effect::NO_EFFECT,
+    no_effect::NO_EFFECT_UNDERSCORE_BINDING,
+    no_effect::UNNECESSARY_OPERATION,
+    non_copy_const::BORROW_INTERIOR_MUTABLE_CONST,
+    non_copy_const::DECLARE_INTERIOR_MUTABLE_CONST,
+    non_expressive_names::JUST_UNDERSCORES_AND_DIGITS,
+    non_expressive_names::MANY_SINGLE_CHAR_NAMES,
+    non_expressive_names::SIMILAR_NAMES,
+    non_octal_unix_permissions::NON_OCTAL_UNIX_PERMISSIONS,
+    non_send_fields_in_send_ty::NON_SEND_FIELDS_IN_SEND_TY,
+    nonstandard_macro_braces::NONSTANDARD_MACRO_BRACES,
+    octal_escapes::OCTAL_ESCAPES,
+    only_used_in_recursion::ONLY_USED_IN_RECURSION,
+    operators::ABSURD_EXTREME_COMPARISONS,
+    operators::ARITHMETIC_SIDE_EFFECTS,
+    operators::ASSIGN_OP_PATTERN,
+    operators::BAD_BIT_MASK,
+    operators::CMP_NAN,
+    operators::CMP_OWNED,
+    operators::DOUBLE_COMPARISONS,
+    operators::DURATION_SUBSEC,
+    operators::EQ_OP,
+    operators::ERASING_OP,
+    operators::FLOAT_ARITHMETIC,
+    operators::FLOAT_CMP,
+    operators::FLOAT_CMP_CONST,
+    operators::FLOAT_EQUALITY_WITHOUT_ABS,
+    operators::IDENTITY_OP,
+    operators::INEFFECTIVE_BIT_MASK,
+    operators::INTEGER_ARITHMETIC,
+    operators::INTEGER_DIVISION,
+    operators::MISREFACTORED_ASSIGN_OP,
+    operators::MODULO_ARITHMETIC,
+    operators::MODULO_ONE,
+    operators::NEEDLESS_BITWISE_BOOL,
+    operators::OP_REF,
+    operators::PTR_EQ,
+    operators::SELF_ASSIGNMENT,
+    operators::VERBOSE_BIT_MASK,
+    option_env_unwrap::OPTION_ENV_UNWRAP,
+    option_if_let_else::OPTION_IF_LET_ELSE,
+    overflow_check_conditional::OVERFLOW_CHECK_CONDITIONAL,
+    panic_in_result_fn::PANIC_IN_RESULT_FN,
+    panic_unimplemented::PANIC,
+    panic_unimplemented::TODO,
+    panic_unimplemented::UNIMPLEMENTED,
+    panic_unimplemented::UNREACHABLE,
+    partial_pub_fields::PARTIAL_PUB_FIELDS,
+    partialeq_ne_impl::PARTIALEQ_NE_IMPL,
+    partialeq_to_none::PARTIALEQ_TO_NONE,
+    pass_by_ref_or_value::LARGE_TYPES_PASSED_BY_VALUE,
+    pass_by_ref_or_value::TRIVIALLY_COPY_PASS_BY_REF,
+    pattern_type_mismatch::PATTERN_TYPE_MISMATCH,
+    precedence::PRECEDENCE,
+    ptr::CMP_NULL,
+    ptr::INVALID_NULL_PTR_USAGE,
+    ptr::MUT_FROM_REF,
+    ptr::PTR_ARG,
+    ptr_offset_with_cast::PTR_OFFSET_WITH_CAST,
+    pub_use::PUB_USE,
+    question_mark::QUESTION_MARK,
+    ranges::MANUAL_RANGE_CONTAINS,
+    ranges::RANGE_MINUS_ONE,
+    ranges::RANGE_PLUS_ONE,
+    ranges::REVERSED_EMPTY_RANGES,
+    rc_clone_in_vec_init::RC_CLONE_IN_VEC_INIT,
+    read_zero_byte_vec::READ_ZERO_BYTE_VEC,
+    redundant_clone::REDUNDANT_CLONE,
+    redundant_closure_call::REDUNDANT_CLOSURE_CALL,
+    redundant_else::REDUNDANT_ELSE,
+    redundant_field_names::REDUNDANT_FIELD_NAMES,
+    redundant_pub_crate::REDUNDANT_PUB_CRATE,
+    redundant_slicing::DEREF_BY_SLICING,
+    redundant_slicing::REDUNDANT_SLICING,
+    redundant_static_lifetimes::REDUNDANT_STATIC_LIFETIMES,
+    ref_option_ref::REF_OPTION_REF,
+    reference::DEREF_ADDROF,
+    regex::INVALID_REGEX,
+    regex::TRIVIAL_REGEX,
+    return_self_not_must_use::RETURN_SELF_NOT_MUST_USE,
+    returns::LET_AND_RETURN,
+    returns::NEEDLESS_RETURN,
+    same_name_method::SAME_NAME_METHOD,
+    self_named_constructors::SELF_NAMED_CONSTRUCTORS,
+    semicolon_if_nothing_returned::SEMICOLON_IF_NOTHING_RETURNED,
+    serde_api::SERDE_API_MISUSE,
+    shadow::SHADOW_REUSE,
+    shadow::SHADOW_SAME,
+    shadow::SHADOW_UNRELATED,
+    single_char_lifetime_names::SINGLE_CHAR_LIFETIME_NAMES,
+    single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS,
+    size_of_in_element_count::SIZE_OF_IN_ELEMENT_COUNT,
+    slow_vector_initialization::SLOW_VECTOR_INITIALIZATION,
+    std_instead_of_core::ALLOC_INSTEAD_OF_CORE,
+    std_instead_of_core::STD_INSTEAD_OF_ALLOC,
+    std_instead_of_core::STD_INSTEAD_OF_CORE,
+    strings::STRING_ADD,
+    strings::STRING_ADD_ASSIGN,
+    strings::STRING_FROM_UTF8_AS_BYTES,
+    strings::STRING_LIT_AS_BYTES,
+    strings::STRING_SLICE,
+    strings::STRING_TO_STRING,
+    strings::STR_TO_STRING,
+    strings::TRIM_SPLIT_WHITESPACE,
+    strlen_on_c_strings::STRLEN_ON_C_STRINGS,
+    suspicious_operation_groupings::SUSPICIOUS_OPERATION_GROUPINGS,
+    suspicious_trait_impl::SUSPICIOUS_ARITHMETIC_IMPL,
+    suspicious_trait_impl::SUSPICIOUS_OP_ASSIGN_IMPL,
+    suspicious_xor_used_as_pow::SUSPICIOUS_XOR_USED_AS_POW,
+    swap::ALMOST_SWAPPED,
+    swap::MANUAL_SWAP,
+    swap_ptr_to_ref::SWAP_PTR_TO_REF,
+    tabs_in_doc_comments::TABS_IN_DOC_COMMENTS,
+    temporary_assignment::TEMPORARY_ASSIGNMENT,
+    to_digit_is_some::TO_DIGIT_IS_SOME,
+    trailing_empty_array::TRAILING_EMPTY_ARRAY,
+    trait_bounds::TRAIT_DUPLICATION_IN_BOUNDS,
+    trait_bounds::TYPE_REPETITION_IN_BOUNDS,
+    transmute::CROSSPOINTER_TRANSMUTE,
+    transmute::TRANSMUTES_EXPRESSIBLE_AS_PTR_CASTS,
+    transmute::TRANSMUTE_BYTES_TO_STR,
+    transmute::TRANSMUTE_FLOAT_TO_INT,
+    transmute::TRANSMUTE_INT_TO_BOOL,
+    transmute::TRANSMUTE_INT_TO_CHAR,
+    transmute::TRANSMUTE_INT_TO_FLOAT,
+    transmute::TRANSMUTE_NUM_TO_BYTES,
+    transmute::TRANSMUTE_PTR_TO_PTR,
+    transmute::TRANSMUTE_PTR_TO_REF,
+    transmute::TRANSMUTE_UNDEFINED_REPR,
+    transmute::TRANSMUTING_NULL,
+    transmute::UNSOUND_COLLECTION_TRANSMUTE,
+    transmute::USELESS_TRANSMUTE,
+    transmute::WRONG_TRANSMUTE,
+    types::BORROWED_BOX,
+    types::BOX_COLLECTION,
+    types::LINKEDLIST,
+    types::OPTION_OPTION,
+    types::RC_BUFFER,
+    types::RC_MUTEX,
+    types::REDUNDANT_ALLOCATION,
+    types::TYPE_COMPLEXITY,
+    types::VEC_BOX,
+    undocumented_unsafe_blocks::UNDOCUMENTED_UNSAFE_BLOCKS,
+    unicode::INVISIBLE_CHARACTERS,
+    unicode::NON_ASCII_LITERAL,
+    unicode::UNICODE_NOT_NFC,
+    uninit_vec::UNINIT_VEC,
+    unit_return_expecting_ord::UNIT_RETURN_EXPECTING_ORD,
+    unit_types::LET_UNIT_VALUE,
+    unit_types::UNIT_ARG,
+    unit_types::UNIT_CMP,
+    unnamed_address::FN_ADDRESS_COMPARISONS,
+    unnamed_address::VTABLE_ADDRESS_COMPARISONS,
+    unnecessary_owned_empty_strings::UNNECESSARY_OWNED_EMPTY_STRINGS,
+    unnecessary_self_imports::UNNECESSARY_SELF_IMPORTS,
+    unnecessary_wraps::UNNECESSARY_WRAPS,
+    unnested_or_patterns::UNNESTED_OR_PATTERNS,
+    unsafe_removed_from_name::UNSAFE_REMOVED_FROM_NAME,
+    unused_async::UNUSED_ASYNC,
+    unused_io_amount::UNUSED_IO_AMOUNT,
+    unused_peekable::UNUSED_PEEKABLE,
+    unused_rounding::UNUSED_ROUNDING,
+    unused_self::UNUSED_SELF,
+    unused_unit::UNUSED_UNIT,
+    unwrap::PANICKING_UNWRAP,
+    unwrap::UNNECESSARY_UNWRAP,
+    unwrap_in_result::UNWRAP_IN_RESULT,
+    upper_case_acronyms::UPPER_CASE_ACRONYMS,
+    use_self::USE_SELF,
+    useless_conversion::USELESS_CONVERSION,
+    vec::USELESS_VEC,
+    vec_init_then_push::VEC_INIT_THEN_PUSH,
+    wildcard_imports::ENUM_GLOB_USE,
+    wildcard_imports::WILDCARD_IMPORTS,
+    write::PRINTLN_EMPTY_STRING,
+    write::PRINT_LITERAL,
+    write::PRINT_STDERR,
+    write::PRINT_STDOUT,
+    write::PRINT_WITH_NEWLINE,
+    write::USE_DEBUG,
+    write::WRITELN_EMPTY_STRING,
+    write::WRITE_LITERAL,
+    write::WRITE_WITH_NEWLINE,
+    zero_div_zero::ZERO_DIVIDED_BY_ZERO,
+    zero_sized_map_values::ZERO_SIZED_MAP_VALUES,
+])
diff --git a/clippy_lints/src/lib.register_restriction.rs b/clippy_lints/src/lib.register_restriction.rs
new file mode 100644
index 00000000000..aa82966f8e5
--- /dev/null
+++ b/clippy_lints/src/lib.register_restriction.rs
@@ -0,0 +1,91 @@
+// This file was generated by `cargo dev update_lints`.
+// Use that command to update this file and do not edit by hand.
+// Manual edits will be overwritten.
+
+store.register_group(true, "clippy::restriction", Some("clippy_restriction"), vec![
+    LintId::of(as_conversions::AS_CONVERSIONS),
+    LintId::of(asm_syntax::INLINE_ASM_X86_ATT_SYNTAX),
+    LintId::of(asm_syntax::INLINE_ASM_X86_INTEL_SYNTAX),
+    LintId::of(assertions_on_result_states::ASSERTIONS_ON_RESULT_STATES),
+    LintId::of(attrs::ALLOW_ATTRIBUTES_WITHOUT_REASON),
+    LintId::of(casts::AS_UNDERSCORE),
+    LintId::of(casts::FN_TO_NUMERIC_CAST_ANY),
+    LintId::of(create_dir::CREATE_DIR),
+    LintId::of(dbg_macro::DBG_MACRO),
+    LintId::of(default_numeric_fallback::DEFAULT_NUMERIC_FALLBACK),
+    LintId::of(default_union_representation::DEFAULT_UNION_REPRESENTATION),
+    LintId::of(disallowed_script_idents::DISALLOWED_SCRIPT_IDENTS),
+    LintId::of(else_if_without_else::ELSE_IF_WITHOUT_ELSE),
+    LintId::of(empty_drop::EMPTY_DROP),
+    LintId::of(empty_structs_with_brackets::EMPTY_STRUCTS_WITH_BRACKETS),
+    LintId::of(exhaustive_items::EXHAUSTIVE_ENUMS),
+    LintId::of(exhaustive_items::EXHAUSTIVE_STRUCTS),
+    LintId::of(exit::EXIT),
+    LintId::of(float_literal::LOSSY_FLOAT_LITERAL),
+    LintId::of(format_push_string::FORMAT_PUSH_STRING),
+    LintId::of(if_then_some_else_none::IF_THEN_SOME_ELSE_NONE),
+    LintId::of(implicit_return::IMPLICIT_RETURN),
+    LintId::of(indexing_slicing::INDEXING_SLICING),
+    LintId::of(inherent_impl::MULTIPLE_INHERENT_IMPL),
+    LintId::of(large_include_file::LARGE_INCLUDE_FILE),
+    LintId::of(let_underscore::LET_UNDERSCORE_MUST_USE),
+    LintId::of(literal_representation::DECIMAL_LITERAL_REPRESENTATION),
+    LintId::of(matches::REST_PAT_IN_FULLY_BOUND_STRUCTS),
+    LintId::of(matches::TRY_ERR),
+    LintId::of(matches::WILDCARD_ENUM_MATCH_ARM),
+    LintId::of(mem_forget::MEM_FORGET),
+    LintId::of(methods::CLONE_ON_REF_PTR),
+    LintId::of(methods::EXPECT_USED),
+    LintId::of(methods::FILETYPE_IS_FILE),
+    LintId::of(methods::GET_UNWRAP),
+    LintId::of(methods::MAP_ERR_IGNORE),
+    LintId::of(methods::UNWRAP_USED),
+    LintId::of(methods::VERBOSE_FILE_READS),
+    LintId::of(misc_early::SEPARATED_LITERAL_SUFFIX),
+    LintId::of(misc_early::UNNEEDED_FIELD_PATTERN),
+    LintId::of(misc_early::UNSEPARATED_LITERAL_SUFFIX),
+    LintId::of(missing_doc::MISSING_DOCS_IN_PRIVATE_ITEMS),
+    LintId::of(missing_enforced_import_rename::MISSING_ENFORCED_IMPORT_RENAMES),
+    LintId::of(missing_inline::MISSING_INLINE_IN_PUBLIC_ITEMS),
+    LintId::of(missing_trait_methods::MISSING_TRAIT_METHODS),
+    LintId::of(mixed_read_write_in_expression::MIXED_READ_WRITE_IN_EXPRESSION),
+    LintId::of(module_style::MOD_MODULE_FILES),
+    LintId::of(module_style::SELF_NAMED_MODULE_FILES),
+    LintId::of(operators::ARITHMETIC_SIDE_EFFECTS),
+    LintId::of(operators::FLOAT_ARITHMETIC),
+    LintId::of(operators::FLOAT_CMP_CONST),
+    LintId::of(operators::INTEGER_ARITHMETIC),
+    LintId::of(operators::INTEGER_DIVISION),
+    LintId::of(operators::MODULO_ARITHMETIC),
+    LintId::of(panic_in_result_fn::PANIC_IN_RESULT_FN),
+    LintId::of(panic_unimplemented::PANIC),
+    LintId::of(panic_unimplemented::TODO),
+    LintId::of(panic_unimplemented::UNIMPLEMENTED),
+    LintId::of(panic_unimplemented::UNREACHABLE),
+    LintId::of(partial_pub_fields::PARTIAL_PUB_FIELDS),
+    LintId::of(pattern_type_mismatch::PATTERN_TYPE_MISMATCH),
+    LintId::of(pub_use::PUB_USE),
+    LintId::of(redundant_slicing::DEREF_BY_SLICING),
+    LintId::of(same_name_method::SAME_NAME_METHOD),
+    LintId::of(shadow::SHADOW_REUSE),
+    LintId::of(shadow::SHADOW_SAME),
+    LintId::of(shadow::SHADOW_UNRELATED),
+    LintId::of(single_char_lifetime_names::SINGLE_CHAR_LIFETIME_NAMES),
+    LintId::of(std_instead_of_core::ALLOC_INSTEAD_OF_CORE),
+    LintId::of(std_instead_of_core::STD_INSTEAD_OF_ALLOC),
+    LintId::of(std_instead_of_core::STD_INSTEAD_OF_CORE),
+    LintId::of(strings::STRING_ADD),
+    LintId::of(strings::STRING_SLICE),
+    LintId::of(strings::STRING_TO_STRING),
+    LintId::of(strings::STR_TO_STRING),
+    LintId::of(suspicious_xor_used_as_pow::SUSPICIOUS_XOR_USED_AS_POW),
+    LintId::of(types::RC_BUFFER),
+    LintId::of(types::RC_MUTEX),
+    LintId::of(undocumented_unsafe_blocks::UNDOCUMENTED_UNSAFE_BLOCKS),
+    LintId::of(unicode::NON_ASCII_LITERAL),
+    LintId::of(unnecessary_self_imports::UNNECESSARY_SELF_IMPORTS),
+    LintId::of(unwrap_in_result::UNWRAP_IN_RESULT),
+    LintId::of(write::PRINT_STDERR),
+    LintId::of(write::PRINT_STDOUT),
+    LintId::of(write::USE_DEBUG),
+])
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 01da11958e2..197d8f2dc08 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -268,6 +268,7 @@ mod strings;
 mod strlen_on_c_strings;
 mod suspicious_operation_groupings;
 mod suspicious_trait_impl;
+mod suspicious_xor_used_as_pow;
 mod swap;
 mod swap_ptr_to_ref;
 mod tabs_in_doc_comments;
@@ -916,6 +917,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_early_pass(|| Box::new(partial_pub_fields::PartialPubFields));
     store.register_late_pass(|_| Box::new(missing_trait_methods::MissingTraitMethods));
     store.register_late_pass(|_| Box::new(from_raw_with_void_ptr::FromRawWithVoidPtr));
+    store.register_late_pass(|_| Box::new(suspicious_xor_used_as_pow::ConfusingXorAndPow));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/suspicious_xor_used_as_pow.rs b/clippy_lints/src/suspicious_xor_used_as_pow.rs
new file mode 100644
index 00000000000..b4168d69abc
--- /dev/null
+++ b/clippy_lints/src/suspicious_xor_used_as_pow.rs
@@ -0,0 +1,53 @@
+use clippy_utils::{numeric_literal::NumericLiteral, source::snippet_with_context};
+use rustc_errors::Applicability;
+use rustc_hir::{BinOpKind, Expr, ExprKind};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_middle::lint::in_external_macro;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Warns for a Bitwise XOR (`^`) operator being probably confused as a powering. It will not trigger if any of the numbers are not in decimal.
+    /// ### Why is this bad?
+    ///	It's most probably a typo and may lead to unexpected behaviours.
+    /// ### Example
+    /// ```rust
+    /// let x = 3_i32 ^ 4_i32;
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// let x = 3_i32.pow(4);
+    /// ```
+    #[clippy::version = "1.65.0"]
+    pub SUSPICIOUS_XOR_USED_AS_POW,
+    restriction,
+    "XOR (`^`) operator possibly used as exponentiation operator"
+}
+declare_lint_pass!(ConfusingXorAndPow => [SUSPICIOUS_XOR_USED_AS_POW]);
+
+impl LateLintPass<'_> for ConfusingXorAndPow {
+    fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
+        if !in_external_macro(cx.sess(), expr.span) &&
+        	let ExprKind::Binary(op, left, right) = &expr.kind &&
+            op.node == BinOpKind::BitXor &&
+            left.span.ctxt() == right.span.ctxt() &&
+            let ExprKind::Lit(lit_left) = &left.kind &&
+            let ExprKind::Lit(lit_right) = &right.kind &&
+            let snip_left = snippet_with_context(cx, lit_left.span, lit_left.span.ctxt(), "..", &mut Applicability::MaybeIncorrect) &&
+            let snip_right = snippet_with_context(cx, lit_right.span, lit_right.span.ctxt(), "..", &mut Applicability::MaybeIncorrect) &&
+            let Some(left_val) = NumericLiteral::from_lit_kind(&snip_left.0, &lit_left.node) &&
+            let Some(right_val) = NumericLiteral::from_lit_kind(&snip_right.0, &lit_right.node) &&
+			left_val.is_decimal() &&
+			right_val.is_decimal() {
+					clippy_utils::diagnostics::span_lint_and_sugg(
+					        cx,
+					        SUSPICIOUS_XOR_USED_AS_POW,
+					        expr.span,
+					        "`^` is not the exponentiation operator",
+					        "did you mean to write",
+					        format!("{}.pow({})", left_val.format(), right_val.format()),
+					        Applicability::MaybeIncorrect,
+					    );
+		}
+    }
+}
diff --git a/src/docs.rs b/src/docs.rs
new file mode 100644
index 00000000000..0f46e3f0842
--- /dev/null
+++ b/src/docs.rs
@@ -0,0 +1,607 @@
+// autogenerated. Please look at /clippy_dev/src/update_lints.rs
+
+macro_rules! include_lint {
+    ($file_name: expr) => {
+        include_str!($file_name)
+    };
+}
+
+macro_rules! docs {
+    ($($lint_name: expr,)*) => {
+        pub fn explain(lint: &str) {
+            println!("{}", match lint {
+                $(
+                    $lint_name => include_lint!(concat!("docs/", concat!($lint_name, ".txt"))),
+                )*
+                _ => "unknown lint",
+            })
+        }
+    }
+}
+
+docs! {
+    "absurd_extreme_comparisons",
+    "alloc_instead_of_core",
+    "allow_attributes_without_reason",
+    "almost_complete_letter_range",
+    "almost_swapped",
+    "approx_constant",
+    "arithmetic_side_effects",
+    "as_conversions",
+    "as_ptr_cast_mut",
+    "as_underscore",
+    "assertions_on_constants",
+    "assertions_on_result_states",
+    "assign_op_pattern",
+    "async_yields_async",
+    "await_holding_invalid_type",
+    "await_holding_lock",
+    "await_holding_refcell_ref",
+    "bad_bit_mask",
+    "bind_instead_of_map",
+    "blanket_clippy_restriction_lints",
+    "blocks_in_if_conditions",
+    "bool_assert_comparison",
+    "bool_comparison",
+    "bool_to_int_with_if",
+    "borrow_as_ptr",
+    "borrow_deref_ref",
+    "borrow_interior_mutable_const",
+    "borrowed_box",
+    "box_collection",
+    "box_default",
+    "boxed_local",
+    "branches_sharing_code",
+    "builtin_type_shadow",
+    "bytes_count_to_len",
+    "bytes_nth",
+    "cargo_common_metadata",
+    "case_sensitive_file_extension_comparisons",
+    "cast_abs_to_unsigned",
+    "cast_enum_constructor",
+    "cast_enum_truncation",
+    "cast_lossless",
+    "cast_nan_to_int",
+    "cast_possible_truncation",
+    "cast_possible_wrap",
+    "cast_precision_loss",
+    "cast_ptr_alignment",
+    "cast_ref_to_mut",
+    "cast_sign_loss",
+    "cast_slice_different_sizes",
+    "cast_slice_from_raw_parts",
+    "char_lit_as_u8",
+    "chars_last_cmp",
+    "chars_next_cmp",
+    "checked_conversions",
+    "clone_double_ref",
+    "clone_on_copy",
+    "clone_on_ref_ptr",
+    "cloned_instead_of_copied",
+    "cmp_nan",
+    "cmp_null",
+    "cmp_owned",
+    "cognitive_complexity",
+    "collapsible_else_if",
+    "collapsible_if",
+    "collapsible_match",
+    "collapsible_str_replace",
+    "comparison_chain",
+    "comparison_to_empty",
+    "copy_iterator",
+    "crate_in_macro_def",
+    "create_dir",
+    "crosspointer_transmute",
+    "dbg_macro",
+    "debug_assert_with_mut_call",
+    "decimal_literal_representation",
+    "declare_interior_mutable_const",
+    "default_instead_of_iter_empty",
+    "default_numeric_fallback",
+    "default_trait_access",
+    "default_union_representation",
+    "deprecated_cfg_attr",
+    "deprecated_semver",
+    "deref_addrof",
+    "deref_by_slicing",
+    "derivable_impls",
+    "derive_hash_xor_eq",
+    "derive_ord_xor_partial_ord",
+    "derive_partial_eq_without_eq",
+    "disallowed_macros",
+    "disallowed_methods",
+    "disallowed_names",
+    "disallowed_script_idents",
+    "disallowed_types",
+    "diverging_sub_expression",
+    "doc_link_with_quotes",
+    "doc_markdown",
+    "double_comparisons",
+    "double_must_use",
+    "double_neg",
+    "double_parens",
+    "drop_copy",
+    "drop_non_drop",
+    "drop_ref",
+    "duplicate_mod",
+    "duplicate_underscore_argument",
+    "duration_subsec",
+    "else_if_without_else",
+    "empty_drop",
+    "empty_enum",
+    "empty_line_after_outer_attr",
+    "empty_loop",
+    "empty_structs_with_brackets",
+    "enum_clike_unportable_variant",
+    "enum_glob_use",
+    "enum_variant_names",
+    "eq_op",
+    "equatable_if_let",
+    "erasing_op",
+    "err_expect",
+    "excessive_precision",
+    "exhaustive_enums",
+    "exhaustive_structs",
+    "exit",
+    "expect_fun_call",
+    "expect_used",
+    "expl_impl_clone_on_copy",
+    "explicit_auto_deref",
+    "explicit_counter_loop",
+    "explicit_deref_methods",
+    "explicit_into_iter_loop",
+    "explicit_iter_loop",
+    "explicit_write",
+    "extend_with_drain",
+    "extra_unused_lifetimes",
+    "fallible_impl_from",
+    "field_reassign_with_default",
+    "filetype_is_file",
+    "filter_map_identity",
+    "filter_map_next",
+    "filter_next",
+    "flat_map_identity",
+    "flat_map_option",
+    "float_arithmetic",
+    "float_cmp",
+    "float_cmp_const",
+    "float_equality_without_abs",
+    "fn_address_comparisons",
+    "fn_params_excessive_bools",
+    "fn_to_numeric_cast",
+    "fn_to_numeric_cast_any",
+    "fn_to_numeric_cast_with_truncation",
+    "for_kv_map",
+    "forget_copy",
+    "forget_non_drop",
+    "forget_ref",
+    "format_in_format_args",
+    "format_push_string",
+    "from_iter_instead_of_collect",
+    "from_over_into",
+    "from_str_radix_10",
+    "future_not_send",
+    "get_first",
+    "get_last_with_len",
+    "get_unwrap",
+    "identity_op",
+    "if_let_mutex",
+    "if_not_else",
+    "if_same_then_else",
+    "if_then_some_else_none",
+    "ifs_same_cond",
+    "implicit_clone",
+    "implicit_hasher",
+    "implicit_return",
+    "implicit_saturating_add",
+    "implicit_saturating_sub",
+    "imprecise_flops",
+    "inconsistent_digit_grouping",
+    "inconsistent_struct_constructor",
+    "index_refutable_slice",
+    "indexing_slicing",
+    "ineffective_bit_mask",
+    "inefficient_to_string",
+    "infallible_destructuring_match",
+    "infinite_iter",
+    "inherent_to_string",
+    "inherent_to_string_shadow_display",
+    "init_numbered_fields",
+    "inline_always",
+    "inline_asm_x86_att_syntax",
+    "inline_asm_x86_intel_syntax",
+    "inline_fn_without_body",
+    "inspect_for_each",
+    "int_plus_one",
+    "integer_arithmetic",
+    "integer_division",
+    "into_iter_on_ref",
+    "invalid_null_ptr_usage",
+    "invalid_regex",
+    "invalid_upcast_comparisons",
+    "invalid_utf8_in_unchecked",
+    "invisible_characters",
+    "is_digit_ascii_radix",
+    "items_after_statements",
+    "iter_cloned_collect",
+    "iter_count",
+    "iter_kv_map",
+    "iter_next_loop",
+    "iter_next_slice",
+    "iter_not_returning_iterator",
+    "iter_nth",
+    "iter_nth_zero",
+    "iter_on_empty_collections",
+    "iter_on_single_items",
+    "iter_overeager_cloned",
+    "iter_skip_next",
+    "iter_with_drain",
+    "iterator_step_by_zero",
+    "just_underscores_and_digits",
+    "large_const_arrays",
+    "large_digit_groups",
+    "large_enum_variant",
+    "large_include_file",
+    "large_stack_arrays",
+    "large_types_passed_by_value",
+    "len_without_is_empty",
+    "len_zero",
+    "let_and_return",
+    "let_underscore_drop",
+    "let_underscore_lock",
+    "let_underscore_must_use",
+    "let_unit_value",
+    "linkedlist",
+    "lossy_float_literal",
+    "macro_use_imports",
+    "main_recursion",
+    "manual_assert",
+    "manual_async_fn",
+    "manual_bits",
+    "manual_clamp",
+    "manual_filter",
+    "manual_filter_map",
+    "manual_find",
+    "manual_find_map",
+    "manual_flatten",
+    "manual_instant_elapsed",
+    "manual_map",
+    "manual_memcpy",
+    "manual_non_exhaustive",
+    "manual_ok_or",
+    "manual_range_contains",
+    "manual_rem_euclid",
+    "manual_retain",
+    "manual_saturating_arithmetic",
+    "manual_split_once",
+    "manual_str_repeat",
+    "manual_string_new",
+    "manual_strip",
+    "manual_swap",
+    "manual_unwrap_or",
+    "many_single_char_names",
+    "map_clone",
+    "map_collect_result_unit",
+    "map_entry",
+    "map_err_ignore",
+    "map_flatten",
+    "map_identity",
+    "map_unwrap_or",
+    "match_as_ref",
+    "match_bool",
+    "match_like_matches_macro",
+    "match_on_vec_items",
+    "match_overlapping_arm",
+    "match_ref_pats",
+    "match_result_ok",
+    "match_same_arms",
+    "match_single_binding",
+    "match_str_case_mismatch",
+    "match_wild_err_arm",
+    "match_wildcard_for_single_variants",
+    "maybe_infinite_iter",
+    "mem_forget",
+    "mem_replace_option_with_none",
+    "mem_replace_with_default",
+    "mem_replace_with_uninit",
+    "min_max",
+    "mismatched_target_os",
+    "mismatching_type_param_order",
+    "misrefactored_assign_op",
+    "missing_const_for_fn",
+    "missing_docs_in_private_items",
+    "missing_enforced_import_renames",
+    "missing_errors_doc",
+    "missing_inline_in_public_items",
+    "missing_panics_doc",
+    "missing_safety_doc",
+    "missing_spin_loop",
+    "missing_trait_methods",
+    "mistyped_literal_suffixes",
+    "mixed_case_hex_literals",
+    "mixed_read_write_in_expression",
+    "mod_module_files",
+    "module_inception",
+    "module_name_repetitions",
+    "modulo_arithmetic",
+    "modulo_one",
+    "multi_assignments",
+    "multiple_crate_versions",
+    "multiple_inherent_impl",
+    "must_use_candidate",
+    "must_use_unit",
+    "mut_from_ref",
+    "mut_mut",
+    "mut_mutex_lock",
+    "mut_range_bound",
+    "mutable_key_type",
+    "mutex_atomic",
+    "mutex_integer",
+    "naive_bytecount",
+    "needless_arbitrary_self_type",
+    "needless_bitwise_bool",
+    "needless_bool",
+    "needless_borrow",
+    "needless_borrowed_reference",
+    "needless_collect",
+    "needless_continue",
+    "needless_doctest_main",
+    "needless_for_each",
+    "needless_late_init",
+    "needless_lifetimes",
+    "needless_match",
+    "needless_option_as_deref",
+    "needless_option_take",
+    "needless_parens_on_range_literals",
+    "needless_pass_by_value",
+    "needless_question_mark",
+    "needless_range_loop",
+    "needless_return",
+    "needless_splitn",
+    "needless_update",
+    "neg_cmp_op_on_partial_ord",
+    "neg_multiply",
+    "negative_feature_names",
+    "never_loop",
+    "new_ret_no_self",
+    "new_without_default",
+    "no_effect",
+    "no_effect_replace",
+    "no_effect_underscore_binding",
+    "non_ascii_literal",
+    "non_octal_unix_permissions",
+    "non_send_fields_in_send_ty",
+    "nonminimal_bool",
+    "nonsensical_open_options",
+    "nonstandard_macro_braces",
+    "not_unsafe_ptr_arg_deref",
+    "obfuscated_if_else",
+    "octal_escapes",
+    "ok_expect",
+    "only_used_in_recursion",
+    "op_ref",
+    "option_as_ref_deref",
+    "option_env_unwrap",
+    "option_filter_map",
+    "option_if_let_else",
+    "option_map_or_none",
+    "option_map_unit_fn",
+    "option_option",
+    "or_fun_call",
+    "or_then_unwrap",
+    "out_of_bounds_indexing",
+    "overflow_check_conditional",
+    "overly_complex_bool_expr",
+    "panic",
+    "panic_in_result_fn",
+    "panicking_unwrap",
+    "partial_pub_fields",
+    "partialeq_ne_impl",
+    "partialeq_to_none",
+    "path_buf_push_overwrite",
+    "pattern_type_mismatch",
+    "possible_missing_comma",
+    "precedence",
+    "print_in_format_impl",
+    "print_literal",
+    "print_stderr",
+    "print_stdout",
+    "print_with_newline",
+    "println_empty_string",
+    "ptr_arg",
+    "ptr_as_ptr",
+    "ptr_eq",
+    "ptr_offset_with_cast",
+    "pub_use",
+    "question_mark",
+    "range_minus_one",
+    "range_plus_one",
+    "range_zip_with_len",
+    "rc_buffer",
+    "rc_clone_in_vec_init",
+    "rc_mutex",
+    "read_zero_byte_vec",
+    "recursive_format_impl",
+    "redundant_allocation",
+    "redundant_clone",
+    "redundant_closure",
+    "redundant_closure_call",
+    "redundant_closure_for_method_calls",
+    "redundant_else",
+    "redundant_feature_names",
+    "redundant_field_names",
+    "redundant_pattern",
+    "redundant_pattern_matching",
+    "redundant_pub_crate",
+    "redundant_slicing",
+    "redundant_static_lifetimes",
+    "ref_binding_to_reference",
+    "ref_option_ref",
+    "repeat_once",
+    "rest_pat_in_fully_bound_structs",
+    "result_large_err",
+    "result_map_or_into_option",
+    "result_map_unit_fn",
+    "result_unit_err",
+    "return_self_not_must_use",
+    "reversed_empty_ranges",
+    "same_functions_in_if_condition",
+    "same_item_push",
+    "same_name_method",
+    "search_is_some",
+    "self_assignment",
+    "self_named_constructors",
+    "self_named_module_files",
+    "semicolon_if_nothing_returned",
+    "separated_literal_suffix",
+    "serde_api_misuse",
+    "shadow_reuse",
+    "shadow_same",
+    "shadow_unrelated",
+    "short_circuit_statement",
+    "should_implement_trait",
+    "significant_drop_in_scrutinee",
+    "similar_names",
+    "single_char_add_str",
+    "single_char_lifetime_names",
+    "single_char_pattern",
+    "single_component_path_imports",
+    "single_element_loop",
+    "single_match",
+    "single_match_else",
+    "size_of_in_element_count",
+    "skip_while_next",
+    "slow_vector_initialization",
+    "stable_sort_primitive",
+    "std_instead_of_alloc",
+    "std_instead_of_core",
+    "str_to_string",
+    "string_add",
+    "string_add_assign",
+    "string_extend_chars",
+    "string_from_utf8_as_bytes",
+    "string_lit_as_bytes",
+    "string_slice",
+    "string_to_string",
+    "strlen_on_c_strings",
+    "struct_excessive_bools",
+    "suboptimal_flops",
+    "suspicious_arithmetic_impl",
+    "suspicious_assignment_formatting",
+    "suspicious_else_formatting",
+    "suspicious_map",
+    "suspicious_op_assign_impl",
+    "suspicious_operation_groupings",
+    "suspicious_splitn",
+    "suspicious_to_owned",
+    "suspicious_unary_op_formatting",
+    "suspicious_xor_used_as_pow",
+    "swap_ptr_to_ref",
+    "tabs_in_doc_comments",
+    "temporary_assignment",
+    "to_digit_is_some",
+    "to_string_in_format_args",
+    "todo",
+    "too_many_arguments",
+    "too_many_lines",
+    "toplevel_ref_arg",
+    "trailing_empty_array",
+    "trait_duplication_in_bounds",
+    "transmute_bytes_to_str",
+    "transmute_float_to_int",
+    "transmute_int_to_bool",
+    "transmute_int_to_char",
+    "transmute_int_to_float",
+    "transmute_num_to_bytes",
+    "transmute_ptr_to_ptr",
+    "transmute_ptr_to_ref",
+    "transmute_undefined_repr",
+    "transmutes_expressible_as_ptr_casts",
+    "transmuting_null",
+    "trim_split_whitespace",
+    "trivial_regex",
+    "trivially_copy_pass_by_ref",
+    "try_err",
+    "type_complexity",
+    "type_repetition_in_bounds",
+    "undocumented_unsafe_blocks",
+    "undropped_manually_drops",
+    "unicode_not_nfc",
+    "unimplemented",
+    "uninit_assumed_init",
+    "uninit_vec",
+    "uninlined_format_args",
+    "unit_arg",
+    "unit_cmp",
+    "unit_hash",
+    "unit_return_expecting_ord",
+    "unnecessary_cast",
+    "unnecessary_filter_map",
+    "unnecessary_find_map",
+    "unnecessary_fold",
+    "unnecessary_join",
+    "unnecessary_lazy_evaluations",
+    "unnecessary_mut_passed",
+    "unnecessary_operation",
+    "unnecessary_owned_empty_strings",
+    "unnecessary_self_imports",
+    "unnecessary_sort_by",
+    "unnecessary_to_owned",
+    "unnecessary_unwrap",
+    "unnecessary_wraps",
+    "unneeded_field_pattern",
+    "unneeded_wildcard_pattern",
+    "unnested_or_patterns",
+    "unreachable",
+    "unreadable_literal",
+    "unsafe_derive_deserialize",
+    "unsafe_removed_from_name",
+    "unseparated_literal_suffix",
+    "unsound_collection_transmute",
+    "unused_async",
+    "unused_format_specs",
+    "unused_io_amount",
+    "unused_peekable",
+    "unused_rounding",
+    "unused_self",
+    "unused_unit",
+    "unusual_byte_groupings",
+    "unwrap_in_result",
+    "unwrap_or_else_default",
+    "unwrap_used",
+    "upper_case_acronyms",
+    "use_debug",
+    "use_self",
+    "used_underscore_binding",
+    "useless_asref",
+    "useless_attribute",
+    "useless_conversion",
+    "useless_format",
+    "useless_let_if_seq",
+    "useless_transmute",
+    "useless_vec",
+    "vec_box",
+    "vec_init_then_push",
+    "vec_resize_to_zero",
+    "verbose_bit_mask",
+    "verbose_file_reads",
+    "vtable_address_comparisons",
+    "while_immutable_condition",
+    "while_let_loop",
+    "while_let_on_iterator",
+    "wildcard_dependencies",
+    "wildcard_enum_match_arm",
+    "wildcard_imports",
+    "wildcard_in_or_patterns",
+    "write_literal",
+    "write_with_newline",
+    "writeln_empty_string",
+    "wrong_self_convention",
+    "wrong_transmute",
+    "zero_divided_by_zero",
+    "zero_prefixed_literal",
+    "zero_ptr",
+    "zero_sized_map_values",
+    "zst_offset",
+
+}
diff --git a/src/docs/suspicious_xor_used_as_pow.txt b/src/docs/suspicious_xor_used_as_pow.txt
new file mode 100644
index 00000000000..2cae5497f0f
--- /dev/null
+++ b/src/docs/suspicious_xor_used_as_pow.txt
@@ -0,0 +1,12 @@
+### What it does
+Warns for a Bitwise XOR (`^`) operator being probably confused as a powering. It will not trigger if any of the numbers are not in decimal.
+### Why is this bad?
+	It's most probably a typo and may lead to unexpected behaviours.
+### Example
+```
+let x = 3_i32 ^ 4_i32;
+```
+Use instead:
+```
+let x = 3_i32.pow(4);
+```
\ No newline at end of file
diff --git a/tests/ui/eq_op.rs b/tests/ui/eq_op.rs
index 422f9486503..e7379550265 100644
--- a/tests/ui/eq_op.rs
+++ b/tests/ui/eq_op.rs
@@ -2,6 +2,7 @@
 
 #![warn(clippy::eq_op)]
 #![allow(clippy::double_parens, clippy::identity_op, clippy::nonminimal_bool)]
+#![allow(clippy::suspicious_xor_used_as_pow)]
 
 fn main() {
     // simple values and comparisons
diff --git a/tests/ui/eq_op.stderr b/tests/ui/eq_op.stderr
index 313ceed2b41..d365ab27edc 100644
--- a/tests/ui/eq_op.stderr
+++ b/tests/ui/eq_op.stderr
@@ -1,5 +1,5 @@
 error: equal expressions as operands to `==`
-  --> $DIR/eq_op.rs:8:13
+  --> $DIR/eq_op.rs:9:13
    |
 LL |     let _ = 1 == 1;
    |             ^^^^^^
@@ -7,163 +7,163 @@ LL |     let _ = 1 == 1;
    = note: `-D clippy::eq-op` implied by `-D warnings`
 
 error: equal expressions as operands to `==`
-  --> $DIR/eq_op.rs:9:13
+  --> $DIR/eq_op.rs:10:13
    |
 LL |     let _ = "no" == "no";
    |             ^^^^^^^^^^^^
 
 error: equal expressions as operands to `!=`
-  --> $DIR/eq_op.rs:11:13
+  --> $DIR/eq_op.rs:12:13
    |
 LL |     let _ = false != false;
    |             ^^^^^^^^^^^^^^
 
 error: equal expressions as operands to `<`
-  --> $DIR/eq_op.rs:12:13
+  --> $DIR/eq_op.rs:13:13
    |
 LL |     let _ = 1.5 < 1.5;
    |             ^^^^^^^^^
 
 error: equal expressions as operands to `>=`
-  --> $DIR/eq_op.rs:13:13
+  --> $DIR/eq_op.rs:14:13
    |
 LL |     let _ = 1u64 >= 1u64;
    |             ^^^^^^^^^^^^
 
 error: equal expressions as operands to `&`
-  --> $DIR/eq_op.rs:16:13
+  --> $DIR/eq_op.rs:17:13
    |
 LL |     let _ = (1u32 as u64) & (1u32 as u64);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: equal expressions as operands to `^`
-  --> $DIR/eq_op.rs:19:17
+  --> $DIR/eq_op.rs:20:17
    |
 LL |         let _ = 1 ^ ((((((1))))));
    |                 ^^^^^^^^^^^^^^^^^
 
 error: equal expressions as operands to `<`
-  --> $DIR/eq_op.rs:23:13
+  --> $DIR/eq_op.rs:24:13
    |
 LL |     let _ = (-(2) < -(2));
    |             ^^^^^^^^^^^^^
 
 error: equal expressions as operands to `==`
-  --> $DIR/eq_op.rs:24:13
+  --> $DIR/eq_op.rs:25:13
    |
 LL |     let _ = ((1 + 1) & (1 + 1) == (1 + 1) & (1 + 1));
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: equal expressions as operands to `&`
-  --> $DIR/eq_op.rs:24:14
+  --> $DIR/eq_op.rs:25:14
    |
 LL |     let _ = ((1 + 1) & (1 + 1) == (1 + 1) & (1 + 1));
    |              ^^^^^^^^^^^^^^^^^
 
 error: equal expressions as operands to `&`
-  --> $DIR/eq_op.rs:24:35
+  --> $DIR/eq_op.rs:25:35
    |
 LL |     let _ = ((1 + 1) & (1 + 1) == (1 + 1) & (1 + 1));
    |                                   ^^^^^^^^^^^^^^^^^
 
 error: equal expressions as operands to `==`
-  --> $DIR/eq_op.rs:25:13
+  --> $DIR/eq_op.rs:26:13
    |
 LL |     let _ = (1 * 2) + (3 * 4) == 1 * 2 + 3 * 4;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: equal expressions as operands to `!=`
-  --> $DIR/eq_op.rs:28:13
+  --> $DIR/eq_op.rs:29:13
    |
 LL |     let _ = ([1] != [1]);
    |             ^^^^^^^^^^^^
 
 error: equal expressions as operands to `!=`
-  --> $DIR/eq_op.rs:29:13
+  --> $DIR/eq_op.rs:30:13
    |
 LL |     let _ = ((1, 2) != (1, 2));
    |             ^^^^^^^^^^^^^^^^^^
 
 error: equal expressions as operands to `==`
-  --> $DIR/eq_op.rs:33:13
+  --> $DIR/eq_op.rs:34:13
    |
 LL |     let _ = 1 + 1 == 2;
    |             ^^^^^^^^^^
 
 error: equal expressions as operands to `==`
-  --> $DIR/eq_op.rs:34:13
+  --> $DIR/eq_op.rs:35:13
    |
 LL |     let _ = 1 - 1 == 0;
    |             ^^^^^^^^^^
 
 error: equal expressions as operands to `-`
-  --> $DIR/eq_op.rs:34:13
+  --> $DIR/eq_op.rs:35:13
    |
 LL |     let _ = 1 - 1 == 0;
    |             ^^^^^
 
 error: equal expressions as operands to `-`
-  --> $DIR/eq_op.rs:36:13
+  --> $DIR/eq_op.rs:37:13
    |
 LL |     let _ = 1 - 1;
    |             ^^^^^
 
 error: equal expressions as operands to `/`
-  --> $DIR/eq_op.rs:37:13
+  --> $DIR/eq_op.rs:38:13
    |
 LL |     let _ = 1 / 1;
    |             ^^^^^
 
 error: equal expressions as operands to `&&`
-  --> $DIR/eq_op.rs:38:13
+  --> $DIR/eq_op.rs:39:13
    |
 LL |     let _ = true && true;
    |             ^^^^^^^^^^^^
 
 error: equal expressions as operands to `||`
-  --> $DIR/eq_op.rs:40:13
+  --> $DIR/eq_op.rs:41:13
    |
 LL |     let _ = true || true;
    |             ^^^^^^^^^^^^
 
 error: equal expressions as operands to `&&`
-  --> $DIR/eq_op.rs:45:13
+  --> $DIR/eq_op.rs:46:13
    |
 LL |     let _ = a == b && b == a;
    |             ^^^^^^^^^^^^^^^^
 
 error: equal expressions as operands to `&&`
-  --> $DIR/eq_op.rs:46:13
+  --> $DIR/eq_op.rs:47:13
    |
 LL |     let _ = a != b && b != a;
    |             ^^^^^^^^^^^^^^^^
 
 error: equal expressions as operands to `&&`
-  --> $DIR/eq_op.rs:47:13
+  --> $DIR/eq_op.rs:48:13
    |
 LL |     let _ = a < b && b > a;
    |             ^^^^^^^^^^^^^^
 
 error: equal expressions as operands to `&&`
-  --> $DIR/eq_op.rs:48:13
+  --> $DIR/eq_op.rs:49:13
    |
 LL |     let _ = a <= b && b >= a;
    |             ^^^^^^^^^^^^^^^^
 
 error: equal expressions as operands to `==`
-  --> $DIR/eq_op.rs:51:13
+  --> $DIR/eq_op.rs:52:13
    |
 LL |     let _ = a == a;
    |             ^^^^^^
 
 error: equal expressions as operands to `/`
-  --> $DIR/eq_op.rs:61:20
+  --> $DIR/eq_op.rs:62:20
    |
 LL |     const D: u32 = A / A;
    |                    ^^^^^
 
 error: equal expressions as operands to `==`
-  --> $DIR/eq_op.rs:92:5
+  --> $DIR/eq_op.rs:93:5
    |
 LL |     (n1.inner.0).0 == (n1.inner.0).0 && (n1.inner.1).0 == (n2.inner.1).0 && (n1.inner.2).0 == (n2.inner.2).0
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/suspicious_xor_used_as_pow.rs b/tests/ui/suspicious_xor_used_as_pow.rs
new file mode 100644
index 00000000000..eb9fc63fb1d
--- /dev/null
+++ b/tests/ui/suspicious_xor_used_as_pow.rs
@@ -0,0 +1,34 @@
+#![allow(unused)]
+#![warn(clippy::suspicious_xor_used_as_pow)]
+#![allow(clippy::eq_op)]
+
+macro_rules! macro_test {
+    () => {
+        13
+    };
+}
+
+macro_rules! macro_test_inside {
+    () => {
+        1 ^ 2 // should warn even if inside macro
+    };
+}
+
+fn main() {
+    // Should warn:
+    let _ = 2 ^ 5;
+    let _ = 2i32 ^ 9i32;
+    let _ = 2i32 ^ 2i32;
+    let _ = 50i32 ^ 3i32;
+    let _ = 5i32 ^ 8i32;
+    let _ = 2i32 ^ 32i32;
+    macro_test_inside!();
+
+    // Should not warn:
+    let x = 0x02;
+    let _ = x ^ 2;
+    let _ = 2 ^ x;
+    let _ = x ^ 5;
+    let _ = 10 ^ 0b0101;
+    let _ = 2i32 ^ macro_test!();
+}
diff --git a/tests/ui/suspicious_xor_used_as_pow.stderr b/tests/ui/suspicious_xor_used_as_pow.stderr
new file mode 100644
index 00000000000..8bb3c8fbeeb
--- /dev/null
+++ b/tests/ui/suspicious_xor_used_as_pow.stderr
@@ -0,0 +1,51 @@
+error: `^` is not the exponentiation operator
+  --> $DIR/suspicious_xor_used_as_pow.rs:19:13
+   |
+LL |     let _ = 2 ^ 5;
+   |             ^^^^^ help: did you mean to write: `2.pow(5)`
+   |
+   = note: `-D clippy::suspicious-xor-used-as-pow` implied by `-D warnings`
+
+error: `^` is not the exponentiation operator
+  --> $DIR/suspicious_xor_used_as_pow.rs:20:13
+   |
+LL |     let _ = 2i32 ^ 9i32;
+   |             ^^^^^^^^^^^ help: did you mean to write: `2_i32.pow(9_i32)`
+
+error: `^` is not the exponentiation operator
+  --> $DIR/suspicious_xor_used_as_pow.rs:21:13
+   |
+LL |     let _ = 2i32 ^ 2i32;
+   |             ^^^^^^^^^^^ help: did you mean to write: `2_i32.pow(2_i32)`
+
+error: `^` is not the exponentiation operator
+  --> $DIR/suspicious_xor_used_as_pow.rs:22:13
+   |
+LL |     let _ = 50i32 ^ 3i32;
+   |             ^^^^^^^^^^^^ help: did you mean to write: `50_i32.pow(3_i32)`
+
+error: `^` is not the exponentiation operator
+  --> $DIR/suspicious_xor_used_as_pow.rs:23:13
+   |
+LL |     let _ = 5i32 ^ 8i32;
+   |             ^^^^^^^^^^^ help: did you mean to write: `5_i32.pow(8_i32)`
+
+error: `^` is not the exponentiation operator
+  --> $DIR/suspicious_xor_used_as_pow.rs:24:13
+   |
+LL |     let _ = 2i32 ^ 32i32;
+   |             ^^^^^^^^^^^^ help: did you mean to write: `2_i32.pow(32_i32)`
+
+error: `^` is not the exponentiation operator
+  --> $DIR/suspicious_xor_used_as_pow.rs:13:9
+   |
+LL |         1 ^ 2 // should warn even if inside macro
+   |         ^^^^^ help: did you mean to write: `1.pow(2)`
+...
+LL |     macro_test_inside!();
+   |     -------------------- in this macro invocation
+   |
+   = note: this error originates in the macro `macro_test_inside` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: aborting due to 7 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 64308d6292de5373a892532bac48862cec4b2677 Mon Sep 17 00:00:00 2001
From: Alex <blyxyas@gmail.com>
Date: Tue, 25 Oct 2022 20:35:16 +0200
Subject: Lints updated

---
 clippy_lints/src/declared_lints.rs           |   1 +
 clippy_lints/src/lib.register_lints.rs       | 621 ---------------------------
 clippy_lints/src/lib.register_restriction.rs |  91 ----
 src/docs.rs                                  | 607 --------------------------
 src/docs/suspicious_xor_used_as_pow.txt      |  12 -
 5 files changed, 1 insertion(+), 1331 deletions(-)
 delete mode 100644 clippy_lints/src/lib.register_lints.rs
 delete mode 100644 clippy_lints/src/lib.register_restriction.rs
 delete mode 100644 src/docs.rs
 delete mode 100644 src/docs/suspicious_xor_used_as_pow.txt

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index a903d46b2a4..35f86e8aa78 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -543,6 +543,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::suspicious_operation_groupings::SUSPICIOUS_OPERATION_GROUPINGS_INFO,
     crate::suspicious_trait_impl::SUSPICIOUS_ARITHMETIC_IMPL_INFO,
     crate::suspicious_trait_impl::SUSPICIOUS_OP_ASSIGN_IMPL_INFO,
+    crate::suspicious_xor_used_as_pow::SUSPICIOUS_XOR_USED_AS_POW_INFO,
     crate::swap::ALMOST_SWAPPED_INFO,
     crate::swap::MANUAL_SWAP_INFO,
     crate::swap_ptr_to_ref::SWAP_PTR_TO_REF_INFO,
diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs
deleted file mode 100644
index 3d4e05b335d..00000000000
--- a/clippy_lints/src/lib.register_lints.rs
+++ /dev/null
@@ -1,621 +0,0 @@
-// This file was generated by `cargo dev update_lints`.
-// Use that command to update this file and do not edit by hand.
-// Manual edits will be overwritten.
-
-store.register_lints(&[
-    #[cfg(feature = "internal")]
-    utils::internal_lints::clippy_lints_internal::CLIPPY_LINTS_INTERNAL,
-    #[cfg(feature = "internal")]
-    utils::internal_lints::collapsible_calls::COLLAPSIBLE_SPAN_LINT_CALLS,
-    #[cfg(feature = "internal")]
-    utils::internal_lints::compiler_lint_functions::COMPILER_LINT_FUNCTIONS,
-    #[cfg(feature = "internal")]
-    utils::internal_lints::if_chain_style::IF_CHAIN_STYLE,
-    #[cfg(feature = "internal")]
-    utils::internal_lints::interning_defined_symbol::INTERNING_DEFINED_SYMBOL,
-    #[cfg(feature = "internal")]
-    utils::internal_lints::interning_defined_symbol::UNNECESSARY_SYMBOL_STR,
-    #[cfg(feature = "internal")]
-    utils::internal_lints::invalid_paths::INVALID_PATHS,
-    #[cfg(feature = "internal")]
-    utils::internal_lints::lint_without_lint_pass::DEFAULT_DEPRECATION_REASON,
-    #[cfg(feature = "internal")]
-    utils::internal_lints::lint_without_lint_pass::DEFAULT_LINT,
-    #[cfg(feature = "internal")]
-    utils::internal_lints::lint_without_lint_pass::INVALID_CLIPPY_VERSION_ATTRIBUTE,
-    #[cfg(feature = "internal")]
-    utils::internal_lints::lint_without_lint_pass::LINT_WITHOUT_LINT_PASS,
-    #[cfg(feature = "internal")]
-    utils::internal_lints::lint_without_lint_pass::MISSING_CLIPPY_VERSION_ATTRIBUTE,
-    #[cfg(feature = "internal")]
-    utils::internal_lints::msrv_attr_impl::MISSING_MSRV_ATTR_IMPL,
-    #[cfg(feature = "internal")]
-    utils::internal_lints::outer_expn_data_pass::OUTER_EXPN_EXPN_DATA,
-    #[cfg(feature = "internal")]
-    utils::internal_lints::produce_ice::PRODUCE_ICE,
-    #[cfg(feature = "internal")]
-    utils::internal_lints::unnecessary_def_path::UNNECESSARY_DEF_PATH,
-    almost_complete_letter_range::ALMOST_COMPLETE_LETTER_RANGE,
-    approx_const::APPROX_CONSTANT,
-    as_conversions::AS_CONVERSIONS,
-    asm_syntax::INLINE_ASM_X86_ATT_SYNTAX,
-    asm_syntax::INLINE_ASM_X86_INTEL_SYNTAX,
-    assertions_on_constants::ASSERTIONS_ON_CONSTANTS,
-    assertions_on_result_states::ASSERTIONS_ON_RESULT_STATES,
-    async_yields_async::ASYNC_YIELDS_ASYNC,
-    attrs::ALLOW_ATTRIBUTES_WITHOUT_REASON,
-    attrs::BLANKET_CLIPPY_RESTRICTION_LINTS,
-    attrs::DEPRECATED_CFG_ATTR,
-    attrs::DEPRECATED_SEMVER,
-    attrs::EMPTY_LINE_AFTER_OUTER_ATTR,
-    attrs::INLINE_ALWAYS,
-    attrs::MISMATCHED_TARGET_OS,
-    attrs::USELESS_ATTRIBUTE,
-    await_holding_invalid::AWAIT_HOLDING_INVALID_TYPE,
-    await_holding_invalid::AWAIT_HOLDING_LOCK,
-    await_holding_invalid::AWAIT_HOLDING_REFCELL_REF,
-    blocks_in_if_conditions::BLOCKS_IN_IF_CONDITIONS,
-    bool_assert_comparison::BOOL_ASSERT_COMPARISON,
-    bool_to_int_with_if::BOOL_TO_INT_WITH_IF,
-    booleans::NONMINIMAL_BOOL,
-    booleans::OVERLY_COMPLEX_BOOL_EXPR,
-    borrow_deref_ref::BORROW_DEREF_REF,
-    box_default::BOX_DEFAULT,
-    cargo::CARGO_COMMON_METADATA,
-    cargo::MULTIPLE_CRATE_VERSIONS,
-    cargo::NEGATIVE_FEATURE_NAMES,
-    cargo::REDUNDANT_FEATURE_NAMES,
-    cargo::WILDCARD_DEPENDENCIES,
-    casts::AS_PTR_CAST_MUT,
-    casts::AS_UNDERSCORE,
-    casts::BORROW_AS_PTR,
-    casts::CAST_ABS_TO_UNSIGNED,
-    casts::CAST_ENUM_CONSTRUCTOR,
-    casts::CAST_ENUM_TRUNCATION,
-    casts::CAST_LOSSLESS,
-    casts::CAST_NAN_TO_INT,
-    casts::CAST_POSSIBLE_TRUNCATION,
-    casts::CAST_POSSIBLE_WRAP,
-    casts::CAST_PRECISION_LOSS,
-    casts::CAST_PTR_ALIGNMENT,
-    casts::CAST_REF_TO_MUT,
-    casts::CAST_SIGN_LOSS,
-    casts::CAST_SLICE_DIFFERENT_SIZES,
-    casts::CAST_SLICE_FROM_RAW_PARTS,
-    casts::CHAR_LIT_AS_U8,
-    casts::FN_TO_NUMERIC_CAST,
-    casts::FN_TO_NUMERIC_CAST_ANY,
-    casts::FN_TO_NUMERIC_CAST_WITH_TRUNCATION,
-    casts::PTR_AS_PTR,
-    casts::UNNECESSARY_CAST,
-    checked_conversions::CHECKED_CONVERSIONS,
-    cognitive_complexity::COGNITIVE_COMPLEXITY,
-    collapsible_if::COLLAPSIBLE_ELSE_IF,
-    collapsible_if::COLLAPSIBLE_IF,
-    comparison_chain::COMPARISON_CHAIN,
-    copies::BRANCHES_SHARING_CODE,
-    copies::IFS_SAME_COND,
-    copies::IF_SAME_THEN_ELSE,
-    copies::SAME_FUNCTIONS_IN_IF_CONDITION,
-    copy_iterator::COPY_ITERATOR,
-    crate_in_macro_def::CRATE_IN_MACRO_DEF,
-    create_dir::CREATE_DIR,
-    dbg_macro::DBG_MACRO,
-    default::DEFAULT_TRAIT_ACCESS,
-    default::FIELD_REASSIGN_WITH_DEFAULT,
-    default_instead_of_iter_empty::DEFAULT_INSTEAD_OF_ITER_EMPTY,
-    default_numeric_fallback::DEFAULT_NUMERIC_FALLBACK,
-    default_union_representation::DEFAULT_UNION_REPRESENTATION,
-    dereference::EXPLICIT_AUTO_DEREF,
-    dereference::EXPLICIT_DEREF_METHODS,
-    dereference::NEEDLESS_BORROW,
-    dereference::REF_BINDING_TO_REFERENCE,
-    derivable_impls::DERIVABLE_IMPLS,
-    derive::DERIVE_HASH_XOR_EQ,
-    derive::DERIVE_ORD_XOR_PARTIAL_ORD,
-    derive::DERIVE_PARTIAL_EQ_WITHOUT_EQ,
-    derive::EXPL_IMPL_CLONE_ON_COPY,
-    derive::UNSAFE_DERIVE_DESERIALIZE,
-    disallowed_macros::DISALLOWED_MACROS,
-    disallowed_methods::DISALLOWED_METHODS,
-    disallowed_names::DISALLOWED_NAMES,
-    disallowed_script_idents::DISALLOWED_SCRIPT_IDENTS,
-    disallowed_types::DISALLOWED_TYPES,
-    doc::DOC_LINK_WITH_QUOTES,
-    doc::DOC_MARKDOWN,
-    doc::MISSING_ERRORS_DOC,
-    doc::MISSING_PANICS_DOC,
-    doc::MISSING_SAFETY_DOC,
-    doc::NEEDLESS_DOCTEST_MAIN,
-    double_parens::DOUBLE_PARENS,
-    drop_forget_ref::DROP_COPY,
-    drop_forget_ref::DROP_NON_DROP,
-    drop_forget_ref::DROP_REF,
-    drop_forget_ref::FORGET_COPY,
-    drop_forget_ref::FORGET_NON_DROP,
-    drop_forget_ref::FORGET_REF,
-    drop_forget_ref::UNDROPPED_MANUALLY_DROPS,
-    duplicate_mod::DUPLICATE_MOD,
-    else_if_without_else::ELSE_IF_WITHOUT_ELSE,
-    empty_drop::EMPTY_DROP,
-    empty_enum::EMPTY_ENUM,
-    empty_structs_with_brackets::EMPTY_STRUCTS_WITH_BRACKETS,
-    entry::MAP_ENTRY,
-    enum_clike::ENUM_CLIKE_UNPORTABLE_VARIANT,
-    enum_variants::ENUM_VARIANT_NAMES,
-    enum_variants::MODULE_INCEPTION,
-    enum_variants::MODULE_NAME_REPETITIONS,
-    equatable_if_let::EQUATABLE_IF_LET,
-    escape::BOXED_LOCAL,
-    eta_reduction::REDUNDANT_CLOSURE,
-    eta_reduction::REDUNDANT_CLOSURE_FOR_METHOD_CALLS,
-    excessive_bools::FN_PARAMS_EXCESSIVE_BOOLS,
-    excessive_bools::STRUCT_EXCESSIVE_BOOLS,
-    exhaustive_items::EXHAUSTIVE_ENUMS,
-    exhaustive_items::EXHAUSTIVE_STRUCTS,
-    exit::EXIT,
-    explicit_write::EXPLICIT_WRITE,
-    fallible_impl_from::FALLIBLE_IMPL_FROM,
-    float_literal::EXCESSIVE_PRECISION,
-    float_literal::LOSSY_FLOAT_LITERAL,
-    floating_point_arithmetic::IMPRECISE_FLOPS,
-    floating_point_arithmetic::SUBOPTIMAL_FLOPS,
-    format::USELESS_FORMAT,
-    format_args::FORMAT_IN_FORMAT_ARGS,
-    format_args::TO_STRING_IN_FORMAT_ARGS,
-    format_args::UNINLINED_FORMAT_ARGS,
-    format_args::UNUSED_FORMAT_SPECS,
-    format_impl::PRINT_IN_FORMAT_IMPL,
-    format_impl::RECURSIVE_FORMAT_IMPL,
-    format_push_string::FORMAT_PUSH_STRING,
-    formatting::POSSIBLE_MISSING_COMMA,
-    formatting::SUSPICIOUS_ASSIGNMENT_FORMATTING,
-    formatting::SUSPICIOUS_ELSE_FORMATTING,
-    formatting::SUSPICIOUS_UNARY_OP_FORMATTING,
-    from_over_into::FROM_OVER_INTO,
-    from_str_radix_10::FROM_STR_RADIX_10,
-    functions::DOUBLE_MUST_USE,
-    functions::MUST_USE_CANDIDATE,
-    functions::MUST_USE_UNIT,
-    functions::NOT_UNSAFE_PTR_ARG_DEREF,
-    functions::RESULT_LARGE_ERR,
-    functions::RESULT_UNIT_ERR,
-    functions::TOO_MANY_ARGUMENTS,
-    functions::TOO_MANY_LINES,
-    future_not_send::FUTURE_NOT_SEND,
-    if_let_mutex::IF_LET_MUTEX,
-    if_not_else::IF_NOT_ELSE,
-    if_then_some_else_none::IF_THEN_SOME_ELSE_NONE,
-    implicit_hasher::IMPLICIT_HASHER,
-    implicit_return::IMPLICIT_RETURN,
-    implicit_saturating_add::IMPLICIT_SATURATING_ADD,
-    implicit_saturating_sub::IMPLICIT_SATURATING_SUB,
-    inconsistent_struct_constructor::INCONSISTENT_STRUCT_CONSTRUCTOR,
-    index_refutable_slice::INDEX_REFUTABLE_SLICE,
-    indexing_slicing::INDEXING_SLICING,
-    indexing_slicing::OUT_OF_BOUNDS_INDEXING,
-    infinite_iter::INFINITE_ITER,
-    infinite_iter::MAYBE_INFINITE_ITER,
-    inherent_impl::MULTIPLE_INHERENT_IMPL,
-    inherent_to_string::INHERENT_TO_STRING,
-    inherent_to_string::INHERENT_TO_STRING_SHADOW_DISPLAY,
-    init_numbered_fields::INIT_NUMBERED_FIELDS,
-    inline_fn_without_body::INLINE_FN_WITHOUT_BODY,
-    int_plus_one::INT_PLUS_ONE,
-    invalid_upcast_comparisons::INVALID_UPCAST_COMPARISONS,
-    invalid_utf8_in_unchecked::INVALID_UTF8_IN_UNCHECKED,
-    items_after_statements::ITEMS_AFTER_STATEMENTS,
-    iter_not_returning_iterator::ITER_NOT_RETURNING_ITERATOR,
-    large_const_arrays::LARGE_CONST_ARRAYS,
-    large_enum_variant::LARGE_ENUM_VARIANT,
-    large_include_file::LARGE_INCLUDE_FILE,
-    large_stack_arrays::LARGE_STACK_ARRAYS,
-    len_zero::COMPARISON_TO_EMPTY,
-    len_zero::LEN_WITHOUT_IS_EMPTY,
-    len_zero::LEN_ZERO,
-    let_if_seq::USELESS_LET_IF_SEQ,
-    let_underscore::LET_UNDERSCORE_DROP,
-    let_underscore::LET_UNDERSCORE_LOCK,
-    let_underscore::LET_UNDERSCORE_MUST_USE,
-    lifetimes::EXTRA_UNUSED_LIFETIMES,
-    lifetimes::NEEDLESS_LIFETIMES,
-    literal_representation::DECIMAL_LITERAL_REPRESENTATION,
-    literal_representation::INCONSISTENT_DIGIT_GROUPING,
-    literal_representation::LARGE_DIGIT_GROUPS,
-    literal_representation::MISTYPED_LITERAL_SUFFIXES,
-    literal_representation::UNREADABLE_LITERAL,
-    literal_representation::UNUSUAL_BYTE_GROUPINGS,
-    loops::EMPTY_LOOP,
-    loops::EXPLICIT_COUNTER_LOOP,
-    loops::EXPLICIT_INTO_ITER_LOOP,
-    loops::EXPLICIT_ITER_LOOP,
-    loops::FOR_KV_MAP,
-    loops::ITER_NEXT_LOOP,
-    loops::MANUAL_FIND,
-    loops::MANUAL_FLATTEN,
-    loops::MANUAL_MEMCPY,
-    loops::MISSING_SPIN_LOOP,
-    loops::MUT_RANGE_BOUND,
-    loops::NEEDLESS_COLLECT,
-    loops::NEEDLESS_RANGE_LOOP,
-    loops::NEVER_LOOP,
-    loops::SAME_ITEM_PUSH,
-    loops::SINGLE_ELEMENT_LOOP,
-    loops::WHILE_IMMUTABLE_CONDITION,
-    loops::WHILE_LET_LOOP,
-    loops::WHILE_LET_ON_ITERATOR,
-    macro_use::MACRO_USE_IMPORTS,
-    main_recursion::MAIN_RECURSION,
-    manual_assert::MANUAL_ASSERT,
-    manual_async_fn::MANUAL_ASYNC_FN,
-    manual_bits::MANUAL_BITS,
-    manual_clamp::MANUAL_CLAMP,
-    manual_instant_elapsed::MANUAL_INSTANT_ELAPSED,
-    manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE,
-    manual_rem_euclid::MANUAL_REM_EUCLID,
-    manual_retain::MANUAL_RETAIN,
-    manual_string_new::MANUAL_STRING_NEW,
-    manual_strip::MANUAL_STRIP,
-    map_unit_fn::OPTION_MAP_UNIT_FN,
-    map_unit_fn::RESULT_MAP_UNIT_FN,
-    match_result_ok::MATCH_RESULT_OK,
-    matches::COLLAPSIBLE_MATCH,
-    matches::INFALLIBLE_DESTRUCTURING_MATCH,
-    matches::MANUAL_FILTER,
-    matches::MANUAL_MAP,
-    matches::MANUAL_UNWRAP_OR,
-    matches::MATCH_AS_REF,
-    matches::MATCH_BOOL,
-    matches::MATCH_LIKE_MATCHES_MACRO,
-    matches::MATCH_ON_VEC_ITEMS,
-    matches::MATCH_OVERLAPPING_ARM,
-    matches::MATCH_REF_PATS,
-    matches::MATCH_SAME_ARMS,
-    matches::MATCH_SINGLE_BINDING,
-    matches::MATCH_STR_CASE_MISMATCH,
-    matches::MATCH_WILDCARD_FOR_SINGLE_VARIANTS,
-    matches::MATCH_WILD_ERR_ARM,
-    matches::NEEDLESS_MATCH,
-    matches::REDUNDANT_PATTERN_MATCHING,
-    matches::REST_PAT_IN_FULLY_BOUND_STRUCTS,
-    matches::SIGNIFICANT_DROP_IN_SCRUTINEE,
-    matches::SINGLE_MATCH,
-    matches::SINGLE_MATCH_ELSE,
-    matches::TRY_ERR,
-    matches::WILDCARD_ENUM_MATCH_ARM,
-    matches::WILDCARD_IN_OR_PATTERNS,
-    mem_forget::MEM_FORGET,
-    mem_replace::MEM_REPLACE_OPTION_WITH_NONE,
-    mem_replace::MEM_REPLACE_WITH_DEFAULT,
-    mem_replace::MEM_REPLACE_WITH_UNINIT,
-    methods::BIND_INSTEAD_OF_MAP,
-    methods::BYTES_COUNT_TO_LEN,
-    methods::BYTES_NTH,
-    methods::CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS,
-    methods::CHARS_LAST_CMP,
-    methods::CHARS_NEXT_CMP,
-    methods::CLONED_INSTEAD_OF_COPIED,
-    methods::CLONE_DOUBLE_REF,
-    methods::CLONE_ON_COPY,
-    methods::CLONE_ON_REF_PTR,
-    methods::COLLAPSIBLE_STR_REPLACE,
-    methods::ERR_EXPECT,
-    methods::EXPECT_FUN_CALL,
-    methods::EXPECT_USED,
-    methods::EXTEND_WITH_DRAIN,
-    methods::FILETYPE_IS_FILE,
-    methods::FILTER_MAP_IDENTITY,
-    methods::FILTER_MAP_NEXT,
-    methods::FILTER_NEXT,
-    methods::FLAT_MAP_IDENTITY,
-    methods::FLAT_MAP_OPTION,
-    methods::FROM_ITER_INSTEAD_OF_COLLECT,
-    methods::GET_FIRST,
-    methods::GET_LAST_WITH_LEN,
-    methods::GET_UNWRAP,
-    methods::IMPLICIT_CLONE,
-    methods::INEFFICIENT_TO_STRING,
-    methods::INSPECT_FOR_EACH,
-    methods::INTO_ITER_ON_REF,
-    methods::IS_DIGIT_ASCII_RADIX,
-    methods::ITERATOR_STEP_BY_ZERO,
-    methods::ITER_CLONED_COLLECT,
-    methods::ITER_COUNT,
-    methods::ITER_KV_MAP,
-    methods::ITER_NEXT_SLICE,
-    methods::ITER_NTH,
-    methods::ITER_NTH_ZERO,
-    methods::ITER_ON_EMPTY_COLLECTIONS,
-    methods::ITER_ON_SINGLE_ITEMS,
-    methods::ITER_OVEREAGER_CLONED,
-    methods::ITER_SKIP_NEXT,
-    methods::ITER_WITH_DRAIN,
-    methods::MANUAL_FILTER_MAP,
-    methods::MANUAL_FIND_MAP,
-    methods::MANUAL_OK_OR,
-    methods::MANUAL_SATURATING_ARITHMETIC,
-    methods::MANUAL_SPLIT_ONCE,
-    methods::MANUAL_STR_REPEAT,
-    methods::MAP_CLONE,
-    methods::MAP_COLLECT_RESULT_UNIT,
-    methods::MAP_ERR_IGNORE,
-    methods::MAP_FLATTEN,
-    methods::MAP_IDENTITY,
-    methods::MAP_UNWRAP_OR,
-    methods::MUT_MUTEX_LOCK,
-    methods::NAIVE_BYTECOUNT,
-    methods::NEEDLESS_OPTION_AS_DEREF,
-    methods::NEEDLESS_OPTION_TAKE,
-    methods::NEEDLESS_SPLITN,
-    methods::NEW_RET_NO_SELF,
-    methods::NONSENSICAL_OPEN_OPTIONS,
-    methods::NO_EFFECT_REPLACE,
-    methods::OBFUSCATED_IF_ELSE,
-    methods::OK_EXPECT,
-    methods::OPTION_AS_REF_DEREF,
-    methods::OPTION_FILTER_MAP,
-    methods::OPTION_MAP_OR_NONE,
-    methods::OR_FUN_CALL,
-    methods::OR_THEN_UNWRAP,
-    methods::PATH_BUF_PUSH_OVERWRITE,
-    methods::RANGE_ZIP_WITH_LEN,
-    methods::REPEAT_ONCE,
-    methods::RESULT_MAP_OR_INTO_OPTION,
-    methods::SEARCH_IS_SOME,
-    methods::SHOULD_IMPLEMENT_TRAIT,
-    methods::SINGLE_CHAR_ADD_STR,
-    methods::SINGLE_CHAR_PATTERN,
-    methods::SKIP_WHILE_NEXT,
-    methods::STABLE_SORT_PRIMITIVE,
-    methods::STRING_EXTEND_CHARS,
-    methods::SUSPICIOUS_MAP,
-    methods::SUSPICIOUS_SPLITN,
-    methods::SUSPICIOUS_TO_OWNED,
-    methods::UNINIT_ASSUMED_INIT,
-    methods::UNIT_HASH,
-    methods::UNNECESSARY_FILTER_MAP,
-    methods::UNNECESSARY_FIND_MAP,
-    methods::UNNECESSARY_FOLD,
-    methods::UNNECESSARY_JOIN,
-    methods::UNNECESSARY_LAZY_EVALUATIONS,
-    methods::UNNECESSARY_SORT_BY,
-    methods::UNNECESSARY_TO_OWNED,
-    methods::UNWRAP_OR_ELSE_DEFAULT,
-    methods::UNWRAP_USED,
-    methods::USELESS_ASREF,
-    methods::VEC_RESIZE_TO_ZERO,
-    methods::VERBOSE_FILE_READS,
-    methods::WRONG_SELF_CONVENTION,
-    methods::ZST_OFFSET,
-    minmax::MIN_MAX,
-    misc::SHORT_CIRCUIT_STATEMENT,
-    misc::TOPLEVEL_REF_ARG,
-    misc::USED_UNDERSCORE_BINDING,
-    misc::ZERO_PTR,
-    misc_early::BUILTIN_TYPE_SHADOW,
-    misc_early::DOUBLE_NEG,
-    misc_early::DUPLICATE_UNDERSCORE_ARGUMENT,
-    misc_early::MIXED_CASE_HEX_LITERALS,
-    misc_early::REDUNDANT_PATTERN,
-    misc_early::SEPARATED_LITERAL_SUFFIX,
-    misc_early::UNNEEDED_FIELD_PATTERN,
-    misc_early::UNNEEDED_WILDCARD_PATTERN,
-    misc_early::UNSEPARATED_LITERAL_SUFFIX,
-    misc_early::ZERO_PREFIXED_LITERAL,
-    mismatching_type_param_order::MISMATCHING_TYPE_PARAM_ORDER,
-    missing_const_for_fn::MISSING_CONST_FOR_FN,
-    missing_doc::MISSING_DOCS_IN_PRIVATE_ITEMS,
-    missing_enforced_import_rename::MISSING_ENFORCED_IMPORT_RENAMES,
-    missing_inline::MISSING_INLINE_IN_PUBLIC_ITEMS,
-    missing_trait_methods::MISSING_TRAIT_METHODS,
-    mixed_read_write_in_expression::DIVERGING_SUB_EXPRESSION,
-    mixed_read_write_in_expression::MIXED_READ_WRITE_IN_EXPRESSION,
-    module_style::MOD_MODULE_FILES,
-    module_style::SELF_NAMED_MODULE_FILES,
-    multi_assignments::MULTI_ASSIGNMENTS,
-    mut_key::MUTABLE_KEY_TYPE,
-    mut_mut::MUT_MUT,
-    mut_reference::UNNECESSARY_MUT_PASSED,
-    mutable_debug_assertion::DEBUG_ASSERT_WITH_MUT_CALL,
-    mutex_atomic::MUTEX_ATOMIC,
-    mutex_atomic::MUTEX_INTEGER,
-    needless_arbitrary_self_type::NEEDLESS_ARBITRARY_SELF_TYPE,
-    needless_bool::BOOL_COMPARISON,
-    needless_bool::NEEDLESS_BOOL,
-    needless_borrowed_ref::NEEDLESS_BORROWED_REFERENCE,
-    needless_continue::NEEDLESS_CONTINUE,
-    needless_for_each::NEEDLESS_FOR_EACH,
-    needless_late_init::NEEDLESS_LATE_INIT,
-    needless_parens_on_range_literals::NEEDLESS_PARENS_ON_RANGE_LITERALS,
-    needless_pass_by_value::NEEDLESS_PASS_BY_VALUE,
-    needless_question_mark::NEEDLESS_QUESTION_MARK,
-    needless_update::NEEDLESS_UPDATE,
-    neg_cmp_op_on_partial_ord::NEG_CMP_OP_ON_PARTIAL_ORD,
-    neg_multiply::NEG_MULTIPLY,
-    new_without_default::NEW_WITHOUT_DEFAULT,
-    no_effect::NO_EFFECT,
-    no_effect::NO_EFFECT_UNDERSCORE_BINDING,
-    no_effect::UNNECESSARY_OPERATION,
-    non_copy_const::BORROW_INTERIOR_MUTABLE_CONST,
-    non_copy_const::DECLARE_INTERIOR_MUTABLE_CONST,
-    non_expressive_names::JUST_UNDERSCORES_AND_DIGITS,
-    non_expressive_names::MANY_SINGLE_CHAR_NAMES,
-    non_expressive_names::SIMILAR_NAMES,
-    non_octal_unix_permissions::NON_OCTAL_UNIX_PERMISSIONS,
-    non_send_fields_in_send_ty::NON_SEND_FIELDS_IN_SEND_TY,
-    nonstandard_macro_braces::NONSTANDARD_MACRO_BRACES,
-    octal_escapes::OCTAL_ESCAPES,
-    only_used_in_recursion::ONLY_USED_IN_RECURSION,
-    operators::ABSURD_EXTREME_COMPARISONS,
-    operators::ARITHMETIC_SIDE_EFFECTS,
-    operators::ASSIGN_OP_PATTERN,
-    operators::BAD_BIT_MASK,
-    operators::CMP_NAN,
-    operators::CMP_OWNED,
-    operators::DOUBLE_COMPARISONS,
-    operators::DURATION_SUBSEC,
-    operators::EQ_OP,
-    operators::ERASING_OP,
-    operators::FLOAT_ARITHMETIC,
-    operators::FLOAT_CMP,
-    operators::FLOAT_CMP_CONST,
-    operators::FLOAT_EQUALITY_WITHOUT_ABS,
-    operators::IDENTITY_OP,
-    operators::INEFFECTIVE_BIT_MASK,
-    operators::INTEGER_ARITHMETIC,
-    operators::INTEGER_DIVISION,
-    operators::MISREFACTORED_ASSIGN_OP,
-    operators::MODULO_ARITHMETIC,
-    operators::MODULO_ONE,
-    operators::NEEDLESS_BITWISE_BOOL,
-    operators::OP_REF,
-    operators::PTR_EQ,
-    operators::SELF_ASSIGNMENT,
-    operators::VERBOSE_BIT_MASK,
-    option_env_unwrap::OPTION_ENV_UNWRAP,
-    option_if_let_else::OPTION_IF_LET_ELSE,
-    overflow_check_conditional::OVERFLOW_CHECK_CONDITIONAL,
-    panic_in_result_fn::PANIC_IN_RESULT_FN,
-    panic_unimplemented::PANIC,
-    panic_unimplemented::TODO,
-    panic_unimplemented::UNIMPLEMENTED,
-    panic_unimplemented::UNREACHABLE,
-    partial_pub_fields::PARTIAL_PUB_FIELDS,
-    partialeq_ne_impl::PARTIALEQ_NE_IMPL,
-    partialeq_to_none::PARTIALEQ_TO_NONE,
-    pass_by_ref_or_value::LARGE_TYPES_PASSED_BY_VALUE,
-    pass_by_ref_or_value::TRIVIALLY_COPY_PASS_BY_REF,
-    pattern_type_mismatch::PATTERN_TYPE_MISMATCH,
-    precedence::PRECEDENCE,
-    ptr::CMP_NULL,
-    ptr::INVALID_NULL_PTR_USAGE,
-    ptr::MUT_FROM_REF,
-    ptr::PTR_ARG,
-    ptr_offset_with_cast::PTR_OFFSET_WITH_CAST,
-    pub_use::PUB_USE,
-    question_mark::QUESTION_MARK,
-    ranges::MANUAL_RANGE_CONTAINS,
-    ranges::RANGE_MINUS_ONE,
-    ranges::RANGE_PLUS_ONE,
-    ranges::REVERSED_EMPTY_RANGES,
-    rc_clone_in_vec_init::RC_CLONE_IN_VEC_INIT,
-    read_zero_byte_vec::READ_ZERO_BYTE_VEC,
-    redundant_clone::REDUNDANT_CLONE,
-    redundant_closure_call::REDUNDANT_CLOSURE_CALL,
-    redundant_else::REDUNDANT_ELSE,
-    redundant_field_names::REDUNDANT_FIELD_NAMES,
-    redundant_pub_crate::REDUNDANT_PUB_CRATE,
-    redundant_slicing::DEREF_BY_SLICING,
-    redundant_slicing::REDUNDANT_SLICING,
-    redundant_static_lifetimes::REDUNDANT_STATIC_LIFETIMES,
-    ref_option_ref::REF_OPTION_REF,
-    reference::DEREF_ADDROF,
-    regex::INVALID_REGEX,
-    regex::TRIVIAL_REGEX,
-    return_self_not_must_use::RETURN_SELF_NOT_MUST_USE,
-    returns::LET_AND_RETURN,
-    returns::NEEDLESS_RETURN,
-    same_name_method::SAME_NAME_METHOD,
-    self_named_constructors::SELF_NAMED_CONSTRUCTORS,
-    semicolon_if_nothing_returned::SEMICOLON_IF_NOTHING_RETURNED,
-    serde_api::SERDE_API_MISUSE,
-    shadow::SHADOW_REUSE,
-    shadow::SHADOW_SAME,
-    shadow::SHADOW_UNRELATED,
-    single_char_lifetime_names::SINGLE_CHAR_LIFETIME_NAMES,
-    single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS,
-    size_of_in_element_count::SIZE_OF_IN_ELEMENT_COUNT,
-    slow_vector_initialization::SLOW_VECTOR_INITIALIZATION,
-    std_instead_of_core::ALLOC_INSTEAD_OF_CORE,
-    std_instead_of_core::STD_INSTEAD_OF_ALLOC,
-    std_instead_of_core::STD_INSTEAD_OF_CORE,
-    strings::STRING_ADD,
-    strings::STRING_ADD_ASSIGN,
-    strings::STRING_FROM_UTF8_AS_BYTES,
-    strings::STRING_LIT_AS_BYTES,
-    strings::STRING_SLICE,
-    strings::STRING_TO_STRING,
-    strings::STR_TO_STRING,
-    strings::TRIM_SPLIT_WHITESPACE,
-    strlen_on_c_strings::STRLEN_ON_C_STRINGS,
-    suspicious_operation_groupings::SUSPICIOUS_OPERATION_GROUPINGS,
-    suspicious_trait_impl::SUSPICIOUS_ARITHMETIC_IMPL,
-    suspicious_trait_impl::SUSPICIOUS_OP_ASSIGN_IMPL,
-    suspicious_xor_used_as_pow::SUSPICIOUS_XOR_USED_AS_POW,
-    swap::ALMOST_SWAPPED,
-    swap::MANUAL_SWAP,
-    swap_ptr_to_ref::SWAP_PTR_TO_REF,
-    tabs_in_doc_comments::TABS_IN_DOC_COMMENTS,
-    temporary_assignment::TEMPORARY_ASSIGNMENT,
-    to_digit_is_some::TO_DIGIT_IS_SOME,
-    trailing_empty_array::TRAILING_EMPTY_ARRAY,
-    trait_bounds::TRAIT_DUPLICATION_IN_BOUNDS,
-    trait_bounds::TYPE_REPETITION_IN_BOUNDS,
-    transmute::CROSSPOINTER_TRANSMUTE,
-    transmute::TRANSMUTES_EXPRESSIBLE_AS_PTR_CASTS,
-    transmute::TRANSMUTE_BYTES_TO_STR,
-    transmute::TRANSMUTE_FLOAT_TO_INT,
-    transmute::TRANSMUTE_INT_TO_BOOL,
-    transmute::TRANSMUTE_INT_TO_CHAR,
-    transmute::TRANSMUTE_INT_TO_FLOAT,
-    transmute::TRANSMUTE_NUM_TO_BYTES,
-    transmute::TRANSMUTE_PTR_TO_PTR,
-    transmute::TRANSMUTE_PTR_TO_REF,
-    transmute::TRANSMUTE_UNDEFINED_REPR,
-    transmute::TRANSMUTING_NULL,
-    transmute::UNSOUND_COLLECTION_TRANSMUTE,
-    transmute::USELESS_TRANSMUTE,
-    transmute::WRONG_TRANSMUTE,
-    types::BORROWED_BOX,
-    types::BOX_COLLECTION,
-    types::LINKEDLIST,
-    types::OPTION_OPTION,
-    types::RC_BUFFER,
-    types::RC_MUTEX,
-    types::REDUNDANT_ALLOCATION,
-    types::TYPE_COMPLEXITY,
-    types::VEC_BOX,
-    undocumented_unsafe_blocks::UNDOCUMENTED_UNSAFE_BLOCKS,
-    unicode::INVISIBLE_CHARACTERS,
-    unicode::NON_ASCII_LITERAL,
-    unicode::UNICODE_NOT_NFC,
-    uninit_vec::UNINIT_VEC,
-    unit_return_expecting_ord::UNIT_RETURN_EXPECTING_ORD,
-    unit_types::LET_UNIT_VALUE,
-    unit_types::UNIT_ARG,
-    unit_types::UNIT_CMP,
-    unnamed_address::FN_ADDRESS_COMPARISONS,
-    unnamed_address::VTABLE_ADDRESS_COMPARISONS,
-    unnecessary_owned_empty_strings::UNNECESSARY_OWNED_EMPTY_STRINGS,
-    unnecessary_self_imports::UNNECESSARY_SELF_IMPORTS,
-    unnecessary_wraps::UNNECESSARY_WRAPS,
-    unnested_or_patterns::UNNESTED_OR_PATTERNS,
-    unsafe_removed_from_name::UNSAFE_REMOVED_FROM_NAME,
-    unused_async::UNUSED_ASYNC,
-    unused_io_amount::UNUSED_IO_AMOUNT,
-    unused_peekable::UNUSED_PEEKABLE,
-    unused_rounding::UNUSED_ROUNDING,
-    unused_self::UNUSED_SELF,
-    unused_unit::UNUSED_UNIT,
-    unwrap::PANICKING_UNWRAP,
-    unwrap::UNNECESSARY_UNWRAP,
-    unwrap_in_result::UNWRAP_IN_RESULT,
-    upper_case_acronyms::UPPER_CASE_ACRONYMS,
-    use_self::USE_SELF,
-    useless_conversion::USELESS_CONVERSION,
-    vec::USELESS_VEC,
-    vec_init_then_push::VEC_INIT_THEN_PUSH,
-    wildcard_imports::ENUM_GLOB_USE,
-    wildcard_imports::WILDCARD_IMPORTS,
-    write::PRINTLN_EMPTY_STRING,
-    write::PRINT_LITERAL,
-    write::PRINT_STDERR,
-    write::PRINT_STDOUT,
-    write::PRINT_WITH_NEWLINE,
-    write::USE_DEBUG,
-    write::WRITELN_EMPTY_STRING,
-    write::WRITE_LITERAL,
-    write::WRITE_WITH_NEWLINE,
-    zero_div_zero::ZERO_DIVIDED_BY_ZERO,
-    zero_sized_map_values::ZERO_SIZED_MAP_VALUES,
-])
diff --git a/clippy_lints/src/lib.register_restriction.rs b/clippy_lints/src/lib.register_restriction.rs
deleted file mode 100644
index aa82966f8e5..00000000000
--- a/clippy_lints/src/lib.register_restriction.rs
+++ /dev/null
@@ -1,91 +0,0 @@
-// This file was generated by `cargo dev update_lints`.
-// Use that command to update this file and do not edit by hand.
-// Manual edits will be overwritten.
-
-store.register_group(true, "clippy::restriction", Some("clippy_restriction"), vec![
-    LintId::of(as_conversions::AS_CONVERSIONS),
-    LintId::of(asm_syntax::INLINE_ASM_X86_ATT_SYNTAX),
-    LintId::of(asm_syntax::INLINE_ASM_X86_INTEL_SYNTAX),
-    LintId::of(assertions_on_result_states::ASSERTIONS_ON_RESULT_STATES),
-    LintId::of(attrs::ALLOW_ATTRIBUTES_WITHOUT_REASON),
-    LintId::of(casts::AS_UNDERSCORE),
-    LintId::of(casts::FN_TO_NUMERIC_CAST_ANY),
-    LintId::of(create_dir::CREATE_DIR),
-    LintId::of(dbg_macro::DBG_MACRO),
-    LintId::of(default_numeric_fallback::DEFAULT_NUMERIC_FALLBACK),
-    LintId::of(default_union_representation::DEFAULT_UNION_REPRESENTATION),
-    LintId::of(disallowed_script_idents::DISALLOWED_SCRIPT_IDENTS),
-    LintId::of(else_if_without_else::ELSE_IF_WITHOUT_ELSE),
-    LintId::of(empty_drop::EMPTY_DROP),
-    LintId::of(empty_structs_with_brackets::EMPTY_STRUCTS_WITH_BRACKETS),
-    LintId::of(exhaustive_items::EXHAUSTIVE_ENUMS),
-    LintId::of(exhaustive_items::EXHAUSTIVE_STRUCTS),
-    LintId::of(exit::EXIT),
-    LintId::of(float_literal::LOSSY_FLOAT_LITERAL),
-    LintId::of(format_push_string::FORMAT_PUSH_STRING),
-    LintId::of(if_then_some_else_none::IF_THEN_SOME_ELSE_NONE),
-    LintId::of(implicit_return::IMPLICIT_RETURN),
-    LintId::of(indexing_slicing::INDEXING_SLICING),
-    LintId::of(inherent_impl::MULTIPLE_INHERENT_IMPL),
-    LintId::of(large_include_file::LARGE_INCLUDE_FILE),
-    LintId::of(let_underscore::LET_UNDERSCORE_MUST_USE),
-    LintId::of(literal_representation::DECIMAL_LITERAL_REPRESENTATION),
-    LintId::of(matches::REST_PAT_IN_FULLY_BOUND_STRUCTS),
-    LintId::of(matches::TRY_ERR),
-    LintId::of(matches::WILDCARD_ENUM_MATCH_ARM),
-    LintId::of(mem_forget::MEM_FORGET),
-    LintId::of(methods::CLONE_ON_REF_PTR),
-    LintId::of(methods::EXPECT_USED),
-    LintId::of(methods::FILETYPE_IS_FILE),
-    LintId::of(methods::GET_UNWRAP),
-    LintId::of(methods::MAP_ERR_IGNORE),
-    LintId::of(methods::UNWRAP_USED),
-    LintId::of(methods::VERBOSE_FILE_READS),
-    LintId::of(misc_early::SEPARATED_LITERAL_SUFFIX),
-    LintId::of(misc_early::UNNEEDED_FIELD_PATTERN),
-    LintId::of(misc_early::UNSEPARATED_LITERAL_SUFFIX),
-    LintId::of(missing_doc::MISSING_DOCS_IN_PRIVATE_ITEMS),
-    LintId::of(missing_enforced_import_rename::MISSING_ENFORCED_IMPORT_RENAMES),
-    LintId::of(missing_inline::MISSING_INLINE_IN_PUBLIC_ITEMS),
-    LintId::of(missing_trait_methods::MISSING_TRAIT_METHODS),
-    LintId::of(mixed_read_write_in_expression::MIXED_READ_WRITE_IN_EXPRESSION),
-    LintId::of(module_style::MOD_MODULE_FILES),
-    LintId::of(module_style::SELF_NAMED_MODULE_FILES),
-    LintId::of(operators::ARITHMETIC_SIDE_EFFECTS),
-    LintId::of(operators::FLOAT_ARITHMETIC),
-    LintId::of(operators::FLOAT_CMP_CONST),
-    LintId::of(operators::INTEGER_ARITHMETIC),
-    LintId::of(operators::INTEGER_DIVISION),
-    LintId::of(operators::MODULO_ARITHMETIC),
-    LintId::of(panic_in_result_fn::PANIC_IN_RESULT_FN),
-    LintId::of(panic_unimplemented::PANIC),
-    LintId::of(panic_unimplemented::TODO),
-    LintId::of(panic_unimplemented::UNIMPLEMENTED),
-    LintId::of(panic_unimplemented::UNREACHABLE),
-    LintId::of(partial_pub_fields::PARTIAL_PUB_FIELDS),
-    LintId::of(pattern_type_mismatch::PATTERN_TYPE_MISMATCH),
-    LintId::of(pub_use::PUB_USE),
-    LintId::of(redundant_slicing::DEREF_BY_SLICING),
-    LintId::of(same_name_method::SAME_NAME_METHOD),
-    LintId::of(shadow::SHADOW_REUSE),
-    LintId::of(shadow::SHADOW_SAME),
-    LintId::of(shadow::SHADOW_UNRELATED),
-    LintId::of(single_char_lifetime_names::SINGLE_CHAR_LIFETIME_NAMES),
-    LintId::of(std_instead_of_core::ALLOC_INSTEAD_OF_CORE),
-    LintId::of(std_instead_of_core::STD_INSTEAD_OF_ALLOC),
-    LintId::of(std_instead_of_core::STD_INSTEAD_OF_CORE),
-    LintId::of(strings::STRING_ADD),
-    LintId::of(strings::STRING_SLICE),
-    LintId::of(strings::STRING_TO_STRING),
-    LintId::of(strings::STR_TO_STRING),
-    LintId::of(suspicious_xor_used_as_pow::SUSPICIOUS_XOR_USED_AS_POW),
-    LintId::of(types::RC_BUFFER),
-    LintId::of(types::RC_MUTEX),
-    LintId::of(undocumented_unsafe_blocks::UNDOCUMENTED_UNSAFE_BLOCKS),
-    LintId::of(unicode::NON_ASCII_LITERAL),
-    LintId::of(unnecessary_self_imports::UNNECESSARY_SELF_IMPORTS),
-    LintId::of(unwrap_in_result::UNWRAP_IN_RESULT),
-    LintId::of(write::PRINT_STDERR),
-    LintId::of(write::PRINT_STDOUT),
-    LintId::of(write::USE_DEBUG),
-])
diff --git a/src/docs.rs b/src/docs.rs
deleted file mode 100644
index 0f46e3f0842..00000000000
--- a/src/docs.rs
+++ /dev/null
@@ -1,607 +0,0 @@
-// autogenerated. Please look at /clippy_dev/src/update_lints.rs
-
-macro_rules! include_lint {
-    ($file_name: expr) => {
-        include_str!($file_name)
-    };
-}
-
-macro_rules! docs {
-    ($($lint_name: expr,)*) => {
-        pub fn explain(lint: &str) {
-            println!("{}", match lint {
-                $(
-                    $lint_name => include_lint!(concat!("docs/", concat!($lint_name, ".txt"))),
-                )*
-                _ => "unknown lint",
-            })
-        }
-    }
-}
-
-docs! {
-    "absurd_extreme_comparisons",
-    "alloc_instead_of_core",
-    "allow_attributes_without_reason",
-    "almost_complete_letter_range",
-    "almost_swapped",
-    "approx_constant",
-    "arithmetic_side_effects",
-    "as_conversions",
-    "as_ptr_cast_mut",
-    "as_underscore",
-    "assertions_on_constants",
-    "assertions_on_result_states",
-    "assign_op_pattern",
-    "async_yields_async",
-    "await_holding_invalid_type",
-    "await_holding_lock",
-    "await_holding_refcell_ref",
-    "bad_bit_mask",
-    "bind_instead_of_map",
-    "blanket_clippy_restriction_lints",
-    "blocks_in_if_conditions",
-    "bool_assert_comparison",
-    "bool_comparison",
-    "bool_to_int_with_if",
-    "borrow_as_ptr",
-    "borrow_deref_ref",
-    "borrow_interior_mutable_const",
-    "borrowed_box",
-    "box_collection",
-    "box_default",
-    "boxed_local",
-    "branches_sharing_code",
-    "builtin_type_shadow",
-    "bytes_count_to_len",
-    "bytes_nth",
-    "cargo_common_metadata",
-    "case_sensitive_file_extension_comparisons",
-    "cast_abs_to_unsigned",
-    "cast_enum_constructor",
-    "cast_enum_truncation",
-    "cast_lossless",
-    "cast_nan_to_int",
-    "cast_possible_truncation",
-    "cast_possible_wrap",
-    "cast_precision_loss",
-    "cast_ptr_alignment",
-    "cast_ref_to_mut",
-    "cast_sign_loss",
-    "cast_slice_different_sizes",
-    "cast_slice_from_raw_parts",
-    "char_lit_as_u8",
-    "chars_last_cmp",
-    "chars_next_cmp",
-    "checked_conversions",
-    "clone_double_ref",
-    "clone_on_copy",
-    "clone_on_ref_ptr",
-    "cloned_instead_of_copied",
-    "cmp_nan",
-    "cmp_null",
-    "cmp_owned",
-    "cognitive_complexity",
-    "collapsible_else_if",
-    "collapsible_if",
-    "collapsible_match",
-    "collapsible_str_replace",
-    "comparison_chain",
-    "comparison_to_empty",
-    "copy_iterator",
-    "crate_in_macro_def",
-    "create_dir",
-    "crosspointer_transmute",
-    "dbg_macro",
-    "debug_assert_with_mut_call",
-    "decimal_literal_representation",
-    "declare_interior_mutable_const",
-    "default_instead_of_iter_empty",
-    "default_numeric_fallback",
-    "default_trait_access",
-    "default_union_representation",
-    "deprecated_cfg_attr",
-    "deprecated_semver",
-    "deref_addrof",
-    "deref_by_slicing",
-    "derivable_impls",
-    "derive_hash_xor_eq",
-    "derive_ord_xor_partial_ord",
-    "derive_partial_eq_without_eq",
-    "disallowed_macros",
-    "disallowed_methods",
-    "disallowed_names",
-    "disallowed_script_idents",
-    "disallowed_types",
-    "diverging_sub_expression",
-    "doc_link_with_quotes",
-    "doc_markdown",
-    "double_comparisons",
-    "double_must_use",
-    "double_neg",
-    "double_parens",
-    "drop_copy",
-    "drop_non_drop",
-    "drop_ref",
-    "duplicate_mod",
-    "duplicate_underscore_argument",
-    "duration_subsec",
-    "else_if_without_else",
-    "empty_drop",
-    "empty_enum",
-    "empty_line_after_outer_attr",
-    "empty_loop",
-    "empty_structs_with_brackets",
-    "enum_clike_unportable_variant",
-    "enum_glob_use",
-    "enum_variant_names",
-    "eq_op",
-    "equatable_if_let",
-    "erasing_op",
-    "err_expect",
-    "excessive_precision",
-    "exhaustive_enums",
-    "exhaustive_structs",
-    "exit",
-    "expect_fun_call",
-    "expect_used",
-    "expl_impl_clone_on_copy",
-    "explicit_auto_deref",
-    "explicit_counter_loop",
-    "explicit_deref_methods",
-    "explicit_into_iter_loop",
-    "explicit_iter_loop",
-    "explicit_write",
-    "extend_with_drain",
-    "extra_unused_lifetimes",
-    "fallible_impl_from",
-    "field_reassign_with_default",
-    "filetype_is_file",
-    "filter_map_identity",
-    "filter_map_next",
-    "filter_next",
-    "flat_map_identity",
-    "flat_map_option",
-    "float_arithmetic",
-    "float_cmp",
-    "float_cmp_const",
-    "float_equality_without_abs",
-    "fn_address_comparisons",
-    "fn_params_excessive_bools",
-    "fn_to_numeric_cast",
-    "fn_to_numeric_cast_any",
-    "fn_to_numeric_cast_with_truncation",
-    "for_kv_map",
-    "forget_copy",
-    "forget_non_drop",
-    "forget_ref",
-    "format_in_format_args",
-    "format_push_string",
-    "from_iter_instead_of_collect",
-    "from_over_into",
-    "from_str_radix_10",
-    "future_not_send",
-    "get_first",
-    "get_last_with_len",
-    "get_unwrap",
-    "identity_op",
-    "if_let_mutex",
-    "if_not_else",
-    "if_same_then_else",
-    "if_then_some_else_none",
-    "ifs_same_cond",
-    "implicit_clone",
-    "implicit_hasher",
-    "implicit_return",
-    "implicit_saturating_add",
-    "implicit_saturating_sub",
-    "imprecise_flops",
-    "inconsistent_digit_grouping",
-    "inconsistent_struct_constructor",
-    "index_refutable_slice",
-    "indexing_slicing",
-    "ineffective_bit_mask",
-    "inefficient_to_string",
-    "infallible_destructuring_match",
-    "infinite_iter",
-    "inherent_to_string",
-    "inherent_to_string_shadow_display",
-    "init_numbered_fields",
-    "inline_always",
-    "inline_asm_x86_att_syntax",
-    "inline_asm_x86_intel_syntax",
-    "inline_fn_without_body",
-    "inspect_for_each",
-    "int_plus_one",
-    "integer_arithmetic",
-    "integer_division",
-    "into_iter_on_ref",
-    "invalid_null_ptr_usage",
-    "invalid_regex",
-    "invalid_upcast_comparisons",
-    "invalid_utf8_in_unchecked",
-    "invisible_characters",
-    "is_digit_ascii_radix",
-    "items_after_statements",
-    "iter_cloned_collect",
-    "iter_count",
-    "iter_kv_map",
-    "iter_next_loop",
-    "iter_next_slice",
-    "iter_not_returning_iterator",
-    "iter_nth",
-    "iter_nth_zero",
-    "iter_on_empty_collections",
-    "iter_on_single_items",
-    "iter_overeager_cloned",
-    "iter_skip_next",
-    "iter_with_drain",
-    "iterator_step_by_zero",
-    "just_underscores_and_digits",
-    "large_const_arrays",
-    "large_digit_groups",
-    "large_enum_variant",
-    "large_include_file",
-    "large_stack_arrays",
-    "large_types_passed_by_value",
-    "len_without_is_empty",
-    "len_zero",
-    "let_and_return",
-    "let_underscore_drop",
-    "let_underscore_lock",
-    "let_underscore_must_use",
-    "let_unit_value",
-    "linkedlist",
-    "lossy_float_literal",
-    "macro_use_imports",
-    "main_recursion",
-    "manual_assert",
-    "manual_async_fn",
-    "manual_bits",
-    "manual_clamp",
-    "manual_filter",
-    "manual_filter_map",
-    "manual_find",
-    "manual_find_map",
-    "manual_flatten",
-    "manual_instant_elapsed",
-    "manual_map",
-    "manual_memcpy",
-    "manual_non_exhaustive",
-    "manual_ok_or",
-    "manual_range_contains",
-    "manual_rem_euclid",
-    "manual_retain",
-    "manual_saturating_arithmetic",
-    "manual_split_once",
-    "manual_str_repeat",
-    "manual_string_new",
-    "manual_strip",
-    "manual_swap",
-    "manual_unwrap_or",
-    "many_single_char_names",
-    "map_clone",
-    "map_collect_result_unit",
-    "map_entry",
-    "map_err_ignore",
-    "map_flatten",
-    "map_identity",
-    "map_unwrap_or",
-    "match_as_ref",
-    "match_bool",
-    "match_like_matches_macro",
-    "match_on_vec_items",
-    "match_overlapping_arm",
-    "match_ref_pats",
-    "match_result_ok",
-    "match_same_arms",
-    "match_single_binding",
-    "match_str_case_mismatch",
-    "match_wild_err_arm",
-    "match_wildcard_for_single_variants",
-    "maybe_infinite_iter",
-    "mem_forget",
-    "mem_replace_option_with_none",
-    "mem_replace_with_default",
-    "mem_replace_with_uninit",
-    "min_max",
-    "mismatched_target_os",
-    "mismatching_type_param_order",
-    "misrefactored_assign_op",
-    "missing_const_for_fn",
-    "missing_docs_in_private_items",
-    "missing_enforced_import_renames",
-    "missing_errors_doc",
-    "missing_inline_in_public_items",
-    "missing_panics_doc",
-    "missing_safety_doc",
-    "missing_spin_loop",
-    "missing_trait_methods",
-    "mistyped_literal_suffixes",
-    "mixed_case_hex_literals",
-    "mixed_read_write_in_expression",
-    "mod_module_files",
-    "module_inception",
-    "module_name_repetitions",
-    "modulo_arithmetic",
-    "modulo_one",
-    "multi_assignments",
-    "multiple_crate_versions",
-    "multiple_inherent_impl",
-    "must_use_candidate",
-    "must_use_unit",
-    "mut_from_ref",
-    "mut_mut",
-    "mut_mutex_lock",
-    "mut_range_bound",
-    "mutable_key_type",
-    "mutex_atomic",
-    "mutex_integer",
-    "naive_bytecount",
-    "needless_arbitrary_self_type",
-    "needless_bitwise_bool",
-    "needless_bool",
-    "needless_borrow",
-    "needless_borrowed_reference",
-    "needless_collect",
-    "needless_continue",
-    "needless_doctest_main",
-    "needless_for_each",
-    "needless_late_init",
-    "needless_lifetimes",
-    "needless_match",
-    "needless_option_as_deref",
-    "needless_option_take",
-    "needless_parens_on_range_literals",
-    "needless_pass_by_value",
-    "needless_question_mark",
-    "needless_range_loop",
-    "needless_return",
-    "needless_splitn",
-    "needless_update",
-    "neg_cmp_op_on_partial_ord",
-    "neg_multiply",
-    "negative_feature_names",
-    "never_loop",
-    "new_ret_no_self",
-    "new_without_default",
-    "no_effect",
-    "no_effect_replace",
-    "no_effect_underscore_binding",
-    "non_ascii_literal",
-    "non_octal_unix_permissions",
-    "non_send_fields_in_send_ty",
-    "nonminimal_bool",
-    "nonsensical_open_options",
-    "nonstandard_macro_braces",
-    "not_unsafe_ptr_arg_deref",
-    "obfuscated_if_else",
-    "octal_escapes",
-    "ok_expect",
-    "only_used_in_recursion",
-    "op_ref",
-    "option_as_ref_deref",
-    "option_env_unwrap",
-    "option_filter_map",
-    "option_if_let_else",
-    "option_map_or_none",
-    "option_map_unit_fn",
-    "option_option",
-    "or_fun_call",
-    "or_then_unwrap",
-    "out_of_bounds_indexing",
-    "overflow_check_conditional",
-    "overly_complex_bool_expr",
-    "panic",
-    "panic_in_result_fn",
-    "panicking_unwrap",
-    "partial_pub_fields",
-    "partialeq_ne_impl",
-    "partialeq_to_none",
-    "path_buf_push_overwrite",
-    "pattern_type_mismatch",
-    "possible_missing_comma",
-    "precedence",
-    "print_in_format_impl",
-    "print_literal",
-    "print_stderr",
-    "print_stdout",
-    "print_with_newline",
-    "println_empty_string",
-    "ptr_arg",
-    "ptr_as_ptr",
-    "ptr_eq",
-    "ptr_offset_with_cast",
-    "pub_use",
-    "question_mark",
-    "range_minus_one",
-    "range_plus_one",
-    "range_zip_with_len",
-    "rc_buffer",
-    "rc_clone_in_vec_init",
-    "rc_mutex",
-    "read_zero_byte_vec",
-    "recursive_format_impl",
-    "redundant_allocation",
-    "redundant_clone",
-    "redundant_closure",
-    "redundant_closure_call",
-    "redundant_closure_for_method_calls",
-    "redundant_else",
-    "redundant_feature_names",
-    "redundant_field_names",
-    "redundant_pattern",
-    "redundant_pattern_matching",
-    "redundant_pub_crate",
-    "redundant_slicing",
-    "redundant_static_lifetimes",
-    "ref_binding_to_reference",
-    "ref_option_ref",
-    "repeat_once",
-    "rest_pat_in_fully_bound_structs",
-    "result_large_err",
-    "result_map_or_into_option",
-    "result_map_unit_fn",
-    "result_unit_err",
-    "return_self_not_must_use",
-    "reversed_empty_ranges",
-    "same_functions_in_if_condition",
-    "same_item_push",
-    "same_name_method",
-    "search_is_some",
-    "self_assignment",
-    "self_named_constructors",
-    "self_named_module_files",
-    "semicolon_if_nothing_returned",
-    "separated_literal_suffix",
-    "serde_api_misuse",
-    "shadow_reuse",
-    "shadow_same",
-    "shadow_unrelated",
-    "short_circuit_statement",
-    "should_implement_trait",
-    "significant_drop_in_scrutinee",
-    "similar_names",
-    "single_char_add_str",
-    "single_char_lifetime_names",
-    "single_char_pattern",
-    "single_component_path_imports",
-    "single_element_loop",
-    "single_match",
-    "single_match_else",
-    "size_of_in_element_count",
-    "skip_while_next",
-    "slow_vector_initialization",
-    "stable_sort_primitive",
-    "std_instead_of_alloc",
-    "std_instead_of_core",
-    "str_to_string",
-    "string_add",
-    "string_add_assign",
-    "string_extend_chars",
-    "string_from_utf8_as_bytes",
-    "string_lit_as_bytes",
-    "string_slice",
-    "string_to_string",
-    "strlen_on_c_strings",
-    "struct_excessive_bools",
-    "suboptimal_flops",
-    "suspicious_arithmetic_impl",
-    "suspicious_assignment_formatting",
-    "suspicious_else_formatting",
-    "suspicious_map",
-    "suspicious_op_assign_impl",
-    "suspicious_operation_groupings",
-    "suspicious_splitn",
-    "suspicious_to_owned",
-    "suspicious_unary_op_formatting",
-    "suspicious_xor_used_as_pow",
-    "swap_ptr_to_ref",
-    "tabs_in_doc_comments",
-    "temporary_assignment",
-    "to_digit_is_some",
-    "to_string_in_format_args",
-    "todo",
-    "too_many_arguments",
-    "too_many_lines",
-    "toplevel_ref_arg",
-    "trailing_empty_array",
-    "trait_duplication_in_bounds",
-    "transmute_bytes_to_str",
-    "transmute_float_to_int",
-    "transmute_int_to_bool",
-    "transmute_int_to_char",
-    "transmute_int_to_float",
-    "transmute_num_to_bytes",
-    "transmute_ptr_to_ptr",
-    "transmute_ptr_to_ref",
-    "transmute_undefined_repr",
-    "transmutes_expressible_as_ptr_casts",
-    "transmuting_null",
-    "trim_split_whitespace",
-    "trivial_regex",
-    "trivially_copy_pass_by_ref",
-    "try_err",
-    "type_complexity",
-    "type_repetition_in_bounds",
-    "undocumented_unsafe_blocks",
-    "undropped_manually_drops",
-    "unicode_not_nfc",
-    "unimplemented",
-    "uninit_assumed_init",
-    "uninit_vec",
-    "uninlined_format_args",
-    "unit_arg",
-    "unit_cmp",
-    "unit_hash",
-    "unit_return_expecting_ord",
-    "unnecessary_cast",
-    "unnecessary_filter_map",
-    "unnecessary_find_map",
-    "unnecessary_fold",
-    "unnecessary_join",
-    "unnecessary_lazy_evaluations",
-    "unnecessary_mut_passed",
-    "unnecessary_operation",
-    "unnecessary_owned_empty_strings",
-    "unnecessary_self_imports",
-    "unnecessary_sort_by",
-    "unnecessary_to_owned",
-    "unnecessary_unwrap",
-    "unnecessary_wraps",
-    "unneeded_field_pattern",
-    "unneeded_wildcard_pattern",
-    "unnested_or_patterns",
-    "unreachable",
-    "unreadable_literal",
-    "unsafe_derive_deserialize",
-    "unsafe_removed_from_name",
-    "unseparated_literal_suffix",
-    "unsound_collection_transmute",
-    "unused_async",
-    "unused_format_specs",
-    "unused_io_amount",
-    "unused_peekable",
-    "unused_rounding",
-    "unused_self",
-    "unused_unit",
-    "unusual_byte_groupings",
-    "unwrap_in_result",
-    "unwrap_or_else_default",
-    "unwrap_used",
-    "upper_case_acronyms",
-    "use_debug",
-    "use_self",
-    "used_underscore_binding",
-    "useless_asref",
-    "useless_attribute",
-    "useless_conversion",
-    "useless_format",
-    "useless_let_if_seq",
-    "useless_transmute",
-    "useless_vec",
-    "vec_box",
-    "vec_init_then_push",
-    "vec_resize_to_zero",
-    "verbose_bit_mask",
-    "verbose_file_reads",
-    "vtable_address_comparisons",
-    "while_immutable_condition",
-    "while_let_loop",
-    "while_let_on_iterator",
-    "wildcard_dependencies",
-    "wildcard_enum_match_arm",
-    "wildcard_imports",
-    "wildcard_in_or_patterns",
-    "write_literal",
-    "write_with_newline",
-    "writeln_empty_string",
-    "wrong_self_convention",
-    "wrong_transmute",
-    "zero_divided_by_zero",
-    "zero_prefixed_literal",
-    "zero_ptr",
-    "zero_sized_map_values",
-    "zst_offset",
-
-}
diff --git a/src/docs/suspicious_xor_used_as_pow.txt b/src/docs/suspicious_xor_used_as_pow.txt
deleted file mode 100644
index 2cae5497f0f..00000000000
--- a/src/docs/suspicious_xor_used_as_pow.txt
+++ /dev/null
@@ -1,12 +0,0 @@
-### What it does
-Warns for a Bitwise XOR (`^`) operator being probably confused as a powering. It will not trigger if any of the numbers are not in decimal.
-### Why is this bad?
-	It's most probably a typo and may lead to unexpected behaviours.
-### Example
-```
-let x = 3_i32 ^ 4_i32;
-```
-Use instead:
-```
-let x = 3_i32.pow(4);
-```
\ No newline at end of file
-- 
cgit 1.4.1-3-g733a5


From 98250af4a3835dd3e24595ab40b37ee79d72203a Mon Sep 17 00:00:00 2001
From: Elliot Bobrow <elliotgreybobrow@gmail.com>
Date: Tue, 25 Oct 2022 21:16:28 -0700
Subject: `question_mark` don't lint on `if let Err` with else

---
 clippy_lints/src/question_mark.rs | 1 +
 tests/ui/question_mark.fixed      | 3 +++
 tests/ui/question_mark.rs         | 3 +++
 tests/ui/question_mark.stderr     | 4 ++--
 4 files changed, 9 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/question_mark.rs b/clippy_lints/src/question_mark.rs
index 328371fd602..5644c2f72db 100644
--- a/clippy_lints/src/question_mark.rs
+++ b/clippy_lints/src/question_mark.rs
@@ -189,6 +189,7 @@ fn is_early_return(smbl: Symbol, cx: &LateContext<'_>, if_block: &IfBlockType<'_
                             && expr_return_none_or_err(smbl, cx, if_else.unwrap(), let_expr, Some(let_pat_sym)))
                             || is_res_lang_ctor(cx, res, ResultErr)
                                 && expr_return_none_or_err(smbl, cx, if_then, let_expr, Some(let_pat_sym))
+                                && if_else.is_none()
                     },
                     _ => false,
                 }
diff --git a/tests/ui/question_mark.fixed b/tests/ui/question_mark.fixed
index 993389232cc..5c49d46da72 100644
--- a/tests/ui/question_mark.fixed
+++ b/tests/ui/question_mark.fixed
@@ -134,6 +134,9 @@ fn result_func(x: Result<i32, i32>) -> Result<i32, i32> {
         return func_returning_result();
     }
 
+    // no warning
+    let _ = if let Err(e) = x { Err(e) } else { Ok(0) };
+
     Ok(y)
 }
 
diff --git a/tests/ui/question_mark.rs b/tests/ui/question_mark.rs
index 9ae0d88829a..d057df6a9b3 100644
--- a/tests/ui/question_mark.rs
+++ b/tests/ui/question_mark.rs
@@ -166,6 +166,9 @@ fn result_func(x: Result<i32, i32>) -> Result<i32, i32> {
         return func_returning_result();
     }
 
+    // no warning
+    let _ = if let Err(e) = x { Err(e) } else { Ok(0) };
+
     Ok(y)
 }
 
diff --git a/tests/ui/question_mark.stderr b/tests/ui/question_mark.stderr
index 1b6cd524b2f..23172d7e535 100644
--- a/tests/ui/question_mark.stderr
+++ b/tests/ui/question_mark.stderr
@@ -115,7 +115,7 @@ LL | |     }
    | |_____^ help: replace it with: `x?;`
 
 error: this block may be rewritten with the `?` operator
-  --> $DIR/question_mark.rs:193:5
+  --> $DIR/question_mark.rs:196:5
    |
 LL | /     if let Err(err) = func_returning_result() {
 LL | |         return Err(err);
@@ -123,7 +123,7 @@ LL | |     }
    | |_____^ help: replace it with: `func_returning_result()?;`
 
 error: this block may be rewritten with the `?` operator
-  --> $DIR/question_mark.rs:200:5
+  --> $DIR/question_mark.rs:203:5
    |
 LL | /     if let Err(err) = func_returning_result() {
 LL | |         return Err(err);
-- 
cgit 1.4.1-3-g733a5


From 770362a691cb2049e87595a2123a9912637cee15 Mon Sep 17 00:00:00 2001
From: Rageking8 <tomleetyt@gmail.com>
Date: Wed, 26 Oct 2022 12:24:37 +0800
Subject: fix dupe word typos

---
 clippy_lints/src/matches/significant_drop_in_scrutinee.rs | 2 +-
 clippy_utils/src/ty.rs                                    | 2 +-
 tests/ui/manual_flatten.rs                                | 2 +-
 tests/ui/mut_range_bound.rs                               | 2 +-
 tests/ui/mut_range_bound.stderr                           | 2 +-
 5 files changed, 5 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/significant_drop_in_scrutinee.rs b/clippy_lints/src/matches/significant_drop_in_scrutinee.rs
index 85269e533a0..93e4160c69b 100644
--- a/clippy_lints/src/matches/significant_drop_in_scrutinee.rs
+++ b/clippy_lints/src/matches/significant_drop_in_scrutinee.rs
@@ -226,7 +226,7 @@ impl<'a, 'tcx> SigDropHelper<'a, 'tcx> {
     /// This will try to set the current suggestion (so it can be moved into the suggestions vec
     /// later). If `allow_move_and_clone` is false, the suggestion *won't* be set -- this gives us
     /// an opportunity to look for another type in the chain that will be trivially copyable.
-    /// However, if we are at the the end of the chain, we want to accept whatever is there. (The
+    /// However, if we are at the end of the chain, we want to accept whatever is there. (The
     /// suggestion won't actually be output, but the diagnostic message will be output, so the user
     /// can determine the best way to handle the lint.)
     fn try_setting_current_suggestion(&mut self, expr: &'tcx Expr<'_>, allow_move_and_clone: bool) {
diff --git a/clippy_utils/src/ty.rs b/clippy_utils/src/ty.rs
index a15daec7c3c..f4a135f2b5b 100644
--- a/clippy_utils/src/ty.rs
+++ b/clippy_utils/src/ty.rs
@@ -711,7 +711,7 @@ impl core::ops::Add<u32> for EnumValue {
     }
 }
 
-/// Attempts to read the given constant as though it were an an enum value.
+/// Attempts to read the given constant as though it were an enum value.
 #[expect(clippy::cast_possible_truncation, clippy::cast_possible_wrap)]
 pub fn read_explicit_enum_value(tcx: TyCtxt<'_>, id: DefId) -> Option<EnumValue> {
     if let Ok(ConstValue::Scalar(Scalar::Int(value))) = tcx.const_eval_poly(id) {
diff --git a/tests/ui/manual_flatten.rs b/tests/ui/manual_flatten.rs
index 96cd87c0e19..552213a7ff2 100644
--- a/tests/ui/manual_flatten.rs
+++ b/tests/ui/manual_flatten.rs
@@ -10,7 +10,7 @@ fn main() {
         }
     }
 
-    // Test for loop over implicitly implicitly adjusted `Iterator` with `if let` statement
+    // Test for loop over implicitly adjusted `Iterator` with `if let` statement
     let y: Vec<Result<i32, i32>> = vec![];
     for n in y.clone() {
         if let Ok(n) = n {
diff --git a/tests/ui/mut_range_bound.rs b/tests/ui/mut_range_bound.rs
index e1ae1ef9282..7fdeb27ed98 100644
--- a/tests/ui/mut_range_bound.rs
+++ b/tests/ui/mut_range_bound.rs
@@ -76,7 +76,7 @@ fn mut_range_bound_no_immediate_break() {
     let mut n = 3;
     for i in n..10 {
         if n == 4 {
-            n = 1; // FIXME: warning because is is not immediately followed by break
+            n = 1; // FIXME: warning because it is not immediately followed by break
             let _ = 2;
             break;
         }
diff --git a/tests/ui/mut_range_bound.stderr b/tests/ui/mut_range_bound.stderr
index e0c8dced382..b679b7a0aaf 100644
--- a/tests/ui/mut_range_bound.stderr
+++ b/tests/ui/mut_range_bound.stderr
@@ -50,7 +50,7 @@ LL |         m = 2; // warning because it is not immediately followed by break
 error: attempt to mutate range bound within loop
   --> $DIR/mut_range_bound.rs:79:13
    |
-LL |             n = 1; // FIXME: warning because is is not immediately followed by break
+LL |             n = 1; // FIXME: warning because it is not immediately followed by break
    |             ^
    |
    = note: the range of the loop is unchanged
-- 
cgit 1.4.1-3-g733a5


From 1909a6af1ab68578afbdb879ab6936e06c02da89 Mon Sep 17 00:00:00 2001
From: kraktus <kraktus@users.noreply.github.com>
Date: Wed, 26 Oct 2022 18:10:40 +0200
Subject: [`use_self`] fix suggestion when full path to struct was given

Previously the following wrong suggestion was given

```rust
impl Error for std::fmt::Error {
    fn custom<T: std::fmt::Display>(_msg: T) -> Self {
-        std::fmt::Error // Should lint
+        Self::Error // Should lint
    }
}
```

Also remove known problem line related to #4140 since it's been closed, and refactor the lint
---
 clippy_lints/src/use_self.rs                       | 38 ++++++++--------------
 .../fail_both_diff/src/main.stderr                 |  8 ++++-
 .../fail_both_same/src/main.stderr                 |  8 ++++-
 .../cargo_rust_version/fail_cargo/src/main.stderr  |  8 ++++-
 .../cargo_rust_version/fail_clippy/src/main.stderr |  8 ++++-
 .../fail_file_attr/src/main.stderr                 |  8 ++++-
 tests/ui/use_self_trait.fixed                      | 15 +++++++--
 tests/ui/use_self_trait.rs                         | 13 +++++++-
 tests/ui/use_self_trait.stderr                     | 14 +++++++-
 9 files changed, 87 insertions(+), 33 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/use_self.rs b/clippy_lints/src/use_self.rs
index acf27c34e94..464ffdc0a2a 100644
--- a/clippy_lints/src/use_self.rs
+++ b/clippy_lints/src/use_self.rs
@@ -30,7 +30,6 @@ declare_clippy_lint! {
     ///
     /// ### Known problems
     /// - Unaddressed false negative in fn bodies of trait implementations
-    /// - False positive with associated types in traits (#4140)
     ///
     /// ### Example
     /// ```rust
@@ -235,24 +234,13 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
             then {} else { return; }
         }
         match expr.kind {
-            ExprKind::Struct(QPath::Resolved(_, path), ..) => match path.res {
-                Res::SelfTyParam { .. } | Res::SelfTyAlias { .. } => (),
-                Res::Def(DefKind::Variant, _) => lint_path_to_variant(cx, path),
-                _ => span_lint(cx, path.span),
-            },
-            // tuple struct instantiation (`Foo(arg)` or `Enum::Foo(arg)`)
+            ExprKind::Struct(QPath::Resolved(_, path), ..) => check_path(cx, path),
             ExprKind::Call(fun, _) => {
                 if let ExprKind::Path(QPath::Resolved(_, path)) = fun.kind {
-                    if let Res::Def(DefKind::Ctor(ctor_of, _), ..) = path.res {
-                        match ctor_of {
-                            CtorOf::Variant => lint_path_to_variant(cx, path),
-                            CtorOf::Struct => span_lint(cx, path.span),
-                        }
-                    }
+                    check_path(cx, path);
                 }
             },
-            // unit enum variants (`Enum::A`)
-            ExprKind::Path(QPath::Resolved(_, path)) => lint_path_to_variant(cx, path),
+            ExprKind::Path(QPath::Resolved(_, path)) => check_path(cx, path),
             _ => (),
         }
     }
@@ -268,15 +256,7 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
                  | PatKind::Struct(QPath::Resolved(_, path), _, _) = pat.kind;
             if cx.typeck_results().pat_ty(pat) == cx.tcx.type_of(impl_id);
             then {
-                match path.res {
-                    Res::Def(DefKind::Ctor(ctor_of, _), ..) => match ctor_of {
-                            CtorOf::Variant => lint_path_to_variant(cx, path),
-                            CtorOf::Struct => span_lint(cx, path.span),
-                    },
-                    Res::Def(DefKind::Variant, ..) => lint_path_to_variant(cx, path),
-                    Res::Def(DefKind::Struct, ..) => span_lint(cx, path.span),
-                    _ => ()
-                }
+                check_path(cx, path);
             }
         }
     }
@@ -314,6 +294,16 @@ fn span_lint(cx: &LateContext<'_>, span: Span) {
     );
 }
 
+fn check_path(cx: &LateContext<'_>, path: &Path<'_>) {
+    match path.res {
+        Res::Def(DefKind::Ctor(CtorOf::Variant, _) | DefKind::Variant, ..) => {
+            lint_path_to_variant(cx, path);
+        },
+        Res::Def(DefKind::Ctor(CtorOf::Struct, _) | DefKind::Struct, ..) => span_lint(cx, path.span),
+        _ => (),
+    }
+}
+
 fn lint_path_to_variant(cx: &LateContext<'_>, path: &Path<'_>) {
     if let [.., self_seg, _variant] = path.segments {
         let span = path
diff --git a/tests/ui-cargo/cargo_rust_version/fail_both_diff/src/main.stderr b/tests/ui-cargo/cargo_rust_version/fail_both_diff/src/main.stderr
index 9a7d802dc6d..163f8bb35e7 100644
--- a/tests/ui-cargo/cargo_rust_version/fail_both_diff/src/main.stderr
+++ b/tests/ui-cargo/cargo_rust_version/fail_both_diff/src/main.stderr
@@ -12,5 +12,11 @@ note: the lint level is defined here
 LL | #![deny(clippy::use_self)]
    |         ^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error; 1 warning emitted
+error: unnecessary structure name repetition
+  --> $DIR/main.rs:7:9
+   |
+LL |         Foo
+   |         ^^^ help: use the applicable keyword: `Self`
+
+error: aborting due to 2 previous errors; 1 warning emitted
 
diff --git a/tests/ui-cargo/cargo_rust_version/fail_both_same/src/main.stderr b/tests/ui-cargo/cargo_rust_version/fail_both_same/src/main.stderr
index a280e1bacdf..259d39b1252 100644
--- a/tests/ui-cargo/cargo_rust_version/fail_both_same/src/main.stderr
+++ b/tests/ui-cargo/cargo_rust_version/fail_both_same/src/main.stderr
@@ -10,5 +10,11 @@ note: the lint level is defined here
 LL | #![deny(clippy::use_self)]
    |         ^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: unnecessary structure name repetition
+  --> $DIR/main.rs:7:9
+   |
+LL |         Foo
+   |         ^^^ help: use the applicable keyword: `Self`
+
+error: aborting due to 2 previous errors
 
diff --git a/tests/ui-cargo/cargo_rust_version/fail_cargo/src/main.stderr b/tests/ui-cargo/cargo_rust_version/fail_cargo/src/main.stderr
index a280e1bacdf..259d39b1252 100644
--- a/tests/ui-cargo/cargo_rust_version/fail_cargo/src/main.stderr
+++ b/tests/ui-cargo/cargo_rust_version/fail_cargo/src/main.stderr
@@ -10,5 +10,11 @@ note: the lint level is defined here
 LL | #![deny(clippy::use_self)]
    |         ^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: unnecessary structure name repetition
+  --> $DIR/main.rs:7:9
+   |
+LL |         Foo
+   |         ^^^ help: use the applicable keyword: `Self`
+
+error: aborting due to 2 previous errors
 
diff --git a/tests/ui-cargo/cargo_rust_version/fail_clippy/src/main.stderr b/tests/ui-cargo/cargo_rust_version/fail_clippy/src/main.stderr
index a280e1bacdf..259d39b1252 100644
--- a/tests/ui-cargo/cargo_rust_version/fail_clippy/src/main.stderr
+++ b/tests/ui-cargo/cargo_rust_version/fail_clippy/src/main.stderr
@@ -10,5 +10,11 @@ note: the lint level is defined here
 LL | #![deny(clippy::use_self)]
    |         ^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: unnecessary structure name repetition
+  --> $DIR/main.rs:7:9
+   |
+LL |         Foo
+   |         ^^^ help: use the applicable keyword: `Self`
+
+error: aborting due to 2 previous errors
 
diff --git a/tests/ui-cargo/cargo_rust_version/fail_file_attr/src/main.stderr b/tests/ui-cargo/cargo_rust_version/fail_file_attr/src/main.stderr
index 88f6e00922b..97e6c3d5a55 100644
--- a/tests/ui-cargo/cargo_rust_version/fail_file_attr/src/main.stderr
+++ b/tests/ui-cargo/cargo_rust_version/fail_file_attr/src/main.stderr
@@ -10,5 +10,11 @@ note: the lint level is defined here
 LL | #![deny(clippy::use_self)]
    |         ^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: unnecessary structure name repetition
+  --> $DIR/main.rs:12:9
+   |
+LL |         Foo
+   |         ^^^ help: use the applicable keyword: `Self`
+
+error: aborting due to 2 previous errors
 
diff --git a/tests/ui/use_self_trait.fixed b/tests/ui/use_self_trait.fixed
index 12adf1e41a6..4e779308d02 100644
--- a/tests/ui/use_self_trait.fixed
+++ b/tests/ui/use_self_trait.fixed
@@ -47,8 +47,7 @@ impl Mul for Bad {
 
 impl Clone for Bad {
     fn clone(&self) -> Self {
-        // FIXME: applicable here
-        Bad
+        Self
     }
 }
 
@@ -138,4 +137,16 @@ mod impl_in_macro {
     parse_ip_impl!(Foo); // Should not lint
 }
 
+mod full_path_replacement {
+    trait Error {
+        fn custom<T: std::fmt::Display>(_msg: T) -> Self;
+    }
+
+    impl Error for std::fmt::Error {
+        fn custom<T: std::fmt::Display>(_msg: T) -> Self {
+            Self // Should lint
+        }
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/use_self_trait.rs b/tests/ui/use_self_trait.rs
index 49dbcddc1d8..325dc73b21e 100644
--- a/tests/ui/use_self_trait.rs
+++ b/tests/ui/use_self_trait.rs
@@ -47,7 +47,6 @@ impl Mul for Bad {
 
 impl Clone for Bad {
     fn clone(&self) -> Self {
-        // FIXME: applicable here
         Bad
     }
 }
@@ -138,4 +137,16 @@ mod impl_in_macro {
     parse_ip_impl!(Foo); // Should not lint
 }
 
+mod full_path_replacement {
+    trait Error {
+        fn custom<T: std::fmt::Display>(_msg: T) -> Self;
+    }
+
+    impl Error for std::fmt::Error {
+        fn custom<T: std::fmt::Display>(_msg: T) -> Self {
+            std::fmt::Error // Should lint
+        }
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/use_self_trait.stderr b/tests/ui/use_self_trait.stderr
index 55af3ff2a93..090729b9c3d 100644
--- a/tests/ui/use_self_trait.stderr
+++ b/tests/ui/use_self_trait.stderr
@@ -84,5 +84,17 @@ error: unnecessary structure name repetition
 LL |     fn mul(self, rhs: Bad) -> Bad {
    |                               ^^^ help: use the applicable keyword: `Self`
 
-error: aborting due to 14 previous errors
+error: unnecessary structure name repetition
+  --> $DIR/use_self_trait.rs:50:9
+   |
+LL |         Bad
+   |         ^^^ help: use the applicable keyword: `Self`
+
+error: unnecessary structure name repetition
+  --> $DIR/use_self_trait.rs:147:13
+   |
+LL |             std::fmt::Error // Should lint
+   |             ^^^^^^^^^^^^^^^ help: use the applicable keyword: `Self`
+
+error: aborting due to 16 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 83771c524225176616db45ebe67045a6f89b7117 Mon Sep 17 00:00:00 2001
From: Samuel Moelius <sam@moeli.us>
Date: Wed, 26 Oct 2022 19:31:01 -0400
Subject: Fix `needless_borrow` false positive

---
 clippy_lints/src/dereference.rs | 47 ++++++++++++++++++++++++++++++++++++++---
 tests/ui/needless_borrow.fixed  | 23 ++++++++++++++++++++
 tests/ui/needless_borrow.rs     | 23 ++++++++++++++++++++
 3 files changed, 90 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index 7b5c10db4e1..7e2e32a20d4 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -1049,7 +1049,7 @@ fn ty_contains_infer(ty: &hir::Ty<'_>) -> bool {
 // If the conditions are met, returns `Some(Position::ImplArg(..))`; otherwise, returns `None`.
 //   The "is copyable" condition is to avoid the case where removing the `&` means `e` would have to
 // be moved, but it cannot be.
-#[expect(clippy::too_many_arguments)]
+#[expect(clippy::too_many_arguments, clippy::too_many_lines)]
 fn needless_borrow_impl_arg_position<'tcx>(
     cx: &LateContext<'tcx>,
     possible_borrowers: &mut Vec<(LocalDefId, PossibleBorrowerMap<'tcx, 'tcx>)>,
@@ -1092,7 +1092,7 @@ fn needless_borrow_impl_arg_position<'tcx>(
         .iter()
         .filter_map(|predicate| {
             if let PredicateKind::Trait(trait_predicate) = predicate.kind().skip_binder()
-                && trait_predicate.trait_ref.self_ty() == param_ty.to_ty(cx.tcx)
+                && trait_predicate.self_ty() == param_ty.to_ty(cx.tcx)
             {
                 Some(trait_predicate.trait_ref.def_id)
             } else {
@@ -1111,6 +1111,16 @@ fn needless_borrow_impl_arg_position<'tcx>(
         return Position::Other(precedence);
     }
 
+    // See:
+    // - https://github.com/rust-lang/rust-clippy/pull/9674#issuecomment-1289294201
+    // - https://github.com/rust-lang/rust-clippy/pull/9674#issuecomment-1292225232
+    if projection_predicates
+        .iter()
+        .any(|projection_predicate| is_mixed_projection_predicate(cx, callee_def_id, projection_predicate))
+    {
+        return Position::Other(precedence);
+    }
+
     // `substs_with_referent_ty` can be constructed outside of `check_referent` because the same
     // elements are modified each time `check_referent` is called.
     let mut substs_with_referent_ty = substs_with_expr_ty.to_vec();
@@ -1190,8 +1200,39 @@ fn has_ref_mut_self_method(cx: &LateContext<'_>, trait_def_id: DefId) -> bool {
         })
 }
 
-fn referent_used_exactly_once<'tcx>(
+fn is_mixed_projection_predicate<'tcx>(
     cx: &LateContext<'tcx>,
+    callee_def_id: DefId,
+    projection_predicate: &ProjectionPredicate<'tcx>,
+) -> bool {
+    let generics = cx.tcx.generics_of(callee_def_id);
+    // The predicate requires the projected type to equal a type parameter from the parent context.
+    if let Some(term_ty) = projection_predicate.term.ty()
+        && let ty::Param(term_param_ty) = term_ty.kind()
+        && (term_param_ty.index as usize) < generics.parent_count
+    {
+        // The inner-most self type is a type parameter from the current function.
+        let mut projection_ty = projection_predicate.projection_ty;
+        loop {
+            match projection_ty.self_ty().kind() {
+                ty::Projection(inner_projection_ty) => {
+                    projection_ty = *inner_projection_ty;
+                }
+                ty::Param(param_ty) => {
+                    return (param_ty.index as usize) >= generics.parent_count;
+                }
+                _ => {
+                    return false;
+                }
+            }
+        }
+    } else {
+        false
+    }
+}
+
+fn referent_used_exactly_once<'a, 'tcx>(
+    cx: &'a LateContext<'tcx>,
     possible_borrowers: &mut Vec<(LocalDefId, PossibleBorrowerMap<'tcx, 'tcx>)>,
     reference: &Expr<'tcx>,
 ) -> bool {
diff --git a/tests/ui/needless_borrow.fixed b/tests/ui/needless_borrow.fixed
index 340e89d2db1..57a682d62c0 100644
--- a/tests/ui/needless_borrow.fixed
+++ b/tests/ui/needless_borrow.fixed
@@ -385,3 +385,26 @@ mod used_more_than_once {
     fn use_x(_: impl AsRef<str>) {}
     fn use_x_again(_: impl AsRef<str>) {}
 }
+
+// https://github.com/rust-lang/rust-clippy/issues/9111#issuecomment-1277114280
+#[allow(dead_code)]
+mod issue_9111 {
+    struct A;
+
+    impl Extend<u8> for A {
+        fn extend<T: IntoIterator<Item = u8>>(&mut self, _: T) {
+            unimplemented!()
+        }
+    }
+
+    impl<'a> Extend<&'a u8> for A {
+        fn extend<T: IntoIterator<Item = &'a u8>>(&mut self, _: T) {
+            unimplemented!()
+        }
+    }
+
+    fn main() {
+        let mut a = A;
+        a.extend(&[]); // vs a.extend([]);
+    }
+}
diff --git a/tests/ui/needless_borrow.rs b/tests/ui/needless_borrow.rs
index c93711ac8e2..0d325b48ab8 100644
--- a/tests/ui/needless_borrow.rs
+++ b/tests/ui/needless_borrow.rs
@@ -385,3 +385,26 @@ mod used_more_than_once {
     fn use_x(_: impl AsRef<str>) {}
     fn use_x_again(_: impl AsRef<str>) {}
 }
+
+// https://github.com/rust-lang/rust-clippy/issues/9111#issuecomment-1277114280
+#[allow(dead_code)]
+mod issue_9111 {
+    struct A;
+
+    impl Extend<u8> for A {
+        fn extend<T: IntoIterator<Item = u8>>(&mut self, _: T) {
+            unimplemented!()
+        }
+    }
+
+    impl<'a> Extend<&'a u8> for A {
+        fn extend<T: IntoIterator<Item = &'a u8>>(&mut self, _: T) {
+            unimplemented!()
+        }
+    }
+
+    fn main() {
+        let mut a = A;
+        a.extend(&[]); // vs a.extend([]);
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 14a34c2c619318a670ace9fb38d3a67ee9f0d323 Mon Sep 17 00:00:00 2001
From: dswijj <dswijj@gmail.com>
Date: Thu, 27 Oct 2022 17:49:43 +0800
Subject: move `UNINLINED_FORMAT_ARGS` to pedantic

---
 clippy_lints/src/format_args.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/format_args.rs b/clippy_lints/src/format_args.rs
index 4c4a1e06cd4..a73453bf027 100644
--- a/clippy_lints/src/format_args.rs
+++ b/clippy_lints/src/format_args.rs
@@ -115,7 +115,7 @@ declare_clippy_lint! {
     /// nothing will be suggested, e.g. `println!("{0}={1}", var, 1+2)`.
     #[clippy::version = "1.65.0"]
     pub UNINLINED_FORMAT_ARGS,
-    style,
+    pedantic,
     "using non-inlined variables in `format!` calls"
 }
 
-- 
cgit 1.4.1-3-g733a5


From e27e13c9ad8ff278c0cc3d1e75a6389a2235d5d9 Mon Sep 17 00:00:00 2001
From: Gary Guo <gary@garyguo.net>
Date: Thu, 27 Oct 2022 18:49:07 +0100
Subject: Ensure new_ret_no_self is not fired if `impl Trait<Self>` is
 returned.

---
 clippy_lints/src/methods/mod.rs | 30 ++----------------------
 clippy_utils/src/ty.rs          | 52 +++++++++++++++++++++++++++++++++++++++++
 2 files changed, 54 insertions(+), 28 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index b29c7d9f253..6665329d114 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -103,7 +103,7 @@ mod zst_offset;
 use bind_instead_of_map::BindInsteadOfMap;
 use clippy_utils::consts::{constant, Constant};
 use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
-use clippy_utils::ty::{contains_adt_constructor, implements_trait, is_copy, is_type_diagnostic_item};
+use clippy_utils::ty::{contains_ty_adt_constructor_opaque, implements_trait, is_copy, is_type_diagnostic_item};
 use clippy_utils::{contains_return, is_trait_method, iter_input_pats, meets_msrv, msrvs, return_ty};
 use if_chain::if_chain;
 use rustc_hir as hir;
@@ -3394,36 +3394,10 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
         if let hir::ImplItemKind::Fn(_, _) = impl_item.kind {
             let ret_ty = return_ty(cx, impl_item.hir_id());
 
-            // walk the return type and check for Self (this does not check associated types)
-            if let Some(self_adt) = self_ty.ty_adt_def() {
-                if contains_adt_constructor(ret_ty, self_adt) {
-                    return;
-                }
-            } else if ret_ty.contains(self_ty) {
+            if contains_ty_adt_constructor_opaque(cx, ret_ty, self_ty) {
                 return;
             }
 
-            // if return type is impl trait, check the associated types
-            if let ty::Opaque(def_id, _) = *ret_ty.kind() {
-                // one of the associated types must be Self
-                for &(predicate, _span) in cx.tcx.explicit_item_bounds(def_id) {
-                    if let ty::PredicateKind::Projection(projection_predicate) = predicate.kind().skip_binder() {
-                        let assoc_ty = match projection_predicate.term.unpack() {
-                            ty::TermKind::Ty(ty) => ty,
-                            ty::TermKind::Const(_c) => continue,
-                        };
-                        // walk the associated type and check for Self
-                        if let Some(self_adt) = self_ty.ty_adt_def() {
-                            if contains_adt_constructor(assoc_ty, self_adt) {
-                                return;
-                            }
-                        } else if assoc_ty.contains(self_ty) {
-                            return;
-                        }
-                    }
-                }
-            }
-
             if name == "new" && ret_ty != self_ty {
                 span_lint(
                     cx,
diff --git a/clippy_utils/src/ty.rs b/clippy_utils/src/ty.rs
index f4a135f2b5b..2dd8c826ab3 100644
--- a/clippy_utils/src/ty.rs
+++ b/clippy_utils/src/ty.rs
@@ -59,6 +59,58 @@ pub fn contains_adt_constructor<'tcx>(ty: Ty<'tcx>, adt: AdtDef<'tcx>) -> bool {
     })
 }
 
+/// Walks into `ty` and returns `true` if any inner type is an instance of the given type, or adt
+/// constructor of the same type.
+///
+/// This method also recurses into opaque type predicates, so call it with `impl Trait<U>` and `U`
+/// will also return `true`.
+pub fn contains_ty_adt_constructor_opaque<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>, needle: Ty<'tcx>) -> bool {
+    ty.walk().any(|inner| match inner.unpack() {
+        GenericArgKind::Type(inner_ty) => {
+            if inner_ty == needle {
+                return true;
+            }
+
+            if inner_ty.ty_adt_def() == needle.ty_adt_def() {
+                return true;
+            }
+
+            if let ty::Opaque(def_id, _) = *inner_ty.kind() {
+                for &(predicate, _span) in cx.tcx.explicit_item_bounds(def_id) {
+                    match predicate.kind().skip_binder() {
+                        // For `impl Trait<U>`, it will register a predicate of `T: Trait<U>`, so we go through
+                        // and check substituions to find `U`.
+                        ty::PredicateKind::Trait(trait_predicate) => {
+                            if trait_predicate
+                                .trait_ref
+                                .substs
+                                .types()
+                                .skip(1) // Skip the implicit `Self` generic parameter
+                                .any(|ty| contains_ty_adt_constructor_opaque(cx, ty, needle))
+                            {
+                                return true;
+                            }
+                        },
+                        // For `impl Trait<Assoc=U>`, it will register a predicate of `<T as Trait>::Assoc = U`,
+                        // so we check the term for `U`.
+                        ty::PredicateKind::Projection(projection_predicate) => {
+                            if let ty::TermKind::Ty(ty) = projection_predicate.term.unpack() {
+                                if contains_ty_adt_constructor_opaque(cx, ty, needle) {
+                                    return true;
+                                }
+                            };
+                        },
+                        _ => (),
+                    }
+                }
+            }
+
+            false
+        },
+        GenericArgKind::Lifetime(_) | GenericArgKind::Const(_) => false,
+    })
+}
+
 /// Resolves `<T as Iterator>::Item` for `T`
 /// Do not invoke without first verifying that the type implements `Iterator`
 pub fn get_iterator_item_ty<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Option<Ty<'tcx>> {
-- 
cgit 1.4.1-3-g733a5


From 151395d74e703600a724ecfc219c3f0fb1fe384a Mon Sep 17 00:00:00 2001
From: Alex ✨ Cosmic Princess ✨ <blyxyas@gmail.com>
Date: Thu, 27 Oct 2022 21:32:36 +0200
Subject: Update clippy_lints/src/suspicious_xor_used_as_pow.rs

Co-authored-by: NAKATA Takayuki <f.seasons017@gmail.com>
---
 clippy_lints/src/suspicious_xor_used_as_pow.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/suspicious_xor_used_as_pow.rs b/clippy_lints/src/suspicious_xor_used_as_pow.rs
index b4168d69abc..301aa5798bf 100644
--- a/clippy_lints/src/suspicious_xor_used_as_pow.rs
+++ b/clippy_lints/src/suspicious_xor_used_as_pow.rs
@@ -18,7 +18,7 @@ declare_clippy_lint! {
     /// ```rust
     /// let x = 3_i32.pow(4);
     /// ```
-    #[clippy::version = "1.65.0"]
+    #[clippy::version = "1.66.0"]
     pub SUSPICIOUS_XOR_USED_AS_POW,
     restriction,
     "XOR (`^`) operator possibly used as exponentiation operator"
-- 
cgit 1.4.1-3-g733a5


From fa6850d888ce44d3381451aa484743289029dccc Mon Sep 17 00:00:00 2001
From: kraktus <kraktus@users.noreply.github.com>
Date: Fri, 28 Oct 2022 14:45:16 +0200
Subject: [`bool_to_int_with_if`] do not lint in const context

---
 clippy_lints/src/bool_to_int_with_if.rs | 18 +++++++++---------
 tests/ui/bool_to_int_with_if.fixed      |  2 ++
 tests/ui/bool_to_int_with_if.rs         |  2 ++
 tests/ui/bool_to_int_with_if.stderr     |  2 +-
 4 files changed, 14 insertions(+), 10 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/bool_to_int_with_if.rs b/clippy_lints/src/bool_to_int_with_if.rs
index 001d74c2605..88bdfefddf7 100644
--- a/clippy_lints/src/bool_to_int_with_if.rs
+++ b/clippy_lints/src/bool_to_int_with_if.rs
@@ -3,7 +3,7 @@ use rustc_hir::{Block, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
-use clippy_utils::{diagnostics::span_lint_and_then, is_else_clause, is_integer_literal, sugg::Sugg};
+use clippy_utils::{diagnostics::span_lint_and_then, in_constant, is_else_clause, is_integer_literal, sugg::Sugg};
 use rustc_errors::Applicability;
 
 declare_clippy_lint! {
@@ -44,14 +44,14 @@ declare_clippy_lint! {
 declare_lint_pass!(BoolToIntWithIf => [BOOL_TO_INT_WITH_IF]);
 
 impl<'tcx> LateLintPass<'tcx> for BoolToIntWithIf {
-    fn check_expr(&mut self, ctx: &LateContext<'tcx>, expr: &'tcx rustc_hir::Expr<'tcx>) {
-        if !expr.span.from_expansion() {
-            check_if_else(ctx, expr);
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx rustc_hir::Expr<'tcx>) {
+        if !expr.span.from_expansion() && !in_constant(cx, expr.hir_id) {
+            check_if_else(cx, expr);
         }
     }
 }
 
-fn check_if_else<'tcx>(ctx: &LateContext<'tcx>, expr: &'tcx rustc_hir::Expr<'tcx>) {
+fn check_if_else<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx rustc_hir::Expr<'tcx>) {
     if let ExprKind::If(check, then, Some(else_)) = expr.kind
         && let Some(then_lit) = int_literal(then)
         && let Some(else_lit) = int_literal(else_)
@@ -66,17 +66,17 @@ fn check_if_else<'tcx>(ctx: &LateContext<'tcx>, expr: &'tcx rustc_hir::Expr<'tcx
         };
         let mut applicability = Applicability::MachineApplicable;
         let snippet = {
-            let mut sugg = Sugg::hir_with_applicability(ctx, check, "..", &mut applicability);
+            let mut sugg = Sugg::hir_with_applicability(cx, check, "..", &mut applicability);
             if inverted {
                 sugg = !sugg;
             }
             sugg
         };
 
-        let ty = ctx.typeck_results().expr_ty(then_lit); // then and else must be of same type
+        let ty = cx.typeck_results().expr_ty(then_lit); // then and else must be of same type
 
         let suggestion = {
-            let wrap_in_curly = is_else_clause(ctx.tcx, expr);
+            let wrap_in_curly = is_else_clause(cx.tcx, expr);
             let mut s = Sugg::NonParen(format!("{ty}::from({snippet})").into());
             if wrap_in_curly {
                 s = s.blockify();
@@ -87,7 +87,7 @@ fn check_if_else<'tcx>(ctx: &LateContext<'tcx>, expr: &'tcx rustc_hir::Expr<'tcx
         let into_snippet = snippet.clone().maybe_par();
         let as_snippet = snippet.as_ty(ty);
 
-        span_lint_and_then(ctx,
+        span_lint_and_then(cx,
             BOOL_TO_INT_WITH_IF,
             expr.span,
             "boolean to int conversion using if",
diff --git a/tests/ui/bool_to_int_with_if.fixed b/tests/ui/bool_to_int_with_if.fixed
index 2c8339cdd7f..6e0ff053ff2 100644
--- a/tests/ui/bool_to_int_with_if.fixed
+++ b/tests/ui/bool_to_int_with_if.fixed
@@ -76,6 +76,8 @@ fn main() {
         123
     };
 
+    pub const SHOULD_NOT_LINT: usize = if true { 1 } else { 0 };
+
     some_fn(a);
 }
 
diff --git a/tests/ui/bool_to_int_with_if.rs b/tests/ui/bool_to_int_with_if.rs
index 5d9496f0177..90ad5aa64da 100644
--- a/tests/ui/bool_to_int_with_if.rs
+++ b/tests/ui/bool_to_int_with_if.rs
@@ -108,6 +108,8 @@ fn main() {
         123
     };
 
+    pub const SHOULD_NOT_LINT: usize = if true { 1 } else { 0 };
+
     some_fn(a);
 }
 
diff --git a/tests/ui/bool_to_int_with_if.stderr b/tests/ui/bool_to_int_with_if.stderr
index 4cb5531bef6..1f447c9bfd1 100644
--- a/tests/ui/bool_to_int_with_if.stderr
+++ b/tests/ui/bool_to_int_with_if.stderr
@@ -98,7 +98,7 @@ LL | |     };
    = note: `!b as i32` or `(!b).into()` can also be valid options
 
 error: boolean to int conversion using if
-  --> $DIR/bool_to_int_with_if.rs:116:5
+  --> $DIR/bool_to_int_with_if.rs:118:5
    |
 LL |     if a { 1 } else { 0 }
    |     ^^^^^^^^^^^^^^^^^^^^^ help: replace with from: `u8::from(a)`
-- 
cgit 1.4.1-3-g733a5


From c42626f96958a04871c9a662fafc71e99feba48e Mon Sep 17 00:00:00 2001
From: Samuel Moelius <sam@moeli.us>
Date: Tue, 25 Oct 2022 05:54:22 -0400
Subject: Fix #9710

---
 clippy_lints/src/dereference.rs |  3 +++
 tests/ui/needless_borrow.fixed  | 12 ++++++++++++
 tests/ui/needless_borrow.rs     | 12 ++++++++++++
 3 files changed, 27 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index 7e2e32a20d4..4d2f5eea105 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -9,6 +9,7 @@ use clippy_utils::{
 };
 use rustc_ast::util::parser::{PREC_POSTFIX, PREC_PREFIX};
 use rustc_data_structures::fx::FxIndexMap;
+use rustc_data_structures::graph::iterate::{CycleDetector, TriColorDepthFirstSearch};
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_ty, Visitor};
 use rustc_hir::{
@@ -1242,6 +1243,8 @@ fn referent_used_exactly_once<'a, 'tcx>(
         && let Some(statement) = mir.basic_blocks[location.block].statements.get(location.statement_index)
         && let StatementKind::Assign(box (_, Rvalue::Ref(_, _, place))) = statement.kind
         && !place.has_deref()
+        // Ensure not in a loop (https://github.com/rust-lang/rust-clippy/issues/9710)
+        && TriColorDepthFirstSearch::new(&mir.basic_blocks).run_from(location.block, &mut CycleDetector).is_none()
     {
         let body_owner_local_def_id = cx.tcx.hir().enclosing_body_owner(reference.hir_id);
         if possible_borrowers
diff --git a/tests/ui/needless_borrow.fixed b/tests/ui/needless_borrow.fixed
index 57a682d62c0..9931fab04eb 100644
--- a/tests/ui/needless_borrow.fixed
+++ b/tests/ui/needless_borrow.fixed
@@ -408,3 +408,15 @@ mod issue_9111 {
         a.extend(&[]); // vs a.extend([]);
     }
 }
+
+#[allow(dead_code)]
+mod issue_9710 {
+    fn main() {
+        let string = String::new();
+        for _i in 0..10 {
+            f(&string);
+        }
+    }
+
+    fn f<T: AsRef<str>>(_: T) {}
+}
diff --git a/tests/ui/needless_borrow.rs b/tests/ui/needless_borrow.rs
index 0d325b48ab8..4460f16d191 100644
--- a/tests/ui/needless_borrow.rs
+++ b/tests/ui/needless_borrow.rs
@@ -408,3 +408,15 @@ mod issue_9111 {
         a.extend(&[]); // vs a.extend([]);
     }
 }
+
+#[allow(dead_code)]
+mod issue_9710 {
+    fn main() {
+        let string = String::new();
+        for _i in 0..10 {
+            f(&string);
+        }
+    }
+
+    fn f<T: AsRef<str>>(_: T) {}
+}
-- 
cgit 1.4.1-3-g733a5


From 7e68c718c0db31c317c77cf776441d695f715f41 Mon Sep 17 00:00:00 2001
From: Andre Bogus <bogusandre@gmail.com>
Date: Fri, 28 Oct 2022 17:22:40 +0200
Subject: fix the `string-extend-chars` suggestion on slice

This adds the missing `&` to the suggestion if the target is a
`str` slice (e.g. extending with `"foo"[..].chars()`).
---
 clippy_lints/src/methods/string_extend_chars.rs | 6 +++++-
 tests/ui/string_extend.fixed                    | 3 +++
 tests/ui/string_extend.rs                       | 3 +++
 tests/ui/string_extend.stderr                   | 8 +++++++-
 4 files changed, 18 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/string_extend_chars.rs b/clippy_lints/src/methods/string_extend_chars.rs
index 6974260f70d..0e93543fd7e 100644
--- a/clippy_lints/src/methods/string_extend_chars.rs
+++ b/clippy_lints/src/methods/string_extend_chars.rs
@@ -19,7 +19,11 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr
         let target = &arglists[0].0;
         let self_ty = cx.typeck_results().expr_ty(target).peel_refs();
         let ref_str = if *self_ty.kind() == ty::Str {
-            ""
+            if matches!(target.kind, hir::ExprKind::Index(..)) {
+                "&"
+            } else {
+                ""
+            }
         } else if is_type_diagnostic_item(cx, self_ty, sym::String) {
             "&"
         } else {
diff --git a/tests/ui/string_extend.fixed b/tests/ui/string_extend.fixed
index 1883a9f8325..d200d7310fc 100644
--- a/tests/ui/string_extend.fixed
+++ b/tests/ui/string_extend.fixed
@@ -29,4 +29,7 @@ fn main() {
 
     let f = HasChars;
     s.extend(f.chars());
+
+    // issue #9735
+    s.push_str(&abc[0..2]);
 }
diff --git a/tests/ui/string_extend.rs b/tests/ui/string_extend.rs
index 07d0baa1be6..0dd96a3b210 100644
--- a/tests/ui/string_extend.rs
+++ b/tests/ui/string_extend.rs
@@ -29,4 +29,7 @@ fn main() {
 
     let f = HasChars;
     s.extend(f.chars());
+
+    // issue #9735
+    s.extend(abc[0..2].chars());
 }
diff --git a/tests/ui/string_extend.stderr b/tests/ui/string_extend.stderr
index 6af8c9e1662..b35c77fd961 100644
--- a/tests/ui/string_extend.stderr
+++ b/tests/ui/string_extend.stderr
@@ -18,5 +18,11 @@ error: calling `.extend(_.chars())`
 LL |     s.extend(def.chars());
    |     ^^^^^^^^^^^^^^^^^^^^^ help: try this: `s.push_str(&def)`
 
-error: aborting due to 3 previous errors
+error: calling `.extend(_.chars())`
+  --> $DIR/string_extend.rs:34:5
+   |
+LL |     s.extend(abc[0..2].chars());
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `s.push_str(&abc[0..2])`
+
+error: aborting due to 4 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From e9216d836c7190fe5d90e0c48ca73de5b8e3e4f8 Mon Sep 17 00:00:00 2001
From: Samuel Moelius <sam@moeli.us>
Date: Fri, 28 Oct 2022 13:17:36 -0400
Subject: Improve `needless_lifetimes`

---
 clippy_lints/src/lifetimes.rs      | 120 ++++++++++++++++++++++++++++---------
 tests/ui/needless_lifetimes.rs     |   8 +++
 tests/ui/needless_lifetimes.stderr | 100 +++++++++++++++++++++----------
 3 files changed, 168 insertions(+), 60 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lifetimes.rs b/clippy_lints/src/lifetimes.rs
index 13878eda0f1..996eb277426 100644
--- a/clippy_lints/src/lifetimes.rs
+++ b/clippy_lints/src/lifetimes.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint;
+use clippy_utils::diagnostics::{span_lint, span_lint_and_then};
 use clippy_utils::trait_ref_of_method;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_hir::intravisit::nested_filter::{self as hir_nested_filter, NestedFilter};
@@ -151,6 +151,7 @@ fn check_fn_inner<'tcx>(
         .params
         .iter()
         .filter(|param| matches!(param.kind, GenericParamKind::Type { .. }));
+
     for typ in types {
         for pred in generics.bounds_for_param(cx.tcx.hir().local_def_id(typ.hir_id)) {
             if pred.origin == PredicateOrigin::WhereClause {
@@ -187,15 +188,30 @@ fn check_fn_inner<'tcx>(
             }
         }
     }
-    if could_use_elision(cx, decl, body, trait_sig, generics.params) {
-        span_lint(
+
+    if let Some(elidable_lts) = could_use_elision(cx, decl, body, trait_sig, generics.params) {
+        let lts = elidable_lts
+            .iter()
+            // In principle, the result of the call to `Node::ident` could be `unwrap`ped, as `DefId` should refer to a
+            // `Node::GenericParam`.
+            .filter_map(|&(def_id, _)| cx.tcx.hir().get_by_def_id(def_id).ident())
+            .map(|ident| ident.to_string())
+            .collect::<Vec<_>>()
+            .join(", ");
+
+        span_lint_and_then(
             cx,
             NEEDLESS_LIFETIMES,
             span.with_hi(decl.output.span().hi()),
-            "explicit lifetimes given in parameter types where they could be elided \
-             (or replaced with `'_` if needed by type declaration)",
+            &format!("the following explicit lifetimes could be elided: {lts}"),
+            |diag| {
+                if let Some(span) = elidable_lts.iter().find_map(|&(_, span)| span) {
+                    diag.span_help(span, "replace with `'_` in generic arguments such as here");
+                }
+            },
         );
     }
+
     if report_extra_lifetimes {
         self::report_extra_lifetimes(cx, decl, generics);
     }
@@ -220,13 +236,14 @@ fn explicit_self_type<'tcx>(cx: &LateContext<'tcx>, func: &FnDecl<'tcx>, ident:
     }
 }
 
+#[expect(clippy::too_many_lines)]
 fn could_use_elision<'tcx>(
     cx: &LateContext<'tcx>,
     func: &'tcx FnDecl<'_>,
     body: Option<BodyId>,
     trait_sig: Option<&[Ident]>,
     named_generics: &'tcx [GenericParam<'_>],
-) -> bool {
+) -> Option<Vec<(LocalDefId, Option<Span>)>> {
     // There are two scenarios where elision works:
     // * no output references, all input references have different LT
     // * output references, exactly one input reference with same LT
@@ -253,7 +270,7 @@ fn could_use_elision<'tcx>(
     }
 
     if input_visitor.abort() || output_visitor.abort() {
-        return false;
+        return None;
     }
 
     let input_lts = input_visitor.lts;
@@ -261,7 +278,7 @@ fn could_use_elision<'tcx>(
 
     if let Some(trait_sig) = trait_sig {
         if explicit_self_type(cx, func, trait_sig.first().copied()) {
-            return false;
+            return None;
         }
     }
 
@@ -270,7 +287,7 @@ fn could_use_elision<'tcx>(
 
         let first_ident = body.params.first().and_then(|param| param.pat.simple_ident());
         if explicit_self_type(cx, func, first_ident) {
-            return false;
+            return None;
         }
 
         let mut checker = BodyLifetimeChecker {
@@ -278,14 +295,14 @@ fn could_use_elision<'tcx>(
         };
         checker.visit_expr(body.value);
         if checker.lifetimes_used_in_body {
-            return false;
+            return None;
         }
     }
 
     // check for lifetimes from higher scopes
     for lt in input_lts.iter().chain(output_lts.iter()) {
         if !allowed_lts.contains(lt) {
-            return false;
+            return None;
         }
     }
 
@@ -301,14 +318,14 @@ fn could_use_elision<'tcx>(
         for lt in input_visitor.nested_elision_site_lts {
             if let RefLt::Named(def_id) = lt {
                 if allowed_lts.contains(&cx.tcx.item_name(def_id.to_def_id())) {
-                    return false;
+                    return None;
                 }
             }
         }
         for lt in output_visitor.nested_elision_site_lts {
             if let RefLt::Named(def_id) = lt {
                 if allowed_lts.contains(&cx.tcx.item_name(def_id.to_def_id())) {
-                    return false;
+                    return None;
                 }
             }
         }
@@ -316,32 +333,47 @@ fn could_use_elision<'tcx>(
 
     // no input lifetimes? easy case!
     if input_lts.is_empty() {
-        false
+        None
     } else if output_lts.is_empty() {
         // no output lifetimes, check distinctness of input lifetimes
 
         // only unnamed and static, ok
         let unnamed_and_static = input_lts.iter().all(|lt| *lt == RefLt::Unnamed || *lt == RefLt::Static);
         if unnamed_and_static {
-            return false;
+            return None;
+        }
+        // we have no output reference, so we can elide explicit lifetimes that occur at most once
+        let elidable_lts = named_lifetime_occurrences(&input_lts)
+            .into_iter()
+            .filter_map(|(def_id, occurrences)| {
+                if occurrences <= 1 {
+                    Some((def_id, input_visitor.sample_generic_arg_span.get(&def_id).copied()))
+                } else {
+                    None
+                }
+            })
+            .collect::<Vec<_>>();
+        if elidable_lts.is_empty() {
+            None
+        } else {
+            Some(elidable_lts)
         }
-        // we have no output reference, so we only need all distinct lifetimes
-        input_lts.len() == unique_lifetimes(&input_lts)
     } else {
         // we have output references, so we need one input reference,
         // and all output lifetimes must be the same
-        if unique_lifetimes(&output_lts) > 1 {
-            return false;
-        }
         if input_lts.len() == 1 {
             match (&input_lts[0], &output_lts[0]) {
-                (&RefLt::Named(n1), &RefLt::Named(n2)) if n1 == n2 => true,
-                (&RefLt::Named(_), &RefLt::Unnamed) => true,
-                _ => false, /* already elided, different named lifetimes
-                             * or something static going on */
+                (&RefLt::Named(n1), &RefLt::Named(n2)) if n1 == n2 => {
+                    Some(vec![(n1, input_visitor.sample_generic_arg_span.get(&n1).copied())])
+                },
+                (&RefLt::Named(n), &RefLt::Unnamed) => {
+                    Some(vec![(n, input_visitor.sample_generic_arg_span.get(&n).copied())])
+                },
+                _ => None, /* already elided, different named lifetimes
+                            * or something static going on */
             }
         } else {
-            false
+            None
         }
     }
 }
@@ -358,10 +390,24 @@ fn allowed_lts_from(tcx: TyCtxt<'_>, named_generics: &[GenericParam<'_>]) -> FxH
     allowed_lts
 }
 
-/// Number of unique lifetimes in the given vector.
+/// Number of times each named lifetime occurs in the given slice. Returns a vector to preserve
+/// relative order.
 #[must_use]
-fn unique_lifetimes(lts: &[RefLt]) -> usize {
-    lts.iter().collect::<FxHashSet<_>>().len()
+fn named_lifetime_occurrences(lts: &[RefLt]) -> Vec<(LocalDefId, usize)> {
+    let mut occurrences = Vec::new();
+    for lt in lts {
+        if let &RefLt::Named(curr_def_id) = lt {
+            if let Some(i) = occurrences
+                .iter()
+                .position(|&(prev_def_id, _)| prev_def_id == curr_def_id)
+            {
+                occurrences[i].1 += 1;
+            } else {
+                occurrences.push((curr_def_id, 1));
+            }
+        }
+    }
+    occurrences
 }
 
 const CLOSURE_TRAIT_BOUNDS: [LangItem; 3] = [LangItem::Fn, LangItem::FnMut, LangItem::FnOnce];
@@ -370,6 +416,7 @@ const CLOSURE_TRAIT_BOUNDS: [LangItem; 3] = [LangItem::Fn, LangItem::FnMut, Lang
 struct RefVisitor<'a, 'tcx> {
     cx: &'a LateContext<'tcx>,
     lts: Vec<RefLt>,
+    sample_generic_arg_span: FxHashMap<LocalDefId, Span>,
     nested_elision_site_lts: Vec<RefLt>,
     unelided_trait_object_lifetime: bool,
 }
@@ -379,6 +426,7 @@ impl<'a, 'tcx> RefVisitor<'a, 'tcx> {
         Self {
             cx,
             lts: Vec::new(),
+            sample_generic_arg_span: FxHashMap::default(),
             nested_elision_site_lts: Vec::new(),
             unelided_trait_object_lifetime: false,
         }
@@ -472,6 +520,22 @@ impl<'a, 'tcx> Visitor<'tcx> for RefVisitor<'a, 'tcx> {
             _ => walk_ty(self, ty),
         }
     }
+
+    fn visit_generic_arg(&mut self, generic_arg: &'tcx GenericArg<'tcx>) {
+        if let GenericArg::Lifetime(l) = generic_arg
+            && let LifetimeName::Param(def_id, _) = l.name
+        {
+            self.sample_generic_arg_span.entry(def_id).or_insert(l.span);
+        }
+        // Replace with `walk_generic_arg` if/when https://github.com/rust-lang/rust/pull/103692 lands.
+        // walk_generic_arg(self, generic_arg);
+        match generic_arg {
+            GenericArg::Lifetime(lt) => self.visit_lifetime(lt),
+            GenericArg::Type(ty) => self.visit_ty(ty),
+            GenericArg::Const(ct) => self.visit_anon_const(&ct.value),
+            GenericArg::Infer(inf) => self.visit_infer(inf),
+        }
+    }
 }
 
 /// Are any lifetimes mentioned in the `where` clause? If so, we don't try to
diff --git a/tests/ui/needless_lifetimes.rs b/tests/ui/needless_lifetimes.rs
index fc686b1dac0..3fe12214294 100644
--- a/tests/ui/needless_lifetimes.rs
+++ b/tests/ui/needless_lifetimes.rs
@@ -419,4 +419,12 @@ mod issue7296 {
     }
 }
 
+mod false_negative {
+    #![allow(unused)]
+
+    fn foo<'a>(x: &'a u8, y: &'_ u8) {}
+
+    fn bar<'a>(x: &'a u8, y: &'_ u8, z: &'_ u8) {}
+}
+
 fn main() {}
diff --git a/tests/ui/needless_lifetimes.stderr b/tests/ui/needless_lifetimes.stderr
index 3c428fd4674..94787b95181 100644
--- a/tests/ui/needless_lifetimes.stderr
+++ b/tests/ui/needless_lifetimes.stderr
@@ -1,4 +1,4 @@
-error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+error: the following explicit lifetimes could be elided: 'a, 'b
   --> $DIR/needless_lifetimes.rs:11:1
    |
 LL | fn distinct_lifetimes<'a, 'b>(_x: &'a u8, _y: &'b u8, _z: u8) {}
@@ -6,185 +6,221 @@ LL | fn distinct_lifetimes<'a, 'b>(_x: &'a u8, _y: &'b u8, _z: u8) {}
    |
    = note: `-D clippy::needless-lifetimes` implied by `-D warnings`
 
-error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+error: the following explicit lifetimes could be elided: 'a, 'b
   --> $DIR/needless_lifetimes.rs:13:1
    |
 LL | fn distinct_and_static<'a, 'b>(_x: &'a u8, _y: &'b u8, _z: &'static u8) {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+error: the following explicit lifetimes could be elided: 'a
   --> $DIR/needless_lifetimes.rs:23:1
    |
 LL | fn in_and_out<'a>(x: &'a u8, _y: u8) -> &'a u8 {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+error: the following explicit lifetimes could be elided: 'a
   --> $DIR/needless_lifetimes.rs:57:1
    |
 LL | fn deep_reference_3<'a>(x: &'a u8, _y: u8) -> Result<&'a u8, ()> {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+error: the following explicit lifetimes could be elided: 'a
   --> $DIR/needless_lifetimes.rs:62:1
    |
 LL | fn where_clause_without_lt<'a, T>(x: &'a u8, _y: u8) -> Result<&'a u8, ()>
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+error: the following explicit lifetimes could be elided: 'a, 'b
   --> $DIR/needless_lifetimes.rs:74:1
    |
 LL | fn lifetime_param_2<'a, 'b>(_x: Ref<'a>, _y: &'b u8) {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: replace with `'_` in generic arguments such as here
+  --> $DIR/needless_lifetimes.rs:74:37
+   |
+LL | fn lifetime_param_2<'a, 'b>(_x: Ref<'a>, _y: &'b u8) {}
+   |                                     ^^
 
-error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+error: the following explicit lifetimes could be elided: 'a
   --> $DIR/needless_lifetimes.rs:98:1
    |
 LL | fn fn_bound_2<'a, F, I>(_m: Lt<'a, I>, _f: F) -> Lt<'a, I>
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: replace with `'_` in generic arguments such as here
+  --> $DIR/needless_lifetimes.rs:98:32
+   |
+LL | fn fn_bound_2<'a, F, I>(_m: Lt<'a, I>, _f: F) -> Lt<'a, I>
+   |                                ^^
 
-error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+error: the following explicit lifetimes could be elided: 's
   --> $DIR/needless_lifetimes.rs:128:5
    |
 LL |     fn self_and_out<'s>(&'s self) -> &'s u8 {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+error: the following explicit lifetimes could be elided: 's, 't
   --> $DIR/needless_lifetimes.rs:137:5
    |
 LL |     fn distinct_self_and_in<'s, 't>(&'s self, _x: &'t u8) {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+error: the following explicit lifetimes could be elided: 'a
   --> $DIR/needless_lifetimes.rs:156:1
    |
 LL | fn struct_with_lt<'a>(_foo: Foo<'a>) -> &'a str {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: replace with `'_` in generic arguments such as here
+  --> $DIR/needless_lifetimes.rs:156:33
+   |
+LL | fn struct_with_lt<'a>(_foo: Foo<'a>) -> &'a str {
+   |                                 ^^
 
-error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+error: the following explicit lifetimes could be elided: 'a
   --> $DIR/needless_lifetimes.rs:186:1
    |
 LL | fn trait_obj_elided2<'a>(_arg: &'a dyn Drop) -> &'a str {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+error: the following explicit lifetimes could be elided: 'a
   --> $DIR/needless_lifetimes.rs:192:1
    |
 LL | fn alias_with_lt<'a>(_foo: FooAlias<'a>) -> &'a str {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: replace with `'_` in generic arguments such as here
+  --> $DIR/needless_lifetimes.rs:192:37
+   |
+LL | fn alias_with_lt<'a>(_foo: FooAlias<'a>) -> &'a str {
+   |                                     ^^
 
-error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+error: the following explicit lifetimes could be elided: 'a
   --> $DIR/needless_lifetimes.rs:211:1
    |
 LL | fn named_input_elided_output<'a>(_arg: &'a str) -> &str {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+error: the following explicit lifetimes could be elided: 'a
   --> $DIR/needless_lifetimes.rs:219:1
    |
 LL | fn trait_bound_ok<'a, T: WithLifetime<'static>>(_: &'a u8, _: T) {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+error: the following explicit lifetimes could be elided: 'a
   --> $DIR/needless_lifetimes.rs:255:1
    |
 LL | fn out_return_type_lts<'a>(e: &'a str) -> Cow<'a> {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+error: the following explicit lifetimes could be elided: 'a
   --> $DIR/needless_lifetimes.rs:262:9
    |
 LL |         fn needless_lt<'a>(x: &'a u8) {}
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+error: the following explicit lifetimes could be elided: 'a
   --> $DIR/needless_lifetimes.rs:266:9
    |
 LL |         fn needless_lt<'a>(_x: &'a u8) {}
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+error: the following explicit lifetimes could be elided: 'a
   --> $DIR/needless_lifetimes.rs:279:9
    |
 LL |         fn baz<'a>(&'a self) -> impl Foo + 'a {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+error: the following explicit lifetimes could be elided: 'a
   --> $DIR/needless_lifetimes.rs:311:5
    |
 LL |     fn impl_trait_elidable_nested_anonymous_lifetimes<'a>(i: &'a i32, f: impl Fn(&i32) -> &i32) -> &'a i32 {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+error: the following explicit lifetimes could be elided: 'a
   --> $DIR/needless_lifetimes.rs:320:5
    |
 LL |     fn generics_elidable<'a, T: Fn(&i32) -> &i32>(i: &'a i32, f: T) -> &'a i32 {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+error: the following explicit lifetimes could be elided: 'a
   --> $DIR/needless_lifetimes.rs:332:5
    |
 LL |     fn where_clause_elidadable<'a, T>(i: &'a i32, f: T) -> &'a i32
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+error: the following explicit lifetimes could be elided: 'a
   --> $DIR/needless_lifetimes.rs:347:5
    |
 LL |     fn pointer_fn_elidable<'a>(i: &'a i32, f: fn(&i32) -> &i32) -> &'a i32 {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+error: the following explicit lifetimes could be elided: 'a
   --> $DIR/needless_lifetimes.rs:360:5
    |
 LL |     fn nested_fn_pointer_3<'a>(_: &'a i32) -> fn(fn(&i32) -> &i32) -> i32 {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+error: the following explicit lifetimes could be elided: 'a
   --> $DIR/needless_lifetimes.rs:363:5
    |
 LL |     fn nested_fn_pointer_4<'a>(_: &'a i32) -> impl Fn(fn(&i32)) {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+error: the following explicit lifetimes could be elided: 'a
   --> $DIR/needless_lifetimes.rs:385:9
    |
 LL |         fn implicit<'a>(&'a self) -> &'a () {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+error: the following explicit lifetimes could be elided: 'a
   --> $DIR/needless_lifetimes.rs:388:9
    |
 LL |         fn implicit_mut<'a>(&'a mut self) -> &'a () {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+error: the following explicit lifetimes could be elided: 'a
   --> $DIR/needless_lifetimes.rs:399:9
    |
 LL |         fn lifetime_elsewhere<'a>(self: Box<Self>, here: &'a ()) -> &'a () {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+error: the following explicit lifetimes could be elided: 'a
   --> $DIR/needless_lifetimes.rs:405:9
    |
 LL |         fn implicit<'a>(&'a self) -> &'a ();
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+error: the following explicit lifetimes could be elided: 'a
   --> $DIR/needless_lifetimes.rs:406:9
    |
 LL |         fn implicit_provided<'a>(&'a self) -> &'a () {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+error: the following explicit lifetimes could be elided: 'a
   --> $DIR/needless_lifetimes.rs:415:9
    |
 LL |         fn lifetime_elsewhere<'a>(self: Box<Self>, here: &'a ()) -> &'a ();
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+error: the following explicit lifetimes could be elided: 'a
   --> $DIR/needless_lifetimes.rs:416:9
    |
 LL |         fn lifetime_elsewhere_provided<'a>(self: Box<Self>, here: &'a ()) -> &'a () {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 31 previous errors
+error: the following explicit lifetimes could be elided: 'a
+  --> $DIR/needless_lifetimes.rs:425:5
+   |
+LL |     fn foo<'a>(x: &'a u8, y: &'_ u8) {}
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: the following explicit lifetimes could be elided: 'a
+  --> $DIR/needless_lifetimes.rs:427:5
+   |
+LL |     fn bar<'a>(x: &'a u8, y: &'_ u8, z: &'_ u8) {}
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 33 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 10b7fabbf36f1ab45c4d33357270d0557822ff90 Mon Sep 17 00:00:00 2001
From: Samuel Moelius <sam@moeli.us>
Date: Fri, 28 Oct 2022 13:18:07 -0400
Subject: Fix adjacent code

---
 clippy_lints/src/booleans.rs                                 |  2 +-
 clippy_lints/src/dereference.rs                              |  4 ++--
 clippy_lints/src/doc.rs                                      |  6 +++---
 clippy_lints/src/fallible_impl_from.rs                       |  2 +-
 clippy_lints/src/implicit_hasher.rs                          |  4 ++--
 clippy_lints/src/index_refutable_slice.rs                    |  4 ++--
 clippy_lints/src/indexing_slicing.rs                         |  6 +-----
 clippy_lints/src/invalid_upcast_comparisons.rs               |  2 +-
 clippy_lints/src/loops/mut_range_bound.rs                    |  4 ++--
 clippy_lints/src/map_unit_fn.rs                              |  2 +-
 clippy_lints/src/matches/manual_filter.rs                    |  2 +-
 clippy_lints/src/matches/significant_drop_in_scrutinee.rs    |  2 +-
 clippy_lints/src/matches/single_match.rs                     |  2 +-
 clippy_lints/src/methods/chars_cmp_with_unwrap.rs            |  4 ++--
 clippy_lints/src/methods/chars_last_cmp.rs                   |  2 +-
 clippy_lints/src/methods/chars_last_cmp_with_unwrap.rs       |  2 +-
 clippy_lints/src/methods/chars_next_cmp.rs                   |  2 +-
 clippy_lints/src/methods/chars_next_cmp_with_unwrap.rs       |  2 +-
 clippy_lints/src/methods/filter_map.rs                       |  8 ++++----
 clippy_lints/src/methods/inefficient_to_string.rs            |  4 ++--
 clippy_lints/src/methods/iter_nth_zero.rs                    |  2 +-
 .../src/methods/iter_on_single_or_empty_collections.rs       |  2 +-
 clippy_lints/src/methods/manual_saturating_arithmetic.rs     |  2 +-
 clippy_lints/src/methods/map_clone.rs                        |  4 ++--
 clippy_lints/src/methods/map_err_ignore.rs                   |  2 +-
 clippy_lints/src/methods/option_as_ref_deref.rs              |  4 ++--
 clippy_lints/src/methods/suspicious_map.rs                   |  2 +-
 clippy_lints/src/mixed_read_write_in_expression.rs           |  4 ++--
 clippy_lints/src/mut_key.rs                                  |  2 +-
 clippy_lints/src/needless_continue.rs                        |  8 ++++----
 clippy_lints/src/operators/op_ref.rs                         |  2 +-
 clippy_lints/src/pattern_type_mismatch.rs                    |  4 ++--
 clippy_lints/src/ptr_offset_with_cast.rs                     |  8 ++++----
 clippy_lints/src/redundant_closure_call.rs                   |  4 ++--
 clippy_lints/src/slow_vector_initialization.rs               |  2 +-
 .../src/utils/internal_lints/lint_without_lint_pass.rs       |  2 +-
 clippy_utils/src/diagnostics.rs                              | 12 ++++++------
 clippy_utils/src/lib.rs                                      |  4 ++--
 clippy_utils/src/qualify_min_const_fn.rs                     |  6 +++---
 clippy_utils/src/sugg.rs                                     |  2 +-
 tests/ui/crashes/ice-2774.stderr                             |  2 +-
 tests/ui/crashes/needless_lifetimes_impl_trait.stderr        |  2 +-
 tests/ui/issue_4266.stderr                                   |  4 ++--
 43 files changed, 74 insertions(+), 78 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/booleans.rs b/clippy_lints/src/booleans.rs
index 08164c0b654..939bdbcdc7c 100644
--- a/clippy_lints/src/booleans.rs
+++ b/clippy_lints/src/booleans.rs
@@ -481,7 +481,7 @@ impl<'a, 'tcx> Visitor<'tcx> for NonminimalBoolVisitor<'a, 'tcx> {
     }
 }
 
-fn implements_ord<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>) -> bool {
+fn implements_ord(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
     let ty = cx.typeck_results().expr_ty(expr);
     cx.tcx
         .get_diagnostic_item(sym::Ord)
diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index 7e2e32a20d4..dcbcabf1347 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -1231,8 +1231,8 @@ fn is_mixed_projection_predicate<'tcx>(
     }
 }
 
-fn referent_used_exactly_once<'a, 'tcx>(
-    cx: &'a LateContext<'tcx>,
+fn referent_used_exactly_once<'tcx>(
+    cx: &LateContext<'tcx>,
     possible_borrowers: &mut Vec<(LocalDefId, PossibleBorrowerMap<'tcx, 'tcx>)>,
     reference: &Expr<'tcx>,
 ) -> bool {
diff --git a/clippy_lints/src/doc.rs b/clippy_lints/src/doc.rs
index 36dc7e3396b..cecec520a6d 100644
--- a/clippy_lints/src/doc.rs
+++ b/clippy_lints/src/doc.rs
@@ -336,8 +336,8 @@ impl<'tcx> LateLintPass<'tcx> for DocMarkdown {
     }
 }
 
-fn lint_for_missing_headers<'tcx>(
-    cx: &LateContext<'tcx>,
+fn lint_for_missing_headers(
+    cx: &LateContext<'_>,
     def_id: LocalDefId,
     span: impl Into<MultiSpan> + Copy,
     sig: &hir::FnSig<'_>,
@@ -467,7 +467,7 @@ struct DocHeaders {
     panics: bool,
 }
 
-fn check_attrs<'a>(cx: &LateContext<'_>, valid_idents: &FxHashSet<String>, attrs: &'a [Attribute]) -> DocHeaders {
+fn check_attrs(cx: &LateContext<'_>, valid_idents: &FxHashSet<String>, attrs: &[Attribute]) -> DocHeaders {
     use pulldown_cmark::{BrokenLink, CowStr, Options};
     /// We don't want the parser to choke on intra doc links. Since we don't
     /// actually care about rendering them, just pretend that all broken links are
diff --git a/clippy_lints/src/fallible_impl_from.rs b/clippy_lints/src/fallible_impl_from.rs
index ef24a5d06ad..15d693a117a 100644
--- a/clippy_lints/src/fallible_impl_from.rs
+++ b/clippy_lints/src/fallible_impl_from.rs
@@ -64,7 +64,7 @@ impl<'tcx> LateLintPass<'tcx> for FallibleImplFrom {
     }
 }
 
-fn lint_impl_body<'tcx>(cx: &LateContext<'tcx>, impl_span: Span, impl_items: &[hir::ImplItemRef]) {
+fn lint_impl_body(cx: &LateContext<'_>, impl_span: Span, impl_items: &[hir::ImplItemRef]) {
     use rustc_hir::intravisit::{self, Visitor};
     use rustc_hir::{Expr, ImplItemKind};
 
diff --git a/clippy_lints/src/implicit_hasher.rs b/clippy_lints/src/implicit_hasher.rs
index 93efe957b1d..c7c3b3f6b94 100644
--- a/clippy_lints/src/implicit_hasher.rs
+++ b/clippy_lints/src/implicit_hasher.rs
@@ -66,8 +66,8 @@ impl<'tcx> LateLintPass<'tcx> for ImplicitHasher {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
         use rustc_span::BytePos;
 
-        fn suggestion<'tcx>(
-            cx: &LateContext<'tcx>,
+        fn suggestion(
+            cx: &LateContext<'_>,
             diag: &mut Diagnostic,
             generics_span: Span,
             generics_suggestion_span: Span,
diff --git a/clippy_lints/src/index_refutable_slice.rs b/clippy_lints/src/index_refutable_slice.rs
index c7b5badaae5..0d5099bde6d 100644
--- a/clippy_lints/src/index_refutable_slice.rs
+++ b/clippy_lints/src/index_refutable_slice.rs
@@ -207,8 +207,8 @@ impl SliceLintInformation {
     }
 }
 
-fn filter_lintable_slices<'a, 'tcx>(
-    cx: &'a LateContext<'tcx>,
+fn filter_lintable_slices<'tcx>(
+    cx: &LateContext<'tcx>,
     slice_lint_info: FxIndexMap<hir::HirId, SliceLintInformation>,
     max_suggested_slice: u64,
     scope: &'tcx hir::Expr<'tcx>,
diff --git a/clippy_lints/src/indexing_slicing.rs b/clippy_lints/src/indexing_slicing.rs
index af40a5a8187..4cd7dff4cfd 100644
--- a/clippy_lints/src/indexing_slicing.rs
+++ b/clippy_lints/src/indexing_slicing.rs
@@ -171,11 +171,7 @@ impl<'tcx> LateLintPass<'tcx> for IndexingSlicing {
 
 /// Returns a tuple of options with the start and end (exclusive) values of
 /// the range. If the start or end is not constant, None is returned.
-fn to_const_range<'tcx>(
-    cx: &LateContext<'tcx>,
-    range: higher::Range<'_>,
-    array_size: u128,
-) -> (Option<u128>, Option<u128>) {
+fn to_const_range(cx: &LateContext<'_>, range: higher::Range<'_>, array_size: u128) -> (Option<u128>, Option<u128>) {
     let s = range
         .start
         .map(|expr| constant(cx, cx.typeck_results(), expr).map(|(c, _)| c));
diff --git a/clippy_lints/src/invalid_upcast_comparisons.rs b/clippy_lints/src/invalid_upcast_comparisons.rs
index 0ef77e03de9..6ea637412d5 100644
--- a/clippy_lints/src/invalid_upcast_comparisons.rs
+++ b/clippy_lints/src/invalid_upcast_comparisons.rs
@@ -38,7 +38,7 @@ declare_clippy_lint! {
 
 declare_lint_pass!(InvalidUpcastComparisons => [INVALID_UPCAST_COMPARISONS]);
 
-fn numeric_cast_precast_bounds<'a>(cx: &LateContext<'_>, expr: &'a Expr<'_>) -> Option<(FullInt, FullInt)> {
+fn numeric_cast_precast_bounds(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<(FullInt, FullInt)> {
     if let ExprKind::Cast(cast_exp, _) = expr.kind {
         let pre_cast_ty = cx.typeck_results().expr_ty(cast_exp);
         let cast_ty = cx.typeck_results().expr_ty(expr);
diff --git a/clippy_lints/src/loops/mut_range_bound.rs b/clippy_lints/src/loops/mut_range_bound.rs
index db73ab55b37..72ae2b39162 100644
--- a/clippy_lints/src/loops/mut_range_bound.rs
+++ b/clippy_lints/src/loops/mut_range_bound.rs
@@ -52,8 +52,8 @@ fn check_for_mutability(cx: &LateContext<'_>, bound: &Expr<'_>) -> Option<HirId>
     None
 }
 
-fn check_for_mutation<'tcx>(
-    cx: &LateContext<'tcx>,
+fn check_for_mutation(
+    cx: &LateContext<'_>,
     body: &Expr<'_>,
     bound_id_start: Option<HirId>,
     bound_id_end: Option<HirId>,
diff --git a/clippy_lints/src/map_unit_fn.rs b/clippy_lints/src/map_unit_fn.rs
index 32da37a862d..59195d1ae4e 100644
--- a/clippy_lints/src/map_unit_fn.rs
+++ b/clippy_lints/src/map_unit_fn.rs
@@ -119,7 +119,7 @@ fn is_unit_expression(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> bool {
 /// semicolons, which causes problems when generating a suggestion. Given an
 /// expression that evaluates to '()' or '!', recursively remove useless braces
 /// and semi-colons until is suitable for including in the suggestion template
-fn reduce_unit_expression<'a>(cx: &LateContext<'_>, expr: &'a hir::Expr<'_>) -> Option<Span> {
+fn reduce_unit_expression(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> Option<Span> {
     if !is_unit_expression(cx, expr) {
         return None;
     }
diff --git a/clippy_lints/src/matches/manual_filter.rs b/clippy_lints/src/matches/manual_filter.rs
index 66ba1f6f9c5..d521a529e0d 100644
--- a/clippy_lints/src/matches/manual_filter.rs
+++ b/clippy_lints/src/matches/manual_filter.rs
@@ -62,7 +62,7 @@ fn peels_blocks_incl_unsafe<'a>(expr: &'a Expr<'a>) -> &'a Expr<'a> {
 //    <expr>
 // }
 // Returns true if <expr> resolves to `Some(x)`, `false` otherwise
-fn is_some_expr<'tcx>(cx: &LateContext<'_>, target: HirId, ctxt: SyntaxContext, expr: &'tcx Expr<'_>) -> bool {
+fn is_some_expr(cx: &LateContext<'_>, target: HirId, ctxt: SyntaxContext, expr: &Expr<'_>) -> bool {
     if let Some(inner_expr) = peels_blocks_incl_unsafe_opt(expr) {
         // there can be not statements in the block as they would be removed when switching to `.filter`
         if let ExprKind::Call(callee, [arg]) = inner_expr.kind {
diff --git a/clippy_lints/src/matches/significant_drop_in_scrutinee.rs b/clippy_lints/src/matches/significant_drop_in_scrutinee.rs
index 93e4160c69b..78c70d1c8d8 100644
--- a/clippy_lints/src/matches/significant_drop_in_scrutinee.rs
+++ b/clippy_lints/src/matches/significant_drop_in_scrutinee.rs
@@ -377,7 +377,7 @@ impl<'a, 'tcx> ArmSigDropHelper<'a, 'tcx> {
     }
 }
 
-fn has_significant_drop_in_arms<'tcx, 'a>(cx: &'a LateContext<'tcx>, arms: &'tcx [Arm<'_>]) -> FxHashSet<Span> {
+fn has_significant_drop_in_arms<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>]) -> FxHashSet<Span> {
     let mut helper = ArmSigDropHelper::new(cx);
     for arm in arms {
         helper.visit_expr(arm.body);
diff --git a/clippy_lints/src/matches/single_match.rs b/clippy_lints/src/matches/single_match.rs
index e5a15b2e1a1..19b49c44d57 100644
--- a/clippy_lints/src/matches/single_match.rs
+++ b/clippy_lints/src/matches/single_match.rs
@@ -153,7 +153,7 @@ fn pat_in_candidate_enum<'a>(cx: &LateContext<'a>, ty: Ty<'a>, pat: &Pat<'_>) ->
 }
 
 /// Returns `true` if the given type is an enum we know won't be expanded in the future
-fn in_candidate_enum<'a>(cx: &LateContext<'a>, ty: Ty<'_>) -> bool {
+fn in_candidate_enum(cx: &LateContext<'_>, ty: Ty<'_>) -> bool {
     // list of candidate `Enum`s we know will never get any more members
     let candidates = [sym::Cow, sym::Option, sym::Result];
 
diff --git a/clippy_lints/src/methods/chars_cmp_with_unwrap.rs b/clippy_lints/src/methods/chars_cmp_with_unwrap.rs
index 7e808760663..27a05337a29 100644
--- a/clippy_lints/src/methods/chars_cmp_with_unwrap.rs
+++ b/clippy_lints/src/methods/chars_cmp_with_unwrap.rs
@@ -9,8 +9,8 @@ use rustc_lint::LateContext;
 use rustc_lint::Lint;
 
 /// Wrapper fn for `CHARS_NEXT_CMP` and `CHARS_LAST_CMP` lints with `unwrap()`.
-pub(super) fn check<'tcx>(
-    cx: &LateContext<'tcx>,
+pub(super) fn check(
+    cx: &LateContext<'_>,
     info: &crate::methods::BinaryExprInfo<'_>,
     chain_methods: &[&str],
     lint: &'static Lint,
diff --git a/clippy_lints/src/methods/chars_last_cmp.rs b/clippy_lints/src/methods/chars_last_cmp.rs
index 07bbc5ca1bf..2efff4c3c54 100644
--- a/clippy_lints/src/methods/chars_last_cmp.rs
+++ b/clippy_lints/src/methods/chars_last_cmp.rs
@@ -4,7 +4,7 @@ use rustc_lint::LateContext;
 use super::CHARS_LAST_CMP;
 
 /// Checks for the `CHARS_LAST_CMP` lint.
-pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, info: &crate::methods::BinaryExprInfo<'_>) -> bool {
+pub(super) fn check(cx: &LateContext<'_>, info: &crate::methods::BinaryExprInfo<'_>) -> bool {
     if chars_cmp::check(cx, info, &["chars", "last"], CHARS_LAST_CMP, "ends_with") {
         true
     } else {
diff --git a/clippy_lints/src/methods/chars_last_cmp_with_unwrap.rs b/clippy_lints/src/methods/chars_last_cmp_with_unwrap.rs
index c29ee0ec8c8..5b8713f7d79 100644
--- a/clippy_lints/src/methods/chars_last_cmp_with_unwrap.rs
+++ b/clippy_lints/src/methods/chars_last_cmp_with_unwrap.rs
@@ -4,7 +4,7 @@ use rustc_lint::LateContext;
 use super::CHARS_LAST_CMP;
 
 /// Checks for the `CHARS_LAST_CMP` lint with `unwrap()`.
-pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, info: &crate::methods::BinaryExprInfo<'_>) -> bool {
+pub(super) fn check(cx: &LateContext<'_>, info: &crate::methods::BinaryExprInfo<'_>) -> bool {
     if chars_cmp_with_unwrap::check(cx, info, &["chars", "last", "unwrap"], CHARS_LAST_CMP, "ends_with") {
         true
     } else {
diff --git a/clippy_lints/src/methods/chars_next_cmp.rs b/clippy_lints/src/methods/chars_next_cmp.rs
index a6701d8830e..b631fecab97 100644
--- a/clippy_lints/src/methods/chars_next_cmp.rs
+++ b/clippy_lints/src/methods/chars_next_cmp.rs
@@ -3,6 +3,6 @@ use rustc_lint::LateContext;
 use super::CHARS_NEXT_CMP;
 
 /// Checks for the `CHARS_NEXT_CMP` lint.
-pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, info: &crate::methods::BinaryExprInfo<'_>) -> bool {
+pub(super) fn check(cx: &LateContext<'_>, info: &crate::methods::BinaryExprInfo<'_>) -> bool {
     crate::methods::chars_cmp::check(cx, info, &["chars", "next"], CHARS_NEXT_CMP, "starts_with")
 }
diff --git a/clippy_lints/src/methods/chars_next_cmp_with_unwrap.rs b/clippy_lints/src/methods/chars_next_cmp_with_unwrap.rs
index 28ede28e935..caf21d3ff3b 100644
--- a/clippy_lints/src/methods/chars_next_cmp_with_unwrap.rs
+++ b/clippy_lints/src/methods/chars_next_cmp_with_unwrap.rs
@@ -3,6 +3,6 @@ use rustc_lint::LateContext;
 use super::CHARS_NEXT_CMP;
 
 /// Checks for the `CHARS_NEXT_CMP` lint with `unwrap()`.
-pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, info: &crate::methods::BinaryExprInfo<'_>) -> bool {
+pub(super) fn check(cx: &LateContext<'_>, info: &crate::methods::BinaryExprInfo<'_>) -> bool {
     crate::methods::chars_cmp_with_unwrap::check(cx, info, &["chars", "next", "unwrap"], CHARS_NEXT_CMP, "starts_with")
 }
diff --git a/clippy_lints/src/methods/filter_map.rs b/clippy_lints/src/methods/filter_map.rs
index 9719b2f1c51..f888c58a72d 100644
--- a/clippy_lints/src/methods/filter_map.rs
+++ b/clippy_lints/src/methods/filter_map.rs
@@ -17,7 +17,7 @@ use super::MANUAL_FILTER_MAP;
 use super::MANUAL_FIND_MAP;
 use super::OPTION_FILTER_MAP;
 
-fn is_method<'tcx>(cx: &LateContext<'tcx>, expr: &hir::Expr<'_>, method_name: Symbol) -> bool {
+fn is_method(cx: &LateContext<'_>, expr: &hir::Expr<'_>, method_name: Symbol) -> bool {
     match &expr.kind {
         hir::ExprKind::Path(QPath::TypeRelative(_, mname)) => mname.ident.name == method_name,
         hir::ExprKind::Path(QPath::Resolved(_, segments)) => {
@@ -46,7 +46,7 @@ fn is_method<'tcx>(cx: &LateContext<'tcx>, expr: &hir::Expr<'_>, method_name: Sy
     }
 }
 
-fn is_option_filter_map<'tcx>(cx: &LateContext<'tcx>, filter_arg: &hir::Expr<'_>, map_arg: &hir::Expr<'_>) -> bool {
+fn is_option_filter_map(cx: &LateContext<'_>, filter_arg: &hir::Expr<'_>, map_arg: &hir::Expr<'_>) -> bool {
     is_method(cx, map_arg, sym::unwrap) && is_method(cx, filter_arg, sym!(is_some))
 }
 
@@ -66,8 +66,8 @@ fn is_filter_some_map_unwrap(
 
 /// lint use of `filter().map()` or `find().map()` for `Iterators`
 #[allow(clippy::too_many_arguments)]
-pub(super) fn check<'tcx>(
-    cx: &LateContext<'tcx>,
+pub(super) fn check(
+    cx: &LateContext<'_>,
     expr: &hir::Expr<'_>,
     filter_recv: &hir::Expr<'_>,
     filter_arg: &hir::Expr<'_>,
diff --git a/clippy_lints/src/methods/inefficient_to_string.rs b/clippy_lints/src/methods/inefficient_to_string.rs
index ede3b8bb74e..3a8b8cbff47 100644
--- a/clippy_lints/src/methods/inefficient_to_string.rs
+++ b/clippy_lints/src/methods/inefficient_to_string.rs
@@ -12,8 +12,8 @@ use rustc_span::symbol::{sym, Symbol};
 use super::INEFFICIENT_TO_STRING;
 
 /// Checks for the `INEFFICIENT_TO_STRING` lint
-pub fn check<'tcx>(
-    cx: &LateContext<'tcx>,
+pub fn check(
+    cx: &LateContext<'_>,
     expr: &hir::Expr<'_>,
     method_name: Symbol,
     receiver: &hir::Expr<'_>,
diff --git a/clippy_lints/src/methods/iter_nth_zero.rs b/clippy_lints/src/methods/iter_nth_zero.rs
index 68d906c3ea3..c830958d5c8 100644
--- a/clippy_lints/src/methods/iter_nth_zero.rs
+++ b/clippy_lints/src/methods/iter_nth_zero.rs
@@ -10,7 +10,7 @@ use rustc_span::sym;
 
 use super::ITER_NTH_ZERO;
 
-pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &hir::Expr<'_>, recv: &hir::Expr<'_>, arg: &hir::Expr<'_>) {
+pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr<'_>, arg: &hir::Expr<'_>) {
     if_chain! {
         if is_trait_method(cx, expr, sym::Iterator);
         if let Some((Constant::Int(0), _)) = constant(cx, cx.typeck_results(), arg);
diff --git a/clippy_lints/src/methods/iter_on_single_or_empty_collections.rs b/clippy_lints/src/methods/iter_on_single_or_empty_collections.rs
index 4f73b3ec422..70abe4891d9 100644
--- a/clippy_lints/src/methods/iter_on_single_or_empty_collections.rs
+++ b/clippy_lints/src/methods/iter_on_single_or_empty_collections.rs
@@ -25,7 +25,7 @@ impl IterType {
     }
 }
 
-pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, method_name: &str, recv: &Expr<'_>) {
+pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, method_name: &str, recv: &Expr<'_>) {
     let item = match recv.kind {
         ExprKind::Array([]) => None,
         ExprKind::Array([e]) => Some(e),
diff --git a/clippy_lints/src/methods/manual_saturating_arithmetic.rs b/clippy_lints/src/methods/manual_saturating_arithmetic.rs
index b80541b8647..a7284c64497 100644
--- a/clippy_lints/src/methods/manual_saturating_arithmetic.rs
+++ b/clippy_lints/src/methods/manual_saturating_arithmetic.rs
@@ -67,7 +67,7 @@ enum MinMax {
     Max,
 }
 
-fn is_min_or_max<'tcx>(cx: &LateContext<'tcx>, expr: &hir::Expr<'_>) -> Option<MinMax> {
+fn is_min_or_max(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> Option<MinMax> {
     // `T::max_value()` `T::min_value()` inherent methods
     if_chain! {
         if let hir::ExprKind::Call(func, args) = &expr.kind;
diff --git a/clippy_lints/src/methods/map_clone.rs b/clippy_lints/src/methods/map_clone.rs
index 7ce14ec080b..6bc783c6d50 100644
--- a/clippy_lints/src/methods/map_clone.rs
+++ b/clippy_lints/src/methods/map_clone.rs
@@ -15,11 +15,11 @@ use rustc_span::{sym, Span};
 
 use super::MAP_CLONE;
 
-pub(super) fn check<'tcx>(
+pub(super) fn check(
     cx: &LateContext<'_>,
     e: &hir::Expr<'_>,
     recv: &hir::Expr<'_>,
-    arg: &'tcx hir::Expr<'_>,
+    arg: &hir::Expr<'_>,
     msrv: Option<RustcVersion>,
 ) {
     if_chain! {
diff --git a/clippy_lints/src/methods/map_err_ignore.rs b/clippy_lints/src/methods/map_err_ignore.rs
index 1fb6617145e..b773b3e423f 100644
--- a/clippy_lints/src/methods/map_err_ignore.rs
+++ b/clippy_lints/src/methods/map_err_ignore.rs
@@ -6,7 +6,7 @@ use rustc_span::sym;
 
 use super::MAP_ERR_IGNORE;
 
-pub(super) fn check<'tcx>(cx: &LateContext<'_>, e: &Expr<'_>, arg: &'tcx Expr<'_>) {
+pub(super) fn check(cx: &LateContext<'_>, e: &Expr<'_>, arg: &Expr<'_>) {
     if let Some(method_id) = cx.typeck_results().type_dependent_def_id(e.hir_id)
         && let Some(impl_id) = cx.tcx.impl_of_method(method_id)
         && is_type_diagnostic_item(cx, cx.tcx.type_of(impl_id), sym::Result)
diff --git a/clippy_lints/src/methods/option_as_ref_deref.rs b/clippy_lints/src/methods/option_as_ref_deref.rs
index 742483e6b2e..e6eb64bcbde 100644
--- a/clippy_lints/src/methods/option_as_ref_deref.rs
+++ b/clippy_lints/src/methods/option_as_ref_deref.rs
@@ -13,8 +13,8 @@ use rustc_span::sym;
 use super::OPTION_AS_REF_DEREF;
 
 /// lint use of `_.as_ref().map(Deref::deref)` for `Option`s
-pub(super) fn check<'tcx>(
-    cx: &LateContext<'tcx>,
+pub(super) fn check(
+    cx: &LateContext<'_>,
     expr: &hir::Expr<'_>,
     as_ref_recv: &hir::Expr<'_>,
     map_arg: &hir::Expr<'_>,
diff --git a/clippy_lints/src/methods/suspicious_map.rs b/clippy_lints/src/methods/suspicious_map.rs
index 851cdf54455..2ac0786b37b 100644
--- a/clippy_lints/src/methods/suspicious_map.rs
+++ b/clippy_lints/src/methods/suspicious_map.rs
@@ -8,7 +8,7 @@ use rustc_span::sym;
 
 use super::SUSPICIOUS_MAP;
 
-pub fn check<'tcx>(cx: &LateContext<'tcx>, expr: &hir::Expr<'_>, count_recv: &hir::Expr<'_>, map_arg: &hir::Expr<'_>) {
+pub fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, count_recv: &hir::Expr<'_>, map_arg: &hir::Expr<'_>) {
     if_chain! {
         if is_trait_method(cx, count_recv, sym::Iterator);
         let closure = expr_or_init(cx, map_arg);
diff --git a/clippy_lints/src/mixed_read_write_in_expression.rs b/clippy_lints/src/mixed_read_write_in_expression.rs
index 6752976348f..321fa4b7f99 100644
--- a/clippy_lints/src/mixed_read_write_in_expression.rs
+++ b/clippy_lints/src/mixed_read_write_in_expression.rs
@@ -218,7 +218,7 @@ enum StopEarly {
     Stop,
 }
 
-fn check_expr<'a, 'tcx>(vis: &mut ReadVisitor<'a, 'tcx>, expr: &'tcx Expr<'_>) -> StopEarly {
+fn check_expr<'tcx>(vis: &mut ReadVisitor<'_, 'tcx>, expr: &'tcx Expr<'_>) -> StopEarly {
     if expr.hir_id == vis.last_expr.hir_id {
         return StopEarly::KeepGoing;
     }
@@ -265,7 +265,7 @@ fn check_expr<'a, 'tcx>(vis: &mut ReadVisitor<'a, 'tcx>, expr: &'tcx Expr<'_>) -
     StopEarly::KeepGoing
 }
 
-fn check_stmt<'a, 'tcx>(vis: &mut ReadVisitor<'a, 'tcx>, stmt: &'tcx Stmt<'_>) -> StopEarly {
+fn check_stmt<'tcx>(vis: &mut ReadVisitor<'_, 'tcx>, stmt: &'tcx Stmt<'_>) -> StopEarly {
     match stmt.kind {
         StmtKind::Expr(expr) | StmtKind::Semi(expr) => check_expr(vis, expr),
         // If the declaration is of a local variable, check its initializer
diff --git a/clippy_lints/src/mut_key.rs b/clippy_lints/src/mut_key.rs
index 3d643e4e65c..551b6ed1227 100644
--- a/clippy_lints/src/mut_key.rs
+++ b/clippy_lints/src/mut_key.rs
@@ -137,7 +137,7 @@ impl MutableKeyType {
         }
     }
 
-    fn check_sig<'tcx>(&self, cx: &LateContext<'tcx>, item_hir_id: hir::HirId, decl: &hir::FnDecl<'_>) {
+    fn check_sig(&self, cx: &LateContext<'_>, item_hir_id: hir::HirId, decl: &hir::FnDecl<'_>) {
         let fn_def_id = cx.tcx.hir().local_def_id(item_hir_id);
         let fn_sig = cx.tcx.fn_sig(fn_def_id);
         for (hir_ty, ty) in iter::zip(decl.inputs, fn_sig.inputs().skip_binder()) {
diff --git a/clippy_lints/src/needless_continue.rs b/clippy_lints/src/needless_continue.rs
index 6f0e755466e..38a75034cd3 100644
--- a/clippy_lints/src/needless_continue.rs
+++ b/clippy_lints/src/needless_continue.rs
@@ -287,7 +287,7 @@ const DROP_ELSE_BLOCK_MSG: &str = "consider dropping the `else` clause";
 
 const DROP_CONTINUE_EXPRESSION_MSG: &str = "consider dropping the `continue` expression";
 
-fn emit_warning<'a>(cx: &EarlyContext<'_>, data: &'a LintData<'_>, header: &str, typ: LintType) {
+fn emit_warning(cx: &EarlyContext<'_>, data: &LintData<'_>, header: &str, typ: LintType) {
     // snip    is the whole *help* message that appears after the warning.
     // message is the warning message.
     // expr    is the expression which the lint warning message refers to.
@@ -313,7 +313,7 @@ fn emit_warning<'a>(cx: &EarlyContext<'_>, data: &'a LintData<'_>, header: &str,
     );
 }
 
-fn suggestion_snippet_for_continue_inside_if<'a>(cx: &EarlyContext<'_>, data: &'a LintData<'_>) -> String {
+fn suggestion_snippet_for_continue_inside_if(cx: &EarlyContext<'_>, data: &LintData<'_>) -> String {
     let cond_code = snippet(cx, data.if_cond.span, "..");
 
     let continue_code = snippet_block(cx, data.if_block.span, "..", Some(data.if_expr.span));
@@ -327,7 +327,7 @@ fn suggestion_snippet_for_continue_inside_if<'a>(cx: &EarlyContext<'_>, data: &'
     )
 }
 
-fn suggestion_snippet_for_continue_inside_else<'a>(cx: &EarlyContext<'_>, data: &'a LintData<'_>) -> String {
+fn suggestion_snippet_for_continue_inside_else(cx: &EarlyContext<'_>, data: &LintData<'_>) -> String {
     let cond_code = snippet(cx, data.if_cond.span, "..");
 
     // Region B
@@ -361,7 +361,7 @@ fn suggestion_snippet_for_continue_inside_else<'a>(cx: &EarlyContext<'_>, data:
     )
 }
 
-fn check_and_warn<'a>(cx: &EarlyContext<'_>, expr: &'a ast::Expr) {
+fn check_and_warn(cx: &EarlyContext<'_>, expr: &ast::Expr) {
     if_chain! {
         if let ast::ExprKind::Loop(loop_block, ..) = &expr.kind;
         if let Some(last_stmt) = loop_block.stmts.last();
diff --git a/clippy_lints/src/operators/op_ref.rs b/clippy_lints/src/operators/op_ref.rs
index 1085e608944..7de00c53f73 100644
--- a/clippy_lints/src/operators/op_ref.rs
+++ b/clippy_lints/src/operators/op_ref.rs
@@ -199,7 +199,7 @@ fn in_impl<'tcx>(
     }
 }
 
-fn are_equal<'tcx>(cx: &LateContext<'tcx>, middle_ty: Ty<'_>, hir_ty: &rustc_hir::Ty<'_>) -> bool {
+fn are_equal(cx: &LateContext<'_>, middle_ty: Ty<'_>, hir_ty: &rustc_hir::Ty<'_>) -> bool {
     if_chain! {
         if let ty::Adt(adt_def, _) = middle_ty.kind();
         if let Some(local_did) = adt_def.did().as_local();
diff --git a/clippy_lints/src/pattern_type_mismatch.rs b/clippy_lints/src/pattern_type_mismatch.rs
index a4d265111f9..97b5a4ce364 100644
--- a/clippy_lints/src/pattern_type_mismatch.rs
+++ b/clippy_lints/src/pattern_type_mismatch.rs
@@ -130,7 +130,7 @@ enum DerefPossible {
     Impossible,
 }
 
-fn apply_lint<'tcx>(cx: &LateContext<'tcx>, pat: &Pat<'_>, deref_possible: DerefPossible) -> bool {
+fn apply_lint(cx: &LateContext<'_>, pat: &Pat<'_>, deref_possible: DerefPossible) -> bool {
     let maybe_mismatch = find_first_mismatch(cx, pat);
     if let Some((span, mutability, level)) = maybe_mismatch {
         span_lint_and_help(
@@ -163,7 +163,7 @@ enum Level {
     Lower,
 }
 
-fn find_first_mismatch<'tcx>(cx: &LateContext<'tcx>, pat: &Pat<'_>) -> Option<(Span, Mutability, Level)> {
+fn find_first_mismatch(cx: &LateContext<'_>, pat: &Pat<'_>) -> Option<(Span, Mutability, Level)> {
     let mut result = None;
     pat.walk(|p| {
         if result.is_some() {
diff --git a/clippy_lints/src/ptr_offset_with_cast.rs b/clippy_lints/src/ptr_offset_with_cast.rs
index 72dda67c72b..47b8891e123 100644
--- a/clippy_lints/src/ptr_offset_with_cast.rs
+++ b/clippy_lints/src/ptr_offset_with_cast.rs
@@ -105,17 +105,17 @@ fn expr_as_ptr_offset_call<'tcx>(
 }
 
 // Is the type of the expression a usize?
-fn is_expr_ty_usize<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>) -> bool {
+fn is_expr_ty_usize(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
     cx.typeck_results().expr_ty(expr) == cx.tcx.types.usize
 }
 
 // Is the type of the expression a raw pointer?
-fn is_expr_ty_raw_ptr<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>) -> bool {
+fn is_expr_ty_raw_ptr(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
     cx.typeck_results().expr_ty(expr).is_unsafe_ptr()
 }
 
-fn build_suggestion<'tcx>(
-    cx: &LateContext<'tcx>,
+fn build_suggestion(
+    cx: &LateContext<'_>,
     method: Method,
     receiver_expr: &Expr<'_>,
     cast_lhs_expr: &Expr<'_>,
diff --git a/clippy_lints/src/redundant_closure_call.rs b/clippy_lints/src/redundant_closure_call.rs
index 74eea6de4bb..8cc8d5ea629 100644
--- a/clippy_lints/src/redundant_closure_call.rs
+++ b/clippy_lints/src/redundant_closure_call.rs
@@ -105,8 +105,8 @@ impl EarlyLintPass for RedundantClosureCall {
 
 impl<'tcx> LateLintPass<'tcx> for RedundantClosureCall {
     fn check_block(&mut self, cx: &LateContext<'tcx>, block: &'tcx hir::Block<'_>) {
-        fn count_closure_usage<'a, 'tcx>(
-            cx: &'a LateContext<'tcx>,
+        fn count_closure_usage<'tcx>(
+            cx: &LateContext<'tcx>,
             block: &'tcx hir::Block<'_>,
             path: &'tcx hir::Path<'tcx>,
         ) -> usize {
diff --git a/clippy_lints/src/slow_vector_initialization.rs b/clippy_lints/src/slow_vector_initialization.rs
index 76039923151..a2109038a05 100644
--- a/clippy_lints/src/slow_vector_initialization.rs
+++ b/clippy_lints/src/slow_vector_initialization.rs
@@ -168,7 +168,7 @@ impl SlowVectorInit {
         };
     }
 
-    fn emit_lint<'tcx>(cx: &LateContext<'tcx>, slow_fill: &Expr<'_>, vec_alloc: &VecAllocation<'_>, msg: &str) {
+    fn emit_lint(cx: &LateContext<'_>, slow_fill: &Expr<'_>, vec_alloc: &VecAllocation<'_>, msg: &str) {
         let len_expr = Sugg::hir(cx, vec_alloc.len_expr, "len");
 
         span_lint_and_then(cx, SLOW_VECTOR_INITIALIZATION, slow_fill.span, msg, |diag| {
diff --git a/clippy_lints/src/utils/internal_lints/lint_without_lint_pass.rs b/clippy_lints/src/utils/internal_lints/lint_without_lint_pass.rs
index 0dac64376b0..1aebb8b3104 100644
--- a/clippy_lints/src/utils/internal_lints/lint_without_lint_pass.rs
+++ b/clippy_lints/src/utils/internal_lints/lint_without_lint_pass.rs
@@ -256,7 +256,7 @@ impl<'tcx> LateLintPass<'tcx> for LintWithoutLintPass {
     }
 }
 
-pub(super) fn is_lint_ref_type<'tcx>(cx: &LateContext<'tcx>, ty: &hir::Ty<'_>) -> bool {
+pub(super) fn is_lint_ref_type(cx: &LateContext<'_>, ty: &hir::Ty<'_>) -> bool {
     if let TyKind::Rptr(
         _,
         MutTy {
diff --git a/clippy_utils/src/diagnostics.rs b/clippy_utils/src/diagnostics.rs
index 78f93755b72..16b160b6fd2 100644
--- a/clippy_utils/src/diagnostics.rs
+++ b/clippy_utils/src/diagnostics.rs
@@ -72,8 +72,8 @@ pub fn span_lint<T: LintContext>(cx: &T, lint: &'static Lint, sp: impl Into<Mult
 ///    |
 ///    = help: consider using `f64::NAN` if you would like a constant representing NaN
 /// ```
-pub fn span_lint_and_help<'a, T: LintContext>(
-    cx: &'a T,
+pub fn span_lint_and_help<T: LintContext>(
+    cx: &T,
     lint: &'static Lint,
     span: impl Into<MultiSpan>,
     msg: &str,
@@ -114,8 +114,8 @@ pub fn span_lint_and_help<'a, T: LintContext>(
 /// 10 |     forget(&SomeStruct);
 ///    |            ^^^^^^^^^^^
 /// ```
-pub fn span_lint_and_note<'a, T: LintContext>(
-    cx: &'a T,
+pub fn span_lint_and_note<T: LintContext>(
+    cx: &T,
     lint: &'static Lint,
     span: impl Into<MultiSpan>,
     msg: &str,
@@ -192,8 +192,8 @@ pub fn span_lint_hir_and_then(
 ///     = note: `-D fold-any` implied by `-D warnings`
 /// ```
 #[cfg_attr(feature = "internal", allow(clippy::collapsible_span_lint_calls))]
-pub fn span_lint_and_sugg<'a, T: LintContext>(
-    cx: &'a T,
+pub fn span_lint_and_sugg<T: LintContext>(
+    cx: &T,
     lint: &'static Lint,
     sp: Span,
     msg: &str,
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index dda4660fb7a..f7d3c91777e 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -994,7 +994,7 @@ impl std::ops::BitOrAssign for CaptureKind {
 /// Note as this will walk up to parent expressions until the capture can be determined it should
 /// only be used while making a closure somewhere a value is consumed. e.g. a block, match arm, or
 /// function argument (other than a receiver).
-pub fn capture_local_usage<'tcx>(cx: &LateContext<'tcx>, e: &Expr<'_>) -> CaptureKind {
+pub fn capture_local_usage(cx: &LateContext<'_>, e: &Expr<'_>) -> CaptureKind {
     fn pat_capture_kind(cx: &LateContext<'_>, pat: &Pat<'_>) -> CaptureKind {
         let mut capture = CaptureKind::Ref(Mutability::Not);
         pat.each_binding_or_first(&mut |_, id, span, _| match cx
@@ -1852,7 +1852,7 @@ pub fn match_any_def_paths(cx: &LateContext<'_>, did: DefId, paths: &[&[&str]])
 }
 
 /// Checks if the given `DefId` matches the path.
-pub fn match_def_path<'tcx>(cx: &LateContext<'tcx>, did: DefId, syms: &[&str]) -> bool {
+pub fn match_def_path(cx: &LateContext<'_>, did: DefId, syms: &[&str]) -> bool {
     // We should probably move to Symbols in Clippy as well rather than interning every time.
     let path = cx.get_def_path(did);
     syms.iter().map(|x| Symbol::intern(x)).eq(path.iter().copied())
diff --git a/clippy_utils/src/qualify_min_const_fn.rs b/clippy_utils/src/qualify_min_const_fn.rs
index 45b63a4aa5d..65722f142aa 100644
--- a/clippy_utils/src/qualify_min_const_fn.rs
+++ b/clippy_utils/src/qualify_min_const_fn.rs
@@ -18,7 +18,7 @@ use std::borrow::Cow;
 
 type McfResult = Result<(), (Span, Cow<'static, str>)>;
 
-pub fn is_min_const_fn<'a, 'tcx>(tcx: TyCtxt<'tcx>, body: &'a Body<'tcx>, msrv: Option<RustcVersion>) -> McfResult {
+pub fn is_min_const_fn<'tcx>(tcx: TyCtxt<'tcx>, body: &Body<'tcx>, msrv: Option<RustcVersion>) -> McfResult {
     let def_id = body.source.def_id();
     let mut current = def_id;
     loop {
@@ -276,9 +276,9 @@ fn check_place<'tcx>(tcx: TyCtxt<'tcx>, place: Place<'tcx>, span: Span, body: &B
     Ok(())
 }
 
-fn check_terminator<'a, 'tcx>(
+fn check_terminator<'tcx>(
     tcx: TyCtxt<'tcx>,
-    body: &'a Body<'tcx>,
+    body: &Body<'tcx>,
     terminator: &Terminator<'tcx>,
     msrv: Option<RustcVersion>,
 ) -> McfResult {
diff --git a/clippy_utils/src/sugg.rs b/clippy_utils/src/sugg.rs
index 01c2b11f65b..45181d3c7a8 100644
--- a/clippy_utils/src/sugg.rs
+++ b/clippy_utils/src/sugg.rs
@@ -801,7 +801,7 @@ pub struct DerefClosure {
 /// Returns `None` if no such use cases have been triggered in closure body
 ///
 /// note: this only works on single line immutable closures with exactly one input parameter.
-pub fn deref_closure_args<'tcx>(cx: &LateContext<'_>, closure: &'tcx hir::Expr<'_>) -> Option<DerefClosure> {
+pub fn deref_closure_args(cx: &LateContext<'_>, closure: &hir::Expr<'_>) -> Option<DerefClosure> {
     if let hir::ExprKind::Closure(&Closure { fn_decl, body, .. }) = closure.kind {
         let closure_body = cx.tcx.hir().body(body);
         // is closure arg a type annotated double reference (i.e.: `|x: &&i32| ...`)
diff --git a/tests/ui/crashes/ice-2774.stderr b/tests/ui/crashes/ice-2774.stderr
index 0c2d48f938f..1f26c7f4db6 100644
--- a/tests/ui/crashes/ice-2774.stderr
+++ b/tests/ui/crashes/ice-2774.stderr
@@ -1,4 +1,4 @@
-error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+error: the following explicit lifetimes could be elided: 'a
   --> $DIR/ice-2774.rs:15:1
    |
 LL | pub fn add_barfoos_to_foos<'a>(bars: &HashSet<&'a Bar>) {
diff --git a/tests/ui/crashes/needless_lifetimes_impl_trait.stderr b/tests/ui/crashes/needless_lifetimes_impl_trait.stderr
index d68bbe78802..875d5ab4f21 100644
--- a/tests/ui/crashes/needless_lifetimes_impl_trait.stderr
+++ b/tests/ui/crashes/needless_lifetimes_impl_trait.stderr
@@ -1,4 +1,4 @@
-error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+error: the following explicit lifetimes could be elided: 'a
   --> $DIR/needless_lifetimes_impl_trait.rs:15:5
    |
 LL |     fn baz<'a>(&'a self) -> impl Foo + 'a {
diff --git a/tests/ui/issue_4266.stderr b/tests/ui/issue_4266.stderr
index fb2a93c9580..fd553aa4538 100644
--- a/tests/ui/issue_4266.stderr
+++ b/tests/ui/issue_4266.stderr
@@ -1,4 +1,4 @@
-error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+error: the following explicit lifetimes could be elided: 'a
   --> $DIR/issue_4266.rs:4:1
    |
 LL | async fn sink1<'a>(_: &'a str) {} // lint
@@ -6,7 +6,7 @@ LL | async fn sink1<'a>(_: &'a str) {} // lint
    |
    = note: `-D clippy::needless-lifetimes` implied by `-D warnings`
 
-error: explicit lifetimes given in parameter types where they could be elided (or replaced with `'_` if needed by type declaration)
+error: the following explicit lifetimes could be elided: 'a
   --> $DIR/issue_4266.rs:8:1
    |
 LL | async fn one_to_one<'a>(s: &'a str) -> &'a str {
-- 
cgit 1.4.1-3-g733a5


From e19fe890911cce2258e4e670e037d88e61fae951 Mon Sep 17 00:00:00 2001
From: Andre Bogus <bogusandre@gmail.com>
Date: Fri, 14 Oct 2022 16:07:22 +0200
Subject: fix `undocumented-unsafe-blocks` false positive

---
 clippy_lints/src/undocumented_unsafe_blocks.rs | 40 ++++++++++++++++++++++++--
 tests/ui/undocumented_unsafe_blocks.rs         | 19 ++++++++++++
 tests/ui/undocumented_unsafe_blocks.stderr     | 26 ++++++++++++++++-
 3 files changed, 81 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/undocumented_unsafe_blocks.rs b/clippy_lints/src/undocumented_unsafe_blocks.rs
index d2e675a783e..e8f15a44473 100644
--- a/clippy_lints/src/undocumented_unsafe_blocks.rs
+++ b/clippy_lints/src/undocumented_unsafe_blocks.rs
@@ -68,7 +68,8 @@ impl LateLintPass<'_> for UndocumentedUnsafeBlocks {
             && !in_external_macro(cx.tcx.sess, block.span)
             && !is_lint_allowed(cx, UNDOCUMENTED_UNSAFE_BLOCKS, block.hir_id)
             && !is_unsafe_from_proc_macro(cx, block.span)
-            && !block_has_safety_comment(cx, block)
+            && !block_has_safety_comment(cx, block.span)
+            && !block_parents_have_safety_comment(cx, block.hir_id)
         {
             let source_map = cx.tcx.sess.source_map();
             let span = if source_map.is_multiline(block.span) {
@@ -126,8 +127,41 @@ fn is_unsafe_from_proc_macro(cx: &LateContext<'_>, span: Span) -> bool {
         .map_or(true, |src| !src.starts_with("unsafe"))
 }
 
+// Checks if any parent {expression, statement, block, local, const, static}
+// has a safety comment
+fn block_parents_have_safety_comment(cx: &LateContext<'_>, id: hir::HirId) -> bool {
+    if let Some(node) = get_parent_node(cx.tcx, id) {
+        return match node {
+            Node::Expr(expr) => !is_branchy(expr) && span_in_body_has_safety_comment(cx, expr.span),
+            Node::Stmt(hir::Stmt {
+                kind:
+                    hir::StmtKind::Local(hir::Local { span, .. })
+                    | hir::StmtKind::Expr(hir::Expr { span, .. })
+                    | hir::StmtKind::Semi(hir::Expr { span, .. }),
+                ..
+            })
+            | Node::Local(hir::Local { span, .. })
+            | Node::Item(hir::Item {
+                kind: hir::ItemKind::Const(..) | ItemKind::Static(..),
+                span,
+                ..
+            }) => span_in_body_has_safety_comment(cx, *span),
+            _ => false,
+        };
+    }
+    false
+}
+
+/// Checks if an expression is "branchy", e.g. loop, match/if/etc.
+fn is_branchy(expr: &hir::Expr<'_>) -> bool {
+    matches!(
+        expr.kind,
+        hir::ExprKind::If(..) | hir::ExprKind::Loop(..) | hir::ExprKind::Match(..)
+    )
+}
+
 /// Checks if the lines immediately preceding the block contain a safety comment.
-fn block_has_safety_comment(cx: &LateContext<'_>, block: &hir::Block<'_>) -> bool {
+fn block_has_safety_comment(cx: &LateContext<'_>, span: Span) -> bool {
     // This intentionally ignores text before the start of a function so something like:
     // ```
     //     // SAFETY: reason
@@ -136,7 +170,7 @@ fn block_has_safety_comment(cx: &LateContext<'_>, block: &hir::Block<'_>) -> boo
     // won't work. This is to avoid dealing with where such a comment should be place relative to
     // attributes and doc comments.
 
-    span_from_macro_expansion_has_safety_comment(cx, block.span) || span_in_body_has_safety_comment(cx, block.span)
+    span_from_macro_expansion_has_safety_comment(cx, span) || span_in_body_has_safety_comment(cx, span)
 }
 
 /// Checks if the lines immediately preceding the item contain a safety comment.
diff --git a/tests/ui/undocumented_unsafe_blocks.rs b/tests/ui/undocumented_unsafe_blocks.rs
index 08aee433215..cbc6768033e 100644
--- a/tests/ui/undocumented_unsafe_blocks.rs
+++ b/tests/ui/undocumented_unsafe_blocks.rs
@@ -490,4 +490,23 @@ unsafe impl CrateRoot for () {}
 // SAFETY: ok
 unsafe impl CrateRoot for (i32) {}
 
+fn issue_9142() {
+    // SAFETY: ok
+    let _ =
+        // we need this comment to avoid rustfmt putting
+        // it all on one line
+        unsafe {};
+
+    // SAFETY: this is more than one level away, so it should warn
+    let _ = {
+        if unsafe { true } {
+            todo!();
+        } else {
+            let bar = unsafe {};
+            todo!();
+            bar
+        }
+    };
+}
+
 fn main() {}
diff --git a/tests/ui/undocumented_unsafe_blocks.stderr b/tests/ui/undocumented_unsafe_blocks.stderr
index 2c466ff5c73..ba4de9806d1 100644
--- a/tests/ui/undocumented_unsafe_blocks.stderr
+++ b/tests/ui/undocumented_unsafe_blocks.stderr
@@ -263,5 +263,29 @@ LL | unsafe impl CrateRoot for () {}
    |
    = help: consider adding a safety comment on the preceding line
 
-error: aborting due to 31 previous errors
+error: unsafe block missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:498:9
+   |
+LL |         unsafe {};
+   |         ^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: unsafe block missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:502:12
+   |
+LL |         if unsafe { true } {
+   |            ^^^^^^^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: unsafe block missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:505:23
+   |
+LL |             let bar = unsafe {};
+   |                       ^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: aborting due to 34 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 329dc4715bb152c98d4a5d59747604f3e79a2bb6 Mon Sep 17 00:00:00 2001
From: Matthew Ingwersen <matttpt@gmail.com>
Date: Fri, 28 Oct 2022 15:48:04 -0400
Subject: Fix `redundant_closure_for_method_calls` suggestion

Certain types must be enclosed in angle brackets and must have generic
arguments substituted to create a working suggestion. For example, if
`s` has type `&[u8]`, then `|s| s.len()` may be replaced with
`<[u8]>::len`. Previously, Clippy erroneously suggested `[T]::len`.
---
 clippy_lints/src/eta_reduction.rs | 15 ++++++++++++---
 tests/ui/eta.fixed                | 22 ++++++++++++++++++++++
 tests/ui/eta.rs                   | 22 ++++++++++++++++++++++
 tests/ui/eta.stderr               | 26 +++++++++++++++++++++++++-
 4 files changed, 81 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/eta_reduction.rs b/clippy_lints/src/eta_reduction.rs
index 7b9786d7e57..9588be7364d 100644
--- a/clippy_lints/src/eta_reduction.rs
+++ b/clippy_lints/src/eta_reduction.rs
@@ -11,7 +11,7 @@ use rustc_hir::{Closure, Expr, ExprKind, Param, PatKind, Unsafety};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::adjustment::{Adjust, Adjustment, AutoBorrow};
 use rustc_middle::ty::binding::BindingMode;
-use rustc_middle::ty::{self, Ty, TypeVisitable};
+use rustc_middle::ty::{self, EarlyBinder, SubstsRef, Ty, TypeVisitable};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::symbol::sym;
 
@@ -150,7 +150,7 @@ impl<'tcx> LateLintPass<'tcx> for EtaReduction {
             if check_sig(cx, closure_ty, call_ty);
             then {
                 span_lint_and_then(cx, REDUNDANT_CLOSURE_FOR_METHOD_CALLS, expr.span, "redundant closure", |diag| {
-                    let name = get_ufcs_type_name(cx, method_def_id);
+                    let name = get_ufcs_type_name(cx, method_def_id, substs);
                     diag.span_suggestion(
                         expr.span,
                         "replace the closure with the method itself",
@@ -220,7 +220,7 @@ fn check_sig<'tcx>(cx: &LateContext<'tcx>, closure_ty: Ty<'tcx>, call_ty: Ty<'tc
     cx.tcx.erase_late_bound_regions(closure_sig) == cx.tcx.erase_late_bound_regions(call_sig)
 }
 
-fn get_ufcs_type_name(cx: &LateContext<'_>, method_def_id: DefId) -> String {
+fn get_ufcs_type_name<'tcx>(cx: &LateContext<'tcx>, method_def_id: DefId, substs: SubstsRef<'tcx>) -> String {
     let assoc_item = cx.tcx.associated_item(method_def_id);
     let def_id = assoc_item.container_id(cx.tcx);
     match assoc_item.container {
@@ -229,6 +229,15 @@ fn get_ufcs_type_name(cx: &LateContext<'_>, method_def_id: DefId) -> String {
             let ty = cx.tcx.type_of(def_id);
             match ty.kind() {
                 ty::Adt(adt, _) => cx.tcx.def_path_str(adt.did()),
+                ty::Array(..)
+                | ty::Dynamic(..)
+                | ty::Never
+                | ty::RawPtr(_)
+                | ty::Ref(..)
+                | ty::Slice(_)
+                | ty::Tuple(_) => {
+                    format!("<{}>", EarlyBinder(ty).subst(cx.tcx, substs))
+                },
                 _ => ty.to_string(),
             }
         },
diff --git a/tests/ui/eta.fixed b/tests/ui/eta.fixed
index a9cc80aaaf6..dc129591eac 100644
--- a/tests/ui/eta.fixed
+++ b/tests/ui/eta.fixed
@@ -316,3 +316,25 @@ pub fn mutable_impl_fn_mut(mut f: impl FnMut(), mut f_used_once: impl FnMut()) -
 
     move || takes_fn_mut(&mut f_used_once)
 }
+
+impl dyn TestTrait + '_ {
+    fn method_on_dyn(&self) -> bool {
+        false
+    }
+}
+
+// https://github.com/rust-lang/rust-clippy/issues/7746
+fn angle_brackets_and_substs() {
+    let array_opt: Option<&[u8; 3]> = Some(&[4, 8, 7]);
+    array_opt.map(<[u8; 3]>::as_slice);
+
+    let slice_opt: Option<&[u8]> = Some(b"slice");
+    slice_opt.map(<[u8]>::len);
+
+    let ptr_opt: Option<*const usize> = Some(&487);
+    ptr_opt.map(<*const usize>::is_null);
+
+    let test_struct = TestStruct { some_ref: &487 };
+    let dyn_opt: Option<&dyn TestTrait> = Some(&test_struct);
+    dyn_opt.map(<dyn TestTrait>::method_on_dyn);
+}
diff --git a/tests/ui/eta.rs b/tests/ui/eta.rs
index cc99906ccd6..025fd6a0b7a 100644
--- a/tests/ui/eta.rs
+++ b/tests/ui/eta.rs
@@ -316,3 +316,25 @@ pub fn mutable_impl_fn_mut(mut f: impl FnMut(), mut f_used_once: impl FnMut()) -
 
     move || takes_fn_mut(|| f_used_once())
 }
+
+impl dyn TestTrait + '_ {
+    fn method_on_dyn(&self) -> bool {
+        false
+    }
+}
+
+// https://github.com/rust-lang/rust-clippy/issues/7746
+fn angle_brackets_and_substs() {
+    let array_opt: Option<&[u8; 3]> = Some(&[4, 8, 7]);
+    array_opt.map(|a| a.as_slice());
+
+    let slice_opt: Option<&[u8]> = Some(b"slice");
+    slice_opt.map(|s| s.len());
+
+    let ptr_opt: Option<*const usize> = Some(&487);
+    ptr_opt.map(|p| p.is_null());
+
+    let test_struct = TestStruct { some_ref: &487 };
+    let dyn_opt: Option<&dyn TestTrait> = Some(&test_struct);
+    dyn_opt.map(|d| d.method_on_dyn());
+}
diff --git a/tests/ui/eta.stderr b/tests/ui/eta.stderr
index 434706b7e25..a521fb86860 100644
--- a/tests/ui/eta.stderr
+++ b/tests/ui/eta.stderr
@@ -134,5 +134,29 @@ error: redundant closure
 LL |     move || takes_fn_mut(|| f_used_once())
    |                          ^^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `&mut f_used_once`
 
-error: aborting due to 22 previous errors
+error: redundant closure
+  --> $DIR/eta.rs:329:19
+   |
+LL |     array_opt.map(|a| a.as_slice());
+   |                   ^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `<[u8; 3]>::as_slice`
+
+error: redundant closure
+  --> $DIR/eta.rs:332:19
+   |
+LL |     slice_opt.map(|s| s.len());
+   |                   ^^^^^^^^^^^ help: replace the closure with the method itself: `<[u8]>::len`
+
+error: redundant closure
+  --> $DIR/eta.rs:335:17
+   |
+LL |     ptr_opt.map(|p| p.is_null());
+   |                 ^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `<*const usize>::is_null`
+
+error: redundant closure
+  --> $DIR/eta.rs:339:17
+   |
+LL |     dyn_opt.map(|d| d.method_on_dyn());
+   |                 ^^^^^^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `<dyn TestTrait>::method_on_dyn`
+
+error: aborting due to 26 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From ad5dfcd123a236fd588cd83fb4aba29be5535bc4 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Sat, 29 Oct 2022 12:15:51 +0000
Subject: Fix `bool_to_int_with_if` false positive with `if let`

---
 clippy_lints/src/bool_to_int_with_if.rs |  7 ++++---
 tests/ui/bool_to_int_with_if.fixed      | 20 ++++++++++++++++++++
 tests/ui/bool_to_int_with_if.rs         | 20 ++++++++++++++++++++
 tests/ui/bool_to_int_with_if.stderr     | 18 +++++++++---------
 4 files changed, 53 insertions(+), 12 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/bool_to_int_with_if.rs b/clippy_lints/src/bool_to_int_with_if.rs
index 88bdfefddf7..40ded405669 100644
--- a/clippy_lints/src/bool_to_int_with_if.rs
+++ b/clippy_lints/src/bool_to_int_with_if.rs
@@ -1,3 +1,4 @@
+use clippy_utils::higher::If;
 use rustc_ast::LitKind;
 use rustc_hir::{Block, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
@@ -52,9 +53,9 @@ impl<'tcx> LateLintPass<'tcx> for BoolToIntWithIf {
 }
 
 fn check_if_else<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx rustc_hir::Expr<'tcx>) {
-    if let ExprKind::If(check, then, Some(else_)) = expr.kind
+    if let Some(If { cond, then, r#else: Some(r#else) }) = If::hir(expr)
         && let Some(then_lit) = int_literal(then)
-        && let Some(else_lit) = int_literal(else_)
+        && let Some(else_lit) = int_literal(r#else)
     {
         let inverted = if is_integer_literal(then_lit, 1) && is_integer_literal(else_lit, 0) {
             false
@@ -66,7 +67,7 @@ fn check_if_else<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx rustc_hir::Expr<'tcx>
         };
         let mut applicability = Applicability::MachineApplicable;
         let snippet = {
-            let mut sugg = Sugg::hir_with_applicability(cx, check, "..", &mut applicability);
+            let mut sugg = Sugg::hir_with_applicability(cx, cond, "..", &mut applicability);
             if inverted {
                 sugg = !sugg;
             }
diff --git a/tests/ui/bool_to_int_with_if.fixed b/tests/ui/bool_to_int_with_if.fixed
index 6e0ff053ff2..37d3e3286a4 100644
--- a/tests/ui/bool_to_int_with_if.fixed
+++ b/tests/ui/bool_to_int_with_if.fixed
@@ -1,5 +1,6 @@
 // run-rustfix
 
+#![feature(let_chains)]
 #![warn(clippy::bool_to_int_with_if)]
 #![allow(unused, dead_code, clippy::unnecessary_operation, clippy::no_effect)]
 
@@ -91,3 +92,22 @@ fn side_effect() {}
 fn cond(a: bool, b: bool) -> bool {
     a || b
 }
+
+enum Enum {
+    A,
+    B,
+}
+
+fn if_let(a: Enum, b: Enum) {
+    if let Enum::A = a {
+        1
+    } else {
+        0
+    };
+
+    if let Enum::A = a && let Enum::B = b {
+        1
+    } else {
+        0
+    };
+}
diff --git a/tests/ui/bool_to_int_with_if.rs b/tests/ui/bool_to_int_with_if.rs
index 90ad5aa64da..ebdf86fd185 100644
--- a/tests/ui/bool_to_int_with_if.rs
+++ b/tests/ui/bool_to_int_with_if.rs
@@ -1,5 +1,6 @@
 // run-rustfix
 
+#![feature(let_chains)]
 #![warn(clippy::bool_to_int_with_if)]
 #![allow(unused, dead_code, clippy::unnecessary_operation, clippy::no_effect)]
 
@@ -123,3 +124,22 @@ fn side_effect() {}
 fn cond(a: bool, b: bool) -> bool {
     a || b
 }
+
+enum Enum {
+    A,
+    B,
+}
+
+fn if_let(a: Enum, b: Enum) {
+    if let Enum::A = a {
+        1
+    } else {
+        0
+    };
+
+    if let Enum::A = a && let Enum::B = b {
+        1
+    } else {
+        0
+    };
+}
diff --git a/tests/ui/bool_to_int_with_if.stderr b/tests/ui/bool_to_int_with_if.stderr
index 1f447c9bfd1..5cfb75cc0df 100644
--- a/tests/ui/bool_to_int_with_if.stderr
+++ b/tests/ui/bool_to_int_with_if.stderr
@@ -1,5 +1,5 @@
 error: boolean to int conversion using if
-  --> $DIR/bool_to_int_with_if.rs:15:5
+  --> $DIR/bool_to_int_with_if.rs:16:5
    |
 LL | /     if a {
 LL | |         1
@@ -12,7 +12,7 @@ LL | |     };
    = note: `-D clippy::bool-to-int-with-if` implied by `-D warnings`
 
 error: boolean to int conversion using if
-  --> $DIR/bool_to_int_with_if.rs:20:5
+  --> $DIR/bool_to_int_with_if.rs:21:5
    |
 LL | /     if a {
 LL | |         0
@@ -24,7 +24,7 @@ LL | |     };
    = note: `!a as i32` or `(!a).into()` can also be valid options
 
 error: boolean to int conversion using if
-  --> $DIR/bool_to_int_with_if.rs:25:5
+  --> $DIR/bool_to_int_with_if.rs:26:5
    |
 LL | /     if !a {
 LL | |         1
@@ -36,7 +36,7 @@ LL | |     };
    = note: `!a as i32` or `(!a).into()` can also be valid options
 
 error: boolean to int conversion using if
-  --> $DIR/bool_to_int_with_if.rs:30:5
+  --> $DIR/bool_to_int_with_if.rs:31:5
    |
 LL | /     if a || b {
 LL | |         1
@@ -48,7 +48,7 @@ LL | |     };
    = note: `(a || b) as i32` or `(a || b).into()` can also be valid options
 
 error: boolean to int conversion using if
-  --> $DIR/bool_to_int_with_if.rs:35:5
+  --> $DIR/bool_to_int_with_if.rs:36:5
    |
 LL | /     if cond(a, b) {
 LL | |         1
@@ -60,7 +60,7 @@ LL | |     };
    = note: `cond(a, b) as i32` or `cond(a, b).into()` can also be valid options
 
 error: boolean to int conversion using if
-  --> $DIR/bool_to_int_with_if.rs:40:5
+  --> $DIR/bool_to_int_with_if.rs:41:5
    |
 LL | /     if x + y < 4 {
 LL | |         1
@@ -72,7 +72,7 @@ LL | |     };
    = note: `(x + y < 4) as i32` or `(x + y < 4).into()` can also be valid options
 
 error: boolean to int conversion using if
-  --> $DIR/bool_to_int_with_if.rs:49:12
+  --> $DIR/bool_to_int_with_if.rs:50:12
    |
 LL |       } else if b {
    |  ____________^
@@ -85,7 +85,7 @@ LL | |     };
    = note: `b as i32` or `b.into()` can also be valid options
 
 error: boolean to int conversion using if
-  --> $DIR/bool_to_int_with_if.rs:58:12
+  --> $DIR/bool_to_int_with_if.rs:59:12
    |
 LL |       } else if b {
    |  ____________^
@@ -98,7 +98,7 @@ LL | |     };
    = note: `!b as i32` or `(!b).into()` can also be valid options
 
 error: boolean to int conversion using if
-  --> $DIR/bool_to_int_with_if.rs:118:5
+  --> $DIR/bool_to_int_with_if.rs:119:5
    |
 LL |     if a { 1 } else { 0 }
    |     ^^^^^^^^^^^^^^^^^^^^^ help: replace with from: `u8::from(a)`
-- 
cgit 1.4.1-3-g733a5


From 00cf07b5214d7b072470bb4584737f51242bdd55 Mon Sep 17 00:00:00 2001
From: kraktus <kraktus@users.noreply.github.com>
Date: Sat, 29 Oct 2022 16:32:11 +0200
Subject: [`option_if_let_else`] do not lint if any arm has guard

---
 clippy_lints/src/option_if_let_else.rs | 13 ++++++++-----
 tests/ui/option_if_let_else.fixed      |  9 +++++++++
 tests/ui/option_if_let_else.rs         |  9 +++++++++
 3 files changed, 26 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/option_if_let_else.rs b/clippy_lints/src/option_if_let_else.rs
index 4eb42da1fed..472f52380bb 100644
--- a/clippy_lints/src/option_if_let_else.rs
+++ b/clippy_lints/src/option_if_let_else.rs
@@ -213,11 +213,14 @@ fn try_convert_match<'tcx>(
     cx: &LateContext<'tcx>,
     arms: &[Arm<'tcx>],
 ) -> Option<(&'tcx Pat<'tcx>, &'tcx Expr<'tcx>, &'tcx Expr<'tcx>)> {
-    if arms.len() == 2 {
-        return if is_none_or_err_arm(cx, &arms[1]) {
-            Some((arms[0].pat, arms[0].body, arms[1].body))
-        } else if is_none_or_err_arm(cx, &arms[0]) {
-            Some((arms[1].pat, arms[1].body, arms[0].body))
+    if let [first_arm, second_arm] = arms
+        && first_arm.guard.is_none()
+        && second_arm.guard.is_none()
+        {
+        return if is_none_or_err_arm(cx, second_arm) {
+            Some((first_arm.pat, first_arm.body, second_arm.body))
+        } else if is_none_or_err_arm(cx, first_arm) {
+            Some((second_arm.pat, second_arm.body, first_arm.body))
         } else {
             None
         };
diff --git a/tests/ui/option_if_let_else.fixed b/tests/ui/option_if_let_else.fixed
index f15ac551bb3..0456005dce4 100644
--- a/tests/ui/option_if_let_else.fixed
+++ b/tests/ui/option_if_let_else.fixed
@@ -189,3 +189,12 @@ fn main() {
     let _ = res.map_or(1, |a| a + 1);
     let _ = res.map_or(5, |a| a + 1);
 }
+
+#[allow(dead_code)]
+fn issue9742() -> Option<&'static str> {
+    // should not lint because of guards
+    match Some("foo  ") {
+        Some(name) if name.starts_with("foo") => Some(name.trim()),
+        _ => None,
+    }
+}
diff --git a/tests/ui/option_if_let_else.rs b/tests/ui/option_if_let_else.rs
index 9eeaea12d3b..23b148752cb 100644
--- a/tests/ui/option_if_let_else.rs
+++ b/tests/ui/option_if_let_else.rs
@@ -230,3 +230,12 @@ fn main() {
     };
     let _ = if let Ok(a) = res { a + 1 } else { 5 };
 }
+
+#[allow(dead_code)]
+fn issue9742() -> Option<&'static str> {
+    // should not lint because of guards
+    match Some("foo  ") {
+        Some(name) if name.starts_with("foo") => Some(name.trim()),
+        _ => None,
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 2c443984870c2a28ea54e8f8306749c8827dfb2d Mon Sep 17 00:00:00 2001
From: Samuel Moelius <sam@moeli.us>
Date: Sun, 30 Oct 2022 06:47:35 -0400
Subject: Adress review comments

---
 clippy_lints/src/lifetimes.rs                      |  81 ++++-------
 .../src/matches/significant_drop_in_scrutinee.rs   |   4 +-
 tests/ui/mut_from_ref.rs                           |   2 +-
 tests/ui/needless_lifetimes.rs                     |  90 ++++++++++--
 tests/ui/needless_lifetimes.stderr                 | 160 ++++++++++++++++-----
 tests/ui/transmute.rs                              |   2 +-
 tests/ui/trivially_copy_pass_by_ref.rs             |   1 +
 tests/ui/trivially_copy_pass_by_ref.stderr         |  36 ++---
 8 files changed, 258 insertions(+), 118 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lifetimes.rs b/clippy_lints/src/lifetimes.rs
index 996eb277426..36e75d45fd7 100644
--- a/clippy_lints/src/lifetimes.rs
+++ b/clippy_lints/src/lifetimes.rs
@@ -236,7 +236,6 @@ fn explicit_self_type<'tcx>(cx: &LateContext<'tcx>, func: &FnDecl<'tcx>, ident:
     }
 }
 
-#[expect(clippy::too_many_lines)]
 fn could_use_elision<'tcx>(
     cx: &LateContext<'tcx>,
     func: &'tcx FnDecl<'_>,
@@ -331,50 +330,32 @@ fn could_use_elision<'tcx>(
         }
     }
 
-    // no input lifetimes? easy case!
-    if input_lts.is_empty() {
-        None
-    } else if output_lts.is_empty() {
-        // no output lifetimes, check distinctness of input lifetimes
+    // A lifetime can be newly elided if:
+    // - It occurs only once among the inputs.
+    // - If there are multiple input lifetimes, then the newly elided lifetime does not occur among the
+    //   outputs (because eliding such an lifetime would create an ambiguity).
+    let elidable_lts = named_lifetime_occurrences(&input_lts)
+        .into_iter()
+        .filter_map(|(def_id, occurrences)| {
+            if occurrences <= 1 && (input_lts.len() <= 1 || !output_lts.contains(&RefLt::Named(def_id))) {
+                Some((
+                    def_id,
+                    input_visitor
+                        .lifetime_generic_arg_spans
+                        .get(&def_id)
+                        .or_else(|| output_visitor.lifetime_generic_arg_spans.get(&def_id))
+                        .copied(),
+                ))
+            } else {
+                None
+            }
+        })
+        .collect::<Vec<_>>();
 
-        // only unnamed and static, ok
-        let unnamed_and_static = input_lts.iter().all(|lt| *lt == RefLt::Unnamed || *lt == RefLt::Static);
-        if unnamed_and_static {
-            return None;
-        }
-        // we have no output reference, so we can elide explicit lifetimes that occur at most once
-        let elidable_lts = named_lifetime_occurrences(&input_lts)
-            .into_iter()
-            .filter_map(|(def_id, occurrences)| {
-                if occurrences <= 1 {
-                    Some((def_id, input_visitor.sample_generic_arg_span.get(&def_id).copied()))
-                } else {
-                    None
-                }
-            })
-            .collect::<Vec<_>>();
-        if elidable_lts.is_empty() {
-            None
-        } else {
-            Some(elidable_lts)
-        }
+    if elidable_lts.is_empty() {
+        None
     } else {
-        // we have output references, so we need one input reference,
-        // and all output lifetimes must be the same
-        if input_lts.len() == 1 {
-            match (&input_lts[0], &output_lts[0]) {
-                (&RefLt::Named(n1), &RefLt::Named(n2)) if n1 == n2 => {
-                    Some(vec![(n1, input_visitor.sample_generic_arg_span.get(&n1).copied())])
-                },
-                (&RefLt::Named(n), &RefLt::Unnamed) => {
-                    Some(vec![(n, input_visitor.sample_generic_arg_span.get(&n).copied())])
-                },
-                _ => None, /* already elided, different named lifetimes
-                            * or something static going on */
-            }
-        } else {
-            None
-        }
+        Some(elidable_lts)
     }
 }
 
@@ -397,11 +378,11 @@ fn named_lifetime_occurrences(lts: &[RefLt]) -> Vec<(LocalDefId, usize)> {
     let mut occurrences = Vec::new();
     for lt in lts {
         if let &RefLt::Named(curr_def_id) = lt {
-            if let Some(i) = occurrences
-                .iter()
-                .position(|&(prev_def_id, _)| prev_def_id == curr_def_id)
+            if let Some(pair) = occurrences
+                .iter_mut()
+                .find(|(prev_def_id, _)| *prev_def_id == curr_def_id)
             {
-                occurrences[i].1 += 1;
+                pair.1 += 1;
             } else {
                 occurrences.push((curr_def_id, 1));
             }
@@ -416,7 +397,7 @@ const CLOSURE_TRAIT_BOUNDS: [LangItem; 3] = [LangItem::Fn, LangItem::FnMut, Lang
 struct RefVisitor<'a, 'tcx> {
     cx: &'a LateContext<'tcx>,
     lts: Vec<RefLt>,
-    sample_generic_arg_span: FxHashMap<LocalDefId, Span>,
+    lifetime_generic_arg_spans: FxHashMap<LocalDefId, Span>,
     nested_elision_site_lts: Vec<RefLt>,
     unelided_trait_object_lifetime: bool,
 }
@@ -426,7 +407,7 @@ impl<'a, 'tcx> RefVisitor<'a, 'tcx> {
         Self {
             cx,
             lts: Vec::new(),
-            sample_generic_arg_span: FxHashMap::default(),
+            lifetime_generic_arg_spans: FxHashMap::default(),
             nested_elision_site_lts: Vec::new(),
             unelided_trait_object_lifetime: false,
         }
@@ -525,7 +506,7 @@ impl<'a, 'tcx> Visitor<'tcx> for RefVisitor<'a, 'tcx> {
         if let GenericArg::Lifetime(l) = generic_arg
             && let LifetimeName::Param(def_id, _) = l.name
         {
-            self.sample_generic_arg_span.entry(def_id).or_insert(l.span);
+            self.lifetime_generic_arg_spans.entry(def_id).or_insert(l.span);
         }
         // Replace with `walk_generic_arg` if/when https://github.com/rust-lang/rust/pull/103692 lands.
         // walk_generic_arg(self, generic_arg);
diff --git a/clippy_lints/src/matches/significant_drop_in_scrutinee.rs b/clippy_lints/src/matches/significant_drop_in_scrutinee.rs
index 78c70d1c8d8..f587c69f730 100644
--- a/clippy_lints/src/matches/significant_drop_in_scrutinee.rs
+++ b/clippy_lints/src/matches/significant_drop_in_scrutinee.rs
@@ -83,8 +83,8 @@ fn set_diagnostic<'tcx>(diag: &mut Diagnostic, cx: &LateContext<'tcx>, expr: &'t
 
 /// If the expression is an `ExprKind::Match`, check if the scrutinee has a significant drop that
 /// may have a surprising lifetime.
-fn has_significant_drop_in_scrutinee<'tcx, 'a>(
-    cx: &'a LateContext<'tcx>,
+fn has_significant_drop_in_scrutinee<'tcx>(
+    cx: &LateContext<'tcx>,
     scrutinee: &'tcx Expr<'tcx>,
     source: MatchSource,
 ) -> Option<(Vec<FoundSigDrop>, &'static str)> {
diff --git a/tests/ui/mut_from_ref.rs b/tests/ui/mut_from_ref.rs
index 370dbd58821..7de15330594 100644
--- a/tests/ui/mut_from_ref.rs
+++ b/tests/ui/mut_from_ref.rs
@@ -1,4 +1,4 @@
-#![allow(unused)]
+#![allow(unused, clippy::needless_lifetimes)]
 #![warn(clippy::mut_from_ref)]
 
 struct Foo;
diff --git a/tests/ui/needless_lifetimes.rs b/tests/ui/needless_lifetimes.rs
index 3fe12214294..2efc936752e 100644
--- a/tests/ui/needless_lifetimes.rs
+++ b/tests/ui/needless_lifetimes.rs
@@ -29,11 +29,20 @@ fn multiple_in_and_out_1<'a>(x: &'a u8, _y: &'a u8) -> &'a u8 {
     x
 }
 
-// No error; multiple input refs.
-fn multiple_in_and_out_2<'a, 'b>(x: &'a u8, _y: &'b u8) -> &'a u8 {
+// Error; multiple input refs, but the output lifetime is not elided, i.e., the following is valid:
+//   fn multiple_in_and_out_2a<'a>(x: &'a u8, _y: &u8) -> &'a u8
+//                                                ^^^
+fn multiple_in_and_out_2a<'a, 'b>(x: &'a u8, _y: &'b u8) -> &'a u8 {
     x
 }
 
+// Error; multiple input refs, but the output lifetime is not elided, i.e., the following is valid:
+//   fn multiple_in_and_out_2b<'b>(_x: &u8, y: &'b u8) -> &'b u8
+//                                     ^^^
+fn multiple_in_and_out_2b<'a, 'b>(_x: &'a u8, y: &'b u8) -> &'b u8 {
+    y
+}
+
 // No error; multiple input refs
 async fn func<'a>(args: &[&'a str]) -> Option<&'a str> {
     args.get(0).cloned()
@@ -44,11 +53,20 @@ fn in_static_and_out<'a>(x: &'a u8, _y: &'static u8) -> &'a u8 {
     x
 }
 
-// No error.
-fn deep_reference_1<'a, 'b>(x: &'a u8, _y: &'b u8) -> Result<&'a u8, ()> {
+// Error; multiple input refs, but the output lifetime is not elided, i.e., the following is valid:
+//   fn deep_reference_1a<'a>(x: &'a u8, _y: &u8) -> Result<&'a u8, ()>
+//                                           ^^^
+fn deep_reference_1a<'a, 'b>(x: &'a u8, _y: &'b u8) -> Result<&'a u8, ()> {
     Ok(x)
 }
 
+// Error; multiple input refs, but the output lifetime is not elided, i.e., the following is valid:
+//   fn deep_reference_1b<'b>(_x: &u8, y: &'b u8) -> Result<&'b u8, ()>
+//                                ^^^
+fn deep_reference_1b<'a, 'b>(_x: &'a u8, y: &'b u8) -> Result<&'b u8, ()> {
+    Ok(y)
+}
+
 // No error; two input refs.
 fn deep_reference_2<'a>(x: Result<&'a u8, &'a u8>) -> &'a u8 {
     x.unwrap()
@@ -129,11 +147,20 @@ impl X {
         &self.x
     }
 
-    // No error; multiple input refs.
-    fn self_and_in_out<'s, 't>(&'s self, _x: &'t u8) -> &'s u8 {
+    // Error; multiple input refs, but the output lifetime is not elided, i.e., the following is valid:
+    //   fn self_and_in_out_1<'s>(&'s self, _x: &u8) -> &'s u8
+    //                                          ^^^
+    fn self_and_in_out_1<'s, 't>(&'s self, _x: &'t u8) -> &'s u8 {
         &self.x
     }
 
+    // Error; multiple input refs, but the output lifetime is not elided, i.e., the following is valid:
+    //   fn self_and_in_out_2<'t>(&self, x: &'t u8) -> &'t u8
+    //                            ^^^^^
+    fn self_and_in_out_2<'s, 't>(&'s self, x: &'t u8) -> &'t u8 {
+        x
+    }
+
     fn distinct_self_and_in<'s, 't>(&'s self, _x: &'t u8) {}
 
     // No error; same lifetimes on two params.
@@ -167,8 +194,19 @@ fn struct_with_lt3<'a>(_foo: &Foo<'a>) -> &'a str {
     unimplemented!()
 }
 
-// No warning; two input lifetimes.
-fn struct_with_lt4<'a, 'b>(_foo: &'a Foo<'b>) -> &'a str {
+// Warning; two input lifetimes, but the output lifetime is not elided, i.e., the following is
+// valid:
+//   fn struct_with_lt4a<'a>(_foo: &'a Foo<'_>) -> &'a str
+//                                         ^^
+fn struct_with_lt4a<'a, 'b>(_foo: &'a Foo<'b>) -> &'a str {
+    unimplemented!()
+}
+
+// Warning; two input lifetimes, but the output lifetime is not elided, i.e., the following is
+// valid:
+//   fn struct_with_lt4b<'b>(_foo: &Foo<'b>) -> &'b str
+//                                 ^^^^
+fn struct_with_lt4b<'a, 'b>(_foo: &'a Foo<'b>) -> &'b str {
     unimplemented!()
 }
 
@@ -203,8 +241,19 @@ fn alias_with_lt3<'a>(_foo: &FooAlias<'a>) -> &'a str {
     unimplemented!()
 }
 
-// No warning; two input lifetimes.
-fn alias_with_lt4<'a, 'b>(_foo: &'a FooAlias<'b>) -> &'a str {
+// Warning; two input lifetimes, but the output lifetime is not elided, i.e., the following is
+// valid:
+//   fn alias_with_lt4a<'a>(_foo: &'a FooAlias<'_>) -> &'a str
+//                                             ^^
+fn alias_with_lt4a<'a, 'b>(_foo: &'a FooAlias<'b>) -> &'a str {
+    unimplemented!()
+}
+
+// Warning; two input lifetimes, but the output lifetime is not elided, i.e., the following is
+// valid:
+//   fn alias_with_lt4b<'b>(_foo: &FooAlias<'b>) -> &'b str
+//                                ^^^^^^^^^
+fn alias_with_lt4b<'a, 'b>(_foo: &'a FooAlias<'b>) -> &'b str {
     unimplemented!()
 }
 
@@ -419,7 +468,7 @@ mod issue7296 {
     }
 }
 
-mod false_negative {
+mod pr_9743_false_negative_fix {
     #![allow(unused)]
 
     fn foo<'a>(x: &'a u8, y: &'_ u8) {}
@@ -427,4 +476,23 @@ mod false_negative {
     fn bar<'a>(x: &'a u8, y: &'_ u8, z: &'_ u8) {}
 }
 
+mod pr_9743_output_lifetime_checks {
+    #![allow(unused)]
+
+    // lint: only one input
+    fn one_input<'a>(x: &'a u8) -> &'a u8 {
+        unimplemented!()
+    }
+
+    // lint: multiple inputs, output would not be elided
+    fn multiple_inputs_output_not_elided<'a, 'b>(x: &'a u8, y: &'b u8, z: &'b u8) -> &'b u8 {
+        unimplemented!()
+    }
+
+    // don't lint: multiple inputs, output would be elided (which would create an ambiguity)
+    fn multiple_inputs_output_would_be_elided<'a, 'b>(x: &'a u8, y: &'b u8, z: &'b u8) -> &'a u8 {
+        unimplemented!()
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/needless_lifetimes.stderr b/tests/ui/needless_lifetimes.stderr
index 94787b95181..5a7cf13c86d 100644
--- a/tests/ui/needless_lifetimes.stderr
+++ b/tests/ui/needless_lifetimes.stderr
@@ -18,209 +18,299 @@ error: the following explicit lifetimes could be elided: 'a
 LL | fn in_and_out<'a>(x: &'a u8, _y: u8) -> &'a u8 {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
+error: the following explicit lifetimes could be elided: 'b
+  --> $DIR/needless_lifetimes.rs:35:1
+   |
+LL | fn multiple_in_and_out_2a<'a, 'b>(x: &'a u8, _y: &'b u8) -> &'a u8 {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:57:1
+  --> $DIR/needless_lifetimes.rs:42:1
+   |
+LL | fn multiple_in_and_out_2b<'a, 'b>(_x: &'a u8, y: &'b u8) -> &'b u8 {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: the following explicit lifetimes could be elided: 'b
+  --> $DIR/needless_lifetimes.rs:59:1
+   |
+LL | fn deep_reference_1a<'a, 'b>(x: &'a u8, _y: &'b u8) -> Result<&'a u8, ()> {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: the following explicit lifetimes could be elided: 'a
+  --> $DIR/needless_lifetimes.rs:66:1
+   |
+LL | fn deep_reference_1b<'a, 'b>(_x: &'a u8, y: &'b u8) -> Result<&'b u8, ()> {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: the following explicit lifetimes could be elided: 'a
+  --> $DIR/needless_lifetimes.rs:75:1
    |
 LL | fn deep_reference_3<'a>(x: &'a u8, _y: u8) -> Result<&'a u8, ()> {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:62:1
+  --> $DIR/needless_lifetimes.rs:80:1
    |
 LL | fn where_clause_without_lt<'a, T>(x: &'a u8, _y: u8) -> Result<&'a u8, ()>
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: the following explicit lifetimes could be elided: 'a, 'b
-  --> $DIR/needless_lifetimes.rs:74:1
+  --> $DIR/needless_lifetimes.rs:92:1
    |
 LL | fn lifetime_param_2<'a, 'b>(_x: Ref<'a>, _y: &'b u8) {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: replace with `'_` in generic arguments such as here
-  --> $DIR/needless_lifetimes.rs:74:37
+  --> $DIR/needless_lifetimes.rs:92:37
    |
 LL | fn lifetime_param_2<'a, 'b>(_x: Ref<'a>, _y: &'b u8) {}
    |                                     ^^
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:98:1
+  --> $DIR/needless_lifetimes.rs:116:1
    |
 LL | fn fn_bound_2<'a, F, I>(_m: Lt<'a, I>, _f: F) -> Lt<'a, I>
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: replace with `'_` in generic arguments such as here
-  --> $DIR/needless_lifetimes.rs:98:32
+  --> $DIR/needless_lifetimes.rs:116:32
    |
 LL | fn fn_bound_2<'a, F, I>(_m: Lt<'a, I>, _f: F) -> Lt<'a, I>
    |                                ^^
 
 error: the following explicit lifetimes could be elided: 's
-  --> $DIR/needless_lifetimes.rs:128:5
+  --> $DIR/needless_lifetimes.rs:146:5
    |
 LL |     fn self_and_out<'s>(&'s self) -> &'s u8 {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
+error: the following explicit lifetimes could be elided: 't
+  --> $DIR/needless_lifetimes.rs:153:5
+   |
+LL |     fn self_and_in_out_1<'s, 't>(&'s self, _x: &'t u8) -> &'s u8 {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: the following explicit lifetimes could be elided: 's
+  --> $DIR/needless_lifetimes.rs:160:5
+   |
+LL |     fn self_and_in_out_2<'s, 't>(&'s self, x: &'t u8) -> &'t u8 {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
 error: the following explicit lifetimes could be elided: 's, 't
-  --> $DIR/needless_lifetimes.rs:137:5
+  --> $DIR/needless_lifetimes.rs:164:5
    |
 LL |     fn distinct_self_and_in<'s, 't>(&'s self, _x: &'t u8) {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:156:1
+  --> $DIR/needless_lifetimes.rs:183:1
    |
 LL | fn struct_with_lt<'a>(_foo: Foo<'a>) -> &'a str {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: replace with `'_` in generic arguments such as here
-  --> $DIR/needless_lifetimes.rs:156:33
+  --> $DIR/needless_lifetimes.rs:183:33
    |
 LL | fn struct_with_lt<'a>(_foo: Foo<'a>) -> &'a str {
    |                                 ^^
 
+error: the following explicit lifetimes could be elided: 'b
+  --> $DIR/needless_lifetimes.rs:201:1
+   |
+LL | fn struct_with_lt4a<'a, 'b>(_foo: &'a Foo<'b>) -> &'a str {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: replace with `'_` in generic arguments such as here
+  --> $DIR/needless_lifetimes.rs:201:43
+   |
+LL | fn struct_with_lt4a<'a, 'b>(_foo: &'a Foo<'b>) -> &'a str {
+   |                                           ^^
+
+error: the following explicit lifetimes could be elided: 'a
+  --> $DIR/needless_lifetimes.rs:209:1
+   |
+LL | fn struct_with_lt4b<'a, 'b>(_foo: &'a Foo<'b>) -> &'b str {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:186:1
+  --> $DIR/needless_lifetimes.rs:224:1
    |
 LL | fn trait_obj_elided2<'a>(_arg: &'a dyn Drop) -> &'a str {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:192:1
+  --> $DIR/needless_lifetimes.rs:230:1
    |
 LL | fn alias_with_lt<'a>(_foo: FooAlias<'a>) -> &'a str {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: replace with `'_` in generic arguments such as here
-  --> $DIR/needless_lifetimes.rs:192:37
+  --> $DIR/needless_lifetimes.rs:230:37
    |
 LL | fn alias_with_lt<'a>(_foo: FooAlias<'a>) -> &'a str {
    |                                     ^^
 
+error: the following explicit lifetimes could be elided: 'b
+  --> $DIR/needless_lifetimes.rs:248:1
+   |
+LL | fn alias_with_lt4a<'a, 'b>(_foo: &'a FooAlias<'b>) -> &'a str {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: replace with `'_` in generic arguments such as here
+  --> $DIR/needless_lifetimes.rs:248:47
+   |
+LL | fn alias_with_lt4a<'a, 'b>(_foo: &'a FooAlias<'b>) -> &'a str {
+   |                                               ^^
+
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:211:1
+  --> $DIR/needless_lifetimes.rs:256:1
+   |
+LL | fn alias_with_lt4b<'a, 'b>(_foo: &'a FooAlias<'b>) -> &'b str {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: the following explicit lifetimes could be elided: 'a
+  --> $DIR/needless_lifetimes.rs:260:1
    |
 LL | fn named_input_elided_output<'a>(_arg: &'a str) -> &str {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:219:1
+  --> $DIR/needless_lifetimes.rs:268:1
    |
 LL | fn trait_bound_ok<'a, T: WithLifetime<'static>>(_: &'a u8, _: T) {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:255:1
+  --> $DIR/needless_lifetimes.rs:304:1
    |
 LL | fn out_return_type_lts<'a>(e: &'a str) -> Cow<'a> {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: replace with `'_` in generic arguments such as here
+  --> $DIR/needless_lifetimes.rs:304:47
+   |
+LL | fn out_return_type_lts<'a>(e: &'a str) -> Cow<'a> {
+   |                                               ^^
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:262:9
+  --> $DIR/needless_lifetimes.rs:311:9
    |
 LL |         fn needless_lt<'a>(x: &'a u8) {}
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:266:9
+  --> $DIR/needless_lifetimes.rs:315:9
    |
 LL |         fn needless_lt<'a>(_x: &'a u8) {}
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:279:9
+  --> $DIR/needless_lifetimes.rs:328:9
    |
 LL |         fn baz<'a>(&'a self) -> impl Foo + 'a {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:311:5
+  --> $DIR/needless_lifetimes.rs:360:5
    |
 LL |     fn impl_trait_elidable_nested_anonymous_lifetimes<'a>(i: &'a i32, f: impl Fn(&i32) -> &i32) -> &'a i32 {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:320:5
+  --> $DIR/needless_lifetimes.rs:369:5
    |
 LL |     fn generics_elidable<'a, T: Fn(&i32) -> &i32>(i: &'a i32, f: T) -> &'a i32 {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:332:5
+  --> $DIR/needless_lifetimes.rs:381:5
    |
 LL |     fn where_clause_elidadable<'a, T>(i: &'a i32, f: T) -> &'a i32
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:347:5
+  --> $DIR/needless_lifetimes.rs:396:5
    |
 LL |     fn pointer_fn_elidable<'a>(i: &'a i32, f: fn(&i32) -> &i32) -> &'a i32 {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:360:5
+  --> $DIR/needless_lifetimes.rs:409:5
    |
 LL |     fn nested_fn_pointer_3<'a>(_: &'a i32) -> fn(fn(&i32) -> &i32) -> i32 {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:363:5
+  --> $DIR/needless_lifetimes.rs:412:5
    |
 LL |     fn nested_fn_pointer_4<'a>(_: &'a i32) -> impl Fn(fn(&i32)) {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:385:9
+  --> $DIR/needless_lifetimes.rs:434:9
    |
 LL |         fn implicit<'a>(&'a self) -> &'a () {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:388:9
+  --> $DIR/needless_lifetimes.rs:437:9
    |
 LL |         fn implicit_mut<'a>(&'a mut self) -> &'a () {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:399:9
+  --> $DIR/needless_lifetimes.rs:448:9
    |
 LL |         fn lifetime_elsewhere<'a>(self: Box<Self>, here: &'a ()) -> &'a () {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:405:9
+  --> $DIR/needless_lifetimes.rs:454:9
    |
 LL |         fn implicit<'a>(&'a self) -> &'a ();
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:406:9
+  --> $DIR/needless_lifetimes.rs:455:9
    |
 LL |         fn implicit_provided<'a>(&'a self) -> &'a () {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:415:9
+  --> $DIR/needless_lifetimes.rs:464:9
    |
 LL |         fn lifetime_elsewhere<'a>(self: Box<Self>, here: &'a ()) -> &'a ();
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:416:9
+  --> $DIR/needless_lifetimes.rs:465:9
    |
 LL |         fn lifetime_elsewhere_provided<'a>(self: Box<Self>, here: &'a ()) -> &'a () {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:425:5
+  --> $DIR/needless_lifetimes.rs:474:5
    |
 LL |     fn foo<'a>(x: &'a u8, y: &'_ u8) {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:427:5
+  --> $DIR/needless_lifetimes.rs:476:5
    |
 LL |     fn bar<'a>(x: &'a u8, y: &'_ u8, z: &'_ u8) {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 33 previous errors
+error: the following explicit lifetimes could be elided: 'a
+  --> $DIR/needless_lifetimes.rs:483:5
+   |
+LL |     fn one_input<'a>(x: &'a u8) -> &'a u8 {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: the following explicit lifetimes could be elided: 'a
+  --> $DIR/needless_lifetimes.rs:488:5
+   |
+LL |     fn multiple_inputs_output_not_elided<'a, 'b>(x: &'a u8, y: &'b u8, z: &'b u8) -> &'b u8 {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 45 previous errors
 
diff --git a/tests/ui/transmute.rs b/tests/ui/transmute.rs
index 001c910239a..1cbacf0feab 100644
--- a/tests/ui/transmute.rs
+++ b/tests/ui/transmute.rs
@@ -1,4 +1,4 @@
-#![allow(dead_code, clippy::borrow_as_ptr)]
+#![allow(dead_code, clippy::borrow_as_ptr, clippy::needless_lifetimes)]
 
 extern crate core;
 
diff --git a/tests/ui/trivially_copy_pass_by_ref.rs b/tests/ui/trivially_copy_pass_by_ref.rs
index af4f3b18443..c0af011d33d 100644
--- a/tests/ui/trivially_copy_pass_by_ref.rs
+++ b/tests/ui/trivially_copy_pass_by_ref.rs
@@ -3,6 +3,7 @@
 #![deny(clippy::trivially_copy_pass_by_ref)]
 #![allow(
     clippy::disallowed_names,
+    clippy::needless_lifetimes,
     clippy::redundant_field_names,
     clippy::uninlined_format_args
 )]
diff --git a/tests/ui/trivially_copy_pass_by_ref.stderr b/tests/ui/trivially_copy_pass_by_ref.stderr
index 6a8eca96553..8c5cfa8a0f1 100644
--- a/tests/ui/trivially_copy_pass_by_ref.stderr
+++ b/tests/ui/trivially_copy_pass_by_ref.stderr
@@ -1,5 +1,5 @@
 error: this argument (N byte) is passed by reference, but would be more efficient if passed by value (limit: N byte)
-  --> $DIR/trivially_copy_pass_by_ref.rs:50:11
+  --> $DIR/trivially_copy_pass_by_ref.rs:51:11
    |
 LL | fn bad(x: &u32, y: &Foo, z: &Baz) {}
    |           ^^^^ help: consider passing by value instead: `u32`
@@ -11,103 +11,103 @@ LL | #![deny(clippy::trivially_copy_pass_by_ref)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this argument (N byte) is passed by reference, but would be more efficient if passed by value (limit: N byte)
-  --> $DIR/trivially_copy_pass_by_ref.rs:50:20
+  --> $DIR/trivially_copy_pass_by_ref.rs:51:20
    |
 LL | fn bad(x: &u32, y: &Foo, z: &Baz) {}
    |                    ^^^^ help: consider passing by value instead: `Foo`
 
 error: this argument (N byte) is passed by reference, but would be more efficient if passed by value (limit: N byte)
-  --> $DIR/trivially_copy_pass_by_ref.rs:50:29
+  --> $DIR/trivially_copy_pass_by_ref.rs:51:29
    |
 LL | fn bad(x: &u32, y: &Foo, z: &Baz) {}
    |                             ^^^^ help: consider passing by value instead: `Baz`
 
 error: this argument (N byte) is passed by reference, but would be more efficient if passed by value (limit: N byte)
-  --> $DIR/trivially_copy_pass_by_ref.rs:57:12
+  --> $DIR/trivially_copy_pass_by_ref.rs:58:12
    |
 LL |     fn bad(&self, x: &u32, y: &Foo, z: &Baz) {}
    |            ^^^^^ help: consider passing by value instead: `self`
 
 error: this argument (N byte) is passed by reference, but would be more efficient if passed by value (limit: N byte)
-  --> $DIR/trivially_copy_pass_by_ref.rs:57:22
+  --> $DIR/trivially_copy_pass_by_ref.rs:58:22
    |
 LL |     fn bad(&self, x: &u32, y: &Foo, z: &Baz) {}
    |                      ^^^^ help: consider passing by value instead: `u32`
 
 error: this argument (N byte) is passed by reference, but would be more efficient if passed by value (limit: N byte)
-  --> $DIR/trivially_copy_pass_by_ref.rs:57:31
+  --> $DIR/trivially_copy_pass_by_ref.rs:58:31
    |
 LL |     fn bad(&self, x: &u32, y: &Foo, z: &Baz) {}
    |                               ^^^^ help: consider passing by value instead: `Foo`
 
 error: this argument (N byte) is passed by reference, but would be more efficient if passed by value (limit: N byte)
-  --> $DIR/trivially_copy_pass_by_ref.rs:57:40
+  --> $DIR/trivially_copy_pass_by_ref.rs:58:40
    |
 LL |     fn bad(&self, x: &u32, y: &Foo, z: &Baz) {}
    |                                        ^^^^ help: consider passing by value instead: `Baz`
 
 error: this argument (N byte) is passed by reference, but would be more efficient if passed by value (limit: N byte)
-  --> $DIR/trivially_copy_pass_by_ref.rs:59:16
+  --> $DIR/trivially_copy_pass_by_ref.rs:60:16
    |
 LL |     fn bad2(x: &u32, y: &Foo, z: &Baz) {}
    |                ^^^^ help: consider passing by value instead: `u32`
 
 error: this argument (N byte) is passed by reference, but would be more efficient if passed by value (limit: N byte)
-  --> $DIR/trivially_copy_pass_by_ref.rs:59:25
+  --> $DIR/trivially_copy_pass_by_ref.rs:60:25
    |
 LL |     fn bad2(x: &u32, y: &Foo, z: &Baz) {}
    |                         ^^^^ help: consider passing by value instead: `Foo`
 
 error: this argument (N byte) is passed by reference, but would be more efficient if passed by value (limit: N byte)
-  --> $DIR/trivially_copy_pass_by_ref.rs:59:34
+  --> $DIR/trivially_copy_pass_by_ref.rs:60:34
    |
 LL |     fn bad2(x: &u32, y: &Foo, z: &Baz) {}
    |                                  ^^^^ help: consider passing by value instead: `Baz`
 
 error: this argument (N byte) is passed by reference, but would be more efficient if passed by value (limit: N byte)
-  --> $DIR/trivially_copy_pass_by_ref.rs:61:35
+  --> $DIR/trivially_copy_pass_by_ref.rs:62:35
    |
 LL |     fn bad_issue7518(self, other: &Self) {}
    |                                   ^^^^^ help: consider passing by value instead: `Self`
 
 error: this argument (N byte) is passed by reference, but would be more efficient if passed by value (limit: N byte)
-  --> $DIR/trivially_copy_pass_by_ref.rs:73:16
+  --> $DIR/trivially_copy_pass_by_ref.rs:74:16
    |
 LL |     fn bad2(x: &u32, y: &Foo, z: &Baz) {}
    |                ^^^^ help: consider passing by value instead: `u32`
 
 error: this argument (N byte) is passed by reference, but would be more efficient if passed by value (limit: N byte)
-  --> $DIR/trivially_copy_pass_by_ref.rs:73:25
+  --> $DIR/trivially_copy_pass_by_ref.rs:74:25
    |
 LL |     fn bad2(x: &u32, y: &Foo, z: &Baz) {}
    |                         ^^^^ help: consider passing by value instead: `Foo`
 
 error: this argument (N byte) is passed by reference, but would be more efficient if passed by value (limit: N byte)
-  --> $DIR/trivially_copy_pass_by_ref.rs:73:34
+  --> $DIR/trivially_copy_pass_by_ref.rs:74:34
    |
 LL |     fn bad2(x: &u32, y: &Foo, z: &Baz) {}
    |                                  ^^^^ help: consider passing by value instead: `Baz`
 
 error: this argument (N byte) is passed by reference, but would be more efficient if passed by value (limit: N byte)
-  --> $DIR/trivially_copy_pass_by_ref.rs:77:34
+  --> $DIR/trivially_copy_pass_by_ref.rs:78:34
    |
 LL |     fn trait_method(&self, _foo: &Foo);
    |                                  ^^^^ help: consider passing by value instead: `Foo`
 
 error: this argument (N byte) is passed by reference, but would be more efficient if passed by value (limit: N byte)
-  --> $DIR/trivially_copy_pass_by_ref.rs:109:21
+  --> $DIR/trivially_copy_pass_by_ref.rs:110:21
    |
 LL |     fn foo_never(x: &i32) {
    |                     ^^^^ help: consider passing by value instead: `i32`
 
 error: this argument (N byte) is passed by reference, but would be more efficient if passed by value (limit: N byte)
-  --> $DIR/trivially_copy_pass_by_ref.rs:114:15
+  --> $DIR/trivially_copy_pass_by_ref.rs:115:15
    |
 LL |     fn foo(x: &i32) {
    |               ^^^^ help: consider passing by value instead: `i32`
 
 error: this argument (N byte) is passed by reference, but would be more efficient if passed by value (limit: N byte)
-  --> $DIR/trivially_copy_pass_by_ref.rs:141:37
+  --> $DIR/trivially_copy_pass_by_ref.rs:142:37
    |
 LL | fn _unrelated_lifetimes<'a, 'b>(_x: &'a u32, y: &'b u32) -> &'b u32 {
    |                                     ^^^^^^^ help: consider passing by value instead: `u32`
-- 
cgit 1.4.1-3-g733a5


From b16a534618958d4981b62adb29b27de890862cbe Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Sun, 30 Oct 2022 21:15:46 +0000
Subject: Warn when clippy::restriction is enabled via the command line

---
 clippy_lints/src/attrs.rs                        | 28 ++++++++++++++++++++----
 tests/ui/blanket_clippy_restriction_lints.rs     |  2 ++
 tests/ui/blanket_clippy_restriction_lints.stderr | 27 +++++++++++++----------
 3 files changed, 42 insertions(+), 15 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs
index bed9cf565f3..235ab4977ce 100644
--- a/clippy_lints/src/attrs.rs
+++ b/clippy_lints/src/attrs.rs
@@ -11,14 +11,14 @@ use rustc_errors::Applicability;
 use rustc_hir::{
     Block, Expr, ExprKind, ImplItem, ImplItemKind, Item, ItemKind, StmtKind, TraitFn, TraitItem, TraitItemKind,
 };
-use rustc_lint::{EarlyContext, EarlyLintPass, LateContext, LateLintPass, LintContext};
+use rustc_lint::{EarlyContext, EarlyLintPass, LateContext, LateLintPass, Level, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty;
 use rustc_semver::RustcVersion;
 use rustc_session::{declare_lint_pass, declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::Span;
-use rustc_span::sym;
 use rustc_span::symbol::Symbol;
+use rustc_span::{sym, DUMMY_SP};
 use semver::Version;
 
 static UNIX_SYSTEMS: &[&str] = &[
@@ -303,6 +303,26 @@ declare_lint_pass!(Attributes => [
 ]);
 
 impl<'tcx> LateLintPass<'tcx> for Attributes {
+    fn check_crate(&mut self, cx: &LateContext<'tcx>) {
+        for (name, level) in &cx.sess().opts.lint_opts {
+            if name == "clippy::restriction" && *level > Level::Allow {
+                span_lint_and_then(
+                    cx,
+                    BLANKET_CLIPPY_RESTRICTION_LINTS,
+                    DUMMY_SP,
+                    "`clippy::restriction` is not meant to be enabled as a group",
+                    |diag| {
+                        diag.note(format!(
+                            "because of the command line `--{} clippy::restriction`",
+                            level.as_str()
+                        ));
+                        diag.help("enable the restriction lints you need individually");
+                    },
+                );
+            }
+        }
+    }
+
     fn check_attribute(&mut self, cx: &LateContext<'tcx>, attr: &'tcx Attribute) {
         if let Some(items) = &attr.meta_item_list() {
             if let Some(ident) = attr.ident() {
@@ -441,9 +461,9 @@ fn check_clippy_lint_names(cx: &LateContext<'_>, name: Symbol, items: &[NestedMe
                     cx,
                     BLANKET_CLIPPY_RESTRICTION_LINTS,
                     lint.span(),
-                    "restriction lints are not meant to be all enabled",
+                    "`clippy::restriction` is not meant to be enabled as a group",
                     None,
-                    "try enabling only the lints you really need",
+                    "enable the restriction lints you need individually",
                 );
             }
         }
diff --git a/tests/ui/blanket_clippy_restriction_lints.rs b/tests/ui/blanket_clippy_restriction_lints.rs
index d055f17526b..554745368bc 100644
--- a/tests/ui/blanket_clippy_restriction_lints.rs
+++ b/tests/ui/blanket_clippy_restriction_lints.rs
@@ -1,3 +1,5 @@
+// compile-flags: -W clippy::restriction
+
 #![warn(clippy::blanket_clippy_restriction_lints)]
 
 //! Test that the whole restriction group is not enabled
diff --git a/tests/ui/blanket_clippy_restriction_lints.stderr b/tests/ui/blanket_clippy_restriction_lints.stderr
index e83eb4d605a..2bf89ab69a4 100644
--- a/tests/ui/blanket_clippy_restriction_lints.stderr
+++ b/tests/ui/blanket_clippy_restriction_lints.stderr
@@ -1,27 +1,32 @@
-error: restriction lints are not meant to be all enabled
-  --> $DIR/blanket_clippy_restriction_lints.rs:4:9
+error: `clippy::restriction` is not meant to be enabled as a group
+   |
+   = note: because of the command line `--warn clippy::restriction`
+   = help: enable the restriction lints you need individually
+   = note: `-D clippy::blanket-clippy-restriction-lints` implied by `-D warnings`
+
+error: `clippy::restriction` is not meant to be enabled as a group
+  --> $DIR/blanket_clippy_restriction_lints.rs:6:9
    |
 LL | #![warn(clippy::restriction)]
    |         ^^^^^^^^^^^^^^^^^^^
    |
-   = help: try enabling only the lints you really need
-   = note: `-D clippy::blanket-clippy-restriction-lints` implied by `-D warnings`
+   = help: enable the restriction lints you need individually
 
-error: restriction lints are not meant to be all enabled
-  --> $DIR/blanket_clippy_restriction_lints.rs:5:9
+error: `clippy::restriction` is not meant to be enabled as a group
+  --> $DIR/blanket_clippy_restriction_lints.rs:7:9
    |
 LL | #![deny(clippy::restriction)]
    |         ^^^^^^^^^^^^^^^^^^^
    |
-   = help: try enabling only the lints you really need
+   = help: enable the restriction lints you need individually
 
-error: restriction lints are not meant to be all enabled
-  --> $DIR/blanket_clippy_restriction_lints.rs:6:11
+error: `clippy::restriction` is not meant to be enabled as a group
+  --> $DIR/blanket_clippy_restriction_lints.rs:8:11
    |
 LL | #![forbid(clippy::restriction)]
    |           ^^^^^^^^^^^^^^^^^^^
    |
-   = help: try enabling only the lints you really need
+   = help: enable the restriction lints you need individually
 
-error: aborting due to 3 previous errors
+error: aborting due to 4 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 6dcade0692fc516752c811d2b05302f2ed97aaeb Mon Sep 17 00:00:00 2001
From: Steven Casper <sebastiancasper3@gmail.com>
Date: Mon, 31 Oct 2022 12:50:59 -0700
Subject: Implement let_underscore_future

---
 clippy_lints/src/let_underscore.rs    | 38 +++++++++++++++++++++++++++++++++--
 tests/ui/let_underscore_future.rs     | 20 ++++++++++++++++++
 tests/ui/let_underscore_future.stderr | 27 +++++++++++++++++++++++++
 3 files changed, 83 insertions(+), 2 deletions(-)
 create mode 100644 tests/ui/let_underscore_future.rs
 create mode 100644 tests/ui/let_underscore_future.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/let_underscore.rs b/clippy_lints/src/let_underscore.rs
index cfc1a21ea87..4855f301d0d 100644
--- a/clippy_lints/src/let_underscore.rs
+++ b/clippy_lints/src/let_underscore.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_help;
-use clippy_utils::ty::{is_must_use_ty, match_type};
+use clippy_utils::ty::{implements_trait, is_must_use_ty, match_type};
 use clippy_utils::{is_must_use_func_call, paths};
 use rustc_hir::{Local, PatKind};
 use rustc_lint::{LateContext, LateLintPass};
@@ -59,7 +59,31 @@ declare_clippy_lint! {
     "non-binding let on a synchronization lock"
 }
 
-declare_lint_pass!(LetUnderscore => [LET_UNDERSCORE_MUST_USE, LET_UNDERSCORE_LOCK]);
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `let _ = <expr>` where the resulting type of expr implements `Future`
+    ///
+    /// ### Why is this bad?
+    /// Futures must be polled for work to be done. The original intention was most likely to await the future
+    /// and ignore the resulting value.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// async fn foo() -> Result<(), ()> { }
+    /// let _ = foo();
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust,ignore
+    /// let _ = foo().await;
+    /// ```
+    #[clippy::version = "1.66"]
+    pub LET_UNDERSCORE_FUTURE,
+    suspicious,
+    "non-binding let on a future"
+}
+
+declare_lint_pass!(LetUnderscore => [LET_UNDERSCORE_MUST_USE, LET_UNDERSCORE_LOCK, LET_UNDERSCORE_FUTURE]);
 
 const SYNC_GUARD_PATHS: [&[&str]; 3] = [
     &paths::PARKING_LOT_MUTEX_GUARD,
@@ -88,6 +112,16 @@ impl<'tcx> LateLintPass<'tcx> for LetUnderscore {
                     "consider using an underscore-prefixed named \
                             binding or dropping explicitly with `std::mem::drop`",
                 );
+            } else if let Some(future_trait_def_id) = cx.tcx.lang_items().future_trait()
+                && implements_trait(cx, cx.typeck_results().expr_ty(init), future_trait_def_id, &[]) {
+                span_lint_and_help(
+                    cx,
+                    LET_UNDERSCORE_FUTURE,
+                    local.span,
+                    "non-binding let on a future",
+                    None,
+                    "consider awaiting the future or dropping explicitly with `std::mem::drop`"
+                );
             } else if is_must_use_ty(cx, cx.typeck_results().expr_ty(init)) {
                 span_lint_and_help(
                     cx,
diff --git a/tests/ui/let_underscore_future.rs b/tests/ui/let_underscore_future.rs
new file mode 100644
index 00000000000..d8f54cdca91
--- /dev/null
+++ b/tests/ui/let_underscore_future.rs
@@ -0,0 +1,20 @@
+use std::future::Future;
+
+async fn some_async_fn() {}
+
+fn sync_side_effects() {}
+fn custom() -> impl Future<Output = ()> {
+    sync_side_effects();
+    async {}
+}
+
+fn do_something_to_future(future: &mut impl Future<Output = ()>) {}
+
+fn main() {
+    let _ = some_async_fn();
+    let _ = custom();
+
+    let mut future = some_async_fn();
+    do_something_to_future(&mut future);
+    let _ = future;
+}
diff --git a/tests/ui/let_underscore_future.stderr b/tests/ui/let_underscore_future.stderr
new file mode 100644
index 00000000000..f1b9b1d709e
--- /dev/null
+++ b/tests/ui/let_underscore_future.stderr
@@ -0,0 +1,27 @@
+error: non-binding let on a future
+  --> $DIR/let_underscore_future.rs:14:5
+   |
+LL |     let _ = some_async_fn();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider awaiting the future or dropping explicitly with `std::mem::drop`
+   = note: `-D clippy::let-underscore-future` implied by `-D warnings`
+
+error: non-binding let on a future
+  --> $DIR/let_underscore_future.rs:15:5
+   |
+LL |     let _ = custom();
+   |     ^^^^^^^^^^^^^^^^^
+   |
+   = help: consider awaiting the future or dropping explicitly with `std::mem::drop`
+
+error: non-binding let on a future
+  --> $DIR/let_underscore_future.rs:19:5
+   |
+LL |     let _ = future;
+   |     ^^^^^^^^^^^^^^^
+   |
+   = help: consider awaiting the future or dropping explicitly with `std::mem::drop`
+
+error: aborting due to 3 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 1f930452b9483612bc7dabbc38281170f0c9e747 Mon Sep 17 00:00:00 2001
From: Steven Casper <sebastiancasper3@gmail.com>
Date: Mon, 31 Oct 2022 12:56:04 -0700
Subject: update_lints

---
 CHANGELOG.md                       | 1 +
 clippy_lints/src/declared_lints.rs | 1 +
 2 files changed, 2 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 35864e85673..8813a456976 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3979,6 +3979,7 @@ Released 2018-09-13
 [`len_zero`]: https://rust-lang.github.io/rust-clippy/master/index.html#len_zero
 [`let_and_return`]: https://rust-lang.github.io/rust-clippy/master/index.html#let_and_return
 [`let_underscore_drop`]: https://rust-lang.github.io/rust-clippy/master/index.html#let_underscore_drop
+[`let_underscore_future`]: https://rust-lang.github.io/rust-clippy/master/index.html#let_underscore_future
 [`let_underscore_lock`]: https://rust-lang.github.io/rust-clippy/master/index.html#let_underscore_lock
 [`let_underscore_must_use`]: https://rust-lang.github.io/rust-clippy/master/index.html#let_underscore_must_use
 [`let_unit_value`]: https://rust-lang.github.io/rust-clippy/master/index.html#let_unit_value
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index f4fc2bd3330..747636b7ec3 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -215,6 +215,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::len_zero::LEN_WITHOUT_IS_EMPTY_INFO,
     crate::len_zero::LEN_ZERO_INFO,
     crate::let_if_seq::USELESS_LET_IF_SEQ_INFO,
+    crate::let_underscore::LET_UNDERSCORE_FUTURE_INFO,
     crate::let_underscore::LET_UNDERSCORE_LOCK_INFO,
     crate::let_underscore::LET_UNDERSCORE_MUST_USE_INFO,
     crate::lifetimes::EXTRA_UNUSED_LIFETIMES_INFO,
-- 
cgit 1.4.1-3-g733a5


From 9e7996b14957421320bbcdb9d4b3f3a65b78b223 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Mon, 31 Oct 2022 21:28:02 +0100
Subject: Update lint versions for 1.65

---
 clippy_lints/src/casts/mod.rs              | 2 +-
 clippy_lints/src/functions/mod.rs          | 2 +-
 clippy_lints/src/manual_instant_elapsed.rs | 2 +-
 clippy_lints/src/methods/mod.rs            | 6 +++---
 clippy_lints/src/partialeq_to_none.rs      | 2 +-
 clippy_lints/src/unused_peekable.rs        | 2 +-
 6 files changed, 8 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index b72c4c772f1..7148b5e6ebf 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -593,7 +593,7 @@ declare_clippy_lint! {
     /// let _: *mut [u8] = std::ptr::slice_from_raw_parts_mut(ptr, len);
     /// ```
     /// [safety requirements]: https://doc.rust-lang.org/std/slice/fn.from_raw_parts.html#safety
-    #[clippy::version = "1.64.0"]
+    #[clippy::version = "1.65.0"]
     pub CAST_SLICE_FROM_RAW_PARTS,
     suspicious,
     "casting a slice created from a pointer and length to a slice pointer"
diff --git a/clippy_lints/src/functions/mod.rs b/clippy_lints/src/functions/mod.rs
index 90911e0bf25..ae0e0833446 100644
--- a/clippy_lints/src/functions/mod.rs
+++ b/clippy_lints/src/functions/mod.rs
@@ -254,7 +254,7 @@ declare_clippy_lint! {
     ///     Ok(())
     /// }
     /// ```
-    #[clippy::version = "1.64.0"]
+    #[clippy::version = "1.65.0"]
     pub RESULT_LARGE_ERR,
     perf,
     "function returning `Result` with large `Err` type"
diff --git a/clippy_lints/src/manual_instant_elapsed.rs b/clippy_lints/src/manual_instant_elapsed.rs
index 331cda1db89..1e60aa02d3c 100644
--- a/clippy_lints/src/manual_instant_elapsed.rs
+++ b/clippy_lints/src/manual_instant_elapsed.rs
@@ -27,7 +27,7 @@ declare_clippy_lint! {
     /// let prev_instant = Instant::now();
     /// let duration = prev_instant.elapsed();
     /// ```
-    #[clippy::version = "1.64.0"]
+    #[clippy::version = "1.65.0"]
     pub MANUAL_INSTANT_ELAPSED,
     pedantic,
     "subtraction between `Instant::now()` and previous `Instant`"
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 6665329d114..43a52f15680 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -160,7 +160,7 @@ declare_clippy_lint! {
     /// ```rust
     /// let hello = "hesuo worpd".replace(&['s', 'u', 'p'], "l");
     /// ```
-    #[clippy::version = "1.64.0"]
+    #[clippy::version = "1.65.0"]
     pub COLLAPSIBLE_STR_REPLACE,
     perf,
     "collapse consecutive calls to str::replace (2 or more) into a single call"
@@ -2428,7 +2428,7 @@ declare_clippy_lint! {
     /// ### Known problems
     ///
     /// The type of the resulting iterator might become incompatible with its usage
-    #[clippy::version = "1.64.0"]
+    #[clippy::version = "1.65.0"]
     pub ITER_ON_SINGLE_ITEMS,
     nursery,
     "Iterator for array of length 1"
@@ -2460,7 +2460,7 @@ declare_clippy_lint! {
     /// ### Known problems
     ///
     /// The type of the resulting iterator might become incompatible with its usage
-    #[clippy::version = "1.64.0"]
+    #[clippy::version = "1.65.0"]
     pub ITER_ON_EMPTY_COLLECTIONS,
     nursery,
     "Iterator for empty array"
diff --git a/clippy_lints/src/partialeq_to_none.rs b/clippy_lints/src/partialeq_to_none.rs
index 6810a243175..456ded3fc02 100644
--- a/clippy_lints/src/partialeq_to_none.rs
+++ b/clippy_lints/src/partialeq_to_none.rs
@@ -33,7 +33,7 @@ declare_clippy_lint! {
     ///     if f.is_some() { "yay" } else { "nay" }
     /// }
     /// ```
-    #[clippy::version = "1.64.0"]
+    #[clippy::version = "1.65.0"]
     pub PARTIALEQ_TO_NONE,
     style,
     "Binary comparison to `Option<T>::None` relies on `T: PartialEq`, which is unneeded"
diff --git a/clippy_lints/src/unused_peekable.rs b/clippy_lints/src/unused_peekable.rs
index f1cebf0f992..d086c963c32 100644
--- a/clippy_lints/src/unused_peekable.rs
+++ b/clippy_lints/src/unused_peekable.rs
@@ -37,7 +37,7 @@ declare_clippy_lint! {
     ///     // ...
     /// }
     /// ```
-    #[clippy::version = "1.64.0"]
+    #[clippy::version = "1.65.0"]
     pub UNUSED_PEEKABLE,
     nursery,
     "creating a peekable iterator without using any of its methods"
-- 
cgit 1.4.1-3-g733a5


From c0d928561c3b88b294ddffaf8f8179f672babcda Mon Sep 17 00:00:00 2001
From: Samuel Moelius <sam@moeli.us>
Date: Mon, 31 Oct 2022 20:12:37 -0400
Subject: Change two `<=` to `==` for clarity

---
 clippy_lints/src/lifetimes.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lifetimes.rs b/clippy_lints/src/lifetimes.rs
index 36e75d45fd7..be14f6eb669 100644
--- a/clippy_lints/src/lifetimes.rs
+++ b/clippy_lints/src/lifetimes.rs
@@ -337,7 +337,7 @@ fn could_use_elision<'tcx>(
     let elidable_lts = named_lifetime_occurrences(&input_lts)
         .into_iter()
         .filter_map(|(def_id, occurrences)| {
-            if occurrences <= 1 && (input_lts.len() <= 1 || !output_lts.contains(&RefLt::Named(def_id))) {
+            if occurrences == 1 && (input_lts.len() == 1 || !output_lts.contains(&RefLt::Named(def_id))) {
                 Some((
                     def_id,
                     input_visitor
-- 
cgit 1.4.1-3-g733a5


From 9f618b196a0325c7db8e0da28729dee1ab2f8fb4 Mon Sep 17 00:00:00 2001
From: Steven Casper <sebastiancasper3@gmail.com>
Date: Tue, 1 Nov 2022 14:26:18 -0700
Subject: Un-ingnore code snippets

---
 clippy_lints/src/let_underscore.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/let_underscore.rs b/clippy_lints/src/let_underscore.rs
index 4855f301d0d..c50f57132f0 100644
--- a/clippy_lints/src/let_underscore.rs
+++ b/clippy_lints/src/let_underscore.rs
@@ -68,13 +68,13 @@ declare_clippy_lint! {
     /// and ignore the resulting value.
     ///
     /// ### Example
-    /// ```rust,ignore
+    /// ```rust
     /// async fn foo() -> Result<(), ()> { }
     /// let _ = foo();
     /// ```
     ///
     /// Use instead:
-    /// ```rust,ignore
+    /// ```rust
     /// let _ = foo().await;
     /// ```
     #[clippy::version = "1.66"]
-- 
cgit 1.4.1-3-g733a5


From 139f2a3cda66da80659cfa6e5f1a6a4536ce96a2 Mon Sep 17 00:00:00 2001
From: Steven Casper <sebastiancasper3@gmail.com>
Date: Tue, 1 Nov 2022 14:27:28 -0700
Subject: Surround let with backticks

---
 clippy_lints/src/let_underscore.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/let_underscore.rs b/clippy_lints/src/let_underscore.rs
index c50f57132f0..05be1743d54 100644
--- a/clippy_lints/src/let_underscore.rs
+++ b/clippy_lints/src/let_underscore.rs
@@ -28,7 +28,7 @@ declare_clippy_lint! {
     #[clippy::version = "1.42.0"]
     pub LET_UNDERSCORE_MUST_USE,
     restriction,
-    "non-binding let on a `#[must_use]` expression"
+    "non-binding `let` on a `#[must_use]` expression"
 }
 
 declare_clippy_lint! {
@@ -56,7 +56,7 @@ declare_clippy_lint! {
     #[clippy::version = "1.43.0"]
     pub LET_UNDERSCORE_LOCK,
     correctness,
-    "non-binding let on a synchronization lock"
+    "non-binding `let` on a synchronization lock"
 }
 
 declare_clippy_lint! {
@@ -80,7 +80,7 @@ declare_clippy_lint! {
     #[clippy::version = "1.66"]
     pub LET_UNDERSCORE_FUTURE,
     suspicious,
-    "non-binding let on a future"
+    "non-binding `let` on a future"
 }
 
 declare_lint_pass!(LetUnderscore => [LET_UNDERSCORE_MUST_USE, LET_UNDERSCORE_LOCK, LET_UNDERSCORE_FUTURE]);
-- 
cgit 1.4.1-3-g733a5


From b7d9af278cc7e2d3bc8845156a0ab405a3536724 Mon Sep 17 00:00:00 2001
From: Steven Casper <sebastiancasper3@gmail.com>
Date: Tue, 1 Nov 2022 17:27:43 -0700
Subject: Fix examples

---
 clippy_lints/src/let_underscore.rs | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/let_underscore.rs b/clippy_lints/src/let_underscore.rs
index 05be1743d54..8da7b8c3543 100644
--- a/clippy_lints/src/let_underscore.rs
+++ b/clippy_lints/src/let_underscore.rs
@@ -69,13 +69,20 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust
-    /// async fn foo() -> Result<(), ()> { }
+    /// async fn foo() -> Result<(), ()> {
+    ///     Ok(())
+    /// }
     /// let _ = foo();
     /// ```
     ///
     /// Use instead:
     /// ```rust
+    /// # async fn context() {
+    /// async fn foo() -> Result<(), ()> {
+    ///     Ok(())
+    /// }
     /// let _ = foo().await;
+    /// # }
     /// ```
     #[clippy::version = "1.66"]
     pub LET_UNDERSCORE_FUTURE,
-- 
cgit 1.4.1-3-g733a5


From d35b7de1d5fb59ce00d678f66d6897cbafc3107c Mon Sep 17 00:00:00 2001
From: Lukas Markeffsky <@>
Date: Wed, 2 Nov 2022 12:47:46 +0100
Subject: shrink `missing_{safety,errors,panics}_doc` spans

---
 clippy_lints/src/doc.rs            | 29 ++++++----------------
 tests/ui/doc_errors.stderr         | 36 ++++++++++------------------
 tests/ui/doc_unsafe.stderr         | 34 ++++++++++----------------
 tests/ui/missing_panics_doc.stderr | 49 +++++++++++---------------------------
 4 files changed, 45 insertions(+), 103 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/doc.rs b/clippy_lints/src/doc.rs
index cecec520a6d..fbc00836b39 100644
--- a/clippy_lints/src/doc.rs
+++ b/clippy_lints/src/doc.rs
@@ -11,7 +11,7 @@ use rustc_ast::token::CommentKind;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_data_structures::sync::Lrc;
 use rustc_errors::emitter::EmitterWriter;
-use rustc_errors::{Applicability, Handler, MultiSpan, SuggestionStyle};
+use rustc_errors::{Applicability, Handler, SuggestionStyle};
 use rustc_hir as hir;
 use rustc_hir::intravisit::{self, Visitor};
 use rustc_hir::{AnonConst, Expr};
@@ -265,15 +265,7 @@ impl<'tcx> LateLintPass<'tcx> for DocMarkdown {
                         panic_span: None,
                     };
                     fpu.visit_expr(body.value);
-                    lint_for_missing_headers(
-                        cx,
-                        item.def_id.def_id,
-                        item.span,
-                        sig,
-                        headers,
-                        Some(body_id),
-                        fpu.panic_span,
-                    );
+                    lint_for_missing_headers(cx, item.def_id.def_id, sig, headers, Some(body_id), fpu.panic_span);
                 }
             },
             hir::ItemKind::Impl(impl_) => {
@@ -284,7 +276,7 @@ impl<'tcx> LateLintPass<'tcx> for DocMarkdown {
                     span_lint(
                         cx,
                         MISSING_SAFETY_DOC,
-                        item.span,
+                        cx.tcx.def_span(item.def_id),
                         "docs for unsafe trait missing `# Safety` section",
                     );
                 }
@@ -304,7 +296,7 @@ impl<'tcx> LateLintPass<'tcx> for DocMarkdown {
         let headers = check_attrs(cx, &self.valid_idents, attrs);
         if let hir::TraitItemKind::Fn(ref sig, ..) = item.kind {
             if !in_external_macro(cx.tcx.sess, item.span) {
-                lint_for_missing_headers(cx, item.def_id.def_id, item.span, sig, headers, None, None);
+                lint_for_missing_headers(cx, item.def_id.def_id, sig, headers, None, None);
             }
         }
     }
@@ -323,15 +315,7 @@ impl<'tcx> LateLintPass<'tcx> for DocMarkdown {
                 panic_span: None,
             };
             fpu.visit_expr(body.value);
-            lint_for_missing_headers(
-                cx,
-                item.def_id.def_id,
-                item.span,
-                sig,
-                headers,
-                Some(body_id),
-                fpu.panic_span,
-            );
+            lint_for_missing_headers(cx, item.def_id.def_id, sig, headers, Some(body_id), fpu.panic_span);
         }
     }
 }
@@ -339,7 +323,6 @@ impl<'tcx> LateLintPass<'tcx> for DocMarkdown {
 fn lint_for_missing_headers(
     cx: &LateContext<'_>,
     def_id: LocalDefId,
-    span: impl Into<MultiSpan> + Copy,
     sig: &hir::FnSig<'_>,
     headers: DocHeaders,
     body_id: Option<hir::BodyId>,
@@ -359,6 +342,8 @@ fn lint_for_missing_headers(
         return;
     }
 
+    let span = cx.tcx.def_span(def_id);
+
     if !headers.safety && sig.header.unsafety == hir::Unsafety::Unsafe {
         span_lint(
             cx,
diff --git a/tests/ui/doc_errors.stderr b/tests/ui/doc_errors.stderr
index c7b616e2897..d74f2dbfe1b 100644
--- a/tests/ui/doc_errors.stderr
+++ b/tests/ui/doc_errors.stderr
@@ -1,52 +1,40 @@
 error: docs for function returning `Result` missing `# Errors` section
   --> $DIR/doc_errors.rs:7:1
    |
-LL | / pub fn pub_fn_missing_errors_header() -> Result<(), ()> {
-LL | |     unimplemented!();
-LL | | }
-   | |_^
+LL | pub fn pub_fn_missing_errors_header() -> Result<(), ()> {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::missing-errors-doc` implied by `-D warnings`
 
 error: docs for function returning `Result` missing `# Errors` section
   --> $DIR/doc_errors.rs:11:1
    |
-LL | / pub async fn async_pub_fn_missing_errors_header() -> Result<(), ()> {
-LL | |     unimplemented!();
-LL | | }
-   | |_^
+LL | pub async fn async_pub_fn_missing_errors_header() -> Result<(), ()> {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: docs for function returning `Result` missing `# Errors` section
   --> $DIR/doc_errors.rs:16:1
    |
-LL | / pub fn pub_fn_returning_io_result() -> io::Result<()> {
-LL | |     unimplemented!();
-LL | | }
-   | |_^
+LL | pub fn pub_fn_returning_io_result() -> io::Result<()> {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: docs for function returning `Result` missing `# Errors` section
   --> $DIR/doc_errors.rs:21:1
    |
-LL | / pub async fn async_pub_fn_returning_io_result() -> io::Result<()> {
-LL | |     unimplemented!();
-LL | | }
-   | |_^
+LL | pub async fn async_pub_fn_returning_io_result() -> io::Result<()> {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: docs for function returning `Result` missing `# Errors` section
   --> $DIR/doc_errors.rs:51:5
    |
-LL | /     pub fn pub_method_missing_errors_header() -> Result<(), ()> {
-LL | |         unimplemented!();
-LL | |     }
-   | |_____^
+LL |     pub fn pub_method_missing_errors_header() -> Result<(), ()> {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: docs for function returning `Result` missing `# Errors` section
   --> $DIR/doc_errors.rs:56:5
    |
-LL | /     pub async fn async_pub_method_missing_errors_header() -> Result<(), ()> {
-LL | |         unimplemented!();
-LL | |     }
-   | |_____^
+LL |     pub async fn async_pub_method_missing_errors_header() -> Result<(), ()> {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: docs for function returning `Result` missing `# Errors` section
   --> $DIR/doc_errors.rs:85:5
diff --git a/tests/ui/doc_unsafe.stderr b/tests/ui/doc_unsafe.stderr
index 904b88eaef6..a86e191370e 100644
--- a/tests/ui/doc_unsafe.stderr
+++ b/tests/ui/doc_unsafe.stderr
@@ -1,20 +1,16 @@
 error: unsafe function's docs miss `# Safety` section
   --> $DIR/doc_unsafe.rs:9:1
    |
-LL | / pub unsafe fn destroy_the_planet() {
-LL | |     unimplemented!();
-LL | | }
-   | |_^
+LL | pub unsafe fn destroy_the_planet() {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::missing-safety-doc` implied by `-D warnings`
 
 error: unsafe function's docs miss `# Safety` section
   --> $DIR/doc_unsafe.rs:32:5
    |
-LL | /     pub unsafe fn republished() {
-LL | |         unimplemented!();
-LL | |     }
-   | |_____^
+LL |     pub unsafe fn republished() {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: unsafe function's docs miss `# Safety` section
   --> $DIR/doc_unsafe.rs:40:5
@@ -25,29 +21,23 @@ LL |     unsafe fn woefully_underdocumented(self);
 error: docs for unsafe trait missing `# Safety` section
   --> $DIR/doc_unsafe.rs:46:1
    |
-LL | / pub unsafe trait UnsafeTrait {
-LL | |     fn method();
-LL | | }
-   | |_^
+LL | pub unsafe trait UnsafeTrait {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: unsafe function's docs miss `# Safety` section
   --> $DIR/doc_unsafe.rs:76:5
    |
-LL | /     pub unsafe fn more_undocumented_unsafe() -> Self {
-LL | |         unimplemented!();
-LL | |     }
-   | |_____^
+LL |     pub unsafe fn more_undocumented_unsafe() -> Self {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: unsafe function's docs miss `# Safety` section
   --> $DIR/doc_unsafe.rs:92:9
    |
-LL | /         pub unsafe fn whee() {
-LL | |             unimplemented!()
-LL | |         }
-   | |_________^
+LL |         pub unsafe fn whee() {
+   |         ^^^^^^^^^^^^^^^^^^^^
 ...
-LL |   very_unsafe!();
-   |   -------------- in this macro invocation
+LL | very_unsafe!();
+   | -------------- in this macro invocation
    |
    = note: this error originates in the macro `very_unsafe` (in Nightly builds, run with -Z macro-backtrace for more info)
 
diff --git a/tests/ui/missing_panics_doc.stderr b/tests/ui/missing_panics_doc.stderr
index c9ded7f1ad0..183c262ce0b 100644
--- a/tests/ui/missing_panics_doc.stderr
+++ b/tests/ui/missing_panics_doc.stderr
@@ -1,11 +1,8 @@
 error: docs for function which may panic missing `# Panics` section
   --> $DIR/missing_panics_doc.rs:6:1
    |
-LL | / pub fn unwrap() {
-LL | |     let result = Err("Hi");
-LL | |     result.unwrap()
-LL | | }
-   | |_^
+LL | pub fn unwrap() {
+   | ^^^^^^^^^^^^^^^
    |
 note: first possible panic found here
   --> $DIR/missing_panics_doc.rs:8:5
@@ -17,10 +14,8 @@ LL |     result.unwrap()
 error: docs for function which may panic missing `# Panics` section
   --> $DIR/missing_panics_doc.rs:12:1
    |
-LL | / pub fn panic() {
-LL | |     panic!("This function panics")
-LL | | }
-   | |_^
+LL | pub fn panic() {
+   | ^^^^^^^^^^^^^^
    |
 note: first possible panic found here
   --> $DIR/missing_panics_doc.rs:13:5
@@ -31,10 +26,8 @@ LL |     panic!("This function panics")
 error: docs for function which may panic missing `# Panics` section
   --> $DIR/missing_panics_doc.rs:17:1
    |
-LL | / pub fn todo() {
-LL | |     todo!()
-LL | | }
-   | |_^
+LL | pub fn todo() {
+   | ^^^^^^^^^^^^^
    |
 note: first possible panic found here
   --> $DIR/missing_panics_doc.rs:18:5
@@ -45,14 +38,8 @@ LL |     todo!()
 error: docs for function which may panic missing `# Panics` section
   --> $DIR/missing_panics_doc.rs:22:1
    |
-LL | / pub fn inner_body(opt: Option<u32>) {
-LL | |     opt.map(|x| {
-LL | |         if x == 10 {
-LL | |             panic!()
-LL | |         }
-LL | |     });
-LL | | }
-   | |_^
+LL | pub fn inner_body(opt: Option<u32>) {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: first possible panic found here
   --> $DIR/missing_panics_doc.rs:25:13
@@ -63,10 +50,8 @@ LL |             panic!()
 error: docs for function which may panic missing `# Panics` section
   --> $DIR/missing_panics_doc.rs:31:1
    |
-LL | / pub fn unreachable_and_panic() {
-LL | |     if true { unreachable!() } else { panic!() }
-LL | | }
-   | |_^
+LL | pub fn unreachable_and_panic() {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: first possible panic found here
   --> $DIR/missing_panics_doc.rs:32:39
@@ -77,11 +62,8 @@ LL |     if true { unreachable!() } else { panic!() }
 error: docs for function which may panic missing `# Panics` section
   --> $DIR/missing_panics_doc.rs:36:1
    |
-LL | / pub fn assert_eq() {
-LL | |     let x = 0;
-LL | |     assert_eq!(x, 0);
-LL | | }
-   | |_^
+LL | pub fn assert_eq() {
+   | ^^^^^^^^^^^^^^^^^^
    |
 note: first possible panic found here
   --> $DIR/missing_panics_doc.rs:38:5
@@ -92,11 +74,8 @@ LL |     assert_eq!(x, 0);
 error: docs for function which may panic missing `# Panics` section
   --> $DIR/missing_panics_doc.rs:42:1
    |
-LL | / pub fn assert_ne() {
-LL | |     let x = 0;
-LL | |     assert_ne!(x, 0);
-LL | | }
-   | |_^
+LL | pub fn assert_ne() {
+   | ^^^^^^^^^^^^^^^^^^
    |
 note: first possible panic found here
   --> $DIR/missing_panics_doc.rs:44:5
-- 
cgit 1.4.1-3-g733a5


From 517605e1fd35ae4dd62b1a8418674de31c020a07 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Wed, 2 Nov 2022 13:24:34 +0000
Subject: Fix ICE in `redundant_allocation`

---
 clippy_lints/src/types/redundant_allocation.rs |  8 +++++---
 tests/ui/crashes/ice-9746.rs                   | 15 +++++++++++++++
 2 files changed, 20 insertions(+), 3 deletions(-)
 create mode 100644 tests/ui/crashes/ice-9746.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types/redundant_allocation.rs b/clippy_lints/src/types/redundant_allocation.rs
index 7883353e3fe..b74081176dc 100644
--- a/clippy_lints/src/types/redundant_allocation.rs
+++ b/clippy_lints/src/types/redundant_allocation.rs
@@ -5,6 +5,7 @@ use rustc_errors::Applicability;
 use rustc_hir::{self as hir, def_id::DefId, QPath, TyKind};
 use rustc_hir_analysis::hir_ty_to_ty;
 use rustc_lint::LateContext;
+use rustc_middle::ty::TypeVisitable;
 use rustc_span::symbol::sym;
 
 use super::{utils, REDUNDANT_ALLOCATION};
@@ -51,14 +52,15 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_
         return false
     };
     let inner_span = match qpath_generic_tys(inner_qpath).next() {
-        Some(ty) => {
+        Some(hir_ty) => {
             // Reallocation of a fat pointer causes it to become thin. `hir_ty_to_ty` is safe to use
             // here because `mod.rs` guarantees this lint is only run on types outside of bodies and
             // is not run on locals.
-            if !hir_ty_to_ty(cx.tcx, ty).is_sized(cx.tcx.at(ty.span), cx.param_env) {
+            let ty = hir_ty_to_ty(cx.tcx, hir_ty);
+            if ty.has_escaping_bound_vars() || !ty.is_sized(cx.tcx.at(hir_ty.span), cx.param_env) {
                 return false;
             }
-            ty.span
+            hir_ty.span
         },
         None => return false,
     };
diff --git a/tests/ui/crashes/ice-9746.rs b/tests/ui/crashes/ice-9746.rs
new file mode 100644
index 00000000000..fbd373c70bf
--- /dev/null
+++ b/tests/ui/crashes/ice-9746.rs
@@ -0,0 +1,15 @@
+//! <https://github.com/rust-lang/rust-clippy/issues/9746#issuecomment-1297132880>
+
+trait Trait {}
+
+struct Struct<'a> {
+    _inner: &'a Struct<'a>,
+}
+
+impl Trait for Struct<'_> {}
+
+fn example<'a>(s: &'a Struct) -> Box<Box<dyn Trait + 'a>> {
+    Box::new(Box::new(Struct { _inner: s }))
+}
+
+fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 05006e58c08d24bf6f7fbe2eca96f3e82d355e26 Mon Sep 17 00:00:00 2001
From: koka <koka.code@gmail.com>
Date: Thu, 3 Nov 2022 23:53:29 +0900
Subject: fix turbofish in suggest message

---
 clippy_lints/src/methods/unnecessary_join.rs | 2 +-
 tests/ui/unnecessary_join.stderr             | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/unnecessary_join.rs b/clippy_lints/src/methods/unnecessary_join.rs
index 973b8a7e6bf..33efa16c300 100644
--- a/clippy_lints/src/methods/unnecessary_join.rs
+++ b/clippy_lints/src/methods/unnecessary_join.rs
@@ -31,7 +31,7 @@ pub(super) fn check<'tcx>(
                 cx,
                 UNNECESSARY_JOIN,
                 span.with_hi(expr.span.hi()),
-                r#"called `.collect<Vec<String>>().join("")` on an iterator"#,
+                r#"called `.collect::<Vec<String>>().join("")` on an iterator"#,
                 "try using",
                 "collect::<String>()".to_owned(),
                 applicability,
diff --git a/tests/ui/unnecessary_join.stderr b/tests/ui/unnecessary_join.stderr
index 0b14b143aff..e919a6d1d8a 100644
--- a/tests/ui/unnecessary_join.stderr
+++ b/tests/ui/unnecessary_join.stderr
@@ -1,4 +1,4 @@
-error: called `.collect<Vec<String>>().join("")` on an iterator
+error: called `.collect::<Vec<String>>().join("")` on an iterator
   --> $DIR/unnecessary_join.rs:11:10
    |
 LL |           .collect::<Vec<String>>()
@@ -8,7 +8,7 @@ LL | |         .join("");
    |
    = note: `-D clippy::unnecessary-join` implied by `-D warnings`
 
-error: called `.collect<Vec<String>>().join("")` on an iterator
+error: called `.collect::<Vec<String>>().join("")` on an iterator
   --> $DIR/unnecessary_join.rs:20:10
    |
 LL |           .collect::<Vec<_>>()
-- 
cgit 1.4.1-3-g733a5


From 50f63a0f240b4c37d992eaf55babaef1f162cacf Mon Sep 17 00:00:00 2001
From: Samuel Moelius <samuel.moelius@trailofbits.com>
Date: Fri, 4 Nov 2022 11:19:45 +0000
Subject: Address issues 9739 and 9782

---
 clippy_lints/src/dereference.rs | 69 ++++++++++++++++++++-----------
 tests/ui/needless_borrow.fixed  | 90 +++++++++++++++++++++++++++++++++++++++++
 tests/ui/needless_borrow.rs     | 90 +++++++++++++++++++++++++++++++++++++++++
 tests/ui/needless_borrow.stderr |  8 +++-
 4 files changed, 233 insertions(+), 24 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index 86e7bc2e6d1..400fbd6d8a7 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -805,30 +805,39 @@ fn walk_parents<'tcx>(
                     .position(|arg| arg.hir_id == child_id)
                     .zip(expr_sig(cx, func))
                     .and_then(|(i, sig)| {
-                        sig.input_with_hir(i).map(|(hir_ty, ty)| match hir_ty {
-                            // Type inference for closures can depend on how they're called. Only go by the explicit
-                            // types here.
-                            Some(hir_ty) => binding_ty_auto_deref_stability(cx, hir_ty, precedence, ty.bound_vars()),
-                            None => {
-                                if let ty::Param(param_ty) = ty.skip_binder().kind() {
-                                    needless_borrow_impl_arg_position(
-                                        cx,
-                                        possible_borrowers,
-                                        parent,
-                                        i,
-                                        *param_ty,
-                                        e,
-                                        precedence,
-                                        msrv,
-                                    )
-                                } else {
-                                    ty_auto_deref_stability(cx, cx.tcx.erase_late_bound_regions(ty), precedence)
-                                        .position_for_arg()
-                                }
-                            },
+                        sig.input_with_hir(i).map(|(hir_ty, ty)| {
+                            match hir_ty {
+                                // Type inference for closures can depend on how they're called. Only go by the explicit
+                                // types here.
+                                Some(hir_ty) => {
+                                    binding_ty_auto_deref_stability(cx, hir_ty, precedence, ty.bound_vars())
+                                },
+                                None => {
+                                    // `e.hir_id == child_id` for https://github.com/rust-lang/rust-clippy/issues/9739
+                                    // `!call_is_qualified(func)` for https://github.com/rust-lang/rust-clippy/issues/9782
+                                    if e.hir_id == child_id
+                                        && !call_is_qualified(func)
+                                        && let ty::Param(param_ty) = ty.skip_binder().kind()
+                                    {
+                                        needless_borrow_impl_arg_position(
+                                            cx,
+                                            possible_borrowers,
+                                            parent,
+                                            i,
+                                            *param_ty,
+                                            e,
+                                            precedence,
+                                            msrv,
+                                        )
+                                    } else {
+                                        ty_auto_deref_stability(cx, cx.tcx.erase_late_bound_regions(ty), precedence)
+                                            .position_for_arg()
+                                    }
+                                },
+                            }
                         })
                     }),
-                ExprKind::MethodCall(_, receiver, args, _) => {
+                ExprKind::MethodCall(method, receiver, args, _) => {
                     let id = cx.typeck_results().type_dependent_def_id(parent.hir_id).unwrap();
                     if receiver.hir_id == child_id {
                         // Check for calls to trait methods where the trait is implemented on a reference.
@@ -866,7 +875,9 @@ fn walk_parents<'tcx>(
                     }
                     args.iter().position(|arg| arg.hir_id == child_id).map(|i| {
                         let ty = cx.tcx.fn_sig(id).skip_binder().inputs()[i + 1];
-                        if let ty::Param(param_ty) = ty.kind() {
+                        // `e.hir_id == child_id` for https://github.com/rust-lang/rust-clippy/issues/9739
+                        // `method.args.is_none()` for https://github.com/rust-lang/rust-clippy/issues/9782
+                        if e.hir_id == child_id && method.args.is_none() && let ty::Param(param_ty) = ty.kind() {
                             needless_borrow_impl_arg_position(
                                 cx,
                                 possible_borrowers,
@@ -1044,6 +1055,18 @@ fn ty_contains_infer(ty: &hir::Ty<'_>) -> bool {
     v.0
 }
 
+fn call_is_qualified(expr: &Expr<'_>) -> bool {
+    if let ExprKind::Path(path) = &expr.kind {
+        match path {
+            QPath::Resolved(_, path) => path.segments.last().map_or(false, |segment| segment.args.is_some()),
+            QPath::TypeRelative(_, segment) => segment.args.is_some(),
+            QPath::LangItem(..) => false,
+        }
+    } else {
+        false
+    }
+}
+
 // Checks whether:
 // * child is an expression of the form `&e` in an argument position requiring an `impl Trait`
 // * `e`'s type implements `Trait` and is copyable
diff --git a/tests/ui/needless_borrow.fixed b/tests/ui/needless_borrow.fixed
index 9931fab04eb..85b6b639d55 100644
--- a/tests/ui/needless_borrow.fixed
+++ b/tests/ui/needless_borrow.fixed
@@ -420,3 +420,93 @@ mod issue_9710 {
 
     fn f<T: AsRef<str>>(_: T) {}
 }
+
+#[allow(dead_code)]
+mod issue_9739 {
+    fn foo<D: std::fmt::Display>(_it: impl IntoIterator<Item = D>) {}
+
+    fn main() {
+        foo(if std::env::var_os("HI").is_some() {
+            &[0]
+        } else {
+            &[] as &[u32]
+        });
+    }
+}
+
+#[allow(dead_code)]
+mod issue_9739_method_variant {
+    struct S;
+
+    impl S {
+        fn foo<D: std::fmt::Display>(&self, _it: impl IntoIterator<Item = D>) {}
+    }
+
+    fn main() {
+        S.foo(if std::env::var_os("HI").is_some() {
+            &[0]
+        } else {
+            &[] as &[u32]
+        });
+    }
+}
+
+#[allow(dead_code)]
+mod issue_9782 {
+    fn foo<T: AsRef<[u8]>>(t: T) {
+        println!("{}", std::mem::size_of::<T>());
+        let _t: &[u8] = t.as_ref();
+    }
+
+    fn main() {
+        let a: [u8; 100] = [0u8; 100];
+
+        // 100
+        foo::<[u8; 100]>(a);
+        foo(a);
+
+        // 16
+        foo::<&[u8]>(&a);
+        foo(a.as_slice());
+
+        // 8
+        foo::<&[u8; 100]>(&a);
+        foo(a);
+    }
+}
+
+#[allow(dead_code)]
+mod issue_9782_type_relative_variant {
+    struct S;
+
+    impl S {
+        fn foo<T: AsRef<[u8]>>(t: T) {
+            println!("{}", std::mem::size_of::<T>());
+            let _t: &[u8] = t.as_ref();
+        }
+    }
+
+    fn main() {
+        let a: [u8; 100] = [0u8; 100];
+
+        S::foo::<&[u8; 100]>(&a);
+    }
+}
+
+#[allow(dead_code)]
+mod issue_9782_method_variant {
+    struct S;
+
+    impl S {
+        fn foo<T: AsRef<[u8]>>(&self, t: T) {
+            println!("{}", std::mem::size_of::<T>());
+            let _t: &[u8] = t.as_ref();
+        }
+    }
+
+    fn main() {
+        let a: [u8; 100] = [0u8; 100];
+
+        S.foo::<&[u8; 100]>(&a);
+    }
+}
diff --git a/tests/ui/needless_borrow.rs b/tests/ui/needless_borrow.rs
index 4460f16d191..7b97bcf3817 100644
--- a/tests/ui/needless_borrow.rs
+++ b/tests/ui/needless_borrow.rs
@@ -420,3 +420,93 @@ mod issue_9710 {
 
     fn f<T: AsRef<str>>(_: T) {}
 }
+
+#[allow(dead_code)]
+mod issue_9739 {
+    fn foo<D: std::fmt::Display>(_it: impl IntoIterator<Item = D>) {}
+
+    fn main() {
+        foo(if std::env::var_os("HI").is_some() {
+            &[0]
+        } else {
+            &[] as &[u32]
+        });
+    }
+}
+
+#[allow(dead_code)]
+mod issue_9739_method_variant {
+    struct S;
+
+    impl S {
+        fn foo<D: std::fmt::Display>(&self, _it: impl IntoIterator<Item = D>) {}
+    }
+
+    fn main() {
+        S.foo(if std::env::var_os("HI").is_some() {
+            &[0]
+        } else {
+            &[] as &[u32]
+        });
+    }
+}
+
+#[allow(dead_code)]
+mod issue_9782 {
+    fn foo<T: AsRef<[u8]>>(t: T) {
+        println!("{}", std::mem::size_of::<T>());
+        let _t: &[u8] = t.as_ref();
+    }
+
+    fn main() {
+        let a: [u8; 100] = [0u8; 100];
+
+        // 100
+        foo::<[u8; 100]>(a);
+        foo(a);
+
+        // 16
+        foo::<&[u8]>(&a);
+        foo(a.as_slice());
+
+        // 8
+        foo::<&[u8; 100]>(&a);
+        foo(&a);
+    }
+}
+
+#[allow(dead_code)]
+mod issue_9782_type_relative_variant {
+    struct S;
+
+    impl S {
+        fn foo<T: AsRef<[u8]>>(t: T) {
+            println!("{}", std::mem::size_of::<T>());
+            let _t: &[u8] = t.as_ref();
+        }
+    }
+
+    fn main() {
+        let a: [u8; 100] = [0u8; 100];
+
+        S::foo::<&[u8; 100]>(&a);
+    }
+}
+
+#[allow(dead_code)]
+mod issue_9782_method_variant {
+    struct S;
+
+    impl S {
+        fn foo<T: AsRef<[u8]>>(&self, t: T) {
+            println!("{}", std::mem::size_of::<T>());
+            let _t: &[u8] = t.as_ref();
+        }
+    }
+
+    fn main() {
+        let a: [u8; 100] = [0u8; 100];
+
+        S.foo::<&[u8; 100]>(&a);
+    }
+}
diff --git a/tests/ui/needless_borrow.stderr b/tests/ui/needless_borrow.stderr
index 8b593268bec..485e6b84c86 100644
--- a/tests/ui/needless_borrow.stderr
+++ b/tests/ui/needless_borrow.stderr
@@ -210,5 +210,11 @@ error: the borrowed expression implements the required traits
 LL |         use_x(&x);
    |               ^^ help: change this to: `x`
 
-error: aborting due to 35 previous errors
+error: the borrowed expression implements the required traits
+  --> $DIR/needless_borrow.rs:474:13
+   |
+LL |         foo(&a);
+   |             ^^ help: change this to: `a`
+
+error: aborting due to 36 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From f27ca5c00a96d2dbd1e2b5dceee918d829891bc1 Mon Sep 17 00:00:00 2001
From: Samuel Moelius <samuel.moelius@trailofbits.com>
Date: Fri, 4 Nov 2022 16:01:44 +0000
Subject: Fix #9771 (`unnecessary_to_owned` false positive)

---
 clippy_lints/src/methods/unnecessary_to_owned.rs | 18 +++++++++++----
 tests/ui/unnecessary_to_owned.fixed              | 29 ++++++++++++++++++++++++
 tests/ui/unnecessary_to_owned.rs                 | 29 ++++++++++++++++++++++++
 3 files changed, 72 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/unnecessary_to_owned.rs b/clippy_lints/src/methods/unnecessary_to_owned.rs
index 4b4f2f47b1d..460bd1cfbd3 100644
--- a/clippy_lints/src/methods/unnecessary_to_owned.rs
+++ b/clippy_lints/src/methods/unnecessary_to_owned.rs
@@ -19,7 +19,6 @@ use rustc_middle::ty::{self, ParamTy, PredicateKind, ProjectionPredicate, TraitP
 use rustc_semver::RustcVersion;
 use rustc_span::{sym, Symbol};
 use rustc_trait_selection::traits::{query::evaluate_obligation::InferCtxtExt as _, Obligation, ObligationCause};
-use std::cmp::max;
 
 use super::UNNECESSARY_TO_OWNED;
 
@@ -263,11 +262,22 @@ fn check_other_call_arg<'tcx>(
         if let Some(as_ref_trait_id) = cx.tcx.get_diagnostic_item(sym::AsRef);
         if trait_predicate.def_id() == deref_trait_id || trait_predicate.def_id() == as_ref_trait_id;
         let receiver_ty = cx.typeck_results().expr_ty(receiver);
-        if can_change_type(cx, maybe_arg, receiver_ty);
         // We can't add an `&` when the trait is `Deref` because `Target = &T` won't match
         // `Target = T`.
-        if n_refs > 0 || is_copy(cx, receiver_ty) || trait_predicate.def_id() != deref_trait_id;
-        let n_refs = max(n_refs, usize::from(!is_copy(cx, receiver_ty)));
+        if let Some((n_refs, receiver_ty)) = if n_refs > 0 || is_copy(cx, receiver_ty) {
+            Some((n_refs, receiver_ty))
+        } else if trait_predicate.def_id() != deref_trait_id {
+            Some((1, cx.tcx.mk_ref(
+                cx.tcx.lifetimes.re_erased,
+                ty::TypeAndMut {
+                    ty: receiver_ty,
+                    mutbl: Mutability::Not,
+                },
+            )))
+        } else {
+            None
+        };
+        if can_change_type(cx, maybe_arg, receiver_ty);
         if let Some(receiver_snippet) = snippet_opt(cx, receiver.span);
         then {
             span_lint_and_sugg(
diff --git a/tests/ui/unnecessary_to_owned.fixed b/tests/ui/unnecessary_to_owned.fixed
index fe09aad06bc..fadcf7f9c9e 100644
--- a/tests/ui/unnecessary_to_owned.fixed
+++ b/tests/ui/unnecessary_to_owned.fixed
@@ -426,3 +426,32 @@ mod issue_9504 {
         foo(std::path::PathBuf::new().to_string_lossy().to_string()).await;
     }
 }
+
+mod issue_9771a {
+    #![allow(dead_code)]
+
+    use std::marker::PhantomData;
+
+    pub struct Key<K: AsRef<[u8]>, V: ?Sized>(K, PhantomData<V>);
+
+    impl<K: AsRef<[u8]>, V: ?Sized> Key<K, V> {
+        pub fn new(key: K) -> Key<K, V> {
+            Key(key, PhantomData)
+        }
+    }
+
+    pub fn pkh(pkh: &[u8]) -> Key<Vec<u8>, String> {
+        Key::new([b"pkh-", pkh].concat().to_vec())
+    }
+}
+
+mod issue_9771b {
+    #![allow(dead_code)]
+
+    pub struct Key<K: AsRef<[u8]>>(K);
+
+    pub fn from(c: &[u8]) -> Key<Vec<u8>> {
+        let v = [c].concat();
+        Key(v.to_vec())
+    }
+}
diff --git a/tests/ui/unnecessary_to_owned.rs b/tests/ui/unnecessary_to_owned.rs
index 3de6d0903c0..fe6864b9e07 100644
--- a/tests/ui/unnecessary_to_owned.rs
+++ b/tests/ui/unnecessary_to_owned.rs
@@ -426,3 +426,32 @@ mod issue_9504 {
         foo(std::path::PathBuf::new().to_string_lossy().to_string()).await;
     }
 }
+
+mod issue_9771a {
+    #![allow(dead_code)]
+
+    use std::marker::PhantomData;
+
+    pub struct Key<K: AsRef<[u8]>, V: ?Sized>(K, PhantomData<V>);
+
+    impl<K: AsRef<[u8]>, V: ?Sized> Key<K, V> {
+        pub fn new(key: K) -> Key<K, V> {
+            Key(key, PhantomData)
+        }
+    }
+
+    pub fn pkh(pkh: &[u8]) -> Key<Vec<u8>, String> {
+        Key::new([b"pkh-", pkh].concat().to_vec())
+    }
+}
+
+mod issue_9771b {
+    #![allow(dead_code)]
+
+    pub struct Key<K: AsRef<[u8]>>(K);
+
+    pub fn from(c: &[u8]) -> Key<Vec<u8>> {
+        let v = [c].concat();
+        Key(v.to_vec())
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From ddcfff6d9a33fd8ee95f715055e8ea3e691cc1f2 Mon Sep 17 00:00:00 2001
From: Trevor Arjeski <tmarjeski@gmail.com>
Date: Fri, 4 Nov 2022 20:33:04 +0300
Subject: Add allow-print-in-tests config

Add a config, allow-print-in-tests, that can be set in clippy.toml which
allows the usage of `[e]print[ln]!` macros in tests.

Closes #9795
---
 clippy_lints/src/lib.rs                              |  3 ++-
 clippy_lints/src/utils/conf.rs                       |  4 ++++
 clippy_lints/src/write.rs                            | 17 +++++++++++++++--
 tests/ui-toml/print_macro/clippy.toml                |  1 +
 tests/ui-toml/print_macro/print_macro.rs             | 20 ++++++++++++++++++++
 tests/ui-toml/print_macro/print_macro.stderr         | 18 ++++++++++++++++++
 .../ui-toml/toml_unknown_key/conf_unknown_key.stderr |  1 +
 7 files changed, 61 insertions(+), 3 deletions(-)
 create mode 100644 tests/ui-toml/print_macro/clippy.toml
 create mode 100644 tests/ui-toml/print_macro/print_macro.rs
 create mode 100644 tests/ui-toml/print_macro/print_macro.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 197d8f2dc08..4949a1b778f 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -876,13 +876,14 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::<only_used_in_recursion::OnlyUsedInRecursion>::default());
     let allow_dbg_in_tests = conf.allow_dbg_in_tests;
     store.register_late_pass(move |_| Box::new(dbg_macro::DbgMacro::new(allow_dbg_in_tests)));
+    let allow_print_in_tests = conf.allow_print_in_tests;
+    store.register_late_pass(move |_| Box::new(write::Write::new(allow_print_in_tests)));
     let cargo_ignore_publish = conf.cargo_ignore_publish;
     store.register_late_pass(move |_| {
         Box::new(cargo::Cargo {
             ignore_publish: cargo_ignore_publish,
         })
     });
-    store.register_late_pass(|_| Box::<write::Write>::default());
     store.register_early_pass(|| Box::new(crate_in_macro_def::CrateInMacroDef));
     store.register_early_pass(|| Box::new(empty_structs_with_brackets::EmptyStructsWithBrackets));
     store.register_late_pass(|_| Box::new(unnecessary_owned_empty_strings::UnnecessaryOwnedEmptyStrings));
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 2771c26255a..0cf49ca6d42 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -389,6 +389,10 @@ define_Conf! {
     ///
     /// Whether `dbg!` should be allowed in test functions
     (allow_dbg_in_tests: bool = false),
+    /// Lint: PRINT_STDOUT, PRINT_STDERR.
+    ///
+    /// Whether print macros (ex. `println!`) should be allowed in test functions
+    (allow_print_in_tests: bool = false),
     /// Lint: RESULT_LARGE_ERR.
     ///
     /// The maximum size of the `Err`-variant in a `Result` returned from a function
diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs
index 36574198f91..6b321765bc0 100644
--- a/clippy_lints/src/write.rs
+++ b/clippy_lints/src/write.rs
@@ -1,6 +1,7 @@
 use clippy_utils::diagnostics::{span_lint, span_lint_and_then};
 use clippy_utils::macros::{root_macro_call_first_node, FormatArgsExpn, MacroCall};
 use clippy_utils::source::{expand_past_previous_comma, snippet_opt};
+use clippy_utils::{is_in_cfg_test, is_in_test_function};
 use rustc_ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, HirIdMap, Impl, Item, ItemKind};
@@ -232,6 +233,16 @@ declare_clippy_lint! {
 #[derive(Default)]
 pub struct Write {
     in_debug_impl: bool,
+    allow_print_in_tests: bool,
+}
+
+impl Write {
+    pub fn new(allow_print_in_tests: bool) -> Self {
+        Self {
+            allow_print_in_tests,
+            ..Default::default()
+        }
+    }
 }
 
 impl_lint_pass!(Write => [
@@ -271,13 +282,15 @@ impl<'tcx> LateLintPass<'tcx> for Write {
             .as_ref()
             .map_or(false, |crate_name| crate_name == "build_script_build");
 
+        let allowed_in_tests = self.allow_print_in_tests
+            && (is_in_test_function(cx.tcx, expr.hir_id) || is_in_cfg_test(cx.tcx, expr.hir_id));
         match diag_name {
-            sym::print_macro | sym::println_macro => {
+            sym::print_macro | sym::println_macro if !allowed_in_tests => {
                 if !is_build_script {
                     span_lint(cx, PRINT_STDOUT, macro_call.span, &format!("use of `{name}!`"));
                 }
             },
-            sym::eprint_macro | sym::eprintln_macro => {
+            sym::eprint_macro | sym::eprintln_macro if !allowed_in_tests => {
                 span_lint(cx, PRINT_STDERR, macro_call.span, &format!("use of `{name}!`"));
             },
             sym::write_macro | sym::writeln_macro => {},
diff --git a/tests/ui-toml/print_macro/clippy.toml b/tests/ui-toml/print_macro/clippy.toml
new file mode 100644
index 00000000000..40b1dda5b2e
--- /dev/null
+++ b/tests/ui-toml/print_macro/clippy.toml
@@ -0,0 +1 @@
+allow-print-in-tests = true
diff --git a/tests/ui-toml/print_macro/print_macro.rs b/tests/ui-toml/print_macro/print_macro.rs
new file mode 100644
index 00000000000..5aefb6a6b4d
--- /dev/null
+++ b/tests/ui-toml/print_macro/print_macro.rs
@@ -0,0 +1,20 @@
+// compile-flags: --test
+#![warn(clippy::print_stdout)]
+#![warn(clippy::print_stderr)]
+
+fn foo(n: u32) {
+    print!("{n}");
+    eprint!("{n}");
+}
+
+#[test]
+pub fn foo1() {
+    print!("{}", 1);
+    eprint!("{}", 1);
+}
+
+#[cfg(test)]
+fn foo3() {
+    print!("{}", 1);
+    eprint!("{}", 1);
+}
diff --git a/tests/ui-toml/print_macro/print_macro.stderr b/tests/ui-toml/print_macro/print_macro.stderr
new file mode 100644
index 00000000000..d4b1ae84fd7
--- /dev/null
+++ b/tests/ui-toml/print_macro/print_macro.stderr
@@ -0,0 +1,18 @@
+error: use of `print!`
+  --> $DIR/print_macro.rs:6:5
+   |
+LL |     print!("{n}");
+   |     ^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::print-stdout` implied by `-D warnings`
+
+error: use of `eprint!`
+  --> $DIR/print_macro.rs:7:5
+   |
+LL |     eprint!("{n}");
+   |     ^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::print-stderr` implied by `-D warnings`
+
+error: aborting due to 2 previous errors
+
diff --git a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
index b7842c36240..f91d285c2e0 100644
--- a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
+++ b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
@@ -1,6 +1,7 @@
 error: error reading Clippy's configuration file `$DIR/clippy.toml`: unknown field `foobar`, expected one of
            allow-dbg-in-tests
            allow-expect-in-tests
+           allow-print-in-tests
            allow-unwrap-in-tests
            allowed-scripts
            arithmetic-side-effects-allowed
-- 
cgit 1.4.1-3-g733a5


From f86c35c326006d2406192985e49085a3a828a1fc Mon Sep 17 00:00:00 2001
From: bebecue <109153518+bebecue@users.noreply.github.com>
Date: Sat, 5 Nov 2022 04:44:02 +0800
Subject: Update lint `suspicious_to_owned`

`matches!(data, String)` will matches any type, replace it with explicit type annotation.
---
 clippy_lints/src/methods/mod.rs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 43a52f15680..26834dc4fcc 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -2096,8 +2096,7 @@ declare_clippy_lint! {
     /// let s = "Hello world!";
     /// let cow = Cow::Borrowed(s);
     ///
-    /// let data = cow.into_owned();
-    /// assert!(matches!(data, String))
+    /// let _data: String = cow.into_owned();
     /// ```
     #[clippy::version = "1.65.0"]
     pub SUSPICIOUS_TO_OWNED,
-- 
cgit 1.4.1-3-g733a5


From 1e1ac2b4985a1236003ef23b92e3edf3af8f5dfe Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Fri, 4 Nov 2022 21:58:07 +0000
Subject: Return multiple resolutions from `def_path_res`

---
 clippy_lints/src/await_holding_invalid.rs          |   3 +-
 clippy_lints/src/disallowed_macros.rs              |   5 +-
 clippy_lints/src/disallowed_methods.rs             |   5 +-
 clippy_lints/src/disallowed_types.rs               |  40 +--
 clippy_lints/src/missing_enforced_import_rename.rs |   2 +-
 clippy_lints/src/mut_key.rs                        |   5 +-
 clippy_lints/src/utils/conf.rs                     |   4 +-
 .../internal_lints/interning_defined_symbol.rs     |   4 +-
 .../src/utils/internal_lints/invalid_paths.rs      |   4 +-
 .../utils/internal_lints/unnecessary_def_path.rs   |  48 +---
 clippy_utils/src/lib.rs                            | 307 +++++++++++----------
 .../await_holding_invalid_type.stderr              |   4 +-
 tests/ui-toml/toml_disallowed_methods/clippy.toml  |   6 +
 .../conf_disallowed_methods.rs                     |  30 ++
 .../conf_disallowed_methods.stderr                 |  50 +++-
 15 files changed, 281 insertions(+), 236 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/await_holding_invalid.rs b/clippy_lints/src/await_holding_invalid.rs
index 34717811866..d40a385435a 100644
--- a/clippy_lints/src/await_holding_invalid.rs
+++ b/clippy_lints/src/await_holding_invalid.rs
@@ -1,7 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::{match_def_path, paths};
 use rustc_data_structures::fx::FxHashMap;
-use rustc_hir::def::{Namespace, Res};
 use rustc_hir::def_id::DefId;
 use rustc_hir::{AsyncGeneratorKind, Body, BodyId, GeneratorKind};
 use rustc_lint::{LateContext, LateLintPass};
@@ -189,7 +188,7 @@ impl LateLintPass<'_> for AwaitHolding {
     fn check_crate(&mut self, cx: &LateContext<'_>) {
         for conf in &self.conf_invalid_types {
             let segs: Vec<_> = conf.path().split("::").collect();
-            if let Res::Def(_, id) = clippy_utils::def_path_res(cx, &segs, Some(Namespace::TypeNS)) {
+            for id in clippy_utils::def_path_def_ids(cx, &segs) {
                 self.def_ids.insert(id, conf.clone());
             }
         }
diff --git a/clippy_lints/src/disallowed_macros.rs b/clippy_lints/src/disallowed_macros.rs
index 5ab7144e290..68122b4cef5 100644
--- a/clippy_lints/src/disallowed_macros.rs
+++ b/clippy_lints/src/disallowed_macros.rs
@@ -1,7 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::macros::macro_backtrace;
 use rustc_data_structures::fx::FxHashSet;
-use rustc_hir::def::{Namespace, Res};
 use rustc_hir::def_id::DefIdMap;
 use rustc_hir::{Expr, ForeignItem, HirId, ImplItem, Item, Pat, Path, Stmt, TraitItem, Ty};
 use rustc_lint::{LateContext, LateLintPass};
@@ -89,7 +88,7 @@ impl DisallowedMacros {
                     &format!("use of a disallowed macro `{}`", conf.path()),
                     |diag| {
                         if let Some(reason) = conf.reason() {
-                            diag.note(&format!("{reason} (from clippy.toml)"));
+                            diag.note(reason);
                         }
                     },
                 );
@@ -104,7 +103,7 @@ impl LateLintPass<'_> for DisallowedMacros {
     fn check_crate(&mut self, cx: &LateContext<'_>) {
         for (index, conf) in self.conf_disallowed.iter().enumerate() {
             let segs: Vec<_> = conf.path().split("::").collect();
-            if let Res::Def(_, id) = clippy_utils::def_path_res(cx, &segs, Some(Namespace::MacroNS)) {
+            for id in clippy_utils::def_path_def_ids(cx, &segs) {
                 self.disallowed.insert(id, index);
             }
         }
diff --git a/clippy_lints/src/disallowed_methods.rs b/clippy_lints/src/disallowed_methods.rs
index 6ac85606d9c..ca8671c8f1a 100644
--- a/clippy_lints/src/disallowed_methods.rs
+++ b/clippy_lints/src/disallowed_methods.rs
@@ -1,7 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::{fn_def_id, get_parent_expr, path_def_id};
 
-use rustc_hir::def::{Namespace, Res};
 use rustc_hir::def_id::DefIdMap;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
@@ -79,7 +78,7 @@ impl<'tcx> LateLintPass<'tcx> for DisallowedMethods {
     fn check_crate(&mut self, cx: &LateContext<'_>) {
         for (index, conf) in self.conf_disallowed.iter().enumerate() {
             let segs: Vec<_> = conf.path().split("::").collect();
-            if let Res::Def(_, id) = clippy_utils::def_path_res(cx, &segs, Some(Namespace::ValueNS)) {
+            for id in clippy_utils::def_path_def_ids(cx, &segs) {
                 self.disallowed.insert(id, index);
             }
         }
@@ -104,7 +103,7 @@ impl<'tcx> LateLintPass<'tcx> for DisallowedMethods {
         let msg = format!("use of a disallowed method `{}`", conf.path());
         span_lint_and_then(cx, DISALLOWED_METHODS, expr.span, &msg, |diag| {
             if let Some(reason) = conf.reason() {
-                diag.note(&format!("{reason} (from clippy.toml)"));
+                diag.note(reason);
             }
         });
     }
diff --git a/clippy_lints/src/disallowed_types.rs b/clippy_lints/src/disallowed_types.rs
index c7131fc164d..aee3d8c4f08 100644
--- a/clippy_lints/src/disallowed_types.rs
+++ b/clippy_lints/src/disallowed_types.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 
 use rustc_data_structures::fx::FxHashMap;
-use rustc_hir::def::{Namespace, Res};
+use rustc_hir::def::Res;
 use rustc_hir::def_id::DefId;
 use rustc_hir::{Item, ItemKind, PolyTraitRef, PrimTy, Ty, TyKind, UseKind};
 use rustc_lint::{LateContext, LateLintPass};
@@ -53,8 +53,8 @@ declare_clippy_lint! {
 #[derive(Clone, Debug)]
 pub struct DisallowedTypes {
     conf_disallowed: Vec<conf::DisallowedPath>,
-    def_ids: FxHashMap<DefId, Option<String>>,
-    prim_tys: FxHashMap<PrimTy, Option<String>>,
+    def_ids: FxHashMap<DefId, usize>,
+    prim_tys: FxHashMap<PrimTy, usize>,
 }
 
 impl DisallowedTypes {
@@ -69,13 +69,13 @@ impl DisallowedTypes {
     fn check_res_emit(&self, cx: &LateContext<'_>, res: &Res, span: Span) {
         match res {
             Res::Def(_, did) => {
-                if let Some(reason) = self.def_ids.get(did) {
-                    emit(cx, &cx.tcx.def_path_str(*did), span, reason.as_deref());
+                if let Some(&index) = self.def_ids.get(did) {
+                    emit(cx, &cx.tcx.def_path_str(*did), span, &self.conf_disallowed[index]);
                 }
             },
             Res::PrimTy(prim) => {
-                if let Some(reason) = self.prim_tys.get(prim) {
-                    emit(cx, prim.name_str(), span, reason.as_deref());
+                if let Some(&index) = self.prim_tys.get(prim) {
+                    emit(cx, prim.name_str(), span, &self.conf_disallowed[index]);
                 }
             },
             _ => {},
@@ -87,17 +87,19 @@ impl_lint_pass!(DisallowedTypes => [DISALLOWED_TYPES]);
 
 impl<'tcx> LateLintPass<'tcx> for DisallowedTypes {
     fn check_crate(&mut self, cx: &LateContext<'_>) {
-        for conf in &self.conf_disallowed {
+        for (index, conf) in self.conf_disallowed.iter().enumerate() {
             let segs: Vec<_> = conf.path().split("::").collect();
-            let reason = conf.reason().map(|reason| format!("{reason} (from clippy.toml)"));
-            match clippy_utils::def_path_res(cx, &segs, Some(Namespace::TypeNS)) {
-                Res::Def(_, id) => {
-                    self.def_ids.insert(id, reason);
-                },
-                Res::PrimTy(ty) => {
-                    self.prim_tys.insert(ty, reason);
-                },
-                _ => {},
+
+            for res in clippy_utils::def_path_res(cx, &segs) {
+                match res {
+                    Res::Def(_, id) => {
+                        self.def_ids.insert(id, index);
+                    },
+                    Res::PrimTy(ty) => {
+                        self.prim_tys.insert(ty, index);
+                    },
+                    _ => {},
+                }
             }
         }
     }
@@ -119,14 +121,14 @@ impl<'tcx> LateLintPass<'tcx> for DisallowedTypes {
     }
 }
 
-fn emit(cx: &LateContext<'_>, name: &str, span: Span, reason: Option<&str>) {
+fn emit(cx: &LateContext<'_>, name: &str, span: Span, conf: &conf::DisallowedPath) {
     span_lint_and_then(
         cx,
         DISALLOWED_TYPES,
         span,
         &format!("`{name}` is not allowed according to config"),
         |diag| {
-            if let Some(reason) = reason {
+            if let Some(reason) = conf.reason() {
                 diag.note(reason);
             }
         },
diff --git a/clippy_lints/src/missing_enforced_import_rename.rs b/clippy_lints/src/missing_enforced_import_rename.rs
index 872679f25ab..4712846939e 100644
--- a/clippy_lints/src/missing_enforced_import_rename.rs
+++ b/clippy_lints/src/missing_enforced_import_rename.rs
@@ -59,7 +59,7 @@ impl LateLintPass<'_> for ImportRename {
     fn check_crate(&mut self, cx: &LateContext<'_>) {
         for Rename { path, rename } in &self.conf_renames {
             let segs = path.split("::").collect::<Vec<_>>();
-            if let Res::Def(_, id) = clippy_utils::def_path_res(cx, &segs, None) {
+            for id in clippy_utils::def_path_def_ids(cx, &segs) {
                 self.renames.insert(id, Symbol::intern(rename));
             }
         }
diff --git a/clippy_lints/src/mut_key.rs b/clippy_lints/src/mut_key.rs
index 551b6ed1227..f0f152904f7 100644
--- a/clippy_lints/src/mut_key.rs
+++ b/clippy_lints/src/mut_key.rs
@@ -1,8 +1,7 @@
 use clippy_utils::diagnostics::span_lint;
-use clippy_utils::{def_path_res, trait_ref_of_method};
+use clippy_utils::{def_path_def_ids, trait_ref_of_method};
 use rustc_data_structures::fx::FxHashSet;
 use rustc_hir as hir;
-use rustc_hir::def::Namespace;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::TypeVisitable;
 use rustc_middle::ty::{Adt, Array, Ref, Slice, Tuple, Ty};
@@ -94,7 +93,7 @@ impl<'tcx> LateLintPass<'tcx> for MutableKeyType {
         let mut path = Vec::new();
         for ty in &self.ignore_interior_mutability {
             path.extend(ty.split("::"));
-            if let Some(id) = def_path_res(cx, &path[..], Some(Namespace::TypeNS)).opt_def_id() {
+            for id in def_path_def_ids(cx, &path[..]) {
                 self.ignore_mut_def_ids.insert(id);
             }
             path.clear();
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 2771c26255a..5bd88fa3c1c 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -53,11 +53,11 @@ impl DisallowedPath {
         path
     }
 
-    pub fn reason(&self) -> Option<&str> {
+    pub fn reason(&self) -> Option<String> {
         match self {
             Self::WithReason {
                 reason: Some(reason), ..
-            } => Some(reason),
+            } => Some(format!("{reason} (from clippy.toml)")),
             _ => None,
         }
     }
diff --git a/clippy_lints/src/utils/internal_lints/interning_defined_symbol.rs b/clippy_lints/src/utils/internal_lints/interning_defined_symbol.rs
index 096b601572b..4b33d492a0e 100644
--- a/clippy_lints/src/utils/internal_lints/interning_defined_symbol.rs
+++ b/clippy_lints/src/utils/internal_lints/interning_defined_symbol.rs
@@ -2,7 +2,7 @@ use clippy_utils::consts::{constant_simple, Constant};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::match_type;
-use clippy_utils::{def_path_res, is_expn_of, match_def_path, paths};
+use clippy_utils::{def_path_def_ids, is_expn_of, match_def_path, paths};
 use if_chain::if_chain;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::Applicability;
@@ -74,7 +74,7 @@ impl<'tcx> LateLintPass<'tcx> for InterningDefinedSymbol {
         }
 
         for &module in &[&paths::KW_MODULE, &paths::SYM_MODULE] {
-            if let Some(def_id) = def_path_res(cx, module, None).opt_def_id() {
+            for def_id in def_path_def_ids(cx, module) {
                 for item in cx.tcx.module_children(def_id).iter() {
                     if_chain! {
                         if let Res::Def(DefKind::Const, item_def_id) = item.res;
diff --git a/clippy_lints/src/utils/internal_lints/invalid_paths.rs b/clippy_lints/src/utils/internal_lints/invalid_paths.rs
index 25532dd4e26..4e2e1cc8d77 100644
--- a/clippy_lints/src/utils/internal_lints/invalid_paths.rs
+++ b/clippy_lints/src/utils/internal_lints/invalid_paths.rs
@@ -3,7 +3,7 @@ use clippy_utils::def_path_res;
 use clippy_utils::diagnostics::span_lint;
 use if_chain::if_chain;
 use rustc_hir as hir;
-use rustc_hir::def::{DefKind, Res};
+use rustc_hir::def::DefKind;
 use rustc_hir::Item;
 use rustc_hir_analysis::hir_ty_to_ty;
 use rustc_lint::{LateContext, LateLintPass};
@@ -63,7 +63,7 @@ impl<'tcx> LateLintPass<'tcx> for InvalidPaths {
 // This is not a complete resolver for paths. It works on all the paths currently used in the paths
 // module.  That's all it does and all it needs to do.
 pub fn check_path(cx: &LateContext<'_>, path: &[&str]) -> bool {
-    if def_path_res(cx, path, None) != Res::Err {
+    if !def_path_res(cx, path).is_empty() {
         return true;
     }
 
diff --git a/clippy_lints/src/utils/internal_lints/unnecessary_def_path.rs b/clippy_lints/src/utils/internal_lints/unnecessary_def_path.rs
index 4cf76f53625..0d91398b74f 100644
--- a/clippy_lints/src/utils/internal_lints/unnecessary_def_path.rs
+++ b/clippy_lints/src/utils/internal_lints/unnecessary_def_path.rs
@@ -1,19 +1,19 @@
 use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_then};
 use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::{def_path_res, is_lint_allowed, match_any_def_paths, peel_hir_expr_refs};
+use clippy_utils::{def_path_def_ids, is_lint_allowed, match_any_def_paths, peel_hir_expr_refs};
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
-use rustc_hir::def::{DefKind, Namespace, Res};
+use rustc_hir::def::{DefKind, Res};
 use rustc_hir::def_id::DefId;
 use rustc_hir::{Expr, ExprKind, Local, Mutability, Node};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::mir::interpret::{Allocation, ConstValue, GlobalAlloc};
-use rustc_middle::ty::{self, AssocKind, DefIdTree, Ty};
+use rustc_middle::ty::{self, DefIdTree, Ty};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::symbol::{Ident, Symbol};
+use rustc_span::symbol::Symbol;
 use rustc_span::Span;
 
 use std::str;
@@ -110,7 +110,7 @@ impl UnnecessaryDefPath {
             // Extract the path to the matched type
             if let Some(segments) = path_to_matched_type(cx, item_arg);
             let segments: Vec<&str> = segments.iter().map(|sym| &**sym).collect();
-            if let Some(def_id) = inherent_def_path_res(cx, &segments[..]);
+            if let Some(def_id) = def_path_def_ids(cx, &segments[..]).next();
             then {
                 // Check if the target item is a diagnostic item or LangItem.
                 #[rustfmt::skip]
@@ -209,7 +209,7 @@ impl UnnecessaryDefPath {
     fn check_array(&mut self, cx: &LateContext<'_>, elements: &[Expr<'_>], span: Span) {
         let Some(path) = path_from_array(elements) else { return };
 
-        if let Some(def_id) = inherent_def_path_res(cx, &path.iter().map(AsRef::as_ref).collect::<Vec<_>>()) {
+        for def_id in def_path_def_ids(cx, &path.iter().map(AsRef::as_ref).collect::<Vec<_>>()) {
             self.array_def_ids.insert((def_id, span));
         }
     }
@@ -293,41 +293,11 @@ fn path_from_array(exprs: &[Expr<'_>]) -> Option<Vec<String>> {
         .collect()
 }
 
-// def_path_res will match field names before anything else, but for this we want to match
-// inherent functions first.
-fn inherent_def_path_res(cx: &LateContext<'_>, segments: &[&str]) -> Option<DefId> {
-    def_path_res(cx, segments, None).opt_def_id().map(|def_id| {
-        if cx.tcx.def_kind(def_id) == DefKind::Field {
-            let method_name = *segments.last().unwrap();
-            cx.tcx
-                .def_key(def_id)
-                .parent
-                .and_then(|parent_idx| {
-                    cx.tcx
-                        .inherent_impls(DefId {
-                            index: parent_idx,
-                            krate: def_id.krate,
-                        })
-                        .iter()
-                        .find_map(|impl_id| {
-                            cx.tcx.associated_items(*impl_id).find_by_name_and_kind(
-                                cx.tcx,
-                                Ident::from_str(method_name),
-                                AssocKind::Fn,
-                                *impl_id,
-                            )
-                        })
-                })
-                .map_or(def_id, |item| item.def_id)
-        } else {
-            def_id
-        }
-    })
-}
-
 fn get_lang_item_name(cx: &LateContext<'_>, def_id: DefId) -> Option<Symbol> {
     if let Some(lang_item) = cx.tcx.lang_items().items().iter().position(|id| *id == Some(def_id)) {
-        let lang_items = def_path_res(cx, &["rustc_hir", "lang_items", "LangItem"], Some(Namespace::TypeNS)).def_id();
+        let lang_items = def_path_def_ids(cx, &["rustc_hir", "lang_items", "LangItem"])
+            .next()
+            .unwrap();
         let item_name = cx
             .tcx
             .adt_def(lang_items)
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index f7d3c91777e..0e72075e9f4 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -80,17 +80,16 @@ use rustc_ast::ast::{self, LitKind};
 use rustc_ast::Attribute;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_data_structures::unhash::UnhashMap;
-use rustc_hir as hir;
-use rustc_hir::def::{DefKind, Namespace, Res};
-use rustc_hir::def_id::{CrateNum, DefId, LocalDefId};
+use rustc_hir::def::{DefKind, Res};
+use rustc_hir::def_id::{CrateNum, DefId, LocalDefId, LOCAL_CRATE};
 use rustc_hir::hir_id::{HirIdMap, HirIdSet};
 use rustc_hir::intravisit::{walk_expr, FnKind, Visitor};
 use rustc_hir::LangItem::{OptionNone, ResultErr, ResultOk};
 use rustc_hir::{
-    def, Arm, ArrayLen, BindingAnnotation, Block, BlockCheckMode, Body, Closure, Constness, Destination, Expr,
-    ExprKind, FnDecl, HirId, Impl, ImplItem, ImplItemKind, IsAsync, Item, ItemKind, LangItem, Local, MatchSource,
-    Mutability, Node, Param, Pat, PatKind, Path, PathSegment, PrimTy, QPath, Stmt, StmtKind, TraitItem, TraitItemKind,
-    TraitRef, TyKind, UnOp,
+    self as hir, def, Arm, ArrayLen, BindingAnnotation, Block, BlockCheckMode, Body, Closure, Constness, Destination,
+    Expr, ExprKind, FnDecl, HirId, Impl, ImplItem, ImplItemKind, ImplItemRef, IsAsync, Item, ItemKind, LangItem, Local,
+    MatchSource, Mutability, Node, OwnerId, Param, Pat, PatKind, Path, PathSegment, PrimTy, QPath, Stmt, StmtKind,
+    TraitItem, TraitItemKind, TraitItemRef, TraitRef, TyKind, UnOp,
 };
 use rustc_lexer::{tokenize, TokenKind};
 use rustc_lint::{LateContext, Level, Lint, LintContext};
@@ -112,7 +111,7 @@ use rustc_span::hygiene::{ExpnKind, MacroKind};
 use rustc_span::source_map::original_sp;
 use rustc_span::source_map::SourceMap;
 use rustc_span::sym;
-use rustc_span::symbol::{kw, Symbol};
+use rustc_span::symbol::{kw, Ident, Symbol};
 use rustc_span::{Span, DUMMY_SP};
 use rustc_target::abi::Integer;
 
@@ -525,165 +524,177 @@ pub fn path_def_id<'tcx>(cx: &LateContext<'_>, maybe_path: &impl MaybePath<'tcx>
     path_res(cx, maybe_path).opt_def_id()
 }
 
-fn find_primitive<'tcx>(tcx: TyCtxt<'tcx>, name: &str) -> impl Iterator<Item = DefId> + 'tcx {
-    let single = |ty| tcx.incoherent_impls(ty).iter().copied();
-    let empty = || [].iter().copied();
-    match name {
-        "bool" => single(BoolSimplifiedType),
-        "char" => single(CharSimplifiedType),
-        "str" => single(StrSimplifiedType),
-        "array" => single(ArraySimplifiedType),
-        "slice" => single(SliceSimplifiedType),
+fn find_primitive_impls<'tcx>(tcx: TyCtxt<'tcx>, name: &str) -> impl Iterator<Item = DefId> + 'tcx {
+    let ty = match name {
+        "bool" => BoolSimplifiedType,
+        "char" => CharSimplifiedType,
+        "str" => StrSimplifiedType,
+        "array" => ArraySimplifiedType,
+        "slice" => SliceSimplifiedType,
         // FIXME: rustdoc documents these two using just `pointer`.
         //
         // Maybe this is something we should do here too.
-        "const_ptr" => single(PtrSimplifiedType(Mutability::Not)),
-        "mut_ptr" => single(PtrSimplifiedType(Mutability::Mut)),
-        "isize" => single(IntSimplifiedType(IntTy::Isize)),
-        "i8" => single(IntSimplifiedType(IntTy::I8)),
-        "i16" => single(IntSimplifiedType(IntTy::I16)),
-        "i32" => single(IntSimplifiedType(IntTy::I32)),
-        "i64" => single(IntSimplifiedType(IntTy::I64)),
-        "i128" => single(IntSimplifiedType(IntTy::I128)),
-        "usize" => single(UintSimplifiedType(UintTy::Usize)),
-        "u8" => single(UintSimplifiedType(UintTy::U8)),
-        "u16" => single(UintSimplifiedType(UintTy::U16)),
-        "u32" => single(UintSimplifiedType(UintTy::U32)),
-        "u64" => single(UintSimplifiedType(UintTy::U64)),
-        "u128" => single(UintSimplifiedType(UintTy::U128)),
-        "f32" => single(FloatSimplifiedType(FloatTy::F32)),
-        "f64" => single(FloatSimplifiedType(FloatTy::F64)),
-        _ => empty(),
-    }
-}
-
-/// Resolves a def path like `std::vec::Vec`. `namespace_hint` can be supplied to disambiguate
-/// between `std::vec` the module and `std::vec` the macro
-///
-/// This function is expensive and should be used sparingly.
-pub fn def_path_res(cx: &LateContext<'_>, path: &[&str], namespace_hint: Option<Namespace>) -> Res {
-    fn item_child_by_name(tcx: TyCtxt<'_>, def_id: DefId, name: &str, matches_ns: impl Fn(Res) -> bool) -> Option<Res> {
-        match tcx.def_kind(def_id) {
-            DefKind::Mod | DefKind::Enum | DefKind::Trait => tcx
-                .module_children(def_id)
-                .iter()
-                .find(|item| item.ident.name.as_str() == name && matches_ns(item.res.expect_non_local()))
-                .map(|child| child.res.expect_non_local()),
-            DefKind::Impl => tcx
-                .associated_item_def_ids(def_id)
-                .iter()
-                .copied()
-                .find(|assoc_def_id| tcx.item_name(*assoc_def_id).as_str() == name)
-                .map(|assoc_def_id| Res::Def(tcx.def_kind(assoc_def_id), assoc_def_id)),
-            DefKind::Struct | DefKind::Union => tcx
-                .adt_def(def_id)
-                .non_enum_variant()
-                .fields
-                .iter()
-                .find(|f| f.name.as_str() == name)
-                .map(|f| Res::Def(DefKind::Field, f.did)),
-            _ => None,
+        "const_ptr" => PtrSimplifiedType(Mutability::Not),
+        "mut_ptr" => PtrSimplifiedType(Mutability::Mut),
+        "isize" => IntSimplifiedType(IntTy::Isize),
+        "i8" => IntSimplifiedType(IntTy::I8),
+        "i16" => IntSimplifiedType(IntTy::I16),
+        "i32" => IntSimplifiedType(IntTy::I32),
+        "i64" => IntSimplifiedType(IntTy::I64),
+        "i128" => IntSimplifiedType(IntTy::I128),
+        "usize" => UintSimplifiedType(UintTy::Usize),
+        "u8" => UintSimplifiedType(UintTy::U8),
+        "u16" => UintSimplifiedType(UintTy::U16),
+        "u32" => UintSimplifiedType(UintTy::U32),
+        "u64" => UintSimplifiedType(UintTy::U64),
+        "u128" => UintSimplifiedType(UintTy::U128),
+        "f32" => FloatSimplifiedType(FloatTy::F32),
+        "f64" => FloatSimplifiedType(FloatTy::F64),
+        _ => return [].iter().copied(),
+    };
+
+    tcx.incoherent_impls(ty).iter().copied()
+}
+
+fn non_local_item_children_by_name(tcx: TyCtxt<'_>, def_id: DefId, name: Symbol) -> Vec<Res> {
+    match tcx.def_kind(def_id) {
+        DefKind::Mod | DefKind::Enum | DefKind::Trait => tcx
+            .module_children(def_id)
+            .iter()
+            .filter(|item| item.ident.name == name)
+            .map(|child| child.res.expect_non_local())
+            .collect(),
+        DefKind::Impl => tcx
+            .associated_item_def_ids(def_id)
+            .iter()
+            .copied()
+            .filter(|assoc_def_id| tcx.item_name(*assoc_def_id) == name)
+            .map(|assoc_def_id| Res::Def(tcx.def_kind(assoc_def_id), assoc_def_id))
+            .collect(),
+        _ => Vec::new(),
+    }
+}
+
+fn local_item_children_by_name(tcx: TyCtxt<'_>, local_id: LocalDefId, name: Symbol) -> Vec<Res> {
+    let hir = tcx.hir();
+
+    let root_mod;
+    let item_kind = match hir.find_by_def_id(local_id) {
+        Some(Node::Crate(r#mod)) => {
+            root_mod = ItemKind::Mod(r#mod);
+            &root_mod
+        },
+        Some(Node::Item(item)) => &item.kind,
+        _ => return Vec::new(),
+    };
+
+    let res = |ident: Ident, owner_id: OwnerId| {
+        if ident.name == name {
+            let def_id = owner_id.to_def_id();
+            Some(Res::Def(tcx.def_kind(def_id), def_id))
+        } else {
+            None
         }
+    };
+
+    match item_kind {
+        ItemKind::Mod(r#mod) => r#mod
+            .item_ids
+            .iter()
+            .filter_map(|&item_id| res(hir.item(item_id).ident, item_id.def_id))
+            .collect(),
+        ItemKind::Impl(r#impl) => r#impl
+            .items
+            .iter()
+            .filter_map(|&ImplItemRef { ident, id, .. }| res(ident, id.def_id))
+            .collect(),
+        ItemKind::Trait(.., trait_item_refs) => trait_item_refs
+            .iter()
+            .filter_map(|&TraitItemRef { ident, id, .. }| res(ident, id.def_id))
+            .collect(),
+        _ => Vec::new(),
+    }
+}
+
+fn item_children_by_name(tcx: TyCtxt<'_>, def_id: DefId, name: Symbol) -> Vec<Res> {
+    if let Some(local_id) = def_id.as_local() {
+        local_item_children_by_name(tcx, local_id, name)
+    } else {
+        non_local_item_children_by_name(tcx, def_id, name)
     }
+}
 
-    fn find_crate(tcx: TyCtxt<'_>, name: &str) -> Option<DefId> {
+/// Resolves a def path like `std::vec::Vec`.
+///
+/// Can return multiple resolutions when there are multiple versions of the same crate, e.g.
+/// `memchr::memchr` could return the functions from both memchr 1.0 and memchr 2.0.
+///
+/// Also returns multiple results when there are mulitple paths under the same name e.g. `std::vec`
+/// would have both a [`DefKind::Mod`] and [`DefKind::Macro`].
+///
+/// This function is expensive and should be used sparingly.
+pub fn def_path_res(cx: &LateContext<'_>, path: &[&str]) -> Vec<Res> {
+    fn find_crates(tcx: TyCtxt<'_>, name: Symbol) -> impl Iterator<Item = DefId> + '_ {
         tcx.crates(())
             .iter()
             .copied()
-            .find(|&num| tcx.crate_name(num).as_str() == name)
+            .filter(move |&num| tcx.crate_name(num) == name)
             .map(CrateNum::as_def_id)
     }
 
-    let (base, path) = match *path {
+    let tcx = cx.tcx;
+
+    let (base, mut path) = match *path {
         [primitive] => {
-            return PrimTy::from_name(Symbol::intern(primitive)).map_or(Res::Err, Res::PrimTy);
-        },
-        [base, ref path @ ..] => {
-            let crate_name = cx.sess().opts.crate_name.as_deref();
-            if Some(base) == crate_name {
-                return def_path_res_local(cx, path);
-            }
-            (base, path)
+            return vec![PrimTy::from_name(Symbol::intern(primitive)).map_or(Res::Err, Res::PrimTy)];
         },
-        _ => return Res::Err,
+        [base, ref path @ ..] => (base, path),
+        _ => return Vec::new(),
     };
-    let tcx = cx.tcx;
-    let starts = find_primitive(tcx, base)
-        .chain(find_crate(tcx, base))
+
+    let base_sym = Symbol::intern(base);
+
+    let local_crate = if tcx.crate_name(LOCAL_CRATE) == base_sym {
+        Some(LOCAL_CRATE.as_def_id())
+    } else {
+        None
+    };
+
+    let starts = find_primitive_impls(tcx, base)
+        .chain(find_crates(tcx, base_sym))
+        .chain(local_crate)
         .map(|id| Res::Def(tcx.def_kind(id), id));
 
-    for first in starts {
-        let last = path
-            .iter()
-            .copied()
-            .enumerate()
-            // for each segment, find the child item
-            .try_fold(first, |res, (idx, segment)| {
-                let matches_ns = |res: Res| {
-                    // If at the last segment in the path, respect the namespace hint
-                    if idx == path.len() - 1 {
-                        match namespace_hint {
-                            Some(ns) => res.matches_ns(ns),
-                            None => true,
-                        }
-                    } else {
-                        res.matches_ns(Namespace::TypeNS)
-                    }
-                };
-
-                let def_id = res.def_id();
-                if let Some(item) = item_child_by_name(tcx, def_id, segment, matches_ns) {
-                    Some(item)
-                } else if matches!(res, Res::Def(DefKind::Enum | DefKind::Struct, _)) {
-                    // it is not a child item so check inherent impl items
-                    tcx.inherent_impls(def_id)
-                        .iter()
-                        .find_map(|&impl_def_id| item_child_by_name(tcx, impl_def_id, segment, matches_ns))
-                } else {
-                    None
-                }
-            });
+    let mut resolutions: Vec<Res> = starts.collect();
 
-        if let Some(last) = last {
-            return last;
-        }
+    while let [segment, rest @ ..] = path {
+        path = rest;
+        let segment = Symbol::intern(segment);
+
+        resolutions = resolutions
+            .into_iter()
+            .filter_map(|res| res.opt_def_id())
+            .flat_map(|def_id| {
+                // When the current def_id is e.g. `struct S`, check the impl items in
+                // `impl S { ... }`
+                let inherent_impl_children = tcx
+                    .inherent_impls(def_id)
+                    .iter()
+                    .flat_map(|&impl_def_id| item_children_by_name(tcx, impl_def_id, segment));
+
+                let direct_children = item_children_by_name(tcx, def_id, segment);
+
+                inherent_impl_children.chain(direct_children)
+            })
+            .collect();
     }
-    Res::Err
+
+    resolutions
 }
 
-fn def_path_res_local(cx: &LateContext<'_>, mut path: &[&str]) -> Res {
-    let map = cx.tcx.hir();
-    let mut ids = map.root_module().item_ids;
-    while let Some(&segment) = path.first() {
-        let mut next_ids = None;
-        for i in ids {
-            if let Some(Node::Item(hir::Item {
-                ident,
-                kind,
-                def_id: item_def_id,
-                ..
-            })) = map.find(i.hir_id())
-            {
-                if ident.name.as_str() == segment {
-                    path = &path[1..];
-                    if path.is_empty() {
-                        let def_id = item_def_id.to_def_id();
-                        return Res::Def(cx.tcx.def_kind(def_id), def_id);
-                    }
-                    if let ItemKind::Mod(m) = kind {
-                        next_ids = Some(m.item_ids);
-                    };
-                    break;
-                }
-            }
-        }
-        if let Some(next_ids) = next_ids {
-            ids = next_ids;
-        } else {
-            break;
-        }
-    }
-    Res::Err
+/// Resolves a def path like `std::vec::Vec` to its [`DefId`]s, see [`def_path_res`].
+pub fn def_path_def_ids(cx: &LateContext<'_>, path: &[&str]) -> impl Iterator<Item = DefId> {
+    def_path_res(cx, path).into_iter().filter_map(|res| res.opt_def_id())
 }
 
 /// Convenience function to get the `DefId` of a trait by path.
@@ -691,10 +702,10 @@ fn def_path_res_local(cx: &LateContext<'_>, mut path: &[&str]) -> Res {
 ///
 /// This function is expensive and should be used sparingly.
 pub fn get_trait_def_id(cx: &LateContext<'_>, path: &[&str]) -> Option<DefId> {
-    match def_path_res(cx, path, Some(Namespace::TypeNS)) {
+    def_path_res(cx, path).into_iter().find_map(|res| match res {
         Res::Def(DefKind::Trait | DefKind::TraitAlias, trait_id) => Some(trait_id),
         _ => None,
-    }
+    })
 }
 
 /// Gets the `hir::TraitRef` of the trait the given method is implemented for.
diff --git a/tests/ui-toml/await_holding_invalid_type/await_holding_invalid_type.stderr b/tests/ui-toml/await_holding_invalid_type/await_holding_invalid_type.stderr
index 4c75998437f..825aa1487e7 100644
--- a/tests/ui-toml/await_holding_invalid_type/await_holding_invalid_type.stderr
+++ b/tests/ui-toml/await_holding_invalid_type/await_holding_invalid_type.stderr
@@ -4,7 +4,7 @@ error: `std::string::String` may not be held across an `await` point per `clippy
 LL |     let _x = String::from("hello");
    |         ^^
    |
-   = note: strings are bad
+   = note: strings are bad (from clippy.toml)
    = note: `-D clippy::await-holding-invalid-type` implied by `-D warnings`
 
 error: `std::net::Ipv4Addr` may not be held across an `await` point per `clippy.toml`
@@ -19,7 +19,7 @@ error: `std::string::String` may not be held across an `await` point per `clippy
 LL |         let _x = String::from("hi!");
    |             ^^
    |
-   = note: strings are bad
+   = note: strings are bad (from clippy.toml)
 
 error: aborting due to 3 previous errors
 
diff --git a/tests/ui-toml/toml_disallowed_methods/clippy.toml b/tests/ui-toml/toml_disallowed_methods/clippy.toml
index 28774db625b..41dbd506847 100644
--- a/tests/ui-toml/toml_disallowed_methods/clippy.toml
+++ b/tests/ui-toml/toml_disallowed_methods/clippy.toml
@@ -8,4 +8,10 @@ disallowed-methods = [
     { path = "regex::Regex::is_match", reason = "no matching allowed" },
     # can use an inline table but omit reason
     { path = "regex::Regex::new" },
+    # local paths
+    "conf_disallowed_methods::local_fn",
+    "conf_disallowed_methods::local_mod::f",
+    "conf_disallowed_methods::Struct::method",
+    "conf_disallowed_methods::Trait::provided_method",
+    "conf_disallowed_methods::Trait::implemented_method",
 ]
diff --git a/tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.rs b/tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.rs
index b483f160028..2f3160c8338 100644
--- a/tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.rs
+++ b/tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.rs
@@ -1,3 +1,5 @@
+// compile-flags: --crate-name conf_disallowed_methods
+
 #![warn(clippy::disallowed_methods)]
 
 extern crate futures;
@@ -6,6 +8,27 @@ extern crate regex;
 use futures::stream::{empty, select_all};
 use regex::Regex;
 
+fn local_fn() {}
+
+struct Struct;
+
+impl Struct {
+    fn method(&self) {}
+}
+
+trait Trait {
+    fn provided_method(&self) {}
+    fn implemented_method(&self);
+}
+
+impl Trait for Struct {
+    fn implemented_method(&self) {}
+}
+
+mod local_mod {
+    pub fn f() {}
+}
+
 fn main() {
     let re = Regex::new(r"ab.*c").unwrap();
     re.is_match("abc");
@@ -26,4 +49,11 @@ fn main() {
 
     // resolve ambiguity between `futures::stream::select_all` the module and the function
     let same_name_as_module = select_all(vec![empty::<()>()]);
+
+    local_fn();
+    local_mod::f();
+    let s = Struct;
+    s.method();
+    s.provided_method();
+    s.implemented_method();
 }
diff --git a/tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.stderr b/tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.stderr
index 6d78c32e127..148d1cae51f 100644
--- a/tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.stderr
+++ b/tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.stderr
@@ -1,5 +1,5 @@
 error: use of a disallowed method `regex::Regex::new`
-  --> $DIR/conf_disallowed_methods.rs:10:14
+  --> $DIR/conf_disallowed_methods.rs:33:14
    |
 LL |     let re = Regex::new(r"ab.*c").unwrap();
    |              ^^^^^^^^^^^^^^^^^^^^
@@ -7,7 +7,7 @@ LL |     let re = Regex::new(r"ab.*c").unwrap();
    = note: `-D clippy::disallowed-methods` implied by `-D warnings`
 
 error: use of a disallowed method `regex::Regex::is_match`
-  --> $DIR/conf_disallowed_methods.rs:11:5
+  --> $DIR/conf_disallowed_methods.rs:34:5
    |
 LL |     re.is_match("abc");
    |     ^^^^^^^^^^^^^^^^^^
@@ -15,46 +15,76 @@ LL |     re.is_match("abc");
    = note: no matching allowed (from clippy.toml)
 
 error: use of a disallowed method `std::iter::Iterator::sum`
-  --> $DIR/conf_disallowed_methods.rs:14:5
+  --> $DIR/conf_disallowed_methods.rs:37:5
    |
 LL |     a.iter().sum::<i32>();
    |     ^^^^^^^^^^^^^^^^^^^^^
 
 error: use of a disallowed method `slice::sort_unstable`
-  --> $DIR/conf_disallowed_methods.rs:16:5
+  --> $DIR/conf_disallowed_methods.rs:39:5
    |
 LL |     a.sort_unstable();
    |     ^^^^^^^^^^^^^^^^^
 
 error: use of a disallowed method `f32::clamp`
-  --> $DIR/conf_disallowed_methods.rs:18:13
+  --> $DIR/conf_disallowed_methods.rs:41:13
    |
 LL |     let _ = 2.0f32.clamp(3.0f32, 4.0f32);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: use of a disallowed method `regex::Regex::new`
-  --> $DIR/conf_disallowed_methods.rs:21:61
+  --> $DIR/conf_disallowed_methods.rs:44:61
    |
 LL |     let indirect: fn(&str) -> Result<Regex, regex::Error> = Regex::new;
    |                                                             ^^^^^^^^^^
 
 error: use of a disallowed method `f32::clamp`
-  --> $DIR/conf_disallowed_methods.rs:24:28
+  --> $DIR/conf_disallowed_methods.rs:47:28
    |
 LL |     let in_call = Box::new(f32::clamp);
    |                            ^^^^^^^^^^
 
 error: use of a disallowed method `regex::Regex::new`
-  --> $DIR/conf_disallowed_methods.rs:25:53
+  --> $DIR/conf_disallowed_methods.rs:48:53
    |
 LL |     let in_method_call = ["^", "$"].into_iter().map(Regex::new);
    |                                                     ^^^^^^^^^^
 
 error: use of a disallowed method `futures::stream::select_all`
-  --> $DIR/conf_disallowed_methods.rs:28:31
+  --> $DIR/conf_disallowed_methods.rs:51:31
    |
 LL |     let same_name_as_module = select_all(vec![empty::<()>()]);
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 9 previous errors
+error: use of a disallowed method `conf_disallowed_methods::local_fn`
+  --> $DIR/conf_disallowed_methods.rs:53:5
+   |
+LL |     local_fn();
+   |     ^^^^^^^^^^
+
+error: use of a disallowed method `conf_disallowed_methods::local_mod::f`
+  --> $DIR/conf_disallowed_methods.rs:54:5
+   |
+LL |     local_mod::f();
+   |     ^^^^^^^^^^^^^^
+
+error: use of a disallowed method `conf_disallowed_methods::Struct::method`
+  --> $DIR/conf_disallowed_methods.rs:56:5
+   |
+LL |     s.method();
+   |     ^^^^^^^^^^
+
+error: use of a disallowed method `conf_disallowed_methods::Trait::provided_method`
+  --> $DIR/conf_disallowed_methods.rs:57:5
+   |
+LL |     s.provided_method();
+   |     ^^^^^^^^^^^^^^^^^^^
+
+error: use of a disallowed method `conf_disallowed_methods::Trait::implemented_method`
+  --> $DIR/conf_disallowed_methods.rs:58:5
+   |
+LL |     s.implemented_method();
+   |     ^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 14 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 93dab8fea2a8cd01faca7dc729a4005a3394ae27 Mon Sep 17 00:00:00 2001
From: Steven Casper <sebastiancasper3@gmail.com>
Date: Fri, 4 Nov 2022 20:59:31 -0700
Subject: More backticks

---
 clippy_lints/src/let_underscore.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/let_underscore.rs b/clippy_lints/src/let_underscore.rs
index 8da7b8c3543..61f87b91400 100644
--- a/clippy_lints/src/let_underscore.rs
+++ b/clippy_lints/src/let_underscore.rs
@@ -114,7 +114,7 @@ impl<'tcx> LateLintPass<'tcx> for LetUnderscore {
                     cx,
                     LET_UNDERSCORE_LOCK,
                     local.span,
-                    "non-binding let on a synchronization lock",
+                    "non-binding `let` on a synchronization lock",
                     None,
                     "consider using an underscore-prefixed named \
                             binding or dropping explicitly with `std::mem::drop`",
@@ -125,7 +125,7 @@ impl<'tcx> LateLintPass<'tcx> for LetUnderscore {
                     cx,
                     LET_UNDERSCORE_FUTURE,
                     local.span,
-                    "non-binding let on a future",
+                    "non-binding `let` on a future",
                     None,
                     "consider awaiting the future or dropping explicitly with `std::mem::drop`"
                 );
@@ -134,7 +134,7 @@ impl<'tcx> LateLintPass<'tcx> for LetUnderscore {
                     cx,
                     LET_UNDERSCORE_MUST_USE,
                     local.span,
-                    "non-binding let on an expression with `#[must_use]` type",
+                    "non-binding `let` on an expression with `#[must_use]` type",
                     None,
                     "consider explicitly using expression value",
                 );
@@ -143,7 +143,7 @@ impl<'tcx> LateLintPass<'tcx> for LetUnderscore {
                     cx,
                     LET_UNDERSCORE_MUST_USE,
                     local.span,
-                    "non-binding let on a result of a `#[must_use]` function",
+                    "non-binding `let` on a result of a `#[must_use]` function",
                     None,
                     "consider explicitly using function result",
                 );
-- 
cgit 1.4.1-3-g733a5


From e4540ad65fa14ceebd5145ab771fe4918d170bf1 Mon Sep 17 00:00:00 2001
From: koka <koka.code@gmail.com>
Date: Mon, 24 Oct 2022 23:49:59 +0900
Subject: feat: implement manual_is_ascii_check lint

modify

fix: allow unused in test code

fix: types in doc comment

Update clippy_lints/src/manual_is_ascii_check.rs

Co-authored-by: Fridtjof Stoldt <xFrednet@gmail.com>

Update clippy_lints/src/manual_is_ascii_check.rs

Co-authored-by: Fridtjof Stoldt <xFrednet@gmail.com>

Update clippy_lints/src/manual_is_ascii_check.rs

Co-authored-by: Fridtjof Stoldt <xFrednet@gmail.com>

fix ui test result

fix: unnecessary format!

chore: apply feedbacks

* check msrvs also for const fn
* check applicability manually
* modify documents
---
 CHANGELOG.md                              |   1 +
 clippy_lints/src/declared_lints.rs        |   1 +
 clippy_lints/src/lib.rs                   |   2 +
 clippy_lints/src/manual_is_ascii_check.rs | 157 ++++++++++++++++++++++++++++++
 clippy_utils/src/msrvs.rs                 |   2 +-
 tests/ui/manual_is_ascii_check.fixed      |  45 +++++++++
 tests/ui/manual_is_ascii_check.rs         |  45 +++++++++
 tests/ui/manual_is_ascii_check.stderr     |  70 +++++++++++++
 8 files changed, 322 insertions(+), 1 deletion(-)
 create mode 100644 clippy_lints/src/manual_is_ascii_check.rs
 create mode 100644 tests/ui/manual_is_ascii_check.fixed
 create mode 100644 tests/ui/manual_is_ascii_check.rs
 create mode 100644 tests/ui/manual_is_ascii_check.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 35864e85673..d75ef52e0ee 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3997,6 +3997,7 @@ Released 2018-09-13
 [`manual_find_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_find_map
 [`manual_flatten`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_flatten
 [`manual_instant_elapsed`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_instant_elapsed
+[`manual_is_ascii_check`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_is_ascii_check
 [`manual_let_else`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_let_else
 [`manual_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_map
 [`manual_memcpy`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_memcpy
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index f4fc2bd3330..448b12f1b0a 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -251,6 +251,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::manual_bits::MANUAL_BITS_INFO,
     crate::manual_clamp::MANUAL_CLAMP_INFO,
     crate::manual_instant_elapsed::MANUAL_INSTANT_ELAPSED_INFO,
+    crate::manual_is_ascii_check::MANUAL_IS_ASCII_CHECK_INFO,
     crate::manual_let_else::MANUAL_LET_ELSE_INFO,
     crate::manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE_INFO,
     crate::manual_rem_euclid::MANUAL_REM_EUCLID_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 197d8f2dc08..fe05f2a13f9 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -173,6 +173,7 @@ mod manual_async_fn;
 mod manual_bits;
 mod manual_clamp;
 mod manual_instant_elapsed;
+mod manual_is_ascii_check;
 mod manual_let_else;
 mod manual_non_exhaustive;
 mod manual_rem_euclid;
@@ -918,6 +919,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(missing_trait_methods::MissingTraitMethods));
     store.register_late_pass(|_| Box::new(from_raw_with_void_ptr::FromRawWithVoidPtr));
     store.register_late_pass(|_| Box::new(suspicious_xor_used_as_pow::ConfusingXorAndPow));
+    store.register_late_pass(move |_| Box::new(manual_is_ascii_check::ManualIsAsciiCheck::new(msrv)));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/manual_is_ascii_check.rs b/clippy_lints/src/manual_is_ascii_check.rs
new file mode 100644
index 00000000000..3a6b693f766
--- /dev/null
+++ b/clippy_lints/src/manual_is_ascii_check.rs
@@ -0,0 +1,157 @@
+use rustc_ast::LitKind::{Byte, Char};
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind, PatKind, RangeEnd};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_semver::RustcVersion;
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::{def_id::DefId, sym};
+
+use clippy_utils::{
+    diagnostics::span_lint_and_sugg, in_constant, macros::root_macro_call, meets_msrv, msrvs, source::snippet,
+};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Suggests to use dedicated built-in methods,
+    /// `is_ascii_(lowercase|uppercase|digit)` for checking on corresponding ascii range
+    ///
+    /// ### Why is this bad?
+    /// Using the built-in functions is more readable and makes it
+    /// clear that it's not a specific subset of characters, but all
+    /// ASCII (lowercase|uppercase|digit) characters.
+    /// ### Example
+    /// ```rust
+    /// fn main() {
+    ///     assert!(matches!('x', 'a'..='z'));
+    ///     assert!(matches!(b'X', b'A'..=b'Z'));
+    ///     assert!(matches!('2', '0'..='9'));
+    ///     assert!(matches!('x', 'A'..='Z' | 'a'..='z'));
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// fn main() {
+    ///     assert!('x'.is_ascii_lowercase());
+    ///     assert!(b'X'.is_ascii_uppercase());
+    ///     assert!('2'.is_ascii_digit());
+    ///     assert!('x'.is_ascii_alphabetic());
+    /// }
+    /// ```
+    #[clippy::version = "1.66.0"]
+    pub MANUAL_IS_ASCII_CHECK,
+    style,
+    "use dedicated method to check ascii range"
+}
+impl_lint_pass!(ManualIsAsciiCheck => [MANUAL_IS_ASCII_CHECK]);
+
+pub struct ManualIsAsciiCheck {
+    msrv: Option<RustcVersion>,
+}
+
+impl ManualIsAsciiCheck {
+    #[must_use]
+    pub fn new(msrv: Option<RustcVersion>) -> Self {
+        Self { msrv }
+    }
+}
+
+#[derive(Debug, PartialEq)]
+enum CharRange {
+    /// 'a'..='z' | b'a'..=b'z'
+    LowerChar,
+    /// 'A'..='Z' | b'A'..=b'Z'
+    UpperChar,
+    /// AsciiLower | AsciiUpper
+    FullChar,
+    /// '0..=9'
+    Digit,
+    Otherwise,
+}
+
+impl<'tcx> LateLintPass<'tcx> for ManualIsAsciiCheck {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        if !meets_msrv(self.msrv, msrvs::IS_ASCII_DIGIT) {
+            return;
+        }
+
+        if in_constant(cx, expr.hir_id) && !meets_msrv(self.msrv, msrvs::IS_ASCII_DIGIT_CONST) {
+            return;
+        }
+
+        let Some(macro_call) = root_macro_call(expr.span) else { return };
+
+        if is_matches_macro(cx, macro_call.def_id) {
+            if let ExprKind::Match(recv, [arm, ..], _) = expr.kind {
+                let range = check_pat(&arm.pat.kind);
+
+                if let Some(sugg) = match range {
+                    CharRange::UpperChar => Some("is_ascii_uppercase"),
+                    CharRange::LowerChar => Some("is_ascii_lowercase"),
+                    CharRange::FullChar => Some("is_ascii_alphabetic"),
+                    CharRange::Digit => Some("is_ascii_digit"),
+                    CharRange::Otherwise => None,
+                } {
+                    let mut applicability = Applicability::MaybeIncorrect;
+                    let default_snip = "..";
+                    // `snippet_with_applicability` may set applicability to `MaybeIncorrect` for
+                    // macro span, so we check applicability manually by comaring `recv` is not default.
+                    let recv = snippet(cx, recv.span, default_snip);
+
+                    if recv != default_snip {
+                        applicability = Applicability::MachineApplicable;
+                    }
+
+                    span_lint_and_sugg(
+                        cx,
+                        MANUAL_IS_ASCII_CHECK,
+                        macro_call.span,
+                        "manual check for common ascii range",
+                        "try",
+                        format!("{recv}.{sugg}()"),
+                        applicability,
+                    );
+                }
+            }
+        }
+    }
+
+    extract_msrv_attr!(LateContext);
+}
+
+fn check_pat(pat_kind: &PatKind<'_>) -> CharRange {
+    match pat_kind {
+        PatKind::Or(pats) => {
+            let ranges = pats.iter().map(|p| check_pat(&p.kind)).collect::<Vec<_>>();
+
+            if ranges.len() == 2 && ranges.contains(&CharRange::UpperChar) && ranges.contains(&CharRange::LowerChar) {
+                CharRange::FullChar
+            } else {
+                CharRange::Otherwise
+            }
+        },
+        PatKind::Range(Some(start), Some(end), kind) if *kind == RangeEnd::Included => check_range(start, end),
+        _ => CharRange::Otherwise,
+    }
+}
+
+fn check_range(start: &Expr<'_>, end: &Expr<'_>) -> CharRange {
+    if let ExprKind::Lit(start_lit) = &start.kind
+        && let ExprKind::Lit(end_lit) = &end.kind {
+        match (&start_lit.node, &end_lit.node) {
+            (Char('a'), Char('z')) | (Byte(b'a'), Byte(b'z')) => CharRange::LowerChar,
+            (Char('A'), Char('Z')) | (Byte(b'A'), Byte(b'Z')) => CharRange::UpperChar,
+            (Char('0'), Char('9')) | (Byte(b'0'), Byte(b'9')) => CharRange::Digit,
+            _ => CharRange::Otherwise,
+        }
+    } else {
+        CharRange::Otherwise
+    }
+}
+
+fn is_matches_macro(cx: &LateContext<'_>, macro_def_id: DefId) -> bool {
+    if let Some(name) = cx.tcx.get_diagnostic_name(macro_def_id) {
+        return sym::matches_macro == name;
+    }
+
+    false
+}
diff --git a/clippy_utils/src/msrvs.rs b/clippy_utils/src/msrvs.rs
index 9a672e2ddfd..79b19e6fb3e 100644
--- a/clippy_utils/src/msrvs.rs
+++ b/clippy_utils/src/msrvs.rs
@@ -19,7 +19,7 @@ msrv_aliases! {
     1,52,0 { STR_SPLIT_ONCE, REM_EUCLID_CONST }
     1,51,0 { BORROW_AS_PTR, SEEK_FROM_CURRENT, UNSIGNED_ABS }
     1,50,0 { BOOL_THEN, CLAMP }
-    1,47,0 { TAU }
+    1,47,0 { TAU, IS_ASCII_DIGIT_CONST }
     1,46,0 { CONST_IF_MATCH }
     1,45,0 { STR_STRIP_PREFIX }
     1,43,0 { LOG2_10, LOG10_2 }
diff --git a/tests/ui/manual_is_ascii_check.fixed b/tests/ui/manual_is_ascii_check.fixed
new file mode 100644
index 00000000000..765bb785994
--- /dev/null
+++ b/tests/ui/manual_is_ascii_check.fixed
@@ -0,0 +1,45 @@
+// run-rustfix
+
+#![feature(custom_inner_attributes)]
+#![allow(unused, dead_code)]
+#![warn(clippy::manual_is_ascii_check)]
+
+fn main() {
+    assert!('x'.is_ascii_lowercase());
+    assert!('X'.is_ascii_uppercase());
+    assert!(b'x'.is_ascii_lowercase());
+    assert!(b'X'.is_ascii_uppercase());
+
+    let num = '2';
+    assert!(num.is_ascii_digit());
+    assert!(b'1'.is_ascii_digit());
+    assert!('x'.is_ascii_alphabetic());
+
+    assert!(matches!('x', 'A'..='Z' | 'a'..='z' | '_'));
+}
+
+fn msrv_1_23() {
+    #![clippy::msrv = "1.23"]
+
+    assert!(matches!(b'1', b'0'..=b'9'));
+    assert!(matches!('X', 'A'..='Z'));
+    assert!(matches!('x', 'A'..='Z' | 'a'..='z'));
+}
+
+fn msrv_1_24() {
+    #![clippy::msrv = "1.24"]
+
+    assert!(b'1'.is_ascii_digit());
+    assert!('X'.is_ascii_uppercase());
+    assert!('x'.is_ascii_alphabetic());
+}
+
+fn msrv_1_46() {
+    #![clippy::msrv = "1.46"]
+    const FOO: bool = matches!('x', '0'..='9');
+}
+
+fn msrv_1_47() {
+    #![clippy::msrv = "1.47"]
+    const FOO: bool = 'x'.is_ascii_digit();
+}
diff --git a/tests/ui/manual_is_ascii_check.rs b/tests/ui/manual_is_ascii_check.rs
new file mode 100644
index 00000000000..be133161041
--- /dev/null
+++ b/tests/ui/manual_is_ascii_check.rs
@@ -0,0 +1,45 @@
+// run-rustfix
+
+#![feature(custom_inner_attributes)]
+#![allow(unused, dead_code)]
+#![warn(clippy::manual_is_ascii_check)]
+
+fn main() {
+    assert!(matches!('x', 'a'..='z'));
+    assert!(matches!('X', 'A'..='Z'));
+    assert!(matches!(b'x', b'a'..=b'z'));
+    assert!(matches!(b'X', b'A'..=b'Z'));
+
+    let num = '2';
+    assert!(matches!(num, '0'..='9'));
+    assert!(matches!(b'1', b'0'..=b'9'));
+    assert!(matches!('x', 'A'..='Z' | 'a'..='z'));
+
+    assert!(matches!('x', 'A'..='Z' | 'a'..='z' | '_'));
+}
+
+fn msrv_1_23() {
+    #![clippy::msrv = "1.23"]
+
+    assert!(matches!(b'1', b'0'..=b'9'));
+    assert!(matches!('X', 'A'..='Z'));
+    assert!(matches!('x', 'A'..='Z' | 'a'..='z'));
+}
+
+fn msrv_1_24() {
+    #![clippy::msrv = "1.24"]
+
+    assert!(matches!(b'1', b'0'..=b'9'));
+    assert!(matches!('X', 'A'..='Z'));
+    assert!(matches!('x', 'A'..='Z' | 'a'..='z'));
+}
+
+fn msrv_1_46() {
+    #![clippy::msrv = "1.46"]
+    const FOO: bool = matches!('x', '0'..='9');
+}
+
+fn msrv_1_47() {
+    #![clippy::msrv = "1.47"]
+    const FOO: bool = matches!('x', '0'..='9');
+}
diff --git a/tests/ui/manual_is_ascii_check.stderr b/tests/ui/manual_is_ascii_check.stderr
new file mode 100644
index 00000000000..c0a9d4db1a1
--- /dev/null
+++ b/tests/ui/manual_is_ascii_check.stderr
@@ -0,0 +1,70 @@
+error: manual check for common ascii range
+  --> $DIR/manual_is_ascii_check.rs:8:13
+   |
+LL |     assert!(matches!('x', 'a'..='z'));
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `'x'.is_ascii_lowercase()`
+   |
+   = note: `-D clippy::manual-is-ascii-check` implied by `-D warnings`
+
+error: manual check for common ascii range
+  --> $DIR/manual_is_ascii_check.rs:9:13
+   |
+LL |     assert!(matches!('X', 'A'..='Z'));
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `'X'.is_ascii_uppercase()`
+
+error: manual check for common ascii range
+  --> $DIR/manual_is_ascii_check.rs:10:13
+   |
+LL |     assert!(matches!(b'x', b'a'..=b'z'));
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `b'x'.is_ascii_lowercase()`
+
+error: manual check for common ascii range
+  --> $DIR/manual_is_ascii_check.rs:11:13
+   |
+LL |     assert!(matches!(b'X', b'A'..=b'Z'));
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `b'X'.is_ascii_uppercase()`
+
+error: manual check for common ascii range
+  --> $DIR/manual_is_ascii_check.rs:14:13
+   |
+LL |     assert!(matches!(num, '0'..='9'));
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `num.is_ascii_digit()`
+
+error: manual check for common ascii range
+  --> $DIR/manual_is_ascii_check.rs:15:13
+   |
+LL |     assert!(matches!(b'1', b'0'..=b'9'));
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `b'1'.is_ascii_digit()`
+
+error: manual check for common ascii range
+  --> $DIR/manual_is_ascii_check.rs:16:13
+   |
+LL |     assert!(matches!('x', 'A'..='Z' | 'a'..='z'));
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `'x'.is_ascii_alphabetic()`
+
+error: manual check for common ascii range
+  --> $DIR/manual_is_ascii_check.rs:32:13
+   |
+LL |     assert!(matches!(b'1', b'0'..=b'9'));
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `b'1'.is_ascii_digit()`
+
+error: manual check for common ascii range
+  --> $DIR/manual_is_ascii_check.rs:33:13
+   |
+LL |     assert!(matches!('X', 'A'..='Z'));
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `'X'.is_ascii_uppercase()`
+
+error: manual check for common ascii range
+  --> $DIR/manual_is_ascii_check.rs:34:13
+   |
+LL |     assert!(matches!('x', 'A'..='Z' | 'a'..='z'));
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `'x'.is_ascii_alphabetic()`
+
+error: manual check for common ascii range
+  --> $DIR/manual_is_ascii_check.rs:44:23
+   |
+LL |     const FOO: bool = matches!('x', '0'..='9');
+   |                       ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `'x'.is_ascii_digit()`
+
+error: aborting due to 11 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From b0dcb862c60c87c55f4e34c2ecce8914ffe3c4c7 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Fri, 22 Apr 2022 18:49:15 -0400
Subject: Move `needless_collect` into the `methods` lint pass

---
 clippy_lints/src/declared_lints.rs           |   2 +-
 clippy_lints/src/loops/mod.rs                |  26 --
 clippy_lints/src/loops/needless_collect.rs   | 401 ---------------------------
 clippy_lints/src/methods/mod.rs              |  26 ++
 clippy_lints/src/methods/needless_collect.rs | 401 +++++++++++++++++++++++++++
 5 files changed, 428 insertions(+), 428 deletions(-)
 delete mode 100644 clippy_lints/src/loops/needless_collect.rs
 create mode 100644 clippy_lints/src/methods/needless_collect.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 747636b7ec3..e9094ca3a09 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -237,7 +237,6 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::loops::MANUAL_MEMCPY_INFO,
     crate::loops::MISSING_SPIN_LOOP_INFO,
     crate::loops::MUT_RANGE_BOUND_INFO,
-    crate::loops::NEEDLESS_COLLECT_INFO,
     crate::loops::NEEDLESS_RANGE_LOOP_INFO,
     crate::loops::NEVER_LOOP_INFO,
     crate::loops::SAME_ITEM_PUSH_INFO,
@@ -346,6 +345,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::methods::MAP_UNWRAP_OR_INFO,
     crate::methods::MUT_MUTEX_LOCK_INFO,
     crate::methods::NAIVE_BYTECOUNT_INFO,
+    crate::methods::NEEDLESS_COLLECT_INFO,
     crate::methods::NEEDLESS_OPTION_AS_DEREF_INFO,
     crate::methods::NEEDLESS_OPTION_TAKE_INFO,
     crate::methods::NEEDLESS_SPLITN_INFO,
diff --git a/clippy_lints/src/loops/mod.rs b/clippy_lints/src/loops/mod.rs
index 821fe173023..8e52cac4323 100644
--- a/clippy_lints/src/loops/mod.rs
+++ b/clippy_lints/src/loops/mod.rs
@@ -9,7 +9,6 @@ mod manual_flatten;
 mod manual_memcpy;
 mod missing_spin_loop;
 mod mut_range_bound;
-mod needless_collect;
 mod needless_range_loop;
 mod never_loop;
 mod same_item_push;
@@ -205,28 +204,6 @@ declare_clippy_lint! {
     "`loop { if let { ... } else break }`, which can be written as a `while let` loop"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for functions collecting an iterator when collect
-    /// is not needed.
-    ///
-    /// ### Why is this bad?
-    /// `collect` causes the allocation of a new data structure,
-    /// when this allocation may not be needed.
-    ///
-    /// ### Example
-    /// ```rust
-    /// # let iterator = vec![1].into_iter();
-    /// let len = iterator.clone().collect::<Vec<_>>().len();
-    /// // should be
-    /// let len = iterator.count();
-    /// ```
-    #[clippy::version = "1.30.0"]
-    pub NEEDLESS_COLLECT,
-    nursery,
-    "collecting an iterator when collect is not needed"
-}
-
 declare_clippy_lint! {
     /// ### What it does
     /// Checks `for` loops over slices with an explicit counter
@@ -605,7 +582,6 @@ declare_lint_pass!(Loops => [
     EXPLICIT_INTO_ITER_LOOP,
     ITER_NEXT_LOOP,
     WHILE_LET_LOOP,
-    NEEDLESS_COLLECT,
     EXPLICIT_COUNTER_LOOP,
     EMPTY_LOOP,
     WHILE_LET_ON_ITERATOR,
@@ -667,8 +643,6 @@ impl<'tcx> LateLintPass<'tcx> for Loops {
             while_immutable_condition::check(cx, condition, body);
             missing_spin_loop::check(cx, condition, body);
         }
-
-        needless_collect::check(expr, cx);
     }
 }
 
diff --git a/clippy_lints/src/loops/needless_collect.rs b/clippy_lints/src/loops/needless_collect.rs
deleted file mode 100644
index 66f9e28596e..00000000000
--- a/clippy_lints/src/loops/needless_collect.rs
+++ /dev/null
@@ -1,401 +0,0 @@
-use super::NEEDLESS_COLLECT;
-use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_hir_and_then};
-use clippy_utils::higher;
-use clippy_utils::source::{snippet, snippet_with_applicability};
-use clippy_utils::sugg::Sugg;
-use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{can_move_expr_to_closure, is_trait_method, path_to_local, path_to_local_id, CaptureKind};
-use if_chain::if_chain;
-use rustc_data_structures::fx::FxHashMap;
-use rustc_errors::{Applicability, MultiSpan};
-use rustc_hir::intravisit::{walk_block, walk_expr, Visitor};
-use rustc_hir::{Block, Expr, ExprKind, HirId, HirIdSet, Local, Mutability, Node, PatKind, Stmt, StmtKind};
-use rustc_lint::LateContext;
-use rustc_middle::hir::nested_filter;
-use rustc_middle::ty::subst::GenericArgKind;
-use rustc_middle::ty::{self, Ty};
-use rustc_span::sym;
-use rustc_span::Span;
-
-const NEEDLESS_COLLECT_MSG: &str = "avoid using `collect()` when not needed";
-
-pub(super) fn check<'tcx>(expr: &'tcx Expr<'_>, cx: &LateContext<'tcx>) {
-    check_needless_collect_direct_usage(expr, cx);
-    check_needless_collect_indirect_usage(expr, cx);
-}
-fn check_needless_collect_direct_usage<'tcx>(expr: &'tcx Expr<'_>, cx: &LateContext<'tcx>) {
-    if_chain! {
-        if let ExprKind::MethodCall(method, receiver, args, _) = expr.kind;
-        if let ExprKind::MethodCall(chain_method, ..) = receiver.kind;
-        if chain_method.ident.name == sym!(collect) && is_trait_method(cx, receiver, sym::Iterator);
-        then {
-            let ty = cx.typeck_results().expr_ty(receiver);
-            let mut applicability = Applicability::MaybeIncorrect;
-            let is_empty_sugg = "next().is_none()".to_string();
-            let method_name = method.ident.name.as_str();
-            let sugg = if is_type_diagnostic_item(cx, ty, sym::Vec) ||
-                        is_type_diagnostic_item(cx, ty, sym::VecDeque) ||
-                        is_type_diagnostic_item(cx, ty, sym::LinkedList) ||
-                        is_type_diagnostic_item(cx, ty, sym::BinaryHeap) {
-                match method_name {
-                    "len" => "count()".to_string(),
-                    "is_empty" => is_empty_sugg,
-                    "contains" => {
-                        let contains_arg = snippet_with_applicability(cx, args[0].span, "??", &mut applicability);
-                        let (arg, pred) = contains_arg
-                            .strip_prefix('&')
-                            .map_or(("&x", &*contains_arg), |s| ("x", s));
-                        format!("any(|{arg}| x == {pred})")
-                    }
-                    _ => return,
-                }
-            }
-            else if is_type_diagnostic_item(cx, ty, sym::BTreeMap) ||
-                is_type_diagnostic_item(cx, ty, sym::HashMap) {
-                match method_name {
-                    "is_empty" => is_empty_sugg,
-                    _ => return,
-                }
-            }
-            else {
-                return;
-            };
-            span_lint_and_sugg(
-                cx,
-                NEEDLESS_COLLECT,
-                chain_method.ident.span.with_hi(expr.span.hi()),
-                NEEDLESS_COLLECT_MSG,
-                "replace with",
-                sugg,
-                applicability,
-            );
-        }
-    }
-}
-
-fn check_needless_collect_indirect_usage<'tcx>(expr: &'tcx Expr<'_>, cx: &LateContext<'tcx>) {
-    if let ExprKind::Block(block, _) = expr.kind {
-        for stmt in block.stmts {
-            if_chain! {
-                if let StmtKind::Local(local) = stmt.kind;
-                if let PatKind::Binding(_, id, ..) = local.pat.kind;
-                if let Some(init_expr) = local.init;
-                if let ExprKind::MethodCall(method_name, iter_source, [], ..) = init_expr.kind;
-                if method_name.ident.name == sym!(collect) && is_trait_method(cx, init_expr, sym::Iterator);
-                let ty = cx.typeck_results().expr_ty(init_expr);
-                if is_type_diagnostic_item(cx, ty, sym::Vec) ||
-                    is_type_diagnostic_item(cx, ty, sym::VecDeque) ||
-                    is_type_diagnostic_item(cx, ty, sym::BinaryHeap) ||
-                    is_type_diagnostic_item(cx, ty, sym::LinkedList);
-                let iter_ty = cx.typeck_results().expr_ty(iter_source);
-                if let Some(iter_calls) = detect_iter_and_into_iters(block, id, cx, get_captured_ids(cx, iter_ty));
-                if let [iter_call] = &*iter_calls;
-                then {
-                    let mut used_count_visitor = UsedCountVisitor {
-                        cx,
-                        id,
-                        count: 0,
-                    };
-                    walk_block(&mut used_count_visitor, block);
-                    if used_count_visitor.count > 1 {
-                        return;
-                    }
-
-                    // Suggest replacing iter_call with iter_replacement, and removing stmt
-                    let mut span = MultiSpan::from_span(method_name.ident.span);
-                    span.push_span_label(iter_call.span, "the iterator could be used here instead");
-                    span_lint_hir_and_then(
-                        cx,
-                        super::NEEDLESS_COLLECT,
-                        init_expr.hir_id,
-                        span,
-                        NEEDLESS_COLLECT_MSG,
-                        |diag| {
-                            let iter_replacement = format!("{}{}", Sugg::hir(cx, iter_source, ".."), iter_call.get_iter_method(cx));
-                            diag.multipart_suggestion(
-                                iter_call.get_suggestion_text(),
-                                vec![
-                                    (stmt.span, String::new()),
-                                    (iter_call.span, iter_replacement)
-                                ],
-                                Applicability::MaybeIncorrect,
-                            );
-                        },
-                    );
-                }
-            }
-        }
-    }
-}
-
-struct IterFunction {
-    func: IterFunctionKind,
-    span: Span,
-}
-impl IterFunction {
-    fn get_iter_method(&self, cx: &LateContext<'_>) -> String {
-        match &self.func {
-            IterFunctionKind::IntoIter => String::new(),
-            IterFunctionKind::Len => String::from(".count()"),
-            IterFunctionKind::IsEmpty => String::from(".next().is_none()"),
-            IterFunctionKind::Contains(span) => {
-                let s = snippet(cx, *span, "..");
-                if let Some(stripped) = s.strip_prefix('&') {
-                    format!(".any(|x| x == {stripped})")
-                } else {
-                    format!(".any(|x| x == *{s})")
-                }
-            },
-        }
-    }
-    fn get_suggestion_text(&self) -> &'static str {
-        match &self.func {
-            IterFunctionKind::IntoIter => {
-                "use the original Iterator instead of collecting it and then producing a new one"
-            },
-            IterFunctionKind::Len => {
-                "take the original Iterator's count instead of collecting it and finding the length"
-            },
-            IterFunctionKind::IsEmpty => {
-                "check if the original Iterator has anything instead of collecting it and seeing if it's empty"
-            },
-            IterFunctionKind::Contains(_) => {
-                "check if the original Iterator contains an element instead of collecting then checking"
-            },
-        }
-    }
-}
-enum IterFunctionKind {
-    IntoIter,
-    Len,
-    IsEmpty,
-    Contains(Span),
-}
-
-struct IterFunctionVisitor<'a, 'tcx> {
-    illegal_mutable_capture_ids: HirIdSet,
-    current_mutably_captured_ids: HirIdSet,
-    cx: &'a LateContext<'tcx>,
-    uses: Vec<Option<IterFunction>>,
-    hir_id_uses_map: FxHashMap<HirId, usize>,
-    current_statement_hir_id: Option<HirId>,
-    seen_other: bool,
-    target: HirId,
-}
-impl<'tcx> Visitor<'tcx> for IterFunctionVisitor<'_, 'tcx> {
-    fn visit_block(&mut self, block: &'tcx Block<'tcx>) {
-        for (expr, hir_id) in block.stmts.iter().filter_map(get_expr_and_hir_id_from_stmt) {
-            if check_loop_kind(expr).is_some() {
-                continue;
-            }
-            self.visit_block_expr(expr, hir_id);
-        }
-        if let Some(expr) = block.expr {
-            if let Some(loop_kind) = check_loop_kind(expr) {
-                if let LoopKind::Conditional(block_expr) = loop_kind {
-                    self.visit_block_expr(block_expr, None);
-                }
-            } else {
-                self.visit_block_expr(expr, None);
-            }
-        }
-    }
-
-    fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) {
-        // Check function calls on our collection
-        if let ExprKind::MethodCall(method_name, recv, [args @ ..], _) = &expr.kind {
-            if method_name.ident.name == sym!(collect) && is_trait_method(self.cx, expr, sym::Iterator) {
-                self.current_mutably_captured_ids = get_captured_ids(self.cx, self.cx.typeck_results().expr_ty(recv));
-                self.visit_expr(recv);
-                return;
-            }
-
-            if path_to_local_id(recv, self.target) {
-                if self
-                    .illegal_mutable_capture_ids
-                    .intersection(&self.current_mutably_captured_ids)
-                    .next()
-                    .is_none()
-                {
-                    if let Some(hir_id) = self.current_statement_hir_id {
-                        self.hir_id_uses_map.insert(hir_id, self.uses.len());
-                    }
-                    match method_name.ident.name.as_str() {
-                        "into_iter" => self.uses.push(Some(IterFunction {
-                            func: IterFunctionKind::IntoIter,
-                            span: expr.span,
-                        })),
-                        "len" => self.uses.push(Some(IterFunction {
-                            func: IterFunctionKind::Len,
-                            span: expr.span,
-                        })),
-                        "is_empty" => self.uses.push(Some(IterFunction {
-                            func: IterFunctionKind::IsEmpty,
-                            span: expr.span,
-                        })),
-                        "contains" => self.uses.push(Some(IterFunction {
-                            func: IterFunctionKind::Contains(args[0].span),
-                            span: expr.span,
-                        })),
-                        _ => {
-                            self.seen_other = true;
-                            if let Some(hir_id) = self.current_statement_hir_id {
-                                self.hir_id_uses_map.remove(&hir_id);
-                            }
-                        },
-                    }
-                }
-                return;
-            }
-
-            if let Some(hir_id) = path_to_local(recv) {
-                if let Some(index) = self.hir_id_uses_map.remove(&hir_id) {
-                    if self
-                        .illegal_mutable_capture_ids
-                        .intersection(&self.current_mutably_captured_ids)
-                        .next()
-                        .is_none()
-                    {
-                        if let Some(hir_id) = self.current_statement_hir_id {
-                            self.hir_id_uses_map.insert(hir_id, index);
-                        }
-                    } else {
-                        self.uses[index] = None;
-                    }
-                }
-            }
-        }
-        // Check if the collection is used for anything else
-        if path_to_local_id(expr, self.target) {
-            self.seen_other = true;
-        } else {
-            walk_expr(self, expr);
-        }
-    }
-}
-
-enum LoopKind<'tcx> {
-    Conditional(&'tcx Expr<'tcx>),
-    Loop,
-}
-
-fn check_loop_kind<'tcx>(expr: &Expr<'tcx>) -> Option<LoopKind<'tcx>> {
-    if let Some(higher::WhileLet { let_expr, .. }) = higher::WhileLet::hir(expr) {
-        return Some(LoopKind::Conditional(let_expr));
-    }
-    if let Some(higher::While { condition, .. }) = higher::While::hir(expr) {
-        return Some(LoopKind::Conditional(condition));
-    }
-    if let Some(higher::ForLoop { arg, .. }) = higher::ForLoop::hir(expr) {
-        return Some(LoopKind::Conditional(arg));
-    }
-    if let ExprKind::Loop { .. } = expr.kind {
-        return Some(LoopKind::Loop);
-    }
-
-    None
-}
-
-impl<'tcx> IterFunctionVisitor<'_, 'tcx> {
-    fn visit_block_expr(&mut self, expr: &'tcx Expr<'tcx>, hir_id: Option<HirId>) {
-        self.current_statement_hir_id = hir_id;
-        self.current_mutably_captured_ids = get_captured_ids(self.cx, self.cx.typeck_results().expr_ty(expr));
-        self.visit_expr(expr);
-    }
-}
-
-fn get_expr_and_hir_id_from_stmt<'v>(stmt: &'v Stmt<'v>) -> Option<(&'v Expr<'v>, Option<HirId>)> {
-    match stmt.kind {
-        StmtKind::Expr(expr) | StmtKind::Semi(expr) => Some((expr, None)),
-        StmtKind::Item(..) => None,
-        StmtKind::Local(Local { init, pat, .. }) => {
-            if let PatKind::Binding(_, hir_id, ..) = pat.kind {
-                init.map(|init_expr| (init_expr, Some(hir_id)))
-            } else {
-                init.map(|init_expr| (init_expr, None))
-            }
-        },
-    }
-}
-
-struct UsedCountVisitor<'a, 'tcx> {
-    cx: &'a LateContext<'tcx>,
-    id: HirId,
-    count: usize,
-}
-
-impl<'a, 'tcx> Visitor<'tcx> for UsedCountVisitor<'a, 'tcx> {
-    type NestedFilter = nested_filter::OnlyBodies;
-
-    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
-        if path_to_local_id(expr, self.id) {
-            self.count += 1;
-        } else {
-            walk_expr(self, expr);
-        }
-    }
-
-    fn nested_visit_map(&mut self) -> Self::Map {
-        self.cx.tcx.hir()
-    }
-}
-
-/// Detect the occurrences of calls to `iter` or `into_iter` for the
-/// given identifier
-fn detect_iter_and_into_iters<'tcx: 'a, 'a>(
-    block: &'tcx Block<'tcx>,
-    id: HirId,
-    cx: &'a LateContext<'tcx>,
-    captured_ids: HirIdSet,
-) -> Option<Vec<IterFunction>> {
-    let mut visitor = IterFunctionVisitor {
-        uses: Vec::new(),
-        target: id,
-        seen_other: false,
-        cx,
-        current_mutably_captured_ids: HirIdSet::default(),
-        illegal_mutable_capture_ids: captured_ids,
-        hir_id_uses_map: FxHashMap::default(),
-        current_statement_hir_id: None,
-    };
-    visitor.visit_block(block);
-    if visitor.seen_other {
-        None
-    } else {
-        Some(visitor.uses.into_iter().flatten().collect())
-    }
-}
-
-fn get_captured_ids(cx: &LateContext<'_>, ty: Ty<'_>) -> HirIdSet {
-    fn get_captured_ids_recursive(cx: &LateContext<'_>, ty: Ty<'_>, set: &mut HirIdSet) {
-        match ty.kind() {
-            ty::Adt(_, generics) => {
-                for generic in *generics {
-                    if let GenericArgKind::Type(ty) = generic.unpack() {
-                        get_captured_ids_recursive(cx, ty, set);
-                    }
-                }
-            },
-            ty::Closure(def_id, _) => {
-                let closure_hir_node = cx.tcx.hir().get_if_local(*def_id).unwrap();
-                if let Node::Expr(closure_expr) = closure_hir_node {
-                    can_move_expr_to_closure(cx, closure_expr)
-                        .unwrap()
-                        .into_iter()
-                        .for_each(|(hir_id, capture_kind)| {
-                            if matches!(capture_kind, CaptureKind::Ref(Mutability::Mut)) {
-                                set.insert(hir_id);
-                            }
-                        });
-                }
-            },
-            _ => (),
-        }
-    }
-
-    let mut set = HirIdSet::default();
-
-    get_captured_ids_recursive(cx, ty, &mut set);
-
-    set
-}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 26834dc4fcc..c413d9baf17 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -54,6 +54,7 @@ mod map_flatten;
 mod map_identity;
 mod map_unwrap_or;
 mod mut_mutex_lock;
+mod needless_collect;
 mod needless_option_as_deref;
 mod needless_option_take;
 mod no_effect_replace;
@@ -3141,6 +3142,28 @@ declare_clippy_lint! {
     "jumping to the start of stream using `seek` method"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for functions collecting an iterator when collect
+    /// is not needed.
+    ///
+    /// ### Why is this bad?
+    /// `collect` causes the allocation of a new data structure,
+    /// when this allocation may not be needed.
+    ///
+    /// ### Example
+    /// ```rust
+    /// # let iterator = vec![1].into_iter();
+    /// let len = iterator.clone().collect::<Vec<_>>().len();
+    /// // should be
+    /// let len = iterator.count();
+    /// ```
+    #[clippy::version = "1.30.0"]
+    pub NEEDLESS_COLLECT,
+    nursery,
+    "collecting an iterator when collect is not needed"
+}
+
 pub struct Methods {
     avoid_breaking_exported_api: bool,
     msrv: Option<RustcVersion>,
@@ -3267,6 +3290,7 @@ impl_lint_pass!(Methods => [
     ITER_KV_MAP,
     SEEK_FROM_CURRENT,
     SEEK_TO_START_INSTEAD_OF_REWIND,
+    NEEDLESS_COLLECT,
 ]);
 
 /// Extracts a method call name, args, and `Span` of the method name.
@@ -3317,6 +3341,8 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             },
             _ => (),
         }
+
+        needless_collect::check(expr, cx);
     }
 
     #[allow(clippy::too_many_lines)]
diff --git a/clippy_lints/src/methods/needless_collect.rs b/clippy_lints/src/methods/needless_collect.rs
new file mode 100644
index 00000000000..66f9e28596e
--- /dev/null
+++ b/clippy_lints/src/methods/needless_collect.rs
@@ -0,0 +1,401 @@
+use super::NEEDLESS_COLLECT;
+use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_hir_and_then};
+use clippy_utils::higher;
+use clippy_utils::source::{snippet, snippet_with_applicability};
+use clippy_utils::sugg::Sugg;
+use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::{can_move_expr_to_closure, is_trait_method, path_to_local, path_to_local_id, CaptureKind};
+use if_chain::if_chain;
+use rustc_data_structures::fx::FxHashMap;
+use rustc_errors::{Applicability, MultiSpan};
+use rustc_hir::intravisit::{walk_block, walk_expr, Visitor};
+use rustc_hir::{Block, Expr, ExprKind, HirId, HirIdSet, Local, Mutability, Node, PatKind, Stmt, StmtKind};
+use rustc_lint::LateContext;
+use rustc_middle::hir::nested_filter;
+use rustc_middle::ty::subst::GenericArgKind;
+use rustc_middle::ty::{self, Ty};
+use rustc_span::sym;
+use rustc_span::Span;
+
+const NEEDLESS_COLLECT_MSG: &str = "avoid using `collect()` when not needed";
+
+pub(super) fn check<'tcx>(expr: &'tcx Expr<'_>, cx: &LateContext<'tcx>) {
+    check_needless_collect_direct_usage(expr, cx);
+    check_needless_collect_indirect_usage(expr, cx);
+}
+fn check_needless_collect_direct_usage<'tcx>(expr: &'tcx Expr<'_>, cx: &LateContext<'tcx>) {
+    if_chain! {
+        if let ExprKind::MethodCall(method, receiver, args, _) = expr.kind;
+        if let ExprKind::MethodCall(chain_method, ..) = receiver.kind;
+        if chain_method.ident.name == sym!(collect) && is_trait_method(cx, receiver, sym::Iterator);
+        then {
+            let ty = cx.typeck_results().expr_ty(receiver);
+            let mut applicability = Applicability::MaybeIncorrect;
+            let is_empty_sugg = "next().is_none()".to_string();
+            let method_name = method.ident.name.as_str();
+            let sugg = if is_type_diagnostic_item(cx, ty, sym::Vec) ||
+                        is_type_diagnostic_item(cx, ty, sym::VecDeque) ||
+                        is_type_diagnostic_item(cx, ty, sym::LinkedList) ||
+                        is_type_diagnostic_item(cx, ty, sym::BinaryHeap) {
+                match method_name {
+                    "len" => "count()".to_string(),
+                    "is_empty" => is_empty_sugg,
+                    "contains" => {
+                        let contains_arg = snippet_with_applicability(cx, args[0].span, "??", &mut applicability);
+                        let (arg, pred) = contains_arg
+                            .strip_prefix('&')
+                            .map_or(("&x", &*contains_arg), |s| ("x", s));
+                        format!("any(|{arg}| x == {pred})")
+                    }
+                    _ => return,
+                }
+            }
+            else if is_type_diagnostic_item(cx, ty, sym::BTreeMap) ||
+                is_type_diagnostic_item(cx, ty, sym::HashMap) {
+                match method_name {
+                    "is_empty" => is_empty_sugg,
+                    _ => return,
+                }
+            }
+            else {
+                return;
+            };
+            span_lint_and_sugg(
+                cx,
+                NEEDLESS_COLLECT,
+                chain_method.ident.span.with_hi(expr.span.hi()),
+                NEEDLESS_COLLECT_MSG,
+                "replace with",
+                sugg,
+                applicability,
+            );
+        }
+    }
+}
+
+fn check_needless_collect_indirect_usage<'tcx>(expr: &'tcx Expr<'_>, cx: &LateContext<'tcx>) {
+    if let ExprKind::Block(block, _) = expr.kind {
+        for stmt in block.stmts {
+            if_chain! {
+                if let StmtKind::Local(local) = stmt.kind;
+                if let PatKind::Binding(_, id, ..) = local.pat.kind;
+                if let Some(init_expr) = local.init;
+                if let ExprKind::MethodCall(method_name, iter_source, [], ..) = init_expr.kind;
+                if method_name.ident.name == sym!(collect) && is_trait_method(cx, init_expr, sym::Iterator);
+                let ty = cx.typeck_results().expr_ty(init_expr);
+                if is_type_diagnostic_item(cx, ty, sym::Vec) ||
+                    is_type_diagnostic_item(cx, ty, sym::VecDeque) ||
+                    is_type_diagnostic_item(cx, ty, sym::BinaryHeap) ||
+                    is_type_diagnostic_item(cx, ty, sym::LinkedList);
+                let iter_ty = cx.typeck_results().expr_ty(iter_source);
+                if let Some(iter_calls) = detect_iter_and_into_iters(block, id, cx, get_captured_ids(cx, iter_ty));
+                if let [iter_call] = &*iter_calls;
+                then {
+                    let mut used_count_visitor = UsedCountVisitor {
+                        cx,
+                        id,
+                        count: 0,
+                    };
+                    walk_block(&mut used_count_visitor, block);
+                    if used_count_visitor.count > 1 {
+                        return;
+                    }
+
+                    // Suggest replacing iter_call with iter_replacement, and removing stmt
+                    let mut span = MultiSpan::from_span(method_name.ident.span);
+                    span.push_span_label(iter_call.span, "the iterator could be used here instead");
+                    span_lint_hir_and_then(
+                        cx,
+                        super::NEEDLESS_COLLECT,
+                        init_expr.hir_id,
+                        span,
+                        NEEDLESS_COLLECT_MSG,
+                        |diag| {
+                            let iter_replacement = format!("{}{}", Sugg::hir(cx, iter_source, ".."), iter_call.get_iter_method(cx));
+                            diag.multipart_suggestion(
+                                iter_call.get_suggestion_text(),
+                                vec![
+                                    (stmt.span, String::new()),
+                                    (iter_call.span, iter_replacement)
+                                ],
+                                Applicability::MaybeIncorrect,
+                            );
+                        },
+                    );
+                }
+            }
+        }
+    }
+}
+
+struct IterFunction {
+    func: IterFunctionKind,
+    span: Span,
+}
+impl IterFunction {
+    fn get_iter_method(&self, cx: &LateContext<'_>) -> String {
+        match &self.func {
+            IterFunctionKind::IntoIter => String::new(),
+            IterFunctionKind::Len => String::from(".count()"),
+            IterFunctionKind::IsEmpty => String::from(".next().is_none()"),
+            IterFunctionKind::Contains(span) => {
+                let s = snippet(cx, *span, "..");
+                if let Some(stripped) = s.strip_prefix('&') {
+                    format!(".any(|x| x == {stripped})")
+                } else {
+                    format!(".any(|x| x == *{s})")
+                }
+            },
+        }
+    }
+    fn get_suggestion_text(&self) -> &'static str {
+        match &self.func {
+            IterFunctionKind::IntoIter => {
+                "use the original Iterator instead of collecting it and then producing a new one"
+            },
+            IterFunctionKind::Len => {
+                "take the original Iterator's count instead of collecting it and finding the length"
+            },
+            IterFunctionKind::IsEmpty => {
+                "check if the original Iterator has anything instead of collecting it and seeing if it's empty"
+            },
+            IterFunctionKind::Contains(_) => {
+                "check if the original Iterator contains an element instead of collecting then checking"
+            },
+        }
+    }
+}
+enum IterFunctionKind {
+    IntoIter,
+    Len,
+    IsEmpty,
+    Contains(Span),
+}
+
+struct IterFunctionVisitor<'a, 'tcx> {
+    illegal_mutable_capture_ids: HirIdSet,
+    current_mutably_captured_ids: HirIdSet,
+    cx: &'a LateContext<'tcx>,
+    uses: Vec<Option<IterFunction>>,
+    hir_id_uses_map: FxHashMap<HirId, usize>,
+    current_statement_hir_id: Option<HirId>,
+    seen_other: bool,
+    target: HirId,
+}
+impl<'tcx> Visitor<'tcx> for IterFunctionVisitor<'_, 'tcx> {
+    fn visit_block(&mut self, block: &'tcx Block<'tcx>) {
+        for (expr, hir_id) in block.stmts.iter().filter_map(get_expr_and_hir_id_from_stmt) {
+            if check_loop_kind(expr).is_some() {
+                continue;
+            }
+            self.visit_block_expr(expr, hir_id);
+        }
+        if let Some(expr) = block.expr {
+            if let Some(loop_kind) = check_loop_kind(expr) {
+                if let LoopKind::Conditional(block_expr) = loop_kind {
+                    self.visit_block_expr(block_expr, None);
+                }
+            } else {
+                self.visit_block_expr(expr, None);
+            }
+        }
+    }
+
+    fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) {
+        // Check function calls on our collection
+        if let ExprKind::MethodCall(method_name, recv, [args @ ..], _) = &expr.kind {
+            if method_name.ident.name == sym!(collect) && is_trait_method(self.cx, expr, sym::Iterator) {
+                self.current_mutably_captured_ids = get_captured_ids(self.cx, self.cx.typeck_results().expr_ty(recv));
+                self.visit_expr(recv);
+                return;
+            }
+
+            if path_to_local_id(recv, self.target) {
+                if self
+                    .illegal_mutable_capture_ids
+                    .intersection(&self.current_mutably_captured_ids)
+                    .next()
+                    .is_none()
+                {
+                    if let Some(hir_id) = self.current_statement_hir_id {
+                        self.hir_id_uses_map.insert(hir_id, self.uses.len());
+                    }
+                    match method_name.ident.name.as_str() {
+                        "into_iter" => self.uses.push(Some(IterFunction {
+                            func: IterFunctionKind::IntoIter,
+                            span: expr.span,
+                        })),
+                        "len" => self.uses.push(Some(IterFunction {
+                            func: IterFunctionKind::Len,
+                            span: expr.span,
+                        })),
+                        "is_empty" => self.uses.push(Some(IterFunction {
+                            func: IterFunctionKind::IsEmpty,
+                            span: expr.span,
+                        })),
+                        "contains" => self.uses.push(Some(IterFunction {
+                            func: IterFunctionKind::Contains(args[0].span),
+                            span: expr.span,
+                        })),
+                        _ => {
+                            self.seen_other = true;
+                            if let Some(hir_id) = self.current_statement_hir_id {
+                                self.hir_id_uses_map.remove(&hir_id);
+                            }
+                        },
+                    }
+                }
+                return;
+            }
+
+            if let Some(hir_id) = path_to_local(recv) {
+                if let Some(index) = self.hir_id_uses_map.remove(&hir_id) {
+                    if self
+                        .illegal_mutable_capture_ids
+                        .intersection(&self.current_mutably_captured_ids)
+                        .next()
+                        .is_none()
+                    {
+                        if let Some(hir_id) = self.current_statement_hir_id {
+                            self.hir_id_uses_map.insert(hir_id, index);
+                        }
+                    } else {
+                        self.uses[index] = None;
+                    }
+                }
+            }
+        }
+        // Check if the collection is used for anything else
+        if path_to_local_id(expr, self.target) {
+            self.seen_other = true;
+        } else {
+            walk_expr(self, expr);
+        }
+    }
+}
+
+enum LoopKind<'tcx> {
+    Conditional(&'tcx Expr<'tcx>),
+    Loop,
+}
+
+fn check_loop_kind<'tcx>(expr: &Expr<'tcx>) -> Option<LoopKind<'tcx>> {
+    if let Some(higher::WhileLet { let_expr, .. }) = higher::WhileLet::hir(expr) {
+        return Some(LoopKind::Conditional(let_expr));
+    }
+    if let Some(higher::While { condition, .. }) = higher::While::hir(expr) {
+        return Some(LoopKind::Conditional(condition));
+    }
+    if let Some(higher::ForLoop { arg, .. }) = higher::ForLoop::hir(expr) {
+        return Some(LoopKind::Conditional(arg));
+    }
+    if let ExprKind::Loop { .. } = expr.kind {
+        return Some(LoopKind::Loop);
+    }
+
+    None
+}
+
+impl<'tcx> IterFunctionVisitor<'_, 'tcx> {
+    fn visit_block_expr(&mut self, expr: &'tcx Expr<'tcx>, hir_id: Option<HirId>) {
+        self.current_statement_hir_id = hir_id;
+        self.current_mutably_captured_ids = get_captured_ids(self.cx, self.cx.typeck_results().expr_ty(expr));
+        self.visit_expr(expr);
+    }
+}
+
+fn get_expr_and_hir_id_from_stmt<'v>(stmt: &'v Stmt<'v>) -> Option<(&'v Expr<'v>, Option<HirId>)> {
+    match stmt.kind {
+        StmtKind::Expr(expr) | StmtKind::Semi(expr) => Some((expr, None)),
+        StmtKind::Item(..) => None,
+        StmtKind::Local(Local { init, pat, .. }) => {
+            if let PatKind::Binding(_, hir_id, ..) = pat.kind {
+                init.map(|init_expr| (init_expr, Some(hir_id)))
+            } else {
+                init.map(|init_expr| (init_expr, None))
+            }
+        },
+    }
+}
+
+struct UsedCountVisitor<'a, 'tcx> {
+    cx: &'a LateContext<'tcx>,
+    id: HirId,
+    count: usize,
+}
+
+impl<'a, 'tcx> Visitor<'tcx> for UsedCountVisitor<'a, 'tcx> {
+    type NestedFilter = nested_filter::OnlyBodies;
+
+    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
+        if path_to_local_id(expr, self.id) {
+            self.count += 1;
+        } else {
+            walk_expr(self, expr);
+        }
+    }
+
+    fn nested_visit_map(&mut self) -> Self::Map {
+        self.cx.tcx.hir()
+    }
+}
+
+/// Detect the occurrences of calls to `iter` or `into_iter` for the
+/// given identifier
+fn detect_iter_and_into_iters<'tcx: 'a, 'a>(
+    block: &'tcx Block<'tcx>,
+    id: HirId,
+    cx: &'a LateContext<'tcx>,
+    captured_ids: HirIdSet,
+) -> Option<Vec<IterFunction>> {
+    let mut visitor = IterFunctionVisitor {
+        uses: Vec::new(),
+        target: id,
+        seen_other: false,
+        cx,
+        current_mutably_captured_ids: HirIdSet::default(),
+        illegal_mutable_capture_ids: captured_ids,
+        hir_id_uses_map: FxHashMap::default(),
+        current_statement_hir_id: None,
+    };
+    visitor.visit_block(block);
+    if visitor.seen_other {
+        None
+    } else {
+        Some(visitor.uses.into_iter().flatten().collect())
+    }
+}
+
+fn get_captured_ids(cx: &LateContext<'_>, ty: Ty<'_>) -> HirIdSet {
+    fn get_captured_ids_recursive(cx: &LateContext<'_>, ty: Ty<'_>, set: &mut HirIdSet) {
+        match ty.kind() {
+            ty::Adt(_, generics) => {
+                for generic in *generics {
+                    if let GenericArgKind::Type(ty) = generic.unpack() {
+                        get_captured_ids_recursive(cx, ty, set);
+                    }
+                }
+            },
+            ty::Closure(def_id, _) => {
+                let closure_hir_node = cx.tcx.hir().get_if_local(*def_id).unwrap();
+                if let Node::Expr(closure_expr) = closure_hir_node {
+                    can_move_expr_to_closure(cx, closure_expr)
+                        .unwrap()
+                        .into_iter()
+                        .for_each(|(hir_id, capture_kind)| {
+                            if matches!(capture_kind, CaptureKind::Ref(Mutability::Mut)) {
+                                set.insert(hir_id);
+                            }
+                        });
+                }
+            },
+            _ => (),
+        }
+    }
+
+    let mut set = HirIdSet::default();
+
+    get_captured_ids_recursive(cx, ty, &mut set);
+
+    set
+}
-- 
cgit 1.4.1-3-g733a5


From 586bd3f735a7ec8c0ee03ab3515dfd8a89a31ff4 Mon Sep 17 00:00:00 2001
From: kraktus <kraktus@users.noreply.github.com>
Date: Sun, 23 Oct 2022 14:00:44 +0200
Subject: refactor to avoid potential ICE

---
 clippy_lints/src/excessive_bools.rs | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/excessive_bools.rs b/clippy_lints/src/excessive_bools.rs
index 453471c8cdd..e1911449242 100644
--- a/clippy_lints/src/excessive_bools.rs
+++ b/clippy_lints/src/excessive_bools.rs
@@ -141,14 +141,13 @@ impl EarlyLintPass for ExcessiveBools {
                     return;
                 }
 
-                let struct_bools = variant_data
+                if let Ok(struct_bools) = variant_data
                     .fields()
                     .iter()
                     .filter(|field| is_bool_ty(&field.ty))
                     .count()
-                    .try_into()
-                    .unwrap();
-                if self.max_struct_bools < struct_bools {
+                    .try_into() && self.max_struct_bools < struct_bools
+                    {
                     span_lint_and_help(
                         cx,
                         STRUCT_EXCESSIVE_BOOLS,
@@ -156,8 +155,8 @@ impl EarlyLintPass for ExcessiveBools {
                         &format!("more than {} bools in a struct", self.max_struct_bools),
                         None,
                         "consider using a state machine or refactoring bools into two-variant enums",
-                    );
-                }
+                    )
+                    }
             },
             ItemKind::Impl(box Impl {
                 of_trait: None, items, ..
-- 
cgit 1.4.1-3-g733a5


From 9c69e93595e581a92c8385b633e687393cb07471 Mon Sep 17 00:00:00 2001
From: kraktus <kraktus@users.noreply.github.com>
Date: Fri, 28 Oct 2022 14:54:59 +0200
Subject: Rewrite `ExcessiveBools` to be a `LateLintPass` lint

changelog: [`fn_params_excessive_bools`] Make it possible to allow the lint at the method level
---
 clippy_lints/src/excessive_bools.rs       | 126 ++++++++++++++++--------------
 clippy_lints/src/lib.rs                   |   2 +-
 clippy_lints/src/methods/mod.rs           |  13 +--
 clippy_utils/src/hir_utils.rs             |  10 ++-
 clippy_utils/src/lib.rs                   |   2 +-
 tests/ui/fn_params_excessive_bools.rs     |   1 +
 tests/ui/fn_params_excessive_bools.stderr |  20 ++---
 7 files changed, 90 insertions(+), 84 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/excessive_bools.rs b/clippy_lints/src/excessive_bools.rs
index e1911449242..08164955c6a 100644
--- a/clippy_lints/src/excessive_bools.rs
+++ b/clippy_lints/src/excessive_bools.rs
@@ -1,8 +1,11 @@
 use clippy_utils::diagnostics::span_lint_and_help;
-use rustc_ast::ast::{AssocItemKind, Extern, Fn, FnSig, Impl, Item, ItemKind, Trait, Ty, TyKind};
-use rustc_lint::{EarlyContext, EarlyLintPass};
+use clippy_utils::{get_parent_node, is_bool};
+use rustc_hir::intravisit::FnKind;
+use rustc_hir::{Body, FnDecl, HirId, Item, ItemKind, Node, Ty};
+use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::{sym, Span};
+use rustc_target::spec::abi::Abi;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -83,6 +86,12 @@ pub struct ExcessiveBools {
     max_fn_params_bools: u64,
 }
 
+#[derive(Eq, PartialEq, Debug)]
+enum Kind {
+    Struct,
+    Fn,
+}
+
 impl ExcessiveBools {
     #[must_use]
     pub fn new(max_struct_bools: u64, max_fn_params_bools: u64) -> Self {
@@ -92,21 +101,20 @@ impl ExcessiveBools {
         }
     }
 
-    fn check_fn_sig(&self, cx: &EarlyContext<'_>, fn_sig: &FnSig, span: Span) {
-        match fn_sig.header.ext {
-            Extern::Implicit(_) | Extern::Explicit(_, _) => return,
-            Extern::None => (),
+    fn too_many_bools<'tcx>(&self, tys: impl Iterator<Item = &'tcx Ty<'tcx>>, kind: Kind) -> bool {
+        if let Ok(bools) = tys.filter(|ty| is_bool(ty)).count().try_into() {
+            (if Kind::Fn == kind {
+                self.max_fn_params_bools
+            } else {
+                self.max_struct_bools
+            }) < bools
+        } else {
+            false
         }
+    }
 
-        let fn_sig_bools = fn_sig
-            .decl
-            .inputs
-            .iter()
-            .filter(|param| is_bool_ty(&param.ty))
-            .count()
-            .try_into()
-            .unwrap();
-        if self.max_fn_params_bools < fn_sig_bools {
+    fn check_fn_sig(&self, cx: &LateContext<'_>, fn_decl: &FnDecl<'_>, span: Span) {
+        if self.too_many_bools(fn_decl.inputs.iter(), Kind::Fn) {
             span_lint_and_help(
                 cx,
                 FN_PARAMS_EXCESSIVE_BOOLS,
@@ -121,55 +129,53 @@ impl ExcessiveBools {
 
 impl_lint_pass!(ExcessiveBools => [STRUCT_EXCESSIVE_BOOLS, FN_PARAMS_EXCESSIVE_BOOLS]);
 
-fn is_bool_ty(ty: &Ty) -> bool {
-    if let TyKind::Path(None, path) = &ty.kind {
-        if let [name] = path.segments.as_slice() {
-            return name.ident.name == sym::bool;
-        }
-    }
-    false
-}
-
-impl EarlyLintPass for ExcessiveBools {
-    fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {
+impl<'tcx> LateLintPass<'tcx> for ExcessiveBools {
+    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
         if item.span.from_expansion() {
             return;
         }
-        match &item.kind {
-            ItemKind::Struct(variant_data, _) => {
-                if item.attrs.iter().any(|attr| attr.has_name(sym::repr)) {
-                    return;
-                }
+        if let ItemKind::Struct(variant_data, _) = &item.kind {
+            if cx
+                .tcx
+                .hir()
+                .attrs(item.hir_id())
+                .iter()
+                .any(|attr| attr.has_name(sym::repr))
+            {
+                return;
+            }
+
+            if self.too_many_bools(variant_data.fields().iter().map(|field| field.ty), Kind::Struct) {
+                span_lint_and_help(
+                    cx,
+                    STRUCT_EXCESSIVE_BOOLS,
+                    item.span,
+                    &format!("more than {} bools in a struct", self.max_struct_bools),
+                    None,
+                    "consider using a state machine or refactoring bools into two-variant enums",
+                )
+            }
+        }
+    }
 
-                if let Ok(struct_bools) = variant_data
-                    .fields()
-                    .iter()
-                    .filter(|field| is_bool_ty(&field.ty))
-                    .count()
-                    .try_into() && self.max_struct_bools < struct_bools
-                    {
-                    span_lint_and_help(
-                        cx,
-                        STRUCT_EXCESSIVE_BOOLS,
-                        item.span,
-                        &format!("more than {} bools in a struct", self.max_struct_bools),
-                        None,
-                        "consider using a state machine or refactoring bools into two-variant enums",
-                    )
-                    }
-            },
-            ItemKind::Impl(box Impl {
-                of_trait: None, items, ..
-            })
-            | ItemKind::Trait(box Trait { items, .. }) => {
-                for item in items {
-                    if let AssocItemKind::Fn(box Fn { sig, .. }) = &item.kind {
-                        self.check_fn_sig(cx, sig, item.span);
-                    }
-                }
-            },
-            ItemKind::Fn(box Fn { sig, .. }) => self.check_fn_sig(cx, sig, item.span),
-            _ => (),
+    fn check_fn(
+        &mut self,
+        cx: &LateContext<'tcx>,
+        fn_kind: FnKind<'tcx>,
+        fn_decl: &'tcx FnDecl<'tcx>,
+        _: &'tcx Body<'tcx>,
+        span: Span,
+        hir_id: HirId,
+    ) {
+        if let Some(fn_header) = fn_kind.header()
+            && fn_header.abi == Abi::Rust
+            && if let Some(Node::Item(item)) = get_parent_node(cx.tcx, hir_id) {
+                !matches!(item.kind, ItemKind::ExternCrate(..))
+                } else {
+                    true
+            }
+            && !span.from_expansion() {
+            self.check_fn_sig(cx, fn_decl, span)
         }
     }
 }
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 01da11958e2..e96075a2673 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -793,7 +793,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_early_pass(|| Box::new(single_component_path_imports::SingleComponentPathImports));
     let max_fn_params_bools = conf.max_fn_params_bools;
     let max_struct_bools = conf.max_struct_bools;
-    store.register_early_pass(move || {
+    store.register_late_pass(move |_| {
         Box::new(excessive_bools::ExcessiveBools::new(
             max_struct_bools,
             max_fn_params_bools,
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 6665329d114..996d4cb4123 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -104,11 +104,10 @@ use bind_instead_of_map::BindInsteadOfMap;
 use clippy_utils::consts::{constant, Constant};
 use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
 use clippy_utils::ty::{contains_ty_adt_constructor_opaque, implements_trait, is_copy, is_type_diagnostic_item};
-use clippy_utils::{contains_return, is_trait_method, iter_input_pats, meets_msrv, msrvs, return_ty};
+use clippy_utils::{contains_return, is_bool, is_trait_method, iter_input_pats, meets_msrv, msrvs, return_ty};
 use if_chain::if_chain;
 use rustc_hir as hir;
-use rustc_hir::def::Res;
-use rustc_hir::{Expr, ExprKind, PrimTy, QPath, TraitItem, TraitItemKind};
+use rustc_hir::{Expr, ExprKind, TraitItem, TraitItemKind};
 use rustc_hir_analysis::hir_ty_to_ty;
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
@@ -3966,14 +3965,6 @@ impl OutType {
     }
 }
 
-fn is_bool(ty: &hir::Ty<'_>) -> bool {
-    if let hir::TyKind::Path(QPath::Resolved(_, path)) = ty.kind {
-        matches!(path.res, Res::PrimTy(PrimTy::Bool))
-    } else {
-        false
-    }
-}
-
 fn fn_header_equals(expected: hir::FnHeader, actual: hir::FnHeader) -> bool {
     expected.constness == actual.constness
         && expected.unsafety == actual.unsafety
diff --git a/clippy_utils/src/hir_utils.rs b/clippy_utils/src/hir_utils.rs
index 02b973e5b27..da8c976c952 100644
--- a/clippy_utils/src/hir_utils.rs
+++ b/clippy_utils/src/hir_utils.rs
@@ -8,7 +8,7 @@ use rustc_hir::HirIdMap;
 use rustc_hir::{
     ArrayLen, BinOpKind, BindingAnnotation, Block, BodyId, Closure, Expr, ExprField, ExprKind, FnRetTy, GenericArg,
     GenericArgs, Guard, HirId, InlineAsmOperand, Let, Lifetime, LifetimeName, ParamName, Pat, PatField, PatKind, Path,
-    PathSegment, QPath, Stmt, StmtKind, Ty, TyKind, TypeBinding,
+    PathSegment, PrimTy, QPath, Stmt, StmtKind, Ty, TyKind, TypeBinding,
 };
 use rustc_lexer::{tokenize, TokenKind};
 use rustc_lint::LateContext;
@@ -1030,6 +1030,14 @@ pub fn hash_stmt(cx: &LateContext<'_>, s: &Stmt<'_>) -> u64 {
     h.finish()
 }
 
+pub fn is_bool(ty: &Ty<'_>) -> bool {
+    if let TyKind::Path(QPath::Resolved(_, path)) = ty.kind {
+        matches!(path.res, Res::PrimTy(PrimTy::Bool))
+    } else {
+        false
+    }
+}
+
 pub fn hash_expr(cx: &LateContext<'_>, e: &Expr<'_>) -> u64 {
     let mut h = SpanlessHash::new(cx);
     h.hash_expr(e);
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index dda4660fb7a..0000896fdb6 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -66,7 +66,7 @@ pub mod visitors;
 pub use self::attrs::*;
 pub use self::check_proc_macro::{is_from_proc_macro, is_span_if, is_span_match};
 pub use self::hir_utils::{
-    both, count_eq, eq_expr_value, hash_expr, hash_stmt, over, HirEqInterExpr, SpanlessEq, SpanlessHash,
+    both, count_eq, eq_expr_value, hash_expr, hash_stmt, is_bool, over, HirEqInterExpr, SpanlessEq, SpanlessHash,
 };
 
 use core::ops::ControlFlow;
diff --git a/tests/ui/fn_params_excessive_bools.rs b/tests/ui/fn_params_excessive_bools.rs
index f805bcc9ba8..4fcd4d54ce6 100644
--- a/tests/ui/fn_params_excessive_bools.rs
+++ b/tests/ui/fn_params_excessive_bools.rs
@@ -2,6 +2,7 @@
 #![allow(clippy::too_many_arguments)]
 
 extern "C" {
+    // Should not lint, most of the time users have no control over extern function signatures
     fn f(_: bool, _: bool, _: bool, _: bool);
 }
 
diff --git a/tests/ui/fn_params_excessive_bools.stderr b/tests/ui/fn_params_excessive_bools.stderr
index 11627105691..9d22d3851d2 100644
--- a/tests/ui/fn_params_excessive_bools.stderr
+++ b/tests/ui/fn_params_excessive_bools.stderr
@@ -1,5 +1,5 @@
 error: more than 3 bools in function parameters
-  --> $DIR/fn_params_excessive_bools.rs:18:1
+  --> $DIR/fn_params_excessive_bools.rs:19:1
    |
 LL | fn g(_: bool, _: bool, _: bool, _: bool) {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -8,7 +8,7 @@ LL | fn g(_: bool, _: bool, _: bool, _: bool) {}
    = note: `-D clippy::fn-params-excessive-bools` implied by `-D warnings`
 
 error: more than 3 bools in function parameters
-  --> $DIR/fn_params_excessive_bools.rs:21:1
+  --> $DIR/fn_params_excessive_bools.rs:22:1
    |
 LL | fn t(_: S, _: S, _: Box<S>, _: Vec<u32>, _: bool, _: bool, _: bool, _: bool) {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -16,23 +16,23 @@ LL | fn t(_: S, _: S, _: Box<S>, _: Vec<u32>, _: bool, _: bool, _: bool, _: bool
    = help: consider refactoring bools into two-variant enums
 
 error: more than 3 bools in function parameters
-  --> $DIR/fn_params_excessive_bools.rs:25:5
+  --> $DIR/fn_params_excessive_bools.rs:31:5
    |
-LL |     fn f(_: bool, _: bool, _: bool, _: bool);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |     fn f(&self, _: bool, _: bool, _: bool, _: bool) {}
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: consider refactoring bools into two-variant enums
 
 error: more than 3 bools in function parameters
-  --> $DIR/fn_params_excessive_bools.rs:30:5
+  --> $DIR/fn_params_excessive_bools.rs:38:5
    |
-LL |     fn f(&self, _: bool, _: bool, _: bool, _: bool) {}
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |     fn f(_: bool, _: bool, _: bool, _: bool) {}
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: consider refactoring bools into two-variant enums
 
 error: more than 3 bools in function parameters
-  --> $DIR/fn_params_excessive_bools.rs:42:5
+  --> $DIR/fn_params_excessive_bools.rs:43:5
    |
 LL | /     fn n(_: bool, _: u32, _: bool, _: Box<u32>, _: bool, _: bool) {
 LL | |         fn nn(_: bool, _: bool, _: bool, _: bool) {}
@@ -42,7 +42,7 @@ LL | |     }
    = help: consider refactoring bools into two-variant enums
 
 error: more than 3 bools in function parameters
-  --> $DIR/fn_params_excessive_bools.rs:43:9
+  --> $DIR/fn_params_excessive_bools.rs:44:9
    |
 LL |         fn nn(_: bool, _: bool, _: bool, _: bool) {}
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From e8c2c3d1c6ac27d0f1fa9125b79f1f927a59cfcf Mon Sep 17 00:00:00 2001
From: kraktus <kraktus@users.noreply.github.com>
Date: Fri, 28 Oct 2022 14:57:51 +0200
Subject: refactor `has_repr_attr`

---
 clippy_lints/src/excessive_bools.rs      | 21 +++++----------------
 clippy_lints/src/trailing_empty_array.rs |  8 ++------
 clippy_utils/src/lib.rs                  |  4 ++++
 3 files changed, 11 insertions(+), 22 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/excessive_bools.rs b/clippy_lints/src/excessive_bools.rs
index 08164955c6a..08fcf304958 100644
--- a/clippy_lints/src/excessive_bools.rs
+++ b/clippy_lints/src/excessive_bools.rs
@@ -1,10 +1,10 @@
 use clippy_utils::diagnostics::span_lint_and_help;
-use clippy_utils::{get_parent_node, is_bool};
+use clippy_utils::{has_repr_attr, is_bool};
 use rustc_hir::intravisit::FnKind;
-use rustc_hir::{Body, FnDecl, HirId, Item, ItemKind, Node, Ty};
+use rustc_hir::{Body, FnDecl, HirId, Item, ItemKind, Ty};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::{sym, Span};
+use rustc_span::Span;
 use rustc_target::spec::abi::Abi;
 
 declare_clippy_lint! {
@@ -135,13 +135,7 @@ impl<'tcx> LateLintPass<'tcx> for ExcessiveBools {
             return;
         }
         if let ItemKind::Struct(variant_data, _) = &item.kind {
-            if cx
-                .tcx
-                .hir()
-                .attrs(item.hir_id())
-                .iter()
-                .any(|attr| attr.has_name(sym::repr))
-            {
+            if has_repr_attr(cx, item.hir_id()) {
                 return;
             }
 
@@ -165,15 +159,10 @@ impl<'tcx> LateLintPass<'tcx> for ExcessiveBools {
         fn_decl: &'tcx FnDecl<'tcx>,
         _: &'tcx Body<'tcx>,
         span: Span,
-        hir_id: HirId,
+        _: HirId,
     ) {
         if let Some(fn_header) = fn_kind.header()
             && fn_header.abi == Abi::Rust
-            && if let Some(Node::Item(item)) = get_parent_node(cx.tcx, hir_id) {
-                !matches!(item.kind, ItemKind::ExternCrate(..))
-                } else {
-                    true
-            }
             && !span.from_expansion() {
             self.check_fn_sig(cx, fn_decl, span)
         }
diff --git a/clippy_lints/src/trailing_empty_array.rs b/clippy_lints/src/trailing_empty_array.rs
index 58cc057a39e..712a7a6601a 100644
--- a/clippy_lints/src/trailing_empty_array.rs
+++ b/clippy_lints/src/trailing_empty_array.rs
@@ -1,9 +1,9 @@
 use clippy_utils::diagnostics::span_lint_and_help;
-use rustc_hir::{HirId, Item, ItemKind};
+use clippy_utils::has_repr_attr;
+use rustc_hir::{Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::Const;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::sym;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -72,7 +72,3 @@ fn is_struct_with_trailing_zero_sized_array(cx: &LateContext<'_>, item: &Item<'_
         }
     }
 }
-
-fn has_repr_attr(cx: &LateContext<'_>, hir_id: HirId) -> bool {
-    cx.tcx.hir().attrs(hir_id).iter().any(|attr| attr.has_name(sym::repr))
-}
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 0000896fdb6..7ce8bbc1b7b 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -1780,6 +1780,10 @@ pub fn has_attr(attrs: &[ast::Attribute], symbol: Symbol) -> bool {
     attrs.iter().any(|attr| attr.has_name(symbol))
 }
 
+pub fn has_repr_attr(cx: &LateContext<'_>, hir_id: HirId) -> bool {
+    has_attr(cx.tcx.hir().attrs(hir_id), sym::repr)
+}
+
 pub fn any_parent_has_attr(tcx: TyCtxt<'_>, node: HirId, symbol: Symbol) -> bool {
     let map = &tcx.hir();
     let mut prev_enclosing_node = None;
-- 
cgit 1.4.1-3-g733a5


From d9b940e2c36eee3172c0f41f570de9e2d8ed95fd Mon Sep 17 00:00:00 2001
From: kraktus <kraktus@users.noreply.github.com>
Date: Sun, 23 Oct 2022 16:03:05 +0200
Subject: dogfood

---
 clippy_lints/src/excessive_bools.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/excessive_bools.rs b/clippy_lints/src/excessive_bools.rs
index 08fcf304958..281d0631d06 100644
--- a/clippy_lints/src/excessive_bools.rs
+++ b/clippy_lints/src/excessive_bools.rs
@@ -86,7 +86,7 @@ pub struct ExcessiveBools {
     max_fn_params_bools: u64,
 }
 
-#[derive(Eq, PartialEq, Debug)]
+#[derive(Eq, PartialEq, Debug, Copy, Clone)]
 enum Kind {
     Struct,
     Fn,
@@ -147,7 +147,7 @@ impl<'tcx> LateLintPass<'tcx> for ExcessiveBools {
                     &format!("more than {} bools in a struct", self.max_struct_bools),
                     None,
                     "consider using a state machine or refactoring bools into two-variant enums",
-                )
+                );
             }
         }
     }
@@ -164,7 +164,7 @@ impl<'tcx> LateLintPass<'tcx> for ExcessiveBools {
         if let Some(fn_header) = fn_kind.header()
             && fn_header.abi == Abi::Rust
             && !span.from_expansion() {
-            self.check_fn_sig(cx, fn_decl, span)
+            self.check_fn_sig(cx, fn_decl, span);
         }
     }
 }
-- 
cgit 1.4.1-3-g733a5


From 9e1c7febe261b834d2c787aca2fcd9de577d76d8 Mon Sep 17 00:00:00 2001
From: kraktus <kraktus@users.noreply.github.com>
Date: Sat, 29 Oct 2022 16:12:41 +0200
Subject: `excessive_bools`, do not lint in trait impls

Should not lint because the trait might not be changeable by the user
We only lint in the trait definition
---
 clippy_lints/src/excessive_bools.rs       | 11 ++++++++---
 tests/ui/fn_params_excessive_bools.rs     |  2 ++
 tests/ui/fn_params_excessive_bools.stderr | 14 +++-----------
 3 files changed, 13 insertions(+), 14 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/excessive_bools.rs b/clippy_lints/src/excessive_bools.rs
index 281d0631d06..68c5e5ab1f1 100644
--- a/clippy_lints/src/excessive_bools.rs
+++ b/clippy_lints/src/excessive_bools.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_help;
-use clippy_utils::{has_repr_attr, is_bool};
+use clippy_utils::{get_parent_as_impl, has_repr_attr, is_bool};
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::{Body, FnDecl, HirId, Item, ItemKind, Ty};
 use rustc_lint::{LateContext, LateLintPass};
@@ -159,11 +159,16 @@ impl<'tcx> LateLintPass<'tcx> for ExcessiveBools {
         fn_decl: &'tcx FnDecl<'tcx>,
         _: &'tcx Body<'tcx>,
         span: Span,
-        _: HirId,
+        hir_id: HirId,
     ) {
         if let Some(fn_header) = fn_kind.header()
             && fn_header.abi == Abi::Rust
-            && !span.from_expansion() {
+            && !span.from_expansion()
+            && get_parent_as_impl(cx.tcx, hir_id)
+                .map_or(true,
+                    |impl_item| impl_item.of_trait.is_none()
+                )
+            {
             self.check_fn_sig(cx, fn_decl, span);
         }
     }
diff --git a/tests/ui/fn_params_excessive_bools.rs b/tests/ui/fn_params_excessive_bools.rs
index 4fcd4d54ce6..2635e433a31 100644
--- a/tests/ui/fn_params_excessive_bools.rs
+++ b/tests/ui/fn_params_excessive_bools.rs
@@ -35,6 +35,8 @@ impl S {
 }
 
 impl Trait for S {
+    // Should not lint because the trait might not be changeable by the user
+    // We only lint in the trait definition
     fn f(_: bool, _: bool, _: bool, _: bool) {}
     fn g(_: bool, _: bool, _: bool, _: Vec<u32>) {}
 }
diff --git a/tests/ui/fn_params_excessive_bools.stderr b/tests/ui/fn_params_excessive_bools.stderr
index 9d22d3851d2..7edfd07b9db 100644
--- a/tests/ui/fn_params_excessive_bools.stderr
+++ b/tests/ui/fn_params_excessive_bools.stderr
@@ -24,15 +24,7 @@ LL |     fn f(&self, _: bool, _: bool, _: bool, _: bool) {}
    = help: consider refactoring bools into two-variant enums
 
 error: more than 3 bools in function parameters
-  --> $DIR/fn_params_excessive_bools.rs:38:5
-   |
-LL |     fn f(_: bool, _: bool, _: bool, _: bool) {}
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: consider refactoring bools into two-variant enums
-
-error: more than 3 bools in function parameters
-  --> $DIR/fn_params_excessive_bools.rs:43:5
+  --> $DIR/fn_params_excessive_bools.rs:45:5
    |
 LL | /     fn n(_: bool, _: u32, _: bool, _: Box<u32>, _: bool, _: bool) {
 LL | |         fn nn(_: bool, _: bool, _: bool, _: bool) {}
@@ -42,12 +34,12 @@ LL | |     }
    = help: consider refactoring bools into two-variant enums
 
 error: more than 3 bools in function parameters
-  --> $DIR/fn_params_excessive_bools.rs:44:9
+  --> $DIR/fn_params_excessive_bools.rs:46:9
    |
 LL |         fn nn(_: bool, _: bool, _: bool, _: bool) {}
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: consider refactoring bools into two-variant enums
 
-error: aborting due to 6 previous errors
+error: aborting due to 5 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 8bfc8bc5e0210dabd2976edad5bf285a96dcb360 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Wed, 20 Apr 2022 16:10:18 -0400
Subject: Lint `needless_collect` on non-std collection types

---
 .../src/methods/collapsible_str_replace.rs         |   6 +-
 clippy_lints/src/methods/manual_str_repeat.rs      |   2 -
 .../src/methods/map_collect_result_unit.rs         |  15 +-
 clippy_lints/src/methods/mod.rs                    |  95 ++++-----
 clippy_lints/src/methods/needless_collect.rs       | 223 +++++++++++++--------
 clippy_utils/src/ty.rs                             | 134 ++++++++++++-
 tests/ui/needless_collect.fixed                    |  29 +++
 tests/ui/needless_collect.rs                       |  29 +++
 tests/ui/needless_collect.stderr                   |  26 ++-
 9 files changed, 408 insertions(+), 151 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/collapsible_str_replace.rs b/clippy_lints/src/methods/collapsible_str_replace.rs
index 501646863fe..ac61b437788 100644
--- a/clippy_lints/src/methods/collapsible_str_replace.rs
+++ b/clippy_lints/src/methods/collapsible_str_replace.rs
@@ -23,7 +23,7 @@ pub(super) fn check<'tcx>(
         // If the parent node's `to` argument is the same as the `to` argument
         // of the last replace call in the current chain, don't lint as it was already linted
         if let Some(parent) = get_parent_expr(cx, expr)
-            && let Some(("replace", _, [current_from, current_to], _)) = method_call(parent)
+            && let Some(("replace", _, [current_from, current_to], _, _)) = method_call(parent)
             && eq_expr_value(cx, to, current_to)
             && from_kind == cx.typeck_results().expr_ty(current_from).peel_refs().kind()
         {
@@ -48,7 +48,7 @@ fn collect_replace_calls<'tcx>(
     let mut from_args = VecDeque::new();
 
     let _: Option<()> = for_each_expr(expr, |e| {
-        if let Some(("replace", _, [from, to], _)) = method_call(e) {
+        if let Some(("replace", _, [from, to], _, _)) = method_call(e) {
             if eq_expr_value(cx, to_arg, to) && cx.typeck_results().expr_ty(from).peel_refs().is_char() {
                 methods.push_front(e);
                 from_args.push_front(from);
@@ -78,7 +78,7 @@ fn check_consecutive_replace_calls<'tcx>(
         .collect();
     let app = Applicability::MachineApplicable;
     let earliest_replace_call = replace_methods.methods.front().unwrap();
-    if let Some((_, _, [..], span_lo)) = method_call(earliest_replace_call) {
+    if let Some((_, _, [..], span_lo, _)) = method_call(earliest_replace_call) {
         span_lint_and_sugg(
             cx,
             COLLAPSIBLE_STR_REPLACE,
diff --git a/clippy_lints/src/methods/manual_str_repeat.rs b/clippy_lints/src/methods/manual_str_repeat.rs
index 8b6b8f1bf16..8b798fdb12f 100644
--- a/clippy_lints/src/methods/manual_str_repeat.rs
+++ b/clippy_lints/src/methods/manual_str_repeat.rs
@@ -59,10 +59,8 @@ pub(super) fn check(
         if let ExprKind::Call(repeat_fn, [repeat_arg]) = take_self_arg.kind;
         if is_path_diagnostic_item(cx, repeat_fn, sym::iter_repeat);
         if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(collect_expr), sym::String);
-        if let Some(collect_id) = cx.typeck_results().type_dependent_def_id(collect_expr.hir_id);
         if let Some(take_id) = cx.typeck_results().type_dependent_def_id(take_expr.hir_id);
         if let Some(iter_trait_id) = cx.tcx.get_diagnostic_item(sym::Iterator);
-        if cx.tcx.trait_of_item(collect_id) == Some(iter_trait_id);
         if cx.tcx.trait_of_item(take_id) == Some(iter_trait_id);
         if let Some(repeat_kind) = parse_repeat_arg(cx, repeat_arg);
         let ctxt = collect_expr.span.ctxt();
diff --git a/clippy_lints/src/methods/map_collect_result_unit.rs b/clippy_lints/src/methods/map_collect_result_unit.rs
index d420f144eea..a0300d27870 100644
--- a/clippy_lints/src/methods/map_collect_result_unit.rs
+++ b/clippy_lints/src/methods/map_collect_result_unit.rs
@@ -1,5 +1,4 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::is_trait_method;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
@@ -11,18 +10,10 @@ use rustc_span::symbol::sym;
 
 use super::MAP_COLLECT_RESULT_UNIT;
 
-pub(super) fn check(
-    cx: &LateContext<'_>,
-    expr: &hir::Expr<'_>,
-    iter: &hir::Expr<'_>,
-    map_fn: &hir::Expr<'_>,
-    collect_recv: &hir::Expr<'_>,
-) {
+pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, iter: &hir::Expr<'_>, map_fn: &hir::Expr<'_>) {
+    // return of collect `Result<(),_>`
+    let collect_ret_ty = cx.typeck_results().expr_ty(expr);
     if_chain! {
-        // called on Iterator
-        if is_trait_method(cx, collect_recv, sym::Iterator);
-        // return of collect `Result<(),_>`
-        let collect_ret_ty = cx.typeck_results().expr_ty(expr);
         if is_type_diagnostic_item(cx, collect_ret_ty, sym::Result);
         if let ty::Adt(_, substs) = collect_ret_ty.kind();
         if let Some(result_t) = substs.types().next();
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index c413d9baf17..1c0bbe086f7 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3296,11 +3296,11 @@ impl_lint_pass!(Methods => [
 /// Extracts a method call name, args, and `Span` of the method name.
 fn method_call<'tcx>(
     recv: &'tcx hir::Expr<'tcx>,
-) -> Option<(&'tcx str, &'tcx hir::Expr<'tcx>, &'tcx [hir::Expr<'tcx>], Span)> {
-    if let ExprKind::MethodCall(path, receiver, args, _) = recv.kind {
+) -> Option<(&'tcx str, &'tcx hir::Expr<'tcx>, &'tcx [hir::Expr<'tcx>], Span, Span)> {
+    if let ExprKind::MethodCall(path, receiver, args, call_span) = recv.kind {
         if !args.iter().any(|e| e.span.from_expansion()) && !receiver.span.from_expansion() {
             let name = path.ident.name.as_str();
-            return Some((name, receiver, args, path.ident.span));
+            return Some((name, receiver, args, path.ident.span, call_span));
         }
     }
     None
@@ -3341,8 +3341,6 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             },
             _ => (),
         }
-
-        needless_collect::check(expr, cx);
     }
 
     #[allow(clippy::too_many_lines)]
@@ -3488,7 +3486,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
 impl Methods {
     #[allow(clippy::too_many_lines)]
     fn check_methods<'tcx>(&self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if let Some((name, recv, args, span)) = method_call(expr) {
+        if let Some((name, recv, args, span, call_span)) = method_call(expr) {
             match (name, args) {
                 ("add" | "offset" | "sub" | "wrapping_offset" | "wrapping_add" | "wrapping_sub", [_arg]) => {
                     zst_offset::check(cx, expr, recv);
@@ -3507,28 +3505,31 @@ impl Methods {
                 ("as_ref", []) => useless_asref::check(cx, expr, "as_ref", recv),
                 ("assume_init", []) => uninit_assumed_init::check(cx, expr, recv),
                 ("cloned", []) => cloned_instead_of_copied::check(cx, expr, recv, span, self.msrv),
-                ("collect", []) => match method_call(recv) {
-                    Some((name @ ("cloned" | "copied"), recv2, [], _)) => {
-                        iter_cloned_collect::check(cx, name, expr, recv2);
-                    },
-                    Some(("map", m_recv, [m_arg], _)) => {
-                        map_collect_result_unit::check(cx, expr, m_recv, m_arg, recv);
-                    },
-                    Some(("take", take_self_arg, [take_arg], _)) => {
-                        if meets_msrv(self.msrv, msrvs::STR_REPEAT) {
-                            manual_str_repeat::check(cx, expr, recv, take_self_arg, take_arg);
-                        }
-                    },
-                    _ => {},
+                ("collect", []) if is_trait_method(cx, expr, sym::Iterator) => {
+                    needless_collect::check(cx, span, expr, recv, call_span);
+                    match method_call(recv) {
+                        Some((name @ ("cloned" | "copied"), recv2, [], _, _)) => {
+                            iter_cloned_collect::check(cx, name, expr, recv2);
+                        },
+                        Some(("map", m_recv, [m_arg], _, _)) => {
+                            map_collect_result_unit::check(cx, expr, m_recv, m_arg);
+                        },
+                        Some(("take", take_self_arg, [take_arg], _, _)) => {
+                            if meets_msrv(self.msrv, msrvs::STR_REPEAT) {
+                                manual_str_repeat::check(cx, expr, recv, take_self_arg, take_arg);
+                            }
+                        },
+                        _ => {},
+                    }
                 },
                 ("count", []) if is_trait_method(cx, expr, sym::Iterator) => match method_call(recv) {
-                    Some(("cloned", recv2, [], _)) => iter_overeager_cloned::check(cx, expr, recv, recv2, true, false),
-                    Some((name2 @ ("into_iter" | "iter" | "iter_mut"), recv2, [], _)) => {
+                    Some(("cloned", recv2, [], _, _)) => iter_overeager_cloned::check(cx, expr, recv, recv2, true, false),
+                    Some((name2 @ ("into_iter" | "iter" | "iter_mut"), recv2, [], _, _)) => {
                         iter_count::check(cx, expr, recv2, name2);
                     },
-                    Some(("map", _, [arg], _)) => suspicious_map::check(cx, expr, recv, arg),
-                    Some(("filter", recv2, [arg], _)) => bytecount::check(cx, expr, recv2, arg),
-                    Some(("bytes", recv2, [], _)) => bytes_count_to_len::check(cx, expr, recv, recv2),
+                    Some(("map", _, [arg], _, _)) => suspicious_map::check(cx, expr, recv, arg),
+                    Some(("filter", recv2, [arg], _, _)) => bytecount::check(cx, expr, recv2, arg),
+                    Some(("bytes", recv2, [], _, _)) => bytes_count_to_len::check(cx, expr, recv, recv2),
                     _ => {},
                 },
                 ("drain", [arg]) => {
@@ -3540,8 +3541,8 @@ impl Methods {
                     }
                 },
                 ("expect", [_]) => match method_call(recv) {
-                    Some(("ok", recv, [], _)) => ok_expect::check(cx, expr, recv),
-                    Some(("err", recv, [], err_span)) => err_expect::check(cx, expr, recv, self.msrv, span, err_span),
+                    Some(("ok", recv, [], _, _)) => ok_expect::check(cx, expr, recv),
+                    Some(("err", recv, [], err_span, _)) => err_expect::check(cx, expr, recv, self.msrv, span, err_span),
                     _ => expect_used::check(cx, expr, recv, false, self.allow_expect_in_tests),
                 },
                 ("expect_err", [_]) => expect_used::check(cx, expr, recv, true, self.allow_expect_in_tests),
@@ -3561,13 +3562,13 @@ impl Methods {
                     flat_map_option::check(cx, expr, arg, span);
                 },
                 ("flatten", []) => match method_call(recv) {
-                    Some(("map", recv, [map_arg], map_span)) => map_flatten::check(cx, expr, recv, map_arg, map_span),
-                    Some(("cloned", recv2, [], _)) => iter_overeager_cloned::check(cx, expr, recv, recv2, false, true),
+                    Some(("map", recv, [map_arg], map_span, _)) => map_flatten::check(cx, expr, recv, map_arg, map_span),
+                    Some(("cloned", recv2, [], _, _)) => iter_overeager_cloned::check(cx, expr, recv, recv2, false, true),
                     _ => {},
                 },
                 ("fold", [init, acc]) => unnecessary_fold::check(cx, expr, init, acc, span),
                 ("for_each", [_]) => {
-                    if let Some(("inspect", _, [_], span2)) = method_call(recv) {
+                    if let Some(("inspect", _, [_], span2, _)) = method_call(recv) {
                         inspect_for_each::check(cx, expr, span2);
                     }
                 },
@@ -3587,12 +3588,12 @@ impl Methods {
                     iter_on_single_or_empty_collections::check(cx, expr, name, recv);
                 },
                 ("join", [join_arg]) => {
-                    if let Some(("collect", _, _, span)) = method_call(recv) {
+                    if let Some(("collect", _, _, span, _)) = method_call(recv) {
                         unnecessary_join::check(cx, expr, recv, join_arg, span);
                     }
                 },
                 ("last", []) | ("skip", [_]) => {
-                    if let Some((name2, recv2, args2, _span2)) = method_call(recv) {
+                    if let Some((name2, recv2, args2, _span2, _)) = method_call(recv) {
                         if let ("cloned", []) = (name2, args2) {
                             iter_overeager_cloned::check(cx, expr, recv, recv2, false, false);
                         }
@@ -3604,13 +3605,13 @@ impl Methods {
                 (name @ ("map" | "map_err"), [m_arg]) => {
                     if name == "map" {
                         map_clone::check(cx, expr, recv, m_arg, self.msrv);
-                        if let Some((map_name @ ("iter" | "into_iter"), recv2, _, _)) = method_call(recv) {
+                        if let Some((map_name @ ("iter" | "into_iter"), recv2, _, _, _)) = method_call(recv) {
                             iter_kv_map::check(cx, map_name, expr, recv2, m_arg);
                         }
                     } else {
                         map_err_ignore::check(cx, expr, m_arg);
                     }
-                    if let Some((name, recv2, args, span2)) = method_call(recv) {
+                    if let Some((name, recv2, args, span2,_)) = method_call(recv) {
                         match (name, args) {
                             ("as_mut", []) => option_as_ref_deref::check(cx, expr, recv2, m_arg, true, self.msrv),
                             ("as_ref", []) => option_as_ref_deref::check(cx, expr, recv2, m_arg, false, self.msrv),
@@ -3630,7 +3631,7 @@ impl Methods {
                     manual_ok_or::check(cx, expr, recv, def, map);
                 },
                 ("next", []) => {
-                    if let Some((name2, recv2, args2, _)) = method_call(recv) {
+                    if let Some((name2, recv2, args2, _, _)) = method_call(recv) {
                         match (name2, args2) {
                             ("cloned", []) => iter_overeager_cloned::check(cx, expr, recv, recv2, false, false),
                             ("filter", [arg]) => filter_next::check(cx, expr, recv2, arg),
@@ -3643,10 +3644,10 @@ impl Methods {
                     }
                 },
                 ("nth", [n_arg]) => match method_call(recv) {
-                    Some(("bytes", recv2, [], _)) => bytes_nth::check(cx, expr, recv2, n_arg),
-                    Some(("cloned", recv2, [], _)) => iter_overeager_cloned::check(cx, expr, recv, recv2, false, false),
-                    Some(("iter", recv2, [], _)) => iter_nth::check(cx, expr, recv2, recv, n_arg, false),
-                    Some(("iter_mut", recv2, [], _)) => iter_nth::check(cx, expr, recv2, recv, n_arg, true),
+                    Some(("bytes", recv2, [], _, _)) => bytes_nth::check(cx, expr, recv2, n_arg),
+                    Some(("cloned", recv2, [], _, _)) => iter_overeager_cloned::check(cx, expr, recv, recv2, false, false),
+                    Some(("iter", recv2, [], _, _)) => iter_nth::check(cx, expr, recv2, recv, n_arg, false),
+                    Some(("iter_mut", recv2, [], _, _)) => iter_nth::check(cx, expr, recv2, recv, n_arg, true),
                     _ => iter_nth_zero::check(cx, expr, recv, n_arg),
                 },
                 ("ok_or_else", [arg]) => unnecessary_lazy_eval::check(cx, expr, recv, arg, "ok_or"),
@@ -3711,7 +3712,7 @@ impl Methods {
                 },
                 ("step_by", [arg]) => iterator_step_by_zero::check(cx, expr, arg),
                 ("take", [_arg]) => {
-                    if let Some((name2, recv2, args2, _span2)) = method_call(recv) {
+                    if let Some((name2, recv2, args2, _span2, _)) = method_call(recv) {
                         if let ("cloned", []) = (name2, args2) {
                             iter_overeager_cloned::check(cx, expr, recv, recv2, false, false);
                         }
@@ -3734,13 +3735,13 @@ impl Methods {
                 },
                 ("unwrap", []) => {
                     match method_call(recv) {
-                        Some(("get", recv, [get_arg], _)) => {
+                        Some(("get", recv, [get_arg], _, _)) => {
                             get_unwrap::check(cx, expr, recv, get_arg, false);
                         },
-                        Some(("get_mut", recv, [get_arg], _)) => {
+                        Some(("get_mut", recv, [get_arg], _, _)) => {
                             get_unwrap::check(cx, expr, recv, get_arg, true);
                         },
-                        Some(("or", recv, [or_arg], or_span)) => {
+                        Some(("or", recv, [or_arg], or_span, _)) => {
                             or_then_unwrap::check(cx, expr, recv, or_arg, or_span);
                         },
                         _ => {},
@@ -3749,19 +3750,19 @@ impl Methods {
                 },
                 ("unwrap_err", []) => unwrap_used::check(cx, expr, recv, true, self.allow_unwrap_in_tests),
                 ("unwrap_or", [u_arg]) => match method_call(recv) {
-                    Some((arith @ ("checked_add" | "checked_sub" | "checked_mul"), lhs, [rhs], _)) => {
+                    Some((arith @ ("checked_add" | "checked_sub" | "checked_mul"), lhs, [rhs], _, _)) => {
                         manual_saturating_arithmetic::check(cx, expr, lhs, rhs, u_arg, &arith["checked_".len()..]);
                     },
-                    Some(("map", m_recv, [m_arg], span)) => {
+                    Some(("map", m_recv, [m_arg], span, _)) => {
                         option_map_unwrap_or::check(cx, expr, m_recv, m_arg, recv, u_arg, span);
                     },
-                    Some(("then_some", t_recv, [t_arg], _)) => {
+                    Some(("then_some", t_recv, [t_arg], _, _)) => {
                         obfuscated_if_else::check(cx, expr, t_recv, t_arg, u_arg);
                     },
                     _ => {},
                 },
                 ("unwrap_or_else", [u_arg]) => match method_call(recv) {
-                    Some(("map", recv, [map_arg], _))
+                    Some(("map", recv, [map_arg], _, _))
                         if map_unwrap_or::check(cx, expr, recv, map_arg, u_arg, self.msrv) => {},
                     _ => {
                         unwrap_or_else_default::check(cx, expr, recv, u_arg);
@@ -3782,7 +3783,7 @@ impl Methods {
 }
 
 fn check_is_some_is_none(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'_>, is_some: bool) {
-    if let Some((name @ ("find" | "position" | "rposition"), f_recv, [arg], span)) = method_call(recv) {
+    if let Some((name @ ("find" | "position" | "rposition"), f_recv, [arg], span, _)) = method_call(recv) {
         search_is_some::check(cx, expr, name, is_some, f_recv, arg, recv, span);
     }
 }
diff --git a/clippy_lints/src/methods/needless_collect.rs b/clippy_lints/src/methods/needless_collect.rs
index 66f9e28596e..b088e642e0e 100644
--- a/clippy_lints/src/methods/needless_collect.rs
+++ b/clippy_lints/src/methods/needless_collect.rs
@@ -3,94 +3,99 @@ use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_hir_and_then};
 use clippy_utils::higher;
 use clippy_utils::source::{snippet, snippet_with_applicability};
 use clippy_utils::sugg::Sugg;
-use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{can_move_expr_to_closure, is_trait_method, path_to_local, path_to_local_id, CaptureKind};
-use if_chain::if_chain;
+use clippy_utils::ty::{is_type_diagnostic_item, make_normalized_projection, make_projection};
+use clippy_utils::{
+    can_move_expr_to_closure, get_enclosing_block, get_parent_node, is_trait_method, path_to_local, path_to_local_id,
+    CaptureKind,
+};
 use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::{Applicability, MultiSpan};
 use rustc_hir::intravisit::{walk_block, walk_expr, Visitor};
-use rustc_hir::{Block, Expr, ExprKind, HirId, HirIdSet, Local, Mutability, Node, PatKind, Stmt, StmtKind};
+use rustc_hir::{
+    BindingAnnotation, Block, Expr, ExprKind, HirId, HirIdSet, Local, Mutability, Node, PatKind, Stmt, StmtKind,
+};
 use rustc_lint::LateContext;
 use rustc_middle::hir::nested_filter;
-use rustc_middle::ty::subst::GenericArgKind;
-use rustc_middle::ty::{self, Ty};
-use rustc_span::sym;
-use rustc_span::Span;
+use rustc_middle::ty::{self, AssocKind, EarlyBinder, GenericArg, GenericArgKind, Ty};
+use rustc_span::symbol::Ident;
+use rustc_span::{sym, Span, Symbol};
 
 const NEEDLESS_COLLECT_MSG: &str = "avoid using `collect()` when not needed";
 
-pub(super) fn check<'tcx>(expr: &'tcx Expr<'_>, cx: &LateContext<'tcx>) {
-    check_needless_collect_direct_usage(expr, cx);
-    check_needless_collect_indirect_usage(expr, cx);
-}
-fn check_needless_collect_direct_usage<'tcx>(expr: &'tcx Expr<'_>, cx: &LateContext<'tcx>) {
-    if_chain! {
-        if let ExprKind::MethodCall(method, receiver, args, _) = expr.kind;
-        if let ExprKind::MethodCall(chain_method, ..) = receiver.kind;
-        if chain_method.ident.name == sym!(collect) && is_trait_method(cx, receiver, sym::Iterator);
-        then {
-            let ty = cx.typeck_results().expr_ty(receiver);
-            let mut applicability = Applicability::MaybeIncorrect;
-            let is_empty_sugg = "next().is_none()".to_string();
-            let method_name = method.ident.name.as_str();
-            let sugg = if is_type_diagnostic_item(cx, ty, sym::Vec) ||
-                        is_type_diagnostic_item(cx, ty, sym::VecDeque) ||
-                        is_type_diagnostic_item(cx, ty, sym::LinkedList) ||
-                        is_type_diagnostic_item(cx, ty, sym::BinaryHeap) {
-                match method_name {
-                    "len" => "count()".to_string(),
-                    "is_empty" => is_empty_sugg,
-                    "contains" => {
-                        let contains_arg = snippet_with_applicability(cx, args[0].span, "??", &mut applicability);
-                        let (arg, pred) = contains_arg
-                            .strip_prefix('&')
-                            .map_or(("&x", &*contains_arg), |s| ("x", s));
-                        format!("any(|{arg}| x == {pred})")
-                    }
-                    _ => return,
-                }
-            }
-            else if is_type_diagnostic_item(cx, ty, sym::BTreeMap) ||
-                is_type_diagnostic_item(cx, ty, sym::HashMap) {
-                match method_name {
-                    "is_empty" => is_empty_sugg,
-                    _ => return,
-                }
-            }
-            else {
-                return;
-            };
-            span_lint_and_sugg(
-                cx,
-                NEEDLESS_COLLECT,
-                chain_method.ident.span.with_hi(expr.span.hi()),
-                NEEDLESS_COLLECT_MSG,
-                "replace with",
-                sugg,
-                applicability,
-            );
-        }
-    }
-}
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    name_span: Span,
+    collect_expr: &'tcx Expr<'_>,
+    iter_expr: &'tcx Expr<'tcx>,
+    call_span: Span,
+) {
+    if let Some(parent) = get_parent_node(cx.tcx, collect_expr.hir_id) {
+        match parent {
+            Node::Expr(parent) => {
+                if let ExprKind::MethodCall(name, _, args @ ([] | [_]), _) = parent.kind {
+                    let mut app = Applicability::MachineApplicable;
+                    let name = name.ident.as_str();
+                    let collect_ty = cx.typeck_results().expr_ty(collect_expr);
 
-fn check_needless_collect_indirect_usage<'tcx>(expr: &'tcx Expr<'_>, cx: &LateContext<'tcx>) {
-    if let ExprKind::Block(block, _) = expr.kind {
-        for stmt in block.stmts {
-            if_chain! {
-                if let StmtKind::Local(local) = stmt.kind;
-                if let PatKind::Binding(_, id, ..) = local.pat.kind;
-                if let Some(init_expr) = local.init;
-                if let ExprKind::MethodCall(method_name, iter_source, [], ..) = init_expr.kind;
-                if method_name.ident.name == sym!(collect) && is_trait_method(cx, init_expr, sym::Iterator);
-                let ty = cx.typeck_results().expr_ty(init_expr);
-                if is_type_diagnostic_item(cx, ty, sym::Vec) ||
-                    is_type_diagnostic_item(cx, ty, sym::VecDeque) ||
-                    is_type_diagnostic_item(cx, ty, sym::BinaryHeap) ||
-                    is_type_diagnostic_item(cx, ty, sym::LinkedList);
-                let iter_ty = cx.typeck_results().expr_ty(iter_source);
-                if let Some(iter_calls) = detect_iter_and_into_iters(block, id, cx, get_captured_ids(cx, iter_ty));
-                if let [iter_call] = &*iter_calls;
-                then {
+                    let sugg: String = match name {
+                        "len" => {
+                            if let Some(adt) = collect_ty.ty_adt_def()
+                                && matches!(
+                                    cx.tcx.get_diagnostic_name(adt.did()),
+                                    Some(sym::Vec | sym::VecDeque | sym::LinkedList | sym::BinaryHeap)
+                                )
+                            {
+                                "count()".into()
+                            } else {
+                                return;
+                            }
+                        },
+                        "is_empty"
+                            if is_is_empty_sig(cx, parent.hir_id)
+                                && iterates_same_ty(cx, cx.typeck_results().expr_ty(iter_expr), collect_ty) =>
+                        {
+                            "next().is_none()".into()
+                        },
+                        "contains" => {
+                            if is_contains_sig(cx, parent.hir_id, iter_expr)
+                                && let Some(arg) = args.first()
+                            {
+                                let (span, prefix) = if let ExprKind::AddrOf(_, _, arg) = arg.kind {
+                                    (arg.span, "")
+                                } else {
+                                    (arg.span, "*")
+                                };
+                                let snip = snippet_with_applicability(cx, span, "??", &mut app);
+                                format!("any(|x| x == {prefix}{snip})")
+                            } else {
+                                return;
+                            }
+                        },
+                        _ => return,
+                    };
+
+                    span_lint_and_sugg(
+                        cx,
+                        NEEDLESS_COLLECT,
+                        call_span.with_hi(parent.span.hi()),
+                        NEEDLESS_COLLECT_MSG,
+                        "replace with",
+                        sugg,
+                        app,
+                    );
+                }
+            },
+            Node::Local(l) => {
+                if let PatKind::Binding(BindingAnnotation::NONE | BindingAnnotation::MUT, id, _, None)
+                    = l.pat.kind
+                    && let ty = cx.typeck_results().expr_ty(collect_expr)
+                    && [sym::Vec, sym::VecDeque, sym::BinaryHeap, sym::LinkedList].into_iter()
+                        .any(|item| is_type_diagnostic_item(cx, ty, item))
+                    && let iter_ty = cx.typeck_results().expr_ty(iter_expr)
+                    && let Some(block) = get_enclosing_block(cx, l.hir_id)
+                    && let Some(iter_calls) = detect_iter_and_into_iters(block, id, cx, get_captured_ids(cx, iter_ty))
+                    && let [iter_call] = &*iter_calls
+                {
                     let mut used_count_visitor = UsedCountVisitor {
                         cx,
                         id,
@@ -102,20 +107,20 @@ fn check_needless_collect_indirect_usage<'tcx>(expr: &'tcx Expr<'_>, cx: &LateCo
                     }
 
                     // Suggest replacing iter_call with iter_replacement, and removing stmt
-                    let mut span = MultiSpan::from_span(method_name.ident.span);
+                    let mut span = MultiSpan::from_span(name_span);
                     span.push_span_label(iter_call.span, "the iterator could be used here instead");
                     span_lint_hir_and_then(
                         cx,
                         super::NEEDLESS_COLLECT,
-                        init_expr.hir_id,
+                        collect_expr.hir_id,
                         span,
                         NEEDLESS_COLLECT_MSG,
                         |diag| {
-                            let iter_replacement = format!("{}{}", Sugg::hir(cx, iter_source, ".."), iter_call.get_iter_method(cx));
+                            let iter_replacement = format!("{}{}", Sugg::hir(cx, iter_expr, ".."), iter_call.get_iter_method(cx));
                             diag.multipart_suggestion(
                                 iter_call.get_suggestion_text(),
                                 vec![
-                                    (stmt.span, String::new()),
+                                    (l.span, String::new()),
                                     (iter_call.span, iter_replacement)
                                 ],
                                 Applicability::MaybeIncorrect,
@@ -123,11 +128,61 @@ fn check_needless_collect_indirect_usage<'tcx>(expr: &'tcx Expr<'_>, cx: &LateCo
                         },
                     );
                 }
-            }
+            },
+            _ => (),
         }
     }
 }
 
+/// Checks if the given method call matches the expected signature of `([&[mut]] self) -> bool`
+fn is_is_empty_sig(cx: &LateContext<'_>, call_id: HirId) -> bool {
+    cx.typeck_results().type_dependent_def_id(call_id).map_or(false, |id| {
+        let sig = cx.tcx.fn_sig(id).skip_binder();
+        sig.inputs().len() == 1 && sig.output().is_bool()
+    })
+}
+
+/// Checks if `<iter_ty as Iterator>::Item` is the same as `<collect_ty as IntoIter>::Item`
+fn iterates_same_ty<'tcx>(cx: &LateContext<'tcx>, iter_ty: Ty<'tcx>, collect_ty: Ty<'tcx>) -> bool {
+    let item = Symbol::intern("Item");
+    if let Some(iter_trait) = cx.tcx.get_diagnostic_item(sym::Iterator)
+        && let Some(into_iter_trait) = cx.tcx.get_diagnostic_item(sym::IntoIterator)
+        && let Some(iter_item_ty) = make_normalized_projection(cx.tcx, cx.param_env, iter_trait, item, [iter_ty])
+        && let Some(into_iter_item_proj) = make_projection(cx.tcx, into_iter_trait, item, [collect_ty])
+        && let Ok(into_iter_item_ty) = cx.tcx.try_normalize_erasing_regions(
+            cx.param_env,
+            cx.tcx.mk_projection(into_iter_item_proj.item_def_id, into_iter_item_proj.substs)
+        )
+    {
+        iter_item_ty == into_iter_item_ty
+    } else {
+        false
+    }
+}
+
+/// Checks if the given method call matches the expected signature of
+/// `([&[mut]] self, &<iter_ty as Iterator>::Item) -> bool`
+fn is_contains_sig(cx: &LateContext<'_>, call_id: HirId, iter_expr: &Expr<'_>) -> bool {
+    let typeck = cx.typeck_results();
+    if let Some(id) = typeck.type_dependent_def_id(call_id)
+        && let sig = cx.tcx.fn_sig(id)
+        && sig.skip_binder().output().is_bool()
+        && let [_, search_ty] = *sig.skip_binder().inputs()
+        && let ty::Ref(_, search_ty, Mutability::Not) = *cx.tcx.erase_late_bound_regions(sig.rebind(search_ty)).kind()
+        && let Some(iter_trait) = cx.tcx.get_diagnostic_item(sym::Iterator)
+        && let Some(iter_item) = cx.tcx
+            .associated_items(iter_trait)
+            .find_by_name_and_kind(cx.tcx, Ident::with_dummy_span(Symbol::intern("Item")), AssocKind::Type, iter_trait)
+        && let substs = cx.tcx.mk_substs([GenericArg::from(typeck.expr_ty_adjusted(iter_expr))].into_iter())
+        && let proj_ty = cx.tcx.mk_projection(iter_item.def_id, substs)
+        && let Ok(item_ty) = cx.tcx.try_normalize_erasing_regions(cx.param_env, proj_ty)
+    {
+        item_ty == EarlyBinder(search_ty).subst(cx.tcx, cx.typeck_results().node_substs(call_id))
+    } else {
+        false
+    }
+}
+
 struct IterFunction {
     func: IterFunctionKind,
     span: Span,
diff --git a/clippy_utils/src/ty.rs b/clippy_utils/src/ty.rs
index 2dd8c826ab3..a022aac4bfe 100644
--- a/clippy_utils/src/ty.rs
+++ b/clippy_utils/src/ty.rs
@@ -13,8 +13,9 @@ use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::LateContext;
 use rustc_middle::mir::interpret::{ConstValue, Scalar};
 use rustc_middle::ty::{
-    self, AdtDef, Binder, BoundRegion, DefIdTree, FnSig, IntTy, ParamEnv, Predicate, PredicateKind, ProjectionTy,
-    Region, RegionKind, Ty, TyCtxt, TypeSuperVisitable, TypeVisitable, TypeVisitor, UintTy, VariantDef, VariantDiscr,
+    self, AdtDef, AssocKind, Binder, BoundRegion, DefIdTree, FnSig, GenericParamDefKind, IntTy, ParamEnv, Predicate,
+    PredicateKind, ProjectionTy, Region, RegionKind, SubstsRef, Ty, TyCtxt, TypeSuperVisitable, TypeVisitable,
+    TypeVisitor, UintTy, VariantDef, VariantDiscr,
 };
 use rustc_middle::ty::{GenericArg, GenericArgKind};
 use rustc_span::symbol::Ident;
@@ -938,3 +939,132 @@ pub fn approx_ty_size<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> u64 {
         (Err(_), _) => 0,
     }
 }
+
+/// Makes the projection type for the named associated type in the given impl or trait impl.
+///
+/// This function is for associated types which are "known" to exist, and as such, will only return
+/// `None` when debug assertions are disabled in order to prevent ICE's. With debug assertions
+/// enabled this will check that the named associated type exists, the correct number of
+/// substitutions are given, and that the correct kinds of substitutions are given (lifetime,
+/// constant or type). This will not check if type normalization would succeed.
+pub fn make_projection<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    container_id: DefId,
+    assoc_ty: Symbol,
+    substs: impl IntoIterator<Item = impl Into<GenericArg<'tcx>>>,
+) -> Option<ProjectionTy<'tcx>> {
+    fn helper<'tcx>(
+        tcx: TyCtxt<'tcx>,
+        container_id: DefId,
+        assoc_ty: Symbol,
+        substs: SubstsRef<'tcx>,
+    ) -> Option<ProjectionTy<'tcx>> {
+        let Some(assoc_item) = tcx
+            .associated_items(container_id)
+            .find_by_name_and_kind(tcx, Ident::with_dummy_span(assoc_ty), AssocKind::Type, container_id)
+        else {
+            debug_assert!(false, "type `{assoc_ty}` not found in `{container_id:?}`");
+            return None;
+        };
+        #[cfg(debug_assertions)]
+        {
+            let generics = tcx.generics_of(assoc_item.def_id);
+            let generic_count = generics.parent_count + generics.params.len();
+            let params = generics
+                .parent
+                .map_or([].as_slice(), |id| &*tcx.generics_of(id).params)
+                .iter()
+                .chain(&generics.params)
+                .map(|x| &x.kind);
+
+            debug_assert!(
+                generic_count == substs.len(),
+                "wrong number of substs for `{:?}`: found `{}` expected `{}`.\n\
+                    note: the expected parameters are: {:#?}\n\
+                    the given arguments are: `{:#?}`",
+                assoc_item.def_id,
+                substs.len(),
+                generic_count,
+                params.map(GenericParamDefKind::descr).collect::<Vec<_>>(),
+                substs,
+            );
+
+            if let Some((idx, (param, arg))) = params
+                .clone()
+                .zip(substs.iter().map(GenericArg::unpack))
+                .enumerate()
+                .find(|(_, (param, arg))| {
+                    !matches!(
+                        (param, arg),
+                        (GenericParamDefKind::Lifetime, GenericArgKind::Lifetime(_))
+                            | (GenericParamDefKind::Type { .. }, GenericArgKind::Type(_))
+                            | (GenericParamDefKind::Const { .. }, GenericArgKind::Const(_))
+                    )
+                })
+            {
+                debug_assert!(
+                    false,
+                    "mismatched subst type at index {}: expected a {}, found `{:?}`\n\
+                        note: the expected parameters are {:#?}\n\
+                        the given arguments are {:#?}",
+                    idx,
+                    param.descr(),
+                    arg,
+                    params.map(GenericParamDefKind::descr).collect::<Vec<_>>(),
+                    substs,
+                );
+            }
+        }
+
+        Some(ProjectionTy {
+            substs,
+            item_def_id: assoc_item.def_id,
+        })
+    }
+    helper(
+        tcx,
+        container_id,
+        assoc_ty,
+        tcx.mk_substs(substs.into_iter().map(Into::into)),
+    )
+}
+
+/// Normalizes the named associated type in the given impl or trait impl.
+///
+/// This function is for associated types which are "known" to be valid with the given
+/// substitutions, and as such, will only return `None` when debug assertions are disabled in order
+/// to prevent ICE's. With debug assertions enabled this will check that that type normalization
+/// succeeds as well as everything checked by `make_projection`.
+pub fn make_normalized_projection<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    param_env: ParamEnv<'tcx>,
+    container_id: DefId,
+    assoc_ty: Symbol,
+    substs: impl IntoIterator<Item = impl Into<GenericArg<'tcx>>>,
+) -> Option<Ty<'tcx>> {
+    fn helper<'tcx>(tcx: TyCtxt<'tcx>, param_env: ParamEnv<'tcx>, ty: ProjectionTy<'tcx>) -> Option<Ty<'tcx>> {
+        #[cfg(debug_assertions)]
+        if let Some((i, subst)) = ty
+            .substs
+            .iter()
+            .enumerate()
+            .find(|(_, subst)| subst.has_late_bound_regions())
+        {
+            debug_assert!(
+                false,
+                "substs contain late-bound region at index `{i}` which can't be normalized.\n\
+                    use `TyCtxt::erase_late_bound_regions`\n\
+                    note: subst is `{subst:#?}`",
+            );
+            return None;
+        }
+        match tcx.try_normalize_erasing_regions(param_env, tcx.mk_projection(ty.item_def_id, ty.substs)) {
+            Ok(ty) => Some(ty),
+            Err(e) => {
+                debug_assert!(false, "failed to normalize type `{ty}`: {e:#?}");
+                None
+            },
+        }
+    }
+    helper(tcx, param_env, make_projection(tcx, container_id, assoc_ty, substs)?)
+}
diff --git a/tests/ui/needless_collect.fixed b/tests/ui/needless_collect.fixed
index 6ecbbcb6249..2659ad38488 100644
--- a/tests/ui/needless_collect.fixed
+++ b/tests/ui/needless_collect.fixed
@@ -33,4 +33,33 @@ fn main() {
     // `BinaryHeap` doesn't have `contains` method
     sample.iter().count();
     sample.iter().next().is_none();
+
+    // Don't lint string from str
+    let _ = ["", ""].into_iter().collect::<String>().is_empty();
+
+    let _ = sample.iter().next().is_none();
+    let _ = sample.iter().any(|x| x == &0);
+
+    struct VecWrapper<T>(Vec<T>);
+    impl<T> core::ops::Deref for VecWrapper<T> {
+        type Target = Vec<T>;
+        fn deref(&self) -> &Self::Target {
+            &self.0
+        }
+    }
+    impl<T> IntoIterator for VecWrapper<T> {
+        type IntoIter = <Vec<T> as IntoIterator>::IntoIter;
+        type Item = <Vec<T> as IntoIterator>::Item;
+        fn into_iter(self) -> Self::IntoIter {
+            self.0.into_iter()
+        }
+    }
+    impl<T> FromIterator<T> for VecWrapper<T> {
+        fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
+            Self(Vec::from_iter(iter))
+        }
+    }
+
+    let _ = sample.iter().next().is_none();
+    let _ = sample.iter().any(|x| x == &0);
 }
diff --git a/tests/ui/needless_collect.rs b/tests/ui/needless_collect.rs
index 8dc69bcf5b3..535ec82982b 100644
--- a/tests/ui/needless_collect.rs
+++ b/tests/ui/needless_collect.rs
@@ -33,4 +33,33 @@ fn main() {
     // `BinaryHeap` doesn't have `contains` method
     sample.iter().collect::<BinaryHeap<_>>().len();
     sample.iter().collect::<BinaryHeap<_>>().is_empty();
+
+    // Don't lint string from str
+    let _ = ["", ""].into_iter().collect::<String>().is_empty();
+
+    let _ = sample.iter().collect::<HashSet<_>>().is_empty();
+    let _ = sample.iter().collect::<HashSet<_>>().contains(&&0);
+
+    struct VecWrapper<T>(Vec<T>);
+    impl<T> core::ops::Deref for VecWrapper<T> {
+        type Target = Vec<T>;
+        fn deref(&self) -> &Self::Target {
+            &self.0
+        }
+    }
+    impl<T> IntoIterator for VecWrapper<T> {
+        type IntoIter = <Vec<T> as IntoIterator>::IntoIter;
+        type Item = <Vec<T> as IntoIterator>::Item;
+        fn into_iter(self) -> Self::IntoIter {
+            self.0.into_iter()
+        }
+    }
+    impl<T> FromIterator<T> for VecWrapper<T> {
+        fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
+            Self(Vec::from_iter(iter))
+        }
+    }
+
+    let _ = sample.iter().collect::<VecWrapper<_>>().is_empty();
+    let _ = sample.iter().collect::<VecWrapper<_>>().contains(&&0);
 }
diff --git a/tests/ui/needless_collect.stderr b/tests/ui/needless_collect.stderr
index 039091627a8..584d2a1d835 100644
--- a/tests/ui/needless_collect.stderr
+++ b/tests/ui/needless_collect.stderr
@@ -66,5 +66,29 @@ error: avoid using `collect()` when not needed
 LL |     sample.iter().collect::<BinaryHeap<_>>().is_empty();
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `next().is_none()`
 
-error: aborting due to 11 previous errors
+error: avoid using `collect()` when not needed
+  --> $DIR/needless_collect.rs:40:27
+   |
+LL |     let _ = sample.iter().collect::<HashSet<_>>().is_empty();
+   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `next().is_none()`
+
+error: avoid using `collect()` when not needed
+  --> $DIR/needless_collect.rs:41:27
+   |
+LL |     let _ = sample.iter().collect::<HashSet<_>>().contains(&&0);
+   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `any(|x| x == &0)`
+
+error: avoid using `collect()` when not needed
+  --> $DIR/needless_collect.rs:63:27
+   |
+LL |     let _ = sample.iter().collect::<VecWrapper<_>>().is_empty();
+   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `next().is_none()`
+
+error: avoid using `collect()` when not needed
+  --> $DIR/needless_collect.rs:64:27
+   |
+LL |     let _ = sample.iter().collect::<VecWrapper<_>>().contains(&&0);
+   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `any(|x| x == &0)`
+
+error: aborting due to 15 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 5b1e445b9abff4f9eec0c5911389913108f7ba93 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Mon, 7 Nov 2022 14:08:40 -0500
Subject: Don't lint `explicit_auto_deref` when the target type is a projection
 containing a generic argument

---
 clippy_lints/src/dereference.rs    |  1 +
 tests/ui/explicit_auto_deref.fixed | 11 +++++++++++
 tests/ui/explicit_auto_deref.rs    | 11 +++++++++++
 3 files changed, 23 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index 86e7bc2e6d1..e2624ee80c0 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -1362,6 +1362,7 @@ fn ty_auto_deref_stability<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>, precedenc
                 continue;
             },
             ty::Param(_) => TyPosition::new_deref_stable_for_result(precedence, ty),
+            ty::Projection(_) if ty.has_non_region_param() => TyPosition::new_deref_stable_for_result(precedence, ty),
             ty::Infer(_) | ty::Error(_) | ty::Bound(..) | ty::Opaque(..) | ty::Placeholder(_) | ty::Dynamic(..) => {
                 Position::ReborrowStable(precedence).into()
             },
diff --git a/tests/ui/explicit_auto_deref.fixed b/tests/ui/explicit_auto_deref.fixed
index d1d35e5c0eb..59ff5e4040a 100644
--- a/tests/ui/explicit_auto_deref.fixed
+++ b/tests/ui/explicit_auto_deref.fixed
@@ -266,4 +266,15 @@ fn main() {
         }
         x
     };
+
+    trait WithAssoc {
+        type Assoc: ?Sized;
+    }
+    impl WithAssoc for String {
+        type Assoc = str;
+    }
+    fn takes_assoc<T: WithAssoc>(_: &T::Assoc) -> T {
+        unimplemented!()
+    }
+    let _: String = takes_assoc(&*String::new());
 }
diff --git a/tests/ui/explicit_auto_deref.rs b/tests/ui/explicit_auto_deref.rs
index deedafad153..bcfb60c3278 100644
--- a/tests/ui/explicit_auto_deref.rs
+++ b/tests/ui/explicit_auto_deref.rs
@@ -266,4 +266,15 @@ fn main() {
         }
         *x
     };
+
+    trait WithAssoc {
+        type Assoc: ?Sized;
+    }
+    impl WithAssoc for String {
+        type Assoc = str;
+    }
+    fn takes_assoc<T: WithAssoc>(_: &T::Assoc) -> T {
+        unimplemented!()
+    }
+    let _: String = takes_assoc(&*String::new());
 }
-- 
cgit 1.4.1-3-g733a5


From 3d4b73c26da1630318e76f43a7dedfc4dbc716cd Mon Sep 17 00:00:00 2001
From: kraktus <kraktus@users.noreply.github.com>
Date: Mon, 7 Nov 2022 21:00:37 +0100
Subject: [`excessive_bools`] lint trait functions even without bodies

---
 clippy_lints/src/excessive_bools.rs       | 14 +++++++++++---
 tests/ui/fn_params_excessive_bools.rs     |  2 ++
 tests/ui/fn_params_excessive_bools.stderr | 24 ++++++++++++++++++++----
 3 files changed, 33 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/excessive_bools.rs b/clippy_lints/src/excessive_bools.rs
index 68c5e5ab1f1..fc2912f696e 100644
--- a/clippy_lints/src/excessive_bools.rs
+++ b/clippy_lints/src/excessive_bools.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::{get_parent_as_impl, has_repr_attr, is_bool};
 use rustc_hir::intravisit::FnKind;
-use rustc_hir::{Body, FnDecl, HirId, Item, ItemKind, Ty};
+use rustc_hir::{Body, FnDecl, HirId, Item, ItemKind, TraitFn, TraitItem, TraitItemKind, Ty};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::Span;
@@ -114,7 +114,7 @@ impl ExcessiveBools {
     }
 
     fn check_fn_sig(&self, cx: &LateContext<'_>, fn_decl: &FnDecl<'_>, span: Span) {
-        if self.too_many_bools(fn_decl.inputs.iter(), Kind::Fn) {
+        if !span.from_expansion() && self.too_many_bools(fn_decl.inputs.iter(), Kind::Fn) {
             span_lint_and_help(
                 cx,
                 FN_PARAMS_EXCESSIVE_BOOLS,
@@ -152,6 +152,15 @@ impl<'tcx> LateLintPass<'tcx> for ExcessiveBools {
         }
     }
 
+    fn check_trait_item(&mut self, cx: &LateContext<'tcx>, trait_item: &'tcx TraitItem<'tcx>) {
+        // functions with a body are already checked by `check_fn`
+        if let TraitItemKind::Fn(fn_sig, TraitFn::Required(_)) = &trait_item.kind
+            && fn_sig.header.abi == Abi::Rust
+            {
+            self.check_fn_sig(cx, fn_sig.decl, fn_sig.span);
+        }
+    }
+
     fn check_fn(
         &mut self,
         cx: &LateContext<'tcx>,
@@ -163,7 +172,6 @@ impl<'tcx> LateLintPass<'tcx> for ExcessiveBools {
     ) {
         if let Some(fn_header) = fn_kind.header()
             && fn_header.abi == Abi::Rust
-            && !span.from_expansion()
             && get_parent_as_impl(cx.tcx, hir_id)
                 .map_or(true,
                     |impl_item| impl_item.of_trait.is_none()
diff --git a/tests/ui/fn_params_excessive_bools.rs b/tests/ui/fn_params_excessive_bools.rs
index 7995912110d..f53e531629a 100644
--- a/tests/ui/fn_params_excessive_bools.rs
+++ b/tests/ui/fn_params_excessive_bools.rs
@@ -23,10 +23,12 @@ fn t(_: S, _: S, _: Box<S>, _: Vec<u32>, _: bool, _: bool, _: bool, _: bool) {}
 
 struct S;
 trait Trait {
+    // should warn for trait functions with and without body
     fn f(_: bool, _: bool, _: bool, _: bool);
     fn g(_: bool, _: bool, _: bool, _: Vec<u32>);
     #[allow(clippy::fn_params_excessive_bools)]
     fn h(_: bool, _: bool, _: bool, _: bool, _: bool, _: bool);
+    fn i(_: bool, _: bool, _: bool, _: bool) {}
 }
 
 impl S {
diff --git a/tests/ui/fn_params_excessive_bools.stderr b/tests/ui/fn_params_excessive_bools.stderr
index 8c2383873fe..43363b46972 100644
--- a/tests/ui/fn_params_excessive_bools.stderr
+++ b/tests/ui/fn_params_excessive_bools.stderr
@@ -16,7 +16,23 @@ LL | fn t(_: S, _: S, _: Box<S>, _: Vec<u32>, _: bool, _: bool, _: bool, _: bool
    = help: consider refactoring bools into two-variant enums
 
 error: more than 3 bools in function parameters
-  --> $DIR/fn_params_excessive_bools.rs:33:5
+  --> $DIR/fn_params_excessive_bools.rs:27:5
+   |
+LL |     fn f(_: bool, _: bool, _: bool, _: bool);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider refactoring bools into two-variant enums
+
+error: more than 3 bools in function parameters
+  --> $DIR/fn_params_excessive_bools.rs:31:5
+   |
+LL |     fn i(_: bool, _: bool, _: bool, _: bool) {}
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider refactoring bools into two-variant enums
+
+error: more than 3 bools in function parameters
+  --> $DIR/fn_params_excessive_bools.rs:35:5
    |
 LL |     fn f(&self, _: bool, _: bool, _: bool, _: bool) {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -24,7 +40,7 @@ LL |     fn f(&self, _: bool, _: bool, _: bool, _: bool) {}
    = help: consider refactoring bools into two-variant enums
 
 error: more than 3 bools in function parameters
-  --> $DIR/fn_params_excessive_bools.rs:48:5
+  --> $DIR/fn_params_excessive_bools.rs:50:5
    |
 LL | /     fn n(_: bool, _: u32, _: bool, _: Box<u32>, _: bool, _: bool) {
 LL | |         fn nn(_: bool, _: bool, _: bool, _: bool) {}
@@ -34,12 +50,12 @@ LL | |     }
    = help: consider refactoring bools into two-variant enums
 
 error: more than 3 bools in function parameters
-  --> $DIR/fn_params_excessive_bools.rs:49:9
+  --> $DIR/fn_params_excessive_bools.rs:51:9
    |
 LL |         fn nn(_: bool, _: bool, _: bool, _: bool) {}
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: consider refactoring bools into two-variant enums
 
-error: aborting due to 5 previous errors
+error: aborting due to 7 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 80e5856b02060f1185b5976b515eeada18811756 Mon Sep 17 00:00:00 2001
From: Elliot Bobrow <elliotgreybobrow@gmail.com>
Date: Sun, 16 Oct 2022 11:37:26 -0700
Subject: `result_large_err` show largest variants in err msg

---
 clippy_lints/src/functions/result.rs   | 68 +++++++++++++++++++++++++++-------
 clippy_lints/src/large_enum_variant.rs | 60 +++++-------------------------
 clippy_utils/src/ty.rs                 | 42 +++++++++++++++++++--
 tests/ui/result_large_err.rs           | 12 ++++++
 tests/ui/result_large_err.stderr       | 30 +++++++++++----
 5 files changed, 138 insertions(+), 74 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/functions/result.rs b/clippy_lints/src/functions/result.rs
index 113c4e9f509..3e288467ba1 100644
--- a/clippy_lints/src/functions/result.rs
+++ b/clippy_lints/src/functions/result.rs
@@ -2,12 +2,12 @@ use rustc_errors::Diagnostic;
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_middle::ty::{self, Ty};
+use rustc_middle::ty::{self, Adt, Ty};
 use rustc_span::{sym, Span};
 
 use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_then};
 use clippy_utils::trait_ref_of_method;
-use clippy_utils::ty::{approx_ty_size, is_type_diagnostic_item};
+use clippy_utils::ty::{approx_ty_size, is_type_diagnostic_item, AdtVariantInfo};
 
 use super::{RESULT_LARGE_ERR, RESULT_UNIT_ERR};
 
@@ -84,17 +84,57 @@ fn check_result_unit_err(cx: &LateContext<'_>, err_ty: Ty<'_>, fn_header_span: S
 }
 
 fn check_result_large_err<'tcx>(cx: &LateContext<'tcx>, err_ty: Ty<'tcx>, hir_ty_span: Span, large_err_threshold: u64) {
-    let ty_size = approx_ty_size(cx, err_ty);
-    if ty_size >= large_err_threshold {
-        span_lint_and_then(
-            cx,
-            RESULT_LARGE_ERR,
-            hir_ty_span,
-            "the `Err`-variant returned from this function is very large",
-            |diag: &mut Diagnostic| {
-                diag.span_label(hir_ty_span, format!("the `Err`-variant is at least {ty_size} bytes"));
-                diag.help(format!("try reducing the size of `{err_ty}`, for example by boxing large elements or replacing it with `Box<{err_ty}>`"));
-            },
-        );
+    if_chain! {
+        if let Adt(adt, subst) = err_ty.kind();
+        if let Some(local_def_id) = err_ty.ty_adt_def().expect("already checked this is adt").did().as_local();
+        if let Some(hir::Node::Item(item)) = cx
+            .tcx
+            .hir()
+            .find_by_def_id(local_def_id);
+        if let hir::ItemKind::Enum(ref def, _) = item.kind;
+        then {
+            let variants_size = AdtVariantInfo::new(cx, *adt, subst);
+            if variants_size[0].size >= large_err_threshold {
+                span_lint_and_then(
+                    cx,
+                    RESULT_LARGE_ERR,
+                    hir_ty_span,
+                    "the `Err`-variant returned from this function is very large",
+                    |diag| {
+                        diag.span_label(
+                            def.variants[variants_size[0].ind].span,
+                            format!("the largest variant contains at least {} bytes", variants_size[0].size),
+                        );
+
+                        for variant in &variants_size[1..] {
+                            if variant.size >= large_err_threshold {
+                                let variant_def = &def.variants[variant.ind];
+                                diag.span_label(
+                                    variant_def.span,
+                                    format!("the variant `{}` contains at least {} bytes", variant_def.ident, variant.size),
+                                );
+                            }
+                        }
+
+                        diag.help(format!("try reducing the size of `{err_ty}`, for example by boxing large elements or replacing it with `Box<{err_ty}>`"));
+                    }
+                );
+            }
+        }
+        else {
+            let ty_size = approx_ty_size(cx, err_ty);
+            if ty_size >= large_err_threshold {
+                span_lint_and_then(
+                    cx,
+                    RESULT_LARGE_ERR,
+                    hir_ty_span,
+                    "the `Err`-variant returned from this function is very large",
+                    |diag: &mut Diagnostic| {
+                        diag.span_label(hir_ty_span, format!("the `Err`-variant is at least {ty_size} bytes"));
+                        diag.help(format!("try reducing the size of `{err_ty}`, for example by boxing large elements or replacing it with `Box<{err_ty}>`"));
+                    },
+                );
+            }
+        }
     }
 }
diff --git a/clippy_lints/src/large_enum_variant.rs b/clippy_lints/src/large_enum_variant.rs
index 8ed7e4bb196..fd82d9f80f9 100644
--- a/clippy_lints/src/large_enum_variant.rs
+++ b/clippy_lints/src/large_enum_variant.rs
@@ -1,12 +1,15 @@
 //! lint when there is a large size difference between variants on an enum
 
 use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::{diagnostics::span_lint_and_then, ty::approx_ty_size, ty::is_copy};
+use clippy_utils::{
+    diagnostics::span_lint_and_then,
+    ty::{approx_ty_size, is_copy, AdtVariantInfo},
+};
 use rustc_errors::Applicability;
 use rustc_hir::{Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::lint::in_external_macro;
-use rustc_middle::ty::{Adt, AdtDef, GenericArg, List, Ty};
+use rustc_middle::ty::{Adt, Ty};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::Span;
 
@@ -72,49 +75,6 @@ impl LargeEnumVariant {
     }
 }
 
-struct FieldInfo {
-    ind: usize,
-    size: u64,
-}
-
-struct VariantInfo {
-    ind: usize,
-    size: u64,
-    fields_size: Vec<FieldInfo>,
-}
-
-fn variants_size<'tcx>(
-    cx: &LateContext<'tcx>,
-    adt: AdtDef<'tcx>,
-    subst: &'tcx List<GenericArg<'tcx>>,
-) -> Vec<VariantInfo> {
-    let mut variants_size = adt
-        .variants()
-        .iter()
-        .enumerate()
-        .map(|(i, variant)| {
-            let mut fields_size = variant
-                .fields
-                .iter()
-                .enumerate()
-                .map(|(i, f)| FieldInfo {
-                    ind: i,
-                    size: approx_ty_size(cx, f.ty(cx.tcx, subst)),
-                })
-                .collect::<Vec<_>>();
-            fields_size.sort_by(|a, b| (a.size.cmp(&b.size)));
-
-            VariantInfo {
-                ind: i,
-                size: fields_size.iter().map(|info| info.size).sum(),
-                fields_size,
-            }
-        })
-        .collect::<Vec<_>>();
-    variants_size.sort_by(|a, b| (b.size.cmp(&a.size)));
-    variants_size
-}
-
 impl_lint_pass!(LargeEnumVariant => [LARGE_ENUM_VARIANT]);
 
 impl<'tcx> LateLintPass<'tcx> for LargeEnumVariant {
@@ -130,7 +90,7 @@ impl<'tcx> LateLintPass<'tcx> for LargeEnumVariant {
             if adt.variants().len() <= 1 {
                 return;
             }
-            let variants_size = variants_size(cx, *adt, subst);
+            let variants_size = AdtVariantInfo::new(cx, *adt, subst);
 
             let mut difference = variants_size[0].size - variants_size[1].size;
             if difference > self.maximum_size_difference_allowed {
@@ -173,16 +133,16 @@ impl<'tcx> LateLintPass<'tcx> for LargeEnumVariant {
                                 .fields_size
                                 .iter()
                                 .rev()
-                                .map_while(|val| {
+                                .map_while(|&(ind, size)| {
                                     if difference > self.maximum_size_difference_allowed {
-                                        difference = difference.saturating_sub(val.size);
+                                        difference = difference.saturating_sub(size);
                                         Some((
-                                            fields[val.ind].ty.span,
+                                            fields[ind].ty.span,
                                             format!(
                                                 "Box<{}>",
                                                 snippet_with_applicability(
                                                     cx,
-                                                    fields[val.ind].ty.span,
+                                                    fields[ind].ty.span,
                                                     "..",
                                                     &mut applicability
                                                 )
diff --git a/clippy_utils/src/ty.rs b/clippy_utils/src/ty.rs
index a022aac4bfe..3e9c605e3f9 100644
--- a/clippy_utils/src/ty.rs
+++ b/clippy_utils/src/ty.rs
@@ -13,9 +13,9 @@ use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::LateContext;
 use rustc_middle::mir::interpret::{ConstValue, Scalar};
 use rustc_middle::ty::{
-    self, AdtDef, AssocKind, Binder, BoundRegion, DefIdTree, FnSig, GenericParamDefKind, IntTy, ParamEnv, Predicate,
-    PredicateKind, ProjectionTy, Region, RegionKind, SubstsRef, Ty, TyCtxt, TypeSuperVisitable, TypeVisitable,
-    TypeVisitor, UintTy, VariantDef, VariantDiscr,
+    self, AdtDef, AssocKind, Binder, BoundRegion, DefIdTree, FnSig, GenericParamDefKind, IntTy, List, ParamEnv,
+    Predicate, PredicateKind, ProjectionTy, Region, RegionKind, SubstsRef, Ty, TyCtxt, TypeSuperVisitable,
+    TypeVisitable, TypeVisitor, UintTy, VariantDef, VariantDiscr,
 };
 use rustc_middle::ty::{GenericArg, GenericArgKind};
 use rustc_span::symbol::Ident;
@@ -845,6 +845,42 @@ pub fn for_each_top_level_late_bound_region<B>(
     ty.visit_with(&mut V { index: 0, f })
 }
 
+pub struct AdtVariantInfo {
+    pub ind: usize,
+    pub size: u64,
+
+    /// (ind, size)
+    pub fields_size: Vec<(usize, u64)>,
+}
+
+impl AdtVariantInfo {
+    /// Returns ADT variants ordered by size
+    pub fn new<'tcx>(cx: &LateContext<'tcx>, adt: AdtDef<'tcx>, subst: &'tcx List<GenericArg<'tcx>>) -> Vec<Self> {
+        let mut variants_size = adt
+            .variants()
+            .iter()
+            .enumerate()
+            .map(|(i, variant)| {
+                let mut fields_size = variant
+                    .fields
+                    .iter()
+                    .enumerate()
+                    .map(|(i, f)| (i, approx_ty_size(cx, f.ty(cx.tcx, subst))))
+                    .collect::<Vec<_>>();
+                fields_size.sort_by(|(_, a_size), (_, b_size)| (a_size.cmp(b_size)));
+
+                Self {
+                    ind: i,
+                    size: fields_size.iter().map(|(_, size)| size).sum(),
+                    fields_size,
+                }
+            })
+            .collect::<Vec<_>>();
+        variants_size.sort_by(|a, b| (b.size.cmp(&a.size)));
+        variants_size
+    }
+}
+
 /// Gets the struct or enum variant from the given `Res`
 pub fn variant_of_res<'tcx>(cx: &LateContext<'tcx>, res: Res) -> Option<&'tcx VariantDef> {
     match res {
diff --git a/tests/ui/result_large_err.rs b/tests/ui/result_large_err.rs
index f7df3b85655..9dd27d6dc01 100644
--- a/tests/ui/result_large_err.rs
+++ b/tests/ui/result_large_err.rs
@@ -50,6 +50,18 @@ impl LargeErrorVariants<()> {
     }
 }
 
+enum MultipleLargeVariants {
+    _Biggest([u8; 1024]),
+    _AlsoBig([u8; 512]),
+    _Ok(usize),
+}
+
+impl MultipleLargeVariants {
+    fn large_enum_error() -> Result<(), Self> {
+        Ok(())
+    }
+}
+
 trait TraitForcesLargeError {
     fn large_error() -> Result<(), [u8; 512]> {
         Ok(())
diff --git a/tests/ui/result_large_err.stderr b/tests/ui/result_large_err.stderr
index bea101fe20b..c386edfd215 100644
--- a/tests/ui/result_large_err.stderr
+++ b/tests/ui/result_large_err.stderr
@@ -42,13 +42,29 @@ LL | pub fn param_large_error<R>() -> Result<(), (u128, R, FullyDefinedLargeErro
 error: the `Err`-variant returned from this function is very large
   --> $DIR/result_large_err.rs:48:34
    |
+LL |     _Omg([u8; 512]),
+   |     --------------- the largest variant contains at least 512 bytes
+...
 LL |     pub fn large_enum_error() -> Result<(), Self> {
-   |                                  ^^^^^^^^^^^^^^^^ the `Err`-variant is at least 513 bytes
+   |                                  ^^^^^^^^^^^^^^^^
    |
    = help: try reducing the size of `LargeErrorVariants<()>`, for example by boxing large elements or replacing it with `Box<LargeErrorVariants<()>>`
 
 error: the `Err`-variant returned from this function is very large
-  --> $DIR/result_large_err.rs:54:25
+  --> $DIR/result_large_err.rs:60:30
+   |
+LL |     _Biggest([u8; 1024]),
+   |     -------------------- the largest variant contains at least 1024 bytes
+LL |     _AlsoBig([u8; 512]),
+   |     ------------------- the variant `_AlsoBig` contains at least 512 bytes
+...
+LL |     fn large_enum_error() -> Result<(), Self> {
+   |                              ^^^^^^^^^^^^^^^^
+   |
+   = help: try reducing the size of `MultipleLargeVariants`, for example by boxing large elements or replacing it with `Box<MultipleLargeVariants>`
+
+error: the `Err`-variant returned from this function is very large
+  --> $DIR/result_large_err.rs:66:25
    |
 LL |     fn large_error() -> Result<(), [u8; 512]> {
    |                         ^^^^^^^^^^^^^^^^^^^^^ the `Err`-variant is at least 512 bytes
@@ -56,7 +72,7 @@ LL |     fn large_error() -> Result<(), [u8; 512]> {
    = help: try reducing the size of `[u8; 512]`, for example by boxing large elements or replacing it with `Box<[u8; 512]>`
 
 error: the `Err`-variant returned from this function is very large
-  --> $DIR/result_large_err.rs:73:29
+  --> $DIR/result_large_err.rs:85:29
    |
 LL | pub fn large_union_err() -> Result<(), FullyDefinedUnionError> {
    |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the `Err`-variant is at least 512 bytes
@@ -64,7 +80,7 @@ LL | pub fn large_union_err() -> Result<(), FullyDefinedUnionError> {
    = help: try reducing the size of `FullyDefinedUnionError`, for example by boxing large elements or replacing it with `Box<FullyDefinedUnionError>`
 
 error: the `Err`-variant returned from this function is very large
-  --> $DIR/result_large_err.rs:82:40
+  --> $DIR/result_large_err.rs:94:40
    |
 LL | pub fn param_large_union<T: Copy>() -> Result<(), UnionError<T>> {
    |                                        ^^^^^^^^^^^^^^^^^^^^^^^^^ the `Err`-variant is at least 512 bytes
@@ -72,7 +88,7 @@ LL | pub fn param_large_union<T: Copy>() -> Result<(), UnionError<T>> {
    = help: try reducing the size of `UnionError<T>`, for example by boxing large elements or replacing it with `Box<UnionError<T>>`
 
 error: the `Err`-variant returned from this function is very large
-  --> $DIR/result_large_err.rs:91:34
+  --> $DIR/result_large_err.rs:103:34
    |
 LL | pub fn array_error_subst<U>() -> Result<(), ArrayError<i32, U>> {
    |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the `Err`-variant is at least 128 bytes
@@ -80,12 +96,12 @@ LL | pub fn array_error_subst<U>() -> Result<(), ArrayError<i32, U>> {
    = help: try reducing the size of `ArrayError<i32, U>`, for example by boxing large elements or replacing it with `Box<ArrayError<i32, U>>`
 
 error: the `Err`-variant returned from this function is very large
-  --> $DIR/result_large_err.rs:95:31
+  --> $DIR/result_large_err.rs:107:31
    |
 LL | pub fn array_error<T, U>() -> Result<(), ArrayError<(i32, T), U>> {
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the `Err`-variant is at least 128 bytes
    |
    = help: try reducing the size of `ArrayError<(i32, T), U>`, for example by boxing large elements or replacing it with `Box<ArrayError<(i32, T), U>>`
 
-error: aborting due to 11 previous errors
+error: aborting due to 12 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 70010850e498de0b9b2a0b1874ab8271bb7da180 Mon Sep 17 00:00:00 2001
From: Grachev Mikhail <work@mgrachev.com>
Date: Tue, 8 Nov 2022 15:33:50 +0300
Subject: Update lint example for `collapsible_str_replace`

---
 clippy_lints/src/methods/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 1c0bbe086f7..686930a0bbe 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -159,7 +159,7 @@ declare_clippy_lint! {
     /// ```
     /// Use instead:
     /// ```rust
-    /// let hello = "hesuo worpd".replace(&['s', 'u', 'p'], "l");
+    /// let hello = "hesuo worpd".replace(['s', 'u', 'p'], "l");
     /// ```
     #[clippy::version = "1.65.0"]
     pub COLLAPSIBLE_STR_REPLACE,
-- 
cgit 1.4.1-3-g733a5


From 43a6d0b39ce5403c12264065a1619b49a1670a94 Mon Sep 17 00:00:00 2001
From: Ryan Scheidter <ryan.scheidter@oracle.com>
Date: Tue, 8 Nov 2022 07:48:39 -0600
Subject: Fixed Typo

---
 clippy_lints/src/methods/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 1c0bbe086f7..0a240bbee6c 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1731,7 +1731,7 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of `_.as_ref().map(Deref::deref)` or it's aliases (such as String::as_str).
+    /// Checks for usage of `_.as_ref().map(Deref::deref)` or its aliases (such as String::as_str).
     ///
     /// ### Why is this bad?
     /// Readability, this can be written more concisely as
-- 
cgit 1.4.1-3-g733a5


From 146bd1e13d910bc90c5316f11ddecd35f2673d65 Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukastw97@gmail.com>
Date: Wed, 9 Nov 2022 16:54:10 +0100
Subject: Add `unnecessary_safety_doc` lint

---
 CHANGELOG.md                            |   1 +
 clippy_lints/src/declared_lints.rs      |   1 +
 clippy_lints/src/doc.rs                 |  94 ++++++++++++++------
 tests/ui/auxiliary/doc_unsafe_macros.rs |   8 ++
 tests/ui/doc_unnecessary_unsafe.rs      | 148 ++++++++++++++++++++++++++++++++
 tests/ui/doc_unnecessary_unsafe.stderr  |  51 +++++++++++
 6 files changed, 278 insertions(+), 25 deletions(-)
 create mode 100644 tests/ui/doc_unnecessary_unsafe.rs
 create mode 100644 tests/ui/doc_unnecessary_unsafe.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9bd67617f5b..f1697312d5c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4449,6 +4449,7 @@ Released 2018-09-13
 [`unnecessary_mut_passed`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_mut_passed
 [`unnecessary_operation`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_operation
 [`unnecessary_owned_empty_strings`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_owned_empty_strings
+[`unnecessary_safety_doc`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_safety_doc
 [`unnecessary_self_imports`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_self_imports
 [`unnecessary_sort_by`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_sort_by
 [`unnecessary_to_owned`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_to_owned
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 98265410e84..0ff039a4cdf 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -127,6 +127,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::doc::MISSING_PANICS_DOC_INFO,
     crate::doc::MISSING_SAFETY_DOC_INFO,
     crate::doc::NEEDLESS_DOCTEST_MAIN_INFO,
+    crate::doc::UNNECESSARY_SAFETY_DOC_INFO,
     crate::double_parens::DOUBLE_PARENS_INFO,
     crate::drop_forget_ref::DROP_COPY_INFO,
     crate::drop_forget_ref::DROP_NON_DROP_INFO,
diff --git a/clippy_lints/src/doc.rs b/clippy_lints/src/doc.rs
index fbc00836b39..2ff58ade31f 100644
--- a/clippy_lints/src/doc.rs
+++ b/clippy_lints/src/doc.rs
@@ -221,6 +221,42 @@ declare_clippy_lint! {
     "possible typo for an intra-doc link"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for the doc comments of publicly visible
+    /// safe functions and traits and warns if there is a `# Safety` section.
+    ///
+    /// ### Why is this bad?
+    /// Safe functions and traits are safe to implement and therefore do not
+    /// need to describe safety preconditions that users are required to uphold.
+    ///
+    /// ### Examples
+    /// ```rust
+    ///# type Universe = ();
+    /// /// # Safety
+    /// ///
+    /// /// This function should not be called before the horsemen are ready.
+    /// pub fn start_apocalypse_but_safely(u: &mut Universe) {
+    ///     unimplemented!();
+    /// }
+    /// ```
+    ///
+    /// The function is safe, so there shouldn't be any preconditions
+    /// that have to be explained for safety reasons.
+    ///
+    /// ```rust
+    ///# type Universe = ();
+    /// /// This function should really be documented
+    /// pub fn start_apocalypse(u: &mut Universe) {
+    ///     unimplemented!();
+    /// }
+    /// ```
+    #[clippy::version = "1.66.0"]
+    pub UNNECESSARY_SAFETY_DOC,
+    style,
+    "`pub fn` or `pub trait` with `# Safety` docs"
+}
+
 #[expect(clippy::module_name_repetitions)]
 #[derive(Clone)]
 pub struct DocMarkdown {
@@ -243,7 +279,8 @@ impl_lint_pass!(DocMarkdown => [
     MISSING_SAFETY_DOC,
     MISSING_ERRORS_DOC,
     MISSING_PANICS_DOC,
-    NEEDLESS_DOCTEST_MAIN
+    NEEDLESS_DOCTEST_MAIN,
+    UNNECESSARY_SAFETY_DOC,
 ]);
 
 impl<'tcx> LateLintPass<'tcx> for DocMarkdown {
@@ -254,7 +291,7 @@ impl<'tcx> LateLintPass<'tcx> for DocMarkdown {
 
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) {
         let attrs = cx.tcx.hir().attrs(item.hir_id());
-        let headers = check_attrs(cx, &self.valid_idents, attrs);
+        let Some(headers) = check_attrs(cx, &self.valid_idents, attrs) else { return };
         match item.kind {
             hir::ItemKind::Fn(ref sig, _, body_id) => {
                 if !(is_entrypoint_fn(cx, item.def_id.to_def_id()) || in_external_macro(cx.tcx.sess, item.span)) {
@@ -271,15 +308,20 @@ impl<'tcx> LateLintPass<'tcx> for DocMarkdown {
             hir::ItemKind::Impl(impl_) => {
                 self.in_trait_impl = impl_.of_trait.is_some();
             },
-            hir::ItemKind::Trait(_, unsafety, ..) => {
-                if !headers.safety && unsafety == hir::Unsafety::Unsafe {
-                    span_lint(
-                        cx,
-                        MISSING_SAFETY_DOC,
-                        cx.tcx.def_span(item.def_id),
-                        "docs for unsafe trait missing `# Safety` section",
-                    );
-                }
+            hir::ItemKind::Trait(_, unsafety, ..) => match (headers.safety, unsafety) {
+                (false, hir::Unsafety::Unsafe) => span_lint(
+                    cx,
+                    MISSING_SAFETY_DOC,
+                    cx.tcx.def_span(item.def_id),
+                    "docs for unsafe trait missing `# Safety` section",
+                ),
+                (true, hir::Unsafety::Normal) => span_lint(
+                    cx,
+                    UNNECESSARY_SAFETY_DOC,
+                    cx.tcx.def_span(item.def_id),
+                    "docs for safe trait have unnecessary `# Safety` section",
+                ),
+                _ => (),
             },
             _ => (),
         }
@@ -293,7 +335,7 @@ impl<'tcx> LateLintPass<'tcx> for DocMarkdown {
 
     fn check_trait_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::TraitItem<'_>) {
         let attrs = cx.tcx.hir().attrs(item.hir_id());
-        let headers = check_attrs(cx, &self.valid_idents, attrs);
+        let Some(headers) = check_attrs(cx, &self.valid_idents, attrs) else { return };
         if let hir::TraitItemKind::Fn(ref sig, ..) = item.kind {
             if !in_external_macro(cx.tcx.sess, item.span) {
                 lint_for_missing_headers(cx, item.def_id.def_id, sig, headers, None, None);
@@ -303,7 +345,7 @@ impl<'tcx> LateLintPass<'tcx> for DocMarkdown {
 
     fn check_impl_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::ImplItem<'_>) {
         let attrs = cx.tcx.hir().attrs(item.hir_id());
-        let headers = check_attrs(cx, &self.valid_idents, attrs);
+        let Some(headers) = check_attrs(cx, &self.valid_idents, attrs) else { return };
         if self.in_trait_impl || in_external_macro(cx.tcx.sess, item.span) {
             return;
         }
@@ -343,14 +385,20 @@ fn lint_for_missing_headers(
     }
 
     let span = cx.tcx.def_span(def_id);
-
-    if !headers.safety && sig.header.unsafety == hir::Unsafety::Unsafe {
-        span_lint(
+    match (headers.safety, sig.header.unsafety) {
+        (false, hir::Unsafety::Unsafe) => span_lint(
             cx,
             MISSING_SAFETY_DOC,
             span,
             "unsafe function's docs miss `# Safety` section",
-        );
+        ),
+        (true, hir::Unsafety::Normal) => span_lint(
+            cx,
+            UNNECESSARY_SAFETY_DOC,
+            span,
+            "safe function's docs have unnecessary `# Safety` section",
+        ),
+        _ => (),
     }
     if !headers.panics && panic_span.is_some() {
         span_lint_and_note(
@@ -452,7 +500,7 @@ struct DocHeaders {
     panics: bool,
 }
 
-fn check_attrs(cx: &LateContext<'_>, valid_idents: &FxHashSet<String>, attrs: &[Attribute]) -> DocHeaders {
+fn check_attrs(cx: &LateContext<'_>, valid_idents: &FxHashSet<String>, attrs: &[Attribute]) -> Option<DocHeaders> {
     use pulldown_cmark::{BrokenLink, CowStr, Options};
     /// We don't want the parser to choke on intra doc links. Since we don't
     /// actually care about rendering them, just pretend that all broken links are
@@ -473,11 +521,7 @@ fn check_attrs(cx: &LateContext<'_>, valid_idents: &FxHashSet<String>, attrs: &[
         } else if attr.has_name(sym::doc) {
             // ignore mix of sugared and non-sugared doc
             // don't trigger the safety or errors check
-            return DocHeaders {
-                safety: true,
-                errors: true,
-                panics: true,
-            };
+            return None;
         }
     }
 
@@ -489,7 +533,7 @@ fn check_attrs(cx: &LateContext<'_>, valid_idents: &FxHashSet<String>, attrs: &[
     }
 
     if doc.is_empty() {
-        return DocHeaders::default();
+        return Some(DocHeaders::default());
     }
 
     let mut cb = fake_broken_link_callback;
@@ -512,7 +556,7 @@ fn check_attrs(cx: &LateContext<'_>, valid_idents: &FxHashSet<String>, attrs: &[
             (previous, current) => Err(((previous, previous_range), (current, current_range))),
         }
     });
-    check_doc(cx, valid_idents, events, &spans)
+    Some(check_doc(cx, valid_idents, events, &spans))
 }
 
 const RUST_CODE: &[&str] = &["rust", "no_run", "should_panic", "compile_fail"];
diff --git a/tests/ui/auxiliary/doc_unsafe_macros.rs b/tests/ui/auxiliary/doc_unsafe_macros.rs
index 869672d1eda..3d917e3dc75 100644
--- a/tests/ui/auxiliary/doc_unsafe_macros.rs
+++ b/tests/ui/auxiliary/doc_unsafe_macros.rs
@@ -6,3 +6,11 @@ macro_rules! undocd_unsafe {
         }
     };
 }
+#[macro_export]
+macro_rules! undocd_safe {
+    () => {
+        pub fn vey_oy() {
+            unimplemented!();
+        }
+    };
+}
diff --git a/tests/ui/doc_unnecessary_unsafe.rs b/tests/ui/doc_unnecessary_unsafe.rs
new file mode 100644
index 00000000000..d9e9363b0f4
--- /dev/null
+++ b/tests/ui/doc_unnecessary_unsafe.rs
@@ -0,0 +1,148 @@
+// aux-build:doc_unsafe_macros.rs
+
+#![allow(clippy::let_unit_value)]
+
+#[macro_use]
+extern crate doc_unsafe_macros;
+
+/// This is has no safety section, and does not need one either
+pub fn destroy_the_planet() {
+    unimplemented!();
+}
+
+/// This one does not need a `Safety` section
+///
+/// # Safety
+///
+/// This function shouldn't be called unless the horsemen are ready
+pub fn apocalypse(universe: &mut ()) {
+    unimplemented!();
+}
+
+/// This is a private function, skip to match behavior with `missing_safety_doc`.
+///
+/// # Safety
+///
+/// Boo!
+fn you_dont_see_me() {
+    unimplemented!();
+}
+
+mod private_mod {
+    /// This is public but unexported function, skip to match behavior with `missing_safety_doc`.
+    ///
+    /// # Safety
+    ///
+    /// Very safe!
+    pub fn only_crate_wide_accessible() {
+        unimplemented!();
+    }
+
+    /// # Safety
+    ///
+    /// Unnecessary safety!
+    pub fn republished() {
+        unimplemented!();
+    }
+}
+
+pub use private_mod::republished;
+
+pub trait SafeTraitSafeMethods {
+    fn woefully_underdocumented(self);
+
+    /// # Safety
+    ///
+    /// Unnecessary!
+    fn documented(self);
+}
+
+pub trait SafeTrait {
+    fn method();
+}
+
+/// # Safety
+///
+/// Unnecessary!
+pub trait DocumentedSafeTrait {
+    fn method2();
+}
+
+pub struct Struct;
+
+impl SafeTraitSafeMethods for Struct {
+    fn woefully_underdocumented(self) {
+        // all is well
+    }
+
+    fn documented(self) {
+        // all is still well
+    }
+}
+
+impl SafeTrait for Struct {
+    fn method() {}
+}
+
+impl DocumentedSafeTrait for Struct {
+    fn method2() {}
+}
+
+impl Struct {
+    /// # Safety
+    ///
+    /// Unnecessary!
+    pub fn documented() -> Self {
+        unimplemented!();
+    }
+
+    pub fn undocumented(&self) {
+        unimplemented!();
+    }
+
+    /// Private, fine again to stay consistent with `missing_safety_doc`.
+    ///
+    /// # Safety
+    ///
+    /// Unnecessary!
+    fn private(&self) {
+        unimplemented!();
+    }
+}
+
+macro_rules! very_safe {
+    () => {
+        pub fn whee() {
+            unimplemented!()
+        }
+
+        /// # Safety
+        ///
+        /// Driving is very safe already!
+        pub fn drive() {
+            whee()
+        }
+    };
+}
+
+very_safe!();
+
+// we don't lint code from external macros
+undocd_safe!();
+
+fn main() {}
+
+// do not lint if any parent has `#[doc(hidden)]` attribute
+// see #7347
+#[doc(hidden)]
+pub mod __macro {
+    pub struct T;
+    impl T {
+        pub unsafe fn f() {}
+    }
+}
+
+/// # Implementation safety
+pub trait DocumentedSafeTraitWithImplementationHeader {
+    fn method();
+}
diff --git a/tests/ui/doc_unnecessary_unsafe.stderr b/tests/ui/doc_unnecessary_unsafe.stderr
new file mode 100644
index 00000000000..83b2efbb346
--- /dev/null
+++ b/tests/ui/doc_unnecessary_unsafe.stderr
@@ -0,0 +1,51 @@
+error: safe function's docs have unnecessary `# Safety` section
+  --> $DIR/doc_unnecessary_unsafe.rs:18:1
+   |
+LL | pub fn apocalypse(universe: &mut ()) {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::unnecessary-safety-doc` implied by `-D warnings`
+
+error: safe function's docs have unnecessary `# Safety` section
+  --> $DIR/doc_unnecessary_unsafe.rs:44:5
+   |
+LL |     pub fn republished() {
+   |     ^^^^^^^^^^^^^^^^^^^^
+
+error: safe function's docs have unnecessary `# Safety` section
+  --> $DIR/doc_unnecessary_unsafe.rs:57:5
+   |
+LL |     fn documented(self);
+   |     ^^^^^^^^^^^^^^^^^^^^
+
+error: docs for safe trait have unnecessary `# Safety` section
+  --> $DIR/doc_unnecessary_unsafe.rs:67:1
+   |
+LL | pub trait DocumentedSafeTrait {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: safe function's docs have unnecessary `# Safety` section
+  --> $DIR/doc_unnecessary_unsafe.rs:95:5
+   |
+LL |     pub fn documented() -> Self {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: safe function's docs have unnecessary `# Safety` section
+  --> $DIR/doc_unnecessary_unsafe.rs:122:9
+   |
+LL |         pub fn drive() {
+   |         ^^^^^^^^^^^^^^
+...
+LL | very_safe!();
+   | ------------ in this macro invocation
+   |
+   = note: this error originates in the macro `very_safe` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: docs for safe trait have unnecessary `# Safety` section
+  --> $DIR/doc_unnecessary_unsafe.rs:146:1
+   |
+LL | pub trait DocumentedSafeTraitWithImplementationHeader {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 7 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 708c2d95c14829e0acbe7f40d9bea39e7bb03450 Mon Sep 17 00:00:00 2001
From: Nadir Fejzic <nadirfejzo@gmail.com>
Date: Sat, 1 Oct 2022 15:58:10 +0200
Subject: feat: add and implement unchecked_duration_subtraction lint

---
 CHANGELOG.md                                       |   1 +
 clippy_lints/src/lib.rs                            |   2 +
 clippy_lints/src/unchecked_duration_subtraction.rs | 107 +++++++++++++++++++++
 clippy_lints/src/utils/conf.rs                     |   2 +-
 4 files changed, 111 insertions(+), 1 deletion(-)
 create mode 100644 clippy_lints/src/unchecked_duration_subtraction.rs

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9bd67617f5b..eb4ca980143 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4428,6 +4428,7 @@ Released 2018-09-13
 [`try_err`]: https://rust-lang.github.io/rust-clippy/master/index.html#try_err
 [`type_complexity`]: https://rust-lang.github.io/rust-clippy/master/index.html#type_complexity
 [`type_repetition_in_bounds`]: https://rust-lang.github.io/rust-clippy/master/index.html#type_repetition_in_bounds
+[`unchecked_duration_subtraction`]: https://rust-lang.github.io/rust-clippy/master/index.html#unchecked_duration_subtraction
 [`undocumented_unsafe_blocks`]: https://rust-lang.github.io/rust-clippy/master/index.html#undocumented_unsafe_blocks
 [`undropped_manually_drops`]: https://rust-lang.github.io/rust-clippy/master/index.html#undropped_manually_drops
 [`unicode_not_nfc`]: https://rust-lang.github.io/rust-clippy/master/index.html#unicode_not_nfc
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index a4bacb78034..a5407b65b88 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -279,6 +279,7 @@ mod trailing_empty_array;
 mod trait_bounds;
 mod transmute;
 mod types;
+mod unchecked_duration_subtraction;
 mod undocumented_unsafe_blocks;
 mod unicode;
 mod uninit_vec;
@@ -921,6 +922,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(from_raw_with_void_ptr::FromRawWithVoidPtr));
     store.register_late_pass(|_| Box::new(suspicious_xor_used_as_pow::ConfusingXorAndPow));
     store.register_late_pass(move |_| Box::new(manual_is_ascii_check::ManualIsAsciiCheck::new(msrv)));
+    store.register_late_pass(move || Box::new(unchecked_duration_subtraction::UncheckedDurationSubtraction::new(msrv)));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/unchecked_duration_subtraction.rs b/clippy_lints/src/unchecked_duration_subtraction.rs
new file mode 100644
index 00000000000..fb08067de8d
--- /dev/null
+++ b/clippy_lints/src/unchecked_duration_subtraction.rs
@@ -0,0 +1,107 @@
+use clippy_utils::{diagnostics, meets_msrv, msrvs, source, ty};
+use rustc_errors::Applicability;
+use rustc_hir::*;
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_semver::RustcVersion;
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::symbol::sym;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Finds patterns of unchecked subtraction of [`Duration`] from [`Instant::now()`].
+    ///
+    /// ### Why is this bad?
+    /// Unchecked subtraction could cause underflow on certain platforms, leading to bugs and/or
+    /// unintentional panics.
+    ///
+    /// ### Example
+    /// ```rust
+    /// let time_passed = Instant::now() - Duration::from_secs(5);
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust
+    /// let time_passed = Instant::now().checked_sub(Duration::from_secs(5));
+    /// ```
+    ///
+    /// [`Duration`]: std::time::Duration
+    /// [`Instant::now()`]: std::time::Instant::now;
+    #[clippy::version = "1.65.0"]
+    pub UNCHECKED_DURATION_SUBTRACTION,
+    suspicious,
+    "finds unchecked subtraction of a 'Duration' from an 'Instant'"
+}
+
+pub struct UncheckedDurationSubtraction {
+    msrv: Option<RustcVersion>,
+}
+
+impl UncheckedDurationSubtraction {
+    #[must_use]
+    pub fn new(msrv: Option<RustcVersion>) -> Self {
+        Self { msrv }
+    }
+}
+
+impl_lint_pass!(UncheckedDurationSubtraction => [UNCHECKED_DURATION_SUBTRACTION]);
+
+impl<'tcx> LateLintPass<'tcx> for UncheckedDurationSubtraction {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
+        if expr.span.from_expansion() || !meets_msrv(self.msrv, msrvs::TRY_FROM) {
+            return;
+        }
+
+        if_chain! {
+            if let ExprKind::Binary(op, lhs, rhs) = expr.kind;
+
+            if let BinOpKind::Sub = op.node;
+
+            // get types of left and right side
+            if is_an_instant(cx, lhs);
+            if is_a_duration(cx, rhs);
+
+            then {
+                print_lint_and_sugg(cx, lhs, rhs, expr)
+            }
+        }
+    }
+}
+
+fn is_an_instant(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+    let expr_ty = cx.typeck_results().expr_ty(expr);
+
+    match expr_ty.kind() {
+        rustc_middle::ty::Adt(def, _) => {
+            clippy_utils::match_def_path(cx, dbg!(def).did(), &clippy_utils::paths::INSTANT)
+        },
+        _ => false,
+    }
+}
+
+fn is_a_duration(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+    let expr_ty = cx.typeck_results().expr_ty(expr);
+    ty::is_type_diagnostic_item(cx, expr_ty, sym::Duration)
+}
+
+fn print_lint_and_sugg(cx: &LateContext<'_>, left_expr: &Expr<'_>, right_expr: &Expr<'_>, expr: &Expr<'_>) {
+    let mut applicability = Applicability::MachineApplicable;
+
+    let left_expr =
+        source::snippet_with_applicability(cx, left_expr.span, "std::time::Instant::now()", &mut applicability);
+    let right_expr = source::snippet_with_applicability(
+        cx,
+        right_expr.span,
+        "std::time::Duration::from_secs(1)",
+        &mut applicability,
+    );
+
+    diagnostics::span_lint_and_sugg(
+        cx,
+        UNCHECKED_DURATION_SUBTRACTION,
+        expr.span,
+        "unchecked subtraction of a 'Duration' from an 'Instant'",
+        "try",
+        format!("{}.checked_sub({}).unwrap();", left_expr, right_expr),
+        applicability,
+    );
+}
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 0cf49ca6d42..ab58e9b8b68 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -213,7 +213,7 @@ define_Conf! {
     ///
     /// Suppress lints whenever the suggested change would cause breakage for other crates.
     (avoid_breaking_exported_api: bool = true),
-    /// Lint: MANUAL_SPLIT_ONCE, MANUAL_STR_REPEAT, CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR, IF_THEN_SOME_ELSE_NONE, APPROX_CONSTANT, DEPRECATED_CFG_ATTR, INDEX_REFUTABLE_SLICE, MAP_CLONE, BORROW_AS_PTR, MANUAL_BITS, ERR_EXPECT, CAST_ABS_TO_UNSIGNED, UNINLINED_FORMAT_ARGS, MANUAL_CLAMP, MANUAL_LET_ELSE.
+    /// Lint: MANUAL_SPLIT_ONCE, MANUAL_STR_REPEAT, CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR, IF_THEN_SOME_ELSE_NONE, APPROX_CONSTANT, DEPRECATED_CFG_ATTR, INDEX_REFUTABLE_SLICE, MAP_CLONE, BORROW_AS_PTR, MANUAL_BITS, ERR_EXPECT, CAST_ABS_TO_UNSIGNED, UNINLINED_FORMAT_ARGS, MANUAL_CLAMP, MANUAL_LET_ELSE, UNCHECKED_DURATION_SUBTRACTION.
     ///
     /// The minimum rust version that the project supports
     (msrv: Option<String> = None),
-- 
cgit 1.4.1-3-g733a5


From b485832b16a388dbcfd3c42030356959e7662a3d Mon Sep 17 00:00:00 2001
From: Nadir Fejzic <nadirfejzo@gmail.com>
Date: Sat, 1 Oct 2022 16:50:56 +0200
Subject: style: remove `dbg!` call

---
 clippy_lints/src/unchecked_duration_subtraction.rs | 4 +---
 tests/ui/unchecked_duration_subtraction.stderr     | 4 ----
 2 files changed, 1 insertion(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unchecked_duration_subtraction.rs b/clippy_lints/src/unchecked_duration_subtraction.rs
index fb08067de8d..ae796000662 100644
--- a/clippy_lints/src/unchecked_duration_subtraction.rs
+++ b/clippy_lints/src/unchecked_duration_subtraction.rs
@@ -71,9 +71,7 @@ fn is_an_instant(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
     let expr_ty = cx.typeck_results().expr_ty(expr);
 
     match expr_ty.kind() {
-        rustc_middle::ty::Adt(def, _) => {
-            clippy_utils::match_def_path(cx, dbg!(def).did(), &clippy_utils::paths::INSTANT)
-        },
+        rustc_middle::ty::Adt(def, _) => clippy_utils::match_def_path(cx, def.did(), &clippy_utils::paths::INSTANT),
         _ => false,
     }
 }
diff --git a/tests/ui/unchecked_duration_subtraction.stderr b/tests/ui/unchecked_duration_subtraction.stderr
index 827b18a5a09..6b297a01c7b 100644
--- a/tests/ui/unchecked_duration_subtraction.stderr
+++ b/tests/ui/unchecked_duration_subtraction.stderr
@@ -1,4 +1,3 @@
-[clippy_lints/src/unchecked_duration_subtraction.rs:75] def = std::time::Instant
 error: unchecked subtraction of a 'Duration' from an 'Instant'
   --> $DIR/unchecked_duration_subtraction.rs:9:13
    |
@@ -7,21 +6,18 @@ LL |     let _ = _first - second;
    |
    = note: `-D clippy::unchecked-duration-subtraction` implied by `-D warnings`
 
-[clippy_lints/src/unchecked_duration_subtraction.rs:75] def = std::time::Instant
 error: unchecked subtraction of a 'Duration' from an 'Instant'
   --> $DIR/unchecked_duration_subtraction.rs:11:13
    |
 LL |     let _ = Instant::now() - Duration::from_secs(5);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Instant::now().checked_sub(Duration::from_secs(5)).unwrap();`
 
-[clippy_lints/src/unchecked_duration_subtraction.rs:75] def = std::time::Instant
 error: unchecked subtraction of a 'Duration' from an 'Instant'
   --> $DIR/unchecked_duration_subtraction.rs:13:13
    |
 LL |     let _ = _first - Duration::from_secs(5);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `_first.checked_sub(Duration::from_secs(5)).unwrap();`
 
-[clippy_lints/src/unchecked_duration_subtraction.rs:75] def = std::time::Instant
 error: unchecked subtraction of a 'Duration' from an 'Instant'
   --> $DIR/unchecked_duration_subtraction.rs:15:13
    |
-- 
cgit 1.4.1-3-g733a5


From 2f2eb2e4baace68868af2f4ac3ec7aed073139ad Mon Sep 17 00:00:00 2001
From: Nadir Fejzic <nadirfejzo@gmail.com>
Date: Mon, 7 Nov 2022 20:58:49 +0100
Subject: refactor: lint man. instant elapsed and unch. dur. subtr. in single
 pass

---
 clippy_lints/src/instant_subtraction.rs            | 165 +++++++++++++++++++++
 clippy_lints/src/lib.rs                            |   5 +-
 clippy_lints/src/manual_instant_elapsed.rs         |  69 ---------
 clippy_lints/src/unchecked_duration_subtraction.rs | 105 -------------
 4 files changed, 167 insertions(+), 177 deletions(-)
 create mode 100644 clippy_lints/src/instant_subtraction.rs
 delete mode 100644 clippy_lints/src/manual_instant_elapsed.rs
 delete mode 100644 clippy_lints/src/unchecked_duration_subtraction.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/instant_subtraction.rs b/clippy_lints/src/instant_subtraction.rs
new file mode 100644
index 00000000000..8cc5643c9a7
--- /dev/null
+++ b/clippy_lints/src/instant_subtraction.rs
@@ -0,0 +1,165 @@
+use clippy_utils::{
+    diagnostics::{self, span_lint_and_sugg},
+    meets_msrv, msrvs, source, ty,
+};
+use rustc_errors::Applicability;
+use rustc_hir::{BinOpKind, Expr, ExprKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_semver::RustcVersion;
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::{source_map::Spanned, sym};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Lints subtraction between `Instant::now()` and another `Instant`.
+    ///
+    /// ### Why is this bad?
+    /// It is easy to accidentally write `prev_instant - Instant::now()`, which will always be 0ns
+    /// as `Instant` subtraction saturates.
+    ///
+    /// `prev_instant.elapsed()` also more clearly signals intention.
+    ///
+    /// ### Example
+    /// ```rust
+    /// use std::time::Instant;
+    /// let prev_instant = Instant::now();
+    /// let duration = Instant::now() - prev_instant;
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// use std::time::Instant;
+    /// let prev_instant = Instant::now();
+    /// let duration = prev_instant.elapsed();
+    /// ```
+    #[clippy::version = "1.64.0"]
+    pub MANUAL_INSTANT_ELAPSED,
+    pedantic,
+    "subtraction between `Instant::now()` and previous `Instant`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Finds patterns of unchecked subtraction of [`Duration`] from [`Instant::now()`].
+    ///
+    /// ### Why is this bad?
+    /// Unchecked subtraction could cause underflow on certain platforms, leading to
+    /// unintentional panics.
+    ///
+    /// ### Example
+    /// ```rust
+    /// let time_passed = Instant::now() - Duration::from_secs(5);
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust
+    /// let time_passed = Instant::now().checked_sub(Duration::from_secs(5));
+    /// ```
+    ///
+    /// [`Duration`]: std::time::Duration
+    /// [`Instant::now()`]: std::time::Instant::now;
+    #[clippy::version = "1.65.0"]
+    pub UNCHECKED_DURATION_SUBTRACTION,
+    suspicious,
+    "finds unchecked subtraction of a 'Duration' from an 'Instant'"
+}
+
+pub struct InstantSubtraction {
+    msrv: Option<RustcVersion>,
+}
+
+impl InstantSubtraction {
+    #[must_use]
+    pub fn new(msrv: Option<RustcVersion>) -> Self {
+        Self { msrv }
+    }
+}
+
+impl_lint_pass!(InstantSubtraction => [MANUAL_INSTANT_ELAPSED, UNCHECKED_DURATION_SUBTRACTION]);
+
+impl LateLintPass<'_> for InstantSubtraction {
+    fn check_expr(&mut self, cx: &LateContext<'_>, expr: &'_ Expr<'_>) {
+        if let ExprKind::Binary(Spanned {node: BinOpKind::Sub, ..}, lhs, rhs) = expr.kind
+            && check_instant_now_call(cx, lhs)
+            && let ty_resolved = cx.typeck_results().expr_ty(rhs)
+            && let rustc_middle::ty::Adt(def, _) = ty_resolved.kind()
+            && clippy_utils::match_def_path(cx, def.did(), &clippy_utils::paths::INSTANT)
+            && let Some(sugg) = clippy_utils::sugg::Sugg::hir_opt(cx, rhs)
+        {
+            span_lint_and_sugg(
+                cx,
+                MANUAL_INSTANT_ELAPSED,
+                expr.span,
+                "manual implementation of `Instant::elapsed`",
+                "try",
+                format!("{}.elapsed()", sugg.maybe_par()),
+                Applicability::MachineApplicable,
+            );
+        }
+
+        if expr.span.from_expansion() || !meets_msrv(self.msrv, msrvs::TRY_FROM) {
+            return;
+        }
+
+        if_chain! {
+            if let ExprKind::Binary(op, lhs, rhs) = expr.kind;
+
+            if let BinOpKind::Sub = op.node;
+
+            // get types of left and right side
+            if is_an_instant(cx, lhs);
+            if is_a_duration(cx, rhs);
+
+            then {
+                print_lint_and_sugg(cx, lhs, rhs, expr)
+            }
+        }
+    }
+}
+
+fn check_instant_now_call(cx: &LateContext<'_>, expr_block: &'_ Expr<'_>) -> bool {
+    if let ExprKind::Call(fn_expr, []) = expr_block.kind
+        && let Some(fn_id) = clippy_utils::path_def_id(cx, fn_expr)
+        && clippy_utils::match_def_path(cx, fn_id, &clippy_utils::paths::INSTANT_NOW)
+    {
+        true
+    } else {
+        false
+    }
+}
+
+fn is_an_instant(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+    let expr_ty = cx.typeck_results().expr_ty(expr);
+
+    match expr_ty.kind() {
+        rustc_middle::ty::Adt(def, _) => clippy_utils::match_def_path(cx, def.did(), &clippy_utils::paths::INSTANT),
+        _ => false,
+    }
+}
+
+fn is_a_duration(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+    let expr_ty = cx.typeck_results().expr_ty(expr);
+    ty::is_type_diagnostic_item(cx, expr_ty, sym::Duration)
+}
+
+fn print_lint_and_sugg(cx: &LateContext<'_>, left_expr: &Expr<'_>, right_expr: &Expr<'_>, expr: &Expr<'_>) {
+    let mut applicability = Applicability::MachineApplicable;
+
+    let left_expr =
+        source::snippet_with_applicability(cx, left_expr.span, "std::time::Instant::now()", &mut applicability);
+    let right_expr = source::snippet_with_applicability(
+        cx,
+        right_expr.span,
+        "std::time::Duration::from_secs(1)",
+        &mut applicability,
+    );
+
+    diagnostics::span_lint_and_sugg(
+        cx,
+        UNCHECKED_DURATION_SUBTRACTION,
+        expr.span,
+        "unchecked subtraction of a 'Duration' from an 'Instant'",
+        "try",
+        format!("{}.checked_sub({}).unwrap();", left_expr, right_expr),
+        applicability,
+    );
+}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index a5407b65b88..ce0e7ebfbf1 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -151,6 +151,7 @@ mod inherent_impl;
 mod inherent_to_string;
 mod init_numbered_fields;
 mod inline_fn_without_body;
+mod instant_subtraction;
 mod int_plus_one;
 mod invalid_upcast_comparisons;
 mod invalid_utf8_in_unchecked;
@@ -172,7 +173,6 @@ mod manual_assert;
 mod manual_async_fn;
 mod manual_bits;
 mod manual_clamp;
-mod manual_instant_elapsed;
 mod manual_is_ascii_check;
 mod manual_let_else;
 mod manual_non_exhaustive;
@@ -279,7 +279,6 @@ mod trailing_empty_array;
 mod trait_bounds;
 mod transmute;
 mod types;
-mod unchecked_duration_subtraction;
 mod undocumented_unsafe_blocks;
 mod unicode;
 mod uninit_vec;
@@ -908,7 +907,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(move |_| Box::new(operators::Operators::new(verbose_bit_mask_threshold)));
     store.register_late_pass(|_| Box::new(invalid_utf8_in_unchecked::InvalidUtf8InUnchecked));
     store.register_late_pass(|_| Box::<std_instead_of_core::StdReexports>::default());
-    store.register_late_pass(|_| Box::new(manual_instant_elapsed::ManualInstantElapsed));
+    store.register_late_pass(move |_| Box::new(instant_subtraction::InstantSubtraction::new(msrv)));
     store.register_late_pass(|_| Box::new(partialeq_to_none::PartialeqToNone));
     store.register_late_pass(move |_| Box::new(manual_clamp::ManualClamp::new(msrv)));
     store.register_late_pass(|_| Box::new(manual_string_new::ManualStringNew));
diff --git a/clippy_lints/src/manual_instant_elapsed.rs b/clippy_lints/src/manual_instant_elapsed.rs
deleted file mode 100644
index 1e60aa02d3c..00000000000
--- a/clippy_lints/src/manual_instant_elapsed.rs
+++ /dev/null
@@ -1,69 +0,0 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
-use rustc_errors::Applicability;
-use rustc_hir::{BinOpKind, Expr, ExprKind};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::source_map::Spanned;
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Lints subtraction between `Instant::now()` and another `Instant`.
-    ///
-    /// ### Why is this bad?
-    /// It is easy to accidentally write `prev_instant - Instant::now()`, which will always be 0ns
-    /// as `Instant` subtraction saturates.
-    ///
-    /// `prev_instant.elapsed()` also more clearly signals intention.
-    ///
-    /// ### Example
-    /// ```rust
-    /// use std::time::Instant;
-    /// let prev_instant = Instant::now();
-    /// let duration = Instant::now() - prev_instant;
-    /// ```
-    /// Use instead:
-    /// ```rust
-    /// use std::time::Instant;
-    /// let prev_instant = Instant::now();
-    /// let duration = prev_instant.elapsed();
-    /// ```
-    #[clippy::version = "1.65.0"]
-    pub MANUAL_INSTANT_ELAPSED,
-    pedantic,
-    "subtraction between `Instant::now()` and previous `Instant`"
-}
-
-declare_lint_pass!(ManualInstantElapsed => [MANUAL_INSTANT_ELAPSED]);
-
-impl LateLintPass<'_> for ManualInstantElapsed {
-    fn check_expr(&mut self, cx: &LateContext<'_>, expr: &'_ Expr<'_>) {
-        if let ExprKind::Binary(Spanned {node: BinOpKind::Sub, ..}, lhs, rhs) = expr.kind
-            && check_instant_now_call(cx, lhs)
-            && let ty_resolved = cx.typeck_results().expr_ty(rhs)
-            && let rustc_middle::ty::Adt(def, _) = ty_resolved.kind()
-            && clippy_utils::match_def_path(cx, def.did(), &clippy_utils::paths::INSTANT)
-            && let Some(sugg) = clippy_utils::sugg::Sugg::hir_opt(cx, rhs)
-        {
-            span_lint_and_sugg(
-                cx,
-                MANUAL_INSTANT_ELAPSED,
-                expr.span,
-                "manual implementation of `Instant::elapsed`",
-                "try",
-                format!("{}.elapsed()", sugg.maybe_par()),
-                Applicability::MachineApplicable,
-            );
-        }
-    }
-}
-
-fn check_instant_now_call(cx: &LateContext<'_>, expr_block: &'_ Expr<'_>) -> bool {
-    if let ExprKind::Call(fn_expr, []) = expr_block.kind
-        && let Some(fn_id) = clippy_utils::path_def_id(cx, fn_expr)
-        && clippy_utils::match_def_path(cx, fn_id, &clippy_utils::paths::INSTANT_NOW)
-    {
-        true
-    } else {
-        false
-    }
-}
diff --git a/clippy_lints/src/unchecked_duration_subtraction.rs b/clippy_lints/src/unchecked_duration_subtraction.rs
deleted file mode 100644
index ae796000662..00000000000
--- a/clippy_lints/src/unchecked_duration_subtraction.rs
+++ /dev/null
@@ -1,105 +0,0 @@
-use clippy_utils::{diagnostics, meets_msrv, msrvs, source, ty};
-use rustc_errors::Applicability;
-use rustc_hir::*;
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_semver::RustcVersion;
-use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::symbol::sym;
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Finds patterns of unchecked subtraction of [`Duration`] from [`Instant::now()`].
-    ///
-    /// ### Why is this bad?
-    /// Unchecked subtraction could cause underflow on certain platforms, leading to bugs and/or
-    /// unintentional panics.
-    ///
-    /// ### Example
-    /// ```rust
-    /// let time_passed = Instant::now() - Duration::from_secs(5);
-    /// ```
-    ///
-    /// Use instead:
-    /// ```rust
-    /// let time_passed = Instant::now().checked_sub(Duration::from_secs(5));
-    /// ```
-    ///
-    /// [`Duration`]: std::time::Duration
-    /// [`Instant::now()`]: std::time::Instant::now;
-    #[clippy::version = "1.65.0"]
-    pub UNCHECKED_DURATION_SUBTRACTION,
-    suspicious,
-    "finds unchecked subtraction of a 'Duration' from an 'Instant'"
-}
-
-pub struct UncheckedDurationSubtraction {
-    msrv: Option<RustcVersion>,
-}
-
-impl UncheckedDurationSubtraction {
-    #[must_use]
-    pub fn new(msrv: Option<RustcVersion>) -> Self {
-        Self { msrv }
-    }
-}
-
-impl_lint_pass!(UncheckedDurationSubtraction => [UNCHECKED_DURATION_SUBTRACTION]);
-
-impl<'tcx> LateLintPass<'tcx> for UncheckedDurationSubtraction {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
-        if expr.span.from_expansion() || !meets_msrv(self.msrv, msrvs::TRY_FROM) {
-            return;
-        }
-
-        if_chain! {
-            if let ExprKind::Binary(op, lhs, rhs) = expr.kind;
-
-            if let BinOpKind::Sub = op.node;
-
-            // get types of left and right side
-            if is_an_instant(cx, lhs);
-            if is_a_duration(cx, rhs);
-
-            then {
-                print_lint_and_sugg(cx, lhs, rhs, expr)
-            }
-        }
-    }
-}
-
-fn is_an_instant(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-    let expr_ty = cx.typeck_results().expr_ty(expr);
-
-    match expr_ty.kind() {
-        rustc_middle::ty::Adt(def, _) => clippy_utils::match_def_path(cx, def.did(), &clippy_utils::paths::INSTANT),
-        _ => false,
-    }
-}
-
-fn is_a_duration(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-    let expr_ty = cx.typeck_results().expr_ty(expr);
-    ty::is_type_diagnostic_item(cx, expr_ty, sym::Duration)
-}
-
-fn print_lint_and_sugg(cx: &LateContext<'_>, left_expr: &Expr<'_>, right_expr: &Expr<'_>, expr: &Expr<'_>) {
-    let mut applicability = Applicability::MachineApplicable;
-
-    let left_expr =
-        source::snippet_with_applicability(cx, left_expr.span, "std::time::Instant::now()", &mut applicability);
-    let right_expr = source::snippet_with_applicability(
-        cx,
-        right_expr.span,
-        "std::time::Duration::from_secs(1)",
-        &mut applicability,
-    );
-
-    diagnostics::span_lint_and_sugg(
-        cx,
-        UNCHECKED_DURATION_SUBTRACTION,
-        expr.span,
-        "unchecked subtraction of a 'Duration' from an 'Instant'",
-        "try",
-        format!("{}.checked_sub({}).unwrap();", left_expr, right_expr),
-        applicability,
-    );
-}
-- 
cgit 1.4.1-3-g733a5


From 80e3553f290cd252646c61086e9461fc7618b694 Mon Sep 17 00:00:00 2001
From: Nadir Fejzic <nadirfejzo@gmail.com>
Date: Mon, 7 Nov 2022 21:34:24 +0100
Subject: refactor: improve code re-use in InstantSubtraction lint pass

---
 clippy_lints/src/instant_subtraction.rs | 85 +++++++++++++++++++--------------
 1 file changed, 50 insertions(+), 35 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/instant_subtraction.rs b/clippy_lints/src/instant_subtraction.rs
index 8cc5643c9a7..3166c62dad4 100644
--- a/clippy_lints/src/instant_subtraction.rs
+++ b/clippy_lints/src/instant_subtraction.rs
@@ -1,6 +1,8 @@
 use clippy_utils::{
     diagnostics::{self, span_lint_and_sugg},
-    meets_msrv, msrvs, source, ty,
+    meets_msrv, msrvs, source,
+    sugg::Sugg,
+    ty,
 };
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind};
@@ -78,45 +80,41 @@ impl_lint_pass!(InstantSubtraction => [MANUAL_INSTANT_ELAPSED, UNCHECKED_DURATIO
 
 impl LateLintPass<'_> for InstantSubtraction {
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &'_ Expr<'_>) {
-        if let ExprKind::Binary(Spanned {node: BinOpKind::Sub, ..}, lhs, rhs) = expr.kind
-            && check_instant_now_call(cx, lhs)
-            && let ty_resolved = cx.typeck_results().expr_ty(rhs)
-            && let rustc_middle::ty::Adt(def, _) = ty_resolved.kind()
-            && clippy_utils::match_def_path(cx, def.did(), &clippy_utils::paths::INSTANT)
-            && let Some(sugg) = clippy_utils::sugg::Sugg::hir_opt(cx, rhs)
+        if let ExprKind::Binary(
+            Spanned {
+                node: BinOpKind::Sub, ..
+            },
+            lhs,
+            rhs,
+        ) = expr.kind
         {
-            span_lint_and_sugg(
-                cx,
-                MANUAL_INSTANT_ELAPSED,
-                expr.span,
-                "manual implementation of `Instant::elapsed`",
-                "try",
-                format!("{}.elapsed()", sugg.maybe_par()),
-                Applicability::MachineApplicable,
-            );
-        }
-
-        if expr.span.from_expansion() || !meets_msrv(self.msrv, msrvs::TRY_FROM) {
-            return;
-        }
-
-        if_chain! {
-            if let ExprKind::Binary(op, lhs, rhs) = expr.kind;
-
-            if let BinOpKind::Sub = op.node;
-
-            // get types of left and right side
-            if is_an_instant(cx, lhs);
-            if is_a_duration(cx, rhs);
-
-            then {
-                print_lint_and_sugg(cx, lhs, rhs, expr)
+            if_chain! {
+                if is_instant_now_call(cx, lhs);
+
+                if is_an_instant(cx, rhs);
+                if let Some(sugg) = Sugg::hir_opt(cx, rhs);
+
+                then {
+                    print_manual_instant_elapsed_sugg(cx, expr, sugg)
+                } else {
+                    if_chain! {
+                        if !expr.span.from_expansion();
+                        if meets_msrv(self.msrv, msrvs::TRY_FROM);
+
+                        if is_an_instant(cx, lhs);
+                        if is_a_duration(cx, rhs);
+
+                        then {
+                            print_unchecked_duration_subtraction_sugg(cx, lhs, rhs, expr)
+                        }
+                    }
+                }
             }
         }
     }
 }
 
-fn check_instant_now_call(cx: &LateContext<'_>, expr_block: &'_ Expr<'_>) -> bool {
+fn is_instant_now_call(cx: &LateContext<'_>, expr_block: &'_ Expr<'_>) -> bool {
     if let ExprKind::Call(fn_expr, []) = expr_block.kind
         && let Some(fn_id) = clippy_utils::path_def_id(cx, fn_expr)
         && clippy_utils::match_def_path(cx, fn_id, &clippy_utils::paths::INSTANT_NOW)
@@ -141,7 +139,24 @@ fn is_a_duration(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
     ty::is_type_diagnostic_item(cx, expr_ty, sym::Duration)
 }
 
-fn print_lint_and_sugg(cx: &LateContext<'_>, left_expr: &Expr<'_>, right_expr: &Expr<'_>, expr: &Expr<'_>) {
+fn print_manual_instant_elapsed_sugg(cx: &LateContext<'_>, expr: &Expr<'_>, sugg: Sugg<'_>) {
+    span_lint_and_sugg(
+        cx,
+        MANUAL_INSTANT_ELAPSED,
+        expr.span,
+        "manual implementation of `Instant::elapsed`",
+        "try",
+        format!("{}.elapsed()", sugg.maybe_par()),
+        Applicability::MachineApplicable,
+    );
+}
+
+fn print_unchecked_duration_subtraction_sugg(
+    cx: &LateContext<'_>,
+    left_expr: &Expr<'_>,
+    right_expr: &Expr<'_>,
+    expr: &Expr<'_>,
+) {
     let mut applicability = Applicability::MachineApplicable;
 
     let left_expr =
-- 
cgit 1.4.1-3-g733a5


From 852d80245148cdd23c5516bea015b0f3bf277ed4 Mon Sep 17 00:00:00 2001
From: Nadir Fejzic <nadirfejzo@gmail.com>
Date: Mon, 7 Nov 2022 22:21:32 +0100
Subject: style: inline variables in `format!`

---
 clippy_lints/src/instant_subtraction.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/instant_subtraction.rs b/clippy_lints/src/instant_subtraction.rs
index 3166c62dad4..c039f1b5c6a 100644
--- a/clippy_lints/src/instant_subtraction.rs
+++ b/clippy_lints/src/instant_subtraction.rs
@@ -174,7 +174,7 @@ fn print_unchecked_duration_subtraction_sugg(
         expr.span,
         "unchecked subtraction of a 'Duration' from an 'Instant'",
         "try",
-        format!("{}.checked_sub({}).unwrap();", left_expr, right_expr),
+        format!("{left_expr}.checked_sub({right_expr}).unwrap();"),
         applicability,
     );
 }
-- 
cgit 1.4.1-3-g733a5


From 862ac29192bd4e2c9db04e9763dfd1a35a00a9cb Mon Sep 17 00:00:00 2001
From: Nadir Fejzic <nadirfejzo@gmail.com>
Date: Tue, 8 Nov 2022 15:04:32 +0100
Subject: fix: remove (redundant) semicolon in lint suggestion

---
 clippy_lints/src/instant_subtraction.rs        | 2 +-
 tests/ui/unchecked_duration_subtraction.fixed  | 8 ++++----
 tests/ui/unchecked_duration_subtraction.stderr | 8 ++++----
 3 files changed, 9 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/instant_subtraction.rs b/clippy_lints/src/instant_subtraction.rs
index c039f1b5c6a..d83beb622cf 100644
--- a/clippy_lints/src/instant_subtraction.rs
+++ b/clippy_lints/src/instant_subtraction.rs
@@ -174,7 +174,7 @@ fn print_unchecked_duration_subtraction_sugg(
         expr.span,
         "unchecked subtraction of a 'Duration' from an 'Instant'",
         "try",
-        format!("{left_expr}.checked_sub({right_expr}).unwrap();"),
+        format!("{left_expr}.checked_sub({right_expr}).unwrap()"),
         applicability,
     );
 }
diff --git a/tests/ui/unchecked_duration_subtraction.fixed b/tests/ui/unchecked_duration_subtraction.fixed
index bcc231d93b1..a0e49a8beb1 100644
--- a/tests/ui/unchecked_duration_subtraction.fixed
+++ b/tests/ui/unchecked_duration_subtraction.fixed
@@ -7,11 +7,11 @@ fn main() {
     let _first = Instant::now();
     let second = Duration::from_secs(3);
 
-    let _ = _first.checked_sub(second).unwrap();;
+    let _ = _first.checked_sub(second).unwrap();
 
-    let _ = Instant::now().checked_sub(Duration::from_secs(5)).unwrap();;
+    let _ = Instant::now().checked_sub(Duration::from_secs(5)).unwrap();
 
-    let _ = _first.checked_sub(Duration::from_secs(5)).unwrap();;
+    let _ = _first.checked_sub(Duration::from_secs(5)).unwrap();
 
-    let _ = Instant::now().checked_sub(second).unwrap();;
+    let _ = Instant::now().checked_sub(second).unwrap();
 }
diff --git a/tests/ui/unchecked_duration_subtraction.stderr b/tests/ui/unchecked_duration_subtraction.stderr
index b949dbf701a..a2e0aa1d7c0 100644
--- a/tests/ui/unchecked_duration_subtraction.stderr
+++ b/tests/ui/unchecked_duration_subtraction.stderr
@@ -2,7 +2,7 @@ error: unchecked subtraction of a 'Duration' from an 'Instant'
   --> $DIR/unchecked_duration_subtraction.rs:10:13
    |
 LL |     let _ = _first - second;
-   |             ^^^^^^^^^^^^^^^ help: try: `_first.checked_sub(second).unwrap();`
+   |             ^^^^^^^^^^^^^^^ help: try: `_first.checked_sub(second).unwrap()`
    |
    = note: `-D clippy::unchecked-duration-subtraction` implied by `-D warnings`
 
@@ -10,19 +10,19 @@ error: unchecked subtraction of a 'Duration' from an 'Instant'
   --> $DIR/unchecked_duration_subtraction.rs:12:13
    |
 LL |     let _ = Instant::now() - Duration::from_secs(5);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Instant::now().checked_sub(Duration::from_secs(5)).unwrap();`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Instant::now().checked_sub(Duration::from_secs(5)).unwrap()`
 
 error: unchecked subtraction of a 'Duration' from an 'Instant'
   --> $DIR/unchecked_duration_subtraction.rs:14:13
    |
 LL |     let _ = _first - Duration::from_secs(5);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `_first.checked_sub(Duration::from_secs(5)).unwrap();`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `_first.checked_sub(Duration::from_secs(5)).unwrap()`
 
 error: unchecked subtraction of a 'Duration' from an 'Instant'
   --> $DIR/unchecked_duration_subtraction.rs:16:13
    |
 LL |     let _ = Instant::now() - second;
-   |             ^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Instant::now().checked_sub(second).unwrap();`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Instant::now().checked_sub(second).unwrap()`
 
 error: aborting due to 4 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 36eac0cb4ae2e372193f73c3181d5290431d3ae4 Mon Sep 17 00:00:00 2001
From: Nadir Fejzic <nadirfejzo@gmail.com>
Date: Thu, 10 Nov 2022 15:55:45 +0100
Subject: fix: update lints

---
 clippy_lints/src/declared_lints.rs          |  3 ++-
 clippy_lints/src/lib.rs                     |  1 -
 src/docs/unchecked_duration_subtraction.txt | 19 -------------------
 3 files changed, 2 insertions(+), 21 deletions(-)
 delete mode 100644 src/docs/unchecked_duration_subtraction.txt

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 98265410e84..7a705e563fc 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -202,6 +202,8 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::inherent_to_string::INHERENT_TO_STRING_SHADOW_DISPLAY_INFO,
     crate::init_numbered_fields::INIT_NUMBERED_FIELDS_INFO,
     crate::inline_fn_without_body::INLINE_FN_WITHOUT_BODY_INFO,
+    crate::instant_subtraction::MANUAL_INSTANT_ELAPSED_INFO,
+    crate::instant_subtraction::UNCHECKED_DURATION_SUBTRACTION_INFO,
     crate::int_plus_one::INT_PLUS_ONE_INFO,
     crate::invalid_upcast_comparisons::INVALID_UPCAST_COMPARISONS_INFO,
     crate::invalid_utf8_in_unchecked::INVALID_UTF8_IN_UNCHECKED_INFO,
@@ -250,7 +252,6 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::manual_async_fn::MANUAL_ASYNC_FN_INFO,
     crate::manual_bits::MANUAL_BITS_INFO,
     crate::manual_clamp::MANUAL_CLAMP_INFO,
-    crate::manual_instant_elapsed::MANUAL_INSTANT_ELAPSED_INFO,
     crate::manual_is_ascii_check::MANUAL_IS_ASCII_CHECK_INFO,
     crate::manual_let_else::MANUAL_LET_ELSE_INFO,
     crate::manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index ce0e7ebfbf1..3cfb2f491bc 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -921,7 +921,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(from_raw_with_void_ptr::FromRawWithVoidPtr));
     store.register_late_pass(|_| Box::new(suspicious_xor_used_as_pow::ConfusingXorAndPow));
     store.register_late_pass(move |_| Box::new(manual_is_ascii_check::ManualIsAsciiCheck::new(msrv)));
-    store.register_late_pass(move || Box::new(unchecked_duration_subtraction::UncheckedDurationSubtraction::new(msrv)));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/src/docs/unchecked_duration_subtraction.txt b/src/docs/unchecked_duration_subtraction.txt
deleted file mode 100644
index 15a4c02c606..00000000000
--- a/src/docs/unchecked_duration_subtraction.txt
+++ /dev/null
@@ -1,19 +0,0 @@
-### What it does
-Finds patterns of unchecked subtraction of [`Duration`] from [`Instant::now()`].
-
-### Why is this bad?
-Unchecked subtraction could cause underflow on certain platforms, leading to
-unintentional panics.
-
-### Example
-```
-let time_passed = Instant::now() - Duration::from_secs(5);
-```
-
-Use instead:
-```
-let time_passed = Instant::now().checked_sub(Duration::from_secs(5));
-```
-
-[`Duration`]: std::time::Duration
-[`Instant::now()`]: std::time::Instant::now;
\ No newline at end of file
-- 
cgit 1.4.1-3-g733a5


From 2bc04bdac26fbb49e3b4ef3673f6a5143df307e7 Mon Sep 17 00:00:00 2001
From: koka <koka.code@gmail.com>
Date: Fri, 11 Nov 2022 00:14:18 +0900
Subject: fix: cognitive_complexity for async fn

---
 clippy_lints/src/cognitive_complexity.rs | 21 +++++++++++++++------
 tests/ui/cognitive_complexity.rs         |  8 ++++++++
 tests/ui/cognitive_complexity.stderr     | 10 +++++++++-
 3 files changed, 32 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/cognitive_complexity.rs b/clippy_lints/src/cognitive_complexity.rs
index 77af3b53d63..1c3a89a9782 100644
--- a/clippy_lints/src/cognitive_complexity.rs
+++ b/clippy_lints/src/cognitive_complexity.rs
@@ -4,11 +4,11 @@ use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::visitors::for_each_expr;
-use clippy_utils::LimitStack;
+use clippy_utils::{get_async_fn_body, is_async_fn, LimitStack};
 use core::ops::ControlFlow;
 use rustc_ast::ast::Attribute;
 use rustc_hir::intravisit::FnKind;
-use rustc_hir::{Body, ExprKind, FnDecl, HirId};
+use rustc_hir::{Body, Expr, ExprKind, FnDecl, HirId};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::Span;
@@ -56,15 +56,13 @@ impl CognitiveComplexity {
         cx: &LateContext<'tcx>,
         kind: FnKind<'tcx>,
         decl: &'tcx FnDecl<'_>,
-        body: &'tcx Body<'_>,
+        expr: &'tcx Expr<'_>,
         body_span: Span,
     ) {
         if body_span.from_expansion() {
             return;
         }
 
-        let expr = body.value;
-
         let mut cc = 1u64;
         let mut returns = 0u64;
         let _: Option<!> = for_each_expr(expr, |e| {
@@ -146,7 +144,18 @@ impl<'tcx> LateLintPass<'tcx> for CognitiveComplexity {
     ) {
         let def_id = cx.tcx.hir().local_def_id(hir_id);
         if !cx.tcx.has_attr(def_id.to_def_id(), sym::test) {
-            self.check(cx, kind, decl, body, span);
+            let expr = if is_async_fn(kind) {
+                match get_async_fn_body(cx.tcx, body) {
+                    Some(b) => b,
+                    None => {
+                        return;
+                    },
+                }
+            } else {
+                body.value
+            };
+
+            self.check(cx, kind, decl, expr, span);
         }
     }
 
diff --git a/tests/ui/cognitive_complexity.rs b/tests/ui/cognitive_complexity.rs
index 912e6788afd..498a9f0644f 100644
--- a/tests/ui/cognitive_complexity.rs
+++ b/tests/ui/cognitive_complexity.rs
@@ -393,3 +393,11 @@ impl Moo {
         }
     }
 }
+
+#[clippy::cognitive_complexity = "1"]
+mod issue9300 {
+    async fn a() {
+        let a = 0;
+        if a == 0 {}
+    }
+}
diff --git a/tests/ui/cognitive_complexity.stderr b/tests/ui/cognitive_complexity.stderr
index d7f2f24e52f..208f4d7b347 100644
--- a/tests/ui/cognitive_complexity.stderr
+++ b/tests/ui/cognitive_complexity.stderr
@@ -135,5 +135,13 @@ LL |     fn moo(&self) {
    |
    = help: you could split it up into multiple smaller functions
 
-error: aborting due to 17 previous errors
+error: the function has a cognitive complexity of (2/1)
+  --> $DIR/cognitive_complexity.rs:399:14
+   |
+LL |     async fn a() {
+   |              ^
+   |
+   = help: you could split it up into multiple smaller functions
+
+error: aborting due to 18 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 3790aa3d5d14ef79b27776767985716844861f33 Mon Sep 17 00:00:00 2001
From: hrxi <hrrrxi@gmail.com>
Date: Thu, 10 Nov 2022 19:42:20 +0100
Subject: Make `bool_to_int_with_if` a pedantic lint

In all the cases I've observed, it did not make the code clearer. Using
bools as integer is frowned upon in some languages, in others it's
simply not possible.

You can find comments on the original pull request #8131 that agree with
this point of view.
---
 clippy_lints/src/bool_to_int_with_if.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/bool_to_int_with_if.rs b/clippy_lints/src/bool_to_int_with_if.rs
index 40ded405669..bdb3a011602 100644
--- a/clippy_lints/src/bool_to_int_with_if.rs
+++ b/clippy_lints/src/bool_to_int_with_if.rs
@@ -13,7 +13,7 @@ declare_clippy_lint! {
     /// this lint suggests using a `from()` function or an `as` coercion.
     ///
     /// ### Why is this bad?
-    /// Coercion or `from()` is idiomatic way to convert bool to a number.
+    /// Coercion or `from()` is another way to convert bool to a number.
     /// Both methods are guaranteed to return 1 for true, and 0 for false.
     ///
     /// See https://doc.rust-lang.org/std/primitive.bool.html#impl-From%3Cbool%3E
@@ -39,7 +39,7 @@ declare_clippy_lint! {
     /// ```
     #[clippy::version = "1.65.0"]
     pub BOOL_TO_INT_WITH_IF,
-    style,
+    pedantic,
     "using if to convert bool to int"
 }
 declare_lint_pass!(BoolToIntWithIf => [BOOL_TO_INT_WITH_IF]);
-- 
cgit 1.4.1-3-g733a5


From 39398e163ac7508b585f07821e5be195102a4017 Mon Sep 17 00:00:00 2001
From: koka <koka.code@gmail.com>
Date: Sat, 12 Nov 2022 19:15:21 +0900
Subject: fix: use HasPlaceholders * remove unnecessary mutability * fix typo

---
 clippy_lints/src/manual_is_ascii_check.rs | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_is_ascii_check.rs b/clippy_lints/src/manual_is_ascii_check.rs
index 3a6b693f766..bb8c142f8e4 100644
--- a/clippy_lints/src/manual_is_ascii_check.rs
+++ b/clippy_lints/src/manual_is_ascii_check.rs
@@ -91,15 +91,16 @@ impl<'tcx> LateLintPass<'tcx> for ManualIsAsciiCheck {
                     CharRange::Digit => Some("is_ascii_digit"),
                     CharRange::Otherwise => None,
                 } {
-                    let mut applicability = Applicability::MaybeIncorrect;
                     let default_snip = "..";
                     // `snippet_with_applicability` may set applicability to `MaybeIncorrect` for
-                    // macro span, so we check applicability manually by comaring `recv` is not default.
+                    // macro span, so we check applicability manually by comparing `recv` is not default.
                     let recv = snippet(cx, recv.span, default_snip);
 
-                    if recv != default_snip {
-                        applicability = Applicability::MachineApplicable;
-                    }
+                    let applicability = if recv == default_snip {
+                        Applicability::HasPlaceholders
+                    } else {
+                        Applicability::MachineApplicable
+                    };
 
                     span_lint_and_sugg(
                         cx,
-- 
cgit 1.4.1-3-g733a5


From 93edc127a0d9a5ecd403a2f72ff6c02c5fadb696 Mon Sep 17 00:00:00 2001
From: koka <koka.code@gmail.com>
Date: Sat, 12 Nov 2022 20:31:25 +0900
Subject: Avoid lint to unsized mutable reference

---
 clippy_lints/src/mut_mut.rs | 16 +++++++++-------
 tests/ui/mut_mut.rs         | 17 +++++++++++++++++
 2 files changed, 26 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/mut_mut.rs b/clippy_lints/src/mut_mut.rs
index cb16f00047a..ae17327fd2a 100644
--- a/clippy_lints/src/mut_mut.rs
+++ b/clippy_lints/src/mut_mut.rs
@@ -68,13 +68,15 @@ impl<'a, 'tcx> intravisit::Visitor<'tcx> for MutVisitor<'a, 'tcx> {
                     expr.span,
                     "generally you want to avoid `&mut &mut _` if possible",
                 );
-            } else if let ty::Ref(_, _, hir::Mutability::Mut) = self.cx.typeck_results().expr_ty(e).kind() {
-                span_lint(
-                    self.cx,
-                    MUT_MUT,
-                    expr.span,
-                    "this expression mutably borrows a mutable reference. Consider reborrowing",
-                );
+            } else if let ty::Ref(_, ty, hir::Mutability::Mut) = self.cx.typeck_results().expr_ty(e).kind() {
+                if ty.peel_refs().is_sized(self.cx.tcx.at(expr.span), self.cx.param_env) {
+                    span_lint(
+                        self.cx,
+                        MUT_MUT,
+                        expr.span,
+                        "this expression mutably borrows a mutable reference. Consider reborrowing",
+                    );
+                }
             }
         }
     }
diff --git a/tests/ui/mut_mut.rs b/tests/ui/mut_mut.rs
index ac8fd9d8fb0..ee3a856566c 100644
--- a/tests/ui/mut_mut.rs
+++ b/tests/ui/mut_mut.rs
@@ -57,3 +57,20 @@ fn issue6922() {
     // do not lint from an external macro
     mut_mut!();
 }
+
+mod issue9035 {
+    use std::fmt::Display;
+
+    struct Foo<'a> {
+        inner: &'a mut dyn Display,
+    }
+
+    impl Foo<'_> {
+        fn foo(&mut self) {
+            let hlp = &mut self.inner;
+            bar(hlp);
+        }
+    }
+
+    fn bar(_: &mut impl Display) {}
+}
-- 
cgit 1.4.1-3-g733a5


From 989986144c889051eb3014cc1fdc0891bbb483f5 Mon Sep 17 00:00:00 2001
From: Kartavya Vashishtha <sendtokartavya@gmail.com>
Date: Sat, 12 Nov 2022 20:36:30 +0530
Subject: fix never_loop false positive

on unconditional break to internal labeled block

ref #9831
---
 clippy_lints/src/loops/never_loop.rs |  3 ++-
 tests/ui/never_loop.rs               | 12 ++++++++++++
 2 files changed, 14 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/never_loop.rs b/clippy_lints/src/loops/never_loop.rs
index 16b00ad6637..abb18187ef1 100644
--- a/clippy_lints/src/loops/never_loop.rs
+++ b/clippy_lints/src/loops/never_loop.rs
@@ -169,7 +169,8 @@ fn never_loop_expr(expr: &Expr<'_>, main_loop_id: HirId) -> NeverLoopResult {
                 combine_seq(e, arms)
             }
         },
-        ExprKind::Block(b, _) => never_loop_block(b, main_loop_id),
+        ExprKind::Block(b, None) => never_loop_block(b, main_loop_id),
+        ExprKind::Block(b, Some(_label)) => absorb_break(never_loop_block(b, main_loop_id)),
         ExprKind::Continue(d) => {
             let id = d
                 .target_id
diff --git a/tests/ui/never_loop.rs b/tests/ui/never_loop.rs
index 3dbef19890e..86a5d03f765 100644
--- a/tests/ui/never_loop.rs
+++ b/tests/ui/never_loop.rs
@@ -229,6 +229,18 @@ pub fn test18() {
     };
 }
 
+// Issue #9831: unconditional break to internal labeled block
+pub fn test19() {
+    fn thing(iter: impl Iterator) {
+        for _ in iter {
+            'b: {
+                // error goes away if we just have the block's value be ().
+                break 'b;
+            }
+        }
+    }
+}
+
 fn main() {
     test1();
     test2();
-- 
cgit 1.4.1-3-g733a5


From 243661b739b122f51a17e64161d9f3a1324b8d6a Mon Sep 17 00:00:00 2001
From: hrxi <hrrrxi@gmail.com>
Date: Sat, 12 Nov 2022 22:26:09 +0100
Subject: Make it clear that `or_fun_call` can be a false-positive

Also move it to nursery so that the false-positives can be dealt with.

CC #8574
---
 clippy_lints/src/methods/mod.rs | 22 ++++++++++------------
 tests/ui/unwrap_or.rs           |  2 +-
 2 files changed, 11 insertions(+), 13 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 82a2cc62d82..53f9c355c5d 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -832,32 +832,30 @@ declare_clippy_lint! {
     /// etc. instead.
     ///
     /// ### Why is this bad?
-    /// The function will always be called and potentially
-    /// allocate an object acting as the default.
+    /// The function will always be called. This is only bad if it allocates or
+    /// does some non-trivial amount of work.
     ///
     /// ### Known problems
-    /// If the function has side-effects, not calling it will
-    /// change the semantic of the program, but you shouldn't rely on that anyway.
+    /// If the function has side-effects, not calling it will change the
+    /// semantic of the program, but you shouldn't rely on that.
+    ///
+    /// The lint also cannot figure out whether the function you call is
+    /// actually expensive to call or not.
     ///
     /// ### Example
     /// ```rust
     /// # let foo = Some(String::new());
-    /// foo.unwrap_or(String::new());
+    /// foo.unwrap_or(String::from("empty"));
     /// ```
     ///
     /// Use instead:
     /// ```rust
     /// # let foo = Some(String::new());
-    /// foo.unwrap_or_else(String::new);
-    ///
-    /// // or
-    ///
-    /// # let foo = Some(String::new());
-    /// foo.unwrap_or_default();
+    /// foo.unwrap_or_else(|| String::from("empty"));
     /// ```
     #[clippy::version = "pre 1.29.0"]
     pub OR_FUN_CALL,
-    perf,
+    nursery,
     "using any `*or` method with a function call, which suggests `*or_else`"
 }
 
diff --git a/tests/ui/unwrap_or.rs b/tests/ui/unwrap_or.rs
index bfb41e43947..a0c003f5b1e 100644
--- a/tests/ui/unwrap_or.rs
+++ b/tests/ui/unwrap_or.rs
@@ -1,4 +1,4 @@
-#![warn(clippy::all)]
+#![warn(clippy::all, clippy::or_fun_call)]
 
 fn main() {
     let s = Some(String::from("test string")).unwrap_or("Fail".to_string()).len();
-- 
cgit 1.4.1-3-g733a5


From b8357ffd1f2b3f7cd12b7cd29d32c08a5ec5b7c5 Mon Sep 17 00:00:00 2001
From: Lukas Markeffsky <@>
Date: Mon, 14 Nov 2022 16:06:21 +0100
Subject: fix `vec-box-size-threshold` off-by-one error

---
 clippy_lints/src/types/vec_box.rs       | 2 +-
 tests/ui-toml/vec_box_sized/test.rs     | 5 +++--
 tests/ui-toml/vec_box_sized/test.stderr | 6 +++---
 3 files changed, 7 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types/vec_box.rs b/clippy_lints/src/types/vec_box.rs
index 6c329d8cdf1..02703ebecb9 100644
--- a/clippy_lints/src/types/vec_box.rs
+++ b/clippy_lints/src/types/vec_box.rs
@@ -42,7 +42,7 @@ pub(super) fn check(
             if !ty_ty.has_escaping_bound_vars();
             if ty_ty.is_sized(cx.tcx.at(ty.span), cx.param_env);
             if let Ok(ty_ty_size) = cx.layout_of(ty_ty).map(|l| l.size.bytes());
-            if ty_ty_size <= box_size_threshold;
+            if ty_ty_size < box_size_threshold;
             then {
                 span_lint_and_sugg(
                     cx,
diff --git a/tests/ui-toml/vec_box_sized/test.rs b/tests/ui-toml/vec_box_sized/test.rs
index bf04bee1637..4c46deb585b 100644
--- a/tests/ui-toml/vec_box_sized/test.rs
+++ b/tests/ui-toml/vec_box_sized/test.rs
@@ -7,8 +7,9 @@ struct C {
 }
 
 struct Foo(Vec<Box<u8>>);
-struct Bar(Vec<Box<u32>>);
-struct Baz(Vec<Box<(u32, u32)>>);
+struct Bar(Vec<Box<u16>>);
+struct Quux(Vec<Box<u32>>);
+struct Baz(Vec<Box<(u16, u16)>>);
 struct BarBaz(Vec<Box<S>>);
 struct FooBarBaz(Vec<Box<C>>);
 
diff --git a/tests/ui-toml/vec_box_sized/test.stderr b/tests/ui-toml/vec_box_sized/test.stderr
index cf194de3c55..55de68f8ecf 100644
--- a/tests/ui-toml/vec_box_sized/test.stderr
+++ b/tests/ui-toml/vec_box_sized/test.stderr
@@ -9,11 +9,11 @@ LL | struct Foo(Vec<Box<u8>>);
 error: `Vec<T>` is already on the heap, the boxing is unnecessary
   --> $DIR/test.rs:10:12
    |
-LL | struct Bar(Vec<Box<u32>>);
-   |            ^^^^^^^^^^^^^ help: try: `Vec<u32>`
+LL | struct Bar(Vec<Box<u16>>);
+   |            ^^^^^^^^^^^^^ help: try: `Vec<u16>`
 
 error: `Vec<T>` is already on the heap, the boxing is unnecessary
-  --> $DIR/test.rs:13:18
+  --> $DIR/test.rs:14:18
    |
 LL | struct FooBarBaz(Vec<Box<C>>);
    |                  ^^^^^^^^^^^ help: try: `Vec<C>`
-- 
cgit 1.4.1-3-g733a5


From 3f89ab0618a1075f0c53c47d405c0f6e9bf43953 Mon Sep 17 00:00:00 2001
From: Nadir Fejzic <nadirfejzo@gmail.com>
Date: Mon, 14 Nov 2022 22:00:09 +0100
Subject: chore: update lint version of MANUAL_INSTAN_ELAPSED to 1.65

---
 clippy_lints/src/instant_subtraction.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/instant_subtraction.rs b/clippy_lints/src/instant_subtraction.rs
index d83beb622cf..6d23a672856 100644
--- a/clippy_lints/src/instant_subtraction.rs
+++ b/clippy_lints/src/instant_subtraction.rs
@@ -33,7 +33,7 @@ declare_clippy_lint! {
     /// let prev_instant = Instant::now();
     /// let duration = prev_instant.elapsed();
     /// ```
-    #[clippy::version = "1.64.0"]
+    #[clippy::version = "1.65.0"]
     pub MANUAL_INSTANT_ELAPSED,
     pedantic,
     "subtraction between `Instant::now()` and previous `Instant`"
-- 
cgit 1.4.1-3-g733a5


From 912dc919af03427288b64921bb4aea0010d071bf Mon Sep 17 00:00:00 2001
From: Nadir Fejzic <nadirfejzo@gmail.com>
Date: Mon, 14 Nov 2022 22:08:11 +0100
Subject: docs: update unchecked duration subtraction lint doc

---
 clippy_lints/src/instant_subtraction.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/instant_subtraction.rs b/clippy_lints/src/instant_subtraction.rs
index 6d23a672856..3f72222f31b 100644
--- a/clippy_lints/src/instant_subtraction.rs
+++ b/clippy_lints/src/instant_subtraction.rs
@@ -41,7 +41,7 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Finds patterns of unchecked subtraction of [`Duration`] from [`Instant::now()`].
+    /// Lints subtraction between an [`Instant`] and a [`Duration`].
     ///
     /// ### Why is this bad?
     /// Unchecked subtraction could cause underflow on certain platforms, leading to
-- 
cgit 1.4.1-3-g733a5


From 72ab91d8066ee399cff3e3c8293bf4dbccfb6358 Mon Sep 17 00:00:00 2001
From: Nadir Fejzic <nadirfejzo@gmail.com>
Date: Mon, 14 Nov 2022 22:25:56 +0100
Subject: fix: add extract_msrv_attr call to instan_subtraction lint pass

---
 clippy_lints/src/instant_subtraction.rs | 2 ++
 1 file changed, 2 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/instant_subtraction.rs b/clippy_lints/src/instant_subtraction.rs
index 3f72222f31b..716c11becd9 100644
--- a/clippy_lints/src/instant_subtraction.rs
+++ b/clippy_lints/src/instant_subtraction.rs
@@ -112,6 +112,8 @@ impl LateLintPass<'_> for InstantSubtraction {
             }
         }
     }
+
+    extract_msrv_attr!(LateContext);
 }
 
 fn is_instant_now_call(cx: &LateContext<'_>, expr_block: &'_ Expr<'_>) -> bool {
-- 
cgit 1.4.1-3-g733a5


From 0dd6ce0b1931e3e5c274daf4bbf50e96a322befd Mon Sep 17 00:00:00 2001
From: Nadir Fejzic <nadirfejzo@gmail.com>
Date: Mon, 14 Nov 2022 22:37:25 +0100
Subject: docs: import Instant and Duration in doctests

---
 clippy_lints/src/instant_subtraction.rs | 2 ++
 1 file changed, 2 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/instant_subtraction.rs b/clippy_lints/src/instant_subtraction.rs
index 716c11becd9..60754b224fc 100644
--- a/clippy_lints/src/instant_subtraction.rs
+++ b/clippy_lints/src/instant_subtraction.rs
@@ -49,11 +49,13 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust
+    /// # use std::time::{Instant, Duration};
     /// let time_passed = Instant::now() - Duration::from_secs(5);
     /// ```
     ///
     /// Use instead:
     /// ```rust
+    /// # use std::time::{Instant, Duration};
     /// let time_passed = Instant::now().checked_sub(Duration::from_secs(5));
     /// ```
     ///
-- 
cgit 1.4.1-3-g733a5


From 7c4611c7e170a7eb6a642f9267b95a14f0cd54de Mon Sep 17 00:00:00 2001
From: koka <koka.code@gmail.com>
Date: Tue, 15 Nov 2022 12:58:17 +0900
Subject: Allow return types for closures with lifetime binder

---
 clippy_lints/src/unused_unit.rs |  8 ++++++--
 tests/ui/unused_unit.fixed      |  7 +++++++
 tests/ui/unused_unit.rs         |  7 +++++++
 tests/ui/unused_unit.stderr     | 40 ++++++++++++++++++++--------------------
 4 files changed, 40 insertions(+), 22 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unused_unit.rs b/clippy_lints/src/unused_unit.rs
index cd1d90e860b..cad8da18c2f 100644
--- a/clippy_lints/src/unused_unit.rs
+++ b/clippy_lints/src/unused_unit.rs
@@ -1,8 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::{position_before_rarrow, snippet_opt};
 use if_chain::if_chain;
-use rustc_ast::ast;
-use rustc_ast::visit::FnKind;
+use rustc_ast::{ast, visit::FnKind, ClosureBinder};
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -43,6 +42,11 @@ impl EarlyLintPass for UnusedUnit {
             if let ast::TyKind::Tup(ref vals) = ty.kind;
             if vals.is_empty() && !ty.span.from_expansion() && get_def(span) == get_def(ty.span);
             then {
+                // implicit types in closure signatures are forbidden when `for<...>` is present
+                if let FnKind::Closure(&ClosureBinder::For { .. }, ..) = kind {
+                    return;
+                }
+
                 lint_unneeded_unit_return(cx, ty, span);
             }
         }
diff --git a/tests/ui/unused_unit.fixed b/tests/ui/unused_unit.fixed
index 7bb43cf7ae8..3dd640b86f0 100644
--- a/tests/ui/unused_unit.fixed
+++ b/tests/ui/unused_unit.fixed
@@ -7,6 +7,7 @@
 // test of the JSON error format.
 
 #![feature(custom_inner_attributes)]
+#![feature(closure_lifetime_binder)]
 #![rustfmt::skip]
 
 #![deny(clippy::unused_unit)]
@@ -87,3 +88,9 @@ fn macro_expr() {
     }
     e!()
 }
+
+mod issue9748 {
+    fn main() {
+        let _ = for<'a> |_: &'a u32| -> () {};
+    }
+}
diff --git a/tests/ui/unused_unit.rs b/tests/ui/unused_unit.rs
index 21073fb802a..bddecf06fb7 100644
--- a/tests/ui/unused_unit.rs
+++ b/tests/ui/unused_unit.rs
@@ -7,6 +7,7 @@
 // test of the JSON error format.
 
 #![feature(custom_inner_attributes)]
+#![feature(closure_lifetime_binder)]
 #![rustfmt::skip]
 
 #![deny(clippy::unused_unit)]
@@ -87,3 +88,9 @@ fn macro_expr() {
     }
     e!()
 }
+
+mod issue9748 {
+    fn main() {
+        let _ = for<'a> |_: &'a u32| -> () {};
+    }
+}
diff --git a/tests/ui/unused_unit.stderr b/tests/ui/unused_unit.stderr
index 0d2cb77855b..ce06738cfe4 100644
--- a/tests/ui/unused_unit.stderr
+++ b/tests/ui/unused_unit.stderr
@@ -1,119 +1,119 @@
 error: unneeded unit return type
-  --> $DIR/unused_unit.rs:19:58
+  --> $DIR/unused_unit.rs:20:58
    |
 LL |     pub fn get_unit<F: Fn() -> (), G>(&self, f: F, _g: G) -> ()
    |                                                          ^^^^^^ help: remove the `-> ()`
    |
 note: the lint level is defined here
-  --> $DIR/unused_unit.rs:12:9
+  --> $DIR/unused_unit.rs:13:9
    |
 LL | #![deny(clippy::unused_unit)]
    |         ^^^^^^^^^^^^^^^^^^^
 
 error: unneeded unit return type
-  --> $DIR/unused_unit.rs:19:28
+  --> $DIR/unused_unit.rs:20:28
    |
 LL |     pub fn get_unit<F: Fn() -> (), G>(&self, f: F, _g: G) -> ()
    |                            ^^^^^^ help: remove the `-> ()`
 
 error: unneeded unit return type
-  --> $DIR/unused_unit.rs:20:18
+  --> $DIR/unused_unit.rs:21:18
    |
 LL |     where G: Fn() -> () {
    |                  ^^^^^^ help: remove the `-> ()`
 
 error: unneeded unit return type
-  --> $DIR/unused_unit.rs:21:26
+  --> $DIR/unused_unit.rs:22:26
    |
 LL |         let _y: &dyn Fn() -> () = &f;
    |                          ^^^^^^ help: remove the `-> ()`
 
 error: unneeded unit return type
-  --> $DIR/unused_unit.rs:28:18
+  --> $DIR/unused_unit.rs:29:18
    |
 LL |     fn into(self) -> () {
    |                  ^^^^^^ help: remove the `-> ()`
 
 error: unneeded unit expression
-  --> $DIR/unused_unit.rs:29:9
+  --> $DIR/unused_unit.rs:30:9
    |
 LL |         ()
    |         ^^ help: remove the final `()`
 
 error: unneeded unit return type
-  --> $DIR/unused_unit.rs:34:29
+  --> $DIR/unused_unit.rs:35:29
    |
 LL |     fn redundant<F: FnOnce() -> (), G, H>(&self, _f: F, _g: G, _h: H)
    |                             ^^^^^^ help: remove the `-> ()`
 
 error: unneeded unit return type
-  --> $DIR/unused_unit.rs:36:19
+  --> $DIR/unused_unit.rs:37:19
    |
 LL |         G: FnMut() -> (),
    |                   ^^^^^^ help: remove the `-> ()`
 
 error: unneeded unit return type
-  --> $DIR/unused_unit.rs:37:16
+  --> $DIR/unused_unit.rs:38:16
    |
 LL |         H: Fn() -> ();
    |                ^^^^^^ help: remove the `-> ()`
 
 error: unneeded unit return type
-  --> $DIR/unused_unit.rs:41:29
+  --> $DIR/unused_unit.rs:42:29
    |
 LL |     fn redundant<F: FnOnce() -> (), G, H>(&self, _f: F, _g: G, _h: H)
    |                             ^^^^^^ help: remove the `-> ()`
 
 error: unneeded unit return type
-  --> $DIR/unused_unit.rs:43:19
+  --> $DIR/unused_unit.rs:44:19
    |
 LL |         G: FnMut() -> (),
    |                   ^^^^^^ help: remove the `-> ()`
 
 error: unneeded unit return type
-  --> $DIR/unused_unit.rs:44:16
+  --> $DIR/unused_unit.rs:45:16
    |
 LL |         H: Fn() -> () {}
    |                ^^^^^^ help: remove the `-> ()`
 
 error: unneeded unit return type
-  --> $DIR/unused_unit.rs:47:17
+  --> $DIR/unused_unit.rs:48:17
    |
 LL | fn return_unit() -> () { () }
    |                 ^^^^^^ help: remove the `-> ()`
 
 error: unneeded unit expression
-  --> $DIR/unused_unit.rs:47:26
+  --> $DIR/unused_unit.rs:48:26
    |
 LL | fn return_unit() -> () { () }
    |                          ^^ help: remove the final `()`
 
 error: unneeded `()`
-  --> $DIR/unused_unit.rs:57:14
+  --> $DIR/unused_unit.rs:58:14
    |
 LL |         break();
    |              ^^ help: remove the `()`
 
 error: unneeded `()`
-  --> $DIR/unused_unit.rs:59:11
+  --> $DIR/unused_unit.rs:60:11
    |
 LL |     return();
    |           ^^ help: remove the `()`
 
 error: unneeded unit return type
-  --> $DIR/unused_unit.rs:76:10
+  --> $DIR/unused_unit.rs:77:10
    |
 LL | fn test()->(){}
    |          ^^^^ help: remove the `-> ()`
 
 error: unneeded unit return type
-  --> $DIR/unused_unit.rs:79:11
+  --> $DIR/unused_unit.rs:80:11
    |
 LL | fn test2() ->(){}
    |           ^^^^^ help: remove the `-> ()`
 
 error: unneeded unit return type
-  --> $DIR/unused_unit.rs:82:11
+  --> $DIR/unused_unit.rs:83:11
    |
 LL | fn test3()-> (){}
    |           ^^^^^ help: remove the `-> ()`
-- 
cgit 1.4.1-3-g733a5


From 93ac0f58bfeb8046a6e49b79fbaca0cb27d92f56 Mon Sep 17 00:00:00 2001
From: Aphek <bilkow@tutanota.com>
Date: Tue, 15 Nov 2022 01:57:56 -0300
Subject: Keep `ref` on `infallible_destructuring_match` suggestion

---
 .../src/matches/infallible_destructuring_match.rs        |  7 ++++---
 tests/ui/infallible_destructuring_match.fixed            | 12 ++++++++++++
 tests/ui/infallible_destructuring_match.rs               | 14 ++++++++++++++
 tests/ui/infallible_destructuring_match.stderr           | 16 ++++++++++++----
 4 files changed, 42 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/infallible_destructuring_match.rs b/clippy_lints/src/matches/infallible_destructuring_match.rs
index 2472acb6f6e..d18c92caba2 100644
--- a/clippy_lints/src/matches/infallible_destructuring_match.rs
+++ b/clippy_lints/src/matches/infallible_destructuring_match.rs
@@ -2,7 +2,7 @@ use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::{path_to_local_id, peel_blocks, strip_pat_refs};
 use rustc_errors::Applicability;
-use rustc_hir::{ExprKind, Local, MatchSource, PatKind, QPath};
+use rustc_hir::{ByRef, ExprKind, Local, MatchSource, PatKind, QPath};
 use rustc_lint::LateContext;
 
 use super::INFALLIBLE_DESTRUCTURING_MATCH;
@@ -16,7 +16,7 @@ pub(crate) fn check(cx: &LateContext<'_>, local: &Local<'_>) -> bool {
         if let PatKind::TupleStruct(
             QPath::Resolved(None, variant_name), args, _) = arms[0].pat.kind;
         if args.len() == 1;
-        if let PatKind::Binding(_, arg, ..) = strip_pat_refs(&args[0]).kind;
+        if let PatKind::Binding(binding, arg, ..) = strip_pat_refs(&args[0]).kind;
         let body = peel_blocks(arms[0].body);
         if path_to_local_id(body, arg);
 
@@ -30,8 +30,9 @@ pub(crate) fn check(cx: &LateContext<'_>, local: &Local<'_>) -> bool {
                 Consider using `let`",
                 "try this",
                 format!(
-                    "let {}({}) = {};",
+                    "let {}({}{}) = {};",
                     snippet_with_applicability(cx, variant_name.span, "..", &mut applicability),
+                    if binding.0 == ByRef::Yes { "ref " } else { "" },
                     snippet_with_applicability(cx, local.pat.span, "..", &mut applicability),
                     snippet_with_applicability(cx, target.span, "..", &mut applicability),
                 ),
diff --git a/tests/ui/infallible_destructuring_match.fixed b/tests/ui/infallible_destructuring_match.fixed
index b8e40d99553..61985e56b76 100644
--- a/tests/ui/infallible_destructuring_match.fixed
+++ b/tests/ui/infallible_destructuring_match.fixed
@@ -9,6 +9,9 @@ enum SingleVariantEnum {
 
 struct TupleStruct(i32);
 
+struct NonCopy;
+struct TupleStructWithNonCopy(NonCopy);
+
 enum EmptyEnum {}
 
 macro_rules! match_enum {
@@ -71,6 +74,15 @@ fn infallible_destructuring_match_struct() {
     let TupleStruct(data) = wrapper;
 }
 
+fn infallible_destructuring_match_struct_with_noncopy() {
+    let wrapper = TupleStructWithNonCopy(NonCopy);
+
+    // This should lint! (keeping `ref` in the suggestion)
+    let TupleStructWithNonCopy(ref data) = wrapper;
+
+    let TupleStructWithNonCopy(ref data) = wrapper;
+}
+
 macro_rules! match_never_enum {
     ($param:expr) => {
         let data = match $param {
diff --git a/tests/ui/infallible_destructuring_match.rs b/tests/ui/infallible_destructuring_match.rs
index 106cd438b90..f2768245bbc 100644
--- a/tests/ui/infallible_destructuring_match.rs
+++ b/tests/ui/infallible_destructuring_match.rs
@@ -9,6 +9,9 @@ enum SingleVariantEnum {
 
 struct TupleStruct(i32);
 
+struct NonCopy;
+struct TupleStructWithNonCopy(NonCopy);
+
 enum EmptyEnum {}
 
 macro_rules! match_enum {
@@ -75,6 +78,17 @@ fn infallible_destructuring_match_struct() {
     let TupleStruct(data) = wrapper;
 }
 
+fn infallible_destructuring_match_struct_with_noncopy() {
+    let wrapper = TupleStructWithNonCopy(NonCopy);
+
+    // This should lint! (keeping `ref` in the suggestion)
+    let data = match wrapper {
+        TupleStructWithNonCopy(ref n) => n,
+    };
+
+    let TupleStructWithNonCopy(ref data) = wrapper;
+}
+
 macro_rules! match_never_enum {
     ($param:expr) => {
         let data = match $param {
diff --git a/tests/ui/infallible_destructuring_match.stderr b/tests/ui/infallible_destructuring_match.stderr
index 1b78db42014..f8a50f0223d 100644
--- a/tests/ui/infallible_destructuring_match.stderr
+++ b/tests/ui/infallible_destructuring_match.stderr
@@ -1,5 +1,5 @@
 error: you seem to be trying to use `match` to destructure a single infallible pattern. Consider using `let`
-  --> $DIR/infallible_destructuring_match.rs:26:5
+  --> $DIR/infallible_destructuring_match.rs:29:5
    |
 LL | /     let data = match wrapper {
 LL | |         SingleVariantEnum::Variant(i) => i,
@@ -9,7 +9,7 @@ LL | |     };
    = note: `-D clippy::infallible-destructuring-match` implied by `-D warnings`
 
 error: you seem to be trying to use `match` to destructure a single infallible pattern. Consider using `let`
-  --> $DIR/infallible_destructuring_match.rs:58:5
+  --> $DIR/infallible_destructuring_match.rs:61:5
    |
 LL | /     let data = match wrapper {
 LL | |         TupleStruct(i) => i,
@@ -17,12 +17,20 @@ LL | |     };
    | |______^ help: try this: `let TupleStruct(data) = wrapper;`
 
 error: you seem to be trying to use `match` to destructure a single infallible pattern. Consider using `let`
-  --> $DIR/infallible_destructuring_match.rs:90:5
+  --> $DIR/infallible_destructuring_match.rs:85:5
+   |
+LL | /     let data = match wrapper {
+LL | |         TupleStructWithNonCopy(ref n) => n,
+LL | |     };
+   | |______^ help: try this: `let TupleStructWithNonCopy(ref data) = wrapper;`
+
+error: you seem to be trying to use `match` to destructure a single infallible pattern. Consider using `let`
+  --> $DIR/infallible_destructuring_match.rs:104:5
    |
 LL | /     let data = match wrapper {
 LL | |         Ok(i) => i,
 LL | |     };
    | |______^ help: try this: `let Ok(data) = wrapper;`
 
-error: aborting due to 3 previous errors
+error: aborting due to 4 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From f75fc857839ff71e89d968bb1952e54a3969fb9f Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Tue, 15 Nov 2022 18:24:18 +0000
Subject: Extend `needless_borrowed_reference` to structs and tuples, ignore _

---
 clippy_lints/src/enum_variants.rs             |   2 +-
 clippy_lints/src/int_plus_one.rs              |  28 +++----
 clippy_lints/src/len_zero.rs                  |   3 +-
 clippy_lints/src/needless_borrowed_ref.rs     | 108 +++++++++++++++---------
 clippy_lints/src/unsafe_removed_from_name.rs  |   2 +-
 clippy_utils/src/consts.rs                    |  22 ++---
 clippy_utils/src/hir_utils.rs                 |  16 ++--
 tests/ui/match_expr_like_matches_macro.fixed  |   7 +-
 tests/ui/match_expr_like_matches_macro.rs     |   7 +-
 tests/ui/match_expr_like_matches_macro.stderr |  28 +++----
 tests/ui/needless_borrowed_ref.fixed          |  67 ++++++++++++++-
 tests/ui/needless_borrowed_ref.rs             |  67 ++++++++++++++-
 tests/ui/needless_borrowed_ref.stderr         | 113 +++++++++++++++++++++++---
 13 files changed, 356 insertions(+), 114 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/enum_variants.rs b/clippy_lints/src/enum_variants.rs
index b019d07d53d..7add358e8e4 100644
--- a/clippy_lints/src/enum_variants.rs
+++ b/clippy_lints/src/enum_variants.rs
@@ -250,7 +250,7 @@ impl LateLintPass<'_> for EnumVariantNames {
         let item_name = item.ident.name.as_str();
         let item_camel = to_camel_case(item_name);
         if !item.span.from_expansion() && is_present_in_source(cx, item.span) {
-            if let Some(&(ref mod_name, ref mod_camel)) = self.modules.last() {
+            if let Some((mod_name, mod_camel)) = self.modules.last() {
                 // constants don't have surrounding modules
                 if !mod_camel.is_empty() {
                     if mod_name == &item.ident.name {
diff --git a/clippy_lints/src/int_plus_one.rs b/clippy_lints/src/int_plus_one.rs
index 33491da3fc5..51757592c02 100644
--- a/clippy_lints/src/int_plus_one.rs
+++ b/clippy_lints/src/int_plus_one.rs
@@ -62,58 +62,54 @@ impl IntPlusOne {
     fn check_binop(cx: &EarlyContext<'_>, binop: BinOpKind, lhs: &Expr, rhs: &Expr) -> Option<String> {
         match (binop, &lhs.kind, &rhs.kind) {
             // case where `x - 1 >= ...` or `-1 + x >= ...`
-            (BinOpKind::Ge, &ExprKind::Binary(ref lhskind, ref lhslhs, ref lhsrhs), _) => {
+            (BinOpKind::Ge, ExprKind::Binary(lhskind, lhslhs, lhsrhs), _) => {
                 match (lhskind.node, &lhslhs.kind, &lhsrhs.kind) {
                     // `-1 + x`
-                    (BinOpKind::Add, &ExprKind::Lit(ref lit), _) if Self::check_lit(lit, -1) => {
+                    (BinOpKind::Add, ExprKind::Lit(lit), _) if Self::check_lit(lit, -1) => {
                         Self::generate_recommendation(cx, binop, lhsrhs, rhs, Side::Lhs)
                     },
                     // `x - 1`
-                    (BinOpKind::Sub, _, &ExprKind::Lit(ref lit)) if Self::check_lit(lit, 1) => {
+                    (BinOpKind::Sub, _, ExprKind::Lit(lit)) if Self::check_lit(lit, 1) => {
                         Self::generate_recommendation(cx, binop, lhslhs, rhs, Side::Lhs)
                     },
                     _ => None,
                 }
             },
             // case where `... >= y + 1` or `... >= 1 + y`
-            (BinOpKind::Ge, _, &ExprKind::Binary(ref rhskind, ref rhslhs, ref rhsrhs))
-                if rhskind.node == BinOpKind::Add =>
-            {
+            (BinOpKind::Ge, _, ExprKind::Binary(rhskind, rhslhs, rhsrhs)) if rhskind.node == BinOpKind::Add => {
                 match (&rhslhs.kind, &rhsrhs.kind) {
                     // `y + 1` and `1 + y`
-                    (&ExprKind::Lit(ref lit), _) if Self::check_lit(lit, 1) => {
+                    (ExprKind::Lit(lit), _) if Self::check_lit(lit, 1) => {
                         Self::generate_recommendation(cx, binop, rhsrhs, lhs, Side::Rhs)
                     },
-                    (_, &ExprKind::Lit(ref lit)) if Self::check_lit(lit, 1) => {
+                    (_, ExprKind::Lit(lit)) if Self::check_lit(lit, 1) => {
                         Self::generate_recommendation(cx, binop, rhslhs, lhs, Side::Rhs)
                     },
                     _ => None,
                 }
             },
             // case where `x + 1 <= ...` or `1 + x <= ...`
-            (BinOpKind::Le, &ExprKind::Binary(ref lhskind, ref lhslhs, ref lhsrhs), _)
-                if lhskind.node == BinOpKind::Add =>
-            {
+            (BinOpKind::Le, ExprKind::Binary(lhskind, lhslhs, lhsrhs), _) if lhskind.node == BinOpKind::Add => {
                 match (&lhslhs.kind, &lhsrhs.kind) {
                     // `1 + x` and `x + 1`
-                    (&ExprKind::Lit(ref lit), _) if Self::check_lit(lit, 1) => {
+                    (ExprKind::Lit(lit), _) if Self::check_lit(lit, 1) => {
                         Self::generate_recommendation(cx, binop, lhsrhs, rhs, Side::Lhs)
                     },
-                    (_, &ExprKind::Lit(ref lit)) if Self::check_lit(lit, 1) => {
+                    (_, ExprKind::Lit(lit)) if Self::check_lit(lit, 1) => {
                         Self::generate_recommendation(cx, binop, lhslhs, rhs, Side::Lhs)
                     },
                     _ => None,
                 }
             },
             // case where `... >= y - 1` or `... >= -1 + y`
-            (BinOpKind::Le, _, &ExprKind::Binary(ref rhskind, ref rhslhs, ref rhsrhs)) => {
+            (BinOpKind::Le, _, ExprKind::Binary(rhskind, rhslhs, rhsrhs)) => {
                 match (rhskind.node, &rhslhs.kind, &rhsrhs.kind) {
                     // `-1 + y`
-                    (BinOpKind::Add, &ExprKind::Lit(ref lit), _) if Self::check_lit(lit, -1) => {
+                    (BinOpKind::Add, ExprKind::Lit(lit), _) if Self::check_lit(lit, -1) => {
                         Self::generate_recommendation(cx, binop, rhsrhs, lhs, Side::Rhs)
                     },
                     // `y - 1`
-                    (BinOpKind::Sub, _, &ExprKind::Lit(ref lit)) if Self::check_lit(lit, 1) => {
+                    (BinOpKind::Sub, _, ExprKind::Lit(lit)) if Self::check_lit(lit, 1) => {
                         Self::generate_recommendation(cx, binop, rhslhs, lhs, Side::Rhs)
                     },
                     _ => None,
diff --git a/clippy_lints/src/len_zero.rs b/clippy_lints/src/len_zero.rs
index 3a563736fb0..76b0c21327c 100644
--- a/clippy_lints/src/len_zero.rs
+++ b/clippy_lints/src/len_zero.rs
@@ -366,8 +366,7 @@ fn check_for_is_empty<'tcx>(
 }
 
 fn check_cmp(cx: &LateContext<'_>, span: Span, method: &Expr<'_>, lit: &Expr<'_>, op: &str, compare_to: u32) {
-    if let (&ExprKind::MethodCall(method_path, receiver, args, _), &ExprKind::Lit(ref lit)) = (&method.kind, &lit.kind)
-    {
+    if let (&ExprKind::MethodCall(method_path, receiver, args, _), ExprKind::Lit(lit)) = (&method.kind, &lit.kind) {
         // check if we are in an is_empty() method
         if let Some(name) = get_item_name(cx, method) {
             if name.as_str() == "is_empty" {
diff --git a/clippy_lints/src/needless_borrowed_ref.rs b/clippy_lints/src/needless_borrowed_ref.rs
index 10c3ff026b6..498e1408e52 100644
--- a/clippy_lints/src/needless_borrowed_ref.rs
+++ b/clippy_lints/src/needless_borrowed_ref.rs
@@ -36,14 +36,14 @@ declare_clippy_lint! {
 declare_lint_pass!(NeedlessBorrowedRef => [NEEDLESS_BORROWED_REFERENCE]);
 
 impl<'tcx> LateLintPass<'tcx> for NeedlessBorrowedRef {
-    fn check_pat(&mut self, cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>) {
-        if pat.span.from_expansion() {
+    fn check_pat(&mut self, cx: &LateContext<'tcx>, ref_pat: &'tcx Pat<'_>) {
+        if ref_pat.span.from_expansion() {
             // OK, simple enough, lints doesn't check in macro.
             return;
         }
 
         // Do not lint patterns that are part of an OR `|` pattern, the binding mode must match in all arms
-        for (_, node) in cx.tcx.hir().parent_iter(pat.hir_id) {
+        for (_, node) in cx.tcx.hir().parent_iter(ref_pat.hir_id) {
             let Node::Pat(pat) = node else { break };
 
             if matches!(pat.kind, PatKind::Or(_)) {
@@ -52,20 +52,20 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessBorrowedRef {
         }
 
         // Only lint immutable refs, because `&mut ref T` may be useful.
-        let PatKind::Ref(sub_pat, Mutability::Not) = pat.kind else { return };
+        let PatKind::Ref(pat, Mutability::Not) = ref_pat.kind else { return };
 
-        match sub_pat.kind {
+        match pat.kind {
             // Check sub_pat got a `ref` keyword (excluding `ref mut`).
             PatKind::Binding(BindingAnnotation::REF, _, ident, None) => {
                 span_lint_and_then(
                     cx,
                     NEEDLESS_BORROWED_REFERENCE,
-                    pat.span,
+                    ref_pat.span,
                     "this pattern takes a reference on something that is being dereferenced",
                     |diag| {
                         // `&ref ident`
                         //  ^^^^^
-                        let span = pat.span.until(ident.span);
+                        let span = ref_pat.span.until(ident.span);
                         diag.span_suggestion_verbose(
                             span,
                             "try removing the `&ref` part",
@@ -84,41 +84,71 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessBorrowedRef {
                 }),
                 after,
             ) => {
-                let mut suggestions = Vec::new();
-
-                for element_pat in itertools::chain(before, after) {
-                    if let PatKind::Binding(BindingAnnotation::REF, _, ident, None) = element_pat.kind {
-                        // `&[..., ref ident, ...]`
-                        //         ^^^^
-                        let span = element_pat.span.until(ident.span);
-                        suggestions.push((span, String::new()));
-                    } else {
-                        return;
-                    }
-                }
+                check_subpatterns(
+                    cx,
+                    "dereferencing a slice pattern where every element takes a reference",
+                    ref_pat,
+                    pat,
+                    itertools::chain(before, after),
+                );
+            },
+            PatKind::Tuple(subpatterns, _) | PatKind::TupleStruct(_, subpatterns, _) => {
+                check_subpatterns(
+                    cx,
+                    "dereferencing a tuple pattern where every element takes a reference",
+                    ref_pat,
+                    pat,
+                    subpatterns,
+                );
+            },
+            PatKind::Struct(_, fields, _) => {
+                check_subpatterns(
+                    cx,
+                    "dereferencing a struct pattern where every field's pattern takes a reference",
+                    ref_pat,
+                    pat,
+                    fields.iter().map(|field| field.pat),
+                );
+            },
+            _ => {},
+        }
+    }
+}
 
-                if !suggestions.is_empty() {
-                    span_lint_and_then(
-                        cx,
-                        NEEDLESS_BORROWED_REFERENCE,
-                        pat.span,
-                        "dereferencing a slice pattern where every element takes a reference",
-                        |diag| {
-                            // `&[...]`
-                            //  ^
-                            let span = pat.span.until(sub_pat.span);
-                            suggestions.push((span, String::new()));
+fn check_subpatterns<'tcx>(
+    cx: &LateContext<'tcx>,
+    message: &str,
+    ref_pat: &Pat<'_>,
+    pat: &Pat<'_>,
+    subpatterns: impl IntoIterator<Item = &'tcx Pat<'tcx>>,
+) {
+    let mut suggestions = Vec::new();
 
-                            diag.multipart_suggestion(
-                                "try removing the `&` and `ref` parts",
-                                suggestions,
-                                Applicability::MachineApplicable,
-                            );
-                        },
-                    );
-                }
+    for subpattern in subpatterns {
+        match subpattern.kind {
+            PatKind::Binding(BindingAnnotation::REF, _, ident, None) => {
+                // `ref ident`
+                //  ^^^^
+                let span = subpattern.span.until(ident.span);
+                suggestions.push((span, String::new()));
             },
-            _ => {},
+            PatKind::Wild => {},
+            _ => return,
         }
     }
+
+    if !suggestions.is_empty() {
+        span_lint_and_then(cx, NEEDLESS_BORROWED_REFERENCE, ref_pat.span, message, |diag| {
+            // `&pat`
+            //  ^
+            let span = ref_pat.span.until(pat.span);
+            suggestions.push((span, String::new()));
+
+            diag.multipart_suggestion(
+                "try removing the `&` and `ref` parts",
+                suggestions,
+                Applicability::MachineApplicable,
+            );
+        });
+    }
 }
diff --git a/clippy_lints/src/unsafe_removed_from_name.rs b/clippy_lints/src/unsafe_removed_from_name.rs
index 32cd4681201..95258652768 100644
--- a/clippy_lints/src/unsafe_removed_from_name.rs
+++ b/clippy_lints/src/unsafe_removed_from_name.rs
@@ -50,7 +50,7 @@ fn check_use_tree(use_tree: &UseTree, cx: &EarlyContext<'_>, span: Span) {
         },
         UseTreeKind::Simple(None, ..) | UseTreeKind::Glob => {},
         UseTreeKind::Nested(ref nested_use_tree) => {
-            for &(ref use_tree, _) in nested_use_tree {
+            for (use_tree, _) in nested_use_tree {
                 check_use_tree(use_tree, cx, span);
             }
         },
diff --git a/clippy_utils/src/consts.rs b/clippy_utils/src/consts.rs
index f01afda72b2..315aea9aa09 100644
--- a/clippy_utils/src/consts.rs
+++ b/clippy_utils/src/consts.rs
@@ -51,8 +51,8 @@ pub enum Constant {
 impl PartialEq for Constant {
     fn eq(&self, other: &Self) -> bool {
         match (self, other) {
-            (&Self::Str(ref ls), &Self::Str(ref rs)) => ls == rs,
-            (&Self::Binary(ref l), &Self::Binary(ref r)) => l == r,
+            (Self::Str(ls), Self::Str(rs)) => ls == rs,
+            (Self::Binary(l), Self::Binary(r)) => l == r,
             (&Self::Char(l), &Self::Char(r)) => l == r,
             (&Self::Int(l), &Self::Int(r)) => l == r,
             (&Self::F64(l), &Self::F64(r)) => {
@@ -69,8 +69,8 @@ impl PartialEq for Constant {
             },
             (&Self::Bool(l), &Self::Bool(r)) => l == r,
             (&Self::Vec(ref l), &Self::Vec(ref r)) | (&Self::Tuple(ref l), &Self::Tuple(ref r)) => l == r,
-            (&Self::Repeat(ref lv, ref ls), &Self::Repeat(ref rv, ref rs)) => ls == rs && lv == rv,
-            (&Self::Ref(ref lb), &Self::Ref(ref rb)) => *lb == *rb,
+            (Self::Repeat(lv, ls), Self::Repeat(rv, rs)) => ls == rs && lv == rv,
+            (Self::Ref(lb), Self::Ref(rb)) => *lb == *rb,
             // TODO: are there inter-type equalities?
             _ => false,
         }
@@ -126,8 +126,8 @@ impl Hash for Constant {
 impl Constant {
     pub fn partial_cmp(tcx: TyCtxt<'_>, cmp_type: Ty<'_>, left: &Self, right: &Self) -> Option<Ordering> {
         match (left, right) {
-            (&Self::Str(ref ls), &Self::Str(ref rs)) => Some(ls.cmp(rs)),
-            (&Self::Char(ref l), &Self::Char(ref r)) => Some(l.cmp(r)),
+            (Self::Str(ls), Self::Str(rs)) => Some(ls.cmp(rs)),
+            (Self::Char(l), Self::Char(r)) => Some(l.cmp(r)),
             (&Self::Int(l), &Self::Int(r)) => match *cmp_type.kind() {
                 ty::Int(int_ty) => Some(sext(tcx, l, int_ty).cmp(&sext(tcx, r, int_ty))),
                 ty::Uint(_) => Some(l.cmp(&r)),
@@ -135,8 +135,8 @@ impl Constant {
             },
             (&Self::F64(l), &Self::F64(r)) => l.partial_cmp(&r),
             (&Self::F32(l), &Self::F32(r)) => l.partial_cmp(&r),
-            (&Self::Bool(ref l), &Self::Bool(ref r)) => Some(l.cmp(r)),
-            (&Self::Tuple(ref l), &Self::Tuple(ref r)) if l.len() == r.len() => match *cmp_type.kind() {
+            (Self::Bool(l), Self::Bool(r)) => Some(l.cmp(r)),
+            (Self::Tuple(l), Self::Tuple(r)) if l.len() == r.len() => match *cmp_type.kind() {
                 ty::Tuple(tys) if tys.len() == l.len() => l
                     .iter()
                     .zip(r)
@@ -146,7 +146,7 @@ impl Constant {
                     .unwrap_or_else(|| Some(l.len().cmp(&r.len()))),
                 _ => None,
             },
-            (&Self::Vec(ref l), &Self::Vec(ref r)) => {
+            (Self::Vec(l), Self::Vec(r)) => {
                 let (ty::Array(cmp_type, _) | ty::Slice(cmp_type)) = *cmp_type.kind() else {
                     return None
                 };
@@ -155,7 +155,7 @@ impl Constant {
                     .find(|r| r.map_or(true, |o| o != Ordering::Equal))
                     .unwrap_or_else(|| Some(l.len().cmp(&r.len())))
             },
-            (&Self::Repeat(ref lv, ref ls), &Self::Repeat(ref rv, ref rs)) => {
+            (Self::Repeat(lv, ls), Self::Repeat(rv, rs)) => {
                 match Self::partial_cmp(
                     tcx,
                     match *cmp_type.kind() {
@@ -169,7 +169,7 @@ impl Constant {
                     x => x,
                 }
             },
-            (&Self::Ref(ref lb), &Self::Ref(ref rb)) => Self::partial_cmp(
+            (Self::Ref(lb), Self::Ref(rb)) => Self::partial_cmp(
                 tcx,
                 match *cmp_type.kind() {
                     ty::Ref(_, ty, _) => ty,
diff --git a/clippy_utils/src/hir_utils.rs b/clippy_utils/src/hir_utils.rs
index da8c976c952..0231a51adf4 100644
--- a/clippy_utils/src/hir_utils.rs
+++ b/clippy_utils/src/hir_utils.rs
@@ -266,7 +266,7 @@ impl HirEqInterExpr<'_, '_, '_> {
             (&ExprKind::Let(l), &ExprKind::Let(r)) => {
                 self.eq_pat(l.pat, r.pat) && both(&l.ty, &r.ty, |l, r| self.eq_ty(l, r)) && self.eq_expr(l.init, r.init)
             },
-            (&ExprKind::Lit(ref l), &ExprKind::Lit(ref r)) => l.node == r.node,
+            (ExprKind::Lit(l), ExprKind::Lit(r)) => l.node == r.node,
             (&ExprKind::Loop(lb, ref ll, ref lls, _), &ExprKind::Loop(rb, ref rl, ref rls, _)) => {
                 lls == rls && self.eq_block(lb, rb) && both(ll, rl, |l, r| l.ident.name == r.ident.name)
             },
@@ -291,8 +291,8 @@ impl HirEqInterExpr<'_, '_, '_> {
             (&ExprKind::Repeat(le, ll), &ExprKind::Repeat(re, rl)) => {
                 self.eq_expr(le, re) && self.eq_array_length(ll, rl)
             },
-            (&ExprKind::Ret(ref l), &ExprKind::Ret(ref r)) => both(l, r, |l, r| self.eq_expr(l, r)),
-            (&ExprKind::Path(ref l), &ExprKind::Path(ref r)) => self.eq_qpath(l, r),
+            (ExprKind::Ret(l), ExprKind::Ret(r)) => both(l, r, |l, r| self.eq_expr(l, r)),
+            (ExprKind::Path(l), ExprKind::Path(r)) => self.eq_qpath(l, r),
             (&ExprKind::Struct(l_path, lf, ref lo), &ExprKind::Struct(r_path, rf, ref ro)) => {
                 self.eq_qpath(l_path, r_path)
                     && both(lo, ro, |l, r| self.eq_expr(l, r))
@@ -362,7 +362,7 @@ impl HirEqInterExpr<'_, '_, '_> {
                 }
                 eq
             },
-            (&PatKind::Path(ref l), &PatKind::Path(ref r)) => self.eq_qpath(l, r),
+            (PatKind::Path(l), PatKind::Path(r)) => self.eq_qpath(l, r),
             (&PatKind::Lit(l), &PatKind::Lit(r)) => self.eq_expr(l, r),
             (&PatKind::Tuple(l, ls), &PatKind::Tuple(r, rs)) => ls == rs && over(l, r, |l, r| self.eq_pat(l, r)),
             (&PatKind::Range(ref ls, ref le, li), &PatKind::Range(ref rs, ref re, ri)) => {
@@ -429,13 +429,11 @@ impl HirEqInterExpr<'_, '_, '_> {
         match (&left.kind, &right.kind) {
             (&TyKind::Slice(l_vec), &TyKind::Slice(r_vec)) => self.eq_ty(l_vec, r_vec),
             (&TyKind::Array(lt, ll), &TyKind::Array(rt, rl)) => self.eq_ty(lt, rt) && self.eq_array_length(ll, rl),
-            (&TyKind::Ptr(ref l_mut), &TyKind::Ptr(ref r_mut)) => {
-                l_mut.mutbl == r_mut.mutbl && self.eq_ty(l_mut.ty, r_mut.ty)
-            },
-            (&TyKind::Rptr(_, ref l_rmut), &TyKind::Rptr(_, ref r_rmut)) => {
+            (TyKind::Ptr(l_mut), TyKind::Ptr(r_mut)) => l_mut.mutbl == r_mut.mutbl && self.eq_ty(l_mut.ty, r_mut.ty),
+            (TyKind::Rptr(_, l_rmut), TyKind::Rptr(_, r_rmut)) => {
                 l_rmut.mutbl == r_rmut.mutbl && self.eq_ty(l_rmut.ty, r_rmut.ty)
             },
-            (&TyKind::Path(ref l), &TyKind::Path(ref r)) => self.eq_qpath(l, r),
+            (TyKind::Path(l), TyKind::Path(r)) => self.eq_qpath(l, r),
             (&TyKind::Tup(l), &TyKind::Tup(r)) => over(l, r, |l, r| self.eq_ty(l, r)),
             (&TyKind::Infer, &TyKind::Infer) => true,
             _ => false,
diff --git a/tests/ui/match_expr_like_matches_macro.fixed b/tests/ui/match_expr_like_matches_macro.fixed
index 2498007694c..968f462f8a0 100644
--- a/tests/ui/match_expr_like_matches_macro.fixed
+++ b/tests/ui/match_expr_like_matches_macro.fixed
@@ -2,7 +2,12 @@
 
 #![feature(custom_inner_attributes)]
 #![warn(clippy::match_like_matches_macro)]
-#![allow(unreachable_patterns, dead_code, clippy::equatable_if_let)]
+#![allow(
+    unreachable_patterns,
+    dead_code,
+    clippy::equatable_if_let,
+    clippy::needless_borrowed_reference
+)]
 
 fn main() {
     let x = Some(5);
diff --git a/tests/ui/match_expr_like_matches_macro.rs b/tests/ui/match_expr_like_matches_macro.rs
index b4e48499bd0..c6b479e27c5 100644
--- a/tests/ui/match_expr_like_matches_macro.rs
+++ b/tests/ui/match_expr_like_matches_macro.rs
@@ -2,7 +2,12 @@
 
 #![feature(custom_inner_attributes)]
 #![warn(clippy::match_like_matches_macro)]
-#![allow(unreachable_patterns, dead_code, clippy::equatable_if_let)]
+#![allow(
+    unreachable_patterns,
+    dead_code,
+    clippy::equatable_if_let,
+    clippy::needless_borrowed_reference
+)]
 
 fn main() {
     let x = Some(5);
diff --git a/tests/ui/match_expr_like_matches_macro.stderr b/tests/ui/match_expr_like_matches_macro.stderr
index f1d1c23aeb0..a4df8008ac2 100644
--- a/tests/ui/match_expr_like_matches_macro.stderr
+++ b/tests/ui/match_expr_like_matches_macro.stderr
@@ -1,5 +1,5 @@
 error: match expression looks like `matches!` macro
-  --> $DIR/match_expr_like_matches_macro.rs:11:14
+  --> $DIR/match_expr_like_matches_macro.rs:16:14
    |
 LL |       let _y = match x {
    |  ______________^
@@ -11,7 +11,7 @@ LL | |     };
    = note: `-D clippy::match-like-matches-macro` implied by `-D warnings`
 
 error: match expression looks like `matches!` macro
-  --> $DIR/match_expr_like_matches_macro.rs:17:14
+  --> $DIR/match_expr_like_matches_macro.rs:22:14
    |
 LL |       let _w = match x {
    |  ______________^
@@ -21,7 +21,7 @@ LL | |     };
    | |_____^ help: try this: `matches!(x, Some(_))`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/match_expr_like_matches_macro.rs:23:14
+  --> $DIR/match_expr_like_matches_macro.rs:28:14
    |
 LL |       let _z = match x {
    |  ______________^
@@ -33,7 +33,7 @@ LL | |     };
    = note: `-D clippy::redundant-pattern-matching` implied by `-D warnings`
 
 error: match expression looks like `matches!` macro
-  --> $DIR/match_expr_like_matches_macro.rs:29:15
+  --> $DIR/match_expr_like_matches_macro.rs:34:15
    |
 LL |       let _zz = match x {
    |  _______________^
@@ -43,13 +43,13 @@ LL | |     };
    | |_____^ help: try this: `!matches!(x, Some(r) if r == 0)`
 
 error: if let .. else expression looks like `matches!` macro
-  --> $DIR/match_expr_like_matches_macro.rs:35:16
+  --> $DIR/match_expr_like_matches_macro.rs:40:16
    |
 LL |     let _zzz = if let Some(5) = x { true } else { false };
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `matches!(x, Some(5))`
 
 error: match expression looks like `matches!` macro
-  --> $DIR/match_expr_like_matches_macro.rs:59:20
+  --> $DIR/match_expr_like_matches_macro.rs:64:20
    |
 LL |           let _ans = match x {
    |  ____________________^
@@ -60,7 +60,7 @@ LL | |         };
    | |_________^ help: try this: `matches!(x, E::A(_) | E::B(_))`
 
 error: match expression looks like `matches!` macro
-  --> $DIR/match_expr_like_matches_macro.rs:69:20
+  --> $DIR/match_expr_like_matches_macro.rs:74:20
    |
 LL |           let _ans = match x {
    |  ____________________^
@@ -73,7 +73,7 @@ LL | |         };
    | |_________^ help: try this: `matches!(x, E::A(_) | E::B(_))`
 
 error: match expression looks like `matches!` macro
-  --> $DIR/match_expr_like_matches_macro.rs:79:20
+  --> $DIR/match_expr_like_matches_macro.rs:84:20
    |
 LL |           let _ans = match x {
    |  ____________________^
@@ -84,7 +84,7 @@ LL | |         };
    | |_________^ help: try this: `!matches!(x, E::B(_) | E::C)`
 
 error: match expression looks like `matches!` macro
-  --> $DIR/match_expr_like_matches_macro.rs:139:18
+  --> $DIR/match_expr_like_matches_macro.rs:144:18
    |
 LL |           let _z = match &z {
    |  __________________^
@@ -94,7 +94,7 @@ LL | |         };
    | |_________^ help: try this: `matches!(z, Some(3))`
 
 error: match expression looks like `matches!` macro
-  --> $DIR/match_expr_like_matches_macro.rs:148:18
+  --> $DIR/match_expr_like_matches_macro.rs:153:18
    |
 LL |           let _z = match &z {
    |  __________________^
@@ -104,7 +104,7 @@ LL | |         };
    | |_________^ help: try this: `matches!(&z, Some(3))`
 
 error: match expression looks like `matches!` macro
-  --> $DIR/match_expr_like_matches_macro.rs:165:21
+  --> $DIR/match_expr_like_matches_macro.rs:170:21
    |
 LL |               let _ = match &z {
    |  _____________________^
@@ -114,7 +114,7 @@ LL | |             };
    | |_____________^ help: try this: `matches!(&z, AnEnum::X)`
 
 error: match expression looks like `matches!` macro
-  --> $DIR/match_expr_like_matches_macro.rs:179:20
+  --> $DIR/match_expr_like_matches_macro.rs:184:20
    |
 LL |           let _res = match &val {
    |  ____________________^
@@ -124,7 +124,7 @@ LL | |         };
    | |_________^ help: try this: `matches!(&val, &Some(ref _a))`
 
 error: match expression looks like `matches!` macro
-  --> $DIR/match_expr_like_matches_macro.rs:191:20
+  --> $DIR/match_expr_like_matches_macro.rs:196:20
    |
 LL |           let _res = match &val {
    |  ____________________^
@@ -134,7 +134,7 @@ LL | |         };
    | |_________^ help: try this: `matches!(&val, &Some(ref _a))`
 
 error: match expression looks like `matches!` macro
-  --> $DIR/match_expr_like_matches_macro.rs:251:14
+  --> $DIR/match_expr_like_matches_macro.rs:256:14
    |
 LL |       let _y = match Some(5) {
    |  ______________^
diff --git a/tests/ui/needless_borrowed_ref.fixed b/tests/ui/needless_borrowed_ref.fixed
index bcb4eb2dd48..0c47ceb7b67 100644
--- a/tests/ui/needless_borrowed_ref.fixed
+++ b/tests/ui/needless_borrowed_ref.fixed
@@ -1,11 +1,32 @@
 // run-rustfix
 
 #![warn(clippy::needless_borrowed_reference)]
-#![allow(unused, clippy::needless_borrow)]
+#![allow(
+    unused,
+    irrefutable_let_patterns,
+    non_shorthand_field_patterns,
+    clippy::needless_borrow
+)]
 
 fn main() {}
 
-fn should_lint(array: [u8; 4], slice: &[u8], slice_of_refs: &[&u8], vec: Vec<u8>) {
+struct Struct {
+    a: usize,
+    b: usize,
+    c: usize,
+}
+
+struct TupleStruct(u8, u8, u8);
+
+fn should_lint(
+    array: [u8; 4],
+    slice: &[u8],
+    slice_of_refs: &[&u8],
+    vec: Vec<u8>,
+    tuple: (u8, u8, u8),
+    tuple_struct: TupleStruct,
+    s: Struct,
+) {
     let mut v = Vec::<String>::new();
     let _ = v.iter_mut().filter(|a| a.is_empty());
 
@@ -24,16 +45,54 @@ fn should_lint(array: [u8; 4], slice: &[u8], slice_of_refs: &[&u8], vec: Vec<u8>
     if let [a, b, ..] = slice {}
     if let [a, .., b] = slice {}
     if let [.., a, b] = slice {}
+
+    if let [a, _] = slice {}
+
+    if let (a, b, c) = &tuple {}
+    if let (a, _, c) = &tuple {}
+    if let (a, ..) = &tuple {}
+
+    if let TupleStruct(a, ..) = &tuple_struct {}
+
+    if let Struct {
+        a,
+        b: b,
+        c: renamed,
+    } = &s
+    {}
+
+    if let Struct { a, b: _, .. } = &s {}
 }
 
-fn should_not_lint(array: [u8; 4], slice: &[u8], slice_of_refs: &[&u8], vec: Vec<u8>) {
+fn should_not_lint(
+    array: [u8; 4],
+    slice: &[u8],
+    slice_of_refs: &[&u8],
+    vec: Vec<u8>,
+    tuple: (u8, u8, u8),
+    tuple_struct: TupleStruct,
+    s: Struct,
+) {
     if let [ref a] = slice {}
     if let &[ref a, b] = slice {}
     if let &[ref a, .., b] = slice {}
 
+    if let &(ref a, b, ..) = &tuple {}
+    if let &TupleStruct(ref a, b, ..) = &tuple_struct {}
+    if let &Struct { ref a, b, .. } = &s {}
+
     // must not be removed as variables must be bound consistently across | patterns
     if let (&[ref a], _) | ([], ref a) = (slice_of_refs, &1u8) {}
 
+    // the `&`s here technically could be removed, but it'd be noisy and without a `ref` doesn't match
+    // the lint name
+    if let &[] = slice {}
+    if let &[_] = slice {}
+    if let &[..] = slice {}
+    if let &(..) = &tuple {}
+    if let &TupleStruct(..) = &tuple_struct {}
+    if let &Struct { .. } = &s {}
+
     let mut var2 = 5;
     let thingy2 = Some(&mut var2);
     if let Some(&mut ref mut v) = thingy2 {
@@ -59,6 +118,6 @@ fn foo(a: &Animal, b: &Animal) {
         // lifetime mismatch error if there is no '&ref' before `feature(nll)` stabilization in 1.63
         (&Animal::Cat(v), &ref k) | (&ref k, &Animal::Cat(v)) => (),
         //                  ^    and   ^ should **not** be linted
-        (&Animal::Dog(ref a), &Animal::Dog(_)) => (), //              ^ should **not** be linted
+        (Animal::Dog(a), &Animal::Dog(_)) => (),
     }
 }
diff --git a/tests/ui/needless_borrowed_ref.rs b/tests/ui/needless_borrowed_ref.rs
index f6de1a6d83d..f883bb0c889 100644
--- a/tests/ui/needless_borrowed_ref.rs
+++ b/tests/ui/needless_borrowed_ref.rs
@@ -1,11 +1,32 @@
 // run-rustfix
 
 #![warn(clippy::needless_borrowed_reference)]
-#![allow(unused, clippy::needless_borrow)]
+#![allow(
+    unused,
+    irrefutable_let_patterns,
+    non_shorthand_field_patterns,
+    clippy::needless_borrow
+)]
 
 fn main() {}
 
-fn should_lint(array: [u8; 4], slice: &[u8], slice_of_refs: &[&u8], vec: Vec<u8>) {
+struct Struct {
+    a: usize,
+    b: usize,
+    c: usize,
+}
+
+struct TupleStruct(u8, u8, u8);
+
+fn should_lint(
+    array: [u8; 4],
+    slice: &[u8],
+    slice_of_refs: &[&u8],
+    vec: Vec<u8>,
+    tuple: (u8, u8, u8),
+    tuple_struct: TupleStruct,
+    s: Struct,
+) {
     let mut v = Vec::<String>::new();
     let _ = v.iter_mut().filter(|&ref a| a.is_empty());
 
@@ -24,16 +45,54 @@ fn should_lint(array: [u8; 4], slice: &[u8], slice_of_refs: &[&u8], vec: Vec<u8>
     if let &[ref a, ref b, ..] = slice {}
     if let &[ref a, .., ref b] = slice {}
     if let &[.., ref a, ref b] = slice {}
+
+    if let &[ref a, _] = slice {}
+
+    if let &(ref a, ref b, ref c) = &tuple {}
+    if let &(ref a, _, ref c) = &tuple {}
+    if let &(ref a, ..) = &tuple {}
+
+    if let &TupleStruct(ref a, ..) = &tuple_struct {}
+
+    if let &Struct {
+        ref a,
+        b: ref b,
+        c: ref renamed,
+    } = &s
+    {}
+
+    if let &Struct { ref a, b: _, .. } = &s {}
 }
 
-fn should_not_lint(array: [u8; 4], slice: &[u8], slice_of_refs: &[&u8], vec: Vec<u8>) {
+fn should_not_lint(
+    array: [u8; 4],
+    slice: &[u8],
+    slice_of_refs: &[&u8],
+    vec: Vec<u8>,
+    tuple: (u8, u8, u8),
+    tuple_struct: TupleStruct,
+    s: Struct,
+) {
     if let [ref a] = slice {}
     if let &[ref a, b] = slice {}
     if let &[ref a, .., b] = slice {}
 
+    if let &(ref a, b, ..) = &tuple {}
+    if let &TupleStruct(ref a, b, ..) = &tuple_struct {}
+    if let &Struct { ref a, b, .. } = &s {}
+
     // must not be removed as variables must be bound consistently across | patterns
     if let (&[ref a], _) | ([], ref a) = (slice_of_refs, &1u8) {}
 
+    // the `&`s here technically could be removed, but it'd be noisy and without a `ref` doesn't match
+    // the lint name
+    if let &[] = slice {}
+    if let &[_] = slice {}
+    if let &[..] = slice {}
+    if let &(..) = &tuple {}
+    if let &TupleStruct(..) = &tuple_struct {}
+    if let &Struct { .. } = &s {}
+
     let mut var2 = 5;
     let thingy2 = Some(&mut var2);
     if let Some(&mut ref mut v) = thingy2 {
@@ -59,6 +118,6 @@ fn foo(a: &Animal, b: &Animal) {
         // lifetime mismatch error if there is no '&ref' before `feature(nll)` stabilization in 1.63
         (&Animal::Cat(v), &ref k) | (&ref k, &Animal::Cat(v)) => (),
         //                  ^    and   ^ should **not** be linted
-        (&Animal::Dog(ref a), &Animal::Dog(_)) => (), //              ^ should **not** be linted
+        (Animal::Dog(a), &Animal::Dog(_)) => (),
     }
 }
diff --git a/tests/ui/needless_borrowed_ref.stderr b/tests/ui/needless_borrowed_ref.stderr
index 7453542e673..8d0f0c258dd 100644
--- a/tests/ui/needless_borrowed_ref.stderr
+++ b/tests/ui/needless_borrowed_ref.stderr
@@ -1,5 +1,5 @@
 error: this pattern takes a reference on something that is being dereferenced
-  --> $DIR/needless_borrowed_ref.rs:10:34
+  --> $DIR/needless_borrowed_ref.rs:31:34
    |
 LL |     let _ = v.iter_mut().filter(|&ref a| a.is_empty());
    |                                  ^^^^^^
@@ -12,7 +12,7 @@ LL +     let _ = v.iter_mut().filter(|a| a.is_empty());
    |
 
 error: this pattern takes a reference on something that is being dereferenced
-  --> $DIR/needless_borrowed_ref.rs:14:17
+  --> $DIR/needless_borrowed_ref.rs:35:17
    |
 LL |     if let Some(&ref v) = thingy {}
    |                 ^^^^^^
@@ -24,7 +24,7 @@ LL +     if let Some(v) = thingy {}
    |
 
 error: this pattern takes a reference on something that is being dereferenced
-  --> $DIR/needless_borrowed_ref.rs:16:14
+  --> $DIR/needless_borrowed_ref.rs:37:14
    |
 LL |     if let &[&ref a, ref b] = slice_of_refs {}
    |              ^^^^^^
@@ -36,7 +36,7 @@ LL +     if let &[a, ref b] = slice_of_refs {}
    |
 
 error: dereferencing a slice pattern where every element takes a reference
-  --> $DIR/needless_borrowed_ref.rs:18:9
+  --> $DIR/needless_borrowed_ref.rs:39:9
    |
 LL |     let &[ref a, ..] = &array;
    |         ^^^^^^^^^^^^
@@ -48,7 +48,7 @@ LL +     let [a, ..] = &array;
    |
 
 error: dereferencing a slice pattern where every element takes a reference
-  --> $DIR/needless_borrowed_ref.rs:19:9
+  --> $DIR/needless_borrowed_ref.rs:40:9
    |
 LL |     let &[ref a, ref b, ..] = &array;
    |         ^^^^^^^^^^^^^^^^^^^
@@ -60,7 +60,7 @@ LL +     let [a, b, ..] = &array;
    |
 
 error: dereferencing a slice pattern where every element takes a reference
-  --> $DIR/needless_borrowed_ref.rs:21:12
+  --> $DIR/needless_borrowed_ref.rs:42:12
    |
 LL |     if let &[ref a, ref b] = slice {}
    |            ^^^^^^^^^^^^^^^
@@ -72,7 +72,7 @@ LL +     if let [a, b] = slice {}
    |
 
 error: dereferencing a slice pattern where every element takes a reference
-  --> $DIR/needless_borrowed_ref.rs:22:12
+  --> $DIR/needless_borrowed_ref.rs:43:12
    |
 LL |     if let &[ref a, ref b] = &vec[..] {}
    |            ^^^^^^^^^^^^^^^
@@ -84,7 +84,7 @@ LL +     if let [a, b] = &vec[..] {}
    |
 
 error: dereferencing a slice pattern where every element takes a reference
-  --> $DIR/needless_borrowed_ref.rs:24:12
+  --> $DIR/needless_borrowed_ref.rs:45:12
    |
 LL |     if let &[ref a, ref b, ..] = slice {}
    |            ^^^^^^^^^^^^^^^^^^^
@@ -96,7 +96,7 @@ LL +     if let [a, b, ..] = slice {}
    |
 
 error: dereferencing a slice pattern where every element takes a reference
-  --> $DIR/needless_borrowed_ref.rs:25:12
+  --> $DIR/needless_borrowed_ref.rs:46:12
    |
 LL |     if let &[ref a, .., ref b] = slice {}
    |            ^^^^^^^^^^^^^^^^^^^
@@ -108,7 +108,7 @@ LL +     if let [a, .., b] = slice {}
    |
 
 error: dereferencing a slice pattern where every element takes a reference
-  --> $DIR/needless_borrowed_ref.rs:26:12
+  --> $DIR/needless_borrowed_ref.rs:47:12
    |
 LL |     if let &[.., ref a, ref b] = slice {}
    |            ^^^^^^^^^^^^^^^^^^^
@@ -119,5 +119,96 @@ LL -     if let &[.., ref a, ref b] = slice {}
 LL +     if let [.., a, b] = slice {}
    |
 
-error: aborting due to 10 previous errors
+error: dereferencing a slice pattern where every element takes a reference
+  --> $DIR/needless_borrowed_ref.rs:49:12
+   |
+LL |     if let &[ref a, _] = slice {}
+   |            ^^^^^^^^^^^
+   |
+help: try removing the `&` and `ref` parts
+   |
+LL -     if let &[ref a, _] = slice {}
+LL +     if let [a, _] = slice {}
+   |
+
+error: dereferencing a tuple pattern where every element takes a reference
+  --> $DIR/needless_borrowed_ref.rs:51:12
+   |
+LL |     if let &(ref a, ref b, ref c) = &tuple {}
+   |            ^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: try removing the `&` and `ref` parts
+   |
+LL -     if let &(ref a, ref b, ref c) = &tuple {}
+LL +     if let (a, b, c) = &tuple {}
+   |
+
+error: dereferencing a tuple pattern where every element takes a reference
+  --> $DIR/needless_borrowed_ref.rs:52:12
+   |
+LL |     if let &(ref a, _, ref c) = &tuple {}
+   |            ^^^^^^^^^^^^^^^^^^
+   |
+help: try removing the `&` and `ref` parts
+   |
+LL -     if let &(ref a, _, ref c) = &tuple {}
+LL +     if let (a, _, c) = &tuple {}
+   |
+
+error: dereferencing a tuple pattern where every element takes a reference
+  --> $DIR/needless_borrowed_ref.rs:53:12
+   |
+LL |     if let &(ref a, ..) = &tuple {}
+   |            ^^^^^^^^^^^^
+   |
+help: try removing the `&` and `ref` parts
+   |
+LL -     if let &(ref a, ..) = &tuple {}
+LL +     if let (a, ..) = &tuple {}
+   |
+
+error: dereferencing a tuple pattern where every element takes a reference
+  --> $DIR/needless_borrowed_ref.rs:55:12
+   |
+LL |     if let &TupleStruct(ref a, ..) = &tuple_struct {}
+   |            ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: try removing the `&` and `ref` parts
+   |
+LL -     if let &TupleStruct(ref a, ..) = &tuple_struct {}
+LL +     if let TupleStruct(a, ..) = &tuple_struct {}
+   |
+
+error: dereferencing a struct pattern where every field's pattern takes a reference
+  --> $DIR/needless_borrowed_ref.rs:57:12
+   |
+LL |       if let &Struct {
+   |  ____________^
+LL | |         ref a,
+LL | |         b: ref b,
+LL | |         c: ref renamed,
+LL | |     } = &s
+   | |_____^
+   |
+help: try removing the `&` and `ref` parts
+   |
+LL ~     if let Struct {
+LL ~         a,
+LL ~         b: b,
+LL ~         c: renamed,
+   |
+
+error: dereferencing a struct pattern where every field's pattern takes a reference
+  --> $DIR/needless_borrowed_ref.rs:64:12
+   |
+LL |     if let &Struct { ref a, b: _, .. } = &s {}
+   |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: try removing the `&` and `ref` parts
+   |
+LL -     if let &Struct { ref a, b: _, .. } = &s {}
+LL +     if let Struct { a, b: _, .. } = &s {}
+   |
+
+error: aborting due to 17 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 9f3b6e9acd367b53b80031af7e8b61226b1eaabc Mon Sep 17 00:00:00 2001
From: Kartavya Vashishtha <sendtokartavya@gmail.com>
Date: Wed, 16 Nov 2022 11:01:07 +0530
Subject: don't emit AlwaysBreaks if it targets a block

Introduced an ignored_ids parameter.
Takes O(n^2) time in the worst case.

Can be changed to collect block ids in first phase,
and then filter with binary search in second.
---
 clippy_lints/src/loops/never_loop.rs | 113 +++++++++++++++++++++--------------
 tests/ui/never_loop.rs               |  11 +++-
 2 files changed, 79 insertions(+), 45 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/never_loop.rs b/clippy_lints/src/loops/never_loop.rs
index abb18187ef1..123e1e3cce1 100644
--- a/clippy_lints/src/loops/never_loop.rs
+++ b/clippy_lints/src/loops/never_loop.rs
@@ -4,7 +4,7 @@ use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::higher::ForLoop;
 use clippy_utils::source::snippet;
 use rustc_errors::Applicability;
-use rustc_hir::{Block, Expr, ExprKind, HirId, InlineAsmOperand, Pat, Stmt, StmtKind};
+use rustc_hir::{Block, Destination, Expr, ExprKind, HirId, InlineAsmOperand, Pat, Stmt, StmtKind};
 use rustc_lint::LateContext;
 use rustc_span::Span;
 use std::iter::{once, Iterator};
@@ -16,7 +16,7 @@ pub(super) fn check(
     span: Span,
     for_loop: Option<&ForLoop<'_>>,
 ) {
-    match never_loop_block(block, loop_id) {
+    match never_loop_block(block, &mut Vec::new(), loop_id) {
         NeverLoopResult::AlwaysBreak => {
             span_lint_and_then(cx, NEVER_LOOP, span, "this loop never actually loops", |diag| {
                 if let Some(ForLoop {
@@ -92,35 +92,33 @@ fn combine_branches(b1: NeverLoopResult, b2: NeverLoopResult) -> NeverLoopResult
     }
 }
 
-fn never_loop_block(block: &Block<'_>, main_loop_id: HirId) -> NeverLoopResult {
-    let mut iter = block
+fn never_loop_block(block: &Block<'_>, ignore_ids: &mut Vec<HirId>, main_loop_id: HirId) -> NeverLoopResult {
+    let iter = block
         .stmts
         .iter()
         .filter_map(stmt_to_expr)
         .chain(block.expr.map(|expr| (expr, None)));
-    never_loop_expr_seq(&mut iter, main_loop_id)
-}
 
-fn never_loop_expr_seq<'a, T: Iterator<Item = (&'a Expr<'a>, Option<&'a Block<'a>>)>>(
-    es: &mut T,
-    main_loop_id: HirId,
-) -> NeverLoopResult {
-    es.map(|(e, els)| {
-        let e = never_loop_expr(e, main_loop_id);
-        els.map_or(e, |els| combine_branches(e, never_loop_block(els, main_loop_id)))
+    iter.map(|(e, els)| {
+        let e = never_loop_expr(e, ignore_ids, main_loop_id);
+        // els is an else block in a let...else binding
+        els.map_or(e, |els| {
+            combine_branches(e, never_loop_block(els, ignore_ids, main_loop_id))
+        })
     })
     .fold(NeverLoopResult::Otherwise, combine_seq)
 }
 
 fn stmt_to_expr<'tcx>(stmt: &Stmt<'tcx>) -> Option<(&'tcx Expr<'tcx>, Option<&'tcx Block<'tcx>>)> {
     match stmt.kind {
-        StmtKind::Semi(e, ..) | StmtKind::Expr(e, ..) => Some((e, None)),
+        StmtKind::Semi(e) | StmtKind::Expr(e) => Some((e, None)),
+        // add the let...else expression (if present)
         StmtKind::Local(local) => local.init.map(|init| (init, local.els)),
         StmtKind::Item(..) => None,
     }
 }
 
-fn never_loop_expr(expr: &Expr<'_>, main_loop_id: HirId) -> NeverLoopResult {
+fn never_loop_expr(expr: &Expr<'_>, ignore_ids: &mut Vec<HirId>, main_loop_id: HirId) -> NeverLoopResult {
     match expr.kind {
         ExprKind::Box(e)
         | ExprKind::Unary(_, e)
@@ -129,48 +127,56 @@ fn never_loop_expr(expr: &Expr<'_>, main_loop_id: HirId) -> NeverLoopResult {
         | ExprKind::Field(e, _)
         | ExprKind::AddrOf(_, _, e)
         | ExprKind::Repeat(e, _)
-        | ExprKind::DropTemps(e) => never_loop_expr(e, main_loop_id),
-        ExprKind::Let(let_expr) => never_loop_expr(let_expr.init, main_loop_id),
-        ExprKind::Array(es) | ExprKind::Tup(es) => never_loop_expr_all(&mut es.iter(), main_loop_id),
-        ExprKind::MethodCall(_, receiver, es, _) => {
-            never_loop_expr_all(&mut std::iter::once(receiver).chain(es.iter()), main_loop_id)
-        },
+        | ExprKind::DropTemps(e) => never_loop_expr(e, ignore_ids, main_loop_id),
+        ExprKind::Let(let_expr) => never_loop_expr(let_expr.init, ignore_ids, main_loop_id),
+        ExprKind::Array(es) | ExprKind::Tup(es) => never_loop_expr_all(&mut es.iter(), ignore_ids, main_loop_id),
+        ExprKind::MethodCall(_, receiver, es, _) => never_loop_expr_all(
+            &mut std::iter::once(receiver).chain(es.iter()),
+            ignore_ids,
+            main_loop_id,
+        ),
         ExprKind::Struct(_, fields, base) => {
-            let fields = never_loop_expr_all(&mut fields.iter().map(|f| f.expr), main_loop_id);
+            let fields = never_loop_expr_all(&mut fields.iter().map(|f| f.expr), ignore_ids, main_loop_id);
             if let Some(base) = base {
-                combine_both(fields, never_loop_expr(base, main_loop_id))
+                combine_both(fields, never_loop_expr(base, ignore_ids, main_loop_id))
             } else {
                 fields
             }
         },
-        ExprKind::Call(e, es) => never_loop_expr_all(&mut once(e).chain(es.iter()), main_loop_id),
+        ExprKind::Call(e, es) => never_loop_expr_all(&mut once(e).chain(es.iter()), ignore_ids, main_loop_id),
         ExprKind::Binary(_, e1, e2)
         | ExprKind::Assign(e1, e2, _)
         | ExprKind::AssignOp(_, e1, e2)
-        | ExprKind::Index(e1, e2) => never_loop_expr_all(&mut [e1, e2].iter().copied(), main_loop_id),
+        | ExprKind::Index(e1, e2) => never_loop_expr_all(&mut [e1, e2].iter().copied(), ignore_ids, main_loop_id),
         ExprKind::Loop(b, _, _, _) => {
             // Break can come from the inner loop so remove them.
-            absorb_break(never_loop_block(b, main_loop_id))
+            absorb_break(never_loop_block(b, ignore_ids, main_loop_id))
         },
         ExprKind::If(e, e2, e3) => {
-            let e1 = never_loop_expr(e, main_loop_id);
-            let e2 = never_loop_expr(e2, main_loop_id);
-            let e3 = e3
-                .as_ref()
-                .map_or(NeverLoopResult::Otherwise, |e| never_loop_expr(e, main_loop_id));
+            let e1 = never_loop_expr(e, ignore_ids, main_loop_id);
+            let e2 = never_loop_expr(e2, ignore_ids, main_loop_id);
+            let e3 = e3.as_ref().map_or(NeverLoopResult::Otherwise, |e| {
+                never_loop_expr(e, ignore_ids, main_loop_id)
+            });
             combine_seq(e1, combine_branches(e2, e3))
         },
         ExprKind::Match(e, arms, _) => {
-            let e = never_loop_expr(e, main_loop_id);
+            let e = never_loop_expr(e, ignore_ids, main_loop_id);
             if arms.is_empty() {
                 e
             } else {
-                let arms = never_loop_expr_branch(&mut arms.iter().map(|a| a.body), main_loop_id);
+                let arms = never_loop_expr_branch(&mut arms.iter().map(|a| a.body), ignore_ids, main_loop_id);
                 combine_seq(e, arms)
             }
         },
-        ExprKind::Block(b, None) => never_loop_block(b, main_loop_id),
-        ExprKind::Block(b, Some(_label)) => absorb_break(never_loop_block(b, main_loop_id)),
+        ExprKind::Block(b, l) => {
+            if let Some(_) = l {
+                ignore_ids.push(b.hir_id);
+            }
+            let ret = never_loop_block(b, ignore_ids, main_loop_id);
+            ignore_ids.pop();
+            ret
+        },
         ExprKind::Continue(d) => {
             let id = d
                 .target_id
@@ -181,20 +187,31 @@ fn never_loop_expr(expr: &Expr<'_>, main_loop_id: HirId) -> NeverLoopResult {
                 NeverLoopResult::AlwaysBreak
             }
         },
+        ExprKind::Break(Destination { target_id: Ok(t), .. }, e) if ignore_ids.contains(&t) => e
+            .map_or(NeverLoopResult::Otherwise, |e| {
+                combine_seq(never_loop_expr(e, ignore_ids, main_loop_id), NeverLoopResult::Otherwise)
+            }),
         ExprKind::Break(_, e) | ExprKind::Ret(e) => e.as_ref().map_or(NeverLoopResult::AlwaysBreak, |e| {
-            combine_seq(never_loop_expr(e, main_loop_id), NeverLoopResult::AlwaysBreak)
+            combine_seq(
+                never_loop_expr(e, ignore_ids, main_loop_id),
+                NeverLoopResult::AlwaysBreak,
+            )
         }),
         ExprKind::InlineAsm(asm) => asm
             .operands
             .iter()
             .map(|(o, _)| match o {
                 InlineAsmOperand::In { expr, .. } | InlineAsmOperand::InOut { expr, .. } => {
-                    never_loop_expr(expr, main_loop_id)
+                    never_loop_expr(expr, ignore_ids, main_loop_id)
                 },
-                InlineAsmOperand::Out { expr, .. } => never_loop_expr_all(&mut expr.iter().copied(), main_loop_id),
-                InlineAsmOperand::SplitInOut { in_expr, out_expr, .. } => {
-                    never_loop_expr_all(&mut once(*in_expr).chain(out_expr.iter().copied()), main_loop_id)
+                InlineAsmOperand::Out { expr, .. } => {
+                    never_loop_expr_all(&mut expr.iter().copied(), ignore_ids, main_loop_id)
                 },
+                InlineAsmOperand::SplitInOut { in_expr, out_expr, .. } => never_loop_expr_all(
+                    &mut once(*in_expr).chain(out_expr.iter().copied()),
+                    ignore_ids,
+                    main_loop_id,
+                ),
                 InlineAsmOperand::Const { .. }
                 | InlineAsmOperand::SymFn { .. }
                 | InlineAsmOperand::SymStatic { .. } => NeverLoopResult::Otherwise,
@@ -209,13 +226,21 @@ fn never_loop_expr(expr: &Expr<'_>, main_loop_id: HirId) -> NeverLoopResult {
     }
 }
 
-fn never_loop_expr_all<'a, T: Iterator<Item = &'a Expr<'a>>>(es: &mut T, main_loop_id: HirId) -> NeverLoopResult {
-    es.map(|e| never_loop_expr(e, main_loop_id))
+fn never_loop_expr_all<'a, T: Iterator<Item = &'a Expr<'a>>>(
+    es: &mut T,
+    ignore_ids: &mut Vec<HirId>,
+    main_loop_id: HirId,
+) -> NeverLoopResult {
+    es.map(|e| never_loop_expr(e, ignore_ids, main_loop_id))
         .fold(NeverLoopResult::Otherwise, combine_both)
 }
 
-fn never_loop_expr_branch<'a, T: Iterator<Item = &'a Expr<'a>>>(e: &mut T, main_loop_id: HirId) -> NeverLoopResult {
-    e.map(|e| never_loop_expr(e, main_loop_id))
+fn never_loop_expr_branch<'a, T: Iterator<Item = &'a Expr<'a>>>(
+    e: &mut T,
+    ignore_ids: &mut Vec<HirId>,
+    main_loop_id: HirId,
+) -> NeverLoopResult {
+    e.map(|e| never_loop_expr(e, ignore_ids, main_loop_id))
         .fold(NeverLoopResult::AlwaysBreak, combine_branches)
 }
 
diff --git a/tests/ui/never_loop.rs b/tests/ui/never_loop.rs
index 86a5d03f765..28e8f459d44 100644
--- a/tests/ui/never_loop.rs
+++ b/tests/ui/never_loop.rs
@@ -234,13 +234,22 @@ pub fn test19() {
     fn thing(iter: impl Iterator) {
         for _ in iter {
             'b: {
-                // error goes away if we just have the block's value be ().
                 break 'b;
             }
         }
     }
 }
 
+pub fn test20() {
+    'a: loop {
+        'b: {
+            break 'b 'c: {
+                break 'a;
+            };
+        }
+    }
+}
+
 fn main() {
     test1();
     test2();
-- 
cgit 1.4.1-3-g733a5


From bc3cd344a1edefdea8eef7962d75bb35cdeea880 Mon Sep 17 00:00:00 2001
From: Kartavya Vashishtha <sendtokartavya@gmail.com>
Date: Wed, 16 Nov 2022 13:15:22 +0530
Subject: fix clippy suggestions

---
 clippy_lints/src/loops/never_loop.rs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/never_loop.rs b/clippy_lints/src/loops/never_loop.rs
index 123e1e3cce1..14f161f5102 100644
--- a/clippy_lints/src/loops/never_loop.rs
+++ b/clippy_lints/src/loops/never_loop.rs
@@ -118,6 +118,7 @@ fn stmt_to_expr<'tcx>(stmt: &Stmt<'tcx>) -> Option<(&'tcx Expr<'tcx>, Option<&'t
     }
 }
 
+#[allow(clippy::too_many_lines)]
 fn never_loop_expr(expr: &Expr<'_>, ignore_ids: &mut Vec<HirId>, main_loop_id: HirId) -> NeverLoopResult {
     match expr.kind {
         ExprKind::Box(e)
@@ -170,7 +171,7 @@ fn never_loop_expr(expr: &Expr<'_>, ignore_ids: &mut Vec<HirId>, main_loop_id: H
             }
         },
         ExprKind::Block(b, l) => {
-            if let Some(_) = l {
+            if l.is_some() {
                 ignore_ids.push(b.hir_id);
             }
             let ret = never_loop_block(b, ignore_ids, main_loop_id);
@@ -187,6 +188,7 @@ fn never_loop_expr(expr: &Expr<'_>, ignore_ids: &mut Vec<HirId>, main_loop_id: H
                 NeverLoopResult::AlwaysBreak
             }
         },
+        // checks if break targets a block instead of a loop
         ExprKind::Break(Destination { target_id: Ok(t), .. }, e) if ignore_ids.contains(&t) => e
             .map_or(NeverLoopResult::Otherwise, |e| {
                 combine_seq(never_loop_expr(e, ignore_ids, main_loop_id), NeverLoopResult::Otherwise)
-- 
cgit 1.4.1-3-g733a5


From 3f015a363020d3811e1f028c9ce4b0705c728289 Mon Sep 17 00:00:00 2001
From: koka <koka.code@gmail.com>
Date: Thu, 17 Nov 2022 00:02:22 +0900
Subject: Avoid generating files via doctest

When we run `cargo test` in `clippy_lints` directory, it will generate
`foo.txt` in the directory.
In order to avoid that, add `no_run` to rustdoc which contains
`File::create`.
---
 clippy_lints/foo.txt            | 1 -
 clippy_lints/src/methods/mod.rs | 4 ++--
 2 files changed, 2 insertions(+), 3 deletions(-)
 delete mode 100644 clippy_lints/foo.txt

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/foo.txt b/clippy_lints/foo.txt
deleted file mode 100644
index 5ab2f8a4323..00000000000
--- a/clippy_lints/foo.txt
+++ /dev/null
@@ -1 +0,0 @@
-Hello
\ No newline at end of file
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 43507f17e35..acb3b20a61b 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3077,7 +3077,7 @@ declare_clippy_lint! {
     ///
     /// ### Example
     ///
-    /// ```rust
+    /// ```rust,no_run
     /// use std::fs::File;
     /// use std::io::{self, Write, Seek, SeekFrom};
     ///
@@ -3090,7 +3090,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```rust,no_run
     /// use std::fs::File;
     /// use std::io::{self, Write, Seek, SeekFrom};
     ///
-- 
cgit 1.4.1-3-g733a5


From 00ae5e15a8f2fde216a09751454f5e98cf241f21 Mon Sep 17 00:00:00 2001
From: Samuel Moelius <samuel.moelius@trailofbits.com>
Date: Thu, 17 Nov 2022 14:57:39 +0000
Subject: Fix typo in `expect_used` and `unwrap_used` warning messages

---
 clippy_lints/src/methods/expect_used.rs      |  6 +++---
 clippy_lints/src/methods/unwrap_used.rs      |  6 +++---
 tests/ui-toml/expect_used/expect_used.stderr |  4 ++--
 tests/ui-toml/unwrap_used/unwrap_used.stderr | 26 +++++++++++++-------------
 tests/ui/expect.stderr                       |  6 +++---
 tests/ui/get_unwrap.stderr                   | 26 +++++++++++++-------------
 tests/ui/unwrap.stderr                       |  6 +++---
 tests/ui/unwrap_expect_used.stderr           | 12 ++++++------
 8 files changed, 46 insertions(+), 46 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/expect_used.rs b/clippy_lints/src/methods/expect_used.rs
index 0d3c8928046..cce8f797e98 100644
--- a/clippy_lints/src/methods/expect_used.rs
+++ b/clippy_lints/src/methods/expect_used.rs
@@ -18,9 +18,9 @@ pub(super) fn check(
     let obj_ty = cx.typeck_results().expr_ty(recv).peel_refs();
 
     let mess = if is_type_diagnostic_item(cx, obj_ty, sym::Option) && !is_err {
-        Some((EXPECT_USED, "an Option", "None", ""))
+        Some((EXPECT_USED, "an `Option`", "None", ""))
     } else if is_type_diagnostic_item(cx, obj_ty, sym::Result) {
-        Some((EXPECT_USED, "a Result", if is_err { "Ok" } else { "Err" }, "an "))
+        Some((EXPECT_USED, "a `Result`", if is_err { "Ok" } else { "Err" }, "an "))
     } else {
         None
     };
@@ -36,7 +36,7 @@ pub(super) fn check(
             cx,
             lint,
             expr.span,
-            &format!("used `{method}()` on `{kind}` value"),
+            &format!("used `{method}()` on {kind} value"),
             None,
             &format!("if this value is {none_prefix}`{none_value}`, it will panic"),
         );
diff --git a/clippy_lints/src/methods/unwrap_used.rs b/clippy_lints/src/methods/unwrap_used.rs
index d11830a24b6..90983f249cd 100644
--- a/clippy_lints/src/methods/unwrap_used.rs
+++ b/clippy_lints/src/methods/unwrap_used.rs
@@ -18,9 +18,9 @@ pub(super) fn check(
     let obj_ty = cx.typeck_results().expr_ty(recv).peel_refs();
 
     let mess = if is_type_diagnostic_item(cx, obj_ty, sym::Option) && !is_err {
-        Some((UNWRAP_USED, "an Option", "None", ""))
+        Some((UNWRAP_USED, "an `Option`", "None", ""))
     } else if is_type_diagnostic_item(cx, obj_ty, sym::Result) {
-        Some((UNWRAP_USED, "a Result", if is_err { "Ok" } else { "Err" }, "an "))
+        Some((UNWRAP_USED, "a `Result`", if is_err { "Ok" } else { "Err" }, "an "))
     } else {
         None
     };
@@ -45,7 +45,7 @@ pub(super) fn check(
             cx,
             lint,
             expr.span,
-            &format!("used `unwrap{method_suffix}()` on `{kind}` value"),
+            &format!("used `unwrap{method_suffix}()` on {kind} value"),
             None,
             &help,
         );
diff --git a/tests/ui-toml/expect_used/expect_used.stderr b/tests/ui-toml/expect_used/expect_used.stderr
index 28a08599c67..1e9bb48c333 100644
--- a/tests/ui-toml/expect_used/expect_used.stderr
+++ b/tests/ui-toml/expect_used/expect_used.stderr
@@ -1,4 +1,4 @@
-error: used `expect()` on `an Option` value
+error: used `expect()` on an `Option` value
   --> $DIR/expect_used.rs:6:13
    |
 LL |     let _ = opt.expect("");
@@ -7,7 +7,7 @@ LL |     let _ = opt.expect("");
    = help: if this value is `None`, it will panic
    = note: `-D clippy::expect-used` implied by `-D warnings`
 
-error: used `expect()` on `a Result` value
+error: used `expect()` on a `Result` value
   --> $DIR/expect_used.rs:11:13
    |
 LL |     let _ = res.expect("");
diff --git a/tests/ui-toml/unwrap_used/unwrap_used.stderr b/tests/ui-toml/unwrap_used/unwrap_used.stderr
index 2bca88660e1..94b5ef663ad 100644
--- a/tests/ui-toml/unwrap_used/unwrap_used.stderr
+++ b/tests/ui-toml/unwrap_used/unwrap_used.stderr
@@ -10,7 +10,7 @@ note: the lint level is defined here
 LL | #![deny(clippy::get_unwrap)]
    |         ^^^^^^^^^^^^^^^^^^
 
-error: used `unwrap()` on `an Option` value
+error: used `unwrap()` on an `Option` value
   --> $DIR/unwrap_used.rs:35:17
    |
 LL |         let _ = boxed_slice.get(1).unwrap();
@@ -25,7 +25,7 @@ error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more co
 LL |         let _ = some_slice.get(0).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&some_slice[0]`
 
-error: used `unwrap()` on `an Option` value
+error: used `unwrap()` on an `Option` value
   --> $DIR/unwrap_used.rs:36:17
    |
 LL |         let _ = some_slice.get(0).unwrap();
@@ -39,7 +39,7 @@ error: called `.get().unwrap()` on a Vec. Using `[]` is more clear and more conc
 LL |         let _ = some_vec.get(0).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&some_vec[0]`
 
-error: used `unwrap()` on `an Option` value
+error: used `unwrap()` on an `Option` value
   --> $DIR/unwrap_used.rs:37:17
    |
 LL |         let _ = some_vec.get(0).unwrap();
@@ -53,7 +53,7 @@ error: called `.get().unwrap()` on a VecDeque. Using `[]` is more clear and more
 LL |         let _ = some_vecdeque.get(0).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&some_vecdeque[0]`
 
-error: used `unwrap()` on `an Option` value
+error: used `unwrap()` on an `Option` value
   --> $DIR/unwrap_used.rs:38:17
    |
 LL |         let _ = some_vecdeque.get(0).unwrap();
@@ -67,7 +67,7 @@ error: called `.get().unwrap()` on a HashMap. Using `[]` is more clear and more
 LL |         let _ = some_hashmap.get(&1).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&some_hashmap[&1]`
 
-error: used `unwrap()` on `an Option` value
+error: used `unwrap()` on an `Option` value
   --> $DIR/unwrap_used.rs:39:17
    |
 LL |         let _ = some_hashmap.get(&1).unwrap();
@@ -81,7 +81,7 @@ error: called `.get().unwrap()` on a BTreeMap. Using `[]` is more clear and more
 LL |         let _ = some_btreemap.get(&1).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&some_btreemap[&1]`
 
-error: used `unwrap()` on `an Option` value
+error: used `unwrap()` on an `Option` value
   --> $DIR/unwrap_used.rs:40:17
    |
 LL |         let _ = some_btreemap.get(&1).unwrap();
@@ -95,7 +95,7 @@ error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more co
 LL |         let _: u8 = *boxed_slice.get(1).unwrap();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `boxed_slice[1]`
 
-error: used `unwrap()` on `an Option` value
+error: used `unwrap()` on an `Option` value
   --> $DIR/unwrap_used.rs:44:22
    |
 LL |         let _: u8 = *boxed_slice.get(1).unwrap();
@@ -109,7 +109,7 @@ error: called `.get_mut().unwrap()` on a slice. Using `[]` is more clear and mor
 LL |         *boxed_slice.get_mut(0).unwrap() = 1;
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `boxed_slice[0]`
 
-error: used `unwrap()` on `an Option` value
+error: used `unwrap()` on an `Option` value
   --> $DIR/unwrap_used.rs:49:10
    |
 LL |         *boxed_slice.get_mut(0).unwrap() = 1;
@@ -123,7 +123,7 @@ error: called `.get_mut().unwrap()` on a slice. Using `[]` is more clear and mor
 LL |         *some_slice.get_mut(0).unwrap() = 1;
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `some_slice[0]`
 
-error: used `unwrap()` on `an Option` value
+error: used `unwrap()` on an `Option` value
   --> $DIR/unwrap_used.rs:50:10
    |
 LL |         *some_slice.get_mut(0).unwrap() = 1;
@@ -137,7 +137,7 @@ error: called `.get_mut().unwrap()` on a Vec. Using `[]` is more clear and more
 LL |         *some_vec.get_mut(0).unwrap() = 1;
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `some_vec[0]`
 
-error: used `unwrap()` on `an Option` value
+error: used `unwrap()` on an `Option` value
   --> $DIR/unwrap_used.rs:51:10
    |
 LL |         *some_vec.get_mut(0).unwrap() = 1;
@@ -151,7 +151,7 @@ error: called `.get_mut().unwrap()` on a VecDeque. Using `[]` is more clear and
 LL |         *some_vecdeque.get_mut(0).unwrap() = 1;
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `some_vecdeque[0]`
 
-error: used `unwrap()` on `an Option` value
+error: used `unwrap()` on an `Option` value
   --> $DIR/unwrap_used.rs:52:10
    |
 LL |         *some_vecdeque.get_mut(0).unwrap() = 1;
@@ -165,7 +165,7 @@ error: called `.get().unwrap()` on a Vec. Using `[]` is more clear and more conc
 LL |         let _ = some_vec.get(0..1).unwrap().to_vec();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `some_vec[0..1]`
 
-error: used `unwrap()` on `an Option` value
+error: used `unwrap()` on an `Option` value
   --> $DIR/unwrap_used.rs:64:17
    |
 LL |         let _ = some_vec.get(0..1).unwrap().to_vec();
@@ -179,7 +179,7 @@ error: called `.get_mut().unwrap()` on a Vec. Using `[]` is more clear and more
 LL |         let _ = some_vec.get_mut(0..1).unwrap().to_vec();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `some_vec[0..1]`
 
-error: used `unwrap()` on `an Option` value
+error: used `unwrap()` on an `Option` value
   --> $DIR/unwrap_used.rs:65:17
    |
 LL |         let _ = some_vec.get_mut(0..1).unwrap().to_vec();
diff --git a/tests/ui/expect.stderr b/tests/ui/expect.stderr
index f6738865cac..c08e0dbbf74 100644
--- a/tests/ui/expect.stderr
+++ b/tests/ui/expect.stderr
@@ -1,4 +1,4 @@
-error: used `expect()` on `an Option` value
+error: used `expect()` on an `Option` value
   --> $DIR/expect.rs:5:13
    |
 LL |     let _ = opt.expect("");
@@ -7,7 +7,7 @@ LL |     let _ = opt.expect("");
    = help: if this value is `None`, it will panic
    = note: `-D clippy::expect-used` implied by `-D warnings`
 
-error: used `expect()` on `a Result` value
+error: used `expect()` on a `Result` value
   --> $DIR/expect.rs:10:13
    |
 LL |     let _ = res.expect("");
@@ -15,7 +15,7 @@ LL |     let _ = res.expect("");
    |
    = help: if this value is an `Err`, it will panic
 
-error: used `expect_err()` on `a Result` value
+error: used `expect_err()` on a `Result` value
   --> $DIR/expect.rs:11:13
    |
 LL |     let _ = res.expect_err("");
diff --git a/tests/ui/get_unwrap.stderr b/tests/ui/get_unwrap.stderr
index 937f8590408..6dee4d5b4b6 100644
--- a/tests/ui/get_unwrap.stderr
+++ b/tests/ui/get_unwrap.stderr
@@ -10,7 +10,7 @@ note: the lint level is defined here
 LL | #![deny(clippy::get_unwrap)]
    |         ^^^^^^^^^^^^^^^^^^
 
-error: used `unwrap()` on `an Option` value
+error: used `unwrap()` on an `Option` value
   --> $DIR/get_unwrap.rs:35:17
    |
 LL |         let _ = boxed_slice.get(1).unwrap();
@@ -25,7 +25,7 @@ error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more co
 LL |         let _ = some_slice.get(0).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&some_slice[0]`
 
-error: used `unwrap()` on `an Option` value
+error: used `unwrap()` on an `Option` value
   --> $DIR/get_unwrap.rs:36:17
    |
 LL |         let _ = some_slice.get(0).unwrap();
@@ -39,7 +39,7 @@ error: called `.get().unwrap()` on a Vec. Using `[]` is more clear and more conc
 LL |         let _ = some_vec.get(0).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&some_vec[0]`
 
-error: used `unwrap()` on `an Option` value
+error: used `unwrap()` on an `Option` value
   --> $DIR/get_unwrap.rs:37:17
    |
 LL |         let _ = some_vec.get(0).unwrap();
@@ -53,7 +53,7 @@ error: called `.get().unwrap()` on a VecDeque. Using `[]` is more clear and more
 LL |         let _ = some_vecdeque.get(0).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&some_vecdeque[0]`
 
-error: used `unwrap()` on `an Option` value
+error: used `unwrap()` on an `Option` value
   --> $DIR/get_unwrap.rs:38:17
    |
 LL |         let _ = some_vecdeque.get(0).unwrap();
@@ -67,7 +67,7 @@ error: called `.get().unwrap()` on a HashMap. Using `[]` is more clear and more
 LL |         let _ = some_hashmap.get(&1).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&some_hashmap[&1]`
 
-error: used `unwrap()` on `an Option` value
+error: used `unwrap()` on an `Option` value
   --> $DIR/get_unwrap.rs:39:17
    |
 LL |         let _ = some_hashmap.get(&1).unwrap();
@@ -81,7 +81,7 @@ error: called `.get().unwrap()` on a BTreeMap. Using `[]` is more clear and more
 LL |         let _ = some_btreemap.get(&1).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&some_btreemap[&1]`
 
-error: used `unwrap()` on `an Option` value
+error: used `unwrap()` on an `Option` value
   --> $DIR/get_unwrap.rs:40:17
    |
 LL |         let _ = some_btreemap.get(&1).unwrap();
@@ -95,7 +95,7 @@ error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more co
 LL |         let _: u8 = *boxed_slice.get(1).unwrap();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `boxed_slice[1]`
 
-error: used `unwrap()` on `an Option` value
+error: used `unwrap()` on an `Option` value
   --> $DIR/get_unwrap.rs:44:22
    |
 LL |         let _: u8 = *boxed_slice.get(1).unwrap();
@@ -109,7 +109,7 @@ error: called `.get_mut().unwrap()` on a slice. Using `[]` is more clear and mor
 LL |         *boxed_slice.get_mut(0).unwrap() = 1;
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `boxed_slice[0]`
 
-error: used `unwrap()` on `an Option` value
+error: used `unwrap()` on an `Option` value
   --> $DIR/get_unwrap.rs:49:10
    |
 LL |         *boxed_slice.get_mut(0).unwrap() = 1;
@@ -123,7 +123,7 @@ error: called `.get_mut().unwrap()` on a slice. Using `[]` is more clear and mor
 LL |         *some_slice.get_mut(0).unwrap() = 1;
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `some_slice[0]`
 
-error: used `unwrap()` on `an Option` value
+error: used `unwrap()` on an `Option` value
   --> $DIR/get_unwrap.rs:50:10
    |
 LL |         *some_slice.get_mut(0).unwrap() = 1;
@@ -137,7 +137,7 @@ error: called `.get_mut().unwrap()` on a Vec. Using `[]` is more clear and more
 LL |         *some_vec.get_mut(0).unwrap() = 1;
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `some_vec[0]`
 
-error: used `unwrap()` on `an Option` value
+error: used `unwrap()` on an `Option` value
   --> $DIR/get_unwrap.rs:51:10
    |
 LL |         *some_vec.get_mut(0).unwrap() = 1;
@@ -151,7 +151,7 @@ error: called `.get_mut().unwrap()` on a VecDeque. Using `[]` is more clear and
 LL |         *some_vecdeque.get_mut(0).unwrap() = 1;
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `some_vecdeque[0]`
 
-error: used `unwrap()` on `an Option` value
+error: used `unwrap()` on an `Option` value
   --> $DIR/get_unwrap.rs:52:10
    |
 LL |         *some_vecdeque.get_mut(0).unwrap() = 1;
@@ -165,7 +165,7 @@ error: called `.get().unwrap()` on a Vec. Using `[]` is more clear and more conc
 LL |         let _ = some_vec.get(0..1).unwrap().to_vec();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `some_vec[0..1]`
 
-error: used `unwrap()` on `an Option` value
+error: used `unwrap()` on an `Option` value
   --> $DIR/get_unwrap.rs:64:17
    |
 LL |         let _ = some_vec.get(0..1).unwrap().to_vec();
@@ -179,7 +179,7 @@ error: called `.get_mut().unwrap()` on a Vec. Using `[]` is more clear and more
 LL |         let _ = some_vec.get_mut(0..1).unwrap().to_vec();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `some_vec[0..1]`
 
-error: used `unwrap()` on `an Option` value
+error: used `unwrap()` on an `Option` value
   --> $DIR/get_unwrap.rs:65:17
    |
 LL |         let _ = some_vec.get_mut(0..1).unwrap().to_vec();
diff --git a/tests/ui/unwrap.stderr b/tests/ui/unwrap.stderr
index e88d580f7bd..d49bf2b3228 100644
--- a/tests/ui/unwrap.stderr
+++ b/tests/ui/unwrap.stderr
@@ -1,4 +1,4 @@
-error: used `unwrap()` on `an Option` value
+error: used `unwrap()` on an `Option` value
   --> $DIR/unwrap.rs:5:13
    |
 LL |     let _ = opt.unwrap();
@@ -7,7 +7,7 @@ LL |     let _ = opt.unwrap();
    = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
    = note: `-D clippy::unwrap-used` implied by `-D warnings`
 
-error: used `unwrap()` on `a Result` value
+error: used `unwrap()` on a `Result` value
   --> $DIR/unwrap.rs:10:13
    |
 LL |     let _ = res.unwrap();
@@ -15,7 +15,7 @@ LL |     let _ = res.unwrap();
    |
    = help: if you don't want to handle the `Err` case gracefully, consider using `expect()` to provide a better panic message
 
-error: used `unwrap_err()` on `a Result` value
+error: used `unwrap_err()` on a `Result` value
   --> $DIR/unwrap.rs:11:13
    |
 LL |     let _ = res.unwrap_err();
diff --git a/tests/ui/unwrap_expect_used.stderr b/tests/ui/unwrap_expect_used.stderr
index 211d2be1834..fe4ecef1145 100644
--- a/tests/ui/unwrap_expect_used.stderr
+++ b/tests/ui/unwrap_expect_used.stderr
@@ -1,4 +1,4 @@
-error: used `unwrap()` on `an Option` value
+error: used `unwrap()` on an `Option` value
   --> $DIR/unwrap_expect_used.rs:23:5
    |
 LL |     Some(3).unwrap();
@@ -7,7 +7,7 @@ LL |     Some(3).unwrap();
    = help: if this value is `None`, it will panic
    = note: `-D clippy::unwrap-used` implied by `-D warnings`
 
-error: used `expect()` on `an Option` value
+error: used `expect()` on an `Option` value
   --> $DIR/unwrap_expect_used.rs:24:5
    |
 LL |     Some(3).expect("Hello world!");
@@ -16,7 +16,7 @@ LL |     Some(3).expect("Hello world!");
    = help: if this value is `None`, it will panic
    = note: `-D clippy::expect-used` implied by `-D warnings`
 
-error: used `unwrap()` on `a Result` value
+error: used `unwrap()` on a `Result` value
   --> $DIR/unwrap_expect_used.rs:31:5
    |
 LL |     a.unwrap();
@@ -24,7 +24,7 @@ LL |     a.unwrap();
    |
    = help: if this value is an `Err`, it will panic
 
-error: used `expect()` on `a Result` value
+error: used `expect()` on a `Result` value
   --> $DIR/unwrap_expect_used.rs:32:5
    |
 LL |     a.expect("Hello world!");
@@ -32,7 +32,7 @@ LL |     a.expect("Hello world!");
    |
    = help: if this value is an `Err`, it will panic
 
-error: used `unwrap_err()` on `a Result` value
+error: used `unwrap_err()` on a `Result` value
   --> $DIR/unwrap_expect_used.rs:33:5
    |
 LL |     a.unwrap_err();
@@ -40,7 +40,7 @@ LL |     a.unwrap_err();
    |
    = help: if this value is an `Ok`, it will panic
 
-error: used `expect_err()` on `a Result` value
+error: used `expect_err()` on a `Result` value
   --> $DIR/unwrap_expect_used.rs:34:5
    |
 LL |     a.expect_err("Hello error!");
-- 
cgit 1.4.1-3-g733a5


From 921f4d317ec3498b0583a72ba1dfdfd84699c268 Mon Sep 17 00:00:00 2001
From: koka <koka.code@gmail.com>
Date: Fri, 18 Nov 2022 21:23:16 +0900
Subject: Keep original literal notation in suggestion

---
 clippy_lints/src/unused_rounding.rs | 2 +-
 tests/ui/unused_rounding.fixed      | 5 +++++
 tests/ui/unused_rounding.rs         | 5 +++++
 tests/ui/unused_rounding.stderr     | 8 +++++++-
 4 files changed, 18 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unused_rounding.rs b/clippy_lints/src/unused_rounding.rs
index 3164937293b..0f6f36da820 100644
--- a/clippy_lints/src/unused_rounding.rs
+++ b/clippy_lints/src/unused_rounding.rs
@@ -36,7 +36,7 @@ fn is_useless_rounding(expr: &Expr) -> Option<(&str, String)> {
         && let ExprKind::Lit(spanned) = &receiver.kind
         && let LitKind::Float(symbol, ty) = spanned.kind {
             let f = symbol.as_str().parse::<f64>().unwrap();
-            let f_str = symbol.to_string() + if let LitFloatType::Suffixed(ty) = ty {
+            let f_str = spanned.token_lit.symbol.to_string() + if let LitFloatType::Suffixed(ty) = ty {
                 ty.name_str()
             } else {
                 ""
diff --git a/tests/ui/unused_rounding.fixed b/tests/ui/unused_rounding.fixed
index 54f85806ac3..38fe6c34cfe 100644
--- a/tests/ui/unused_rounding.fixed
+++ b/tests/ui/unused_rounding.fixed
@@ -6,4 +6,9 @@ fn main() {
     let _ = 1.0f64;
     let _ = 1.00f32;
     let _ = 2e-54f64.floor();
+
+    // issue9866
+    let _ = 3.3_f32.round();
+    let _ = 3.3_f64.round();
+    let _ = 3.0_f32;
 }
diff --git a/tests/ui/unused_rounding.rs b/tests/ui/unused_rounding.rs
index 8d007bc4a1d..a5cac64d023 100644
--- a/tests/ui/unused_rounding.rs
+++ b/tests/ui/unused_rounding.rs
@@ -6,4 +6,9 @@ fn main() {
     let _ = 1.0f64.floor();
     let _ = 1.00f32.round();
     let _ = 2e-54f64.floor();
+
+    // issue9866
+    let _ = 3.3_f32.round();
+    let _ = 3.3_f64.round();
+    let _ = 3.0_f32.round();
 }
diff --git a/tests/ui/unused_rounding.stderr b/tests/ui/unused_rounding.stderr
index 6cfb02e0402..1eeb5d1de88 100644
--- a/tests/ui/unused_rounding.stderr
+++ b/tests/ui/unused_rounding.stderr
@@ -18,5 +18,11 @@ error: used the `round` method with a whole number float
 LL |     let _ = 1.00f32.round();
    |             ^^^^^^^^^^^^^^^ help: remove the `round` method call: `1.00f32`
 
-error: aborting due to 3 previous errors
+error: used the `round` method with a whole number float
+  --> $DIR/unused_rounding.rs:13:13
+   |
+LL |     let _ = 3.0_f32.round();
+   |             ^^^^^^^^^^^^^^^ help: remove the `round` method call: `3.0_f32`
+
+error: aborting due to 4 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 928a158716b8aaee0cf1c40973b027cd63710c99 Mon Sep 17 00:00:00 2001
From: koka <koka.code@gmail.com>
Date: Fri, 18 Nov 2022 21:51:43 +0900
Subject: Allow manual swap in const fn

---
 clippy_lints/src/swap.rs | 6 +++++-
 tests/ui/swap.fixed      | 9 +++++++++
 tests/ui/swap.rs         | 9 +++++++++
 3 files changed, 23 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/swap.rs b/clippy_lints/src/swap.rs
index f46c21e1265..68a60170551 100644
--- a/clippy_lints/src/swap.rs
+++ b/clippy_lints/src/swap.rs
@@ -2,7 +2,7 @@ use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{can_mut_borrow_both, eq_expr_value, std_or_core};
+use clippy_utils::{can_mut_borrow_both, eq_expr_value, in_constant, std_or_core};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Block, Expr, ExprKind, PatKind, QPath, Stmt, StmtKind};
@@ -138,6 +138,10 @@ fn generate_swap_warning(cx: &LateContext<'_>, e1: &Expr<'_>, e2: &Expr<'_>, spa
 
 /// Implementation of the `MANUAL_SWAP` lint.
 fn check_manual_swap(cx: &LateContext<'_>, block: &Block<'_>) {
+    if in_constant(cx, block.hir_id) {
+        return;
+    }
+
     for w in block.stmts.windows(3) {
         if_chain! {
             // let t = foo();
diff --git a/tests/ui/swap.fixed b/tests/ui/swap.fixed
index 24b229235d3..805a2ba5a59 100644
--- a/tests/ui/swap.fixed
+++ b/tests/ui/swap.fixed
@@ -155,3 +155,12 @@ fn issue_8154() {
     let s = S3(&mut s);
     std::mem::swap(&mut s.0.x, &mut s.0.y);
 }
+
+const fn issue_9864(mut u: u32) -> u32 {
+    let mut v = 10;
+
+    let temp = u;
+    u = v;
+    v = temp;
+    u + v
+}
diff --git a/tests/ui/swap.rs b/tests/ui/swap.rs
index a318c27919c..a8c87847952 100644
--- a/tests/ui/swap.rs
+++ b/tests/ui/swap.rs
@@ -179,3 +179,12 @@ fn issue_8154() {
     s.0.x = s.0.y;
     s.0.y = t;
 }
+
+const fn issue_9864(mut u: u32) -> u32 {
+    let mut v = 10;
+
+    let temp = u;
+    u = v;
+    v = temp;
+    u + v
+}
-- 
cgit 1.4.1-3-g733a5


From 3c86cade4ea11baebaadb96402f8987fa013b31c Mon Sep 17 00:00:00 2001
From: koka <koka.code@gmail.com>
Date: Sat, 19 Nov 2022 00:28:02 +0900
Subject: Note about const fn

Since `std::mem::swap` is not stable as a const fn, the suggestion
would not be applicable in that cases
---
 clippy_lints/src/swap.rs | 2 ++
 1 file changed, 2 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/swap.rs b/clippy_lints/src/swap.rs
index 68a60170551..c374529d1ea 100644
--- a/clippy_lints/src/swap.rs
+++ b/clippy_lints/src/swap.rs
@@ -16,6 +16,8 @@ declare_clippy_lint! {
     /// ### What it does
     /// Checks for manual swapping.
     ///
+    /// Note that the lint will not be emitted in const blocks, as the suggestion would not be applicable.
+    ///
     /// ### Why is this bad?
     /// The `std::mem::swap` function exposes the intent better
     /// without deinitializing or copying either variable.
-- 
cgit 1.4.1-3-g733a5


From 98b343c5e6a5059a420d0b2d38edad0b719520e8 Mon Sep 17 00:00:00 2001
From: Caio <c410.f3r@gmail.com>
Date: Sat, 19 Nov 2022 08:22:27 -0300
Subject: [arithmetic-side-effects] Detect overflowing associated constants of
 integers

---
 .../src/operators/arithmetic_side_effects.rs       | 115 +++++++++++----------
 .../arithmetic_side_effects_allowed.rs             |  11 +-
 tests/ui/arithmetic_side_effects.rs                |   8 +-
 tests/ui/arithmetic_side_effects.stderr            | 110 ++++++++++----------
 4 files changed, 130 insertions(+), 114 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/operators/arithmetic_side_effects.rs b/clippy_lints/src/operators/arithmetic_side_effects.rs
index 8827daaa3ee..eda65e30153 100644
--- a/clippy_lints/src/operators/arithmetic_side_effects.rs
+++ b/clippy_lints/src/operators/arithmetic_side_effects.rs
@@ -1,12 +1,19 @@
 use super::ARITHMETIC_SIDE_EFFECTS;
-use clippy_utils::{consts::constant_simple, diagnostics::span_lint};
+use clippy_utils::{
+    consts::{constant, constant_simple},
+    diagnostics::span_lint,
+    peel_hir_expr_refs,
+};
 use rustc_ast as ast;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::Ty;
 use rustc_session::impl_lint_pass;
-use rustc_span::source_map::{Span, Spanned};
+use rustc_span::{
+    source_map::{Span, Spanned},
+    sym,
+};
 
 const HARD_CODED_ALLOWED: &[&str] = &[
     "&str",
@@ -38,24 +45,6 @@ impl ArithmeticSideEffects {
         }
     }
 
-    /// Assuming that `expr` is a literal integer, checks operators (+=, -=, *, /) in a
-    /// non-constant environment that won't overflow.
-    fn has_valid_op(op: &Spanned<hir::BinOpKind>, expr: &hir::Expr<'_>) -> bool {
-        if let hir::ExprKind::Lit(ref lit) = expr.kind &&
-            let ast::LitKind::Int(value, _) = lit.node
-        {
-            match (&op.node, value) {
-                (hir::BinOpKind::Div | hir::BinOpKind::Rem, 0) => false,
-                (hir::BinOpKind::Add | hir::BinOpKind::Sub, 0)
-                    | (hir::BinOpKind::Div | hir::BinOpKind::Rem, _)
-                    | (hir::BinOpKind::Mul, 0 | 1) => true,
-                _ => false,
-            }
-        } else {
-            false
-        }
-    }
-
     /// Checks if the given `expr` has any of the inner `allowed` elements.
     fn is_allowed_ty(&self, ty: Ty<'_>) -> bool {
         self.allowed
@@ -74,15 +63,14 @@ impl ArithmeticSideEffects {
         self.expr_span = Some(expr.span);
     }
 
-    /// If `expr` does not match any variant of `LiteralIntegerTy`, returns `None`.
-    fn literal_integer<'expr, 'tcx>(expr: &'expr hir::Expr<'tcx>) -> Option<LiteralIntegerTy<'expr, 'tcx>> {
-        if matches!(expr.kind, hir::ExprKind::Lit(_)) {
-            return Some(LiteralIntegerTy::Value(expr));
+    /// If `expr` is not a literal integer like `1`, returns `None`.
+    fn literal_integer(expr: &hir::Expr<'_>) -> Option<u128> {
+        if let hir::ExprKind::Lit(ref lit) = expr.kind && let ast::LitKind::Int(n, _) = lit.node {
+            Some(n)
         }
-        if let hir::ExprKind::AddrOf(.., inn) = expr.kind && let hir::ExprKind::Lit(_) = inn.kind {
-            return Some(LiteralIntegerTy::Ref(inn));
+        else {
+            None
         }
-        None
     }
 
     /// Manages when the lint should be triggered. Operations in constant environments, hard coded
@@ -117,10 +105,20 @@ impl ArithmeticSideEffects {
             return;
         }
         let has_valid_op = if Self::is_integral(lhs_ty) && Self::is_integral(rhs_ty) {
-            match (Self::literal_integer(lhs), Self::literal_integer(rhs)) {
-                (None, Some(lit_int_ty)) | (Some(lit_int_ty), None) => Self::has_valid_op(op, lit_int_ty.into()),
-                (Some(LiteralIntegerTy::Value(_)), Some(LiteralIntegerTy::Value(_))) => true,
-                (None, None) | (Some(_), Some(_)) => false,
+            let (actual_lhs, lhs_ref_counter) = peel_hir_expr_refs(lhs);
+            let (actual_rhs, rhs_ref_counter) = peel_hir_expr_refs(rhs);
+            match (Self::literal_integer(actual_lhs), Self::literal_integer(actual_rhs)) {
+                (None, None) => false,
+                (None, Some(n)) | (Some(n), None) => match (&op.node, n) {
+                    (hir::BinOpKind::Div | hir::BinOpKind::Rem, 0) => false,
+                    (hir::BinOpKind::Add | hir::BinOpKind::Sub, 0)
+                    | (hir::BinOpKind::Div | hir::BinOpKind::Rem, _)
+                    | (hir::BinOpKind::Mul, 0 | 1) => true,
+                    _ => false,
+                },
+                (Some(_), Some(_)) => {
+                    matches!((lhs_ref_counter, rhs_ref_counter), (0, 0))
+                },
             }
         } else {
             false
@@ -129,21 +127,45 @@ impl ArithmeticSideEffects {
             self.issue_lint(cx, expr);
         }
     }
+
+    fn manage_unary_ops<'tcx>(
+        &mut self,
+        cx: &LateContext<'tcx>,
+        expr: &hir::Expr<'tcx>,
+        un_expr: &hir::Expr<'tcx>,
+        un_op: hir::UnOp,
+    ) {
+        let hir::UnOp::Neg = un_op else { return; };
+        if constant(cx, cx.typeck_results(), un_expr).is_some() {
+            return;
+        }
+        let ty = cx.typeck_results().expr_ty(expr).peel_refs();
+        if self.is_allowed_ty(ty) {
+            return;
+        }
+        let actual_un_expr = peel_hir_expr_refs(un_expr).0;
+        if Self::literal_integer(actual_un_expr).is_some() {
+            return;
+        }
+        self.issue_lint(cx, expr);
+    }
+
+    fn should_skip_expr(&mut self, expr: &hir::Expr<'_>) -> bool {
+        self.expr_span.is_some() || self.const_span.map_or(false, |sp| sp.contains(expr.span))
+    }
 }
 
 impl<'tcx> LateLintPass<'tcx> for ArithmeticSideEffects {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &hir::Expr<'tcx>) {
-        if self.expr_span.is_some() || self.const_span.map_or(false, |sp| sp.contains(expr.span)) {
+        if self.should_skip_expr(expr) {
             return;
         }
         match &expr.kind {
-            hir::ExprKind::Binary(op, lhs, rhs) | hir::ExprKind::AssignOp(op, lhs, rhs) => {
+            hir::ExprKind::AssignOp(op, lhs, rhs) | hir::ExprKind::Binary(op, lhs, rhs) => {
                 self.manage_bin_ops(cx, expr, op, lhs, rhs);
             },
-            hir::ExprKind::Unary(hir::UnOp::Neg, _) => {
-                if constant_simple(cx, cx.typeck_results(), expr).is_none() {
-                    self.issue_lint(cx, expr);
-                }
+            hir::ExprKind::Unary(un_op, un_expr) => {
+                self.manage_unary_ops(cx, expr, un_expr, *un_op);
             },
             _ => {},
         }
@@ -177,22 +199,3 @@ impl<'tcx> LateLintPass<'tcx> for ArithmeticSideEffects {
         }
     }
 }
-
-/// Tells if an expression is a integer declared by value or by reference.
-///
-/// If `LiteralIntegerTy::Ref`, then the contained value will be `hir::ExprKind::Lit` rather
-/// than `hirExprKind::Addr`.
-enum LiteralIntegerTy<'expr, 'tcx> {
-    /// For example, `&199`
-    Ref(&'expr hir::Expr<'tcx>),
-    /// For example, `1` or `i32::MAX`
-    Value(&'expr hir::Expr<'tcx>),
-}
-
-impl<'expr, 'tcx> From<LiteralIntegerTy<'expr, 'tcx>> for &'expr hir::Expr<'tcx> {
-    fn from(from: LiteralIntegerTy<'expr, 'tcx>) -> Self {
-        match from {
-            LiteralIntegerTy::Ref(elem) | LiteralIntegerTy::Value(elem) => elem,
-        }
-    }
-}
diff --git a/tests/ui-toml/arithmetic_side_effects_allowed/arithmetic_side_effects_allowed.rs b/tests/ui-toml/arithmetic_side_effects_allowed/arithmetic_side_effects_allowed.rs
index 1aed09b7c7b..e8a023ab176 100644
--- a/tests/ui-toml/arithmetic_side_effects_allowed/arithmetic_side_effects_allowed.rs
+++ b/tests/ui-toml/arithmetic_side_effects_allowed/arithmetic_side_effects_allowed.rs
@@ -1,6 +1,6 @@
 #![warn(clippy::arithmetic_side_effects)]
 
-use core::ops::Add;
+use core::ops::{Add, Neg};
 
 #[derive(Clone, Copy)]
 struct Point {
@@ -16,9 +16,18 @@ impl Add for Point {
     }
 }
 
+impl Neg for Point {
+    type Output = Self;
+
+    fn neg(self) -> Self::Output {
+        todo!()
+    }
+}
+
 fn main() {
     let _ = Point { x: 1, y: 0 } + Point { x: 2, y: 3 };
 
     let point: Point = Point { x: 1, y: 0 };
     let _ = point + point;
+    let _ = -point;
 }
diff --git a/tests/ui/arithmetic_side_effects.rs b/tests/ui/arithmetic_side_effects.rs
index b25e68f1306..b5ed8988a51 100644
--- a/tests/ui/arithmetic_side_effects.rs
+++ b/tests/ui/arithmetic_side_effects.rs
@@ -150,8 +150,12 @@ pub fn non_overflowing_ops_or_ops_already_handled_by_the_compiler_should_not_tri
     _n = 23 + 85;
 
     // Unary
-    _n = -1;
-    _n = -(-1);
+    _n = -2147483647;
+    _n = -i32::MAX;
+    _n = -i32::MIN;
+    _n = -&2147483647;
+    _n = -&i32::MAX;
+    _n = -&i32::MIN;
 }
 
 pub fn runtime_ops() {
diff --git a/tests/ui/arithmetic_side_effects.stderr b/tests/ui/arithmetic_side_effects.stderr
index 0f06e22bae9..0259a0824e7 100644
--- a/tests/ui/arithmetic_side_effects.stderr
+++ b/tests/ui/arithmetic_side_effects.stderr
@@ -19,331 +19,331 @@ LL |     let _ = inferred_string + "";
    |             ^^^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:161:5
+  --> $DIR/arithmetic_side_effects.rs:165:5
    |
 LL |     _n += 1;
    |     ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:162:5
+  --> $DIR/arithmetic_side_effects.rs:166:5
    |
 LL |     _n += &1;
    |     ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:163:5
+  --> $DIR/arithmetic_side_effects.rs:167:5
    |
 LL |     _n -= 1;
    |     ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:164:5
+  --> $DIR/arithmetic_side_effects.rs:168:5
    |
 LL |     _n -= &1;
    |     ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:165:5
+  --> $DIR/arithmetic_side_effects.rs:169:5
    |
 LL |     _n /= 0;
    |     ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:166:5
+  --> $DIR/arithmetic_side_effects.rs:170:5
    |
 LL |     _n /= &0;
    |     ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:167:5
+  --> $DIR/arithmetic_side_effects.rs:171:5
    |
 LL |     _n %= 0;
    |     ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:168:5
+  --> $DIR/arithmetic_side_effects.rs:172:5
    |
 LL |     _n %= &0;
    |     ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:169:5
+  --> $DIR/arithmetic_side_effects.rs:173:5
    |
 LL |     _n *= 2;
    |     ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:170:5
+  --> $DIR/arithmetic_side_effects.rs:174:5
    |
 LL |     _n *= &2;
    |     ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:173:10
+  --> $DIR/arithmetic_side_effects.rs:177:10
    |
 LL |     _n = _n + 1;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:174:10
+  --> $DIR/arithmetic_side_effects.rs:178:10
    |
 LL |     _n = _n + &1;
    |          ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:175:10
+  --> $DIR/arithmetic_side_effects.rs:179:10
    |
 LL |     _n = 1 + _n;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:176:10
+  --> $DIR/arithmetic_side_effects.rs:180:10
    |
 LL |     _n = &1 + _n;
    |          ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:177:10
+  --> $DIR/arithmetic_side_effects.rs:181:10
    |
 LL |     _n = _n - 1;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:178:10
+  --> $DIR/arithmetic_side_effects.rs:182:10
    |
 LL |     _n = _n - &1;
    |          ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:179:10
+  --> $DIR/arithmetic_side_effects.rs:183:10
    |
 LL |     _n = 1 - _n;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:180:10
+  --> $DIR/arithmetic_side_effects.rs:184:10
    |
 LL |     _n = &1 - _n;
    |          ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:181:10
+  --> $DIR/arithmetic_side_effects.rs:185:10
    |
 LL |     _n = _n / 0;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:182:10
+  --> $DIR/arithmetic_side_effects.rs:186:10
    |
 LL |     _n = _n / &0;
    |          ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:183:10
+  --> $DIR/arithmetic_side_effects.rs:187:10
    |
 LL |     _n = _n % 0;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:184:10
+  --> $DIR/arithmetic_side_effects.rs:188:10
    |
 LL |     _n = _n % &0;
    |          ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:185:10
+  --> $DIR/arithmetic_side_effects.rs:189:10
    |
 LL |     _n = _n * 2;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:186:10
+  --> $DIR/arithmetic_side_effects.rs:190:10
    |
 LL |     _n = _n * &2;
    |          ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:187:10
+  --> $DIR/arithmetic_side_effects.rs:191:10
    |
 LL |     _n = 2 * _n;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:188:10
+  --> $DIR/arithmetic_side_effects.rs:192:10
    |
 LL |     _n = &2 * _n;
    |          ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:189:10
+  --> $DIR/arithmetic_side_effects.rs:193:10
    |
 LL |     _n = 23 + &85;
    |          ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:190:10
+  --> $DIR/arithmetic_side_effects.rs:194:10
    |
 LL |     _n = &23 + 85;
    |          ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:191:10
+  --> $DIR/arithmetic_side_effects.rs:195:10
    |
 LL |     _n = &23 + &85;
    |          ^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:194:13
+  --> $DIR/arithmetic_side_effects.rs:198:13
    |
 LL |     let _ = Custom + 0;
    |             ^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:195:13
+  --> $DIR/arithmetic_side_effects.rs:199:13
    |
 LL |     let _ = Custom + 1;
    |             ^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:196:13
+  --> $DIR/arithmetic_side_effects.rs:200:13
    |
 LL |     let _ = Custom + 2;
    |             ^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:197:13
+  --> $DIR/arithmetic_side_effects.rs:201:13
    |
 LL |     let _ = Custom + 0.0;
    |             ^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:198:13
+  --> $DIR/arithmetic_side_effects.rs:202:13
    |
 LL |     let _ = Custom + 1.0;
    |             ^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:199:13
+  --> $DIR/arithmetic_side_effects.rs:203:13
    |
 LL |     let _ = Custom + 2.0;
    |             ^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:200:13
+  --> $DIR/arithmetic_side_effects.rs:204:13
    |
 LL |     let _ = Custom - 0;
    |             ^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:201:13
+  --> $DIR/arithmetic_side_effects.rs:205:13
    |
 LL |     let _ = Custom - 1;
    |             ^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:202:13
+  --> $DIR/arithmetic_side_effects.rs:206:13
    |
 LL |     let _ = Custom - 2;
    |             ^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:203:13
+  --> $DIR/arithmetic_side_effects.rs:207:13
    |
 LL |     let _ = Custom - 0.0;
    |             ^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:204:13
+  --> $DIR/arithmetic_side_effects.rs:208:13
    |
 LL |     let _ = Custom - 1.0;
    |             ^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:205:13
+  --> $DIR/arithmetic_side_effects.rs:209:13
    |
 LL |     let _ = Custom - 2.0;
    |             ^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:206:13
+  --> $DIR/arithmetic_side_effects.rs:210:13
    |
 LL |     let _ = Custom / 0;
    |             ^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:207:13
+  --> $DIR/arithmetic_side_effects.rs:211:13
    |
 LL |     let _ = Custom / 1;
    |             ^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:208:13
+  --> $DIR/arithmetic_side_effects.rs:212:13
    |
 LL |     let _ = Custom / 2;
    |             ^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:209:13
+  --> $DIR/arithmetic_side_effects.rs:213:13
    |
 LL |     let _ = Custom / 0.0;
    |             ^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:210:13
+  --> $DIR/arithmetic_side_effects.rs:214:13
    |
 LL |     let _ = Custom / 1.0;
    |             ^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:211:13
+  --> $DIR/arithmetic_side_effects.rs:215:13
    |
 LL |     let _ = Custom / 2.0;
    |             ^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:212:13
+  --> $DIR/arithmetic_side_effects.rs:216:13
    |
 LL |     let _ = Custom * 0;
    |             ^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:213:13
+  --> $DIR/arithmetic_side_effects.rs:217:13
    |
 LL |     let _ = Custom * 1;
    |             ^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:214:13
+  --> $DIR/arithmetic_side_effects.rs:218:13
    |
 LL |     let _ = Custom * 2;
    |             ^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:215:13
+  --> $DIR/arithmetic_side_effects.rs:219:13
    |
 LL |     let _ = Custom * 0.0;
    |             ^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:216:13
+  --> $DIR/arithmetic_side_effects.rs:220:13
    |
 LL |     let _ = Custom * 1.0;
    |             ^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:217:13
+  --> $DIR/arithmetic_side_effects.rs:221:13
    |
 LL |     let _ = Custom * 2.0;
    |             ^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:220:10
+  --> $DIR/arithmetic_side_effects.rs:224:10
    |
 LL |     _n = -_n;
    |          ^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:221:10
+  --> $DIR/arithmetic_side_effects.rs:225:10
    |
 LL |     _n = -&_n;
    |          ^^^^
-- 
cgit 1.4.1-3-g733a5


From e0b1463e0a0133ae49fc31aab3e7f18882ff00b0 Mon Sep 17 00:00:00 2001
From: Caio <c410.f3r@gmail.com>
Date: Sat, 19 Nov 2022 08:25:20 -0300
Subject: Remove unused

---
 clippy_lints/src/operators/arithmetic_side_effects.rs | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/operators/arithmetic_side_effects.rs b/clippy_lints/src/operators/arithmetic_side_effects.rs
index eda65e30153..20b82d81a2a 100644
--- a/clippy_lints/src/operators/arithmetic_side_effects.rs
+++ b/clippy_lints/src/operators/arithmetic_side_effects.rs
@@ -10,10 +10,7 @@ use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::Ty;
 use rustc_session::impl_lint_pass;
-use rustc_span::{
-    source_map::{Span, Spanned},
-    sym,
-};
+use rustc_span::source_map::{Span, Spanned};
 
 const HARD_CODED_ALLOWED: &[&str] = &[
     "&str",
-- 
cgit 1.4.1-3-g733a5


From 1baa6cd591982471475895fc3256d5162a651628 Mon Sep 17 00:00:00 2001
From: koka <koka.code@gmail.com>
Date: Sat, 19 Nov 2022 21:21:47 +0900
Subject: refac: grab a snip from receiver

---
 clippy_lints/src/unused_rounding.rs | 16 ++++++----------
 1 file changed, 6 insertions(+), 10 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unused_rounding.rs b/clippy_lints/src/unused_rounding.rs
index 0f6f36da820..cf34a57f91d 100644
--- a/clippy_lints/src/unused_rounding.rs
+++ b/clippy_lints/src/unused_rounding.rs
@@ -1,5 +1,5 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
-use rustc_ast::ast::{Expr, ExprKind, LitFloatType, LitKind};
+use clippy_utils::{diagnostics::span_lint_and_sugg, source::snippet};
+use rustc_ast::ast::{Expr, ExprKind, LitKind};
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -29,19 +29,15 @@ declare_clippy_lint! {
 }
 declare_lint_pass!(UnusedRounding => [UNUSED_ROUNDING]);
 
-fn is_useless_rounding(expr: &Expr) -> Option<(&str, String)> {
+fn is_useless_rounding<'a>(cx: &EarlyContext<'a>, expr: &'a Expr) -> Option<(&'a str, String)> {
     if let ExprKind::MethodCall(name_ident, receiver, _, _) = &expr.kind
         && let method_name = name_ident.ident.name.as_str()
         && (method_name == "ceil" || method_name == "round" || method_name == "floor")
         && let ExprKind::Lit(spanned) = &receiver.kind
-        && let LitKind::Float(symbol, ty) = spanned.kind {
+        && let LitKind::Float(symbol, _) = spanned.kind {
             let f = symbol.as_str().parse::<f64>().unwrap();
-            let f_str = spanned.token_lit.symbol.to_string() + if let LitFloatType::Suffixed(ty) = ty {
-                ty.name_str()
-            } else {
-                ""
-            };
             if f.fract() == 0.0 {
+                let f_str = snippet(cx, receiver.span, "..").to_string();
                 Some((method_name, f_str))
             } else {
                 None
@@ -53,7 +49,7 @@ fn is_useless_rounding(expr: &Expr) -> Option<(&str, String)> {
 
 impl EarlyLintPass for UnusedRounding {
     fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
-        if let Some((method_name, float)) = is_useless_rounding(expr) {
+        if let Some((method_name, float)) = is_useless_rounding(cx, expr) {
             span_lint_and_sugg(
                 cx,
                 UNUSED_ROUNDING,
-- 
cgit 1.4.1-3-g733a5


From 4d8af99365d73725b4d46bfc4cd993d6c3af63c5 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Sat, 19 Nov 2022 18:13:17 +0000
Subject: Fix `#[allow]` for module_name_repetitions &
 single_component_path_imports

---
 clippy_lints/src/attrs.rs                          |   4 +-
 clippy_lints/src/lib.rs                            |   2 +-
 clippy_lints/src/single_component_path_imports.rs  | 219 ++++++++++++---------
 tests/ui/single_component_path_imports.stderr      |  12 +-
 ...ngle_component_path_imports_nested_first.stderr |  15 +-
 tests/ui/useless_attribute.fixed                   |  21 +-
 tests/ui/useless_attribute.rs                      |  21 +-
 tests/ui/useless_attribute.stderr                  |   6 +-
 8 files changed, 180 insertions(+), 120 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs
index 235ab4977ce..ecf8e83375d 100644
--- a/clippy_lints/src/attrs.rs
+++ b/clippy_lints/src/attrs.rs
@@ -378,7 +378,9 @@ impl<'tcx> LateLintPass<'tcx> for Attributes {
                                                         | "enum_glob_use"
                                                         | "redundant_pub_crate"
                                                         | "macro_use_imports"
-                                                        | "unsafe_removed_from_name",
+                                                        | "unsafe_removed_from_name"
+                                                        | "module_name_repetitions"
+                                                        | "single_component_path_imports"
                                                 )
                                             })
                                         {
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 4e640d7ebf6..3ab5031696d 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -792,7 +792,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(floating_point_arithmetic::FloatingPointArithmetic));
     store.register_early_pass(|| Box::new(as_conversions::AsConversions));
     store.register_late_pass(|_| Box::new(let_underscore::LetUnderscore));
-    store.register_early_pass(|| Box::new(single_component_path_imports::SingleComponentPathImports));
+    store.register_early_pass(|| Box::<single_component_path_imports::SingleComponentPathImports>::default());
     let max_fn_params_bools = conf.max_fn_params_bools;
     let max_struct_bools = conf.max_struct_bools;
     store.register_late_pass(move |_| {
diff --git a/clippy_lints/src/single_component_path_imports.rs b/clippy_lints/src/single_component_path_imports.rs
index 66b79513032..2036e85db7e 100644
--- a/clippy_lints/src/single_component_path_imports.rs
+++ b/clippy_lints/src/single_component_path_imports.rs
@@ -1,8 +1,9 @@
 use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg};
+use rustc_ast::node_id::{NodeId, NodeMap};
 use rustc_ast::{ptr::P, Crate, Item, ItemKind, MacroDef, ModKind, UseTreeKind};
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::{edition::Edition, symbol::kw, Span, Symbol};
 
 declare_clippy_lint! {
@@ -33,51 +34,32 @@ declare_clippy_lint! {
     "imports with single component path are redundant"
 }
 
-declare_lint_pass!(SingleComponentPathImports => [SINGLE_COMPONENT_PATH_IMPORTS]);
+#[derive(Default)]
+pub struct SingleComponentPathImports {
+    /// Buffer found usages to emit when visiting that item so that `#[allow]` works as expected
+    found: NodeMap<Vec<SingleUse>>,
+}
+
+struct SingleUse {
+    name: Symbol,
+    span: Span,
+    item_id: NodeId,
+    can_suggest: bool,
+}
+
+impl_lint_pass!(SingleComponentPathImports => [SINGLE_COMPONENT_PATH_IMPORTS]);
 
 impl EarlyLintPass for SingleComponentPathImports {
     fn check_crate(&mut self, cx: &EarlyContext<'_>, krate: &Crate) {
         if cx.sess().opts.edition < Edition::Edition2018 {
             return;
         }
-        check_mod(cx, &krate.items);
-    }
-}
 
-fn check_mod(cx: &EarlyContext<'_>, items: &[P<Item>]) {
-    // keep track of imports reused with `self` keyword,
-    // such as `self::crypto_hash` in the example below
-    // ```rust,ignore
-    // use self::crypto_hash::{Algorithm, Hasher};
-    // ```
-    let mut imports_reused_with_self = Vec::new();
-
-    // keep track of single use statements
-    // such as `crypto_hash` in the example below
-    // ```rust,ignore
-    // use crypto_hash;
-    // ```
-    let mut single_use_usages = Vec::new();
-
-    // keep track of macros defined in the module as we don't want it to trigger on this (#7106)
-    // ```rust,ignore
-    // macro_rules! foo { () => {} };
-    // pub(crate) use foo;
-    // ```
-    let mut macros = Vec::new();
-
-    for item in items {
-        track_uses(
-            cx,
-            item,
-            &mut imports_reused_with_self,
-            &mut single_use_usages,
-            &mut macros,
-        );
+        self.check_mod(cx, &krate.items);
     }
 
-    for (name, span, can_suggest) in single_use_usages {
-        if !imports_reused_with_self.contains(&name) {
+    fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {
+        for SingleUse { span, can_suggest, .. } in self.found.remove(&item.id).into_iter().flatten() {
             if can_suggest {
                 span_lint_and_sugg(
                     cx,
@@ -102,74 +84,127 @@ fn check_mod(cx: &EarlyContext<'_>, items: &[P<Item>]) {
     }
 }
 
-fn track_uses(
-    cx: &EarlyContext<'_>,
-    item: &Item,
-    imports_reused_with_self: &mut Vec<Symbol>,
-    single_use_usages: &mut Vec<(Symbol, Span, bool)>,
-    macros: &mut Vec<Symbol>,
-) {
-    if item.span.from_expansion() || item.vis.kind.is_pub() {
-        return;
-    }
+impl SingleComponentPathImports {
+    fn check_mod(&mut self, cx: &EarlyContext<'_>, items: &[P<Item>]) {
+        // keep track of imports reused with `self` keyword, such as `self::crypto_hash` in the example
+        // below. Removing the `use crypto_hash;` would make this a compile error
+        // ```
+        // use crypto_hash;
+        //
+        // use self::crypto_hash::{Algorithm, Hasher};
+        // ```
+        let mut imports_reused_with_self = Vec::new();
 
-    match &item.kind {
-        ItemKind::Mod(_, ModKind::Loaded(ref items, ..)) => {
-            check_mod(cx, items);
-        },
-        ItemKind::MacroDef(MacroDef { macro_rules: true, .. }) => {
-            macros.push(item.ident.name);
-        },
-        ItemKind::Use(use_tree) => {
-            let segments = &use_tree.prefix.segments;
-
-            // keep track of `use some_module;` usages
-            if segments.len() == 1 {
-                if let UseTreeKind::Simple(None, _, _) = use_tree.kind {
-                    let name = segments[0].ident.name;
-                    if !macros.contains(&name) {
-                        single_use_usages.push((name, item.span, true));
-                    }
-                }
-                return;
+        // keep track of single use statements such as `crypto_hash` in the example below
+        // ```
+        // use crypto_hash;
+        // ```
+        let mut single_use_usages = Vec::new();
+
+        // keep track of macros defined in the module as we don't want it to trigger on this (#7106)
+        // ```
+        // macro_rules! foo { () => {} };
+        // pub(crate) use foo;
+        // ```
+        let mut macros = Vec::new();
+
+        for item in items {
+            self.track_uses(
+                cx,
+                item,
+                &mut imports_reused_with_self,
+                &mut single_use_usages,
+                &mut macros,
+            );
+        }
+
+        for usage in single_use_usages {
+            if !imports_reused_with_self.contains(&usage.name) {
+                self.found.entry(usage.item_id).or_default().push(usage);
             }
+        }
+    }
 
-            if segments.is_empty() {
-                // keep track of `use {some_module, some_other_module};` usages
-                if let UseTreeKind::Nested(trees) = &use_tree.kind {
-                    for tree in trees {
-                        let segments = &tree.0.prefix.segments;
-                        if segments.len() == 1 {
-                            if let UseTreeKind::Simple(None, _, _) = tree.0.kind {
-                                let name = segments[0].ident.name;
-                                if !macros.contains(&name) {
-                                    single_use_usages.push((name, tree.0.span, false));
-                                }
-                            }
+    fn track_uses(
+        &mut self,
+        cx: &EarlyContext<'_>,
+        item: &Item,
+        imports_reused_with_self: &mut Vec<Symbol>,
+        single_use_usages: &mut Vec<SingleUse>,
+        macros: &mut Vec<Symbol>,
+    ) {
+        if item.span.from_expansion() || item.vis.kind.is_pub() {
+            return;
+        }
+
+        match &item.kind {
+            ItemKind::Mod(_, ModKind::Loaded(ref items, ..)) => {
+                self.check_mod(cx, items);
+            },
+            ItemKind::MacroDef(MacroDef { macro_rules: true, .. }) => {
+                macros.push(item.ident.name);
+            },
+            ItemKind::Use(use_tree) => {
+                let segments = &use_tree.prefix.segments;
+
+                // keep track of `use some_module;` usages
+                if segments.len() == 1 {
+                    if let UseTreeKind::Simple(None, _, _) = use_tree.kind {
+                        let name = segments[0].ident.name;
+                        if !macros.contains(&name) {
+                            single_use_usages.push(SingleUse {
+                                name,
+                                span: item.span,
+                                item_id: item.id,
+                                can_suggest: true,
+                            });
                         }
                     }
+                    return;
                 }
-            } else {
-                // keep track of `use self::some_module` usages
-                if segments[0].ident.name == kw::SelfLower {
-                    // simple case such as `use self::module::SomeStruct`
-                    if segments.len() > 1 {
-                        imports_reused_with_self.push(segments[1].ident.name);
-                        return;
-                    }
 
-                    // nested case such as `use self::{module1::Struct1, module2::Struct2}`
+                if segments.is_empty() {
+                    // keep track of `use {some_module, some_other_module};` usages
                     if let UseTreeKind::Nested(trees) = &use_tree.kind {
                         for tree in trees {
                             let segments = &tree.0.prefix.segments;
-                            if !segments.is_empty() {
-                                imports_reused_with_self.push(segments[0].ident.name);
+                            if segments.len() == 1 {
+                                if let UseTreeKind::Simple(None, _, _) = tree.0.kind {
+                                    let name = segments[0].ident.name;
+                                    if !macros.contains(&name) {
+                                        single_use_usages.push(SingleUse {
+                                            name,
+                                            span: tree.0.span,
+                                            item_id: item.id,
+                                            can_suggest: false,
+                                        });
+                                    }
+                                }
+                            }
+                        }
+                    }
+                } else {
+                    // keep track of `use self::some_module` usages
+                    if segments[0].ident.name == kw::SelfLower {
+                        // simple case such as `use self::module::SomeStruct`
+                        if segments.len() > 1 {
+                            imports_reused_with_self.push(segments[1].ident.name);
+                            return;
+                        }
+
+                        // nested case such as `use self::{module1::Struct1, module2::Struct2}`
+                        if let UseTreeKind::Nested(trees) = &use_tree.kind {
+                            for tree in trees {
+                                let segments = &tree.0.prefix.segments;
+                                if !segments.is_empty() {
+                                    imports_reused_with_self.push(segments[0].ident.name);
+                                }
                             }
                         }
                     }
                 }
-            }
-        },
-        _ => {},
+            },
+            _ => {},
+        }
     }
 }
diff --git a/tests/ui/single_component_path_imports.stderr b/tests/ui/single_component_path_imports.stderr
index 509c88ac256..71dcc25d6e5 100644
--- a/tests/ui/single_component_path_imports.stderr
+++ b/tests/ui/single_component_path_imports.stderr
@@ -1,16 +1,16 @@
 error: this import is redundant
-  --> $DIR/single_component_path_imports.rs:23:5
+  --> $DIR/single_component_path_imports.rs:5:1
    |
-LL |     use regex;
-   |     ^^^^^^^^^^ help: remove it entirely
+LL | use regex;
+   | ^^^^^^^^^^ help: remove it entirely
    |
    = note: `-D clippy::single-component-path-imports` implied by `-D warnings`
 
 error: this import is redundant
-  --> $DIR/single_component_path_imports.rs:5:1
+  --> $DIR/single_component_path_imports.rs:23:5
    |
-LL | use regex;
-   | ^^^^^^^^^^ help: remove it entirely
+LL |     use regex;
+   |     ^^^^^^^^^^ help: remove it entirely
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/single_component_path_imports_nested_first.stderr b/tests/ui/single_component_path_imports_nested_first.stderr
index 633546f6419..330f285202d 100644
--- a/tests/ui/single_component_path_imports_nested_first.stderr
+++ b/tests/ui/single_component_path_imports_nested_first.stderr
@@ -1,3 +1,11 @@
+error: this import is redundant
+  --> $DIR/single_component_path_imports_nested_first.rs:4:1
+   |
+LL | use regex;
+   | ^^^^^^^^^^ help: remove it entirely
+   |
+   = note: `-D clippy::single-component-path-imports` implied by `-D warnings`
+
 error: this import is redundant
   --> $DIR/single_component_path_imports_nested_first.rs:13:10
    |
@@ -5,7 +13,6 @@ LL |     use {regex, serde};
    |          ^^^^^
    |
    = help: remove this import
-   = note: `-D clippy::single-component-path-imports` implied by `-D warnings`
 
 error: this import is redundant
   --> $DIR/single_component_path_imports_nested_first.rs:13:17
@@ -15,11 +22,5 @@ LL |     use {regex, serde};
    |
    = help: remove this import
 
-error: this import is redundant
-  --> $DIR/single_component_path_imports_nested_first.rs:4:1
-   |
-LL | use regex;
-   | ^^^^^^^^^^ help: remove it entirely
-
 error: aborting due to 3 previous errors
 
diff --git a/tests/ui/useless_attribute.fixed b/tests/ui/useless_attribute.fixed
index c23231a99e9..871e4fb5c3a 100644
--- a/tests/ui/useless_attribute.fixed
+++ b/tests/ui/useless_attribute.fixed
@@ -1,6 +1,7 @@
 // run-rustfix
 // aux-build:proc_macro_derive.rs
 
+#![allow(unused)]
 #![warn(clippy::useless_attribute)]
 #![warn(unreachable_pub)]
 #![feature(rustc_private)]
@@ -16,6 +17,13 @@ extern crate rustc_middle;
 #[macro_use]
 extern crate proc_macro_derive;
 
+fn test_indented_attr() {
+    #![allow(clippy::almost_swapped)]
+    use std::collections::HashSet;
+
+    let _ = HashSet::<u32>::default();
+}
+
 // don't lint on unused_import for `use` items
 #[allow(unused_imports)]
 use std::collections;
@@ -63,13 +71,16 @@ mod c {
     pub(crate) struct S;
 }
 
-fn test_indented_attr() {
-    #![allow(clippy::almost_swapped)]
-    use std::collections::HashSet;
-
-    let _ = HashSet::<u32>::default();
+// https://github.com/rust-lang/rust-clippy/issues/7511
+pub mod split {
+    #[allow(clippy::module_name_repetitions)]
+    pub use regex::SplitN;
 }
 
+// https://github.com/rust-lang/rust-clippy/issues/8768
+#[allow(clippy::single_component_path_imports)]
+use regex;
+
 fn main() {
     test_indented_attr();
 }
diff --git a/tests/ui/useless_attribute.rs b/tests/ui/useless_attribute.rs
index 7a7b198ea60..cb50736ba39 100644
--- a/tests/ui/useless_attribute.rs
+++ b/tests/ui/useless_attribute.rs
@@ -1,6 +1,7 @@
 // run-rustfix
 // aux-build:proc_macro_derive.rs
 
+#![allow(unused)]
 #![warn(clippy::useless_attribute)]
 #![warn(unreachable_pub)]
 #![feature(rustc_private)]
@@ -16,6 +17,13 @@ extern crate rustc_middle;
 #[macro_use]
 extern crate proc_macro_derive;
 
+fn test_indented_attr() {
+    #[allow(clippy::almost_swapped)]
+    use std::collections::HashSet;
+
+    let _ = HashSet::<u32>::default();
+}
+
 // don't lint on unused_import for `use` items
 #[allow(unused_imports)]
 use std::collections;
@@ -63,13 +71,16 @@ mod c {
     pub(crate) struct S;
 }
 
-fn test_indented_attr() {
-    #[allow(clippy::almost_swapped)]
-    use std::collections::HashSet;
-
-    let _ = HashSet::<u32>::default();
+// https://github.com/rust-lang/rust-clippy/issues/7511
+pub mod split {
+    #[allow(clippy::module_name_repetitions)]
+    pub use regex::SplitN;
 }
 
+// https://github.com/rust-lang/rust-clippy/issues/8768
+#[allow(clippy::single_component_path_imports)]
+use regex;
+
 fn main() {
     test_indented_attr();
 }
diff --git a/tests/ui/useless_attribute.stderr b/tests/ui/useless_attribute.stderr
index 255d2876355..a7ea0df2294 100644
--- a/tests/ui/useless_attribute.stderr
+++ b/tests/ui/useless_attribute.stderr
@@ -1,5 +1,5 @@
 error: useless lint attribute
-  --> $DIR/useless_attribute.rs:8:1
+  --> $DIR/useless_attribute.rs:9:1
    |
 LL | #[allow(dead_code)]
    | ^^^^^^^^^^^^^^^^^^^ help: if you just forgot a `!`, use: `#![allow(dead_code)]`
@@ -7,13 +7,13 @@ LL | #[allow(dead_code)]
    = note: `-D clippy::useless-attribute` implied by `-D warnings`
 
 error: useless lint attribute
-  --> $DIR/useless_attribute.rs:9:1
+  --> $DIR/useless_attribute.rs:10:1
    |
 LL | #[cfg_attr(feature = "cargo-clippy", allow(dead_code))]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: if you just forgot a `!`, use: `#![cfg_attr(feature = "cargo-clippy", allow(dead_code)`
 
 error: useless lint attribute
-  --> $DIR/useless_attribute.rs:67:5
+  --> $DIR/useless_attribute.rs:21:5
    |
 LL |     #[allow(clippy::almost_swapped)]
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: if you just forgot a `!`, use: `#![allow(clippy::almost_swapped)]`
-- 
cgit 1.4.1-3-g733a5


From 31b83d0895d37dc8a37e195f75bb9fe7de2c5e37 Mon Sep 17 00:00:00 2001
From: Sosthène Guédon <sosthene@guedon.gdn>
Date: Tue, 1 Nov 2022 18:39:36 +0100
Subject: Add missnamed_getters lint

---
 CHANGELOG.md                                    |   1 +
 clippy_lints/src/declared_lints.rs              |   1 +
 clippy_lints/src/functions/missnamed_getters.rs | 123 ++++++++++++++++++++++++
 clippy_lints/src/functions/mod.rs               |  22 +++++
 tests/ui/missnamed_getters.rs                   |  28 ++++++
 tests/ui/missnamed_getters.stderr               |  16 +++
 6 files changed, 191 insertions(+)
 create mode 100644 clippy_lints/src/functions/missnamed_getters.rs
 create mode 100644 tests/ui/missnamed_getters.rs
 create mode 100644 tests/ui/missnamed_getters.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 6f1f73c1fd2..180e7d8bedc 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4198,6 +4198,7 @@ Released 2018-09-13
 [`missing_safety_doc`]: https://rust-lang.github.io/rust-clippy/master/index.html#missing_safety_doc
 [`missing_spin_loop`]: https://rust-lang.github.io/rust-clippy/master/index.html#missing_spin_loop
 [`missing_trait_methods`]: https://rust-lang.github.io/rust-clippy/master/index.html#missing_trait_methods
+[`missnamed_getters`]: https://rust-lang.github.io/rust-clippy/master/index.html#missnamed_getters
 [`mistyped_literal_suffixes`]: https://rust-lang.github.io/rust-clippy/master/index.html#mistyped_literal_suffixes
 [`mixed_case_hex_literals`]: https://rust-lang.github.io/rust-clippy/master/index.html#mixed_case_hex_literals
 [`mixed_read_write_in_expression`]: https://rust-lang.github.io/rust-clippy/master/index.html#mixed_read_write_in_expression
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 0d3fc43a644..0c9ae6380d8 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -184,6 +184,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::functions::RESULT_UNIT_ERR_INFO,
     crate::functions::TOO_MANY_ARGUMENTS_INFO,
     crate::functions::TOO_MANY_LINES_INFO,
+    crate::functions::MISSNAMED_GETTERS_INFO,
     crate::future_not_send::FUTURE_NOT_SEND_INFO,
     crate::if_let_mutex::IF_LET_MUTEX_INFO,
     crate::if_not_else::IF_NOT_ELSE_INFO,
diff --git a/clippy_lints/src/functions/missnamed_getters.rs b/clippy_lints/src/functions/missnamed_getters.rs
new file mode 100644
index 00000000000..c522bb780b3
--- /dev/null
+++ b/clippy_lints/src/functions/missnamed_getters.rs
@@ -0,0 +1,123 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet;
+use rustc_errors::Applicability;
+use rustc_hir::{intravisit::FnKind, Body, ExprKind, FnDecl, HirId, ImplicitSelfKind};
+use rustc_lint::LateContext;
+use rustc_middle::ty;
+use rustc_span::Span;
+
+use super::MISSNAMED_GETTERS;
+
+pub fn check_fn(
+    cx: &LateContext<'_>,
+    kind: FnKind<'_>,
+    decl: &FnDecl<'_>,
+    body: &Body<'_>,
+    _span: Span,
+    _hir_id: HirId,
+) {
+    let FnKind::Method(ref ident, sig) = kind else {
+            return;
+        };
+
+    // Takes only &(mut) self
+    if decl.inputs.len() != 1 {
+        return;
+    }
+
+    let name = ident.name.as_str();
+
+    let name = match sig.decl.implicit_self {
+        ImplicitSelfKind::ImmRef => name,
+        ImplicitSelfKind::MutRef => {
+            let Some(name) = name.strip_suffix("_mut") else {
+                    return;
+                };
+            name
+        },
+        _ => return,
+    };
+
+    // Body must be &(mut) <self_data>.name
+    // self_data is not neccessarilly self
+    let (self_data, used_ident, span) = if_chain! {
+        if let ExprKind::Block(block,_) = body.value.kind;
+        if block.stmts.is_empty();
+        if let Some(block_expr) = block.expr;
+        // replace with while for as many addrof needed
+        if let ExprKind::AddrOf(_,_, expr) = block_expr.kind;
+        if let ExprKind::Field(self_data, ident) = expr.kind;
+        if ident.name.as_str() != name;
+        then {
+            (self_data,ident,block_expr.span)
+        } else {
+            return;
+        }
+    };
+
+    let ty = cx.typeck_results().expr_ty(self_data);
+
+    let def = {
+        let mut kind = ty.kind();
+        loop {
+            match kind {
+                ty::Adt(def, _) => break def,
+                ty::Ref(_, ty, _) => kind = ty.kind(),
+                // We don't do tuples because the function name cannot be a number
+                _ => return,
+            }
+        }
+    };
+
+    let variants = def.variants();
+
+    // We're accessing a field, so it should be an union or a struct and have one and only one variant
+    if variants.len() != 1 {
+        if cfg!(debug_assertions) {
+            panic!("Struct or union expected to have only one variant");
+        } else {
+            // Don't ICE when possible
+            return;
+        }
+    }
+
+    let first = variants.last().unwrap();
+    let fields = &variants[first];
+
+    let mut used_field = None;
+    let mut correct_field = None;
+    for f in &fields.fields {
+        if f.name.as_str() == name {
+            correct_field = Some(f);
+        }
+        if f.name == used_ident.name {
+            used_field = Some(f);
+        }
+    }
+
+    let Some(used_field) = used_field else {
+            if cfg!(debug_assertions) {
+                panic!("Struct doesn't contain the correct field");
+            } else {
+                // Don't ICE when possible
+                return;
+            }
+        };
+    let Some(correct_field) = correct_field else {
+            return;
+        };
+
+    if cx.tcx.type_of(used_field.did) == cx.tcx.type_of(correct_field.did) {
+        let snippet = snippet(cx, span, "..");
+        let sugg = format!("{}{name}", snippet.strip_suffix(used_field.name.as_str()).unwrap());
+        span_lint_and_sugg(
+            cx,
+            MISSNAMED_GETTERS,
+            span,
+            "getter function appears to return the wrong field",
+            "consider using",
+            sugg,
+            Applicability::MaybeIncorrect,
+        );
+    }
+}
diff --git a/clippy_lints/src/functions/mod.rs b/clippy_lints/src/functions/mod.rs
index ae0e0833446..726df02444f 100644
--- a/clippy_lints/src/functions/mod.rs
+++ b/clippy_lints/src/functions/mod.rs
@@ -1,3 +1,4 @@
+mod missnamed_getters;
 mod must_use;
 mod not_unsafe_ptr_arg_deref;
 mod result;
@@ -260,6 +261,25 @@ declare_clippy_lint! {
     "function returning `Result` with large `Err` type"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    ///
+    /// ### Why is this bad?
+    ///
+    /// ### Example
+    /// ```rust
+    /// // example code where clippy issues a warning
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// // example code which does not raise clippy warning
+    /// ```
+    #[clippy::version = "1.66.0"]
+    pub MISSNAMED_GETTERS,
+    suspicious,
+    "default lint description"
+}
+
 #[derive(Copy, Clone)]
 pub struct Functions {
     too_many_arguments_threshold: u64,
@@ -286,6 +306,7 @@ impl_lint_pass!(Functions => [
     MUST_USE_CANDIDATE,
     RESULT_UNIT_ERR,
     RESULT_LARGE_ERR,
+    MISSNAMED_GETTERS,
 ]);
 
 impl<'tcx> LateLintPass<'tcx> for Functions {
@@ -301,6 +322,7 @@ impl<'tcx> LateLintPass<'tcx> for Functions {
         too_many_arguments::check_fn(cx, kind, decl, span, hir_id, self.too_many_arguments_threshold);
         too_many_lines::check_fn(cx, kind, span, body, self.too_many_lines_threshold);
         not_unsafe_ptr_arg_deref::check_fn(cx, kind, decl, body, hir_id);
+        missnamed_getters::check_fn(cx, kind, decl, body, span, hir_id);
     }
 
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) {
diff --git a/tests/ui/missnamed_getters.rs b/tests/ui/missnamed_getters.rs
new file mode 100644
index 00000000000..b47f6edc5ba
--- /dev/null
+++ b/tests/ui/missnamed_getters.rs
@@ -0,0 +1,28 @@
+#![allow(unused)]
+#![warn(clippy::missnamed_getters)]
+
+struct A {
+    a: u8,
+    b: u8,
+}
+
+impl A {
+    fn a(&self) -> &u8 {
+        &self.b
+    }
+}
+
+union B {
+    a: u8,
+    b: u8,
+}
+
+impl B {
+    unsafe fn a(&self) -> &u8 {
+        &self.b
+    }
+}
+
+fn main() {
+    // test code goes here
+}
diff --git a/tests/ui/missnamed_getters.stderr b/tests/ui/missnamed_getters.stderr
new file mode 100644
index 00000000000..8e31a42b97c
--- /dev/null
+++ b/tests/ui/missnamed_getters.stderr
@@ -0,0 +1,16 @@
+error: getter function appears to return the wrong field
+  --> $DIR/missnamed_getters.rs:11:9
+   |
+LL |         &self.b
+   |         ^^^^^^^ help: consider using: `&self.a`
+   |
+   = note: `-D clippy::missnamed-getters` implied by `-D warnings`
+
+error: getter function appears to return the wrong field
+  --> $DIR/missnamed_getters.rs:22:9
+   |
+LL |         &self.b
+   |         ^^^^^^^ help: consider using: `&self.a`
+
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 9891af348c01f8cf14ab1e10754faccad04fcaa5 Mon Sep 17 00:00:00 2001
From: Sosthène Guédon <sosthene@guedon.gdn>
Date: Tue, 1 Nov 2022 19:07:51 +0100
Subject: missnamed_getters: Match owned methods

---
 clippy_lints/src/functions/missnamed_getters.rs | 27 +++++++++----
 tests/ui/missnamed_getters.rs                   | 39 ++++++++++++++++++
 tests/ui/missnamed_getters.stderr               | 54 +++++++++++++++++++++++--
 3 files changed, 110 insertions(+), 10 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/functions/missnamed_getters.rs b/clippy_lints/src/functions/missnamed_getters.rs
index c522bb780b3..1f4eefc620b 100644
--- a/clippy_lints/src/functions/missnamed_getters.rs
+++ b/clippy_lints/src/functions/missnamed_getters.rs
@@ -35,21 +35,34 @@ pub fn check_fn(
                 };
             name
         },
+        ImplicitSelfKind::Imm | ImplicitSelfKind::Mut => name,
         _ => return,
     };
 
     // Body must be &(mut) <self_data>.name
-    // self_data is not neccessarilly self
-    let (self_data, used_ident, span) = if_chain! {
+    // self_data is not neccessarilly self, to also lint sub-getters, etc…
+
+    let block_expr = if_chain! {
         if let ExprKind::Block(block,_) = body.value.kind;
         if block.stmts.is_empty();
         if let Some(block_expr) = block.expr;
-        // replace with while for as many addrof needed
-        if let ExprKind::AddrOf(_,_, expr) = block_expr.kind;
+        then {
+            block_expr
+        } else {
+            return;
+        }
+    };
+    let expr_span = block_expr.span;
+
+    let mut expr = block_expr;
+    if let ExprKind::AddrOf(_, _, tmp) = expr.kind {
+        expr = tmp;
+    }
+    let (self_data, used_ident) = if_chain! {
         if let ExprKind::Field(self_data, ident) = expr.kind;
         if ident.name.as_str() != name;
         then {
-            (self_data,ident,block_expr.span)
+            (self_data,ident)
         } else {
             return;
         }
@@ -108,12 +121,12 @@ pub fn check_fn(
         };
 
     if cx.tcx.type_of(used_field.did) == cx.tcx.type_of(correct_field.did) {
-        let snippet = snippet(cx, span, "..");
+        let snippet = snippet(cx, expr_span, "..");
         let sugg = format!("{}{name}", snippet.strip_suffix(used_field.name.as_str()).unwrap());
         span_lint_and_sugg(
             cx,
             MISSNAMED_GETTERS,
-            span,
+            expr_span,
             "getter function appears to return the wrong field",
             "consider using",
             sugg,
diff --git a/tests/ui/missnamed_getters.rs b/tests/ui/missnamed_getters.rs
index b47f6edc5ba..f9c2351f833 100644
--- a/tests/ui/missnamed_getters.rs
+++ b/tests/ui/missnamed_getters.rs
@@ -4,12 +4,32 @@
 struct A {
     a: u8,
     b: u8,
+    c: u8,
 }
 
 impl A {
     fn a(&self) -> &u8 {
         &self.b
     }
+    fn a_mut(&mut self) -> &mut u8 {
+        &mut self.b
+    }
+
+    fn b(self) -> u8 {
+        self.a
+    }
+
+    fn b_mut(&mut self) -> &mut u8 {
+        &mut self.a
+    }
+
+    fn c(&self) -> &u8 {
+        &self.b
+    }
+
+    fn c_mut(&mut self) -> &mut u8 {
+        &mut self.a
+    }
 }
 
 union B {
@@ -21,6 +41,25 @@ impl B {
     unsafe fn a(&self) -> &u8 {
         &self.b
     }
+    unsafe fn a_mut(&mut self) -> &mut u8 {
+        &mut self.b
+    }
+
+    unsafe fn b(self) -> u8 {
+        self.a
+    }
+
+    unsafe fn b_mut(&mut self) -> &mut u8 {
+        &mut self.a
+    }
+
+    unsafe fn c(&self) -> &u8 {
+        &self.b
+    }
+
+    unsafe fn c_mut(&mut self) -> &mut u8 {
+        &mut self.a
+    }
 }
 
 fn main() {
diff --git a/tests/ui/missnamed_getters.stderr b/tests/ui/missnamed_getters.stderr
index 8e31a42b97c..276096ade87 100644
--- a/tests/ui/missnamed_getters.stderr
+++ b/tests/ui/missnamed_getters.stderr
@@ -1,5 +1,5 @@
 error: getter function appears to return the wrong field
-  --> $DIR/missnamed_getters.rs:11:9
+  --> $DIR/missnamed_getters.rs:12:9
    |
 LL |         &self.b
    |         ^^^^^^^ help: consider using: `&self.a`
@@ -7,10 +7,58 @@ LL |         &self.b
    = note: `-D clippy::missnamed-getters` implied by `-D warnings`
 
 error: getter function appears to return the wrong field
-  --> $DIR/missnamed_getters.rs:22:9
+  --> $DIR/missnamed_getters.rs:15:9
+   |
+LL |         &mut self.b
+   |         ^^^^^^^^^^^ help: consider using: `&mut self.a`
+
+error: getter function appears to return the wrong field
+  --> $DIR/missnamed_getters.rs:19:9
+   |
+LL |         self.a
+   |         ^^^^^^ help: consider using: `self.b`
+
+error: getter function appears to return the wrong field
+  --> $DIR/missnamed_getters.rs:23:9
+   |
+LL |         &mut self.a
+   |         ^^^^^^^^^^^ help: consider using: `&mut self.b`
+
+error: getter function appears to return the wrong field
+  --> $DIR/missnamed_getters.rs:27:9
+   |
+LL |         &self.b
+   |         ^^^^^^^ help: consider using: `&self.c`
+
+error: getter function appears to return the wrong field
+  --> $DIR/missnamed_getters.rs:31:9
+   |
+LL |         &mut self.a
+   |         ^^^^^^^^^^^ help: consider using: `&mut self.c`
+
+error: getter function appears to return the wrong field
+  --> $DIR/missnamed_getters.rs:42:9
    |
 LL |         &self.b
    |         ^^^^^^^ help: consider using: `&self.a`
 
-error: aborting due to 2 previous errors
+error: getter function appears to return the wrong field
+  --> $DIR/missnamed_getters.rs:45:9
+   |
+LL |         &mut self.b
+   |         ^^^^^^^^^^^ help: consider using: `&mut self.a`
+
+error: getter function appears to return the wrong field
+  --> $DIR/missnamed_getters.rs:49:9
+   |
+LL |         self.a
+   |         ^^^^^^ help: consider using: `self.b`
+
+error: getter function appears to return the wrong field
+  --> $DIR/missnamed_getters.rs:53:9
+   |
+LL |         &mut self.a
+   |         ^^^^^^^^^^^ help: consider using: `&mut self.b`
+
+error: aborting due to 10 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From ddc49966dc4552b77582cf7e5aace8ac97d736fc Mon Sep 17 00:00:00 2001
From: Sosthène Guédon <sosthene@guedon.gdn>
Date: Tue, 1 Nov 2022 19:28:06 +0100
Subject: Fix suggestion to point to the whole method

---
 clippy_lints/src/functions/missnamed_getters.rs | 22 +++---
 tests/ui/missnamed_getters.stderr               | 90 ++++++++++++++++---------
 2 files changed, 72 insertions(+), 40 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/functions/missnamed_getters.rs b/clippy_lints/src/functions/missnamed_getters.rs
index 1f4eefc620b..60922fb4ea4 100644
--- a/clippy_lints/src/functions/missnamed_getters.rs
+++ b/clippy_lints/src/functions/missnamed_getters.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet;
 use rustc_errors::Applicability;
 use rustc_hir::{intravisit::FnKind, Body, ExprKind, FnDecl, HirId, ImplicitSelfKind};
@@ -13,7 +13,7 @@ pub fn check_fn(
     kind: FnKind<'_>,
     decl: &FnDecl<'_>,
     body: &Body<'_>,
-    _span: Span,
+    span: Span,
     _hir_id: HirId,
 ) {
     let FnKind::Method(ref ident, sig) = kind else {
@@ -55,6 +55,7 @@ pub fn check_fn(
     let expr_span = block_expr.span;
 
     let mut expr = block_expr;
+    // Accept &<expr>, &mut <expr> and <expr>
     if let ExprKind::AddrOf(_, _, tmp) = expr.kind {
         expr = tmp;
     }
@@ -62,7 +63,7 @@ pub fn check_fn(
         if let ExprKind::Field(self_data, ident) = expr.kind;
         if ident.name.as_str() != name;
         then {
-            (self_data,ident)
+            (self_data, ident)
         } else {
             return;
         }
@@ -121,16 +122,17 @@ pub fn check_fn(
         };
 
     if cx.tcx.type_of(used_field.did) == cx.tcx.type_of(correct_field.did) {
-        let snippet = snippet(cx, expr_span, "..");
-        let sugg = format!("{}{name}", snippet.strip_suffix(used_field.name.as_str()).unwrap());
-        span_lint_and_sugg(
+        let left_span = block_expr.span.until(used_ident.span);
+        let snippet = snippet(cx, left_span, "..");
+        let sugg = format!("{snippet}{name}");
+        span_lint_and_then(
             cx,
             MISSNAMED_GETTERS,
-            expr_span,
+            span,
             "getter function appears to return the wrong field",
-            "consider using",
-            sugg,
-            Applicability::MaybeIncorrect,
+            |diag| {
+                diag.span_suggestion(expr_span, "consider using", sugg, Applicability::MaybeIncorrect);
+            },
         );
     }
 }
diff --git a/tests/ui/missnamed_getters.stderr b/tests/ui/missnamed_getters.stderr
index 276096ade87..2e3d9df34f4 100644
--- a/tests/ui/missnamed_getters.stderr
+++ b/tests/ui/missnamed_getters.stderr
@@ -1,64 +1,94 @@
 error: getter function appears to return the wrong field
-  --> $DIR/missnamed_getters.rs:12:9
+  --> $DIR/missnamed_getters.rs:11:5
    |
-LL |         &self.b
-   |         ^^^^^^^ help: consider using: `&self.a`
+LL | /     fn a(&self) -> &u8 {
+LL | |         &self.b
+   | |         ------- help: consider using: `&self.a`
+LL | |     }
+   | |_____^
    |
    = note: `-D clippy::missnamed-getters` implied by `-D warnings`
 
 error: getter function appears to return the wrong field
-  --> $DIR/missnamed_getters.rs:15:9
+  --> $DIR/missnamed_getters.rs:14:5
    |
-LL |         &mut self.b
-   |         ^^^^^^^^^^^ help: consider using: `&mut self.a`
+LL | /     fn a_mut(&mut self) -> &mut u8 {
+LL | |         &mut self.b
+   | |         ----------- help: consider using: `&mut self.a`
+LL | |     }
+   | |_____^
 
 error: getter function appears to return the wrong field
-  --> $DIR/missnamed_getters.rs:19:9
+  --> $DIR/missnamed_getters.rs:18:5
    |
-LL |         self.a
-   |         ^^^^^^ help: consider using: `self.b`
+LL | /     fn b(self) -> u8 {
+LL | |         self.a
+   | |         ------ help: consider using: `self.b`
+LL | |     }
+   | |_____^
 
 error: getter function appears to return the wrong field
-  --> $DIR/missnamed_getters.rs:23:9
+  --> $DIR/missnamed_getters.rs:22:5
    |
-LL |         &mut self.a
-   |         ^^^^^^^^^^^ help: consider using: `&mut self.b`
+LL | /     fn b_mut(&mut self) -> &mut u8 {
+LL | |         &mut self.a
+   | |         ----------- help: consider using: `&mut self.b`
+LL | |     }
+   | |_____^
 
 error: getter function appears to return the wrong field
-  --> $DIR/missnamed_getters.rs:27:9
+  --> $DIR/missnamed_getters.rs:26:5
    |
-LL |         &self.b
-   |         ^^^^^^^ help: consider using: `&self.c`
+LL | /     fn c(&self) -> &u8 {
+LL | |         &self.b
+   | |         ------- help: consider using: `&self.c`
+LL | |     }
+   | |_____^
 
 error: getter function appears to return the wrong field
-  --> $DIR/missnamed_getters.rs:31:9
+  --> $DIR/missnamed_getters.rs:30:5
    |
-LL |         &mut self.a
-   |         ^^^^^^^^^^^ help: consider using: `&mut self.c`
+LL | /     fn c_mut(&mut self) -> &mut u8 {
+LL | |         &mut self.a
+   | |         ----------- help: consider using: `&mut self.c`
+LL | |     }
+   | |_____^
 
 error: getter function appears to return the wrong field
-  --> $DIR/missnamed_getters.rs:42:9
+  --> $DIR/missnamed_getters.rs:41:5
    |
-LL |         &self.b
-   |         ^^^^^^^ help: consider using: `&self.a`
+LL | /     unsafe fn a(&self) -> &u8 {
+LL | |         &self.b
+   | |         ------- help: consider using: `&self.a`
+LL | |     }
+   | |_____^
 
 error: getter function appears to return the wrong field
-  --> $DIR/missnamed_getters.rs:45:9
+  --> $DIR/missnamed_getters.rs:44:5
    |
-LL |         &mut self.b
-   |         ^^^^^^^^^^^ help: consider using: `&mut self.a`
+LL | /     unsafe fn a_mut(&mut self) -> &mut u8 {
+LL | |         &mut self.b
+   | |         ----------- help: consider using: `&mut self.a`
+LL | |     }
+   | |_____^
 
 error: getter function appears to return the wrong field
-  --> $DIR/missnamed_getters.rs:49:9
+  --> $DIR/missnamed_getters.rs:48:5
    |
-LL |         self.a
-   |         ^^^^^^ help: consider using: `self.b`
+LL | /     unsafe fn b(self) -> u8 {
+LL | |         self.a
+   | |         ------ help: consider using: `self.b`
+LL | |     }
+   | |_____^
 
 error: getter function appears to return the wrong field
-  --> $DIR/missnamed_getters.rs:53:9
+  --> $DIR/missnamed_getters.rs:52:5
    |
-LL |         &mut self.a
-   |         ^^^^^^^^^^^ help: consider using: `&mut self.b`
+LL | /     unsafe fn b_mut(&mut self) -> &mut u8 {
+LL | |         &mut self.a
+   | |         ----------- help: consider using: `&mut self.b`
+LL | |     }
+   | |_____^
 
 error: aborting due to 10 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 81d459083499c35700f3d7fa2b28cdae2f35a636 Mon Sep 17 00:00:00 2001
From: Sosthène Guédon <sosthene@guedon.gdn>
Date: Tue, 1 Nov 2022 19:31:47 +0100
Subject: missnamed_getters: use all_fields iterator

---
 clippy_lints/src/functions/missnamed_getters.rs | 17 +----------------
 1 file changed, 1 insertion(+), 16 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/functions/missnamed_getters.rs b/clippy_lints/src/functions/missnamed_getters.rs
index 60922fb4ea4..306dccdbd48 100644
--- a/clippy_lints/src/functions/missnamed_getters.rs
+++ b/clippy_lints/src/functions/missnamed_getters.rs
@@ -83,24 +83,9 @@ pub fn check_fn(
         }
     };
 
-    let variants = def.variants();
-
-    // We're accessing a field, so it should be an union or a struct and have one and only one variant
-    if variants.len() != 1 {
-        if cfg!(debug_assertions) {
-            panic!("Struct or union expected to have only one variant");
-        } else {
-            // Don't ICE when possible
-            return;
-        }
-    }
-
-    let first = variants.last().unwrap();
-    let fields = &variants[first];
-
     let mut used_field = None;
     let mut correct_field = None;
-    for f in &fields.fields {
+    for f in def.all_fields() {
         if f.name.as_str() == name {
             correct_field = Some(f);
         }
-- 
cgit 1.4.1-3-g733a5


From 5fa0e07cdf5e6798a71ff252f14a2713699ae99d Mon Sep 17 00:00:00 2001
From: Sosthène Guédon <sosthene@guedon.gdn>
Date: Tue, 1 Nov 2022 21:36:18 +0100
Subject: Document missname_getters

---
 clippy_lints/src/declared_lints.rs |  2 +-
 clippy_lints/src/functions/mod.rs  | 21 +++++++++++++++++++--
 2 files changed, 20 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 0c9ae6380d8..bccf8425968 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -177,6 +177,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::from_raw_with_void_ptr::FROM_RAW_WITH_VOID_PTR_INFO,
     crate::from_str_radix_10::FROM_STR_RADIX_10_INFO,
     crate::functions::DOUBLE_MUST_USE_INFO,
+    crate::functions::MISSNAMED_GETTERS_INFO,
     crate::functions::MUST_USE_CANDIDATE_INFO,
     crate::functions::MUST_USE_UNIT_INFO,
     crate::functions::NOT_UNSAFE_PTR_ARG_DEREF_INFO,
@@ -184,7 +185,6 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::functions::RESULT_UNIT_ERR_INFO,
     crate::functions::TOO_MANY_ARGUMENTS_INFO,
     crate::functions::TOO_MANY_LINES_INFO,
-    crate::functions::MISSNAMED_GETTERS_INFO,
     crate::future_not_send::FUTURE_NOT_SEND_INFO,
     crate::if_let_mutex::IF_LET_MUTEX_INFO,
     crate::if_not_else::IF_NOT_ELSE_INFO,
diff --git a/clippy_lints/src/functions/mod.rs b/clippy_lints/src/functions/mod.rs
index 726df02444f..87792899b25 100644
--- a/clippy_lints/src/functions/mod.rs
+++ b/clippy_lints/src/functions/mod.rs
@@ -263,21 +263,38 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
+    /// Checks for getter methods that return a field that doesn't correspond
+    /// to the name of the method, when there is a field's whose name matches that of the method.
     ///
     /// ### Why is this bad?
+    /// It is most likely that such a  method is a bug caused by a typo or by copy-pasting.
     ///
     /// ### Example
     /// ```rust
+    /// struct A {
+    ///     a: String,
+    ///     b: String,
+    /// }
+    ///
+    /// impl A {
+    ///     fn a(&self) -> &str{
+    ///         self.b
+    ///     }
+    /// }
     /// // example code where clippy issues a warning
     /// ```
     /// Use instead:
     /// ```rust
-    /// // example code which does not raise clippy warning
+    /// impl A {
+    ///     fn a(&self) -> &str{
+    ///         self.a
+    ///     }
+    /// }
     /// ```
     #[clippy::version = "1.66.0"]
     pub MISSNAMED_GETTERS,
     suspicious,
-    "default lint description"
+    "getter method returning the wrong field"
 }
 
 #[derive(Copy, Clone)]
-- 
cgit 1.4.1-3-g733a5


From 3e2e81b2db9bbacc826ac429b52ac1173356a2e3 Mon Sep 17 00:00:00 2001
From: Sosthène Guédon <sosthene@guedon.gdn>
Date: Tue, 1 Nov 2022 21:49:20 +0100
Subject: Fix internal warnings

---
 clippy_lints/src/functions/missnamed_getters.rs | 5 ++---
 clippy_lints/src/functions/mod.rs               | 9 +++++++--
 2 files changed, 9 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/functions/missnamed_getters.rs b/clippy_lints/src/functions/missnamed_getters.rs
index 306dccdbd48..3d78679b526 100644
--- a/clippy_lints/src/functions/missnamed_getters.rs
+++ b/clippy_lints/src/functions/missnamed_getters.rs
@@ -28,15 +28,14 @@ pub fn check_fn(
     let name = ident.name.as_str();
 
     let name = match sig.decl.implicit_self {
-        ImplicitSelfKind::ImmRef => name,
         ImplicitSelfKind::MutRef => {
             let Some(name) = name.strip_suffix("_mut") else {
                     return;
                 };
             name
         },
-        ImplicitSelfKind::Imm | ImplicitSelfKind::Mut => name,
-        _ => return,
+        ImplicitSelfKind::Imm | ImplicitSelfKind::Mut | ImplicitSelfKind::ImmRef => name,
+        ImplicitSelfKind::None => return,
     };
 
     // Body must be &(mut) <self_data>.name
diff --git a/clippy_lints/src/functions/mod.rs b/clippy_lints/src/functions/mod.rs
index 87792899b25..e4181a164cb 100644
--- a/clippy_lints/src/functions/mod.rs
+++ b/clippy_lints/src/functions/mod.rs
@@ -278,16 +278,21 @@ declare_clippy_lint! {
     ///
     /// impl A {
     ///     fn a(&self) -> &str{
-    ///         self.b
+    ///         &self.b
     ///     }
     /// }
     /// // example code where clippy issues a warning
     /// ```
     /// Use instead:
     /// ```rust
+    /// struct A {
+    ///     a: String,
+    ///     b: String,
+    /// }
+    ///
     /// impl A {
     ///     fn a(&self) -> &str{
-    ///         self.a
+    ///         &self.a
     ///     }
     /// }
     /// ```
-- 
cgit 1.4.1-3-g733a5


From 3428da6e00c025b3b3141a9fe7c65ee5008e07f3 Mon Sep 17 00:00:00 2001
From: Sosthène Guédon <sosthene@guedon.gdn>
Date: Wed, 2 Nov 2022 09:01:33 +0100
Subject: Fix typo missnamed -> misnamed

---
 CHANGELOG.md                                    |   2 +-
 clippy_lints/src/declared_lints.rs              |   2 +-
 clippy_lints/src/functions/misnamed_getters.rs  | 122 ++++++++++++++++++++++++
 clippy_lints/src/functions/missnamed_getters.rs | 122 ------------------------
 clippy_lints/src/functions/mod.rs               |   8 +-
 tests/ui/misnamed_getters.rs                    |  67 +++++++++++++
 tests/ui/misnamed_getters.stderr                |  94 ++++++++++++++++++
 tests/ui/missnamed_getters.rs                   |  67 -------------
 tests/ui/missnamed_getters.stderr               |  94 ------------------
 9 files changed, 289 insertions(+), 289 deletions(-)
 create mode 100644 clippy_lints/src/functions/misnamed_getters.rs
 delete mode 100644 clippy_lints/src/functions/missnamed_getters.rs
 create mode 100644 tests/ui/misnamed_getters.rs
 create mode 100644 tests/ui/misnamed_getters.stderr
 delete mode 100644 tests/ui/missnamed_getters.rs
 delete mode 100644 tests/ui/missnamed_getters.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 180e7d8bedc..5b6b12c623a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4188,6 +4188,7 @@ Released 2018-09-13
 [`misaligned_transmute`]: https://rust-lang.github.io/rust-clippy/master/index.html#misaligned_transmute
 [`mismatched_target_os`]: https://rust-lang.github.io/rust-clippy/master/index.html#mismatched_target_os
 [`mismatching_type_param_order`]: https://rust-lang.github.io/rust-clippy/master/index.html#mismatching_type_param_order
+[`misnamed_getters`]: https://rust-lang.github.io/rust-clippy/master/index.html#misnamed_getters
 [`misrefactored_assign_op`]: https://rust-lang.github.io/rust-clippy/master/index.html#misrefactored_assign_op
 [`missing_const_for_fn`]: https://rust-lang.github.io/rust-clippy/master/index.html#missing_const_for_fn
 [`missing_docs_in_private_items`]: https://rust-lang.github.io/rust-clippy/master/index.html#missing_docs_in_private_items
@@ -4198,7 +4199,6 @@ Released 2018-09-13
 [`missing_safety_doc`]: https://rust-lang.github.io/rust-clippy/master/index.html#missing_safety_doc
 [`missing_spin_loop`]: https://rust-lang.github.io/rust-clippy/master/index.html#missing_spin_loop
 [`missing_trait_methods`]: https://rust-lang.github.io/rust-clippy/master/index.html#missing_trait_methods
-[`missnamed_getters`]: https://rust-lang.github.io/rust-clippy/master/index.html#missnamed_getters
 [`mistyped_literal_suffixes`]: https://rust-lang.github.io/rust-clippy/master/index.html#mistyped_literal_suffixes
 [`mixed_case_hex_literals`]: https://rust-lang.github.io/rust-clippy/master/index.html#mixed_case_hex_literals
 [`mixed_read_write_in_expression`]: https://rust-lang.github.io/rust-clippy/master/index.html#mixed_read_write_in_expression
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index bccf8425968..eb3210946f1 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -177,7 +177,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::from_raw_with_void_ptr::FROM_RAW_WITH_VOID_PTR_INFO,
     crate::from_str_radix_10::FROM_STR_RADIX_10_INFO,
     crate::functions::DOUBLE_MUST_USE_INFO,
-    crate::functions::MISSNAMED_GETTERS_INFO,
+    crate::functions::MISNAMED_GETTERS_INFO,
     crate::functions::MUST_USE_CANDIDATE_INFO,
     crate::functions::MUST_USE_UNIT_INFO,
     crate::functions::NOT_UNSAFE_PTR_ARG_DEREF_INFO,
diff --git a/clippy_lints/src/functions/misnamed_getters.rs b/clippy_lints/src/functions/misnamed_getters.rs
new file mode 100644
index 00000000000..3859c7a62ea
--- /dev/null
+++ b/clippy_lints/src/functions/misnamed_getters.rs
@@ -0,0 +1,122 @@
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::source::snippet;
+use rustc_errors::Applicability;
+use rustc_hir::{intravisit::FnKind, Body, ExprKind, FnDecl, HirId, ImplicitSelfKind};
+use rustc_lint::LateContext;
+use rustc_middle::ty;
+use rustc_span::Span;
+
+use super::MISNAMED_GETTERS;
+
+pub fn check_fn(
+    cx: &LateContext<'_>,
+    kind: FnKind<'_>,
+    decl: &FnDecl<'_>,
+    body: &Body<'_>,
+    span: Span,
+    _hir_id: HirId,
+) {
+    let FnKind::Method(ref ident, sig) = kind else {
+            return;
+        };
+
+    // Takes only &(mut) self
+    if decl.inputs.len() != 1 {
+        return;
+    }
+
+    let name = ident.name.as_str();
+
+    let name = match sig.decl.implicit_self {
+        ImplicitSelfKind::MutRef => {
+            let Some(name) = name.strip_suffix("_mut") else {
+                    return;
+                };
+            name
+        },
+        ImplicitSelfKind::Imm | ImplicitSelfKind::Mut | ImplicitSelfKind::ImmRef => name,
+        ImplicitSelfKind::None => return,
+    };
+
+    // Body must be &(mut) <self_data>.name
+    // self_data is not neccessarilly self, to also lint sub-getters, etc…
+
+    let block_expr = if_chain! {
+        if let ExprKind::Block(block,_) = body.value.kind;
+        if block.stmts.is_empty();
+        if let Some(block_expr) = block.expr;
+        then {
+            block_expr
+        } else {
+            return;
+        }
+    };
+    let expr_span = block_expr.span;
+
+    let mut expr = block_expr;
+    // Accept &<expr>, &mut <expr> and <expr>
+    if let ExprKind::AddrOf(_, _, tmp) = expr.kind {
+        expr = tmp;
+    }
+    let (self_data, used_ident) = if_chain! {
+        if let ExprKind::Field(self_data, ident) = expr.kind;
+        if ident.name.as_str() != name;
+        then {
+            (self_data, ident)
+        } else {
+            return;
+        }
+    };
+
+    let ty = cx.typeck_results().expr_ty(self_data);
+
+    let def = {
+        let mut kind = ty.kind();
+        loop {
+            match kind {
+                ty::Adt(def, _) => break def,
+                ty::Ref(_, ty, _) => kind = ty.kind(),
+                // We don't do tuples because the function name cannot be a number
+                _ => return,
+            }
+        }
+    };
+
+    let mut used_field = None;
+    let mut correct_field = None;
+    for f in def.all_fields() {
+        if f.name.as_str() == name {
+            correct_field = Some(f);
+        }
+        if f.name == used_ident.name {
+            used_field = Some(f);
+        }
+    }
+
+    let Some(used_field) = used_field else {
+            if cfg!(debug_assertions) {
+                panic!("Struct doesn't contain the correct field");
+            } else {
+                // Don't ICE when possible
+                return;
+            }
+        };
+    let Some(correct_field) = correct_field else {
+            return;
+        };
+
+    if cx.tcx.type_of(used_field.did) == cx.tcx.type_of(correct_field.did) {
+        let left_span = block_expr.span.until(used_ident.span);
+        let snippet = snippet(cx, left_span, "..");
+        let sugg = format!("{snippet}{name}");
+        span_lint_and_then(
+            cx,
+            MISNAMED_GETTERS,
+            span,
+            "getter function appears to return the wrong field",
+            |diag| {
+                diag.span_suggestion(expr_span, "consider using", sugg, Applicability::MaybeIncorrect);
+            },
+        );
+    }
+}
diff --git a/clippy_lints/src/functions/missnamed_getters.rs b/clippy_lints/src/functions/missnamed_getters.rs
deleted file mode 100644
index 3d78679b526..00000000000
--- a/clippy_lints/src/functions/missnamed_getters.rs
+++ /dev/null
@@ -1,122 +0,0 @@
-use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::source::snippet;
-use rustc_errors::Applicability;
-use rustc_hir::{intravisit::FnKind, Body, ExprKind, FnDecl, HirId, ImplicitSelfKind};
-use rustc_lint::LateContext;
-use rustc_middle::ty;
-use rustc_span::Span;
-
-use super::MISSNAMED_GETTERS;
-
-pub fn check_fn(
-    cx: &LateContext<'_>,
-    kind: FnKind<'_>,
-    decl: &FnDecl<'_>,
-    body: &Body<'_>,
-    span: Span,
-    _hir_id: HirId,
-) {
-    let FnKind::Method(ref ident, sig) = kind else {
-            return;
-        };
-
-    // Takes only &(mut) self
-    if decl.inputs.len() != 1 {
-        return;
-    }
-
-    let name = ident.name.as_str();
-
-    let name = match sig.decl.implicit_self {
-        ImplicitSelfKind::MutRef => {
-            let Some(name) = name.strip_suffix("_mut") else {
-                    return;
-                };
-            name
-        },
-        ImplicitSelfKind::Imm | ImplicitSelfKind::Mut | ImplicitSelfKind::ImmRef => name,
-        ImplicitSelfKind::None => return,
-    };
-
-    // Body must be &(mut) <self_data>.name
-    // self_data is not neccessarilly self, to also lint sub-getters, etc…
-
-    let block_expr = if_chain! {
-        if let ExprKind::Block(block,_) = body.value.kind;
-        if block.stmts.is_empty();
-        if let Some(block_expr) = block.expr;
-        then {
-            block_expr
-        } else {
-            return;
-        }
-    };
-    let expr_span = block_expr.span;
-
-    let mut expr = block_expr;
-    // Accept &<expr>, &mut <expr> and <expr>
-    if let ExprKind::AddrOf(_, _, tmp) = expr.kind {
-        expr = tmp;
-    }
-    let (self_data, used_ident) = if_chain! {
-        if let ExprKind::Field(self_data, ident) = expr.kind;
-        if ident.name.as_str() != name;
-        then {
-            (self_data, ident)
-        } else {
-            return;
-        }
-    };
-
-    let ty = cx.typeck_results().expr_ty(self_data);
-
-    let def = {
-        let mut kind = ty.kind();
-        loop {
-            match kind {
-                ty::Adt(def, _) => break def,
-                ty::Ref(_, ty, _) => kind = ty.kind(),
-                // We don't do tuples because the function name cannot be a number
-                _ => return,
-            }
-        }
-    };
-
-    let mut used_field = None;
-    let mut correct_field = None;
-    for f in def.all_fields() {
-        if f.name.as_str() == name {
-            correct_field = Some(f);
-        }
-        if f.name == used_ident.name {
-            used_field = Some(f);
-        }
-    }
-
-    let Some(used_field) = used_field else {
-            if cfg!(debug_assertions) {
-                panic!("Struct doesn't contain the correct field");
-            } else {
-                // Don't ICE when possible
-                return;
-            }
-        };
-    let Some(correct_field) = correct_field else {
-            return;
-        };
-
-    if cx.tcx.type_of(used_field.did) == cx.tcx.type_of(correct_field.did) {
-        let left_span = block_expr.span.until(used_ident.span);
-        let snippet = snippet(cx, left_span, "..");
-        let sugg = format!("{snippet}{name}");
-        span_lint_and_then(
-            cx,
-            MISSNAMED_GETTERS,
-            span,
-            "getter function appears to return the wrong field",
-            |diag| {
-                diag.span_suggestion(expr_span, "consider using", sugg, Applicability::MaybeIncorrect);
-            },
-        );
-    }
-}
diff --git a/clippy_lints/src/functions/mod.rs b/clippy_lints/src/functions/mod.rs
index e4181a164cb..3478fdd8624 100644
--- a/clippy_lints/src/functions/mod.rs
+++ b/clippy_lints/src/functions/mod.rs
@@ -1,4 +1,4 @@
-mod missnamed_getters;
+mod misnamed_getters;
 mod must_use;
 mod not_unsafe_ptr_arg_deref;
 mod result;
@@ -297,7 +297,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     #[clippy::version = "1.66.0"]
-    pub MISSNAMED_GETTERS,
+    pub MISNAMED_GETTERS,
     suspicious,
     "getter method returning the wrong field"
 }
@@ -328,7 +328,7 @@ impl_lint_pass!(Functions => [
     MUST_USE_CANDIDATE,
     RESULT_UNIT_ERR,
     RESULT_LARGE_ERR,
-    MISSNAMED_GETTERS,
+    MISNAMED_GETTERS,
 ]);
 
 impl<'tcx> LateLintPass<'tcx> for Functions {
@@ -344,7 +344,7 @@ impl<'tcx> LateLintPass<'tcx> for Functions {
         too_many_arguments::check_fn(cx, kind, decl, span, hir_id, self.too_many_arguments_threshold);
         too_many_lines::check_fn(cx, kind, span, body, self.too_many_lines_threshold);
         not_unsafe_ptr_arg_deref::check_fn(cx, kind, decl, body, hir_id);
-        missnamed_getters::check_fn(cx, kind, decl, body, span, hir_id);
+        misnamed_getters::check_fn(cx, kind, decl, body, span, hir_id);
     }
 
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) {
diff --git a/tests/ui/misnamed_getters.rs b/tests/ui/misnamed_getters.rs
new file mode 100644
index 00000000000..7d490f4b143
--- /dev/null
+++ b/tests/ui/misnamed_getters.rs
@@ -0,0 +1,67 @@
+#![allow(unused)]
+#![warn(clippy::misnamed_getters)]
+
+struct A {
+    a: u8,
+    b: u8,
+    c: u8,
+}
+
+impl A {
+    fn a(&self) -> &u8 {
+        &self.b
+    }
+    fn a_mut(&mut self) -> &mut u8 {
+        &mut self.b
+    }
+
+    fn b(self) -> u8 {
+        self.a
+    }
+
+    fn b_mut(&mut self) -> &mut u8 {
+        &mut self.a
+    }
+
+    fn c(&self) -> &u8 {
+        &self.b
+    }
+
+    fn c_mut(&mut self) -> &mut u8 {
+        &mut self.a
+    }
+}
+
+union B {
+    a: u8,
+    b: u8,
+}
+
+impl B {
+    unsafe fn a(&self) -> &u8 {
+        &self.b
+    }
+    unsafe fn a_mut(&mut self) -> &mut u8 {
+        &mut self.b
+    }
+
+    unsafe fn b(self) -> u8 {
+        self.a
+    }
+
+    unsafe fn b_mut(&mut self) -> &mut u8 {
+        &mut self.a
+    }
+
+    unsafe fn c(&self) -> &u8 {
+        &self.b
+    }
+
+    unsafe fn c_mut(&mut self) -> &mut u8 {
+        &mut self.a
+    }
+}
+
+fn main() {
+    // test code goes here
+}
diff --git a/tests/ui/misnamed_getters.stderr b/tests/ui/misnamed_getters.stderr
new file mode 100644
index 00000000000..f4a059ab9b5
--- /dev/null
+++ b/tests/ui/misnamed_getters.stderr
@@ -0,0 +1,94 @@
+error: getter function appears to return the wrong field
+  --> $DIR/misnamed_getters.rs:11:5
+   |
+LL | /     fn a(&self) -> &u8 {
+LL | |         &self.b
+   | |         ------- help: consider using: `&self.a`
+LL | |     }
+   | |_____^
+   |
+   = note: `-D clippy::misnamed-getters` implied by `-D warnings`
+
+error: getter function appears to return the wrong field
+  --> $DIR/misnamed_getters.rs:14:5
+   |
+LL | /     fn a_mut(&mut self) -> &mut u8 {
+LL | |         &mut self.b
+   | |         ----------- help: consider using: `&mut self.a`
+LL | |     }
+   | |_____^
+
+error: getter function appears to return the wrong field
+  --> $DIR/misnamed_getters.rs:18:5
+   |
+LL | /     fn b(self) -> u8 {
+LL | |         self.a
+   | |         ------ help: consider using: `self.b`
+LL | |     }
+   | |_____^
+
+error: getter function appears to return the wrong field
+  --> $DIR/misnamed_getters.rs:22:5
+   |
+LL | /     fn b_mut(&mut self) -> &mut u8 {
+LL | |         &mut self.a
+   | |         ----------- help: consider using: `&mut self.b`
+LL | |     }
+   | |_____^
+
+error: getter function appears to return the wrong field
+  --> $DIR/misnamed_getters.rs:26:5
+   |
+LL | /     fn c(&self) -> &u8 {
+LL | |         &self.b
+   | |         ------- help: consider using: `&self.c`
+LL | |     }
+   | |_____^
+
+error: getter function appears to return the wrong field
+  --> $DIR/misnamed_getters.rs:30:5
+   |
+LL | /     fn c_mut(&mut self) -> &mut u8 {
+LL | |         &mut self.a
+   | |         ----------- help: consider using: `&mut self.c`
+LL | |     }
+   | |_____^
+
+error: getter function appears to return the wrong field
+  --> $DIR/misnamed_getters.rs:41:5
+   |
+LL | /     unsafe fn a(&self) -> &u8 {
+LL | |         &self.b
+   | |         ------- help: consider using: `&self.a`
+LL | |     }
+   | |_____^
+
+error: getter function appears to return the wrong field
+  --> $DIR/misnamed_getters.rs:44:5
+   |
+LL | /     unsafe fn a_mut(&mut self) -> &mut u8 {
+LL | |         &mut self.b
+   | |         ----------- help: consider using: `&mut self.a`
+LL | |     }
+   | |_____^
+
+error: getter function appears to return the wrong field
+  --> $DIR/misnamed_getters.rs:48:5
+   |
+LL | /     unsafe fn b(self) -> u8 {
+LL | |         self.a
+   | |         ------ help: consider using: `self.b`
+LL | |     }
+   | |_____^
+
+error: getter function appears to return the wrong field
+  --> $DIR/misnamed_getters.rs:52:5
+   |
+LL | /     unsafe fn b_mut(&mut self) -> &mut u8 {
+LL | |         &mut self.a
+   | |         ----------- help: consider using: `&mut self.b`
+LL | |     }
+   | |_____^
+
+error: aborting due to 10 previous errors
+
diff --git a/tests/ui/missnamed_getters.rs b/tests/ui/missnamed_getters.rs
deleted file mode 100644
index f9c2351f833..00000000000
--- a/tests/ui/missnamed_getters.rs
+++ /dev/null
@@ -1,67 +0,0 @@
-#![allow(unused)]
-#![warn(clippy::missnamed_getters)]
-
-struct A {
-    a: u8,
-    b: u8,
-    c: u8,
-}
-
-impl A {
-    fn a(&self) -> &u8 {
-        &self.b
-    }
-    fn a_mut(&mut self) -> &mut u8 {
-        &mut self.b
-    }
-
-    fn b(self) -> u8 {
-        self.a
-    }
-
-    fn b_mut(&mut self) -> &mut u8 {
-        &mut self.a
-    }
-
-    fn c(&self) -> &u8 {
-        &self.b
-    }
-
-    fn c_mut(&mut self) -> &mut u8 {
-        &mut self.a
-    }
-}
-
-union B {
-    a: u8,
-    b: u8,
-}
-
-impl B {
-    unsafe fn a(&self) -> &u8 {
-        &self.b
-    }
-    unsafe fn a_mut(&mut self) -> &mut u8 {
-        &mut self.b
-    }
-
-    unsafe fn b(self) -> u8 {
-        self.a
-    }
-
-    unsafe fn b_mut(&mut self) -> &mut u8 {
-        &mut self.a
-    }
-
-    unsafe fn c(&self) -> &u8 {
-        &self.b
-    }
-
-    unsafe fn c_mut(&mut self) -> &mut u8 {
-        &mut self.a
-    }
-}
-
-fn main() {
-    // test code goes here
-}
diff --git a/tests/ui/missnamed_getters.stderr b/tests/ui/missnamed_getters.stderr
deleted file mode 100644
index 2e3d9df34f4..00000000000
--- a/tests/ui/missnamed_getters.stderr
+++ /dev/null
@@ -1,94 +0,0 @@
-error: getter function appears to return the wrong field
-  --> $DIR/missnamed_getters.rs:11:5
-   |
-LL | /     fn a(&self) -> &u8 {
-LL | |         &self.b
-   | |         ------- help: consider using: `&self.a`
-LL | |     }
-   | |_____^
-   |
-   = note: `-D clippy::missnamed-getters` implied by `-D warnings`
-
-error: getter function appears to return the wrong field
-  --> $DIR/missnamed_getters.rs:14:5
-   |
-LL | /     fn a_mut(&mut self) -> &mut u8 {
-LL | |         &mut self.b
-   | |         ----------- help: consider using: `&mut self.a`
-LL | |     }
-   | |_____^
-
-error: getter function appears to return the wrong field
-  --> $DIR/missnamed_getters.rs:18:5
-   |
-LL | /     fn b(self) -> u8 {
-LL | |         self.a
-   | |         ------ help: consider using: `self.b`
-LL | |     }
-   | |_____^
-
-error: getter function appears to return the wrong field
-  --> $DIR/missnamed_getters.rs:22:5
-   |
-LL | /     fn b_mut(&mut self) -> &mut u8 {
-LL | |         &mut self.a
-   | |         ----------- help: consider using: `&mut self.b`
-LL | |     }
-   | |_____^
-
-error: getter function appears to return the wrong field
-  --> $DIR/missnamed_getters.rs:26:5
-   |
-LL | /     fn c(&self) -> &u8 {
-LL | |         &self.b
-   | |         ------- help: consider using: `&self.c`
-LL | |     }
-   | |_____^
-
-error: getter function appears to return the wrong field
-  --> $DIR/missnamed_getters.rs:30:5
-   |
-LL | /     fn c_mut(&mut self) -> &mut u8 {
-LL | |         &mut self.a
-   | |         ----------- help: consider using: `&mut self.c`
-LL | |     }
-   | |_____^
-
-error: getter function appears to return the wrong field
-  --> $DIR/missnamed_getters.rs:41:5
-   |
-LL | /     unsafe fn a(&self) -> &u8 {
-LL | |         &self.b
-   | |         ------- help: consider using: `&self.a`
-LL | |     }
-   | |_____^
-
-error: getter function appears to return the wrong field
-  --> $DIR/missnamed_getters.rs:44:5
-   |
-LL | /     unsafe fn a_mut(&mut self) -> &mut u8 {
-LL | |         &mut self.b
-   | |         ----------- help: consider using: `&mut self.a`
-LL | |     }
-   | |_____^
-
-error: getter function appears to return the wrong field
-  --> $DIR/missnamed_getters.rs:48:5
-   |
-LL | /     unsafe fn b(self) -> u8 {
-LL | |         self.a
-   | |         ------ help: consider using: `self.b`
-LL | |     }
-   | |_____^
-
-error: getter function appears to return the wrong field
-  --> $DIR/missnamed_getters.rs:52:5
-   |
-LL | /     unsafe fn b_mut(&mut self) -> &mut u8 {
-LL | |         &mut self.a
-   | |         ----------- help: consider using: `&mut self.b`
-LL | |     }
-   | |_____^
-
-error: aborting due to 10 previous errors
-
-- 
cgit 1.4.1-3-g733a5


From a867c17ab36926a575a57e24a03e99db672055f2 Mon Sep 17 00:00:00 2001
From: Sosthène Guédon <sosthene@guedon.gdn>
Date: Wed, 2 Nov 2022 19:02:46 +0100
Subject: Improve code

---
 clippy_lints/src/functions/misnamed_getters.rs | 13 +++++++------
 tests/ui/misnamed_getters.rs                   | 23 +++++++++++++++++++++++
 2 files changed, 30 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/functions/misnamed_getters.rs b/clippy_lints/src/functions/misnamed_getters.rs
index 3859c7a62ea..0d50ec37989 100644
--- a/clippy_lints/src/functions/misnamed_getters.rs
+++ b/clippy_lints/src/functions/misnamed_getters.rs
@@ -16,7 +16,7 @@ pub fn check_fn(
     span: Span,
     _hir_id: HirId,
 ) {
-    let FnKind::Method(ref ident, sig) = kind else {
+    let FnKind::Method(ref ident, _) = kind else {
             return;
         };
 
@@ -27,7 +27,7 @@ pub fn check_fn(
 
     let name = ident.name.as_str();
 
-    let name = match sig.decl.implicit_self {
+    let name = match decl.implicit_self {
         ImplicitSelfKind::MutRef => {
             let Some(name) = name.strip_suffix("_mut") else {
                     return;
@@ -53,11 +53,12 @@ pub fn check_fn(
     };
     let expr_span = block_expr.span;
 
-    let mut expr = block_expr;
     // Accept &<expr>, &mut <expr> and <expr>
-    if let ExprKind::AddrOf(_, _, tmp) = expr.kind {
-        expr = tmp;
-    }
+    let expr = if let ExprKind::AddrOf(_, _, tmp) = block_expr.kind {
+        tmp
+    } else {
+        block_expr
+    };
     let (self_data, used_ident) = if_chain! {
         if let ExprKind::Field(self_data, ident) = expr.kind;
         if ident.name.as_str() != name;
diff --git a/tests/ui/misnamed_getters.rs b/tests/ui/misnamed_getters.rs
index 7d490f4b143..6f161818251 100644
--- a/tests/ui/misnamed_getters.rs
+++ b/tests/ui/misnamed_getters.rs
@@ -60,6 +60,29 @@ impl B {
     unsafe fn c_mut(&mut self) -> &mut u8 {
         &mut self.a
     }
+
+    unsafe fn a_unchecked(&self) -> &u8 {
+        &self.b
+    }
+    unsafe fn a_unchecked_mut(&mut self) -> &mut u8 {
+        &mut self.b
+    }
+
+    unsafe fn b_unchecked(self) -> u8 {
+        self.a
+    }
+
+    unsafe fn b_unchecked_mut(&mut self) -> &mut u8 {
+        &mut self.a
+    }
+
+    unsafe fn c_unchecked(&self) -> &u8 {
+        &self.b
+    }
+
+    unsafe fn c_unchecked_mut(&mut self) -> &mut u8 {
+        &mut self.a
+    }
 }
 
 fn main() {
-- 
cgit 1.4.1-3-g733a5


From 3f1a186bd1fd74ad3b25bf5c642e86c8913a1149 Mon Sep 17 00:00:00 2001
From: Sosthène Guédon <sosthene@guedon.gdn>
Date: Wed, 2 Nov 2022 19:11:27 +0100
Subject: misnamed_getters: Trigger on unsafe with _unchecked

---
 clippy_lints/src/functions/misnamed_getters.rs | 10 +++++--
 tests/ui/misnamed_getters.stderr               | 38 +++++++++++++++++++++++++-
 2 files changed, 45 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/functions/misnamed_getters.rs b/clippy_lints/src/functions/misnamed_getters.rs
index 0d50ec37989..599269e2d63 100644
--- a/clippy_lints/src/functions/misnamed_getters.rs
+++ b/clippy_lints/src/functions/misnamed_getters.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet;
 use rustc_errors::Applicability;
-use rustc_hir::{intravisit::FnKind, Body, ExprKind, FnDecl, HirId, ImplicitSelfKind};
+use rustc_hir::{intravisit::FnKind, Body, ExprKind, FnDecl, HirId, ImplicitSelfKind, Unsafety};
 use rustc_lint::LateContext;
 use rustc_middle::ty;
 use rustc_span::Span;
@@ -16,7 +16,7 @@ pub fn check_fn(
     span: Span,
     _hir_id: HirId,
 ) {
-    let FnKind::Method(ref ident, _) = kind else {
+    let FnKind::Method(ref ident, sig) = kind else {
             return;
         };
 
@@ -38,6 +38,12 @@ pub fn check_fn(
         ImplicitSelfKind::None => return,
     };
 
+    let name = if sig.header.unsafety == Unsafety::Unsafe {
+        name.strip_suffix("_unchecked").unwrap_or(name)
+    } else {
+        name
+    };
+
     // Body must be &(mut) <self_data>.name
     // self_data is not neccessarilly self, to also lint sub-getters, etc…
 
diff --git a/tests/ui/misnamed_getters.stderr b/tests/ui/misnamed_getters.stderr
index f4a059ab9b5..feefb95ab4f 100644
--- a/tests/ui/misnamed_getters.stderr
+++ b/tests/ui/misnamed_getters.stderr
@@ -90,5 +90,41 @@ LL | |         &mut self.a
 LL | |     }
    | |_____^
 
-error: aborting due to 10 previous errors
+error: getter function appears to return the wrong field
+  --> $DIR/misnamed_getters.rs:64:5
+   |
+LL | /     unsafe fn a_unchecked(&self) -> &u8 {
+LL | |         &self.b
+   | |         ------- help: consider using: `&self.a`
+LL | |     }
+   | |_____^
+
+error: getter function appears to return the wrong field
+  --> $DIR/misnamed_getters.rs:67:5
+   |
+LL | /     unsafe fn a_unchecked_mut(&mut self) -> &mut u8 {
+LL | |         &mut self.b
+   | |         ----------- help: consider using: `&mut self.a`
+LL | |     }
+   | |_____^
+
+error: getter function appears to return the wrong field
+  --> $DIR/misnamed_getters.rs:71:5
+   |
+LL | /     unsafe fn b_unchecked(self) -> u8 {
+LL | |         self.a
+   | |         ------ help: consider using: `self.b`
+LL | |     }
+   | |_____^
+
+error: getter function appears to return the wrong field
+  --> $DIR/misnamed_getters.rs:75:5
+   |
+LL | /     unsafe fn b_unchecked_mut(&mut self) -> &mut u8 {
+LL | |         &mut self.a
+   | |         ----------- help: consider using: `&mut self.b`
+LL | |     }
+   | |_____^
+
+error: aborting due to 14 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From d9993cb133909eb17705cd9dc518c2c213fc779b Mon Sep 17 00:00:00 2001
From: Sosthène Guédon <sosthene@guedon.gdn>
Date: Sun, 20 Nov 2022 12:20:16 +0100
Subject: Remove error when fields use autoderef

---
 clippy_lints/src/functions/misnamed_getters.rs | 14 ++++++--------
 1 file changed, 6 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/functions/misnamed_getters.rs b/clippy_lints/src/functions/misnamed_getters.rs
index 599269e2d63..c553901059b 100644
--- a/clippy_lints/src/functions/misnamed_getters.rs
+++ b/clippy_lints/src/functions/misnamed_getters.rs
@@ -101,16 +101,14 @@ pub fn check_fn(
     }
 
     let Some(used_field) = used_field else {
-            if cfg!(debug_assertions) {
-                panic!("Struct doesn't contain the correct field");
-            } else {
-                // Don't ICE when possible
-                return;
-            }
-        };
+        // FIXME: This can be reached if the field access uses autoderef.
+        // `dec.all_fields()` should be replaced by something that uses autoderef.
+        return;
+    };
+
     let Some(correct_field) = correct_field else {
             return;
-        };
+    };
 
     if cx.tcx.type_of(used_field.did) == cx.tcx.type_of(correct_field.did) {
         let left_span = block_expr.span.until(used_ident.span);
-- 
cgit 1.4.1-3-g733a5


From 6178ddaded7f73ba413475ea27ac98336069cb11 Mon Sep 17 00:00:00 2001
From: Sosthène Guédon <sosthene@guedon.gdn>
Date: Sun, 20 Nov 2022 13:46:30 +0100
Subject: misname-getters: Fix documentation

---
 clippy_lints/src/functions/mod.rs | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/functions/mod.rs b/clippy_lints/src/functions/mod.rs
index 3478fdd8624..91e6ffe6447 100644
--- a/clippy_lints/src/functions/mod.rs
+++ b/clippy_lints/src/functions/mod.rs
@@ -270,6 +270,7 @@ declare_clippy_lint! {
     /// It is most likely that such a  method is a bug caused by a typo or by copy-pasting.
     ///
     /// ### Example
+
     /// ```rust
     /// struct A {
     ///     a: String,
@@ -281,7 +282,7 @@ declare_clippy_lint! {
     ///         &self.b
     ///     }
     /// }
-    /// // example code where clippy issues a warning
+
     /// ```
     /// Use instead:
     /// ```rust
@@ -296,7 +297,7 @@ declare_clippy_lint! {
     ///     }
     /// }
     /// ```
-    #[clippy::version = "1.66.0"]
+    #[clippy::version = "1.67.0"]
     pub MISNAMED_GETTERS,
     suspicious,
     "getter method returning the wrong field"
-- 
cgit 1.4.1-3-g733a5


From 0411edfbbda82407c956b69db5bf687f8749766e Mon Sep 17 00:00:00 2001
From: Sosthène Guédon <sosthene@guedon.gdn>
Date: Sun, 20 Nov 2022 15:34:56 +0100
Subject: Improve diagnostic for cases where autoderef is used

---
 clippy_lints/src/functions/misnamed_getters.rs |  4 ++--
 tests/ui/misnamed_getters.stderr               | 20 +++++++++++++++++++-
 2 files changed, 21 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/functions/misnamed_getters.rs b/clippy_lints/src/functions/misnamed_getters.rs
index c553901059b..5424c0eecfe 100644
--- a/clippy_lints/src/functions/misnamed_getters.rs
+++ b/clippy_lints/src/functions/misnamed_getters.rs
@@ -75,7 +75,7 @@ pub fn check_fn(
         }
     };
 
-    let ty = cx.typeck_results().expr_ty(self_data);
+    let ty = cx.typeck_results().expr_ty_adjusted(self_data);
 
     let def = {
         let mut kind = ty.kind();
@@ -102,7 +102,7 @@ pub fn check_fn(
 
     let Some(used_field) = used_field else {
         // FIXME: This can be reached if the field access uses autoderef.
-        // `dec.all_fields()` should be replaced by something that uses autoderef.
+        // `dec.all_fields()` should be replaced by something that uses autoderef on the unajusted type of `self_data`
         return;
     };
 
diff --git a/tests/ui/misnamed_getters.stderr b/tests/ui/misnamed_getters.stderr
index feefb95ab4f..5210295893e 100644
--- a/tests/ui/misnamed_getters.stderr
+++ b/tests/ui/misnamed_getters.stderr
@@ -126,5 +126,23 @@ LL | |         &mut self.a
 LL | |     }
    | |_____^
 
-error: aborting due to 14 previous errors
+error: getter function appears to return the wrong field
+  --> $DIR/misnamed_getters.rs:92:5
+   |
+LL | /     unsafe fn a(&self) -> &u8 {
+LL | |         &self.inner.b
+   | |         ------------- help: consider using: `&self.inner.a`
+LL | |     }
+   | |_____^
+
+error: getter function appears to return the wrong field
+  --> $DIR/misnamed_getters.rs:95:5
+   |
+LL | /     unsafe fn a_mut(&mut self) -> &mut u8 {
+LL | |         &mut self.inner.b
+   | |         ----------------- help: consider using: `&mut self.inner.a`
+LL | |     }
+   | |_____^
+
+error: aborting due to 16 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 1f2f50c34eb304ce56213dad70ccdeb2f2901512 Mon Sep 17 00:00:00 2001
From: Sosthène Guédon <sosthene@guedon.gdn>
Date: Sun, 20 Nov 2022 17:03:53 +0100
Subject: Fix many false negatives caused by autoderef

---
 clippy_lints/src/functions/misnamed_getters.rs | 44 ++++++++++++--------------
 tests/ui/misnamed_getters.rs                   | 36 +++++++++++++++++----
 tests/ui/misnamed_getters.stderr               | 36 +++++++++++++++------
 3 files changed, 77 insertions(+), 39 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/functions/misnamed_getters.rs b/clippy_lints/src/functions/misnamed_getters.rs
index 5424c0eecfe..27acad45ccf 100644
--- a/clippy_lints/src/functions/misnamed_getters.rs
+++ b/clippy_lints/src/functions/misnamed_getters.rs
@@ -6,6 +6,8 @@ use rustc_lint::LateContext;
 use rustc_middle::ty;
 use rustc_span::Span;
 
+use std::iter;
+
 use super::MISNAMED_GETTERS;
 
 pub fn check_fn(
@@ -75,39 +77,35 @@ pub fn check_fn(
         }
     };
 
-    let ty = cx.typeck_results().expr_ty_adjusted(self_data);
-
-    let def = {
-        let mut kind = ty.kind();
-        loop {
-            match kind {
-                ty::Adt(def, _) => break def,
-                ty::Ref(_, ty, _) => kind = ty.kind(),
-                // We don't do tuples because the function name cannot be a number
-                _ => return,
-            }
-        }
-    };
-
     let mut used_field = None;
     let mut correct_field = None;
-    for f in def.all_fields() {
-        if f.name.as_str() == name {
-            correct_field = Some(f);
-        }
-        if f.name == used_ident.name {
-            used_field = Some(f);
+    let typeck_results = cx.typeck_results();
+    for adjusted_type in iter::once(typeck_results.expr_ty(self_data))
+        .chain(typeck_results.expr_adjustments(self_data).iter().map(|adj| adj.target))
+    {
+        let ty::Adt(def,_) = adjusted_type.kind() else {
+            continue;
+        };
+
+        for f in def.all_fields() {
+            if f.name.as_str() == name {
+                correct_field = Some(f);
+            }
+            if f.name == used_ident.name {
+                used_field = Some(f);
+            }
         }
     }
 
     let Some(used_field) = used_field else {
-        // FIXME: This can be reached if the field access uses autoderef.
-        // `dec.all_fields()` should be replaced by something that uses autoderef on the unajusted type of `self_data`
+        // Can happen if the field access is a tuple. We don't lint those because the getter name could not start with a number.
         return;
     };
 
     let Some(correct_field) = correct_field else {
-            return;
+        // There is no field corresponding to the getter name.
+        // FIXME: This can be a false positive if the correct field is reachable trought deeper autodereferences than used_field is
+        return;
     };
 
     if cx.tcx.type_of(used_field.did) == cx.tcx.type_of(correct_field.did) {
diff --git a/tests/ui/misnamed_getters.rs b/tests/ui/misnamed_getters.rs
index 2c451bd3a16..03e7dac7df9 100644
--- a/tests/ui/misnamed_getters.rs
+++ b/tests/ui/misnamed_getters.rs
@@ -85,15 +85,37 @@ impl B {
     }
 }
 
-struct C {
-    inner: Box<A>,
+struct D {
+    d: u8,
+    inner: A,
 }
-impl C {
-    unsafe fn a(&self) -> &u8 {
-        &self.inner.b
+
+impl core::ops::Deref for D {
+    type Target = A;
+    fn deref(&self) -> &A {
+        &self.inner
     }
-    unsafe fn a_mut(&mut self) -> &mut u8 {
-        &mut self.inner.b
+}
+
+impl core::ops::DerefMut for D {
+    fn deref_mut(&mut self) -> &mut A {
+        &mut self.inner
+    }
+}
+
+impl D {
+    fn a(&self) -> &u8 {
+        &self.b
+    }
+    fn a_mut(&mut self) -> &mut u8 {
+        &mut self.b
+    }
+
+    fn d(&self) -> &u8 {
+        &self.b
+    }
+    fn d_mut(&mut self) -> &mut u8 {
+        &mut self.b
     }
 }
 
diff --git a/tests/ui/misnamed_getters.stderr b/tests/ui/misnamed_getters.stderr
index 5210295893e..1e38a83d019 100644
--- a/tests/ui/misnamed_getters.stderr
+++ b/tests/ui/misnamed_getters.stderr
@@ -127,22 +127,40 @@ LL | |     }
    | |_____^
 
 error: getter function appears to return the wrong field
-  --> $DIR/misnamed_getters.rs:92:5
+  --> $DIR/misnamed_getters.rs:107:5
    |
-LL | /     unsafe fn a(&self) -> &u8 {
-LL | |         &self.inner.b
-   | |         ------------- help: consider using: `&self.inner.a`
+LL | /     fn a(&self) -> &u8 {
+LL | |         &self.b
+   | |         ------- help: consider using: `&self.a`
 LL | |     }
    | |_____^
 
 error: getter function appears to return the wrong field
-  --> $DIR/misnamed_getters.rs:95:5
+  --> $DIR/misnamed_getters.rs:110:5
    |
-LL | /     unsafe fn a_mut(&mut self) -> &mut u8 {
-LL | |         &mut self.inner.b
-   | |         ----------------- help: consider using: `&mut self.inner.a`
+LL | /     fn a_mut(&mut self) -> &mut u8 {
+LL | |         &mut self.b
+   | |         ----------- help: consider using: `&mut self.a`
+LL | |     }
+   | |_____^
+
+error: getter function appears to return the wrong field
+  --> $DIR/misnamed_getters.rs:114:5
+   |
+LL | /     fn d(&self) -> &u8 {
+LL | |         &self.b
+   | |         ------- help: consider using: `&self.d`
+LL | |     }
+   | |_____^
+
+error: getter function appears to return the wrong field
+  --> $DIR/misnamed_getters.rs:117:5
+   |
+LL | /     fn d_mut(&mut self) -> &mut u8 {
+LL | |         &mut self.b
+   | |         ----------- help: consider using: `&mut self.d`
 LL | |     }
    | |_____^
 
-error: aborting due to 16 previous errors
+error: aborting due to 18 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 637139d2ff4202f9296777f8f4750bcc233b09f8 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Mon, 21 Nov 2022 14:37:51 +0000
Subject: Add `clippy_utils::msrv::Msrv` to keep track of the current MSRV

---
 book/src/development/adding_lints.md               |   8 +-
 clippy_dev/src/new_lint.rs                         |  16 ++-
 clippy_lints/src/almost_complete_letter_range.rs   |  11 +--
 clippy_lints/src/approx_const.rs                   |   8 +-
 clippy_lints/src/attrs.rs                          |  12 +--
 clippy_lints/src/casts/cast_abs_to_unsigned.rs     |   7 +-
 clippy_lints/src/casts/cast_lossless.rs            |  16 +--
 .../src/casts/cast_slice_different_sizes.rs        |   8 +-
 .../src/casts/cast_slice_from_raw_parts.rs         |  14 +--
 clippy_lints/src/casts/mod.rs                      |  22 ++---
 clippy_lints/src/casts/ptr_as_ptr.rs               |   7 +-
 clippy_lints/src/checked_conversions.rs            |  10 +-
 clippy_lints/src/dereference.rs                    |  18 ++--
 clippy_lints/src/format_args.rs                    |  10 +-
 clippy_lints/src/from_over_into.rs                 |  10 +-
 clippy_lints/src/if_then_some_else_none.rs         |  14 ++-
 clippy_lints/src/index_refutable_slice.rs          |  11 +--
 clippy_lints/src/instant_subtraction.rs            |  18 ++--
 clippy_lints/src/lib.rs                            | 108 +++++++--------------
 clippy_lints/src/manual_bits.rs                    |  10 +-
 clippy_lints/src/manual_clamp.rs                   |  33 +++----
 clippy_lints/src/manual_is_ascii_check.rs          |  15 ++-
 clippy_lints/src/manual_let_else.rs                |  10 +-
 clippy_lints/src/manual_non_exhaustive.rs          |  16 +--
 clippy_lints/src/manual_rem_euclid.rs              |  12 +--
 clippy_lints/src/manual_retain.rs                  |  24 ++---
 clippy_lints/src/manual_strip.rs                   |  10 +-
 clippy_lints/src/matches/mod.rs                    |  14 ++-
 clippy_lints/src/mem_replace.rs                    |  10 +-
 .../src/methods/cloned_instead_of_copied.rs        |  10 +-
 clippy_lints/src/methods/err_expect.rs             |   8 +-
 clippy_lints/src/methods/filter_map_next.rs        |   8 +-
 clippy_lints/src/methods/is_digit_ascii_radix.rs   |   9 +-
 clippy_lints/src/methods/map_clone.rs              |  16 +--
 clippy_lints/src/methods/map_unwrap_or.rs          |   7 +-
 clippy_lints/src/methods/mod.rs                    |  36 +++----
 clippy_lints/src/methods/option_as_ref_deref.rs    |   8 +-
 clippy_lints/src/methods/str_splitn.rs             |   8 +-
 clippy_lints/src/methods/unnecessary_to_owned.rs   |   9 +-
 clippy_lints/src/missing_const_for_fn.rs           |  14 ++-
 clippy_lints/src/ranges.rs                         |  10 +-
 clippy_lints/src/redundant_field_names.rs          |   9 +-
 clippy_lints/src/redundant_static_lifetimes.rs     |   9 +-
 clippy_lints/src/transmute/mod.rs                  |   8 +-
 clippy_lints/src/transmute/transmute_ptr_to_ref.rs |  10 +-
 clippy_lints/src/unnested_or_patterns.rs           |  17 ++--
 clippy_lints/src/use_self.rs                       |  14 +--
 .../src/utils/internal_lints/msrv_attr_impl.rs     |   2 +-
 clippy_utils/src/lib.rs                            |  33 ++-----
 clippy_utils/src/msrvs.rs                          | 101 +++++++++++++++++++
 clippy_utils/src/paths.rs                          |   4 +-
 clippy_utils/src/qualify_min_const_fn.rs           |  18 ++--
 tests/ui-internal/invalid_msrv_attr_impl.fixed     |   4 +-
 tests/ui-internal/invalid_msrv_attr_impl.rs        |   4 +-
 tests/ui/min_rust_version_attr.rs                  |  23 +++++
 tests/ui/min_rust_version_attr.stderr              |  18 +++-
 56 files changed, 466 insertions(+), 433 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/book/src/development/adding_lints.md b/book/src/development/adding_lints.md
index 3c3f368a529..29d0d45dcc9 100644
--- a/book/src/development/adding_lints.md
+++ b/book/src/development/adding_lints.md
@@ -443,22 +443,22 @@ value is passed to the constructor in `clippy_lints/lib.rs`.
 
 ```rust
 pub struct ManualStrip {
-    msrv: Option<RustcVersion>,
+    msrv: Msrv,
 }
 
 impl ManualStrip {
     #[must_use]
-    pub fn new(msrv: Option<RustcVersion>) -> Self {
+    pub fn new(msrv: Msrv) -> Self {
         Self { msrv }
     }
 }
 ```
 
 The project's MSRV can then be matched against the feature MSRV in the LintPass
-using the `meets_msrv` utility function.
+using the `Msrv::meets` method.
 
 ``` rust
-if !meets_msrv(self.msrv, msrvs::STR_STRIP_PREFIX) {
+if !self.msrv.meets(msrvs::STR_STRIP_PREFIX) {
     return;
 }
 ```
diff --git a/clippy_dev/src/new_lint.rs b/clippy_dev/src/new_lint.rs
index 9e15f1504fa..ec7f1dd0d84 100644
--- a/clippy_dev/src/new_lint.rs
+++ b/clippy_dev/src/new_lint.rs
@@ -120,7 +120,7 @@ fn add_lint(lint: &LintData<'_>, enable_msrv: bool) -> io::Result<()> {
 
     let new_lint = if enable_msrv {
         format!(
-            "store.register_{lint_pass}_pass(move |{ctor_arg}| Box::new({module_name}::{camel_name}::new(msrv)));\n    ",
+            "store.register_{lint_pass}_pass(move |{ctor_arg}| Box::new({module_name}::{camel_name}::new(msrv())));\n    ",
             lint_pass = lint.pass,
             ctor_arg = if lint.pass == "late" { "_" } else { "" },
             module_name = lint.name,
@@ -238,10 +238,9 @@ fn get_lint_file_contents(lint: &LintData<'_>, enable_msrv: bool) -> String {
     result.push_str(&if enable_msrv {
         formatdoc!(
             r#"
-            use clippy_utils::msrvs;
+            use clippy_utils::msrvs::{{self, Msrv}};
             {pass_import}
             use rustc_lint::{{{context_import}, {pass_type}, LintContext}};
-            use rustc_semver::RustcVersion;
             use rustc_session::{{declare_tool_lint, impl_lint_pass}};
 
         "#
@@ -263,12 +262,12 @@ fn get_lint_file_contents(lint: &LintData<'_>, enable_msrv: bool) -> String {
         formatdoc!(
             r#"
             pub struct {name_camel} {{
-                msrv: Option<RustcVersion>,
+                msrv: Msrv,
             }}
 
             impl {name_camel} {{
                 #[must_use]
-                pub fn new(msrv: Option<RustcVersion>) -> Self {{
+                pub fn new(msrv: Msrv) -> Self {{
                     Self {{ msrv }}
                 }}
             }}
@@ -357,15 +356,14 @@ fn create_lint_for_ty(lint: &LintData<'_>, enable_msrv: bool, ty: &str) -> io::R
         let _ = writedoc!(
             lint_file_contents,
             r#"
-                use clippy_utils::{{meets_msrv, msrvs}};
+                use clippy_utils::msrvs::{{self, Msrv}};
                 use rustc_lint::{{{context_import}, LintContext}};
-                use rustc_semver::RustcVersion;
 
                 use super::{name_upper};
 
                 // TODO: Adjust the parameters as necessary
-                pub(super) fn check(cx: &{context_import}, msrv: Option<RustcVersion>) {{
-                    if !meets_msrv(msrv, todo!("Add a new entry in `clippy_utils/src/msrvs`")) {{
+                pub(super) fn check(cx: &{context_import}, msrv: &Msrv) {{
+                    if !msrv.meets(todo!("Add a new entry in `clippy_utils/src/msrvs`")) {{
                         return;
                     }}
                     todo!();
diff --git a/clippy_lints/src/almost_complete_letter_range.rs b/clippy_lints/src/almost_complete_letter_range.rs
index 073e4af1318..3cf8ba0a521 100644
--- a/clippy_lints/src/almost_complete_letter_range.rs
+++ b/clippy_lints/src/almost_complete_letter_range.rs
@@ -1,11 +1,10 @@
 use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::{trim_span, walk_span_to_context};
-use clippy_utils::{meets_msrv, msrvs};
 use rustc_ast::ast::{Expr, ExprKind, LitKind, Pat, PatKind, RangeEnd, RangeLimits};
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::Span;
 
@@ -33,10 +32,10 @@ declare_clippy_lint! {
 impl_lint_pass!(AlmostCompleteLetterRange => [ALMOST_COMPLETE_LETTER_RANGE]);
 
 pub struct AlmostCompleteLetterRange {
-    msrv: Option<RustcVersion>,
+    msrv: Msrv,
 }
 impl AlmostCompleteLetterRange {
-    pub fn new(msrv: Option<RustcVersion>) -> Self {
+    pub fn new(msrv: Msrv) -> Self {
         Self { msrv }
     }
 }
@@ -46,7 +45,7 @@ impl EarlyLintPass for AlmostCompleteLetterRange {
             let ctxt = e.span.ctxt();
             let sugg = if let Some(start) = walk_span_to_context(start.span, ctxt)
                 && let Some(end) = walk_span_to_context(end.span, ctxt)
-                && meets_msrv(self.msrv, msrvs::RANGE_INCLUSIVE)
+                && self.msrv.meets(msrvs::RANGE_INCLUSIVE)
             {
                 Some((trim_span(cx.sess().source_map(), start.between(end)), "..="))
             } else {
@@ -60,7 +59,7 @@ impl EarlyLintPass for AlmostCompleteLetterRange {
         if let PatKind::Range(Some(start), Some(end), kind) = &p.kind
             && matches!(kind.node, RangeEnd::Excluded)
         {
-            let sugg = if meets_msrv(self.msrv, msrvs::RANGE_INCLUSIVE) {
+            let sugg = if self.msrv.meets(msrvs::RANGE_INCLUSIVE) {
                 "..="
             } else {
                 "..."
diff --git a/clippy_lints/src/approx_const.rs b/clippy_lints/src/approx_const.rs
index 724490fb495..ccf82f132f4 100644
--- a/clippy_lints/src/approx_const.rs
+++ b/clippy_lints/src/approx_const.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_help;
-use clippy_utils::{meets_msrv, msrvs};
+use clippy_utils::msrvs::{self, Msrv};
 use rustc_ast::ast::{FloatTy, LitFloatType, LitKind};
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
@@ -63,12 +63,12 @@ const KNOWN_CONSTS: [(f64, &str, usize, Option<RustcVersion>); 19] = [
 ];
 
 pub struct ApproxConstant {
-    msrv: Option<RustcVersion>,
+    msrv: Msrv,
 }
 
 impl ApproxConstant {
     #[must_use]
-    pub fn new(msrv: Option<RustcVersion>) -> Self {
+    pub fn new(msrv: Msrv) -> Self {
         Self { msrv }
     }
 
@@ -87,7 +87,7 @@ impl ApproxConstant {
         let s = s.as_str();
         if s.parse::<f64>().is_ok() {
             for &(constant, name, min_digits, msrv) in &KNOWN_CONSTS {
-                if is_approx_const(constant, s, min_digits) && msrv.map_or(true, |msrv| meets_msrv(self.msrv, msrv)) {
+                if is_approx_const(constant, s, min_digits) && msrv.map_or(true, |msrv| self.msrv.meets(msrv)) {
                     span_lint_and_help(
                         cx,
                         APPROX_CONSTANT,
diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs
index ecf8e83375d..54364f9dab2 100644
--- a/clippy_lints/src/attrs.rs
+++ b/clippy_lints/src/attrs.rs
@@ -2,9 +2,8 @@
 
 use clippy_utils::diagnostics::{span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::macros::{is_panic, macro_backtrace};
-use clippy_utils::msrvs;
+use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::{first_line_of_span, is_present_in_source, snippet_opt, without_block_comments};
-use clippy_utils::{extract_msrv_attr, meets_msrv};
 use if_chain::if_chain;
 use rustc_ast::{AttrKind, AttrStyle, Attribute, Lit, LitKind, MetaItemKind, NestedMetaItem};
 use rustc_errors::Applicability;
@@ -14,7 +13,6 @@ use rustc_hir::{
 use rustc_lint::{EarlyContext, EarlyLintPass, LateContext, LateLintPass, Level, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty;
-use rustc_semver::RustcVersion;
 use rustc_session::{declare_lint_pass, declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::Span;
 use rustc_span::symbol::Symbol;
@@ -599,7 +597,7 @@ fn is_word(nmi: &NestedMetaItem, expected: Symbol) -> bool {
 }
 
 pub struct EarlyAttributes {
-    pub msrv: Option<RustcVersion>,
+    pub msrv: Msrv,
 }
 
 impl_lint_pass!(EarlyAttributes => [
@@ -614,7 +612,7 @@ impl EarlyLintPass for EarlyAttributes {
     }
 
     fn check_attribute(&mut self, cx: &EarlyContext<'_>, attr: &Attribute) {
-        check_deprecated_cfg_attr(cx, attr, self.msrv);
+        check_deprecated_cfg_attr(cx, attr, &self.msrv);
         check_mismatched_target_os(cx, attr);
     }
 
@@ -654,9 +652,9 @@ fn check_empty_line_after_outer_attr(cx: &EarlyContext<'_>, item: &rustc_ast::It
     }
 }
 
-fn check_deprecated_cfg_attr(cx: &EarlyContext<'_>, attr: &Attribute, msrv: Option<RustcVersion>) {
+fn check_deprecated_cfg_attr(cx: &EarlyContext<'_>, attr: &Attribute, msrv: &Msrv) {
     if_chain! {
-        if meets_msrv(msrv, msrvs::TOOL_ATTRIBUTES);
+        if msrv.meets(msrvs::TOOL_ATTRIBUTES);
         // check cfg_attr
         if attr.has_name(sym::cfg_attr);
         if let Some(items) = attr.meta_item_list();
diff --git a/clippy_lints/src/casts/cast_abs_to_unsigned.rs b/clippy_lints/src/casts/cast_abs_to_unsigned.rs
index 3f1edabe6c5..44226298333 100644
--- a/clippy_lints/src/casts/cast_abs_to_unsigned.rs
+++ b/clippy_lints/src/casts/cast_abs_to_unsigned.rs
@@ -1,11 +1,10 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::sugg::Sugg;
-use clippy_utils::{meets_msrv, msrvs};
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::LateContext;
 use rustc_middle::ty::{self, Ty};
-use rustc_semver::RustcVersion;
 
 use super::CAST_ABS_TO_UNSIGNED;
 
@@ -15,9 +14,9 @@ pub(super) fn check(
     cast_expr: &Expr<'_>,
     cast_from: Ty<'_>,
     cast_to: Ty<'_>,
-    msrv: Option<RustcVersion>,
+    msrv: &Msrv,
 ) {
-    if meets_msrv(msrv, msrvs::UNSIGNED_ABS)
+    if msrv.meets(msrvs::UNSIGNED_ABS)
         && let ty::Int(from) = cast_from.kind()
         && let ty::Uint(to) = cast_to.kind()
         && let ExprKind::MethodCall(method_path, receiver, ..) = cast_expr.kind
diff --git a/clippy_lints/src/casts/cast_lossless.rs b/clippy_lints/src/casts/cast_lossless.rs
index 13c403234da..cf07e050ccc 100644
--- a/clippy_lints/src/casts/cast_lossless.rs
+++ b/clippy_lints/src/casts/cast_lossless.rs
@@ -1,12 +1,12 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::in_constant;
+use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::is_isize_or_usize;
-use clippy_utils::{in_constant, meets_msrv, msrvs};
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::LateContext;
 use rustc_middle::ty::{self, FloatTy, Ty};
-use rustc_semver::RustcVersion;
 
 use super::{utils, CAST_LOSSLESS};
 
@@ -16,7 +16,7 @@ pub(super) fn check(
     cast_op: &Expr<'_>,
     cast_from: Ty<'_>,
     cast_to: Ty<'_>,
-    msrv: Option<RustcVersion>,
+    msrv: &Msrv,
 ) {
     if !should_lint(cx, expr, cast_from, cast_to, msrv) {
         return;
@@ -57,13 +57,7 @@ pub(super) fn check(
     );
 }
 
-fn should_lint(
-    cx: &LateContext<'_>,
-    expr: &Expr<'_>,
-    cast_from: Ty<'_>,
-    cast_to: Ty<'_>,
-    msrv: Option<RustcVersion>,
-) -> bool {
+fn should_lint(cx: &LateContext<'_>, expr: &Expr<'_>, cast_from: Ty<'_>, cast_to: Ty<'_>, msrv: &Msrv) -> bool {
     // Do not suggest using From in consts/statics until it is valid to do so (see #2267).
     if in_constant(cx, expr.hir_id) {
         return false;
@@ -89,7 +83,7 @@ fn should_lint(
             };
             !is_isize_or_usize(cast_from) && from_nbits < to_nbits
         },
-        (false, true) if matches!(cast_from.kind(), ty::Bool) && meets_msrv(msrv, msrvs::FROM_BOOL) => true,
+        (false, true) if matches!(cast_from.kind(), ty::Bool) && msrv.meets(msrvs::FROM_BOOL) => true,
         (_, _) => {
             matches!(cast_from.kind(), ty::Float(FloatTy::F32)) && matches!(cast_to.kind(), ty::Float(FloatTy::F64))
         },
diff --git a/clippy_lints/src/casts/cast_slice_different_sizes.rs b/clippy_lints/src/casts/cast_slice_different_sizes.rs
index d31d10d22b9..e862f13e69f 100644
--- a/clippy_lints/src/casts/cast_slice_different_sizes.rs
+++ b/clippy_lints/src/casts/cast_slice_different_sizes.rs
@@ -1,16 +1,16 @@
-use clippy_utils::{diagnostics::span_lint_and_then, meets_msrv, msrvs, source};
+use clippy_utils::msrvs::{self, Msrv};
+use clippy_utils::{diagnostics::span_lint_and_then, source};
 use if_chain::if_chain;
 use rustc_ast::Mutability;
 use rustc_hir::{Expr, ExprKind, Node};
 use rustc_lint::LateContext;
 use rustc_middle::ty::{self, layout::LayoutOf, Ty, TypeAndMut};
-use rustc_semver::RustcVersion;
 
 use super::CAST_SLICE_DIFFERENT_SIZES;
 
-pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>, msrv: Option<RustcVersion>) {
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>, msrv: &Msrv) {
     // suggestion is invalid if `ptr::slice_from_raw_parts` does not exist
-    if !meets_msrv(msrv, msrvs::PTR_SLICE_RAW_PARTS) {
+    if !msrv.meets(msrvs::PTR_SLICE_RAW_PARTS) {
         return;
     }
 
diff --git a/clippy_lints/src/casts/cast_slice_from_raw_parts.rs b/clippy_lints/src/casts/cast_slice_from_raw_parts.rs
index 284ef165998..627b795d6ed 100644
--- a/clippy_lints/src/casts/cast_slice_from_raw_parts.rs
+++ b/clippy_lints/src/casts/cast_slice_from_raw_parts.rs
@@ -1,12 +1,12 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::{match_def_path, meets_msrv, msrvs, paths};
+use clippy_utils::{match_def_path, paths};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{def_id::DefId, Expr, ExprKind};
 use rustc_lint::LateContext;
 use rustc_middle::ty::{self, Ty};
-use rustc_semver::RustcVersion;
 
 use super::CAST_SLICE_FROM_RAW_PARTS;
 
@@ -25,15 +25,9 @@ fn raw_parts_kind(cx: &LateContext<'_>, did: DefId) -> Option<RawPartsKind> {
     }
 }
 
-pub(super) fn check(
-    cx: &LateContext<'_>,
-    expr: &Expr<'_>,
-    cast_expr: &Expr<'_>,
-    cast_to: Ty<'_>,
-    msrv: Option<RustcVersion>,
-) {
+pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_expr: &Expr<'_>, cast_to: Ty<'_>, msrv: &Msrv) {
     if_chain! {
-        if meets_msrv(msrv, msrvs::PTR_SLICE_RAW_PARTS);
+        if msrv.meets(msrvs::PTR_SLICE_RAW_PARTS);
         if let ty::RawPtr(ptrty) = cast_to.kind();
         if let ty::Slice(_) = ptrty.ty.kind();
         if let ExprKind::Call(fun, [ptr_arg, len_arg]) = cast_expr.peel_blocks().kind;
diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index 7148b5e6ebf..c6d505c4a18 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -21,11 +21,11 @@ mod ptr_as_ptr;
 mod unnecessary_cast;
 mod utils;
 
-use clippy_utils::{is_hir_ty_cfg_dependant, meets_msrv, msrvs};
+use clippy_utils::is_hir_ty_cfg_dependant;
+use clippy_utils::msrvs::{self, Msrv};
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 
 declare_clippy_lint! {
@@ -648,12 +648,12 @@ declare_clippy_lint! {
 }
 
 pub struct Casts {
-    msrv: Option<RustcVersion>,
+    msrv: Msrv,
 }
 
 impl Casts {
     #[must_use]
-    pub fn new(msrv: Option<RustcVersion>) -> Self {
+    pub fn new(msrv: Msrv) -> Self {
         Self { msrv }
     }
 }
@@ -686,7 +686,7 @@ impl_lint_pass!(Casts => [
 impl<'tcx> LateLintPass<'tcx> for Casts {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if !in_external_macro(cx.sess(), expr.span) {
-            ptr_as_ptr::check(cx, expr, self.msrv);
+            ptr_as_ptr::check(cx, expr, &self.msrv);
         }
 
         if expr.span.from_expansion() {
@@ -705,7 +705,7 @@ impl<'tcx> LateLintPass<'tcx> for Casts {
             if unnecessary_cast::check(cx, expr, cast_expr, cast_from, cast_to) {
                 return;
             }
-            cast_slice_from_raw_parts::check(cx, expr, cast_expr, cast_to, self.msrv);
+            cast_slice_from_raw_parts::check(cx, expr, cast_expr, cast_to, &self.msrv);
             as_ptr_cast_mut::check(cx, expr, cast_expr, cast_to);
             fn_to_numeric_cast_any::check(cx, expr, cast_expr, cast_from, cast_to);
             fn_to_numeric_cast::check(cx, expr, cast_expr, cast_from, cast_to);
@@ -717,16 +717,16 @@ impl<'tcx> LateLintPass<'tcx> for Casts {
                     cast_possible_wrap::check(cx, expr, cast_from, cast_to);
                     cast_precision_loss::check(cx, expr, cast_from, cast_to);
                     cast_sign_loss::check(cx, expr, cast_expr, cast_from, cast_to);
-                    cast_abs_to_unsigned::check(cx, expr, cast_expr, cast_from, cast_to, self.msrv);
+                    cast_abs_to_unsigned::check(cx, expr, cast_expr, cast_from, cast_to, &self.msrv);
                     cast_nan_to_int::check(cx, expr, cast_expr, cast_from, cast_to);
                 }
-                cast_lossless::check(cx, expr, cast_expr, cast_from, cast_to, self.msrv);
+                cast_lossless::check(cx, expr, cast_expr, cast_from, cast_to, &self.msrv);
                 cast_enum_constructor::check(cx, expr, cast_expr, cast_from);
             }
 
             as_underscore::check(cx, expr, cast_to_hir);
 
-            if meets_msrv(self.msrv, msrvs::BORROW_AS_PTR) {
+            if self.msrv.meets(msrvs::BORROW_AS_PTR) {
                 borrow_as_ptr::check(cx, expr, cast_expr, cast_to_hir);
             }
         }
@@ -734,8 +734,8 @@ impl<'tcx> LateLintPass<'tcx> for Casts {
         cast_ref_to_mut::check(cx, expr);
         cast_ptr_alignment::check(cx, expr);
         char_lit_as_u8::check(cx, expr);
-        ptr_as_ptr::check(cx, expr, self.msrv);
-        cast_slice_different_sizes::check(cx, expr, self.msrv);
+        ptr_as_ptr::check(cx, expr, &self.msrv);
+        cast_slice_different_sizes::check(cx, expr, &self.msrv);
     }
 
     extract_msrv_attr!(LateContext);
diff --git a/clippy_lints/src/casts/ptr_as_ptr.rs b/clippy_lints/src/casts/ptr_as_ptr.rs
index c2b9253ec35..43d75a03235 100644
--- a/clippy_lints/src/casts/ptr_as_ptr.rs
+++ b/clippy_lints/src/casts/ptr_as_ptr.rs
@@ -1,19 +1,18 @@
 use std::borrow::Cow;
 
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::sugg::Sugg;
-use clippy_utils::{meets_msrv, msrvs};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, Mutability, TyKind};
 use rustc_lint::LateContext;
 use rustc_middle::ty::{self, TypeAndMut};
-use rustc_semver::RustcVersion;
 
 use super::PTR_AS_PTR;
 
-pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, msrv: Option<RustcVersion>) {
-    if !meets_msrv(msrv, msrvs::POINTER_CAST) {
+pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, msrv: &Msrv) {
+    if !msrv.meets(msrvs::POINTER_CAST) {
         return;
     }
 
diff --git a/clippy_lints/src/checked_conversions.rs b/clippy_lints/src/checked_conversions.rs
index 78e9921f036..9102a89e377 100644
--- a/clippy_lints/src/checked_conversions.rs
+++ b/clippy_lints/src/checked_conversions.rs
@@ -1,14 +1,14 @@
 //! lint on manually implemented checked conversions that could be transformed into `try_from`
 
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::{in_constant, is_integer_literal, meets_msrv, msrvs, SpanlessEq};
+use clippy_utils::{in_constant, is_integer_literal, SpanlessEq};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOp, BinOpKind, Expr, ExprKind, QPath, TyKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 
 declare_clippy_lint! {
@@ -37,12 +37,12 @@ declare_clippy_lint! {
 }
 
 pub struct CheckedConversions {
-    msrv: Option<RustcVersion>,
+    msrv: Msrv,
 }
 
 impl CheckedConversions {
     #[must_use]
-    pub fn new(msrv: Option<RustcVersion>) -> Self {
+    pub fn new(msrv: Msrv) -> Self {
         Self { msrv }
     }
 }
@@ -51,7 +51,7 @@ impl_lint_pass!(CheckedConversions => [CHECKED_CONVERSIONS]);
 
 impl<'tcx> LateLintPass<'tcx> for CheckedConversions {
     fn check_expr(&mut self, cx: &LateContext<'_>, item: &Expr<'_>) {
-        if !meets_msrv(self.msrv, msrvs::TRY_FROM) {
+        if !self.msrv.meets(msrvs::TRY_FROM) {
             return;
         }
 
diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index 0eee7f23982..faa8467d266 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -1,12 +1,13 @@
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_hir_and_then};
 use clippy_utils::mir::{enclosing_mir, expr_local, local_assignments, used_exactly_once, PossibleBorrowerMap};
+use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::{snippet_with_applicability, snippet_with_context};
 use clippy_utils::sugg::has_enclosing_paren;
 use clippy_utils::ty::{expr_sig, is_copy, peel_mid_ty_refs, ty_sig, variant_of_res};
 use clippy_utils::{
-    fn_def_id, get_parent_expr, get_parent_expr_for_hir, is_lint_allowed, meets_msrv, msrvs, path_to_local,
-    walk_to_expr_usage,
+    fn_def_id, get_parent_expr, get_parent_expr_for_hir, is_lint_allowed, path_to_local, walk_to_expr_usage,
 };
+
 use rustc_ast::util::parser::{PREC_POSTFIX, PREC_PREFIX};
 use rustc_data_structures::fx::FxIndexMap;
 use rustc_data_structures::graph::iterate::{CycleDetector, TriColorDepthFirstSearch};
@@ -28,7 +29,6 @@ use rustc_middle::ty::{
     self, Binder, BoundVariableKind, EarlyBinder, FnSig, GenericArgKind, List, ParamTy, PredicateKind,
     ProjectionPredicate, Ty, TyCtxt, TypeVisitable, TypeckResults,
 };
-use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::{symbol::sym, Span, Symbol, DUMMY_SP};
 use rustc_trait_selection::infer::InferCtxtExt as _;
@@ -181,12 +181,12 @@ pub struct Dereferencing<'tcx> {
     possible_borrowers: Vec<(LocalDefId, PossibleBorrowerMap<'tcx, 'tcx>)>,
 
     // `IntoIterator` for arrays requires Rust 1.53.
-    msrv: Option<RustcVersion>,
+    msrv: Msrv,
 }
 
 impl<'tcx> Dereferencing<'tcx> {
     #[must_use]
-    pub fn new(msrv: Option<RustcVersion>) -> Self {
+    pub fn new(msrv: Msrv) -> Self {
         Self {
             msrv,
             ..Dereferencing::default()
@@ -286,7 +286,7 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing<'tcx> {
         match (self.state.take(), kind) {
             (None, kind) => {
                 let expr_ty = typeck.expr_ty(expr);
-                let (position, adjustments) = walk_parents(cx, &mut self.possible_borrowers, expr, self.msrv);
+                let (position, adjustments) = walk_parents(cx, &mut self.possible_borrowers, expr, &self.msrv);
                 match kind {
                     RefOp::Deref => {
                         if let Position::FieldAccess {
@@ -698,7 +698,7 @@ fn walk_parents<'tcx>(
     cx: &LateContext<'tcx>,
     possible_borrowers: &mut Vec<(LocalDefId, PossibleBorrowerMap<'tcx, 'tcx>)>,
     e: &'tcx Expr<'_>,
-    msrv: Option<RustcVersion>,
+    msrv: &Msrv,
 ) -> (Position, &'tcx [Adjustment<'tcx>]) {
     let mut adjustments = [].as_slice();
     let mut precedence = 0i8;
@@ -1082,7 +1082,7 @@ fn needless_borrow_impl_arg_position<'tcx>(
     param_ty: ParamTy,
     mut expr: &Expr<'tcx>,
     precedence: i8,
-    msrv: Option<RustcVersion>,
+    msrv: &Msrv,
 ) -> Position {
     let destruct_trait_def_id = cx.tcx.lang_items().destruct_trait();
     let sized_trait_def_id = cx.tcx.lang_items().sized_trait();
@@ -1182,7 +1182,7 @@ fn needless_borrow_impl_arg_position<'tcx>(
                 && let ty::Param(param_ty) = trait_predicate.self_ty().kind()
                 && let GenericArgKind::Type(ty) = substs_with_referent_ty[param_ty.index as usize].unpack()
                 && ty.is_array()
-                && !meets_msrv(msrv, msrvs::ARRAY_INTO_ITERATOR)
+                && !msrv.meets(msrvs::ARRAY_INTO_ITERATOR)
             {
                 return false;
             }
diff --git a/clippy_lints/src/format_args.rs b/clippy_lints/src/format_args.rs
index a73453bf027..ec45be558f1 100644
--- a/clippy_lints/src/format_args.rs
+++ b/clippy_lints/src/format_args.rs
@@ -1,11 +1,12 @@
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
+use clippy_utils::is_diag_trait_item;
 use clippy_utils::macros::FormatParamKind::{Implicit, Named, Numbered, Starred};
 use clippy_utils::macros::{
     is_format_macro, is_panic, root_macro_call, Count, FormatArg, FormatArgsExpn, FormatParam, FormatParamUsage,
 };
+use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::{implements_trait, is_type_diagnostic_item};
-use clippy_utils::{is_diag_trait_item, meets_msrv, msrvs};
 use if_chain::if_chain;
 use itertools::Itertools;
 use rustc_errors::Applicability;
@@ -13,7 +14,6 @@ use rustc_hir::{Expr, ExprKind, HirId, QPath};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::ty::adjustment::{Adjust, Adjustment};
 use rustc_middle::ty::Ty;
-use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::def_id::DefId;
 use rustc_span::edition::Edition::Edition2021;
@@ -158,12 +158,12 @@ impl_lint_pass!(FormatArgs => [
 ]);
 
 pub struct FormatArgs {
-    msrv: Option<RustcVersion>,
+    msrv: Msrv,
 }
 
 impl FormatArgs {
     #[must_use]
-    pub fn new(msrv: Option<RustcVersion>) -> Self {
+    pub fn new(msrv: Msrv) -> Self {
         Self { msrv }
     }
 }
@@ -188,7 +188,7 @@ impl<'tcx> LateLintPass<'tcx> for FormatArgs {
                 check_format_in_format_args(cx, outermost_expn_data.call_site, name, arg.param.value);
                 check_to_string_in_format_args(cx, name, arg.param.value);
             }
-            if meets_msrv(self.msrv, msrvs::FORMAT_ARGS_CAPTURE) {
+            if self.msrv.meets(msrvs::FORMAT_ARGS_CAPTURE) {
                 check_uninlined_args(cx, &format_args, outermost_expn_data.call_site, macro_def_id);
             }
         }
diff --git a/clippy_lints/src/from_over_into.rs b/clippy_lints/src/from_over_into.rs
index 95eda4ea882..7ff4a05fcdd 100644
--- a/clippy_lints/src/from_over_into.rs
+++ b/clippy_lints/src/from_over_into.rs
@@ -1,7 +1,8 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::macros::span_is_local;
+use clippy_utils::msrvs::{self, Msrv};
+use clippy_utils::path_def_id;
 use clippy_utils::source::snippet_opt;
-use clippy_utils::{meets_msrv, msrvs, path_def_id};
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_path, Visitor};
 use rustc_hir::{
@@ -10,7 +11,6 @@ use rustc_hir::{
 };
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::nested_filter::OnlyBodies;
-use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::symbol::{kw, sym};
 use rustc_span::{Span, Symbol};
@@ -49,12 +49,12 @@ declare_clippy_lint! {
 }
 
 pub struct FromOverInto {
-    msrv: Option<RustcVersion>,
+    msrv: Msrv,
 }
 
 impl FromOverInto {
     #[must_use]
-    pub fn new(msrv: Option<RustcVersion>) -> Self {
+    pub fn new(msrv: Msrv) -> Self {
         FromOverInto { msrv }
     }
 }
@@ -63,7 +63,7 @@ impl_lint_pass!(FromOverInto => [FROM_OVER_INTO]);
 
 impl<'tcx> LateLintPass<'tcx> for FromOverInto {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
-        if !meets_msrv(self.msrv, msrvs::RE_REBALANCING_COHERENCE) || !span_is_local(item.span) {
+        if !self.msrv.meets(msrvs::RE_REBALANCING_COHERENCE) || !span_is_local(item.span) {
             return;
         }
 
diff --git a/clippy_lints/src/if_then_some_else_none.rs b/clippy_lints/src/if_then_some_else_none.rs
index 0d6718c168a..9cadaaa493e 100644
--- a/clippy_lints/src/if_then_some_else_none.rs
+++ b/clippy_lints/src/if_then_some_else_none.rs
@@ -1,14 +1,12 @@
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::eager_or_lazy::switch_to_eager_eval;
+use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::snippet_with_macro_callsite;
-use clippy_utils::{
-    contains_return, higher, is_else_clause, is_res_lang_ctor, meets_msrv, msrvs, path_res, peel_blocks,
-};
+use clippy_utils::{contains_return, higher, is_else_clause, is_res_lang_ctor, path_res, peel_blocks};
 use rustc_hir::LangItem::{OptionNone, OptionSome};
 use rustc_hir::{Expr, ExprKind, Stmt, StmtKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 
 declare_clippy_lint! {
@@ -47,12 +45,12 @@ declare_clippy_lint! {
 }
 
 pub struct IfThenSomeElseNone {
-    msrv: Option<RustcVersion>,
+    msrv: Msrv,
 }
 
 impl IfThenSomeElseNone {
     #[must_use]
-    pub fn new(msrv: Option<RustcVersion>) -> Self {
+    pub fn new(msrv: Msrv) -> Self {
         Self { msrv }
     }
 }
@@ -61,7 +59,7 @@ impl_lint_pass!(IfThenSomeElseNone => [IF_THEN_SOME_ELSE_NONE]);
 
 impl<'tcx> LateLintPass<'tcx> for IfThenSomeElseNone {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
-        if !meets_msrv(self.msrv, msrvs::BOOL_THEN) {
+        if !self.msrv.meets(msrvs::BOOL_THEN) {
             return;
         }
 
@@ -94,7 +92,7 @@ impl<'tcx> LateLintPass<'tcx> for IfThenSomeElseNone {
             } else {
                 format!("{{ /* snippet */ {arg_snip} }}")
             };
-            let method_name = if switch_to_eager_eval(cx, expr) && meets_msrv(self.msrv, msrvs::BOOL_THEN_SOME) {
+            let method_name = if switch_to_eager_eval(cx, expr) && self.msrv.meets(msrvs::BOOL_THEN_SOME) {
                 "then_some"
             } else {
                 method_body.insert_str(0, "|| ");
diff --git a/clippy_lints/src/index_refutable_slice.rs b/clippy_lints/src/index_refutable_slice.rs
index 0d5099bde6d..ee5f10da5b8 100644
--- a/clippy_lints/src/index_refutable_slice.rs
+++ b/clippy_lints/src/index_refutable_slice.rs
@@ -1,8 +1,9 @@
 use clippy_utils::consts::{constant, Constant};
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::higher::IfLet;
+use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::ty::is_copy;
-use clippy_utils::{is_expn_of, is_lint_allowed, meets_msrv, msrvs, path_to_local};
+use clippy_utils::{is_expn_of, is_lint_allowed, path_to_local};
 use if_chain::if_chain;
 use rustc_data_structures::fx::{FxHashSet, FxIndexMap};
 use rustc_errors::Applicability;
@@ -11,7 +12,6 @@ use rustc_hir::intravisit::{self, Visitor};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::nested_filter;
 use rustc_middle::ty;
-use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::{symbol::Ident, Span};
 
@@ -51,14 +51,13 @@ declare_clippy_lint! {
     "avoid indexing on slices which could be destructed"
 }
 
-#[derive(Copy, Clone)]
 pub struct IndexRefutableSlice {
     max_suggested_slice: u64,
-    msrv: Option<RustcVersion>,
+    msrv: Msrv,
 }
 
 impl IndexRefutableSlice {
-    pub fn new(max_suggested_slice_pattern_length: u64, msrv: Option<RustcVersion>) -> Self {
+    pub fn new(max_suggested_slice_pattern_length: u64, msrv: Msrv) -> Self {
         Self {
             max_suggested_slice: max_suggested_slice_pattern_length,
             msrv,
@@ -74,7 +73,7 @@ impl<'tcx> LateLintPass<'tcx> for IndexRefutableSlice {
             if !expr.span.from_expansion() || is_expn_of(expr.span, "if_chain").is_some();
             if let Some(IfLet {let_pat, if_then, ..}) = IfLet::hir(cx, expr);
             if !is_lint_allowed(cx, INDEX_REFUTABLE_SLICE, expr.hir_id);
-            if meets_msrv(self.msrv, msrvs::SLICE_PATTERNS);
+            if self.msrv.meets(msrvs::SLICE_PATTERNS);
 
             let found_slices = find_slice_values(cx, let_pat);
             if !found_slices.is_empty();
diff --git a/clippy_lints/src/instant_subtraction.rs b/clippy_lints/src/instant_subtraction.rs
index 60754b224fc..dd1b23e7d9d 100644
--- a/clippy_lints/src/instant_subtraction.rs
+++ b/clippy_lints/src/instant_subtraction.rs
@@ -1,13 +1,11 @@
-use clippy_utils::{
-    diagnostics::{self, span_lint_and_sugg},
-    meets_msrv, msrvs, source,
-    sugg::Sugg,
-    ty,
-};
+use clippy_utils::diagnostics::{self, span_lint_and_sugg};
+use clippy_utils::msrvs::{self, Msrv};
+use clippy_utils::source;
+use clippy_utils::sugg::Sugg;
+use clippy_utils::ty;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::{source_map::Spanned, sym};
 
@@ -68,12 +66,12 @@ declare_clippy_lint! {
 }
 
 pub struct InstantSubtraction {
-    msrv: Option<RustcVersion>,
+    msrv: Msrv,
 }
 
 impl InstantSubtraction {
     #[must_use]
-    pub fn new(msrv: Option<RustcVersion>) -> Self {
+    pub fn new(msrv: Msrv) -> Self {
         Self { msrv }
     }
 }
@@ -101,7 +99,7 @@ impl LateLintPass<'_> for InstantSubtraction {
                 } else {
                     if_chain! {
                         if !expr.span.from_expansion();
-                        if meets_msrv(self.msrv, msrvs::TRY_FROM);
+                        if self.msrv.meets(msrvs::TRY_FROM);
 
                         if is_an_instant(cx, lhs);
                         if is_a_duration(cx, rhs);
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 3ab5031696d..46acc9679f5 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -52,10 +52,9 @@ extern crate declare_clippy_lint;
 use std::io;
 use std::path::PathBuf;
 
-use clippy_utils::parse_msrv;
+use clippy_utils::msrvs::Msrv;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_lint::{Lint, LintId};
-use rustc_semver::RustcVersion;
 use rustc_session::Session;
 
 #[cfg(feature = "internal")]
@@ -322,48 +321,10 @@ pub use crate::utils::conf::{lookup_conf_file, Conf};
 /// Used in `./src/driver.rs`.
 pub fn register_pre_expansion_lints(store: &mut rustc_lint::LintStore, sess: &Session, conf: &Conf) {
     // NOTE: Do not add any more pre-expansion passes. These should be removed eventually.
+    let msrv = Msrv::read(&conf.msrv, sess);
+    let msrv = move || msrv.clone();
 
-    let msrv = conf.msrv.as_ref().and_then(|s| {
-        parse_msrv(s, None, None).or_else(|| {
-            sess.err(format!(
-                "error reading Clippy's configuration file. `{s}` is not a valid Rust version"
-            ));
-            None
-        })
-    });
-
-    store.register_pre_expansion_pass(move || Box::new(attrs::EarlyAttributes { msrv }));
-}
-
-fn read_msrv(conf: &Conf, sess: &Session) -> Option<RustcVersion> {
-    let cargo_msrv = std::env::var("CARGO_PKG_RUST_VERSION")
-        .ok()
-        .and_then(|v| parse_msrv(&v, None, None));
-    let clippy_msrv = conf.msrv.as_ref().and_then(|s| {
-        parse_msrv(s, None, None).or_else(|| {
-            sess.err(format!(
-                "error reading Clippy's configuration file. `{s}` is not a valid Rust version"
-            ));
-            None
-        })
-    });
-
-    if let Some(cargo_msrv) = cargo_msrv {
-        if let Some(clippy_msrv) = clippy_msrv {
-            // if both files have an msrv, let's compare them and emit a warning if they differ
-            if clippy_msrv != cargo_msrv {
-                sess.warn(format!(
-                    "the MSRV in `clippy.toml` and `Cargo.toml` differ; using `{clippy_msrv}` from `clippy.toml`"
-                ));
-            }
-
-            Some(clippy_msrv)
-        } else {
-            Some(cargo_msrv)
-        }
-    } else {
-        clippy_msrv
-    }
+    store.register_pre_expansion_pass(move || Box::new(attrs::EarlyAttributes { msrv: msrv() }));
 }
 
 #[doc(hidden)]
@@ -595,43 +556,44 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(non_octal_unix_permissions::NonOctalUnixPermissions));
     store.register_early_pass(|| Box::new(unnecessary_self_imports::UnnecessarySelfImports));
 
-    let msrv = read_msrv(conf, sess);
+    let msrv = Msrv::read(&conf.msrv, sess);
+    let msrv = move || msrv.clone();
     let avoid_breaking_exported_api = conf.avoid_breaking_exported_api;
     let allow_expect_in_tests = conf.allow_expect_in_tests;
     let allow_unwrap_in_tests = conf.allow_unwrap_in_tests;
-    store.register_late_pass(move |_| Box::new(approx_const::ApproxConstant::new(msrv)));
+    store.register_late_pass(move |_| Box::new(approx_const::ApproxConstant::new(msrv())));
     store.register_late_pass(move |_| {
         Box::new(methods::Methods::new(
             avoid_breaking_exported_api,
-            msrv,
+            msrv(),
             allow_expect_in_tests,
             allow_unwrap_in_tests,
         ))
     });
-    store.register_late_pass(move |_| Box::new(matches::Matches::new(msrv)));
+    store.register_late_pass(move |_| Box::new(matches::Matches::new(msrv())));
     let matches_for_let_else = conf.matches_for_let_else;
-    store.register_late_pass(move |_| Box::new(manual_let_else::ManualLetElse::new(msrv, matches_for_let_else)));
-    store.register_early_pass(move || Box::new(manual_non_exhaustive::ManualNonExhaustiveStruct::new(msrv)));
-    store.register_late_pass(move |_| Box::new(manual_non_exhaustive::ManualNonExhaustiveEnum::new(msrv)));
-    store.register_late_pass(move |_| Box::new(manual_strip::ManualStrip::new(msrv)));
-    store.register_early_pass(move || Box::new(redundant_static_lifetimes::RedundantStaticLifetimes::new(msrv)));
-    store.register_early_pass(move || Box::new(redundant_field_names::RedundantFieldNames::new(msrv)));
-    store.register_late_pass(move |_| Box::new(checked_conversions::CheckedConversions::new(msrv)));
-    store.register_late_pass(move |_| Box::new(mem_replace::MemReplace::new(msrv)));
-    store.register_late_pass(move |_| Box::new(ranges::Ranges::new(msrv)));
-    store.register_late_pass(move |_| Box::new(from_over_into::FromOverInto::new(msrv)));
-    store.register_late_pass(move |_| Box::new(use_self::UseSelf::new(msrv)));
-    store.register_late_pass(move |_| Box::new(missing_const_for_fn::MissingConstForFn::new(msrv)));
+    store.register_late_pass(move |_| Box::new(manual_let_else::ManualLetElse::new(msrv(), matches_for_let_else)));
+    store.register_early_pass(move || Box::new(manual_non_exhaustive::ManualNonExhaustiveStruct::new(msrv())));
+    store.register_late_pass(move |_| Box::new(manual_non_exhaustive::ManualNonExhaustiveEnum::new(msrv())));
+    store.register_late_pass(move |_| Box::new(manual_strip::ManualStrip::new(msrv())));
+    store.register_early_pass(move || Box::new(redundant_static_lifetimes::RedundantStaticLifetimes::new(msrv())));
+    store.register_early_pass(move || Box::new(redundant_field_names::RedundantFieldNames::new(msrv())));
+    store.register_late_pass(move |_| Box::new(checked_conversions::CheckedConversions::new(msrv())));
+    store.register_late_pass(move |_| Box::new(mem_replace::MemReplace::new(msrv())));
+    store.register_late_pass(move |_| Box::new(ranges::Ranges::new(msrv())));
+    store.register_late_pass(move |_| Box::new(from_over_into::FromOverInto::new(msrv())));
+    store.register_late_pass(move |_| Box::new(use_self::UseSelf::new(msrv())));
+    store.register_late_pass(move |_| Box::new(missing_const_for_fn::MissingConstForFn::new(msrv())));
     store.register_late_pass(move |_| Box::new(needless_question_mark::NeedlessQuestionMark));
-    store.register_late_pass(move |_| Box::new(casts::Casts::new(msrv)));
-    store.register_early_pass(move || Box::new(unnested_or_patterns::UnnestedOrPatterns::new(msrv)));
+    store.register_late_pass(move |_| Box::new(casts::Casts::new(msrv())));
+    store.register_early_pass(move || Box::new(unnested_or_patterns::UnnestedOrPatterns::new(msrv())));
     store.register_late_pass(|_| Box::new(size_of_in_element_count::SizeOfInElementCount));
     store.register_late_pass(|_| Box::new(same_name_method::SameNameMethod));
     let max_suggested_slice_pattern_length = conf.max_suggested_slice_pattern_length;
     store.register_late_pass(move |_| {
         Box::new(index_refutable_slice::IndexRefutableSlice::new(
             max_suggested_slice_pattern_length,
-            msrv,
+            msrv(),
         ))
     });
     store.register_late_pass(|_| Box::<shadow::Shadow>::default());
@@ -648,7 +610,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(borrow_deref_ref::BorrowDerefRef));
     store.register_late_pass(|_| Box::new(no_effect::NoEffect));
     store.register_late_pass(|_| Box::new(temporary_assignment::TemporaryAssignment));
-    store.register_late_pass(move |_| Box::new(transmute::Transmute::new(msrv)));
+    store.register_late_pass(move |_| Box::new(transmute::Transmute::new(msrv())));
     let cognitive_complexity_threshold = conf.cognitive_complexity_threshold;
     store.register_late_pass(move |_| {
         Box::new(cognitive_complexity::CognitiveComplexity::new(
@@ -806,7 +768,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(move |_| Box::new(wildcard_imports::WildcardImports::new(warn_on_all_wildcard_imports)));
     store.register_late_pass(|_| Box::<redundant_pub_crate::RedundantPubCrate>::default());
     store.register_late_pass(|_| Box::new(unnamed_address::UnnamedAddress));
-    store.register_late_pass(move |_| Box::new(dereference::Dereferencing::new(msrv)));
+    store.register_late_pass(move |_| Box::new(dereference::Dereferencing::new(msrv())));
     store.register_late_pass(|_| Box::new(option_if_let_else::OptionIfLetElse));
     store.register_late_pass(|_| Box::new(future_not_send::FutureNotSend));
     store.register_late_pass(|_| Box::new(if_let_mutex::IfLetMutex));
@@ -840,7 +802,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::<vec_init_then_push::VecInitThenPush>::default());
     store.register_late_pass(|_| Box::new(redundant_slicing::RedundantSlicing));
     store.register_late_pass(|_| Box::new(from_str_radix_10::FromStrRadix10));
-    store.register_late_pass(move |_| Box::new(if_then_some_else_none::IfThenSomeElseNone::new(msrv)));
+    store.register_late_pass(move |_| Box::new(if_then_some_else_none::IfThenSomeElseNone::new(msrv())));
     store.register_late_pass(|_| Box::new(bool_assert_comparison::BoolAssertComparison));
     store.register_early_pass(move || Box::new(module_style::ModStyle));
     store.register_late_pass(|_| Box::new(unused_async::UnusedAsync));
@@ -865,14 +827,14 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         ))
     });
     store.register_late_pass(move |_| Box::new(undocumented_unsafe_blocks::UndocumentedUnsafeBlocks));
-    store.register_late_pass(move |_| Box::new(format_args::FormatArgs::new(msrv)));
+    store.register_late_pass(move |_| Box::new(format_args::FormatArgs::new(msrv())));
     store.register_late_pass(|_| Box::new(trailing_empty_array::TrailingEmptyArray));
     store.register_early_pass(|| Box::new(octal_escapes::OctalEscapes));
     store.register_late_pass(|_| Box::new(needless_late_init::NeedlessLateInit));
     store.register_late_pass(|_| Box::new(return_self_not_must_use::ReturnSelfNotMustUse));
     store.register_late_pass(|_| Box::new(init_numbered_fields::NumberedFields));
     store.register_early_pass(|| Box::new(single_char_lifetime_names::SingleCharLifetimeNames));
-    store.register_late_pass(move |_| Box::new(manual_bits::ManualBits::new(msrv)));
+    store.register_late_pass(move |_| Box::new(manual_bits::ManualBits::new(msrv())));
     store.register_late_pass(|_| Box::new(default_union_representation::DefaultUnionRepresentation));
     store.register_late_pass(|_| Box::<only_used_in_recursion::OnlyUsedInRecursion>::default());
     let allow_dbg_in_tests = conf.allow_dbg_in_tests;
@@ -896,20 +858,20 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(rc_clone_in_vec_init::RcCloneInVecInit));
     store.register_early_pass(|| Box::<duplicate_mod::DuplicateMod>::default());
     store.register_early_pass(|| Box::new(unused_rounding::UnusedRounding));
-    store.register_early_pass(move || Box::new(almost_complete_letter_range::AlmostCompleteLetterRange::new(msrv)));
+    store.register_early_pass(move || Box::new(almost_complete_letter_range::AlmostCompleteLetterRange::new(msrv())));
     store.register_late_pass(|_| Box::new(swap_ptr_to_ref::SwapPtrToRef));
     store.register_late_pass(|_| Box::new(mismatching_type_param_order::TypeParamMismatch));
     store.register_late_pass(|_| Box::new(read_zero_byte_vec::ReadZeroByteVec));
     store.register_late_pass(|_| Box::new(default_instead_of_iter_empty::DefaultIterEmpty));
-    store.register_late_pass(move |_| Box::new(manual_rem_euclid::ManualRemEuclid::new(msrv)));
-    store.register_late_pass(move |_| Box::new(manual_retain::ManualRetain::new(msrv)));
+    store.register_late_pass(move |_| Box::new(manual_rem_euclid::ManualRemEuclid::new(msrv())));
+    store.register_late_pass(move |_| Box::new(manual_retain::ManualRetain::new(msrv())));
     let verbose_bit_mask_threshold = conf.verbose_bit_mask_threshold;
     store.register_late_pass(move |_| Box::new(operators::Operators::new(verbose_bit_mask_threshold)));
     store.register_late_pass(|_| Box::new(invalid_utf8_in_unchecked::InvalidUtf8InUnchecked));
     store.register_late_pass(|_| Box::<std_instead_of_core::StdReexports>::default());
-    store.register_late_pass(move |_| Box::new(instant_subtraction::InstantSubtraction::new(msrv)));
+    store.register_late_pass(move |_| Box::new(instant_subtraction::InstantSubtraction::new(msrv())));
     store.register_late_pass(|_| Box::new(partialeq_to_none::PartialeqToNone));
-    store.register_late_pass(move |_| Box::new(manual_clamp::ManualClamp::new(msrv)));
+    store.register_late_pass(move |_| Box::new(manual_clamp::ManualClamp::new(msrv())));
     store.register_late_pass(|_| Box::new(manual_string_new::ManualStringNew));
     store.register_late_pass(|_| Box::new(unused_peekable::UnusedPeekable));
     store.register_early_pass(|| Box::new(multi_assignments::MultiAssignments));
@@ -920,7 +882,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(missing_trait_methods::MissingTraitMethods));
     store.register_late_pass(|_| Box::new(from_raw_with_void_ptr::FromRawWithVoidPtr));
     store.register_late_pass(|_| Box::new(suspicious_xor_used_as_pow::ConfusingXorAndPow));
-    store.register_late_pass(move |_| Box::new(manual_is_ascii_check::ManualIsAsciiCheck::new(msrv)));
+    store.register_late_pass(move |_| Box::new(manual_is_ascii_check::ManualIsAsciiCheck::new(msrv())));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/manual_bits.rs b/clippy_lints/src/manual_bits.rs
index 6655c92b1da..462d73cf0b9 100644
--- a/clippy_lints/src/manual_bits.rs
+++ b/clippy_lints/src/manual_bits.rs
@@ -1,12 +1,12 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::get_parent_expr;
+use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::{get_parent_expr, meets_msrv, msrvs};
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind, GenericArg, QPath};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{self, Ty};
-use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::sym;
 
@@ -34,12 +34,12 @@ declare_clippy_lint! {
 
 #[derive(Clone)]
 pub struct ManualBits {
-    msrv: Option<RustcVersion>,
+    msrv: Msrv,
 }
 
 impl ManualBits {
     #[must_use]
-    pub fn new(msrv: Option<RustcVersion>) -> Self {
+    pub fn new(msrv: Msrv) -> Self {
         Self { msrv }
     }
 }
@@ -48,7 +48,7 @@ impl_lint_pass!(ManualBits => [MANUAL_BITS]);
 
 impl<'tcx> LateLintPass<'tcx> for ManualBits {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if !meets_msrv(self.msrv, msrvs::MANUAL_BITS) {
+        if !self.msrv.meets(msrvs::MANUAL_BITS) {
             return;
         }
 
diff --git a/clippy_lints/src/manual_clamp.rs b/clippy_lints/src/manual_clamp.rs
index 02dc8755dd6..bb6d628af3b 100644
--- a/clippy_lints/src/manual_clamp.rs
+++ b/clippy_lints/src/manual_clamp.rs
@@ -1,28 +1,25 @@
+use clippy_utils::diagnostics::{span_lint_and_then, span_lint_hir_and_then};
+use clippy_utils::higher::If;
+use clippy_utils::msrvs::{self, Msrv};
+use clippy_utils::sugg::Sugg;
+use clippy_utils::ty::implements_trait;
+use clippy_utils::visitors::is_const_evaluatable;
+use clippy_utils::MaybePath;
+use clippy_utils::{
+    eq_expr_value, is_diag_trait_item, is_trait_method, path_res, path_to_local_id, peel_blocks, peel_blocks_with_stmt,
+};
 use itertools::Itertools;
+use rustc_errors::Applicability;
 use rustc_errors::Diagnostic;
 use rustc_hir::{
     def::Res, Arm, BinOpKind, Block, Expr, ExprKind, Guard, HirId, PatKind, PathSegment, PrimTy, QPath, StmtKind,
 };
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::Ty;
-use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::{symbol::sym, Span};
 use std::ops::Deref;
 
-use clippy_utils::{
-    diagnostics::{span_lint_and_then, span_lint_hir_and_then},
-    eq_expr_value,
-    higher::If,
-    is_diag_trait_item, is_trait_method, meets_msrv, msrvs, path_res, path_to_local_id, peel_blocks,
-    peel_blocks_with_stmt,
-    sugg::Sugg,
-    ty::implements_trait,
-    visitors::is_const_evaluatable,
-    MaybePath,
-};
-use rustc_errors::Applicability;
-
 declare_clippy_lint! {
     /// ### What it does
     /// Identifies good opportunities for a clamp function from std or core, and suggests using it.
@@ -87,11 +84,11 @@ declare_clippy_lint! {
 impl_lint_pass!(ManualClamp => [MANUAL_CLAMP]);
 
 pub struct ManualClamp {
-    msrv: Option<RustcVersion>,
+    msrv: Msrv,
 }
 
 impl ManualClamp {
-    pub fn new(msrv: Option<RustcVersion>) -> Self {
+    pub fn new(msrv: Msrv) -> Self {
         Self { msrv }
     }
 }
@@ -114,7 +111,7 @@ struct InputMinMax<'tcx> {
 
 impl<'tcx> LateLintPass<'tcx> for ManualClamp {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
-        if !meets_msrv(self.msrv, msrvs::CLAMP) {
+        if !self.msrv.meets(msrvs::CLAMP) {
             return;
         }
         if !expr.span.from_expansion() {
@@ -130,7 +127,7 @@ impl<'tcx> LateLintPass<'tcx> for ManualClamp {
     }
 
     fn check_block(&mut self, cx: &LateContext<'tcx>, block: &'tcx Block<'tcx>) {
-        if !meets_msrv(self.msrv, msrvs::CLAMP) {
+        if !self.msrv.meets(msrvs::CLAMP) {
             return;
         }
         for suggestion in is_two_if_pattern(cx, block) {
diff --git a/clippy_lints/src/manual_is_ascii_check.rs b/clippy_lints/src/manual_is_ascii_check.rs
index bb8c142f8e4..5ab049d8d13 100644
--- a/clippy_lints/src/manual_is_ascii_check.rs
+++ b/clippy_lints/src/manual_is_ascii_check.rs
@@ -1,15 +1,12 @@
+use clippy_utils::msrvs::{self, Msrv};
+use clippy_utils::{diagnostics::span_lint_and_sugg, in_constant, macros::root_macro_call, source::snippet};
 use rustc_ast::LitKind::{Byte, Char};
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, PatKind, RangeEnd};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::{def_id::DefId, sym};
 
-use clippy_utils::{
-    diagnostics::span_lint_and_sugg, in_constant, macros::root_macro_call, meets_msrv, msrvs, source::snippet,
-};
-
 declare_clippy_lint! {
     /// ### What it does
     /// Suggests to use dedicated built-in methods,
@@ -45,12 +42,12 @@ declare_clippy_lint! {
 impl_lint_pass!(ManualIsAsciiCheck => [MANUAL_IS_ASCII_CHECK]);
 
 pub struct ManualIsAsciiCheck {
-    msrv: Option<RustcVersion>,
+    msrv: Msrv,
 }
 
 impl ManualIsAsciiCheck {
     #[must_use]
-    pub fn new(msrv: Option<RustcVersion>) -> Self {
+    pub fn new(msrv: Msrv) -> Self {
         Self { msrv }
     }
 }
@@ -70,11 +67,11 @@ enum CharRange {
 
 impl<'tcx> LateLintPass<'tcx> for ManualIsAsciiCheck {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if !meets_msrv(self.msrv, msrvs::IS_ASCII_DIGIT) {
+        if !self.msrv.meets(msrvs::IS_ASCII_DIGIT) {
             return;
         }
 
-        if in_constant(cx, expr.hir_id) && !meets_msrv(self.msrv, msrvs::IS_ASCII_DIGIT_CONST) {
+        if in_constant(cx, expr.hir_id) && !self.msrv.meets(msrvs::IS_ASCII_DIGIT_CONST) {
             return;
         }
 
diff --git a/clippy_lints/src/manual_let_else.rs b/clippy_lints/src/manual_let_else.rs
index 1846596fa4c..20f06830952 100644
--- a/clippy_lints/src/manual_let_else.rs
+++ b/clippy_lints/src/manual_let_else.rs
@@ -1,16 +1,16 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::higher::IfLetOrMatch;
+use clippy_utils::msrvs::{self, Msrv};
+use clippy_utils::peel_blocks;
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::visitors::{for_each_expr, Descend};
-use clippy_utils::{meets_msrv, msrvs, peel_blocks};
 use if_chain::if_chain;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, MatchSource, Pat, PatKind, QPath, Stmt, StmtKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::symbol::sym;
 use rustc_span::Span;
@@ -50,13 +50,13 @@ declare_clippy_lint! {
 }
 
 pub struct ManualLetElse {
-    msrv: Option<RustcVersion>,
+    msrv: Msrv,
     matches_behaviour: MatchLintBehaviour,
 }
 
 impl ManualLetElse {
     #[must_use]
-    pub fn new(msrv: Option<RustcVersion>, matches_behaviour: MatchLintBehaviour) -> Self {
+    pub fn new(msrv: Msrv, matches_behaviour: MatchLintBehaviour) -> Self {
         Self {
             msrv,
             matches_behaviour,
@@ -69,7 +69,7 @@ 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 meets_msrv(self.msrv, msrvs::LET_ELSE);
+            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;
diff --git a/clippy_lints/src/manual_non_exhaustive.rs b/clippy_lints/src/manual_non_exhaustive.rs
index 6a42275322b..d32fa1121f4 100644
--- a/clippy_lints/src/manual_non_exhaustive.rs
+++ b/clippy_lints/src/manual_non_exhaustive.rs
@@ -1,6 +1,7 @@
 use clippy_utils::diagnostics::{span_lint_and_then, span_lint_hir_and_then};
+use clippy_utils::is_doc_hidden;
+use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::snippet_opt;
-use clippy_utils::{is_doc_hidden, meets_msrv, msrvs};
 use rustc_ast::ast::{self, VisibilityKind};
 use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Applicability;
@@ -8,7 +9,6 @@ use rustc_hir::def::{CtorKind, CtorOf, DefKind, Res};
 use rustc_hir::{self as hir, Expr, ExprKind, QPath};
 use rustc_lint::{EarlyContext, EarlyLintPass, LateContext, LateLintPass, LintContext};
 use rustc_middle::ty::DefIdTree;
-use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::def_id::{DefId, LocalDefId};
 use rustc_span::{sym, Span};
@@ -63,12 +63,12 @@ declare_clippy_lint! {
 
 #[expect(clippy::module_name_repetitions)]
 pub struct ManualNonExhaustiveStruct {
-    msrv: Option<RustcVersion>,
+    msrv: Msrv,
 }
 
 impl ManualNonExhaustiveStruct {
     #[must_use]
-    pub fn new(msrv: Option<RustcVersion>) -> Self {
+    pub fn new(msrv: Msrv) -> Self {
         Self { msrv }
     }
 }
@@ -77,14 +77,14 @@ impl_lint_pass!(ManualNonExhaustiveStruct => [MANUAL_NON_EXHAUSTIVE]);
 
 #[expect(clippy::module_name_repetitions)]
 pub struct ManualNonExhaustiveEnum {
-    msrv: Option<RustcVersion>,
+    msrv: Msrv,
     constructed_enum_variants: FxHashSet<(DefId, DefId)>,
     potential_enums: Vec<(LocalDefId, LocalDefId, Span, Span)>,
 }
 
 impl ManualNonExhaustiveEnum {
     #[must_use]
-    pub fn new(msrv: Option<RustcVersion>) -> Self {
+    pub fn new(msrv: Msrv) -> Self {
         Self {
             msrv,
             constructed_enum_variants: FxHashSet::default(),
@@ -97,7 +97,7 @@ impl_lint_pass!(ManualNonExhaustiveEnum => [MANUAL_NON_EXHAUSTIVE]);
 
 impl EarlyLintPass for ManualNonExhaustiveStruct {
     fn check_item(&mut self, cx: &EarlyContext<'_>, item: &ast::Item) {
-        if !meets_msrv(self.msrv, msrvs::NON_EXHAUSTIVE) {
+        if !self.msrv.meets(msrvs::NON_EXHAUSTIVE) {
             return;
         }
 
@@ -149,7 +149,7 @@ impl EarlyLintPass for ManualNonExhaustiveStruct {
 
 impl<'tcx> LateLintPass<'tcx> for ManualNonExhaustiveEnum {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) {
-        if !meets_msrv(self.msrv, msrvs::NON_EXHAUSTIVE) {
+        if !self.msrv.meets(msrvs::NON_EXHAUSTIVE) {
             return;
         }
 
diff --git a/clippy_lints/src/manual_rem_euclid.rs b/clippy_lints/src/manual_rem_euclid.rs
index 6f25a2ed8e4..8d447c37150 100644
--- a/clippy_lints/src/manual_rem_euclid.rs
+++ b/clippy_lints/src/manual_rem_euclid.rs
@@ -1,12 +1,12 @@
 use clippy_utils::consts::{constant_full_int, FullInt};
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::{in_constant, meets_msrv, msrvs, path_to_local};
+use clippy_utils::{in_constant, path_to_local};
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind, Node, TyKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 
 declare_clippy_lint! {
@@ -34,12 +34,12 @@ declare_clippy_lint! {
 }
 
 pub struct ManualRemEuclid {
-    msrv: Option<RustcVersion>,
+    msrv: Msrv,
 }
 
 impl ManualRemEuclid {
     #[must_use]
-    pub fn new(msrv: Option<RustcVersion>) -> Self {
+    pub fn new(msrv: Msrv) -> Self {
         Self { msrv }
     }
 }
@@ -48,11 +48,11 @@ impl_lint_pass!(ManualRemEuclid => [MANUAL_REM_EUCLID]);
 
 impl<'tcx> LateLintPass<'tcx> for ManualRemEuclid {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if !meets_msrv(self.msrv, msrvs::REM_EUCLID) {
+        if !self.msrv.meets(msrvs::REM_EUCLID) {
             return;
         }
 
-        if in_constant(cx, expr.hir_id) && !meets_msrv(self.msrv, msrvs::REM_EUCLID_CONST) {
+        if in_constant(cx, expr.hir_id) && !self.msrv.meets(msrvs::REM_EUCLID_CONST) {
             return;
         }
 
diff --git a/clippy_lints/src/manual_retain.rs b/clippy_lints/src/manual_retain.rs
index 3181bc86d17..4907f02b5a3 100644
--- a/clippy_lints/src/manual_retain.rs
+++ b/clippy_lints/src/manual_retain.rs
@@ -1,8 +1,8 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::snippet;
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::{get_parent_expr, match_def_path, paths, SpanlessEq};
-use clippy_utils::{meets_msrv, msrvs};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_hir::def_id::DefId;
@@ -50,12 +50,12 @@ declare_clippy_lint! {
 }
 
 pub struct ManualRetain {
-    msrv: Option<RustcVersion>,
+    msrv: Msrv,
 }
 
 impl ManualRetain {
     #[must_use]
-    pub fn new(msrv: Option<RustcVersion>) -> Self {
+    pub fn new(msrv: Msrv) -> Self {
         Self { msrv }
     }
 }
@@ -71,9 +71,9 @@ impl<'tcx> LateLintPass<'tcx> for ManualRetain {
             && let hir::ExprKind::MethodCall(_, target_expr, [], _) = &collect_expr.kind
             && let Some(collect_def_id) = cx.typeck_results().type_dependent_def_id(collect_expr.hir_id)
             && match_def_path(cx, collect_def_id, &paths::CORE_ITER_COLLECT) {
-            check_into_iter(cx, parent_expr, left_expr, target_expr, self.msrv);
-            check_iter(cx, parent_expr, left_expr, target_expr, self.msrv);
-            check_to_owned(cx, parent_expr, left_expr, target_expr, self.msrv);
+            check_into_iter(cx, parent_expr, left_expr, target_expr, &self.msrv);
+            check_iter(cx, parent_expr, left_expr, target_expr, &self.msrv);
+            check_to_owned(cx, parent_expr, left_expr, target_expr, &self.msrv);
         }
     }
 
@@ -85,7 +85,7 @@ fn check_into_iter(
     parent_expr: &hir::Expr<'_>,
     left_expr: &hir::Expr<'_>,
     target_expr: &hir::Expr<'_>,
-    msrv: Option<RustcVersion>,
+    msrv: &Msrv,
 ) {
     if let hir::ExprKind::MethodCall(_, into_iter_expr, [_], _) = &target_expr.kind
         && let Some(filter_def_id) = cx.typeck_results().type_dependent_def_id(target_expr.hir_id)
@@ -104,7 +104,7 @@ fn check_iter(
     parent_expr: &hir::Expr<'_>,
     left_expr: &hir::Expr<'_>,
     target_expr: &hir::Expr<'_>,
-    msrv: Option<RustcVersion>,
+    msrv: &Msrv,
 ) {
     if let hir::ExprKind::MethodCall(_, filter_expr, [], _) = &target_expr.kind
         && let Some(copied_def_id) = cx.typeck_results().type_dependent_def_id(target_expr.hir_id)
@@ -127,9 +127,9 @@ fn check_to_owned(
     parent_expr: &hir::Expr<'_>,
     left_expr: &hir::Expr<'_>,
     target_expr: &hir::Expr<'_>,
-    msrv: Option<RustcVersion>,
+    msrv: &Msrv,
 ) {
-    if meets_msrv(msrv,  msrvs::STRING_RETAIN)
+    if msrv.meets(msrvs::STRING_RETAIN)
         && let hir::ExprKind::MethodCall(_, filter_expr, [], _) = &target_expr.kind
         && let Some(to_owned_def_id) = cx.typeck_results().type_dependent_def_id(target_expr.hir_id)
         && match_def_path(cx, to_owned_def_id, &paths::TO_OWNED_METHOD)
@@ -215,10 +215,10 @@ fn match_acceptable_def_path(cx: &LateContext<'_>, collect_def_id: DefId) -> boo
         .any(|&method| match_def_path(cx, collect_def_id, method))
 }
 
-fn match_acceptable_type(cx: &LateContext<'_>, expr: &hir::Expr<'_>, msrv: Option<RustcVersion>) -> bool {
+fn match_acceptable_type(cx: &LateContext<'_>, expr: &hir::Expr<'_>, msrv: &Msrv) -> bool {
     let expr_ty = cx.typeck_results().expr_ty(expr).peel_refs();
     ACCEPTABLE_TYPES.iter().any(|(ty, acceptable_msrv)| {
         is_type_diagnostic_item(cx, expr_ty, *ty)
-            && acceptable_msrv.map_or(true, |acceptable_msrv| meets_msrv(msrv, acceptable_msrv))
+            && acceptable_msrv.map_or(true, |acceptable_msrv| msrv.meets(acceptable_msrv))
     })
 }
diff --git a/clippy_lints/src/manual_strip.rs b/clippy_lints/src/manual_strip.rs
index 0976940afac..de166b9765f 100644
--- a/clippy_lints/src/manual_strip.rs
+++ b/clippy_lints/src/manual_strip.rs
@@ -1,8 +1,9 @@
 use clippy_utils::consts::{constant, Constant};
 use clippy_utils::diagnostics::{multispan_sugg, span_lint_and_then};
+use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::snippet;
 use clippy_utils::usage::mutated_variables;
-use clippy_utils::{eq_expr_value, higher, match_def_path, meets_msrv, msrvs, paths};
+use clippy_utils::{eq_expr_value, higher, match_def_path, paths};
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
 use rustc_hir::def::Res;
@@ -11,7 +12,6 @@ use rustc_hir::BinOpKind;
 use rustc_hir::{BorrowKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
-use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::Spanned;
 use rustc_span::Span;
@@ -48,12 +48,12 @@ declare_clippy_lint! {
 }
 
 pub struct ManualStrip {
-    msrv: Option<RustcVersion>,
+    msrv: Msrv,
 }
 
 impl ManualStrip {
     #[must_use]
-    pub fn new(msrv: Option<RustcVersion>) -> Self {
+    pub fn new(msrv: Msrv) -> Self {
         Self { msrv }
     }
 }
@@ -68,7 +68,7 @@ enum StripKind {
 
 impl<'tcx> LateLintPass<'tcx> for ManualStrip {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if !meets_msrv(self.msrv, msrvs::STR_STRIP_PREFIX) {
+        if !self.msrv.meets(msrvs::STR_STRIP_PREFIX) {
             return;
         }
 
diff --git a/clippy_lints/src/matches/mod.rs b/clippy_lints/src/matches/mod.rs
index 7d8171ead89..7b15a307fec 100644
--- a/clippy_lints/src/matches/mod.rs
+++ b/clippy_lints/src/matches/mod.rs
@@ -23,13 +23,13 @@ mod single_match;
 mod try_err;
 mod wild_in_or_pats;
 
+use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::{snippet_opt, walk_span_to_context};
-use clippy_utils::{higher, in_constant, is_span_match, meets_msrv, msrvs};
+use clippy_utils::{higher, in_constant, is_span_match};
 use rustc_hir::{Arm, Expr, ExprKind, Local, MatchSource, Pat};
 use rustc_lexer::{tokenize, TokenKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::{Span, SpanData, SyntaxContext};
 
@@ -930,13 +930,13 @@ declare_clippy_lint! {
 
 #[derive(Default)]
 pub struct Matches {
-    msrv: Option<RustcVersion>,
+    msrv: Msrv,
     infallible_destructuring_match_linted: bool,
 }
 
 impl Matches {
     #[must_use]
-    pub fn new(msrv: Option<RustcVersion>) -> Self {
+    pub fn new(msrv: Msrv) -> Self {
         Self {
             msrv,
             ..Matches::default()
@@ -1000,9 +1000,7 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
 
             if !from_expansion && !contains_cfg_arm(cx, expr, ex, arms) {
                 if source == MatchSource::Normal {
-                    if !(meets_msrv(self.msrv, msrvs::MATCHES_MACRO)
-                        && match_like_matches::check_match(cx, expr, ex, arms))
-                    {
+                    if !(self.msrv.meets(msrvs::MATCHES_MACRO) && match_like_matches::check_match(cx, expr, ex, arms)) {
                         match_same_arms::check(cx, arms);
                     }
 
@@ -1034,7 +1032,7 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
             collapsible_match::check_if_let(cx, if_let.let_pat, if_let.if_then, if_let.if_else);
             if !from_expansion {
                 if let Some(else_expr) = if_let.if_else {
-                    if meets_msrv(self.msrv, msrvs::MATCHES_MACRO) {
+                    if self.msrv.meets(msrvs::MATCHES_MACRO) {
                         match_like_matches::check_if_let(
                             cx,
                             expr,
diff --git a/clippy_lints/src/mem_replace.rs b/clippy_lints/src/mem_replace.rs
index 0c4d9f100f7..35024ec1224 100644
--- a/clippy_lints/src/mem_replace.rs
+++ b/clippy_lints/src/mem_replace.rs
@@ -1,14 +1,14 @@
 use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg, span_lint_and_then};
+use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::{snippet, snippet_with_applicability};
 use clippy_utils::ty::is_non_aggregate_primitive_type;
-use clippy_utils::{is_default_equivalent, is_res_lang_ctor, meets_msrv, msrvs, path_res};
+use clippy_utils::{is_default_equivalent, is_res_lang_ctor, path_res};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::LangItem::OptionNone;
 use rustc_hir::{BorrowKind, Expr, ExprKind, Mutability, QPath};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::lint::in_external_macro;
-use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::Span;
 use rustc_span::symbol::sym;
@@ -227,12 +227,12 @@ fn check_replace_with_default(cx: &LateContext<'_>, src: &Expr<'_>, dest: &Expr<
 }
 
 pub struct MemReplace {
-    msrv: Option<RustcVersion>,
+    msrv: Msrv,
 }
 
 impl MemReplace {
     #[must_use]
-    pub fn new(msrv: Option<RustcVersion>) -> Self {
+    pub fn new(msrv: Msrv) -> Self {
         Self { msrv }
     }
 }
@@ -248,7 +248,7 @@ impl<'tcx> LateLintPass<'tcx> for MemReplace {
             then {
                 check_replace_option_with_none(cx, src, dest, expr.span);
                 check_replace_with_uninit(cx, src, dest, expr.span);
-                if meets_msrv(self.msrv, msrvs::MEM_TAKE) {
+                if self.msrv.meets(msrvs::MEM_TAKE) {
                     check_replace_with_default(cx, src, dest, expr.span);
                 }
             }
diff --git a/clippy_lints/src/methods/cloned_instead_of_copied.rs b/clippy_lints/src/methods/cloned_instead_of_copied.rs
index e9aeab2d5b6..4e6ec61f6a8 100644
--- a/clippy_lints/src/methods/cloned_instead_of_copied.rs
+++ b/clippy_lints/src/methods/cloned_instead_of_copied.rs
@@ -1,25 +1,25 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::is_trait_method;
+use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::ty::{get_iterator_item_ty, is_copy};
-use clippy_utils::{is_trait_method, meets_msrv, msrvs};
 use rustc_errors::Applicability;
 use rustc_hir::Expr;
 use rustc_lint::LateContext;
 use rustc_middle::ty;
-use rustc_semver::RustcVersion;
 use rustc_span::{sym, Span};
 
 use super::CLONED_INSTEAD_OF_COPIED;
 
-pub fn check(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'_>, span: Span, msrv: Option<RustcVersion>) {
+pub fn check(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'_>, span: Span, msrv: &Msrv) {
     let recv_ty = cx.typeck_results().expr_ty_adjusted(recv);
     let inner_ty = match recv_ty.kind() {
         // `Option<T>` -> `T`
         ty::Adt(adt, subst)
-            if cx.tcx.is_diagnostic_item(sym::Option, adt.did()) && meets_msrv(msrv, msrvs::OPTION_COPIED) =>
+            if cx.tcx.is_diagnostic_item(sym::Option, adt.did()) && msrv.meets(msrvs::OPTION_COPIED) =>
         {
             subst.type_at(0)
         },
-        _ if is_trait_method(cx, expr, sym::Iterator) && meets_msrv(msrv, msrvs::ITERATOR_COPIED) => {
+        _ if is_trait_method(cx, expr, sym::Iterator) && msrv.meets(msrvs::ITERATOR_COPIED) => {
             match get_iterator_item_ty(cx, recv_ty) {
                 // <T as Iterator>::Item
                 Some(ty) => ty,
diff --git a/clippy_lints/src/methods/err_expect.rs b/clippy_lints/src/methods/err_expect.rs
index 720d9a68c85..ae03da0d3f9 100644
--- a/clippy_lints/src/methods/err_expect.rs
+++ b/clippy_lints/src/methods/err_expect.rs
@@ -1,27 +1,27 @@
 use super::ERR_EXPECT;
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::ty::has_debug_impl;
-use clippy_utils::{meets_msrv, msrvs, ty::is_type_diagnostic_item};
+use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_errors::Applicability;
 use rustc_lint::LateContext;
 use rustc_middle::ty;
 use rustc_middle::ty::Ty;
-use rustc_semver::RustcVersion;
 use rustc_span::{sym, Span};
 
 pub(super) fn check(
     cx: &LateContext<'_>,
     _expr: &rustc_hir::Expr<'_>,
     recv: &rustc_hir::Expr<'_>,
-    msrv: Option<RustcVersion>,
     expect_span: Span,
     err_span: Span,
+    msrv: &Msrv,
 ) {
     if_chain! {
         if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(recv), sym::Result);
         // Test the version to make sure the lint can be showed (expect_err has been
         // introduced in rust 1.17.0 : https://github.com/rust-lang/rust/pull/38982)
-        if meets_msrv(msrv, msrvs::EXPECT_ERR);
+        if msrv.meets(msrvs::EXPECT_ERR);
 
         // Grabs the `Result<T, E>` type
         let result_type = cx.typeck_results().expr_ty(recv);
diff --git a/clippy_lints/src/methods/filter_map_next.rs b/clippy_lints/src/methods/filter_map_next.rs
index ddf8a1f09b8..175e04f8ac0 100644
--- a/clippy_lints/src/methods/filter_map_next.rs
+++ b/clippy_lints/src/methods/filter_map_next.rs
@@ -1,10 +1,10 @@
 use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg};
+use clippy_utils::is_trait_method;
+use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::snippet;
-use clippy_utils::{is_trait_method, meets_msrv, msrvs};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
-use rustc_semver::RustcVersion;
 use rustc_span::sym;
 
 use super::FILTER_MAP_NEXT;
@@ -14,10 +14,10 @@ pub(super) fn check<'tcx>(
     expr: &'tcx hir::Expr<'_>,
     recv: &'tcx hir::Expr<'_>,
     arg: &'tcx hir::Expr<'_>,
-    msrv: Option<RustcVersion>,
+    msrv: &Msrv,
 ) {
     if is_trait_method(cx, expr, sym::Iterator) {
-        if !meets_msrv(msrv, msrvs::ITERATOR_FIND_MAP) {
+        if !msrv.meets(msrvs::ITERATOR_FIND_MAP) {
             return;
         }
 
diff --git a/clippy_lints/src/methods/is_digit_ascii_radix.rs b/clippy_lints/src/methods/is_digit_ascii_radix.rs
index 304024e8066..301aff5ae6a 100644
--- a/clippy_lints/src/methods/is_digit_ascii_radix.rs
+++ b/clippy_lints/src/methods/is_digit_ascii_radix.rs
@@ -1,23 +1,22 @@
 //! Lint for `c.is_digit(10)`
 
 use super::IS_DIGIT_ASCII_RADIX;
+use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::{
-    consts::constant_full_int, consts::FullInt, diagnostics::span_lint_and_sugg, meets_msrv, msrvs,
-    source::snippet_with_applicability,
+    consts::constant_full_int, consts::FullInt, diagnostics::span_lint_and_sugg, source::snippet_with_applicability,
 };
 use rustc_errors::Applicability;
 use rustc_hir::Expr;
 use rustc_lint::LateContext;
-use rustc_semver::RustcVersion;
 
 pub(super) fn check<'tcx>(
     cx: &LateContext<'tcx>,
     expr: &'tcx Expr<'_>,
     self_arg: &'tcx Expr<'_>,
     radix: &'tcx Expr<'_>,
-    msrv: Option<RustcVersion>,
+    msrv: &Msrv,
 ) {
-    if !meets_msrv(msrv, msrvs::IS_ASCII_DIGIT) {
+    if !msrv.meets(msrvs::IS_ASCII_DIGIT) {
         return;
     }
 
diff --git a/clippy_lints/src/methods/map_clone.rs b/clippy_lints/src/methods/map_clone.rs
index 6bc783c6d50..52cc1e0464b 100644
--- a/clippy_lints/src/methods/map_clone.rs
+++ b/clippy_lints/src/methods/map_clone.rs
@@ -1,7 +1,8 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::{is_copy, is_type_diagnostic_item};
-use clippy_utils::{is_diag_trait_item, meets_msrv, msrvs, peel_blocks};
+use clippy_utils::{is_diag_trait_item, peel_blocks};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
@@ -9,19 +10,12 @@ use rustc_lint::LateContext;
 use rustc_middle::mir::Mutability;
 use rustc_middle::ty;
 use rustc_middle::ty::adjustment::Adjust;
-use rustc_semver::RustcVersion;
 use rustc_span::symbol::Ident;
 use rustc_span::{sym, Span};
 
 use super::MAP_CLONE;
 
-pub(super) fn check(
-    cx: &LateContext<'_>,
-    e: &hir::Expr<'_>,
-    recv: &hir::Expr<'_>,
-    arg: &hir::Expr<'_>,
-    msrv: Option<RustcVersion>,
-) {
+pub(super) fn check(cx: &LateContext<'_>, e: &hir::Expr<'_>, recv: &hir::Expr<'_>, arg: &hir::Expr<'_>, msrv: &Msrv) {
     if_chain! {
         if let Some(method_id) = cx.typeck_results().type_dependent_def_id(e.hir_id);
         if cx.tcx.impl_of_method(method_id)
@@ -97,10 +91,10 @@ fn lint_needless_cloning(cx: &LateContext<'_>, root: Span, receiver: Span) {
     );
 }
 
-fn lint_explicit_closure(cx: &LateContext<'_>, replace: Span, root: Span, is_copy: bool, msrv: Option<RustcVersion>) {
+fn lint_explicit_closure(cx: &LateContext<'_>, replace: Span, root: Span, is_copy: bool, msrv: &Msrv) {
     let mut applicability = Applicability::MachineApplicable;
 
-    let (message, sugg_method) = if is_copy && meets_msrv(msrv, msrvs::ITERATOR_COPIED) {
+    let (message, sugg_method) = if is_copy && msrv.meets(msrvs::ITERATOR_COPIED) {
         ("you are using an explicit closure for copying elements", "copied")
     } else {
         ("you are using an explicit closure for cloning elements", "cloned")
diff --git a/clippy_lints/src/methods/map_unwrap_or.rs b/clippy_lints/src/methods/map_unwrap_or.rs
index 74fdead216b..3122f72ee91 100644
--- a/clippy_lints/src/methods/map_unwrap_or.rs
+++ b/clippy_lints/src/methods/map_unwrap_or.rs
@@ -1,12 +1,11 @@
 use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg};
+use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::snippet;
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::usage::mutated_variables;
-use clippy_utils::{meets_msrv, msrvs};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
-use rustc_semver::RustcVersion;
 use rustc_span::symbol::sym;
 
 use super::MAP_UNWRAP_OR;
@@ -19,13 +18,13 @@ pub(super) fn check<'tcx>(
     recv: &'tcx hir::Expr<'_>,
     map_arg: &'tcx hir::Expr<'_>,
     unwrap_arg: &'tcx hir::Expr<'_>,
-    msrv: Option<RustcVersion>,
+    msrv: &Msrv,
 ) -> bool {
     // lint if the caller of `map()` is an `Option`
     let is_option = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(recv), sym::Option);
     let is_result = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(recv), sym::Result);
 
-    if is_result && !meets_msrv(msrv, msrvs::RESULT_MAP_OR_ELSE) {
+    if is_result && !msrv.meets(msrvs::RESULT_MAP_OR_ELSE) {
         return false;
     }
 
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index acb3b20a61b..c5451195727 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -104,8 +104,9 @@ mod zst_offset;
 use bind_instead_of_map::BindInsteadOfMap;
 use clippy_utils::consts::{constant, Constant};
 use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
+use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::ty::{contains_ty_adt_constructor_opaque, implements_trait, is_copy, is_type_diagnostic_item};
-use clippy_utils::{contains_return, is_bool, is_trait_method, iter_input_pats, meets_msrv, msrvs, return_ty};
+use clippy_utils::{contains_return, is_bool, is_trait_method, iter_input_pats, return_ty};
 use if_chain::if_chain;
 use rustc_hir as hir;
 use rustc_hir::{Expr, ExprKind, TraitItem, TraitItemKind};
@@ -113,7 +114,6 @@ use rustc_hir_analysis::hir_ty_to_ty;
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::{self, TraitRef, Ty};
-use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::{sym, Span};
 
@@ -3163,7 +3163,7 @@ declare_clippy_lint! {
 
 pub struct Methods {
     avoid_breaking_exported_api: bool,
-    msrv: Option<RustcVersion>,
+    msrv: Msrv,
     allow_expect_in_tests: bool,
     allow_unwrap_in_tests: bool,
 }
@@ -3172,7 +3172,7 @@ impl Methods {
     #[must_use]
     pub fn new(
         avoid_breaking_exported_api: bool,
-        msrv: Option<RustcVersion>,
+        msrv: Msrv,
         allow_expect_in_tests: bool,
         allow_unwrap_in_tests: bool,
     ) -> Self {
@@ -3325,7 +3325,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
                 single_char_add_str::check(cx, expr, receiver, args);
                 into_iter_on_ref::check(cx, expr, method_span, method_call.ident.name, receiver);
                 single_char_pattern::check(cx, expr, method_call.ident.name, receiver, args);
-                unnecessary_to_owned::check(cx, expr, method_call.ident.name, receiver, args, self.msrv);
+                unnecessary_to_owned::check(cx, expr, method_call.ident.name, receiver, args, &self.msrv);
             },
             hir::ExprKind::Binary(op, lhs, rhs) if op.node == hir::BinOpKind::Eq || op.node == hir::BinOpKind::Ne => {
                 let mut info = BinaryExprInfo {
@@ -3501,7 +3501,7 @@ impl Methods {
                 ("as_mut", []) => useless_asref::check(cx, expr, "as_mut", recv),
                 ("as_ref", []) => useless_asref::check(cx, expr, "as_ref", recv),
                 ("assume_init", []) => uninit_assumed_init::check(cx, expr, recv),
-                ("cloned", []) => cloned_instead_of_copied::check(cx, expr, recv, span, self.msrv),
+                ("cloned", []) => cloned_instead_of_copied::check(cx, expr, recv, span, &self.msrv),
                 ("collect", []) if is_trait_method(cx, expr, sym::Iterator) => {
                     needless_collect::check(cx, span, expr, recv, call_span);
                     match method_call(recv) {
@@ -3512,7 +3512,7 @@ impl Methods {
                             map_collect_result_unit::check(cx, expr, m_recv, m_arg);
                         },
                         Some(("take", take_self_arg, [take_arg], _, _)) => {
-                            if meets_msrv(self.msrv, msrvs::STR_REPEAT) {
+                            if self.msrv.meets(msrvs::STR_REPEAT) {
                                 manual_str_repeat::check(cx, expr, recv, take_self_arg, take_arg);
                             }
                         },
@@ -3539,7 +3539,7 @@ impl Methods {
                 },
                 ("expect", [_]) => match method_call(recv) {
                     Some(("ok", recv, [], _, _)) => ok_expect::check(cx, expr, recv),
-                    Some(("err", recv, [], err_span, _)) => err_expect::check(cx, expr, recv, self.msrv, span, err_span),
+                    Some(("err", recv, [], err_span, _)) => err_expect::check(cx, expr, recv, span, err_span, &self.msrv),
                     _ => expect_used::check(cx, expr, recv, false, self.allow_expect_in_tests),
                 },
                 ("expect_err", [_]) => expect_used::check(cx, expr, recv, true, self.allow_expect_in_tests),
@@ -3578,7 +3578,7 @@ impl Methods {
                     unit_hash::check(cx, expr, recv, arg);
                 },
                 ("is_file", []) => filetype_is_file::check(cx, expr, recv),
-                ("is_digit", [radix]) => is_digit_ascii_radix::check(cx, expr, recv, radix, self.msrv),
+                ("is_digit", [radix]) => is_digit_ascii_radix::check(cx, expr, recv, radix, &self.msrv),
                 ("is_none", []) => check_is_some_is_none(cx, expr, recv, false),
                 ("is_some", []) => check_is_some_is_none(cx, expr, recv, true),
                 ("iter" | "iter_mut" | "into_iter", []) => {
@@ -3601,7 +3601,7 @@ impl Methods {
                 },
                 (name @ ("map" | "map_err"), [m_arg]) => {
                     if name == "map" {
-                        map_clone::check(cx, expr, recv, m_arg, self.msrv);
+                        map_clone::check(cx, expr, recv, m_arg, &self.msrv);
                         if let Some((map_name @ ("iter" | "into_iter"), recv2, _, _, _)) = method_call(recv) {
                             iter_kv_map::check(cx, map_name, expr, recv2, m_arg);
                         }
@@ -3610,8 +3610,8 @@ impl Methods {
                     }
                     if let Some((name, recv2, args, span2,_)) = method_call(recv) {
                         match (name, args) {
-                            ("as_mut", []) => option_as_ref_deref::check(cx, expr, recv2, m_arg, true, self.msrv),
-                            ("as_ref", []) => option_as_ref_deref::check(cx, expr, recv2, m_arg, false, self.msrv),
+                            ("as_mut", []) => option_as_ref_deref::check(cx, expr, recv2, m_arg, true, &self.msrv),
+                            ("as_ref", []) => option_as_ref_deref::check(cx, expr, recv2, m_arg, false, &self.msrv),
                             ("filter", [f_arg]) => {
                                 filter_map::check(cx, expr, recv2, f_arg, span2, recv, m_arg, span, false);
                             },
@@ -3632,7 +3632,7 @@ impl Methods {
                         match (name2, args2) {
                             ("cloned", []) => iter_overeager_cloned::check(cx, expr, recv, recv2, false, false),
                             ("filter", [arg]) => filter_next::check(cx, expr, recv2, arg),
-                            ("filter_map", [arg]) => filter_map_next::check(cx, expr, recv2, arg, self.msrv),
+                            ("filter_map", [arg]) => filter_map_next::check(cx, expr, recv2, arg, &self.msrv),
                             ("iter", []) => iter_next_slice::check(cx, expr, recv2),
                             ("skip", [arg]) => iter_skip_next::check(cx, expr, recv2, arg),
                             ("skip_while", [_]) => skip_while_next::check(cx, expr),
@@ -3680,10 +3680,10 @@ impl Methods {
                     vec_resize_to_zero::check(cx, expr, count_arg, default_arg, span);
                 },
                 ("seek", [arg]) => {
-                    if meets_msrv(self.msrv, msrvs::SEEK_FROM_CURRENT) {
+                    if self.msrv.meets(msrvs::SEEK_FROM_CURRENT) {
                         seek_from_current::check(cx, expr, recv, arg);
                     }
-                    if meets_msrv(self.msrv, msrvs::SEEK_REWIND) {
+                    if self.msrv.meets(msrvs::SEEK_REWIND) {
                         seek_to_start_instead_of_rewind::check(cx, expr, recv, arg, span);
                     }
                 },
@@ -3699,7 +3699,7 @@ impl Methods {
                 ("splitn" | "rsplitn", [count_arg, pat_arg]) => {
                     if let Some((Constant::Int(count), _)) = constant(cx, cx.typeck_results(), count_arg) {
                         suspicious_splitn::check(cx, name, expr, recv, count);
-                        str_splitn::check(cx, name, expr, recv, pat_arg, count, self.msrv);
+                        str_splitn::check(cx, name, expr, recv, pat_arg, count, &self.msrv);
                     }
                 },
                 ("splitn_mut" | "rsplitn_mut", [count_arg, _]) => {
@@ -3717,7 +3717,7 @@ impl Methods {
                 },
                 ("take", []) => needless_option_take::check(cx, expr, recv),
                 ("then", [arg]) => {
-                    if !meets_msrv(self.msrv, msrvs::BOOL_THEN_SOME) {
+                    if !self.msrv.meets(msrvs::BOOL_THEN_SOME) {
                         return;
                     }
                     unnecessary_lazy_eval::check(cx, expr, recv, arg, "then_some");
@@ -3760,7 +3760,7 @@ impl Methods {
                 },
                 ("unwrap_or_else", [u_arg]) => match method_call(recv) {
                     Some(("map", recv, [map_arg], _, _))
-                        if map_unwrap_or::check(cx, expr, recv, map_arg, u_arg, self.msrv) => {},
+                        if map_unwrap_or::check(cx, expr, recv, map_arg, u_arg, &self.msrv) => {},
                     _ => {
                         unwrap_or_else_default::check(cx, expr, recv, u_arg);
                         unnecessary_lazy_eval::check(cx, expr, recv, u_arg, "unwrap_or");
diff --git a/clippy_lints/src/methods/option_as_ref_deref.rs b/clippy_lints/src/methods/option_as_ref_deref.rs
index e6eb64bcbde..3e33f919337 100644
--- a/clippy_lints/src/methods/option_as_ref_deref.rs
+++ b/clippy_lints/src/methods/option_as_ref_deref.rs
@@ -1,13 +1,13 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::snippet;
 use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{match_def_path, meets_msrv, msrvs, path_to_local_id, paths, peel_blocks};
+use clippy_utils::{match_def_path, path_to_local_id, paths, peel_blocks};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
 use rustc_middle::ty;
-use rustc_semver::RustcVersion;
 use rustc_span::sym;
 
 use super::OPTION_AS_REF_DEREF;
@@ -19,9 +19,9 @@ pub(super) fn check(
     as_ref_recv: &hir::Expr<'_>,
     map_arg: &hir::Expr<'_>,
     is_mut: bool,
-    msrv: Option<RustcVersion>,
+    msrv: &Msrv,
 ) {
-    if !meets_msrv(msrv, msrvs::OPTION_AS_DEREF) {
+    if !msrv.meets(msrvs::OPTION_AS_DEREF) {
         return;
     }
 
diff --git a/clippy_lints/src/methods/str_splitn.rs b/clippy_lints/src/methods/str_splitn.rs
index 1acac59144c..3c01ce1fecd 100644
--- a/clippy_lints/src/methods/str_splitn.rs
+++ b/clippy_lints/src/methods/str_splitn.rs
@@ -1,9 +1,10 @@
 use clippy_utils::consts::{constant, Constant};
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
+use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::snippet_with_context;
 use clippy_utils::usage::local_used_after_expr;
 use clippy_utils::visitors::{for_each_expr_with_closures, Descend};
-use clippy_utils::{is_diag_item_method, match_def_path, meets_msrv, msrvs, path_to_local_id, paths};
+use clippy_utils::{is_diag_item_method, match_def_path, path_to_local_id, paths};
 use core::ops::ControlFlow;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
@@ -12,7 +13,6 @@ use rustc_hir::{
 };
 use rustc_lint::LateContext;
 use rustc_middle::ty;
-use rustc_semver::RustcVersion;
 use rustc_span::{sym, Span, Symbol, SyntaxContext};
 
 use super::{MANUAL_SPLIT_ONCE, NEEDLESS_SPLITN};
@@ -24,7 +24,7 @@ pub(super) fn check(
     self_arg: &Expr<'_>,
     pat_arg: &Expr<'_>,
     count: u128,
-    msrv: Option<RustcVersion>,
+    msrv: &Msrv,
 ) {
     if count < 2 || !cx.typeck_results().expr_ty_adjusted(self_arg).peel_refs().is_str() {
         return;
@@ -34,7 +34,7 @@ pub(super) fn check(
         IterUsageKind::Nth(n) => count > n + 1,
         IterUsageKind::NextTuple => count > 2,
     };
-    let manual = count == 2 && meets_msrv(msrv, msrvs::STR_SPLIT_ONCE);
+    let manual = count == 2 && msrv.meets(msrvs::STR_SPLIT_ONCE);
 
     match parse_iter_usage(cx, expr.span.ctxt(), cx.tcx.hir().parent_iter(expr.hir_id)) {
         Some(usage) if needless(usage.kind) => lint_needless(cx, method_name, expr, self_arg, pat_arg),
diff --git a/clippy_lints/src/methods/unnecessary_to_owned.rs b/clippy_lints/src/methods/unnecessary_to_owned.rs
index 4b4f2f47b1d..21d1df4d0c2 100644
--- a/clippy_lints/src/methods/unnecessary_to_owned.rs
+++ b/clippy_lints/src/methods/unnecessary_to_owned.rs
@@ -1,11 +1,11 @@
 use super::implicit_clone::is_clone_like;
 use super::unnecessary_iter_cloned::{self, is_into_iter};
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::{get_associated_type, get_iterator_item_ty, implements_trait, is_copy, peel_mid_ty_refs};
 use clippy_utils::visitors::find_all_ret_expressions;
 use clippy_utils::{fn_def_id, get_parent_expr, is_diag_item_method, is_diag_trait_item, return_ty};
-use clippy_utils::{meets_msrv, msrvs};
 use rustc_errors::Applicability;
 use rustc_hir::{def_id::DefId, BorrowKind, Expr, ExprKind, ItemKind, LangItem, Node};
 use rustc_hir_analysis::check::{FnCtxt, Inherited};
@@ -16,7 +16,6 @@ use rustc_middle::ty::adjustment::{Adjust, Adjustment, OverloadedDeref};
 use rustc_middle::ty::subst::{GenericArg, GenericArgKind, SubstsRef};
 use rustc_middle::ty::EarlyBinder;
 use rustc_middle::ty::{self, ParamTy, PredicateKind, ProjectionPredicate, TraitPredicate, Ty};
-use rustc_semver::RustcVersion;
 use rustc_span::{sym, Symbol};
 use rustc_trait_selection::traits::{query::evaluate_obligation::InferCtxtExt as _, Obligation, ObligationCause};
 use std::cmp::max;
@@ -29,7 +28,7 @@ pub fn check<'tcx>(
     method_name: Symbol,
     receiver: &'tcx Expr<'_>,
     args: &'tcx [Expr<'_>],
-    msrv: Option<RustcVersion>,
+    msrv: &Msrv,
 ) {
     if_chain! {
         if let Some(method_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
@@ -200,7 +199,7 @@ fn check_into_iter_call_arg(
     expr: &Expr<'_>,
     method_name: Symbol,
     receiver: &Expr<'_>,
-    msrv: Option<RustcVersion>,
+    msrv: &Msrv,
 ) -> bool {
     if_chain! {
         if let Some(parent) = get_parent_expr(cx, expr);
@@ -215,7 +214,7 @@ fn check_into_iter_call_arg(
             if unnecessary_iter_cloned::check_for_loop_iter(cx, parent, method_name, receiver, true) {
                 return true;
             }
-            let cloned_or_copied = if is_copy(cx, item_ty) && meets_msrv(msrv, msrvs::ITERATOR_COPIED) {
+            let cloned_or_copied = if is_copy(cx, item_ty) && msrv.meets(msrvs::ITERATOR_COPIED) {
                 "copied"
             } else {
                 "cloned"
diff --git a/clippy_lints/src/missing_const_for_fn.rs b/clippy_lints/src/missing_const_for_fn.rs
index 71cc0d0a81c..5bc04bc17fb 100644
--- a/clippy_lints/src/missing_const_for_fn.rs
+++ b/clippy_lints/src/missing_const_for_fn.rs
@@ -1,9 +1,8 @@
 use clippy_utils::diagnostics::span_lint;
+use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::qualify_min_const_fn::is_min_const_fn;
 use clippy_utils::ty::has_drop;
-use clippy_utils::{
-    fn_has_unsatisfiable_preds, is_entrypoint_fn, is_from_proc_macro, meets_msrv, msrvs, trait_ref_of_method,
-};
+use clippy_utils::{fn_has_unsatisfiable_preds, is_entrypoint_fn, is_from_proc_macro, trait_ref_of_method};
 use rustc_hir as hir;
 use rustc_hir::def_id::CRATE_DEF_ID;
 use rustc_hir::intravisit::FnKind;
@@ -11,7 +10,6 @@ use rustc_hir::{Body, Constness, FnDecl, GenericParamKind, HirId};
 use rustc_hir_analysis::hir_ty_to_ty;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::lint::in_external_macro;
-use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::Span;
 
@@ -75,12 +73,12 @@ declare_clippy_lint! {
 impl_lint_pass!(MissingConstForFn => [MISSING_CONST_FOR_FN]);
 
 pub struct MissingConstForFn {
-    msrv: Option<RustcVersion>,
+    msrv: Msrv,
 }
 
 impl MissingConstForFn {
     #[must_use]
-    pub fn new(msrv: Option<RustcVersion>) -> Self {
+    pub fn new(msrv: Msrv) -> Self {
         Self { msrv }
     }
 }
@@ -95,7 +93,7 @@ impl<'tcx> LateLintPass<'tcx> for MissingConstForFn {
         span: Span,
         hir_id: HirId,
     ) {
-        if !meets_msrv(self.msrv, msrvs::CONST_IF_MATCH) {
+        if !self.msrv.meets(msrvs::CONST_IF_MATCH) {
             return;
         }
 
@@ -152,7 +150,7 @@ impl<'tcx> LateLintPass<'tcx> for MissingConstForFn {
 
         let mir = cx.tcx.optimized_mir(def_id);
 
-        if let Err((span, err)) = is_min_const_fn(cx.tcx, mir, self.msrv) {
+        if let Err((span, err)) = is_min_const_fn(cx.tcx, mir, &self.msrv) {
             if cx.tcx.is_const_fn_raw(def_id.to_def_id()) {
                 cx.tcx.sess.span_err(span, err.as_ref());
             }
diff --git a/clippy_lints/src/ranges.rs b/clippy_lints/src/ranges.rs
index c6fbb5e805a..0a1b9d173cf 100644
--- a/clippy_lints/src/ranges.rs
+++ b/clippy_lints/src/ranges.rs
@@ -1,16 +1,16 @@
 use clippy_utils::consts::{constant, Constant};
 use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::higher;
+use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::{snippet, snippet_opt, snippet_with_applicability};
 use clippy_utils::sugg::Sugg;
-use clippy_utils::{get_parent_expr, in_constant, is_integer_const, meets_msrv, msrvs, path_to_local};
+use clippy_utils::{get_parent_expr, in_constant, is_integer_const, path_to_local};
 use if_chain::if_chain;
 use rustc_ast::ast::RangeLimits;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind, HirId};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
-use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::{Span, Spanned};
 use std::cmp::Ordering;
@@ -161,12 +161,12 @@ declare_clippy_lint! {
 }
 
 pub struct Ranges {
-    msrv: Option<RustcVersion>,
+    msrv: Msrv,
 }
 
 impl Ranges {
     #[must_use]
-    pub fn new(msrv: Option<RustcVersion>) -> Self {
+    pub fn new(msrv: Msrv) -> Self {
         Self { msrv }
     }
 }
@@ -181,7 +181,7 @@ impl_lint_pass!(Ranges => [
 impl<'tcx> LateLintPass<'tcx> for Ranges {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if let ExprKind::Binary(ref op, l, r) = expr.kind {
-            if meets_msrv(self.msrv, msrvs::RANGE_CONTAINS) {
+            if self.msrv.meets(msrvs::RANGE_CONTAINS) {
                 check_possible_range_contains(cx, op.node, l, r, expr, expr.span);
             }
         }
diff --git a/clippy_lints/src/redundant_field_names.rs b/clippy_lints/src/redundant_field_names.rs
index 40b03068f6c..61bff4a0e38 100644
--- a/clippy_lints/src/redundant_field_names.rs
+++ b/clippy_lints/src/redundant_field_names.rs
@@ -1,10 +1,9 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::{meets_msrv, msrvs};
+use clippy_utils::msrvs::{self, Msrv};
 use rustc_ast::ast::{Expr, ExprKind};
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 
 declare_clippy_lint! {
@@ -37,12 +36,12 @@ declare_clippy_lint! {
 }
 
 pub struct RedundantFieldNames {
-    msrv: Option<RustcVersion>,
+    msrv: Msrv,
 }
 
 impl RedundantFieldNames {
     #[must_use]
-    pub fn new(msrv: Option<RustcVersion>) -> Self {
+    pub fn new(msrv: Msrv) -> Self {
         Self { msrv }
     }
 }
@@ -51,7 +50,7 @@ impl_lint_pass!(RedundantFieldNames => [REDUNDANT_FIELD_NAMES]);
 
 impl EarlyLintPass for RedundantFieldNames {
     fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
-        if !meets_msrv(self.msrv, msrvs::FIELD_INIT_SHORTHAND) {
+        if !self.msrv.meets(msrvs::FIELD_INIT_SHORTHAND) {
             return;
         }
 
diff --git a/clippy_lints/src/redundant_static_lifetimes.rs b/clippy_lints/src/redundant_static_lifetimes.rs
index 60ba62c4a43..3aa2490bc44 100644
--- a/clippy_lints/src/redundant_static_lifetimes.rs
+++ b/clippy_lints/src/redundant_static_lifetimes.rs
@@ -1,10 +1,9 @@
 use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::snippet;
-use clippy_utils::{meets_msrv, msrvs};
 use rustc_ast::ast::{Item, ItemKind, Ty, TyKind};
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass};
-use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 
 declare_clippy_lint! {
@@ -34,12 +33,12 @@ declare_clippy_lint! {
 }
 
 pub struct RedundantStaticLifetimes {
-    msrv: Option<RustcVersion>,
+    msrv: Msrv,
 }
 
 impl RedundantStaticLifetimes {
     #[must_use]
-    pub fn new(msrv: Option<RustcVersion>) -> Self {
+    pub fn new(msrv: Msrv) -> Self {
         Self { msrv }
     }
 }
@@ -96,7 +95,7 @@ impl RedundantStaticLifetimes {
 
 impl EarlyLintPass for RedundantStaticLifetimes {
     fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {
-        if !meets_msrv(self.msrv, msrvs::STATIC_IN_CONST) {
+        if !self.msrv.meets(msrvs::STATIC_IN_CONST) {
             return;
         }
 
diff --git a/clippy_lints/src/transmute/mod.rs b/clippy_lints/src/transmute/mod.rs
index 424a6e9264e..83e651aba8e 100644
--- a/clippy_lints/src/transmute/mod.rs
+++ b/clippy_lints/src/transmute/mod.rs
@@ -16,10 +16,10 @@ mod utils;
 mod wrong_transmute;
 
 use clippy_utils::in_constant;
+use clippy_utils::msrvs::Msrv;
 use if_chain::if_chain;
 use rustc_hir::{Expr, ExprKind, QPath};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::symbol::sym;
 
@@ -410,7 +410,7 @@ declare_clippy_lint! {
 }
 
 pub struct Transmute {
-    msrv: Option<RustcVersion>,
+    msrv: Msrv,
 }
 impl_lint_pass!(Transmute => [
     CROSSPOINTER_TRANSMUTE,
@@ -431,7 +431,7 @@ impl_lint_pass!(Transmute => [
 ]);
 impl Transmute {
     #[must_use]
-    pub fn new(msrv: Option<RustcVersion>) -> Self {
+    pub fn new(msrv: Msrv) -> Self {
         Self { msrv }
     }
 }
@@ -461,7 +461,7 @@ impl<'tcx> LateLintPass<'tcx> for Transmute {
                 let linted = wrong_transmute::check(cx, e, from_ty, to_ty)
                     | crosspointer_transmute::check(cx, e, from_ty, to_ty)
                     | transmuting_null::check(cx, e, arg, to_ty)
-                    | transmute_ptr_to_ref::check(cx, e, from_ty, to_ty, arg, path, self.msrv)
+                    | transmute_ptr_to_ref::check(cx, e, from_ty, to_ty, arg, path, &self.msrv)
                     | transmute_int_to_char::check(cx, e, from_ty, to_ty, arg, const_context)
                     | transmute_ref_to_ref::check(cx, e, from_ty, to_ty, arg, const_context)
                     | transmute_ptr_to_ptr::check(cx, e, from_ty, to_ty, arg)
diff --git a/clippy_lints/src/transmute/transmute_ptr_to_ref.rs b/clippy_lints/src/transmute/transmute_ptr_to_ref.rs
index 12d0b866e1c..3dde4eee671 100644
--- a/clippy_lints/src/transmute/transmute_ptr_to_ref.rs
+++ b/clippy_lints/src/transmute/transmute_ptr_to_ref.rs
@@ -1,12 +1,12 @@
 use super::TRANSMUTE_PTR_TO_REF;
 use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::{meets_msrv, msrvs, sugg};
+use clippy_utils::sugg;
 use rustc_errors::Applicability;
 use rustc_hir::{self as hir, Expr, GenericArg, Mutability, Path, TyKind};
 use rustc_lint::LateContext;
 use rustc_middle::ty::{self, Ty, TypeVisitable};
-use rustc_semver::RustcVersion;
 
 /// Checks for `transmute_ptr_to_ref` lint.
 /// Returns `true` if it's triggered, otherwise returns `false`.
@@ -17,7 +17,7 @@ pub(super) fn check<'tcx>(
     to_ty: Ty<'tcx>,
     arg: &'tcx Expr<'_>,
     path: &'tcx Path<'_>,
-    msrv: Option<RustcVersion>,
+    msrv: &Msrv,
 ) -> bool {
     match (&from_ty.kind(), &to_ty.kind()) {
         (ty::RawPtr(from_ptr_ty), ty::Ref(_, to_ref_ty, mutbl)) => {
@@ -37,7 +37,7 @@ pub(super) fn check<'tcx>(
 
                     let sugg = if let Some(ty) = get_explicit_type(path) {
                         let ty_snip = snippet_with_applicability(cx, ty.span, "..", &mut app);
-                        if meets_msrv(msrv, msrvs::POINTER_CAST) {
+                        if msrv.meets(msrvs::POINTER_CAST) {
                             format!("{deref}{}.cast::<{ty_snip}>()", arg.maybe_par())
                         } else if from_ptr_ty.has_erased_regions() {
                             sugg::make_unop(deref, arg.as_ty(format!("{cast} () as {cast} {ty_snip}"))).to_string()
@@ -46,7 +46,7 @@ pub(super) fn check<'tcx>(
                         }
                     } else if from_ptr_ty.ty == *to_ref_ty {
                         if from_ptr_ty.has_erased_regions() {
-                            if meets_msrv(msrv, msrvs::POINTER_CAST) {
+                            if msrv.meets(msrvs::POINTER_CAST) {
                                 format!("{deref}{}.cast::<{to_ref_ty}>()", arg.maybe_par())
                             } else {
                                 sugg::make_unop(deref, arg.as_ty(format!("{cast} () as {cast} {to_ref_ty}")))
diff --git a/clippy_lints/src/unnested_or_patterns.rs b/clippy_lints/src/unnested_or_patterns.rs
index b305dae7608..2c2730267db 100644
--- a/clippy_lints/src/unnested_or_patterns.rs
+++ b/clippy_lints/src/unnested_or_patterns.rs
@@ -2,14 +2,14 @@
 
 use clippy_utils::ast_utils::{eq_field_pat, eq_id, eq_maybe_qself, eq_pat, eq_path};
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::{meets_msrv, msrvs, over};
+use clippy_utils::msrvs::{self, Msrv};
+use clippy_utils::over;
 use rustc_ast::mut_visit::*;
 use rustc_ast::ptr::P;
 use rustc_ast::{self as ast, Mutability, Pat, PatKind, PatKind::*, DUMMY_NODE_ID};
 use rustc_ast_pretty::pprust;
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass};
-use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::DUMMY_SP;
 
@@ -45,14 +45,13 @@ declare_clippy_lint! {
     "unnested or-patterns, e.g., `Foo(Bar) | Foo(Baz) instead of `Foo(Bar | Baz)`"
 }
 
-#[derive(Clone, Copy)]
 pub struct UnnestedOrPatterns {
-    msrv: Option<RustcVersion>,
+    msrv: Msrv,
 }
 
 impl UnnestedOrPatterns {
     #[must_use]
-    pub fn new(msrv: Option<RustcVersion>) -> Self {
+    pub fn new(msrv: Msrv) -> Self {
         Self { msrv }
     }
 }
@@ -61,13 +60,13 @@ impl_lint_pass!(UnnestedOrPatterns => [UNNESTED_OR_PATTERNS]);
 
 impl EarlyLintPass for UnnestedOrPatterns {
     fn check_arm(&mut self, cx: &EarlyContext<'_>, a: &ast::Arm) {
-        if meets_msrv(self.msrv, msrvs::OR_PATTERNS) {
+        if self.msrv.meets(msrvs::OR_PATTERNS) {
             lint_unnested_or_patterns(cx, &a.pat);
         }
     }
 
     fn check_expr(&mut self, cx: &EarlyContext<'_>, e: &ast::Expr) {
-        if meets_msrv(self.msrv, msrvs::OR_PATTERNS) {
+        if self.msrv.meets(msrvs::OR_PATTERNS) {
             if let ast::ExprKind::Let(pat, _, _) = &e.kind {
                 lint_unnested_or_patterns(cx, pat);
             }
@@ -75,13 +74,13 @@ impl EarlyLintPass for UnnestedOrPatterns {
     }
 
     fn check_param(&mut self, cx: &EarlyContext<'_>, p: &ast::Param) {
-        if meets_msrv(self.msrv, msrvs::OR_PATTERNS) {
+        if self.msrv.meets(msrvs::OR_PATTERNS) {
             lint_unnested_or_patterns(cx, &p.pat);
         }
     }
 
     fn check_local(&mut self, cx: &EarlyContext<'_>, l: &ast::Local) {
-        if meets_msrv(self.msrv, msrvs::OR_PATTERNS) {
+        if self.msrv.meets(msrvs::OR_PATTERNS) {
             lint_unnested_or_patterns(cx, &l.pat);
         }
     }
diff --git a/clippy_lints/src/use_self.rs b/clippy_lints/src/use_self.rs
index 464ffdc0a2a..06975443d8f 100644
--- a/clippy_lints/src/use_self.rs
+++ b/clippy_lints/src/use_self.rs
@@ -1,6 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::is_from_proc_macro;
+use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::ty::same_type_and_consts;
-use clippy_utils::{is_from_proc_macro, meets_msrv, msrvs};
 use if_chain::if_chain;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Applicability;
@@ -14,7 +15,6 @@ use rustc_hir::{
 };
 use rustc_hir_analysis::hir_ty_to_ty;
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::Span;
 
@@ -57,13 +57,13 @@ declare_clippy_lint! {
 
 #[derive(Default)]
 pub struct UseSelf {
-    msrv: Option<RustcVersion>,
+    msrv: Msrv,
     stack: Vec<StackItem>,
 }
 
 impl UseSelf {
     #[must_use]
-    pub fn new(msrv: Option<RustcVersion>) -> Self {
+    pub fn new(msrv: Msrv) -> Self {
         Self {
             msrv,
             ..Self::default()
@@ -199,7 +199,7 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
     fn check_ty(&mut self, cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>) {
         if_chain! {
             if !hir_ty.span.from_expansion();
-            if meets_msrv(self.msrv, msrvs::TYPE_ALIAS_ENUM_VARIANTS);
+            if self.msrv.meets(msrvs::TYPE_ALIAS_ENUM_VARIANTS);
             if let Some(&StackItem::Check {
                 impl_id,
                 in_body,
@@ -228,7 +228,7 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
         if_chain! {
             if !expr.span.from_expansion();
-            if meets_msrv(self.msrv, msrvs::TYPE_ALIAS_ENUM_VARIANTS);
+            if self.msrv.meets(msrvs::TYPE_ALIAS_ENUM_VARIANTS);
             if let Some(&StackItem::Check { impl_id, .. }) = self.stack.last();
             if cx.typeck_results().expr_ty(expr) == cx.tcx.type_of(impl_id);
             then {} else { return; }
@@ -248,7 +248,7 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
     fn check_pat(&mut self, cx: &LateContext<'_>, pat: &Pat<'_>) {
         if_chain! {
             if !pat.span.from_expansion();
-            if meets_msrv(self.msrv, msrvs::TYPE_ALIAS_ENUM_VARIANTS);
+            if self.msrv.meets(msrvs::TYPE_ALIAS_ENUM_VARIANTS);
             if let Some(&StackItem::Check { impl_id, .. }) = self.stack.last();
             // get the path from the pattern
             if let PatKind::Path(QPath::Resolved(_, path))
diff --git a/clippy_lints/src/utils/internal_lints/msrv_attr_impl.rs b/clippy_lints/src/utils/internal_lints/msrv_attr_impl.rs
index 1e994e3f2b1..9876a8a765c 100644
--- a/clippy_lints/src/utils/internal_lints/msrv_attr_impl.rs
+++ b/clippy_lints/src/utils/internal_lints/msrv_attr_impl.rs
@@ -41,7 +41,7 @@ impl LateLintPass<'_> for MsrvAttrImpl {
                     .type_of(f.did)
                     .walk()
                     .filter(|t| matches!(t.unpack(), GenericArgKind::Type(_)))
-                    .any(|t| match_type(cx, t.expect_ty(), &paths::RUSTC_VERSION))
+                    .any(|t| match_type(cx, t.expect_ty(), &paths::MSRV))
             });
             if !items.iter().any(|item| item.ident.name == sym!(enter_lint_attrs));
             then {
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index b0063758dce..86ee172cb28 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -105,8 +105,6 @@ use rustc_middle::ty::{
     layout::IntegerExt, BorrowKind, ClosureKind, DefIdTree, Ty, TyCtxt, TypeAndMut, TypeVisitable, UpvarCapture,
 };
 use rustc_middle::ty::{FloatTy, IntTy, UintTy};
-use rustc_semver::RustcVersion;
-use rustc_session::Session;
 use rustc_span::hygiene::{ExpnKind, MacroKind};
 use rustc_span::source_map::SourceMap;
 use rustc_span::sym;
@@ -118,36 +116,17 @@ use crate::consts::{constant, Constant};
 use crate::ty::{can_partially_move_ty, expr_sig, is_copy, is_recursively_primitive_type, ty_is_fn_once_param};
 use crate::visitors::for_each_expr;
 
-pub fn parse_msrv(msrv: &str, sess: Option<&Session>, span: Option<Span>) -> Option<RustcVersion> {
-    if let Ok(version) = RustcVersion::parse(msrv) {
-        return Some(version);
-    } else if let Some(sess) = sess {
-        if let Some(span) = span {
-            sess.span_err(span, format!("`{msrv}` is not a valid Rust version"));
-        }
-    }
-    None
-}
-
-pub fn meets_msrv(msrv: Option<RustcVersion>, lint_msrv: RustcVersion) -> bool {
-    msrv.map_or(true, |msrv| msrv.meets(lint_msrv))
-}
-
 #[macro_export]
 macro_rules! extract_msrv_attr {
     ($context:ident) => {
         fn enter_lint_attrs(&mut self, cx: &rustc_lint::$context<'_>, attrs: &[rustc_ast::ast::Attribute]) {
             let sess = rustc_lint::LintContext::sess(cx);
-            match $crate::get_unique_inner_attr(sess, attrs, "msrv") {
-                Some(msrv_attr) => {
-                    if let Some(msrv) = msrv_attr.value_str() {
-                        self.msrv = $crate::parse_msrv(&msrv.to_string(), Some(sess), Some(msrv_attr.span));
-                    } else {
-                        sess.span_err(msrv_attr.span, "bad clippy attribute");
-                    }
-                },
-                _ => (),
-            }
+            self.msrv.enter_lint_attrs(sess, attrs);
+        }
+
+        fn exit_lint_attrs(&mut self, cx: &rustc_lint::$context<'_>, attrs: &[rustc_ast::ast::Attribute]) {
+            let sess = rustc_lint::LintContext::sess(cx);
+            self.msrv.exit_lint_attrs(sess, attrs);
         }
     };
 }
diff --git a/clippy_utils/src/msrvs.rs b/clippy_utils/src/msrvs.rs
index 79b19e6fb3e..2c9f75736e5 100644
--- a/clippy_utils/src/msrvs.rs
+++ b/clippy_utils/src/msrvs.rs
@@ -1,4 +1,11 @@
+use std::sync::OnceLock;
+
+use rustc_ast::Attribute;
 use rustc_semver::RustcVersion;
+use rustc_session::Session;
+use rustc_span::Span;
+
+use crate::attrs::get_unique_inner_attr;
 
 macro_rules! msrv_aliases {
     ($($major:literal,$minor:literal,$patch:literal {
@@ -40,3 +47,97 @@ msrv_aliases! {
     1,16,0 { STR_REPEAT }
     1,55,0 { SEEK_REWIND }
 }
+
+fn parse_msrv(msrv: &str, sess: Option<&Session>, span: Option<Span>) -> Option<RustcVersion> {
+    if let Ok(version) = RustcVersion::parse(msrv) {
+        return Some(version);
+    } else if let Some(sess) = sess {
+        if let Some(span) = span {
+            sess.span_err(span, format!("`{msrv}` is not a valid Rust version"));
+        }
+    }
+    None
+}
+
+/// Tracks the current MSRV from `clippy.toml`, `Cargo.toml` or set via `#[clippy::msrv]`
+#[derive(Debug, Clone, Default)]
+pub struct Msrv {
+    stack: Vec<RustcVersion>,
+}
+
+impl Msrv {
+    fn new(initial: Option<RustcVersion>) -> Self {
+        Self {
+            stack: Vec::from_iter(initial),
+        }
+    }
+
+    fn read_inner(conf_msrv: &Option<String>, sess: &Session) -> Self {
+        let cargo_msrv = std::env::var("CARGO_PKG_RUST_VERSION")
+            .ok()
+            .and_then(|v| parse_msrv(&v, None, None));
+        let clippy_msrv = conf_msrv.as_ref().and_then(|s| {
+            parse_msrv(s, None, None).or_else(|| {
+                sess.err(format!(
+                    "error reading Clippy's configuration file. `{s}` is not a valid Rust version"
+                ));
+                None
+            })
+        });
+
+        // if both files have an msrv, let's compare them and emit a warning if they differ
+        if let Some(cargo_msrv) = cargo_msrv
+            && let Some(clippy_msrv) = clippy_msrv
+            && clippy_msrv != cargo_msrv
+        {
+            sess.warn(format!(
+                "the MSRV in `clippy.toml` and `Cargo.toml` differ; using `{clippy_msrv}` from `clippy.toml`"
+            ));
+        }
+
+        Self::new(clippy_msrv.or(cargo_msrv))
+    }
+
+    /// Set the initial MSRV from the Clippy config file or from Cargo due to the `rust-version`
+    /// field in `Cargo.toml`
+    ///
+    /// Returns a `&'static Msrv` as `Copy` types are more easily passed to the
+    /// `register_{late,early}_pass` callbacks
+    pub fn read(conf_msrv: &Option<String>, sess: &Session) -> &'static Self {
+        static PARSED: OnceLock<Msrv> = OnceLock::new();
+
+        PARSED.get_or_init(|| Self::read_inner(conf_msrv, sess))
+    }
+
+    pub fn current(&self) -> Option<RustcVersion> {
+        self.stack.last().copied()
+    }
+
+    pub fn meets(&self, required: RustcVersion) -> bool {
+        self.current().map_or(true, |version| version.meets(required))
+    }
+
+    fn parse_attr(sess: &Session, attrs: &[Attribute]) -> Option<RustcVersion> {
+        if let Some(msrv_attr) = get_unique_inner_attr(sess, attrs, "msrv") {
+            if let Some(msrv) = msrv_attr.value_str() {
+                return parse_msrv(&msrv.to_string(), Some(sess), Some(msrv_attr.span));
+            }
+
+            sess.span_err(msrv_attr.span, "bad clippy attribute");
+        }
+
+        None
+    }
+
+    pub fn enter_lint_attrs(&mut self, sess: &Session, attrs: &[Attribute]) {
+        if let Some(version) = Self::parse_attr(sess, attrs) {
+            self.stack.push(version);
+        }
+    }
+
+    pub fn exit_lint_attrs(&mut self, sess: &Session, attrs: &[Attribute]) {
+        if Self::parse_attr(sess, attrs).is_some() {
+            self.stack.pop();
+        }
+    }
+}
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index 6c09c146082..3cf8cb76651 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -60,6 +60,8 @@ pub const LATE_LINT_PASS: [&str; 3] = ["rustc_lint", "passes", "LateLintPass"];
 #[cfg(feature = "internal")]
 pub const LINT: [&str; 2] = ["rustc_lint_defs", "Lint"];
 pub const MEM_SWAP: [&str; 3] = ["core", "mem", "swap"];
+#[cfg(feature = "internal")]
+pub const MSRV: [&str; 3] = ["clippy_utils", "msrvs", "Msrv"];
 pub const OPEN_OPTIONS: [&str; 3] = ["std", "fs", "OpenOptions"];
 pub const OS_STRING_AS_OS_STR: [&str; 5] = ["std", "ffi", "os_str", "OsString", "as_os_str"];
 pub const OS_STR_TO_OS_STRING: [&str; 5] = ["std", "ffi", "os_str", "OsStr", "to_os_string"];
@@ -101,8 +103,6 @@ pub const REGEX_BYTES_NEW: [&str; 4] = ["regex", "re_bytes", "Regex", "new"];
 pub const REGEX_BYTES_SET_NEW: [&str; 5] = ["regex", "re_set", "bytes", "RegexSet", "new"];
 pub const REGEX_NEW: [&str; 4] = ["regex", "re_unicode", "Regex", "new"];
 pub const REGEX_SET_NEW: [&str; 5] = ["regex", "re_set", "unicode", "RegexSet", "new"];
-#[cfg(feature = "internal")]
-pub const RUSTC_VERSION: [&str; 2] = ["rustc_semver", "RustcVersion"];
 pub const SERDE_DESERIALIZE: [&str; 3] = ["serde", "de", "Deserialize"];
 pub const SERDE_DE_VISITOR: [&str; 3] = ["serde", "de", "Visitor"];
 pub const SLICE_FROM_RAW_PARTS: [&str; 4] = ["core", "slice", "raw", "from_raw_parts"];
diff --git a/clippy_utils/src/qualify_min_const_fn.rs b/clippy_utils/src/qualify_min_const_fn.rs
index 65722f142aa..0def1245615 100644
--- a/clippy_utils/src/qualify_min_const_fn.rs
+++ b/clippy_utils/src/qualify_min_const_fn.rs
@@ -3,6 +3,7 @@
 // of terminologies might not be relevant in the context of Clippy. Note that its behavior might
 // differ from the time of `rustc` even if the name stays the same.
 
+use crate::msrvs::Msrv;
 use rustc_hir as hir;
 use rustc_hir::def_id::DefId;
 use rustc_middle::mir::{
@@ -18,7 +19,7 @@ use std::borrow::Cow;
 
 type McfResult = Result<(), (Span, Cow<'static, str>)>;
 
-pub fn is_min_const_fn<'tcx>(tcx: TyCtxt<'tcx>, body: &Body<'tcx>, msrv: Option<RustcVersion>) -> McfResult {
+pub fn is_min_const_fn<'tcx>(tcx: TyCtxt<'tcx>, body: &Body<'tcx>, msrv: &Msrv) -> McfResult {
     let def_id = body.source.def_id();
     let mut current = def_id;
     loop {
@@ -280,7 +281,7 @@ fn check_terminator<'tcx>(
     tcx: TyCtxt<'tcx>,
     body: &Body<'tcx>,
     terminator: &Terminator<'tcx>,
-    msrv: Option<RustcVersion>,
+    msrv: &Msrv,
 ) -> McfResult {
     let span = terminator.source_info.span;
     match &terminator.kind {
@@ -364,7 +365,7 @@ fn check_terminator<'tcx>(
     }
 }
 
-fn is_const_fn(tcx: TyCtxt<'_>, def_id: DefId, msrv: Option<RustcVersion>) -> bool {
+fn is_const_fn(tcx: TyCtxt<'_>, def_id: DefId, msrv: &Msrv) -> bool {
     tcx.is_const_fn(def_id)
         && tcx.lookup_const_stability(def_id).map_or(true, |const_stab| {
             if let rustc_attr::StabilityLevel::Stable { since, .. } = const_stab.level {
@@ -383,15 +384,12 @@ fn is_const_fn(tcx: TyCtxt<'_>, def_id: DefId, msrv: Option<RustcVersion>) -> bo
 
                 let since = rustc_span::Symbol::intern(short_version);
 
-                crate::meets_msrv(
-                    msrv,
-                    RustcVersion::parse(since.as_str()).unwrap_or_else(|err| {
-                        panic!("`rustc_attr::StabilityLevel::Stable::since` is ill-formatted: `{since}`, {err:?}")
-                    }),
-                )
+                msrv.meets(RustcVersion::parse(since.as_str()).unwrap_or_else(|err| {
+                    panic!("`rustc_attr::StabilityLevel::Stable::since` is ill-formatted: `{since}`, {err:?}")
+                }))
             } else {
                 // Unstable const fn with the feature enabled.
-                msrv.is_none()
+                msrv.current().is_none()
             }
         })
 }
diff --git a/tests/ui-internal/invalid_msrv_attr_impl.fixed b/tests/ui-internal/invalid_msrv_attr_impl.fixed
index 900a8fffd40..08634063a57 100644
--- a/tests/ui-internal/invalid_msrv_attr_impl.fixed
+++ b/tests/ui-internal/invalid_msrv_attr_impl.fixed
@@ -11,9 +11,9 @@ extern crate rustc_middle;
 #[macro_use]
 extern crate rustc_session;
 use clippy_utils::extract_msrv_attr;
+use clippy_utils::msrvs::Msrv;
 use rustc_hir::Expr;
 use rustc_lint::{EarlyContext, EarlyLintPass, LateContext, LateLintPass};
-use rustc_semver::RustcVersion;
 
 declare_lint! {
     pub TEST_LINT,
@@ -22,7 +22,7 @@ declare_lint! {
 }
 
 struct Pass {
-    msrv: Option<RustcVersion>,
+    msrv: Msrv,
 }
 
 impl_lint_pass!(Pass => [TEST_LINT]);
diff --git a/tests/ui-internal/invalid_msrv_attr_impl.rs b/tests/ui-internal/invalid_msrv_attr_impl.rs
index 4bc8164db67..f8af77e6d39 100644
--- a/tests/ui-internal/invalid_msrv_attr_impl.rs
+++ b/tests/ui-internal/invalid_msrv_attr_impl.rs
@@ -11,9 +11,9 @@ extern crate rustc_middle;
 #[macro_use]
 extern crate rustc_session;
 use clippy_utils::extract_msrv_attr;
+use clippy_utils::msrvs::Msrv;
 use rustc_hir::Expr;
 use rustc_lint::{EarlyContext, EarlyLintPass, LateContext, LateLintPass};
-use rustc_semver::RustcVersion;
 
 declare_lint! {
     pub TEST_LINT,
@@ -22,7 +22,7 @@ declare_lint! {
 }
 
 struct Pass {
-    msrv: Option<RustcVersion>,
+    msrv: Msrv,
 }
 
 impl_lint_pass!(Pass => [TEST_LINT]);
diff --git a/tests/ui/min_rust_version_attr.rs b/tests/ui/min_rust_version_attr.rs
index cd148063bf0..28ab132394b 100644
--- a/tests/ui/min_rust_version_attr.rs
+++ b/tests/ui/min_rust_version_attr.rs
@@ -27,3 +27,26 @@ fn no_patch_meets() {
     #![clippy::msrv = "1.43"]
     let log2_10 = 3.321928094887362;
 }
+
+// https://github.com/rust-lang/rust-clippy/issues/6920
+fn scoping() {
+    mod m {
+        #![clippy::msrv = "1.42.0"]
+    }
+
+    // Should warn
+    let log2_10 = 3.321928094887362;
+
+    mod a {
+        #![clippy::msrv = "1.42.0"]
+
+        fn should_warn() {
+            #![clippy::msrv = "1.43.0"]
+            let log2_10 = 3.321928094887362;
+        }
+
+        fn should_not_warn() {
+            let log2_10 = 3.321928094887362;
+        }
+    }
+}
diff --git a/tests/ui/min_rust_version_attr.stderr b/tests/ui/min_rust_version_attr.stderr
index 68aa5874819..6174443372f 100644
--- a/tests/ui/min_rust_version_attr.stderr
+++ b/tests/ui/min_rust_version_attr.stderr
@@ -23,5 +23,21 @@ LL |     let log2_10 = 3.321928094887362;
    |
    = help: consider using the constant directly
 
-error: aborting due to 3 previous errors
+error: approximate value of `f{32, 64}::consts::LOG2_10` found
+  --> $DIR/min_rust_version_attr.rs:38:19
+   |
+LL |     let log2_10 = 3.321928094887362;
+   |                   ^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using the constant directly
+
+error: approximate value of `f{32, 64}::consts::LOG2_10` found
+  --> $DIR/min_rust_version_attr.rs:45:27
+   |
+LL |             let log2_10 = 3.321928094887362;
+   |                           ^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using the constant directly
+
+error: aborting due to 5 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 2cda73f617028712c097124f8f38ace4660c066d Mon Sep 17 00:00:00 2001
From: Samuel Moelius <sam@moeli.us>
Date: Tue, 22 Nov 2022 13:47:38 -0500
Subject: Use `walk_generic_arg`

---
 clippy_lints/src/lifetimes.rs | 11 ++---------
 1 file changed, 2 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lifetimes.rs b/clippy_lints/src/lifetimes.rs
index d9acaa99c6d..897428797e5 100644
--- a/clippy_lints/src/lifetimes.rs
+++ b/clippy_lints/src/lifetimes.rs
@@ -3,7 +3,7 @@ use clippy_utils::trait_ref_of_method;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_hir::intravisit::nested_filter::{self as hir_nested_filter, NestedFilter};
 use rustc_hir::intravisit::{
-    walk_fn_decl, walk_generic_param, walk_generics, walk_impl_item_ref, walk_item, walk_param_bound,
+    walk_fn_decl, walk_generic_arg, walk_generic_param, walk_generics, walk_impl_item_ref, walk_item, walk_param_bound,
     walk_poly_trait_ref, walk_trait_ref, walk_ty, Visitor,
 };
 use rustc_hir::lang_items;
@@ -503,14 +503,7 @@ impl<'a, 'tcx> Visitor<'tcx> for RefVisitor<'a, 'tcx> {
         {
             self.lifetime_generic_arg_spans.entry(def_id).or_insert(l.span);
         }
-        // Replace with `walk_generic_arg` if/when https://github.com/rust-lang/rust/pull/103692 lands.
-        // walk_generic_arg(self, generic_arg);
-        match generic_arg {
-            GenericArg::Lifetime(lt) => self.visit_lifetime(lt),
-            GenericArg::Type(ty) => self.visit_ty(ty),
-            GenericArg::Const(ct) => self.visit_anon_const(&ct.value),
-            GenericArg::Infer(inf) => self.visit_infer(inf),
-        }
+        walk_generic_arg(self, generic_arg);
     }
 }
 
-- 
cgit 1.4.1-3-g733a5


From a116b9bdba6c3c00f4544a937af690bd462ca428 Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukastw97@gmail.com>
Date: Mon, 14 Nov 2022 13:42:47 +0100
Subject: Lint unnecessary safety comments on items

---
 CHANGELOG.md                                   |   1 +
 clippy_lints/src/declared_lints.rs             |   1 +
 clippy_lints/src/undocumented_unsafe_blocks.rs | 240 +++++++++++++++++++------
 tests/ui/undocumented_unsafe_blocks.rs         |   2 +-
 tests/ui/undocumented_unsafe_blocks.stderr     |  15 +-
 5 files changed, 200 insertions(+), 59 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5b6b12c623a..23912bb3ed6 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4451,6 +4451,7 @@ Released 2018-09-13
 [`unnecessary_mut_passed`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_mut_passed
 [`unnecessary_operation`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_operation
 [`unnecessary_owned_empty_strings`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_owned_empty_strings
+[`unnecessary_safety_comment`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_safety_comment
 [`unnecessary_safety_doc`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_safety_doc
 [`unnecessary_self_imports`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_self_imports
 [`unnecessary_sort_by`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_sort_by
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index eb3210946f1..e4d76f07d6b 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -584,6 +584,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::types::TYPE_COMPLEXITY_INFO,
     crate::types::VEC_BOX_INFO,
     crate::undocumented_unsafe_blocks::UNDOCUMENTED_UNSAFE_BLOCKS_INFO,
+    crate::undocumented_unsafe_blocks::UNNECESSARY_SAFETY_COMMENT_INFO,
     crate::unicode::INVISIBLE_CHARACTERS_INFO,
     crate::unicode::NON_ASCII_LITERAL_INFO,
     crate::unicode::UNICODE_NOT_NFC_INFO,
diff --git a/clippy_lints/src/undocumented_unsafe_blocks.rs b/clippy_lints/src/undocumented_unsafe_blocks.rs
index e8f15a44473..57ee2735aa0 100644
--- a/clippy_lints/src/undocumented_unsafe_blocks.rs
+++ b/clippy_lints/src/undocumented_unsafe_blocks.rs
@@ -59,8 +59,36 @@ declare_clippy_lint! {
     restriction,
     "creating an unsafe block without explaining why it is safe"
 }
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `// SAFETY: ` comments on safe code.
+    ///
+    /// ### Why is this bad?
+    /// Safe code has no safety requirements, so there is no need to
+    /// describe safety invariants.
+    ///
+    /// ### Example
+    /// ```rust
+    /// use std::ptr::NonNull;
+    /// let a = &mut 42;
+    ///
+    /// // SAFETY: references are guaranteed to be non-null.
+    /// let ptr = NonNull::new(a).unwrap();
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// use std::ptr::NonNull;
+    /// let a = &mut 42;
+    ///
+    /// let ptr = NonNull::new(a).unwrap();
+    /// ```
+    #[clippy::version = "1.66.0"]
+    pub UNNECESSARY_SAFETY_COMMENT,
+    restriction,
+    "creating an unsafe block without explaining why it is safe"
+}
 
-declare_lint_pass!(UndocumentedUnsafeBlocks => [UNDOCUMENTED_UNSAFE_BLOCKS]);
+declare_lint_pass!(UndocumentedUnsafeBlocks => [UNDOCUMENTED_UNSAFE_BLOCKS, UNNECESSARY_SAFETY_COMMENT]);
 
 impl LateLintPass<'_> for UndocumentedUnsafeBlocks {
     fn check_block(&mut self, cx: &LateContext<'_>, block: &'_ Block<'_>) {
@@ -90,28 +118,95 @@ impl LateLintPass<'_> for UndocumentedUnsafeBlocks {
     }
 
     fn check_item(&mut self, cx: &LateContext<'_>, item: &hir::Item<'_>) {
-        if let hir::ItemKind::Impl(imple) = item.kind
-            && imple.unsafety == hir::Unsafety::Unsafe
-            && !in_external_macro(cx.tcx.sess, item.span)
-            && !is_lint_allowed(cx, UNDOCUMENTED_UNSAFE_BLOCKS, item.hir_id())
-            && !is_unsafe_from_proc_macro(cx, item.span)
-            && !item_has_safety_comment(cx, item)
-        {
+        if in_external_macro(cx.tcx.sess, item.span) {
+            return;
+        }
+
+        let mk_spans = |pos: BytePos| {
             let source_map = cx.tcx.sess.source_map();
+            let span = Span::new(pos, pos, SyntaxContext::root(), None);
+            let help_span = source_map.span_extend_to_next_char(span, '\n', true);
             let span = if source_map.is_multiline(item.span) {
                 source_map.span_until_char(item.span, '\n')
             } else {
                 item.span
             };
+            (span, help_span)
+        };
 
-            span_lint_and_help(
-                cx,
-                UNDOCUMENTED_UNSAFE_BLOCKS,
-                span,
-                "unsafe impl missing a safety comment",
-                None,
-                "consider adding a safety comment on the preceding line",
-            );
+        let item_has_safety_comment = item_has_safety_comment(cx, item);
+        match (&item.kind, item_has_safety_comment) {
+            (hir::ItemKind::Impl(impl_), HasSafetyComment::No) if impl_.unsafety == hir::Unsafety::Unsafe => {
+                if !is_lint_allowed(cx, UNDOCUMENTED_UNSAFE_BLOCKS, item.hir_id())
+                    && !is_unsafe_from_proc_macro(cx, item.span)
+                {
+                    let source_map = cx.tcx.sess.source_map();
+                    let span = if source_map.is_multiline(item.span) {
+                        source_map.span_until_char(item.span, '\n')
+                    } else {
+                        item.span
+                    };
+
+                    span_lint_and_help(
+                        cx,
+                        UNDOCUMENTED_UNSAFE_BLOCKS,
+                        span,
+                        "unsafe impl missing a safety comment",
+                        None,
+                        "consider adding a safety comment on the preceding line",
+                    );
+                }
+            },
+            (hir::ItemKind::Impl(impl_), HasSafetyComment::Yes(pos)) if impl_.unsafety == hir::Unsafety::Normal => {
+                if !is_lint_allowed(cx, UNNECESSARY_SAFETY_COMMENT, item.hir_id()) {
+                    let (span, help_span) = mk_spans(pos);
+
+                    span_lint_and_help(
+                        cx,
+                        UNNECESSARY_SAFETY_COMMENT,
+                        span,
+                        "impl has unnecessary safety comment",
+                        Some(help_span),
+                        "consider removing the safety comment",
+                    );
+                }
+            },
+            (hir::ItemKind::Impl(_), _) => {},
+            (&hir::ItemKind::Const(.., body) | &hir::ItemKind::Static(.., body), HasSafetyComment::Yes(pos)) => {
+                if !is_lint_allowed(cx, UNNECESSARY_SAFETY_COMMENT, body.hir_id) {
+                    let body = cx.tcx.hir().body(body);
+                    if !matches!(
+                        body.value.kind, hir::ExprKind::Block(block, _)
+                        if block.rules == BlockCheckMode::UnsafeBlock(UnsafeSource::UserProvided)
+                    ) {
+                        let (span, help_span) = mk_spans(pos);
+
+                        span_lint_and_help(
+                            cx,
+                            UNNECESSARY_SAFETY_COMMENT,
+                            span,
+                            &format!("{} has unnecessary safety comment", item.kind.descr()),
+                            Some(help_span),
+                            "consider removing the safety comment",
+                        );
+                    }
+                }
+            },
+            (_, HasSafetyComment::Yes(pos)) => {
+                if !is_lint_allowed(cx, UNNECESSARY_SAFETY_COMMENT, item.hir_id()) {
+                    let (span, help_span) = mk_spans(pos);
+
+                    span_lint_and_help(
+                        cx,
+                        UNNECESSARY_SAFETY_COMMENT,
+                        span,
+                        &format!("{} has unnecessary safety comment", item.kind.descr()),
+                        Some(help_span),
+                        "consider removing the safety comment",
+                    );
+                }
+            },
+            _ => (),
         }
     }
 }
@@ -170,28 +265,38 @@ fn block_has_safety_comment(cx: &LateContext<'_>, span: Span) -> bool {
     // won't work. This is to avoid dealing with where such a comment should be place relative to
     // attributes and doc comments.
 
-    span_from_macro_expansion_has_safety_comment(cx, span) || span_in_body_has_safety_comment(cx, span)
+    matches!(
+        span_from_macro_expansion_has_safety_comment(cx, span),
+        HasSafetyComment::Yes(_)
+    ) || span_in_body_has_safety_comment(cx, span)
+}
+
+enum HasSafetyComment {
+    Yes(BytePos),
+    No,
+    Maybe,
 }
 
 /// Checks if the lines immediately preceding the item contain a safety comment.
 #[allow(clippy::collapsible_match)]
-fn item_has_safety_comment(cx: &LateContext<'_>, item: &hir::Item<'_>) -> bool {
-    if span_from_macro_expansion_has_safety_comment(cx, item.span) {
-        return true;
+fn item_has_safety_comment(cx: &LateContext<'_>, item: &hir::Item<'_>) -> HasSafetyComment {
+    match span_from_macro_expansion_has_safety_comment(cx, item.span) {
+        HasSafetyComment::Maybe => (),
+        has_safety_comment => return has_safety_comment,
     }
 
     if item.span.ctxt() == SyntaxContext::root() {
         if let Some(parent_node) = get_parent_node(cx.tcx, item.hir_id()) {
             let comment_start = match parent_node {
                 Node::Crate(parent_mod) => {
-                    comment_start_before_impl_in_mod(cx, parent_mod, parent_mod.spans.inner_span, item)
+                    comment_start_before_item_in_mod(cx, parent_mod, parent_mod.spans.inner_span, item)
                 },
                 Node::Item(parent_item) => {
                     if let ItemKind::Mod(parent_mod) = &parent_item.kind {
-                        comment_start_before_impl_in_mod(cx, parent_mod, parent_item.span, item)
+                        comment_start_before_item_in_mod(cx, parent_mod, parent_item.span, item)
                     } else {
                         // Doesn't support impls in this position. Pretend a comment was found.
-                        return true;
+                        return HasSafetyComment::Maybe;
                     }
                 },
                 Node::Stmt(stmt) => {
@@ -200,17 +305,17 @@ fn item_has_safety_comment(cx: &LateContext<'_>, item: &hir::Item<'_>) -> bool {
                             Node::Block(block) => walk_span_to_context(block.span, SyntaxContext::root()).map(Span::lo),
                             _ => {
                                 // Doesn't support impls in this position. Pretend a comment was found.
-                                return true;
+                                return HasSafetyComment::Maybe;
                             },
                         }
                     } else {
                         // Problem getting the parent node. Pretend a comment was found.
-                        return true;
+                        return HasSafetyComment::Maybe;
                     }
                 },
                 _ => {
                     // Doesn't support impls in this position. Pretend a comment was found.
-                    return true;
+                    return HasSafetyComment::Maybe;
                 },
             };
 
@@ -222,33 +327,40 @@ fn item_has_safety_comment(cx: &LateContext<'_>, item: &hir::Item<'_>) -> bool {
                 && let Some(src) = unsafe_line.sf.src.as_deref()
             {
                 unsafe_line.sf.lines(|lines| {
-                    comment_start_line.line < unsafe_line.line && text_has_safety_comment(
-                        src,
-                        &lines[comment_start_line.line + 1..=unsafe_line.line],
-                        unsafe_line.sf.start_pos.to_usize(),
-                    )
+                    if comment_start_line.line >= unsafe_line.line {
+                        HasSafetyComment::No
+                    } else {
+                        match text_has_safety_comment(
+                            src,
+                            &lines[comment_start_line.line + 1..=unsafe_line.line],
+                            unsafe_line.sf.start_pos.to_usize(),
+                        ) {
+                            Some(b) => HasSafetyComment::Yes(b),
+                            None => HasSafetyComment::No,
+                        }
+                    }
                 })
             } else {
                 // Problem getting source text. Pretend a comment was found.
-                true
+                HasSafetyComment::Maybe
             }
         } else {
             // No parent node. Pretend a comment was found.
-            true
+            HasSafetyComment::Maybe
         }
     } else {
-        false
+        HasSafetyComment::No
     }
 }
 
-fn comment_start_before_impl_in_mod(
+fn comment_start_before_item_in_mod(
     cx: &LateContext<'_>,
     parent_mod: &hir::Mod<'_>,
     parent_mod_span: Span,
-    imple: &hir::Item<'_>,
+    item: &hir::Item<'_>,
 ) -> Option<BytePos> {
     parent_mod.item_ids.iter().enumerate().find_map(|(idx, item_id)| {
-        if *item_id == imple.item_id() {
+        if *item_id == item.item_id() {
             if idx == 0 {
                 // mod A { /* comment */ unsafe impl T {} ... }
                 // ^------------------------------------------^ returns the start of this span
@@ -270,11 +382,11 @@ fn comment_start_before_impl_in_mod(
     })
 }
 
-fn span_from_macro_expansion_has_safety_comment(cx: &LateContext<'_>, span: Span) -> bool {
+fn span_from_macro_expansion_has_safety_comment(cx: &LateContext<'_>, span: Span) -> HasSafetyComment {
     let source_map = cx.sess().source_map();
     let ctxt = span.ctxt();
     if ctxt == SyntaxContext::root() {
-        false
+        HasSafetyComment::Maybe
     } else {
         // From a macro expansion. Get the text from the start of the macro declaration to start of the
         // unsafe block.
@@ -286,15 +398,22 @@ fn span_from_macro_expansion_has_safety_comment(cx: &LateContext<'_>, span: Span
             && let Some(src) = unsafe_line.sf.src.as_deref()
         {
             unsafe_line.sf.lines(|lines| {
-                macro_line.line < unsafe_line.line && text_has_safety_comment(
-                    src,
-                    &lines[macro_line.line + 1..=unsafe_line.line],
-                    unsafe_line.sf.start_pos.to_usize(),
-                )
+                if macro_line.line < unsafe_line.line {
+                    match text_has_safety_comment(
+                        src,
+                        &lines[macro_line.line + 1..=unsafe_line.line],
+                        unsafe_line.sf.start_pos.to_usize(),
+                    ) {
+                        Some(b) => HasSafetyComment::Yes(b),
+                        None => HasSafetyComment::No,
+                    }
+                } else {
+                    HasSafetyComment::No
+                }
             })
         } else {
             // Problem getting source text. Pretend a comment was found.
-            true
+            HasSafetyComment::Maybe
         }
     }
 }
@@ -333,7 +452,7 @@ fn span_in_body_has_safety_comment(cx: &LateContext<'_>, span: Span) -> bool {
                     src,
                     &lines[body_line.line + 1..=unsafe_line.line],
                     unsafe_line.sf.start_pos.to_usize(),
-                )
+                ).is_some()
             })
         } else {
             // Problem getting source text. Pretend a comment was found.
@@ -345,30 +464,34 @@ fn span_in_body_has_safety_comment(cx: &LateContext<'_>, span: Span) -> bool {
 }
 
 /// Checks if the given text has a safety comment for the immediately proceeding line.
-fn text_has_safety_comment(src: &str, line_starts: &[BytePos], offset: usize) -> bool {
+fn text_has_safety_comment(src: &str, line_starts: &[BytePos], offset: usize) -> Option<BytePos> {
     let mut lines = line_starts
         .array_windows::<2>()
         .rev()
         .map_while(|[start, end]| {
             let start = start.to_usize() - offset;
             let end = end.to_usize() - offset;
-            src.get(start..end).map(|text| (start, text.trim_start()))
+            let text = src.get(start..end)?;
+            let trimmed = text.trim_start();
+            Some((start + (text.len() - trimmed.len()), trimmed))
         })
         .filter(|(_, text)| !text.is_empty());
 
     let Some((line_start, line)) = lines.next() else {
-        return false;
+        return None;
     };
     // Check for a sequence of line comments.
     if line.starts_with("//") {
-        let mut line = line;
+        let (mut line, mut line_start) = (line, line_start);
         loop {
             if line.to_ascii_uppercase().contains("SAFETY:") {
-                return true;
+                return Some(BytePos(
+                    u32::try_from(line_start).unwrap() + u32::try_from(offset).unwrap(),
+                ));
             }
             match lines.next() {
-                Some((_, x)) if x.starts_with("//") => line = x,
-                _ => return false,
+                Some((s, x)) if x.starts_with("//") => (line, line_start) = (x, s),
+                _ => return None,
             }
         }
     }
@@ -377,16 +500,19 @@ fn text_has_safety_comment(src: &str, line_starts: &[BytePos], offset: usize) ->
     let (mut line_start, mut line) = (line_start, line);
     loop {
         if line.starts_with("/*") {
-            let src = src[line_start..line_starts.last().unwrap().to_usize() - offset].trim_start();
+            let src = &src[line_start..line_starts.last().unwrap().to_usize() - offset];
             let mut tokens = tokenize(src);
-            return src[..tokens.next().unwrap().len as usize]
+            return (src[..tokens.next().unwrap().len as usize]
                 .to_ascii_uppercase()
                 .contains("SAFETY:")
-                && tokens.all(|t| t.kind == TokenKind::Whitespace);
+                && tokens.all(|t| t.kind == TokenKind::Whitespace))
+            .then_some(BytePos(
+                u32::try_from(line_start).unwrap() + u32::try_from(offset).unwrap(),
+            ));
         }
         match lines.next() {
             Some(x) => (line_start, line) = x,
-            None => return false,
+            None => return None,
         }
     }
 }
diff --git a/tests/ui/undocumented_unsafe_blocks.rs b/tests/ui/undocumented_unsafe_blocks.rs
index cbc6768033e..c05eb447b2e 100644
--- a/tests/ui/undocumented_unsafe_blocks.rs
+++ b/tests/ui/undocumented_unsafe_blocks.rs
@@ -1,6 +1,6 @@
 // aux-build:proc_macro_unsafe.rs
 
-#![warn(clippy::undocumented_unsafe_blocks)]
+#![warn(clippy::undocumented_unsafe_blocks, clippy::unnecessary_safety_comment)]
 #![allow(clippy::let_unit_value, clippy::missing_safety_doc)]
 
 extern crate proc_macro_unsafe;
diff --git a/tests/ui/undocumented_unsafe_blocks.stderr b/tests/ui/undocumented_unsafe_blocks.stderr
index ba4de9806d1..4c6f6cd18c5 100644
--- a/tests/ui/undocumented_unsafe_blocks.stderr
+++ b/tests/ui/undocumented_unsafe_blocks.stderr
@@ -239,6 +239,19 @@ LL |     unsafe impl TrailingComment for () {} // SAFETY:
    |
    = help: consider adding a safety comment on the preceding line
 
+error: constant item has unnecessary safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:471:5
+   |
+LL |     const BIG_NUMBER: i32 = 1000000;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider removing the safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:470:5
+   |
+LL |     // SAFETY:
+   |     ^^^^^^^^^^
+   = note: `-D clippy::unnecessary-safety-comment` implied by `-D warnings`
+
 error: unsafe impl missing a safety comment
   --> $DIR/undocumented_unsafe_blocks.rs:472:5
    |
@@ -287,5 +300,5 @@ LL |             let bar = unsafe {};
    |
    = help: consider adding a safety comment on the preceding line
 
-error: aborting due to 34 previous errors
+error: aborting due to 35 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From b8c3f64cee8b07470572f274712dc9ab2634221b Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukastw97@gmail.com>
Date: Thu, 17 Nov 2022 11:00:51 +0100
Subject: Add some more test cases for undocumented_unsafe_blocks

---
 clippy_lints/src/undocumented_unsafe_blocks.rs |  7 ++-
 tests/ui/undocumented_unsafe_blocks.rs         | 13 +++++
 tests/ui/undocumented_unsafe_blocks.stderr     | 72 +++++++++++++++++++++++---
 3 files changed, 85 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/undocumented_unsafe_blocks.rs b/clippy_lints/src/undocumented_unsafe_blocks.rs
index 57ee2735aa0..080a481e87f 100644
--- a/clippy_lints/src/undocumented_unsafe_blocks.rs
+++ b/clippy_lints/src/undocumented_unsafe_blocks.rs
@@ -82,7 +82,7 @@ declare_clippy_lint! {
     ///
     /// let ptr = NonNull::new(a).unwrap();
     /// ```
-    #[clippy::version = "1.66.0"]
+    #[clippy::version = "1.67.0"]
     pub UNNECESSARY_SAFETY_COMMENT,
     restriction,
     "creating an unsafe block without explaining why it is safe"
@@ -136,6 +136,7 @@ impl LateLintPass<'_> for UndocumentedUnsafeBlocks {
 
         let item_has_safety_comment = item_has_safety_comment(cx, item);
         match (&item.kind, item_has_safety_comment) {
+            // lint unsafe impl without safety comment
             (hir::ItemKind::Impl(impl_), HasSafetyComment::No) if impl_.unsafety == hir::Unsafety::Unsafe => {
                 if !is_lint_allowed(cx, UNDOCUMENTED_UNSAFE_BLOCKS, item.hir_id())
                     && !is_unsafe_from_proc_macro(cx, item.span)
@@ -157,6 +158,7 @@ impl LateLintPass<'_> for UndocumentedUnsafeBlocks {
                     );
                 }
             },
+            // lint safe impl with unnecessary safety comment
             (hir::ItemKind::Impl(impl_), HasSafetyComment::Yes(pos)) if impl_.unsafety == hir::Unsafety::Normal => {
                 if !is_lint_allowed(cx, UNNECESSARY_SAFETY_COMMENT, item.hir_id()) {
                     let (span, help_span) = mk_spans(pos);
@@ -172,6 +174,7 @@ impl LateLintPass<'_> for UndocumentedUnsafeBlocks {
                 }
             },
             (hir::ItemKind::Impl(_), _) => {},
+            // const and static items only need a safety comment if their body is an unsafe block, lint otherwise
             (&hir::ItemKind::Const(.., body) | &hir::ItemKind::Static(.., body), HasSafetyComment::Yes(pos)) => {
                 if !is_lint_allowed(cx, UNNECESSARY_SAFETY_COMMENT, body.hir_id) {
                     let body = cx.tcx.hir().body(body);
@@ -192,6 +195,8 @@ impl LateLintPass<'_> for UndocumentedUnsafeBlocks {
                     }
                 }
             },
+            // Aside from unsafe impls and consts/statics with an unsafe block, items in general
+            // do not have safety invariants that need to be documented, so lint those.
             (_, HasSafetyComment::Yes(pos)) => {
                 if !is_lint_allowed(cx, UNNECESSARY_SAFETY_COMMENT, item.hir_id()) {
                     let (span, help_span) = mk_spans(pos);
diff --git a/tests/ui/undocumented_unsafe_blocks.rs b/tests/ui/undocumented_unsafe_blocks.rs
index c05eb447b2e..f68e0b4915e 100644
--- a/tests/ui/undocumented_unsafe_blocks.rs
+++ b/tests/ui/undocumented_unsafe_blocks.rs
@@ -472,6 +472,19 @@ mod unsafe_impl_invalid_comment {
     unsafe impl Interference for () {}
 }
 
+mod unsafe_items_invalid_comment {
+    // SAFETY:
+    const CONST: u32 = 0;
+    // SAFETY:
+    static STATIC: u32 = 0;
+    // SAFETY:
+    struct Struct;
+    // SAFETY:
+    enum Enum {}
+    // SAFETY:
+    mod module {}
+}
+
 unsafe trait ImplInFn {}
 
 fn impl_in_fn() {
diff --git a/tests/ui/undocumented_unsafe_blocks.stderr b/tests/ui/undocumented_unsafe_blocks.stderr
index 4c6f6cd18c5..becad4f61a9 100644
--- a/tests/ui/undocumented_unsafe_blocks.stderr
+++ b/tests/ui/undocumented_unsafe_blocks.stderr
@@ -260,16 +260,76 @@ LL |     unsafe impl Interference for () {}
    |
    = help: consider adding a safety comment on the preceding line
 
-error: unsafe impl missing a safety comment
+error: constant item has unnecessary safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:477:5
+   |
+LL |     const CONST: u32 = 0;
+   |     ^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider removing the safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:476:5
+   |
+LL |     // SAFETY:
+   |     ^^^^^^^^^^
+
+error: static item has unnecessary safety comment
   --> $DIR/undocumented_unsafe_blocks.rs:479:5
    |
+LL |     static STATIC: u32 = 0;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider removing the safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:478:5
+   |
+LL |     // SAFETY:
+   |     ^^^^^^^^^^
+
+error: struct has unnecessary safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:481:5
+   |
+LL |     struct Struct;
+   |     ^^^^^^^^^^^^^^
+   |
+help: consider removing the safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:480:5
+   |
+LL |     // SAFETY:
+   |     ^^^^^^^^^^
+
+error: enum has unnecessary safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:483:5
+   |
+LL |     enum Enum {}
+   |     ^^^^^^^^^^^^
+   |
+help: consider removing the safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:482:5
+   |
+LL |     // SAFETY:
+   |     ^^^^^^^^^^
+
+error: module has unnecessary safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:485:5
+   |
+LL |     mod module {}
+   |     ^^^^^^^^^^^^^
+   |
+help: consider removing the safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:484:5
+   |
+LL |     // SAFETY:
+   |     ^^^^^^^^^^
+
+error: unsafe impl missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:492:5
+   |
 LL |     unsafe impl ImplInFn for () {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe impl missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:488:1
+  --> $DIR/undocumented_unsafe_blocks.rs:501:1
    |
 LL | unsafe impl CrateRoot for () {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -277,7 +337,7 @@ LL | unsafe impl CrateRoot for () {}
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:498:9
+  --> $DIR/undocumented_unsafe_blocks.rs:511:9
    |
 LL |         unsafe {};
    |         ^^^^^^^^^
@@ -285,7 +345,7 @@ LL |         unsafe {};
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:502:12
+  --> $DIR/undocumented_unsafe_blocks.rs:515:12
    |
 LL |         if unsafe { true } {
    |            ^^^^^^^^^^^^^^^
@@ -293,12 +353,12 @@ LL |         if unsafe { true } {
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:505:23
+  --> $DIR/undocumented_unsafe_blocks.rs:518:23
    |
 LL |             let bar = unsafe {};
    |                       ^^^^^^^^^
    |
    = help: consider adding a safety comment on the preceding line
 
-error: aborting due to 35 previous errors
+error: aborting due to 40 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 4fa57575302a5931517590daf8df2ef8a93f7a7b Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukastw97@gmail.com>
Date: Thu, 17 Nov 2022 15:14:03 +0100
Subject: Lint unnecessary safety comments on statements and block tail
 expressions

---
 clippy_lints/src/undocumented_unsafe_blocks.rs | 126 ++++++++++++++++++++++++-
 clippy_utils/src/visitors.rs                   |  12 +--
 tests/ui/undocumented_unsafe_blocks.rs         |  31 ++++++
 tests/ui/undocumented_unsafe_blocks.stderr     |  60 +++++++++++-
 4 files changed, 220 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/undocumented_unsafe_blocks.rs b/clippy_lints/src/undocumented_unsafe_blocks.rs
index 080a481e87f..c60144df757 100644
--- a/clippy_lints/src/undocumented_unsafe_blocks.rs
+++ b/clippy_lints/src/undocumented_unsafe_blocks.rs
@@ -1,6 +1,10 @@
+use std::ops::ControlFlow;
+
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::source::walk_span_to_context;
+use clippy_utils::visitors::{for_each_expr_with_closures, Descend};
 use clippy_utils::{get_parent_node, is_lint_allowed};
+use hir::HirId;
 use rustc_data_structures::sync::Lrc;
 use rustc_hir as hir;
 use rustc_hir::{Block, BlockCheckMode, ItemKind, Node, UnsafeSource};
@@ -90,8 +94,8 @@ declare_clippy_lint! {
 
 declare_lint_pass!(UndocumentedUnsafeBlocks => [UNDOCUMENTED_UNSAFE_BLOCKS, UNNECESSARY_SAFETY_COMMENT]);
 
-impl LateLintPass<'_> for UndocumentedUnsafeBlocks {
-    fn check_block(&mut self, cx: &LateContext<'_>, block: &'_ Block<'_>) {
+impl<'tcx> LateLintPass<'tcx> for UndocumentedUnsafeBlocks {
+    fn check_block(&mut self, cx: &LateContext<'tcx>, block: &'tcx Block<'tcx>) {
         if block.rules == BlockCheckMode::UnsafeBlock(UnsafeSource::UserProvided)
             && !in_external_macro(cx.tcx.sess, block.span)
             && !is_lint_allowed(cx, UNDOCUMENTED_UNSAFE_BLOCKS, block.hir_id)
@@ -115,6 +119,45 @@ impl LateLintPass<'_> for UndocumentedUnsafeBlocks {
                 "consider adding a safety comment on the preceding line",
             );
         }
+
+        if let Some(tail) = block.expr
+            && !is_lint_allowed(cx, UNNECESSARY_SAFETY_COMMENT, tail.hir_id)
+            && !in_external_macro(cx.tcx.sess, tail.span)
+            && let HasSafetyComment::Yes(pos) = stmt_has_safety_comment(cx, tail.span, tail.hir_id)
+            && let Some(help_span) = expr_has_unnecessary_safety_comment(cx, tail, pos)
+        {
+            span_lint_and_help(
+                cx,
+                UNNECESSARY_SAFETY_COMMENT,
+                tail.span,
+                "expression has unnecessary safety comment",
+                Some(help_span),
+                "consider removing the safety comment",
+            );
+        }
+    }
+
+    fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &hir::Stmt<'tcx>) {
+        let expr = match stmt.kind {
+            hir::StmtKind::Local(&hir::Local { init: Some(expr), .. })
+            | hir::StmtKind::Expr(expr)
+            | hir::StmtKind::Semi(expr) => expr,
+            _ => return,
+        };
+        if !is_lint_allowed(cx, UNNECESSARY_SAFETY_COMMENT, stmt.hir_id)
+            && !in_external_macro(cx.tcx.sess, stmt.span)
+            && let HasSafetyComment::Yes(pos) = stmt_has_safety_comment(cx, stmt.span, stmt.hir_id)
+            && let Some(help_span) = expr_has_unnecessary_safety_comment(cx, expr, pos)
+        {
+            span_lint_and_help(
+                cx,
+                UNNECESSARY_SAFETY_COMMENT,
+                stmt.span,
+                "statement has unnecessary safety comment",
+                Some(help_span),
+                "consider removing the safety comment",
+            );
+        }
     }
 
     fn check_item(&mut self, cx: &LateContext<'_>, item: &hir::Item<'_>) {
@@ -216,6 +259,36 @@ impl LateLintPass<'_> for UndocumentedUnsafeBlocks {
     }
 }
 
+fn expr_has_unnecessary_safety_comment<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx hir::Expr<'tcx>,
+    comment_pos: BytePos,
+) -> Option<Span> {
+    // this should roughly be the reverse of `block_parents_have_safety_comment`
+    if for_each_expr_with_closures(cx, expr, |expr| match expr.kind {
+        hir::ExprKind::Block(
+            Block {
+                rules: BlockCheckMode::UnsafeBlock(UnsafeSource::UserProvided),
+                ..
+            },
+            _,
+        ) => ControlFlow::Break(()),
+        // statements will be handled by check_stmt itself again
+        hir::ExprKind::Block(..) => ControlFlow::Continue(Descend::No),
+        _ => ControlFlow::Continue(Descend::Yes),
+    })
+    .is_some()
+    {
+        return None;
+    }
+
+    let source_map = cx.tcx.sess.source_map();
+    let span = Span::new(comment_pos, comment_pos, SyntaxContext::root(), None);
+    let help_span = source_map.span_extend_to_next_char(span, '\n', true);
+
+    Some(help_span)
+}
+
 fn is_unsafe_from_proc_macro(cx: &LateContext<'_>, span: Span) -> bool {
     let source_map = cx.sess().source_map();
     let file_pos = source_map.lookup_byte_offset(span.lo());
@@ -358,6 +431,55 @@ fn item_has_safety_comment(cx: &LateContext<'_>, item: &hir::Item<'_>) -> HasSaf
     }
 }
 
+/// Checks if the lines immediately preceding the item contain a safety comment.
+#[allow(clippy::collapsible_match)]
+fn stmt_has_safety_comment(cx: &LateContext<'_>, span: Span, hir_id: HirId) -> HasSafetyComment {
+    match span_from_macro_expansion_has_safety_comment(cx, span) {
+        HasSafetyComment::Maybe => (),
+        has_safety_comment => return has_safety_comment,
+    }
+
+    if span.ctxt() == SyntaxContext::root() {
+        if let Some(parent_node) = get_parent_node(cx.tcx, hir_id) {
+            let comment_start = match parent_node {
+                Node::Block(block) => walk_span_to_context(block.span, SyntaxContext::root()).map(Span::lo),
+                _ => return HasSafetyComment::Maybe,
+            };
+
+            let source_map = cx.sess().source_map();
+            if let Some(comment_start) = comment_start
+                && let Ok(unsafe_line) = source_map.lookup_line(span.lo())
+                && let Ok(comment_start_line) = source_map.lookup_line(comment_start)
+                && Lrc::ptr_eq(&unsafe_line.sf, &comment_start_line.sf)
+                && let Some(src) = unsafe_line.sf.src.as_deref()
+            {
+                unsafe_line.sf.lines(|lines| {
+                    if comment_start_line.line >= unsafe_line.line {
+                        HasSafetyComment::No
+                    } else {
+                        match text_has_safety_comment(
+                            src,
+                            &lines[comment_start_line.line + 1..=unsafe_line.line],
+                            unsafe_line.sf.start_pos.to_usize(),
+                        ) {
+                            Some(b) => HasSafetyComment::Yes(b),
+                            None => HasSafetyComment::No,
+                        }
+                    }
+                })
+            } else {
+                // Problem getting source text. Pretend a comment was found.
+                HasSafetyComment::Maybe
+            }
+        } else {
+            // No parent node. Pretend a comment was found.
+            HasSafetyComment::Maybe
+        }
+    } else {
+        HasSafetyComment::No
+    }
+}
+
 fn comment_start_before_item_in_mod(
     cx: &LateContext<'_>,
     parent_mod: &hir::Mod<'_>,
diff --git a/clippy_utils/src/visitors.rs b/clippy_utils/src/visitors.rs
index d4294f18fd5..863fb60fcfc 100644
--- a/clippy_utils/src/visitors.rs
+++ b/clippy_utils/src/visitors.rs
@@ -170,22 +170,22 @@ where
         cb: F,
     }
 
-    struct WithStmtGuarg<'a, F> {
+    struct WithStmtGuard<'a, F> {
         val: &'a mut RetFinder<F>,
         prev_in_stmt: bool,
     }
 
     impl<F> RetFinder<F> {
-        fn inside_stmt(&mut self, in_stmt: bool) -> WithStmtGuarg<'_, F> {
+        fn inside_stmt(&mut self, in_stmt: bool) -> WithStmtGuard<'_, F> {
             let prev_in_stmt = std::mem::replace(&mut self.in_stmt, in_stmt);
-            WithStmtGuarg {
+            WithStmtGuard {
                 val: self,
                 prev_in_stmt,
             }
         }
     }
 
-    impl<F> std::ops::Deref for WithStmtGuarg<'_, F> {
+    impl<F> std::ops::Deref for WithStmtGuard<'_, F> {
         type Target = RetFinder<F>;
 
         fn deref(&self) -> &Self::Target {
@@ -193,13 +193,13 @@ where
         }
     }
 
-    impl<F> std::ops::DerefMut for WithStmtGuarg<'_, F> {
+    impl<F> std::ops::DerefMut for WithStmtGuard<'_, F> {
         fn deref_mut(&mut self) -> &mut Self::Target {
             self.val
         }
     }
 
-    impl<F> Drop for WithStmtGuarg<'_, F> {
+    impl<F> Drop for WithStmtGuard<'_, F> {
         fn drop(&mut self) {
             self.val.in_stmt = self.prev_in_stmt;
         }
diff --git a/tests/ui/undocumented_unsafe_blocks.rs b/tests/ui/undocumented_unsafe_blocks.rs
index f68e0b4915e..cb99ce0d421 100644
--- a/tests/ui/undocumented_unsafe_blocks.rs
+++ b/tests/ui/undocumented_unsafe_blocks.rs
@@ -522,4 +522,35 @@ fn issue_9142() {
     };
 }
 
+mod unnecessary_from_macro {
+    trait T {}
+
+    macro_rules! no_safety_comment {
+        ($t:ty) => {
+            impl T for $t {}
+        };
+    }
+
+    // FIXME: This is not caught
+    // Safety: unnecessary
+    no_safety_comment!(());
+
+    macro_rules! with_safety_comment {
+        ($t:ty) => {
+            // Safety: unnecessary
+            impl T for $t {}
+        };
+    }
+
+    with_safety_comment!(i32);
+}
+
+fn unnecessary_on_stmt_and_expr() -> u32 {
+    // SAFETY: unnecessary
+    let num = 42;
+
+    // SAFETY: unnecessary
+    24
+}
+
 fn main() {}
diff --git a/tests/ui/undocumented_unsafe_blocks.stderr b/tests/ui/undocumented_unsafe_blocks.stderr
index becad4f61a9..919fd51351c 100644
--- a/tests/ui/undocumented_unsafe_blocks.stderr
+++ b/tests/ui/undocumented_unsafe_blocks.stderr
@@ -344,6 +344,24 @@ LL |         unsafe {};
    |
    = help: consider adding a safety comment on the preceding line
 
+error: statement has unnecessary safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:514:5
+   |
+LL | /     let _ = {
+LL | |         if unsafe { true } {
+LL | |             todo!();
+LL | |         } else {
+...  |
+LL | |         }
+LL | |     };
+   | |______^
+   |
+help: consider removing the safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:513:5
+   |
+LL |     // SAFETY: this is more than one level away, so it should warn
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
 error: unsafe block missing a safety comment
   --> $DIR/undocumented_unsafe_blocks.rs:515:12
    |
@@ -360,5 +378,45 @@ LL |             let bar = unsafe {};
    |
    = help: consider adding a safety comment on the preceding line
 
-error: aborting due to 40 previous errors
+error: impl has unnecessary safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:541:13
+   |
+LL |             impl T for $t {}
+   |             ^^^^^^^^^^^^^^^^
+...
+LL |     with_safety_comment!(i32);
+   |     ------------------------- in this macro invocation
+   |
+help: consider removing the safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:540:13
+   |
+LL |             // Safety: unnecessary
+   |             ^^^^^^^^^^^^^^^^^^^^^^
+   = note: this error originates in the macro `with_safety_comment` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: expression has unnecessary safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:553:5
+   |
+LL |     24
+   |     ^^
+   |
+help: consider removing the safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:552:5
+   |
+LL |     // SAFETY: unnecessary
+   |     ^^^^^^^^^^^^^^^^^^^^^^
+
+error: statement has unnecessary safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:550:5
+   |
+LL |     let num = 42;
+   |     ^^^^^^^^^^^^^
+   |
+help: consider removing the safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:549:5
+   |
+LL |     // SAFETY: unnecessary
+   |     ^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 44 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 9c69e1cc893878987991d77b8fb54d1f6de29733 Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukastw97@gmail.com>
Date: Thu, 17 Nov 2022 15:17:28 +0100
Subject: Simplify

---
 clippy_lints/src/undocumented_unsafe_blocks.rs | 173 +++++++++++--------------
 1 file changed, 78 insertions(+), 95 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/undocumented_unsafe_blocks.rs b/clippy_lints/src/undocumented_unsafe_blocks.rs
index c60144df757..d7e48342306 100644
--- a/clippy_lints/src/undocumented_unsafe_blocks.rs
+++ b/clippy_lints/src/undocumented_unsafe_blocks.rs
@@ -363,72 +363,60 @@ fn item_has_safety_comment(cx: &LateContext<'_>, item: &hir::Item<'_>) -> HasSaf
         has_safety_comment => return has_safety_comment,
     }
 
-    if item.span.ctxt() == SyntaxContext::root() {
-        if let Some(parent_node) = get_parent_node(cx.tcx, item.hir_id()) {
-            let comment_start = match parent_node {
-                Node::Crate(parent_mod) => {
-                    comment_start_before_item_in_mod(cx, parent_mod, parent_mod.spans.inner_span, item)
-                },
-                Node::Item(parent_item) => {
-                    if let ItemKind::Mod(parent_mod) = &parent_item.kind {
-                        comment_start_before_item_in_mod(cx, parent_mod, parent_item.span, item)
-                    } else {
-                        // Doesn't support impls in this position. Pretend a comment was found.
-                        return HasSafetyComment::Maybe;
-                    }
-                },
-                Node::Stmt(stmt) => {
-                    if let Some(stmt_parent) = get_parent_node(cx.tcx, stmt.hir_id) {
-                        match stmt_parent {
-                            Node::Block(block) => walk_span_to_context(block.span, SyntaxContext::root()).map(Span::lo),
-                            _ => {
-                                // Doesn't support impls in this position. Pretend a comment was found.
-                                return HasSafetyComment::Maybe;
-                            },
-                        }
-                    } else {
-                        // Problem getting the parent node. Pretend a comment was found.
-                        return HasSafetyComment::Maybe;
-                    }
-                },
-                _ => {
+    if item.span.ctxt() != SyntaxContext::root() {
+        return HasSafetyComment::No;
+    }
+    if let Some(parent_node) = get_parent_node(cx.tcx, item.hir_id()) {
+        let comment_start = match parent_node {
+            Node::Crate(parent_mod) => {
+                comment_start_before_item_in_mod(cx, parent_mod, parent_mod.spans.inner_span, item)
+            },
+            Node::Item(parent_item) => {
+                if let ItemKind::Mod(parent_mod) = &parent_item.kind {
+                    comment_start_before_item_in_mod(cx, parent_mod, parent_item.span, item)
+                } else {
                     // Doesn't support impls in this position. Pretend a comment was found.
                     return HasSafetyComment::Maybe;
-                },
-            };
+                }
+            },
+            Node::Stmt(stmt) => {
+                if let Some(Node::Block(block)) = get_parent_node(cx.tcx, stmt.hir_id) {
+                    walk_span_to_context(block.span, SyntaxContext::root()).map(Span::lo)
+                } else {
+                    // Problem getting the parent node. Pretend a comment was found.
+                    return HasSafetyComment::Maybe;
+                }
+            },
+            _ => {
+                // Doesn't support impls in this position. Pretend a comment was found.
+                return HasSafetyComment::Maybe;
+            },
+        };
 
-            let source_map = cx.sess().source_map();
-            if let Some(comment_start) = comment_start
-                && let Ok(unsafe_line) = source_map.lookup_line(item.span.lo())
-                && let Ok(comment_start_line) = source_map.lookup_line(comment_start)
-                && Lrc::ptr_eq(&unsafe_line.sf, &comment_start_line.sf)
-                && let Some(src) = unsafe_line.sf.src.as_deref()
-            {
-                unsafe_line.sf.lines(|lines| {
-                    if comment_start_line.line >= unsafe_line.line {
-                        HasSafetyComment::No
-                    } else {
-                        match text_has_safety_comment(
-                            src,
-                            &lines[comment_start_line.line + 1..=unsafe_line.line],
-                            unsafe_line.sf.start_pos.to_usize(),
-                        ) {
-                            Some(b) => HasSafetyComment::Yes(b),
-                            None => HasSafetyComment::No,
-                        }
+        let source_map = cx.sess().source_map();
+        if let Some(comment_start) = comment_start
+            && let Ok(unsafe_line) = source_map.lookup_line(item.span.lo())
+            && let Ok(comment_start_line) = source_map.lookup_line(comment_start)
+            && Lrc::ptr_eq(&unsafe_line.sf, &comment_start_line.sf)
+            && let Some(src) = unsafe_line.sf.src.as_deref()
+        {
+            return unsafe_line.sf.lines(|lines| {
+                if comment_start_line.line >= unsafe_line.line {
+                    HasSafetyComment::No
+                } else {
+                    match text_has_safety_comment(
+                        src,
+                        &lines[comment_start_line.line + 1..=unsafe_line.line],
+                        unsafe_line.sf.start_pos.to_usize(),
+                    ) {
+                        Some(b) => HasSafetyComment::Yes(b),
+                        None => HasSafetyComment::No,
                     }
-                })
-            } else {
-                // Problem getting source text. Pretend a comment was found.
-                HasSafetyComment::Maybe
-            }
-        } else {
-            // No parent node. Pretend a comment was found.
-            HasSafetyComment::Maybe
+                }
+            });
         }
-    } else {
-        HasSafetyComment::No
     }
+    HasSafetyComment::Maybe
 }
 
 /// Checks if the lines immediately preceding the item contain a safety comment.
@@ -439,45 +427,40 @@ fn stmt_has_safety_comment(cx: &LateContext<'_>, span: Span, hir_id: HirId) -> H
         has_safety_comment => return has_safety_comment,
     }
 
-    if span.ctxt() == SyntaxContext::root() {
-        if let Some(parent_node) = get_parent_node(cx.tcx, hir_id) {
-            let comment_start = match parent_node {
-                Node::Block(block) => walk_span_to_context(block.span, SyntaxContext::root()).map(Span::lo),
-                _ => return HasSafetyComment::Maybe,
-            };
+    if span.ctxt() != SyntaxContext::root() {
+        return HasSafetyComment::No;
+    }
 
-            let source_map = cx.sess().source_map();
-            if let Some(comment_start) = comment_start
-                && let Ok(unsafe_line) = source_map.lookup_line(span.lo())
-                && let Ok(comment_start_line) = source_map.lookup_line(comment_start)
-                && Lrc::ptr_eq(&unsafe_line.sf, &comment_start_line.sf)
-                && let Some(src) = unsafe_line.sf.src.as_deref()
-            {
-                unsafe_line.sf.lines(|lines| {
-                    if comment_start_line.line >= unsafe_line.line {
-                        HasSafetyComment::No
-                    } else {
-                        match text_has_safety_comment(
-                            src,
-                            &lines[comment_start_line.line + 1..=unsafe_line.line],
-                            unsafe_line.sf.start_pos.to_usize(),
-                        ) {
-                            Some(b) => HasSafetyComment::Yes(b),
-                            None => HasSafetyComment::No,
-                        }
+    if let Some(parent_node) = get_parent_node(cx.tcx, hir_id) {
+        let comment_start = match parent_node {
+            Node::Block(block) => walk_span_to_context(block.span, SyntaxContext::root()).map(Span::lo),
+            _ => return HasSafetyComment::Maybe,
+        };
+
+        let source_map = cx.sess().source_map();
+        if let Some(comment_start) = comment_start
+            && let Ok(unsafe_line) = source_map.lookup_line(span.lo())
+            && let Ok(comment_start_line) = source_map.lookup_line(comment_start)
+            && Lrc::ptr_eq(&unsafe_line.sf, &comment_start_line.sf)
+            && let Some(src) = unsafe_line.sf.src.as_deref()
+        {
+            return unsafe_line.sf.lines(|lines| {
+                if comment_start_line.line >= unsafe_line.line {
+                    HasSafetyComment::No
+                } else {
+                    match text_has_safety_comment(
+                        src,
+                        &lines[comment_start_line.line + 1..=unsafe_line.line],
+                        unsafe_line.sf.start_pos.to_usize(),
+                    ) {
+                        Some(b) => HasSafetyComment::Yes(b),
+                        None => HasSafetyComment::No,
                     }
-                })
-            } else {
-                // Problem getting source text. Pretend a comment was found.
-                HasSafetyComment::Maybe
-            }
-        } else {
-            // No parent node. Pretend a comment was found.
-            HasSafetyComment::Maybe
+                }
+            });
         }
-    } else {
-        HasSafetyComment::No
     }
+    HasSafetyComment::Maybe
 }
 
 fn comment_start_before_item_in_mod(
-- 
cgit 1.4.1-3-g733a5


From f96dd383188e9f24e5b401e664cca97b8bd73825 Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukastw97@gmail.com>
Date: Thu, 24 Nov 2022 09:47:50 +0100
Subject: Address reviews

---
 clippy_lints/src/undocumented_unsafe_blocks.rs |   9 +-
 tests/ui/undocumented_unsafe_blocks.rs         |  44 ----------
 tests/ui/undocumented_unsafe_blocks.stderr     | 116 ++-----------------------
 tests/ui/unnecessary_safety_comment.rs         |  51 +++++++++++
 tests/ui/unnecessary_safety_comment.stderr     | 115 ++++++++++++++++++++++++
 5 files changed, 178 insertions(+), 157 deletions(-)
 create mode 100644 tests/ui/unnecessary_safety_comment.rs
 create mode 100644 tests/ui/unnecessary_safety_comment.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/undocumented_unsafe_blocks.rs b/clippy_lints/src/undocumented_unsafe_blocks.rs
index d7e48342306..2e1b6d8d4ea 100644
--- a/clippy_lints/src/undocumented_unsafe_blocks.rs
+++ b/clippy_lints/src/undocumented_unsafe_blocks.rs
@@ -89,7 +89,7 @@ declare_clippy_lint! {
     #[clippy::version = "1.67.0"]
     pub UNNECESSARY_SAFETY_COMMENT,
     restriction,
-    "creating an unsafe block without explaining why it is safe"
+    "annotating safe code with a safety comment"
 }
 
 declare_lint_pass!(UndocumentedUnsafeBlocks => [UNDOCUMENTED_UNSAFE_BLOCKS, UNNECESSARY_SAFETY_COMMENT]);
@@ -138,12 +138,11 @@ impl<'tcx> LateLintPass<'tcx> for UndocumentedUnsafeBlocks {
     }
 
     fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &hir::Stmt<'tcx>) {
-        let expr = match stmt.kind {
+        let (
             hir::StmtKind::Local(&hir::Local { init: Some(expr), .. })
             | hir::StmtKind::Expr(expr)
-            | hir::StmtKind::Semi(expr) => expr,
-            _ => return,
-        };
+            | hir::StmtKind::Semi(expr)
+        ) = stmt.kind else { return };
         if !is_lint_allowed(cx, UNNECESSARY_SAFETY_COMMENT, stmt.hir_id)
             && !in_external_macro(cx.tcx.sess, stmt.span)
             && let HasSafetyComment::Yes(pos) = stmt_has_safety_comment(cx, stmt.span, stmt.hir_id)
diff --git a/tests/ui/undocumented_unsafe_blocks.rs b/tests/ui/undocumented_unsafe_blocks.rs
index cb99ce0d421..c05eb447b2e 100644
--- a/tests/ui/undocumented_unsafe_blocks.rs
+++ b/tests/ui/undocumented_unsafe_blocks.rs
@@ -472,19 +472,6 @@ mod unsafe_impl_invalid_comment {
     unsafe impl Interference for () {}
 }
 
-mod unsafe_items_invalid_comment {
-    // SAFETY:
-    const CONST: u32 = 0;
-    // SAFETY:
-    static STATIC: u32 = 0;
-    // SAFETY:
-    struct Struct;
-    // SAFETY:
-    enum Enum {}
-    // SAFETY:
-    mod module {}
-}
-
 unsafe trait ImplInFn {}
 
 fn impl_in_fn() {
@@ -522,35 +509,4 @@ fn issue_9142() {
     };
 }
 
-mod unnecessary_from_macro {
-    trait T {}
-
-    macro_rules! no_safety_comment {
-        ($t:ty) => {
-            impl T for $t {}
-        };
-    }
-
-    // FIXME: This is not caught
-    // Safety: unnecessary
-    no_safety_comment!(());
-
-    macro_rules! with_safety_comment {
-        ($t:ty) => {
-            // Safety: unnecessary
-            impl T for $t {}
-        };
-    }
-
-    with_safety_comment!(i32);
-}
-
-fn unnecessary_on_stmt_and_expr() -> u32 {
-    // SAFETY: unnecessary
-    let num = 42;
-
-    // SAFETY: unnecessary
-    24
-}
-
 fn main() {}
diff --git a/tests/ui/undocumented_unsafe_blocks.stderr b/tests/ui/undocumented_unsafe_blocks.stderr
index 919fd51351c..d1c1bb5ffea 100644
--- a/tests/ui/undocumented_unsafe_blocks.stderr
+++ b/tests/ui/undocumented_unsafe_blocks.stderr
@@ -260,68 +260,8 @@ LL |     unsafe impl Interference for () {}
    |
    = help: consider adding a safety comment on the preceding line
 
-error: constant item has unnecessary safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:477:5
-   |
-LL |     const CONST: u32 = 0;
-   |     ^^^^^^^^^^^^^^^^^^^^^
-   |
-help: consider removing the safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:476:5
-   |
-LL |     // SAFETY:
-   |     ^^^^^^^^^^
-
-error: static item has unnecessary safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:479:5
-   |
-LL |     static STATIC: u32 = 0;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: consider removing the safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:478:5
-   |
-LL |     // SAFETY:
-   |     ^^^^^^^^^^
-
-error: struct has unnecessary safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:481:5
-   |
-LL |     struct Struct;
-   |     ^^^^^^^^^^^^^^
-   |
-help: consider removing the safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:480:5
-   |
-LL |     // SAFETY:
-   |     ^^^^^^^^^^
-
-error: enum has unnecessary safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:483:5
-   |
-LL |     enum Enum {}
-   |     ^^^^^^^^^^^^
-   |
-help: consider removing the safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:482:5
-   |
-LL |     // SAFETY:
-   |     ^^^^^^^^^^
-
-error: module has unnecessary safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:485:5
-   |
-LL |     mod module {}
-   |     ^^^^^^^^^^^^^
-   |
-help: consider removing the safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:484:5
-   |
-LL |     // SAFETY:
-   |     ^^^^^^^^^^
-
 error: unsafe impl missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:492:5
+  --> $DIR/undocumented_unsafe_blocks.rs:479:5
    |
 LL |     unsafe impl ImplInFn for () {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -329,7 +269,7 @@ LL |     unsafe impl ImplInFn for () {}
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe impl missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:501:1
+  --> $DIR/undocumented_unsafe_blocks.rs:488:1
    |
 LL | unsafe impl CrateRoot for () {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -337,7 +277,7 @@ LL | unsafe impl CrateRoot for () {}
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:511:9
+  --> $DIR/undocumented_unsafe_blocks.rs:498:9
    |
 LL |         unsafe {};
    |         ^^^^^^^^^
@@ -345,7 +285,7 @@ LL |         unsafe {};
    = help: consider adding a safety comment on the preceding line
 
 error: statement has unnecessary safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:514:5
+  --> $DIR/undocumented_unsafe_blocks.rs:501:5
    |
 LL | /     let _ = {
 LL | |         if unsafe { true } {
@@ -357,13 +297,13 @@ LL | |     };
    | |______^
    |
 help: consider removing the safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:513:5
+  --> $DIR/undocumented_unsafe_blocks.rs:500:5
    |
 LL |     // SAFETY: this is more than one level away, so it should warn
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:515:12
+  --> $DIR/undocumented_unsafe_blocks.rs:502:12
    |
 LL |         if unsafe { true } {
    |            ^^^^^^^^^^^^^^^
@@ -371,52 +311,12 @@ LL |         if unsafe { true } {
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:518:23
+  --> $DIR/undocumented_unsafe_blocks.rs:505:23
    |
 LL |             let bar = unsafe {};
    |                       ^^^^^^^^^
    |
    = help: consider adding a safety comment on the preceding line
 
-error: impl has unnecessary safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:541:13
-   |
-LL |             impl T for $t {}
-   |             ^^^^^^^^^^^^^^^^
-...
-LL |     with_safety_comment!(i32);
-   |     ------------------------- in this macro invocation
-   |
-help: consider removing the safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:540:13
-   |
-LL |             // Safety: unnecessary
-   |             ^^^^^^^^^^^^^^^^^^^^^^
-   = note: this error originates in the macro `with_safety_comment` (in Nightly builds, run with -Z macro-backtrace for more info)
-
-error: expression has unnecessary safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:553:5
-   |
-LL |     24
-   |     ^^
-   |
-help: consider removing the safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:552:5
-   |
-LL |     // SAFETY: unnecessary
-   |     ^^^^^^^^^^^^^^^^^^^^^^
-
-error: statement has unnecessary safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:550:5
-   |
-LL |     let num = 42;
-   |     ^^^^^^^^^^^^^
-   |
-help: consider removing the safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:549:5
-   |
-LL |     // SAFETY: unnecessary
-   |     ^^^^^^^^^^^^^^^^^^^^^^
-
-error: aborting due to 44 previous errors
+error: aborting due to 36 previous errors
 
diff --git a/tests/ui/unnecessary_safety_comment.rs b/tests/ui/unnecessary_safety_comment.rs
new file mode 100644
index 00000000000..7fefea7051d
--- /dev/null
+++ b/tests/ui/unnecessary_safety_comment.rs
@@ -0,0 +1,51 @@
+#![warn(clippy::undocumented_unsafe_blocks, clippy::unnecessary_safety_comment)]
+#![allow(clippy::let_unit_value, clippy::missing_safety_doc)]
+
+mod unsafe_items_invalid_comment {
+    // SAFETY:
+    const CONST: u32 = 0;
+    // SAFETY:
+    static STATIC: u32 = 0;
+    // SAFETY:
+    struct Struct;
+    // SAFETY:
+    enum Enum {}
+    // SAFETY:
+    mod module {}
+}
+
+mod unnecessary_from_macro {
+    trait T {}
+
+    macro_rules! no_safety_comment {
+        ($t:ty) => {
+            impl T for $t {}
+        };
+    }
+
+    // FIXME: This is not caught
+    // Safety: unnecessary
+    no_safety_comment!(());
+
+    macro_rules! with_safety_comment {
+        ($t:ty) => {
+            // Safety: unnecessary
+            impl T for $t {}
+        };
+    }
+
+    with_safety_comment!(i32);
+}
+
+fn unnecessary_on_stmt_and_expr() -> u32 {
+    // SAFETY: unnecessary
+    let num = 42;
+
+    // SAFETY: unnecessary
+    if num > 24 {}
+
+    // SAFETY: unnecessary
+    24
+}
+
+fn main() {}
diff --git a/tests/ui/unnecessary_safety_comment.stderr b/tests/ui/unnecessary_safety_comment.stderr
new file mode 100644
index 00000000000..7b2af67d64c
--- /dev/null
+++ b/tests/ui/unnecessary_safety_comment.stderr
@@ -0,0 +1,115 @@
+error: constant item has unnecessary safety comment
+  --> $DIR/unnecessary_safety_comment.rs:6:5
+   |
+LL |     const CONST: u32 = 0;
+   |     ^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider removing the safety comment
+  --> $DIR/unnecessary_safety_comment.rs:5:5
+   |
+LL |     // SAFETY:
+   |     ^^^^^^^^^^
+   = note: `-D clippy::unnecessary-safety-comment` implied by `-D warnings`
+
+error: static item has unnecessary safety comment
+  --> $DIR/unnecessary_safety_comment.rs:8:5
+   |
+LL |     static STATIC: u32 = 0;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider removing the safety comment
+  --> $DIR/unnecessary_safety_comment.rs:7:5
+   |
+LL |     // SAFETY:
+   |     ^^^^^^^^^^
+
+error: struct has unnecessary safety comment
+  --> $DIR/unnecessary_safety_comment.rs:10:5
+   |
+LL |     struct Struct;
+   |     ^^^^^^^^^^^^^^
+   |
+help: consider removing the safety comment
+  --> $DIR/unnecessary_safety_comment.rs:9:5
+   |
+LL |     // SAFETY:
+   |     ^^^^^^^^^^
+
+error: enum has unnecessary safety comment
+  --> $DIR/unnecessary_safety_comment.rs:12:5
+   |
+LL |     enum Enum {}
+   |     ^^^^^^^^^^^^
+   |
+help: consider removing the safety comment
+  --> $DIR/unnecessary_safety_comment.rs:11:5
+   |
+LL |     // SAFETY:
+   |     ^^^^^^^^^^
+
+error: module has unnecessary safety comment
+  --> $DIR/unnecessary_safety_comment.rs:14:5
+   |
+LL |     mod module {}
+   |     ^^^^^^^^^^^^^
+   |
+help: consider removing the safety comment
+  --> $DIR/unnecessary_safety_comment.rs:13:5
+   |
+LL |     // SAFETY:
+   |     ^^^^^^^^^^
+
+error: impl has unnecessary safety comment
+  --> $DIR/unnecessary_safety_comment.rs:33:13
+   |
+LL |             impl T for $t {}
+   |             ^^^^^^^^^^^^^^^^
+...
+LL |     with_safety_comment!(i32);
+   |     ------------------------- in this macro invocation
+   |
+help: consider removing the safety comment
+  --> $DIR/unnecessary_safety_comment.rs:32:13
+   |
+LL |             // Safety: unnecessary
+   |             ^^^^^^^^^^^^^^^^^^^^^^
+   = note: this error originates in the macro `with_safety_comment` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: expression has unnecessary safety comment
+  --> $DIR/unnecessary_safety_comment.rs:48:5
+   |
+LL |     24
+   |     ^^
+   |
+help: consider removing the safety comment
+  --> $DIR/unnecessary_safety_comment.rs:47:5
+   |
+LL |     // SAFETY: unnecessary
+   |     ^^^^^^^^^^^^^^^^^^^^^^
+
+error: statement has unnecessary safety comment
+  --> $DIR/unnecessary_safety_comment.rs:42:5
+   |
+LL |     let num = 42;
+   |     ^^^^^^^^^^^^^
+   |
+help: consider removing the safety comment
+  --> $DIR/unnecessary_safety_comment.rs:41:5
+   |
+LL |     // SAFETY: unnecessary
+   |     ^^^^^^^^^^^^^^^^^^^^^^
+
+error: statement has unnecessary safety comment
+  --> $DIR/unnecessary_safety_comment.rs:45:5
+   |
+LL |     if num > 24 {}
+   |     ^^^^^^^^^^^^^^
+   |
+help: consider removing the safety comment
+  --> $DIR/unnecessary_safety_comment.rs:44:5
+   |
+LL |     // SAFETY: unnecessary
+   |     ^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 9 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From bbcc260b6feecdeadd2b366cc8f021cc3404c9ec Mon Sep 17 00:00:00 2001
From: dswij <dswijj@gmail.com>
Date: Fri, 25 Nov 2022 18:04:17 +0800
Subject: `manual_let_else`: keep macro call on suggestion blocks

---
 clippy_lints/src/manual_let_else.rs | 30 +++++++++++++++++-------------
 1 file changed, 17 insertions(+), 13 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_let_else.rs b/clippy_lints/src/manual_let_else.rs
index 20f06830952..91f0dc2a717 100644
--- a/clippy_lints/src/manual_let_else.rs
+++ b/clippy_lints/src/manual_let_else.rs
@@ -2,7 +2,7 @@ use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::higher::IfLetOrMatch;
 use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::peel_blocks;
-use clippy_utils::source::snippet_opt;
+use clippy_utils::source::{snippet, snippet_with_macro_callsite};
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::visitors::{for_each_expr, Descend};
 use if_chain::if_chain;
@@ -143,18 +143,22 @@ fn emit_manual_let_else(cx: &LateContext<'_>, span: Span, expr: &Expr<'_>, pat:
             // for this to be machine applicable.
             let app = Applicability::HasPlaceholders;
 
-            if let Some(sn_pat) = snippet_opt(cx, pat.span) &&
-                let Some(sn_expr) = snippet_opt(cx, expr.span) &&
-                let Some(sn_else) = snippet_opt(cx, else_body.span)
-            {
-                let else_bl = if matches!(else_body.kind, ExprKind::Block(..)) {
-                    sn_else
-                } else {
-                    format!("{{ {sn_else} }}")
-                };
-                let sugg = format!("let {sn_pat} = {sn_expr} else {else_bl};");
-                diag.span_suggestion(span, "consider writing", sugg, app);
-            }
+            let snippet_fn = if span.from_expansion() {
+                snippet
+            } else {
+                snippet_with_macro_callsite
+            };
+            let sn_pat = snippet_fn(cx, pat.span, "");
+            let sn_expr = snippet_fn(cx, expr.span, "");
+            let sn_else = snippet_fn(cx, else_body.span, "");
+
+            let else_bl = if matches!(else_body.kind, ExprKind::Block(..)) {
+                sn_else.into_owned()
+            } else {
+                format!("{{ {sn_else} }}")
+            };
+            let sugg = format!("let {sn_pat} = {sn_expr} else {else_bl};");
+            diag.span_suggestion(span, "consider writing", sugg, app);
         },
     );
 }
-- 
cgit 1.4.1-3-g733a5


From 5610d22c8d58d12748308efb6e331e65618d11dc Mon Sep 17 00:00:00 2001
From: kraktus <kraktus@users.noreply.github.com>
Date: Fri, 25 Nov 2022 16:36:22 +0100
Subject: Re-enable `uninlined_format_args` on multiline `format!`

But do not display the code suggestion which can be sometimes completely broken (fortunately when applied it's valid)
---
 clippy_lints/src/format_args.rs       | 19 +++++++++++++------
 tests/ui/uninlined_format_args.fixed  | 11 +++--------
 tests/ui/uninlined_format_args.stderr | 31 ++++++++++++++++++++++++++++++-
 3 files changed, 46 insertions(+), 15 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/format_args.rs b/clippy_lints/src/format_args.rs
index ec45be558f1..fd3ce2f3d6c 100644
--- a/clippy_lints/src/format_args.rs
+++ b/clippy_lints/src/format_args.rs
@@ -9,7 +9,10 @@ use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::{implements_trait, is_type_diagnostic_item};
 use if_chain::if_chain;
 use itertools::Itertools;
-use rustc_errors::Applicability;
+use rustc_errors::{
+    Applicability,
+    SuggestionStyle::{CompletelyHidden, ShowCode},
+};
 use rustc_hir::{Expr, ExprKind, HirId, QPath};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::ty::adjustment::{Adjust, Adjustment};
@@ -286,10 +289,9 @@ fn check_uninlined_args(cx: &LateContext<'_>, args: &FormatArgsExpn<'_>, call_si
         return;
     }
 
-    // Temporarily ignore multiline spans: https://github.com/rust-lang/rust/pull/102729#discussion_r988704308
-    if fixes.iter().any(|(span, _)| cx.sess().source_map().is_multiline(*span)) {
-        return;
-    }
+    // multiline span display suggestion is sometimes broken: https://github.com/rust-lang/rust/pull/102729#discussion_r988704308
+    // in those cases, make the code suggestion hidden
+    let multiline_fix = fixes.iter().any(|(span, _)| cx.sess().source_map().is_multiline(*span));
 
     span_lint_and_then(
         cx,
@@ -297,7 +299,12 @@ fn check_uninlined_args(cx: &LateContext<'_>, args: &FormatArgsExpn<'_>, call_si
         call_site,
         "variables can be used directly in the `format!` string",
         |diag| {
-            diag.multipart_suggestion("change this to", fixes, Applicability::MachineApplicable);
+            diag.multipart_suggestion_with_style(
+                "change this to",
+                fixes,
+                Applicability::MachineApplicable,
+                if multiline_fix { CompletelyHidden } else { ShowCode },
+            );
         },
     );
 }
diff --git a/tests/ui/uninlined_format_args.fixed b/tests/ui/uninlined_format_args.fixed
index 10627447975..ca56c95c23f 100644
--- a/tests/ui/uninlined_format_args.fixed
+++ b/tests/ui/uninlined_format_args.fixed
@@ -44,9 +44,7 @@ fn tester(fn_arg: i32) {
     println!("val='{local_i32}'"); // space+tab
     println!("val='{local_i32}'"); // tab+space
     println!(
-        "val='{
-    }'",
-        local_i32
+        "val='{local_i32}'"
     );
     println!("{local_i32}");
     println!("{fn_arg}");
@@ -110,8 +108,7 @@ fn tester(fn_arg: i32) {
     println!("{local_f64:width$.prec$}");
     println!("{local_f64:width$.prec$} {local_f64} {width} {prec}");
     println!(
-        "{0:1$.2$} {0:2$.1$} {1:0$.2$} {1:2$.0$} {2:0$.1$} {2:1$.0$}",
-        local_i32, width, prec,
+        "{local_i32:width$.prec$} {local_i32:prec$.width$} {width:local_i32$.prec$} {width:prec$.local_i32$} {prec:local_i32$.width$} {prec:width$.local_i32$}",
     );
     println!(
         "{0:1$.2$} {0:2$.1$} {1:0$.2$} {1:2$.0$} {2:0$.1$} {2:1$.0$} {3}",
@@ -142,9 +139,7 @@ fn tester(fn_arg: i32) {
     println!(no_param_str!(), local_i32);
 
     println!(
-        "{}",
-        // comment with a comma , in it
-        val,
+        "{val}",
     );
     println!("{val}");
 
diff --git a/tests/ui/uninlined_format_args.stderr b/tests/ui/uninlined_format_args.stderr
index 2ce3b7fa960..1182d57ce9b 100644
--- a/tests/ui/uninlined_format_args.stderr
+++ b/tests/ui/uninlined_format_args.stderr
@@ -59,6 +59,16 @@ LL -     println!("val='{     }'", local_i32); // tab+space
 LL +     println!("val='{local_i32}'"); // tab+space
    |
 
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:46:5
+   |
+LL | /     println!(
+LL | |         "val='{
+LL | |     }'",
+LL | |         local_i32
+LL | |     );
+   | |_____^
+
 error: variables can be used directly in the `format!` string
   --> $DIR/uninlined_format_args.rs:51:5
    |
@@ -767,6 +777,15 @@ LL -     println!("{:1$.2$} {0} {1} {2}", local_f64, width, prec);
 LL +     println!("{local_f64:width$.prec$} {local_f64} {width} {prec}");
    |
 
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:112:5
+   |
+LL | /     println!(
+LL | |         "{0:1$.2$} {0:2$.1$} {1:0$.2$} {1:2$.0$} {2:0$.1$} {2:1$.0$}",
+LL | |         local_i32, width, prec,
+LL | |     );
+   | |_____^
+
 error: variables can be used directly in the `format!` string
   --> $DIR/uninlined_format_args.rs:123:5
    |
@@ -815,6 +834,16 @@ LL -     println!("{}", format!("{}", local_i32));
 LL +     println!("{}", format!("{local_i32}"));
    |
 
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:144:5
+   |
+LL | /     println!(
+LL | |         "{}",
+LL | |         // comment with a comma , in it
+LL | |         val,
+LL | |     );
+   | |_____^
+
 error: variables can be used directly in the `format!` string
   --> $DIR/uninlined_format_args.rs:149:5
    |
@@ -875,5 +904,5 @@ LL -     println!("expand='{}'", local_i32);
 LL +     println!("expand='{local_i32}'");
    |
 
-error: aborting due to 73 previous errors
+error: aborting due to 76 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 93b5c893e6394104b5ae80cf42d7220ad3d18779 Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukastw97@gmail.com>
Date: Thu, 10 Nov 2022 13:19:15 +0100
Subject: Add semicolon-outside/inside-block lints

---
 CHANGELOG.md                            |   2 +
 clippy_lints/src/declared_lints.rs      |   2 +
 clippy_lints/src/lib.rs                 |   2 +
 clippy_lints/src/semicolon_block.rs     | 131 ++++++++++++++++++++++++++++++++
 tests/ui/semicolon_inside_block.fixed   |  83 ++++++++++++++++++++
 tests/ui/semicolon_inside_block.rs      |  83 ++++++++++++++++++++
 tests/ui/semicolon_inside_block.stderr  |  39 ++++++++++
 tests/ui/semicolon_outside_block.fixed  |  83 ++++++++++++++++++++
 tests/ui/semicolon_outside_block.rs     |  83 ++++++++++++++++++++
 tests/ui/semicolon_outside_block.stderr |  39 ++++++++++
 10 files changed, 547 insertions(+)
 create mode 100644 clippy_lints/src/semicolon_block.rs
 create mode 100644 tests/ui/semicolon_inside_block.fixed
 create mode 100644 tests/ui/semicolon_inside_block.rs
 create mode 100644 tests/ui/semicolon_inside_block.stderr
 create mode 100644 tests/ui/semicolon_outside_block.fixed
 create mode 100644 tests/ui/semicolon_outside_block.rs
 create mode 100644 tests/ui/semicolon_outside_block.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5b6b12c623a..dac4a54b11f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4353,6 +4353,8 @@ Released 2018-09-13
 [`self_named_constructors`]: https://rust-lang.github.io/rust-clippy/master/index.html#self_named_constructors
 [`self_named_module_files`]: https://rust-lang.github.io/rust-clippy/master/index.html#self_named_module_files
 [`semicolon_if_nothing_returned`]: https://rust-lang.github.io/rust-clippy/master/index.html#semicolon_if_nothing_returned
+[`semicolon_inside_block`]: https://rust-lang.github.io/rust-clippy/master/index.html#semicolon_inside_block
+[`semicolon_outside_block`]: https://rust-lang.github.io/rust-clippy/master/index.html#semicolon_outside_block
 [`separated_literal_suffix`]: https://rust-lang.github.io/rust-clippy/master/index.html#separated_literal_suffix
 [`serde_api_misuse`]: https://rust-lang.github.io/rust-clippy/master/index.html#serde_api_misuse
 [`shadow_reuse`]: https://rust-lang.github.io/rust-clippy/master/index.html#shadow_reuse
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index eb3210946f1..76b4a2ccf5e 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -525,6 +525,8 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::returns::NEEDLESS_RETURN_INFO,
     crate::same_name_method::SAME_NAME_METHOD_INFO,
     crate::self_named_constructors::SELF_NAMED_CONSTRUCTORS_INFO,
+    crate::semicolon_block::SEMICOLON_INSIDE_BLOCK_INFO,
+    crate::semicolon_block::SEMICOLON_OUTSIDE_BLOCK_INFO,
     crate::semicolon_if_nothing_returned::SEMICOLON_IF_NOTHING_RETURNED_INFO,
     crate::serde_api::SERDE_API_MISUSE_INFO,
     crate::shadow::SHADOW_REUSE_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 17dbd983b6c..cbca317a146 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -257,6 +257,7 @@ mod return_self_not_must_use;
 mod returns;
 mod same_name_method;
 mod self_named_constructors;
+mod semicolon_block;
 mod semicolon_if_nothing_returned;
 mod serde_api;
 mod shadow;
@@ -884,6 +885,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(from_raw_with_void_ptr::FromRawWithVoidPtr));
     store.register_late_pass(|_| Box::new(suspicious_xor_used_as_pow::ConfusingXorAndPow));
     store.register_late_pass(move |_| Box::new(manual_is_ascii_check::ManualIsAsciiCheck::new(msrv())));
+    store.register_late_pass(|_| Box::new(semicolon_block::SemicolonBlock));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/semicolon_block.rs b/clippy_lints/src/semicolon_block.rs
new file mode 100644
index 00000000000..911d38f65d6
--- /dev/null
+++ b/clippy_lints/src/semicolon_block.rs
@@ -0,0 +1,131 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet_with_macro_callsite;
+use clippy_utils::{get_parent_expr_for_hir, get_parent_node};
+use rustc_errors::Applicability;
+use rustc_hir::{Block, Expr, ExprKind, Node, Stmt, StmtKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// ### What it does
+    ///
+    /// For () returning expressions, check that the semicolon is inside the block.
+    ///
+    /// ### Why is this bad?
+    ///
+    /// For consistency it's best to have the semicolon inside/outside the block. Either way is fine and this lint suggests inside the block.
+    /// Take a look at `semicolon_outside_block` for the other alternative.
+    ///
+    /// ### Example
+    ///
+    /// ```rust
+    /// # fn f(_: u32) {}
+    /// # let x = 0;
+    /// unsafe { f(x) };
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// # fn f(_: u32) {}
+    /// # let x = 0;
+    /// unsafe { f(x); }
+    /// ```
+    #[clippy::version = "1.66.0"]
+    pub SEMICOLON_INSIDE_BLOCK,
+    restriction,
+    "add a semicolon inside the block"
+}
+declare_clippy_lint! {
+    /// ### What it does
+    ///
+    /// For () returning expressions, check that the semicolon is outside the block.
+    ///
+    /// ### Why is this bad?
+    ///
+    /// For consistency it's best to have the semicolon inside/outside the block. Either way is fine and this lint suggests outside the block.
+    /// Take a look at `semicolon_inside_block` for the other alternative.
+    ///
+    /// ### Example
+    ///
+    /// ```rust
+    /// # fn f(_: u32) {}
+    /// # let x = 0;
+    /// unsafe { f(x); }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// # fn f(_: u32) {}
+    /// # let x = 0;
+    /// unsafe { f(x) };
+    /// ```
+    #[clippy::version = "1.66.0"]
+    pub SEMICOLON_OUTSIDE_BLOCK,
+    restriction,
+    "add a semicolon outside the block"
+}
+declare_lint_pass!(SemicolonBlock => [SEMICOLON_INSIDE_BLOCK, SEMICOLON_OUTSIDE_BLOCK]);
+
+impl LateLintPass<'_> for SemicolonBlock {
+    fn check_block(&mut self, cx: &LateContext<'_>, block: &Block<'_>) {
+        semicolon_inside_block(cx, block);
+        semicolon_outside_block(cx, block);
+    }
+}
+
+fn semicolon_inside_block(cx: &LateContext<'_>, block: &Block<'_>) {
+    if !block.span.from_expansion()
+    && let Some(tail) = block.expr
+    && let Some(block_expr @ Expr { kind: ExprKind::Block(_, _), ..}) = get_parent_expr_for_hir(cx, block.hir_id)
+    && let Some(Node::Stmt(Stmt { kind: StmtKind::Semi(_), span, .. })) = get_parent_node(cx.tcx, block_expr.hir_id)
+    {
+        let expr_snip = snippet_with_macro_callsite(cx, tail.span, "..");
+
+        let mut suggestion: String = snippet_with_macro_callsite(cx, block.span, "..").to_string();
+
+        if let Some((expr_offset, _)) = suggestion.rmatch_indices(&*expr_snip).next() {
+            suggestion.insert(expr_offset + expr_snip.len(), ';');
+        } else {
+            return;
+        }
+
+        span_lint_and_sugg(
+            cx,
+            SEMICOLON_INSIDE_BLOCK,
+            *span,
+            "consider moving the `;` inside the block for consistent formatting",
+            "put the `;` here",
+            suggestion,
+            Applicability::MaybeIncorrect,
+        );
+    }
+}
+
+fn semicolon_outside_block(cx: &LateContext<'_>, block: &Block<'_>) {
+    if !block.span.from_expansion()
+    && block.expr.is_none()
+    && let [.., Stmt { kind: StmtKind::Semi(expr), .. }] = block.stmts
+    && let Some(block_expr @ Expr { kind: ExprKind::Block(_, _), ..}) = get_parent_expr_for_hir(cx,block.hir_id)
+    && let Some(Node::Stmt(Stmt { kind: StmtKind::Expr(_), .. })) = get_parent_node(cx.tcx, block_expr.hir_id) {
+        let expr_snip = snippet_with_macro_callsite(cx, expr.span, "..");
+
+        let mut suggestion: String = snippet_with_macro_callsite(cx, block.span, "..").to_string();
+
+        if let Some((expr_offset, _)) = suggestion.rmatch_indices(&*expr_snip).next()
+        && let Some(semi_offset) = suggestion[expr_offset + expr_snip.len()..].find(';') {
+            suggestion.remove(expr_offset +  expr_snip.len() + semi_offset);
+        } else {
+            return;
+        }
+
+        suggestion.push(';');
+
+        span_lint_and_sugg(
+            cx,
+            SEMICOLON_OUTSIDE_BLOCK,
+            block.span,
+            "consider moving the `;` outside the block for consistent formatting",
+            "put the `;` outside the block",
+            suggestion,
+            Applicability::MaybeIncorrect,
+        );
+    }
+}
diff --git a/tests/ui/semicolon_inside_block.fixed b/tests/ui/semicolon_inside_block.fixed
new file mode 100644
index 00000000000..4cd112dd5e1
--- /dev/null
+++ b/tests/ui/semicolon_inside_block.fixed
@@ -0,0 +1,83 @@
+// run-rustfix
+#![allow(
+    unused,
+    clippy::unused_unit,
+    clippy::unnecessary_operation,
+    clippy::no_effect,
+    clippy::single_element_loop
+)]
+#![warn(clippy::semicolon_inside_block)]
+
+macro_rules! m {
+    (()) => {
+        ()
+    };
+    (0) => {{
+        0
+    };};
+    (1) => {{
+        1;
+    }};
+    (2) => {{
+        2;
+    }};
+}
+
+fn unit_fn_block() {
+    ()
+}
+
+#[rustfmt::skip]
+fn main() {
+    { unit_fn_block() }
+    unsafe { unit_fn_block() }
+
+    {
+        unit_fn_block()
+    }
+
+    { unit_fn_block(); }
+    unsafe { unit_fn_block(); }
+
+    { unit_fn_block(); }
+    unsafe { unit_fn_block(); }
+
+    { unit_fn_block(); };
+    unsafe { unit_fn_block(); };
+
+    {
+        unit_fn_block();
+        unit_fn_block();
+    }
+    {
+        unit_fn_block();
+        unit_fn_block();
+    }
+    {
+        unit_fn_block();
+        unit_fn_block();
+    };
+
+    { m!(()); }
+    { m!(()); }
+    { m!(()); };
+    m!(0);
+    m!(1);
+    m!(2);
+
+    for _ in [()] {
+        unit_fn_block();
+    }
+    for _ in [()] {
+        unit_fn_block()
+    }
+
+    let _d = || {
+        unit_fn_block();
+    };
+    let _d = || {
+        unit_fn_block()
+    };
+
+    unit_fn_block()
+}
diff --git a/tests/ui/semicolon_inside_block.rs b/tests/ui/semicolon_inside_block.rs
new file mode 100644
index 00000000000..7512125c051
--- /dev/null
+++ b/tests/ui/semicolon_inside_block.rs
@@ -0,0 +1,83 @@
+// run-rustfix
+#![allow(
+    unused,
+    clippy::unused_unit,
+    clippy::unnecessary_operation,
+    clippy::no_effect,
+    clippy::single_element_loop
+)]
+#![warn(clippy::semicolon_inside_block)]
+
+macro_rules! m {
+    (()) => {
+        ()
+    };
+    (0) => {{
+        0
+    };};
+    (1) => {{
+        1;
+    }};
+    (2) => {{
+        2;
+    }};
+}
+
+fn unit_fn_block() {
+    ()
+}
+
+#[rustfmt::skip]
+fn main() {
+    { unit_fn_block() }
+    unsafe { unit_fn_block() }
+
+    {
+        unit_fn_block()
+    }
+
+    { unit_fn_block() };
+    unsafe { unit_fn_block() };
+
+    { unit_fn_block(); }
+    unsafe { unit_fn_block(); }
+
+    { unit_fn_block(); };
+    unsafe { unit_fn_block(); };
+
+    {
+        unit_fn_block();
+        unit_fn_block()
+    };
+    {
+        unit_fn_block();
+        unit_fn_block();
+    }
+    {
+        unit_fn_block();
+        unit_fn_block();
+    };
+
+    { m!(()) };
+    { m!(()); }
+    { m!(()); };
+    m!(0);
+    m!(1);
+    m!(2);
+
+    for _ in [()] {
+        unit_fn_block();
+    }
+    for _ in [()] {
+        unit_fn_block()
+    }
+
+    let _d = || {
+        unit_fn_block();
+    };
+    let _d = || {
+        unit_fn_block()
+    };
+
+    unit_fn_block()
+}
diff --git a/tests/ui/semicolon_inside_block.stderr b/tests/ui/semicolon_inside_block.stderr
new file mode 100644
index 00000000000..febe74b49bd
--- /dev/null
+++ b/tests/ui/semicolon_inside_block.stderr
@@ -0,0 +1,39 @@
+error: consider moving the `;` inside the block for consistent formatting
+  --> $DIR/semicolon_inside_block.rs:39:5
+   |
+LL |     { unit_fn_block() };
+   |     ^^^^^^^^^^^^^^^^^^^^ help: put the `;` here: `{ unit_fn_block(); }`
+   |
+   = note: `-D clippy::semicolon-inside-block` implied by `-D warnings`
+
+error: consider moving the `;` inside the block for consistent formatting
+  --> $DIR/semicolon_inside_block.rs:40:5
+   |
+LL |     unsafe { unit_fn_block() };
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: put the `;` here: `unsafe { unit_fn_block(); }`
+
+error: consider moving the `;` inside the block for consistent formatting
+  --> $DIR/semicolon_inside_block.rs:48:5
+   |
+LL | /     {
+LL | |         unit_fn_block();
+LL | |         unit_fn_block()
+LL | |     };
+   | |______^
+   |
+help: put the `;` here
+   |
+LL ~     {
+LL +         unit_fn_block();
+LL +         unit_fn_block();
+LL +     }
+   |
+
+error: consider moving the `;` inside the block for consistent formatting
+  --> $DIR/semicolon_inside_block.rs:61:5
+   |
+LL |     { m!(()) };
+   |     ^^^^^^^^^^^ help: put the `;` here: `{ m!(()); }`
+
+error: aborting due to 4 previous errors
+
diff --git a/tests/ui/semicolon_outside_block.fixed b/tests/ui/semicolon_outside_block.fixed
new file mode 100644
index 00000000000..5bc18faaad8
--- /dev/null
+++ b/tests/ui/semicolon_outside_block.fixed
@@ -0,0 +1,83 @@
+// run-rustfix
+#![allow(
+    unused,
+    clippy::unused_unit,
+    clippy::unnecessary_operation,
+    clippy::no_effect,
+    clippy::single_element_loop
+)]
+#![warn(clippy::semicolon_outside_block)]
+
+macro_rules! m {
+    (()) => {
+        ()
+    };
+    (0) => {{
+        0
+    };};
+    (1) => {{
+        1;
+    }};
+    (2) => {{
+        2;
+    }};
+}
+
+fn unit_fn_block() {
+    ()
+}
+
+#[rustfmt::skip]
+fn main() {
+    { unit_fn_block() }
+    unsafe { unit_fn_block() }
+
+    {
+        unit_fn_block()
+    }
+
+    { unit_fn_block() };
+    unsafe { unit_fn_block() };
+
+    { unit_fn_block() };
+    unsafe { unit_fn_block() };
+
+    { unit_fn_block(); };
+    unsafe { unit_fn_block(); };
+
+    {
+        unit_fn_block();
+        unit_fn_block()
+    };
+    {
+        unit_fn_block();
+        unit_fn_block()
+    };
+    {
+        unit_fn_block();
+        unit_fn_block();
+    };
+
+    { m!(()) };
+    { m!(()) };
+    { m!(()); };
+    m!(0);
+    m!(1);
+    m!(2);
+
+    for _ in [()] {
+        unit_fn_block();
+    }
+    for _ in [()] {
+        unit_fn_block()
+    }
+
+    let _d = || {
+        unit_fn_block();
+    };
+    let _d = || {
+        unit_fn_block()
+    };
+
+    unit_fn_block()
+}
diff --git a/tests/ui/semicolon_outside_block.rs b/tests/ui/semicolon_outside_block.rs
new file mode 100644
index 00000000000..0a429323876
--- /dev/null
+++ b/tests/ui/semicolon_outside_block.rs
@@ -0,0 +1,83 @@
+// run-rustfix
+#![allow(
+    unused,
+    clippy::unused_unit,
+    clippy::unnecessary_operation,
+    clippy::no_effect,
+    clippy::single_element_loop
+)]
+#![warn(clippy::semicolon_outside_block)]
+
+macro_rules! m {
+    (()) => {
+        ()
+    };
+    (0) => {{
+        0
+    };};
+    (1) => {{
+        1;
+    }};
+    (2) => {{
+        2;
+    }};
+}
+
+fn unit_fn_block() {
+    ()
+}
+
+#[rustfmt::skip]
+fn main() {
+    { unit_fn_block() }
+    unsafe { unit_fn_block() }
+
+    {
+        unit_fn_block()
+    }
+
+    { unit_fn_block() };
+    unsafe { unit_fn_block() };
+
+    { unit_fn_block(); }
+    unsafe { unit_fn_block(); }
+
+    { unit_fn_block(); };
+    unsafe { unit_fn_block(); };
+
+    {
+        unit_fn_block();
+        unit_fn_block()
+    };
+    {
+        unit_fn_block();
+        unit_fn_block();
+    }
+    {
+        unit_fn_block();
+        unit_fn_block();
+    };
+
+    { m!(()) };
+    { m!(()); }
+    { m!(()); };
+    m!(0);
+    m!(1);
+    m!(2);
+
+    for _ in [()] {
+        unit_fn_block();
+    }
+    for _ in [()] {
+        unit_fn_block()
+    }
+
+    let _d = || {
+        unit_fn_block();
+    };
+    let _d = || {
+        unit_fn_block()
+    };
+
+    unit_fn_block()
+}
diff --git a/tests/ui/semicolon_outside_block.stderr b/tests/ui/semicolon_outside_block.stderr
new file mode 100644
index 00000000000..fddf5120813
--- /dev/null
+++ b/tests/ui/semicolon_outside_block.stderr
@@ -0,0 +1,39 @@
+error: consider moving the `;` outside the block for consistent formatting
+  --> $DIR/semicolon_outside_block.rs:42:5
+   |
+LL |     { unit_fn_block(); }
+   |     ^^^^^^^^^^^^^^^^^^^^ help: put the `;` outside the block: `{ unit_fn_block() };`
+   |
+   = note: `-D clippy::semicolon-outside-block` implied by `-D warnings`
+
+error: consider moving the `;` outside the block for consistent formatting
+  --> $DIR/semicolon_outside_block.rs:43:5
+   |
+LL |     unsafe { unit_fn_block(); }
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: put the `;` outside the block: `unsafe { unit_fn_block() };`
+
+error: consider moving the `;` outside the block for consistent formatting
+  --> $DIR/semicolon_outside_block.rs:52:5
+   |
+LL | /     {
+LL | |         unit_fn_block();
+LL | |         unit_fn_block();
+LL | |     }
+   | |_____^
+   |
+help: put the `;` outside the block
+   |
+LL ~     {
+LL +         unit_fn_block();
+LL +         unit_fn_block()
+LL +     };
+   |
+
+error: consider moving the `;` outside the block for consistent formatting
+  --> $DIR/semicolon_outside_block.rs:62:5
+   |
+LL |     { m!(()); }
+   |     ^^^^^^^^^^^ help: put the `;` outside the block: `{ m!(()) };`
+
+error: aborting due to 4 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From ba951e3ca72283d39757bd39d20bfd75ce901147 Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukastw97@gmail.com>
Date: Tue, 15 Nov 2022 18:29:43 +0100
Subject: Fix formatting of let chains

---
 clippy_lints/src/semicolon_block.rs | 18 ++++++++++--------
 1 file changed, 10 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/semicolon_block.rs b/clippy_lints/src/semicolon_block.rs
index 911d38f65d6..a41f89a6aa3 100644
--- a/clippy_lints/src/semicolon_block.rs
+++ b/clippy_lints/src/semicolon_block.rs
@@ -73,9 +73,9 @@ impl LateLintPass<'_> for SemicolonBlock {
 
 fn semicolon_inside_block(cx: &LateContext<'_>, block: &Block<'_>) {
     if !block.span.from_expansion()
-    && let Some(tail) = block.expr
-    && let Some(block_expr @ Expr { kind: ExprKind::Block(_, _), ..}) = get_parent_expr_for_hir(cx, block.hir_id)
-    && let Some(Node::Stmt(Stmt { kind: StmtKind::Semi(_), span, .. })) = get_parent_node(cx.tcx, block_expr.hir_id)
+        && let Some(tail) = block.expr
+        && let Some(block_expr @ Expr { kind: ExprKind::Block(_, _), ..}) = get_parent_expr_for_hir(cx, block.hir_id)
+        && let Some(Node::Stmt(Stmt { kind: StmtKind::Semi(_), span, .. })) = get_parent_node(cx.tcx, block_expr.hir_id)
     {
         let expr_snip = snippet_with_macro_callsite(cx, tail.span, "..");
 
@@ -101,16 +101,18 @@ fn semicolon_inside_block(cx: &LateContext<'_>, block: &Block<'_>) {
 
 fn semicolon_outside_block(cx: &LateContext<'_>, block: &Block<'_>) {
     if !block.span.from_expansion()
-    && block.expr.is_none()
-    && let [.., Stmt { kind: StmtKind::Semi(expr), .. }] = block.stmts
-    && let Some(block_expr @ Expr { kind: ExprKind::Block(_, _), ..}) = get_parent_expr_for_hir(cx,block.hir_id)
-    && let Some(Node::Stmt(Stmt { kind: StmtKind::Expr(_), .. })) = get_parent_node(cx.tcx, block_expr.hir_id) {
+        && block.expr.is_none()
+        && let [.., Stmt { kind: StmtKind::Semi(expr), .. }] = block.stmts
+        && let Some(block_expr @ Expr { kind: ExprKind::Block(_, _), ..}) = get_parent_expr_for_hir(cx,block.hir_id)
+        && let Some(Node::Stmt(Stmt { kind: StmtKind::Expr(_), .. })) = get_parent_node(cx.tcx, block_expr.hir_id)
+    {
         let expr_snip = snippet_with_macro_callsite(cx, expr.span, "..");
 
         let mut suggestion: String = snippet_with_macro_callsite(cx, block.span, "..").to_string();
 
         if let Some((expr_offset, _)) = suggestion.rmatch_indices(&*expr_snip).next()
-        && let Some(semi_offset) = suggestion[expr_offset + expr_snip.len()..].find(';') {
+            && let Some(semi_offset) = suggestion[expr_offset + expr_snip.len()..].find(';')
+        {
             suggestion.remove(expr_offset +  expr_snip.len() + semi_offset);
         } else {
             return;
-- 
cgit 1.4.1-3-g733a5


From 23744cd4ba57d2fc5c57459002282fe2d896193b Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukastw97@gmail.com>
Date: Tue, 15 Nov 2022 19:22:00 +0100
Subject: Use multi-span suggestions

---
 clippy_lints/src/semicolon_block.rs     | 127 ++++++++++++++++----------------
 tests/ui/semicolon_inside_block.fixed   |   4 +-
 tests/ui/semicolon_inside_block.stderr  |  32 ++++++--
 tests/ui/semicolon_outside_block.fixed  |  14 ++--
 tests/ui/semicolon_outside_block.stderr |  31 ++++++--
 5 files changed, 124 insertions(+), 84 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/semicolon_block.rs b/clippy_lints/src/semicolon_block.rs
index a41f89a6aa3..34bf9744827 100644
--- a/clippy_lints/src/semicolon_block.rs
+++ b/clippy_lints/src/semicolon_block.rs
@@ -1,10 +1,9 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::source::snippet_with_macro_callsite;
-use clippy_utils::{get_parent_expr_for_hir, get_parent_node};
+use clippy_utils::diagnostics::{multispan_sugg_with_applicability, span_lint_and_then};
 use rustc_errors::Applicability;
-use rustc_hir::{Block, Expr, ExprKind, Node, Stmt, StmtKind};
+use rustc_hir::{Block, Expr, ExprKind, Stmt, StmtKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::Span;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -65,69 +64,73 @@ declare_clippy_lint! {
 declare_lint_pass!(SemicolonBlock => [SEMICOLON_INSIDE_BLOCK, SEMICOLON_OUTSIDE_BLOCK]);
 
 impl LateLintPass<'_> for SemicolonBlock {
-    fn check_block(&mut self, cx: &LateContext<'_>, block: &Block<'_>) {
-        semicolon_inside_block(cx, block);
-        semicolon_outside_block(cx, block);
-    }
-}
-
-fn semicolon_inside_block(cx: &LateContext<'_>, block: &Block<'_>) {
-    if !block.span.from_expansion()
-        && let Some(tail) = block.expr
-        && let Some(block_expr @ Expr { kind: ExprKind::Block(_, _), ..}) = get_parent_expr_for_hir(cx, block.hir_id)
-        && let Some(Node::Stmt(Stmt { kind: StmtKind::Semi(_), span, .. })) = get_parent_node(cx.tcx, block_expr.hir_id)
-    {
-        let expr_snip = snippet_with_macro_callsite(cx, tail.span, "..");
-
-        let mut suggestion: String = snippet_with_macro_callsite(cx, block.span, "..").to_string();
-
-        if let Some((expr_offset, _)) = suggestion.rmatch_indices(&*expr_snip).next() {
-            suggestion.insert(expr_offset + expr_snip.len(), ';');
-        } else {
-            return;
+    fn check_stmt(&mut self, cx: &LateContext<'_>, stmt: &Stmt<'_>) {
+        match stmt.kind {
+            StmtKind::Expr(Expr {
+                kind:
+                    ExprKind::Block(
+                        block @ Block {
+                            expr: None,
+                            stmts:
+                                &[
+                                    ..,
+                                    Stmt {
+                                        kind: StmtKind::Semi(expr),
+                                        span,
+                                        ..
+                                    },
+                                ],
+                            ..
+                        },
+                        _,
+                    ),
+                ..
+            }) if !block.span.from_expansion() => semicolon_outside_block(cx, block, expr, span),
+            StmtKind::Semi(Expr {
+                kind: ExprKind::Block(block @ Block { expr: Some(tail), .. }, _),
+                ..
+            }) if !block.span.from_expansion() => semicolon_inside_block(cx, block, tail, stmt.span),
+            _ => (),
         }
-
-        span_lint_and_sugg(
-            cx,
-            SEMICOLON_INSIDE_BLOCK,
-            *span,
-            "consider moving the `;` inside the block for consistent formatting",
-            "put the `;` here",
-            suggestion,
-            Applicability::MaybeIncorrect,
-        );
     }
 }
 
-fn semicolon_outside_block(cx: &LateContext<'_>, block: &Block<'_>) {
-    if !block.span.from_expansion()
-        && block.expr.is_none()
-        && let [.., Stmt { kind: StmtKind::Semi(expr), .. }] = block.stmts
-        && let Some(block_expr @ Expr { kind: ExprKind::Block(_, _), ..}) = get_parent_expr_for_hir(cx,block.hir_id)
-        && let Some(Node::Stmt(Stmt { kind: StmtKind::Expr(_), .. })) = get_parent_node(cx.tcx, block_expr.hir_id)
-    {
-        let expr_snip = snippet_with_macro_callsite(cx, expr.span, "..");
-
-        let mut suggestion: String = snippet_with_macro_callsite(cx, block.span, "..").to_string();
+fn semicolon_inside_block(cx: &LateContext<'_>, block: &Block<'_>, tail: &Expr<'_>, semi_span: Span) {
+    let insert_span = tail.span.with_lo(tail.span.hi());
+    let remove_span = semi_span.with_lo(block.span.hi());
 
-        if let Some((expr_offset, _)) = suggestion.rmatch_indices(&*expr_snip).next()
-            && let Some(semi_offset) = suggestion[expr_offset + expr_snip.len()..].find(';')
-        {
-            suggestion.remove(expr_offset +  expr_snip.len() + semi_offset);
-        } else {
-            return;
-        }
+    span_lint_and_then(
+        cx,
+        SEMICOLON_INSIDE_BLOCK,
+        semi_span,
+        "consider moving the `;` inside the block for consistent formatting",
+        |diag| {
+            multispan_sugg_with_applicability(
+                diag,
+                "put the `;` here",
+                Applicability::MachineApplicable,
+                [(remove_span, String::new()), (insert_span, ";".to_owned())],
+            );
+        },
+    );
+}
 
-        suggestion.push(';');
+fn semicolon_outside_block(cx: &LateContext<'_>, block: &Block<'_>, tail_stmt_expr: &Expr<'_>, semi_span: Span) {
+    let insert_span = block.span.with_lo(block.span.hi());
+    let remove_span = semi_span.with_lo(tail_stmt_expr.span.source_callsite().hi());
 
-        span_lint_and_sugg(
-            cx,
-            SEMICOLON_OUTSIDE_BLOCK,
-            block.span,
-            "consider moving the `;` outside the block for consistent formatting",
-            "put the `;` outside the block",
-            suggestion,
-            Applicability::MaybeIncorrect,
-        );
-    }
+    span_lint_and_then(
+        cx,
+        SEMICOLON_OUTSIDE_BLOCK,
+        block.span,
+        "consider moving the `;` outside the block for consistent formatting",
+        |diag| {
+            multispan_sugg_with_applicability(
+                diag,
+                "put the `;` here",
+                Applicability::MachineApplicable,
+                [(remove_span, String::new()), (insert_span, ";".to_owned())],
+            );
+        },
+    );
 }
diff --git a/tests/ui/semicolon_inside_block.fixed b/tests/ui/semicolon_inside_block.fixed
index 4cd112dd5e1..d2cd8b21882 100644
--- a/tests/ui/semicolon_inside_block.fixed
+++ b/tests/ui/semicolon_inside_block.fixed
@@ -10,7 +10,7 @@
 
 macro_rules! m {
     (()) => {
-        ()
+        ();
     };
     (0) => {{
         0
@@ -58,7 +58,7 @@ fn main() {
         unit_fn_block();
     };
 
-    { m!(()); }
+    { m!(()) }
     { m!(()); }
     { m!(()); };
     m!(0);
diff --git a/tests/ui/semicolon_inside_block.stderr b/tests/ui/semicolon_inside_block.stderr
index febe74b49bd..99f3b65be0f 100644
--- a/tests/ui/semicolon_inside_block.stderr
+++ b/tests/ui/semicolon_inside_block.stderr
@@ -2,15 +2,26 @@ error: consider moving the `;` inside the block for consistent formatting
   --> $DIR/semicolon_inside_block.rs:39:5
    |
 LL |     { unit_fn_block() };
-   |     ^^^^^^^^^^^^^^^^^^^^ help: put the `;` here: `{ unit_fn_block(); }`
+   |     ^^^^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::semicolon-inside-block` implied by `-D warnings`
+help: put the `;` here
+   |
+LL -     { unit_fn_block() };
+LL +     { unit_fn_block(); }
+   |
 
 error: consider moving the `;` inside the block for consistent formatting
   --> $DIR/semicolon_inside_block.rs:40:5
    |
 LL |     unsafe { unit_fn_block() };
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: put the `;` here: `unsafe { unit_fn_block(); }`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: put the `;` here
+   |
+LL -     unsafe { unit_fn_block() };
+LL +     unsafe { unit_fn_block(); }
+   |
 
 error: consider moving the `;` inside the block for consistent formatting
   --> $DIR/semicolon_inside_block.rs:48:5
@@ -23,17 +34,24 @@ LL | |     };
    |
 help: put the `;` here
    |
-LL ~     {
-LL +         unit_fn_block();
-LL +         unit_fn_block();
-LL +     }
+LL ~         unit_fn_block();
+LL ~     }
    |
 
 error: consider moving the `;` inside the block for consistent formatting
   --> $DIR/semicolon_inside_block.rs:61:5
    |
 LL |     { m!(()) };
-   |     ^^^^^^^^^^^ help: put the `;` here: `{ m!(()); }`
+   |     ^^^^^^^^^^^
+   |
+help: put the `;` here
+   |
+LL ~         ();
+LL |     };
+ ...
+LL | 
+LL ~     { m!(()) }
+   |
 
 error: aborting due to 4 previous errors
 
diff --git a/tests/ui/semicolon_outside_block.fixed b/tests/ui/semicolon_outside_block.fixed
index 5bc18faaad8..35eacfe6d3f 100644
--- a/tests/ui/semicolon_outside_block.fixed
+++ b/tests/ui/semicolon_outside_block.fixed
@@ -21,6 +21,9 @@ macro_rules! m {
     (2) => {{
         2;
     }};
+    (stmt) => {
+        stmt;
+    };
 }
 
 fn unit_fn_block() {
@@ -39,8 +42,8 @@ fn main() {
     { unit_fn_block() };
     unsafe { unit_fn_block() };
 
-    { unit_fn_block() };
-    unsafe { unit_fn_block() };
+    { unit_fn_block(); }
+    unsafe { unit_fn_block(); }
 
     { unit_fn_block(); };
     unsafe { unit_fn_block(); };
@@ -51,19 +54,20 @@ fn main() {
     };
     {
         unit_fn_block();
-        unit_fn_block()
-    };
+        unit_fn_block();
+    }
     {
         unit_fn_block();
         unit_fn_block();
     };
 
     { m!(()) };
-    { m!(()) };
+    { m!(()); }
     { m!(()); };
     m!(0);
     m!(1);
     m!(2);
+    { m!(stmt) };
 
     for _ in [()] {
         unit_fn_block();
diff --git a/tests/ui/semicolon_outside_block.stderr b/tests/ui/semicolon_outside_block.stderr
index fddf5120813..c2151f7af63 100644
--- a/tests/ui/semicolon_outside_block.stderr
+++ b/tests/ui/semicolon_outside_block.stderr
@@ -2,15 +2,26 @@ error: consider moving the `;` outside the block for consistent formatting
   --> $DIR/semicolon_outside_block.rs:42:5
    |
 LL |     { unit_fn_block(); }
-   |     ^^^^^^^^^^^^^^^^^^^^ help: put the `;` outside the block: `{ unit_fn_block() };`
+   |     ^^^^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::semicolon-outside-block` implied by `-D warnings`
+help: put the `;` here
+   |
+LL -     { unit_fn_block(); }
+LL +     { unit_fn_block() };
+   |
 
 error: consider moving the `;` outside the block for consistent formatting
   --> $DIR/semicolon_outside_block.rs:43:5
    |
 LL |     unsafe { unit_fn_block(); }
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: put the `;` outside the block: `unsafe { unit_fn_block() };`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: put the `;` here
+   |
+LL -     unsafe { unit_fn_block(); }
+LL +     unsafe { unit_fn_block() };
+   |
 
 error: consider moving the `;` outside the block for consistent formatting
   --> $DIR/semicolon_outside_block.rs:52:5
@@ -21,19 +32,23 @@ LL | |         unit_fn_block();
 LL | |     }
    | |_____^
    |
-help: put the `;` outside the block
+help: put the `;` here
    |
-LL ~     {
-LL +         unit_fn_block();
-LL +         unit_fn_block()
-LL +     };
+LL ~         unit_fn_block()
+LL ~     };
    |
 
 error: consider moving the `;` outside the block for consistent formatting
   --> $DIR/semicolon_outside_block.rs:62:5
    |
 LL |     { m!(()); }
-   |     ^^^^^^^^^^^ help: put the `;` outside the block: `{ m!(()) };`
+   |     ^^^^^^^^^^^
+   |
+help: put the `;` here
+   |
+LL -         ()
+LL +         (); };
+   |
 
 error: aborting due to 4 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From dd1163f4611d8597d03d2efd569d63a1d82bfd15 Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukastw97@gmail.com>
Date: Wed, 16 Nov 2022 14:30:53 +0100
Subject: Fix macro statement handling

---
 clippy_lints/src/semicolon_block.rs     |  7 +++++--
 tests/ui/semicolon_inside_block.fixed   |  4 ++--
 tests/ui/semicolon_inside_block.stderr  |  7 ++-----
 tests/ui/semicolon_outside_block.fixed  | 14 +++++---------
 tests/ui/semicolon_outside_block.stderr |  4 ++--
 5 files changed, 16 insertions(+), 20 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/semicolon_block.rs b/clippy_lints/src/semicolon_block.rs
index 34bf9744827..57f835d45b1 100644
--- a/clippy_lints/src/semicolon_block.rs
+++ b/clippy_lints/src/semicolon_block.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::{multispan_sugg_with_applicability, span_lint_and_then};
 use rustc_errors::Applicability;
 use rustc_hir::{Block, Expr, ExprKind, Stmt, StmtKind};
-use rustc_lint::{LateContext, LateLintPass};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::Span;
 
@@ -96,7 +96,8 @@ impl LateLintPass<'_> for SemicolonBlock {
 }
 
 fn semicolon_inside_block(cx: &LateContext<'_>, block: &Block<'_>, tail: &Expr<'_>, semi_span: Span) {
-    let insert_span = tail.span.with_lo(tail.span.hi());
+    let tail_span_end = tail.span.source_callsite().hi();
+    let insert_span = Span::with_root_ctxt(tail_span_end, tail_span_end);
     let remove_span = semi_span.with_lo(block.span.hi());
 
     span_lint_and_then(
@@ -117,6 +118,8 @@ fn semicolon_inside_block(cx: &LateContext<'_>, block: &Block<'_>, tail: &Expr<'
 
 fn semicolon_outside_block(cx: &LateContext<'_>, block: &Block<'_>, tail_stmt_expr: &Expr<'_>, semi_span: Span) {
     let insert_span = block.span.with_lo(block.span.hi());
+    // account for macro calls
+    let semi_span = cx.sess().source_map().stmt_span(semi_span, block.span);
     let remove_span = semi_span.with_lo(tail_stmt_expr.span.source_callsite().hi());
 
     span_lint_and_then(
diff --git a/tests/ui/semicolon_inside_block.fixed b/tests/ui/semicolon_inside_block.fixed
index d2cd8b21882..4cd112dd5e1 100644
--- a/tests/ui/semicolon_inside_block.fixed
+++ b/tests/ui/semicolon_inside_block.fixed
@@ -10,7 +10,7 @@
 
 macro_rules! m {
     (()) => {
-        ();
+        ()
     };
     (0) => {{
         0
@@ -58,7 +58,7 @@ fn main() {
         unit_fn_block();
     };
 
-    { m!(()) }
+    { m!(()); }
     { m!(()); }
     { m!(()); };
     m!(0);
diff --git a/tests/ui/semicolon_inside_block.stderr b/tests/ui/semicolon_inside_block.stderr
index 99f3b65be0f..48d3690e2bd 100644
--- a/tests/ui/semicolon_inside_block.stderr
+++ b/tests/ui/semicolon_inside_block.stderr
@@ -46,11 +46,8 @@ LL |     { m!(()) };
    |
 help: put the `;` here
    |
-LL ~         ();
-LL |     };
- ...
-LL | 
-LL ~     { m!(()) }
+LL -     { m!(()) };
+LL +     { m!(()); }
    |
 
 error: aborting due to 4 previous errors
diff --git a/tests/ui/semicolon_outside_block.fixed b/tests/ui/semicolon_outside_block.fixed
index 35eacfe6d3f..5bc18faaad8 100644
--- a/tests/ui/semicolon_outside_block.fixed
+++ b/tests/ui/semicolon_outside_block.fixed
@@ -21,9 +21,6 @@ macro_rules! m {
     (2) => {{
         2;
     }};
-    (stmt) => {
-        stmt;
-    };
 }
 
 fn unit_fn_block() {
@@ -42,8 +39,8 @@ fn main() {
     { unit_fn_block() };
     unsafe { unit_fn_block() };
 
-    { unit_fn_block(); }
-    unsafe { unit_fn_block(); }
+    { unit_fn_block() };
+    unsafe { unit_fn_block() };
 
     { unit_fn_block(); };
     unsafe { unit_fn_block(); };
@@ -54,20 +51,19 @@ fn main() {
     };
     {
         unit_fn_block();
-        unit_fn_block();
-    }
+        unit_fn_block()
+    };
     {
         unit_fn_block();
         unit_fn_block();
     };
 
     { m!(()) };
-    { m!(()); }
+    { m!(()) };
     { m!(()); };
     m!(0);
     m!(1);
     m!(2);
-    { m!(stmt) };
 
     for _ in [()] {
         unit_fn_block();
diff --git a/tests/ui/semicolon_outside_block.stderr b/tests/ui/semicolon_outside_block.stderr
index c2151f7af63..dcc102e6099 100644
--- a/tests/ui/semicolon_outside_block.stderr
+++ b/tests/ui/semicolon_outside_block.stderr
@@ -46,8 +46,8 @@ LL |     { m!(()); }
    |
 help: put the `;` here
    |
-LL -         ()
-LL +         (); };
+LL -     { m!(()); }
+LL +     { m!(()) };
    |
 
 error: aborting due to 4 previous errors
-- 
cgit 1.4.1-3-g733a5


From ab4154697512ec076c4c5550d218d46638353eb9 Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukastw97@gmail.com>
Date: Thu, 24 Nov 2022 09:54:09 +0100
Subject: Address reviews

---
 clippy_lints/src/semicolon_block.rs | 35 +++++++++++++++--------------------
 1 file changed, 15 insertions(+), 20 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/semicolon_block.rs b/clippy_lints/src/semicolon_block.rs
index 57f835d45b1..d06f21c89c4 100644
--- a/clippy_lints/src/semicolon_block.rs
+++ b/clippy_lints/src/semicolon_block.rs
@@ -67,25 +67,21 @@ impl LateLintPass<'_> for SemicolonBlock {
     fn check_stmt(&mut self, cx: &LateContext<'_>, stmt: &Stmt<'_>) {
         match stmt.kind {
             StmtKind::Expr(Expr {
-                kind:
-                    ExprKind::Block(
-                        block @ Block {
-                            expr: None,
-                            stmts:
-                                &[
-                                    ..,
-                                    Stmt {
-                                        kind: StmtKind::Semi(expr),
-                                        span,
-                                        ..
-                                    },
-                                ],
-                            ..
-                        },
-                        _,
-                    ),
+                kind: ExprKind::Block(block, _),
                 ..
-            }) if !block.span.from_expansion() => semicolon_outside_block(cx, block, expr, span),
+            }) if !block.span.from_expansion() => {
+                let Block {
+                    expr: None,
+                    stmts: [.., stmt],
+                    ..
+                } = block else { return };
+                let &Stmt {
+                    kind: StmtKind::Semi(expr),
+                    span,
+                    ..
+                } = stmt else { return };
+                semicolon_outside_block(cx, block, expr, span)
+            },
             StmtKind::Semi(Expr {
                 kind: ExprKind::Block(block @ Block { expr: Some(tail), .. }, _),
                 ..
@@ -96,8 +92,7 @@ impl LateLintPass<'_> for SemicolonBlock {
 }
 
 fn semicolon_inside_block(cx: &LateContext<'_>, block: &Block<'_>, tail: &Expr<'_>, semi_span: Span) {
-    let tail_span_end = tail.span.source_callsite().hi();
-    let insert_span = Span::with_root_ctxt(tail_span_end, tail_span_end);
+    let insert_span = tail.span.source_callsite().shrink_to_hi();
     let remove_span = semi_span.with_lo(block.span.hi());
 
     span_lint_and_then(
-- 
cgit 1.4.1-3-g733a5


From f585414cd2fc635fecfe0437f9f71b08aba51d16 Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukastw97@gmail.com>
Date: Thu, 24 Nov 2022 20:37:07 +0100
Subject: Adjust semicolon block lint descriptions

---
 clippy_lints/src/semicolon_block.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/semicolon_block.rs b/clippy_lints/src/semicolon_block.rs
index d06f21c89c4..6861b370939 100644
--- a/clippy_lints/src/semicolon_block.rs
+++ b/clippy_lints/src/semicolon_block.rs
@@ -8,7 +8,7 @@ use rustc_span::Span;
 declare_clippy_lint! {
     /// ### What it does
     ///
-    /// For () returning expressions, check that the semicolon is inside the block.
+    /// Checks for semicolon terminated blocks containing only a single expression.
     ///
     /// ### Why is this bad?
     ///
@@ -36,7 +36,7 @@ declare_clippy_lint! {
 declare_clippy_lint! {
     /// ### What it does
     ///
-    /// For () returning expressions, check that the semicolon is outside the block.
+    /// Checks for blocks containing only a single semicolon terminated statement.
     ///
     /// ### Why is this bad?
     ///
-- 
cgit 1.4.1-3-g733a5


From 459621d31be6f9b177372feae3a37a872a630f58 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Fri, 25 Nov 2022 21:50:38 +0100
Subject: Improve `EXIT` lint docs

---
 clippy_lints/src/exit.rs | 23 ++++++++++++++++++-----
 1 file changed, 18 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/exit.rs b/clippy_lints/src/exit.rs
index 407dd1b3957..9c8b0d076df 100644
--- a/clippy_lints/src/exit.rs
+++ b/clippy_lints/src/exit.rs
@@ -7,21 +7,34 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
     /// ### What it does
-    /// `exit()`  terminates the program and doesn't provide a
-    /// stack trace.
+    /// Detects calls to the `exit()` function which terminates the program.
     ///
     /// ### Why is this bad?
-    /// Ideally a program is terminated by finishing
+    /// Exit terminates the program at the location it is called. For unrecoverable
+    /// errors `panics` should be used to provide a stacktrace and potentualy other
+    /// information. A normal termination or one with an error code should happen in
     /// the main function.
     ///
     /// ### Example
-    /// ```ignore
+    /// ```
     /// std::process::exit(0)
     /// ```
+    ///
+    /// Use instead:
+    ///
+    /// ```ignore
+    /// // To provide a stacktrace and additional information
+    /// panic!("message");
+    ///
+    /// // or a main method with a return
+    /// fn main() -> Result<(), i32> {
+    ///     Ok(())
+    /// }
+    /// ```
     #[clippy::version = "1.41.0"]
     pub EXIT,
     restriction,
-    "`std::process::exit` is called, terminating the program"
+    "detects `std::process::exit` calls"
 }
 
 declare_lint_pass!(Exit => [EXIT]);
-- 
cgit 1.4.1-3-g733a5


From 8c50dfb54649cbd67e37e7a456e736241740666d Mon Sep 17 00:00:00 2001
From: koka <koka.code@gmail.com>
Date: Sun, 27 Nov 2022 22:01:21 +0900
Subject: Remove blank lines when needless_return returns no value

fix https://github.com/rust-lang/rust-clippy/issues/9416
---
 clippy_lints/src/returns.rs     | 30 +++++++++++----
 tests/ui/needless_return.fixed  | 19 +++++----
 tests/ui/needless_return.rs     | 13 +++++++
 tests/ui/needless_return.stderr | 85 +++++++++++++++++++++++++++++------------
 4 files changed, 107 insertions(+), 40 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
index 2b2a41d1601..933258f9c3e 100644
--- a/clippy_lints/src/returns.rs
+++ b/clippy_lints/src/returns.rs
@@ -12,6 +12,7 @@ use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::subst::GenericArgKind;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
+use rustc_span::BytePos;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -209,13 +210,14 @@ fn check_final_expr<'tcx>(
             if cx.tcx.hir().attrs(expr.hir_id).is_empty() {
                 let borrows = inner.map_or(false, |inner| last_statement_borrows(cx, inner));
                 if !borrows {
-                    emit_return_lint(
-                        cx,
-                        peeled_drop_expr.span,
-                        semi_spans,
-                        inner.as_ref().map(|i| i.span),
-                        replacement,
-                    );
+                    // check if expr return nothing
+                    let ret_span = if inner.is_none() && replacement == RetReplacement::Empty {
+                        extend_span_to_previous_non_ws(cx, peeled_drop_expr.span)
+                    } else {
+                        peeled_drop_expr.span
+                    };
+
+                    emit_return_lint(cx, ret_span, semi_spans, inner.as_ref().map(|i| i.span), replacement);
                 }
             }
         },
@@ -289,3 +291,17 @@ fn last_statement_borrows<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>)
     })
     .is_some()
 }
+
+// Go backwards while encountering whitespace and extend the given Span to that point.
+#[expect(clippy::cast_possible_truncation)]
+fn extend_span_to_previous_non_ws(cx: &LateContext<'_>, sp: Span) -> Span {
+    if let Ok(prev_source) = cx.sess().source_map().span_to_prev_source(sp) {
+        let ws = [' ', '\t', '\n'];
+        if let Some(non_ws_pos) = prev_source.rfind(|c| !ws.contains(&c)) {
+            let len = prev_source.len() - non_ws_pos - 1;
+            return sp.with_lo(BytePos(sp.lo().0 - len as u32));
+        }
+    }
+
+    sp
+}
diff --git a/tests/ui/needless_return.fixed b/tests/ui/needless_return.fixed
index d2163b14fca..4386aaec49e 100644
--- a/tests/ui/needless_return.fixed
+++ b/tests/ui/needless_return.fixed
@@ -59,14 +59,11 @@ fn test_macro_call() -> i32 {
 }
 
 fn test_void_fun() {
-    
 }
 
 fn test_void_if_fun(b: bool) {
     if b {
-        
     } else {
-        
     }
 }
 
@@ -82,7 +79,6 @@ fn test_nested_match(x: u32) {
         0 => (),
         1 => {
             let _ = 42;
-            
         },
         _ => (),
     }
@@ -126,7 +122,6 @@ mod issue6501 {
 
     fn test_closure() {
         let _ = || {
-            
         };
         let _ = || {};
     }
@@ -179,14 +174,11 @@ async fn async_test_macro_call() -> i32 {
 }
 
 async fn async_test_void_fun() {
-    
 }
 
 async fn async_test_void_if_fun(b: bool) {
     if b {
-        
     } else {
-        
     }
 }
 
@@ -269,4 +261,15 @@ fn issue9503(x: usize) -> isize {
     }
 }
 
+mod issue9416 {
+    pub fn with_newline() {
+        let _ = 42;
+    }
+
+    #[rustfmt::skip]
+    pub fn oneline() {
+        let _ = 42;
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/needless_return.rs b/tests/ui/needless_return.rs
index 114414b5fac..666dc54b76b 100644
--- a/tests/ui/needless_return.rs
+++ b/tests/ui/needless_return.rs
@@ -269,4 +269,17 @@ fn issue9503(x: usize) -> isize {
     };
 }
 
+mod issue9416 {
+    pub fn with_newline() {
+        let _ = 42;
+
+        return;
+    }
+
+    #[rustfmt::skip]
+    pub fn oneline() {
+        let _ = 42; return;
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/needless_return.stderr b/tests/ui/needless_return.stderr
index 047fb6c2311..a8b5d86cd55 100644
--- a/tests/ui/needless_return.stderr
+++ b/tests/ui/needless_return.stderr
@@ -72,26 +72,32 @@ LL |     return the_answer!();
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:62:5
+  --> $DIR/needless_return.rs:61:21
    |
-LL |     return;
-   |     ^^^^^^
+LL |   fn test_void_fun() {
+   |  _____________________^
+LL | |     return;
+   | |__________^
    |
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:67:9
+  --> $DIR/needless_return.rs:66:11
    |
-LL |         return;
-   |         ^^^^^^
+LL |       if b {
+   |  ___________^
+LL | |         return;
+   | |______________^
    |
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:69:9
+  --> $DIR/needless_return.rs:68:13
    |
-LL |         return;
-   |         ^^^^^^
+LL |       } else {
+   |  _____________^
+LL | |         return;
+   | |______________^
    |
    = help: remove `return`
 
@@ -104,10 +110,12 @@ LL |         _ => return,
    = help: replace `return` with a unit value
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:85:13
+  --> $DIR/needless_return.rs:84:24
    |
-LL |             return;
-   |             ^^^^^^
+LL |               let _ = 42;
+   |  ________________________^
+LL | |             return;
+   | |__________________^
    |
    = help: remove `return`
 
@@ -144,10 +152,12 @@ LL |         bar.unwrap_or_else(|_| return)
    = help: replace `return` with an empty block
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:129:13
+  --> $DIR/needless_return.rs:128:21
    |
-LL |             return;
-   |             ^^^^^^
+LL |           let _ = || {
+   |  _____________________^
+LL | |             return;
+   | |__________________^
    |
    = help: remove `return`
 
@@ -240,26 +250,32 @@ LL |     return the_answer!();
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:182:5
+  --> $DIR/needless_return.rs:181:33
    |
-LL |     return;
-   |     ^^^^^^
+LL |   async fn async_test_void_fun() {
+   |  _________________________________^
+LL | |     return;
+   | |__________^
    |
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:187:9
+  --> $DIR/needless_return.rs:186:11
    |
-LL |         return;
-   |         ^^^^^^
+LL |       if b {
+   |  ___________^
+LL | |         return;
+   | |______________^
    |
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:189:9
+  --> $DIR/needless_return.rs:188:13
    |
-LL |         return;
-   |         ^^^^^^
+LL |       } else {
+   |  _____________^
+LL | |         return;
+   | |______________^
    |
    = help: remove `return`
 
@@ -351,5 +367,24 @@ LL |             return !*(x as *const isize);
    |
    = help: remove `return`
 
-error: aborting due to 44 previous errors
+error: unneeded `return` statement
+  --> $DIR/needless_return.rs:274:20
+   |
+LL |           let _ = 42;
+   |  ____________________^
+LL | |
+LL | |         return;
+   | |______________^
+   |
+   = help: remove `return`
+
+error: unneeded `return` statement
+  --> $DIR/needless_return.rs:281:20
+   |
+LL |         let _ = 42; return;
+   |                    ^^^^^^^
+   |
+   = help: remove `return`
+
+error: aborting due to 46 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 39d0477080de2c458cdbeb4a0a44d267d58af521 Mon Sep 17 00:00:00 2001
From: koka <koka.code@gmail.com>
Date: Sun, 27 Nov 2022 22:41:06 +0900
Subject: Refactor BytePos handling

---
 clippy_lints/src/returns.rs | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
index 933258f9c3e..81143d7799e 100644
--- a/clippy_lints/src/returns.rs
+++ b/clippy_lints/src/returns.rs
@@ -12,7 +12,7 @@ use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::subst::GenericArgKind;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
-use rustc_span::BytePos;
+use rustc_span::{BytePos, Pos};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -293,13 +293,12 @@ fn last_statement_borrows<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>)
 }
 
 // Go backwards while encountering whitespace and extend the given Span to that point.
-#[expect(clippy::cast_possible_truncation)]
 fn extend_span_to_previous_non_ws(cx: &LateContext<'_>, sp: Span) -> Span {
     if let Ok(prev_source) = cx.sess().source_map().span_to_prev_source(sp) {
         let ws = [' ', '\t', '\n'];
         if let Some(non_ws_pos) = prev_source.rfind(|c| !ws.contains(&c)) {
             let len = prev_source.len() - non_ws_pos - 1;
-            return sp.with_lo(BytePos(sp.lo().0 - len as u32));
+            return sp.with_lo(sp.lo() - BytePos::from_usize(len));
         }
     }
 
-- 
cgit 1.4.1-3-g733a5


From 7a2d92e1f29f774acb640b8e4262aed1b8f7f9a4 Mon Sep 17 00:00:00 2001
From: Yuri Astrakhan <YuriAstrakhan@gmail.com>
Date: Sun, 27 Nov 2022 10:12:51 -0500
Subject: Add allow-mixed-uninlined-format-args config

Implement `allow-mixed-uninlined-format-args` config param to change the behavior of the `uninlined_format_args` lint. Now it is a part of `style`, and won't propose inlining in case of a mixed usage, e.g. `print!("{} {}", var, 1+2)`. If the user sets allow-mixed-uninlined-format-args config param to `false`, then it would behave like before, proposing to inline args even in the mixed case.
---
 clippy_lints/src/format_args.rs                    |  62 +-
 clippy_lints/src/lib.rs                            |   3 +-
 clippy_lints/src/utils/conf.rs                     |   4 +
 .../auxiliary/proc_macro_with_span.rs              |  32 +
 .../allow_mixed_uninlined_format_args/clippy.toml  |   1 +
 .../uninlined_format_args.fixed                    | 177 ++++
 .../uninlined_format_args.rs                       | 182 +++++
 .../uninlined_format_args.stderr                   | 908 +++++++++++++++++++++
 .../toml_unknown_key/conf_unknown_key.stderr       |   1 +
 tests/ui/uninlined_format_args.fixed               |   8 +-
 .../uninlined_format_args_panic.edition2018.stderr |   1 +
 .../uninlined_format_args_panic.edition2021.stderr |   1 +
 12 files changed, 1359 insertions(+), 21 deletions(-)
 create mode 100644 tests/ui-toml/allow_mixed_uninlined_format_args/auxiliary/proc_macro_with_span.rs
 create mode 100644 tests/ui-toml/allow_mixed_uninlined_format_args/clippy.toml
 create mode 100644 tests/ui-toml/allow_mixed_uninlined_format_args/uninlined_format_args.fixed
 create mode 100644 tests/ui-toml/allow_mixed_uninlined_format_args/uninlined_format_args.rs
 create mode 100644 tests/ui-toml/allow_mixed_uninlined_format_args/uninlined_format_args.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/format_args.rs b/clippy_lints/src/format_args.rs
index fd3ce2f3d6c..40a37d39ecf 100644
--- a/clippy_lints/src/format_args.rs
+++ b/clippy_lints/src/format_args.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::is_diag_trait_item;
-use clippy_utils::macros::FormatParamKind::{Implicit, Named, Numbered, Starred};
+use clippy_utils::macros::FormatParamKind::{Implicit, Named, NamedInline, Numbered, Starred};
 use clippy_utils::macros::{
     is_format_macro, is_panic, root_macro_call, Count, FormatArg, FormatArgsExpn, FormatParam, FormatParamUsage,
 };
@@ -106,19 +106,25 @@ declare_clippy_lint! {
     /// format!("{var:.prec$}");
     /// ```
     ///
-    /// ### Known Problems
-    ///
-    /// There may be a false positive if the format string is expanded from certain proc macros:
-    ///
-    /// ```ignore
-    /// println!(indoc!("{}"), var);
+    /// If allow-mixed-uninlined-format-args is set to false in clippy.toml,
+    /// the following code will also trigger the lint:
+    /// ```rust
+    /// # let var = 42;
+    /// format!("{} {}", var, 1+2);
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// # let var = 42;
+    /// format!("{var} {}", 1+2);
     /// ```
     ///
+    /// ### Known Problems
+    ///
     /// If a format string contains a numbered argument that cannot be inlined
     /// nothing will be suggested, e.g. `println!("{0}={1}", var, 1+2)`.
     #[clippy::version = "1.65.0"]
     pub UNINLINED_FORMAT_ARGS,
-    pedantic,
+    style,
     "using non-inlined variables in `format!` calls"
 }
 
@@ -162,12 +168,16 @@ impl_lint_pass!(FormatArgs => [
 
 pub struct FormatArgs {
     msrv: Msrv,
+    ignore_mixed: bool,
 }
 
 impl FormatArgs {
     #[must_use]
-    pub fn new(msrv: Msrv) -> Self {
-        Self { msrv }
+    pub fn new(msrv: Msrv, allow_mixed_uninlined_format_args: bool) -> Self {
+        Self {
+            msrv,
+            ignore_mixed: allow_mixed_uninlined_format_args,
+        }
     }
 }
 
@@ -192,7 +202,7 @@ impl<'tcx> LateLintPass<'tcx> for FormatArgs {
                 check_to_string_in_format_args(cx, name, arg.param.value);
             }
             if self.msrv.meets(msrvs::FORMAT_ARGS_CAPTURE) {
-                check_uninlined_args(cx, &format_args, outermost_expn_data.call_site, macro_def_id);
+                check_uninlined_args(cx, &format_args, outermost_expn_data.call_site, macro_def_id, self.ignore_mixed);
             }
         }
     }
@@ -270,7 +280,13 @@ fn check_unused_format_specifier(cx: &LateContext<'_>, arg: &FormatArg<'_>) {
     }
 }
 
-fn check_uninlined_args(cx: &LateContext<'_>, args: &FormatArgsExpn<'_>, call_site: Span, def_id: DefId) {
+fn check_uninlined_args(
+    cx: &LateContext<'_>,
+    args: &FormatArgsExpn<'_>,
+    call_site: Span,
+    def_id: DefId,
+    ignore_mixed: bool,
+) {
     if args.format_string.span.from_expansion() {
         return;
     }
@@ -285,7 +301,7 @@ fn check_uninlined_args(cx: &LateContext<'_>, args: &FormatArgsExpn<'_>, call_si
     // we cannot remove any other arguments in the format string,
     // because the index numbers might be wrong after inlining.
     // Example of an un-inlinable format:  print!("{}{1}", foo, 2)
-    if !args.params().all(|p| check_one_arg(args, &p, &mut fixes)) || fixes.is_empty() {
+    if !args.params().all(|p| check_one_arg(args, &p, &mut fixes, ignore_mixed)) || fixes.is_empty() {
         return;
     }
 
@@ -305,11 +321,23 @@ fn check_uninlined_args(cx: &LateContext<'_>, args: &FormatArgsExpn<'_>, call_si
                 Applicability::MachineApplicable,
                 if multiline_fix { CompletelyHidden } else { ShowCode },
             );
+            if ignore_mixed {
+                // Improve lint config discoverability
+                diag.note_once(
+                    "this lint can also fix mixed format arg inlining if \
+                    `allow-mixed-uninlined-format-args = false` is set in the `clippy.toml` file",
+                );
+            }
         },
     );
 }
 
-fn check_one_arg(args: &FormatArgsExpn<'_>, param: &FormatParam<'_>, fixes: &mut Vec<(Span, String)>) -> bool {
+fn check_one_arg(
+    args: &FormatArgsExpn<'_>,
+    param: &FormatParam<'_>,
+    fixes: &mut Vec<(Span, String)>,
+    ignore_mixed: bool,
+) -> bool {
     if matches!(param.kind, Implicit | Starred | Named(_) | Numbered)
         && let ExprKind::Path(QPath::Resolved(None, path)) = param.value.kind
         && let [segment] = path.segments
@@ -324,8 +352,10 @@ fn check_one_arg(args: &FormatArgsExpn<'_>, param: &FormatParam<'_>, fixes: &mut
         fixes.push((arg_span, String::new()));
         true  // successful inlining, continue checking
     } else {
-        // if we can't inline a numbered argument, we can't continue
-        param.kind != Numbered
+        // Do not continue inlining (return false) in case
+        // * if we can't inline a numbered argument, e.g. `print!("{0} ...", foo.bar, ...)`
+        // * if allow_mixed_uninlined_format_args is false and this arg hasn't been inlined already
+        param.kind != Numbered && (!ignore_mixed || matches!(param.kind, NamedInline(_)))
     }
 }
 
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 17dbd983b6c..3fe39488ab8 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -828,7 +828,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         ))
     });
     store.register_late_pass(move |_| Box::new(undocumented_unsafe_blocks::UndocumentedUnsafeBlocks));
-    store.register_late_pass(move |_| Box::new(format_args::FormatArgs::new(msrv())));
+    let allow_mixed_uninlined = conf.allow_mixed_uninlined_format_args;
+    store.register_late_pass(move |_| Box::new(format_args::FormatArgs::new(msrv(), allow_mixed_uninlined)));
     store.register_late_pass(|_| Box::new(trailing_empty_array::TrailingEmptyArray));
     store.register_early_pass(|| Box::new(octal_escapes::OctalEscapes));
     store.register_late_pass(|_| Box::new(needless_late_init::NeedlessLateInit));
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index b37d4239477..b6dc8cd7ab1 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -402,6 +402,10 @@ define_Conf! {
     /// A list of paths to types that should be treated like `Arc`, i.e. ignored but
     /// for the generic parameters for determining interior mutability
     (ignore_interior_mutability: Vec<String> = Vec::from(["bytes::Bytes".into()])),
+    /// Lint: UNINLINED_FORMAT_ARGS.
+    ///
+    /// Whether to allow mixed uninlined format args, e.g. `format!("{} {}", a, foo.bar)`
+    (allow_mixed_uninlined_format_args: bool = true),
 }
 
 /// Search for the configuration file.
diff --git a/tests/ui-toml/allow_mixed_uninlined_format_args/auxiliary/proc_macro_with_span.rs b/tests/ui-toml/allow_mixed_uninlined_format_args/auxiliary/proc_macro_with_span.rs
new file mode 100644
index 00000000000..8ea631f2bbd
--- /dev/null
+++ b/tests/ui-toml/allow_mixed_uninlined_format_args/auxiliary/proc_macro_with_span.rs
@@ -0,0 +1,32 @@
+// compile-flags: --emit=link
+// no-prefer-dynamic
+
+#![crate_type = "proc-macro"]
+
+extern crate proc_macro;
+
+use proc_macro::{token_stream::IntoIter, Group, Span, TokenStream, TokenTree};
+
+#[proc_macro]
+pub fn with_span(input: TokenStream) -> TokenStream {
+    let mut iter = input.into_iter();
+    let span = iter.next().unwrap().span();
+    let mut res = TokenStream::new();
+    write_with_span(span, iter, &mut res);
+    res
+}
+
+fn write_with_span(s: Span, input: IntoIter, out: &mut TokenStream) {
+    for mut tt in input {
+        if let TokenTree::Group(g) = tt {
+            let mut stream = TokenStream::new();
+            write_with_span(s, g.stream().into_iter(), &mut stream);
+            let mut group = Group::new(g.delimiter(), stream);
+            group.set_span(s);
+            out.extend([TokenTree::Group(group)]);
+        } else {
+            tt.set_span(s);
+            out.extend([tt]);
+        }
+    }
+}
diff --git a/tests/ui-toml/allow_mixed_uninlined_format_args/clippy.toml b/tests/ui-toml/allow_mixed_uninlined_format_args/clippy.toml
new file mode 100644
index 00000000000..b95e806aae2
--- /dev/null
+++ b/tests/ui-toml/allow_mixed_uninlined_format_args/clippy.toml
@@ -0,0 +1 @@
+allow-mixed-uninlined-format-args = false
diff --git a/tests/ui-toml/allow_mixed_uninlined_format_args/uninlined_format_args.fixed b/tests/ui-toml/allow_mixed_uninlined_format_args/uninlined_format_args.fixed
new file mode 100644
index 00000000000..ca56c95c23f
--- /dev/null
+++ b/tests/ui-toml/allow_mixed_uninlined_format_args/uninlined_format_args.fixed
@@ -0,0 +1,177 @@
+// aux-build:proc_macro_with_span.rs
+// run-rustfix
+#![feature(custom_inner_attributes)]
+#![warn(clippy::uninlined_format_args)]
+#![allow(named_arguments_used_positionally, unused_imports, unused_macros, unused_variables)]
+#![allow(clippy::eq_op, clippy::format_in_format_args, clippy::print_literal)]
+
+extern crate proc_macro_with_span;
+use proc_macro_with_span::with_span;
+
+macro_rules! no_param_str {
+    () => {
+        "{}"
+    };
+}
+
+macro_rules! my_println {
+   ($($args:tt),*) => {{
+        println!($($args),*)
+    }};
+}
+
+macro_rules! my_println_args {
+    ($($args:tt),*) => {{
+        println!("foo: {}", format_args!($($args),*))
+    }};
+}
+
+fn tester(fn_arg: i32) {
+    let local_i32 = 1;
+    let local_f64 = 2.0;
+    let local_opt: Option<i32> = Some(3);
+    let width = 4;
+    let prec = 5;
+    let val = 6;
+
+    // make sure this file hasn't been corrupted with tabs converted to spaces
+    // let _ = '	';  // <- this is a single tab character
+    let _: &[u8; 3] = b"	 	"; // <- <tab><space><tab>
+
+    println!("val='{local_i32}'");
+    println!("val='{local_i32}'"); // 3 spaces
+    println!("val='{local_i32}'"); // tab
+    println!("val='{local_i32}'"); // space+tab
+    println!("val='{local_i32}'"); // tab+space
+    println!(
+        "val='{local_i32}'"
+    );
+    println!("{local_i32}");
+    println!("{fn_arg}");
+    println!("{local_i32:?}");
+    println!("{local_i32:#?}");
+    println!("{local_i32:4}");
+    println!("{local_i32:04}");
+    println!("{local_i32:<3}");
+    println!("{local_i32:#010x}");
+    println!("{local_f64:.1}");
+    println!("Hello {} is {local_f64:.local_i32$}", "x");
+    println!("Hello {local_i32} is {local_f64:.*}", 5);
+    println!("Hello {local_i32} is {local_f64:.*}", 5);
+    println!("{local_i32} {local_f64}");
+    println!("{local_i32}, {}", local_opt.unwrap());
+    println!("{val}");
+    println!("{val}");
+    println!("{} {1}", local_i32, 42);
+    println!("val='{local_i32}'");
+    println!("val='{local_i32}'");
+    println!("val='{local_i32}'");
+    println!("val='{fn_arg}'");
+    println!("{local_i32}");
+    println!("{local_i32:?}");
+    println!("{local_i32:#?}");
+    println!("{local_i32:04}");
+    println!("{local_i32:<3}");
+    println!("{local_i32:#010x}");
+    println!("{local_f64:.1}");
+    println!("{local_i32} {local_i32}");
+    println!("{local_f64} {local_i32} {local_i32} {local_f64}");
+    println!("{local_i32} {local_f64}");
+    println!("{local_f64} {local_i32}");
+    println!("{local_f64} {local_i32} {local_f64} {local_i32}");
+    println!("{1} {0}", "str", local_i32);
+    println!("{local_i32}");
+    println!("{local_i32:width$}");
+    println!("{local_i32:width$}");
+    println!("{local_i32:.prec$}");
+    println!("{local_i32:.prec$}");
+    println!("{val:val$}");
+    println!("{val:val$}");
+    println!("{val:val$.val$}");
+    println!("{val:val$.val$}");
+    println!("{val:val$.val$}");
+    println!("{val:val$.val$}");
+    println!("{val:val$.val$}");
+    println!("{val:val$.val$}");
+    println!("{val:val$.val$}");
+    println!("{val:val$.val$}");
+    println!("{width:width$}");
+    println!("{local_i32:width$}");
+    println!("{width:width$}");
+    println!("{local_i32:width$}");
+    println!("{prec:.prec$}");
+    println!("{local_i32:.prec$}");
+    println!("{prec:.prec$}");
+    println!("{local_i32:.prec$}");
+    println!("{width:width$.prec$}");
+    println!("{width:width$.prec$}");
+    println!("{local_f64:width$.prec$}");
+    println!("{local_f64:width$.prec$} {local_f64} {width} {prec}");
+    println!(
+        "{local_i32:width$.prec$} {local_i32:prec$.width$} {width:local_i32$.prec$} {width:prec$.local_i32$} {prec:local_i32$.width$} {prec:width$.local_i32$}",
+    );
+    println!(
+        "{0:1$.2$} {0:2$.1$} {1:0$.2$} {1:2$.0$} {2:0$.1$} {2:1$.0$} {3}",
+        local_i32,
+        width,
+        prec,
+        1 + 2
+    );
+    println!("Width = {local_i32}, value with width = {local_f64:local_i32$}");
+    println!("{local_i32:width$.prec$}");
+    println!("{width:width$.prec$}");
+    println!("{}", format!("{local_i32}"));
+    my_println!("{}", local_i32);
+    my_println_args!("{}", local_i32);
+
+    // these should NOT be modified by the lint
+    println!(concat!("nope ", "{}"), local_i32);
+    println!("val='{local_i32}'");
+    println!("val='{local_i32 }'");
+    println!("val='{local_i32	}'"); // with tab
+    println!("val='{local_i32\n}'");
+    println!("{}", usize::MAX);
+    println!("{}", local_opt.unwrap());
+    println!(
+        "val='{local_i32
+    }'"
+    );
+    println!(no_param_str!(), local_i32);
+
+    println!(
+        "{val}",
+    );
+    println!("{val}");
+
+    println!(with_span!("{0} {1}" "{1} {0}"), local_i32, local_f64);
+    println!("{}", with_span!(span val));
+
+    if local_i32 > 0 {
+        panic!("p1 {local_i32}");
+    }
+    if local_i32 > 0 {
+        panic!("p2 {local_i32}");
+    }
+    if local_i32 > 0 {
+        panic!("p3 {local_i32}");
+    }
+    if local_i32 > 0 {
+        panic!("p4 {local_i32}");
+    }
+}
+
+fn main() {
+    tester(42);
+}
+
+fn _under_msrv() {
+    #![clippy::msrv = "1.57"]
+    let local_i32 = 1;
+    println!("don't expand='{}'", local_i32);
+}
+
+fn _meets_msrv() {
+    #![clippy::msrv = "1.58"]
+    let local_i32 = 1;
+    println!("expand='{local_i32}'");
+}
diff --git a/tests/ui-toml/allow_mixed_uninlined_format_args/uninlined_format_args.rs b/tests/ui-toml/allow_mixed_uninlined_format_args/uninlined_format_args.rs
new file mode 100644
index 00000000000..8e495ebd083
--- /dev/null
+++ b/tests/ui-toml/allow_mixed_uninlined_format_args/uninlined_format_args.rs
@@ -0,0 +1,182 @@
+// aux-build:proc_macro_with_span.rs
+// run-rustfix
+#![feature(custom_inner_attributes)]
+#![warn(clippy::uninlined_format_args)]
+#![allow(named_arguments_used_positionally, unused_imports, unused_macros, unused_variables)]
+#![allow(clippy::eq_op, clippy::format_in_format_args, clippy::print_literal)]
+
+extern crate proc_macro_with_span;
+use proc_macro_with_span::with_span;
+
+macro_rules! no_param_str {
+    () => {
+        "{}"
+    };
+}
+
+macro_rules! my_println {
+   ($($args:tt),*) => {{
+        println!($($args),*)
+    }};
+}
+
+macro_rules! my_println_args {
+    ($($args:tt),*) => {{
+        println!("foo: {}", format_args!($($args),*))
+    }};
+}
+
+fn tester(fn_arg: i32) {
+    let local_i32 = 1;
+    let local_f64 = 2.0;
+    let local_opt: Option<i32> = Some(3);
+    let width = 4;
+    let prec = 5;
+    let val = 6;
+
+    // make sure this file hasn't been corrupted with tabs converted to spaces
+    // let _ = '	';  // <- this is a single tab character
+    let _: &[u8; 3] = b"	 	"; // <- <tab><space><tab>
+
+    println!("val='{}'", local_i32);
+    println!("val='{   }'", local_i32); // 3 spaces
+    println!("val='{	}'", local_i32); // tab
+    println!("val='{ 	}'", local_i32); // space+tab
+    println!("val='{	 }'", local_i32); // tab+space
+    println!(
+        "val='{
+    }'",
+        local_i32
+    );
+    println!("{}", local_i32);
+    println!("{}", fn_arg);
+    println!("{:?}", local_i32);
+    println!("{:#?}", local_i32);
+    println!("{:4}", local_i32);
+    println!("{:04}", local_i32);
+    println!("{:<3}", local_i32);
+    println!("{:#010x}", local_i32);
+    println!("{:.1}", local_f64);
+    println!("Hello {} is {:.*}", "x", local_i32, local_f64);
+    println!("Hello {} is {:.*}", local_i32, 5, local_f64);
+    println!("Hello {} is {2:.*}", local_i32, 5, local_f64);
+    println!("{} {}", local_i32, local_f64);
+    println!("{}, {}", local_i32, local_opt.unwrap());
+    println!("{}", val);
+    println!("{}", v = val);
+    println!("{} {1}", local_i32, 42);
+    println!("val='{\t }'", local_i32);
+    println!("val='{\n }'", local_i32);
+    println!("val='{local_i32}'", local_i32 = local_i32);
+    println!("val='{local_i32}'", local_i32 = fn_arg);
+    println!("{0}", local_i32);
+    println!("{0:?}", local_i32);
+    println!("{0:#?}", local_i32);
+    println!("{0:04}", local_i32);
+    println!("{0:<3}", local_i32);
+    println!("{0:#010x}", local_i32);
+    println!("{0:.1}", local_f64);
+    println!("{0} {0}", local_i32);
+    println!("{1} {} {0} {}", local_i32, local_f64);
+    println!("{0} {1}", local_i32, local_f64);
+    println!("{1} {0}", local_i32, local_f64);
+    println!("{1} {0} {1} {0}", local_i32, local_f64);
+    println!("{1} {0}", "str", local_i32);
+    println!("{v}", v = local_i32);
+    println!("{local_i32:0$}", width);
+    println!("{local_i32:w$}", w = width);
+    println!("{local_i32:.0$}", prec);
+    println!("{local_i32:.p$}", p = prec);
+    println!("{:0$}", v = val);
+    println!("{0:0$}", v = val);
+    println!("{:0$.0$}", v = val);
+    println!("{0:0$.0$}", v = val);
+    println!("{0:0$.v$}", v = val);
+    println!("{0:v$.0$}", v = val);
+    println!("{v:0$.0$}", v = val);
+    println!("{v:v$.0$}", v = val);
+    println!("{v:0$.v$}", v = val);
+    println!("{v:v$.v$}", v = val);
+    println!("{:0$}", width);
+    println!("{:1$}", local_i32, width);
+    println!("{:w$}", w = width);
+    println!("{:w$}", local_i32, w = width);
+    println!("{:.0$}", prec);
+    println!("{:.1$}", local_i32, prec);
+    println!("{:.p$}", p = prec);
+    println!("{:.p$}", local_i32, p = prec);
+    println!("{:0$.1$}", width, prec);
+    println!("{:0$.w$}", width, w = prec);
+    println!("{:1$.2$}", local_f64, width, prec);
+    println!("{:1$.2$} {0} {1} {2}", local_f64, width, prec);
+    println!(
+        "{0:1$.2$} {0:2$.1$} {1:0$.2$} {1:2$.0$} {2:0$.1$} {2:1$.0$}",
+        local_i32, width, prec,
+    );
+    println!(
+        "{0:1$.2$} {0:2$.1$} {1:0$.2$} {1:2$.0$} {2:0$.1$} {2:1$.0$} {3}",
+        local_i32,
+        width,
+        prec,
+        1 + 2
+    );
+    println!("Width = {}, value with width = {:0$}", local_i32, local_f64);
+    println!("{:w$.p$}", local_i32, w = width, p = prec);
+    println!("{:w$.p$}", w = width, p = prec);
+    println!("{}", format!("{}", local_i32));
+    my_println!("{}", local_i32);
+    my_println_args!("{}", local_i32);
+
+    // these should NOT be modified by the lint
+    println!(concat!("nope ", "{}"), local_i32);
+    println!("val='{local_i32}'");
+    println!("val='{local_i32 }'");
+    println!("val='{local_i32	}'"); // with tab
+    println!("val='{local_i32\n}'");
+    println!("{}", usize::MAX);
+    println!("{}", local_opt.unwrap());
+    println!(
+        "val='{local_i32
+    }'"
+    );
+    println!(no_param_str!(), local_i32);
+
+    println!(
+        "{}",
+        // comment with a comma , in it
+        val,
+    );
+    println!("{}", /* comment with a comma , in it */ val);
+
+    println!(with_span!("{0} {1}" "{1} {0}"), local_i32, local_f64);
+    println!("{}", with_span!(span val));
+
+    if local_i32 > 0 {
+        panic!("p1 {}", local_i32);
+    }
+    if local_i32 > 0 {
+        panic!("p2 {0}", local_i32);
+    }
+    if local_i32 > 0 {
+        panic!("p3 {local_i32}", local_i32 = local_i32);
+    }
+    if local_i32 > 0 {
+        panic!("p4 {local_i32}");
+    }
+}
+
+fn main() {
+    tester(42);
+}
+
+fn _under_msrv() {
+    #![clippy::msrv = "1.57"]
+    let local_i32 = 1;
+    println!("don't expand='{}'", local_i32);
+}
+
+fn _meets_msrv() {
+    #![clippy::msrv = "1.58"]
+    let local_i32 = 1;
+    println!("expand='{}'", local_i32);
+}
diff --git a/tests/ui-toml/allow_mixed_uninlined_format_args/uninlined_format_args.stderr b/tests/ui-toml/allow_mixed_uninlined_format_args/uninlined_format_args.stderr
new file mode 100644
index 00000000000..1182d57ce9b
--- /dev/null
+++ b/tests/ui-toml/allow_mixed_uninlined_format_args/uninlined_format_args.stderr
@@ -0,0 +1,908 @@
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:41:5
+   |
+LL |     println!("val='{}'", local_i32);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::uninlined-format-args` implied by `-D warnings`
+help: change this to
+   |
+LL -     println!("val='{}'", local_i32);
+LL +     println!("val='{local_i32}'");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:42:5
+   |
+LL |     println!("val='{   }'", local_i32); // 3 spaces
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("val='{   }'", local_i32); // 3 spaces
+LL +     println!("val='{local_i32}'"); // 3 spaces
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:43:5
+   |
+LL |     println!("val='{    }'", local_i32); // tab
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("val='{    }'", local_i32); // tab
+LL +     println!("val='{local_i32}'"); // tab
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:44:5
+   |
+LL |     println!("val='{     }'", local_i32); // space+tab
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("val='{     }'", local_i32); // space+tab
+LL +     println!("val='{local_i32}'"); // space+tab
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:45:5
+   |
+LL |     println!("val='{     }'", local_i32); // tab+space
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("val='{     }'", local_i32); // tab+space
+LL +     println!("val='{local_i32}'"); // tab+space
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:46:5
+   |
+LL | /     println!(
+LL | |         "val='{
+LL | |     }'",
+LL | |         local_i32
+LL | |     );
+   | |_____^
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:51:5
+   |
+LL |     println!("{}", local_i32);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{}", local_i32);
+LL +     println!("{local_i32}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:52:5
+   |
+LL |     println!("{}", fn_arg);
+   |     ^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{}", fn_arg);
+LL +     println!("{fn_arg}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:53:5
+   |
+LL |     println!("{:?}", local_i32);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{:?}", local_i32);
+LL +     println!("{local_i32:?}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:54:5
+   |
+LL |     println!("{:#?}", local_i32);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{:#?}", local_i32);
+LL +     println!("{local_i32:#?}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:55:5
+   |
+LL |     println!("{:4}", local_i32);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{:4}", local_i32);
+LL +     println!("{local_i32:4}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:56:5
+   |
+LL |     println!("{:04}", local_i32);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{:04}", local_i32);
+LL +     println!("{local_i32:04}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:57:5
+   |
+LL |     println!("{:<3}", local_i32);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{:<3}", local_i32);
+LL +     println!("{local_i32:<3}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:58:5
+   |
+LL |     println!("{:#010x}", local_i32);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{:#010x}", local_i32);
+LL +     println!("{local_i32:#010x}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:59:5
+   |
+LL |     println!("{:.1}", local_f64);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{:.1}", local_f64);
+LL +     println!("{local_f64:.1}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:60:5
+   |
+LL |     println!("Hello {} is {:.*}", "x", local_i32, local_f64);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("Hello {} is {:.*}", "x", local_i32, local_f64);
+LL +     println!("Hello {} is {local_f64:.local_i32$}", "x");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:61:5
+   |
+LL |     println!("Hello {} is {:.*}", local_i32, 5, local_f64);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("Hello {} is {:.*}", local_i32, 5, local_f64);
+LL +     println!("Hello {local_i32} is {local_f64:.*}", 5);
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:62:5
+   |
+LL |     println!("Hello {} is {2:.*}", local_i32, 5, local_f64);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("Hello {} is {2:.*}", local_i32, 5, local_f64);
+LL +     println!("Hello {local_i32} is {local_f64:.*}", 5);
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:63:5
+   |
+LL |     println!("{} {}", local_i32, local_f64);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{} {}", local_i32, local_f64);
+LL +     println!("{local_i32} {local_f64}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:64:5
+   |
+LL |     println!("{}, {}", local_i32, local_opt.unwrap());
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{}, {}", local_i32, local_opt.unwrap());
+LL +     println!("{local_i32}, {}", local_opt.unwrap());
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:65:5
+   |
+LL |     println!("{}", val);
+   |     ^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{}", val);
+LL +     println!("{val}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:66:5
+   |
+LL |     println!("{}", v = val);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{}", v = val);
+LL +     println!("{val}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:68:5
+   |
+LL |     println!("val='{/t }'", local_i32);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("val='{/t }'", local_i32);
+LL +     println!("val='{local_i32}'");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:69:5
+   |
+LL |     println!("val='{/n }'", local_i32);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("val='{/n }'", local_i32);
+LL +     println!("val='{local_i32}'");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:70:5
+   |
+LL |     println!("val='{local_i32}'", local_i32 = local_i32);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("val='{local_i32}'", local_i32 = local_i32);
+LL +     println!("val='{local_i32}'");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:71:5
+   |
+LL |     println!("val='{local_i32}'", local_i32 = fn_arg);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("val='{local_i32}'", local_i32 = fn_arg);
+LL +     println!("val='{fn_arg}'");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:72:5
+   |
+LL |     println!("{0}", local_i32);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{0}", local_i32);
+LL +     println!("{local_i32}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:73:5
+   |
+LL |     println!("{0:?}", local_i32);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{0:?}", local_i32);
+LL +     println!("{local_i32:?}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:74:5
+   |
+LL |     println!("{0:#?}", local_i32);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{0:#?}", local_i32);
+LL +     println!("{local_i32:#?}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:75:5
+   |
+LL |     println!("{0:04}", local_i32);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{0:04}", local_i32);
+LL +     println!("{local_i32:04}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:76:5
+   |
+LL |     println!("{0:<3}", local_i32);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{0:<3}", local_i32);
+LL +     println!("{local_i32:<3}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:77:5
+   |
+LL |     println!("{0:#010x}", local_i32);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{0:#010x}", local_i32);
+LL +     println!("{local_i32:#010x}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:78:5
+   |
+LL |     println!("{0:.1}", local_f64);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{0:.1}", local_f64);
+LL +     println!("{local_f64:.1}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:79:5
+   |
+LL |     println!("{0} {0}", local_i32);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{0} {0}", local_i32);
+LL +     println!("{local_i32} {local_i32}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:80:5
+   |
+LL |     println!("{1} {} {0} {}", local_i32, local_f64);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{1} {} {0} {}", local_i32, local_f64);
+LL +     println!("{local_f64} {local_i32} {local_i32} {local_f64}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:81:5
+   |
+LL |     println!("{0} {1}", local_i32, local_f64);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{0} {1}", local_i32, local_f64);
+LL +     println!("{local_i32} {local_f64}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:82:5
+   |
+LL |     println!("{1} {0}", local_i32, local_f64);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{1} {0}", local_i32, local_f64);
+LL +     println!("{local_f64} {local_i32}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:83:5
+   |
+LL |     println!("{1} {0} {1} {0}", local_i32, local_f64);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{1} {0} {1} {0}", local_i32, local_f64);
+LL +     println!("{local_f64} {local_i32} {local_f64} {local_i32}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:85:5
+   |
+LL |     println!("{v}", v = local_i32);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{v}", v = local_i32);
+LL +     println!("{local_i32}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:86:5
+   |
+LL |     println!("{local_i32:0$}", width);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{local_i32:0$}", width);
+LL +     println!("{local_i32:width$}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:87:5
+   |
+LL |     println!("{local_i32:w$}", w = width);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{local_i32:w$}", w = width);
+LL +     println!("{local_i32:width$}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:88:5
+   |
+LL |     println!("{local_i32:.0$}", prec);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{local_i32:.0$}", prec);
+LL +     println!("{local_i32:.prec$}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:89:5
+   |
+LL |     println!("{local_i32:.p$}", p = prec);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{local_i32:.p$}", p = prec);
+LL +     println!("{local_i32:.prec$}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:90:5
+   |
+LL |     println!("{:0$}", v = val);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{:0$}", v = val);
+LL +     println!("{val:val$}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:91:5
+   |
+LL |     println!("{0:0$}", v = val);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{0:0$}", v = val);
+LL +     println!("{val:val$}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:92:5
+   |
+LL |     println!("{:0$.0$}", v = val);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{:0$.0$}", v = val);
+LL +     println!("{val:val$.val$}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:93:5
+   |
+LL |     println!("{0:0$.0$}", v = val);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{0:0$.0$}", v = val);
+LL +     println!("{val:val$.val$}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:94:5
+   |
+LL |     println!("{0:0$.v$}", v = val);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{0:0$.v$}", v = val);
+LL +     println!("{val:val$.val$}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:95:5
+   |
+LL |     println!("{0:v$.0$}", v = val);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{0:v$.0$}", v = val);
+LL +     println!("{val:val$.val$}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:96:5
+   |
+LL |     println!("{v:0$.0$}", v = val);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{v:0$.0$}", v = val);
+LL +     println!("{val:val$.val$}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:97:5
+   |
+LL |     println!("{v:v$.0$}", v = val);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{v:v$.0$}", v = val);
+LL +     println!("{val:val$.val$}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:98:5
+   |
+LL |     println!("{v:0$.v$}", v = val);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{v:0$.v$}", v = val);
+LL +     println!("{val:val$.val$}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:99:5
+   |
+LL |     println!("{v:v$.v$}", v = val);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{v:v$.v$}", v = val);
+LL +     println!("{val:val$.val$}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:100:5
+   |
+LL |     println!("{:0$}", width);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{:0$}", width);
+LL +     println!("{width:width$}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:101:5
+   |
+LL |     println!("{:1$}", local_i32, width);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{:1$}", local_i32, width);
+LL +     println!("{local_i32:width$}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:102:5
+   |
+LL |     println!("{:w$}", w = width);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{:w$}", w = width);
+LL +     println!("{width:width$}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:103:5
+   |
+LL |     println!("{:w$}", local_i32, w = width);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{:w$}", local_i32, w = width);
+LL +     println!("{local_i32:width$}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:104:5
+   |
+LL |     println!("{:.0$}", prec);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{:.0$}", prec);
+LL +     println!("{prec:.prec$}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:105:5
+   |
+LL |     println!("{:.1$}", local_i32, prec);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{:.1$}", local_i32, prec);
+LL +     println!("{local_i32:.prec$}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:106:5
+   |
+LL |     println!("{:.p$}", p = prec);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{:.p$}", p = prec);
+LL +     println!("{prec:.prec$}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:107:5
+   |
+LL |     println!("{:.p$}", local_i32, p = prec);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{:.p$}", local_i32, p = prec);
+LL +     println!("{local_i32:.prec$}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:108:5
+   |
+LL |     println!("{:0$.1$}", width, prec);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{:0$.1$}", width, prec);
+LL +     println!("{width:width$.prec$}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:109:5
+   |
+LL |     println!("{:0$.w$}", width, w = prec);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{:0$.w$}", width, w = prec);
+LL +     println!("{width:width$.prec$}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:110:5
+   |
+LL |     println!("{:1$.2$}", local_f64, width, prec);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{:1$.2$}", local_f64, width, prec);
+LL +     println!("{local_f64:width$.prec$}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:111:5
+   |
+LL |     println!("{:1$.2$} {0} {1} {2}", local_f64, width, prec);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{:1$.2$} {0} {1} {2}", local_f64, width, prec);
+LL +     println!("{local_f64:width$.prec$} {local_f64} {width} {prec}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:112:5
+   |
+LL | /     println!(
+LL | |         "{0:1$.2$} {0:2$.1$} {1:0$.2$} {1:2$.0$} {2:0$.1$} {2:1$.0$}",
+LL | |         local_i32, width, prec,
+LL | |     );
+   | |_____^
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:123:5
+   |
+LL |     println!("Width = {}, value with width = {:0$}", local_i32, local_f64);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("Width = {}, value with width = {:0$}", local_i32, local_f64);
+LL +     println!("Width = {local_i32}, value with width = {local_f64:local_i32$}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:124:5
+   |
+LL |     println!("{:w$.p$}", local_i32, w = width, p = prec);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{:w$.p$}", local_i32, w = width, p = prec);
+LL +     println!("{local_i32:width$.prec$}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:125:5
+   |
+LL |     println!("{:w$.p$}", w = width, p = prec);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{:w$.p$}", w = width, p = prec);
+LL +     println!("{width:width$.prec$}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:126:20
+   |
+LL |     println!("{}", format!("{}", local_i32));
+   |                    ^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{}", format!("{}", local_i32));
+LL +     println!("{}", format!("{local_i32}"));
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:144:5
+   |
+LL | /     println!(
+LL | |         "{}",
+LL | |         // comment with a comma , in it
+LL | |         val,
+LL | |     );
+   | |_____^
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:149:5
+   |
+LL |     println!("{}", /* comment with a comma , in it */ val);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("{}", /* comment with a comma , in it */ val);
+LL +     println!("{val}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:155:9
+   |
+LL |         panic!("p1 {}", local_i32);
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -         panic!("p1 {}", local_i32);
+LL +         panic!("p1 {local_i32}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:158:9
+   |
+LL |         panic!("p2 {0}", local_i32);
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -         panic!("p2 {0}", local_i32);
+LL +         panic!("p2 {local_i32}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:161:9
+   |
+LL |         panic!("p3 {local_i32}", local_i32 = local_i32);
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -         panic!("p3 {local_i32}", local_i32 = local_i32);
+LL +         panic!("p3 {local_i32}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:181:5
+   |
+LL |     println!("expand='{}'", local_i32);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     println!("expand='{}'", local_i32);
+LL +     println!("expand='{local_i32}'");
+   |
+
+error: aborting due to 76 previous errors
+
diff --git a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
index f91d285c2e0..01a5e962c94 100644
--- a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
+++ b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
@@ -1,6 +1,7 @@
 error: error reading Clippy's configuration file `$DIR/clippy.toml`: unknown field `foobar`, expected one of
            allow-dbg-in-tests
            allow-expect-in-tests
+           allow-mixed-uninlined-format-args
            allow-print-in-tests
            allow-unwrap-in-tests
            allowed-scripts
diff --git a/tests/ui/uninlined_format_args.fixed b/tests/ui/uninlined_format_args.fixed
index 46ec7771114..9d08e80cf9a 100644
--- a/tests/ui/uninlined_format_args.fixed
+++ b/tests/ui/uninlined_format_args.fixed
@@ -54,11 +54,11 @@ fn tester(fn_arg: i32) {
     println!("{local_i32:<3}");
     println!("{local_i32:#010x}");
     println!("{local_f64:.1}");
-    println!("Hello {} is {local_f64:.local_i32$}", "x");
-    println!("Hello {local_i32} is {local_f64:.*}", 5);
-    println!("Hello {local_i32} is {local_f64:.*}", 5);
+    println!("Hello {} is {:.*}", "x", local_i32, local_f64);
+    println!("Hello {} is {:.*}", local_i32, 5, local_f64);
+    println!("Hello {} is {2:.*}", local_i32, 5, local_f64);
     println!("{local_i32} {local_f64}");
-    println!("{local_i32}, {}", local_opt.unwrap());
+    println!("{}, {}", local_i32, local_opt.unwrap());
     println!("{val}");
     println!("{val}");
     println!("{} {1}", local_i32, 42);
diff --git a/tests/ui/uninlined_format_args_panic.edition2018.stderr b/tests/ui/uninlined_format_args_panic.edition2018.stderr
index 2c806125922..1afdb4d0fba 100644
--- a/tests/ui/uninlined_format_args_panic.edition2018.stderr
+++ b/tests/ui/uninlined_format_args_panic.edition2018.stderr
@@ -4,6 +4,7 @@ error: variables can be used directly in the `format!` string
 LL |     println!("val='{}'", var);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: this lint can also fix mixed format arg inlining if `allow-mixed-uninlined-format-args = false` is set in the `clippy.toml` file
    = note: `-D clippy::uninlined-format-args` implied by `-D warnings`
 help: change this to
    |
diff --git a/tests/ui/uninlined_format_args_panic.edition2021.stderr b/tests/ui/uninlined_format_args_panic.edition2021.stderr
index 0f09c45f413..a38ea4168bc 100644
--- a/tests/ui/uninlined_format_args_panic.edition2021.stderr
+++ b/tests/ui/uninlined_format_args_panic.edition2021.stderr
@@ -4,6 +4,7 @@ error: variables can be used directly in the `format!` string
 LL |     println!("val='{}'", var);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+   = note: this lint can also fix mixed format arg inlining if `allow-mixed-uninlined-format-args = false` is set in the `clippy.toml` file
    = note: `-D clippy::uninlined-format-args` implied by `-D warnings`
 help: change this to
    |
-- 
cgit 1.4.1-3-g733a5


From ab576afc18e0b15167388c1a294587962a94d264 Mon Sep 17 00:00:00 2001
From: Yuri Astrakhan <YuriAstrakhan@gmail.com>
Date: Sun, 27 Nov 2022 10:34:13 -0500
Subject: addressed review feedback

---
 clippy_lints/src/format_args.rs                    |   7 -
 .../auxiliary/proc_macro_with_span.rs              |  32 -
 .../uninlined_format_args.fixed                    | 167 +---
 .../uninlined_format_args.rs                       | 170 +---
 .../uninlined_format_args.stderr                   | 860 +--------------------
 tests/ui/uninlined_format_args.stderr              |  50 +-
 .../uninlined_format_args_panic.edition2018.stderr |   1 -
 .../uninlined_format_args_panic.edition2021.stderr |   1 -
 8 files changed, 18 insertions(+), 1270 deletions(-)
 delete mode 100644 tests/ui-toml/allow_mixed_uninlined_format_args/auxiliary/proc_macro_with_span.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/format_args.rs b/clippy_lints/src/format_args.rs
index 40a37d39ecf..f0995a81329 100644
--- a/clippy_lints/src/format_args.rs
+++ b/clippy_lints/src/format_args.rs
@@ -321,13 +321,6 @@ fn check_uninlined_args(
                 Applicability::MachineApplicable,
                 if multiline_fix { CompletelyHidden } else { ShowCode },
             );
-            if ignore_mixed {
-                // Improve lint config discoverability
-                diag.note_once(
-                    "this lint can also fix mixed format arg inlining if \
-                    `allow-mixed-uninlined-format-args = false` is set in the `clippy.toml` file",
-                );
-            }
         },
     );
 }
diff --git a/tests/ui-toml/allow_mixed_uninlined_format_args/auxiliary/proc_macro_with_span.rs b/tests/ui-toml/allow_mixed_uninlined_format_args/auxiliary/proc_macro_with_span.rs
deleted file mode 100644
index 8ea631f2bbd..00000000000
--- a/tests/ui-toml/allow_mixed_uninlined_format_args/auxiliary/proc_macro_with_span.rs
+++ /dev/null
@@ -1,32 +0,0 @@
-// compile-flags: --emit=link
-// no-prefer-dynamic
-
-#![crate_type = "proc-macro"]
-
-extern crate proc_macro;
-
-use proc_macro::{token_stream::IntoIter, Group, Span, TokenStream, TokenTree};
-
-#[proc_macro]
-pub fn with_span(input: TokenStream) -> TokenStream {
-    let mut iter = input.into_iter();
-    let span = iter.next().unwrap().span();
-    let mut res = TokenStream::new();
-    write_with_span(span, iter, &mut res);
-    res
-}
-
-fn write_with_span(s: Span, input: IntoIter, out: &mut TokenStream) {
-    for mut tt in input {
-        if let TokenTree::Group(g) = tt {
-            let mut stream = TokenStream::new();
-            write_with_span(s, g.stream().into_iter(), &mut stream);
-            let mut group = Group::new(g.delimiter(), stream);
-            group.set_span(s);
-            out.extend([TokenTree::Group(group)]);
-        } else {
-            tt.set_span(s);
-            out.extend([tt]);
-        }
-    }
-}
diff --git a/tests/ui-toml/allow_mixed_uninlined_format_args/uninlined_format_args.fixed b/tests/ui-toml/allow_mixed_uninlined_format_args/uninlined_format_args.fixed
index ca56c95c23f..aa8b45b5fe7 100644
--- a/tests/ui-toml/allow_mixed_uninlined_format_args/uninlined_format_args.fixed
+++ b/tests/ui-toml/allow_mixed_uninlined_format_args/uninlined_format_args.fixed
@@ -1,177 +1,14 @@
-// aux-build:proc_macro_with_span.rs
 // run-rustfix
-#![feature(custom_inner_attributes)]
 #![warn(clippy::uninlined_format_args)]
-#![allow(named_arguments_used_positionally, unused_imports, unused_macros, unused_variables)]
-#![allow(clippy::eq_op, clippy::format_in_format_args, clippy::print_literal)]
 
-extern crate proc_macro_with_span;
-use proc_macro_with_span::with_span;
-
-macro_rules! no_param_str {
-    () => {
-        "{}"
-    };
-}
-
-macro_rules! my_println {
-   ($($args:tt),*) => {{
-        println!($($args),*)
-    }};
-}
-
-macro_rules! my_println_args {
-    ($($args:tt),*) => {{
-        println!("foo: {}", format_args!($($args),*))
-    }};
-}
-
-fn tester(fn_arg: i32) {
+fn main() {
     let local_i32 = 1;
     let local_f64 = 2.0;
     let local_opt: Option<i32> = Some(3);
-    let width = 4;
-    let prec = 5;
-    let val = 6;
-
-    // make sure this file hasn't been corrupted with tabs converted to spaces
-    // let _ = '	';  // <- this is a single tab character
-    let _: &[u8; 3] = b"	 	"; // <- <tab><space><tab>
 
     println!("val='{local_i32}'");
-    println!("val='{local_i32}'"); // 3 spaces
-    println!("val='{local_i32}'"); // tab
-    println!("val='{local_i32}'"); // space+tab
-    println!("val='{local_i32}'"); // tab+space
-    println!(
-        "val='{local_i32}'"
-    );
-    println!("{local_i32}");
-    println!("{fn_arg}");
-    println!("{local_i32:?}");
-    println!("{local_i32:#?}");
-    println!("{local_i32:4}");
-    println!("{local_i32:04}");
-    println!("{local_i32:<3}");
-    println!("{local_i32:#010x}");
-    println!("{local_f64:.1}");
-    println!("Hello {} is {local_f64:.local_i32$}", "x");
+    println!("Hello x is {local_f64:.local_i32$}");
     println!("Hello {local_i32} is {local_f64:.*}", 5);
     println!("Hello {local_i32} is {local_f64:.*}", 5);
-    println!("{local_i32} {local_f64}");
     println!("{local_i32}, {}", local_opt.unwrap());
-    println!("{val}");
-    println!("{val}");
-    println!("{} {1}", local_i32, 42);
-    println!("val='{local_i32}'");
-    println!("val='{local_i32}'");
-    println!("val='{local_i32}'");
-    println!("val='{fn_arg}'");
-    println!("{local_i32}");
-    println!("{local_i32:?}");
-    println!("{local_i32:#?}");
-    println!("{local_i32:04}");
-    println!("{local_i32:<3}");
-    println!("{local_i32:#010x}");
-    println!("{local_f64:.1}");
-    println!("{local_i32} {local_i32}");
-    println!("{local_f64} {local_i32} {local_i32} {local_f64}");
-    println!("{local_i32} {local_f64}");
-    println!("{local_f64} {local_i32}");
-    println!("{local_f64} {local_i32} {local_f64} {local_i32}");
-    println!("{1} {0}", "str", local_i32);
-    println!("{local_i32}");
-    println!("{local_i32:width$}");
-    println!("{local_i32:width$}");
-    println!("{local_i32:.prec$}");
-    println!("{local_i32:.prec$}");
-    println!("{val:val$}");
-    println!("{val:val$}");
-    println!("{val:val$.val$}");
-    println!("{val:val$.val$}");
-    println!("{val:val$.val$}");
-    println!("{val:val$.val$}");
-    println!("{val:val$.val$}");
-    println!("{val:val$.val$}");
-    println!("{val:val$.val$}");
-    println!("{val:val$.val$}");
-    println!("{width:width$}");
-    println!("{local_i32:width$}");
-    println!("{width:width$}");
-    println!("{local_i32:width$}");
-    println!("{prec:.prec$}");
-    println!("{local_i32:.prec$}");
-    println!("{prec:.prec$}");
-    println!("{local_i32:.prec$}");
-    println!("{width:width$.prec$}");
-    println!("{width:width$.prec$}");
-    println!("{local_f64:width$.prec$}");
-    println!("{local_f64:width$.prec$} {local_f64} {width} {prec}");
-    println!(
-        "{local_i32:width$.prec$} {local_i32:prec$.width$} {width:local_i32$.prec$} {width:prec$.local_i32$} {prec:local_i32$.width$} {prec:width$.local_i32$}",
-    );
-    println!(
-        "{0:1$.2$} {0:2$.1$} {1:0$.2$} {1:2$.0$} {2:0$.1$} {2:1$.0$} {3}",
-        local_i32,
-        width,
-        prec,
-        1 + 2
-    );
-    println!("Width = {local_i32}, value with width = {local_f64:local_i32$}");
-    println!("{local_i32:width$.prec$}");
-    println!("{width:width$.prec$}");
-    println!("{}", format!("{local_i32}"));
-    my_println!("{}", local_i32);
-    my_println_args!("{}", local_i32);
-
-    // these should NOT be modified by the lint
-    println!(concat!("nope ", "{}"), local_i32);
-    println!("val='{local_i32}'");
-    println!("val='{local_i32 }'");
-    println!("val='{local_i32	}'"); // with tab
-    println!("val='{local_i32\n}'");
-    println!("{}", usize::MAX);
-    println!("{}", local_opt.unwrap());
-    println!(
-        "val='{local_i32
-    }'"
-    );
-    println!(no_param_str!(), local_i32);
-
-    println!(
-        "{val}",
-    );
-    println!("{val}");
-
-    println!(with_span!("{0} {1}" "{1} {0}"), local_i32, local_f64);
-    println!("{}", with_span!(span val));
-
-    if local_i32 > 0 {
-        panic!("p1 {local_i32}");
-    }
-    if local_i32 > 0 {
-        panic!("p2 {local_i32}");
-    }
-    if local_i32 > 0 {
-        panic!("p3 {local_i32}");
-    }
-    if local_i32 > 0 {
-        panic!("p4 {local_i32}");
-    }
-}
-
-fn main() {
-    tester(42);
-}
-
-fn _under_msrv() {
-    #![clippy::msrv = "1.57"]
-    let local_i32 = 1;
-    println!("don't expand='{}'", local_i32);
-}
-
-fn _meets_msrv() {
-    #![clippy::msrv = "1.58"]
-    let local_i32 = 1;
-    println!("expand='{local_i32}'");
 }
diff --git a/tests/ui-toml/allow_mixed_uninlined_format_args/uninlined_format_args.rs b/tests/ui-toml/allow_mixed_uninlined_format_args/uninlined_format_args.rs
index 8e495ebd083..ad2e4863ee8 100644
--- a/tests/ui-toml/allow_mixed_uninlined_format_args/uninlined_format_args.rs
+++ b/tests/ui-toml/allow_mixed_uninlined_format_args/uninlined_format_args.rs
@@ -1,182 +1,14 @@
-// aux-build:proc_macro_with_span.rs
 // run-rustfix
-#![feature(custom_inner_attributes)]
 #![warn(clippy::uninlined_format_args)]
-#![allow(named_arguments_used_positionally, unused_imports, unused_macros, unused_variables)]
-#![allow(clippy::eq_op, clippy::format_in_format_args, clippy::print_literal)]
 
-extern crate proc_macro_with_span;
-use proc_macro_with_span::with_span;
-
-macro_rules! no_param_str {
-    () => {
-        "{}"
-    };
-}
-
-macro_rules! my_println {
-   ($($args:tt),*) => {{
-        println!($($args),*)
-    }};
-}
-
-macro_rules! my_println_args {
-    ($($args:tt),*) => {{
-        println!("foo: {}", format_args!($($args),*))
-    }};
-}
-
-fn tester(fn_arg: i32) {
+fn main() {
     let local_i32 = 1;
     let local_f64 = 2.0;
     let local_opt: Option<i32> = Some(3);
-    let width = 4;
-    let prec = 5;
-    let val = 6;
-
-    // make sure this file hasn't been corrupted with tabs converted to spaces
-    // let _ = '	';  // <- this is a single tab character
-    let _: &[u8; 3] = b"	 	"; // <- <tab><space><tab>
 
     println!("val='{}'", local_i32);
-    println!("val='{   }'", local_i32); // 3 spaces
-    println!("val='{	}'", local_i32); // tab
-    println!("val='{ 	}'", local_i32); // space+tab
-    println!("val='{	 }'", local_i32); // tab+space
-    println!(
-        "val='{
-    }'",
-        local_i32
-    );
-    println!("{}", local_i32);
-    println!("{}", fn_arg);
-    println!("{:?}", local_i32);
-    println!("{:#?}", local_i32);
-    println!("{:4}", local_i32);
-    println!("{:04}", local_i32);
-    println!("{:<3}", local_i32);
-    println!("{:#010x}", local_i32);
-    println!("{:.1}", local_f64);
     println!("Hello {} is {:.*}", "x", local_i32, local_f64);
     println!("Hello {} is {:.*}", local_i32, 5, local_f64);
     println!("Hello {} is {2:.*}", local_i32, 5, local_f64);
-    println!("{} {}", local_i32, local_f64);
     println!("{}, {}", local_i32, local_opt.unwrap());
-    println!("{}", val);
-    println!("{}", v = val);
-    println!("{} {1}", local_i32, 42);
-    println!("val='{\t }'", local_i32);
-    println!("val='{\n }'", local_i32);
-    println!("val='{local_i32}'", local_i32 = local_i32);
-    println!("val='{local_i32}'", local_i32 = fn_arg);
-    println!("{0}", local_i32);
-    println!("{0:?}", local_i32);
-    println!("{0:#?}", local_i32);
-    println!("{0:04}", local_i32);
-    println!("{0:<3}", local_i32);
-    println!("{0:#010x}", local_i32);
-    println!("{0:.1}", local_f64);
-    println!("{0} {0}", local_i32);
-    println!("{1} {} {0} {}", local_i32, local_f64);
-    println!("{0} {1}", local_i32, local_f64);
-    println!("{1} {0}", local_i32, local_f64);
-    println!("{1} {0} {1} {0}", local_i32, local_f64);
-    println!("{1} {0}", "str", local_i32);
-    println!("{v}", v = local_i32);
-    println!("{local_i32:0$}", width);
-    println!("{local_i32:w$}", w = width);
-    println!("{local_i32:.0$}", prec);
-    println!("{local_i32:.p$}", p = prec);
-    println!("{:0$}", v = val);
-    println!("{0:0$}", v = val);
-    println!("{:0$.0$}", v = val);
-    println!("{0:0$.0$}", v = val);
-    println!("{0:0$.v$}", v = val);
-    println!("{0:v$.0$}", v = val);
-    println!("{v:0$.0$}", v = val);
-    println!("{v:v$.0$}", v = val);
-    println!("{v:0$.v$}", v = val);
-    println!("{v:v$.v$}", v = val);
-    println!("{:0$}", width);
-    println!("{:1$}", local_i32, width);
-    println!("{:w$}", w = width);
-    println!("{:w$}", local_i32, w = width);
-    println!("{:.0$}", prec);
-    println!("{:.1$}", local_i32, prec);
-    println!("{:.p$}", p = prec);
-    println!("{:.p$}", local_i32, p = prec);
-    println!("{:0$.1$}", width, prec);
-    println!("{:0$.w$}", width, w = prec);
-    println!("{:1$.2$}", local_f64, width, prec);
-    println!("{:1$.2$} {0} {1} {2}", local_f64, width, prec);
-    println!(
-        "{0:1$.2$} {0:2$.1$} {1:0$.2$} {1:2$.0$} {2:0$.1$} {2:1$.0$}",
-        local_i32, width, prec,
-    );
-    println!(
-        "{0:1$.2$} {0:2$.1$} {1:0$.2$} {1:2$.0$} {2:0$.1$} {2:1$.0$} {3}",
-        local_i32,
-        width,
-        prec,
-        1 + 2
-    );
-    println!("Width = {}, value with width = {:0$}", local_i32, local_f64);
-    println!("{:w$.p$}", local_i32, w = width, p = prec);
-    println!("{:w$.p$}", w = width, p = prec);
-    println!("{}", format!("{}", local_i32));
-    my_println!("{}", local_i32);
-    my_println_args!("{}", local_i32);
-
-    // these should NOT be modified by the lint
-    println!(concat!("nope ", "{}"), local_i32);
-    println!("val='{local_i32}'");
-    println!("val='{local_i32 }'");
-    println!("val='{local_i32	}'"); // with tab
-    println!("val='{local_i32\n}'");
-    println!("{}", usize::MAX);
-    println!("{}", local_opt.unwrap());
-    println!(
-        "val='{local_i32
-    }'"
-    );
-    println!(no_param_str!(), local_i32);
-
-    println!(
-        "{}",
-        // comment with a comma , in it
-        val,
-    );
-    println!("{}", /* comment with a comma , in it */ val);
-
-    println!(with_span!("{0} {1}" "{1} {0}"), local_i32, local_f64);
-    println!("{}", with_span!(span val));
-
-    if local_i32 > 0 {
-        panic!("p1 {}", local_i32);
-    }
-    if local_i32 > 0 {
-        panic!("p2 {0}", local_i32);
-    }
-    if local_i32 > 0 {
-        panic!("p3 {local_i32}", local_i32 = local_i32);
-    }
-    if local_i32 > 0 {
-        panic!("p4 {local_i32}");
-    }
-}
-
-fn main() {
-    tester(42);
-}
-
-fn _under_msrv() {
-    #![clippy::msrv = "1.57"]
-    let local_i32 = 1;
-    println!("don't expand='{}'", local_i32);
-}
-
-fn _meets_msrv() {
-    #![clippy::msrv = "1.58"]
-    let local_i32 = 1;
-    println!("expand='{}'", local_i32);
 }
diff --git a/tests/ui-toml/allow_mixed_uninlined_format_args/uninlined_format_args.stderr b/tests/ui-toml/allow_mixed_uninlined_format_args/uninlined_format_args.stderr
index 1182d57ce9b..ee941762196 100644
--- a/tests/ui-toml/allow_mixed_uninlined_format_args/uninlined_format_args.stderr
+++ b/tests/ui-toml/allow_mixed_uninlined_format_args/uninlined_format_args.stderr
@@ -1,5 +1,5 @@
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:41:5
+  --> $DIR/uninlined_format_args.rs:9:5
    |
 LL |     println!("val='{}'", local_i32);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -11,174 +11,21 @@ LL -     println!("val='{}'", local_i32);
 LL +     println!("val='{local_i32}'");
    |
 
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:42:5
-   |
-LL |     println!("val='{   }'", local_i32); // 3 spaces
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: change this to
-   |
-LL -     println!("val='{   }'", local_i32); // 3 spaces
-LL +     println!("val='{local_i32}'"); // 3 spaces
-   |
-
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:43:5
-   |
-LL |     println!("val='{    }'", local_i32); // tab
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: change this to
-   |
-LL -     println!("val='{    }'", local_i32); // tab
-LL +     println!("val='{local_i32}'"); // tab
-   |
-
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:44:5
-   |
-LL |     println!("val='{     }'", local_i32); // space+tab
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: change this to
-   |
-LL -     println!("val='{     }'", local_i32); // space+tab
-LL +     println!("val='{local_i32}'"); // space+tab
-   |
-
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:45:5
-   |
-LL |     println!("val='{     }'", local_i32); // tab+space
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: change this to
-   |
-LL -     println!("val='{     }'", local_i32); // tab+space
-LL +     println!("val='{local_i32}'"); // tab+space
-   |
-
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:46:5
-   |
-LL | /     println!(
-LL | |         "val='{
-LL | |     }'",
-LL | |         local_i32
-LL | |     );
-   | |_____^
-
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:51:5
-   |
-LL |     println!("{}", local_i32);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: change this to
-   |
-LL -     println!("{}", local_i32);
-LL +     println!("{local_i32}");
-   |
-
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:52:5
-   |
-LL |     println!("{}", fn_arg);
-   |     ^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: change this to
-   |
-LL -     println!("{}", fn_arg);
-LL +     println!("{fn_arg}");
-   |
-
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:53:5
-   |
-LL |     println!("{:?}", local_i32);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+error: literal with an empty format string
+  --> $DIR/uninlined_format_args.rs:10:35
    |
-help: change this to
-   |
-LL -     println!("{:?}", local_i32);
-LL +     println!("{local_i32:?}");
-   |
-
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:54:5
-   |
-LL |     println!("{:#?}", local_i32);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: change this to
-   |
-LL -     println!("{:#?}", local_i32);
-LL +     println!("{local_i32:#?}");
-   |
-
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:55:5
-   |
-LL |     println!("{:4}", local_i32);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: change this to
-   |
-LL -     println!("{:4}", local_i32);
-LL +     println!("{local_i32:4}");
-   |
-
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:56:5
-   |
-LL |     println!("{:04}", local_i32);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: change this to
-   |
-LL -     println!("{:04}", local_i32);
-LL +     println!("{local_i32:04}");
-   |
-
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:57:5
-   |
-LL |     println!("{:<3}", local_i32);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: change this to
-   |
-LL -     println!("{:<3}", local_i32);
-LL +     println!("{local_i32:<3}");
-   |
-
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:58:5
-   |
-LL |     println!("{:#010x}", local_i32);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: change this to
-   |
-LL -     println!("{:#010x}", local_i32);
-LL +     println!("{local_i32:#010x}");
-   |
-
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:59:5
+LL |     println!("Hello {} is {:.*}", "x", local_i32, local_f64);
+   |                                   ^^^
    |
-LL |     println!("{:.1}", local_f64);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   = note: `-D clippy::print-literal` implied by `-D warnings`
+help: try this
    |
-help: change this to
-   |
-LL -     println!("{:.1}", local_f64);
-LL +     println!("{local_f64:.1}");
+LL -     println!("Hello {} is {:.*}", "x", local_i32, local_f64);
+LL +     println!("Hello x is {:.*}", local_i32, local_f64);
    |
 
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:60:5
+  --> $DIR/uninlined_format_args.rs:10:5
    |
 LL |     println!("Hello {} is {:.*}", "x", local_i32, local_f64);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -190,7 +37,7 @@ LL +     println!("Hello {} is {local_f64:.local_i32$}", "x");
    |
 
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:61:5
+  --> $DIR/uninlined_format_args.rs:11:5
    |
 LL |     println!("Hello {} is {:.*}", local_i32, 5, local_f64);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -202,7 +49,7 @@ LL +     println!("Hello {local_i32} is {local_f64:.*}", 5);
    |
 
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:62:5
+  --> $DIR/uninlined_format_args.rs:12:5
    |
 LL |     println!("Hello {} is {2:.*}", local_i32, 5, local_f64);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -214,19 +61,7 @@ LL +     println!("Hello {local_i32} is {local_f64:.*}", 5);
    |
 
 error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:63:5
-   |
-LL |     println!("{} {}", local_i32, local_f64);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: change this to
-   |
-LL -     println!("{} {}", local_i32, local_f64);
-LL +     println!("{local_i32} {local_f64}");
-   |
-
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:64:5
+  --> $DIR/uninlined_format_args.rs:13:5
    |
 LL |     println!("{}, {}", local_i32, local_opt.unwrap());
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -237,672 +72,5 @@ LL -     println!("{}, {}", local_i32, local_opt.unwrap());
 LL +     println!("{local_i32}, {}", local_opt.unwrap());
    |
 
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:65:5
-   |
-LL |     println!("{}", val);
-   |     ^^^^^^^^^^^^^^^^^^^
-   |
-help: change this to
-   |
-LL -     println!("{}", val);
-LL +     println!("{val}");
-   |
-
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:66:5
-   |
-LL |     println!("{}", v = val);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: change this to
-   |
-LL -     println!("{}", v = val);
-LL +     println!("{val}");
-   |
-
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:68:5
-   |
-LL |     println!("val='{/t }'", local_i32);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: change this to
-   |
-LL -     println!("val='{/t }'", local_i32);
-LL +     println!("val='{local_i32}'");
-   |
-
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:69:5
-   |
-LL |     println!("val='{/n }'", local_i32);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: change this to
-   |
-LL -     println!("val='{/n }'", local_i32);
-LL +     println!("val='{local_i32}'");
-   |
-
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:70:5
-   |
-LL |     println!("val='{local_i32}'", local_i32 = local_i32);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: change this to
-   |
-LL -     println!("val='{local_i32}'", local_i32 = local_i32);
-LL +     println!("val='{local_i32}'");
-   |
-
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:71:5
-   |
-LL |     println!("val='{local_i32}'", local_i32 = fn_arg);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: change this to
-   |
-LL -     println!("val='{local_i32}'", local_i32 = fn_arg);
-LL +     println!("val='{fn_arg}'");
-   |
-
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:72:5
-   |
-LL |     println!("{0}", local_i32);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: change this to
-   |
-LL -     println!("{0}", local_i32);
-LL +     println!("{local_i32}");
-   |
-
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:73:5
-   |
-LL |     println!("{0:?}", local_i32);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: change this to
-   |
-LL -     println!("{0:?}", local_i32);
-LL +     println!("{local_i32:?}");
-   |
-
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:74:5
-   |
-LL |     println!("{0:#?}", local_i32);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: change this to
-   |
-LL -     println!("{0:#?}", local_i32);
-LL +     println!("{local_i32:#?}");
-   |
-
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:75:5
-   |
-LL |     println!("{0:04}", local_i32);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: change this to
-   |
-LL -     println!("{0:04}", local_i32);
-LL +     println!("{local_i32:04}");
-   |
-
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:76:5
-   |
-LL |     println!("{0:<3}", local_i32);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: change this to
-   |
-LL -     println!("{0:<3}", local_i32);
-LL +     println!("{local_i32:<3}");
-   |
-
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:77:5
-   |
-LL |     println!("{0:#010x}", local_i32);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: change this to
-   |
-LL -     println!("{0:#010x}", local_i32);
-LL +     println!("{local_i32:#010x}");
-   |
-
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:78:5
-   |
-LL |     println!("{0:.1}", local_f64);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: change this to
-   |
-LL -     println!("{0:.1}", local_f64);
-LL +     println!("{local_f64:.1}");
-   |
-
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:79:5
-   |
-LL |     println!("{0} {0}", local_i32);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: change this to
-   |
-LL -     println!("{0} {0}", local_i32);
-LL +     println!("{local_i32} {local_i32}");
-   |
-
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:80:5
-   |
-LL |     println!("{1} {} {0} {}", local_i32, local_f64);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: change this to
-   |
-LL -     println!("{1} {} {0} {}", local_i32, local_f64);
-LL +     println!("{local_f64} {local_i32} {local_i32} {local_f64}");
-   |
-
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:81:5
-   |
-LL |     println!("{0} {1}", local_i32, local_f64);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: change this to
-   |
-LL -     println!("{0} {1}", local_i32, local_f64);
-LL +     println!("{local_i32} {local_f64}");
-   |
-
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:82:5
-   |
-LL |     println!("{1} {0}", local_i32, local_f64);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: change this to
-   |
-LL -     println!("{1} {0}", local_i32, local_f64);
-LL +     println!("{local_f64} {local_i32}");
-   |
-
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:83:5
-   |
-LL |     println!("{1} {0} {1} {0}", local_i32, local_f64);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: change this to
-   |
-LL -     println!("{1} {0} {1} {0}", local_i32, local_f64);
-LL +     println!("{local_f64} {local_i32} {local_f64} {local_i32}");
-   |
-
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:85:5
-   |
-LL |     println!("{v}", v = local_i32);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: change this to
-   |
-LL -     println!("{v}", v = local_i32);
-LL +     println!("{local_i32}");
-   |
-
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:86:5
-   |
-LL |     println!("{local_i32:0$}", width);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: change this to
-   |
-LL -     println!("{local_i32:0$}", width);
-LL +     println!("{local_i32:width$}");
-   |
-
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:87:5
-   |
-LL |     println!("{local_i32:w$}", w = width);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: change this to
-   |
-LL -     println!("{local_i32:w$}", w = width);
-LL +     println!("{local_i32:width$}");
-   |
-
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:88:5
-   |
-LL |     println!("{local_i32:.0$}", prec);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: change this to
-   |
-LL -     println!("{local_i32:.0$}", prec);
-LL +     println!("{local_i32:.prec$}");
-   |
-
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:89:5
-   |
-LL |     println!("{local_i32:.p$}", p = prec);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: change this to
-   |
-LL -     println!("{local_i32:.p$}", p = prec);
-LL +     println!("{local_i32:.prec$}");
-   |
-
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:90:5
-   |
-LL |     println!("{:0$}", v = val);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: change this to
-   |
-LL -     println!("{:0$}", v = val);
-LL +     println!("{val:val$}");
-   |
-
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:91:5
-   |
-LL |     println!("{0:0$}", v = val);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: change this to
-   |
-LL -     println!("{0:0$}", v = val);
-LL +     println!("{val:val$}");
-   |
-
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:92:5
-   |
-LL |     println!("{:0$.0$}", v = val);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: change this to
-   |
-LL -     println!("{:0$.0$}", v = val);
-LL +     println!("{val:val$.val$}");
-   |
-
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:93:5
-   |
-LL |     println!("{0:0$.0$}", v = val);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: change this to
-   |
-LL -     println!("{0:0$.0$}", v = val);
-LL +     println!("{val:val$.val$}");
-   |
-
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:94:5
-   |
-LL |     println!("{0:0$.v$}", v = val);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: change this to
-   |
-LL -     println!("{0:0$.v$}", v = val);
-LL +     println!("{val:val$.val$}");
-   |
-
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:95:5
-   |
-LL |     println!("{0:v$.0$}", v = val);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: change this to
-   |
-LL -     println!("{0:v$.0$}", v = val);
-LL +     println!("{val:val$.val$}");
-   |
-
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:96:5
-   |
-LL |     println!("{v:0$.0$}", v = val);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: change this to
-   |
-LL -     println!("{v:0$.0$}", v = val);
-LL +     println!("{val:val$.val$}");
-   |
-
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:97:5
-   |
-LL |     println!("{v:v$.0$}", v = val);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: change this to
-   |
-LL -     println!("{v:v$.0$}", v = val);
-LL +     println!("{val:val$.val$}");
-   |
-
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:98:5
-   |
-LL |     println!("{v:0$.v$}", v = val);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: change this to
-   |
-LL -     println!("{v:0$.v$}", v = val);
-LL +     println!("{val:val$.val$}");
-   |
-
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:99:5
-   |
-LL |     println!("{v:v$.v$}", v = val);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: change this to
-   |
-LL -     println!("{v:v$.v$}", v = val);
-LL +     println!("{val:val$.val$}");
-   |
-
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:100:5
-   |
-LL |     println!("{:0$}", width);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: change this to
-   |
-LL -     println!("{:0$}", width);
-LL +     println!("{width:width$}");
-   |
-
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:101:5
-   |
-LL |     println!("{:1$}", local_i32, width);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: change this to
-   |
-LL -     println!("{:1$}", local_i32, width);
-LL +     println!("{local_i32:width$}");
-   |
-
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:102:5
-   |
-LL |     println!("{:w$}", w = width);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: change this to
-   |
-LL -     println!("{:w$}", w = width);
-LL +     println!("{width:width$}");
-   |
-
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:103:5
-   |
-LL |     println!("{:w$}", local_i32, w = width);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: change this to
-   |
-LL -     println!("{:w$}", local_i32, w = width);
-LL +     println!("{local_i32:width$}");
-   |
-
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:104:5
-   |
-LL |     println!("{:.0$}", prec);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: change this to
-   |
-LL -     println!("{:.0$}", prec);
-LL +     println!("{prec:.prec$}");
-   |
-
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:105:5
-   |
-LL |     println!("{:.1$}", local_i32, prec);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: change this to
-   |
-LL -     println!("{:.1$}", local_i32, prec);
-LL +     println!("{local_i32:.prec$}");
-   |
-
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:106:5
-   |
-LL |     println!("{:.p$}", p = prec);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: change this to
-   |
-LL -     println!("{:.p$}", p = prec);
-LL +     println!("{prec:.prec$}");
-   |
-
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:107:5
-   |
-LL |     println!("{:.p$}", local_i32, p = prec);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: change this to
-   |
-LL -     println!("{:.p$}", local_i32, p = prec);
-LL +     println!("{local_i32:.prec$}");
-   |
-
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:108:5
-   |
-LL |     println!("{:0$.1$}", width, prec);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: change this to
-   |
-LL -     println!("{:0$.1$}", width, prec);
-LL +     println!("{width:width$.prec$}");
-   |
-
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:109:5
-   |
-LL |     println!("{:0$.w$}", width, w = prec);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: change this to
-   |
-LL -     println!("{:0$.w$}", width, w = prec);
-LL +     println!("{width:width$.prec$}");
-   |
-
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:110:5
-   |
-LL |     println!("{:1$.2$}", local_f64, width, prec);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: change this to
-   |
-LL -     println!("{:1$.2$}", local_f64, width, prec);
-LL +     println!("{local_f64:width$.prec$}");
-   |
-
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:111:5
-   |
-LL |     println!("{:1$.2$} {0} {1} {2}", local_f64, width, prec);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: change this to
-   |
-LL -     println!("{:1$.2$} {0} {1} {2}", local_f64, width, prec);
-LL +     println!("{local_f64:width$.prec$} {local_f64} {width} {prec}");
-   |
-
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:112:5
-   |
-LL | /     println!(
-LL | |         "{0:1$.2$} {0:2$.1$} {1:0$.2$} {1:2$.0$} {2:0$.1$} {2:1$.0$}",
-LL | |         local_i32, width, prec,
-LL | |     );
-   | |_____^
-
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:123:5
-   |
-LL |     println!("Width = {}, value with width = {:0$}", local_i32, local_f64);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: change this to
-   |
-LL -     println!("Width = {}, value with width = {:0$}", local_i32, local_f64);
-LL +     println!("Width = {local_i32}, value with width = {local_f64:local_i32$}");
-   |
-
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:124:5
-   |
-LL |     println!("{:w$.p$}", local_i32, w = width, p = prec);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: change this to
-   |
-LL -     println!("{:w$.p$}", local_i32, w = width, p = prec);
-LL +     println!("{local_i32:width$.prec$}");
-   |
-
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:125:5
-   |
-LL |     println!("{:w$.p$}", w = width, p = prec);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: change this to
-   |
-LL -     println!("{:w$.p$}", w = width, p = prec);
-LL +     println!("{width:width$.prec$}");
-   |
-
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:126:20
-   |
-LL |     println!("{}", format!("{}", local_i32));
-   |                    ^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: change this to
-   |
-LL -     println!("{}", format!("{}", local_i32));
-LL +     println!("{}", format!("{local_i32}"));
-   |
-
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:144:5
-   |
-LL | /     println!(
-LL | |         "{}",
-LL | |         // comment with a comma , in it
-LL | |         val,
-LL | |     );
-   | |_____^
-
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:149:5
-   |
-LL |     println!("{}", /* comment with a comma , in it */ val);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: change this to
-   |
-LL -     println!("{}", /* comment with a comma , in it */ val);
-LL +     println!("{val}");
-   |
-
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:155:9
-   |
-LL |         panic!("p1 {}", local_i32);
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: change this to
-   |
-LL -         panic!("p1 {}", local_i32);
-LL +         panic!("p1 {local_i32}");
-   |
-
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:158:9
-   |
-LL |         panic!("p2 {0}", local_i32);
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: change this to
-   |
-LL -         panic!("p2 {0}", local_i32);
-LL +         panic!("p2 {local_i32}");
-   |
-
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:161:9
-   |
-LL |         panic!("p3 {local_i32}", local_i32 = local_i32);
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: change this to
-   |
-LL -         panic!("p3 {local_i32}", local_i32 = local_i32);
-LL +         panic!("p3 {local_i32}");
-   |
-
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:181:5
-   |
-LL |     println!("expand='{}'", local_i32);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: change this to
-   |
-LL -     println!("expand='{}'", local_i32);
-LL +     println!("expand='{local_i32}'");
-   |
-
-error: aborting due to 76 previous errors
+error: aborting due to 6 previous errors
 
diff --git a/tests/ui/uninlined_format_args.stderr b/tests/ui/uninlined_format_args.stderr
index 05ed5b6616c..a12abf8bef8 100644
--- a/tests/ui/uninlined_format_args.stderr
+++ b/tests/ui/uninlined_format_args.stderr
@@ -177,42 +177,6 @@ LL -     println!("{:.1}", local_f64);
 LL +     println!("{local_f64:.1}");
    |
 
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:59:5
-   |
-LL |     println!("Hello {} is {:.*}", "x", local_i32, local_f64);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: change this to
-   |
-LL -     println!("Hello {} is {:.*}", "x", local_i32, local_f64);
-LL +     println!("Hello {} is {local_f64:.local_i32$}", "x");
-   |
-
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:60:5
-   |
-LL |     println!("Hello {} is {:.*}", local_i32, 5, local_f64);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: change this to
-   |
-LL -     println!("Hello {} is {:.*}", local_i32, 5, local_f64);
-LL +     println!("Hello {local_i32} is {local_f64:.*}", 5);
-   |
-
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:61:5
-   |
-LL |     println!("Hello {} is {2:.*}", local_i32, 5, local_f64);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: change this to
-   |
-LL -     println!("Hello {} is {2:.*}", local_i32, 5, local_f64);
-LL +     println!("Hello {local_i32} is {local_f64:.*}", 5);
-   |
-
 error: variables can be used directly in the `format!` string
   --> $DIR/uninlined_format_args.rs:62:5
    |
@@ -225,18 +189,6 @@ LL -     println!("{} {}", local_i32, local_f64);
 LL +     println!("{local_i32} {local_f64}");
    |
 
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:63:5
-   |
-LL |     println!("{}, {}", local_i32, local_opt.unwrap());
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: change this to
-   |
-LL -     println!("{}, {}", local_i32, local_opt.unwrap());
-LL +     println!("{local_i32}, {}", local_opt.unwrap());
-   |
-
 error: variables can be used directly in the `format!` string
   --> $DIR/uninlined_format_args.rs:64:5
    |
@@ -904,5 +856,5 @@ LL -     println!("expand='{}'", local_i32);
 LL +     println!("expand='{local_i32}'");
    |
 
-error: aborting due to 76 previous errors
+error: aborting due to 72 previous errors
 
diff --git a/tests/ui/uninlined_format_args_panic.edition2018.stderr b/tests/ui/uninlined_format_args_panic.edition2018.stderr
index 1afdb4d0fba..2c806125922 100644
--- a/tests/ui/uninlined_format_args_panic.edition2018.stderr
+++ b/tests/ui/uninlined_format_args_panic.edition2018.stderr
@@ -4,7 +4,6 @@ error: variables can be used directly in the `format!` string
 LL |     println!("val='{}'", var);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = note: this lint can also fix mixed format arg inlining if `allow-mixed-uninlined-format-args = false` is set in the `clippy.toml` file
    = note: `-D clippy::uninlined-format-args` implied by `-D warnings`
 help: change this to
    |
diff --git a/tests/ui/uninlined_format_args_panic.edition2021.stderr b/tests/ui/uninlined_format_args_panic.edition2021.stderr
index a38ea4168bc..0f09c45f413 100644
--- a/tests/ui/uninlined_format_args_panic.edition2021.stderr
+++ b/tests/ui/uninlined_format_args_panic.edition2021.stderr
@@ -4,7 +4,6 @@ error: variables can be used directly in the `format!` string
 LL |     println!("val='{}'", var);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = note: this lint can also fix mixed format arg inlining if `allow-mixed-uninlined-format-args = false` is set in the `clippy.toml` file
    = note: `-D clippy::uninlined-format-args` implied by `-D warnings`
 help: change this to
    |
-- 
cgit 1.4.1-3-g733a5


From f62eab43123ac463d7ff95590c285cb30e86b1f7 Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukastw97@gmail.com>
Date: Fri, 25 Nov 2022 17:10:05 +0100
Subject: Adjust description once more

---
 clippy_lints/src/semicolon_block.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/semicolon_block.rs b/clippy_lints/src/semicolon_block.rs
index 6861b370939..d3cab68137c 100644
--- a/clippy_lints/src/semicolon_block.rs
+++ b/clippy_lints/src/semicolon_block.rs
@@ -8,7 +8,7 @@ use rustc_span::Span;
 declare_clippy_lint! {
     /// ### What it does
     ///
-    /// Checks for semicolon terminated blocks containing only a single expression.
+    /// Suggests moving the semicolon from a block inside of the block to its kast expression.
     ///
     /// ### Why is this bad?
     ///
@@ -36,7 +36,7 @@ declare_clippy_lint! {
 declare_clippy_lint! {
     /// ### What it does
     ///
-    /// Checks for blocks containing only a single semicolon terminated statement.
+    /// Suggests moving the semicolon from a block's final expression outside of the block.
     ///
     /// ### Why is this bad?
     ///
@@ -80,7 +80,7 @@ impl LateLintPass<'_> for SemicolonBlock {
                     span,
                     ..
                 } = stmt else { return };
-                semicolon_outside_block(cx, block, expr, span)
+                semicolon_outside_block(cx, block, expr, span);
             },
             StmtKind::Semi(Expr {
                 kind: ExprKind::Block(block @ Block { expr: Some(tail), .. }, _),
-- 
cgit 1.4.1-3-g733a5


From 6bbf16660bf218b16d64d812b4c3d916cf827a88 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Mon, 28 Nov 2022 20:23:09 +0100
Subject: Move `index_refutable_slice` to `pedantic`

---
 clippy_lints/src/index_refutable_slice.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/index_refutable_slice.rs b/clippy_lints/src/index_refutable_slice.rs
index ee5f10da5b8..cf35b1f175c 100644
--- a/clippy_lints/src/index_refutable_slice.rs
+++ b/clippy_lints/src/index_refutable_slice.rs
@@ -47,7 +47,7 @@ declare_clippy_lint! {
     /// ```
     #[clippy::version = "1.59.0"]
     pub INDEX_REFUTABLE_SLICE,
-    nursery,
+    pedantic,
     "avoid indexing on slices which could be destructed"
 }
 
-- 
cgit 1.4.1-3-g733a5


From 0893322e5412f78e8214c3ebc8b5b79a8c976f38 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Mon, 28 Nov 2022 23:56:02 -0500
Subject: Don't lint `unnecessary_operation` in mixed macro contexts

---
 clippy_lints/src/no_effect.rs        | 8 ++++++--
 tests/ui/unnecessary_operation.fixed | 9 +++++++++
 tests/ui/unnecessary_operation.rs    | 9 +++++++++
 3 files changed, 24 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/no_effect.rs b/clippy_lints/src/no_effect.rs
index 819646bb678..79c1ae4861e 100644
--- a/clippy_lints/src/no_effect.rs
+++ b/clippy_lints/src/no_effect.rs
@@ -6,7 +6,8 @@ use clippy_utils::ty::has_drop;
 use rustc_errors::Applicability;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::{is_range_literal, BinOpKind, BlockCheckMode, Expr, ExprKind, PatKind, Stmt, StmtKind, UnsafeSource};
-use rustc_lint::{LateContext, LateLintPass};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use std::ops::Deref;
 
@@ -159,8 +160,11 @@ fn has_no_effect(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
 fn check_unnecessary_operation(cx: &LateContext<'_>, stmt: &Stmt<'_>) {
     if_chain! {
         if let StmtKind::Semi(expr) = stmt.kind;
+        let ctxt = stmt.span.ctxt();
+        if expr.span.ctxt() == ctxt;
         if let Some(reduced) = reduce_expression(cx, expr);
-        if !&reduced.iter().any(|e| e.span.from_expansion());
+        if !in_external_macro(cx.sess(), stmt.span);
+        if reduced.iter().all(|e| e.span.ctxt() == ctxt);
         then {
             if let ExprKind::Index(..) = &expr.kind {
                 let snippet = if let (Some(arr), Some(func)) =
diff --git a/tests/ui/unnecessary_operation.fixed b/tests/ui/unnecessary_operation.fixed
index bf0ec8deb34..d37163570ab 100644
--- a/tests/ui/unnecessary_operation.fixed
+++ b/tests/ui/unnecessary_operation.fixed
@@ -76,4 +76,13 @@ fn main() {
     DropStruct { ..get_drop_struct() };
     DropEnum::Tuple(get_number());
     DropEnum::Struct { field: get_number() };
+
+    // Issue #9954
+    fn one() -> i8 {
+        1
+    }
+    macro_rules! use_expr {
+        ($($e:expr),*) => {{ $($e;)* }}
+    }
+    use_expr!(isize::MIN / -(one() as isize), i8::MIN / -one());
 }
diff --git a/tests/ui/unnecessary_operation.rs b/tests/ui/unnecessary_operation.rs
index 08cb9ab522e..a14fd4bca0e 100644
--- a/tests/ui/unnecessary_operation.rs
+++ b/tests/ui/unnecessary_operation.rs
@@ -80,4 +80,13 @@ fn main() {
     DropStruct { ..get_drop_struct() };
     DropEnum::Tuple(get_number());
     DropEnum::Struct { field: get_number() };
+
+    // Issue #9954
+    fn one() -> i8 {
+        1
+    }
+    macro_rules! use_expr {
+        ($($e:expr),*) => {{ $($e;)* }}
+    }
+    use_expr!(isize::MIN / -(one() as isize), i8::MIN / -one());
 }
-- 
cgit 1.4.1-3-g733a5


From f44b7aa81eca5916a165f571b4621a9ec1dd22fb Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Mon, 28 Nov 2022 23:30:56 -0500
Subject: Don't lint `unnecessary_cast` in mixed macro context

---
 clippy_lints/src/casts/unnecessary_cast.rs | 11 +++++++-
 tests/ui/unnecessary_cast.fixed            | 11 ++++++++
 tests/ui/unnecessary_cast.rs               | 11 ++++++++
 tests/ui/unnecessary_cast.stderr           | 44 +++++++++++++++---------------
 4 files changed, 54 insertions(+), 23 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/unnecessary_cast.rs b/clippy_lints/src/casts/unnecessary_cast.rs
index c8596987e4d..ecc8a8de97b 100644
--- a/clippy_lints/src/casts/unnecessary_cast.rs
+++ b/clippy_lints/src/casts/unnecessary_cast.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::get_parent_expr;
 use clippy_utils::numeric_literal::NumericLiteral;
 use clippy_utils::source::snippet_opt;
+use clippy_utils::{get_parent_expr, path_to_local};
 use if_chain::if_chain;
 use rustc_ast::{LitFloatType, LitIntType, LitKind};
 use rustc_errors::Applicability;
@@ -75,6 +75,15 @@ pub(super) fn check<'tcx>(
     }
 
     if cast_from.kind() == cast_to.kind() && !in_external_macro(cx.sess(), expr.span) {
+        if let Some(id) = path_to_local(cast_expr)
+            && let Some(span) = cx.tcx.hir().opt_span(id)
+            && span.ctxt() != cast_expr.span.ctxt()
+        {
+            // Binding context is different than the identifiers context.
+            // Weird macro wizardry could be involved here.
+            return false;
+        }
+
         span_lint_and_sugg(
             cx,
             UNNECESSARY_CAST,
diff --git a/tests/ui/unnecessary_cast.fixed b/tests/ui/unnecessary_cast.fixed
index ec8c6abfab9..f234d4473c3 100644
--- a/tests/ui/unnecessary_cast.fixed
+++ b/tests/ui/unnecessary_cast.fixed
@@ -41,6 +41,17 @@ fn main() {
     // do not lint cast to alias type
     1 as I32Alias;
     &1 as &I32Alias;
+
+    // issue #9960
+    macro_rules! bind_var {
+        ($id:ident, $e:expr) => {{
+            let $id = 0usize;
+            let _ = $e != 0usize;
+            let $id = 0isize;
+            let _ = $e != 0usize;
+        }}
+    }
+    bind_var!(x, (x as usize) + 1);
 }
 
 type I32Alias = i32;
diff --git a/tests/ui/unnecessary_cast.rs b/tests/ui/unnecessary_cast.rs
index 5213cdc269b..855a4efa034 100644
--- a/tests/ui/unnecessary_cast.rs
+++ b/tests/ui/unnecessary_cast.rs
@@ -41,6 +41,17 @@ fn main() {
     // do not lint cast to alias type
     1 as I32Alias;
     &1 as &I32Alias;
+
+    // issue #9960
+    macro_rules! bind_var {
+        ($id:ident, $e:expr) => {{
+            let $id = 0usize;
+            let _ = $e != 0usize;
+            let $id = 0isize;
+            let _ = $e != 0usize;
+        }}
+    }
+    bind_var!(x, (x as usize) + 1);
 }
 
 type I32Alias = i32;
diff --git a/tests/ui/unnecessary_cast.stderr b/tests/ui/unnecessary_cast.stderr
index e5c3dd5e53f..934db0e86e6 100644
--- a/tests/ui/unnecessary_cast.stderr
+++ b/tests/ui/unnecessary_cast.stderr
@@ -49,133 +49,133 @@ LL |     1_f32 as f32;
    |     ^^^^^^^^^^^^ help: try: `1_f32`
 
 error: casting integer literal to `f32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:53:9
+  --> $DIR/unnecessary_cast.rs:64:9
    |
 LL |         100 as f32;
    |         ^^^^^^^^^^ help: try: `100_f32`
 
 error: casting integer literal to `f64` is unnecessary
-  --> $DIR/unnecessary_cast.rs:54:9
+  --> $DIR/unnecessary_cast.rs:65:9
    |
 LL |         100 as f64;
    |         ^^^^^^^^^^ help: try: `100_f64`
 
 error: casting integer literal to `f64` is unnecessary
-  --> $DIR/unnecessary_cast.rs:55:9
+  --> $DIR/unnecessary_cast.rs:66:9
    |
 LL |         100_i32 as f64;
    |         ^^^^^^^^^^^^^^ help: try: `100_f64`
 
 error: casting integer literal to `f32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:56:17
+  --> $DIR/unnecessary_cast.rs:67:17
    |
 LL |         let _ = -100 as f32;
    |                 ^^^^^^^^^^^ help: try: `-100_f32`
 
 error: casting integer literal to `f64` is unnecessary
-  --> $DIR/unnecessary_cast.rs:57:17
+  --> $DIR/unnecessary_cast.rs:68:17
    |
 LL |         let _ = -100 as f64;
    |                 ^^^^^^^^^^^ help: try: `-100_f64`
 
 error: casting integer literal to `f64` is unnecessary
-  --> $DIR/unnecessary_cast.rs:58:17
+  --> $DIR/unnecessary_cast.rs:69:17
    |
 LL |         let _ = -100_i32 as f64;
    |                 ^^^^^^^^^^^^^^^ help: try: `-100_f64`
 
 error: casting float literal to `f32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:59:9
+  --> $DIR/unnecessary_cast.rs:70:9
    |
 LL |         100. as f32;
    |         ^^^^^^^^^^^ help: try: `100_f32`
 
 error: casting float literal to `f64` is unnecessary
-  --> $DIR/unnecessary_cast.rs:60:9
+  --> $DIR/unnecessary_cast.rs:71:9
    |
 LL |         100. as f64;
    |         ^^^^^^^^^^^ help: try: `100_f64`
 
 error: casting integer literal to `u32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:72:9
+  --> $DIR/unnecessary_cast.rs:83:9
    |
 LL |         1 as u32;
    |         ^^^^^^^^ help: try: `1_u32`
 
 error: casting integer literal to `i32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:73:9
+  --> $DIR/unnecessary_cast.rs:84:9
    |
 LL |         0x10 as i32;
    |         ^^^^^^^^^^^ help: try: `0x10_i32`
 
 error: casting integer literal to `usize` is unnecessary
-  --> $DIR/unnecessary_cast.rs:74:9
+  --> $DIR/unnecessary_cast.rs:85:9
    |
 LL |         0b10 as usize;
    |         ^^^^^^^^^^^^^ help: try: `0b10_usize`
 
 error: casting integer literal to `u16` is unnecessary
-  --> $DIR/unnecessary_cast.rs:75:9
+  --> $DIR/unnecessary_cast.rs:86:9
    |
 LL |         0o73 as u16;
    |         ^^^^^^^^^^^ help: try: `0o73_u16`
 
 error: casting integer literal to `u32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:76:9
+  --> $DIR/unnecessary_cast.rs:87:9
    |
 LL |         1_000_000_000 as u32;
    |         ^^^^^^^^^^^^^^^^^^^^ help: try: `1_000_000_000_u32`
 
 error: casting float literal to `f64` is unnecessary
-  --> $DIR/unnecessary_cast.rs:78:9
+  --> $DIR/unnecessary_cast.rs:89:9
    |
 LL |         1.0 as f64;
    |         ^^^^^^^^^^ help: try: `1.0_f64`
 
 error: casting float literal to `f32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:79:9
+  --> $DIR/unnecessary_cast.rs:90:9
    |
 LL |         0.5 as f32;
    |         ^^^^^^^^^^ help: try: `0.5_f32`
 
 error: casting integer literal to `i32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:83:17
+  --> $DIR/unnecessary_cast.rs:94:17
    |
 LL |         let _ = -1 as i32;
    |                 ^^^^^^^^^ help: try: `-1_i32`
 
 error: casting float literal to `f32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:84:17
+  --> $DIR/unnecessary_cast.rs:95:17
    |
 LL |         let _ = -1.0 as f32;
    |                 ^^^^^^^^^^^ help: try: `-1.0_f32`
 
 error: casting integer literal to `i32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:93:22
+  --> $DIR/unnecessary_cast.rs:104:22
    |
 LL |         let _: i32 = -(1) as i32;
    |                      ^^^^^^^^^^^ help: try: `-1_i32`
 
 error: casting integer literal to `i64` is unnecessary
-  --> $DIR/unnecessary_cast.rs:95:22
+  --> $DIR/unnecessary_cast.rs:106:22
    |
 LL |         let _: i64 = -(1) as i64;
    |                      ^^^^^^^^^^^ help: try: `-1_i64`
 
 error: casting float literal to `f64` is unnecessary
-  --> $DIR/unnecessary_cast.rs:102:22
+  --> $DIR/unnecessary_cast.rs:113:22
    |
 LL |         let _: f64 = (-8.0 as f64).exp();
    |                      ^^^^^^^^^^^^^ help: try: `(-8.0_f64)`
 
 error: casting float literal to `f64` is unnecessary
-  --> $DIR/unnecessary_cast.rs:104:23
+  --> $DIR/unnecessary_cast.rs:115:23
    |
 LL |         let _: f64 = -(8.0 as f64).exp(); // should suggest `-8.0_f64.exp()` here not to change code behavior
    |                       ^^^^^^^^^^^^ help: try: `8.0_f64`
 
 error: casting to the same type is unnecessary (`f32` -> `f32`)
-  --> $DIR/unnecessary_cast.rs:112:20
+  --> $DIR/unnecessary_cast.rs:123:20
    |
 LL |         let _num = foo() as f32;
    |                    ^^^^^^^^^^^^ help: try: `foo()`
-- 
cgit 1.4.1-3-g733a5


From 96f1385fdd75af35ea888eeb68dc3631d7637a2b Mon Sep 17 00:00:00 2001
From: naosense <pingao777@gmail.com>
Date: Mon, 21 Nov 2022 14:36:56 +0800
Subject: add `suppress_lint_in_const` conf

---
 clippy_lints/src/indexing_slicing.rs | 19 ++++++++++++++++---
 clippy_lints/src/lib.rs              |  3 +++
 clippy_lints/src/utils/conf.rs       |  4 ++++
 3 files changed, 23 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/indexing_slicing.rs b/clippy_lints/src/indexing_slicing.rs
index 4cd7dff4cfd..23beeb4458c 100644
--- a/clippy_lints/src/indexing_slicing.rs
+++ b/clippy_lints/src/indexing_slicing.rs
@@ -82,11 +82,24 @@ declare_clippy_lint! {
     "indexing/slicing usage"
 }
 
+#[derive(Copy, Clone)]
+pub struct IndexingSlicing {
+    suppress_lint_in_const: bool,
+}
+
+impl IndexingSlicing {
+    pub fn new(suppress_lint_in_const: bool) -> Self {
+        Self {
+            suppress_lint_in_const,
+        }
+    }
+}
+
 declare_lint_pass!(IndexingSlicing => [INDEXING_SLICING, OUT_OF_BOUNDS_INDEXING]);
 
 impl<'tcx> LateLintPass<'tcx> for IndexingSlicing {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if cx.tcx.hir().is_inside_const_context(expr.hir_id) {
+        if self.suppress_lint_in_const && cx.tcx.hir().is_inside_const_context(expr.hir_id) {
             return;
         }
 
@@ -146,7 +159,7 @@ impl<'tcx> LateLintPass<'tcx> for IndexingSlicing {
                 // Catchall non-range index, i.e., [n] or [n << m]
                 if let ty::Array(..) = ty.kind() {
                     // Index is a const block.
-                    if let ExprKind::ConstBlock(..) = index.kind {
+                    if self.suppress_lint_in_const && let ExprKind::ConstBlock(..) = index.kind {
                         return;
                     }
                     // Index is a constant uint.
@@ -191,7 +204,7 @@ fn to_const_range(cx: &LateContext<'_>, range: higher::Range<'_>, array_size: u1
             } else {
                 Some(x)
             }
-        },
+        }
         Some(_) => None,
         None => Some(array_size),
     };
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 3fe39488ab8..3bac394582e 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -562,7 +562,9 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     let avoid_breaking_exported_api = conf.avoid_breaking_exported_api;
     let allow_expect_in_tests = conf.allow_expect_in_tests;
     let allow_unwrap_in_tests = conf.allow_unwrap_in_tests;
+    let suppress_lint_in_const = conf.suppress_lint_in_const;
     store.register_late_pass(move |_| Box::new(approx_const::ApproxConstant::new(msrv())));
+    store.register_late_pass(move |_| Box::new(approx_const::ApproxConstant::new(msrv)));
     store.register_late_pass(move |_| {
         Box::new(methods::Methods::new(
             avoid_breaking_exported_api,
@@ -684,6 +686,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(neg_cmp_op_on_partial_ord::NoNegCompOpForPartialOrd));
     store.register_late_pass(|_| Box::new(unwrap::Unwrap));
     store.register_late_pass(|_| Box::new(indexing_slicing::IndexingSlicing));
+    store.register_late_pass(|_| Box::new(indexing_slicing::IndexingSlicing::new(suppress_lint_in_const)));
     store.register_late_pass(|_| Box::new(non_copy_const::NonCopyConst));
     store.register_late_pass(|_| Box::new(ptr_offset_with_cast::PtrOffsetWithCast));
     store.register_late_pass(|_| Box::new(redundant_clone::RedundantClone));
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index b6dc8cd7ab1..1352632b3a6 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -406,6 +406,10 @@ define_Conf! {
     ///
     /// Whether to allow mixed uninlined format args, e.g. `format!("{} {}", a, foo.bar)`
     (allow_mixed_uninlined_format_args: bool = true),
+    /// Lint: SUPPRESS_LINT
+    ///
+    /// Whether to suppress lint in const function
+    (suppress_lint_in_const: bool = true),
 }
 
 /// Search for the configuration file.
-- 
cgit 1.4.1-3-g733a5


From aed9497978ce0520147cf1cf100513bf049ddf50 Mon Sep 17 00:00:00 2001
From: naosense <pingao777@gmail.com>
Date: Tue, 22 Nov 2022 17:12:50 +0800
Subject: add test and stderr

---
 clippy_lints/src/indexing_slicing.rs                   | 12 +++++-------
 clippy_lints/src/lib.rs                                |  3 +--
 clippy_lints/src/utils/conf.rs                         |  2 +-
 tests/ui-toml/suppress_lint_in_const/clippy.toml       |  1 +
 tests/ui-toml/suppress_lint_in_const/test.rs           | 15 +++++++++++++++
 tests/ui-toml/suppress_lint_in_const/test.stderr       | 11 +++++++++++
 tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr |  1 +
 7 files changed, 35 insertions(+), 10 deletions(-)
 create mode 100644 tests/ui-toml/suppress_lint_in_const/clippy.toml
 create mode 100644 tests/ui-toml/suppress_lint_in_const/test.rs
 create mode 100644 tests/ui-toml/suppress_lint_in_const/test.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/indexing_slicing.rs b/clippy_lints/src/indexing_slicing.rs
index 23beeb4458c..92facbbf034 100644
--- a/clippy_lints/src/indexing_slicing.rs
+++ b/clippy_lints/src/indexing_slicing.rs
@@ -7,7 +7,7 @@ use rustc_ast::ast::RangeLimits;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -82,6 +82,8 @@ declare_clippy_lint! {
     "indexing/slicing usage"
 }
 
+impl_lint_pass!(IndexingSlicing => [INDEXING_SLICING, OUT_OF_BOUNDS_INDEXING]);
+
 #[derive(Copy, Clone)]
 pub struct IndexingSlicing {
     suppress_lint_in_const: bool,
@@ -89,14 +91,10 @@ pub struct IndexingSlicing {
 
 impl IndexingSlicing {
     pub fn new(suppress_lint_in_const: bool) -> Self {
-        Self {
-            suppress_lint_in_const,
-        }
+        Self { suppress_lint_in_const }
     }
 }
 
-declare_lint_pass!(IndexingSlicing => [INDEXING_SLICING, OUT_OF_BOUNDS_INDEXING]);
-
 impl<'tcx> LateLintPass<'tcx> for IndexingSlicing {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if self.suppress_lint_in_const && cx.tcx.hir().is_inside_const_context(expr.hir_id) {
@@ -204,7 +202,7 @@ fn to_const_range(cx: &LateContext<'_>, range: higher::Range<'_>, array_size: u1
             } else {
                 Some(x)
             }
-        }
+        },
         Some(_) => None,
         None => Some(array_size),
     };
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 3bac394582e..3b5bac644ef 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -685,8 +685,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(inherent_impl::MultipleInherentImpl));
     store.register_late_pass(|_| Box::new(neg_cmp_op_on_partial_ord::NoNegCompOpForPartialOrd));
     store.register_late_pass(|_| Box::new(unwrap::Unwrap));
-    store.register_late_pass(|_| Box::new(indexing_slicing::IndexingSlicing));
-    store.register_late_pass(|_| Box::new(indexing_slicing::IndexingSlicing::new(suppress_lint_in_const)));
+    store.register_late_pass(move |_| Box::new(indexing_slicing::IndexingSlicing::new(suppress_lint_in_const)));
     store.register_late_pass(|_| Box::new(non_copy_const::NonCopyConst));
     store.register_late_pass(|_| Box::new(ptr_offset_with_cast::PtrOffsetWithCast));
     store.register_late_pass(|_| Box::new(redundant_clone::RedundantClone));
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 1352632b3a6..4a0e135db83 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -406,7 +406,7 @@ define_Conf! {
     ///
     /// Whether to allow mixed uninlined format args, e.g. `format!("{} {}", a, foo.bar)`
     (allow_mixed_uninlined_format_args: bool = true),
-    /// Lint: SUPPRESS_LINT
+    /// Lint: INDEXING_SLICING
     ///
     /// Whether to suppress lint in const function
     (suppress_lint_in_const: bool = true),
diff --git a/tests/ui-toml/suppress_lint_in_const/clippy.toml b/tests/ui-toml/suppress_lint_in_const/clippy.toml
new file mode 100644
index 00000000000..fd459ff5ac5
--- /dev/null
+++ b/tests/ui-toml/suppress_lint_in_const/clippy.toml
@@ -0,0 +1 @@
+suppress-lint-in-const = false
\ No newline at end of file
diff --git a/tests/ui-toml/suppress_lint_in_const/test.rs b/tests/ui-toml/suppress_lint_in_const/test.rs
new file mode 100644
index 00000000000..e5f4ca7cc90
--- /dev/null
+++ b/tests/ui-toml/suppress_lint_in_const/test.rs
@@ -0,0 +1,15 @@
+#![warn(clippy::indexing_slicing)]
+
+/// An opaque integer representation
+pub struct Integer<'a> {
+    /// The underlying data
+    value: &'a [u8],
+}
+impl<'a> Integer<'a> {
+    // Check whether `self` holds a negative number or not
+    pub const fn is_negative(&self) -> bool {
+        self.value[0] & 0b1000_0000 != 0
+    }
+}
+
+fn main() {}
diff --git a/tests/ui-toml/suppress_lint_in_const/test.stderr b/tests/ui-toml/suppress_lint_in_const/test.stderr
new file mode 100644
index 00000000000..b4f6fe0c024
--- /dev/null
+++ b/tests/ui-toml/suppress_lint_in_const/test.stderr
@@ -0,0 +1,11 @@
+error: indexing may panic
+  --> $DIR/test.rs:11:9
+   |
+LL |         self.value[0] & 0b1000_0000 != 0
+   |         ^^^^^^^^^^^^^
+   |
+   = help: consider using `.get(n)` or `.get_mut(n)` instead
+   = note: `-D clippy::indexing-slicing` implied by `-D warnings`
+
+error: aborting due to previous error
+
diff --git a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
index 01a5e962c94..521af13fe03 100644
--- a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
+++ b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
@@ -35,6 +35,7 @@ error: error reading Clippy's configuration file `$DIR/clippy.toml`: unknown fie
            pass-by-value-size-limit
            single-char-binding-names-threshold
            standard-macro-braces
+           suppress-lint-in-const
            third-party
            too-large-for-stack
            too-many-arguments-threshold
-- 
cgit 1.4.1-3-g733a5


From 4528aec7e9a4fdce65a5dfec3a06aad5ee1950dd Mon Sep 17 00:00:00 2001
From: naosense <pingao777@gmail.com>
Date: Wed, 23 Nov 2022 16:26:25 +0800
Subject: update config and suggest

---
 clippy_lints/src/indexing_slicing.rs               | 45 ++++++++++++++-------
 clippy_lints/src/lib.rs                            |  8 +++-
 clippy_lints/src/utils/conf.rs                     |  8 +++-
 tests/ui-toml/suppress_lint_in_const/clippy.toml   |  2 +-
 tests/ui-toml/suppress_lint_in_const/test.stderr   |  3 +-
 .../toml_unknown_key/conf_unknown_key.stderr       |  2 +-
 tests/ui/indexing_slicing_index.stderr             | 23 +++--------
 tests/ui/indexing_slicing_slice.stderr             | 47 ++++++----------------
 8 files changed, 63 insertions(+), 75 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/indexing_slicing.rs b/clippy_lints/src/indexing_slicing.rs
index 92facbbf034..dfea0bf18d1 100644
--- a/clippy_lints/src/indexing_slicing.rs
+++ b/clippy_lints/src/indexing_slicing.rs
@@ -1,9 +1,10 @@
 //! lint on indexing and slicing operations
 
 use clippy_utils::consts::{constant, Constant};
-use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
+use clippy_utils::diagnostics::{span_lint, span_lint_and_then};
 use clippy_utils::higher;
 use rustc_ast::ast::RangeLimits;
+use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
@@ -86,18 +87,20 @@ impl_lint_pass!(IndexingSlicing => [INDEXING_SLICING, OUT_OF_BOUNDS_INDEXING]);
 
 #[derive(Copy, Clone)]
 pub struct IndexingSlicing {
-    suppress_lint_in_const: bool,
+    suppress_restriction_lint_in_const: bool,
 }
 
 impl IndexingSlicing {
-    pub fn new(suppress_lint_in_const: bool) -> Self {
-        Self { suppress_lint_in_const }
+    pub fn new(suppress_restriction_lint_in_const: bool) -> Self {
+        Self {
+            suppress_restriction_lint_in_const,
+        }
     }
 }
 
 impl<'tcx> LateLintPass<'tcx> for IndexingSlicing {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if self.suppress_lint_in_const && cx.tcx.hir().is_inside_const_context(expr.hir_id) {
+        if self.suppress_restriction_lint_in_const && cx.tcx.hir().is_inside_const_context(expr.hir_id) {
             return;
         }
 
@@ -152,12 +155,19 @@ impl<'tcx> LateLintPass<'tcx> for IndexingSlicing {
                     (None, None) => return, // [..] is ok.
                 };
 
-                span_lint_and_help(cx, INDEXING_SLICING, expr.span, "slicing may panic", None, help_msg);
+                span_lint_and_then(cx, INDEXING_SLICING, expr.span, "slicing may panic", |diag| {
+                    let note = if cx.tcx.hir().is_inside_const_context(expr.hir_id) {
+                        "the suggestion might not be applicable in constant blocks"
+                    } else {
+                        ""
+                    };
+                    diag.span_suggestion(expr.span, help_msg, note, Applicability::MachineApplicable);
+                });
             } else {
                 // Catchall non-range index, i.e., [n] or [n << m]
                 if let ty::Array(..) = ty.kind() {
                     // Index is a const block.
-                    if self.suppress_lint_in_const && let ExprKind::ConstBlock(..) = index.kind {
+                    if self.suppress_restriction_lint_in_const && let ExprKind::ConstBlock(..) = index.kind {
                         return;
                     }
                     // Index is a constant uint.
@@ -167,14 +177,19 @@ impl<'tcx> LateLintPass<'tcx> for IndexingSlicing {
                     }
                 }
 
-                span_lint_and_help(
-                    cx,
-                    INDEXING_SLICING,
-                    expr.span,
-                    "indexing may panic",
-                    None,
-                    "consider using `.get(n)` or `.get_mut(n)` instead",
-                );
+                span_lint_and_then(cx, INDEXING_SLICING, expr.span, "indexing may panic", |diag| {
+                    let note = if cx.tcx.hir().is_inside_const_context(expr.hir_id) {
+                        "the suggestion might not be applicable in constant blocks"
+                    } else {
+                        ""
+                    };
+                    diag.span_suggestion(
+                        expr.span,
+                        "consider using `.get(n)` or `.get_mut(n)` instead",
+                        note,
+                        Applicability::MachineApplicable,
+                    );
+                });
             }
         }
     }
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 3b5bac644ef..2dc3a082277 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -562,7 +562,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     let avoid_breaking_exported_api = conf.avoid_breaking_exported_api;
     let allow_expect_in_tests = conf.allow_expect_in_tests;
     let allow_unwrap_in_tests = conf.allow_unwrap_in_tests;
-    let suppress_lint_in_const = conf.suppress_lint_in_const;
+    let suppress_restriction_lint_in_const = conf.suppress_restriction_lint_in_const;
     store.register_late_pass(move |_| Box::new(approx_const::ApproxConstant::new(msrv())));
     store.register_late_pass(move |_| Box::new(approx_const::ApproxConstant::new(msrv)));
     store.register_late_pass(move |_| {
@@ -685,7 +685,11 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(inherent_impl::MultipleInherentImpl));
     store.register_late_pass(|_| Box::new(neg_cmp_op_on_partial_ord::NoNegCompOpForPartialOrd));
     store.register_late_pass(|_| Box::new(unwrap::Unwrap));
-    store.register_late_pass(move |_| Box::new(indexing_slicing::IndexingSlicing::new(suppress_lint_in_const)));
+    store.register_late_pass(move |_| {
+        Box::new(indexing_slicing::IndexingSlicing::new(
+            suppress_restriction_lint_in_const,
+        ))
+    });
     store.register_late_pass(|_| Box::new(non_copy_const::NonCopyConst));
     store.register_late_pass(|_| Box::new(ptr_offset_with_cast::PtrOffsetWithCast));
     store.register_late_pass(|_| Box::new(redundant_clone::RedundantClone));
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 4a0e135db83..0022044ea41 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -408,8 +408,12 @@ define_Conf! {
     (allow_mixed_uninlined_format_args: bool = true),
     /// Lint: INDEXING_SLICING
     ///
-    /// Whether to suppress lint in const function
-    (suppress_lint_in_const: bool = true),
+    /// Whether to suppress a restriction lint in constant code. In same
+    /// cases the restructured operation might not be unavoidable, as the
+    /// suggested counterparts are unavailable in constant code. This
+    /// configuration will cause restriction lints to trigger even
+    /// if no suggestion can be made.
+    (suppress_restriction_lint_in_const: bool = true),
 }
 
 /// Search for the configuration file.
diff --git a/tests/ui-toml/suppress_lint_in_const/clippy.toml b/tests/ui-toml/suppress_lint_in_const/clippy.toml
index fd459ff5ac5..d458f53a73d 100644
--- a/tests/ui-toml/suppress_lint_in_const/clippy.toml
+++ b/tests/ui-toml/suppress_lint_in_const/clippy.toml
@@ -1 +1 @@
-suppress-lint-in-const = false
\ No newline at end of file
+suppress-restriction-lint-in-const = false
\ No newline at end of file
diff --git a/tests/ui-toml/suppress_lint_in_const/test.stderr b/tests/ui-toml/suppress_lint_in_const/test.stderr
index b4f6fe0c024..4e4583ab33c 100644
--- a/tests/ui-toml/suppress_lint_in_const/test.stderr
+++ b/tests/ui-toml/suppress_lint_in_const/test.stderr
@@ -2,9 +2,8 @@ error: indexing may panic
   --> $DIR/test.rs:11:9
    |
 LL |         self.value[0] & 0b1000_0000 != 0
-   |         ^^^^^^^^^^^^^
+   |         ^^^^^^^^^^^^^ help: consider using `.get(n)` or `.get_mut(n)` instead: `the suggestion might not be applicable in constant blocks`
    |
-   = help: consider using `.get(n)` or `.get_mut(n)` instead
    = note: `-D clippy::indexing-slicing` implied by `-D warnings`
 
 error: aborting due to previous error
diff --git a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
index 521af13fe03..6ef2abb15b2 100644
--- a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
+++ b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
@@ -35,7 +35,7 @@ error: error reading Clippy's configuration file `$DIR/clippy.toml`: unknown fie
            pass-by-value-size-limit
            single-char-binding-names-threshold
            standard-macro-braces
-           suppress-lint-in-const
+           suppress-restriction-lint-in-const
            third-party
            too-large-for-stack
            too-many-arguments-threshold
diff --git a/tests/ui/indexing_slicing_index.stderr b/tests/ui/indexing_slicing_index.stderr
index d8b6e3f1262..30fb6990795 100644
--- a/tests/ui/indexing_slicing_index.stderr
+++ b/tests/ui/indexing_slicing_index.stderr
@@ -14,50 +14,39 @@ error: indexing may panic
   --> $DIR/indexing_slicing_index.rs:22:5
    |
 LL |     x[index];
-   |     ^^^^^^^^
+   |     ^^^^^^^^ help: consider using `.get(n)` or `.get_mut(n)` instead
    |
-   = help: consider using `.get(n)` or `.get_mut(n)` instead
    = note: `-D clippy::indexing-slicing` implied by `-D warnings`
 
 error: indexing may panic
   --> $DIR/indexing_slicing_index.rs:38:5
    |
 LL |     v[0];
-   |     ^^^^
-   |
-   = help: consider using `.get(n)` or `.get_mut(n)` instead
+   |     ^^^^ help: consider using `.get(n)` or `.get_mut(n)` instead
 
 error: indexing may panic
   --> $DIR/indexing_slicing_index.rs:39:5
    |
 LL |     v[10];
-   |     ^^^^^
-   |
-   = help: consider using `.get(n)` or `.get_mut(n)` instead
+   |     ^^^^^ help: consider using `.get(n)` or `.get_mut(n)` instead
 
 error: indexing may panic
   --> $DIR/indexing_slicing_index.rs:40:5
    |
 LL |     v[1 << 3];
-   |     ^^^^^^^^^
-   |
-   = help: consider using `.get(n)` or `.get_mut(n)` instead
+   |     ^^^^^^^^^ help: consider using `.get(n)` or `.get_mut(n)` instead
 
 error: indexing may panic
   --> $DIR/indexing_slicing_index.rs:46:5
    |
 LL |     v[N];
-   |     ^^^^
-   |
-   = help: consider using `.get(n)` or `.get_mut(n)` instead
+   |     ^^^^ help: consider using `.get(n)` or `.get_mut(n)` instead
 
 error: indexing may panic
   --> $DIR/indexing_slicing_index.rs:47:5
    |
 LL |     v[M];
-   |     ^^^^
-   |
-   = help: consider using `.get(n)` or `.get_mut(n)` instead
+   |     ^^^^ help: consider using `.get(n)` or `.get_mut(n)` instead
 
 error[E0080]: evaluation of constant value failed
   --> $DIR/indexing_slicing_index.rs:10:24
diff --git a/tests/ui/indexing_slicing_slice.stderr b/tests/ui/indexing_slicing_slice.stderr
index dc54bd41365..ac2cc009a22 100644
--- a/tests/ui/indexing_slicing_slice.stderr
+++ b/tests/ui/indexing_slicing_slice.stderr
@@ -2,50 +2,39 @@ error: slicing may panic
   --> $DIR/indexing_slicing_slice.rs:12:6
    |
 LL |     &x[index..];
-   |      ^^^^^^^^^^
+   |      ^^^^^^^^^^ help: consider using `.get(n..)` or .get_mut(n..)` instead
    |
-   = help: consider using `.get(n..)` or .get_mut(n..)` instead
    = note: `-D clippy::indexing-slicing` implied by `-D warnings`
 
 error: slicing may panic
   --> $DIR/indexing_slicing_slice.rs:13:6
    |
 LL |     &x[..index];
-   |      ^^^^^^^^^^
-   |
-   = help: consider using `.get(..n)`or `.get_mut(..n)` instead
+   |      ^^^^^^^^^^ help: consider using `.get(..n)`or `.get_mut(..n)` instead
 
 error: slicing may panic
   --> $DIR/indexing_slicing_slice.rs:14:6
    |
 LL |     &x[index_from..index_to];
-   |      ^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: consider using `.get(n..m)` or `.get_mut(n..m)` instead
+   |      ^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `.get(n..m)` or `.get_mut(n..m)` instead
 
 error: slicing may panic
   --> $DIR/indexing_slicing_slice.rs:15:6
    |
 LL |     &x[index_from..][..index_to]; // Two lint reports, one for [index_from..] and another for [..index_to].
-   |      ^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: consider using `.get(..n)`or `.get_mut(..n)` instead
+   |      ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `.get(..n)`or `.get_mut(..n)` instead
 
 error: slicing may panic
   --> $DIR/indexing_slicing_slice.rs:15:6
    |
 LL |     &x[index_from..][..index_to]; // Two lint reports, one for [index_from..] and another for [..index_to].
-   |      ^^^^^^^^^^^^^^^
-   |
-   = help: consider using `.get(n..)` or .get_mut(n..)` instead
+   |      ^^^^^^^^^^^^^^^ help: consider using `.get(n..)` or .get_mut(n..)` instead
 
 error: slicing may panic
   --> $DIR/indexing_slicing_slice.rs:16:6
    |
 LL |     &x[5..][..10]; // Two lint reports, one for out of bounds [5..] and another for slicing [..10].
-   |      ^^^^^^^^^^^^
-   |
-   = help: consider using `.get(..n)`or `.get_mut(..n)` instead
+   |      ^^^^^^^^^^^^ help: consider using `.get(..n)`or `.get_mut(..n)` instead
 
 error: range is out of bounds
   --> $DIR/indexing_slicing_slice.rs:16:8
@@ -59,17 +48,13 @@ error: slicing may panic
   --> $DIR/indexing_slicing_slice.rs:17:6
    |
 LL |     &x[0..][..3];
-   |      ^^^^^^^^^^^
-   |
-   = help: consider using `.get(..n)`or `.get_mut(..n)` instead
+   |      ^^^^^^^^^^^ help: consider using `.get(..n)`or `.get_mut(..n)` instead
 
 error: slicing may panic
   --> $DIR/indexing_slicing_slice.rs:18:6
    |
 LL |     &x[1..][..5];
-   |      ^^^^^^^^^^^
-   |
-   = help: consider using `.get(..n)`or `.get_mut(..n)` instead
+   |      ^^^^^^^^^^^ help: consider using `.get(..n)`or `.get_mut(..n)` instead
 
 error: range is out of bounds
   --> $DIR/indexing_slicing_slice.rs:25:12
@@ -87,17 +72,13 @@ error: slicing may panic
   --> $DIR/indexing_slicing_slice.rs:31:6
    |
 LL |     &v[10..100];
-   |      ^^^^^^^^^^
-   |
-   = help: consider using `.get(n..m)` or `.get_mut(n..m)` instead
+   |      ^^^^^^^^^^ help: consider using `.get(n..m)` or `.get_mut(n..m)` instead
 
 error: slicing may panic
   --> $DIR/indexing_slicing_slice.rs:32:6
    |
 LL |     &x[10..][..100]; // Two lint reports, one for [10..] and another for [..100].
-   |      ^^^^^^^^^^^^^^
-   |
-   = help: consider using `.get(..n)`or `.get_mut(..n)` instead
+   |      ^^^^^^^^^^^^^^ help: consider using `.get(..n)`or `.get_mut(..n)` instead
 
 error: range is out of bounds
   --> $DIR/indexing_slicing_slice.rs:32:8
@@ -109,17 +90,13 @@ error: slicing may panic
   --> $DIR/indexing_slicing_slice.rs:33:6
    |
 LL |     &v[10..];
-   |      ^^^^^^^
-   |
-   = help: consider using `.get(n..)` or .get_mut(n..)` instead
+   |      ^^^^^^^ help: consider using `.get(n..)` or .get_mut(n..)` instead
 
 error: slicing may panic
   --> $DIR/indexing_slicing_slice.rs:34:6
    |
 LL |     &v[..100];
-   |      ^^^^^^^^
-   |
-   = help: consider using `.get(..n)`or `.get_mut(..n)` instead
+   |      ^^^^^^^^ help: consider using `.get(..n)`or `.get_mut(..n)` instead
 
 error: aborting due to 16 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From c9bf4b75cea2259ad927228c762d4cf323628ae5 Mon Sep 17 00:00:00 2001
From: naosense <pingao777@gmail.com>
Date: Wed, 23 Nov 2022 16:43:42 +0800
Subject: resolve conflicts

---
 clippy_lints/src/lib.rs | 1 -
 1 file changed, 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 2dc3a082277..5ce70de8810 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -564,7 +564,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     let allow_unwrap_in_tests = conf.allow_unwrap_in_tests;
     let suppress_restriction_lint_in_const = conf.suppress_restriction_lint_in_const;
     store.register_late_pass(move |_| Box::new(approx_const::ApproxConstant::new(msrv())));
-    store.register_late_pass(move |_| Box::new(approx_const::ApproxConstant::new(msrv)));
     store.register_late_pass(move |_| {
         Box::new(methods::Methods::new(
             avoid_breaking_exported_api,
-- 
cgit 1.4.1-3-g733a5


From 1fc98c51dfd771e5cd45c2feee0649ae299ab18b Mon Sep 17 00:00:00 2001
From: naosense <pingao777@gmail.com>
Date: Wed, 23 Nov 2022 16:50:05 +0800
Subject: change default value

---
 clippy_lints/src/utils/conf.rs                   | 2 +-
 tests/ui-toml/suppress_lint_in_const/clippy.toml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 0022044ea41..f5f0e3ef48c 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -413,7 +413,7 @@ define_Conf! {
     /// suggested counterparts are unavailable in constant code. This
     /// configuration will cause restriction lints to trigger even
     /// if no suggestion can be made.
-    (suppress_restriction_lint_in_const: bool = true),
+    (suppress_restriction_lint_in_const: bool = false),
 }
 
 /// Search for the configuration file.
diff --git a/tests/ui-toml/suppress_lint_in_const/clippy.toml b/tests/ui-toml/suppress_lint_in_const/clippy.toml
index d458f53a73d..d6b6fc7f268 100644
--- a/tests/ui-toml/suppress_lint_in_const/clippy.toml
+++ b/tests/ui-toml/suppress_lint_in_const/clippy.toml
@@ -1 +1 @@
-suppress-restriction-lint-in-const = false
\ No newline at end of file
+suppress-restriction-lint-in-const = false
-- 
cgit 1.4.1-3-g733a5


From 67a94135cbce195078efcbf18ac2347a1d734e68 Mon Sep 17 00:00:00 2001
From: naosense <pingao777@gmail.com>
Date: Thu, 24 Nov 2022 09:43:11 +0800
Subject: change note style

---
 clippy_lints/src/indexing_slicing.rs             | 29 ++++-----
 tests/ui-toml/suppress_lint_in_const/test.stderr |  4 +-
 tests/ui/indexing_slicing_index.stderr           | 79 +++++++++++++++++++++---
 tests/ui/indexing_slicing_slice.stderr           | 47 ++++++++++----
 4 files changed, 120 insertions(+), 39 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/indexing_slicing.rs b/clippy_lints/src/indexing_slicing.rs
index dfea0bf18d1..1a8ac43ac89 100644
--- a/clippy_lints/src/indexing_slicing.rs
+++ b/clippy_lints/src/indexing_slicing.rs
@@ -4,7 +4,6 @@ use clippy_utils::consts::{constant, Constant};
 use clippy_utils::diagnostics::{span_lint, span_lint_and_then};
 use clippy_utils::higher;
 use rustc_ast::ast::RangeLimits;
-use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
@@ -105,6 +104,7 @@ impl<'tcx> LateLintPass<'tcx> for IndexingSlicing {
         }
 
         if let ExprKind::Index(array, index) = &expr.kind {
+            let note = "the suggestion might not be applicable in constant blocks";
             let ty = cx.typeck_results().expr_ty(array).peel_refs();
             if let Some(range) = higher::Range::hir(index) {
                 // Ranged indexes, i.e., &x[n..m], &x[n..], &x[..n] and &x[..]
@@ -156,12 +156,11 @@ impl<'tcx> LateLintPass<'tcx> for IndexingSlicing {
                 };
 
                 span_lint_and_then(cx, INDEXING_SLICING, expr.span, "slicing may panic", |diag| {
-                    let note = if cx.tcx.hir().is_inside_const_context(expr.hir_id) {
-                        "the suggestion might not be applicable in constant blocks"
-                    } else {
-                        ""
-                    };
-                    diag.span_suggestion(expr.span, help_msg, note, Applicability::MachineApplicable);
+                    diag.help(help_msg);
+
+                    if cx.tcx.hir().is_inside_const_context(expr.hir_id) {
+                        diag.note(note);
+                    }
                 });
             } else {
                 // Catchall non-range index, i.e., [n] or [n << m]
@@ -178,17 +177,11 @@ impl<'tcx> LateLintPass<'tcx> for IndexingSlicing {
                 }
 
                 span_lint_and_then(cx, INDEXING_SLICING, expr.span, "indexing may panic", |diag| {
-                    let note = if cx.tcx.hir().is_inside_const_context(expr.hir_id) {
-                        "the suggestion might not be applicable in constant blocks"
-                    } else {
-                        ""
-                    };
-                    diag.span_suggestion(
-                        expr.span,
-                        "consider using `.get(n)` or `.get_mut(n)` instead",
-                        note,
-                        Applicability::MachineApplicable,
-                    );
+                    diag.help("consider using `.get(n)` or `.get_mut(n)` instead");
+
+                    if cx.tcx.hir().is_inside_const_context(expr.hir_id) {
+                        diag.note(note);
+                    }
                 });
             }
         }
diff --git a/tests/ui-toml/suppress_lint_in_const/test.stderr b/tests/ui-toml/suppress_lint_in_const/test.stderr
index 4e4583ab33c..c2acfed559d 100644
--- a/tests/ui-toml/suppress_lint_in_const/test.stderr
+++ b/tests/ui-toml/suppress_lint_in_const/test.stderr
@@ -2,8 +2,10 @@ error: indexing may panic
   --> $DIR/test.rs:11:9
    |
 LL |         self.value[0] & 0b1000_0000 != 0
-   |         ^^^^^^^^^^^^^ help: consider using `.get(n)` or `.get_mut(n)` instead: `the suggestion might not be applicable in constant blocks`
+   |         ^^^^^^^^^^^^^
    |
+   = help: consider using `.get(n)` or `.get_mut(n)` instead
+   = note: the suggestion might not be applicable in constant blocks
    = note: `-D clippy::indexing-slicing` implied by `-D warnings`
 
 error: aborting due to previous error
diff --git a/tests/ui/indexing_slicing_index.stderr b/tests/ui/indexing_slicing_index.stderr
index 30fb6990795..84e1f65623c 100644
--- a/tests/ui/indexing_slicing_index.stderr
+++ b/tests/ui/indexing_slicing_index.stderr
@@ -1,3 +1,22 @@
+error: indexing may panic
+  --> $DIR/indexing_slicing_index.rs:9:20
+   |
+LL | const REF: &i32 = &ARR[idx()]; // Ok, should not produce stderr.
+   |                    ^^^^^^^^^^
+   |
+   = help: consider using `.get(n)` or `.get_mut(n)` instead
+   = note: the suggestion might not be applicable in constant blocks
+   = note: `-D clippy::indexing-slicing` implied by `-D warnings`
+
+error: indexing may panic
+  --> $DIR/indexing_slicing_index.rs:10:24
+   |
+LL | const REF_ERR: &i32 = &ARR[idx4()]; // Ok, let rustc handle const contexts.
+   |                        ^^^^^^^^^^^
+   |
+   = help: consider using `.get(n)` or `.get_mut(n)` instead
+   = note: the suggestion might not be applicable in constant blocks
+
 error[E0080]: evaluation of `main::{constant#3}` failed
   --> $DIR/indexing_slicing_index.rs:31:14
    |
@@ -14,39 +33,83 @@ error: indexing may panic
   --> $DIR/indexing_slicing_index.rs:22:5
    |
 LL |     x[index];
-   |     ^^^^^^^^ help: consider using `.get(n)` or `.get_mut(n)` instead
+   |     ^^^^^^^^
    |
-   = note: `-D clippy::indexing-slicing` implied by `-D warnings`
+   = help: consider using `.get(n)` or `.get_mut(n)` instead
+
+error: indexing may panic
+  --> $DIR/indexing_slicing_index.rs:28:5
+   |
+LL |     x[const { idx() }]; // Ok, should not produce stderr.
+   |     ^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using `.get(n)` or `.get_mut(n)` instead
+
+error: indexing may panic
+  --> $DIR/indexing_slicing_index.rs:29:5
+   |
+LL |     x[const { idx4() }]; // Ok, let rustc's `unconditional_panic` lint handle `usize` indexing on arrays.
+   |     ^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using `.get(n)` or `.get_mut(n)` instead
+
+error: indexing may panic
+  --> $DIR/indexing_slicing_index.rs:30:14
+   |
+LL |     const { &ARR[idx()] }; // Ok, should not produce stderr.
+   |              ^^^^^^^^^^
+   |
+   = help: consider using `.get(n)` or `.get_mut(n)` instead
+   = note: the suggestion might not be applicable in constant blocks
+
+error: indexing may panic
+  --> $DIR/indexing_slicing_index.rs:31:14
+   |
+LL |     const { &ARR[idx4()] }; // Ok, let rustc handle const contexts.
+   |              ^^^^^^^^^^^
+   |
+   = help: consider using `.get(n)` or `.get_mut(n)` instead
+   = note: the suggestion might not be applicable in constant blocks
 
 error: indexing may panic
   --> $DIR/indexing_slicing_index.rs:38:5
    |
 LL |     v[0];
-   |     ^^^^ help: consider using `.get(n)` or `.get_mut(n)` instead
+   |     ^^^^
+   |
+   = help: consider using `.get(n)` or `.get_mut(n)` instead
 
 error: indexing may panic
   --> $DIR/indexing_slicing_index.rs:39:5
    |
 LL |     v[10];
-   |     ^^^^^ help: consider using `.get(n)` or `.get_mut(n)` instead
+   |     ^^^^^
+   |
+   = help: consider using `.get(n)` or `.get_mut(n)` instead
 
 error: indexing may panic
   --> $DIR/indexing_slicing_index.rs:40:5
    |
 LL |     v[1 << 3];
-   |     ^^^^^^^^^ help: consider using `.get(n)` or `.get_mut(n)` instead
+   |     ^^^^^^^^^
+   |
+   = help: consider using `.get(n)` or `.get_mut(n)` instead
 
 error: indexing may panic
   --> $DIR/indexing_slicing_index.rs:46:5
    |
 LL |     v[N];
-   |     ^^^^ help: consider using `.get(n)` or `.get_mut(n)` instead
+   |     ^^^^
+   |
+   = help: consider using `.get(n)` or `.get_mut(n)` instead
 
 error: indexing may panic
   --> $DIR/indexing_slicing_index.rs:47:5
    |
 LL |     v[M];
-   |     ^^^^ help: consider using `.get(n)` or `.get_mut(n)` instead
+   |     ^^^^
+   |
+   = help: consider using `.get(n)` or `.get_mut(n)` instead
 
 error[E0080]: evaluation of constant value failed
   --> $DIR/indexing_slicing_index.rs:10:24
@@ -54,6 +117,6 @@ error[E0080]: evaluation of constant value failed
 LL | const REF_ERR: &i32 = &ARR[idx4()]; // Ok, let rustc handle const contexts.
    |                        ^^^^^^^^^^^ index out of bounds: the length is 2 but the index is 4
 
-error: aborting due to 8 previous errors
+error: aborting due to 14 previous errors
 
 For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/indexing_slicing_slice.stderr b/tests/ui/indexing_slicing_slice.stderr
index ac2cc009a22..dc54bd41365 100644
--- a/tests/ui/indexing_slicing_slice.stderr
+++ b/tests/ui/indexing_slicing_slice.stderr
@@ -2,39 +2,50 @@ error: slicing may panic
   --> $DIR/indexing_slicing_slice.rs:12:6
    |
 LL |     &x[index..];
-   |      ^^^^^^^^^^ help: consider using `.get(n..)` or .get_mut(n..)` instead
+   |      ^^^^^^^^^^
    |
+   = help: consider using `.get(n..)` or .get_mut(n..)` instead
    = note: `-D clippy::indexing-slicing` implied by `-D warnings`
 
 error: slicing may panic
   --> $DIR/indexing_slicing_slice.rs:13:6
    |
 LL |     &x[..index];
-   |      ^^^^^^^^^^ help: consider using `.get(..n)`or `.get_mut(..n)` instead
+   |      ^^^^^^^^^^
+   |
+   = help: consider using `.get(..n)`or `.get_mut(..n)` instead
 
 error: slicing may panic
   --> $DIR/indexing_slicing_slice.rs:14:6
    |
 LL |     &x[index_from..index_to];
-   |      ^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `.get(n..m)` or `.get_mut(n..m)` instead
+   |      ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using `.get(n..m)` or `.get_mut(n..m)` instead
 
 error: slicing may panic
   --> $DIR/indexing_slicing_slice.rs:15:6
    |
 LL |     &x[index_from..][..index_to]; // Two lint reports, one for [index_from..] and another for [..index_to].
-   |      ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `.get(..n)`or `.get_mut(..n)` instead
+   |      ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using `.get(..n)`or `.get_mut(..n)` instead
 
 error: slicing may panic
   --> $DIR/indexing_slicing_slice.rs:15:6
    |
 LL |     &x[index_from..][..index_to]; // Two lint reports, one for [index_from..] and another for [..index_to].
-   |      ^^^^^^^^^^^^^^^ help: consider using `.get(n..)` or .get_mut(n..)` instead
+   |      ^^^^^^^^^^^^^^^
+   |
+   = help: consider using `.get(n..)` or .get_mut(n..)` instead
 
 error: slicing may panic
   --> $DIR/indexing_slicing_slice.rs:16:6
    |
 LL |     &x[5..][..10]; // Two lint reports, one for out of bounds [5..] and another for slicing [..10].
-   |      ^^^^^^^^^^^^ help: consider using `.get(..n)`or `.get_mut(..n)` instead
+   |      ^^^^^^^^^^^^
+   |
+   = help: consider using `.get(..n)`or `.get_mut(..n)` instead
 
 error: range is out of bounds
   --> $DIR/indexing_slicing_slice.rs:16:8
@@ -48,13 +59,17 @@ error: slicing may panic
   --> $DIR/indexing_slicing_slice.rs:17:6
    |
 LL |     &x[0..][..3];
-   |      ^^^^^^^^^^^ help: consider using `.get(..n)`or `.get_mut(..n)` instead
+   |      ^^^^^^^^^^^
+   |
+   = help: consider using `.get(..n)`or `.get_mut(..n)` instead
 
 error: slicing may panic
   --> $DIR/indexing_slicing_slice.rs:18:6
    |
 LL |     &x[1..][..5];
-   |      ^^^^^^^^^^^ help: consider using `.get(..n)`or `.get_mut(..n)` instead
+   |      ^^^^^^^^^^^
+   |
+   = help: consider using `.get(..n)`or `.get_mut(..n)` instead
 
 error: range is out of bounds
   --> $DIR/indexing_slicing_slice.rs:25:12
@@ -72,13 +87,17 @@ error: slicing may panic
   --> $DIR/indexing_slicing_slice.rs:31:6
    |
 LL |     &v[10..100];
-   |      ^^^^^^^^^^ help: consider using `.get(n..m)` or `.get_mut(n..m)` instead
+   |      ^^^^^^^^^^
+   |
+   = help: consider using `.get(n..m)` or `.get_mut(n..m)` instead
 
 error: slicing may panic
   --> $DIR/indexing_slicing_slice.rs:32:6
    |
 LL |     &x[10..][..100]; // Two lint reports, one for [10..] and another for [..100].
-   |      ^^^^^^^^^^^^^^ help: consider using `.get(..n)`or `.get_mut(..n)` instead
+   |      ^^^^^^^^^^^^^^
+   |
+   = help: consider using `.get(..n)`or `.get_mut(..n)` instead
 
 error: range is out of bounds
   --> $DIR/indexing_slicing_slice.rs:32:8
@@ -90,13 +109,17 @@ error: slicing may panic
   --> $DIR/indexing_slicing_slice.rs:33:6
    |
 LL |     &v[10..];
-   |      ^^^^^^^ help: consider using `.get(n..)` or .get_mut(n..)` instead
+   |      ^^^^^^^
+   |
+   = help: consider using `.get(n..)` or .get_mut(n..)` instead
 
 error: slicing may panic
   --> $DIR/indexing_slicing_slice.rs:34:6
    |
 LL |     &v[..100];
-   |      ^^^^^^^^ help: consider using `.get(..n)`or `.get_mut(..n)` instead
+   |      ^^^^^^^^
+   |
+   = help: consider using `.get(..n)`or `.get_mut(..n)` instead
 
 error: aborting due to 16 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From c502dee41ec38e6e0096abaa50a48e792e4c9d40 Mon Sep 17 00:00:00 2001
From: dswij <dswijj@gmail.com>
Date: Wed, 30 Nov 2022 14:50:13 +0800
Subject: Use `snippet_with_context` instead of `_with_macro_callsite`

---
 clippy_lints/src/manual_let_else.rs | 16 +++++-----------
 1 file changed, 5 insertions(+), 11 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_let_else.rs b/clippy_lints/src/manual_let_else.rs
index 91f0dc2a717..874d36ca9f4 100644
--- a/clippy_lints/src/manual_let_else.rs
+++ b/clippy_lints/src/manual_let_else.rs
@@ -2,7 +2,7 @@ use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::higher::IfLetOrMatch;
 use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::peel_blocks;
-use clippy_utils::source::{snippet, snippet_with_macro_callsite};
+use clippy_utils::source::snippet_with_context;
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::visitors::{for_each_expr, Descend};
 use if_chain::if_chain;
@@ -141,16 +141,10 @@ fn emit_manual_let_else(cx: &LateContext<'_>, span: Span, expr: &Expr<'_>, pat:
             // * unused binding collision detection with existing ones
             // * putting patterns with at the top level | inside ()
             // for this to be machine applicable.
-            let app = Applicability::HasPlaceholders;
-
-            let snippet_fn = if span.from_expansion() {
-                snippet
-            } else {
-                snippet_with_macro_callsite
-            };
-            let sn_pat = snippet_fn(cx, pat.span, "");
-            let sn_expr = snippet_fn(cx, expr.span, "");
-            let sn_else = snippet_fn(cx, else_body.span, "");
+            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);
 
             let else_bl = if matches!(else_body.kind, ExprKind::Block(..)) {
                 sn_else.into_owned()
-- 
cgit 1.4.1-3-g733a5


From cc43c3d25d4c0a6cf3dc3df7d5b560656c652bab Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Tue, 29 Nov 2022 18:22:02 +0100
Subject: Move `unnecessary_unsafety_doc` to `pedantic`

---
 clippy_lints/src/doc.rs                  |   2 +-
 tests/ui/doc_unnecessary_unsafe.rs       | 148 ------------------------------
 tests/ui/doc_unnecessary_unsafe.stderr   |  51 -----------
 tests/ui/unnecessary_unsafety_doc.rs     | 149 +++++++++++++++++++++++++++++++
 tests/ui/unnecessary_unsafety_doc.stderr |  51 +++++++++++
 5 files changed, 201 insertions(+), 200 deletions(-)
 delete mode 100644 tests/ui/doc_unnecessary_unsafe.rs
 delete mode 100644 tests/ui/doc_unnecessary_unsafe.stderr
 create mode 100644 tests/ui/unnecessary_unsafety_doc.rs
 create mode 100644 tests/ui/unnecessary_unsafety_doc.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/doc.rs b/clippy_lints/src/doc.rs
index 4557e432885..49b5d8b60d8 100644
--- a/clippy_lints/src/doc.rs
+++ b/clippy_lints/src/doc.rs
@@ -253,7 +253,7 @@ declare_clippy_lint! {
     /// ```
     #[clippy::version = "1.66.0"]
     pub UNNECESSARY_SAFETY_DOC,
-    style,
+    restriction,
     "`pub fn` or `pub trait` with `# Safety` docs"
 }
 
diff --git a/tests/ui/doc_unnecessary_unsafe.rs b/tests/ui/doc_unnecessary_unsafe.rs
deleted file mode 100644
index d9e9363b0f4..00000000000
--- a/tests/ui/doc_unnecessary_unsafe.rs
+++ /dev/null
@@ -1,148 +0,0 @@
-// aux-build:doc_unsafe_macros.rs
-
-#![allow(clippy::let_unit_value)]
-
-#[macro_use]
-extern crate doc_unsafe_macros;
-
-/// This is has no safety section, and does not need one either
-pub fn destroy_the_planet() {
-    unimplemented!();
-}
-
-/// This one does not need a `Safety` section
-///
-/// # Safety
-///
-/// This function shouldn't be called unless the horsemen are ready
-pub fn apocalypse(universe: &mut ()) {
-    unimplemented!();
-}
-
-/// This is a private function, skip to match behavior with `missing_safety_doc`.
-///
-/// # Safety
-///
-/// Boo!
-fn you_dont_see_me() {
-    unimplemented!();
-}
-
-mod private_mod {
-    /// This is public but unexported function, skip to match behavior with `missing_safety_doc`.
-    ///
-    /// # Safety
-    ///
-    /// Very safe!
-    pub fn only_crate_wide_accessible() {
-        unimplemented!();
-    }
-
-    /// # Safety
-    ///
-    /// Unnecessary safety!
-    pub fn republished() {
-        unimplemented!();
-    }
-}
-
-pub use private_mod::republished;
-
-pub trait SafeTraitSafeMethods {
-    fn woefully_underdocumented(self);
-
-    /// # Safety
-    ///
-    /// Unnecessary!
-    fn documented(self);
-}
-
-pub trait SafeTrait {
-    fn method();
-}
-
-/// # Safety
-///
-/// Unnecessary!
-pub trait DocumentedSafeTrait {
-    fn method2();
-}
-
-pub struct Struct;
-
-impl SafeTraitSafeMethods for Struct {
-    fn woefully_underdocumented(self) {
-        // all is well
-    }
-
-    fn documented(self) {
-        // all is still well
-    }
-}
-
-impl SafeTrait for Struct {
-    fn method() {}
-}
-
-impl DocumentedSafeTrait for Struct {
-    fn method2() {}
-}
-
-impl Struct {
-    /// # Safety
-    ///
-    /// Unnecessary!
-    pub fn documented() -> Self {
-        unimplemented!();
-    }
-
-    pub fn undocumented(&self) {
-        unimplemented!();
-    }
-
-    /// Private, fine again to stay consistent with `missing_safety_doc`.
-    ///
-    /// # Safety
-    ///
-    /// Unnecessary!
-    fn private(&self) {
-        unimplemented!();
-    }
-}
-
-macro_rules! very_safe {
-    () => {
-        pub fn whee() {
-            unimplemented!()
-        }
-
-        /// # Safety
-        ///
-        /// Driving is very safe already!
-        pub fn drive() {
-            whee()
-        }
-    };
-}
-
-very_safe!();
-
-// we don't lint code from external macros
-undocd_safe!();
-
-fn main() {}
-
-// do not lint if any parent has `#[doc(hidden)]` attribute
-// see #7347
-#[doc(hidden)]
-pub mod __macro {
-    pub struct T;
-    impl T {
-        pub unsafe fn f() {}
-    }
-}
-
-/// # Implementation safety
-pub trait DocumentedSafeTraitWithImplementationHeader {
-    fn method();
-}
diff --git a/tests/ui/doc_unnecessary_unsafe.stderr b/tests/ui/doc_unnecessary_unsafe.stderr
deleted file mode 100644
index 83b2efbb346..00000000000
--- a/tests/ui/doc_unnecessary_unsafe.stderr
+++ /dev/null
@@ -1,51 +0,0 @@
-error: safe function's docs have unnecessary `# Safety` section
-  --> $DIR/doc_unnecessary_unsafe.rs:18:1
-   |
-LL | pub fn apocalypse(universe: &mut ()) {
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: `-D clippy::unnecessary-safety-doc` implied by `-D warnings`
-
-error: safe function's docs have unnecessary `# Safety` section
-  --> $DIR/doc_unnecessary_unsafe.rs:44:5
-   |
-LL |     pub fn republished() {
-   |     ^^^^^^^^^^^^^^^^^^^^
-
-error: safe function's docs have unnecessary `# Safety` section
-  --> $DIR/doc_unnecessary_unsafe.rs:57:5
-   |
-LL |     fn documented(self);
-   |     ^^^^^^^^^^^^^^^^^^^^
-
-error: docs for safe trait have unnecessary `# Safety` section
-  --> $DIR/doc_unnecessary_unsafe.rs:67:1
-   |
-LL | pub trait DocumentedSafeTrait {
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: safe function's docs have unnecessary `# Safety` section
-  --> $DIR/doc_unnecessary_unsafe.rs:95:5
-   |
-LL |     pub fn documented() -> Self {
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: safe function's docs have unnecessary `# Safety` section
-  --> $DIR/doc_unnecessary_unsafe.rs:122:9
-   |
-LL |         pub fn drive() {
-   |         ^^^^^^^^^^^^^^
-...
-LL | very_safe!();
-   | ------------ in this macro invocation
-   |
-   = note: this error originates in the macro `very_safe` (in Nightly builds, run with -Z macro-backtrace for more info)
-
-error: docs for safe trait have unnecessary `# Safety` section
-  --> $DIR/doc_unnecessary_unsafe.rs:146:1
-   |
-LL | pub trait DocumentedSafeTraitWithImplementationHeader {
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: aborting due to 7 previous errors
-
diff --git a/tests/ui/unnecessary_unsafety_doc.rs b/tests/ui/unnecessary_unsafety_doc.rs
new file mode 100644
index 00000000000..c160e31afd3
--- /dev/null
+++ b/tests/ui/unnecessary_unsafety_doc.rs
@@ -0,0 +1,149 @@
+// aux-build:doc_unsafe_macros.rs
+
+#![allow(clippy::let_unit_value)]
+#![warn(clippy::unnecessary_safety_doc)]
+
+#[macro_use]
+extern crate doc_unsafe_macros;
+
+/// This is has no safety section, and does not need one either
+pub fn destroy_the_planet() {
+    unimplemented!();
+}
+
+/// This one does not need a `Safety` section
+///
+/// # Safety
+///
+/// This function shouldn't be called unless the horsemen are ready
+pub fn apocalypse(universe: &mut ()) {
+    unimplemented!();
+}
+
+/// This is a private function, skip to match behavior with `missing_safety_doc`.
+///
+/// # Safety
+///
+/// Boo!
+fn you_dont_see_me() {
+    unimplemented!();
+}
+
+mod private_mod {
+    /// This is public but unexported function, skip to match behavior with `missing_safety_doc`.
+    ///
+    /// # Safety
+    ///
+    /// Very safe!
+    pub fn only_crate_wide_accessible() {
+        unimplemented!();
+    }
+
+    /// # Safety
+    ///
+    /// Unnecessary safety!
+    pub fn republished() {
+        unimplemented!();
+    }
+}
+
+pub use private_mod::republished;
+
+pub trait SafeTraitSafeMethods {
+    fn woefully_underdocumented(self);
+
+    /// # Safety
+    ///
+    /// Unnecessary!
+    fn documented(self);
+}
+
+pub trait SafeTrait {
+    fn method();
+}
+
+/// # Safety
+///
+/// Unnecessary!
+pub trait DocumentedSafeTrait {
+    fn method2();
+}
+
+pub struct Struct;
+
+impl SafeTraitSafeMethods for Struct {
+    fn woefully_underdocumented(self) {
+        // all is well
+    }
+
+    fn documented(self) {
+        // all is still well
+    }
+}
+
+impl SafeTrait for Struct {
+    fn method() {}
+}
+
+impl DocumentedSafeTrait for Struct {
+    fn method2() {}
+}
+
+impl Struct {
+    /// # Safety
+    ///
+    /// Unnecessary!
+    pub fn documented() -> Self {
+        unimplemented!();
+    }
+
+    pub fn undocumented(&self) {
+        unimplemented!();
+    }
+
+    /// Private, fine again to stay consistent with `missing_safety_doc`.
+    ///
+    /// # Safety
+    ///
+    /// Unnecessary!
+    fn private(&self) {
+        unimplemented!();
+    }
+}
+
+macro_rules! very_safe {
+    () => {
+        pub fn whee() {
+            unimplemented!()
+        }
+
+        /// # Safety
+        ///
+        /// Driving is very safe already!
+        pub fn drive() {
+            whee()
+        }
+    };
+}
+
+very_safe!();
+
+// we don't lint code from external macros
+undocd_safe!();
+
+fn main() {}
+
+// do not lint if any parent has `#[doc(hidden)]` attribute
+// see #7347
+#[doc(hidden)]
+pub mod __macro {
+    pub struct T;
+    impl T {
+        pub unsafe fn f() {}
+    }
+}
+
+/// # Implementation safety
+pub trait DocumentedSafeTraitWithImplementationHeader {
+    fn method();
+}
diff --git a/tests/ui/unnecessary_unsafety_doc.stderr b/tests/ui/unnecessary_unsafety_doc.stderr
new file mode 100644
index 00000000000..72898c93fa1
--- /dev/null
+++ b/tests/ui/unnecessary_unsafety_doc.stderr
@@ -0,0 +1,51 @@
+error: safe function's docs have unnecessary `# Safety` section
+  --> $DIR/unnecessary_unsafety_doc.rs:19:1
+   |
+LL | pub fn apocalypse(universe: &mut ()) {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::unnecessary-safety-doc` implied by `-D warnings`
+
+error: safe function's docs have unnecessary `# Safety` section
+  --> $DIR/unnecessary_unsafety_doc.rs:45:5
+   |
+LL |     pub fn republished() {
+   |     ^^^^^^^^^^^^^^^^^^^^
+
+error: safe function's docs have unnecessary `# Safety` section
+  --> $DIR/unnecessary_unsafety_doc.rs:58:5
+   |
+LL |     fn documented(self);
+   |     ^^^^^^^^^^^^^^^^^^^^
+
+error: docs for safe trait have unnecessary `# Safety` section
+  --> $DIR/unnecessary_unsafety_doc.rs:68:1
+   |
+LL | pub trait DocumentedSafeTrait {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: safe function's docs have unnecessary `# Safety` section
+  --> $DIR/unnecessary_unsafety_doc.rs:96:5
+   |
+LL |     pub fn documented() -> Self {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: safe function's docs have unnecessary `# Safety` section
+  --> $DIR/unnecessary_unsafety_doc.rs:123:9
+   |
+LL |         pub fn drive() {
+   |         ^^^^^^^^^^^^^^
+...
+LL | very_safe!();
+   | ------------ in this macro invocation
+   |
+   = note: this error originates in the macro `very_safe` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: docs for safe trait have unnecessary `# Safety` section
+  --> $DIR/unnecessary_unsafety_doc.rs:147:1
+   |
+LL | pub trait DocumentedSafeTraitWithImplementationHeader {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 7 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 7a0f0c0e8b79d0dd95e0c97660e327e51fa09c0f Mon Sep 17 00:00:00 2001
From: mdgaziur <mdgaziurrahmannoor@gmail.com>
Date: Sat, 26 Nov 2022 12:17:49 +0600
Subject: Fix #9958

---
 clippy_lints/src/len_zero.rs | 20 ++++++++----
 tests/ui/len_zero.fixed      | 40 ++++++++++++++++++++++++
 tests/ui/len_zero.rs         | 40 ++++++++++++++++++++++++
 tests/ui/len_zero.stderr     | 74 +++++++++++++++++++++++++++++++++++---------
 4 files changed, 153 insertions(+), 21 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/len_zero.rs b/clippy_lints/src/len_zero.rs
index 4c133c06a15..3babc2a5895 100644
--- a/clippy_lints/src/len_zero.rs
+++ b/clippy_lints/src/len_zero.rs
@@ -1,13 +1,13 @@
 use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::{get_item_name, get_parent_as_impl, is_lint_allowed};
+use clippy_utils::{get_item_name, get_parent_as_impl, is_lint_allowed, peel_ref_operators};
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::def_id::DefIdSet;
 use rustc_hir::{
     def_id::DefId, AssocItemKind, BinOpKind, Expr, ExprKind, FnRetTy, ImplItem, ImplItemKind, ImplicitSelfKind, Item,
-    ItemKind, Mutability, Node, TraitItemRef, TyKind,
+    ItemKind, Mutability, Node, TraitItemRef, TyKind, UnOp,
 };
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{self, AssocKind, FnSig, Ty};
@@ -16,6 +16,7 @@ use rustc_span::{
     source_map::{Span, Spanned, Symbol},
     symbol::sym,
 };
+use std::borrow::Cow;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -428,16 +429,23 @@ fn check_len(
 fn check_empty_expr(cx: &LateContext<'_>, span: Span, lit1: &Expr<'_>, lit2: &Expr<'_>, op: &str) {
     if (is_empty_array(lit2) || is_empty_string(lit2)) && has_is_empty(cx, lit1) {
         let mut applicability = Applicability::MachineApplicable;
+
+        let lit1 = peel_ref_operators(cx, lit1);
+        let mut lit_str = snippet_with_applicability(cx, lit1.span, "_", &mut applicability);
+
+        // Wrap the expression in parentheses if it's a deref expression. Otherwise operator precedence will
+        // cause the code to dereference boolean(won't compile).
+        if let ExprKind::Unary(UnOp::Deref, _) = lit1.kind {
+            lit_str = Cow::from(format!("({lit_str})"));
+        }
+
         span_lint_and_sugg(
             cx,
             COMPARISON_TO_EMPTY,
             span,
             "comparison to empty slice",
             &format!("using `{op}is_empty` is clearer and more explicit"),
-            format!(
-                "{op}{}.is_empty()",
-                snippet_with_applicability(cx, lit1.span, "_", &mut applicability)
-            ),
+            format!("{op}{lit_str}.is_empty()"),
             applicability,
         );
     }
diff --git a/tests/ui/len_zero.fixed b/tests/ui/len_zero.fixed
index 1f3b8ac99b1..c1c0b5ae40f 100644
--- a/tests/ui/len_zero.fixed
+++ b/tests/ui/len_zero.fixed
@@ -3,6 +3,9 @@
 #![warn(clippy::len_zero)]
 #![allow(dead_code, unused, clippy::len_without_is_empty)]
 
+extern crate core;
+use core::ops::Deref;
+
 pub struct One;
 struct Wither;
 
@@ -56,6 +59,26 @@ impl WithIsEmpty for Wither {
     }
 }
 
+struct DerefToDerefToString;
+
+impl Deref for DerefToDerefToString {
+    type Target = DerefToString;
+
+    fn deref(&self) -> &Self::Target {
+        &DerefToString {}
+    }
+}
+
+struct DerefToString;
+
+impl Deref for DerefToString {
+    type Target = str;
+
+    fn deref(&self) -> &Self::Target {
+        "Hello, world!"
+    }
+}
+
 fn main() {
     let x = [1, 2];
     if x.is_empty() {
@@ -64,6 +87,23 @@ fn main() {
 
     if "".is_empty() {}
 
+    let s = "Hello, world!";
+    let s1 = &s;
+    let s2 = &s1;
+    let s3 = &s2;
+    let s4 = &s3;
+    let s5 = &s4;
+    let s6 = &s5;
+    println!("{}", s1.is_empty());
+    println!("{}", s2.is_empty());
+    println!("{}", s3.is_empty());
+    println!("{}", s4.is_empty());
+    println!("{}", s5.is_empty());
+    println!("{}", (s6).is_empty());
+
+    let d2s = DerefToDerefToString {};
+    println!("{}", (**d2s).is_empty());
+
     let y = One;
     if y.len() == 0 {
         // No error; `One` does not have `.is_empty()`.
diff --git a/tests/ui/len_zero.rs b/tests/ui/len_zero.rs
index dc21de0001b..cc2eb05b6bf 100644
--- a/tests/ui/len_zero.rs
+++ b/tests/ui/len_zero.rs
@@ -3,6 +3,9 @@
 #![warn(clippy::len_zero)]
 #![allow(dead_code, unused, clippy::len_without_is_empty)]
 
+extern crate core;
+use core::ops::Deref;
+
 pub struct One;
 struct Wither;
 
@@ -56,6 +59,26 @@ impl WithIsEmpty for Wither {
     }
 }
 
+struct DerefToDerefToString;
+
+impl Deref for DerefToDerefToString {
+    type Target = DerefToString;
+
+    fn deref(&self) -> &Self::Target {
+        &DerefToString {}
+    }
+}
+
+struct DerefToString;
+
+impl Deref for DerefToString {
+    type Target = str;
+
+    fn deref(&self) -> &Self::Target {
+        "Hello, world!"
+    }
+}
+
 fn main() {
     let x = [1, 2];
     if x.len() == 0 {
@@ -64,6 +87,23 @@ fn main() {
 
     if "".len() == 0 {}
 
+    let s = "Hello, world!";
+    let s1 = &s;
+    let s2 = &s1;
+    let s3 = &s2;
+    let s4 = &s3;
+    let s5 = &s4;
+    let s6 = &s5;
+    println!("{}", *s1 == "");
+    println!("{}", **s2 == "");
+    println!("{}", ***s3 == "");
+    println!("{}", ****s4 == "");
+    println!("{}", *****s5 == "");
+    println!("{}", ******(s6) == "");
+
+    let d2s = DerefToDerefToString {};
+    println!("{}", &**d2s == "");
+
     let y = One;
     if y.len() == 0 {
         // No error; `One` does not have `.is_empty()`.
diff --git a/tests/ui/len_zero.stderr b/tests/ui/len_zero.stderr
index 6c71f1beeac..b6f13780253 100644
--- a/tests/ui/len_zero.stderr
+++ b/tests/ui/len_zero.stderr
@@ -1,5 +1,5 @@
 error: length comparison to zero
-  --> $DIR/len_zero.rs:61:8
+  --> $DIR/len_zero.rs:84:8
    |
 LL |     if x.len() == 0 {
    |        ^^^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `x.is_empty()`
@@ -7,82 +7,126 @@ LL |     if x.len() == 0 {
    = note: `-D clippy::len-zero` implied by `-D warnings`
 
 error: length comparison to zero
-  --> $DIR/len_zero.rs:65:8
+  --> $DIR/len_zero.rs:88:8
    |
 LL |     if "".len() == 0 {}
    |        ^^^^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `"".is_empty()`
 
+error: comparison to empty slice
+  --> $DIR/len_zero.rs:97:20
+   |
+LL |     println!("{}", *s1 == "");
+   |                    ^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `s1.is_empty()`
+   |
+   = note: `-D clippy::comparison-to-empty` implied by `-D warnings`
+
+error: comparison to empty slice
+  --> $DIR/len_zero.rs:98:20
+   |
+LL |     println!("{}", **s2 == "");
+   |                    ^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `s2.is_empty()`
+
+error: comparison to empty slice
+  --> $DIR/len_zero.rs:99:20
+   |
+LL |     println!("{}", ***s3 == "");
+   |                    ^^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `s3.is_empty()`
+
+error: comparison to empty slice
+  --> $DIR/len_zero.rs:100:20
+   |
+LL |     println!("{}", ****s4 == "");
+   |                    ^^^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `s4.is_empty()`
+
+error: comparison to empty slice
+  --> $DIR/len_zero.rs:101:20
+   |
+LL |     println!("{}", *****s5 == "");
+   |                    ^^^^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `s5.is_empty()`
+
+error: comparison to empty slice
+  --> $DIR/len_zero.rs:102:20
+   |
+LL |     println!("{}", ******(s6) == "");
+   |                    ^^^^^^^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `(s6).is_empty()`
+
+error: comparison to empty slice
+  --> $DIR/len_zero.rs:105:20
+   |
+LL |     println!("{}", &**d2s == "");
+   |                    ^^^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `(**d2s).is_empty()`
+
 error: length comparison to zero
-  --> $DIR/len_zero.rs:80:8
+  --> $DIR/len_zero.rs:120:8
    |
 LL |     if has_is_empty.len() == 0 {
    |        ^^^^^^^^^^^^^^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `has_is_empty.is_empty()`
 
 error: length comparison to zero
-  --> $DIR/len_zero.rs:83:8
+  --> $DIR/len_zero.rs:123:8
    |
 LL |     if has_is_empty.len() != 0 {
    |        ^^^^^^^^^^^^^^^^^^^^^^^ help: using `!is_empty` is clearer and more explicit: `!has_is_empty.is_empty()`
 
 error: length comparison to zero
-  --> $DIR/len_zero.rs:86:8
+  --> $DIR/len_zero.rs:126:8
    |
 LL |     if has_is_empty.len() > 0 {
    |        ^^^^^^^^^^^^^^^^^^^^^^ help: using `!is_empty` is clearer and more explicit: `!has_is_empty.is_empty()`
 
 error: length comparison to one
-  --> $DIR/len_zero.rs:89:8
+  --> $DIR/len_zero.rs:129:8
    |
 LL |     if has_is_empty.len() < 1 {
    |        ^^^^^^^^^^^^^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `has_is_empty.is_empty()`
 
 error: length comparison to one
-  --> $DIR/len_zero.rs:92:8
+  --> $DIR/len_zero.rs:132:8
    |
 LL |     if has_is_empty.len() >= 1 {
    |        ^^^^^^^^^^^^^^^^^^^^^^^ help: using `!is_empty` is clearer and more explicit: `!has_is_empty.is_empty()`
 
 error: length comparison to zero
-  --> $DIR/len_zero.rs:103:8
+  --> $DIR/len_zero.rs:143:8
    |
 LL |     if 0 == has_is_empty.len() {
    |        ^^^^^^^^^^^^^^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `has_is_empty.is_empty()`
 
 error: length comparison to zero
-  --> $DIR/len_zero.rs:106:8
+  --> $DIR/len_zero.rs:146:8
    |
 LL |     if 0 != has_is_empty.len() {
    |        ^^^^^^^^^^^^^^^^^^^^^^^ help: using `!is_empty` is clearer and more explicit: `!has_is_empty.is_empty()`
 
 error: length comparison to zero
-  --> $DIR/len_zero.rs:109:8
+  --> $DIR/len_zero.rs:149:8
    |
 LL |     if 0 < has_is_empty.len() {
    |        ^^^^^^^^^^^^^^^^^^^^^^ help: using `!is_empty` is clearer and more explicit: `!has_is_empty.is_empty()`
 
 error: length comparison to one
-  --> $DIR/len_zero.rs:112:8
+  --> $DIR/len_zero.rs:152:8
    |
 LL |     if 1 <= has_is_empty.len() {
    |        ^^^^^^^^^^^^^^^^^^^^^^^ help: using `!is_empty` is clearer and more explicit: `!has_is_empty.is_empty()`
 
 error: length comparison to one
-  --> $DIR/len_zero.rs:115:8
+  --> $DIR/len_zero.rs:155:8
    |
 LL |     if 1 > has_is_empty.len() {
    |        ^^^^^^^^^^^^^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `has_is_empty.is_empty()`
 
 error: length comparison to zero
-  --> $DIR/len_zero.rs:129:8
+  --> $DIR/len_zero.rs:169:8
    |
 LL |     if with_is_empty.len() == 0 {
    |        ^^^^^^^^^^^^^^^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `with_is_empty.is_empty()`
 
 error: length comparison to zero
-  --> $DIR/len_zero.rs:142:8
+  --> $DIR/len_zero.rs:182:8
    |
 LL |     if b.len() != 0 {}
    |        ^^^^^^^^^^^^ help: using `!is_empty` is clearer and more explicit: `!b.is_empty()`
 
-error: aborting due to 14 previous errors
+error: aborting due to 21 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From e0eba9cafcc8aaf3821f4b0b9777954caf049498 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Tue, 29 Nov 2022 10:36:43 -0500
Subject: Don't cross contexts while building the suggestion for
 `redundant_closure_call`

---
 clippy_lints/src/collapsible_if.rs             | 10 ++--
 clippy_lints/src/redundant_closure_call.rs     |  4 +-
 clippy_utils/src/source.rs                     | 38 ++++++++++++---
 clippy_utils/src/sugg.rs                       | 65 ++++++++++++++------------
 tests/ui/redundant_closure_call_fixable.fixed  | 12 +++++
 tests/ui/redundant_closure_call_fixable.rs     | 12 +++++
 tests/ui/redundant_closure_call_fixable.stderr | 24 +++++++++-
 7 files changed, 122 insertions(+), 43 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/collapsible_if.rs b/clippy_lints/src/collapsible_if.rs
index 90430b71a0e..b38e09dc09f 100644
--- a/clippy_lints/src/collapsible_if.rs
+++ b/clippy_lints/src/collapsible_if.rs
@@ -160,11 +160,13 @@ fn check_collapsible_no_if_let(cx: &EarlyContext<'_>, expr: &ast::Expr, check: &
         if let ast::ExprKind::If(ref check_inner, ref content, None) = inner.kind;
         // Prevent triggering on `if c { if let a = b { .. } }`.
         if !matches!(check_inner.kind, ast::ExprKind::Let(..));
-        if expr.span.ctxt() == inner.span.ctxt();
+        let ctxt = expr.span.ctxt();
+        if inner.span.ctxt() == ctxt;
         then {
             span_lint_and_then(cx, COLLAPSIBLE_IF, expr.span, "this `if` statement can be collapsed", |diag| {
-                let lhs = Sugg::ast(cx, check, "..");
-                let rhs = Sugg::ast(cx, check_inner, "..");
+                let mut app = Applicability::MachineApplicable;
+                let lhs = Sugg::ast(cx, check, "..", ctxt, &mut app);
+                let rhs = Sugg::ast(cx, check_inner, "..", ctxt, &mut app);
                 diag.span_suggestion(
                     expr.span,
                     "collapse nested if block",
@@ -173,7 +175,7 @@ fn check_collapsible_no_if_let(cx: &EarlyContext<'_>, expr: &ast::Expr, check: &
                         lhs.and(&rhs),
                         snippet_block(cx, content.span, "..", Some(expr.span)),
                     ),
-                    Applicability::MachineApplicable, // snippet
+                    app, // snippet
                 );
             });
         }
diff --git a/clippy_lints/src/redundant_closure_call.rs b/clippy_lints/src/redundant_closure_call.rs
index 8e675d34a18..2a42e73488f 100644
--- a/clippy_lints/src/redundant_closure_call.rs
+++ b/clippy_lints/src/redundant_closure_call.rs
@@ -81,8 +81,8 @@ impl EarlyLintPass for RedundantClosureCall {
                         "try not to call a closure in the expression where it is declared",
                         |diag| {
                             if fn_decl.inputs.is_empty() {
-                                let app = Applicability::MachineApplicable;
-                                let mut hint = Sugg::ast(cx, body, "..");
+                                let mut app = Applicability::MachineApplicable;
+                                let mut hint = Sugg::ast(cx, body, "..", closure.span.ctxt(), &mut app);
 
                                 if asyncness.is_async() {
                                     // `async x` is a syntax error, so it becomes `async { x }`
diff --git a/clippy_utils/src/source.rs b/clippy_utils/src/source.rs
index eacfa91ba55..cd5dcfdaca3 100644
--- a/clippy_utils/src/source.rs
+++ b/clippy_utils/src/source.rs
@@ -5,6 +5,7 @@
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LintContext};
+use rustc_session::Session;
 use rustc_span::hygiene;
 use rustc_span::source_map::{original_sp, SourceMap};
 use rustc_span::{BytePos, Pos, Span, SpanData, SyntaxContext, DUMMY_SP};
@@ -204,11 +205,20 @@ pub fn snippet_with_applicability<'a, T: LintContext>(
     span: Span,
     default: &'a str,
     applicability: &mut Applicability,
+) -> Cow<'a, str> {
+    snippet_with_applicability_sess(cx.sess(), span, default, applicability)
+}
+
+fn snippet_with_applicability_sess<'a>(
+    sess: &Session,
+    span: Span,
+    default: &'a str,
+    applicability: &mut Applicability,
 ) -> Cow<'a, str> {
     if *applicability != Applicability::Unspecified && span.from_expansion() {
         *applicability = Applicability::MaybeIncorrect;
     }
-    snippet_opt(cx, span).map_or_else(
+    snippet_opt_sess(sess, span).map_or_else(
         || {
             if *applicability == Applicability::MachineApplicable {
                 *applicability = Applicability::HasPlaceholders;
@@ -226,8 +236,12 @@ pub fn snippet_with_macro_callsite<'a, T: LintContext>(cx: &T, span: Span, defau
 }
 
 /// Converts a span to a code snippet. Returns `None` if not available.
-pub fn snippet_opt<T: LintContext>(cx: &T, span: Span) -> Option<String> {
-    cx.sess().source_map().span_to_snippet(span).ok()
+pub fn snippet_opt(cx: &impl LintContext, span: Span) -> Option<String> {
+    snippet_opt_sess(cx.sess(), span)
+}
+
+fn snippet_opt_sess(sess: &Session, span: Span) -> Option<String> {
+    sess.source_map().span_to_snippet(span).ok()
 }
 
 /// Converts a span (from a block) to a code snippet if available, otherwise use default.
@@ -277,8 +291,8 @@ pub fn snippet_block<'a, T: LintContext>(
 
 /// Same as `snippet_block`, but adapts the applicability level by the rules of
 /// `snippet_with_applicability`.
-pub fn snippet_block_with_applicability<'a, T: LintContext>(
-    cx: &T,
+pub fn snippet_block_with_applicability<'a>(
+    cx: &impl LintContext,
     span: Span,
     default: &'a str,
     indent_relative_to: Option<Span>,
@@ -299,7 +313,17 @@ pub fn snippet_block_with_applicability<'a, T: LintContext>(
 ///
 /// This will also return whether or not the snippet is a macro call.
 pub fn snippet_with_context<'a>(
-    cx: &LateContext<'_>,
+    cx: &impl LintContext,
+    span: Span,
+    outer: SyntaxContext,
+    default: &'a str,
+    applicability: &mut Applicability,
+) -> (Cow<'a, str>, bool) {
+    snippet_with_context_sess(cx.sess(), span, outer, default, applicability)
+}
+
+fn snippet_with_context_sess<'a>(
+    sess: &Session,
     span: Span,
     outer: SyntaxContext,
     default: &'a str,
@@ -318,7 +342,7 @@ pub fn snippet_with_context<'a>(
     );
 
     (
-        snippet_with_applicability(cx, span, default, applicability),
+        snippet_with_applicability_sess(sess, span, default, applicability),
         is_macro_call,
     )
 }
diff --git a/clippy_utils/src/sugg.rs b/clippy_utils/src/sugg.rs
index 3cacdb49377..b66604f33db 100644
--- a/clippy_utils/src/sugg.rs
+++ b/clippy_utils/src/sugg.rs
@@ -176,25 +176,28 @@ impl<'a> Sugg<'a> {
     }
 
     /// Prepare a suggestion from an expression.
-    pub fn ast(cx: &EarlyContext<'_>, expr: &ast::Expr, default: &'a str) -> Self {
+    pub fn ast(
+        cx: &EarlyContext<'_>,
+        expr: &ast::Expr,
+        default: &'a str,
+        ctxt: SyntaxContext,
+        app: &mut Applicability,
+    ) -> Self {
         use rustc_ast::ast::RangeLimits;
 
-        let snippet_without_expansion = |cx, span: Span, default| {
-            if span.from_expansion() {
-                snippet_with_macro_callsite(cx, span, default)
-            } else {
-                snippet(cx, span, default)
-            }
-        };
-
+        #[expect(clippy::match_wildcard_for_single_variants)]
         match expr.kind {
+            _ if expr.span.ctxt() != ctxt => Sugg::NonParen(snippet_with_context(cx, expr.span, ctxt, default, app).0),
             ast::ExprKind::AddrOf(..)
             | ast::ExprKind::Box(..)
             | ast::ExprKind::Closure { .. }
             | ast::ExprKind::If(..)
             | ast::ExprKind::Let(..)
             | ast::ExprKind::Unary(..)
-            | ast::ExprKind::Match(..) => Sugg::MaybeParen(snippet_without_expansion(cx, expr.span, default)),
+            | ast::ExprKind::Match(..) => match snippet_with_context(cx, expr.span, ctxt, default, app) {
+                (snip, false) => Sugg::MaybeParen(snip),
+                (snip, true) => Sugg::NonParen(snip),
+            },
             ast::ExprKind::Async(..)
             | ast::ExprKind::Block(..)
             | ast::ExprKind::Break(..)
@@ -224,45 +227,49 @@ impl<'a> Sugg<'a> {
             | ast::ExprKind::Array(..)
             | ast::ExprKind::While(..)
             | ast::ExprKind::Await(..)
-            | ast::ExprKind::Err => Sugg::NonParen(snippet_without_expansion(cx, expr.span, default)),
+            | ast::ExprKind::Err => Sugg::NonParen(snippet_with_context(cx, expr.span, ctxt, default, app).0),
             ast::ExprKind::Range(ref lhs, ref rhs, RangeLimits::HalfOpen) => Sugg::BinOp(
                 AssocOp::DotDot,
-                lhs.as_ref()
-                    .map_or("".into(), |lhs| snippet_without_expansion(cx, lhs.span, default)),
-                rhs.as_ref()
-                    .map_or("".into(), |rhs| snippet_without_expansion(cx, rhs.span, default)),
+                lhs.as_ref().map_or("".into(), |lhs| {
+                    snippet_with_context(cx, lhs.span, ctxt, default, app).0
+                }),
+                rhs.as_ref().map_or("".into(), |rhs| {
+                    snippet_with_context(cx, rhs.span, ctxt, default, app).0
+                }),
             ),
             ast::ExprKind::Range(ref lhs, ref rhs, RangeLimits::Closed) => Sugg::BinOp(
                 AssocOp::DotDotEq,
-                lhs.as_ref()
-                    .map_or("".into(), |lhs| snippet_without_expansion(cx, lhs.span, default)),
-                rhs.as_ref()
-                    .map_or("".into(), |rhs| snippet_without_expansion(cx, rhs.span, default)),
+                lhs.as_ref().map_or("".into(), |lhs| {
+                    snippet_with_context(cx, lhs.span, ctxt, default, app).0
+                }),
+                rhs.as_ref().map_or("".into(), |rhs| {
+                    snippet_with_context(cx, rhs.span, ctxt, default, app).0
+                }),
             ),
             ast::ExprKind::Assign(ref lhs, ref rhs, _) => Sugg::BinOp(
                 AssocOp::Assign,
-                snippet_without_expansion(cx, lhs.span, default),
-                snippet_without_expansion(cx, rhs.span, default),
+                snippet_with_context(cx, lhs.span, ctxt, default, app).0,
+                snippet_with_context(cx, rhs.span, ctxt, default, app).0,
             ),
             ast::ExprKind::AssignOp(op, ref lhs, ref rhs) => Sugg::BinOp(
                 astbinop2assignop(op),
-                snippet_without_expansion(cx, lhs.span, default),
-                snippet_without_expansion(cx, rhs.span, default),
+                snippet_with_context(cx, lhs.span, ctxt, default, app).0,
+                snippet_with_context(cx, rhs.span, ctxt, default, app).0,
             ),
             ast::ExprKind::Binary(op, ref lhs, ref rhs) => Sugg::BinOp(
                 AssocOp::from_ast_binop(op.node),
-                snippet_without_expansion(cx, lhs.span, default),
-                snippet_without_expansion(cx, rhs.span, default),
+                snippet_with_context(cx, lhs.span, ctxt, default, app).0,
+                snippet_with_context(cx, rhs.span, ctxt, default, app).0,
             ),
             ast::ExprKind::Cast(ref lhs, ref ty) => Sugg::BinOp(
                 AssocOp::As,
-                snippet_without_expansion(cx, lhs.span, default),
-                snippet_without_expansion(cx, ty.span, default),
+                snippet_with_context(cx, lhs.span, ctxt, default, app).0,
+                snippet_with_context(cx, ty.span, ctxt, default, app).0,
             ),
             ast::ExprKind::Type(ref lhs, ref ty) => Sugg::BinOp(
                 AssocOp::Colon,
-                snippet_without_expansion(cx, lhs.span, default),
-                snippet_without_expansion(cx, ty.span, default),
+                snippet_with_context(cx, lhs.span, ctxt, default, app).0,
+                snippet_with_context(cx, ty.span, ctxt, default, app).0,
             ),
         }
     }
diff --git a/tests/ui/redundant_closure_call_fixable.fixed b/tests/ui/redundant_closure_call_fixable.fixed
index 7cd687c95a0..c0e49ff4caa 100644
--- a/tests/ui/redundant_closure_call_fixable.fixed
+++ b/tests/ui/redundant_closure_call_fixable.fixed
@@ -25,4 +25,16 @@ fn main() {
         x * y
     };
     let d = async { something().await };
+
+    macro_rules! m {
+        () => {
+            0
+        };
+    }
+    macro_rules! m2 {
+        () => {
+            m!()
+        };
+    }
+    m2!();
 }
diff --git a/tests/ui/redundant_closure_call_fixable.rs b/tests/ui/redundant_closure_call_fixable.rs
index 37e4d223864..9e6e54348a8 100644
--- a/tests/ui/redundant_closure_call_fixable.rs
+++ b/tests/ui/redundant_closure_call_fixable.rs
@@ -25,4 +25,16 @@ fn main() {
         x * y
     })();
     let d = (async || something().await)();
+
+    macro_rules! m {
+        () => {
+            (|| 0)()
+        };
+    }
+    macro_rules! m2 {
+        () => {
+            (|| m!())()
+        };
+    }
+    m2!();
 }
diff --git a/tests/ui/redundant_closure_call_fixable.stderr b/tests/ui/redundant_closure_call_fixable.stderr
index 56a8e57c0c3..d71bcba2a82 100644
--- a/tests/ui/redundant_closure_call_fixable.stderr
+++ b/tests/ui/redundant_closure_call_fixable.stderr
@@ -52,5 +52,27 @@ error: try not to call a closure in the expression where it is declared
 LL |     let d = (async || something().await)();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try doing something like: `async { something().await }`
 
-error: aborting due to 4 previous errors
+error: try not to call a closure in the expression where it is declared
+  --> $DIR/redundant_closure_call_fixable.rs:36:13
+   |
+LL |             (|| m!())()
+   |             ^^^^^^^^^^^ help: try doing something like: `m!()`
+...
+LL |     m2!();
+   |     ----- in this macro invocation
+   |
+   = note: this error originates in the macro `m2` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: try not to call a closure in the expression where it is declared
+  --> $DIR/redundant_closure_call_fixable.rs:31:13
+   |
+LL |             (|| 0)()
+   |             ^^^^^^^^ help: try doing something like: `0`
+...
+LL |     m2!();
+   |     ----- in this macro invocation
+   |
+   = note: this error originates in the macro `m` which comes from the expansion of the macro `m2` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: aborting due to 6 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 73f4546d24bc00f032d3761fa966f9f5927a8f76 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Wed, 30 Nov 2022 10:48:53 -0500
Subject: Fix `unnecessary_cast` suggestion when taking a reference

---
 clippy_lints/src/casts/unnecessary_cast.rs |  6 +++++-
 tests/ui/unnecessary_cast.fixed            |  3 +++
 tests/ui/unnecessary_cast.rs               |  3 +++
 tests/ui/unnecessary_cast.stderr           | 18 ++++++++++++------
 4 files changed, 23 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/unnecessary_cast.rs b/clippy_lints/src/casts/unnecessary_cast.rs
index ecc8a8de97b..7e23318076c 100644
--- a/clippy_lints/src/casts/unnecessary_cast.rs
+++ b/clippy_lints/src/casts/unnecessary_cast.rs
@@ -90,7 +90,11 @@ pub(super) fn check<'tcx>(
             expr.span,
             &format!("casting to the same type is unnecessary (`{cast_from}` -> `{cast_to}`)"),
             "try",
-            cast_str,
+            if get_parent_expr(cx, expr).map_or(false, |e| matches!(e.kind, ExprKind::AddrOf(..))) {
+                format!("{{ {cast_str} }}")
+            } else {
+                cast_str
+            },
             Applicability::MachineApplicable,
         );
         return true;
diff --git a/tests/ui/unnecessary_cast.fixed b/tests/ui/unnecessary_cast.fixed
index f234d4473c3..2f7e2997e73 100644
--- a/tests/ui/unnecessary_cast.fixed
+++ b/tests/ui/unnecessary_cast.fixed
@@ -96,6 +96,9 @@ mod fixable {
 
         let _ = 1 as I32Alias;
         let _ = &1 as &I32Alias;
+
+        let x = 1i32;
+        let _ = &{ x };
     }
 
     type I32Alias = i32;
diff --git a/tests/ui/unnecessary_cast.rs b/tests/ui/unnecessary_cast.rs
index 855a4efa034..54dd46ba59f 100644
--- a/tests/ui/unnecessary_cast.rs
+++ b/tests/ui/unnecessary_cast.rs
@@ -96,6 +96,9 @@ mod fixable {
 
         let _ = 1 as I32Alias;
         let _ = &1 as &I32Alias;
+
+        let x = 1i32;
+        let _ = &(x as i32);
     }
 
     type I32Alias = i32;
diff --git a/tests/ui/unnecessary_cast.stderr b/tests/ui/unnecessary_cast.stderr
index 934db0e86e6..fcee4ee2a65 100644
--- a/tests/ui/unnecessary_cast.stderr
+++ b/tests/ui/unnecessary_cast.stderr
@@ -150,35 +150,41 @@ error: casting float literal to `f32` is unnecessary
 LL |         let _ = -1.0 as f32;
    |                 ^^^^^^^^^^^ help: try: `-1.0_f32`
 
+error: casting to the same type is unnecessary (`i32` -> `i32`)
+  --> $DIR/unnecessary_cast.rs:101:18
+   |
+LL |         let _ = &(x as i32);
+   |                  ^^^^^^^^^^ help: try: `{ x }`
+
 error: casting integer literal to `i32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:104:22
+  --> $DIR/unnecessary_cast.rs:107:22
    |
 LL |         let _: i32 = -(1) as i32;
    |                      ^^^^^^^^^^^ help: try: `-1_i32`
 
 error: casting integer literal to `i64` is unnecessary
-  --> $DIR/unnecessary_cast.rs:106:22
+  --> $DIR/unnecessary_cast.rs:109:22
    |
 LL |         let _: i64 = -(1) as i64;
    |                      ^^^^^^^^^^^ help: try: `-1_i64`
 
 error: casting float literal to `f64` is unnecessary
-  --> $DIR/unnecessary_cast.rs:113:22
+  --> $DIR/unnecessary_cast.rs:116:22
    |
 LL |         let _: f64 = (-8.0 as f64).exp();
    |                      ^^^^^^^^^^^^^ help: try: `(-8.0_f64)`
 
 error: casting float literal to `f64` is unnecessary
-  --> $DIR/unnecessary_cast.rs:115:23
+  --> $DIR/unnecessary_cast.rs:118:23
    |
 LL |         let _: f64 = -(8.0 as f64).exp(); // should suggest `-8.0_f64.exp()` here not to change code behavior
    |                       ^^^^^^^^^^^^ help: try: `8.0_f64`
 
 error: casting to the same type is unnecessary (`f32` -> `f32`)
-  --> $DIR/unnecessary_cast.rs:123:20
+  --> $DIR/unnecessary_cast.rs:126:20
    |
 LL |         let _num = foo() as f32;
    |                    ^^^^^^^^^^^^ help: try: `foo()`
 
-error: aborting due to 30 previous errors
+error: aborting due to 31 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 2d32b403596d6ff152ccce3f1136b695698a3cc8 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Wed, 30 Nov 2022 11:15:49 -0500
Subject: Don't lint `explicit_auto_deref` when the initial type is neither a
 reference, nor a receiver

---
 clippy_lints/src/dereference.rs    | 17 +++++++++++------
 tests/ui/explicit_auto_deref.fixed |  4 ++++
 tests/ui/explicit_auto_deref.rs    |  4 ++++
 3 files changed, 19 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index 7de117d5549..57c30661e88 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -289,23 +289,24 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing<'tcx> {
                 let (position, adjustments) = walk_parents(cx, &mut self.possible_borrowers, expr, &self.msrv);
                 match kind {
                     RefOp::Deref => {
+                        let sub_ty = typeck.expr_ty(sub_expr);
                         if let Position::FieldAccess {
                             name,
                             of_union: false,
                         } = position
-                            && !ty_contains_field(typeck.expr_ty(sub_expr), name)
+                            && !ty_contains_field(sub_ty, name)
                         {
                             self.state = Some((
                                 State::ExplicitDerefField { name },
                                 StateData { span: expr.span, hir_id: expr.hir_id, position },
                             ));
-                        } else if position.is_deref_stable() {
+                        } else if position.is_deref_stable() && sub_ty.is_ref() {
                             self.state = Some((
                                 State::ExplicitDeref { mutability: None },
                                 StateData { span: expr.span, hir_id: expr.hir_id, position },
                             ));
                         }
-                    }
+                    },
                     RefOp::Method(target_mut)
                         if !is_lint_allowed(cx, EXPLICIT_DEREF_METHODS, expr.hir_id)
                             && position.lint_explicit_deref() =>
@@ -320,7 +321,7 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing<'tcx> {
                             StateData {
                                 span: expr.span,
                                 hir_id: expr.hir_id,
-                                position
+                                position,
                             },
                         ));
                     },
@@ -394,7 +395,11 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing<'tcx> {
                                     msg,
                                     snip_expr,
                                 }),
-                                StateData { span: expr.span, hir_id: expr.hir_id, position },
+                                StateData {
+                                    span: expr.span,
+                                    hir_id: expr.hir_id,
+                                    position,
+                                },
                             ));
                         } else if position.is_deref_stable()
                             // Auto-deref doesn't combine with other adjustments
@@ -406,7 +411,7 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing<'tcx> {
                                 StateData {
                                     span: expr.span,
                                     hir_id: expr.hir_id,
-                                    position
+                                    position,
                                 },
                             ));
                         }
diff --git a/tests/ui/explicit_auto_deref.fixed b/tests/ui/explicit_auto_deref.fixed
index 59ff5e4040a..475fae5e823 100644
--- a/tests/ui/explicit_auto_deref.fixed
+++ b/tests/ui/explicit_auto_deref.fixed
@@ -277,4 +277,8 @@ fn main() {
         unimplemented!()
     }
     let _: String = takes_assoc(&*String::new());
+
+    // Issue #9901
+    fn takes_ref(_: &i32) {}
+    takes_ref(*Box::new(&0i32));
 }
diff --git a/tests/ui/explicit_auto_deref.rs b/tests/ui/explicit_auto_deref.rs
index bcfb60c3278..c1894258f4d 100644
--- a/tests/ui/explicit_auto_deref.rs
+++ b/tests/ui/explicit_auto_deref.rs
@@ -277,4 +277,8 @@ fn main() {
         unimplemented!()
     }
     let _: String = takes_assoc(&*String::new());
+
+    // Issue #9901
+    fn takes_ref(_: &i32) {}
+    takes_ref(*Box::new(&0i32));
 }
-- 
cgit 1.4.1-3-g733a5


From c1b8bc66e999eda7dfa2887aab2a8b06914ed875 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Wed, 30 Nov 2022 12:31:38 -0500
Subject: Fix ICE in `unused_rounding`

---
 clippy_lints/src/unused_rounding.rs | 21 ++++++++-------------
 tests/ui/unused_rounding.fixed      |  3 +++
 tests/ui/unused_rounding.rs         |  3 +++
 tests/ui/unused_rounding.stderr     |  8 +++++++-
 4 files changed, 21 insertions(+), 14 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unused_rounding.rs b/clippy_lints/src/unused_rounding.rs
index aac6719a8dc..097568cd1f7 100644
--- a/clippy_lints/src/unused_rounding.rs
+++ b/clippy_lints/src/unused_rounding.rs
@@ -1,4 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet;
 use rustc_ast::ast::{Expr, ExprKind, MethodCall};
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass};
@@ -29,22 +30,16 @@ declare_clippy_lint! {
 }
 declare_lint_pass!(UnusedRounding => [UNUSED_ROUNDING]);
 
-fn is_useless_rounding(expr: &Expr) -> Option<(&str, String)> {
+fn is_useless_rounding<'a>(cx: &EarlyContext<'_>, expr: &'a Expr) -> Option<(&'a str, String)> {
     if let ExprKind::MethodCall(box MethodCall { seg:name_ident, receiver, .. }) = &expr.kind
         && let method_name = name_ident.ident.name.as_str()
         && (method_name == "ceil" || method_name == "round" || method_name == "floor")
         && let ExprKind::Lit(token_lit) = &receiver.kind
-        && token_lit.is_semantic_float() {
-            let mut f_str = token_lit.symbol.to_string();
-            let f = f_str.trim_end_matches('_').parse::<f64>().unwrap();
-            if let Some(suffix) = token_lit.suffix {
-                f_str.push_str(suffix.as_str());
-            }
-            if f.fract() == 0.0 {
-                Some((method_name, f_str))
-            } else {
-                None
-            }
+        && token_lit.is_semantic_float()
+        && let Ok(f) = token_lit.symbol.as_str().replace('_', "").parse::<f64>() {
+            (f.fract() == 0.0).then(||
+                (method_name, snippet(cx, receiver.span, "..").to_string())
+            )
         } else {
             None
         }
@@ -52,7 +47,7 @@ fn is_useless_rounding(expr: &Expr) -> Option<(&str, String)> {
 
 impl EarlyLintPass for UnusedRounding {
     fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
-        if let Some((method_name, float)) = is_useless_rounding(expr) {
+        if let Some((method_name, float)) = is_useless_rounding(cx, expr) {
             span_lint_and_sugg(
                 cx,
                 UNUSED_ROUNDING,
diff --git a/tests/ui/unused_rounding.fixed b/tests/ui/unused_rounding.fixed
index 38fe6c34cfe..f6f734c05ed 100644
--- a/tests/ui/unused_rounding.fixed
+++ b/tests/ui/unused_rounding.fixed
@@ -11,4 +11,7 @@ fn main() {
     let _ = 3.3_f32.round();
     let _ = 3.3_f64.round();
     let _ = 3.0_f32;
+
+    let _ = 3_3.0_0_f32;
+    let _ = 3_3.0_1_f64.round();
 }
diff --git a/tests/ui/unused_rounding.rs b/tests/ui/unused_rounding.rs
index a5cac64d023..a0267d8144a 100644
--- a/tests/ui/unused_rounding.rs
+++ b/tests/ui/unused_rounding.rs
@@ -11,4 +11,7 @@ fn main() {
     let _ = 3.3_f32.round();
     let _ = 3.3_f64.round();
     let _ = 3.0_f32.round();
+
+    let _ = 3_3.0_0_f32.round();
+    let _ = 3_3.0_1_f64.round();
 }
diff --git a/tests/ui/unused_rounding.stderr b/tests/ui/unused_rounding.stderr
index 1eeb5d1de88..b867996fe57 100644
--- a/tests/ui/unused_rounding.stderr
+++ b/tests/ui/unused_rounding.stderr
@@ -24,5 +24,11 @@ error: used the `round` method with a whole number float
 LL |     let _ = 3.0_f32.round();
    |             ^^^^^^^^^^^^^^^ help: remove the `round` method call: `3.0_f32`
 
-error: aborting due to 4 previous errors
+error: used the `round` method with a whole number float
+  --> $DIR/unused_rounding.rs:15:13
+   |
+LL |     let _ = 3_3.0_0_f32.round();
+   |             ^^^^^^^^^^^^^^^^^^^ help: remove the `round` method call: `3_3.0_0_f32`
+
+error: aborting due to 5 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 03ba0ea400b42a71455a9774b6cbbf7f28a8e9a7 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Wed, 30 Nov 2022 16:25:57 -0500
Subject: Don't suggest keeping borrows in `identity_op`

---
 clippy_lints/src/operators/identity_op.rs | 74 +++++++++++++++++++++++++++----
 tests/ui/identity_op.fixed                |  6 ++-
 tests/ui/identity_op.rs                   |  4 ++
 tests/ui/identity_op.stderr               | 12 +++--
 4 files changed, 83 insertions(+), 13 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/operators/identity_op.rs b/clippy_lints/src/operators/identity_op.rs
index b48d6c4e2e2..14a12da862e 100644
--- a/clippy_lints/src/operators/identity_op.rs
+++ b/clippy_lints/src/operators/identity_op.rs
@@ -1,7 +1,7 @@
 use clippy_utils::consts::{constant_full_int, constant_simple, Constant, FullInt};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::{clip, unsext};
+use clippy_utils::{clip, peel_hir_expr_refs, unsext};
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind, Node};
 use rustc_lint::LateContext;
@@ -20,20 +20,76 @@ pub(crate) fn check<'tcx>(
     if !is_allowed(cx, op, left, right) {
         match op {
             BinOpKind::Add | BinOpKind::BitOr | BinOpKind::BitXor => {
-                check_op(cx, left, 0, expr.span, right.span, needs_parenthesis(cx, expr, right));
-                check_op(cx, right, 0, expr.span, left.span, Parens::Unneeded);
+                check_op(
+                    cx,
+                    left,
+                    0,
+                    expr.span,
+                    peel_hir_expr_refs(right).0.span,
+                    needs_parenthesis(cx, expr, right),
+                );
+                check_op(
+                    cx,
+                    right,
+                    0,
+                    expr.span,
+                    peel_hir_expr_refs(left).0.span,
+                    Parens::Unneeded,
+                );
             },
             BinOpKind::Shl | BinOpKind::Shr | BinOpKind::Sub => {
-                check_op(cx, right, 0, expr.span, left.span, Parens::Unneeded);
+                check_op(
+                    cx,
+                    right,
+                    0,
+                    expr.span,
+                    peel_hir_expr_refs(left).0.span,
+                    Parens::Unneeded,
+                );
             },
             BinOpKind::Mul => {
-                check_op(cx, left, 1, expr.span, right.span, needs_parenthesis(cx, expr, right));
-                check_op(cx, right, 1, expr.span, left.span, Parens::Unneeded);
+                check_op(
+                    cx,
+                    left,
+                    1,
+                    expr.span,
+                    peel_hir_expr_refs(right).0.span,
+                    needs_parenthesis(cx, expr, right),
+                );
+                check_op(
+                    cx,
+                    right,
+                    1,
+                    expr.span,
+                    peel_hir_expr_refs(left).0.span,
+                    Parens::Unneeded,
+                );
             },
-            BinOpKind::Div => check_op(cx, right, 1, expr.span, left.span, Parens::Unneeded),
+            BinOpKind::Div => check_op(
+                cx,
+                right,
+                1,
+                expr.span,
+                peel_hir_expr_refs(left).0.span,
+                Parens::Unneeded,
+            ),
             BinOpKind::BitAnd => {
-                check_op(cx, left, -1, expr.span, right.span, needs_parenthesis(cx, expr, right));
-                check_op(cx, right, -1, expr.span, left.span, Parens::Unneeded);
+                check_op(
+                    cx,
+                    left,
+                    -1,
+                    expr.span,
+                    peel_hir_expr_refs(right).0.span,
+                    needs_parenthesis(cx, expr, right),
+                );
+                check_op(
+                    cx,
+                    right,
+                    -1,
+                    expr.span,
+                    peel_hir_expr_refs(left).0.span,
+                    Parens::Unneeded,
+                );
             },
             BinOpKind::Rem => check_remainder(cx, left, right, expr.span, left.span),
             _ => (),
diff --git a/tests/ui/identity_op.fixed b/tests/ui/identity_op.fixed
index e7b9a78c5db..cac69ef42c4 100644
--- a/tests/ui/identity_op.fixed
+++ b/tests/ui/identity_op.fixed
@@ -65,7 +65,7 @@ fn main() {
     42;
     1;
     42;
-    &x;
+    x;
     x;
 
     let mut a = A(String::new());
@@ -112,6 +112,10 @@ fn main() {
     2 * { a };
     (({ a } + 4));
     1;
+
+    // Issue #9904
+    let x = 0i32;
+    let _: i32 = x;
 }
 
 pub fn decide(a: bool, b: bool) -> u32 {
diff --git a/tests/ui/identity_op.rs b/tests/ui/identity_op.rs
index 9a435cdbb75..33201aad4f6 100644
--- a/tests/ui/identity_op.rs
+++ b/tests/ui/identity_op.rs
@@ -112,6 +112,10 @@ fn main() {
     2 * (0 + { a });
     1 * ({ a } + 4);
     1 * 1;
+
+    // Issue #9904
+    let x = 0i32;
+    let _: i32 = &x + 0;
 }
 
 pub fn decide(a: bool, b: bool) -> u32 {
diff --git a/tests/ui/identity_op.stderr b/tests/ui/identity_op.stderr
index 1a104a20b84..3ba557d18b2 100644
--- a/tests/ui/identity_op.stderr
+++ b/tests/ui/identity_op.stderr
@@ -70,7 +70,7 @@ error: this operation has no effect
   --> $DIR/identity_op.rs:68:5
    |
 LL |     &x >> 0;
-   |     ^^^^^^^ help: consider reducing it to: `&x`
+   |     ^^^^^^^ help: consider reducing it to: `x`
 
 error: this operation has no effect
   --> $DIR/identity_op.rs:69:5
@@ -229,10 +229,16 @@ LL |     1 * 1;
    |     ^^^^^ help: consider reducing it to: `1`
 
 error: this operation has no effect
-  --> $DIR/identity_op.rs:118:5
+  --> $DIR/identity_op.rs:118:18
+   |
+LL |     let _: i32 = &x + 0;
+   |                  ^^^^^^ help: consider reducing it to: `x`
+
+error: this operation has no effect
+  --> $DIR/identity_op.rs:122:5
    |
 LL |     0 + if a { 1 } else { 2 } + if b { 3 } else { 5 }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider reducing it to: `(if a { 1 } else { 2 })`
 
-error: aborting due to 39 previous errors
+error: aborting due to 40 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 55096eab0f5b398294cba8b9182e06b1c1e3d423 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Wed, 30 Nov 2022 21:29:48 -0500
Subject: Don't suggest removing `mut` from references in
 `redundant_static_lifetimes`

---
 clippy_lints/src/redundant_static_lifetimes.rs |  2 +-
 tests/ui/redundant_static_lifetimes.fixed      |  6 ++++++
 tests/ui/redundant_static_lifetimes.rs         |  6 ++++++
 tests/ui/redundant_static_lifetimes.stderr     | 10 ++++++++--
 4 files changed, 21 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/redundant_static_lifetimes.rs b/clippy_lints/src/redundant_static_lifetimes.rs
index 3aa2490bc44..41f991a967b 100644
--- a/clippy_lints/src/redundant_static_lifetimes.rs
+++ b/clippy_lints/src/redundant_static_lifetimes.rs
@@ -66,7 +66,7 @@ impl RedundantStaticLifetimes {
                         TyKind::Path(..) | TyKind::Slice(..) | TyKind::Array(..) | TyKind::Tup(..) => {
                             if lifetime.ident.name == rustc_span::symbol::kw::StaticLifetime {
                                 let snip = snippet(cx, borrow_type.ty.span, "<type>");
-                                let sugg = format!("&{snip}");
+                                let sugg = format!("&{}{snip}", borrow_type.mutbl.prefix_str());
                                 span_lint_and_then(
                                     cx,
                                     REDUNDANT_STATIC_LIFETIMES,
diff --git a/tests/ui/redundant_static_lifetimes.fixed b/tests/ui/redundant_static_lifetimes.fixed
index 4c5846fe837..bca777a890c 100644
--- a/tests/ui/redundant_static_lifetimes.fixed
+++ b/tests/ui/redundant_static_lifetimes.fixed
@@ -39,8 +39,14 @@ static STATIC_VAR_TUPLE: &(u8, u8) = &(1, 2); // ERROR Consider removing 'static
 
 static STATIC_VAR_ARRAY: &[u8; 1] = b"T"; // ERROR Consider removing 'static.
 
+static mut STATIC_MUT_SLICE: &mut [u32] = &mut [0];
+
 fn main() {
     let false_positive: &'static str = "test";
+
+    unsafe {
+        STATIC_MUT_SLICE[0] = 0;
+    }
 }
 
 trait Bar {
diff --git a/tests/ui/redundant_static_lifetimes.rs b/tests/ui/redundant_static_lifetimes.rs
index 64a66be1a83..afe7644816d 100644
--- a/tests/ui/redundant_static_lifetimes.rs
+++ b/tests/ui/redundant_static_lifetimes.rs
@@ -39,8 +39,14 @@ static STATIC_VAR_TUPLE: &'static (u8, u8) = &(1, 2); // ERROR Consider removing
 
 static STATIC_VAR_ARRAY: &'static [u8; 1] = b"T"; // ERROR Consider removing 'static.
 
+static mut STATIC_MUT_SLICE: &'static mut [u32] = &mut [0];
+
 fn main() {
     let false_positive: &'static str = "test";
+
+    unsafe {
+        STATIC_MUT_SLICE[0] = 0;
+    }
 }
 
 trait Bar {
diff --git a/tests/ui/redundant_static_lifetimes.stderr b/tests/ui/redundant_static_lifetimes.stderr
index 0938ebf783f..b2cbd2d9d01 100644
--- a/tests/ui/redundant_static_lifetimes.stderr
+++ b/tests/ui/redundant_static_lifetimes.stderr
@@ -97,10 +97,16 @@ LL | static STATIC_VAR_ARRAY: &'static [u8; 1] = b"T"; // ERROR Consider removin
    |                          -^^^^^^^-------- help: consider removing `'static`: `&[u8; 1]`
 
 error: statics have by default a `'static` lifetime
-  --> $DIR/redundant_static_lifetimes.rs:65:16
+  --> $DIR/redundant_static_lifetimes.rs:42:31
+   |
+LL | static mut STATIC_MUT_SLICE: &'static mut [u32] = &mut [0];
+   |                              -^^^^^^^---------- help: consider removing `'static`: `&mut [u32]`
+
+error: statics have by default a `'static` lifetime
+  --> $DIR/redundant_static_lifetimes.rs:71:16
    |
 LL |     static V: &'static u8 = &17;
    |               -^^^^^^^--- help: consider removing `'static`: `&u8`
 
-error: aborting due to 17 previous errors
+error: aborting due to 18 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 7ae5c81e9f9046a547757a1521e83c23da0bb67e Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Wed, 30 Nov 2022 21:44:18 -0500
Subject: Fix ICE in `result large_err` with uninhabited enums

---
 clippy_lints/src/functions/result.rs | 8 +++++---
 tests/ui/result_large_err.rs         | 6 ++++++
 2 files changed, 11 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/functions/result.rs b/clippy_lints/src/functions/result.rs
index f7e30b051a6..23da145d038 100644
--- a/clippy_lints/src/functions/result.rs
+++ b/clippy_lints/src/functions/result.rs
@@ -94,7 +94,9 @@ fn check_result_large_err<'tcx>(cx: &LateContext<'tcx>, err_ty: Ty<'tcx>, hir_ty
         if let hir::ItemKind::Enum(ref def, _) = item.kind;
         then {
             let variants_size = AdtVariantInfo::new(cx, *adt, subst);
-            if variants_size[0].size >= large_err_threshold {
+            if let Some((first_variant, variants)) = variants_size.split_first()
+                && first_variant.size >= large_err_threshold
+            {
                 span_lint_and_then(
                     cx,
                     RESULT_LARGE_ERR,
@@ -102,11 +104,11 @@ fn check_result_large_err<'tcx>(cx: &LateContext<'tcx>, err_ty: Ty<'tcx>, hir_ty
                     "the `Err`-variant returned from this function is very large",
                     |diag| {
                         diag.span_label(
-                            def.variants[variants_size[0].ind].span,
+                            def.variants[first_variant.ind].span,
                             format!("the largest variant contains at least {} bytes", variants_size[0].size),
                         );
 
-                        for variant in &variants_size[1..] {
+                        for variant in variants {
                             if variant.size >= large_err_threshold {
                                 let variant_def = &def.variants[variant.ind];
                                 diag.span_label(
diff --git a/tests/ui/result_large_err.rs b/tests/ui/result_large_err.rs
index 9dd27d6dc01..1c12cebfd97 100644
--- a/tests/ui/result_large_err.rs
+++ b/tests/ui/result_large_err.rs
@@ -108,4 +108,10 @@ pub fn array_error<T, U>() -> Result<(), ArrayError<(i32, T), U>> {
     Ok(())
 }
 
+// Issue #10005
+enum Empty {}
+fn _empty_error() -> Result<(), Empty> {
+    Ok(())
+}
+
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 6ecdff07e5c38f3cf53f299219ba575ebd4f9831 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Tue, 29 Nov 2022 00:20:53 -0500
Subject: Don't lint `from_over_into` for opaque types

---
 clippy_lints/src/from_over_into.rs |  3 ++-
 tests/ui/from_over_into.fixed      |  7 +++++++
 tests/ui/from_over_into.rs         |  7 +++++++
 tests/ui/from_over_into.stderr     | 10 +++++-----
 4 files changed, 21 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/from_over_into.rs b/clippy_lints/src/from_over_into.rs
index 8621504c1b4..cc3c35f4863 100644
--- a/clippy_lints/src/from_over_into.rs
+++ b/clippy_lints/src/from_over_into.rs
@@ -10,7 +10,7 @@ use rustc_hir::{
     TyKind,
 };
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::hir::nested_filter::OnlyBodies;
+use rustc_middle::{hir::nested_filter::OnlyBodies, ty};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::symbol::{kw, sym};
 use rustc_span::{Span, Symbol};
@@ -78,6 +78,7 @@ impl<'tcx> LateLintPass<'tcx> for FromOverInto {
             && let Some(GenericArgs { args: [GenericArg::Type(target_ty)], .. }) = into_trait_seg.args
             && let Some(middle_trait_ref) = cx.tcx.impl_trait_ref(item.owner_id)
             && cx.tcx.is_diagnostic_item(sym::Into, middle_trait_ref.def_id)
+            && !matches!(middle_trait_ref.substs.type_at(1).kind(), ty::Opaque(..))
         {
             span_lint_and_then(
                 cx,
diff --git a/tests/ui/from_over_into.fixed b/tests/ui/from_over_into.fixed
index 125c9a69cd3..72d635c2ccd 100644
--- a/tests/ui/from_over_into.fixed
+++ b/tests/ui/from_over_into.fixed
@@ -1,5 +1,6 @@
 // run-rustfix
 
+#![feature(type_alias_impl_trait)]
 #![warn(clippy::from_over_into)]
 #![allow(unused)]
 
@@ -81,4 +82,10 @@ fn msrv_1_41() {
     }
 }
 
+type Opaque = impl Sized;
+struct IntoOpaque;
+impl Into<Opaque> for IntoOpaque {
+    fn into(self) -> Opaque {}
+}
+
 fn main() {}
diff --git a/tests/ui/from_over_into.rs b/tests/ui/from_over_into.rs
index 5aa127bfabe..965f4d5d785 100644
--- a/tests/ui/from_over_into.rs
+++ b/tests/ui/from_over_into.rs
@@ -1,5 +1,6 @@
 // run-rustfix
 
+#![feature(type_alias_impl_trait)]
 #![warn(clippy::from_over_into)]
 #![allow(unused)]
 
@@ -81,4 +82,10 @@ fn msrv_1_41() {
     }
 }
 
+type Opaque = impl Sized;
+struct IntoOpaque;
+impl Into<Opaque> for IntoOpaque {
+    fn into(self) -> Opaque {}
+}
+
 fn main() {}
diff --git a/tests/ui/from_over_into.stderr b/tests/ui/from_over_into.stderr
index a1764a5ea12..3c4d011d6fb 100644
--- a/tests/ui/from_over_into.stderr
+++ b/tests/ui/from_over_into.stderr
@@ -1,5 +1,5 @@
 error: an implementation of `From` is preferred since it gives you `Into<_>` for free where the reverse isn't true
-  --> $DIR/from_over_into.rs:9:1
+  --> $DIR/from_over_into.rs:10:1
    |
 LL | impl Into<StringWrapper> for String {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -13,7 +13,7 @@ LL ~         StringWrapper(val)
    |
 
 error: an implementation of `From` is preferred since it gives you `Into<_>` for free where the reverse isn't true
-  --> $DIR/from_over_into.rs:17:1
+  --> $DIR/from_over_into.rs:18:1
    |
 LL | impl Into<SelfType> for String {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -26,7 +26,7 @@ LL ~         SelfType(String::new())
    |
 
 error: an implementation of `From` is preferred since it gives you `Into<_>` for free where the reverse isn't true
-  --> $DIR/from_over_into.rs:32:1
+  --> $DIR/from_over_into.rs:33:1
    |
 LL | impl Into<SelfKeywords> for X {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -41,7 +41,7 @@ LL ~         let _: X = val;
    |
 
 error: an implementation of `From` is preferred since it gives you `Into<_>` for free where the reverse isn't true
-  --> $DIR/from_over_into.rs:44:1
+  --> $DIR/from_over_into.rs:45:1
    |
 LL | impl core::convert::Into<bool> for crate::ExplicitPaths {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -59,7 +59,7 @@ LL ~         val.0
    |
 
 error: an implementation of `From` is preferred since it gives you `Into<_>` for free where the reverse isn't true
-  --> $DIR/from_over_into.rs:77:5
+  --> $DIR/from_over_into.rs:78:5
    |
 LL |     impl<T> Into<FromOverInto<T>> for Vec<T> {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From 05477ff8df2056e7301f28930e72bd13e983504d Mon Sep 17 00:00:00 2001
From: alex-semenyuk <alexsemenyuk88@gmail.com>
Date: Sat, 26 Nov 2022 19:21:07 +0300
Subject: Fix manual_let_else produces a wrong suggestion with or-patterns

---
 clippy_lints/src/manual_let_else.rs   |  7 ++++++-
 tests/ui/manual_let_else_match.rs     |  7 +++++++
 tests/ui/manual_let_else_match.stderr | 15 ++++++++++++---
 3 files changed, 25 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_let_else.rs b/clippy_lints/src/manual_let_else.rs
index 874d36ca9f4..9c6f8b43c07 100644
--- a/clippy_lints/src/manual_let_else.rs
+++ b/clippy_lints/src/manual_let_else.rs
@@ -151,7 +151,12 @@ fn emit_manual_let_else(cx: &LateContext<'_>, span: Span, expr: &Expr<'_>, pat:
             } else {
                 format!("{{ {sn_else} }}")
             };
-            let sugg = format!("let {sn_pat} = {sn_expr} else {else_bl};");
+            let sn_bl = if matches!(pat.kind, PatKind::Or(..)) {
+                format!("({sn_pat})")
+            } else {
+                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_match.rs b/tests/ui/manual_let_else_match.rs
index 93c86ca24fe..28caed9d79d 100644
--- a/tests/ui/manual_let_else_match.rs
+++ b/tests/ui/manual_let_else_match.rs
@@ -64,6 +64,13 @@ fn fire() {
         Ok(v) => v,
         Err(()) => return,
     };
+
+    let f = Variant::Bar(1);
+
+    let _value = match f {
+        Variant::Bar(_) | Variant::Baz(_) => (),
+        _ => return,
+    };
 }
 
 fn not_fire() {
diff --git a/tests/ui/manual_let_else_match.stderr b/tests/ui/manual_let_else_match.stderr
index 38be5ac5454..cd5e9a9ac39 100644
--- a/tests/ui/manual_let_else_match.stderr
+++ b/tests/ui/manual_let_else_match.stderr
@@ -25,7 +25,7 @@ LL | /         let v = match h() {
 LL | |             (Some(_), Some(_)) | (None, None) => continue,
 LL | |             (Some(v), None) | (None, Some(v)) => v,
 LL | |         };
-   | |__________^ help: consider writing: `let (Some(v), None) | (None, Some(v)) = h() else { continue };`
+   | |__________^ help: consider writing: `let ((Some(v), None) | (None, Some(v))) = h() else { continue };`
 
 error: this could be rewritten as `let...else`
   --> $DIR/manual_let_else_match.rs:49:9
@@ -34,7 +34,7 @@ LL | /         let v = match build_enum() {
 LL | |             _ => continue,
 LL | |             Variant::Bar(v) | Variant::Baz(v) => v,
 LL | |         };
-   | |__________^ help: consider writing: `let Variant::Bar(v) | Variant::Baz(v) = build_enum() else { continue };`
+   | |__________^ help: consider writing: `let (Variant::Bar(v) | Variant::Baz(v)) = build_enum() else { continue };`
 
 error: this could be rewritten as `let...else`
   --> $DIR/manual_let_else_match.rs:57:5
@@ -54,5 +54,14 @@ LL | |         Err(()) => return,
 LL | |     };
    | |______^ help: consider writing: `let Ok(v) = f().map_err(|_| ()) else { return };`
 
-error: aborting due to 6 previous errors
+error: this could be rewritten as `let...else`
+  --> $DIR/manual_let_else_match.rs:70:5
+   |
+LL | /     let _value = match f {
+LL | |         Variant::Bar(_) | Variant::Baz(_) => (),
+LL | |         _ => return,
+LL | |     };
+   | |______^ help: consider writing: `let (Variant::Bar(_) | Variant::Baz(_)) = f else { return };`
+
+error: aborting due to 7 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From a21b5b25f6aef692968470b9e2aae7600d1f07b4 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Thu, 1 Dec 2022 12:17:38 -0500
Subject: Don't lint `string_lit_as_bytes` in match scrutinees

---
 clippy_lints/src/strings.rs        | 38 ++++++++++++++++++++++++--------------
 tests/ui/string_lit_as_bytes.fixed |  6 ++++++
 tests/ui/string_lit_as_bytes.rs    |  6 ++++++
 3 files changed, 36 insertions(+), 14 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/strings.rs b/clippy_lints/src/strings.rs
index f4705481d4e..bc18cad6d38 100644
--- a/clippy_lints/src/strings.rs
+++ b/clippy_lints/src/strings.rs
@@ -1,12 +1,12 @@
 use clippy_utils::diagnostics::{span_lint, span_lint_and_help, span_lint_and_sugg};
 use clippy_utils::source::{snippet, snippet_with_applicability};
 use clippy_utils::ty::is_type_lang_item;
+use clippy_utils::{get_expr_use_or_unification_node, peel_blocks, SpanlessEq};
 use clippy_utils::{get_parent_expr, is_lint_allowed, match_function_call, method_calls, paths};
-use clippy_utils::{peel_blocks, SpanlessEq};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::def_id::DefId;
-use rustc_hir::{BinOpKind, BorrowKind, Expr, ExprKind, LangItem, QPath};
+use rustc_hir::{BinOpKind, BorrowKind, Expr, ExprKind, LangItem, Node, QPath};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty;
@@ -249,6 +249,7 @@ const MAX_LENGTH_BYTE_STRING_LIT: usize = 32;
 declare_lint_pass!(StringLitAsBytes => [STRING_LIT_AS_BYTES, STRING_FROM_UTF8_AS_BYTES]);
 
 impl<'tcx> LateLintPass<'tcx> for StringLitAsBytes {
+    #[expect(clippy::too_many_lines)]
     fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
         use rustc_ast::LitKind;
 
@@ -316,18 +317,27 @@ impl<'tcx> LateLintPass<'tcx> for StringLitAsBytes {
                     && lit_content.as_str().len() <= MAX_LENGTH_BYTE_STRING_LIT
                     && !receiver.span.from_expansion()
                 {
-                    span_lint_and_sugg(
-                        cx,
-                        STRING_LIT_AS_BYTES,
-                        e.span,
-                        "calling `as_bytes()` on a string literal",
-                        "consider using a byte string literal instead",
-                        format!(
-                            "b{}",
-                            snippet_with_applicability(cx, receiver.span, r#""foo""#, &mut applicability)
-                        ),
-                        applicability,
-                    );
+                    if let Some((parent, id)) = get_expr_use_or_unification_node(cx.tcx, e)
+                        && let Node::Expr(parent) = parent
+                        && let ExprKind::Match(scrutinee, ..) = parent.kind
+                        && scrutinee.hir_id == id
+                    {
+                        // Don't lint. Byte strings produce `&[u8; N]` whereas `as_bytes()` produces
+                        // `&[u8]`. This change would prevent matching with different sized slices.
+                    } else {
+                        span_lint_and_sugg(
+                            cx,
+                            STRING_LIT_AS_BYTES,
+                            e.span,
+                            "calling `as_bytes()` on a string literal",
+                            "consider using a byte string literal instead",
+                            format!(
+                                "b{}",
+                                snippet_with_applicability(cx, receiver.span, r#""foo""#, &mut applicability)
+                            ),
+                            applicability,
+                        );
+                    }
                 }
             }
         }
diff --git a/tests/ui/string_lit_as_bytes.fixed b/tests/ui/string_lit_as_bytes.fixed
index df2256e4f97..506187fc125 100644
--- a/tests/ui/string_lit_as_bytes.fixed
+++ b/tests/ui/string_lit_as_bytes.fixed
@@ -25,6 +25,12 @@ fn str_lit_as_bytes() {
     let includestr = include_bytes!("string_lit_as_bytes.rs");
 
     let _ = b"string with newline\t\n";
+
+    let _ = match "x".as_bytes() {
+        b"xx" => 0,
+        [b'x', ..] => 1,
+        _ => 2,
+    };
 }
 
 fn main() {}
diff --git a/tests/ui/string_lit_as_bytes.rs b/tests/ui/string_lit_as_bytes.rs
index c6bf8f732ed..2c339f1ddb8 100644
--- a/tests/ui/string_lit_as_bytes.rs
+++ b/tests/ui/string_lit_as_bytes.rs
@@ -25,6 +25,12 @@ fn str_lit_as_bytes() {
     let includestr = include_str!("string_lit_as_bytes.rs").as_bytes();
 
     let _ = "string with newline\t\n".as_bytes();
+
+    let _ = match "x".as_bytes() {
+        b"xx" => 0,
+        [b'x', ..] => 1,
+        _ => 2,
+    };
 }
 
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 47fb67fa086d88a878c11d7edc38f322f3b98fb9 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Thu, 1 Dec 2022 12:30:19 -0500
Subject: Don't lint `manual_assert` in `else if`

---
 clippy_lints/src/manual_assert.rs         | 6 +++++-
 tests/ui/manual_assert.edition2018.fixed  | 5 +++++
 tests/ui/manual_assert.edition2021.fixed  | 5 +++++
 tests/ui/manual_assert.edition2021.stderr | 2 +-
 tests/ui/manual_assert.rs                 | 5 +++++
 5 files changed, 21 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_assert.rs b/clippy_lints/src/manual_assert.rs
index b8ed9b9ec18..4277455a3a2 100644
--- a/clippy_lints/src/manual_assert.rs
+++ b/clippy_lints/src/manual_assert.rs
@@ -2,7 +2,7 @@ use crate::rustc_lint::LintContext;
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::macros::{root_macro_call, FormatArgsExpn};
 use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::{peel_blocks_with_stmt, span_extract_comment, sugg};
+use clippy_utils::{is_else_clause, peel_blocks_with_stmt, span_extract_comment, sugg};
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
@@ -47,6 +47,10 @@ impl<'tcx> LateLintPass<'tcx> for ManualAssert {
             if cx.tcx.item_name(macro_call.def_id) == sym::panic;
             if !cx.tcx.sess.source_map().is_multiline(cond.span);
             if let Some(format_args) = FormatArgsExpn::find_nested(cx, then, macro_call.expn);
+            // Don't change `else if foo { panic!(..) }` to `else { assert!(foo, ..) }` as it just
+            // shuffles the condition around.
+            // Should this have a config value?
+            if !is_else_clause(cx.tcx, expr);
             then {
                 let mut applicability = Applicability::MachineApplicable;
                 let format_args_snip = snippet_with_applicability(cx, format_args.inputs_span(), "..", &mut applicability);
diff --git a/tests/ui/manual_assert.edition2018.fixed b/tests/ui/manual_assert.edition2018.fixed
index c9a819ba535..638320dd6ee 100644
--- a/tests/ui/manual_assert.edition2018.fixed
+++ b/tests/ui/manual_assert.edition2018.fixed
@@ -62,6 +62,11 @@ fn main() {
         panic!("panic5");
     }
     assert!(!a.is_empty(), "with expansion {}", one!());
+    if a.is_empty() {
+        let _ = 0;
+    } else if a.len() == 1 {
+        panic!("panic6");
+    }
 }
 
 fn issue7730(a: u8) {
diff --git a/tests/ui/manual_assert.edition2021.fixed b/tests/ui/manual_assert.edition2021.fixed
index 2f62de51cad..8c7e919bf62 100644
--- a/tests/ui/manual_assert.edition2021.fixed
+++ b/tests/ui/manual_assert.edition2021.fixed
@@ -50,6 +50,11 @@ fn main() {
     assert!(!(b.is_empty() || a.is_empty()), "panic4");
     assert!(!(a.is_empty() || !b.is_empty()), "panic5");
     assert!(!a.is_empty(), "with expansion {}", one!());
+    if a.is_empty() {
+        let _ = 0;
+    } else if a.len() == 1 {
+        panic!("panic6");
+    }
 }
 
 fn issue7730(a: u8) {
diff --git a/tests/ui/manual_assert.edition2021.stderr b/tests/ui/manual_assert.edition2021.stderr
index 237638ee134..3555ac29243 100644
--- a/tests/ui/manual_assert.edition2021.stderr
+++ b/tests/ui/manual_assert.edition2021.stderr
@@ -65,7 +65,7 @@ LL | |     }
    | |_____^ help: try instead: `assert!(!a.is_empty(), "with expansion {}", one!());`
 
 error: only a `panic!` in `if`-then statement
-  --> $DIR/manual_assert.rs:73:5
+  --> $DIR/manual_assert.rs:78:5
    |
 LL | /     if a > 2 {
 LL | |         // comment
diff --git a/tests/ui/manual_assert.rs b/tests/ui/manual_assert.rs
index 6a4cc2468d4..f037c5b8405 100644
--- a/tests/ui/manual_assert.rs
+++ b/tests/ui/manual_assert.rs
@@ -66,6 +66,11 @@ fn main() {
     if a.is_empty() {
         panic!("with expansion {}", one!())
     }
+    if a.is_empty() {
+        let _ = 0;
+    } else if a.len() == 1 {
+        panic!("panic6");
+    }
 }
 
 fn issue7730(a: u8) {
-- 
cgit 1.4.1-3-g733a5


From ab8c6beb8526f9dbf3934835681e1ff9e951ea5b Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Thu, 1 Dec 2022 23:05:53 -0500
Subject: Don't lint `implicit_clone` when the type doesn't implement clone

---
 clippy_lints/src/methods/implicit_clone.rs |  4 +++-
 tests/ui/implicit_clone.fixed              | 10 ++++++++++
 tests/ui/implicit_clone.rs                 | 10 ++++++++++
 3 files changed, 23 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/implicit_clone.rs b/clippy_lints/src/methods/implicit_clone.rs
index 429cdc1918d..06ecbce4e70 100644
--- a/clippy_lints/src/methods/implicit_clone.rs
+++ b/clippy_lints/src/methods/implicit_clone.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_context;
-use clippy_utils::ty::peel_mid_ty_refs;
+use clippy_utils::ty::{implements_trait, peel_mid_ty_refs};
 use clippy_utils::{is_diag_item_method, is_diag_trait_item};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
@@ -19,6 +19,8 @@ pub fn check(cx: &LateContext<'_>, method_name: &str, expr: &hir::Expr<'_>, recv
         let (input_type, ref_count) = peel_mid_ty_refs(input_type);
         if let Some(ty_name) = input_type.ty_adt_def().map(|adt_def| cx.tcx.item_name(adt_def.did()));
         if return_type == input_type;
+        if let Some(clone_trait) = cx.tcx.lang_items().clone_trait();
+        if implements_trait(cx, return_type, clone_trait, &[]);
         then {
             let mut app = Applicability::MachineApplicable;
             let recv_snip = snippet_with_context(cx, recv.span, expr.span.ctxt(), "..", &mut app).0;
diff --git a/tests/ui/implicit_clone.fixed b/tests/ui/implicit_clone.fixed
index 33770fc2a2c..51b1afbe5ac 100644
--- a/tests/ui/implicit_clone.fixed
+++ b/tests/ui/implicit_clone.fixed
@@ -115,4 +115,14 @@ fn main() {
     let pathbuf_ref = &pathbuf_ref;
     let _ = pathbuf_ref.to_owned(); // Don't lint. Returns `&&PathBuf`
     let _ = (**pathbuf_ref).clone();
+
+    struct NoClone;
+    impl ToOwned for NoClone {
+        type Owned = Self;
+        fn to_owned(&self) -> Self {
+            NoClone
+        }
+    }
+    let no_clone = &NoClone;
+    let _ = no_clone.to_owned();
 }
diff --git a/tests/ui/implicit_clone.rs b/tests/ui/implicit_clone.rs
index fc896525bd2..8a9027433d9 100644
--- a/tests/ui/implicit_clone.rs
+++ b/tests/ui/implicit_clone.rs
@@ -115,4 +115,14 @@ fn main() {
     let pathbuf_ref = &pathbuf_ref;
     let _ = pathbuf_ref.to_owned(); // Don't lint. Returns `&&PathBuf`
     let _ = pathbuf_ref.to_path_buf();
+
+    struct NoClone;
+    impl ToOwned for NoClone {
+        type Owned = Self;
+        fn to_owned(&self) -> Self {
+            NoClone
+        }
+    }
+    let no_clone = &NoClone;
+    let _ = no_clone.to_owned();
 }
-- 
cgit 1.4.1-3-g733a5


From 6ba2cda79a33522d89c7c89f814f2788496616b9 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Thu, 1 Dec 2022 23:29:47 -0500
Subject: Fix `zero_ptr` suggestion for `no_std` crates

---
 clippy_lints/src/lib.rs         |  2 +-
 clippy_lints/src/misc.rs        | 66 ++++++++++++++++++++++++++---------------
 tests/ui/zero_ptr_no_std.fixed  | 21 +++++++++++++
 tests/ui/zero_ptr_no_std.rs     | 21 +++++++++++++
 tests/ui/zero_ptr_no_std.stderr | 26 ++++++++++++++++
 5 files changed, 111 insertions(+), 25 deletions(-)
 create mode 100644 tests/ui/zero_ptr_no_std.fixed
 create mode 100644 tests/ui/zero_ptr_no_std.rs
 create mode 100644 tests/ui/zero_ptr_no_std.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 7b17d8a156d..11177f830ab 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -538,7 +538,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(needless_bool::NeedlessBool));
     store.register_late_pass(|_| Box::new(needless_bool::BoolComparison));
     store.register_late_pass(|_| Box::new(needless_for_each::NeedlessForEach));
-    store.register_late_pass(|_| Box::new(misc::MiscLints));
+    store.register_late_pass(|_| Box::<misc::LintPass>::default());
     store.register_late_pass(|_| Box::new(eta_reduction::EtaReduction));
     store.register_late_pass(|_| Box::new(mut_mut::MutMut));
     store.register_late_pass(|_| Box::new(mut_reference::UnnecessaryMutPassed));
diff --git a/clippy_lints/src/misc.rs b/clippy_lints/src/misc.rs
index 516dee20f8b..9f4beb92b9d 100644
--- a/clippy_lints/src/misc.rs
+++ b/clippy_lints/src/misc.rs
@@ -9,12 +9,14 @@ use rustc_hir::{
 };
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::lint::in_external_macro;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::hygiene::DesugaringKind;
 use rustc_span::source_map::{ExpnKind, Span};
 
 use clippy_utils::sugg::Sugg;
-use clippy_utils::{get_parent_expr, in_constant, is_integer_literal, iter_input_pats, last_path_segment, SpanlessEq};
+use clippy_utils::{
+    get_parent_expr, in_constant, is_integer_literal, is_no_std_crate, iter_input_pats, last_path_segment, SpanlessEq,
+};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -120,14 +122,28 @@ declare_clippy_lint! {
     "using `0 as *{const, mut} T`"
 }
 
-declare_lint_pass!(MiscLints => [
+pub struct LintPass {
+    std_or_core: &'static str,
+}
+impl Default for LintPass {
+    fn default() -> Self {
+        Self { std_or_core: "std" }
+    }
+}
+impl_lint_pass!(LintPass => [
     TOPLEVEL_REF_ARG,
     USED_UNDERSCORE_BINDING,
     SHORT_CIRCUIT_STATEMENT,
     ZERO_PTR,
 ]);
 
-impl<'tcx> LateLintPass<'tcx> for MiscLints {
+impl<'tcx> LateLintPass<'tcx> for LintPass {
+    fn check_crate(&mut self, cx: &LateContext<'_>) {
+        if is_no_std_crate(cx) {
+            self.std_or_core = "core";
+        }
+    }
+
     fn check_fn(
         &mut self,
         cx: &LateContext<'tcx>,
@@ -231,7 +247,7 @@ impl<'tcx> LateLintPass<'tcx> for MiscLints {
 
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if let ExprKind::Cast(e, ty) = expr.kind {
-            check_cast(cx, expr.span, e, ty);
+            self.check_cast(cx, expr.span, e, ty);
             return;
         }
         if in_attributes_expansion(expr) || expr.span.is_desugaring(DesugaringKind::Await) {
@@ -310,26 +326,28 @@ fn non_macro_local(cx: &LateContext<'_>, res: def::Res) -> bool {
     }
 }
 
-fn check_cast(cx: &LateContext<'_>, span: Span, e: &Expr<'_>, ty: &hir::Ty<'_>) {
-    if_chain! {
-        if let TyKind::Ptr(ref mut_ty) = ty.kind;
-        if is_integer_literal(e, 0);
-        if !in_constant(cx, e.hir_id);
-        then {
-            let (msg, sugg_fn) = match mut_ty.mutbl {
-                Mutability::Mut => ("`0 as *mut _` detected", "std::ptr::null_mut"),
-                Mutability::Not => ("`0 as *const _` detected", "std::ptr::null"),
-            };
+impl LintPass {
+    fn check_cast(&self, cx: &LateContext<'_>, span: Span, e: &Expr<'_>, ty: &hir::Ty<'_>) {
+        if_chain! {
+            if let TyKind::Ptr(ref mut_ty) = ty.kind;
+            if is_integer_literal(e, 0);
+            if !in_constant(cx, e.hir_id);
+            then {
+                let (msg, sugg_fn) = match mut_ty.mutbl {
+                    Mutability::Mut => ("`0 as *mut _` detected", "ptr::null_mut"),
+                    Mutability::Not => ("`0 as *const _` detected", "ptr::null"),
+                };
 
-            let (sugg, appl) = if let TyKind::Infer = mut_ty.ty.kind {
-                (format!("{sugg_fn}()"), Applicability::MachineApplicable)
-            } else if let Some(mut_ty_snip) = snippet_opt(cx, mut_ty.ty.span) {
-                (format!("{sugg_fn}::<{mut_ty_snip}>()"), Applicability::MachineApplicable)
-            } else {
-                // `MaybeIncorrect` as type inference may not work with the suggested code
-                (format!("{sugg_fn}()"), Applicability::MaybeIncorrect)
-            };
-            span_lint_and_sugg(cx, ZERO_PTR, span, msg, "try", sugg, appl);
+                let (sugg, appl) = if let TyKind::Infer = mut_ty.ty.kind {
+                    (format!("{}::{sugg_fn}()", self.std_or_core), Applicability::MachineApplicable)
+                } else if let Some(mut_ty_snip) = snippet_opt(cx, mut_ty.ty.span) {
+                    (format!("{}::{sugg_fn}::<{mut_ty_snip}>()", self.std_or_core), Applicability::MachineApplicable)
+                } else {
+                    // `MaybeIncorrect` as type inference may not work with the suggested code
+                    (format!("{}::{sugg_fn}()", self.std_or_core), Applicability::MaybeIncorrect)
+                };
+                span_lint_and_sugg(cx, ZERO_PTR, span, msg, "try", sugg, appl);
+            }
         }
     }
 }
diff --git a/tests/ui/zero_ptr_no_std.fixed b/tests/ui/zero_ptr_no_std.fixed
new file mode 100644
index 00000000000..8906c776977
--- /dev/null
+++ b/tests/ui/zero_ptr_no_std.fixed
@@ -0,0 +1,21 @@
+// run-rustfix
+
+#![feature(lang_items, start, libc)]
+#![no_std]
+#![deny(clippy::zero_ptr)]
+
+#[start]
+fn main(_argc: isize, _argv: *const *const u8) -> isize {
+    let _ = core::ptr::null::<usize>();
+    let _ = core::ptr::null_mut::<f64>();
+    let _: *const u8 = core::ptr::null();
+    0
+}
+
+#[panic_handler]
+fn panic(_info: &core::panic::PanicInfo) -> ! {
+    loop {}
+}
+
+#[lang = "eh_personality"]
+extern "C" fn eh_personality() {}
diff --git a/tests/ui/zero_ptr_no_std.rs b/tests/ui/zero_ptr_no_std.rs
new file mode 100644
index 00000000000..379c1b18d29
--- /dev/null
+++ b/tests/ui/zero_ptr_no_std.rs
@@ -0,0 +1,21 @@
+// run-rustfix
+
+#![feature(lang_items, start, libc)]
+#![no_std]
+#![deny(clippy::zero_ptr)]
+
+#[start]
+fn main(_argc: isize, _argv: *const *const u8) -> isize {
+    let _ = 0 as *const usize;
+    let _ = 0 as *mut f64;
+    let _: *const u8 = 0 as *const _;
+    0
+}
+
+#[panic_handler]
+fn panic(_info: &core::panic::PanicInfo) -> ! {
+    loop {}
+}
+
+#[lang = "eh_personality"]
+extern "C" fn eh_personality() {}
diff --git a/tests/ui/zero_ptr_no_std.stderr b/tests/ui/zero_ptr_no_std.stderr
new file mode 100644
index 00000000000..d92bb4a6528
--- /dev/null
+++ b/tests/ui/zero_ptr_no_std.stderr
@@ -0,0 +1,26 @@
+error: `0 as *const _` detected
+  --> $DIR/zero_ptr_no_std.rs:9:13
+   |
+LL |     let _ = 0 as *const usize;
+   |             ^^^^^^^^^^^^^^^^^ help: try: `core::ptr::null::<usize>()`
+   |
+note: the lint level is defined here
+  --> $DIR/zero_ptr_no_std.rs:5:9
+   |
+LL | #![deny(clippy::zero_ptr)]
+   |         ^^^^^^^^^^^^^^^^
+
+error: `0 as *mut _` detected
+  --> $DIR/zero_ptr_no_std.rs:10:13
+   |
+LL |     let _ = 0 as *mut f64;
+   |             ^^^^^^^^^^^^^ help: try: `core::ptr::null_mut::<f64>()`
+
+error: `0 as *const _` detected
+  --> $DIR/zero_ptr_no_std.rs:11:24
+   |
+LL |     let _: *const u8 = 0 as *const _;
+   |                        ^^^^^^^^^^^^^ help: try: `core::ptr::null()`
+
+error: aborting due to 3 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 2701a4076f3d18edc06781d7a9b3091ee5dbd05f Mon Sep 17 00:00:00 2001
From: Samuel Moelius <sam@moeli.us>
Date: Fri, 2 Dec 2022 20:41:29 -0500
Subject: Fix #10021

---
 clippy_lints/src/methods/unnecessary_to_owned.rs | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/unnecessary_to_owned.rs b/clippy_lints/src/methods/unnecessary_to_owned.rs
index 17b0507682a..9263f051972 100644
--- a/clippy_lints/src/methods/unnecessary_to_owned.rs
+++ b/clippy_lints/src/methods/unnecessary_to_owned.rs
@@ -386,14 +386,12 @@ fn can_change_type<'a>(cx: &LateContext<'a>, mut expr: &'a Expr<'a>, mut ty: Ty<
             Node::Expr(parent_expr) => {
                 if let Some((callee_def_id, call_substs, recv, call_args)) = get_callee_substs_and_args(cx, parent_expr)
                 {
-                    if Some(callee_def_id) == cx.tcx.lang_items().into_future_fn() {
-                        return false;
-                    }
-
                     let fn_sig = cx.tcx.fn_sig(callee_def_id).skip_binder();
                     if let Some(arg_index) = recv.into_iter().chain(call_args).position(|arg| arg.hir_id == expr.hir_id)
                         && let Some(param_ty) = fn_sig.inputs().get(arg_index)
                         && let ty::Param(ParamTy { index: param_index , ..}) = param_ty.kind()
+                        // https://github.com/rust-lang/rust-clippy/issues/9504 and https://github.com/rust-lang/rust-clippy/issues/10021
+                        && (*param_index as usize) < call_substs.len()
                     {
                         if fn_sig
                             .inputs()
-- 
cgit 1.4.1-3-g733a5


From eec5039f09bc7992fbacaf0778adf85dcad54997 Mon Sep 17 00:00:00 2001
From: naosense <pingao777@gmail.com>
Date: Mon, 28 Nov 2022 17:40:00 +0800
Subject: fix test

---
 clippy_lints/src/indexing_slicing.rs             |  2 +-
 tests/ui-toml/suppress_lint_in_const/clippy.toml |  2 +-
 tests/ui-toml/suppress_lint_in_const/test.rs     | 49 ++++++++++++++++-
 tests/ui-toml/suppress_lint_in_const/test.stderr | 68 ++++++++++++++++++++++--
 tests/ui/indexing_slicing_index.rs               |  6 +--
 tests/ui/indexing_slicing_index.stderr           | 28 +++-------
 6 files changed, 121 insertions(+), 34 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/indexing_slicing.rs b/clippy_lints/src/indexing_slicing.rs
index 1a8ac43ac89..eebfb753a0c 100644
--- a/clippy_lints/src/indexing_slicing.rs
+++ b/clippy_lints/src/indexing_slicing.rs
@@ -166,7 +166,7 @@ impl<'tcx> LateLintPass<'tcx> for IndexingSlicing {
                 // Catchall non-range index, i.e., [n] or [n << m]
                 if let ty::Array(..) = ty.kind() {
                     // Index is a const block.
-                    if self.suppress_restriction_lint_in_const && let ExprKind::ConstBlock(..) = index.kind {
+                    if let ExprKind::ConstBlock(..) = index.kind {
                         return;
                     }
                     // Index is a constant uint.
diff --git a/tests/ui-toml/suppress_lint_in_const/clippy.toml b/tests/ui-toml/suppress_lint_in_const/clippy.toml
index d6b6fc7f268..1b9384d7e3e 100644
--- a/tests/ui-toml/suppress_lint_in_const/clippy.toml
+++ b/tests/ui-toml/suppress_lint_in_const/clippy.toml
@@ -1 +1 @@
-suppress-restriction-lint-in-const = false
+suppress-restriction-lint-in-const = true
diff --git a/tests/ui-toml/suppress_lint_in_const/test.rs b/tests/ui-toml/suppress_lint_in_const/test.rs
index e5f4ca7cc90..5a2df9f6c5d 100644
--- a/tests/ui-toml/suppress_lint_in_const/test.rs
+++ b/tests/ui-toml/suppress_lint_in_const/test.rs
@@ -1,4 +1,51 @@
+#![feature(inline_const)]
 #![warn(clippy::indexing_slicing)]
+// We also check the out_of_bounds_indexing lint here, because it lints similar things and
+// we want to avoid false positives.
+#![warn(clippy::out_of_bounds_indexing)]
+#![allow(unconditional_panic, clippy::no_effect, clippy::unnecessary_operation)]
+
+const ARR: [i32; 2] = [1, 2];
+const REF: &i32 = &ARR[idx()]; // Ok, should not produce stderr, since `suppress-restriction-lint-in-const` is set true.
+const REF_ERR: &i32 = &ARR[idx4()]; // Ok, let rustc handle const contexts.
+
+const fn idx() -> usize {
+    1
+}
+const fn idx4() -> usize {
+    4
+}
+
+fn main() {
+    let x = [1, 2, 3, 4];
+    let index: usize = 1;
+    x[index];
+    x[4]; // Ok, let rustc's `unconditional_panic` lint handle `usize` indexing on arrays.
+    x[1 << 3]; // Ok, let rustc's `unconditional_panic` lint handle `usize` indexing on arrays.
+
+    x[0]; // Ok, should not produce stderr.
+    x[3]; // Ok, should not produce stderr.
+    x[const { idx() }]; // Ok, should not produce stderr.
+    x[const { idx4() }]; // Ok, let rustc's `unconditional_panic` lint handle `usize` indexing on arrays.
+    const { &ARR[idx()] }; // Ok, should not produce stderr, since `suppress-restriction-lint-in-const` is set true.
+    const { &ARR[idx4()] }; // Ok, should not produce stderr, since `suppress-restriction-lint-in-const` is set true.
+
+    let y = &x;
+    y[0]; // Ok, referencing shouldn't affect this lint. See the issue 6021
+    y[4]; // Ok, rustc will handle references too.
+
+    let v = vec![0; 5];
+    v[0];
+    v[10];
+    v[1 << 3];
+
+    const N: usize = 15; // Out of bounds
+    const M: usize = 3; // In bounds
+    x[N]; // Ok, let rustc's `unconditional_panic` lint handle `usize` indexing on arrays.
+    x[M]; // Ok, should not produce stderr.
+    v[N];
+    v[M];
+}
 
 /// An opaque integer representation
 pub struct Integer<'a> {
@@ -11,5 +58,3 @@ impl<'a> Integer<'a> {
         self.value[0] & 0b1000_0000 != 0
     }
 }
-
-fn main() {}
diff --git a/tests/ui-toml/suppress_lint_in_const/test.stderr b/tests/ui-toml/suppress_lint_in_const/test.stderr
index c2acfed559d..bc178b7e131 100644
--- a/tests/ui-toml/suppress_lint_in_const/test.stderr
+++ b/tests/ui-toml/suppress_lint_in_const/test.stderr
@@ -1,12 +1,70 @@
+error[E0080]: evaluation of `main::{constant#3}` failed
+  --> $DIR/test.rs:31:14
+   |
+LL |     const { &ARR[idx4()] }; // Ok, should not produce stderr, since `suppress-restriction-lint-in-const` is set true.
+   |              ^^^^^^^^^^^ index out of bounds: the length is 2 but the index is 4
+
+note: erroneous constant used
+  --> $DIR/test.rs:31:5
+   |
+LL |     const { &ARR[idx4()] }; // Ok, should not produce stderr, since `suppress-restriction-lint-in-const` is set true.
+   |     ^^^^^^^^^^^^^^^^^^^^^^
+
 error: indexing may panic
-  --> $DIR/test.rs:11:9
+  --> $DIR/test.rs:22:5
    |
-LL |         self.value[0] & 0b1000_0000 != 0
-   |         ^^^^^^^^^^^^^
+LL |     x[index];
+   |     ^^^^^^^^
    |
    = help: consider using `.get(n)` or `.get_mut(n)` instead
-   = note: the suggestion might not be applicable in constant blocks
    = note: `-D clippy::indexing-slicing` implied by `-D warnings`
 
-error: aborting due to previous error
+error: indexing may panic
+  --> $DIR/test.rs:38:5
+   |
+LL |     v[0];
+   |     ^^^^
+   |
+   = help: consider using `.get(n)` or `.get_mut(n)` instead
+
+error: indexing may panic
+  --> $DIR/test.rs:39:5
+   |
+LL |     v[10];
+   |     ^^^^^
+   |
+   = help: consider using `.get(n)` or `.get_mut(n)` instead
+
+error: indexing may panic
+  --> $DIR/test.rs:40:5
+   |
+LL |     v[1 << 3];
+   |     ^^^^^^^^^
+   |
+   = help: consider using `.get(n)` or `.get_mut(n)` instead
+
+error: indexing may panic
+  --> $DIR/test.rs:46:5
+   |
+LL |     v[N];
+   |     ^^^^
+   |
+   = help: consider using `.get(n)` or `.get_mut(n)` instead
+
+error: indexing may panic
+  --> $DIR/test.rs:47:5
+   |
+LL |     v[M];
+   |     ^^^^
+   |
+   = help: consider using `.get(n)` or `.get_mut(n)` instead
+
+error[E0080]: evaluation of constant value failed
+  --> $DIR/test.rs:10:24
+   |
+LL | const REF_ERR: &i32 = &ARR[idx4()]; // Ok, let rustc handle const contexts.
+   |                        ^^^^^^^^^^^ index out of bounds: the length is 2 but the index is 4
+
+error: aborting due to 8 previous errors
 
+For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/indexing_slicing_index.rs b/tests/ui/indexing_slicing_index.rs
index 4476e0eb922..26abc9edb5e 100644
--- a/tests/ui/indexing_slicing_index.rs
+++ b/tests/ui/indexing_slicing_index.rs
@@ -6,7 +6,7 @@
 #![allow(unconditional_panic, clippy::no_effect, clippy::unnecessary_operation)]
 
 const ARR: [i32; 2] = [1, 2];
-const REF: &i32 = &ARR[idx()]; // Ok, should not produce stderr.
+const REF: &i32 = &ARR[idx()]; // This should be linted, since `suppress-restriction-lint-in-const` default is false.
 const REF_ERR: &i32 = &ARR[idx4()]; // Ok, let rustc handle const contexts.
 
 const fn idx() -> usize {
@@ -27,8 +27,8 @@ fn main() {
     x[3]; // Ok, should not produce stderr.
     x[const { idx() }]; // Ok, should not produce stderr.
     x[const { idx4() }]; // Ok, let rustc's `unconditional_panic` lint handle `usize` indexing on arrays.
-    const { &ARR[idx()] }; // Ok, should not produce stderr.
-    const { &ARR[idx4()] }; // Ok, let rustc handle const contexts.
+    const { &ARR[idx()] }; // This should be linted, since `suppress-restriction-lint-in-const` default is false.
+    const { &ARR[idx4()] }; // This should be linted, since `suppress-restriction-lint-in-const` default is false.
 
     let y = &x;
     y[0]; // Ok, referencing shouldn't affect this lint. See the issue 6021
diff --git a/tests/ui/indexing_slicing_index.stderr b/tests/ui/indexing_slicing_index.stderr
index 84e1f65623c..8fd77913a3f 100644
--- a/tests/ui/indexing_slicing_index.stderr
+++ b/tests/ui/indexing_slicing_index.stderr
@@ -1,7 +1,7 @@
 error: indexing may panic
   --> $DIR/indexing_slicing_index.rs:9:20
    |
-LL | const REF: &i32 = &ARR[idx()]; // Ok, should not produce stderr.
+LL | const REF: &i32 = &ARR[idx()]; // This should be linted, since `suppress-restriction-lint-in-const` default is false.
    |                    ^^^^^^^^^^
    |
    = help: consider using `.get(n)` or `.get_mut(n)` instead
@@ -20,13 +20,13 @@ LL | const REF_ERR: &i32 = &ARR[idx4()]; // Ok, let rustc handle const contexts.
 error[E0080]: evaluation of `main::{constant#3}` failed
   --> $DIR/indexing_slicing_index.rs:31:14
    |
-LL |     const { &ARR[idx4()] }; // Ok, let rustc handle const contexts.
+LL |     const { &ARR[idx4()] }; // This should be linted, since `suppress-restriction-lint-in-const` default is false.
    |              ^^^^^^^^^^^ index out of bounds: the length is 2 but the index is 4
 
 note: erroneous constant used
   --> $DIR/indexing_slicing_index.rs:31:5
    |
-LL |     const { &ARR[idx4()] }; // Ok, let rustc handle const contexts.
+LL |     const { &ARR[idx4()] }; // This should be linted, since `suppress-restriction-lint-in-const` default is false.
    |     ^^^^^^^^^^^^^^^^^^^^^^
 
 error: indexing may panic
@@ -37,26 +37,10 @@ LL |     x[index];
    |
    = help: consider using `.get(n)` or `.get_mut(n)` instead
 
-error: indexing may panic
-  --> $DIR/indexing_slicing_index.rs:28:5
-   |
-LL |     x[const { idx() }]; // Ok, should not produce stderr.
-   |     ^^^^^^^^^^^^^^^^^^
-   |
-   = help: consider using `.get(n)` or `.get_mut(n)` instead
-
-error: indexing may panic
-  --> $DIR/indexing_slicing_index.rs:29:5
-   |
-LL |     x[const { idx4() }]; // Ok, let rustc's `unconditional_panic` lint handle `usize` indexing on arrays.
-   |     ^^^^^^^^^^^^^^^^^^^
-   |
-   = help: consider using `.get(n)` or `.get_mut(n)` instead
-
 error: indexing may panic
   --> $DIR/indexing_slicing_index.rs:30:14
    |
-LL |     const { &ARR[idx()] }; // Ok, should not produce stderr.
+LL |     const { &ARR[idx()] }; // This should be linted, since `suppress-restriction-lint-in-const` default is false.
    |              ^^^^^^^^^^
    |
    = help: consider using `.get(n)` or `.get_mut(n)` instead
@@ -65,7 +49,7 @@ LL |     const { &ARR[idx()] }; // Ok, should not produce stderr.
 error: indexing may panic
   --> $DIR/indexing_slicing_index.rs:31:14
    |
-LL |     const { &ARR[idx4()] }; // Ok, let rustc handle const contexts.
+LL |     const { &ARR[idx4()] }; // This should be linted, since `suppress-restriction-lint-in-const` default is false.
    |              ^^^^^^^^^^^
    |
    = help: consider using `.get(n)` or `.get_mut(n)` instead
@@ -117,6 +101,6 @@ error[E0080]: evaluation of constant value failed
 LL | const REF_ERR: &i32 = &ARR[idx4()]; // Ok, let rustc handle const contexts.
    |                        ^^^^^^^^^^^ index out of bounds: the length is 2 but the index is 4
 
-error: aborting due to 14 previous errors
+error: aborting due to 12 previous errors
 
 For more information about this error, try `rustc --explain E0080`.
-- 
cgit 1.4.1-3-g733a5


From 20ec2ceab8450e1a0611fbc54a17a03ffc0bd39b Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukastw97@gmail.com>
Date: Mon, 5 Dec 2022 11:02:10 +0100
Subject: Add test case for blocks with semicolon inside and outside a block

---
 clippy_lints/src/semicolon_block.rs    | 9 ++++++---
 tests/ui/semicolon_inside_block.fixed  | 2 ++
 tests/ui/semicolon_inside_block.rs     | 2 ++
 tests/ui/semicolon_outside_block.fixed | 2 ++
 tests/ui/semicolon_outside_block.rs    | 2 ++
 5 files changed, 14 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/semicolon_block.rs b/clippy_lints/src/semicolon_block.rs
index d3cab68137c..8f1d1490e1f 100644
--- a/clippy_lints/src/semicolon_block.rs
+++ b/clippy_lints/src/semicolon_block.rs
@@ -8,11 +8,13 @@ use rustc_span::Span;
 declare_clippy_lint! {
     /// ### What it does
     ///
-    /// Suggests moving the semicolon from a block inside of the block to its kast expression.
+    /// Suggests moving the semicolon after a block to the inside of the block, after its last
+    /// expression.
     ///
     /// ### Why is this bad?
     ///
-    /// For consistency it's best to have the semicolon inside/outside the block. Either way is fine and this lint suggests inside the block.
+    /// For consistency it's best to have the semicolon inside/outside the block. Either way is fine
+    /// and this lint suggests inside the block.
     /// Take a look at `semicolon_outside_block` for the other alternative.
     ///
     /// ### Example
@@ -40,7 +42,8 @@ declare_clippy_lint! {
     ///
     /// ### Why is this bad?
     ///
-    /// For consistency it's best to have the semicolon inside/outside the block. Either way is fine and this lint suggests outside the block.
+    /// For consistency it's best to have the semicolon inside/outside the block. Either way is fine
+    /// and this lint suggests outside the block.
     /// Take a look at `semicolon_inside_block` for the other alternative.
     ///
     /// ### Example
diff --git a/tests/ui/semicolon_inside_block.fixed b/tests/ui/semicolon_inside_block.fixed
index 4cd112dd5e1..42e97e1ca35 100644
--- a/tests/ui/semicolon_inside_block.fixed
+++ b/tests/ui/semicolon_inside_block.fixed
@@ -79,5 +79,7 @@ fn main() {
         unit_fn_block()
     };
 
+    { unit_fn_block(); };
+
     unit_fn_block()
 }
diff --git a/tests/ui/semicolon_inside_block.rs b/tests/ui/semicolon_inside_block.rs
index 7512125c051..f40848f702e 100644
--- a/tests/ui/semicolon_inside_block.rs
+++ b/tests/ui/semicolon_inside_block.rs
@@ -79,5 +79,7 @@ fn main() {
         unit_fn_block()
     };
 
+    { unit_fn_block(); };
+
     unit_fn_block()
 }
diff --git a/tests/ui/semicolon_outside_block.fixed b/tests/ui/semicolon_outside_block.fixed
index 5bc18faaad8..091eaa7518e 100644
--- a/tests/ui/semicolon_outside_block.fixed
+++ b/tests/ui/semicolon_outside_block.fixed
@@ -79,5 +79,7 @@ fn main() {
         unit_fn_block()
     };
 
+    { unit_fn_block(); };
+
     unit_fn_block()
 }
diff --git a/tests/ui/semicolon_outside_block.rs b/tests/ui/semicolon_outside_block.rs
index 0a429323876..7ce46431fac 100644
--- a/tests/ui/semicolon_outside_block.rs
+++ b/tests/ui/semicolon_outside_block.rs
@@ -79,5 +79,7 @@ fn main() {
         unit_fn_block()
     };
 
+    { unit_fn_block(); };
+
     unit_fn_block()
 }
-- 
cgit 1.4.1-3-g733a5


From 591c18d2f01c140b55eed01ab33b96373a4ab230 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Wed, 7 Dec 2022 17:37:08 +0000
Subject: Add 1.58 MSRV for `collapsible_str_replace`

---
 clippy_lints/src/methods/mod.rs         |  5 ++++-
 clippy_utils/src/msrvs.rs               |  2 +-
 tests/ui/collapsible_str_replace.fixed  | 11 +++++++++++
 tests/ui/collapsible_str_replace.rs     | 11 +++++++++++
 tests/ui/collapsible_str_replace.stderr | 34 +++++++++++++++++++--------------
 5 files changed, 47 insertions(+), 16 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index d2913680cbb..cb7229ba8a4 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3672,7 +3672,10 @@ impl Methods {
                     no_effect_replace::check(cx, expr, arg1, arg2);
 
                     // Check for repeated `str::replace` calls to perform `collapsible_str_replace` lint
-                    if name == "replace" && let Some(("replace", ..)) = method_call(recv) {
+                    if self.msrv.meets(msrvs::PATTERN_TRAIT_CHAR_ARRAY)
+                        && name == "replace"
+                        && let Some(("replace", ..)) = method_call(recv)
+                    {
                         collapsible_str_replace::check(cx, expr, arg1, arg2);
                     }
                 },
diff --git a/clippy_utils/src/msrvs.rs b/clippy_utils/src/msrvs.rs
index 12a512f78a6..ba5bc9c3135 100644
--- a/clippy_utils/src/msrvs.rs
+++ b/clippy_utils/src/msrvs.rs
@@ -21,7 +21,7 @@ macro_rules! msrv_aliases {
 msrv_aliases! {
     1,65,0 { LET_ELSE }
     1,62,0 { BOOL_THEN_SOME }
-    1,58,0 { FORMAT_ARGS_CAPTURE }
+    1,58,0 { FORMAT_ARGS_CAPTURE, PATTERN_TRAIT_CHAR_ARRAY }
     1,53,0 { OR_PATTERNS, MANUAL_BITS, BTREE_MAP_RETAIN, BTREE_SET_RETAIN, ARRAY_INTO_ITERATOR }
     1,52,0 { STR_SPLIT_ONCE, REM_EUCLID_CONST }
     1,51,0 { BORROW_AS_PTR, SEEK_FROM_CURRENT, UNSIGNED_ABS }
diff --git a/tests/ui/collapsible_str_replace.fixed b/tests/ui/collapsible_str_replace.fixed
index 49fc9a9629e..9792ae9ed6b 100644
--- a/tests/ui/collapsible_str_replace.fixed
+++ b/tests/ui/collapsible_str_replace.fixed
@@ -1,5 +1,6 @@
 // run-rustfix
 
+#![allow(unused)]
 #![warn(clippy::collapsible_str_replace)]
 
 fn get_filter() -> char {
@@ -71,3 +72,13 @@ fn main() {
         .replace('u', iter.next().unwrap())
         .replace('s', iter.next().unwrap());
 }
+
+#[clippy::msrv = "1.57"]
+fn msrv_1_57() {
+    let _ = "".replace('a', "1.57").replace('b', "1.57");
+}
+
+#[clippy::msrv = "1.58"]
+fn msrv_1_58() {
+    let _ = "".replace(['a', 'b'], "1.58");
+}
diff --git a/tests/ui/collapsible_str_replace.rs b/tests/ui/collapsible_str_replace.rs
index e3e25c4146f..baee185b79e 100644
--- a/tests/ui/collapsible_str_replace.rs
+++ b/tests/ui/collapsible_str_replace.rs
@@ -1,5 +1,6 @@
 // run-rustfix
 
+#![allow(unused)]
 #![warn(clippy::collapsible_str_replace)]
 
 fn get_filter() -> char {
@@ -74,3 +75,13 @@ fn main() {
         .replace('u', iter.next().unwrap())
         .replace('s', iter.next().unwrap());
 }
+
+#[clippy::msrv = "1.57"]
+fn msrv_1_57() {
+    let _ = "".replace('a', "1.57").replace('b', "1.57");
+}
+
+#[clippy::msrv = "1.58"]
+fn msrv_1_58() {
+    let _ = "".replace('a', "1.58").replace('b', "1.58");
+}
diff --git a/tests/ui/collapsible_str_replace.stderr b/tests/ui/collapsible_str_replace.stderr
index 8e3daf3b898..223358cf53f 100644
--- a/tests/ui/collapsible_str_replace.stderr
+++ b/tests/ui/collapsible_str_replace.stderr
@@ -1,5 +1,5 @@
 error: used consecutive `str::replace` call
-  --> $DIR/collapsible_str_replace.rs:19:27
+  --> $DIR/collapsible_str_replace.rs:20:27
    |
 LL |     let _ = "hesuo worpd".replace('s', "l").replace('u', "l");
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `replace(['s', 'u'], "l")`
@@ -7,19 +7,19 @@ LL |     let _ = "hesuo worpd".replace('s', "l").replace('u', "l");
    = note: `-D clippy::collapsible-str-replace` implied by `-D warnings`
 
 error: used consecutive `str::replace` call
-  --> $DIR/collapsible_str_replace.rs:21:27
+  --> $DIR/collapsible_str_replace.rs:22:27
    |
 LL |     let _ = "hesuo worpd".replace('s', l).replace('u', l);
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `replace(['s', 'u'], l)`
 
 error: used consecutive `str::replace` call
-  --> $DIR/collapsible_str_replace.rs:23:27
+  --> $DIR/collapsible_str_replace.rs:24:27
    |
 LL |     let _ = "hesuo worpd".replace('s', "l").replace('u', "l").replace('p', "l");
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `replace(['s', 'u', 'p'], "l")`
 
 error: used consecutive `str::replace` call
-  --> $DIR/collapsible_str_replace.rs:26:10
+  --> $DIR/collapsible_str_replace.rs:27:10
    |
 LL |           .replace('s', "l")
    |  __________^
@@ -29,58 +29,64 @@ LL | |         .replace('d', "l");
    | |__________________________^ help: replace with: `replace(['s', 'u', 'p', 'd'], "l")`
 
 error: used consecutive `str::replace` call
-  --> $DIR/collapsible_str_replace.rs:31:27
+  --> $DIR/collapsible_str_replace.rs:32:27
    |
 LL |     let _ = "hesuo world".replace(s, "l").replace('u', "l");
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `replace([s, 'u'], "l")`
 
 error: used consecutive `str::replace` call
-  --> $DIR/collapsible_str_replace.rs:33:27
+  --> $DIR/collapsible_str_replace.rs:34:27
    |
 LL |     let _ = "hesuo worpd".replace(s, "l").replace('u', "l").replace('p', "l");
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `replace([s, 'u', 'p'], "l")`
 
 error: used consecutive `str::replace` call
-  --> $DIR/collapsible_str_replace.rs:35:27
+  --> $DIR/collapsible_str_replace.rs:36:27
    |
 LL |     let _ = "hesuo worpd".replace(s, "l").replace(u, "l").replace('p', "l");
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `replace([s, u, 'p'], "l")`
 
 error: used consecutive `str::replace` call
-  --> $DIR/collapsible_str_replace.rs:37:27
+  --> $DIR/collapsible_str_replace.rs:38:27
    |
 LL |     let _ = "hesuo worpd".replace(s, "l").replace(u, "l").replace(p, "l");
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `replace([s, u, p], "l")`
 
 error: used consecutive `str::replace` call
-  --> $DIR/collapsible_str_replace.rs:39:27
+  --> $DIR/collapsible_str_replace.rs:40:27
    |
 LL |     let _ = "hesuo worlp".replace('s', "l").replace('u', "l").replace('p', "d");
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `replace(['s', 'u'], "l")`
 
 error: used consecutive `str::replace` call
-  --> $DIR/collapsible_str_replace.rs:41:45
+  --> $DIR/collapsible_str_replace.rs:42:45
    |
 LL |     let _ = "hesuo worpd".replace('s', "x").replace('u', "l").replace('p', "l");
    |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `replace(['u', 'p'], "l")`
 
 error: used consecutive `str::replace` call
-  --> $DIR/collapsible_str_replace.rs:44:47
+  --> $DIR/collapsible_str_replace.rs:45:47
    |
 LL |     let _ = "hesudo worpd".replace("su", "l").replace('d', "l").replace('p', "l");
    |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `replace(['d', 'p'], "l")`
 
 error: used consecutive `str::replace` call
-  --> $DIR/collapsible_str_replace.rs:46:28
+  --> $DIR/collapsible_str_replace.rs:47:28
    |
 LL |     let _ = "hesudo worpd".replace(d, "l").replace('p', "l").replace("su", "l");
    |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `replace([d, 'p'], "l")`
 
 error: used consecutive `str::replace` call
-  --> $DIR/collapsible_str_replace.rs:48:27
+  --> $DIR/collapsible_str_replace.rs:49:27
    |
 LL |     let _ = "hesuo world".replace(get_filter(), "l").replace('s', "l");
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `replace([get_filter(), 's'], "l")`
 
-error: aborting due to 13 previous errors
+error: used consecutive `str::replace` call
+  --> $DIR/collapsible_str_replace.rs:86:16
+   |
+LL |     let _ = "".replace('a', "1.58").replace('b', "1.58");
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `replace(['a', 'b'], "1.58")`
+
+error: aborting due to 14 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 1f92f97e5acb3e400af406b17639cfae3926dd3b Mon Sep 17 00:00:00 2001
From: Caio <c410.f3r@gmail.com>
Date: Thu, 8 Dec 2022 17:41:49 -0300
Subject: [arithmetic-side-effects]: Consider user-provided pairs

---
 clippy_lints/src/lib.rs                            |  13 ++-
 .../src/operators/arithmetic_side_effects.rs       |  74 +++++++++----
 clippy_lints/src/operators/mod.rs                  |   3 -
 clippy_lints/src/utils/conf.rs                     |  43 ++++++-
 .../arithmetic_side_effects_allowed.rs             | 123 +++++++++++++++++----
 .../arithmetic_side_effects_allowed.stderr         |  58 ++++++++++
 .../arithmetic_side_effects_allowed/clippy.toml    |  12 +-
 .../toml_unknown_key/conf_unknown_key.stderr       |   2 +
 tests/ui/arithmetic_side_effects.stderr            |  24 +---
 9 files changed, 286 insertions(+), 66 deletions(-)
 create mode 100644 tests/ui-toml/arithmetic_side_effects_allowed/arithmetic_side_effects_allowed.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 3fe39488ab8..8facb78e35e 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -508,9 +508,20 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     }
 
     let arithmetic_side_effects_allowed = conf.arithmetic_side_effects_allowed.clone();
+    let arithmetic_side_effects_allowed_binary = conf.arithmetic_side_effects_allowed_binary.clone();
+    let arithmetic_side_effects_allowed_unary = conf.arithmetic_side_effects_allowed_unary.clone();
     store.register_late_pass(move |_| {
         Box::new(operators::arithmetic_side_effects::ArithmeticSideEffects::new(
-            arithmetic_side_effects_allowed.clone(),
+            arithmetic_side_effects_allowed
+                .iter()
+                .flat_map(|el| [[el.clone(), "*".to_string()], ["*".to_string(), el.clone()]])
+                .chain(arithmetic_side_effects_allowed_binary.clone())
+                .collect(),
+            arithmetic_side_effects_allowed
+                .iter()
+                .chain(arithmetic_side_effects_allowed_unary.iter())
+                .cloned()
+                .collect(),
         ))
     });
     store.register_late_pass(|_| Box::new(utils::dump_hir::DumpHir));
diff --git a/clippy_lints/src/operators/arithmetic_side_effects.rs b/clippy_lints/src/operators/arithmetic_side_effects.rs
index 20b82d81a2a..4fbc8398e37 100644
--- a/clippy_lints/src/operators/arithmetic_side_effects.rs
+++ b/clippy_lints/src/operators/arithmetic_side_effects.rs
@@ -5,25 +5,26 @@ use clippy_utils::{
     peel_hir_expr_refs,
 };
 use rustc_ast as ast;
-use rustc_data_structures::fx::FxHashSet;
+use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::Ty;
 use rustc_session::impl_lint_pass;
 use rustc_span::source_map::{Span, Spanned};
 
-const HARD_CODED_ALLOWED: &[&str] = &[
-    "&str",
-    "f32",
-    "f64",
-    "std::num::Saturating",
-    "std::num::Wrapping",
-    "std::string::String",
+const HARD_CODED_ALLOWED_BINARY: &[[&str; 2]] = &[
+    ["f32", "f32"],
+    ["f64", "f64"],
+    ["std::num::Saturating", "std::num::Saturating"],
+    ["std::num::Wrapping", "std::num::Wrapping"],
+    ["std::string::String", "&str"],
 ];
+const HARD_CODED_ALLOWED_UNARY: &[&str] = &["f32", "f64", "std::num::Saturating", "std::num::Wrapping"];
 
 #[derive(Debug)]
 pub struct ArithmeticSideEffects {
-    allowed: FxHashSet<String>,
+    allowed_binary: FxHashMap<String, FxHashSet<String>>,
+    allowed_unary: FxHashSet<String>,
     // Used to check whether expressions are constants, such as in enum discriminants and consts
     const_span: Option<Span>,
     expr_span: Option<Span>,
@@ -33,19 +34,55 @@ impl_lint_pass!(ArithmeticSideEffects => [ARITHMETIC_SIDE_EFFECTS]);
 
 impl ArithmeticSideEffects {
     #[must_use]
-    pub fn new(mut allowed: FxHashSet<String>) -> Self {
-        allowed.extend(HARD_CODED_ALLOWED.iter().copied().map(String::from));
+    pub fn new(user_allowed_binary: Vec<[String; 2]>, user_allowed_unary: Vec<String>) -> Self {
+        let mut allowed_binary: FxHashMap<String, FxHashSet<String>> = <_>::default();
+        for [lhs, rhs] in user_allowed_binary.into_iter().chain(
+            HARD_CODED_ALLOWED_BINARY
+                .iter()
+                .copied()
+                .map(|[lhs, rhs]| [lhs.to_string(), rhs.to_string()]),
+        ) {
+            allowed_binary.entry(lhs).or_default().insert(rhs);
+        }
+        let allowed_unary = user_allowed_unary
+            .into_iter()
+            .chain(HARD_CODED_ALLOWED_UNARY.iter().copied().map(String::from))
+            .collect();
         Self {
-            allowed,
+            allowed_binary,
+            allowed_unary,
             const_span: None,
             expr_span: None,
         }
     }
 
-    /// Checks if the given `expr` has any of the inner `allowed` elements.
-    fn is_allowed_ty(&self, ty: Ty<'_>) -> bool {
-        self.allowed
-            .contains(ty.to_string().split('<').next().unwrap_or_default())
+    /// Checks if the lhs and the rhs types of a binary operation like "addition" or
+    /// "multiplication" are present in the inner set of allowed types.
+    fn has_allowed_binary(&self, lhs_ty: Ty<'_>, rhs_ty: Ty<'_>) -> bool {
+        let lhs_ty_string = lhs_ty.to_string();
+        let lhs_ty_string_elem = lhs_ty_string.split('<').next().unwrap_or_default();
+        let rhs_ty_string = rhs_ty.to_string();
+        let rhs_ty_string_elem = rhs_ty_string.split('<').next().unwrap_or_default();
+        if let Some(rhs_from_specific) = self.allowed_binary.get(lhs_ty_string_elem)
+            && {
+                let rhs_has_allowed_ty = rhs_from_specific.contains(rhs_ty_string_elem);
+                rhs_has_allowed_ty || rhs_from_specific.contains("*")
+            }
+        {
+           true
+        } else if let Some(rhs_from_glob) = self.allowed_binary.get("*") {
+            rhs_from_glob.contains(rhs_ty_string_elem)
+        } else {
+            false
+        }
+    }
+
+    /// Checks if the type of an unary operation like "negation" is present in the inner set of
+    /// allowed types.
+    fn has_allowed_unary(&self, ty: Ty<'_>) -> bool {
+        let ty_string = ty.to_string();
+        let ty_string_elem = ty_string.split('<').next().unwrap_or_default();
+        self.allowed_unary.contains(ty_string_elem)
     }
 
     // For example, 8i32 or &i64::MAX.
@@ -97,8 +134,7 @@ impl ArithmeticSideEffects {
         };
         let lhs_ty = cx.typeck_results().expr_ty(lhs);
         let rhs_ty = cx.typeck_results().expr_ty(rhs);
-        let lhs_and_rhs_have_the_same_ty = lhs_ty == rhs_ty;
-        if lhs_and_rhs_have_the_same_ty && self.is_allowed_ty(lhs_ty) && self.is_allowed_ty(rhs_ty) {
+        if self.has_allowed_binary(lhs_ty, rhs_ty) {
             return;
         }
         let has_valid_op = if Self::is_integral(lhs_ty) && Self::is_integral(rhs_ty) {
@@ -137,7 +173,7 @@ impl ArithmeticSideEffects {
             return;
         }
         let ty = cx.typeck_results().expr_ty(expr).peel_refs();
-        if self.is_allowed_ty(ty) {
+        if self.has_allowed_unary(ty) {
             return;
         }
         let actual_un_expr = peel_hir_expr_refs(un_expr).0;
diff --git a/clippy_lints/src/operators/mod.rs b/clippy_lints/src/operators/mod.rs
index b8a20d5ebe9..eba230da6c3 100644
--- a/clippy_lints/src/operators/mod.rs
+++ b/clippy_lints/src/operators/mod.rs
@@ -90,9 +90,6 @@ declare_clippy_lint! {
     /// use rust_decimal::Decimal;
     /// let _n = Decimal::MAX + Decimal::MAX;
     /// ```
-    ///
-    /// ### Allowed types
-    /// Custom allowed types can be specified through the "arithmetic-side-effects-allowed" filter.
     #[clippy::version = "1.64.0"]
     pub ARITHMETIC_SIDE_EFFECTS,
     restriction,
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index b6dc8cd7ab1..d1dde069970 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -205,10 +205,49 @@ macro_rules! define_Conf {
 }
 
 define_Conf! {
-    /// Lint: Arithmetic.
+    /// Lint: ARITHMETIC_SIDE_EFFECTS.
     ///
-    /// Suppress checking of the passed type names.
+    /// Suppress checking of the passed type names in all types of operations.
+    ///
+    /// If a specific operation is desired, consider using `arithmetic_side_effects_allowed_binary` or `arithmetic_side_effects_allowed_unary` instead.
+    ///
+    /// #### Example
+    ///
+    /// ```toml
+    /// arithmetic-side-effects-allowed = ["SomeType", "AnotherType"]
+    /// ```
+    ///
+    /// #### Noteworthy
+    ///
+    /// A type, say `SomeType`, listed in this configuration has the same behavior of `["SomeType" , "*"], ["*", "SomeType"]` in `arithmetic_side_effects_allowed_binary`.
     (arithmetic_side_effects_allowed: rustc_data_structures::fx::FxHashSet<String> = <_>::default()),
+    /// Lint: ARITHMETIC_SIDE_EFFECTS.
+    ///
+    /// Suppress checking of the passed type pair names in binary operations like addition or
+    /// multiplication.
+    ///
+    /// Supports the "*" wildcard to indicate that a certain type won't trigger the lint regardless
+    /// of the involved counterpart. For example, `["SomeType", "*"]` or `["*", "AnotherType"]`.
+    ///
+    /// Pairs are asymmetric, which means that `["SomeType", "AnotherType"]` is not the same as
+    /// `["AnotherType", "SomeType"]`.
+    ///
+    /// #### Example
+    ///
+    /// ```toml
+    /// arithmetic-side-effects-allowed-binary = [["SomeType" , "f32"], ["AnotherType", "*"]]
+    /// ```
+    (arithmetic_side_effects_allowed_binary: Vec<[String; 2]> = <_>::default()),
+    /// Lint: ARITHMETIC_SIDE_EFFECTS.
+    ///
+    /// Suppress checking of the passed type names in unary operations like "negation" (`-`).
+    ///
+    /// #### Example
+    ///
+    /// ```toml
+    /// arithmetic-side-effects-allowed-unary = ["SomeType", "AnotherType"]
+    /// ```
+    (arithmetic_side_effects_allowed_unary: rustc_data_structures::fx::FxHashSet<String> = <_>::default()),
     /// Lint: ENUM_VARIANT_NAMES, LARGE_TYPES_PASSED_BY_VALUE, TRIVIALLY_COPY_PASS_BY_REF, UNNECESSARY_WRAPS, UNUSED_SELF, UPPER_CASE_ACRONYMS, WRONG_SELF_CONVENTION, BOX_COLLECTION, REDUNDANT_ALLOCATION, RC_BUFFER, VEC_BOX, OPTION_OPTION, LINKEDLIST, RC_MUTEX.
     ///
     /// Suppress lints whenever the suggested change would cause breakage for other crates.
diff --git a/tests/ui-toml/arithmetic_side_effects_allowed/arithmetic_side_effects_allowed.rs b/tests/ui-toml/arithmetic_side_effects_allowed/arithmetic_side_effects_allowed.rs
index e8a023ab176..36db9e54a22 100644
--- a/tests/ui-toml/arithmetic_side_effects_allowed/arithmetic_side_effects_allowed.rs
+++ b/tests/ui-toml/arithmetic_side_effects_allowed/arithmetic_side_effects_allowed.rs
@@ -2,32 +2,117 @@
 
 use core::ops::{Add, Neg};
 
-#[derive(Clone, Copy)]
-struct Point {
-    x: i32,
-    y: i32,
+macro_rules! create {
+    ($name:ident) => {
+        #[allow(clippy::arithmetic_side_effects)]
+        #[derive(Clone, Copy)]
+        struct $name;
+
+        impl Add<$name> for $name {
+            type Output = $name;
+            fn add(self, other: $name) -> Self::Output {
+                todo!()
+            }
+        }
+
+        impl Add<i32> for $name {
+            type Output = $name;
+            fn add(self, other: i32) -> Self::Output {
+                todo!()
+            }
+        }
+
+        impl Add<$name> for i32 {
+            type Output = $name;
+            fn add(self, other: $name) -> Self::Output {
+                todo!()
+            }
+        }
+
+        impl Add<i64> for $name {
+            type Output = $name;
+            fn add(self, other: i64) -> Self::Output {
+                todo!()
+            }
+        }
+
+        impl Add<$name> for i64 {
+            type Output = $name;
+            fn add(self, other: $name) -> Self::Output {
+                todo!()
+            }
+        }
+
+        impl Neg for $name {
+            type Output = $name;
+            fn neg(self) -> Self::Output {
+                todo!()
+            }
+        }
+    };
 }
 
-impl Add for Point {
-    type Output = Self;
+create!(Foo);
+create!(Bar);
+create!(Baz);
+create!(OutOfNames);
 
-    fn add(self, other: Self) -> Self {
-        todo!()
-    }
+fn lhs_and_rhs_are_equal() {
+    // is explicitly on the list
+    let _ = OutOfNames + OutOfNames;
+    // is explicitly on the list
+    let _ = Foo + Foo;
+    // is implicitly on the list
+    let _ = Bar + Bar;
+    // not on the list
+    let _ = Baz + Baz;
 }
 
-impl Neg for Point {
-    type Output = Self;
+fn lhs_is_different() {
+    // is explicitly on the list
+    let _ = 1i32 + OutOfNames;
+    // is explicitly on the list
+    let _ = 1i32 + Foo;
+    // is implicitly on the list
+    let _ = 1i32 + Bar;
+    // not on the list
+    let _ = 1i32 + Baz;
 
-    fn neg(self) -> Self::Output {
-        todo!()
-    }
+    // not on the list
+    let _ = 1i64 + Foo;
+    // is implicitly on the list
+    let _ = 1i64 + Bar;
+    // not on the list
+    let _ = 1i64 + Baz;
 }
 
-fn main() {
-    let _ = Point { x: 1, y: 0 } + Point { x: 2, y: 3 };
+fn rhs_is_different() {
+    // is explicitly on the list
+    let _ = OutOfNames + 1i32;
+    // is explicitly on the list
+    let _ = Foo + 1i32;
+    // is implicitly on the list
+    let _ = Bar + 1i32;
+    // not on the list
+    let _ = Baz + 1i32;
+
+    // not on the list
+    let _ = Foo + 1i64;
+    // is implicitly on the list
+    let _ = Bar + 1i64;
+    // not on the list
+    let _ = Baz + 1i64;
+}
 
-    let point: Point = Point { x: 1, y: 0 };
-    let _ = point + point;
-    let _ = -point;
+fn unary() {
+    // is explicitly on the list
+    let _ = -OutOfNames;
+    // is specifically on the list
+    let _ = -Foo;
+    // not on the list
+    let _ = -Bar;
+    // not on the list
+    let _ = -Baz;
 }
+
+fn main() {}
diff --git a/tests/ui-toml/arithmetic_side_effects_allowed/arithmetic_side_effects_allowed.stderr b/tests/ui-toml/arithmetic_side_effects_allowed/arithmetic_side_effects_allowed.stderr
new file mode 100644
index 00000000000..ad89534aa1b
--- /dev/null
+++ b/tests/ui-toml/arithmetic_side_effects_allowed/arithmetic_side_effects_allowed.stderr
@@ -0,0 +1,58 @@
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects_allowed.rs:68:13
+   |
+LL |     let _ = Baz + Baz;
+   |             ^^^^^^^^^
+   |
+   = note: `-D clippy::arithmetic-side-effects` implied by `-D warnings`
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects_allowed.rs:79:13
+   |
+LL |     let _ = 1i32 + Baz;
+   |             ^^^^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects_allowed.rs:82:13
+   |
+LL |     let _ = 1i64 + Foo;
+   |             ^^^^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects_allowed.rs:86:13
+   |
+LL |     let _ = 1i64 + Baz;
+   |             ^^^^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects_allowed.rs:97:13
+   |
+LL |     let _ = Baz + 1i32;
+   |             ^^^^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects_allowed.rs:100:13
+   |
+LL |     let _ = Foo + 1i64;
+   |             ^^^^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects_allowed.rs:104:13
+   |
+LL |     let _ = Baz + 1i64;
+   |             ^^^^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects_allowed.rs:113:13
+   |
+LL |     let _ = -Bar;
+   |             ^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects_allowed.rs:115:13
+   |
+LL |     let _ = -Baz;
+   |             ^^^^
+
+error: aborting due to 9 previous errors
+
diff --git a/tests/ui-toml/arithmetic_side_effects_allowed/clippy.toml b/tests/ui-toml/arithmetic_side_effects_allowed/clippy.toml
index e736256f29a..89cbea7ecfe 100644
--- a/tests/ui-toml/arithmetic_side_effects_allowed/clippy.toml
+++ b/tests/ui-toml/arithmetic_side_effects_allowed/clippy.toml
@@ -1 +1,11 @@
-arithmetic-side-effects-allowed = ["Point"]
+arithmetic-side-effects-allowed = [
+    "OutOfNames"
+]
+arithmetic-side-effects-allowed-binary = [
+    ["Foo", "Foo"],
+    ["Foo", "i32"],
+    ["i32", "Foo"],
+    ["Bar", "*"],
+    ["*", "Bar"],
+]
+arithmetic-side-effects-allowed-unary = ["Foo"]
diff --git a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
index 01a5e962c94..d8329f9c61b 100644
--- a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
+++ b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
@@ -6,6 +6,8 @@ error: error reading Clippy's configuration file `$DIR/clippy.toml`: unknown fie
            allow-unwrap-in-tests
            allowed-scripts
            arithmetic-side-effects-allowed
+           arithmetic-side-effects-allowed-binary
+           arithmetic-side-effects-allowed-unary
            array-size-threshold
            avoid-breaking-exported-api
            await-holding-invalid-types
diff --git a/tests/ui/arithmetic_side_effects.stderr b/tests/ui/arithmetic_side_effects.stderr
index 0259a0824e7..9fe4b7cf28d 100644
--- a/tests/ui/arithmetic_side_effects.stderr
+++ b/tests/ui/arithmetic_side_effects.stderr
@@ -1,28 +1,10 @@
-error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:78:13
-   |
-LL |     let _ = String::new() + "";
-   |             ^^^^^^^^^^^^^^^^^^
-   |
-   = note: `-D clippy::arithmetic-side-effects` implied by `-D warnings`
-
-error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:86:27
-   |
-LL |     let inferred_string = string + "";
-   |                           ^^^^^^^^^^^
-
-error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:90:13
-   |
-LL |     let _ = inferred_string + "";
-   |             ^^^^^^^^^^^^^^^^^^^^
-
 error: arithmetic operation that can potentially result in unexpected side-effects
   --> $DIR/arithmetic_side_effects.rs:165:5
    |
 LL |     _n += 1;
    |     ^^^^^^^
+   |
+   = note: `-D clippy::arithmetic-side-effects` implied by `-D warnings`
 
 error: arithmetic operation that can potentially result in unexpected side-effects
   --> $DIR/arithmetic_side_effects.rs:166:5
@@ -348,5 +330,5 @@ error: arithmetic operation that can potentially result in unexpected side-effec
 LL |     _n = -&_n;
    |          ^^^^
 
-error: aborting due to 58 previous errors
+error: aborting due to 55 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 4c80f210c38b78ddce983c2db16132a37bffd829 Mon Sep 17 00:00:00 2001
From: Hannah Town <phtown@protonmail.com>
Date: Fri, 9 Dec 2022 13:29:50 -0500
Subject: Add lint `almost_complete_range`

This replaces and expands `almost_complete_letter_range`.
---
 CHANGELOG.md                                     |   1 +
 clippy_lints/src/almost_complete_letter_range.rs | 110 -----------
 clippy_lints/src/almost_complete_range.rs        | 114 +++++++++++
 clippy_lints/src/declared_lints.rs               |   2 +-
 clippy_lints/src/lib.rs                          |   4 +-
 clippy_lints/src/renamed_lints.rs                |   1 +
 tests/ui/almost_complete_letter_range.fixed      |  79 --------
 tests/ui/almost_complete_letter_range.rs         |  79 --------
 tests/ui/almost_complete_letter_range.stderr     | 113 -----------
 tests/ui/almost_complete_range.fixed             | 108 +++++++++++
 tests/ui/almost_complete_range.rs                | 108 +++++++++++
 tests/ui/almost_complete_range.stderr            | 235 +++++++++++++++++++++++
 tests/ui/auxiliary/macro_rules.rs                |   4 +-
 tests/ui/needless_parens_on_range_literals.fixed |   2 +-
 tests/ui/needless_parens_on_range_literals.rs    |   2 +-
 tests/ui/rename.fixed                            |   2 +
 tests/ui/rename.rs                               |   2 +
 tests/ui/rename.stderr                           |  92 ++++-----
 18 files changed, 628 insertions(+), 430 deletions(-)
 delete mode 100644 clippy_lints/src/almost_complete_letter_range.rs
 create mode 100644 clippy_lints/src/almost_complete_range.rs
 delete mode 100644 tests/ui/almost_complete_letter_range.fixed
 delete mode 100644 tests/ui/almost_complete_letter_range.rs
 delete mode 100644 tests/ui/almost_complete_letter_range.stderr
 create mode 100644 tests/ui/almost_complete_range.fixed
 create mode 100644 tests/ui/almost_complete_range.rs
 create mode 100644 tests/ui/almost_complete_range.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index bc41e70fe1f..70a09db074e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3875,6 +3875,7 @@ Released 2018-09-13
 [`alloc_instead_of_core`]: https://rust-lang.github.io/rust-clippy/master/index.html#alloc_instead_of_core
 [`allow_attributes_without_reason`]: https://rust-lang.github.io/rust-clippy/master/index.html#allow_attributes_without_reason
 [`almost_complete_letter_range`]: https://rust-lang.github.io/rust-clippy/master/index.html#almost_complete_letter_range
+[`almost_complete_range`]: https://rust-lang.github.io/rust-clippy/master/index.html#almost_complete_range
 [`almost_swapped`]: https://rust-lang.github.io/rust-clippy/master/index.html#almost_swapped
 [`approx_constant`]: https://rust-lang.github.io/rust-clippy/master/index.html#approx_constant
 [`arithmetic_side_effects`]: https://rust-lang.github.io/rust-clippy/master/index.html#arithmetic_side_effects
diff --git a/clippy_lints/src/almost_complete_letter_range.rs b/clippy_lints/src/almost_complete_letter_range.rs
deleted file mode 100644
index 52beaf504a4..00000000000
--- a/clippy_lints/src/almost_complete_letter_range.rs
+++ /dev/null
@@ -1,110 +0,0 @@
-use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::msrvs::{self, Msrv};
-use clippy_utils::source::{trim_span, walk_span_to_context};
-use rustc_ast::ast::{Expr, ExprKind, LitKind, Pat, PatKind, RangeEnd, RangeLimits};
-use rustc_errors::Applicability;
-use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
-use rustc_middle::lint::in_external_macro;
-use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::Span;
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for ranges which almost include the entire range of letters from 'a' to 'z', but
-    /// don't because they're a half open range.
-    ///
-    /// ### Why is this bad?
-    /// This (`'a'..'z'`) is almost certainly a typo meant to include all letters.
-    ///
-    /// ### Example
-    /// ```rust
-    /// let _ = 'a'..'z';
-    /// ```
-    /// Use instead:
-    /// ```rust
-    /// let _ = 'a'..='z';
-    /// ```
-    #[clippy::version = "1.63.0"]
-    pub ALMOST_COMPLETE_LETTER_RANGE,
-    suspicious,
-    "almost complete letter range"
-}
-impl_lint_pass!(AlmostCompleteLetterRange => [ALMOST_COMPLETE_LETTER_RANGE]);
-
-pub struct AlmostCompleteLetterRange {
-    msrv: Msrv,
-}
-impl AlmostCompleteLetterRange {
-    pub fn new(msrv: Msrv) -> Self {
-        Self { msrv }
-    }
-}
-impl EarlyLintPass for AlmostCompleteLetterRange {
-    fn check_expr(&mut self, cx: &EarlyContext<'_>, e: &Expr) {
-        if let ExprKind::Range(Some(start), Some(end), RangeLimits::HalfOpen) = &e.kind {
-            let ctxt = e.span.ctxt();
-            let sugg = if let Some(start) = walk_span_to_context(start.span, ctxt)
-                && let Some(end) = walk_span_to_context(end.span, ctxt)
-                && self.msrv.meets(msrvs::RANGE_INCLUSIVE)
-            {
-                Some((trim_span(cx.sess().source_map(), start.between(end)), "..="))
-            } else {
-                None
-            };
-            check_range(cx, e.span, start, end, sugg);
-        }
-    }
-
-    fn check_pat(&mut self, cx: &EarlyContext<'_>, p: &Pat) {
-        if let PatKind::Range(Some(start), Some(end), kind) = &p.kind
-            && matches!(kind.node, RangeEnd::Excluded)
-        {
-            let sugg = if self.msrv.meets(msrvs::RANGE_INCLUSIVE) {
-                "..="
-            } else {
-                "..."
-            };
-            check_range(cx, p.span, start, end, Some((kind.span, sugg)));
-        }
-    }
-
-    extract_msrv_attr!(EarlyContext);
-}
-
-fn check_range(cx: &EarlyContext<'_>, span: Span, start: &Expr, end: &Expr, sugg: Option<(Span, &str)>) {
-    if let ExprKind::Lit(start_token_lit) = start.peel_parens().kind
-        && let ExprKind::Lit(end_token_lit) = end.peel_parens().kind
-        && matches!(
-            (
-                LitKind::from_token_lit(start_token_lit),
-                LitKind::from_token_lit(end_token_lit),
-            ),
-            (
-                Ok(LitKind::Byte(b'a') | LitKind::Char('a')),
-                Ok(LitKind::Byte(b'z') | LitKind::Char('z'))
-            )
-            | (
-                Ok(LitKind::Byte(b'A') | LitKind::Char('A')),
-                Ok(LitKind::Byte(b'Z') | LitKind::Char('Z')),
-            )
-        )
-        && !in_external_macro(cx.sess(), span)
-    {
-        span_lint_and_then(
-            cx,
-            ALMOST_COMPLETE_LETTER_RANGE,
-            span,
-            "almost complete ascii letter range",
-            |diag| {
-                if let Some((span, sugg)) = sugg {
-                    diag.span_suggestion(
-                        span,
-                        "use an inclusive range",
-                        sugg,
-                        Applicability::MaybeIncorrect,
-                    );
-                }
-            }
-        );
-    }
-}
diff --git a/clippy_lints/src/almost_complete_range.rs b/clippy_lints/src/almost_complete_range.rs
new file mode 100644
index 00000000000..42e14b5cd94
--- /dev/null
+++ b/clippy_lints/src/almost_complete_range.rs
@@ -0,0 +1,114 @@
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::msrvs::{self, Msrv};
+use clippy_utils::source::{trim_span, walk_span_to_context};
+use rustc_ast::ast::{Expr, ExprKind, LitKind, Pat, PatKind, RangeEnd, RangeLimits};
+use rustc_errors::Applicability;
+use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
+use rustc_middle::lint::in_external_macro;
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::Span;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for ranges which almost include the entire range of letters from 'a' to 'z'
+    /// or digits from '0' to '9', but don't because they're a half open range.
+    ///
+    /// ### Why is this bad?
+    /// This (`'a'..'z'`) is almost certainly a typo meant to include all letters.
+    ///
+    /// ### Example
+    /// ```rust
+    /// let _ = 'a'..'z';
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// let _ = 'a'..='z';
+    /// ```
+    #[clippy::version = "1.63.0"]
+    pub ALMOST_COMPLETE_RANGE,
+    suspicious,
+    "almost complete range"
+}
+impl_lint_pass!(AlmostCompleteRange => [ALMOST_COMPLETE_RANGE]);
+
+pub struct AlmostCompleteRange {
+    msrv: Msrv,
+}
+impl AlmostCompleteRange {
+    pub fn new(msrv: Msrv) -> Self {
+        Self { msrv }
+    }
+}
+impl EarlyLintPass for AlmostCompleteRange {
+    fn check_expr(&mut self, cx: &EarlyContext<'_>, e: &Expr) {
+        if let ExprKind::Range(Some(start), Some(end), RangeLimits::HalfOpen) = &e.kind {
+            let ctxt = e.span.ctxt();
+            let sugg = if let Some(start) = walk_span_to_context(start.span, ctxt)
+                && let Some(end) = walk_span_to_context(end.span, ctxt)
+                && self.msrv.meets(msrvs::RANGE_INCLUSIVE)
+            {
+                Some((trim_span(cx.sess().source_map(), start.between(end)), "..="))
+            } else {
+                None
+            };
+            check_range(cx, e.span, start, end, sugg);
+        }
+    }
+
+    fn check_pat(&mut self, cx: &EarlyContext<'_>, p: &Pat) {
+        if let PatKind::Range(Some(start), Some(end), kind) = &p.kind
+            && matches!(kind.node, RangeEnd::Excluded)
+        {
+            let sugg = if self.msrv.meets(msrvs::RANGE_INCLUSIVE) {
+                "..="
+            } else {
+                "..."
+            };
+            check_range(cx, p.span, start, end, Some((kind.span, sugg)));
+        }
+    }
+
+    extract_msrv_attr!(EarlyContext);
+}
+
+fn check_range(cx: &EarlyContext<'_>, span: Span, start: &Expr, end: &Expr, sugg: Option<(Span, &str)>) {
+    if let ExprKind::Lit(start_token_lit) = start.peel_parens().kind
+        && let ExprKind::Lit(end_token_lit) = end.peel_parens().kind
+        && matches!(
+            (
+                LitKind::from_token_lit(start_token_lit),
+                LitKind::from_token_lit(end_token_lit),
+            ),
+            (
+                Ok(LitKind::Byte(b'a') | LitKind::Char('a')),
+                Ok(LitKind::Byte(b'z') | LitKind::Char('z'))
+            )
+            | (
+                Ok(LitKind::Byte(b'A') | LitKind::Char('A')),
+                Ok(LitKind::Byte(b'Z') | LitKind::Char('Z')),
+            )
+            | (
+                Ok(LitKind::Byte(b'0') | LitKind::Char('0')),
+                Ok(LitKind::Byte(b'9') | LitKind::Char('9')),
+            )
+        )
+        && !in_external_macro(cx.sess(), span)
+    {
+        span_lint_and_then(
+            cx,
+            ALMOST_COMPLETE_RANGE,
+            span,
+            "almost complete ascii range",
+            |diag| {
+                if let Some((span, sugg)) = sugg {
+                    diag.span_suggestion(
+                        span,
+                        "use an inclusive range",
+                        sugg,
+                        Applicability::MaybeIncorrect,
+                    );
+                }
+            }
+        );
+    }
+}
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 77c1da993dc..3cd7d1d7e72 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -35,7 +35,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::utils::internal_lints::produce_ice::PRODUCE_ICE_INFO,
     #[cfg(feature = "internal")]
     crate::utils::internal_lints::unnecessary_def_path::UNNECESSARY_DEF_PATH_INFO,
-    crate::almost_complete_letter_range::ALMOST_COMPLETE_LETTER_RANGE_INFO,
+    crate::almost_complete_range::ALMOST_COMPLETE_RANGE_INFO,
     crate::approx_const::APPROX_CONSTANT_INFO,
     crate::as_conversions::AS_CONVERSIONS_INFO,
     crate::asm_syntax::INLINE_ASM_X86_ATT_SYNTAX_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index bea28f7620b..39850d59803 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -66,7 +66,7 @@ mod declared_lints;
 mod renamed_lints;
 
 // begin lints modules, do not remove this comment, it’s used in `update_lints`
-mod almost_complete_letter_range;
+mod almost_complete_range;
 mod approx_const;
 mod as_conversions;
 mod asm_syntax;
@@ -876,7 +876,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(rc_clone_in_vec_init::RcCloneInVecInit));
     store.register_early_pass(|| Box::<duplicate_mod::DuplicateMod>::default());
     store.register_early_pass(|| Box::new(unused_rounding::UnusedRounding));
-    store.register_early_pass(move || Box::new(almost_complete_letter_range::AlmostCompleteLetterRange::new(msrv())));
+    store.register_early_pass(move || Box::new(almost_complete_range::AlmostCompleteRange::new(msrv())));
     store.register_late_pass(|_| Box::new(swap_ptr_to_ref::SwapPtrToRef));
     store.register_late_pass(|_| Box::new(mismatching_type_param_order::TypeParamMismatch));
     store.register_late_pass(|_| Box::new(read_zero_byte_vec::ReadZeroByteVec));
diff --git a/clippy_lints/src/renamed_lints.rs b/clippy_lints/src/renamed_lints.rs
index 8e214218f23..72c25592609 100644
--- a/clippy_lints/src/renamed_lints.rs
+++ b/clippy_lints/src/renamed_lints.rs
@@ -2,6 +2,7 @@
 
 #[rustfmt::skip]
 pub static RENAMED_LINTS: &[(&str, &str)] = &[
+    ("clippy::almost_complete_letter_range", "clippy::almost_complete_range"),
     ("clippy::blacklisted_name", "clippy::disallowed_names"),
     ("clippy::block_in_if_condition_expr", "clippy::blocks_in_if_conditions"),
     ("clippy::block_in_if_condition_stmt", "clippy::blocks_in_if_conditions"),
diff --git a/tests/ui/almost_complete_letter_range.fixed b/tests/ui/almost_complete_letter_range.fixed
deleted file mode 100644
index adcbd4d5134..00000000000
--- a/tests/ui/almost_complete_letter_range.fixed
+++ /dev/null
@@ -1,79 +0,0 @@
-// run-rustfix
-// edition:2018
-// aux-build:macro_rules.rs
-
-#![feature(exclusive_range_pattern)]
-#![feature(stmt_expr_attributes)]
-#![warn(clippy::almost_complete_letter_range)]
-#![allow(ellipsis_inclusive_range_patterns)]
-#![allow(clippy::needless_parens_on_range_literals)]
-
-#[macro_use]
-extern crate macro_rules;
-
-macro_rules! a {
-    () => {
-        'a'
-    };
-}
-
-macro_rules! b {
-    () => {
-        let _ = 'a'..='z';
-    };
-}
-
-fn main() {
-    #[rustfmt::skip]
-    {
-        let _ = ('a') ..='z';
-        let _ = 'A' ..= ('Z');
-    }
-
-    let _ = 'b'..'z';
-    let _ = 'B'..'Z';
-
-    let _ = (b'a')..=(b'z');
-    let _ = b'A'..=b'Z';
-
-    let _ = b'b'..b'z';
-    let _ = b'B'..b'Z';
-
-    let _ = a!()..='z';
-
-    let _ = match 0u8 {
-        b'a'..=b'z' if true => 1,
-        b'A'..=b'Z' if true => 2,
-        b'b'..b'z' => 3,
-        b'B'..b'Z' => 4,
-        _ => 5,
-    };
-
-    let _ = match 'x' {
-        'a'..='z' if true => 1,
-        'A'..='Z' if true => 2,
-        'b'..'z' => 3,
-        'B'..'Z' => 4,
-        _ => 5,
-    };
-
-    almost_complete_letter_range!();
-    b!();
-}
-
-#[clippy::msrv = "1.25"]
-fn _under_msrv() {
-    let _ = match 'a' {
-        'a'...'z' => 1,
-        _ => 2,
-    };
-}
-
-#[clippy::msrv = "1.26"]
-fn _meets_msrv() {
-    let _ = 'a'..='z';
-    let _ = match 'a' {
-        'a'..='z' => 1,
-        _ => 2,
-    };
-}
diff --git a/tests/ui/almost_complete_letter_range.rs b/tests/ui/almost_complete_letter_range.rs
deleted file mode 100644
index 9979316eca4..00000000000
--- a/tests/ui/almost_complete_letter_range.rs
+++ /dev/null
@@ -1,79 +0,0 @@
-// run-rustfix
-// edition:2018
-// aux-build:macro_rules.rs
-
-#![feature(exclusive_range_pattern)]
-#![feature(stmt_expr_attributes)]
-#![warn(clippy::almost_complete_letter_range)]
-#![allow(ellipsis_inclusive_range_patterns)]
-#![allow(clippy::needless_parens_on_range_literals)]
-
-#[macro_use]
-extern crate macro_rules;
-
-macro_rules! a {
-    () => {
-        'a'
-    };
-}
-
-macro_rules! b {
-    () => {
-        let _ = 'a'..'z';
-    };
-}
-
-fn main() {
-    #[rustfmt::skip]
-    {
-        let _ = ('a') ..'z';
-        let _ = 'A' .. ('Z');
-    }
-
-    let _ = 'b'..'z';
-    let _ = 'B'..'Z';
-
-    let _ = (b'a')..(b'z');
-    let _ = b'A'..b'Z';
-
-    let _ = b'b'..b'z';
-    let _ = b'B'..b'Z';
-
-    let _ = a!()..'z';
-
-    let _ = match 0u8 {
-        b'a'..b'z' if true => 1,
-        b'A'..b'Z' if true => 2,
-        b'b'..b'z' => 3,
-        b'B'..b'Z' => 4,
-        _ => 5,
-    };
-
-    let _ = match 'x' {
-        'a'..'z' if true => 1,
-        'A'..'Z' if true => 2,
-        'b'..'z' => 3,
-        'B'..'Z' => 4,
-        _ => 5,
-    };
-
-    almost_complete_letter_range!();
-    b!();
-}
-
-#[clippy::msrv = "1.25"]
-fn _under_msrv() {
-    let _ = match 'a' {
-        'a'..'z' => 1,
-        _ => 2,
-    };
-}
-
-#[clippy::msrv = "1.26"]
-fn _meets_msrv() {
-    let _ = 'a'..'z';
-    let _ = match 'a' {
-        'a'..'z' => 1,
-        _ => 2,
-    };
-}
diff --git a/tests/ui/almost_complete_letter_range.stderr b/tests/ui/almost_complete_letter_range.stderr
deleted file mode 100644
index 9abf6d6c5e7..00000000000
--- a/tests/ui/almost_complete_letter_range.stderr
+++ /dev/null
@@ -1,113 +0,0 @@
-error: almost complete ascii letter range
-  --> $DIR/almost_complete_letter_range.rs:29:17
-   |
-LL |         let _ = ('a') ..'z';
-   |                 ^^^^^^--^^^
-   |                       |
-   |                       help: use an inclusive range: `..=`
-   |
-   = note: `-D clippy::almost-complete-letter-range` implied by `-D warnings`
-
-error: almost complete ascii letter range
-  --> $DIR/almost_complete_letter_range.rs:30:17
-   |
-LL |         let _ = 'A' .. ('Z');
-   |                 ^^^^--^^^^^^
-   |                     |
-   |                     help: use an inclusive range: `..=`
-
-error: almost complete ascii letter range
-  --> $DIR/almost_complete_letter_range.rs:36:13
-   |
-LL |     let _ = (b'a')..(b'z');
-   |             ^^^^^^--^^^^^^
-   |                   |
-   |                   help: use an inclusive range: `..=`
-
-error: almost complete ascii letter range
-  --> $DIR/almost_complete_letter_range.rs:37:13
-   |
-LL |     let _ = b'A'..b'Z';
-   |             ^^^^--^^^^
-   |                 |
-   |                 help: use an inclusive range: `..=`
-
-error: almost complete ascii letter range
-  --> $DIR/almost_complete_letter_range.rs:42:13
-   |
-LL |     let _ = a!()..'z';
-   |             ^^^^--^^^
-   |                 |
-   |                 help: use an inclusive range: `..=`
-
-error: almost complete ascii letter range
-  --> $DIR/almost_complete_letter_range.rs:45:9
-   |
-LL |         b'a'..b'z' if true => 1,
-   |         ^^^^--^^^^
-   |             |
-   |             help: use an inclusive range: `..=`
-
-error: almost complete ascii letter range
-  --> $DIR/almost_complete_letter_range.rs:46:9
-   |
-LL |         b'A'..b'Z' if true => 2,
-   |         ^^^^--^^^^
-   |             |
-   |             help: use an inclusive range: `..=`
-
-error: almost complete ascii letter range
-  --> $DIR/almost_complete_letter_range.rs:53:9
-   |
-LL |         'a'..'z' if true => 1,
-   |         ^^^--^^^
-   |            |
-   |            help: use an inclusive range: `..=`
-
-error: almost complete ascii letter range
-  --> $DIR/almost_complete_letter_range.rs:54:9
-   |
-LL |         'A'..'Z' if true => 2,
-   |         ^^^--^^^
-   |            |
-   |            help: use an inclusive range: `..=`
-
-error: almost complete ascii letter range
-  --> $DIR/almost_complete_letter_range.rs:22:17
-   |
-LL |         let _ = 'a'..'z';
-   |                 ^^^--^^^
-   |                    |
-   |                    help: use an inclusive range: `..=`
-...
-LL |     b!();
-   |     ---- in this macro invocation
-   |
-   = note: this error originates in the macro `b` (in Nightly builds, run with -Z macro-backtrace for more info)
-
-error: almost complete ascii letter range
-  --> $DIR/almost_complete_letter_range.rs:67:9
-   |
-LL |         'a'..'z' => 1,
-   |         ^^^--^^^
-   |            |
-   |            help: use an inclusive range: `...`
-
-error: almost complete ascii letter range
-  --> $DIR/almost_complete_letter_range.rs:74:13
-   |
-LL |     let _ = 'a'..'z';
-   |             ^^^--^^^
-   |                |
-   |                help: use an inclusive range: `..=`
-
-error: almost complete ascii letter range
-  --> $DIR/almost_complete_letter_range.rs:76:9
-   |
-LL |         'a'..'z' => 1,
-   |         ^^^--^^^
-   |            |
-   |            help: use an inclusive range: `..=`
-
-error: aborting due to 13 previous errors
-
diff --git a/tests/ui/almost_complete_range.fixed b/tests/ui/almost_complete_range.fixed
new file mode 100644
index 00000000000..6046addf719
--- /dev/null
+++ b/tests/ui/almost_complete_range.fixed
@@ -0,0 +1,108 @@
+// run-rustfix
+// edition:2018
+// aux-build:macro_rules.rs
+
+#![feature(exclusive_range_pattern)]
+#![feature(stmt_expr_attributes)]
+#![warn(clippy::almost_complete_range)]
+#![allow(ellipsis_inclusive_range_patterns)]
+#![allow(clippy::needless_parens_on_range_literals)]
+#![allow(clippy::double_parens)]
+
+#[macro_use]
+extern crate macro_rules;
+
+macro_rules! a {
+    () => {
+        'a'
+    };
+}
+macro_rules! A {
+    () => {
+        'A'
+    };
+}
+macro_rules! zero {
+    () => {
+        '0'
+    };
+}
+
+macro_rules! b {
+    () => {
+        let _ = 'a'..='z';
+        let _ = 'A'..='Z';
+        let _ = '0'..='9';
+    };
+}
+
+fn main() {
+    #[rustfmt::skip]
+    {
+        let _ = ('a') ..='z';
+        let _ = 'A' ..= ('Z');
+        let _ = ((('0'))) ..= ('9');
+    }
+
+    let _ = 'b'..'z';
+    let _ = 'B'..'Z';
+    let _ = '1'..'9';
+
+    let _ = (b'a')..=(b'z');
+    let _ = b'A'..=b'Z';
+    let _ = b'0'..=b'9';
+
+    let _ = b'b'..b'z';
+    let _ = b'B'..b'Z';
+    let _ = b'1'..b'9';
+
+    let _ = a!()..='z';
+    let _ = A!()..='Z';
+    let _ = zero!()..='9';
+
+    let _ = match 0u8 {
+        b'a'..=b'z' if true => 1,
+        b'A'..=b'Z' if true => 2,
+        b'0'..=b'9' if true => 3,
+        b'b'..b'z' => 4,
+        b'B'..b'Z' => 5,
+        b'1'..b'9' => 6,
+        _ => 7,
+    };
+
+    let _ = match 'x' {
+        'a'..='z' if true => 1,
+        'A'..='Z' if true => 2,
+        '0'..='9' if true => 3,
+        'b'..'z' => 4,
+        'B'..'Z' => 5,
+        '1'..'9' => 6,
+        _ => 7,
+    };
+
+    almost_complete_range!();
+    b!();
+}
+
+#[clippy::msrv = "1.25"]
+fn _under_msrv() {
+    let _ = match 'a' {
+        'a'...'z' => 1,
+        'A'...'Z' => 2,
+        '0'...'9' => 3,
+        _ => 4,
+    };
+}
+
+#[clippy::msrv = "1.26"]
+fn _meets_msrv() {
+    let _ = 'a'..='z';
+    let _ = 'A'..='Z';
+    let _ = '0'..='9';
+    let _ = match 'a' {
+        'a'..='z' => 1,
+        'A'..='Z' => 1,
+        '0'..='9' => 3,
+        _ => 4,
+    };
+}
diff --git a/tests/ui/almost_complete_range.rs b/tests/ui/almost_complete_range.rs
new file mode 100644
index 00000000000..ae7e07ab872
--- /dev/null
+++ b/tests/ui/almost_complete_range.rs
@@ -0,0 +1,108 @@
+// run-rustfix
+// edition:2018
+// aux-build:macro_rules.rs
+
+#![feature(exclusive_range_pattern)]
+#![feature(stmt_expr_attributes)]
+#![warn(clippy::almost_complete_range)]
+#![allow(ellipsis_inclusive_range_patterns)]
+#![allow(clippy::needless_parens_on_range_literals)]
+#![allow(clippy::double_parens)]
+
+#[macro_use]
+extern crate macro_rules;
+
+macro_rules! a {
+    () => {
+        'a'
+    };
+}
+macro_rules! A {
+    () => {
+        'A'
+    };
+}
+macro_rules! zero {
+    () => {
+        '0'
+    };
+}
+
+macro_rules! b {
+    () => {
+        let _ = 'a'..'z';
+        let _ = 'A'..'Z';
+        let _ = '0'..'9';
+    };
+}
+
+fn main() {
+    #[rustfmt::skip]
+    {
+        let _ = ('a') ..'z';
+        let _ = 'A' .. ('Z');
+        let _ = ((('0'))) .. ('9');
+    }
+
+    let _ = 'b'..'z';
+    let _ = 'B'..'Z';
+    let _ = '1'..'9';
+
+    let _ = (b'a')..(b'z');
+    let _ = b'A'..b'Z';
+    let _ = b'0'..b'9';
+
+    let _ = b'b'..b'z';
+    let _ = b'B'..b'Z';
+    let _ = b'1'..b'9';
+
+    let _ = a!()..'z';
+    let _ = A!()..'Z';
+    let _ = zero!()..'9';
+
+    let _ = match 0u8 {
+        b'a'..b'z' if true => 1,
+        b'A'..b'Z' if true => 2,
+        b'0'..b'9' if true => 3,
+        b'b'..b'z' => 4,
+        b'B'..b'Z' => 5,
+        b'1'..b'9' => 6,
+        _ => 7,
+    };
+
+    let _ = match 'x' {
+        'a'..'z' if true => 1,
+        'A'..'Z' if true => 2,
+        '0'..'9' if true => 3,
+        'b'..'z' => 4,
+        'B'..'Z' => 5,
+        '1'..'9' => 6,
+        _ => 7,
+    };
+
+    almost_complete_range!();
+    b!();
+}
+
+#[clippy::msrv = "1.25"]
+fn _under_msrv() {
+    let _ = match 'a' {
+        'a'..'z' => 1,
+        'A'..'Z' => 2,
+        '0'..'9' => 3,
+        _ => 4,
+    };
+}
+
+#[clippy::msrv = "1.26"]
+fn _meets_msrv() {
+    let _ = 'a'..'z';
+    let _ = 'A'..'Z';
+    let _ = '0'..'9';
+    let _ = match 'a' {
+        'a'..'z' => 1,
+        'A'..'Z' => 1,
+        '0'..'9' => 3,
+        _ => 4,
+    };
+}
diff --git a/tests/ui/almost_complete_range.stderr b/tests/ui/almost_complete_range.stderr
new file mode 100644
index 00000000000..a7a53287850
--- /dev/null
+++ b/tests/ui/almost_complete_range.stderr
@@ -0,0 +1,235 @@
+error: almost complete ascii range
+  --> $DIR/almost_complete_range.rs:42:17
+   |
+LL |         let _ = ('a') ..'z';
+   |                 ^^^^^^--^^^
+   |                       |
+   |                       help: use an inclusive range: `..=`
+   |
+   = note: `-D clippy::almost-complete-range` implied by `-D warnings`
+
+error: almost complete ascii range
+  --> $DIR/almost_complete_range.rs:43:17
+   |
+LL |         let _ = 'A' .. ('Z');
+   |                 ^^^^--^^^^^^
+   |                     |
+   |                     help: use an inclusive range: `..=`
+
+error: almost complete ascii range
+  --> $DIR/almost_complete_range.rs:44:17
+   |
+LL |         let _ = ((('0'))) .. ('9');
+   |                 ^^^^^^^^^^--^^^^^^
+   |                           |
+   |                           help: use an inclusive range: `..=`
+
+error: almost complete ascii range
+  --> $DIR/almost_complete_range.rs:51:13
+   |
+LL |     let _ = (b'a')..(b'z');
+   |             ^^^^^^--^^^^^^
+   |                   |
+   |                   help: use an inclusive range: `..=`
+
+error: almost complete ascii range
+  --> $DIR/almost_complete_range.rs:52:13
+   |
+LL |     let _ = b'A'..b'Z';
+   |             ^^^^--^^^^
+   |                 |
+   |                 help: use an inclusive range: `..=`
+
+error: almost complete ascii range
+  --> $DIR/almost_complete_range.rs:53:13
+   |
+LL |     let _ = b'0'..b'9';
+   |             ^^^^--^^^^
+   |                 |
+   |                 help: use an inclusive range: `..=`
+
+error: almost complete ascii range
+  --> $DIR/almost_complete_range.rs:59:13
+   |
+LL |     let _ = a!()..'z';
+   |             ^^^^--^^^
+   |                 |
+   |                 help: use an inclusive range: `..=`
+
+error: almost complete ascii range
+  --> $DIR/almost_complete_range.rs:60:13
+   |
+LL |     let _ = A!()..'Z';
+   |             ^^^^--^^^
+   |                 |
+   |                 help: use an inclusive range: `..=`
+
+error: almost complete ascii range
+  --> $DIR/almost_complete_range.rs:61:13
+   |
+LL |     let _ = zero!()..'9';
+   |             ^^^^^^^--^^^
+   |                    |
+   |                    help: use an inclusive range: `..=`
+
+error: almost complete ascii range
+  --> $DIR/almost_complete_range.rs:64:9
+   |
+LL |         b'a'..b'z' if true => 1,
+   |         ^^^^--^^^^
+   |             |
+   |             help: use an inclusive range: `..=`
+
+error: almost complete ascii range
+  --> $DIR/almost_complete_range.rs:65:9
+   |
+LL |         b'A'..b'Z' if true => 2,
+   |         ^^^^--^^^^
+   |             |
+   |             help: use an inclusive range: `..=`
+
+error: almost complete ascii range
+  --> $DIR/almost_complete_range.rs:66:9
+   |
+LL |         b'0'..b'9' if true => 3,
+   |         ^^^^--^^^^
+   |             |
+   |             help: use an inclusive range: `..=`
+
+error: almost complete ascii range
+  --> $DIR/almost_complete_range.rs:74:9
+   |
+LL |         'a'..'z' if true => 1,
+   |         ^^^--^^^
+   |            |
+   |            help: use an inclusive range: `..=`
+
+error: almost complete ascii range
+  --> $DIR/almost_complete_range.rs:75:9
+   |
+LL |         'A'..'Z' if true => 2,
+   |         ^^^--^^^
+   |            |
+   |            help: use an inclusive range: `..=`
+
+error: almost complete ascii range
+  --> $DIR/almost_complete_range.rs:76:9
+   |
+LL |         '0'..'9' if true => 3,
+   |         ^^^--^^^
+   |            |
+   |            help: use an inclusive range: `..=`
+
+error: almost complete ascii range
+  --> $DIR/almost_complete_range.rs:33:17
+   |
+LL |         let _ = 'a'..'z';
+   |                 ^^^--^^^
+   |                    |
+   |                    help: use an inclusive range: `..=`
+...
+LL |     b!();
+   |     ---- in this macro invocation
+   |
+   = note: this error originates in the macro `b` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: almost complete ascii range
+  --> $DIR/almost_complete_range.rs:34:17
+   |
+LL |         let _ = 'A'..'Z';
+   |                 ^^^--^^^
+   |                    |
+   |                    help: use an inclusive range: `..=`
+...
+LL |     b!();
+   |     ---- in this macro invocation
+   |
+   = note: this error originates in the macro `b` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: almost complete ascii range
+  --> $DIR/almost_complete_range.rs:35:17
+   |
+LL |         let _ = '0'..'9';
+   |                 ^^^--^^^
+   |                    |
+   |                    help: use an inclusive range: `..=`
+...
+LL |     b!();
+   |     ---- in this macro invocation
+   |
+   = note: this error originates in the macro `b` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: almost complete ascii range
+  --> $DIR/almost_complete_range.rs:90:9
+   |
+LL |         'a'..'z' => 1,
+   |         ^^^--^^^
+   |            |
+   |            help: use an inclusive range: `...`
+
+error: almost complete ascii range
+  --> $DIR/almost_complete_range.rs:91:9
+   |
+LL |         'A'..'Z' => 2,
+   |         ^^^--^^^
+   |            |
+   |            help: use an inclusive range: `...`
+
+error: almost complete ascii range
+  --> $DIR/almost_complete_range.rs:92:9
+   |
+LL |         '0'..'9' => 3,
+   |         ^^^--^^^
+   |            |
+   |            help: use an inclusive range: `...`
+
+error: almost complete ascii range
+  --> $DIR/almost_complete_range.rs:99:13
+   |
+LL |     let _ = 'a'..'z';
+   |             ^^^--^^^
+   |                |
+   |                help: use an inclusive range: `..=`
+
+error: almost complete ascii range
+  --> $DIR/almost_complete_range.rs:100:13
+   |
+LL |     let _ = 'A'..'Z';
+   |             ^^^--^^^
+   |                |
+   |                help: use an inclusive range: `..=`
+
+error: almost complete ascii range
+  --> $DIR/almost_complete_range.rs:101:13
+   |
+LL |     let _ = '0'..'9';
+   |             ^^^--^^^
+   |                |
+   |                help: use an inclusive range: `..=`
+
+error: almost complete ascii range
+  --> $DIR/almost_complete_range.rs:103:9
+   |
+LL |         'a'..'z' => 1,
+   |         ^^^--^^^
+   |            |
+   |            help: use an inclusive range: `..=`
+
+error: almost complete ascii range
+  --> $DIR/almost_complete_range.rs:104:9
+   |
+LL |         'A'..'Z' => 1,
+   |         ^^^--^^^
+   |            |
+   |            help: use an inclusive range: `..=`
+
+error: almost complete ascii range
+  --> $DIR/almost_complete_range.rs:105:9
+   |
+LL |         '0'..'9' => 3,
+   |         ^^^--^^^
+   |            |
+   |            help: use an inclusive range: `..=`
+
+error: aborting due to 27 previous errors
+
diff --git a/tests/ui/auxiliary/macro_rules.rs b/tests/ui/auxiliary/macro_rules.rs
index ef3ca9aea38..1e5f20e8c39 100644
--- a/tests/ui/auxiliary/macro_rules.rs
+++ b/tests/ui/auxiliary/macro_rules.rs
@@ -142,8 +142,10 @@ macro_rules! equatable_if_let {
 }
 
 #[macro_export]
-macro_rules! almost_complete_letter_range {
+macro_rules! almost_complete_range {
     () => {
         let _ = 'a'..'z';
+        let _ = 'A'..'Z';
+        let _ = '0'..'9';
     };
 }
diff --git a/tests/ui/needless_parens_on_range_literals.fixed b/tests/ui/needless_parens_on_range_literals.fixed
index 1bd75c806bc..f11330a8916 100644
--- a/tests/ui/needless_parens_on_range_literals.fixed
+++ b/tests/ui/needless_parens_on_range_literals.fixed
@@ -2,7 +2,7 @@
 // edition:2018
 
 #![warn(clippy::needless_parens_on_range_literals)]
-#![allow(clippy::almost_complete_letter_range)]
+#![allow(clippy::almost_complete_range)]
 
 fn main() {
     let _ = 'a'..='z';
diff --git a/tests/ui/needless_parens_on_range_literals.rs b/tests/ui/needless_parens_on_range_literals.rs
index 7abb8a1adc1..671c0009e23 100644
--- a/tests/ui/needless_parens_on_range_literals.rs
+++ b/tests/ui/needless_parens_on_range_literals.rs
@@ -2,7 +2,7 @@
 // edition:2018
 
 #![warn(clippy::needless_parens_on_range_literals)]
-#![allow(clippy::almost_complete_letter_range)]
+#![allow(clippy::almost_complete_range)]
 
 fn main() {
     let _ = ('a')..=('z');
diff --git a/tests/ui/rename.fixed b/tests/ui/rename.fixed
index 689928f0479..2f76b575296 100644
--- a/tests/ui/rename.fixed
+++ b/tests/ui/rename.fixed
@@ -4,6 +4,7 @@
 
 // run-rustfix
 
+#![allow(clippy::almost_complete_range)]
 #![allow(clippy::disallowed_names)]
 #![allow(clippy::blocks_in_if_conditions)]
 #![allow(clippy::box_collection)]
@@ -37,6 +38,7 @@
 #![allow(temporary_cstring_as_ptr)]
 #![allow(unknown_lints)]
 #![allow(unused_labels)]
+#![warn(clippy::almost_complete_range)]
 #![warn(clippy::disallowed_names)]
 #![warn(clippy::blocks_in_if_conditions)]
 #![warn(clippy::blocks_in_if_conditions)]
diff --git a/tests/ui/rename.rs b/tests/ui/rename.rs
index b74aa650ffd..699c0ff464e 100644
--- a/tests/ui/rename.rs
+++ b/tests/ui/rename.rs
@@ -4,6 +4,7 @@
 
 // run-rustfix
 
+#![allow(clippy::almost_complete_range)]
 #![allow(clippy::disallowed_names)]
 #![allow(clippy::blocks_in_if_conditions)]
 #![allow(clippy::box_collection)]
@@ -37,6 +38,7 @@
 #![allow(temporary_cstring_as_ptr)]
 #![allow(unknown_lints)]
 #![allow(unused_labels)]
+#![warn(clippy::almost_complete_letter_range)]
 #![warn(clippy::blacklisted_name)]
 #![warn(clippy::block_in_if_condition_expr)]
 #![warn(clippy::block_in_if_condition_stmt)]
diff --git a/tests/ui/rename.stderr b/tests/ui/rename.stderr
index 622a32c5908..9af58dc75a6 100644
--- a/tests/ui/rename.stderr
+++ b/tests/ui/rename.stderr
@@ -1,244 +1,250 @@
+error: lint `clippy::almost_complete_letter_range` has been renamed to `clippy::almost_complete_range`
+  --> $DIR/rename.rs:41:9
+   |
+LL | #![warn(clippy::almost_complete_letter_range)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::almost_complete_range`
+   |
+   = note: `-D renamed-and-removed-lints` implied by `-D warnings`
+
 error: lint `clippy::blacklisted_name` has been renamed to `clippy::disallowed_names`
-  --> $DIR/rename.rs:40:9
+  --> $DIR/rename.rs:42:9
    |
 LL | #![warn(clippy::blacklisted_name)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::disallowed_names`
-   |
-   = note: `-D renamed-and-removed-lints` implied by `-D warnings`
 
 error: lint `clippy::block_in_if_condition_expr` has been renamed to `clippy::blocks_in_if_conditions`
-  --> $DIR/rename.rs:41:9
+  --> $DIR/rename.rs:43:9
    |
 LL | #![warn(clippy::block_in_if_condition_expr)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::blocks_in_if_conditions`
 
 error: lint `clippy::block_in_if_condition_stmt` has been renamed to `clippy::blocks_in_if_conditions`
-  --> $DIR/rename.rs:42:9
+  --> $DIR/rename.rs:44:9
    |
 LL | #![warn(clippy::block_in_if_condition_stmt)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::blocks_in_if_conditions`
 
 error: lint `clippy::box_vec` has been renamed to `clippy::box_collection`
-  --> $DIR/rename.rs:43:9
+  --> $DIR/rename.rs:45:9
    |
 LL | #![warn(clippy::box_vec)]
    |         ^^^^^^^^^^^^^^^ help: use the new name: `clippy::box_collection`
 
 error: lint `clippy::const_static_lifetime` has been renamed to `clippy::redundant_static_lifetimes`
-  --> $DIR/rename.rs:44:9
+  --> $DIR/rename.rs:46:9
    |
 LL | #![warn(clippy::const_static_lifetime)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::redundant_static_lifetimes`
 
 error: lint `clippy::cyclomatic_complexity` has been renamed to `clippy::cognitive_complexity`
-  --> $DIR/rename.rs:45:9
+  --> $DIR/rename.rs:47:9
    |
 LL | #![warn(clippy::cyclomatic_complexity)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::cognitive_complexity`
 
 error: lint `clippy::disallowed_method` has been renamed to `clippy::disallowed_methods`
-  --> $DIR/rename.rs:46:9
+  --> $DIR/rename.rs:48:9
    |
 LL | #![warn(clippy::disallowed_method)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::disallowed_methods`
 
 error: lint `clippy::disallowed_type` has been renamed to `clippy::disallowed_types`
-  --> $DIR/rename.rs:47:9
+  --> $DIR/rename.rs:49:9
    |
 LL | #![warn(clippy::disallowed_type)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::disallowed_types`
 
 error: lint `clippy::eval_order_dependence` has been renamed to `clippy::mixed_read_write_in_expression`
-  --> $DIR/rename.rs:48:9
+  --> $DIR/rename.rs:50:9
    |
 LL | #![warn(clippy::eval_order_dependence)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::mixed_read_write_in_expression`
 
 error: lint `clippy::identity_conversion` has been renamed to `clippy::useless_conversion`
-  --> $DIR/rename.rs:49:9
+  --> $DIR/rename.rs:51:9
    |
 LL | #![warn(clippy::identity_conversion)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::useless_conversion`
 
 error: lint `clippy::if_let_some_result` has been renamed to `clippy::match_result_ok`
-  --> $DIR/rename.rs:50:9
+  --> $DIR/rename.rs:52:9
    |
 LL | #![warn(clippy::if_let_some_result)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::match_result_ok`
 
 error: lint `clippy::logic_bug` has been renamed to `clippy::overly_complex_bool_expr`
-  --> $DIR/rename.rs:51:9
+  --> $DIR/rename.rs:53:9
    |
 LL | #![warn(clippy::logic_bug)]
    |         ^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::overly_complex_bool_expr`
 
 error: lint `clippy::new_without_default_derive` has been renamed to `clippy::new_without_default`
-  --> $DIR/rename.rs:52:9
+  --> $DIR/rename.rs:54:9
    |
 LL | #![warn(clippy::new_without_default_derive)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::new_without_default`
 
 error: lint `clippy::option_and_then_some` has been renamed to `clippy::bind_instead_of_map`
-  --> $DIR/rename.rs:53:9
+  --> $DIR/rename.rs:55:9
    |
 LL | #![warn(clippy::option_and_then_some)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::bind_instead_of_map`
 
 error: lint `clippy::option_expect_used` has been renamed to `clippy::expect_used`
-  --> $DIR/rename.rs:54:9
+  --> $DIR/rename.rs:56:9
    |
 LL | #![warn(clippy::option_expect_used)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::expect_used`
 
 error: lint `clippy::option_map_unwrap_or` has been renamed to `clippy::map_unwrap_or`
-  --> $DIR/rename.rs:55:9
+  --> $DIR/rename.rs:57:9
    |
 LL | #![warn(clippy::option_map_unwrap_or)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::map_unwrap_or`
 
 error: lint `clippy::option_map_unwrap_or_else` has been renamed to `clippy::map_unwrap_or`
-  --> $DIR/rename.rs:56:9
+  --> $DIR/rename.rs:58:9
    |
 LL | #![warn(clippy::option_map_unwrap_or_else)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::map_unwrap_or`
 
 error: lint `clippy::option_unwrap_used` has been renamed to `clippy::unwrap_used`
-  --> $DIR/rename.rs:57:9
+  --> $DIR/rename.rs:59:9
    |
 LL | #![warn(clippy::option_unwrap_used)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::unwrap_used`
 
 error: lint `clippy::ref_in_deref` has been renamed to `clippy::needless_borrow`
-  --> $DIR/rename.rs:58:9
+  --> $DIR/rename.rs:60:9
    |
 LL | #![warn(clippy::ref_in_deref)]
    |         ^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::needless_borrow`
 
 error: lint `clippy::result_expect_used` has been renamed to `clippy::expect_used`
-  --> $DIR/rename.rs:59:9
+  --> $DIR/rename.rs:61:9
    |
 LL | #![warn(clippy::result_expect_used)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::expect_used`
 
 error: lint `clippy::result_map_unwrap_or_else` has been renamed to `clippy::map_unwrap_or`
-  --> $DIR/rename.rs:60:9
+  --> $DIR/rename.rs:62:9
    |
 LL | #![warn(clippy::result_map_unwrap_or_else)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::map_unwrap_or`
 
 error: lint `clippy::result_unwrap_used` has been renamed to `clippy::unwrap_used`
-  --> $DIR/rename.rs:61:9
+  --> $DIR/rename.rs:63:9
    |
 LL | #![warn(clippy::result_unwrap_used)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::unwrap_used`
 
 error: lint `clippy::single_char_push_str` has been renamed to `clippy::single_char_add_str`
-  --> $DIR/rename.rs:62:9
+  --> $DIR/rename.rs:64:9
    |
 LL | #![warn(clippy::single_char_push_str)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::single_char_add_str`
 
 error: lint `clippy::stutter` has been renamed to `clippy::module_name_repetitions`
-  --> $DIR/rename.rs:63:9
+  --> $DIR/rename.rs:65:9
    |
 LL | #![warn(clippy::stutter)]
    |         ^^^^^^^^^^^^^^^ help: use the new name: `clippy::module_name_repetitions`
 
 error: lint `clippy::to_string_in_display` has been renamed to `clippy::recursive_format_impl`
-  --> $DIR/rename.rs:64:9
+  --> $DIR/rename.rs:66:9
    |
 LL | #![warn(clippy::to_string_in_display)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::recursive_format_impl`
 
 error: lint `clippy::zero_width_space` has been renamed to `clippy::invisible_characters`
-  --> $DIR/rename.rs:65:9
+  --> $DIR/rename.rs:67:9
    |
 LL | #![warn(clippy::zero_width_space)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::invisible_characters`
 
 error: lint `clippy::drop_bounds` has been renamed to `drop_bounds`
-  --> $DIR/rename.rs:66:9
+  --> $DIR/rename.rs:68:9
    |
 LL | #![warn(clippy::drop_bounds)]
    |         ^^^^^^^^^^^^^^^^^^^ help: use the new name: `drop_bounds`
 
 error: lint `clippy::for_loop_over_option` has been renamed to `for_loops_over_fallibles`
-  --> $DIR/rename.rs:67:9
+  --> $DIR/rename.rs:69:9
    |
 LL | #![warn(clippy::for_loop_over_option)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `for_loops_over_fallibles`
 
 error: lint `clippy::for_loop_over_result` has been renamed to `for_loops_over_fallibles`
-  --> $DIR/rename.rs:68:9
+  --> $DIR/rename.rs:70:9
    |
 LL | #![warn(clippy::for_loop_over_result)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `for_loops_over_fallibles`
 
 error: lint `clippy::for_loops_over_fallibles` has been renamed to `for_loops_over_fallibles`
-  --> $DIR/rename.rs:69:9
+  --> $DIR/rename.rs:71:9
    |
 LL | #![warn(clippy::for_loops_over_fallibles)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `for_loops_over_fallibles`
 
 error: lint `clippy::into_iter_on_array` has been renamed to `array_into_iter`
-  --> $DIR/rename.rs:70:9
+  --> $DIR/rename.rs:72:9
    |
 LL | #![warn(clippy::into_iter_on_array)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `array_into_iter`
 
 error: lint `clippy::invalid_atomic_ordering` has been renamed to `invalid_atomic_ordering`
-  --> $DIR/rename.rs:71:9
+  --> $DIR/rename.rs:73:9
    |
 LL | #![warn(clippy::invalid_atomic_ordering)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `invalid_atomic_ordering`
 
 error: lint `clippy::invalid_ref` has been renamed to `invalid_value`
-  --> $DIR/rename.rs:72:9
+  --> $DIR/rename.rs:74:9
    |
 LL | #![warn(clippy::invalid_ref)]
    |         ^^^^^^^^^^^^^^^^^^^ help: use the new name: `invalid_value`
 
 error: lint `clippy::let_underscore_drop` has been renamed to `let_underscore_drop`
-  --> $DIR/rename.rs:73:9
+  --> $DIR/rename.rs:75:9
    |
 LL | #![warn(clippy::let_underscore_drop)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `let_underscore_drop`
 
 error: lint `clippy::mem_discriminant_non_enum` has been renamed to `enum_intrinsics_non_enums`
-  --> $DIR/rename.rs:74:9
+  --> $DIR/rename.rs:76:9
    |
 LL | #![warn(clippy::mem_discriminant_non_enum)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `enum_intrinsics_non_enums`
 
 error: lint `clippy::panic_params` has been renamed to `non_fmt_panics`
-  --> $DIR/rename.rs:75:9
+  --> $DIR/rename.rs:77:9
    |
 LL | #![warn(clippy::panic_params)]
    |         ^^^^^^^^^^^^^^^^^^^^ help: use the new name: `non_fmt_panics`
 
 error: lint `clippy::positional_named_format_parameters` has been renamed to `named_arguments_used_positionally`
-  --> $DIR/rename.rs:76:9
+  --> $DIR/rename.rs:78:9
    |
 LL | #![warn(clippy::positional_named_format_parameters)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `named_arguments_used_positionally`
 
 error: lint `clippy::temporary_cstring_as_ptr` has been renamed to `temporary_cstring_as_ptr`
-  --> $DIR/rename.rs:77:9
+  --> $DIR/rename.rs:79:9
    |
 LL | #![warn(clippy::temporary_cstring_as_ptr)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `temporary_cstring_as_ptr`
 
 error: lint `clippy::unknown_clippy_lints` has been renamed to `unknown_lints`
-  --> $DIR/rename.rs:78:9
+  --> $DIR/rename.rs:80:9
    |
 LL | #![warn(clippy::unknown_clippy_lints)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `unknown_lints`
 
 error: lint `clippy::unused_label` has been renamed to `unused_labels`
-  --> $DIR/rename.rs:79:9
+  --> $DIR/rename.rs:81:9
    |
 LL | #![warn(clippy::unused_label)]
    |         ^^^^^^^^^^^^^^^^^^^^ help: use the new name: `unused_labels`
 
-error: aborting due to 40 previous errors
+error: aborting due to 41 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From e5010c996e9cb9fa09fefb4e3d31608915869c78 Mon Sep 17 00:00:00 2001
From: Taiki Endo <te316e89@gmail.com>
Date: Sat, 10 Dec 2022 18:35:24 +0900
Subject: uninlined_format_args: Ignore assert! and debug_assert! before 2021
 edition

---
 clippy_lints/src/format_args.rs                    |  8 ++++---
 clippy_utils/src/macros.rs                         |  6 +++++
 .../uninlined_format_args_panic.edition2018.fixed  |  3 +++
 .../uninlined_format_args_panic.edition2021.fixed  |  3 +++
 .../uninlined_format_args_panic.edition2021.stderr | 26 +++++++++++++++++++++-
 tests/ui/uninlined_format_args_panic.rs            |  3 +++
 6 files changed, 45 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/format_args.rs b/clippy_lints/src/format_args.rs
index f0995a81329..aa182a3230b 100644
--- a/clippy_lints/src/format_args.rs
+++ b/clippy_lints/src/format_args.rs
@@ -2,7 +2,8 @@ use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::is_diag_trait_item;
 use clippy_utils::macros::FormatParamKind::{Implicit, Named, NamedInline, Numbered, Starred};
 use clippy_utils::macros::{
-    is_format_macro, is_panic, root_macro_call, Count, FormatArg, FormatArgsExpn, FormatParam, FormatParamUsage,
+    is_assert_macro, is_format_macro, is_panic, root_macro_call, Count, FormatArg, FormatArgsExpn, FormatParam,
+    FormatParamUsage,
 };
 use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::snippet_opt;
@@ -290,8 +291,9 @@ fn check_uninlined_args(
     if args.format_string.span.from_expansion() {
         return;
     }
-    if call_site.edition() < Edition2021 && is_panic(cx, def_id) {
-        // panic! before 2021 edition considers a single string argument as non-format
+    if call_site.edition() < Edition2021 && (is_panic(cx, def_id) || is_assert_macro(cx, def_id)) {
+        // panic!, assert!, and debug_assert! before 2021 edition considers a single string argument as
+        // non-format
         return;
     }
 
diff --git a/clippy_utils/src/macros.rs b/clippy_utils/src/macros.rs
index d13b34a66cc..77c5f115542 100644
--- a/clippy_utils/src/macros.rs
+++ b/clippy_utils/src/macros.rs
@@ -208,6 +208,12 @@ pub fn is_panic(cx: &LateContext<'_>, def_id: DefId) -> bool {
     )
 }
 
+/// Is `def_id` of `assert!` or `debug_assert!`
+pub fn is_assert_macro(cx: &LateContext<'_>, def_id: DefId) -> bool {
+    let Some(name) = cx.tcx.get_diagnostic_name(def_id) else { return false };
+    matches!(name, sym::assert_macro | sym::debug_assert_macro)
+}
+
 pub enum PanicExpn<'a> {
     /// No arguments - `panic!()`
     Empty,
diff --git a/tests/ui/uninlined_format_args_panic.edition2018.fixed b/tests/ui/uninlined_format_args_panic.edition2018.fixed
index 96cc0877960..52b5343c351 100644
--- a/tests/ui/uninlined_format_args_panic.edition2018.fixed
+++ b/tests/ui/uninlined_format_args_panic.edition2018.fixed
@@ -26,4 +26,7 @@ fn main() {
             panic!("p4 {var}");
         }
     }
+
+    assert!(var == 1, "p5 {}", var);
+    debug_assert!(var == 1, "p6 {}", var);
 }
diff --git a/tests/ui/uninlined_format_args_panic.edition2021.fixed b/tests/ui/uninlined_format_args_panic.edition2021.fixed
index faf8ca4d3a7..ee72065e28a 100644
--- a/tests/ui/uninlined_format_args_panic.edition2021.fixed
+++ b/tests/ui/uninlined_format_args_panic.edition2021.fixed
@@ -26,4 +26,7 @@ fn main() {
             panic!("p4 {var}");
         }
     }
+
+    assert!(var == 1, "p5 {var}");
+    debug_assert!(var == 1, "p6 {var}");
 }
diff --git a/tests/ui/uninlined_format_args_panic.edition2021.stderr b/tests/ui/uninlined_format_args_panic.edition2021.stderr
index 0f09c45f413..fc7b125080e 100644
--- a/tests/ui/uninlined_format_args_panic.edition2021.stderr
+++ b/tests/ui/uninlined_format_args_panic.edition2021.stderr
@@ -47,5 +47,29 @@ LL -         panic!("p3 {var}", var = var);
 LL +         panic!("p3 {var}");
    |
 
-error: aborting due to 4 previous errors
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args_panic.rs:30:5
+   |
+LL |     assert!(var == 1, "p5 {}", var);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     assert!(var == 1, "p5 {}", var);
+LL +     assert!(var == 1, "p5 {var}");
+   |
+
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args_panic.rs:31:5
+   |
+LL |     debug_assert!(var == 1, "p6 {}", var);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: change this to
+   |
+LL -     debug_assert!(var == 1, "p6 {}", var);
+LL +     debug_assert!(var == 1, "p6 {var}");
+   |
+
+error: aborting due to 6 previous errors
 
diff --git a/tests/ui/uninlined_format_args_panic.rs b/tests/ui/uninlined_format_args_panic.rs
index 6421c5bbed2..b4a0a0f496e 100644
--- a/tests/ui/uninlined_format_args_panic.rs
+++ b/tests/ui/uninlined_format_args_panic.rs
@@ -26,4 +26,7 @@ fn main() {
             panic!("p4 {var}");
         }
     }
+
+    assert!(var == 1, "p5 {}", var);
+    debug_assert!(var == 1, "p6 {}", var);
 }
-- 
cgit 1.4.1-3-g733a5


From 055f349670155d88ae3a2f0a40baa47f524efa88 Mon Sep 17 00:00:00 2001
From: koka <koka.code@gmail.com>
Date: Sat, 10 Dec 2022 21:05:08 +0900
Subject: Avoid `match_wildcard_for_single_variants` on guarded wild matches

fix #9993
changlog: [`match_wildcard_for_single_variants`] avoid suggestion on wildcard with guard
---
 clippy_lints/src/matches/match_wild_enum.rs       |  2 +-
 clippy_utils/src/sugg.rs                          |  1 -
 tests/ui/match_wildcard_for_single_variants.fixed | 16 ++++++++++++++++
 tests/ui/match_wildcard_for_single_variants.rs    | 16 ++++++++++++++++
 4 files changed, 33 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/match_wild_enum.rs b/clippy_lints/src/matches/match_wild_enum.rs
index 7f8d124838c..59de8c0384b 100644
--- a/clippy_lints/src/matches/match_wild_enum.rs
+++ b/clippy_lints/src/matches/match_wild_enum.rs
@@ -30,7 +30,7 @@ pub(crate) fn check(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>]) {
     let mut has_non_wild = false;
     for arm in arms {
         match peel_hir_pat_refs(arm.pat).0.kind {
-            PatKind::Wild => wildcard_span = Some(arm.pat.span),
+            PatKind::Wild if arm.guard.is_none() => wildcard_span = Some(arm.pat.span),
             PatKind::Binding(_, _, ident, None) => {
                 wildcard_span = Some(arm.pat.span);
                 wildcard_ident = Some(ident);
diff --git a/clippy_utils/src/sugg.rs b/clippy_utils/src/sugg.rs
index b66604f33db..4c4c077d771 100644
--- a/clippy_utils/src/sugg.rs
+++ b/clippy_utils/src/sugg.rs
@@ -185,7 +185,6 @@ impl<'a> Sugg<'a> {
     ) -> Self {
         use rustc_ast::ast::RangeLimits;
 
-        #[expect(clippy::match_wildcard_for_single_variants)]
         match expr.kind {
             _ if expr.span.ctxt() != ctxt => Sugg::NonParen(snippet_with_context(cx, expr.span, ctxt, default, app).0),
             ast::ExprKind::AddrOf(..)
diff --git a/tests/ui/match_wildcard_for_single_variants.fixed b/tests/ui/match_wildcard_for_single_variants.fixed
index e675c183ea7..c508b7cc3b2 100644
--- a/tests/ui/match_wildcard_for_single_variants.fixed
+++ b/tests/ui/match_wildcard_for_single_variants.fixed
@@ -132,3 +132,19 @@ fn main() {
         }
     }
 }
+
+mod issue9993 {
+    enum Foo {
+        A(bool),
+        B,
+    }
+
+    fn test() {
+        let _ = match Foo::A(true) {
+            _ if false => 0,
+            Foo::A(true) => 1,
+            Foo::A(false) => 2,
+            Foo::B => 3,
+        };
+    }
+}
diff --git a/tests/ui/match_wildcard_for_single_variants.rs b/tests/ui/match_wildcard_for_single_variants.rs
index 38c3ffc00c7..ad03f797129 100644
--- a/tests/ui/match_wildcard_for_single_variants.rs
+++ b/tests/ui/match_wildcard_for_single_variants.rs
@@ -132,3 +132,19 @@ fn main() {
         }
     }
 }
+
+mod issue9993 {
+    enum Foo {
+        A(bool),
+        B,
+    }
+
+    fn test() {
+        let _ = match Foo::A(true) {
+            _ if false => 0,
+            Foo::A(true) => 1,
+            Foo::A(false) => 2,
+            Foo::B => 3,
+        };
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 3b6bbf7d16dd8b42fadf8dcdbad4d4d872a3e88c Mon Sep 17 00:00:00 2001
From: alex-semenyuk <alexsemenyuk88@gmail.com>
Date: Mon, 7 Nov 2022 10:51:52 +0300
Subject: Fix match_single_binding suggestion introduced an extra semicolon

---
 clippy_lints/src/matches/match_single_binding.rs | 18 +++++-----------
 tests/ui/match_single_binding.fixed              | 13 ++++++++++++
 tests/ui/match_single_binding.rs                 | 14 ++++++++++++
 tests/ui/match_single_binding.stderr             | 27 +++++++++++++++++++++++-
 4 files changed, 58 insertions(+), 14 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/match_single_binding.rs b/clippy_lints/src/matches/match_single_binding.rs
index 1bf8d4e96ad..c94a1f76330 100644
--- a/clippy_lints/src/matches/match_single_binding.rs
+++ b/clippy_lints/src/matches/match_single_binding.rs
@@ -31,19 +31,11 @@ pub(crate) fn check<'a>(cx: &LateContext<'a>, ex: &Expr<'a>, arms: &[Arm<'_>], e
     };
 
     // Do we need to add ';' to suggestion ?
-    match match_body.kind {
-        ExprKind::Block(block, _) => {
-            // macro + expr_ty(body) == ()
-            if block.span.from_expansion() && cx.typeck_results().expr_ty(match_body).is_unit() {
-                snippet_body.push(';');
-            }
-        },
-        _ => {
-            // expr_ty(body) == ()
-            if cx.typeck_results().expr_ty(match_body).is_unit() {
-                snippet_body.push(';');
-            }
-        },
+    if let ExprKind::Block(block, _) = match_body.kind {
+        // macro + expr_ty(body) == ()
+        if block.span.from_expansion() && cx.typeck_results().expr_ty(match_body).is_unit() {
+            snippet_body.push(';');
+        }
     }
 
     let mut applicability = Applicability::MaybeIncorrect;
diff --git a/tests/ui/match_single_binding.fixed b/tests/ui/match_single_binding.fixed
index a6e315e4773..6cfb6661a03 100644
--- a/tests/ui/match_single_binding.fixed
+++ b/tests/ui/match_single_binding.fixed
@@ -133,3 +133,16 @@ fn issue_9575() {
         println!("Needs curlies");
     };
 }
+
+#[allow(dead_code)]
+fn issue_9725(r: Option<u32>) {
+    let x = r;
+    match x {
+        Some(_) => {
+            println!("Some");
+        },
+        None => {
+            println!("None");
+        },
+    };
+}
diff --git a/tests/ui/match_single_binding.rs b/tests/ui/match_single_binding.rs
index cecbd703e56..f188aeb5f2f 100644
--- a/tests/ui/match_single_binding.rs
+++ b/tests/ui/match_single_binding.rs
@@ -148,3 +148,17 @@ fn issue_9575() {
         _ => println!("Needs curlies"),
     };
 }
+
+#[allow(dead_code)]
+fn issue_9725(r: Option<u32>) {
+    match r {
+        x => match x {
+            Some(_) => {
+                println!("Some");
+            },
+            None => {
+                println!("None");
+            },
+        },
+    };
+}
diff --git a/tests/ui/match_single_binding.stderr b/tests/ui/match_single_binding.stderr
index 2b9ec7ee702..e960d64ad2b 100644
--- a/tests/ui/match_single_binding.stderr
+++ b/tests/ui/match_single_binding.stderr
@@ -213,5 +213,30 @@ LL +         println!("Needs curlies");
 LL ~     };
    |
 
-error: aborting due to 14 previous errors
+error: this match could be written as a `let` statement
+  --> $DIR/match_single_binding.rs:154:5
+   |
+LL | /     match r {
+LL | |         x => match x {
+LL | |             Some(_) => {
+LL | |                 println!("Some");
+...  |
+LL | |         },
+LL | |     };
+   | |_____^
+   |
+help: consider using a `let` statement
+   |
+LL ~     let x = r;
+LL +     match x {
+LL +         Some(_) => {
+LL +             println!("Some");
+LL +         },
+LL +         None => {
+LL +             println!("None");
+LL +         },
+LL ~     };
+   |
+
+error: aborting due to 15 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 25c9718c04e43b5aa18b6345e0c384f9d1236e2c Mon Sep 17 00:00:00 2001
From: naosense <pingao777@gmail.com>
Date: Fri, 9 Dec 2022 11:40:50 +0800
Subject: check ranges with .contains calls

---
 clippy_lints/src/manual_is_ascii_check.rs | 75 +++++++++++++++++--------------
 tests/ui/manual_is_ascii_check.fixed      |  1 +
 tests/ui/manual_is_ascii_check.rs         |  1 +
 tests/ui/manual_is_ascii_check.stderr     | 16 ++++---
 4 files changed, 54 insertions(+), 39 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_is_ascii_check.rs b/clippy_lints/src/manual_is_ascii_check.rs
index 5ab049d8d13..39e7145b479 100644
--- a/clippy_lints/src/manual_is_ascii_check.rs
+++ b/clippy_lints/src/manual_is_ascii_check.rs
@@ -1,11 +1,11 @@
 use clippy_utils::msrvs::{self, Msrv};
-use clippy_utils::{diagnostics::span_lint_and_sugg, in_constant, macros::root_macro_call, source::snippet};
+use clippy_utils::{diagnostics::span_lint_and_sugg, higher, in_constant, macros::root_macro_call, source::snippet};
 use rustc_ast::LitKind::{Byte, Char};
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, PatKind, RangeEnd};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::{def_id::DefId, sym};
+use rustc_span::{def_id::DefId, sym, Span};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -75,47 +75,54 @@ impl<'tcx> LateLintPass<'tcx> for ManualIsAsciiCheck {
             return;
         }
 
-        let Some(macro_call) = root_macro_call(expr.span) else { return };
-
-        if is_matches_macro(cx, macro_call.def_id) {
+        if let Some(macro_call) = root_macro_call(expr.span)
+            && is_matches_macro(cx, macro_call.def_id) {
             if let ExprKind::Match(recv, [arm, ..], _) = expr.kind {
                 let range = check_pat(&arm.pat.kind);
-
-                if let Some(sugg) = match range {
-                    CharRange::UpperChar => Some("is_ascii_uppercase"),
-                    CharRange::LowerChar => Some("is_ascii_lowercase"),
-                    CharRange::FullChar => Some("is_ascii_alphabetic"),
-                    CharRange::Digit => Some("is_ascii_digit"),
-                    CharRange::Otherwise => None,
-                } {
-                    let default_snip = "..";
-                    // `snippet_with_applicability` may set applicability to `MaybeIncorrect` for
-                    // macro span, so we check applicability manually by comparing `recv` is not default.
-                    let recv = snippet(cx, recv.span, default_snip);
-
-                    let applicability = if recv == default_snip {
-                        Applicability::HasPlaceholders
-                    } else {
-                        Applicability::MachineApplicable
-                    };
-
-                    span_lint_and_sugg(
-                        cx,
-                        MANUAL_IS_ASCII_CHECK,
-                        macro_call.span,
-                        "manual check for common ascii range",
-                        "try",
-                        format!("{recv}.{sugg}()"),
-                        applicability,
-                    );
-                }
+                check_is_ascii(cx, macro_call.span, recv, &range);
             }
+        } else if let ExprKind::MethodCall(path, receiver, [arg], ..) = expr.kind
+            && path.ident.name == sym!(contains)
+            && let Some(higher::Range { start: Some(start), end: Some(end), .. }) = higher::Range::hir(receiver) {
+                let range = check_range(start, end);
+                check_is_ascii(cx, expr.span, arg, &range);
         }
     }
 
     extract_msrv_attr!(LateContext);
 }
 
+fn check_is_ascii(cx: &LateContext<'_>, span: Span, recv: &Expr<'_>, range: &CharRange) {
+    if let Some(sugg) = match range {
+        CharRange::UpperChar => Some("is_ascii_uppercase"),
+        CharRange::LowerChar => Some("is_ascii_lowercase"),
+        CharRange::FullChar => Some("is_ascii_alphabetic"),
+        CharRange::Digit => Some("is_ascii_digit"),
+        CharRange::Otherwise => None,
+    } {
+        let default_snip = "..";
+        // `snippet_with_applicability` may set applicability to `MaybeIncorrect` for
+        // macro span, so we check applicability manually by comparing `recv` is not default.
+        let recv = snippet(cx, recv.span, default_snip);
+
+        let applicability = if recv == default_snip {
+            Applicability::HasPlaceholders
+        } else {
+            Applicability::MachineApplicable
+        };
+
+        span_lint_and_sugg(
+            cx,
+            MANUAL_IS_ASCII_CHECK,
+            span,
+            "manual check for common ascii range",
+            "try",
+            format!("{recv}.{sugg}()"),
+            applicability,
+        );
+    }
+}
+
 fn check_pat(pat_kind: &PatKind<'_>) -> CharRange {
     match pat_kind {
         PatKind::Or(pats) => {
diff --git a/tests/ui/manual_is_ascii_check.fixed b/tests/ui/manual_is_ascii_check.fixed
index 231ba83b142..bfba6dd7cd8 100644
--- a/tests/ui/manual_is_ascii_check.fixed
+++ b/tests/ui/manual_is_ascii_check.fixed
@@ -15,6 +15,7 @@ fn main() {
     assert!('x'.is_ascii_alphabetic());
 
     assert!(matches!('x', 'A'..='Z' | 'a'..='z' | '_'));
+    assert!(&b'0'.is_ascii_digit());
 }
 
 #[clippy::msrv = "1.23"]
diff --git a/tests/ui/manual_is_ascii_check.rs b/tests/ui/manual_is_ascii_check.rs
index 39ee6151c56..c929f30f729 100644
--- a/tests/ui/manual_is_ascii_check.rs
+++ b/tests/ui/manual_is_ascii_check.rs
@@ -15,6 +15,7 @@ fn main() {
     assert!(matches!('x', 'A'..='Z' | 'a'..='z'));
 
     assert!(matches!('x', 'A'..='Z' | 'a'..='z' | '_'));
+    assert!((b'0'..=b'9').contains(&b'0'));
 }
 
 #[clippy::msrv = "1.23"]
diff --git a/tests/ui/manual_is_ascii_check.stderr b/tests/ui/manual_is_ascii_check.stderr
index 397cbe05c82..888924f9386 100644
--- a/tests/ui/manual_is_ascii_check.stderr
+++ b/tests/ui/manual_is_ascii_check.stderr
@@ -43,28 +43,34 @@ LL |     assert!(matches!('x', 'A'..='Z' | 'a'..='z'));
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `'x'.is_ascii_alphabetic()`
 
 error: manual check for common ascii range
-  --> $DIR/manual_is_ascii_check.rs:29:13
+  --> $DIR/manual_is_ascii_check.rs:18:13
+   |
+LL |     assert!((b'0'..=b'9').contains(&b'0'));
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&b'0'.is_ascii_digit()`
+
+error: manual check for common ascii range
+  --> $DIR/manual_is_ascii_check.rs:30:13
    |
 LL |     assert!(matches!(b'1', b'0'..=b'9'));
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `b'1'.is_ascii_digit()`
 
 error: manual check for common ascii range
-  --> $DIR/manual_is_ascii_check.rs:30:13
+  --> $DIR/manual_is_ascii_check.rs:31:13
    |
 LL |     assert!(matches!('X', 'A'..='Z'));
    |             ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `'X'.is_ascii_uppercase()`
 
 error: manual check for common ascii range
-  --> $DIR/manual_is_ascii_check.rs:31:13
+  --> $DIR/manual_is_ascii_check.rs:32:13
    |
 LL |     assert!(matches!('x', 'A'..='Z' | 'a'..='z'));
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `'x'.is_ascii_alphabetic()`
 
 error: manual check for common ascii range
-  --> $DIR/manual_is_ascii_check.rs:41:23
+  --> $DIR/manual_is_ascii_check.rs:42:23
    |
 LL |     const FOO: bool = matches!('x', '0'..='9');
    |                       ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `'x'.is_ascii_digit()`
 
-error: aborting due to 11 previous errors
+error: aborting due to 12 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From de92da297466f974b63fb8157419c0616cbfd558 Mon Sep 17 00:00:00 2001
From: naosense <pingao777@gmail.com>
Date: Mon, 12 Dec 2022 18:58:02 +0800
Subject: add more test, limits check

---
 clippy_lints/src/manual_is_ascii_check.rs |  4 ++-
 tests/ui/manual_is_ascii_check.fixed      |  7 ++++++
 tests/ui/manual_is_ascii_check.rs         |  7 ++++++
 tests/ui/manual_is_ascii_check.stderr     | 42 ++++++++++++++++++++++++++-----
 4 files changed, 53 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_is_ascii_check.rs b/clippy_lints/src/manual_is_ascii_check.rs
index 39e7145b479..eaaaf0c6581 100644
--- a/clippy_lints/src/manual_is_ascii_check.rs
+++ b/clippy_lints/src/manual_is_ascii_check.rs
@@ -1,5 +1,6 @@
 use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::{diagnostics::span_lint_and_sugg, higher, in_constant, macros::root_macro_call, source::snippet};
+use rustc_ast::ast::RangeLimits;
 use rustc_ast::LitKind::{Byte, Char};
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, PatKind, RangeEnd};
@@ -83,7 +84,8 @@ impl<'tcx> LateLintPass<'tcx> for ManualIsAsciiCheck {
             }
         } else if let ExprKind::MethodCall(path, receiver, [arg], ..) = expr.kind
             && path.ident.name == sym!(contains)
-            && let Some(higher::Range { start: Some(start), end: Some(end), .. }) = higher::Range::hir(receiver) {
+            && let Some(higher::Range { start: Some(start), end: Some(end), limits: RangeLimits::Closed })
+            = higher::Range::hir(receiver) {
                 let range = check_range(start, end);
                 check_is_ascii(cx, expr.span, arg, &range);
         }
diff --git a/tests/ui/manual_is_ascii_check.fixed b/tests/ui/manual_is_ascii_check.fixed
index bfba6dd7cd8..b2f45aba59a 100644
--- a/tests/ui/manual_is_ascii_check.fixed
+++ b/tests/ui/manual_is_ascii_check.fixed
@@ -15,7 +15,14 @@ fn main() {
     assert!('x'.is_ascii_alphabetic());
 
     assert!(matches!('x', 'A'..='Z' | 'a'..='z' | '_'));
+
     assert!(&b'0'.is_ascii_digit());
+    assert!(&b'a'.is_ascii_lowercase());
+    assert!(&b'A'.is_ascii_uppercase());
+
+    assert!(&'0'.is_ascii_digit());
+    assert!(&'a'.is_ascii_lowercase());
+    assert!(&'A'.is_ascii_uppercase());
 }
 
 #[clippy::msrv = "1.23"]
diff --git a/tests/ui/manual_is_ascii_check.rs b/tests/ui/manual_is_ascii_check.rs
index c929f30f729..7f1ee88fc74 100644
--- a/tests/ui/manual_is_ascii_check.rs
+++ b/tests/ui/manual_is_ascii_check.rs
@@ -15,7 +15,14 @@ fn main() {
     assert!(matches!('x', 'A'..='Z' | 'a'..='z'));
 
     assert!(matches!('x', 'A'..='Z' | 'a'..='z' | '_'));
+
     assert!((b'0'..=b'9').contains(&b'0'));
+    assert!((b'a'..=b'z').contains(&b'a'));
+    assert!((b'A'..=b'Z').contains(&b'A'));
+
+    assert!(('0'..='9').contains(&'0'));
+    assert!(('a'..='z').contains(&'a'));
+    assert!(('A'..='Z').contains(&'A'));
 }
 
 #[clippy::msrv = "1.23"]
diff --git a/tests/ui/manual_is_ascii_check.stderr b/tests/ui/manual_is_ascii_check.stderr
index 888924f9386..797952a3aba 100644
--- a/tests/ui/manual_is_ascii_check.stderr
+++ b/tests/ui/manual_is_ascii_check.stderr
@@ -43,34 +43,64 @@ LL |     assert!(matches!('x', 'A'..='Z' | 'a'..='z'));
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `'x'.is_ascii_alphabetic()`
 
 error: manual check for common ascii range
-  --> $DIR/manual_is_ascii_check.rs:18:13
+  --> $DIR/manual_is_ascii_check.rs:19:13
    |
 LL |     assert!((b'0'..=b'9').contains(&b'0'));
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&b'0'.is_ascii_digit()`
 
 error: manual check for common ascii range
-  --> $DIR/manual_is_ascii_check.rs:30:13
+  --> $DIR/manual_is_ascii_check.rs:20:13
+   |
+LL |     assert!((b'a'..=b'z').contains(&b'a'));
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&b'a'.is_ascii_lowercase()`
+
+error: manual check for common ascii range
+  --> $DIR/manual_is_ascii_check.rs:21:13
+   |
+LL |     assert!((b'A'..=b'Z').contains(&b'A'));
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&b'A'.is_ascii_uppercase()`
+
+error: manual check for common ascii range
+  --> $DIR/manual_is_ascii_check.rs:23:13
+   |
+LL |     assert!(('0'..='9').contains(&'0'));
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&'0'.is_ascii_digit()`
+
+error: manual check for common ascii range
+  --> $DIR/manual_is_ascii_check.rs:24:13
+   |
+LL |     assert!(('a'..='z').contains(&'a'));
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&'a'.is_ascii_lowercase()`
+
+error: manual check for common ascii range
+  --> $DIR/manual_is_ascii_check.rs:25:13
+   |
+LL |     assert!(('A'..='Z').contains(&'A'));
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&'A'.is_ascii_uppercase()`
+
+error: manual check for common ascii range
+  --> $DIR/manual_is_ascii_check.rs:37:13
    |
 LL |     assert!(matches!(b'1', b'0'..=b'9'));
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `b'1'.is_ascii_digit()`
 
 error: manual check for common ascii range
-  --> $DIR/manual_is_ascii_check.rs:31:13
+  --> $DIR/manual_is_ascii_check.rs:38:13
    |
 LL |     assert!(matches!('X', 'A'..='Z'));
    |             ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `'X'.is_ascii_uppercase()`
 
 error: manual check for common ascii range
-  --> $DIR/manual_is_ascii_check.rs:32:13
+  --> $DIR/manual_is_ascii_check.rs:39:13
    |
 LL |     assert!(matches!('x', 'A'..='Z' | 'a'..='z'));
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `'x'.is_ascii_alphabetic()`
 
 error: manual check for common ascii range
-  --> $DIR/manual_is_ascii_check.rs:42:23
+  --> $DIR/manual_is_ascii_check.rs:49:23
    |
 LL |     const FOO: bool = matches!('x', '0'..='9');
    |                       ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `'x'.is_ascii_digit()`
 
-error: aborting due to 12 previous errors
+error: aborting due to 17 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 55fdd1e78c73b67adce581fbf09aa0a1b6f07c61 Mon Sep 17 00:00:00 2001
From: naosense <pingao777@gmail.com>
Date: Tue, 13 Dec 2022 10:50:49 +0800
Subject: replace reference with value

---
 clippy_lints/src/manual_is_ascii_check.rs |  8 ++++++--
 tests/ui/manual_is_ascii_check.fixed      | 12 ++++++------
 tests/ui/manual_is_ascii_check.stderr     | 12 ++++++------
 3 files changed, 18 insertions(+), 14 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_is_ascii_check.rs b/clippy_lints/src/manual_is_ascii_check.rs
index eaaaf0c6581..b1578627b50 100644
--- a/clippy_lints/src/manual_is_ascii_check.rs
+++ b/clippy_lints/src/manual_is_ascii_check.rs
@@ -3,7 +3,7 @@ use clippy_utils::{diagnostics::span_lint_and_sugg, higher, in_constant, macros:
 use rustc_ast::ast::RangeLimits;
 use rustc_ast::LitKind::{Byte, Char};
 use rustc_errors::Applicability;
-use rustc_hir::{Expr, ExprKind, PatKind, RangeEnd};
+use rustc_hir::{BorrowKind, Expr, ExprKind, PatKind, RangeEnd};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::{def_id::DefId, sym, Span};
@@ -86,8 +86,12 @@ impl<'tcx> LateLintPass<'tcx> for ManualIsAsciiCheck {
             && path.ident.name == sym!(contains)
             && let Some(higher::Range { start: Some(start), end: Some(end), limits: RangeLimits::Closed })
             = higher::Range::hir(receiver) {
-                let range = check_range(start, end);
+            let range = check_range(start, end);
+            if let ExprKind::AddrOf(BorrowKind::Ref, _, e) = arg.kind {
+                check_is_ascii(cx, expr.span, e, &range);
+            } else {
                 check_is_ascii(cx, expr.span, arg, &range);
+            }
         }
     }
 
diff --git a/tests/ui/manual_is_ascii_check.fixed b/tests/ui/manual_is_ascii_check.fixed
index b2f45aba59a..b5e8b9c19cb 100644
--- a/tests/ui/manual_is_ascii_check.fixed
+++ b/tests/ui/manual_is_ascii_check.fixed
@@ -16,13 +16,13 @@ fn main() {
 
     assert!(matches!('x', 'A'..='Z' | 'a'..='z' | '_'));
 
-    assert!(&b'0'.is_ascii_digit());
-    assert!(&b'a'.is_ascii_lowercase());
-    assert!(&b'A'.is_ascii_uppercase());
+    assert!(b'0'.is_ascii_digit());
+    assert!(b'a'.is_ascii_lowercase());
+    assert!(b'A'.is_ascii_uppercase());
 
-    assert!(&'0'.is_ascii_digit());
-    assert!(&'a'.is_ascii_lowercase());
-    assert!(&'A'.is_ascii_uppercase());
+    assert!('0'.is_ascii_digit());
+    assert!('a'.is_ascii_lowercase());
+    assert!('A'.is_ascii_uppercase());
 }
 
 #[clippy::msrv = "1.23"]
diff --git a/tests/ui/manual_is_ascii_check.stderr b/tests/ui/manual_is_ascii_check.stderr
index 797952a3aba..ae747d33b58 100644
--- a/tests/ui/manual_is_ascii_check.stderr
+++ b/tests/ui/manual_is_ascii_check.stderr
@@ -46,37 +46,37 @@ error: manual check for common ascii range
   --> $DIR/manual_is_ascii_check.rs:19:13
    |
 LL |     assert!((b'0'..=b'9').contains(&b'0'));
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&b'0'.is_ascii_digit()`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `b'0'.is_ascii_digit()`
 
 error: manual check for common ascii range
   --> $DIR/manual_is_ascii_check.rs:20:13
    |
 LL |     assert!((b'a'..=b'z').contains(&b'a'));
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&b'a'.is_ascii_lowercase()`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `b'a'.is_ascii_lowercase()`
 
 error: manual check for common ascii range
   --> $DIR/manual_is_ascii_check.rs:21:13
    |
 LL |     assert!((b'A'..=b'Z').contains(&b'A'));
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&b'A'.is_ascii_uppercase()`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `b'A'.is_ascii_uppercase()`
 
 error: manual check for common ascii range
   --> $DIR/manual_is_ascii_check.rs:23:13
    |
 LL |     assert!(('0'..='9').contains(&'0'));
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&'0'.is_ascii_digit()`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `'0'.is_ascii_digit()`
 
 error: manual check for common ascii range
   --> $DIR/manual_is_ascii_check.rs:24:13
    |
 LL |     assert!(('a'..='z').contains(&'a'));
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&'a'.is_ascii_lowercase()`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `'a'.is_ascii_lowercase()`
 
 error: manual check for common ascii range
   --> $DIR/manual_is_ascii_check.rs:25:13
    |
 LL |     assert!(('A'..='Z').contains(&'A'));
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&'A'.is_ascii_uppercase()`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `'A'.is_ascii_uppercase()`
 
 error: manual check for common ascii range
   --> $DIR/manual_is_ascii_check.rs:37:13
-- 
cgit 1.4.1-3-g733a5


From 949d0709bd814c1191ab8c0e6c689db3f7ff07e4 Mon Sep 17 00:00:00 2001
From: naosense <pingao777@gmail.com>
Date: Tue, 13 Dec 2022 11:11:52 +0800
Subject: improve document

---
 clippy_lints/src/manual_is_ascii_check.rs | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_is_ascii_check.rs b/clippy_lints/src/manual_is_ascii_check.rs
index b1578627b50..6ee94551d70 100644
--- a/clippy_lints/src/manual_is_ascii_check.rs
+++ b/clippy_lints/src/manual_is_ascii_check.rs
@@ -24,6 +24,14 @@ declare_clippy_lint! {
     ///     assert!(matches!(b'X', b'A'..=b'Z'));
     ///     assert!(matches!('2', '0'..='9'));
     ///     assert!(matches!('x', 'A'..='Z' | 'a'..='z'));
+    ///
+    ///     assert!((b'0'..=b'9').contains(&b'0'));
+    ///     assert!((b'a'..=b'z').contains(&b'a'));
+    ///     assert!((b'A'..=b'Z').contains(&b'A'));
+    ///
+    ///     assert!(('0'..='9').contains(&'0'));
+    ///     assert!(('a'..='z').contains(&'a'));
+    ///     assert!(('A'..='Z').contains(&'A'));
     /// }
     /// ```
     /// Use instead:
@@ -33,6 +41,14 @@ declare_clippy_lint! {
     ///     assert!(b'X'.is_ascii_uppercase());
     ///     assert!('2'.is_ascii_digit());
     ///     assert!('x'.is_ascii_alphabetic());
+    ///
+    ///     assert!(b'0'.is_ascii_digit());
+    ///     assert!(b'a'.is_ascii_lowercase());
+    ///     assert!(b'A'.is_ascii_uppercase());
+    ///
+    ///     assert!('0'.is_ascii_digit());
+    ///     assert!('a'.is_ascii_lowercase());
+    ///     assert!('A'.is_ascii_uppercase());
     /// }
     /// ```
     #[clippy::version = "1.66.0"]
-- 
cgit 1.4.1-3-g733a5


From 1f862c2ad31a64beb86a2c6b0c1d2a1947b8173b Mon Sep 17 00:00:00 2001
From: naosense <pingao777@gmail.com>
Date: Tue, 13 Dec 2022 16:50:09 +0800
Subject: remove assert macro

---
 clippy_lints/src/manual_is_ascii_check.rs | 20 +++-------
 tests/ui/manual_is_ascii_check.fixed      | 19 +++++----
 tests/ui/manual_is_ascii_check.rs         | 19 +++++----
 tests/ui/manual_is_ascii_check.stderr     | 64 ++++++++++++++++++++-----------
 4 files changed, 71 insertions(+), 51 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_is_ascii_check.rs b/clippy_lints/src/manual_is_ascii_check.rs
index 6ee94551d70..d9ef7dffa02 100644
--- a/clippy_lints/src/manual_is_ascii_check.rs
+++ b/clippy_lints/src/manual_is_ascii_check.rs
@@ -25,13 +25,9 @@ declare_clippy_lint! {
     ///     assert!(matches!('2', '0'..='9'));
     ///     assert!(matches!('x', 'A'..='Z' | 'a'..='z'));
     ///
-    ///     assert!((b'0'..=b'9').contains(&b'0'));
-    ///     assert!((b'a'..=b'z').contains(&b'a'));
-    ///     assert!((b'A'..=b'Z').contains(&b'A'));
-    ///
-    ///     assert!(('0'..='9').contains(&'0'));
-    ///     assert!(('a'..='z').contains(&'a'));
-    ///     assert!(('A'..='Z').contains(&'A'));
+    ///     ('0'..='9').contains(&'0');
+    ///     ('a'..='z').contains(&'a');
+    ///     ('A'..='Z').contains(&'A');
     /// }
     /// ```
     /// Use instead:
@@ -42,13 +38,9 @@ declare_clippy_lint! {
     ///     assert!('2'.is_ascii_digit());
     ///     assert!('x'.is_ascii_alphabetic());
     ///
-    ///     assert!(b'0'.is_ascii_digit());
-    ///     assert!(b'a'.is_ascii_lowercase());
-    ///     assert!(b'A'.is_ascii_uppercase());
-    ///
-    ///     assert!('0'.is_ascii_digit());
-    ///     assert!('a'.is_ascii_lowercase());
-    ///     assert!('A'.is_ascii_uppercase());
+    ///     '0'.is_ascii_digit();
+    ///     'a'.is_ascii_lowercase();
+    ///     'A'.is_ascii_uppercase();
     /// }
     /// ```
     #[clippy::version = "1.66.0"]
diff --git a/tests/ui/manual_is_ascii_check.fixed b/tests/ui/manual_is_ascii_check.fixed
index b5e8b9c19cb..5b2b44c2fdb 100644
--- a/tests/ui/manual_is_ascii_check.fixed
+++ b/tests/ui/manual_is_ascii_check.fixed
@@ -16,13 +16,18 @@ fn main() {
 
     assert!(matches!('x', 'A'..='Z' | 'a'..='z' | '_'));
 
-    assert!(b'0'.is_ascii_digit());
-    assert!(b'a'.is_ascii_lowercase());
-    assert!(b'A'.is_ascii_uppercase());
-
-    assert!('0'.is_ascii_digit());
-    assert!('a'.is_ascii_lowercase());
-    assert!('A'.is_ascii_uppercase());
+    b'0'.is_ascii_digit();
+    b'a'.is_ascii_lowercase();
+    b'A'.is_ascii_uppercase();
+
+    '0'.is_ascii_digit();
+    'a'.is_ascii_lowercase();
+    'A'.is_ascii_uppercase();
+
+    let cool_letter = &'g';
+    cool_letter.is_ascii_digit();
+    cool_letter.is_ascii_lowercase();
+    cool_letter.is_ascii_uppercase();
 }
 
 #[clippy::msrv = "1.23"]
diff --git a/tests/ui/manual_is_ascii_check.rs b/tests/ui/manual_is_ascii_check.rs
index 7f1ee88fc74..c9433f33a1b 100644
--- a/tests/ui/manual_is_ascii_check.rs
+++ b/tests/ui/manual_is_ascii_check.rs
@@ -16,13 +16,18 @@ fn main() {
 
     assert!(matches!('x', 'A'..='Z' | 'a'..='z' | '_'));
 
-    assert!((b'0'..=b'9').contains(&b'0'));
-    assert!((b'a'..=b'z').contains(&b'a'));
-    assert!((b'A'..=b'Z').contains(&b'A'));
-
-    assert!(('0'..='9').contains(&'0'));
-    assert!(('a'..='z').contains(&'a'));
-    assert!(('A'..='Z').contains(&'A'));
+    (b'0'..=b'9').contains(&b'0');
+    (b'a'..=b'z').contains(&b'a');
+    (b'A'..=b'Z').contains(&b'A');
+
+    ('0'..='9').contains(&'0');
+    ('a'..='z').contains(&'a');
+    ('A'..='Z').contains(&'A');
+
+    let cool_letter = &'g';
+    ('0'..='9').contains(cool_letter);
+    ('a'..='z').contains(cool_letter);
+    ('A'..='Z').contains(cool_letter);
 }
 
 #[clippy::msrv = "1.23"]
diff --git a/tests/ui/manual_is_ascii_check.stderr b/tests/ui/manual_is_ascii_check.stderr
index ae747d33b58..ee60188506d 100644
--- a/tests/ui/manual_is_ascii_check.stderr
+++ b/tests/ui/manual_is_ascii_check.stderr
@@ -43,64 +43,82 @@ LL |     assert!(matches!('x', 'A'..='Z' | 'a'..='z'));
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `'x'.is_ascii_alphabetic()`
 
 error: manual check for common ascii range
-  --> $DIR/manual_is_ascii_check.rs:19:13
+  --> $DIR/manual_is_ascii_check.rs:19:5
    |
-LL |     assert!((b'0'..=b'9').contains(&b'0'));
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `b'0'.is_ascii_digit()`
+LL |     (b'0'..=b'9').contains(&b'0');
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `b'0'.is_ascii_digit()`
 
 error: manual check for common ascii range
-  --> $DIR/manual_is_ascii_check.rs:20:13
+  --> $DIR/manual_is_ascii_check.rs:20:5
    |
-LL |     assert!((b'a'..=b'z').contains(&b'a'));
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `b'a'.is_ascii_lowercase()`
+LL |     (b'a'..=b'z').contains(&b'a');
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `b'a'.is_ascii_lowercase()`
 
 error: manual check for common ascii range
-  --> $DIR/manual_is_ascii_check.rs:21:13
+  --> $DIR/manual_is_ascii_check.rs:21:5
    |
-LL |     assert!((b'A'..=b'Z').contains(&b'A'));
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `b'A'.is_ascii_uppercase()`
+LL |     (b'A'..=b'Z').contains(&b'A');
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `b'A'.is_ascii_uppercase()`
 
 error: manual check for common ascii range
-  --> $DIR/manual_is_ascii_check.rs:23:13
+  --> $DIR/manual_is_ascii_check.rs:23:5
    |
-LL |     assert!(('0'..='9').contains(&'0'));
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `'0'.is_ascii_digit()`
+LL |     ('0'..='9').contains(&'0');
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `'0'.is_ascii_digit()`
 
 error: manual check for common ascii range
-  --> $DIR/manual_is_ascii_check.rs:24:13
+  --> $DIR/manual_is_ascii_check.rs:24:5
    |
-LL |     assert!(('a'..='z').contains(&'a'));
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `'a'.is_ascii_lowercase()`
+LL |     ('a'..='z').contains(&'a');
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `'a'.is_ascii_lowercase()`
 
 error: manual check for common ascii range
-  --> $DIR/manual_is_ascii_check.rs:25:13
+  --> $DIR/manual_is_ascii_check.rs:25:5
    |
-LL |     assert!(('A'..='Z').contains(&'A'));
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `'A'.is_ascii_uppercase()`
+LL |     ('A'..='Z').contains(&'A');
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `'A'.is_ascii_uppercase()`
 
 error: manual check for common ascii range
-  --> $DIR/manual_is_ascii_check.rs:37:13
+  --> $DIR/manual_is_ascii_check.rs:28:5
+   |
+LL |     ('0'..='9').contains(cool_letter);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `cool_letter.is_ascii_digit()`
+
+error: manual check for common ascii range
+  --> $DIR/manual_is_ascii_check.rs:29:5
+   |
+LL |     ('a'..='z').contains(cool_letter);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `cool_letter.is_ascii_lowercase()`
+
+error: manual check for common ascii range
+  --> $DIR/manual_is_ascii_check.rs:30:5
+   |
+LL |     ('A'..='Z').contains(cool_letter);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `cool_letter.is_ascii_uppercase()`
+
+error: manual check for common ascii range
+  --> $DIR/manual_is_ascii_check.rs:42:13
    |
 LL |     assert!(matches!(b'1', b'0'..=b'9'));
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `b'1'.is_ascii_digit()`
 
 error: manual check for common ascii range
-  --> $DIR/manual_is_ascii_check.rs:38:13
+  --> $DIR/manual_is_ascii_check.rs:43:13
    |
 LL |     assert!(matches!('X', 'A'..='Z'));
    |             ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `'X'.is_ascii_uppercase()`
 
 error: manual check for common ascii range
-  --> $DIR/manual_is_ascii_check.rs:39:13
+  --> $DIR/manual_is_ascii_check.rs:44:13
    |
 LL |     assert!(matches!('x', 'A'..='Z' | 'a'..='z'));
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `'x'.is_ascii_alphabetic()`
 
 error: manual check for common ascii range
-  --> $DIR/manual_is_ascii_check.rs:49:23
+  --> $DIR/manual_is_ascii_check.rs:54:23
    |
 LL |     const FOO: bool = matches!('x', '0'..='9');
    |                       ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `'x'.is_ascii_digit()`
 
-error: aborting due to 17 previous errors
+error: aborting due to 20 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 2532c56d8643c9ee343da8dff60828fcfe77d065 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Tue, 13 Dec 2022 18:29:22 +0100
Subject: Update version attribute for 1.66 lints

---
 clippy_lints/src/box_default.rs             | 2 +-
 clippy_lints/src/casts/mod.rs               | 2 +-
 clippy_lints/src/disallowed_macros.rs       | 2 +-
 clippy_lints/src/format_args.rs             | 2 +-
 clippy_lints/src/implicit_saturating_add.rs | 2 +-
 clippy_lints/src/methods/mod.rs             | 2 +-
 6 files changed, 6 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/box_default.rs b/clippy_lints/src/box_default.rs
index 36daceabe0b..91900542af8 100644
--- a/clippy_lints/src/box_default.rs
+++ b/clippy_lints/src/box_default.rs
@@ -30,7 +30,7 @@ declare_clippy_lint! {
     /// ```rust
     /// let x: Box<String> = Box::default();
     /// ```
-    #[clippy::version = "1.65.0"]
+    #[clippy::version = "1.66.0"]
     pub BOX_DEFAULT,
     perf,
     "Using Box::new(T::default()) instead of Box::default()"
diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index c6d505c4a18..161e3a698e9 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -641,7 +641,7 @@ declare_clippy_lint! {
     /// ```rust,ignore
     /// let _: = 0_u64;
     /// ```
-    #[clippy::version = "1.64.0"]
+    #[clippy::version = "1.66.0"]
     pub CAST_NAN_TO_INT,
     suspicious,
     "casting a known floating-point NaN into an integer"
diff --git a/clippy_lints/src/disallowed_macros.rs b/clippy_lints/src/disallowed_macros.rs
index 68122b4cef5..1971cab64ef 100644
--- a/clippy_lints/src/disallowed_macros.rs
+++ b/clippy_lints/src/disallowed_macros.rs
@@ -47,7 +47,7 @@ declare_clippy_lint! {
     ///     value: usize,
     /// }
     /// ```
-    #[clippy::version = "1.65.0"]
+    #[clippy::version = "1.66.0"]
     pub DISALLOWED_MACROS,
     style,
     "use of a disallowed macro"
diff --git a/clippy_lints/src/format_args.rs b/clippy_lints/src/format_args.rs
index f0995a81329..08976bde882 100644
--- a/clippy_lints/src/format_args.rs
+++ b/clippy_lints/src/format_args.rs
@@ -122,7 +122,7 @@ declare_clippy_lint! {
     ///
     /// If a format string contains a numbered argument that cannot be inlined
     /// nothing will be suggested, e.g. `println!("{0}={1}", var, 1+2)`.
-    #[clippy::version = "1.65.0"]
+    #[clippy::version = "1.66.0"]
     pub UNINLINED_FORMAT_ARGS,
     style,
     "using non-inlined variables in `format!` calls"
diff --git a/clippy_lints/src/implicit_saturating_add.rs b/clippy_lints/src/implicit_saturating_add.rs
index bf1351829c6..6e19343931e 100644
--- a/clippy_lints/src/implicit_saturating_add.rs
+++ b/clippy_lints/src/implicit_saturating_add.rs
@@ -31,7 +31,7 @@ declare_clippy_lint! {
     ///
     /// u = u.saturating_add(1);
     /// ```
-    #[clippy::version = "1.65.0"]
+    #[clippy::version = "1.66.0"]
     pub IMPLICIT_SATURATING_ADD,
     style,
     "Perform saturating addition instead of implicitly checking max bound of data type"
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index d2913680cbb..30883ba8d05 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3059,7 +3059,7 @@ declare_clippy_lint! {
     /// let map: HashMap<u32, u32> = HashMap::new();
     /// let values = map.values().collect::<Vec<_>>();
     /// ```
-    #[clippy::version = "1.65.0"]
+    #[clippy::version = "1.66.0"]
     pub ITER_KV_MAP,
     complexity,
     "iterating on map using `iter` when `keys` or `values` would do"
-- 
cgit 1.4.1-3-g733a5


From 5b3a6669f75dda31d9f736abb0ef30429264069a Mon Sep 17 00:00:00 2001
From: Eric Wu <eric.dianhao.wu@gmail.com>
Date: Thu, 15 Dec 2022 23:29:28 -0500
Subject: fix manual_filter false positive

do explicit checks for the other branch being None
---
 clippy_lints/src/matches/manual_filter.rs | 17 +++++++++++------
 tests/ui/manual_filter.fixed              | 27 +++++++++++++++++++++++++++
 tests/ui/manual_filter.rs                 | 27 +++++++++++++++++++++++++++
 3 files changed, 65 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/manual_filter.rs b/clippy_lints/src/matches/manual_filter.rs
index d521a529e0d..f6bf0e7aa1a 100644
--- a/clippy_lints/src/matches/manual_filter.rs
+++ b/clippy_lints/src/matches/manual_filter.rs
@@ -3,7 +3,7 @@ use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::visitors::contains_unsafe_block;
 use clippy_utils::{is_res_lang_ctor, path_res, path_to_local_id};
 
-use rustc_hir::LangItem::OptionSome;
+use rustc_hir::LangItem::{OptionNone, OptionSome};
 use rustc_hir::{Arm, Expr, ExprKind, HirId, Pat, PatKind};
 use rustc_lint::LateContext;
 use rustc_span::{sym, SyntaxContext};
@@ -25,15 +25,13 @@ fn get_cond_expr<'tcx>(
         if let Some(block_expr) = peels_blocks_incl_unsafe_opt(expr);
         if let ExprKind::If(cond, then_expr, Some(else_expr)) = block_expr.kind;
         if let PatKind::Binding(_,target, ..) = pat.kind;
-        if let (then_visitor, else_visitor)
-            = (is_some_expr(cx, target, ctxt, then_expr),
-                is_some_expr(cx, target, ctxt, else_expr));
-        if then_visitor != else_visitor; // check that one expr resolves to `Some(x)`, the other to `None`
+        if is_some_expr(cx, target, ctxt, then_expr) && is_none_expr(cx, else_expr)
+            || is_none_expr(cx, then_expr) && is_some_expr(cx, target, ctxt, else_expr); // check that one expr resolves to `Some(x)`, the other to `None`
         then {
             return Some(SomeExpr {
                     expr: peels_blocks_incl_unsafe(cond.peel_drop_temps()),
                     needs_unsafe_block: contains_unsafe_block(cx, expr),
-                    needs_negated: !then_visitor // if the `then_expr` resolves to `None`, need to negate the cond
+                    needs_negated: is_none_expr(cx, then_expr) // if the `then_expr` resolves to `None`, need to negate the cond
                 })
             }
     };
@@ -74,6 +72,13 @@ fn is_some_expr(cx: &LateContext<'_>, target: HirId, ctxt: SyntaxContext, expr:
     false
 }
 
+fn is_none_expr(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+    if let Some(inner_expr) = peels_blocks_incl_unsafe_opt(expr) {
+        return is_res_lang_ctor(cx, path_res(cx, inner_expr), OptionNone);
+    };
+    false
+}
+
 // given the closure: `|<pattern>| <expr>`
 // returns `|&<pattern>| <expr>`
 fn add_ampersand_if_copy(body_str: String, has_copy_trait: bool) -> String {
diff --git a/tests/ui/manual_filter.fixed b/tests/ui/manual_filter.fixed
index 3553291b87d..b986dd5e213 100644
--- a/tests/ui/manual_filter.fixed
+++ b/tests/ui/manual_filter.fixed
@@ -116,4 +116,31 @@ fn main() {
         },
         None => None,
     };
+
+    match Some(20) {
+        // Don't Lint, because `Some(3*x)` is not `None`
+        None => None,
+        Some(x) => {
+            if x > 0 {
+                Some(3 * x)
+            } else {
+                Some(x)
+            }
+        },
+    };
+
+    // Don't lint: https://github.com/rust-lang/rust-clippy/issues/10088
+    let result = if let Some(a) = maybe_some() {
+        if let Some(b) = maybe_some() {
+            Some(a + b)
+        } else {
+            Some(a)
+        }
+    } else {
+        None
+    };
+}
+
+fn maybe_some() -> Option<u32> {
+    Some(0)
 }
diff --git a/tests/ui/manual_filter.rs b/tests/ui/manual_filter.rs
index aa9f90f752b..1e786b9027c 100644
--- a/tests/ui/manual_filter.rs
+++ b/tests/ui/manual_filter.rs
@@ -240,4 +240,31 @@ fn main() {
         },
         None => None,
     };
+
+    match Some(20) {
+        // Don't Lint, because `Some(3*x)` is not `None`
+        None => None,
+        Some(x) => {
+            if x > 0 {
+                Some(3 * x)
+            } else {
+                Some(x)
+            }
+        },
+    };
+
+    // Don't lint: https://github.com/rust-lang/rust-clippy/issues/10088
+    let result = if let Some(a) = maybe_some() {
+        if let Some(b) = maybe_some() {
+            Some(a + b)
+        } else {
+            Some(a)
+        }
+    } else {
+        None
+    };
+}
+
+fn maybe_some() -> Option<u32> {
+    Some(0)
 }
-- 
cgit 1.4.1-3-g733a5


From 97c12e0460270bd6b0a6d52b8677f24c5b2d6879 Mon Sep 17 00:00:00 2001
From: Eric Wu <eric.dianhao.wu@gmail.com>
Date: Fri, 16 Dec 2022 10:22:29 -0500
Subject: fix logic in IncrementVisitor

There used to be a logical bug where IncrementVisitor would
completely stop checking an expression/block after seeing a continue
statement. This led to issue #10058 where a variable incremented
(or otherwise modified) after any continue statement would still be
considered incremented only once.

The solution is to continue scanning the expression after seeing a
`continue` statement, but increment self.depth so that the Visitor
thinks that the rest of the loop is within a conditional.
---
 clippy_lints/src/loops/utils.rs   | 10 +++-------
 tests/ui/explicit_counter_loop.rs | 30 ++++++++++++++++++++++++++++++
 2 files changed, 33 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/utils.rs b/clippy_lints/src/loops/utils.rs
index b6f4cf7bbb3..28ee24309cc 100644
--- a/clippy_lints/src/loops/utils.rs
+++ b/clippy_lints/src/loops/utils.rs
@@ -25,7 +25,6 @@ pub(super) struct IncrementVisitor<'a, 'tcx> {
     cx: &'a LateContext<'tcx>,                  // context reference
     states: HirIdMap<IncrementVisitorVarState>, // incremented variables
     depth: u32,                                 // depth of conditional expressions
-    done: bool,
 }
 
 impl<'a, 'tcx> IncrementVisitor<'a, 'tcx> {
@@ -34,7 +33,6 @@ impl<'a, 'tcx> IncrementVisitor<'a, 'tcx> {
             cx,
             states: HirIdMap::default(),
             depth: 0,
-            done: false,
         }
     }
 
@@ -51,10 +49,6 @@ impl<'a, 'tcx> IncrementVisitor<'a, 'tcx> {
 
 impl<'a, 'tcx> Visitor<'tcx> for IncrementVisitor<'a, 'tcx> {
     fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
-        if self.done {
-            return;
-        }
-
         // If node is a variable
         if let Some(def_id) = path_to_local(expr) {
             if let Some(parent) = get_parent_expr(self.cx, expr) {
@@ -95,7 +89,9 @@ impl<'a, 'tcx> Visitor<'tcx> for IncrementVisitor<'a, 'tcx> {
             walk_expr(self, expr);
             self.depth -= 1;
         } else if let ExprKind::Continue(_) = expr.kind {
-            self.done = true;
+            // If we see a `continue` block, then we increment depth so that the IncrementVisitor
+            // state will be set to DontWarn if we see the variable being modified anywhere afterwards.
+            self.depth += 1;
         } else {
             walk_expr(self, expr);
         }
diff --git a/tests/ui/explicit_counter_loop.rs b/tests/ui/explicit_counter_loop.rs
index 6eddc01e2c4..46565a97f00 100644
--- a/tests/ui/explicit_counter_loop.rs
+++ b/tests/ui/explicit_counter_loop.rs
@@ -189,3 +189,33 @@ mod issue_7920 {
         }
     }
 }
+
+mod issue_10058 {
+    pub fn test() {
+        // should not lint since we are increasing counter potentially more than once in the loop
+        let values = [0, 1, 0, 1, 1, 1, 0, 1, 0, 1];
+        let mut counter = 0;
+        for value in values {
+            counter += 1;
+
+            if value == 0 {
+                continue;
+            }
+
+            counter += 1;
+        }
+    }
+
+    pub fn test2() {
+        // should not lint since we are increasing counter potentially more than once in the loop
+        let values = [0, 1, 0, 1, 1, 1, 0, 1, 0, 1];
+        let mut counter = 0;
+        for value in values {
+            counter += 1;
+
+            if value != 0 {
+                counter += 1;
+            }
+        }
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From c39849a34dae51d104f197894ed5a9f02dd62d75 Mon Sep 17 00:00:00 2001
From: feniljain <fkjainco@gmail.com>
Date: Sat, 17 Dec 2022 17:24:03 +0530
Subject: fix: not suggest seek_to_start_instead_of_rewind when expr is used

---
 clippy_lints/src/methods/seek_to_start_instead_of_rewind.rs | 6 +++++-
 tests/ui/seek_to_start_instead_of_rewind.fixed              | 6 ++++++
 tests/ui/seek_to_start_instead_of_rewind.rs                 | 6 ++++++
 tests/ui/seek_to_start_instead_of_rewind.stderr             | 2 +-
 4 files changed, 18 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/seek_to_start_instead_of_rewind.rs b/clippy_lints/src/methods/seek_to_start_instead_of_rewind.rs
index 7e3bed1e41a..660b7049cce 100644
--- a/clippy_lints/src/methods/seek_to_start_instead_of_rewind.rs
+++ b/clippy_lints/src/methods/seek_to_start_instead_of_rewind.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::ty::implements_trait;
-use clippy_utils::{get_trait_def_id, match_def_path, paths};
+use clippy_utils::{get_trait_def_id, is_expr_used_or_unified, match_def_path, paths};
 use rustc_ast::ast::{LitIntType, LitKind};
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
@@ -19,6 +19,10 @@ pub(super) fn check<'tcx>(
     // Get receiver type
     let ty = cx.typeck_results().expr_ty(recv).peel_refs();
 
+    if is_expr_used_or_unified(cx.tcx, expr) {
+        return;
+    }
+
     if let Some(seek_trait_id) = get_trait_def_id(cx, &paths::STD_IO_SEEK) &&
         implements_trait(cx, ty, seek_trait_id, &[]) &&
         let ExprKind::Call(func, args1) = arg.kind &&
diff --git a/tests/ui/seek_to_start_instead_of_rewind.fixed b/tests/ui/seek_to_start_instead_of_rewind.fixed
index 9d0d1124c46..713cff604a1 100644
--- a/tests/ui/seek_to_start_instead_of_rewind.fixed
+++ b/tests/ui/seek_to_start_instead_of_rewind.fixed
@@ -70,6 +70,12 @@ fn seek_to_end<T: Seek>(t: &mut T) {
     t.seek(SeekFrom::End(0));
 }
 
+// This should NOT trigger clippy warning because
+// expr is used here
+fn seek_to_start_in_let<T: Seek>(t: &mut T) {
+    let a = t.seek(SeekFrom::Start(0)).unwrap();
+}
+
 fn main() {
     let mut f = OpenOptions::new()
         .write(true)
diff --git a/tests/ui/seek_to_start_instead_of_rewind.rs b/tests/ui/seek_to_start_instead_of_rewind.rs
index c5bc57cc3a7..467003a1a66 100644
--- a/tests/ui/seek_to_start_instead_of_rewind.rs
+++ b/tests/ui/seek_to_start_instead_of_rewind.rs
@@ -70,6 +70,12 @@ fn seek_to_end<T: Seek>(t: &mut T) {
     t.seek(SeekFrom::End(0));
 }
 
+// This should NOT trigger clippy warning because
+// expr is used here
+fn seek_to_start_in_let<T: Seek>(t: &mut T) {
+    let a = t.seek(SeekFrom::Start(0)).unwrap();
+}
+
 fn main() {
     let mut f = OpenOptions::new()
         .write(true)
diff --git a/tests/ui/seek_to_start_instead_of_rewind.stderr b/tests/ui/seek_to_start_instead_of_rewind.stderr
index 6cce025359f..342ec00fe72 100644
--- a/tests/ui/seek_to_start_instead_of_rewind.stderr
+++ b/tests/ui/seek_to_start_instead_of_rewind.stderr
@@ -13,7 +13,7 @@ LL |     t.seek(SeekFrom::Start(0));
    |       ^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `rewind()`
 
 error: used `seek` to go to the start of the stream
-  --> $DIR/seek_to_start_instead_of_rewind.rs:128:7
+  --> $DIR/seek_to_start_instead_of_rewind.rs:134:7
    |
 LL |     f.seek(SeekFrom::Start(0));
    |       ^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `rewind()`
-- 
cgit 1.4.1-3-g733a5


From af39a8a4a82001b38e2b6c0d391d1aa76740ec4b Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Thu, 1 Dec 2022 17:58:28 +0100
Subject: Identify more cases of useless `into_iter()` calls

If the type of the result of a call to `IntoIterator::into_iter()`
and the type of the receiver are the same, then the receiver
implements `Iterator` and `into_iter()` is the identity function.

The call to `into_iter()` may be removed in all but two cases:

- If the receiver implements `Copy`, `into_iter()` will produce
  a copy of the receiver and cannot be removed. For example,
  `x.into_iter().next()` will not advance `x` while `x.next()` will.
- If the receiver is an immutable local variable and the call to
  `into_iter()` appears in a larger expression, removing the call to
  `into_iter()` might cause mutability issues. For example, if `x`
  is an immutable local variable, `x.into_iter().next()` will
  compile while `x.next()` will not as `next()` receives
  `&mut self`.
---
 clippy_lints/src/useless_conversion.rs | 28 ++++++++-----
 tests/ui/useless_conversion.fixed      | 73 ++++++++++++++++++++++++++++++++--
 tests/ui/useless_conversion.rs         | 73 ++++++++++++++++++++++++++++++++--
 tests/ui/useless_conversion.stderr     | 54 +++++++++++++++++++------
 4 files changed, 200 insertions(+), 28 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/useless_conversion.rs b/clippy_lints/src/useless_conversion.rs
index 3743d5d97a7..a95e7b61374 100644
--- a/clippy_lints/src/useless_conversion.rs
+++ b/clippy_lints/src/useless_conversion.rs
@@ -1,11 +1,11 @@
 use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg};
 use clippy_utils::source::{snippet, snippet_with_macro_callsite};
 use clippy_utils::sugg::Sugg;
-use clippy_utils::ty::{is_type_diagnostic_item, same_type_and_consts};
-use clippy_utils::{get_parent_expr, is_trait_method, match_def_path, paths};
+use clippy_utils::ty::{is_copy, is_type_diagnostic_item, same_type_and_consts};
+use clippy_utils::{get_parent_expr, is_trait_method, match_def_path, path_to_local, paths};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
-use rustc_hir::{Expr, ExprKind, HirId, MatchSource};
+use rustc_hir::{BindingAnnotation, Expr, ExprKind, HirId, MatchSource, Node, PatKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
@@ -81,16 +81,24 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
                     }
                 }
                 if is_trait_method(cx, e, sym::IntoIterator) && name.ident.name == sym::into_iter {
-                    if let Some(parent_expr) = get_parent_expr(cx, e) {
-                        if let ExprKind::MethodCall(parent_name, ..) = parent_expr.kind {
-                            if parent_name.ident.name != sym::into_iter {
-                                return;
-                            }
-                        }
+                    if get_parent_expr(cx, e).is_some() &&
+                       let Some(id) = path_to_local(recv) &&
+                       let Node::Pat(pat) = cx.tcx.hir().get(id) &&
+                       let PatKind::Binding(ann, ..) = pat.kind &&
+                       ann != BindingAnnotation::MUT
+                    {
+                        // Do not remove .into_iter() applied to a non-mutable local variable used in
+                        // a larger expression context as it would differ in mutability.
+                        return;
                     }
+
                     let a = cx.typeck_results().expr_ty(e);
                     let b = cx.typeck_results().expr_ty(recv);
-                    if same_type_and_consts(a, b) {
+
+                    // If the types are identical then .into_iter() can be removed, unless the type
+                    // implements Copy, in which case .into_iter() returns a copy of the receiver and
+                    // cannot be safely omitted.
+                    if same_type_and_consts(a, b) && !is_copy(cx, b) {
                         let sugg = snippet(cx, recv.span, "<expr>").into_owned();
                         span_lint_and_sugg(
                             cx,
diff --git a/tests/ui/useless_conversion.fixed b/tests/ui/useless_conversion.fixed
index 70ff08f3655..94b206d8e58 100644
--- a/tests/ui/useless_conversion.fixed
+++ b/tests/ui/useless_conversion.fixed
@@ -33,12 +33,71 @@ fn test_issue_3913() -> Result<(), std::io::Error> {
     Ok(())
 }
 
-fn test_issue_5833() -> Result<(), ()> {
+fn dont_lint_into_iter_on_immutable_local_implementing_iterator_in_expr() {
     let text = "foo\r\nbar\n\nbaz\n";
     let lines = text.lines();
     if Some("ok") == lines.into_iter().next() {}
+}
 
-    Ok(())
+fn lint_into_iter_on_mutable_local_implementing_iterator_in_expr() {
+    let text = "foo\r\nbar\n\nbaz\n";
+    let mut lines = text.lines();
+    if Some("ok") == lines.next() {}
+}
+
+fn lint_into_iter_on_expr_implementing_iterator() {
+    let text = "foo\r\nbar\n\nbaz\n";
+    let mut lines = text.lines();
+    if Some("ok") == lines.next() {}
+}
+
+fn lint_into_iter_on_expr_implementing_iterator_2() {
+    let text = "foo\r\nbar\n\nbaz\n";
+    if Some("ok") == text.lines().next() {}
+}
+
+#[allow(const_item_mutation)]
+fn lint_into_iter_on_const_implementing_iterator() {
+    const NUMBERS: std::ops::Range<i32> = 0..10;
+    let _ = NUMBERS.next();
+}
+
+fn lint_into_iter_on_const_implementing_iterator_2() {
+    const NUMBERS: std::ops::Range<i32> = 0..10;
+    let mut n = NUMBERS;
+    n.next();
+}
+
+#[derive(Clone, Copy)]
+struct CopiableCounter {
+    counter: u32,
+}
+
+impl Iterator for CopiableCounter {
+    type Item = u32;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.counter = self.counter.wrapping_add(1);
+        Some(self.counter)
+    }
+}
+
+fn dont_lint_into_iter_on_copy_iter() {
+    let mut c = CopiableCounter { counter: 0 };
+    assert_eq!(c.into_iter().next(), Some(1));
+    assert_eq!(c.into_iter().next(), Some(1));
+    assert_eq!(c.next(), Some(1));
+    assert_eq!(c.next(), Some(2));
+}
+
+fn dont_lint_into_iter_on_static_copy_iter() {
+    static mut C: CopiableCounter = CopiableCounter { counter: 0 };
+    unsafe {
+        assert_eq!(C.into_iter().next(), Some(1));
+        assert_eq!(C.into_iter().next(), Some(1));
+        assert_eq!(C.next(), Some(1));
+        assert_eq!(C.next(), Some(2));
+    }
 }
 
 fn main() {
@@ -46,7 +105,15 @@ fn main() {
     test_generic2::<i32, i32>(10i32);
     test_questionmark().unwrap();
     test_issue_3913().unwrap();
-    test_issue_5833().unwrap();
+
+    dont_lint_into_iter_on_immutable_local_implementing_iterator_in_expr();
+    lint_into_iter_on_mutable_local_implementing_iterator_in_expr();
+    lint_into_iter_on_expr_implementing_iterator();
+    lint_into_iter_on_expr_implementing_iterator_2();
+    lint_into_iter_on_const_implementing_iterator();
+    lint_into_iter_on_const_implementing_iterator_2();
+    dont_lint_into_iter_on_copy_iter();
+    dont_lint_into_iter_on_static_copy_iter();
 
     let _: String = "foo".into();
     let _: String = From::from("foo");
diff --git a/tests/ui/useless_conversion.rs b/tests/ui/useless_conversion.rs
index f2444a8f436..c7ae927941b 100644
--- a/tests/ui/useless_conversion.rs
+++ b/tests/ui/useless_conversion.rs
@@ -33,12 +33,71 @@ fn test_issue_3913() -> Result<(), std::io::Error> {
     Ok(())
 }
 
-fn test_issue_5833() -> Result<(), ()> {
+fn dont_lint_into_iter_on_immutable_local_implementing_iterator_in_expr() {
     let text = "foo\r\nbar\n\nbaz\n";
     let lines = text.lines();
     if Some("ok") == lines.into_iter().next() {}
+}
 
-    Ok(())
+fn lint_into_iter_on_mutable_local_implementing_iterator_in_expr() {
+    let text = "foo\r\nbar\n\nbaz\n";
+    let mut lines = text.lines();
+    if Some("ok") == lines.into_iter().next() {}
+}
+
+fn lint_into_iter_on_expr_implementing_iterator() {
+    let text = "foo\r\nbar\n\nbaz\n";
+    let mut lines = text.lines().into_iter();
+    if Some("ok") == lines.next() {}
+}
+
+fn lint_into_iter_on_expr_implementing_iterator_2() {
+    let text = "foo\r\nbar\n\nbaz\n";
+    if Some("ok") == text.lines().into_iter().next() {}
+}
+
+#[allow(const_item_mutation)]
+fn lint_into_iter_on_const_implementing_iterator() {
+    const NUMBERS: std::ops::Range<i32> = 0..10;
+    let _ = NUMBERS.into_iter().next();
+}
+
+fn lint_into_iter_on_const_implementing_iterator_2() {
+    const NUMBERS: std::ops::Range<i32> = 0..10;
+    let mut n = NUMBERS.into_iter();
+    n.next();
+}
+
+#[derive(Clone, Copy)]
+struct CopiableCounter {
+    counter: u32,
+}
+
+impl Iterator for CopiableCounter {
+    type Item = u32;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.counter = self.counter.wrapping_add(1);
+        Some(self.counter)
+    }
+}
+
+fn dont_lint_into_iter_on_copy_iter() {
+    let mut c = CopiableCounter { counter: 0 };
+    assert_eq!(c.into_iter().next(), Some(1));
+    assert_eq!(c.into_iter().next(), Some(1));
+    assert_eq!(c.next(), Some(1));
+    assert_eq!(c.next(), Some(2));
+}
+
+fn dont_lint_into_iter_on_static_copy_iter() {
+    static mut C: CopiableCounter = CopiableCounter { counter: 0 };
+    unsafe {
+        assert_eq!(C.into_iter().next(), Some(1));
+        assert_eq!(C.into_iter().next(), Some(1));
+        assert_eq!(C.next(), Some(1));
+        assert_eq!(C.next(), Some(2));
+    }
 }
 
 fn main() {
@@ -46,7 +105,15 @@ fn main() {
     test_generic2::<i32, i32>(10i32);
     test_questionmark().unwrap();
     test_issue_3913().unwrap();
-    test_issue_5833().unwrap();
+
+    dont_lint_into_iter_on_immutable_local_implementing_iterator_in_expr();
+    lint_into_iter_on_mutable_local_implementing_iterator_in_expr();
+    lint_into_iter_on_expr_implementing_iterator();
+    lint_into_iter_on_expr_implementing_iterator_2();
+    lint_into_iter_on_const_implementing_iterator();
+    lint_into_iter_on_const_implementing_iterator_2();
+    dont_lint_into_iter_on_copy_iter();
+    dont_lint_into_iter_on_static_copy_iter();
 
     let _: String = "foo".into();
     let _: String = From::from("foo");
diff --git a/tests/ui/useless_conversion.stderr b/tests/ui/useless_conversion.stderr
index 65ee3807fa9..be067c6843a 100644
--- a/tests/ui/useless_conversion.stderr
+++ b/tests/ui/useless_conversion.stderr
@@ -22,71 +22,101 @@ error: useless conversion to the same type: `i32`
 LL |         let _: i32 = 0i32.into();
    |                      ^^^^^^^^^^^ help: consider removing `.into()`: `0i32`
 
+error: useless conversion to the same type: `std::str::Lines<'_>`
+  --> $DIR/useless_conversion.rs:45:22
+   |
+LL |     if Some("ok") == lines.into_iter().next() {}
+   |                      ^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `lines`
+
+error: useless conversion to the same type: `std::str::Lines<'_>`
+  --> $DIR/useless_conversion.rs:50:21
+   |
+LL |     let mut lines = text.lines().into_iter();
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `text.lines()`
+
+error: useless conversion to the same type: `std::str::Lines<'_>`
+  --> $DIR/useless_conversion.rs:56:22
+   |
+LL |     if Some("ok") == text.lines().into_iter().next() {}
+   |                      ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `text.lines()`
+
+error: useless conversion to the same type: `std::ops::Range<i32>`
+  --> $DIR/useless_conversion.rs:62:13
+   |
+LL |     let _ = NUMBERS.into_iter().next();
+   |             ^^^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `NUMBERS`
+
+error: useless conversion to the same type: `std::ops::Range<i32>`
+  --> $DIR/useless_conversion.rs:67:17
+   |
+LL |     let mut n = NUMBERS.into_iter();
+   |                 ^^^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `NUMBERS`
+
 error: useless conversion to the same type: `std::string::String`
-  --> $DIR/useless_conversion.rs:61:21
+  --> $DIR/useless_conversion.rs:128:21
    |
 LL |     let _: String = "foo".to_string().into();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into()`: `"foo".to_string()`
 
 error: useless conversion to the same type: `std::string::String`
-  --> $DIR/useless_conversion.rs:62:21
+  --> $DIR/useless_conversion.rs:129:21
    |
 LL |     let _: String = From::from("foo".to_string());
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `From::from()`: `"foo".to_string()`
 
 error: useless conversion to the same type: `std::string::String`
-  --> $DIR/useless_conversion.rs:63:13
+  --> $DIR/useless_conversion.rs:130:13
    |
 LL |     let _ = String::from("foo".to_string());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `String::from()`: `"foo".to_string()`
 
 error: useless conversion to the same type: `std::string::String`
-  --> $DIR/useless_conversion.rs:64:13
+  --> $DIR/useless_conversion.rs:131:13
    |
 LL |     let _ = String::from(format!("A: {:04}", 123));
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `String::from()`: `format!("A: {:04}", 123)`
 
 error: useless conversion to the same type: `std::str::Lines<'_>`
-  --> $DIR/useless_conversion.rs:65:13
+  --> $DIR/useless_conversion.rs:132:13
    |
 LL |     let _ = "".lines().into_iter();
    |             ^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `"".lines()`
 
 error: useless conversion to the same type: `std::vec::IntoIter<i32>`
-  --> $DIR/useless_conversion.rs:66:13
+  --> $DIR/useless_conversion.rs:133:13
    |
 LL |     let _ = vec![1, 2, 3].into_iter().into_iter();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `vec![1, 2, 3].into_iter()`
 
 error: useless conversion to the same type: `std::string::String`
-  --> $DIR/useless_conversion.rs:67:21
+  --> $DIR/useless_conversion.rs:134:21
    |
 LL |     let _: String = format!("Hello {}", "world").into();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into()`: `format!("Hello {}", "world")`
 
 error: useless conversion to the same type: `i32`
-  --> $DIR/useless_conversion.rs:72:13
+  --> $DIR/useless_conversion.rs:139:13
    |
 LL |     let _ = i32::from(a + b) * 3;
    |             ^^^^^^^^^^^^^^^^ help: consider removing `i32::from()`: `(a + b)`
 
 error: useless conversion to the same type: `Foo<'a'>`
-  --> $DIR/useless_conversion.rs:78:23
+  --> $DIR/useless_conversion.rs:145:23
    |
 LL |     let _: Foo<'a'> = s2.into();
    |                       ^^^^^^^^^ help: consider removing `.into()`: `s2`
 
 error: useless conversion to the same type: `Foo<'a'>`
-  --> $DIR/useless_conversion.rs:80:13
+  --> $DIR/useless_conversion.rs:147:13
    |
 LL |     let _ = Foo::<'a'>::from(s3);
    |             ^^^^^^^^^^^^^^^^^^^^ help: consider removing `Foo::<'a'>::from()`: `s3`
 
 error: useless conversion to the same type: `std::vec::IntoIter<Foo<'a'>>`
-  --> $DIR/useless_conversion.rs:82:13
+  --> $DIR/useless_conversion.rs:149:13
    |
 LL |     let _ = vec![s4, s4, s4].into_iter().into_iter();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `vec![s4, s4, s4].into_iter()`
 
-error: aborting due to 14 previous errors
+error: aborting due to 19 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 6afe5471cf3cc78b5ce85d1bbb13a010516c500e Mon Sep 17 00:00:00 2001
From: Niki4tap <rombiklol2@gmail.com>
Date: Sat, 17 Dec 2022 20:22:52 +0300
Subject: Add lint `transmute_null_to_fn`

---
 CHANGELOG.md                                       |  1 +
 clippy_lints/src/declared_lints.rs                 |  1 +
 clippy_lints/src/transmute/mod.rs                  | 31 +++++++++++
 clippy_lints/src/transmute/transmute_null_to_fn.rs | 62 ++++++++++++++++++++++
 tests/ui/transmute_null_to_fn.rs                   | 28 ++++++++++
 tests/ui/transmute_null_to_fn.stderr               | 27 ++++++++++
 6 files changed, 150 insertions(+)
 create mode 100644 clippy_lints/src/transmute/transmute_null_to_fn.rs
 create mode 100644 tests/ui/transmute_null_to_fn.rs
 create mode 100644 tests/ui/transmute_null_to_fn.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 903ee938d9d..3c2801cfb5e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4590,6 +4590,7 @@ Released 2018-09-13
 [`transmute_int_to_bool`]: https://rust-lang.github.io/rust-clippy/master/index.html#transmute_int_to_bool
 [`transmute_int_to_char`]: https://rust-lang.github.io/rust-clippy/master/index.html#transmute_int_to_char
 [`transmute_int_to_float`]: https://rust-lang.github.io/rust-clippy/master/index.html#transmute_int_to_float
+[`transmute_null_to_fn`]: https://rust-lang.github.io/rust-clippy/master/index.html#transmute_null_to_fn
 [`transmute_num_to_bytes`]: https://rust-lang.github.io/rust-clippy/master/index.html#transmute_num_to_bytes
 [`transmute_ptr_to_ptr`]: https://rust-lang.github.io/rust-clippy/master/index.html#transmute_ptr_to_ptr
 [`transmute_ptr_to_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#transmute_ptr_to_ref
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 3cd7d1d7e72..5bae62ce24f 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -568,6 +568,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::transmute::TRANSMUTE_INT_TO_BOOL_INFO,
     crate::transmute::TRANSMUTE_INT_TO_CHAR_INFO,
     crate::transmute::TRANSMUTE_INT_TO_FLOAT_INFO,
+    crate::transmute::TRANSMUTE_NULL_TO_FN_INFO,
     crate::transmute::TRANSMUTE_NUM_TO_BYTES_INFO,
     crate::transmute::TRANSMUTE_PTR_TO_PTR_INFO,
     crate::transmute::TRANSMUTE_PTR_TO_REF_INFO,
diff --git a/clippy_lints/src/transmute/mod.rs b/clippy_lints/src/transmute/mod.rs
index 83e651aba8e..7a2ab2bb4c4 100644
--- a/clippy_lints/src/transmute/mod.rs
+++ b/clippy_lints/src/transmute/mod.rs
@@ -3,6 +3,7 @@ mod transmute_float_to_int;
 mod transmute_int_to_bool;
 mod transmute_int_to_char;
 mod transmute_int_to_float;
+mod transmute_null_to_fn;
 mod transmute_num_to_bytes;
 mod transmute_ptr_to_ptr;
 mod transmute_ptr_to_ref;
@@ -409,6 +410,34 @@ declare_clippy_lint! {
     "transmutes from a null pointer to a reference, which is undefined behavior"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for null function pointer creation through transmute.
+    ///
+    /// ### Why is this bad?
+    /// Creating a null function pointer is undefined behavior.
+    ///
+    /// More info: https://doc.rust-lang.org/nomicon/ffi.html#the-nullable-pointer-optimization
+    ///
+    /// ### Known problems
+    /// Not all cases can be detected at the moment of this writing.
+    /// For example, variables which hold a null pointer and are then fed to a `transmute`
+    /// call, aren't detectable yet.
+    ///
+    /// ### Example
+    /// ```rust
+    /// let null_fn: fn() = unsafe { std::mem::transmute( std::ptr::null() ) };
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// let null_fn: Option<fn()> = None;
+    /// ```
+    #[clippy::version = "1.67.0"]
+    pub TRANSMUTE_NULL_TO_FN,
+    correctness,
+    "transmute results in a null function pointer, which is undefined behavior"
+}
+
 pub struct Transmute {
     msrv: Msrv,
 }
@@ -428,6 +457,7 @@ impl_lint_pass!(Transmute => [
     TRANSMUTES_EXPRESSIBLE_AS_PTR_CASTS,
     TRANSMUTE_UNDEFINED_REPR,
     TRANSMUTING_NULL,
+    TRANSMUTE_NULL_TO_FN,
 ]);
 impl Transmute {
     #[must_use]
@@ -461,6 +491,7 @@ impl<'tcx> LateLintPass<'tcx> for Transmute {
                 let linted = wrong_transmute::check(cx, e, from_ty, to_ty)
                     | crosspointer_transmute::check(cx, e, from_ty, to_ty)
                     | transmuting_null::check(cx, e, arg, to_ty)
+                    | transmute_null_to_fn::check(cx, e, arg, to_ty)
                     | transmute_ptr_to_ref::check(cx, e, from_ty, to_ty, arg, path, &self.msrv)
                     | transmute_int_to_char::check(cx, e, from_ty, to_ty, arg, const_context)
                     | transmute_ref_to_ref::check(cx, e, from_ty, to_ty, arg, const_context)
diff --git a/clippy_lints/src/transmute/transmute_null_to_fn.rs b/clippy_lints/src/transmute/transmute_null_to_fn.rs
new file mode 100644
index 00000000000..db89078f657
--- /dev/null
+++ b/clippy_lints/src/transmute/transmute_null_to_fn.rs
@@ -0,0 +1,62 @@
+use clippy_utils::consts::{constant_context, Constant};
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::{is_integer_literal, is_path_diagnostic_item};
+use rustc_hir::{Expr, ExprKind};
+use rustc_lint::LateContext;
+use rustc_middle::ty::Ty;
+use rustc_span::symbol::sym;
+
+use super::TRANSMUTE_NULL_TO_FN;
+
+const LINT_MSG: &str = "transmuting a known null pointer into a function pointer";
+const NOTE_MSG: &str = "this transmute results in a null function pointer";
+const HELP_MSG: &str =
+    "try wrapping your function pointer type in `Option<T>` instead, and using `None` as a null pointer value";
+
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, arg: &'tcx Expr<'_>, to_ty: Ty<'tcx>) -> bool {
+    if !to_ty.is_fn() {
+        return false;
+    }
+
+    // Catching transmute over constants that resolve to `null`.
+    let mut const_eval_context = constant_context(cx, cx.typeck_results());
+    if let ExprKind::Path(ref _qpath) = arg.kind &&
+        let Some(Constant::RawPtr(x)) = const_eval_context.expr(arg) &&
+        x == 0
+    {
+        span_lint_and_then(cx, TRANSMUTE_NULL_TO_FN, expr.span, LINT_MSG, |diag| {
+            diag.span_label(expr.span, NOTE_MSG);
+            diag.help(HELP_MSG);
+        });
+        return true;
+    }
+
+    // Catching:
+    // `std::mem::transmute(0 as *const i32)`
+    if let ExprKind::Cast(inner_expr, _cast_ty) = arg.kind && is_integer_literal(inner_expr, 0) {
+        span_lint_and_then(cx, TRANSMUTE_NULL_TO_FN, expr.span, LINT_MSG, |diag| {
+            diag.span_label(expr.span, NOTE_MSG);
+            diag.help(HELP_MSG);
+        });
+        return true;
+    }
+
+    // Catching:
+    // `std::mem::transmute(std::ptr::null::<i32>())`
+    if let ExprKind::Call(func1, []) = arg.kind &&
+        is_path_diagnostic_item(cx, func1, sym::ptr_null)
+    {
+        span_lint_and_then(cx, TRANSMUTE_NULL_TO_FN, expr.span, LINT_MSG, |diag| {
+            diag.span_label(expr.span, NOTE_MSG);
+            diag.help(HELP_MSG);
+        });
+        return true;
+    }
+
+    // FIXME:
+    // Also catch transmutations of variables which are known nulls.
+    // To do this, MIR const propagation seems to be the better tool.
+    // Whenever MIR const prop routines are more developed, this will
+    // become available. As of this writing (25/03/19) it is not yet.
+    false
+}
diff --git a/tests/ui/transmute_null_to_fn.rs b/tests/ui/transmute_null_to_fn.rs
new file mode 100644
index 00000000000..b3ea3d9039e
--- /dev/null
+++ b/tests/ui/transmute_null_to_fn.rs
@@ -0,0 +1,28 @@
+#![allow(dead_code)]
+#![warn(clippy::transmute_null_to_fn)]
+#![allow(clippy::zero_ptr)]
+
+// Easy to lint because these only span one line.
+fn one_liners() {
+    unsafe {
+        let _: fn() = std::mem::transmute(0 as *const ());
+        let _: fn() = std::mem::transmute(std::ptr::null::<()>());
+    }
+}
+
+pub const ZPTR: *const usize = 0 as *const _;
+pub const NOT_ZPTR: *const usize = 1 as *const _;
+
+fn transmute_const() {
+    unsafe {
+        // Should raise a lint.
+        let _: fn() = std::mem::transmute(ZPTR);
+        // Should NOT raise a lint.
+        let _: fn() = std::mem::transmute(NOT_ZPTR);
+    }
+}
+
+fn main() {
+    one_liners();
+    transmute_const();
+}
diff --git a/tests/ui/transmute_null_to_fn.stderr b/tests/ui/transmute_null_to_fn.stderr
new file mode 100644
index 00000000000..f0c65497d75
--- /dev/null
+++ b/tests/ui/transmute_null_to_fn.stderr
@@ -0,0 +1,27 @@
+error: transmuting a known null pointer into a function pointer
+  --> $DIR/transmute_null_to_fn.rs:8:23
+   |
+LL |         let _: fn() = std::mem::transmute(0 as *const ());
+   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this transmute results in undefined behavior
+   |
+   = help: try wrapping your function pointer type in `Option<T>` instead, and using `None` as a null pointer value
+   = note: `-D clippy::transmute-null-to-fn` implied by `-D warnings`
+
+error: transmuting a known null pointer into a function pointer
+  --> $DIR/transmute_null_to_fn.rs:9:23
+   |
+LL |         let _: fn() = std::mem::transmute(std::ptr::null::<()>());
+   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this transmute results in undefined behavior
+   |
+   = help: try wrapping your function pointer type in `Option<T>` instead, and using `None` as a null pointer value
+
+error: transmuting a known null pointer into a function pointer
+  --> $DIR/transmute_null_to_fn.rs:19:23
+   |
+LL |         let _: fn() = std::mem::transmute(ZPTR);
+   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^ this transmute results in undefined behavior
+   |
+   = help: try wrapping your function pointer type in `Option<T>` instead, and using `None` as a null pointer value
+
+error: aborting due to 3 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 3cc67d08569b5cf847242532f99c5aca838dbdeb Mon Sep 17 00:00:00 2001
From: Niki4tap <rombiklol2@gmail.com>
Date: Sun, 18 Dec 2022 02:14:09 +0300
Subject: Relax clippy_utils::consts::miri_to_const pointer type
 restrictiveness

---
 clippy_lints/src/lib.rs    | 2 ++
 clippy_utils/src/consts.rs | 7 +------
 2 files changed, 3 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 39850d59803..7f7d73339e4 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -125,6 +125,7 @@ mod explicit_write;
 mod fallible_impl_from;
 mod float_literal;
 mod floating_point_arithmetic;
+mod fn_null_check;
 mod format;
 mod format_args;
 mod format_impl;
@@ -902,6 +903,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(suspicious_xor_used_as_pow::ConfusingXorAndPow));
     store.register_late_pass(move |_| Box::new(manual_is_ascii_check::ManualIsAsciiCheck::new(msrv())));
     store.register_late_pass(|_| Box::new(semicolon_block::SemicolonBlock));
+    store.register_late_pass(|_| Box::new(fn_null_check::FnNullCheck));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_utils/src/consts.rs b/clippy_utils/src/consts.rs
index 7a637d32bab..a67bd8d4600 100644
--- a/clippy_utils/src/consts.rs
+++ b/clippy_utils/src/consts.rs
@@ -620,12 +620,7 @@ pub fn miri_to_const<'tcx>(tcx: TyCtxt<'tcx>, result: mir::ConstantKind<'tcx>) -
                 ty::Float(FloatTy::F64) => Some(Constant::F64(f64::from_bits(
                     int.try_into().expect("invalid f64 bit representation"),
                 ))),
-                ty::RawPtr(type_and_mut) => {
-                    if let ty::Uint(_) = type_and_mut.ty.kind() {
-                        return Some(Constant::RawPtr(int.assert_bits(int.size())));
-                    }
-                    None
-                },
+                ty::RawPtr(_) => Some(Constant::RawPtr(int.assert_bits(int.size()))),
                 // FIXME: implement other conversions.
                 _ => None,
             }
-- 
cgit 1.4.1-3-g733a5


From 42106e04951f409c88131a42a0514af479ecb932 Mon Sep 17 00:00:00 2001
From: Niki4tap <rombiklol2@gmail.com>
Date: Sun, 18 Dec 2022 02:16:04 +0300
Subject: Add lint `fn_null_check`

---
 CHANGELOG.md                                       |   1 +
 clippy_lints/src/declared_lints.rs                 |   1 +
 clippy_lints/src/fn_null_check.rs                  | 129 +++++++++++++++++++++
 clippy_lints/src/transmute/transmute_null_to_fn.rs |   2 +-
 tests/ui/fn_null_check.rs                          |  21 ++++
 tests/ui/fn_null_check.stderr                      |  43 +++++++
 6 files changed, 196 insertions(+), 1 deletion(-)
 create mode 100644 clippy_lints/src/fn_null_check.rs
 create mode 100644 tests/ui/fn_null_check.rs
 create mode 100644 tests/ui/fn_null_check.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 3c2801cfb5e..17ff182c7be 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4203,6 +4203,7 @@ Released 2018-09-13
 [`float_cmp_const`]: https://rust-lang.github.io/rust-clippy/master/index.html#float_cmp_const
 [`float_equality_without_abs`]: https://rust-lang.github.io/rust-clippy/master/index.html#float_equality_without_abs
 [`fn_address_comparisons`]: https://rust-lang.github.io/rust-clippy/master/index.html#fn_address_comparisons
+[`fn_null_check`]: https://rust-lang.github.io/rust-clippy/master/index.html#fn_null_check
 [`fn_params_excessive_bools`]: https://rust-lang.github.io/rust-clippy/master/index.html#fn_params_excessive_bools
 [`fn_to_numeric_cast`]: https://rust-lang.github.io/rust-clippy/master/index.html#fn_to_numeric_cast
 [`fn_to_numeric_cast_any`]: https://rust-lang.github.io/rust-clippy/master/index.html#fn_to_numeric_cast_any
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 5bae62ce24f..480a65ac70c 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -161,6 +161,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::float_literal::LOSSY_FLOAT_LITERAL_INFO,
     crate::floating_point_arithmetic::IMPRECISE_FLOPS_INFO,
     crate::floating_point_arithmetic::SUBOPTIMAL_FLOPS_INFO,
+    crate::fn_null_check::FN_NULL_CHECK_INFO,
     crate::format::USELESS_FORMAT_INFO,
     crate::format_args::FORMAT_IN_FORMAT_ARGS_INFO,
     crate::format_args::TO_STRING_IN_FORMAT_ARGS_INFO,
diff --git a/clippy_lints/src/fn_null_check.rs b/clippy_lints/src/fn_null_check.rs
new file mode 100644
index 00000000000..d0e82500dd0
--- /dev/null
+++ b/clippy_lints/src/fn_null_check.rs
@@ -0,0 +1,129 @@
+use clippy_utils::consts::{constant, Constant};
+use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::{is_integer_literal, is_path_diagnostic_item};
+use if_chain::if_chain;
+use rustc_hir::{BinOpKind, Expr, ExprKind, TyKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::sym;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for comparing a function pointer to null.
+    ///
+    /// ### Why is this bad?
+    /// Function pointers are assumed to not be null.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// let fn_ptr: fn() = /* somehow obtained nullable function pointer */
+    ///
+    /// if (fn_ptr as *const ()).is_null() { ... }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// let fn_ptr: Option<fn()> = /* somehow obtained nullable function pointer */
+    ///
+    /// if fn_ptr.is_none() { ... }
+    /// ```
+    #[clippy::version = "1.67.0"]
+    pub FN_NULL_CHECK,
+    correctness,
+    "`fn()` type assumed to be nullable"
+}
+declare_lint_pass!(FnNullCheck => [FN_NULL_CHECK]);
+
+const LINT_MSG: &str = "function pointer assumed to be nullable, even though it isn't";
+const HELP_MSG: &str = "try wrapping your function pointer type in `Option<T>` instead, and using `is_none` to check for null pointer value";
+
+fn is_fn_ptr_cast(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+    if_chain! {
+        if let ExprKind::Cast(cast_expr, cast_ty) = expr.kind;
+        if let TyKind::Ptr(_) = cast_ty.kind;
+        if cx.typeck_results().expr_ty_adjusted(cast_expr).is_fn();
+        then {
+            true
+        } else {
+            false
+        }
+    }
+}
+
+impl<'tcx> LateLintPass<'tcx> for FnNullCheck {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        // Catching:
+        // (fn_ptr as *<const/mut> <ty>).is_null()
+        if_chain! {
+            if let ExprKind::MethodCall(method_name, receiver, _, _) = expr.kind;
+            if method_name.ident.as_str() == "is_null";
+            if is_fn_ptr_cast(cx, receiver);
+            then {
+                span_lint_and_help(
+                    cx,
+                    FN_NULL_CHECK,
+                    expr.span,
+                    LINT_MSG,
+                    None,
+                    HELP_MSG
+                );
+            }
+        }
+
+        if let ExprKind::Binary(op, left, right) = expr.kind
+            && let BinOpKind::Eq = op.node
+        {
+            let to_check: &Expr<'_>;
+            if is_fn_ptr_cast(cx, left) {
+                to_check = right;
+            } else if is_fn_ptr_cast(cx, right) {
+                to_check = left;
+            } else {
+                return;
+            }
+
+            // Catching:
+            // (fn_ptr as *<const/mut> <ty>) == <const that evaluates to null_ptr>
+            let c = constant(cx, cx.typeck_results(), to_check);
+            if let Some((Constant::RawPtr(0), _)) = c {
+                span_lint_and_help(
+                    cx,
+                    FN_NULL_CHECK,
+                    expr.span,
+                    LINT_MSG,
+                    None,
+                    HELP_MSG
+                );
+                return;
+            }
+
+            // Catching:
+            // (fn_ptr as *<const/mut> <ty>) == (0 as <ty>)
+            if let ExprKind::Cast(cast_expr, _) = to_check.kind && is_integer_literal(cast_expr, 0) {
+                span_lint_and_help(
+                    cx,
+                    FN_NULL_CHECK,
+                    expr.span,
+                    LINT_MSG,
+                    None,
+                    HELP_MSG
+                );
+                return;
+            }
+
+            // Catching:
+            // (fn_ptr as *<const/mut> <ty>) == std::ptr::null()
+            if let ExprKind::Call(func, []) = to_check.kind &&
+                is_path_diagnostic_item(cx, func, sym::ptr_null)
+            {
+                span_lint_and_help(
+                    cx,
+                    FN_NULL_CHECK,
+                    expr.span,
+                    LINT_MSG,
+                    None,
+                    HELP_MSG
+                );
+            }
+        }
+    }
+}
diff --git a/clippy_lints/src/transmute/transmute_null_to_fn.rs b/clippy_lints/src/transmute/transmute_null_to_fn.rs
index db89078f657..032b4c1e2d2 100644
--- a/clippy_lints/src/transmute/transmute_null_to_fn.rs
+++ b/clippy_lints/src/transmute/transmute_null_to_fn.rs
@@ -9,7 +9,7 @@ use rustc_span::symbol::sym;
 use super::TRANSMUTE_NULL_TO_FN;
 
 const LINT_MSG: &str = "transmuting a known null pointer into a function pointer";
-const NOTE_MSG: &str = "this transmute results in a null function pointer";
+const NOTE_MSG: &str = "this transmute results in undefined behavior";
 const HELP_MSG: &str =
     "try wrapping your function pointer type in `Option<T>` instead, and using `None` as a null pointer value";
 
diff --git a/tests/ui/fn_null_check.rs b/tests/ui/fn_null_check.rs
new file mode 100644
index 00000000000..df5bc8420d5
--- /dev/null
+++ b/tests/ui/fn_null_check.rs
@@ -0,0 +1,21 @@
+#![allow(unused)]
+#![warn(clippy::fn_null_check)]
+#![allow(clippy::cmp_null)]
+#![allow(clippy::ptr_eq)]
+#![allow(clippy::zero_ptr)]
+
+pub const ZPTR: *const () = 0 as *const _;
+pub const NOT_ZPTR: *const () = 1 as *const _;
+
+fn main() {
+    let fn_ptr = main;
+
+    if (fn_ptr as *mut ()).is_null() {}
+    if (fn_ptr as *const u8).is_null() {}
+    if (fn_ptr as *const ()) == std::ptr::null() {}
+    if (fn_ptr as *const ()) == (0 as *const ()) {}
+    if (fn_ptr as *const ()) == ZPTR {}
+
+    // no lint
+    if (fn_ptr as *const ()) == NOT_ZPTR {}
+}
diff --git a/tests/ui/fn_null_check.stderr b/tests/ui/fn_null_check.stderr
new file mode 100644
index 00000000000..660dd323979
--- /dev/null
+++ b/tests/ui/fn_null_check.stderr
@@ -0,0 +1,43 @@
+error: function pointer assumed to be nullable, even though it isn't
+  --> $DIR/fn_null_check.rs:13:8
+   |
+LL |     if (fn_ptr as *mut ()).is_null() {}
+   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: try wrapping your function pointer type in `Option<T>` instead, and using `is_none` to check for null pointer value
+   = note: `-D clippy::fn-null-check` implied by `-D warnings`
+
+error: function pointer assumed to be nullable, even though it isn't
+  --> $DIR/fn_null_check.rs:14:8
+   |
+LL |     if (fn_ptr as *const u8).is_null() {}
+   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: try wrapping your function pointer type in `Option<T>` instead, and using `is_none` to check for null pointer value
+
+error: function pointer assumed to be nullable, even though it isn't
+  --> $DIR/fn_null_check.rs:15:8
+   |
+LL |     if (fn_ptr as *const ()) == std::ptr::null() {}
+   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: try wrapping your function pointer type in `Option<T>` instead, and using `is_none` to check for null pointer value
+
+error: function pointer assumed to be nullable, even though it isn't
+  --> $DIR/fn_null_check.rs:16:8
+   |
+LL |     if (fn_ptr as *const ()) == (0 as *const ()) {}
+   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: try wrapping your function pointer type in `Option<T>` instead, and using `is_none` to check for null pointer value
+
+error: function pointer assumed to be nullable, even though it isn't
+  --> $DIR/fn_null_check.rs:17:8
+   |
+LL |     if (fn_ptr as *const ()) == ZPTR {}
+   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: try wrapping your function pointer type in `Option<T>` instead, and using `is_none` to check for null pointer value
+
+error: aborting due to 5 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 54a9168efb9d1a34e8430199d20a7fd5db032e7b Mon Sep 17 00:00:00 2001
From: Niki4tap <rombiklol2@gmail.com>
Date: Sun, 18 Dec 2022 02:25:21 +0300
Subject: Remove useless pattern matching

---
 clippy_lints/src/transmute/transmute_null_to_fn.rs | 3 +--
 clippy_lints/src/transmute/transmuting_null.rs     | 3 +--
 2 files changed, 2 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/transmute/transmute_null_to_fn.rs b/clippy_lints/src/transmute/transmute_null_to_fn.rs
index 032b4c1e2d2..2286e17fd16 100644
--- a/clippy_lints/src/transmute/transmute_null_to_fn.rs
+++ b/clippy_lints/src/transmute/transmute_null_to_fn.rs
@@ -21,8 +21,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, arg: &'t
     // Catching transmute over constants that resolve to `null`.
     let mut const_eval_context = constant_context(cx, cx.typeck_results());
     if let ExprKind::Path(ref _qpath) = arg.kind &&
-        let Some(Constant::RawPtr(x)) = const_eval_context.expr(arg) &&
-        x == 0
+        let Some(Constant::RawPtr(0)) = const_eval_context.expr(arg)
     {
         span_lint_and_then(cx, TRANSMUTE_NULL_TO_FN, expr.span, LINT_MSG, |diag| {
             diag.span_label(expr.span, NOTE_MSG);
diff --git a/clippy_lints/src/transmute/transmuting_null.rs b/clippy_lints/src/transmute/transmuting_null.rs
index 19ce5ae72c2..1e407fc4138 100644
--- a/clippy_lints/src/transmute/transmuting_null.rs
+++ b/clippy_lints/src/transmute/transmuting_null.rs
@@ -18,8 +18,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, arg: &'t
     // Catching transmute over constants that resolve to `null`.
     let mut const_eval_context = constant_context(cx, cx.typeck_results());
     if let ExprKind::Path(ref _qpath) = arg.kind &&
-        let Some(Constant::RawPtr(x)) = const_eval_context.expr(arg) &&
-        x == 0
+        let Some(Constant::RawPtr(0)) = const_eval_context.expr(arg)
     {
         span_lint(cx, TRANSMUTING_NULL, expr.span, LINT_MSG);
         return true;
-- 
cgit 1.4.1-3-g733a5


From dae54fad3ee4b51ed286d4686f6d064b48b56cca Mon Sep 17 00:00:00 2001
From: Niki4tap <rombiklol2@gmail.com>
Date: Sun, 18 Dec 2022 03:20:04 +0300
Subject: Doc codeblock fixup

---
 clippy_lints/src/fn_null_check.rs | 2 +-
 clippy_lints/src/transmute/mod.rs | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/fn_null_check.rs b/clippy_lints/src/fn_null_check.rs
index d0e82500dd0..89841936954 100644
--- a/clippy_lints/src/fn_null_check.rs
+++ b/clippy_lints/src/fn_null_check.rs
@@ -21,7 +21,7 @@ declare_clippy_lint! {
     /// if (fn_ptr as *const ()).is_null() { ... }
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```rust,ignore
     /// let fn_ptr: Option<fn()> = /* somehow obtained nullable function pointer */
     ///
     /// if fn_ptr.is_none() { ... }
diff --git a/clippy_lints/src/transmute/mod.rs b/clippy_lints/src/transmute/mod.rs
index 7a2ab2bb4c4..691d759d773 100644
--- a/clippy_lints/src/transmute/mod.rs
+++ b/clippy_lints/src/transmute/mod.rs
@@ -426,7 +426,7 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust
-    /// let null_fn: fn() = unsafe { std::mem::transmute( std::ptr::null() ) };
+    /// let null_fn: fn() = unsafe { std::mem::transmute( std::ptr::null::<()>() ) };
     /// ```
     /// Use instead:
     /// ```rust
-- 
cgit 1.4.1-3-g733a5


From b1ca307168b622d66a7f0d66421933236bb8cbcf Mon Sep 17 00:00:00 2001
From: Niki4tap <rombiklol2@gmail.com>
Date: Sun, 18 Dec 2022 18:58:15 +0300
Subject: Address some of the code style issues

---
 clippy_lints/src/fn_null_check.rs                  | 75 ++++++++--------------
 clippy_lints/src/transmute/transmute_null_to_fn.rs |  3 +-
 2 files changed, 27 insertions(+), 51 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/fn_null_check.rs b/clippy_lints/src/fn_null_check.rs
index 89841936954..f4b7a55fa74 100644
--- a/clippy_lints/src/fn_null_check.rs
+++ b/clippy_lints/src/fn_null_check.rs
@@ -1,7 +1,6 @@
 use clippy_utils::consts::{constant, Constant};
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::{is_integer_literal, is_path_diagnostic_item};
-use if_chain::if_chain;
 use rustc_hir::{BinOpKind, Expr, ExprKind, TyKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -33,19 +32,24 @@ declare_clippy_lint! {
 }
 declare_lint_pass!(FnNullCheck => [FN_NULL_CHECK]);
 
-const LINT_MSG: &str = "function pointer assumed to be nullable, even though it isn't";
-const HELP_MSG: &str = "try wrapping your function pointer type in `Option<T>` instead, and using `is_none` to check for null pointer value";
+fn lint_expr(cx: &LateContext<'_>, expr: &Expr<'_>) {
+    span_lint_and_help(
+        cx,
+        FN_NULL_CHECK,
+        expr.span,
+        "function pointer assumed to be nullable, even though it isn't",
+        None,
+        "try wrapping your function pointer type in `Option<T>` instead, and using `is_none` to check for null pointer value",
+    )
+}
 
 fn is_fn_ptr_cast(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-    if_chain! {
-        if let ExprKind::Cast(cast_expr, cast_ty) = expr.kind;
-        if let TyKind::Ptr(_) = cast_ty.kind;
-        if cx.typeck_results().expr_ty_adjusted(cast_expr).is_fn();
-        then {
-            true
-        } else {
-            false
-        }
+    if let ExprKind::Cast(cast_expr, cast_ty) = expr.kind
+        && let TyKind::Ptr(_) = cast_ty.kind
+    {
+        cx.typeck_results().expr_ty_adjusted(cast_expr).is_fn()
+    } else {
+        false
     }
 }
 
@@ -53,20 +57,12 @@ impl<'tcx> LateLintPass<'tcx> for FnNullCheck {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         // Catching:
         // (fn_ptr as *<const/mut> <ty>).is_null()
-        if_chain! {
-            if let ExprKind::MethodCall(method_name, receiver, _, _) = expr.kind;
-            if method_name.ident.as_str() == "is_null";
-            if is_fn_ptr_cast(cx, receiver);
-            then {
-                span_lint_and_help(
-                    cx,
-                    FN_NULL_CHECK,
-                    expr.span,
-                    LINT_MSG,
-                    None,
-                    HELP_MSG
-                );
-            }
+        if let ExprKind::MethodCall(method_name, receiver, _, _) = expr.kind
+            && method_name.ident.as_str() == "is_null"
+            && is_fn_ptr_cast(cx, receiver)
+        {
+                lint_expr(cx, expr);
+                return;
         }
 
         if let ExprKind::Binary(op, left, right) = expr.kind
@@ -85,28 +81,14 @@ impl<'tcx> LateLintPass<'tcx> for FnNullCheck {
             // (fn_ptr as *<const/mut> <ty>) == <const that evaluates to null_ptr>
             let c = constant(cx, cx.typeck_results(), to_check);
             if let Some((Constant::RawPtr(0), _)) = c {
-                span_lint_and_help(
-                    cx,
-                    FN_NULL_CHECK,
-                    expr.span,
-                    LINT_MSG,
-                    None,
-                    HELP_MSG
-                );
+                lint_expr(cx, expr);
                 return;
             }
 
             // Catching:
             // (fn_ptr as *<const/mut> <ty>) == (0 as <ty>)
             if let ExprKind::Cast(cast_expr, _) = to_check.kind && is_integer_literal(cast_expr, 0) {
-                span_lint_and_help(
-                    cx,
-                    FN_NULL_CHECK,
-                    expr.span,
-                    LINT_MSG,
-                    None,
-                    HELP_MSG
-                );
+                lint_expr(cx, expr);
                 return;
             }
 
@@ -115,14 +97,7 @@ impl<'tcx> LateLintPass<'tcx> for FnNullCheck {
             if let ExprKind::Call(func, []) = to_check.kind &&
                 is_path_diagnostic_item(cx, func, sym::ptr_null)
             {
-                span_lint_and_help(
-                    cx,
-                    FN_NULL_CHECK,
-                    expr.span,
-                    LINT_MSG,
-                    None,
-                    HELP_MSG
-                );
+                lint_expr(cx, expr);
             }
         }
     }
diff --git a/clippy_lints/src/transmute/transmute_null_to_fn.rs b/clippy_lints/src/transmute/transmute_null_to_fn.rs
index 2286e17fd16..074a5d31763 100644
--- a/clippy_lints/src/transmute/transmute_null_to_fn.rs
+++ b/clippy_lints/src/transmute/transmute_null_to_fn.rs
@@ -18,7 +18,8 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, arg: &'t
         return false;
     }
 
-    // Catching transmute over constants that resolve to `null`.
+    // Catching:
+    // transmute over constants that resolve to `null`.
     let mut const_eval_context = constant_context(cx, cx.typeck_results());
     if let ExprKind::Path(ref _qpath) = arg.kind &&
         let Some(Constant::RawPtr(0)) = const_eval_context.expr(arg)
-- 
cgit 1.4.1-3-g733a5


From 9b2fc8e2a2da497344d42ccf8ddefc794eb82858 Mon Sep 17 00:00:00 2001
From: Niki4tap <rombiklol2@gmail.com>
Date: Sun, 18 Dec 2022 19:43:26 +0300
Subject: Make clippy happy

---
 clippy_lints/src/fn_null_check.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/fn_null_check.rs b/clippy_lints/src/fn_null_check.rs
index f4b7a55fa74..6eb5ddd94d7 100644
--- a/clippy_lints/src/fn_null_check.rs
+++ b/clippy_lints/src/fn_null_check.rs
@@ -40,7 +40,7 @@ fn lint_expr(cx: &LateContext<'_>, expr: &Expr<'_>) {
         "function pointer assumed to be nullable, even though it isn't",
         None,
         "try wrapping your function pointer type in `Option<T>` instead, and using `is_none` to check for null pointer value",
-    )
+    );
 }
 
 fn is_fn_ptr_cast(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-- 
cgit 1.4.1-3-g733a5


From 20f501a9d9f253bfe503388755bdebfe72910e0e Mon Sep 17 00:00:00 2001
From: Niki4tap <rombiklol2@gmail.com>
Date: Sun, 18 Dec 2022 22:39:06 +0300
Subject: Improve code style further

---
 clippy_lints/src/fn_null_check.rs                  | 78 +++++++++++-----------
 clippy_lints/src/transmute/transmute_null_to_fn.rs | 69 ++++++++++---------
 2 files changed, 73 insertions(+), 74 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/fn_null_check.rs b/clippy_lints/src/fn_null_check.rs
index 6eb5ddd94d7..4f79ce6f8fe 100644
--- a/clippy_lints/src/fn_null_check.rs
+++ b/clippy_lints/src/fn_null_check.rs
@@ -55,50 +55,50 @@ fn is_fn_ptr_cast(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
 
 impl<'tcx> LateLintPass<'tcx> for FnNullCheck {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        // Catching:
-        // (fn_ptr as *<const/mut> <ty>).is_null()
-        if let ExprKind::MethodCall(method_name, receiver, _, _) = expr.kind
-            && method_name.ident.as_str() == "is_null"
-            && is_fn_ptr_cast(cx, receiver)
-        {
+        match expr.kind {
+            ExprKind::MethodCall(method_name, receiver, _, _)
+                if method_name.ident.as_str() == "is_null" && is_fn_ptr_cast(cx, receiver) =>
+            {
                 lint_expr(cx, expr);
-                return;
-        }
+            },
 
-        if let ExprKind::Binary(op, left, right) = expr.kind
-            && let BinOpKind::Eq = op.node
-        {
-            let to_check: &Expr<'_>;
-            if is_fn_ptr_cast(cx, left) {
-                to_check = right;
-            } else if is_fn_ptr_cast(cx, right) {
-                to_check = left;
-            } else {
-                return;
-            }
+            ExprKind::Binary(op, left, right) if matches!(op.node, BinOpKind::Eq) => {
+                let to_check: &Expr<'_>;
+                if is_fn_ptr_cast(cx, left) {
+                    to_check = right;
+                } else if is_fn_ptr_cast(cx, right) {
+                    to_check = left;
+                } else {
+                    return;
+                }
 
-            // Catching:
-            // (fn_ptr as *<const/mut> <ty>) == <const that evaluates to null_ptr>
-            let c = constant(cx, cx.typeck_results(), to_check);
-            if let Some((Constant::RawPtr(0), _)) = c {
-                lint_expr(cx, expr);
-                return;
-            }
+                match to_check.kind {
+                    // Catching:
+                    // (fn_ptr as *<const/mut> <ty>) == (0 as <ty>)
+                    ExprKind::Cast(cast_expr, _) if is_integer_literal(cast_expr, 0) => {
+                        lint_expr(cx, expr);
+                    },
 
-            // Catching:
-            // (fn_ptr as *<const/mut> <ty>) == (0 as <ty>)
-            if let ExprKind::Cast(cast_expr, _) = to_check.kind && is_integer_literal(cast_expr, 0) {
-                lint_expr(cx, expr);
-                return;
-            }
+                    // Catching:
+                    // (fn_ptr as *<const/mut> <ty>) == std::ptr::null()
+                    ExprKind::Call(func, []) if is_path_diagnostic_item(cx, func, sym::ptr_null) => {
+                        lint_expr(cx, expr);
+                    },
 
-            // Catching:
-            // (fn_ptr as *<const/mut> <ty>) == std::ptr::null()
-            if let ExprKind::Call(func, []) = to_check.kind &&
-                is_path_diagnostic_item(cx, func, sym::ptr_null)
-            {
-                lint_expr(cx, expr);
-            }
+                    // Catching:
+                    // (fn_ptr as *<const/mut> <ty>) == <const that evaluates to null_ptr>
+                    _ if matches!(
+                        constant(cx, cx.typeck_results(), to_check),
+                        Some((Constant::RawPtr(0), _))
+                    ) =>
+                    {
+                        lint_expr(cx, expr);
+                    },
+
+                    _ => {},
+                }
+            },
+            _ => {},
         }
     }
 }
diff --git a/clippy_lints/src/transmute/transmute_null_to_fn.rs b/clippy_lints/src/transmute/transmute_null_to_fn.rs
index 074a5d31763..79d8cb084fd 100644
--- a/clippy_lints/src/transmute/transmute_null_to_fn.rs
+++ b/clippy_lints/src/transmute/transmute_null_to_fn.rs
@@ -13,6 +13,13 @@ const NOTE_MSG: &str = "this transmute results in undefined behavior";
 const HELP_MSG: &str =
     "try wrapping your function pointer type in `Option<T>` instead, and using `None` as a null pointer value";
 
+fn lint_expr(cx: &LateContext<'_>, expr: &Expr<'_>) {
+    span_lint_and_then(cx, TRANSMUTE_NULL_TO_FN, expr.span, LINT_MSG, |diag| {
+        diag.span_label(expr.span, NOTE_MSG);
+        diag.help(HELP_MSG);
+    });
+}
+
 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, arg: &'tcx Expr<'_>, to_ty: Ty<'tcx>) -> bool {
     if !to_ty.is_fn() {
         return false;
@@ -21,42 +28,34 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, arg: &'t
     // Catching:
     // transmute over constants that resolve to `null`.
     let mut const_eval_context = constant_context(cx, cx.typeck_results());
-    if let ExprKind::Path(ref _qpath) = arg.kind &&
-        let Some(Constant::RawPtr(0)) = const_eval_context.expr(arg)
-    {
-        span_lint_and_then(cx, TRANSMUTE_NULL_TO_FN, expr.span, LINT_MSG, |diag| {
-            diag.span_label(expr.span, NOTE_MSG);
-            diag.help(HELP_MSG);
-        });
-        return true;
-    }
 
-    // Catching:
-    // `std::mem::transmute(0 as *const i32)`
-    if let ExprKind::Cast(inner_expr, _cast_ty) = arg.kind && is_integer_literal(inner_expr, 0) {
-        span_lint_and_then(cx, TRANSMUTE_NULL_TO_FN, expr.span, LINT_MSG, |diag| {
-            diag.span_label(expr.span, NOTE_MSG);
-            diag.help(HELP_MSG);
-        });
-        return true;
-    }
+    match arg.kind {
+        ExprKind::Path(ref _qpath) if matches!(const_eval_context.expr(arg), Some(Constant::RawPtr(0))) => {
+            lint_expr(cx, expr);
+            true
+        },
 
-    // Catching:
-    // `std::mem::transmute(std::ptr::null::<i32>())`
-    if let ExprKind::Call(func1, []) = arg.kind &&
-        is_path_diagnostic_item(cx, func1, sym::ptr_null)
-    {
-        span_lint_and_then(cx, TRANSMUTE_NULL_TO_FN, expr.span, LINT_MSG, |diag| {
-            diag.span_label(expr.span, NOTE_MSG);
-            diag.help(HELP_MSG);
-        });
-        return true;
-    }
+        // Catching:
+        // `std::mem::transmute(0 as *const i32)`
+        ExprKind::Cast(inner_expr, _cast_ty) if is_integer_literal(inner_expr, 0) => {
+            lint_expr(cx, expr);
+            true
+        },
 
-    // FIXME:
-    // Also catch transmutations of variables which are known nulls.
-    // To do this, MIR const propagation seems to be the better tool.
-    // Whenever MIR const prop routines are more developed, this will
-    // become available. As of this writing (25/03/19) it is not yet.
-    false
+        // Catching:
+        // `std::mem::transmute(std::ptr::null::<i32>())`
+        ExprKind::Call(func1, []) if is_path_diagnostic_item(cx, func1, sym::ptr_null) => {
+            lint_expr(cx, expr);
+            true
+        },
+
+        _ => {
+            // FIXME:
+            // Also catch transmutations of variables which are known nulls.
+            // To do this, MIR const propagation seems to be the better tool.
+            // Whenever MIR const prop routines are more developed, this will
+            // become available. As of this writing (25/03/19) it is not yet.
+            false
+        },
+    }
 }
-- 
cgit 1.4.1-3-g733a5


From cc985748838c64b7bf4a3be635026bfffb02088c Mon Sep 17 00:00:00 2001
From: Niki4tap <rombiklol2@gmail.com>
Date: Sun, 18 Dec 2022 22:47:02 +0300
Subject: Fix comments, use `constant` instead of raw `constant_context`

---
 clippy_lints/src/fn_null_check.rs                  |  2 ++
 clippy_lints/src/transmute/transmute_null_to_fn.rs | 12 ++++++------
 2 files changed, 8 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/fn_null_check.rs b/clippy_lints/src/fn_null_check.rs
index 4f79ce6f8fe..91c8c340ce2 100644
--- a/clippy_lints/src/fn_null_check.rs
+++ b/clippy_lints/src/fn_null_check.rs
@@ -56,6 +56,8 @@ fn is_fn_ptr_cast(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
 impl<'tcx> LateLintPass<'tcx> for FnNullCheck {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         match expr.kind {
+            // Catching:
+            // (fn_ptr as *<const/mut> <ty>).is_null()
             ExprKind::MethodCall(method_name, receiver, _, _)
                 if method_name.ident.as_str() == "is_null" && is_fn_ptr_cast(cx, receiver) =>
             {
diff --git a/clippy_lints/src/transmute/transmute_null_to_fn.rs b/clippy_lints/src/transmute/transmute_null_to_fn.rs
index 79d8cb084fd..410c9eaaba0 100644
--- a/clippy_lints/src/transmute/transmute_null_to_fn.rs
+++ b/clippy_lints/src/transmute/transmute_null_to_fn.rs
@@ -1,4 +1,4 @@
-use clippy_utils::consts::{constant_context, Constant};
+use clippy_utils::consts::{constant, Constant};
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::{is_integer_literal, is_path_diagnostic_item};
 use rustc_hir::{Expr, ExprKind};
@@ -25,12 +25,12 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, arg: &'t
         return false;
     }
 
-    // Catching:
-    // transmute over constants that resolve to `null`.
-    let mut const_eval_context = constant_context(cx, cx.typeck_results());
-
     match arg.kind {
-        ExprKind::Path(ref _qpath) if matches!(const_eval_context.expr(arg), Some(Constant::RawPtr(0))) => {
+        // Catching:
+        // transmute over constants that resolve to `null`.
+        ExprKind::Path(ref _qpath)
+            if matches!(constant(cx, cx.typeck_results(), arg), Some((Constant::RawPtr(0), _))) =>
+        {
             lint_expr(cx, expr);
             true
         },
-- 
cgit 1.4.1-3-g733a5


From 62061b8a05751c8d0075c6eeebb827b3e8e0201e Mon Sep 17 00:00:00 2001
From: Philipp Krones <hello@philkrones.com>
Date: Mon, 19 Dec 2022 09:44:56 +0100
Subject: Move manual_clamp to nursery

---
 clippy_lints/src/manual_clamp.rs | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_clamp.rs b/clippy_lints/src/manual_clamp.rs
index bb6d628af3b..f239736d38a 100644
--- a/clippy_lints/src/manual_clamp.rs
+++ b/clippy_lints/src/manual_clamp.rs
@@ -35,6 +35,9 @@ declare_clippy_lint! {
     /// Some may consider panicking in these situations to be desirable, but it also may
     /// introduce panicking where there wasn't any before.
     ///
+    /// See also [the discussion in the
+    /// PR](https://github.com/rust-lang/rust-clippy/pull/9484#issuecomment-1278922613).
+    ///
     /// ### Examples
     /// ```rust
     /// # let (input, min, max) = (0, -2, 1);
@@ -78,7 +81,7 @@ declare_clippy_lint! {
     /// ```
     #[clippy::version = "1.66.0"]
     pub MANUAL_CLAMP,
-    complexity,
+    nursery,
     "using a clamp pattern instead of the clamp function"
 }
 impl_lint_pass!(ManualClamp => [MANUAL_CLAMP]);
-- 
cgit 1.4.1-3-g733a5


From 691df70bbcab3a22a961fe4df839857af19f8413 Mon Sep 17 00:00:00 2001
From: Niki4tap <rombiklol2@gmail.com>
Date: Mon, 19 Dec 2022 15:32:49 +0300
Subject: Inline some `const`s

---
 clippy_lints/src/transmute/transmute_null_to_fn.rs | 21 ++++++++++++---------
 1 file changed, 12 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/transmute/transmute_null_to_fn.rs b/clippy_lints/src/transmute/transmute_null_to_fn.rs
index 410c9eaaba0..e75d7f6bf1d 100644
--- a/clippy_lints/src/transmute/transmute_null_to_fn.rs
+++ b/clippy_lints/src/transmute/transmute_null_to_fn.rs
@@ -8,16 +8,19 @@ use rustc_span::symbol::sym;
 
 use super::TRANSMUTE_NULL_TO_FN;
 
-const LINT_MSG: &str = "transmuting a known null pointer into a function pointer";
-const NOTE_MSG: &str = "this transmute results in undefined behavior";
-const HELP_MSG: &str =
-    "try wrapping your function pointer type in `Option<T>` instead, and using `None` as a null pointer value";
-
 fn lint_expr(cx: &LateContext<'_>, expr: &Expr<'_>) {
-    span_lint_and_then(cx, TRANSMUTE_NULL_TO_FN, expr.span, LINT_MSG, |diag| {
-        diag.span_label(expr.span, NOTE_MSG);
-        diag.help(HELP_MSG);
-    });
+    span_lint_and_then(
+        cx,
+        TRANSMUTE_NULL_TO_FN,
+        expr.span,
+        "transmuting a known null pointer into a function pointer",
+        |diag| {
+            diag.span_label(expr.span, "this transmute results in undefined behavior");
+            diag.help(
+               "try wrapping your function pointer type in `Option<T>` instead, and using `None` as a null pointer value"
+            );
+        },
+    );
 }
 
 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, arg: &'tcx Expr<'_>, to_ty: Ty<'tcx>) -> bool {
-- 
cgit 1.4.1-3-g733a5


From d0ac6ba0b17666431b4727345059c71cde281680 Mon Sep 17 00:00:00 2001
From: Niki4tap <rombiklol2@gmail.com>
Date: Mon, 19 Dec 2022 18:27:42 +0300
Subject: Fix overflow ICE in large_stack/const_arrays

---
 clippy_lints/src/large_const_arrays.rs |  6 +++---
 clippy_lints/src/large_stack_arrays.rs |  6 +++---
 clippy_lints/src/utils/conf.rs         |  2 +-
 tests/ui/crashes/ice-10044.rs          |  3 +++
 tests/ui/crashes/ice-10044.stderr      | 10 ++++++++++
 5 files changed, 20 insertions(+), 7 deletions(-)
 create mode 100644 tests/ui/crashes/ice-10044.rs
 create mode 100644 tests/ui/crashes/ice-10044.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/large_const_arrays.rs b/clippy_lints/src/large_const_arrays.rs
index 76c83ab47d0..db637dfc068 100644
--- a/clippy_lints/src/large_const_arrays.rs
+++ b/clippy_lints/src/large_const_arrays.rs
@@ -34,12 +34,12 @@ declare_clippy_lint! {
 }
 
 pub struct LargeConstArrays {
-    maximum_allowed_size: u64,
+    maximum_allowed_size: u128,
 }
 
 impl LargeConstArrays {
     #[must_use]
-    pub fn new(maximum_allowed_size: u64) -> Self {
+    pub fn new(maximum_allowed_size: u128) -> Self {
         Self { maximum_allowed_size }
     }
 }
@@ -56,7 +56,7 @@ impl<'tcx> LateLintPass<'tcx> for LargeConstArrays {
             if let ConstKind::Value(ty::ValTree::Leaf(element_count)) = cst.kind();
             if let Ok(element_count) = element_count.try_to_machine_usize(cx.tcx);
             if let Ok(element_size) = cx.layout_of(*element_type).map(|l| l.size.bytes());
-            if self.maximum_allowed_size < element_count * element_size;
+            if self.maximum_allowed_size < u128::from(element_count) * u128::from(element_size);
 
             then {
                 let hi_pos = item.ident.span.lo() - BytePos::from_usize(1);
diff --git a/clippy_lints/src/large_stack_arrays.rs b/clippy_lints/src/large_stack_arrays.rs
index 5857d81ab1f..89ae83d48f5 100644
--- a/clippy_lints/src/large_stack_arrays.rs
+++ b/clippy_lints/src/large_stack_arrays.rs
@@ -24,12 +24,12 @@ declare_clippy_lint! {
 }
 
 pub struct LargeStackArrays {
-    maximum_allowed_size: u64,
+    maximum_allowed_size: u128,
 }
 
 impl LargeStackArrays {
     #[must_use]
-    pub fn new(maximum_allowed_size: u64) -> Self {
+    pub fn new(maximum_allowed_size: u128) -> Self {
         Self { maximum_allowed_size }
     }
 }
@@ -45,7 +45,7 @@ impl<'tcx> LateLintPass<'tcx> for LargeStackArrays {
           && let Ok(element_size) = cx.layout_of(*element_type).map(|l| l.size.bytes())
           && !cx.tcx.hir().parent_iter(expr.hir_id)
               .any(|(_, node)| matches!(node, Node::Item(Item { kind: ItemKind::Static(..), .. })))
-          && self.maximum_allowed_size < element_count * element_size {
+          && self.maximum_allowed_size < u128::from(element_count) * u128::from(element_size) {
               span_lint_and_help(
                   cx,
                   LARGE_STACK_ARRAYS,
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 3e7d0028c0f..c1589c771c4 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -333,7 +333,7 @@ define_Conf! {
     /// Lint: LARGE_STACK_ARRAYS, LARGE_CONST_ARRAYS.
     ///
     /// The maximum allowed size for arrays on the stack
-    (array_size_threshold: u64 = 512_000),
+    (array_size_threshold: u128 = 512_000),
     /// Lint: VEC_BOX.
     ///
     /// The size of the boxed type in bytes, where boxing in a `Vec` is allowed
diff --git a/tests/ui/crashes/ice-10044.rs b/tests/ui/crashes/ice-10044.rs
new file mode 100644
index 00000000000..65f38fe7118
--- /dev/null
+++ b/tests/ui/crashes/ice-10044.rs
@@ -0,0 +1,3 @@
+fn main() {
+    [0; usize::MAX];
+}
diff --git a/tests/ui/crashes/ice-10044.stderr b/tests/ui/crashes/ice-10044.stderr
new file mode 100644
index 00000000000..731f8265ad6
--- /dev/null
+++ b/tests/ui/crashes/ice-10044.stderr
@@ -0,0 +1,10 @@
+error: statement with no effect
+  --> $DIR/ice-10044.rs:2:5
+   |
+LL |     [0; usize::MAX];
+   |     ^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::no-effect` implied by `-D warnings`
+
+error: aborting due to previous error
+
-- 
cgit 1.4.1-3-g733a5


From 30e6e855088207a3fca8f1efb516f5b5dd43d1dd Mon Sep 17 00:00:00 2001
From: dboso <dboso@protonmail.com>
Date: Fri, 28 Oct 2022 20:07:17 +0000
Subject: add [`permissions_set_readonly_false`] #9702

---
 CHANGELOG.md                                       |  1 +
 clippy_lints/src/declared_lints.rs                 |  1 +
 clippy_lints/src/lib.rs                            |  2 +
 clippy_lints/src/permissions_set_readonly_false.rs | 48 ++++++++++++++++++++++
 tests/ui/permissions_set_readonly_false.rs         | 29 +++++++++++++
 tests/ui/permissions_set_readonly_false.stderr     | 11 +++++
 6 files changed, 92 insertions(+)
 create mode 100644 clippy_lints/src/permissions_set_readonly_false.rs
 create mode 100644 tests/ui/permissions_set_readonly_false.rs
 create mode 100644 tests/ui/permissions_set_readonly_false.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 17ff182c7be..52efa8db485 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4461,6 +4461,7 @@ Released 2018-09-13
 [`partialeq_to_none`]: https://rust-lang.github.io/rust-clippy/master/index.html#partialeq_to_none
 [`path_buf_push_overwrite`]: https://rust-lang.github.io/rust-clippy/master/index.html#path_buf_push_overwrite
 [`pattern_type_mismatch`]: https://rust-lang.github.io/rust-clippy/master/index.html#pattern_type_mismatch
+[`permissions_set_readonly_false`]: https://rust-lang.github.io/rust-clippy/master/index.html#permissions_set_readonly_false
 [`positional_named_format_parameters`]: https://rust-lang.github.io/rust-clippy/master/index.html#positional_named_format_parameters
 [`possible_missing_comma`]: https://rust-lang.github.io/rust-clippy/master/index.html#possible_missing_comma
 [`precedence`]: https://rust-lang.github.io/rust-clippy/master/index.html#precedence
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 480a65ac70c..980e128cba4 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -495,6 +495,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::pass_by_ref_or_value::LARGE_TYPES_PASSED_BY_VALUE_INFO,
     crate::pass_by_ref_or_value::TRIVIALLY_COPY_PASS_BY_REF_INFO,
     crate::pattern_type_mismatch::PATTERN_TYPE_MISMATCH_INFO,
+    crate::permissions_set_readonly_false::PERMISSIONS_SET_READONLY_FALSE_INFO,
     crate::precedence::PRECEDENCE_INFO,
     crate::ptr::CMP_NULL_INFO,
     crate::ptr::INVALID_NULL_PTR_USAGE_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 7f7d73339e4..676ef3946bf 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -235,6 +235,7 @@ mod partialeq_ne_impl;
 mod partialeq_to_none;
 mod pass_by_ref_or_value;
 mod pattern_type_mismatch;
+mod permissions_set_readonly_false;
 mod precedence;
 mod ptr;
 mod ptr_offset_with_cast;
@@ -904,6 +905,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(move |_| Box::new(manual_is_ascii_check::ManualIsAsciiCheck::new(msrv())));
     store.register_late_pass(|_| Box::new(semicolon_block::SemicolonBlock));
     store.register_late_pass(|_| Box::new(fn_null_check::FnNullCheck));
+    store.register_late_pass(|_| Box::new(permissions_set_readonly_false::PermissionsSetReadonlyFalse));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/permissions_set_readonly_false.rs b/clippy_lints/src/permissions_set_readonly_false.rs
new file mode 100644
index 00000000000..7d787ea4a4c
--- /dev/null
+++ b/clippy_lints/src/permissions_set_readonly_false.rs
@@ -0,0 +1,48 @@
+use clippy_utils::diagnostics::span_lint_and_note;
+use clippy_utils::paths;
+use clippy_utils::ty::match_type;
+use rustc_ast::ast::LitKind;
+use rustc_hir::{Expr, ExprKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for calls to `std::fs::Permissions.set_readonly` with argument `false`
+    ///
+    /// ### Why is this bad?
+    /// On Unix platforms this results in the file being world writable
+    ///
+    /// ### Example
+    /// ```rust
+    /// use std::fs::File;
+    /// let f = File::create("foo.txt").unwrap();
+    /// let metadata = f.metadata().unwrap();
+    /// let mut permissions = metadata.permissions();
+    /// permissions.set_readonly(false);
+    /// ```
+    #[clippy::version = "1.66.0"]
+    pub PERMISSIONS_SET_READONLY_FALSE,
+    suspicious,
+    "Checks for calls to `std::fs::Permissions.set_readonly` with argument `false`"
+}
+declare_lint_pass!(PermissionsSetReadonlyFalse => [PERMISSIONS_SET_READONLY_FALSE]);
+
+impl<'tcx> LateLintPass<'tcx> for PermissionsSetReadonlyFalse {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
+        if let ExprKind::MethodCall(path, receiver, [arg], _) = &expr.kind
+            && match_type(cx, cx.typeck_results().expr_ty(receiver), &paths::PERMISSIONS)
+                && path.ident.name == sym!(set_readonly)
+                && let ExprKind::Lit(lit) = &arg.kind
+                && LitKind::Bool(false) == lit.node {
+                    span_lint_and_note(
+                        cx,
+                        PERMISSIONS_SET_READONLY_FALSE,
+                        expr.span,
+                        "call to `set_readonly` with argument `false`",
+                        None,
+                        "on Unix platforms this results in the file being world writable",
+                    );
+        }
+    }
+}
diff --git a/tests/ui/permissions_set_readonly_false.rs b/tests/ui/permissions_set_readonly_false.rs
new file mode 100644
index 00000000000..28c00d10094
--- /dev/null
+++ b/tests/ui/permissions_set_readonly_false.rs
@@ -0,0 +1,29 @@
+#![allow(unused)]
+#![warn(clippy::permissions_set_readonly_false)]
+
+use std::fs::File;
+
+struct A;
+
+impl A {
+    pub fn set_readonly(&mut self, b: bool) {}
+}
+
+fn set_readonly(b: bool) {}
+
+fn main() {
+    let f = File::create("foo.txt").unwrap();
+    let metadata = f.metadata().unwrap();
+    let mut permissions = metadata.permissions();
+    // lint here
+    permissions.set_readonly(false);
+    // no lint
+    permissions.set_readonly(true);
+
+    let mut a = A;
+    // no lint here - a is not of type std::fs::Permissions
+    a.set_readonly(false);
+
+    // no lint here - plain function
+    set_readonly(false);
+}
diff --git a/tests/ui/permissions_set_readonly_false.stderr b/tests/ui/permissions_set_readonly_false.stderr
new file mode 100644
index 00000000000..106d2f793a4
--- /dev/null
+++ b/tests/ui/permissions_set_readonly_false.stderr
@@ -0,0 +1,11 @@
+error: call to `set_readonly` with argument `false`
+  --> $DIR/permissions_set_readonly_false.rs:19:5
+   |
+LL |     permissions.set_readonly(false);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: on Unix platforms this results in the file being world writable
+   = note: `-D clippy::permissions-set-readonly-false` implied by `-D warnings`
+
+error: aborting due to previous error
+
-- 
cgit 1.4.1-3-g733a5


From e1d3c1e8f1f2d7bd819fbaafe80de74e67ebb488 Mon Sep 17 00:00:00 2001
From: chansuke <moonset20@gmail.com>
Date: Sat, 17 Dec 2022 20:32:46 +0900
Subject: refactor: fix style

---
 clippy_lints/src/permissions_set_readonly_false.rs | 19 ++++++++++---------
 1 file changed, 10 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/permissions_set_readonly_false.rs b/clippy_lints/src/permissions_set_readonly_false.rs
index 7d787ea4a4c..6c463bd8fce 100644
--- a/clippy_lints/src/permissions_set_readonly_false.rs
+++ b/clippy_lints/src/permissions_set_readonly_false.rs
@@ -34,15 +34,16 @@ impl<'tcx> LateLintPass<'tcx> for PermissionsSetReadonlyFalse {
             && match_type(cx, cx.typeck_results().expr_ty(receiver), &paths::PERMISSIONS)
                 && path.ident.name == sym!(set_readonly)
                 && let ExprKind::Lit(lit) = &arg.kind
-                && LitKind::Bool(false) == lit.node {
-                    span_lint_and_note(
-                        cx,
-                        PERMISSIONS_SET_READONLY_FALSE,
-                        expr.span,
-                        "call to `set_readonly` with argument `false`",
-                        None,
-                        "on Unix platforms this results in the file being world writable",
-                    );
+                && LitKind::Bool(false) == lit.node
+        {
+                span_lint_and_note(
+                    cx,
+                    PERMISSIONS_SET_READONLY_FALSE,
+                    expr.span,
+                    "call to `set_readonly` with argument `false`",
+                    None,
+                    "on Unix platforms this results in the file being world writable",
+                );
         }
     }
 }
-- 
cgit 1.4.1-3-g733a5


From ed519ad746e31f64c4e9255be561785612532d37 Mon Sep 17 00:00:00 2001
From: Samuel Moelius <sam@moeli.us>
Date: Wed, 12 Oct 2022 04:34:25 -0400
Subject: Improve `possible_borrower`

---
 clippy_lints/src/dereference.rs           |   8 +-
 clippy_lints/src/redundant_clone.rs       |   4 +-
 clippy_utils/src/mir/possible_borrower.rs | 265 +++++++++++++++++++-----------
 tests/ui/needless_borrow.fixed            |   2 +-
 tests/ui/needless_borrow.stderr           |   8 +-
 tests/ui/redundant_clone.fixed            |   2 +-
 tests/ui/redundant_clone.stderr           |  14 +-
 7 files changed, 195 insertions(+), 108 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index 7b43d8ccc67..728941b8b3d 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -1282,10 +1282,10 @@ fn referent_used_exactly_once<'tcx>(
             possible_borrowers.push((body_owner_local_def_id, PossibleBorrowerMap::new(cx, mir)));
         }
         let possible_borrower = &mut possible_borrowers.last_mut().unwrap().1;
-        // If `only_borrowers` were used here, the `copyable_iterator::warn` test would fail. The reason is
-        // that `PossibleBorrowerVisitor::visit_terminator` considers `place.local` a possible borrower of
-        // itself. See the comment in that method for an explanation as to why.
-        possible_borrower.bounded_borrowers(&[local], &[local, place.local], place.local, location)
+        // If `place.local` were not included here, the `copyable_iterator::warn` test would fail. The
+        // reason is that `PossibleBorrowerVisitor::visit_terminator` considers `place.local` a possible
+        // borrower of itself. See the comment in that method for an explanation as to why.
+        possible_borrower.at_most_borrowers(cx, &[local, place.local], place.local, location)
             && used_exactly_once(mir, place.local).unwrap_or(false)
     } else {
         false
diff --git a/clippy_lints/src/redundant_clone.rs b/clippy_lints/src/redundant_clone.rs
index c1677fb3da1..0e7c5cca724 100644
--- a/clippy_lints/src/redundant_clone.rs
+++ b/clippy_lints/src/redundant_clone.rs
@@ -131,7 +131,7 @@ impl<'tcx> LateLintPass<'tcx> for RedundantClone {
                 // `res = clone(arg)` can be turned into `res = move arg;`
                 // if `arg` is the only borrow of `cloned` at this point.
 
-                if cannot_move_out || !possible_borrower.only_borrowers(&[arg], cloned, loc) {
+                if cannot_move_out || !possible_borrower.at_most_borrowers(cx, &[arg], cloned, loc) {
                     continue;
                 }
 
@@ -178,7 +178,7 @@ impl<'tcx> LateLintPass<'tcx> for RedundantClone {
                 // StorageDead(pred_arg);
                 // res = to_path_buf(cloned);
                 // ```
-                if cannot_move_out || !possible_borrower.only_borrowers(&[arg, cloned], local, loc) {
+                if cannot_move_out || !possible_borrower.at_most_borrowers(cx, &[arg, cloned], local, loc) {
                     continue;
                 }
 
diff --git a/clippy_utils/src/mir/possible_borrower.rs b/clippy_utils/src/mir/possible_borrower.rs
index 8c695801c73..ebe7d339309 100644
--- a/clippy_utils/src/mir/possible_borrower.rs
+++ b/clippy_utils/src/mir/possible_borrower.rs
@@ -1,89 +1,137 @@
-use super::{possible_origin::PossibleOriginVisitor, transitive_relation::TransitiveRelation};
+use super::possible_origin::PossibleOriginVisitor;
 use crate::ty::is_copy;
-use rustc_data_structures::fx::FxHashMap;
+use rustc_data_structures::fx::{FxHashMap, FxIndexMap};
 use rustc_index::bit_set::{BitSet, HybridBitSet};
 use rustc_lint::LateContext;
-use rustc_middle::mir::{self, visit::Visitor as _, Mutability};
-use rustc_middle::ty::{self, visit::TypeVisitor};
-use rustc_mir_dataflow::{impls::MaybeStorageLive, Analysis, ResultsCursor};
+use rustc_middle::mir::{
+    self, visit::Visitor as _, BasicBlock, Local, Location, Mutability, Statement, StatementKind, Terminator,
+};
+use rustc_middle::ty::{self, visit::TypeVisitor, TyCtxt};
+use rustc_mir_dataflow::{
+    fmt::DebugWithContext, impls::MaybeStorageLive, lattice::JoinSemiLattice, Analysis, AnalysisDomain,
+    CallReturnPlaces, ResultsCursor,
+};
+use std::collections::VecDeque;
 use std::ops::ControlFlow;
 
 /// Collects the possible borrowers of each local.
 /// For example, `b = &a; c = &a;` will make `b` and (transitively) `c`
 /// possible borrowers of `a`.
 #[allow(clippy::module_name_repetitions)]
-struct PossibleBorrowerVisitor<'a, 'b, 'tcx> {
-    possible_borrower: TransitiveRelation,
+struct PossibleBorrowerAnalysis<'b, 'tcx> {
+    tcx: TyCtxt<'tcx>,
     body: &'b mir::Body<'tcx>,
-    cx: &'a LateContext<'tcx>,
     possible_origin: FxHashMap<mir::Local, HybridBitSet<mir::Local>>,
 }
 
-impl<'a, 'b, 'tcx> PossibleBorrowerVisitor<'a, 'b, 'tcx> {
-    fn new(
-        cx: &'a LateContext<'tcx>,
-        body: &'b mir::Body<'tcx>,
-        possible_origin: FxHashMap<mir::Local, HybridBitSet<mir::Local>>,
-    ) -> Self {
+#[derive(Clone, Debug, Eq, PartialEq)]
+struct PossibleBorrowerState {
+    map: FxIndexMap<Local, BitSet<Local>>,
+    domain_size: usize,
+}
+
+impl PossibleBorrowerState {
+    fn new(domain_size: usize) -> Self {
         Self {
-            possible_borrower: TransitiveRelation::default(),
-            cx,
-            body,
-            possible_origin,
+            map: FxIndexMap::default(),
+            domain_size,
         }
     }
 
-    fn into_map(
-        self,
-        cx: &'a LateContext<'tcx>,
-        maybe_live: ResultsCursor<'b, 'tcx, MaybeStorageLive>,
-    ) -> PossibleBorrowerMap<'b, 'tcx> {
-        let mut map = FxHashMap::default();
-        for row in (1..self.body.local_decls.len()).map(mir::Local::from_usize) {
-            if is_copy(cx, self.body.local_decls[row].ty) {
-                continue;
-            }
+    #[allow(clippy::similar_names)]
+    fn add(&mut self, borrowed: Local, borrower: Local) {
+        self.map
+            .entry(borrowed)
+            .or_insert(BitSet::new_empty(self.domain_size))
+            .insert(borrower);
+    }
+}
+
+impl<C> DebugWithContext<C> for PossibleBorrowerState {
+    fn fmt_with(&self, _ctxt: &C, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        <_ as std::fmt::Debug>::fmt(self, f)
+    }
+    fn fmt_diff_with(&self, _old: &Self, _ctxt: &C, _f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        unimplemented!()
+    }
+}
 
-            let mut borrowers = self.possible_borrower.reachable_from(row, self.body.local_decls.len());
-            borrowers.remove(mir::Local::from_usize(0));
+impl JoinSemiLattice for PossibleBorrowerState {
+    fn join(&mut self, other: &Self) -> bool {
+        let mut changed = false;
+        for (&borrowed, borrowers) in other.map.iter() {
             if !borrowers.is_empty() {
-                map.insert(row, borrowers);
+                changed |= self
+                    .map
+                    .entry(borrowed)
+                    .or_insert(BitSet::new_empty(self.domain_size))
+                    .union(borrowers);
             }
         }
+        changed
+    }
+}
 
-        let bs = BitSet::new_empty(self.body.local_decls.len());
-        PossibleBorrowerMap {
-            map,
-            maybe_live,
-            bitset: (bs.clone(), bs),
+impl<'b, 'tcx> AnalysisDomain<'tcx> for PossibleBorrowerAnalysis<'b, 'tcx> {
+    type Domain = PossibleBorrowerState;
+
+    const NAME: &'static str = "possible_borrower";
+
+    fn bottom_value(&self, body: &mir::Body<'tcx>) -> Self::Domain {
+        PossibleBorrowerState::new(body.local_decls.len())
+    }
+
+    fn initialize_start_block(&self, _body: &mir::Body<'tcx>, _entry_set: &mut Self::Domain) {}
+}
+
+impl<'b, 'tcx> PossibleBorrowerAnalysis<'b, 'tcx> {
+    fn new(
+        tcx: TyCtxt<'tcx>,
+        body: &'b mir::Body<'tcx>,
+        possible_origin: FxHashMap<mir::Local, HybridBitSet<mir::Local>>,
+    ) -> Self {
+        Self {
+            tcx,
+            body,
+            possible_origin,
         }
     }
 }
 
-impl<'a, 'b, 'tcx> mir::visit::Visitor<'tcx> for PossibleBorrowerVisitor<'a, 'b, 'tcx> {
-    fn visit_assign(&mut self, place: &mir::Place<'tcx>, rvalue: &mir::Rvalue<'_>, _location: mir::Location) {
-        let lhs = place.local;
-        match rvalue {
-            mir::Rvalue::Ref(_, _, borrowed) => {
-                self.possible_borrower.add(borrowed.local, lhs);
-            },
-            other => {
-                if ContainsRegion
-                    .visit_ty(place.ty(&self.body.local_decls, self.cx.tcx).ty)
-                    .is_continue()
-                {
-                    return;
-                }
-                rvalue_locals(other, |rhs| {
-                    if lhs != rhs {
-                        self.possible_borrower.add(rhs, lhs);
+impl<'b, 'tcx> Analysis<'tcx> for PossibleBorrowerAnalysis<'b, 'tcx> {
+    fn apply_call_return_effect(
+        &self,
+        _state: &mut Self::Domain,
+        _block: BasicBlock,
+        _return_places: CallReturnPlaces<'_, 'tcx>,
+    ) {
+    }
+
+    fn apply_statement_effect(&self, state: &mut Self::Domain, statement: &Statement<'tcx>, _location: Location) {
+        if let StatementKind::Assign(box (place, rvalue)) = &statement.kind {
+            let lhs = place.local;
+            match rvalue {
+                mir::Rvalue::Ref(_, _, borrowed) => {
+                    state.add(borrowed.local, lhs);
+                },
+                other => {
+                    if ContainsRegion
+                        .visit_ty(place.ty(&self.body.local_decls, self.tcx).ty)
+                        .is_continue()
+                    {
+                        return;
                     }
-                });
-            },
+                    rvalue_locals(other, |rhs| {
+                        if lhs != rhs {
+                            state.add(rhs, lhs);
+                        }
+                    });
+                },
+            }
         }
     }
 
-    fn visit_terminator(&mut self, terminator: &mir::Terminator<'_>, _loc: mir::Location) {
+    fn apply_terminator_effect(&self, state: &mut Self::Domain, terminator: &Terminator<'tcx>, _location: Location) {
         if let mir::TerminatorKind::Call {
             args,
             destination: mir::Place { local: dest, .. },
@@ -123,10 +171,10 @@ impl<'a, 'b, 'tcx> mir::visit::Visitor<'tcx> for PossibleBorrowerVisitor<'a, 'b,
 
             for y in mutable_variables {
                 for x in &immutable_borrowers {
-                    self.possible_borrower.add(*x, y);
+                    state.add(*x, y);
                 }
                 for x in &mutable_borrowers {
-                    self.possible_borrower.add(*x, y);
+                    state.add(*x, y);
                 }
             }
         }
@@ -162,73 +210,94 @@ fn rvalue_locals(rvalue: &mir::Rvalue<'_>, mut visit: impl FnMut(mir::Local)) {
     }
 }
 
-/// Result of `PossibleBorrowerVisitor`.
+/// Result of `PossibleBorrowerAnalysis`.
 #[allow(clippy::module_name_repetitions)]
 pub struct PossibleBorrowerMap<'b, 'tcx> {
-    /// Mapping `Local -> its possible borrowers`
-    pub map: FxHashMap<mir::Local, HybridBitSet<mir::Local>>,
+    body: &'b mir::Body<'tcx>,
+    possible_borrower: ResultsCursor<'b, 'tcx, PossibleBorrowerAnalysis<'b, 'tcx>>,
     maybe_live: ResultsCursor<'b, 'tcx, MaybeStorageLive>,
-    // Caches to avoid allocation of `BitSet` on every query
-    pub bitset: (BitSet<mir::Local>, BitSet<mir::Local>),
 }
 
-impl<'a, 'b, 'tcx> PossibleBorrowerMap<'b, 'tcx> {
-    pub fn new(cx: &'a LateContext<'tcx>, mir: &'b mir::Body<'tcx>) -> Self {
+impl<'b, 'tcx> PossibleBorrowerMap<'b, 'tcx> {
+    pub fn new(cx: &LateContext<'tcx>, mir: &'b mir::Body<'tcx>) -> Self {
         let possible_origin = {
             let mut vis = PossibleOriginVisitor::new(mir);
             vis.visit_body(mir);
             vis.into_map(cx)
         };
-        let maybe_storage_live_result = MaybeStorageLive::new(BitSet::new_empty(mir.local_decls.len()))
+        let possible_borrower = PossibleBorrowerAnalysis::new(cx.tcx, mir, possible_origin)
             .into_engine(cx.tcx, mir)
-            .pass_name("redundant_clone")
+            .pass_name("possible_borrower")
             .iterate_to_fixpoint()
             .into_results_cursor(mir);
-        let mut vis = PossibleBorrowerVisitor::new(cx, mir, possible_origin);
-        vis.visit_body(mir);
-        vis.into_map(cx, maybe_storage_live_result)
-    }
-
-    /// Returns true if the set of borrowers of `borrowed` living at `at` matches with `borrowers`.
-    pub fn only_borrowers(&mut self, borrowers: &[mir::Local], borrowed: mir::Local, at: mir::Location) -> bool {
-        self.bounded_borrowers(borrowers, borrowers, borrowed, at)
+        let maybe_live = MaybeStorageLive::new(BitSet::new_empty(mir.local_decls.len()))
+            .into_engine(cx.tcx, mir)
+            .pass_name("possible_borrower")
+            .iterate_to_fixpoint()
+            .into_results_cursor(mir);
+        PossibleBorrowerMap {
+            body: mir,
+            possible_borrower,
+            maybe_live,
+        }
     }
 
-    /// Returns true if the set of borrowers of `borrowed` living at `at` includes at least `below`
-    /// but no more than `above`.
-    pub fn bounded_borrowers(
+    /// Returns true if the set of borrowers of `borrowed` living at `at` includes no more than
+    /// `borrowers`.
+    /// Notes:
+    /// 1. It would be nice if `PossibleBorrowerMap` could store `cx` so that `at_most_borrowers`
+    /// would not require it to be passed in. But a `PossibleBorrowerMap` is stored in `LintPass`
+    /// `Dereferencing`, which outlives any `LateContext`.
+    /// 2. In all current uses of `at_most_borrowers`, `borrowers` is a slice of at most two
+    /// elements. Thus, `borrowers.contains(...)` is effectively a constant-time operation. If
+    /// `at_most_borrowers`'s uses were to expand beyond this, its implementation might have to be
+    /// adjusted.
+    pub fn at_most_borrowers(
         &mut self,
-        below: &[mir::Local],
-        above: &[mir::Local],
+        cx: &LateContext<'tcx>,
+        borrowers: &[mir::Local],
         borrowed: mir::Local,
         at: mir::Location,
     ) -> bool {
-        self.maybe_live.seek_after_primary_effect(at);
+        if is_copy(cx, self.body.local_decls[borrowed].ty) {
+            return true;
+        }
+
+        self.possible_borrower.seek_before_primary_effect(at);
+        self.maybe_live.seek_before_primary_effect(at);
 
-        self.bitset.0.clear();
-        let maybe_live = &mut self.maybe_live;
-        if let Some(bitset) = self.map.get(&borrowed) {
-            for b in bitset.iter().filter(move |b| maybe_live.contains(*b)) {
-                self.bitset.0.insert(b);
+        let possible_borrower = &self.possible_borrower.get().map;
+        let maybe_live = &self.maybe_live;
+
+        let mut queued = BitSet::new_empty(self.body.local_decls.len());
+        let mut deque = VecDeque::with_capacity(self.body.local_decls.len());
+
+        if let Some(borrowers) = possible_borrower.get(&borrowed) {
+            for b in borrowers.iter() {
+                if queued.insert(b) {
+                    deque.push_back(b);
+                }
             }
         } else {
-            return false;
+            // Nothing borrows `borrowed` at `at`.
+            return true;
         }
 
-        self.bitset.1.clear();
-        for b in below {
-            self.bitset.1.insert(*b);
-        }
-
-        if !self.bitset.0.superset(&self.bitset.1) {
-            return false;
-        }
+        while let Some(borrower) = deque.pop_front() {
+            if maybe_live.contains(borrower) && !borrowers.contains(&borrower) {
+                return false;
+            }
 
-        for b in above {
-            self.bitset.0.remove(*b);
+            if let Some(borrowers) = possible_borrower.get(&borrower) {
+                for b in borrowers.iter() {
+                    if queued.insert(b) {
+                        deque.push_back(b);
+                    }
+                }
+            }
         }
 
-        self.bitset.0.is_empty()
+        true
     }
 
     pub fn local_is_alive_at(&mut self, local: mir::Local, at: mir::Location) -> bool {
diff --git a/tests/ui/needless_borrow.fixed b/tests/ui/needless_borrow.fixed
index e970f87e226..31e1cb6c3d7 100644
--- a/tests/ui/needless_borrow.fixed
+++ b/tests/ui/needless_borrow.fixed
@@ -499,6 +499,6 @@ extern crate rustc_span;
 mod span_lint {
     use rustc_lint::{LateContext, Lint, LintContext};
     fn foo(cx: &LateContext<'_>, lint: &'static Lint) {
-        cx.struct_span_lint(lint, rustc_span::Span::default(), "", |diag| diag.note(&String::new()));
+        cx.struct_span_lint(lint, rustc_span::Span::default(), "", |diag| diag.note(String::new()));
     }
 }
diff --git a/tests/ui/needless_borrow.stderr b/tests/ui/needless_borrow.stderr
index d26c317124b..98a48d68317 100644
--- a/tests/ui/needless_borrow.stderr
+++ b/tests/ui/needless_borrow.stderr
@@ -216,5 +216,11 @@ error: the borrowed expression implements the required traits
 LL |         foo(&a);
    |             ^^ help: change this to: `a`
 
-error: aborting due to 36 previous errors
+error: the borrowed expression implements the required traits
+  --> $DIR/needless_borrow.rs:502:85
+   |
+LL |         cx.struct_span_lint(lint, rustc_span::Span::default(), "", |diag| diag.note(&String::new()));
+   |                                                                                     ^^^^^^^^^^^^^^ help: change this to: `String::new()`
+
+error: aborting due to 37 previous errors
 
diff --git a/tests/ui/redundant_clone.fixed b/tests/ui/redundant_clone.fixed
index 369ae3f7147..a157b6a6f9a 100644
--- a/tests/ui/redundant_clone.fixed
+++ b/tests/ui/redundant_clone.fixed
@@ -243,5 +243,5 @@ fn false_negative_5707() {
 #[allow(unused, clippy::manual_retain)]
 fn possible_borrower_improvements() {
     let mut s = String::from("foobar");
-    s = s.chars().filter(|&c| c != 'o').to_owned().collect();
+    s = s.chars().filter(|&c| c != 'o').collect();
 }
diff --git a/tests/ui/redundant_clone.stderr b/tests/ui/redundant_clone.stderr
index 782590034d0..1bacc2c76af 100644
--- a/tests/ui/redundant_clone.stderr
+++ b/tests/ui/redundant_clone.stderr
@@ -179,5 +179,17 @@ note: this value is dropped without further use
 LL |     foo(&x.clone(), move || {
    |          ^
 
-error: aborting due to 15 previous errors
+error: redundant clone
+  --> $DIR/redundant_clone.rs:246:40
+   |
+LL |     s = s.chars().filter(|&c| c != 'o').to_owned().collect();
+   |                                        ^^^^^^^^^^^ help: remove this
+   |
+note: this value is dropped without further use
+  --> $DIR/redundant_clone.rs:246:9
+   |
+LL |     s = s.chars().filter(|&c| c != 'o').to_owned().collect();
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 16 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 26df55112f754033d18d2157731ae3b4ecd41aa8 Mon Sep 17 00:00:00 2001
From: Samuel Moelius <sam@moeli.us>
Date: Wed, 12 Oct 2022 04:34:39 -0400
Subject: Fix adjacent code

---
 clippy_lints/src/casts/cast_slice_different_sizes.rs       |  2 +-
 clippy_lints/src/format_args.rs                            |  2 +-
 clippy_lints/src/large_enum_variant.rs                     |  2 +-
 clippy_lints/src/len_zero.rs                               |  2 +-
 clippy_lints/src/lib.rs                                    |  2 +-
 clippy_lints/src/loops/explicit_counter_loop.rs            |  2 +-
 clippy_lints/src/manual_async_fn.rs                        |  2 +-
 clippy_lints/src/manual_strip.rs                           |  2 +-
 clippy_lints/src/methods/inefficient_to_string.rs          |  2 +-
 clippy_lints/src/methods/iter_skip_next.rs                 |  2 +-
 clippy_lints/src/methods/option_map_unwrap_or.rs           |  2 +-
 clippy_lints/src/methods/str_splitn.rs                     |  2 +-
 clippy_lints/src/methods/unnecessary_lazy_eval.rs          |  2 +-
 clippy_lints/src/needless_late_init.rs                     |  6 +++---
 clippy_lints/src/octal_escapes.rs                          |  4 ++--
 clippy_lints/src/operators/misrefactored_assign_op.rs      |  2 +-
 clippy_lints/src/same_name_method.rs                       |  4 ++--
 clippy_lints/src/swap.rs                                   |  4 ++--
 clippy_lints/src/transmute/transmute_undefined_repr.rs     | 14 +++++++-------
 .../src/transmute/transmutes_expressible_as_ptr_casts.rs   |  2 +-
 clippy_lints/src/transmute/useless_transmute.rs            |  2 +-
 clippy_lints/src/types/redundant_allocation.rs             |  8 ++++----
 clippy_lints/src/unit_types/unit_arg.rs                    |  4 ++--
 clippy_lints/src/write.rs                                  |  4 ++--
 clippy_utils/src/diagnostics.rs                            |  2 +-
 tests/ui/manual_retain.fixed                               |  2 +-
 tests/ui/manual_retain.rs                                  |  2 +-
 27 files changed, 43 insertions(+), 43 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/cast_slice_different_sizes.rs b/clippy_lints/src/casts/cast_slice_different_sizes.rs
index e862f13e69f..c8e54d7b8e0 100644
--- a/clippy_lints/src/casts/cast_slice_different_sizes.rs
+++ b/clippy_lints/src/casts/cast_slice_different_sizes.rs
@@ -54,7 +54,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>, msrv: &Msrv
 
                         diag.span_suggestion(
                             expr.span,
-                            &format!("replace with `ptr::slice_from_raw_parts{mutbl_fn_str}`"),
+                            format!("replace with `ptr::slice_from_raw_parts{mutbl_fn_str}`"),
                             sugg,
                             rustc_errors::Applicability::HasPlaceholders,
                         );
diff --git a/clippy_lints/src/format_args.rs b/clippy_lints/src/format_args.rs
index 62284235dbf..9891955a4ef 100644
--- a/clippy_lints/src/format_args.rs
+++ b/clippy_lints/src/format_args.rs
@@ -377,7 +377,7 @@ fn check_format_in_format_args(cx: &LateContext<'_>, call_site: Span, name: Symb
         call_site,
         &format!("`format!` in `{name}!` args"),
         |diag| {
-            diag.help(&format!(
+            diag.help(format!(
                 "combine the `format!(..)` arguments with the outer `{name}!(..)` call"
             ));
             diag.help("or consider changing `format!` to `format_args!`");
diff --git a/clippy_lints/src/large_enum_variant.rs b/clippy_lints/src/large_enum_variant.rs
index b18456ee523..b8d4abdbb78 100644
--- a/clippy_lints/src/large_enum_variant.rs
+++ b/clippy_lints/src/large_enum_variant.rs
@@ -111,7 +111,7 @@ impl<'tcx> LateLintPass<'tcx> for LargeEnumVariant {
                         );
                         diag.span_label(
                             def.variants[variants_size[1].ind].span,
-                            &if variants_size[1].fields_size.is_empty() {
+                            if variants_size[1].fields_size.is_empty() {
                                 "the second-largest variant carries no data at all".to_owned()
                             } else {
                                 format!(
diff --git a/clippy_lints/src/len_zero.rs b/clippy_lints/src/len_zero.rs
index e88d1764a24..9eba4675629 100644
--- a/clippy_lints/src/len_zero.rs
+++ b/clippy_lints/src/len_zero.rs
@@ -361,7 +361,7 @@ fn check_for_is_empty<'tcx>(
             db.span_note(span, "`is_empty` defined here");
         }
         if let Some(self_kind) = self_kind {
-            db.note(&output.expected_sig(self_kind));
+            db.note(output.expected_sig(self_kind));
         }
     });
 }
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 7f7d73339e4..f95b9538cef 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -335,7 +335,7 @@ pub fn read_conf(sess: &Session, path: &io::Result<Option<PathBuf>>) -> Conf {
         Ok(Some(path)) => path,
         Ok(None) => return Conf::default(),
         Err(error) => {
-            sess.struct_err(&format!("error finding Clippy's configuration file: {error}"))
+            sess.struct_err(format!("error finding Clippy's configuration file: {error}"))
                 .emit();
             return Conf::default();
         },
diff --git a/clippy_lints/src/loops/explicit_counter_loop.rs b/clippy_lints/src/loops/explicit_counter_loop.rs
index 14f22348132..1953ee8a717 100644
--- a/clippy_lints/src/loops/explicit_counter_loop.rs
+++ b/clippy_lints/src/loops/explicit_counter_loop.rs
@@ -77,7 +77,7 @@ pub(super) fn check<'tcx>(
                                 applicability,
                             );
 
-                            diag.note(&format!(
+                            diag.note(format!(
                                 "`{name}` is of type `{int_name}`, making it ineligible for `Iterator::enumerate`"
                             ));
                         },
diff --git a/clippy_lints/src/manual_async_fn.rs b/clippy_lints/src/manual_async_fn.rs
index 075ecbe7ede..af7c0563555 100644
--- a/clippy_lints/src/manual_async_fn.rs
+++ b/clippy_lints/src/manual_async_fn.rs
@@ -76,7 +76,7 @@ impl<'tcx> LateLintPass<'tcx> for ManualAsyncFn {
                                 let help = format!("make the function `async` and {ret_sugg}");
                                 diag.span_suggestion(
                                     header_span,
-                                    &help,
+                                    help,
                                     format!("async {}{ret_snip}", &header_snip[..ret_pos]),
                                     Applicability::MachineApplicable
                                 );
diff --git a/clippy_lints/src/manual_strip.rs b/clippy_lints/src/manual_strip.rs
index de166b9765f..c795c1d9a16 100644
--- a/clippy_lints/src/manual_strip.rs
+++ b/clippy_lints/src/manual_strip.rs
@@ -109,7 +109,7 @@ impl<'tcx> LateLintPass<'tcx> for ManualStrip {
 
                     let test_span = expr.span.until(then.span);
                     span_lint_and_then(cx, MANUAL_STRIP, strippings[0], &format!("stripping a {kind_word} manually"), |diag| {
-                        diag.span_note(test_span, &format!("the {kind_word} was tested here"));
+                        diag.span_note(test_span, format!("the {kind_word} was tested here"));
                         multispan_sugg(
                             diag,
                             &format!("try using the `strip_{kind_word}` method"),
diff --git a/clippy_lints/src/methods/inefficient_to_string.rs b/clippy_lints/src/methods/inefficient_to_string.rs
index 5c620d02716..122088f4857 100644
--- a/clippy_lints/src/methods/inefficient_to_string.rs
+++ b/clippy_lints/src/methods/inefficient_to_string.rs
@@ -36,7 +36,7 @@ pub fn check(
                 expr.span,
                 &format!("calling `to_string` on `{arg_ty}`"),
                 |diag| {
-                    diag.help(&format!(
+                    diag.help(format!(
                         "`{self_ty}` implements `ToString` through a slower blanket impl, but `{deref_self_ty}` has a fast specialization of `ToString`"
                     ));
                     let mut applicability = Applicability::MachineApplicable;
diff --git a/clippy_lints/src/methods/iter_skip_next.rs b/clippy_lints/src/methods/iter_skip_next.rs
index beb772100af..279175e20c3 100644
--- a/clippy_lints/src/methods/iter_skip_next.rs
+++ b/clippy_lints/src/methods/iter_skip_next.rs
@@ -29,7 +29,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr
                         application = Applicability::Unspecified;
                         diag.span_help(
                             pat.span,
-                            &format!("for this change `{}` has to be mutable", snippet(cx, pat.span, "..")),
+                            format!("for this change `{}` has to be mutable", snippet(cx, pat.span, "..")),
                         );
                     }
                 }
diff --git a/clippy_lints/src/methods/option_map_unwrap_or.rs b/clippy_lints/src/methods/option_map_unwrap_or.rs
index 910ee14855e..4c6328481e4 100644
--- a/clippy_lints/src/methods/option_map_unwrap_or.rs
+++ b/clippy_lints/src/methods/option_map_unwrap_or.rs
@@ -84,7 +84,7 @@ pub(super) fn check<'tcx>(
                 suggestion.push((map_arg_span.with_hi(map_arg_span.lo()), format!("{unwrap_snippet}, ")));
             }
 
-            diag.multipart_suggestion(&format!("use `{suggest}` instead"), suggestion, applicability);
+            diag.multipart_suggestion(format!("use `{suggest}` instead"), suggestion, applicability);
         });
     }
 }
diff --git a/clippy_lints/src/methods/str_splitn.rs b/clippy_lints/src/methods/str_splitn.rs
index 3c01ce1fecd..d00708e828e 100644
--- a/clippy_lints/src/methods/str_splitn.rs
+++ b/clippy_lints/src/methods/str_splitn.rs
@@ -167,7 +167,7 @@ fn check_manual_split_once_indirect(
             };
             diag.span_suggestion_verbose(
                 local.span,
-                &format!("try `{r}split_once`"),
+                format!("try `{r}split_once`"),
                 format!("let ({lhs}, {rhs}) = {self_snip}.{r}split_once({pat_snip}){unwrap};"),
                 app,
             );
diff --git a/clippy_lints/src/methods/unnecessary_lazy_eval.rs b/clippy_lints/src/methods/unnecessary_lazy_eval.rs
index 0e73459ad65..47e2e744112 100644
--- a/clippy_lints/src/methods/unnecessary_lazy_eval.rs
+++ b/clippy_lints/src/methods/unnecessary_lazy_eval.rs
@@ -62,7 +62,7 @@ pub(super) fn check<'tcx>(
                     span_lint_and_then(cx, UNNECESSARY_LAZY_EVALUATIONS, expr.span, msg, |diag| {
                         diag.span_suggestion(
                             span,
-                            &format!("use `{simplify_using}(..)` instead"),
+                            format!("use `{simplify_using}(..)` instead"),
                             format!("{simplify_using}({})", snippet(cx, body_expr.span, "..")),
                             applicability,
                         );
diff --git a/clippy_lints/src/needless_late_init.rs b/clippy_lints/src/needless_late_init.rs
index 67debe7e08a..5a9387b34cc 100644
--- a/clippy_lints/src/needless_late_init.rs
+++ b/clippy_lints/src/needless_late_init.rs
@@ -284,7 +284,7 @@ fn check<'tcx>(
 
                     diag.span_suggestion(
                         assign.lhs_span,
-                        &format!("declare `{binding_name}` here"),
+                        format!("declare `{binding_name}` here"),
                         let_snippet,
                         Applicability::MachineApplicable,
                     );
@@ -304,7 +304,7 @@ fn check<'tcx>(
 
                     diag.span_suggestion_verbose(
                         usage.stmt.span.shrink_to_lo(),
-                        &format!("declare `{binding_name}` here"),
+                        format!("declare `{binding_name}` here"),
                         format!("{let_snippet} = "),
                         applicability,
                     );
@@ -335,7 +335,7 @@ fn check<'tcx>(
 
                     diag.span_suggestion_verbose(
                         usage.stmt.span.shrink_to_lo(),
-                        &format!("declare `{binding_name}` here"),
+                        format!("declare `{binding_name}` here"),
                         format!("{let_snippet} = "),
                         applicability,
                     );
diff --git a/clippy_lints/src/octal_escapes.rs b/clippy_lints/src/octal_escapes.rs
index ae0a41db918..7376ab0c846 100644
--- a/clippy_lints/src/octal_escapes.rs
+++ b/clippy_lints/src/octal_escapes.rs
@@ -125,7 +125,7 @@ fn check_lit(cx: &EarlyContext<'_>, lit: &Lit, span: Span, is_string: bool) {
             if is_string { "string" } else { "byte string" }
         ),
         |diag| {
-            diag.help(&format!(
+            diag.help(format!(
                 "octal escapes are not supported, `\\0` is always a null {}",
                 if is_string { "character" } else { "byte" }
             ));
@@ -139,7 +139,7 @@ fn check_lit(cx: &EarlyContext<'_>, lit: &Lit, span: Span, is_string: bool) {
             // suggestion 2: unambiguous null byte
             diag.span_suggestion(
                 span,
-                &format!(
+                format!(
                     "if the null {} is intended, disambiguate using",
                     if is_string { "character" } else { "byte" }
                 ),
diff --git a/clippy_lints/src/operators/misrefactored_assign_op.rs b/clippy_lints/src/operators/misrefactored_assign_op.rs
index ae805147f07..015f6c14e76 100644
--- a/clippy_lints/src/operators/misrefactored_assign_op.rs
+++ b/clippy_lints/src/operators/misrefactored_assign_op.rs
@@ -50,7 +50,7 @@ fn lint_misrefactored_assign_op(
                 let long = format!("{snip_a} = {}", sugg::make_binop(op.into(), a, r));
                 diag.span_suggestion(
                     expr.span,
-                    &format!(
+                    format!(
                         "did you mean `{snip_a} = {snip_a} {} {snip_r}` or `{long}`? Consider replacing it with",
                         op.as_str()
                     ),
diff --git a/clippy_lints/src/same_name_method.rs b/clippy_lints/src/same_name_method.rs
index 91326558cd8..f35bfb0b4ed 100644
--- a/clippy_lints/src/same_name_method.rs
+++ b/clippy_lints/src/same_name_method.rs
@@ -108,7 +108,7 @@ impl<'tcx> LateLintPass<'tcx> for SameNameMethod {
                                     |diag| {
                                         diag.span_note(
                                             trait_method_span,
-                                            &format!("existing `{method_name}` defined here"),
+                                            format!("existing `{method_name}` defined here"),
                                         );
                                     },
                                 );
@@ -151,7 +151,7 @@ impl<'tcx> LateLintPass<'tcx> for SameNameMethod {
                                         // iterate on trait_spans?
                                         diag.span_note(
                                             trait_spans[0],
-                                            &format!("existing `{method_name}` defined here"),
+                                            format!("existing `{method_name}` defined here"),
                                         );
                                     },
                                 );
diff --git a/clippy_lints/src/swap.rs b/clippy_lints/src/swap.rs
index c374529d1ea..17e9cc5f6b7 100644
--- a/clippy_lints/src/swap.rs
+++ b/clippy_lints/src/swap.rs
@@ -132,7 +132,7 @@ fn generate_swap_warning(cx: &LateContext<'_>, e1: &Expr<'_>, e2: &Expr<'_>, spa
                 applicability,
             );
             if !is_xor_based {
-                diag.note(&format!("or maybe you should use `{sugg}::mem::replace`?"));
+                diag.note(format!("or maybe you should use `{sugg}::mem::replace`?"));
             }
         },
     );
@@ -214,7 +214,7 @@ fn check_suspicious_swap(cx: &LateContext<'_>, block: &Block<'_>) {
                                 Applicability::MaybeIncorrect,
                             );
                             diag.note(
-                                &format!("or maybe you should use `{sugg}::mem::replace`?")
+                                format!("or maybe you should use `{sugg}::mem::replace`?")
                             );
                         }
                     });
diff --git a/clippy_lints/src/transmute/transmute_undefined_repr.rs b/clippy_lints/src/transmute/transmute_undefined_repr.rs
index 34642f4b122..af0242348ac 100644
--- a/clippy_lints/src/transmute/transmute_undefined_repr.rs
+++ b/clippy_lints/src/transmute/transmute_undefined_repr.rs
@@ -77,7 +77,7 @@ pub(super) fn check<'tcx>(
                     &format!("transmute from `{from_ty_orig}` which has an undefined layout"),
                     |diag| {
                         if from_ty_orig.peel_refs() != from_ty.peel_refs() {
-                            diag.note(&format!("the contained type `{from_ty}` has an undefined layout"));
+                            diag.note(format!("the contained type `{from_ty}` has an undefined layout"));
                         }
                     },
                 );
@@ -91,7 +91,7 @@ pub(super) fn check<'tcx>(
                     &format!("transmute to `{to_ty_orig}` which has an undefined layout"),
                     |diag| {
                         if to_ty_orig.peel_refs() != to_ty.peel_refs() {
-                            diag.note(&format!("the contained type `{to_ty}` has an undefined layout"));
+                            diag.note(format!("the contained type `{to_ty}` has an undefined layout"));
                         }
                     },
                 );
@@ -119,16 +119,16 @@ pub(super) fn check<'tcx>(
                     ),
                     |diag| {
                         if let Some(same_adt_did) = same_adt_did {
-                            diag.note(&format!(
+                            diag.note(format!(
                                 "two instances of the same generic type (`{}`) may have different layouts",
                                 cx.tcx.item_name(same_adt_did)
                             ));
                         } else {
                             if from_ty_orig.peel_refs() != from_ty {
-                                diag.note(&format!("the contained type `{from_ty}` has an undefined layout"));
+                                diag.note(format!("the contained type `{from_ty}` has an undefined layout"));
                             }
                             if to_ty_orig.peel_refs() != to_ty {
-                                diag.note(&format!("the contained type `{to_ty}` has an undefined layout"));
+                                diag.note(format!("the contained type `{to_ty}` has an undefined layout"));
                             }
                         }
                     },
@@ -146,7 +146,7 @@ pub(super) fn check<'tcx>(
                     &format!("transmute from `{from_ty_orig}` which has an undefined layout"),
                     |diag| {
                         if from_ty_orig.peel_refs() != from_ty {
-                            diag.note(&format!("the contained type `{from_ty}` has an undefined layout"));
+                            diag.note(format!("the contained type `{from_ty}` has an undefined layout"));
                         }
                     },
                 );
@@ -163,7 +163,7 @@ pub(super) fn check<'tcx>(
                     &format!("transmute into `{to_ty_orig}` which has an undefined layout"),
                     |diag| {
                         if to_ty_orig.peel_refs() != to_ty {
-                            diag.note(&format!("the contained type `{to_ty}` has an undefined layout"));
+                            diag.note(format!("the contained type `{to_ty}` has an undefined layout"));
                         }
                     },
                 );
diff --git a/clippy_lints/src/transmute/transmutes_expressible_as_ptr_casts.rs b/clippy_lints/src/transmute/transmutes_expressible_as_ptr_casts.rs
index 6b444922a7c..b79d4e915a2 100644
--- a/clippy_lints/src/transmute/transmutes_expressible_as_ptr_casts.rs
+++ b/clippy_lints/src/transmute/transmutes_expressible_as_ptr_casts.rs
@@ -24,7 +24,7 @@ pub(super) fn check<'tcx>(
             &format!("transmute from `{from_ty}` to `{to_ty}` which could be expressed as a pointer cast instead"),
             |diag| {
                 if let Some(arg) = sugg::Sugg::hir_opt(cx, arg) {
-                    let sugg = arg.as_ty(&to_ty.to_string()).to_string();
+                    let sugg = arg.as_ty(to_ty.to_string()).to_string();
                     diag.span_suggestion(e.span, "try", sugg, Applicability::MachineApplicable);
                 }
             },
diff --git a/clippy_lints/src/transmute/useless_transmute.rs b/clippy_lints/src/transmute/useless_transmute.rs
index f919bbd5afc..871c3fadbba 100644
--- a/clippy_lints/src/transmute/useless_transmute.rs
+++ b/clippy_lints/src/transmute/useless_transmute.rs
@@ -61,7 +61,7 @@ pub(super) fn check<'tcx>(
                 "transmute from an integer to a pointer",
                 |diag| {
                     if let Some(arg) = sugg::Sugg::hir_opt(cx, arg) {
-                        diag.span_suggestion(e.span, "try", arg.as_ty(&to_ty.to_string()), Applicability::Unspecified);
+                        diag.span_suggestion(e.span, "try", arg.as_ty(to_ty.to_string()), Applicability::Unspecified);
                     }
                 },
             );
diff --git a/clippy_lints/src/types/redundant_allocation.rs b/clippy_lints/src/types/redundant_allocation.rs
index fae5385ffc8..f9b9a66b5fa 100644
--- a/clippy_lints/src/types/redundant_allocation.rs
+++ b/clippy_lints/src/types/redundant_allocation.rs
@@ -31,7 +31,7 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_
             &format!("usage of `{outer_sym}<{generic_snippet}>`"),
             |diag| {
                 diag.span_suggestion(hir_ty.span, "try", format!("{generic_snippet}"), applicability);
-                diag.note(&format!(
+                diag.note(format!(
                     "`{generic_snippet}` is already a pointer, `{outer_sym}<{generic_snippet}>` allocates a pointer on the heap"
                 ));
             },
@@ -78,7 +78,7 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_
                     format!("{outer_sym}<{generic_snippet}>"),
                     applicability,
                 );
-                diag.note(&format!(
+                diag.note(format!(
                     "`{inner_sym}<{generic_snippet}>` is already on the heap, `{outer_sym}<{inner_sym}<{generic_snippet}>>` makes an extra allocation"
                 ));
             },
@@ -91,10 +91,10 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_
             hir_ty.span,
             &format!("usage of `{outer_sym}<{inner_sym}<{generic_snippet}>>`"),
             |diag| {
-                diag.note(&format!(
+                diag.note(format!(
                     "`{inner_sym}<{generic_snippet}>` is already on the heap, `{outer_sym}<{inner_sym}<{generic_snippet}>>` makes an extra allocation"
                 ));
-                diag.help(&format!(
+                diag.help(format!(
                     "consider using just `{outer_sym}<{generic_snippet}>` or `{inner_sym}<{generic_snippet}>`"
                 ));
             },
diff --git a/clippy_lints/src/unit_types/unit_arg.rs b/clippy_lints/src/unit_types/unit_arg.rs
index f6d3fb00f4e..ef9f740f704 100644
--- a/clippy_lints/src/unit_types/unit_arg.rs
+++ b/clippy_lints/src/unit_types/unit_arg.rs
@@ -129,7 +129,7 @@ fn lint_unit_args(cx: &LateContext<'_>, expr: &Expr<'_>, args_to_recover: &[&Exp
 
                 if arg_snippets_without_empty_blocks.is_empty() {
                     db.multipart_suggestion(
-                        &format!("use {singular}unit literal{plural} instead"),
+                        format!("use {singular}unit literal{plural} instead"),
                         args_to_recover
                             .iter()
                             .map(|arg| (arg.span, "()".to_string()))
@@ -142,7 +142,7 @@ fn lint_unit_args(cx: &LateContext<'_>, expr: &Expr<'_>, args_to_recover: &[&Exp
                     let it_or_them = if plural { "them" } else { "it" };
                     db.span_suggestion(
                         expr.span,
-                        &format!(
+                        format!(
                             "{or}move the expression{empty_or_s} in front of the call and replace {it_or_them} with the unit literal `()`"
                         ),
                         sugg,
diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs
index 6b321765bc0..df335038881 100644
--- a/clippy_lints/src/write.rs
+++ b/clippy_lints/src/write.rs
@@ -377,7 +377,7 @@ fn check_newline(cx: &LateContext<'_>, format_args: &FormatArgsExpn<'_>, macro_c
                     // print!("\n"), write!(f, "\n")
 
                     diag.multipart_suggestion(
-                        &format!("use `{name}ln!` instead"),
+                        format!("use `{name}ln!` instead"),
                         vec![(name_span, format!("{name}ln")), (format_string_span, String::new())],
                         Applicability::MachineApplicable,
                     );
@@ -388,7 +388,7 @@ fn check_newline(cx: &LateContext<'_>, format_args: &FormatArgsExpn<'_>, macro_c
                     let newline_span = format_string_span.with_lo(hi - BytePos(3)).with_hi(hi - BytePos(1));
 
                     diag.multipart_suggestion(
-                        &format!("use `{name}ln!` instead"),
+                        format!("use `{name}ln!` instead"),
                         vec![(name_span, format!("{name}ln")), (newline_span, String::new())],
                         Applicability::MachineApplicable,
                     );
diff --git a/clippy_utils/src/diagnostics.rs b/clippy_utils/src/diagnostics.rs
index 16b160b6fd2..812f6fe71a0 100644
--- a/clippy_utils/src/diagnostics.rs
+++ b/clippy_utils/src/diagnostics.rs
@@ -17,7 +17,7 @@ use std::env;
 fn docs_link(diag: &mut Diagnostic, lint: &'static Lint) {
     if env::var("CLIPPY_DISABLE_DOCS_LINKS").is_err() {
         if let Some(lint) = lint.name_lower().strip_prefix("clippy::") {
-            diag.help(&format!(
+            diag.help(format!(
                 "for further information visit https://rust-lang.github.io/rust-clippy/{}/index.html#{lint}",
                 &option_env!("RUST_RELEASE_NUM").map_or("master".to_string(), |n| {
                     // extract just major + minor version and ignore patch versions
diff --git a/tests/ui/manual_retain.fixed b/tests/ui/manual_retain.fixed
index e5ae3cf3e50..8f25fea678f 100644
--- a/tests/ui/manual_retain.fixed
+++ b/tests/ui/manual_retain.fixed
@@ -1,6 +1,6 @@
 // run-rustfix
 #![warn(clippy::manual_retain)]
-#![allow(unused)]
+#![allow(unused, clippy::redundant_clone)]
 use std::collections::BTreeMap;
 use std::collections::BTreeSet;
 use std::collections::BinaryHeap;
diff --git a/tests/ui/manual_retain.rs b/tests/ui/manual_retain.rs
index 1021f15edd1..e6b3995a689 100644
--- a/tests/ui/manual_retain.rs
+++ b/tests/ui/manual_retain.rs
@@ -1,6 +1,6 @@
 // run-rustfix
 #![warn(clippy::manual_retain)]
-#![allow(unused)]
+#![allow(unused, clippy::redundant_clone)]
 use std::collections::BTreeMap;
 use std::collections::BTreeSet;
 use std::collections::BinaryHeap;
-- 
cgit 1.4.1-3-g733a5


From b21cc36ee92a2cf3c387b47e40faa2aa4d39fd1a Mon Sep 17 00:00:00 2001
From: chansuke <moonset20@gmail.com>
Date: Sat, 17 Dec 2022 21:13:02 +0900
Subject: hotfix: add help dialog for `PermissionExt`

---
 clippy_lints/src/permissions_set_readonly_false.rs | 33 ++++++++++++----------
 tests/ui/permissions_set_readonly_false.stderr     |  2 ++
 2 files changed, 20 insertions(+), 15 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/permissions_set_readonly_false.rs b/clippy_lints/src/permissions_set_readonly_false.rs
index 6c463bd8fce..e7095ec191f 100644
--- a/clippy_lints/src/permissions_set_readonly_false.rs
+++ b/clippy_lints/src/permissions_set_readonly_false.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_note;
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::paths;
 use clippy_utils::ty::match_type;
 use rustc_ast::ast::LitKind;
@@ -8,11 +8,11 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for calls to `std::fs::Permissions.set_readonly` with argument `false`
+    /// Checks for calls to `std::fs::Permissions.set_readonly` with argument `false`.
     ///
     /// ### Why is this bad?
-    /// On Unix platforms this results in the file being world writable
-    ///
+    /// On Unix platforms this results in the file being world writable,
+    /// equivalent to `chmod a+w <file>`.
     /// ### Example
     /// ```rust
     /// use std::fs::File;
@@ -32,18 +32,21 @@ impl<'tcx> LateLintPass<'tcx> for PermissionsSetReadonlyFalse {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
         if let ExprKind::MethodCall(path, receiver, [arg], _) = &expr.kind
             && match_type(cx, cx.typeck_results().expr_ty(receiver), &paths::PERMISSIONS)
-                && path.ident.name == sym!(set_readonly)
-                && let ExprKind::Lit(lit) = &arg.kind
-                && LitKind::Bool(false) == lit.node
+            && path.ident.name == sym!(set_readonly)
+            && let ExprKind::Lit(lit) = &arg.kind
+            && LitKind::Bool(false) == lit.node
         {
-                span_lint_and_note(
-                    cx,
-                    PERMISSIONS_SET_READONLY_FALSE,
-                    expr.span,
-                    "call to `set_readonly` with argument `false`",
-                    None,
-                    "on Unix platforms this results in the file being world writable",
-                );
+            span_lint_and_then(
+                cx,
+                PERMISSIONS_SET_READONLY_FALSE,
+                expr.span,
+                "call to `set_readonly` with argument `false`",
+                |diag| {
+                    diag.note("on Unix platforms this results in the file being world writable");
+                    diag.help("you can set the desired permissions using `PermissionsExt`. For more information, see\n\
+                        https://doc.rust-lang.org/std/os/unix/fs/trait.PermissionsExt.html");
+                }
+            );
         }
     }
 }
diff --git a/tests/ui/permissions_set_readonly_false.stderr b/tests/ui/permissions_set_readonly_false.stderr
index 106d2f793a4..e7a8ee6cb19 100644
--- a/tests/ui/permissions_set_readonly_false.stderr
+++ b/tests/ui/permissions_set_readonly_false.stderr
@@ -5,6 +5,8 @@ LL |     permissions.set_readonly(false);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: on Unix platforms this results in the file being world writable
+   = help: you can set the desired permissions using `PermissionsExt`. For more information, see
+           https://doc.rust-lang.org/std/os/unix/fs/trait.PermissionsExt.html
    = note: `-D clippy::permissions-set-readonly-false` implied by `-D warnings`
 
 error: aborting due to previous error
-- 
cgit 1.4.1-3-g733a5


From b6882f6107193696e14ab21fb0ee9921a4e0b842 Mon Sep 17 00:00:00 2001
From: Niki4tap <rombiklol2@gmail.com>
Date: Thu, 22 Dec 2022 12:40:05 +0300
Subject: Fix FP in needless_return when using yeet

---
 clippy_lints/src/returns.rs     |  8 +++-
 tests/ui/needless_return.fixed  |  5 +++
 tests/ui/needless_return.rs     |  5 +++
 tests/ui/needless_return.stderr | 92 ++++++++++++++++++++---------------------
 4 files changed, 63 insertions(+), 47 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
index 81143d7799e..d4d50660520 100644
--- a/clippy_lints/src/returns.rs
+++ b/clippy_lints/src/returns.rs
@@ -6,7 +6,7 @@ use core::ops::ControlFlow;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::FnKind;
-use rustc_hir::{Block, Body, Expr, ExprKind, FnDecl, HirId, MatchSource, PatKind, StmtKind};
+use rustc_hir::{Block, Body, Expr, ExprKind, FnDecl, HirId, LangItem, MatchSource, PatKind, QPath, StmtKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::subst::GenericArgKind;
@@ -207,6 +207,12 @@ fn check_final_expr<'tcx>(
     match &peeled_drop_expr.kind {
         // simple return is always "bad"
         ExprKind::Ret(ref inner) => {
+            // if desugar of `do yeet`, don't lint
+            if let Some(inner_expr) = inner
+                && let ExprKind::Call(path_expr, _) = inner_expr.kind
+                && let ExprKind::Path(QPath::LangItem(LangItem::TryTraitFromYeet, _, _)) = path_expr.kind {
+                    return;
+            }
             if cx.tcx.hir().attrs(expr.hir_id).is_empty() {
                 let borrows = inner.map_or(false, |inner| last_statement_borrows(cx, inner));
                 if !borrows {
diff --git a/tests/ui/needless_return.fixed b/tests/ui/needless_return.fixed
index 4386aaec49e..d451be1f389 100644
--- a/tests/ui/needless_return.fixed
+++ b/tests/ui/needless_return.fixed
@@ -1,6 +1,7 @@
 // run-rustfix
 
 #![feature(lint_reasons)]
+#![feature(yeet_expr)]
 #![allow(unused)]
 #![allow(
     clippy::if_same_then_else,
@@ -272,4 +273,8 @@ mod issue9416 {
     }
 }
 
+fn issue9947() -> Result<(), String> {
+    do yeet "hello";
+}
+
 fn main() {}
diff --git a/tests/ui/needless_return.rs b/tests/ui/needless_return.rs
index 666dc54b76b..e1a1bea2c0b 100644
--- a/tests/ui/needless_return.rs
+++ b/tests/ui/needless_return.rs
@@ -1,6 +1,7 @@
 // run-rustfix
 
 #![feature(lint_reasons)]
+#![feature(yeet_expr)]
 #![allow(unused)]
 #![allow(
     clippy::if_same_then_else,
@@ -282,4 +283,8 @@ mod issue9416 {
     }
 }
 
+fn issue9947() -> Result<(), String> {
+    do yeet "hello";
+}
+
 fn main() {}
diff --git a/tests/ui/needless_return.stderr b/tests/ui/needless_return.stderr
index a8b5d86cd55..ca2253e6586 100644
--- a/tests/ui/needless_return.stderr
+++ b/tests/ui/needless_return.stderr
@@ -1,5 +1,5 @@
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:26:5
+  --> $DIR/needless_return.rs:27:5
    |
 LL |     return true;
    |     ^^^^^^^^^^^
@@ -8,7 +8,7 @@ LL |     return true;
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:30:5
+  --> $DIR/needless_return.rs:31:5
    |
 LL |     return true;
    |     ^^^^^^^^^^^
@@ -16,7 +16,7 @@ LL |     return true;
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:35:9
+  --> $DIR/needless_return.rs:36:9
    |
 LL |         return true;
    |         ^^^^^^^^^^^
@@ -24,7 +24,7 @@ LL |         return true;
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:37:9
+  --> $DIR/needless_return.rs:38:9
    |
 LL |         return false;
    |         ^^^^^^^^^^^^
@@ -32,7 +32,7 @@ LL |         return false;
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:43:17
+  --> $DIR/needless_return.rs:44:17
    |
 LL |         true => return false,
    |                 ^^^^^^^^^^^^
@@ -40,7 +40,7 @@ LL |         true => return false,
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:45:13
+  --> $DIR/needless_return.rs:46:13
    |
 LL |             return true;
    |             ^^^^^^^^^^^
@@ -48,7 +48,7 @@ LL |             return true;
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:52:9
+  --> $DIR/needless_return.rs:53:9
    |
 LL |         return true;
    |         ^^^^^^^^^^^
@@ -56,7 +56,7 @@ LL |         return true;
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:54:16
+  --> $DIR/needless_return.rs:55:16
    |
 LL |     let _ = || return true;
    |                ^^^^^^^^^^^
@@ -64,7 +64,7 @@ LL |     let _ = || return true;
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:58:5
+  --> $DIR/needless_return.rs:59:5
    |
 LL |     return the_answer!();
    |     ^^^^^^^^^^^^^^^^^^^^
@@ -72,7 +72,7 @@ LL |     return the_answer!();
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:61:21
+  --> $DIR/needless_return.rs:62:21
    |
 LL |   fn test_void_fun() {
    |  _____________________^
@@ -82,7 +82,7 @@ LL | |     return;
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:66:11
+  --> $DIR/needless_return.rs:67:11
    |
 LL |       if b {
    |  ___________^
@@ -92,7 +92,7 @@ LL | |         return;
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:68:13
+  --> $DIR/needless_return.rs:69:13
    |
 LL |       } else {
    |  _____________^
@@ -102,7 +102,7 @@ LL | |         return;
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:76:14
+  --> $DIR/needless_return.rs:77:14
    |
 LL |         _ => return,
    |              ^^^^^^
@@ -110,7 +110,7 @@ LL |         _ => return,
    = help: replace `return` with a unit value
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:84:24
+  --> $DIR/needless_return.rs:85:24
    |
 LL |               let _ = 42;
    |  ________________________^
@@ -120,7 +120,7 @@ LL | |             return;
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:87:14
+  --> $DIR/needless_return.rs:88:14
    |
 LL |         _ => return,
    |              ^^^^^^
@@ -128,7 +128,7 @@ LL |         _ => return,
    = help: replace `return` with a unit value
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:100:9
+  --> $DIR/needless_return.rs:101:9
    |
 LL |         return String::from("test");
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -136,7 +136,7 @@ LL |         return String::from("test");
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:102:9
+  --> $DIR/needless_return.rs:103:9
    |
 LL |         return String::new();
    |         ^^^^^^^^^^^^^^^^^^^^
@@ -144,7 +144,7 @@ LL |         return String::new();
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:124:32
+  --> $DIR/needless_return.rs:125:32
    |
 LL |         bar.unwrap_or_else(|_| return)
    |                                ^^^^^^
@@ -152,7 +152,7 @@ LL |         bar.unwrap_or_else(|_| return)
    = help: replace `return` with an empty block
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:128:21
+  --> $DIR/needless_return.rs:129:21
    |
 LL |           let _ = || {
    |  _____________________^
@@ -162,7 +162,7 @@ LL | |             return;
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:131:20
+  --> $DIR/needless_return.rs:132:20
    |
 LL |         let _ = || return;
    |                    ^^^^^^
@@ -170,7 +170,7 @@ LL |         let _ = || return;
    = help: replace `return` with an empty block
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:137:32
+  --> $DIR/needless_return.rs:138:32
    |
 LL |         res.unwrap_or_else(|_| return Foo)
    |                                ^^^^^^^^^^
@@ -178,7 +178,7 @@ LL |         res.unwrap_or_else(|_| return Foo)
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:146:5
+  --> $DIR/needless_return.rs:147:5
    |
 LL |     return true;
    |     ^^^^^^^^^^^
@@ -186,7 +186,7 @@ LL |     return true;
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:150:5
+  --> $DIR/needless_return.rs:151:5
    |
 LL |     return true;
    |     ^^^^^^^^^^^
@@ -194,7 +194,7 @@ LL |     return true;
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:155:9
+  --> $DIR/needless_return.rs:156:9
    |
 LL |         return true;
    |         ^^^^^^^^^^^
@@ -202,7 +202,7 @@ LL |         return true;
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:157:9
+  --> $DIR/needless_return.rs:158:9
    |
 LL |         return false;
    |         ^^^^^^^^^^^^
@@ -210,7 +210,7 @@ LL |         return false;
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:163:17
+  --> $DIR/needless_return.rs:164:17
    |
 LL |         true => return false,
    |                 ^^^^^^^^^^^^
@@ -218,7 +218,7 @@ LL |         true => return false,
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:165:13
+  --> $DIR/needless_return.rs:166:13
    |
 LL |             return true;
    |             ^^^^^^^^^^^
@@ -226,7 +226,7 @@ LL |             return true;
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:172:9
+  --> $DIR/needless_return.rs:173:9
    |
 LL |         return true;
    |         ^^^^^^^^^^^
@@ -234,7 +234,7 @@ LL |         return true;
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:174:16
+  --> $DIR/needless_return.rs:175:16
    |
 LL |     let _ = || return true;
    |                ^^^^^^^^^^^
@@ -242,7 +242,7 @@ LL |     let _ = || return true;
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:178:5
+  --> $DIR/needless_return.rs:179:5
    |
 LL |     return the_answer!();
    |     ^^^^^^^^^^^^^^^^^^^^
@@ -250,7 +250,7 @@ LL |     return the_answer!();
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:181:33
+  --> $DIR/needless_return.rs:182:33
    |
 LL |   async fn async_test_void_fun() {
    |  _________________________________^
@@ -260,7 +260,7 @@ LL | |     return;
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:186:11
+  --> $DIR/needless_return.rs:187:11
    |
 LL |       if b {
    |  ___________^
@@ -270,7 +270,7 @@ LL | |         return;
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:188:13
+  --> $DIR/needless_return.rs:189:13
    |
 LL |       } else {
    |  _____________^
@@ -280,7 +280,7 @@ LL | |         return;
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:196:14
+  --> $DIR/needless_return.rs:197:14
    |
 LL |         _ => return,
    |              ^^^^^^
@@ -288,7 +288,7 @@ LL |         _ => return,
    = help: replace `return` with a unit value
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:209:9
+  --> $DIR/needless_return.rs:210:9
    |
 LL |         return String::from("test");
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -296,7 +296,7 @@ LL |         return String::from("test");
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:211:9
+  --> $DIR/needless_return.rs:212:9
    |
 LL |         return String::new();
    |         ^^^^^^^^^^^^^^^^^^^^
@@ -304,7 +304,7 @@ LL |         return String::new();
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:227:5
+  --> $DIR/needless_return.rs:228:5
    |
 LL |     return format!("Hello {}", "world!");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -312,7 +312,7 @@ LL |     return format!("Hello {}", "world!");
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:238:9
+  --> $DIR/needless_return.rs:239:9
    |
 LL |         return true;
    |         ^^^^^^^^^^^
@@ -320,7 +320,7 @@ LL |         return true;
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:240:9
+  --> $DIR/needless_return.rs:241:9
    |
 LL |         return false;
    |         ^^^^^^^^^^^^
@@ -328,7 +328,7 @@ LL |         return false;
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:247:13
+  --> $DIR/needless_return.rs:248:13
    |
 LL |             return 10;
    |             ^^^^^^^^^
@@ -336,7 +336,7 @@ LL |             return 10;
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:250:13
+  --> $DIR/needless_return.rs:251:13
    |
 LL |             return 100;
    |             ^^^^^^^^^^
@@ -344,7 +344,7 @@ LL |             return 100;
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:258:9
+  --> $DIR/needless_return.rs:259:9
    |
 LL |         return 0;
    |         ^^^^^^^^
@@ -352,7 +352,7 @@ LL |         return 0;
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:265:13
+  --> $DIR/needless_return.rs:266:13
    |
 LL |             return *(x as *const isize);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -360,7 +360,7 @@ LL |             return *(x as *const isize);
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:267:13
+  --> $DIR/needless_return.rs:268:13
    |
 LL |             return !*(x as *const isize);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -368,7 +368,7 @@ LL |             return !*(x as *const isize);
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:274:20
+  --> $DIR/needless_return.rs:275:20
    |
 LL |           let _ = 42;
    |  ____________________^
@@ -379,7 +379,7 @@ LL | |         return;
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:281:20
+  --> $DIR/needless_return.rs:282:20
    |
 LL |         let _ = 42; return;
    |                    ^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From 0cd9b06125c5a4ffce659bc92328946be94ccc2b Mon Sep 17 00:00:00 2001
From: Niki4tap <rombiklol2@gmail.com>
Date: Fri, 23 Dec 2022 00:56:50 +0300
Subject: Small code style adjustments

---
 clippy_lints/src/returns.rs | 31 +++++++++++++++++--------------
 1 file changed, 17 insertions(+), 14 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
index d4d50660520..0da50450512 100644
--- a/clippy_lints/src/returns.rs
+++ b/clippy_lints/src/returns.rs
@@ -210,22 +210,25 @@ fn check_final_expr<'tcx>(
             // if desugar of `do yeet`, don't lint
             if let Some(inner_expr) = inner
                 && let ExprKind::Call(path_expr, _) = inner_expr.kind
-                && let ExprKind::Path(QPath::LangItem(LangItem::TryTraitFromYeet, _, _)) = path_expr.kind {
-                    return;
+                && let ExprKind::Path(QPath::LangItem(LangItem::TryTraitFromYeet, _, _)) = path_expr.kind
+            {
+                return;
             }
-            if cx.tcx.hir().attrs(expr.hir_id).is_empty() {
-                let borrows = inner.map_or(false, |inner| last_statement_borrows(cx, inner));
-                if !borrows {
-                    // check if expr return nothing
-                    let ret_span = if inner.is_none() && replacement == RetReplacement::Empty {
-                        extend_span_to_previous_non_ws(cx, peeled_drop_expr.span)
-                    } else {
-                        peeled_drop_expr.span
-                    };
-
-                    emit_return_lint(cx, ret_span, semi_spans, inner.as_ref().map(|i| i.span), replacement);
-                }
+            if !cx.tcx.hir().attrs(expr.hir_id).is_empty() {
+                return;
+            }
+            let borrows = inner.map_or(false, |inner| last_statement_borrows(cx, inner));
+            if borrows {
+                return;
             }
+            // check if expr return nothing
+            let ret_span = if inner.is_none() && replacement == RetReplacement::Empty {
+                extend_span_to_previous_non_ws(cx, peeled_drop_expr.span)
+            } else {
+                peeled_drop_expr.span
+            };
+
+            emit_return_lint(cx, ret_span, semi_spans, inner.as_ref().map(|i| i.span), replacement);
         },
         ExprKind::If(_, then, else_clause_opt) => {
             check_block_return(cx, &then.kind, semi_spans.clone());
-- 
cgit 1.4.1-3-g733a5


From a9358260717e55c367f16bc033990bac77cfb5a1 Mon Sep 17 00:00:00 2001
From: Niki4tap <rombiklol2@gmail.com>
Date: Fri, 23 Dec 2022 00:57:28 +0300
Subject: Fix the actual bug

---
 clippy_lints/src/returns.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
index 0da50450512..bbbd9e4989e 100644
--- a/clippy_lints/src/returns.rs
+++ b/clippy_lints/src/returns.rs
@@ -295,7 +295,7 @@ fn last_statement_borrows<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>)
         {
             ControlFlow::Break(())
         } else {
-            ControlFlow::Continue(Descend::from(!expr.span.from_expansion()))
+            ControlFlow::Continue(Descend::from(!e.span.from_expansion()))
         }
     })
     .is_some()
-- 
cgit 1.4.1-3-g733a5


From d7b9e195c2df9e576abd2eba54f3fe6516619054 Mon Sep 17 00:00:00 2001
From: Lukas Lueg <lukas.lueg@gmail.com>
Date: Sat, 17 Dec 2022 14:16:45 +0100
Subject: Add size_of_ref lint

Fixes #9995
---
 CHANGELOG.md                       |  1 +
 clippy_lints/src/declared_lints.rs |  1 +
 clippy_lints/src/lib.rs            |  2 ++
 clippy_lints/src/size_of_ref.rs    | 73 ++++++++++++++++++++++++++++++++++++++
 tests/ui/size_of_ref.rs            | 27 ++++++++++++++
 tests/ui/size_of_ref.stderr        | 27 ++++++++++++++
 6 files changed, 131 insertions(+)
 create mode 100644 clippy_lints/src/size_of_ref.rs
 create mode 100644 tests/ui/size_of_ref.rs
 create mode 100644 tests/ui/size_of_ref.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 52efa8db485..02f3188f8be 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4547,6 +4547,7 @@ Released 2018-09-13
 [`single_match`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_match
 [`single_match_else`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_match_else
 [`size_of_in_element_count`]: https://rust-lang.github.io/rust-clippy/master/index.html#size_of_in_element_count
+[`size_of_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#size_of_ref
 [`skip_while_next`]: https://rust-lang.github.io/rust-clippy/master/index.html#skip_while_next
 [`slow_vector_initialization`]: https://rust-lang.github.io/rust-clippy/master/index.html#slow_vector_initialization
 [`stable_sort_primitive`]: https://rust-lang.github.io/rust-clippy/master/index.html#stable_sort_primitive
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 980e128cba4..2982460c9cf 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -537,6 +537,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::single_char_lifetime_names::SINGLE_CHAR_LIFETIME_NAMES_INFO,
     crate::single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS_INFO,
     crate::size_of_in_element_count::SIZE_OF_IN_ELEMENT_COUNT_INFO,
+    crate::size_of_ref::SIZE_OF_REF_INFO,
     crate::slow_vector_initialization::SLOW_VECTOR_INITIALIZATION_INFO,
     crate::std_instead_of_core::ALLOC_INSTEAD_OF_CORE_INFO,
     crate::std_instead_of_core::STD_INSTEAD_OF_ALLOC_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 676ef3946bf..ccd89b77858 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -265,6 +265,7 @@ mod shadow;
 mod single_char_lifetime_names;
 mod single_component_path_imports;
 mod size_of_in_element_count;
+mod size_of_ref;
 mod slow_vector_initialization;
 mod std_instead_of_core;
 mod strings;
@@ -906,6 +907,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(semicolon_block::SemicolonBlock));
     store.register_late_pass(|_| Box::new(fn_null_check::FnNullCheck));
     store.register_late_pass(|_| Box::new(permissions_set_readonly_false::PermissionsSetReadonlyFalse));
+    store.register_late_pass(|_| Box::new(size_of_ref::SizeOfRef));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/size_of_ref.rs b/clippy_lints/src/size_of_ref.rs
new file mode 100644
index 00000000000..3fcdb4288ce
--- /dev/null
+++ b/clippy_lints/src/size_of_ref.rs
@@ -0,0 +1,73 @@
+use clippy_utils::{diagnostics::span_lint_and_help, path_def_id, ty::peel_mid_ty_refs};
+use rustc_hir::{Expr, ExprKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::sym;
+
+declare_clippy_lint! {
+    /// ### What it does
+    ///
+    /// Checks for calls to `std::mem::size_of_val()` where the argument is
+    /// a reference to a reference.
+    ///
+    /// ### Why is this bad?
+    ///
+    /// Calling `size_of_val()` with a reference to a reference as the argument
+    /// yields the size of the reference-type, not the size of the value behind
+    /// the reference.
+    ///
+    /// ### Example
+    /// ```rust
+    /// struct Foo {
+    ///     buffer: [u8],
+    /// }
+    ///
+    /// impl Foo {
+    ///     fn size(&self) -> usize {
+    ///         // Note that `&self` as an argument is a `&&Foo`: Because `self`
+    ///         // is already a reference, `&self` is a double-reference.
+    ///         // The return value of `size_of_val()` therefor is the
+    ///         // size of the reference-type, not the size of `self`.
+    ///         std::mem::size_of_val(&self)
+    ///     }
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// struct Foo {
+    ///     buffer: [u8],
+    /// }
+    ///
+    /// impl Foo {
+    ///     fn size(&self) -> usize {
+    ///         // Correct
+    ///         std::mem::size_of_val(self)
+    ///     }
+    /// }
+    /// ```
+    #[clippy::version = "1.67.0"]
+    pub SIZE_OF_REF,
+    suspicious,
+    "Argument to `std::mem::size_of_val()` is a double-reference, which is almost certainly unintended"
+}
+declare_lint_pass!(SizeOfRef => [SIZE_OF_REF]);
+
+impl LateLintPass<'_> for SizeOfRef {
+    fn check_expr(&mut self, cx: &LateContext<'_>, expr: &'_ Expr<'_>) {
+        if let ExprKind::Call(path, [arg]) = expr.kind
+            && let Some(def_id) = path_def_id(cx, path)
+            && cx.tcx.is_diagnostic_item(sym::mem_size_of_val, def_id)
+            && let arg_ty = cx.typeck_results().expr_ty(arg)
+            && peel_mid_ty_refs(arg_ty).1 > 1
+        {
+            span_lint_and_help(
+                cx,
+                SIZE_OF_REF,
+                expr.span,
+                "argument to `std::mem::size_of_val()` is a reference to a reference",
+                None,
+                "dereference the argument to `std::mem::size_of_val()` to get the size of the value instead of the size of the reference-type",
+            );
+        }
+    }
+}
diff --git a/tests/ui/size_of_ref.rs b/tests/ui/size_of_ref.rs
new file mode 100644
index 00000000000..1e83ab82907
--- /dev/null
+++ b/tests/ui/size_of_ref.rs
@@ -0,0 +1,27 @@
+#![allow(unused)]
+#![warn(clippy::size_of_ref)]
+
+use std::mem::size_of_val;
+
+fn main() {
+    let x = 5;
+    let y = &x;
+
+    size_of_val(&x); // no lint
+    size_of_val(y); // no lint
+
+    size_of_val(&&x);
+    size_of_val(&y);
+}
+
+struct S {
+    field: u32,
+    data: Vec<u8>,
+}
+
+impl S {
+    /// Get size of object including `self`, in bytes.
+    pub fn size(&self) -> usize {
+        std::mem::size_of_val(&self) + (std::mem::size_of::<u8>() * self.data.capacity())
+    }
+}
diff --git a/tests/ui/size_of_ref.stderr b/tests/ui/size_of_ref.stderr
new file mode 100644
index 00000000000..d4c13ac3290
--- /dev/null
+++ b/tests/ui/size_of_ref.stderr
@@ -0,0 +1,27 @@
+error: argument to `std::mem::size_of_val()` is a reference to a reference
+  --> $DIR/size_of_ref.rs:13:5
+   |
+LL |     size_of_val(&&x);
+   |     ^^^^^^^^^^^^^^^^
+   |
+   = help: dereference the argument to `std::mem::size_of_val()` to get the size of the value instead of the size of the reference-type
+   = note: `-D clippy::size-of-ref` implied by `-D warnings`
+
+error: argument to `std::mem::size_of_val()` is a reference to a reference
+  --> $DIR/size_of_ref.rs:14:5
+   |
+LL |     size_of_val(&y);
+   |     ^^^^^^^^^^^^^^^
+   |
+   = help: dereference the argument to `std::mem::size_of_val()` to get the size of the value instead of the size of the reference-type
+
+error: argument to `std::mem::size_of_val()` is a reference to a reference
+  --> $DIR/size_of_ref.rs:25:9
+   |
+LL |         std::mem::size_of_val(&self) + (std::mem::size_of::<u8>() * self.data.capacity())
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: dereference the argument to `std::mem::size_of_val()` to get the size of the value instead of the size of the reference-type
+
+error: aborting due to 3 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 0e5fcb7b7f13c30668637568e9eb11ce0672a5ed Mon Sep 17 00:00:00 2001
From: Ray Redondo <raydredondo@gmail.com>
Date: Sat, 24 Dec 2022 23:47:14 -0600
Subject: move mutex_atomic to clippy::restriction

---
 clippy_lints/src/mutex_atomic.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/mutex_atomic.rs b/clippy_lints/src/mutex_atomic.rs
index 09cb5333176..45bb217979a 100644
--- a/clippy_lints/src/mutex_atomic.rs
+++ b/clippy_lints/src/mutex_atomic.rs
@@ -39,7 +39,7 @@ declare_clippy_lint! {
     /// ```
     #[clippy::version = "pre 1.29.0"]
     pub MUTEX_ATOMIC,
-    nursery,
+    restriction,
     "using a mutex where an atomic value could be used instead"
 }
 
-- 
cgit 1.4.1-3-g733a5


From 12f2dea229a49a1b0d25453ba7993eb35aaadc6b Mon Sep 17 00:00:00 2001
From: Trevor Gross <tmgross@umich.edu>
Date: Sun, 25 Dec 2022 01:52:57 -0500
Subject: `not_unsafe_ptr_arg_deref` update documentation

---
 clippy_lints/src/functions/mod.rs | 33 ++++++++++++++++++++++++++++-----
 1 file changed, 28 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/functions/mod.rs b/clippy_lints/src/functions/mod.rs
index 91e6ffe6447..9dbce3f889b 100644
--- a/clippy_lints/src/functions/mod.rs
+++ b/clippy_lints/src/functions/mod.rs
@@ -63,23 +63,40 @@ declare_clippy_lint! {
     /// arguments but are not marked `unsafe`.
     ///
     /// ### Why is this bad?
-    /// The function should probably be marked `unsafe`, since
-    /// for an arbitrary raw pointer, there is no way of telling for sure if it is
-    /// valid.
+    /// The function should almost definitely be marked `unsafe`, since for an
+    /// arbitrary raw pointer, there is no way of telling for sure if it is valid.
+    ///
+    /// In general, this lint should **never be disabled** unless it is definitely a
+    /// false positive (please submit an issue if so) since it breaks Rust's
+    /// soundness guarantees, directly exposing API users to potentially dangerous
+    /// program behavior. This is also true for internal APIs, as it is easy to leak
+    /// unsoundness.
+    ///
+    /// ### Context
+    /// In Rust, an `unsafe {...}` block is used to indicate that the code in that
+    /// section has been verified in some way that the compiler can not. For a
+    /// function that accepts a raw pointer then accesses the pointer's data, this is
+    /// generally impossible as the incoming pointer could point anywhere, valid or
+    /// not. So, the signature should be marked `unsafe fn`: this indicates that the
+    /// function's caller must provide some verification that the arguments it sends
+    /// are valid (and then call the function within an `unsafe` block).
     ///
     /// ### Known problems
     /// * It does not check functions recursively so if the pointer is passed to a
     /// private non-`unsafe` function which does the dereferencing, the lint won't
-    /// trigger.
+    /// trigger (false negative).
     /// * It only checks for arguments whose type are raw pointers, not raw pointers
     /// got from an argument in some other way (`fn foo(bar: &[*const u8])` or
-    /// `some_argument.get_raw_ptr()`).
+    /// `some_argument.get_raw_ptr()`) (false negative).
     ///
     /// ### Example
     /// ```rust,ignore
     /// pub fn foo(x: *const u8) {
     ///     println!("{}", unsafe { *x });
     /// }
+    ///
+    /// // this call "looks" safe but will segfault or worse!
+    /// // foo(invalid_ptr);
     /// ```
     ///
     /// Use instead:
@@ -87,6 +104,12 @@ declare_clippy_lint! {
     /// pub unsafe fn foo(x: *const u8) {
     ///     println!("{}", unsafe { *x });
     /// }
+    ///
+    /// // this would cause a compiler error for calling without `unsafe`
+    /// // foo(invalid_ptr);
+    ///
+    /// // sound call if the caller knows the pointer is valid
+    /// unsafe { foo(valid_ptr); }
     /// ```
     #[clippy::version = "pre 1.29.0"]
     pub NOT_UNSAFE_PTR_ARG_DEREF,
-- 
cgit 1.4.1-3-g733a5


From fae19a9a79ad275af9e9f2ee5ad15404a9a1bbf7 Mon Sep 17 00:00:00 2001
From: koka <koka.code@gmail.com>
Date: Mon, 26 Dec 2022 01:51:46 +0900
Subject: Place default values near its definitions

This patch not only improves visibility, but also fixes a potential bug.
When a lint description ends with code block, the string will have three
backquotes at the end.
Since the current implementation prints the default value immediately
after that, the markdown renderer is unable to properly close the code
block.
---
 clippy_lints/src/utils/internal_lints/metadata_collector.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index 857abe77e21..929544cd69d 100644
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -558,8 +558,8 @@ impl fmt::Display for ClippyConfiguration {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> fmt::Result {
         writeln!(
             f,
-            "* `{}`: `{}`: {} (defaults to `{}`)",
-            self.name, self.config_type, self.doc, self.default
+            "* `{}`: `{}`(defaults to `{}`): {}",
+            self.name, self.config_type, self.default, self.doc
         )
     }
 }
-- 
cgit 1.4.1-3-g733a5


From 6bb6dd64d44eab37fef808ce96d3abb87e5e02b3 Mon Sep 17 00:00:00 2001
From: Eric Wu <eric.dianhao.wu@gmail.com>
Date: Fri, 23 Dec 2022 16:05:45 -0500
Subject: fix incorrect suggestion in `suboptimal_flops`

There was an error when trying to negate an expression
like `x - 1.0`. We used to format it as `-x - 1.0` whereas
a proper negation would be `-(x - 1.0)`.

Therefore, we add parentheses around the expression when it is a
Binary ExprKind.

We also add parentheses around multiply and divide expressions,
even though this is not strictly necessary.
---
 clippy_lints/src/floating_point_arithmetic.rs |  2 +-
 tests/ui/floating_point_powi.fixed            |  9 ++++++
 tests/ui/floating_point_powi.rs               |  9 ++++++
 tests/ui/floating_point_powi.stderr           | 44 ++++++++++++++++++++++++++-
 4 files changed, 62 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/floating_point_arithmetic.rs b/clippy_lints/src/floating_point_arithmetic.rs
index 0ed30196475..f95b628e6c3 100644
--- a/clippy_lints/src/floating_point_arithmetic.rs
+++ b/clippy_lints/src/floating_point_arithmetic.rs
@@ -324,7 +324,7 @@ fn check_powi(cx: &LateContext<'_>, expr: &Expr<'_>, receiver: &Expr<'_>, args:
                     let maybe_neg_sugg = |expr, hir_id| {
                         let sugg = Sugg::hir(cx, expr, "..");
                         if matches!(op, BinOpKind::Sub) && hir_id == rhs.hir_id {
-                            format!("-{sugg}")
+                            format!("-{}", sugg.maybe_par())
                         } else {
                             sugg.to_string()
                         }
diff --git a/tests/ui/floating_point_powi.fixed b/tests/ui/floating_point_powi.fixed
index 884d05fed71..8ffd4cc5137 100644
--- a/tests/ui/floating_point_powi.fixed
+++ b/tests/ui/floating_point_powi.fixed
@@ -14,6 +14,15 @@ fn main() {
     let _ = (y as f32).mul_add(y as f32, x);
     let _ = x.mul_add(x, y).sqrt();
     let _ = y.mul_add(y, x).sqrt();
+
+    let _ = (x - 1.0).mul_add(x - 1.0, -y);
+    let _ = (x - 1.0).mul_add(x - 1.0, -y) + 3.0;
+    let _ = (x - 1.0).mul_add(x - 1.0, -(y + 3.0));
+    let _ = (y + 1.0).mul_add(-(y + 1.0), x);
+    let _ = (3.0 * y).mul_add(-(3.0 * y), x);
+    let _ = (y + 1.0 + x).mul_add(-(y + 1.0 + x), x);
+    let _ = (y + 1.0 + 2.0).mul_add(-(y + 1.0 + 2.0), x);
+
     // Cases where the lint shouldn't be applied
     let _ = x.powi(2);
     let _ = x.powi(1 + 1);
diff --git a/tests/ui/floating_point_powi.rs b/tests/ui/floating_point_powi.rs
index e6a1c895371..9ae3455a134 100644
--- a/tests/ui/floating_point_powi.rs
+++ b/tests/ui/floating_point_powi.rs
@@ -14,6 +14,15 @@ fn main() {
     let _ = x + (y as f32).powi(2);
     let _ = (x.powi(2) + y).sqrt();
     let _ = (x + y.powi(2)).sqrt();
+
+    let _ = (x - 1.0).powi(2) - y;
+    let _ = (x - 1.0).powi(2) - y + 3.0;
+    let _ = (x - 1.0).powi(2) - (y + 3.0);
+    let _ = x - (y + 1.0).powi(2);
+    let _ = x - (3.0 * y).powi(2);
+    let _ = x - (y + 1.0 + x).powi(2);
+    let _ = x - (y + 1.0 + 2.0).powi(2);
+
     // Cases where the lint shouldn't be applied
     let _ = x.powi(2);
     let _ = x.powi(1 + 1);
diff --git a/tests/ui/floating_point_powi.stderr b/tests/ui/floating_point_powi.stderr
index 5df0de1fef2..fdf6d088052 100644
--- a/tests/ui/floating_point_powi.stderr
+++ b/tests/ui/floating_point_powi.stderr
@@ -42,5 +42,47 @@ error: multiply and add expressions can be calculated more efficiently and accur
 LL |     let _ = (x + y.powi(2)).sqrt();
    |             ^^^^^^^^^^^^^^^ help: consider using: `y.mul_add(y, x)`
 
-error: aborting due to 7 previous errors
+error: multiply and add expressions can be calculated more efficiently and accurately
+  --> $DIR/floating_point_powi.rs:18:13
+   |
+LL |     let _ = (x - 1.0).powi(2) - y;
+   |             ^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(x - 1.0).mul_add(x - 1.0, -y)`
+
+error: multiply and add expressions can be calculated more efficiently and accurately
+  --> $DIR/floating_point_powi.rs:19:13
+   |
+LL |     let _ = (x - 1.0).powi(2) - y + 3.0;
+   |             ^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(x - 1.0).mul_add(x - 1.0, -y)`
+
+error: multiply and add expressions can be calculated more efficiently and accurately
+  --> $DIR/floating_point_powi.rs:20:13
+   |
+LL |     let _ = (x - 1.0).powi(2) - (y + 3.0);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(x - 1.0).mul_add(x - 1.0, -(y + 3.0))`
+
+error: multiply and add expressions can be calculated more efficiently and accurately
+  --> $DIR/floating_point_powi.rs:21:13
+   |
+LL |     let _ = x - (y + 1.0).powi(2);
+   |             ^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(y + 1.0).mul_add(-(y + 1.0), x)`
+
+error: multiply and add expressions can be calculated more efficiently and accurately
+  --> $DIR/floating_point_powi.rs:22:13
+   |
+LL |     let _ = x - (3.0 * y).powi(2);
+   |             ^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(3.0 * y).mul_add(-(3.0 * y), x)`
+
+error: multiply and add expressions can be calculated more efficiently and accurately
+  --> $DIR/floating_point_powi.rs:23:13
+   |
+LL |     let _ = x - (y + 1.0 + x).powi(2);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(y + 1.0 + x).mul_add(-(y + 1.0 + x), x)`
+
+error: multiply and add expressions can be calculated more efficiently and accurately
+  --> $DIR/floating_point_powi.rs:24:13
+   |
+LL |     let _ = x - (y + 1.0 + 2.0).powi(2);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(y + 1.0 + 2.0).mul_add(-(y + 1.0 + 2.0), x)`
+
+error: aborting due to 14 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 0298095ac21e8fd5eb5ead8edc1b49a365972cc4 Mon Sep 17 00:00:00 2001
From: Ray Redondo <raydredondo@gmail.com>
Date: Thu, 29 Dec 2022 14:48:36 -0600
Subject: add comment about mutex_atomic issue to description

---
 clippy_lints/src/mutex_atomic.rs | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/mutex_atomic.rs b/clippy_lints/src/mutex_atomic.rs
index 45bb217979a..dc866ab6373 100644
--- a/clippy_lints/src/mutex_atomic.rs
+++ b/clippy_lints/src/mutex_atomic.rs
@@ -1,6 +1,6 @@
 //! Checks for uses of mutex where an atomic value could be used
 //!
-//! This lint is **warn** by default
+//! This lint is **allow** by default
 
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::ty::is_type_diagnostic_item;
@@ -20,6 +20,10 @@ declare_clippy_lint! {
     /// `std::sync::atomic::AtomicBool` and `std::sync::atomic::AtomicPtr` are leaner and
     /// faster.
     ///
+    /// On the other hand, `Mutex`es are, in general, easier to
+    /// verify correctness. An atomic does not behave the same as
+    /// an equivalent mutex. See [this issue](https://github.com/rust-lang/rust-clippy/issues/4295)'s commentary for more details.
+    ///
     /// ### Known problems
     /// This lint cannot detect if the mutex is actually used
     /// for waiting before a critical section.
@@ -40,7 +44,7 @@ declare_clippy_lint! {
     #[clippy::version = "pre 1.29.0"]
     pub MUTEX_ATOMIC,
     restriction,
-    "using a mutex where an atomic value could be used instead"
+    "using a mutex where an atomic value could be used instead."
 }
 
 declare_clippy_lint! {
-- 
cgit 1.4.1-3-g733a5


From ca5f4a1deea72a7a0c0654055195c6e98af9ef41 Mon Sep 17 00:00:00 2001
From: Trevor Gross <t.gross35@gmail.com>
Date: Sat, 24 Dec 2022 23:26:25 -0500
Subject: option_if_let_else: update known problems wording

---
 clippy_lints/src/option_if_let_else.rs | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/option_if_let_else.rs b/clippy_lints/src/option_if_let_else.rs
index 472f52380bb..c5ea09590d3 100644
--- a/clippy_lints/src/option_if_let_else.rs
+++ b/clippy_lints/src/option_if_let_else.rs
@@ -25,11 +25,11 @@ declare_clippy_lint! {
     /// Using the dedicated functions of the `Option` type is clearer and
     /// more concise than an `if let` expression.
     ///
-    /// ### Known problems
-    /// This lint uses a deliberately conservative metric for checking
-    /// if the inside of either body contains breaks or continues which will
-    /// cause it to not suggest a fix if either block contains a loop with
-    /// continues or breaks contained within the loop.
+    /// ### Notes
+    /// This lint uses a deliberately conservative metric for checking if the
+    /// inside of either body contains loop control expressions `break` or
+    /// `continue` (which cannot be used within closures). If these are found,
+    /// this lint will not be raised.
     ///
     /// ### Example
     /// ```rust
-- 
cgit 1.4.1-3-g733a5


From da7c99b81e7f863539a88f0d6ad2b79076d425f0 Mon Sep 17 00:00:00 2001
From: Samuel Moelius <sam@moeli.us>
Date: Sun, 1 Jan 2023 06:21:28 -0500
Subject: Fix typo in `unused_self` diagnostic message

---
 clippy_lints/src/unused_self.rs |  2 +-
 tests/ui/unused_self.stderr     | 18 +++++++++---------
 2 files changed, 10 insertions(+), 10 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unused_self.rs b/clippy_lints/src/unused_self.rs
index 42bccc7212b..18231b6a7e8 100644
--- a/clippy_lints/src/unused_self.rs
+++ b/clippy_lints/src/unused_self.rs
@@ -72,7 +72,7 @@ impl<'tcx> LateLintPass<'tcx> for UnusedSelf {
                     self_param.span,
                     "unused `self` argument",
                     None,
-                    "consider refactoring to a associated function",
+                    "consider refactoring to an associated function",
                 );
             }
         }
diff --git a/tests/ui/unused_self.stderr b/tests/ui/unused_self.stderr
index 23186122a9a..919f9b6efda 100644
--- a/tests/ui/unused_self.stderr
+++ b/tests/ui/unused_self.stderr
@@ -4,7 +4,7 @@ error: unused `self` argument
 LL |         fn unused_self_move(self) {}
    |                             ^^^^
    |
-   = help: consider refactoring to a associated function
+   = help: consider refactoring to an associated function
    = note: `-D clippy::unused-self` implied by `-D warnings`
 
 error: unused `self` argument
@@ -13,7 +13,7 @@ error: unused `self` argument
 LL |         fn unused_self_ref(&self) {}
    |                            ^^^^^
    |
-   = help: consider refactoring to a associated function
+   = help: consider refactoring to an associated function
 
 error: unused `self` argument
   --> $DIR/unused_self.rs:13:32
@@ -21,7 +21,7 @@ error: unused `self` argument
 LL |         fn unused_self_mut_ref(&mut self) {}
    |                                ^^^^^^^^^
    |
-   = help: consider refactoring to a associated function
+   = help: consider refactoring to an associated function
 
 error: unused `self` argument
   --> $DIR/unused_self.rs:14:32
@@ -29,7 +29,7 @@ error: unused `self` argument
 LL |         fn unused_self_pin_ref(self: Pin<&Self>) {}
    |                                ^^^^
    |
-   = help: consider refactoring to a associated function
+   = help: consider refactoring to an associated function
 
 error: unused `self` argument
   --> $DIR/unused_self.rs:15:36
@@ -37,7 +37,7 @@ error: unused `self` argument
 LL |         fn unused_self_pin_mut_ref(self: Pin<&mut Self>) {}
    |                                    ^^^^
    |
-   = help: consider refactoring to a associated function
+   = help: consider refactoring to an associated function
 
 error: unused `self` argument
   --> $DIR/unused_self.rs:16:35
@@ -45,7 +45,7 @@ error: unused `self` argument
 LL |         fn unused_self_pin_nested(self: Pin<Arc<Self>>) {}
    |                                   ^^^^
    |
-   = help: consider refactoring to a associated function
+   = help: consider refactoring to an associated function
 
 error: unused `self` argument
   --> $DIR/unused_self.rs:17:28
@@ -53,7 +53,7 @@ error: unused `self` argument
 LL |         fn unused_self_box(self: Box<Self>) {}
    |                            ^^^^
    |
-   = help: consider refactoring to a associated function
+   = help: consider refactoring to an associated function
 
 error: unused `self` argument
   --> $DIR/unused_self.rs:18:40
@@ -61,7 +61,7 @@ error: unused `self` argument
 LL |         fn unused_with_other_used_args(&self, x: u8, y: u8) -> u8 {
    |                                        ^^^^^
    |
-   = help: consider refactoring to a associated function
+   = help: consider refactoring to an associated function
 
 error: unused `self` argument
   --> $DIR/unused_self.rs:21:37
@@ -69,7 +69,7 @@ error: unused `self` argument
 LL |         fn unused_self_class_method(&self) {
    |                                     ^^^^^
    |
-   = help: consider refactoring to a associated function
+   = help: consider refactoring to an associated function
 
 error: aborting due to 9 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 5b46f2db594fc3f2e8c6d8c7f9274ba77736b67c Mon Sep 17 00:00:00 2001
From: chansuke <moonset20@gmail.com>
Date: Thu, 22 Dec 2022 22:59:06 +0900
Subject: chore: fix identation of `if_chain` in `filter_map`

---
 clippy_lints/src/methods/filter_map.rs | 174 ++++++++++++++++-----------------
 1 file changed, 87 insertions(+), 87 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/filter_map.rs b/clippy_lints/src/methods/filter_map.rs
index f888c58a72d..fc80f2eeae0 100644
--- a/clippy_lints/src/methods/filter_map.rs
+++ b/clippy_lints/src/methods/filter_map.rs
@@ -30,12 +30,12 @@ fn is_method(cx: &LateContext<'_>, expr: &hir::Expr<'_>, method_name: Symbol) ->
             match closure_expr.kind {
                 hir::ExprKind::MethodCall(hir::PathSegment { ident, .. }, receiver, ..) => {
                     if_chain! {
-                    if ident.name == method_name;
-                    if let hir::ExprKind::Path(path) = &receiver.kind;
-                    if let Res::Local(ref local) = cx.qpath_res(path, receiver.hir_id);
-                    then {
-                        return arg_id == *local
-                    }
+                        if ident.name == method_name;
+                        if let hir::ExprKind::Path(path) = &receiver.kind;
+                        if let Res::Local(ref local) = cx.qpath_res(path, receiver.hir_id);
+                        then {
+                            return arg_id == *local
+                        }
                     }
                     false
                 },
@@ -92,92 +92,92 @@ pub(super) fn check(
     }
 
     if_chain! {
-            if is_trait_method(cx, map_recv, sym::Iterator);
-
-            // filter(|x| ...is_some())...
-            if let ExprKind::Closure(&Closure { body: filter_body_id, .. }) = filter_arg.kind;
-            let filter_body = cx.tcx.hir().body(filter_body_id);
-            if let [filter_param] = filter_body.params;
-            // optional ref pattern: `filter(|&x| ..)`
-            let (filter_pat, is_filter_param_ref) = if let PatKind::Ref(ref_pat, _) = filter_param.pat.kind {
-                (ref_pat, true)
-            } else {
-                (filter_param.pat, false)
+        if is_trait_method(cx, map_recv, sym::Iterator);
+
+        // filter(|x| ...is_some())...
+        if let ExprKind::Closure(&Closure { body: filter_body_id, .. }) = filter_arg.kind;
+        let filter_body = cx.tcx.hir().body(filter_body_id);
+        if let [filter_param] = filter_body.params;
+        // optional ref pattern: `filter(|&x| ..)`
+        let (filter_pat, is_filter_param_ref) = if let PatKind::Ref(ref_pat, _) = filter_param.pat.kind {
+            (ref_pat, true)
+        } else {
+            (filter_param.pat, false)
+        };
+        // closure ends with is_some() or is_ok()
+        if let PatKind::Binding(_, filter_param_id, _, None) = filter_pat.kind;
+        if let ExprKind::MethodCall(path, filter_arg, [], _) = filter_body.value.kind;
+        if let Some(opt_ty) = cx.typeck_results().expr_ty(filter_arg).peel_refs().ty_adt_def();
+        if let Some(is_result) = if cx.tcx.is_diagnostic_item(sym::Option, opt_ty.did()) {
+            Some(false)
+        } else if cx.tcx.is_diagnostic_item(sym::Result, opt_ty.did()) {
+            Some(true)
+        } else {
+            None
+        };
+        if path.ident.name.as_str() == if is_result { "is_ok" } else { "is_some" };
+
+        // ...map(|x| ...unwrap())
+        if let ExprKind::Closure(&Closure { body: map_body_id, .. }) = map_arg.kind;
+        let map_body = cx.tcx.hir().body(map_body_id);
+        if let [map_param] = map_body.params;
+        if let PatKind::Binding(_, map_param_id, map_param_ident, None) = map_param.pat.kind;
+        // closure ends with expect() or unwrap()
+        if let ExprKind::MethodCall(seg, map_arg, ..) = map_body.value.kind;
+        if matches!(seg.ident.name, sym::expect | sym::unwrap | sym::unwrap_or);
+
+        // .filter(..).map(|y| f(y).copied().unwrap())
+        //                     ~~~~
+        let map_arg_peeled = match map_arg.kind {
+            ExprKind::MethodCall(method, original_arg, [], _) if acceptable_methods(method) => {
+                original_arg
+            },
+            _ => map_arg,
+        };
+
+        // .filter(|x| x.is_some()).map(|y| y[.acceptable_method()].unwrap())
+        let simple_equal = path_to_local_id(filter_arg, filter_param_id)
+            && path_to_local_id(map_arg_peeled, map_param_id);
+
+        let eq_fallback = |a: &Expr<'_>, b: &Expr<'_>| {
+            // in `filter(|x| ..)`, replace `*x` with `x`
+            let a_path = if_chain! {
+                if !is_filter_param_ref;
+                if let ExprKind::Unary(UnOp::Deref, expr_path) = a.kind;
+                then { expr_path } else { a }
             };
-            // closure ends with is_some() or is_ok()
-            if let PatKind::Binding(_, filter_param_id, _, None) = filter_pat.kind;
-            if let ExprKind::MethodCall(path, filter_arg, [], _) = filter_body.value.kind;
-            if let Some(opt_ty) = cx.typeck_results().expr_ty(filter_arg).peel_refs().ty_adt_def();
-            if let Some(is_result) = if cx.tcx.is_diagnostic_item(sym::Option, opt_ty.did()) {
-                Some(false)
-            } else if cx.tcx.is_diagnostic_item(sym::Result, opt_ty.did()) {
-                Some(true)
+            // let the filter closure arg and the map closure arg be equal
+            path_to_local_id(a_path, filter_param_id)
+                && path_to_local_id(b, map_param_id)
+                && cx.typeck_results().expr_ty_adjusted(a) == cx.typeck_results().expr_ty_adjusted(b)
+        };
+
+        if simple_equal || SpanlessEq::new(cx).expr_fallback(eq_fallback).eq_expr(filter_arg, map_arg_peeled);
+        then {
+            let span = filter_span.with_hi(expr.span.hi());
+            let (filter_name, lint) = if is_find {
+                ("find", MANUAL_FIND_MAP)
             } else {
-                None
-            };
-            if path.ident.name.as_str() == if is_result { "is_ok" } else { "is_some" };
-
-            // ...map(|x| ...unwrap())
-            if let ExprKind::Closure(&Closure { body: map_body_id, .. }) = map_arg.kind;
-            let map_body = cx.tcx.hir().body(map_body_id);
-            if let [map_param] = map_body.params;
-            if let PatKind::Binding(_, map_param_id, map_param_ident, None) = map_param.pat.kind;
-            // closure ends with expect() or unwrap()
-            if let ExprKind::MethodCall(seg, map_arg, ..) = map_body.value.kind;
-            if matches!(seg.ident.name, sym::expect | sym::unwrap | sym::unwrap_or);
-
-            // .filter(..).map(|y| f(y).copied().unwrap())
-            //                     ~~~~
-            let map_arg_peeled = match map_arg.kind {
-                ExprKind::MethodCall(method, original_arg, [], _) if acceptable_methods(method) => {
-                    original_arg
-                },
-                _ => map_arg,
+                ("filter", MANUAL_FILTER_MAP)
             };
+            let msg = format!("`{filter_name}(..).map(..)` can be simplified as `{filter_name}_map(..)`");
+            let (to_opt, deref) = if is_result {
+                (".ok()", String::new())
+            } else {
+                let derefs = cx.typeck_results()
+                    .expr_adjustments(map_arg)
+                    .iter()
+                    .filter(|adj| matches!(adj.kind, Adjust::Deref(_)))
+                    .count();
 
-            // .filter(|x| x.is_some()).map(|y| y[.acceptable_method()].unwrap())
-            let simple_equal = path_to_local_id(filter_arg, filter_param_id)
-                && path_to_local_id(map_arg_peeled, map_param_id);
-
-            let eq_fallback = |a: &Expr<'_>, b: &Expr<'_>| {
-                // in `filter(|x| ..)`, replace `*x` with `x`
-                let a_path = if_chain! {
-                    if !is_filter_param_ref;
-                    if let ExprKind::Unary(UnOp::Deref, expr_path) = a.kind;
-                    then { expr_path } else { a }
-                };
-                // let the filter closure arg and the map closure arg be equal
-                path_to_local_id(a_path, filter_param_id)
-                    && path_to_local_id(b, map_param_id)
-                    && cx.typeck_results().expr_ty_adjusted(a) == cx.typeck_results().expr_ty_adjusted(b)
+                ("", "*".repeat(derefs))
             };
-
-            if simple_equal || SpanlessEq::new(cx).expr_fallback(eq_fallback).eq_expr(filter_arg, map_arg_peeled);
-            then {
-                let span = filter_span.with_hi(expr.span.hi());
-                let (filter_name, lint) = if is_find {
-                    ("find", MANUAL_FIND_MAP)
-                } else {
-                    ("filter", MANUAL_FILTER_MAP)
-                };
-                let msg = format!("`{filter_name}(..).map(..)` can be simplified as `{filter_name}_map(..)`");
-                let (to_opt, deref) = if is_result {
-                    (".ok()", String::new())
-                } else {
-                    let derefs = cx.typeck_results()
-                        .expr_adjustments(map_arg)
-                        .iter()
-                        .filter(|adj| matches!(adj.kind, Adjust::Deref(_)))
-                        .count();
-
-                    ("", "*".repeat(derefs))
-                };
-                let sugg = format!(
-                    "{filter_name}_map(|{map_param_ident}| {deref}{}{to_opt})",
-                    snippet(cx, map_arg.span, ".."),
-                );
-                span_lint_and_sugg(cx, lint, span, &msg, "try", sugg, Applicability::MachineApplicable);
-            }
+            let sugg = format!(
+                "{filter_name}_map(|{map_param_ident}| {deref}{}{to_opt})",
+                snippet(cx, map_arg.span, ".."),
+            );
+            span_lint_and_sugg(cx, lint, span, &msg, "try", sugg, Applicability::MachineApplicable);
+        }
     }
 }
 
-- 
cgit 1.4.1-3-g733a5


From 8de011fdf72849e6dc25555bc1800632a66615f6 Mon Sep 17 00:00:00 2001
From: Eric Wu <eric.dianhao.wu@gmail.com>
Date: Sun, 1 Jan 2023 21:23:32 -0500
Subject: don't lint field_reassign when field in closure

This commit makes the ContainsName struct visit all interior
expressions, which means that ContainsName will return true
even if `name` is used in a closure within `expr`.
---
 clippy_lints/src/copies.rs                    |  6 +++++-
 clippy_lints/src/default.rs                   |  2 +-
 clippy_lints/src/loops/needless_range_loop.rs |  4 ++--
 clippy_utils/src/lib.rs                       | 21 +++++++++++++++++----
 tests/ui/field_reassign_with_default.rs       | 21 +++++++++++++++++++++
 5 files changed, 46 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/copies.rs b/clippy_lints/src/copies.rs
index 0e3d9317590..f10c35cde52 100644
--- a/clippy_lints/src/copies.rs
+++ b/clippy_lints/src/copies.rs
@@ -525,7 +525,11 @@ fn check_for_warn_of_moved_symbol(cx: &LateContext<'_>, symbols: &[(HirId, Symbo
             .iter()
             .filter(|&&(_, name)| !name.as_str().starts_with('_'))
             .any(|&(_, name)| {
-                let mut walker = ContainsName { name, result: false };
+                let mut walker = ContainsName {
+                    name,
+                    result: false,
+                    cx,
+                };
 
                 // Scan block
                 block
diff --git a/clippy_lints/src/default.rs b/clippy_lints/src/default.rs
index 7f937de1dd3..55f6121a09d 100644
--- a/clippy_lints/src/default.rs
+++ b/clippy_lints/src/default.rs
@@ -170,7 +170,7 @@ impl<'tcx> LateLintPass<'tcx> for Default {
                 // find out if and which field was set by this `consecutive_statement`
                 if let Some((field_ident, assign_rhs)) = field_reassigned_by_stmt(consecutive_statement, binding_name) {
                     // interrupt and cancel lint if assign_rhs references the original binding
-                    if contains_name(binding_name, assign_rhs) {
+                    if contains_name(binding_name, assign_rhs, cx) {
                         cancel_lint = true;
                         break;
                     }
diff --git a/clippy_lints/src/loops/needless_range_loop.rs b/clippy_lints/src/loops/needless_range_loop.rs
index 27ba27202bf..3bca93d80aa 100644
--- a/clippy_lints/src/loops/needless_range_loop.rs
+++ b/clippy_lints/src/loops/needless_range_loop.rs
@@ -81,7 +81,7 @@ pub(super) fn check<'tcx>(
 
                 let skip = if starts_at_zero {
                     String::new()
-                } else if visitor.indexed_mut.contains(&indexed) && contains_name(indexed, start) {
+                } else if visitor.indexed_mut.contains(&indexed) && contains_name(indexed, start, cx) {
                     return;
                 } else {
                     format!(".skip({})", snippet(cx, start.span, ".."))
@@ -109,7 +109,7 @@ pub(super) fn check<'tcx>(
 
                     if is_len_call(end, indexed) || is_end_eq_array_len(cx, end, limits, indexed_ty) {
                         String::new()
-                    } else if visitor.indexed_mut.contains(&indexed) && contains_name(indexed, take_expr) {
+                    } else if visitor.indexed_mut.contains(&indexed) && contains_name(indexed, take_expr, cx) {
                         return;
                     } else {
                         match limits {
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 43e2d1ec826..b2175c5cb16 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -116,6 +116,8 @@ use crate::consts::{constant, Constant};
 use crate::ty::{can_partially_move_ty, expr_sig, is_copy, is_recursively_primitive_type, ty_is_fn_once_param};
 use crate::visitors::for_each_expr;
 
+use rustc_middle::hir::nested_filter;
+
 #[macro_export]
 macro_rules! extract_msrv_attr {
     ($context:ident) => {
@@ -1253,22 +1255,33 @@ pub fn get_item_name(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<Symbol> {
     }
 }
 
-pub struct ContainsName {
+pub struct ContainsName<'a, 'tcx> {
+    pub cx: &'a LateContext<'tcx>,
     pub name: Symbol,
     pub result: bool,
 }
 
-impl<'tcx> Visitor<'tcx> for ContainsName {
+impl<'a, 'tcx> Visitor<'tcx> for ContainsName<'a, 'tcx> {
+    type NestedFilter = nested_filter::All;
+
     fn visit_name(&mut self, name: Symbol) {
         if self.name == name {
             self.result = true;
         }
     }
+
+    fn nested_visit_map(&mut self) -> Self::Map {
+        self.cx.tcx.hir()
+    }
 }
 
 /// Checks if an `Expr` contains a certain name.
-pub fn contains_name(name: Symbol, expr: &Expr<'_>) -> bool {
-    let mut cn = ContainsName { name, result: false };
+pub fn contains_name<'tcx>(name: Symbol, expr: &'tcx Expr<'_>, cx: &LateContext<'tcx>) -> bool {
+    let mut cn = ContainsName {
+        name,
+        result: false,
+        cx,
+    };
     cn.visit_expr(expr);
     cn.result
 }
diff --git a/tests/ui/field_reassign_with_default.rs b/tests/ui/field_reassign_with_default.rs
index 7367910eaa1..1f989bb1220 100644
--- a/tests/ui/field_reassign_with_default.rs
+++ b/tests/ui/field_reassign_with_default.rs
@@ -247,3 +247,24 @@ mod issue6312 {
         }
     }
 }
+
+struct Collection {
+    items: Vec<i32>,
+    len: usize,
+}
+
+impl Default for Collection {
+    fn default() -> Self {
+        Self {
+            items: vec![1, 2, 3],
+            len: 0,
+        }
+    }
+}
+
+#[allow(clippy::redundant_closure_call)]
+fn issue10136() {
+    let mut c = Collection::default();
+    // don't lint, since c.items was used to calculate this value
+    c.len = (|| c.items.len())();
+}
-- 
cgit 1.4.1-3-g733a5


From 01a2a9df4300749f5c96209e707d02aae44f39e3 Mon Sep 17 00:00:00 2001
From: Eric Wu <eric.dianhao.wu@gmail.com>
Date: Sun, 1 Jan 2023 19:10:21 -0500
Subject: [`drop_ref`]: don't lint idiomatic in match arm

---
 clippy_lints/src/drop_forget_ref.rs |  2 +-
 tests/ui/drop_ref.rs                | 23 ++++++++++++++++++++++
 tests/ui/drop_ref.stderr            | 38 ++++++++++++++++++++++++++++++++++++-
 3 files changed, 61 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/drop_forget_ref.rs b/clippy_lints/src/drop_forget_ref.rs
index 4721a7b3705..11e1bcdf12d 100644
--- a/clippy_lints/src/drop_forget_ref.rs
+++ b/clippy_lints/src/drop_forget_ref.rs
@@ -206,7 +206,7 @@ impl<'tcx> LateLintPass<'tcx> for DropForgetRef {
             let is_copy = is_copy(cx, arg_ty);
             let drop_is_single_call_in_arm = is_single_call_in_arm(cx, arg, expr);
             let (lint, msg) = match fn_name {
-                sym::mem_drop if arg_ty.is_ref() => (DROP_REF, DROP_REF_SUMMARY),
+                sym::mem_drop if arg_ty.is_ref() && !drop_is_single_call_in_arm => (DROP_REF, DROP_REF_SUMMARY),
                 sym::mem_forget if arg_ty.is_ref() => (FORGET_REF, FORGET_REF_SUMMARY),
                 sym::mem_drop if is_copy && !drop_is_single_call_in_arm => (DROP_COPY, DROP_COPY_SUMMARY),
                 sym::mem_forget if is_copy => (FORGET_COPY, FORGET_COPY_SUMMARY),
diff --git a/tests/ui/drop_ref.rs b/tests/ui/drop_ref.rs
index 7de0b0bbdf9..10044e65f11 100644
--- a/tests/ui/drop_ref.rs
+++ b/tests/ui/drop_ref.rs
@@ -72,3 +72,26 @@ fn test_owl_result_2() -> Result<u8, ()> {
     produce_half_owl_ok().map(drop)?;
     Ok(1)
 }
+
+#[allow(unused)]
+#[allow(clippy::unit_cmp)]
+fn issue10122(x: u8) {
+    // This is a function which returns a reference and has a side-effect, which means
+    // that calling drop() on the function is considered an idiomatic way of achieving the side-effect
+    // in a match arm.
+    fn println_and<T>(t: &T) -> &T {
+        println!("foo");
+        t
+    }
+
+    match x {
+        0 => drop(println_and(&12)), // Don't lint (copy type), we only care about side-effects
+        1 => drop(println_and(&String::new())), // Don't lint (no copy type), we only care about side-effects
+        2 => {
+            drop(println_and(&13)); // Lint, even if we only care about the side-effect, it's already in a block
+        },
+        3 if drop(println_and(&14)) == () => (), // Lint, idiomatic use is only in body of `Arm`
+        4 => drop(&2),                           // Lint, not a fn/method call
+        _ => (),
+    }
+}
diff --git a/tests/ui/drop_ref.stderr b/tests/ui/drop_ref.stderr
index 4743cf79b5d..293b9f6de83 100644
--- a/tests/ui/drop_ref.stderr
+++ b/tests/ui/drop_ref.stderr
@@ -107,5 +107,41 @@ note: argument has type `&SomeStruct`
 LL |     std::mem::drop(&SomeStruct);
    |                    ^^^^^^^^^^^
 
-error: aborting due to 9 previous errors
+error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing
+  --> $DIR/drop_ref.rs:91:13
+   |
+LL |             drop(println_and(&13)); // Lint, even if we only care about the side-effect, it's already in a block
+   |             ^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: argument has type `&i32`
+  --> $DIR/drop_ref.rs:91:18
+   |
+LL |             drop(println_and(&13)); // Lint, even if we only care about the side-effect, it's already in a block
+   |                  ^^^^^^^^^^^^^^^^
+
+error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing
+  --> $DIR/drop_ref.rs:93:14
+   |
+LL |         3 if drop(println_and(&14)) == () => (), // Lint, idiomatic use is only in body of `Arm`
+   |              ^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: argument has type `&i32`
+  --> $DIR/drop_ref.rs:93:19
+   |
+LL |         3 if drop(println_and(&14)) == () => (), // Lint, idiomatic use is only in body of `Arm`
+   |                   ^^^^^^^^^^^^^^^^
+
+error: calls to `std::mem::drop` with a reference instead of an owned value. Dropping a reference does nothing
+  --> $DIR/drop_ref.rs:94:14
+   |
+LL |         4 => drop(&2),                           // Lint, not a fn/method call
+   |              ^^^^^^^^
+   |
+note: argument has type `&i32`
+  --> $DIR/drop_ref.rs:94:19
+   |
+LL |         4 => drop(&2),                           // Lint, not a fn/method call
+   |                   ^^
+
+error: aborting due to 12 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 7a1a9c8188eed7212eab35c820dcdff88cf0f3df Mon Sep 17 00:00:00 2001
From: Max Baumann <max@bmn.dev>
Date: Mon, 2 Jan 2023 14:58:10 +0100
Subject: empty_structs_with_brackets: not MachineApplicable anymore

---
 clippy_lints/src/empty_structs_with_brackets.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/empty_structs_with_brackets.rs b/clippy_lints/src/empty_structs_with_brackets.rs
index 08bf80a4229..c3a020433de 100644
--- a/clippy_lints/src/empty_structs_with_brackets.rs
+++ b/clippy_lints/src/empty_structs_with_brackets.rs
@@ -45,7 +45,7 @@ impl EarlyLintPass for EmptyStructsWithBrackets {
                         span_after_ident,
                         "remove the brackets",
                         ";",
-                        Applicability::MachineApplicable);
+                        Applicability::Unspecified);
                     },
             );
         }
-- 
cgit 1.4.1-3-g733a5


From 9aef1a264a52d59e959e4b0a2f9a71d06c3def13 Mon Sep 17 00:00:00 2001
From: Andy Russell <arussell123@gmail.com>
Date: Sun, 1 Jan 2023 02:41:45 -0500
Subject: reword dbg_macro labels

---
 clippy_lints/src/dbg_macro.rs            | 10 +++---
 tests/ui-toml/dbg_macro/dbg_macro.stderr | 36 +++++++++++-----------
 tests/ui/dbg_macro.stderr                | 52 ++++++++++++++++----------------
 3 files changed, 49 insertions(+), 49 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/dbg_macro.rs b/clippy_lints/src/dbg_macro.rs
index fe9f4f9ae3c..799e71e847a 100644
--- a/clippy_lints/src/dbg_macro.rs
+++ b/clippy_lints/src/dbg_macro.rs
@@ -10,11 +10,11 @@ use rustc_span::sym;
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of dbg!() macro.
+    /// Checks for usage of the [`dbg!`](https://doc.rust-lang.org/std/macro.dbg.html) macro.
     ///
     /// ### Why is this bad?
-    /// `dbg!` macro is intended as a debugging tool. It
-    /// should not be in version control.
+    /// The `dbg!` macro is intended as a debugging tool. It should not be present in released
+    /// software or committed to a version control system.
     ///
     /// ### Example
     /// ```rust,ignore
@@ -91,8 +91,8 @@ impl LateLintPass<'_> for DbgMacro {
                 cx,
                 DBG_MACRO,
                 macro_call.span,
-                "`dbg!` macro is intended as a debugging tool",
-                "ensure to avoid having uses of it in version control",
+                "the `dbg!` macro is intended as a debugging tool",
+                "remove the invocation before committing it to a version control system",
                 suggestion,
                 applicability,
             );
diff --git a/tests/ui-toml/dbg_macro/dbg_macro.stderr b/tests/ui-toml/dbg_macro/dbg_macro.stderr
index 46efb86dcfc..859383a7119 100644
--- a/tests/ui-toml/dbg_macro/dbg_macro.stderr
+++ b/tests/ui-toml/dbg_macro/dbg_macro.stderr
@@ -1,99 +1,99 @@
-error: `dbg!` macro is intended as a debugging tool
+error: the `dbg!` macro is intended as a debugging tool
   --> $DIR/dbg_macro.rs:5:22
    |
 LL |     if let Some(n) = dbg!(n.checked_sub(4)) { n } else { n }
    |                      ^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::dbg-macro` implied by `-D warnings`
-help: ensure to avoid having uses of it in version control
+help: remove the invocation before committing it to a version control system
    |
 LL |     if let Some(n) = n.checked_sub(4) { n } else { n }
    |                      ~~~~~~~~~~~~~~~~
 
-error: `dbg!` macro is intended as a debugging tool
+error: the `dbg!` macro is intended as a debugging tool
   --> $DIR/dbg_macro.rs:9:8
    |
 LL |     if dbg!(n <= 1) {
    |        ^^^^^^^^^^^^
    |
-help: ensure to avoid having uses of it in version control
+help: remove the invocation before committing it to a version control system
    |
 LL |     if n <= 1 {
    |        ~~~~~~
 
-error: `dbg!` macro is intended as a debugging tool
+error: the `dbg!` macro is intended as a debugging tool
   --> $DIR/dbg_macro.rs:10:9
    |
 LL |         dbg!(1)
    |         ^^^^^^^
    |
-help: ensure to avoid having uses of it in version control
+help: remove the invocation before committing it to a version control system
    |
 LL |         1
    |
 
-error: `dbg!` macro is intended as a debugging tool
+error: the `dbg!` macro is intended as a debugging tool
   --> $DIR/dbg_macro.rs:12:9
    |
 LL |         dbg!(n * factorial(n - 1))
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-help: ensure to avoid having uses of it in version control
+help: remove the invocation before committing it to a version control system
    |
 LL |         n * factorial(n - 1)
    |
 
-error: `dbg!` macro is intended as a debugging tool
+error: the `dbg!` macro is intended as a debugging tool
   --> $DIR/dbg_macro.rs:17:5
    |
 LL |     dbg!(42);
    |     ^^^^^^^^
    |
-help: ensure to avoid having uses of it in version control
+help: remove the invocation before committing it to a version control system
    |
 LL |     42;
    |     ~~
 
-error: `dbg!` macro is intended as a debugging tool
+error: the `dbg!` macro is intended as a debugging tool
   --> $DIR/dbg_macro.rs:18:5
    |
 LL |     dbg!(dbg!(dbg!(42)));
    |     ^^^^^^^^^^^^^^^^^^^^
    |
-help: ensure to avoid having uses of it in version control
+help: remove the invocation before committing it to a version control system
    |
 LL |     dbg!(dbg!(42));
    |     ~~~~~~~~~~~~~~
 
-error: `dbg!` macro is intended as a debugging tool
+error: the `dbg!` macro is intended as a debugging tool
   --> $DIR/dbg_macro.rs:19:14
    |
 LL |     foo(3) + dbg!(factorial(4));
    |              ^^^^^^^^^^^^^^^^^^
    |
-help: ensure to avoid having uses of it in version control
+help: remove the invocation before committing it to a version control system
    |
 LL |     foo(3) + factorial(4);
    |              ~~~~~~~~~~~~
 
-error: `dbg!` macro is intended as a debugging tool
+error: the `dbg!` macro is intended as a debugging tool
   --> $DIR/dbg_macro.rs:20:5
    |
 LL |     dbg!(1, 2, dbg!(3, 4));
    |     ^^^^^^^^^^^^^^^^^^^^^^
    |
-help: ensure to avoid having uses of it in version control
+help: remove the invocation before committing it to a version control system
    |
 LL |     (1, 2, dbg!(3, 4));
    |     ~~~~~~~~~~~~~~~~~~
 
-error: `dbg!` macro is intended as a debugging tool
+error: the `dbg!` macro is intended as a debugging tool
   --> $DIR/dbg_macro.rs:21:5
    |
 LL |     dbg!(1, 2, 3, 4, 5);
    |     ^^^^^^^^^^^^^^^^^^^
    |
-help: ensure to avoid having uses of it in version control
+help: remove the invocation before committing it to a version control system
    |
 LL |     (1, 2, 3, 4, 5);
    |     ~~~~~~~~~~~~~~~
diff --git a/tests/ui/dbg_macro.stderr b/tests/ui/dbg_macro.stderr
index e6a65b46d97..ddb5f1342e9 100644
--- a/tests/ui/dbg_macro.stderr
+++ b/tests/ui/dbg_macro.stderr
@@ -1,143 +1,143 @@
-error: `dbg!` macro is intended as a debugging tool
+error: the `dbg!` macro is intended as a debugging tool
   --> $DIR/dbg_macro.rs:5:22
    |
 LL |     if let Some(n) = dbg!(n.checked_sub(4)) { n } else { n }
    |                      ^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::dbg-macro` implied by `-D warnings`
-help: ensure to avoid having uses of it in version control
+help: remove the invocation before committing it to a version control system
    |
 LL |     if let Some(n) = n.checked_sub(4) { n } else { n }
    |                      ~~~~~~~~~~~~~~~~
 
-error: `dbg!` macro is intended as a debugging tool
+error: the `dbg!` macro is intended as a debugging tool
   --> $DIR/dbg_macro.rs:9:8
    |
 LL |     if dbg!(n <= 1) {
    |        ^^^^^^^^^^^^
    |
-help: ensure to avoid having uses of it in version control
+help: remove the invocation before committing it to a version control system
    |
 LL |     if n <= 1 {
    |        ~~~~~~
 
-error: `dbg!` macro is intended as a debugging tool
+error: the `dbg!` macro is intended as a debugging tool
   --> $DIR/dbg_macro.rs:10:9
    |
 LL |         dbg!(1)
    |         ^^^^^^^
    |
-help: ensure to avoid having uses of it in version control
+help: remove the invocation before committing it to a version control system
    |
 LL |         1
    |
 
-error: `dbg!` macro is intended as a debugging tool
+error: the `dbg!` macro is intended as a debugging tool
   --> $DIR/dbg_macro.rs:12:9
    |
 LL |         dbg!(n * factorial(n - 1))
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-help: ensure to avoid having uses of it in version control
+help: remove the invocation before committing it to a version control system
    |
 LL |         n * factorial(n - 1)
    |
 
-error: `dbg!` macro is intended as a debugging tool
+error: the `dbg!` macro is intended as a debugging tool
   --> $DIR/dbg_macro.rs:17:5
    |
 LL |     dbg!(42);
    |     ^^^^^^^^
    |
-help: ensure to avoid having uses of it in version control
+help: remove the invocation before committing it to a version control system
    |
 LL |     42;
    |     ~~
 
-error: `dbg!` macro is intended as a debugging tool
+error: the `dbg!` macro is intended as a debugging tool
   --> $DIR/dbg_macro.rs:18:5
    |
 LL |     dbg!(dbg!(dbg!(42)));
    |     ^^^^^^^^^^^^^^^^^^^^
    |
-help: ensure to avoid having uses of it in version control
+help: remove the invocation before committing it to a version control system
    |
 LL |     dbg!(dbg!(42));
    |     ~~~~~~~~~~~~~~
 
-error: `dbg!` macro is intended as a debugging tool
+error: the `dbg!` macro is intended as a debugging tool
   --> $DIR/dbg_macro.rs:19:14
    |
 LL |     foo(3) + dbg!(factorial(4));
    |              ^^^^^^^^^^^^^^^^^^
    |
-help: ensure to avoid having uses of it in version control
+help: remove the invocation before committing it to a version control system
    |
 LL |     foo(3) + factorial(4);
    |              ~~~~~~~~~~~~
 
-error: `dbg!` macro is intended as a debugging tool
+error: the `dbg!` macro is intended as a debugging tool
   --> $DIR/dbg_macro.rs:20:5
    |
 LL |     dbg!(1, 2, dbg!(3, 4));
    |     ^^^^^^^^^^^^^^^^^^^^^^
    |
-help: ensure to avoid having uses of it in version control
+help: remove the invocation before committing it to a version control system
    |
 LL |     (1, 2, dbg!(3, 4));
    |     ~~~~~~~~~~~~~~~~~~
 
-error: `dbg!` macro is intended as a debugging tool
+error: the `dbg!` macro is intended as a debugging tool
   --> $DIR/dbg_macro.rs:21:5
    |
 LL |     dbg!(1, 2, 3, 4, 5);
    |     ^^^^^^^^^^^^^^^^^^^
    |
-help: ensure to avoid having uses of it in version control
+help: remove the invocation before committing it to a version control system
    |
 LL |     (1, 2, 3, 4, 5);
    |     ~~~~~~~~~~~~~~~
 
-error: `dbg!` macro is intended as a debugging tool
+error: the `dbg!` macro is intended as a debugging tool
   --> $DIR/dbg_macro.rs:41:9
    |
 LL |         dbg!(2);
    |         ^^^^^^^
    |
-help: ensure to avoid having uses of it in version control
+help: remove the invocation before committing it to a version control system
    |
 LL |         2;
    |         ~
 
-error: `dbg!` macro is intended as a debugging tool
+error: the `dbg!` macro is intended as a debugging tool
   --> $DIR/dbg_macro.rs:47:5
    |
 LL |     dbg!(1);
    |     ^^^^^^^
    |
-help: ensure to avoid having uses of it in version control
+help: remove the invocation before committing it to a version control system
    |
 LL |     1;
    |     ~
 
-error: `dbg!` macro is intended as a debugging tool
+error: the `dbg!` macro is intended as a debugging tool
   --> $DIR/dbg_macro.rs:52:5
    |
 LL |     dbg!(1);
    |     ^^^^^^^
    |
-help: ensure to avoid having uses of it in version control
+help: remove the invocation before committing it to a version control system
    |
 LL |     1;
    |     ~
 
-error: `dbg!` macro is intended as a debugging tool
+error: the `dbg!` macro is intended as a debugging tool
   --> $DIR/dbg_macro.rs:58:9
    |
 LL |         dbg!(1);
    |         ^^^^^^^
    |
-help: ensure to avoid having uses of it in version control
+help: remove the invocation before committing it to a version control system
    |
 LL |         1;
    |         ~
-- 
cgit 1.4.1-3-g733a5


From f53c6e2f15a54dee84cbf20228a54861fa66bf09 Mon Sep 17 00:00:00 2001
From: Nilstrieb <48135649+Nilstrieb@users.noreply.github.com>
Date: Mon, 2 Jan 2023 19:58:00 +0100
Subject: Correct Gankra's name in the linkedlist lint

---
 clippy_lints/src/types/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types/mod.rs b/clippy_lints/src/types/mod.rs
index 20978e81dc5..b0d49d26856 100644
--- a/clippy_lints/src/types/mod.rs
+++ b/clippy_lints/src/types/mod.rs
@@ -127,7 +127,7 @@ declare_clippy_lint! {
     /// `Vec` or a `VecDeque` (formerly called `RingBuf`).
     ///
     /// ### Why is this bad?
-    /// Gankro says:
+    /// Gankra says:
     ///
     /// > The TL;DR of `LinkedList` is that it's built on a massive amount of
     /// pointers and indirection.
-- 
cgit 1.4.1-3-g733a5


From bd83650e91a751ad352444b458f9f50549fac208 Mon Sep 17 00:00:00 2001
From: Tyler Weaver <maybe@tylerjw.dev>
Date: Wed, 21 Dec 2022 12:47:39 -0700
Subject: Suggest using Path for comparing extensions

Signed-off-by: Tyler Weaver <maybe@tylerjw.dev>
---
 .../case_sensitive_file_extension_comparisons.rs   | 38 ++++++++--
 ...case_sensitive_file_extension_comparisons.fixed | 64 +++++++++++++++++
 .../case_sensitive_file_extension_comparisons.rs   |  8 ++-
 ...ase_sensitive_file_extension_comparisons.stderr | 82 +++++++++++++++++++---
 4 files changed, 175 insertions(+), 17 deletions(-)
 create mode 100644 tests/ui/case_sensitive_file_extension_comparisons.fixed

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/case_sensitive_file_extension_comparisons.rs b/clippy_lints/src/methods/case_sensitive_file_extension_comparisons.rs
index d226c0bba65..bc9b7a73b5b 100644
--- a/clippy_lints/src/methods/case_sensitive_file_extension_comparisons.rs
+++ b/clippy_lints/src/methods/case_sensitive_file_extension_comparisons.rs
@@ -1,7 +1,9 @@
-use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::is_type_lang_item;
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
+use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, LangItem};
 use rustc_lint::LateContext;
 use rustc_span::{source_map::Spanned, Span};
@@ -28,13 +30,39 @@ pub(super) fn check<'tcx>(
         let recv_ty = cx.typeck_results().expr_ty(recv).peel_refs();
         if recv_ty.is_str() || is_type_lang_item(cx, recv_ty, LangItem::String);
         then {
-            span_lint_and_help(
+            span_lint_and_then(
                 cx,
                 CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS,
-                call_span,
+                recv.span.to(call_span),
                 "case-sensitive file extension comparison",
-                None,
-                "consider using a case-insensitive comparison instead",
+                |diag| {
+                    diag.help("consider using a case-insensitive comparison instead");
+                    let mut recv_str = Sugg::hir(cx, recv, "").to_string();
+
+                    if is_type_lang_item(cx, recv_ty, LangItem::String) {
+                        recv_str = format!("&{recv_str}");
+                    }
+
+                    if recv_str.contains(".to_lowercase()") {
+                        diag.note("to_lowercase allocates memory, this can be avoided by using Path");
+                        recv_str = recv_str.replace(".to_lowercase()", "");
+                    }
+
+                    if recv_str.contains(".to_uppercase()") {
+                        diag.note("to_uppercase allocates memory, this can be avoided by using Path");
+                        recv_str = recv_str.replace(".to_uppercase()", "");
+                    }
+
+                    diag.span_suggestion(
+                        recv.span.to(call_span),
+                        "use std::path::Path",
+                        format!("std::path::Path::new({})
+        .extension()
+        .map_or(false, |ext| ext.eq_ignore_ascii_case(\"{}\"))", 
+                            recv_str, ext_str.strip_prefix('.').unwrap()),
+                        Applicability::MaybeIncorrect,
+                    );
+                }
             );
         }
     }
diff --git a/tests/ui/case_sensitive_file_extension_comparisons.fixed b/tests/ui/case_sensitive_file_extension_comparisons.fixed
new file mode 100644
index 00000000000..a8b5950f208
--- /dev/null
+++ b/tests/ui/case_sensitive_file_extension_comparisons.fixed
@@ -0,0 +1,64 @@
+// run-rustfix
+#![warn(clippy::case_sensitive_file_extension_comparisons)]
+
+use std::string::String;
+
+struct TestStruct;
+
+impl TestStruct {
+    fn ends_with(self, _arg: &str) {}
+}
+
+#[allow(dead_code)]
+fn is_rust_file(filename: &str) -> bool {
+    std::path::Path::new(filename)
+        .extension()
+        .map_or(false, |ext| ext.eq_ignore_ascii_case("rs"))
+}
+
+fn main() {
+    // std::string::String and &str should trigger the lint failure with .ext12
+    let _ = std::path::Path::new(&String::new())
+        .extension()
+        .map_or(false, |ext| ext.eq_ignore_ascii_case("ext12"));
+    let _ = std::path::Path::new("str")
+        .extension()
+        .map_or(false, |ext| ext.eq_ignore_ascii_case("ext12"));
+
+    // The test struct should not trigger the lint failure with .ext12
+    TestStruct {}.ends_with(".ext12");
+
+    // std::string::String and &str should trigger the lint failure with .EXT12
+    let _ = std::path::Path::new(&String::new())
+        .extension()
+        .map_or(false, |ext| ext.eq_ignore_ascii_case("EXT12"));
+    let _ = std::path::Path::new("str")
+        .extension()
+        .map_or(false, |ext| ext.eq_ignore_ascii_case("EXT12"));
+
+    // This should print a note about how to_lowercase and to_uppercase allocates
+    let _ = std::path::Path::new(&String::new())
+        .extension()
+        .map_or(false, |ext| ext.eq_ignore_ascii_case("EXT12"));
+    let _ = std::path::Path::new(&String::new())
+        .extension()
+        .map_or(false, |ext| ext.eq_ignore_ascii_case("EXT12"));
+
+    // The test struct should not trigger the lint failure with .EXT12
+    TestStruct {}.ends_with(".EXT12");
+
+    // Should not trigger the lint failure with .eXT12
+    let _ = String::new().ends_with(".eXT12");
+    let _ = "str".ends_with(".eXT12");
+    TestStruct {}.ends_with(".eXT12");
+
+    // Should not trigger the lint failure with .EXT123 (too long)
+    let _ = String::new().ends_with(".EXT123");
+    let _ = "str".ends_with(".EXT123");
+    TestStruct {}.ends_with(".EXT123");
+
+    // Shouldn't fail if it doesn't start with a dot
+    let _ = String::new().ends_with("a.ext");
+    let _ = "str".ends_with("a.extA");
+    TestStruct {}.ends_with("a.ext");
+}
diff --git a/tests/ui/case_sensitive_file_extension_comparisons.rs b/tests/ui/case_sensitive_file_extension_comparisons.rs
index 6f0485b5279..ee9bcd73d52 100644
--- a/tests/ui/case_sensitive_file_extension_comparisons.rs
+++ b/tests/ui/case_sensitive_file_extension_comparisons.rs
@@ -1,3 +1,4 @@
+// run-rustfix
 #![warn(clippy::case_sensitive_file_extension_comparisons)]
 
 use std::string::String;
@@ -5,9 +6,10 @@ use std::string::String;
 struct TestStruct;
 
 impl TestStruct {
-    fn ends_with(self, arg: &str) {}
+    fn ends_with(self, _arg: &str) {}
 }
 
+#[allow(dead_code)]
 fn is_rust_file(filename: &str) -> bool {
     filename.ends_with(".rs")
 }
@@ -24,6 +26,10 @@ fn main() {
     let _ = String::new().ends_with(".EXT12");
     let _ = "str".ends_with(".EXT12");
 
+    // This should print a note about how to_lowercase and to_uppercase allocates
+    let _ = String::new().to_lowercase().ends_with(".EXT12");
+    let _ = String::new().to_uppercase().ends_with(".EXT12");
+
     // The test struct should not trigger the lint failure with .EXT12
     TestStruct {}.ends_with(".EXT12");
 
diff --git a/tests/ui/case_sensitive_file_extension_comparisons.stderr b/tests/ui/case_sensitive_file_extension_comparisons.stderr
index a28dd8bd5ad..33435f086d4 100644
--- a/tests/ui/case_sensitive_file_extension_comparisons.stderr
+++ b/tests/ui/case_sensitive_file_extension_comparisons.stderr
@@ -1,43 +1,103 @@
 error: case-sensitive file extension comparison
-  --> $DIR/case_sensitive_file_extension_comparisons.rs:12:14
+  --> $DIR/case_sensitive_file_extension_comparisons.rs:14:5
    |
 LL |     filename.ends_with(".rs")
-   |              ^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: consider using a case-insensitive comparison instead
    = note: `-D clippy::case-sensitive-file-extension-comparisons` implied by `-D warnings`
+help: use std::path::Path
+   |
+LL ~     std::path::Path::new(filename)
+LL +         .extension()
+LL +         .map_or(false, |ext| ext.eq_ignore_ascii_case("rs"))
+   |
 
 error: case-sensitive file extension comparison
-  --> $DIR/case_sensitive_file_extension_comparisons.rs:17:27
+  --> $DIR/case_sensitive_file_extension_comparisons.rs:19:13
    |
 LL |     let _ = String::new().ends_with(".ext12");
-   |                           ^^^^^^^^^^^^^^^^^^^
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: consider using a case-insensitive comparison instead
+help: use std::path::Path
+   |
+LL ~     let _ = std::path::Path::new(&String::new())
+LL +         .extension()
+LL ~         .map_or(false, |ext| ext.eq_ignore_ascii_case("ext12"));
+   |
 
 error: case-sensitive file extension comparison
-  --> $DIR/case_sensitive_file_extension_comparisons.rs:18:19
+  --> $DIR/case_sensitive_file_extension_comparisons.rs:20:13
    |
 LL |     let _ = "str".ends_with(".ext12");
-   |                   ^^^^^^^^^^^^^^^^^^^
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: consider using a case-insensitive comparison instead
+help: use std::path::Path
+   |
+LL ~     let _ = std::path::Path::new("str")
+LL +         .extension()
+LL ~         .map_or(false, |ext| ext.eq_ignore_ascii_case("ext12"));
+   |
 
 error: case-sensitive file extension comparison
-  --> $DIR/case_sensitive_file_extension_comparisons.rs:24:27
+  --> $DIR/case_sensitive_file_extension_comparisons.rs:26:13
    |
 LL |     let _ = String::new().ends_with(".EXT12");
-   |                           ^^^^^^^^^^^^^^^^^^^
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: consider using a case-insensitive comparison instead
+help: use std::path::Path
+   |
+LL ~     let _ = std::path::Path::new(&String::new())
+LL +         .extension()
+LL ~         .map_or(false, |ext| ext.eq_ignore_ascii_case("EXT12"));
+   |
 
 error: case-sensitive file extension comparison
-  --> $DIR/case_sensitive_file_extension_comparisons.rs:25:19
+  --> $DIR/case_sensitive_file_extension_comparisons.rs:27:13
    |
 LL |     let _ = "str".ends_with(".EXT12");
-   |                   ^^^^^^^^^^^^^^^^^^^
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using a case-insensitive comparison instead
+help: use std::path::Path
+   |
+LL ~     let _ = std::path::Path::new("str")
+LL +         .extension()
+LL ~         .map_or(false, |ext| ext.eq_ignore_ascii_case("EXT12"));
+   |
+
+error: case-sensitive file extension comparison
+  --> $DIR/case_sensitive_file_extension_comparisons.rs:30:13
+   |
+LL |     let _ = String::new().to_lowercase().ends_with(".EXT12");
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using a case-insensitive comparison instead
+   = note: to_lowercase allocates memory, this can be avoided by using Path
+help: use std::path::Path
+   |
+LL ~     let _ = std::path::Path::new(&String::new())
+LL +         .extension()
+LL ~         .map_or(false, |ext| ext.eq_ignore_ascii_case("EXT12"));
+   |
+
+error: case-sensitive file extension comparison
+  --> $DIR/case_sensitive_file_extension_comparisons.rs:31:13
+   |
+LL |     let _ = String::new().to_uppercase().ends_with(".EXT12");
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: consider using a case-insensitive comparison instead
+   = note: to_uppercase allocates memory, this can be avoided by using Path
+help: use std::path::Path
+   |
+LL ~     let _ = std::path::Path::new(&String::new())
+LL +         .extension()
+LL ~         .map_or(false, |ext| ext.eq_ignore_ascii_case("EXT12"));
+   |
 
-error: aborting due to 5 previous errors
+error: aborting due to 7 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 0aa7d73df37470b9f868873587faf64c3339f964 Mon Sep 17 00:00:00 2001
From: Tyler Weaver <maybe@tylerjw.dev>
Date: Mon, 2 Jan 2023 07:12:43 -0700
Subject: Only remove method from end of recv, indent suggestion source

Signed-off-by: Tyler Weaver <maybe@tylerjw.dev>
---
 .../case_sensitive_file_extension_comparisons.rs   | 28 ++++++++++++++--------
 1 file changed, 18 insertions(+), 10 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/case_sensitive_file_extension_comparisons.rs b/clippy_lints/src/methods/case_sensitive_file_extension_comparisons.rs
index bc9b7a73b5b..e34c377f5fc 100644
--- a/clippy_lints/src/methods/case_sensitive_file_extension_comparisons.rs
+++ b/clippy_lints/src/methods/case_sensitive_file_extension_comparisons.rs
@@ -1,4 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::source::{indent_of, reindent_multiline};
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::is_type_lang_item;
 use if_chain::if_chain;
@@ -37,29 +38,36 @@ pub(super) fn check<'tcx>(
                 "case-sensitive file extension comparison",
                 |diag| {
                     diag.help("consider using a case-insensitive comparison instead");
-                    let mut recv_str = Sugg::hir(cx, recv, "").to_string();
+                    let mut recv_source = Sugg::hir(cx, recv, "").to_string();
 
                     if is_type_lang_item(cx, recv_ty, LangItem::String) {
-                        recv_str = format!("&{recv_str}");
+                        recv_source = format!("&{recv_source}");
                     }
 
-                    if recv_str.contains(".to_lowercase()") {
+                    if recv_source.ends_with(".to_lowercase()") {
                         diag.note("to_lowercase allocates memory, this can be avoided by using Path");
-                        recv_str = recv_str.replace(".to_lowercase()", "");
+                        recv_source = recv_source.strip_suffix(".to_lowercase()").unwrap().to_string();
                     }
 
-                    if recv_str.contains(".to_uppercase()") {
+                    if recv_source.ends_with(".to_uppercase()") {
                         diag.note("to_uppercase allocates memory, this can be avoided by using Path");
-                        recv_str = recv_str.replace(".to_uppercase()", "");
+                        recv_source = recv_source.strip_suffix(".to_uppercase()").unwrap().to_string();
                     }
 
+                    let suggestion_source = reindent_multiline(
+                        format!(
+                            "std::path::Path::new({})
+                                .extension()
+                                .map_or(false, |ext| ext.eq_ignore_ascii_case(\"{}\"))",
+                            recv_source, ext_str.strip_prefix('.').unwrap()).into(),
+                        true,
+                        Some(indent_of(cx, call_span).unwrap_or(0) + 4)
+                    );
+
                     diag.span_suggestion(
                         recv.span.to(call_span),
                         "use std::path::Path",
-                        format!("std::path::Path::new({})
-        .extension()
-        .map_or(false, |ext| ext.eq_ignore_ascii_case(\"{}\"))", 
-                            recv_str, ext_str.strip_prefix('.').unwrap()),
+                        suggestion_source,
                         Applicability::MaybeIncorrect,
                     );
                 }
-- 
cgit 1.4.1-3-g733a5


From 0cee2c50952a11099692652af367b4fea3cb09a6 Mon Sep 17 00:00:00 2001
From: Tyler Weaver <tyler@picknik.ai>
Date: Mon, 2 Jan 2023 16:42:56 -0700
Subject: Don't trigger lint if last method is to_lower/upper

---
 .../case_sensitive_file_extension_comparisons.rs   | 17 +++++-------
 ...case_sensitive_file_extension_comparisons.fixed | 10 ++-----
 .../case_sensitive_file_extension_comparisons.rs   |  2 +-
 ...ase_sensitive_file_extension_comparisons.stderr | 32 +---------------------
 4 files changed, 12 insertions(+), 49 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/case_sensitive_file_extension_comparisons.rs b/clippy_lints/src/methods/case_sensitive_file_extension_comparisons.rs
index e34c377f5fc..b6ec0fba6cf 100644
--- a/clippy_lints/src/methods/case_sensitive_file_extension_comparisons.rs
+++ b/clippy_lints/src/methods/case_sensitive_file_extension_comparisons.rs
@@ -18,6 +18,13 @@ pub(super) fn check<'tcx>(
     recv: &'tcx Expr<'_>,
     arg: &'tcx Expr<'_>,
 ) {
+    if let ExprKind::MethodCall(path_segment, ..) = recv.kind {
+        let method_name = path_segment.ident.name.as_str();
+        if method_name == "to_lowercase" || method_name == "to_uppercase" {
+            return;
+        }
+    }
+
     if_chain! {
         if let Some(method_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
         if let Some(impl_id) = cx.tcx.impl_of_method(method_id);
@@ -44,16 +51,6 @@ pub(super) fn check<'tcx>(
                         recv_source = format!("&{recv_source}");
                     }
 
-                    if recv_source.ends_with(".to_lowercase()") {
-                        diag.note("to_lowercase allocates memory, this can be avoided by using Path");
-                        recv_source = recv_source.strip_suffix(".to_lowercase()").unwrap().to_string();
-                    }
-
-                    if recv_source.ends_with(".to_uppercase()") {
-                        diag.note("to_uppercase allocates memory, this can be avoided by using Path");
-                        recv_source = recv_source.strip_suffix(".to_uppercase()").unwrap().to_string();
-                    }
-
                     let suggestion_source = reindent_multiline(
                         format!(
                             "std::path::Path::new({})
diff --git a/tests/ui/case_sensitive_file_extension_comparisons.fixed b/tests/ui/case_sensitive_file_extension_comparisons.fixed
index a8b5950f208..a19ed1ddcd5 100644
--- a/tests/ui/case_sensitive_file_extension_comparisons.fixed
+++ b/tests/ui/case_sensitive_file_extension_comparisons.fixed
@@ -36,13 +36,9 @@ fn main() {
         .extension()
         .map_or(false, |ext| ext.eq_ignore_ascii_case("EXT12"));
 
-    // This should print a note about how to_lowercase and to_uppercase allocates
-    let _ = std::path::Path::new(&String::new())
-        .extension()
-        .map_or(false, |ext| ext.eq_ignore_ascii_case("EXT12"));
-    let _ = std::path::Path::new(&String::new())
-        .extension()
-        .map_or(false, |ext| ext.eq_ignore_ascii_case("EXT12"));
+    // Should not trigger the lint failure because of the calls to to_lowercase and to_uppercase
+    let _ = String::new().to_lowercase().ends_with(".EXT12");
+    let _ = String::new().to_uppercase().ends_with(".EXT12");
 
     // The test struct should not trigger the lint failure with .EXT12
     TestStruct {}.ends_with(".EXT12");
diff --git a/tests/ui/case_sensitive_file_extension_comparisons.rs b/tests/ui/case_sensitive_file_extension_comparisons.rs
index ee9bcd73d52..ad56b7296f7 100644
--- a/tests/ui/case_sensitive_file_extension_comparisons.rs
+++ b/tests/ui/case_sensitive_file_extension_comparisons.rs
@@ -26,7 +26,7 @@ fn main() {
     let _ = String::new().ends_with(".EXT12");
     let _ = "str".ends_with(".EXT12");
 
-    // This should print a note about how to_lowercase and to_uppercase allocates
+    // Should not trigger the lint failure because of the calls to to_lowercase and to_uppercase
     let _ = String::new().to_lowercase().ends_with(".EXT12");
     let _ = String::new().to_uppercase().ends_with(".EXT12");
 
diff --git a/tests/ui/case_sensitive_file_extension_comparisons.stderr b/tests/ui/case_sensitive_file_extension_comparisons.stderr
index 33435f086d4..b5c8e4b4fe6 100644
--- a/tests/ui/case_sensitive_file_extension_comparisons.stderr
+++ b/tests/ui/case_sensitive_file_extension_comparisons.stderr
@@ -69,35 +69,5 @@ LL +         .extension()
 LL ~         .map_or(false, |ext| ext.eq_ignore_ascii_case("EXT12"));
    |
 
-error: case-sensitive file extension comparison
-  --> $DIR/case_sensitive_file_extension_comparisons.rs:30:13
-   |
-LL |     let _ = String::new().to_lowercase().ends_with(".EXT12");
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: consider using a case-insensitive comparison instead
-   = note: to_lowercase allocates memory, this can be avoided by using Path
-help: use std::path::Path
-   |
-LL ~     let _ = std::path::Path::new(&String::new())
-LL +         .extension()
-LL ~         .map_or(false, |ext| ext.eq_ignore_ascii_case("EXT12"));
-   |
-
-error: case-sensitive file extension comparison
-  --> $DIR/case_sensitive_file_extension_comparisons.rs:31:13
-   |
-LL |     let _ = String::new().to_uppercase().ends_with(".EXT12");
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: consider using a case-insensitive comparison instead
-   = note: to_uppercase allocates memory, this can be avoided by using Path
-help: use std::path::Path
-   |
-LL ~     let _ = std::path::Path::new(&String::new())
-LL +         .extension()
-LL ~         .map_or(false, |ext| ext.eq_ignore_ascii_case("EXT12"));
-   |
-
-error: aborting due to 7 previous errors
+error: aborting due to 5 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From d3a50d2fda4fd1a024dfe7b01ab69fb5a0a6b7a7 Mon Sep 17 00:00:00 2001
From: Andre Bogus <bogusandre@gmail.com>
Date: Wed, 4 Jan 2023 00:44:20 +0100
Subject: trim paths in `box_default`

---
 clippy_lints/src/box_default.rs | 4 ++--
 tests/ui/box_default.fixed      | 8 ++++----
 tests/ui/box_default.stderr     | 8 ++++----
 3 files changed, 10 insertions(+), 10 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/box_default.rs b/clippy_lints/src/box_default.rs
index 91900542af8..9d98a6bab71 100644
--- a/clippy_lints/src/box_default.rs
+++ b/clippy_lints/src/box_default.rs
@@ -8,7 +8,7 @@ use rustc_hir::{
     Block, Expr, ExprKind, Local, Node, QPath, TyKind,
 };
 use rustc_lint::{LateContext, LateLintPass, LintContext};
-use rustc_middle::lint::in_external_macro;
+use rustc_middle::{lint::in_external_macro, ty::print::with_forced_trimmed_paths};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::sym;
 
@@ -59,7 +59,7 @@ impl LateLintPass<'_> for BoxDefault {
                 if is_plain_default(arg_path) || given_type(cx, expr) {
                     "Box::default()".into()
                 } else {
-                    format!("Box::<{arg_ty}>::default()")
+                    with_forced_trimmed_paths!(format!("Box::<{arg_ty}>::default()"))
                 },
                 Applicability::MachineApplicable
             );
diff --git a/tests/ui/box_default.fixed b/tests/ui/box_default.fixed
index 911fa856aa0..68ab996a704 100644
--- a/tests/ui/box_default.fixed
+++ b/tests/ui/box_default.fixed
@@ -21,16 +21,16 @@ macro_rules! outer {
 fn main() {
     let _string: Box<String> = Box::default();
     let _byte = Box::<u8>::default();
-    let _vec = Box::<std::vec::Vec<u8>>::default();
+    let _vec = Box::<Vec<u8>>::default();
     let _impl = Box::<ImplementsDefault>::default();
     let _impl2 = Box::<ImplementsDefault>::default();
     let _impl3: Box<ImplementsDefault> = Box::default();
     let _own = Box::new(OwnDefault::default()); // should not lint
-    let _in_macro = outer!(Box::<std::string::String>::default());
-    let _string_default = outer!(Box::<std::string::String>::default());
+    let _in_macro = outer!(Box::<String>::default());
+    let _string_default = outer!(Box::<String>::default());
     let _vec2: Box<Vec<ImplementsDefault>> = Box::default();
     let _vec3: Box<Vec<bool>> = Box::default();
-    let _vec4: Box<_> = Box::<std::vec::Vec<bool>>::default();
+    let _vec4: Box<_> = Box::<Vec<bool>>::default();
     let _more = ret_ty_fn();
     call_ty_fn(Box::default());
 }
diff --git a/tests/ui/box_default.stderr b/tests/ui/box_default.stderr
index 5ea410331af..f77c97cdfa2 100644
--- a/tests/ui/box_default.stderr
+++ b/tests/ui/box_default.stderr
@@ -16,7 +16,7 @@ error: `Box::new(_)` of default value
   --> $DIR/box_default.rs:24:16
    |
 LL |     let _vec = Box::new(Vec::<u8>::new());
-   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Box::<std::vec::Vec<u8>>::default()`
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Box::<Vec<u8>>::default()`
 
 error: `Box::new(_)` of default value
   --> $DIR/box_default.rs:25:17
@@ -40,13 +40,13 @@ error: `Box::new(_)` of default value
   --> $DIR/box_default.rs:29:28
    |
 LL |     let _in_macro = outer!(Box::new(String::new()));
-   |                            ^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Box::<std::string::String>::default()`
+   |                            ^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Box::<String>::default()`
 
 error: `Box::new(_)` of default value
   --> $DIR/box_default.rs:30:34
    |
 LL |     let _string_default = outer!(Box::new(String::from("")));
-   |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Box::<std::string::String>::default()`
+   |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Box::<String>::default()`
 
 error: `Box::new(_)` of default value
   --> $DIR/box_default.rs:31:46
@@ -64,7 +64,7 @@ error: `Box::new(_)` of default value
   --> $DIR/box_default.rs:33:25
    |
 LL |     let _vec4: Box<_> = Box::new(Vec::from([false; 0]));
-   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Box::<std::vec::Vec<bool>>::default()`
+   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Box::<Vec<bool>>::default()`
 
 error: `Box::new(_)` of default value
   --> $DIR/box_default.rs:35:16
-- 
cgit 1.4.1-3-g733a5


From ea6ff7ed04b5785d20af03b1e4ac73b4960fa5d5 Mon Sep 17 00:00:00 2001
From: Tyler Weaver <maybe@tylerjw.dev>
Date: Wed, 4 Jan 2023 07:06:07 -0700
Subject: Apply changes suggested in review

---
 .../case_sensitive_file_extension_comparisons.rs   | 47 ++++++++++++----------
 ...case_sensitive_file_extension_comparisons.fixed |  7 ++++
 .../case_sensitive_file_extension_comparisons.rs   |  5 +++
 ...ase_sensitive_file_extension_comparisons.stderr | 20 +++++++--
 4 files changed, 54 insertions(+), 25 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/case_sensitive_file_extension_comparisons.rs b/clippy_lints/src/methods/case_sensitive_file_extension_comparisons.rs
index b6ec0fba6cf..0b3bf22743f 100644
--- a/clippy_lints/src/methods/case_sensitive_file_extension_comparisons.rs
+++ b/clippy_lints/src/methods/case_sensitive_file_extension_comparisons.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::source::snippet_opt;
 use clippy_utils::source::{indent_of, reindent_multiline};
-use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::is_type_lang_item;
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
@@ -19,8 +19,10 @@ pub(super) fn check<'tcx>(
     arg: &'tcx Expr<'_>,
 ) {
     if let ExprKind::MethodCall(path_segment, ..) = recv.kind {
-        let method_name = path_segment.ident.name.as_str();
-        if method_name == "to_lowercase" || method_name == "to_uppercase" {
+        if matches!(
+            path_segment.ident.name.as_str(),
+            "to_lowercase" | "to_uppercase" | "to_ascii_lowercase" | "to_ascii_uppercase"
+        ) {
             return;
         }
     }
@@ -45,28 +47,29 @@ pub(super) fn check<'tcx>(
                 "case-sensitive file extension comparison",
                 |diag| {
                     diag.help("consider using a case-insensitive comparison instead");
-                    let mut recv_source = Sugg::hir(cx, recv, "").to_string();
+                    if let Some(mut recv_source) = snippet_opt(cx, recv.span) {
 
-                    if is_type_lang_item(cx, recv_ty, LangItem::String) {
-                        recv_source = format!("&{recv_source}");
-                    }
+                        if !cx.typeck_results().expr_ty(recv).is_ref() {
+                            recv_source = format!("&{recv_source}");
+                        }
 
-                    let suggestion_source = reindent_multiline(
-                        format!(
-                            "std::path::Path::new({})
-                                .extension()
-                                .map_or(false, |ext| ext.eq_ignore_ascii_case(\"{}\"))",
-                            recv_source, ext_str.strip_prefix('.').unwrap()).into(),
-                        true,
-                        Some(indent_of(cx, call_span).unwrap_or(0) + 4)
-                    );
+                        let suggestion_source = reindent_multiline(
+                            format!(
+                                "std::path::Path::new({})
+                                    .extension()
+                                    .map_or(false, |ext| ext.eq_ignore_ascii_case(\"{}\"))",
+                                recv_source, ext_str.strip_prefix('.').unwrap()).into(),
+                            true,
+                            Some(indent_of(cx, call_span).unwrap_or(0) + 4)
+                        );
 
-                    diag.span_suggestion(
-                        recv.span.to(call_span),
-                        "use std::path::Path",
-                        suggestion_source,
-                        Applicability::MaybeIncorrect,
-                    );
+                        diag.span_suggestion(
+                            recv.span.to(call_span),
+                            "use std::path::Path",
+                            suggestion_source,
+                            Applicability::MaybeIncorrect,
+                        );
+                    }
                 }
             );
         }
diff --git a/tests/ui/case_sensitive_file_extension_comparisons.fixed b/tests/ui/case_sensitive_file_extension_comparisons.fixed
index a19ed1ddcd5..5fbaa64db39 100644
--- a/tests/ui/case_sensitive_file_extension_comparisons.fixed
+++ b/tests/ui/case_sensitive_file_extension_comparisons.fixed
@@ -25,6 +25,13 @@ fn main() {
         .extension()
         .map_or(false, |ext| ext.eq_ignore_ascii_case("ext12"));
 
+    // The fixup should preserve the indentation level
+    {
+        let _ = std::path::Path::new("str")
+            .extension()
+            .map_or(false, |ext| ext.eq_ignore_ascii_case("ext12"));
+    }
+
     // The test struct should not trigger the lint failure with .ext12
     TestStruct {}.ends_with(".ext12");
 
diff --git a/tests/ui/case_sensitive_file_extension_comparisons.rs b/tests/ui/case_sensitive_file_extension_comparisons.rs
index ad56b7296f7..3c0d4821f9f 100644
--- a/tests/ui/case_sensitive_file_extension_comparisons.rs
+++ b/tests/ui/case_sensitive_file_extension_comparisons.rs
@@ -19,6 +19,11 @@ fn main() {
     let _ = String::new().ends_with(".ext12");
     let _ = "str".ends_with(".ext12");
 
+    // The fixup should preserve the indentation level
+    {
+        let _ = "str".ends_with(".ext12");
+    }
+
     // The test struct should not trigger the lint failure with .ext12
     TestStruct {}.ends_with(".ext12");
 
diff --git a/tests/ui/case_sensitive_file_extension_comparisons.stderr b/tests/ui/case_sensitive_file_extension_comparisons.stderr
index b5c8e4b4fe6..44c8e3fdf74 100644
--- a/tests/ui/case_sensitive_file_extension_comparisons.stderr
+++ b/tests/ui/case_sensitive_file_extension_comparisons.stderr
@@ -42,7 +42,21 @@ LL ~         .map_or(false, |ext| ext.eq_ignore_ascii_case("ext12"));
    |
 
 error: case-sensitive file extension comparison
-  --> $DIR/case_sensitive_file_extension_comparisons.rs:26:13
+  --> $DIR/case_sensitive_file_extension_comparisons.rs:24:17
+   |
+LL |         let _ = "str".ends_with(".ext12");
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using a case-insensitive comparison instead
+help: use std::path::Path
+   |
+LL ~         let _ = std::path::Path::new("str")
+LL +             .extension()
+LL ~             .map_or(false, |ext| ext.eq_ignore_ascii_case("ext12"));
+   |
+
+error: case-sensitive file extension comparison
+  --> $DIR/case_sensitive_file_extension_comparisons.rs:31:13
    |
 LL |     let _ = String::new().ends_with(".EXT12");
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -56,7 +70,7 @@ LL ~         .map_or(false, |ext| ext.eq_ignore_ascii_case("EXT12"));
    |
 
 error: case-sensitive file extension comparison
-  --> $DIR/case_sensitive_file_extension_comparisons.rs:27:13
+  --> $DIR/case_sensitive_file_extension_comparisons.rs:32:13
    |
 LL |     let _ = "str".ends_with(".EXT12");
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -69,5 +83,5 @@ LL +         .extension()
 LL ~         .map_or(false, |ext| ext.eq_ignore_ascii_case("EXT12"));
    |
 
-error: aborting due to 5 previous errors
+error: aborting due to 6 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From d0c1605d5151c86215ad609feadead811e5602c0 Mon Sep 17 00:00:00 2001
From: Kyle Huey <khuey@kylehuey.com>
Date: Wed, 4 Jan 2023 13:32:34 -0800
Subject: Make the iter_kv_map lint handle ref/mut annotations.

For the degenerate (`map(|(k, _)| k)`/`map(|(_, v)| v)`) cases a mut annotation is superfluous and a ref annotation won't compile, so no additional handling is required. For cases where the `map` call must be preserved ref/mut annotations should also be presereved so that the map body continues to work as expected.
---
 clippy_lints/src/methods/iter_kv_map.rs |  20 ++++--
 tests/ui/iter_kv_map.fixed              |  35 +++++++++-
 tests/ui/iter_kv_map.rs                 |  39 ++++++++++-
 tests/ui/iter_kv_map.stderr             | 114 +++++++++++++++++++++++++-------
 4 files changed, 174 insertions(+), 34 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/iter_kv_map.rs b/clippy_lints/src/methods/iter_kv_map.rs
index 2244ebfb129..1e5805c5347 100644
--- a/clippy_lints/src/methods/iter_kv_map.rs
+++ b/clippy_lints/src/methods/iter_kv_map.rs
@@ -6,7 +6,7 @@ use clippy_utils::source::{snippet, snippet_with_applicability};
 use clippy_utils::sugg;
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::visitors::is_local_used;
-use rustc_hir::{BindingAnnotation, Body, BorrowKind, Expr, ExprKind, Mutability, Pat, PatKind};
+use rustc_hir::{BindingAnnotation, Body, BorrowKind, ByRef, Expr, ExprKind, Mutability, Pat, PatKind};
 use rustc_lint::{LateContext, LintContext};
 use rustc_middle::ty;
 use rustc_span::sym;
@@ -30,9 +30,9 @@ pub(super) fn check<'tcx>(
         if let Body {params: [p], value: body_expr, generator_kind: _ } = cx.tcx.hir().body(c.body);
         if let PatKind::Tuple([key_pat, val_pat], _) = p.pat.kind;
 
-        let (replacement_kind, binded_ident) = match (&key_pat.kind, &val_pat.kind) {
-            (key, PatKind::Binding(_, _, value, _)) if pat_is_wild(cx, key, m_arg) => ("value", value),
-            (PatKind::Binding(_, _, key, _), value) if pat_is_wild(cx, value, m_arg) => ("key", key),
+        let (replacement_kind, annotation, binded_ident) = match (&key_pat.kind, &val_pat.kind) {
+            (key, PatKind::Binding(ann, _, value, _)) if pat_is_wild(cx, key, m_arg) => ("value", ann, value),
+            (PatKind::Binding(ann, _, key, _), value) if pat_is_wild(cx, value, m_arg) => ("key", ann, key),
             _ => return,
         };
 
@@ -60,13 +60,23 @@ pub(super) fn check<'tcx>(
                         applicability,
                     );
                 } else {
+                    let ref_annotation = if annotation.0 == ByRef::Yes {
+                        "ref "
+                    } else {
+                        ""
+                    };
+                    let mut_annotation = if annotation.1 == Mutability::Mut {
+                        "mut "
+                    } else {
+                        ""
+                    };
                     span_lint_and_sugg(
                         cx,
                         ITER_KV_MAP,
                         expr.span,
                         &format!("iterating on a map's {replacement_kind}s"),
                         "try",
-                        format!("{recv_snippet}.{into_prefix}{replacement_kind}s().map(|{binded_ident}| {})",
+                        format!("{recv_snippet}.{into_prefix}{replacement_kind}s().map(|{ref_annotation}{mut_annotation}{binded_ident}| {})",
                             snippet_with_applicability(cx, body_expr.span, "/* body */", &mut applicability)),
                         applicability,
                     );
diff --git a/tests/ui/iter_kv_map.fixed b/tests/ui/iter_kv_map.fixed
index 83fee04080f..f2a4c284cb1 100644
--- a/tests/ui/iter_kv_map.fixed
+++ b/tests/ui/iter_kv_map.fixed
@@ -1,14 +1,15 @@
 // run-rustfix
 
 #![warn(clippy::iter_kv_map)]
-#![allow(clippy::redundant_clone)]
-#![allow(clippy::suspicious_map)]
-#![allow(clippy::map_identity)]
+#![allow(unused_mut, clippy::redundant_clone, clippy::suspicious_map, clippy::map_identity)]
 
 use std::collections::{BTreeMap, HashMap};
 
 fn main() {
     let get_key = |(key, _val)| key;
+    fn ref_acceptor(v: &u32) -> u32 {
+        *v
+    }
 
     let map: HashMap<u32, u32> = HashMap::new();
 
@@ -36,6 +37,20 @@ fn main() {
     let _ = map.keys().map(|key| key * 9).count();
     let _ = map.values().map(|value| value * 17).count();
 
+    // Preserve the ref in the fix.
+    let _ = map.clone().into_values().map(|ref val| ref_acceptor(val)).count();
+
+    // Preserve the mut in the fix.
+    let _ = map
+        .clone().into_values().map(|mut val| {
+            val += 2;
+            val
+        })
+        .count();
+
+    // Don't let a mut interfere.
+    let _ = map.clone().into_values().count();
+
     let map: BTreeMap<u32, u32> = BTreeMap::new();
 
     let _ = map.keys().collect::<Vec<_>>();
@@ -61,4 +76,18 @@ fn main() {
     // Lint
     let _ = map.keys().map(|key| key * 9).count();
     let _ = map.values().map(|value| value * 17).count();
+
+    // Preserve the ref in the fix.
+    let _ = map.clone().into_values().map(|ref val| ref_acceptor(val)).count();
+
+    // Preserve the mut in the fix.
+    let _ = map
+        .clone().into_values().map(|mut val| {
+            val += 2;
+            val
+        })
+        .count();
+
+    // Don't let a mut interfere.
+    let _ = map.clone().into_values().count();
 }
diff --git a/tests/ui/iter_kv_map.rs b/tests/ui/iter_kv_map.rs
index 7a1f1fb0198..ad6564df408 100644
--- a/tests/ui/iter_kv_map.rs
+++ b/tests/ui/iter_kv_map.rs
@@ -1,14 +1,15 @@
 // run-rustfix
 
 #![warn(clippy::iter_kv_map)]
-#![allow(clippy::redundant_clone)]
-#![allow(clippy::suspicious_map)]
-#![allow(clippy::map_identity)]
+#![allow(unused_mut, clippy::redundant_clone, clippy::suspicious_map, clippy::map_identity)]
 
 use std::collections::{BTreeMap, HashMap};
 
 fn main() {
     let get_key = |(key, _val)| key;
+    fn ref_acceptor(v: &u32) -> u32 {
+        *v
+    }
 
     let map: HashMap<u32, u32> = HashMap::new();
 
@@ -36,6 +37,22 @@ fn main() {
     let _ = map.iter().map(|(key, _value)| key * 9).count();
     let _ = map.iter().map(|(_key, value)| value * 17).count();
 
+    // Preserve the ref in the fix.
+    let _ = map.clone().into_iter().map(|(_, ref val)| ref_acceptor(val)).count();
+
+    // Preserve the mut in the fix.
+    let _ = map
+        .clone()
+        .into_iter()
+        .map(|(_, mut val)| {
+            val += 2;
+            val
+        })
+        .count();
+
+    // Don't let a mut interfere.
+    let _ = map.clone().into_iter().map(|(_, mut val)| val).count();
+
     let map: BTreeMap<u32, u32> = BTreeMap::new();
 
     let _ = map.iter().map(|(key, _)| key).collect::<Vec<_>>();
@@ -61,4 +78,20 @@ fn main() {
     // Lint
     let _ = map.iter().map(|(key, _value)| key * 9).count();
     let _ = map.iter().map(|(_key, value)| value * 17).count();
+
+    // Preserve the ref in the fix.
+    let _ = map.clone().into_iter().map(|(_, ref val)| ref_acceptor(val)).count();
+
+    // Preserve the mut in the fix.
+    let _ = map
+        .clone()
+        .into_iter()
+        .map(|(_, mut val)| {
+            val += 2;
+            val
+        })
+        .count();
+
+    // Don't let a mut interfere.
+    let _ = map.clone().into_iter().map(|(_, mut val)| val).count();
 }
diff --git a/tests/ui/iter_kv_map.stderr b/tests/ui/iter_kv_map.stderr
index 9b9b04c97d8..e00da223b4d 100644
--- a/tests/ui/iter_kv_map.stderr
+++ b/tests/ui/iter_kv_map.stderr
@@ -1,5 +1,5 @@
 error: iterating on a map's keys
-  --> $DIR/iter_kv_map.rs:15:13
+  --> $DIR/iter_kv_map.rs:16:13
    |
 LL |     let _ = map.iter().map(|(key, _)| key).collect::<Vec<_>>();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.keys()`
@@ -7,130 +7,198 @@ LL |     let _ = map.iter().map(|(key, _)| key).collect::<Vec<_>>();
    = note: `-D clippy::iter-kv-map` implied by `-D warnings`
 
 error: iterating on a map's values
-  --> $DIR/iter_kv_map.rs:16:13
+  --> $DIR/iter_kv_map.rs:17:13
    |
 LL |     let _ = map.iter().map(|(_, value)| value).collect::<Vec<_>>();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.values()`
 
 error: iterating on a map's values
-  --> $DIR/iter_kv_map.rs:17:13
+  --> $DIR/iter_kv_map.rs:18:13
    |
 LL |     let _ = map.iter().map(|(_, v)| v + 2).collect::<Vec<_>>();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.values().map(|v| v + 2)`
 
 error: iterating on a map's keys
-  --> $DIR/iter_kv_map.rs:19:13
+  --> $DIR/iter_kv_map.rs:20:13
    |
 LL |     let _ = map.clone().into_iter().map(|(key, _)| key).collect::<Vec<_>>();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.clone().into_keys()`
 
 error: iterating on a map's keys
-  --> $DIR/iter_kv_map.rs:20:13
+  --> $DIR/iter_kv_map.rs:21:13
    |
 LL |     let _ = map.clone().into_iter().map(|(key, _)| key + 2).collect::<Vec<_>>();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.clone().into_keys().map(|key| key + 2)`
 
 error: iterating on a map's values
-  --> $DIR/iter_kv_map.rs:22:13
+  --> $DIR/iter_kv_map.rs:23:13
    |
 LL |     let _ = map.clone().into_iter().map(|(_, val)| val).collect::<Vec<_>>();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.clone().into_values()`
 
 error: iterating on a map's values
-  --> $DIR/iter_kv_map.rs:23:13
+  --> $DIR/iter_kv_map.rs:24:13
    |
 LL |     let _ = map.clone().into_iter().map(|(_, val)| val + 2).collect::<Vec<_>>();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.clone().into_values().map(|val| val + 2)`
 
 error: iterating on a map's values
-  --> $DIR/iter_kv_map.rs:25:13
+  --> $DIR/iter_kv_map.rs:26:13
    |
 LL |     let _ = map.clone().iter().map(|(_, val)| val).collect::<Vec<_>>();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.clone().values()`
 
 error: iterating on a map's keys
-  --> $DIR/iter_kv_map.rs:26:13
+  --> $DIR/iter_kv_map.rs:27:13
    |
 LL |     let _ = map.iter().map(|(key, _)| key).filter(|x| *x % 2 == 0).count();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.keys()`
 
 error: iterating on a map's keys
-  --> $DIR/iter_kv_map.rs:36:13
+  --> $DIR/iter_kv_map.rs:37:13
    |
 LL |     let _ = map.iter().map(|(key, _value)| key * 9).count();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.keys().map(|key| key * 9)`
 
 error: iterating on a map's values
-  --> $DIR/iter_kv_map.rs:37:13
+  --> $DIR/iter_kv_map.rs:38:13
    |
 LL |     let _ = map.iter().map(|(_key, value)| value * 17).count();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.values().map(|value| value * 17)`
 
-error: iterating on a map's keys
+error: iterating on a map's values
   --> $DIR/iter_kv_map.rs:41:13
    |
+LL |     let _ = map.clone().into_iter().map(|(_, ref val)| ref_acceptor(val)).count();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.clone().into_values().map(|ref val| ref_acceptor(val))`
+
+error: iterating on a map's values
+  --> $DIR/iter_kv_map.rs:44:13
+   |
+LL |       let _ = map
+   |  _____________^
+LL | |         .clone()
+LL | |         .into_iter()
+LL | |         .map(|(_, mut val)| {
+LL | |             val += 2;
+LL | |             val
+LL | |         })
+   | |__________^
+   |
+help: try
+   |
+LL ~     let _ = map
+LL +         .clone().into_values().map(|mut val| {
+LL +             val += 2;
+LL +             val
+LL +         })
+   |
+
+error: iterating on a map's values
+  --> $DIR/iter_kv_map.rs:54:13
+   |
+LL |     let _ = map.clone().into_iter().map(|(_, mut val)| val).count();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.clone().into_values()`
+
+error: iterating on a map's keys
+  --> $DIR/iter_kv_map.rs:58:13
+   |
 LL |     let _ = map.iter().map(|(key, _)| key).collect::<Vec<_>>();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.keys()`
 
 error: iterating on a map's values
-  --> $DIR/iter_kv_map.rs:42:13
+  --> $DIR/iter_kv_map.rs:59:13
    |
 LL |     let _ = map.iter().map(|(_, value)| value).collect::<Vec<_>>();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.values()`
 
 error: iterating on a map's values
-  --> $DIR/iter_kv_map.rs:43:13
+  --> $DIR/iter_kv_map.rs:60:13
    |
 LL |     let _ = map.iter().map(|(_, v)| v + 2).collect::<Vec<_>>();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.values().map(|v| v + 2)`
 
 error: iterating on a map's keys
-  --> $DIR/iter_kv_map.rs:45:13
+  --> $DIR/iter_kv_map.rs:62:13
    |
 LL |     let _ = map.clone().into_iter().map(|(key, _)| key).collect::<Vec<_>>();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.clone().into_keys()`
 
 error: iterating on a map's keys
-  --> $DIR/iter_kv_map.rs:46:13
+  --> $DIR/iter_kv_map.rs:63:13
    |
 LL |     let _ = map.clone().into_iter().map(|(key, _)| key + 2).collect::<Vec<_>>();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.clone().into_keys().map(|key| key + 2)`
 
 error: iterating on a map's values
-  --> $DIR/iter_kv_map.rs:48:13
+  --> $DIR/iter_kv_map.rs:65:13
    |
 LL |     let _ = map.clone().into_iter().map(|(_, val)| val).collect::<Vec<_>>();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.clone().into_values()`
 
 error: iterating on a map's values
-  --> $DIR/iter_kv_map.rs:49:13
+  --> $DIR/iter_kv_map.rs:66:13
    |
 LL |     let _ = map.clone().into_iter().map(|(_, val)| val + 2).collect::<Vec<_>>();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.clone().into_values().map(|val| val + 2)`
 
 error: iterating on a map's values
-  --> $DIR/iter_kv_map.rs:51:13
+  --> $DIR/iter_kv_map.rs:68:13
    |
 LL |     let _ = map.clone().iter().map(|(_, val)| val).collect::<Vec<_>>();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.clone().values()`
 
 error: iterating on a map's keys
-  --> $DIR/iter_kv_map.rs:52:13
+  --> $DIR/iter_kv_map.rs:69:13
    |
 LL |     let _ = map.iter().map(|(key, _)| key).filter(|x| *x % 2 == 0).count();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.keys()`
 
 error: iterating on a map's keys
-  --> $DIR/iter_kv_map.rs:62:13
+  --> $DIR/iter_kv_map.rs:79:13
    |
 LL |     let _ = map.iter().map(|(key, _value)| key * 9).count();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.keys().map(|key| key * 9)`
 
 error: iterating on a map's values
-  --> $DIR/iter_kv_map.rs:63:13
+  --> $DIR/iter_kv_map.rs:80:13
    |
 LL |     let _ = map.iter().map(|(_key, value)| value * 17).count();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.values().map(|value| value * 17)`
 
-error: aborting due to 22 previous errors
+error: iterating on a map's values
+  --> $DIR/iter_kv_map.rs:83:13
+   |
+LL |     let _ = map.clone().into_iter().map(|(_, ref val)| ref_acceptor(val)).count();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.clone().into_values().map(|ref val| ref_acceptor(val))`
+
+error: iterating on a map's values
+  --> $DIR/iter_kv_map.rs:86:13
+   |
+LL |       let _ = map
+   |  _____________^
+LL | |         .clone()
+LL | |         .into_iter()
+LL | |         .map(|(_, mut val)| {
+LL | |             val += 2;
+LL | |             val
+LL | |         })
+   | |__________^
+   |
+help: try
+   |
+LL ~     let _ = map
+LL +         .clone().into_values().map(|mut val| {
+LL +             val += 2;
+LL +             val
+LL +         })
+   |
+
+error: iterating on a map's values
+  --> $DIR/iter_kv_map.rs:96:13
+   |
+LL |     let _ = map.clone().into_iter().map(|(_, mut val)| val).count();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.clone().into_values()`
+
+error: aborting due to 28 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 05ba519a3ab8c06ba449d41a14e8584d785c1cb9 Mon Sep 17 00:00:00 2001
From: Andre Bogus <bogusandre@gmail.com>
Date: Wed, 4 Jan 2023 11:23:35 +0100
Subject: trim paths in `default_trait_access`/`clone_on_copy` suggestions

---
 clippy_lints/src/default.rs               |  5 ++---
 clippy_lints/src/methods/clone_on_copy.rs | 14 ++++++++------
 tests/ui/clone_on_copy.stderr             |  2 +-
 tests/ui/default_trait_access.fixed       |  8 ++++----
 tests/ui/default_trait_access.stderr      | 16 ++++++++--------
 tests/ui/unnecessary_clone.stderr         | 10 +++++-----
 6 files changed, 28 insertions(+), 27 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/default.rs b/clippy_lints/src/default.rs
index 55f6121a09d..a04693f4637 100644
--- a/clippy_lints/src/default.rs
+++ b/clippy_lints/src/default.rs
@@ -11,6 +11,7 @@ use rustc_hir::def::Res;
 use rustc_hir::{Block, Expr, ExprKind, PatKind, QPath, Stmt, StmtKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
+use rustc_middle::ty::print::with_forced_trimmed_paths;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::symbol::{Ident, Symbol};
 use rustc_span::Span;
@@ -98,9 +99,7 @@ impl<'tcx> LateLintPass<'tcx> for Default {
             if let ty::Adt(def, ..) = expr_ty.kind();
             if !is_from_proc_macro(cx, expr);
             then {
-                // TODO: Work out a way to put "whatever the imported way of referencing
-                // this type in this file" rather than a fully-qualified type.
-                let replacement = format!("{}::default()", cx.tcx.def_path_str(def.did()));
+                let replacement = with_forced_trimmed_paths!(format!("{}::default()", cx.tcx.def_path_str(def.did())));
                 span_lint_and_sugg(
                     cx,
                     DEFAULT_TRAIT_ACCESS,
diff --git a/clippy_lints/src/methods/clone_on_copy.rs b/clippy_lints/src/methods/clone_on_copy.rs
index 7c7938dd2e8..3795c0ec250 100644
--- a/clippy_lints/src/methods/clone_on_copy.rs
+++ b/clippy_lints/src/methods/clone_on_copy.rs
@@ -6,7 +6,7 @@ use clippy_utils::ty::is_copy;
 use rustc_errors::Applicability;
 use rustc_hir::{BindingAnnotation, ByRef, Expr, ExprKind, MatchSource, Node, PatKind, QPath};
 use rustc_lint::LateContext;
-use rustc_middle::ty::{self, adjustment::Adjust};
+use rustc_middle::ty::{self, adjustment::Adjust, print::with_forced_trimmed_paths};
 use rustc_span::symbol::{sym, Symbol};
 
 use super::CLONE_DOUBLE_REF;
@@ -47,10 +47,10 @@ pub(super) fn check(
                 cx,
                 CLONE_DOUBLE_REF,
                 expr.span,
-                &format!(
+                &with_forced_trimmed_paths!(format!(
                     "using `clone` on a double-reference; \
                     this will copy the reference of type `{ty}` instead of cloning the inner type"
-                ),
+                )),
                 |diag| {
                     if let Some(snip) = sugg::Sugg::hir_opt(cx, arg) {
                         let mut ty = innermost;
@@ -61,11 +61,11 @@ pub(super) fn check(
                         }
                         let refs = "&".repeat(n + 1);
                         let derefs = "*".repeat(n);
-                        let explicit = format!("<{refs}{ty}>::clone({snip})");
+                        let explicit = with_forced_trimmed_paths!(format!("<{refs}{ty}>::clone({snip})"));
                         diag.span_suggestion(
                             expr.span,
                             "try dereferencing it",
-                            format!("{refs}({derefs}{}).clone()", snip.deref()),
+                            with_forced_trimmed_paths!(format!("{refs}({derefs}{}).clone()", snip.deref())),
                             Applicability::MaybeIncorrect,
                         );
                         diag.span_suggestion(
@@ -129,7 +129,9 @@ pub(super) fn check(
             cx,
             CLONE_ON_COPY,
             expr.span,
-            &format!("using `clone` on type `{ty}` which implements the `Copy` trait"),
+            &with_forced_trimmed_paths!(format!(
+                "using `clone` on type `{ty}` which implements the `Copy` trait"
+            )),
             help,
             sugg,
             app,
diff --git a/tests/ui/clone_on_copy.stderr b/tests/ui/clone_on_copy.stderr
index 42ae227777c..862234d204b 100644
--- a/tests/ui/clone_on_copy.stderr
+++ b/tests/ui/clone_on_copy.stderr
@@ -48,7 +48,7 @@ error: using `clone` on type `i32` which implements the `Copy` trait
 LL |     vec.push(42.clone());
    |              ^^^^^^^^^^ help: try removing the `clone` call: `42`
 
-error: using `clone` on type `std::option::Option<i32>` which implements the `Copy` trait
+error: using `clone` on type `Option<i32>` which implements the `Copy` trait
   --> $DIR/clone_on_copy.rs:77:17
    |
 LL |     let value = opt.clone()?; // operator precedence needed (*opt)?
diff --git a/tests/ui/default_trait_access.fixed b/tests/ui/default_trait_access.fixed
index eedd4361939..5640599d48a 100644
--- a/tests/ui/default_trait_access.fixed
+++ b/tests/ui/default_trait_access.fixed
@@ -12,17 +12,17 @@ use std::default::Default as D2;
 use std::string;
 
 fn main() {
-    let s1: String = std::string::String::default();
+    let s1: String = String::default();
 
     let s2 = String::default();
 
-    let s3: String = std::string::String::default();
+    let s3: String = String::default();
 
-    let s4: String = std::string::String::default();
+    let s4: String = String::default();
 
     let s5 = string::String::default();
 
-    let s6: String = std::string::String::default();
+    let s6: String = String::default();
 
     let s7 = std::string::String::default();
 
diff --git a/tests/ui/default_trait_access.stderr b/tests/ui/default_trait_access.stderr
index 49b2dde3f1e..e4f73c08d19 100644
--- a/tests/ui/default_trait_access.stderr
+++ b/tests/ui/default_trait_access.stderr
@@ -1,8 +1,8 @@
-error: calling `std::string::String::default()` is more clear than this expression
+error: calling `String::default()` is more clear than this expression
   --> $DIR/default_trait_access.rs:15:22
    |
 LL |     let s1: String = Default::default();
-   |                      ^^^^^^^^^^^^^^^^^^ help: try: `std::string::String::default()`
+   |                      ^^^^^^^^^^^^^^^^^^ help: try: `String::default()`
    |
 note: the lint level is defined here
   --> $DIR/default_trait_access.rs:3:9
@@ -10,23 +10,23 @@ note: the lint level is defined here
 LL | #![deny(clippy::default_trait_access)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: calling `std::string::String::default()` is more clear than this expression
+error: calling `String::default()` is more clear than this expression
   --> $DIR/default_trait_access.rs:19:22
    |
 LL |     let s3: String = D2::default();
-   |                      ^^^^^^^^^^^^^ help: try: `std::string::String::default()`
+   |                      ^^^^^^^^^^^^^ help: try: `String::default()`
 
-error: calling `std::string::String::default()` is more clear than this expression
+error: calling `String::default()` is more clear than this expression
   --> $DIR/default_trait_access.rs:21:22
    |
 LL |     let s4: String = std::default::Default::default();
-   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::string::String::default()`
+   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `String::default()`
 
-error: calling `std::string::String::default()` is more clear than this expression
+error: calling `String::default()` is more clear than this expression
   --> $DIR/default_trait_access.rs:25:22
    |
 LL |     let s6: String = default::Default::default();
-   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::string::String::default()`
+   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `String::default()`
 
 error: calling `GenericDerivedDefault::default()` is more clear than this expression
   --> $DIR/default_trait_access.rs:35:46
diff --git a/tests/ui/unnecessary_clone.stderr b/tests/ui/unnecessary_clone.stderr
index 94cc7777aca..6022d9fa4c5 100644
--- a/tests/ui/unnecessary_clone.stderr
+++ b/tests/ui/unnecessary_clone.stderr
@@ -38,13 +38,13 @@ LL |     t.clone();
    |
    = note: `-D clippy::clone-on-copy` implied by `-D warnings`
 
-error: using `clone` on type `std::option::Option<T>` which implements the `Copy` trait
+error: using `clone` on type `Option<T>` which implements the `Copy` trait
   --> $DIR/unnecessary_clone.rs:42:5
    |
 LL |     Some(t).clone();
    |     ^^^^^^^^^^^^^^^ help: try removing the `clone` call: `Some(t)`
 
-error: using `clone` on a double-reference; this will copy the reference of type `&std::vec::Vec<i32>` instead of cloning the inner type
+error: using `clone` on a double-reference; this will copy the reference of type `&Vec<i32>` instead of cloning the inner type
   --> $DIR/unnecessary_clone.rs:48:22
    |
 LL |     let z: &Vec<_> = y.clone();
@@ -57,10 +57,10 @@ LL |     let z: &Vec<_> = &(*y).clone();
    |                      ~~~~~~~~~~~~~
 help: or try being explicit if you are sure, that you want to clone a reference
    |
-LL |     let z: &Vec<_> = <&std::vec::Vec<i32>>::clone(y);
-   |                      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+LL |     let z: &Vec<_> = <&Vec<i32>>::clone(y);
+   |                      ~~~~~~~~~~~~~~~~~~~~~
 
-error: using `clone` on type `many_derefs::E` which implements the `Copy` trait
+error: using `clone` on type `E` which implements the `Copy` trait
   --> $DIR/unnecessary_clone.rs:84:20
    |
 LL |         let _: E = a.clone();
-- 
cgit 1.4.1-3-g733a5


From 755ae3fa29b0b2c6b11eaecf81b201b0a9a026bf Mon Sep 17 00:00:00 2001
From: Kyle Huey <khuey@kylehuey.com>
Date: Wed, 4 Jan 2023 14:58:07 -0800
Subject: Fix spelling while we're in the neighborhood.

---
 clippy_lints/src/methods/iter_kv_map.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/iter_kv_map.rs b/clippy_lints/src/methods/iter_kv_map.rs
index 1e5805c5347..c87f5daab6f 100644
--- a/clippy_lints/src/methods/iter_kv_map.rs
+++ b/clippy_lints/src/methods/iter_kv_map.rs
@@ -30,7 +30,7 @@ pub(super) fn check<'tcx>(
         if let Body {params: [p], value: body_expr, generator_kind: _ } = cx.tcx.hir().body(c.body);
         if let PatKind::Tuple([key_pat, val_pat], _) = p.pat.kind;
 
-        let (replacement_kind, annotation, binded_ident) = match (&key_pat.kind, &val_pat.kind) {
+        let (replacement_kind, annotation, bound_ident) = match (&key_pat.kind, &val_pat.kind) {
             (key, PatKind::Binding(ann, _, value, _)) if pat_is_wild(cx, key, m_arg) => ("value", ann, value),
             (PatKind::Binding(ann, _, key, _), value) if pat_is_wild(cx, value, m_arg) => ("key", ann, key),
             _ => return,
@@ -47,7 +47,7 @@ pub(super) fn check<'tcx>(
             if_chain! {
                 if let ExprKind::Path(rustc_hir::QPath::Resolved(_, path)) = body_expr.kind;
                 if let [local_ident] = path.segments;
-                if local_ident.ident.as_str() == binded_ident.as_str();
+                if local_ident.ident.as_str() == bound_ident.as_str();
 
                 then {
                     span_lint_and_sugg(
@@ -76,7 +76,7 @@ pub(super) fn check<'tcx>(
                         expr.span,
                         &format!("iterating on a map's {replacement_kind}s"),
                         "try",
-                        format!("{recv_snippet}.{into_prefix}{replacement_kind}s().map(|{ref_annotation}{mut_annotation}{binded_ident}| {})",
+                        format!("{recv_snippet}.{into_prefix}{replacement_kind}s().map(|{ref_annotation}{mut_annotation}{bound_ident}| {})",
                             snippet_with_applicability(cx, body_expr.span, "/* body */", &mut applicability)),
                         applicability,
                     );
-- 
cgit 1.4.1-3-g733a5


From 1c42dbba60ece87f3031bc2dad5497f3cc9ad7d0 Mon Sep 17 00:00:00 2001
From: Kyle Huey <khuey@kylehuey.com>
Date: Wed, 4 Jan 2023 19:08:37 -0800
Subject: Expand derivable-impls to cover enums with a default unit variant.

---
 clippy_lints/src/derivable_impls.rs | 143 +++++++++++++++++++++++++-----------
 tests/ui/derivable_impls.fixed      |  21 ++++++
 tests/ui/derivable_impls.rs         |  23 ++++++
 tests/ui/derivable_impls.stderr     |  23 +++++-
 4 files changed, 167 insertions(+), 43 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/derivable_impls.rs b/clippy_lints/src/derivable_impls.rs
index ae8f6b79449..c987fdb1a67 100644
--- a/clippy_lints/src/derivable_impls.rs
+++ b/clippy_lints/src/derivable_impls.rs
@@ -1,11 +1,13 @@
 use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::source::indent_of;
 use clippy_utils::{is_default_equivalent, peel_blocks};
 use rustc_errors::Applicability;
 use rustc_hir::{
-    def::{DefKind, Res},
-    Body, Expr, ExprKind, GenericArg, Impl, ImplItemKind, Item, ItemKind, Node, PathSegment, QPath, TyKind,
+    def::{CtorKind, CtorOf, DefKind, Res},
+    Body, Expr, ExprKind, GenericArg, Impl, ImplItemKind, Item, ItemKind, Node, PathSegment, QPath, Ty, TyKind,
 };
 use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::{AdtDef, DefIdTree};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::sym;
 
@@ -61,6 +63,98 @@ fn is_path_self(e: &Expr<'_>) -> bool {
     }
 }
 
+fn check_struct<'tcx>(
+    cx: &LateContext<'tcx>,
+    item: &'tcx Item<'_>,
+    self_ty: &Ty<'_>,
+    func_expr: &Expr<'_>,
+    adt_def: AdtDef<'_>,
+) {
+    if let TyKind::Path(QPath::Resolved(_, p)) = self_ty.kind {
+        if let Some(PathSegment { args: Some(a), .. }) = p.segments.last() {
+            for arg in a.args {
+                if !matches!(arg, GenericArg::Lifetime(_)) {
+                    return;
+                }
+            }
+        }
+    }
+    let should_emit = match peel_blocks(func_expr).kind {
+        ExprKind::Tup(fields) => fields.iter().all(|e| is_default_equivalent(cx, e)),
+        ExprKind::Call(callee, args) if is_path_self(callee) => args.iter().all(|e| is_default_equivalent(cx, e)),
+        ExprKind::Struct(_, fields, _) => fields.iter().all(|ef| is_default_equivalent(cx, ef.expr)),
+        _ => false,
+    };
+
+    if should_emit {
+        let struct_span = cx.tcx.def_span(adt_def.did());
+        span_lint_and_then(cx, DERIVABLE_IMPLS, item.span, "this `impl` can be derived", |diag| {
+            diag.span_suggestion_hidden(
+                item.span,
+                "remove the manual implementation...",
+                String::new(),
+                Applicability::MachineApplicable,
+            );
+            diag.span_suggestion(
+                struct_span.shrink_to_lo(),
+                "...and instead derive it",
+                "#[derive(Default)]\n".to_string(),
+                Applicability::MachineApplicable,
+            );
+        });
+    }
+}
+
+fn check_enum<'tcx>(cx: &LateContext<'tcx>, item: &'tcx Item<'_>, func_expr: &Expr<'_>, adt_def: AdtDef<'_>) {
+    if_chain! {
+        if let ExprKind::Path(QPath::Resolved(None, p)) = &peel_blocks(func_expr).kind;
+        if let Res::Def(DefKind::Ctor(CtorOf::Variant, CtorKind::Const), id) = p.res;
+        if let variant_id = cx.tcx.parent(id);
+        if let Some(variant_def) = adt_def.variants().iter().find(|v| v.def_id == variant_id);
+        if variant_def.fields.is_empty();
+        if !variant_def.is_field_list_non_exhaustive();
+
+        then {
+            let enum_span = cx.tcx.def_span(adt_def.did());
+            let indent_enum = indent_of(cx, enum_span).unwrap_or(0);
+            let variant_span = cx.tcx.def_span(variant_def.def_id);
+            let indent_variant = indent_of(cx, variant_span).unwrap_or(0);
+            span_lint_and_then(
+                cx,
+                DERIVABLE_IMPLS,
+                item.span,
+                "this `impl` can be derived",
+                |diag| {
+                    diag.span_suggestion_hidden(
+                        item.span,
+                        "remove the manual implementation...",
+                        String::new(),
+                        Applicability::MachineApplicable
+                    );
+                    diag.span_suggestion(
+                        enum_span.shrink_to_lo(),
+                        "...and instead derive it...",
+                        format!(
+                            "#[derive(Default)]\n{indent}",
+                            indent = " ".repeat(indent_enum),
+                        ),
+                        Applicability::MachineApplicable
+                    );
+                    diag.span_suggestion(
+                        variant_span.shrink_to_lo(),
+                        "...and mark the default variant",
+                        format!(
+                            "#[default]\n{indent}",
+                            indent = " ".repeat(indent_variant),
+                        ),
+                        Applicability::MachineApplicable
+                    );
+                }
+            );
+        }
+    }
+}
+
 impl<'tcx> LateLintPass<'tcx> for DerivableImpls {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
         if_chain! {
@@ -83,47 +177,12 @@ impl<'tcx> LateLintPass<'tcx> for DerivableImpls {
             if !attrs.iter().any(|attr| attr.doc_str().is_some());
             if let child_attrs = cx.tcx.hir().attrs(impl_item_hir);
             if !child_attrs.iter().any(|attr| attr.doc_str().is_some());
-            if adt_def.is_struct();
-            then {
-                if let TyKind::Path(QPath::Resolved(_, p)) = self_ty.kind {
-                    if let Some(PathSegment { args: Some(a), .. }) = p.segments.last() {
-                        for arg in a.args {
-                            if !matches!(arg, GenericArg::Lifetime(_)) {
-                                return;
-                            }
-                        }
-                    }
-                }
-                let should_emit = match peel_blocks(func_expr).kind {
-                    ExprKind::Tup(fields) => fields.iter().all(|e| is_default_equivalent(cx, e)),
-                    ExprKind::Call(callee, args)
-                        if is_path_self(callee) => args.iter().all(|e| is_default_equivalent(cx, e)),
-                    ExprKind::Struct(_, fields, _) => fields.iter().all(|ef| is_default_equivalent(cx, ef.expr)),
-                    _ => false,
-                };
 
-                if should_emit {
-                    let struct_span = cx.tcx.def_span(adt_def.did());
-                    span_lint_and_then(
-                        cx,
-                        DERIVABLE_IMPLS,
-                        item.span,
-                        "this `impl` can be derived",
-                        |diag| {
-                            diag.span_suggestion_hidden(
-                                item.span,
-                                "remove the manual implementation...",
-                                String::new(),
-                                Applicability::MachineApplicable
-                            );
-                            diag.span_suggestion(
-                                struct_span.shrink_to_lo(),
-                                "...and instead derive it",
-                                "#[derive(Default)]\n".to_string(),
-                                Applicability::MachineApplicable
-                            );
-                        }
-                    );
+            then {
+                if adt_def.is_struct() {
+                    check_struct(cx, item, self_ty, func_expr, adt_def);
+                } else if adt_def.is_enum() {
+                    check_enum(cx, item, func_expr, adt_def);
                 }
             }
         }
diff --git a/tests/ui/derivable_impls.fixed b/tests/ui/derivable_impls.fixed
index 7dcdfb0937e..ee8456f5deb 100644
--- a/tests/ui/derivable_impls.fixed
+++ b/tests/ui/derivable_impls.fixed
@@ -210,4 +210,25 @@ impl Default for IntOrString {
     }
 }
 
+#[derive(Default)]
+pub enum SimpleEnum {
+    Foo,
+    #[default]
+    Bar,
+}
+
+
+
+pub enum NonExhaustiveEnum {
+    Foo,
+    #[non_exhaustive]
+    Bar,
+}
+
+impl Default for NonExhaustiveEnum {
+    fn default() -> Self {
+        NonExhaustiveEnum::Bar
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/derivable_impls.rs b/tests/ui/derivable_impls.rs
index 625cbcdde23..14af419bcad 100644
--- a/tests/ui/derivable_impls.rs
+++ b/tests/ui/derivable_impls.rs
@@ -244,4 +244,27 @@ impl Default for IntOrString {
     }
 }
 
+pub enum SimpleEnum {
+    Foo,
+    Bar,
+}
+
+impl Default for SimpleEnum {
+    fn default() -> Self {
+        SimpleEnum::Bar
+    }
+}
+
+pub enum NonExhaustiveEnum {
+    Foo,
+    #[non_exhaustive]
+    Bar,
+}
+
+impl Default for NonExhaustiveEnum {
+    fn default() -> Self {
+        NonExhaustiveEnum::Bar
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/derivable_impls.stderr b/tests/ui/derivable_impls.stderr
index c1db5a58b1f..81963c3be5b 100644
--- a/tests/ui/derivable_impls.stderr
+++ b/tests/ui/derivable_impls.stderr
@@ -113,5 +113,26 @@ help: ...and instead derive it
 LL | #[derive(Default)]
    |
 
-error: aborting due to 7 previous errors
+error: this `impl` can be derived
+  --> $DIR/derivable_impls.rs:252:1
+   |
+LL | / impl Default for SimpleEnum {
+LL | |     fn default() -> Self {
+LL | |         SimpleEnum::Bar
+LL | |     }
+LL | | }
+   | |_^
+   |
+   = help: remove the manual implementation...
+help: ...and instead derive it...
+   |
+LL | #[derive(Default)]
+   |
+help: ...and mark the default variant
+   |
+LL ~     #[default]
+LL ~     Bar,
+   |
+
+error: aborting due to 8 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 79ed23ff815bc39d0062ade40b2c38dd37e77373 Mon Sep 17 00:00:00 2001
From: Raiki Tamura <tamaron1203@gmail.com>
Date: Thu, 5 Jan 2023 18:30:13 +0900
Subject: fix

---
 clippy_lints/src/loops/single_element_loop.rs | 14 +++++++++++++
 tests/ui/single_element_loop.fixed            | 27 +++++++++++++++++++++++++
 tests/ui/single_element_loop.rs               | 26 ++++++++++++++++++++++++
 tests/ui/single_element_loop.stderr           | 29 ++++++++++++++++++++++++++-
 4 files changed, 95 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/single_element_loop.rs b/clippy_lints/src/loops/single_element_loop.rs
index f4b47808dfa..7cbc456244e 100644
--- a/clippy_lints/src/loops/single_element_loop.rs
+++ b/clippy_lints/src/loops/single_element_loop.rs
@@ -1,6 +1,7 @@
 use super::SINGLE_ELEMENT_LOOP;
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::{indent_of, snippet_with_applicability};
+use clippy_utils::visitors::for_each_expr;
 use if_chain::if_chain;
 use rustc_ast::util::parser::PREC_PREFIX;
 use rustc_ast::Mutability;
@@ -8,6 +9,18 @@ use rustc_errors::Applicability;
 use rustc_hir::{is_range_literal, BorrowKind, Expr, ExprKind, Pat};
 use rustc_lint::LateContext;
 use rustc_span::edition::Edition;
+use std::ops::ControlFlow;
+
+fn contains_break_or_continue(expr: &Expr<'_>) -> bool {
+    for_each_expr(expr, |e| {
+        if matches!(e.kind, ExprKind::Break(..) | ExprKind::Continue(..)) {
+            ControlFlow::Break(())
+        } else {
+            ControlFlow::Continue(())
+        }
+    })
+    .is_some()
+}
 
 pub(super) fn check<'tcx>(
     cx: &LateContext<'tcx>,
@@ -67,6 +80,7 @@ pub(super) fn check<'tcx>(
     if_chain! {
         if let ExprKind::Block(block, _) = body.kind;
         if !block.stmts.is_empty();
+        if !contains_break_or_continue(body);
         then {
             let mut applicability = Applicability::MachineApplicable;
             let pat_snip = snippet_with_applicability(cx, pat.span, "..", &mut applicability);
diff --git a/tests/ui/single_element_loop.fixed b/tests/ui/single_element_loop.fixed
index 63d31ff83f9..a0dcc0172e8 100644
--- a/tests/ui/single_element_loop.fixed
+++ b/tests/ui/single_element_loop.fixed
@@ -33,4 +33,31 @@ fn main() {
         let item = 0..5;
         dbg!(item);
     }
+
+    // should not lint (issue #10018)
+    for e in [42] {
+        if e > 0 {
+            continue;
+        }
+    }
+
+    // should not lint (issue #10018)
+    for e in [42] {
+        if e > 0 {
+            break;
+        }
+    }
+
+    // should lint (issue #10018)
+    {
+        let _ = 42;
+        let _f = |n: u32| {
+            for i in 0..n {
+                if i > 10 {
+                    dbg!(i);
+                    break;
+                }
+            }
+        };
+    }
 }
diff --git a/tests/ui/single_element_loop.rs b/tests/ui/single_element_loop.rs
index 2cda5a329d2..bc014035c98 100644
--- a/tests/ui/single_element_loop.rs
+++ b/tests/ui/single_element_loop.rs
@@ -27,4 +27,30 @@ fn main() {
     for item in [0..5].into_iter() {
         dbg!(item);
     }
+
+    // should not lint (issue #10018)
+    for e in [42] {
+        if e > 0 {
+            continue;
+        }
+    }
+
+    // should not lint (issue #10018)
+    for e in [42] {
+        if e > 0 {
+            break;
+        }
+    }
+
+    // should lint (issue #10018)
+    for _ in [42] {
+        let _f = |n: u32| {
+            for i in 0..n {
+                if i > 10 {
+                    dbg!(i);
+                    break;
+                }
+            }
+        };
+    }
 }
diff --git a/tests/ui/single_element_loop.stderr b/tests/ui/single_element_loop.stderr
index 0aeb8da1a2e..14437a59745 100644
--- a/tests/ui/single_element_loop.stderr
+++ b/tests/ui/single_element_loop.stderr
@@ -95,5 +95,32 @@ LL +         dbg!(item);
 LL +     }
    |
 
-error: aborting due to 6 previous errors
+error: for loop over a single element
+  --> $DIR/single_element_loop.rs:46:5
+   |
+LL | /     for _ in [42] {
+LL | |         let _f = |n: u32| {
+LL | |             for i in 0..n {
+LL | |                 if i > 10 {
+...  |
+LL | |         };
+LL | |     }
+   | |_____^
+   |
+help: try
+   |
+LL ~     {
+LL +         let _ = 42;
+LL +         let _f = |n: u32| {
+LL +             for i in 0..n {
+LL +                 if i > 10 {
+LL +                     dbg!(i);
+LL +                     break;
+LL +                 }
+LL +             }
+LL +         };
+LL +     }
+   |
+
+error: aborting due to 7 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 6433d796a1e22ea37f9b51bda5248b9ac82df578 Mon Sep 17 00:00:00 2001
From: Kyle Huey <khuey@kylehuey.com>
Date: Thu, 5 Jan 2023 13:06:43 -0800
Subject: Restrict suggestion of deriving Default for enums to MSRV 1.62.

See https://blog.rust-lang.org/2022/06/30/Rust-1.62.0.html#default-enum-variants
---
 clippy_lints/src/derivable_impls.rs | 20 +++++++++++++++++---
 clippy_lints/src/lib.rs             |  2 +-
 clippy_utils/src/msrvs.rs           |  4 ++--
 3 files changed, 20 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/derivable_impls.rs b/clippy_lints/src/derivable_impls.rs
index c987fdb1a67..bc18e2e5ed5 100644
--- a/clippy_lints/src/derivable_impls.rs
+++ b/clippy_lints/src/derivable_impls.rs
@@ -1,4 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::indent_of;
 use clippy_utils::{is_default_equivalent, peel_blocks};
 use rustc_errors::Applicability;
@@ -8,7 +9,7 @@ use rustc_hir::{
 };
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{AdtDef, DefIdTree};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::sym;
 
 declare_clippy_lint! {
@@ -53,7 +54,18 @@ declare_clippy_lint! {
     "manual implementation of the `Default` trait which is equal to a derive"
 }
 
-declare_lint_pass!(DerivableImpls => [DERIVABLE_IMPLS]);
+pub struct DerivableImpls {
+    msrv: Msrv,
+}
+
+impl DerivableImpls {
+    #[must_use]
+    pub fn new(msrv: Msrv) -> Self {
+        DerivableImpls { msrv }
+    }
+}
+
+impl_lint_pass!(DerivableImpls => [DERIVABLE_IMPLS]);
 
 fn is_path_self(e: &Expr<'_>) -> bool {
     if let ExprKind::Path(QPath::Resolved(_, p)) = e.kind {
@@ -181,10 +193,12 @@ impl<'tcx> LateLintPass<'tcx> for DerivableImpls {
             then {
                 if adt_def.is_struct() {
                     check_struct(cx, item, self_ty, func_expr, adt_def);
-                } else if adt_def.is_enum() {
+                } else if adt_def.is_enum() && self.msrv.meets(msrvs::DEFAULT_ENUM_ATTRIBUTE) {
                     check_enum(cx, item, func_expr, adt_def);
                 }
             }
         }
     }
+
+    extract_msrv_attr!(LateContext);
 }
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index dcd8ca81ae8..d8e2ae02c5a 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -639,7 +639,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(panic_unimplemented::PanicUnimplemented));
     store.register_late_pass(|_| Box::new(strings::StringLitAsBytes));
     store.register_late_pass(|_| Box::new(derive::Derive));
-    store.register_late_pass(|_| Box::new(derivable_impls::DerivableImpls));
+    store.register_late_pass(move |_| Box::new(derivable_impls::DerivableImpls::new(msrv())));
     store.register_late_pass(|_| Box::new(drop_forget_ref::DropForgetRef));
     store.register_late_pass(|_| Box::new(empty_enum::EmptyEnum));
     store.register_late_pass(|_| Box::new(invalid_upcast_comparisons::InvalidUpcastComparisons));
diff --git a/clippy_utils/src/msrvs.rs b/clippy_utils/src/msrvs.rs
index ba5bc9c3135..dbf9f3b621d 100644
--- a/clippy_utils/src/msrvs.rs
+++ b/clippy_utils/src/msrvs.rs
@@ -20,8 +20,9 @@ macro_rules! msrv_aliases {
 // names may refer to stabilized feature flags or library items
 msrv_aliases! {
     1,65,0 { LET_ELSE }
-    1,62,0 { BOOL_THEN_SOME }
+    1,62,0 { BOOL_THEN_SOME, DEFAULT_ENUM_ATTRIBUTE }
     1,58,0 { FORMAT_ARGS_CAPTURE, PATTERN_TRAIT_CHAR_ARRAY }
+    1,55,0 { SEEK_REWIND }
     1,53,0 { OR_PATTERNS, MANUAL_BITS, BTREE_MAP_RETAIN, BTREE_SET_RETAIN, ARRAY_INTO_ITERATOR }
     1,52,0 { STR_SPLIT_ONCE, REM_EUCLID_CONST }
     1,51,0 { BORROW_AS_PTR, SEEK_FROM_CURRENT, UNSIGNED_ABS }
@@ -45,7 +46,6 @@ msrv_aliases! {
     1,18,0 { HASH_MAP_RETAIN, HASH_SET_RETAIN }
     1,17,0 { FIELD_INIT_SHORTHAND, STATIC_IN_CONST, EXPECT_ERR }
     1,16,0 { STR_REPEAT }
-    1,55,0 { SEEK_REWIND }
 }
 
 fn parse_msrv(msrv: &str, sess: Option<&Session>, span: Option<Span>) -> Option<RustcVersion> {
-- 
cgit 1.4.1-3-g733a5


From e443604a24029e0ffd77f917e82980539fdacbbe Mon Sep 17 00:00:00 2001
From: Robin Schroer <git@sulami.xyz>
Date: Fri, 6 Jan 2023 12:52:51 +0900
Subject: unused_self: Don't trigger if the method body contains todo!()

If the author is using todo!(), presumably they intend to use self at
some point later, so we don't have a good basis to recommend factoring
out to an associated function.

Fixes #10117.

changelog: Don't trigger [`unused_self`] if the method body contains a `todo!()` call
---
 clippy_lints/src/unused_self.rs | 19 ++++++++++++++++++-
 tests/ui/unused_self.rs         | 10 ++++++++++
 2 files changed, 28 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unused_self.rs b/clippy_lints/src/unused_self.rs
index 18231b6a7e8..f864c520302 100644
--- a/clippy_lints/src/unused_self.rs
+++ b/clippy_lints/src/unused_self.rs
@@ -1,9 +1,11 @@
 use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::macros::root_macro_call_first_node;
 use clippy_utils::visitors::is_local_used;
 use if_chain::if_chain;
-use rustc_hir::{Impl, ImplItem, ImplItemKind, ItemKind};
+use rustc_hir::{Body, Impl, ImplItem, ImplItemKind, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
+use std::ops::ControlFlow;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -57,6 +59,20 @@ impl<'tcx> LateLintPass<'tcx> for UnusedSelf {
         let parent = cx.tcx.hir().get_parent_item(impl_item.hir_id()).def_id;
         let parent_item = cx.tcx.hir().expect_item(parent);
         let assoc_item = cx.tcx.associated_item(impl_item.owner_id);
+        let contains_todo = |cx, body: &'_ Body<'_>| -> bool {
+            clippy_utils::visitors::for_each_expr(body.value, |e| {
+                if let Some(macro_call) = root_macro_call_first_node(cx, e) {
+                    if cx.tcx.item_name(macro_call.def_id).as_str() == "todo" {
+                        ControlFlow::Break(())
+                    } else {
+                        ControlFlow::Continue(())
+                    }
+                } else {
+                    ControlFlow::Continue(())
+                }
+            })
+            .is_some()
+        };
         if_chain! {
             if let ItemKind::Impl(Impl { of_trait: None, .. }) = parent_item.kind;
             if assoc_item.fn_has_self_parameter;
@@ -65,6 +81,7 @@ impl<'tcx> LateLintPass<'tcx> for UnusedSelf {
             let body = cx.tcx.hir().body(*body_id);
             if let [self_param, ..] = body.params;
             if !is_local_used(cx, body, self_param.pat.hir_id);
+            if !contains_todo(cx, body);
             then {
                 span_lint_and_help(
                     cx,
diff --git a/tests/ui/unused_self.rs b/tests/ui/unused_self.rs
index 92e8e1dba69..55bd5607185 100644
--- a/tests/ui/unused_self.rs
+++ b/tests/ui/unused_self.rs
@@ -60,6 +60,16 @@ mod unused_self_allow {
         // shouldn't trigger for public methods
         pub fn unused_self_move(self) {}
     }
+
+    pub struct E;
+
+    impl E {
+        // shouldn't trigger if body contains todo!()
+        pub fn unused_self_todo(self) {
+            let x = 42;
+            todo!()
+        }
+    }
 }
 
 pub use unused_self_allow::D;
-- 
cgit 1.4.1-3-g733a5


From 1b9a25e28d76221ee9906b2c3ec833a9837d0349 Mon Sep 17 00:00:00 2001
From: blyxyas <blyxyas@gmail.com>
Date: Fri, 6 Jan 2023 14:41:50 +0100
Subject: [#10167] Clarify that the lint only works if x eq. y in a `for` loop.

Reading the documentation for the lint, one could expect that the lint works in all cases that `X == Y`. This is false.

While the lint was updated, the documentation wasn't.

More information about the `N..N` problem in #5689 and #5628
---
 clippy_lints/src/ranges.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/ranges.rs b/clippy_lints/src/ranges.rs
index 0a1b9d173cf..fc655fe2d0b 100644
--- a/clippy_lints/src/ranges.rs
+++ b/clippy_lints/src/ranges.rs
@@ -103,7 +103,7 @@ declare_clippy_lint! {
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for range expressions `x..y` where both `x` and `y`
-    /// are constant and `x` is greater or equal to `y`.
+    /// are constant and `x` is greater to `y`. Also triggers if `x` is equal to `y` when they are conditions to a `for` loop.
     ///
     /// ### Why is this bad?
     /// Empty ranges yield no values so iterating them is a no-op.
-- 
cgit 1.4.1-3-g733a5


From 4262aebeaaa5789279110b1f039e991ad8996fa2 Mon Sep 17 00:00:00 2001
From: Caio <c410.f3r@gmail.com>
Date: Fri, 6 Jan 2023 12:25:51 -0300
Subject: [arithmetic-side-effects] Consider negative numbers and add more
 tests

---
 .../src/operators/arithmetic_side_effects.rs       |  11 +-
 clippy_utils/src/lib.rs                            |  12 +
 .../arithmetic_side_effects_allowed.rs             |   2 +-
 tests/ui/arithmetic_side_effects.rs                |  67 ++++-
 tests/ui/arithmetic_side_effects.stderr            | 274 ++++++++++++++++-----
 5 files changed, 304 insertions(+), 62 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/operators/arithmetic_side_effects.rs b/clippy_lints/src/operators/arithmetic_side_effects.rs
index 4fbc8398e37..cff82b875f1 100644
--- a/clippy_lints/src/operators/arithmetic_side_effects.rs
+++ b/clippy_lints/src/operators/arithmetic_side_effects.rs
@@ -2,7 +2,7 @@ use super::ARITHMETIC_SIDE_EFFECTS;
 use clippy_utils::{
     consts::{constant, constant_simple},
     diagnostics::span_lint,
-    peel_hir_expr_refs,
+    peel_hir_expr_refs, peel_hir_expr_unary,
 };
 use rustc_ast as ast;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
@@ -98,8 +98,11 @@ impl ArithmeticSideEffects {
     }
 
     /// If `expr` is not a literal integer like `1`, returns `None`.
+    ///
+    /// Returns the absolute value of the expression, if this is an integer literal.
     fn literal_integer(expr: &hir::Expr<'_>) -> Option<u128> {
-        if let hir::ExprKind::Lit(ref lit) = expr.kind && let ast::LitKind::Int(n, _) = lit.node {
+        let actual = peel_hir_expr_unary(expr).0;
+        if let hir::ExprKind::Lit(ref lit) = actual.kind && let ast::LitKind::Int(n, _) = lit.node {
             Some(n)
         }
         else {
@@ -123,12 +126,12 @@ impl ArithmeticSideEffects {
         if !matches!(
             op.node,
             hir::BinOpKind::Add
-                | hir::BinOpKind::Sub
-                | hir::BinOpKind::Mul
                 | hir::BinOpKind::Div
+                | hir::BinOpKind::Mul
                 | hir::BinOpKind::Rem
                 | hir::BinOpKind::Shl
                 | hir::BinOpKind::Shr
+                | hir::BinOpKind::Sub
         ) {
             return;
         };
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index e7000fb5058..1dc68be31d9 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -2258,6 +2258,18 @@ pub fn peel_n_hir_expr_refs<'a>(expr: &'a Expr<'a>, count: usize) -> (&'a Expr<'
     (e, count - remaining)
 }
 
+/// Peels off all unary operators of an expression. Returns the underlying expression and the number
+/// of operators removed.
+pub fn peel_hir_expr_unary<'a>(expr: &'a Expr<'a>) -> (&'a Expr<'a>, usize) {
+    let mut count: usize = 0;
+    let mut curr_expr = expr;
+    while let ExprKind::Unary(_, local_expr) = curr_expr.kind {
+        count = count.wrapping_add(1);
+        curr_expr = local_expr;
+    }
+    (curr_expr, count)
+}
+
 /// Peels off all references on the expression. Returns the underlying expression and the number of
 /// references removed.
 pub fn peel_hir_expr_refs<'a>(expr: &'a Expr<'a>) -> (&'a Expr<'a>, usize) {
diff --git a/tests/ui-toml/arithmetic_side_effects_allowed/arithmetic_side_effects_allowed.rs b/tests/ui-toml/arithmetic_side_effects_allowed/arithmetic_side_effects_allowed.rs
index 36db9e54a22..fb5b1b193f8 100644
--- a/tests/ui-toml/arithmetic_side_effects_allowed/arithmetic_side_effects_allowed.rs
+++ b/tests/ui-toml/arithmetic_side_effects_allowed/arithmetic_side_effects_allowed.rs
@@ -107,7 +107,7 @@ fn rhs_is_different() {
 fn unary() {
     // is explicitly on the list
     let _ = -OutOfNames;
-    // is specifically on the list
+    // is explicitly on the list
     let _ = -Foo;
     // not on the list
     let _ = -Bar;
diff --git a/tests/ui/arithmetic_side_effects.rs b/tests/ui/arithmetic_side_effects.rs
index b5ed8988a51..66c468c9406 100644
--- a/tests/ui/arithmetic_side_effects.rs
+++ b/tests/ui/arithmetic_side_effects.rs
@@ -2,6 +2,7 @@
     clippy::assign_op_pattern,
     clippy::erasing_op,
     clippy::identity_op,
+    clippy::no_effect,
     clippy::op_ref,
     clippy::unnecessary_owned_empty_strings,
     arithmetic_overflow,
@@ -125,6 +126,18 @@ pub fn non_overflowing_ops_or_ops_already_handled_by_the_compiler_should_not_tri
     _n *= &0;
     _n *= 1;
     _n *= &1;
+    _n += -0;
+    _n += &-0;
+    _n -= -0;
+    _n -= &-0;
+    _n /= -99;
+    _n /= &-99;
+    _n %= -99;
+    _n %= &-99;
+    _n *= -0;
+    _n *= &-0;
+    _n *= -1;
+    _n *= &-1;
 
     // Binary
     _n = _n + 0;
@@ -158,7 +171,7 @@ pub fn non_overflowing_ops_or_ops_already_handled_by_the_compiler_should_not_tri
     _n = -&i32::MIN;
 }
 
-pub fn runtime_ops() {
+pub fn unknown_ops_or_runtime_ops_that_can_overflow() {
     let mut _n = i32::MAX;
 
     // Assign
@@ -172,6 +185,16 @@ pub fn runtime_ops() {
     _n %= &0;
     _n *= 2;
     _n *= &2;
+    _n += -1;
+    _n += &-1;
+    _n -= -1;
+    _n -= &-1;
+    _n /= -0;
+    _n /= &-0;
+    _n %= -0;
+    _n %= &-0;
+    _n *= -2;
+    _n *= &-2;
 
     // Binary
     _n = _n + 1;
@@ -225,4 +248,46 @@ pub fn runtime_ops() {
     _n = -&_n;
 }
 
+// Copied and pasted from the `integer_arithmetic` lint for comparison.
+pub fn integer_arithmetic() {
+    let mut i = 1i32;
+    let mut var1 = 0i32;
+    let mut var2 = -1i32;
+
+    1 + i;
+    i * 2;
+    1 % i / 2;
+    i - 2 + 2 - i;
+    -i;
+    i >> 1;
+    i << 1;
+
+    -1;
+    -(-1);
+
+    i & 1;
+    i | 1;
+    i ^ 1;
+
+    i += 1;
+    i -= 1;
+    i *= 2;
+    i /= 2;
+    i /= 0;
+    i /= -1;
+    i /= var1;
+    i /= var2;
+    i %= 2;
+    i %= 0;
+    i %= -1;
+    i %= var1;
+    i %= var2;
+    i <<= 3;
+    i >>= 2;
+
+    i |= 1;
+    i &= 1;
+    i ^= i;
+}
+
 fn main() {}
diff --git a/tests/ui/arithmetic_side_effects.stderr b/tests/ui/arithmetic_side_effects.stderr
index 9fe4b7cf28d..a9bb0ae9280 100644
--- a/tests/ui/arithmetic_side_effects.stderr
+++ b/tests/ui/arithmetic_side_effects.stderr
@@ -1,5 +1,5 @@
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:165:5
+  --> $DIR/arithmetic_side_effects.rs:178:5
    |
 LL |     _n += 1;
    |     ^^^^^^^
@@ -7,328 +7,490 @@ LL |     _n += 1;
    = note: `-D clippy::arithmetic-side-effects` implied by `-D warnings`
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:166:5
+  --> $DIR/arithmetic_side_effects.rs:179:5
    |
 LL |     _n += &1;
    |     ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:167:5
+  --> $DIR/arithmetic_side_effects.rs:180:5
    |
 LL |     _n -= 1;
    |     ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:168:5
+  --> $DIR/arithmetic_side_effects.rs:181:5
    |
 LL |     _n -= &1;
    |     ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:169:5
+  --> $DIR/arithmetic_side_effects.rs:182:5
    |
 LL |     _n /= 0;
    |     ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:170:5
+  --> $DIR/arithmetic_side_effects.rs:183:5
    |
 LL |     _n /= &0;
    |     ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:171:5
+  --> $DIR/arithmetic_side_effects.rs:184:5
    |
 LL |     _n %= 0;
    |     ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:172:5
+  --> $DIR/arithmetic_side_effects.rs:185:5
    |
 LL |     _n %= &0;
    |     ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:173:5
+  --> $DIR/arithmetic_side_effects.rs:186:5
    |
 LL |     _n *= 2;
    |     ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:174:5
+  --> $DIR/arithmetic_side_effects.rs:187:5
    |
 LL |     _n *= &2;
    |     ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:177:10
+  --> $DIR/arithmetic_side_effects.rs:188:5
+   |
+LL |     _n += -1;
+   |     ^^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:189:5
+   |
+LL |     _n += &-1;
+   |     ^^^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:190:5
+   |
+LL |     _n -= -1;
+   |     ^^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:191:5
+   |
+LL |     _n -= &-1;
+   |     ^^^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:192:5
+   |
+LL |     _n /= -0;
+   |     ^^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:193:5
+   |
+LL |     _n /= &-0;
+   |     ^^^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:194:5
+   |
+LL |     _n %= -0;
+   |     ^^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:195:5
+   |
+LL |     _n %= &-0;
+   |     ^^^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:196:5
+   |
+LL |     _n *= -2;
+   |     ^^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:197:5
+   |
+LL |     _n *= &-2;
+   |     ^^^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:200:10
    |
 LL |     _n = _n + 1;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:178:10
+  --> $DIR/arithmetic_side_effects.rs:201:10
    |
 LL |     _n = _n + &1;
    |          ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:179:10
+  --> $DIR/arithmetic_side_effects.rs:202:10
    |
 LL |     _n = 1 + _n;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:180:10
+  --> $DIR/arithmetic_side_effects.rs:203:10
    |
 LL |     _n = &1 + _n;
    |          ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:181:10
+  --> $DIR/arithmetic_side_effects.rs:204:10
    |
 LL |     _n = _n - 1;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:182:10
+  --> $DIR/arithmetic_side_effects.rs:205:10
    |
 LL |     _n = _n - &1;
    |          ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:183:10
+  --> $DIR/arithmetic_side_effects.rs:206:10
    |
 LL |     _n = 1 - _n;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:184:10
+  --> $DIR/arithmetic_side_effects.rs:207:10
    |
 LL |     _n = &1 - _n;
    |          ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:185:10
+  --> $DIR/arithmetic_side_effects.rs:208:10
    |
 LL |     _n = _n / 0;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:186:10
+  --> $DIR/arithmetic_side_effects.rs:209:10
    |
 LL |     _n = _n / &0;
    |          ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:187:10
+  --> $DIR/arithmetic_side_effects.rs:210:10
    |
 LL |     _n = _n % 0;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:188:10
+  --> $DIR/arithmetic_side_effects.rs:211:10
    |
 LL |     _n = _n % &0;
    |          ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:189:10
+  --> $DIR/arithmetic_side_effects.rs:212:10
    |
 LL |     _n = _n * 2;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:190:10
+  --> $DIR/arithmetic_side_effects.rs:213:10
    |
 LL |     _n = _n * &2;
    |          ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:191:10
+  --> $DIR/arithmetic_side_effects.rs:214:10
    |
 LL |     _n = 2 * _n;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:192:10
+  --> $DIR/arithmetic_side_effects.rs:215:10
    |
 LL |     _n = &2 * _n;
    |          ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:193:10
+  --> $DIR/arithmetic_side_effects.rs:216:10
    |
 LL |     _n = 23 + &85;
    |          ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:194:10
+  --> $DIR/arithmetic_side_effects.rs:217:10
    |
 LL |     _n = &23 + 85;
    |          ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:195:10
+  --> $DIR/arithmetic_side_effects.rs:218:10
    |
 LL |     _n = &23 + &85;
    |          ^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:198:13
+  --> $DIR/arithmetic_side_effects.rs:221:13
    |
 LL |     let _ = Custom + 0;
    |             ^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:199:13
+  --> $DIR/arithmetic_side_effects.rs:222:13
    |
 LL |     let _ = Custom + 1;
    |             ^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:200:13
+  --> $DIR/arithmetic_side_effects.rs:223:13
    |
 LL |     let _ = Custom + 2;
    |             ^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:201:13
+  --> $DIR/arithmetic_side_effects.rs:224:13
    |
 LL |     let _ = Custom + 0.0;
    |             ^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:202:13
+  --> $DIR/arithmetic_side_effects.rs:225:13
    |
 LL |     let _ = Custom + 1.0;
    |             ^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:203:13
+  --> $DIR/arithmetic_side_effects.rs:226:13
    |
 LL |     let _ = Custom + 2.0;
    |             ^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:204:13
+  --> $DIR/arithmetic_side_effects.rs:227:13
    |
 LL |     let _ = Custom - 0;
    |             ^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:205:13
+  --> $DIR/arithmetic_side_effects.rs:228:13
    |
 LL |     let _ = Custom - 1;
    |             ^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:206:13
+  --> $DIR/arithmetic_side_effects.rs:229:13
    |
 LL |     let _ = Custom - 2;
    |             ^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:207:13
+  --> $DIR/arithmetic_side_effects.rs:230:13
    |
 LL |     let _ = Custom - 0.0;
    |             ^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:208:13
+  --> $DIR/arithmetic_side_effects.rs:231:13
    |
 LL |     let _ = Custom - 1.0;
    |             ^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:209:13
+  --> $DIR/arithmetic_side_effects.rs:232:13
    |
 LL |     let _ = Custom - 2.0;
    |             ^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:210:13
+  --> $DIR/arithmetic_side_effects.rs:233:13
    |
 LL |     let _ = Custom / 0;
    |             ^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:211:13
+  --> $DIR/arithmetic_side_effects.rs:234:13
    |
 LL |     let _ = Custom / 1;
    |             ^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:212:13
+  --> $DIR/arithmetic_side_effects.rs:235:13
    |
 LL |     let _ = Custom / 2;
    |             ^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:213:13
+  --> $DIR/arithmetic_side_effects.rs:236:13
    |
 LL |     let _ = Custom / 0.0;
    |             ^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:214:13
+  --> $DIR/arithmetic_side_effects.rs:237:13
    |
 LL |     let _ = Custom / 1.0;
    |             ^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:215:13
+  --> $DIR/arithmetic_side_effects.rs:238:13
    |
 LL |     let _ = Custom / 2.0;
    |             ^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:216:13
+  --> $DIR/arithmetic_side_effects.rs:239:13
    |
 LL |     let _ = Custom * 0;
    |             ^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:217:13
+  --> $DIR/arithmetic_side_effects.rs:240:13
    |
 LL |     let _ = Custom * 1;
    |             ^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:218:13
+  --> $DIR/arithmetic_side_effects.rs:241:13
    |
 LL |     let _ = Custom * 2;
    |             ^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:219:13
+  --> $DIR/arithmetic_side_effects.rs:242:13
    |
 LL |     let _ = Custom * 0.0;
    |             ^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:220:13
+  --> $DIR/arithmetic_side_effects.rs:243:13
    |
 LL |     let _ = Custom * 1.0;
    |             ^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:221:13
+  --> $DIR/arithmetic_side_effects.rs:244:13
    |
 LL |     let _ = Custom * 2.0;
    |             ^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:224:10
+  --> $DIR/arithmetic_side_effects.rs:247:10
    |
 LL |     _n = -_n;
    |          ^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:225:10
+  --> $DIR/arithmetic_side_effects.rs:248:10
    |
 LL |     _n = -&_n;
    |          ^^^^
 
-error: aborting due to 55 previous errors
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:257:5
+   |
+LL |     1 + i;
+   |     ^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:258:5
+   |
+LL |     i * 2;
+   |     ^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:260:5
+   |
+LL |     i - 2 + 2 - i;
+   |     ^^^^^^^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:261:5
+   |
+LL |     -i;
+   |     ^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:262:5
+   |
+LL |     i >> 1;
+   |     ^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:263:5
+   |
+LL |     i << 1;
+   |     ^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:272:5
+   |
+LL |     i += 1;
+   |     ^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:273:5
+   |
+LL |     i -= 1;
+   |     ^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:274:5
+   |
+LL |     i *= 2;
+   |     ^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:276:5
+   |
+LL |     i /= 0;
+   |     ^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:278:5
+   |
+LL |     i /= var1;
+   |     ^^^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:279:5
+   |
+LL |     i /= var2;
+   |     ^^^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:281:5
+   |
+LL |     i %= 0;
+   |     ^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:283:5
+   |
+LL |     i %= var1;
+   |     ^^^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:284:5
+   |
+LL |     i %= var2;
+   |     ^^^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:285:5
+   |
+LL |     i <<= 3;
+   |     ^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:286:5
+   |
+LL |     i >>= 2;
+   |     ^^^^^^^
+
+error: aborting due to 82 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From ce56cf71d956ea78c319ff510651473ca8dce47c Mon Sep 17 00:00:00 2001
From: Raiki Tamura <tamaron1203@gmail.com>
Date: Sat, 7 Jan 2023 20:44:02 +0900
Subject: chore

---
 clippy_lints/src/loops/single_element_loop.rs | 14 +-------------
 clippy_utils/src/visitors.rs                  | 11 +++++++++++
 2 files changed, 12 insertions(+), 13 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/single_element_loop.rs b/clippy_lints/src/loops/single_element_loop.rs
index 7cbc456244e..744fd61bd13 100644
--- a/clippy_lints/src/loops/single_element_loop.rs
+++ b/clippy_lints/src/loops/single_element_loop.rs
@@ -1,7 +1,7 @@
 use super::SINGLE_ELEMENT_LOOP;
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::{indent_of, snippet_with_applicability};
-use clippy_utils::visitors::for_each_expr;
+use clippy_utils::visitors::contains_break_or_continue;
 use if_chain::if_chain;
 use rustc_ast::util::parser::PREC_PREFIX;
 use rustc_ast::Mutability;
@@ -9,18 +9,6 @@ use rustc_errors::Applicability;
 use rustc_hir::{is_range_literal, BorrowKind, Expr, ExprKind, Pat};
 use rustc_lint::LateContext;
 use rustc_span::edition::Edition;
-use std::ops::ControlFlow;
-
-fn contains_break_or_continue(expr: &Expr<'_>) -> bool {
-    for_each_expr(expr, |e| {
-        if matches!(e.kind, ExprKind::Break(..) | ExprKind::Continue(..)) {
-            ControlFlow::Break(())
-        } else {
-            ControlFlow::Continue(())
-        }
-    })
-    .is_some()
-}
 
 pub(super) fn check<'tcx>(
     cx: &LateContext<'tcx>,
diff --git a/clippy_utils/src/visitors.rs b/clippy_utils/src/visitors.rs
index 863fb60fcfc..14c01a60b4c 100644
--- a/clippy_utils/src/visitors.rs
+++ b/clippy_utils/src/visitors.rs
@@ -724,3 +724,14 @@ pub fn for_each_local_assignment<'tcx, B>(
         ControlFlow::Continue(())
     }
 }
+
+pub fn contains_break_or_continue(expr: &Expr<'_>) -> bool {
+    for_each_expr(expr, |e| {
+        if matches!(e.kind, ExprKind::Break(..) | ExprKind::Continue(..)) {
+            ControlFlow::Break(())
+        } else {
+            ControlFlow::Continue(())
+        }
+    })
+    .is_some()
+}
-- 
cgit 1.4.1-3-g733a5


From 1a7ef02dcb65ee4aa9e7679ad0ce7e8a42bee6bf Mon Sep 17 00:00:00 2001
From: koka <koka.code@gmail.com>
Date: Mon, 9 Jan 2023 18:49:46 +0900
Subject: Fix fp in unnecessary_safety_comment

---
 clippy_lints/src/undocumented_unsafe_blocks.rs | 12 ++++++++++++
 tests/ui/unnecessary_safety_comment.rs         | 17 +++++++++++++++++
 2 files changed, 29 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/undocumented_unsafe_blocks.rs b/clippy_lints/src/undocumented_unsafe_blocks.rs
index 2e1b6d8d4ea..2920684ade3 100644
--- a/clippy_lints/src/undocumented_unsafe_blocks.rs
+++ b/clippy_lints/src/undocumented_unsafe_blocks.rs
@@ -263,6 +263,18 @@ fn expr_has_unnecessary_safety_comment<'tcx>(
     expr: &'tcx hir::Expr<'tcx>,
     comment_pos: BytePos,
 ) -> Option<Span> {
+    if cx.tcx.hir().parent_iter(expr.hir_id).any(|(_, ref node)| {
+        matches!(
+            node,
+            Node::Block(&Block {
+                rules: BlockCheckMode::UnsafeBlock(UnsafeSource::UserProvided),
+                ..
+            }),
+        )
+    }) {
+        return None;
+    }
+
     // this should roughly be the reverse of `block_parents_have_safety_comment`
     if for_each_expr_with_closures(cx, expr, |expr| match expr.kind {
         hir::ExprKind::Block(
diff --git a/tests/ui/unnecessary_safety_comment.rs b/tests/ui/unnecessary_safety_comment.rs
index 7fefea7051d..89fedb145f8 100644
--- a/tests/ui/unnecessary_safety_comment.rs
+++ b/tests/ui/unnecessary_safety_comment.rs
@@ -48,4 +48,21 @@ fn unnecessary_on_stmt_and_expr() -> u32 {
     24
 }
 
+mod issue_10084 {
+    unsafe fn bar() -> i32 {
+        42
+    }
+
+    macro_rules! foo {
+        () => {
+            // SAFETY: This is necessary
+            unsafe { bar() }
+        };
+    }
+
+    fn main() {
+        foo!();
+    }
+}
+
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 53c12e085ab9595dff369f26046038afa20e8e5c Mon Sep 17 00:00:00 2001
From: Robert Bastian <robertbastian@google.com>
Date: Mon, 9 Jan 2023 21:29:42 +0100
Subject: hash xor peq

---
 clippy_lints/src/derive.rs         | 10 ++--------
 tests/ui/derive_hash_xor_eq.rs     | 19 -------------------
 tests/ui/derive_hash_xor_eq.stderr | 32 +-------------------------------
 3 files changed, 3 insertions(+), 58 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/derive.rs b/clippy_lints/src/derive.rs
index cf3483d4c00..e39a31a8c72 100644
--- a/clippy_lints/src/derive.rs
+++ b/clippy_lints/src/derive.rs
@@ -243,7 +243,7 @@ fn check_hash_peq<'tcx>(
             cx.tcx.for_each_relevant_impl(peq_trait_def_id, ty, |impl_id| {
                 let peq_is_automatically_derived = cx.tcx.has_attr(impl_id, sym::automatically_derived);
 
-                if peq_is_automatically_derived == hash_is_automatically_derived {
+                if !hash_is_automatically_derived || peq_is_automatically_derived {
                     return;
                 }
 
@@ -252,17 +252,11 @@ fn check_hash_peq<'tcx>(
                 // Only care about `impl PartialEq<Foo> for Foo`
                 // For `impl PartialEq<B> for A, input_types is [A, B]
                 if trait_ref.substs.type_at(1) == ty {
-                    let mess = if peq_is_automatically_derived {
-                        "you are implementing `Hash` explicitly but have derived `PartialEq`"
-                    } else {
-                        "you are deriving `Hash` but have implemented `PartialEq` explicitly"
-                    };
-
                     span_lint_and_then(
                         cx,
                         DERIVE_HASH_XOR_EQ,
                         span,
-                        mess,
+                        "you are deriving `Hash` but have implemented `PartialEq` explicitly",
                         |diag| {
                             if let Some(local_def_id) = impl_id.as_local() {
                                 let hir_id = cx.tcx.hir().local_def_id_to_hir_id(local_def_id);
diff --git a/tests/ui/derive_hash_xor_eq.rs b/tests/ui/derive_hash_xor_eq.rs
index 813ddc56646..0804e3cffa1 100644
--- a/tests/ui/derive_hash_xor_eq.rs
+++ b/tests/ui/derive_hash_xor_eq.rs
@@ -34,23 +34,4 @@ impl std::hash::Hash for Bah {
     fn hash<H: std::hash::Hasher>(&self, _: &mut H) {}
 }
 
-#[derive(PartialEq)]
-struct Foo2;
-
-trait Hash {}
-
-// We don't want to lint on user-defined traits called `Hash`
-impl Hash for Foo2 {}
-
-mod use_hash {
-    use std::hash::{Hash, Hasher};
-
-    #[derive(PartialEq)]
-    struct Foo3;
-
-    impl Hash for Foo3 {
-        fn hash<H: std::hash::Hasher>(&self, _: &mut H) {}
-    }
-}
-
 fn main() {}
diff --git a/tests/ui/derive_hash_xor_eq.stderr b/tests/ui/derive_hash_xor_eq.stderr
index 16c92397804..16965aa42d8 100644
--- a/tests/ui/derive_hash_xor_eq.stderr
+++ b/tests/ui/derive_hash_xor_eq.stderr
@@ -25,35 +25,5 @@ LL | impl PartialEq<Baz> for Baz {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
    = note: this error originates in the derive macro `Hash` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: you are implementing `Hash` explicitly but have derived `PartialEq`
-  --> $DIR/derive_hash_xor_eq.rs:33:1
-   |
-LL | / impl std::hash::Hash for Bah {
-LL | |     fn hash<H: std::hash::Hasher>(&self, _: &mut H) {}
-LL | | }
-   | |_^
-   |
-note: `PartialEq` implemented here
-  --> $DIR/derive_hash_xor_eq.rs:30:10
-   |
-LL | #[derive(PartialEq)]
-   |          ^^^^^^^^^
-   = note: this error originates in the derive macro `PartialEq` (in Nightly builds, run with -Z macro-backtrace for more info)
-
-error: you are implementing `Hash` explicitly but have derived `PartialEq`
-  --> $DIR/derive_hash_xor_eq.rs:51:5
-   |
-LL | /     impl Hash for Foo3 {
-LL | |         fn hash<H: std::hash::Hasher>(&self, _: &mut H) {}
-LL | |     }
-   | |_____^
-   |
-note: `PartialEq` implemented here
-  --> $DIR/derive_hash_xor_eq.rs:48:14
-   |
-LL |     #[derive(PartialEq)]
-   |              ^^^^^^^^^
-   = note: this error originates in the derive macro `PartialEq` (in Nightly builds, run with -Z macro-backtrace for more info)
-
-error: aborting due to 4 previous errors
+error: aborting due to 2 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 8ca900b01ce5ff90511fd9d02c29e50a89fcccf0 Mon Sep 17 00:00:00 2001
From: Robert Bastian <robertbastian@google.com>
Date: Tue, 10 Jan 2023 11:12:54 +0100
Subject: rename

---
 CHANGELOG.md                                |  1 +
 clippy_lints/src/declared_lints.rs          |  2 +-
 clippy_lints/src/derive.rs                  |  8 +++----
 clippy_lints/src/renamed_lints.rs           |  1 +
 tests/ui/derive_hash_xor_eq.rs              | 37 -----------------------------
 tests/ui/derive_hash_xor_eq.stderr          | 29 ----------------------
 tests/ui/derived_hash_with_manual_eq.rs     | 37 +++++++++++++++++++++++++++++
 tests/ui/derived_hash_with_manual_eq.stderr | 29 ++++++++++++++++++++++
 tests/ui/rename.rs                          |  2 ++
 9 files changed, 75 insertions(+), 71 deletions(-)
 delete mode 100644 tests/ui/derive_hash_xor_eq.rs
 delete mode 100644 tests/ui/derive_hash_xor_eq.stderr
 create mode 100644 tests/ui/derived_hash_with_manual_eq.rs
 create mode 100644 tests/ui/derived_hash_with_manual_eq.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 02f3188f8be..8e31e8f0d98 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4137,6 +4137,7 @@ Released 2018-09-13
 [`derive_hash_xor_eq`]: https://rust-lang.github.io/rust-clippy/master/index.html#derive_hash_xor_eq
 [`derive_ord_xor_partial_ord`]: https://rust-lang.github.io/rust-clippy/master/index.html#derive_ord_xor_partial_ord
 [`derive_partial_eq_without_eq`]: https://rust-lang.github.io/rust-clippy/master/index.html#derive_partial_eq_without_eq
+[`derived_hash_with_manual_eq`]: https://rust-lang.github.io/rust-clippy/master/index.html#derived_hash_with_manual_eq
 [`disallowed_macros`]: https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_macros
 [`disallowed_method`]: https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_method
 [`disallowed_methods`]: https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_methods
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 2982460c9cf..91ca73633f0 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -111,7 +111,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::dereference::NEEDLESS_BORROW_INFO,
     crate::dereference::REF_BINDING_TO_REFERENCE_INFO,
     crate::derivable_impls::DERIVABLE_IMPLS_INFO,
-    crate::derive::DERIVE_HASH_XOR_EQ_INFO,
+    crate::derive::DERIVED_HASH_WITH_MANUAL_EQ_INFO,
     crate::derive::DERIVE_ORD_XOR_PARTIAL_ORD_INFO,
     crate::derive::DERIVE_PARTIAL_EQ_WITHOUT_EQ_INFO,
     crate::derive::EXPL_IMPL_CLONE_ON_COPY_INFO,
diff --git a/clippy_lints/src/derive.rs b/clippy_lints/src/derive.rs
index e39a31a8c72..983a517bc12 100644
--- a/clippy_lints/src/derive.rs
+++ b/clippy_lints/src/derive.rs
@@ -46,7 +46,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     #[clippy::version = "pre 1.29.0"]
-    pub DERIVE_HASH_XOR_EQ,
+    pub DERIVED_HASH_WITH_MANUAL_EQ,
     correctness,
     "deriving `Hash` but implementing `PartialEq` explicitly"
 }
@@ -197,7 +197,7 @@ declare_clippy_lint! {
 
 declare_lint_pass!(Derive => [
     EXPL_IMPL_CLONE_ON_COPY,
-    DERIVE_HASH_XOR_EQ,
+    DERIVED_HASH_WITH_MANUAL_EQ,
     DERIVE_ORD_XOR_PARTIAL_ORD,
     UNSAFE_DERIVE_DESERIALIZE,
     DERIVE_PARTIAL_EQ_WITHOUT_EQ
@@ -226,7 +226,7 @@ impl<'tcx> LateLintPass<'tcx> for Derive {
     }
 }
 
-/// Implementation of the `DERIVE_HASH_XOR_EQ` lint.
+/// Implementation of the `DERIVED_HASH_WITH_MANUAL_EQ` lint.
 fn check_hash_peq<'tcx>(
     cx: &LateContext<'tcx>,
     span: Span,
@@ -254,7 +254,7 @@ fn check_hash_peq<'tcx>(
                 if trait_ref.substs.type_at(1) == ty {
                     span_lint_and_then(
                         cx,
-                        DERIVE_HASH_XOR_EQ,
+                        DERIVED_HASH_WITH_MANUAL_EQ,
                         span,
                         "you are deriving `Hash` but have implemented `PartialEq` explicitly",
                         |diag| {
diff --git a/clippy_lints/src/renamed_lints.rs b/clippy_lints/src/renamed_lints.rs
index 72c25592609..9f487dedb8c 100644
--- a/clippy_lints/src/renamed_lints.rs
+++ b/clippy_lints/src/renamed_lints.rs
@@ -9,6 +9,7 @@ pub static RENAMED_LINTS: &[(&str, &str)] = &[
     ("clippy::box_vec", "clippy::box_collection"),
     ("clippy::const_static_lifetime", "clippy::redundant_static_lifetimes"),
     ("clippy::cyclomatic_complexity", "clippy::cognitive_complexity"),
+    ("clippy::derive_hash_xor_eq", "clippy::derived_hash_with_manual_eq"),
     ("clippy::disallowed_method", "clippy::disallowed_methods"),
     ("clippy::disallowed_type", "clippy::disallowed_types"),
     ("clippy::eval_order_dependence", "clippy::mixed_read_write_in_expression"),
diff --git a/tests/ui/derive_hash_xor_eq.rs b/tests/ui/derive_hash_xor_eq.rs
deleted file mode 100644
index 0804e3cffa1..00000000000
--- a/tests/ui/derive_hash_xor_eq.rs
+++ /dev/null
@@ -1,37 +0,0 @@
-#![allow(clippy::derive_partial_eq_without_eq)]
-
-#[derive(PartialEq, Hash)]
-struct Foo;
-
-impl PartialEq<u64> for Foo {
-    fn eq(&self, _: &u64) -> bool {
-        true
-    }
-}
-
-#[derive(Hash)]
-struct Bar;
-
-impl PartialEq for Bar {
-    fn eq(&self, _: &Bar) -> bool {
-        true
-    }
-}
-
-#[derive(Hash)]
-struct Baz;
-
-impl PartialEq<Baz> for Baz {
-    fn eq(&self, _: &Baz) -> bool {
-        true
-    }
-}
-
-#[derive(PartialEq)]
-struct Bah;
-
-impl std::hash::Hash for Bah {
-    fn hash<H: std::hash::Hasher>(&self, _: &mut H) {}
-}
-
-fn main() {}
diff --git a/tests/ui/derive_hash_xor_eq.stderr b/tests/ui/derive_hash_xor_eq.stderr
deleted file mode 100644
index 16965aa42d8..00000000000
--- a/tests/ui/derive_hash_xor_eq.stderr
+++ /dev/null
@@ -1,29 +0,0 @@
-error: you are deriving `Hash` but have implemented `PartialEq` explicitly
-  --> $DIR/derive_hash_xor_eq.rs:12:10
-   |
-LL | #[derive(Hash)]
-   |          ^^^^
-   |
-note: `PartialEq` implemented here
-  --> $DIR/derive_hash_xor_eq.rs:15:1
-   |
-LL | impl PartialEq for Bar {
-   | ^^^^^^^^^^^^^^^^^^^^^^
-   = note: `#[deny(clippy::derive_hash_xor_eq)]` on by default
-   = note: this error originates in the derive macro `Hash` (in Nightly builds, run with -Z macro-backtrace for more info)
-
-error: you are deriving `Hash` but have implemented `PartialEq` explicitly
-  --> $DIR/derive_hash_xor_eq.rs:21:10
-   |
-LL | #[derive(Hash)]
-   |          ^^^^
-   |
-note: `PartialEq` implemented here
-  --> $DIR/derive_hash_xor_eq.rs:24:1
-   |
-LL | impl PartialEq<Baz> for Baz {
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   = note: this error originates in the derive macro `Hash` (in Nightly builds, run with -Z macro-backtrace for more info)
-
-error: aborting due to 2 previous errors
-
diff --git a/tests/ui/derived_hash_with_manual_eq.rs b/tests/ui/derived_hash_with_manual_eq.rs
new file mode 100644
index 00000000000..0804e3cffa1
--- /dev/null
+++ b/tests/ui/derived_hash_with_manual_eq.rs
@@ -0,0 +1,37 @@
+#![allow(clippy::derive_partial_eq_without_eq)]
+
+#[derive(PartialEq, Hash)]
+struct Foo;
+
+impl PartialEq<u64> for Foo {
+    fn eq(&self, _: &u64) -> bool {
+        true
+    }
+}
+
+#[derive(Hash)]
+struct Bar;
+
+impl PartialEq for Bar {
+    fn eq(&self, _: &Bar) -> bool {
+        true
+    }
+}
+
+#[derive(Hash)]
+struct Baz;
+
+impl PartialEq<Baz> for Baz {
+    fn eq(&self, _: &Baz) -> bool {
+        true
+    }
+}
+
+#[derive(PartialEq)]
+struct Bah;
+
+impl std::hash::Hash for Bah {
+    fn hash<H: std::hash::Hasher>(&self, _: &mut H) {}
+}
+
+fn main() {}
diff --git a/tests/ui/derived_hash_with_manual_eq.stderr b/tests/ui/derived_hash_with_manual_eq.stderr
new file mode 100644
index 00000000000..16965aa42d8
--- /dev/null
+++ b/tests/ui/derived_hash_with_manual_eq.stderr
@@ -0,0 +1,29 @@
+error: you are deriving `Hash` but have implemented `PartialEq` explicitly
+  --> $DIR/derive_hash_xor_eq.rs:12:10
+   |
+LL | #[derive(Hash)]
+   |          ^^^^
+   |
+note: `PartialEq` implemented here
+  --> $DIR/derive_hash_xor_eq.rs:15:1
+   |
+LL | impl PartialEq for Bar {
+   | ^^^^^^^^^^^^^^^^^^^^^^
+   = note: `#[deny(clippy::derive_hash_xor_eq)]` on by default
+   = note: this error originates in the derive macro `Hash` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: you are deriving `Hash` but have implemented `PartialEq` explicitly
+  --> $DIR/derive_hash_xor_eq.rs:21:10
+   |
+LL | #[derive(Hash)]
+   |          ^^^^
+   |
+note: `PartialEq` implemented here
+  --> $DIR/derive_hash_xor_eq.rs:24:1
+   |
+LL | impl PartialEq<Baz> for Baz {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   = note: this error originates in the derive macro `Hash` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: aborting due to 2 previous errors
+
diff --git a/tests/ui/rename.rs b/tests/ui/rename.rs
index 699c0ff464e..64bc1ca7116 100644
--- a/tests/ui/rename.rs
+++ b/tests/ui/rename.rs
@@ -10,6 +10,7 @@
 #![allow(clippy::box_collection)]
 #![allow(clippy::redundant_static_lifetimes)]
 #![allow(clippy::cognitive_complexity)]
+#![allow(clippy::derived_hash_with_manual_eq)]
 #![allow(clippy::disallowed_methods)]
 #![allow(clippy::disallowed_types)]
 #![allow(clippy::mixed_read_write_in_expression)]
@@ -45,6 +46,7 @@
 #![warn(clippy::box_vec)]
 #![warn(clippy::const_static_lifetime)]
 #![warn(clippy::cyclomatic_complexity)]
+#![warn(clippy::derive_hash_xor_eq)]
 #![warn(clippy::disallowed_method)]
 #![warn(clippy::disallowed_type)]
 #![warn(clippy::eval_order_dependence)]
-- 
cgit 1.4.1-3-g733a5


From d73adea465726944815eb62d373abf6e87dc3b12 Mon Sep 17 00:00:00 2001
From: dswij <dswijj@gmail.com>
Date: Wed, 11 Jan 2023 06:52:22 +0800
Subject: `needless_return`: remove multiple semis on suggestion

---
 clippy_lints/src/returns.rs | 26 ++++++++++++++------------
 clippy_utils/src/lib.rs     |  4 ++++
 2 files changed, 18 insertions(+), 12 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
index bbbd9e4989e..42c51d7d071 100644
--- a/clippy_lints/src/returns.rs
+++ b/clippy_lints/src/returns.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::{span_lint_and_then, span_lint_hir_and_then};
 use clippy_utils::source::{snippet_opt, snippet_with_context};
 use clippy_utils::visitors::{for_each_expr, Descend};
-use clippy_utils::{fn_def_id, path_to_local_id};
+use clippy_utils::{fn_def_id, path_to_local_id, span_find_starting_semi};
 use core::ops::ControlFlow;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
@@ -151,7 +151,7 @@ impl<'tcx> LateLintPass<'tcx> for Return {
         kind: FnKind<'tcx>,
         _: &'tcx FnDecl<'tcx>,
         body: &'tcx Body<'tcx>,
-        _: Span,
+        sp: Span,
         _: HirId,
     ) {
         match kind {
@@ -166,14 +166,14 @@ impl<'tcx> LateLintPass<'tcx> for Return {
                 check_final_expr(cx, body.value, vec![], replacement);
             },
             FnKind::ItemFn(..) | FnKind::Method(..) => {
-                check_block_return(cx, &body.value.kind, vec![]);
+                check_block_return(cx, &body.value.kind, sp, vec![]);
             },
         }
     }
 }
 
 // if `expr` is a block, check if there are needless returns in it
-fn check_block_return<'tcx>(cx: &LateContext<'tcx>, expr_kind: &ExprKind<'tcx>, semi_spans: Vec<Span>) {
+fn check_block_return<'tcx>(cx: &LateContext<'tcx>, expr_kind: &ExprKind<'tcx>, sp: Span, mut semi_spans: Vec<Span>) {
     if let ExprKind::Block(block, _) = expr_kind {
         if let Some(block_expr) = block.expr {
             check_final_expr(cx, block_expr, semi_spans, RetReplacement::Empty);
@@ -183,12 +183,14 @@ fn check_block_return<'tcx>(cx: &LateContext<'tcx>, expr_kind: &ExprKind<'tcx>,
                     check_final_expr(cx, expr, semi_spans, RetReplacement::Empty);
                 },
                 StmtKind::Semi(semi_expr) => {
-                    let mut semi_spans_and_this_one = semi_spans;
-                    // we only want the span containing the semicolon so we can remove it later. From `entry.rs:382`
-                    if let Some(semicolon_span) = stmt.span.trim_start(semi_expr.span) {
-                        semi_spans_and_this_one.push(semicolon_span);
-                        check_final_expr(cx, semi_expr, semi_spans_and_this_one, RetReplacement::Empty);
+                    // Remove ending semicolons and any whitespace ' ' in between.
+                    // Without `return`, the suggestion might not compile if the semicolon is retained
+                    if let Some(semi_span) = stmt.span.trim_start(semi_expr.span) {
+                        let semi_span_to_remove =
+                            span_find_starting_semi(cx.sess().source_map(), semi_span.with_hi(sp.hi()));
+                        semi_spans.push(semi_span_to_remove);
                     }
+                    check_final_expr(cx, semi_expr, semi_spans, RetReplacement::Empty);
                 },
                 _ => (),
             }
@@ -231,9 +233,9 @@ fn check_final_expr<'tcx>(
             emit_return_lint(cx, ret_span, semi_spans, inner.as_ref().map(|i| i.span), replacement);
         },
         ExprKind::If(_, then, else_clause_opt) => {
-            check_block_return(cx, &then.kind, semi_spans.clone());
+            check_block_return(cx, &then.kind, peeled_drop_expr.span, semi_spans.clone());
             if let Some(else_clause) = else_clause_opt {
-                check_block_return(cx, &else_clause.kind, semi_spans);
+                check_block_return(cx, &else_clause.kind, peeled_drop_expr.span, semi_spans);
             }
         },
         // a match expr, check all arms
@@ -246,7 +248,7 @@ fn check_final_expr<'tcx>(
             }
         },
         // if it's a whole block, check it
-        other_expr_kind => check_block_return(cx, other_expr_kind, semi_spans),
+        other_expr_kind => check_block_return(cx, other_expr_kind, peeled_drop_expr.span, semi_spans),
     }
 }
 
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 1dc68be31d9..76f406abf1c 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -2488,6 +2488,10 @@ pub fn span_extract_comment(sm: &SourceMap, span: Span) -> String {
     comments_buf.join("\n")
 }
 
+pub fn span_find_starting_semi(sm: &SourceMap, span: Span) -> Span {
+    sm.span_take_while(span, |&ch| ch == ' ' || ch == ';')
+}
+
 macro_rules! op_utils {
     ($($name:ident $assign:ident)*) => {
         /// Binary operation traits like `LangItem::Add`
-- 
cgit 1.4.1-3-g733a5


From bd76d9133b62447035741e0f693de9c98893902a Mon Sep 17 00:00:00 2001
From: Andre Bogus <bogusandre@gmail.com>
Date: Sun, 8 Jan 2023 16:19:11 +0100
Subject: trim paths in `suspicious_to_owned`

---
 clippy_lints/src/methods/suspicious_to_owned.rs | 6 ++++--
 tests/ui/suspicious_to_owned.stderr             | 8 ++++----
 2 files changed, 8 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/suspicious_to_owned.rs b/clippy_lints/src/methods/suspicious_to_owned.rs
index 15c1c618c51..fe88fa41fd9 100644
--- a/clippy_lints/src/methods/suspicious_to_owned.rs
+++ b/clippy_lints/src/methods/suspicious_to_owned.rs
@@ -5,7 +5,7 @@ use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
-use rustc_middle::ty;
+use rustc_middle::ty::{self, print::with_forced_trimmed_paths};
 use rustc_span::sym;
 
 use super::SUSPICIOUS_TO_OWNED;
@@ -24,7 +24,9 @@ pub fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr<'_>) -
                 cx,
                 SUSPICIOUS_TO_OWNED,
                 expr.span,
-                &format!("this `to_owned` call clones the {input_type} itself and does not cause the {input_type} contents to become owned"),
+                &with_forced_trimmed_paths!(format!(
+                    "this `to_owned` call clones the {input_type} itself and does not cause the {input_type} contents to become owned"
+                )),
                 "consider using, depending on intent",
                 format!("{recv_snip}.clone()` or `{recv_snip}.into_owned()"),
                 app,
diff --git a/tests/ui/suspicious_to_owned.stderr b/tests/ui/suspicious_to_owned.stderr
index ae1aec34d82..dec3f50d6f1 100644
--- a/tests/ui/suspicious_to_owned.stderr
+++ b/tests/ui/suspicious_to_owned.stderr
@@ -1,4 +1,4 @@
-error: this `to_owned` call clones the std::borrow::Cow<'_, str> itself and does not cause the std::borrow::Cow<'_, str> contents to become owned
+error: this `to_owned` call clones the Cow<'_, str> itself and does not cause the Cow<'_, str> contents to become owned
   --> $DIR/suspicious_to_owned.rs:16:13
    |
 LL |     let _ = cow.to_owned();
@@ -6,19 +6,19 @@ LL |     let _ = cow.to_owned();
    |
    = note: `-D clippy::suspicious-to-owned` implied by `-D warnings`
 
-error: this `to_owned` call clones the std::borrow::Cow<'_, [char; 3]> itself and does not cause the std::borrow::Cow<'_, [char; 3]> contents to become owned
+error: this `to_owned` call clones the Cow<'_, [char; 3]> itself and does not cause the Cow<'_, [char; 3]> contents to become owned
   --> $DIR/suspicious_to_owned.rs:26:13
    |
 LL |     let _ = cow.to_owned();
    |             ^^^^^^^^^^^^^^ help: consider using, depending on intent: `cow.clone()` or `cow.into_owned()`
 
-error: this `to_owned` call clones the std::borrow::Cow<'_, std::vec::Vec<char>> itself and does not cause the std::borrow::Cow<'_, std::vec::Vec<char>> contents to become owned
+error: this `to_owned` call clones the Cow<'_, Vec<char>> itself and does not cause the Cow<'_, Vec<char>> contents to become owned
   --> $DIR/suspicious_to_owned.rs:36:13
    |
 LL |     let _ = cow.to_owned();
    |             ^^^^^^^^^^^^^^ help: consider using, depending on intent: `cow.clone()` or `cow.into_owned()`
 
-error: this `to_owned` call clones the std::borrow::Cow<'_, str> itself and does not cause the std::borrow::Cow<'_, str> contents to become owned
+error: this `to_owned` call clones the Cow<'_, str> itself and does not cause the Cow<'_, str> contents to become owned
   --> $DIR/suspicious_to_owned.rs:46:13
    |
 LL |     let _ = cow.to_owned();
-- 
cgit 1.4.1-3-g733a5


From 34024adc88df9d95e2b002250d41a00c5a937234 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Wed, 11 Jan 2023 17:25:47 +0000
Subject: expl_impl_clone_on_copy: ignore packed structs with type/const params

---
 clippy_lints/src/derive.rs | 13 +++++++++++--
 tests/ui/derive.rs         | 11 +++++++++++
 2 files changed, 22 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/derive.rs b/clippy_lints/src/derive.rs
index cf3483d4c00..df32fbd4b33 100644
--- a/clippy_lints/src/derive.rs
+++ b/clippy_lints/src/derive.rs
@@ -14,8 +14,8 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::nested_filter;
 use rustc_middle::traits::Reveal;
 use rustc_middle::ty::{
-    self, Binder, BoundConstness, Clause, GenericParamDefKind, ImplPolarity, ParamEnv, PredicateKind, TraitPredicate,
-    Ty, TyCtxt,
+    self, Binder, BoundConstness, Clause, GenericArgKind, GenericParamDefKind, ImplPolarity, ParamEnv, PredicateKind,
+    TraitPredicate, Ty, TyCtxt,
 };
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
@@ -366,6 +366,15 @@ fn check_copy_clone<'tcx>(cx: &LateContext<'tcx>, item: &Item<'_>, trait_ref: &h
     if ty_subs.types().any(|ty| !implements_trait(cx, ty, clone_id, &[])) {
         return;
     }
+    // `#[repr(packed)]` structs with type/const parameters can't derive `Clone`.
+    // https://github.com/rust-lang/rust-clippy/issues/10188
+    if ty_adt.repr().packed()
+        && ty_subs
+            .iter()
+            .any(|arg| matches!(arg.unpack(), GenericArgKind::Type(_) | GenericArgKind::Const(_)))
+    {
+        return;
+    }
 
     span_lint_and_note(
         cx,
diff --git a/tests/ui/derive.rs b/tests/ui/derive.rs
index c629c0e5353..843e1df8bc6 100644
--- a/tests/ui/derive.rs
+++ b/tests/ui/derive.rs
@@ -85,4 +85,15 @@ impl<T: Clone, U> Clone for GenericRef<'_, T, U> {
     }
 }
 
+// https://github.com/rust-lang/rust-clippy/issues/10188
+#[repr(packed)]
+#[derive(Copy)]
+struct Packed<T>(T);
+
+impl<T: Copy> Clone for Packed<T> {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 51aaba6e8cf50289d55f53ac85aab4c95d601439 Mon Sep 17 00:00:00 2001
From: navh <navarre.hebb@gmail.com>
Date: Tue, 6 Dec 2022 19:05:22 +0100
Subject: `cast_possible_truncation` Suggest TryFrom when truncation possible

---
 clippy_lints/src/casts/cast_possible_truncation.rs | 24 +++++-
 clippy_lints/src/casts/mod.rs                      |  2 +-
 tests/ui/cast.stderr                               | 95 ++++++++++++++++++++++
 tests/ui/cast_size.stderr                          | 53 ++++++++++++
 4 files changed, 170 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/cast_possible_truncation.rs b/clippy_lints/src/casts/cast_possible_truncation.rs
index a6376484914..d9898aeb92c 100644
--- a/clippy_lints/src/casts/cast_possible_truncation.rs
+++ b/clippy_lints/src/casts/cast_possible_truncation.rs
@@ -1,7 +1,11 @@
 use clippy_utils::consts::{constant, Constant};
-use clippy_utils::diagnostics::span_lint;
+use clippy_utils::diagnostics::{span_lint, span_lint_and_then};
 use clippy_utils::expr_or_init;
+use clippy_utils::source::snippet;
 use clippy_utils::ty::{get_discriminant_value, is_isize_or_usize};
+use rustc_ast::ast;
+use rustc_attr::IntType;
+use rustc_errors::{Applicability, SuggestionStyle};
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::LateContext;
@@ -139,7 +143,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_expr: &Expr<'_>,
                 );
                 return;
             }
-            format!("casting `{cast_from}` to `{cast_to}` may truncate the value{suffix}",)
+            format!("casting `{cast_from}` to `{cast_to}` may truncate the value{suffix}")
         },
 
         (ty::Float(_), true) => {
@@ -153,5 +157,19 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_expr: &Expr<'_>,
         _ => return,
     };
 
-    span_lint(cx, CAST_POSSIBLE_TRUNCATION, expr.span, &msg);
+    let snippet = snippet(cx, expr.span, "x");
+    let name_of_cast_from = snippet.split(" as").next().unwrap_or("x");
+    let suggestion = format!("{cast_to}::try_from({name_of_cast_from})");
+
+    span_lint_and_then(cx, CAST_POSSIBLE_TRUNCATION, expr.span, &msg, |diag| {
+        diag.help("if this is intentional allow the lint with `#[allow(clippy::cast_precision_loss)]` ...");
+        diag.span_suggestion_with_style(
+            expr.span,
+            "... or use `try_from` and handle the error accordingly",
+            suggestion,
+            Applicability::Unspecified,
+            // always show the suggestion in a separate line
+            SuggestionStyle::ShowAlways,
+        );
+    });
 }
diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index 161e3a698e9..38b1c5c1c7e 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -85,7 +85,7 @@ declare_clippy_lint! {
     /// ### Why is this bad?
     /// In some problem domains, it is good practice to avoid
     /// truncation. This lint can be activated to help assess where additional
-    /// checks could be beneficial.
+    /// checks could be beneficial, and suggests implementing TryFrom trait.
     ///
     /// ### Example
     /// ```rust
diff --git a/tests/ui/cast.stderr b/tests/ui/cast.stderr
index 0c63b4af308..eceb135d62b 100644
--- a/tests/ui/cast.stderr
+++ b/tests/ui/cast.stderr
@@ -42,13 +42,24 @@ error: casting `f32` to `i32` may truncate the value
 LL |     1f32 as i32;
    |     ^^^^^^^^^^^
    |
+   = help: if this is intentional allow the lint with `#[allow(clippy::cast_precision_loss)]` ...
    = note: `-D clippy::cast-possible-truncation` implied by `-D warnings`
+help: ... or use `try_from` and handle the error accordingly
+   |
+LL |     i32::try_from(1f32);
+   |     ~~~~~~~~~~~~~~~~~~~
 
 error: casting `f32` to `u32` may truncate the value
   --> $DIR/cast.rs:25:5
    |
 LL |     1f32 as u32;
    |     ^^^^^^^^^^^
+   |
+   = help: if this is intentional allow the lint with `#[allow(clippy::cast_precision_loss)]` ...
+help: ... or use `try_from` and handle the error accordingly
+   |
+LL |     u32::try_from(1f32);
+   |     ~~~~~~~~~~~~~~~~~~~
 
 error: casting `f32` to `u32` may lose the sign of the value
   --> $DIR/cast.rs:25:5
@@ -63,30 +74,60 @@ error: casting `f64` to `f32` may truncate the value
    |
 LL |     1f64 as f32;
    |     ^^^^^^^^^^^
+   |
+   = help: if this is intentional allow the lint with `#[allow(clippy::cast_precision_loss)]` ...
+help: ... or use `try_from` and handle the error accordingly
+   |
+LL |     f32::try_from(1f64);
+   |     ~~~~~~~~~~~~~~~~~~~
 
 error: casting `i32` to `i8` may truncate the value
   --> $DIR/cast.rs:27:5
    |
 LL |     1i32 as i8;
    |     ^^^^^^^^^^
+   |
+   = help: if this is intentional allow the lint with `#[allow(clippy::cast_precision_loss)]` ...
+help: ... or use `try_from` and handle the error accordingly
+   |
+LL |     i8::try_from(1i32);
+   |     ~~~~~~~~~~~~~~~~~~
 
 error: casting `i32` to `u8` may truncate the value
   --> $DIR/cast.rs:28:5
    |
 LL |     1i32 as u8;
    |     ^^^^^^^^^^
+   |
+   = help: if this is intentional allow the lint with `#[allow(clippy::cast_precision_loss)]` ...
+help: ... or use `try_from` and handle the error accordingly
+   |
+LL |     u8::try_from(1i32);
+   |     ~~~~~~~~~~~~~~~~~~
 
 error: casting `f64` to `isize` may truncate the value
   --> $DIR/cast.rs:29:5
    |
 LL |     1f64 as isize;
    |     ^^^^^^^^^^^^^
+   |
+   = help: if this is intentional allow the lint with `#[allow(clippy::cast_precision_loss)]` ...
+help: ... or use `try_from` and handle the error accordingly
+   |
+LL |     isize::try_from(1f64);
+   |     ~~~~~~~~~~~~~~~~~~~~~
 
 error: casting `f64` to `usize` may truncate the value
   --> $DIR/cast.rs:30:5
    |
 LL |     1f64 as usize;
    |     ^^^^^^^^^^^^^
+   |
+   = help: if this is intentional allow the lint with `#[allow(clippy::cast_precision_loss)]` ...
+help: ... or use `try_from` and handle the error accordingly
+   |
+LL |     usize::try_from(1f64);
+   |     ~~~~~~~~~~~~~~~~~~~~~
 
 error: casting `f64` to `usize` may lose the sign of the value
   --> $DIR/cast.rs:30:5
@@ -143,18 +184,36 @@ error: casting `i64` to `i8` may truncate the value
    |
 LL |     (-99999999999i64).min(1) as i8; // should be linted because signed
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: if this is intentional allow the lint with `#[allow(clippy::cast_precision_loss)]` ...
+help: ... or use `try_from` and handle the error accordingly
+   |
+LL |     i8::try_from((-99999999999i64).min(1)); // should be linted because signed
+   |     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 error: casting `u64` to `u8` may truncate the value
   --> $DIR/cast.rs:120:5
    |
 LL |     999999u64.clamp(0, 256) as u8; // should still be linted
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: if this is intentional allow the lint with `#[allow(clippy::cast_precision_loss)]` ...
+help: ... or use `try_from` and handle the error accordingly
+   |
+LL |     u8::try_from(999999u64.clamp(0, 256)); // should still be linted
+   |     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 error: casting `main::E2` to `u8` may truncate the value
   --> $DIR/cast.rs:141:21
    |
 LL |             let _ = self as u8;
    |                     ^^^^^^^^^^
+   |
+   = help: if this is intentional allow the lint with `#[allow(clippy::cast_precision_loss)]` ...
+help: ... or use `try_from` and handle the error accordingly
+   |
+LL |             let _ = u8::try_from(self);
+   |                     ~~~~~~~~~~~~~~~~~~
 
 error: casting `main::E2::B` to `u8` will truncate the value
   --> $DIR/cast.rs:142:21
@@ -169,6 +228,12 @@ error: casting `main::E5` to `i8` may truncate the value
    |
 LL |             let _ = self as i8;
    |                     ^^^^^^^^^^
+   |
+   = help: if this is intentional allow the lint with `#[allow(clippy::cast_precision_loss)]` ...
+help: ... or use `try_from` and handle the error accordingly
+   |
+LL |             let _ = i8::try_from(self);
+   |                     ~~~~~~~~~~~~~~~~~~
 
 error: casting `main::E5::A` to `i8` will truncate the value
   --> $DIR/cast.rs:179:21
@@ -181,30 +246,60 @@ error: casting `main::E6` to `i16` may truncate the value
    |
 LL |             let _ = self as i16;
    |                     ^^^^^^^^^^^
+   |
+   = help: if this is intentional allow the lint with `#[allow(clippy::cast_precision_loss)]` ...
+help: ... or use `try_from` and handle the error accordingly
+   |
+LL |             let _ = i16::try_from(self);
+   |                     ~~~~~~~~~~~~~~~~~~~
 
 error: casting `main::E7` to `usize` may truncate the value on targets with 32-bit wide pointers
   --> $DIR/cast.rs:208:21
    |
 LL |             let _ = self as usize;
    |                     ^^^^^^^^^^^^^
+   |
+   = help: if this is intentional allow the lint with `#[allow(clippy::cast_precision_loss)]` ...
+help: ... or use `try_from` and handle the error accordingly
+   |
+LL |             let _ = usize::try_from(self);
+   |                     ~~~~~~~~~~~~~~~~~~~~~
 
 error: casting `main::E10` to `u16` may truncate the value
   --> $DIR/cast.rs:249:21
    |
 LL |             let _ = self as u16;
    |                     ^^^^^^^^^^^
+   |
+   = help: if this is intentional allow the lint with `#[allow(clippy::cast_precision_loss)]` ...
+help: ... or use `try_from` and handle the error accordingly
+   |
+LL |             let _ = u16::try_from(self);
+   |                     ~~~~~~~~~~~~~~~~~~~
 
 error: casting `u32` to `u8` may truncate the value
   --> $DIR/cast.rs:257:13
    |
 LL |     let c = (q >> 16) as u8;
    |             ^^^^^^^^^^^^^^^
+   |
+   = help: if this is intentional allow the lint with `#[allow(clippy::cast_precision_loss)]` ...
+help: ... or use `try_from` and handle the error accordingly
+   |
+LL |     let c = u8::try_from((q >> 16));
+   |             ~~~~~~~~~~~~~~~~~~~~~~~
 
 error: casting `u32` to `u8` may truncate the value
   --> $DIR/cast.rs:260:13
    |
 LL |     let c = (q / 1000) as u8;
    |             ^^^^^^^^^^^^^^^^
+   |
+   = help: if this is intentional allow the lint with `#[allow(clippy::cast_precision_loss)]` ...
+help: ... or use `try_from` and handle the error accordingly
+   |
+LL |     let c = u8::try_from((q / 1000));
+   |             ~~~~~~~~~~~~~~~~~~~~~~~~
 
 error: aborting due to 33 previous errors
 
diff --git a/tests/ui/cast_size.stderr b/tests/ui/cast_size.stderr
index 95552f2e285..8acf26049f4 100644
--- a/tests/ui/cast_size.stderr
+++ b/tests/ui/cast_size.stderr
@@ -4,7 +4,12 @@ error: casting `isize` to `i8` may truncate the value
 LL |     1isize as i8;
    |     ^^^^^^^^^^^^
    |
+   = help: if this is intentional allow the lint with `#[allow(clippy::cast_precision_loss)]` ...
    = note: `-D clippy::cast-possible-truncation` implied by `-D warnings`
+help: ... or use `try_from` and handle the error accordingly
+   |
+LL |     i8::try_from(1isize);
+   |     ~~~~~~~~~~~~~~~~~~~~
 
 error: casting `isize` to `f64` causes a loss of precision on targets with 64-bit wide pointers (`isize` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
   --> $DIR/cast_size.rs:15:5
@@ -37,24 +42,48 @@ error: casting `isize` to `i32` may truncate the value on targets with 64-bit wi
    |
 LL |     1isize as i32;
    |     ^^^^^^^^^^^^^
+   |
+   = help: if this is intentional allow the lint with `#[allow(clippy::cast_precision_loss)]` ...
+help: ... or use `try_from` and handle the error accordingly
+   |
+LL |     i32::try_from(1isize);
+   |     ~~~~~~~~~~~~~~~~~~~~~
 
 error: casting `isize` to `u32` may truncate the value on targets with 64-bit wide pointers
   --> $DIR/cast_size.rs:20:5
    |
 LL |     1isize as u32;
    |     ^^^^^^^^^^^^^
+   |
+   = help: if this is intentional allow the lint with `#[allow(clippy::cast_precision_loss)]` ...
+help: ... or use `try_from` and handle the error accordingly
+   |
+LL |     u32::try_from(1isize);
+   |     ~~~~~~~~~~~~~~~~~~~~~
 
 error: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
   --> $DIR/cast_size.rs:21:5
    |
 LL |     1usize as u32;
    |     ^^^^^^^^^^^^^
+   |
+   = help: if this is intentional allow the lint with `#[allow(clippy::cast_precision_loss)]` ...
+help: ... or use `try_from` and handle the error accordingly
+   |
+LL |     u32::try_from(1usize);
+   |     ~~~~~~~~~~~~~~~~~~~~~
 
 error: casting `usize` to `i32` may truncate the value on targets with 64-bit wide pointers
   --> $DIR/cast_size.rs:22:5
    |
 LL |     1usize as i32;
    |     ^^^^^^^^^^^^^
+   |
+   = help: if this is intentional allow the lint with `#[allow(clippy::cast_precision_loss)]` ...
+help: ... or use `try_from` and handle the error accordingly
+   |
+LL |     i32::try_from(1usize);
+   |     ~~~~~~~~~~~~~~~~~~~~~
 
 error: casting `usize` to `i32` may wrap around the value on targets with 32-bit wide pointers
   --> $DIR/cast_size.rs:22:5
@@ -69,18 +98,36 @@ error: casting `i64` to `isize` may truncate the value on targets with 32-bit wi
    |
 LL |     1i64 as isize;
    |     ^^^^^^^^^^^^^
+   |
+   = help: if this is intentional allow the lint with `#[allow(clippy::cast_precision_loss)]` ...
+help: ... or use `try_from` and handle the error accordingly
+   |
+LL |     isize::try_from(1i64);
+   |     ~~~~~~~~~~~~~~~~~~~~~
 
 error: casting `i64` to `usize` may truncate the value on targets with 32-bit wide pointers
   --> $DIR/cast_size.rs:25:5
    |
 LL |     1i64 as usize;
    |     ^^^^^^^^^^^^^
+   |
+   = help: if this is intentional allow the lint with `#[allow(clippy::cast_precision_loss)]` ...
+help: ... or use `try_from` and handle the error accordingly
+   |
+LL |     usize::try_from(1i64);
+   |     ~~~~~~~~~~~~~~~~~~~~~
 
 error: casting `u64` to `isize` may truncate the value on targets with 32-bit wide pointers
   --> $DIR/cast_size.rs:26:5
    |
 LL |     1u64 as isize;
    |     ^^^^^^^^^^^^^
+   |
+   = help: if this is intentional allow the lint with `#[allow(clippy::cast_precision_loss)]` ...
+help: ... or use `try_from` and handle the error accordingly
+   |
+LL |     isize::try_from(1u64);
+   |     ~~~~~~~~~~~~~~~~~~~~~
 
 error: casting `u64` to `isize` may wrap around the value on targets with 64-bit wide pointers
   --> $DIR/cast_size.rs:26:5
@@ -93,6 +140,12 @@ error: casting `u64` to `usize` may truncate the value on targets with 32-bit wi
    |
 LL |     1u64 as usize;
    |     ^^^^^^^^^^^^^
+   |
+   = help: if this is intentional allow the lint with `#[allow(clippy::cast_precision_loss)]` ...
+help: ... or use `try_from` and handle the error accordingly
+   |
+LL |     usize::try_from(1u64);
+   |     ~~~~~~~~~~~~~~~~~~~~~
 
 error: casting `u32` to `isize` may wrap around the value on targets with 32-bit wide pointers
   --> $DIR/cast_size.rs:28:5
-- 
cgit 1.4.1-3-g733a5


From fcdd08badf90665832939ccd30dc6df3194dd8a4 Mon Sep 17 00:00:00 2001
From: navh <navarre.hebb@gmail.com>
Date: Tue, 6 Dec 2022 19:05:49 +0100
Subject: update `cast_possible_truncation` documentation

---
 clippy_lints/src/casts/mod.rs | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index 38b1c5c1c7e..a9618ca06d6 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -80,12 +80,13 @@ declare_clippy_lint! {
     /// ### What it does
     /// Checks for casts between numerical types that may
     /// truncate large values. This is expected behavior, so the cast is `Allow` by
-    /// default.
+    /// default. It suggests user either explicitly ignore the lint,
+    /// or use `try_from()` and handle the truncation, default, or panic explicitly.
     ///
     /// ### Why is this bad?
     /// In some problem domains, it is good practice to avoid
     /// truncation. This lint can be activated to help assess where additional
-    /// checks could be beneficial, and suggests implementing TryFrom trait.
+    /// checks could be beneficial.
     ///
     /// ### Example
     /// ```rust
-- 
cgit 1.4.1-3-g733a5


From e6948c4117b608585c5aa22a7f95b6cfdc88dc48 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Tue, 6 Dec 2022 19:07:18 +0100
Subject: Last PR adjustments

---
 clippy_lints/src/casts/cast_possible_truncation.rs |  6 ++----
 clippy_lints/src/casts/mod.rs                      | 15 +++++++++++++++
 2 files changed, 17 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/cast_possible_truncation.rs b/clippy_lints/src/casts/cast_possible_truncation.rs
index d9898aeb92c..7a6450ffaa5 100644
--- a/clippy_lints/src/casts/cast_possible_truncation.rs
+++ b/clippy_lints/src/casts/cast_possible_truncation.rs
@@ -3,8 +3,6 @@ use clippy_utils::diagnostics::{span_lint, span_lint_and_then};
 use clippy_utils::expr_or_init;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::{get_discriminant_value, is_isize_or_usize};
-use rustc_ast::ast;
-use rustc_attr::IntType;
 use rustc_errors::{Applicability, SuggestionStyle};
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::{BinOpKind, Expr, ExprKind};
@@ -157,8 +155,8 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_expr: &Expr<'_>,
         _ => return,
     };
 
-    let snippet = snippet(cx, expr.span, "x");
-    let name_of_cast_from = snippet.split(" as").next().unwrap_or("x");
+    let snippet = snippet(cx, expr.span, "..");
+    let name_of_cast_from = snippet.split(" as").next().unwrap_or("..");
     let suggestion = format!("{cast_to}::try_from({name_of_cast_from})");
 
     span_lint_and_then(cx, CAST_POSSIBLE_TRUNCATION, expr.span, &msg, |diag| {
diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index a9618ca06d6..64dbe6c224c 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -94,6 +94,21 @@ declare_clippy_lint! {
     ///     x as u8
     /// }
     /// ```
+    /// Use instead:
+    /// ```
+    /// fn as_u8(x: u64) -> u8 {
+    ///     if let Ok(x) = u8::try_from(x) {
+    ///         x
+    ///     } else {
+    ///         todo!();
+    ///     }
+    /// }
+    /// // Or
+    /// #[allow(clippy::cast_possible_truncation)]
+    /// fn as_u16(x: u64) -> u16 {
+    ///     x as u16
+    /// }
+    /// ```
     #[clippy::version = "pre 1.29.0"]
     pub CAST_POSSIBLE_TRUNCATION,
     pedantic,
-- 
cgit 1.4.1-3-g733a5


From 5cb6246c3e7ccae640eafbc238a293918b552116 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Thu, 12 Jan 2023 12:35:29 +0100
Subject: Address PR reivew

---
 clippy_lints/src/casts/cast_possible_truncation.rs | 16 +++--
 clippy_lints/src/casts/mod.rs                      |  2 +-
 tests/ui/cast.rs                                   |  1 +
 tests/ui/cast.stderr                               | 68 ++++++++++++++++------
 4 files changed, 63 insertions(+), 24 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/cast_possible_truncation.rs b/clippy_lints/src/casts/cast_possible_truncation.rs
index 7a6450ffaa5..f3f8b8d8798 100644
--- a/clippy_lints/src/casts/cast_possible_truncation.rs
+++ b/clippy_lints/src/casts/cast_possible_truncation.rs
@@ -8,6 +8,7 @@ use rustc_hir::def::{DefKind, Res};
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::LateContext;
 use rustc_middle::ty::{self, FloatTy, Ty};
+use rustc_span::Span;
 use rustc_target::abi::IntegerType;
 
 use super::{utils, CAST_ENUM_TRUNCATION, CAST_POSSIBLE_TRUNCATION};
@@ -76,7 +77,14 @@ fn apply_reductions(cx: &LateContext<'_>, nbits: u64, expr: &Expr<'_>, signed: b
     }
 }
 
-pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_expr: &Expr<'_>, cast_from: Ty<'_>, cast_to: Ty<'_>) {
+pub(super) fn check(
+    cx: &LateContext<'_>,
+    expr: &Expr<'_>,
+    cast_expr: &Expr<'_>,
+    cast_from: Ty<'_>,
+    cast_to: Ty<'_>,
+    cast_to_span: Span,
+) {
     let msg = match (cast_from.kind(), cast_to.is_integral()) {
         (ty::Int(_) | ty::Uint(_), true) => {
             let from_nbits = apply_reductions(
@@ -155,9 +163,9 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_expr: &Expr<'_>,
         _ => return,
     };
 
-    let snippet = snippet(cx, expr.span, "..");
-    let name_of_cast_from = snippet.split(" as").next().unwrap_or("..");
-    let suggestion = format!("{cast_to}::try_from({name_of_cast_from})");
+    let name_of_cast_from = snippet(cx, cast_expr.span, "..");
+    let cast_to_snip = snippet(cx, cast_to_span, "..");
+    let suggestion = format!("{cast_to_snip}::try_from({name_of_cast_from})");
 
     span_lint_and_then(cx, CAST_POSSIBLE_TRUNCATION, expr.span, &msg, |diag| {
         diag.help("if this is intentional allow the lint with `#[allow(clippy::cast_precision_loss)]` ...");
diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index 64dbe6c224c..362f70d12d1 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -728,7 +728,7 @@ impl<'tcx> LateLintPass<'tcx> for Casts {
             fn_to_numeric_cast_with_truncation::check(cx, expr, cast_expr, cast_from, cast_to);
 
             if cast_to.is_numeric() && !in_external_macro(cx.sess(), expr.span) {
-                cast_possible_truncation::check(cx, expr, cast_expr, cast_from, cast_to);
+                cast_possible_truncation::check(cx, expr, cast_expr, cast_from, cast_to, cast_to_hir.span);
                 if cast_from.is_numeric() {
                     cast_possible_wrap::check(cx, expr, cast_from, cast_to);
                     cast_precision_loss::check(cx, expr, cast_from, cast_to);
diff --git a/tests/ui/cast.rs b/tests/ui/cast.rs
index e6031e9adae..8b2673c2a7f 100644
--- a/tests/ui/cast.rs
+++ b/tests/ui/cast.rs
@@ -28,6 +28,7 @@ fn main() {
     1i32 as u8;
     1f64 as isize;
     1f64 as usize;
+    1f32 as u32 as u16;
     // Test clippy::cast_possible_wrap
     1u8 as i8;
     1u16 as i16;
diff --git a/tests/ui/cast.stderr b/tests/ui/cast.stderr
index eceb135d62b..4af1de9aa38 100644
--- a/tests/ui/cast.stderr
+++ b/tests/ui/cast.stderr
@@ -135,8 +135,38 @@ error: casting `f64` to `usize` may lose the sign of the value
 LL |     1f64 as usize;
    |     ^^^^^^^^^^^^^
 
+error: casting `u32` to `u16` may truncate the value
+  --> $DIR/cast.rs:31:5
+   |
+LL |     1f32 as u32 as u16;
+   |     ^^^^^^^^^^^^^^^^^^
+   |
+   = help: if this is intentional allow the lint with `#[allow(clippy::cast_precision_loss)]` ...
+help: ... or use `try_from` and handle the error accordingly
+   |
+LL |     u16::try_from(1f32 as u32);
+   |     ~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+error: casting `f32` to `u32` may truncate the value
+  --> $DIR/cast.rs:31:5
+   |
+LL |     1f32 as u32 as u16;
+   |     ^^^^^^^^^^^
+   |
+   = help: if this is intentional allow the lint with `#[allow(clippy::cast_precision_loss)]` ...
+help: ... or use `try_from` and handle the error accordingly
+   |
+LL |     u32::try_from(1f32) as u16;
+   |     ~~~~~~~~~~~~~~~~~~~
+
+error: casting `f32` to `u32` may lose the sign of the value
+  --> $DIR/cast.rs:31:5
+   |
+LL |     1f32 as u32 as u16;
+   |     ^^^^^^^^^^^
+
 error: casting `u8` to `i8` may wrap around the value
-  --> $DIR/cast.rs:32:5
+  --> $DIR/cast.rs:33:5
    |
 LL |     1u8 as i8;
    |     ^^^^^^^^^
@@ -144,43 +174,43 @@ LL |     1u8 as i8;
    = note: `-D clippy::cast-possible-wrap` implied by `-D warnings`
 
 error: casting `u16` to `i16` may wrap around the value
-  --> $DIR/cast.rs:33:5
+  --> $DIR/cast.rs:34:5
    |
 LL |     1u16 as i16;
    |     ^^^^^^^^^^^
 
 error: casting `u32` to `i32` may wrap around the value
-  --> $DIR/cast.rs:34:5
+  --> $DIR/cast.rs:35:5
    |
 LL |     1u32 as i32;
    |     ^^^^^^^^^^^
 
 error: casting `u64` to `i64` may wrap around the value
-  --> $DIR/cast.rs:35:5
+  --> $DIR/cast.rs:36:5
    |
 LL |     1u64 as i64;
    |     ^^^^^^^^^^^
 
 error: casting `usize` to `isize` may wrap around the value
-  --> $DIR/cast.rs:36:5
+  --> $DIR/cast.rs:37:5
    |
 LL |     1usize as isize;
    |     ^^^^^^^^^^^^^^^
 
 error: casting `i32` to `u32` may lose the sign of the value
-  --> $DIR/cast.rs:39:5
+  --> $DIR/cast.rs:40:5
    |
 LL |     -1i32 as u32;
    |     ^^^^^^^^^^^^
 
 error: casting `isize` to `usize` may lose the sign of the value
-  --> $DIR/cast.rs:41:5
+  --> $DIR/cast.rs:42:5
    |
 LL |     -1isize as usize;
    |     ^^^^^^^^^^^^^^^^
 
 error: casting `i64` to `i8` may truncate the value
-  --> $DIR/cast.rs:108:5
+  --> $DIR/cast.rs:109:5
    |
 LL |     (-99999999999i64).min(1) as i8; // should be linted because signed
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -192,7 +222,7 @@ LL |     i8::try_from((-99999999999i64).min(1)); // should be linted because sig
    |     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 error: casting `u64` to `u8` may truncate the value
-  --> $DIR/cast.rs:120:5
+  --> $DIR/cast.rs:121:5
    |
 LL |     999999u64.clamp(0, 256) as u8; // should still be linted
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -204,7 +234,7 @@ LL |     u8::try_from(999999u64.clamp(0, 256)); // should still be linted
    |     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 error: casting `main::E2` to `u8` may truncate the value
-  --> $DIR/cast.rs:141:21
+  --> $DIR/cast.rs:142:21
    |
 LL |             let _ = self as u8;
    |                     ^^^^^^^^^^
@@ -216,7 +246,7 @@ LL |             let _ = u8::try_from(self);
    |                     ~~~~~~~~~~~~~~~~~~
 
 error: casting `main::E2::B` to `u8` will truncate the value
-  --> $DIR/cast.rs:142:21
+  --> $DIR/cast.rs:143:21
    |
 LL |             let _ = Self::B as u8;
    |                     ^^^^^^^^^^^^^
@@ -224,7 +254,7 @@ LL |             let _ = Self::B as u8;
    = note: `-D clippy::cast-enum-truncation` implied by `-D warnings`
 
 error: casting `main::E5` to `i8` may truncate the value
-  --> $DIR/cast.rs:178:21
+  --> $DIR/cast.rs:179:21
    |
 LL |             let _ = self as i8;
    |                     ^^^^^^^^^^
@@ -236,13 +266,13 @@ LL |             let _ = i8::try_from(self);
    |                     ~~~~~~~~~~~~~~~~~~
 
 error: casting `main::E5::A` to `i8` will truncate the value
-  --> $DIR/cast.rs:179:21
+  --> $DIR/cast.rs:180:21
    |
 LL |             let _ = Self::A as i8;
    |                     ^^^^^^^^^^^^^
 
 error: casting `main::E6` to `i16` may truncate the value
-  --> $DIR/cast.rs:193:21
+  --> $DIR/cast.rs:194:21
    |
 LL |             let _ = self as i16;
    |                     ^^^^^^^^^^^
@@ -254,7 +284,7 @@ LL |             let _ = i16::try_from(self);
    |                     ~~~~~~~~~~~~~~~~~~~
 
 error: casting `main::E7` to `usize` may truncate the value on targets with 32-bit wide pointers
-  --> $DIR/cast.rs:208:21
+  --> $DIR/cast.rs:209:21
    |
 LL |             let _ = self as usize;
    |                     ^^^^^^^^^^^^^
@@ -266,7 +296,7 @@ LL |             let _ = usize::try_from(self);
    |                     ~~~~~~~~~~~~~~~~~~~~~
 
 error: casting `main::E10` to `u16` may truncate the value
-  --> $DIR/cast.rs:249:21
+  --> $DIR/cast.rs:250:21
    |
 LL |             let _ = self as u16;
    |                     ^^^^^^^^^^^
@@ -278,7 +308,7 @@ LL |             let _ = u16::try_from(self);
    |                     ~~~~~~~~~~~~~~~~~~~
 
 error: casting `u32` to `u8` may truncate the value
-  --> $DIR/cast.rs:257:13
+  --> $DIR/cast.rs:258:13
    |
 LL |     let c = (q >> 16) as u8;
    |             ^^^^^^^^^^^^^^^
@@ -290,7 +320,7 @@ LL |     let c = u8::try_from((q >> 16));
    |             ~~~~~~~~~~~~~~~~~~~~~~~
 
 error: casting `u32` to `u8` may truncate the value
-  --> $DIR/cast.rs:260:13
+  --> $DIR/cast.rs:261:13
    |
 LL |     let c = (q / 1000) as u8;
    |             ^^^^^^^^^^^^^^^^
@@ -301,5 +331,5 @@ help: ... or use `try_from` and handle the error accordingly
 LL |     let c = u8::try_from((q / 1000));
    |             ~~~~~~~~~~~~~~~~~~~~~~~~
 
-error: aborting due to 33 previous errors
+error: aborting due to 36 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 5eed9c69ca9fa04a1417f1f14df0bb5bab2fc8c8 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Thu, 12 Jan 2023 13:28:22 -0500
Subject: Revert 4dbd8ad34e7f6820f6e9e99531353e7ffe37b76a,
 c7dc96155853a3919b973347277d0e9bcaaa22f0,
 ed519ad746e31f64c4e9255be561785612532d37 and
 c6477eb71188311f01f409da628fab7062697bd7

---
 clippy_lints/src/dereference.rs           |   8 +-
 clippy_lints/src/redundant_clone.rs       |   4 +-
 clippy_utils/src/mir/possible_borrower.rs | 271 +++++++++++-------------------
 tests/ui/needless_borrow.fixed            |  13 +-
 tests/ui/needless_borrow.rs               |  13 +-
 tests/ui/needless_borrow.stderr           |   8 +-
 tests/ui/redundant_clone.fixed            |   6 -
 tests/ui/redundant_clone.rs               |   6 -
 tests/ui/redundant_clone.stderr           |  14 +-
 9 files changed, 109 insertions(+), 234 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index 728941b8b3d..7b43d8ccc67 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -1282,10 +1282,10 @@ fn referent_used_exactly_once<'tcx>(
             possible_borrowers.push((body_owner_local_def_id, PossibleBorrowerMap::new(cx, mir)));
         }
         let possible_borrower = &mut possible_borrowers.last_mut().unwrap().1;
-        // If `place.local` were not included here, the `copyable_iterator::warn` test would fail. The
-        // reason is that `PossibleBorrowerVisitor::visit_terminator` considers `place.local` a possible
-        // borrower of itself. See the comment in that method for an explanation as to why.
-        possible_borrower.at_most_borrowers(cx, &[local, place.local], place.local, location)
+        // If `only_borrowers` were used here, the `copyable_iterator::warn` test would fail. The reason is
+        // that `PossibleBorrowerVisitor::visit_terminator` considers `place.local` a possible borrower of
+        // itself. See the comment in that method for an explanation as to why.
+        possible_borrower.bounded_borrowers(&[local], &[local, place.local], place.local, location)
             && used_exactly_once(mir, place.local).unwrap_or(false)
     } else {
         false
diff --git a/clippy_lints/src/redundant_clone.rs b/clippy_lints/src/redundant_clone.rs
index 0e7c5cca724..c1677fb3da1 100644
--- a/clippy_lints/src/redundant_clone.rs
+++ b/clippy_lints/src/redundant_clone.rs
@@ -131,7 +131,7 @@ impl<'tcx> LateLintPass<'tcx> for RedundantClone {
                 // `res = clone(arg)` can be turned into `res = move arg;`
                 // if `arg` is the only borrow of `cloned` at this point.
 
-                if cannot_move_out || !possible_borrower.at_most_borrowers(cx, &[arg], cloned, loc) {
+                if cannot_move_out || !possible_borrower.only_borrowers(&[arg], cloned, loc) {
                     continue;
                 }
 
@@ -178,7 +178,7 @@ impl<'tcx> LateLintPass<'tcx> for RedundantClone {
                 // StorageDead(pred_arg);
                 // res = to_path_buf(cloned);
                 // ```
-                if cannot_move_out || !possible_borrower.at_most_borrowers(cx, &[arg, cloned], local, loc) {
+                if cannot_move_out || !possible_borrower.only_borrowers(&[arg, cloned], local, loc) {
                     continue;
                 }
 
diff --git a/clippy_utils/src/mir/possible_borrower.rs b/clippy_utils/src/mir/possible_borrower.rs
index 395d46e7a2f..8c695801c73 100644
--- a/clippy_utils/src/mir/possible_borrower.rs
+++ b/clippy_utils/src/mir/possible_borrower.rs
@@ -1,137 +1,89 @@
-use super::possible_origin::PossibleOriginVisitor;
+use super::{possible_origin::PossibleOriginVisitor, transitive_relation::TransitiveRelation};
 use crate::ty::is_copy;
-use rustc_data_structures::fx::{FxHashMap, FxIndexMap};
+use rustc_data_structures::fx::FxHashMap;
 use rustc_index::bit_set::{BitSet, HybridBitSet};
 use rustc_lint::LateContext;
-use rustc_middle::mir::{
-    self, visit::Visitor as _, BasicBlock, Local, Location, Mutability, Statement, StatementKind, Terminator,
-};
-use rustc_middle::ty::{self, visit::TypeVisitor, TyCtxt};
-use rustc_mir_dataflow::{
-    fmt::DebugWithContext, impls::MaybeStorageLive, lattice::JoinSemiLattice, Analysis, AnalysisDomain,
-    CallReturnPlaces, ResultsCursor,
-};
-use std::borrow::Cow;
+use rustc_middle::mir::{self, visit::Visitor as _, Mutability};
+use rustc_middle::ty::{self, visit::TypeVisitor};
+use rustc_mir_dataflow::{impls::MaybeStorageLive, Analysis, ResultsCursor};
 use std::ops::ControlFlow;
 
 /// Collects the possible borrowers of each local.
 /// For example, `b = &a; c = &a;` will make `b` and (transitively) `c`
 /// possible borrowers of `a`.
 #[allow(clippy::module_name_repetitions)]
-struct PossibleBorrowerAnalysis<'b, 'tcx> {
-    tcx: TyCtxt<'tcx>,
+struct PossibleBorrowerVisitor<'a, 'b, 'tcx> {
+    possible_borrower: TransitiveRelation,
     body: &'b mir::Body<'tcx>,
+    cx: &'a LateContext<'tcx>,
     possible_origin: FxHashMap<mir::Local, HybridBitSet<mir::Local>>,
 }
 
-#[derive(Clone, Debug, Eq, PartialEq)]
-struct PossibleBorrowerState {
-    map: FxIndexMap<Local, BitSet<Local>>,
-    domain_size: usize,
-}
-
-impl PossibleBorrowerState {
-    fn new(domain_size: usize) -> Self {
+impl<'a, 'b, 'tcx> PossibleBorrowerVisitor<'a, 'b, 'tcx> {
+    fn new(
+        cx: &'a LateContext<'tcx>,
+        body: &'b mir::Body<'tcx>,
+        possible_origin: FxHashMap<mir::Local, HybridBitSet<mir::Local>>,
+    ) -> Self {
         Self {
-            map: FxIndexMap::default(),
-            domain_size,
+            possible_borrower: TransitiveRelation::default(),
+            cx,
+            body,
+            possible_origin,
         }
     }
 
-    #[allow(clippy::similar_names)]
-    fn add(&mut self, borrowed: Local, borrower: Local) {
-        self.map
-            .entry(borrowed)
-            .or_insert(BitSet::new_empty(self.domain_size))
-            .insert(borrower);
-    }
-}
-
-impl<C> DebugWithContext<C> for PossibleBorrowerState {
-    fn fmt_with(&self, _ctxt: &C, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        <_ as std::fmt::Debug>::fmt(self, f)
-    }
-    fn fmt_diff_with(&self, _old: &Self, _ctxt: &C, _f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        unimplemented!()
-    }
-}
+    fn into_map(
+        self,
+        cx: &'a LateContext<'tcx>,
+        maybe_live: ResultsCursor<'b, 'tcx, MaybeStorageLive>,
+    ) -> PossibleBorrowerMap<'b, 'tcx> {
+        let mut map = FxHashMap::default();
+        for row in (1..self.body.local_decls.len()).map(mir::Local::from_usize) {
+            if is_copy(cx, self.body.local_decls[row].ty) {
+                continue;
+            }
 
-impl JoinSemiLattice for PossibleBorrowerState {
-    fn join(&mut self, other: &Self) -> bool {
-        let mut changed = false;
-        for (&borrowed, borrowers) in other.map.iter() {
+            let mut borrowers = self.possible_borrower.reachable_from(row, self.body.local_decls.len());
+            borrowers.remove(mir::Local::from_usize(0));
             if !borrowers.is_empty() {
-                changed |= self
-                    .map
-                    .entry(borrowed)
-                    .or_insert(BitSet::new_empty(self.domain_size))
-                    .union(borrowers);
+                map.insert(row, borrowers);
             }
         }
-        changed
-    }
-}
-
-impl<'b, 'tcx> AnalysisDomain<'tcx> for PossibleBorrowerAnalysis<'b, 'tcx> {
-    type Domain = PossibleBorrowerState;
-
-    const NAME: &'static str = "possible_borrower";
-
-    fn bottom_value(&self, body: &mir::Body<'tcx>) -> Self::Domain {
-        PossibleBorrowerState::new(body.local_decls.len())
-    }
-
-    fn initialize_start_block(&self, _body: &mir::Body<'tcx>, _entry_set: &mut Self::Domain) {}
-}
 
-impl<'b, 'tcx> PossibleBorrowerAnalysis<'b, 'tcx> {
-    fn new(
-        tcx: TyCtxt<'tcx>,
-        body: &'b mir::Body<'tcx>,
-        possible_origin: FxHashMap<mir::Local, HybridBitSet<mir::Local>>,
-    ) -> Self {
-        Self {
-            tcx,
-            body,
-            possible_origin,
+        let bs = BitSet::new_empty(self.body.local_decls.len());
+        PossibleBorrowerMap {
+            map,
+            maybe_live,
+            bitset: (bs.clone(), bs),
         }
     }
 }
 
-impl<'b, 'tcx> Analysis<'tcx> for PossibleBorrowerAnalysis<'b, 'tcx> {
-    fn apply_call_return_effect(
-        &self,
-        _state: &mut Self::Domain,
-        _block: BasicBlock,
-        _return_places: CallReturnPlaces<'_, 'tcx>,
-    ) {
-    }
-
-    fn apply_statement_effect(&self, state: &mut Self::Domain, statement: &Statement<'tcx>, _location: Location) {
-        if let StatementKind::Assign(box (place, rvalue)) = &statement.kind {
-            let lhs = place.local;
-            match rvalue {
-                mir::Rvalue::Ref(_, _, borrowed) => {
-                    state.add(borrowed.local, lhs);
-                },
-                other => {
-                    if ContainsRegion
-                        .visit_ty(place.ty(&self.body.local_decls, self.tcx).ty)
-                        .is_continue()
-                    {
-                        return;
+impl<'a, 'b, 'tcx> mir::visit::Visitor<'tcx> for PossibleBorrowerVisitor<'a, 'b, 'tcx> {
+    fn visit_assign(&mut self, place: &mir::Place<'tcx>, rvalue: &mir::Rvalue<'_>, _location: mir::Location) {
+        let lhs = place.local;
+        match rvalue {
+            mir::Rvalue::Ref(_, _, borrowed) => {
+                self.possible_borrower.add(borrowed.local, lhs);
+            },
+            other => {
+                if ContainsRegion
+                    .visit_ty(place.ty(&self.body.local_decls, self.cx.tcx).ty)
+                    .is_continue()
+                {
+                    return;
+                }
+                rvalue_locals(other, |rhs| {
+                    if lhs != rhs {
+                        self.possible_borrower.add(rhs, lhs);
                     }
-                    rvalue_locals(other, |rhs| {
-                        if lhs != rhs {
-                            state.add(rhs, lhs);
-                        }
-                    });
-                },
-            }
+                });
+            },
         }
     }
 
-    fn apply_terminator_effect(&self, state: &mut Self::Domain, terminator: &Terminator<'tcx>, _location: Location) {
+    fn visit_terminator(&mut self, terminator: &mir::Terminator<'_>, _loc: mir::Location) {
         if let mir::TerminatorKind::Call {
             args,
             destination: mir::Place { local: dest, .. },
@@ -171,10 +123,10 @@ impl<'b, 'tcx> Analysis<'tcx> for PossibleBorrowerAnalysis<'b, 'tcx> {
 
             for y in mutable_variables {
                 for x in &immutable_borrowers {
-                    state.add(*x, y);
+                    self.possible_borrower.add(*x, y);
                 }
                 for x in &mutable_borrowers {
-                    state.add(*x, y);
+                    self.possible_borrower.add(*x, y);
                 }
             }
         }
@@ -210,98 +162,73 @@ fn rvalue_locals(rvalue: &mir::Rvalue<'_>, mut visit: impl FnMut(mir::Local)) {
     }
 }
 
-/// Result of `PossibleBorrowerAnalysis`.
+/// Result of `PossibleBorrowerVisitor`.
 #[allow(clippy::module_name_repetitions)]
 pub struct PossibleBorrowerMap<'b, 'tcx> {
-    body: &'b mir::Body<'tcx>,
-    possible_borrower: ResultsCursor<'b, 'tcx, PossibleBorrowerAnalysis<'b, 'tcx>>,
-    maybe_live: ResultsCursor<'b, 'tcx, MaybeStorageLive<'b>>,
-    pushed: BitSet<Local>,
-    stack: Vec<Local>,
+    /// Mapping `Local -> its possible borrowers`
+    pub map: FxHashMap<mir::Local, HybridBitSet<mir::Local>>,
+    maybe_live: ResultsCursor<'b, 'tcx, MaybeStorageLive>,
+    // Caches to avoid allocation of `BitSet` on every query
+    pub bitset: (BitSet<mir::Local>, BitSet<mir::Local>),
 }
 
-impl<'b, 'tcx> PossibleBorrowerMap<'b, 'tcx> {
-    pub fn new(cx: &LateContext<'tcx>, mir: &'b mir::Body<'tcx>) -> Self {
+impl<'a, 'b, 'tcx> PossibleBorrowerMap<'b, 'tcx> {
+    pub fn new(cx: &'a LateContext<'tcx>, mir: &'b mir::Body<'tcx>) -> Self {
         let possible_origin = {
             let mut vis = PossibleOriginVisitor::new(mir);
             vis.visit_body(mir);
             vis.into_map(cx)
         };
-        let possible_borrower = PossibleBorrowerAnalysis::new(cx.tcx, mir, possible_origin)
+        let maybe_storage_live_result = MaybeStorageLive::new(BitSet::new_empty(mir.local_decls.len()))
             .into_engine(cx.tcx, mir)
-            .pass_name("possible_borrower")
+            .pass_name("redundant_clone")
             .iterate_to_fixpoint()
             .into_results_cursor(mir);
-        let maybe_live = MaybeStorageLive::new(Cow::Owned(BitSet::new_empty(mir.local_decls.len())))
-            .into_engine(cx.tcx, mir)
-            .pass_name("possible_borrower")
-            .iterate_to_fixpoint()
-            .into_results_cursor(mir);
-        PossibleBorrowerMap {
-            body: mir,
-            possible_borrower,
-            maybe_live,
-            pushed: BitSet::new_empty(mir.local_decls.len()),
-            stack: Vec::with_capacity(mir.local_decls.len()),
-        }
+        let mut vis = PossibleBorrowerVisitor::new(cx, mir, possible_origin);
+        vis.visit_body(mir);
+        vis.into_map(cx, maybe_storage_live_result)
     }
 
-    /// Returns true if the set of borrowers of `borrowed` living at `at` includes no more than
-    /// `borrowers`.
-    /// Notes:
-    /// 1. It would be nice if `PossibleBorrowerMap` could store `cx` so that `at_most_borrowers`
-    /// would not require it to be passed in. But a `PossibleBorrowerMap` is stored in `LintPass`
-    /// `Dereferencing`, which outlives any `LateContext`.
-    /// 2. In all current uses of `at_most_borrowers`, `borrowers` is a slice of at most two
-    /// elements. Thus, `borrowers.contains(...)` is effectively a constant-time operation. If
-    /// `at_most_borrowers`'s uses were to expand beyond this, its implementation might have to be
-    /// adjusted.
-    pub fn at_most_borrowers(
+    /// Returns true if the set of borrowers of `borrowed` living at `at` matches with `borrowers`.
+    pub fn only_borrowers(&mut self, borrowers: &[mir::Local], borrowed: mir::Local, at: mir::Location) -> bool {
+        self.bounded_borrowers(borrowers, borrowers, borrowed, at)
+    }
+
+    /// Returns true if the set of borrowers of `borrowed` living at `at` includes at least `below`
+    /// but no more than `above`.
+    pub fn bounded_borrowers(
         &mut self,
-        cx: &LateContext<'tcx>,
-        borrowers: &[mir::Local],
+        below: &[mir::Local],
+        above: &[mir::Local],
         borrowed: mir::Local,
         at: mir::Location,
     ) -> bool {
-        if is_copy(cx, self.body.local_decls[borrowed].ty) {
-            return true;
-        }
-
-        self.possible_borrower.seek_before_primary_effect(at);
-        self.maybe_live.seek_before_primary_effect(at);
-
-        let possible_borrower = &self.possible_borrower.get().map;
-        let maybe_live = &self.maybe_live;
-
-        self.pushed.clear();
-        self.stack.clear();
+        self.maybe_live.seek_after_primary_effect(at);
 
-        if let Some(borrowers) = possible_borrower.get(&borrowed) {
-            for b in borrowers.iter() {
-                if self.pushed.insert(b) {
-                    self.stack.push(b);
-                }
+        self.bitset.0.clear();
+        let maybe_live = &mut self.maybe_live;
+        if let Some(bitset) = self.map.get(&borrowed) {
+            for b in bitset.iter().filter(move |b| maybe_live.contains(*b)) {
+                self.bitset.0.insert(b);
             }
         } else {
-            // Nothing borrows `borrowed` at `at`.
-            return true;
+            return false;
         }
 
-        while let Some(borrower) = self.stack.pop() {
-            if maybe_live.contains(borrower) && !borrowers.contains(&borrower) {
-                return false;
-            }
+        self.bitset.1.clear();
+        for b in below {
+            self.bitset.1.insert(*b);
+        }
 
-            if let Some(borrowers) = possible_borrower.get(&borrower) {
-                for b in borrowers.iter() {
-                    if self.pushed.insert(b) {
-                        self.stack.push(b);
-                    }
-                }
-            }
+        if !self.bitset.0.superset(&self.bitset.1) {
+            return false;
+        }
+
+        for b in above {
+            self.bitset.0.remove(*b);
         }
 
-        true
+        self.bitset.0.is_empty()
     }
 
     pub fn local_is_alive_at(&mut self, local: mir::Local, at: mir::Location) -> bool {
diff --git a/tests/ui/needless_borrow.fixed b/tests/ui/needless_borrow.fixed
index 31e1cb6c3d7..4cb7f6b687f 100644
--- a/tests/ui/needless_borrow.fixed
+++ b/tests/ui/needless_borrow.fixed
@@ -1,5 +1,5 @@
 // run-rustfix
-#![feature(custom_inner_attributes, lint_reasons, rustc_private)]
+#![feature(lint_reasons)]
 #![allow(
     unused,
     clippy::uninlined_format_args,
@@ -491,14 +491,3 @@ mod issue_9782_method_variant {
         S.foo::<&[u8; 100]>(&a);
     }
 }
-
-extern crate rustc_lint;
-extern crate rustc_span;
-
-#[allow(dead_code)]
-mod span_lint {
-    use rustc_lint::{LateContext, Lint, LintContext};
-    fn foo(cx: &LateContext<'_>, lint: &'static Lint) {
-        cx.struct_span_lint(lint, rustc_span::Span::default(), "", |diag| diag.note(String::new()));
-    }
-}
diff --git a/tests/ui/needless_borrow.rs b/tests/ui/needless_borrow.rs
index 55c2738fcf2..9a01190ed8d 100644
--- a/tests/ui/needless_borrow.rs
+++ b/tests/ui/needless_borrow.rs
@@ -1,5 +1,5 @@
 // run-rustfix
-#![feature(custom_inner_attributes, lint_reasons, rustc_private)]
+#![feature(lint_reasons)]
 #![allow(
     unused,
     clippy::uninlined_format_args,
@@ -491,14 +491,3 @@ mod issue_9782_method_variant {
         S.foo::<&[u8; 100]>(&a);
     }
 }
-
-extern crate rustc_lint;
-extern crate rustc_span;
-
-#[allow(dead_code)]
-mod span_lint {
-    use rustc_lint::{LateContext, Lint, LintContext};
-    fn foo(cx: &LateContext<'_>, lint: &'static Lint) {
-        cx.struct_span_lint(lint, rustc_span::Span::default(), "", |diag| diag.note(&String::new()));
-    }
-}
diff --git a/tests/ui/needless_borrow.stderr b/tests/ui/needless_borrow.stderr
index 98a48d68317..d26c317124b 100644
--- a/tests/ui/needless_borrow.stderr
+++ b/tests/ui/needless_borrow.stderr
@@ -216,11 +216,5 @@ error: the borrowed expression implements the required traits
 LL |         foo(&a);
    |             ^^ help: change this to: `a`
 
-error: the borrowed expression implements the required traits
-  --> $DIR/needless_borrow.rs:502:85
-   |
-LL |         cx.struct_span_lint(lint, rustc_span::Span::default(), "", |diag| diag.note(&String::new()));
-   |                                                                                     ^^^^^^^^^^^^^^ help: change this to: `String::new()`
-
-error: aborting due to 37 previous errors
+error: aborting due to 36 previous errors
 
diff --git a/tests/ui/redundant_clone.fixed b/tests/ui/redundant_clone.fixed
index a157b6a6f9a..00b42745093 100644
--- a/tests/ui/redundant_clone.fixed
+++ b/tests/ui/redundant_clone.fixed
@@ -239,9 +239,3 @@ fn false_negative_5707() {
     let _z = x.clone(); // pr 7346 can't lint on `x`
     drop(y);
 }
-
-#[allow(unused, clippy::manual_retain)]
-fn possible_borrower_improvements() {
-    let mut s = String::from("foobar");
-    s = s.chars().filter(|&c| c != 'o').collect();
-}
diff --git a/tests/ui/redundant_clone.rs b/tests/ui/redundant_clone.rs
index 430672e8b8d..f899127db8d 100644
--- a/tests/ui/redundant_clone.rs
+++ b/tests/ui/redundant_clone.rs
@@ -239,9 +239,3 @@ fn false_negative_5707() {
     let _z = x.clone(); // pr 7346 can't lint on `x`
     drop(y);
 }
-
-#[allow(unused, clippy::manual_retain)]
-fn possible_borrower_improvements() {
-    let mut s = String::from("foobar");
-    s = s.chars().filter(|&c| c != 'o').to_owned().collect();
-}
diff --git a/tests/ui/redundant_clone.stderr b/tests/ui/redundant_clone.stderr
index 1bacc2c76af..782590034d0 100644
--- a/tests/ui/redundant_clone.stderr
+++ b/tests/ui/redundant_clone.stderr
@@ -179,17 +179,5 @@ note: this value is dropped without further use
 LL |     foo(&x.clone(), move || {
    |          ^
 
-error: redundant clone
-  --> $DIR/redundant_clone.rs:246:40
-   |
-LL |     s = s.chars().filter(|&c| c != 'o').to_owned().collect();
-   |                                        ^^^^^^^^^^^ help: remove this
-   |
-note: this value is dropped without further use
-  --> $DIR/redundant_clone.rs:246:9
-   |
-LL |     s = s.chars().filter(|&c| c != 'o').to_owned().collect();
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: aborting due to 16 previous errors
+error: aborting due to 15 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From b38848d8f740a7ada6b2ba14acf08c5e57c94002 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Thu, 12 Jan 2023 13:00:03 -0500
Subject: Fix suggestion in `transmutes_expressible_as_ptr_casts` when the
 source type is a borrow.

---
 clippy_lints/src/transmute/mod.rs                  |  7 ++-
 .../transmutes_expressible_as_ptr_casts.rs         | 58 ++++++++++++++--------
 clippy_lints/src/transmute/utils.rs                | 24 +++------
 tests/ui/transmutes_expressible_as_ptr_casts.fixed |  2 +
 tests/ui/transmutes_expressible_as_ptr_casts.rs    |  2 +
 .../ui/transmutes_expressible_as_ptr_casts.stderr  | 10 +++-
 6 files changed, 60 insertions(+), 43 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/transmute/mod.rs b/clippy_lints/src/transmute/mod.rs
index 691d759d773..c0d290b5adc 100644
--- a/clippy_lints/src/transmute/mod.rs
+++ b/clippy_lints/src/transmute/mod.rs
@@ -479,7 +479,10 @@ impl<'tcx> LateLintPass<'tcx> for Transmute {
                 // - char conversions (https://github.com/rust-lang/rust/issues/89259)
                 let const_context = in_constant(cx, e.hir_id);
 
-                let from_ty = cx.typeck_results().expr_ty_adjusted(arg);
+                let (from_ty, from_ty_adjusted) = match cx.typeck_results().expr_adjustments(arg) {
+                    [] => (cx.typeck_results().expr_ty(arg), false),
+                    [.., a] => (a.target, true),
+                };
                 // Adjustments for `to_ty` happen after the call to `transmute`, so don't use them.
                 let to_ty = cx.typeck_results().expr_ty(e);
 
@@ -506,7 +509,7 @@ impl<'tcx> LateLintPass<'tcx> for Transmute {
                     );
 
                 if !linted {
-                    transmutes_expressible_as_ptr_casts::check(cx, e, from_ty, to_ty, arg);
+                    transmutes_expressible_as_ptr_casts::check(cx, e, from_ty, from_ty_adjusted, to_ty, arg);
                 }
             }
         }
diff --git a/clippy_lints/src/transmute/transmutes_expressible_as_ptr_casts.rs b/clippy_lints/src/transmute/transmutes_expressible_as_ptr_casts.rs
index b79d4e915a2..8530b43243f 100644
--- a/clippy_lints/src/transmute/transmutes_expressible_as_ptr_casts.rs
+++ b/clippy_lints/src/transmute/transmutes_expressible_as_ptr_casts.rs
@@ -1,11 +1,11 @@
-use super::utils::can_be_expressed_as_pointer_cast;
+use super::utils::check_cast;
 use super::TRANSMUTES_EXPRESSIBLE_AS_PTR_CASTS;
-use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::sugg;
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::sugg::Sugg;
 use rustc_errors::Applicability;
 use rustc_hir::Expr;
 use rustc_lint::LateContext;
-use rustc_middle::ty::Ty;
+use rustc_middle::ty::{cast::CastKind, Ty};
 
 /// Checks for `transmutes_expressible_as_ptr_casts` lint.
 /// Returns `true` if it's triggered, otherwise returns `false`.
@@ -13,24 +13,40 @@ pub(super) fn check<'tcx>(
     cx: &LateContext<'tcx>,
     e: &'tcx Expr<'_>,
     from_ty: Ty<'tcx>,
+    from_ty_adjusted: bool,
     to_ty: Ty<'tcx>,
     arg: &'tcx Expr<'_>,
 ) -> bool {
-    if can_be_expressed_as_pointer_cast(cx, e, from_ty, to_ty) {
-        span_lint_and_then(
-            cx,
-            TRANSMUTES_EXPRESSIBLE_AS_PTR_CASTS,
-            e.span,
-            &format!("transmute from `{from_ty}` to `{to_ty}` which could be expressed as a pointer cast instead"),
-            |diag| {
-                if let Some(arg) = sugg::Sugg::hir_opt(cx, arg) {
-                    let sugg = arg.as_ty(to_ty.to_string()).to_string();
-                    diag.span_suggestion(e.span, "try", sugg, Applicability::MachineApplicable);
-                }
-            },
-        );
-        true
-    } else {
-        false
-    }
+    use CastKind::{AddrPtrCast, ArrayPtrCast, FnPtrAddrCast, FnPtrPtrCast, PtrAddrCast, PtrPtrCast};
+    let mut app = Applicability::MachineApplicable;
+    let sugg = match check_cast(cx, e, from_ty, to_ty) {
+        Some(PtrPtrCast | AddrPtrCast | ArrayPtrCast | FnPtrPtrCast | FnPtrAddrCast) => {
+            Sugg::hir_with_context(cx, arg, e.span.ctxt(), "..", &mut app)
+                .as_ty(to_ty.to_string())
+                .to_string()
+        },
+        Some(PtrAddrCast) if !from_ty_adjusted => Sugg::hir_with_context(cx, arg, e.span.ctxt(), "..", &mut app)
+            .as_ty(to_ty.to_string())
+            .to_string(),
+
+        // The only adjustments here would be ref-to-ptr and unsize coercions. The result of an unsize coercions can't
+        // be transmuted to a usize. For ref-to-ptr coercions, borrows need to be cast to a pointer before being cast to
+        // a usize.
+        Some(PtrAddrCast) => format!(
+            "{} as {to_ty}",
+            Sugg::hir_with_context(cx, arg, e.span.ctxt(), "..", &mut app).as_ty(from_ty)
+        ),
+        _ => return false,
+    };
+
+    span_lint_and_sugg(
+        cx,
+        TRANSMUTES_EXPRESSIBLE_AS_PTR_CASTS,
+        e.span,
+        &format!("transmute from `{from_ty}` to `{to_ty}` which could be expressed as a pointer cast instead"),
+        "try",
+        sugg,
+        app,
+    );
+    true
 }
diff --git a/clippy_lints/src/transmute/utils.rs b/clippy_lints/src/transmute/utils.rs
index 49d863ec03f..c93f047f5da 100644
--- a/clippy_lints/src/transmute/utils.rs
+++ b/clippy_lints/src/transmute/utils.rs
@@ -20,28 +20,16 @@ pub(super) fn is_layout_incompatible<'tcx>(cx: &LateContext<'tcx>, from: Ty<'tcx
     }
 }
 
-/// Check if the type conversion can be expressed as a pointer cast, instead of
-/// a transmute. In certain cases, including some invalid casts from array
-/// references to pointers, this may cause additional errors to be emitted and/or
-/// ICE error messages. This function will panic if that occurs.
-pub(super) fn can_be_expressed_as_pointer_cast<'tcx>(
-    cx: &LateContext<'tcx>,
-    e: &'tcx Expr<'_>,
-    from_ty: Ty<'tcx>,
-    to_ty: Ty<'tcx>,
-) -> bool {
-    use CastKind::{AddrPtrCast, ArrayPtrCast, FnPtrAddrCast, FnPtrPtrCast, PtrAddrCast, PtrPtrCast};
-    matches!(
-        check_cast(cx, e, from_ty, to_ty),
-        Some(PtrPtrCast | PtrAddrCast | AddrPtrCast | ArrayPtrCast | FnPtrPtrCast | FnPtrAddrCast)
-    )
-}
-
 /// If a cast from `from_ty` to `to_ty` is valid, returns an Ok containing the kind of
 /// the cast. In certain cases, including some invalid casts from array references
 /// to pointers, this may cause additional errors to be emitted and/or ICE error
 /// messages. This function will panic if that occurs.
-fn check_cast<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>, from_ty: Ty<'tcx>, to_ty: Ty<'tcx>) -> Option<CastKind> {
+pub(super) fn check_cast<'tcx>(
+    cx: &LateContext<'tcx>,
+    e: &'tcx Expr<'_>,
+    from_ty: Ty<'tcx>,
+    to_ty: Ty<'tcx>,
+) -> Option<CastKind> {
     let hir_id = e.hir_id;
     let local_def_id = hir_id.owner.def_id;
 
diff --git a/tests/ui/transmutes_expressible_as_ptr_casts.fixed b/tests/ui/transmutes_expressible_as_ptr_casts.fixed
index 7263abac15d..55307506eb3 100644
--- a/tests/ui/transmutes_expressible_as_ptr_casts.fixed
+++ b/tests/ui/transmutes_expressible_as_ptr_casts.fixed
@@ -51,6 +51,8 @@ fn main() {
     // e is a function pointer type and U is an integer; fptr-addr-cast
     let _usize_from_fn_ptr_transmute = unsafe { foo as usize };
     let _usize_from_fn_ptr = foo as *const usize;
+
+    let _usize_from_ref = unsafe { &1u32 as *const u32 as usize };
 }
 
 // If a ref-to-ptr cast of this form where the pointer type points to a type other
diff --git a/tests/ui/transmutes_expressible_as_ptr_casts.rs b/tests/ui/transmutes_expressible_as_ptr_casts.rs
index d8e4421d4c1..e7360f3f9dc 100644
--- a/tests/ui/transmutes_expressible_as_ptr_casts.rs
+++ b/tests/ui/transmutes_expressible_as_ptr_casts.rs
@@ -51,6 +51,8 @@ fn main() {
     // e is a function pointer type and U is an integer; fptr-addr-cast
     let _usize_from_fn_ptr_transmute = unsafe { transmute::<fn(usize) -> u8, usize>(foo) };
     let _usize_from_fn_ptr = foo as *const usize;
+
+    let _usize_from_ref = unsafe { transmute::<*const u32, usize>(&1u32) };
 }
 
 // If a ref-to-ptr cast of this form where the pointer type points to a type other
diff --git a/tests/ui/transmutes_expressible_as_ptr_casts.stderr b/tests/ui/transmutes_expressible_as_ptr_casts.stderr
index de9418c8d1a..e862fcb67a4 100644
--- a/tests/ui/transmutes_expressible_as_ptr_casts.stderr
+++ b/tests/ui/transmutes_expressible_as_ptr_casts.stderr
@@ -46,11 +46,17 @@ error: transmute from `fn(usize) -> u8` to `usize` which could be expressed as a
 LL |     let _usize_from_fn_ptr_transmute = unsafe { transmute::<fn(usize) -> u8, usize>(foo) };
    |                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `foo as usize`
 
+error: transmute from `*const u32` to `usize` which could be expressed as a pointer cast instead
+  --> $DIR/transmutes_expressible_as_ptr_casts.rs:55:36
+   |
+LL |     let _usize_from_ref = unsafe { transmute::<*const u32, usize>(&1u32) };
+   |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&1u32 as *const u32 as usize`
+
 error: transmute from a reference to a pointer
-  --> $DIR/transmutes_expressible_as_ptr_casts.rs:64:14
+  --> $DIR/transmutes_expressible_as_ptr_casts.rs:66:14
    |
 LL |     unsafe { transmute::<&[i32; 1], *const u8>(in_param) }
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `in_param as *const [i32; 1] as *const u8`
 
-error: aborting due to 8 previous errors
+error: aborting due to 9 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 295225e9cdb69fa29986cd07d38fd54a16ca2aa0 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Fri, 13 Jan 2023 00:04:28 +0000
Subject: Move `unchecked_duration_subtraction` to pedantic

---
 clippy_lints/src/instant_subtraction.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/instant_subtraction.rs b/clippy_lints/src/instant_subtraction.rs
index dd1b23e7d9d..9f6e8940571 100644
--- a/clippy_lints/src/instant_subtraction.rs
+++ b/clippy_lints/src/instant_subtraction.rs
@@ -61,7 +61,7 @@ declare_clippy_lint! {
     /// [`Instant::now()`]: std::time::Instant::now;
     #[clippy::version = "1.65.0"]
     pub UNCHECKED_DURATION_SUBTRACTION,
-    suspicious,
+    pedantic,
     "finds unchecked subtraction of a 'Duration' from an 'Instant'"
 }
 
-- 
cgit 1.4.1-3-g733a5


From 2e2ae68d5a3ef0b8c0c968fd6ec4e859c77ed2f1 Mon Sep 17 00:00:00 2001
From: Tyler Weaver <maybe@tylerjw.dev>
Date: Fri, 13 Jan 2023 11:38:34 -0700
Subject: Document lint configuration values in Clippy's book

Signed-off-by: Tyler Weaver <maybe@tylerjw.dev>
---
 .github/workflows/remark.yml                       |  3 ++
 README.md                                          |  3 ++
 book/src/SUMMARY.md                                |  1 +
 book/src/configuration.md                          |  3 ++
 book/src/lint_configuration.md                     | 52 ++++++++++++++++++
 .../src/utils/internal_lints/metadata_collector.rs | 62 +++++++++++++++++++---
 6 files changed, 118 insertions(+), 6 deletions(-)
 create mode 100644 book/src/lint_configuration.md

(limited to 'clippy_lints/src')

diff --git a/.github/workflows/remark.yml b/.github/workflows/remark.yml
index 81ef072bbb0..22925a753df 100644
--- a/.github/workflows/remark.yml
+++ b/.github/workflows/remark.yml
@@ -33,6 +33,9 @@ jobs:
         echo `pwd`/mdbook >> $GITHUB_PATH
 
     # Run
+    - name: cargo collect-metadata
+      run: cargo collect-metadata
+      
     - name: Check *.md files
       run: git ls-files -z '*.md' | xargs -0 -n 1 -I {} ./node_modules/.bin/remark {} -u lint -f > /dev/null
 
diff --git a/README.md b/README.md
index c78ae06765d..2ba095368eb 100644
--- a/README.md
+++ b/README.md
@@ -199,6 +199,9 @@ disallowed-names = ["toto", "tata", "titi"]
 See the [list of configurable lints](https://rust-lang.github.io/rust-clippy/master/index.html#Configuration),
 the lint descriptions contain the names and meanings of these configuration variables.
 
+See [table of lint configurations](https://doc.rust-lang.org/nightly/clippy/lint_configuration.html)
+to see what configuration options you can set and the lints they configure.
+
 For configurations that are a list type with default values such as
 [disallowed-names](https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_names),
 you can use the unique value `".."` to extend the default values instead of replacing them.
diff --git a/book/src/SUMMARY.md b/book/src/SUMMARY.md
index 1f0b8db28a1..0649f7a631d 100644
--- a/book/src/SUMMARY.md
+++ b/book/src/SUMMARY.md
@@ -5,6 +5,7 @@
 - [Installation](installation.md)
 - [Usage](usage.md)
 - [Configuration](configuration.md)
+    - [Lint Configuration](lint_configuration.md)
 - [Clippy's Lints](lints.md)
 - [Continuous Integration](continuous_integration/README.md)
     - [GitHub Actions](continuous_integration/github_actions.md)
diff --git a/book/src/configuration.md b/book/src/configuration.md
index fac3e438c54..e68f30be43c 100644
--- a/book/src/configuration.md
+++ b/book/src/configuration.md
@@ -13,6 +13,9 @@ disallowed-names = ["toto", "tata", "titi"]
 See the [list of configurable lints](https://rust-lang.github.io/rust-clippy/master/index.html#Configuration),
 the lint descriptions contain the names and meanings of these configuration variables.
 
+See [table of lint configurations](./lint_configuration.md)
+to see what configuration options you can set and the lints they configure.
+
 For configurations that are a list type with default values such as
 [disallowed-names](https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_names),
 you can use the unique value `".."` to extend the default values instead of replacing them.
diff --git a/book/src/lint_configuration.md b/book/src/lint_configuration.md
new file mode 100644
index 00000000000..102ed7ad2ce
--- /dev/null
+++ b/book/src/lint_configuration.md
@@ -0,0 +1,52 @@
+## Configuration Options
+
+| Option | Default | Description | Lints |
+|--|--|--|--|
+| arithmetic-side-effects-allowed | `{}` | Suppress checking of the passed type names in all types of operations | [arithmetic_side_effects](https://rust-lang.github.io/rust-clippy/master/index.html#arithmetic_side_effects) |
+| arithmetic-side-effects-allowed-binary | `[]` | Suppress checking of the passed type pair names in binary operations like addition or multiplication | [arithmetic_side_effects](https://rust-lang.github.io/rust-clippy/master/index.html#arithmetic_side_effects) |
+| arithmetic-side-effects-allowed-unary | `{}` | Suppress checking of the passed type names in unary operations like "negation" (`-`) | [arithmetic_side_effects](https://rust-lang.github.io/rust-clippy/master/index.html#arithmetic_side_effects) |
+| avoid-breaking-exported-api | `true` | Suppress lints whenever the suggested change would cause breakage for other crates | [enum_variant_names](https://rust-lang.github.io/rust-clippy/master/index.html#enum_variant_names) [large_types_passed_by_value](https://rust-lang.github.io/rust-clippy/master/index.html#large_types_passed_by_value) [trivially_copy_pass_by_ref](https://rust-lang.github.io/rust-clippy/master/index.html#trivially_copy_pass_by_ref) [unnecessary_wraps](https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_wraps) [unused_self](https://rust-lang.github.io/rust-clippy/master/index.html#unused_self) [upper_case_acronyms](https://rust-lang.github.io/rust-clippy/master/index.html#upper_case_acronyms) [wrong_self_convention](https://rust-lang.github.io/rust-clippy/master/index.html#wrong_self_convention) [box_collection](https://rust-lang.github.io/rust-clippy/master/index.html#box_collection) [redundant_allocation](https://rust-lang.github.io/rust-clippy/master/index.html#redundant_allocation) [rc_buffer](https://rust-lang.github.io/rust-clippy/master/index.html#rc_buffer) [vec_box](https://rust-lang.github.io/rust-clippy/master/index.html#vec_box) [option_option](https://rust-lang.github.io/rust-clippy/master/index.html#option_option) [linkedlist](https://rust-lang.github.io/rust-clippy/master/index.html#linkedlist) [rc_mutex](https://rust-lang.github.io/rust-clippy/master/index.html#rc_mutex) |
+| msrv | `None` | The minimum rust version that the project supports | [manual_split_once](https://rust-lang.github.io/rust-clippy/master/index.html#manual_split_once) [manual_str_repeat](https://rust-lang.github.io/rust-clippy/master/index.html#manual_str_repeat) [cloned_instead_of_copied](https://rust-lang.github.io/rust-clippy/master/index.html#cloned_instead_of_copied) [redundant_field_names](https://rust-lang.github.io/rust-clippy/master/index.html#redundant_field_names) [redundant_static_lifetimes](https://rust-lang.github.io/rust-clippy/master/index.html#redundant_static_lifetimes) [filter_map_next](https://rust-lang.github.io/rust-clippy/master/index.html#filter_map_next) [checked_conversions](https://rust-lang.github.io/rust-clippy/master/index.html#checked_conversions) [manual_range_contains](https://rust-lang.github.io/rust-clippy/master/index.html#manual_range_contains) [use_self](https://rust-lang.github.io/rust-clippy/master/index.html#use_self) [mem_replace_with_default](https://rust-lang.github.io/rust-clippy/master/index.html#mem_replace_with_default) [manual_non_exhaustive](https://rust-lang.github.io/rust-clippy/master/index.html#manual_non_exhaustive) [option_as_ref_deref](https://rust-lang.github.io/rust-clippy/master/index.html#option_as_ref_deref) [map_unwrap_or](https://rust-lang.github.io/rust-clippy/master/index.html#map_unwrap_or) [match_like_matches_macro](https://rust-lang.github.io/rust-clippy/master/index.html#match_like_matches_macro) [manual_strip](https://rust-lang.github.io/rust-clippy/master/index.html#manual_strip) [missing_const_for_fn](https://rust-lang.github.io/rust-clippy/master/index.html#missing_const_for_fn) [unnested_or_patterns](https://rust-lang.github.io/rust-clippy/master/index.html#unnested_or_patterns) [from_over_into](https://rust-lang.github.io/rust-clippy/master/index.html#from_over_into) [ptr_as_ptr](https://rust-lang.github.io/rust-clippy/master/index.html#ptr_as_ptr) [if_then_some_else_none](https://rust-lang.github.io/rust-clippy/master/index.html#if_then_some_else_none) [approx_constant](https://rust-lang.github.io/rust-clippy/master/index.html#approx_constant) [deprecated_cfg_attr](https://rust-lang.github.io/rust-clippy/master/index.html#deprecated_cfg_attr) [index_refutable_slice](https://rust-lang.github.io/rust-clippy/master/index.html#index_refutable_slice) [map_clone](https://rust-lang.github.io/rust-clippy/master/index.html#map_clone) [borrow_as_ptr](https://rust-lang.github.io/rust-clippy/master/index.html#borrow_as_ptr) [manual_bits](https://rust-lang.github.io/rust-clippy/master/index.html#manual_bits) [err_expect](https://rust-lang.github.io/rust-clippy/master/index.html#err_expect) [cast_abs_to_unsigned](https://rust-lang.github.io/rust-clippy/master/index.html#cast_abs_to_unsigned) [uninlined_format_args](https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args) [manual_clamp](https://rust-lang.github.io/rust-clippy/master/index.html#manual_clamp) [manual_let_else](https://rust-lang.github.io/rust-clippy/master/index.html#manual_let_else) [unchecked_duration_subtraction](https://rust-lang.github.io/rust-clippy/master/index.html#unchecked_duration_subtraction) |
+| cognitive-complexity-threshold | `25` | The maximum cognitive complexity a function can have | [cognitive_complexity](https://rust-lang.github.io/rust-clippy/master/index.html#cognitive_complexity) |
+| disallowed-names | `["foo", "baz", "quux"]` | The list of disallowed names to lint about | [disallowed_names](https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_names) |
+| doc-valid-idents | `["KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "DirectX", "ECMAScript", "GPLv2", "GPLv3", "GitHub", "GitLab", "IPv4", "IPv6", "ClojureScript", "CoffeeScript", "JavaScript", "PureScript", "TypeScript", "NaN", "NaNs", "OAuth", "GraphQL", "OCaml", "OpenGL", "OpenMP", "OpenSSH", "OpenSSL", "OpenStreetMap", "OpenDNS", "WebGL", "TensorFlow", "TrueType", "iOS", "macOS", "FreeBSD", "TeX", "LaTeX", "BibTeX", "BibLaTeX", "MinGW", "CamelCase"]` | The list of words this lint should not consider as identifiers needing ticks | [doc_markdown](https://rust-lang.github.io/rust-clippy/master/index.html#doc_markdown) |
+| too-many-arguments-threshold | `7` | The maximum number of argument a function or method can have | [too_many_arguments](https://rust-lang.github.io/rust-clippy/master/index.html#too_many_arguments) |
+| type-complexity-threshold | `250` | The maximum complexity a type can have | [type_complexity](https://rust-lang.github.io/rust-clippy/master/index.html#type_complexity) |
+| single-char-binding-names-threshold | `4` | The maximum number of single char bindings a scope may have | [many_single_char_names](https://rust-lang.github.io/rust-clippy/master/index.html#many_single_char_names) |
+| too-large-for-stack | `200` | The maximum size of objects (in bytes) that will be linted | [boxed_local](https://rust-lang.github.io/rust-clippy/master/index.html#boxed_local) [useless_vec](https://rust-lang.github.io/rust-clippy/master/index.html#useless_vec) |
+| enum-variant-name-threshold | `3` | The minimum number of enum variants for the lints about variant names to trigger | [enum_variant_names](https://rust-lang.github.io/rust-clippy/master/index.html#enum_variant_names) |
+| enum-variant-size-threshold | `200` | The maximum size of an enum's variant to avoid box suggestion | [large_enum_variant](https://rust-lang.github.io/rust-clippy/master/index.html#large_enum_variant) |
+| verbose-bit-mask-threshold | `1` | The maximum allowed size of a bit mask before suggesting to use 'trailing_zeros' | [verbose_bit_mask](https://rust-lang.github.io/rust-clippy/master/index.html#verbose_bit_mask) |
+| literal-representation-threshold | `16384` | The lower bound for linting decimal literals | [decimal_literal_representation](https://rust-lang.github.io/rust-clippy/master/index.html#decimal_literal_representation) |
+| trivial-copy-size-limit | `None` | The maximum size (in bytes) to consider a `Copy` type for passing by value instead of by reference | [trivially_copy_pass_by_ref](https://rust-lang.github.io/rust-clippy/master/index.html#trivially_copy_pass_by_ref) |
+| pass-by-value-size-limit | `256` | The minimum size (in bytes) to consider a type for passing by reference instead of by value | [large_type_pass_by_move](https://rust-lang.github.io/rust-clippy/master/index.html#large_type_pass_by_move) |
+| too-many-lines-threshold | `100` | The maximum number of lines a function or method can have | [too_many_lines](https://rust-lang.github.io/rust-clippy/master/index.html#too_many_lines) |
+| array-size-threshold | `512000` | The maximum allowed size for arrays on the stack | [large_stack_arrays](https://rust-lang.github.io/rust-clippy/master/index.html#large_stack_arrays) [large_const_arrays](https://rust-lang.github.io/rust-clippy/master/index.html#large_const_arrays) |
+| vec-box-size-threshold | `4096` | The size of the boxed type in bytes, where boxing in a `Vec` is allowed | [vec_box](https://rust-lang.github.io/rust-clippy/master/index.html#vec_box) |
+| max-trait-bounds | `3` | The maximum number of bounds a trait can have to be linted | [type_repetition_in_bounds](https://rust-lang.github.io/rust-clippy/master/index.html#type_repetition_in_bounds) |
+| max-struct-bools | `3` | The maximum number of bool fields a struct can have | [struct_excessive_bools](https://rust-lang.github.io/rust-clippy/master/index.html#struct_excessive_bools) |
+| max-fn-params-bools | `3` | The maximum number of bool parameters a function can have | [fn_params_excessive_bools](https://rust-lang.github.io/rust-clippy/master/index.html#fn_params_excessive_bools) |
+| warn-on-all-wildcard-imports | `false` | Whether to allow certain wildcard imports (prelude, super in tests) | [wildcard_imports](https://rust-lang.github.io/rust-clippy/master/index.html#wildcard_imports) |
+| disallowed-macros | `[]` | The list of disallowed macros, written as fully qualified paths | [disallowed_macros](https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_macros) |
+| disallowed-methods | `[]` | The list of disallowed methods, written as fully qualified paths | [disallowed_methods](https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_methods) |
+| disallowed-types | `[]` | The list of disallowed types, written as fully qualified paths | [disallowed_types](https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_types) |
+| unreadable-literal-lint-fractions | `true` | Should the fraction of a decimal be linted to include separators | [unreadable_literal](https://rust-lang.github.io/rust-clippy/master/index.html#unreadable_literal) |
+| upper-case-acronyms-aggressive | `false` | Enables verbose mode | [upper_case_acronyms](https://rust-lang.github.io/rust-clippy/master/index.html#upper_case_acronyms) |
+| matches-for-let-else | `WellKnownTypes` | Whether the matches should be considered by the lint, and whether there should be filtering for common types | [manual_let_else](https://rust-lang.github.io/rust-clippy/master/index.html#manual_let_else) |
+| cargo-ignore-publish | `false` | For internal testing only, ignores the current `publish` settings in the Cargo manifest | [_cargo_common_metadata](https://rust-lang.github.io/rust-clippy/master/index.html#_cargo_common_metadata) |
+| standard-macro-braces | `[]` | Enforce the named macros always use the braces specified | [nonstandard_macro_braces](https://rust-lang.github.io/rust-clippy/master/index.html#nonstandard_macro_braces) |
+| enforced-import-renames | `[]` | The list of imports to always rename, a fully qualified path followed by the rename | [missing_enforced_import_renames](https://rust-lang.github.io/rust-clippy/master/index.html#missing_enforced_import_renames) |
+| allowed-scripts | `["Latin"]` | The list of unicode scripts allowed to be used in the scope | [disallowed_script_idents](https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_script_idents) |
+| enable-raw-pointer-heuristic-for-send | `true` | Whether to apply the raw pointer heuristic to determine if a type is `Send` | [non_send_fields_in_send_ty](https://rust-lang.github.io/rust-clippy/master/index.html#non_send_fields_in_send_ty) |
+| max-suggested-slice-pattern-length | `3` | When Clippy suggests using a slice pattern, this is the maximum number of elements allowed in the slice pattern that is suggested | [index_refutable_slice](https://rust-lang.github.io/rust-clippy/master/index.html#index_refutable_slice) |
+| await-holding-invalid-types | `[]` | [ERROR] MALFORMED DOC COMMENT |  |
+| max-include-file-size | `1000000` | The maximum size of a file included via `include_bytes!()` or `include_str!()`, in bytes | [large_include_file](https://rust-lang.github.io/rust-clippy/master/index.html#large_include_file) |
+| allow-expect-in-tests | `false` | Whether `expect` should be allowed within `#[cfg(test)]` | [expect_used](https://rust-lang.github.io/rust-clippy/master/index.html#expect_used) |
+| allow-unwrap-in-tests | `false` | Whether `unwrap` should be allowed in test cfg | [unwrap_used](https://rust-lang.github.io/rust-clippy/master/index.html#unwrap_used) |
+| allow-dbg-in-tests | `false` | Whether `dbg!` should be allowed in test functions | [dbg_macro](https://rust-lang.github.io/rust-clippy/master/index.html#dbg_macro) |
+| allow-print-in-tests | `false` | Whether print macros (ex | [print_stdout](https://rust-lang.github.io/rust-clippy/master/index.html#print_stdout) [print_stderr](https://rust-lang.github.io/rust-clippy/master/index.html#print_stderr) |
+| large-error-threshold | `128` | The maximum size of the `Err`-variant in a `Result` returned from a function | [result_large_err](https://rust-lang.github.io/rust-clippy/master/index.html#result_large_err) |
+| ignore-interior-mutability | `["bytes::Bytes"]` | A list of paths to types that should be treated like `Arc`, i | [mutable_key](https://rust-lang.github.io/rust-clippy/master/index.html#mutable_key) |
+| allow-mixed-uninlined-format-args | `true` | Whether to allow mixed uninlined format args, e | [uninlined_format_args](https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args) |
+| suppress-restriction-lint-in-const | `false` | In same cases the restructured operation might not be unavoidable, as the suggested counterparts are unavailable in constant code | [indexing_slicing](https://rust-lang.github.io/rust-clippy/master/index.html#indexing_slicing) |
+
diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index 929544cd69d..c74f3b6e3ad 100644
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -14,6 +14,7 @@ use clippy_utils::diagnostics::span_lint;
 use clippy_utils::ty::{match_type, walk_ptrs_ty_depth};
 use clippy_utils::{last_path_segment, match_def_path, match_function_call, match_path, paths};
 use if_chain::if_chain;
+use itertools::Itertools;
 use rustc_ast as ast;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_hir::{
@@ -34,8 +35,10 @@ use std::path::Path;
 use std::path::PathBuf;
 use std::process::Command;
 
-/// This is the output file of the lint collector.
-const OUTPUT_FILE: &str = "../util/gh-pages/lints.json";
+/// This is the json output file of the lint collector.
+const JSON_OUTPUT_FILE: &str = "../util/gh-pages/lints.json";
+/// This is the markdown output file of the lint collector.
+const MARKDOWN_OUTPUT_FILE: &str = "../book/src/lint_configuration.md";
 /// These lints are excluded from the export.
 const BLACK_LISTED_LINTS: &[&str] = &["lint_author", "dump_hir", "internal_metadata_collector"];
 /// These groups will be ignored by the lint group matcher. This is useful for collections like
@@ -176,6 +179,14 @@ This lint has the following configuration variables:
                 )
             })
     }
+
+    fn get_markdown_table(&self) -> String {
+        self.config
+            .iter()
+            .filter(|config| config.deprecation_reason.is_none())
+            .map(ClippyConfiguration::to_markdown_table_entry)
+            .join("\n")
+    }
 }
 
 impl Drop for MetadataCollector {
@@ -199,12 +210,32 @@ impl Drop for MetadataCollector {
 
         collect_renames(&mut lints);
 
-        // Outputting
-        if Path::new(OUTPUT_FILE).exists() {
-            fs::remove_file(OUTPUT_FILE).unwrap();
+        // Outputting json
+        if Path::new(JSON_OUTPUT_FILE).exists() {
+            fs::remove_file(JSON_OUTPUT_FILE).unwrap();
         }
-        let mut file = OpenOptions::new().write(true).create(true).open(OUTPUT_FILE).unwrap();
+        let mut file = OpenOptions::new()
+            .write(true)
+            .create(true)
+            .open(JSON_OUTPUT_FILE)
+            .unwrap();
         writeln!(file, "{}", serde_json::to_string_pretty(&lints).unwrap()).unwrap();
+
+        // Outputting markdown
+        if Path::new(MARKDOWN_OUTPUT_FILE).exists() {
+            fs::remove_file(MARKDOWN_OUTPUT_FILE).unwrap();
+        }
+        let mut file = OpenOptions::new()
+            .write(true)
+            .create(true)
+            .open(MARKDOWN_OUTPUT_FILE)
+            .unwrap();
+        writeln!(
+            file,
+            "## Lint Configuration\n\n| Option | Default | Description | Lints |\n|--|--|--|--|\n{}\n",
+            self.get_markdown_table()
+        )
+        .unwrap();
     }
 }
 
@@ -505,6 +536,25 @@ impl ClippyConfiguration {
             deprecation_reason,
         }
     }
+
+    fn to_markdown_table_entry(&self) -> String {
+        format!(
+            "| {} | `{}` | {} | {} |",
+            self.name,
+            self.default,
+            self.doc
+                .split('.')
+                .next()
+                .unwrap_or("")
+                .replace('|', "\\|")
+                .replace("\n    ", " "),
+            self.lints
+                .iter()
+                .map(|name| name.to_string().split_whitespace().next().unwrap().to_string())
+                .map(|name| format!("[{name}](https://rust-lang.github.io/rust-clippy/master/index.html#{name})"))
+                .join(" ")
+        )
+    }
 }
 
 fn collect_configs() -> Vec<ClippyConfiguration> {
-- 
cgit 1.4.1-3-g733a5


From 7d1609dce356b9b603702f1ba0011f2fee949787 Mon Sep 17 00:00:00 2001
From: Tyler Weaver <maybe@tylerjw.dev>
Date: Fri, 13 Jan 2023 15:32:04 -0700
Subject: Document configurations in table and paragraphs

Signed-off-by: Tyler Weaver <maybe@tylerjw.dev>
---
 README.md                                          |   9 +-
 book/src/configuration.md                          |   9 +-
 book/src/lint_configuration.md                     | 568 +++++++++++++++++++--
 clippy_lints/src/utils/conf.rs                     |   3 +-
 .../src/utils/internal_lints/metadata_collector.rs |  43 +-
 5 files changed, 552 insertions(+), 80 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/README.md b/README.md
index 2ba095368eb..ab44db69483 100644
--- a/README.md
+++ b/README.md
@@ -196,11 +196,10 @@ avoid-breaking-exported-api = false
 disallowed-names = ["toto", "tata", "titi"]
 ```
 
-See the [list of configurable lints](https://rust-lang.github.io/rust-clippy/master/index.html#Configuration),
-the lint descriptions contain the names and meanings of these configuration variables.
-
-See [table of lint configurations](https://doc.rust-lang.org/nightly/clippy/lint_configuration.html)
-to see what configuration options you can set and the lints they configure.
+The [table of configurations](https://doc.rust-lang.org/nightly/clippy/lint_configuration.html)
+contains all config values, their default, and a list of lints they affect.
+Each [configurable lint](https://rust-lang.github.io/rust-clippy/master/index.html#Configuration)
+, also contains information about these values.
 
 For configurations that are a list type with default values such as
 [disallowed-names](https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_names),
diff --git a/book/src/configuration.md b/book/src/configuration.md
index e68f30be43c..87f4a697af9 100644
--- a/book/src/configuration.md
+++ b/book/src/configuration.md
@@ -10,11 +10,10 @@ avoid-breaking-exported-api = false
 disallowed-names = ["toto", "tata", "titi"]
 ```
 
-See the [list of configurable lints](https://rust-lang.github.io/rust-clippy/master/index.html#Configuration),
-the lint descriptions contain the names and meanings of these configuration variables.
-
-See [table of lint configurations](./lint_configuration.md)
-to see what configuration options you can set and the lints they configure.
+The [table of configurations](./lint_configuration.md)
+contains all config values, their default, and a list of lints they affect.
+Each [configurable lint](https://rust-lang.github.io/rust-clippy/master/index.html#Configuration)
+, also contains information about these values.
 
 For configurations that are a list type with default values such as
 [disallowed-names](https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_names),
diff --git a/book/src/lint_configuration.md b/book/src/lint_configuration.md
index 102ed7ad2ce..cfaaefe3ea1 100644
--- a/book/src/lint_configuration.md
+++ b/book/src/lint_configuration.md
@@ -1,52 +1,518 @@
-## Configuration Options
-
-| Option | Default | Description | Lints |
-|--|--|--|--|
-| arithmetic-side-effects-allowed | `{}` | Suppress checking of the passed type names in all types of operations | [arithmetic_side_effects](https://rust-lang.github.io/rust-clippy/master/index.html#arithmetic_side_effects) |
-| arithmetic-side-effects-allowed-binary | `[]` | Suppress checking of the passed type pair names in binary operations like addition or multiplication | [arithmetic_side_effects](https://rust-lang.github.io/rust-clippy/master/index.html#arithmetic_side_effects) |
-| arithmetic-side-effects-allowed-unary | `{}` | Suppress checking of the passed type names in unary operations like "negation" (`-`) | [arithmetic_side_effects](https://rust-lang.github.io/rust-clippy/master/index.html#arithmetic_side_effects) |
-| avoid-breaking-exported-api | `true` | Suppress lints whenever the suggested change would cause breakage for other crates | [enum_variant_names](https://rust-lang.github.io/rust-clippy/master/index.html#enum_variant_names) [large_types_passed_by_value](https://rust-lang.github.io/rust-clippy/master/index.html#large_types_passed_by_value) [trivially_copy_pass_by_ref](https://rust-lang.github.io/rust-clippy/master/index.html#trivially_copy_pass_by_ref) [unnecessary_wraps](https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_wraps) [unused_self](https://rust-lang.github.io/rust-clippy/master/index.html#unused_self) [upper_case_acronyms](https://rust-lang.github.io/rust-clippy/master/index.html#upper_case_acronyms) [wrong_self_convention](https://rust-lang.github.io/rust-clippy/master/index.html#wrong_self_convention) [box_collection](https://rust-lang.github.io/rust-clippy/master/index.html#box_collection) [redundant_allocation](https://rust-lang.github.io/rust-clippy/master/index.html#redundant_allocation) [rc_buffer](https://rust-lang.github.io/rust-clippy/master/index.html#rc_buffer) [vec_box](https://rust-lang.github.io/rust-clippy/master/index.html#vec_box) [option_option](https://rust-lang.github.io/rust-clippy/master/index.html#option_option) [linkedlist](https://rust-lang.github.io/rust-clippy/master/index.html#linkedlist) [rc_mutex](https://rust-lang.github.io/rust-clippy/master/index.html#rc_mutex) |
-| msrv | `None` | The minimum rust version that the project supports | [manual_split_once](https://rust-lang.github.io/rust-clippy/master/index.html#manual_split_once) [manual_str_repeat](https://rust-lang.github.io/rust-clippy/master/index.html#manual_str_repeat) [cloned_instead_of_copied](https://rust-lang.github.io/rust-clippy/master/index.html#cloned_instead_of_copied) [redundant_field_names](https://rust-lang.github.io/rust-clippy/master/index.html#redundant_field_names) [redundant_static_lifetimes](https://rust-lang.github.io/rust-clippy/master/index.html#redundant_static_lifetimes) [filter_map_next](https://rust-lang.github.io/rust-clippy/master/index.html#filter_map_next) [checked_conversions](https://rust-lang.github.io/rust-clippy/master/index.html#checked_conversions) [manual_range_contains](https://rust-lang.github.io/rust-clippy/master/index.html#manual_range_contains) [use_self](https://rust-lang.github.io/rust-clippy/master/index.html#use_self) [mem_replace_with_default](https://rust-lang.github.io/rust-clippy/master/index.html#mem_replace_with_default) [manual_non_exhaustive](https://rust-lang.github.io/rust-clippy/master/index.html#manual_non_exhaustive) [option_as_ref_deref](https://rust-lang.github.io/rust-clippy/master/index.html#option_as_ref_deref) [map_unwrap_or](https://rust-lang.github.io/rust-clippy/master/index.html#map_unwrap_or) [match_like_matches_macro](https://rust-lang.github.io/rust-clippy/master/index.html#match_like_matches_macro) [manual_strip](https://rust-lang.github.io/rust-clippy/master/index.html#manual_strip) [missing_const_for_fn](https://rust-lang.github.io/rust-clippy/master/index.html#missing_const_for_fn) [unnested_or_patterns](https://rust-lang.github.io/rust-clippy/master/index.html#unnested_or_patterns) [from_over_into](https://rust-lang.github.io/rust-clippy/master/index.html#from_over_into) [ptr_as_ptr](https://rust-lang.github.io/rust-clippy/master/index.html#ptr_as_ptr) [if_then_some_else_none](https://rust-lang.github.io/rust-clippy/master/index.html#if_then_some_else_none) [approx_constant](https://rust-lang.github.io/rust-clippy/master/index.html#approx_constant) [deprecated_cfg_attr](https://rust-lang.github.io/rust-clippy/master/index.html#deprecated_cfg_attr) [index_refutable_slice](https://rust-lang.github.io/rust-clippy/master/index.html#index_refutable_slice) [map_clone](https://rust-lang.github.io/rust-clippy/master/index.html#map_clone) [borrow_as_ptr](https://rust-lang.github.io/rust-clippy/master/index.html#borrow_as_ptr) [manual_bits](https://rust-lang.github.io/rust-clippy/master/index.html#manual_bits) [err_expect](https://rust-lang.github.io/rust-clippy/master/index.html#err_expect) [cast_abs_to_unsigned](https://rust-lang.github.io/rust-clippy/master/index.html#cast_abs_to_unsigned) [uninlined_format_args](https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args) [manual_clamp](https://rust-lang.github.io/rust-clippy/master/index.html#manual_clamp) [manual_let_else](https://rust-lang.github.io/rust-clippy/master/index.html#manual_let_else) [unchecked_duration_subtraction](https://rust-lang.github.io/rust-clippy/master/index.html#unchecked_duration_subtraction) |
-| cognitive-complexity-threshold | `25` | The maximum cognitive complexity a function can have | [cognitive_complexity](https://rust-lang.github.io/rust-clippy/master/index.html#cognitive_complexity) |
-| disallowed-names | `["foo", "baz", "quux"]` | The list of disallowed names to lint about | [disallowed_names](https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_names) |
-| doc-valid-idents | `["KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "DirectX", "ECMAScript", "GPLv2", "GPLv3", "GitHub", "GitLab", "IPv4", "IPv6", "ClojureScript", "CoffeeScript", "JavaScript", "PureScript", "TypeScript", "NaN", "NaNs", "OAuth", "GraphQL", "OCaml", "OpenGL", "OpenMP", "OpenSSH", "OpenSSL", "OpenStreetMap", "OpenDNS", "WebGL", "TensorFlow", "TrueType", "iOS", "macOS", "FreeBSD", "TeX", "LaTeX", "BibTeX", "BibLaTeX", "MinGW", "CamelCase"]` | The list of words this lint should not consider as identifiers needing ticks | [doc_markdown](https://rust-lang.github.io/rust-clippy/master/index.html#doc_markdown) |
-| too-many-arguments-threshold | `7` | The maximum number of argument a function or method can have | [too_many_arguments](https://rust-lang.github.io/rust-clippy/master/index.html#too_many_arguments) |
-| type-complexity-threshold | `250` | The maximum complexity a type can have | [type_complexity](https://rust-lang.github.io/rust-clippy/master/index.html#type_complexity) |
-| single-char-binding-names-threshold | `4` | The maximum number of single char bindings a scope may have | [many_single_char_names](https://rust-lang.github.io/rust-clippy/master/index.html#many_single_char_names) |
-| too-large-for-stack | `200` | The maximum size of objects (in bytes) that will be linted | [boxed_local](https://rust-lang.github.io/rust-clippy/master/index.html#boxed_local) [useless_vec](https://rust-lang.github.io/rust-clippy/master/index.html#useless_vec) |
-| enum-variant-name-threshold | `3` | The minimum number of enum variants for the lints about variant names to trigger | [enum_variant_names](https://rust-lang.github.io/rust-clippy/master/index.html#enum_variant_names) |
-| enum-variant-size-threshold | `200` | The maximum size of an enum's variant to avoid box suggestion | [large_enum_variant](https://rust-lang.github.io/rust-clippy/master/index.html#large_enum_variant) |
-| verbose-bit-mask-threshold | `1` | The maximum allowed size of a bit mask before suggesting to use 'trailing_zeros' | [verbose_bit_mask](https://rust-lang.github.io/rust-clippy/master/index.html#verbose_bit_mask) |
-| literal-representation-threshold | `16384` | The lower bound for linting decimal literals | [decimal_literal_representation](https://rust-lang.github.io/rust-clippy/master/index.html#decimal_literal_representation) |
-| trivial-copy-size-limit | `None` | The maximum size (in bytes) to consider a `Copy` type for passing by value instead of by reference | [trivially_copy_pass_by_ref](https://rust-lang.github.io/rust-clippy/master/index.html#trivially_copy_pass_by_ref) |
-| pass-by-value-size-limit | `256` | The minimum size (in bytes) to consider a type for passing by reference instead of by value | [large_type_pass_by_move](https://rust-lang.github.io/rust-clippy/master/index.html#large_type_pass_by_move) |
-| too-many-lines-threshold | `100` | The maximum number of lines a function or method can have | [too_many_lines](https://rust-lang.github.io/rust-clippy/master/index.html#too_many_lines) |
-| array-size-threshold | `512000` | The maximum allowed size for arrays on the stack | [large_stack_arrays](https://rust-lang.github.io/rust-clippy/master/index.html#large_stack_arrays) [large_const_arrays](https://rust-lang.github.io/rust-clippy/master/index.html#large_const_arrays) |
-| vec-box-size-threshold | `4096` | The size of the boxed type in bytes, where boxing in a `Vec` is allowed | [vec_box](https://rust-lang.github.io/rust-clippy/master/index.html#vec_box) |
-| max-trait-bounds | `3` | The maximum number of bounds a trait can have to be linted | [type_repetition_in_bounds](https://rust-lang.github.io/rust-clippy/master/index.html#type_repetition_in_bounds) |
-| max-struct-bools | `3` | The maximum number of bool fields a struct can have | [struct_excessive_bools](https://rust-lang.github.io/rust-clippy/master/index.html#struct_excessive_bools) |
-| max-fn-params-bools | `3` | The maximum number of bool parameters a function can have | [fn_params_excessive_bools](https://rust-lang.github.io/rust-clippy/master/index.html#fn_params_excessive_bools) |
-| warn-on-all-wildcard-imports | `false` | Whether to allow certain wildcard imports (prelude, super in tests) | [wildcard_imports](https://rust-lang.github.io/rust-clippy/master/index.html#wildcard_imports) |
-| disallowed-macros | `[]` | The list of disallowed macros, written as fully qualified paths | [disallowed_macros](https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_macros) |
-| disallowed-methods | `[]` | The list of disallowed methods, written as fully qualified paths | [disallowed_methods](https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_methods) |
-| disallowed-types | `[]` | The list of disallowed types, written as fully qualified paths | [disallowed_types](https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_types) |
-| unreadable-literal-lint-fractions | `true` | Should the fraction of a decimal be linted to include separators | [unreadable_literal](https://rust-lang.github.io/rust-clippy/master/index.html#unreadable_literal) |
-| upper-case-acronyms-aggressive | `false` | Enables verbose mode | [upper_case_acronyms](https://rust-lang.github.io/rust-clippy/master/index.html#upper_case_acronyms) |
-| matches-for-let-else | `WellKnownTypes` | Whether the matches should be considered by the lint, and whether there should be filtering for common types | [manual_let_else](https://rust-lang.github.io/rust-clippy/master/index.html#manual_let_else) |
-| cargo-ignore-publish | `false` | For internal testing only, ignores the current `publish` settings in the Cargo manifest | [_cargo_common_metadata](https://rust-lang.github.io/rust-clippy/master/index.html#_cargo_common_metadata) |
-| standard-macro-braces | `[]` | Enforce the named macros always use the braces specified | [nonstandard_macro_braces](https://rust-lang.github.io/rust-clippy/master/index.html#nonstandard_macro_braces) |
-| enforced-import-renames | `[]` | The list of imports to always rename, a fully qualified path followed by the rename | [missing_enforced_import_renames](https://rust-lang.github.io/rust-clippy/master/index.html#missing_enforced_import_renames) |
-| allowed-scripts | `["Latin"]` | The list of unicode scripts allowed to be used in the scope | [disallowed_script_idents](https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_script_idents) |
-| enable-raw-pointer-heuristic-for-send | `true` | Whether to apply the raw pointer heuristic to determine if a type is `Send` | [non_send_fields_in_send_ty](https://rust-lang.github.io/rust-clippy/master/index.html#non_send_fields_in_send_ty) |
-| max-suggested-slice-pattern-length | `3` | When Clippy suggests using a slice pattern, this is the maximum number of elements allowed in the slice pattern that is suggested | [index_refutable_slice](https://rust-lang.github.io/rust-clippy/master/index.html#index_refutable_slice) |
-| await-holding-invalid-types | `[]` | [ERROR] MALFORMED DOC COMMENT |  |
-| max-include-file-size | `1000000` | The maximum size of a file included via `include_bytes!()` or `include_str!()`, in bytes | [large_include_file](https://rust-lang.github.io/rust-clippy/master/index.html#large_include_file) |
-| allow-expect-in-tests | `false` | Whether `expect` should be allowed within `#[cfg(test)]` | [expect_used](https://rust-lang.github.io/rust-clippy/master/index.html#expect_used) |
-| allow-unwrap-in-tests | `false` | Whether `unwrap` should be allowed in test cfg | [unwrap_used](https://rust-lang.github.io/rust-clippy/master/index.html#unwrap_used) |
-| allow-dbg-in-tests | `false` | Whether `dbg!` should be allowed in test functions | [dbg_macro](https://rust-lang.github.io/rust-clippy/master/index.html#dbg_macro) |
-| allow-print-in-tests | `false` | Whether print macros (ex | [print_stdout](https://rust-lang.github.io/rust-clippy/master/index.html#print_stdout) [print_stderr](https://rust-lang.github.io/rust-clippy/master/index.html#print_stderr) |
-| large-error-threshold | `128` | The maximum size of the `Err`-variant in a `Result` returned from a function | [result_large_err](https://rust-lang.github.io/rust-clippy/master/index.html#result_large_err) |
-| ignore-interior-mutability | `["bytes::Bytes"]` | A list of paths to types that should be treated like `Arc`, i | [mutable_key](https://rust-lang.github.io/rust-clippy/master/index.html#mutable_key) |
-| allow-mixed-uninlined-format-args | `true` | Whether to allow mixed uninlined format args, e | [uninlined_format_args](https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args) |
-| suppress-restriction-lint-in-const | `false` | In same cases the restructured operation might not be unavoidable, as the suggested counterparts are unavailable in constant code | [indexing_slicing](https://rust-lang.github.io/rust-clippy/master/index.html#indexing_slicing) |
+## Lint Configuration Options
+| <div style="width:290px">Option</div> | Default Value |
+|--|--|
+| [arithmetic-side-effects-allowed](#arithmetic-side-effects-allowed) | `{}` |
+| [arithmetic-side-effects-allowed-binary](#arithmetic-side-effects-allowed-binary) | `[]` |
+| [arithmetic-side-effects-allowed-unary](#arithmetic-side-effects-allowed-unary) | `{}` |
+| [avoid-breaking-exported-api](#avoid-breaking-exported-api) | `true` |
+| [msrv](#msrv) | `None` |
+| [cognitive-complexity-threshold](#cognitive-complexity-threshold) | `25` |
+| [disallowed-names](#disallowed-names) | `["foo", "baz", "quux"]` |
+| [doc-valid-idents](#doc-valid-idents) | `["KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "DirectX", "ECMAScript", "GPLv2", "GPLv3", "GitHub", "GitLab", "IPv4", "IPv6", "ClojureScript", "CoffeeScript", "JavaScript", "PureScript", "TypeScript", "NaN", "NaNs", "OAuth", "GraphQL", "OCaml", "OpenGL", "OpenMP", "OpenSSH", "OpenSSL", "OpenStreetMap", "OpenDNS", "WebGL", "TensorFlow", "TrueType", "iOS", "macOS", "FreeBSD", "TeX", "LaTeX", "BibTeX", "BibLaTeX", "MinGW", "CamelCase"]` |
+| [too-many-arguments-threshold](#too-many-arguments-threshold) | `7` |
+| [type-complexity-threshold](#type-complexity-threshold) | `250` |
+| [single-char-binding-names-threshold](#single-char-binding-names-threshold) | `4` |
+| [too-large-for-stack](#too-large-for-stack) | `200` |
+| [enum-variant-name-threshold](#enum-variant-name-threshold) | `3` |
+| [enum-variant-size-threshold](#enum-variant-size-threshold) | `200` |
+| [verbose-bit-mask-threshold](#verbose-bit-mask-threshold) | `1` |
+| [literal-representation-threshold](#literal-representation-threshold) | `16384` |
+| [trivial-copy-size-limit](#trivial-copy-size-limit) | `None` |
+| [pass-by-value-size-limit](#pass-by-value-size-limit) | `256` |
+| [too-many-lines-threshold](#too-many-lines-threshold) | `100` |
+| [array-size-threshold](#array-size-threshold) | `512000` |
+| [vec-box-size-threshold](#vec-box-size-threshold) | `4096` |
+| [max-trait-bounds](#max-trait-bounds) | `3` |
+| [max-struct-bools](#max-struct-bools) | `3` |
+| [max-fn-params-bools](#max-fn-params-bools) | `3` |
+| [warn-on-all-wildcard-imports](#warn-on-all-wildcard-imports) | `false` |
+| [disallowed-macros](#disallowed-macros) | `[]` |
+| [disallowed-methods](#disallowed-methods) | `[]` |
+| [disallowed-types](#disallowed-types) | `[]` |
+| [unreadable-literal-lint-fractions](#unreadable-literal-lint-fractions) | `true` |
+| [upper-case-acronyms-aggressive](#upper-case-acronyms-aggressive) | `false` |
+| [matches-for-let-else](#matches-for-let-else) | `WellKnownTypes` |
+| [cargo-ignore-publish](#cargo-ignore-publish) | `false` |
+| [standard-macro-braces](#standard-macro-braces) | `[]` |
+| [enforced-import-renames](#enforced-import-renames) | `[]` |
+| [allowed-scripts](#allowed-scripts) | `["Latin"]` |
+| [enable-raw-pointer-heuristic-for-send](#enable-raw-pointer-heuristic-for-send) | `true` |
+| [max-suggested-slice-pattern-length](#max-suggested-slice-pattern-length) | `3` |
+| [max-include-file-size](#max-include-file-size) | `1000000` |
+| [allow-expect-in-tests](#allow-expect-in-tests) | `false` |
+| [allow-unwrap-in-tests](#allow-unwrap-in-tests) | `false` |
+| [allow-dbg-in-tests](#allow-dbg-in-tests) | `false` |
+| [allow-print-in-tests](#allow-print-in-tests) | `false` |
+| [large-error-threshold](#large-error-threshold) | `128` |
+| [ignore-interior-mutability](#ignore-interior-mutability) | `["bytes::Bytes"]` |
+| [allow-mixed-uninlined-format-args](#allow-mixed-uninlined-format-args) | `true` |
+| [suppress-restriction-lint-in-const](#suppress-restriction-lint-in-const) | `false` |
+
+### arithmetic-side-effects-allowed
+Suppress checking of the passed type names in all types of operations.
+
+If a specific operation is desired, consider using `arithmetic_side_effects_allowed_binary` or `arithmetic_side_effects_allowed_unary` instead.
+
+#### Example
+
+```toml
+arithmetic-side-effects-allowed = ["SomeType", "AnotherType"]
+```
+
+#### Noteworthy
+
+A type, say `SomeType`, listed in this configuration has the same behavior of
+`["SomeType" , "*"], ["*", "SomeType"]` in `arithmetic_side_effects_allowed_binary`.
+
+**Default Value:** `{}` (`rustc_data_structures::fx::FxHashSet<String>`)
+
+* [arithmetic_side_effects](https://rust-lang.github.io/rust-clippy/master/index.html#arithmetic_side_effects)
+
+
+### arithmetic-side-effects-allowed-binary
+Suppress checking of the passed type pair names in binary operations like addition or
+multiplication.
+
+Supports the "*" wildcard to indicate that a certain type won't trigger the lint regardless
+of the involved counterpart. For example, `["SomeType", "*"]` or `["*", "AnotherType"]`.
+
+Pairs are asymmetric, which means that `["SomeType", "AnotherType"]` is not the same as
+`["AnotherType", "SomeType"]`.
+
+#### Example
+
+```toml
+arithmetic-side-effects-allowed-binary = [["SomeType" , "f32"], ["AnotherType", "*"]]
+```
+
+**Default Value:** `[]` (`Vec<[String; 2]>`)
+
+* [arithmetic_side_effects](https://rust-lang.github.io/rust-clippy/master/index.html#arithmetic_side_effects)
+
+
+### arithmetic-side-effects-allowed-unary
+Suppress checking of the passed type names in unary operations like "negation" (`-`).
+
+#### Example
+
+```toml
+arithmetic-side-effects-allowed-unary = ["SomeType", "AnotherType"]
+```
+
+**Default Value:** `{}` (`rustc_data_structures::fx::FxHashSet<String>`)
+
+* [arithmetic_side_effects](https://rust-lang.github.io/rust-clippy/master/index.html#arithmetic_side_effects)
+
+
+### avoid-breaking-exported-api
+Suppress lints whenever the suggested change would cause breakage for other crates.
+
+**Default Value:** `true` (`bool`)
+
+* [enum_variant_names](https://rust-lang.github.io/rust-clippy/master/index.html#enum_variant_names)
+* [large_types_passed_by_value](https://rust-lang.github.io/rust-clippy/master/index.html#large_types_passed_by_value)
+* [trivially_copy_pass_by_ref](https://rust-lang.github.io/rust-clippy/master/index.html#trivially_copy_pass_by_ref)
+* [unnecessary_wraps](https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_wraps)
+* [unused_self](https://rust-lang.github.io/rust-clippy/master/index.html#unused_self)
+* [upper_case_acronyms](https://rust-lang.github.io/rust-clippy/master/index.html#upper_case_acronyms)
+* [wrong_self_convention](https://rust-lang.github.io/rust-clippy/master/index.html#wrong_self_convention)
+* [box_collection](https://rust-lang.github.io/rust-clippy/master/index.html#box_collection)
+* [redundant_allocation](https://rust-lang.github.io/rust-clippy/master/index.html#redundant_allocation)
+* [rc_buffer](https://rust-lang.github.io/rust-clippy/master/index.html#rc_buffer)
+* [vec_box](https://rust-lang.github.io/rust-clippy/master/index.html#vec_box)
+* [option_option](https://rust-lang.github.io/rust-clippy/master/index.html#option_option)
+* [linkedlist](https://rust-lang.github.io/rust-clippy/master/index.html#linkedlist)
+* [rc_mutex](https://rust-lang.github.io/rust-clippy/master/index.html#rc_mutex)
+
+
+### msrv
+The minimum rust version that the project supports
+
+**Default Value:** `None` (`Option<String>`)
+
+* [manual_split_once](https://rust-lang.github.io/rust-clippy/master/index.html#manual_split_once)
+* [manual_str_repeat](https://rust-lang.github.io/rust-clippy/master/index.html#manual_str_repeat)
+* [cloned_instead_of_copied](https://rust-lang.github.io/rust-clippy/master/index.html#cloned_instead_of_copied)
+* [redundant_field_names](https://rust-lang.github.io/rust-clippy/master/index.html#redundant_field_names)
+* [redundant_static_lifetimes](https://rust-lang.github.io/rust-clippy/master/index.html#redundant_static_lifetimes)
+* [filter_map_next](https://rust-lang.github.io/rust-clippy/master/index.html#filter_map_next)
+* [checked_conversions](https://rust-lang.github.io/rust-clippy/master/index.html#checked_conversions)
+* [manual_range_contains](https://rust-lang.github.io/rust-clippy/master/index.html#manual_range_contains)
+* [use_self](https://rust-lang.github.io/rust-clippy/master/index.html#use_self)
+* [mem_replace_with_default](https://rust-lang.github.io/rust-clippy/master/index.html#mem_replace_with_default)
+* [manual_non_exhaustive](https://rust-lang.github.io/rust-clippy/master/index.html#manual_non_exhaustive)
+* [option_as_ref_deref](https://rust-lang.github.io/rust-clippy/master/index.html#option_as_ref_deref)
+* [map_unwrap_or](https://rust-lang.github.io/rust-clippy/master/index.html#map_unwrap_or)
+* [match_like_matches_macro](https://rust-lang.github.io/rust-clippy/master/index.html#match_like_matches_macro)
+* [manual_strip](https://rust-lang.github.io/rust-clippy/master/index.html#manual_strip)
+* [missing_const_for_fn](https://rust-lang.github.io/rust-clippy/master/index.html#missing_const_for_fn)
+* [unnested_or_patterns](https://rust-lang.github.io/rust-clippy/master/index.html#unnested_or_patterns)
+* [from_over_into](https://rust-lang.github.io/rust-clippy/master/index.html#from_over_into)
+* [ptr_as_ptr](https://rust-lang.github.io/rust-clippy/master/index.html#ptr_as_ptr)
+* [if_then_some_else_none](https://rust-lang.github.io/rust-clippy/master/index.html#if_then_some_else_none)
+* [approx_constant](https://rust-lang.github.io/rust-clippy/master/index.html#approx_constant)
+* [deprecated_cfg_attr](https://rust-lang.github.io/rust-clippy/master/index.html#deprecated_cfg_attr)
+* [index_refutable_slice](https://rust-lang.github.io/rust-clippy/master/index.html#index_refutable_slice)
+* [map_clone](https://rust-lang.github.io/rust-clippy/master/index.html#map_clone)
+* [borrow_as_ptr](https://rust-lang.github.io/rust-clippy/master/index.html#borrow_as_ptr)
+* [manual_bits](https://rust-lang.github.io/rust-clippy/master/index.html#manual_bits)
+* [err_expect](https://rust-lang.github.io/rust-clippy/master/index.html#err_expect)
+* [cast_abs_to_unsigned](https://rust-lang.github.io/rust-clippy/master/index.html#cast_abs_to_unsigned)
+* [uninlined_format_args](https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args)
+* [manual_clamp](https://rust-lang.github.io/rust-clippy/master/index.html#manual_clamp)
+* [manual_let_else](https://rust-lang.github.io/rust-clippy/master/index.html#manual_let_else)
+* [unchecked_duration_subtraction](https://rust-lang.github.io/rust-clippy/master/index.html#unchecked_duration_subtraction)
+
+
+### cognitive-complexity-threshold
+The maximum cognitive complexity a function can have
+
+**Default Value:** `25` (`u64`)
+
+* [cognitive_complexity](https://rust-lang.github.io/rust-clippy/master/index.html#cognitive_complexity)
+
+
+### disallowed-names
+The list of disallowed names to lint about. NB: `bar` is not here since it has legitimate uses. The value
+`".."` can be used as part of the list to indicate, that the configured values should be appended to the
+default configuration of Clippy. By default any configuration will replace the default value.
+
+**Default Value:** `["foo", "baz", "quux"]` (`Vec<String>`)
+
+* [disallowed_names](https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_names)
+
+
+### doc-valid-idents
+The list of words this lint should not consider as identifiers needing ticks. The value
+`".."` can be used as part of the list to indicate, that the configured values should be appended to the
+default configuration of Clippy. By default any configuraction will replace the default value. For example:
+* `doc-valid-idents = ["ClipPy"]` would replace the default list with `["ClipPy"]`.
+* `doc-valid-idents = ["ClipPy", ".."]` would append `ClipPy` to the default list.
+
+Default list:
+
+**Default Value:** `["KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "DirectX", "ECMAScript", "GPLv2", "GPLv3", "GitHub", "GitLab", "IPv4", "IPv6", "ClojureScript", "CoffeeScript", "JavaScript", "PureScript", "TypeScript", "NaN", "NaNs", "OAuth", "GraphQL", "OCaml", "OpenGL", "OpenMP", "OpenSSH", "OpenSSL", "OpenStreetMap", "OpenDNS", "WebGL", "TensorFlow", "TrueType", "iOS", "macOS", "FreeBSD", "TeX", "LaTeX", "BibTeX", "BibLaTeX", "MinGW", "CamelCase"]` (`Vec<String>`)
+
+* [doc_markdown](https://rust-lang.github.io/rust-clippy/master/index.html#doc_markdown)
+
+
+### too-many-arguments-threshold
+The maximum number of argument a function or method can have
+
+**Default Value:** `7` (`u64`)
+
+* [too_many_arguments](https://rust-lang.github.io/rust-clippy/master/index.html#too_many_arguments)
+
+
+### type-complexity-threshold
+The maximum complexity a type can have
+
+**Default Value:** `250` (`u64`)
+
+* [type_complexity](https://rust-lang.github.io/rust-clippy/master/index.html#type_complexity)
+
+
+### single-char-binding-names-threshold
+The maximum number of single char bindings a scope may have
+
+**Default Value:** `4` (`u64`)
+
+* [many_single_char_names](https://rust-lang.github.io/rust-clippy/master/index.html#many_single_char_names)
+
+
+### too-large-for-stack
+The maximum size of objects (in bytes) that will be linted. Larger objects are ok on the heap
+
+**Default Value:** `200` (`u64`)
+
+* [boxed_local](https://rust-lang.github.io/rust-clippy/master/index.html#boxed_local)
+* [useless_vec](https://rust-lang.github.io/rust-clippy/master/index.html#useless_vec)
+
+
+### enum-variant-name-threshold
+The minimum number of enum variants for the lints about variant names to trigger
+
+**Default Value:** `3` (`u64`)
+
+* [enum_variant_names](https://rust-lang.github.io/rust-clippy/master/index.html#enum_variant_names)
+
+
+### enum-variant-size-threshold
+The maximum size of an enum's variant to avoid box suggestion
+
+**Default Value:** `200` (`u64`)
+
+* [large_enum_variant](https://rust-lang.github.io/rust-clippy/master/index.html#large_enum_variant)
+
+
+### verbose-bit-mask-threshold
+The maximum allowed size of a bit mask before suggesting to use 'trailing_zeros'
+
+**Default Value:** `1` (`u64`)
+
+* [verbose_bit_mask](https://rust-lang.github.io/rust-clippy/master/index.html#verbose_bit_mask)
+
+
+### literal-representation-threshold
+The lower bound for linting decimal literals
+
+**Default Value:** `16384` (`u64`)
+
+* [decimal_literal_representation](https://rust-lang.github.io/rust-clippy/master/index.html#decimal_literal_representation)
+
+
+### trivial-copy-size-limit
+The maximum size (in bytes) to consider a `Copy` type for passing by value instead of by reference.
+
+**Default Value:** `None` (`Option<u64>`)
+
+* [trivially_copy_pass_by_ref](https://rust-lang.github.io/rust-clippy/master/index.html#trivially_copy_pass_by_ref)
+
+
+### pass-by-value-size-limit
+The minimum size (in bytes) to consider a type for passing by reference instead of by value.
+
+**Default Value:** `256` (`u64`)
+
+* [large_type_pass_by_move](https://rust-lang.github.io/rust-clippy/master/index.html#large_type_pass_by_move)
+
+
+### too-many-lines-threshold
+The maximum number of lines a function or method can have
+
+**Default Value:** `100` (`u64`)
+
+* [too_many_lines](https://rust-lang.github.io/rust-clippy/master/index.html#too_many_lines)
+
+
+### array-size-threshold
+The maximum allowed size for arrays on the stack
+
+**Default Value:** `512000` (`u128`)
+
+* [large_stack_arrays](https://rust-lang.github.io/rust-clippy/master/index.html#large_stack_arrays)
+* [large_const_arrays](https://rust-lang.github.io/rust-clippy/master/index.html#large_const_arrays)
+
+
+### vec-box-size-threshold
+The size of the boxed type in bytes, where boxing in a `Vec` is allowed
+
+**Default Value:** `4096` (`u64`)
+
+* [vec_box](https://rust-lang.github.io/rust-clippy/master/index.html#vec_box)
+
+
+### max-trait-bounds
+The maximum number of bounds a trait can have to be linted
+
+**Default Value:** `3` (`u64`)
+
+* [type_repetition_in_bounds](https://rust-lang.github.io/rust-clippy/master/index.html#type_repetition_in_bounds)
+
+
+### max-struct-bools
+The maximum number of bool fields a struct can have
+
+**Default Value:** `3` (`u64`)
+
+* [struct_excessive_bools](https://rust-lang.github.io/rust-clippy/master/index.html#struct_excessive_bools)
+
+
+### max-fn-params-bools
+The maximum number of bool parameters a function can have
+
+**Default Value:** `3` (`u64`)
+
+* [fn_params_excessive_bools](https://rust-lang.github.io/rust-clippy/master/index.html#fn_params_excessive_bools)
+
+
+### warn-on-all-wildcard-imports
+Whether to allow certain wildcard imports (prelude, super in tests).
+
+**Default Value:** `false` (`bool`)
+
+* [wildcard_imports](https://rust-lang.github.io/rust-clippy/master/index.html#wildcard_imports)
+
+
+### disallowed-macros
+The list of disallowed macros, written as fully qualified paths.
+
+**Default Value:** `[]` (`Vec<crate::utils::conf::DisallowedPath>`)
+
+* [disallowed_macros](https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_macros)
+
+
+### disallowed-methods
+The list of disallowed methods, written as fully qualified paths.
+
+**Default Value:** `[]` (`Vec<crate::utils::conf::DisallowedPath>`)
+
+* [disallowed_methods](https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_methods)
+
+
+### disallowed-types
+The list of disallowed types, written as fully qualified paths.
+
+**Default Value:** `[]` (`Vec<crate::utils::conf::DisallowedPath>`)
+
+* [disallowed_types](https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_types)
+
+
+### unreadable-literal-lint-fractions
+Should the fraction of a decimal be linted to include separators.
+
+**Default Value:** `true` (`bool`)
+
+* [unreadable_literal](https://rust-lang.github.io/rust-clippy/master/index.html#unreadable_literal)
+
+
+### upper-case-acronyms-aggressive
+Enables verbose mode. Triggers if there is more than one uppercase char next to each other
+
+**Default Value:** `false` (`bool`)
+
+* [upper_case_acronyms](https://rust-lang.github.io/rust-clippy/master/index.html#upper_case_acronyms)
+
+
+### matches-for-let-else
+Whether the matches should be considered by the lint, and whether there should
+be filtering for common types.
+
+**Default Value:** `WellKnownTypes` (`crate::manual_let_else::MatchLintBehaviour`)
+
+* [manual_let_else](https://rust-lang.github.io/rust-clippy/master/index.html#manual_let_else)
+
+
+### cargo-ignore-publish
+For internal testing only, ignores the current `publish` settings in the Cargo manifest.
+
+**Default Value:** `false` (`bool`)
+
+* [_cargo_common_metadata](https://rust-lang.github.io/rust-clippy/master/index.html#_cargo_common_metadata)
+
+
+### standard-macro-braces
+Enforce the named macros always use the braces specified.
+
+A `MacroMatcher` can be added like so `{ name = "macro_name", brace = "(" }`. If the macro
+is could be used with a full path two `MacroMatcher`s have to be added one with the full path
+`crate_name::macro_name` and one with just the macro name.
+
+**Default Value:** `[]` (`Vec<crate::nonstandard_macro_braces::MacroMatcher>`)
+
+* [nonstandard_macro_braces](https://rust-lang.github.io/rust-clippy/master/index.html#nonstandard_macro_braces)
+
+
+### enforced-import-renames
+The list of imports to always rename, a fully qualified path followed by the rename.
+
+**Default Value:** `[]` (`Vec<crate::utils::conf::Rename>`)
+
+* [missing_enforced_import_renames](https://rust-lang.github.io/rust-clippy/master/index.html#missing_enforced_import_renames)
+
+
+### allowed-scripts
+The list of unicode scripts allowed to be used in the scope.
+
+**Default Value:** `["Latin"]` (`Vec<String>`)
+
+* [disallowed_script_idents](https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_script_idents)
+
+
+### enable-raw-pointer-heuristic-for-send
+Whether to apply the raw pointer heuristic to determine if a type is `Send`.
+
+**Default Value:** `true` (`bool`)
+
+* [non_send_fields_in_send_ty](https://rust-lang.github.io/rust-clippy/master/index.html#non_send_fields_in_send_ty)
+
+
+### max-suggested-slice-pattern-length
+When Clippy suggests using a slice pattern, this is the maximum number of elements allowed in
+the slice pattern that is suggested. If more elements would be necessary, the lint is suppressed.
+For example, `[_, _, _, e, ..]` is a slice pattern with 4 elements.
+
+**Default Value:** `3` (`u64`)
+
+* [index_refutable_slice](https://rust-lang.github.io/rust-clippy/master/index.html#index_refutable_slice)
+
+
+### max-include-file-size
+The maximum size of a file included via `include_bytes!()` or `include_str!()`, in bytes
+
+**Default Value:** `1000000` (`u64`)
+
+* [large_include_file](https://rust-lang.github.io/rust-clippy/master/index.html#large_include_file)
+
+
+### allow-expect-in-tests
+Whether `expect` should be allowed within `#[cfg(test)]`
+
+**Default Value:** `false` (`bool`)
+
+* [expect_used](https://rust-lang.github.io/rust-clippy/master/index.html#expect_used)
+
+
+### allow-unwrap-in-tests
+Whether `unwrap` should be allowed in test cfg
+
+**Default Value:** `false` (`bool`)
+
+* [unwrap_used](https://rust-lang.github.io/rust-clippy/master/index.html#unwrap_used)
+
+
+### allow-dbg-in-tests
+Whether `dbg!` should be allowed in test functions
+
+**Default Value:** `false` (`bool`)
+
+* [dbg_macro](https://rust-lang.github.io/rust-clippy/master/index.html#dbg_macro)
+
+
+### allow-print-in-tests
+Whether print macros (ex. `println!`) should be allowed in test functions
+
+**Default Value:** `false` (`bool`)
+
+* [print_stdout](https://rust-lang.github.io/rust-clippy/master/index.html#print_stdout)
+* [print_stderr](https://rust-lang.github.io/rust-clippy/master/index.html#print_stderr)
+
+
+### large-error-threshold
+The maximum size of the `Err`-variant in a `Result` returned from a function
+
+**Default Value:** `128` (`u64`)
+
+* [result_large_err](https://rust-lang.github.io/rust-clippy/master/index.html#result_large_err)
+
+
+### ignore-interior-mutability
+A list of paths to types that should be treated like `Arc`, i.e. ignored but
+for the generic parameters for determining interior mutability
+
+**Default Value:** `["bytes::Bytes"]` (`Vec<String>`)
+
+* [mutable_key](https://rust-lang.github.io/rust-clippy/master/index.html#mutable_key)
+
+
+### allow-mixed-uninlined-format-args
+Whether to allow mixed uninlined format args, e.g. `format!("{} {}", a, foo.bar)`
+
+**Default Value:** `true` (`bool`)
+
+* [uninlined_format_args](https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args)
+
+
+### suppress-restriction-lint-in-const
+In same
+cases the restructured operation might not be unavoidable, as the
+suggested counterparts are unavailable in constant code. This
+configuration will cause restriction lints to trigger even
+if no suggestion can be made.
+
+**Default Value:** `false` (`bool`)
+
+* [indexing_slicing](https://rust-lang.github.io/rust-clippy/master/index.html#indexing_slicing)
+
+
 
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index c1589c771c4..f48be27592b 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -219,7 +219,8 @@ define_Conf! {
     ///
     /// #### Noteworthy
     ///
-    /// A type, say `SomeType`, listed in this configuration has the same behavior of `["SomeType" , "*"], ["*", "SomeType"]` in `arithmetic_side_effects_allowed_binary`.
+    /// A type, say `SomeType`, listed in this configuration has the same behavior of
+    /// `["SomeType" , "*"], ["*", "SomeType"]` in `arithmetic_side_effects_allowed_binary`.
     (arithmetic_side_effects_allowed: rustc_data_structures::fx::FxHashSet<String> = <_>::default()),
     /// Lint: ARITHMETIC_SIDE_EFFECTS.
     ///
diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index c74f3b6e3ad..47604f6933b 100644
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -180,13 +180,22 @@ This lint has the following configuration variables:
             })
     }
 
-    fn get_markdown_table(&self) -> String {
+    fn configs_to_markdown(&self, map_fn: fn(&ClippyConfiguration) -> String) -> String {
         self.config
             .iter()
             .filter(|config| config.deprecation_reason.is_none())
-            .map(ClippyConfiguration::to_markdown_table_entry)
+            .filter(|config| !config.lints.is_empty())
+            .map(map_fn)
             .join("\n")
     }
+
+    fn get_markdown_docs(&self) -> String {
+        format!(
+            "## Lint Configuration Options\n| <div style=\"width:290px\">Option</div> | Default Value |\n|--|--|\n{}\n\n{}\n",
+            self.configs_to_markdown(ClippyConfiguration::to_markdown_table_entry),
+            self.configs_to_markdown(ClippyConfiguration::to_markdown_paragraph),
+        )
+    }
 }
 
 impl Drop for MetadataCollector {
@@ -230,12 +239,7 @@ impl Drop for MetadataCollector {
             .create(true)
             .open(MARKDOWN_OUTPUT_FILE)
             .unwrap();
-        writeln!(
-            file,
-            "## Lint Configuration\n\n| Option | Default | Description | Lints |\n|--|--|--|--|\n{}\n",
-            self.get_markdown_table()
-        )
-        .unwrap();
+        writeln!(file, "{}", self.get_markdown_docs(),).unwrap();
     }
 }
 
@@ -537,24 +541,27 @@ impl ClippyConfiguration {
         }
     }
 
-    fn to_markdown_table_entry(&self) -> String {
+    fn to_markdown_paragraph(&self) -> String {
         format!(
-            "| {} | `{}` | {} | {} |",
+            "### {}\n{}\n\n**Default Value:** `{}` (`{}`)\n\n{}\n\n",
             self.name,
-            self.default,
             self.doc
-                .split('.')
-                .next()
-                .unwrap_or("")
-                .replace('|', "\\|")
-                .replace("\n    ", " "),
+                .lines()
+                .map(|line| line.strip_prefix("    ").unwrap_or(line))
+                .join("\n"),
+            self.default,
+            self.config_type,
             self.lints
                 .iter()
                 .map(|name| name.to_string().split_whitespace().next().unwrap().to_string())
-                .map(|name| format!("[{name}](https://rust-lang.github.io/rust-clippy/master/index.html#{name})"))
-                .join(" ")
+                .map(|name| format!("* [{name}](https://rust-lang.github.io/rust-clippy/master/index.html#{name})"))
+                .join("\n"),
         )
     }
+
+    fn to_markdown_table_entry(&self) -> String {
+        format!("| [{}](#{}) | `{}` |", self.name, self.name, self.default)
+    }
 }
 
 fn collect_configs() -> Vec<ClippyConfiguration> {
-- 
cgit 1.4.1-3-g733a5


From c0da8acb72529fdfc156b006e9ee5d2f18f1a730 Mon Sep 17 00:00:00 2001
From: Tyler Weaver <maybe@tylerjw.dev>
Date: Sat, 14 Jan 2023 11:10:40 -0700
Subject: Comment that lint_configuration.md is machine generated

---
 book/src/lint_configuration.md                              |  5 +++++
 clippy_lints/src/utils/internal_lints/metadata_collector.rs | 12 +++++++++++-
 2 files changed, 16 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/book/src/lint_configuration.md b/book/src/lint_configuration.md
index cfaaefe3ea1..f79dbb50ff4 100644
--- a/book/src/lint_configuration.md
+++ b/book/src/lint_configuration.md
@@ -1,3 +1,8 @@
+<!--
+This file is generated by `cargo collect-metadata`.
+Please use that command to update the file and do not edit it by hand.
+-->
+
 ## Lint Configuration Options
 | <div style="width:290px">Option</div> | Default Value |
 |--|--|
diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index 47604f6933b..1995c373835 100644
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -239,7 +239,17 @@ impl Drop for MetadataCollector {
             .create(true)
             .open(MARKDOWN_OUTPUT_FILE)
             .unwrap();
-        writeln!(file, "{}", self.get_markdown_docs(),).unwrap();
+        writeln!(
+            file,
+            "<!--
+This file is generated by `cargo collect-metadata`.
+Please use that command to update the file and do not edit it by hand.
+-->
+
+{}",
+            self.get_markdown_docs(),
+        )
+        .unwrap();
     }
 }
 
-- 
cgit 1.4.1-3-g733a5


From 875e36f7e459776d3e51b7c089ab89b0821b6122 Mon Sep 17 00:00:00 2001
From: Niki4tap <rombiklol2@gmail.com>
Date: Sun, 8 Jan 2023 06:52:22 +0300
Subject: Add `multiple_unsafe_ops_per_block` lint

---
 CHANGELOG.md                                      |   1 +
 clippy_lints/src/declared_lints.rs                |   1 +
 clippy_lints/src/lib.rs                           |   2 +
 clippy_lints/src/multiple_unsafe_ops_per_block.rs | 185 ++++++++++++++++++++++
 tests/ui/multiple_unsafe_ops_per_block.rs         | 110 +++++++++++++
 tests/ui/multiple_unsafe_ops_per_block.stderr     | 129 +++++++++++++++
 6 files changed, 428 insertions(+)
 create mode 100644 clippy_lints/src/multiple_unsafe_ops_per_block.rs
 create mode 100644 tests/ui/multiple_unsafe_ops_per_block.rs
 create mode 100644 tests/ui/multiple_unsafe_ops_per_block.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 8e31e8f0d98..84f4654f34e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4383,6 +4383,7 @@ Released 2018-09-13
 [`multi_assignments`]: https://rust-lang.github.io/rust-clippy/master/index.html#multi_assignments
 [`multiple_crate_versions`]: https://rust-lang.github.io/rust-clippy/master/index.html#multiple_crate_versions
 [`multiple_inherent_impl`]: https://rust-lang.github.io/rust-clippy/master/index.html#multiple_inherent_impl
+[`multiple_unsafe_ops_per_block`]: https://rust-lang.github.io/rust-clippy/master/index.html#multiple_unsafe_ops_per_block
 [`must_use_candidate`]: https://rust-lang.github.io/rust-clippy/master/index.html#must_use_candidate
 [`must_use_unit`]: https://rust-lang.github.io/rust-clippy/master/index.html#must_use_unit
 [`mut_from_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#mut_from_ref
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 91ca73633f0..36a366fc974 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -422,6 +422,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::module_style::MOD_MODULE_FILES_INFO,
     crate::module_style::SELF_NAMED_MODULE_FILES_INFO,
     crate::multi_assignments::MULTI_ASSIGNMENTS_INFO,
+    crate::multiple_unsafe_ops_per_block::MULTIPLE_UNSAFE_OPS_PER_BLOCK_INFO,
     crate::mut_key::MUTABLE_KEY_TYPE_INFO,
     crate::mut_mut::MUT_MUT_INFO,
     crate::mut_reference::UNNECESSARY_MUT_PASSED_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index d8e2ae02c5a..5c4b6041044 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -198,6 +198,7 @@ mod missing_trait_methods;
 mod mixed_read_write_in_expression;
 mod module_style;
 mod multi_assignments;
+mod multiple_unsafe_ops_per_block;
 mod mut_key;
 mod mut_mut;
 mod mut_reference;
@@ -908,6 +909,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(fn_null_check::FnNullCheck));
     store.register_late_pass(|_| Box::new(permissions_set_readonly_false::PermissionsSetReadonlyFalse));
     store.register_late_pass(|_| Box::new(size_of_ref::SizeOfRef));
+    store.register_late_pass(|_| Box::new(multiple_unsafe_ops_per_block::MultipleUnsafeOpsPerBlock));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/multiple_unsafe_ops_per_block.rs b/clippy_lints/src/multiple_unsafe_ops_per_block.rs
new file mode 100644
index 00000000000..18e61c75eec
--- /dev/null
+++ b/clippy_lints/src/multiple_unsafe_ops_per_block.rs
@@ -0,0 +1,185 @@
+use clippy_utils::{
+    diagnostics::span_lint_and_then,
+    visitors::{for_each_expr_with_closures, Descend, Visitable},
+};
+use core::ops::ControlFlow::Continue;
+use hir::{
+    def::{DefKind, Res},
+    BlockCheckMode, ExprKind, QPath, UnOp, Unsafety,
+};
+use rustc_ast::Mutability;
+use rustc_hir as hir;
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::Span;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `unsafe` blocks that contain more than one unsafe operation.
+    ///
+    /// ### Why is this bad?
+    /// Combined with `undocumented_unsafe_blocks`,
+    /// this lint ensures that each unsafe operation must be independently justified.
+    /// Combined with `unused_unsafe`, this lint also ensures
+    /// elimination of unnecessary unsafe blocks through refactoring.
+    ///
+    /// ### Example
+    /// ```rust
+    /// /// Reads a `char` from the given pointer.
+    /// ///
+    /// /// # Safety
+    /// ///
+    /// /// `ptr` must point to four consecutive, initialized bytes which
+    /// /// form a valid `char` when interpreted in the native byte order.
+    /// fn read_char(ptr: *const u8) -> char {
+    ///     // SAFETY: The caller has guaranteed that the value pointed
+    ///     // to by `bytes` is a valid `char`.
+    ///     unsafe { char::from_u32_unchecked(*ptr.cast::<u32>()) }
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// /// Reads a `char` from the given pointer.
+    /// ///
+    /// /// # Safety
+    /// ///
+    /// /// - `ptr` must be 4-byte aligned, point to four consecutive
+    /// ///   initialized bytes, and be valid for reads of 4 bytes.
+    /// /// - The bytes pointed to by `ptr` must represent a valid
+    /// ///   `char` when interpreted in the native byte order.
+    /// fn read_char(ptr: *const u8) -> char {
+    ///     // SAFETY: `ptr` is 4-byte aligned, points to four consecutive
+    ///     // initialized bytes, and is valid for reads of 4 bytes.
+    ///     let int_value = unsafe { *ptr.cast::<u32>() };
+    ///
+    ///     // SAFETY: The caller has guaranteed that the four bytes
+    ///     // pointed to by `bytes` represent a valid `char`.
+    ///     unsafe { char::from_u32_unchecked(int_value) }
+    /// }
+    /// ```
+    #[clippy::version = "1.68.0"]
+    pub MULTIPLE_UNSAFE_OPS_PER_BLOCK,
+    restriction,
+    "more than one unsafe operation per `unsafe` block"
+}
+declare_lint_pass!(MultipleUnsafeOpsPerBlock => [MULTIPLE_UNSAFE_OPS_PER_BLOCK]);
+
+impl<'tcx> LateLintPass<'tcx> for MultipleUnsafeOpsPerBlock {
+    fn check_block(&mut self, cx: &LateContext<'tcx>, block: &'tcx hir::Block<'_>) {
+        if !matches!(block.rules, BlockCheckMode::UnsafeBlock(_)) {
+            return;
+        }
+        let mut unsafe_ops = vec![];
+        collect_unsafe_exprs(cx, block, &mut unsafe_ops);
+        if unsafe_ops.len() > 1 {
+            span_lint_and_then(
+                cx,
+                MULTIPLE_UNSAFE_OPS_PER_BLOCK,
+                block.span,
+                &format!(
+                    "this `unsafe` block contains {} unsafe operations, expected only one",
+                    unsafe_ops.len()
+                ),
+                |diag| {
+                    for (msg, span) in unsafe_ops {
+                        diag.span_note(span, msg);
+                    }
+                },
+            );
+        }
+    }
+}
+
+fn collect_unsafe_exprs<'tcx>(
+    cx: &LateContext<'tcx>,
+    node: impl Visitable<'tcx>,
+    unsafe_ops: &mut Vec<(&'static str, Span)>,
+) {
+    for_each_expr_with_closures(cx, node, |expr| {
+        match expr.kind {
+            ExprKind::InlineAsm(_) => unsafe_ops.push(("inline assembly used here", expr.span)),
+
+            ExprKind::Field(e, _) => {
+                if cx.typeck_results().expr_ty(e).is_union() {
+                    unsafe_ops.push(("union field access occurs here", expr.span));
+                }
+            },
+
+            ExprKind::Path(QPath::Resolved(
+                _,
+                hir::Path {
+                    res: Res::Def(DefKind::Static(Mutability::Mut), _),
+                    ..
+                },
+            )) => {
+                unsafe_ops.push(("access of a mutable static occurs here", expr.span));
+            },
+
+            ExprKind::Unary(UnOp::Deref, e) if cx.typeck_results().expr_ty_adjusted(e).is_unsafe_ptr() => {
+                unsafe_ops.push(("raw pointer dereference occurs here", expr.span));
+            },
+
+            ExprKind::Call(path_expr, _) => match path_expr.kind {
+                ExprKind::Path(QPath::Resolved(
+                    _,
+                    hir::Path {
+                        res: Res::Def(kind, def_id),
+                        ..
+                    },
+                )) if kind.is_fn_like() => {
+                    let sig = cx.tcx.bound_fn_sig(*def_id);
+                    if sig.0.unsafety() == Unsafety::Unsafe {
+                        unsafe_ops.push(("unsafe function call occurs here", expr.span));
+                    }
+                },
+
+                ExprKind::Path(QPath::TypeRelative(..)) => {
+                    if let Some(sig) = cx
+                        .typeck_results()
+                        .type_dependent_def_id(path_expr.hir_id)
+                        .map(|def_id| cx.tcx.bound_fn_sig(def_id))
+                    {
+                        if sig.0.unsafety() == Unsafety::Unsafe {
+                            unsafe_ops.push(("unsafe function call occurs here", expr.span));
+                        }
+                    }
+                },
+
+                _ => {},
+            },
+
+            ExprKind::MethodCall(..) => {
+                if let Some(sig) = cx
+                    .typeck_results()
+                    .type_dependent_def_id(expr.hir_id)
+                    .map(|def_id| cx.tcx.bound_fn_sig(def_id))
+                {
+                    if sig.0.unsafety() == Unsafety::Unsafe {
+                        unsafe_ops.push(("unsafe method call occurs here", expr.span));
+                    }
+                }
+            },
+
+            ExprKind::AssignOp(_, lhs, rhs) | ExprKind::Assign(lhs, rhs, _) => {
+                if matches!(
+                    lhs.kind,
+                    ExprKind::Path(QPath::Resolved(
+                        _,
+                        hir::Path {
+                            res: Res::Def(DefKind::Static(Mutability::Mut), _),
+                            ..
+                        }
+                    ))
+                ) {
+                    unsafe_ops.push(("modification of a mutable static occurs here", expr.span));
+                    collect_unsafe_exprs(cx, rhs, unsafe_ops);
+                    return Continue(Descend::No);
+                }
+            },
+
+            _ => {},
+        };
+
+        Continue::<(), _>(Descend::Yes)
+    });
+}
diff --git a/tests/ui/multiple_unsafe_ops_per_block.rs b/tests/ui/multiple_unsafe_ops_per_block.rs
new file mode 100644
index 00000000000..41263535df6
--- /dev/null
+++ b/tests/ui/multiple_unsafe_ops_per_block.rs
@@ -0,0 +1,110 @@
+#![allow(unused)]
+#![allow(deref_nullptr)]
+#![allow(clippy::unnecessary_operation)]
+#![allow(clippy::drop_copy)]
+#![warn(clippy::multiple_unsafe_ops_per_block)]
+
+use core::arch::asm;
+
+fn raw_ptr() -> *const () {
+    core::ptr::null()
+}
+
+unsafe fn not_very_safe() {}
+
+struct Sample;
+
+impl Sample {
+    unsafe fn not_very_safe(&self) {}
+}
+
+#[allow(non_upper_case_globals)]
+const sample: Sample = Sample;
+
+union U {
+    i: i32,
+    u: u32,
+}
+
+static mut STATIC: i32 = 0;
+
+fn test1() {
+    unsafe {
+        STATIC += 1;
+        not_very_safe();
+    }
+}
+
+fn test2() {
+    let u = U { i: 0 };
+
+    unsafe {
+        drop(u.u);
+        *raw_ptr();
+    }
+}
+
+fn test3() {
+    unsafe {
+        asm!("nop");
+        sample.not_very_safe();
+        STATIC = 0;
+    }
+}
+
+fn test_all() {
+    let u = U { i: 0 };
+    unsafe {
+        drop(u.u);
+        drop(STATIC);
+        sample.not_very_safe();
+        not_very_safe();
+        *raw_ptr();
+        asm!("nop");
+    }
+}
+
+// no lint
+fn correct1() {
+    unsafe {
+        STATIC += 1;
+    }
+}
+
+// no lint
+fn correct2() {
+    unsafe {
+        STATIC += 1;
+    }
+
+    unsafe {
+        *raw_ptr();
+    }
+}
+
+// no lint
+fn correct3() {
+    let u = U { u: 0 };
+
+    unsafe {
+        not_very_safe();
+    }
+
+    unsafe {
+        drop(u.i);
+    }
+}
+
+// tests from the issue (https://github.com/rust-lang/rust-clippy/issues/10064)
+
+unsafe fn read_char_bad(ptr: *const u8) -> char {
+    unsafe { char::from_u32_unchecked(*ptr.cast::<u32>()) }
+}
+
+// no lint
+unsafe fn read_char_good(ptr: *const u8) -> char {
+    let int_value = unsafe { *ptr.cast::<u32>() };
+    unsafe { core::char::from_u32_unchecked(int_value) }
+}
+
+fn main() {}
diff --git a/tests/ui/multiple_unsafe_ops_per_block.stderr b/tests/ui/multiple_unsafe_ops_per_block.stderr
new file mode 100644
index 00000000000..f6b8341795d
--- /dev/null
+++ b/tests/ui/multiple_unsafe_ops_per_block.stderr
@@ -0,0 +1,129 @@
+error: this `unsafe` block contains 2 unsafe operations, expected only one
+  --> $DIR/multiple_unsafe_ops_per_block.rs:32:5
+   |
+LL | /     unsafe {
+LL | |         STATIC += 1;
+LL | |         not_very_safe();
+LL | |     }
+   | |_____^
+   |
+note: modification of a mutable static occurs here
+  --> $DIR/multiple_unsafe_ops_per_block.rs:33:9
+   |
+LL |         STATIC += 1;
+   |         ^^^^^^^^^^^
+note: unsafe function call occurs here
+  --> $DIR/multiple_unsafe_ops_per_block.rs:34:9
+   |
+LL |         not_very_safe();
+   |         ^^^^^^^^^^^^^^^
+   = note: `-D clippy::multiple-unsafe-ops-per-block` implied by `-D warnings`
+
+error: this `unsafe` block contains 2 unsafe operations, expected only one
+  --> $DIR/multiple_unsafe_ops_per_block.rs:41:5
+   |
+LL | /     unsafe {
+LL | |         drop(u.u);
+LL | |         *raw_ptr();
+LL | |     }
+   | |_____^
+   |
+note: union field access occurs here
+  --> $DIR/multiple_unsafe_ops_per_block.rs:42:14
+   |
+LL |         drop(u.u);
+   |              ^^^
+note: raw pointer dereference occurs here
+  --> $DIR/multiple_unsafe_ops_per_block.rs:43:9
+   |
+LL |         *raw_ptr();
+   |         ^^^^^^^^^^
+
+error: this `unsafe` block contains 3 unsafe operations, expected only one
+  --> $DIR/multiple_unsafe_ops_per_block.rs:48:5
+   |
+LL | /     unsafe {
+LL | |         asm!("nop");
+LL | |         sample.not_very_safe();
+LL | |         STATIC = 0;
+LL | |     }
+   | |_____^
+   |
+note: inline assembly used here
+  --> $DIR/multiple_unsafe_ops_per_block.rs:49:9
+   |
+LL |         asm!("nop");
+   |         ^^^^^^^^^^^
+note: unsafe method call occurs here
+  --> $DIR/multiple_unsafe_ops_per_block.rs:50:9
+   |
+LL |         sample.not_very_safe();
+   |         ^^^^^^^^^^^^^^^^^^^^^^
+note: modification of a mutable static occurs here
+  --> $DIR/multiple_unsafe_ops_per_block.rs:51:9
+   |
+LL |         STATIC = 0;
+   |         ^^^^^^^^^^
+
+error: this `unsafe` block contains 6 unsafe operations, expected only one
+  --> $DIR/multiple_unsafe_ops_per_block.rs:57:5
+   |
+LL | /     unsafe {
+LL | |         drop(u.u);
+LL | |         drop(STATIC);
+LL | |         sample.not_very_safe();
+...  |
+LL | |         asm!("nop");
+LL | |     }
+   | |_____^
+   |
+note: union field access occurs here
+  --> $DIR/multiple_unsafe_ops_per_block.rs:58:14
+   |
+LL |         drop(u.u);
+   |              ^^^
+note: access of a mutable static occurs here
+  --> $DIR/multiple_unsafe_ops_per_block.rs:59:14
+   |
+LL |         drop(STATIC);
+   |              ^^^^^^
+note: unsafe method call occurs here
+  --> $DIR/multiple_unsafe_ops_per_block.rs:60:9
+   |
+LL |         sample.not_very_safe();
+   |         ^^^^^^^^^^^^^^^^^^^^^^
+note: unsafe function call occurs here
+  --> $DIR/multiple_unsafe_ops_per_block.rs:61:9
+   |
+LL |         not_very_safe();
+   |         ^^^^^^^^^^^^^^^
+note: raw pointer dereference occurs here
+  --> $DIR/multiple_unsafe_ops_per_block.rs:62:9
+   |
+LL |         *raw_ptr();
+   |         ^^^^^^^^^^
+note: inline assembly used here
+  --> $DIR/multiple_unsafe_ops_per_block.rs:63:9
+   |
+LL |         asm!("nop");
+   |         ^^^^^^^^^^^
+
+error: this `unsafe` block contains 2 unsafe operations, expected only one
+  --> $DIR/multiple_unsafe_ops_per_block.rs:101:5
+   |
+LL |     unsafe { char::from_u32_unchecked(*ptr.cast::<u32>()) }
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: unsafe function call occurs here
+  --> $DIR/multiple_unsafe_ops_per_block.rs:101:14
+   |
+LL |     unsafe { char::from_u32_unchecked(*ptr.cast::<u32>()) }
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+note: raw pointer dereference occurs here
+  --> $DIR/multiple_unsafe_ops_per_block.rs:101:39
+   |
+LL |     unsafe { char::from_u32_unchecked(*ptr.cast::<u32>()) }
+   |                                       ^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 5 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From e3a09eca6d810af2105b4ed3af17048b318d25c4 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Thu, 19 Jan 2023 21:57:56 +0100
Subject: Update version attribute for 1.67 lints

---
 clippy_lints/src/doc.rs                        | 2 +-
 clippy_lints/src/from_raw_with_void_ptr.rs     | 2 +-
 clippy_lints/src/instant_subtraction.rs        | 2 +-
 clippy_lints/src/let_underscore.rs             | 2 +-
 clippy_lints/src/manual_is_ascii_check.rs      | 2 +-
 clippy_lints/src/methods/mod.rs                | 4 ++--
 clippy_lints/src/suspicious_xor_used_as_pow.rs | 2 +-
 7 files changed, 8 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/doc.rs b/clippy_lints/src/doc.rs
index cdc23a4d227..f7a3d6d53f7 100644
--- a/clippy_lints/src/doc.rs
+++ b/clippy_lints/src/doc.rs
@@ -251,7 +251,7 @@ declare_clippy_lint! {
     ///     unimplemented!();
     /// }
     /// ```
-    #[clippy::version = "1.66.0"]
+    #[clippy::version = "1.67.0"]
     pub UNNECESSARY_SAFETY_DOC,
     restriction,
     "`pub fn` or `pub trait` with `# Safety` docs"
diff --git a/clippy_lints/src/from_raw_with_void_ptr.rs b/clippy_lints/src/from_raw_with_void_ptr.rs
index 00f5ba56496..096508dc4f1 100644
--- a/clippy_lints/src/from_raw_with_void_ptr.rs
+++ b/clippy_lints/src/from_raw_with_void_ptr.rs
@@ -31,7 +31,7 @@ declare_clippy_lint! {
     /// let _ = unsafe { Box::from_raw(ptr as *mut usize) };
     /// ```
     ///
-    #[clippy::version = "1.66.0"]
+    #[clippy::version = "1.67.0"]
     pub FROM_RAW_WITH_VOID_PTR,
     suspicious,
     "creating a `Box` from a void raw pointer"
diff --git a/clippy_lints/src/instant_subtraction.rs b/clippy_lints/src/instant_subtraction.rs
index 9f6e8940571..668110c7cc0 100644
--- a/clippy_lints/src/instant_subtraction.rs
+++ b/clippy_lints/src/instant_subtraction.rs
@@ -59,7 +59,7 @@ declare_clippy_lint! {
     ///
     /// [`Duration`]: std::time::Duration
     /// [`Instant::now()`]: std::time::Instant::now;
-    #[clippy::version = "1.65.0"]
+    #[clippy::version = "1.67.0"]
     pub UNCHECKED_DURATION_SUBTRACTION,
     pedantic,
     "finds unchecked subtraction of a 'Duration' from an 'Instant'"
diff --git a/clippy_lints/src/let_underscore.rs b/clippy_lints/src/let_underscore.rs
index 61f87b91400..f8e35950980 100644
--- a/clippy_lints/src/let_underscore.rs
+++ b/clippy_lints/src/let_underscore.rs
@@ -84,7 +84,7 @@ declare_clippy_lint! {
     /// let _ = foo().await;
     /// # }
     /// ```
-    #[clippy::version = "1.66"]
+    #[clippy::version = "1.67.0"]
     pub LET_UNDERSCORE_FUTURE,
     suspicious,
     "non-binding `let` on a future"
diff --git a/clippy_lints/src/manual_is_ascii_check.rs b/clippy_lints/src/manual_is_ascii_check.rs
index d9ef7dffa02..2fd32c009ea 100644
--- a/clippy_lints/src/manual_is_ascii_check.rs
+++ b/clippy_lints/src/manual_is_ascii_check.rs
@@ -43,7 +43,7 @@ declare_clippy_lint! {
     ///     'A'.is_ascii_uppercase();
     /// }
     /// ```
-    #[clippy::version = "1.66.0"]
+    #[clippy::version = "1.67.0"]
     pub MANUAL_IS_ASCII_CHECK,
     style,
     "use dedicated method to check ascii range"
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 77be61b4793..42377a3d138 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3102,7 +3102,7 @@ declare_clippy_lint! {
     ///     Ok(())
     /// }
     /// ```
-    #[clippy::version = "1.66.0"]
+    #[clippy::version = "1.67.0"]
     pub SEEK_FROM_CURRENT,
     complexity,
     "use dedicated method for seek from current position"
@@ -3133,7 +3133,7 @@ declare_clippy_lint! {
     ///     t.rewind();
     /// }
     /// ```
-    #[clippy::version = "1.66.0"]
+    #[clippy::version = "1.67.0"]
     pub SEEK_TO_START_INSTEAD_OF_REWIND,
     complexity,
     "jumping to the start of stream using `seek` method"
diff --git a/clippy_lints/src/suspicious_xor_used_as_pow.rs b/clippy_lints/src/suspicious_xor_used_as_pow.rs
index 301aa5798bf..c181919b164 100644
--- a/clippy_lints/src/suspicious_xor_used_as_pow.rs
+++ b/clippy_lints/src/suspicious_xor_used_as_pow.rs
@@ -18,7 +18,7 @@ declare_clippy_lint! {
     /// ```rust
     /// let x = 3_i32.pow(4);
     /// ```
-    #[clippy::version = "1.66.0"]
+    #[clippy::version = "1.67.0"]
     pub SUSPICIOUS_XOR_USED_AS_POW,
     restriction,
     "XOR (`^`) operator possibly used as exponentiation operator"
-- 
cgit 1.4.1-3-g733a5


From 5f49808bdefc42deb06f5096854ec2f910848cb0 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Sat, 21 Jan 2023 17:20:46 +0000
Subject: Add machine applicable suggestion for `bool_assert_comparison`

---
 clippy_lints/src/bool_assert_comparison.rs |  53 ++++--
 tests/ui/bool_assert_comparison.fixed      | 161 ++++++++++++++++++
 tests/ui/bool_assert_comparison.rs         |  43 ++++-
 tests/ui/bool_assert_comparison.stderr     | 257 ++++++++++++++++++++++++-----
 4 files changed, 453 insertions(+), 61 deletions(-)
 create mode 100644 tests/ui/bool_assert_comparison.fixed

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/bool_assert_comparison.rs b/clippy_lints/src/bool_assert_comparison.rs
index 82d368bb8bc..556fa579000 100644
--- a/clippy_lints/src/bool_assert_comparison.rs
+++ b/clippy_lints/src/bool_assert_comparison.rs
@@ -1,10 +1,11 @@
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::macros::{find_assert_eq_args, root_macro_call_first_node};
-use clippy_utils::{diagnostics::span_lint_and_sugg, ty::implements_trait};
+use clippy_utils::ty::{implements_trait, is_copy};
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, Lit};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty;
+use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_middle::ty::{self, Ty};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::symbol::Ident;
 
@@ -43,9 +44,7 @@ fn is_bool_lit(e: &Expr<'_>) -> bool {
     ) && !e.span.from_expansion()
 }
 
-fn is_impl_not_trait_with_bool_out(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
-    let ty = cx.typeck_results().expr_ty(e);
-
+fn is_impl_not_trait_with_bool_out<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
     cx.tcx
         .lang_items()
         .not_trait()
@@ -77,31 +76,57 @@ impl<'tcx> LateLintPass<'tcx> for BoolAssertComparison {
             return;
         }
         let Some ((a, b, _)) = find_assert_eq_args(cx, expr, macro_call.expn) else { return };
-        if !(is_bool_lit(a) ^ is_bool_lit(b)) {
+
+        let a_span = a.span.source_callsite();
+        let b_span = b.span.source_callsite();
+
+        let (lit_span, non_lit_expr) = match (is_bool_lit(a), is_bool_lit(b)) {
+            // assert_eq!(true, b)
+            //            ^^^^^^
+            (true, false) => (a_span.until(b_span), b),
+            // assert_eq!(a, true)
+            //             ^^^^^^
+            (false, true) => (b_span.with_lo(a_span.hi()), a),
             // If there are two boolean arguments, we definitely don't understand
             // what's going on, so better leave things as is...
             //
             // Or there is simply no boolean and then we can leave things as is!
-            return;
-        }
+            _ => return,
+        };
 
-        if !is_impl_not_trait_with_bool_out(cx, a) || !is_impl_not_trait_with_bool_out(cx, b) {
+        let non_lit_ty = cx.typeck_results().expr_ty(non_lit_expr);
+
+        if !is_impl_not_trait_with_bool_out(cx, non_lit_ty) {
             // At this point the expression which is not a boolean
             // literal does not implement Not trait with a bool output,
             // so we cannot suggest to rewrite our code
             return;
         }
 
+        if !is_copy(cx, non_lit_ty) {
+            // Only lint with types that are `Copy` because `assert!(x)` takes
+            // ownership of `x` whereas `assert_eq(x, true)` does not
+            return;
+        }
+
         let macro_name = macro_name.as_str();
         let non_eq_mac = &macro_name[..macro_name.len() - 3];
-        span_lint_and_sugg(
+        span_lint_and_then(
             cx,
             BOOL_ASSERT_COMPARISON,
             macro_call.span,
             &format!("used `{macro_name}!` with a literal bool"),
-            "replace it with",
-            format!("{non_eq_mac}!(..)"),
-            Applicability::MaybeIncorrect,
+            |diag| {
+                // assert_eq!(...)
+                // ^^^^^^^^^
+                let name_span = cx.sess().source_map().span_until_char(macro_call.span, '!');
+
+                diag.multipart_suggestion(
+                    format!("replace it with `{non_eq_mac}!(..)`"),
+                    vec![(name_span, non_eq_mac.to_string()), (lit_span, String::new())],
+                    Applicability::MachineApplicable,
+                );
+            },
         );
     }
 }
diff --git a/tests/ui/bool_assert_comparison.fixed b/tests/ui/bool_assert_comparison.fixed
new file mode 100644
index 00000000000..95f35a61bb2
--- /dev/null
+++ b/tests/ui/bool_assert_comparison.fixed
@@ -0,0 +1,161 @@
+// run-rustfix
+
+#![allow(unused, clippy::assertions_on_constants)]
+#![warn(clippy::bool_assert_comparison)]
+
+use std::ops::Not;
+
+macro_rules! a {
+    () => {
+        true
+    };
+}
+macro_rules! b {
+    () => {
+        true
+    };
+}
+
+// Implements the Not trait but with an output type
+// that's not bool. Should not suggest a rewrite
+#[derive(Debug, Clone, Copy)]
+enum ImplNotTraitWithoutBool {
+    VariantX(bool),
+    VariantY(u32),
+}
+
+impl PartialEq<bool> for ImplNotTraitWithoutBool {
+    fn eq(&self, other: &bool) -> bool {
+        match *self {
+            ImplNotTraitWithoutBool::VariantX(b) => b == *other,
+            _ => false,
+        }
+    }
+}
+
+impl Not for ImplNotTraitWithoutBool {
+    type Output = Self;
+
+    fn not(self) -> Self::Output {
+        match self {
+            ImplNotTraitWithoutBool::VariantX(b) => ImplNotTraitWithoutBool::VariantX(!b),
+            ImplNotTraitWithoutBool::VariantY(0) => ImplNotTraitWithoutBool::VariantY(1),
+            ImplNotTraitWithoutBool::VariantY(_) => ImplNotTraitWithoutBool::VariantY(0),
+        }
+    }
+}
+
+// This type implements the Not trait with an Output of
+// type bool. Using assert!(..) must be suggested
+#[derive(Debug, Clone, Copy)]
+struct ImplNotTraitWithBool;
+
+impl PartialEq<bool> for ImplNotTraitWithBool {
+    fn eq(&self, other: &bool) -> bool {
+        false
+    }
+}
+
+impl Not for ImplNotTraitWithBool {
+    type Output = bool;
+
+    fn not(self) -> Self::Output {
+        true
+    }
+}
+
+#[derive(Debug)]
+struct NonCopy;
+
+impl PartialEq<bool> for NonCopy {
+    fn eq(&self, other: &bool) -> bool {
+        false
+    }
+}
+
+impl Not for NonCopy {
+    type Output = bool;
+
+    fn not(self) -> Self::Output {
+        true
+    }
+}
+
+fn main() {
+    let a = ImplNotTraitWithoutBool::VariantX(true);
+    let b = ImplNotTraitWithBool;
+
+    assert_eq!("a".len(), 1);
+    assert!("a".is_empty());
+    assert!("".is_empty());
+    assert!("".is_empty());
+    assert_eq!(a!(), b!());
+    assert_eq!(a!(), "".is_empty());
+    assert_eq!("".is_empty(), b!());
+    assert_eq!(a, true);
+    assert!(b);
+
+    assert_ne!("a".len(), 1);
+    assert!("a".is_empty());
+    assert!("".is_empty());
+    assert!("".is_empty());
+    assert_ne!(a!(), b!());
+    assert_ne!(a!(), "".is_empty());
+    assert_ne!("".is_empty(), b!());
+    assert_ne!(a, true);
+    assert!(b);
+
+    debug_assert_eq!("a".len(), 1);
+    debug_assert!("a".is_empty());
+    debug_assert!("".is_empty());
+    debug_assert!("".is_empty());
+    debug_assert_eq!(a!(), b!());
+    debug_assert_eq!(a!(), "".is_empty());
+    debug_assert_eq!("".is_empty(), b!());
+    debug_assert_eq!(a, true);
+    debug_assert!(b);
+
+    debug_assert_ne!("a".len(), 1);
+    debug_assert!("a".is_empty());
+    debug_assert!("".is_empty());
+    debug_assert!("".is_empty());
+    debug_assert_ne!(a!(), b!());
+    debug_assert_ne!(a!(), "".is_empty());
+    debug_assert_ne!("".is_empty(), b!());
+    debug_assert_ne!(a, true);
+    debug_assert!(b);
+
+    // assert with error messages
+    assert_eq!("a".len(), 1, "tadam {}", 1);
+    assert_eq!("a".len(), 1, "tadam {}", true);
+    assert!("a".is_empty(), "tadam {}", 1);
+    assert!("a".is_empty(), "tadam {}", true);
+    assert!("a".is_empty(), "tadam {}", true);
+    assert_eq!(a, true, "tadam {}", false);
+
+    debug_assert_eq!("a".len(), 1, "tadam {}", 1);
+    debug_assert_eq!("a".len(), 1, "tadam {}", true);
+    debug_assert!("a".is_empty(), "tadam {}", 1);
+    debug_assert!("a".is_empty(), "tadam {}", true);
+    debug_assert!("a".is_empty(), "tadam {}", true);
+    debug_assert_eq!(a, true, "tadam {}", false);
+
+    assert!(a!());
+    assert!(b!());
+
+    use debug_assert_eq as renamed;
+    renamed!(a, true);
+    debug_assert!(b);
+
+    let non_copy = NonCopy;
+    assert_eq!(non_copy, true);
+    // changing the above to `assert!(non_copy)` would cause a `borrow of moved value`
+    println!("{non_copy:?}");
+
+    macro_rules! in_macro {
+        ($v:expr) => {{
+            assert_eq!($v, true);
+        }};
+    }
+    in_macro!(a);
+}
diff --git a/tests/ui/bool_assert_comparison.rs b/tests/ui/bool_assert_comparison.rs
index ec4d6f3ff84..88e7560b4f9 100644
--- a/tests/ui/bool_assert_comparison.rs
+++ b/tests/ui/bool_assert_comparison.rs
@@ -1,3 +1,6 @@
+// run-rustfix
+
+#![allow(unused, clippy::assertions_on_constants)]
 #![warn(clippy::bool_assert_comparison)]
 
 use std::ops::Not;
@@ -15,7 +18,7 @@ macro_rules! b {
 
 // Implements the Not trait but with an output type
 // that's not bool. Should not suggest a rewrite
-#[derive(Debug)]
+#[derive(Debug, Clone, Copy)]
 enum ImplNotTraitWithoutBool {
     VariantX(bool),
     VariantY(u32),
@@ -44,7 +47,7 @@ impl Not for ImplNotTraitWithoutBool {
 
 // This type implements the Not trait with an Output of
 // type bool. Using assert!(..) must be suggested
-#[derive(Debug)]
+#[derive(Debug, Clone, Copy)]
 struct ImplNotTraitWithBool;
 
 impl PartialEq<bool> for ImplNotTraitWithBool {
@@ -61,6 +64,23 @@ impl Not for ImplNotTraitWithBool {
     }
 }
 
+#[derive(Debug)]
+struct NonCopy;
+
+impl PartialEq<bool> for NonCopy {
+    fn eq(&self, other: &bool) -> bool {
+        false
+    }
+}
+
+impl Not for NonCopy {
+    type Output = bool;
+
+    fn not(self) -> Self::Output {
+        true
+    }
+}
+
 fn main() {
     let a = ImplNotTraitWithoutBool::VariantX(true);
     let b = ImplNotTraitWithBool;
@@ -119,4 +139,23 @@ fn main() {
     debug_assert_eq!("a".is_empty(), false, "tadam {}", true);
     debug_assert_eq!(false, "a".is_empty(), "tadam {}", true);
     debug_assert_eq!(a, true, "tadam {}", false);
+
+    assert_eq!(a!(), true);
+    assert_eq!(true, b!());
+
+    use debug_assert_eq as renamed;
+    renamed!(a, true);
+    renamed!(b, true);
+
+    let non_copy = NonCopy;
+    assert_eq!(non_copy, true);
+    // changing the above to `assert!(non_copy)` would cause a `borrow of moved value`
+    println!("{non_copy:?}");
+
+    macro_rules! in_macro {
+        ($v:expr) => {{
+            assert_eq!($v, true);
+        }};
+    }
+    in_macro!(a);
 }
diff --git a/tests/ui/bool_assert_comparison.stderr b/tests/ui/bool_assert_comparison.stderr
index 377d51be4cd..3d9f8573e61 100644
--- a/tests/ui/bool_assert_comparison.stderr
+++ b/tests/ui/bool_assert_comparison.stderr
@@ -1,136 +1,303 @@
 error: used `assert_eq!` with a literal bool
-  --> $DIR/bool_assert_comparison.rs:69:5
+  --> $DIR/bool_assert_comparison.rs:89:5
    |
 LL |     assert_eq!("a".is_empty(), false);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `assert!(..)`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::bool-assert-comparison` implied by `-D warnings`
+help: replace it with `assert!(..)`
+   |
+LL -     assert_eq!("a".is_empty(), false);
+LL +     assert!("a".is_empty());
+   |
 
 error: used `assert_eq!` with a literal bool
-  --> $DIR/bool_assert_comparison.rs:70:5
+  --> $DIR/bool_assert_comparison.rs:90:5
    |
 LL |     assert_eq!("".is_empty(), true);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `assert!(..)`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: replace it with `assert!(..)`
+   |
+LL -     assert_eq!("".is_empty(), true);
+LL +     assert!("".is_empty());
+   |
 
 error: used `assert_eq!` with a literal bool
-  --> $DIR/bool_assert_comparison.rs:71:5
+  --> $DIR/bool_assert_comparison.rs:91:5
    |
 LL |     assert_eq!(true, "".is_empty());
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `assert!(..)`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: replace it with `assert!(..)`
+   |
+LL -     assert_eq!(true, "".is_empty());
+LL +     assert!("".is_empty());
+   |
 
 error: used `assert_eq!` with a literal bool
-  --> $DIR/bool_assert_comparison.rs:76:5
+  --> $DIR/bool_assert_comparison.rs:96:5
    |
 LL |     assert_eq!(b, true);
-   |     ^^^^^^^^^^^^^^^^^^^ help: replace it with: `assert!(..)`
+   |     ^^^^^^^^^^^^^^^^^^^
+   |
+help: replace it with `assert!(..)`
+   |
+LL -     assert_eq!(b, true);
+LL +     assert!(b);
+   |
 
 error: used `assert_ne!` with a literal bool
-  --> $DIR/bool_assert_comparison.rs:79:5
+  --> $DIR/bool_assert_comparison.rs:99:5
    |
 LL |     assert_ne!("a".is_empty(), false);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `assert!(..)`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: replace it with `assert!(..)`
+   |
+LL -     assert_ne!("a".is_empty(), false);
+LL +     assert!("a".is_empty());
+   |
 
 error: used `assert_ne!` with a literal bool
-  --> $DIR/bool_assert_comparison.rs:80:5
+  --> $DIR/bool_assert_comparison.rs:100:5
    |
 LL |     assert_ne!("".is_empty(), true);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `assert!(..)`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: replace it with `assert!(..)`
+   |
+LL -     assert_ne!("".is_empty(), true);
+LL +     assert!("".is_empty());
+   |
 
 error: used `assert_ne!` with a literal bool
-  --> $DIR/bool_assert_comparison.rs:81:5
+  --> $DIR/bool_assert_comparison.rs:101:5
    |
 LL |     assert_ne!(true, "".is_empty());
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `assert!(..)`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: replace it with `assert!(..)`
+   |
+LL -     assert_ne!(true, "".is_empty());
+LL +     assert!("".is_empty());
+   |
 
 error: used `assert_ne!` with a literal bool
-  --> $DIR/bool_assert_comparison.rs:86:5
+  --> $DIR/bool_assert_comparison.rs:106:5
    |
 LL |     assert_ne!(b, true);
-   |     ^^^^^^^^^^^^^^^^^^^ help: replace it with: `assert!(..)`
+   |     ^^^^^^^^^^^^^^^^^^^
+   |
+help: replace it with `assert!(..)`
+   |
+LL -     assert_ne!(b, true);
+LL +     assert!(b);
+   |
 
 error: used `debug_assert_eq!` with a literal bool
-  --> $DIR/bool_assert_comparison.rs:89:5
+  --> $DIR/bool_assert_comparison.rs:109:5
    |
 LL |     debug_assert_eq!("a".is_empty(), false);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `debug_assert!(..)`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: replace it with `debug_assert!(..)`
+   |
+LL -     debug_assert_eq!("a".is_empty(), false);
+LL +     debug_assert!("a".is_empty());
+   |
 
 error: used `debug_assert_eq!` with a literal bool
-  --> $DIR/bool_assert_comparison.rs:90:5
+  --> $DIR/bool_assert_comparison.rs:110:5
    |
 LL |     debug_assert_eq!("".is_empty(), true);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `debug_assert!(..)`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: replace it with `debug_assert!(..)`
+   |
+LL -     debug_assert_eq!("".is_empty(), true);
+LL +     debug_assert!("".is_empty());
+   |
 
 error: used `debug_assert_eq!` with a literal bool
-  --> $DIR/bool_assert_comparison.rs:91:5
+  --> $DIR/bool_assert_comparison.rs:111:5
    |
 LL |     debug_assert_eq!(true, "".is_empty());
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `debug_assert!(..)`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: replace it with `debug_assert!(..)`
+   |
+LL -     debug_assert_eq!(true, "".is_empty());
+LL +     debug_assert!("".is_empty());
+   |
 
 error: used `debug_assert_eq!` with a literal bool
-  --> $DIR/bool_assert_comparison.rs:96:5
+  --> $DIR/bool_assert_comparison.rs:116:5
    |
 LL |     debug_assert_eq!(b, true);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `debug_assert!(..)`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: replace it with `debug_assert!(..)`
+   |
+LL -     debug_assert_eq!(b, true);
+LL +     debug_assert!(b);
+   |
 
 error: used `debug_assert_ne!` with a literal bool
-  --> $DIR/bool_assert_comparison.rs:99:5
+  --> $DIR/bool_assert_comparison.rs:119:5
    |
 LL |     debug_assert_ne!("a".is_empty(), false);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `debug_assert!(..)`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: replace it with `debug_assert!(..)`
+   |
+LL -     debug_assert_ne!("a".is_empty(), false);
+LL +     debug_assert!("a".is_empty());
+   |
 
 error: used `debug_assert_ne!` with a literal bool
-  --> $DIR/bool_assert_comparison.rs:100:5
+  --> $DIR/bool_assert_comparison.rs:120:5
    |
 LL |     debug_assert_ne!("".is_empty(), true);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `debug_assert!(..)`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: replace it with `debug_assert!(..)`
+   |
+LL -     debug_assert_ne!("".is_empty(), true);
+LL +     debug_assert!("".is_empty());
+   |
 
 error: used `debug_assert_ne!` with a literal bool
-  --> $DIR/bool_assert_comparison.rs:101:5
+  --> $DIR/bool_assert_comparison.rs:121:5
    |
 LL |     debug_assert_ne!(true, "".is_empty());
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `debug_assert!(..)`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: replace it with `debug_assert!(..)`
+   |
+LL -     debug_assert_ne!(true, "".is_empty());
+LL +     debug_assert!("".is_empty());
+   |
 
 error: used `debug_assert_ne!` with a literal bool
-  --> $DIR/bool_assert_comparison.rs:106:5
+  --> $DIR/bool_assert_comparison.rs:126:5
    |
 LL |     debug_assert_ne!(b, true);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `debug_assert!(..)`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: replace it with `debug_assert!(..)`
+   |
+LL -     debug_assert_ne!(b, true);
+LL +     debug_assert!(b);
+   |
 
 error: used `assert_eq!` with a literal bool
-  --> $DIR/bool_assert_comparison.rs:111:5
+  --> $DIR/bool_assert_comparison.rs:131:5
    |
 LL |     assert_eq!("a".is_empty(), false, "tadam {}", 1);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `assert!(..)`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: replace it with `assert!(..)`
+   |
+LL -     assert_eq!("a".is_empty(), false, "tadam {}", 1);
+LL +     assert!("a".is_empty(), "tadam {}", 1);
+   |
 
 error: used `assert_eq!` with a literal bool
-  --> $DIR/bool_assert_comparison.rs:112:5
+  --> $DIR/bool_assert_comparison.rs:132:5
    |
 LL |     assert_eq!("a".is_empty(), false, "tadam {}", true);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `assert!(..)`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: replace it with `assert!(..)`
+   |
+LL -     assert_eq!("a".is_empty(), false, "tadam {}", true);
+LL +     assert!("a".is_empty(), "tadam {}", true);
+   |
 
 error: used `assert_eq!` with a literal bool
-  --> $DIR/bool_assert_comparison.rs:113:5
+  --> $DIR/bool_assert_comparison.rs:133:5
    |
 LL |     assert_eq!(false, "a".is_empty(), "tadam {}", true);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `assert!(..)`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: replace it with `assert!(..)`
+   |
+LL -     assert_eq!(false, "a".is_empty(), "tadam {}", true);
+LL +     assert!("a".is_empty(), "tadam {}", true);
+   |
 
 error: used `debug_assert_eq!` with a literal bool
-  --> $DIR/bool_assert_comparison.rs:118:5
+  --> $DIR/bool_assert_comparison.rs:138:5
    |
 LL |     debug_assert_eq!("a".is_empty(), false, "tadam {}", 1);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `debug_assert!(..)`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: replace it with `debug_assert!(..)`
+   |
+LL -     debug_assert_eq!("a".is_empty(), false, "tadam {}", 1);
+LL +     debug_assert!("a".is_empty(), "tadam {}", 1);
+   |
 
 error: used `debug_assert_eq!` with a literal bool
-  --> $DIR/bool_assert_comparison.rs:119:5
+  --> $DIR/bool_assert_comparison.rs:139:5
    |
 LL |     debug_assert_eq!("a".is_empty(), false, "tadam {}", true);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `debug_assert!(..)`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: replace it with `debug_assert!(..)`
+   |
+LL -     debug_assert_eq!("a".is_empty(), false, "tadam {}", true);
+LL +     debug_assert!("a".is_empty(), "tadam {}", true);
+   |
 
 error: used `debug_assert_eq!` with a literal bool
-  --> $DIR/bool_assert_comparison.rs:120:5
+  --> $DIR/bool_assert_comparison.rs:140:5
    |
 LL |     debug_assert_eq!(false, "a".is_empty(), "tadam {}", true);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `debug_assert!(..)`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: replace it with `debug_assert!(..)`
+   |
+LL -     debug_assert_eq!(false, "a".is_empty(), "tadam {}", true);
+LL +     debug_assert!("a".is_empty(), "tadam {}", true);
+   |
+
+error: used `assert_eq!` with a literal bool
+  --> $DIR/bool_assert_comparison.rs:143:5
+   |
+LL |     assert_eq!(a!(), true);
+   |     ^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: replace it with `assert!(..)`
+   |
+LL -     assert_eq!(a!(), true);
+LL +     assert!(a!());
+   |
+
+error: used `assert_eq!` with a literal bool
+  --> $DIR/bool_assert_comparison.rs:144:5
+   |
+LL |     assert_eq!(true, b!());
+   |     ^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: replace it with `assert!(..)`
+   |
+LL -     assert_eq!(true, b!());
+LL +     assert!(b!());
+   |
+
+error: used `debug_assert_eq!` with a literal bool
+  --> $DIR/bool_assert_comparison.rs:148:5
+   |
+LL |     renamed!(b, true);
+   |     ^^^^^^^^^^^^^^^^^
+   |
+help: replace it with `debug_assert!(..)`
+   |
+LL -     renamed!(b, true);
+LL +     debug_assert!(b);
+   |
 
-error: aborting due to 22 previous errors
+error: aborting due to 25 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From f9f75e093259384ec2d9fb83cbc799a27d894fea Mon Sep 17 00:00:00 2001
From: Evan Typanski <evantypanski@gmail.com>
Date: Tue, 24 Jan 2023 18:18:35 -0500
Subject: Lint `unused_io_amount` with `is_ok` and `is_err`

---
 clippy_lints/src/unused_io_amount.rs |  2 +-
 tests/ui/unused_io_amount.rs         |  8 +++++++
 tests/ui/unused_io_amount.stderr     | 44 +++++++++++++++++++++++++++++++-----
 3 files changed, 47 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unused_io_amount.rs b/clippy_lints/src/unused_io_amount.rs
index 92053cec59f..0e526c216be 100644
--- a/clippy_lints/src/unused_io_amount.rs
+++ b/clippy_lints/src/unused_io_amount.rs
@@ -65,7 +65,7 @@ impl<'tcx> LateLintPass<'tcx> for UnusedIoAmount {
                 }
             },
             hir::ExprKind::MethodCall(path, arg_0, ..) => match path.ident.as_str() {
-                "expect" | "unwrap" | "unwrap_or" | "unwrap_or_else" => {
+                "expect" | "unwrap" | "unwrap_or" | "unwrap_or_else" | "is_ok" | "is_err" => {
                     check_map_error(cx, arg_0, expr);
                 },
                 _ => (),
diff --git a/tests/ui/unused_io_amount.rs b/tests/ui/unused_io_amount.rs
index 4b059558173..8d3e094b759 100644
--- a/tests/ui/unused_io_amount.rs
+++ b/tests/ui/unused_io_amount.rs
@@ -63,6 +63,14 @@ fn combine_or(file: &str) -> Result<(), Error> {
     Ok(())
 }
 
+fn is_ok_err<T: io::Read + io::Write>(s: &mut T) {
+    s.write(b"ok").is_ok();
+    s.write(b"err").is_err();
+    let mut buf = [0u8; 0];
+    s.read(&mut buf).is_ok();
+    s.read(&mut buf).is_err();
+}
+
 async fn bad_async_write<W: AsyncWrite + Unpin>(w: &mut W) {
     w.write(b"hello world").await.unwrap();
 }
diff --git a/tests/ui/unused_io_amount.stderr b/tests/ui/unused_io_amount.stderr
index 7ba7e09c0f0..0865c5213f6 100644
--- a/tests/ui/unused_io_amount.stderr
+++ b/tests/ui/unused_io_amount.stderr
@@ -82,13 +82,45 @@ LL | |         .expect("error");
 error: written amount is not handled
   --> $DIR/unused_io_amount.rs:67:5
    |
+LL |     s.write(b"ok").is_ok();
+   |     ^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use `Write::write_all` instead, or handle partial writes
+
+error: written amount is not handled
+  --> $DIR/unused_io_amount.rs:68:5
+   |
+LL |     s.write(b"err").is_err();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use `Write::write_all` instead, or handle partial writes
+
+error: read amount is not handled
+  --> $DIR/unused_io_amount.rs:70:5
+   |
+LL |     s.read(&mut buf).is_ok();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use `Read::read_exact` instead, or handle partial reads
+
+error: read amount is not handled
+  --> $DIR/unused_io_amount.rs:71:5
+   |
+LL |     s.read(&mut buf).is_err();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use `Read::read_exact` instead, or handle partial reads
+
+error: written amount is not handled
+  --> $DIR/unused_io_amount.rs:75:5
+   |
 LL |     w.write(b"hello world").await.unwrap();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: use `AsyncWriteExt::write_all` instead, or handle partial writes
 
 error: read amount is not handled
-  --> $DIR/unused_io_amount.rs:72:5
+  --> $DIR/unused_io_amount.rs:80:5
    |
 LL |     r.read(&mut buf[..]).await.unwrap();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -96,7 +128,7 @@ LL |     r.read(&mut buf[..]).await.unwrap();
    = help: use `AsyncReadExt::read_exact` instead, or handle partial reads
 
 error: written amount is not handled
-  --> $DIR/unused_io_amount.rs:85:9
+  --> $DIR/unused_io_amount.rs:93:9
    |
 LL |         w.write(b"hello world").await?;
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -104,7 +136,7 @@ LL |         w.write(b"hello world").await?;
    = help: use `AsyncWriteExt::write_all` instead, or handle partial writes
 
 error: read amount is not handled
-  --> $DIR/unused_io_amount.rs:93:9
+  --> $DIR/unused_io_amount.rs:101:9
    |
 LL |         r.read(&mut buf[..]).await.or(Err(Error::Kind))?;
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -112,7 +144,7 @@ LL |         r.read(&mut buf[..]).await.or(Err(Error::Kind))?;
    = help: use `AsyncReadExt::read_exact` instead, or handle partial reads
 
 error: written amount is not handled
-  --> $DIR/unused_io_amount.rs:101:5
+  --> $DIR/unused_io_amount.rs:109:5
    |
 LL |     w.write(b"hello world").await.unwrap();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -120,12 +152,12 @@ LL |     w.write(b"hello world").await.unwrap();
    = help: use `AsyncWriteExt::write_all` instead, or handle partial writes
 
 error: read amount is not handled
-  --> $DIR/unused_io_amount.rs:106:5
+  --> $DIR/unused_io_amount.rs:114:5
    |
 LL |     r.read(&mut buf[..]).await.unwrap();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: use `AsyncReadExt::read_exact` instead, or handle partial reads
 
-error: aborting due to 16 previous errors
+error: aborting due to 20 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 20cc72e8a8269107f3405a24861ea7f9d2d748dc Mon Sep 17 00:00:00 2001
From: Martin Fischer <martin@push-f.com>
Date: Wed, 25 Jan 2023 07:07:10 +0100
Subject: Improve span for module_name_repetitions

---
 clippy_lints/src/enum_variants.rs       |  4 ++--
 tests/ui/module_name_repetitions.stderr | 20 ++++++++++----------
 2 files changed, 12 insertions(+), 12 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/enum_variants.rs b/clippy_lints/src/enum_variants.rs
index b77b5621b4c..4c69dacf381 100644
--- a/clippy_lints/src/enum_variants.rs
+++ b/clippy_lints/src/enum_variants.rs
@@ -277,7 +277,7 @@ impl LateLintPass<'_> for EnumVariantNames {
                                 Some(c) if is_word_beginning(c) => span_lint(
                                     cx,
                                     MODULE_NAME_REPETITIONS,
-                                    item.span,
+                                    item.ident.span,
                                     "item name starts with its containing module's name",
                                 ),
                                 _ => (),
@@ -287,7 +287,7 @@ impl LateLintPass<'_> for EnumVariantNames {
                             span_lint(
                                 cx,
                                 MODULE_NAME_REPETITIONS,
-                                item.span,
+                                item.ident.span,
                                 "item name ends with its containing module's name",
                             );
                         }
diff --git a/tests/ui/module_name_repetitions.stderr b/tests/ui/module_name_repetitions.stderr
index 3f343a3e430..277801194a1 100644
--- a/tests/ui/module_name_repetitions.stderr
+++ b/tests/ui/module_name_repetitions.stderr
@@ -1,34 +1,34 @@
 error: item name starts with its containing module's name
-  --> $DIR/module_name_repetitions.rs:8:5
+  --> $DIR/module_name_repetitions.rs:8:12
    |
 LL |     pub fn foo_bar() {}
-   |     ^^^^^^^^^^^^^^^^^^^
+   |            ^^^^^^^
    |
    = note: `-D clippy::module-name-repetitions` implied by `-D warnings`
 
 error: item name ends with its containing module's name
-  --> $DIR/module_name_repetitions.rs:9:5
+  --> $DIR/module_name_repetitions.rs:9:12
    |
 LL |     pub fn bar_foo() {}
-   |     ^^^^^^^^^^^^^^^^^^^
+   |            ^^^^^^^
 
 error: item name starts with its containing module's name
-  --> $DIR/module_name_repetitions.rs:10:5
+  --> $DIR/module_name_repetitions.rs:10:16
    |
 LL |     pub struct FooCake;
-   |     ^^^^^^^^^^^^^^^^^^^
+   |                ^^^^^^^
 
 error: item name ends with its containing module's name
-  --> $DIR/module_name_repetitions.rs:11:5
+  --> $DIR/module_name_repetitions.rs:11:14
    |
 LL |     pub enum CakeFoo {}
-   |     ^^^^^^^^^^^^^^^^^^^
+   |              ^^^^^^^
 
 error: item name starts with its containing module's name
-  --> $DIR/module_name_repetitions.rs:12:5
+  --> $DIR/module_name_repetitions.rs:12:16
    |
 LL |     pub struct Foo7Bar;
-   |     ^^^^^^^^^^^^^^^^^^^
+   |                ^^^^^^^
 
 error: aborting due to 5 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 986f40fab0828257016477174f9a6036a4a7f4d3 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Thu, 26 Jan 2023 15:30:44 +0000
Subject: `invalid_regex`: Show full error when string value doesn't match
 source

---
 clippy_lints/src/regex.rs | 89 +++++++++++++++++++++++------------------------
 tests/ui/regex.rs         |  4 +++
 tests/ui/regex.stderr     | 66 ++++++++++++++++++++++++++---------
 3 files changed, 97 insertions(+), 62 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/regex.rs b/clippy_lints/src/regex.rs
index 1fda58fa54d..9e6c6c73d4f 100644
--- a/clippy_lints/src/regex.rs
+++ b/clippy_lints/src/regex.rs
@@ -1,5 +1,8 @@
+use std::fmt::Display;
+
 use clippy_utils::consts::{constant, Constant};
 use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
+use clippy_utils::source::snippet_opt;
 use clippy_utils::{match_def_path, paths};
 use if_chain::if_chain;
 use rustc_ast::ast::{LitKind, StrStyle};
@@ -77,13 +80,45 @@ impl<'tcx> LateLintPass<'tcx> for Regex {
     }
 }
 
-#[must_use]
-fn str_span(base: Span, c: regex_syntax::ast::Span, offset: u8) -> Span {
-    let offset = u32::from(offset);
-    let end = base.lo() + BytePos(u32::try_from(c.end.offset).expect("offset too large") + offset);
-    let start = base.lo() + BytePos(u32::try_from(c.start.offset).expect("offset too large") + offset);
-    assert!(start <= end);
-    Span::new(start, end, base.ctxt(), base.parent())
+fn lint_syntax_error(cx: &LateContext<'_>, error: &regex_syntax::Error, unescaped: &str, base: Span, offset: u8) {
+    let parts: Option<(_, _, &dyn Display)> = match &error {
+        regex_syntax::Error::Parse(e) => Some((e.span(), e.auxiliary_span(), e.kind())),
+        regex_syntax::Error::Translate(e) => Some((e.span(), None, e.kind())),
+        _ => None,
+    };
+
+    let convert_span = |regex_span: &regex_syntax::ast::Span| {
+        let offset = u32::from(offset);
+        let start = base.lo() + BytePos(u32::try_from(regex_span.start.offset).expect("offset too large") + offset);
+        let end = base.lo() + BytePos(u32::try_from(regex_span.end.offset).expect("offset too large") + offset);
+
+        Span::new(start, end, base.ctxt(), base.parent())
+    };
+
+    if let Some((primary, auxiliary, kind)) = parts
+        && let Some(literal_snippet) = snippet_opt(cx, base)
+        && let Some(inner) = literal_snippet.get(offset as usize..)
+        // Only convert to native rustc spans if the parsed regex matches the
+        // source snippet exactly, to ensure the span offsets are correct
+        && inner.get(..unescaped.len()) == Some(unescaped)
+    {
+        let spans = if let Some(auxiliary) = auxiliary {
+            vec![convert_span(primary), convert_span(auxiliary)]
+        } else {
+            vec![convert_span(primary)]
+        };
+
+        span_lint(cx, INVALID_REGEX, spans, &format!("regex syntax error: {kind}"));
+    } else {
+        span_lint_and_help(
+            cx,
+            INVALID_REGEX,
+            base,
+            &error.to_string(),
+            None,
+            "consider using a raw string literal: `r\"..\"`",
+        );
+    }
 }
 
 fn const_str<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> Option<String> {
@@ -155,25 +190,7 @@ fn check_regex<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, utf8: bool) {
                         span_lint_and_help(cx, TRIVIAL_REGEX, expr.span, "trivial regex", None, repl);
                     }
                 },
-                Err(regex_syntax::Error::Parse(e)) => {
-                    span_lint(
-                        cx,
-                        INVALID_REGEX,
-                        str_span(expr.span, *e.span(), offset),
-                        &format!("regex syntax error: {}", e.kind()),
-                    );
-                },
-                Err(regex_syntax::Error::Translate(e)) => {
-                    span_lint(
-                        cx,
-                        INVALID_REGEX,
-                        str_span(expr.span, *e.span(), offset),
-                        &format!("regex syntax error: {}", e.kind()),
-                    );
-                },
-                Err(e) => {
-                    span_lint(cx, INVALID_REGEX, expr.span, &format!("regex syntax error: {e}"));
-                },
+                Err(e) => lint_syntax_error(cx, &e, r, expr.span, offset),
             }
         }
     } else if let Some(r) = const_str(cx, expr) {
@@ -183,25 +200,7 @@ fn check_regex<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, utf8: bool) {
                     span_lint_and_help(cx, TRIVIAL_REGEX, expr.span, "trivial regex", None, repl);
                 }
             },
-            Err(regex_syntax::Error::Parse(e)) => {
-                span_lint(
-                    cx,
-                    INVALID_REGEX,
-                    expr.span,
-                    &format!("regex syntax error on position {}: {}", e.span().start.offset, e.kind()),
-                );
-            },
-            Err(regex_syntax::Error::Translate(e)) => {
-                span_lint(
-                    cx,
-                    INVALID_REGEX,
-                    expr.span,
-                    &format!("regex syntax error on position {}: {}", e.span().start.offset, e.kind()),
-                );
-            },
-            Err(e) => {
-                span_lint(cx, INVALID_REGEX, expr.span, &format!("regex syntax error: {e}"));
-            },
+            Err(e) => span_lint(cx, INVALID_REGEX, expr.span, &e.to_string()),
         }
     }
 }
diff --git a/tests/ui/regex.rs b/tests/ui/regex.rs
index f0e1a8128d7..ab8ac97a0e7 100644
--- a/tests/ui/regex.rs
+++ b/tests/ui/regex.rs
@@ -36,6 +36,10 @@ fn syntax_error() {
 
     let raw_string_error = Regex::new(r"[...\/...]");
     let raw_string_error = Regex::new(r#"[...\/...]"#);
+
+    let escaped_string_span = Regex::new("\\b\\c");
+
+    let aux_span = Regex::new("(?ixi)");
 }
 
 fn trivial_regex() {
diff --git a/tests/ui/regex.stderr b/tests/ui/regex.stderr
index 2424644c6f6..c2440f39e0a 100644
--- a/tests/ui/regex.stderr
+++ b/tests/ui/regex.stderr
@@ -29,7 +29,10 @@ error: regex syntax error: invalid character class range, the start must be <= t
 LL |     let some_unicode = Regex::new("[é-è]");
    |                                     ^^^
 
-error: regex syntax error on position 0: unclosed group
+error: regex parse error:
+           (
+           ^
+       error: unclosed group
   --> $DIR/regex.rs:18:33
    |
 LL |     let some_regex = Regex::new(OPENING_PAREN);
@@ -43,25 +46,37 @@ LL |     let binary_pipe_in_wrong_position = BRegex::new("|");
    |
    = help: the regex is unlikely to be useful as it is
 
-error: regex syntax error on position 0: unclosed group
+error: regex parse error:
+           (
+           ^
+       error: unclosed group
   --> $DIR/regex.rs:21:41
    |
 LL |     let some_binary_regex = BRegex::new(OPENING_PAREN);
    |                                         ^^^^^^^^^^^^^
 
-error: regex syntax error on position 0: unclosed group
+error: regex parse error:
+           (
+           ^
+       error: unclosed group
   --> $DIR/regex.rs:22:56
    |
 LL |     let some_binary_regex_builder = BRegexBuilder::new(OPENING_PAREN);
    |                                                        ^^^^^^^^^^^^^
 
-error: regex syntax error on position 0: unclosed group
+error: regex parse error:
+           (
+           ^
+       error: unclosed group
   --> $DIR/regex.rs:34:37
    |
 LL |     let set_error = RegexSet::new(&[OPENING_PAREN, r"[a-z]+/.(com|org|net)"]);
    |                                     ^^^^^^^^^^^^^
 
-error: regex syntax error on position 0: unclosed group
+error: regex parse error:
+           (
+           ^
+       error: unclosed group
   --> $DIR/regex.rs:35:39
    |
 LL |     let bset_error = BRegexSet::new(&[OPENING_PAREN, r"[a-z]+/.(com|org|net)"]);
@@ -79,8 +94,25 @@ error: regex syntax error: unrecognized escape sequence
 LL |     let raw_string_error = Regex::new(r#"[...//...]"#);
    |                                              ^^
 
+error: regex parse error:
+           /b/c
+             ^^
+       error: unrecognized escape sequence
+  --> $DIR/regex.rs:40:42
+   |
+LL |     let escaped_string_span = Regex::new("/b/c");
+   |                                          ^^^^^^^^
+   |
+   = help: consider using a raw string literal: `r".."`
+
+error: regex syntax error: duplicate flag
+  --> $DIR/regex.rs:42:34
+   |
+LL |     let aux_span = Regex::new("(?ixi)");
+   |                                  ^ ^
+
 error: trivial regex
-  --> $DIR/regex.rs:42:33
+  --> $DIR/regex.rs:46:33
    |
 LL |     let trivial_eq = Regex::new("^foobar$");
    |                                 ^^^^^^^^^^
@@ -88,7 +120,7 @@ LL |     let trivial_eq = Regex::new("^foobar$");
    = help: consider using `==` on `str`s
 
 error: trivial regex
-  --> $DIR/regex.rs:44:48
+  --> $DIR/regex.rs:48:48
    |
 LL |     let trivial_eq_builder = RegexBuilder::new("^foobar$");
    |                                                ^^^^^^^^^^
@@ -96,7 +128,7 @@ LL |     let trivial_eq_builder = RegexBuilder::new("^foobar$");
    = help: consider using `==` on `str`s
 
 error: trivial regex
-  --> $DIR/regex.rs:46:42
+  --> $DIR/regex.rs:50:42
    |
 LL |     let trivial_starts_with = Regex::new("^foobar");
    |                                          ^^^^^^^^^
@@ -104,7 +136,7 @@ LL |     let trivial_starts_with = Regex::new("^foobar");
    = help: consider using `str::starts_with`
 
 error: trivial regex
-  --> $DIR/regex.rs:48:40
+  --> $DIR/regex.rs:52:40
    |
 LL |     let trivial_ends_with = Regex::new("foobar$");
    |                                        ^^^^^^^^^
@@ -112,7 +144,7 @@ LL |     let trivial_ends_with = Regex::new("foobar$");
    = help: consider using `str::ends_with`
 
 error: trivial regex
-  --> $DIR/regex.rs:50:39
+  --> $DIR/regex.rs:54:39
    |
 LL |     let trivial_contains = Regex::new("foobar");
    |                                       ^^^^^^^^
@@ -120,7 +152,7 @@ LL |     let trivial_contains = Regex::new("foobar");
    = help: consider using `str::contains`
 
 error: trivial regex
-  --> $DIR/regex.rs:52:39
+  --> $DIR/regex.rs:56:39
    |
 LL |     let trivial_contains = Regex::new(NOT_A_REAL_REGEX);
    |                                       ^^^^^^^^^^^^^^^^
@@ -128,7 +160,7 @@ LL |     let trivial_contains = Regex::new(NOT_A_REAL_REGEX);
    = help: consider using `str::contains`
 
 error: trivial regex
-  --> $DIR/regex.rs:54:40
+  --> $DIR/regex.rs:58:40
    |
 LL |     let trivial_backslash = Regex::new("a/.b");
    |                                        ^^^^^^^
@@ -136,7 +168,7 @@ LL |     let trivial_backslash = Regex::new("a/.b");
    = help: consider using `str::contains`
 
 error: trivial regex
-  --> $DIR/regex.rs:57:36
+  --> $DIR/regex.rs:61:36
    |
 LL |     let trivial_empty = Regex::new("");
    |                                    ^^
@@ -144,7 +176,7 @@ LL |     let trivial_empty = Regex::new("");
    = help: the regex is unlikely to be useful as it is
 
 error: trivial regex
-  --> $DIR/regex.rs:59:36
+  --> $DIR/regex.rs:63:36
    |
 LL |     let trivial_empty = Regex::new("^");
    |                                    ^^^
@@ -152,7 +184,7 @@ LL |     let trivial_empty = Regex::new("^");
    = help: the regex is unlikely to be useful as it is
 
 error: trivial regex
-  --> $DIR/regex.rs:61:36
+  --> $DIR/regex.rs:65:36
    |
 LL |     let trivial_empty = Regex::new("^$");
    |                                    ^^^^
@@ -160,12 +192,12 @@ LL |     let trivial_empty = Regex::new("^$");
    = help: consider using `str::is_empty`
 
 error: trivial regex
-  --> $DIR/regex.rs:63:44
+  --> $DIR/regex.rs:67:44
    |
 LL |     let binary_trivial_empty = BRegex::new("^$");
    |                                            ^^^^
    |
    = help: consider using `str::is_empty`
 
-error: aborting due to 23 previous errors
+error: aborting due to 25 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From a1a01c19f15d597215911e966667e0d35905e967 Mon Sep 17 00:00:00 2001
From: Collin Styles <collingstyles@gmail.com>
Date: Thu, 26 Jan 2023 16:44:44 -0800
Subject: Fix docs for `suspicious_xor_used_as_pow` lint

There was a tab after the three leading slashes which caused the
contents of the "Why is this bad?" section to be rendered as a code
block.
---
 clippy_lints/src/suspicious_xor_used_as_pow.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/suspicious_xor_used_as_pow.rs b/clippy_lints/src/suspicious_xor_used_as_pow.rs
index c181919b164..9c0dc8096d0 100644
--- a/clippy_lints/src/suspicious_xor_used_as_pow.rs
+++ b/clippy_lints/src/suspicious_xor_used_as_pow.rs
@@ -9,7 +9,7 @@ declare_clippy_lint! {
     /// ### What it does
     /// Warns for a Bitwise XOR (`^`) operator being probably confused as a powering. It will not trigger if any of the numbers are not in decimal.
     /// ### Why is this bad?
-    ///	It's most probably a typo and may lead to unexpected behaviours.
+    /// It's most probably a typo and may lead to unexpected behaviours.
     /// ### Example
     /// ```rust
     /// let x = 3_i32 ^ 4_i32;
-- 
cgit 1.4.1-3-g733a5


From a0460cf37d010643c1c7fa1c26923c3d61075e3f Mon Sep 17 00:00:00 2001
From: koka <koka.code@gmail.com>
Date: Sun, 29 Jan 2023 01:49:10 +0900
Subject: add COLLAPSIBLE_STR_REPLACE in msrv

COLLAPSIBLE_STR_REPLACE uses msrvs::PATTERN_TRAIT_CHAR_ARRAY
---
 book/src/lint_configuration.md | 1 +
 clippy_lints/src/utils/conf.rs | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/book/src/lint_configuration.md b/book/src/lint_configuration.md
index f79dbb50ff4..6068b4aa950 100644
--- a/book/src/lint_configuration.md
+++ b/book/src/lint_configuration.md
@@ -167,6 +167,7 @@ The minimum rust version that the project supports
 * [manual_clamp](https://rust-lang.github.io/rust-clippy/master/index.html#manual_clamp)
 * [manual_let_else](https://rust-lang.github.io/rust-clippy/master/index.html#manual_let_else)
 * [unchecked_duration_subtraction](https://rust-lang.github.io/rust-clippy/master/index.html#unchecked_duration_subtraction)
+* [collapsible_str_replace](https://rust-lang.github.io/rust-clippy/master/index.html#collapsible_str_replace)
 
 
 ### cognitive-complexity-threshold
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index f48be27592b..e81e983e3c1 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -253,7 +253,7 @@ define_Conf! {
     ///
     /// Suppress lints whenever the suggested change would cause breakage for other crates.
     (avoid_breaking_exported_api: bool = true),
-    /// Lint: MANUAL_SPLIT_ONCE, MANUAL_STR_REPEAT, CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR, IF_THEN_SOME_ELSE_NONE, APPROX_CONSTANT, DEPRECATED_CFG_ATTR, INDEX_REFUTABLE_SLICE, MAP_CLONE, BORROW_AS_PTR, MANUAL_BITS, ERR_EXPECT, CAST_ABS_TO_UNSIGNED, UNINLINED_FORMAT_ARGS, MANUAL_CLAMP, MANUAL_LET_ELSE, UNCHECKED_DURATION_SUBTRACTION.
+    /// Lint: MANUAL_SPLIT_ONCE, MANUAL_STR_REPEAT, CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR, IF_THEN_SOME_ELSE_NONE, APPROX_CONSTANT, DEPRECATED_CFG_ATTR, INDEX_REFUTABLE_SLICE, MAP_CLONE, BORROW_AS_PTR, MANUAL_BITS, ERR_EXPECT, CAST_ABS_TO_UNSIGNED, UNINLINED_FORMAT_ARGS, MANUAL_CLAMP, MANUAL_LET_ELSE, UNCHECKED_DURATION_SUBTRACTION, COLLAPSIBLE_STR_REPLACE.
     ///
     /// The minimum rust version that the project supports
     (msrv: Option<String> = None),
-- 
cgit 1.4.1-3-g733a5


From 5a9c4a009052ad5e5baf6f9ee8450136e1bde939 Mon Sep 17 00:00:00 2001
From: koka <koka.code@gmail.com>
Date: Sun, 29 Jan 2023 01:52:05 +0900
Subject: add SEEK_FROM_CURRENT in msrv

SEEK_FROM_CURRENT uses msrvs::SEEK_FROM_CURRENT
---
 book/src/lint_configuration.md | 1 +
 clippy_lints/src/utils/conf.rs | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/book/src/lint_configuration.md b/book/src/lint_configuration.md
index 6068b4aa950..7c8a3291f94 100644
--- a/book/src/lint_configuration.md
+++ b/book/src/lint_configuration.md
@@ -168,6 +168,7 @@ The minimum rust version that the project supports
 * [manual_let_else](https://rust-lang.github.io/rust-clippy/master/index.html#manual_let_else)
 * [unchecked_duration_subtraction](https://rust-lang.github.io/rust-clippy/master/index.html#unchecked_duration_subtraction)
 * [collapsible_str_replace](https://rust-lang.github.io/rust-clippy/master/index.html#collapsible_str_replace)
+* [seek_from_current](https://rust-lang.github.io/rust-clippy/master/index.html#seek_from_current)
 
 
 ### cognitive-complexity-threshold
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index e81e983e3c1..36ca69c23f7 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -253,7 +253,7 @@ define_Conf! {
     ///
     /// Suppress lints whenever the suggested change would cause breakage for other crates.
     (avoid_breaking_exported_api: bool = true),
-    /// Lint: MANUAL_SPLIT_ONCE, MANUAL_STR_REPEAT, CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR, IF_THEN_SOME_ELSE_NONE, APPROX_CONSTANT, DEPRECATED_CFG_ATTR, INDEX_REFUTABLE_SLICE, MAP_CLONE, BORROW_AS_PTR, MANUAL_BITS, ERR_EXPECT, CAST_ABS_TO_UNSIGNED, UNINLINED_FORMAT_ARGS, MANUAL_CLAMP, MANUAL_LET_ELSE, UNCHECKED_DURATION_SUBTRACTION, COLLAPSIBLE_STR_REPLACE.
+    /// Lint: MANUAL_SPLIT_ONCE, MANUAL_STR_REPEAT, CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR, IF_THEN_SOME_ELSE_NONE, APPROX_CONSTANT, DEPRECATED_CFG_ATTR, INDEX_REFUTABLE_SLICE, MAP_CLONE, BORROW_AS_PTR, MANUAL_BITS, ERR_EXPECT, CAST_ABS_TO_UNSIGNED, UNINLINED_FORMAT_ARGS, MANUAL_CLAMP, MANUAL_LET_ELSE, UNCHECKED_DURATION_SUBTRACTION, COLLAPSIBLE_STR_REPLACE, SEEK_FROM_CURRENT.
     ///
     /// The minimum rust version that the project supports
     (msrv: Option<String> = None),
-- 
cgit 1.4.1-3-g733a5


From a05e86f5ddcc976ac1d44692bafd92dfd65b62a6 Mon Sep 17 00:00:00 2001
From: koka <koka.code@gmail.com>
Date: Sun, 29 Jan 2023 01:54:31 +0900
Subject: add SEEK_REWIND in msrv

SEEK_REWIND uses msrvs::SEEK_REWIND
---
 book/src/lint_configuration.md | 1 +
 clippy_lints/src/utils/conf.rs | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/book/src/lint_configuration.md b/book/src/lint_configuration.md
index 7c8a3291f94..4c204d93e0a 100644
--- a/book/src/lint_configuration.md
+++ b/book/src/lint_configuration.md
@@ -169,6 +169,7 @@ The minimum rust version that the project supports
 * [unchecked_duration_subtraction](https://rust-lang.github.io/rust-clippy/master/index.html#unchecked_duration_subtraction)
 * [collapsible_str_replace](https://rust-lang.github.io/rust-clippy/master/index.html#collapsible_str_replace)
 * [seek_from_current](https://rust-lang.github.io/rust-clippy/master/index.html#seek_from_current)
+* [seek_rewind](https://rust-lang.github.io/rust-clippy/master/index.html#seek_rewind)
 
 
 ### cognitive-complexity-threshold
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 36ca69c23f7..33ca3c16a24 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -253,7 +253,7 @@ define_Conf! {
     ///
     /// Suppress lints whenever the suggested change would cause breakage for other crates.
     (avoid_breaking_exported_api: bool = true),
-    /// Lint: MANUAL_SPLIT_ONCE, MANUAL_STR_REPEAT, CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR, IF_THEN_SOME_ELSE_NONE, APPROX_CONSTANT, DEPRECATED_CFG_ATTR, INDEX_REFUTABLE_SLICE, MAP_CLONE, BORROW_AS_PTR, MANUAL_BITS, ERR_EXPECT, CAST_ABS_TO_UNSIGNED, UNINLINED_FORMAT_ARGS, MANUAL_CLAMP, MANUAL_LET_ELSE, UNCHECKED_DURATION_SUBTRACTION, COLLAPSIBLE_STR_REPLACE, SEEK_FROM_CURRENT.
+    /// Lint: MANUAL_SPLIT_ONCE, MANUAL_STR_REPEAT, CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR, IF_THEN_SOME_ELSE_NONE, APPROX_CONSTANT, DEPRECATED_CFG_ATTR, INDEX_REFUTABLE_SLICE, MAP_CLONE, BORROW_AS_PTR, MANUAL_BITS, ERR_EXPECT, CAST_ABS_TO_UNSIGNED, UNINLINED_FORMAT_ARGS, MANUAL_CLAMP, MANUAL_LET_ELSE, UNCHECKED_DURATION_SUBTRACTION, COLLAPSIBLE_STR_REPLACE, SEEK_FROM_CURRENT, SEEK_REWIND.
     ///
     /// The minimum rust version that the project supports
     (msrv: Option<String> = None),
-- 
cgit 1.4.1-3-g733a5


From 532841fcae289ff328ddbb10587695b2c6965771 Mon Sep 17 00:00:00 2001
From: koka <koka.code@gmail.com>
Date: Sun, 29 Jan 2023 02:02:46 +0900
Subject: add UNNECESSARY_LAZY_EVALUATIONS to msrv

UNNECESSARY_LAZY_EVALUATIONS uses msrvs::BOOL_THEN_SOME for `then` to
`then_some`
---
 book/src/lint_configuration.md  | 1 +
 clippy_lints/src/methods/mod.rs | 1 +
 clippy_lints/src/utils/conf.rs  | 2 +-
 3 files changed, 3 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/book/src/lint_configuration.md b/book/src/lint_configuration.md
index 4c204d93e0a..d24b5259a0b 100644
--- a/book/src/lint_configuration.md
+++ b/book/src/lint_configuration.md
@@ -170,6 +170,7 @@ The minimum rust version that the project supports
 * [collapsible_str_replace](https://rust-lang.github.io/rust-clippy/master/index.html#collapsible_str_replace)
 * [seek_from_current](https://rust-lang.github.io/rust-clippy/master/index.html#seek_from_current)
 * [seek_rewind](https://rust-lang.github.io/rust-clippy/master/index.html#seek_rewind)
+* [unnecessary_lazy_evaluations](https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_lazy_evaluations)
 
 
 ### cognitive-complexity-threshold
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 42377a3d138..6a1575e182f 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1818,6 +1818,7 @@ declare_clippy_lint! {
     ///  - `or_else` to `or`
     ///  - `get_or_insert_with` to `get_or_insert`
     ///  - `ok_or_else` to `ok_or`
+    ///  - `then` to `then_some` (for msrv >= 1.62.0)
     ///
     /// ### Why is this bad?
     /// Using eager evaluation is shorter and simpler in some cases.
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 33ca3c16a24..21301e2e31b 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -253,7 +253,7 @@ define_Conf! {
     ///
     /// Suppress lints whenever the suggested change would cause breakage for other crates.
     (avoid_breaking_exported_api: bool = true),
-    /// Lint: MANUAL_SPLIT_ONCE, MANUAL_STR_REPEAT, CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR, IF_THEN_SOME_ELSE_NONE, APPROX_CONSTANT, DEPRECATED_CFG_ATTR, INDEX_REFUTABLE_SLICE, MAP_CLONE, BORROW_AS_PTR, MANUAL_BITS, ERR_EXPECT, CAST_ABS_TO_UNSIGNED, UNINLINED_FORMAT_ARGS, MANUAL_CLAMP, MANUAL_LET_ELSE, UNCHECKED_DURATION_SUBTRACTION, COLLAPSIBLE_STR_REPLACE, SEEK_FROM_CURRENT, SEEK_REWIND.
+    /// Lint: MANUAL_SPLIT_ONCE, MANUAL_STR_REPEAT, CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR, IF_THEN_SOME_ELSE_NONE, APPROX_CONSTANT, DEPRECATED_CFG_ATTR, INDEX_REFUTABLE_SLICE, MAP_CLONE, BORROW_AS_PTR, MANUAL_BITS, ERR_EXPECT, CAST_ABS_TO_UNSIGNED, UNINLINED_FORMAT_ARGS, MANUAL_CLAMP, MANUAL_LET_ELSE, UNCHECKED_DURATION_SUBTRACTION, COLLAPSIBLE_STR_REPLACE, SEEK_FROM_CURRENT, SEEK_REWIND, UNNECESSARY_LAZY_EVALUATIONS.
     ///
     /// The minimum rust version that the project supports
     (msrv: Option<String> = None),
-- 
cgit 1.4.1-3-g733a5


From 07a8bf15ff4fa044670bd9e6d5b823bfff84f1a9 Mon Sep 17 00:00:00 2001
From: koka <koka.code@gmail.com>
Date: Sun, 29 Jan 2023 02:14:38 +0900
Subject: add TRANSMUTE_PTR_TO_REF to msrv

TRANSMUTE_PTR_TO_REF uses msrvs::POINTER_CAST
---
 book/src/lint_configuration.md | 1 +
 clippy_lints/src/utils/conf.rs | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/book/src/lint_configuration.md b/book/src/lint_configuration.md
index d24b5259a0b..c621dec1d60 100644
--- a/book/src/lint_configuration.md
+++ b/book/src/lint_configuration.md
@@ -171,6 +171,7 @@ The minimum rust version that the project supports
 * [seek_from_current](https://rust-lang.github.io/rust-clippy/master/index.html#seek_from_current)
 * [seek_rewind](https://rust-lang.github.io/rust-clippy/master/index.html#seek_rewind)
 * [unnecessary_lazy_evaluations](https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_lazy_evaluations)
+* [transmute_ptr_to_ref](https://rust-lang.github.io/rust-clippy/master/index.html#transmute_ptr_to_ref)
 
 
 ### cognitive-complexity-threshold
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 21301e2e31b..5e7ae71ea36 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -253,7 +253,7 @@ define_Conf! {
     ///
     /// Suppress lints whenever the suggested change would cause breakage for other crates.
     (avoid_breaking_exported_api: bool = true),
-    /// Lint: MANUAL_SPLIT_ONCE, MANUAL_STR_REPEAT, CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR, IF_THEN_SOME_ELSE_NONE, APPROX_CONSTANT, DEPRECATED_CFG_ATTR, INDEX_REFUTABLE_SLICE, MAP_CLONE, BORROW_AS_PTR, MANUAL_BITS, ERR_EXPECT, CAST_ABS_TO_UNSIGNED, UNINLINED_FORMAT_ARGS, MANUAL_CLAMP, MANUAL_LET_ELSE, UNCHECKED_DURATION_SUBTRACTION, COLLAPSIBLE_STR_REPLACE, SEEK_FROM_CURRENT, SEEK_REWIND, UNNECESSARY_LAZY_EVALUATIONS.
+    /// Lint: MANUAL_SPLIT_ONCE, MANUAL_STR_REPEAT, CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR, IF_THEN_SOME_ELSE_NONE, APPROX_CONSTANT, DEPRECATED_CFG_ATTR, INDEX_REFUTABLE_SLICE, MAP_CLONE, BORROW_AS_PTR, MANUAL_BITS, ERR_EXPECT, CAST_ABS_TO_UNSIGNED, UNINLINED_FORMAT_ARGS, MANUAL_CLAMP, MANUAL_LET_ELSE, UNCHECKED_DURATION_SUBTRACTION, COLLAPSIBLE_STR_REPLACE, SEEK_FROM_CURRENT, SEEK_REWIND, UNNECESSARY_LAZY_EVALUATIONS, TRANSMUTE_PTR_TO_REF.
     ///
     /// The minimum rust version that the project supports
     (msrv: Option<String> = None),
-- 
cgit 1.4.1-3-g733a5


From e65f9f9d32e53ce4edbd1bee96f4e5cdf67e1624 Mon Sep 17 00:00:00 2001
From: koka <koka.code@gmail.com>
Date: Sun, 29 Jan 2023 02:22:10 +0900
Subject: add ALMOST_COMPLETE_RANGE to msrv ALMOST_COMPLETE_RANGE uses
 msrvs::RANGE_INCLUSIVE

---
 book/src/lint_configuration.md | 1 +
 clippy_lints/src/utils/conf.rs | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/book/src/lint_configuration.md b/book/src/lint_configuration.md
index c621dec1d60..9b4460fc655 100644
--- a/book/src/lint_configuration.md
+++ b/book/src/lint_configuration.md
@@ -172,6 +172,7 @@ The minimum rust version that the project supports
 * [seek_rewind](https://rust-lang.github.io/rust-clippy/master/index.html#seek_rewind)
 * [unnecessary_lazy_evaluations](https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_lazy_evaluations)
 * [transmute_ptr_to_ref](https://rust-lang.github.io/rust-clippy/master/index.html#transmute_ptr_to_ref)
+* [almost_complete_range](https://rust-lang.github.io/rust-clippy/master/index.html#almost_complete_range)
 
 
 ### cognitive-complexity-threshold
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 5e7ae71ea36..c7aec62c1ee 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -253,7 +253,7 @@ define_Conf! {
     ///
     /// Suppress lints whenever the suggested change would cause breakage for other crates.
     (avoid_breaking_exported_api: bool = true),
-    /// Lint: MANUAL_SPLIT_ONCE, MANUAL_STR_REPEAT, CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR, IF_THEN_SOME_ELSE_NONE, APPROX_CONSTANT, DEPRECATED_CFG_ATTR, INDEX_REFUTABLE_SLICE, MAP_CLONE, BORROW_AS_PTR, MANUAL_BITS, ERR_EXPECT, CAST_ABS_TO_UNSIGNED, UNINLINED_FORMAT_ARGS, MANUAL_CLAMP, MANUAL_LET_ELSE, UNCHECKED_DURATION_SUBTRACTION, COLLAPSIBLE_STR_REPLACE, SEEK_FROM_CURRENT, SEEK_REWIND, UNNECESSARY_LAZY_EVALUATIONS, TRANSMUTE_PTR_TO_REF.
+    /// Lint: MANUAL_SPLIT_ONCE, MANUAL_STR_REPEAT, CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR, IF_THEN_SOME_ELSE_NONE, APPROX_CONSTANT, DEPRECATED_CFG_ATTR, INDEX_REFUTABLE_SLICE, MAP_CLONE, BORROW_AS_PTR, MANUAL_BITS, ERR_EXPECT, CAST_ABS_TO_UNSIGNED, UNINLINED_FORMAT_ARGS, MANUAL_CLAMP, MANUAL_LET_ELSE, UNCHECKED_DURATION_SUBTRACTION, COLLAPSIBLE_STR_REPLACE, SEEK_FROM_CURRENT, SEEK_REWIND, UNNECESSARY_LAZY_EVALUATIONS, TRANSMUTE_PTR_TO_REF, ALMOST_COMPLETE_RANGE.
     ///
     /// The minimum rust version that the project supports
     (msrv: Option<String> = None),
-- 
cgit 1.4.1-3-g733a5


From 7716d69757ec65e11332ea222e1c83aafd1f53db Mon Sep 17 00:00:00 2001
From: koka <koka.code@gmail.com>
Date: Sun, 29 Jan 2023 02:27:43 +0900
Subject: fix: add missing dot to AWAIT_HOLDING_INVALID_TYPE

---
 book/src/lint_configuration.md | 9 +++++++++
 clippy_lints/src/utils/conf.rs | 2 +-
 2 files changed, 10 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/book/src/lint_configuration.md b/book/src/lint_configuration.md
index 9b4460fc655..d425b46be51 100644
--- a/book/src/lint_configuration.md
+++ b/book/src/lint_configuration.md
@@ -43,6 +43,7 @@ Please use that command to update the file and do not edit it by hand.
 | [allowed-scripts](#allowed-scripts) | `["Latin"]` |
 | [enable-raw-pointer-heuristic-for-send](#enable-raw-pointer-heuristic-for-send) | `true` |
 | [max-suggested-slice-pattern-length](#max-suggested-slice-pattern-length) | `3` |
+| [await-holding-invalid-types](#await-holding-invalid-types) | `[]` |
 | [max-include-file-size](#max-include-file-size) | `1000000` |
 | [allow-expect-in-tests](#allow-expect-in-tests) | `false` |
 | [allow-unwrap-in-tests](#allow-unwrap-in-tests) | `false` |
@@ -448,6 +449,14 @@ For example, `[_, _, _, e, ..]` is a slice pattern with 4 elements.
 * [index_refutable_slice](https://rust-lang.github.io/rust-clippy/master/index.html#index_refutable_slice)
 
 
+### await-holding-invalid-types
+
+
+**Default Value:** `[]` (`Vec<crate::utils::conf::DisallowedPath>`)
+
+* [await_holding_invalid_type](https://rust-lang.github.io/rust-clippy/master/index.html#await_holding_invalid_type)
+
+
 ### max-include-file-size
 The maximum size of a file included via `include_bytes!()` or `include_str!()`, in bytes
 
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index c7aec62c1ee..1b0aa9a63ed 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -411,7 +411,7 @@ define_Conf! {
     /// the slice pattern that is suggested. If more elements would be necessary, the lint is suppressed.
     /// For example, `[_, _, _, e, ..]` is a slice pattern with 4 elements.
     (max_suggested_slice_pattern_length: u64 = 3),
-    /// Lint: AWAIT_HOLDING_INVALID_TYPE
+    /// Lint: AWAIT_HOLDING_INVALID_TYPE.
     (await_holding_invalid_types: Vec<crate::utils::conf::DisallowedPath> = Vec::new()),
     /// Lint: LARGE_INCLUDE_FILE.
     ///
-- 
cgit 1.4.1-3-g733a5


From fb77b027891daf4c730e3f80852ce446fef9beab Mon Sep 17 00:00:00 2001
From: koka <koka.code@gmail.com>
Date: Sun, 29 Jan 2023 02:37:00 +0900
Subject: add NEEDLESS_BORROW to msrv

NEEDLESS_BORROW uses msrvs::ARRAY_INTO_ITERATOR
---
 book/src/lint_configuration.md | 1 +
 clippy_lints/src/utils/conf.rs | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/book/src/lint_configuration.md b/book/src/lint_configuration.md
index d425b46be51..9bd4e72fe8f 100644
--- a/book/src/lint_configuration.md
+++ b/book/src/lint_configuration.md
@@ -174,6 +174,7 @@ The minimum rust version that the project supports
 * [unnecessary_lazy_evaluations](https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_lazy_evaluations)
 * [transmute_ptr_to_ref](https://rust-lang.github.io/rust-clippy/master/index.html#transmute_ptr_to_ref)
 * [almost_complete_range](https://rust-lang.github.io/rust-clippy/master/index.html#almost_complete_range)
+* [needless_borrow](https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow)
 
 
 ### cognitive-complexity-threshold
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 1b0aa9a63ed..7364729606b 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -253,7 +253,7 @@ define_Conf! {
     ///
     /// Suppress lints whenever the suggested change would cause breakage for other crates.
     (avoid_breaking_exported_api: bool = true),
-    /// Lint: MANUAL_SPLIT_ONCE, MANUAL_STR_REPEAT, CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR, IF_THEN_SOME_ELSE_NONE, APPROX_CONSTANT, DEPRECATED_CFG_ATTR, INDEX_REFUTABLE_SLICE, MAP_CLONE, BORROW_AS_PTR, MANUAL_BITS, ERR_EXPECT, CAST_ABS_TO_UNSIGNED, UNINLINED_FORMAT_ARGS, MANUAL_CLAMP, MANUAL_LET_ELSE, UNCHECKED_DURATION_SUBTRACTION, COLLAPSIBLE_STR_REPLACE, SEEK_FROM_CURRENT, SEEK_REWIND, UNNECESSARY_LAZY_EVALUATIONS, TRANSMUTE_PTR_TO_REF, ALMOST_COMPLETE_RANGE.
+    /// Lint: MANUAL_SPLIT_ONCE, MANUAL_STR_REPEAT, CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR, IF_THEN_SOME_ELSE_NONE, APPROX_CONSTANT, DEPRECATED_CFG_ATTR, INDEX_REFUTABLE_SLICE, MAP_CLONE, BORROW_AS_PTR, MANUAL_BITS, ERR_EXPECT, CAST_ABS_TO_UNSIGNED, UNINLINED_FORMAT_ARGS, MANUAL_CLAMP, MANUAL_LET_ELSE, UNCHECKED_DURATION_SUBTRACTION, COLLAPSIBLE_STR_REPLACE, SEEK_FROM_CURRENT, SEEK_REWIND, UNNECESSARY_LAZY_EVALUATIONS, TRANSMUTE_PTR_TO_REF, ALMOST_COMPLETE_RANGE, NEEDLESS_BORROW.
     ///
     /// The minimum rust version that the project supports
     (msrv: Option<String> = None),
-- 
cgit 1.4.1-3-g733a5


From e791522d35bf33a9008c367902ccaf3387325968 Mon Sep 17 00:00:00 2001
From: koka <koka.code@gmail.com>
Date: Sun, 29 Jan 2023 02:39:37 +0900
Subject: add DERIVABLE_IMPLS to msrv

DERIVABLE_IMPLS uses msrvs::DEFAULT_ENUM_ATTRIBUTE
---
 book/src/lint_configuration.md | 1 +
 clippy_lints/src/utils/conf.rs | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/book/src/lint_configuration.md b/book/src/lint_configuration.md
index 9bd4e72fe8f..9f7cf9a6163 100644
--- a/book/src/lint_configuration.md
+++ b/book/src/lint_configuration.md
@@ -175,6 +175,7 @@ The minimum rust version that the project supports
 * [transmute_ptr_to_ref](https://rust-lang.github.io/rust-clippy/master/index.html#transmute_ptr_to_ref)
 * [almost_complete_range](https://rust-lang.github.io/rust-clippy/master/index.html#almost_complete_range)
 * [needless_borrow](https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow)
+* [derivable_impls](https://rust-lang.github.io/rust-clippy/master/index.html#derivable_impls)
 
 
 ### cognitive-complexity-threshold
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 7364729606b..f7a35dc798e 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -253,7 +253,7 @@ define_Conf! {
     ///
     /// Suppress lints whenever the suggested change would cause breakage for other crates.
     (avoid_breaking_exported_api: bool = true),
-    /// Lint: MANUAL_SPLIT_ONCE, MANUAL_STR_REPEAT, CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR, IF_THEN_SOME_ELSE_NONE, APPROX_CONSTANT, DEPRECATED_CFG_ATTR, INDEX_REFUTABLE_SLICE, MAP_CLONE, BORROW_AS_PTR, MANUAL_BITS, ERR_EXPECT, CAST_ABS_TO_UNSIGNED, UNINLINED_FORMAT_ARGS, MANUAL_CLAMP, MANUAL_LET_ELSE, UNCHECKED_DURATION_SUBTRACTION, COLLAPSIBLE_STR_REPLACE, SEEK_FROM_CURRENT, SEEK_REWIND, UNNECESSARY_LAZY_EVALUATIONS, TRANSMUTE_PTR_TO_REF, ALMOST_COMPLETE_RANGE, NEEDLESS_BORROW.
+    /// Lint: MANUAL_SPLIT_ONCE, MANUAL_STR_REPEAT, CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR, IF_THEN_SOME_ELSE_NONE, APPROX_CONSTANT, DEPRECATED_CFG_ATTR, INDEX_REFUTABLE_SLICE, MAP_CLONE, BORROW_AS_PTR, MANUAL_BITS, ERR_EXPECT, CAST_ABS_TO_UNSIGNED, UNINLINED_FORMAT_ARGS, MANUAL_CLAMP, MANUAL_LET_ELSE, UNCHECKED_DURATION_SUBTRACTION, COLLAPSIBLE_STR_REPLACE, SEEK_FROM_CURRENT, SEEK_REWIND, UNNECESSARY_LAZY_EVALUATIONS, TRANSMUTE_PTR_TO_REF, ALMOST_COMPLETE_RANGE, NEEDLESS_BORROW, DERIVABLE_IMPLS.
     ///
     /// The minimum rust version that the project supports
     (msrv: Option<String> = None),
-- 
cgit 1.4.1-3-g733a5


From 25d455bd1728ba28c5cf6a0e044f2194a7d4d2ca Mon Sep 17 00:00:00 2001
From: koka <koka.code@gmail.com>
Date: Sun, 29 Jan 2023 02:54:26 +0900
Subject: fix: add missing dot to suppress_restriction_lint_in_const

---
 book/src/lint_configuration.md | 2 +-
 clippy_lints/src/utils/conf.rs | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/book/src/lint_configuration.md b/book/src/lint_configuration.md
index 9f7cf9a6163..32a2b44392d 100644
--- a/book/src/lint_configuration.md
+++ b/book/src/lint_configuration.md
@@ -526,7 +526,7 @@ Whether to allow mixed uninlined format args, e.g. `format!("{} {}", a, foo.bar)
 
 
 ### suppress-restriction-lint-in-const
-In same
+Whether to suppress a restriction lint in constant code. In same
 cases the restructured operation might not be unavoidable, as the
 suggested counterparts are unavailable in constant code. This
 configuration will cause restriction lints to trigger even
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index f7a35dc798e..f8a5b5547de 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -446,7 +446,7 @@ define_Conf! {
     ///
     /// Whether to allow mixed uninlined format args, e.g. `format!("{} {}", a, foo.bar)`
     (allow_mixed_uninlined_format_args: bool = true),
-    /// Lint: INDEXING_SLICING
+    /// Lint: INDEXING_SLICING.
     ///
     /// Whether to suppress a restriction lint in constant code. In same
     /// cases the restructured operation might not be unavoidable, as the
-- 
cgit 1.4.1-3-g733a5


From 1766532b20a7af11cd4cd52545a643b50a117040 Mon Sep 17 00:00:00 2001
From: koka <koka.code@gmail.com>
Date: Sun, 29 Jan 2023 03:02:23 +0900
Subject: add MANUAL_IS_ASCII_CHECK to msrv

MANUAL_IS_ASCII_CHECK uses msrvs::IS_ASCII_DIGIT and msrvs::IS_ASCII_DIGIT_CONST
---
 book/src/lint_configuration.md | 1 +
 clippy_lints/src/utils/conf.rs | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/book/src/lint_configuration.md b/book/src/lint_configuration.md
index 32a2b44392d..07414f5408b 100644
--- a/book/src/lint_configuration.md
+++ b/book/src/lint_configuration.md
@@ -176,6 +176,7 @@ The minimum rust version that the project supports
 * [almost_complete_range](https://rust-lang.github.io/rust-clippy/master/index.html#almost_complete_range)
 * [needless_borrow](https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow)
 * [derivable_impls](https://rust-lang.github.io/rust-clippy/master/index.html#derivable_impls)
+* [manual_is_ascii_check](https://rust-lang.github.io/rust-clippy/master/index.html#manual_is_ascii_check)
 
 
 ### cognitive-complexity-threshold
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index f8a5b5547de..380884cc21e 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -253,7 +253,7 @@ define_Conf! {
     ///
     /// Suppress lints whenever the suggested change would cause breakage for other crates.
     (avoid_breaking_exported_api: bool = true),
-    /// Lint: MANUAL_SPLIT_ONCE, MANUAL_STR_REPEAT, CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR, IF_THEN_SOME_ELSE_NONE, APPROX_CONSTANT, DEPRECATED_CFG_ATTR, INDEX_REFUTABLE_SLICE, MAP_CLONE, BORROW_AS_PTR, MANUAL_BITS, ERR_EXPECT, CAST_ABS_TO_UNSIGNED, UNINLINED_FORMAT_ARGS, MANUAL_CLAMP, MANUAL_LET_ELSE, UNCHECKED_DURATION_SUBTRACTION, COLLAPSIBLE_STR_REPLACE, SEEK_FROM_CURRENT, SEEK_REWIND, UNNECESSARY_LAZY_EVALUATIONS, TRANSMUTE_PTR_TO_REF, ALMOST_COMPLETE_RANGE, NEEDLESS_BORROW, DERIVABLE_IMPLS.
+    /// Lint: MANUAL_SPLIT_ONCE, MANUAL_STR_REPEAT, CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR, IF_THEN_SOME_ELSE_NONE, APPROX_CONSTANT, DEPRECATED_CFG_ATTR, INDEX_REFUTABLE_SLICE, MAP_CLONE, BORROW_AS_PTR, MANUAL_BITS, ERR_EXPECT, CAST_ABS_TO_UNSIGNED, UNINLINED_FORMAT_ARGS, MANUAL_CLAMP, MANUAL_LET_ELSE, UNCHECKED_DURATION_SUBTRACTION, COLLAPSIBLE_STR_REPLACE, SEEK_FROM_CURRENT, SEEK_REWIND, UNNECESSARY_LAZY_EVALUATIONS, TRANSMUTE_PTR_TO_REF, ALMOST_COMPLETE_RANGE, NEEDLESS_BORROW, DERIVABLE_IMPLS, MANUAL_IS_ASCII_CHECK.
     ///
     /// The minimum rust version that the project supports
     (msrv: Option<String> = None),
-- 
cgit 1.4.1-3-g733a5


From 2f4b047b277b70ff0b43e07e00e58d54d92fda3c Mon Sep 17 00:00:00 2001
From: koka <koka.code@gmail.com>
Date: Sun, 29 Jan 2023 03:04:56 +0900
Subject: add MANUAL_REM_EUCLID to msrv

MANUAL_REM_EUCLID uses msrvs::REM_EUCLID
---
 book/src/lint_configuration.md | 1 +
 clippy_lints/src/utils/conf.rs | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/book/src/lint_configuration.md b/book/src/lint_configuration.md
index 07414f5408b..78304ca48fe 100644
--- a/book/src/lint_configuration.md
+++ b/book/src/lint_configuration.md
@@ -177,6 +177,7 @@ The minimum rust version that the project supports
 * [needless_borrow](https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow)
 * [derivable_impls](https://rust-lang.github.io/rust-clippy/master/index.html#derivable_impls)
 * [manual_is_ascii_check](https://rust-lang.github.io/rust-clippy/master/index.html#manual_is_ascii_check)
+* [manual_rem_euclid](https://rust-lang.github.io/rust-clippy/master/index.html#manual_rem_euclid)
 
 
 ### cognitive-complexity-threshold
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 380884cc21e..e47546e3e42 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -253,7 +253,7 @@ define_Conf! {
     ///
     /// Suppress lints whenever the suggested change would cause breakage for other crates.
     (avoid_breaking_exported_api: bool = true),
-    /// Lint: MANUAL_SPLIT_ONCE, MANUAL_STR_REPEAT, CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR, IF_THEN_SOME_ELSE_NONE, APPROX_CONSTANT, DEPRECATED_CFG_ATTR, INDEX_REFUTABLE_SLICE, MAP_CLONE, BORROW_AS_PTR, MANUAL_BITS, ERR_EXPECT, CAST_ABS_TO_UNSIGNED, UNINLINED_FORMAT_ARGS, MANUAL_CLAMP, MANUAL_LET_ELSE, UNCHECKED_DURATION_SUBTRACTION, COLLAPSIBLE_STR_REPLACE, SEEK_FROM_CURRENT, SEEK_REWIND, UNNECESSARY_LAZY_EVALUATIONS, TRANSMUTE_PTR_TO_REF, ALMOST_COMPLETE_RANGE, NEEDLESS_BORROW, DERIVABLE_IMPLS, MANUAL_IS_ASCII_CHECK.
+    /// Lint: MANUAL_SPLIT_ONCE, MANUAL_STR_REPEAT, CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR, IF_THEN_SOME_ELSE_NONE, APPROX_CONSTANT, DEPRECATED_CFG_ATTR, INDEX_REFUTABLE_SLICE, MAP_CLONE, BORROW_AS_PTR, MANUAL_BITS, ERR_EXPECT, CAST_ABS_TO_UNSIGNED, UNINLINED_FORMAT_ARGS, MANUAL_CLAMP, MANUAL_LET_ELSE, UNCHECKED_DURATION_SUBTRACTION, COLLAPSIBLE_STR_REPLACE, SEEK_FROM_CURRENT, SEEK_REWIND, UNNECESSARY_LAZY_EVALUATIONS, TRANSMUTE_PTR_TO_REF, ALMOST_COMPLETE_RANGE, NEEDLESS_BORROW, DERIVABLE_IMPLS, MANUAL_IS_ASCII_CHECK, MANUAL_REM_EUCLID.
     ///
     /// The minimum rust version that the project supports
     (msrv: Option<String> = None),
-- 
cgit 1.4.1-3-g733a5


From d87a6bc9b18594bdadb479f7ade1361527d3f46b Mon Sep 17 00:00:00 2001
From: koka <koka.code@gmail.com>
Date: Sun, 29 Jan 2023 03:07:09 +0900
Subject: add MANUAL_RETAIN to msrv

MANUAL_RETAIN uses
- msrvs::STRING_RETAIN
- msrvs::BTREE_SET_RETAIN
- msrvs::BTREE_MAP_RETAIN
- msrvs::HASH_SET_RETAIN
- msrvs::HASH_MAP_RETAIN
---
 book/src/lint_configuration.md | 1 +
 clippy_lints/src/utils/conf.rs | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/book/src/lint_configuration.md b/book/src/lint_configuration.md
index 78304ca48fe..1db2ad5859c 100644
--- a/book/src/lint_configuration.md
+++ b/book/src/lint_configuration.md
@@ -178,6 +178,7 @@ The minimum rust version that the project supports
 * [derivable_impls](https://rust-lang.github.io/rust-clippy/master/index.html#derivable_impls)
 * [manual_is_ascii_check](https://rust-lang.github.io/rust-clippy/master/index.html#manual_is_ascii_check)
 * [manual_rem_euclid](https://rust-lang.github.io/rust-clippy/master/index.html#manual_rem_euclid)
+* [manual_retain](https://rust-lang.github.io/rust-clippy/master/index.html#manual_retain)
 
 
 ### cognitive-complexity-threshold
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index e47546e3e42..5bdffab26b2 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -253,7 +253,7 @@ define_Conf! {
     ///
     /// Suppress lints whenever the suggested change would cause breakage for other crates.
     (avoid_breaking_exported_api: bool = true),
-    /// Lint: MANUAL_SPLIT_ONCE, MANUAL_STR_REPEAT, CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR, IF_THEN_SOME_ELSE_NONE, APPROX_CONSTANT, DEPRECATED_CFG_ATTR, INDEX_REFUTABLE_SLICE, MAP_CLONE, BORROW_AS_PTR, MANUAL_BITS, ERR_EXPECT, CAST_ABS_TO_UNSIGNED, UNINLINED_FORMAT_ARGS, MANUAL_CLAMP, MANUAL_LET_ELSE, UNCHECKED_DURATION_SUBTRACTION, COLLAPSIBLE_STR_REPLACE, SEEK_FROM_CURRENT, SEEK_REWIND, UNNECESSARY_LAZY_EVALUATIONS, TRANSMUTE_PTR_TO_REF, ALMOST_COMPLETE_RANGE, NEEDLESS_BORROW, DERIVABLE_IMPLS, MANUAL_IS_ASCII_CHECK, MANUAL_REM_EUCLID.
+    /// Lint: MANUAL_SPLIT_ONCE, MANUAL_STR_REPEAT, CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR, IF_THEN_SOME_ELSE_NONE, APPROX_CONSTANT, DEPRECATED_CFG_ATTR, INDEX_REFUTABLE_SLICE, MAP_CLONE, BORROW_AS_PTR, MANUAL_BITS, ERR_EXPECT, CAST_ABS_TO_UNSIGNED, UNINLINED_FORMAT_ARGS, MANUAL_CLAMP, MANUAL_LET_ELSE, UNCHECKED_DURATION_SUBTRACTION, COLLAPSIBLE_STR_REPLACE, SEEK_FROM_CURRENT, SEEK_REWIND, UNNECESSARY_LAZY_EVALUATIONS, TRANSMUTE_PTR_TO_REF, ALMOST_COMPLETE_RANGE, NEEDLESS_BORROW, DERIVABLE_IMPLS, MANUAL_IS_ASCII_CHECK, MANUAL_REM_EUCLID, MANUAL_RETAIN.
     ///
     /// The minimum rust version that the project supports
     (msrv: Option<String> = None),
-- 
cgit 1.4.1-3-g733a5


From af62bf95a3fc2d8d1164698160507fa7d7035284 Mon Sep 17 00:00:00 2001
From: koka <koka.code@gmail.com>
Date: Sun, 29 Jan 2023 03:13:30 +0900
Subject: fix key name of MUTABLE_KEY_TYPE

---
 book/src/lint_configuration.md | 2 +-
 clippy_lints/src/utils/conf.rs | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/book/src/lint_configuration.md b/book/src/lint_configuration.md
index 1db2ad5859c..9acacede5a8 100644
--- a/book/src/lint_configuration.md
+++ b/book/src/lint_configuration.md
@@ -517,7 +517,7 @@ for the generic parameters for determining interior mutability
 
 **Default Value:** `["bytes::Bytes"]` (`Vec<String>`)
 
-* [mutable_key](https://rust-lang.github.io/rust-clippy/master/index.html#mutable_key)
+* [mutable_key_type](https://rust-lang.github.io/rust-clippy/master/index.html#mutable_key_type)
 
 
 ### allow-mixed-uninlined-format-args
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 5bdffab26b2..4dfe23f474f 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -437,7 +437,7 @@ define_Conf! {
     ///
     /// The maximum size of the `Err`-variant in a `Result` returned from a function
     (large_error_threshold: u64 = 128),
-    /// Lint: MUTABLE_KEY.
+    /// Lint: MUTABLE_KEY_TYPE.
     ///
     /// A list of paths to types that should be treated like `Arc`, i.e. ignored but
     /// for the generic parameters for determining interior mutability
-- 
cgit 1.4.1-3-g733a5


From 4d266d31ded825d43df64e496cea54bdcf2f65e4 Mon Sep 17 00:00:00 2001
From: Tyler Weaver <maybe@tylerjw.dev>
Date: Sun, 29 Jan 2023 11:41:53 -0700
Subject: needless_range_loop: improve documentation

---
 clippy_lints/src/loops/mod.rs                 | 3 ++-
 clippy_lints/src/loops/needless_range_loop.rs | 2 +-
 tests/ui/needless_range_loop.stderr           | 8 ++++----
 3 files changed, 7 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/mod.rs b/clippy_lints/src/loops/mod.rs
index 8e52cac4323..610a0233eee 100644
--- a/clippy_lints/src/loops/mod.rs
+++ b/clippy_lints/src/loops/mod.rs
@@ -61,7 +61,8 @@ declare_clippy_lint! {
     ///
     /// ### Why is this bad?
     /// Just iterating the collection itself makes the intent
-    /// more clear and is probably faster.
+    /// more clear and is probably faster because it eliminates
+    /// the bounds check that is done when indexing.
     ///
     /// ### Example
     /// ```rust
diff --git a/clippy_lints/src/loops/needless_range_loop.rs b/clippy_lints/src/loops/needless_range_loop.rs
index 3bca93d80aa..1336b80d88d 100644
--- a/clippy_lints/src/loops/needless_range_loop.rs
+++ b/clippy_lints/src/loops/needless_range_loop.rs
@@ -149,7 +149,7 @@ pub(super) fn check<'tcx>(
                         |diag| {
                             multispan_sugg(
                                 diag,
-                                "consider using an iterator",
+                                "consider using an iterator and enumerate",
                                 vec![
                                     (pat.span, format!("({}, <item>)", ident.name)),
                                     (
diff --git a/tests/ui/needless_range_loop.stderr b/tests/ui/needless_range_loop.stderr
index b31544ec334..81b6f214bd1 100644
--- a/tests/ui/needless_range_loop.stderr
+++ b/tests/ui/needless_range_loop.stderr
@@ -49,7 +49,7 @@ error: the loop variable `i` is used to index `vec`
 LL |     for i in 0..vec.len() {
    |              ^^^^^^^^^^^^
    |
-help: consider using an iterator
+help: consider using an iterator and enumerate
    |
 LL |     for (i, <item>) in vec.iter().enumerate() {
    |         ~~~~~~~~~~~    ~~~~~~~~~~~~~~~~~~~~~~
@@ -126,7 +126,7 @@ error: the loop variable `i` is used to index `vec`
 LL |     for i in 5..vec.len() {
    |              ^^^^^^^^^^^^
    |
-help: consider using an iterator
+help: consider using an iterator and enumerate
    |
 LL |     for (i, <item>) in vec.iter().enumerate().skip(5) {
    |         ~~~~~~~~~~~    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -137,7 +137,7 @@ error: the loop variable `i` is used to index `vec`
 LL |     for i in 5..10 {
    |              ^^^^^
    |
-help: consider using an iterator
+help: consider using an iterator and enumerate
    |
 LL |     for (i, <item>) in vec.iter().enumerate().take(10).skip(5) {
    |         ~~~~~~~~~~~    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -148,7 +148,7 @@ error: the loop variable `i` is used to index `vec`
 LL |     for i in 0..vec.len() {
    |              ^^^^^^^^^^^^
    |
-help: consider using an iterator
+help: consider using an iterator and enumerate
    |
 LL |     for (i, <item>) in vec.iter_mut().enumerate() {
    |         ~~~~~~~~~~~    ~~~~~~~~~~~~~~~~~~~~~~~~~~
-- 
cgit 1.4.1-3-g733a5


From 2fd94a4e01d9e8049df3651d0b29b3964cf235d8 Mon Sep 17 00:00:00 2001
From: ksaleem <ksaleem@digitalocean.com>
Date: Sun, 29 Jan 2023 13:48:06 -0500
Subject: prevents `len_without_is_empty` from yielding positive when `len`
 takes more than just `&self` in non-standard implementations.

changelog: Fix [`len_without_is_empty`] false positive when len has a
non-standard method signature

Fixes #9520
---
 clippy_lints/src/len_zero.rs     |  1 +
 tests/ui/len_without_is_empty.rs | 46 ++++++++++++++++++++++++++++++++++++++++
 2 files changed, 47 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/len_zero.rs b/clippy_lints/src/len_zero.rs
index 3c70c9cf19a..920ab7f0633 100644
--- a/clippy_lints/src/len_zero.rs
+++ b/clippy_lints/src/len_zero.rs
@@ -135,6 +135,7 @@ impl<'tcx> LateLintPass<'tcx> for LenZero {
             if item.ident.name == sym::len;
             if let ImplItemKind::Fn(sig, _) = &item.kind;
             if sig.decl.implicit_self.has_implicit_self();
+            if sig.decl.inputs.len() == 1;
             if cx.effective_visibilities.is_exported(item.owner_id.def_id);
             if matches!(sig.decl.output, FnRetTy::Return(_));
             if let Some(imp) = get_parent_as_impl(cx.tcx, item.hir_id());
diff --git a/tests/ui/len_without_is_empty.rs b/tests/ui/len_without_is_empty.rs
index 78397c2af34..b5dec6c46bd 100644
--- a/tests/ui/len_without_is_empty.rs
+++ b/tests/ui/len_without_is_empty.rs
@@ -282,4 +282,50 @@ impl AsyncLen {
     }
 }
 
+// issue #9520
+pub struct NonStandardLenAndIsEmptySignature;
+impl NonStandardLenAndIsEmptySignature {
+    // don't lint
+    pub fn len(&self, something: usize) -> usize {
+        something
+    }
+
+    pub fn is_empty(&self, something: usize) -> bool {
+        something == 0
+    }
+}
+
+// test case for #9520 with generics in the function signature
+pub trait TestResource {
+    type NonStandardSignatureWithGenerics: Copy;
+    fn lookup_content(&self, item: Self::NonStandardSignatureWithGenerics) -> Result<Option<&[u8]>, String>;
+}
+pub struct NonStandardSignatureWithGenerics(u32);
+impl NonStandardSignatureWithGenerics {
+    pub fn is_empty<T, U>(self, resource: &T) -> bool
+    where
+        T: TestResource<NonStandardSignatureWithGenerics = U>,
+        U: Copy + From<NonStandardSignatureWithGenerics>,
+    {
+        if let Ok(Some(content)) = resource.lookup_content(self.into()) {
+            content.is_empty()
+        } else {
+            true
+        }
+    }
+
+    // test case for #9520 with generics in the function signature
+    pub fn len<T, U>(self, resource: &T) -> usize
+    where
+        T: TestResource<NonStandardSignatureWithGenerics = U>,
+        U: Copy + From<NonStandardSignatureWithGenerics>,
+    {
+        if let Ok(Some(content)) = resource.lookup_content(self.into()) {
+            content.len()
+        } else {
+            0_usize
+        }
+    }
+}
+
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From ecde2019e9ad63282b647fbce33cbbc3d394fd84 Mon Sep 17 00:00:00 2001
From: Sylvain Desodt <sylvain.desodt@forvia.com>
Date: Mon, 30 Jan 2023 10:01:29 +0100
Subject: Fix version declared for semicolon_inside_block and
 semicolon_outside_block

As per Issue #10244, the lint were documentated
as being part of 1.66.0 but will actually be
released 1.68.0 .
---
 clippy_lints/src/semicolon_block.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/semicolon_block.rs b/clippy_lints/src/semicolon_block.rs
index 8f1d1490e1f..34a3e5ddf4f 100644
--- a/clippy_lints/src/semicolon_block.rs
+++ b/clippy_lints/src/semicolon_block.rs
@@ -30,7 +30,7 @@ declare_clippy_lint! {
     /// # let x = 0;
     /// unsafe { f(x); }
     /// ```
-    #[clippy::version = "1.66.0"]
+    #[clippy::version = "1.68.0"]
     pub SEMICOLON_INSIDE_BLOCK,
     restriction,
     "add a semicolon inside the block"
@@ -59,7 +59,7 @@ declare_clippy_lint! {
     /// # let x = 0;
     /// unsafe { f(x) };
     /// ```
-    #[clippy::version = "1.66.0"]
+    #[clippy::version = "1.68.0"]
     pub SEMICOLON_OUTSIDE_BLOCK,
     restriction,
     "add a semicolon outside the block"
-- 
cgit 1.4.1-3-g733a5


From a9e6b128542134c340bb25e13144eafbd176f51b Mon Sep 17 00:00:00 2001
From: koka <koka.code@gmail.com>
Date: Sun, 29 Jan 2023 03:22:17 +0900
Subject: fix: use correct lint name

fix
---
 book/src/lint_configuration.md | 2 +-
 clippy_lints/src/utils/conf.rs | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/book/src/lint_configuration.md b/book/src/lint_configuration.md
index 9acacede5a8..32e8e218c40 100644
--- a/book/src/lint_configuration.md
+++ b/book/src/lint_configuration.md
@@ -291,7 +291,7 @@ The minimum size (in bytes) to consider a type for passing by reference instead
 
 **Default Value:** `256` (`u64`)
 
-* [large_type_pass_by_move](https://rust-lang.github.io/rust-clippy/master/index.html#large_type_pass_by_move)
+* [large_types_passed_by_value](https://rust-lang.github.io/rust-clippy/master/index.html#large_types_passed_by_value)
 
 
 ### too-many-lines-threshold
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 4dfe23f474f..1d78c7cfae0 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -323,7 +323,7 @@ define_Conf! {
     ///
     /// The maximum size (in bytes) to consider a `Copy` type for passing by value instead of by reference.
     (trivial_copy_size_limit: Option<u64> = None),
-    /// Lint: LARGE_TYPE_PASS_BY_MOVE.
+    /// Lint: LARGE_TYPES_PASSED_BY_VALUE.
     ///
     /// The minimum size (in bytes) to consider a type for passing by reference instead of by value.
     (pass_by_value_size_limit: u64 = 256),
-- 
cgit 1.4.1-3-g733a5


From 3b225e3a96abcf8eab678691b244e5cdda4c6ea5 Mon Sep 17 00:00:00 2001
From: Tyler Weaver <maybe@tylerjw.dev>
Date: Mon, 30 Jan 2023 09:59:26 -0700
Subject: Update clippy_lints/src/loops/needless_range_loop.rs

Co-authored-by: Manish Goregaokar <manishsmail@gmail.com>
---
 clippy_lints/src/loops/needless_range_loop.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/needless_range_loop.rs b/clippy_lints/src/loops/needless_range_loop.rs
index 1336b80d88d..d060b6ade24 100644
--- a/clippy_lints/src/loops/needless_range_loop.rs
+++ b/clippy_lints/src/loops/needless_range_loop.rs
@@ -149,7 +149,7 @@ pub(super) fn check<'tcx>(
                         |diag| {
                             multispan_sugg(
                                 diag,
-                                "consider using an iterator and enumerate",
+                                "consider using an iterator and enumerate()",
                                 vec![
                                     (pat.span, format!("({}, <item>)", ident.name)),
                                     (
-- 
cgit 1.4.1-3-g733a5


From 926c5e4cde09470ecfcdae562e802e5abbddb17c Mon Sep 17 00:00:00 2001
From: Niki4tap <rombiklol2@gmail.com>
Date: Mon, 30 Jan 2023 20:42:40 +0300
Subject: multiple_unsafe_ops_per_block: don't lint in external macros

---
 clippy_lints/src/multiple_unsafe_ops_per_block.rs |  3 +-
 tests/ui/auxiliary/macro_rules.rs                 | 10 ++++++
 tests/ui/multiple_unsafe_ops_per_block.rs         |  9 +++++
 tests/ui/multiple_unsafe_ops_per_block.stderr     | 40 +++++++++++------------
 4 files changed, 41 insertions(+), 21 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/multiple_unsafe_ops_per_block.rs b/clippy_lints/src/multiple_unsafe_ops_per_block.rs
index 18e61c75eec..191da3085be 100644
--- a/clippy_lints/src/multiple_unsafe_ops_per_block.rs
+++ b/clippy_lints/src/multiple_unsafe_ops_per_block.rs
@@ -10,6 +10,7 @@ use hir::{
 use rustc_ast::Mutability;
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::Span;
 
@@ -66,7 +67,7 @@ declare_lint_pass!(MultipleUnsafeOpsPerBlock => [MULTIPLE_UNSAFE_OPS_PER_BLOCK])
 
 impl<'tcx> LateLintPass<'tcx> for MultipleUnsafeOpsPerBlock {
     fn check_block(&mut self, cx: &LateContext<'tcx>, block: &'tcx hir::Block<'_>) {
-        if !matches!(block.rules, BlockCheckMode::UnsafeBlock(_)) {
+        if !matches!(block.rules, BlockCheckMode::UnsafeBlock(_)) || in_external_macro(cx.tcx.sess, block.span) {
             return;
         }
         let mut unsafe_ops = vec![];
diff --git a/tests/ui/auxiliary/macro_rules.rs b/tests/ui/auxiliary/macro_rules.rs
index 1e5f20e8c39..f74a614eefe 100644
--- a/tests/ui/auxiliary/macro_rules.rs
+++ b/tests/ui/auxiliary/macro_rules.rs
@@ -149,3 +149,13 @@ macro_rules! almost_complete_range {
         let _ = '0'..'9';
     };
 }
+
+#[macro_export]
+macro_rules! unsafe_macro {
+    () => {
+        unsafe {
+            *core::ptr::null::<()>();
+            *core::ptr::null::<()>();
+        }
+    };
+}
diff --git a/tests/ui/multiple_unsafe_ops_per_block.rs b/tests/ui/multiple_unsafe_ops_per_block.rs
index 41263535df6..4511bc99c3c 100644
--- a/tests/ui/multiple_unsafe_ops_per_block.rs
+++ b/tests/ui/multiple_unsafe_ops_per_block.rs
@@ -1,9 +1,13 @@
+// aux-build:macro_rules.rs
 #![allow(unused)]
 #![allow(deref_nullptr)]
 #![allow(clippy::unnecessary_operation)]
 #![allow(clippy::drop_copy)]
 #![warn(clippy::multiple_unsafe_ops_per_block)]
 
+#[macro_use]
+extern crate macro_rules;
+
 use core::arch::asm;
 
 fn raw_ptr() -> *const () {
@@ -107,4 +111,9 @@ unsafe fn read_char_good(ptr: *const u8) -> char {
     unsafe { core::char::from_u32_unchecked(int_value) }
 }
 
+// no lint
+fn issue10259() {
+    unsafe_macro!();
+}
+
 fn main() {}
diff --git a/tests/ui/multiple_unsafe_ops_per_block.stderr b/tests/ui/multiple_unsafe_ops_per_block.stderr
index f6b8341795d..303aeb7aee0 100644
--- a/tests/ui/multiple_unsafe_ops_per_block.stderr
+++ b/tests/ui/multiple_unsafe_ops_per_block.stderr
@@ -1,5 +1,5 @@
 error: this `unsafe` block contains 2 unsafe operations, expected only one
-  --> $DIR/multiple_unsafe_ops_per_block.rs:32:5
+  --> $DIR/multiple_unsafe_ops_per_block.rs:36:5
    |
 LL | /     unsafe {
 LL | |         STATIC += 1;
@@ -8,19 +8,19 @@ LL | |     }
    | |_____^
    |
 note: modification of a mutable static occurs here
-  --> $DIR/multiple_unsafe_ops_per_block.rs:33:9
+  --> $DIR/multiple_unsafe_ops_per_block.rs:37:9
    |
 LL |         STATIC += 1;
    |         ^^^^^^^^^^^
 note: unsafe function call occurs here
-  --> $DIR/multiple_unsafe_ops_per_block.rs:34:9
+  --> $DIR/multiple_unsafe_ops_per_block.rs:38:9
    |
 LL |         not_very_safe();
    |         ^^^^^^^^^^^^^^^
    = note: `-D clippy::multiple-unsafe-ops-per-block` implied by `-D warnings`
 
 error: this `unsafe` block contains 2 unsafe operations, expected only one
-  --> $DIR/multiple_unsafe_ops_per_block.rs:41:5
+  --> $DIR/multiple_unsafe_ops_per_block.rs:45:5
    |
 LL | /     unsafe {
 LL | |         drop(u.u);
@@ -29,18 +29,18 @@ LL | |     }
    | |_____^
    |
 note: union field access occurs here
-  --> $DIR/multiple_unsafe_ops_per_block.rs:42:14
+  --> $DIR/multiple_unsafe_ops_per_block.rs:46:14
    |
 LL |         drop(u.u);
    |              ^^^
 note: raw pointer dereference occurs here
-  --> $DIR/multiple_unsafe_ops_per_block.rs:43:9
+  --> $DIR/multiple_unsafe_ops_per_block.rs:47:9
    |
 LL |         *raw_ptr();
    |         ^^^^^^^^^^
 
 error: this `unsafe` block contains 3 unsafe operations, expected only one
-  --> $DIR/multiple_unsafe_ops_per_block.rs:48:5
+  --> $DIR/multiple_unsafe_ops_per_block.rs:52:5
    |
 LL | /     unsafe {
 LL | |         asm!("nop");
@@ -50,23 +50,23 @@ LL | |     }
    | |_____^
    |
 note: inline assembly used here
-  --> $DIR/multiple_unsafe_ops_per_block.rs:49:9
+  --> $DIR/multiple_unsafe_ops_per_block.rs:53:9
    |
 LL |         asm!("nop");
    |         ^^^^^^^^^^^
 note: unsafe method call occurs here
-  --> $DIR/multiple_unsafe_ops_per_block.rs:50:9
+  --> $DIR/multiple_unsafe_ops_per_block.rs:54:9
    |
 LL |         sample.not_very_safe();
    |         ^^^^^^^^^^^^^^^^^^^^^^
 note: modification of a mutable static occurs here
-  --> $DIR/multiple_unsafe_ops_per_block.rs:51:9
+  --> $DIR/multiple_unsafe_ops_per_block.rs:55:9
    |
 LL |         STATIC = 0;
    |         ^^^^^^^^^^
 
 error: this `unsafe` block contains 6 unsafe operations, expected only one
-  --> $DIR/multiple_unsafe_ops_per_block.rs:57:5
+  --> $DIR/multiple_unsafe_ops_per_block.rs:61:5
    |
 LL | /     unsafe {
 LL | |         drop(u.u);
@@ -78,49 +78,49 @@ LL | |     }
    | |_____^
    |
 note: union field access occurs here
-  --> $DIR/multiple_unsafe_ops_per_block.rs:58:14
+  --> $DIR/multiple_unsafe_ops_per_block.rs:62:14
    |
 LL |         drop(u.u);
    |              ^^^
 note: access of a mutable static occurs here
-  --> $DIR/multiple_unsafe_ops_per_block.rs:59:14
+  --> $DIR/multiple_unsafe_ops_per_block.rs:63:14
    |
 LL |         drop(STATIC);
    |              ^^^^^^
 note: unsafe method call occurs here
-  --> $DIR/multiple_unsafe_ops_per_block.rs:60:9
+  --> $DIR/multiple_unsafe_ops_per_block.rs:64:9
    |
 LL |         sample.not_very_safe();
    |         ^^^^^^^^^^^^^^^^^^^^^^
 note: unsafe function call occurs here
-  --> $DIR/multiple_unsafe_ops_per_block.rs:61:9
+  --> $DIR/multiple_unsafe_ops_per_block.rs:65:9
    |
 LL |         not_very_safe();
    |         ^^^^^^^^^^^^^^^
 note: raw pointer dereference occurs here
-  --> $DIR/multiple_unsafe_ops_per_block.rs:62:9
+  --> $DIR/multiple_unsafe_ops_per_block.rs:66:9
    |
 LL |         *raw_ptr();
    |         ^^^^^^^^^^
 note: inline assembly used here
-  --> $DIR/multiple_unsafe_ops_per_block.rs:63:9
+  --> $DIR/multiple_unsafe_ops_per_block.rs:67:9
    |
 LL |         asm!("nop");
    |         ^^^^^^^^^^^
 
 error: this `unsafe` block contains 2 unsafe operations, expected only one
-  --> $DIR/multiple_unsafe_ops_per_block.rs:101:5
+  --> $DIR/multiple_unsafe_ops_per_block.rs:105:5
    |
 LL |     unsafe { char::from_u32_unchecked(*ptr.cast::<u32>()) }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: unsafe function call occurs here
-  --> $DIR/multiple_unsafe_ops_per_block.rs:101:14
+  --> $DIR/multiple_unsafe_ops_per_block.rs:105:14
    |
 LL |     unsafe { char::from_u32_unchecked(*ptr.cast::<u32>()) }
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 note: raw pointer dereference occurs here
-  --> $DIR/multiple_unsafe_ops_per_block.rs:101:39
+  --> $DIR/multiple_unsafe_ops_per_block.rs:105:39
    |
 LL |     unsafe { char::from_u32_unchecked(*ptr.cast::<u32>()) }
    |                                       ^^^^^^^^^^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From 4fde96c30eab3845905f8eb0b074c1168877dd95 Mon Sep 17 00:00:00 2001
From: Tyler Weaver <maybe@tylerjw.dev>
Date: Mon, 30 Jan 2023 16:04:19 -0700
Subject: Test needless_lifetimes within external macro

Signed-off-by: Tyler Weaver <maybe@tylerjw.dev>
---
 clippy_lints/src/lifetimes.rs      |   5 +-
 tests/ui/auxiliary/macro_rules.rs  |   9 +++
 tests/ui/needless_lifetimes.rs     |  19 ++++--
 tests/ui/needless_lifetimes.stderr | 117 ++++++++++++++++++++-----------------
 4 files changed, 89 insertions(+), 61 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lifetimes.rs b/clippy_lints/src/lifetimes.rs
index 7cf1a6b8084..ef9ac96ace5 100644
--- a/clippy_lints/src/lifetimes.rs
+++ b/clippy_lints/src/lifetimes.rs
@@ -13,8 +13,9 @@ use rustc_hir::{
     ImplItemKind, Item, ItemKind, Lifetime, LifetimeName, LifetimeParamKind, PolyTraitRef, PredicateOrigin, TraitFn,
     TraitItem, TraitItemKind, Ty, TyKind, WherePredicate,
 };
-use rustc_lint::{LateContext, LateLintPass};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::hir::nested_filter as middle_nested_filter;
+use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::TyCtxt;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::def_id::LocalDefId;
@@ -144,7 +145,7 @@ fn check_fn_inner<'tcx>(
     span: Span,
     report_extra_lifetimes: bool,
 ) {
-    if span.from_expansion() || has_where_lifetimes(cx, generics) {
+    if in_external_macro(cx.sess(), span) || has_where_lifetimes(cx, generics) {
         return;
     }
 
diff --git a/tests/ui/auxiliary/macro_rules.rs b/tests/ui/auxiliary/macro_rules.rs
index f74a614eefe..a13af565203 100644
--- a/tests/ui/auxiliary/macro_rules.rs
+++ b/tests/ui/auxiliary/macro_rules.rs
@@ -159,3 +159,12 @@ macro_rules! unsafe_macro {
         }
     };
 }
+
+#[macro_export]
+macro_rules! needless_lifetime {
+    () => {
+        fn needless_lifetime<'a>(x: &'a u8) -> &'a u8 {
+            unimplemented!()
+        }
+    };
+}
diff --git a/tests/ui/needless_lifetimes.rs b/tests/ui/needless_lifetimes.rs
index ac467cbbdf1..78493c6d067 100644
--- a/tests/ui/needless_lifetimes.rs
+++ b/tests/ui/needless_lifetimes.rs
@@ -1,3 +1,4 @@
+// aux-build:macro_rules.rs
 #![warn(clippy::needless_lifetimes)]
 #![allow(
     dead_code,
@@ -8,6 +9,9 @@
     clippy::get_first
 )]
 
+#[macro_use]
+extern crate macro_rules;
+
 fn distinct_lifetimes<'a, 'b>(_x: &'a u8, _y: &'b u8, _z: u8) {}
 
 fn distinct_and_static<'a, 'b>(_x: &'a u8, _y: &'b u8, _z: &'static u8) {}
@@ -495,17 +499,20 @@ mod pr_9743_output_lifetime_checks {
     }
 }
 
-mod skip_inside_macros {
-    macro_rules! print_with_one_input {
-        ($a:expr) => {
-            fn print_with_one_input<'a>(x: &'a u8) -> &'a u8 {
-                println!("{}", $a);
+mod in_macro {
+    macro_rules! local_one_input_macro {
+        () => {
+            fn one_input<'a>(x: &'a u8) -> &'a u8 {
                 unimplemented!()
             }
         };
     }
 
-    print_with_one_input!("this is a dandy little string literal");
+    // lint local macro expands to function with needless lifetimes
+    local_one_input_macro!();
+
+    // no lint on external macro
+    macro_rules::needless_lifetime!();
 }
 
 fn main() {}
diff --git a/tests/ui/needless_lifetimes.stderr b/tests/ui/needless_lifetimes.stderr
index 5a7cf13c86d..9d02626956e 100644
--- a/tests/ui/needless_lifetimes.stderr
+++ b/tests/ui/needless_lifetimes.stderr
@@ -1,5 +1,5 @@
 error: the following explicit lifetimes could be elided: 'a, 'b
-  --> $DIR/needless_lifetimes.rs:11:1
+  --> $DIR/needless_lifetimes.rs:15:1
    |
 LL | fn distinct_lifetimes<'a, 'b>(_x: &'a u8, _y: &'b u8, _z: u8) {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -7,310 +7,321 @@ LL | fn distinct_lifetimes<'a, 'b>(_x: &'a u8, _y: &'b u8, _z: u8) {}
    = note: `-D clippy::needless-lifetimes` implied by `-D warnings`
 
 error: the following explicit lifetimes could be elided: 'a, 'b
-  --> $DIR/needless_lifetimes.rs:13:1
+  --> $DIR/needless_lifetimes.rs:17:1
    |
 LL | fn distinct_and_static<'a, 'b>(_x: &'a u8, _y: &'b u8, _z: &'static u8) {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:23:1
+  --> $DIR/needless_lifetimes.rs:27:1
    |
 LL | fn in_and_out<'a>(x: &'a u8, _y: u8) -> &'a u8 {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: the following explicit lifetimes could be elided: 'b
-  --> $DIR/needless_lifetimes.rs:35:1
+  --> $DIR/needless_lifetimes.rs:39:1
    |
 LL | fn multiple_in_and_out_2a<'a, 'b>(x: &'a u8, _y: &'b u8) -> &'a u8 {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:42:1
+  --> $DIR/needless_lifetimes.rs:46:1
    |
 LL | fn multiple_in_and_out_2b<'a, 'b>(_x: &'a u8, y: &'b u8) -> &'b u8 {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: the following explicit lifetimes could be elided: 'b
-  --> $DIR/needless_lifetimes.rs:59:1
+  --> $DIR/needless_lifetimes.rs:63:1
    |
 LL | fn deep_reference_1a<'a, 'b>(x: &'a u8, _y: &'b u8) -> Result<&'a u8, ()> {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:66:1
+  --> $DIR/needless_lifetimes.rs:70:1
    |
 LL | fn deep_reference_1b<'a, 'b>(_x: &'a u8, y: &'b u8) -> Result<&'b u8, ()> {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:75:1
+  --> $DIR/needless_lifetimes.rs:79:1
    |
 LL | fn deep_reference_3<'a>(x: &'a u8, _y: u8) -> Result<&'a u8, ()> {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:80:1
+  --> $DIR/needless_lifetimes.rs:84:1
    |
 LL | fn where_clause_without_lt<'a, T>(x: &'a u8, _y: u8) -> Result<&'a u8, ()>
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: the following explicit lifetimes could be elided: 'a, 'b
-  --> $DIR/needless_lifetimes.rs:92:1
+  --> $DIR/needless_lifetimes.rs:96:1
    |
 LL | fn lifetime_param_2<'a, 'b>(_x: Ref<'a>, _y: &'b u8) {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: replace with `'_` in generic arguments such as here
-  --> $DIR/needless_lifetimes.rs:92:37
+  --> $DIR/needless_lifetimes.rs:96:37
    |
 LL | fn lifetime_param_2<'a, 'b>(_x: Ref<'a>, _y: &'b u8) {}
    |                                     ^^
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:116:1
+  --> $DIR/needless_lifetimes.rs:120:1
    |
 LL | fn fn_bound_2<'a, F, I>(_m: Lt<'a, I>, _f: F) -> Lt<'a, I>
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: replace with `'_` in generic arguments such as here
-  --> $DIR/needless_lifetimes.rs:116:32
+  --> $DIR/needless_lifetimes.rs:120:32
    |
 LL | fn fn_bound_2<'a, F, I>(_m: Lt<'a, I>, _f: F) -> Lt<'a, I>
    |                                ^^
 
 error: the following explicit lifetimes could be elided: 's
-  --> $DIR/needless_lifetimes.rs:146:5
+  --> $DIR/needless_lifetimes.rs:150:5
    |
 LL |     fn self_and_out<'s>(&'s self) -> &'s u8 {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: the following explicit lifetimes could be elided: 't
-  --> $DIR/needless_lifetimes.rs:153:5
+  --> $DIR/needless_lifetimes.rs:157:5
    |
 LL |     fn self_and_in_out_1<'s, 't>(&'s self, _x: &'t u8) -> &'s u8 {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: the following explicit lifetimes could be elided: 's
-  --> $DIR/needless_lifetimes.rs:160:5
+  --> $DIR/needless_lifetimes.rs:164:5
    |
 LL |     fn self_and_in_out_2<'s, 't>(&'s self, x: &'t u8) -> &'t u8 {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: the following explicit lifetimes could be elided: 's, 't
-  --> $DIR/needless_lifetimes.rs:164:5
+  --> $DIR/needless_lifetimes.rs:168:5
    |
 LL |     fn distinct_self_and_in<'s, 't>(&'s self, _x: &'t u8) {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:183:1
+  --> $DIR/needless_lifetimes.rs:187:1
    |
 LL | fn struct_with_lt<'a>(_foo: Foo<'a>) -> &'a str {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: replace with `'_` in generic arguments such as here
-  --> $DIR/needless_lifetimes.rs:183:33
+  --> $DIR/needless_lifetimes.rs:187:33
    |
 LL | fn struct_with_lt<'a>(_foo: Foo<'a>) -> &'a str {
    |                                 ^^
 
 error: the following explicit lifetimes could be elided: 'b
-  --> $DIR/needless_lifetimes.rs:201:1
+  --> $DIR/needless_lifetimes.rs:205:1
    |
 LL | fn struct_with_lt4a<'a, 'b>(_foo: &'a Foo<'b>) -> &'a str {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: replace with `'_` in generic arguments such as here
-  --> $DIR/needless_lifetimes.rs:201:43
+  --> $DIR/needless_lifetimes.rs:205:43
    |
 LL | fn struct_with_lt4a<'a, 'b>(_foo: &'a Foo<'b>) -> &'a str {
    |                                           ^^
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:209:1
+  --> $DIR/needless_lifetimes.rs:213:1
    |
 LL | fn struct_with_lt4b<'a, 'b>(_foo: &'a Foo<'b>) -> &'b str {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:224:1
+  --> $DIR/needless_lifetimes.rs:228:1
    |
 LL | fn trait_obj_elided2<'a>(_arg: &'a dyn Drop) -> &'a str {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:230:1
+  --> $DIR/needless_lifetimes.rs:234:1
    |
 LL | fn alias_with_lt<'a>(_foo: FooAlias<'a>) -> &'a str {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: replace with `'_` in generic arguments such as here
-  --> $DIR/needless_lifetimes.rs:230:37
+  --> $DIR/needless_lifetimes.rs:234:37
    |
 LL | fn alias_with_lt<'a>(_foo: FooAlias<'a>) -> &'a str {
    |                                     ^^
 
 error: the following explicit lifetimes could be elided: 'b
-  --> $DIR/needless_lifetimes.rs:248:1
+  --> $DIR/needless_lifetimes.rs:252:1
    |
 LL | fn alias_with_lt4a<'a, 'b>(_foo: &'a FooAlias<'b>) -> &'a str {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: replace with `'_` in generic arguments such as here
-  --> $DIR/needless_lifetimes.rs:248:47
+  --> $DIR/needless_lifetimes.rs:252:47
    |
 LL | fn alias_with_lt4a<'a, 'b>(_foo: &'a FooAlias<'b>) -> &'a str {
    |                                               ^^
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:256:1
+  --> $DIR/needless_lifetimes.rs:260:1
    |
 LL | fn alias_with_lt4b<'a, 'b>(_foo: &'a FooAlias<'b>) -> &'b str {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:260:1
+  --> $DIR/needless_lifetimes.rs:264:1
    |
 LL | fn named_input_elided_output<'a>(_arg: &'a str) -> &str {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:268:1
+  --> $DIR/needless_lifetimes.rs:272:1
    |
 LL | fn trait_bound_ok<'a, T: WithLifetime<'static>>(_: &'a u8, _: T) {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:304:1
+  --> $DIR/needless_lifetimes.rs:308:1
    |
 LL | fn out_return_type_lts<'a>(e: &'a str) -> Cow<'a> {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: replace with `'_` in generic arguments such as here
-  --> $DIR/needless_lifetimes.rs:304:47
+  --> $DIR/needless_lifetimes.rs:308:47
    |
 LL | fn out_return_type_lts<'a>(e: &'a str) -> Cow<'a> {
    |                                               ^^
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:311:9
+  --> $DIR/needless_lifetimes.rs:315:9
    |
 LL |         fn needless_lt<'a>(x: &'a u8) {}
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:315:9
+  --> $DIR/needless_lifetimes.rs:319:9
    |
 LL |         fn needless_lt<'a>(_x: &'a u8) {}
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:328:9
+  --> $DIR/needless_lifetimes.rs:332:9
    |
 LL |         fn baz<'a>(&'a self) -> impl Foo + 'a {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:360:5
+  --> $DIR/needless_lifetimes.rs:364:5
    |
 LL |     fn impl_trait_elidable_nested_anonymous_lifetimes<'a>(i: &'a i32, f: impl Fn(&i32) -> &i32) -> &'a i32 {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:369:5
+  --> $DIR/needless_lifetimes.rs:373:5
    |
 LL |     fn generics_elidable<'a, T: Fn(&i32) -> &i32>(i: &'a i32, f: T) -> &'a i32 {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:381:5
+  --> $DIR/needless_lifetimes.rs:385:5
    |
 LL |     fn where_clause_elidadable<'a, T>(i: &'a i32, f: T) -> &'a i32
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:396:5
+  --> $DIR/needless_lifetimes.rs:400:5
    |
 LL |     fn pointer_fn_elidable<'a>(i: &'a i32, f: fn(&i32) -> &i32) -> &'a i32 {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:409:5
+  --> $DIR/needless_lifetimes.rs:413:5
    |
 LL |     fn nested_fn_pointer_3<'a>(_: &'a i32) -> fn(fn(&i32) -> &i32) -> i32 {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:412:5
+  --> $DIR/needless_lifetimes.rs:416:5
    |
 LL |     fn nested_fn_pointer_4<'a>(_: &'a i32) -> impl Fn(fn(&i32)) {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:434:9
+  --> $DIR/needless_lifetimes.rs:438:9
    |
 LL |         fn implicit<'a>(&'a self) -> &'a () {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:437:9
+  --> $DIR/needless_lifetimes.rs:441:9
    |
 LL |         fn implicit_mut<'a>(&'a mut self) -> &'a () {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:448:9
+  --> $DIR/needless_lifetimes.rs:452:9
    |
 LL |         fn lifetime_elsewhere<'a>(self: Box<Self>, here: &'a ()) -> &'a () {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:454:9
+  --> $DIR/needless_lifetimes.rs:458:9
    |
 LL |         fn implicit<'a>(&'a self) -> &'a ();
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:455:9
+  --> $DIR/needless_lifetimes.rs:459:9
    |
 LL |         fn implicit_provided<'a>(&'a self) -> &'a () {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:464:9
+  --> $DIR/needless_lifetimes.rs:468:9
    |
 LL |         fn lifetime_elsewhere<'a>(self: Box<Self>, here: &'a ()) -> &'a ();
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:465:9
+  --> $DIR/needless_lifetimes.rs:469:9
    |
 LL |         fn lifetime_elsewhere_provided<'a>(self: Box<Self>, here: &'a ()) -> &'a () {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:474:5
+  --> $DIR/needless_lifetimes.rs:478:5
    |
 LL |     fn foo<'a>(x: &'a u8, y: &'_ u8) {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:476:5
+  --> $DIR/needless_lifetimes.rs:480:5
    |
 LL |     fn bar<'a>(x: &'a u8, y: &'_ u8, z: &'_ u8) {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:483:5
+  --> $DIR/needless_lifetimes.rs:487:5
    |
 LL |     fn one_input<'a>(x: &'a u8) -> &'a u8 {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:488:5
+  --> $DIR/needless_lifetimes.rs:492:5
    |
 LL |     fn multiple_inputs_output_not_elided<'a, 'b>(x: &'a u8, y: &'b u8, z: &'b u8) -> &'b u8 {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 45 previous errors
+error: the following explicit lifetimes could be elided: 'a
+  --> $DIR/needless_lifetimes.rs:505:13
+   |
+LL |             fn one_input<'a>(x: &'a u8) -> &'a u8 {
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+...
+LL |     local_one_input_macro!();
+   |     ------------------------ in this macro invocation
+   |
+   = note: this error originates in the macro `local_one_input_macro` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: aborting due to 46 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 2432e97d6ab7e44390542c00229344bf45fcaddd Mon Sep 17 00:00:00 2001
From: Tyler Weaver <maybe@tylerjw.dev>
Date: Sat, 28 Jan 2023 18:45:57 -0700
Subject: wildcard_enum_match_arm lint takes the enum origin into account

Signed-off-by: Tyler Weaver <maybe@tylerjw.dev>
---
 clippy_lints/src/matches/match_wild_enum.rs        | 17 +++++++++++------
 tests/ui/match_wildcard_for_single_variants.fixed  |  2 +-
 tests/ui/match_wildcard_for_single_variants.stderr |  8 +++++++-
 tests/ui/wildcard_enum_match_arm.fixed             |  2 +-
 tests/ui/wildcard_enum_match_arm.stderr            |  4 ++--
 5 files changed, 22 insertions(+), 11 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/match_wild_enum.rs b/clippy_lints/src/matches/match_wild_enum.rs
index 59de8c0384b..05cac0f9979 100644
--- a/clippy_lints/src/matches/match_wild_enum.rs
+++ b/clippy_lints/src/matches/match_wild_enum.rs
@@ -45,8 +45,12 @@ pub(crate) fn check(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>]) {
 
     // Accumulate the variants which should be put in place of the wildcard because they're not
     // already covered.
-    let has_hidden = adt_def.variants().iter().any(|x| is_hidden(cx, x));
-    let mut missing_variants: Vec<_> = adt_def.variants().iter().filter(|x| !is_hidden(cx, x)).collect();
+    let has_hidden_external = adt_def.variants().iter().any(|x| is_hidden_and_external(cx, x));
+    let mut missing_variants: Vec<_> = adt_def
+        .variants()
+        .iter()
+        .filter(|x| !is_hidden_and_external(cx, x))
+        .collect();
 
     let mut path_prefix = CommonPrefixSearcher::None;
     for arm in arms {
@@ -133,7 +137,7 @@ pub(crate) fn check(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>]) {
 
     match missing_variants.as_slice() {
         [] => (),
-        [x] if !adt_def.is_variant_list_non_exhaustive() && !has_hidden => span_lint_and_sugg(
+        [x] if !adt_def.is_variant_list_non_exhaustive() && !has_hidden_external => span_lint_and_sugg(
             cx,
             MATCH_WILDCARD_FOR_SINGLE_VARIANTS,
             wildcard_span,
@@ -144,7 +148,7 @@ pub(crate) fn check(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>]) {
         ),
         variants => {
             let mut suggestions: Vec<_> = variants.iter().copied().map(format_suggestion).collect();
-            let message = if adt_def.is_variant_list_non_exhaustive() || has_hidden {
+            let message = if adt_def.is_variant_list_non_exhaustive() || has_hidden_external {
                 suggestions.push("_".into());
                 "wildcard matches known variants and will also match future added variants"
             } else {
@@ -191,6 +195,7 @@ impl<'a> CommonPrefixSearcher<'a> {
     }
 }
 
-fn is_hidden(cx: &LateContext<'_>, variant_def: &VariantDef) -> bool {
-    cx.tcx.is_doc_hidden(variant_def.def_id) || cx.tcx.has_attr(variant_def.def_id, sym::unstable)
+fn is_hidden_and_external(cx: &LateContext<'_>, variant_def: &VariantDef) -> bool {
+    (cx.tcx.is_doc_hidden(variant_def.def_id) || cx.tcx.has_attr(variant_def.def_id, sym::unstable))
+        && variant_def.def_id.as_local().is_none()
 }
diff --git a/tests/ui/match_wildcard_for_single_variants.fixed b/tests/ui/match_wildcard_for_single_variants.fixed
index fc252cdd352..9fd3739b69c 100644
--- a/tests/ui/match_wildcard_for_single_variants.fixed
+++ b/tests/ui/match_wildcard_for_single_variants.fixed
@@ -123,7 +123,7 @@ fn main() {
             Enum::A => (),
             Enum::B => (),
             Enum::C => (),
-            _ => (),
+            Enum::__Private => (),
         }
         match Enum::A {
             Enum::A => (),
diff --git a/tests/ui/match_wildcard_for_single_variants.stderr b/tests/ui/match_wildcard_for_single_variants.stderr
index 6fa313dc911..105b4c4b41d 100644
--- a/tests/ui/match_wildcard_for_single_variants.stderr
+++ b/tests/ui/match_wildcard_for_single_variants.stderr
@@ -48,11 +48,17 @@ error: wildcard matches only a single variant and will also match any future add
 LL |         _ => (),
    |         ^ help: try this: `Color::Blue`
 
+error: wildcard matches only a single variant and will also match any future added variants
+  --> $DIR/match_wildcard_for_single_variants.rs:126:13
+   |
+LL |             _ => (),
+   |             ^ help: try this: `Enum::__Private`
+
 error: wildcard matches only a single variant and will also match any future added variants
   --> $DIR/match_wildcard_for_single_variants.rs:153:13
    |
 LL |             _ => 2,
    |             ^ help: try this: `Foo::B`
 
-error: aborting due to 9 previous errors
+error: aborting due to 10 previous errors
 
diff --git a/tests/ui/wildcard_enum_match_arm.fixed b/tests/ui/wildcard_enum_match_arm.fixed
index 23607497841..293bf75a717 100644
--- a/tests/ui/wildcard_enum_match_arm.fixed
+++ b/tests/ui/wildcard_enum_match_arm.fixed
@@ -96,7 +96,7 @@ fn main() {
         }
         match Enum::A {
             Enum::A => (),
-            Enum::B | _ => (),
+            Enum::B | Enum::__Private => (),
         }
     }
 }
diff --git a/tests/ui/wildcard_enum_match_arm.stderr b/tests/ui/wildcard_enum_match_arm.stderr
index efecc9576cc..30d29aa4e77 100644
--- a/tests/ui/wildcard_enum_match_arm.stderr
+++ b/tests/ui/wildcard_enum_match_arm.stderr
@@ -34,11 +34,11 @@ error: wildcard matches known variants and will also match future added variants
 LL |         _ => {},
    |         ^ help: try this: `ErrorKind::PermissionDenied | _`
 
-error: wildcard matches known variants and will also match future added variants
+error: wildcard match will also match any future added variants
   --> $DIR/wildcard_enum_match_arm.rs:99:13
    |
 LL |             _ => (),
-   |             ^ help: try this: `Enum::B | _`
+   |             ^ help: try this: `Enum::B | Enum::__Private`
 
 error: aborting due to 6 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From c531b09eb85e4dff966b6bfb93e7fbf128fdfba0 Mon Sep 17 00:00:00 2001
From: Tyler Weaver <maybe@tylerjw.dev>
Date: Mon, 30 Jan 2023 15:46:34 -0700
Subject: Check external before hidden

---
 clippy_lints/src/matches/match_wild_enum.rs | 18 +++++++++++++-----
 1 file changed, 13 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/match_wild_enum.rs b/clippy_lints/src/matches/match_wild_enum.rs
index 05cac0f9979..3b35c04620c 100644
--- a/clippy_lints/src/matches/match_wild_enum.rs
+++ b/clippy_lints/src/matches/match_wild_enum.rs
@@ -3,6 +3,7 @@ use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::{is_refutable, peel_hir_pat_refs, recurse_or_patterns};
 use rustc_errors::Applicability;
 use rustc_hir::def::{CtorKind, DefKind, Res};
+use rustc_hir::def_id::DefId;
 use rustc_hir::{Arm, Expr, PatKind, PathSegment, QPath, Ty, TyKind};
 use rustc_lint::LateContext;
 use rustc_middle::ty::{self, VariantDef};
@@ -45,11 +46,11 @@ pub(crate) fn check(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>]) {
 
     // Accumulate the variants which should be put in place of the wildcard because they're not
     // already covered.
-    let has_hidden_external = adt_def.variants().iter().any(|x| is_hidden_and_external(cx, x));
+    let has_hidden_external = adt_def.variants().iter().any(|x| is_external_and_hidden(cx, x));
     let mut missing_variants: Vec<_> = adt_def
         .variants()
         .iter()
-        .filter(|x| !is_hidden_and_external(cx, x))
+        .filter(|x| !is_external_and_hidden(cx, x))
         .collect();
 
     let mut path_prefix = CommonPrefixSearcher::None;
@@ -195,7 +196,14 @@ impl<'a> CommonPrefixSearcher<'a> {
     }
 }
 
-fn is_hidden_and_external(cx: &LateContext<'_>, variant_def: &VariantDef) -> bool {
-    (cx.tcx.is_doc_hidden(variant_def.def_id) || cx.tcx.has_attr(variant_def.def_id, sym::unstable))
-        && variant_def.def_id.as_local().is_none()
+fn is_external_and_hidden(cx: &LateContext<'_>, variant_def: &VariantDef) -> bool {
+    is_external(variant_def.def_id) && is_hidden(cx, variant_def)
+}
+
+fn is_hidden(cx: &LateContext<'_>, variant_def: &VariantDef) -> bool {
+    cx.tcx.is_doc_hidden(variant_def.def_id) || cx.tcx.has_attr(variant_def.def_id, sym::unstable)
+}
+
+fn is_external(def_id: DefId) -> bool {
+    def_id.as_local().is_none()
 }
-- 
cgit 1.4.1-3-g733a5


From df7cdf732d3679f21c4a36808fb43b832f0a6725 Mon Sep 17 00:00:00 2001
From: Tyler Weaver <maybe@tylerjw.dev>
Date: Mon, 30 Jan 2023 17:29:17 -0700
Subject: Pull the is_external test out of the loop

---
 clippy_lints/src/matches/match_wild_enum.rs | 18 +++++-------------
 1 file changed, 5 insertions(+), 13 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/match_wild_enum.rs b/clippy_lints/src/matches/match_wild_enum.rs
index 3b35c04620c..3126b590180 100644
--- a/clippy_lints/src/matches/match_wild_enum.rs
+++ b/clippy_lints/src/matches/match_wild_enum.rs
@@ -3,7 +3,6 @@ use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::{is_refutable, peel_hir_pat_refs, recurse_or_patterns};
 use rustc_errors::Applicability;
 use rustc_hir::def::{CtorKind, DefKind, Res};
-use rustc_hir::def_id::DefId;
 use rustc_hir::{Arm, Expr, PatKind, PathSegment, QPath, Ty, TyKind};
 use rustc_lint::LateContext;
 use rustc_middle::ty::{self, VariantDef};
@@ -46,11 +45,12 @@ pub(crate) fn check(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>]) {
 
     // Accumulate the variants which should be put in place of the wildcard because they're not
     // already covered.
-    let has_hidden_external = adt_def.variants().iter().any(|x| is_external_and_hidden(cx, x));
+    let is_external = adt_def.did().as_local().is_none();
+    let has_external_hidden = is_external && adt_def.variants().iter().any(|x| is_hidden(cx, x));
     let mut missing_variants: Vec<_> = adt_def
         .variants()
         .iter()
-        .filter(|x| !is_external_and_hidden(cx, x))
+        .filter(|x| !(is_external && is_hidden(cx, x)))
         .collect();
 
     let mut path_prefix = CommonPrefixSearcher::None;
@@ -138,7 +138,7 @@ pub(crate) fn check(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>]) {
 
     match missing_variants.as_slice() {
         [] => (),
-        [x] if !adt_def.is_variant_list_non_exhaustive() && !has_hidden_external => span_lint_and_sugg(
+        [x] if !adt_def.is_variant_list_non_exhaustive() && !has_external_hidden => span_lint_and_sugg(
             cx,
             MATCH_WILDCARD_FOR_SINGLE_VARIANTS,
             wildcard_span,
@@ -149,7 +149,7 @@ pub(crate) fn check(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>]) {
         ),
         variants => {
             let mut suggestions: Vec<_> = variants.iter().copied().map(format_suggestion).collect();
-            let message = if adt_def.is_variant_list_non_exhaustive() || has_hidden_external {
+            let message = if adt_def.is_variant_list_non_exhaustive() || has_external_hidden {
                 suggestions.push("_".into());
                 "wildcard matches known variants and will also match future added variants"
             } else {
@@ -196,14 +196,6 @@ impl<'a> CommonPrefixSearcher<'a> {
     }
 }
 
-fn is_external_and_hidden(cx: &LateContext<'_>, variant_def: &VariantDef) -> bool {
-    is_external(variant_def.def_id) && is_hidden(cx, variant_def)
-}
-
 fn is_hidden(cx: &LateContext<'_>, variant_def: &VariantDef) -> bool {
     cx.tcx.is_doc_hidden(variant_def.def_id) || cx.tcx.has_attr(variant_def.def_id, sym::unstable)
 }
-
-fn is_external(def_id: DefId) -> bool {
-    def_id.as_local().is_none()
-}
-- 
cgit 1.4.1-3-g733a5


From b4e2b48270008b2c4fa84f4d6270e13a93f1ac14 Mon Sep 17 00:00:00 2001
From: Manish Goregaokar <manishsmail@gmail.com>
Date: Mon, 30 Jan 2023 19:28:27 -0800
Subject: Mark uninlined_format_args as pedantic

---
 clippy_lints/src/format_args.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/format_args.rs b/clippy_lints/src/format_args.rs
index ab05d4688cc..d6b02f174f9 100644
--- a/clippy_lints/src/format_args.rs
+++ b/clippy_lints/src/format_args.rs
@@ -125,7 +125,7 @@ declare_clippy_lint! {
     /// nothing will be suggested, e.g. `println!("{0}={1}", var, 1+2)`.
     #[clippy::version = "1.66.0"]
     pub UNINLINED_FORMAT_ARGS,
-    style,
+    pedantic,
     "using non-inlined variables in `format!` calls"
 }
 
-- 
cgit 1.4.1-3-g733a5


From 6a8b20230b4e1ccdc5936d9cde5a6018d3b8fc74 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Tue, 31 Jan 2023 14:12:03 +0000
Subject: Add machine applicable suggestion for `needless_lifetimes`

Also adds a test for #5787
---
 clippy_lints/src/lifetimes.rs                      | 253 ++++++----
 tests/ui/crashes/ice-2774.stderr                   |   5 +
 .../crashes/needless_lifetimes_impl_trait.stderr   |   5 +
 tests/ui/needless_lifetimes.fixed                  | 537 +++++++++++++++++++++
 tests/ui/needless_lifetimes.rs                     |  21 +-
 tests/ui/needless_lifetimes.stderr                 | 380 ++++++++++++---
 6 files changed, 1019 insertions(+), 182 deletions(-)
 create mode 100644 tests/ui/needless_lifetimes.fixed

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lifetimes.rs b/clippy_lints/src/lifetimes.rs
index ef9ac96ace5..3cccc2cfe2a 100644
--- a/clippy_lints/src/lifetimes.rs
+++ b/clippy_lints/src/lifetimes.rs
@@ -1,22 +1,21 @@
 use clippy_utils::diagnostics::{span_lint, span_lint_and_then};
 use clippy_utils::trait_ref_of_method;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
+use rustc_errors::Applicability;
 use rustc_hir::intravisit::nested_filter::{self as hir_nested_filter, NestedFilter};
 use rustc_hir::intravisit::{
-    walk_fn_decl, walk_generic_arg, walk_generic_param, walk_generics, walk_impl_item_ref, walk_item, walk_param_bound,
+    walk_fn_decl, walk_generic_param, walk_generics, walk_impl_item_ref, walk_item, walk_param_bound,
     walk_poly_trait_ref, walk_trait_ref, walk_ty, Visitor,
 };
-use rustc_hir::lang_items;
 use rustc_hir::FnRetTy::Return;
 use rustc_hir::{
-    BareFnTy, BodyId, FnDecl, GenericArg, GenericBound, GenericParam, GenericParamKind, Generics, Impl, ImplItem,
-    ImplItemKind, Item, ItemKind, Lifetime, LifetimeName, LifetimeParamKind, PolyTraitRef, PredicateOrigin, TraitFn,
-    TraitItem, TraitItemKind, Ty, TyKind, WherePredicate,
+    lang_items, BareFnTy, BodyId, FnDecl, FnSig, GenericArg, GenericBound, GenericParam, GenericParamKind, Generics,
+    Impl, ImplItem, ImplItemKind, Item, ItemKind, Lifetime, LifetimeName, LifetimeParamKind, Node, PolyTraitRef,
+    PredicateOrigin, TraitFn, TraitItem, TraitItemKind, Ty, TyKind, WherePredicate,
 };
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::hir::nested_filter as middle_nested_filter;
 use rustc_middle::lint::in_external_macro;
-use rustc_middle::ty::TyCtxt;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::def_id::LocalDefId;
 use rustc_span::source_map::Span;
@@ -35,8 +34,6 @@ declare_clippy_lint! {
     /// ### Known problems
     /// - We bail out if the function has a `where` clause where lifetimes
     /// are mentioned due to potential false positives.
-    /// - Lifetime bounds such as `impl Foo + 'a` and `T: 'a` must be elided with the
-    /// placeholder notation `'_` because the fully elided notation leaves the type bound to `'static`.
     ///
     /// ### Example
     /// ```rust
@@ -94,7 +91,7 @@ declare_lint_pass!(Lifetimes => [NEEDLESS_LIFETIMES, EXTRA_UNUSED_LIFETIMES]);
 impl<'tcx> LateLintPass<'tcx> for Lifetimes {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
         if let ItemKind::Fn(ref sig, generics, id) = item.kind {
-            check_fn_inner(cx, sig.decl, Some(id), None, generics, item.span, true);
+            check_fn_inner(cx, sig, Some(id), None, generics, item.span, true);
         } else if let ItemKind::Impl(impl_) = item.kind {
             if !item.span.from_expansion() {
                 report_extra_impl_lifetimes(cx, impl_);
@@ -107,7 +104,7 @@ impl<'tcx> LateLintPass<'tcx> for Lifetimes {
             let report_extra_lifetimes = trait_ref_of_method(cx, item.owner_id.def_id).is_none();
             check_fn_inner(
                 cx,
-                sig.decl,
+                sig,
                 Some(id),
                 None,
                 item.generics,
@@ -123,22 +120,14 @@ impl<'tcx> LateLintPass<'tcx> for Lifetimes {
                 TraitFn::Required(sig) => (None, Some(sig)),
                 TraitFn::Provided(id) => (Some(id), None),
             };
-            check_fn_inner(cx, sig.decl, body, trait_sig, item.generics, item.span, true);
+            check_fn_inner(cx, sig, body, trait_sig, item.generics, item.span, true);
         }
     }
 }
 
-/// The lifetime of a &-reference.
-#[derive(PartialEq, Eq, Hash, Debug, Clone)]
-enum RefLt {
-    Unnamed,
-    Static,
-    Named(LocalDefId),
-}
-
 fn check_fn_inner<'tcx>(
     cx: &LateContext<'tcx>,
-    decl: &'tcx FnDecl<'_>,
+    sig: &'tcx FnSig<'_>,
     body: Option<BodyId>,
     trait_sig: Option<&[Ident]>,
     generics: &'tcx Generics<'_>,
@@ -164,7 +153,7 @@ fn check_fn_inner<'tcx>(
             for bound in pred.bounds {
                 let mut visitor = RefVisitor::new(cx);
                 walk_param_bound(&mut visitor, bound);
-                if visitor.lts.iter().any(|lt| matches!(lt, RefLt::Named(_))) {
+                if visitor.lts.iter().any(|lt| matches!(lt.res, LifetimeName::Param(_))) {
                     return;
                 }
                 if let GenericBound::Trait(ref trait_ref, _) = *bound {
@@ -191,12 +180,12 @@ fn check_fn_inner<'tcx>(
         }
     }
 
-    if let Some(elidable_lts) = could_use_elision(cx, decl, body, trait_sig, generics.params) {
+    if let Some((elidable_lts, usages)) = could_use_elision(cx, sig.decl, body, trait_sig, generics.params) {
         let lts = elidable_lts
             .iter()
             // In principle, the result of the call to `Node::ident` could be `unwrap`ped, as `DefId` should refer to a
             // `Node::GenericParam`.
-            .filter_map(|&(def_id, _)| cx.tcx.hir().get_by_def_id(def_id).ident())
+            .filter_map(|&def_id| cx.tcx.hir().get_by_def_id(def_id).ident())
             .map(|ident| ident.to_string())
             .collect::<Vec<_>>()
             .join(", ");
@@ -204,21 +193,99 @@ fn check_fn_inner<'tcx>(
         span_lint_and_then(
             cx,
             NEEDLESS_LIFETIMES,
-            span.with_hi(decl.output.span().hi()),
+            span.with_hi(sig.decl.output.span().hi()),
             &format!("the following explicit lifetimes could be elided: {lts}"),
             |diag| {
-                if let Some(span) = elidable_lts.iter().find_map(|&(_, span)| span) {
-                    diag.span_help(span, "replace with `'_` in generic arguments such as here");
+                if sig.header.is_async() {
+                    // async functions have usages whose spans point at the lifetime declaration which messes up
+                    // suggestions
+                    return;
+                };
+
+                if let Some(suggestions) = elision_suggestions(cx, generics, &elidable_lts, &usages) {
+                    diag.multipart_suggestion("elide the lifetimes", suggestions, Applicability::MachineApplicable);
                 }
             },
         );
     }
 
     if report_extra_lifetimes {
-        self::report_extra_lifetimes(cx, decl, generics);
+        self::report_extra_lifetimes(cx, sig.decl, generics);
     }
 }
 
+fn elision_suggestions(
+    cx: &LateContext<'_>,
+    generics: &Generics<'_>,
+    elidable_lts: &[LocalDefId],
+    usages: &[Lifetime],
+) -> Option<Vec<(Span, String)>> {
+    let explicit_params = generics
+        .params
+        .iter()
+        .filter(|param| !param.is_elided_lifetime() && !param.is_impl_trait())
+        .collect::<Vec<_>>();
+
+    let mut suggestions = if elidable_lts.len() == explicit_params.len() {
+        // if all the params are elided remove the whole generic block
+        //
+        // fn x<'a>() {}
+        //     ^^^^
+        vec![(generics.span, String::new())]
+    } else {
+        elidable_lts
+            .iter()
+            .map(|&id| {
+                let pos = explicit_params.iter().position(|param| param.def_id == id)?;
+                let param = explicit_params.get(pos)?;
+
+                let span = if let Some(next) = explicit_params.get(pos + 1) {
+                    // fn x<'prev, 'a, 'next>() {}
+                    //             ^^^^
+                    param.span.until(next.span)
+                } else {
+                    // `pos` should be at least 1 here, because the param in position 0 would either have a `next`
+                    // param or would have taken the `elidable_lts.len() == explicit_params.len()` branch.
+                    let prev = explicit_params.get(pos - 1)?;
+
+                    // fn x<'prev, 'a>() {}
+                    //           ^^^^
+                    param.span.with_lo(prev.span.hi())
+                };
+
+                Some((span, String::new()))
+            })
+            .collect::<Option<Vec<_>>>()?
+    };
+
+    suggestions.extend(
+        usages
+            .iter()
+            .filter(|usage| named_lifetime(usage).map_or(false, |id| elidable_lts.contains(&id)))
+            .map(|usage| {
+                match cx.tcx.hir().get_parent(usage.hir_id) {
+                    Node::Ty(Ty {
+                        kind: TyKind::Ref(..), ..
+                    }) => {
+                        // expand `&'a T` to `&'a T`
+                        //          ^^         ^^^
+                        let span = cx
+                            .sess()
+                            .source_map()
+                            .span_extend_while(usage.ident.span, |ch| ch.is_ascii_whitespace())
+                            .unwrap_or(usage.ident.span);
+
+                        (span, String::new())
+                    },
+                    // `T<'a>` and `impl Foo + 'a` should be replaced by `'_`
+                    _ => (usage.ident.span, String::from("'_")),
+                }
+            }),
+    );
+
+    Some(suggestions)
+}
+
 // elision doesn't work for explicit self types, see rust-lang/rust#69064
 fn explicit_self_type<'tcx>(cx: &LateContext<'tcx>, func: &FnDecl<'tcx>, ident: Option<Ident>) -> bool {
     if_chain! {
@@ -238,13 +305,20 @@ fn explicit_self_type<'tcx>(cx: &LateContext<'tcx>, func: &FnDecl<'tcx>, ident:
     }
 }
 
+fn named_lifetime(lt: &Lifetime) -> Option<LocalDefId> {
+    match lt.res {
+        LifetimeName::Param(id) if !lt.is_anonymous() => Some(id),
+        _ => None,
+    }
+}
+
 fn could_use_elision<'tcx>(
     cx: &LateContext<'tcx>,
     func: &'tcx FnDecl<'_>,
     body: Option<BodyId>,
     trait_sig: Option<&[Ident]>,
     named_generics: &'tcx [GenericParam<'_>],
-) -> Option<Vec<(LocalDefId, Option<Span>)>> {
+) -> Option<(Vec<LocalDefId>, Vec<Lifetime>)> {
     // There are two scenarios where elision works:
     // * no output references, all input references have different LT
     // * output references, exactly one input reference with same LT
@@ -252,7 +326,7 @@ fn could_use_elision<'tcx>(
     // level of the current item.
 
     // check named LTs
-    let allowed_lts = allowed_lts_from(cx.tcx, named_generics);
+    let allowed_lts = allowed_lts_from(named_generics);
 
     // these will collect all the lifetimes for references in arg/return types
     let mut input_visitor = RefVisitor::new(cx);
@@ -302,32 +376,24 @@ fn could_use_elision<'tcx>(
 
     // check for lifetimes from higher scopes
     for lt in input_lts.iter().chain(output_lts.iter()) {
-        if !allowed_lts.contains(lt) {
+        if let Some(id) = named_lifetime(lt)
+            && !allowed_lts.contains(&id)
+        {
             return None;
         }
     }
 
     // check for higher-ranked trait bounds
     if !input_visitor.nested_elision_site_lts.is_empty() || !output_visitor.nested_elision_site_lts.is_empty() {
-        let allowed_lts: FxHashSet<_> = allowed_lts
-            .iter()
-            .filter_map(|lt| match lt {
-                RefLt::Named(def_id) => Some(cx.tcx.item_name(def_id.to_def_id())),
-                _ => None,
-            })
-            .collect();
+        let allowed_lts: FxHashSet<_> = allowed_lts.iter().map(|id| cx.tcx.item_name(id.to_def_id())).collect();
         for lt in input_visitor.nested_elision_site_lts {
-            if let RefLt::Named(def_id) = lt {
-                if allowed_lts.contains(&cx.tcx.item_name(def_id.to_def_id())) {
-                    return None;
-                }
+            if allowed_lts.contains(&lt.ident.name) {
+                return None;
             }
         }
         for lt in output_visitor.nested_elision_site_lts {
-            if let RefLt::Named(def_id) = lt {
-                if allowed_lts.contains(&cx.tcx.item_name(def_id.to_def_id())) {
-                    return None;
-                }
+            if allowed_lts.contains(&lt.ident.name) {
+                return None;
             }
         }
     }
@@ -339,15 +405,10 @@ fn could_use_elision<'tcx>(
     let elidable_lts = named_lifetime_occurrences(&input_lts)
         .into_iter()
         .filter_map(|(def_id, occurrences)| {
-            if occurrences == 1 && (input_lts.len() == 1 || !output_lts.contains(&RefLt::Named(def_id))) {
-                Some((
-                    def_id,
-                    input_visitor
-                        .lifetime_generic_arg_spans
-                        .get(&def_id)
-                        .or_else(|| output_visitor.lifetime_generic_arg_spans.get(&def_id))
-                        .copied(),
-                ))
+            if occurrences == 1
+                && (input_lts.len() == 1 || !output_lts.iter().any(|lt| named_lifetime(lt) == Some(def_id)))
+            {
+                Some(def_id)
             } else {
                 None
             }
@@ -355,31 +416,34 @@ fn could_use_elision<'tcx>(
         .collect::<Vec<_>>();
 
     if elidable_lts.is_empty() {
-        None
-    } else {
-        Some(elidable_lts)
+        return None;
     }
+
+    let usages = itertools::chain(input_lts, output_lts).collect();
+
+    Some((elidable_lts, usages))
 }
 
-fn allowed_lts_from(tcx: TyCtxt<'_>, named_generics: &[GenericParam<'_>]) -> FxHashSet<RefLt> {
-    let mut allowed_lts = FxHashSet::default();
-    for par in named_generics.iter() {
-        if let GenericParamKind::Lifetime { .. } = par.kind {
-            allowed_lts.insert(RefLt::Named(tcx.hir().local_def_id(par.hir_id)));
-        }
-    }
-    allowed_lts.insert(RefLt::Unnamed);
-    allowed_lts.insert(RefLt::Static);
-    allowed_lts
+fn allowed_lts_from(named_generics: &[GenericParam<'_>]) -> FxHashSet<LocalDefId> {
+    named_generics
+        .iter()
+        .filter_map(|par| {
+            if let GenericParamKind::Lifetime { .. } = par.kind {
+                Some(par.def_id)
+            } else {
+                None
+            }
+        })
+        .collect()
 }
 
 /// Number of times each named lifetime occurs in the given slice. Returns a vector to preserve
 /// relative order.
 #[must_use]
-fn named_lifetime_occurrences(lts: &[RefLt]) -> Vec<(LocalDefId, usize)> {
+fn named_lifetime_occurrences(lts: &[Lifetime]) -> Vec<(LocalDefId, usize)> {
     let mut occurrences = Vec::new();
     for lt in lts {
-        if let &RefLt::Named(curr_def_id) = lt {
+        if let Some(curr_def_id) = named_lifetime(lt) {
             if let Some(pair) = occurrences
                 .iter_mut()
                 .find(|(prev_def_id, _)| *prev_def_id == curr_def_id)
@@ -393,12 +457,10 @@ fn named_lifetime_occurrences(lts: &[RefLt]) -> Vec<(LocalDefId, usize)> {
     occurrences
 }
 
-/// A visitor usable for `rustc_front::visit::walk_ty()`.
 struct RefVisitor<'a, 'tcx> {
     cx: &'a LateContext<'tcx>,
-    lts: Vec<RefLt>,
-    lifetime_generic_arg_spans: FxHashMap<LocalDefId, Span>,
-    nested_elision_site_lts: Vec<RefLt>,
+    lts: Vec<Lifetime>,
+    nested_elision_site_lts: Vec<Lifetime>,
     unelided_trait_object_lifetime: bool,
 }
 
@@ -407,32 +469,16 @@ impl<'a, 'tcx> RefVisitor<'a, 'tcx> {
         Self {
             cx,
             lts: Vec::new(),
-            lifetime_generic_arg_spans: FxHashMap::default(),
             nested_elision_site_lts: Vec::new(),
             unelided_trait_object_lifetime: false,
         }
     }
 
-    fn record(&mut self, lifetime: &Option<Lifetime>) {
-        if let Some(ref lt) = *lifetime {
-            if lt.is_static() {
-                self.lts.push(RefLt::Static);
-            } else if lt.is_anonymous() {
-                // Fresh lifetimes generated should be ignored.
-                self.lts.push(RefLt::Unnamed);
-            } else if let LifetimeName::Param(def_id) = lt.res {
-                self.lts.push(RefLt::Named(def_id));
-            }
-        } else {
-            self.lts.push(RefLt::Unnamed);
-        }
-    }
-
-    fn all_lts(&self) -> Vec<RefLt> {
+    fn all_lts(&self) -> Vec<Lifetime> {
         self.lts
             .iter()
             .chain(self.nested_elision_site_lts.iter())
-            .cloned()
+            .copied()
             .collect::<Vec<_>>()
     }
 
@@ -444,7 +490,7 @@ impl<'a, 'tcx> RefVisitor<'a, 'tcx> {
 impl<'a, 'tcx> Visitor<'tcx> for RefVisitor<'a, 'tcx> {
     // for lifetimes as parameters of generics
     fn visit_lifetime(&mut self, lifetime: &'tcx Lifetime) {
-        self.record(&Some(*lifetime));
+        self.lts.push(*lifetime);
     }
 
     fn visit_poly_trait_ref(&mut self, poly_tref: &'tcx PolyTraitRef<'tcx>) {
@@ -469,11 +515,7 @@ impl<'a, 'tcx> Visitor<'tcx> for RefVisitor<'a, 'tcx> {
                 walk_item(self, item);
                 self.lts.truncate(len);
                 self.lts.extend(bounds.iter().filter_map(|bound| match bound {
-                    GenericArg::Lifetime(l) => Some(if let LifetimeName::Param(def_id) = l.res {
-                        RefLt::Named(def_id)
-                    } else {
-                        RefLt::Unnamed
-                    }),
+                    GenericArg::Lifetime(&l) => Some(l),
                     _ => None,
                 }));
             },
@@ -493,13 +535,6 @@ impl<'a, 'tcx> Visitor<'tcx> for RefVisitor<'a, 'tcx> {
             _ => walk_ty(self, ty),
         }
     }
-
-    fn visit_generic_arg(&mut self, generic_arg: &'tcx GenericArg<'tcx>) {
-        if let GenericArg::Lifetime(l) = generic_arg && let LifetimeName::Param(def_id) = l.res {
-            self.lifetime_generic_arg_spans.entry(def_id).or_insert(l.ident.span);
-        }
-        walk_generic_arg(self, generic_arg);
-    }
 }
 
 /// Are any lifetimes mentioned in the `where` clause? If so, we don't try to
@@ -517,14 +552,18 @@ fn has_where_lifetimes<'tcx>(cx: &LateContext<'tcx>, generics: &'tcx Generics<'_
                     return true;
                 }
                 // if the bounds define new lifetimes, they are fine to occur
-                let allowed_lts = allowed_lts_from(cx.tcx, pred.bound_generic_params);
+                let allowed_lts = allowed_lts_from(pred.bound_generic_params);
                 // now walk the bounds
                 for bound in pred.bounds.iter() {
                     walk_param_bound(&mut visitor, bound);
                 }
                 // and check that all lifetimes are allowed
-                if visitor.all_lts().iter().any(|it| !allowed_lts.contains(it)) {
-                    return true;
+                for lt in visitor.all_lts() {
+                    if let Some(id) = named_lifetime(&lt)
+                        && !allowed_lts.contains(&id)
+                    {
+                        return true;
+                    }
                 }
             },
             WherePredicate::EqPredicate(ref pred) => {
diff --git a/tests/ui/crashes/ice-2774.stderr b/tests/ui/crashes/ice-2774.stderr
index 1f26c7f4db6..c5ea0b16d1b 100644
--- a/tests/ui/crashes/ice-2774.stderr
+++ b/tests/ui/crashes/ice-2774.stderr
@@ -5,6 +5,11 @@ LL | pub fn add_barfoos_to_foos<'a>(bars: &HashSet<&'a Bar>) {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::needless-lifetimes` implied by `-D warnings`
+help: elide the lifetimes
+   |
+LL - pub fn add_barfoos_to_foos<'a>(bars: &HashSet<&'a Bar>) {
+LL + pub fn add_barfoos_to_foos(bars: &HashSet<&Bar>) {
+   |
 
 error: aborting due to previous error
 
diff --git a/tests/ui/crashes/needless_lifetimes_impl_trait.stderr b/tests/ui/crashes/needless_lifetimes_impl_trait.stderr
index 875d5ab4f21..0b0e0ad2684 100644
--- a/tests/ui/crashes/needless_lifetimes_impl_trait.stderr
+++ b/tests/ui/crashes/needless_lifetimes_impl_trait.stderr
@@ -9,6 +9,11 @@ note: the lint level is defined here
    |
 LL | #![deny(clippy::needless_lifetimes)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
+help: elide the lifetimes
+   |
+LL -     fn baz<'a>(&'a self) -> impl Foo + 'a {
+LL +     fn baz(&self) -> impl Foo + '_ {
+   |
 
 error: aborting due to previous error
 
diff --git a/tests/ui/needless_lifetimes.fixed b/tests/ui/needless_lifetimes.fixed
new file mode 100644
index 00000000000..270cd1afc67
--- /dev/null
+++ b/tests/ui/needless_lifetimes.fixed
@@ -0,0 +1,537 @@
+// run-rustfix
+// aux-build:macro_rules.rs
+
+#![warn(clippy::needless_lifetimes)]
+#![allow(
+    unused,
+    clippy::boxed_local,
+    clippy::needless_pass_by_value,
+    clippy::unnecessary_wraps,
+    dyn_drop,
+    clippy::get_first
+)]
+
+#[macro_use]
+extern crate macro_rules;
+
+fn distinct_lifetimes(_x: &u8, _y: &u8, _z: u8) {}
+
+fn distinct_and_static(_x: &u8, _y: &u8, _z: &'static u8) {}
+
+// No error; same lifetime on two params.
+fn same_lifetime_on_input<'a>(_x: &'a u8, _y: &'a u8) {}
+
+// No error; static involved.
+fn only_static_on_input(_x: &u8, _y: &u8, _z: &'static u8) {}
+
+fn mut_and_static_input(_x: &mut u8, _y: &'static str) {}
+
+fn in_and_out(x: &u8, _y: u8) -> &u8 {
+    x
+}
+
+// No error; multiple input refs.
+fn multiple_in_and_out_1<'a>(x: &'a u8, _y: &'a u8) -> &'a u8 {
+    x
+}
+
+// Error; multiple input refs, but the output lifetime is not elided, i.e., the following is valid:
+//   fn multiple_in_and_out_2a<'a>(x: &'a u8, _y: &u8) -> &'a u8
+//                                                ^^^
+fn multiple_in_and_out_2a<'a>(x: &'a u8, _y: &u8) -> &'a u8 {
+    x
+}
+
+// Error; multiple input refs, but the output lifetime is not elided, i.e., the following is valid:
+//   fn multiple_in_and_out_2b<'b>(_x: &u8, y: &'b u8) -> &'b u8
+//                                     ^^^
+fn multiple_in_and_out_2b<'b>(_x: &u8, y: &'b u8) -> &'b u8 {
+    y
+}
+
+// No error; multiple input refs
+async fn func<'a>(args: &[&'a str]) -> Option<&'a str> {
+    args.get(0).cloned()
+}
+
+// No error; static involved.
+fn in_static_and_out<'a>(x: &'a u8, _y: &'static u8) -> &'a u8 {
+    x
+}
+
+// Error; multiple input refs, but the output lifetime is not elided, i.e., the following is valid:
+//   fn deep_reference_1a<'a>(x: &'a u8, _y: &u8) -> Result<&'a u8, ()>
+//                                           ^^^
+fn deep_reference_1a<'a>(x: &'a u8, _y: &u8) -> Result<&'a u8, ()> {
+    Ok(x)
+}
+
+// Error; multiple input refs, but the output lifetime is not elided, i.e., the following is valid:
+//   fn deep_reference_1b<'b>(_x: &u8, y: &'b u8) -> Result<&'b u8, ()>
+//                                ^^^
+fn deep_reference_1b<'b>(_x: &u8, y: &'b u8) -> Result<&'b u8, ()> {
+    Ok(y)
+}
+
+// No error; two input refs.
+fn deep_reference_2<'a>(x: Result<&'a u8, &'a u8>) -> &'a u8 {
+    x.unwrap()
+}
+
+fn deep_reference_3(x: &u8, _y: u8) -> Result<&u8, ()> {
+    Ok(x)
+}
+
+// Where-clause, but without lifetimes.
+fn where_clause_without_lt<T>(x: &u8, _y: u8) -> Result<&u8, ()>
+where
+    T: Copy,
+{
+    Ok(x)
+}
+
+type Ref<'r> = &'r u8;
+
+// No error; same lifetime on two params.
+fn lifetime_param_1<'a>(_x: Ref<'a>, _y: &'a u8) {}
+
+fn lifetime_param_2(_x: Ref<'_>, _y: &u8) {}
+
+// No error; bounded lifetime.
+fn lifetime_param_3<'a, 'b: 'a>(_x: Ref<'a>, _y: &'b u8) {}
+
+// No error; bounded lifetime.
+fn lifetime_param_4<'a, 'b>(_x: Ref<'a>, _y: &'b u8)
+where
+    'b: 'a,
+{
+}
+
+struct Lt<'a, I: 'static> {
+    x: &'a I,
+}
+
+// No error; fn bound references `'a`.
+fn fn_bound<'a, F, I>(_m: Lt<'a, I>, _f: F) -> Lt<'a, I>
+where
+    F: Fn(Lt<'a, I>) -> Lt<'a, I>,
+{
+    unreachable!()
+}
+
+fn fn_bound_2<F, I>(_m: Lt<'_, I>, _f: F) -> Lt<'_, I>
+where
+    for<'x> F: Fn(Lt<'x, I>) -> Lt<'x, I>,
+{
+    unreachable!()
+}
+
+// No error; see below.
+fn fn_bound_3<'a, F: FnOnce(&'a i32)>(x: &'a i32, f: F) {
+    f(x);
+}
+
+fn fn_bound_3_cannot_elide() {
+    let x = 42;
+    let p = &x;
+    let mut q = &x;
+    // This will fail if we elide lifetimes of `fn_bound_3`.
+    fn_bound_3(p, |y| q = y);
+}
+
+// No error; multiple input refs.
+fn fn_bound_4<'a, F: FnOnce() -> &'a ()>(cond: bool, x: &'a (), f: F) -> &'a () {
+    if cond { x } else { f() }
+}
+
+struct X {
+    x: u8,
+}
+
+impl X {
+    fn self_and_out(&self) -> &u8 {
+        &self.x
+    }
+
+    // Error; multiple input refs, but the output lifetime is not elided, i.e., the following is valid:
+    //   fn self_and_in_out_1<'s>(&'s self, _x: &u8) -> &'s u8
+    //                                          ^^^
+    fn self_and_in_out_1<'s>(&'s self, _x: &u8) -> &'s u8 {
+        &self.x
+    }
+
+    // Error; multiple input refs, but the output lifetime is not elided, i.e., the following is valid:
+    //   fn self_and_in_out_2<'t>(&self, x: &'t u8) -> &'t u8
+    //                            ^^^^^
+    fn self_and_in_out_2<'t>(&self, x: &'t u8) -> &'t u8 {
+        x
+    }
+
+    fn distinct_self_and_in(&self, _x: &u8) {}
+
+    // No error; same lifetimes on two params.
+    fn self_and_same_in<'s>(&'s self, _x: &'s u8) {}
+}
+
+struct Foo<'a>(&'a u8);
+
+impl<'a> Foo<'a> {
+    // No error; lifetime `'a` not defined in method.
+    fn self_shared_lifetime(&self, _: &'a u8) {}
+    // No error; bounds exist.
+    fn self_bound_lifetime<'b: 'a>(&self, _: &'b u8) {}
+}
+
+fn already_elided<'a>(_: &u8, _: &'a u8) -> &'a u8 {
+    unimplemented!()
+}
+
+fn struct_with_lt(_foo: Foo<'_>) -> &str {
+    unimplemented!()
+}
+
+// No warning; two input lifetimes (named on the reference, anonymous on `Foo`).
+fn struct_with_lt2<'a>(_foo: &'a Foo) -> &'a str {
+    unimplemented!()
+}
+
+// No warning; two input lifetimes (anonymous on the reference, named on `Foo`).
+fn struct_with_lt3<'a>(_foo: &Foo<'a>) -> &'a str {
+    unimplemented!()
+}
+
+// Warning; two input lifetimes, but the output lifetime is not elided, i.e., the following is
+// valid:
+//   fn struct_with_lt4a<'a>(_foo: &'a Foo<'_>) -> &'a str
+//                                         ^^
+fn struct_with_lt4a<'a>(_foo: &'a Foo<'_>) -> &'a str {
+    unimplemented!()
+}
+
+// Warning; two input lifetimes, but the output lifetime is not elided, i.e., the following is
+// valid:
+//   fn struct_with_lt4b<'b>(_foo: &Foo<'b>) -> &'b str
+//                                 ^^^^
+fn struct_with_lt4b<'b>(_foo: &Foo<'b>) -> &'b str {
+    unimplemented!()
+}
+
+trait WithLifetime<'a> {}
+
+type WithLifetimeAlias<'a> = dyn WithLifetime<'a>;
+
+// Should not warn because it won't build without the lifetime.
+fn trait_obj_elided<'a>(_arg: &'a dyn WithLifetime) -> &'a str {
+    unimplemented!()
+}
+
+// Should warn because there is no lifetime on `Drop`, so this would be
+// unambiguous if we elided the lifetime.
+fn trait_obj_elided2(_arg: &dyn Drop) -> &str {
+    unimplemented!()
+}
+
+type FooAlias<'a> = Foo<'a>;
+
+fn alias_with_lt(_foo: FooAlias<'_>) -> &str {
+    unimplemented!()
+}
+
+// No warning; two input lifetimes (named on the reference, anonymous on `FooAlias`).
+fn alias_with_lt2<'a>(_foo: &'a FooAlias) -> &'a str {
+    unimplemented!()
+}
+
+// No warning; two input lifetimes (anonymous on the reference, named on `FooAlias`).
+fn alias_with_lt3<'a>(_foo: &FooAlias<'a>) -> &'a str {
+    unimplemented!()
+}
+
+// Warning; two input lifetimes, but the output lifetime is not elided, i.e., the following is
+// valid:
+//   fn alias_with_lt4a<'a>(_foo: &'a FooAlias<'_>) -> &'a str
+//                                             ^^
+fn alias_with_lt4a<'a>(_foo: &'a FooAlias<'_>) -> &'a str {
+    unimplemented!()
+}
+
+// Warning; two input lifetimes, but the output lifetime is not elided, i.e., the following is
+// valid:
+//   fn alias_with_lt4b<'b>(_foo: &FooAlias<'b>) -> &'b str
+//                                ^^^^^^^^^
+fn alias_with_lt4b<'b>(_foo: &FooAlias<'b>) -> &'b str {
+    unimplemented!()
+}
+
+fn named_input_elided_output(_arg: &str) -> &str {
+    unimplemented!()
+}
+
+fn elided_input_named_output<'a>(_arg: &str) -> &'a str {
+    unimplemented!()
+}
+
+fn trait_bound_ok<T: WithLifetime<'static>>(_: &u8, _: T) {
+    unimplemented!()
+}
+fn trait_bound<'a, T: WithLifetime<'a>>(_: &'a u8, _: T) {
+    unimplemented!()
+}
+
+// Don't warn on these; see issue #292.
+fn trait_bound_bug<'a, T: WithLifetime<'a>>() {
+    unimplemented!()
+}
+
+// See issue #740.
+struct Test {
+    vec: Vec<usize>,
+}
+
+impl Test {
+    fn iter<'a>(&'a self) -> Box<dyn Iterator<Item = usize> + 'a> {
+        unimplemented!()
+    }
+}
+
+trait LintContext<'a> {}
+
+fn f<'a, T: LintContext<'a>>(_: &T) {}
+
+fn test<'a>(x: &'a [u8]) -> u8 {
+    let y: &'a u8 = &x[5];
+    *y
+}
+
+// Issue #3284: give hint regarding lifetime in return type.
+struct Cow<'a> {
+    x: &'a str,
+}
+fn out_return_type_lts(e: &str) -> Cow<'_> {
+    unimplemented!()
+}
+
+// Make sure we still warn on implementations
+mod issue4291 {
+    trait BadTrait {
+        fn needless_lt(x: &u8) {}
+    }
+
+    impl BadTrait for () {
+        fn needless_lt(_x: &u8) {}
+    }
+}
+
+mod issue2944 {
+    trait Foo {}
+    struct Bar;
+    struct Baz<'a> {
+        bar: &'a Bar,
+    }
+
+    impl<'a> Foo for Baz<'a> {}
+    impl Bar {
+        fn baz(&self) -> impl Foo + '_ {
+            Baz { bar: self }
+        }
+    }
+}
+
+mod nested_elision_sites {
+    // issue #issue2944
+
+    // closure trait bounds subject to nested elision
+    // don't lint because they refer to outer lifetimes
+    fn trait_fn<'a>(i: &'a i32) -> impl Fn() -> &'a i32 {
+        move || i
+    }
+    fn trait_fn_mut<'a>(i: &'a i32) -> impl FnMut() -> &'a i32 {
+        move || i
+    }
+    fn trait_fn_once<'a>(i: &'a i32) -> impl FnOnce() -> &'a i32 {
+        move || i
+    }
+
+    // don't lint
+    fn impl_trait_in_input_position<'a>(f: impl Fn() -> &'a i32) -> &'a i32 {
+        f()
+    }
+    fn impl_trait_in_output_position<'a>(i: &'a i32) -> impl Fn() -> &'a i32 {
+        move || i
+    }
+    // lint
+    fn impl_trait_elidable_nested_named_lifetimes<'a>(i: &'a i32, f: impl for<'b> Fn(&'b i32) -> &'b i32) -> &'a i32 {
+        f(i)
+    }
+    fn impl_trait_elidable_nested_anonymous_lifetimes(i: &i32, f: impl Fn(&i32) -> &i32) -> &i32 {
+        f(i)
+    }
+
+    // don't lint
+    fn generics_not_elidable<'a, T: Fn() -> &'a i32>(f: T) -> &'a i32 {
+        f()
+    }
+    // lint
+    fn generics_elidable<T: Fn(&i32) -> &i32>(i: &i32, f: T) -> &i32 {
+        f(i)
+    }
+
+    // don't lint
+    fn where_clause_not_elidable<'a, T>(f: T) -> &'a i32
+    where
+        T: Fn() -> &'a i32,
+    {
+        f()
+    }
+    // lint
+    fn where_clause_elidadable<T>(i: &i32, f: T) -> &i32
+    where
+        T: Fn(&i32) -> &i32,
+    {
+        f(i)
+    }
+
+    // don't lint
+    fn pointer_fn_in_input_position<'a>(f: fn(&'a i32) -> &'a i32, i: &'a i32) -> &'a i32 {
+        f(i)
+    }
+    fn pointer_fn_in_output_position<'a>(_: &'a i32) -> fn(&'a i32) -> &'a i32 {
+        |i| i
+    }
+    // lint
+    fn pointer_fn_elidable(i: &i32, f: fn(&i32) -> &i32) -> &i32 {
+        f(i)
+    }
+
+    // don't lint
+    fn nested_fn_pointer_1<'a>(_: &'a i32) -> fn(fn(&'a i32) -> &'a i32) -> i32 {
+        |f| 42
+    }
+    fn nested_fn_pointer_2<'a>(_: &'a i32) -> impl Fn(fn(&'a i32)) {
+        |f| ()
+    }
+
+    // lint
+    fn nested_fn_pointer_3(_: &i32) -> fn(fn(&i32) -> &i32) -> i32 {
+        |f| 42
+    }
+    fn nested_fn_pointer_4(_: &i32) -> impl Fn(fn(&i32)) {
+        |f| ()
+    }
+}
+
+mod issue6159 {
+    use std::ops::Deref;
+    pub fn apply_deref<'a, T, F, R>(x: &'a T, f: F) -> R
+    where
+        T: Deref,
+        F: FnOnce(&'a T::Target) -> R,
+    {
+        f(x.deref())
+    }
+}
+
+mod issue7296 {
+    use std::rc::Rc;
+    use std::sync::Arc;
+
+    struct Foo;
+    impl Foo {
+        fn implicit(&self) -> &() {
+            &()
+        }
+        fn implicit_mut(&mut self) -> &() {
+            &()
+        }
+
+        fn explicit<'a>(self: &'a Arc<Self>) -> &'a () {
+            &()
+        }
+        fn explicit_mut<'a>(self: &'a mut Rc<Self>) -> &'a () {
+            &()
+        }
+
+        fn lifetime_elsewhere(self: Box<Self>, here: &()) -> &() {
+            &()
+        }
+    }
+
+    trait Bar {
+        fn implicit(&self) -> &();
+        fn implicit_provided(&self) -> &() {
+            &()
+        }
+
+        fn explicit<'a>(self: &'a Arc<Self>) -> &'a ();
+        fn explicit_provided<'a>(self: &'a Arc<Self>) -> &'a () {
+            &()
+        }
+
+        fn lifetime_elsewhere(self: Box<Self>, here: &()) -> &();
+        fn lifetime_elsewhere_provided(self: Box<Self>, here: &()) -> &() {
+            &()
+        }
+    }
+}
+
+mod pr_9743_false_negative_fix {
+    #![allow(unused)]
+
+    fn foo(x: &u8, y: &'_ u8) {}
+
+    fn bar(x: &u8, y: &'_ u8, z: &'_ u8) {}
+}
+
+mod pr_9743_output_lifetime_checks {
+    #![allow(unused)]
+
+    // lint: only one input
+    fn one_input(x: &u8) -> &u8 {
+        unimplemented!()
+    }
+
+    // lint: multiple inputs, output would not be elided
+    fn multiple_inputs_output_not_elided<'b>(x: &u8, y: &'b u8, z: &'b u8) -> &'b u8 {
+        unimplemented!()
+    }
+
+    // don't lint: multiple inputs, output would be elided (which would create an ambiguity)
+    fn multiple_inputs_output_would_be_elided<'a, 'b>(x: &'a u8, y: &'b u8, z: &'b u8) -> &'a u8 {
+        unimplemented!()
+    }
+}
+
+mod in_macro {
+    macro_rules! local_one_input_macro {
+        () => {
+            fn one_input(x: &u8) -> &u8 {
+                unimplemented!()
+            }
+        };
+    }
+
+    // lint local macro expands to function with needless lifetimes
+    local_one_input_macro!();
+
+    // no lint on external macro
+    macro_rules::needless_lifetime!();
+}
+
+mod issue5787 {
+    use std::sync::MutexGuard;
+
+    struct Foo;
+
+    impl Foo {
+        // doesn't get linted without async
+        pub async fn wait<'a, T>(&self, guard: MutexGuard<'a, T>) -> MutexGuard<'a, T> {
+            guard
+        }
+    }
+
+    async fn foo<'a>(_x: &i32, y: &'a str) -> &'a str {
+        y
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/needless_lifetimes.rs b/tests/ui/needless_lifetimes.rs
index 78493c6d067..5d4dc971b8d 100644
--- a/tests/ui/needless_lifetimes.rs
+++ b/tests/ui/needless_lifetimes.rs
@@ -1,7 +1,9 @@
+// run-rustfix
 // aux-build:macro_rules.rs
+
 #![warn(clippy::needless_lifetimes)]
 #![allow(
-    dead_code,
+    unused,
     clippy::boxed_local,
     clippy::needless_pass_by_value,
     clippy::unnecessary_wraps,
@@ -515,4 +517,21 @@ mod in_macro {
     macro_rules::needless_lifetime!();
 }
 
+mod issue5787 {
+    use std::sync::MutexGuard;
+
+    struct Foo;
+
+    impl Foo {
+        // doesn't get linted without async
+        pub async fn wait<'a, T>(&self, guard: MutexGuard<'a, T>) -> MutexGuard<'a, T> {
+            guard
+        }
+    }
+
+    async fn foo<'a>(_x: &i32, y: &'a str) -> &'a str {
+        y
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/needless_lifetimes.stderr b/tests/ui/needless_lifetimes.stderr
index 9d02626956e..afe637ac388 100644
--- a/tests/ui/needless_lifetimes.stderr
+++ b/tests/ui/needless_lifetimes.stderr
@@ -1,319 +1,546 @@
 error: the following explicit lifetimes could be elided: 'a, 'b
-  --> $DIR/needless_lifetimes.rs:15:1
+  --> $DIR/needless_lifetimes.rs:17:1
    |
 LL | fn distinct_lifetimes<'a, 'b>(_x: &'a u8, _y: &'b u8, _z: u8) {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::needless-lifetimes` implied by `-D warnings`
+help: elide the lifetimes
+   |
+LL - fn distinct_lifetimes<'a, 'b>(_x: &'a u8, _y: &'b u8, _z: u8) {}
+LL + fn distinct_lifetimes(_x: &u8, _y: &u8, _z: u8) {}
+   |
 
 error: the following explicit lifetimes could be elided: 'a, 'b
-  --> $DIR/needless_lifetimes.rs:17:1
+  --> $DIR/needless_lifetimes.rs:19:1
    |
 LL | fn distinct_and_static<'a, 'b>(_x: &'a u8, _y: &'b u8, _z: &'static u8) {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: elide the lifetimes
+   |
+LL - fn distinct_and_static<'a, 'b>(_x: &'a u8, _y: &'b u8, _z: &'static u8) {}
+LL + fn distinct_and_static(_x: &u8, _y: &u8, _z: &'static u8) {}
+   |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:27:1
+  --> $DIR/needless_lifetimes.rs:29:1
    |
 LL | fn in_and_out<'a>(x: &'a u8, _y: u8) -> &'a u8 {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: elide the lifetimes
+   |
+LL - fn in_and_out<'a>(x: &'a u8, _y: u8) -> &'a u8 {
+LL + fn in_and_out(x: &u8, _y: u8) -> &u8 {
+   |
 
 error: the following explicit lifetimes could be elided: 'b
-  --> $DIR/needless_lifetimes.rs:39:1
+  --> $DIR/needless_lifetimes.rs:41:1
    |
 LL | fn multiple_in_and_out_2a<'a, 'b>(x: &'a u8, _y: &'b u8) -> &'a u8 {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: elide the lifetimes
+   |
+LL - fn multiple_in_and_out_2a<'a, 'b>(x: &'a u8, _y: &'b u8) -> &'a u8 {
+LL + fn multiple_in_and_out_2a<'a>(x: &'a u8, _y: &u8) -> &'a u8 {
+   |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:46:1
+  --> $DIR/needless_lifetimes.rs:48:1
    |
 LL | fn multiple_in_and_out_2b<'a, 'b>(_x: &'a u8, y: &'b u8) -> &'b u8 {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: elide the lifetimes
+   |
+LL - fn multiple_in_and_out_2b<'a, 'b>(_x: &'a u8, y: &'b u8) -> &'b u8 {
+LL + fn multiple_in_and_out_2b<'b>(_x: &u8, y: &'b u8) -> &'b u8 {
+   |
 
 error: the following explicit lifetimes could be elided: 'b
-  --> $DIR/needless_lifetimes.rs:63:1
+  --> $DIR/needless_lifetimes.rs:65:1
    |
 LL | fn deep_reference_1a<'a, 'b>(x: &'a u8, _y: &'b u8) -> Result<&'a u8, ()> {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: elide the lifetimes
+   |
+LL - fn deep_reference_1a<'a, 'b>(x: &'a u8, _y: &'b u8) -> Result<&'a u8, ()> {
+LL + fn deep_reference_1a<'a>(x: &'a u8, _y: &u8) -> Result<&'a u8, ()> {
+   |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:70:1
+  --> $DIR/needless_lifetimes.rs:72:1
    |
 LL | fn deep_reference_1b<'a, 'b>(_x: &'a u8, y: &'b u8) -> Result<&'b u8, ()> {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: elide the lifetimes
+   |
+LL - fn deep_reference_1b<'a, 'b>(_x: &'a u8, y: &'b u8) -> Result<&'b u8, ()> {
+LL + fn deep_reference_1b<'b>(_x: &u8, y: &'b u8) -> Result<&'b u8, ()> {
+   |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:79:1
+  --> $DIR/needless_lifetimes.rs:81:1
    |
 LL | fn deep_reference_3<'a>(x: &'a u8, _y: u8) -> Result<&'a u8, ()> {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: elide the lifetimes
+   |
+LL - fn deep_reference_3<'a>(x: &'a u8, _y: u8) -> Result<&'a u8, ()> {
+LL + fn deep_reference_3(x: &u8, _y: u8) -> Result<&u8, ()> {
+   |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:84:1
+  --> $DIR/needless_lifetimes.rs:86:1
    |
 LL | fn where_clause_without_lt<'a, T>(x: &'a u8, _y: u8) -> Result<&'a u8, ()>
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: elide the lifetimes
+   |
+LL - fn where_clause_without_lt<'a, T>(x: &'a u8, _y: u8) -> Result<&'a u8, ()>
+LL + fn where_clause_without_lt<T>(x: &u8, _y: u8) -> Result<&u8, ()>
+   |
 
 error: the following explicit lifetimes could be elided: 'a, 'b
-  --> $DIR/needless_lifetimes.rs:96:1
+  --> $DIR/needless_lifetimes.rs:98:1
    |
 LL | fn lifetime_param_2<'a, 'b>(_x: Ref<'a>, _y: &'b u8) {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-help: replace with `'_` in generic arguments such as here
-  --> $DIR/needless_lifetimes.rs:96:37
+help: elide the lifetimes
+   |
+LL - fn lifetime_param_2<'a, 'b>(_x: Ref<'a>, _y: &'b u8) {}
+LL + fn lifetime_param_2(_x: Ref<'_>, _y: &u8) {}
    |
-LL | fn lifetime_param_2<'a, 'b>(_x: Ref<'a>, _y: &'b u8) {}
-   |                                     ^^
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:120:1
+  --> $DIR/needless_lifetimes.rs:122:1
    |
 LL | fn fn_bound_2<'a, F, I>(_m: Lt<'a, I>, _f: F) -> Lt<'a, I>
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-help: replace with `'_` in generic arguments such as here
-  --> $DIR/needless_lifetimes.rs:120:32
+help: elide the lifetimes
+   |
+LL - fn fn_bound_2<'a, F, I>(_m: Lt<'a, I>, _f: F) -> Lt<'a, I>
+LL + fn fn_bound_2<F, I>(_m: Lt<'_, I>, _f: F) -> Lt<'_, I>
    |
-LL | fn fn_bound_2<'a, F, I>(_m: Lt<'a, I>, _f: F) -> Lt<'a, I>
-   |                                ^^
 
 error: the following explicit lifetimes could be elided: 's
-  --> $DIR/needless_lifetimes.rs:150:5
+  --> $DIR/needless_lifetimes.rs:152:5
    |
 LL |     fn self_and_out<'s>(&'s self) -> &'s u8 {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: elide the lifetimes
+   |
+LL -     fn self_and_out<'s>(&'s self) -> &'s u8 {
+LL +     fn self_and_out(&self) -> &u8 {
+   |
 
 error: the following explicit lifetimes could be elided: 't
-  --> $DIR/needless_lifetimes.rs:157:5
+  --> $DIR/needless_lifetimes.rs:159:5
    |
 LL |     fn self_and_in_out_1<'s, 't>(&'s self, _x: &'t u8) -> &'s u8 {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: elide the lifetimes
+   |
+LL -     fn self_and_in_out_1<'s, 't>(&'s self, _x: &'t u8) -> &'s u8 {
+LL +     fn self_and_in_out_1<'s>(&'s self, _x: &u8) -> &'s u8 {
+   |
 
 error: the following explicit lifetimes could be elided: 's
-  --> $DIR/needless_lifetimes.rs:164:5
+  --> $DIR/needless_lifetimes.rs:166:5
    |
 LL |     fn self_and_in_out_2<'s, 't>(&'s self, x: &'t u8) -> &'t u8 {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: elide the lifetimes
+   |
+LL -     fn self_and_in_out_2<'s, 't>(&'s self, x: &'t u8) -> &'t u8 {
+LL +     fn self_and_in_out_2<'t>(&self, x: &'t u8) -> &'t u8 {
+   |
 
 error: the following explicit lifetimes could be elided: 's, 't
-  --> $DIR/needless_lifetimes.rs:168:5
+  --> $DIR/needless_lifetimes.rs:170:5
    |
 LL |     fn distinct_self_and_in<'s, 't>(&'s self, _x: &'t u8) {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: elide the lifetimes
+   |
+LL -     fn distinct_self_and_in<'s, 't>(&'s self, _x: &'t u8) {}
+LL +     fn distinct_self_and_in(&self, _x: &u8) {}
+   |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:187:1
+  --> $DIR/needless_lifetimes.rs:189:1
    |
 LL | fn struct_with_lt<'a>(_foo: Foo<'a>) -> &'a str {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-help: replace with `'_` in generic arguments such as here
-  --> $DIR/needless_lifetimes.rs:187:33
+help: elide the lifetimes
+   |
+LL - fn struct_with_lt<'a>(_foo: Foo<'a>) -> &'a str {
+LL + fn struct_with_lt(_foo: Foo<'_>) -> &str {
    |
-LL | fn struct_with_lt<'a>(_foo: Foo<'a>) -> &'a str {
-   |                                 ^^
 
 error: the following explicit lifetimes could be elided: 'b
-  --> $DIR/needless_lifetimes.rs:205:1
+  --> $DIR/needless_lifetimes.rs:207:1
    |
 LL | fn struct_with_lt4a<'a, 'b>(_foo: &'a Foo<'b>) -> &'a str {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-help: replace with `'_` in generic arguments such as here
-  --> $DIR/needless_lifetimes.rs:205:43
+help: elide the lifetimes
+   |
+LL - fn struct_with_lt4a<'a, 'b>(_foo: &'a Foo<'b>) -> &'a str {
+LL + fn struct_with_lt4a<'a>(_foo: &'a Foo<'_>) -> &'a str {
    |
-LL | fn struct_with_lt4a<'a, 'b>(_foo: &'a Foo<'b>) -> &'a str {
-   |                                           ^^
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:213:1
+  --> $DIR/needless_lifetimes.rs:215:1
    |
 LL | fn struct_with_lt4b<'a, 'b>(_foo: &'a Foo<'b>) -> &'b str {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: elide the lifetimes
+   |
+LL - fn struct_with_lt4b<'a, 'b>(_foo: &'a Foo<'b>) -> &'b str {
+LL + fn struct_with_lt4b<'b>(_foo: &Foo<'b>) -> &'b str {
+   |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:228:1
+  --> $DIR/needless_lifetimes.rs:230:1
    |
 LL | fn trait_obj_elided2<'a>(_arg: &'a dyn Drop) -> &'a str {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: elide the lifetimes
+   |
+LL - fn trait_obj_elided2<'a>(_arg: &'a dyn Drop) -> &'a str {
+LL + fn trait_obj_elided2(_arg: &dyn Drop) -> &str {
+   |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:234:1
+  --> $DIR/needless_lifetimes.rs:236:1
    |
 LL | fn alias_with_lt<'a>(_foo: FooAlias<'a>) -> &'a str {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-help: replace with `'_` in generic arguments such as here
-  --> $DIR/needless_lifetimes.rs:234:37
+help: elide the lifetimes
+   |
+LL - fn alias_with_lt<'a>(_foo: FooAlias<'a>) -> &'a str {
+LL + fn alias_with_lt(_foo: FooAlias<'_>) -> &str {
    |
-LL | fn alias_with_lt<'a>(_foo: FooAlias<'a>) -> &'a str {
-   |                                     ^^
 
 error: the following explicit lifetimes could be elided: 'b
-  --> $DIR/needless_lifetimes.rs:252:1
+  --> $DIR/needless_lifetimes.rs:254:1
    |
 LL | fn alias_with_lt4a<'a, 'b>(_foo: &'a FooAlias<'b>) -> &'a str {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-help: replace with `'_` in generic arguments such as here
-  --> $DIR/needless_lifetimes.rs:252:47
+help: elide the lifetimes
+   |
+LL - fn alias_with_lt4a<'a, 'b>(_foo: &'a FooAlias<'b>) -> &'a str {
+LL + fn alias_with_lt4a<'a>(_foo: &'a FooAlias<'_>) -> &'a str {
    |
-LL | fn alias_with_lt4a<'a, 'b>(_foo: &'a FooAlias<'b>) -> &'a str {
-   |                                               ^^
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:260:1
+  --> $DIR/needless_lifetimes.rs:262:1
    |
 LL | fn alias_with_lt4b<'a, 'b>(_foo: &'a FooAlias<'b>) -> &'b str {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: elide the lifetimes
+   |
+LL - fn alias_with_lt4b<'a, 'b>(_foo: &'a FooAlias<'b>) -> &'b str {
+LL + fn alias_with_lt4b<'b>(_foo: &FooAlias<'b>) -> &'b str {
+   |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:264:1
+  --> $DIR/needless_lifetimes.rs:266:1
    |
 LL | fn named_input_elided_output<'a>(_arg: &'a str) -> &str {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: elide the lifetimes
+   |
+LL - fn named_input_elided_output<'a>(_arg: &'a str) -> &str {
+LL + fn named_input_elided_output(_arg: &str) -> &str {
+   |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:272:1
+  --> $DIR/needless_lifetimes.rs:274:1
    |
 LL | fn trait_bound_ok<'a, T: WithLifetime<'static>>(_: &'a u8, _: T) {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: elide the lifetimes
+   |
+LL - fn trait_bound_ok<'a, T: WithLifetime<'static>>(_: &'a u8, _: T) {
+LL + fn trait_bound_ok<T: WithLifetime<'static>>(_: &u8, _: T) {
+   |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:308:1
+  --> $DIR/needless_lifetimes.rs:310:1
    |
 LL | fn out_return_type_lts<'a>(e: &'a str) -> Cow<'a> {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-help: replace with `'_` in generic arguments such as here
-  --> $DIR/needless_lifetimes.rs:308:47
+help: elide the lifetimes
+   |
+LL - fn out_return_type_lts<'a>(e: &'a str) -> Cow<'a> {
+LL + fn out_return_type_lts(e: &str) -> Cow<'_> {
    |
-LL | fn out_return_type_lts<'a>(e: &'a str) -> Cow<'a> {
-   |                                               ^^
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:315:9
+  --> $DIR/needless_lifetimes.rs:317:9
    |
 LL |         fn needless_lt<'a>(x: &'a u8) {}
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: elide the lifetimes
+   |
+LL -         fn needless_lt<'a>(x: &'a u8) {}
+LL +         fn needless_lt(x: &u8) {}
+   |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:319:9
+  --> $DIR/needless_lifetimes.rs:321:9
    |
 LL |         fn needless_lt<'a>(_x: &'a u8) {}
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: elide the lifetimes
+   |
+LL -         fn needless_lt<'a>(_x: &'a u8) {}
+LL +         fn needless_lt(_x: &u8) {}
+   |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:332:9
+  --> $DIR/needless_lifetimes.rs:334:9
    |
 LL |         fn baz<'a>(&'a self) -> impl Foo + 'a {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: elide the lifetimes
+   |
+LL -         fn baz<'a>(&'a self) -> impl Foo + 'a {
+LL +         fn baz(&self) -> impl Foo + '_ {
+   |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:364:5
+  --> $DIR/needless_lifetimes.rs:366:5
    |
 LL |     fn impl_trait_elidable_nested_anonymous_lifetimes<'a>(i: &'a i32, f: impl Fn(&i32) -> &i32) -> &'a i32 {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: elide the lifetimes
+   |
+LL -     fn impl_trait_elidable_nested_anonymous_lifetimes<'a>(i: &'a i32, f: impl Fn(&i32) -> &i32) -> &'a i32 {
+LL +     fn impl_trait_elidable_nested_anonymous_lifetimes(i: &i32, f: impl Fn(&i32) -> &i32) -> &i32 {
+   |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:373:5
+  --> $DIR/needless_lifetimes.rs:375:5
    |
 LL |     fn generics_elidable<'a, T: Fn(&i32) -> &i32>(i: &'a i32, f: T) -> &'a i32 {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: elide the lifetimes
+   |
+LL -     fn generics_elidable<'a, T: Fn(&i32) -> &i32>(i: &'a i32, f: T) -> &'a i32 {
+LL +     fn generics_elidable<T: Fn(&i32) -> &i32>(i: &i32, f: T) -> &i32 {
+   |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:385:5
+  --> $DIR/needless_lifetimes.rs:387:5
    |
 LL |     fn where_clause_elidadable<'a, T>(i: &'a i32, f: T) -> &'a i32
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: elide the lifetimes
+   |
+LL -     fn where_clause_elidadable<'a, T>(i: &'a i32, f: T) -> &'a i32
+LL +     fn where_clause_elidadable<T>(i: &i32, f: T) -> &i32
+   |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:400:5
+  --> $DIR/needless_lifetimes.rs:402:5
    |
 LL |     fn pointer_fn_elidable<'a>(i: &'a i32, f: fn(&i32) -> &i32) -> &'a i32 {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: elide the lifetimes
+   |
+LL -     fn pointer_fn_elidable<'a>(i: &'a i32, f: fn(&i32) -> &i32) -> &'a i32 {
+LL +     fn pointer_fn_elidable(i: &i32, f: fn(&i32) -> &i32) -> &i32 {
+   |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:413:5
+  --> $DIR/needless_lifetimes.rs:415:5
    |
 LL |     fn nested_fn_pointer_3<'a>(_: &'a i32) -> fn(fn(&i32) -> &i32) -> i32 {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: elide the lifetimes
+   |
+LL -     fn nested_fn_pointer_3<'a>(_: &'a i32) -> fn(fn(&i32) -> &i32) -> i32 {
+LL +     fn nested_fn_pointer_3(_: &i32) -> fn(fn(&i32) -> &i32) -> i32 {
+   |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:416:5
+  --> $DIR/needless_lifetimes.rs:418:5
    |
 LL |     fn nested_fn_pointer_4<'a>(_: &'a i32) -> impl Fn(fn(&i32)) {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: elide the lifetimes
+   |
+LL -     fn nested_fn_pointer_4<'a>(_: &'a i32) -> impl Fn(fn(&i32)) {
+LL +     fn nested_fn_pointer_4(_: &i32) -> impl Fn(fn(&i32)) {
+   |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:438:9
+  --> $DIR/needless_lifetimes.rs:440:9
    |
 LL |         fn implicit<'a>(&'a self) -> &'a () {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: elide the lifetimes
+   |
+LL -         fn implicit<'a>(&'a self) -> &'a () {
+LL +         fn implicit(&self) -> &() {
+   |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:441:9
+  --> $DIR/needless_lifetimes.rs:443:9
    |
 LL |         fn implicit_mut<'a>(&'a mut self) -> &'a () {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: elide the lifetimes
+   |
+LL -         fn implicit_mut<'a>(&'a mut self) -> &'a () {
+LL +         fn implicit_mut(&mut self) -> &() {
+   |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:452:9
+  --> $DIR/needless_lifetimes.rs:454:9
    |
 LL |         fn lifetime_elsewhere<'a>(self: Box<Self>, here: &'a ()) -> &'a () {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: elide the lifetimes
+   |
+LL -         fn lifetime_elsewhere<'a>(self: Box<Self>, here: &'a ()) -> &'a () {
+LL +         fn lifetime_elsewhere(self: Box<Self>, here: &()) -> &() {
+   |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:458:9
+  --> $DIR/needless_lifetimes.rs:460:9
    |
 LL |         fn implicit<'a>(&'a self) -> &'a ();
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: elide the lifetimes
+   |
+LL -         fn implicit<'a>(&'a self) -> &'a ();
+LL +         fn implicit(&self) -> &();
+   |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:459:9
+  --> $DIR/needless_lifetimes.rs:461:9
    |
 LL |         fn implicit_provided<'a>(&'a self) -> &'a () {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: elide the lifetimes
+   |
+LL -         fn implicit_provided<'a>(&'a self) -> &'a () {
+LL +         fn implicit_provided(&self) -> &() {
+   |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:468:9
+  --> $DIR/needless_lifetimes.rs:470:9
    |
 LL |         fn lifetime_elsewhere<'a>(self: Box<Self>, here: &'a ()) -> &'a ();
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: elide the lifetimes
+   |
+LL -         fn lifetime_elsewhere<'a>(self: Box<Self>, here: &'a ()) -> &'a ();
+LL +         fn lifetime_elsewhere(self: Box<Self>, here: &()) -> &();
+   |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:469:9
+  --> $DIR/needless_lifetimes.rs:471:9
    |
 LL |         fn lifetime_elsewhere_provided<'a>(self: Box<Self>, here: &'a ()) -> &'a () {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: elide the lifetimes
+   |
+LL -         fn lifetime_elsewhere_provided<'a>(self: Box<Self>, here: &'a ()) -> &'a () {
+LL +         fn lifetime_elsewhere_provided(self: Box<Self>, here: &()) -> &() {
+   |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:478:5
+  --> $DIR/needless_lifetimes.rs:480:5
    |
 LL |     fn foo<'a>(x: &'a u8, y: &'_ u8) {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: elide the lifetimes
+   |
+LL -     fn foo<'a>(x: &'a u8, y: &'_ u8) {}
+LL +     fn foo(x: &u8, y: &'_ u8) {}
+   |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:480:5
+  --> $DIR/needless_lifetimes.rs:482:5
    |
 LL |     fn bar<'a>(x: &'a u8, y: &'_ u8, z: &'_ u8) {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: elide the lifetimes
+   |
+LL -     fn bar<'a>(x: &'a u8, y: &'_ u8, z: &'_ u8) {}
+LL +     fn bar(x: &u8, y: &'_ u8, z: &'_ u8) {}
+   |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:487:5
+  --> $DIR/needless_lifetimes.rs:489:5
    |
 LL |     fn one_input<'a>(x: &'a u8) -> &'a u8 {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: elide the lifetimes
+   |
+LL -     fn one_input<'a>(x: &'a u8) -> &'a u8 {
+LL +     fn one_input(x: &u8) -> &u8 {
+   |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:492:5
+  --> $DIR/needless_lifetimes.rs:494:5
    |
 LL |     fn multiple_inputs_output_not_elided<'a, 'b>(x: &'a u8, y: &'b u8, z: &'b u8) -> &'b u8 {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: elide the lifetimes
+   |
+LL -     fn multiple_inputs_output_not_elided<'a, 'b>(x: &'a u8, y: &'b u8, z: &'b u8) -> &'b u8 {
+LL +     fn multiple_inputs_output_not_elided<'b>(x: &u8, y: &'b u8, z: &'b u8) -> &'b u8 {
+   |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:505:13
+  --> $DIR/needless_lifetimes.rs:507:13
    |
 LL |             fn one_input<'a>(x: &'a u8) -> &'a u8 {
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -322,6 +549,11 @@ LL |     local_one_input_macro!();
    |     ------------------------ in this macro invocation
    |
    = note: this error originates in the macro `local_one_input_macro` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: elide the lifetimes
+   |
+LL -             fn one_input<'a>(x: &'a u8) -> &'a u8 {
+LL +             fn one_input(x: &u8) -> &u8 {
+   |
 
 error: aborting due to 46 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From a408e76098acc353d18ae43b0f02485954d80d5d Mon Sep 17 00:00:00 2001
From: koka <koka.code@gmail.com>
Date: Wed, 1 Feb 2023 19:17:39 +0900
Subject: Suggest the correct variable name for `manual_let_else`

---
 clippy_lints/src/manual_let_else.rs   | 59 ++++++++++++++++++++---------------
 tests/ui/manual_let_else.stderr       | 32 +++++++++----------
 tests/ui/manual_let_else_match.stderr |  4 +--
 3 files changed, 52 insertions(+), 43 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_let_else.rs b/clippy_lints/src/manual_let_else.rs
index 9c6f8b43c07..4d53a664fa0 100644
--- a/clippy_lints/src/manual_let_else.rs
+++ b/clippy_lints/src/manual_let_else.rs
@@ -68,29 +68,21 @@ 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) &&
+            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) => {
@@ -120,15 +112,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,
@@ -137,12 +137,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);
 
@@ -151,10 +150,20 @@ 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})")
+                },
+                PatKind::TupleStruct(ref w, ..) => {
+                    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.stderr b/tests/ui/manual_let_else.stderr
index 52aac6bc673..fe45cfd25b6 100644
--- a/tests/ui/manual_let_else.stderr
+++ b/tests/ui/manual_let_else.stderr
@@ -2,7 +2,7 @@ error: this could be rewritten as `let...else`
   --> $DIR/manual_let_else.rs:18: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`
 
@@ -18,7 +18,7 @@ LL | |     };
    |
 help: consider writing
    |
-LL ~     let Some(v_some) = g() else {
+LL ~     let Some(v) = g() else {
 LL +         return;
 LL +     };
    |
@@ -48,19 +48,19 @@ error: this could be rewritten as `let...else`
   --> $DIR/manual_let_else.rs:38: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
    |
 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
    |
 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
@@ -74,7 +74,7 @@ LL | |     };
    |
 help: consider writing
    |
-LL ~     let Some(v_some) = g() else {
+LL ~     let Some(v) = g() else {
 LL +         std::process::abort()
 LL +     };
    |
@@ -91,7 +91,7 @@ LL | |     };
    |
 help: consider writing
    |
-LL ~     let Some(v_some) = g() else {
+LL ~     let Some(v) = g() else {
 LL +         if true { return } else { panic!() }
 LL +     };
    |
@@ -109,7 +109,7 @@ LL | |     };
    |
 help: consider writing
    |
-LL ~     let Some(v_some) = g() else {
+LL ~     let Some(v) = g() else {
 LL +         if true {}
 LL +         panic!();
 LL +     };
@@ -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!(),
@@ -141,7 +141,7 @@ error: this could be rewritten as `let...else`
   --> $DIR/manual_let_else.rs:80: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
@@ -157,7 +157,7 @@ LL | |     };
    |
 help: consider writing
    |
-LL ~     let Some(v_some) = g() else {
+LL ~     let Some(v) = g() else {
 LL +         match panic!() {
 LL +             _ => {},
 LL +         }
@@ -178,7 +178,7 @@ 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");
@@ -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(_)) => {
@@ -226,7 +226,7 @@ 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 +     };
    |
@@ -252,7 +252,7 @@ error: this could be rewritten as `let...else`
   --> $DIR/manual_let_else.rs:134: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
@@ -266,7 +266,7 @@ 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
 
diff --git a/tests/ui/manual_let_else_match.stderr b/tests/ui/manual_let_else_match.stderr
index cd5e9a9ac39..867e459830d 100644
--- a/tests/ui/manual_let_else_match.stderr
+++ b/tests/ui/manual_let_else_match.stderr
@@ -5,7 +5,7 @@ LL | /     let v = match g() {
 LL | |         Some(v_some) => v_some,
 LL | |         None => return,
 LL | |     };
-   | |______^ 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`
 
@@ -16,7 +16,7 @@ LL | /     let v = match g() {
 LL | |         Some(v_some) => v_some,
 LL | |         _ => return,
 LL | |     };
-   | |______^ help: consider writing: `let Some(v_some) = g() else { return };`
+   | |______^ help: consider writing: `let Some(v) = g() else { return };`
 
 error: this could be rewritten as `let...else`
   --> $DIR/manual_let_else_match.rs:44:9
-- 
cgit 1.4.1-3-g733a5


From 4931f4549bb8622f3588ba835f8eb2201e687059 Mon Sep 17 00:00:00 2001
From: koka <koka.code@gmail.com>
Date: Wed, 1 Feb 2023 19:29:31 +0900
Subject: Split if conditions by its semantics

---
 clippy_lints/src/manual_let_else.rs | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_let_else.rs b/clippy_lints/src/manual_let_else.rs
index 4d53a664fa0..e461e538b5a 100644
--- a/clippy_lints/src/manual_let_else.rs
+++ b/clippy_lints/src/manual_let_else.rs
@@ -68,9 +68,11 @@ impl_lint_pass!(ManualLetElse => [MANUAL_LET_ELSE]);
 
 impl<'tcx> LateLintPass<'tcx> for ManualLetElse {
     fn check_stmt(&mut self, cx: &LateContext<'_>, stmt: &'tcx Stmt<'tcx>) {
-        if self.msrv.meets(msrvs::LET_ELSE) &&
-            !in_external_macro(cx.sess(), stmt.span) &&
-            let StmtKind::Local(local) = stmt.kind &&
+        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() &&
-- 
cgit 1.4.1-3-g733a5


From 20338fd378fb6ee937ee1171c2752c57ba385ab4 Mon Sep 17 00:00:00 2001
From: koka <koka.code@gmail.com>
Date: Wed, 1 Feb 2023 19:30:21 +0900
Subject: Remove old feature flag in code comment

Since let_else feature has been stable in 1.65.0, it's now unnecessary
---
 clippy_lints/src/manual_let_else.rs | 1 -
 1 file changed, 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_let_else.rs b/clippy_lints/src/manual_let_else.rs
index e461e538b5a..ccc0e475cb2 100644
--- a/clippy_lints/src/manual_let_else.rs
+++ b/clippy_lints/src/manual_let_else.rs
@@ -37,7 +37,6 @@ declare_clippy_lint! {
     /// Could be written:
     ///
     /// ```rust
-    /// # #![feature(let_else)]
     /// # fn main () {
     /// # let w = Some(0);
     /// let Some(v) = w else { return };
-- 
cgit 1.4.1-3-g733a5


From 07c8c50a41dd4551ca3cb9155976a237eeefc1eb Mon Sep 17 00:00:00 2001
From: koka <koka.code@gmail.com>
Date: Wed, 1 Feb 2023 20:45:26 +0900
Subject: Avoid renaming for TupleStruct with multiple arguments

update spec

fix: move specs in fire
---
 clippy_lints/src/manual_let_else.rs |  3 ++-
 tests/ui/manual_let_else.rs         | 15 +++++++++++
 tests/ui/manual_let_else.stderr     | 50 +++++++++++++++++++++++--------------
 3 files changed, 48 insertions(+), 20 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_let_else.rs b/clippy_lints/src/manual_let_else.rs
index ccc0e475cb2..9554f5d5a77 100644
--- a/clippy_lints/src/manual_let_else.rs
+++ b/clippy_lints/src/manual_let_else.rs
@@ -156,7 +156,8 @@ fn emit_manual_let_else(
                     let (sn_pat, _) = snippet_with_context(cx, pat.span, span.ctxt(), "", &mut app);
                     format!("({sn_pat})")
                 },
-                PatKind::TupleStruct(ref w, ..) => {
+                // 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})")
diff --git a/tests/ui/manual_let_else.rs b/tests/ui/manual_let_else.rs
index 48a162c1360..23f530f41cd 100644
--- 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
index fe45cfd25b6..f6f56f7b00e 100644
--- a/tests/ui/manual_let_else.stderr
+++ b/tests/ui/manual_let_else.stderr
@@ -1,5 +1,5 @@
 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) = g() else { return };`
@@ -7,7 +7,7 @@ LL |     let v = if let Some(v_some) = g() { v_some } 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
@@ -24,7 +24,7 @@ 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) = 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) = 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) = 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
@@ -80,7 +80,7 @@ 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
@@ -97,7 +97,7 @@ 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
@@ -116,7 +116,7 @@ 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
@@ -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) = 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
@@ -165,7 +165,7 @@ 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
@@ -186,7 +186,7 @@ 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
@@ -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
@@ -232,7 +232,7 @@ 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,7 +249,7 @@ 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($n) = g() else { return };`
@@ -260,7 +260,19 @@ LL |     create_binding_if_some!(w, g());
    = 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,
@@ -268,5 +280,5 @@ LL | |         _ => macro_call!(),
 LL | |     };
    | |______^ help: consider writing: `let Some(_) = ff else { macro_call!() };`
 
-error: aborting due to 18 previous errors
+error: aborting due to 20 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From f7d59b2e574888912cf7fb670c742b4636e451d0 Mon Sep 17 00:00:00 2001
From: Mara Bos <m-ou.se@m-ou.se>
Date: Wed, 1 Feb 2023 22:50:43 +0100
Subject: Don't depend on FormatArgsExpn in ManualAssert.

---
 clippy_lints/src/manual_assert.rs | 97 +++++++++++++++++++--------------------
 1 file changed, 48 insertions(+), 49 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_assert.rs b/clippy_lints/src/manual_assert.rs
index 4277455a3a2..ce5d657bcf0 100644
--- a/clippy_lints/src/manual_assert.rs
+++ b/clippy_lints/src/manual_assert.rs
@@ -1,7 +1,6 @@
 use crate::rustc_lint::LintContext;
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::macros::{root_macro_call, FormatArgsExpn};
-use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::macros::root_macro_call;
 use clippy_utils::{is_else_clause, peel_blocks_with_stmt, span_extract_comment, sugg};
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, UnOp};
@@ -38,57 +37,57 @@ declare_lint_pass!(ManualAssert => [MANUAL_ASSERT]);
 
 impl<'tcx> LateLintPass<'tcx> for ManualAssert {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &Expr<'tcx>) {
-        if_chain! {
-            if let ExprKind::If(cond, then, None) = expr.kind;
-            if !matches!(cond.kind, ExprKind::Let(_));
-            if !expr.span.from_expansion();
-            let then = peel_blocks_with_stmt(then);
-            if let Some(macro_call) = root_macro_call(then.span);
-            if cx.tcx.item_name(macro_call.def_id) == sym::panic;
-            if !cx.tcx.sess.source_map().is_multiline(cond.span);
-            if let Some(format_args) = FormatArgsExpn::find_nested(cx, then, macro_call.expn);
+        if let ExprKind::If(cond, then, None) = expr.kind
+            && !matches!(cond.kind, ExprKind::Let(_))
+            && !expr.span.from_expansion()
+            && let then = peel_blocks_with_stmt(then)
+            && let Some(macro_call) = root_macro_call(then.span)
+            && cx.tcx.item_name(macro_call.def_id) == sym::panic
+            && !cx.tcx.sess.source_map().is_multiline(cond.span)
+            && let Ok(panic_snippet) = cx.sess().source_map().span_to_snippet(macro_call.span)
+            && let Some(panic_snippet) = panic_snippet.strip_suffix(')')
+            && let Some((_, format_args_snip)) = panic_snippet.split_once('(')
             // Don't change `else if foo { panic!(..) }` to `else { assert!(foo, ..) }` as it just
             // shuffles the condition around.
             // Should this have a config value?
-            if !is_else_clause(cx.tcx, expr);
-            then {
-                let mut applicability = Applicability::MachineApplicable;
-                let format_args_snip = snippet_with_applicability(cx, format_args.inputs_span(), "..", &mut applicability);
-                let cond = cond.peel_drop_temps();
-                let mut comments = span_extract_comment(cx.sess().source_map(), expr.span);
-                if !comments.is_empty() {
-                    comments += "\n";
-                }
-                let (cond, not) = match cond.kind {
-                    ExprKind::Unary(UnOp::Not, e) => (e, ""),
-                    _ => (cond, "!"),
-                };
-                let cond_sugg = sugg::Sugg::hir_with_applicability(cx, cond, "..", &mut applicability).maybe_par();
-                let sugg = format!("assert!({not}{cond_sugg}, {format_args_snip});");
-                // we show to the user the suggestion without the comments, but when applicating the fix, include the comments in the block
-                span_lint_and_then(
-                    cx,
-                    MANUAL_ASSERT,
-                    expr.span,
-                    "only a `panic!` in `if`-then statement",
-                    |diag| {
-                        // comments can be noisy, do not show them to the user
-                        if !comments.is_empty() {
-                            diag.tool_only_span_suggestion(
-                                        expr.span.shrink_to_lo(),
-                                        "add comments back",
-                                        comments,
-                                        applicability);
-                        }
-                        diag.span_suggestion(
-                                    expr.span,
-                                    "try instead",
-                                    sugg,
-                                    applicability);
-                                     }
-
-                );
+            && !is_else_clause(cx.tcx, expr)
+        {
+            let mut applicability = Applicability::MachineApplicable;
+            let cond = cond.peel_drop_temps();
+            let mut comments = span_extract_comment(cx.sess().source_map(), expr.span);
+            if !comments.is_empty() {
+                comments += "\n";
             }
+            let (cond, not) = match cond.kind {
+                ExprKind::Unary(UnOp::Not, e) => (e, ""),
+                _ => (cond, "!"),
+            };
+            let cond_sugg = sugg::Sugg::hir_with_applicability(cx, cond, "..", &mut applicability).maybe_par();
+            let sugg = format!("assert!({not}{cond_sugg}, {format_args_snip});");
+            // we show to the user the suggestion without the comments, but when applicating the fix, include the comments in the block
+            span_lint_and_then(
+                cx,
+                MANUAL_ASSERT,
+                expr.span,
+                "only a `panic!` in `if`-then statement",
+                |diag| {
+                    // comments can be noisy, do not show them to the user
+                    if !comments.is_empty() {
+                        diag.tool_only_span_suggestion(
+                            expr.span.shrink_to_lo(),
+                            "add comments back",
+                            comments,
+                            applicability
+                        );
+                    }
+                    diag.span_suggestion(
+                        expr.span,
+                        "try instead",
+                        sugg,
+                        applicability
+                    );
+                }
+            );
         }
     }
 }
-- 
cgit 1.4.1-3-g733a5


From fba16e2e3a6f743cb23c7793851a4f0201b21722 Mon Sep 17 00:00:00 2001
From: Michael Krasnitski <michael.krasnitski@gmail.com>
Date: Thu, 2 Feb 2023 19:36:42 -0500
Subject: Add `extra_unused_type_parameters` lint

---
 CHANGELOG.md                                     |   1 +
 README.md                                        |   2 +-
 book/src/README.md                               |   2 +-
 clippy_lints/src/declared_lints.rs               |   1 +
 clippy_lints/src/extra_unused_type_parameters.rs | 178 +++++++++++++++++++++++
 clippy_lints/src/lib.rs                          |   2 +
 tests/ui/extra_unused_type_parameters.rs         |  69 +++++++++
 tests/ui/extra_unused_type_parameters.stderr     |  59 ++++++++
 tests/ui/needless_lifetimes.fixed                |   1 +
 tests/ui/needless_lifetimes.rs                   |   1 +
 tests/ui/needless_lifetimes.stderr               |  92 ++++++------
 tests/ui/new_without_default.rs                  |   7 +-
 tests/ui/new_without_default.stderr              |  14 +-
 tests/ui/redundant_field_names.fixed             |   2 +-
 tests/ui/redundant_field_names.rs                |   2 +-
 tests/ui/seek_to_start_instead_of_rewind.fixed   |   4 +-
 tests/ui/seek_to_start_instead_of_rewind.rs      |   4 +-
 tests/ui/type_repetition_in_bounds.rs            |   1 +
 tests/ui/type_repetition_in_bounds.stderr        |   8 +-
 19 files changed, 384 insertions(+), 66 deletions(-)
 create mode 100644 clippy_lints/src/extra_unused_type_parameters.rs
 create mode 100644 tests/ui/extra_unused_type_parameters.rs
 create mode 100644 tests/ui/extra_unused_type_parameters.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index e2cde09776f..659e8aebcd5 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4383,6 +4383,7 @@ Released 2018-09-13
 [`extend_from_slice`]: https://rust-lang.github.io/rust-clippy/master/index.html#extend_from_slice
 [`extend_with_drain`]: https://rust-lang.github.io/rust-clippy/master/index.html#extend_with_drain
 [`extra_unused_lifetimes`]: https://rust-lang.github.io/rust-clippy/master/index.html#extra_unused_lifetimes
+[`extra_unused_type_parameters`]: https://rust-lang.github.io/rust-clippy/master/index.html#extra_unused_type_parameters
 [`fallible_impl_from`]: https://rust-lang.github.io/rust-clippy/master/index.html#fallible_impl_from
 [`field_reassign_with_default`]: https://rust-lang.github.io/rust-clippy/master/index.html#field_reassign_with_default
 [`filetype_is_file`]: https://rust-lang.github.io/rust-clippy/master/index.html#filetype_is_file
diff --git a/README.md b/README.md
index ab44db69483..95f6d2cc45c 100644
--- a/README.md
+++ b/README.md
@@ -5,7 +5,7 @@
 
 A collection of lints to catch common mistakes and improve your [Rust](https://github.com/rust-lang/rust) code.
 
-[There are over 550 lints included in this crate!](https://rust-lang.github.io/rust-clippy/master/index.html)
+[There are over 600 lints included in this crate!](https://rust-lang.github.io/rust-clippy/master/index.html)
 
 Lints are divided into categories, each with a default [lint level](https://doc.rust-lang.org/rustc/lints/levels.html).
 You can choose how much Clippy is supposed to ~~annoy~~ help you by changing the lint level by category.
diff --git a/book/src/README.md b/book/src/README.md
index 23867df8efe..df4a1f2702e 100644
--- a/book/src/README.md
+++ b/book/src/README.md
@@ -6,7 +6,7 @@
 A collection of lints to catch common mistakes and improve your
 [Rust](https://github.com/rust-lang/rust) code.
 
-[There are over 550 lints included in this crate!](https://rust-lang.github.io/rust-clippy/master/index.html)
+[There are over 600 lints included in this crate!](https://rust-lang.github.io/rust-clippy/master/index.html)
 
 Lints are divided into categories, each with a default [lint
 level](https://doc.rust-lang.org/rustc/lints/levels.html). You can choose how
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 36a366fc974..457a25826e7 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -156,6 +156,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::exhaustive_items::EXHAUSTIVE_STRUCTS_INFO,
     crate::exit::EXIT_INFO,
     crate::explicit_write::EXPLICIT_WRITE_INFO,
+    crate::extra_unused_type_parameters::EXTRA_UNUSED_TYPE_PARAMETERS_INFO,
     crate::fallible_impl_from::FALLIBLE_IMPL_FROM_INFO,
     crate::float_literal::EXCESSIVE_PRECISION_INFO,
     crate::float_literal::LOSSY_FLOAT_LITERAL_INFO,
diff --git a/clippy_lints/src/extra_unused_type_parameters.rs b/clippy_lints/src/extra_unused_type_parameters.rs
new file mode 100644
index 00000000000..2fdd8a71466
--- /dev/null
+++ b/clippy_lints/src/extra_unused_type_parameters.rs
@@ -0,0 +1,178 @@
+use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::trait_ref_of_method;
+use rustc_data_structures::fx::FxHashMap;
+use rustc_errors::MultiSpan;
+use rustc_hir::intravisit::{walk_impl_item, walk_item, walk_param_bound, walk_ty, Visitor};
+use rustc_hir::{
+    GenericParamKind, Generics, ImplItem, ImplItemKind, Item, ItemKind, PredicateOrigin, Ty, TyKind, WherePredicate,
+};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::hir::nested_filter;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::{def_id::DefId, Span};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for type parameters in generics that are never used anywhere else.
+    ///
+    /// ### Why is this bad?
+    /// Functions cannot infer the value of unused type parameters; therefore, calling them
+    /// requires using a turbofish, which serves no purpose but to satisfy the compiler.
+    ///
+    /// ### Example
+    /// ```rust
+    /// // unused type parameters
+    /// fn unused_ty<T>(x: u8) {
+    ///     // ..
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// fn no_unused_ty(x: u8) {
+    ///     // ..
+    /// }
+    /// ```
+    #[clippy::version = "1.69.0"]
+    pub EXTRA_UNUSED_TYPE_PARAMETERS,
+    complexity,
+    "unused type parameters in function definitions"
+}
+declare_lint_pass!(ExtraUnusedTypeParameters => [EXTRA_UNUSED_TYPE_PARAMETERS]);
+
+/// A visitor struct that walks a given function and gathers generic type parameters, plus any
+/// trait bounds those parameters have.
+struct TypeWalker<'cx, 'tcx> {
+    cx: &'cx LateContext<'tcx>,
+    /// Collection of all the type parameters and their spans.
+    ty_params: FxHashMap<DefId, Span>,
+    /// Collection of any (inline) trait bounds corresponding to each type parameter.
+    bounds: FxHashMap<DefId, Span>,
+    /// The entire `Generics` object of the function, useful for querying purposes.
+    generics: &'tcx Generics<'tcx>,
+    /// The value of this will remain `true` if *every* parameter:
+    ///   1. Is a type parameter, and
+    ///   2. Goes unused in the function.
+    /// Otherwise, if any type parameters end up being used, or if any lifetime or const-generic
+    /// parameters are present, this will be set to `false`.
+    all_params_unused: bool,
+}
+
+impl<'cx, 'tcx> TypeWalker<'cx, 'tcx> {
+    fn new(cx: &'cx LateContext<'tcx>, generics: &'tcx Generics<'tcx>) -> Self {
+        let mut all_params_unused = true;
+        let ty_params = generics
+            .params
+            .iter()
+            .filter_map(|param| {
+                if let GenericParamKind::Type { .. } = param.kind {
+                    Some((param.def_id.into(), param.span))
+                } else {
+                    if !param.is_elided_lifetime() {
+                        all_params_unused = false;
+                    }
+                    None
+                }
+            })
+            .collect();
+        Self {
+            cx,
+            ty_params,
+            bounds: FxHashMap::default(),
+            generics,
+            all_params_unused,
+        }
+    }
+
+    fn emit_lint(&self) {
+        let (msg, help) = match self.ty_params.len() {
+            0 => return,
+            1 => (
+                "type parameter goes unused in function definition",
+                "consider removing the parameter",
+            ),
+            _ => (
+                "type parameters go unused in function definition",
+                "consider removing the parameters",
+            ),
+        };
+
+        let source_map = self.cx.tcx.sess.source_map();
+        let span = if self.all_params_unused {
+            self.generics.span.into() // Remove the entire list of generics
+        } else {
+            MultiSpan::from_spans(
+                self.ty_params
+                    .iter()
+                    .map(|(def_id, &span)| {
+                        // Extend the span past any trait bounds, and include the comma at the end.
+                        let span_to_extend = self.bounds.get(def_id).copied().map_or(span, Span::shrink_to_hi);
+                        let comma_range = source_map.span_extend_to_next_char(span_to_extend, '>', false);
+                        let comma_span = source_map.span_through_char(comma_range, ',');
+                        span.with_hi(comma_span.hi())
+                    })
+                    .collect(),
+            )
+        };
+
+        span_lint_and_help(self.cx, EXTRA_UNUSED_TYPE_PARAMETERS, span, msg, None, help);
+    }
+}
+
+impl<'cx, 'tcx> Visitor<'tcx> for TypeWalker<'cx, 'tcx> {
+    type NestedFilter = nested_filter::OnlyBodies;
+
+    fn visit_ty(&mut self, t: &'tcx Ty<'tcx>) {
+        if let Some((def_id, _)) = t.peel_refs().as_generic_param() {
+            if self.ty_params.remove(&def_id).is_some() {
+                self.all_params_unused = false;
+            }
+        } else if let TyKind::OpaqueDef(id, _, _) = t.kind {
+            // Explicitly walk OpaqueDef. Normally `walk_ty` would do the job, but it calls
+            // `visit_nested_item`, which checks that `Self::NestedFilter::INTER` is set. We're
+            // using `OnlyBodies`, so the check ends up failing and the type isn't fully walked.
+            let item = self.nested_visit_map().item(id);
+            walk_item(self, item);
+        } else {
+            walk_ty(self, t);
+        }
+    }
+
+    fn visit_where_predicate(&mut self, predicate: &'tcx WherePredicate<'tcx>) {
+        if let WherePredicate::BoundPredicate(predicate) = predicate {
+            // Collect spans for bounds that appear in the list of generics (not in a where-clause)
+            // for use in forming the help message
+            if let Some((def_id, _)) = predicate.bounded_ty.peel_refs().as_generic_param()
+                && let PredicateOrigin::GenericParam = predicate.origin
+            {
+                self.bounds.insert(def_id, predicate.span);
+            }
+            // Only walk the right-hand side of where-bounds
+            for bound in predicate.bounds {
+                walk_param_bound(self, bound);
+            }
+        }
+    }
+
+    fn nested_visit_map(&mut self) -> Self::Map {
+        self.cx.tcx.hir()
+    }
+}
+
+impl<'tcx> LateLintPass<'tcx> for ExtraUnusedTypeParameters {
+    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
+        if let ItemKind::Fn(_, generics, _) = item.kind {
+            let mut walker = TypeWalker::new(cx, generics);
+            walk_item(&mut walker, item);
+            walker.emit_lint();
+        }
+    }
+
+    fn check_impl_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx ImplItem<'tcx>) {
+        // Only lint on inherent methods, not trait methods.
+        if let ImplItemKind::Fn(..) = item.kind && trait_ref_of_method(cx, item.owner_id.def_id).is_none() {
+            let mut walker = TypeWalker::new(cx, item.generics);
+            walk_impl_item(&mut walker, item);
+            walker.emit_lint();
+        }
+    }
+}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 5c4b6041044..2f5c4adca9f 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -122,6 +122,7 @@ mod excessive_bools;
 mod exhaustive_items;
 mod exit;
 mod explicit_write;
+mod extra_unused_type_parameters;
 mod fallible_impl_from;
 mod float_literal;
 mod floating_point_arithmetic;
@@ -910,6 +911,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(permissions_set_readonly_false::PermissionsSetReadonlyFalse));
     store.register_late_pass(|_| Box::new(size_of_ref::SizeOfRef));
     store.register_late_pass(|_| Box::new(multiple_unsafe_ops_per_block::MultipleUnsafeOpsPerBlock));
+    store.register_late_pass(|_| Box::new(extra_unused_type_parameters::ExtraUnusedTypeParameters));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/tests/ui/extra_unused_type_parameters.rs b/tests/ui/extra_unused_type_parameters.rs
new file mode 100644
index 00000000000..5cb80cb6233
--- /dev/null
+++ b/tests/ui/extra_unused_type_parameters.rs
@@ -0,0 +1,69 @@
+#![allow(unused, clippy::needless_lifetimes)]
+#![warn(clippy::extra_unused_type_parameters)]
+
+fn unused_ty<T>(x: u8) {}
+
+fn unused_multi<T, U>(x: u8) {}
+
+fn unused_with_lt<'a, T>(x: &'a u8) {}
+
+fn used_ty<T>(x: T, y: u8) {}
+
+fn used_ref<'a, T>(x: &'a T) {}
+
+fn used_ret<T: Default>(x: u8) -> T {
+    T::default()
+}
+
+fn unused_bounded<T: Default, U>(x: U) {}
+
+fn unused_where_clause<T, U>(x: U)
+where
+    T: Default,
+{
+}
+
+fn some_unused<A, B, C, D: Iterator<Item = (B, C)>, E>(b: B, c: C) {}
+
+fn used_opaque<A>(iter: impl Iterator<Item = A>) -> usize {
+    iter.count()
+}
+
+fn used_ret_opaque<A>() -> impl Iterator<Item = A> {
+    std::iter::empty()
+}
+
+fn used_vec_box<T>(x: Vec<Box<T>>) {}
+
+fn used_body<T: Default + ToString>() -> String {
+    T::default().to_string()
+}
+
+fn used_closure<T: Default + ToString>() -> impl Fn() {
+    || println!("{}", T::default().to_string())
+}
+
+struct S;
+
+impl S {
+    fn unused_ty_impl<T>(&self) {}
+}
+
+// Don't lint on trait methods
+trait Foo {
+    fn bar<T>(&self);
+}
+
+impl Foo for S {
+    fn bar<T>(&self) {}
+}
+
+fn skip_index<A, Iter>(iter: Iter, index: usize) -> impl Iterator<Item = A>
+where
+    Iter: Iterator<Item = A>,
+{
+    iter.enumerate()
+        .filter_map(move |(i, a)| if i == index { None } else { Some(a) })
+}
+
+fn main() {}
diff --git a/tests/ui/extra_unused_type_parameters.stderr b/tests/ui/extra_unused_type_parameters.stderr
new file mode 100644
index 00000000000..1c8dd53e638
--- /dev/null
+++ b/tests/ui/extra_unused_type_parameters.stderr
@@ -0,0 +1,59 @@
+error: type parameter goes unused in function definition
+  --> $DIR/extra_unused_type_parameters.rs:4:13
+   |
+LL | fn unused_ty<T>(x: u8) {}
+   |             ^^^
+   |
+   = help: consider removing the parameter
+   = note: `-D clippy::extra-unused-type-parameters` implied by `-D warnings`
+
+error: type parameters go unused in function definition
+  --> $DIR/extra_unused_type_parameters.rs:6:16
+   |
+LL | fn unused_multi<T, U>(x: u8) {}
+   |                ^^^^^^
+   |
+   = help: consider removing the parameters
+
+error: type parameter goes unused in function definition
+  --> $DIR/extra_unused_type_parameters.rs:8:23
+   |
+LL | fn unused_with_lt<'a, T>(x: &'a u8) {}
+   |                       ^
+   |
+   = help: consider removing the parameter
+
+error: type parameter goes unused in function definition
+  --> $DIR/extra_unused_type_parameters.rs:18:19
+   |
+LL | fn unused_bounded<T: Default, U>(x: U) {}
+   |                   ^^^^^^^^^^^
+   |
+   = help: consider removing the parameter
+
+error: type parameter goes unused in function definition
+  --> $DIR/extra_unused_type_parameters.rs:20:24
+   |
+LL | fn unused_where_clause<T, U>(x: U)
+   |                        ^^
+   |
+   = help: consider removing the parameter
+
+error: type parameters go unused in function definition
+  --> $DIR/extra_unused_type_parameters.rs:26:16
+   |
+LL | fn some_unused<A, B, C, D: Iterator<Item = (B, C)>, E>(b: B, c: C) {}
+   |                ^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^
+   |
+   = help: consider removing the parameters
+
+error: type parameter goes unused in function definition
+  --> $DIR/extra_unused_type_parameters.rs:49:22
+   |
+LL |     fn unused_ty_impl<T>(&self) {}
+   |                      ^^^
+   |
+   = help: consider removing the parameter
+
+error: aborting due to 7 previous errors
+
diff --git a/tests/ui/needless_lifetimes.fixed b/tests/ui/needless_lifetimes.fixed
index 270cd1afc67..d286ef4ba37 100644
--- a/tests/ui/needless_lifetimes.fixed
+++ b/tests/ui/needless_lifetimes.fixed
@@ -5,6 +5,7 @@
 #![allow(
     unused,
     clippy::boxed_local,
+    clippy::extra_unused_type_parameters,
     clippy::needless_pass_by_value,
     clippy::unnecessary_wraps,
     dyn_drop,
diff --git a/tests/ui/needless_lifetimes.rs b/tests/ui/needless_lifetimes.rs
index 5d4dc971b8d..409528b291d 100644
--- a/tests/ui/needless_lifetimes.rs
+++ b/tests/ui/needless_lifetimes.rs
@@ -5,6 +5,7 @@
 #![allow(
     unused,
     clippy::boxed_local,
+    clippy::extra_unused_type_parameters,
     clippy::needless_pass_by_value,
     clippy::unnecessary_wraps,
     dyn_drop,
diff --git a/tests/ui/needless_lifetimes.stderr b/tests/ui/needless_lifetimes.stderr
index afe637ac388..4e3c8f20d8c 100644
--- a/tests/ui/needless_lifetimes.stderr
+++ b/tests/ui/needless_lifetimes.stderr
@@ -1,5 +1,5 @@
 error: the following explicit lifetimes could be elided: 'a, 'b
-  --> $DIR/needless_lifetimes.rs:17:1
+  --> $DIR/needless_lifetimes.rs:18:1
    |
 LL | fn distinct_lifetimes<'a, 'b>(_x: &'a u8, _y: &'b u8, _z: u8) {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -12,7 +12,7 @@ LL + fn distinct_lifetimes(_x: &u8, _y: &u8, _z: u8) {}
    |
 
 error: the following explicit lifetimes could be elided: 'a, 'b
-  --> $DIR/needless_lifetimes.rs:19:1
+  --> $DIR/needless_lifetimes.rs:20:1
    |
 LL | fn distinct_and_static<'a, 'b>(_x: &'a u8, _y: &'b u8, _z: &'static u8) {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -24,7 +24,7 @@ LL + fn distinct_and_static(_x: &u8, _y: &u8, _z: &'static u8) {}
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:29:1
+  --> $DIR/needless_lifetimes.rs:30:1
    |
 LL | fn in_and_out<'a>(x: &'a u8, _y: u8) -> &'a u8 {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -36,7 +36,7 @@ LL + fn in_and_out(x: &u8, _y: u8) -> &u8 {
    |
 
 error: the following explicit lifetimes could be elided: 'b
-  --> $DIR/needless_lifetimes.rs:41:1
+  --> $DIR/needless_lifetimes.rs:42:1
    |
 LL | fn multiple_in_and_out_2a<'a, 'b>(x: &'a u8, _y: &'b u8) -> &'a u8 {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -48,7 +48,7 @@ LL + fn multiple_in_and_out_2a<'a>(x: &'a u8, _y: &u8) -> &'a u8 {
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:48:1
+  --> $DIR/needless_lifetimes.rs:49:1
    |
 LL | fn multiple_in_and_out_2b<'a, 'b>(_x: &'a u8, y: &'b u8) -> &'b u8 {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -60,7 +60,7 @@ LL + fn multiple_in_and_out_2b<'b>(_x: &u8, y: &'b u8) -> &'b u8 {
    |
 
 error: the following explicit lifetimes could be elided: 'b
-  --> $DIR/needless_lifetimes.rs:65:1
+  --> $DIR/needless_lifetimes.rs:66:1
    |
 LL | fn deep_reference_1a<'a, 'b>(x: &'a u8, _y: &'b u8) -> Result<&'a u8, ()> {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -72,7 +72,7 @@ LL + fn deep_reference_1a<'a>(x: &'a u8, _y: &u8) -> Result<&'a u8, ()> {
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:72:1
+  --> $DIR/needless_lifetimes.rs:73:1
    |
 LL | fn deep_reference_1b<'a, 'b>(_x: &'a u8, y: &'b u8) -> Result<&'b u8, ()> {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -84,7 +84,7 @@ LL + fn deep_reference_1b<'b>(_x: &u8, y: &'b u8) -> Result<&'b u8, ()> {
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:81:1
+  --> $DIR/needless_lifetimes.rs:82:1
    |
 LL | fn deep_reference_3<'a>(x: &'a u8, _y: u8) -> Result<&'a u8, ()> {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -96,7 +96,7 @@ LL + fn deep_reference_3(x: &u8, _y: u8) -> Result<&u8, ()> {
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:86:1
+  --> $DIR/needless_lifetimes.rs:87:1
    |
 LL | fn where_clause_without_lt<'a, T>(x: &'a u8, _y: u8) -> Result<&'a u8, ()>
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -108,7 +108,7 @@ LL + fn where_clause_without_lt<T>(x: &u8, _y: u8) -> Result<&u8, ()>
    |
 
 error: the following explicit lifetimes could be elided: 'a, 'b
-  --> $DIR/needless_lifetimes.rs:98:1
+  --> $DIR/needless_lifetimes.rs:99:1
    |
 LL | fn lifetime_param_2<'a, 'b>(_x: Ref<'a>, _y: &'b u8) {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -120,7 +120,7 @@ LL + fn lifetime_param_2(_x: Ref<'_>, _y: &u8) {}
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:122:1
+  --> $DIR/needless_lifetimes.rs:123:1
    |
 LL | fn fn_bound_2<'a, F, I>(_m: Lt<'a, I>, _f: F) -> Lt<'a, I>
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -132,7 +132,7 @@ LL + fn fn_bound_2<F, I>(_m: Lt<'_, I>, _f: F) -> Lt<'_, I>
    |
 
 error: the following explicit lifetimes could be elided: 's
-  --> $DIR/needless_lifetimes.rs:152:5
+  --> $DIR/needless_lifetimes.rs:153:5
    |
 LL |     fn self_and_out<'s>(&'s self) -> &'s u8 {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -144,7 +144,7 @@ LL +     fn self_and_out(&self) -> &u8 {
    |
 
 error: the following explicit lifetimes could be elided: 't
-  --> $DIR/needless_lifetimes.rs:159:5
+  --> $DIR/needless_lifetimes.rs:160:5
    |
 LL |     fn self_and_in_out_1<'s, 't>(&'s self, _x: &'t u8) -> &'s u8 {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -156,7 +156,7 @@ LL +     fn self_and_in_out_1<'s>(&'s self, _x: &u8) -> &'s u8 {
    |
 
 error: the following explicit lifetimes could be elided: 's
-  --> $DIR/needless_lifetimes.rs:166:5
+  --> $DIR/needless_lifetimes.rs:167:5
    |
 LL |     fn self_and_in_out_2<'s, 't>(&'s self, x: &'t u8) -> &'t u8 {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -168,7 +168,7 @@ LL +     fn self_and_in_out_2<'t>(&self, x: &'t u8) -> &'t u8 {
    |
 
 error: the following explicit lifetimes could be elided: 's, 't
-  --> $DIR/needless_lifetimes.rs:170:5
+  --> $DIR/needless_lifetimes.rs:171:5
    |
 LL |     fn distinct_self_and_in<'s, 't>(&'s self, _x: &'t u8) {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -180,7 +180,7 @@ LL +     fn distinct_self_and_in(&self, _x: &u8) {}
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:189:1
+  --> $DIR/needless_lifetimes.rs:190:1
    |
 LL | fn struct_with_lt<'a>(_foo: Foo<'a>) -> &'a str {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -192,7 +192,7 @@ LL + fn struct_with_lt(_foo: Foo<'_>) -> &str {
    |
 
 error: the following explicit lifetimes could be elided: 'b
-  --> $DIR/needless_lifetimes.rs:207:1
+  --> $DIR/needless_lifetimes.rs:208:1
    |
 LL | fn struct_with_lt4a<'a, 'b>(_foo: &'a Foo<'b>) -> &'a str {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -204,7 +204,7 @@ LL + fn struct_with_lt4a<'a>(_foo: &'a Foo<'_>) -> &'a str {
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:215:1
+  --> $DIR/needless_lifetimes.rs:216:1
    |
 LL | fn struct_with_lt4b<'a, 'b>(_foo: &'a Foo<'b>) -> &'b str {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -216,7 +216,7 @@ LL + fn struct_with_lt4b<'b>(_foo: &Foo<'b>) -> &'b str {
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:230:1
+  --> $DIR/needless_lifetimes.rs:231:1
    |
 LL | fn trait_obj_elided2<'a>(_arg: &'a dyn Drop) -> &'a str {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -228,7 +228,7 @@ LL + fn trait_obj_elided2(_arg: &dyn Drop) -> &str {
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:236:1
+  --> $DIR/needless_lifetimes.rs:237:1
    |
 LL | fn alias_with_lt<'a>(_foo: FooAlias<'a>) -> &'a str {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -240,7 +240,7 @@ LL + fn alias_with_lt(_foo: FooAlias<'_>) -> &str {
    |
 
 error: the following explicit lifetimes could be elided: 'b
-  --> $DIR/needless_lifetimes.rs:254:1
+  --> $DIR/needless_lifetimes.rs:255:1
    |
 LL | fn alias_with_lt4a<'a, 'b>(_foo: &'a FooAlias<'b>) -> &'a str {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -252,7 +252,7 @@ LL + fn alias_with_lt4a<'a>(_foo: &'a FooAlias<'_>) -> &'a str {
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:262:1
+  --> $DIR/needless_lifetimes.rs:263:1
    |
 LL | fn alias_with_lt4b<'a, 'b>(_foo: &'a FooAlias<'b>) -> &'b str {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -264,7 +264,7 @@ LL + fn alias_with_lt4b<'b>(_foo: &FooAlias<'b>) -> &'b str {
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:266:1
+  --> $DIR/needless_lifetimes.rs:267:1
    |
 LL | fn named_input_elided_output<'a>(_arg: &'a str) -> &str {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -276,7 +276,7 @@ LL + fn named_input_elided_output(_arg: &str) -> &str {
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:274:1
+  --> $DIR/needless_lifetimes.rs:275:1
    |
 LL | fn trait_bound_ok<'a, T: WithLifetime<'static>>(_: &'a u8, _: T) {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -288,7 +288,7 @@ LL + fn trait_bound_ok<T: WithLifetime<'static>>(_: &u8, _: T) {
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:310:1
+  --> $DIR/needless_lifetimes.rs:311:1
    |
 LL | fn out_return_type_lts<'a>(e: &'a str) -> Cow<'a> {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -300,7 +300,7 @@ LL + fn out_return_type_lts(e: &str) -> Cow<'_> {
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:317:9
+  --> $DIR/needless_lifetimes.rs:318:9
    |
 LL |         fn needless_lt<'a>(x: &'a u8) {}
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -312,7 +312,7 @@ LL +         fn needless_lt(x: &u8) {}
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:321:9
+  --> $DIR/needless_lifetimes.rs:322:9
    |
 LL |         fn needless_lt<'a>(_x: &'a u8) {}
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -324,7 +324,7 @@ LL +         fn needless_lt(_x: &u8) {}
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:334:9
+  --> $DIR/needless_lifetimes.rs:335:9
    |
 LL |         fn baz<'a>(&'a self) -> impl Foo + 'a {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -336,7 +336,7 @@ LL +         fn baz(&self) -> impl Foo + '_ {
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:366:5
+  --> $DIR/needless_lifetimes.rs:367:5
    |
 LL |     fn impl_trait_elidable_nested_anonymous_lifetimes<'a>(i: &'a i32, f: impl Fn(&i32) -> &i32) -> &'a i32 {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -348,7 +348,7 @@ LL +     fn impl_trait_elidable_nested_anonymous_lifetimes(i: &i32, f: impl Fn(&
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:375:5
+  --> $DIR/needless_lifetimes.rs:376:5
    |
 LL |     fn generics_elidable<'a, T: Fn(&i32) -> &i32>(i: &'a i32, f: T) -> &'a i32 {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -360,7 +360,7 @@ LL +     fn generics_elidable<T: Fn(&i32) -> &i32>(i: &i32, f: T) -> &i32 {
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:387:5
+  --> $DIR/needless_lifetimes.rs:388:5
    |
 LL |     fn where_clause_elidadable<'a, T>(i: &'a i32, f: T) -> &'a i32
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -372,7 +372,7 @@ LL +     fn where_clause_elidadable<T>(i: &i32, f: T) -> &i32
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:402:5
+  --> $DIR/needless_lifetimes.rs:403:5
    |
 LL |     fn pointer_fn_elidable<'a>(i: &'a i32, f: fn(&i32) -> &i32) -> &'a i32 {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -384,7 +384,7 @@ LL +     fn pointer_fn_elidable(i: &i32, f: fn(&i32) -> &i32) -> &i32 {
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:415:5
+  --> $DIR/needless_lifetimes.rs:416:5
    |
 LL |     fn nested_fn_pointer_3<'a>(_: &'a i32) -> fn(fn(&i32) -> &i32) -> i32 {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -396,7 +396,7 @@ LL +     fn nested_fn_pointer_3(_: &i32) -> fn(fn(&i32) -> &i32) -> i32 {
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:418:5
+  --> $DIR/needless_lifetimes.rs:419:5
    |
 LL |     fn nested_fn_pointer_4<'a>(_: &'a i32) -> impl Fn(fn(&i32)) {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -408,7 +408,7 @@ LL +     fn nested_fn_pointer_4(_: &i32) -> impl Fn(fn(&i32)) {
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:440:9
+  --> $DIR/needless_lifetimes.rs:441:9
    |
 LL |         fn implicit<'a>(&'a self) -> &'a () {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -420,7 +420,7 @@ LL +         fn implicit(&self) -> &() {
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:443:9
+  --> $DIR/needless_lifetimes.rs:444:9
    |
 LL |         fn implicit_mut<'a>(&'a mut self) -> &'a () {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -432,7 +432,7 @@ LL +         fn implicit_mut(&mut self) -> &() {
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:454:9
+  --> $DIR/needless_lifetimes.rs:455:9
    |
 LL |         fn lifetime_elsewhere<'a>(self: Box<Self>, here: &'a ()) -> &'a () {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -444,7 +444,7 @@ LL +         fn lifetime_elsewhere(self: Box<Self>, here: &()) -> &() {
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:460:9
+  --> $DIR/needless_lifetimes.rs:461:9
    |
 LL |         fn implicit<'a>(&'a self) -> &'a ();
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -456,7 +456,7 @@ LL +         fn implicit(&self) -> &();
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:461:9
+  --> $DIR/needless_lifetimes.rs:462:9
    |
 LL |         fn implicit_provided<'a>(&'a self) -> &'a () {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -468,7 +468,7 @@ LL +         fn implicit_provided(&self) -> &() {
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:470:9
+  --> $DIR/needless_lifetimes.rs:471:9
    |
 LL |         fn lifetime_elsewhere<'a>(self: Box<Self>, here: &'a ()) -> &'a ();
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -480,7 +480,7 @@ LL +         fn lifetime_elsewhere(self: Box<Self>, here: &()) -> &();
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:471:9
+  --> $DIR/needless_lifetimes.rs:472:9
    |
 LL |         fn lifetime_elsewhere_provided<'a>(self: Box<Self>, here: &'a ()) -> &'a () {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -492,7 +492,7 @@ LL +         fn lifetime_elsewhere_provided(self: Box<Self>, here: &()) -> &() {
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:480:5
+  --> $DIR/needless_lifetimes.rs:481:5
    |
 LL |     fn foo<'a>(x: &'a u8, y: &'_ u8) {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -504,7 +504,7 @@ LL +     fn foo(x: &u8, y: &'_ u8) {}
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:482:5
+  --> $DIR/needless_lifetimes.rs:483:5
    |
 LL |     fn bar<'a>(x: &'a u8, y: &'_ u8, z: &'_ u8) {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -516,7 +516,7 @@ LL +     fn bar(x: &u8, y: &'_ u8, z: &'_ u8) {}
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:489:5
+  --> $DIR/needless_lifetimes.rs:490:5
    |
 LL |     fn one_input<'a>(x: &'a u8) -> &'a u8 {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -528,7 +528,7 @@ LL +     fn one_input(x: &u8) -> &u8 {
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:494:5
+  --> $DIR/needless_lifetimes.rs:495:5
    |
 LL |     fn multiple_inputs_output_not_elided<'a, 'b>(x: &'a u8, y: &'b u8, z: &'b u8) -> &'b u8 {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -540,7 +540,7 @@ LL +     fn multiple_inputs_output_not_elided<'b>(x: &u8, y: &'b u8, z: &'b u8)
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:507:13
+  --> $DIR/needless_lifetimes.rs:508:13
    |
 LL |             fn one_input<'a>(x: &'a u8) -> &'a u8 {
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/new_without_default.rs b/tests/ui/new_without_default.rs
index 65809023f8d..7803418cb04 100644
--- a/tests/ui/new_without_default.rs
+++ b/tests/ui/new_without_default.rs
@@ -1,4 +1,9 @@
-#![allow(dead_code, clippy::missing_safety_doc, clippy::extra_unused_lifetimes)]
+#![allow(
+    dead_code,
+    clippy::missing_safety_doc,
+    clippy::extra_unused_lifetimes,
+    clippy::extra_unused_type_parameters
+)]
 #![warn(clippy::new_without_default)]
 
 pub struct Foo;
diff --git a/tests/ui/new_without_default.stderr b/tests/ui/new_without_default.stderr
index 212a69ab94e..583dd327d6a 100644
--- a/tests/ui/new_without_default.stderr
+++ b/tests/ui/new_without_default.stderr
@@ -1,5 +1,5 @@
 error: you should consider adding a `Default` implementation for `Foo`
-  --> $DIR/new_without_default.rs:7:5
+  --> $DIR/new_without_default.rs:12:5
    |
 LL | /     pub fn new() -> Foo {
 LL | |         Foo
@@ -17,7 +17,7 @@ LL + }
    |
 
 error: you should consider adding a `Default` implementation for `Bar`
-  --> $DIR/new_without_default.rs:15:5
+  --> $DIR/new_without_default.rs:20:5
    |
 LL | /     pub fn new() -> Self {
 LL | |         Bar
@@ -34,7 +34,7 @@ LL + }
    |
 
 error: you should consider adding a `Default` implementation for `LtKo<'c>`
-  --> $DIR/new_without_default.rs:79:5
+  --> $DIR/new_without_default.rs:84:5
    |
 LL | /     pub fn new() -> LtKo<'c> {
 LL | |         unimplemented!()
@@ -51,7 +51,7 @@ LL + }
    |
 
 error: you should consider adding a `Default` implementation for `NewNotEqualToDerive`
-  --> $DIR/new_without_default.rs:172:5
+  --> $DIR/new_without_default.rs:177:5
    |
 LL | /     pub fn new() -> Self {
 LL | |         NewNotEqualToDerive { foo: 1 }
@@ -68,7 +68,7 @@ LL + }
    |
 
 error: you should consider adding a `Default` implementation for `FooGenerics<T>`
-  --> $DIR/new_without_default.rs:180:5
+  --> $DIR/new_without_default.rs:185:5
    |
 LL | /     pub fn new() -> Self {
 LL | |         Self(Default::default())
@@ -85,7 +85,7 @@ LL + }
    |
 
 error: you should consider adding a `Default` implementation for `BarGenerics<T>`
-  --> $DIR/new_without_default.rs:187:5
+  --> $DIR/new_without_default.rs:192:5
    |
 LL | /     pub fn new() -> Self {
 LL | |         Self(Default::default())
@@ -102,7 +102,7 @@ LL + }
    |
 
 error: you should consider adding a `Default` implementation for `Foo<T>`
-  --> $DIR/new_without_default.rs:198:9
+  --> $DIR/new_without_default.rs:203:9
    |
 LL | /         pub fn new() -> Self {
 LL | |             todo!()
diff --git a/tests/ui/redundant_field_names.fixed b/tests/ui/redundant_field_names.fixed
index ec7f8ae923a..276266a2dd8 100644
--- a/tests/ui/redundant_field_names.fixed
+++ b/tests/ui/redundant_field_names.fixed
@@ -1,7 +1,7 @@
 // run-rustfix
 
 #![warn(clippy::redundant_field_names)]
-#![allow(clippy::no_effect, dead_code, unused_variables)]
+#![allow(clippy::extra_unused_type_parameters, clippy::no_effect, dead_code, unused_variables)]
 
 #[macro_use]
 extern crate derive_new;
diff --git a/tests/ui/redundant_field_names.rs b/tests/ui/redundant_field_names.rs
index 73122016cf6..f674141c138 100644
--- a/tests/ui/redundant_field_names.rs
+++ b/tests/ui/redundant_field_names.rs
@@ -1,7 +1,7 @@
 // run-rustfix
 
 #![warn(clippy::redundant_field_names)]
-#![allow(clippy::no_effect, dead_code, unused_variables)]
+#![allow(clippy::extra_unused_type_parameters, clippy::no_effect, dead_code, unused_variables)]
 
 #[macro_use]
 extern crate derive_new;
diff --git a/tests/ui/seek_to_start_instead_of_rewind.fixed b/tests/ui/seek_to_start_instead_of_rewind.fixed
index 713cff604a1..dc24d447c60 100644
--- a/tests/ui/seek_to_start_instead_of_rewind.fixed
+++ b/tests/ui/seek_to_start_instead_of_rewind.fixed
@@ -26,7 +26,7 @@ fn seek_to_start_false_method(t: &mut StructWithSeekMethod) {
 
 // This should NOT trigger clippy warning because
 // StructWithSeekMethod does not implement std::io::Seek;
-fn seek_to_start_method_owned_false<T>(mut t: StructWithSeekMethod) {
+fn seek_to_start_method_owned_false(mut t: StructWithSeekMethod) {
     t.seek(SeekFrom::Start(0));
 }
 
@@ -38,7 +38,7 @@ fn seek_to_start_false_trait(t: &mut StructWithSeekTrait) {
 
 // This should NOT trigger clippy warning because
 // StructWithSeekMethod does not implement std::io::Seek;
-fn seek_to_start_false_trait_owned<T>(mut t: StructWithSeekTrait) {
+fn seek_to_start_false_trait_owned(mut t: StructWithSeekTrait) {
     t.seek(SeekFrom::Start(0));
 }
 
diff --git a/tests/ui/seek_to_start_instead_of_rewind.rs b/tests/ui/seek_to_start_instead_of_rewind.rs
index 467003a1a66..4adde2c4018 100644
--- a/tests/ui/seek_to_start_instead_of_rewind.rs
+++ b/tests/ui/seek_to_start_instead_of_rewind.rs
@@ -26,7 +26,7 @@ fn seek_to_start_false_method(t: &mut StructWithSeekMethod) {
 
 // This should NOT trigger clippy warning because
 // StructWithSeekMethod does not implement std::io::Seek;
-fn seek_to_start_method_owned_false<T>(mut t: StructWithSeekMethod) {
+fn seek_to_start_method_owned_false(mut t: StructWithSeekMethod) {
     t.seek(SeekFrom::Start(0));
 }
 
@@ -38,7 +38,7 @@ fn seek_to_start_false_trait(t: &mut StructWithSeekTrait) {
 
 // This should NOT trigger clippy warning because
 // StructWithSeekMethod does not implement std::io::Seek;
-fn seek_to_start_false_trait_owned<T>(mut t: StructWithSeekTrait) {
+fn seek_to_start_false_trait_owned(mut t: StructWithSeekTrait) {
     t.seek(SeekFrom::Start(0));
 }
 
diff --git a/tests/ui/type_repetition_in_bounds.rs b/tests/ui/type_repetition_in_bounds.rs
index 2eca1f4701c..8b4613b3f6e 100644
--- a/tests/ui/type_repetition_in_bounds.rs
+++ b/tests/ui/type_repetition_in_bounds.rs
@@ -1,4 +1,5 @@
 #![deny(clippy::type_repetition_in_bounds)]
+#![allow(clippy::extra_unused_type_parameters)]
 
 use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Sub, SubAssign};
 
diff --git a/tests/ui/type_repetition_in_bounds.stderr b/tests/ui/type_repetition_in_bounds.stderr
index 70d700c1cc4..a90df03c04f 100644
--- a/tests/ui/type_repetition_in_bounds.stderr
+++ b/tests/ui/type_repetition_in_bounds.stderr
@@ -1,5 +1,5 @@
 error: this type has already been used as a bound predicate
-  --> $DIR/type_repetition_in_bounds.rs:8:5
+  --> $DIR/type_repetition_in_bounds.rs:9:5
    |
 LL |     T: Clone,
    |     ^^^^^^^^
@@ -12,7 +12,7 @@ LL | #![deny(clippy::type_repetition_in_bounds)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this type has already been used as a bound predicate
-  --> $DIR/type_repetition_in_bounds.rs:25:5
+  --> $DIR/type_repetition_in_bounds.rs:26:5
    |
 LL |     Self: Copy + Default + Ord,
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -20,7 +20,7 @@ LL |     Self: Copy + Default + Ord,
    = help: consider combining the bounds: `Self: Clone + Copy + Default + Ord`
 
 error: this type has already been used as a bound predicate
-  --> $DIR/type_repetition_in_bounds.rs:85:5
+  --> $DIR/type_repetition_in_bounds.rs:86:5
    |
 LL |     T: Clone,
    |     ^^^^^^^^
@@ -28,7 +28,7 @@ LL |     T: Clone,
    = help: consider combining the bounds: `T: ?Sized + Clone`
 
 error: this type has already been used as a bound predicate
-  --> $DIR/type_repetition_in_bounds.rs:90:5
+  --> $DIR/type_repetition_in_bounds.rs:91:5
    |
 LL |     T: ?Sized,
    |     ^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From c642cfe3bf245ffe34f6e994f0b359b267be5e3d Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Sat, 4 Feb 2023 19:10:19 +0100
Subject: Make `[clippy::dump]` support trait items

---
 clippy_lints/src/utils/dump_hir.rs | 13 +++++++++++++
 1 file changed, 13 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/dump_hir.rs b/clippy_lints/src/utils/dump_hir.rs
index 01efc527a8c..092041aecf2 100644
--- a/clippy_lints/src/utils/dump_hir.rs
+++ b/clippy_lints/src/utils/dump_hir.rs
@@ -1,4 +1,5 @@
 use clippy_utils::get_attr;
+use hir::TraitItem;
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -47,6 +48,18 @@ impl<'tcx> LateLintPass<'tcx> for DumpHir {
             println!("{stmt:#?}");
         }
     }
+
+    fn check_trait_item(&mut self, cx: &LateContext<'_>, item: &TraitItem<'_>) {
+        if has_attr(cx, item.hir_id()) {
+            println!("{item:#?}");
+        }
+    }
+
+    fn check_impl_item(&mut self, cx: &LateContext<'_>, item: &hir::ImplItem<'_>) {
+        if has_attr(cx, item.hir_id()) {
+            println!("{item:#?}");
+        }
+    }
 }
 
 fn has_attr(cx: &LateContext<'_>, hir_id: hir::HirId) -> bool {
-- 
cgit 1.4.1-3-g733a5


From 5546c82051e05f3f30733c9885f68f5bf9d1759a Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Sat, 4 Feb 2023 19:12:06 +0000
Subject: Negate suggestions when needed in `bool_assert_comparison`

---
 clippy_lints/src/bool_assert_comparison.rs |  53 +++++++-----
 tests/ui/bool_assert_comparison.fixed      |  38 +++++----
 tests/ui/bool_assert_comparison.rs         |  10 +++
 tests/ui/bool_assert_comparison.stderr     | 126 +++++++++++++++++++++++++----
 4 files changed, 176 insertions(+), 51 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/bool_assert_comparison.rs b/clippy_lints/src/bool_assert_comparison.rs
index 556fa579000..1d9096ea64d 100644
--- a/clippy_lints/src/bool_assert_comparison.rs
+++ b/clippy_lints/src/bool_assert_comparison.rs
@@ -1,5 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::macros::{find_assert_eq_args, root_macro_call_first_node};
+use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::{implements_trait, is_copy};
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
@@ -34,14 +35,16 @@ declare_clippy_lint! {
 
 declare_lint_pass!(BoolAssertComparison => [BOOL_ASSERT_COMPARISON]);
 
-fn is_bool_lit(e: &Expr<'_>) -> bool {
-    matches!(
-        e.kind,
-        ExprKind::Lit(Lit {
-            node: LitKind::Bool(_),
-            ..
-        })
-    ) && !e.span.from_expansion()
+fn extract_bool_lit(e: &Expr<'_>) -> Option<bool> {
+    if let ExprKind::Lit(Lit {
+        node: LitKind::Bool(b), ..
+    }) = e.kind
+        && !e.span.from_expansion()
+    {
+        Some(b)
+    } else {
+        None
+    }
 }
 
 fn is_impl_not_trait_with_bool_out<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
@@ -69,24 +72,23 @@ impl<'tcx> LateLintPass<'tcx> for BoolAssertComparison {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         let Some(macro_call) = root_macro_call_first_node(cx, expr) else { return };
         let macro_name = cx.tcx.item_name(macro_call.def_id);
-        if !matches!(
-            macro_name.as_str(),
-            "assert_eq" | "debug_assert_eq" | "assert_ne" | "debug_assert_ne"
-        ) {
-            return;
-        }
+        let eq_macro = match macro_name.as_str() {
+            "assert_eq" | "debug_assert_eq" => true,
+            "assert_ne" | "debug_assert_ne" => false,
+            _ => return,
+        };
         let Some ((a, b, _)) = find_assert_eq_args(cx, expr, macro_call.expn) else { return };
 
         let a_span = a.span.source_callsite();
         let b_span = b.span.source_callsite();
 
-        let (lit_span, non_lit_expr) = match (is_bool_lit(a), is_bool_lit(b)) {
-            // assert_eq!(true, b)
-            //            ^^^^^^
-            (true, false) => (a_span.until(b_span), b),
-            // assert_eq!(a, true)
-            //             ^^^^^^
-            (false, true) => (b_span.with_lo(a_span.hi()), a),
+        let (lit_span, bool_value, non_lit_expr) = match (extract_bool_lit(a), extract_bool_lit(b)) {
+            // assert_eq!(true/false, b)
+            //            ^^^^^^^^^^^^
+            (Some(bool_value), None) => (a_span.until(b_span), bool_value, b),
+            // assert_eq!(a, true/false)
+            //             ^^^^^^^^^^^^
+            (None, Some(bool_value)) => (b_span.with_lo(a_span.hi()), bool_value, a),
             // If there are two boolean arguments, we definitely don't understand
             // what's going on, so better leave things as is...
             //
@@ -121,9 +123,16 @@ impl<'tcx> LateLintPass<'tcx> for BoolAssertComparison {
                 // ^^^^^^^^^
                 let name_span = cx.sess().source_map().span_until_char(macro_call.span, '!');
 
+                let mut suggestions = vec![(name_span, non_eq_mac.to_string()), (lit_span, String::new())];
+
+                if bool_value ^ eq_macro {
+                    let Some(sugg) = Sugg::hir_opt(cx, non_lit_expr) else { return };
+                    suggestions.push((non_lit_expr.span, (!sugg).to_string()));
+                }
+
                 diag.multipart_suggestion(
                     format!("replace it with `{non_eq_mac}!(..)`"),
-                    vec![(name_span, non_eq_mac.to_string()), (lit_span, String::new())],
+                    suggestions,
                     Applicability::MachineApplicable,
                 );
             },
diff --git a/tests/ui/bool_assert_comparison.fixed b/tests/ui/bool_assert_comparison.fixed
index 95f35a61bb2..b8dd92906c8 100644
--- a/tests/ui/bool_assert_comparison.fixed
+++ b/tests/ui/bool_assert_comparison.fixed
@@ -86,7 +86,7 @@ fn main() {
     let b = ImplNotTraitWithBool;
 
     assert_eq!("a".len(), 1);
-    assert!("a".is_empty());
+    assert!(!"a".is_empty());
     assert!("".is_empty());
     assert!("".is_empty());
     assert_eq!(a!(), b!());
@@ -97,16 +97,16 @@ fn main() {
 
     assert_ne!("a".len(), 1);
     assert!("a".is_empty());
-    assert!("".is_empty());
-    assert!("".is_empty());
+    assert!(!"".is_empty());
+    assert!(!"".is_empty());
     assert_ne!(a!(), b!());
     assert_ne!(a!(), "".is_empty());
     assert_ne!("".is_empty(), b!());
     assert_ne!(a, true);
-    assert!(b);
+    assert!(!b);
 
     debug_assert_eq!("a".len(), 1);
-    debug_assert!("a".is_empty());
+    debug_assert!(!"a".is_empty());
     debug_assert!("".is_empty());
     debug_assert!("".is_empty());
     debug_assert_eq!(a!(), b!());
@@ -117,27 +117,27 @@ fn main() {
 
     debug_assert_ne!("a".len(), 1);
     debug_assert!("a".is_empty());
-    debug_assert!("".is_empty());
-    debug_assert!("".is_empty());
+    debug_assert!(!"".is_empty());
+    debug_assert!(!"".is_empty());
     debug_assert_ne!(a!(), b!());
     debug_assert_ne!(a!(), "".is_empty());
     debug_assert_ne!("".is_empty(), b!());
     debug_assert_ne!(a, true);
-    debug_assert!(b);
+    debug_assert!(!b);
 
     // assert with error messages
     assert_eq!("a".len(), 1, "tadam {}", 1);
     assert_eq!("a".len(), 1, "tadam {}", true);
-    assert!("a".is_empty(), "tadam {}", 1);
-    assert!("a".is_empty(), "tadam {}", true);
-    assert!("a".is_empty(), "tadam {}", true);
+    assert!(!"a".is_empty(), "tadam {}", 1);
+    assert!(!"a".is_empty(), "tadam {}", true);
+    assert!(!"a".is_empty(), "tadam {}", true);
     assert_eq!(a, true, "tadam {}", false);
 
     debug_assert_eq!("a".len(), 1, "tadam {}", 1);
     debug_assert_eq!("a".len(), 1, "tadam {}", true);
-    debug_assert!("a".is_empty(), "tadam {}", 1);
-    debug_assert!("a".is_empty(), "tadam {}", true);
-    debug_assert!("a".is_empty(), "tadam {}", true);
+    debug_assert!(!"a".is_empty(), "tadam {}", 1);
+    debug_assert!(!"a".is_empty(), "tadam {}", true);
+    debug_assert!(!"a".is_empty(), "tadam {}", true);
     debug_assert_eq!(a, true, "tadam {}", false);
 
     assert!(a!());
@@ -158,4 +158,14 @@ fn main() {
         }};
     }
     in_macro!(a);
+
+    assert!("".is_empty());
+    assert!("".is_empty());
+    assert!(!"requires negation".is_empty());
+    assert!(!"requires negation".is_empty());
+
+    debug_assert!("".is_empty());
+    debug_assert!("".is_empty());
+    debug_assert!(!"requires negation".is_empty());
+    debug_assert!(!"requires negation".is_empty());
 }
diff --git a/tests/ui/bool_assert_comparison.rs b/tests/ui/bool_assert_comparison.rs
index 88e7560b4f9..0a8ad34fda5 100644
--- a/tests/ui/bool_assert_comparison.rs
+++ b/tests/ui/bool_assert_comparison.rs
@@ -158,4 +158,14 @@ fn main() {
         }};
     }
     in_macro!(a);
+
+    assert_eq!("".is_empty(), true);
+    assert_ne!("".is_empty(), false);
+    assert_ne!("requires negation".is_empty(), true);
+    assert_eq!("requires negation".is_empty(), false);
+
+    debug_assert_eq!("".is_empty(), true);
+    debug_assert_ne!("".is_empty(), false);
+    debug_assert_ne!("requires negation".is_empty(), true);
+    debug_assert_eq!("requires negation".is_empty(), false);
 }
diff --git a/tests/ui/bool_assert_comparison.stderr b/tests/ui/bool_assert_comparison.stderr
index 3d9f8573e61..89cefc95a9f 100644
--- a/tests/ui/bool_assert_comparison.stderr
+++ b/tests/ui/bool_assert_comparison.stderr
@@ -8,7 +8,7 @@ LL |     assert_eq!("a".is_empty(), false);
 help: replace it with `assert!(..)`
    |
 LL -     assert_eq!("a".is_empty(), false);
-LL +     assert!("a".is_empty());
+LL +     assert!(!"a".is_empty());
    |
 
 error: used `assert_eq!` with a literal bool
@@ -68,7 +68,7 @@ LL |     assert_ne!("".is_empty(), true);
 help: replace it with `assert!(..)`
    |
 LL -     assert_ne!("".is_empty(), true);
-LL +     assert!("".is_empty());
+LL +     assert!(!"".is_empty());
    |
 
 error: used `assert_ne!` with a literal bool
@@ -80,7 +80,7 @@ LL |     assert_ne!(true, "".is_empty());
 help: replace it with `assert!(..)`
    |
 LL -     assert_ne!(true, "".is_empty());
-LL +     assert!("".is_empty());
+LL +     assert!(!"".is_empty());
    |
 
 error: used `assert_ne!` with a literal bool
@@ -92,7 +92,7 @@ LL |     assert_ne!(b, true);
 help: replace it with `assert!(..)`
    |
 LL -     assert_ne!(b, true);
-LL +     assert!(b);
+LL +     assert!(!b);
    |
 
 error: used `debug_assert_eq!` with a literal bool
@@ -104,7 +104,7 @@ LL |     debug_assert_eq!("a".is_empty(), false);
 help: replace it with `debug_assert!(..)`
    |
 LL -     debug_assert_eq!("a".is_empty(), false);
-LL +     debug_assert!("a".is_empty());
+LL +     debug_assert!(!"a".is_empty());
    |
 
 error: used `debug_assert_eq!` with a literal bool
@@ -164,7 +164,7 @@ LL |     debug_assert_ne!("".is_empty(), true);
 help: replace it with `debug_assert!(..)`
    |
 LL -     debug_assert_ne!("".is_empty(), true);
-LL +     debug_assert!("".is_empty());
+LL +     debug_assert!(!"".is_empty());
    |
 
 error: used `debug_assert_ne!` with a literal bool
@@ -176,7 +176,7 @@ LL |     debug_assert_ne!(true, "".is_empty());
 help: replace it with `debug_assert!(..)`
    |
 LL -     debug_assert_ne!(true, "".is_empty());
-LL +     debug_assert!("".is_empty());
+LL +     debug_assert!(!"".is_empty());
    |
 
 error: used `debug_assert_ne!` with a literal bool
@@ -188,7 +188,7 @@ LL |     debug_assert_ne!(b, true);
 help: replace it with `debug_assert!(..)`
    |
 LL -     debug_assert_ne!(b, true);
-LL +     debug_assert!(b);
+LL +     debug_assert!(!b);
    |
 
 error: used `assert_eq!` with a literal bool
@@ -200,7 +200,7 @@ LL |     assert_eq!("a".is_empty(), false, "tadam {}", 1);
 help: replace it with `assert!(..)`
    |
 LL -     assert_eq!("a".is_empty(), false, "tadam {}", 1);
-LL +     assert!("a".is_empty(), "tadam {}", 1);
+LL +     assert!(!"a".is_empty(), "tadam {}", 1);
    |
 
 error: used `assert_eq!` with a literal bool
@@ -212,7 +212,7 @@ LL |     assert_eq!("a".is_empty(), false, "tadam {}", true);
 help: replace it with `assert!(..)`
    |
 LL -     assert_eq!("a".is_empty(), false, "tadam {}", true);
-LL +     assert!("a".is_empty(), "tadam {}", true);
+LL +     assert!(!"a".is_empty(), "tadam {}", true);
    |
 
 error: used `assert_eq!` with a literal bool
@@ -224,7 +224,7 @@ LL |     assert_eq!(false, "a".is_empty(), "tadam {}", true);
 help: replace it with `assert!(..)`
    |
 LL -     assert_eq!(false, "a".is_empty(), "tadam {}", true);
-LL +     assert!("a".is_empty(), "tadam {}", true);
+LL +     assert!(!"a".is_empty(), "tadam {}", true);
    |
 
 error: used `debug_assert_eq!` with a literal bool
@@ -236,7 +236,7 @@ LL |     debug_assert_eq!("a".is_empty(), false, "tadam {}", 1);
 help: replace it with `debug_assert!(..)`
    |
 LL -     debug_assert_eq!("a".is_empty(), false, "tadam {}", 1);
-LL +     debug_assert!("a".is_empty(), "tadam {}", 1);
+LL +     debug_assert!(!"a".is_empty(), "tadam {}", 1);
    |
 
 error: used `debug_assert_eq!` with a literal bool
@@ -248,7 +248,7 @@ LL |     debug_assert_eq!("a".is_empty(), false, "tadam {}", true);
 help: replace it with `debug_assert!(..)`
    |
 LL -     debug_assert_eq!("a".is_empty(), false, "tadam {}", true);
-LL +     debug_assert!("a".is_empty(), "tadam {}", true);
+LL +     debug_assert!(!"a".is_empty(), "tadam {}", true);
    |
 
 error: used `debug_assert_eq!` with a literal bool
@@ -260,7 +260,7 @@ LL |     debug_assert_eq!(false, "a".is_empty(), "tadam {}", true);
 help: replace it with `debug_assert!(..)`
    |
 LL -     debug_assert_eq!(false, "a".is_empty(), "tadam {}", true);
-LL +     debug_assert!("a".is_empty(), "tadam {}", true);
+LL +     debug_assert!(!"a".is_empty(), "tadam {}", true);
    |
 
 error: used `assert_eq!` with a literal bool
@@ -299,5 +299,101 @@ LL -     renamed!(b, true);
 LL +     debug_assert!(b);
    |
 
-error: aborting due to 25 previous errors
+error: used `assert_eq!` with a literal bool
+  --> $DIR/bool_assert_comparison.rs:162:5
+   |
+LL |     assert_eq!("".is_empty(), true);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: replace it with `assert!(..)`
+   |
+LL -     assert_eq!("".is_empty(), true);
+LL +     assert!("".is_empty());
+   |
+
+error: used `assert_ne!` with a literal bool
+  --> $DIR/bool_assert_comparison.rs:163:5
+   |
+LL |     assert_ne!("".is_empty(), false);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: replace it with `assert!(..)`
+   |
+LL -     assert_ne!("".is_empty(), false);
+LL +     assert!("".is_empty());
+   |
+
+error: used `assert_ne!` with a literal bool
+  --> $DIR/bool_assert_comparison.rs:164:5
+   |
+LL |     assert_ne!("requires negation".is_empty(), true);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: replace it with `assert!(..)`
+   |
+LL -     assert_ne!("requires negation".is_empty(), true);
+LL +     assert!(!"requires negation".is_empty());
+   |
+
+error: used `assert_eq!` with a literal bool
+  --> $DIR/bool_assert_comparison.rs:165:5
+   |
+LL |     assert_eq!("requires negation".is_empty(), false);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: replace it with `assert!(..)`
+   |
+LL -     assert_eq!("requires negation".is_empty(), false);
+LL +     assert!(!"requires negation".is_empty());
+   |
+
+error: used `debug_assert_eq!` with a literal bool
+  --> $DIR/bool_assert_comparison.rs:167:5
+   |
+LL |     debug_assert_eq!("".is_empty(), true);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: replace it with `debug_assert!(..)`
+   |
+LL -     debug_assert_eq!("".is_empty(), true);
+LL +     debug_assert!("".is_empty());
+   |
+
+error: used `debug_assert_ne!` with a literal bool
+  --> $DIR/bool_assert_comparison.rs:168:5
+   |
+LL |     debug_assert_ne!("".is_empty(), false);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: replace it with `debug_assert!(..)`
+   |
+LL -     debug_assert_ne!("".is_empty(), false);
+LL +     debug_assert!("".is_empty());
+   |
+
+error: used `debug_assert_ne!` with a literal bool
+  --> $DIR/bool_assert_comparison.rs:169:5
+   |
+LL |     debug_assert_ne!("requires negation".is_empty(), true);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: replace it with `debug_assert!(..)`
+   |
+LL -     debug_assert_ne!("requires negation".is_empty(), true);
+LL +     debug_assert!(!"requires negation".is_empty());
+   |
+
+error: used `debug_assert_eq!` with a literal bool
+  --> $DIR/bool_assert_comparison.rs:170:5
+   |
+LL |     debug_assert_eq!("requires negation".is_empty(), false);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: replace it with `debug_assert!(..)`
+   |
+LL -     debug_assert_eq!("requires negation".is_empty(), false);
+LL +     debug_assert!(!"requires negation".is_empty());
+   |
+
+error: aborting due to 33 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 1fb42daf11e68393f2cf9eb8e67e4b2779a4bf5e Mon Sep 17 00:00:00 2001
From: Kartavya Vashishtha <sendtokartavya@gmail.com>
Date: Sun, 5 Feb 2023 01:05:31 +0530
Subject: use span_suggestions to suggest both intents

---
 clippy_lints/src/methods/suspicious_to_owned.rs | 16 +++++++++++-----
 1 file changed, 11 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/suspicious_to_owned.rs b/clippy_lints/src/methods/suspicious_to_owned.rs
index fe88fa41fd9..1adc7b7453e 100644
--- a/clippy_lints/src/methods/suspicious_to_owned.rs
+++ b/clippy_lints/src/methods/suspicious_to_owned.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::is_diag_trait_item;
 use clippy_utils::source::snippet_with_context;
 use if_chain::if_chain;
@@ -17,19 +17,25 @@ pub fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr<'_>) -
         let input_type = cx.typeck_results().expr_ty(expr);
         if let ty::Adt(adt, _) = cx.typeck_results().expr_ty(expr).kind();
         if cx.tcx.is_diagnostic_item(sym::Cow, adt.did());
+
         then {
             let mut app = Applicability::MaybeIncorrect;
             let recv_snip = snippet_with_context(cx, recv.span, expr.span.ctxt(), "..", &mut app).0;
-            span_lint_and_sugg(
+            span_lint_and_then(
                 cx,
                 SUSPICIOUS_TO_OWNED,
                 expr.span,
                 &with_forced_trimmed_paths!(format!(
                     "this `to_owned` call clones the {input_type} itself and does not cause the {input_type} contents to become owned"
                 )),
-                "consider using, depending on intent",
-                format!("{recv_snip}.clone()` or `{recv_snip}.into_owned()"),
-                app,
+                |diag| {
+                    diag.span_suggestions(
+                        expr.span,
+                        "depending on intent, either make the Cow an Owned variant or clone the Cow itself",
+                        [format!("{recv_snip}.into_owned()"), format!("{recv_snip}.clone()")],
+                        Applicability::Unspecified
+                    );
+                }
             );
             return true;
         }
-- 
cgit 1.4.1-3-g733a5


From 63a57ee1c381ec8ee0dec13213619113f030d773 Mon Sep 17 00:00:00 2001
From: Kartavya Vashishtha <sendtokartavya@gmail.com>
Date: Sun, 5 Feb 2023 01:50:44 +0530
Subject: retain applicability

---
 clippy_lints/src/methods/suspicious_to_owned.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/suspicious_to_owned.rs b/clippy_lints/src/methods/suspicious_to_owned.rs
index 1adc7b7453e..62eeb3f7a4e 100644
--- a/clippy_lints/src/methods/suspicious_to_owned.rs
+++ b/clippy_lints/src/methods/suspicious_to_owned.rs
@@ -33,7 +33,7 @@ pub fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr<'_>) -
                         expr.span,
                         "depending on intent, either make the Cow an Owned variant or clone the Cow itself",
                         [format!("{recv_snip}.into_owned()"), format!("{recv_snip}.clone()")],
-                        Applicability::Unspecified
+                        app
                     );
                 }
             );
-- 
cgit 1.4.1-3-g733a5


From 2fc1693cd577eb8af48b75518945a71f1652711c Mon Sep 17 00:00:00 2001
From: Kartavya Vashishtha <sendtokartavya@gmail.com>
Date: Mon, 6 Feb 2023 21:34:35 +0530
Subject: split suggestions into two separate suggestions

---
 clippy_lints/src/methods/suspicious_to_owned.rs | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/suspicious_to_owned.rs b/clippy_lints/src/methods/suspicious_to_owned.rs
index 62eeb3f7a4e..e818f1892e5 100644
--- a/clippy_lints/src/methods/suspicious_to_owned.rs
+++ b/clippy_lints/src/methods/suspicious_to_owned.rs
@@ -29,10 +29,16 @@ pub fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr<'_>) -
                     "this `to_owned` call clones the {input_type} itself and does not cause the {input_type} contents to become owned"
                 )),
                 |diag| {
-                    diag.span_suggestions(
+                    diag.span_suggestion(
                         expr.span,
-                        "depending on intent, either make the Cow an Owned variant or clone the Cow itself",
-                        [format!("{recv_snip}.into_owned()"), format!("{recv_snip}.clone()")],
+                        "depending on intent, either make the Cow an Owned variant",
+                        format!("{recv_snip}.into_owned()"),
+                        app
+                    );
+                    diag.span_suggestion(
+                        expr.span,
+                        "or clone the Cow itself",
+                        format!("{recv_snip}.clone()"),
                         app
                     );
                 }
-- 
cgit 1.4.1-3-g733a5


From c6692a8b4284a2e033f620b71a2ad6a88833bb05 Mon Sep 17 00:00:00 2001
From: Christian Poveda <git@pvdrz.com>
Date: Mon, 6 Feb 2023 14:21:37 -0500
Subject: Add configuration to lint missing docs of `pub(crate)` items

---
 clippy_lints/src/lib.rs                            |  3 +-
 clippy_lints/src/missing_doc.rs                    | 16 +++++++++--
 clippy_lints/src/utils/conf.rs                     |  4 +++
 tests/ui-toml/pub_crate_missing_docs/clippy.toml   |  1 +
 .../pub_crate_missing_doc.rs                       | 32 ++++++++++++++++++++++
 .../pub_crate_missing_doc.stderr                   | 22 +++++++++++++++
 6 files changed, 74 insertions(+), 4 deletions(-)
 create mode 100644 tests/ui-toml/pub_crate_missing_docs/clippy.toml
 create mode 100644 tests/ui-toml/pub_crate_missing_docs/pub_crate_missing_doc.rs
 create mode 100644 tests/ui-toml/pub_crate_missing_docs/pub_crate_missing_doc.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 2f5c4adca9f..f5c417fffa8 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -665,12 +665,13 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         ))
     });
     let doc_valid_idents = conf.doc_valid_idents.iter().cloned().collect::<FxHashSet<_>>();
+    let only_check_missing_docs_in_crate_items = conf.only_check_missing_docs_in_crate_items;
     store.register_late_pass(move |_| Box::new(doc::DocMarkdown::new(doc_valid_idents.clone())));
     store.register_late_pass(|_| Box::new(neg_multiply::NegMultiply));
     store.register_late_pass(|_| Box::new(mem_forget::MemForget));
     store.register_late_pass(|_| Box::new(let_if_seq::LetIfSeq));
     store.register_late_pass(|_| Box::new(mixed_read_write_in_expression::EvalOrderDependence));
-    store.register_late_pass(|_| Box::new(missing_doc::MissingDoc::new()));
+    store.register_late_pass(move |_| Box::new(missing_doc::MissingDoc::new(only_check_missing_docs_in_crate_items)));
     store.register_late_pass(|_| Box::new(missing_inline::MissingInline));
     store.register_late_pass(move |_| Box::new(exhaustive_items::ExhaustiveItems));
     store.register_late_pass(|_| Box::new(match_result_ok::MatchResultOk));
diff --git a/clippy_lints/src/missing_doc.rs b/clippy_lints/src/missing_doc.rs
index 9942e8115b7..3bce54bf2e9 100644
--- a/clippy_lints/src/missing_doc.rs
+++ b/clippy_lints/src/missing_doc.rs
@@ -12,7 +12,7 @@ use if_chain::if_chain;
 use rustc_ast::ast::{self, MetaItem, MetaItemKind};
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass, LintContext};
-use rustc_middle::ty::DefIdTree;
+use rustc_middle::ty::{DefIdTree, Visibility};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::def_id::CRATE_DEF_ID;
 use rustc_span::source_map::Span;
@@ -35,6 +35,8 @@ declare_clippy_lint! {
 }
 
 pub struct MissingDoc {
+    /// FIXME: docs
+    crate_items_only: bool,
     /// Stack of whether #[doc(hidden)] is set
     /// at each level which has lint attributes.
     doc_hidden_stack: Vec<bool>,
@@ -43,14 +45,15 @@ pub struct MissingDoc {
 impl Default for MissingDoc {
     #[must_use]
     fn default() -> Self {
-        Self::new()
+        Self::new(false)
     }
 }
 
 impl MissingDoc {
     #[must_use]
-    pub fn new() -> Self {
+    pub fn new(crate_items_only: bool) -> Self {
         Self {
+            crate_items_only,
             doc_hidden_stack: vec![false],
         }
     }
@@ -128,6 +131,13 @@ impl<'tcx> LateLintPass<'tcx> for MissingDoc {
     }
 
     fn check_item(&mut self, cx: &LateContext<'tcx>, it: &'tcx hir::Item<'_>) {
+        if self.crate_items_only {
+            let vis = cx.tcx.visibility(it.owner_id.to_def_id());
+            if vis != Visibility::Public && vis != Visibility::Restricted(CRATE_DEF_ID.into()) {
+                return;
+            }
+        }
+
         match it.kind {
             hir::ItemKind::Fn(..) => {
                 // ignore main()
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 1d78c7cfae0..f81965b6432 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -454,6 +454,10 @@ define_Conf! {
     /// configuration will cause restriction lints to trigger even
     /// if no suggestion can be made.
     (suppress_restriction_lint_in_const: bool = false),
+    /// Lint: MISSING_DOCS_IN_PRIVATE_ITEMS.
+    ///
+    /// FIXME: docs
+    (only_check_missing_docs_in_crate_items: bool = false),
 }
 
 /// Search for the configuration file.
diff --git a/tests/ui-toml/pub_crate_missing_docs/clippy.toml b/tests/ui-toml/pub_crate_missing_docs/clippy.toml
new file mode 100644
index 00000000000..a2f1fc27da3
--- /dev/null
+++ b/tests/ui-toml/pub_crate_missing_docs/clippy.toml
@@ -0,0 +1 @@
+only-check-missing-docs-in-crate-items = true
diff --git a/tests/ui-toml/pub_crate_missing_docs/pub_crate_missing_doc.rs b/tests/ui-toml/pub_crate_missing_docs/pub_crate_missing_doc.rs
new file mode 100644
index 00000000000..8eef92d20bf
--- /dev/null
+++ b/tests/ui-toml/pub_crate_missing_docs/pub_crate_missing_doc.rs
@@ -0,0 +1,32 @@
+//! this is crate
+#![warn(clippy::missing_docs_in_private_items)]
+
+/// this is mod
+mod my_mod {
+    /// some docs
+    fn priv_with_docs() {}
+    fn priv_no_docs() {}
+    /// some docs
+    pub(crate) fn crate_with_docs() {}
+    pub(crate) fn crate_no_docs() {}
+    /// some docs
+    pub(super) fn super_with_docs() {}
+    pub(super) fn super_no_docs() {}
+
+    mod my_sub {
+        /// some docs
+        fn sub_priv_with_docs() {}
+        fn sub_priv_no_docs() {}
+        /// some docs
+        pub(crate) fn sub_crate_with_docs() {}
+        pub(crate) fn sub_crate_no_docs() {}
+        /// some docs
+        pub(super) fn sub_super_with_docs() {}
+        pub(super) fn sub_super_no_docs() {}
+    }
+}
+
+fn main() {
+    my_mod::crate_with_docs();
+    my_mod::crate_no_docs();
+}
diff --git a/tests/ui-toml/pub_crate_missing_docs/pub_crate_missing_doc.stderr b/tests/ui-toml/pub_crate_missing_docs/pub_crate_missing_doc.stderr
new file mode 100644
index 00000000000..954ef2382f7
--- /dev/null
+++ b/tests/ui-toml/pub_crate_missing_docs/pub_crate_missing_doc.stderr
@@ -0,0 +1,22 @@
+error: missing documentation for a function
+  --> $DIR/pub_crate_missing_doc.rs:11:5
+   |
+LL |     pub(crate) fn crate_no_docs() {}
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::missing-docs-in-private-items` implied by `-D warnings`
+
+error: missing documentation for a function
+  --> $DIR/pub_crate_missing_doc.rs:14:5
+   |
+LL |     pub(super) fn super_no_docs() {}
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: missing documentation for a function
+  --> $DIR/pub_crate_missing_doc.rs:22:9
+   |
+LL |         pub(crate) fn sub_crate_no_docs() {}
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 3 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From e2e23c0045d94cc0d509cbb3c915faae74844ea8 Mon Sep 17 00:00:00 2001
From: Christian Poveda <git@pvdrz.com>
Date: Thu, 9 Feb 2023 16:41:45 -0500
Subject: Add docs and update tests

---
 clippy_lints/src/lib.rs                            |  4 +--
 clippy_lints/src/missing_doc.rs                    | 30 ++++++++++++----------
 clippy_lints/src/utils/conf.rs                     |  4 +--
 tests/ui-toml/pub_crate_missing_docs/clippy.toml   |  2 +-
 .../pub_crate_missing_doc.rs                       | 19 ++++++++++++++
 .../pub_crate_missing_doc.stderr                   | 26 ++++++++++++++++++-
 .../pub_crate_missing_doc.stdout                   |  0
 .../toml_unknown_key/conf_unknown_key.stderr       |  2 +-
 8 files changed, 66 insertions(+), 21 deletions(-)
 create mode 100644 tests/ui-toml/pub_crate_missing_docs/pub_crate_missing_doc.stdout

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index f5c417fffa8..2d04118c694 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -665,13 +665,13 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         ))
     });
     let doc_valid_idents = conf.doc_valid_idents.iter().cloned().collect::<FxHashSet<_>>();
-    let only_check_missing_docs_in_crate_items = conf.only_check_missing_docs_in_crate_items;
+    let missing_docs_in_crate_items = conf.missing_docs_in_crate_items;
     store.register_late_pass(move |_| Box::new(doc::DocMarkdown::new(doc_valid_idents.clone())));
     store.register_late_pass(|_| Box::new(neg_multiply::NegMultiply));
     store.register_late_pass(|_| Box::new(mem_forget::MemForget));
     store.register_late_pass(|_| Box::new(let_if_seq::LetIfSeq));
     store.register_late_pass(|_| Box::new(mixed_read_write_in_expression::EvalOrderDependence));
-    store.register_late_pass(move |_| Box::new(missing_doc::MissingDoc::new(only_check_missing_docs_in_crate_items)));
+    store.register_late_pass(move |_| Box::new(missing_doc::MissingDoc::new(missing_docs_in_crate_items)));
     store.register_late_pass(|_| Box::new(missing_inline::MissingInline));
     store.register_late_pass(move |_| Box::new(exhaustive_items::ExhaustiveItems));
     store.register_late_pass(|_| Box::new(match_result_ok::MatchResultOk));
diff --git a/clippy_lints/src/missing_doc.rs b/clippy_lints/src/missing_doc.rs
index 3bce54bf2e9..a5d8a500cca 100644
--- a/clippy_lints/src/missing_doc.rs
+++ b/clippy_lints/src/missing_doc.rs
@@ -8,6 +8,7 @@
 use clippy_utils::attrs::is_doc_hidden;
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::is_from_proc_macro;
+use hir::def_id::LocalDefId;
 use if_chain::if_chain;
 use rustc_ast::ast::{self, MetaItem, MetaItemKind};
 use rustc_hir as hir;
@@ -35,7 +36,7 @@ declare_clippy_lint! {
 }
 
 pub struct MissingDoc {
-    /// FIXME: docs
+    /// Whether to only check for missing docs in `pub(crate)` items.
     crate_items_only: bool,
     /// Stack of whether #[doc(hidden)] is set
     /// at each level which has lint attributes.
@@ -79,6 +80,7 @@ impl MissingDoc {
     fn check_missing_docs_attrs(
         &self,
         cx: &LateContext<'_>,
+        def_id: LocalDefId,
         attrs: &[ast::Attribute],
         sp: Span,
         article: &'static str,
@@ -99,6 +101,13 @@ impl MissingDoc {
             return;
         }
 
+        if self.crate_items_only && def_id != CRATE_DEF_ID {
+            let vis = cx.tcx.visibility(def_id);
+            if vis != Visibility::Public && vis != Visibility::Restricted(CRATE_DEF_ID.into()) {
+                return;
+            }
+        }
+
         let has_doc = attrs
             .iter()
             .any(|a| a.doc_str().is_some() || Self::has_include(a.meta()));
@@ -127,17 +136,10 @@ impl<'tcx> LateLintPass<'tcx> for MissingDoc {
 
     fn check_crate(&mut self, cx: &LateContext<'tcx>) {
         let attrs = cx.tcx.hir().attrs(hir::CRATE_HIR_ID);
-        self.check_missing_docs_attrs(cx, attrs, cx.tcx.def_span(CRATE_DEF_ID), "the", "crate");
+        self.check_missing_docs_attrs(cx, CRATE_DEF_ID, attrs, cx.tcx.def_span(CRATE_DEF_ID), "the", "crate");
     }
 
     fn check_item(&mut self, cx: &LateContext<'tcx>, it: &'tcx hir::Item<'_>) {
-        if self.crate_items_only {
-            let vis = cx.tcx.visibility(it.owner_id.to_def_id());
-            if vis != Visibility::Public && vis != Visibility::Restricted(CRATE_DEF_ID.into()) {
-                return;
-            }
-        }
-
         match it.kind {
             hir::ItemKind::Fn(..) => {
                 // ignore main()
@@ -170,7 +172,7 @@ impl<'tcx> LateLintPass<'tcx> for MissingDoc {
 
         let attrs = cx.tcx.hir().attrs(it.hir_id());
         if !is_from_proc_macro(cx, it) {
-            self.check_missing_docs_attrs(cx, attrs, it.span, article, desc);
+            self.check_missing_docs_attrs(cx, it.owner_id.def_id, attrs, it.span, article, desc);
         }
     }
 
@@ -179,7 +181,7 @@ impl<'tcx> LateLintPass<'tcx> for MissingDoc {
 
         let attrs = cx.tcx.hir().attrs(trait_item.hir_id());
         if !is_from_proc_macro(cx, trait_item) {
-            self.check_missing_docs_attrs(cx, attrs, trait_item.span, article, desc);
+            self.check_missing_docs_attrs(cx, trait_item.owner_id.def_id, attrs, trait_item.span, article, desc);
         }
     }
 
@@ -196,7 +198,7 @@ impl<'tcx> LateLintPass<'tcx> for MissingDoc {
         let (article, desc) = cx.tcx.article_and_description(impl_item.owner_id.to_def_id());
         let attrs = cx.tcx.hir().attrs(impl_item.hir_id());
         if !is_from_proc_macro(cx, impl_item) {
-            self.check_missing_docs_attrs(cx, attrs, impl_item.span, article, desc);
+            self.check_missing_docs_attrs(cx, impl_item.owner_id.def_id, attrs, impl_item.span, article, desc);
         }
     }
 
@@ -204,7 +206,7 @@ impl<'tcx> LateLintPass<'tcx> for MissingDoc {
         if !sf.is_positional() {
             let attrs = cx.tcx.hir().attrs(sf.hir_id);
             if !is_from_proc_macro(cx, sf) {
-                self.check_missing_docs_attrs(cx, attrs, sf.span, "a", "struct field");
+                self.check_missing_docs_attrs(cx, sf.def_id, attrs, sf.span, "a", "struct field");
             }
         }
     }
@@ -212,7 +214,7 @@ impl<'tcx> LateLintPass<'tcx> for MissingDoc {
     fn check_variant(&mut self, cx: &LateContext<'tcx>, v: &'tcx hir::Variant<'_>) {
         let attrs = cx.tcx.hir().attrs(v.hir_id);
         if !is_from_proc_macro(cx, v) {
-            self.check_missing_docs_attrs(cx, attrs, v.span, "a", "variant");
+            self.check_missing_docs_attrs(cx, v.def_id, attrs, v.span, "a", "variant");
         }
     }
 }
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index f81965b6432..86a17a40930 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -456,8 +456,8 @@ define_Conf! {
     (suppress_restriction_lint_in_const: bool = false),
     /// Lint: MISSING_DOCS_IN_PRIVATE_ITEMS.
     ///
-    /// FIXME: docs
-    (only_check_missing_docs_in_crate_items: bool = false),
+    /// Whether to **only** check for missing docmuentation in `pub(crate)` items.
+    (missing_docs_in_crate_items: bool = false),
 }
 
 /// Search for the configuration file.
diff --git a/tests/ui-toml/pub_crate_missing_docs/clippy.toml b/tests/ui-toml/pub_crate_missing_docs/clippy.toml
index a2f1fc27da3..ec210a98783 100644
--- a/tests/ui-toml/pub_crate_missing_docs/clippy.toml
+++ b/tests/ui-toml/pub_crate_missing_docs/clippy.toml
@@ -1 +1 @@
-only-check-missing-docs-in-crate-items = true
+missing-docs-in-crate-items = true
diff --git a/tests/ui-toml/pub_crate_missing_docs/pub_crate_missing_doc.rs b/tests/ui-toml/pub_crate_missing_docs/pub_crate_missing_doc.rs
index 8eef92d20bf..f2edb737d59 100644
--- a/tests/ui-toml/pub_crate_missing_docs/pub_crate_missing_doc.rs
+++ b/tests/ui-toml/pub_crate_missing_docs/pub_crate_missing_doc.rs
@@ -24,6 +24,25 @@ mod my_mod {
         pub(super) fn sub_super_with_docs() {}
         pub(super) fn sub_super_no_docs() {}
     }
+
+    /// some docs
+    pub(crate) struct CrateStructWithDocs {
+        /// some docs
+        pub(crate) crate_field_with_docs: (),
+        pub(crate) crate_field_no_docs: (),
+        /// some docs
+        priv_field_with_docs: (),
+        priv_field_no_docs: (),
+    }
+
+    pub(crate) struct CrateStructNoDocs {
+        /// some docs
+        pub(crate) crate_field_with_docs: (),
+        pub(crate) crate_field_no_docs: (),
+        /// some docs
+        priv_field_with_docs: (),
+        priv_field_no_docs: (),
+    }
 }
 
 fn main() {
diff --git a/tests/ui-toml/pub_crate_missing_docs/pub_crate_missing_doc.stderr b/tests/ui-toml/pub_crate_missing_docs/pub_crate_missing_doc.stderr
index 954ef2382f7..89927abd87b 100644
--- a/tests/ui-toml/pub_crate_missing_docs/pub_crate_missing_doc.stderr
+++ b/tests/ui-toml/pub_crate_missing_docs/pub_crate_missing_doc.stderr
@@ -18,5 +18,29 @@ error: missing documentation for a function
 LL |         pub(crate) fn sub_crate_no_docs() {}
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 3 previous errors
+error: missing documentation for a struct field
+  --> $DIR/pub_crate_missing_doc.rs:32:9
+   |
+LL |         pub(crate) crate_field_no_docs: (),
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: missing documentation for a struct
+  --> $DIR/pub_crate_missing_doc.rs:38:5
+   |
+LL | /     pub(crate) struct CrateStructNoDocs {
+LL | |         /// some docs
+LL | |         pub(crate) crate_field_with_docs: (),
+LL | |         pub(crate) crate_field_no_docs: (),
+...  |
+LL | |         priv_field_no_docs: (),
+LL | |     }
+   | |_____^
+
+error: missing documentation for a struct field
+  --> $DIR/pub_crate_missing_doc.rs:41:9
+   |
+LL |         pub(crate) crate_field_no_docs: (),
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 6 previous errors
 
diff --git a/tests/ui-toml/pub_crate_missing_docs/pub_crate_missing_doc.stdout b/tests/ui-toml/pub_crate_missing_docs/pub_crate_missing_doc.stdout
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
index f4815df19ca..6a246afac76 100644
--- a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
+++ b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
@@ -33,8 +33,8 @@ error: error reading Clippy's configuration file `$DIR/clippy.toml`: unknown fie
            max-struct-bools
            max-suggested-slice-pattern-length
            max-trait-bounds
+           missing-docs-in-crate-items
            msrv
-           only-check-missing-docs-in-crate-items
            pass-by-value-size-limit
            single-char-binding-names-threshold
            standard-macro-braces
-- 
cgit 1.4.1-3-g733a5


From cc19fbe177eea84aac436a35889788b2ad0f1c6a Mon Sep 17 00:00:00 2001
From: Christian Poveda <git@pvdrz.com>
Date: Thu, 9 Feb 2023 16:53:34 -0500
Subject: update metadata

---
 book/src/lint_configuration.md | 9 +++++++++
 clippy_lints/src/utils/conf.rs | 2 +-
 2 files changed, 10 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/book/src/lint_configuration.md b/book/src/lint_configuration.md
index 32e8e218c40..46bed62dfc9 100644
--- a/book/src/lint_configuration.md
+++ b/book/src/lint_configuration.md
@@ -53,6 +53,7 @@ Please use that command to update the file and do not edit it by hand.
 | [ignore-interior-mutability](#ignore-interior-mutability) | `["bytes::Bytes"]` |
 | [allow-mixed-uninlined-format-args](#allow-mixed-uninlined-format-args) | `true` |
 | [suppress-restriction-lint-in-const](#suppress-restriction-lint-in-const) | `false` |
+| [missing-docs-in-crate-items](#missing-docs-in-crate-items) | `false` |
 
 ### arithmetic-side-effects-allowed
 Suppress checking of the passed type names in all types of operations.
@@ -540,4 +541,12 @@ if no suggestion can be made.
 * [indexing_slicing](https://rust-lang.github.io/rust-clippy/master/index.html#indexing_slicing)
 
 
+### missing-docs-in-crate-items
+Whether to **only** check for missing documentation in `pub(crate)` items.
+
+**Default Value:** `false` (`bool`)
+
+* [missing_docs_in_private_items](https://rust-lang.github.io/rust-clippy/master/index.html#missing_docs_in_private_items)
+
+
 
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 86a17a40930..ae35ceebc55 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -456,7 +456,7 @@ define_Conf! {
     (suppress_restriction_lint_in_const: bool = false),
     /// Lint: MISSING_DOCS_IN_PRIVATE_ITEMS.
     ///
-    /// Whether to **only** check for missing docmuentation in `pub(crate)` items.
+    /// Whether to **only** check for missing documentation in `pub(crate)` items.
     (missing_docs_in_crate_items: bool = false),
 }
 
-- 
cgit 1.4.1-3-g733a5


From 179c037643fda44f7874816c0030ad83798bdad3 Mon Sep 17 00:00:00 2001
From: DevAccentor <dev.accentor@gmail.com>
Date: Sat, 4 Jun 2022 16:48:35 +0200
Subject: improve almost swap to look for let statement

---
 clippy_lints/src/swap.rs       | 74 ++++++++++++++++++++++++++++++++++++++++++
 tests/ui/almost_swapped.rs     | 32 ++++++++++++++++++
 tests/ui/almost_swapped.stderr | 30 +++++++++++++++++
 3 files changed, 136 insertions(+)
 create mode 100644 tests/ui/almost_swapped.rs
 create mode 100644 tests/ui/almost_swapped.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/swap.rs b/clippy_lints/src/swap.rs
index 17e9cc5f6b7..5c408a73a55 100644
--- a/clippy_lints/src/swap.rs
+++ b/clippy_lints/src/swap.rs
@@ -172,6 +172,7 @@ fn check_manual_swap(cx: &LateContext<'_>, block: &Block<'_>) {
     }
 }
 
+#[allow(clippy::too_many_lines)]
 /// Implementation of the `ALMOST_SWAPPED` lint.
 fn check_suspicious_swap(cx: &LateContext<'_>, block: &Block<'_>) {
     for w in block.stmts.windows(2) {
@@ -220,6 +221,79 @@ fn check_suspicious_swap(cx: &LateContext<'_>, block: &Block<'_>) {
                     });
             }
         }
+
+        let lint_almost_swapped_note = |span, what: String, sugg, lhs, rhs| {
+            span_lint_and_then(
+                cx,
+                ALMOST_SWAPPED,
+                span,
+                &format!("this looks like you are trying to swap{}", what),
+                |diag| {
+                    if !what.is_empty() {
+                        diag.note(&format!(
+                            "maybe you could use `{sugg}::mem::swap({lhs}, {rhs})` or `{sugg}::mem::replace`?"
+                        ));
+                    }
+                },
+            );
+        };
+
+        if let StmtKind::Local(first) = w[0].kind
+            && let StmtKind::Local(second) = w[1].kind
+            && first.span.ctxt() == second.span.ctxt()
+            && let Some(rhs0) = first.init
+            && let Some(rhs1) = second.init
+            && let ExprKind::Path(QPath::Resolved(None, path_l)) = rhs0.kind
+            && let ExprKind::Path(QPath::Resolved(None, path_r)) = rhs1.kind
+            && let PatKind::Binding(_,_, ident_l,_) = first.pat.kind
+            && let PatKind::Binding(_,_, ident_r,_) = second.pat.kind
+            && ident_l.name.as_str() == path_r.segments.iter().map(|el| el.ident.to_string()).collect::<Vec<_>>().join("::")
+            && ident_r.name.as_str() == path_l.segments.iter().map(|el| el.ident.to_string()).collect::<Vec<_>>().join("::") 
+                {
+                    let rhs0 = Sugg::hir_opt(cx, rhs0);
+                    let (what, lhs, rhs) = if let Some(second) = rhs0 {
+                        (
+                            format!(" `{}` and `{}`", ident_l, second),
+                            format!("&mut {}", ident_l),
+                            second.mut_addr().to_string(),
+                        )
+                    } else {
+                        (String::new(), String::new(), String::new())
+                    };
+                    let span = first.span.to(second.span);
+                    let Some(sugg) = std_or_core(cx) else { return };
+
+                    lint_almost_swapped_note(span, what, sugg, lhs, rhs);
+                }
+
+        if let StmtKind::Local(first) = w[0].kind
+            && let StmtKind::Semi(second) = w[1].kind
+            && first.span.ctxt() == second.span.ctxt()
+            && let Some(rhs0) = first.init
+            && let ExprKind::Path(QPath::Resolved(None, path_l)) = rhs0.kind
+            && let PatKind::Binding(_,_, ident_l,_) = first.pat.kind
+            && let ExprKind::Assign(lhs1, rhs1, _) = second.kind
+            && let ExprKind::Path(QPath::Resolved(None, lhs1_path)) = lhs1.kind
+            && let ExprKind::Path(QPath::Resolved(None, rhs1_path)) = rhs1.kind
+            && ident_l.name.as_str() == rhs1_path.segments.iter().map(|el| el.ident.to_string()).collect::<Vec<_>>().join("::")
+            && path_l.segments.iter().map(|el| el.ident.to_string()).collect::<Vec<_>>().join("::") == lhs1_path.segments.iter().map(|el| el.ident.to_string()).collect::<Vec<_>>().join("::") 
+                {
+                    let lhs1 = Sugg::hir_opt(cx, lhs1);
+                    let rhs1 = Sugg::hir_opt(cx, rhs1);
+                    let (what, lhs, rhs) = if let (Some(first),Some(second)) = (lhs1,rhs1) {
+                        (
+                            format!(" `{}` and `{}`", first, second),
+                            first.mut_addr().to_string(),
+                            second.mut_addr().to_string(),
+                        )
+                    } else {
+                        (String::new(), String::new(), String::new())
+                    };
+                    let span = first.span.to(second.span);
+                    let Some(sugg) = std_or_core(cx) else { return };
+
+                    lint_almost_swapped_note(span, what, sugg, lhs, rhs);
+                }
     }
 }
 
diff --git a/tests/ui/almost_swapped.rs b/tests/ui/almost_swapped.rs
new file mode 100644
index 00000000000..8b0740c3209
--- /dev/null
+++ b/tests/ui/almost_swapped.rs
@@ -0,0 +1,32 @@
+#![allow(clippy::needless_late_init, clippy::manual_swap)]
+#![allow(unused_variables, unused_assignments)]
+#![warn(clippy::almost_swapped)]
+
+fn main() {
+    let b = 1;
+    let a = b;
+    let b = a;
+
+    let mut c = 1;
+    let mut d = 2;
+    d = c;
+    c = d;
+
+    let mut b = 1;
+    let a = b;
+    b = a;
+
+    let b = 1;
+    let a = 2;
+
+    let t = b;
+    let b = a;
+    let a = t;
+
+    let mut b = 1;
+    let mut a = 2;
+
+    let t = b;
+    b = a;
+    a = t;
+}
diff --git a/tests/ui/almost_swapped.stderr b/tests/ui/almost_swapped.stderr
new file mode 100644
index 00000000000..70788d23f16
--- /dev/null
+++ b/tests/ui/almost_swapped.stderr
@@ -0,0 +1,30 @@
+error: this looks like you are trying to swap `a` and `b`
+  --> $DIR/almost_swapped.rs:7:5
+   |
+LL | /     let a = b;
+LL | |     let b = a;
+   | |______________^
+   |
+   = note: `-D clippy::almost-swapped` implied by `-D warnings`
+   = note: maybe you could use `std::mem::swap(&mut a, &mut b)` or `std::mem::replace`?
+
+error: this looks like you are trying to swap `d` and `c`
+  --> $DIR/almost_swapped.rs:12:5
+   |
+LL | /     d = c;
+LL | |     c = d;
+   | |_________^ help: try: `std::mem::swap(&mut d, &mut c)`
+   |
+   = note: or maybe you should use `std::mem::replace`?
+
+error: this looks like you are trying to swap `b` and `a`
+  --> $DIR/almost_swapped.rs:16:5
+   |
+LL | /     let a = b;
+LL | |     b = a;
+   | |_________^
+   |
+   = note: maybe you could use `std::mem::swap(&mut b, &mut a)` or `std::mem::replace`?
+
+error: aborting due to 3 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 145e6a94d6bd9aa360fa7d43e52a2e9aad1752ef Mon Sep 17 00:00:00 2001
From: Mara Bos <m-ou.se@m-ou.se>
Date: Fri, 10 Feb 2023 16:59:04 +0100
Subject: Add suspicious_command_arg_space lint.

---
 clippy_lints/src/methods/mod.rs                    | 30 +++++++++++++++++
 .../src/methods/suspicious_command_arg_space.rs    | 39 ++++++++++++++++++++++
 clippy_utils/src/paths.rs                          |  1 +
 3 files changed, 70 insertions(+)
 create mode 100644 clippy_lints/src/methods/suspicious_command_arg_space.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index f1e8be7f2b8..c97f4661cf1 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -80,6 +80,7 @@ mod skip_while_next;
 mod stable_sort_primitive;
 mod str_splitn;
 mod string_extend_chars;
+mod suspicious_command_arg_space;
 mod suspicious_map;
 mod suspicious_splitn;
 mod suspicious_to_owned;
@@ -3162,6 +3163,32 @@ declare_clippy_lint! {
     "collecting an iterator when collect is not needed"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    ///
+    /// Checks for `Command::arg()` invocations that look like they
+    /// should be multiple arguments instead, such as `arg("-t ext2")`.
+    ///
+    /// ### Why is this bad?
+    ///
+    /// Arguments are not split by space. An argument like `arg("-t ext2")`
+    /// will be passed as a single argument to the command,
+    /// which is likely not what was intended.
+    ///
+    /// ### Example
+    /// ```rust
+    /// std::process::Command::new("echo").arg("-n hello").spawn().unwrap();
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// std::process::Command::new("echo").args(["-n", "hello"]).spawn().unwrap();
+    /// ```
+    #[clippy::version = "1.67.0"]
+    pub SUSPICIOUS_COMMAND_ARG_SPACE,
+    suspicious,
+    "single command line argument that looks like it should be multiple arguments"
+}
+
 pub struct Methods {
     avoid_breaking_exported_api: bool,
     msrv: Msrv,
@@ -3496,6 +3523,9 @@ impl Methods {
                         unnecessary_lazy_eval::check(cx, expr, recv, arg, "and");
                     }
                 },
+                ("arg", [arg]) => {
+                    suspicious_command_arg_space::check(cx, recv, arg, span);
+                }
                 ("as_deref" | "as_deref_mut", []) => {
                     needless_option_as_deref::check(cx, expr, recv, name);
                 },
diff --git a/clippy_lints/src/methods/suspicious_command_arg_space.rs b/clippy_lints/src/methods/suspicious_command_arg_space.rs
new file mode 100644
index 00000000000..73632c5a357
--- /dev/null
+++ b/clippy_lints/src/methods/suspicious_command_arg_space.rs
@@ -0,0 +1,39 @@
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::paths;
+use clippy_utils::ty::match_type;
+use rustc_ast as ast;
+use rustc_errors::{Applicability, Diagnostic};
+use rustc_hir as hir;
+use rustc_lint::LateContext;
+use rustc_span::Span;
+
+use super::SUSPICIOUS_COMMAND_ARG_SPACE;
+
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, recv: &'tcx hir::Expr<'_>, arg: &'tcx hir::Expr<'_>, span: Span) {
+    let ty = cx.typeck_results().expr_ty(recv).peel_refs();
+
+    if match_type(cx, ty, &paths::STD_PROCESS_COMMAND)
+        && let hir::ExprKind::Lit(lit) = &arg.kind
+        && let ast::LitKind::Str(s, _) = &lit.node
+        && let Some((arg1, arg2)) = s.as_str().split_once(' ')
+        && arg1.starts_with('-')
+        && arg1.chars().all(|c| c.is_ascii_alphanumeric() || c == '_' || c == '-')
+    {
+        span_lint_and_then(
+            cx,
+            SUSPICIOUS_COMMAND_ARG_SPACE,
+            arg.span,
+            "single argument that looks like it should be multiple arguments",
+            |diag: &mut Diagnostic| {
+                diag.multipart_suggestion_verbose(
+                    "consider splitting the argument",
+                    vec![
+                        (span, "args".to_string()),
+                        (arg.span, format!("[{arg1:?}, {arg2:?}]")),
+                    ],
+                    Applicability::MaybeIncorrect,
+                );
+            }
+        );
+    }
+}
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index 95eebab7567..4aae0f7284e 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -115,6 +115,7 @@ pub const STD_FS_CREATE_DIR: [&str; 3] = ["std", "fs", "create_dir"];
 pub const STD_IO_SEEK: [&str; 3] = ["std", "io", "Seek"];
 pub const STD_IO_SEEK_FROM_CURRENT: [&str; 4] = ["std", "io", "SeekFrom", "Current"];
 pub const STD_IO_SEEKFROM_START: [&str; 4] = ["std", "io", "SeekFrom", "Start"];
+pub const STD_PROCESS_COMMAND: [&str; 3] = ["std", "process", "Command"];
 pub const STRING_AS_MUT_STR: [&str; 4] = ["alloc", "string", "String", "as_mut_str"];
 pub const STRING_AS_STR: [&str; 4] = ["alloc", "string", "String", "as_str"];
 pub const STRING_NEW: [&str; 4] = ["alloc", "string", "String", "new"];
-- 
cgit 1.4.1-3-g733a5


From 984c47b9f4e0341bf4d3ed29007f4a51bf8a146d Mon Sep 17 00:00:00 2001
From: Mara Bos <m-ou.se@m-ou.se>
Date: Fri, 10 Feb 2023 18:59:37 +0100
Subject: Clarify description of suspicious_command_arg_space.

Co-authored-by: Manish Goregaokar <manishsmail@gmail.com>
---
 clippy_lints/src/methods/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index c97f4661cf1..7e34d08ea32 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3171,7 +3171,7 @@ declare_clippy_lint! {
     ///
     /// ### Why is this bad?
     ///
-    /// Arguments are not split by space. An argument like `arg("-t ext2")`
+    /// `Command::arg()` does not split arguments by space. An argument like `arg("-t ext2")`
     /// will be passed as a single argument to the command,
     /// which is likely not what was intended.
     ///
-- 
cgit 1.4.1-3-g733a5


From 8f56767c94a9ccadcd5cb6c495fe7f646e5221a7 Mon Sep 17 00:00:00 2001
From: Mara Bos <m-ou.se@m-ou.se>
Date: Fri, 10 Feb 2023 19:03:20 +0100
Subject: Update lints.

---
 CHANGELOG.md                       | 1 +
 clippy_lints/src/declared_lints.rs | 1 +
 2 files changed, 2 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 659e8aebcd5..30727beb8e7 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4764,6 +4764,7 @@ Released 2018-09-13
 [`suboptimal_flops`]: https://rust-lang.github.io/rust-clippy/master/index.html#suboptimal_flops
 [`suspicious_arithmetic_impl`]: https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_arithmetic_impl
 [`suspicious_assignment_formatting`]: https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_assignment_formatting
+[`suspicious_command_arg_space`]: https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_command_arg_space
 [`suspicious_else_formatting`]: https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_else_formatting
 [`suspicious_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_map
 [`suspicious_op_assign_impl`]: https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_op_assign_impl
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 457a25826e7..c1feabf05aa 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -378,6 +378,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::methods::SKIP_WHILE_NEXT_INFO,
     crate::methods::STABLE_SORT_PRIMITIVE_INFO,
     crate::methods::STRING_EXTEND_CHARS_INFO,
+    crate::methods::SUSPICIOUS_COMMAND_ARG_SPACE_INFO,
     crate::methods::SUSPICIOUS_MAP_INFO,
     crate::methods::SUSPICIOUS_SPLITN_INFO,
     crate::methods::SUSPICIOUS_TO_OWNED_INFO,
-- 
cgit 1.4.1-3-g733a5


From 078f149aa46c198200f54de556a7ba978a619564 Mon Sep 17 00:00:00 2001
From: Caio <c410.f3r@gmail.com>
Date: Fri, 10 Feb 2023 08:04:24 -0300
Subject: [significant_drop_tightening] Add MVP

---
 CHANGELOG.md                                    |   1 +
 clippy_lints/src/declared_lints.rs              |   1 +
 clippy_lints/src/lib.rs                         |   3 +
 clippy_lints/src/significant_drop_tightening.rs | 381 ++++++++++++++++++++++++
 tests/ui/significant_drop_tightening.fixed      |  56 ++++
 tests/ui/significant_drop_tightening.rs         |  53 ++++
 tests/ui/significant_drop_tightening.stderr     |  71 +++++
 7 files changed, 566 insertions(+)
 create mode 100644 clippy_lints/src/significant_drop_tightening.rs
 create mode 100644 tests/ui/significant_drop_tightening.fixed
 create mode 100644 tests/ui/significant_drop_tightening.rs
 create mode 100644 tests/ui/significant_drop_tightening.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 659e8aebcd5..2367524ca72 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4734,6 +4734,7 @@ Released 2018-09-13
 [`should_assert_eq`]: https://rust-lang.github.io/rust-clippy/master/index.html#should_assert_eq
 [`should_implement_trait`]: https://rust-lang.github.io/rust-clippy/master/index.html#should_implement_trait
 [`significant_drop_in_scrutinee`]: https://rust-lang.github.io/rust-clippy/master/index.html#significant_drop_in_scrutinee
+[`significant_drop_tightening`]: https://rust-lang.github.io/rust-clippy/master/index.html#significant_drop_tightening
 [`similar_names`]: https://rust-lang.github.io/rust-clippy/master/index.html#similar_names
 [`single_char_add_str`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_char_add_str
 [`single_char_lifetime_names`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_char_lifetime_names
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 457a25826e7..bc8ea8a6f2f 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -536,6 +536,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::shadow::SHADOW_REUSE_INFO,
     crate::shadow::SHADOW_SAME_INFO,
     crate::shadow::SHADOW_UNRELATED_INFO,
+    crate::significant_drop_tightening::SIGNIFICANT_DROP_TIGHTENING_INFO,
     crate::single_char_lifetime_names::SINGLE_CHAR_LIFETIME_NAMES_INFO,
     crate::single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS_INFO,
     crate::size_of_in_element_count::SIZE_OF_IN_ELEMENT_COUNT_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 565c5b7af00..223e6698b72 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -2,6 +2,7 @@
 #![feature(binary_heap_into_iter_sorted)]
 #![feature(box_patterns)]
 #![feature(drain_filter)]
+#![feature(if_let_guard)]
 #![feature(iter_intersperse)]
 #![feature(let_chains)]
 #![feature(lint_reasons)]
@@ -263,6 +264,7 @@ mod semicolon_block;
 mod semicolon_if_nothing_returned;
 mod serde_api;
 mod shadow;
+mod significant_drop_tightening;
 mod single_char_lifetime_names;
 mod single_component_path_imports;
 mod size_of_in_element_count;
@@ -558,6 +560,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(eta_reduction::EtaReduction));
     store.register_late_pass(|_| Box::new(mut_mut::MutMut));
     store.register_late_pass(|_| Box::new(mut_reference::UnnecessaryMutPassed));
+    store.register_late_pass(|_| Box::<significant_drop_tightening::SignificantDropTightening<'_>>::default());
     store.register_late_pass(|_| Box::new(len_zero::LenZero));
     store.register_late_pass(|_| Box::new(attrs::Attributes));
     store.register_late_pass(|_| Box::new(blocks_in_if_conditions::BlocksInIfConditions));
diff --git a/clippy_lints/src/significant_drop_tightening.rs b/clippy_lints/src/significant_drop_tightening.rs
new file mode 100644
index 00000000000..a509592a1a4
--- /dev/null
+++ b/clippy_lints/src/significant_drop_tightening.rs
@@ -0,0 +1,381 @@
+use crate::FxHashSet;
+use clippy_utils::{
+    diagnostics::span_lint_and_then,
+    get_attr,
+    source::{indent_of, snippet},
+};
+use rustc_errors::{Applicability, Diagnostic};
+use rustc_hir::{
+    self as hir,
+    intravisit::{walk_expr, Visitor},
+};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_middle::ty::{subst::GenericArgKind, Ty, TypeAndMut};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::{symbol::Ident, Span, DUMMY_SP};
+
+declare_clippy_lint! {
+    /// ### What it does
+    ///
+    /// Searches for elements marked with `#[clippy::significant_drop]` that could be early
+    /// dropped but are in fact dropped at the end of their scopes. In other words, enforces the
+    /// "tightening" of their possible lifetimes.
+    ///
+    /// ### Why is this bad?
+    ///
+    /// Elements marked with `#[clippy::has_significant_drop]` are generally synchronizing
+    /// primitives that manage shared resources, as such, it is desired to release them as soon as
+    /// possible to avoid unnecessary resource contention.
+    ///
+    /// ### Example
+    ///
+    /// ```rust,ignore
+    /// fn main() {
+    ///   let lock = some_sync_resource.lock();
+    ///   let owned_rslt = lock.do_stuff_with_resource();
+    ///   // Only `owned_rslt` is needed but `lock` is still held.
+    ///   do_heavy_computation_that_takes_time(owned_rslt);
+    /// }
+    /// ```
+    ///
+    /// Use instead:
+    ///
+    /// ```rust,ignore
+    /// fn main() {
+    ///     let owned_rslt = some_sync_resource.lock().do_stuff_with_resource();
+    ///     do_heavy_computation_that_takes_time(owned_rslt);
+    /// }
+    /// ```
+    #[clippy::version = "1.67.0"]
+    pub SIGNIFICANT_DROP_TIGHTENING,
+    nursery,
+    "Searches for elements marked with `#[clippy::has_significant_drop]` that could be early dropped but are in fact dropped at the end of their scopes"
+}
+
+impl_lint_pass!(SignificantDropTightening<'_> => [SIGNIFICANT_DROP_TIGHTENING]);
+
+#[derive(Default)]
+pub struct SignificantDropTightening<'tcx> {
+    /// Auxiliary structure used to avoid having to verify the same type multiple times.
+    seen_types: FxHashSet<Ty<'tcx>>,
+}
+
+impl<'tcx> SignificantDropTightening<'tcx> {
+    /// Verifies if the expression is of type `drop(some_lock_path)` to assert that the temporary
+    /// is already being dropped before the end of its scope.
+    fn has_drop(expr: &'tcx hir::Expr<'_>, init_bind_ident: Ident) -> bool {
+        if let hir::ExprKind::Call(fun, args) = expr.kind
+            && let hir::ExprKind::Path(hir::QPath::Resolved(_, fun_path)) = &fun.kind
+            && let [fun_ident, ..] = fun_path.segments
+            && fun_ident.ident.name == rustc_span::sym::drop
+            && let [first_arg, ..] = args
+            && let hir::ExprKind::Path(hir::QPath::Resolved(_, arg_path)) = &first_arg.kind
+            && let [first_arg_ps, .. ] = arg_path.segments
+        {
+            first_arg_ps.ident == init_bind_ident
+        }
+        else {
+            false
+        }
+    }
+
+    /// Tries to find types marked with `#[has_significant_drop]` of an expression `expr` that is
+    /// originated from `stmt` and then performs common logic on `sdap`.
+    fn modify_sdap_if_sig_drop_exists(
+        &mut self,
+        cx: &LateContext<'tcx>,
+        expr: &'tcx hir::Expr<'_>,
+        idx: usize,
+        sdap: &mut SigDropAuxParams,
+        stmt: &'tcx hir::Stmt<'_>,
+        cb: impl Fn(&mut SigDropAuxParams),
+    ) {
+        let mut sig_drop_finder = SigDropFinder::new(cx, &mut self.seen_types);
+        sig_drop_finder.visit_expr(expr);
+        if sig_drop_finder.has_sig_drop {
+            cb(sdap);
+            if sdap.number_of_stmts > 0 {
+                sdap.last_use_stmt_idx = idx;
+                sdap.last_use_stmt_span = stmt.span;
+                if let hir::ExprKind::MethodCall(_, _, _, span) = expr.kind {
+                    sdap.last_use_method_span = span;
+                }
+            }
+            sdap.number_of_stmts = sdap.number_of_stmts.wrapping_add(1);
+        }
+    }
+
+    /// Shows a generic overall message as well as specialized messages depending on the usage.
+    fn set_suggestions(cx: &LateContext<'tcx>, block_span: Span, diag: &mut Diagnostic, sdap: &SigDropAuxParams) {
+        match sdap.number_of_stmts {
+            0 | 1 => {},
+            2 => {
+                let indent = " ".repeat(indent_of(cx, sdap.last_use_stmt_span).unwrap_or(0));
+                let init_method = snippet(cx, sdap.init_method_span, "..");
+                let usage_method = snippet(cx, sdap.last_use_method_span, "..");
+                let stmt = if let Some(last_use_bind_span) = sdap.last_use_bind_span {
+                    format!(
+                        "\n{indent}let {} = {init_method}.{usage_method};",
+                        snippet(cx, last_use_bind_span, ".."),
+                    )
+                } else {
+                    format!("\n{indent}{init_method}.{usage_method};")
+                };
+                diag.span_suggestion_verbose(
+                    sdap.init_stmt_span,
+                    "merge the temporary construction with its single usage",
+                    stmt,
+                    Applicability::MaybeIncorrect,
+                );
+                diag.span_suggestion(
+                    sdap.last_use_stmt_span,
+                    "remove separated single usage",
+                    "",
+                    Applicability::MaybeIncorrect,
+                );
+            },
+            _ => {
+                diag.span_suggestion(
+                    sdap.last_use_stmt_span.shrink_to_hi(),
+                    "drop the temporary after the end of its last usage",
+                    format!(
+                        "\n{}drop({});",
+                        " ".repeat(indent_of(cx, sdap.last_use_stmt_span).unwrap_or(0)),
+                        sdap.init_bind_ident
+                    ),
+                    Applicability::MaybeIncorrect,
+                );
+            },
+        }
+        diag.note("this might lead to unnecessary resource contention");
+        diag.span_label(
+            block_span,
+            format!(
+                "temporary `{}` is currently being dropped at the end of its contained scope",
+                sdap.init_bind_ident
+            ),
+        );
+    }
+}
+
+impl<'tcx> LateLintPass<'tcx> for SignificantDropTightening<'tcx> {
+    fn check_block(&mut self, cx: &LateContext<'tcx>, block: &'tcx hir::Block<'_>) {
+        let mut sdap = SigDropAuxParams::default();
+        for (idx, stmt) in block.stmts.iter().enumerate() {
+            match stmt.kind {
+                hir::StmtKind::Expr(expr) => self.modify_sdap_if_sig_drop_exists(
+                    cx,
+                    expr,
+                    idx,
+                    &mut sdap,
+                    stmt,
+                    |_| {}
+                ),
+                hir::StmtKind::Local(local) if let Some(expr) = local.init => self.modify_sdap_if_sig_drop_exists(
+                    cx,
+                    expr,
+                    idx,
+                    &mut sdap,
+                    stmt,
+                    |local_sdap| {
+                        if local_sdap.number_of_stmts == 0 {
+                            if let hir::PatKind::Binding(_, _, ident, _) = local.pat.kind {
+                                local_sdap.init_bind_ident = ident;
+                            }
+                            if let hir::ExprKind::MethodCall(_, local_expr, _, span) = expr.kind {
+                                local_sdap.init_method_span = local_expr.span.to(span);
+                            }
+                            local_sdap.init_stmt_span = stmt.span;
+                        }
+                        else if let hir::PatKind::Binding(_, _, ident, _) = local.pat.kind {
+                            local_sdap.last_use_bind_span = Some(ident.span);
+                        }
+                    }
+                ),
+                hir::StmtKind::Semi(expr) => {
+                    if Self::has_drop(expr, sdap.init_bind_ident) {
+                        return;
+                    }
+                    self.modify_sdap_if_sig_drop_exists(cx, expr, idx, &mut sdap, stmt, |_| {});
+                },
+                _ => continue
+            };
+        }
+        if sdap.number_of_stmts > 1 && {
+            let last_stmts_idx = block.stmts.len().wrapping_sub(1);
+            sdap.last_use_stmt_idx != last_stmts_idx
+        } {
+            span_lint_and_then(
+                cx,
+                SIGNIFICANT_DROP_TIGHTENING,
+                sdap.init_bind_ident.span,
+                "temporary with significant `Drop` can be early dropped",
+                |diag| {
+                    Self::set_suggestions(cx, block.span, diag, &sdap);
+                },
+            );
+        }
+    }
+}
+
+/// Auxiliary parameters used on each block check.
+struct SigDropAuxParams {
+    /// The binding or variable that references the initial construction of the type marked with
+    /// `#[has_significant_drop]`.
+    init_bind_ident: Ident,
+    /// Similar to `init_bind_ident` but encompasses the right-hand method call.
+    init_method_span: Span,
+    /// Similar to `init_bind_ident` but encompasses the whole contained statement.
+    init_stmt_span: Span,
+
+    /// The last visited binding or variable span within a block that had any referenced inner type
+    /// marked with `#[has_significant_drop]`.
+    last_use_bind_span: Option<Span>,
+    /// Index of the last visited statement within a block that had any referenced inner type
+    /// marked with `#[has_significant_drop]`.
+    last_use_stmt_idx: usize,
+    /// Similar to `last_use_bind_span` but encompasses the whole contained statement.
+    last_use_stmt_span: Span,
+    /// Similar to `last_use_bind_span` but encompasses the right-hand method call.
+    last_use_method_span: Span,
+
+    /// Total number of statements within a block that have any referenced inner type marked with
+    /// `#[has_significant_drop]`.
+    number_of_stmts: usize,
+}
+
+impl Default for SigDropAuxParams {
+    fn default() -> Self {
+        Self {
+            init_bind_ident: Ident::empty(),
+            init_method_span: DUMMY_SP,
+            init_stmt_span: DUMMY_SP,
+            last_use_bind_span: None,
+            last_use_method_span: DUMMY_SP,
+            last_use_stmt_idx: 0,
+            last_use_stmt_span: DUMMY_SP,
+            number_of_stmts: 0,
+        }
+    }
+}
+
+/// Checks the existence of the `#[has_significant_drop]` attribute
+struct SigDropChecker<'cx, 'sdt, 'tcx> {
+    cx: &'cx LateContext<'tcx>,
+    seen_types: &'sdt mut FxHashSet<Ty<'tcx>>,
+}
+
+impl<'cx, 'sdt, 'tcx> SigDropChecker<'cx, 'sdt, 'tcx> {
+    pub(crate) fn new(cx: &'cx LateContext<'tcx>, seen_types: &'sdt mut FxHashSet<Ty<'tcx>>) -> Self {
+        seen_types.clear();
+        Self { cx, seen_types }
+    }
+
+    pub(crate) fn has_sig_drop_attr(&mut self, ty: Ty<'tcx>) -> bool {
+        if let Some(adt) = ty.ty_adt_def() {
+            let iter = get_attr(
+                self.cx.sess(),
+                self.cx.tcx.get_attrs_unchecked(adt.did()),
+                "has_significant_drop",
+            );
+            if iter.count() > 0 {
+                return true;
+            }
+        }
+        match ty.kind() {
+            rustc_middle::ty::Adt(a, b) => {
+                for f in a.all_fields() {
+                    let ty = f.ty(self.cx.tcx, b);
+                    if !self.has_seen_ty(ty) && self.has_sig_drop_attr(ty) {
+                        return true;
+                    }
+                }
+                for generic_arg in b.iter() {
+                    if let GenericArgKind::Type(ty) = generic_arg.unpack() {
+                        if self.has_sig_drop_attr(ty) {
+                            return true;
+                        }
+                    }
+                }
+                false
+            },
+            rustc_middle::ty::Array(ty, _)
+            | rustc_middle::ty::RawPtr(TypeAndMut { ty, .. })
+            | rustc_middle::ty::Ref(_, ty, _)
+            | rustc_middle::ty::Slice(ty) => self.has_sig_drop_attr(*ty),
+            _ => false,
+        }
+    }
+
+    fn has_seen_ty(&mut self, ty: Ty<'tcx>) -> bool {
+        !self.seen_types.insert(ty)
+    }
+}
+
+/// Performs recursive calls to find any inner type marked with `#[has_significant_drop]`.
+struct SigDropFinder<'cx, 'sdt, 'tcx> {
+    cx: &'cx LateContext<'tcx>,
+    has_sig_drop: bool,
+    sig_drop_checker: SigDropChecker<'cx, 'sdt, 'tcx>,
+}
+
+impl<'cx, 'sdt, 'tcx> SigDropFinder<'cx, 'sdt, 'tcx> {
+    fn new(cx: &'cx LateContext<'tcx>, seen_types: &'sdt mut FxHashSet<Ty<'tcx>>) -> Self {
+        Self {
+            cx,
+            has_sig_drop: false,
+            sig_drop_checker: SigDropChecker::new(cx, seen_types),
+        }
+    }
+}
+
+impl<'cx, 'sdt, 'tcx> Visitor<'tcx> for SigDropFinder<'cx, 'sdt, 'tcx> {
+    fn visit_expr(&mut self, ex: &'tcx hir::Expr<'_>) {
+        if self
+            .sig_drop_checker
+            .has_sig_drop_attr(self.cx.typeck_results().expr_ty(ex))
+        {
+            self.has_sig_drop = true;
+            return;
+        }
+
+        match ex.kind {
+            hir::ExprKind::MethodCall(_, expr, ..) => {
+                self.visit_expr(expr);
+            },
+            hir::ExprKind::Array(..)
+            | hir::ExprKind::Assign(..)
+            | hir::ExprKind::AssignOp(..)
+            | hir::ExprKind::Binary(..)
+            | hir::ExprKind::Box(..)
+            | hir::ExprKind::Call(..)
+            | hir::ExprKind::Field(..)
+            | hir::ExprKind::If(..)
+            | hir::ExprKind::Index(..)
+            | hir::ExprKind::Match(..)
+            | hir::ExprKind::Repeat(..)
+            | hir::ExprKind::Ret(..)
+            | hir::ExprKind::Tup(..)
+            | hir::ExprKind::Unary(..)
+            | hir::ExprKind::Yield(..) => {
+                walk_expr(self, ex);
+            },
+            hir::ExprKind::AddrOf(_, _, _)
+            | hir::ExprKind::Block(_, _)
+            | hir::ExprKind::Break(_, _)
+            | hir::ExprKind::Cast(_, _)
+            | hir::ExprKind::Closure { .. }
+            | hir::ExprKind::ConstBlock(_)
+            | hir::ExprKind::Continue(_)
+            | hir::ExprKind::DropTemps(_)
+            | hir::ExprKind::Err
+            | hir::ExprKind::InlineAsm(_)
+            | hir::ExprKind::Let(_)
+            | hir::ExprKind::Lit(_)
+            | hir::ExprKind::Loop(_, _, _, _)
+            | hir::ExprKind::Path(_)
+            | hir::ExprKind::Struct(_, _, _)
+            | hir::ExprKind::Type(_, _) => {},
+        }
+    }
+}
diff --git a/tests/ui/significant_drop_tightening.fixed b/tests/ui/significant_drop_tightening.fixed
new file mode 100644
index 00000000000..7d56a87053f
--- /dev/null
+++ b/tests/ui/significant_drop_tightening.fixed
@@ -0,0 +1,56 @@
+// run-rustfix
+
+#![warn(clippy::significant_drop_tightening)]
+
+use std::sync::Mutex;
+
+pub fn unnecessary_contention_with_multiple_owned_results() {
+    {
+        let mutex = Mutex::new(1i32);
+        let lock = mutex.lock().unwrap();
+        let _ = lock.abs();
+        let _ = lock.is_positive();
+    }
+
+    {
+        let mutex = Mutex::new(1i32);
+        let lock = mutex.lock().unwrap();
+        let rslt0 = lock.abs();
+        let rslt1 = lock.is_positive();
+        drop(lock);
+        do_heavy_computation_that_takes_time((rslt0, rslt1));
+    }
+}
+
+pub fn unnecessary_contention_with_single_owned_results() {
+    {
+        let mutex = Mutex::new(1i32);
+        let lock = mutex.lock().unwrap();
+        let _ = lock.abs();
+    }
+    {
+        let mutex = Mutex::new(vec![1i32]);
+        let mut lock = mutex.lock().unwrap();
+        lock.clear();
+    }
+
+    {
+        let mutex = Mutex::new(1i32);
+        
+        let rslt0 = mutex.lock().unwrap().abs();
+        
+        do_heavy_computation_that_takes_time(rslt0);
+    }
+    {
+        let mutex = Mutex::new(vec![1i32]);
+        
+        mutex.lock().unwrap().clear();
+        
+        do_heavy_computation_that_takes_time(());
+    }
+}
+
+// Marker used for illustration purposes.
+pub fn do_heavy_computation_that_takes_time<T>(_: T) {}
+
+fn main() {}
diff --git a/tests/ui/significant_drop_tightening.rs b/tests/ui/significant_drop_tightening.rs
new file mode 100644
index 00000000000..6f3ce328e5d
--- /dev/null
+++ b/tests/ui/significant_drop_tightening.rs
@@ -0,0 +1,53 @@
+// run-rustfix
+
+#![warn(clippy::significant_drop_tightening)]
+
+use std::sync::Mutex;
+
+pub fn unnecessary_contention_with_multiple_owned_results() {
+    {
+        let mutex = Mutex::new(1i32);
+        let lock = mutex.lock().unwrap();
+        let _ = lock.abs();
+        let _ = lock.is_positive();
+    }
+
+    {
+        let mutex = Mutex::new(1i32);
+        let lock = mutex.lock().unwrap();
+        let rslt0 = lock.abs();
+        let rslt1 = lock.is_positive();
+        do_heavy_computation_that_takes_time((rslt0, rslt1));
+    }
+}
+
+pub fn unnecessary_contention_with_single_owned_results() {
+    {
+        let mutex = Mutex::new(1i32);
+        let lock = mutex.lock().unwrap();
+        let _ = lock.abs();
+    }
+    {
+        let mutex = Mutex::new(vec![1i32]);
+        let mut lock = mutex.lock().unwrap();
+        lock.clear();
+    }
+
+    {
+        let mutex = Mutex::new(1i32);
+        let lock = mutex.lock().unwrap();
+        let rslt0 = lock.abs();
+        do_heavy_computation_that_takes_time(rslt0);
+    }
+    {
+        let mutex = Mutex::new(vec![1i32]);
+        let mut lock = mutex.lock().unwrap();
+        lock.clear();
+        do_heavy_computation_that_takes_time(());
+    }
+}
+
+// Marker used for illustration purposes.
+pub fn do_heavy_computation_that_takes_time<T>(_: T) {}
+
+fn main() {}
diff --git a/tests/ui/significant_drop_tightening.stderr b/tests/ui/significant_drop_tightening.stderr
new file mode 100644
index 00000000000..52754aac782
--- /dev/null
+++ b/tests/ui/significant_drop_tightening.stderr
@@ -0,0 +1,71 @@
+error: temporary with significant `Drop` can be early dropped
+  --> $DIR/significant_drop_tightening.rs:17:13
+   |
+LL | /     {
+LL | |         let mutex = Mutex::new(1i32);
+LL | |         let lock = mutex.lock().unwrap();
+   | |             ^^^^
+LL | |         let rslt0 = lock.abs();
+LL | |         let rslt1 = lock.is_positive();
+LL | |         do_heavy_computation_that_takes_time((rslt0, rslt1));
+LL | |     }
+   | |_____- temporary `lock` is currently being dropped at the end of its contained scope
+   |
+   = note: this might lead to unnecessary resource contention
+   = note: `-D clippy::significant-drop-tightening` implied by `-D warnings`
+help: drop the temporary after the end of its last usage
+   |
+LL ~         let rslt1 = lock.is_positive();
+LL +         drop(lock);
+   |
+
+error: temporary with significant `Drop` can be early dropped
+  --> $DIR/significant_drop_tightening.rs:38:13
+   |
+LL | /     {
+LL | |         let mutex = Mutex::new(1i32);
+LL | |         let lock = mutex.lock().unwrap();
+   | |             ^^^^
+LL | |         let rslt0 = lock.abs();
+LL | |         do_heavy_computation_that_takes_time(rslt0);
+LL | |     }
+   | |_____- temporary `lock` is currently being dropped at the end of its contained scope
+   |
+   = note: this might lead to unnecessary resource contention
+help: merge the temporary construction with its single usage
+   |
+LL ~         
+LL +         let rslt0 = mutex.lock().unwrap().abs();
+   |
+help: remove separated single usage
+   |
+LL -         let rslt0 = lock.abs();
+LL +         
+   |
+
+error: temporary with significant `Drop` can be early dropped
+  --> $DIR/significant_drop_tightening.rs:44:17
+   |
+LL | /     {
+LL | |         let mutex = Mutex::new(vec![1i32]);
+LL | |         let mut lock = mutex.lock().unwrap();
+   | |                 ^^^^
+LL | |         lock.clear();
+LL | |         do_heavy_computation_that_takes_time(());
+LL | |     }
+   | |_____- temporary `lock` is currently being dropped at the end of its contained scope
+   |
+   = note: this might lead to unnecessary resource contention
+help: merge the temporary construction with its single usage
+   |
+LL ~         
+LL +         mutex.lock().unwrap().clear();
+   |
+help: remove separated single usage
+   |
+LL -         lock.clear();
+LL +         
+   |
+
+error: aborting due to 3 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 8789b37d06e74aef732b5bba1b88a9f4fefdee18 Mon Sep 17 00:00:00 2001
From: Michael Krasnitski <michael.krasnitski@gmail.com>
Date: Sat, 11 Feb 2023 12:22:25 -0500
Subject: Fix false positives for `extra_unused_type_parameters`

---
 clippy_lints/src/extra_unused_type_parameters.rs | 49 +++++++++++++++++-------
 tests/ui/extra_unused_type_parameters.rs         | 19 ++++++++-
 tests/ui/extra_unused_type_parameters.stderr     | 10 ++---
 tests/ui/type_repetition_in_bounds.rs            |  1 -
 tests/ui/type_repetition_in_bounds.stderr        |  8 ++--
 5 files changed, 61 insertions(+), 26 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/extra_unused_type_parameters.rs b/clippy_lints/src/extra_unused_type_parameters.rs
index 2fdd8a71466..9e9ad80b334 100644
--- a/clippy_lints/src/extra_unused_type_parameters.rs
+++ b/clippy_lints/src/extra_unused_type_parameters.rs
@@ -4,10 +4,12 @@ use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::MultiSpan;
 use rustc_hir::intravisit::{walk_impl_item, walk_item, walk_param_bound, walk_ty, Visitor};
 use rustc_hir::{
-    GenericParamKind, Generics, ImplItem, ImplItemKind, Item, ItemKind, PredicateOrigin, Ty, TyKind, WherePredicate,
+    BodyId, ExprKind, GenericParamKind, Generics, ImplItem, ImplItemKind, Item, ItemKind, PredicateOrigin, Ty, TyKind,
+    WherePredicate,
 };
-use rustc_lint::{LateContext, LateLintPass};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::hir::nested_filter;
+use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::{def_id::DefId, Span};
 
@@ -55,10 +57,13 @@ struct TypeWalker<'cx, 'tcx> {
     /// Otherwise, if any type parameters end up being used, or if any lifetime or const-generic
     /// parameters are present, this will be set to `false`.
     all_params_unused: bool,
+    /// Whether or not the function has an empty body, in which case any bounded type parameters
+    /// will not be linted.
+    fn_body_empty: bool,
 }
 
 impl<'cx, 'tcx> TypeWalker<'cx, 'tcx> {
-    fn new(cx: &'cx LateContext<'tcx>, generics: &'tcx Generics<'tcx>) -> Self {
+    fn new(cx: &'cx LateContext<'tcx>, generics: &'tcx Generics<'tcx>, body_id: BodyId) -> Self {
         let mut all_params_unused = true;
         let ty_params = generics
             .params
@@ -74,12 +79,18 @@ impl<'cx, 'tcx> TypeWalker<'cx, 'tcx> {
                 }
             })
             .collect();
+
+        let body = cx.tcx.hir().body(body_id).value;
+        let fn_body_empty =
+            matches!(&body.kind, ExprKind::Block(block, None) if block.stmts.is_empty() && block.expr.is_none());
+
         Self {
             cx,
             ty_params,
             bounds: FxHashMap::default(),
             generics,
             all_params_unused,
+            fn_body_empty,
         }
     }
 
@@ -96,7 +107,7 @@ impl<'cx, 'tcx> TypeWalker<'cx, 'tcx> {
             ),
         };
 
-        let source_map = self.cx.tcx.sess.source_map();
+        let source_map = self.cx.sess().source_map();
         let span = if self.all_params_unused {
             self.generics.span.into() // Remove the entire list of generics
         } else {
@@ -139,12 +150,17 @@ impl<'cx, 'tcx> Visitor<'tcx> for TypeWalker<'cx, 'tcx> {
 
     fn visit_where_predicate(&mut self, predicate: &'tcx WherePredicate<'tcx>) {
         if let WherePredicate::BoundPredicate(predicate) = predicate {
-            // Collect spans for bounds that appear in the list of generics (not in a where-clause)
-            // for use in forming the help message
-            if let Some((def_id, _)) = predicate.bounded_ty.peel_refs().as_generic_param()
-                && let PredicateOrigin::GenericParam = predicate.origin
-            {
-                self.bounds.insert(def_id, predicate.span);
+            // Collect spans for any bounds on type parameters. We only keep bounds that appear in
+            // the list of generics (not in a where-clause).
+            //
+            // Also, if the function body is empty, we don't lint the corresponding type parameters
+            // (See https://github.com/rust-lang/rust-clippy/issues/10319).
+            if let Some((def_id, _)) = predicate.bounded_ty.peel_refs().as_generic_param() {
+                if self.fn_body_empty {
+                    self.ty_params.remove(&def_id);
+                } else if let PredicateOrigin::GenericParam = predicate.origin {
+                    self.bounds.insert(def_id, predicate.span);
+                }
             }
             // Only walk the right-hand side of where-bounds
             for bound in predicate.bounds {
@@ -160,8 +176,10 @@ impl<'cx, 'tcx> Visitor<'tcx> for TypeWalker<'cx, 'tcx> {
 
 impl<'tcx> LateLintPass<'tcx> for ExtraUnusedTypeParameters {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
-        if let ItemKind::Fn(_, generics, _) = item.kind {
-            let mut walker = TypeWalker::new(cx, generics);
+        if let ItemKind::Fn(_, generics, body_id) = item.kind
+            && !in_external_macro(cx.sess(), item.span)
+        {
+            let mut walker = TypeWalker::new(cx, generics, body_id);
             walk_item(&mut walker, item);
             walker.emit_lint();
         }
@@ -169,8 +187,11 @@ impl<'tcx> LateLintPass<'tcx> for ExtraUnusedTypeParameters {
 
     fn check_impl_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx ImplItem<'tcx>) {
         // Only lint on inherent methods, not trait methods.
-        if let ImplItemKind::Fn(..) = item.kind && trait_ref_of_method(cx, item.owner_id.def_id).is_none() {
-            let mut walker = TypeWalker::new(cx, item.generics);
+        if let ImplItemKind::Fn(.., body_id) = item.kind
+            && trait_ref_of_method(cx, item.owner_id.def_id).is_none()
+            && !in_external_macro(cx.sess(), item.span)
+        {
+            let mut walker = TypeWalker::new(cx, item.generics, body_id);
             walk_impl_item(&mut walker, item);
             walker.emit_lint();
         }
diff --git a/tests/ui/extra_unused_type_parameters.rs b/tests/ui/extra_unused_type_parameters.rs
index 5cb80cb6233..a1cd8a0d085 100644
--- a/tests/ui/extra_unused_type_parameters.rs
+++ b/tests/ui/extra_unused_type_parameters.rs
@@ -15,15 +15,20 @@ fn used_ret<T: Default>(x: u8) -> T {
     T::default()
 }
 
-fn unused_bounded<T: Default, U>(x: U) {}
+fn unused_bounded<T: Default, U>(x: U) {
+    unimplemented!();
+}
 
 fn unused_where_clause<T, U>(x: U)
 where
     T: Default,
 {
+    unimplemented!();
 }
 
-fn some_unused<A, B, C, D: Iterator<Item = (B, C)>, E>(b: B, c: C) {}
+fn some_unused<A, B, C, D: Iterator<Item = (B, C)>, E>(b: B, c: C) {
+    unimplemented!();
+}
 
 fn used_opaque<A>(iter: impl Iterator<Item = A>) -> usize {
     iter.count()
@@ -66,4 +71,14 @@ where
         .filter_map(move |(i, a)| if i == index { None } else { Some(a) })
 }
 
+mod issue10319 {
+    fn assert_send<T: Send>() {}
+
+    fn assert_send_where<T>()
+    where
+        T: Send,
+    {
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/extra_unused_type_parameters.stderr b/tests/ui/extra_unused_type_parameters.stderr
index 1c8dd53e638..69a067bd849 100644
--- a/tests/ui/extra_unused_type_parameters.stderr
+++ b/tests/ui/extra_unused_type_parameters.stderr
@@ -26,13 +26,13 @@ LL | fn unused_with_lt<'a, T>(x: &'a u8) {}
 error: type parameter goes unused in function definition
   --> $DIR/extra_unused_type_parameters.rs:18:19
    |
-LL | fn unused_bounded<T: Default, U>(x: U) {}
+LL | fn unused_bounded<T: Default, U>(x: U) {
    |                   ^^^^^^^^^^^
    |
    = help: consider removing the parameter
 
 error: type parameter goes unused in function definition
-  --> $DIR/extra_unused_type_parameters.rs:20:24
+  --> $DIR/extra_unused_type_parameters.rs:22:24
    |
 LL | fn unused_where_clause<T, U>(x: U)
    |                        ^^
@@ -40,15 +40,15 @@ LL | fn unused_where_clause<T, U>(x: U)
    = help: consider removing the parameter
 
 error: type parameters go unused in function definition
-  --> $DIR/extra_unused_type_parameters.rs:26:16
+  --> $DIR/extra_unused_type_parameters.rs:29:16
    |
-LL | fn some_unused<A, B, C, D: Iterator<Item = (B, C)>, E>(b: B, c: C) {}
+LL | fn some_unused<A, B, C, D: Iterator<Item = (B, C)>, E>(b: B, c: C) {
    |                ^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^
    |
    = help: consider removing the parameters
 
 error: type parameter goes unused in function definition
-  --> $DIR/extra_unused_type_parameters.rs:49:22
+  --> $DIR/extra_unused_type_parameters.rs:54:22
    |
 LL |     fn unused_ty_impl<T>(&self) {}
    |                      ^^^
diff --git a/tests/ui/type_repetition_in_bounds.rs b/tests/ui/type_repetition_in_bounds.rs
index 8b4613b3f6e..2eca1f4701c 100644
--- a/tests/ui/type_repetition_in_bounds.rs
+++ b/tests/ui/type_repetition_in_bounds.rs
@@ -1,5 +1,4 @@
 #![deny(clippy::type_repetition_in_bounds)]
-#![allow(clippy::extra_unused_type_parameters)]
 
 use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Sub, SubAssign};
 
diff --git a/tests/ui/type_repetition_in_bounds.stderr b/tests/ui/type_repetition_in_bounds.stderr
index a90df03c04f..70d700c1cc4 100644
--- a/tests/ui/type_repetition_in_bounds.stderr
+++ b/tests/ui/type_repetition_in_bounds.stderr
@@ -1,5 +1,5 @@
 error: this type has already been used as a bound predicate
-  --> $DIR/type_repetition_in_bounds.rs:9:5
+  --> $DIR/type_repetition_in_bounds.rs:8:5
    |
 LL |     T: Clone,
    |     ^^^^^^^^
@@ -12,7 +12,7 @@ LL | #![deny(clippy::type_repetition_in_bounds)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this type has already been used as a bound predicate
-  --> $DIR/type_repetition_in_bounds.rs:26:5
+  --> $DIR/type_repetition_in_bounds.rs:25:5
    |
 LL |     Self: Copy + Default + Ord,
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -20,7 +20,7 @@ LL |     Self: Copy + Default + Ord,
    = help: consider combining the bounds: `Self: Clone + Copy + Default + Ord`
 
 error: this type has already been used as a bound predicate
-  --> $DIR/type_repetition_in_bounds.rs:86:5
+  --> $DIR/type_repetition_in_bounds.rs:85:5
    |
 LL |     T: Clone,
    |     ^^^^^^^^
@@ -28,7 +28,7 @@ LL |     T: Clone,
    = help: consider combining the bounds: `T: ?Sized + Clone`
 
 error: this type has already been used as a bound predicate
-  --> $DIR/type_repetition_in_bounds.rs:91:5
+  --> $DIR/type_repetition_in_bounds.rs:90:5
    |
 LL |     T: ?Sized,
    |     ^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From d9dc1679f50344e60a69e4e7f93acb8081d009a4 Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Sun, 12 Feb 2023 08:51:33 +0100
Subject: cast_possible_truncation: issue proper help message

---
 clippy_lints/src/casts/cast_possible_truncation.rs |  2 +-
 tests/ui/cast.stderr                               | 36 +++++++++++-----------
 tests/ui/cast_size.stderr                          | 18 +++++------
 3 files changed, 28 insertions(+), 28 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/cast_possible_truncation.rs b/clippy_lints/src/casts/cast_possible_truncation.rs
index f3f8b8d8798..823970e35ab 100644
--- a/clippy_lints/src/casts/cast_possible_truncation.rs
+++ b/clippy_lints/src/casts/cast_possible_truncation.rs
@@ -168,7 +168,7 @@ pub(super) fn check(
     let suggestion = format!("{cast_to_snip}::try_from({name_of_cast_from})");
 
     span_lint_and_then(cx, CAST_POSSIBLE_TRUNCATION, expr.span, &msg, |diag| {
-        diag.help("if this is intentional allow the lint with `#[allow(clippy::cast_precision_loss)]` ...");
+        diag.help("if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...");
         diag.span_suggestion_with_style(
             expr.span,
             "... or use `try_from` and handle the error accordingly",
diff --git a/tests/ui/cast.stderr b/tests/ui/cast.stderr
index 4af1de9aa38..451078de23b 100644
--- a/tests/ui/cast.stderr
+++ b/tests/ui/cast.stderr
@@ -42,7 +42,7 @@ error: casting `f32` to `i32` may truncate the value
 LL |     1f32 as i32;
    |     ^^^^^^^^^^^
    |
-   = help: if this is intentional allow the lint with `#[allow(clippy::cast_precision_loss)]` ...
+   = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
    = note: `-D clippy::cast-possible-truncation` implied by `-D warnings`
 help: ... or use `try_from` and handle the error accordingly
    |
@@ -55,7 +55,7 @@ error: casting `f32` to `u32` may truncate the value
 LL |     1f32 as u32;
    |     ^^^^^^^^^^^
    |
-   = help: if this is intentional allow the lint with `#[allow(clippy::cast_precision_loss)]` ...
+   = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
 help: ... or use `try_from` and handle the error accordingly
    |
 LL |     u32::try_from(1f32);
@@ -75,7 +75,7 @@ error: casting `f64` to `f32` may truncate the value
 LL |     1f64 as f32;
    |     ^^^^^^^^^^^
    |
-   = help: if this is intentional allow the lint with `#[allow(clippy::cast_precision_loss)]` ...
+   = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
 help: ... or use `try_from` and handle the error accordingly
    |
 LL |     f32::try_from(1f64);
@@ -87,7 +87,7 @@ error: casting `i32` to `i8` may truncate the value
 LL |     1i32 as i8;
    |     ^^^^^^^^^^
    |
-   = help: if this is intentional allow the lint with `#[allow(clippy::cast_precision_loss)]` ...
+   = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
 help: ... or use `try_from` and handle the error accordingly
    |
 LL |     i8::try_from(1i32);
@@ -99,7 +99,7 @@ error: casting `i32` to `u8` may truncate the value
 LL |     1i32 as u8;
    |     ^^^^^^^^^^
    |
-   = help: if this is intentional allow the lint with `#[allow(clippy::cast_precision_loss)]` ...
+   = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
 help: ... or use `try_from` and handle the error accordingly
    |
 LL |     u8::try_from(1i32);
@@ -111,7 +111,7 @@ error: casting `f64` to `isize` may truncate the value
 LL |     1f64 as isize;
    |     ^^^^^^^^^^^^^
    |
-   = help: if this is intentional allow the lint with `#[allow(clippy::cast_precision_loss)]` ...
+   = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
 help: ... or use `try_from` and handle the error accordingly
    |
 LL |     isize::try_from(1f64);
@@ -123,7 +123,7 @@ error: casting `f64` to `usize` may truncate the value
 LL |     1f64 as usize;
    |     ^^^^^^^^^^^^^
    |
-   = help: if this is intentional allow the lint with `#[allow(clippy::cast_precision_loss)]` ...
+   = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
 help: ... or use `try_from` and handle the error accordingly
    |
 LL |     usize::try_from(1f64);
@@ -141,7 +141,7 @@ error: casting `u32` to `u16` may truncate the value
 LL |     1f32 as u32 as u16;
    |     ^^^^^^^^^^^^^^^^^^
    |
-   = help: if this is intentional allow the lint with `#[allow(clippy::cast_precision_loss)]` ...
+   = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
 help: ... or use `try_from` and handle the error accordingly
    |
 LL |     u16::try_from(1f32 as u32);
@@ -153,7 +153,7 @@ error: casting `f32` to `u32` may truncate the value
 LL |     1f32 as u32 as u16;
    |     ^^^^^^^^^^^
    |
-   = help: if this is intentional allow the lint with `#[allow(clippy::cast_precision_loss)]` ...
+   = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
 help: ... or use `try_from` and handle the error accordingly
    |
 LL |     u32::try_from(1f32) as u16;
@@ -215,7 +215,7 @@ error: casting `i64` to `i8` may truncate the value
 LL |     (-99999999999i64).min(1) as i8; // should be linted because signed
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: if this is intentional allow the lint with `#[allow(clippy::cast_precision_loss)]` ...
+   = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
 help: ... or use `try_from` and handle the error accordingly
    |
 LL |     i8::try_from((-99999999999i64).min(1)); // should be linted because signed
@@ -227,7 +227,7 @@ error: casting `u64` to `u8` may truncate the value
 LL |     999999u64.clamp(0, 256) as u8; // should still be linted
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: if this is intentional allow the lint with `#[allow(clippy::cast_precision_loss)]` ...
+   = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
 help: ... or use `try_from` and handle the error accordingly
    |
 LL |     u8::try_from(999999u64.clamp(0, 256)); // should still be linted
@@ -239,7 +239,7 @@ error: casting `main::E2` to `u8` may truncate the value
 LL |             let _ = self as u8;
    |                     ^^^^^^^^^^
    |
-   = help: if this is intentional allow the lint with `#[allow(clippy::cast_precision_loss)]` ...
+   = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
 help: ... or use `try_from` and handle the error accordingly
    |
 LL |             let _ = u8::try_from(self);
@@ -259,7 +259,7 @@ error: casting `main::E5` to `i8` may truncate the value
 LL |             let _ = self as i8;
    |                     ^^^^^^^^^^
    |
-   = help: if this is intentional allow the lint with `#[allow(clippy::cast_precision_loss)]` ...
+   = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
 help: ... or use `try_from` and handle the error accordingly
    |
 LL |             let _ = i8::try_from(self);
@@ -277,7 +277,7 @@ error: casting `main::E6` to `i16` may truncate the value
 LL |             let _ = self as i16;
    |                     ^^^^^^^^^^^
    |
-   = help: if this is intentional allow the lint with `#[allow(clippy::cast_precision_loss)]` ...
+   = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
 help: ... or use `try_from` and handle the error accordingly
    |
 LL |             let _ = i16::try_from(self);
@@ -289,7 +289,7 @@ error: casting `main::E7` to `usize` may truncate the value on targets with 32-b
 LL |             let _ = self as usize;
    |                     ^^^^^^^^^^^^^
    |
-   = help: if this is intentional allow the lint with `#[allow(clippy::cast_precision_loss)]` ...
+   = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
 help: ... or use `try_from` and handle the error accordingly
    |
 LL |             let _ = usize::try_from(self);
@@ -301,7 +301,7 @@ error: casting `main::E10` to `u16` may truncate the value
 LL |             let _ = self as u16;
    |                     ^^^^^^^^^^^
    |
-   = help: if this is intentional allow the lint with `#[allow(clippy::cast_precision_loss)]` ...
+   = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
 help: ... or use `try_from` and handle the error accordingly
    |
 LL |             let _ = u16::try_from(self);
@@ -313,7 +313,7 @@ error: casting `u32` to `u8` may truncate the value
 LL |     let c = (q >> 16) as u8;
    |             ^^^^^^^^^^^^^^^
    |
-   = help: if this is intentional allow the lint with `#[allow(clippy::cast_precision_loss)]` ...
+   = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
 help: ... or use `try_from` and handle the error accordingly
    |
 LL |     let c = u8::try_from((q >> 16));
@@ -325,7 +325,7 @@ error: casting `u32` to `u8` may truncate the value
 LL |     let c = (q / 1000) as u8;
    |             ^^^^^^^^^^^^^^^^
    |
-   = help: if this is intentional allow the lint with `#[allow(clippy::cast_precision_loss)]` ...
+   = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
 help: ... or use `try_from` and handle the error accordingly
    |
 LL |     let c = u8::try_from((q / 1000));
diff --git a/tests/ui/cast_size.stderr b/tests/ui/cast_size.stderr
index 8acf26049f4..6d2d49d9ed2 100644
--- a/tests/ui/cast_size.stderr
+++ b/tests/ui/cast_size.stderr
@@ -4,7 +4,7 @@ error: casting `isize` to `i8` may truncate the value
 LL |     1isize as i8;
    |     ^^^^^^^^^^^^
    |
-   = help: if this is intentional allow the lint with `#[allow(clippy::cast_precision_loss)]` ...
+   = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
    = note: `-D clippy::cast-possible-truncation` implied by `-D warnings`
 help: ... or use `try_from` and handle the error accordingly
    |
@@ -43,7 +43,7 @@ error: casting `isize` to `i32` may truncate the value on targets with 64-bit wi
 LL |     1isize as i32;
    |     ^^^^^^^^^^^^^
    |
-   = help: if this is intentional allow the lint with `#[allow(clippy::cast_precision_loss)]` ...
+   = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
 help: ... or use `try_from` and handle the error accordingly
    |
 LL |     i32::try_from(1isize);
@@ -55,7 +55,7 @@ error: casting `isize` to `u32` may truncate the value on targets with 64-bit wi
 LL |     1isize as u32;
    |     ^^^^^^^^^^^^^
    |
-   = help: if this is intentional allow the lint with `#[allow(clippy::cast_precision_loss)]` ...
+   = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
 help: ... or use `try_from` and handle the error accordingly
    |
 LL |     u32::try_from(1isize);
@@ -67,7 +67,7 @@ error: casting `usize` to `u32` may truncate the value on targets with 64-bit wi
 LL |     1usize as u32;
    |     ^^^^^^^^^^^^^
    |
-   = help: if this is intentional allow the lint with `#[allow(clippy::cast_precision_loss)]` ...
+   = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
 help: ... or use `try_from` and handle the error accordingly
    |
 LL |     u32::try_from(1usize);
@@ -79,7 +79,7 @@ error: casting `usize` to `i32` may truncate the value on targets with 64-bit wi
 LL |     1usize as i32;
    |     ^^^^^^^^^^^^^
    |
-   = help: if this is intentional allow the lint with `#[allow(clippy::cast_precision_loss)]` ...
+   = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
 help: ... or use `try_from` and handle the error accordingly
    |
 LL |     i32::try_from(1usize);
@@ -99,7 +99,7 @@ error: casting `i64` to `isize` may truncate the value on targets with 32-bit wi
 LL |     1i64 as isize;
    |     ^^^^^^^^^^^^^
    |
-   = help: if this is intentional allow the lint with `#[allow(clippy::cast_precision_loss)]` ...
+   = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
 help: ... or use `try_from` and handle the error accordingly
    |
 LL |     isize::try_from(1i64);
@@ -111,7 +111,7 @@ error: casting `i64` to `usize` may truncate the value on targets with 32-bit wi
 LL |     1i64 as usize;
    |     ^^^^^^^^^^^^^
    |
-   = help: if this is intentional allow the lint with `#[allow(clippy::cast_precision_loss)]` ...
+   = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
 help: ... or use `try_from` and handle the error accordingly
    |
 LL |     usize::try_from(1i64);
@@ -123,7 +123,7 @@ error: casting `u64` to `isize` may truncate the value on targets with 32-bit wi
 LL |     1u64 as isize;
    |     ^^^^^^^^^^^^^
    |
-   = help: if this is intentional allow the lint with `#[allow(clippy::cast_precision_loss)]` ...
+   = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
 help: ... or use `try_from` and handle the error accordingly
    |
 LL |     isize::try_from(1u64);
@@ -141,7 +141,7 @@ error: casting `u64` to `usize` may truncate the value on targets with 32-bit wi
 LL |     1u64 as usize;
    |     ^^^^^^^^^^^^^
    |
-   = help: if this is intentional allow the lint with `#[allow(clippy::cast_precision_loss)]` ...
+   = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
 help: ... or use `try_from` and handle the error accordingly
    |
 LL |     usize::try_from(1u64);
-- 
cgit 1.4.1-3-g733a5


From 09d3097734883a78b69f111a9ecf2154c7da9ce7 Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Sun, 12 Feb 2023 15:40:06 +0100
Subject: manual_let_else: do not suggest semantically different replacements

---
 clippy_lints/src/manual_let_else.rs   |  7 +++++++
 tests/ui/manual_let_else_match.rs     | 29 +++++++++++++++++++++++++++--
 tests/ui/manual_let_else_match.stderr | 15 ++++++++++++---
 3 files changed, 46 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_let_else.rs b/clippy_lints/src/manual_let_else.rs
index 9c6f8b43c07..9eacb383514 100644
--- a/clippy_lints/src/manual_let_else.rs
+++ b/clippy_lints/src/manual_let_else.rs
@@ -115,6 +115,13 @@ impl<'tcx> LateLintPass<'tcx> for ManualLetElse {
                     .enumerate()
                     .find(|(_, arm)| expr_diverges(cx, arm.body) && pat_allowed_for_else(cx, arm.pat, check_types));
                 let Some((idx, diverging_arm)) = diverging_arm_opt else { return; };
+                // If the non-diverging arm is the first one, its pattern can be reused in a let/else statement.
+                // However, if it arrives in second position, its pattern may cover some cases already covered
+                // by the diverging one.
+                // TODO: accept the non-diverging arm as a second position if patterns are disjointed.
+                if idx == 0 {
+                    return;
+                }
                 let pat_arm = &arms[1 - idx];
                 if !expr_is_simple_identity(pat_arm.pat, pat_arm.body) {
                     return;
diff --git a/tests/ui/manual_let_else_match.rs b/tests/ui/manual_let_else_match.rs
index 28caed9d79d..73b74679125 100644
--- a/tests/ui/manual_let_else_match.rs
+++ b/tests/ui/manual_let_else_match.rs
@@ -42,13 +42,13 @@ fn fire() {
     loop {
         // More complex pattern for the identity arm and diverging arm
         let v = match h() {
-            (Some(_), Some(_)) | (None, None) => continue,
             (Some(v), None) | (None, Some(v)) => v,
+            (Some(_), Some(_)) | (None, None) => continue,
         };
         // Custom enums are supported as long as the "else" arm is a simple _
         let v = match build_enum() {
-            _ => continue,
             Variant::Bar(v) | Variant::Baz(v) => v,
+            _ => continue,
         };
     }
 
@@ -71,6 +71,12 @@ fn fire() {
         Variant::Bar(_) | Variant::Baz(_) => (),
         _ => return,
     };
+
+    let data = [1_u8, 2, 3, 4, 0, 0, 0, 0];
+    let data = match data.as_slice() {
+        [data @ .., 0, 0, 0, 0] | [data @ .., 0, 0] | [data @ .., 0] => data,
+        _ => return,
+    };
 }
 
 fn not_fire() {
@@ -125,4 +131,23 @@ fn not_fire() {
         Ok(v) | Err(Variant::Bar(v) | Variant::Baz(v)) => v,
         Err(Variant::Foo) => return,
     };
+
+    // Issue 10241
+    // The non-divergent arm arrives in second position and
+    // may cover values already matched in the first arm.
+    let v = match h() {
+        (Some(_), Some(_)) | (None, None) => return,
+        (Some(v), _) | (None, Some(v)) => v,
+    };
+
+    let v = match build_enum() {
+        _ => return,
+        Variant::Bar(v) | Variant::Baz(v) => v,
+    };
+
+    let data = [1_u8, 2, 3, 4, 0, 0, 0, 0];
+    let data = match data.as_slice() {
+        [] | [0, 0] => return,
+        [data @ .., 0, 0, 0, 0] | [data @ .., 0, 0] | [data @ ..] => data,
+    };
 }
diff --git a/tests/ui/manual_let_else_match.stderr b/tests/ui/manual_let_else_match.stderr
index cd5e9a9ac39..7abaa0b85d2 100644
--- a/tests/ui/manual_let_else_match.stderr
+++ b/tests/ui/manual_let_else_match.stderr
@@ -22,8 +22,8 @@ error: this could be rewritten as `let...else`
   --> $DIR/manual_let_else_match.rs:44:9
    |
 LL | /         let v = match h() {
-LL | |             (Some(_), Some(_)) | (None, None) => continue,
 LL | |             (Some(v), None) | (None, Some(v)) => v,
+LL | |             (Some(_), Some(_)) | (None, None) => continue,
 LL | |         };
    | |__________^ help: consider writing: `let ((Some(v), None) | (None, Some(v))) = h() else { continue };`
 
@@ -31,8 +31,8 @@ error: this could be rewritten as `let...else`
   --> $DIR/manual_let_else_match.rs:49:9
    |
 LL | /         let v = match build_enum() {
-LL | |             _ => continue,
 LL | |             Variant::Bar(v) | Variant::Baz(v) => v,
+LL | |             _ => continue,
 LL | |         };
    | |__________^ help: consider writing: `let (Variant::Bar(v) | Variant::Baz(v)) = build_enum() else { continue };`
 
@@ -63,5 +63,14 @@ LL | |         _ => return,
 LL | |     };
    | |______^ help: consider writing: `let (Variant::Bar(_) | Variant::Baz(_)) = f else { return };`
 
-error: aborting due to 7 previous errors
+error: this could be rewritten as `let...else`
+  --> $DIR/manual_let_else_match.rs:76:5
+   |
+LL | /     let data = match data.as_slice() {
+LL | |         [data @ .., 0, 0, 0, 0] | [data @ .., 0, 0] | [data @ .., 0] => data,
+LL | |         _ => return,
+LL | |     };
+   | |______^ help: consider writing: `let ([data @ .., 0, 0, 0, 0] | [data @ .., 0, 0] | [data @ .., 0]) = data.as_slice() else { return };`
+
+error: aborting due to 8 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 1b286b128b529d558f92f8dda39ae72759c3fa15 Mon Sep 17 00:00:00 2001
From: Caio <c410.f3r@gmail.com>
Date: Sun, 12 Feb 2023 16:17:37 -0300
Subject: Address comments

---
 clippy_lints/src/significant_drop_tightening.rs | 21 +++------------------
 1 file changed, 3 insertions(+), 18 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/significant_drop_tightening.rs b/clippy_lints/src/significant_drop_tightening.rs
index a509592a1a4..4cc85e38564 100644
--- a/clippy_lints/src/significant_drop_tightening.rs
+++ b/clippy_lints/src/significant_drop_tightening.rs
@@ -273,12 +273,12 @@ impl<'cx, 'sdt, 'tcx> SigDropChecker<'cx, 'sdt, 'tcx> {
 
     pub(crate) fn has_sig_drop_attr(&mut self, ty: Ty<'tcx>) -> bool {
         if let Some(adt) = ty.ty_adt_def() {
-            let iter = get_attr(
+            let mut iter = get_attr(
                 self.cx.sess(),
                 self.cx.tcx.get_attrs_unchecked(adt.did()),
                 "has_significant_drop",
             );
-            if iter.count() > 0 {
+            if iter.next().is_some() {
                 return true;
             }
         }
@@ -360,22 +360,7 @@ impl<'cx, 'sdt, 'tcx> Visitor<'tcx> for SigDropFinder<'cx, 'sdt, 'tcx> {
             | hir::ExprKind::Yield(..) => {
                 walk_expr(self, ex);
             },
-            hir::ExprKind::AddrOf(_, _, _)
-            | hir::ExprKind::Block(_, _)
-            | hir::ExprKind::Break(_, _)
-            | hir::ExprKind::Cast(_, _)
-            | hir::ExprKind::Closure { .. }
-            | hir::ExprKind::ConstBlock(_)
-            | hir::ExprKind::Continue(_)
-            | hir::ExprKind::DropTemps(_)
-            | hir::ExprKind::Err
-            | hir::ExprKind::InlineAsm(_)
-            | hir::ExprKind::Let(_)
-            | hir::ExprKind::Lit(_)
-            | hir::ExprKind::Loop(_, _, _, _)
-            | hir::ExprKind::Path(_)
-            | hir::ExprKind::Struct(_, _, _)
-            | hir::ExprKind::Type(_, _) => {},
+            _ => {},
         }
     }
 }
-- 
cgit 1.4.1-3-g733a5


From e70a7a68bda5d2f5a53a59f26ff87577eade5839 Mon Sep 17 00:00:00 2001
From: Caio <c410.f3r@gmail.com>
Date: Thu, 9 Feb 2023 16:46:13 -0300
Subject: [arithmetic_side_effects] Evaluate integers originated from constant
 declarations

---
 .../src/operators/arithmetic_side_effects.rs       |  23 ++-
 tests/ui/arithmetic_side_effects.rs                |  27 +++
 tests/ui/arithmetic_side_effects.stderr            | 198 ++++++++++-----------
 3 files changed, 140 insertions(+), 108 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/operators/arithmetic_side_effects.rs b/clippy_lints/src/operators/arithmetic_side_effects.rs
index d592f6e814c..4736c4b802d 100644
--- a/clippy_lints/src/operators/arithmetic_side_effects.rs
+++ b/clippy_lints/src/operators/arithmetic_side_effects.rs
@@ -1,6 +1,6 @@
 use super::ARITHMETIC_SIDE_EFFECTS;
 use clippy_utils::{
-    consts::{constant, constant_simple},
+    consts::{constant, constant_simple, Constant},
     diagnostics::span_lint,
     peel_hir_expr_refs, peel_hir_expr_unary,
 };
@@ -97,17 +97,19 @@ impl ArithmeticSideEffects {
         self.expr_span = Some(expr.span);
     }
 
-    /// If `expr` is not a literal integer like `1`, returns `None`.
+    /// Returns the numeric value of a literal integer originated from `expr`, if any.
     ///
-    /// Returns the absolute value of the expression, if this is an integer literal.
-    fn literal_integer(expr: &hir::Expr<'_>) -> Option<u128> {
+    /// Literal integers can be originated from adhoc declarations like `1`, associated constants
+    /// like `i32::MAX` or constant references like `N` from `const N: i32 = 1;`,
+    fn literal_integer(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> Option<u128> {
         let actual = peel_hir_expr_unary(expr).0;
         if let hir::ExprKind::Lit(ref lit) = actual.kind && let ast::LitKind::Int(n, _) = lit.node {
-            Some(n)
+            return Some(n)
         }
-        else {
-            None
+        if let Some((Constant::Int(n), _)) = constant(cx, cx.typeck_results(), expr) {
+            return Some(n);
         }
+        None
     }
 
     /// Manages when the lint should be triggered. Operations in constant environments, hard coded
@@ -143,7 +145,10 @@ impl ArithmeticSideEffects {
         let has_valid_op = if Self::is_integral(lhs_ty) && Self::is_integral(rhs_ty) {
             let (actual_lhs, lhs_ref_counter) = peel_hir_expr_refs(lhs);
             let (actual_rhs, rhs_ref_counter) = peel_hir_expr_refs(rhs);
-            match (Self::literal_integer(actual_lhs), Self::literal_integer(actual_rhs)) {
+            match (
+                Self::literal_integer(cx, actual_lhs),
+                Self::literal_integer(cx, actual_rhs),
+            ) {
                 (None, None) => false,
                 (None, Some(n)) | (Some(n), None) => match (&op.node, n) {
                     (hir::BinOpKind::Div | hir::BinOpKind::Rem, 0) => false,
@@ -180,7 +185,7 @@ impl ArithmeticSideEffects {
             return;
         }
         let actual_un_expr = peel_hir_expr_refs(un_expr).0;
-        if Self::literal_integer(actual_un_expr).is_some() {
+        if Self::literal_integer(cx, actual_un_expr).is_some() {
             return;
         }
         self.issue_lint(cx, expr);
diff --git a/tests/ui/arithmetic_side_effects.rs b/tests/ui/arithmetic_side_effects.rs
index 918cf81c600..2611e3a785f 100644
--- a/tests/ui/arithmetic_side_effects.rs
+++ b/tests/ui/arithmetic_side_effects.rs
@@ -13,6 +13,9 @@
 
 use core::num::{Saturating, Wrapping};
 
+const ONE: i32 = 1;
+const ZERO: i32 = 0;
+
 #[derive(Clone, Copy)]
 pub struct Custom;
 
@@ -182,6 +185,10 @@ pub fn non_overflowing_ops_or_ops_already_handled_by_the_compiler_should_not_tri
     _n += &0;
     _n -= 0;
     _n -= &0;
+    _n += ZERO;
+    _n += &ZERO;
+    _n -= ZERO;
+    _n -= &ZERO;
     _n /= 99;
     _n /= &99;
     _n %= 99;
@@ -190,10 +197,18 @@ pub fn non_overflowing_ops_or_ops_already_handled_by_the_compiler_should_not_tri
     _n *= &0;
     _n *= 1;
     _n *= &1;
+    _n *= ZERO;
+    _n *= &ZERO;
+    _n *= ONE;
+    _n *= &ONE;
     _n += -0;
     _n += &-0;
     _n -= -0;
     _n -= &-0;
+    _n += -ZERO;
+    _n += &-ZERO;
+    _n -= -ZERO;
+    _n -= &-ZERO;
     _n /= -99;
     _n /= &-99;
     _n %= -99;
@@ -208,10 +223,18 @@ pub fn non_overflowing_ops_or_ops_already_handled_by_the_compiler_should_not_tri
     _n = _n + &0;
     _n = 0 + _n;
     _n = &0 + _n;
+    _n = _n + ZERO;
+    _n = _n + &ZERO;
+    _n = ZERO + _n;
+    _n = &ZERO + _n;
     _n = _n - 0;
     _n = _n - &0;
     _n = 0 - _n;
     _n = &0 - _n;
+    _n = _n - ZERO;
+    _n = _n - &ZERO;
+    _n = ZERO - _n;
+    _n = &ZERO - _n;
     _n = _n / 99;
     _n = _n / &99;
     _n = _n % 99;
@@ -222,6 +245,10 @@ pub fn non_overflowing_ops_or_ops_already_handled_by_the_compiler_should_not_tri
     _n = &0 * _n;
     _n = _n * 1;
     _n = _n * &1;
+    _n = ZERO * _n;
+    _n = &ZERO * _n;
+    _n = _n * ONE;
+    _n = _n * &ONE;
     _n = 1 * _n;
     _n = &1 * _n;
     _n = 23 + 85;
diff --git a/tests/ui/arithmetic_side_effects.stderr b/tests/ui/arithmetic_side_effects.stderr
index 5e349f6b497..17a2448fbfc 100644
--- a/tests/ui/arithmetic_side_effects.stderr
+++ b/tests/ui/arithmetic_side_effects.stderr
@@ -1,5 +1,5 @@
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:243:5
+  --> $DIR/arithmetic_side_effects.rs:270:5
    |
 LL |     _n += 1;
    |     ^^^^^^^
@@ -7,589 +7,589 @@ LL |     _n += 1;
    = note: `-D clippy::arithmetic-side-effects` implied by `-D warnings`
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:244:5
+  --> $DIR/arithmetic_side_effects.rs:271:5
    |
 LL |     _n += &1;
    |     ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:245:5
+  --> $DIR/arithmetic_side_effects.rs:272:5
    |
 LL |     _n -= 1;
    |     ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:246:5
+  --> $DIR/arithmetic_side_effects.rs:273:5
    |
 LL |     _n -= &1;
    |     ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:247:5
+  --> $DIR/arithmetic_side_effects.rs:274:5
    |
 LL |     _n /= 0;
    |     ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:248:5
+  --> $DIR/arithmetic_side_effects.rs:275:5
    |
 LL |     _n /= &0;
    |     ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:249:5
+  --> $DIR/arithmetic_side_effects.rs:276:5
    |
 LL |     _n %= 0;
    |     ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:250:5
+  --> $DIR/arithmetic_side_effects.rs:277:5
    |
 LL |     _n %= &0;
    |     ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:251:5
+  --> $DIR/arithmetic_side_effects.rs:278:5
    |
 LL |     _n *= 2;
    |     ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:252:5
+  --> $DIR/arithmetic_side_effects.rs:279:5
    |
 LL |     _n *= &2;
    |     ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:253:5
+  --> $DIR/arithmetic_side_effects.rs:280:5
    |
 LL |     _n += -1;
    |     ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:254:5
+  --> $DIR/arithmetic_side_effects.rs:281:5
    |
 LL |     _n += &-1;
    |     ^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:255:5
+  --> $DIR/arithmetic_side_effects.rs:282:5
    |
 LL |     _n -= -1;
    |     ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:256:5
+  --> $DIR/arithmetic_side_effects.rs:283:5
    |
 LL |     _n -= &-1;
    |     ^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:257:5
+  --> $DIR/arithmetic_side_effects.rs:284:5
    |
 LL |     _n /= -0;
    |     ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:258:5
+  --> $DIR/arithmetic_side_effects.rs:285:5
    |
 LL |     _n /= &-0;
    |     ^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:259:5
+  --> $DIR/arithmetic_side_effects.rs:286:5
    |
 LL |     _n %= -0;
    |     ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:260:5
+  --> $DIR/arithmetic_side_effects.rs:287:5
    |
 LL |     _n %= &-0;
    |     ^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:261:5
+  --> $DIR/arithmetic_side_effects.rs:288:5
    |
 LL |     _n *= -2;
    |     ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:262:5
+  --> $DIR/arithmetic_side_effects.rs:289:5
    |
 LL |     _n *= &-2;
    |     ^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:263:5
+  --> $DIR/arithmetic_side_effects.rs:290:5
    |
 LL |     _custom += Custom;
    |     ^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:264:5
+  --> $DIR/arithmetic_side_effects.rs:291:5
    |
 LL |     _custom += &Custom;
    |     ^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:265:5
+  --> $DIR/arithmetic_side_effects.rs:292:5
    |
 LL |     _custom -= Custom;
    |     ^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:266:5
+  --> $DIR/arithmetic_side_effects.rs:293:5
    |
 LL |     _custom -= &Custom;
    |     ^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:267:5
+  --> $DIR/arithmetic_side_effects.rs:294:5
    |
 LL |     _custom /= Custom;
    |     ^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:268:5
+  --> $DIR/arithmetic_side_effects.rs:295:5
    |
 LL |     _custom /= &Custom;
    |     ^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:269:5
+  --> $DIR/arithmetic_side_effects.rs:296:5
    |
 LL |     _custom %= Custom;
    |     ^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:270:5
+  --> $DIR/arithmetic_side_effects.rs:297:5
    |
 LL |     _custom %= &Custom;
    |     ^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:271:5
+  --> $DIR/arithmetic_side_effects.rs:298:5
    |
 LL |     _custom *= Custom;
    |     ^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:272:5
+  --> $DIR/arithmetic_side_effects.rs:299:5
    |
 LL |     _custom *= &Custom;
    |     ^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:273:5
+  --> $DIR/arithmetic_side_effects.rs:300:5
    |
 LL |     _custom += -Custom;
    |     ^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:274:5
+  --> $DIR/arithmetic_side_effects.rs:301:5
    |
 LL |     _custom += &-Custom;
    |     ^^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:275:5
+  --> $DIR/arithmetic_side_effects.rs:302:5
    |
 LL |     _custom -= -Custom;
    |     ^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:276:5
+  --> $DIR/arithmetic_side_effects.rs:303:5
    |
 LL |     _custom -= &-Custom;
    |     ^^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:277:5
+  --> $DIR/arithmetic_side_effects.rs:304:5
    |
 LL |     _custom /= -Custom;
    |     ^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:278:5
+  --> $DIR/arithmetic_side_effects.rs:305:5
    |
 LL |     _custom /= &-Custom;
    |     ^^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:279:5
+  --> $DIR/arithmetic_side_effects.rs:306:5
    |
 LL |     _custom %= -Custom;
    |     ^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:280:5
+  --> $DIR/arithmetic_side_effects.rs:307:5
    |
 LL |     _custom %= &-Custom;
    |     ^^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:281:5
+  --> $DIR/arithmetic_side_effects.rs:308:5
    |
 LL |     _custom *= -Custom;
    |     ^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:282:5
+  --> $DIR/arithmetic_side_effects.rs:309:5
    |
 LL |     _custom *= &-Custom;
    |     ^^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:285:10
+  --> $DIR/arithmetic_side_effects.rs:312:10
    |
 LL |     _n = _n + 1;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:286:10
+  --> $DIR/arithmetic_side_effects.rs:313:10
    |
 LL |     _n = _n + &1;
    |          ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:287:10
+  --> $DIR/arithmetic_side_effects.rs:314:10
    |
 LL |     _n = 1 + _n;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:288:10
+  --> $DIR/arithmetic_side_effects.rs:315:10
    |
 LL |     _n = &1 + _n;
    |          ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:289:10
+  --> $DIR/arithmetic_side_effects.rs:316:10
    |
 LL |     _n = _n - 1;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:290:10
+  --> $DIR/arithmetic_side_effects.rs:317:10
    |
 LL |     _n = _n - &1;
    |          ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:291:10
+  --> $DIR/arithmetic_side_effects.rs:318:10
    |
 LL |     _n = 1 - _n;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:292:10
+  --> $DIR/arithmetic_side_effects.rs:319:10
    |
 LL |     _n = &1 - _n;
    |          ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:293:10
+  --> $DIR/arithmetic_side_effects.rs:320:10
    |
 LL |     _n = _n / 0;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:294:10
+  --> $DIR/arithmetic_side_effects.rs:321:10
    |
 LL |     _n = _n / &0;
    |          ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:295:10
+  --> $DIR/arithmetic_side_effects.rs:322:10
    |
 LL |     _n = _n % 0;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:296:10
+  --> $DIR/arithmetic_side_effects.rs:323:10
    |
 LL |     _n = _n % &0;
    |          ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:297:10
+  --> $DIR/arithmetic_side_effects.rs:324:10
    |
 LL |     _n = _n * 2;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:298:10
+  --> $DIR/arithmetic_side_effects.rs:325:10
    |
 LL |     _n = _n * &2;
    |          ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:299:10
+  --> $DIR/arithmetic_side_effects.rs:326:10
    |
 LL |     _n = 2 * _n;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:300:10
+  --> $DIR/arithmetic_side_effects.rs:327:10
    |
 LL |     _n = &2 * _n;
    |          ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:301:10
+  --> $DIR/arithmetic_side_effects.rs:328:10
    |
 LL |     _n = 23 + &85;
    |          ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:302:10
+  --> $DIR/arithmetic_side_effects.rs:329:10
    |
 LL |     _n = &23 + 85;
    |          ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:303:10
+  --> $DIR/arithmetic_side_effects.rs:330:10
    |
 LL |     _n = &23 + &85;
    |          ^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:304:15
+  --> $DIR/arithmetic_side_effects.rs:331:15
    |
 LL |     _custom = _custom + _custom;
    |               ^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:305:15
+  --> $DIR/arithmetic_side_effects.rs:332:15
    |
 LL |     _custom = _custom + &_custom;
    |               ^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:306:15
+  --> $DIR/arithmetic_side_effects.rs:333:15
    |
 LL |     _custom = Custom + _custom;
    |               ^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:307:15
+  --> $DIR/arithmetic_side_effects.rs:334:15
    |
 LL |     _custom = &Custom + _custom;
    |               ^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:308:15
+  --> $DIR/arithmetic_side_effects.rs:335:15
    |
 LL |     _custom = _custom - Custom;
    |               ^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:309:15
+  --> $DIR/arithmetic_side_effects.rs:336:15
    |
 LL |     _custom = _custom - &Custom;
    |               ^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:310:15
+  --> $DIR/arithmetic_side_effects.rs:337:15
    |
 LL |     _custom = Custom - _custom;
    |               ^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:311:15
+  --> $DIR/arithmetic_side_effects.rs:338:15
    |
 LL |     _custom = &Custom - _custom;
    |               ^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:312:15
+  --> $DIR/arithmetic_side_effects.rs:339:15
    |
 LL |     _custom = _custom / Custom;
    |               ^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:313:15
+  --> $DIR/arithmetic_side_effects.rs:340:15
    |
 LL |     _custom = _custom / &Custom;
    |               ^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:314:15
+  --> $DIR/arithmetic_side_effects.rs:341:15
    |
 LL |     _custom = _custom % Custom;
    |               ^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:315:15
+  --> $DIR/arithmetic_side_effects.rs:342:15
    |
 LL |     _custom = _custom % &Custom;
    |               ^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:316:15
+  --> $DIR/arithmetic_side_effects.rs:343:15
    |
 LL |     _custom = _custom * Custom;
    |               ^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:317:15
+  --> $DIR/arithmetic_side_effects.rs:344:15
    |
 LL |     _custom = _custom * &Custom;
    |               ^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:318:15
+  --> $DIR/arithmetic_side_effects.rs:345:15
    |
 LL |     _custom = Custom * _custom;
    |               ^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:319:15
+  --> $DIR/arithmetic_side_effects.rs:346:15
    |
 LL |     _custom = &Custom * _custom;
    |               ^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:320:15
+  --> $DIR/arithmetic_side_effects.rs:347:15
    |
 LL |     _custom = Custom + &Custom;
    |               ^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:321:15
+  --> $DIR/arithmetic_side_effects.rs:348:15
    |
 LL |     _custom = &Custom + Custom;
    |               ^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:322:15
+  --> $DIR/arithmetic_side_effects.rs:349:15
    |
 LL |     _custom = &Custom + &Custom;
    |               ^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:325:10
+  --> $DIR/arithmetic_side_effects.rs:352:10
    |
 LL |     _n = -_n;
    |          ^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:326:10
+  --> $DIR/arithmetic_side_effects.rs:353:10
    |
 LL |     _n = -&_n;
    |          ^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:327:15
+  --> $DIR/arithmetic_side_effects.rs:354:15
    |
 LL |     _custom = -_custom;
    |               ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:328:15
+  --> $DIR/arithmetic_side_effects.rs:355:15
    |
 LL |     _custom = -&_custom;
    |               ^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:337:5
+  --> $DIR/arithmetic_side_effects.rs:364:5
    |
 LL |     1 + i;
    |     ^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:338:5
+  --> $DIR/arithmetic_side_effects.rs:365:5
    |
 LL |     i * 2;
    |     ^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:340:5
+  --> $DIR/arithmetic_side_effects.rs:367:5
    |
 LL |     i - 2 + 2 - i;
    |     ^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:341:5
+  --> $DIR/arithmetic_side_effects.rs:368:5
    |
 LL |     -i;
    |     ^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:342:5
+  --> $DIR/arithmetic_side_effects.rs:369:5
    |
 LL |     i >> 1;
    |     ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:343:5
+  --> $DIR/arithmetic_side_effects.rs:370:5
    |
 LL |     i << 1;
    |     ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:352:5
+  --> $DIR/arithmetic_side_effects.rs:379:5
    |
 LL |     i += 1;
    |     ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:353:5
+  --> $DIR/arithmetic_side_effects.rs:380:5
    |
 LL |     i -= 1;
    |     ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:354:5
+  --> $DIR/arithmetic_side_effects.rs:381:5
    |
 LL |     i *= 2;
    |     ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:356:5
+  --> $DIR/arithmetic_side_effects.rs:383:5
    |
 LL |     i /= 0;
    |     ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:358:5
+  --> $DIR/arithmetic_side_effects.rs:385:5
    |
 LL |     i /= var1;
    |     ^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:359:5
+  --> $DIR/arithmetic_side_effects.rs:386:5
    |
 LL |     i /= var2;
    |     ^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:361:5
+  --> $DIR/arithmetic_side_effects.rs:388:5
    |
 LL |     i %= 0;
    |     ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:363:5
+  --> $DIR/arithmetic_side_effects.rs:390:5
    |
 LL |     i %= var1;
    |     ^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:364:5
+  --> $DIR/arithmetic_side_effects.rs:391:5
    |
 LL |     i %= var2;
    |     ^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:365:5
+  --> $DIR/arithmetic_side_effects.rs:392:5
    |
 LL |     i <<= 3;
    |     ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:366:5
+  --> $DIR/arithmetic_side_effects.rs:393:5
    |
 LL |     i >>= 2;
    |     ^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From 1ed8ed3435ab5dca63694d536f91b1d225da868d Mon Sep 17 00:00:00 2001
From: Caio <c410.f3r@gmail.com>
Date: Sun, 12 Feb 2023 16:27:30 -0300
Subject: Address comment

---
 clippy_lints/src/operators/arithmetic_side_effects.rs | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/operators/arithmetic_side_effects.rs b/clippy_lints/src/operators/arithmetic_side_effects.rs
index 4736c4b802d..87a8a2ed12b 100644
--- a/clippy_lints/src/operators/arithmetic_side_effects.rs
+++ b/clippy_lints/src/operators/arithmetic_side_effects.rs
@@ -2,7 +2,7 @@ use super::ARITHMETIC_SIDE_EFFECTS;
 use clippy_utils::{
     consts::{constant, constant_simple, Constant},
     diagnostics::span_lint,
-    peel_hir_expr_refs, peel_hir_expr_unary,
+    is_lint_allowed, peel_hir_expr_refs, peel_hir_expr_unary,
 };
 use rustc_ast as ast;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
@@ -191,14 +191,16 @@ impl ArithmeticSideEffects {
         self.issue_lint(cx, expr);
     }
 
-    fn should_skip_expr(&mut self, expr: &hir::Expr<'_>) -> bool {
-        self.expr_span.is_some() || self.const_span.map_or(false, |sp| sp.contains(expr.span))
+    fn should_skip_expr(&mut self, cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> bool {
+        is_lint_allowed(cx, ARITHMETIC_SIDE_EFFECTS, expr.hir_id)
+            || self.expr_span.is_some()
+            || self.const_span.map_or(false, |sp| sp.contains(expr.span))
     }
 }
 
 impl<'tcx> LateLintPass<'tcx> for ArithmeticSideEffects {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &hir::Expr<'tcx>) {
-        if self.should_skip_expr(expr) {
+        if self.should_skip_expr(cx, expr) {
             return;
         }
         match &expr.kind {
-- 
cgit 1.4.1-3-g733a5


From c43937316af1321a97c03a22cd04273eba63d5b9 Mon Sep 17 00:00:00 2001
From: Caio <c410.f3r@gmail.com>
Date: Sun, 12 Feb 2023 17:34:07 -0300
Subject: [arithmetic_side_effects] Fix #10252

---
 .../src/operators/arithmetic_side_effects.rs       |  13 +-
 tests/ui/arithmetic_side_effects.rs                |  28 ++
 tests/ui/arithmetic_side_effects.stderr            | 288 ++++++++++++---------
 3 files changed, 206 insertions(+), 123 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/operators/arithmetic_side_effects.rs b/clippy_lints/src/operators/arithmetic_side_effects.rs
index 87a8a2ed12b..25e8de94863 100644
--- a/clippy_lints/src/operators/arithmetic_side_effects.rs
+++ b/clippy_lints/src/operators/arithmetic_side_effects.rs
@@ -143,6 +143,10 @@ impl ArithmeticSideEffects {
             return;
         }
         let has_valid_op = if Self::is_integral(lhs_ty) && Self::is_integral(rhs_ty) {
+            if let hir::BinOpKind::Shl | hir::BinOpKind::Shr = op.node {
+                // At least for integers, shifts are already handled by the CTFE
+                return;
+            }
             let (actual_lhs, lhs_ref_counter) = peel_hir_expr_refs(lhs);
             let (actual_rhs, rhs_ref_counter) = peel_hir_expr_refs(rhs);
             match (
@@ -151,10 +155,13 @@ impl ArithmeticSideEffects {
             ) {
                 (None, None) => false,
                 (None, Some(n)) | (Some(n), None) => match (&op.node, n) {
-                    (hir::BinOpKind::Div | hir::BinOpKind::Rem, 0) => false,
+                    // Division and module are always valid if applied to non-zero integers
+                    (hir::BinOpKind::Div | hir::BinOpKind::Rem, local_n) if local_n != 0 => true,
+                    // Addition or subtracting zeros is always a no-op
                     (hir::BinOpKind::Add | hir::BinOpKind::Sub, 0)
-                    | (hir::BinOpKind::Div | hir::BinOpKind::Rem, _)
-                    | (hir::BinOpKind::Mul, 0 | 1) => true,
+                    // Multiplication by 1 or 0 will never overflow
+                    | (hir::BinOpKind::Mul, 0 | 1)
+                    => true,
                     _ => false,
                 },
                 (Some(_), Some(_)) => {
diff --git a/tests/ui/arithmetic_side_effects.rs b/tests/ui/arithmetic_side_effects.rs
index 2611e3a785f..ee7d2ba444b 100644
--- a/tests/ui/arithmetic_side_effects.rs
+++ b/tests/ui/arithmetic_side_effects.rs
@@ -45,24 +45,32 @@ impl_arith!(
     Div, Custom, Custom, div;
     Mul, Custom, Custom, mul;
     Rem, Custom, Custom, rem;
+    Shl, Custom, Custom, shl;
+    Shr, Custom, Custom, shr;
     Sub, Custom, Custom, sub;
 
     Add, Custom, &Custom, add;
     Div, Custom, &Custom, div;
     Mul, Custom, &Custom, mul;
     Rem, Custom, &Custom, rem;
+    Shl, Custom, &Custom, shl;
+    Shr, Custom, &Custom, shr;
     Sub, Custom, &Custom, sub;
 
     Add, &Custom, Custom, add;
     Div, &Custom, Custom, div;
     Mul, &Custom, Custom, mul;
     Rem, &Custom, Custom, rem;
+    Shl, &Custom, Custom, shl;
+    Shr, &Custom, Custom, shr;
     Sub, &Custom, Custom, sub;
 
     Add, &Custom, &Custom, add;
     Div, &Custom, &Custom, div;
     Mul, &Custom, &Custom, mul;
     Rem, &Custom, &Custom, rem;
+    Shl, &Custom, &Custom, shl;
+    Shr, &Custom, &Custom, shr;
     Sub, &Custom, &Custom, sub;
 );
 
@@ -71,24 +79,32 @@ impl_assign_arith!(
     DivAssign, Custom, Custom, div_assign;
     MulAssign, Custom, Custom, mul_assign;
     RemAssign, Custom, Custom, rem_assign;
+    ShlAssign, Custom, Custom, shl_assign;
+    ShrAssign, Custom, Custom, shr_assign;
     SubAssign, Custom, Custom, sub_assign;
 
     AddAssign, Custom, &Custom, add_assign;
     DivAssign, Custom, &Custom, div_assign;
     MulAssign, Custom, &Custom, mul_assign;
     RemAssign, Custom, &Custom, rem_assign;
+    ShlAssign, Custom, &Custom, shl_assign;
+    ShrAssign, Custom, &Custom, shr_assign;
     SubAssign, Custom, &Custom, sub_assign;
 
     AddAssign, &Custom, Custom, add_assign;
     DivAssign, &Custom, Custom, div_assign;
     MulAssign, &Custom, Custom, mul_assign;
     RemAssign, &Custom, Custom, rem_assign;
+    ShlAssign, &Custom, Custom, shl_assign;
+    ShrAssign, &Custom, Custom, shr_assign;
     SubAssign, &Custom, Custom, sub_assign;
 
     AddAssign, &Custom, &Custom, add_assign;
     DivAssign, &Custom, &Custom, div_assign;
     MulAssign, &Custom, &Custom, mul_assign;
     RemAssign, &Custom, &Custom, rem_assign;
+    ShlAssign, &Custom, &Custom, shl_assign;
+    ShrAssign, &Custom, &Custom, shr_assign;
     SubAssign, &Custom, &Custom, sub_assign;
 );
 
@@ -297,6 +313,10 @@ pub fn unknown_ops_or_runtime_ops_that_can_overflow() {
     _custom %= &Custom;
     _custom *= Custom;
     _custom *= &Custom;
+    _custom >>= Custom;
+    _custom >>= &Custom;
+    _custom <<= Custom;
+    _custom <<= &Custom;
     _custom += -Custom;
     _custom += &-Custom;
     _custom -= -Custom;
@@ -307,6 +327,10 @@ pub fn unknown_ops_or_runtime_ops_that_can_overflow() {
     _custom %= &-Custom;
     _custom *= -Custom;
     _custom *= &-Custom;
+    _custom >>= -Custom;
+    _custom >>= &-Custom;
+    _custom <<= -Custom;
+    _custom <<= &-Custom;
 
     // Binary
     _n = _n + 1;
@@ -347,6 +371,10 @@ pub fn unknown_ops_or_runtime_ops_that_can_overflow() {
     _custom = Custom + &Custom;
     _custom = &Custom + Custom;
     _custom = &Custom + &Custom;
+    _custom = _custom >> _custom;
+    _custom = _custom >> &_custom;
+    _custom = Custom << _custom;
+    _custom = &Custom << _custom;
 
     // Unary
     _n = -_n;
diff --git a/tests/ui/arithmetic_side_effects.stderr b/tests/ui/arithmetic_side_effects.stderr
index 17a2448fbfc..3895f08964c 100644
--- a/tests/ui/arithmetic_side_effects.stderr
+++ b/tests/ui/arithmetic_side_effects.stderr
@@ -1,5 +1,5 @@
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:270:5
+  --> $DIR/arithmetic_side_effects.rs:286:5
    |
 LL |     _n += 1;
    |     ^^^^^^^
@@ -7,592 +7,640 @@ LL |     _n += 1;
    = note: `-D clippy::arithmetic-side-effects` implied by `-D warnings`
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:271:5
+  --> $DIR/arithmetic_side_effects.rs:287:5
    |
 LL |     _n += &1;
    |     ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:272:5
+  --> $DIR/arithmetic_side_effects.rs:288:5
    |
 LL |     _n -= 1;
    |     ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:273:5
+  --> $DIR/arithmetic_side_effects.rs:289:5
    |
 LL |     _n -= &1;
    |     ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:274:5
+  --> $DIR/arithmetic_side_effects.rs:290:5
    |
 LL |     _n /= 0;
    |     ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:275:5
+  --> $DIR/arithmetic_side_effects.rs:291:5
    |
 LL |     _n /= &0;
    |     ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:276:5
+  --> $DIR/arithmetic_side_effects.rs:292:5
    |
 LL |     _n %= 0;
    |     ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:277:5
+  --> $DIR/arithmetic_side_effects.rs:293:5
    |
 LL |     _n %= &0;
    |     ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:278:5
+  --> $DIR/arithmetic_side_effects.rs:294:5
    |
 LL |     _n *= 2;
    |     ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:279:5
+  --> $DIR/arithmetic_side_effects.rs:295:5
    |
 LL |     _n *= &2;
    |     ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:280:5
+  --> $DIR/arithmetic_side_effects.rs:296:5
    |
 LL |     _n += -1;
    |     ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:281:5
+  --> $DIR/arithmetic_side_effects.rs:297:5
    |
 LL |     _n += &-1;
    |     ^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:282:5
+  --> $DIR/arithmetic_side_effects.rs:298:5
    |
 LL |     _n -= -1;
    |     ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:283:5
+  --> $DIR/arithmetic_side_effects.rs:299:5
    |
 LL |     _n -= &-1;
    |     ^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:284:5
+  --> $DIR/arithmetic_side_effects.rs:300:5
    |
 LL |     _n /= -0;
    |     ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:285:5
+  --> $DIR/arithmetic_side_effects.rs:301:5
    |
 LL |     _n /= &-0;
    |     ^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:286:5
+  --> $DIR/arithmetic_side_effects.rs:302:5
    |
 LL |     _n %= -0;
    |     ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:287:5
+  --> $DIR/arithmetic_side_effects.rs:303:5
    |
 LL |     _n %= &-0;
    |     ^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:288:5
+  --> $DIR/arithmetic_side_effects.rs:304:5
    |
 LL |     _n *= -2;
    |     ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:289:5
+  --> $DIR/arithmetic_side_effects.rs:305:5
    |
 LL |     _n *= &-2;
    |     ^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:290:5
+  --> $DIR/arithmetic_side_effects.rs:306:5
    |
 LL |     _custom += Custom;
    |     ^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:291:5
+  --> $DIR/arithmetic_side_effects.rs:307:5
    |
 LL |     _custom += &Custom;
    |     ^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:292:5
+  --> $DIR/arithmetic_side_effects.rs:308:5
    |
 LL |     _custom -= Custom;
    |     ^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:293:5
+  --> $DIR/arithmetic_side_effects.rs:309:5
    |
 LL |     _custom -= &Custom;
    |     ^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:294:5
+  --> $DIR/arithmetic_side_effects.rs:310:5
    |
 LL |     _custom /= Custom;
    |     ^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:295:5
+  --> $DIR/arithmetic_side_effects.rs:311:5
    |
 LL |     _custom /= &Custom;
    |     ^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:296:5
+  --> $DIR/arithmetic_side_effects.rs:312:5
    |
 LL |     _custom %= Custom;
    |     ^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:297:5
+  --> $DIR/arithmetic_side_effects.rs:313:5
    |
 LL |     _custom %= &Custom;
    |     ^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:298:5
+  --> $DIR/arithmetic_side_effects.rs:314:5
    |
 LL |     _custom *= Custom;
    |     ^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:299:5
+  --> $DIR/arithmetic_side_effects.rs:315:5
    |
 LL |     _custom *= &Custom;
    |     ^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:300:5
+  --> $DIR/arithmetic_side_effects.rs:316:5
+   |
+LL |     _custom >>= Custom;
+   |     ^^^^^^^^^^^^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:317:5
+   |
+LL |     _custom >>= &Custom;
+   |     ^^^^^^^^^^^^^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:318:5
+   |
+LL |     _custom <<= Custom;
+   |     ^^^^^^^^^^^^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:319:5
+   |
+LL |     _custom <<= &Custom;
+   |     ^^^^^^^^^^^^^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:320:5
    |
 LL |     _custom += -Custom;
    |     ^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:301:5
+  --> $DIR/arithmetic_side_effects.rs:321:5
    |
 LL |     _custom += &-Custom;
    |     ^^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:302:5
+  --> $DIR/arithmetic_side_effects.rs:322:5
    |
 LL |     _custom -= -Custom;
    |     ^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:303:5
+  --> $DIR/arithmetic_side_effects.rs:323:5
    |
 LL |     _custom -= &-Custom;
    |     ^^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:304:5
+  --> $DIR/arithmetic_side_effects.rs:324:5
    |
 LL |     _custom /= -Custom;
    |     ^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:305:5
+  --> $DIR/arithmetic_side_effects.rs:325:5
    |
 LL |     _custom /= &-Custom;
    |     ^^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:306:5
+  --> $DIR/arithmetic_side_effects.rs:326:5
    |
 LL |     _custom %= -Custom;
    |     ^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:307:5
+  --> $DIR/arithmetic_side_effects.rs:327:5
    |
 LL |     _custom %= &-Custom;
    |     ^^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:308:5
+  --> $DIR/arithmetic_side_effects.rs:328:5
    |
 LL |     _custom *= -Custom;
    |     ^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:309:5
+  --> $DIR/arithmetic_side_effects.rs:329:5
    |
 LL |     _custom *= &-Custom;
    |     ^^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:312:10
+  --> $DIR/arithmetic_side_effects.rs:330:5
+   |
+LL |     _custom >>= -Custom;
+   |     ^^^^^^^^^^^^^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:331:5
+   |
+LL |     _custom >>= &-Custom;
+   |     ^^^^^^^^^^^^^^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:332:5
+   |
+LL |     _custom <<= -Custom;
+   |     ^^^^^^^^^^^^^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:333:5
+   |
+LL |     _custom <<= &-Custom;
+   |     ^^^^^^^^^^^^^^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:336:10
    |
 LL |     _n = _n + 1;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:313:10
+  --> $DIR/arithmetic_side_effects.rs:337:10
    |
 LL |     _n = _n + &1;
    |          ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:314:10
+  --> $DIR/arithmetic_side_effects.rs:338:10
    |
 LL |     _n = 1 + _n;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:315:10
+  --> $DIR/arithmetic_side_effects.rs:339:10
    |
 LL |     _n = &1 + _n;
    |          ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:316:10
+  --> $DIR/arithmetic_side_effects.rs:340:10
    |
 LL |     _n = _n - 1;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:317:10
+  --> $DIR/arithmetic_side_effects.rs:341:10
    |
 LL |     _n = _n - &1;
    |          ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:318:10
+  --> $DIR/arithmetic_side_effects.rs:342:10
    |
 LL |     _n = 1 - _n;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:319:10
+  --> $DIR/arithmetic_side_effects.rs:343:10
    |
 LL |     _n = &1 - _n;
    |          ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:320:10
+  --> $DIR/arithmetic_side_effects.rs:344:10
    |
 LL |     _n = _n / 0;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:321:10
+  --> $DIR/arithmetic_side_effects.rs:345:10
    |
 LL |     _n = _n / &0;
    |          ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:322:10
+  --> $DIR/arithmetic_side_effects.rs:346:10
    |
 LL |     _n = _n % 0;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:323:10
+  --> $DIR/arithmetic_side_effects.rs:347:10
    |
 LL |     _n = _n % &0;
    |          ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:324:10
+  --> $DIR/arithmetic_side_effects.rs:348:10
    |
 LL |     _n = _n * 2;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:325:10
+  --> $DIR/arithmetic_side_effects.rs:349:10
    |
 LL |     _n = _n * &2;
    |          ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:326:10
+  --> $DIR/arithmetic_side_effects.rs:350:10
    |
 LL |     _n = 2 * _n;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:327:10
+  --> $DIR/arithmetic_side_effects.rs:351:10
    |
 LL |     _n = &2 * _n;
    |          ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:328:10
+  --> $DIR/arithmetic_side_effects.rs:352:10
    |
 LL |     _n = 23 + &85;
    |          ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:329:10
+  --> $DIR/arithmetic_side_effects.rs:353:10
    |
 LL |     _n = &23 + 85;
    |          ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:330:10
+  --> $DIR/arithmetic_side_effects.rs:354:10
    |
 LL |     _n = &23 + &85;
    |          ^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:331:15
+  --> $DIR/arithmetic_side_effects.rs:355:15
    |
 LL |     _custom = _custom + _custom;
    |               ^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:332:15
+  --> $DIR/arithmetic_side_effects.rs:356:15
    |
 LL |     _custom = _custom + &_custom;
    |               ^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:333:15
+  --> $DIR/arithmetic_side_effects.rs:357:15
    |
 LL |     _custom = Custom + _custom;
    |               ^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:334:15
+  --> $DIR/arithmetic_side_effects.rs:358:15
    |
 LL |     _custom = &Custom + _custom;
    |               ^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:335:15
+  --> $DIR/arithmetic_side_effects.rs:359:15
    |
 LL |     _custom = _custom - Custom;
    |               ^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:336:15
+  --> $DIR/arithmetic_side_effects.rs:360:15
    |
 LL |     _custom = _custom - &Custom;
    |               ^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:337:15
+  --> $DIR/arithmetic_side_effects.rs:361:15
    |
 LL |     _custom = Custom - _custom;
    |               ^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:338:15
+  --> $DIR/arithmetic_side_effects.rs:362:15
    |
 LL |     _custom = &Custom - _custom;
    |               ^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:339:15
+  --> $DIR/arithmetic_side_effects.rs:363:15
    |
 LL |     _custom = _custom / Custom;
    |               ^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:340:15
+  --> $DIR/arithmetic_side_effects.rs:364:15
    |
 LL |     _custom = _custom / &Custom;
    |               ^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:341:15
+  --> $DIR/arithmetic_side_effects.rs:365:15
    |
 LL |     _custom = _custom % Custom;
    |               ^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:342:15
+  --> $DIR/arithmetic_side_effects.rs:366:15
    |
 LL |     _custom = _custom % &Custom;
    |               ^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:343:15
+  --> $DIR/arithmetic_side_effects.rs:367:15
    |
 LL |     _custom = _custom * Custom;
    |               ^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:344:15
+  --> $DIR/arithmetic_side_effects.rs:368:15
    |
 LL |     _custom = _custom * &Custom;
    |               ^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:345:15
+  --> $DIR/arithmetic_side_effects.rs:369:15
    |
 LL |     _custom = Custom * _custom;
    |               ^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:346:15
+  --> $DIR/arithmetic_side_effects.rs:370:15
    |
 LL |     _custom = &Custom * _custom;
    |               ^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:347:15
+  --> $DIR/arithmetic_side_effects.rs:371:15
    |
 LL |     _custom = Custom + &Custom;
    |               ^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:348:15
+  --> $DIR/arithmetic_side_effects.rs:372:15
    |
 LL |     _custom = &Custom + Custom;
    |               ^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:349:15
+  --> $DIR/arithmetic_side_effects.rs:373:15
    |
 LL |     _custom = &Custom + &Custom;
    |               ^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:352:10
+  --> $DIR/arithmetic_side_effects.rs:374:15
+   |
+LL |     _custom = _custom >> _custom;
+   |               ^^^^^^^^^^^^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:375:15
+   |
+LL |     _custom = _custom >> &_custom;
+   |               ^^^^^^^^^^^^^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:376:15
+   |
+LL |     _custom = Custom << _custom;
+   |               ^^^^^^^^^^^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:377:15
+   |
+LL |     _custom = &Custom << _custom;
+   |               ^^^^^^^^^^^^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:380:10
    |
 LL |     _n = -_n;
    |          ^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:353:10
+  --> $DIR/arithmetic_side_effects.rs:381:10
    |
 LL |     _n = -&_n;
    |          ^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:354:15
+  --> $DIR/arithmetic_side_effects.rs:382:15
    |
 LL |     _custom = -_custom;
    |               ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:355:15
+  --> $DIR/arithmetic_side_effects.rs:383:15
    |
 LL |     _custom = -&_custom;
    |               ^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:364:5
+  --> $DIR/arithmetic_side_effects.rs:392:5
    |
 LL |     1 + i;
    |     ^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:365:5
+  --> $DIR/arithmetic_side_effects.rs:393:5
    |
 LL |     i * 2;
    |     ^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:367:5
+  --> $DIR/arithmetic_side_effects.rs:395:5
    |
 LL |     i - 2 + 2 - i;
    |     ^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:368:5
+  --> $DIR/arithmetic_side_effects.rs:396:5
    |
 LL |     -i;
    |     ^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:369:5
-   |
-LL |     i >> 1;
-   |     ^^^^^^
-
-error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:370:5
-   |
-LL |     i << 1;
-   |     ^^^^^^
-
-error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:379:5
+  --> $DIR/arithmetic_side_effects.rs:407:5
    |
 LL |     i += 1;
    |     ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:380:5
+  --> $DIR/arithmetic_side_effects.rs:408:5
    |
 LL |     i -= 1;
    |     ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:381:5
+  --> $DIR/arithmetic_side_effects.rs:409:5
    |
 LL |     i *= 2;
    |     ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:383:5
+  --> $DIR/arithmetic_side_effects.rs:411:5
    |
 LL |     i /= 0;
    |     ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:385:5
+  --> $DIR/arithmetic_side_effects.rs:413:5
    |
 LL |     i /= var1;
    |     ^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:386:5
+  --> $DIR/arithmetic_side_effects.rs:414:5
    |
 LL |     i /= var2;
    |     ^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:388:5
+  --> $DIR/arithmetic_side_effects.rs:416:5
    |
 LL |     i %= 0;
    |     ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:390:5
+  --> $DIR/arithmetic_side_effects.rs:418:5
    |
 LL |     i %= var1;
    |     ^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:391:5
+  --> $DIR/arithmetic_side_effects.rs:419:5
    |
 LL |     i %= var2;
    |     ^^^^^^^^^
 
-error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:392:5
-   |
-LL |     i <<= 3;
-   |     ^^^^^^^
-
-error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:393:5
-   |
-LL |     i >>= 2;
-   |     ^^^^^^^
-
-error: aborting due to 99 previous errors
+error: aborting due to 107 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 1f77866991568557e69e2135369ab2a512052a6b Mon Sep 17 00:00:00 2001
From: Mara Bos <m-ou.se@m-ou.se>
Date: Sun, 12 Feb 2023 22:00:13 +0100
Subject: Add SUSPICIOUS_COMMAND_ARG_SPACE to lint pass.

---
 clippy_lints/src/methods/mod.rs | 1 +
 1 file changed, 1 insertion(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 7e34d08ea32..d8c018f7591 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3316,6 +3316,7 @@ impl_lint_pass!(Methods => [
     SEEK_FROM_CURRENT,
     SEEK_TO_START_INSTEAD_OF_REWIND,
     NEEDLESS_COLLECT,
+    SUSPICIOUS_COMMAND_ARG_SPACE,
 ]);
 
 /// Extracts a method call name, args, and `Span` of the method name.
-- 
cgit 1.4.1-3-g733a5


From ebca1b5d008f87bb0d5712144f68dce18b28c261 Mon Sep 17 00:00:00 2001
From: chansuke <moonset20@gmail.com>
Date: Sun, 8 Jan 2023 20:02:50 +0900
Subject: Refactor `almost_swapped` to lint with `let` statement correctly

---
 clippy_lints/src/swap.rs       | 167 ++++++++++++++---------------------------
 tests/ui/almost_swapped.rs     |  32 --------
 tests/ui/almost_swapped.stderr |  30 --------
 tests/ui/swap.fixed            |  24 +++++-
 tests/ui/swap.rs               |  29 ++++++-
 tests/ui/swap.stderr           |  65 ++++++++++++----
 6 files changed, 159 insertions(+), 188 deletions(-)
 delete mode 100644 tests/ui/almost_swapped.rs
 delete mode 100644 tests/ui/almost_swapped.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/swap.rs b/clippy_lints/src/swap.rs
index 5c408a73a55..0f062cecf88 100644
--- a/clippy_lints/src/swap.rs
+++ b/clippy_lints/src/swap.rs
@@ -10,7 +10,7 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Spanned;
-use rustc_span::{sym, Span};
+use rustc_span::{sym, symbol::Ident, Span};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -172,129 +172,76 @@ fn check_manual_swap(cx: &LateContext<'_>, block: &Block<'_>) {
     }
 }
 
-#[allow(clippy::too_many_lines)]
 /// Implementation of the `ALMOST_SWAPPED` lint.
 fn check_suspicious_swap(cx: &LateContext<'_>, block: &Block<'_>) {
-    for w in block.stmts.windows(2) {
-        if_chain! {
-            if let StmtKind::Semi(first) = w[0].kind;
-            if let StmtKind::Semi(second) = w[1].kind;
-            if first.span.ctxt() == second.span.ctxt();
-            if let ExprKind::Assign(lhs0, rhs0, _) = first.kind;
-            if let ExprKind::Assign(lhs1, rhs1, _) = second.kind;
-            if eq_expr_value(cx, lhs0, rhs1);
-            if eq_expr_value(cx, lhs1, rhs0);
-            then {
-                let lhs0 = Sugg::hir_opt(cx, lhs0);
-                let rhs0 = Sugg::hir_opt(cx, rhs0);
-                let (what, lhs, rhs) = if let (Some(first), Some(second)) = (lhs0, rhs0) {
-                    (
-                        format!(" `{first}` and `{second}`"),
-                        first.mut_addr().to_string(),
-                        second.mut_addr().to_string(),
-                    )
-                } else {
-                    (String::new(), String::new(), String::new())
-                };
-
-                let span = first.span.to(second.span);
-                let Some(sugg) = std_or_core(cx) else { return };
-
-                span_lint_and_then(cx,
-                    ALMOST_SWAPPED,
-                    span,
-                    &format!("this looks like you are trying to swap{what}"),
-                    |diag| {
-                        if !what.is_empty() {
-                            diag.span_suggestion(
-                                span,
-                                "try",
-                                format!(
-                                    "{sugg}::mem::swap({lhs}, {rhs})",
-                                ),
-                                Applicability::MaybeIncorrect,
-                            );
-                            diag.note(
-                                format!("or maybe you should use `{sugg}::mem::replace`?")
-                            );
-                        }
-                    });
+    for [first, second] in block.stmts.array_windows() {
+        if let Some((lhs0, rhs0)) = parse(first)
+            && let Some((lhs1, rhs1)) = parse(second)
+            && first.span.eq_ctxt(second.span)
+            && is_same(cx, lhs0, rhs1)
+            && is_same(cx, lhs1, rhs0)
+            && let Some(lhs_sugg) = match &lhs0 {
+                ExprOrIdent::Expr(expr) => Sugg::hir_opt(cx, expr),
+                ExprOrIdent::Ident(ident) => Some(Sugg::NonParen(ident.as_str().into())),
             }
-        }
-
-        let lint_almost_swapped_note = |span, what: String, sugg, lhs, rhs| {
+            && let Some(rhs_sugg) = Sugg::hir_opt(cx, rhs0)
+        {
+            let span = first.span.to(rhs1.span);
+            let Some(sugg) = std_or_core(cx) else { return };
             span_lint_and_then(
                 cx,
                 ALMOST_SWAPPED,
                 span,
-                &format!("this looks like you are trying to swap{}", what),
+                &format!("this looks like you are trying to swap `{lhs_sugg}` and `{rhs_sugg}`"),
                 |diag| {
-                    if !what.is_empty() {
-                        diag.note(&format!(
-                            "maybe you could use `{sugg}::mem::swap({lhs}, {rhs})` or `{sugg}::mem::replace`?"
-                        ));
-                    }
+                    diag.span_suggestion(
+                        span,
+                        "try",
+                        format!("{sugg}::mem::swap({}, {})", lhs_sugg.mut_addr(), rhs_sugg.mut_addr()),
+                        Applicability::MaybeIncorrect,
+                    );
+                    diag.note(format!("or maybe you should use `{sugg}::mem::replace`?"));
                 },
             );
-        };
-
-        if let StmtKind::Local(first) = w[0].kind
-            && let StmtKind::Local(second) = w[1].kind
-            && first.span.ctxt() == second.span.ctxt()
-            && let Some(rhs0) = first.init
-            && let Some(rhs1) = second.init
-            && let ExprKind::Path(QPath::Resolved(None, path_l)) = rhs0.kind
-            && let ExprKind::Path(QPath::Resolved(None, path_r)) = rhs1.kind
-            && let PatKind::Binding(_,_, ident_l,_) = first.pat.kind
-            && let PatKind::Binding(_,_, ident_r,_) = second.pat.kind
-            && ident_l.name.as_str() == path_r.segments.iter().map(|el| el.ident.to_string()).collect::<Vec<_>>().join("::")
-            && ident_r.name.as_str() == path_l.segments.iter().map(|el| el.ident.to_string()).collect::<Vec<_>>().join("::") 
-                {
-                    let rhs0 = Sugg::hir_opt(cx, rhs0);
-                    let (what, lhs, rhs) = if let Some(second) = rhs0 {
-                        (
-                            format!(" `{}` and `{}`", ident_l, second),
-                            format!("&mut {}", ident_l),
-                            second.mut_addr().to_string(),
-                        )
-                    } else {
-                        (String::new(), String::new(), String::new())
-                    };
-                    let span = first.span.to(second.span);
-                    let Some(sugg) = std_or_core(cx) else { return };
+        }
+    }
+}
 
-                    lint_almost_swapped_note(span, what, sugg, lhs, rhs);
-                }
+fn is_same(cx: &LateContext<'_>, lhs: ExprOrIdent<'_>, rhs: &Expr<'_>) -> bool {
+    match lhs {
+        ExprOrIdent::Expr(expr) => eq_expr_value(cx, expr, rhs),
+        ExprOrIdent::Ident(ident) => {
+            if let ExprKind::Path(QPath::Resolved(None, path)) = rhs.kind
+                && let [segment] = &path.segments
+                && segment.ident == ident
+            {
+                true
+            } else {
+                false
+            }
+        }
+    }
+}
 
-        if let StmtKind::Local(first) = w[0].kind
-            && let StmtKind::Semi(second) = w[1].kind
-            && first.span.ctxt() == second.span.ctxt()
-            && let Some(rhs0) = first.init
-            && let ExprKind::Path(QPath::Resolved(None, path_l)) = rhs0.kind
-            && let PatKind::Binding(_,_, ident_l,_) = first.pat.kind
-            && let ExprKind::Assign(lhs1, rhs1, _) = second.kind
-            && let ExprKind::Path(QPath::Resolved(None, lhs1_path)) = lhs1.kind
-            && let ExprKind::Path(QPath::Resolved(None, rhs1_path)) = rhs1.kind
-            && ident_l.name.as_str() == rhs1_path.segments.iter().map(|el| el.ident.to_string()).collect::<Vec<_>>().join("::")
-            && path_l.segments.iter().map(|el| el.ident.to_string()).collect::<Vec<_>>().join("::") == lhs1_path.segments.iter().map(|el| el.ident.to_string()).collect::<Vec<_>>().join("::") 
-                {
-                    let lhs1 = Sugg::hir_opt(cx, lhs1);
-                    let rhs1 = Sugg::hir_opt(cx, rhs1);
-                    let (what, lhs, rhs) = if let (Some(first),Some(second)) = (lhs1,rhs1) {
-                        (
-                            format!(" `{}` and `{}`", first, second),
-                            first.mut_addr().to_string(),
-                            second.mut_addr().to_string(),
-                        )
-                    } else {
-                        (String::new(), String::new(), String::new())
-                    };
-                    let span = first.span.to(second.span);
-                    let Some(sugg) = std_or_core(cx) else { return };
+#[derive(Debug, Clone, Copy)]
+enum ExprOrIdent<'a> {
+    Expr(&'a Expr<'a>),
+    Ident(Ident),
+}
 
-                    lint_almost_swapped_note(span, what, sugg, lhs, rhs);
-                }
+fn parse<'a, 'hir>(stmt: &'a Stmt<'hir>) -> Option<(ExprOrIdent<'hir>, &'a Expr<'hir>)> {
+    if let StmtKind::Semi(expr) = stmt.kind {
+        if let ExprKind::Assign(lhs, rhs, _) = expr.kind {
+            return Some((ExprOrIdent::Expr(lhs), rhs));
+        }
+    } else if let StmtKind::Local(expr) = stmt.kind {
+        if let Some(rhs) = expr.init {
+            if let PatKind::Binding(_, _, ident_l, _) = expr.pat.kind {
+                return Some((ExprOrIdent::Ident(ident_l), rhs));
+            }
+        }
     }
+    None
 }
 
 /// Implementation of the xor case for `MANUAL_SWAP` lint.
diff --git a/tests/ui/almost_swapped.rs b/tests/ui/almost_swapped.rs
deleted file mode 100644
index 8b0740c3209..00000000000
--- a/tests/ui/almost_swapped.rs
+++ /dev/null
@@ -1,32 +0,0 @@
-#![allow(clippy::needless_late_init, clippy::manual_swap)]
-#![allow(unused_variables, unused_assignments)]
-#![warn(clippy::almost_swapped)]
-
-fn main() {
-    let b = 1;
-    let a = b;
-    let b = a;
-
-    let mut c = 1;
-    let mut d = 2;
-    d = c;
-    c = d;
-
-    let mut b = 1;
-    let a = b;
-    b = a;
-
-    let b = 1;
-    let a = 2;
-
-    let t = b;
-    let b = a;
-    let a = t;
-
-    let mut b = 1;
-    let mut a = 2;
-
-    let t = b;
-    b = a;
-    a = t;
-}
diff --git a/tests/ui/almost_swapped.stderr b/tests/ui/almost_swapped.stderr
deleted file mode 100644
index 70788d23f16..00000000000
--- a/tests/ui/almost_swapped.stderr
+++ /dev/null
@@ -1,30 +0,0 @@
-error: this looks like you are trying to swap `a` and `b`
-  --> $DIR/almost_swapped.rs:7:5
-   |
-LL | /     let a = b;
-LL | |     let b = a;
-   | |______________^
-   |
-   = note: `-D clippy::almost-swapped` implied by `-D warnings`
-   = note: maybe you could use `std::mem::swap(&mut a, &mut b)` or `std::mem::replace`?
-
-error: this looks like you are trying to swap `d` and `c`
-  --> $DIR/almost_swapped.rs:12:5
-   |
-LL | /     d = c;
-LL | |     c = d;
-   | |_________^ help: try: `std::mem::swap(&mut d, &mut c)`
-   |
-   = note: or maybe you should use `std::mem::replace`?
-
-error: this looks like you are trying to swap `b` and `a`
-  --> $DIR/almost_swapped.rs:16:5
-   |
-LL | /     let a = b;
-LL | |     b = a;
-   | |_________^
-   |
-   = note: maybe you could use `std::mem::swap(&mut b, &mut a)` or `std::mem::replace`?
-
-error: aborting due to 3 previous errors
-
diff --git a/tests/ui/swap.fixed b/tests/ui/swap.fixed
index 805a2ba5a59..fa89706a815 100644
--- a/tests/ui/swap.fixed
+++ b/tests/ui/swap.fixed
@@ -7,7 +7,8 @@
     clippy::redundant_clone,
     redundant_semicolons,
     dead_code,
-    unused_assignments
+    unused_assignments,
+    unused_variables
 )]
 
 struct Foo(u32);
@@ -121,6 +122,27 @@ fn main() {
     std::mem::swap(&mut c.0, &mut a);
 
     ; std::mem::swap(&mut c.0, &mut a);
+
+    std::mem::swap(&mut a, &mut b);
+
+    let mut c = 1;
+    let mut d = 2;
+    std::mem::swap(&mut d, &mut c);
+
+    let mut b = 1;
+    std::mem::swap(&mut a, &mut b);
+
+    let b = 1;
+    let a = 2;
+
+    let t = b;
+    let b = a;
+    let a = t;
+
+    let mut b = 1;
+    let mut a = 2;
+
+    std::mem::swap(&mut b, &mut a);
 }
 
 fn issue_8154() {
diff --git a/tests/ui/swap.rs b/tests/ui/swap.rs
index a8c87847952..ef8a81c8341 100644
--- a/tests/ui/swap.rs
+++ b/tests/ui/swap.rs
@@ -7,7 +7,8 @@
     clippy::redundant_clone,
     redundant_semicolons,
     dead_code,
-    unused_assignments
+    unused_assignments,
+    unused_variables
 )]
 
 struct Foo(u32);
@@ -143,6 +144,32 @@ fn main() {
     ; let t = c.0;
     c.0 = a;
     a = t;
+
+    let a = b;
+    let b = a;
+
+    let mut c = 1;
+    let mut d = 2;
+    d = c;
+    c = d;
+
+    let mut b = 1;
+    let a = b;
+    b = a;
+
+    let b = 1;
+    let a = 2;
+
+    let t = b;
+    let b = a;
+    let a = t;
+
+    let mut b = 1;
+    let mut a = 2;
+
+    let t = b;
+    b = a;
+    a = t;
 }
 
 fn issue_8154() {
diff --git a/tests/ui/swap.stderr b/tests/ui/swap.stderr
index ee4b7a508a5..f0acbfe253f 100644
--- a/tests/ui/swap.stderr
+++ b/tests/ui/swap.stderr
@@ -1,5 +1,5 @@
 error: this looks like you are swapping `bar.a` and `bar.b` manually
-  --> $DIR/swap.rs:24:5
+  --> $DIR/swap.rs:25:5
    |
 LL | /     let temp = bar.a;
 LL | |     bar.a = bar.b;
@@ -10,7 +10,7 @@ LL | |     bar.b = temp;
    = note: `-D clippy::manual-swap` implied by `-D warnings`
 
 error: this looks like you are swapping elements of `foo` manually
-  --> $DIR/swap.rs:36:5
+  --> $DIR/swap.rs:37:5
    |
 LL | /     let temp = foo[0];
 LL | |     foo[0] = foo[1];
@@ -18,7 +18,7 @@ LL | |     foo[1] = temp;
    | |_________________^ help: try: `foo.swap(0, 1)`
 
 error: this looks like you are swapping elements of `foo` manually
-  --> $DIR/swap.rs:45:5
+  --> $DIR/swap.rs:46:5
    |
 LL | /     let temp = foo[0];
 LL | |     foo[0] = foo[1];
@@ -26,7 +26,7 @@ LL | |     foo[1] = temp;
    | |_________________^ help: try: `foo.swap(0, 1)`
 
 error: this looks like you are swapping elements of `foo` manually
-  --> $DIR/swap.rs:64:5
+  --> $DIR/swap.rs:65:5
    |
 LL | /     let temp = foo[0];
 LL | |     foo[0] = foo[1];
@@ -34,7 +34,7 @@ LL | |     foo[1] = temp;
    | |_________________^ help: try: `foo.swap(0, 1)`
 
 error: this looks like you are swapping `a` and `b` manually
-  --> $DIR/swap.rs:75:5
+  --> $DIR/swap.rs:76:5
    |
 LL | /     a ^= b;
 LL | |     b ^= a;
@@ -42,7 +42,7 @@ LL | |     a ^= b;
    | |___________^ help: try: `std::mem::swap(&mut a, &mut b)`
 
 error: this looks like you are swapping `bar.a` and `bar.b` manually
-  --> $DIR/swap.rs:83:5
+  --> $DIR/swap.rs:84:5
    |
 LL | /     bar.a ^= bar.b;
 LL | |     bar.b ^= bar.a;
@@ -50,7 +50,7 @@ LL | |     bar.a ^= bar.b;
    | |___________________^ help: try: `std::mem::swap(&mut bar.a, &mut bar.b)`
 
 error: this looks like you are swapping elements of `foo` manually
-  --> $DIR/swap.rs:91:5
+  --> $DIR/swap.rs:92:5
    |
 LL | /     foo[0] ^= foo[1];
 LL | |     foo[1] ^= foo[0];
@@ -58,7 +58,7 @@ LL | |     foo[0] ^= foo[1];
    | |_____________________^ help: try: `foo.swap(0, 1)`
 
 error: this looks like you are swapping `foo[0][1]` and `bar[1][0]` manually
-  --> $DIR/swap.rs:120:5
+  --> $DIR/swap.rs:121:5
    |
 LL | /     let temp = foo[0][1];
 LL | |     foo[0][1] = bar[1][0];
@@ -68,7 +68,7 @@ LL | |     bar[1][0] = temp;
    = note: or maybe you should use `std::mem::replace`?
 
 error: this looks like you are swapping `a` and `b` manually
-  --> $DIR/swap.rs:134:7
+  --> $DIR/swap.rs:135:7
    |
 LL |       ; let t = a;
    |  _______^
@@ -79,7 +79,7 @@ LL | |     b = t;
    = note: or maybe you should use `std::mem::replace`?
 
 error: this looks like you are swapping `c.0` and `a` manually
-  --> $DIR/swap.rs:143:7
+  --> $DIR/swap.rs:144:7
    |
 LL |       ; let t = c.0;
    |  _______^
@@ -89,8 +89,18 @@ LL | |     a = t;
    |
    = note: or maybe you should use `std::mem::replace`?
 
+error: this looks like you are swapping `b` and `a` manually
+  --> $DIR/swap.rs:170:5
+   |
+LL | /     let t = b;
+LL | |     b = a;
+LL | |     a = t;
+   | |_________^ help: try: `std::mem::swap(&mut b, &mut a)`
+   |
+   = note: or maybe you should use `std::mem::replace`?
+
 error: this looks like you are trying to swap `a` and `b`
-  --> $DIR/swap.rs:131:5
+  --> $DIR/swap.rs:132:5
    |
 LL | /     a = b;
 LL | |     b = a;
@@ -100,7 +110,7 @@ LL | |     b = a;
    = note: `-D clippy::almost-swapped` implied by `-D warnings`
 
 error: this looks like you are trying to swap `c.0` and `a`
-  --> $DIR/swap.rs:140:5
+  --> $DIR/swap.rs:141:5
    |
 LL | /     c.0 = a;
 LL | |     a = c.0;
@@ -108,8 +118,35 @@ LL | |     a = c.0;
    |
    = note: or maybe you should use `std::mem::replace`?
 
+error: this looks like you are trying to swap `a` and `b`
+  --> $DIR/swap.rs:148:5
+   |
+LL | /     let a = b;
+LL | |     let b = a;
+   | |_____________^ help: try: `std::mem::swap(&mut a, &mut b)`
+   |
+   = note: or maybe you should use `std::mem::replace`?
+
+error: this looks like you are trying to swap `d` and `c`
+  --> $DIR/swap.rs:153:5
+   |
+LL | /     d = c;
+LL | |     c = d;
+   | |_________^ help: try: `std::mem::swap(&mut d, &mut c)`
+   |
+   = note: or maybe you should use `std::mem::replace`?
+
+error: this looks like you are trying to swap `a` and `b`
+  --> $DIR/swap.rs:157:5
+   |
+LL | /     let a = b;
+LL | |     b = a;
+   | |_________^ help: try: `std::mem::swap(&mut a, &mut b)`
+   |
+   = note: or maybe you should use `std::mem::replace`?
+
 error: this looks like you are swapping `s.0.x` and `s.0.y` manually
-  --> $DIR/swap.rs:178:5
+  --> $DIR/swap.rs:205:5
    |
 LL | /     let t = s.0.x;
 LL | |     s.0.x = s.0.y;
@@ -118,5 +155,5 @@ LL | |     s.0.y = t;
    |
    = note: or maybe you should use `std::mem::replace`?
 
-error: aborting due to 13 previous errors
+error: aborting due to 17 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 89314a08054cea924c807032ebdb62e031453bb3 Mon Sep 17 00:00:00 2001
From: Armin Ronacher <armin.ronacher@active-4.com>
Date: Mon, 13 Feb 2023 20:50:08 +0100
Subject: Add question-mark-used lint

This lint complains when the question mark operator (try operator)
is used.  This is a restriction lint that can be useful on local
scopes where a custom error handling macro is supposed to be used
to augment the error based on local scope data before returning.
---
 CHANGELOG.md                           |  1 +
 clippy_lints/src/declared_lints.rs     |  1 +
 clippy_lints/src/lib.rs                |  2 ++
 clippy_lints/src/question_mark_used.rs | 47 ++++++++++++++++++++++++++++++++++
 tests/ui/question_mark_used.rs         | 15 +++++++++++
 tests/ui/question_mark_used.stderr     | 11 ++++++++
 6 files changed, 77 insertions(+)
 create mode 100644 clippy_lints/src/question_mark_used.rs
 create mode 100644 tests/ui/question_mark_used.rs
 create mode 100644 tests/ui/question_mark_used.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 30727beb8e7..077e60af931 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4675,6 +4675,7 @@ Released 2018-09-13
 [`pub_enum_variant_names`]: https://rust-lang.github.io/rust-clippy/master/index.html#pub_enum_variant_names
 [`pub_use`]: https://rust-lang.github.io/rust-clippy/master/index.html#pub_use
 [`question_mark`]: https://rust-lang.github.io/rust-clippy/master/index.html#question_mark
+[`question_mark_used`]: https://rust-lang.github.io/rust-clippy/master/index.html#question_mark_used
 [`range_minus_one`]: https://rust-lang.github.io/rust-clippy/master/index.html#range_minus_one
 [`range_plus_one`]: https://rust-lang.github.io/rust-clippy/master/index.html#range_plus_one
 [`range_step_by_zero`]: https://rust-lang.github.io/rust-clippy/master/index.html#range_step_by_zero
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index c1feabf05aa..61ce0c5a469 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -507,6 +507,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::ptr_offset_with_cast::PTR_OFFSET_WITH_CAST_INFO,
     crate::pub_use::PUB_USE_INFO,
     crate::question_mark::QUESTION_MARK_INFO,
+    crate::question_mark_used::QUESTION_MARK_USED_INFO,
     crate::ranges::MANUAL_RANGE_CONTAINS_INFO,
     crate::ranges::RANGE_MINUS_ONE_INFO,
     crate::ranges::RANGE_PLUS_ONE_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 565c5b7af00..e4926c0ed08 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -242,6 +242,7 @@ mod ptr;
 mod ptr_offset_with_cast;
 mod pub_use;
 mod question_mark;
+mod question_mark_used;
 mod ranges;
 mod rc_clone_in_vec_init;
 mod read_zero_byte_vec;
@@ -693,6 +694,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(implicit_hasher::ImplicitHasher));
     store.register_late_pass(|_| Box::new(fallible_impl_from::FallibleImplFrom));
     store.register_late_pass(|_| Box::new(question_mark::QuestionMark));
+    store.register_late_pass(|_| Box::new(question_mark_used::QuestionMarkUsed));
     store.register_early_pass(|| Box::new(suspicious_operation_groupings::SuspiciousOperationGroupings));
     store.register_late_pass(|_| Box::new(suspicious_trait_impl::SuspiciousImpl));
     store.register_late_pass(|_| Box::new(map_unit_fn::MapUnit));
diff --git a/clippy_lints/src/question_mark_used.rs b/clippy_lints/src/question_mark_used.rs
new file mode 100644
index 00000000000..1a103dc35a4
--- /dev/null
+++ b/clippy_lints/src/question_mark_used.rs
@@ -0,0 +1,47 @@
+use clippy_utils::diagnostics::span_lint_and_help;
+
+use rustc_hir::{Expr, ExprKind, MatchSource};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for expressions that use the question mark operator and rejects them.
+    ///
+    /// ### Why is this bad?
+    /// Sometimes code wants to avoid the question mark operator because for instance a local
+    /// block requires a macro to re-throw errors to attach additional information to the
+    /// error.
+    ///
+    /// ### Example
+    /// ```ignore
+    /// let result = expr?;
+    /// ```
+    ///
+    /// Could be written:
+    ///
+    /// ```ignore
+    /// utility_macro!(expr);
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub QUESTION_MARK_USED,
+    restriction,
+    "complains if the question mark operator is used"
+}
+
+declare_lint_pass!(QuestionMarkUsed => [QUESTION_MARK_USED]);
+
+impl<'tcx> LateLintPass<'tcx> for QuestionMarkUsed {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        if let ExprKind::Match(_, _, MatchSource::TryDesugar) = expr.kind {
+            span_lint_and_help(
+                cx,
+                QUESTION_MARK_USED,
+                expr.span,
+                "question mark operator was used",
+                None,
+                "consider using a custom macro or match expression",
+            );
+        }
+    }
+}
diff --git a/tests/ui/question_mark_used.rs b/tests/ui/question_mark_used.rs
new file mode 100644
index 00000000000..8c3ef789697
--- /dev/null
+++ b/tests/ui/question_mark_used.rs
@@ -0,0 +1,15 @@
+// non rustfixable
+#![allow(unreachable_code)]
+#![allow(dead_code)]
+#![warn(clippy::question_mark_used)]
+
+fn other_function() -> Option<i32> {
+    Some(32)
+}
+
+fn my_function() -> Option<i32> {
+    other_function()?;
+    None
+}
+
+fn main() {}
diff --git a/tests/ui/question_mark_used.stderr b/tests/ui/question_mark_used.stderr
new file mode 100644
index 00000000000..8b5fcbcdbfd
--- /dev/null
+++ b/tests/ui/question_mark_used.stderr
@@ -0,0 +1,11 @@
+error: question mark operator was used
+  --> $DIR/question_mark_used.rs:11:5
+   |
+LL |     other_function()?;
+   |     ^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using a custom macro or match expression
+   = note: `-D clippy::question-mark-used` implied by `-D warnings`
+
+error: aborting due to previous error
+
-- 
cgit 1.4.1-3-g733a5


From c231b4188782c249428a66d70b3f705757390ce5 Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Thu, 9 Feb 2023 20:32:44 +0100
Subject: Remove useless call to combine_seq

`combine_seq(x, NeverLoopResult::Otherwise)`  always returns `x`
---
 clippy_lints/src/loops/never_loop.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/never_loop.rs b/clippy_lints/src/loops/never_loop.rs
index 14f161f5102..5bc0f4226fb 100644
--- a/clippy_lints/src/loops/never_loop.rs
+++ b/clippy_lints/src/loops/never_loop.rs
@@ -191,7 +191,7 @@ fn never_loop_expr(expr: &Expr<'_>, ignore_ids: &mut Vec<HirId>, main_loop_id: H
         // checks if break targets a block instead of a loop
         ExprKind::Break(Destination { target_id: Ok(t), .. }, e) if ignore_ids.contains(&t) => e
             .map_or(NeverLoopResult::Otherwise, |e| {
-                combine_seq(never_loop_expr(e, ignore_ids, main_loop_id), NeverLoopResult::Otherwise)
+                never_loop_expr(e, ignore_ids, main_loop_id)
             }),
         ExprKind::Break(_, e) | ExprKind::Ret(e) => e.as_ref().map_or(NeverLoopResult::AlwaysBreak, |e| {
             combine_seq(
-- 
cgit 1.4.1-3-g733a5


From 1fec2927c5cf02de85c08a63dbc8909077661d1b Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Mon, 13 Feb 2023 20:36:41 +0100
Subject: Replace combine_both by combine_seq

All evaluations now happen in order.
---
 clippy_lints/src/loops/never_loop.rs | 18 +++---------------
 1 file changed, 3 insertions(+), 15 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/never_loop.rs b/clippy_lints/src/loops/never_loop.rs
index 5bc0f4226fb..9d16949c81f 100644
--- a/clippy_lints/src/loops/never_loop.rs
+++ b/clippy_lints/src/loops/never_loop.rs
@@ -68,18 +68,6 @@ fn combine_seq(first: NeverLoopResult, second: NeverLoopResult) -> NeverLoopResu
     }
 }
 
-// Combine two results where both parts are called but not necessarily in order.
-#[must_use]
-fn combine_both(left: NeverLoopResult, right: NeverLoopResult) -> NeverLoopResult {
-    match (left, right) {
-        (NeverLoopResult::MayContinueMainLoop, _) | (_, NeverLoopResult::MayContinueMainLoop) => {
-            NeverLoopResult::MayContinueMainLoop
-        },
-        (NeverLoopResult::AlwaysBreak, _) | (_, NeverLoopResult::AlwaysBreak) => NeverLoopResult::AlwaysBreak,
-        (NeverLoopResult::Otherwise, NeverLoopResult::Otherwise) => NeverLoopResult::Otherwise,
-    }
-}
-
 // Combine two results where only one of the part may have been executed.
 #[must_use]
 fn combine_branches(b1: NeverLoopResult, b2: NeverLoopResult) -> NeverLoopResult {
@@ -139,7 +127,7 @@ fn never_loop_expr(expr: &Expr<'_>, ignore_ids: &mut Vec<HirId>, main_loop_id: H
         ExprKind::Struct(_, fields, base) => {
             let fields = never_loop_expr_all(&mut fields.iter().map(|f| f.expr), ignore_ids, main_loop_id);
             if let Some(base) = base {
-                combine_both(fields, never_loop_expr(base, ignore_ids, main_loop_id))
+                combine_seq(fields, never_loop_expr(base, ignore_ids, main_loop_id))
             } else {
                 fields
             }
@@ -218,7 +206,7 @@ fn never_loop_expr(expr: &Expr<'_>, ignore_ids: &mut Vec<HirId>, main_loop_id: H
                 | InlineAsmOperand::SymFn { .. }
                 | InlineAsmOperand::SymStatic { .. } => NeverLoopResult::Otherwise,
             })
-            .fold(NeverLoopResult::Otherwise, combine_both),
+            .fold(NeverLoopResult::Otherwise, combine_seq),
         ExprKind::Yield(_, _)
         | ExprKind::Closure { .. }
         | ExprKind::Path(_)
@@ -234,7 +222,7 @@ fn never_loop_expr_all<'a, T: Iterator<Item = &'a Expr<'a>>>(
     main_loop_id: HirId,
 ) -> NeverLoopResult {
     es.map(|e| never_loop_expr(e, ignore_ids, main_loop_id))
-        .fold(NeverLoopResult::Otherwise, combine_both)
+        .fold(NeverLoopResult::Otherwise, combine_seq)
 }
 
 fn never_loop_expr_branch<'a, T: Iterator<Item = &'a Expr<'a>>>(
-- 
cgit 1.4.1-3-g733a5


From 8e96adedd56993eec0609276124ff17d4866b94b Mon Sep 17 00:00:00 2001
From: J-ZhengLi <lizheng135@huawei.com>
Date: Tue, 14 Feb 2023 11:31:42 +0800
Subject: fix [`needless_return`] incorrect suggestion when returning if
 sequence

---
 clippy_lints/src/returns.rs     | 96 +++++++++++++++++++++++------------------
 tests/ui/needless_return.fixed  |  4 ++
 tests/ui/needless_return.rs     |  4 ++
 tests/ui/needless_return.stderr | 10 ++++-
 4 files changed, 72 insertions(+), 42 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
index 84a0c6b9558..84bcef856d0 100644
--- a/clippy_lints/src/returns.rs
+++ b/clippy_lints/src/returns.rs
@@ -69,31 +69,35 @@ declare_clippy_lint! {
     "using a return statement like `return expr;` where an expression would suffice"
 }
 
-#[derive(PartialEq, Eq, Copy, Clone)]
+#[derive(PartialEq, Eq, Clone)]
 enum RetReplacement {
     Empty,
     Block,
     Unit,
+    IfSequence(String),
+    Expr(String),
 }
 
 impl RetReplacement {
     fn sugg_help(self) -> &'static str {
         match self {
-            Self::Empty => "remove `return`",
+            Self::Empty | Self::Expr(_) => "remove `return`",
             Self::Block => "replace `return` with an empty block",
             Self::Unit => "replace `return` with a unit value",
+            Self::IfSequence(_) => "remove `return` and wrap the sequence with parentheses",
         }
     }
 }
 
 impl ToString for RetReplacement {
     fn to_string(&self) -> String {
-        match *self {
-            Self::Empty => "",
-            Self::Block => "{}",
-            Self::Unit => "()",
+        match self {
+            Self::Empty => String::new(),
+            Self::Block => "{}".to_string(),
+            Self::Unit => "()".to_string(),
+            Self::IfSequence(inner) => format!("({inner})"),
+            Self::Expr(inner) => inner.clone(),
         }
-        .to_string()
     }
 }
 
@@ -210,13 +214,37 @@ fn check_final_expr<'tcx>(
     match &peeled_drop_expr.kind {
         // simple return is always "bad"
         ExprKind::Ret(ref inner) => {
-            // if desugar of `do yeet`, don't lint
-            if let Some(inner_expr) = inner
-                && let ExprKind::Call(path_expr, _) = inner_expr.kind
-                && let ExprKind::Path(QPath::LangItem(LangItem::TryTraitFromYeet, _, _)) = path_expr.kind
-            {
-                return;
-            }
+            // check if expr return nothing
+            let ret_span = if inner.is_none() && replacement == RetReplacement::Empty {
+                extend_span_to_previous_non_ws(cx, peeled_drop_expr.span)
+            } else {
+                peeled_drop_expr.span
+            };
+
+            let replacement = if let Some(inner_expr) = inner {
+                // if desugar of `do yeet`, don't lint
+                if let ExprKind::Call(path_expr, _) = inner_expr.kind
+                    && let ExprKind::Path(QPath::LangItem(LangItem::TryTraitFromYeet, _, _)) = path_expr.kind
+                {
+                    return;
+                }
+
+                let (snippet, _) = snippet_with_context(
+                    cx,
+                    inner_expr.span,
+                    ret_span.ctxt(),
+                    "..",
+                    &mut Applicability::MachineApplicable,
+                );
+                if expr_contains_if(inner_expr) {
+                    RetReplacement::IfSequence(snippet.to_string())
+                } else {
+                    RetReplacement::Expr(snippet.to_string())
+                }
+            } else {
+                replacement
+            };
+
             if !cx.tcx.hir().attrs(expr.hir_id).is_empty() {
                 return;
             }
@@ -224,14 +252,8 @@ fn check_final_expr<'tcx>(
             if borrows {
                 return;
             }
-            // check if expr return nothing
-            let ret_span = if inner.is_none() && replacement == RetReplacement::Empty {
-                extend_span_to_previous_non_ws(cx, peeled_drop_expr.span)
-            } else {
-                peeled_drop_expr.span
-            };
 
-            emit_return_lint(cx, ret_span, semi_spans, inner.as_ref().map(|i| i.span), replacement);
+            emit_return_lint(cx, ret_span, semi_spans, replacement);
         },
         ExprKind::If(_, then, else_clause_opt) => {
             check_block_return(cx, &then.kind, peeled_drop_expr.span, semi_spans.clone());
@@ -253,29 +275,21 @@ fn check_final_expr<'tcx>(
     }
 }
 
-fn emit_return_lint(
-    cx: &LateContext<'_>,
-    ret_span: Span,
-    semi_spans: Vec<Span>,
-    inner_span: Option<Span>,
-    replacement: RetReplacement,
-) {
+fn expr_contains_if<'tcx>(expr: &'tcx Expr<'tcx>) -> bool {
+    match expr.kind {
+        ExprKind::If(..) => true,
+        ExprKind::Binary(_, left, right) => expr_contains_if(left) || expr_contains_if(right),
+        _ => false,
+    }
+}
+
+fn emit_return_lint(cx: &LateContext<'_>, ret_span: Span, semi_spans: Vec<Span>, replacement: RetReplacement) {
     if ret_span.from_expansion() {
         return;
     }
-    let mut applicability = Applicability::MachineApplicable;
-    let return_replacement = inner_span.map_or_else(
-        || replacement.to_string(),
-        |inner_span| {
-            let (snippet, _) = snippet_with_context(cx, inner_span, ret_span.ctxt(), "..", &mut applicability);
-            snippet.to_string()
-        },
-    );
-    let sugg_help = if inner_span.is_some() {
-        "remove `return`"
-    } else {
-        replacement.sugg_help()
-    };
+    let applicability = Applicability::MachineApplicable;
+    let return_replacement = replacement.to_string();
+    let sugg_help = replacement.sugg_help();
     span_lint_and_then(cx, NEEDLESS_RETURN, ret_span, "unneeded `return` statement", |diag| {
         diag.span_suggestion_hidden(ret_span, sugg_help, return_replacement, applicability);
         // for each parent statement, we need to remove the semicolon
diff --git a/tests/ui/needless_return.fixed b/tests/ui/needless_return.fixed
index 079e3531def..c77554fb47b 100644
--- a/tests/ui/needless_return.fixed
+++ b/tests/ui/needless_return.fixed
@@ -297,4 +297,8 @@ fn issue10051() -> Result<String, String> {
     }
 }
 
+fn issue10049(b1: bool, b2: bool, b3: bool) -> u32 {
+    (if b1 { 0 } else { 1 } | if b2 { 2 } else { 3 } | if b3 { 4 } else { 5 })
+}
+
 fn main() {}
diff --git a/tests/ui/needless_return.rs b/tests/ui/needless_return.rs
index c1c48284f08..8fed64ac6e3 100644
--- a/tests/ui/needless_return.rs
+++ b/tests/ui/needless_return.rs
@@ -307,4 +307,8 @@ fn issue10051() -> Result<String, String> {
     }
 }
 
+fn issue10049(b1: bool, b2: bool, b3: bool) -> u32 {
+    return if b1 { 0 } else { 1 } | if b2 { 2 } else { 3 } | if b3 { 4 } else { 5 };
+}
+
 fn main() {}
diff --git a/tests/ui/needless_return.stderr b/tests/ui/needless_return.stderr
index 08b04bfe9d8..18edbce2f44 100644
--- a/tests/ui/needless_return.stderr
+++ b/tests/ui/needless_return.stderr
@@ -418,5 +418,13 @@ LL |         return Err(format!("err!"));
    |
    = help: remove `return`
 
-error: aborting due to 50 previous errors
+error: unneeded `return` statement
+  --> $DIR/needless_return.rs:311:5
+   |
+LL |     return if b1 { 0 } else { 1 } | if b2 { 2 } else { 3 } | if b3 { 4 } else { 5 };
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: remove `return` and wrap the sequence with parentheses
+
+error: aborting due to 51 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From e9dffa391085f4b3c84f90e8ab82bdd568d1f17e Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Tue, 14 Feb 2023 09:12:51 +0100
Subject: Fix a bug in never_loop when anonymous blocks are nested in named
 blocks

The following code

```
loop {
    'a: {
        { }
        break 'a;
    }
}
```

was detected as a never-looping loop.
---
 clippy_lints/src/loops/never_loop.rs | 4 +++-
 tests/ui/never_loop.rs               | 9 +++++++++
 2 files changed, 12 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/never_loop.rs b/clippy_lints/src/loops/never_loop.rs
index 9d16949c81f..3cb5b1ffc7b 100644
--- a/clippy_lints/src/loops/never_loop.rs
+++ b/clippy_lints/src/loops/never_loop.rs
@@ -163,7 +163,9 @@ fn never_loop_expr(expr: &Expr<'_>, ignore_ids: &mut Vec<HirId>, main_loop_id: H
                 ignore_ids.push(b.hir_id);
             }
             let ret = never_loop_block(b, ignore_ids, main_loop_id);
-            ignore_ids.pop();
+            if l.is_some() {
+                ignore_ids.pop();
+            }
             ret
         },
         ExprKind::Continue(d) => {
diff --git a/tests/ui/never_loop.rs b/tests/ui/never_loop.rs
index 28e8f459d44..a177d5e06aa 100644
--- a/tests/ui/never_loop.rs
+++ b/tests/ui/never_loop.rs
@@ -250,6 +250,15 @@ pub fn test20() {
     }
 }
 
+pub fn test21() {
+    loop {
+        'a: {
+            { }
+            break 'a;
+        }
+    }
+}
+
 fn main() {
     test1();
     test2();
-- 
cgit 1.4.1-3-g733a5


From 657ee48bec2c02ad6885176ea37658bddf6ce59a Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Mon, 13 Feb 2023 20:37:36 +0100
Subject: Ignore instructions following a break from block in never_loop lint

It is not sufficient to ignore break from a block inside the loop.
Instructions after the break must be ignored, as they are unreachable.
This is also true for all instructions in outer blocks and loops
until the right block is reached.
---
 clippy_lints/src/loops/never_loop.rs | 35 +++++++++++++++++++++++++--------
 tests/ui/never_loop.rs               | 38 +++++++++++++++++++++++++++++++++++-
 tests/ui/never_loop.stderr           | 15 +++++++++++++-
 3 files changed, 78 insertions(+), 10 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/never_loop.rs b/clippy_lints/src/loops/never_loop.rs
index 3cb5b1ffc7b..ea7630ce56d 100644
--- a/clippy_lints/src/loops/never_loop.rs
+++ b/clippy_lints/src/loops/never_loop.rs
@@ -39,6 +39,7 @@ pub(super) fn check(
             });
         },
         NeverLoopResult::MayContinueMainLoop | NeverLoopResult::Otherwise => (),
+        NeverLoopResult::IgnoreUntilEnd(_) => unreachable!(),
     }
 }
 
@@ -48,6 +49,8 @@ enum NeverLoopResult {
     AlwaysBreak,
     // A continue may occur for the main loop.
     MayContinueMainLoop,
+    // Ignore everything until the end of the block with this id
+    IgnoreUntilEnd(HirId),
     Otherwise,
 }
 
@@ -56,6 +59,7 @@ fn absorb_break(arg: NeverLoopResult) -> NeverLoopResult {
     match arg {
         NeverLoopResult::AlwaysBreak | NeverLoopResult::Otherwise => NeverLoopResult::Otherwise,
         NeverLoopResult::MayContinueMainLoop => NeverLoopResult::MayContinueMainLoop,
+        NeverLoopResult::IgnoreUntilEnd(id) => NeverLoopResult::IgnoreUntilEnd(id),
     }
 }
 
@@ -63,15 +67,26 @@ fn absorb_break(arg: NeverLoopResult) -> NeverLoopResult {
 #[must_use]
 fn combine_seq(first: NeverLoopResult, second: NeverLoopResult) -> NeverLoopResult {
     match first {
-        NeverLoopResult::AlwaysBreak | NeverLoopResult::MayContinueMainLoop => first,
+        NeverLoopResult::AlwaysBreak | NeverLoopResult::MayContinueMainLoop | NeverLoopResult::IgnoreUntilEnd(_) => {
+            first
+        },
         NeverLoopResult::Otherwise => second,
     }
 }
 
 // Combine two results where only one of the part may have been executed.
 #[must_use]
-fn combine_branches(b1: NeverLoopResult, b2: NeverLoopResult) -> NeverLoopResult {
+fn combine_branches(b1: NeverLoopResult, b2: NeverLoopResult, ignore_ids: &[HirId]) -> NeverLoopResult {
     match (b1, b2) {
+        (NeverLoopResult::IgnoreUntilEnd(a), NeverLoopResult::IgnoreUntilEnd(b)) => {
+            if ignore_ids.iter().find(|&e| e == &a || e == &b).unwrap() == &a {
+                NeverLoopResult::IgnoreUntilEnd(b)
+            } else {
+                NeverLoopResult::IgnoreUntilEnd(a)
+            }
+        },
+        (i @ NeverLoopResult::IgnoreUntilEnd(_), NeverLoopResult::AlwaysBreak)
+        | (NeverLoopResult::AlwaysBreak, i @ NeverLoopResult::IgnoreUntilEnd(_)) => i,
         (NeverLoopResult::AlwaysBreak, NeverLoopResult::AlwaysBreak) => NeverLoopResult::AlwaysBreak,
         (NeverLoopResult::MayContinueMainLoop, _) | (_, NeverLoopResult::MayContinueMainLoop) => {
             NeverLoopResult::MayContinueMainLoop
@@ -91,7 +106,7 @@ fn never_loop_block(block: &Block<'_>, ignore_ids: &mut Vec<HirId>, main_loop_id
         let e = never_loop_expr(e, ignore_ids, main_loop_id);
         // els is an else block in a let...else binding
         els.map_or(e, |els| {
-            combine_branches(e, never_loop_block(els, ignore_ids, main_loop_id))
+            combine_branches(e, never_loop_block(els, ignore_ids, main_loop_id), ignore_ids)
         })
     })
     .fold(NeverLoopResult::Otherwise, combine_seq)
@@ -147,7 +162,7 @@ fn never_loop_expr(expr: &Expr<'_>, ignore_ids: &mut Vec<HirId>, main_loop_id: H
             let e3 = e3.as_ref().map_or(NeverLoopResult::Otherwise, |e| {
                 never_loop_expr(e, ignore_ids, main_loop_id)
             });
-            combine_seq(e1, combine_branches(e2, e3))
+            combine_seq(e1, combine_branches(e2, e3, ignore_ids))
         },
         ExprKind::Match(e, arms, _) => {
             let e = never_loop_expr(e, ignore_ids, main_loop_id);
@@ -166,7 +181,10 @@ fn never_loop_expr(expr: &Expr<'_>, ignore_ids: &mut Vec<HirId>, main_loop_id: H
             if l.is_some() {
                 ignore_ids.pop();
             }
-            ret
+            match ret {
+                NeverLoopResult::IgnoreUntilEnd(a) if a == b.hir_id => NeverLoopResult::Otherwise,
+                _ => ret,
+            }
         },
         ExprKind::Continue(d) => {
             let id = d
@@ -180,7 +198,7 @@ fn never_loop_expr(expr: &Expr<'_>, ignore_ids: &mut Vec<HirId>, main_loop_id: H
         },
         // checks if break targets a block instead of a loop
         ExprKind::Break(Destination { target_id: Ok(t), .. }, e) if ignore_ids.contains(&t) => e
-            .map_or(NeverLoopResult::Otherwise, |e| {
+            .map_or(NeverLoopResult::IgnoreUntilEnd(t), |e| {
                 never_loop_expr(e, ignore_ids, main_loop_id)
             }),
         ExprKind::Break(_, e) | ExprKind::Ret(e) => e.as_ref().map_or(NeverLoopResult::AlwaysBreak, |e| {
@@ -232,8 +250,9 @@ fn never_loop_expr_branch<'a, T: Iterator<Item = &'a Expr<'a>>>(
     ignore_ids: &mut Vec<HirId>,
     main_loop_id: HirId,
 ) -> NeverLoopResult {
-    e.map(|e| never_loop_expr(e, ignore_ids, main_loop_id))
-        .fold(NeverLoopResult::AlwaysBreak, combine_branches)
+    e.fold(NeverLoopResult::AlwaysBreak, |a, b| {
+        combine_branches(a, never_loop_expr(b, ignore_ids, main_loop_id), ignore_ids)
+    })
 }
 
 fn for_to_if_let_sugg(cx: &LateContext<'_>, iterator: &Expr<'_>, pat: &Pat<'_>) -> String {
diff --git a/tests/ui/never_loop.rs b/tests/ui/never_loop.rs
index a177d5e06aa..29821ff96fc 100644
--- a/tests/ui/never_loop.rs
+++ b/tests/ui/never_loop.rs
@@ -253,12 +253,48 @@ pub fn test20() {
 pub fn test21() {
     loop {
         'a: {
-            { }
+            {}
             break 'a;
         }
     }
 }
 
+// Issue 10304: code after break from block was not considered
+// unreachable code and was considered for further analysis of
+// whether the loop would ever be executed or not.
+pub fn test22() {
+    for _ in 0..10 {
+        'block: {
+            break 'block;
+            return;
+        }
+        println!("looped");
+    }
+}
+
+pub fn test23() {
+    for _ in 0..10 {
+        'block: {
+            for _ in 0..20 {
+                break 'block;
+            }
+        }
+        println!("looped");
+    }
+}
+
+pub fn test24() {
+    'a: for _ in 0..10 {
+        'b: {
+            let x = Some(1);
+            match x {
+                None => break 'a,
+                Some(_) => break 'b,
+            }
+        }
+    }
+}
+
 fn main() {
     test1();
     test2();
diff --git a/tests/ui/never_loop.stderr b/tests/ui/never_loop.stderr
index b7029bf8bed..704d448644e 100644
--- a/tests/ui/never_loop.stderr
+++ b/tests/ui/never_loop.stderr
@@ -126,5 +126,18 @@ LL | |         }
 LL | |     }
    | |_____^
 
-error: aborting due to 11 previous errors
+error: this loop never actually loops
+  --> $DIR/never_loop.rs:278:13
+   |
+LL | /             for _ in 0..20 {
+LL | |                 break 'block;
+LL | |             }
+   | |_____________^
+   |
+help: if you need the first element of the iterator, try writing
+   |
+LL |             if let Some(_) = (0..20).next() {
+   |             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+error: aborting due to 12 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From e4e5924b99b30c693bc87aa95ef51fd2263b6280 Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Tue, 14 Feb 2023 14:50:08 +0100
Subject: Do not base map_entry lint suggestion on expanded code

---
 clippy_lints/src/entry.rs |  4 ++++
 tests/ui/entry.fixed      | 14 ++++++++++++++
 tests/ui/entry.rs         | 14 ++++++++++++++
 3 files changed, 32 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/entry.rs b/clippy_lints/src/entry.rs
index b44e6243588..ed9d94cdec3 100644
--- a/clippy_lints/src/entry.rs
+++ b/clippy_lints/src/entry.rs
@@ -65,6 +65,10 @@ declare_lint_pass!(HashMapPass => [MAP_ENTRY]);
 impl<'tcx> LateLintPass<'tcx> for HashMapPass {
     #[expect(clippy::too_many_lines)]
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        if expr.span.from_expansion() {
+            return;
+        }
+
         let Some(higher::If { cond: cond_expr, then: then_expr, r#else: else_expr }) = higher::If::hir(expr) else {
             return
         };
diff --git a/tests/ui/entry.fixed b/tests/ui/entry.fixed
index 79c29c04e05..dbe09e0ff3c 100644
--- a/tests/ui/entry.fixed
+++ b/tests/ui/entry.fixed
@@ -152,4 +152,18 @@ fn hash_map<K: Eq + Hash + Copy, V: Copy>(m: &mut HashMap<K, V>, m2: &mut HashMa
     });
 }
 
+// Issue 10331
+// do not suggest a bad expansion because the compiler unrolls the first
+// occurrence of the loop
+pub fn issue_10331() {
+    let mut m = HashMap::new();
+    let mut i = 0;
+    let mut x = 0;
+    while !m.contains_key(&x) {
+        m.insert(x, i);
+        i += 1;
+        x += 1;
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/entry.rs b/tests/ui/entry.rs
index 2d7985457d8..30fed34fc5d 100644
--- a/tests/ui/entry.rs
+++ b/tests/ui/entry.rs
@@ -156,4 +156,18 @@ fn hash_map<K: Eq + Hash + Copy, V: Copy>(m: &mut HashMap<K, V>, m2: &mut HashMa
     }
 }
 
+// Issue 10331
+// do not suggest a bad expansion because the compiler unrolls the first
+// occurrence of the loop
+pub fn issue_10331() {
+    let mut m = HashMap::new();
+    let mut i = 0;
+    let mut x = 0;
+    while !m.contains_key(&x) {
+        m.insert(x, i);
+        i += 1;
+        x += 1;
+    }
+}
+
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 17cb2e47e5503494fa506af42be289f38a3a8d73 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Sun, 12 Feb 2023 07:12:32 +0000
Subject: Liberate late-bound regions rather than erasing them in
 needless_pass_by_value

---
 clippy_lints/src/needless_pass_by_value.rs                |  2 +-
 tests/ui/crashes/needless_pass_by_value-w-late-bound.rs   |  9 +++++++++
 .../ui/crashes/needless_pass_by_value-w-late-bound.stderr | 15 +++++++++++++++
 3 files changed, 25 insertions(+), 1 deletion(-)
 create mode 100644 tests/ui/crashes/needless_pass_by_value-w-late-bound.rs
 create mode 100644 tests/ui/crashes/needless_pass_by_value-w-late-bound.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/needless_pass_by_value.rs b/clippy_lints/src/needless_pass_by_value.rs
index 996ea6ed723..b403092d5c7 100644
--- a/clippy_lints/src/needless_pass_by_value.rs
+++ b/clippy_lints/src/needless_pass_by_value.rs
@@ -149,7 +149,7 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByValue {
         };
 
         let fn_sig = cx.tcx.fn_sig(fn_def_id).subst_identity();
-        let fn_sig = cx.tcx.erase_late_bound_regions(fn_sig);
+        let fn_sig = cx.tcx.liberate_late_bound_regions(fn_def_id.to_def_id(), fn_sig);
 
         for (idx, ((input, &ty), arg)) in decl.inputs.iter().zip(fn_sig.inputs()).zip(body.params).enumerate() {
             // All spans generated from a proc-macro invocation are the same...
diff --git a/tests/ui/crashes/needless_pass_by_value-w-late-bound.rs b/tests/ui/crashes/needless_pass_by_value-w-late-bound.rs
new file mode 100644
index 00000000000..dd3d8b8b6d1
--- /dev/null
+++ b/tests/ui/crashes/needless_pass_by_value-w-late-bound.rs
@@ -0,0 +1,9 @@
+// https://github.com/rust-lang/rust/issues/107147
+
+#![warn(clippy::needless_pass_by_value)]
+
+struct Foo<'a>(&'a [(); 100]);
+
+fn test(x: Foo<'_>) {}
+
+fn main() {}
diff --git a/tests/ui/crashes/needless_pass_by_value-w-late-bound.stderr b/tests/ui/crashes/needless_pass_by_value-w-late-bound.stderr
new file mode 100644
index 00000000000..7a0a648974f
--- /dev/null
+++ b/tests/ui/crashes/needless_pass_by_value-w-late-bound.stderr
@@ -0,0 +1,15 @@
+error: this argument is passed by value, but not consumed in the function body
+  --> $DIR/needless_pass_by_value-w-late-bound.rs:7:12
+   |
+LL | fn test(x: Foo<'_>) {}
+   |            ^^^^^^^ help: consider taking a reference instead: `&Foo<'_>`
+   |
+help: consider marking this type as `Copy`
+  --> $DIR/needless_pass_by_value-w-late-bound.rs:5:1
+   |
+LL | struct Foo<'a>(&'a [(); 100]);
+   | ^^^^^^^^^^^^^^
+   = note: `-D clippy::needless-pass-by-value` implied by `-D warnings`
+
+error: aborting due to previous error
+
-- 
cgit 1.4.1-3-g733a5


From 7f15a11aa174efded805617f2c5664f31389dcc1 Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Sun, 12 Feb 2023 09:18:55 +0100
Subject: manual_let_else: let/else is not divergent by default

The divergent `else` block of a `let`/`else` statement does not make
the `let`/`else` statement itself divergent.
---
 clippy_lints/src/manual_let_else.rs | 146 +++++++++++++++++++++++-------------
 tests/ui/manual_let_else.rs         |  11 +++
 2 files changed, 105 insertions(+), 52 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_let_else.rs b/clippy_lints/src/manual_let_else.rs
index 9c6f8b43c07..5db5c644736 100644
--- a/clippy_lints/src/manual_let_else.rs
+++ b/clippy_lints/src/manual_let_else.rs
@@ -4,11 +4,12 @@ use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::peel_blocks;
 use clippy_utils::source::snippet_with_context;
 use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::visitors::{for_each_expr, Descend};
+use clippy_utils::visitors::{Descend, Visitable};
 use if_chain::if_chain;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Applicability;
-use rustc_hir::{Expr, ExprKind, MatchSource, Pat, PatKind, QPath, Stmt, StmtKind};
+use rustc_hir::intravisit::{walk_expr, Visitor};
+use rustc_hir::{Expr, ExprKind, HirId, ItemId, Local, MatchSource, Pat, PatKind, QPath, Stmt, StmtKind, Ty};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
@@ -162,61 +163,102 @@ fn emit_manual_let_else(cx: &LateContext<'_>, span: Span, expr: &Expr<'_>, pat:
     );
 }
 
-fn expr_diverges(cx: &LateContext<'_>, expr: &'_ Expr<'_>) -> bool {
-    fn is_never(cx: &LateContext<'_>, expr: &'_ Expr<'_>) -> bool {
-        if let Some(ty) = cx.typeck_results().expr_ty_opt(expr) {
-            return ty.is_never();
-        }
-        false
+/// Check whether an expression is divergent. May give false negatives.
+fn expr_diverges(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+    struct V<'cx, 'tcx> {
+        cx: &'cx LateContext<'tcx>,
+        res: ControlFlow<(), Descend>,
     }
-    // We can't just call is_never on expr and be done, because the type system
-    // sometimes coerces the ! type to something different before we can get
-    // our hands on it. So instead, we do a manual search. We do fall back to
-    // is_never in some places when there is no better alternative.
-    for_each_expr(expr, |ex| {
-        match ex.kind {
-            ExprKind::Continue(_) | ExprKind::Break(_, _) | ExprKind::Ret(_) => ControlFlow::Break(()),
-            ExprKind::Call(call, _) => {
-                if is_never(cx, ex) || is_never(cx, call) {
-                    return ControlFlow::Break(());
-                }
-                ControlFlow::Continue(Descend::Yes)
-            },
-            ExprKind::MethodCall(..) => {
-                if is_never(cx, ex) {
-                    return ControlFlow::Break(());
-                }
-                ControlFlow::Continue(Descend::Yes)
-            },
-            ExprKind::If(if_expr, if_then, if_else) => {
-                let else_diverges = if_else.map_or(false, |ex| expr_diverges(cx, ex));
-                let diverges = expr_diverges(cx, if_expr) || (else_diverges && expr_diverges(cx, if_then));
-                if diverges {
-                    return ControlFlow::Break(());
-                }
-                ControlFlow::Continue(Descend::No)
-            },
-            ExprKind::Match(match_expr, match_arms, _) => {
-                let diverges = expr_diverges(cx, match_expr)
-                    || match_arms.iter().all(|arm| {
-                        let guard_diverges = arm.guard.as_ref().map_or(false, |g| expr_diverges(cx, g.body()));
-                        guard_diverges || expr_diverges(cx, arm.body)
-                    });
-                if diverges {
-                    return ControlFlow::Break(());
+    impl<'tcx> Visitor<'tcx> for V<'_, '_> {
+        fn visit_expr(&mut self, e: &'tcx Expr<'tcx>) {
+            fn is_never(cx: &LateContext<'_>, expr: &'_ Expr<'_>) -> bool {
+                if let Some(ty) = cx.typeck_results().expr_ty_opt(expr) {
+                    return ty.is_never();
                 }
-                ControlFlow::Continue(Descend::No)
-            },
+                false
+            }
+
+            if self.res.is_break() {
+                return;
+            }
 
-            // Don't continue into loops or labeled blocks, as they are breakable,
-            // and we'd have to start checking labels.
-            ExprKind::Block(_, Some(_)) | ExprKind::Loop(..) => ControlFlow::Continue(Descend::No),
+            // We can't just call is_never on expr and be done, because the type system
+            // sometimes coerces the ! type to something different before we can get
+            // our hands on it. So instead, we do a manual search. We do fall back to
+            // is_never in some places when there is no better alternative.
+            self.res = match e.kind {
+                ExprKind::Continue(_) | ExprKind::Break(_, _) | ExprKind::Ret(_) => ControlFlow::Break(()),
+                ExprKind::Call(call, _) => {
+                    if is_never(self.cx, e) || is_never(self.cx, call) {
+                        ControlFlow::Break(())
+                    } else {
+                        ControlFlow::Continue(Descend::Yes)
+                    }
+                },
+                ExprKind::MethodCall(..) => {
+                    if is_never(self.cx, e) {
+                        ControlFlow::Break(())
+                    } else {
+                        ControlFlow::Continue(Descend::Yes)
+                    }
+                },
+                ExprKind::If(if_expr, if_then, if_else) => {
+                    let else_diverges = if_else.map_or(false, |ex| expr_diverges(self.cx, ex));
+                    let diverges =
+                        expr_diverges(self.cx, if_expr) || (else_diverges && expr_diverges(self.cx, if_then));
+                    if diverges {
+                        ControlFlow::Break(())
+                    } else {
+                        ControlFlow::Continue(Descend::No)
+                    }
+                },
+                ExprKind::Match(match_expr, match_arms, _) => {
+                    let diverges = expr_diverges(self.cx, match_expr)
+                        || match_arms.iter().all(|arm| {
+                            let guard_diverges = arm.guard.as_ref().map_or(false, |g| expr_diverges(self.cx, g.body()));
+                            guard_diverges || expr_diverges(self.cx, arm.body)
+                        });
+                    if diverges {
+                        ControlFlow::Break(())
+                    } else {
+                        ControlFlow::Continue(Descend::No)
+                    }
+                },
 
-            // Default: descend
-            _ => ControlFlow::Continue(Descend::Yes),
+                // Don't continue into loops or labeled blocks, as they are breakable,
+                // and we'd have to start checking labels.
+                ExprKind::Block(_, Some(_)) | ExprKind::Loop(..) => ControlFlow::Continue(Descend::No),
+
+                // Default: descend
+                _ => ControlFlow::Continue(Descend::Yes),
+            };
+            if let ControlFlow::Continue(Descend::Yes) = self.res {
+                walk_expr(self, e);
+            }
+        }
+
+        fn visit_local(&mut self, local: &'tcx Local<'_>) {
+            // Don't visit the else block of a let/else statement as it will not make
+            // the statement divergent even though the else block is divergent.
+            if let Some(init) = local.init {
+                self.visit_expr(init);
+            }
         }
-    })
-    .is_some()
+
+        // Avoid unnecessary `walk_*` calls.
+        fn visit_ty(&mut self, _: &'tcx Ty<'tcx>) {}
+        fn visit_pat(&mut self, _: &'tcx Pat<'tcx>) {}
+        fn visit_qpath(&mut self, _: &'tcx QPath<'tcx>, _: HirId, _: Span) {}
+        // Avoid monomorphising all `visit_*` functions.
+        fn visit_nested_item(&mut self, _: ItemId) {}
+    }
+
+    let mut v = V {
+        cx,
+        res: ControlFlow::Continue(Descend::Yes),
+    };
+    expr.visit(&mut v);
+    v.res.is_break()
 }
 
 fn pat_allowed_for_else(cx: &LateContext<'_>, pat: &'_ Pat<'_>, check_types: bool) -> bool {
diff --git a/tests/ui/manual_let_else.rs b/tests/ui/manual_let_else.rs
index 48a162c1360..d175597a44a 100644
--- a/tests/ui/manual_let_else.rs
+++ b/tests/ui/manual_let_else.rs
@@ -248,4 +248,15 @@ fn not_fire() {
         Some(value) => value,
         _ => macro_call!(),
     };
+
+    // Issue 10296
+    // The let/else block in the else part is not divergent despite the presence of return
+    let _x = if let Some(x) = Some(1) {
+        x
+    } else {
+        let Some(_z) = Some(3) else {
+            return
+        };
+        1
+    };
 }
-- 
cgit 1.4.1-3-g733a5


From 8b93eb8a9b31fcaadf22ea0fbacfcea4450a5894 Mon Sep 17 00:00:00 2001
From: J-ZhengLi <lizheng135@huawei.com>
Date: Wed, 15 Feb 2023 11:26:30 +0800
Subject: add some adjustment regarding review suggestion

---
 clippy_lints/src/returns.rs     | 60 ++++++++++++++++++++++-------------------
 tests/ui/needless_return.fixed  | 10 +++++--
 tests/ui/needless_return.rs     | 10 +++++--
 tests/ui/needless_return.stderr | 16 ++++++++---
 4 files changed, 61 insertions(+), 35 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
index 84bcef856d0..f0d7dd23a67 100644
--- a/clippy_lints/src/returns.rs
+++ b/clippy_lints/src/returns.rs
@@ -14,6 +14,7 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::def_id::LocalDefId;
 use rustc_span::source_map::Span;
 use rustc_span::{BytePos, Pos};
+use std::borrow::Cow;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -70,33 +71,39 @@ declare_clippy_lint! {
 }
 
 #[derive(PartialEq, Eq, Clone)]
-enum RetReplacement {
+enum RetReplacement<'tcx> {
     Empty,
     Block,
     Unit,
-    IfSequence(String),
-    Expr(String),
+    IfSequence(Cow<'tcx, str>, Applicability),
+    Expr(Cow<'tcx, str>, Applicability),
 }
 
-impl RetReplacement {
+impl<'tcx> RetReplacement<'tcx> {
     fn sugg_help(self) -> &'static str {
         match self {
-            Self::Empty | Self::Expr(_) => "remove `return`",
+            Self::Empty | Self::Expr(..) => "remove `return`",
             Self::Block => "replace `return` with an empty block",
             Self::Unit => "replace `return` with a unit value",
-            Self::IfSequence(_) => "remove `return` and wrap the sequence with parentheses",
+            Self::IfSequence(..) => "remove `return` and wrap the sequence with parentheses",
+        }
+    }
+    fn applicability(&self) -> Option<Applicability> {
+        match self {
+            Self::Expr(_, ap) | Self::IfSequence(_, ap) => Some(*ap),
+            _ => None,
         }
     }
 }
 
-impl ToString for RetReplacement {
+impl<'tcx> ToString for RetReplacement<'tcx> {
     fn to_string(&self) -> String {
         match self {
             Self::Empty => String::new(),
             Self::Block => "{}".to_string(),
             Self::Unit => "()".to_string(),
-            Self::IfSequence(inner) => format!("({inner})"),
-            Self::Expr(inner) => inner.clone(),
+            Self::IfSequence(inner, _) => format!("({inner})"),
+            Self::Expr(inner, _) => inner.to_string(),
         }
     }
 }
@@ -208,7 +215,7 @@ fn check_final_expr<'tcx>(
     expr: &'tcx Expr<'tcx>,
     semi_spans: Vec<Span>, /* containing all the places where we would need to remove semicolons if finding an
                             * needless return */
-    replacement: RetReplacement,
+    replacement: RetReplacement<'tcx>,
 ) {
     let peeled_drop_expr = expr.peel_drop_temps();
     match &peeled_drop_expr.kind {
@@ -229,17 +236,12 @@ fn check_final_expr<'tcx>(
                     return;
                 }
 
-                let (snippet, _) = snippet_with_context(
-                    cx,
-                    inner_expr.span,
-                    ret_span.ctxt(),
-                    "..",
-                    &mut Applicability::MachineApplicable,
-                );
-                if expr_contains_if(inner_expr) {
-                    RetReplacement::IfSequence(snippet.to_string())
+                let mut applicability = Applicability::MachineApplicable;
+                let (snippet, _) = snippet_with_context(cx, inner_expr.span, ret_span.ctxt(), "..", &mut applicability);
+                if expr_contains_conjunctive_ifs(inner_expr) {
+                    RetReplacement::IfSequence(snippet, applicability)
                 } else {
-                    RetReplacement::Expr(snippet.to_string())
+                    RetReplacement::Expr(snippet, applicability)
                 }
             } else {
                 replacement
@@ -275,19 +277,23 @@ fn check_final_expr<'tcx>(
     }
 }
 
-fn expr_contains_if<'tcx>(expr: &'tcx Expr<'tcx>) -> bool {
-    match expr.kind {
-        ExprKind::If(..) => true,
-        ExprKind::Binary(_, left, right) => expr_contains_if(left) || expr_contains_if(right),
-        _ => false,
+fn expr_contains_conjunctive_ifs<'tcx>(expr: &'tcx Expr<'tcx>) -> bool {
+    fn contains_if(expr: &Expr<'_>, on_if: bool) -> bool {
+        match expr.kind {
+            ExprKind::If(..) => on_if,
+            ExprKind::Binary(_, left, right) => contains_if(left, true) || contains_if(right, true),
+            _ => false,
+        }
     }
+
+    contains_if(expr, false)
 }
 
-fn emit_return_lint(cx: &LateContext<'_>, ret_span: Span, semi_spans: Vec<Span>, replacement: RetReplacement) {
+fn emit_return_lint(cx: &LateContext<'_>, ret_span: Span, semi_spans: Vec<Span>, replacement: RetReplacement<'_>) {
     if ret_span.from_expansion() {
         return;
     }
-    let applicability = Applicability::MachineApplicable;
+    let applicability = replacement.applicability().unwrap_or(Applicability::MachineApplicable);
     let return_replacement = replacement.to_string();
     let sugg_help = replacement.sugg_help();
     span_lint_and_then(cx, NEEDLESS_RETURN, ret_span, "unneeded `return` statement", |diag| {
diff --git a/tests/ui/needless_return.fixed b/tests/ui/needless_return.fixed
index c77554fb47b..0f525dd294c 100644
--- a/tests/ui/needless_return.fixed
+++ b/tests/ui/needless_return.fixed
@@ -297,8 +297,14 @@ fn issue10051() -> Result<String, String> {
     }
 }
 
-fn issue10049(b1: bool, b2: bool, b3: bool) -> u32 {
-    (if b1 { 0 } else { 1 } | if b2 { 2 } else { 3 } | if b3 { 4 } else { 5 })
+mod issue10049 {
+    fn single() -> u32 {
+        if true { 1 } else { 2 }
+    }
+
+    fn multiple(b1: bool, b2: bool, b3: bool) -> u32 {
+        (if b1 { 0 } else { 1 } | if b2 { 2 } else { 3 } | if b3 { 4 } else { 5 })
+    }
 }
 
 fn main() {}
diff --git a/tests/ui/needless_return.rs b/tests/ui/needless_return.rs
index 8fed64ac6e3..a1db8375d95 100644
--- a/tests/ui/needless_return.rs
+++ b/tests/ui/needless_return.rs
@@ -307,8 +307,14 @@ fn issue10051() -> Result<String, String> {
     }
 }
 
-fn issue10049(b1: bool, b2: bool, b3: bool) -> u32 {
-    return if b1 { 0 } else { 1 } | if b2 { 2 } else { 3 } | if b3 { 4 } else { 5 };
+mod issue10049 {
+    fn single() -> u32 {
+        return if true { 1 } else { 2 };
+    }
+
+    fn multiple(b1: bool, b2: bool, b3: bool) -> u32 {
+        return if b1 { 0 } else { 1 } | if b2 { 2 } else { 3 } | if b3 { 4 } else { 5 };
+    }
 }
 
 fn main() {}
diff --git a/tests/ui/needless_return.stderr b/tests/ui/needless_return.stderr
index 18edbce2f44..87d0cd3e14c 100644
--- a/tests/ui/needless_return.stderr
+++ b/tests/ui/needless_return.stderr
@@ -419,12 +419,20 @@ LL |         return Err(format!("err!"));
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:311:5
+  --> $DIR/needless_return.rs:312:9
    |
-LL |     return if b1 { 0 } else { 1 } | if b2 { 2 } else { 3 } | if b3 { 4 } else { 5 };
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |         return if true { 1 } else { 2 };
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: remove `return`
+
+error: unneeded `return` statement
+  --> $DIR/needless_return.rs:316:9
+   |
+LL |         return if b1 { 0 } else { 1 } | if b2 { 2 } else { 3 } | if b3 { 4 } else { 5 };
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: remove `return` and wrap the sequence with parentheses
 
-error: aborting due to 51 previous errors
+error: aborting due to 52 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 75aa2b9ec8529a3854a4ebaab1a03438410dc87e Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Mon, 13 Feb 2023 20:41:26 +0100
Subject: uninlined_format_args: do not inline argument with generic parameters

---
 clippy_lints/src/format_args.rs      | 1 +
 tests/ui/uninlined_format_args.fixed | 4 ++++
 tests/ui/uninlined_format_args.rs    | 4 ++++
 3 files changed, 9 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/format_args.rs b/clippy_lints/src/format_args.rs
index 92238d557e9..e7caed65bf2 100644
--- a/clippy_lints/src/format_args.rs
+++ b/clippy_lints/src/format_args.rs
@@ -340,6 +340,7 @@ fn check_one_arg(
     if matches!(param.kind, Implicit | Starred | Named(_) | Numbered)
         && let ExprKind::Path(QPath::Resolved(None, path)) = param.value.kind
         && let [segment] = path.segments
+        && segment.args.is_none()
         && let Some(arg_span) = args.value_with_prev_comma_span(param.value.hir_id)
     {
         let replacement = match param.usage {
diff --git a/tests/ui/uninlined_format_args.fixed b/tests/ui/uninlined_format_args.fixed
index 9d08e80cf9a..cbd5cc5fcee 100644
--- a/tests/ui/uninlined_format_args.fixed
+++ b/tests/ui/uninlined_format_args.fixed
@@ -174,3 +174,7 @@ fn _meets_msrv() {
     let local_i32 = 1;
     println!("expand='{local_i32}'");
 }
+
+fn _do_not_fire() {
+    println!("{:?}", None::<()>);
+}
diff --git a/tests/ui/uninlined_format_args.rs b/tests/ui/uninlined_format_args.rs
index 35b3677a896..cf0ea5be481 100644
--- a/tests/ui/uninlined_format_args.rs
+++ b/tests/ui/uninlined_format_args.rs
@@ -179,3 +179,7 @@ fn _meets_msrv() {
     let local_i32 = 1;
     println!("expand='{}'", local_i32);
 }
+
+fn _do_not_fire() {
+    println!("{:?}", None::<()>);
+}
-- 
cgit 1.4.1-3-g733a5


From 1ee4651ca1c31b39f106079e7546a47d00a3d945 Mon Sep 17 00:00:00 2001
From: Michael Krasnitski <michael.krasnitski@gmail.com>
Date: Sun, 12 Feb 2023 14:45:44 -0500
Subject: Ignore synthetic type parameters for `extra_unused_type_parameters`

---
 clippy_lints/src/extra_unused_type_parameters.rs |  7 +++----
 tests/ui/extra_unused_type_parameters.rs         |  2 ++
 tests/ui/extra_unused_type_parameters.stderr     | 10 +++++++++-
 3 files changed, 14 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/extra_unused_type_parameters.rs b/clippy_lints/src/extra_unused_type_parameters.rs
index 9e9ad80b334..040473c9ffc 100644
--- a/clippy_lints/src/extra_unused_type_parameters.rs
+++ b/clippy_lints/src/extra_unused_type_parameters.rs
@@ -23,7 +23,6 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust
-    /// // unused type parameters
     /// fn unused_ty<T>(x: u8) {
     ///     // ..
     /// }
@@ -45,7 +44,7 @@ declare_lint_pass!(ExtraUnusedTypeParameters => [EXTRA_UNUSED_TYPE_PARAMETERS]);
 /// trait bounds those parameters have.
 struct TypeWalker<'cx, 'tcx> {
     cx: &'cx LateContext<'tcx>,
-    /// Collection of all the type parameters and their spans.
+    /// Collection of all the function's type parameters.
     ty_params: FxHashMap<DefId, Span>,
     /// Collection of any (inline) trait bounds corresponding to each type parameter.
     bounds: FxHashMap<DefId, Span>,
@@ -69,8 +68,8 @@ impl<'cx, 'tcx> TypeWalker<'cx, 'tcx> {
             .params
             .iter()
             .filter_map(|param| {
-                if let GenericParamKind::Type { .. } = param.kind {
-                    Some((param.def_id.into(), param.span))
+                if let GenericParamKind::Type { synthetic, .. } = param.kind {
+                    (!synthetic).then_some((param.def_id.into(), param.span))
                 } else {
                     if !param.is_elided_lifetime() {
                         all_params_unused = false;
diff --git a/tests/ui/extra_unused_type_parameters.rs b/tests/ui/extra_unused_type_parameters.rs
index a1cd8a0d085..2894fda2f47 100644
--- a/tests/ui/extra_unused_type_parameters.rs
+++ b/tests/ui/extra_unused_type_parameters.rs
@@ -71,6 +71,8 @@ where
         .filter_map(move |(i, a)| if i == index { None } else { Some(a) })
 }
 
+fn unused_opaque<A, B>(dummy: impl Default) {}
+
 mod issue10319 {
     fn assert_send<T: Send>() {}
 
diff --git a/tests/ui/extra_unused_type_parameters.stderr b/tests/ui/extra_unused_type_parameters.stderr
index 69a067bd849..aea3ee310f7 100644
--- a/tests/ui/extra_unused_type_parameters.stderr
+++ b/tests/ui/extra_unused_type_parameters.stderr
@@ -55,5 +55,13 @@ LL |     fn unused_ty_impl<T>(&self) {}
    |
    = help: consider removing the parameter
 
-error: aborting due to 7 previous errors
+error: type parameters go unused in function definition
+  --> $DIR/extra_unused_type_parameters.rs:74:17
+   |
+LL | fn unused_opaque<A, B>(dummy: impl Default) {}
+   |                 ^^^^^^
+   |
+   = help: consider removing the parameters
+
+error: aborting due to 8 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 8ec9543f13ba0fe6af76816441b7c7d54653b854 Mon Sep 17 00:00:00 2001
From: blyxyas <blyxyas@gmail.com>
Date: Tue, 10 Jan 2023 00:18:24 +0100
Subject: Add `impl_trait_param` lint

As this is a lint about "style", and a purely cosmetical choice (using `<A: Trait>` over `impl Trait`), a lot of other files needed to be allowed this lint.
---
 CHANGELOG.md                                       |  1 +
 clippy_lints/src/declared_lints.rs                 |  1 +
 clippy_lints/src/functions/impl_trait_param.rs     | 88 ++++++++++++++++++++++
 clippy_lints/src/functions/mod.rs                  | 29 +++++++
 clippy_utils/src/ast_utils.rs                      |  7 +-
 clippy_utils/src/check_proc_macro.rs               |  1 +
 clippy_utils/src/hir_utils.rs                      |  1 +
 clippy_utils/src/macros.rs                         |  2 +-
 clippy_utils/src/source.rs                         |  2 +-
 tests/ui/borrow_box.rs                             |  2 +-
 tests/ui/eta.fixed                                 |  3 +-
 tests/ui/eta.rs                                    |  3 +-
 tests/ui/eta.stderr                                | 52 ++++++-------
 tests/ui/impl_trait_param.rs                       | 15 ++++
 tests/ui/impl_trait_param.stderr                   | 25 ++++++
 tests/ui/trait_duplication_in_bounds.fixed         |  1 +
 tests/ui/trait_duplication_in_bounds.rs            |  1 +
 tests/ui/trait_duplication_in_bounds.stderr        | 16 ++--
 tests/ui/trait_duplication_in_bounds_unfixable.rs  |  1 +
 .../trait_duplication_in_bounds_unfixable.stderr   | 16 ++--
 20 files changed, 219 insertions(+), 48 deletions(-)
 create mode 100644 clippy_lints/src/functions/impl_trait_param.rs
 create mode 100644 tests/ui/impl_trait_param.rs
 create mode 100644 tests/ui/impl_trait_param.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 30727beb8e7..e2d971b38bc 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4430,6 +4430,7 @@ Released 2018-09-13
 [`if_same_then_else`]: https://rust-lang.github.io/rust-clippy/master/index.html#if_same_then_else
 [`if_then_some_else_none`]: https://rust-lang.github.io/rust-clippy/master/index.html#if_then_some_else_none
 [`ifs_same_cond`]: https://rust-lang.github.io/rust-clippy/master/index.html#ifs_same_cond
+[`impl_trait_param`]: https://rust-lang.github.io/rust-clippy/master/index.html#impl_trait_param
 [`implicit_clone`]: https://rust-lang.github.io/rust-clippy/master/index.html#implicit_clone
 [`implicit_hasher`]: https://rust-lang.github.io/rust-clippy/master/index.html#implicit_hasher
 [`implicit_return`]: https://rust-lang.github.io/rust-clippy/master/index.html#implicit_return
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index c1feabf05aa..41b04f13721 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -179,6 +179,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::from_raw_with_void_ptr::FROM_RAW_WITH_VOID_PTR_INFO,
     crate::from_str_radix_10::FROM_STR_RADIX_10_INFO,
     crate::functions::DOUBLE_MUST_USE_INFO,
+    crate::functions::IMPL_TRAIT_PARAM_INFO,
     crate::functions::MISNAMED_GETTERS_INFO,
     crate::functions::MUST_USE_CANDIDATE_INFO,
     crate::functions::MUST_USE_UNIT_INFO,
diff --git a/clippy_lints/src/functions/impl_trait_param.rs b/clippy_lints/src/functions/impl_trait_param.rs
new file mode 100644
index 00000000000..1e819dc6c82
--- /dev/null
+++ b/clippy_lints/src/functions/impl_trait_param.rs
@@ -0,0 +1,88 @@
+use clippy_utils::{diagnostics::span_lint_and_then, is_in_test_function};
+
+use rustc_hir::{intravisit::FnKind, Body, Generics, HirId};
+use rustc_lint::LateContext;
+use rustc_span::Span;
+
+use super::IMPL_TRAIT_PARAM;
+
+pub(super) fn check_fn<'tcx>(cx: &LateContext<'_>, kind: &'tcx FnKind<'_>, body: &'tcx Body<'_>, hir_id: HirId) {
+    if cx.tcx.visibility(cx.tcx.hir().body_owner_def_id(body.id())).is_public() && !is_in_test_function(cx.tcx, hir_id)
+    {
+        if let FnKind::ItemFn(ident, generics, _) = kind {
+            for param in generics.params {
+                if param.is_impl_trait()
+                    && !param.name.ident().as_str().contains('<')
+                    && !param.name.ident().as_str().contains('(')
+                {
+                    // No generics with nested generics, and no generics like FnMut(x)
+                    span_lint_and_then(
+                        cx,
+                        IMPL_TRAIT_PARAM,
+                        param.span,
+                        &format!("'{}' in the function's parameters", param.name.ident().as_str()),
+                        |diag| {
+                            let next_letter = next_valid_letter(generics);
+                            if let Some(gen_span) = generics.span_for_param_suggestion() {
+                                diag.span_suggestion_with_style(
+                                    gen_span,
+                                    format!(
+                                        "create a generic type here and replace that `{}` with `{}`",
+                                        param.name.ident().as_str(),
+                                        next_letter
+                                    ),
+                                    ", T: Trait",
+                                    rustc_errors::Applicability::MaybeIncorrect,
+                                    rustc_errors::SuggestionStyle::ShowAlways,
+                                );
+                            } else {
+                                // multispan.push_span_label(param.span, format!("Replace this with `{}`",
+                                // next_letter));
+
+                                diag.span_suggestion_with_style(
+                                    Span::new(
+                                        body.params[0].span.lo() - rustc_span::BytePos(1),
+                                        ident.span.hi(),
+                                        ident.span.ctxt(),
+                                        ident.span.parent(),
+                                    ),
+                                    format!(
+                                        "create a generic type here and replace that '{}' with `{}`",
+                                        param.name.ident().as_str(),
+                                        next_letter
+                                    ),
+                                    "<T: Trait>",
+                                    rustc_errors::Applicability::MaybeIncorrect,
+                                    rustc_errors::SuggestionStyle::ShowAlways,
+                                );
+                            }
+                        },
+                    );
+                }
+            }
+        }
+    }
+}
+
+fn next_valid_letter(generics: &Generics<'_>) -> char {
+    let mut generics_names = Vec::new();
+
+    generics.params.iter().for_each(|param| {
+        generics_names.push(param.name.ident().as_str().to_owned());
+    });
+
+    // If T exists, try with U, then with V, and so on...
+    let mut current_letter = 84u32; // ASCII code for "T"
+    while generics_names.contains(&String::from(char::from_u32(current_letter).unwrap())) {
+        current_letter += 1;
+        if current_letter == 91 {
+            // ASCII code for "Z"
+            current_letter = 65;
+        } else if current_letter == 83 {
+            // ASCII "S"
+            current_letter = 97; // "a"
+        };
+    }
+
+    char::from_u32(current_letter).unwrap()
+}
diff --git a/clippy_lints/src/functions/mod.rs b/clippy_lints/src/functions/mod.rs
index 4399c68e130..cd0df1438df 100644
--- a/clippy_lints/src/functions/mod.rs
+++ b/clippy_lints/src/functions/mod.rs
@@ -1,3 +1,4 @@
+mod impl_trait_param;
 mod misnamed_getters;
 mod must_use;
 mod not_unsafe_ptr_arg_deref;
@@ -327,6 +328,32 @@ declare_clippy_lint! {
     "getter method returning the wrong field"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Lints when `impl Trait` is being used in a function's paremeters.
+    /// ### Why is this bad?
+    /// Turbofish syntax (`::<>`) cannot be used when `impl Trait` is being used, making `impl Trait` less powerful. Readability may also be a factor.
+    ///
+    /// ### Example
+    /// ```rust
+    /// trait MyTrait {}
+    /// fn foo(a: impl MyTrait) {
+    /// 	// [...]
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// trait MyTrait {}
+    /// fn foo<T: A>(a: A) {
+    /// 	// [...]
+    /// }
+    /// ```
+    #[clippy::version = "1.68.0"]
+    pub IMPL_TRAIT_PARAM,
+    style,
+    "`impl Trait` is used in the function's parameters"
+}
+
 #[derive(Copy, Clone)]
 pub struct Functions {
     too_many_arguments_threshold: u64,
@@ -354,6 +381,7 @@ impl_lint_pass!(Functions => [
     RESULT_UNIT_ERR,
     RESULT_LARGE_ERR,
     MISNAMED_GETTERS,
+    IMPL_TRAIT_PARAM,
 ]);
 
 impl<'tcx> LateLintPass<'tcx> for Functions {
@@ -371,6 +399,7 @@ impl<'tcx> LateLintPass<'tcx> for Functions {
         too_many_lines::check_fn(cx, kind, span, body, self.too_many_lines_threshold);
         not_unsafe_ptr_arg_deref::check_fn(cx, kind, decl, body, def_id);
         misnamed_getters::check_fn(cx, kind, decl, body, span);
+        impl_trait_param::check_fn(cx, &kind, body, hir_id);
     }
 
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) {
diff --git a/clippy_utils/src/ast_utils.rs b/clippy_utils/src/ast_utils.rs
index 9d0263e93be..62089320ce3 100644
--- a/clippy_utils/src/ast_utils.rs
+++ b/clippy_utils/src/ast_utils.rs
@@ -2,7 +2,12 @@
 //!
 //! - The `eq_foobar` functions test for semantic equality but ignores `NodeId`s and `Span`s.
 
-#![allow(clippy::similar_names, clippy::wildcard_imports, clippy::enum_glob_use)]
+#![allow(
+    clippy::similar_names,
+    clippy::wildcard_imports,
+    clippy::enum_glob_use,
+    clippy::impl_trait_param
+)]
 
 use crate::{both, over};
 use rustc_ast::ptr::P;
diff --git a/clippy_utils/src/check_proc_macro.rs b/clippy_utils/src/check_proc_macro.rs
index 43f0df145f0..8650f3c6828 100644
--- a/clippy_utils/src/check_proc_macro.rs
+++ b/clippy_utils/src/check_proc_macro.rs
@@ -1,3 +1,4 @@
+#![allow(clippy::impl_trait_param)]
 //! This module handles checking if the span given is from a proc-macro or not.
 //!
 //! Proc-macros are capable of setting the span of every token they output to a few possible spans.
diff --git a/clippy_utils/src/hir_utils.rs b/clippy_utils/src/hir_utils.rs
index 2bbe1a19b62..2cd213ed705 100644
--- a/clippy_utils/src/hir_utils.rs
+++ b/clippy_utils/src/hir_utils.rs
@@ -1,3 +1,4 @@
+#![allow(clippy::impl_trait_param)]
 use crate::consts::constant_simple;
 use crate::macros::macro_backtrace;
 use crate::source::snippet_opt;
diff --git a/clippy_utils/src/macros.rs b/clippy_utils/src/macros.rs
index 63dccbf697c..a85d11f6234 100644
--- a/clippy_utils/src/macros.rs
+++ b/clippy_utils/src/macros.rs
@@ -1,4 +1,4 @@
-#![allow(clippy::similar_names)] // `expr` and `expn`
+#![allow(clippy::similar_names, clippy::impl_trait_param)] // `expr` and `expn`
 
 use crate::source::snippet_opt;
 use crate::visitors::{for_each_expr, Descend};
diff --git a/clippy_utils/src/source.rs b/clippy_utils/src/source.rs
index cd5dcfdaca3..39d00e89551 100644
--- a/clippy_utils/src/source.rs
+++ b/clippy_utils/src/source.rs
@@ -1,6 +1,6 @@
 //! Utils for extracting, inspecting or transforming source code
 
-#![allow(clippy::module_name_repetitions)]
+#![allow(clippy::module_name_repetitions, clippy::impl_trait_param)]
 
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
diff --git a/tests/ui/borrow_box.rs b/tests/ui/borrow_box.rs
index 3b5b6bf4c95..e3e5b8464b7 100644
--- a/tests/ui/borrow_box.rs
+++ b/tests/ui/borrow_box.rs
@@ -1,6 +1,6 @@
 #![deny(clippy::borrowed_box)]
 #![allow(dead_code, unused_variables)]
-#![allow(clippy::uninlined_format_args, clippy::disallowed_names)]
+#![allow(clippy::uninlined_format_args, clippy::disallowed_names, clippy::impl_trait_param)]
 
 use std::fmt::Display;
 
diff --git a/tests/ui/eta.fixed b/tests/ui/eta.fixed
index dc129591eac..8c19143cb2e 100644
--- a/tests/ui/eta.fixed
+++ b/tests/ui/eta.fixed
@@ -7,7 +7,8 @@
     clippy::no_effect,
     clippy::option_map_unit_fn,
     clippy::redundant_closure_call,
-    clippy::uninlined_format_args
+    clippy::uninlined_format_args,
+    clippy::impl_trait_param
 )]
 
 use std::path::{Path, PathBuf};
diff --git a/tests/ui/eta.rs b/tests/ui/eta.rs
index 025fd6a0b7a..10d4924c599 100644
--- a/tests/ui/eta.rs
+++ b/tests/ui/eta.rs
@@ -7,7 +7,8 @@
     clippy::no_effect,
     clippy::option_map_unit_fn,
     clippy::redundant_closure_call,
-    clippy::uninlined_format_args
+    clippy::uninlined_format_args,
+    clippy::impl_trait_param
 )]
 
 use std::path::{Path, PathBuf};
diff --git a/tests/ui/eta.stderr b/tests/ui/eta.stderr
index a521fb86860..6ddecc58eaf 100644
--- a/tests/ui/eta.stderr
+++ b/tests/ui/eta.stderr
@@ -1,5 +1,5 @@
 error: redundant closure
-  --> $DIR/eta.rs:28:27
+  --> $DIR/eta.rs:29:27
    |
 LL |     let a = Some(1u8).map(|a| foo(a));
    |                           ^^^^^^^^^^ help: replace the closure with the function itself: `foo`
@@ -7,31 +7,31 @@ LL |     let a = Some(1u8).map(|a| foo(a));
    = note: `-D clippy::redundant-closure` implied by `-D warnings`
 
 error: redundant closure
-  --> $DIR/eta.rs:32:40
+  --> $DIR/eta.rs:33:40
    |
 LL |     let _: Option<Vec<u8>> = true.then(|| vec![]); // special case vec!
    |                                        ^^^^^^^^^ help: replace the closure with `Vec::new`: `std::vec::Vec::new`
 
 error: redundant closure
-  --> $DIR/eta.rs:33:35
+  --> $DIR/eta.rs:34:35
    |
 LL |     let d = Some(1u8).map(|a| foo((|b| foo2(b))(a))); //is adjusted?
    |                                   ^^^^^^^^^^^^^ help: replace the closure with the function itself: `foo2`
 
 error: redundant closure
-  --> $DIR/eta.rs:34:26
+  --> $DIR/eta.rs:35:26
    |
 LL |     all(&[1, 2, 3], &&2, |x, y| below(x, y)); //is adjusted
    |                          ^^^^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `below`
 
 error: redundant closure
-  --> $DIR/eta.rs:41:27
+  --> $DIR/eta.rs:42:27
    |
 LL |     let e = Some(1u8).map(|a| generic(a));
    |                           ^^^^^^^^^^^^^^ help: replace the closure with the function itself: `generic`
 
 error: redundant closure
-  --> $DIR/eta.rs:87:51
+  --> $DIR/eta.rs:88:51
    |
 LL |     let e = Some(TestStruct { some_ref: &i }).map(|a| a.foo());
    |                                                   ^^^^^^^^^^^ help: replace the closure with the method itself: `TestStruct::foo`
@@ -39,121 +39,121 @@ LL |     let e = Some(TestStruct { some_ref: &i }).map(|a| a.foo());
    = note: `-D clippy::redundant-closure-for-method-calls` implied by `-D warnings`
 
 error: redundant closure
-  --> $DIR/eta.rs:88:51
+  --> $DIR/eta.rs:89:51
    |
 LL |     let e = Some(TestStruct { some_ref: &i }).map(|a| a.trait_foo());
    |                                                   ^^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `TestTrait::trait_foo`
 
 error: redundant closure
-  --> $DIR/eta.rs:90:42
+  --> $DIR/eta.rs:91:42
    |
 LL |     let e = Some(&mut vec![1, 2, 3]).map(|v| v.clear());
    |                                          ^^^^^^^^^^^^^ help: replace the closure with the method itself: `std::vec::Vec::clear`
 
 error: redundant closure
-  --> $DIR/eta.rs:94:29
+  --> $DIR/eta.rs:95:29
    |
 LL |     let e = Some("str").map(|s| s.to_string());
    |                             ^^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `std::string::ToString::to_string`
 
 error: redundant closure
-  --> $DIR/eta.rs:95:27
+  --> $DIR/eta.rs:96:27
    |
 LL |     let e = Some('a').map(|s| s.to_uppercase());
    |                           ^^^^^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `char::to_uppercase`
 
 error: redundant closure
-  --> $DIR/eta.rs:97:65
+  --> $DIR/eta.rs:98:65
    |
 LL |     let e: std::vec::Vec<char> = vec!['a', 'b', 'c'].iter().map(|c| c.to_ascii_uppercase()).collect();
    |                                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `char::to_ascii_uppercase`
 
 error: redundant closure
-  --> $DIR/eta.rs:160:22
+  --> $DIR/eta.rs:161:22
    |
 LL |     requires_fn_once(|| x());
    |                      ^^^^^^ help: replace the closure with the function itself: `x`
 
 error: redundant closure
-  --> $DIR/eta.rs:167:27
+  --> $DIR/eta.rs:168:27
    |
 LL |     let a = Some(1u8).map(|a| foo_ptr(a));
    |                           ^^^^^^^^^^^^^^ help: replace the closure with the function itself: `foo_ptr`
 
 error: redundant closure
-  --> $DIR/eta.rs:172:27
+  --> $DIR/eta.rs:173:27
    |
 LL |     let a = Some(1u8).map(|a| closure(a));
    |                           ^^^^^^^^^^^^^^ help: replace the closure with the function itself: `closure`
 
 error: redundant closure
-  --> $DIR/eta.rs:204:28
+  --> $DIR/eta.rs:205:28
    |
 LL |     x.into_iter().for_each(|x| add_to_res(x));
    |                            ^^^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `&mut add_to_res`
 
 error: redundant closure
-  --> $DIR/eta.rs:205:28
+  --> $DIR/eta.rs:206:28
    |
 LL |     y.into_iter().for_each(|x| add_to_res(x));
    |                            ^^^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `&mut add_to_res`
 
 error: redundant closure
-  --> $DIR/eta.rs:206:28
+  --> $DIR/eta.rs:207:28
    |
 LL |     z.into_iter().for_each(|x| add_to_res(x));
    |                            ^^^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `add_to_res`
 
 error: redundant closure
-  --> $DIR/eta.rs:213:21
+  --> $DIR/eta.rs:214:21
    |
 LL |         Some(1).map(|n| closure(n));
    |                     ^^^^^^^^^^^^^^ help: replace the closure with the function itself: `&mut closure`
 
 error: redundant closure
-  --> $DIR/eta.rs:217:21
+  --> $DIR/eta.rs:218:21
    |
 LL |         Some(1).map(|n| in_loop(n));
    |                     ^^^^^^^^^^^^^^ help: replace the closure with the function itself: `in_loop`
 
 error: redundant closure
-  --> $DIR/eta.rs:310:18
+  --> $DIR/eta.rs:311:18
    |
 LL |     takes_fn_mut(|| f());
    |                  ^^^^^^ help: replace the closure with the function itself: `&mut f`
 
 error: redundant closure
-  --> $DIR/eta.rs:313:19
+  --> $DIR/eta.rs:314:19
    |
 LL |     takes_fn_once(|| f());
    |                   ^^^^^^ help: replace the closure with the function itself: `&mut f`
 
 error: redundant closure
-  --> $DIR/eta.rs:317:26
+  --> $DIR/eta.rs:318:26
    |
 LL |     move || takes_fn_mut(|| f_used_once())
    |                          ^^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `&mut f_used_once`
 
 error: redundant closure
-  --> $DIR/eta.rs:329:19
+  --> $DIR/eta.rs:330:19
    |
 LL |     array_opt.map(|a| a.as_slice());
    |                   ^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `<[u8; 3]>::as_slice`
 
 error: redundant closure
-  --> $DIR/eta.rs:332:19
+  --> $DIR/eta.rs:333:19
    |
 LL |     slice_opt.map(|s| s.len());
    |                   ^^^^^^^^^^^ help: replace the closure with the method itself: `<[u8]>::len`
 
 error: redundant closure
-  --> $DIR/eta.rs:335:17
+  --> $DIR/eta.rs:336:17
    |
 LL |     ptr_opt.map(|p| p.is_null());
    |                 ^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `<*const usize>::is_null`
 
 error: redundant closure
-  --> $DIR/eta.rs:339:17
+  --> $DIR/eta.rs:340:17
    |
 LL |     dyn_opt.map(|d| d.method_on_dyn());
    |                 ^^^^^^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `<dyn TestTrait>::method_on_dyn`
diff --git a/tests/ui/impl_trait_param.rs b/tests/ui/impl_trait_param.rs
new file mode 100644
index 00000000000..3bb9cdbaa09
--- /dev/null
+++ b/tests/ui/impl_trait_param.rs
@@ -0,0 +1,15 @@
+#![allow(unused)]
+#![warn(clippy::impl_trait_param)]
+
+pub trait Trait {}
+
+// Should warn
+pub fn a(_: impl Trait) {}
+pub fn c<C: Trait>(_: C, _: impl Trait) {}
+
+// Shouldn't warn
+
+pub fn b<B: Trait>(_: B) {}
+fn d<D: Trait>(_: D, _: impl Trait) {}
+
+fn main() {}
diff --git a/tests/ui/impl_trait_param.stderr b/tests/ui/impl_trait_param.stderr
new file mode 100644
index 00000000000..55dec5d0d99
--- /dev/null
+++ b/tests/ui/impl_trait_param.stderr
@@ -0,0 +1,25 @@
+error: 'impl Trait' in the function's parameters
+  --> $DIR/impl_trait_param.rs:7:13
+   |
+LL | pub fn a(_: impl Trait) {}
+   |             ^^^^^^^^^^
+   |
+   = note: `-D clippy::impl-trait-param` implied by `-D warnings`
+help: create a generic type here and replace that 'impl Trait' with `T`
+   |
+LL | pub fn a<T: Trait>(_: impl Trait) {}
+   |         ++++++++++
+
+error: 'impl Trait' in the function's parameters
+  --> $DIR/impl_trait_param.rs:8:29
+   |
+LL | pub fn c<C: Trait>(_: C, _: impl Trait) {}
+   |                             ^^^^^^^^^^
+   |
+help: create a generic type here and replace that `impl Trait` with `T`
+   |
+LL | pub fn c<C: Trait, T: Trait>(_: C, _: impl Trait) {}
+   |                  ++++++++++
+
+error: aborting due to 2 previous errors
+
diff --git a/tests/ui/trait_duplication_in_bounds.fixed b/tests/ui/trait_duplication_in_bounds.fixed
index 4ce5d421782..a587cc8b456 100644
--- a/tests/ui/trait_duplication_in_bounds.fixed
+++ b/tests/ui/trait_duplication_in_bounds.fixed
@@ -1,5 +1,6 @@
 // run-rustfix
 #![deny(clippy::trait_duplication_in_bounds)]
+#![allow(clippy::impl_trait_param)]
 #![allow(unused)]
 
 fn bad_foo<T: Clone + Copy, U: Clone + Copy>(arg0: T, argo1: U) {
diff --git a/tests/ui/trait_duplication_in_bounds.rs b/tests/ui/trait_duplication_in_bounds.rs
index 7f2e96a22e6..beb41ea26d9 100644
--- a/tests/ui/trait_duplication_in_bounds.rs
+++ b/tests/ui/trait_duplication_in_bounds.rs
@@ -1,5 +1,6 @@
 // run-rustfix
 #![deny(clippy::trait_duplication_in_bounds)]
+#![allow(clippy::impl_trait_param)]
 #![allow(unused)]
 
 fn bad_foo<T: Clone + Clone + Clone + Copy, U: Clone + Copy>(arg0: T, argo1: U) {
diff --git a/tests/ui/trait_duplication_in_bounds.stderr b/tests/ui/trait_duplication_in_bounds.stderr
index af800ba7888..5216b2250db 100644
--- a/tests/ui/trait_duplication_in_bounds.stderr
+++ b/tests/ui/trait_duplication_in_bounds.stderr
@@ -1,5 +1,5 @@
 error: these bounds contain repeated elements
-  --> $DIR/trait_duplication_in_bounds.rs:5:15
+  --> $DIR/trait_duplication_in_bounds.rs:6:15
    |
 LL | fn bad_foo<T: Clone + Clone + Clone + Copy, U: Clone + Copy>(arg0: T, argo1: U) {
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Clone + Copy`
@@ -11,43 +11,43 @@ LL | #![deny(clippy::trait_duplication_in_bounds)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: these where clauses contain repeated elements
-  --> $DIR/trait_duplication_in_bounds.rs:11:8
+  --> $DIR/trait_duplication_in_bounds.rs:12:8
    |
 LL |     T: Clone + Clone + Clone + Copy,
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Clone + Copy`
 
 error: these bounds contain repeated elements
-  --> $DIR/trait_duplication_in_bounds.rs:39:26
+  --> $DIR/trait_duplication_in_bounds.rs:40:26
    |
 LL | trait BadSelfTraitBound: Clone + Clone + Clone {
    |                          ^^^^^^^^^^^^^^^^^^^^^ help: try: `Clone`
 
 error: these where clauses contain repeated elements
-  --> $DIR/trait_duplication_in_bounds.rs:46:15
+  --> $DIR/trait_duplication_in_bounds.rs:47:15
    |
 LL |         Self: Clone + Clone + Clone;
    |               ^^^^^^^^^^^^^^^^^^^^^ help: try: `Clone`
 
 error: these bounds contain repeated elements
-  --> $DIR/trait_duplication_in_bounds.rs:60:24
+  --> $DIR/trait_duplication_in_bounds.rs:61:24
    |
 LL | trait BadTraitBound<T: Clone + Clone + Clone + Copy, U: Clone + Copy> {
    |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Clone + Copy`
 
 error: these where clauses contain repeated elements
-  --> $DIR/trait_duplication_in_bounds.rs:67:12
+  --> $DIR/trait_duplication_in_bounds.rs:68:12
    |
 LL |         T: Clone + Clone + Clone + Copy,
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Clone + Copy`
 
 error: these bounds contain repeated elements
-  --> $DIR/trait_duplication_in_bounds.rs:100:19
+  --> $DIR/trait_duplication_in_bounds.rs:101:19
    |
 LL | fn bad_generic<T: GenericTrait<u64> + GenericTrait<u32> + GenericTrait<u64>>(arg0: T) {
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `GenericTrait<u64> + GenericTrait<u32>`
 
 error: these bounds contain repeated elements
-  --> $DIR/trait_duplication_in_bounds.rs:108:22
+  --> $DIR/trait_duplication_in_bounds.rs:109:22
    |
 LL | fn qualified_path<T: std::clone::Clone + Clone + foo::Clone>(arg0: T) {
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::clone::Clone + foo::Clone`
diff --git a/tests/ui/trait_duplication_in_bounds_unfixable.rs b/tests/ui/trait_duplication_in_bounds_unfixable.rs
index 5630a0345ad..63ae4493143 100644
--- a/tests/ui/trait_duplication_in_bounds_unfixable.rs
+++ b/tests/ui/trait_duplication_in_bounds_unfixable.rs
@@ -1,4 +1,5 @@
 #![deny(clippy::trait_duplication_in_bounds)]
+#![allow(clippy::impl_trait_param)]
 
 use std::collections::BTreeMap;
 use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Sub, SubAssign};
diff --git a/tests/ui/trait_duplication_in_bounds_unfixable.stderr b/tests/ui/trait_duplication_in_bounds_unfixable.stderr
index 4d56a94646c..48091b38fb4 100644
--- a/tests/ui/trait_duplication_in_bounds_unfixable.stderr
+++ b/tests/ui/trait_duplication_in_bounds_unfixable.stderr
@@ -1,5 +1,5 @@
 error: this trait bound is already specified in the where clause
-  --> $DIR/trait_duplication_in_bounds_unfixable.rs:6:15
+  --> $DIR/trait_duplication_in_bounds_unfixable.rs:7:15
    |
 LL | fn bad_foo<T: Clone + Default, Z: Copy>(arg0: T, arg1: Z)
    |               ^^^^^
@@ -12,7 +12,7 @@ LL | #![deny(clippy::trait_duplication_in_bounds)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this trait bound is already specified in the where clause
-  --> $DIR/trait_duplication_in_bounds_unfixable.rs:6:23
+  --> $DIR/trait_duplication_in_bounds_unfixable.rs:7:23
    |
 LL | fn bad_foo<T: Clone + Default, Z: Copy>(arg0: T, arg1: Z)
    |                       ^^^^^^^
@@ -20,7 +20,7 @@ LL | fn bad_foo<T: Clone + Default, Z: Copy>(arg0: T, arg1: Z)
    = help: consider removing this trait bound
 
 error: this trait bound is already specified in trait declaration
-  --> $DIR/trait_duplication_in_bounds_unfixable.rs:35:15
+  --> $DIR/trait_duplication_in_bounds_unfixable.rs:36:15
    |
 LL |         Self: Default;
    |               ^^^^^^^
@@ -28,7 +28,7 @@ LL |         Self: Default;
    = help: consider removing this trait bound
 
 error: this trait bound is already specified in trait declaration
-  --> $DIR/trait_duplication_in_bounds_unfixable.rs:49:15
+  --> $DIR/trait_duplication_in_bounds_unfixable.rs:50:15
    |
 LL |         Self: Default + Clone;
    |               ^^^^^^^
@@ -36,7 +36,7 @@ LL |         Self: Default + Clone;
    = help: consider removing this trait bound
 
 error: this trait bound is already specified in trait declaration
-  --> $DIR/trait_duplication_in_bounds_unfixable.rs:55:15
+  --> $DIR/trait_duplication_in_bounds_unfixable.rs:56:15
    |
 LL |         Self: Default + Clone;
    |               ^^^^^^^
@@ -44,7 +44,7 @@ LL |         Self: Default + Clone;
    = help: consider removing this trait bound
 
 error: this trait bound is already specified in trait declaration
-  --> $DIR/trait_duplication_in_bounds_unfixable.rs:55:25
+  --> $DIR/trait_duplication_in_bounds_unfixable.rs:56:25
    |
 LL |         Self: Default + Clone;
    |                         ^^^^^
@@ -52,7 +52,7 @@ LL |         Self: Default + Clone;
    = help: consider removing this trait bound
 
 error: this trait bound is already specified in trait declaration
-  --> $DIR/trait_duplication_in_bounds_unfixable.rs:58:15
+  --> $DIR/trait_duplication_in_bounds_unfixable.rs:59:15
    |
 LL |         Self: Default;
    |               ^^^^^^^
@@ -60,7 +60,7 @@ LL |         Self: Default;
    = help: consider removing this trait bound
 
 error: this trait bound is already specified in trait declaration
-  --> $DIR/trait_duplication_in_bounds_unfixable.rs:93:15
+  --> $DIR/trait_duplication_in_bounds_unfixable.rs:94:15
    |
 LL |         Self: Iterator<Item = Foo>,
    |               ^^^^^^^^^^^^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From ade4c9b2b6e99e0663408318e41139d65a9d0630 Mon Sep 17 00:00:00 2001
From: blyxyas <blyxyas@gmail.com>
Date: Fri, 13 Jan 2023 12:17:30 +0100
Subject: Rename lint to better fit lint naming conventions

---
 CHANGELOG.md                                       |  1 +
 clippy_lints/src/declared_lints.rs                 |  2 +-
 clippy_lints/src/functions/impl_trait_in_params.rs | 88 ++++++++++++++++++++++
 clippy_lints/src/functions/impl_trait_param.rs     | 88 ----------------------
 clippy_lints/src/functions/mod.rs                  |  8 +-
 clippy_utils/src/ast_utils.rs                      |  2 +-
 clippy_utils/src/check_proc_macro.rs               |  2 +-
 clippy_utils/src/hir_utils.rs                      |  2 +-
 clippy_utils/src/macros.rs                         |  2 +-
 clippy_utils/src/source.rs                         |  2 +-
 tests/ui/borrow_box.rs                             |  2 +-
 tests/ui/eta.fixed                                 |  2 +-
 tests/ui/eta.rs                                    |  2 +-
 tests/ui/impl_trait_in_params.rs                   | 15 ++++
 tests/ui/impl_trait_in_params.stderr               | 25 ++++++
 tests/ui/impl_trait_param.rs                       | 15 ----
 tests/ui/impl_trait_param.stderr                   | 25 ------
 tests/ui/trait_duplication_in_bounds.fixed         |  2 +-
 tests/ui/trait_duplication_in_bounds.rs            |  2 +-
 tests/ui/trait_duplication_in_bounds_unfixable.rs  |  2 +-
 20 files changed, 145 insertions(+), 144 deletions(-)
 create mode 100644 clippy_lints/src/functions/impl_trait_in_params.rs
 delete mode 100644 clippy_lints/src/functions/impl_trait_param.rs
 create mode 100644 tests/ui/impl_trait_in_params.rs
 create mode 100644 tests/ui/impl_trait_in_params.stderr
 delete mode 100644 tests/ui/impl_trait_param.rs
 delete mode 100644 tests/ui/impl_trait_param.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index e2d971b38bc..db2602285c9 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4430,6 +4430,7 @@ Released 2018-09-13
 [`if_same_then_else`]: https://rust-lang.github.io/rust-clippy/master/index.html#if_same_then_else
 [`if_then_some_else_none`]: https://rust-lang.github.io/rust-clippy/master/index.html#if_then_some_else_none
 [`ifs_same_cond`]: https://rust-lang.github.io/rust-clippy/master/index.html#ifs_same_cond
+[`impl_trait_in_params`]: https://rust-lang.github.io/rust-clippy/master/index.html#impl_trait_in_params
 [`impl_trait_param`]: https://rust-lang.github.io/rust-clippy/master/index.html#impl_trait_param
 [`implicit_clone`]: https://rust-lang.github.io/rust-clippy/master/index.html#implicit_clone
 [`implicit_hasher`]: https://rust-lang.github.io/rust-clippy/master/index.html#implicit_hasher
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 41b04f13721..9be4f5bf7fc 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -179,7 +179,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::from_raw_with_void_ptr::FROM_RAW_WITH_VOID_PTR_INFO,
     crate::from_str_radix_10::FROM_STR_RADIX_10_INFO,
     crate::functions::DOUBLE_MUST_USE_INFO,
-    crate::functions::IMPL_TRAIT_PARAM_INFO,
+    crate::functions::IMPL_TRAIT_IN_PARAMS_INFO,
     crate::functions::MISNAMED_GETTERS_INFO,
     crate::functions::MUST_USE_CANDIDATE_INFO,
     crate::functions::MUST_USE_UNIT_INFO,
diff --git a/clippy_lints/src/functions/impl_trait_in_params.rs b/clippy_lints/src/functions/impl_trait_in_params.rs
new file mode 100644
index 00000000000..f0bfbbf1ea3
--- /dev/null
+++ b/clippy_lints/src/functions/impl_trait_in_params.rs
@@ -0,0 +1,88 @@
+use clippy_utils::{diagnostics::span_lint_and_then, is_in_test_function};
+
+use rustc_hir::{intravisit::FnKind, Body, Generics, HirId};
+use rustc_lint::LateContext;
+use rustc_span::Span;
+
+use super::IMPL_TRAIT_IN_PARAMS;
+
+pub(super) fn check_fn<'tcx>(cx: &LateContext<'_>, kind: &'tcx FnKind<'_>, body: &'tcx Body<'_>, hir_id: HirId) {
+    if cx.tcx.visibility(cx.tcx.hir().body_owner_def_id(body.id())).is_public() && !is_in_test_function(cx.tcx, hir_id)
+    {
+        if let FnKind::ItemFn(ident, generics, _) = kind {
+            for param in generics.params {
+                if param.is_impl_trait()
+                    && !param.name.ident().as_str().contains('<')
+                    && !param.name.ident().as_str().contains('(')
+                {
+                    // No generics with nested generics, and no generics like FnMut(x)
+                    span_lint_and_then(
+                        cx,
+                        IMPL_TRAIT_IN_PARAMS,
+                        param.span,
+                        &format!("'{}' in the function's parameters", param.name.ident().as_str()),
+                        |diag| {
+                            let next_letter = next_valid_letter(generics);
+                            if let Some(gen_span) = generics.span_for_param_suggestion() {
+                                diag.span_suggestion_with_style(
+                                    gen_span,
+                                    format!(
+                                        "create a generic type here and replace that `{}` with `{}`",
+                                        param.name.ident().as_str(),
+                                        next_letter
+                                    ),
+                                    ", T: Trait",
+                                    rustc_errors::Applicability::MaybeIncorrect,
+                                    rustc_errors::SuggestionStyle::ShowAlways,
+                                );
+                            } else {
+                                // multispan.push_span_label(param.span, format!("Replace this with `{}`",
+                                // next_letter));
+
+                                diag.span_suggestion_with_style(
+                                    Span::new(
+                                        body.params[0].span.lo() - rustc_span::BytePos(1),
+                                        ident.span.hi(),
+                                        ident.span.ctxt(),
+                                        ident.span.parent(),
+                                    ),
+                                    format!(
+                                        "create a generic type here and replace that '{}' with `{}`",
+                                        param.name.ident().as_str(),
+                                        next_letter
+                                    ),
+                                    "<T: Trait>",
+                                    rustc_errors::Applicability::MaybeIncorrect,
+                                    rustc_errors::SuggestionStyle::ShowAlways,
+                                );
+                            }
+                        },
+                    );
+                }
+            }
+        }
+    }
+}
+
+fn next_valid_letter(generics: &Generics<'_>) -> char {
+    let mut generics_names = Vec::new();
+
+    generics.params.iter().for_each(|param| {
+        generics_names.push(param.name.ident().as_str().to_owned());
+    });
+
+    // If T exists, try with U, then with V, and so on...
+    let mut current_letter = 84u32; // ASCII code for "T"
+    while generics_names.contains(&String::from(char::from_u32(current_letter).unwrap())) {
+        current_letter += 1;
+        if current_letter == 91 {
+            // ASCII code for "Z"
+            current_letter = 65;
+        } else if current_letter == 83 {
+            // ASCII "S"
+            current_letter = 97; // "a"
+        };
+    }
+
+    char::from_u32(current_letter).unwrap()
+}
diff --git a/clippy_lints/src/functions/impl_trait_param.rs b/clippy_lints/src/functions/impl_trait_param.rs
deleted file mode 100644
index 1e819dc6c82..00000000000
--- a/clippy_lints/src/functions/impl_trait_param.rs
+++ /dev/null
@@ -1,88 +0,0 @@
-use clippy_utils::{diagnostics::span_lint_and_then, is_in_test_function};
-
-use rustc_hir::{intravisit::FnKind, Body, Generics, HirId};
-use rustc_lint::LateContext;
-use rustc_span::Span;
-
-use super::IMPL_TRAIT_PARAM;
-
-pub(super) fn check_fn<'tcx>(cx: &LateContext<'_>, kind: &'tcx FnKind<'_>, body: &'tcx Body<'_>, hir_id: HirId) {
-    if cx.tcx.visibility(cx.tcx.hir().body_owner_def_id(body.id())).is_public() && !is_in_test_function(cx.tcx, hir_id)
-    {
-        if let FnKind::ItemFn(ident, generics, _) = kind {
-            for param in generics.params {
-                if param.is_impl_trait()
-                    && !param.name.ident().as_str().contains('<')
-                    && !param.name.ident().as_str().contains('(')
-                {
-                    // No generics with nested generics, and no generics like FnMut(x)
-                    span_lint_and_then(
-                        cx,
-                        IMPL_TRAIT_PARAM,
-                        param.span,
-                        &format!("'{}' in the function's parameters", param.name.ident().as_str()),
-                        |diag| {
-                            let next_letter = next_valid_letter(generics);
-                            if let Some(gen_span) = generics.span_for_param_suggestion() {
-                                diag.span_suggestion_with_style(
-                                    gen_span,
-                                    format!(
-                                        "create a generic type here and replace that `{}` with `{}`",
-                                        param.name.ident().as_str(),
-                                        next_letter
-                                    ),
-                                    ", T: Trait",
-                                    rustc_errors::Applicability::MaybeIncorrect,
-                                    rustc_errors::SuggestionStyle::ShowAlways,
-                                );
-                            } else {
-                                // multispan.push_span_label(param.span, format!("Replace this with `{}`",
-                                // next_letter));
-
-                                diag.span_suggestion_with_style(
-                                    Span::new(
-                                        body.params[0].span.lo() - rustc_span::BytePos(1),
-                                        ident.span.hi(),
-                                        ident.span.ctxt(),
-                                        ident.span.parent(),
-                                    ),
-                                    format!(
-                                        "create a generic type here and replace that '{}' with `{}`",
-                                        param.name.ident().as_str(),
-                                        next_letter
-                                    ),
-                                    "<T: Trait>",
-                                    rustc_errors::Applicability::MaybeIncorrect,
-                                    rustc_errors::SuggestionStyle::ShowAlways,
-                                );
-                            }
-                        },
-                    );
-                }
-            }
-        }
-    }
-}
-
-fn next_valid_letter(generics: &Generics<'_>) -> char {
-    let mut generics_names = Vec::new();
-
-    generics.params.iter().for_each(|param| {
-        generics_names.push(param.name.ident().as_str().to_owned());
-    });
-
-    // If T exists, try with U, then with V, and so on...
-    let mut current_letter = 84u32; // ASCII code for "T"
-    while generics_names.contains(&String::from(char::from_u32(current_letter).unwrap())) {
-        current_letter += 1;
-        if current_letter == 91 {
-            // ASCII code for "Z"
-            current_letter = 65;
-        } else if current_letter == 83 {
-            // ASCII "S"
-            current_letter = 97; // "a"
-        };
-    }
-
-    char::from_u32(current_letter).unwrap()
-}
diff --git a/clippy_lints/src/functions/mod.rs b/clippy_lints/src/functions/mod.rs
index cd0df1438df..81b7bfe7181 100644
--- a/clippy_lints/src/functions/mod.rs
+++ b/clippy_lints/src/functions/mod.rs
@@ -1,4 +1,4 @@
-mod impl_trait_param;
+mod impl_trait_in_params;
 mod misnamed_getters;
 mod must_use;
 mod not_unsafe_ptr_arg_deref;
@@ -349,7 +349,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     #[clippy::version = "1.68.0"]
-    pub IMPL_TRAIT_PARAM,
+    pub IMPL_TRAIT_IN_PARAMS,
     style,
     "`impl Trait` is used in the function's parameters"
 }
@@ -381,7 +381,7 @@ impl_lint_pass!(Functions => [
     RESULT_UNIT_ERR,
     RESULT_LARGE_ERR,
     MISNAMED_GETTERS,
-    IMPL_TRAIT_PARAM,
+    IMPL_TRAIT_IN_PARAMS,
 ]);
 
 impl<'tcx> LateLintPass<'tcx> for Functions {
@@ -399,7 +399,7 @@ impl<'tcx> LateLintPass<'tcx> for Functions {
         too_many_lines::check_fn(cx, kind, span, body, self.too_many_lines_threshold);
         not_unsafe_ptr_arg_deref::check_fn(cx, kind, decl, body, def_id);
         misnamed_getters::check_fn(cx, kind, decl, body, span);
-        impl_trait_param::check_fn(cx, &kind, body, hir_id);
+        impl_trait_in_params::check_fn(cx, &kind, body, hir_id);
     }
 
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) {
diff --git a/clippy_utils/src/ast_utils.rs b/clippy_utils/src/ast_utils.rs
index 62089320ce3..65d287d493b 100644
--- a/clippy_utils/src/ast_utils.rs
+++ b/clippy_utils/src/ast_utils.rs
@@ -6,7 +6,7 @@
     clippy::similar_names,
     clippy::wildcard_imports,
     clippy::enum_glob_use,
-    clippy::impl_trait_param
+    clippy::impl_trait_in_params
 )]
 
 use crate::{both, over};
diff --git a/clippy_utils/src/check_proc_macro.rs b/clippy_utils/src/check_proc_macro.rs
index 8650f3c6828..353926074b5 100644
--- a/clippy_utils/src/check_proc_macro.rs
+++ b/clippy_utils/src/check_proc_macro.rs
@@ -1,4 +1,4 @@
-#![allow(clippy::impl_trait_param)]
+#![allow(clippy::impl_trait_in_params)]
 //! This module handles checking if the span given is from a proc-macro or not.
 //!
 //! Proc-macros are capable of setting the span of every token they output to a few possible spans.
diff --git a/clippy_utils/src/hir_utils.rs b/clippy_utils/src/hir_utils.rs
index 2cd213ed705..115d8aafaf7 100644
--- a/clippy_utils/src/hir_utils.rs
+++ b/clippy_utils/src/hir_utils.rs
@@ -1,4 +1,4 @@
-#![allow(clippy::impl_trait_param)]
+#![allow(clippy::impl_trait_in_params)]
 use crate::consts::constant_simple;
 use crate::macros::macro_backtrace;
 use crate::source::snippet_opt;
diff --git a/clippy_utils/src/macros.rs b/clippy_utils/src/macros.rs
index a85d11f6234..cac29ac9c01 100644
--- a/clippy_utils/src/macros.rs
+++ b/clippy_utils/src/macros.rs
@@ -1,4 +1,4 @@
-#![allow(clippy::similar_names, clippy::impl_trait_param)] // `expr` and `expn`
+#![allow(clippy::similar_names, clippy::impl_trait_in_params)] // `expr` and `expn`
 
 use crate::source::snippet_opt;
 use crate::visitors::{for_each_expr, Descend};
diff --git a/clippy_utils/src/source.rs b/clippy_utils/src/source.rs
index 39d00e89551..e802941b5d8 100644
--- a/clippy_utils/src/source.rs
+++ b/clippy_utils/src/source.rs
@@ -1,6 +1,6 @@
 //! Utils for extracting, inspecting or transforming source code
 
-#![allow(clippy::module_name_repetitions, clippy::impl_trait_param)]
+#![allow(clippy::module_name_repetitions, clippy::impl_trait_in_params)]
 
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
diff --git a/tests/ui/borrow_box.rs b/tests/ui/borrow_box.rs
index e3e5b8464b7..3dfd8191adf 100644
--- a/tests/ui/borrow_box.rs
+++ b/tests/ui/borrow_box.rs
@@ -1,6 +1,6 @@
 #![deny(clippy::borrowed_box)]
 #![allow(dead_code, unused_variables)]
-#![allow(clippy::uninlined_format_args, clippy::disallowed_names, clippy::impl_trait_param)]
+#![allow(clippy::uninlined_format_args, clippy::disallowed_names, clippy::impl_trait_in_params)]
 
 use std::fmt::Display;
 
diff --git a/tests/ui/eta.fixed b/tests/ui/eta.fixed
index 8c19143cb2e..c1ad0b66e01 100644
--- a/tests/ui/eta.fixed
+++ b/tests/ui/eta.fixed
@@ -8,7 +8,7 @@
     clippy::option_map_unit_fn,
     clippy::redundant_closure_call,
     clippy::uninlined_format_args,
-    clippy::impl_trait_param
+    clippy::impl_trait_in_params
 )]
 
 use std::path::{Path, PathBuf};
diff --git a/tests/ui/eta.rs b/tests/ui/eta.rs
index 10d4924c599..000af653c15 100644
--- a/tests/ui/eta.rs
+++ b/tests/ui/eta.rs
@@ -8,7 +8,7 @@
     clippy::option_map_unit_fn,
     clippy::redundant_closure_call,
     clippy::uninlined_format_args,
-    clippy::impl_trait_param
+    clippy::impl_trait_in_params
 )]
 
 use std::path::{Path, PathBuf};
diff --git a/tests/ui/impl_trait_in_params.rs b/tests/ui/impl_trait_in_params.rs
new file mode 100644
index 00000000000..8402730d310
--- /dev/null
+++ b/tests/ui/impl_trait_in_params.rs
@@ -0,0 +1,15 @@
+#![allow(unused)]
+#![warn(clippy::impl_trait_in_params)]
+
+pub trait Trait {}
+
+// Should warn
+pub fn a(_: impl Trait) {}
+pub fn c<C: Trait>(_: C, _: impl Trait) {}
+
+// Shouldn't warn
+
+pub fn b<B: Trait>(_: B) {}
+fn d<D: Trait>(_: D, _: impl Trait) {}
+
+fn main() {}
diff --git a/tests/ui/impl_trait_in_params.stderr b/tests/ui/impl_trait_in_params.stderr
new file mode 100644
index 00000000000..55dec5d0d99
--- /dev/null
+++ b/tests/ui/impl_trait_in_params.stderr
@@ -0,0 +1,25 @@
+error: 'impl Trait' in the function's parameters
+  --> $DIR/impl_trait_param.rs:7:13
+   |
+LL | pub fn a(_: impl Trait) {}
+   |             ^^^^^^^^^^
+   |
+   = note: `-D clippy::impl-trait-param` implied by `-D warnings`
+help: create a generic type here and replace that 'impl Trait' with `T`
+   |
+LL | pub fn a<T: Trait>(_: impl Trait) {}
+   |         ++++++++++
+
+error: 'impl Trait' in the function's parameters
+  --> $DIR/impl_trait_param.rs:8:29
+   |
+LL | pub fn c<C: Trait>(_: C, _: impl Trait) {}
+   |                             ^^^^^^^^^^
+   |
+help: create a generic type here and replace that `impl Trait` with `T`
+   |
+LL | pub fn c<C: Trait, T: Trait>(_: C, _: impl Trait) {}
+   |                  ++++++++++
+
+error: aborting due to 2 previous errors
+
diff --git a/tests/ui/impl_trait_param.rs b/tests/ui/impl_trait_param.rs
deleted file mode 100644
index 3bb9cdbaa09..00000000000
--- a/tests/ui/impl_trait_param.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-#![allow(unused)]
-#![warn(clippy::impl_trait_param)]
-
-pub trait Trait {}
-
-// Should warn
-pub fn a(_: impl Trait) {}
-pub fn c<C: Trait>(_: C, _: impl Trait) {}
-
-// Shouldn't warn
-
-pub fn b<B: Trait>(_: B) {}
-fn d<D: Trait>(_: D, _: impl Trait) {}
-
-fn main() {}
diff --git a/tests/ui/impl_trait_param.stderr b/tests/ui/impl_trait_param.stderr
deleted file mode 100644
index 55dec5d0d99..00000000000
--- a/tests/ui/impl_trait_param.stderr
+++ /dev/null
@@ -1,25 +0,0 @@
-error: 'impl Trait' in the function's parameters
-  --> $DIR/impl_trait_param.rs:7:13
-   |
-LL | pub fn a(_: impl Trait) {}
-   |             ^^^^^^^^^^
-   |
-   = note: `-D clippy::impl-trait-param` implied by `-D warnings`
-help: create a generic type here and replace that 'impl Trait' with `T`
-   |
-LL | pub fn a<T: Trait>(_: impl Trait) {}
-   |         ++++++++++
-
-error: 'impl Trait' in the function's parameters
-  --> $DIR/impl_trait_param.rs:8:29
-   |
-LL | pub fn c<C: Trait>(_: C, _: impl Trait) {}
-   |                             ^^^^^^^^^^
-   |
-help: create a generic type here and replace that `impl Trait` with `T`
-   |
-LL | pub fn c<C: Trait, T: Trait>(_: C, _: impl Trait) {}
-   |                  ++++++++++
-
-error: aborting due to 2 previous errors
-
diff --git a/tests/ui/trait_duplication_in_bounds.fixed b/tests/ui/trait_duplication_in_bounds.fixed
index a587cc8b456..373859a2564 100644
--- a/tests/ui/trait_duplication_in_bounds.fixed
+++ b/tests/ui/trait_duplication_in_bounds.fixed
@@ -1,6 +1,6 @@
 // run-rustfix
 #![deny(clippy::trait_duplication_in_bounds)]
-#![allow(clippy::impl_trait_param)]
+#![allow(clippy::impl_trait_in_params)]
 #![allow(unused)]
 
 fn bad_foo<T: Clone + Copy, U: Clone + Copy>(arg0: T, argo1: U) {
diff --git a/tests/ui/trait_duplication_in_bounds.rs b/tests/ui/trait_duplication_in_bounds.rs
index beb41ea26d9..3afd74aa9b2 100644
--- a/tests/ui/trait_duplication_in_bounds.rs
+++ b/tests/ui/trait_duplication_in_bounds.rs
@@ -1,6 +1,6 @@
 // run-rustfix
 #![deny(clippy::trait_duplication_in_bounds)]
-#![allow(clippy::impl_trait_param)]
+#![allow(clippy::impl_trait_in_params)]
 #![allow(unused)]
 
 fn bad_foo<T: Clone + Clone + Clone + Copy, U: Clone + Copy>(arg0: T, argo1: U) {
diff --git a/tests/ui/trait_duplication_in_bounds_unfixable.rs b/tests/ui/trait_duplication_in_bounds_unfixable.rs
index 63ae4493143..7435a4ba609 100644
--- a/tests/ui/trait_duplication_in_bounds_unfixable.rs
+++ b/tests/ui/trait_duplication_in_bounds_unfixable.rs
@@ -1,5 +1,5 @@
 #![deny(clippy::trait_duplication_in_bounds)]
-#![allow(clippy::impl_trait_param)]
+#![allow(clippy::impl_trait_in_params)]
 
 use std::collections::BTreeMap;
 use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Sub, SubAssign};
-- 
cgit 1.4.1-3-g733a5


From bdf4fd3e82542cea1f9104cef7bd82839ed84213 Mon Sep 17 00:00:00 2001
From: blyxyas <blyxyas@gmail.com>
Date: Fri, 13 Jan 2023 12:54:51 +0100
Subject: Tests pass

---
 clippy_lints/src/functions/mod.rs    |  2 +-
 tests/ui/borrow_box.stderr           | 20 ++++++++++----------
 tests/ui/impl_trait_in_params.rs     |  4 +++-
 tests/ui/impl_trait_in_params.stderr |  6 +++---
 4 files changed, 17 insertions(+), 15 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/functions/mod.rs b/clippy_lints/src/functions/mod.rs
index 81b7bfe7181..e7f22f8d778 100644
--- a/clippy_lints/src/functions/mod.rs
+++ b/clippy_lints/src/functions/mod.rs
@@ -344,7 +344,7 @@ declare_clippy_lint! {
     /// Use instead:
     /// ```rust
     /// trait MyTrait {}
-    /// fn foo<T: A>(a: A) {
+    /// fn foo<T: MyTrait>(a: T) {
     /// 	// [...]
     /// }
     /// ```
diff --git a/tests/ui/borrow_box.stderr b/tests/ui/borrow_box.stderr
index 99cb60a1ead..90e752211ff 100644
--- a/tests/ui/borrow_box.stderr
+++ b/tests/ui/borrow_box.stderr
@@ -1,5 +1,5 @@
 error: you seem to be trying to use `&Box<T>`. Consider using just `&T`
-  --> $DIR/borrow_box.rs:20:14
+  --> $DIR/borrow_box.rs:24:14
    |
 LL |     let foo: &Box<bool>;
    |              ^^^^^^^^^^ help: try: `&bool`
@@ -11,55 +11,55 @@ LL | #![deny(clippy::borrowed_box)]
    |         ^^^^^^^^^^^^^^^^^^^^
 
 error: you seem to be trying to use `&Box<T>`. Consider using just `&T`
-  --> $DIR/borrow_box.rs:24:10
+  --> $DIR/borrow_box.rs:28:10
    |
 LL |     foo: &'a Box<bool>,
    |          ^^^^^^^^^^^^^ help: try: `&'a bool`
 
 error: you seem to be trying to use `&Box<T>`. Consider using just `&T`
-  --> $DIR/borrow_box.rs:28:17
+  --> $DIR/borrow_box.rs:32:17
    |
 LL |     fn test4(a: &Box<bool>);
    |                 ^^^^^^^^^^ help: try: `&bool`
 
 error: you seem to be trying to use `&Box<T>`. Consider using just `&T`
-  --> $DIR/borrow_box.rs:94:25
+  --> $DIR/borrow_box.rs:98:25
    |
 LL | pub fn test14(_display: &Box<dyn Display>) {}
    |                         ^^^^^^^^^^^^^^^^^ help: try: `&dyn Display`
 
 error: you seem to be trying to use `&Box<T>`. Consider using just `&T`
-  --> $DIR/borrow_box.rs:95:25
+  --> $DIR/borrow_box.rs:99:25
    |
 LL | pub fn test15(_display: &Box<dyn Display + Send>) {}
    |                         ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&(dyn Display + Send)`
 
 error: you seem to be trying to use `&Box<T>`. Consider using just `&T`
-  --> $DIR/borrow_box.rs:96:29
+  --> $DIR/borrow_box.rs:100:29
    |
 LL | pub fn test16<'a>(_display: &'a Box<dyn Display + 'a>) {}
    |                             ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&'a (dyn Display + 'a)`
 
 error: you seem to be trying to use `&Box<T>`. Consider using just `&T`
-  --> $DIR/borrow_box.rs:98:25
+  --> $DIR/borrow_box.rs:102:25
    |
 LL | pub fn test17(_display: &Box<impl Display>) {}
    |                         ^^^^^^^^^^^^^^^^^^ help: try: `&impl Display`
 
 error: you seem to be trying to use `&Box<T>`. Consider using just `&T`
-  --> $DIR/borrow_box.rs:99:25
+  --> $DIR/borrow_box.rs:103:25
    |
 LL | pub fn test18(_display: &Box<impl Display + Send>) {}
    |                         ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&(impl Display + Send)`
 
 error: you seem to be trying to use `&Box<T>`. Consider using just `&T`
-  --> $DIR/borrow_box.rs:100:29
+  --> $DIR/borrow_box.rs:104:29
    |
 LL | pub fn test19<'a>(_display: &'a Box<impl Display + 'a>) {}
    |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&'a (impl Display + 'a)`
 
 error: you seem to be trying to use `&Box<T>`. Consider using just `&T`
-  --> $DIR/borrow_box.rs:105:25
+  --> $DIR/borrow_box.rs:109:25
    |
 LL | pub fn test20(_display: &Box<(dyn Display + Send)>) {}
    |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&(dyn Display + Send)`
diff --git a/tests/ui/impl_trait_in_params.rs b/tests/ui/impl_trait_in_params.rs
index 8402730d310..07560101a41 100644
--- a/tests/ui/impl_trait_in_params.rs
+++ b/tests/ui/impl_trait_in_params.rs
@@ -2,14 +2,16 @@
 #![warn(clippy::impl_trait_in_params)]
 
 pub trait Trait {}
+pub trait AnotherTrait<T> {}
 
 // Should warn
 pub fn a(_: impl Trait) {}
 pub fn c<C: Trait>(_: C, _: impl Trait) {}
+fn d(_: impl AnotherTrait<u32>) {}
 
 // Shouldn't warn
 
 pub fn b<B: Trait>(_: B) {}
-fn d<D: Trait>(_: D, _: impl Trait) {}
+fn e<T: AnotherTrait<u32>>(_: T) {}
 
 fn main() {}
diff --git a/tests/ui/impl_trait_in_params.stderr b/tests/ui/impl_trait_in_params.stderr
index 55dec5d0d99..a43986017fe 100644
--- a/tests/ui/impl_trait_in_params.stderr
+++ b/tests/ui/impl_trait_in_params.stderr
@@ -1,17 +1,17 @@
 error: 'impl Trait' in the function's parameters
-  --> $DIR/impl_trait_param.rs:7:13
+  --> $DIR/impl_trait_in_params.rs:8:13
    |
 LL | pub fn a(_: impl Trait) {}
    |             ^^^^^^^^^^
    |
-   = note: `-D clippy::impl-trait-param` implied by `-D warnings`
+   = note: `-D clippy::impl-trait-in-params` implied by `-D warnings`
 help: create a generic type here and replace that 'impl Trait' with `T`
    |
 LL | pub fn a<T: Trait>(_: impl Trait) {}
    |         ++++++++++
 
 error: 'impl Trait' in the function's parameters
-  --> $DIR/impl_trait_param.rs:8:29
+  --> $DIR/impl_trait_in_params.rs:9:29
    |
 LL | pub fn c<C: Trait>(_: C, _: impl Trait) {}
    |                             ^^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From 8a2245dcb6ccf8d9491d6fdc7681a4f34739093c Mon Sep 17 00:00:00 2001
From: blyxyas <blyxyas@gmail.com>
Date: Fri, 13 Jan 2023 19:41:06 +0100
Subject: Change lint's from `style` to `restriction`

---
 clippy_lints/src/functions/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/functions/mod.rs b/clippy_lints/src/functions/mod.rs
index e7f22f8d778..d2852b4acad 100644
--- a/clippy_lints/src/functions/mod.rs
+++ b/clippy_lints/src/functions/mod.rs
@@ -350,7 +350,7 @@ declare_clippy_lint! {
     /// ```
     #[clippy::version = "1.68.0"]
     pub IMPL_TRAIT_IN_PARAMS,
-    style,
+    restriction,
     "`impl Trait` is used in the function's parameters"
 }
 
-- 
cgit 1.4.1-3-g733a5


From 6aa06b757dde06b43c198d352c51e1eef82bbb1c Mon Sep 17 00:00:00 2001
From: blyxyas <blyxyas@gmail.com>
Date: Thu, 19 Jan 2023 16:24:47 +0100
Subject: Remove `#[allow]`s. Apply conversations from @Jarcho

---
 clippy_lints/src/functions/impl_trait_in_params.rs | 23 +++-------
 clippy_utils/src/ast_utils.rs                      |  7 +--
 clippy_utils/src/check_proc_macro.rs               |  1 -
 clippy_utils/src/hir_utils.rs                      |  1 -
 clippy_utils/src/macros.rs                         |  2 +-
 clippy_utils/src/source.rs                         |  2 +-
 tests/ui/borrow_box.rs                             |  6 +--
 tests/ui/borrow_box.stderr                         | 20 ++++-----
 tests/ui/eta.fixed                                 |  3 +-
 tests/ui/eta.rs                                    |  3 +-
 tests/ui/eta.stderr                                | 52 +++++++++++-----------
 tests/ui/impl_trait_in_params.stderr               |  8 ++--
 tests/ui/trait_duplication_in_bounds.fixed         |  1 -
 tests/ui/trait_duplication_in_bounds.rs            |  1 -
 tests/ui/trait_duplication_in_bounds.stderr        | 16 +++----
 tests/ui/trait_duplication_in_bounds_unfixable.rs  |  1 -
 .../trait_duplication_in_bounds_unfixable.stderr   | 16 +++----
 17 files changed, 68 insertions(+), 95 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/functions/impl_trait_in_params.rs b/clippy_lints/src/functions/impl_trait_in_params.rs
index f0bfbbf1ea3..ace5932f4e4 100644
--- a/clippy_lints/src/functions/impl_trait_in_params.rs
+++ b/clippy_lints/src/functions/impl_trait_in_params.rs
@@ -11,27 +11,20 @@ pub(super) fn check_fn<'tcx>(cx: &LateContext<'_>, kind: &'tcx FnKind<'_>, body:
     {
         if let FnKind::ItemFn(ident, generics, _) = kind {
             for param in generics.params {
-                if param.is_impl_trait()
-                    && !param.name.ident().as_str().contains('<')
-                    && !param.name.ident().as_str().contains('(')
-                {
+                if param.is_impl_trait() {
                     // No generics with nested generics, and no generics like FnMut(x)
                     span_lint_and_then(
                         cx,
                         IMPL_TRAIT_IN_PARAMS,
                         param.span,
-                        &format!("'{}' in the function's parameters", param.name.ident().as_str()),
+                        "'`impl Trait` used as a function parameter'",
                         |diag| {
                             let next_letter = next_valid_letter(generics);
                             if let Some(gen_span) = generics.span_for_param_suggestion() {
                                 diag.span_suggestion_with_style(
                                     gen_span,
-                                    format!(
-                                        "create a generic type here and replace that `{}` with `{}`",
-                                        param.name.ident().as_str(),
-                                        next_letter
-                                    ),
-                                    ", T: Trait",
+                                    "add a type paremeter, `{}`: `{}`",
+                                    format!(", {next_letter}: {}", &param.name.ident().as_str()[5..]),
                                     rustc_errors::Applicability::MaybeIncorrect,
                                     rustc_errors::SuggestionStyle::ShowAlways,
                                 );
@@ -46,12 +39,8 @@ pub(super) fn check_fn<'tcx>(cx: &LateContext<'_>, kind: &'tcx FnKind<'_>, body:
                                         ident.span.ctxt(),
                                         ident.span.parent(),
                                     ),
-                                    format!(
-                                        "create a generic type here and replace that '{}' with `{}`",
-                                        param.name.ident().as_str(),
-                                        next_letter
-                                    ),
-                                    "<T: Trait>",
+                                    "add a type paremeter",
+                                    format!("<{next_letter}: {}>", &param.name.ident().as_str()[5..]),
                                     rustc_errors::Applicability::MaybeIncorrect,
                                     rustc_errors::SuggestionStyle::ShowAlways,
                                 );
diff --git a/clippy_utils/src/ast_utils.rs b/clippy_utils/src/ast_utils.rs
index 65d287d493b..9d0263e93be 100644
--- a/clippy_utils/src/ast_utils.rs
+++ b/clippy_utils/src/ast_utils.rs
@@ -2,12 +2,7 @@
 //!
 //! - The `eq_foobar` functions test for semantic equality but ignores `NodeId`s and `Span`s.
 
-#![allow(
-    clippy::similar_names,
-    clippy::wildcard_imports,
-    clippy::enum_glob_use,
-    clippy::impl_trait_in_params
-)]
+#![allow(clippy::similar_names, clippy::wildcard_imports, clippy::enum_glob_use)]
 
 use crate::{both, over};
 use rustc_ast::ptr::P;
diff --git a/clippy_utils/src/check_proc_macro.rs b/clippy_utils/src/check_proc_macro.rs
index 353926074b5..43f0df145f0 100644
--- a/clippy_utils/src/check_proc_macro.rs
+++ b/clippy_utils/src/check_proc_macro.rs
@@ -1,4 +1,3 @@
-#![allow(clippy::impl_trait_in_params)]
 //! This module handles checking if the span given is from a proc-macro or not.
 //!
 //! Proc-macros are capable of setting the span of every token they output to a few possible spans.
diff --git a/clippy_utils/src/hir_utils.rs b/clippy_utils/src/hir_utils.rs
index 115d8aafaf7..2bbe1a19b62 100644
--- a/clippy_utils/src/hir_utils.rs
+++ b/clippy_utils/src/hir_utils.rs
@@ -1,4 +1,3 @@
-#![allow(clippy::impl_trait_in_params)]
 use crate::consts::constant_simple;
 use crate::macros::macro_backtrace;
 use crate::source::snippet_opt;
diff --git a/clippy_utils/src/macros.rs b/clippy_utils/src/macros.rs
index cac29ac9c01..63dccbf697c 100644
--- a/clippy_utils/src/macros.rs
+++ b/clippy_utils/src/macros.rs
@@ -1,4 +1,4 @@
-#![allow(clippy::similar_names, clippy::impl_trait_in_params)] // `expr` and `expn`
+#![allow(clippy::similar_names)] // `expr` and `expn`
 
 use crate::source::snippet_opt;
 use crate::visitors::{for_each_expr, Descend};
diff --git a/clippy_utils/src/source.rs b/clippy_utils/src/source.rs
index e802941b5d8..cd5dcfdaca3 100644
--- a/clippy_utils/src/source.rs
+++ b/clippy_utils/src/source.rs
@@ -1,6 +1,6 @@
 //! Utils for extracting, inspecting or transforming source code
 
-#![allow(clippy::module_name_repetitions, clippy::impl_trait_in_params)]
+#![allow(clippy::module_name_repetitions)]
 
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
diff --git a/tests/ui/borrow_box.rs b/tests/ui/borrow_box.rs
index 8fe160e8e0f..3b5b6bf4c95 100644
--- a/tests/ui/borrow_box.rs
+++ b/tests/ui/borrow_box.rs
@@ -1,10 +1,6 @@
 #![deny(clippy::borrowed_box)]
 #![allow(dead_code, unused_variables)]
-#![allow(
-    clippy::uninlined_format_args,
-    clippy::disallowed_names,
-    clippy::impl_trait_in_params
-)]
+#![allow(clippy::uninlined_format_args, clippy::disallowed_names)]
 
 use std::fmt::Display;
 
diff --git a/tests/ui/borrow_box.stderr b/tests/ui/borrow_box.stderr
index 90e752211ff..99cb60a1ead 100644
--- a/tests/ui/borrow_box.stderr
+++ b/tests/ui/borrow_box.stderr
@@ -1,5 +1,5 @@
 error: you seem to be trying to use `&Box<T>`. Consider using just `&T`
-  --> $DIR/borrow_box.rs:24:14
+  --> $DIR/borrow_box.rs:20:14
    |
 LL |     let foo: &Box<bool>;
    |              ^^^^^^^^^^ help: try: `&bool`
@@ -11,55 +11,55 @@ LL | #![deny(clippy::borrowed_box)]
    |         ^^^^^^^^^^^^^^^^^^^^
 
 error: you seem to be trying to use `&Box<T>`. Consider using just `&T`
-  --> $DIR/borrow_box.rs:28:10
+  --> $DIR/borrow_box.rs:24:10
    |
 LL |     foo: &'a Box<bool>,
    |          ^^^^^^^^^^^^^ help: try: `&'a bool`
 
 error: you seem to be trying to use `&Box<T>`. Consider using just `&T`
-  --> $DIR/borrow_box.rs:32:17
+  --> $DIR/borrow_box.rs:28:17
    |
 LL |     fn test4(a: &Box<bool>);
    |                 ^^^^^^^^^^ help: try: `&bool`
 
 error: you seem to be trying to use `&Box<T>`. Consider using just `&T`
-  --> $DIR/borrow_box.rs:98:25
+  --> $DIR/borrow_box.rs:94:25
    |
 LL | pub fn test14(_display: &Box<dyn Display>) {}
    |                         ^^^^^^^^^^^^^^^^^ help: try: `&dyn Display`
 
 error: you seem to be trying to use `&Box<T>`. Consider using just `&T`
-  --> $DIR/borrow_box.rs:99:25
+  --> $DIR/borrow_box.rs:95:25
    |
 LL | pub fn test15(_display: &Box<dyn Display + Send>) {}
    |                         ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&(dyn Display + Send)`
 
 error: you seem to be trying to use `&Box<T>`. Consider using just `&T`
-  --> $DIR/borrow_box.rs:100:29
+  --> $DIR/borrow_box.rs:96:29
    |
 LL | pub fn test16<'a>(_display: &'a Box<dyn Display + 'a>) {}
    |                             ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&'a (dyn Display + 'a)`
 
 error: you seem to be trying to use `&Box<T>`. Consider using just `&T`
-  --> $DIR/borrow_box.rs:102:25
+  --> $DIR/borrow_box.rs:98:25
    |
 LL | pub fn test17(_display: &Box<impl Display>) {}
    |                         ^^^^^^^^^^^^^^^^^^ help: try: `&impl Display`
 
 error: you seem to be trying to use `&Box<T>`. Consider using just `&T`
-  --> $DIR/borrow_box.rs:103:25
+  --> $DIR/borrow_box.rs:99:25
    |
 LL | pub fn test18(_display: &Box<impl Display + Send>) {}
    |                         ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&(impl Display + Send)`
 
 error: you seem to be trying to use `&Box<T>`. Consider using just `&T`
-  --> $DIR/borrow_box.rs:104:29
+  --> $DIR/borrow_box.rs:100:29
    |
 LL | pub fn test19<'a>(_display: &'a Box<impl Display + 'a>) {}
    |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&'a (impl Display + 'a)`
 
 error: you seem to be trying to use `&Box<T>`. Consider using just `&T`
-  --> $DIR/borrow_box.rs:109:25
+  --> $DIR/borrow_box.rs:105:25
    |
 LL | pub fn test20(_display: &Box<(dyn Display + Send)>) {}
    |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&(dyn Display + Send)`
diff --git a/tests/ui/eta.fixed b/tests/ui/eta.fixed
index c1ad0b66e01..dc129591eac 100644
--- a/tests/ui/eta.fixed
+++ b/tests/ui/eta.fixed
@@ -7,8 +7,7 @@
     clippy::no_effect,
     clippy::option_map_unit_fn,
     clippy::redundant_closure_call,
-    clippy::uninlined_format_args,
-    clippy::impl_trait_in_params
+    clippy::uninlined_format_args
 )]
 
 use std::path::{Path, PathBuf};
diff --git a/tests/ui/eta.rs b/tests/ui/eta.rs
index 000af653c15..025fd6a0b7a 100644
--- a/tests/ui/eta.rs
+++ b/tests/ui/eta.rs
@@ -7,8 +7,7 @@
     clippy::no_effect,
     clippy::option_map_unit_fn,
     clippy::redundant_closure_call,
-    clippy::uninlined_format_args,
-    clippy::impl_trait_in_params
+    clippy::uninlined_format_args
 )]
 
 use std::path::{Path, PathBuf};
diff --git a/tests/ui/eta.stderr b/tests/ui/eta.stderr
index 6ddecc58eaf..a521fb86860 100644
--- a/tests/ui/eta.stderr
+++ b/tests/ui/eta.stderr
@@ -1,5 +1,5 @@
 error: redundant closure
-  --> $DIR/eta.rs:29:27
+  --> $DIR/eta.rs:28:27
    |
 LL |     let a = Some(1u8).map(|a| foo(a));
    |                           ^^^^^^^^^^ help: replace the closure with the function itself: `foo`
@@ -7,31 +7,31 @@ LL |     let a = Some(1u8).map(|a| foo(a));
    = note: `-D clippy::redundant-closure` implied by `-D warnings`
 
 error: redundant closure
-  --> $DIR/eta.rs:33:40
+  --> $DIR/eta.rs:32:40
    |
 LL |     let _: Option<Vec<u8>> = true.then(|| vec![]); // special case vec!
    |                                        ^^^^^^^^^ help: replace the closure with `Vec::new`: `std::vec::Vec::new`
 
 error: redundant closure
-  --> $DIR/eta.rs:34:35
+  --> $DIR/eta.rs:33:35
    |
 LL |     let d = Some(1u8).map(|a| foo((|b| foo2(b))(a))); //is adjusted?
    |                                   ^^^^^^^^^^^^^ help: replace the closure with the function itself: `foo2`
 
 error: redundant closure
-  --> $DIR/eta.rs:35:26
+  --> $DIR/eta.rs:34:26
    |
 LL |     all(&[1, 2, 3], &&2, |x, y| below(x, y)); //is adjusted
    |                          ^^^^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `below`
 
 error: redundant closure
-  --> $DIR/eta.rs:42:27
+  --> $DIR/eta.rs:41:27
    |
 LL |     let e = Some(1u8).map(|a| generic(a));
    |                           ^^^^^^^^^^^^^^ help: replace the closure with the function itself: `generic`
 
 error: redundant closure
-  --> $DIR/eta.rs:88:51
+  --> $DIR/eta.rs:87:51
    |
 LL |     let e = Some(TestStruct { some_ref: &i }).map(|a| a.foo());
    |                                                   ^^^^^^^^^^^ help: replace the closure with the method itself: `TestStruct::foo`
@@ -39,121 +39,121 @@ LL |     let e = Some(TestStruct { some_ref: &i }).map(|a| a.foo());
    = note: `-D clippy::redundant-closure-for-method-calls` implied by `-D warnings`
 
 error: redundant closure
-  --> $DIR/eta.rs:89:51
+  --> $DIR/eta.rs:88:51
    |
 LL |     let e = Some(TestStruct { some_ref: &i }).map(|a| a.trait_foo());
    |                                                   ^^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `TestTrait::trait_foo`
 
 error: redundant closure
-  --> $DIR/eta.rs:91:42
+  --> $DIR/eta.rs:90:42
    |
 LL |     let e = Some(&mut vec![1, 2, 3]).map(|v| v.clear());
    |                                          ^^^^^^^^^^^^^ help: replace the closure with the method itself: `std::vec::Vec::clear`
 
 error: redundant closure
-  --> $DIR/eta.rs:95:29
+  --> $DIR/eta.rs:94:29
    |
 LL |     let e = Some("str").map(|s| s.to_string());
    |                             ^^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `std::string::ToString::to_string`
 
 error: redundant closure
-  --> $DIR/eta.rs:96:27
+  --> $DIR/eta.rs:95:27
    |
 LL |     let e = Some('a').map(|s| s.to_uppercase());
    |                           ^^^^^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `char::to_uppercase`
 
 error: redundant closure
-  --> $DIR/eta.rs:98:65
+  --> $DIR/eta.rs:97:65
    |
 LL |     let e: std::vec::Vec<char> = vec!['a', 'b', 'c'].iter().map(|c| c.to_ascii_uppercase()).collect();
    |                                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `char::to_ascii_uppercase`
 
 error: redundant closure
-  --> $DIR/eta.rs:161:22
+  --> $DIR/eta.rs:160:22
    |
 LL |     requires_fn_once(|| x());
    |                      ^^^^^^ help: replace the closure with the function itself: `x`
 
 error: redundant closure
-  --> $DIR/eta.rs:168:27
+  --> $DIR/eta.rs:167:27
    |
 LL |     let a = Some(1u8).map(|a| foo_ptr(a));
    |                           ^^^^^^^^^^^^^^ help: replace the closure with the function itself: `foo_ptr`
 
 error: redundant closure
-  --> $DIR/eta.rs:173:27
+  --> $DIR/eta.rs:172:27
    |
 LL |     let a = Some(1u8).map(|a| closure(a));
    |                           ^^^^^^^^^^^^^^ help: replace the closure with the function itself: `closure`
 
 error: redundant closure
-  --> $DIR/eta.rs:205:28
+  --> $DIR/eta.rs:204:28
    |
 LL |     x.into_iter().for_each(|x| add_to_res(x));
    |                            ^^^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `&mut add_to_res`
 
 error: redundant closure
-  --> $DIR/eta.rs:206:28
+  --> $DIR/eta.rs:205:28
    |
 LL |     y.into_iter().for_each(|x| add_to_res(x));
    |                            ^^^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `&mut add_to_res`
 
 error: redundant closure
-  --> $DIR/eta.rs:207:28
+  --> $DIR/eta.rs:206:28
    |
 LL |     z.into_iter().for_each(|x| add_to_res(x));
    |                            ^^^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `add_to_res`
 
 error: redundant closure
-  --> $DIR/eta.rs:214:21
+  --> $DIR/eta.rs:213:21
    |
 LL |         Some(1).map(|n| closure(n));
    |                     ^^^^^^^^^^^^^^ help: replace the closure with the function itself: `&mut closure`
 
 error: redundant closure
-  --> $DIR/eta.rs:218:21
+  --> $DIR/eta.rs:217:21
    |
 LL |         Some(1).map(|n| in_loop(n));
    |                     ^^^^^^^^^^^^^^ help: replace the closure with the function itself: `in_loop`
 
 error: redundant closure
-  --> $DIR/eta.rs:311:18
+  --> $DIR/eta.rs:310:18
    |
 LL |     takes_fn_mut(|| f());
    |                  ^^^^^^ help: replace the closure with the function itself: `&mut f`
 
 error: redundant closure
-  --> $DIR/eta.rs:314:19
+  --> $DIR/eta.rs:313:19
    |
 LL |     takes_fn_once(|| f());
    |                   ^^^^^^ help: replace the closure with the function itself: `&mut f`
 
 error: redundant closure
-  --> $DIR/eta.rs:318:26
+  --> $DIR/eta.rs:317:26
    |
 LL |     move || takes_fn_mut(|| f_used_once())
    |                          ^^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `&mut f_used_once`
 
 error: redundant closure
-  --> $DIR/eta.rs:330:19
+  --> $DIR/eta.rs:329:19
    |
 LL |     array_opt.map(|a| a.as_slice());
    |                   ^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `<[u8; 3]>::as_slice`
 
 error: redundant closure
-  --> $DIR/eta.rs:333:19
+  --> $DIR/eta.rs:332:19
    |
 LL |     slice_opt.map(|s| s.len());
    |                   ^^^^^^^^^^^ help: replace the closure with the method itself: `<[u8]>::len`
 
 error: redundant closure
-  --> $DIR/eta.rs:336:17
+  --> $DIR/eta.rs:335:17
    |
 LL |     ptr_opt.map(|p| p.is_null());
    |                 ^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `<*const usize>::is_null`
 
 error: redundant closure
-  --> $DIR/eta.rs:340:17
+  --> $DIR/eta.rs:339:17
    |
 LL |     dyn_opt.map(|d| d.method_on_dyn());
    |                 ^^^^^^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `<dyn TestTrait>::method_on_dyn`
diff --git a/tests/ui/impl_trait_in_params.stderr b/tests/ui/impl_trait_in_params.stderr
index a43986017fe..62b264f0051 100644
--- a/tests/ui/impl_trait_in_params.stderr
+++ b/tests/ui/impl_trait_in_params.stderr
@@ -1,22 +1,22 @@
-error: 'impl Trait' in the function's parameters
+error: '`impl Trait` used as a function parameter'
   --> $DIR/impl_trait_in_params.rs:8:13
    |
 LL | pub fn a(_: impl Trait) {}
    |             ^^^^^^^^^^
    |
    = note: `-D clippy::impl-trait-in-params` implied by `-D warnings`
-help: create a generic type here and replace that 'impl Trait' with `T`
+help: add a type paremeter
    |
 LL | pub fn a<T: Trait>(_: impl Trait) {}
    |         ++++++++++
 
-error: 'impl Trait' in the function's parameters
+error: '`impl Trait` used as a function parameter'
   --> $DIR/impl_trait_in_params.rs:9:29
    |
 LL | pub fn c<C: Trait>(_: C, _: impl Trait) {}
    |                             ^^^^^^^^^^
    |
-help: create a generic type here and replace that `impl Trait` with `T`
+help: add a type paremeter, `{}`: `{}`
    |
 LL | pub fn c<C: Trait, T: Trait>(_: C, _: impl Trait) {}
    |                  ++++++++++
diff --git a/tests/ui/trait_duplication_in_bounds.fixed b/tests/ui/trait_duplication_in_bounds.fixed
index 373859a2564..4ce5d421782 100644
--- a/tests/ui/trait_duplication_in_bounds.fixed
+++ b/tests/ui/trait_duplication_in_bounds.fixed
@@ -1,6 +1,5 @@
 // run-rustfix
 #![deny(clippy::trait_duplication_in_bounds)]
-#![allow(clippy::impl_trait_in_params)]
 #![allow(unused)]
 
 fn bad_foo<T: Clone + Copy, U: Clone + Copy>(arg0: T, argo1: U) {
diff --git a/tests/ui/trait_duplication_in_bounds.rs b/tests/ui/trait_duplication_in_bounds.rs
index 3afd74aa9b2..7f2e96a22e6 100644
--- a/tests/ui/trait_duplication_in_bounds.rs
+++ b/tests/ui/trait_duplication_in_bounds.rs
@@ -1,6 +1,5 @@
 // run-rustfix
 #![deny(clippy::trait_duplication_in_bounds)]
-#![allow(clippy::impl_trait_in_params)]
 #![allow(unused)]
 
 fn bad_foo<T: Clone + Clone + Clone + Copy, U: Clone + Copy>(arg0: T, argo1: U) {
diff --git a/tests/ui/trait_duplication_in_bounds.stderr b/tests/ui/trait_duplication_in_bounds.stderr
index 5216b2250db..af800ba7888 100644
--- a/tests/ui/trait_duplication_in_bounds.stderr
+++ b/tests/ui/trait_duplication_in_bounds.stderr
@@ -1,5 +1,5 @@
 error: these bounds contain repeated elements
-  --> $DIR/trait_duplication_in_bounds.rs:6:15
+  --> $DIR/trait_duplication_in_bounds.rs:5:15
    |
 LL | fn bad_foo<T: Clone + Clone + Clone + Copy, U: Clone + Copy>(arg0: T, argo1: U) {
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Clone + Copy`
@@ -11,43 +11,43 @@ LL | #![deny(clippy::trait_duplication_in_bounds)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: these where clauses contain repeated elements
-  --> $DIR/trait_duplication_in_bounds.rs:12:8
+  --> $DIR/trait_duplication_in_bounds.rs:11:8
    |
 LL |     T: Clone + Clone + Clone + Copy,
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Clone + Copy`
 
 error: these bounds contain repeated elements
-  --> $DIR/trait_duplication_in_bounds.rs:40:26
+  --> $DIR/trait_duplication_in_bounds.rs:39:26
    |
 LL | trait BadSelfTraitBound: Clone + Clone + Clone {
    |                          ^^^^^^^^^^^^^^^^^^^^^ help: try: `Clone`
 
 error: these where clauses contain repeated elements
-  --> $DIR/trait_duplication_in_bounds.rs:47:15
+  --> $DIR/trait_duplication_in_bounds.rs:46:15
    |
 LL |         Self: Clone + Clone + Clone;
    |               ^^^^^^^^^^^^^^^^^^^^^ help: try: `Clone`
 
 error: these bounds contain repeated elements
-  --> $DIR/trait_duplication_in_bounds.rs:61:24
+  --> $DIR/trait_duplication_in_bounds.rs:60:24
    |
 LL | trait BadTraitBound<T: Clone + Clone + Clone + Copy, U: Clone + Copy> {
    |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Clone + Copy`
 
 error: these where clauses contain repeated elements
-  --> $DIR/trait_duplication_in_bounds.rs:68:12
+  --> $DIR/trait_duplication_in_bounds.rs:67:12
    |
 LL |         T: Clone + Clone + Clone + Copy,
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Clone + Copy`
 
 error: these bounds contain repeated elements
-  --> $DIR/trait_duplication_in_bounds.rs:101:19
+  --> $DIR/trait_duplication_in_bounds.rs:100:19
    |
 LL | fn bad_generic<T: GenericTrait<u64> + GenericTrait<u32> + GenericTrait<u64>>(arg0: T) {
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `GenericTrait<u64> + GenericTrait<u32>`
 
 error: these bounds contain repeated elements
-  --> $DIR/trait_duplication_in_bounds.rs:109:22
+  --> $DIR/trait_duplication_in_bounds.rs:108:22
    |
 LL | fn qualified_path<T: std::clone::Clone + Clone + foo::Clone>(arg0: T) {
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::clone::Clone + foo::Clone`
diff --git a/tests/ui/trait_duplication_in_bounds_unfixable.rs b/tests/ui/trait_duplication_in_bounds_unfixable.rs
index 7435a4ba609..5630a0345ad 100644
--- a/tests/ui/trait_duplication_in_bounds_unfixable.rs
+++ b/tests/ui/trait_duplication_in_bounds_unfixable.rs
@@ -1,5 +1,4 @@
 #![deny(clippy::trait_duplication_in_bounds)]
-#![allow(clippy::impl_trait_in_params)]
 
 use std::collections::BTreeMap;
 use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Sub, SubAssign};
diff --git a/tests/ui/trait_duplication_in_bounds_unfixable.stderr b/tests/ui/trait_duplication_in_bounds_unfixable.stderr
index 48091b38fb4..4d56a94646c 100644
--- a/tests/ui/trait_duplication_in_bounds_unfixable.stderr
+++ b/tests/ui/trait_duplication_in_bounds_unfixable.stderr
@@ -1,5 +1,5 @@
 error: this trait bound is already specified in the where clause
-  --> $DIR/trait_duplication_in_bounds_unfixable.rs:7:15
+  --> $DIR/trait_duplication_in_bounds_unfixable.rs:6:15
    |
 LL | fn bad_foo<T: Clone + Default, Z: Copy>(arg0: T, arg1: Z)
    |               ^^^^^
@@ -12,7 +12,7 @@ LL | #![deny(clippy::trait_duplication_in_bounds)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this trait bound is already specified in the where clause
-  --> $DIR/trait_duplication_in_bounds_unfixable.rs:7:23
+  --> $DIR/trait_duplication_in_bounds_unfixable.rs:6:23
    |
 LL | fn bad_foo<T: Clone + Default, Z: Copy>(arg0: T, arg1: Z)
    |                       ^^^^^^^
@@ -20,7 +20,7 @@ LL | fn bad_foo<T: Clone + Default, Z: Copy>(arg0: T, arg1: Z)
    = help: consider removing this trait bound
 
 error: this trait bound is already specified in trait declaration
-  --> $DIR/trait_duplication_in_bounds_unfixable.rs:36:15
+  --> $DIR/trait_duplication_in_bounds_unfixable.rs:35:15
    |
 LL |         Self: Default;
    |               ^^^^^^^
@@ -28,7 +28,7 @@ LL |         Self: Default;
    = help: consider removing this trait bound
 
 error: this trait bound is already specified in trait declaration
-  --> $DIR/trait_duplication_in_bounds_unfixable.rs:50:15
+  --> $DIR/trait_duplication_in_bounds_unfixable.rs:49:15
    |
 LL |         Self: Default + Clone;
    |               ^^^^^^^
@@ -36,7 +36,7 @@ LL |         Self: Default + Clone;
    = help: consider removing this trait bound
 
 error: this trait bound is already specified in trait declaration
-  --> $DIR/trait_duplication_in_bounds_unfixable.rs:56:15
+  --> $DIR/trait_duplication_in_bounds_unfixable.rs:55:15
    |
 LL |         Self: Default + Clone;
    |               ^^^^^^^
@@ -44,7 +44,7 @@ LL |         Self: Default + Clone;
    = help: consider removing this trait bound
 
 error: this trait bound is already specified in trait declaration
-  --> $DIR/trait_duplication_in_bounds_unfixable.rs:56:25
+  --> $DIR/trait_duplication_in_bounds_unfixable.rs:55:25
    |
 LL |         Self: Default + Clone;
    |                         ^^^^^
@@ -52,7 +52,7 @@ LL |         Self: Default + Clone;
    = help: consider removing this trait bound
 
 error: this trait bound is already specified in trait declaration
-  --> $DIR/trait_duplication_in_bounds_unfixable.rs:59:15
+  --> $DIR/trait_duplication_in_bounds_unfixable.rs:58:15
    |
 LL |         Self: Default;
    |               ^^^^^^^
@@ -60,7 +60,7 @@ LL |         Self: Default;
    = help: consider removing this trait bound
 
 error: this trait bound is already specified in trait declaration
-  --> $DIR/trait_duplication_in_bounds_unfixable.rs:94:15
+  --> $DIR/trait_duplication_in_bounds_unfixable.rs:93:15
    |
 LL |         Self: Iterator<Item = Foo>,
    |               ^^^^^^^^^^^^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From 4166b7dcfe0384c57dbf24d219b05ccdba30e203 Mon Sep 17 00:00:00 2001
From: blyxyas <blyxyas@gmail.com>
Date: Wed, 25 Jan 2023 19:19:16 +0100
Subject: Fix lint message

---
 clippy_lints/src/functions/impl_trait_in_params.rs | 2 +-
 tests/ui/impl_trait_in_params.stderr               | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/functions/impl_trait_in_params.rs b/clippy_lints/src/functions/impl_trait_in_params.rs
index ace5932f4e4..e4b270db672 100644
--- a/clippy_lints/src/functions/impl_trait_in_params.rs
+++ b/clippy_lints/src/functions/impl_trait_in_params.rs
@@ -23,7 +23,7 @@ pub(super) fn check_fn<'tcx>(cx: &LateContext<'_>, kind: &'tcx FnKind<'_>, body:
                             if let Some(gen_span) = generics.span_for_param_suggestion() {
                                 diag.span_suggestion_with_style(
                                     gen_span,
-                                    "add a type paremeter, `{}`: `{}`",
+                                    "add a type paremeter",
                                     format!(", {next_letter}: {}", &param.name.ident().as_str()[5..]),
                                     rustc_errors::Applicability::MaybeIncorrect,
                                     rustc_errors::SuggestionStyle::ShowAlways,
diff --git a/tests/ui/impl_trait_in_params.stderr b/tests/ui/impl_trait_in_params.stderr
index 62b264f0051..c0bcdfd6d42 100644
--- a/tests/ui/impl_trait_in_params.stderr
+++ b/tests/ui/impl_trait_in_params.stderr
@@ -16,7 +16,7 @@ error: '`impl Trait` used as a function parameter'
 LL | pub fn c<C: Trait>(_: C, _: impl Trait) {}
    |                             ^^^^^^^^^^
    |
-help: add a type paremeter, `{}`: `{}`
+help: add a type paremeter
    |
 LL | pub fn c<C: Trait, T: Trait>(_: C, _: impl Trait) {}
    |                  ++++++++++
-- 
cgit 1.4.1-3-g733a5


From 6ef34bf009343a398b3d04850c5f0784329ebe99 Mon Sep 17 00:00:00 2001
From: blyxyas <blyxyas@gmail.com>
Date: Fri, 3 Feb 2023 16:46:55 +0100
Subject: Remove commented code

---
 clippy_lints/src/functions/impl_trait_in_params.rs | 3 ---
 1 file changed, 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/functions/impl_trait_in_params.rs b/clippy_lints/src/functions/impl_trait_in_params.rs
index e4b270db672..1f00e357bfa 100644
--- a/clippy_lints/src/functions/impl_trait_in_params.rs
+++ b/clippy_lints/src/functions/impl_trait_in_params.rs
@@ -29,9 +29,6 @@ pub(super) fn check_fn<'tcx>(cx: &LateContext<'_>, kind: &'tcx FnKind<'_>, body:
                                     rustc_errors::SuggestionStyle::ShowAlways,
                                 );
                             } else {
-                                // multispan.push_span_label(param.span, format!("Replace this with `{}`",
-                                // next_letter));
-
                                 diag.span_suggestion_with_style(
                                     Span::new(
                                         body.params[0].span.lo() - rustc_span::BytePos(1),
-- 
cgit 1.4.1-3-g733a5


From f12b492ee09eb39ba1ec9867a241a4b87c51528c Mon Sep 17 00:00:00 2001
From: Krishna Sundarram <krishnasundarram@monzo.com>
Date: Thu, 16 Feb 2023 09:55:39 +0000
Subject: Change unusual_byte_groupings to require byte groupings of equal size

---
 clippy_lints/src/literal_representation.rs | 10 +++++++---
 tests/ui/large_digit_groups.fixed          |  4 ++--
 tests/ui/large_digit_groups.stderr         | 20 ++++----------------
 tests/ui/literals.stderr                   | 10 ++--------
 tests/ui/unreadable_literal.fixed          |  2 +-
 tests/ui/unreadable_literal.stderr         | 10 +---------
 6 files changed, 17 insertions(+), 39 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/literal_representation.rs b/clippy_lints/src/literal_representation.rs
index 3a7b7835c99..879bcca33a8 100644
--- a/clippy_lints/src/literal_representation.rs
+++ b/clippy_lints/src/literal_representation.rs
@@ -210,7 +210,7 @@ impl WarningType {
                 cx,
                 UNUSUAL_BYTE_GROUPINGS,
                 span,
-                "digits of hex or binary literal not grouped by four",
+                "digits of hex, binary or octal literal not in groups of equal size",
                 "consider",
                 suggested_format,
                 Applicability::MachineApplicable,
@@ -427,8 +427,12 @@ impl LiteralDigitGrouping {
 
         let first = groups.next().expect("At least one group");
 
-        if (radix == Radix::Binary || radix == Radix::Hexadecimal) && groups.any(|i| i != 4 && i != 2) {
-            return Err(WarningType::UnusualByteGroupings);
+        if radix == Radix::Binary || radix == Radix::Octal || radix == Radix::Hexadecimal {
+            if let Some(second_size) = groups.next() {
+                if !groups.all(|i| i == second_size) || first > second_size {
+                    return Err(WarningType::UnusualByteGroupings);
+                }
+            }
         }
 
         if let Some(second) = groups.next() {
diff --git a/tests/ui/large_digit_groups.fixed b/tests/ui/large_digit_groups.fixed
index 3430c137ec2..ea18dac0683 100644
--- a/tests/ui/large_digit_groups.fixed
+++ b/tests/ui/large_digit_groups.fixed
@@ -11,7 +11,7 @@ fn main() {
     let _good = (
         0b1011_i64,
         0o1_234_u32,
-        0x0123_4567,
+        0x1_234_567,
         1_2345_6789,
         1234_f32,
         1_234.12_f32,
@@ -19,7 +19,7 @@ fn main() {
         1.123_4_f32,
     );
     let _bad = (
-        0b11_0110_i64,
+        0b1_10110_i64,
         0xdead_beef_usize,
         123_456_f32,
         123_456.12_f32,
diff --git a/tests/ui/large_digit_groups.stderr b/tests/ui/large_digit_groups.stderr
index 13d108b56e0..19c0fae98a6 100644
--- a/tests/ui/large_digit_groups.stderr
+++ b/tests/ui/large_digit_groups.stderr
@@ -1,22 +1,10 @@
-error: digits of hex or binary literal not grouped by four
-  --> $DIR/large_digit_groups.rs:14:9
-   |
-LL |         0x1_234_567,
-   |         ^^^^^^^^^^^ help: consider: `0x0123_4567`
-   |
-   = note: `-D clippy::unusual-byte-groupings` implied by `-D warnings`
-
-error: digits of hex or binary literal not grouped by four
-  --> $DIR/large_digit_groups.rs:22:9
-   |
-LL |         0b1_10110_i64,
-   |         ^^^^^^^^^^^^^ help: consider: `0b11_0110_i64`
-
-error: digits of hex or binary literal not grouped by four
+error: digits of hex, binary or octal literal not in groups of equal size
   --> $DIR/large_digit_groups.rs:23:9
    |
 LL |         0xd_e_adbee_f_usize,
    |         ^^^^^^^^^^^^^^^^^^^ help: consider: `0xdead_beef_usize`
+   |
+   = note: `-D clippy::unusual-byte-groupings` implied by `-D warnings`
 
 error: digit groups should be smaller
   --> $DIR/large_digit_groups.rs:24:9
@@ -44,5 +32,5 @@ error: digit groups should be smaller
 LL |         1_23456.12345_6_f64,
    |         ^^^^^^^^^^^^^^^^^^^ help: consider: `123_456.123_456_f64`
 
-error: aborting due to 7 previous errors
+error: aborting due to 5 previous errors
 
diff --git a/tests/ui/literals.stderr b/tests/ui/literals.stderr
index 603d47bacca..9bc7948c7cc 100644
--- a/tests/ui/literals.stderr
+++ b/tests/ui/literals.stderr
@@ -121,7 +121,7 @@ error: digits grouped inconsistently by underscores
 LL |     let fail23 = 3__16___23;
    |                  ^^^^^^^^^^ help: consider: `31_623`
 
-error: digits of hex or binary literal not grouped by four
+error: digits of hex, binary or octal literal not in groups of equal size
   --> $DIR/literals.rs:38:18
    |
 LL |     let fail24 = 0xAB_ABC_AB;
@@ -129,12 +129,6 @@ LL |     let fail24 = 0xAB_ABC_AB;
    |
    = note: `-D clippy::unusual-byte-groupings` implied by `-D warnings`
 
-error: digits of hex or binary literal not grouped by four
-  --> $DIR/literals.rs:39:18
-   |
-LL |     let fail25 = 0b01_100_101;
-   |                  ^^^^^^^^^^^^ help: consider: `0b0110_0101`
-
 error: this is a decimal constant
   --> $DIR/literals.rs:46:13
    |
@@ -168,5 +162,5 @@ help: if you mean to use a decimal constant, remove the `0` to avoid confusion
 LL |     let _ = 89;
    |             ~~
 
-error: aborting due to 21 previous errors
+error: aborting due to 20 previous errors
 
diff --git a/tests/ui/unreadable_literal.fixed b/tests/ui/unreadable_literal.fixed
index a67363b09ea..13e5feb1926 100644
--- a/tests/ui/unreadable_literal.fixed
+++ b/tests/ui/unreadable_literal.fixed
@@ -23,7 +23,7 @@ fn main() {
     let _good = (
         0b1011_i64,
         0o1_234_u32,
-        0x0123_4567,
+        0x1_234_567,
         65536,
         1_2345_6789,
         1234_f32,
diff --git a/tests/ui/unreadable_literal.stderr b/tests/ui/unreadable_literal.stderr
index b51130c6a6a..450121b1c5a 100644
--- a/tests/ui/unreadable_literal.stderr
+++ b/tests/ui/unreadable_literal.stderr
@@ -1,11 +1,3 @@
-error: digits of hex or binary literal not grouped by four
-  --> $DIR/unreadable_literal.rs:26:9
-   |
-LL |         0x1_234_567,
-   |         ^^^^^^^^^^^ help: consider: `0x0123_4567`
-   |
-   = note: `-D clippy::unusual-byte-groupings` implied by `-D warnings`
-
 error: long literal lacking separators
   --> $DIR/unreadable_literal.rs:34:17
    |
@@ -68,5 +60,5 @@ error: long literal lacking separators
 LL |     let _fail5 = 1.100300400;
    |                  ^^^^^^^^^^^ help: consider: `1.100_300_400`
 
-error: aborting due to 11 previous errors
+error: aborting due to 10 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 2d4d39de53ccbada5012e8289625b2a5c2d683b9 Mon Sep 17 00:00:00 2001
From: Jirka Vebr <jirkavebr@gmail.com>
Date: Thu, 16 Feb 2023 13:05:08 +0100
Subject: Add the `let_underscore_untyped` lint

---
 CHANGELOG.md                           |  1 +
 clippy_lints/src/declared_lints.rs     |  1 +
 clippy_lints/src/let_underscore.rs     | 52 +++++++++++++++++++++++++++++++-
 tests/ui/let_underscore_untyped.rs     | 54 ++++++++++++++++++++++++++++++++++
 tests/ui/let_underscore_untyped.stderr | 51 ++++++++++++++++++++++++++++++++
 tests/ui/map_flatten_fixable.fixed     |  1 +
 tests/ui/map_flatten_fixable.rs        |  1 +
 tests/ui/map_flatten_fixable.stderr    | 18 ++++++------
 tests/ui/methods.rs                    |  1 +
 tests/ui/methods.stderr                |  4 +--
 10 files changed, 172 insertions(+), 12 deletions(-)
 create mode 100644 tests/ui/let_underscore_untyped.rs
 create mode 100644 tests/ui/let_underscore_untyped.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 30727beb8e7..c8165caff44 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4494,6 +4494,7 @@ Released 2018-09-13
 [`let_underscore_future`]: https://rust-lang.github.io/rust-clippy/master/index.html#let_underscore_future
 [`let_underscore_lock`]: https://rust-lang.github.io/rust-clippy/master/index.html#let_underscore_lock
 [`let_underscore_must_use`]: https://rust-lang.github.io/rust-clippy/master/index.html#let_underscore_must_use
+[`let_underscore_untyped`]: https://rust-lang.github.io/rust-clippy/master/index.html#let_underscore_untyped
 [`let_unit_value`]: https://rust-lang.github.io/rust-clippy/master/index.html#let_unit_value
 [`linkedlist`]: https://rust-lang.github.io/rust-clippy/master/index.html#linkedlist
 [`logic_bug`]: https://rust-lang.github.io/rust-clippy/master/index.html#logic_bug
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index c1feabf05aa..8fa028c6207 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -224,6 +224,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::let_underscore::LET_UNDERSCORE_FUTURE_INFO,
     crate::let_underscore::LET_UNDERSCORE_LOCK_INFO,
     crate::let_underscore::LET_UNDERSCORE_MUST_USE_INFO,
+    crate::let_underscore::LET_UNDERSCORE_UNTYPED_INFO,
     crate::lifetimes::EXTRA_UNUSED_LIFETIMES_INFO,
     crate::lifetimes::NEEDLESS_LIFETIMES_INFO,
     crate::literal_representation::DECIMAL_LITERAL_REPRESENTATION_INFO,
diff --git a/clippy_lints/src/let_underscore.rs b/clippy_lints/src/let_underscore.rs
index f8e35950980..7600777fab9 100644
--- a/clippy_lints/src/let_underscore.rs
+++ b/clippy_lints/src/let_underscore.rs
@@ -90,7 +90,45 @@ declare_clippy_lint! {
     "non-binding `let` on a future"
 }
 
-declare_lint_pass!(LetUnderscore => [LET_UNDERSCORE_MUST_USE, LET_UNDERSCORE_LOCK, LET_UNDERSCORE_FUTURE]);
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `let _ = <expr>` without a type annotation, and suggests to either provide one,
+    /// or remove the `let` keyword altogether.
+    ///
+    /// ### Why is this bad?
+    /// The `let _ = <expr>` expression ignores the value of `<expr>` but will remain doing so even
+    /// if the type were to change, thus potentially introducing subtle bugs. By supplying a type
+    /// annotation, one will be forced to re-visit the decision to ignore the value in such cases.
+    ///
+    /// ### Known problems
+    /// The `_ = <expr>` is not properly supported by some tools (e.g. IntelliJ) and may seem odd
+    /// to many developers. This lint also partially overlaps with the other `let_underscore_*`
+    /// lints.
+    ///
+    /// ### Example
+    /// ```rust
+    /// fn foo() -> Result<u32, ()> {
+    ///     Ok(123)
+    /// }
+    /// let _ = foo();
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// fn foo() -> Result<u32, ()> {
+    ///     Ok(123)
+    /// }
+    /// // Either provide a type annotation:
+    /// let _: Result<u32, ()> = foo();
+    /// // …or drop the let keyword:
+    /// _ = foo();
+    /// ```
+    #[clippy::version = "1.69.0"]
+    pub LET_UNDERSCORE_UNTYPED,
+    pedantic,
+    "non-binding `let` without a type annotation"
+}
+
+declare_lint_pass!(LetUnderscore => [LET_UNDERSCORE_MUST_USE, LET_UNDERSCORE_LOCK, LET_UNDERSCORE_FUTURE, LET_UNDERSCORE_UNTYPED]);
 
 const SYNC_GUARD_PATHS: [&[&str]; 3] = [
     &paths::PARKING_LOT_MUTEX_GUARD,
@@ -148,6 +186,18 @@ impl<'tcx> LateLintPass<'tcx> for LetUnderscore {
                     "consider explicitly using function result",
                 );
             }
+
+            if local.pat.default_binding_modes && local.ty.is_none() {
+                // When `default_binding_modes` is true, the `let` keyword is present.
+                span_lint_and_help(
+                    cx,
+                    LET_UNDERSCORE_UNTYPED,
+                    local.span,
+                    "non-binding `let` without a type annotation",
+                    None,
+                    "consider adding a type annotation or removing the `let` keyword",
+                );
+            }
         }
     }
 }
diff --git a/tests/ui/let_underscore_untyped.rs b/tests/ui/let_underscore_untyped.rs
new file mode 100644
index 00000000000..bcb33c5c7e3
--- /dev/null
+++ b/tests/ui/let_underscore_untyped.rs
@@ -0,0 +1,54 @@
+#![allow(unused)]
+#![warn(clippy::let_underscore_untyped)]
+
+use std::future::Future;
+use std::{boxed::Box, fmt::Display};
+
+fn a() -> u32 {
+    1
+}
+
+fn b<T>(x: T) -> T {
+    x
+}
+
+fn c() -> impl Display {
+    1
+}
+
+fn d(x: &u32) -> &u32 {
+    x
+}
+
+fn e() -> Result<u32, ()> {
+    Ok(1)
+}
+
+fn f() -> Box<dyn Display> {
+    Box::new(1)
+}
+
+fn main() {
+    let _ = a();
+    let _ = b(1);
+    let _ = c();
+    let _ = d(&1);
+    let _ = e();
+    let _ = f();
+
+    _ = a();
+    _ = b(1);
+    _ = c();
+    _ = d(&1);
+    _ = e();
+    _ = f();
+
+    let _: u32 = a();
+    let _: u32 = b(1);
+    let _: &u32 = d(&1);
+    let _: Result<_, _> = e();
+    let _: Box<_> = f();
+
+    #[allow(clippy::let_underscore_untyped)]
+    let _ = a();
+}
diff --git a/tests/ui/let_underscore_untyped.stderr b/tests/ui/let_underscore_untyped.stderr
new file mode 100644
index 00000000000..36c3d1214d6
--- /dev/null
+++ b/tests/ui/let_underscore_untyped.stderr
@@ -0,0 +1,51 @@
+error: non-binding `let` without a type annotation
+  --> $DIR/let_underscore_untyped.rs:32:5
+   |
+LL |     let _ = a();
+   |     ^^^^^^^^^^^^
+   |
+   = help: consider adding a type annotation or removing the `let` keyword
+   = note: `-D clippy::let-underscore-untyped` implied by `-D warnings`
+
+error: non-binding `let` without a type annotation
+  --> $DIR/let_underscore_untyped.rs:33:5
+   |
+LL |     let _ = b(1);
+   |     ^^^^^^^^^^^^^
+   |
+   = help: consider adding a type annotation or removing the `let` keyword
+
+error: non-binding `let` without a type annotation
+  --> $DIR/let_underscore_untyped.rs:34:5
+   |
+LL |     let _ = c();
+   |     ^^^^^^^^^^^^
+   |
+   = help: consider adding a type annotation or removing the `let` keyword
+
+error: non-binding `let` without a type annotation
+  --> $DIR/let_underscore_untyped.rs:35:5
+   |
+LL |     let _ = d(&1);
+   |     ^^^^^^^^^^^^^^
+   |
+   = help: consider adding a type annotation or removing the `let` keyword
+
+error: non-binding `let` without a type annotation
+  --> $DIR/let_underscore_untyped.rs:36:5
+   |
+LL |     let _ = e();
+   |     ^^^^^^^^^^^^
+   |
+   = help: consider adding a type annotation or removing the `let` keyword
+
+error: non-binding `let` without a type annotation
+  --> $DIR/let_underscore_untyped.rs:37:5
+   |
+LL |     let _ = f();
+   |     ^^^^^^^^^^^^
+   |
+   = help: consider adding a type annotation or removing the `let` keyword
+
+error: aborting due to 6 previous errors
+
diff --git a/tests/ui/map_flatten_fixable.fixed b/tests/ui/map_flatten_fixable.fixed
index 53628ef6531..8e2f11389f8 100644
--- a/tests/ui/map_flatten_fixable.fixed
+++ b/tests/ui/map_flatten_fixable.fixed
@@ -1,6 +1,7 @@
 // run-rustfix
 
 #![warn(clippy::all, clippy::pedantic)]
+#![allow(clippy::let_underscore_untyped)]
 #![allow(clippy::missing_docs_in_private_items)]
 #![allow(clippy::map_identity)]
 #![allow(clippy::redundant_closure)]
diff --git a/tests/ui/map_flatten_fixable.rs b/tests/ui/map_flatten_fixable.rs
index 76016c8ed3c..a783a99c4ff 100644
--- a/tests/ui/map_flatten_fixable.rs
+++ b/tests/ui/map_flatten_fixable.rs
@@ -1,6 +1,7 @@
 // run-rustfix
 
 #![warn(clippy::all, clippy::pedantic)]
+#![allow(clippy::let_underscore_untyped)]
 #![allow(clippy::missing_docs_in_private_items)]
 #![allow(clippy::map_identity)]
 #![allow(clippy::redundant_closure)]
diff --git a/tests/ui/map_flatten_fixable.stderr b/tests/ui/map_flatten_fixable.stderr
index b6b0c4d09c3..c91f0b9ae94 100644
--- a/tests/ui/map_flatten_fixable.stderr
+++ b/tests/ui/map_flatten_fixable.stderr
@@ -1,5 +1,5 @@
 error: called `map(..).flatten()` on `Iterator`
-  --> $DIR/map_flatten_fixable.rs:17:47
+  --> $DIR/map_flatten_fixable.rs:18:47
    |
 LL |     let _: Vec<_> = vec![5_i8; 6].into_iter().map(option_id).flatten().collect();
    |                                               ^^^^^^^^^^^^^^^^^^^^^^^^ help: try replacing `map` with `filter_map` and remove the `.flatten()`: `filter_map(option_id)`
@@ -7,43 +7,43 @@ LL |     let _: Vec<_> = vec![5_i8; 6].into_iter().map(option_id).flatten().coll
    = note: `-D clippy::map-flatten` implied by `-D warnings`
 
 error: called `map(..).flatten()` on `Iterator`
-  --> $DIR/map_flatten_fixable.rs:18:47
+  --> $DIR/map_flatten_fixable.rs:19:47
    |
 LL |     let _: Vec<_> = vec![5_i8; 6].into_iter().map(option_id_ref).flatten().collect();
    |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try replacing `map` with `filter_map` and remove the `.flatten()`: `filter_map(option_id_ref)`
 
 error: called `map(..).flatten()` on `Iterator`
-  --> $DIR/map_flatten_fixable.rs:19:47
+  --> $DIR/map_flatten_fixable.rs:20:47
    |
 LL |     let _: Vec<_> = vec![5_i8; 6].into_iter().map(option_id_closure).flatten().collect();
    |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try replacing `map` with `filter_map` and remove the `.flatten()`: `filter_map(option_id_closure)`
 
 error: called `map(..).flatten()` on `Iterator`
-  --> $DIR/map_flatten_fixable.rs:20:47
+  --> $DIR/map_flatten_fixable.rs:21:47
    |
 LL |     let _: Vec<_> = vec![5_i8; 6].into_iter().map(|x| x.checked_add(1)).flatten().collect();
    |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try replacing `map` with `filter_map` and remove the `.flatten()`: `filter_map(|x| x.checked_add(1))`
 
 error: called `map(..).flatten()` on `Iterator`
-  --> $DIR/map_flatten_fixable.rs:23:47
+  --> $DIR/map_flatten_fixable.rs:24:47
    |
 LL |     let _: Vec<_> = vec![5_i8; 6].into_iter().map(|x| 0..x).flatten().collect();
    |                                               ^^^^^^^^^^^^^^^^^^^^^^^ help: try replacing `map` with `flat_map` and remove the `.flatten()`: `flat_map(|x| 0..x)`
 
 error: called `map(..).flatten()` on `Option`
-  --> $DIR/map_flatten_fixable.rs:26:40
+  --> $DIR/map_flatten_fixable.rs:27:40
    |
 LL |     let _: Option<_> = (Some(Some(1))).map(|x| x).flatten();
    |                                        ^^^^^^^^^^^^^^^^^^^^ help: try replacing `map` with `and_then` and remove the `.flatten()`: `and_then(|x| x)`
 
 error: called `map(..).flatten()` on `Result`
-  --> $DIR/map_flatten_fixable.rs:29:42
+  --> $DIR/map_flatten_fixable.rs:30:42
    |
 LL |     let _: Result<_, &str> = (Ok(Ok(1))).map(|x| x).flatten();
    |                                          ^^^^^^^^^^^^^^^^^^^^ help: try replacing `map` with `and_then` and remove the `.flatten()`: `and_then(|x| x)`
 
 error: called `map(..).flatten()` on `Iterator`
-  --> $DIR/map_flatten_fixable.rs:38:10
+  --> $DIR/map_flatten_fixable.rs:39:10
    |
 LL |           .map(|n| match n {
    |  __________^
@@ -72,7 +72,7 @@ LL ~         });
    |
 
 error: called `map(..).flatten()` on `Option`
-  --> $DIR/map_flatten_fixable.rs:58:10
+  --> $DIR/map_flatten_fixable.rs:59:10
    |
 LL |           .map(|_| {
    |  __________^
diff --git a/tests/ui/methods.rs b/tests/ui/methods.rs
index 6f22366eab2..1519e4da934 100644
--- a/tests/ui/methods.rs
+++ b/tests/ui/methods.rs
@@ -4,6 +4,7 @@
 #![allow(
     clippy::disallowed_names,
     clippy::default_trait_access,
+    clippy::let_underscore_untyped,
     clippy::missing_docs_in_private_items,
     clippy::missing_safety_doc,
     clippy::non_ascii_literal,
diff --git a/tests/ui/methods.stderr b/tests/ui/methods.stderr
index b63672dd6fd..4643e09e270 100644
--- a/tests/ui/methods.stderr
+++ b/tests/ui/methods.stderr
@@ -1,5 +1,5 @@
 error: methods called `new` usually return `Self`
-  --> $DIR/methods.rs:104:5
+  --> $DIR/methods.rs:105:5
    |
 LL | /     fn new() -> i32 {
 LL | |         0
@@ -9,7 +9,7 @@ LL | |     }
    = note: `-D clippy::new-ret-no-self` implied by `-D warnings`
 
 error: called `filter(..).next()` on an `Iterator`. This is more succinctly expressed by calling `.find(..)` instead
-  --> $DIR/methods.rs:125:13
+  --> $DIR/methods.rs:126:13
    |
 LL |       let _ = v.iter().filter(|&x| {
    |  _____________^
-- 
cgit 1.4.1-3-g733a5


From 09337981b21c7004791260fde7ab7f1e21abf5ca Mon Sep 17 00:00:00 2001
From: Armin Ronacher <armin.ronacher@active-4.com>
Date: Thu, 16 Feb 2023 13:21:34 +0100
Subject: Added check for local spans

---
 clippy_lints/src/question_mark_used.rs | 5 +++++
 1 file changed, 5 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/question_mark_used.rs b/clippy_lints/src/question_mark_used.rs
index 1a103dc35a4..9b678e8d753 100644
--- a/clippy_lints/src/question_mark_used.rs
+++ b/clippy_lints/src/question_mark_used.rs
@@ -1,5 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_help;
 
+use clippy_utils::macros::span_is_local;
 use rustc_hir::{Expr, ExprKind, MatchSource};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -34,6 +35,10 @@ declare_lint_pass!(QuestionMarkUsed => [QUESTION_MARK_USED]);
 impl<'tcx> LateLintPass<'tcx> for QuestionMarkUsed {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if let ExprKind::Match(_, _, MatchSource::TryDesugar) = expr.kind {
+            if !span_is_local(expr.span) {
+                return;
+            }
+
             span_lint_and_help(
                 cx,
                 QUESTION_MARK_USED,
-- 
cgit 1.4.1-3-g733a5


From 0b1ae20365f4363fdc5462fae3b3a3bd8ee214e6 Mon Sep 17 00:00:00 2001
From: Jirka Vebr <jirkavebr@gmail.com>
Date: Thu, 16 Feb 2023 13:29:38 +0100
Subject: Fix dogfood tests by adding type annotations

---
 clippy_dev/src/new_lint.rs                          |  9 +++++----
 clippy_dev/src/update_lints.rs                      |  6 +++---
 clippy_lints/src/entry.rs                           |  8 ++++----
 clippy_lints/src/inconsistent_struct_constructor.rs |  4 ++--
 clippy_lints/src/literal_representation.rs          |  2 +-
 clippy_lints/src/module_style.rs                    |  2 +-
 clippy_utils/src/numeric_literal.rs                 |  2 +-
 clippy_utils/src/sugg.rs                            |  8 ++++----
 lintcheck/src/main.rs                               | 12 ++++++------
 9 files changed, 27 insertions(+), 26 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_dev/src/new_lint.rs b/clippy_dev/src/new_lint.rs
index ec7f1dd0d84..420214d9256 100644
--- a/clippy_dev/src/new_lint.rs
+++ b/clippy_dev/src/new_lint.rs
@@ -1,5 +1,6 @@
 use crate::clippy_project_root;
 use indoc::{formatdoc, writedoc};
+use std::fmt;
 use std::fmt::Write as _;
 use std::fs::{self, OpenOptions};
 use std::io::prelude::*;
@@ -256,7 +257,7 @@ fn get_lint_file_contents(lint: &LintData<'_>, enable_msrv: bool) -> String {
         )
     });
 
-    let _ = write!(result, "{}", get_lint_declaration(&name_upper, category));
+    let _: fmt::Result = write!(result, "{}", get_lint_declaration(&name_upper, category));
 
     result.push_str(&if enable_msrv {
         formatdoc!(
@@ -353,7 +354,7 @@ fn create_lint_for_ty(lint: &LintData<'_>, enable_msrv: bool, ty: &str) -> io::R
     let mut lint_file_contents = String::new();
 
     if enable_msrv {
-        let _ = writedoc!(
+        let _: fmt::Result = writedoc!(
             lint_file_contents,
             r#"
                 use clippy_utils::msrvs::{{self, Msrv}};
@@ -373,7 +374,7 @@ fn create_lint_for_ty(lint: &LintData<'_>, enable_msrv: bool, ty: &str) -> io::R
             name_upper = name_upper,
         );
     } else {
-        let _ = writedoc!(
+        let _: fmt::Result = writedoc!(
             lint_file_contents,
             r#"
                 use rustc_lint::{{{context_import}, LintContext}};
@@ -521,7 +522,7 @@ fn setup_mod_file(path: &Path, lint: &LintData<'_>) -> io::Result<&'static str>
         .chain(std::iter::once(&*lint_name_upper))
         .filter(|s| !s.is_empty())
     {
-        let _ = write!(new_arr_content, "\n    {ident},");
+        let _: fmt::Result = write!(new_arr_content, "\n    {ident},");
     }
     new_arr_content.push('\n');
 
diff --git a/clippy_dev/src/update_lints.rs b/clippy_dev/src/update_lints.rs
index 837618c9294..779e4d0e1e3 100644
--- a/clippy_dev/src/update_lints.rs
+++ b/clippy_dev/src/update_lints.rs
@@ -5,7 +5,7 @@ use itertools::Itertools;
 use rustc_lexer::{tokenize, unescape, LiteralKind, TokenKind};
 use std::collections::{HashMap, HashSet};
 use std::ffi::OsStr;
-use std::fmt::Write;
+use std::fmt::{self, Write};
 use std::fs::{self, OpenOptions};
 use std::io::{self, Read, Seek, SeekFrom, Write as _};
 use std::ops::Range;
@@ -691,7 +691,7 @@ fn gen_deprecated(lints: &[DeprecatedLint]) -> String {
     let mut output = GENERATED_FILE_COMMENT.to_string();
     output.push_str("{\n");
     for lint in lints {
-        let _ = write!(
+        let _: fmt::Result = write!(
             output,
             concat!(
                 "    store.register_removed(\n",
@@ -726,7 +726,7 @@ fn gen_declared_lints<'a>(
         if !is_public {
             output.push_str("    #[cfg(feature = \"internal\")]\n");
         }
-        let _ = writeln!(output, "    crate::{module_name}::{lint_name}_INFO,");
+        let _: fmt::Result = writeln!(output, "    crate::{module_name}::{lint_name}_INFO,");
     }
     output.push_str("];\n");
 
diff --git a/clippy_lints/src/entry.rs b/clippy_lints/src/entry.rs
index ed9d94cdec3..48a54f60253 100644
--- a/clippy_lints/src/entry.rs
+++ b/clippy_lints/src/entry.rs
@@ -6,7 +6,7 @@ use clippy_utils::{
     source::{reindent_multiline, snippet_indent, snippet_with_applicability, snippet_with_context},
     SpanlessEq,
 };
-use core::fmt::Write;
+use core::fmt::{self, Write};
 use rustc_errors::Applicability;
 use rustc_hir::{
     hir_id::HirIdSet,
@@ -536,7 +536,7 @@ impl<'tcx> InsertSearchResults<'tcx> {
             if is_expr_used_or_unified(cx.tcx, insertion.call) {
                 write_wrapped(&mut res, insertion, ctxt, app);
             } else {
-                let _ = write!(
+                let _: fmt::Result = write!(
                     res,
                     "e.insert({})",
                     snippet_with_context(cx, insertion.value.span, ctxt, "..", app).0
@@ -552,7 +552,7 @@ impl<'tcx> InsertSearchResults<'tcx> {
         (
             self.snippet(cx, span, app, |res, insertion, ctxt, app| {
                 // Insertion into a map would return `Some(&mut value)`, but the entry returns `&mut value`
-                let _ = write!(
+                let _: fmt::Result = write!(
                     res,
                     "Some(e.insert({}))",
                     snippet_with_context(cx, insertion.value.span, ctxt, "..", app).0
@@ -566,7 +566,7 @@ impl<'tcx> InsertSearchResults<'tcx> {
         (
             self.snippet(cx, span, app, |res, insertion, ctxt, app| {
                 // Insertion into a map would return `None`, but the entry returns a mutable reference.
-                let _ = if is_expr_final_block_expr(cx.tcx, insertion.call) {
+                let _: fmt::Result = if is_expr_final_block_expr(cx.tcx, insertion.call) {
                     write!(
                         res,
                         "e.insert({});\n{}None",
diff --git a/clippy_lints/src/inconsistent_struct_constructor.rs b/clippy_lints/src/inconsistent_struct_constructor.rs
index e2f2d3d42e6..1ad886f2cf3 100644
--- a/clippy_lints/src/inconsistent_struct_constructor.rs
+++ b/clippy_lints/src/inconsistent_struct_constructor.rs
@@ -7,7 +7,7 @@ use rustc_hir::{self as hir, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::symbol::Symbol;
-use std::fmt::Write as _;
+use std::fmt::{self, Write as _};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -90,7 +90,7 @@ impl<'tcx> LateLintPass<'tcx> for InconsistentStructConstructor {
                 let mut fields_snippet = String::new();
                 let (last_ident, idents) = ordered_fields.split_last().unwrap();
                 for ident in idents {
-                    let _ = write!(fields_snippet, "{ident}, ");
+                    let _: fmt::Result = write!(fields_snippet, "{ident}, ");
                 }
                 fields_snippet.push_str(&last_ident.to_string());
 
diff --git a/clippy_lints/src/literal_representation.rs b/clippy_lints/src/literal_representation.rs
index 3a7b7835c99..8097627c869 100644
--- a/clippy_lints/src/literal_representation.rs
+++ b/clippy_lints/src/literal_representation.rs
@@ -484,7 +484,7 @@ impl DecimalLiteralRepresentation {
             then {
                 let hex = format!("{val:#X}");
                 let num_lit = NumericLiteral::new(&hex, num_lit.suffix, false);
-                let _ = Self::do_lint(num_lit.integer).map_err(|warning_type| {
+                let _: Result<(), ()> = Self::do_lint(num_lit.integer).map_err(|warning_type| {
                     warning_type.display(num_lit.format(), cx, span);
                 });
             }
diff --git a/clippy_lints/src/module_style.rs b/clippy_lints/src/module_style.rs
index 0742943dff2..349fcd2274d 100644
--- a/clippy_lints/src/module_style.rs
+++ b/clippy_lints/src/module_style.rs
@@ -134,7 +134,7 @@ fn process_paths_for_mod_files<'a>(
     mod_folders: &mut FxHashSet<&'a OsStr>,
 ) {
     let mut comp = path.components().rev().peekable();
-    let _ = comp.next();
+    let _: Option<_> = comp.next();
     if path.ends_with("mod.rs") {
         mod_folders.insert(comp.peek().map(|c| c.as_os_str()).unwrap_or_default());
     }
diff --git a/clippy_utils/src/numeric_literal.rs b/clippy_utils/src/numeric_literal.rs
index 42bdfd4827f..c225398ad2a 100644
--- a/clippy_utils/src/numeric_literal.rs
+++ b/clippy_utils/src/numeric_literal.rs
@@ -186,7 +186,7 @@ impl<'a> NumericLiteral<'a> {
         // The exponent may have a sign, output it early, otherwise it will be
         // treated as a digit
         if digits.clone().next() == Some('-') {
-            let _ = digits.next();
+            let _: Option<char> = digits.next();
             output.push('-');
         }
 
diff --git a/clippy_utils/src/sugg.rs b/clippy_utils/src/sugg.rs
index 78fb2e0eb7e..51e270d330c 100644
--- a/clippy_utils/src/sugg.rs
+++ b/clippy_utils/src/sugg.rs
@@ -20,7 +20,7 @@ use rustc_middle::mir::{FakeReadCause, Mutability};
 use rustc_middle::ty;
 use rustc_span::source_map::{BytePos, CharPos, Pos, Span, SyntaxContext};
 use std::borrow::Cow;
-use std::fmt::{Display, Write as _};
+use std::fmt::{self, Display, Write as _};
 use std::ops::{Add, Neg, Not, Sub};
 
 /// A helper type to build suggestion correctly handling parentheses.
@@ -932,7 +932,7 @@ impl<'tcx> Delegate<'tcx> for DerefDelegate<'_, 'tcx> {
             if cmt.place.projections.is_empty() {
                 // handle item without any projection, that needs an explicit borrowing
                 // i.e.: suggest `&x` instead of `x`
-                let _ = write!(self.suggestion_start, "{start_snip}&{ident_str}");
+                let _: fmt::Result = write!(self.suggestion_start, "{start_snip}&{ident_str}");
             } else {
                 // cases where a parent `Call` or `MethodCall` is using the item
                 // i.e.: suggest `.contains(&x)` for `.find(|x| [1, 2, 3].contains(x)).is_none()`
@@ -947,7 +947,7 @@ impl<'tcx> Delegate<'tcx> for DerefDelegate<'_, 'tcx> {
                         // given expression is the self argument and will be handled completely by the compiler
                         // i.e.: `|x| x.is_something()`
                         ExprKind::MethodCall(_, self_expr, ..) if self_expr.hir_id == cmt.hir_id => {
-                            let _ = write!(self.suggestion_start, "{start_snip}{ident_str_with_proj}");
+                            let _: fmt::Result = write!(self.suggestion_start, "{start_snip}{ident_str_with_proj}");
                             self.next_pos = span.hi();
                             return;
                         },
@@ -1055,7 +1055,7 @@ impl<'tcx> Delegate<'tcx> for DerefDelegate<'_, 'tcx> {
                     }
                 }
 
-                let _ = write!(self.suggestion_start, "{start_snip}{replacement_str}");
+                let _: fmt::Result = write!(self.suggestion_start, "{start_snip}{replacement_str}");
             }
             self.next_pos = span.hi();
         }
diff --git a/lintcheck/src/main.rs b/lintcheck/src/main.rs
index bd49f096072..23c85298027 100644
--- a/lintcheck/src/main.rs
+++ b/lintcheck/src/main.rs
@@ -17,9 +17,9 @@ use crate::recursive::LintcheckServer;
 use std::collections::{HashMap, HashSet};
 use std::env;
 use std::env::consts::EXE_SUFFIX;
-use std::fmt::Write as _;
+use std::fmt::{self, Write as _};
 use std::fs;
-use std::io::ErrorKind;
+use std::io::{self, ErrorKind};
 use std::path::{Path, PathBuf};
 use std::process::Command;
 use std::sync::atomic::{AtomicUsize, Ordering};
@@ -145,8 +145,8 @@ impl ClippyWarning {
             }
 
             let mut output = String::from("| ");
-            let _ = write!(output, "[`{file_with_pos}`]({file}#L{})", self.line);
-            let _ = write!(output, r#" | `{:<50}` | "{}" |"#, self.lint_type, self.message);
+            let _: fmt::Result = write!(output, "[`{file_with_pos}`]({file}#L{})", self.line);
+            let _: fmt::Result = write!(output, r#" | `{:<50}` | "{}" |"#, self.lint_type, self.message);
             output.push('\n');
             output
         } else {
@@ -632,7 +632,7 @@ fn main() {
         .unwrap();
 
     let server = config.recursive.then(|| {
-        let _ = fs::remove_dir_all("target/lintcheck/shared_target_dir/recursive");
+        let _: io::Result<()> = fs::remove_dir_all("target/lintcheck/shared_target_dir/recursive");
 
         LintcheckServer::spawn(recursive_options)
     });
@@ -689,7 +689,7 @@ fn main() {
     write!(text, "{}", all_msgs.join("")).unwrap();
     text.push_str("\n\n### ICEs:\n");
     for (cratename, msg) in &ices {
-        let _ = write!(text, "{cratename}: '{msg}'");
+        let _: fmt::Result = write!(text, "{cratename}: '{msg}'");
     }
 
     println!("Writing logs to {}", config.lintcheck_results_path.display());
-- 
cgit 1.4.1-3-g733a5


From 9c9dbc24081e569cffe7a1cf83020b4b4907d7be Mon Sep 17 00:00:00 2001
From: Krishna Sundarram <krishnasundarram@monzo.com>
Date: Thu, 16 Feb 2023 14:20:40 +0000
Subject: Fix DOC_MARKDOWN requiring backticks on links to external websites

---
 clippy_lints/src/doc.rs         | 20 +++++++++++---------
 tests/ui/doc/doc-fixable.fixed  |  2 +-
 tests/ui/doc/doc-fixable.rs     |  4 ++--
 tests/ui/doc/doc-fixable.stderr | 24 +-----------------------
 4 files changed, 15 insertions(+), 35 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/doc.rs b/clippy_lints/src/doc.rs
index 127201b72e2..5e2811db2f7 100644
--- a/clippy_lints/src/doc.rs
+++ b/clippy_lints/src/doc.rs
@@ -6,6 +6,11 @@ use clippy_utils::ty::{implements_trait, is_type_diagnostic_item};
 use clippy_utils::{is_entrypoint_fn, method_chain_args, return_ty};
 use if_chain::if_chain;
 use itertools::Itertools;
+use pulldown_cmark::Event::{
+    Code, End, FootnoteReference, HardBreak, Html, Rule, SoftBreak, Start, TaskListMarker, Text,
+};
+use pulldown_cmark::Tag::{CodeBlock, Heading, Item, Link, Paragraph};
+use pulldown_cmark::{BrokenLink, CodeBlockKind, CowStr, Options};
 use rustc_ast::ast::{Async, AttrKind, Attribute, Fn, FnRetTy, ItemKind};
 use rustc_ast::token::CommentKind;
 use rustc_data_structures::fx::FxHashSet;
@@ -497,7 +502,6 @@ struct DocHeaders {
 }
 
 fn check_attrs(cx: &LateContext<'_>, valid_idents: &FxHashSet<String>, attrs: &[Attribute]) -> Option<DocHeaders> {
-    use pulldown_cmark::{BrokenLink, CowStr, Options};
     /// We don't want the parser to choke on intra doc links. Since we don't
     /// actually care about rendering them, just pretend that all broken links are
     /// point to a fake address.
@@ -538,8 +542,6 @@ fn check_attrs(cx: &LateContext<'_>, valid_idents: &FxHashSet<String>, attrs: &[
         pulldown_cmark::Parser::new_with_broken_link_callback(&doc, Options::empty(), Some(&mut cb)).into_offset_iter();
     // Iterate over all `Events` and combine consecutive events into one
     let events = parser.coalesce(|previous, current| {
-        use pulldown_cmark::Event::Text;
-
         let previous_range = previous.1;
         let current_range = current.1;
 
@@ -564,12 +566,6 @@ fn check_doc<'a, Events: Iterator<Item = (pulldown_cmark::Event<'a>, Range<usize
     spans: &[(usize, Span)],
 ) -> DocHeaders {
     // true if a safety header was found
-    use pulldown_cmark::Event::{
-        Code, End, FootnoteReference, HardBreak, Html, Rule, SoftBreak, Start, TaskListMarker, Text,
-    };
-    use pulldown_cmark::Tag::{CodeBlock, Heading, Item, Link, Paragraph};
-    use pulldown_cmark::{CodeBlockKind, CowStr};
-
     let mut headers = DocHeaders::default();
     let mut in_code = false;
     let mut in_link = None;
@@ -660,6 +656,12 @@ fn check_doc<'a, Events: Iterator<Item = (pulldown_cmark::Event<'a>, Range<usize
                     check_link_quotes(cx, in_link.is_some(), trimmed_text, span, &range, begin, text.len());
                     // Adjust for the beginning of the current `Event`
                     let span = span.with_lo(span.lo() + BytePos::from_usize(range.start - begin));
+                    if let Some(link) = in_link.as_ref()
+                      && let Ok(url) = Url::parse(link)
+                      && (url.scheme() == "https" || url.scheme() == "http") {
+                        // Don't check the text associated with external URLs
+                        continue;
+                    }
                     text_to_check.push((text, span));
                 }
             },
diff --git a/tests/ui/doc/doc-fixable.fixed b/tests/ui/doc/doc-fixable.fixed
index 747801b40ee..ecb0bf3644e 100644
--- a/tests/ui/doc/doc-fixable.fixed
+++ b/tests/ui/doc/doc-fixable.fixed
@@ -78,7 +78,7 @@ fn test_allowed() {
 /// This test has [a `link_with_underscores`][chunked-example] inside it. See #823.
 /// See also [the issue tracker](https://github.com/rust-lang/rust-clippy/search?q=clippy::doc_markdown&type=Issues)
 /// on GitHub (which is a camel-cased word, but is OK). And here is another [inline link][inline_link].
-/// It can also be [`inline_link2`].
+/// It can also be [inline_link2]. A link to [StackOverflow](https://stackoverflow.com) is also acceptable.
 ///
 /// [chunked-example]: https://en.wikipedia.org/wiki/Chunked_transfer_encoding#Example
 /// [inline_link]: https://foobar
diff --git a/tests/ui/doc/doc-fixable.rs b/tests/ui/doc/doc-fixable.rs
index f3cf966157a..11c48dd103d 100644
--- a/tests/ui/doc/doc-fixable.rs
+++ b/tests/ui/doc/doc-fixable.rs
@@ -75,10 +75,10 @@ fn test_units() {
 fn test_allowed() {
 }
 
-/// This test has [a link_with_underscores][chunked-example] inside it. See #823.
+/// This test has [a `link_with_underscores`][chunked-example] inside it. See #823.
 /// See also [the issue tracker](https://github.com/rust-lang/rust-clippy/search?q=clippy::doc_markdown&type=Issues)
 /// on GitHub (which is a camel-cased word, but is OK). And here is another [inline link][inline_link].
-/// It can also be [inline_link2].
+/// It can also be [inline_link2]. A link to [StackOverflow](https://stackoverflow.com) is also acceptable.
 ///
 /// [chunked-example]: https://en.wikipedia.org/wiki/Chunked_transfer_encoding#Example
 /// [inline_link]: https://foobar
diff --git a/tests/ui/doc/doc-fixable.stderr b/tests/ui/doc/doc-fixable.stderr
index 40345370c04..6c67c903c75 100644
--- a/tests/ui/doc/doc-fixable.stderr
+++ b/tests/ui/doc/doc-fixable.stderr
@@ -142,28 +142,6 @@ help: try
 LL | /// `be_sure_we_got_to_the_end_of_it`
    |     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-error: item in documentation is missing backticks
-  --> $DIR/doc-fixable.rs:78:22
-   |
-LL | /// This test has [a link_with_underscores][chunked-example] inside it. See #823.
-   |                      ^^^^^^^^^^^^^^^^^^^^^
-   |
-help: try
-   |
-LL | /// This test has [a `link_with_underscores`][chunked-example] inside it. See #823.
-   |                      ~~~~~~~~~~~~~~~~~~~~~~~
-
-error: item in documentation is missing backticks
-  --> $DIR/doc-fixable.rs:81:21
-   |
-LL | /// It can also be [inline_link2].
-   |                     ^^^^^^^^^^^^
-   |
-help: try
-   |
-LL | /// It can also be [`inline_link2`].
-   |                     ~~~~~~~~~~~~~~
-
 error: item in documentation is missing backticks
   --> $DIR/doc-fixable.rs:91:5
    |
@@ -329,5 +307,5 @@ help: try
 LL | /// An iterator over `mycrate::Collection`'s values.
    |                      ~~~~~~~~~~~~~~~~~~~~~
 
-error: aborting due to 30 previous errors
+error: aborting due to 28 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 6d0df84f6f879feb2211f8f61351a4669d2397e0 Mon Sep 17 00:00:00 2001
From: Jirka Vebr <jirkavebr@gmail.com>
Date: Thu, 16 Feb 2023 16:08:28 +0100
Subject: Add the `transmute_int_to_non_zero` lint

---
 CHANGELOG.md                                       |  1 +
 clippy_lints/src/declared_lints.rs                 |  1 +
 clippy_lints/src/transmute/mod.rs                  | 28 ++++++++++
 .../src/transmute/transmute_int_to_non_zero.rs     | 61 +++++++++++++++++++++
 tests/ui/transmute_int_to_non_zero.rs              | 41 ++++++++++++++
 tests/ui/transmute_int_to_non_zero.stderr          | 64 ++++++++++++++++++++++
 6 files changed, 196 insertions(+)
 create mode 100644 clippy_lints/src/transmute/transmute_int_to_non_zero.rs
 create mode 100644 tests/ui/transmute_int_to_non_zero.rs
 create mode 100644 tests/ui/transmute_int_to_non_zero.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 73ae215ce1b..9138a4fb9c5 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4794,6 +4794,7 @@ Released 2018-09-13
 [`transmute_int_to_bool`]: https://rust-lang.github.io/rust-clippy/master/index.html#transmute_int_to_bool
 [`transmute_int_to_char`]: https://rust-lang.github.io/rust-clippy/master/index.html#transmute_int_to_char
 [`transmute_int_to_float`]: https://rust-lang.github.io/rust-clippy/master/index.html#transmute_int_to_float
+[`transmute_int_to_non_zero`]: https://rust-lang.github.io/rust-clippy/master/index.html#transmute_int_to_non_zero
 [`transmute_null_to_fn`]: https://rust-lang.github.io/rust-clippy/master/index.html#transmute_null_to_fn
 [`transmute_num_to_bytes`]: https://rust-lang.github.io/rust-clippy/master/index.html#transmute_num_to_bytes
 [`transmute_ptr_to_ptr`]: https://rust-lang.github.io/rust-clippy/master/index.html#transmute_ptr_to_ptr
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 0dab6b5f3f1..2577cdc8c66 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -577,6 +577,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::transmute::TRANSMUTE_INT_TO_BOOL_INFO,
     crate::transmute::TRANSMUTE_INT_TO_CHAR_INFO,
     crate::transmute::TRANSMUTE_INT_TO_FLOAT_INFO,
+    crate::transmute::TRANSMUTE_INT_TO_NON_ZERO_INFO,
     crate::transmute::TRANSMUTE_NULL_TO_FN_INFO,
     crate::transmute::TRANSMUTE_NUM_TO_BYTES_INFO,
     crate::transmute::TRANSMUTE_PTR_TO_PTR_INFO,
diff --git a/clippy_lints/src/transmute/mod.rs b/clippy_lints/src/transmute/mod.rs
index c0d290b5adc..c01cbe5090f 100644
--- a/clippy_lints/src/transmute/mod.rs
+++ b/clippy_lints/src/transmute/mod.rs
@@ -3,6 +3,7 @@ mod transmute_float_to_int;
 mod transmute_int_to_bool;
 mod transmute_int_to_char;
 mod transmute_int_to_float;
+mod transmute_int_to_non_zero;
 mod transmute_null_to_fn;
 mod transmute_num_to_bytes;
 mod transmute_ptr_to_ptr;
@@ -253,6 +254,31 @@ declare_clippy_lint! {
     "transmutes from an integer to a float"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for transmutes from integers to `NonZero*` types, and suggests their `new_unchecked`
+    /// method instead.
+    ///
+    /// ### Why is this bad?
+    /// Transmutes work on any types and thus might cause unsoundness when those types change
+    /// elsewhere. `new_unchecked` only works for the appropriate types instead.
+    ///
+    /// ### Example
+    /// ```rust
+    /// # use core::num::NonZeroU32;
+    /// let _non_zero: NonZeroU32 = unsafe { std::mem::transmute(123) };
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// # use core::num::NonZeroU32;
+    /// let _non_zero = unsafe { NonZeroU32::new_unchecked(123) };
+    /// ```
+    #[clippy::version = "1.69.0"]
+    pub TRANSMUTE_INT_TO_NON_ZERO,
+    complexity,
+    "transmutes from an integer to a non-zero wrapper"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for transmutes from a float to an integer.
@@ -451,6 +477,7 @@ impl_lint_pass!(Transmute => [
     TRANSMUTE_BYTES_TO_STR,
     TRANSMUTE_INT_TO_BOOL,
     TRANSMUTE_INT_TO_FLOAT,
+    TRANSMUTE_INT_TO_NON_ZERO,
     TRANSMUTE_FLOAT_TO_INT,
     TRANSMUTE_NUM_TO_BYTES,
     UNSOUND_COLLECTION_TRANSMUTE,
@@ -501,6 +528,7 @@ impl<'tcx> LateLintPass<'tcx> for Transmute {
                     | transmute_ptr_to_ptr::check(cx, e, from_ty, to_ty, arg)
                     | transmute_int_to_bool::check(cx, e, from_ty, to_ty, arg)
                     | transmute_int_to_float::check(cx, e, from_ty, to_ty, arg, const_context)
+                    | transmute_int_to_non_zero::check(cx, e, from_ty, to_ty, arg)
                     | transmute_float_to_int::check(cx, e, from_ty, to_ty, arg, const_context)
                     | transmute_num_to_bytes::check(cx, e, from_ty, to_ty, arg, const_context)
                     | (
diff --git a/clippy_lints/src/transmute/transmute_int_to_non_zero.rs b/clippy_lints/src/transmute/transmute_int_to_non_zero.rs
new file mode 100644
index 00000000000..5503653253c
--- /dev/null
+++ b/clippy_lints/src/transmute/transmute_int_to_non_zero.rs
@@ -0,0 +1,61 @@
+use super::TRANSMUTE_INT_TO_NON_ZERO;
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::sugg;
+use rustc_errors::Applicability;
+use rustc_hir::Expr;
+use rustc_lint::LateContext;
+use rustc_middle::{
+    query::Key,
+    ty::{self, Ty},
+};
+use rustc_span::symbol::sym;
+
+/// Checks for `transmute_int_to_non_zero` lint.
+/// Returns `true` if it's triggered, otherwise returns `false`.
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    e: &'tcx Expr<'_>,
+    from_ty: Ty<'tcx>,
+    to_ty: Ty<'tcx>,
+    arg: &'tcx Expr<'_>,
+) -> bool {
+    let (ty::Int(_) | ty::Uint(_), Some(to_ty_id)) = (&from_ty.kind(), to_ty.ty_adt_id()) else {
+        return false;
+    };
+    let Some(to_type_sym) = cx.tcx.get_diagnostic_name(to_ty_id) else {
+        return false;
+    };
+
+    if !matches!(
+        to_type_sym,
+        sym::NonZeroU8
+            | sym::NonZeroU16
+            | sym::NonZeroU32
+            | sym::NonZeroU64
+            | sym::NonZeroU128
+            | sym::NonZeroI8
+            | sym::NonZeroI16
+            | sym::NonZeroI32
+            | sym::NonZeroI64
+            | sym::NonZeroI128
+    ) {
+        return false;
+    }
+
+    span_lint_and_then(
+        cx,
+        TRANSMUTE_INT_TO_NON_ZERO,
+        e.span,
+        &format!("transmute from a `{from_ty}` to a `{to_type_sym}`"),
+        |diag| {
+            let arg = sugg::Sugg::hir(cx, arg, "..");
+            diag.span_suggestion(
+                e.span,
+                "consider using",
+                format!("{to_type_sym}::{}({arg})", sym::new_unchecked),
+                Applicability::Unspecified,
+            );
+        },
+    );
+    true
+}
diff --git a/tests/ui/transmute_int_to_non_zero.rs b/tests/ui/transmute_int_to_non_zero.rs
new file mode 100644
index 00000000000..a3840678250
--- /dev/null
+++ b/tests/ui/transmute_int_to_non_zero.rs
@@ -0,0 +1,41 @@
+#![warn(clippy::transmute_int_to_non_zero)]
+
+use core::num::*;
+
+fn main() {
+    let int_u8: u8 = 1;
+    let int_u16: u16 = 1;
+    let int_u32: u32 = 1;
+    let int_u64: u64 = 1;
+    let int_u128: u128 = 1;
+
+    let int_i8: i8 = 1;
+    let int_i16: i16 = 1;
+    let int_i32: i32 = 1;
+    let int_i64: i64 = 1;
+    let int_i128: i128 = 1;
+
+    let _: NonZeroU8 = unsafe { std::mem::transmute(int_u8) };
+    let _: NonZeroU16 = unsafe { std::mem::transmute(int_u16) };
+    let _: NonZeroU32 = unsafe { std::mem::transmute(int_u32) };
+    let _: NonZeroU64 = unsafe { std::mem::transmute(int_u64) };
+    let _: NonZeroU128 = unsafe { std::mem::transmute(int_u128) };
+
+    let _: NonZeroI8 = unsafe { std::mem::transmute(int_i8) };
+    let _: NonZeroI16 = unsafe { std::mem::transmute(int_i16) };
+    let _: NonZeroI32 = unsafe { std::mem::transmute(int_i32) };
+    let _: NonZeroI64 = unsafe { std::mem::transmute(int_i64) };
+    let _: NonZeroI128 = unsafe { std::mem::transmute(int_i128) };
+
+    let _: NonZeroU8 = unsafe { NonZeroU8::new_unchecked(int_u8) };
+    let _: NonZeroU16 = unsafe { NonZeroU16::new_unchecked(int_u16) };
+    let _: NonZeroU32 = unsafe { NonZeroU32::new_unchecked(int_u32) };
+    let _: NonZeroU64 = unsafe { NonZeroU64::new_unchecked(int_u64) };
+    let _: NonZeroU128 = unsafe { NonZeroU128::new_unchecked(int_u128) };
+
+    let _: NonZeroI8 = unsafe { NonZeroI8::new_unchecked(int_i8) };
+    let _: NonZeroI16 = unsafe { NonZeroI16::new_unchecked(int_i16) };
+    let _: NonZeroI32 = unsafe { NonZeroI32::new_unchecked(int_i32) };
+    let _: NonZeroI64 = unsafe { NonZeroI64::new_unchecked(int_i64) };
+    let _: NonZeroI128 = unsafe { NonZeroI128::new_unchecked(int_i128) };
+}
diff --git a/tests/ui/transmute_int_to_non_zero.stderr b/tests/ui/transmute_int_to_non_zero.stderr
new file mode 100644
index 00000000000..33f8ce79ea7
--- /dev/null
+++ b/tests/ui/transmute_int_to_non_zero.stderr
@@ -0,0 +1,64 @@
+error: transmute from a `u8` to a `NonZeroU8`
+  --> $DIR/transmute_int_to_non_zero.rs:18:33
+   |
+LL |     let _: NonZeroU8 = unsafe { std::mem::transmute(int_u8) };
+   |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `NonZeroU8::new_unchecked(int_u8)`
+   |
+   = note: `-D clippy::transmute-int-to-non-zero` implied by `-D warnings`
+
+error: transmute from a `u16` to a `NonZeroU16`
+  --> $DIR/transmute_int_to_non_zero.rs:19:34
+   |
+LL |     let _: NonZeroU16 = unsafe { std::mem::transmute(int_u16) };
+   |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `NonZeroU16::new_unchecked(int_u16)`
+
+error: transmute from a `u32` to a `NonZeroU32`
+  --> $DIR/transmute_int_to_non_zero.rs:20:34
+   |
+LL |     let _: NonZeroU32 = unsafe { std::mem::transmute(int_u32) };
+   |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `NonZeroU32::new_unchecked(int_u32)`
+
+error: transmute from a `u64` to a `NonZeroU64`
+  --> $DIR/transmute_int_to_non_zero.rs:21:34
+   |
+LL |     let _: NonZeroU64 = unsafe { std::mem::transmute(int_u64) };
+   |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `NonZeroU64::new_unchecked(int_u64)`
+
+error: transmute from a `u128` to a `NonZeroU128`
+  --> $DIR/transmute_int_to_non_zero.rs:22:35
+   |
+LL |     let _: NonZeroU128 = unsafe { std::mem::transmute(int_u128) };
+   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `NonZeroU128::new_unchecked(int_u128)`
+
+error: transmute from a `i8` to a `NonZeroI8`
+  --> $DIR/transmute_int_to_non_zero.rs:24:33
+   |
+LL |     let _: NonZeroI8 = unsafe { std::mem::transmute(int_i8) };
+   |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `NonZeroI8::new_unchecked(int_i8)`
+
+error: transmute from a `i16` to a `NonZeroI16`
+  --> $DIR/transmute_int_to_non_zero.rs:25:34
+   |
+LL |     let _: NonZeroI16 = unsafe { std::mem::transmute(int_i16) };
+   |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `NonZeroI16::new_unchecked(int_i16)`
+
+error: transmute from a `i32` to a `NonZeroI32`
+  --> $DIR/transmute_int_to_non_zero.rs:26:34
+   |
+LL |     let _: NonZeroI32 = unsafe { std::mem::transmute(int_i32) };
+   |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `NonZeroI32::new_unchecked(int_i32)`
+
+error: transmute from a `i64` to a `NonZeroI64`
+  --> $DIR/transmute_int_to_non_zero.rs:27:34
+   |
+LL |     let _: NonZeroI64 = unsafe { std::mem::transmute(int_i64) };
+   |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `NonZeroI64::new_unchecked(int_i64)`
+
+error: transmute from a `i128` to a `NonZeroI128`
+  --> $DIR/transmute_int_to_non_zero.rs:28:35
+   |
+LL |     let _: NonZeroI128 = unsafe { std::mem::transmute(int_i128) };
+   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `NonZeroI128::new_unchecked(int_i128)`
+
+error: aborting due to 10 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 7e53e27dfdb5ce4cda44912fcc6c288c34ac7d91 Mon Sep 17 00:00:00 2001
From: Krishna Sundarram <krishnasundarram@monzo.com>
Date: Thu, 16 Feb 2023 16:41:04 +0000
Subject: Stop bytes_nth from suggesting code that does not compile

---
 clippy_lints/src/methods/bytes_nth.rs | 42 ++++++++++++++++++++++++-----------
 tests/ui/bytes_nth.fixed              |  6 ++---
 tests/ui/bytes_nth.rs                 |  2 +-
 tests/ui/bytes_nth.stderr             | 10 ++++-----
 4 files changed, 38 insertions(+), 22 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/bytes_nth.rs b/clippy_lints/src/methods/bytes_nth.rs
index d512cc4eeae..c5fc145b289 100644
--- a/clippy_lints/src/methods/bytes_nth.rs
+++ b/clippy_lints/src/methods/bytes_nth.rs
@@ -5,6 +5,8 @@ use rustc_errors::Applicability;
 use rustc_hir::{Expr, LangItem};
 use rustc_lint::LateContext;
 
+use crate::methods::method_call;
+
 use super::BYTES_NTH;
 
 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, recv: &'tcx Expr<'tcx>, n_arg: &'tcx Expr<'tcx>) {
@@ -16,18 +18,32 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, recv: &'tcx E
     } else {
         return;
     };
+
     let mut applicability = Applicability::MachineApplicable;
-    span_lint_and_sugg(
-        cx,
-        BYTES_NTH,
-        expr.span,
-        &format!("called `.bytes().nth()` on a `{caller_type}`"),
-        "try",
-        format!(
-            "{}.as_bytes().get({})",
-            snippet_with_applicability(cx, recv.span, "..", &mut applicability),
-            snippet_with_applicability(cx, n_arg.span, "..", &mut applicability)
-        ),
-        applicability,
-    );
+    let receiver = snippet_with_applicability(cx, recv.span, "..", &mut applicability);
+    let n = snippet_with_applicability(cx, n_arg.span, "..", &mut applicability);
+
+    if let Some(parent) = clippy_utils::get_parent_expr(cx, expr)
+      && let Some((name, _, _, _, _)) = method_call(parent)
+      && name == "unwrap" {
+        span_lint_and_sugg(
+            cx,
+            BYTES_NTH,
+            parent.span,
+            &format!("called `.bytes().nth().unwrap()` on a `{caller_type}`"),
+            "try",
+            format!("{receiver}.as_bytes()[{n}]",),
+            applicability
+        );
+    } else {
+        span_lint_and_sugg(
+            cx,
+            BYTES_NTH,
+            expr.span,
+            &format!("called `.bytes().nth()` on a `{caller_type}`"),
+            "try",
+            format!("{receiver}.as_bytes().get({n}).copied()"), 
+            applicability
+        );
+    };
 }
diff --git a/tests/ui/bytes_nth.fixed b/tests/ui/bytes_nth.fixed
index b1fb2e16bd5..a35c679afb7 100644
--- a/tests/ui/bytes_nth.fixed
+++ b/tests/ui/bytes_nth.fixed
@@ -5,7 +5,7 @@
 
 fn main() {
     let s = String::from("String");
-    let _ = s.as_bytes().get(3);
-    let _ = &s.as_bytes().get(3);
-    let _ = s[..].as_bytes().get(3);
+    let _ = s.as_bytes().get(3).copied();
+    let _ = &s.as_bytes()[3];
+    let _ = s[..].as_bytes().get(3).copied();
 }
diff --git a/tests/ui/bytes_nth.rs b/tests/ui/bytes_nth.rs
index 034c54e6a42..1ecffea5303 100644
--- a/tests/ui/bytes_nth.rs
+++ b/tests/ui/bytes_nth.rs
@@ -6,6 +6,6 @@
 fn main() {
     let s = String::from("String");
     let _ = s.bytes().nth(3);
-    let _ = &s.bytes().nth(3);
+    let _ = &s.bytes().nth(3).unwrap();
     let _ = s[..].bytes().nth(3);
 }
diff --git a/tests/ui/bytes_nth.stderr b/tests/ui/bytes_nth.stderr
index 9851d4791d8..e8b15027829 100644
--- a/tests/ui/bytes_nth.stderr
+++ b/tests/ui/bytes_nth.stderr
@@ -2,21 +2,21 @@ error: called `.bytes().nth()` on a `String`
   --> $DIR/bytes_nth.rs:8:13
    |
 LL |     let _ = s.bytes().nth(3);
-   |             ^^^^^^^^^^^^^^^^ help: try: `s.as_bytes().get(3)`
+   |             ^^^^^^^^^^^^^^^^ help: try: `s.as_bytes().get(3).copied()`
    |
    = note: `-D clippy::bytes-nth` implied by `-D warnings`
 
-error: called `.bytes().nth()` on a `String`
+error: called `.bytes().nth().unwrap()` on a `String`
   --> $DIR/bytes_nth.rs:9:14
    |
-LL |     let _ = &s.bytes().nth(3);
-   |              ^^^^^^^^^^^^^^^^ help: try: `s.as_bytes().get(3)`
+LL |     let _ = &s.bytes().nth(3).unwrap();
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `s.as_bytes()[3]`
 
 error: called `.bytes().nth()` on a `str`
   --> $DIR/bytes_nth.rs:10:13
    |
 LL |     let _ = s[..].bytes().nth(3);
-   |             ^^^^^^^^^^^^^^^^^^^^ help: try: `s[..].as_bytes().get(3)`
+   |             ^^^^^^^^^^^^^^^^^^^^ help: try: `s[..].as_bytes().get(3).copied()`
 
 error: aborting due to 3 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 747f81ecd00a4b6daceb9d7e53c6790498196863 Mon Sep 17 00:00:00 2001
From: Caio <c410.f3r@gmail.com>
Date: Thu, 16 Feb 2023 18:34:33 -0300
Subject: [significant_drop_tightening] Ignore inexpensive statements

---
 clippy_lints/src/significant_drop_tightening.rs | 24 +++++++++++++++++++-----
 tests/ui/significant_drop_tightening.fixed      |  8 ++++++++
 tests/ui/significant_drop_tightening.rs         |  8 ++++++++
 tests/ui/significant_drop_tightening.stderr     |  6 +++---
 4 files changed, 38 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/significant_drop_tightening.rs b/clippy_lints/src/significant_drop_tightening.rs
index 4cc85e38564..367466b7d82 100644
--- a/clippy_lints/src/significant_drop_tightening.rs
+++ b/clippy_lints/src/significant_drop_tightening.rs
@@ -61,6 +61,18 @@ pub struct SignificantDropTightening<'tcx> {
 }
 
 impl<'tcx> SignificantDropTightening<'tcx> {
+    /// Searches for at least one statement that could slow down the release of a significant drop.
+    fn at_least_one_stmt_is_expensive(stmts: &[hir::Stmt<'_>]) -> bool {
+        for stmt in stmts {
+            match stmt.kind {
+                hir::StmtKind::Local(local) if let Some(expr) = local.init
+                    && let hir::ExprKind::Path(_) = expr.kind => {},
+                _ => return true
+            };
+        }
+        false
+    }
+
     /// Verifies if the expression is of type `drop(some_lock_path)` to assert that the temporary
     /// is already being dropped before the end of its scope.
     fn has_drop(expr: &'tcx hir::Expr<'_>, init_bind_ident: Ident) -> bool {
@@ -198,13 +210,15 @@ impl<'tcx> LateLintPass<'tcx> for SignificantDropTightening<'tcx> {
                     }
                     self.modify_sdap_if_sig_drop_exists(cx, expr, idx, &mut sdap, stmt, |_| {});
                 },
-                _ => continue
+                _ => {}
             };
         }
-        if sdap.number_of_stmts > 1 && {
-            let last_stmts_idx = block.stmts.len().wrapping_sub(1);
-            sdap.last_use_stmt_idx != last_stmts_idx
-        } {
+        let stmts_after_last_use = sdap
+            .last_use_stmt_idx
+            .checked_add(1)
+            .and_then(|idx| block.stmts.get(idx..))
+            .unwrap_or_default();
+        if sdap.number_of_stmts > 1 && Self::at_least_one_stmt_is_expensive(stmts_after_last_use) {
             span_lint_and_then(
                 cx,
                 SIGNIFICANT_DROP_TIGHTENING,
diff --git a/tests/ui/significant_drop_tightening.fixed b/tests/ui/significant_drop_tightening.fixed
index 7d56a87053f..5d176d2a927 100644
--- a/tests/ui/significant_drop_tightening.fixed
+++ b/tests/ui/significant_drop_tightening.fixed
@@ -4,6 +4,14 @@
 
 use std::sync::Mutex;
 
+pub fn post_bindings_can_be_ignored() {
+    let mutex = Mutex::new(1);
+    let lock = mutex.lock().unwrap();
+    let rslt = *lock;
+    let another = rslt;
+    let _ = another;
+}
+
 pub fn unnecessary_contention_with_multiple_owned_results() {
     {
         let mutex = Mutex::new(1i32);
diff --git a/tests/ui/significant_drop_tightening.rs b/tests/ui/significant_drop_tightening.rs
index 6f3ce328e5d..be9c0774275 100644
--- a/tests/ui/significant_drop_tightening.rs
+++ b/tests/ui/significant_drop_tightening.rs
@@ -4,6 +4,14 @@
 
 use std::sync::Mutex;
 
+pub fn post_bindings_can_be_ignored() {
+    let mutex = Mutex::new(1);
+    let lock = mutex.lock().unwrap();
+    let rslt = *lock;
+    let another = rslt;
+    let _ = another;
+}
+
 pub fn unnecessary_contention_with_multiple_owned_results() {
     {
         let mutex = Mutex::new(1i32);
diff --git a/tests/ui/significant_drop_tightening.stderr b/tests/ui/significant_drop_tightening.stderr
index 52754aac782..0ec9b1acb59 100644
--- a/tests/ui/significant_drop_tightening.stderr
+++ b/tests/ui/significant_drop_tightening.stderr
@@ -1,5 +1,5 @@
 error: temporary with significant `Drop` can be early dropped
-  --> $DIR/significant_drop_tightening.rs:17:13
+  --> $DIR/significant_drop_tightening.rs:25:13
    |
 LL | /     {
 LL | |         let mutex = Mutex::new(1i32);
@@ -20,7 +20,7 @@ LL +         drop(lock);
    |
 
 error: temporary with significant `Drop` can be early dropped
-  --> $DIR/significant_drop_tightening.rs:38:13
+  --> $DIR/significant_drop_tightening.rs:46:13
    |
 LL | /     {
 LL | |         let mutex = Mutex::new(1i32);
@@ -44,7 +44,7 @@ LL +
    |
 
 error: temporary with significant `Drop` can be early dropped
-  --> $DIR/significant_drop_tightening.rs:44:17
+  --> $DIR/significant_drop_tightening.rs:52:17
    |
 LL | /     {
 LL | |         let mutex = Mutex::new(vec![1i32]);
-- 
cgit 1.4.1-3-g733a5


From c29e767ef1f2afc534c175f16fce5d671943fe4b Mon Sep 17 00:00:00 2001
From: Christian Poveda <git@pvdrz.com>
Date: Fri, 17 Feb 2023 09:09:44 -0500
Subject: Address review comments

---
 clippy_lints/src/missing_doc.rs                      |  2 +-
 clippy_lints/src/utils/conf.rs                       |  3 ++-
 .../pub_crate_missing_docs/pub_crate_missing_doc.rs  |  8 ++++++++
 .../pub_crate_missing_doc.stderr                     | 20 +++++++++++++-------
 4 files changed, 24 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/missing_doc.rs b/clippy_lints/src/missing_doc.rs
index a5d8a500cca..74592918bfc 100644
--- a/clippy_lints/src/missing_doc.rs
+++ b/clippy_lints/src/missing_doc.rs
@@ -103,7 +103,7 @@ impl MissingDoc {
 
         if self.crate_items_only && def_id != CRATE_DEF_ID {
             let vis = cx.tcx.visibility(def_id);
-            if vis != Visibility::Public && vis != Visibility::Restricted(CRATE_DEF_ID.into()) {
+            if vis == Visibility::Public || vis != Visibility::Restricted(CRATE_DEF_ID.into()) {
                 return;
             }
         }
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index ae35ceebc55..c3c73ac6e37 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -456,7 +456,8 @@ define_Conf! {
     (suppress_restriction_lint_in_const: bool = false),
     /// Lint: MISSING_DOCS_IN_PRIVATE_ITEMS.
     ///
-    /// Whether to **only** check for missing documentation in `pub(crate)` items.
+    /// Whether to **only** check for missing documentation in items visible within the current
+    /// crate. For example, `pub(crate)` items.
     (missing_docs_in_crate_items: bool = false),
 }
 
diff --git a/tests/ui-toml/pub_crate_missing_docs/pub_crate_missing_doc.rs b/tests/ui-toml/pub_crate_missing_docs/pub_crate_missing_doc.rs
index f2edb737d59..830d71f61dd 100644
--- a/tests/ui-toml/pub_crate_missing_docs/pub_crate_missing_doc.rs
+++ b/tests/ui-toml/pub_crate_missing_docs/pub_crate_missing_doc.rs
@@ -1,4 +1,5 @@
 //! this is crate
+#![allow(missing_docs)]
 #![warn(clippy::missing_docs_in_private_items)]
 
 /// this is mod
@@ -45,6 +46,13 @@ mod my_mod {
     }
 }
 
+/// some docs
+type CrateTypedefWithDocs = String;
+type CrateTypedefNoDocs = String;
+/// some docs
+pub type PubTypedefWithDocs = String;
+pub type PubTypedefNoDocs = String;
+
 fn main() {
     my_mod::crate_with_docs();
     my_mod::crate_no_docs();
diff --git a/tests/ui-toml/pub_crate_missing_docs/pub_crate_missing_doc.stderr b/tests/ui-toml/pub_crate_missing_docs/pub_crate_missing_doc.stderr
index 89927abd87b..a474187050c 100644
--- a/tests/ui-toml/pub_crate_missing_docs/pub_crate_missing_doc.stderr
+++ b/tests/ui-toml/pub_crate_missing_docs/pub_crate_missing_doc.stderr
@@ -1,5 +1,5 @@
 error: missing documentation for a function
-  --> $DIR/pub_crate_missing_doc.rs:11:5
+  --> $DIR/pub_crate_missing_doc.rs:12:5
    |
 LL |     pub(crate) fn crate_no_docs() {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -7,25 +7,25 @@ LL |     pub(crate) fn crate_no_docs() {}
    = note: `-D clippy::missing-docs-in-private-items` implied by `-D warnings`
 
 error: missing documentation for a function
-  --> $DIR/pub_crate_missing_doc.rs:14:5
+  --> $DIR/pub_crate_missing_doc.rs:15:5
    |
 LL |     pub(super) fn super_no_docs() {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: missing documentation for a function
-  --> $DIR/pub_crate_missing_doc.rs:22:9
+  --> $DIR/pub_crate_missing_doc.rs:23:9
    |
 LL |         pub(crate) fn sub_crate_no_docs() {}
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: missing documentation for a struct field
-  --> $DIR/pub_crate_missing_doc.rs:32:9
+  --> $DIR/pub_crate_missing_doc.rs:33:9
    |
 LL |         pub(crate) crate_field_no_docs: (),
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: missing documentation for a struct
-  --> $DIR/pub_crate_missing_doc.rs:38:5
+  --> $DIR/pub_crate_missing_doc.rs:39:5
    |
 LL | /     pub(crate) struct CrateStructNoDocs {
 LL | |         /// some docs
@@ -37,10 +37,16 @@ LL | |     }
    | |_____^
 
 error: missing documentation for a struct field
-  --> $DIR/pub_crate_missing_doc.rs:41:9
+  --> $DIR/pub_crate_missing_doc.rs:42:9
    |
 LL |         pub(crate) crate_field_no_docs: (),
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 6 previous errors
+error: missing documentation for a type alias
+  --> $DIR/pub_crate_missing_doc.rs:51:1
+   |
+LL | type CrateTypedefNoDocs = String;
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 7 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 75189695011c0c047db3d2eacfbfeb7fb0836aa2 Mon Sep 17 00:00:00 2001
From: Caio <c410.f3r@gmail.com>
Date: Sat, 18 Feb 2023 09:14:41 -0300
Subject: Evaluate the return expression of a block

---
 clippy_lints/src/significant_drop_tightening.rs | 37 +++++++++++++++++++------
 tests/ui/significant_drop_tightening.fixed      | 20 +++++++++++++
 tests/ui/significant_drop_tightening.rs         | 19 +++++++++++++
 tests/ui/significant_drop_tightening.stderr     | 33 ++++++++++++++++++----
 4 files changed, 95 insertions(+), 14 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/significant_drop_tightening.rs b/clippy_lints/src/significant_drop_tightening.rs
index 367466b7d82..e2d90edec5a 100644
--- a/clippy_lints/src/significant_drop_tightening.rs
+++ b/clippy_lints/src/significant_drop_tightening.rs
@@ -61,10 +61,26 @@ pub struct SignificantDropTightening<'tcx> {
 }
 
 impl<'tcx> SignificantDropTightening<'tcx> {
+    /// Unifies the statements of a block with its return expression.
+    fn all_block_stmts<'ret, 'rslt, 'stmts>(
+        block_stmts: &'stmts [hir::Stmt<'tcx>],
+        dummy_ret_stmt: Option<&'ret hir::Stmt<'tcx>>,
+    ) -> impl Iterator<Item = &'rslt hir::Stmt<'tcx>>
+    where
+        'ret: 'rslt,
+        'stmts: 'rslt,
+    {
+        block_stmts.iter().chain(dummy_ret_stmt)
+    }
+
     /// Searches for at least one statement that could slow down the release of a significant drop.
-    fn at_least_one_stmt_is_expensive(stmts: &[hir::Stmt<'_>]) -> bool {
+    fn at_least_one_stmt_is_expensive<'stmt>(stmts: impl Iterator<Item = &'stmt hir::Stmt<'tcx>>) -> bool
+    where
+        'tcx: 'stmt,
+    {
         for stmt in stmts {
             match stmt.kind {
+                hir::StmtKind::Expr(expr) if let hir::ExprKind::Path(_) = expr.kind => {}
                 hir::StmtKind::Local(local) if let Some(expr) = local.init
                     && let hir::ExprKind::Path(_) = expr.kind => {},
                 _ => return true
@@ -99,7 +115,7 @@ impl<'tcx> SignificantDropTightening<'tcx> {
         expr: &'tcx hir::Expr<'_>,
         idx: usize,
         sdap: &mut SigDropAuxParams,
-        stmt: &'tcx hir::Stmt<'_>,
+        stmt: &hir::Stmt<'_>,
         cb: impl Fn(&mut SigDropAuxParams),
     ) {
         let mut sig_drop_finder = SigDropFinder::new(cx, &mut self.seen_types);
@@ -117,7 +133,7 @@ impl<'tcx> SignificantDropTightening<'tcx> {
         }
     }
 
-    /// Shows a generic overall message as well as specialized messages depending on the usage.
+    /// Shows generic overall messages as well as specialized messages depending on the usage.
     fn set_suggestions(cx: &LateContext<'tcx>, block_span: Span, diag: &mut Diagnostic, sdap: &SigDropAuxParams) {
         match sdap.number_of_stmts {
             0 | 1 => {},
@@ -172,8 +188,13 @@ impl<'tcx> SignificantDropTightening<'tcx> {
 
 impl<'tcx> LateLintPass<'tcx> for SignificantDropTightening<'tcx> {
     fn check_block(&mut self, cx: &LateContext<'tcx>, block: &'tcx hir::Block<'_>) {
+        let dummy_ret_stmt = block.expr.map(|expr| hir::Stmt {
+            hir_id: hir::HirId::INVALID,
+            kind: hir::StmtKind::Expr(expr),
+            span: DUMMY_SP,
+        });
         let mut sdap = SigDropAuxParams::default();
-        for (idx, stmt) in block.stmts.iter().enumerate() {
+        for (idx, stmt) in Self::all_block_stmts(block.stmts, dummy_ret_stmt.as_ref()).enumerate() {
             match stmt.kind {
                 hir::StmtKind::Expr(expr) => self.modify_sdap_if_sig_drop_exists(
                     cx,
@@ -213,11 +234,9 @@ impl<'tcx> LateLintPass<'tcx> for SignificantDropTightening<'tcx> {
                 _ => {}
             };
         }
-        let stmts_after_last_use = sdap
-            .last_use_stmt_idx
-            .checked_add(1)
-            .and_then(|idx| block.stmts.get(idx..))
-            .unwrap_or_default();
+
+        let idx = sdap.last_use_stmt_idx.wrapping_add(1);
+        let stmts_after_last_use = Self::all_block_stmts(block.stmts, dummy_ret_stmt.as_ref()).skip(idx);
         if sdap.number_of_stmts > 1 && Self::at_least_one_stmt_is_expensive(stmts_after_last_use) {
             span_lint_and_then(
                 cx,
diff --git a/tests/ui/significant_drop_tightening.fixed b/tests/ui/significant_drop_tightening.fixed
index 5d176d2a927..da998c610bd 100644
--- a/tests/ui/significant_drop_tightening.fixed
+++ b/tests/ui/significant_drop_tightening.fixed
@@ -4,6 +4,26 @@
 
 use std::sync::Mutex;
 
+pub fn complex_return_triggers_the_lint() -> i32 {
+    fn foo() -> i32 {
+        1
+    }
+    let mutex = Mutex::new(1);
+    let lock = mutex.lock().unwrap();
+    let _ = *lock;
+    let _ = *lock;
+    drop(lock);
+    foo()
+}
+
+pub fn path_return_can_be_ignored() -> i32 {
+    let mutex = Mutex::new(1);
+    let lock = mutex.lock().unwrap();
+    let rslt = *lock;
+    let _ = *lock;
+    rslt
+}
+
 pub fn post_bindings_can_be_ignored() {
     let mutex = Mutex::new(1);
     let lock = mutex.lock().unwrap();
diff --git a/tests/ui/significant_drop_tightening.rs b/tests/ui/significant_drop_tightening.rs
index be9c0774275..83823f95f68 100644
--- a/tests/ui/significant_drop_tightening.rs
+++ b/tests/ui/significant_drop_tightening.rs
@@ -4,6 +4,25 @@
 
 use std::sync::Mutex;
 
+pub fn complex_return_triggers_the_lint() -> i32 {
+    fn foo() -> i32 {
+        1
+    }
+    let mutex = Mutex::new(1);
+    let lock = mutex.lock().unwrap();
+    let _ = *lock;
+    let _ = *lock;
+    foo()
+}
+
+pub fn path_return_can_be_ignored() -> i32 {
+    let mutex = Mutex::new(1);
+    let lock = mutex.lock().unwrap();
+    let rslt = *lock;
+    let _ = *lock;
+    rslt
+}
+
 pub fn post_bindings_can_be_ignored() {
     let mutex = Mutex::new(1);
     let lock = mutex.lock().unwrap();
diff --git a/tests/ui/significant_drop_tightening.stderr b/tests/ui/significant_drop_tightening.stderr
index 0ec9b1acb59..ab8ce356ec7 100644
--- a/tests/ui/significant_drop_tightening.stderr
+++ b/tests/ui/significant_drop_tightening.stderr
@@ -1,5 +1,29 @@
 error: temporary with significant `Drop` can be early dropped
-  --> $DIR/significant_drop_tightening.rs:25:13
+  --> $DIR/significant_drop_tightening.rs:12:9
+   |
+LL |   pub fn complex_return_triggers_the_lint() -> i32 {
+   |  __________________________________________________-
+LL | |     fn foo() -> i32 {
+LL | |         1
+LL | |     }
+LL | |     let mutex = Mutex::new(1);
+LL | |     let lock = mutex.lock().unwrap();
+   | |         ^^^^
+...  |
+LL | |     foo()
+LL | | }
+   | |_- temporary `lock` is currently being dropped at the end of its contained scope
+   |
+   = note: this might lead to unnecessary resource contention
+   = note: `-D clippy::significant-drop-tightening` implied by `-D warnings`
+help: drop the temporary after the end of its last usage
+   |
+LL ~     let _ = *lock;
+LL +     drop(lock);
+   |
+
+error: temporary with significant `Drop` can be early dropped
+  --> $DIR/significant_drop_tightening.rs:44:13
    |
 LL | /     {
 LL | |         let mutex = Mutex::new(1i32);
@@ -12,7 +36,6 @@ LL | |     }
    | |_____- temporary `lock` is currently being dropped at the end of its contained scope
    |
    = note: this might lead to unnecessary resource contention
-   = note: `-D clippy::significant-drop-tightening` implied by `-D warnings`
 help: drop the temporary after the end of its last usage
    |
 LL ~         let rslt1 = lock.is_positive();
@@ -20,7 +43,7 @@ LL +         drop(lock);
    |
 
 error: temporary with significant `Drop` can be early dropped
-  --> $DIR/significant_drop_tightening.rs:46:13
+  --> $DIR/significant_drop_tightening.rs:65:13
    |
 LL | /     {
 LL | |         let mutex = Mutex::new(1i32);
@@ -44,7 +67,7 @@ LL +
    |
 
 error: temporary with significant `Drop` can be early dropped
-  --> $DIR/significant_drop_tightening.rs:52:17
+  --> $DIR/significant_drop_tightening.rs:71:17
    |
 LL | /     {
 LL | |         let mutex = Mutex::new(vec![1i32]);
@@ -67,5 +90,5 @@ LL -         lock.clear();
 LL +         
    |
 
-error: aborting due to 3 previous errors
+error: aborting due to 4 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 89fde4abf2c689c0ad5a09cc423a0a7be475d6ee Mon Sep 17 00:00:00 2001
From: blyxyas <blyxyas@gmail.com>
Date: Sat, 18 Feb 2023 20:05:30 +0100
Subject: Add placeholders, remove name suggesting

---
 clippy_lints/src/functions/impl_trait_in_params.rs | 34 ++++------------------
 tests/ui/impl_trait_in_params.stderr               |  8 ++---
 2 files changed, 9 insertions(+), 33 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/functions/impl_trait_in_params.rs b/clippy_lints/src/functions/impl_trait_in_params.rs
index 1f00e357bfa..2811a73f6c1 100644
--- a/clippy_lints/src/functions/impl_trait_in_params.rs
+++ b/clippy_lints/src/functions/impl_trait_in_params.rs
@@ -1,6 +1,6 @@
 use clippy_utils::{diagnostics::span_lint_and_then, is_in_test_function};
 
-use rustc_hir::{intravisit::FnKind, Body, Generics, HirId};
+use rustc_hir::{intravisit::FnKind, Body, HirId};
 use rustc_lint::LateContext;
 use rustc_span::Span;
 
@@ -19,13 +19,12 @@ pub(super) fn check_fn<'tcx>(cx: &LateContext<'_>, kind: &'tcx FnKind<'_>, body:
                         param.span,
                         "'`impl Trait` used as a function parameter'",
                         |diag| {
-                            let next_letter = next_valid_letter(generics);
                             if let Some(gen_span) = generics.span_for_param_suggestion() {
                                 diag.span_suggestion_with_style(
                                     gen_span,
                                     "add a type paremeter",
-                                    format!(", {next_letter}: {}", &param.name.ident().as_str()[5..]),
-                                    rustc_errors::Applicability::MaybeIncorrect,
+                                    format!(", {{ /* Generic name */ }}: {}", &param.name.ident().as_str()[5..]),
+                                    rustc_errors::Applicability::HasPlaceholders,
                                     rustc_errors::SuggestionStyle::ShowAlways,
                                 );
                             } else {
@@ -37,8 +36,8 @@ pub(super) fn check_fn<'tcx>(cx: &LateContext<'_>, kind: &'tcx FnKind<'_>, body:
                                         ident.span.parent(),
                                     ),
                                     "add a type paremeter",
-                                    format!("<{next_letter}: {}>", &param.name.ident().as_str()[5..]),
-                                    rustc_errors::Applicability::MaybeIncorrect,
+                                    format!("<{{ /* Generic name */ }}: {}>", &param.name.ident().as_str()[5..]),
+                                    rustc_errors::Applicability::HasPlaceholders,
                                     rustc_errors::SuggestionStyle::ShowAlways,
                                 );
                             }
@@ -49,26 +48,3 @@ pub(super) fn check_fn<'tcx>(cx: &LateContext<'_>, kind: &'tcx FnKind<'_>, body:
         }
     }
 }
-
-fn next_valid_letter(generics: &Generics<'_>) -> char {
-    let mut generics_names = Vec::new();
-
-    generics.params.iter().for_each(|param| {
-        generics_names.push(param.name.ident().as_str().to_owned());
-    });
-
-    // If T exists, try with U, then with V, and so on...
-    let mut current_letter = 84u32; // ASCII code for "T"
-    while generics_names.contains(&String::from(char::from_u32(current_letter).unwrap())) {
-        current_letter += 1;
-        if current_letter == 91 {
-            // ASCII code for "Z"
-            current_letter = 65;
-        } else if current_letter == 83 {
-            // ASCII "S"
-            current_letter = 97; // "a"
-        };
-    }
-
-    char::from_u32(current_letter).unwrap()
-}
diff --git a/tests/ui/impl_trait_in_params.stderr b/tests/ui/impl_trait_in_params.stderr
index c0bcdfd6d42..acfcc21445e 100644
--- a/tests/ui/impl_trait_in_params.stderr
+++ b/tests/ui/impl_trait_in_params.stderr
@@ -7,8 +7,8 @@ LL | pub fn a(_: impl Trait) {}
    = note: `-D clippy::impl-trait-in-params` implied by `-D warnings`
 help: add a type paremeter
    |
-LL | pub fn a<T: Trait>(_: impl Trait) {}
-   |         ++++++++++
+LL | pub fn a<{ /* Generic name */ }: Trait>(_: impl Trait) {}
+   |         +++++++++++++++++++++++++++++++
 
 error: '`impl Trait` used as a function parameter'
   --> $DIR/impl_trait_in_params.rs:9:29
@@ -18,8 +18,8 @@ LL | pub fn c<C: Trait>(_: C, _: impl Trait) {}
    |
 help: add a type paremeter
    |
-LL | pub fn c<C: Trait, T: Trait>(_: C, _: impl Trait) {}
-   |                  ++++++++++
+LL | pub fn c<C: Trait, { /* Generic name */ }: Trait>(_: C, _: impl Trait) {}
+   |                  +++++++++++++++++++++++++++++++
 
 error: aborting due to 2 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From f531abcef52c3c3ab283eb82a9487d5e9192bf12 Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Sun, 19 Feb 2023 11:54:12 +0100
Subject: Do not suggest using Self in const generic parameters

---
 clippy_lints/src/use_self.rs | 15 +++++++++++----
 tests/ui/use_self.fixed      | 10 ++++++++++
 tests/ui/use_self.rs         | 10 ++++++++++
 3 files changed, 31 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/use_self.rs b/clippy_lints/src/use_self.rs
index 3cd35838961..8f2b4a7eafb 100644
--- a/clippy_lints/src/use_self.rs
+++ b/clippy_lints/src/use_self.rs
@@ -10,8 +10,8 @@ use rustc_hir::{
     def::{CtorOf, DefKind, Res},
     def_id::LocalDefId,
     intravisit::{walk_inf, walk_ty, Visitor},
-    Expr, ExprKind, FnRetTy, FnSig, GenericArg, HirId, Impl, ImplItemKind, Item, ItemKind, Pat, PatKind, Path, QPath,
-    TyKind,
+    Expr, ExprKind, FnRetTy, FnSig, GenericArg, GenericParam, GenericParamKind, HirId, Impl, ImplItemKind, Item,
+    ItemKind, Pat, PatKind, Path, QPath, Ty, TyKind,
 };
 use rustc_hir_analysis::hir_ty_to_ty;
 use rustc_lint::{LateContext, LateLintPass};
@@ -96,7 +96,7 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
         // avoid linting on nested items, we push `StackItem::NoCheck` on the stack to signal, that
         // we're in an `impl` or nested item, that we don't want to lint
         let stack_item = if_chain! {
-            if let ItemKind::Impl(Impl { self_ty, .. }) = item.kind;
+            if let ItemKind::Impl(Impl { self_ty, generics,.. }) = item.kind;
             if let TyKind::Path(QPath::Resolved(_, item_path)) = self_ty.kind;
             let parameters = &item_path.segments.last().expect(SEGMENTS_MSG).args;
             if parameters.as_ref().map_or(true, |params| {
@@ -105,10 +105,17 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
             if !item.span.from_expansion();
             if !is_from_proc_macro(cx, item); // expensive, should be last check
             then {
+                // Self cannot be used inside const generic parameters
+                let types_to_skip = generics.params.iter().filter_map(|param| {
+                    match param {
+                        GenericParam { kind: GenericParamKind::Const { ty: Ty { hir_id, ..}, ..}, ..} => Some(*hir_id),
+                        _ => None,
+                    }
+                }).chain(std::iter::once(self_ty.hir_id)).collect();
                 StackItem::Check {
                     impl_id: item.owner_id.def_id,
                     in_body: 0,
-                    types_to_skip: std::iter::once(self_ty.hir_id).collect(),
+                    types_to_skip,
                 }
             } else {
                 StackItem::NoCheck
diff --git a/tests/ui/use_self.fixed b/tests/ui/use_self.fixed
index 0a6166571eb..3ac6217312a 100644
--- a/tests/ui/use_self.fixed
+++ b/tests/ui/use_self.fixed
@@ -647,3 +647,13 @@ fn msrv_1_37() {
         }
     }
 }
+
+mod issue_10371 {
+    struct Val<const V: i32> {}
+
+    impl<const V: i32> From<Val<V>> for i32 {
+        fn from(_: Val<V>) -> Self {
+            todo!()
+        }
+    }
+}
diff --git a/tests/ui/use_self.rs b/tests/ui/use_self.rs
index 39c2b431f7f..9dc5d1e3f9b 100644
--- a/tests/ui/use_self.rs
+++ b/tests/ui/use_self.rs
@@ -647,3 +647,13 @@ fn msrv_1_37() {
         }
     }
 }
+
+mod issue_10371 {
+    struct Val<const V: i32> {}
+
+    impl<const V: i32> From<Val<V>> for i32 {
+        fn from(_: Val<V>) -> Self {
+            todo!()
+        }
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 09058388dec7b62680fd3d33df4b416d84975884 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Mon, 20 Feb 2023 09:47:05 +0000
Subject: Ignore lifetimes from differing contexts in `needless_lifetimes`

---
 clippy_lints/src/lifetimes.rs     |  8 ++++++++
 tests/ui/needless_lifetimes.fixed | 10 ++++++++++
 tests/ui/needless_lifetimes.rs    | 10 ++++++++++
 3 files changed, 28 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lifetimes.rs b/clippy_lints/src/lifetimes.rs
index 43a1a65a43a..986ffcad883 100644
--- a/clippy_lints/src/lifetimes.rs
+++ b/clippy_lints/src/lifetimes.rs
@@ -144,6 +144,10 @@ fn check_fn_inner<'tcx>(
         .filter(|param| matches!(param.kind, GenericParamKind::Type { .. }));
 
     for typ in types {
+        if !typ.span.eq_ctxt(span) {
+            return;
+        }
+
         for pred in generics.bounds_for_param(typ.def_id) {
             if pred.origin == PredicateOrigin::WhereClause {
                 // has_where_lifetimes checked that this predicate contains no lifetime.
@@ -181,6 +185,10 @@ fn check_fn_inner<'tcx>(
     }
 
     if let Some((elidable_lts, usages)) = could_use_elision(cx, sig.decl, body, trait_sig, generics.params) {
+        if usages.iter().any(|usage| !usage.ident.span.eq_ctxt(span)) {
+            return;
+        }
+
         let lts = elidable_lts
             .iter()
             // In principle, the result of the call to `Node::ident` could be `unwrap`ped, as `DefId` should refer to a
diff --git a/tests/ui/needless_lifetimes.fixed b/tests/ui/needless_lifetimes.fixed
index d286ef4ba37..f0f1f9298ac 100644
--- a/tests/ui/needless_lifetimes.fixed
+++ b/tests/ui/needless_lifetimes.fixed
@@ -516,6 +516,16 @@ mod in_macro {
 
     // no lint on external macro
     macro_rules::needless_lifetime!();
+
+    macro_rules! expanded_lifetime {
+        ($l:lifetime) => {
+            fn f<$l>(arg: &$l str) -> &$l str {
+                arg
+            }
+        }
+    }
+
+    expanded_lifetime!('a);
 }
 
 mod issue5787 {
diff --git a/tests/ui/needless_lifetimes.rs b/tests/ui/needless_lifetimes.rs
index 409528b291d..ddfd1043003 100644
--- a/tests/ui/needless_lifetimes.rs
+++ b/tests/ui/needless_lifetimes.rs
@@ -516,6 +516,16 @@ mod in_macro {
 
     // no lint on external macro
     macro_rules::needless_lifetime!();
+
+    macro_rules! expanded_lifetime {
+        ($l:lifetime) => {
+            fn f<$l>(arg: &$l str) -> &$l str {
+                arg
+            }
+        }
+    }
+
+    expanded_lifetime!('a);
 }
 
 mod issue5787 {
-- 
cgit 1.4.1-3-g733a5


From 92c403c9b01e213ad9b5a003d9c3c289abc653f1 Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Sun, 19 Feb 2023 19:25:53 +0100
Subject: Box::default(): do not omit the type of the removed trait object

Within a larger expression, when the type of `Box::new(T::default())` is
`Box<dyn Trait>`, the concrete type `T` cannot be omitted in the
proposed replacement `Box::<T>::default()`.
---
 clippy_lints/src/box_default.rs |  3 ++-
 tests/ui/box_default.fixed      | 18 ++++++++++++++++++
 tests/ui/box_default.rs         | 18 ++++++++++++++++++
 tests/ui/box_default.stderr     | 14 ++++++++++----
 4 files changed, 48 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/box_default.rs b/clippy_lints/src/box_default.rs
index 9d98a6bab71..dfa949d1af2 100644
--- a/clippy_lints/src/box_default.rs
+++ b/clippy_lints/src/box_default.rs
@@ -117,7 +117,8 @@ fn given_type(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
         ) => {
             if let Some(index) = args.iter().position(|arg| arg.hir_id == expr.hir_id) &&
                 let Some(sig) = expr_sig(cx, path) &&
-                let Some(input) = sig.input(index)
+                let Some(input) = sig.input(index) &&
+                !cx.typeck_results().expr_ty_adjusted(expr).boxed_ty().is_trait()
             {
                 input.no_bound_vars().is_some()
             } else {
diff --git a/tests/ui/box_default.fixed b/tests/ui/box_default.fixed
index 7e9f074fdca..59c0baf8718 100644
--- a/tests/ui/box_default.fixed
+++ b/tests/ui/box_default.fixed
@@ -33,6 +33,7 @@ fn main() {
     let _vec4: Box<_> = Box::<Vec<bool>>::default();
     let _more = ret_ty_fn();
     call_ty_fn(Box::default());
+    issue_10381();
 }
 
 fn ret_ty_fn() -> Box<bool> {
@@ -65,3 +66,20 @@ fn issue_10089() {
         let _ = Box::<WeirdPathed>::default();
     };
 }
+
+fn issue_10381() {
+    #[derive(Default)]
+    pub struct Foo {}
+    pub trait Bar {}
+    impl Bar for Foo {}
+
+    fn maybe_get_bar(i: u32) -> Option<Box<dyn Bar>> {
+        if i % 2 == 0 {
+            Some(Box::<Foo>::default())
+        } else {
+            None
+        }
+    }
+
+    assert!(maybe_get_bar(2).is_some());
+}
diff --git a/tests/ui/box_default.rs b/tests/ui/box_default.rs
index 5c8d0b8354c..f7d832193a3 100644
--- a/tests/ui/box_default.rs
+++ b/tests/ui/box_default.rs
@@ -33,6 +33,7 @@ fn main() {
     let _vec4: Box<_> = Box::new(Vec::from([false; 0]));
     let _more = ret_ty_fn();
     call_ty_fn(Box::new(u8::default()));
+    issue_10381();
 }
 
 fn ret_ty_fn() -> Box<bool> {
@@ -65,3 +66,20 @@ fn issue_10089() {
         let _ = Box::new(WeirdPathed::default());
     };
 }
+
+fn issue_10381() {
+    #[derive(Default)]
+    pub struct Foo {}
+    pub trait Bar {}
+    impl Bar for Foo {}
+
+    fn maybe_get_bar(i: u32) -> Option<Box<dyn Bar>> {
+        if i % 2 == 0 {
+            Some(Box::new(Foo::default()))
+        } else {
+            None
+        }
+    }
+
+    assert!(maybe_get_bar(2).is_some());
+}
diff --git a/tests/ui/box_default.stderr b/tests/ui/box_default.stderr
index 249eb340f96..78e17b9f035 100644
--- a/tests/ui/box_default.stderr
+++ b/tests/ui/box_default.stderr
@@ -73,22 +73,28 @@ LL |     call_ty_fn(Box::new(u8::default()));
    |                ^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Box::default()`
 
 error: `Box::new(_)` of default value
-  --> $DIR/box_default.rs:39:5
+  --> $DIR/box_default.rs:40:5
    |
 LL |     Box::new(bool::default())
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Box::<bool>::default()`
 
 error: `Box::new(_)` of default value
-  --> $DIR/box_default.rs:56:28
+  --> $DIR/box_default.rs:57:28
    |
 LL |     let _: Box<dyn Read> = Box::new(ImplementsDefault::default());
    |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Box::<ImplementsDefault>::default()`
 
 error: `Box::new(_)` of default value
-  --> $DIR/box_default.rs:65:17
+  --> $DIR/box_default.rs:66:17
    |
 LL |         let _ = Box::new(WeirdPathed::default());
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Box::<WeirdPathed>::default()`
 
-error: aborting due to 15 previous errors
+error: `Box::new(_)` of default value
+  --> $DIR/box_default.rs:78:18
+   |
+LL |             Some(Box::new(Foo::default()))
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Box::<Foo>::default()`
+
+error: aborting due to 16 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 790f28b1533cbc1aec7ee343b98ea5d570f9928e Mon Sep 17 00:00:00 2001
From: Christian Poveda <git@pvdrz.com>
Date: Mon, 20 Feb 2023 09:34:49 -0500
Subject: Update documentation

---
 book/src/lint_configuration.md  | 3 ++-
 clippy_lints/src/missing_doc.rs | 3 ++-
 2 files changed, 4 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/book/src/lint_configuration.md b/book/src/lint_configuration.md
index 46bed62dfc9..f74431bee82 100644
--- a/book/src/lint_configuration.md
+++ b/book/src/lint_configuration.md
@@ -542,7 +542,8 @@ if no suggestion can be made.
 
 
 ### missing-docs-in-crate-items
-Whether to **only** check for missing documentation in `pub(crate)` items.
+Whether to **only** check for missing documentation in items visible within the current
+crate. For example, `pub(crate)` items.
 
 **Default Value:** `false` (`bool`)
 
diff --git a/clippy_lints/src/missing_doc.rs b/clippy_lints/src/missing_doc.rs
index 74592918bfc..9659ca8ced2 100644
--- a/clippy_lints/src/missing_doc.rs
+++ b/clippy_lints/src/missing_doc.rs
@@ -36,7 +36,8 @@ declare_clippy_lint! {
 }
 
 pub struct MissingDoc {
-    /// Whether to only check for missing docs in `pub(crate)` items.
+    /// Whether to **only** check for missing documentation in items visible within the current
+    /// crate. For example, `pub(crate)` items.
     crate_items_only: bool,
     /// Stack of whether #[doc(hidden)] is set
     /// at each level which has lint attributes.
-- 
cgit 1.4.1-3-g733a5


From 0aad34e43fc3c16d880790f521a2aabce0a62121 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Tue, 21 Feb 2023 15:47:24 -0500
Subject: Normalize projections types when checking `explicit_auto_deref`

---
 clippy_lints/src/dereference.rs    | 78 +++++++++++++++++++++++++++-----------
 clippy_utils/src/ty.rs             | 25 +++++++++---
 tests/ui/explicit_auto_deref.fixed | 14 +++++++
 tests/ui/explicit_auto_deref.rs    | 14 +++++++
 4 files changed, 102 insertions(+), 29 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index 6c333afacc6..b2ed8121994 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -3,7 +3,7 @@ use clippy_utils::mir::{enclosing_mir, expr_local, local_assignments, used_exact
 use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::{snippet_with_applicability, snippet_with_context};
 use clippy_utils::sugg::has_enclosing_paren;
-use clippy_utils::ty::{expr_sig, is_copy, peel_mid_ty_refs, ty_sig, variant_of_res};
+use clippy_utils::ty::{adt_and_variant_of_res, expr_sig, is_copy, peel_mid_ty_refs, ty_sig};
 use clippy_utils::{
     fn_def_id, get_parent_expr, get_parent_expr_for_hir, is_lint_allowed, path_to_local, walk_to_expr_usage,
 };
@@ -26,8 +26,8 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::mir::{Rvalue, StatementKind};
 use rustc_middle::ty::adjustment::{Adjust, Adjustment, AutoBorrow, AutoBorrowMutability};
 use rustc_middle::ty::{
-    self, Binder, BoundVariableKind, Clause, EarlyBinder, FnSig, GenericArgKind, List, ParamTy, PredicateKind,
-    ProjectionPredicate, Ty, TyCtxt, TypeVisitable, TypeckResults,
+    self, Binder, BoundVariableKind, Clause, EarlyBinder, FnSig, GenericArgKind, List, ParamEnv, ParamTy,
+    PredicateKind, ProjectionPredicate, Ty, TyCtxt, TypeVisitable, TypeckResults,
 };
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::{symbol::sym, Span, Symbol};
@@ -736,7 +736,7 @@ fn walk_parents<'tcx>(
                 ..
             }) if span.ctxt() == ctxt => {
                 let ty = cx.tcx.type_of(owner_id.def_id);
-                Some(ty_auto_deref_stability(cx, ty, precedence).position_for_result(cx))
+                Some(ty_auto_deref_stability(cx.tcx, cx.param_env, ty, precedence).position_for_result(cx))
             },
 
             Node::Item(&Item {
@@ -760,7 +760,7 @@ fn walk_parents<'tcx>(
                 let output = cx
                     .tcx
                     .erase_late_bound_regions(cx.tcx.fn_sig(owner_id).subst_identity().output());
-                Some(ty_auto_deref_stability(cx, output, precedence).position_for_result(cx))
+                Some(ty_auto_deref_stability(cx.tcx, cx.param_env, output, precedence).position_for_result(cx))
             },
 
             Node::ExprField(field) if field.span.ctxt() == ctxt => match get_parent_expr_for_hir(cx, field.hir_id) {
@@ -768,10 +768,23 @@ fn walk_parents<'tcx>(
                     hir_id,
                     kind: ExprKind::Struct(path, ..),
                     ..
-                }) => variant_of_res(cx, cx.qpath_res(path, *hir_id))
-                    .and_then(|variant| variant.fields.iter().find(|f| f.name == field.ident.name))
-                    .map(|field_def| {
-                        ty_auto_deref_stability(cx, cx.tcx.type_of(field_def.did), precedence).position_for_arg()
+                }) => adt_and_variant_of_res(cx, cx.qpath_res(path, *hir_id))
+                    .and_then(|(adt, variant)| {
+                        variant
+                            .fields
+                            .iter()
+                            .find(|f| f.name == field.ident.name)
+                            .map(|f| (adt, f))
+                    })
+                    .map(|(adt, field_def)| {
+                        ty_auto_deref_stability(
+                            cx.tcx,
+                            // Use the param_env of the target type.
+                            cx.tcx.param_env(adt.did()),
+                            cx.tcx.type_of(field_def.did),
+                            precedence,
+                        )
+                        .position_for_arg()
                     }),
                 _ => None,
             },
@@ -792,7 +805,7 @@ fn walk_parents<'tcx>(
                             let output = cx
                                 .tcx
                                 .erase_late_bound_regions(cx.tcx.fn_sig(owner_id).subst_identity().output());
-                            ty_auto_deref_stability(cx, output, precedence).position_for_result(cx)
+                            ty_auto_deref_stability(cx.tcx, cx.param_env, output, precedence).position_for_result(cx)
                         },
                     )
                 },
@@ -835,15 +848,20 @@ fn walk_parents<'tcx>(
                                             msrv,
                                         )
                                     } else {
-                                        ty_auto_deref_stability(cx, cx.tcx.erase_late_bound_regions(ty), precedence)
-                                            .position_for_arg()
+                                        ty_auto_deref_stability(
+                                            cx.tcx,
+                                            // Use the param_env of the target function.
+                                            sig.predicates_id().map_or(ParamEnv::empty(), |id| cx.tcx.param_env(id)),
+                                            cx.tcx.erase_late_bound_regions(ty),
+                                            precedence
+                                        ).position_for_arg()
                                     }
                                 },
                             }
                         })
                     }),
                 ExprKind::MethodCall(method, receiver, args, _) => {
-                    let id = cx.typeck_results().type_dependent_def_id(parent.hir_id).unwrap();
+                    let fn_id = cx.typeck_results().type_dependent_def_id(parent.hir_id).unwrap();
                     if receiver.hir_id == child_id {
                         // Check for calls to trait methods where the trait is implemented on a reference.
                         // Two cases need to be handled:
@@ -852,13 +870,17 @@ fn walk_parents<'tcx>(
                         //   priority.
                         if e.hir_id != child_id {
                             return Some(Position::ReborrowStable(precedence))
-                        } else if let Some(trait_id) = cx.tcx.trait_of_item(id)
+                        } else if let Some(trait_id) = cx.tcx.trait_of_item(fn_id)
                             && let arg_ty = cx.tcx.erase_regions(cx.typeck_results().expr_ty_adjusted(e))
                             && let ty::Ref(_, sub_ty, _) = *arg_ty.kind()
                             && let subs = cx
                                 .typeck_results()
                                 .node_substs_opt(parent.hir_id).map(|subs| &subs[1..]).unwrap_or_default()
-                            && let impl_ty = if cx.tcx.fn_sig(id).subst_identity().skip_binder().inputs()[0].is_ref() {
+                            && let impl_ty = if cx.tcx.fn_sig(fn_id)
+                                .subst_identity()
+                                .skip_binder()
+                                .inputs()[0].is_ref()
+                            {
                                 // Trait methods taking `&self`
                                 sub_ty
                             } else {
@@ -879,10 +901,13 @@ fn walk_parents<'tcx>(
                         return Some(Position::MethodReceiver);
                     }
                     args.iter().position(|arg| arg.hir_id == child_id).map(|i| {
-                        let ty = cx.tcx.fn_sig(id).subst_identity().skip_binder().inputs()[i + 1];
+                        let ty = cx.tcx.fn_sig(fn_id).subst_identity().input(i + 1);
                         // `e.hir_id == child_id` for https://github.com/rust-lang/rust-clippy/issues/9739
                         // `method.args.is_none()` for https://github.com/rust-lang/rust-clippy/issues/9782
-                        if e.hir_id == child_id && method.args.is_none() && let ty::Param(param_ty) = ty.kind() {
+                        if e.hir_id == child_id
+                            && method.args.is_none()
+                            && let ty::Param(param_ty) = ty.skip_binder().kind()
+                        {
                             needless_borrow_impl_arg_position(
                                 cx,
                                 possible_borrowers,
@@ -895,8 +920,10 @@ fn walk_parents<'tcx>(
                             )
                         } else {
                             ty_auto_deref_stability(
-                                cx,
-                                cx.tcx.erase_late_bound_regions(cx.tcx.fn_sig(id).subst_identity().input(i + 1)),
+                                cx.tcx,
+                                // Use the param_env of the target function.
+                                cx.tcx.param_env(fn_id),
+                                cx.tcx.erase_late_bound_regions(ty),
                                 precedence,
                             )
                             .position_for_arg()
@@ -1378,11 +1405,18 @@ impl<'tcx> TyPosition<'tcx> {
 }
 
 // Checks whether a type is stable when switching to auto dereferencing,
-fn ty_auto_deref_stability<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>, precedence: i8) -> TyPosition<'tcx> {
+fn ty_auto_deref_stability<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    param_env: ParamEnv<'tcx>,
+    ty: Ty<'tcx>,
+    precedence: i8,
+) -> TyPosition<'tcx> {
     let ty::Ref(_, mut ty, _) = *ty.kind() else {
         return Position::Other(precedence).into();
     };
 
+    ty = tcx.try_normalize_erasing_regions(param_env, ty).unwrap_or(ty);
+
     loop {
         break match *ty.kind() {
             ty::Ref(_, ref_ty, _) => {
@@ -1423,9 +1457,7 @@ fn ty_auto_deref_stability<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>, precedenc
             | ty::Closure(..)
             | ty::Never
             | ty::Tuple(_)
-            | ty::Alias(ty::Projection, _) => {
-                Position::DerefStable(precedence, ty.is_sized(cx.tcx, cx.param_env.without_caller_bounds())).into()
-            },
+            | ty::Alias(ty::Projection, _) => Position::DerefStable(precedence, ty.is_sized(tcx, param_env)).into(),
         };
     }
 }
diff --git a/clippy_utils/src/ty.rs b/clippy_utils/src/ty.rs
index c48d27b05f0..99ebfa8febc 100644
--- a/clippy_utils/src/ty.rs
+++ b/clippy_utils/src/ty.rs
@@ -894,16 +894,29 @@ impl AdtVariantInfo {
 }
 
 /// Gets the struct or enum variant from the given `Res`
-pub fn variant_of_res<'tcx>(cx: &LateContext<'tcx>, res: Res) -> Option<&'tcx VariantDef> {
+pub fn adt_and_variant_of_res<'tcx>(cx: &LateContext<'tcx>, res: Res) -> Option<(AdtDef<'tcx>, &'tcx VariantDef)> {
     match res {
-        Res::Def(DefKind::Struct, id) => Some(cx.tcx.adt_def(id).non_enum_variant()),
-        Res::Def(DefKind::Variant, id) => Some(cx.tcx.adt_def(cx.tcx.parent(id)).variant_with_id(id)),
-        Res::Def(DefKind::Ctor(CtorOf::Struct, _), id) => Some(cx.tcx.adt_def(cx.tcx.parent(id)).non_enum_variant()),
+        Res::Def(DefKind::Struct, id) => {
+            let adt = cx.tcx.adt_def(id);
+            Some((adt, adt.non_enum_variant()))
+        },
+        Res::Def(DefKind::Variant, id) => {
+            let adt = cx.tcx.adt_def(cx.tcx.parent(id));
+            Some((adt, adt.variant_with_id(id)))
+        },
+        Res::Def(DefKind::Ctor(CtorOf::Struct, _), id) => {
+            let adt = cx.tcx.adt_def(cx.tcx.parent(id));
+            Some((adt, adt.non_enum_variant()))
+        },
         Res::Def(DefKind::Ctor(CtorOf::Variant, _), id) => {
             let var_id = cx.tcx.parent(id);
-            Some(cx.tcx.adt_def(cx.tcx.parent(var_id)).variant_with_id(var_id))
+            let adt = cx.tcx.adt_def(cx.tcx.parent(var_id));
+            Some((adt, adt.variant_with_id(var_id)))
+        },
+        Res::SelfCtor(id) => {
+            let adt = cx.tcx.type_of(id).ty_adt_def().unwrap();
+            Some((adt, adt.non_enum_variant()))
         },
-        Res::SelfCtor(id) => Some(cx.tcx.type_of(id).ty_adt_def().unwrap().non_enum_variant()),
         _ => None,
     }
 }
diff --git a/tests/ui/explicit_auto_deref.fixed b/tests/ui/explicit_auto_deref.fixed
index 475fae5e823..5d40c850424 100644
--- a/tests/ui/explicit_auto_deref.fixed
+++ b/tests/ui/explicit_auto_deref.fixed
@@ -269,6 +269,9 @@ fn main() {
 
     trait WithAssoc {
         type Assoc: ?Sized;
+        fn to_assoc(&self) -> &Self::Assoc {
+            panic!()
+        }
     }
     impl WithAssoc for String {
         type Assoc = str;
@@ -281,4 +284,15 @@ fn main() {
     // Issue #9901
     fn takes_ref(_: &i32) {}
     takes_ref(*Box::new(&0i32));
+
+    // Issue #10384
+    impl<'a> WithAssoc for &'a u32 {
+        type Assoc = dyn core::fmt::Display;
+        fn to_assoc(&self) -> &Self::Assoc {
+            *self
+        }
+    }
+    fn return_dyn_assoc<'a>(x: &'a &'a u32) -> &'a <&'a u32 as WithAssoc>::Assoc {
+        *x
+    }
 }
diff --git a/tests/ui/explicit_auto_deref.rs b/tests/ui/explicit_auto_deref.rs
index c1894258f4d..79e03f4d76c 100644
--- a/tests/ui/explicit_auto_deref.rs
+++ b/tests/ui/explicit_auto_deref.rs
@@ -269,6 +269,9 @@ fn main() {
 
     trait WithAssoc {
         type Assoc: ?Sized;
+        fn to_assoc(&self) -> &Self::Assoc {
+            panic!()
+        }
     }
     impl WithAssoc for String {
         type Assoc = str;
@@ -281,4 +284,15 @@ fn main() {
     // Issue #9901
     fn takes_ref(_: &i32) {}
     takes_ref(*Box::new(&0i32));
+
+    // Issue #10384
+    impl<'a> WithAssoc for &'a u32 {
+        type Assoc = dyn core::fmt::Display;
+        fn to_assoc(&self) -> &Self::Assoc {
+            *self
+        }
+    }
+    fn return_dyn_assoc<'a>(x: &'a &'a u32) -> &'a <&'a u32 as WithAssoc>::Assoc {
+        *x
+    }
 }
-- 
cgit 1.4.1-3-g733a5


From 72e773f6a8bca1a4aaec6866ed995eaa0fd05cb2 Mon Sep 17 00:00:00 2001
From: Liu Dingming <liudingming@bytedance.com>
Date: Wed, 22 Feb 2023 21:30:42 +0800
Subject: Fix test function checker in [unwrap_used], [expect_used]

---
 clippy_lints/src/methods/expect_used.rs | 4 ++--
 clippy_lints/src/methods/unwrap_used.rs | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/expect_used.rs b/clippy_lints/src/methods/expect_used.rs
index cce8f797e98..9e370de0a05 100644
--- a/clippy_lints/src/methods/expect_used.rs
+++ b/clippy_lints/src/methods/expect_used.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_help;
-use clippy_utils::is_in_cfg_test;
+use clippy_utils::{is_in_cfg_test, is_in_test_function};
 use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
@@ -27,7 +27,7 @@ pub(super) fn check(
 
     let method = if is_err { "expect_err" } else { "expect" };
 
-    if allow_expect_in_tests && is_in_cfg_test(cx.tcx, expr.hir_id) {
+    if allow_expect_in_tests && (is_in_test_function(cx.tcx, expr.hir_id) || is_in_cfg_test(cx.tcx, expr.hir_id)) {
         return;
     }
 
diff --git a/clippy_lints/src/methods/unwrap_used.rs b/clippy_lints/src/methods/unwrap_used.rs
index 90983f249cd..5e4c3daee64 100644
--- a/clippy_lints/src/methods/unwrap_used.rs
+++ b/clippy_lints/src/methods/unwrap_used.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{is_in_cfg_test, is_lint_allowed};
+use clippy_utils::{is_in_cfg_test, is_in_test_function, is_lint_allowed};
 use rustc_hir as hir;
 use rustc_lint::LateContext;
 use rustc_span::sym;
@@ -27,7 +27,7 @@ pub(super) fn check(
 
     let method_suffix = if is_err { "_err" } else { "" };
 
-    if allow_unwrap_in_tests && is_in_cfg_test(cx.tcx, expr.hir_id) {
+    if allow_unwrap_in_tests && (is_in_test_function(cx.tcx, expr.hir_id) || is_in_cfg_test(cx.tcx, expr.hir_id)) {
         return;
     }
 
-- 
cgit 1.4.1-3-g733a5


From b9c617a1b79eefb63916b64b2942138aa08d6e30 Mon Sep 17 00:00:00 2001
From: Liu Dingming <liudingming@bytedance.com>
Date: Wed, 22 Feb 2023 21:36:16 +0800
Subject: correct comments

---
 clippy_lints/src/utils/conf.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index c3c73ac6e37..5f74de5a288 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -419,19 +419,19 @@ define_Conf! {
     (max_include_file_size: u64 = 1_000_000),
     /// Lint: EXPECT_USED.
     ///
-    /// Whether `expect` should be allowed within `#[cfg(test)]`
+    /// Whether `expect` should be allowed in test functions or `#[cfg(test)]`
     (allow_expect_in_tests: bool = false),
     /// Lint: UNWRAP_USED.
     ///
-    /// Whether `unwrap` should be allowed in test cfg
+    /// Whether `unwrap` should be allowed in test functions or `#[cfg(test)]`
     (allow_unwrap_in_tests: bool = false),
     /// Lint: DBG_MACRO.
     ///
-    /// Whether `dbg!` should be allowed in test functions
+    /// Whether `dbg!` should be allowed in test functions or `#[cfg(test)]`
     (allow_dbg_in_tests: bool = false),
     /// Lint: PRINT_STDOUT, PRINT_STDERR.
     ///
-    /// Whether print macros (ex. `println!`) should be allowed in test functions
+    /// Whether print macros (ex. `println!`) should be allowed in test functions or `#[cfg(test)]`
     (allow_print_in_tests: bool = false),
     /// Lint: RESULT_LARGE_ERR.
     ///
-- 
cgit 1.4.1-3-g733a5


From a5acb926c1c7042980b95a4fd75eaed278bb5d14 Mon Sep 17 00:00:00 2001
From: Liu Dingming <liudingming@bytedance.com>
Date: Wed, 22 Feb 2023 21:44:56 +0800
Subject: fix fmt

---
 clippy_lints/src/methods/expect_used.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/expect_used.rs b/clippy_lints/src/methods/expect_used.rs
index 9e370de0a05..614610335a1 100644
--- a/clippy_lints/src/methods/expect_used.rs
+++ b/clippy_lints/src/methods/expect_used.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_help;
-use clippy_utils::{is_in_cfg_test, is_in_test_function};
 use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::{is_in_cfg_test, is_in_test_function};
 use rustc_hir as hir;
 use rustc_lint::LateContext;
 use rustc_span::sym;
-- 
cgit 1.4.1-3-g733a5


From 528bb639d4a72310b625b947874aad27b5ee5088 Mon Sep 17 00:00:00 2001
From: Michael Krasnitski <michael.krasnitski@gmail.com>
Date: Wed, 22 Feb 2023 10:36:39 -0500
Subject: Fix more false positives for `extra_unused_type_parameters`

---
 clippy_lints/src/extra_unused_type_parameters.rs | 83 ++++++++++++++++--------
 clippy_lints/src/lib.rs                          |  6 +-
 tests/ui/extra_unused_type_parameters.rs         | 34 ++++++++--
 tests/ui/extra_unused_type_parameters.stderr     | 34 ++++++----
 tests/ui/new_without_default.rs                  |  7 +-
 tests/ui/new_without_default.stderr              | 14 ++--
 tests/ui/redundant_field_names.fixed             |  2 +-
 tests/ui/redundant_field_names.rs                |  2 +-
 8 files changed, 122 insertions(+), 60 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/extra_unused_type_parameters.rs b/clippy_lints/src/extra_unused_type_parameters.rs
index 040473c9ffc..20565e1d232 100644
--- a/clippy_lints/src/extra_unused_type_parameters.rs
+++ b/clippy_lints/src/extra_unused_type_parameters.rs
@@ -4,14 +4,17 @@ use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::MultiSpan;
 use rustc_hir::intravisit::{walk_impl_item, walk_item, walk_param_bound, walk_ty, Visitor};
 use rustc_hir::{
-    BodyId, ExprKind, GenericParamKind, Generics, ImplItem, ImplItemKind, Item, ItemKind, PredicateOrigin, Ty, TyKind,
-    WherePredicate,
+    BodyId, ExprKind, GenericBound, GenericParamKind, Generics, ImplItem, ImplItemKind, Item, ItemKind,
+    PredicateOrigin, Ty, TyKind, WherePredicate,
 };
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::hir::nested_filter;
 use rustc_middle::lint::in_external_macro;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::{def_id::DefId, Span};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::{
+    def_id::{DefId, LocalDefId},
+    Span,
+};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -38,7 +41,29 @@ declare_clippy_lint! {
     complexity,
     "unused type parameters in function definitions"
 }
-declare_lint_pass!(ExtraUnusedTypeParameters => [EXTRA_UNUSED_TYPE_PARAMETERS]);
+
+pub struct ExtraUnusedTypeParameters {
+    avoid_breaking_exported_api: bool,
+}
+
+impl ExtraUnusedTypeParameters {
+    pub fn new(avoid_breaking_exported_api: bool) -> Self {
+        Self {
+            avoid_breaking_exported_api,
+        }
+    }
+
+    /// Don't lint external macros or functions with empty bodies. Also, don't lint public items if
+    /// the `avoid_breaking_exported_api` config option is set.
+    fn check_false_positive(&self, cx: &LateContext<'_>, span: Span, def_id: LocalDefId, body_id: BodyId) -> bool {
+        let body = cx.tcx.hir().body(body_id).value;
+        let fn_empty = matches!(&body.kind, ExprKind::Block(blk, None) if blk.stmts.is_empty() && blk.expr.is_none());
+        let is_exported = cx.effective_visibilities.is_exported(def_id);
+        in_external_macro(cx.sess(), span) || (self.avoid_breaking_exported_api && is_exported) || fn_empty
+    }
+}
+
+impl_lint_pass!(ExtraUnusedTypeParameters => [EXTRA_UNUSED_TYPE_PARAMETERS]);
 
 /// A visitor struct that walks a given function and gathers generic type parameters, plus any
 /// trait bounds those parameters have.
@@ -56,13 +81,10 @@ struct TypeWalker<'cx, 'tcx> {
     /// Otherwise, if any type parameters end up being used, or if any lifetime or const-generic
     /// parameters are present, this will be set to `false`.
     all_params_unused: bool,
-    /// Whether or not the function has an empty body, in which case any bounded type parameters
-    /// will not be linted.
-    fn_body_empty: bool,
 }
 
 impl<'cx, 'tcx> TypeWalker<'cx, 'tcx> {
-    fn new(cx: &'cx LateContext<'tcx>, generics: &'tcx Generics<'tcx>, body_id: BodyId) -> Self {
+    fn new(cx: &'cx LateContext<'tcx>, generics: &'tcx Generics<'tcx>) -> Self {
         let mut all_params_unused = true;
         let ty_params = generics
             .params
@@ -79,17 +101,18 @@ impl<'cx, 'tcx> TypeWalker<'cx, 'tcx> {
             })
             .collect();
 
-        let body = cx.tcx.hir().body(body_id).value;
-        let fn_body_empty =
-            matches!(&body.kind, ExprKind::Block(block, None) if block.stmts.is_empty() && block.expr.is_none());
-
         Self {
             cx,
             ty_params,
             bounds: FxHashMap::default(),
             generics,
             all_params_unused,
-            fn_body_empty,
+        }
+    }
+
+    fn mark_param_used(&mut self, def_id: DefId) {
+        if self.ty_params.remove(&def_id).is_some() {
+            self.all_params_unused = false;
         }
     }
 
@@ -128,14 +151,18 @@ impl<'cx, 'tcx> TypeWalker<'cx, 'tcx> {
     }
 }
 
+/// Given a generic bound, if the bound is for a trait that's not a `LangItem`, return the
+/// `LocalDefId` for that trait.
+fn bound_to_trait_def_id(bound: &GenericBound<'_>) -> Option<LocalDefId> {
+    bound.trait_ref()?.trait_def_id()?.as_local()
+}
+
 impl<'cx, 'tcx> Visitor<'tcx> for TypeWalker<'cx, 'tcx> {
     type NestedFilter = nested_filter::OnlyBodies;
 
     fn visit_ty(&mut self, t: &'tcx Ty<'tcx>) {
         if let Some((def_id, _)) = t.peel_refs().as_generic_param() {
-            if self.ty_params.remove(&def_id).is_some() {
-                self.all_params_unused = false;
-            }
+            self.mark_param_used(def_id);
         } else if let TyKind::OpaqueDef(id, _, _) = t.kind {
             // Explicitly walk OpaqueDef. Normally `walk_ty` would do the job, but it calls
             // `visit_nested_item`, which checks that `Self::NestedFilter::INTER` is set. We're
@@ -151,12 +178,16 @@ impl<'cx, 'tcx> Visitor<'tcx> for TypeWalker<'cx, 'tcx> {
         if let WherePredicate::BoundPredicate(predicate) = predicate {
             // Collect spans for any bounds on type parameters. We only keep bounds that appear in
             // the list of generics (not in a where-clause).
-            //
-            // Also, if the function body is empty, we don't lint the corresponding type parameters
-            // (See https://github.com/rust-lang/rust-clippy/issues/10319).
             if let Some((def_id, _)) = predicate.bounded_ty.peel_refs().as_generic_param() {
-                if self.fn_body_empty {
-                    self.ty_params.remove(&def_id);
+                // If the bound contains non-public traits, err on the safe side and don't lint the
+                // corresponding parameter.
+                if !predicate
+                    .bounds
+                    .iter()
+                    .filter_map(bound_to_trait_def_id)
+                    .all(|id| self.cx.effective_visibilities.is_exported(id))
+                {
+                    self.mark_param_used(def_id);
                 } else if let PredicateOrigin::GenericParam = predicate.origin {
                     self.bounds.insert(def_id, predicate.span);
                 }
@@ -176,9 +207,9 @@ impl<'cx, 'tcx> Visitor<'tcx> for TypeWalker<'cx, 'tcx> {
 impl<'tcx> LateLintPass<'tcx> for ExtraUnusedTypeParameters {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
         if let ItemKind::Fn(_, generics, body_id) = item.kind
-            && !in_external_macro(cx.sess(), item.span)
+            && !self.check_false_positive(cx, item.span, item.owner_id.def_id, body_id)
         {
-            let mut walker = TypeWalker::new(cx, generics, body_id);
+            let mut walker = TypeWalker::new(cx, generics);
             walk_item(&mut walker, item);
             walker.emit_lint();
         }
@@ -188,9 +219,9 @@ impl<'tcx> LateLintPass<'tcx> for ExtraUnusedTypeParameters {
         // Only lint on inherent methods, not trait methods.
         if let ImplItemKind::Fn(.., body_id) = item.kind
             && trait_ref_of_method(cx, item.owner_id.def_id).is_none()
-            && !in_external_macro(cx.sess(), item.span)
+            && !self.check_false_positive(cx, item.span, item.owner_id.def_id, body_id)
         {
-            let mut walker = TypeWalker::new(cx, item.generics, body_id);
+            let mut walker = TypeWalker::new(cx, item.generics);
             walk_impl_item(&mut walker, item);
             walker.emit_lint();
         }
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 7336fa19b12..b63cb4df48f 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -916,7 +916,11 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(permissions_set_readonly_false::PermissionsSetReadonlyFalse));
     store.register_late_pass(|_| Box::new(size_of_ref::SizeOfRef));
     store.register_late_pass(|_| Box::new(multiple_unsafe_ops_per_block::MultipleUnsafeOpsPerBlock));
-    store.register_late_pass(|_| Box::new(extra_unused_type_parameters::ExtraUnusedTypeParameters));
+    store.register_late_pass(move |_| {
+        Box::new(extra_unused_type_parameters::ExtraUnusedTypeParameters::new(
+            avoid_breaking_exported_api,
+        ))
+    });
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/tests/ui/extra_unused_type_parameters.rs b/tests/ui/extra_unused_type_parameters.rs
index 2894fda2f47..48017434276 100644
--- a/tests/ui/extra_unused_type_parameters.rs
+++ b/tests/ui/extra_unused_type_parameters.rs
@@ -1,11 +1,17 @@
 #![allow(unused, clippy::needless_lifetimes)]
 #![warn(clippy::extra_unused_type_parameters)]
 
-fn unused_ty<T>(x: u8) {}
+fn unused_ty<T>(x: u8) {
+    unimplemented!()
+}
 
-fn unused_multi<T, U>(x: u8) {}
+fn unused_multi<T, U>(x: u8) {
+    unimplemented!()
+}
 
-fn unused_with_lt<'a, T>(x: &'a u8) {}
+fn unused_with_lt<'a, T>(x: &'a u8) {
+    unimplemented!()
+}
 
 fn used_ty<T>(x: T, y: u8) {}
 
@@ -51,7 +57,9 @@ fn used_closure<T: Default + ToString>() -> impl Fn() {
 struct S;
 
 impl S {
-    fn unused_ty_impl<T>(&self) {}
+    fn unused_ty_impl<T>(&self) {
+        unimplemented!()
+    }
 }
 
 // Don't lint on trait methods
@@ -71,7 +79,23 @@ where
         .filter_map(move |(i, a)| if i == index { None } else { Some(a) })
 }
 
-fn unused_opaque<A, B>(dummy: impl Default) {}
+fn unused_opaque<A, B>(dummy: impl Default) {
+    unimplemented!()
+}
+
+mod unexported_trait_bounds {
+    mod private {
+        pub trait Private {}
+    }
+
+    fn priv_trait_bound<T: private::Private>() {
+        unimplemented!();
+    }
+
+    fn unused_with_priv_trait_bound<T: private::Private, U>() {
+        unimplemented!();
+    }
+}
 
 mod issue10319 {
     fn assert_send<T: Send>() {}
diff --git a/tests/ui/extra_unused_type_parameters.stderr b/tests/ui/extra_unused_type_parameters.stderr
index aea3ee310f7..86c88fc9bf0 100644
--- a/tests/ui/extra_unused_type_parameters.stderr
+++ b/tests/ui/extra_unused_type_parameters.stderr
@@ -1,30 +1,30 @@
 error: type parameter goes unused in function definition
   --> $DIR/extra_unused_type_parameters.rs:4:13
    |
-LL | fn unused_ty<T>(x: u8) {}
+LL | fn unused_ty<T>(x: u8) {
    |             ^^^
    |
    = help: consider removing the parameter
    = note: `-D clippy::extra-unused-type-parameters` implied by `-D warnings`
 
 error: type parameters go unused in function definition
-  --> $DIR/extra_unused_type_parameters.rs:6:16
+  --> $DIR/extra_unused_type_parameters.rs:8:16
    |
-LL | fn unused_multi<T, U>(x: u8) {}
+LL | fn unused_multi<T, U>(x: u8) {
    |                ^^^^^^
    |
    = help: consider removing the parameters
 
 error: type parameter goes unused in function definition
-  --> $DIR/extra_unused_type_parameters.rs:8:23
+  --> $DIR/extra_unused_type_parameters.rs:12:23
    |
-LL | fn unused_with_lt<'a, T>(x: &'a u8) {}
+LL | fn unused_with_lt<'a, T>(x: &'a u8) {
    |                       ^
    |
    = help: consider removing the parameter
 
 error: type parameter goes unused in function definition
-  --> $DIR/extra_unused_type_parameters.rs:18:19
+  --> $DIR/extra_unused_type_parameters.rs:24:19
    |
 LL | fn unused_bounded<T: Default, U>(x: U) {
    |                   ^^^^^^^^^^^
@@ -32,7 +32,7 @@ LL | fn unused_bounded<T: Default, U>(x: U) {
    = help: consider removing the parameter
 
 error: type parameter goes unused in function definition
-  --> $DIR/extra_unused_type_parameters.rs:22:24
+  --> $DIR/extra_unused_type_parameters.rs:28:24
    |
 LL | fn unused_where_clause<T, U>(x: U)
    |                        ^^
@@ -40,7 +40,7 @@ LL | fn unused_where_clause<T, U>(x: U)
    = help: consider removing the parameter
 
 error: type parameters go unused in function definition
-  --> $DIR/extra_unused_type_parameters.rs:29:16
+  --> $DIR/extra_unused_type_parameters.rs:35:16
    |
 LL | fn some_unused<A, B, C, D: Iterator<Item = (B, C)>, E>(b: B, c: C) {
    |                ^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^
@@ -48,20 +48,28 @@ LL | fn some_unused<A, B, C, D: Iterator<Item = (B, C)>, E>(b: B, c: C) {
    = help: consider removing the parameters
 
 error: type parameter goes unused in function definition
-  --> $DIR/extra_unused_type_parameters.rs:54:22
+  --> $DIR/extra_unused_type_parameters.rs:60:22
    |
-LL |     fn unused_ty_impl<T>(&self) {}
+LL |     fn unused_ty_impl<T>(&self) {
    |                      ^^^
    |
    = help: consider removing the parameter
 
 error: type parameters go unused in function definition
-  --> $DIR/extra_unused_type_parameters.rs:74:17
+  --> $DIR/extra_unused_type_parameters.rs:82:17
    |
-LL | fn unused_opaque<A, B>(dummy: impl Default) {}
+LL | fn unused_opaque<A, B>(dummy: impl Default) {
    |                 ^^^^^^
    |
    = help: consider removing the parameters
 
-error: aborting due to 8 previous errors
+error: type parameter goes unused in function definition
+  --> $DIR/extra_unused_type_parameters.rs:95:58
+   |
+LL |     fn unused_with_priv_trait_bound<T: private::Private, U>() {
+   |                                                          ^
+   |
+   = help: consider removing the parameter
+
+error: aborting due to 9 previous errors
 
diff --git a/tests/ui/new_without_default.rs b/tests/ui/new_without_default.rs
index 7803418cb04..65809023f8d 100644
--- a/tests/ui/new_without_default.rs
+++ b/tests/ui/new_without_default.rs
@@ -1,9 +1,4 @@
-#![allow(
-    dead_code,
-    clippy::missing_safety_doc,
-    clippy::extra_unused_lifetimes,
-    clippy::extra_unused_type_parameters
-)]
+#![allow(dead_code, clippy::missing_safety_doc, clippy::extra_unused_lifetimes)]
 #![warn(clippy::new_without_default)]
 
 pub struct Foo;
diff --git a/tests/ui/new_without_default.stderr b/tests/ui/new_without_default.stderr
index 583dd327d6a..212a69ab94e 100644
--- a/tests/ui/new_without_default.stderr
+++ b/tests/ui/new_without_default.stderr
@@ -1,5 +1,5 @@
 error: you should consider adding a `Default` implementation for `Foo`
-  --> $DIR/new_without_default.rs:12:5
+  --> $DIR/new_without_default.rs:7:5
    |
 LL | /     pub fn new() -> Foo {
 LL | |         Foo
@@ -17,7 +17,7 @@ LL + }
    |
 
 error: you should consider adding a `Default` implementation for `Bar`
-  --> $DIR/new_without_default.rs:20:5
+  --> $DIR/new_without_default.rs:15:5
    |
 LL | /     pub fn new() -> Self {
 LL | |         Bar
@@ -34,7 +34,7 @@ LL + }
    |
 
 error: you should consider adding a `Default` implementation for `LtKo<'c>`
-  --> $DIR/new_without_default.rs:84:5
+  --> $DIR/new_without_default.rs:79:5
    |
 LL | /     pub fn new() -> LtKo<'c> {
 LL | |         unimplemented!()
@@ -51,7 +51,7 @@ LL + }
    |
 
 error: you should consider adding a `Default` implementation for `NewNotEqualToDerive`
-  --> $DIR/new_without_default.rs:177:5
+  --> $DIR/new_without_default.rs:172:5
    |
 LL | /     pub fn new() -> Self {
 LL | |         NewNotEqualToDerive { foo: 1 }
@@ -68,7 +68,7 @@ LL + }
    |
 
 error: you should consider adding a `Default` implementation for `FooGenerics<T>`
-  --> $DIR/new_without_default.rs:185:5
+  --> $DIR/new_without_default.rs:180:5
    |
 LL | /     pub fn new() -> Self {
 LL | |         Self(Default::default())
@@ -85,7 +85,7 @@ LL + }
    |
 
 error: you should consider adding a `Default` implementation for `BarGenerics<T>`
-  --> $DIR/new_without_default.rs:192:5
+  --> $DIR/new_without_default.rs:187:5
    |
 LL | /     pub fn new() -> Self {
 LL | |         Self(Default::default())
@@ -102,7 +102,7 @@ LL + }
    |
 
 error: you should consider adding a `Default` implementation for `Foo<T>`
-  --> $DIR/new_without_default.rs:203:9
+  --> $DIR/new_without_default.rs:198:9
    |
 LL | /         pub fn new() -> Self {
 LL | |             todo!()
diff --git a/tests/ui/redundant_field_names.fixed b/tests/ui/redundant_field_names.fixed
index 276266a2dd8..ec7f8ae923a 100644
--- a/tests/ui/redundant_field_names.fixed
+++ b/tests/ui/redundant_field_names.fixed
@@ -1,7 +1,7 @@
 // run-rustfix
 
 #![warn(clippy::redundant_field_names)]
-#![allow(clippy::extra_unused_type_parameters, clippy::no_effect, dead_code, unused_variables)]
+#![allow(clippy::no_effect, dead_code, unused_variables)]
 
 #[macro_use]
 extern crate derive_new;
diff --git a/tests/ui/redundant_field_names.rs b/tests/ui/redundant_field_names.rs
index f674141c138..73122016cf6 100644
--- a/tests/ui/redundant_field_names.rs
+++ b/tests/ui/redundant_field_names.rs
@@ -1,7 +1,7 @@
 // run-rustfix
 
 #![warn(clippy::redundant_field_names)]
-#![allow(clippy::extra_unused_type_parameters, clippy::no_effect, dead_code, unused_variables)]
+#![allow(clippy::no_effect, dead_code, unused_variables)]
 
 #[macro_use]
 extern crate derive_new;
-- 
cgit 1.4.1-3-g733a5


From 00c294ad0599968ce81bdb8763aefb88a2d2faa0 Mon Sep 17 00:00:00 2001
From: Krishna Sundarram <krishnasundarram@monzo.com>
Date: Sat, 18 Feb 2023 16:47:27 +0000
Subject: Add new lint no_mangle_with_rust_abi

---
 CHANGELOG.md                                |  1 +
 clippy_lints/src/declared_lints.rs          |  1 +
 clippy_lints/src/lib.rs                     |  2 +
 clippy_lints/src/no_mangle_with_rust_abi.rs | 65 +++++++++++++++++++++++++++++
 tests/ui/must_use_candidates.fixed          |  2 +-
 tests/ui/must_use_candidates.rs             |  2 +-
 tests/ui/no_mangle_with_rust_abi.fixed      | 48 +++++++++++++++++++++
 tests/ui/no_mangle_with_rust_abi.rs         | 48 +++++++++++++++++++++
 tests/ui/no_mangle_with_rust_abi.stderr     | 45 ++++++++++++++++++++
 9 files changed, 212 insertions(+), 2 deletions(-)
 create mode 100644 clippy_lints/src/no_mangle_with_rust_abi.rs
 create mode 100644 tests/ui/no_mangle_with_rust_abi.fixed
 create mode 100644 tests/ui/no_mangle_with_rust_abi.rs
 create mode 100644 tests/ui/no_mangle_with_rust_abi.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5ed61f99780..765826ed867 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4622,6 +4622,7 @@ Released 2018-09-13
 [`no_effect`]: https://rust-lang.github.io/rust-clippy/master/index.html#no_effect
 [`no_effect_replace`]: https://rust-lang.github.io/rust-clippy/master/index.html#no_effect_replace
 [`no_effect_underscore_binding`]: https://rust-lang.github.io/rust-clippy/master/index.html#no_effect_underscore_binding
+[`no_mangle_with_rust_abi`]: https://rust-lang.github.io/rust-clippy/master/index.html#no_mangle_with_rust_abi
 [`non_ascii_literal`]: https://rust-lang.github.io/rust-clippy/master/index.html#non_ascii_literal
 [`non_octal_unix_permissions`]: https://rust-lang.github.io/rust-clippy/master/index.html#non_octal_unix_permissions
 [`non_send_fields_in_send_ty`]: https://rust-lang.github.io/rust-clippy/master/index.html#non_send_fields_in_send_ty
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index d05f22c231c..cd5dd7a5706 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -450,6 +450,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::no_effect::NO_EFFECT_INFO,
     crate::no_effect::NO_EFFECT_UNDERSCORE_BINDING_INFO,
     crate::no_effect::UNNECESSARY_OPERATION_INFO,
+    crate::no_mangle_with_rust_abi::NO_MANGLE_WITH_RUST_ABI_INFO,
     crate::non_copy_const::BORROW_INTERIOR_MUTABLE_CONST_INFO,
     crate::non_copy_const::DECLARE_INTERIOR_MUTABLE_CONST_INFO,
     crate::non_expressive_names::JUST_UNDERSCORES_AND_DIGITS_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index b63cb4df48f..8c33bae17b5 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -219,6 +219,7 @@ mod neg_cmp_op_on_partial_ord;
 mod neg_multiply;
 mod new_without_default;
 mod no_effect;
+mod no_mangle_with_rust_abi;
 mod non_copy_const;
 mod non_expressive_names;
 mod non_octal_unix_permissions;
@@ -921,6 +922,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
             avoid_breaking_exported_api,
         ))
     });
+    store.register_late_pass(|_| Box::new(no_mangle_with_rust_abi::NoMangleWithRustAbi));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/no_mangle_with_rust_abi.rs b/clippy_lints/src/no_mangle_with_rust_abi.rs
new file mode 100644
index 00000000000..bc64ccb295c
--- /dev/null
+++ b/clippy_lints/src/no_mangle_with_rust_abi.rs
@@ -0,0 +1,65 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet_with_applicability;
+use rustc_errors::Applicability;
+use rustc_hir::{Item, ItemKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_target::spec::abi::Abi;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for Rust ABI functions with the `#[no_mangle]` attribute.
+    ///
+    /// ### Why is this bad?
+    /// The Rust ABI is not stable, but in many simple cases matches
+    /// enough with the C ABI that it is possible to forget to add
+    /// `extern "C"` to a function called from C. Changes to the
+    /// Rust ABI can break this at any point.
+    ///
+    /// ### Example
+    /// ```rust
+    ///  #[no_mangle]
+    ///  fn example(arg_one: u32, arg_two: usize) {}
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust
+    ///  #[no_mangle]
+    ///  extern "C" fn example(arg_one: u32, arg_two: usize) {}
+    /// ```
+    #[clippy::version = "1.69.0"]
+    pub NO_MANGLE_WITH_RUST_ABI,
+    pedantic,
+    "convert Rust ABI functions to C ABI"
+}
+declare_lint_pass!(NoMangleWithRustAbi => [NO_MANGLE_WITH_RUST_ABI]);
+
+impl<'tcx> LateLintPass<'tcx> for NoMangleWithRustAbi {
+    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
+        if let ItemKind::Fn(fn_sig, _, _) = &item.kind {
+            let attrs = cx.tcx.hir().attrs(item.hir_id());
+            let mut applicability = Applicability::MachineApplicable;
+            let snippet = snippet_with_applicability(cx, fn_sig.span, "..", &mut applicability);
+            for attr in attrs {
+                if let Some(ident) = attr.ident()
+                    && ident.name == rustc_span::sym::no_mangle
+                    && fn_sig.header.abi == Abi::Rust
+                    && !snippet.contains("extern") {
+
+                    let suggestion = snippet.split_once("fn")
+                        .map_or(String::new(), |(first, second)| format!(r#"{first}extern "C" fn{second}"#));
+
+                    span_lint_and_sugg(
+                        cx,
+                        NO_MANGLE_WITH_RUST_ABI,
+                        fn_sig.span,
+                        "attribute #[no_mangle] set on a Rust ABI function",
+                        "try",
+                        suggestion,
+                        applicability
+                    );
+                }
+            }
+        }
+    }
+}
diff --git a/tests/ui/must_use_candidates.fixed b/tests/ui/must_use_candidates.fixed
index 04a74a009e0..bbbb3cf621e 100644
--- a/tests/ui/must_use_candidates.fixed
+++ b/tests/ui/must_use_candidates.fixed
@@ -84,7 +84,7 @@ pub unsafe fn mutates_static() -> usize {
 }
 
 #[no_mangle]
-pub fn unmangled(i: bool) -> bool {
+pub extern "C" fn unmangled(i: bool) -> bool {
     !i
 }
 
diff --git a/tests/ui/must_use_candidates.rs b/tests/ui/must_use_candidates.rs
index f04122f4eea..94d3c83bdb9 100644
--- a/tests/ui/must_use_candidates.rs
+++ b/tests/ui/must_use_candidates.rs
@@ -84,7 +84,7 @@ pub unsafe fn mutates_static() -> usize {
 }
 
 #[no_mangle]
-pub fn unmangled(i: bool) -> bool {
+pub extern "C" fn unmangled(i: bool) -> bool {
     !i
 }
 
diff --git a/tests/ui/no_mangle_with_rust_abi.fixed b/tests/ui/no_mangle_with_rust_abi.fixed
new file mode 100644
index 00000000000..d18dec22a8b
--- /dev/null
+++ b/tests/ui/no_mangle_with_rust_abi.fixed
@@ -0,0 +1,48 @@
+// run-rustfix
+
+#![allow(unused)]
+#![warn(clippy::no_mangle_with_rust_abi)]
+
+#[no_mangle]
+extern "C" fn rust_abi_fn_one(arg_one: u32, arg_two: usize) {}
+
+#[no_mangle]
+pub extern "C" fn rust_abi_fn_two(arg_one: u32, arg_two: usize) {}
+
+/// # Safety
+/// This function shouldn't be called unless the horsemen are ready
+#[no_mangle]
+pub unsafe extern "C" fn rust_abi_fn_three(arg_one: u32, arg_two: usize) {}
+
+/// # Safety
+/// This function shouldn't be called unless the horsemen are ready
+#[no_mangle]
+unsafe extern "C" fn rust_abi_fn_four(arg_one: u32, arg_two: usize) {}
+
+#[no_mangle]
+extern "C" fn rust_abi_multiline_function_really_long_name_to_overflow_args_to_multiple_lines(
+    arg_one: u32,
+    arg_two: usize,
+) -> u32 {
+    0
+}
+
+// Must not run on functions that explicitly opt in to Rust ABI with `extern "Rust"`
+#[no_mangle]
+#[rustfmt::skip]
+extern "Rust" fn rust_abi_fn_explicit_opt_in(arg_one: u32, arg_two: usize) {}
+
+fn rust_abi_fn_again(arg_one: u32, arg_two: usize) {}
+
+#[no_mangle]
+extern "C" fn c_abi_fn(arg_one: u32, arg_two: usize) {}
+
+extern "C" fn c_abi_fn_again(arg_one: u32, arg_two: usize) {}
+
+extern "C" {
+    fn c_abi_in_block(arg_one: u32, arg_two: usize);
+}
+
+fn main() {
+    // test code goes here
+}
diff --git a/tests/ui/no_mangle_with_rust_abi.rs b/tests/ui/no_mangle_with_rust_abi.rs
new file mode 100644
index 00000000000..481e1b6d961
--- /dev/null
+++ b/tests/ui/no_mangle_with_rust_abi.rs
@@ -0,0 +1,48 @@
+// run-rustfix
+
+#![allow(unused)]
+#![warn(clippy::no_mangle_with_rust_abi)]
+
+#[no_mangle]
+fn rust_abi_fn_one(arg_one: u32, arg_two: usize) {}
+
+#[no_mangle]
+pub fn rust_abi_fn_two(arg_one: u32, arg_two: usize) {}
+
+/// # Safety
+/// This function shouldn't be called unless the horsemen are ready
+#[no_mangle]
+pub unsafe fn rust_abi_fn_three(arg_one: u32, arg_two: usize) {}
+
+/// # Safety
+/// This function shouldn't be called unless the horsemen are ready
+#[no_mangle]
+unsafe fn rust_abi_fn_four(arg_one: u32, arg_two: usize) {}
+
+#[no_mangle]
+fn rust_abi_multiline_function_really_long_name_to_overflow_args_to_multiple_lines(
+    arg_one: u32,
+    arg_two: usize,
+) -> u32 {
+    0
+}
+
+// Must not run on functions that explicitly opt in to Rust ABI with `extern "Rust"`
+#[no_mangle]
+#[rustfmt::skip]
+extern "Rust" fn rust_abi_fn_explicit_opt_in(arg_one: u32, arg_two: usize) {}
+
+fn rust_abi_fn_again(arg_one: u32, arg_two: usize) {}
+
+#[no_mangle]
+extern "C" fn c_abi_fn(arg_one: u32, arg_two: usize) {}
+
+extern "C" fn c_abi_fn_again(arg_one: u32, arg_two: usize) {}
+
+extern "C" {
+    fn c_abi_in_block(arg_one: u32, arg_two: usize);
+}
+
+fn main() {
+    // test code goes here
+}
diff --git a/tests/ui/no_mangle_with_rust_abi.stderr b/tests/ui/no_mangle_with_rust_abi.stderr
new file mode 100644
index 00000000000..71517d31809
--- /dev/null
+++ b/tests/ui/no_mangle_with_rust_abi.stderr
@@ -0,0 +1,45 @@
+error: attribute #[no_mangle] set on a Rust ABI function
+  --> $DIR/no_mangle_with_rust_abi.rs:7:1
+   |
+LL | fn rust_abi_fn_one(arg_one: u32, arg_two: usize) {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `extern "C" fn rust_abi_fn_one(arg_one: u32, arg_two: usize)`
+   |
+   = note: `-D clippy::no-mangle-with-rust-abi` implied by `-D warnings`
+
+error: attribute #[no_mangle] set on a Rust ABI function
+  --> $DIR/no_mangle_with_rust_abi.rs:10:1
+   |
+LL | pub fn rust_abi_fn_two(arg_one: u32, arg_two: usize) {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `pub extern "C" fn rust_abi_fn_two(arg_one: u32, arg_two: usize)`
+
+error: attribute #[no_mangle] set on a Rust ABI function
+  --> $DIR/no_mangle_with_rust_abi.rs:15:1
+   |
+LL | pub unsafe fn rust_abi_fn_three(arg_one: u32, arg_two: usize) {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `pub unsafe extern "C" fn rust_abi_fn_three(arg_one: u32, arg_two: usize)`
+
+error: attribute #[no_mangle] set on a Rust ABI function
+  --> $DIR/no_mangle_with_rust_abi.rs:20:1
+   |
+LL | unsafe fn rust_abi_fn_four(arg_one: u32, arg_two: usize) {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unsafe extern "C" fn rust_abi_fn_four(arg_one: u32, arg_two: usize)`
+
+error: attribute #[no_mangle] set on a Rust ABI function
+  --> $DIR/no_mangle_with_rust_abi.rs:23:1
+   |
+LL | / fn rust_abi_multiline_function_really_long_name_to_overflow_args_to_multiple_lines(
+LL | |     arg_one: u32,
+LL | |     arg_two: usize,
+LL | | ) -> u32 {
+   | |________^
+   |
+help: try
+   |
+LL + extern "C" fn rust_abi_multiline_function_really_long_name_to_overflow_args_to_multiple_lines(
+LL +     arg_one: u32,
+LL +     arg_two: usize,
+LL ~ ) -> u32 {
+   |
+
+error: aborting due to 5 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 69c4ff6df8605f5f0b293fcf2a597f42510d2fd3 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sat, 25 Feb 2023 18:09:24 -0500
Subject: Emit `unnecessary_def_path` in source order.

---
 .../src/utils/internal_lints/unnecessary_def_path.rs   |  4 ++--
 .../unnecessary_def_path_hardcoded_path.stderr         | 18 +++++++++---------
 2 files changed, 11 insertions(+), 11 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/internal_lints/unnecessary_def_path.rs b/clippy_lints/src/utils/internal_lints/unnecessary_def_path.rs
index ee5e42bae0f..b59ef4086cd 100644
--- a/clippy_lints/src/utils/internal_lints/unnecessary_def_path.rs
+++ b/clippy_lints/src/utils/internal_lints/unnecessary_def_path.rs
@@ -3,7 +3,7 @@ use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::{def_path_def_ids, is_lint_allowed, match_any_def_paths, peel_hir_expr_refs};
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
-use rustc_data_structures::fx::FxHashSet;
+use rustc_data_structures::fx::{FxHashSet, FxIndexSet};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_hir::def::{DefKind, Res};
@@ -44,7 +44,7 @@ impl_lint_pass!(UnnecessaryDefPath => [UNNECESSARY_DEF_PATH]);
 
 #[derive(Default)]
 pub struct UnnecessaryDefPath {
-    array_def_ids: FxHashSet<(DefId, Span)>,
+    array_def_ids: FxIndexSet<(DefId, Span)>,
     linted_def_ids: FxHashSet<DefId>,
 }
 
diff --git a/tests/ui-internal/unnecessary_def_path_hardcoded_path.stderr b/tests/ui-internal/unnecessary_def_path_hardcoded_path.stderr
index c1a10ba55ef..3ca45404e44 100644
--- a/tests/ui-internal/unnecessary_def_path_hardcoded_path.stderr
+++ b/tests/ui-internal/unnecessary_def_path_hardcoded_path.stderr
@@ -1,12 +1,3 @@
-error: hardcoded path to a diagnostic item
-  --> $DIR/unnecessary_def_path_hardcoded_path.rs:12:43
-   |
-LL |     const DEREF_TRAIT_METHOD: [&str; 5] = ["core", "ops", "deref", "Deref", "deref"];
-   |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: convert all references to use `sym::deref_method`
-   = note: `-D clippy::unnecessary-def-path` implied by `-D warnings`
-
 error: hardcoded path to a diagnostic item
   --> $DIR/unnecessary_def_path_hardcoded_path.rs:10:36
    |
@@ -14,6 +5,7 @@ LL |     const DEREF_TRAIT: [&str; 4] = ["core", "ops", "deref", "Deref"];
    |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: convert all references to use `sym::Deref`
+   = note: `-D clippy::unnecessary-def-path` implied by `-D warnings`
 
 error: hardcoded path to a language item
   --> $DIR/unnecessary_def_path_hardcoded_path.rs:11:40
@@ -23,5 +15,13 @@ LL |     const DEREF_MUT_TRAIT: [&str; 4] = ["core", "ops", "deref", "DerefMut"]
    |
    = help: convert all references to use `LangItem::DerefMut`
 
+error: hardcoded path to a diagnostic item
+  --> $DIR/unnecessary_def_path_hardcoded_path.rs:12:43
+   |
+LL |     const DEREF_TRAIT_METHOD: [&str; 5] = ["core", "ops", "deref", "Deref", "deref"];
+   |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: convert all references to use `sym::deref_method`
+
 error: aborting due to 3 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 49a06ed66f106b332b0e488bf970957e83cb03b0 Mon Sep 17 00:00:00 2001
From: Andrew Banchich <git@andrew.banchi.ch>
Date: Sat, 11 Feb 2023 19:16:12 -0500
Subject: Scope missing_docs_in_private_items to only private items

---
 clippy_lints/src/missing_doc.rs  | 10 +++---
 tests/ui/missing_doc.stderr      | 70 +---------------------------------------
 tests/ui/missing_doc_impl.stderr | 56 +-------------------------------
 3 files changed, 8 insertions(+), 128 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/missing_doc.rs b/clippy_lints/src/missing_doc.rs
index 9659ca8ced2..f9681deab5b 100644
--- a/clippy_lints/src/missing_doc.rs
+++ b/clippy_lints/src/missing_doc.rs
@@ -8,10 +8,10 @@
 use clippy_utils::attrs::is_doc_hidden;
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::is_from_proc_macro;
-use hir::def_id::LocalDefId;
 use if_chain::if_chain;
 use rustc_ast::ast::{self, MetaItem, MetaItemKind};
 use rustc_hir as hir;
+use rustc_hir::def_id::LocalDefId;
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::ty::{DefIdTree, Visibility};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
@@ -21,8 +21,7 @@ use rustc_span::sym;
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Warns if there is missing doc for any documentable item
-    /// (public or private).
+    /// Warns if there is missing doc for any private documentable item
     ///
     /// ### Why is this bad?
     /// Doc is good. *rustc* has a `MISSING_DOCS`
@@ -32,7 +31,7 @@ declare_clippy_lint! {
     #[clippy::version = "pre 1.29.0"]
     pub MISSING_DOCS_IN_PRIVATE_ITEMS,
     restriction,
-    "detects missing documentation for public and private members"
+    "detects missing documentation for private members"
 }
 
 pub struct MissingDoc {
@@ -107,11 +106,14 @@ impl MissingDoc {
             if vis == Visibility::Public || vis != Visibility::Restricted(CRATE_DEF_ID.into()) {
                 return;
             }
+        } else if def_id != CRATE_DEF_ID && cx.effective_visibilities.is_exported(def_id) {
+            return;
         }
 
         let has_doc = attrs
             .iter()
             .any(|a| a.doc_str().is_some() || Self::has_include(a.meta()));
+
         if !has_doc {
             span_lint(
                 cx,
diff --git a/tests/ui/missing_doc.stderr b/tests/ui/missing_doc.stderr
index d3bef28bf64..4e8a49bf1cd 100644
--- a/tests/ui/missing_doc.stderr
+++ b/tests/ui/missing_doc.stderr
@@ -6,30 +6,12 @@ LL | type Typedef = String;
    |
    = note: `-D clippy::missing-docs-in-private-items` implied by `-D warnings`
 
-error: missing documentation for a type alias
-  --> $DIR/missing_doc.rs:17:1
-   |
-LL | pub type PubTypedef = String;
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
 error: missing documentation for a module
   --> $DIR/missing_doc.rs:19:1
    |
 LL | mod module_no_dox {}
    | ^^^^^^^^^^^^^^^^^^^^
 
-error: missing documentation for a module
-  --> $DIR/missing_doc.rs:20:1
-   |
-LL | pub mod pub_module_no_dox {}
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: missing documentation for a function
-  --> $DIR/missing_doc.rs:24:1
-   |
-LL | pub fn foo2() {}
-   | ^^^^^^^^^^^^^^^^
-
 error: missing documentation for a function
   --> $DIR/missing_doc.rs:25:1
    |
@@ -69,50 +51,18 @@ error: missing documentation for a variant
 LL |     BarB,
    |     ^^^^
 
-error: missing documentation for an enum
-  --> $DIR/missing_doc.rs:44:1
-   |
-LL | / pub enum PubBaz {
-LL | |     PubBazA { a: isize },
-LL | | }
-   | |_^
-
-error: missing documentation for a variant
-  --> $DIR/missing_doc.rs:45:5
-   |
-LL |     PubBazA { a: isize },
-   |     ^^^^^^^^^^^^^^^^^^^^
-
-error: missing documentation for a struct field
-  --> $DIR/missing_doc.rs:45:15
-   |
-LL |     PubBazA { a: isize },
-   |               ^^^^^^^^
-
 error: missing documentation for a constant
   --> $DIR/missing_doc.rs:65:1
    |
 LL | const FOO: u32 = 0;
    | ^^^^^^^^^^^^^^^^^^^
 
-error: missing documentation for a constant
-  --> $DIR/missing_doc.rs:72:1
-   |
-LL | pub const FOO4: u32 = 0;
-   | ^^^^^^^^^^^^^^^^^^^^^^^^
-
 error: missing documentation for a static
   --> $DIR/missing_doc.rs:74:1
    |
 LL | static BAR: u32 = 0;
    | ^^^^^^^^^^^^^^^^^^^^
 
-error: missing documentation for a static
-  --> $DIR/missing_doc.rs:81:1
-   |
-LL | pub static BAR4: u32 = 0;
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^
-
 error: missing documentation for a module
   --> $DIR/missing_doc.rs:83:1
    |
@@ -125,35 +75,17 @@ LL | |     }
 LL | | }
    | |_^
 
-error: missing documentation for a function
-  --> $DIR/missing_doc.rs:86:5
-   |
-LL |     pub fn undocumented1() {}
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: missing documentation for a function
-  --> $DIR/missing_doc.rs:87:5
-   |
-LL |     pub fn undocumented2() {}
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
-
 error: missing documentation for a function
   --> $DIR/missing_doc.rs:88:5
    |
 LL |     fn undocumented3() {}
    |     ^^^^^^^^^^^^^^^^^^^^^
 
-error: missing documentation for a function
-  --> $DIR/missing_doc.rs:93:9
-   |
-LL |         pub fn also_undocumented1() {}
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
 error: missing documentation for a function
   --> $DIR/missing_doc.rs:94:9
    |
 LL |         fn also_undocumented2() {}
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 24 previous errors
+error: aborting due to 13 previous errors
 
diff --git a/tests/ui/missing_doc_impl.stderr b/tests/ui/missing_doc_impl.stderr
index b410f56e167..111d6546966 100644
--- a/tests/ui/missing_doc_impl.stderr
+++ b/tests/ui/missing_doc_impl.stderr
@@ -21,60 +21,12 @@ error: missing documentation for a struct field
 LL |     b: isize,
    |     ^^^^^^^^
 
-error: missing documentation for a struct
-  --> $DIR/missing_doc_impl.rs:18:1
-   |
-LL | / pub struct PubFoo {
-LL | |     pub a: isize,
-LL | |     b: isize,
-LL | | }
-   | |_^
-
-error: missing documentation for a struct field
-  --> $DIR/missing_doc_impl.rs:19:5
-   |
-LL |     pub a: isize,
-   |     ^^^^^^^^^^^^
-
 error: missing documentation for a struct field
   --> $DIR/missing_doc_impl.rs:20:5
    |
 LL |     b: isize,
    |     ^^^^^^^^
 
-error: missing documentation for a trait
-  --> $DIR/missing_doc_impl.rs:43:1
-   |
-LL | / pub trait C {
-LL | |     fn foo(&self);
-LL | |     fn foo_with_impl(&self) {}
-LL | | }
-   | |_^
-
-error: missing documentation for a method
-  --> $DIR/missing_doc_impl.rs:44:5
-   |
-LL |     fn foo(&self);
-   |     ^^^^^^^^^^^^^^
-
-error: missing documentation for a method
-  --> $DIR/missing_doc_impl.rs:45:5
-   |
-LL |     fn foo_with_impl(&self) {}
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: missing documentation for an associated type
-  --> $DIR/missing_doc_impl.rs:55:5
-   |
-LL |     type AssociatedType;
-   |     ^^^^^^^^^^^^^^^^^^^^
-
-error: missing documentation for an associated type
-  --> $DIR/missing_doc_impl.rs:56:5
-   |
-LL |     type AssociatedTypeDef = Self;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
 error: missing documentation for an associated function
   --> $DIR/missing_doc_impl.rs:67:5
    |
@@ -89,12 +41,6 @@ error: missing documentation for an associated function
 LL |     fn bar() {}
    |     ^^^^^^^^^^^
 
-error: missing documentation for an associated function
-  --> $DIR/missing_doc_impl.rs:74:5
-   |
-LL |     pub fn foo() {}
-   |     ^^^^^^^^^^^^^^^
-
 error: missing documentation for an associated function
   --> $DIR/missing_doc_impl.rs:78:5
    |
@@ -103,5 +49,5 @@ LL | |         1
 LL | |     }
    | |_____^
 
-error: aborting due to 15 previous errors
+error: aborting due to 7 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 002e9341891c95886b3eb29dfa9be1d50d8096d4 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sun, 26 Feb 2023 02:55:52 -0500
Subject: Don't assume paths work with `fn_sig` in
 `multiple_unsafe_ops_pre_block`.

---
 clippy_lints/src/multiple_unsafe_ops_per_block.rs | 37 ++++----------
 tests/ui/multiple_unsafe_ops_per_block.rs         | 28 ++++++++++
 tests/ui/multiple_unsafe_ops_per_block.stderr     | 62 ++++++++++++++++++++++-
 3 files changed, 99 insertions(+), 28 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/multiple_unsafe_ops_per_block.rs b/clippy_lints/src/multiple_unsafe_ops_per_block.rs
index 63c575fca30..5418616ded0 100644
--- a/clippy_lints/src/multiple_unsafe_ops_per_block.rs
+++ b/clippy_lints/src/multiple_unsafe_ops_per_block.rs
@@ -11,6 +11,7 @@ use rustc_ast::Mutability;
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::lint::in_external_macro;
+use rustc_middle::ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::Span;
 
@@ -120,33 +121,15 @@ fn collect_unsafe_exprs<'tcx>(
                 unsafe_ops.push(("raw pointer dereference occurs here", expr.span));
             },
 
-            ExprKind::Call(path_expr, _) => match path_expr.kind {
-                ExprKind::Path(QPath::Resolved(
-                    _,
-                    hir::Path {
-                        res: Res::Def(kind, def_id),
-                        ..
-                    },
-                )) if kind.is_fn_like() => {
-                    let sig = cx.tcx.fn_sig(*def_id);
-                    if sig.0.unsafety() == Unsafety::Unsafe {
-                        unsafe_ops.push(("unsafe function call occurs here", expr.span));
-                    }
-                },
-
-                ExprKind::Path(QPath::TypeRelative(..)) => {
-                    if let Some(sig) = cx
-                        .typeck_results()
-                        .type_dependent_def_id(path_expr.hir_id)
-                        .map(|def_id| cx.tcx.fn_sig(def_id))
-                    {
-                        if sig.0.unsafety() == Unsafety::Unsafe {
-                            unsafe_ops.push(("unsafe function call occurs here", expr.span));
-                        }
-                    }
-                },
-
-                _ => {},
+            ExprKind::Call(path_expr, _) => {
+                let sig = match *cx.typeck_results().expr_ty(path_expr).kind() {
+                    ty::FnDef(id, _) => cx.tcx.fn_sig(id).skip_binder(),
+                    ty::FnPtr(sig) => sig,
+                    _ => return Continue(Descend::Yes),
+                };
+                if sig.unsafety() == Unsafety::Unsafe {
+                    unsafe_ops.push(("unsafe function call occurs here", expr.span));
+                }
             },
 
             ExprKind::MethodCall(..) => {
diff --git a/tests/ui/multiple_unsafe_ops_per_block.rs b/tests/ui/multiple_unsafe_ops_per_block.rs
index 4511bc99c3c..5073685c9f0 100644
--- a/tests/ui/multiple_unsafe_ops_per_block.rs
+++ b/tests/ui/multiple_unsafe_ops_per_block.rs
@@ -116,4 +116,32 @@ fn issue10259() {
     unsafe_macro!();
 }
 
+fn _fn_ptr(x: unsafe fn()) {
+    unsafe {
+        x();
+        x();
+    }
+}
+
+fn _assoc_const() {
+    trait X {
+        const X: unsafe fn();
+    }
+    fn _f<T: X>() {
+        unsafe {
+            T::X();
+            T::X();
+        }
+    }
+}
+
+fn _field_fn_ptr(x: unsafe fn()) {
+    struct X(unsafe fn());
+    let x = X(x);
+    unsafe {
+        x.0();
+        x.0();
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/multiple_unsafe_ops_per_block.stderr b/tests/ui/multiple_unsafe_ops_per_block.stderr
index 303aeb7aee0..e0c1d3801f7 100644
--- a/tests/ui/multiple_unsafe_ops_per_block.stderr
+++ b/tests/ui/multiple_unsafe_ops_per_block.stderr
@@ -125,5 +125,65 @@ note: raw pointer dereference occurs here
 LL |     unsafe { char::from_u32_unchecked(*ptr.cast::<u32>()) }
    |                                       ^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 5 previous errors
+error: this `unsafe` block contains 2 unsafe operations, expected only one
+  --> $DIR/multiple_unsafe_ops_per_block.rs:120:5
+   |
+LL | /     unsafe {
+LL | |         x();
+LL | |         x();
+LL | |     }
+   | |_____^
+   |
+note: unsafe function call occurs here
+  --> $DIR/multiple_unsafe_ops_per_block.rs:121:9
+   |
+LL |         x();
+   |         ^^^
+note: unsafe function call occurs here
+  --> $DIR/multiple_unsafe_ops_per_block.rs:122:9
+   |
+LL |         x();
+   |         ^^^
+
+error: this `unsafe` block contains 2 unsafe operations, expected only one
+  --> $DIR/multiple_unsafe_ops_per_block.rs:131:9
+   |
+LL | /         unsafe {
+LL | |             T::X();
+LL | |             T::X();
+LL | |         }
+   | |_________^
+   |
+note: unsafe function call occurs here
+  --> $DIR/multiple_unsafe_ops_per_block.rs:132:13
+   |
+LL |             T::X();
+   |             ^^^^^^
+note: unsafe function call occurs here
+  --> $DIR/multiple_unsafe_ops_per_block.rs:133:13
+   |
+LL |             T::X();
+   |             ^^^^^^
+
+error: this `unsafe` block contains 2 unsafe operations, expected only one
+  --> $DIR/multiple_unsafe_ops_per_block.rs:141:5
+   |
+LL | /     unsafe {
+LL | |         x.0();
+LL | |         x.0();
+LL | |     }
+   | |_____^
+   |
+note: unsafe function call occurs here
+  --> $DIR/multiple_unsafe_ops_per_block.rs:142:9
+   |
+LL |         x.0();
+   |         ^^^^^
+note: unsafe function call occurs here
+  --> $DIR/multiple_unsafe_ops_per_block.rs:143:9
+   |
+LL |         x.0();
+   |         ^^^^^
+
+error: aborting due to 8 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From c82ff00539c4441eddecd12151f54c30d1b03430 Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Sat, 25 Feb 2023 15:49:59 +0100
Subject: Do not suggest to derive Default on generics with implicit arguments

---
 clippy_lints/src/derivable_impls.rs | 21 +++++++++++++--------
 tests/ui/derivable_impls.fixed      | 37 +++++++++++++++++++++++++++++++++++++
 tests/ui/derivable_impls.rs         | 37 +++++++++++++++++++++++++++++++++++++
 3 files changed, 87 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/derivable_impls.rs b/clippy_lints/src/derivable_impls.rs
index f95b8ccf067..549ef2d24ca 100644
--- a/clippy_lints/src/derivable_impls.rs
+++ b/clippy_lints/src/derivable_impls.rs
@@ -8,7 +8,7 @@ use rustc_hir::{
     Body, Expr, ExprKind, GenericArg, Impl, ImplItemKind, Item, ItemKind, Node, PathSegment, QPath, Ty, TyKind,
 };
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty::{AdtDef, DefIdTree};
+use rustc_middle::ty::{Adt, AdtDef, DefIdTree, SubstsRef};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::sym;
 
@@ -81,13 +81,18 @@ fn check_struct<'tcx>(
     self_ty: &Ty<'_>,
     func_expr: &Expr<'_>,
     adt_def: AdtDef<'_>,
+    substs: SubstsRef<'_>,
 ) {
     if let TyKind::Path(QPath::Resolved(_, p)) = self_ty.kind {
-        if let Some(PathSegment { args: Some(a), .. }) = p.segments.last() {
-            for arg in a.args {
-                if !matches!(arg, GenericArg::Lifetime(_)) {
-                    return;
-                }
+        if let Some(PathSegment { args, .. }) = p.segments.last() {
+            let args = args.map(|a| a.args).unwrap_or(&[]);
+
+            // substs contains the generic parameters of the type declaration, while args contains the arguments
+            // used at instantiation time. If both len are not equal, it means that some parameters were not
+            // provided (which means that the default values were used); in this case we will not risk
+            // suggesting too broad a rewrite. We won't either if any argument is a type or a const.
+            if substs.len() != args.len() || args.iter().any(|arg| !matches!(arg, GenericArg::Lifetime(_))) {
+                return;
             }
         }
     }
@@ -184,7 +189,7 @@ impl<'tcx> LateLintPass<'tcx> for DerivableImpls {
             if let Some(Node::ImplItem(impl_item)) = cx.tcx.hir().find(impl_item_hir);
             if let ImplItemKind::Fn(_, b) = &impl_item.kind;
             if let Body { value: func_expr, .. } = cx.tcx.hir().body(*b);
-            if let Some(adt_def) = cx.tcx.type_of(item.owner_id).subst_identity().ty_adt_def();
+            if let &Adt(adt_def, substs) = cx.tcx.type_of(item.owner_id).subst_identity().kind();
             if let attrs = cx.tcx.hir().attrs(item.hir_id());
             if !attrs.iter().any(|attr| attr.doc_str().is_some());
             if let child_attrs = cx.tcx.hir().attrs(impl_item_hir);
@@ -192,7 +197,7 @@ impl<'tcx> LateLintPass<'tcx> for DerivableImpls {
 
             then {
                 if adt_def.is_struct() {
-                    check_struct(cx, item, self_ty, func_expr, adt_def);
+                    check_struct(cx, item, self_ty, func_expr, adt_def, substs);
                 } else if adt_def.is_enum() && self.msrv.meets(msrvs::DEFAULT_ENUM_ATTRIBUTE) {
                     check_enum(cx, item, func_expr, adt_def);
                 }
diff --git a/tests/ui/derivable_impls.fixed b/tests/ui/derivable_impls.fixed
index ee8456f5deb..89ec33a0d8f 100644
--- a/tests/ui/derivable_impls.fixed
+++ b/tests/ui/derivable_impls.fixed
@@ -231,4 +231,41 @@ impl Default for NonExhaustiveEnum {
     }
 }
 
+// https://github.com/rust-lang/rust-clippy/issues/10396
+
+#[derive(Default)]
+struct DefaultType;
+
+struct GenericType<T = DefaultType> {
+    t: T,
+}
+
+impl Default for GenericType {
+    fn default() -> Self {
+        Self { t: Default::default() }
+    }
+}
+
+struct InnerGenericType<T> {
+    t: T,
+}
+
+impl Default for InnerGenericType<DefaultType> {
+    fn default() -> Self {
+        Self { t: Default::default() }
+    }
+}
+
+struct OtherGenericType<T = DefaultType> {
+    inner: InnerGenericType<T>,
+}
+
+impl Default for OtherGenericType {
+    fn default() -> Self {
+        Self {
+            inner: Default::default(),
+        }
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/derivable_impls.rs b/tests/ui/derivable_impls.rs
index 14af419bcad..def6e41162f 100644
--- a/tests/ui/derivable_impls.rs
+++ b/tests/ui/derivable_impls.rs
@@ -267,4 +267,41 @@ impl Default for NonExhaustiveEnum {
     }
 }
 
+// https://github.com/rust-lang/rust-clippy/issues/10396
+
+#[derive(Default)]
+struct DefaultType;
+
+struct GenericType<T = DefaultType> {
+    t: T,
+}
+
+impl Default for GenericType {
+    fn default() -> Self {
+        Self { t: Default::default() }
+    }
+}
+
+struct InnerGenericType<T> {
+    t: T,
+}
+
+impl Default for InnerGenericType<DefaultType> {
+    fn default() -> Self {
+        Self { t: Default::default() }
+    }
+}
+
+struct OtherGenericType<T = DefaultType> {
+    inner: InnerGenericType<T>,
+}
+
+impl Default for OtherGenericType {
+    fn default() -> Self {
+        Self {
+            inner: Default::default(),
+        }
+    }
+}
+
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 5f3df6cfce616664177111df50f1e53c309cfbad Mon Sep 17 00:00:00 2001
From: Chris Down <chris@chrisdown.name>
Date: Sun, 26 Feb 2023 17:43:24 +0000
Subject: exit lint: potentualy -> potentially

---
 clippy_lints/src/exit.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/exit.rs b/clippy_lints/src/exit.rs
index 9c8b0d076df..8ba6a9e4876 100644
--- a/clippy_lints/src/exit.rs
+++ b/clippy_lints/src/exit.rs
@@ -11,7 +11,7 @@ declare_clippy_lint! {
     ///
     /// ### Why is this bad?
     /// Exit terminates the program at the location it is called. For unrecoverable
-    /// errors `panics` should be used to provide a stacktrace and potentualy other
+    /// errors `panics` should be used to provide a stacktrace and potentially other
     /// information. A normal termination or one with an error code should happen in
     /// the main function.
     ///
-- 
cgit 1.4.1-3-g733a5


From 2a9c254e23989df2faaaeb102e5fea8ce948f45e Mon Sep 17 00:00:00 2001
From: Michael Schubart <michael@schubart.net>
Date: Thu, 16 Feb 2023 18:12:11 +0000
Subject: Add `collection_is_never_read`

---
 CHANGELOG.md                                 |   1 +
 clippy_lints/src/collection_is_never_read.rs | 123 +++++++++++++++++++++++++++
 clippy_lints/src/declared_lints.rs           |   1 +
 clippy_lints/src/lib.rs                      |   2 +
 tests/ui/collection_is_never_read.rs         | 116 +++++++++++++++++++++++++
 tests/ui/collection_is_never_read.stderr     |  40 +++++++++
 6 files changed, 283 insertions(+)
 create mode 100644 clippy_lints/src/collection_is_never_read.rs
 create mode 100644 tests/ui/collection_is_never_read.rs
 create mode 100644 tests/ui/collection_is_never_read.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 765826ed867..f31e9825a17 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4307,6 +4307,7 @@ Released 2018-09-13
 [`collapsible_if`]: https://rust-lang.github.io/rust-clippy/master/index.html#collapsible_if
 [`collapsible_match`]: https://rust-lang.github.io/rust-clippy/master/index.html#collapsible_match
 [`collapsible_str_replace`]: https://rust-lang.github.io/rust-clippy/master/index.html#collapsible_str_replace
+[`collection_is_never_read`]: https://rust-lang.github.io/rust-clippy/master/index.html#collection_is_never_read
 [`comparison_chain`]: https://rust-lang.github.io/rust-clippy/master/index.html#comparison_chain
 [`comparison_to_empty`]: https://rust-lang.github.io/rust-clippy/master/index.html#comparison_to_empty
 [`const_static_lifetime`]: https://rust-lang.github.io/rust-clippy/master/index.html#const_static_lifetime
diff --git a/clippy_lints/src/collection_is_never_read.rs b/clippy_lints/src/collection_is_never_read.rs
new file mode 100644
index 00000000000..fbc66a2155f
--- /dev/null
+++ b/clippy_lints/src/collection_is_never_read.rs
@@ -0,0 +1,123 @@
+use clippy_utils::diagnostics::span_lint;
+use clippy_utils::get_enclosing_block;
+use clippy_utils::get_parent_node;
+use clippy_utils::path_to_local_id;
+use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::visitors::for_each_expr_with_closures;
+use core::ops::ControlFlow;
+use rustc_hir::Block;
+use rustc_hir::ExprKind;
+use rustc_hir::HirId;
+use rustc_hir::Local;
+use rustc_hir::Node;
+use rustc_hir::PatKind;
+use rustc_lint::LateContext;
+use rustc_lint::LateLintPass;
+use rustc_session::declare_lint_pass;
+use rustc_session::declare_tool_lint;
+use rustc_span::symbol::sym;
+use rustc_span::Symbol;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for collections that are never queried.
+    ///
+    /// ### Why is this bad?
+    /// Putting effort into constructing a collection but then never querying it might indicate that
+    /// the author forgot to do whatever they intended to do with the collection. Example: Clone
+    /// a vector, sort it for iteration, but then mistakenly iterate the original vector
+    /// instead.
+    ///
+    /// ### Example
+    /// ```rust
+    /// let mut sorted_samples = samples.clone();
+    /// sorted_samples.sort();
+    /// for sample in &samples { // Oops, meant to use `sorted_samples`.
+    ///     println!("{sample}");
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// let mut sorted_samples = samples.clone();
+    /// sorted_samples.sort();
+    /// for sample in &sorted_samples {
+    ///     println!("{sample}");
+    /// }
+    /// ```
+    #[clippy::version = "1.69.0"]
+    pub COLLECTION_IS_NEVER_READ,
+    nursery,
+    "a collection is never queried"
+}
+declare_lint_pass!(CollectionIsNeverRead => [COLLECTION_IS_NEVER_READ]);
+
+static COLLECTIONS: [Symbol; 10] = [
+    sym::BTreeMap,
+    sym::BTreeSet,
+    sym::BinaryHeap,
+    sym::HashMap,
+    sym::HashSet,
+    sym::LinkedList,
+    sym::Option,
+    sym::String,
+    sym::Vec,
+    sym::VecDeque,
+];
+
+impl<'tcx> LateLintPass<'tcx> for CollectionIsNeverRead {
+    fn check_local(&mut self, cx: &LateContext<'tcx>, local: &'tcx Local<'tcx>) {
+        // Look for local variables whose type is a container. Search surrounding bock for read access.
+        let ty = cx.typeck_results().pat_ty(local.pat);
+        if COLLECTIONS.iter().any(|&sym| is_type_diagnostic_item(cx, ty, sym))
+            && let PatKind::Binding(_, local_id, _, _) = local.pat.kind
+            && let Some(enclosing_block) = get_enclosing_block(cx, local.hir_id)
+            && has_no_read_access(cx, local_id, enclosing_block)
+        {
+            span_lint(cx, COLLECTION_IS_NEVER_READ, local.span, "collection is never read");
+        }
+    }
+}
+
+fn has_no_read_access<'tcx>(cx: &LateContext<'tcx>, id: HirId, block: &'tcx Block<'tcx>) -> bool {
+    let mut has_access = false;
+    let mut has_read_access = false;
+
+    // Inspect all expressions and sub-expressions in the block.
+    for_each_expr_with_closures(cx, block, |expr| {
+        // Ignore expressions that are not simply `id`.
+        if !path_to_local_id(expr, id) {
+            return ControlFlow::Continue(());
+        }
+
+        // `id` is being accessed. Investigate if it's a read access.
+        has_access = true;
+
+        // `id` appearing in the left-hand side of an assignment is not a read access:
+        //
+        // id = ...; // Not reading `id`.
+        if let Some(Node::Expr(parent)) = get_parent_node(cx.tcx, expr.hir_id)
+            && let ExprKind::Assign(lhs, ..) = parent.kind
+            && path_to_local_id(lhs, id)
+        {
+            return ControlFlow::Continue(());
+        }
+
+        // Method call on `id` in a statement ignores any return value, so it's not a read access:
+        //
+        // id.foo(...); // Not reading `id`.
+        if let Some(Node::Expr(parent)) = get_parent_node(cx.tcx, expr.hir_id)
+            && let ExprKind::MethodCall(_, receiver, _, _) = parent.kind
+            && path_to_local_id(receiver, id)
+            && let Some(Node::Stmt(..)) = get_parent_node(cx.tcx, parent.hir_id)
+        {
+            return ControlFlow::Continue(());
+        }
+
+        // Any other access to `id` is a read access. Stop searching.
+        has_read_access = true;
+        ControlFlow::Break(())
+    });
+
+    // Ignore collections that have no access at all. Other lints should catch them.
+    has_access && !has_read_access
+}
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index cd5dd7a5706..470a2e79e47 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -92,6 +92,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::cognitive_complexity::COGNITIVE_COMPLEXITY_INFO,
     crate::collapsible_if::COLLAPSIBLE_ELSE_IF_INFO,
     crate::collapsible_if::COLLAPSIBLE_IF_INFO,
+    crate::collection_is_never_read::COLLECTION_IS_NEVER_READ_INFO,
     crate::comparison_chain::COMPARISON_CHAIN_INFO,
     crate::copies::BRANCHES_SHARING_CODE_INFO,
     crate::copies::IFS_SAME_COND_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 145cf524652..c6ad7940b81 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -87,6 +87,7 @@ mod casts;
 mod checked_conversions;
 mod cognitive_complexity;
 mod collapsible_if;
+mod collection_is_never_read;
 mod comparison_chain;
 mod copies;
 mod copy_iterator;
@@ -924,6 +925,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         ))
     });
     store.register_late_pass(|_| Box::new(no_mangle_with_rust_abi::NoMangleWithRustAbi));
+    store.register_late_pass(|_| Box::new(collection_is_never_read::CollectionIsNeverRead));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/tests/ui/collection_is_never_read.rs b/tests/ui/collection_is_never_read.rs
new file mode 100644
index 00000000000..2c37fc212b0
--- /dev/null
+++ b/tests/ui/collection_is_never_read.rs
@@ -0,0 +1,116 @@
+#![allow(unused)]
+#![warn(clippy::collection_is_never_read)]
+
+use std::collections::HashMap;
+
+fn main() {}
+
+fn not_a_collection() {
+    // TODO: Expand `collection_is_never_read` beyond collections?
+    let mut x = 10; // Ok
+    x += 1;
+}
+
+fn no_access_at_all() {
+    // Other lints should catch this.
+    let x = vec![1, 2, 3]; // Ok
+}
+
+fn write_without_read() {
+    // The main use case for `collection_is_never_read`.
+    let mut x = HashMap::new(); // WARNING
+    x.insert(1, 2);
+}
+
+fn read_without_write() {
+    let mut x = vec![1, 2, 3]; // Ok
+    let _ = x.len();
+}
+
+fn write_and_read() {
+    let mut x = vec![1, 2, 3]; // Ok
+    x.push(4);
+    let _ = x.len();
+}
+
+fn write_after_read() {
+    // TODO: Warn here, but this requires more extensive data flow analysis.
+    let mut x = vec![1, 2, 3]; // Ok
+    let _ = x.len();
+    x.push(4); // Pointless
+}
+
+fn write_before_reassign() {
+    // TODO: Warn here, but this requires more extensive data flow analysis.
+    let mut x = HashMap::new(); // Ok
+    x.insert(1, 2); // Pointless
+    x = HashMap::new();
+    let _ = x.len();
+}
+
+fn read_in_closure() {
+    let mut x = HashMap::new(); // Ok
+    x.insert(1, 2);
+    let _ = || {
+        let _ = x.len();
+    };
+}
+
+fn write_in_closure() {
+    let mut x = vec![1, 2, 3]; // WARNING
+    let _ = || {
+        x.push(4);
+    };
+}
+
+fn read_in_format() {
+    let mut x = HashMap::new(); // Ok
+    x.insert(1, 2);
+    format!("{x:?}");
+}
+
+fn shadowing_1() {
+    let x = HashMap::<usize, usize>::new(); // Ok
+    let _ = x.len();
+    let mut x = HashMap::new(); // WARNING
+    x.insert(1, 2);
+}
+
+fn shadowing_2() {
+    let mut x = HashMap::new(); // WARNING
+    x.insert(1, 2);
+    let x = HashMap::<usize, usize>::new(); // Ok
+    let _ = x.len();
+}
+
+#[allow(clippy::let_unit_value)]
+fn fake_read() {
+    let mut x = vec![1, 2, 3]; // Ok
+    x.reverse();
+    // `collection_is_never_read` gets fooled, but other lints should catch this.
+    let _: () = x.clear();
+}
+
+fn assignment() {
+    let mut x = vec![1, 2, 3]; // WARNING
+    let y = vec![4, 5, 6]; // Ok
+    x = y;
+}
+
+#[allow(clippy::self_assignment)]
+fn self_assignment() {
+    let mut x = vec![1, 2, 3]; // WARNING
+    x = x;
+}
+
+fn method_argument_but_not_target() {
+    struct MyStruct;
+    impl MyStruct {
+        fn my_method(&self, _argument: &[usize]) {}
+    }
+    let my_struct = MyStruct;
+
+    let mut x = vec![1, 2, 3]; // Ok
+    x.reverse();
+    my_struct.my_method(&x);
+}
diff --git a/tests/ui/collection_is_never_read.stderr b/tests/ui/collection_is_never_read.stderr
new file mode 100644
index 00000000000..43349f550a6
--- /dev/null
+++ b/tests/ui/collection_is_never_read.stderr
@@ -0,0 +1,40 @@
+error: collection is never read
+  --> $DIR/collection_is_never_read.rs:21:5
+   |
+LL |     let mut x = HashMap::new(); // WARNING
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::collection-is-never-read` implied by `-D warnings`
+
+error: collection is never read
+  --> $DIR/collection_is_never_read.rs:60:5
+   |
+LL |     let mut x = vec![1, 2, 3]; // WARNING
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: collection is never read
+  --> $DIR/collection_is_never_read.rs:75:5
+   |
+LL |     let mut x = HashMap::new(); // WARNING
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: collection is never read
+  --> $DIR/collection_is_never_read.rs:80:5
+   |
+LL |     let mut x = HashMap::new(); // WARNING
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: collection is never read
+  --> $DIR/collection_is_never_read.rs:95:5
+   |
+LL |     let mut x = vec![1, 2, 3]; // WARNING
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: collection is never read
+  --> $DIR/collection_is_never_read.rs:102:5
+   |
+LL |     let mut x = vec![1, 2, 3]; // WARNING
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 6 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 08708198fbb8eb4bd8df76bded9fcdb32adb8163 Mon Sep 17 00:00:00 2001
From: Michael Schubart <michael@schubart.net>
Date: Mon, 27 Feb 2023 19:31:59 +0000
Subject: Fix lint documentation

---
 clippy_lints/src/collection_is_never_read.rs | 2 ++
 1 file changed, 2 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/collection_is_never_read.rs b/clippy_lints/src/collection_is_never_read.rs
index fbc66a2155f..f20c09a4448 100644
--- a/clippy_lints/src/collection_is_never_read.rs
+++ b/clippy_lints/src/collection_is_never_read.rs
@@ -30,6 +30,7 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust
+    /// # let samples = vec![3, 1, 2];
     /// let mut sorted_samples = samples.clone();
     /// sorted_samples.sort();
     /// for sample in &samples { // Oops, meant to use `sorted_samples`.
@@ -38,6 +39,7 @@ declare_clippy_lint! {
     /// ```
     /// Use instead:
     /// ```rust
+    /// # let samples = vec![3, 1, 2];
     /// let mut sorted_samples = samples.clone();
     /// sorted_samples.sort();
     /// for sample in &sorted_samples {
-- 
cgit 1.4.1-3-g733a5


From 03a3f743652e3909d27f8b9efcba19ce0ac02206 Mon Sep 17 00:00:00 2001
From: Andreas Deininger <andreas@deininger.net>
Date: Mon, 27 Feb 2023 21:17:25 +0100
Subject: Fixing typos

---
 book/src/development/proposals/syntax-tree-patterns.md | 14 +++++++-------
 clippy_lints/src/functions/impl_trait_in_params.rs     |  4 ++--
 clippy_lints/src/functions/misnamed_getters.rs         |  2 +-
 clippy_lints/src/matches/mod.rs                        |  2 +-
 clippy_utils/src/lib.rs                                |  2 +-
 tests/ui/impl_trait_in_params.stderr                   |  4 ++--
 tests/ui/implicit_clone.fixed                          |  2 +-
 tests/ui/implicit_clone.rs                             |  2 +-
 tests/ui/new_ret_no_self.rs                            |  2 +-
 9 files changed, 17 insertions(+), 17 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/book/src/development/proposals/syntax-tree-patterns.md b/book/src/development/proposals/syntax-tree-patterns.md
index c5587c4bf90..ea4978011b1 100644
--- a/book/src/development/proposals/syntax-tree-patterns.md
+++ b/book/src/development/proposals/syntax-tree-patterns.md
@@ -68,13 +68,13 @@ The second part of the motivation is clippy's dependence on unstable
 compiler-internal data structures. Clippy lints are currently written against
 the compiler's AST / HIR which means that even small changes in these data
 structures might break a lot of lints. The second goal of this RFC is to **make
-lints independant of the compiler's AST / HIR data structures**.
+lints independent of the compiler's AST / HIR data structures**.
 
 # Approach
 
 A lot of complexity in writing lints currently seems to come from having to
 manually implement the matching logic (see code samples above). It's an
-imparative style that describes *how* to match a syntax tree node instead of
+imperative style that describes *how* to match a syntax tree node instead of
 specifying *what* should be matched against declaratively. In other areas, it's
 common to use declarative patterns to describe desired information and let the
 implementation do the actual matching. A well-known example of this approach are
@@ -270,7 +270,7 @@ pattern!{
     // matches if expressions that **may or may not** have an else block
     // Attn: `If(_, _, _)` matches only ifs that **have** an else block
     //
-    //              | if with else block | if witout else block
+    //              | if with else block | if without else block
     // If(_, _, _)  |       match        |       no match
     // If(_, _, _?) |       match        |        match
     // If(_, _, ()) |      no match      |        match
@@ -568,7 +568,7 @@ another example, `Array( Lit(_)* )` is a valid pattern because the parameter of
 
 ## The IsMatch Trait
 
-The pattern syntax and the *PatternTree* are independant of specific syntax tree
+The pattern syntax and the *PatternTree* are independent of specific syntax tree
 implementations (rust ast / hir, syn, ...). When looking at the different
 pattern examples in the previous sections, it can be seen that the patterns
 don't contain any information specific to a certain syntax tree implementation.
@@ -717,7 +717,7 @@ if false {
 #### Problems
 
 Extending Rust syntax (which is quite complex by itself) with additional syntax
-needed for specifying patterns (alternations, sequences, repetisions, named
+needed for specifying patterns (alternations, sequences, repetitions, named
 submatches, ...) might become difficult to read and really hard to parse
 properly.
 
@@ -858,7 +858,7 @@ would be evaluated as soon as the `Block(_)#then` was matched.
 Another idea in this area would be to introduce a syntax for backreferences.
 They could be used to require that multiple parts of a pattern should match the
 same value. For example, the `assign_op_pattern` lint that searches for `a = a
-op b` and recommends changing it to `a op= b` requires that both occurrances of
+op b` and recommends changing it to `a op= b` requires that both occurrences of
 `a` are the same. Using `=#...` as syntax for backreferences, the lint could be
 implemented like this:
 
@@ -882,7 +882,7 @@ least two return statements" could be a practical addition.
 For patterns like "a literal that is not a boolean literal" one currently needs
 to list all alternatives except the boolean case. Introducing a negation
 operator that allows to write `Lit(!Bool(_))` might be a good idea. This pattern
-would be eqivalent to `Lit( Char(_) | Int(_) )` (given that currently only three
+would be equivalent to `Lit( Char(_) | Int(_) )` (given that currently only three
 literal types are implemented).
 
 #### Functional composition
diff --git a/clippy_lints/src/functions/impl_trait_in_params.rs b/clippy_lints/src/functions/impl_trait_in_params.rs
index 2811a73f6c1..d3d0d91c1be 100644
--- a/clippy_lints/src/functions/impl_trait_in_params.rs
+++ b/clippy_lints/src/functions/impl_trait_in_params.rs
@@ -22,7 +22,7 @@ pub(super) fn check_fn<'tcx>(cx: &LateContext<'_>, kind: &'tcx FnKind<'_>, body:
                             if let Some(gen_span) = generics.span_for_param_suggestion() {
                                 diag.span_suggestion_with_style(
                                     gen_span,
-                                    "add a type paremeter",
+                                    "add a type parameter",
                                     format!(", {{ /* Generic name */ }}: {}", &param.name.ident().as_str()[5..]),
                                     rustc_errors::Applicability::HasPlaceholders,
                                     rustc_errors::SuggestionStyle::ShowAlways,
@@ -35,7 +35,7 @@ pub(super) fn check_fn<'tcx>(cx: &LateContext<'_>, kind: &'tcx FnKind<'_>, body:
                                         ident.span.ctxt(),
                                         ident.span.parent(),
                                     ),
-                                    "add a type paremeter",
+                                    "add a type parameter",
                                     format!("<{{ /* Generic name */ }}: {}>", &param.name.ident().as_str()[5..]),
                                     rustc_errors::Applicability::HasPlaceholders,
                                     rustc_errors::SuggestionStyle::ShowAlways,
diff --git a/clippy_lints/src/functions/misnamed_getters.rs b/clippy_lints/src/functions/misnamed_getters.rs
index 8b53ee68ebd..e5945939e60 100644
--- a/clippy_lints/src/functions/misnamed_getters.rs
+++ b/clippy_lints/src/functions/misnamed_getters.rs
@@ -97,7 +97,7 @@ pub fn check_fn(cx: &LateContext<'_>, kind: FnKind<'_>, decl: &FnDecl<'_>, body:
 
     let Some(correct_field) = correct_field else {
         // There is no field corresponding to the getter name.
-        // FIXME: This can be a false positive if the correct field is reachable trought deeper autodereferences than used_field is
+        // FIXME: This can be a false positive if the correct field is reachable through deeper autodereferences than used_field is
         return;
     };
 
diff --git a/clippy_lints/src/matches/mod.rs b/clippy_lints/src/matches/mod.rs
index 7b15a307fec..97ecca450fa 100644
--- a/clippy_lints/src/matches/mod.rs
+++ b/clippy_lints/src/matches/mod.rs
@@ -925,7 +925,7 @@ declare_clippy_lint! {
     #[clippy::version = "1.66.0"]
     pub MANUAL_FILTER,
     complexity,
-    "reimplentation of `filter`"
+    "reimplementation of `filter`"
 }
 
 #[derive(Default)]
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index f02f8ecb43d..213e5b33503 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -617,7 +617,7 @@ fn item_children_by_name(tcx: TyCtxt<'_>, def_id: DefId, name: Symbol) -> Vec<Re
 /// Can return multiple resolutions when there are multiple versions of the same crate, e.g.
 /// `memchr::memchr` could return the functions from both memchr 1.0 and memchr 2.0.
 ///
-/// Also returns multiple results when there are mulitple paths under the same name e.g. `std::vec`
+/// Also returns multiple results when there are multiple paths under the same name e.g. `std::vec`
 /// would have both a [`DefKind::Mod`] and [`DefKind::Macro`].
 ///
 /// This function is expensive and should be used sparingly.
diff --git a/tests/ui/impl_trait_in_params.stderr b/tests/ui/impl_trait_in_params.stderr
index acfcc21445e..80383743525 100644
--- a/tests/ui/impl_trait_in_params.stderr
+++ b/tests/ui/impl_trait_in_params.stderr
@@ -5,7 +5,7 @@ LL | pub fn a(_: impl Trait) {}
    |             ^^^^^^^^^^
    |
    = note: `-D clippy::impl-trait-in-params` implied by `-D warnings`
-help: add a type paremeter
+help: add a type parameter
    |
 LL | pub fn a<{ /* Generic name */ }: Trait>(_: impl Trait) {}
    |         +++++++++++++++++++++++++++++++
@@ -16,7 +16,7 @@ error: '`impl Trait` used as a function parameter'
 LL | pub fn c<C: Trait>(_: C, _: impl Trait) {}
    |                             ^^^^^^^^^^
    |
-help: add a type paremeter
+help: add a type parameter
    |
 LL | pub fn c<C: Trait, { /* Generic name */ }: Trait>(_: C, _: impl Trait) {}
    |                  +++++++++++++++++++++++++++++++
diff --git a/tests/ui/implicit_clone.fixed b/tests/ui/implicit_clone.fixed
index 51b1afbe5ac..8ccc3da7b47 100644
--- a/tests/ui/implicit_clone.fixed
+++ b/tests/ui/implicit_clone.fixed
@@ -87,7 +87,7 @@ fn main() {
     let kitten = Kitten {};
     let _ = kitten.clone();
     let _ = own_same_from_ref(&kitten);
-    // this shouln't lint
+    // this shouldn't lint
     let _ = kitten.to_vec();
 
     // we expect no lints for this
diff --git a/tests/ui/implicit_clone.rs b/tests/ui/implicit_clone.rs
index 8a9027433d9..59333312607 100644
--- a/tests/ui/implicit_clone.rs
+++ b/tests/ui/implicit_clone.rs
@@ -87,7 +87,7 @@ fn main() {
     let kitten = Kitten {};
     let _ = kitten.to_owned();
     let _ = own_same_from_ref(&kitten);
-    // this shouln't lint
+    // this shouldn't lint
     let _ = kitten.to_vec();
 
     // we expect no lints for this
diff --git a/tests/ui/new_ret_no_self.rs b/tests/ui/new_ret_no_self.rs
index beec42f08bb..a2a30c8b931 100644
--- a/tests/ui/new_ret_no_self.rs
+++ b/tests/ui/new_ret_no_self.rs
@@ -406,7 +406,7 @@ mod issue10041 {
     struct Bomb;
 
     impl Bomb {
-        // Hidden <Rhs = Self> default generic paramter.
+        // Hidden <Rhs = Self> default generic parameter.
         pub fn new() -> impl PartialOrd {
             0i32
         }
-- 
cgit 1.4.1-3-g733a5


From 003a2119e7ffe70ee341ebc2bde3866783db8d9d Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Mon, 27 Feb 2023 22:01:12 -0500
Subject: Improve diagnostic of `no_mangle_with_rust_abi`

---
 clippy_lints/src/no_mangle_with_rust_abi.rs | 28 ++++++-----
 tests/ui/no_mangle_with_rust_abi.fixed      | 48 -------------------
 tests/ui/no_mangle_with_rust_abi.rs         |  2 -
 tests/ui/no_mangle_with_rust_abi.stderr     | 74 +++++++++++++++++++++--------
 4 files changed, 71 insertions(+), 81 deletions(-)
 delete mode 100644 tests/ui/no_mangle_with_rust_abi.fixed

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/no_mangle_with_rust_abi.rs b/clippy_lints/src/no_mangle_with_rust_abi.rs
index bc64ccb295c..8fd9ae351a0 100644
--- a/clippy_lints/src/no_mangle_with_rust_abi.rs
+++ b/clippy_lints/src/no_mangle_with_rust_abi.rs
@@ -1,9 +1,10 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet_with_applicability;
 use rustc_errors::Applicability;
 use rustc_hir::{Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::{BytePos, Pos};
 use rustc_target::spec::abi::Abi;
 
 declare_clippy_lint! {
@@ -38,25 +39,28 @@ impl<'tcx> LateLintPass<'tcx> for NoMangleWithRustAbi {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
         if let ItemKind::Fn(fn_sig, _, _) = &item.kind {
             let attrs = cx.tcx.hir().attrs(item.hir_id());
-            let mut applicability = Applicability::MachineApplicable;
-            let snippet = snippet_with_applicability(cx, fn_sig.span, "..", &mut applicability);
+            let mut app = Applicability::MaybeIncorrect;
+            let snippet = snippet_with_applicability(cx, fn_sig.span, "..", &mut app);
             for attr in attrs {
                 if let Some(ident) = attr.ident()
                     && ident.name == rustc_span::sym::no_mangle
                     && fn_sig.header.abi == Abi::Rust
-                    && !snippet.contains("extern") {
+                    && let Some((fn_attrs, _)) = snippet.split_once("fn")
+                    && !fn_attrs.contains("extern")
+                {
+                    let sugg_span = fn_sig.span
+                        .with_lo(fn_sig.span.lo() + BytePos::from_usize(fn_attrs.len()))
+                        .shrink_to_lo();
 
-                    let suggestion = snippet.split_once("fn")
-                        .map_or(String::new(), |(first, second)| format!(r#"{first}extern "C" fn{second}"#));
-
-                    span_lint_and_sugg(
+                    span_lint_and_then(
                         cx,
                         NO_MANGLE_WITH_RUST_ABI,
                         fn_sig.span,
-                        "attribute #[no_mangle] set on a Rust ABI function",
-                        "try",
-                        suggestion,
-                        applicability
+                        "`#[no_mangle]` set on a function with the default (`Rust`) ABI",
+                        |diag| {
+                            diag.span_suggestion(sugg_span, "set an ABI", "extern \"C\" ", app)
+                                .span_suggestion(sugg_span, "or explicitly set the default", "extern \"Rust\" ", app);
+                        },
                     );
                 }
             }
diff --git a/tests/ui/no_mangle_with_rust_abi.fixed b/tests/ui/no_mangle_with_rust_abi.fixed
deleted file mode 100644
index d18dec22a8b..00000000000
--- a/tests/ui/no_mangle_with_rust_abi.fixed
+++ /dev/null
@@ -1,48 +0,0 @@
-// run-rustfix
-
-#![allow(unused)]
-#![warn(clippy::no_mangle_with_rust_abi)]
-
-#[no_mangle]
-extern "C" fn rust_abi_fn_one(arg_one: u32, arg_two: usize) {}
-
-#[no_mangle]
-pub extern "C" fn rust_abi_fn_two(arg_one: u32, arg_two: usize) {}
-
-/// # Safety
-/// This function shouldn't be called unless the horsemen are ready
-#[no_mangle]
-pub unsafe extern "C" fn rust_abi_fn_three(arg_one: u32, arg_two: usize) {}
-
-/// # Safety
-/// This function shouldn't be called unless the horsemen are ready
-#[no_mangle]
-unsafe extern "C" fn rust_abi_fn_four(arg_one: u32, arg_two: usize) {}
-
-#[no_mangle]
-extern "C" fn rust_abi_multiline_function_really_long_name_to_overflow_args_to_multiple_lines(
-    arg_one: u32,
-    arg_two: usize,
-) -> u32 {
-    0
-}
-
-// Must not run on functions that explicitly opt in to Rust ABI with `extern "Rust"`
-#[no_mangle]
-#[rustfmt::skip]
-extern "Rust" fn rust_abi_fn_explicit_opt_in(arg_one: u32, arg_two: usize) {}
-
-fn rust_abi_fn_again(arg_one: u32, arg_two: usize) {}
-
-#[no_mangle]
-extern "C" fn c_abi_fn(arg_one: u32, arg_two: usize) {}
-
-extern "C" fn c_abi_fn_again(arg_one: u32, arg_two: usize) {}
-
-extern "C" {
-    fn c_abi_in_block(arg_one: u32, arg_two: usize);
-}
-
-fn main() {
-    // test code goes here
-}
diff --git a/tests/ui/no_mangle_with_rust_abi.rs b/tests/ui/no_mangle_with_rust_abi.rs
index 481e1b6d961..b32e721110e 100644
--- a/tests/ui/no_mangle_with_rust_abi.rs
+++ b/tests/ui/no_mangle_with_rust_abi.rs
@@ -1,5 +1,3 @@
-// run-rustfix
-
 #![allow(unused)]
 #![warn(clippy::no_mangle_with_rust_abi)]
 
diff --git a/tests/ui/no_mangle_with_rust_abi.stderr b/tests/ui/no_mangle_with_rust_abi.stderr
index 71517d31809..da5d31d8f2d 100644
--- a/tests/ui/no_mangle_with_rust_abi.stderr
+++ b/tests/ui/no_mangle_with_rust_abi.stderr
@@ -1,31 +1,66 @@
-error: attribute #[no_mangle] set on a Rust ABI function
-  --> $DIR/no_mangle_with_rust_abi.rs:7:1
+error: `#[no_mangle]` set on a function with the default (`Rust`) ABI
+  --> $DIR/no_mangle_with_rust_abi.rs:5:1
    |
 LL | fn rust_abi_fn_one(arg_one: u32, arg_two: usize) {}
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `extern "C" fn rust_abi_fn_one(arg_one: u32, arg_two: usize)`
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::no-mangle-with-rust-abi` implied by `-D warnings`
+help: set an ABI
+   |
+LL | extern "C" fn rust_abi_fn_one(arg_one: u32, arg_two: usize) {}
+   | ++++++++++
+help: or explicitly set the default
+   |
+LL | extern "Rust" fn rust_abi_fn_one(arg_one: u32, arg_two: usize) {}
+   | +++++++++++++
 
-error: attribute #[no_mangle] set on a Rust ABI function
-  --> $DIR/no_mangle_with_rust_abi.rs:10:1
+error: `#[no_mangle]` set on a function with the default (`Rust`) ABI
+  --> $DIR/no_mangle_with_rust_abi.rs:8:1
    |
 LL | pub fn rust_abi_fn_two(arg_one: u32, arg_two: usize) {}
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `pub extern "C" fn rust_abi_fn_two(arg_one: u32, arg_two: usize)`
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: set an ABI
+   |
+LL | pub extern "C" fn rust_abi_fn_two(arg_one: u32, arg_two: usize) {}
+   |     ++++++++++
+help: or explicitly set the default
+   |
+LL | pub extern "Rust" fn rust_abi_fn_two(arg_one: u32, arg_two: usize) {}
+   |     +++++++++++++
 
-error: attribute #[no_mangle] set on a Rust ABI function
-  --> $DIR/no_mangle_with_rust_abi.rs:15:1
+error: `#[no_mangle]` set on a function with the default (`Rust`) ABI
+  --> $DIR/no_mangle_with_rust_abi.rs:13:1
    |
 LL | pub unsafe fn rust_abi_fn_three(arg_one: u32, arg_two: usize) {}
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `pub unsafe extern "C" fn rust_abi_fn_three(arg_one: u32, arg_two: usize)`
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: set an ABI
+   |
+LL | pub unsafe extern "C" fn rust_abi_fn_three(arg_one: u32, arg_two: usize) {}
+   |            ++++++++++
+help: or explicitly set the default
+   |
+LL | pub unsafe extern "Rust" fn rust_abi_fn_three(arg_one: u32, arg_two: usize) {}
+   |            +++++++++++++
 
-error: attribute #[no_mangle] set on a Rust ABI function
-  --> $DIR/no_mangle_with_rust_abi.rs:20:1
+error: `#[no_mangle]` set on a function with the default (`Rust`) ABI
+  --> $DIR/no_mangle_with_rust_abi.rs:18:1
    |
 LL | unsafe fn rust_abi_fn_four(arg_one: u32, arg_two: usize) {}
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unsafe extern "C" fn rust_abi_fn_four(arg_one: u32, arg_two: usize)`
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: set an ABI
+   |
+LL | unsafe extern "C" fn rust_abi_fn_four(arg_one: u32, arg_two: usize) {}
+   |        ++++++++++
+help: or explicitly set the default
+   |
+LL | unsafe extern "Rust" fn rust_abi_fn_four(arg_one: u32, arg_two: usize) {}
+   |        +++++++++++++
 
-error: attribute #[no_mangle] set on a Rust ABI function
-  --> $DIR/no_mangle_with_rust_abi.rs:23:1
+error: `#[no_mangle]` set on a function with the default (`Rust`) ABI
+  --> $DIR/no_mangle_with_rust_abi.rs:21:1
    |
 LL | / fn rust_abi_multiline_function_really_long_name_to_overflow_args_to_multiple_lines(
 LL | |     arg_one: u32,
@@ -33,13 +68,14 @@ LL | |     arg_two: usize,
 LL | | ) -> u32 {
    | |________^
    |
-help: try
+help: set an ABI
    |
-LL + extern "C" fn rust_abi_multiline_function_really_long_name_to_overflow_args_to_multiple_lines(
-LL +     arg_one: u32,
-LL +     arg_two: usize,
-LL ~ ) -> u32 {
+LL | extern "C" fn rust_abi_multiline_function_really_long_name_to_overflow_args_to_multiple_lines(
+   | ++++++++++
+help: or explicitly set the default
    |
+LL | extern "Rust" fn rust_abi_multiline_function_really_long_name_to_overflow_args_to_multiple_lines(
+   | +++++++++++++
 
 error: aborting due to 5 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 2cadea5dc5db67212e264ec0a66b3c04e38e41c1 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Tue, 28 Feb 2023 12:45:19 +0000
Subject: Fix array-size-threshold config deserialization error

---
 book/src/lint_configuration.md                     |  2 +-
 clippy_lints/src/lib.rs                            |  2 +-
 clippy_lints/src/utils/conf.rs                     |  2 +-
 .../array_size_threshold/array_size_threshold.rs   | 10 ++++++++
 .../array_size_threshold.stderr                    | 29 ++++++++++++++++++++++
 tests/ui-toml/array_size_threshold/clippy.toml     |  1 +
 tests/ui/crashes/ice-10044.rs                      |  3 ---
 tests/ui/crashes/ice-10044.stderr                  | 10 --------
 tests/ui/large_stack_arrays.rs                     |  1 +
 tests/ui/large_stack_arrays.stderr                 | 10 +++++++-
 10 files changed, 53 insertions(+), 17 deletions(-)
 create mode 100644 tests/ui-toml/array_size_threshold/array_size_threshold.rs
 create mode 100644 tests/ui-toml/array_size_threshold/array_size_threshold.stderr
 create mode 100644 tests/ui-toml/array_size_threshold/clippy.toml
 delete mode 100644 tests/ui/crashes/ice-10044.rs
 delete mode 100644 tests/ui/crashes/ice-10044.stderr

(limited to 'clippy_lints/src')

diff --git a/book/src/lint_configuration.md b/book/src/lint_configuration.md
index 33f2b5c1de9..995dd2f04b1 100644
--- a/book/src/lint_configuration.md
+++ b/book/src/lint_configuration.md
@@ -306,7 +306,7 @@ The maximum number of lines a function or method can have
 ### array-size-threshold
 The maximum allowed size for arrays on the stack
 
-**Default Value:** `512000` (`u128`)
+**Default Value:** `512000` (`u64`)
 
 * [large_stack_arrays](https://rust-lang.github.io/rust-clippy/master/index.html#large_stack_arrays)
 * [large_const_arrays](https://rust-lang.github.io/rust-clippy/master/index.html#large_const_arrays)
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 145cf524652..c626e0bd998 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -777,7 +777,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(mutable_debug_assertion::DebugAssertWithMutCall));
     store.register_late_pass(|_| Box::new(exit::Exit));
     store.register_late_pass(|_| Box::new(to_digit_is_some::ToDigitIsSome));
-    let array_size_threshold = conf.array_size_threshold;
+    let array_size_threshold = u128::from(conf.array_size_threshold);
     store.register_late_pass(move |_| Box::new(large_stack_arrays::LargeStackArrays::new(array_size_threshold)));
     store.register_late_pass(move |_| Box::new(large_const_arrays::LargeConstArrays::new(array_size_threshold)));
     store.register_late_pass(|_| Box::new(floating_point_arithmetic::FloatingPointArithmetic));
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 5f74de5a288..1c7f3e96db8 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -334,7 +334,7 @@ define_Conf! {
     /// Lint: LARGE_STACK_ARRAYS, LARGE_CONST_ARRAYS.
     ///
     /// The maximum allowed size for arrays on the stack
-    (array_size_threshold: u128 = 512_000),
+    (array_size_threshold: u64 = 512_000),
     /// Lint: VEC_BOX.
     ///
     /// The size of the boxed type in bytes, where boxing in a `Vec` is allowed
diff --git a/tests/ui-toml/array_size_threshold/array_size_threshold.rs b/tests/ui-toml/array_size_threshold/array_size_threshold.rs
new file mode 100644
index 00000000000..7f623c7a9ec
--- /dev/null
+++ b/tests/ui-toml/array_size_threshold/array_size_threshold.rs
@@ -0,0 +1,10 @@
+#![allow(unused)]
+#![warn(clippy::large_const_arrays, clippy::large_stack_arrays)]
+
+const ABOVE: [u8; 11] = [0; 11];
+const BELOW: [u8; 10] = [0; 10];
+
+fn main() {
+    let above = [0u8; 11];
+    let below = [0u8; 10];
+}
diff --git a/tests/ui-toml/array_size_threshold/array_size_threshold.stderr b/tests/ui-toml/array_size_threshold/array_size_threshold.stderr
new file mode 100644
index 00000000000..ac017b20916
--- /dev/null
+++ b/tests/ui-toml/array_size_threshold/array_size_threshold.stderr
@@ -0,0 +1,29 @@
+error: large array defined as const
+  --> $DIR/array_size_threshold.rs:4:1
+   |
+LL | const ABOVE: [u8; 11] = [0; 11];
+   | -----^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   | |
+   | help: make this a static item: `static`
+   |
+   = note: `-D clippy::large-const-arrays` implied by `-D warnings`
+
+error: allocating a local array larger than 10 bytes
+  --> $DIR/array_size_threshold.rs:4:25
+   |
+LL | const ABOVE: [u8; 11] = [0; 11];
+   |                         ^^^^^^^
+   |
+   = help: consider allocating on the heap with `vec![0; 11].into_boxed_slice()`
+   = note: `-D clippy::large-stack-arrays` implied by `-D warnings`
+
+error: allocating a local array larger than 10 bytes
+  --> $DIR/array_size_threshold.rs:8:17
+   |
+LL |     let above = [0u8; 11];
+   |                 ^^^^^^^^^
+   |
+   = help: consider allocating on the heap with `vec![0u8; 11].into_boxed_slice()`
+
+error: aborting due to 3 previous errors
+
diff --git a/tests/ui-toml/array_size_threshold/clippy.toml b/tests/ui-toml/array_size_threshold/clippy.toml
new file mode 100644
index 00000000000..3f1fe9a1209
--- /dev/null
+++ b/tests/ui-toml/array_size_threshold/clippy.toml
@@ -0,0 +1 @@
+array-size-threshold = 10
diff --git a/tests/ui/crashes/ice-10044.rs b/tests/ui/crashes/ice-10044.rs
deleted file mode 100644
index 65f38fe7118..00000000000
--- a/tests/ui/crashes/ice-10044.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-fn main() {
-    [0; usize::MAX];
-}
diff --git a/tests/ui/crashes/ice-10044.stderr b/tests/ui/crashes/ice-10044.stderr
deleted file mode 100644
index 731f8265ad6..00000000000
--- a/tests/ui/crashes/ice-10044.stderr
+++ /dev/null
@@ -1,10 +0,0 @@
-error: statement with no effect
-  --> $DIR/ice-10044.rs:2:5
-   |
-LL |     [0; usize::MAX];
-   |     ^^^^^^^^^^^^^^^^
-   |
-   = note: `-D clippy::no-effect` implied by `-D warnings`
-
-error: aborting due to previous error
-
diff --git a/tests/ui/large_stack_arrays.rs b/tests/ui/large_stack_arrays.rs
index 6790765f803..99787ffd3d3 100644
--- a/tests/ui/large_stack_arrays.rs
+++ b/tests/ui/large_stack_arrays.rs
@@ -24,6 +24,7 @@ fn main() {
         [S { data: [0; 32] }; 5000],
         [Some(""); 20_000_000],
         [E::T(0); 5000],
+        [0u8; usize::MAX],
     );
 
     let good = (
diff --git a/tests/ui/large_stack_arrays.stderr b/tests/ui/large_stack_arrays.stderr
index c7bf941ad00..24e90094982 100644
--- a/tests/ui/large_stack_arrays.stderr
+++ b/tests/ui/large_stack_arrays.stderr
@@ -31,5 +31,13 @@ LL |         [E::T(0); 5000],
    |
    = help: consider allocating on the heap with `vec![E::T(0); 5000].into_boxed_slice()`
 
-error: aborting due to 4 previous errors
+error: allocating a local array larger than 512000 bytes
+  --> $DIR/large_stack_arrays.rs:27:9
+   |
+LL |         [0u8; usize::MAX],
+   |         ^^^^^^^^^^^^^^^^^
+   |
+   = help: consider allocating on the heap with `vec![0u8; usize::MAX].into_boxed_slice()`
+
+error: aborting due to 5 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 90ba82bd396cf95cb02318e43a66015cc3f65d7b Mon Sep 17 00:00:00 2001
From: Samuel Moelius <sam@moeli.us>
Date: Tue, 28 Feb 2023 09:50:07 -0500
Subject: Two small documentation improvements

---
 clippy_lints/src/functions/mod.rs | 2 +-
 clippy_lints/src/methods/mod.rs   | 5 +++--
 2 files changed, 4 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/functions/mod.rs b/clippy_lints/src/functions/mod.rs
index d2852b4acad..7c5e44bb7dc 100644
--- a/clippy_lints/src/functions/mod.rs
+++ b/clippy_lints/src/functions/mod.rs
@@ -185,7 +185,7 @@ declare_clippy_lint! {
     /// ### Examples
     /// ```rust
     /// // this could be annotated with `#[must_use]`.
-    /// fn id<T>(t: T) -> T { t }
+    /// pub fn id<T>(t: T) -> T { t }
     /// ```
     #[clippy::version = "1.40.0"]
     pub MUST_USE_CANDIDATE,
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 702df4b282b..56e3988bf09 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -340,8 +340,9 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for methods with certain name prefixes and which
-    /// doesn't match how self is taken. The actual rules are:
+    /// Checks for methods with certain name prefixes or suffixes, and which
+    /// do not adhere to standard conventions regarding how `self` is taken.
+    /// The actual rules are:
     ///
     /// |Prefix |Postfix     |`self` taken                   | `self` type  |
     /// |-------|------------|-------------------------------|--------------|
-- 
cgit 1.4.1-3-g733a5


From 7fb76a1ea72b777d8faf3bc82719435002e7083c Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Tue, 28 Feb 2023 21:55:51 +0100
Subject: Update version attribute for 1.68 lints

---
 clippy_lints/src/almost_complete_range.rs          | 2 +-
 clippy_lints/src/fn_null_check.rs                  | 2 +-
 clippy_lints/src/permissions_set_readonly_false.rs | 2 +-
 clippy_lints/src/size_of_ref.rs                    | 2 +-
 clippy_lints/src/transmute/mod.rs                  | 2 +-
 5 files changed, 5 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/almost_complete_range.rs b/clippy_lints/src/almost_complete_range.rs
index 42e14b5cd94..32d80f42e7e 100644
--- a/clippy_lints/src/almost_complete_range.rs
+++ b/clippy_lints/src/almost_complete_range.rs
@@ -24,7 +24,7 @@ declare_clippy_lint! {
     /// ```rust
     /// let _ = 'a'..='z';
     /// ```
-    #[clippy::version = "1.63.0"]
+    #[clippy::version = "1.68.0"]
     pub ALMOST_COMPLETE_RANGE,
     suspicious,
     "almost complete range"
diff --git a/clippy_lints/src/fn_null_check.rs b/clippy_lints/src/fn_null_check.rs
index 91c8c340ce2..d8f4a5fe221 100644
--- a/clippy_lints/src/fn_null_check.rs
+++ b/clippy_lints/src/fn_null_check.rs
@@ -25,7 +25,7 @@ declare_clippy_lint! {
     ///
     /// if fn_ptr.is_none() { ... }
     /// ```
-    #[clippy::version = "1.67.0"]
+    #[clippy::version = "1.68.0"]
     pub FN_NULL_CHECK,
     correctness,
     "`fn()` type assumed to be nullable"
diff --git a/clippy_lints/src/permissions_set_readonly_false.rs b/clippy_lints/src/permissions_set_readonly_false.rs
index e7095ec191f..664d44d6504 100644
--- a/clippy_lints/src/permissions_set_readonly_false.rs
+++ b/clippy_lints/src/permissions_set_readonly_false.rs
@@ -21,7 +21,7 @@ declare_clippy_lint! {
     /// let mut permissions = metadata.permissions();
     /// permissions.set_readonly(false);
     /// ```
-    #[clippy::version = "1.66.0"]
+    #[clippy::version = "1.68.0"]
     pub PERMISSIONS_SET_READONLY_FALSE,
     suspicious,
     "Checks for calls to `std::fs::Permissions.set_readonly` with argument `false`"
diff --git a/clippy_lints/src/size_of_ref.rs b/clippy_lints/src/size_of_ref.rs
index 3fcdb4288ce..8abec06c641 100644
--- a/clippy_lints/src/size_of_ref.rs
+++ b/clippy_lints/src/size_of_ref.rs
@@ -45,7 +45,7 @@ declare_clippy_lint! {
     ///     }
     /// }
     /// ```
-    #[clippy::version = "1.67.0"]
+    #[clippy::version = "1.68.0"]
     pub SIZE_OF_REF,
     suspicious,
     "Argument to `std::mem::size_of_val()` is a double-reference, which is almost certainly unintended"
diff --git a/clippy_lints/src/transmute/mod.rs b/clippy_lints/src/transmute/mod.rs
index c01cbe5090f..0dc30f7a935 100644
--- a/clippy_lints/src/transmute/mod.rs
+++ b/clippy_lints/src/transmute/mod.rs
@@ -458,7 +458,7 @@ declare_clippy_lint! {
     /// ```rust
     /// let null_fn: Option<fn()> = None;
     /// ```
-    #[clippy::version = "1.67.0"]
+    #[clippy::version = "1.68.0"]
     pub TRANSMUTE_NULL_TO_FN,
     correctness,
     "transmute results in a null function pointer, which is undefined behavior"
-- 
cgit 1.4.1-3-g733a5


From 5770d40d8ea3ba8d5a41db5e5914b45f32d80a9f Mon Sep 17 00:00:00 2001
From: Michael Schubart <michael@schubart.net>
Date: Tue, 28 Feb 2023 21:47:07 +0000
Subject: More compact `use` statements

---
 clippy_lints/src/collection_is_never_read.rs | 17 ++++-------------
 1 file changed, 4 insertions(+), 13 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/collection_is_never_read.rs b/clippy_lints/src/collection_is_never_read.rs
index f20c09a4448..c0c231bb2c7 100644
--- a/clippy_lints/src/collection_is_never_read.rs
+++ b/clippy_lints/src/collection_is_never_read.rs
@@ -1,20 +1,11 @@
 use clippy_utils::diagnostics::span_lint;
-use clippy_utils::get_enclosing_block;
-use clippy_utils::get_parent_node;
-use clippy_utils::path_to_local_id;
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::visitors::for_each_expr_with_closures;
+use clippy_utils::{get_enclosing_block, get_parent_node, path_to_local_id};
 use core::ops::ControlFlow;
-use rustc_hir::Block;
-use rustc_hir::ExprKind;
-use rustc_hir::HirId;
-use rustc_hir::Local;
-use rustc_hir::Node;
-use rustc_hir::PatKind;
-use rustc_lint::LateContext;
-use rustc_lint::LateLintPass;
-use rustc_session::declare_lint_pass;
-use rustc_session::declare_tool_lint;
+use rustc_hir::{Block, ExprKind, HirId, Local, Node, PatKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::symbol::sym;
 use rustc_span::Symbol;
 
-- 
cgit 1.4.1-3-g733a5


From 1a81a3e5cfc47908154b13bd921f9c03c5592010 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Thu, 2 Mar 2023 00:51:04 -0500
Subject: Remove `snippet_with_macro_callsite`

---
 clippy_lints/src/default.rs                        |  9 +++--
 clippy_lints/src/if_then_some_else_none.rs         | 17 ++++-----
 clippy_lints/src/loops/same_item_push.rs           | 32 ++++++++++-------
 clippy_lints/src/matches/manual_unwrap_or.rs       | 12 ++-----
 clippy_lints/src/matches/match_bool.rs             | 20 ++++++-----
 clippy_lints/src/matches/match_ref_pats.rs         | 28 +++++++++++----
 clippy_lints/src/matches/match_single_binding.rs   | 41 +++++++++++----------
 .../src/matches/redundant_pattern_match.rs         | 17 +++++----
 clippy_lints/src/matches/single_match.rs           | 18 ++++------
 clippy_lints/src/methods/bind_instead_of_map.rs    | 11 +++---
 clippy_lints/src/methods/clone_on_ref_ptr.rs       |  8 +++--
 clippy_lints/src/methods/or_fun_call.rs            | 28 ++++-----------
 clippy_lints/src/misc.rs                           | 17 ++++-----
 clippy_lints/src/needless_bool.rs                  | 13 ++-----
 clippy_lints/src/option_if_let_else.rs             | 28 +++++++++++----
 clippy_lints/src/semicolon_if_nothing_returned.rs  | 13 +++----
 clippy_lints/src/unit_types/let_unit_value.rs      |  7 ++--
 clippy_lints/src/useless_conversion.rs             | 14 ++++----
 clippy_utils/src/source.rs                         | 42 ++++++++++++----------
 clippy_utils/src/sugg.rs                           | 10 +-----
 tests/ui/redundant_pattern_matching_result.fixed   |  4 +--
 tests/ui/redundant_pattern_matching_result.stderr  |  4 +--
 22 files changed, 200 insertions(+), 193 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/default.rs b/clippy_lints/src/default.rs
index 080d44e6398..80c22742ba4 100644
--- a/clippy_lints/src/default.rs
+++ b/clippy_lints/src/default.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::{span_lint_and_note, span_lint_and_sugg};
-use clippy_utils::source::snippet_with_macro_callsite;
+use clippy_utils::source::snippet_with_context;
 use clippy_utils::ty::{has_drop, is_copy};
 use clippy_utils::{
     any_parent_is_automatically_derived, contains_name, get_parent_expr, is_from_proc_macro, match_def_path, paths,
@@ -160,6 +160,8 @@ impl<'tcx> LateLintPass<'tcx> for Default {
                 }
             };
 
+            let init_ctxt = local.span.ctxt();
+
             // find all "later statement"'s where the fields of the binding set as
             // Default::default() get reassigned, unless the reassignment refers to the original binding
             let mut first_assign = None;
@@ -169,7 +171,7 @@ impl<'tcx> LateLintPass<'tcx> for Default {
                 // find out if and which field was set by this `consecutive_statement`
                 if let Some((field_ident, assign_rhs)) = field_reassigned_by_stmt(consecutive_statement, binding_name) {
                     // interrupt and cancel lint if assign_rhs references the original binding
-                    if contains_name(binding_name, assign_rhs, cx) {
+                    if contains_name(binding_name, assign_rhs, cx) || init_ctxt != consecutive_statement.span.ctxt() {
                         cancel_lint = true;
                         break;
                     }
@@ -204,11 +206,12 @@ impl<'tcx> LateLintPass<'tcx> for Default {
                     .iter()
                     .all(|field| assigned_fields.iter().any(|(a, _)| a == &field.name));
 
+                let mut app = Applicability::Unspecified;
                 let field_list = assigned_fields
                     .into_iter()
                     .map(|(field, rhs)| {
                         // extract and store the assigned value for help message
-                        let value_snippet = snippet_with_macro_callsite(cx, rhs.span, "..");
+                        let value_snippet = snippet_with_context(cx, rhs.span, init_ctxt, "..", &mut app).0;
                         format!("{field}: {value_snippet}")
                     })
                     .collect::<Vec<String>>()
diff --git a/clippy_lints/src/if_then_some_else_none.rs b/clippy_lints/src/if_then_some_else_none.rs
index 9cadaaa493e..725bd3d54bc 100644
--- a/clippy_lints/src/if_then_some_else_none.rs
+++ b/clippy_lints/src/if_then_some_else_none.rs
@@ -1,8 +1,10 @@
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::eager_or_lazy::switch_to_eager_eval;
 use clippy_utils::msrvs::{self, Msrv};
-use clippy_utils::source::snippet_with_macro_callsite;
+use clippy_utils::source::snippet_with_context;
+use clippy_utils::sugg::Sugg;
 use clippy_utils::{contains_return, higher, is_else_clause, is_res_lang_ctor, path_res, peel_blocks};
+use rustc_errors::Applicability;
 use rustc_hir::LangItem::{OptionNone, OptionSome};
 use rustc_hir::{Expr, ExprKind, Stmt, StmtKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
@@ -72,21 +74,20 @@ impl<'tcx> LateLintPass<'tcx> for IfThenSomeElseNone {
             return;
         }
 
+        let ctxt = expr.span.ctxt();
+
         if let Some(higher::If { cond, then, r#else: Some(els) }) = higher::If::hir(expr)
             && let ExprKind::Block(then_block, _) = then.kind
             && let Some(then_expr) = then_block.expr
             && let ExprKind::Call(then_call, [then_arg]) = then_expr.kind
+            && then_expr.span.ctxt() == ctxt
             && is_res_lang_ctor(cx, path_res(cx, then_call), OptionSome)
             && is_res_lang_ctor(cx, path_res(cx, peel_blocks(els)), OptionNone)
             && !stmts_contains_early_return(then_block.stmts)
         {
-            let cond_snip = snippet_with_macro_callsite(cx, cond.span, "[condition]");
-            let cond_snip = if matches!(cond.kind, ExprKind::Unary(_, _) | ExprKind::Binary(_, _, _)) {
-                format!("({cond_snip})")
-            } else {
-                cond_snip.into_owned()
-            };
-            let arg_snip = snippet_with_macro_callsite(cx, then_arg.span, "");
+            let mut app = Applicability::Unspecified;
+            let cond_snip = Sugg::hir_with_context(cx, cond, expr.span.ctxt(), "[condition]", &mut app).maybe_par().to_string();
+            let arg_snip = snippet_with_context(cx, then_arg.span, ctxt, "[body]", &mut app).0;
             let mut method_body = if then_block.stmts.is_empty() {
                 arg_snip.into_owned()
             } else {
diff --git a/clippy_lints/src/loops/same_item_push.rs b/clippy_lints/src/loops/same_item_push.rs
index 540656a2cd9..9d9341559ac 100644
--- a/clippy_lints/src/loops/same_item_push.rs
+++ b/clippy_lints/src/loops/same_item_push.rs
@@ -1,15 +1,17 @@
 use super::SAME_ITEM_PUSH;
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::path_to_local;
-use clippy_utils::source::snippet_with_macro_callsite;
+use clippy_utils::source::snippet_with_context;
 use clippy_utils::ty::{implements_trait, is_type_diagnostic_item};
 use if_chain::if_chain;
 use rustc_data_structures::fx::FxHashSet;
+use rustc_errors::Applicability;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::intravisit::{walk_expr, Visitor};
 use rustc_hir::{BindingAnnotation, Block, Expr, ExprKind, HirId, Mutability, Node, Pat, PatKind, Stmt, StmtKind};
 use rustc_lint::LateContext;
 use rustc_span::symbol::sym;
+use rustc_span::SyntaxContext;
 use std::iter::Iterator;
 
 /// Detects for loop pushing the same item into a Vec
@@ -20,9 +22,10 @@ pub(super) fn check<'tcx>(
     body: &'tcx Expr<'_>,
     _: &'tcx Expr<'_>,
 ) {
-    fn emit_lint(cx: &LateContext<'_>, vec: &Expr<'_>, pushed_item: &Expr<'_>) {
-        let vec_str = snippet_with_macro_callsite(cx, vec.span, "");
-        let item_str = snippet_with_macro_callsite(cx, pushed_item.span, "");
+    fn emit_lint(cx: &LateContext<'_>, vec: &Expr<'_>, pushed_item: &Expr<'_>, ctxt: SyntaxContext) {
+        let mut app = Applicability::Unspecified;
+        let vec_str = snippet_with_context(cx, vec.span, ctxt, "", &mut app).0;
+        let item_str = snippet_with_context(cx, pushed_item.span, ctxt, "", &mut app).0;
 
         span_lint_and_help(
             cx,
@@ -43,7 +46,7 @@ pub(super) fn check<'tcx>(
     walk_expr(&mut same_item_push_visitor, body);
     if_chain! {
         if same_item_push_visitor.should_lint();
-        if let Some((vec, pushed_item)) = same_item_push_visitor.vec_push;
+        if let Some((vec, pushed_item, ctxt)) = same_item_push_visitor.vec_push;
         let vec_ty = cx.typeck_results().expr_ty(vec);
         let ty = vec_ty.walk().nth(1).unwrap().expect_ty();
         if cx
@@ -69,11 +72,11 @@ pub(super) fn check<'tcx>(
                                 then {
                                     match init.kind {
                                         // immutable bindings that are initialized with literal
-                                        ExprKind::Lit(..) => emit_lint(cx, vec, pushed_item),
+                                        ExprKind::Lit(..) => emit_lint(cx, vec, pushed_item, ctxt),
                                         // immutable bindings that are initialized with constant
                                         ExprKind::Path(ref path) => {
                                             if let Res::Def(DefKind::Const, ..) = cx.qpath_res(path, init.hir_id) {
-                                                emit_lint(cx, vec, pushed_item);
+                                                emit_lint(cx, vec, pushed_item, ctxt);
                                             }
                                         }
                                         _ => {},
@@ -82,11 +85,11 @@ pub(super) fn check<'tcx>(
                             }
                         },
                         // constant
-                        Res::Def(DefKind::Const, ..) => emit_lint(cx, vec, pushed_item),
+                        Res::Def(DefKind::Const, ..) => emit_lint(cx, vec, pushed_item, ctxt),
                         _ => {},
                     }
                 },
-                ExprKind::Lit(..) => emit_lint(cx, vec, pushed_item),
+                ExprKind::Lit(..) => emit_lint(cx, vec, pushed_item, ctxt),
                 _ => {},
             }
         }
@@ -98,7 +101,7 @@ struct SameItemPushVisitor<'a, 'tcx> {
     non_deterministic_expr: bool,
     multiple_pushes: bool,
     // this field holds the last vec push operation visited, which should be the only push seen
-    vec_push: Option<(&'tcx Expr<'tcx>, &'tcx Expr<'tcx>)>,
+    vec_push: Option<(&'tcx Expr<'tcx>, &'tcx Expr<'tcx>, SyntaxContext)>,
     cx: &'a LateContext<'tcx>,
     used_locals: FxHashSet<HirId>,
 }
@@ -118,7 +121,7 @@ impl<'a, 'tcx> SameItemPushVisitor<'a, 'tcx> {
         if_chain! {
             if !self.non_deterministic_expr;
             if !self.multiple_pushes;
-            if let Some((vec, _)) = self.vec_push;
+            if let Some((vec, _, _)) = self.vec_push;
             if let Some(hir_id) = path_to_local(vec);
             then {
                 !self.used_locals.contains(&hir_id)
@@ -173,7 +176,10 @@ impl<'a, 'tcx> Visitor<'tcx> for SameItemPushVisitor<'a, 'tcx> {
 
 // Given some statement, determine if that statement is a push on a Vec. If it is, return
 // the Vec being pushed into and the item being pushed
-fn get_vec_push<'tcx>(cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) -> Option<(&'tcx Expr<'tcx>, &'tcx Expr<'tcx>)> {
+fn get_vec_push<'tcx>(
+    cx: &LateContext<'tcx>,
+    stmt: &'tcx Stmt<'_>,
+) -> Option<(&'tcx Expr<'tcx>, &'tcx Expr<'tcx>, SyntaxContext)> {
     if_chain! {
             // Extract method being called
             if let StmtKind::Semi(semi_stmt) = &stmt.kind;
@@ -184,7 +190,7 @@ fn get_vec_push<'tcx>(cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) -> Option<(&
             if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(self_expr), sym::Vec);
             if path.ident.name.as_str() == "push";
             then {
-                return Some((self_expr, pushed_item))
+                return Some((self_expr, pushed_item, semi_stmt.span.ctxt()))
             }
     }
     None
diff --git a/clippy_lints/src/matches/manual_unwrap_or.rs b/clippy_lints/src/matches/manual_unwrap_or.rs
index 587c926dc01..84ff3c710c2 100644
--- a/clippy_lints/src/matches/manual_unwrap_or.rs
+++ b/clippy_lints/src/matches/manual_unwrap_or.rs
@@ -33,14 +33,8 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>, scrutinee:
             let reindented_or_body =
                 reindent_multiline(or_body_snippet.into(), true, Some(indent));
 
-            let suggestion = if scrutinee.span.from_expansion() {
-                    // we don't want parentheses around macro, e.g. `(some_macro!()).unwrap_or(0)`
-                    sugg::Sugg::hir_with_macro_callsite(cx, scrutinee, "..")
-                }
-                else {
-                    sugg::Sugg::hir(cx, scrutinee, "..").maybe_par()
-                };
-
+            let mut app = Applicability::MachineApplicable;
+            let suggestion = sugg::Sugg::hir_with_context(cx, scrutinee, expr.span.ctxt(), "..", &mut app).maybe_par();
             span_lint_and_sugg(
                 cx,
                 MANUAL_UNWRAP_OR, expr.span,
@@ -49,7 +43,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>, scrutinee:
                 format!(
                     "{suggestion}.unwrap_or({reindented_or_body})",
                 ),
-                Applicability::MachineApplicable,
+                app,
             );
         }
     }
diff --git a/clippy_lints/src/matches/match_bool.rs b/clippy_lints/src/matches/match_bool.rs
index 1c216e13570..df1e585f10b 100644
--- a/clippy_lints/src/matches/match_bool.rs
+++ b/clippy_lints/src/matches/match_bool.rs
@@ -10,9 +10,9 @@ use rustc_middle::ty;
 
 use super::MATCH_BOOL;
 
-pub(crate) fn check(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>], expr: &Expr<'_>) {
+pub(crate) fn check(cx: &LateContext<'_>, scrutinee: &Expr<'_>, arms: &[Arm<'_>], expr: &Expr<'_>) {
     // Type of expression is `bool`.
-    if *cx.typeck_results().expr_ty(ex).kind() == ty::Bool {
+    if *cx.typeck_results().expr_ty(scrutinee).kind() == ty::Bool {
         span_lint_and_then(
             cx,
             MATCH_BOOL,
@@ -36,24 +36,26 @@ pub(crate) fn check(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>], expr:
                     };
 
                     if let Some((true_expr, false_expr)) = exprs {
+                        let mut app = Applicability::HasPlaceholders;
+                        let ctxt = expr.span.ctxt();
                         let sugg = match (is_unit_expr(true_expr), is_unit_expr(false_expr)) {
                             (false, false) => Some(format!(
                                 "if {} {} else {}",
-                                snippet(cx, ex.span, "b"),
-                                expr_block(cx, true_expr, None, "..", Some(expr.span)),
-                                expr_block(cx, false_expr, None, "..", Some(expr.span))
+                                snippet(cx, scrutinee.span, "b"),
+                                expr_block(cx, true_expr, ctxt, "..", Some(expr.span), &mut app),
+                                expr_block(cx, false_expr, ctxt, "..", Some(expr.span), &mut app)
                             )),
                             (false, true) => Some(format!(
                                 "if {} {}",
-                                snippet(cx, ex.span, "b"),
-                                expr_block(cx, true_expr, None, "..", Some(expr.span))
+                                snippet(cx, scrutinee.span, "b"),
+                                expr_block(cx, true_expr, ctxt, "..", Some(expr.span), &mut app)
                             )),
                             (true, false) => {
-                                let test = Sugg::hir(cx, ex, "..");
+                                let test = Sugg::hir(cx, scrutinee, "..");
                                 Some(format!(
                                     "if {} {}",
                                     !test,
-                                    expr_block(cx, false_expr, None, "..", Some(expr.span))
+                                    expr_block(cx, false_expr, ctxt, "..", Some(expr.span), &mut app)
                                 ))
                             },
                             (true, true) => None,
diff --git a/clippy_lints/src/matches/match_ref_pats.rs b/clippy_lints/src/matches/match_ref_pats.rs
index 80f964ba1b7..aba4c85c59e 100644
--- a/clippy_lints/src/matches/match_ref_pats.rs
+++ b/clippy_lints/src/matches/match_ref_pats.rs
@@ -1,13 +1,14 @@
 use clippy_utils::diagnostics::{multispan_sugg, span_lint_and_then};
-use clippy_utils::source::snippet;
+use clippy_utils::source::{snippet, walk_span_to_context};
 use clippy_utils::sugg::Sugg;
 use core::iter::once;
+use rustc_errors::Applicability;
 use rustc_hir::{BorrowKind, Expr, ExprKind, Mutability, Pat, PatKind};
 use rustc_lint::LateContext;
 
 use super::MATCH_REF_PATS;
 
-pub(crate) fn check<'a, 'b, I>(cx: &LateContext<'_>, ex: &Expr<'_>, pats: I, expr: &Expr<'_>)
+pub(crate) fn check<'a, 'b, I>(cx: &LateContext<'_>, scrutinee: &Expr<'_>, pats: I, expr: &Expr<'_>)
 where
     'b: 'a,
     I: Clone + Iterator<Item = &'a Pat<'b>>,
@@ -17,13 +18,28 @@ where
     }
 
     let (first_sugg, msg, title);
-    let span = ex.span.source_callsite();
-    if let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Not, inner) = ex.kind {
-        first_sugg = once((span, Sugg::hir_with_macro_callsite(cx, inner, "..").to_string()));
+    let ctxt = expr.span.ctxt();
+    let mut app = Applicability::Unspecified;
+    if let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Not, inner) = scrutinee.kind {
+        if scrutinee.span.ctxt() != ctxt {
+            return;
+        }
+        first_sugg = once((
+            scrutinee.span,
+            Sugg::hir_with_context(cx, inner, ctxt, "..", &mut app).to_string(),
+        ));
         msg = "try";
         title = "you don't need to add `&` to both the expression and the patterns";
     } else {
-        first_sugg = once((span, Sugg::hir_with_macro_callsite(cx, ex, "..").deref().to_string()));
+        let Some(span) = walk_span_to_context(scrutinee.span, ctxt) else {
+            return;
+        };
+        first_sugg = once((
+            span,
+            Sugg::hir_with_context(cx, scrutinee, ctxt, "..", &mut app)
+                .deref()
+                .to_string(),
+        ));
         msg = "instead of prefixing all patterns with `&`, you can dereference the expression";
         title = "you don't need to add `&` to all patterns";
     }
diff --git a/clippy_lints/src/matches/match_single_binding.rs b/clippy_lints/src/matches/match_single_binding.rs
index 065a5c72621..eec5c1143d4 100644
--- a/clippy_lints/src/matches/match_single_binding.rs
+++ b/clippy_lints/src/matches/match_single_binding.rs
@@ -1,7 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::macros::HirNode;
-use clippy_utils::source::{indent_of, snippet, snippet_block, snippet_with_applicability};
-use clippy_utils::sugg::Sugg;
+use clippy_utils::source::{indent_of, snippet, snippet_block_with_context, snippet_with_applicability};
 use clippy_utils::{get_parent_expr, is_refutable, peel_blocks};
 use rustc_errors::Applicability;
 use rustc_hir::{Arm, Expr, ExprKind, Node, PatKind};
@@ -24,21 +23,25 @@ pub(crate) fn check<'a>(cx: &LateContext<'a>, ex: &Expr<'a>, arms: &[Arm<'_>], e
     let matched_vars = ex.span;
     let bind_names = arms[0].pat.span;
     let match_body = peel_blocks(arms[0].body);
-    let mut snippet_body = if match_body.span.from_expansion() {
-        Sugg::hir_with_macro_callsite(cx, match_body, "..").to_string()
-    } else {
-        snippet_block(cx, match_body.span, "..", Some(expr.span)).to_string()
-    };
+    let mut app = Applicability::MaybeIncorrect;
+    let (snippet_body, from_macro) = snippet_block_with_context(
+        cx,
+        match_body.span,
+        arms[0].span.ctxt(),
+        "..",
+        Some(expr.span),
+        &mut app,
+    );
+    let mut snippet_body = snippet_body.to_string();
 
     // Do we need to add ';' to suggestion ?
-    if let ExprKind::Block(block, _) = match_body.kind {
+    if matches!(match_body.kind, ExprKind::Block(..)) {
         // macro + expr_ty(body) == ()
-        if block.span.from_expansion() && cx.typeck_results().expr_ty(match_body).is_unit() {
+        if from_macro && cx.typeck_results().expr_ty(match_body).is_unit() {
             snippet_body.push(';');
         }
     }
 
-    let mut applicability = Applicability::MaybeIncorrect;
     match arms[0].pat.kind {
         PatKind::Binding(..) | PatKind::Tuple(_, _) | PatKind::Struct(..) => {
             let (target_span, sugg) = match opt_parent_assign_span(cx, ex) {
@@ -48,7 +51,7 @@ pub(crate) fn check<'a>(cx: &LateContext<'a>, ex: &Expr<'a>, arms: &[Arm<'_>], e
                         (ex, expr),
                         (bind_names, matched_vars),
                         &snippet_body,
-                        &mut applicability,
+                        &mut app,
                         Some(span),
                         true,
                     );
@@ -60,7 +63,7 @@ pub(crate) fn check<'a>(cx: &LateContext<'a>, ex: &Expr<'a>, arms: &[Arm<'_>], e
                         "this assignment could be simplified",
                         "consider removing the `match` expression",
                         sugg,
-                        applicability,
+                        app,
                     );
 
                     return;
@@ -69,10 +72,10 @@ pub(crate) fn check<'a>(cx: &LateContext<'a>, ex: &Expr<'a>, arms: &[Arm<'_>], e
                     span,
                     format!(
                         "let {} = {};\n{}let {} = {snippet_body};",
-                        snippet_with_applicability(cx, bind_names, "..", &mut applicability),
-                        snippet_with_applicability(cx, matched_vars, "..", &mut applicability),
+                        snippet_with_applicability(cx, bind_names, "..", &mut app),
+                        snippet_with_applicability(cx, matched_vars, "..", &mut app),
                         " ".repeat(indent_of(cx, expr.span).unwrap_or(0)),
-                        snippet_with_applicability(cx, pat_span, "..", &mut applicability)
+                        snippet_with_applicability(cx, pat_span, "..", &mut app)
                     ),
                 ),
                 None => {
@@ -81,7 +84,7 @@ pub(crate) fn check<'a>(cx: &LateContext<'a>, ex: &Expr<'a>, arms: &[Arm<'_>], e
                         (ex, expr),
                         (bind_names, matched_vars),
                         &snippet_body,
-                        &mut applicability,
+                        &mut app,
                         None,
                         true,
                     );
@@ -96,7 +99,7 @@ pub(crate) fn check<'a>(cx: &LateContext<'a>, ex: &Expr<'a>, arms: &[Arm<'_>], e
                 "this match could be written as a `let` statement",
                 "consider using a `let` statement",
                 sugg,
-                applicability,
+                app,
             );
         },
         PatKind::Wild => {
@@ -106,7 +109,7 @@ pub(crate) fn check<'a>(cx: &LateContext<'a>, ex: &Expr<'a>, arms: &[Arm<'_>], e
                     (ex, expr),
                     (bind_names, matched_vars),
                     &snippet_body,
-                    &mut applicability,
+                    &mut app,
                     None,
                     false,
                 );
@@ -118,7 +121,7 @@ pub(crate) fn check<'a>(cx: &LateContext<'a>, ex: &Expr<'a>, arms: &[Arm<'_>], e
                     "this match could be replaced by its scrutinee and body",
                     "consider using the scrutinee and body instead",
                     sugg,
-                    applicability,
+                    app,
                 );
             } else {
                 span_lint_and_sugg(
diff --git a/clippy_lints/src/matches/redundant_pattern_match.rs b/clippy_lints/src/matches/redundant_pattern_match.rs
index 81bebff34c8..e8610670054 100644
--- a/clippy_lints/src/matches/redundant_pattern_match.rs
+++ b/clippy_lints/src/matches/redundant_pattern_match.rs
@@ -1,6 +1,6 @@
 use super::REDUNDANT_PATTERN_MATCHING;
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::source::snippet;
+use clippy_utils::source::{snippet, walk_span_to_context};
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::{is_type_diagnostic_item, needs_ordered_drop};
 use clippy_utils::visitors::any_temporaries_need_ordered_drop;
@@ -150,22 +150,25 @@ fn find_sugg_for_if_let<'tcx>(
             // if/while let ... = ... { ... }
             // ^^^^^^^^^^^^^^^^^^^^^^^^^^^
             let expr_span = expr.span;
+            let ctxt = expr.span.ctxt();
 
             // if/while let ... = ... { ... }
-            //                 ^^^
-            let op_span = result_expr.span.source_callsite();
+            //                    ^^^
+            let Some(res_span) = walk_span_to_context(result_expr.span.source_callsite(), ctxt) else {
+                return;
+            };
 
             // if/while let ... = ... { ... }
-            // ^^^^^^^^^^^^^^^^^^^
-            let span = expr_span.until(op_span.shrink_to_hi());
+            // ^^^^^^^^^^^^^^^^^^^^^^
+            let span = expr_span.until(res_span.shrink_to_hi());
 
-            let app = if needs_drop {
+            let mut app = if needs_drop {
                 Applicability::MaybeIncorrect
             } else {
                 Applicability::MachineApplicable
             };
 
-            let sugg = Sugg::hir_with_macro_callsite(cx, result_expr, "_")
+            let sugg = Sugg::hir_with_context(cx, result_expr, ctxt, "_", &mut app)
                 .maybe_par()
                 .to_string();
 
diff --git a/clippy_lints/src/matches/single_match.rs b/clippy_lints/src/matches/single_match.rs
index 19b49c44d57..ad47c13896c 100644
--- a/clippy_lints/src/matches/single_match.rs
+++ b/clippy_lints/src/matches/single_match.rs
@@ -67,8 +67,10 @@ fn report_single_pattern(
     els: Option<&Expr<'_>>,
 ) {
     let lint = if els.is_some() { SINGLE_MATCH_ELSE } else { SINGLE_MATCH };
+    let ctxt = expr.span.ctxt();
+    let mut app = Applicability::HasPlaceholders;
     let els_str = els.map_or(String::new(), |els| {
-        format!(" else {}", expr_block(cx, els, None, "..", Some(expr.span)))
+        format!(" else {}", expr_block(cx, els, ctxt, "..", Some(expr.span), &mut app))
     });
 
     let (pat, pat_ref_count) = peel_hir_pat_refs(arms[0].pat);
@@ -103,7 +105,7 @@ fn report_single_pattern(
                 // PartialEq for different reference counts may not exist.
                 "&".repeat(ref_count_diff),
                 snippet(cx, arms[0].pat.span, ".."),
-                expr_block(cx, arms[0].body, None, "..", Some(expr.span)),
+                expr_block(cx, arms[0].body, ctxt, "..", Some(expr.span), &mut app),
             );
             (msg, sugg)
         } else {
@@ -112,21 +114,13 @@ fn report_single_pattern(
                 "if let {} = {} {}{els_str}",
                 snippet(cx, arms[0].pat.span, ".."),
                 snippet(cx, ex.span, ".."),
-                expr_block(cx, arms[0].body, None, "..", Some(expr.span)),
+                expr_block(cx, arms[0].body, ctxt, "..", Some(expr.span), &mut app),
             );
             (msg, sugg)
         }
     };
 
-    span_lint_and_sugg(
-        cx,
-        lint,
-        expr.span,
-        msg,
-        "try this",
-        sugg,
-        Applicability::HasPlaceholders,
-    );
+    span_lint_and_sugg(cx, lint, expr.span, msg, "try this", sugg, app);
 }
 
 fn check_opt_like<'a>(
diff --git a/clippy_lints/src/methods/bind_instead_of_map.rs b/clippy_lints/src/methods/bind_instead_of_map.rs
index 4720a6e6888..8ddb912f90b 100644
--- a/clippy_lints/src/methods/bind_instead_of_map.rs
+++ b/clippy_lints/src/methods/bind_instead_of_map.rs
@@ -1,6 +1,6 @@
 use super::{contains_return, BIND_INSTEAD_OF_MAP};
 use clippy_utils::diagnostics::{multispan_sugg_with_applicability, span_lint_and_sugg, span_lint_and_then};
-use clippy_utils::source::{snippet, snippet_with_macro_callsite};
+use clippy_utils::source::{snippet, snippet_with_context};
 use clippy_utils::{peel_blocks, visitors::find_all_ret_expressions};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
@@ -77,11 +77,8 @@ pub(crate) trait BindInsteadOfMap {
             if !contains_return(inner_expr);
             if let Some(msg) = Self::lint_msg(cx);
             then {
-                let some_inner_snip = if inner_expr.span.from_expansion() {
-                    snippet_with_macro_callsite(cx, inner_expr.span, "_")
-                } else {
-                    snippet(cx, inner_expr.span, "_")
-                };
+                let mut app = Applicability::MachineApplicable;
+                let some_inner_snip = snippet_with_context(cx, inner_expr.span, closure_expr.span.ctxt(), "_", &mut app).0;
 
                 let closure_args_snip = snippet(cx, closure_args_span, "..");
                 let option_snip = snippet(cx, recv.span, "..");
@@ -93,7 +90,7 @@ pub(crate) trait BindInsteadOfMap {
                     &msg,
                     "try this",
                     note,
-                    Applicability::MachineApplicable,
+                    app,
                 );
                 true
             } else {
diff --git a/clippy_lints/src/methods/clone_on_ref_ptr.rs b/clippy_lints/src/methods/clone_on_ref_ptr.rs
index 355f53532e2..5e8ad0861f3 100644
--- a/clippy_lints/src/methods/clone_on_ref_ptr.rs
+++ b/clippy_lints/src/methods/clone_on_ref_ptr.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::paths;
-use clippy_utils::source::snippet_with_macro_callsite;
+use clippy_utils::source::snippet_with_context;
 use clippy_utils::ty::{is_type_diagnostic_item, match_type};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
@@ -33,7 +33,9 @@ pub(super) fn check(
             return;
         };
 
-        let snippet = snippet_with_macro_callsite(cx, receiver.span, "..");
+        // Sometimes unnecessary ::<_> after Rc/Arc/Weak
+        let mut app = Applicability::Unspecified;
+        let snippet = snippet_with_context(cx, receiver.span, expr.span.ctxt(), "..", &mut app).0;
 
         span_lint_and_sugg(
             cx,
@@ -42,7 +44,7 @@ pub(super) fn check(
             "using `.clone()` on a ref-counted pointer",
             "try this",
             format!("{caller_type}::<{}>::clone(&{snippet})", subst.type_at(0)),
-            Applicability::Unspecified, // Sometimes unnecessary ::<_> after Rc/Arc/Weak
+            app,
         );
     }
 }
diff --git a/clippy_lints/src/methods/or_fun_call.rs b/clippy_lints/src/methods/or_fun_call.rs
index 4460f38fcc1..7ce28ea93e0 100644
--- a/clippy_lints/src/methods/or_fun_call.rs
+++ b/clippy_lints/src/methods/or_fun_call.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::eager_or_lazy::switch_to_lazy_eval;
-use clippy_utils::source::{snippet, snippet_with_macro_callsite};
+use clippy_utils::source::snippet_with_context;
 use clippy_utils::ty::{implements_trait, is_type_diagnostic_item};
 use clippy_utils::{contains_return, is_trait_item, last_path_segment};
 use if_chain::if_chain;
@@ -9,7 +9,6 @@ use rustc_hir as hir;
 use rustc_lint::LateContext;
 use rustc_span::source_map::Span;
 use rustc_span::symbol::{kw, sym, Symbol};
-use std::borrow::Cow;
 
 use super::OR_FUN_CALL;
 
@@ -111,37 +110,24 @@ pub(super) fn check<'tcx>(
             if poss.contains(&name);
 
             then {
+                let ctxt = span.ctxt();
+                let mut app = Applicability::HasPlaceholders;
                 let sugg = {
                     let (snippet_span, use_lambda) = match (fn_has_arguments, fun_span) {
                         (false, Some(fun_span)) => (fun_span, false),
                         _ => (arg.span, true),
                     };
 
-                    let format_span = |span: Span| {
-                        let not_macro_argument_snippet = snippet_with_macro_callsite(cx, span, "..");
-                        let snip = if not_macro_argument_snippet == "vec![]" {
-                            let macro_expanded_snipped = snippet(cx, snippet_span, "..");
-                            match macro_expanded_snipped.strip_prefix("$crate::vec::") {
-                                Some(stripped) => Cow::Owned(stripped.to_owned()),
-                                None => macro_expanded_snipped,
-                            }
-                        } else {
-                            not_macro_argument_snippet
-                        };
-
-                        snip.to_string()
-                    };
-
-                    let snip = format_span(snippet_span);
+                    let snip = snippet_with_context(cx, snippet_span, ctxt, "..", &mut app).0;
                     let snip = if use_lambda {
                         let l_arg = if fn_has_arguments { "_" } else { "" };
                         format!("|{l_arg}| {snip}")
                     } else {
-                        snip
+                        snip.into_owned()
                     };
 
                     if let Some(f) = second_arg {
-                        let f = format_span(f.span);
+                        let f = snippet_with_context(cx, f.span, ctxt, "..", &mut app).0;
                         format!("{snip}, {f}")
                     } else {
                         snip
@@ -155,7 +141,7 @@ pub(super) fn check<'tcx>(
                     &format!("use of `{name}` followed by a function call"),
                     "try this",
                     format!("{name}_{suffix}({sugg})"),
-                    Applicability::HasPlaceholders,
+                    app,
                 );
             }
         }
diff --git a/clippy_lints/src/misc.rs b/clippy_lints/src/misc.rs
index 0705029a613..3752b9a946f 100644
--- a/clippy_lints/src/misc.rs
+++ b/clippy_lints/src/misc.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg, span_lint_hir_and_then};
-use clippy_utils::source::{snippet, snippet_opt};
+use clippy_utils::source::{snippet, snippet_opt, snippet_with_context};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::FnKind;
@@ -181,20 +181,17 @@ impl<'tcx> LateLintPass<'tcx> for LintPass {
             if let PatKind::Binding(BindingAnnotation(ByRef::Yes, mutabl), .., name, None) = local.pat.kind;
             if let Some(init) = local.init;
             then {
-                // use the macro callsite when the init span (but not the whole local span)
-                // comes from an expansion like `vec![1, 2, 3]` in `let ref _ = vec![1, 2, 3];`
-                let sugg_init = if init.span.from_expansion() && !local.span.from_expansion() {
-                    Sugg::hir_with_macro_callsite(cx, init, "..")
-                } else {
-                    Sugg::hir(cx, init, "..")
-                };
+                let ctxt = local.span.ctxt();
+                let mut app = Applicability::MachineApplicable;
+                let sugg_init = Sugg::hir_with_context(cx, init, ctxt, "..", &mut app);
                 let (mutopt, initref) = if mutabl == Mutability::Mut {
                     ("mut ", sugg_init.mut_addr())
                 } else {
                     ("", sugg_init.addr())
                 };
                 let tyopt = if let Some(ty) = local.ty {
-                    format!(": &{mutopt}{ty}", ty=snippet(cx, ty.span, ".."))
+                    let ty_snip = snippet_with_context(cx, ty.span, ctxt, "_", &mut app).0;
+                    format!(": &{mutopt}{ty_snip}")
                 } else {
                     String::new()
                 };
@@ -212,7 +209,7 @@ impl<'tcx> LateLintPass<'tcx> for LintPass {
                                 "let {name}{tyopt} = {initref};",
                                 name=snippet(cx, name.span, ".."),
                             ),
-                            Applicability::MachineApplicable,
+                            app,
                         );
                     }
                 );
diff --git a/clippy_lints/src/needless_bool.rs b/clippy_lints/src/needless_bool.rs
index a4eec95b371..c87059bf61d 100644
--- a/clippy_lints/src/needless_bool.rs
+++ b/clippy_lints/src/needless_bool.rs
@@ -340,18 +340,11 @@ fn suggest_bool_comparison<'a, 'tcx>(
     cx: &LateContext<'tcx>,
     e: &'tcx Expr<'_>,
     expr: &Expr<'_>,
-    mut applicability: Applicability,
+    mut app: Applicability,
     message: &str,
     conv_hint: impl FnOnce(Sugg<'a>) -> Sugg<'a>,
 ) {
-    let hint = if expr.span.from_expansion() {
-        if applicability != Applicability::Unspecified {
-            applicability = Applicability::MaybeIncorrect;
-        }
-        Sugg::hir_with_macro_callsite(cx, expr, "..")
-    } else {
-        Sugg::hir_with_applicability(cx, expr, "..", &mut applicability)
-    };
+    let hint = Sugg::hir_with_context(cx, expr, e.span.ctxt(), "..", &mut app);
     span_lint_and_sugg(
         cx,
         BOOL_COMPARISON,
@@ -359,7 +352,7 @@ fn suggest_bool_comparison<'a, 'tcx>(
         message,
         "try simplifying it as shown",
         conv_hint(hint).to_string(),
-        applicability,
+        app,
     );
 }
 
diff --git a/clippy_lints/src/option_if_let_else.rs b/clippy_lints/src/option_if_let_else.rs
index c5ea09590d3..bbbcda069c5 100644
--- a/clippy_lints/src/option_if_let_else.rs
+++ b/clippy_lints/src/option_if_let_else.rs
@@ -12,6 +12,7 @@ use rustc_hir::{
 };
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::SyntaxContext;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -95,10 +96,10 @@ struct OptionOccurrence {
     none_expr: String,
 }
 
-fn format_option_in_sugg(cx: &LateContext<'_>, cond_expr: &Expr<'_>, as_ref: bool, as_mut: bool) -> String {
+fn format_option_in_sugg(cond_sugg: Sugg<'_>, as_ref: bool, as_mut: bool) -> String {
     format!(
         "{}{}",
-        Sugg::hir_with_macro_callsite(cx, cond_expr, "..").maybe_par(),
+        cond_sugg.maybe_par(),
         if as_mut {
             ".as_mut()"
         } else if as_ref {
@@ -111,6 +112,7 @@ fn format_option_in_sugg(cx: &LateContext<'_>, cond_expr: &Expr<'_>, as_ref: boo
 
 fn try_get_option_occurrence<'tcx>(
     cx: &LateContext<'tcx>,
+    ctxt: SyntaxContext,
     pat: &Pat<'tcx>,
     expr: &Expr<'_>,
     if_then: &'tcx Expr<'_>,
@@ -160,11 +162,23 @@ fn try_get_option_occurrence<'tcx>(
                 }
             }
 
+            let mut app = Applicability::Unspecified;
             return Some(OptionOccurrence {
-                option: format_option_in_sugg(cx, cond_expr, as_ref, as_mut),
+                option: format_option_in_sugg(
+                    Sugg::hir_with_context(cx, cond_expr, ctxt, "..", &mut app),
+                    as_ref,
+                    as_mut,
+                ),
                 method_sugg: method_sugg.to_string(),
-                some_expr: format!("|{capture_mut}{capture_name}| {}", Sugg::hir_with_macro_callsite(cx, some_body, "..")),
-                none_expr: format!("{}{}", if method_sugg == "map_or" { "" } else { "|| " }, Sugg::hir_with_macro_callsite(cx, none_body, "..")),
+                some_expr: format!(
+                    "|{capture_mut}{capture_name}| {}",
+                    Sugg::hir_with_context(cx, some_body, ctxt, "..", &mut app),
+                ),
+                none_expr: format!(
+                    "{}{}",
+                    if method_sugg == "map_or" { "" } else { "|| " },
+                    Sugg::hir_with_context(cx, none_body, ctxt, "..", &mut app),
+                ),
             });
         }
     }
@@ -194,7 +208,7 @@ fn detect_option_if_let_else<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>) ->
     }) = higher::IfLet::hir(cx, expr)
     {
         if !is_else_clause(cx.tcx, expr) {
-            return try_get_option_occurrence(cx, let_pat, let_expr, if_then, if_else);
+            return try_get_option_occurrence(cx, expr.span.ctxt(), let_pat, let_expr, if_then, if_else);
         }
     }
     None
@@ -203,7 +217,7 @@ fn detect_option_if_let_else<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>) ->
 fn detect_option_match<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>) -> Option<OptionOccurrence> {
     if let ExprKind::Match(ex, arms, MatchSource::Normal) = expr.kind {
         if let Some((let_pat, if_then, if_else)) = try_convert_match(cx, arms) {
-            return try_get_option_occurrence(cx, let_pat, ex, if_then, if_else);
+            return try_get_option_occurrence(cx, expr.span.ctxt(), let_pat, ex, if_then, if_else);
         }
     }
     None
diff --git a/clippy_lints/src/semicolon_if_nothing_returned.rs b/clippy_lints/src/semicolon_if_nothing_returned.rs
index 66638eed998..355f907e257 100644
--- a/clippy_lints/src/semicolon_if_nothing_returned.rs
+++ b/clippy_lints/src/semicolon_if_nothing_returned.rs
@@ -1,7 +1,6 @@
 use crate::rustc_lint::LintContext;
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::source::snippet_with_macro_callsite;
-use clippy_utils::sugg;
+use clippy_utils::source::snippet_with_context;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Block, ExprKind};
@@ -44,7 +43,8 @@ impl<'tcx> LateLintPass<'tcx> for SemicolonIfNothingReturned {
             if let Some(expr) = block.expr;
             let t_expr = cx.typeck_results().expr_ty(expr);
             if t_expr.is_unit();
-            if let snippet = snippet_with_macro_callsite(cx, expr.span, "}");
+            let mut app = Applicability::MaybeIncorrect;
+            if let snippet = snippet_with_context(cx, expr.span, block.span.ctxt(), "}", &mut app).0;
             if !snippet.ends_with('}') && !snippet.ends_with(';');
             if cx.sess().source_map().is_multiline(block.span);
             then {
@@ -52,17 +52,14 @@ impl<'tcx> LateLintPass<'tcx> for SemicolonIfNothingReturned {
                 if let ExprKind::DropTemps(..) = &expr.kind {
                     return;
                 }
-
-                let sugg = sugg::Sugg::hir_with_macro_callsite(cx, expr, "..");
-                let suggestion = format!("{sugg};");
                 span_lint_and_sugg(
                     cx,
                     SEMICOLON_IF_NOTHING_RETURNED,
                     expr.span.source_callsite(),
                     "consider adding a `;` to the last statement for consistent formatting",
                     "add a `;` here",
-                    suggestion,
-                    Applicability::MaybeIncorrect,
+                    format!("{snippet};"),
+                    app,
                 );
             }
         }
diff --git a/clippy_lints/src/unit_types/let_unit_value.rs b/clippy_lints/src/unit_types/let_unit_value.rs
index d6167a62169..a0164fdfc1e 100644
--- a/clippy_lints/src/unit_types/let_unit_value.rs
+++ b/clippy_lints/src/unit_types/let_unit_value.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::get_parent_node;
-use clippy_utils::source::snippet_with_macro_callsite;
+use clippy_utils::source::snippet_with_context;
 use clippy_utils::visitors::{for_each_local_assignment, for_each_value_source};
 use core::ops::ControlFlow;
 use rustc_errors::Applicability;
@@ -48,12 +48,13 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, local: &'tcx Local<'_>) {
                 "this let-binding has unit value",
                 |diag| {
                     if let Some(expr) = &local.init {
-                        let snip = snippet_with_macro_callsite(cx, expr.span, "()");
+                        let mut app = Applicability::MachineApplicable;
+                        let snip = snippet_with_context(cx, expr.span, local.span.ctxt(), "()", &mut app).0;
                         diag.span_suggestion(
                             local.span,
                             "omit the `let` binding",
                             format!("{snip};"),
-                            Applicability::MachineApplicable, // snippet
+                            app,
                         );
                     }
                 },
diff --git a/clippy_lints/src/useless_conversion.rs b/clippy_lints/src/useless_conversion.rs
index a95e7b61374..47f19557e58 100644
--- a/clippy_lints/src/useless_conversion.rs
+++ b/clippy_lints/src/useless_conversion.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg};
-use clippy_utils::source::{snippet, snippet_with_macro_callsite};
+use clippy_utils::source::{snippet, snippet_with_context};
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::{is_copy, is_type_diagnostic_item, same_type_and_consts};
 use clippy_utils::{get_parent_expr, is_trait_method, match_def_path, path_to_local, paths};
@@ -68,15 +68,16 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
                     let a = cx.typeck_results().expr_ty(e);
                     let b = cx.typeck_results().expr_ty(recv);
                     if same_type_and_consts(a, b) {
-                        let sugg = snippet_with_macro_callsite(cx, recv.span, "<expr>").to_string();
+                        let mut app = Applicability::MachineApplicable;
+                        let sugg = snippet_with_context(cx, recv.span, e.span.ctxt(), "<expr>", &mut app).0;
                         span_lint_and_sugg(
                             cx,
                             USELESS_CONVERSION,
                             e.span,
                             &format!("useless conversion to the same type: `{b}`"),
                             "consider removing `.into()`",
-                            sugg,
-                            Applicability::MachineApplicable, // snippet
+                            sugg.into_owned(),
+                            app,
                         );
                     }
                 }
@@ -165,7 +166,8 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
                             if same_type_and_consts(a, b);
 
                             then {
-                                let sugg = Sugg::hir_with_macro_callsite(cx, arg, "<expr>").maybe_par();
+                                let mut app = Applicability::MachineApplicable;
+                                let sugg = Sugg::hir_with_context(cx, arg, e.span.ctxt(), "<expr>", &mut app).maybe_par();
                                 let sugg_msg =
                                     format!("consider removing `{}()`", snippet(cx, path.span, "From::from"));
                                 span_lint_and_sugg(
@@ -175,7 +177,7 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
                                     &format!("useless conversion to the same type: `{b}`"),
                                     &sugg_msg,
                                     sugg.to_string(),
-                                    Applicability::MachineApplicable, // snippet
+                                    app,
                                 );
                             }
                         }
diff --git a/clippy_utils/src/source.rs b/clippy_utils/src/source.rs
index cd5dcfdaca3..62fa37660fa 100644
--- a/clippy_utils/src/source.rs
+++ b/clippy_utils/src/source.rs
@@ -12,24 +12,21 @@ use rustc_span::{BytePos, Pos, Span, SpanData, SyntaxContext, DUMMY_SP};
 use std::borrow::Cow;
 
 /// Like `snippet_block`, but add braces if the expr is not an `ExprKind::Block`.
-/// Also takes an `Option<String>` which can be put inside the braces.
-pub fn expr_block<'a, T: LintContext>(
+pub fn expr_block<T: LintContext>(
     cx: &T,
     expr: &Expr<'_>,
-    option: Option<String>,
-    default: &'a str,
+    outer: SyntaxContext,
+    default: &str,
     indent_relative_to: Option<Span>,
-) -> Cow<'a, str> {
-    let code = snippet_block(cx, expr.span, default, indent_relative_to);
-    let string = option.unwrap_or_default();
-    if expr.span.from_expansion() {
-        Cow::Owned(format!("{{ {} }}", snippet_with_macro_callsite(cx, expr.span, default)))
+    app: &mut Applicability,
+) -> String {
+    let (code, from_macro) = snippet_block_with_context(cx, expr.span, outer, default, indent_relative_to, app);
+    if from_macro {
+        format!("{{ {code} }}")
     } else if let ExprKind::Block(_, _) = expr.kind {
-        Cow::Owned(format!("{code}{string}"))
-    } else if string.is_empty() {
-        Cow::Owned(format!("{{ {code} }}"))
+        format!("{code}")
     } else {
-        Cow::Owned(format!("{{\n{code};\n{string}\n}}"))
+        format!("{{ {code} }}")
     }
 }
 
@@ -229,12 +226,6 @@ fn snippet_with_applicability_sess<'a>(
     )
 }
 
-/// Same as `snippet`, but should only be used when it's clear that the input span is
-/// not a macro argument.
-pub fn snippet_with_macro_callsite<'a, T: LintContext>(cx: &T, span: Span, default: &'a str) -> Cow<'a, str> {
-    snippet(cx, span.source_callsite(), default)
-}
-
 /// Converts a span to a code snippet. Returns `None` if not available.
 pub fn snippet_opt(cx: &impl LintContext, span: Span) -> Option<String> {
     snippet_opt_sess(cx.sess(), span)
@@ -303,6 +294,19 @@ pub fn snippet_block_with_applicability<'a>(
     reindent_multiline(snip, true, indent)
 }
 
+pub fn snippet_block_with_context<'a>(
+    cx: &impl LintContext,
+    span: Span,
+    outer: SyntaxContext,
+    default: &'a str,
+    indent_relative_to: Option<Span>,
+    app: &mut Applicability,
+) -> (Cow<'a, str>, bool) {
+    let (snip, from_macro) = snippet_with_context(cx, span, outer, default, app);
+    let indent = indent_relative_to.and_then(|s| indent_of(cx, s));
+    (reindent_multiline(snip, true, indent), from_macro)
+}
+
 /// Same as `snippet_with_applicability`, but first walks the span up to the given context. This
 /// will result in the macro call, rather then the expansion, if the span is from a child context.
 /// If the span is not from a child context, it will be used directly instead.
diff --git a/clippy_utils/src/sugg.rs b/clippy_utils/src/sugg.rs
index 51e270d330c..8e3ee22a765 100644
--- a/clippy_utils/src/sugg.rs
+++ b/clippy_utils/src/sugg.rs
@@ -1,9 +1,7 @@
 //! Contains utility functions to generate suggestions.
 #![deny(clippy::missing_docs_in_private_items)]
 
-use crate::source::{
-    snippet, snippet_opt, snippet_with_applicability, snippet_with_context, snippet_with_macro_callsite,
-};
+use crate::source::{snippet, snippet_opt, snippet_with_applicability, snippet_with_context};
 use crate::ty::expr_sig;
 use crate::{get_parent_expr_for_hir, higher};
 use rustc_ast::util::parser::AssocOp;
@@ -89,12 +87,6 @@ impl<'a> Sugg<'a> {
         })
     }
 
-    /// Same as `hir`, but will use the pre expansion span if the `expr` was in a macro.
-    pub fn hir_with_macro_callsite(cx: &LateContext<'_>, expr: &hir::Expr<'_>, default: &'a str) -> Self {
-        let get_snippet = |span| snippet_with_macro_callsite(cx, span, default);
-        Self::hir_from_snippet(expr, get_snippet)
-    }
-
     /// Same as `hir`, but first walks the span up to the given context. This will result in the
     /// macro call, rather then the expansion, if the span is from a child context. If the span is
     /// not from a child context, it will be used directly instead.
diff --git a/tests/ui/redundant_pattern_matching_result.fixed b/tests/ui/redundant_pattern_matching_result.fixed
index b88c5d0bec8..42348df4480 100644
--- a/tests/ui/redundant_pattern_matching_result.fixed
+++ b/tests/ui/redundant_pattern_matching_result.fixed
@@ -69,8 +69,8 @@ fn issue5504() {
     }
 
     fn try_result_opt() -> Result<i32, i32> {
-        while (r#try!(result_opt())).is_some() {}
-        if (r#try!(result_opt())).is_some() {}
+        while r#try!(result_opt()).is_some() {}
+        if r#try!(result_opt()).is_some() {}
         Ok(42)
     }
 
diff --git a/tests/ui/redundant_pattern_matching_result.stderr b/tests/ui/redundant_pattern_matching_result.stderr
index e6afe9eb78e..d6a46babb77 100644
--- a/tests/ui/redundant_pattern_matching_result.stderr
+++ b/tests/ui/redundant_pattern_matching_result.stderr
@@ -88,13 +88,13 @@ error: redundant pattern matching, consider using `is_some()`
   --> $DIR/redundant_pattern_matching_result.rs:84:19
    |
 LL |         while let Some(_) = r#try!(result_opt()) {}
-   |         ----------^^^^^^^----------------------- help: try this: `while (r#try!(result_opt())).is_some()`
+   |         ----------^^^^^^^----------------------- help: try this: `while r#try!(result_opt()).is_some()`
 
 error: redundant pattern matching, consider using `is_some()`
   --> $DIR/redundant_pattern_matching_result.rs:85:16
    |
 LL |         if let Some(_) = r#try!(result_opt()) {}
-   |         -------^^^^^^^----------------------- help: try this: `if (r#try!(result_opt())).is_some()`
+   |         -------^^^^^^^----------------------- help: try this: `if r#try!(result_opt()).is_some()`
 
 error: redundant pattern matching, consider using `is_some()`
   --> $DIR/redundant_pattern_matching_result.rs:91:12
-- 
cgit 1.4.1-3-g733a5


From efbcb99b73d3180f6d667fdad2efdbe6317c30d4 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Thu, 2 Mar 2023 14:29:45 -0500
Subject: Use `snippet_with_context` more

---
 .../src/casts/cast_slice_from_raw_parts.rs         |   8 +-
 clippy_lints/src/default_instead_of_iter_empty.rs  |  16 ++-
 clippy_lints/src/format.rs                         |   6 +-
 clippy_lints/src/implicit_saturating_add.rs        |  16 ++-
 clippy_lints/src/instant_subtraction.rs            |  13 +--
 clippy_lints/src/len_zero.rs                       |  17 +---
 clippy_lints/src/manual_bits.rs                    |  11 +-
 clippy_lints/src/manual_is_ascii_check.rs          |  15 +--
 clippy_lints/src/manual_rem_euclid.rs              |   8 +-
 clippy_lints/src/match_result_ok.rs                |  25 ++---
 clippy_lints/src/neg_multiply.rs                   |   6 +-
 clippy_lints/src/non_octal_unix_permissions.rs     |   2 +
 clippy_lints/src/swap.rs                           | 111 ++++++++++++---------
 tests/ui/match_result_ok.fixed                     |   2 +-
 tests/ui/match_result_ok.stderr                    |   2 +-
 tests/ui/swap.fixed                                |   6 +-
 tests/ui/swap.stderr                               |  24 ++---
 17 files changed, 159 insertions(+), 129 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/cast_slice_from_raw_parts.rs b/clippy_lints/src/casts/cast_slice_from_raw_parts.rs
index 627b795d6ed..1233c632a79 100644
--- a/clippy_lints/src/casts/cast_slice_from_raw_parts.rs
+++ b/clippy_lints/src/casts/cast_slice_from_raw_parts.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::msrvs::{self, Msrv};
-use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::source::snippet_with_context;
 use clippy_utils::{match_def_path, paths};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
@@ -34,6 +34,8 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_expr: &Expr<'_>,
         if let ExprKind::Path(ref qpath) = fun.kind;
         if let Some(fun_def_id) = cx.qpath_res(qpath, fun.hir_id).opt_def_id();
         if let Some(rpk) = raw_parts_kind(cx, fun_def_id);
+        let ctxt = expr.span.ctxt();
+        if cast_expr.span.ctxt() == ctxt;
         then {
             let func = match rpk {
                 RawPartsKind::Immutable => "from_raw_parts",
@@ -41,8 +43,8 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_expr: &Expr<'_>,
             };
             let span = expr.span;
             let mut applicability = Applicability::MachineApplicable;
-            let ptr = snippet_with_applicability(cx, ptr_arg.span, "ptr", &mut applicability);
-            let len = snippet_with_applicability(cx, len_arg.span, "len", &mut applicability);
+            let ptr = snippet_with_context(cx, ptr_arg.span, ctxt, "ptr", &mut applicability).0;
+            let len = snippet_with_context(cx, len_arg.span, ctxt, "len", &mut applicability).0;
             span_lint_and_sugg(
                 cx,
                 CAST_SLICE_FROM_RAW_PARTS,
diff --git a/clippy_lints/src/default_instead_of_iter_empty.rs b/clippy_lints/src/default_instead_of_iter_empty.rs
index 1ad929864b2..f296b80d283 100644
--- a/clippy_lints/src/default_instead_of_iter_empty.rs
+++ b/clippy_lints/src/default_instead_of_iter_empty.rs
@@ -1,11 +1,12 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::last_path_segment;
-use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::source::snippet_with_context;
 use clippy_utils::{match_def_path, paths};
 use rustc_errors::Applicability;
 use rustc_hir::{def, Expr, ExprKind, GenericArg, QPath, TyKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::SyntaxContext;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -38,9 +39,11 @@ impl<'tcx> LateLintPass<'tcx> for DefaultIterEmpty {
             && let QPath::Resolved(None, path) = ty_path
             && let def::Res::Def(_, def_id) = &path.res
             && match_def_path(cx, *def_id, &paths::ITER_EMPTY)
+            && let ctxt = expr.span.ctxt()
+            && ty.span.ctxt() == ctxt
         {
             let mut applicability = Applicability::MachineApplicable;
-            let sugg = make_sugg(cx, ty_path, &mut applicability);
+            let sugg = make_sugg(cx, ty_path, ctxt, &mut applicability);
             span_lint_and_sugg(
                 cx,
                 DEFAULT_INSTEAD_OF_ITER_EMPTY,
@@ -54,14 +57,19 @@ impl<'tcx> LateLintPass<'tcx> for DefaultIterEmpty {
     }
 }
 
-fn make_sugg(cx: &LateContext<'_>, ty_path: &rustc_hir::QPath<'_>, applicability: &mut Applicability) -> String {
+fn make_sugg(
+    cx: &LateContext<'_>,
+    ty_path: &rustc_hir::QPath<'_>,
+    ctxt: SyntaxContext,
+    applicability: &mut Applicability,
+) -> String {
     if let Some(last) = last_path_segment(ty_path).args
         && let Some(iter_ty) = last.args.iter().find_map(|arg| match arg {
             GenericArg::Type(ty) => Some(ty),
             _ => None,
         })
     {
-        format!("std::iter::empty::<{}>()", snippet_with_applicability(cx, iter_ty.span, "..", applicability))
+        format!("std::iter::empty::<{}>()", snippet_with_context(cx, iter_ty.span, ctxt, "..", applicability).0)
     } else {
         "std::iter::empty()".to_owned()
     }
diff --git a/clippy_lints/src/format.rs b/clippy_lints/src/format.rs
index d0fab694960..8040938c626 100644
--- a/clippy_lints/src/format.rs
+++ b/clippy_lints/src/format.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::macros::{root_macro_call_first_node, FormatArgsExpn};
-use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::source::snippet_with_context;
 use clippy_utils::sugg::Sugg;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
@@ -84,9 +84,9 @@ impl<'tcx> LateLintPass<'tcx> for UselessFormat {
                         _ => false,
                     };
                     let sugg = if is_new_string {
-                        snippet_with_applicability(cx, value.span, "..", &mut applicability).into_owned()
+                        snippet_with_context(cx, value.span, call_site.ctxt(), "..", &mut applicability).0.into_owned()
                     } else {
-                        let sugg = Sugg::hir_with_applicability(cx, value, "<arg>", &mut applicability);
+                        let sugg = Sugg::hir_with_context(cx, value, call_site.ctxt(), "<arg>", &mut applicability);
                         format!("{}.to_string()", sugg.maybe_par())
                     };
                     span_useless_format(cx, call_site, sugg, applicability);
diff --git a/clippy_lints/src/implicit_saturating_add.rs b/clippy_lints/src/implicit_saturating_add.rs
index 6e19343931e..57e6caa8711 100644
--- a/clippy_lints/src/implicit_saturating_add.rs
+++ b/clippy_lints/src/implicit_saturating_add.rs
@@ -1,7 +1,7 @@
 use clippy_utils::consts::{constant, Constant};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::get_parent_expr;
-use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::source::snippet_with_context;
 use if_chain::if_chain;
 use rustc_ast::ast::{LitIntType, LitKind};
 use rustc_errors::Applicability;
@@ -55,6 +55,9 @@ impl<'tcx> LateLintPass<'tcx> for ImplicitSaturatingAdd {
             if let ExprKind::AssignOp(op1, target, value) = ex.kind;
             let ty = cx.typeck_results().expr_ty(target);
             if Some(c) == get_int_max(ty);
+            let ctxt = expr.span.ctxt();
+            if ex.span.ctxt() == ctxt;
+            if expr1.span.ctxt() == ctxt;
             if clippy_utils::SpanlessEq::new(cx).eq_expr(l, target);
             if BinOpKind::Add == op1.node;
             if let ExprKind::Lit(ref lit) = value.kind;
@@ -62,8 +65,15 @@ impl<'tcx> LateLintPass<'tcx> for ImplicitSaturatingAdd {
             if block.expr.is_none();
             then {
                 let mut app = Applicability::MachineApplicable;
-                let code = snippet_with_applicability(cx, target.span, "_", &mut app);
-                let sugg = if let Some(parent) = get_parent_expr(cx, expr) && let ExprKind::If(_cond, _then, Some(else_)) = parent.kind && else_.hir_id == expr.hir_id {format!("{{{code} = {code}.saturating_add(1); }}")} else {format!("{code} = {code}.saturating_add(1);")};
+                let code = snippet_with_context(cx, target.span, ctxt, "_", &mut app).0;
+                let sugg = if let Some(parent) = get_parent_expr(cx, expr)
+                    && let ExprKind::If(_cond, _then, Some(else_)) = parent.kind
+                    && else_.hir_id == expr.hir_id
+                {
+                    format!("{{{code} = {code}.saturating_add(1); }}")
+                } else {
+                    format!("{code} = {code}.saturating_add(1);")
+                };
                 span_lint_and_sugg(cx, IMPLICIT_SATURATING_ADD, expr.span, "manual saturating add detected", "use instead", sugg, app);
             }
         }
diff --git a/clippy_lints/src/instant_subtraction.rs b/clippy_lints/src/instant_subtraction.rs
index 668110c7cc0..34e9991582c 100644
--- a/clippy_lints/src/instant_subtraction.rs
+++ b/clippy_lints/src/instant_subtraction.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::{self, span_lint_and_sugg};
 use clippy_utils::msrvs::{self, Msrv};
-use clippy_utils::source;
+use clippy_utils::source::snippet_with_context;
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty;
 use rustc_errors::Applicability;
@@ -161,14 +161,9 @@ fn print_unchecked_duration_subtraction_sugg(
 ) {
     let mut applicability = Applicability::MachineApplicable;
 
-    let left_expr =
-        source::snippet_with_applicability(cx, left_expr.span, "std::time::Instant::now()", &mut applicability);
-    let right_expr = source::snippet_with_applicability(
-        cx,
-        right_expr.span,
-        "std::time::Duration::from_secs(1)",
-        &mut applicability,
-    );
+    let ctxt = expr.span.ctxt();
+    let left_expr = snippet_with_context(cx, left_expr.span, ctxt, "<instant>", &mut applicability).0;
+    let right_expr = snippet_with_context(cx, right_expr.span, ctxt, "<duration>", &mut applicability).0;
 
     diagnostics::span_lint_and_sugg(
         cx,
diff --git a/clippy_lints/src/len_zero.rs b/clippy_lints/src/len_zero.rs
index e13bc47973b..6c32393dc01 100644
--- a/clippy_lints/src/len_zero.rs
+++ b/clippy_lints/src/len_zero.rs
@@ -1,13 +1,13 @@
 use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg, span_lint_and_then};
-use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::{get_item_name, get_parent_as_impl, is_lint_allowed, peel_ref_operators};
+use clippy_utils::source::snippet_with_context;
+use clippy_utils::{get_item_name, get_parent_as_impl, is_lint_allowed, peel_ref_operators, sugg::Sugg};
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::def_id::DefIdSet;
 use rustc_hir::{
     def_id::DefId, AssocItemKind, BinOpKind, Expr, ExprKind, FnRetTy, ImplItem, ImplItemKind, ImplicitSelfKind, Item,
-    ItemKind, Mutability, Node, TraitItemRef, TyKind, UnOp,
+    ItemKind, Mutability, Node, TraitItemRef, TyKind,
 };
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{self, AssocKind, FnSig, Ty};
@@ -16,7 +16,6 @@ use rustc_span::{
     source_map::{Span, Spanned, Symbol},
     symbol::sym,
 };
-use std::borrow::Cow;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -431,7 +430,7 @@ fn check_len(
                 &format!("using `{op}is_empty` is clearer and more explicit"),
                 format!(
                     "{op}{}.is_empty()",
-                    snippet_with_applicability(cx, receiver.span, "_", &mut applicability)
+                    snippet_with_context(cx, receiver.span, span.ctxt(), "_", &mut applicability).0,
                 ),
                 applicability,
             );
@@ -444,13 +443,7 @@ fn check_empty_expr(cx: &LateContext<'_>, span: Span, lit1: &Expr<'_>, lit2: &Ex
         let mut applicability = Applicability::MachineApplicable;
 
         let lit1 = peel_ref_operators(cx, lit1);
-        let mut lit_str = snippet_with_applicability(cx, lit1.span, "_", &mut applicability);
-
-        // Wrap the expression in parentheses if it's a deref expression. Otherwise operator precedence will
-        // cause the code to dereference boolean(won't compile).
-        if let ExprKind::Unary(UnOp::Deref, _) = lit1.kind {
-            lit_str = Cow::from(format!("({lit_str})"));
-        }
+        let lit_str = Sugg::hir_with_context(cx, lit1, span.ctxt(), "_", &mut applicability).maybe_par();
 
         span_lint_and_sugg(
             cx,
diff --git a/clippy_lints/src/manual_bits.rs b/clippy_lints/src/manual_bits.rs
index 462d73cf0b9..bc815dc4a26 100644
--- a/clippy_lints/src/manual_bits.rs
+++ b/clippy_lints/src/manual_bits.rs
@@ -1,11 +1,12 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::get_parent_expr;
 use clippy_utils::msrvs::{self, Msrv};
-use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::source::snippet_with_context;
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind, GenericArg, QPath};
-use rustc_lint::{LateContext, LateLintPass};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::{self, Ty};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::sym;
@@ -55,13 +56,17 @@ impl<'tcx> LateLintPass<'tcx> for ManualBits {
         if_chain! {
             if let ExprKind::Binary(bin_op, left_expr, right_expr) = expr.kind;
             if let BinOpKind::Mul = &bin_op.node;
+            if !in_external_macro(cx.sess(), expr.span);
+            let ctxt = expr.span.ctxt();
+            if left_expr.span.ctxt() == ctxt;
+            if right_expr.span.ctxt() == ctxt;
             if let Some((real_ty, resolved_ty, other_expr)) = get_one_size_of_ty(cx, left_expr, right_expr);
             if matches!(resolved_ty.kind(), ty::Int(_) | ty::Uint(_));
             if let ExprKind::Lit(lit) = &other_expr.kind;
             if let LitKind::Int(8, _) = lit.node;
             then {
                 let mut app = Applicability::MachineApplicable;
-                let ty_snip = snippet_with_applicability(cx, real_ty.span, "..", &mut app);
+                let ty_snip = snippet_with_context(cx, real_ty.span, ctxt, "..", &mut app).0;
                 let sugg = create_sugg(cx, expr, format!("{ty_snip}::BITS"));
 
                 span_lint_and_sugg(
diff --git a/clippy_lints/src/manual_is_ascii_check.rs b/clippy_lints/src/manual_is_ascii_check.rs
index 2fd32c009ea..31264261f5d 100644
--- a/clippy_lints/src/manual_is_ascii_check.rs
+++ b/clippy_lints/src/manual_is_ascii_check.rs
@@ -1,5 +1,5 @@
 use clippy_utils::msrvs::{self, Msrv};
-use clippy_utils::{diagnostics::span_lint_and_sugg, higher, in_constant, macros::root_macro_call, source::snippet};
+use clippy_utils::{diagnostics::span_lint_and_sugg, higher, in_constant, macros::root_macro_call, sugg::Sugg};
 use rustc_ast::ast::RangeLimits;
 use rustc_ast::LitKind::{Byte, Char};
 use rustc_errors::Applicability;
@@ -115,15 +115,8 @@ fn check_is_ascii(cx: &LateContext<'_>, span: Span, recv: &Expr<'_>, range: &Cha
         CharRange::Otherwise => None,
     } {
         let default_snip = "..";
-        // `snippet_with_applicability` may set applicability to `MaybeIncorrect` for
-        // macro span, so we check applicability manually by comparing `recv` is not default.
-        let recv = snippet(cx, recv.span, default_snip);
-
-        let applicability = if recv == default_snip {
-            Applicability::HasPlaceholders
-        } else {
-            Applicability::MachineApplicable
-        };
+        let mut app = Applicability::MachineApplicable;
+        let recv = Sugg::hir_with_context(cx, recv, span.ctxt(), default_snip, &mut app).maybe_par();
 
         span_lint_and_sugg(
             cx,
@@ -132,7 +125,7 @@ fn check_is_ascii(cx: &LateContext<'_>, span: Span, recv: &Expr<'_>, range: &Cha
             "manual check for common ascii range",
             "try",
             format!("{recv}.{sugg}()"),
-            applicability,
+            app,
         );
     }
 }
diff --git a/clippy_lints/src/manual_rem_euclid.rs b/clippy_lints/src/manual_rem_euclid.rs
index 38f41d077c1..aafee92713f 100644
--- a/clippy_lints/src/manual_rem_euclid.rs
+++ b/clippy_lints/src/manual_rem_euclid.rs
@@ -1,7 +1,7 @@
 use clippy_utils::consts::{constant_full_int, FullInt};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::msrvs::{self, Msrv};
-use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::source::snippet_with_context;
 use clippy_utils::{in_constant, path_to_local};
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind, Node, TyKind};
@@ -60,12 +60,16 @@ impl<'tcx> LateLintPass<'tcx> for ManualRemEuclid {
             return;
         }
 
+        // (x % c + c) % c
         if let ExprKind::Binary(op1, expr1, right) = expr.kind
             && op1.node == BinOpKind::Rem
+            && let ctxt = expr.span.ctxt()
+            && expr1.span.ctxt() == ctxt
             && let Some(const1) = check_for_unsigned_int_constant(cx, right)
             && let ExprKind::Binary(op2, left, right) = expr1.kind
             && op2.node == BinOpKind::Add
             && let Some((const2, expr2)) = check_for_either_unsigned_int_constant(cx, left, right)
+            && expr2.span.ctxt() == ctxt
             && let ExprKind::Binary(op3, expr3, right) = expr2.kind
             && op3.node == BinOpKind::Rem
             && let Some(const3) = check_for_unsigned_int_constant(cx, right)
@@ -86,7 +90,7 @@ impl<'tcx> LateLintPass<'tcx> for ManualRemEuclid {
                 };
 
                 let mut app = Applicability::MachineApplicable;
-                let rem_of = snippet_with_applicability(cx, expr3.span, "_", &mut app);
+                let rem_of = snippet_with_context(cx, expr3.span, ctxt, "_", &mut app).0;
                 span_lint_and_sugg(
                     cx,
                     MANUAL_REM_EUCLID,
diff --git a/clippy_lints/src/match_result_ok.rs b/clippy_lints/src/match_result_ok.rs
index a020282d234..6ec9784038c 100644
--- a/clippy_lints/src/match_result_ok.rs
+++ b/clippy_lints/src/match_result_ok.rs
@@ -1,11 +1,11 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::higher;
-use clippy_utils::method_chain_args;
-use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::is_res_lang_ctor;
+use clippy_utils::source::snippet_with_context;
 use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
-use rustc_hir::{Expr, ExprKind, PatKind, QPath};
+use rustc_hir::{Expr, ExprKind, LangItem, PatKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::sym;
@@ -58,17 +58,18 @@ impl<'tcx> LateLintPass<'tcx> for MatchResultOk {
             };
 
         if_chain! {
-            if let ExprKind::MethodCall(ok_path, result_types_0, ..) = let_expr.kind; //check is expr.ok() has type Result<T,E>.ok(, _)
-            if let PatKind::TupleStruct(QPath::Resolved(_, x), y, _)  = let_pat.kind; //get operation
-            if method_chain_args(let_expr, &["ok"]).is_some(); //test to see if using ok() method use std::marker::Sized;
-            if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(result_types_0), sym::Result);
-            if rustc_hir_pretty::to_string(rustc_hir_pretty::NO_ANN, |s| s.print_path(x, false)) == "Some";
-
+            if let ExprKind::MethodCall(ok_path, recv, [], ..) = let_expr.kind; //check is expr.ok() has type Result<T,E>.ok(, _)
+            if let PatKind::TupleStruct(ref pat_path, [ok_pat], _)  = let_pat.kind; //get operation
+            if ok_path.ident.as_str() == "ok";
+            if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(recv), sym::Result);
+            if is_res_lang_ctor(cx, cx.qpath_res(pat_path, let_pat.hir_id), LangItem::OptionSome);
+            let ctxt = expr.span.ctxt();
+            if let_expr.span.ctxt() == ctxt;
+            if let_pat.span.ctxt() == ctxt;
             then {
-
                 let mut applicability = Applicability::MachineApplicable;
-                let some_expr_string = snippet_with_applicability(cx, y[0].span, "", &mut applicability);
-                let trimmed_ok = snippet_with_applicability(cx, let_expr.span.until(ok_path.ident.span), "", &mut applicability);
+                let some_expr_string = snippet_with_context(cx, ok_pat.span, ctxt, "", &mut applicability).0;
+                let trimmed_ok = snippet_with_context(cx, recv.span, ctxt, "", &mut applicability).0;
                 let sugg = format!(
                     "{ifwhile} let Ok({some_expr_string}) = {}",
                     trimmed_ok.trim().trim_end_matches('.'),
diff --git a/clippy_lints/src/neg_multiply.rs b/clippy_lints/src/neg_multiply.rs
index fb9a4abd0b4..ed3e2c6e7f4 100644
--- a/clippy_lints/src/neg_multiply.rs
+++ b/clippy_lints/src/neg_multiply.rs
@@ -1,6 +1,6 @@
 use clippy_utils::consts::{self, Constant};
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::source::snippet_with_context;
 use clippy_utils::sugg::has_enclosing_paren;
 use if_chain::if_chain;
 use rustc_ast::util::parser::PREC_PREFIX;
@@ -60,8 +60,8 @@ fn check_mul(cx: &LateContext<'_>, span: Span, lit: &Expr<'_>, exp: &Expr<'_>) {
 
         then {
             let mut applicability = Applicability::MachineApplicable;
-            let snip = snippet_with_applicability(cx, exp.span, "..", &mut applicability);
-            let suggestion = if exp.precedence().order() < PREC_PREFIX && !has_enclosing_paren(&snip) {
+            let (snip, from_macro) = snippet_with_context(cx, exp.span, span.ctxt(), "..", &mut applicability);
+            let suggestion = if !from_macro && exp.precedence().order() < PREC_PREFIX && !has_enclosing_paren(&snip) {
                 format!("-({snip})")
             } else {
                 format!("-{snip}")
diff --git a/clippy_lints/src/non_octal_unix_permissions.rs b/clippy_lints/src/non_octal_unix_permissions.rs
index 2ecb0487484..e1de494eb41 100644
--- a/clippy_lints/src/non_octal_unix_permissions.rs
+++ b/clippy_lints/src/non_octal_unix_permissions.rs
@@ -53,6 +53,7 @@ impl<'tcx> LateLintPass<'tcx> for NonOctalUnixPermissions {
                             || is_type_diagnostic_item(cx, obj_ty, sym::DirBuilder)))
                         || (path.ident.name == sym!(set_mode) && match_type(cx, obj_ty, &paths::PERMISSIONS));
                     if let ExprKind::Lit(_) = param.kind;
+                    if param.span.ctxt() == expr.span.ctxt();
 
                     then {
                         let Some(snip) = snippet_opt(cx, param.span) else {
@@ -71,6 +72,7 @@ impl<'tcx> LateLintPass<'tcx> for NonOctalUnixPermissions {
                     if let Some(def_id) = cx.qpath_res(path, func.hir_id).opt_def_id();
                     if match_def_path(cx, def_id, &paths::PERMISSIONS_FROM_MODE);
                     if let ExprKind::Lit(_) = param.kind;
+                    if param.span.ctxt() == expr.span.ctxt();
                     if let Some(snip) = snippet_opt(cx, param.span);
                     if !snip.starts_with("0o");
                     then {
diff --git a/clippy_lints/src/swap.rs b/clippy_lints/src/swap.rs
index 0f062cecf88..1aeac724ab1 100644
--- a/clippy_lints/src/swap.rs
+++ b/clippy_lints/src/swap.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
-use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::source::snippet_with_context;
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::{can_mut_borrow_both, eq_expr_value, in_constant, std_or_core};
@@ -10,6 +10,7 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Spanned;
+use rustc_span::SyntaxContext;
 use rustc_span::{sym, symbol::Ident, Span};
 
 declare_clippy_lint! {
@@ -80,43 +81,45 @@ impl<'tcx> LateLintPass<'tcx> for Swap {
 }
 
 fn generate_swap_warning(cx: &LateContext<'_>, e1: &Expr<'_>, e2: &Expr<'_>, span: Span, is_xor_based: bool) {
+    let ctxt = span.ctxt();
     let mut applicability = Applicability::MachineApplicable;
 
     if !can_mut_borrow_both(cx, e1, e2) {
-        if let ExprKind::Index(lhs1, idx1) = e1.kind {
-            if let ExprKind::Index(lhs2, idx2) = e2.kind {
-                if eq_expr_value(cx, lhs1, lhs2) {
-                    let ty = cx.typeck_results().expr_ty(lhs1).peel_refs();
+        if let ExprKind::Index(lhs1, idx1) = e1.kind
+            && let ExprKind::Index(lhs2, idx2) = e2.kind
+            && eq_expr_value(cx, lhs1, lhs2)
+            && e1.span.ctxt() == ctxt
+            && e2.span.ctxt() == ctxt
+        {
+            let ty = cx.typeck_results().expr_ty(lhs1).peel_refs();
 
-                    if matches!(ty.kind(), ty::Slice(_))
-                        || matches!(ty.kind(), ty::Array(_, _))
-                        || is_type_diagnostic_item(cx, ty, sym::Vec)
-                        || is_type_diagnostic_item(cx, ty, sym::VecDeque)
-                    {
-                        let slice = Sugg::hir_with_applicability(cx, lhs1, "<slice>", &mut applicability);
-                        span_lint_and_sugg(
-                            cx,
-                            MANUAL_SWAP,
-                            span,
-                            &format!("this looks like you are swapping elements of `{slice}` manually"),
-                            "try",
-                            format!(
-                                "{}.swap({}, {})",
-                                slice.maybe_par(),
-                                snippet_with_applicability(cx, idx1.span, "..", &mut applicability),
-                                snippet_with_applicability(cx, idx2.span, "..", &mut applicability),
-                            ),
-                            applicability,
-                        );
-                    }
-                }
+            if matches!(ty.kind(), ty::Slice(_))
+                || matches!(ty.kind(), ty::Array(_, _))
+                || is_type_diagnostic_item(cx, ty, sym::Vec)
+                || is_type_diagnostic_item(cx, ty, sym::VecDeque)
+            {
+                let slice = Sugg::hir_with_applicability(cx, lhs1, "<slice>", &mut applicability);
+                span_lint_and_sugg(
+                    cx,
+                    MANUAL_SWAP,
+                    span,
+                    &format!("this looks like you are swapping elements of `{slice}` manually"),
+                    "try",
+                    format!(
+                        "{}.swap({}, {});",
+                        slice.maybe_par(),
+                        snippet_with_context(cx, idx1.span, ctxt, "..", &mut applicability).0,
+                        snippet_with_context(cx, idx2.span, ctxt, "..", &mut applicability).0,
+                    ),
+                    applicability,
+                );
             }
         }
         return;
     }
 
-    let first = Sugg::hir_with_applicability(cx, e1, "..", &mut applicability);
-    let second = Sugg::hir_with_applicability(cx, e2, "..", &mut applicability);
+    let first = Sugg::hir_with_context(cx, e1, ctxt, "..", &mut applicability);
+    let second = Sugg::hir_with_context(cx, e2, ctxt, "..", &mut applicability);
     let Some(sugg) = std_or_core(cx) else { return };
 
     span_lint_and_then(
@@ -128,7 +131,7 @@ fn generate_swap_warning(cx: &LateContext<'_>, e1: &Expr<'_>, e2: &Expr<'_>, spa
             diag.span_suggestion(
                 span,
                 "try",
-                format!("{sugg}::mem::swap({}, {})", first.mut_addr(), second.mut_addr()),
+                format!("{sugg}::mem::swap({}, {});", first.mut_addr(), second.mut_addr()),
                 applicability,
             );
             if !is_xor_based {
@@ -144,19 +147,19 @@ fn check_manual_swap(cx: &LateContext<'_>, block: &Block<'_>) {
         return;
     }
 
-    for w in block.stmts.windows(3) {
+    for [s1, s2, s3] in block.stmts.array_windows::<3>() {
         if_chain! {
             // let t = foo();
-            if let StmtKind::Local(tmp) = w[0].kind;
+            if let StmtKind::Local(tmp) = s1.kind;
             if let Some(tmp_init) = tmp.init;
             if let PatKind::Binding(.., ident, None) = tmp.pat.kind;
 
             // foo() = bar();
-            if let StmtKind::Semi(first) = w[1].kind;
+            if let StmtKind::Semi(first) = s2.kind;
             if let ExprKind::Assign(lhs1, rhs1, _) = first.kind;
 
             // bar() = t;
-            if let StmtKind::Semi(second) = w[2].kind;
+            if let StmtKind::Semi(second) = s3.kind;
             if let ExprKind::Assign(lhs2, rhs2, _) = second.kind;
             if let ExprKind::Path(QPath::Resolved(None, rhs2)) = rhs2.kind;
             if rhs2.segments.len() == 1;
@@ -164,8 +167,15 @@ fn check_manual_swap(cx: &LateContext<'_>, block: &Block<'_>) {
             if ident.name == rhs2.segments[0].ident.name;
             if eq_expr_value(cx, tmp_init, lhs1);
             if eq_expr_value(cx, rhs1, lhs2);
+
+            let ctxt = s1.span.ctxt();
+            if s2.span.ctxt() == ctxt;
+            if s3.span.ctxt() == ctxt;
+            if first.span.ctxt() == ctxt;
+            if second.span.ctxt() == ctxt;
+
             then {
-                let span = w[0].span.to(second.span);
+                let span = s1.span.to(s3.span);
                 generate_swap_warning(cx, lhs1, lhs2, span, false);
             }
         }
@@ -246,17 +256,20 @@ fn parse<'a, 'hir>(stmt: &'a Stmt<'hir>) -> Option<(ExprOrIdent<'hir>, &'a Expr<
 
 /// Implementation of the xor case for `MANUAL_SWAP` lint.
 fn check_xor_swap(cx: &LateContext<'_>, block: &Block<'_>) {
-    for window in block.stmts.windows(3) {
+    for [s1, s2, s3] in block.stmts.array_windows::<3>() {
         if_chain! {
-            if let Some((lhs0, rhs0)) = extract_sides_of_xor_assign(&window[0]);
-            if let Some((lhs1, rhs1)) = extract_sides_of_xor_assign(&window[1]);
-            if let Some((lhs2, rhs2)) = extract_sides_of_xor_assign(&window[2]);
+            let ctxt = s1.span.ctxt();
+            if let Some((lhs0, rhs0)) = extract_sides_of_xor_assign(s1, ctxt);
+            if let Some((lhs1, rhs1)) = extract_sides_of_xor_assign(s2, ctxt);
+            if let Some((lhs2, rhs2)) = extract_sides_of_xor_assign(s3, ctxt);
             if eq_expr_value(cx, lhs0, rhs1);
             if eq_expr_value(cx, lhs2, rhs1);
             if eq_expr_value(cx, lhs1, rhs0);
             if eq_expr_value(cx, lhs1, rhs2);
+            if s2.span.ctxt() == ctxt;
+            if s3.span.ctxt() == ctxt;
             then {
-                let span = window[0].span.to(window[2].span);
+                let span = s1.span.to(s3.span);
                 generate_swap_warning(cx, lhs0, rhs0, span, true);
             }
         };
@@ -264,9 +277,12 @@ fn check_xor_swap(cx: &LateContext<'_>, block: &Block<'_>) {
 }
 
 /// Returns the lhs and rhs of an xor assignment statement.
-fn extract_sides_of_xor_assign<'a, 'hir>(stmt: &'a Stmt<'hir>) -> Option<(&'a Expr<'hir>, &'a Expr<'hir>)> {
-    if let StmtKind::Semi(expr) = stmt.kind {
-        if let ExprKind::AssignOp(
+fn extract_sides_of_xor_assign<'a, 'hir>(
+    stmt: &'a Stmt<'hir>,
+    ctxt: SyntaxContext,
+) -> Option<(&'a Expr<'hir>, &'a Expr<'hir>)> {
+    if let StmtKind::Semi(expr) = stmt.kind
+        && let ExprKind::AssignOp(
             Spanned {
                 node: BinOpKind::BitXor,
                 ..
@@ -274,9 +290,10 @@ fn extract_sides_of_xor_assign<'a, 'hir>(stmt: &'a Stmt<'hir>) -> Option<(&'a Ex
             lhs,
             rhs,
         ) = expr.kind
-        {
-            return Some((lhs, rhs));
-        }
+        && expr.span.ctxt() == ctxt
+    {
+        Some((lhs, rhs))
+    } else {
+        None
     }
-    None
 }
diff --git a/tests/ui/match_result_ok.fixed b/tests/ui/match_result_ok.fixed
index 8b91b9854a0..10ae1ee5245 100644
--- a/tests/ui/match_result_ok.fixed
+++ b/tests/ui/match_result_ok.fixed
@@ -16,7 +16,7 @@ fn str_to_int_ok(x: &str) -> i32 {
 #[rustfmt::skip]
 fn strange_some_no_else(x: &str) -> i32 {
     {
-        if let Ok(y) = x   .   parse()       {
+        if let Ok(y) = x   .   parse()    {
             return y;
         };
         0
diff --git a/tests/ui/match_result_ok.stderr b/tests/ui/match_result_ok.stderr
index 98a95705ca5..cbdc56aa28c 100644
--- a/tests/ui/match_result_ok.stderr
+++ b/tests/ui/match_result_ok.stderr
@@ -18,7 +18,7 @@ LL |         if let Some(y) = x   .   parse()   .   ok   ()    {
    |
 help: consider matching on `Ok(y)` and removing the call to `ok` instead
    |
-LL |         if let Ok(y) = x   .   parse()       {
+LL |         if let Ok(y) = x   .   parse()    {
    |         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 error: matching on `Some` with `ok()` is redundant
diff --git a/tests/ui/swap.fixed b/tests/ui/swap.fixed
index fa89706a815..04008c0d9b3 100644
--- a/tests/ui/swap.fixed
+++ b/tests/ui/swap.fixed
@@ -65,19 +65,19 @@ fn xor_swap_locals() {
     // This is an xor-based swap of local variables.
     let mut a = 0;
     let mut b = 1;
-    std::mem::swap(&mut a, &mut b)
+    std::mem::swap(&mut a, &mut b);
 }
 
 fn xor_field_swap() {
     // This is an xor-based swap of fields in a struct.
     let mut bar = Bar { a: 0, b: 1 };
-    std::mem::swap(&mut bar.a, &mut bar.b)
+    std::mem::swap(&mut bar.a, &mut bar.b);
 }
 
 fn xor_slice_swap() {
     // This is an xor-based swap of a slice
     let foo = &mut [1, 2];
-    foo.swap(0, 1)
+    foo.swap(0, 1);
 }
 
 fn xor_no_swap() {
diff --git a/tests/ui/swap.stderr b/tests/ui/swap.stderr
index f0acbfe253f..825c9261e19 100644
--- a/tests/ui/swap.stderr
+++ b/tests/ui/swap.stderr
@@ -4,7 +4,7 @@ error: this looks like you are swapping `bar.a` and `bar.b` manually
 LL | /     let temp = bar.a;
 LL | |     bar.a = bar.b;
 LL | |     bar.b = temp;
-   | |________________^ help: try: `std::mem::swap(&mut bar.a, &mut bar.b)`
+   | |_________________^ help: try: `std::mem::swap(&mut bar.a, &mut bar.b);`
    |
    = note: or maybe you should use `std::mem::replace`?
    = note: `-D clippy::manual-swap` implied by `-D warnings`
@@ -15,7 +15,7 @@ error: this looks like you are swapping elements of `foo` manually
 LL | /     let temp = foo[0];
 LL | |     foo[0] = foo[1];
 LL | |     foo[1] = temp;
-   | |_________________^ help: try: `foo.swap(0, 1)`
+   | |__________________^ help: try: `foo.swap(0, 1);`
 
 error: this looks like you are swapping elements of `foo` manually
   --> $DIR/swap.rs:46:5
@@ -23,7 +23,7 @@ error: this looks like you are swapping elements of `foo` manually
 LL | /     let temp = foo[0];
 LL | |     foo[0] = foo[1];
 LL | |     foo[1] = temp;
-   | |_________________^ help: try: `foo.swap(0, 1)`
+   | |__________________^ help: try: `foo.swap(0, 1);`
 
 error: this looks like you are swapping elements of `foo` manually
   --> $DIR/swap.rs:65:5
@@ -31,7 +31,7 @@ error: this looks like you are swapping elements of `foo` manually
 LL | /     let temp = foo[0];
 LL | |     foo[0] = foo[1];
 LL | |     foo[1] = temp;
-   | |_________________^ help: try: `foo.swap(0, 1)`
+   | |__________________^ help: try: `foo.swap(0, 1);`
 
 error: this looks like you are swapping `a` and `b` manually
   --> $DIR/swap.rs:76:5
@@ -39,7 +39,7 @@ error: this looks like you are swapping `a` and `b` manually
 LL | /     a ^= b;
 LL | |     b ^= a;
 LL | |     a ^= b;
-   | |___________^ help: try: `std::mem::swap(&mut a, &mut b)`
+   | |___________^ help: try: `std::mem::swap(&mut a, &mut b);`
 
 error: this looks like you are swapping `bar.a` and `bar.b` manually
   --> $DIR/swap.rs:84:5
@@ -47,7 +47,7 @@ error: this looks like you are swapping `bar.a` and `bar.b` manually
 LL | /     bar.a ^= bar.b;
 LL | |     bar.b ^= bar.a;
 LL | |     bar.a ^= bar.b;
-   | |___________________^ help: try: `std::mem::swap(&mut bar.a, &mut bar.b)`
+   | |___________________^ help: try: `std::mem::swap(&mut bar.a, &mut bar.b);`
 
 error: this looks like you are swapping elements of `foo` manually
   --> $DIR/swap.rs:92:5
@@ -55,7 +55,7 @@ error: this looks like you are swapping elements of `foo` manually
 LL | /     foo[0] ^= foo[1];
 LL | |     foo[1] ^= foo[0];
 LL | |     foo[0] ^= foo[1];
-   | |_____________________^ help: try: `foo.swap(0, 1)`
+   | |_____________________^ help: try: `foo.swap(0, 1);`
 
 error: this looks like you are swapping `foo[0][1]` and `bar[1][0]` manually
   --> $DIR/swap.rs:121:5
@@ -63,7 +63,7 @@ error: this looks like you are swapping `foo[0][1]` and `bar[1][0]` manually
 LL | /     let temp = foo[0][1];
 LL | |     foo[0][1] = bar[1][0];
 LL | |     bar[1][0] = temp;
-   | |____________________^ help: try: `std::mem::swap(&mut foo[0][1], &mut bar[1][0])`
+   | |_____________________^ help: try: `std::mem::swap(&mut foo[0][1], &mut bar[1][0]);`
    |
    = note: or maybe you should use `std::mem::replace`?
 
@@ -74,7 +74,7 @@ LL |       ; let t = a;
    |  _______^
 LL | |     a = b;
 LL | |     b = t;
-   | |_________^ help: try: `std::mem::swap(&mut a, &mut b)`
+   | |__________^ help: try: `std::mem::swap(&mut a, &mut b);`
    |
    = note: or maybe you should use `std::mem::replace`?
 
@@ -85,7 +85,7 @@ LL |       ; let t = c.0;
    |  _______^
 LL | |     c.0 = a;
 LL | |     a = t;
-   | |_________^ help: try: `std::mem::swap(&mut c.0, &mut a)`
+   | |__________^ help: try: `std::mem::swap(&mut c.0, &mut a);`
    |
    = note: or maybe you should use `std::mem::replace`?
 
@@ -95,7 +95,7 @@ error: this looks like you are swapping `b` and `a` manually
 LL | /     let t = b;
 LL | |     b = a;
 LL | |     a = t;
-   | |_________^ help: try: `std::mem::swap(&mut b, &mut a)`
+   | |__________^ help: try: `std::mem::swap(&mut b, &mut a);`
    |
    = note: or maybe you should use `std::mem::replace`?
 
@@ -151,7 +151,7 @@ error: this looks like you are swapping `s.0.x` and `s.0.y` manually
 LL | /     let t = s.0.x;
 LL | |     s.0.x = s.0.y;
 LL | |     s.0.y = t;
-   | |_____________^ help: try: `std::mem::swap(&mut s.0.x, &mut s.0.y)`
+   | |______________^ help: try: `std::mem::swap(&mut s.0.x, &mut s.0.y);`
    |
    = note: or maybe you should use `std::mem::replace`?
 
-- 
cgit 1.4.1-3-g733a5


From 027f19c8b911458722511be4ffc469f505766ffa Mon Sep 17 00:00:00 2001
From: Takayuki Nakata <f.seasons017@gmail.com>
Date: Fri, 3 Mar 2023 22:41:39 +0900
Subject: Fix FP for `let_unit_value` when `await` used

---
 clippy_lints/src/unit_types/let_unit_value.rs | 6 +++++-
 tests/ui/let_unit.fixed                       | 4 ++++
 tests/ui/let_unit.rs                          | 4 ++++
 3 files changed, 13 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unit_types/let_unit_value.rs b/clippy_lints/src/unit_types/let_unit_value.rs
index d6167a62169..3430b6e3734 100644
--- a/clippy_lints/src/unit_types/let_unit_value.rs
+++ b/clippy_lints/src/unit_types/let_unit_value.rs
@@ -5,7 +5,7 @@ use clippy_utils::visitors::{for_each_local_assignment, for_each_value_source};
 use core::ops::ControlFlow;
 use rustc_errors::Applicability;
 use rustc_hir::def::{DefKind, Res};
-use rustc_hir::{Expr, ExprKind, HirId, HirIdSet, Local, Node, PatKind, QPath, TyKind};
+use rustc_hir::{Expr, ExprKind, HirId, HirIdSet, Local, MatchSource, Node, PatKind, QPath, TyKind};
 use rustc_lint::{LateContext, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty;
@@ -41,6 +41,10 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, local: &'tcx Local<'_>) {
                 );
             }
         } else {
+            if let ExprKind::Match(_, _, MatchSource::AwaitDesugar) = init.kind {
+                return
+            }
+
             span_lint_and_then(
                 cx,
                 LET_UNIT_VALUE,
diff --git a/tests/ui/let_unit.fixed b/tests/ui/let_unit.fixed
index 6343cff0f7f..76ff0645f41 100644
--- a/tests/ui/let_unit.fixed
+++ b/tests/ui/let_unit.fixed
@@ -175,3 +175,7 @@ fn attributes() {
     #[expect(clippy::let_unit_value)]
     let _ = f();
 }
+
+async fn issue10433() {
+    let _pending: () = std::future::pending().await;
+}
diff --git a/tests/ui/let_unit.rs b/tests/ui/let_unit.rs
index c9bb2849f5c..895ccfe366a 100644
--- a/tests/ui/let_unit.rs
+++ b/tests/ui/let_unit.rs
@@ -175,3 +175,7 @@ fn attributes() {
     #[expect(clippy::let_unit_value)]
     let _ = f();
 }
+
+async fn issue10433() {
+    let _pending: () = std::future::pending().await;
+}
-- 
cgit 1.4.1-3-g733a5


From 03b9940b29917204d46a06393f3b4196e5efd772 Mon Sep 17 00:00:00 2001
From: David Tolnay <dtolnay@gmail.com>
Date: Fri, 3 Mar 2023 13:40:07 -0800
Subject: Downgrade let_underscore_untyped to restriction

---
 clippy_lints/src/let_underscore.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/let_underscore.rs b/clippy_lints/src/let_underscore.rs
index 7600777fab9..51b5de27de8 100644
--- a/clippy_lints/src/let_underscore.rs
+++ b/clippy_lints/src/let_underscore.rs
@@ -124,7 +124,7 @@ declare_clippy_lint! {
     /// ```
     #[clippy::version = "1.69.0"]
     pub LET_UNDERSCORE_UNTYPED,
-    pedantic,
+    restriction,
     "non-binding `let` without a type annotation"
 }
 
-- 
cgit 1.4.1-3-g733a5


From cc6180c2f4bf53a235a139be0ba604dacda618a9 Mon Sep 17 00:00:00 2001
From: David Tolnay <dtolnay@gmail.com>
Date: Fri, 3 Mar 2023 18:50:53 -0800
Subject: Include former name of renamed lints in lints.json

---
 clippy_lints/src/utils/internal_lints/metadata_collector.rs | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index b1b5164ffb3..3d0d4a52511 100644
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -26,7 +26,7 @@ use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::symbol::Ident;
 use rustc_span::{sym, Loc, Span, Symbol};
 use serde::{ser::SerializeStruct, Serialize, Serializer};
-use std::collections::BinaryHeap;
+use std::collections::{BTreeSet, BinaryHeap};
 use std::fmt;
 use std::fmt::Write as _;
 use std::fs::{self, OpenOptions};
@@ -264,6 +264,9 @@ struct LintMetadata {
     /// This field is only used in the output and will only be
     /// mapped shortly before the actual output.
     applicability: Option<ApplicabilityInfo>,
+    /// All the past names of lints which have been renamed.
+    #[serde(skip_serializing_if = "BTreeSet::is_empty")]
+    former_ids: BTreeSet<String>,
 }
 
 impl LintMetadata {
@@ -283,6 +286,7 @@ impl LintMetadata {
             version,
             docs,
             applicability: None,
+            former_ids: BTreeSet::new(),
         }
     }
 }
@@ -901,6 +905,7 @@ fn collect_renames(lints: &mut Vec<LintMetadata>) {
                         if name == lint_name;
                         if let Some(past_name) = k.strip_prefix(CLIPPY_LINT_GROUP_PREFIX);
                         then {
+                            lint.former_ids.insert(past_name.to_owned());
                             writeln!(collected, "* `{past_name}`").unwrap();
                             names.push(past_name.to_string());
                         }
-- 
cgit 1.4.1-3-g733a5


From f95d9deafd0f4d206eea02f2ab56b1c495f2f8d3 Mon Sep 17 00:00:00 2001
From: Samuel Moelius <sam@moeli.us>
Date: Sat, 25 Feb 2023 15:54:31 -0500
Subject: Handle ambiguous projections

---
 clippy_lints/src/dereference.rs     |  8 ++++----
 tests/ui/crashes/ice-rust-107877.rs | 17 +++++++++++++++++
 2 files changed, 21 insertions(+), 4 deletions(-)
 create mode 100644 tests/ui/crashes/ice-rust-107877.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index b2ed8121994..4e305d4f668 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -1357,10 +1357,10 @@ fn replace_types<'tcx>(
                     && let Some(term_ty) = projection_predicate.term.ty()
                     && let ty::Param(term_param_ty) = term_ty.kind()
                 {
-                    let item_def_id = projection_predicate.projection_ty.def_id;
-                    let assoc_item = cx.tcx.associated_item(item_def_id);
-                    let projection = cx.tcx
-                        .mk_projection(assoc_item.def_id, cx.tcx.mk_substs_trait(new_ty, []));
+                    let projection = cx.tcx.mk_ty(ty::Alias(
+                        ty::Projection,
+                        projection_predicate.projection_ty.with_self_ty(cx.tcx, new_ty),
+                    ));
 
                     if let Ok(projected_ty) = cx.tcx.try_normalize_erasing_regions(cx.param_env, projection)
                         && substs[term_param_ty.index as usize] != ty::GenericArg::from(projected_ty)
diff --git a/tests/ui/crashes/ice-rust-107877.rs b/tests/ui/crashes/ice-rust-107877.rs
new file mode 100644
index 00000000000..7f5bae60d55
--- /dev/null
+++ b/tests/ui/crashes/ice-rust-107877.rs
@@ -0,0 +1,17 @@
+#![allow(dead_code)]
+
+struct Foo;
+
+impl<'a> std::convert::TryFrom<&'a String> for Foo {
+    type Error = std::convert::Infallible;
+
+    fn try_from(_: &'a String) -> Result<Self, Self::Error> {
+        Ok(Foo)
+    }
+}
+
+fn find<E>(_: impl std::convert::TryInto<Foo, Error = E>) {}
+
+fn main() {
+    find(&String::new());
+}
-- 
cgit 1.4.1-3-g733a5


From 85ad8a6fdcd2b62b04219592966152196b0a98d7 Mon Sep 17 00:00:00 2001
From: Michael Schubart <michael@schubart.net>
Date: Mon, 6 Mar 2023 07:16:36 +0000
Subject: Avoid false positives from extension traits

---
 clippy_lints/src/collection_is_never_read.rs |  6 ++++++
 tests/ui/collection_is_never_read.rs         | 20 ++++++++++++++++++++
 2 files changed, 26 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/collection_is_never_read.rs b/clippy_lints/src/collection_is_never_read.rs
index c0c231bb2c7..10f2bef268a 100644
--- a/clippy_lints/src/collection_is_never_read.rs
+++ b/clippy_lints/src/collection_is_never_read.rs
@@ -98,10 +98,16 @@ fn has_no_read_access<'tcx>(cx: &LateContext<'tcx>, id: HirId, block: &'tcx Bloc
         // Method call on `id` in a statement ignores any return value, so it's not a read access:
         //
         // id.foo(...); // Not reading `id`.
+        //
+        // Only assuming this for "official" methods defined on the type. For methods defined in extension
+        // traits (identified as local, based on the orphan rule), pessimistically assume that they might
+        // have side effects, so consider them a read.
         if let Some(Node::Expr(parent)) = get_parent_node(cx.tcx, expr.hir_id)
             && let ExprKind::MethodCall(_, receiver, _, _) = parent.kind
             && path_to_local_id(receiver, id)
             && let Some(Node::Stmt(..)) = get_parent_node(cx.tcx, parent.hir_id)
+            && let Some(method_def_id) = cx.typeck_results().type_dependent_def_id(parent.hir_id)
+            && !method_def_id.is_local()
         {
             return ControlFlow::Continue(());
         }
diff --git a/tests/ui/collection_is_never_read.rs b/tests/ui/collection_is_never_read.rs
index 8f5ceb06b89..49c72e7eefe 100644
--- a/tests/ui/collection_is_never_read.rs
+++ b/tests/ui/collection_is_never_read.rs
@@ -133,3 +133,23 @@ fn not_read_if_return_value_not_used() {
     let x = vec![1, 2, 3]; // WARNING
     x.is_empty();
 }
+
+fn extension_traits() {
+    trait VecExt<T> {
+        fn method_with_side_effect(&self);
+        fn method_without_side_effect(&self);
+    }
+
+    impl<T> VecExt<T> for Vec<T> {
+        fn method_with_side_effect(&self) {
+            println!("my length: {}", self.len());
+        }
+        fn method_without_side_effect(&self) {}
+    }
+
+    let x = vec![1, 2, 3]; // Ok
+    x.method_with_side_effect();
+
+    let y = vec![1, 2, 3]; // Ok (false negative)
+    y.method_without_side_effect();
+}
-- 
cgit 1.4.1-3-g733a5


From a2906a1598ca16ac080f95658a8a2eae10ff25d5 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Wed, 1 Feb 2023 21:31:09 +0000
Subject: Migrate `write.rs` to `rustc_ast::FormatArgs`

---
 clippy_lints/src/lib.rs    |   1 +
 clippy_lints/src/write.rs  | 158 +++++++++++++++++++++++++++------------------
 clippy_utils/src/macros.rs |  79 ++++++++++++++++++++++-
 3 files changed, 173 insertions(+), 65 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index c626e0bd998..a025e3cc12a 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -870,6 +870,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     let allow_dbg_in_tests = conf.allow_dbg_in_tests;
     store.register_late_pass(move |_| Box::new(dbg_macro::DbgMacro::new(allow_dbg_in_tests)));
     let allow_print_in_tests = conf.allow_print_in_tests;
+    store.register_early_pass(move || Box::new(write::Write::new(allow_print_in_tests)));
     store.register_late_pass(move |_| Box::new(write::Write::new(allow_print_in_tests)));
     let cargo_ignore_publish = conf.cargo_ignore_publish;
     store.register_late_pass(move |_| {
diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs
index df335038881..ce419ec9373 100644
--- a/clippy_lints/src/write.rs
+++ b/clippy_lints/src/write.rs
@@ -1,11 +1,14 @@
 use clippy_utils::diagnostics::{span_lint, span_lint_and_then};
-use clippy_utils::macros::{root_macro_call_first_node, FormatArgsExpn, MacroCall};
+use clippy_utils::macros::{
+    find_format_args, format_arg_removal_span, populate_ast_format_args, root_macro_call_first_node, MacroCall,
+};
 use clippy_utils::source::{expand_past_previous_comma, snippet_opt};
 use clippy_utils::{is_in_cfg_test, is_in_test_function};
-use rustc_ast::LitKind;
+use rustc_ast::token::LitKind;
+use rustc_ast::{FormatArgPosition, FormatArgs, FormatArgsPiece, FormatOptions, FormatPlaceholder, FormatTrait};
 use rustc_errors::Applicability;
-use rustc_hir::{Expr, ExprKind, HirIdMap, Impl, Item, ItemKind};
-use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_hir::{Expr, Impl, Item, ItemKind};
+use rustc_lint::{EarlyLintPass, LateContext, LateLintPass, LintContext};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::{sym, BytePos};
 
@@ -257,6 +260,12 @@ impl_lint_pass!(Write => [
     WRITE_LITERAL,
 ]);
 
+impl EarlyLintPass for Write {
+    fn check_expr(&mut self, _: &rustc_lint::EarlyContext<'_>, expr: &rustc_ast::Expr) {
+        populate_ast_format_args(expr);
+    }
+}
+
 impl<'tcx> LateLintPass<'tcx> for Write {
     fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
         if is_debug_impl(cx, item) {
@@ -297,34 +306,40 @@ impl<'tcx> LateLintPass<'tcx> for Write {
             _ => return,
         }
 
-        let Some(format_args) = FormatArgsExpn::find_nested(cx, expr, macro_call.expn) else { return };
-
-        // ignore `writeln!(w)` and `write!(v, some_macro!())`
-        if format_args.format_string.span.from_expansion() {
-            return;
-        }
+        find_format_args(cx, expr, macro_call.expn, |format_args| {
+            // ignore `writeln!(w)` and `write!(v, some_macro!())`
+            if format_args.span.from_expansion() {
+                return;
+            }
 
-        match diag_name {
-            sym::print_macro | sym::eprint_macro | sym::write_macro => {
-                check_newline(cx, &format_args, &macro_call, name);
-            },
-            sym::println_macro | sym::eprintln_macro | sym::writeln_macro => {
-                check_empty_string(cx, &format_args, &macro_call, name);
-            },
-            _ => {},
-        }
+            match diag_name {
+                sym::print_macro | sym::eprint_macro | sym::write_macro => {
+                    check_newline(cx, format_args, &macro_call, name);
+                },
+                sym::println_macro | sym::eprintln_macro | sym::writeln_macro => {
+                    check_empty_string(cx, format_args, &macro_call, name);
+                },
+                _ => {},
+            }
 
-        check_literal(cx, &format_args, name);
+            check_literal(cx, format_args, name);
 
-        if !self.in_debug_impl {
-            for arg in &format_args.args {
-                if arg.format.r#trait == sym::Debug {
-                    span_lint(cx, USE_DEBUG, arg.span, "use of `Debug`-based formatting");
+            if !self.in_debug_impl {
+                for piece in &format_args.template {
+                    if let &FormatArgsPiece::Placeholder(FormatPlaceholder {
+                        span: Some(span),
+                        format_trait: FormatTrait::Debug,
+                        ..
+                    }) = piece
+                    {
+                        span_lint(cx, USE_DEBUG, span, "use of `Debug`-based formatting");
+                    }
                 }
             }
-        }
+        });
     }
 }
+
 fn is_debug_impl(cx: &LateContext<'_>, item: &Item<'_>) -> bool {
     if let ItemKind::Impl(Impl { of_trait: Some(trait_ref), .. }) = &item.kind
         && let Some(trait_id) = trait_ref.trait_def_id()
@@ -335,16 +350,18 @@ fn is_debug_impl(cx: &LateContext<'_>, item: &Item<'_>) -> bool {
     }
 }
 
-fn check_newline(cx: &LateContext<'_>, format_args: &FormatArgsExpn<'_>, macro_call: &MacroCall, name: &str) {
-    let format_string_parts = &format_args.format_string.parts;
-    let mut format_string_span = format_args.format_string.span;
-
-    let Some(last) = format_string_parts.last() else { return };
+fn check_newline(cx: &LateContext<'_>, format_args: &FormatArgs, macro_call: &MacroCall, name: &str) {
+    let Some(FormatArgsPiece::Literal(last)) = format_args.template.last() else { return };
 
     let count_vertical_whitespace = || {
-        format_string_parts
+        format_args
+            .template
             .iter()
-            .flat_map(|part| part.as_str().chars())
+            .filter_map(|piece| match piece {
+                FormatArgsPiece::Literal(literal) => Some(literal),
+                FormatArgsPiece::Placeholder(_) => None,
+            })
+            .flat_map(|literal| literal.as_str().chars())
             .filter(|ch| matches!(ch, '\r' | '\n'))
             .count()
     };
@@ -352,10 +369,9 @@ fn check_newline(cx: &LateContext<'_>, format_args: &FormatArgsExpn<'_>, macro_c
     if last.as_str().ends_with('\n')
         // ignore format strings with other internal vertical whitespace
         && count_vertical_whitespace() == 1
-
-        // ignore trailing arguments: `print!("Issue\n{}", 1265);`
-        && format_string_parts.len() > format_args.args.len()
     {
+        let mut format_string_span = format_args.span;
+
         let lint = if name == "write" {
             format_string_span = expand_past_previous_comma(cx, format_string_span);
 
@@ -373,7 +389,7 @@ fn check_newline(cx: &LateContext<'_>, format_args: &FormatArgsExpn<'_>, macro_c
                 let name_span = cx.sess().source_map().span_until_char(macro_call.span, '!');
                 let Some(format_snippet) = snippet_opt(cx, format_string_span) else { return };
 
-                if format_string_parts.len() == 1 && last.as_str() == "\n" {
+                if format_args.template.len() == 1 && last.as_str() == "\n" {
                     // print!("\n"), write!(f, "\n")
 
                     diag.multipart_suggestion(
@@ -398,11 +414,12 @@ fn check_newline(cx: &LateContext<'_>, format_args: &FormatArgsExpn<'_>, macro_c
     }
 }
 
-fn check_empty_string(cx: &LateContext<'_>, format_args: &FormatArgsExpn<'_>, macro_call: &MacroCall, name: &str) {
-    if let [part] = &format_args.format_string.parts[..]
-        && let mut span = format_args.format_string.span
-        && part.as_str() == "\n"
+fn check_empty_string(cx: &LateContext<'_>, format_args: &FormatArgs, macro_call: &MacroCall, name: &str) {
+    if let [FormatArgsPiece::Literal(literal)] = &format_args.template[..]
+        && literal.as_str() == "\n"
     {
+        let mut span = format_args.span;
+
         let lint = if name == "writeln" {
             span = expand_past_previous_comma(cx, span);
 
@@ -428,33 +445,43 @@ fn check_empty_string(cx: &LateContext<'_>, format_args: &FormatArgsExpn<'_>, ma
     }
 }
 
-fn check_literal(cx: &LateContext<'_>, format_args: &FormatArgsExpn<'_>, name: &str) {
-    let mut counts = HirIdMap::<usize>::default();
-    for param in format_args.params() {
-        *counts.entry(param.value.hir_id).or_default() += 1;
+fn check_literal(cx: &LateContext<'_>, format_args: &FormatArgs, name: &str) {
+    let arg_index = |argument: &FormatArgPosition| argument.index.unwrap_or_else(|pos| pos);
+
+    let mut counts = vec![0u32; format_args.arguments.all_args().len()];
+    for piece in &format_args.template {
+        if let FormatArgsPiece::Placeholder(placeholder) = piece {
+            counts[arg_index(&placeholder.argument)] += 1;
+        }
     }
 
-    for arg in &format_args.args {
-        let value = arg.param.value;
-
-        if counts[&value.hir_id] == 1
-            && arg.format.is_default()
-            && let ExprKind::Lit(lit) = &value.kind
-            && !value.span.from_expansion()
-            && let Some(value_string) = snippet_opt(cx, value.span)
-        {
-            let (replacement, replace_raw) = match lit.node {
-                LitKind::Str(..) => extract_str_literal(&value_string),
-                LitKind::Char(ch) => (
-                    match ch {
-                        '"' => "\\\"",
-                        '\'' => "'",
+    for piece in &format_args.template {
+        if let FormatArgsPiece::Placeholder(FormatPlaceholder {
+            argument,
+            span: Some(placeholder_span),
+            format_trait: FormatTrait::Display,
+            format_options,
+        }) = piece
+            && *format_options == FormatOptions::default()
+            && let index = arg_index(argument)
+            && counts[index] == 1
+            && let Some(arg) = format_args.arguments.by_index(index)
+            && let rustc_ast::ExprKind::Lit(lit) = &arg.expr.kind
+            && !arg.expr.span.from_expansion()
+            && let Some(value_string) = snippet_opt(cx, arg.expr.span)
+    {
+            let (replacement, replace_raw) = match lit.kind {
+                LitKind::Str | LitKind::StrRaw(_)  => extract_str_literal(&value_string),
+                LitKind::Char => (
+                    match lit.symbol.as_str() {
+                        "\"" => "\\\"",
+                        "\\'" => "'",
                         _ => &value_string[1..value_string.len() - 1],
                     }
                     .to_string(),
                     false,
                 ),
-                LitKind::Bool(b) => (b.to_string(), false),
+                LitKind::Bool => (lit.symbol.to_string(), false),
                 _ => continue,
             };
 
@@ -464,7 +491,9 @@ fn check_literal(cx: &LateContext<'_>, format_args: &FormatArgsExpn<'_>, name: &
                 PRINT_LITERAL
             };
 
-            let format_string_is_raw = format_args.format_string.style.is_some();
+            let Some(format_string_snippet) = snippet_opt(cx, format_args.span) else { continue };
+            let format_string_is_raw = format_string_snippet.starts_with('r');
+
             let replacement = match (format_string_is_raw, replace_raw) {
                 (false, false) => Some(replacement),
                 (false, true) => Some(replacement.replace('"', "\\\"").replace('\\', "\\\\")),
@@ -485,23 +514,24 @@ fn check_literal(cx: &LateContext<'_>, format_args: &FormatArgsExpn<'_>, name: &
             span_lint_and_then(
                 cx,
                 lint,
-                value.span,
+                arg.expr.span,
                 "literal with an empty format string",
                 |diag| {
                     if let Some(replacement) = replacement
                         // `format!("{}", "a")`, `format!("{named}", named = "b")
                         //              ~~~~~                      ~~~~~~~~~~~~~
-                        && let Some(value_span) = format_args.value_with_prev_comma_span(value.hir_id)
+                        && let Some(removal_span) = format_arg_removal_span(format_args, index)
                     {
                         let replacement = replacement.replace('{', "{{").replace('}', "}}");
                         diag.multipart_suggestion(
                             "try this",
-                            vec![(arg.span, replacement), (value_span, String::new())],
+                            vec![(*placeholder_span, replacement), (removal_span, String::new())],
                             Applicability::MachineApplicable,
                         );
                     }
                 },
             );
+
         }
     }
 }
diff --git a/clippy_utils/src/macros.rs b/clippy_utils/src/macros.rs
index be6133d3202..8e0edd72f92 100644
--- a/clippy_utils/src/macros.rs
+++ b/clippy_utils/src/macros.rs
@@ -6,6 +6,8 @@ use crate::visitors::{for_each_expr, Descend};
 use arrayvec::ArrayVec;
 use itertools::{izip, Either, Itertools};
 use rustc_ast::ast::LitKind;
+use rustc_ast::FormatArgs;
+use rustc_data_structures::fx::FxHashMap;
 use rustc_hir::intravisit::{walk_expr, Visitor};
 use rustc_hir::{self as hir, Expr, ExprField, ExprKind, HirId, LangItem, Node, QPath, TyKind};
 use rustc_lexer::unescape::unescape_literal;
@@ -15,8 +17,10 @@ use rustc_parse_format::{self as rpf, Alignment};
 use rustc_span::def_id::DefId;
 use rustc_span::hygiene::{self, MacroKind, SyntaxContext};
 use rustc_span::{sym, BytePos, ExpnData, ExpnId, ExpnKind, Pos, Span, SpanData, Symbol};
+use std::cell::RefCell;
 use std::iter::{once, zip};
-use std::ops::ControlFlow;
+use std::ops::{ControlFlow, Deref};
+use std::sync::atomic::{AtomicBool, Ordering};
 
 const FORMAT_MACRO_DIAG_ITEMS: &[Symbol] = &[
     sym::assert_eq_macro,
@@ -339,6 +343,79 @@ fn is_assert_arg(cx: &LateContext<'_>, expr: &Expr<'_>, assert_expn: ExpnId) ->
     }
 }
 
+thread_local! {
+    /// We preserve the [`FormatArgs`] structs from the early pass for use in the late pass to be
+    /// able to access the many features of a [`LateContext`].
+    ///
+    /// A thread local is used because [`FormatArgs`] is `!Send` and `!Sync`, we are making an
+    /// assumption that the early pass the populates the map and the later late passes will all be
+    /// running on the same thread.
+    static AST_FORMAT_ARGS: RefCell<FxHashMap<Span, FormatArgs>> = {
+        static CALLED: AtomicBool = AtomicBool::new(false);
+        debug_assert!(
+            !CALLED.swap(true, Ordering::SeqCst),
+            "incorrect assumption: `AST_FORMAT_ARGS` should only be accessed by a single thread",
+        );
+
+        RefCell::default()
+    };
+}
+
+/// Record [`rustc_ast::FormatArgs`] for use in late lint passes, this only needs to be called by
+/// one lint pass.
+pub fn populate_ast_format_args(expr: &rustc_ast::Expr) {
+    if let rustc_ast::ExprKind::FormatArgs(args) = &expr.kind {
+        AST_FORMAT_ARGS.with(|ast_format_args| {
+            ast_format_args.borrow_mut().insert(expr.span, args.deref().clone());
+        });
+    }
+}
+
+/// Calls `callback` with an AST [`FormatArgs`] node if one is found
+pub fn find_format_args(cx: &LateContext<'_>, start: &Expr<'_>, expn_id: ExpnId, callback: impl FnOnce(&FormatArgs)) {
+    let format_args_expr = for_each_expr(start, |expr| {
+        let ctxt = expr.span.ctxt();
+        if ctxt == start.span.ctxt() {
+            ControlFlow::Continue(Descend::Yes)
+        } else if ctxt.outer_expn().is_descendant_of(expn_id)
+            && macro_backtrace(expr.span)
+                .map(|macro_call| cx.tcx.item_name(macro_call.def_id))
+                .any(|name| matches!(name, sym::const_format_args | sym::format_args | sym::format_args_nl))
+        {
+            ControlFlow::Break(expr)
+        } else {
+            ControlFlow::Continue(Descend::No)
+        }
+    });
+
+    if let Some(format_args_expr) = format_args_expr {
+        AST_FORMAT_ARGS.with(|ast_format_args| {
+            ast_format_args.borrow().get(&format_args_expr.span).map(callback);
+        });
+    }
+}
+
+/// Returns the [`Span`] of the value at `index` extended to the previous comma, e.g. for the value
+/// `10`
+///
+/// ```ignore
+/// format("{}.{}", 10, 11)
+/// //            ^^^^
+/// ```
+pub fn format_arg_removal_span(format_args: &FormatArgs, index: usize) -> Option<Span> {
+    let ctxt = format_args.span.ctxt();
+
+    let current = hygiene::walk_chain(format_args.arguments.by_index(index)?.expr.span, ctxt);
+
+    let prev = if index == 0 {
+        format_args.span
+    } else {
+        hygiene::walk_chain(format_args.arguments.by_index(index - 1)?.expr.span, ctxt)
+    };
+
+    Some(current.with_lo(prev.hi()))
+}
+
 /// The format string doesn't exist in the HIR, so we reassemble it from source code
 #[derive(Debug)]
 pub struct FormatString {
-- 
cgit 1.4.1-3-g733a5


From dc23e42fb696b1106d44371170a5fb61c1d725c6 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Thu, 2 Feb 2023 15:11:31 +0000
Subject: Add `format_args_collector` internal lint

---
 clippy_lints/src/lib.rs                         |  2 +-
 clippy_lints/src/utils/format_args_collector.rs | 23 +++++++++++++++++++++++
 clippy_lints/src/utils/mod.rs                   |  1 +
 clippy_lints/src/write.rs                       | 12 ++----------
 clippy_utils/src/macros.rs                      | 16 +++++++---------
 5 files changed, 34 insertions(+), 20 deletions(-)
 create mode 100644 clippy_lints/src/utils/format_args_collector.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index a025e3cc12a..f6d14b31fef 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -533,6 +533,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
                 .collect(),
         ))
     });
+    store.register_early_pass(|| Box::new(utils::format_args_collector::FormatArgsCollector));
     store.register_late_pass(|_| Box::new(utils::dump_hir::DumpHir));
     store.register_late_pass(|_| Box::new(utils::author::Author));
     let await_holding_invalid_types = conf.await_holding_invalid_types.clone();
@@ -870,7 +871,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     let allow_dbg_in_tests = conf.allow_dbg_in_tests;
     store.register_late_pass(move |_| Box::new(dbg_macro::DbgMacro::new(allow_dbg_in_tests)));
     let allow_print_in_tests = conf.allow_print_in_tests;
-    store.register_early_pass(move || Box::new(write::Write::new(allow_print_in_tests)));
     store.register_late_pass(move |_| Box::new(write::Write::new(allow_print_in_tests)));
     let cargo_ignore_publish = conf.cargo_ignore_publish;
     store.register_late_pass(move |_| {
diff --git a/clippy_lints/src/utils/format_args_collector.rs b/clippy_lints/src/utils/format_args_collector.rs
new file mode 100644
index 00000000000..be56b842b98
--- /dev/null
+++ b/clippy_lints/src/utils/format_args_collector.rs
@@ -0,0 +1,23 @@
+use clippy_utils::macros::collect_ast_format_args;
+use rustc_ast::{Expr, ExprKind};
+use rustc_lint::{EarlyContext, EarlyLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Collects [`rustc_ast::FormatArgs`] so that future late passes can call
+    /// [`clippy_utils::macros::find_format_args`]
+    pub FORMAT_ARGS_COLLECTOR,
+    internal_warn,
+    "collects `format_args` AST nodes for use in later lints"
+}
+
+declare_lint_pass!(FormatArgsCollector => [FORMAT_ARGS_COLLECTOR]);
+
+impl EarlyLintPass for FormatArgsCollector {
+    fn check_expr(&mut self, _: &EarlyContext<'_>, expr: &Expr) {
+        if let ExprKind::FormatArgs(args) = &expr.kind {
+            collect_ast_format_args(expr.span, args);
+        }
+    }
+}
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index 787e9fd982c..dc647af264c 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -1,5 +1,6 @@
 pub mod author;
 pub mod conf;
 pub mod dump_hir;
+pub mod format_args_collector;
 #[cfg(feature = "internal")]
 pub mod internal_lints;
diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs
index ce419ec9373..8114a8463fa 100644
--- a/clippy_lints/src/write.rs
+++ b/clippy_lints/src/write.rs
@@ -1,14 +1,12 @@
 use clippy_utils::diagnostics::{span_lint, span_lint_and_then};
-use clippy_utils::macros::{
-    find_format_args, format_arg_removal_span, populate_ast_format_args, root_macro_call_first_node, MacroCall,
-};
+use clippy_utils::macros::{find_format_args, format_arg_removal_span, root_macro_call_first_node, MacroCall};
 use clippy_utils::source::{expand_past_previous_comma, snippet_opt};
 use clippy_utils::{is_in_cfg_test, is_in_test_function};
 use rustc_ast::token::LitKind;
 use rustc_ast::{FormatArgPosition, FormatArgs, FormatArgsPiece, FormatOptions, FormatPlaceholder, FormatTrait};
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, Impl, Item, ItemKind};
-use rustc_lint::{EarlyLintPass, LateContext, LateLintPass, LintContext};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::{sym, BytePos};
 
@@ -260,12 +258,6 @@ impl_lint_pass!(Write => [
     WRITE_LITERAL,
 ]);
 
-impl EarlyLintPass for Write {
-    fn check_expr(&mut self, _: &rustc_lint::EarlyContext<'_>, expr: &rustc_ast::Expr) {
-        populate_ast_format_args(expr);
-    }
-}
-
 impl<'tcx> LateLintPass<'tcx> for Write {
     fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
         if is_debug_impl(cx, item) {
diff --git a/clippy_utils/src/macros.rs b/clippy_utils/src/macros.rs
index 8e0edd72f92..ab1c26fb9ad 100644
--- a/clippy_utils/src/macros.rs
+++ b/clippy_utils/src/macros.rs
@@ -19,7 +19,7 @@ use rustc_span::hygiene::{self, MacroKind, SyntaxContext};
 use rustc_span::{sym, BytePos, ExpnData, ExpnId, ExpnKind, Pos, Span, SpanData, Symbol};
 use std::cell::RefCell;
 use std::iter::{once, zip};
-use std::ops::{ControlFlow, Deref};
+use std::ops::ControlFlow;
 use std::sync::atomic::{AtomicBool, Ordering};
 
 const FORMAT_MACRO_DIAG_ITEMS: &[Symbol] = &[
@@ -361,14 +361,12 @@ thread_local! {
     };
 }
 
-/// Record [`rustc_ast::FormatArgs`] for use in late lint passes, this only needs to be called by
-/// one lint pass.
-pub fn populate_ast_format_args(expr: &rustc_ast::Expr) {
-    if let rustc_ast::ExprKind::FormatArgs(args) = &expr.kind {
-        AST_FORMAT_ARGS.with(|ast_format_args| {
-            ast_format_args.borrow_mut().insert(expr.span, args.deref().clone());
-        });
-    }
+/// Record [`rustc_ast::FormatArgs`] for use in late lint passes, this should only be called by
+/// `FormatArgsCollector`
+pub fn collect_ast_format_args(span: Span, format_args: &FormatArgs) {
+    AST_FORMAT_ARGS.with(|ast_format_args| {
+        ast_format_args.borrow_mut().insert(span, format_args.clone());
+    });
 }
 
 /// Calls `callback` with an AST [`FormatArgs`] node if one is found
-- 
cgit 1.4.1-3-g733a5


From 536905278ff2a4fb057193e3592f7f5dc64eb2d7 Mon Sep 17 00:00:00 2001
From: David Mládek <david.mladek.cz@gmail.com>
Date: Thu, 16 Feb 2023 18:11:29 +0100
Subject: Include async functions in the len_without_is_empty

Co-authored-by: Akshay <nerdy@peppe.rs>
---
 clippy_lints/src/len_zero.rs         | 110 +++++++++++++++++++++++++++++------
 tests/ui/len_without_is_empty.rs     |  92 +++++++++++++++++++++++++++++
 tests/ui/len_without_is_empty.stderr |  20 ++++++-
 3 files changed, 202 insertions(+), 20 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/len_zero.rs b/clippy_lints/src/len_zero.rs
index 6c32393dc01..0805b4b1979 100644
--- a/clippy_lints/src/len_zero.rs
+++ b/clippy_lints/src/len_zero.rs
@@ -6,8 +6,9 @@ use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::def_id::DefIdSet;
 use rustc_hir::{
-    def_id::DefId, AssocItemKind, BinOpKind, Expr, ExprKind, FnRetTy, ImplItem, ImplItemKind, ImplicitSelfKind, Item,
-    ItemKind, Mutability, Node, TraitItemRef, TyKind,
+    def::Res, def_id::DefId, lang_items::LangItem, AssocItemKind, BinOpKind, Expr, ExprKind, FnRetTy, GenericArg,
+    GenericBound, ImplItem, ImplItemKind, ImplicitSelfKind, Item, ItemKind, Mutability, Node, PathSegment, PrimTy,
+    QPath, TraitItemRef, TyKind, TypeBindingKind,
 };
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{self, AssocKind, FnSig, Ty};
@@ -250,33 +251,98 @@ fn check_trait_items(cx: &LateContext<'_>, visited_trait: &Item<'_>, trait_items
 }
 
 #[derive(Debug, Clone, Copy)]
-enum LenOutput<'tcx> {
+enum LenOutput {
     Integral,
     Option(DefId),
-    Result(DefId, Ty<'tcx>),
+    Result(DefId),
 }
-fn parse_len_output<'tcx>(cx: &LateContext<'_>, sig: FnSig<'tcx>) -> Option<LenOutput<'tcx>> {
+
+fn extract_future_output<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Option<&'tcx PathSegment<'tcx>> {
+    if let ty::Alias(_, alias_ty) = ty.kind() &&
+        let Some(Node::Item(item)) = cx.tcx.hir().get_if_local(alias_ty.def_id) &&
+        let Item { kind: ItemKind::OpaqueTy(opaque), .. } = item &&
+        opaque.bounds.len() == 1 &&
+        let GenericBound::LangItemTrait(LangItem::Future, _, _, generic_args) = &opaque.bounds[0] &&
+        generic_args.bindings.len() == 1 &&
+        let TypeBindingKind::Equality {
+            term: rustc_hir::Term::Ty(rustc_hir::Ty {kind: TyKind::Path(QPath::Resolved(_, path)), .. }),
+        } = &generic_args.bindings[0].kind &&
+        path.segments.len() == 1 {
+            return Some(&path.segments[0]);
+        }
+
+    None
+}
+
+fn is_first_generic_integral<'tcx>(segment: &'tcx PathSegment<'tcx>) -> bool {
+    if let Some(generic_args) = segment.args {
+        if generic_args.args.is_empty() {
+            return false;
+        }
+        let arg = &generic_args.args[0];
+        if let GenericArg::Type(rustc_hir::Ty {
+            kind: TyKind::Path(QPath::Resolved(_, path)),
+            ..
+        }) = arg
+        {
+            let segments = &path.segments;
+            let segment = &segments[0];
+            let res = &segment.res;
+            if matches!(res, Res::PrimTy(PrimTy::Uint(_))) || matches!(res, Res::PrimTy(PrimTy::Int(_))) {
+                return true;
+            }
+        }
+    }
+
+    false
+}
+
+fn parse_len_output<'tcx>(cx: &LateContext<'tcx>, sig: FnSig<'tcx>) -> Option<LenOutput> {
+    if let Some(segment) = extract_future_output(cx, sig.output()) {
+        let res = segment.res;
+
+        if matches!(res, Res::PrimTy(PrimTy::Uint(_))) || matches!(res, Res::PrimTy(PrimTy::Int(_))) {
+            return Some(LenOutput::Integral);
+        }
+
+        if let Res::Def(_, def_id) = res {
+            if cx.tcx.is_diagnostic_item(sym::Option, def_id) && is_first_generic_integral(segment) {
+                return Some(LenOutput::Option(def_id));
+            } else if cx.tcx.is_diagnostic_item(sym::Result, def_id) && is_first_generic_integral(segment) {
+                return Some(LenOutput::Result(def_id));
+            }
+        }
+
+        return None;
+    }
+
     match *sig.output().kind() {
         ty::Int(_) | ty::Uint(_) => Some(LenOutput::Integral),
         ty::Adt(adt, subs) if cx.tcx.is_diagnostic_item(sym::Option, adt.did()) => {
             subs.type_at(0).is_integral().then(|| LenOutput::Option(adt.did()))
         },
-        ty::Adt(adt, subs) if cx.tcx.is_diagnostic_item(sym::Result, adt.did()) => subs
-            .type_at(0)
-            .is_integral()
-            .then(|| LenOutput::Result(adt.did(), subs.type_at(1))),
+        ty::Adt(adt, subs) if cx.tcx.is_diagnostic_item(sym::Result, adt.did()) => {
+            subs.type_at(0).is_integral().then(|| LenOutput::Result(adt.did()))
+        },
         _ => None,
     }
 }
 
-impl<'tcx> LenOutput<'tcx> {
-    fn matches_is_empty_output(self, ty: Ty<'tcx>) -> bool {
+impl LenOutput {
+    fn matches_is_empty_output<'tcx>(self, cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
+        if let Some(segment) = extract_future_output(cx, ty) {
+            return match (self, segment.res) {
+                (_, Res::PrimTy(PrimTy::Bool)) => true,
+                (Self::Option(_), Res::Def(_, def_id)) if cx.tcx.is_diagnostic_item(sym::Option, def_id) => true,
+                (Self::Result(_), Res::Def(_, def_id)) if cx.tcx.is_diagnostic_item(sym::Result, def_id) => true,
+                _ => false,
+            };
+        }
+
         match (self, ty.kind()) {
             (_, &ty::Bool) => true,
             (Self::Option(id), &ty::Adt(adt, subs)) if id == adt.did() => subs.type_at(0).is_bool(),
-            (Self::Result(id, err_ty), &ty::Adt(adt, subs)) if id == adt.did() => {
-                subs.type_at(0).is_bool() && subs.type_at(1) == err_ty
-            },
+            (Self::Result(id), &ty::Adt(adt, subs)) if id == adt.did() => subs.type_at(0).is_bool(),
             _ => false,
         }
     }
@@ -300,9 +366,14 @@ impl<'tcx> LenOutput<'tcx> {
 }
 
 /// Checks if the given signature matches the expectations for `is_empty`
-fn check_is_empty_sig<'tcx>(sig: FnSig<'tcx>, self_kind: ImplicitSelfKind, len_output: LenOutput<'tcx>) -> bool {
+fn check_is_empty_sig<'tcx>(
+    cx: &LateContext<'tcx>,
+    sig: FnSig<'tcx>,
+    self_kind: ImplicitSelfKind,
+    len_output: LenOutput,
+) -> bool {
     match &**sig.inputs_and_output {
-        [arg, res] if len_output.matches_is_empty_output(*res) => {
+        [arg, res] if len_output.matches_is_empty_output(cx, *res) => {
             matches!(
                 (arg.kind(), self_kind),
                 (ty::Ref(_, _, Mutability::Not), ImplicitSelfKind::ImmRef)
@@ -314,11 +385,11 @@ fn check_is_empty_sig<'tcx>(sig: FnSig<'tcx>, self_kind: ImplicitSelfKind, len_o
 }
 
 /// Checks if the given type has an `is_empty` method with the appropriate signature.
-fn check_for_is_empty<'tcx>(
-    cx: &LateContext<'tcx>,
+fn check_for_is_empty(
+    cx: &LateContext<'_>,
     span: Span,
     self_kind: ImplicitSelfKind,
-    output: LenOutput<'tcx>,
+    output: LenOutput,
     impl_ty: DefId,
     item_name: Symbol,
     item_kind: &str,
@@ -351,6 +422,7 @@ fn check_for_is_empty<'tcx>(
         Some(is_empty)
             if !(is_empty.fn_has_self_parameter
                 && check_is_empty_sig(
+                    cx,
                     cx.tcx.fn_sig(is_empty.def_id).subst_identity().skip_binder(),
                     self_kind,
                     output,
diff --git a/tests/ui/len_without_is_empty.rs b/tests/ui/len_without_is_empty.rs
index b5dec6c46bd..52aabefaed2 100644
--- a/tests/ui/len_without_is_empty.rs
+++ b/tests/ui/len_without_is_empty.rs
@@ -282,6 +282,87 @@ impl AsyncLen {
     }
 }
 
+// issue #7232
+pub struct AsyncLenWithoutIsEmpty;
+impl AsyncLenWithoutIsEmpty {
+    pub async fn async_task(&self) -> bool {
+        true
+    }
+
+    pub async fn len(&self) -> usize {
+        usize::from(!self.async_task().await)
+    }
+}
+
+// issue #7232
+pub struct AsyncOptionLenWithoutIsEmpty;
+impl AsyncOptionLenWithoutIsEmpty {
+    async fn async_task(&self) -> bool {
+        true
+    }
+
+    pub async fn len(&self) -> Option<usize> {
+        None
+    }
+}
+
+// issue #7232
+pub struct AsyncOptionLenNonIntegral;
+impl AsyncOptionLenNonIntegral {
+    // don't lint
+    pub async fn len(&self) -> Option<String> {
+        None
+    }
+}
+
+// issue #7232
+pub struct AsyncResultLenWithoutIsEmpty;
+impl AsyncResultLenWithoutIsEmpty {
+    async fn async_task(&self) -> bool {
+        true
+    }
+
+    pub async fn len(&self) -> Result<usize, ()> {
+        Err(())
+    }
+}
+
+// issue #7232
+pub struct AsyncOptionLen;
+impl AsyncOptionLen {
+    async fn async_task(&self) -> bool {
+        true
+    }
+
+    pub async fn len(&self) -> Result<usize, ()> {
+        Err(())
+    }
+
+    pub async fn is_empty(&self) -> bool {
+        true
+    }
+}
+
+pub struct AsyncLenSyncIsEmpty;
+impl AsyncLenSyncIsEmpty {
+    pub async fn len(&self) -> u32 {
+        0
+    }
+
+    pub fn is_empty(&self) -> bool {
+        true
+    }
+}
+
+// issue #9520
+pub struct NonStandardLen;
+impl NonStandardLen {
+    // don't lint
+    pub fn len(&self, something: usize) -> usize {
+        something
+    }
+}
+
 // issue #9520
 pub struct NonStandardLenAndIsEmptySignature;
 impl NonStandardLenAndIsEmptySignature {
@@ -328,4 +409,15 @@ impl NonStandardSignatureWithGenerics {
     }
 }
 
+pub struct DifferingErrors;
+impl DifferingErrors {
+    pub fn len(&self) -> Result<usize, u8> {
+        Ok(0)
+    }
+
+    pub fn is_empty(&self) -> Result<bool, u16> {
+        Ok(true)
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/len_without_is_empty.stderr b/tests/ui/len_without_is_empty.stderr
index 8e890e2e259..1bce1734b81 100644
--- a/tests/ui/len_without_is_empty.stderr
+++ b/tests/ui/len_without_is_empty.stderr
@@ -119,5 +119,23 @@ LL |     pub fn len(&self) -> Result<usize, ()> {
    |
    = help: use a custom `Error` type instead
 
-error: aborting due to 12 previous errors
+error: struct `AsyncLenWithoutIsEmpty` has a public `len` method, but no `is_empty` method
+  --> $DIR/len_without_is_empty.rs:292:5
+   |
+LL |     pub async fn len(&self) -> usize {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: struct `AsyncOptionLenWithoutIsEmpty` has a public `len` method, but no `is_empty` method
+  --> $DIR/len_without_is_empty.rs:304:5
+   |
+LL |     pub async fn len(&self) -> Option<usize> {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: struct `AsyncResultLenWithoutIsEmpty` has a public `len` method, but no `is_empty` method
+  --> $DIR/len_without_is_empty.rs:325:5
+   |
+LL |     pub async fn len(&self) -> Result<usize, ()> {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 15 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From ea2547b8c63ce4e410c53e7fa55b127c81721454 Mon Sep 17 00:00:00 2001
From: Burak Varlı <burakvar@amazon.co.uk>
Date: Thu, 16 Feb 2023 14:50:51 +0000
Subject: Add `missing_assert_message` lint

Co-authored-by: Weihang Lo <me@weihanglo.tw>
---
 CHANGELOG.md                               |   1 +
 clippy_lints/src/declared_lints.rs         |   1 +
 clippy_lints/src/lib.rs                    |   2 +
 clippy_lints/src/missing_assert_message.rs | 123 +++++++++++++++++++++++++++++
 tests/ui/filter_map_next_fixable.fixed     |   2 +-
 tests/ui/filter_map_next_fixable.rs        |   2 +-
 tests/ui/missing_assert_message.rs         |  84 ++++++++++++++++++++
 tests/ui/missing_assert_message.stderr     | 100 +++++++++++++++++++++++
 8 files changed, 313 insertions(+), 2 deletions(-)
 create mode 100644 clippy_lints/src/missing_assert_message.rs
 create mode 100644 tests/ui/missing_assert_message.rs
 create mode 100644 tests/ui/missing_assert_message.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9508ab57cb8..62cc7437b82 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4706,6 +4706,7 @@ Released 2018-09-13
 [`mismatching_type_param_order`]: https://rust-lang.github.io/rust-clippy/master/index.html#mismatching_type_param_order
 [`misnamed_getters`]: https://rust-lang.github.io/rust-clippy/master/index.html#misnamed_getters
 [`misrefactored_assign_op`]: https://rust-lang.github.io/rust-clippy/master/index.html#misrefactored_assign_op
+[`missing_assert_message`]: https://rust-lang.github.io/rust-clippy/master/index.html#missing_assert_message
 [`missing_const_for_fn`]: https://rust-lang.github.io/rust-clippy/master/index.html#missing_const_for_fn
 [`missing_docs_in_private_items`]: https://rust-lang.github.io/rust-clippy/master/index.html#missing_docs_in_private_items
 [`missing_enforced_import_renames`]: https://rust-lang.github.io/rust-clippy/master/index.html#missing_enforced_import_renames
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 470a2e79e47..462fcb6483d 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -417,6 +417,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::misc_early::UNSEPARATED_LITERAL_SUFFIX_INFO,
     crate::misc_early::ZERO_PREFIXED_LITERAL_INFO,
     crate::mismatching_type_param_order::MISMATCHING_TYPE_PARAM_ORDER_INFO,
+    crate::missing_assert_message::MISSING_ASSERT_MESSAGE_INFO,
     crate::missing_const_for_fn::MISSING_CONST_FOR_FN_INFO,
     crate::missing_doc::MISSING_DOCS_IN_PRIVATE_ITEMS_INFO,
     crate::missing_enforced_import_rename::MISSING_ENFORCED_IMPORT_RENAMES_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index ae7fdd6be26..fe0229a814f 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -193,6 +193,7 @@ mod minmax;
 mod misc;
 mod misc_early;
 mod mismatching_type_param_order;
+mod missing_assert_message;
 mod missing_const_for_fn;
 mod missing_doc;
 mod missing_enforced_import_rename;
@@ -926,6 +927,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     });
     store.register_late_pass(|_| Box::new(no_mangle_with_rust_abi::NoMangleWithRustAbi));
     store.register_late_pass(|_| Box::new(collection_is_never_read::CollectionIsNeverRead));
+    store.register_pre_expansion_pass(|| Box::new(missing_assert_message::MissingAssertMessage));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/missing_assert_message.rs b/clippy_lints/src/missing_assert_message.rs
new file mode 100644
index 00000000000..a884b22370d
--- /dev/null
+++ b/clippy_lints/src/missing_assert_message.rs
@@ -0,0 +1,123 @@
+use clippy_utils::diagnostics::span_lint;
+use rustc_ast::ast;
+use rustc_ast::{
+    token::{Token, TokenKind},
+    tokenstream::TokenTree,
+};
+use rustc_lint::{EarlyContext, EarlyLintPass};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::sym;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks assertions that doesn't have a custom panic message.
+    ///
+    /// ### Why is this bad?
+    /// If the assertion fails, a custom message may make it easier to debug what went wrong.
+    ///
+    /// ### Example
+    /// ```rust
+    /// let threshold = 50;
+    /// let num = 42;
+    /// assert!(num < threshold);
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// let threshold = 50;
+    /// let num = 42;
+    /// assert!(num < threshold, "{num} is lower than threshold ({threshold})");
+    /// ```
+    #[clippy::version = "1.69.0"]
+    pub MISSING_ASSERT_MESSAGE,
+    pedantic,
+    "checks assertions that doesn't have a custom panic message"
+}
+
+#[derive(Default, Clone, Debug)]
+pub struct MissingAssertMessage {
+    // This field will be greater than zero if we are inside a `#[test]` or `#[cfg(test)]`
+    test_deepnes: usize,
+}
+
+impl_lint_pass!(MissingAssertMessage => [MISSING_ASSERT_MESSAGE]);
+
+impl EarlyLintPass for MissingAssertMessage {
+    fn check_mac(&mut self, cx: &EarlyContext<'_>, mac_call: &ast::MacCall) {
+        if self.test_deepnes != 0 {
+            return;
+        }
+
+        let Some(last_segment) = mac_call.path.segments.last() else { return; };
+        let num_separators_needed = match last_segment.ident.as_str() {
+            "assert" | "debug_assert" => 1,
+            "assert_eq" | "assert_ne" | "debug_assert_eq" | "debug_assert_ne" => 2,
+            _ => return,
+        };
+        let num_separators = num_commas_on_arguments(mac_call);
+
+        if num_separators < num_separators_needed {
+            span_lint(
+                cx,
+                MISSING_ASSERT_MESSAGE,
+                mac_call.span(),
+                "assert without any message",
+            );
+        }
+    }
+
+    fn check_item(&mut self, _: &EarlyContext<'_>, item: &ast::Item) {
+        if item.attrs.iter().any(is_a_test_attribute) {
+            self.test_deepnes += 1;
+        }
+    }
+
+    fn check_item_post(&mut self, _: &EarlyContext<'_>, item: &ast::Item) {
+        if item.attrs.iter().any(is_a_test_attribute) {
+            self.test_deepnes -= 1;
+        }
+    }
+}
+
+// Returns number of commas (excluding trailing comma) from `MacCall`'s arguments.
+fn num_commas_on_arguments(mac_call: &ast::MacCall) -> usize {
+    let mut num_separators = 0;
+    let mut is_trailing = false;
+    for tt in mac_call.args.tokens.trees() {
+        match tt {
+            TokenTree::Token(
+                Token {
+                    kind: TokenKind::Comma,
+                    span: _,
+                },
+                _,
+            ) => {
+                num_separators += 1;
+                is_trailing = true;
+            },
+            _ => {
+                is_trailing = false;
+            },
+        }
+    }
+    if is_trailing {
+        num_separators -= 1;
+    }
+    num_separators
+}
+
+// Returns true if the attribute is either a `#[test]` or a `#[cfg(test)]`.
+fn is_a_test_attribute(attr: &ast::Attribute) -> bool {
+    if attr.has_name(sym::test) {
+        return true;
+    }
+
+    if attr.has_name(sym::cfg)
+        && let Some(items) = attr.meta_item_list()
+        && let [item] = &*items
+        && item.has_name(sym::test)
+    {
+        true
+    } else {
+        false
+    }
+}
diff --git a/tests/ui/filter_map_next_fixable.fixed b/tests/ui/filter_map_next_fixable.fixed
index 462d46169fc..0568eff41b5 100644
--- a/tests/ui/filter_map_next_fixable.fixed
+++ b/tests/ui/filter_map_next_fixable.fixed
@@ -1,7 +1,7 @@
 // run-rustfix
 
 #![warn(clippy::all, clippy::pedantic)]
-#![allow(unused)]
+#![allow(unused, clippy::missing_assert_message)]
 
 fn main() {
     let a = ["1", "lol", "3", "NaN", "5"];
diff --git a/tests/ui/filter_map_next_fixable.rs b/tests/ui/filter_map_next_fixable.rs
index 2ea00cf7307..b0722ee8258 100644
--- a/tests/ui/filter_map_next_fixable.rs
+++ b/tests/ui/filter_map_next_fixable.rs
@@ -1,7 +1,7 @@
 // run-rustfix
 
 #![warn(clippy::all, clippy::pedantic)]
-#![allow(unused)]
+#![allow(unused, clippy::missing_assert_message)]
 
 fn main() {
     let a = ["1", "lol", "3", "NaN", "5"];
diff --git a/tests/ui/missing_assert_message.rs b/tests/ui/missing_assert_message.rs
new file mode 100644
index 00000000000..89404ca8827
--- /dev/null
+++ b/tests/ui/missing_assert_message.rs
@@ -0,0 +1,84 @@
+#![allow(unused)]
+#![warn(clippy::missing_assert_message)]
+
+macro_rules! bar {
+    ($( $x:expr ),*) => {
+        foo()
+    };
+}
+
+fn main() {}
+
+// Should trigger warning
+fn asserts_without_message() {
+    assert!(foo());
+    assert_eq!(foo(), foo());
+    assert_ne!(foo(), foo());
+    debug_assert!(foo());
+    debug_assert_eq!(foo(), foo());
+    debug_assert_ne!(foo(), foo());
+}
+
+// Should trigger warning
+fn asserts_without_message_but_with_macro_calls() {
+    assert!(bar!(true));
+    assert!(bar!(true, false));
+    assert_eq!(bar!(true), foo());
+    assert_ne!(bar!(true, true), bar!(true));
+}
+
+// Should trigger warning
+fn asserts_with_trailing_commas() {
+    assert!(foo(),);
+    assert_eq!(foo(), foo(),);
+    assert_ne!(foo(), foo(),);
+    debug_assert!(foo(),);
+    debug_assert_eq!(foo(), foo(),);
+    debug_assert_ne!(foo(), foo(),);
+}
+
+// Should not trigger warning
+fn asserts_with_message_and_with_macro_calls() {
+    assert!(bar!(true), "msg");
+    assert!(bar!(true, false), "msg");
+    assert_eq!(bar!(true), foo(), "msg");
+    assert_ne!(bar!(true, true), bar!(true), "msg");
+}
+
+// Should not trigger warning
+fn asserts_with_message() {
+    assert!(foo(), "msg");
+    assert_eq!(foo(), foo(), "msg");
+    assert_ne!(foo(), foo(), "msg");
+    debug_assert!(foo(), "msg");
+    debug_assert_eq!(foo(), foo(), "msg");
+    debug_assert_ne!(foo(), foo(), "msg");
+}
+
+// Should not trigger warning
+#[test]
+fn asserts_without_message_but_inside_a_test_function() {
+    assert!(foo());
+    assert_eq!(foo(), foo());
+    assert_ne!(foo(), foo());
+    debug_assert!(foo());
+    debug_assert_eq!(foo(), foo());
+    debug_assert_ne!(foo(), foo());
+}
+
+// Should not trigger warning
+#[cfg(test)]
+mod tests {
+    fn asserts_without_message_but_inside_a_test_module() {
+        assert!(foo());
+        assert_eq!(foo(), foo());
+        assert_ne!(foo(), foo());
+        debug_assert!(foo());
+        debug_assert_eq!(foo(), foo());
+        debug_assert_ne!(foo(), foo());
+    }
+}
+
+fn foo() -> bool {
+    true
+}
diff --git a/tests/ui/missing_assert_message.stderr b/tests/ui/missing_assert_message.stderr
new file mode 100644
index 00000000000..900966500c8
--- /dev/null
+++ b/tests/ui/missing_assert_message.stderr
@@ -0,0 +1,100 @@
+error: assert without any message
+  --> $DIR/missing_assert_message.rs:14:5
+   |
+LL |     assert!(foo());
+   |     ^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::missing-assert-message` implied by `-D warnings`
+
+error: assert without any message
+  --> $DIR/missing_assert_message.rs:15:5
+   |
+LL |     assert_eq!(foo(), foo());
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: assert without any message
+  --> $DIR/missing_assert_message.rs:16:5
+   |
+LL |     assert_ne!(foo(), foo());
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: assert without any message
+  --> $DIR/missing_assert_message.rs:17:5
+   |
+LL |     debug_assert!(foo());
+   |     ^^^^^^^^^^^^^^^^^^^^
+
+error: assert without any message
+  --> $DIR/missing_assert_message.rs:18:5
+   |
+LL |     debug_assert_eq!(foo(), foo());
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: assert without any message
+  --> $DIR/missing_assert_message.rs:19:5
+   |
+LL |     debug_assert_ne!(foo(), foo());
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: assert without any message
+  --> $DIR/missing_assert_message.rs:24:5
+   |
+LL |     assert!(bar!(true));
+   |     ^^^^^^^^^^^^^^^^^^^
+
+error: assert without any message
+  --> $DIR/missing_assert_message.rs:25:5
+   |
+LL |     assert!(bar!(true, false));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: assert without any message
+  --> $DIR/missing_assert_message.rs:26:5
+   |
+LL |     assert_eq!(bar!(true), foo());
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: assert without any message
+  --> $DIR/missing_assert_message.rs:27:5
+   |
+LL |     assert_ne!(bar!(true, true), bar!(true));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: assert without any message
+  --> $DIR/missing_assert_message.rs:32:5
+   |
+LL |     assert!(foo(),);
+   |     ^^^^^^^^^^^^^^^
+
+error: assert without any message
+  --> $DIR/missing_assert_message.rs:33:5
+   |
+LL |     assert_eq!(foo(), foo(),);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: assert without any message
+  --> $DIR/missing_assert_message.rs:34:5
+   |
+LL |     assert_ne!(foo(), foo(),);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: assert without any message
+  --> $DIR/missing_assert_message.rs:35:5
+   |
+LL |     debug_assert!(foo(),);
+   |     ^^^^^^^^^^^^^^^^^^^^^
+
+error: assert without any message
+  --> $DIR/missing_assert_message.rs:36:5
+   |
+LL |     debug_assert_eq!(foo(), foo(),);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: assert without any message
+  --> $DIR/missing_assert_message.rs:37:5
+   |
+LL |     debug_assert_ne!(foo(), foo(),);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 16 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 8f3ac65227b4744924fef56d13de991acc04395b Mon Sep 17 00:00:00 2001
From: Burak Varlı <burakvar@amazon.co.uk>
Date: Thu, 16 Feb 2023 16:58:51 +0000
Subject: Dogfood `missing_assert_message` on Clippy

Co-authored-by: Weihang Lo <me@weihanglo.tw>
---
 clippy_lints/src/doc.rs                  |  2 +-
 clippy_lints/src/duplicate_mod.rs        |  6 +++++-
 clippy_lints/src/enum_variants.rs        |  2 +-
 clippy_lints/src/lib.rs                  |  2 +-
 clippy_lints/src/non_expressive_names.rs |  5 ++++-
 clippy_utils/src/attrs.rs                |  6 ++++--
 clippy_utils/src/lib.rs                  | 11 +++++++----
 clippy_utils/src/numeric_literal.rs      |  6 +++---
 clippy_utils/src/ty.rs                   |  3 +--
 lintcheck/src/main.rs                    |  3 ++-
 tests/compile-test.rs                    |  5 ++++-
 tests/integration.rs                     |  1 +
 tests/test_utils/mod.rs                  |  2 +-
 13 files changed, 35 insertions(+), 19 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/doc.rs b/clippy_lints/src/doc.rs
index 384aca7fead..b1c2a51daa0 100644
--- a/clippy_lints/src/doc.rs
+++ b/clippy_lints/src/doc.rs
@@ -467,7 +467,7 @@ pub fn strip_doc_comment_decoration(doc: &str, comment_kind: CommentKind, span:
     let mut contains_initial_stars = false;
     for line in doc.lines() {
         let offset = line.as_ptr() as usize - doc.as_ptr() as usize;
-        debug_assert_eq!(offset as u32 as usize, offset);
+        debug_assert_eq!(offset as u32 as usize, offset, "`offset` shouldn't overflow `u32`");
         contains_initial_stars |= line.trim_start().starts_with('*');
         // +1 adds the newline, +3 skips the opening delimiter
         sizes.push((line.len() + 1, span.with_lo(span.lo() + BytePos(3 + offset as u32))));
diff --git a/clippy_lints/src/duplicate_mod.rs b/clippy_lints/src/duplicate_mod.rs
index 7ff7068f0b0..9135af40979 100644
--- a/clippy_lints/src/duplicate_mod.rs
+++ b/clippy_lints/src/duplicate_mod.rs
@@ -90,7 +90,11 @@ impl EarlyLintPass for DuplicateMod {
             }
 
             // At this point the lint would be emitted
-            assert_eq!(spans.len(), lint_levels.len());
+            assert_eq!(
+                spans.len(),
+                lint_levels.len(),
+                "`spans` and `lint_levels` should have equal lengths"
+            );
             let spans: Vec<_> = spans
                 .iter()
                 .zip(lint_levels)
diff --git a/clippy_lints/src/enum_variants.rs b/clippy_lints/src/enum_variants.rs
index 4c69dacf381..68fb88bcf7e 100644
--- a/clippy_lints/src/enum_variants.rs
+++ b/clippy_lints/src/enum_variants.rs
@@ -242,7 +242,7 @@ fn to_camel_case(item_name: &str) -> String {
 impl LateLintPass<'_> for EnumVariantNames {
     fn check_item_post(&mut self, _cx: &LateContext<'_>, _item: &Item<'_>) {
         let last = self.modules.pop();
-        assert!(last.is_some());
+        assert!(last.is_some(), "`modules` should not be empty");
     }
 
     #[expect(clippy::similar_names)]
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index fe0229a814f..e3be798f30b 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -927,7 +927,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     });
     store.register_late_pass(|_| Box::new(no_mangle_with_rust_abi::NoMangleWithRustAbi));
     store.register_late_pass(|_| Box::new(collection_is_never_read::CollectionIsNeverRead));
-    store.register_pre_expansion_pass(|| Box::new(missing_assert_message::MissingAssertMessage));
+    store.register_pre_expansion_pass(|| Box::<missing_assert_message::MissingAssertMessage>::default());
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/non_expressive_names.rs b/clippy_lints/src/non_expressive_names.rs
index 9f6917c146f..e24f3aa567a 100644
--- a/clippy_lints/src/non_expressive_names.rs
+++ b/clippy_lints/src/non_expressive_names.rs
@@ -408,7 +408,10 @@ fn do_check(lint: &mut NonExpressiveNames, cx: &EarlyContext<'_>, attrs: &[Attri
 /// Precondition: `a_name.chars().count() < b_name.chars().count()`.
 #[must_use]
 fn levenstein_not_1(a_name: &str, b_name: &str) -> bool {
-    debug_assert!(a_name.chars().count() < b_name.chars().count());
+    debug_assert!(
+        a_name.chars().count() < b_name.chars().count(),
+        "Precondition: `a_name.chars().count() < b_name.chars().count()` does not meet"
+    );
     let mut a_chars = a_name.chars();
     let mut b_chars = b_name.chars();
     while let (Some(a), Some(b)) = (a_chars.next(), b_chars.next()) {
diff --git a/clippy_utils/src/attrs.rs b/clippy_utils/src/attrs.rs
index 7987a233bdc..75f7b5cf98e 100644
--- a/clippy_utils/src/attrs.rs
+++ b/clippy_utils/src/attrs.rs
@@ -31,7 +31,7 @@ pub struct LimitStack {
 
 impl Drop for LimitStack {
     fn drop(&mut self) {
-        assert_eq!(self.stack.len(), 1);
+        assert_eq!(self.stack.len(), 1, "stack should only have one element");
     }
 }
 
@@ -49,7 +49,9 @@ impl LimitStack {
     }
     pub fn pop_attrs(&mut self, sess: &Session, attrs: &[ast::Attribute], name: &'static str) {
         let stack = &mut self.stack;
-        parse_attrs(sess, attrs, name, |val| assert_eq!(stack.pop(), Some(val)));
+        parse_attrs(sess, attrs, name, |val| {
+            assert_eq!(stack.pop(), Some(val), "incorrect last element");
+        });
     }
 }
 
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 213e5b33503..1c453b87f8d 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -1011,10 +1011,13 @@ pub fn capture_local_usage(cx: &LateContext<'_>, e: &Expr<'_>) -> CaptureKind {
         capture
     }
 
-    debug_assert!(matches!(
-        e.kind,
-        ExprKind::Path(QPath::Resolved(None, Path { res: Res::Local(_), .. }))
-    ));
+    debug_assert!(
+        matches!(
+            e.kind,
+            ExprKind::Path(QPath::Resolved(None, Path { res: Res::Local(_), .. }))
+        ),
+        "`e.kind` should be a resolved local path"
+    );
 
     let mut child_id = e.hir_id;
     let mut capture = CaptureKind::Value;
diff --git a/clippy_utils/src/numeric_literal.rs b/clippy_utils/src/numeric_literal.rs
index c225398ad2a..7d8f31e1dfb 100644
--- a/clippy_utils/src/numeric_literal.rs
+++ b/clippy_utils/src/numeric_literal.rs
@@ -179,7 +179,7 @@ impl<'a> NumericLiteral<'a> {
     }
 
     pub fn group_digits(output: &mut String, input: &str, group_size: usize, partial_group_first: bool, pad: bool) {
-        debug_assert!(group_size > 0);
+        debug_assert!(group_size > 0, "group size should be greater than zero");
 
         let mut digits = input.chars().filter(|&c| c != '_');
 
@@ -219,7 +219,7 @@ impl<'a> NumericLiteral<'a> {
 }
 
 fn split_suffix<'a>(src: &'a str, lit_kind: &LitKind) -> (&'a str, Option<&'a str>) {
-    debug_assert!(lit_kind.is_numeric());
+    debug_assert!(lit_kind.is_numeric(), "`lit_kind` should be numeric");
     lit_suffix_length(lit_kind)
         .and_then(|suffix_length| src.len().checked_sub(suffix_length))
         .map_or((src, None), |split_pos| {
@@ -229,7 +229,7 @@ fn split_suffix<'a>(src: &'a str, lit_kind: &LitKind) -> (&'a str, Option<&'a st
 }
 
 fn lit_suffix_length(lit_kind: &LitKind) -> Option<usize> {
-    debug_assert!(lit_kind.is_numeric());
+    debug_assert!(lit_kind.is_numeric(), "`lit_kind` should be numeric");
     let suffix = match lit_kind {
         LitKind::Int(_, int_lit_kind) => match int_lit_kind {
             LitIntType::Signed(int_ty) => Some(int_ty.name_str()),
diff --git a/clippy_utils/src/ty.rs b/clippy_utils/src/ty.rs
index 7cbb77ea2a8..2b3c781477f 100644
--- a/clippy_utils/src/ty.rs
+++ b/clippy_utils/src/ty.rs
@@ -225,8 +225,7 @@ pub fn implements_trait_with_env<'tcx>(
     trait_id: DefId,
     ty_params: impl IntoIterator<Item = Option<GenericArg<'tcx>>>,
 ) -> bool {
-    // Clippy shouldn't have infer types
-    assert!(!ty.needs_infer());
+    assert!(!ty.needs_infer(), "Clippy shouldn't have infer types");
 
     let ty = tcx.erase_regions(ty);
     if ty.has_escaping_bound_vars() {
diff --git a/lintcheck/src/main.rs b/lintcheck/src/main.rs
index 23c85298027..6e39c8d4243 100644
--- a/lintcheck/src/main.rs
+++ b/lintcheck/src/main.rs
@@ -383,7 +383,7 @@ impl Crate {
                 .status()
                 .expect("failed to run cargo");
 
-            assert_eq!(status.code(), Some(0));
+            assert_eq!(status.code(), Some(0), "`cargo check` exited with non-zero code");
 
             return Vec::new();
         }
@@ -741,6 +741,7 @@ fn print_stats(old_stats: HashMap<String, usize>, new_stats: HashMap<&String, us
     let mut new_stats_deduped = new_stats;
 
     // remove duplicates from both hashmaps
+    #[allow(clippy::missing_assert_message)]
     for (k, v) in &same_in_both_hashmaps {
         assert!(old_stats_deduped.remove(k) == Some(*v));
         assert!(new_stats_deduped.remove(k) == Some(*v));
diff --git a/tests/compile-test.rs b/tests/compile-test.rs
index c10ee969c01..2f2d305f54b 100644
--- a/tests/compile-test.rs
+++ b/tests/compile-test.rs
@@ -410,7 +410,10 @@ fn check_rustfix_coverage() {
     };
 
     if let Ok(missing_coverage_contents) = std::fs::read_to_string(missing_coverage_path) {
-        assert!(RUSTFIX_COVERAGE_KNOWN_EXCEPTIONS.iter().is_sorted_by_key(Path::new));
+        assert!(
+            RUSTFIX_COVERAGE_KNOWN_EXCEPTIONS.iter().is_sorted_by_key(Path::new),
+            "`RUSTFIX_COVERAGE_KNOWN_EXCEPTIONS` should be sorted"
+        );
 
         for rs_file in missing_coverage_contents.lines() {
             let rs_path = Path::new(rs_file);
diff --git a/tests/integration.rs b/tests/integration.rs
index a771d8b87c8..2d2d6e6739e 100644
--- a/tests/integration.rs
+++ b/tests/integration.rs
@@ -21,6 +21,7 @@ const CARGO_CLIPPY: &str = "cargo-clippy";
 const CARGO_CLIPPY: &str = "cargo-clippy.exe";
 
 #[cfg_attr(feature = "integration", test)]
+#[allow(clippy::missing_assert_message)]
 fn integration_test() {
     let repo_name = env::var("INTEGRATION").expect("`INTEGRATION` var not set");
     let repo_url = format!("https://github.com/{repo_name}");
diff --git a/tests/test_utils/mod.rs b/tests/test_utils/mod.rs
index ea8c54e08b3..3081bf2d8cc 100644
--- a/tests/test_utils/mod.rs
+++ b/tests/test_utils/mod.rs
@@ -5,7 +5,7 @@ use std::sync::LazyLock;
 
 pub static CARGO_CLIPPY_PATH: LazyLock<PathBuf> = LazyLock::new(|| {
     let mut path = std::env::current_exe().unwrap();
-    assert!(path.pop()); // deps
+    assert!(path.pop(), "current running executable path shouldn't be empty"); // deps
     path.set_file_name("cargo-clippy");
     path
 });
-- 
cgit 1.4.1-3-g733a5


From 099d610640a5ab35a25218af6cedfc4ece765aa0 Mon Sep 17 00:00:00 2001
From: Burak <unexge@gmail.com>
Date: Sat, 18 Feb 2023 18:40:33 +0100
Subject: Apply suggestions from code review

Co-authored-by: llogiq <bogusandre@gmail.com>
---
 clippy_lints/src/missing_assert_message.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/missing_assert_message.rs b/clippy_lints/src/missing_assert_message.rs
index a884b22370d..07424eb46a4 100644
--- a/clippy_lints/src/missing_assert_message.rs
+++ b/clippy_lints/src/missing_assert_message.rs
@@ -10,10 +10,10 @@ use rustc_span::sym;
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks assertions that doesn't have a custom panic message.
+    /// Checks assertions without a custom panic message.
     ///
     /// ### Why is this bad?
-    /// If the assertion fails, a custom message may make it easier to debug what went wrong.
+    /// If the assertion fails, the custom message may make it easier to understand what went wrong.
     ///
     /// ### Example
     /// ```rust
@@ -30,7 +30,7 @@ declare_clippy_lint! {
     #[clippy::version = "1.69.0"]
     pub MISSING_ASSERT_MESSAGE,
     pedantic,
-    "checks assertions that doesn't have a custom panic message"
+    "checks assertions without a custom panic message"
 }
 
 #[derive(Default, Clone, Debug)]
-- 
cgit 1.4.1-3-g733a5


From 4eb6ccc9731095ed014bd5c047bcd7dd75bdf335 Mon Sep 17 00:00:00 2001
From: unexge <unexge@gmail.com>
Date: Sat, 18 Feb 2023 19:09:31 +0000
Subject: Update lint description and add help section

Co-authored-by: Weihang Lo <me@weihanglo.tw>
---
 clippy_lints/src/missing_assert_message.rs | 24 ++++++++++++++---------
 tests/ui/missing_assert_message.stderr     | 31 ++++++++++++++++++++++++++++++
 2 files changed, 46 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/missing_assert_message.rs b/clippy_lints/src/missing_assert_message.rs
index 07424eb46a4..3b73332215e 100644
--- a/clippy_lints/src/missing_assert_message.rs
+++ b/clippy_lints/src/missing_assert_message.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint;
+use clippy_utils::diagnostics::span_lint_and_help;
 use rustc_ast::ast;
 use rustc_ast::{
     token::{Token, TokenKind},
@@ -13,19 +13,23 @@ declare_clippy_lint! {
     /// Checks assertions without a custom panic message.
     ///
     /// ### Why is this bad?
-    /// If the assertion fails, the custom message may make it easier to understand what went wrong.
+    /// Without a good custom message, it'd be hard to understand what went wrong when the assertion fails.
+    /// A good custom message should be more about why the failure of the assertion is problematic
+    /// and not what is failed because the assertion already conveys that.
     ///
     /// ### Example
     /// ```rust
-    /// let threshold = 50;
-    /// let num = 42;
-    /// assert!(num < threshold);
+    /// # struct Service { ready: bool }
+    /// fn call(service: Service) {
+    ///     assert!(service.ready);
+    /// }
     /// ```
     /// Use instead:
     /// ```rust
-    /// let threshold = 50;
-    /// let num = 42;
-    /// assert!(num < threshold, "{num} is lower than threshold ({threshold})");
+    /// # struct Service { ready: bool }
+    /// fn call(service: Service) {
+    ///     assert!(service.ready, "`service.poll_ready()` must be called first to ensure that service is ready to receive requests");
+    /// }
     /// ```
     #[clippy::version = "1.69.0"]
     pub MISSING_ASSERT_MESSAGE,
@@ -56,11 +60,13 @@ impl EarlyLintPass for MissingAssertMessage {
         let num_separators = num_commas_on_arguments(mac_call);
 
         if num_separators < num_separators_needed {
-            span_lint(
+            span_lint_and_help(
                 cx,
                 MISSING_ASSERT_MESSAGE,
                 mac_call.span(),
                 "assert without any message",
+                None,
+                "consider describing why the failing assert is problematic",
             );
         }
     }
diff --git a/tests/ui/missing_assert_message.stderr b/tests/ui/missing_assert_message.stderr
index 900966500c8..ecd03801277 100644
--- a/tests/ui/missing_assert_message.stderr
+++ b/tests/ui/missing_assert_message.stderr
@@ -4,6 +4,7 @@ error: assert without any message
 LL |     assert!(foo());
    |     ^^^^^^^^^^^^^^
    |
+   = help: consider describing why the failing assert is problematic
    = note: `-D clippy::missing-assert-message` implied by `-D warnings`
 
 error: assert without any message
@@ -11,90 +12,120 @@ error: assert without any message
    |
 LL |     assert_eq!(foo(), foo());
    |     ^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider describing why the failing assert is problematic
 
 error: assert without any message
   --> $DIR/missing_assert_message.rs:16:5
    |
 LL |     assert_ne!(foo(), foo());
    |     ^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider describing why the failing assert is problematic
 
 error: assert without any message
   --> $DIR/missing_assert_message.rs:17:5
    |
 LL |     debug_assert!(foo());
    |     ^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider describing why the failing assert is problematic
 
 error: assert without any message
   --> $DIR/missing_assert_message.rs:18:5
    |
 LL |     debug_assert_eq!(foo(), foo());
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider describing why the failing assert is problematic
 
 error: assert without any message
   --> $DIR/missing_assert_message.rs:19:5
    |
 LL |     debug_assert_ne!(foo(), foo());
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider describing why the failing assert is problematic
 
 error: assert without any message
   --> $DIR/missing_assert_message.rs:24:5
    |
 LL |     assert!(bar!(true));
    |     ^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider describing why the failing assert is problematic
 
 error: assert without any message
   --> $DIR/missing_assert_message.rs:25:5
    |
 LL |     assert!(bar!(true, false));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider describing why the failing assert is problematic
 
 error: assert without any message
   --> $DIR/missing_assert_message.rs:26:5
    |
 LL |     assert_eq!(bar!(true), foo());
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider describing why the failing assert is problematic
 
 error: assert without any message
   --> $DIR/missing_assert_message.rs:27:5
    |
 LL |     assert_ne!(bar!(true, true), bar!(true));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider describing why the failing assert is problematic
 
 error: assert without any message
   --> $DIR/missing_assert_message.rs:32:5
    |
 LL |     assert!(foo(),);
    |     ^^^^^^^^^^^^^^^
+   |
+   = help: consider describing why the failing assert is problematic
 
 error: assert without any message
   --> $DIR/missing_assert_message.rs:33:5
    |
 LL |     assert_eq!(foo(), foo(),);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider describing why the failing assert is problematic
 
 error: assert without any message
   --> $DIR/missing_assert_message.rs:34:5
    |
 LL |     assert_ne!(foo(), foo(),);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider describing why the failing assert is problematic
 
 error: assert without any message
   --> $DIR/missing_assert_message.rs:35:5
    |
 LL |     debug_assert!(foo(),);
    |     ^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider describing why the failing assert is problematic
 
 error: assert without any message
   --> $DIR/missing_assert_message.rs:36:5
    |
 LL |     debug_assert_eq!(foo(), foo(),);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider describing why the failing assert is problematic
 
 error: assert without any message
   --> $DIR/missing_assert_message.rs:37:5
    |
 LL |     debug_assert_ne!(foo(), foo(),);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider describing why the failing assert is problematic
 
 error: aborting due to 16 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 6fac73b9874ea79fbac5f0fa9429c726c196d9a6 Mon Sep 17 00:00:00 2001
From: unexge <unexge@gmail.com>
Date: Sat, 18 Feb 2023 19:14:50 +0000
Subject: Move lint to `restriction` category

Co-authored-by: Weihang Lo <me@weihanglo.tw>
---
 clippy_lints/src/missing_assert_message.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/missing_assert_message.rs b/clippy_lints/src/missing_assert_message.rs
index 3b73332215e..f499b3e50ca 100644
--- a/clippy_lints/src/missing_assert_message.rs
+++ b/clippy_lints/src/missing_assert_message.rs
@@ -33,7 +33,7 @@ declare_clippy_lint! {
     /// ```
     #[clippy::version = "1.69.0"]
     pub MISSING_ASSERT_MESSAGE,
-    pedantic,
+    restriction,
     "checks assertions without a custom panic message"
 }
 
-- 
cgit 1.4.1-3-g733a5


From b4b2b1235a07aeb5f6d6e345e23d8fa4873cda08 Mon Sep 17 00:00:00 2001
From: unexge <unexge@gmail.com>
Date: Sat, 18 Feb 2023 19:18:52 +0000
Subject: Revert "Dogfood `missing_assert_message` on Clippy"

This reverts commit ec653570ad50d11ecc3b5649dd28e29ed96199d3.
---
 clippy_lints/src/doc.rs                  |  2 +-
 clippy_lints/src/duplicate_mod.rs        |  6 +-----
 clippy_lints/src/enum_variants.rs        |  2 +-
 clippy_lints/src/non_expressive_names.rs |  5 +----
 clippy_utils/src/attrs.rs                |  6 ++----
 clippy_utils/src/lib.rs                  | 11 ++++-------
 clippy_utils/src/numeric_literal.rs      |  6 +++---
 clippy_utils/src/ty.rs                   |  3 ++-
 lintcheck/src/main.rs                    |  3 +--
 tests/compile-test.rs                    |  5 +----
 tests/integration.rs                     |  1 -
 tests/test_utils/mod.rs                  |  2 +-
 12 files changed, 18 insertions(+), 34 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/doc.rs b/clippy_lints/src/doc.rs
index b1c2a51daa0..384aca7fead 100644
--- a/clippy_lints/src/doc.rs
+++ b/clippy_lints/src/doc.rs
@@ -467,7 +467,7 @@ pub fn strip_doc_comment_decoration(doc: &str, comment_kind: CommentKind, span:
     let mut contains_initial_stars = false;
     for line in doc.lines() {
         let offset = line.as_ptr() as usize - doc.as_ptr() as usize;
-        debug_assert_eq!(offset as u32 as usize, offset, "`offset` shouldn't overflow `u32`");
+        debug_assert_eq!(offset as u32 as usize, offset);
         contains_initial_stars |= line.trim_start().starts_with('*');
         // +1 adds the newline, +3 skips the opening delimiter
         sizes.push((line.len() + 1, span.with_lo(span.lo() + BytePos(3 + offset as u32))));
diff --git a/clippy_lints/src/duplicate_mod.rs b/clippy_lints/src/duplicate_mod.rs
index 9135af40979..7ff7068f0b0 100644
--- a/clippy_lints/src/duplicate_mod.rs
+++ b/clippy_lints/src/duplicate_mod.rs
@@ -90,11 +90,7 @@ impl EarlyLintPass for DuplicateMod {
             }
 
             // At this point the lint would be emitted
-            assert_eq!(
-                spans.len(),
-                lint_levels.len(),
-                "`spans` and `lint_levels` should have equal lengths"
-            );
+            assert_eq!(spans.len(), lint_levels.len());
             let spans: Vec<_> = spans
                 .iter()
                 .zip(lint_levels)
diff --git a/clippy_lints/src/enum_variants.rs b/clippy_lints/src/enum_variants.rs
index 68fb88bcf7e..4c69dacf381 100644
--- a/clippy_lints/src/enum_variants.rs
+++ b/clippy_lints/src/enum_variants.rs
@@ -242,7 +242,7 @@ fn to_camel_case(item_name: &str) -> String {
 impl LateLintPass<'_> for EnumVariantNames {
     fn check_item_post(&mut self, _cx: &LateContext<'_>, _item: &Item<'_>) {
         let last = self.modules.pop();
-        assert!(last.is_some(), "`modules` should not be empty");
+        assert!(last.is_some());
     }
 
     #[expect(clippy::similar_names)]
diff --git a/clippy_lints/src/non_expressive_names.rs b/clippy_lints/src/non_expressive_names.rs
index e24f3aa567a..9f6917c146f 100644
--- a/clippy_lints/src/non_expressive_names.rs
+++ b/clippy_lints/src/non_expressive_names.rs
@@ -408,10 +408,7 @@ fn do_check(lint: &mut NonExpressiveNames, cx: &EarlyContext<'_>, attrs: &[Attri
 /// Precondition: `a_name.chars().count() < b_name.chars().count()`.
 #[must_use]
 fn levenstein_not_1(a_name: &str, b_name: &str) -> bool {
-    debug_assert!(
-        a_name.chars().count() < b_name.chars().count(),
-        "Precondition: `a_name.chars().count() < b_name.chars().count()` does not meet"
-    );
+    debug_assert!(a_name.chars().count() < b_name.chars().count());
     let mut a_chars = a_name.chars();
     let mut b_chars = b_name.chars();
     while let (Some(a), Some(b)) = (a_chars.next(), b_chars.next()) {
diff --git a/clippy_utils/src/attrs.rs b/clippy_utils/src/attrs.rs
index 75f7b5cf98e..7987a233bdc 100644
--- a/clippy_utils/src/attrs.rs
+++ b/clippy_utils/src/attrs.rs
@@ -31,7 +31,7 @@ pub struct LimitStack {
 
 impl Drop for LimitStack {
     fn drop(&mut self) {
-        assert_eq!(self.stack.len(), 1, "stack should only have one element");
+        assert_eq!(self.stack.len(), 1);
     }
 }
 
@@ -49,9 +49,7 @@ impl LimitStack {
     }
     pub fn pop_attrs(&mut self, sess: &Session, attrs: &[ast::Attribute], name: &'static str) {
         let stack = &mut self.stack;
-        parse_attrs(sess, attrs, name, |val| {
-            assert_eq!(stack.pop(), Some(val), "incorrect last element");
-        });
+        parse_attrs(sess, attrs, name, |val| assert_eq!(stack.pop(), Some(val)));
     }
 }
 
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 1c453b87f8d..213e5b33503 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -1011,13 +1011,10 @@ pub fn capture_local_usage(cx: &LateContext<'_>, e: &Expr<'_>) -> CaptureKind {
         capture
     }
 
-    debug_assert!(
-        matches!(
-            e.kind,
-            ExprKind::Path(QPath::Resolved(None, Path { res: Res::Local(_), .. }))
-        ),
-        "`e.kind` should be a resolved local path"
-    );
+    debug_assert!(matches!(
+        e.kind,
+        ExprKind::Path(QPath::Resolved(None, Path { res: Res::Local(_), .. }))
+    ));
 
     let mut child_id = e.hir_id;
     let mut capture = CaptureKind::Value;
diff --git a/clippy_utils/src/numeric_literal.rs b/clippy_utils/src/numeric_literal.rs
index 7d8f31e1dfb..c225398ad2a 100644
--- a/clippy_utils/src/numeric_literal.rs
+++ b/clippy_utils/src/numeric_literal.rs
@@ -179,7 +179,7 @@ impl<'a> NumericLiteral<'a> {
     }
 
     pub fn group_digits(output: &mut String, input: &str, group_size: usize, partial_group_first: bool, pad: bool) {
-        debug_assert!(group_size > 0, "group size should be greater than zero");
+        debug_assert!(group_size > 0);
 
         let mut digits = input.chars().filter(|&c| c != '_');
 
@@ -219,7 +219,7 @@ impl<'a> NumericLiteral<'a> {
 }
 
 fn split_suffix<'a>(src: &'a str, lit_kind: &LitKind) -> (&'a str, Option<&'a str>) {
-    debug_assert!(lit_kind.is_numeric(), "`lit_kind` should be numeric");
+    debug_assert!(lit_kind.is_numeric());
     lit_suffix_length(lit_kind)
         .and_then(|suffix_length| src.len().checked_sub(suffix_length))
         .map_or((src, None), |split_pos| {
@@ -229,7 +229,7 @@ fn split_suffix<'a>(src: &'a str, lit_kind: &LitKind) -> (&'a str, Option<&'a st
 }
 
 fn lit_suffix_length(lit_kind: &LitKind) -> Option<usize> {
-    debug_assert!(lit_kind.is_numeric(), "`lit_kind` should be numeric");
+    debug_assert!(lit_kind.is_numeric());
     let suffix = match lit_kind {
         LitKind::Int(_, int_lit_kind) => match int_lit_kind {
             LitIntType::Signed(int_ty) => Some(int_ty.name_str()),
diff --git a/clippy_utils/src/ty.rs b/clippy_utils/src/ty.rs
index 2b3c781477f..7cbb77ea2a8 100644
--- a/clippy_utils/src/ty.rs
+++ b/clippy_utils/src/ty.rs
@@ -225,7 +225,8 @@ pub fn implements_trait_with_env<'tcx>(
     trait_id: DefId,
     ty_params: impl IntoIterator<Item = Option<GenericArg<'tcx>>>,
 ) -> bool {
-    assert!(!ty.needs_infer(), "Clippy shouldn't have infer types");
+    // Clippy shouldn't have infer types
+    assert!(!ty.needs_infer());
 
     let ty = tcx.erase_regions(ty);
     if ty.has_escaping_bound_vars() {
diff --git a/lintcheck/src/main.rs b/lintcheck/src/main.rs
index 6e39c8d4243..23c85298027 100644
--- a/lintcheck/src/main.rs
+++ b/lintcheck/src/main.rs
@@ -383,7 +383,7 @@ impl Crate {
                 .status()
                 .expect("failed to run cargo");
 
-            assert_eq!(status.code(), Some(0), "`cargo check` exited with non-zero code");
+            assert_eq!(status.code(), Some(0));
 
             return Vec::new();
         }
@@ -741,7 +741,6 @@ fn print_stats(old_stats: HashMap<String, usize>, new_stats: HashMap<&String, us
     let mut new_stats_deduped = new_stats;
 
     // remove duplicates from both hashmaps
-    #[allow(clippy::missing_assert_message)]
     for (k, v) in &same_in_both_hashmaps {
         assert!(old_stats_deduped.remove(k) == Some(*v));
         assert!(new_stats_deduped.remove(k) == Some(*v));
diff --git a/tests/compile-test.rs b/tests/compile-test.rs
index 2f2d305f54b..c10ee969c01 100644
--- a/tests/compile-test.rs
+++ b/tests/compile-test.rs
@@ -410,10 +410,7 @@ fn check_rustfix_coverage() {
     };
 
     if let Ok(missing_coverage_contents) = std::fs::read_to_string(missing_coverage_path) {
-        assert!(
-            RUSTFIX_COVERAGE_KNOWN_EXCEPTIONS.iter().is_sorted_by_key(Path::new),
-            "`RUSTFIX_COVERAGE_KNOWN_EXCEPTIONS` should be sorted"
-        );
+        assert!(RUSTFIX_COVERAGE_KNOWN_EXCEPTIONS.iter().is_sorted_by_key(Path::new));
 
         for rs_file in missing_coverage_contents.lines() {
             let rs_path = Path::new(rs_file);
diff --git a/tests/integration.rs b/tests/integration.rs
index 2d2d6e6739e..a771d8b87c8 100644
--- a/tests/integration.rs
+++ b/tests/integration.rs
@@ -21,7 +21,6 @@ const CARGO_CLIPPY: &str = "cargo-clippy";
 const CARGO_CLIPPY: &str = "cargo-clippy.exe";
 
 #[cfg_attr(feature = "integration", test)]
-#[allow(clippy::missing_assert_message)]
 fn integration_test() {
     let repo_name = env::var("INTEGRATION").expect("`INTEGRATION` var not set");
     let repo_url = format!("https://github.com/{repo_name}");
diff --git a/tests/test_utils/mod.rs b/tests/test_utils/mod.rs
index 3081bf2d8cc..ea8c54e08b3 100644
--- a/tests/test_utils/mod.rs
+++ b/tests/test_utils/mod.rs
@@ -5,7 +5,7 @@ use std::sync::LazyLock;
 
 pub static CARGO_CLIPPY_PATH: LazyLock<PathBuf> = LazyLock::new(|| {
     let mut path = std::env::current_exe().unwrap();
-    assert!(path.pop(), "current running executable path shouldn't be empty"); // deps
+    assert!(path.pop()); // deps
     path.set_file_name("cargo-clippy");
     path
 });
-- 
cgit 1.4.1-3-g733a5


From 87f58a1a4fb0a95973add9ff8c0c8e3439599e8a Mon Sep 17 00:00:00 2001
From: unexge <unexge@gmail.com>
Date: Fri, 24 Feb 2023 00:20:47 +0000
Subject: Use late lint pass for `missing_assert_message` lint

Co-authored-by: Weihang Lo <me@weihanglo.tw>
---
 clippy_lints/src/lib.rs                    |   2 +-
 clippy_lints/src/missing_assert_message.rs | 106 +++++++----------------------
 2 files changed, 27 insertions(+), 81 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index e3be798f30b..6d4ec527756 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -927,7 +927,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     });
     store.register_late_pass(|_| Box::new(no_mangle_with_rust_abi::NoMangleWithRustAbi));
     store.register_late_pass(|_| Box::new(collection_is_never_read::CollectionIsNeverRead));
-    store.register_pre_expansion_pass(|| Box::<missing_assert_message::MissingAssertMessage>::default());
+    store.register_late_pass(|_| Box::new(missing_assert_message::MissingAssertMessage));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/missing_assert_message.rs b/clippy_lints/src/missing_assert_message.rs
index f499b3e50ca..2ff0cee2925 100644
--- a/clippy_lints/src/missing_assert_message.rs
+++ b/clippy_lints/src/missing_assert_message.rs
@@ -1,11 +1,9 @@
 use clippy_utils::diagnostics::span_lint_and_help;
-use rustc_ast::ast;
-use rustc_ast::{
-    token::{Token, TokenKind},
-    tokenstream::TokenTree,
-};
-use rustc_lint::{EarlyContext, EarlyLintPass};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use clippy_utils::macros::{find_assert_args, find_assert_eq_args, root_macro_call_first_node, PanicExpn};
+use clippy_utils::{is_in_cfg_test, is_in_test_function};
+use rustc_hir::Expr;
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::sym;
 
 declare_clippy_lint! {
@@ -37,93 +35,41 @@ declare_clippy_lint! {
     "checks assertions without a custom panic message"
 }
 
-#[derive(Default, Clone, Debug)]
-pub struct MissingAssertMessage {
-    // This field will be greater than zero if we are inside a `#[test]` or `#[cfg(test)]`
-    test_deepnes: usize,
-}
+declare_lint_pass!(MissingAssertMessage => [MISSING_ASSERT_MESSAGE]);
 
-impl_lint_pass!(MissingAssertMessage => [MISSING_ASSERT_MESSAGE]);
+impl<'tcx> LateLintPass<'tcx> for MissingAssertMessage {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        let Some(macro_call) = root_macro_call_first_node(cx, expr) else { return };
+        let single_argument = match cx.tcx.get_diagnostic_name(macro_call.def_id) {
+            Some(sym::assert_macro | sym::debug_assert_macro) => true,
+            Some(
+                sym::assert_eq_macro | sym::assert_ne_macro | sym::debug_assert_eq_macro | sym::debug_assert_ne_macro,
+            ) => false,
+            _ => return,
+        };
 
-impl EarlyLintPass for MissingAssertMessage {
-    fn check_mac(&mut self, cx: &EarlyContext<'_>, mac_call: &ast::MacCall) {
-        if self.test_deepnes != 0 {
+        // This lint would be very noisy in tests, so just ignore if we're in test context
+        if is_in_test_function(cx.tcx, expr.hir_id) || is_in_cfg_test(cx.tcx, expr.hir_id) {
             return;
         }
 
-        let Some(last_segment) = mac_call.path.segments.last() else { return; };
-        let num_separators_needed = match last_segment.ident.as_str() {
-            "assert" | "debug_assert" => 1,
-            "assert_eq" | "assert_ne" | "debug_assert_eq" | "debug_assert_ne" => 2,
-            _ => return,
+        let panic_expn = if single_argument {
+            let Some((_, panic_expn)) = find_assert_args(cx, expr, macro_call.expn) else { return };
+            panic_expn
+        } else {
+            let Some((_, _, panic_expn)) = find_assert_eq_args(cx, expr, macro_call.expn) else { return };
+            panic_expn
         };
-        let num_separators = num_commas_on_arguments(mac_call);
 
-        if num_separators < num_separators_needed {
+        if let PanicExpn::Empty = panic_expn {
             span_lint_and_help(
                 cx,
                 MISSING_ASSERT_MESSAGE,
-                mac_call.span(),
+                macro_call.span,
                 "assert without any message",
                 None,
                 "consider describing why the failing assert is problematic",
             );
         }
     }
-
-    fn check_item(&mut self, _: &EarlyContext<'_>, item: &ast::Item) {
-        if item.attrs.iter().any(is_a_test_attribute) {
-            self.test_deepnes += 1;
-        }
-    }
-
-    fn check_item_post(&mut self, _: &EarlyContext<'_>, item: &ast::Item) {
-        if item.attrs.iter().any(is_a_test_attribute) {
-            self.test_deepnes -= 1;
-        }
-    }
-}
-
-// Returns number of commas (excluding trailing comma) from `MacCall`'s arguments.
-fn num_commas_on_arguments(mac_call: &ast::MacCall) -> usize {
-    let mut num_separators = 0;
-    let mut is_trailing = false;
-    for tt in mac_call.args.tokens.trees() {
-        match tt {
-            TokenTree::Token(
-                Token {
-                    kind: TokenKind::Comma,
-                    span: _,
-                },
-                _,
-            ) => {
-                num_separators += 1;
-                is_trailing = true;
-            },
-            _ => {
-                is_trailing = false;
-            },
-        }
-    }
-    if is_trailing {
-        num_separators -= 1;
-    }
-    num_separators
-}
-
-// Returns true if the attribute is either a `#[test]` or a `#[cfg(test)]`.
-fn is_a_test_attribute(attr: &ast::Attribute) -> bool {
-    if attr.has_name(sym::test) {
-        return true;
-    }
-
-    if attr.has_name(sym::cfg)
-        && let Some(items) = attr.meta_item_list()
-        && let [item] = &*items
-        && item.has_name(sym::test)
-    {
-        true
-    } else {
-        false
-    }
 }
-- 
cgit 1.4.1-3-g733a5


From b554ff4cd833a60e753050703dc5d1384607d1da Mon Sep 17 00:00:00 2001
From: unexge <unexge@gmail.com>
Date: Sun, 5 Mar 2023 14:25:22 +0000
Subject: Add `Known problems` section

Co-authored-by: Weihang Lo <me@weihanglo.tw>
---
 clippy_lints/src/missing_assert_message.rs | 7 +++++++
 1 file changed, 7 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/missing_assert_message.rs b/clippy_lints/src/missing_assert_message.rs
index 2ff0cee2925..2214a568d9c 100644
--- a/clippy_lints/src/missing_assert_message.rs
+++ b/clippy_lints/src/missing_assert_message.rs
@@ -15,6 +15,13 @@ declare_clippy_lint! {
     /// A good custom message should be more about why the failure of the assertion is problematic
     /// and not what is failed because the assertion already conveys that.
     ///
+    /// ### Known problems
+    /// This lint cannot check the quality of the custom panic messages.
+    /// Hence, you can suppress this lint simply by adding placeholder messages
+    /// like "assertion failed". However, we recommend coming up with good messages
+    /// that provide useful information instead of placeholder messages that
+    /// don't provide any extra information.
+    ///
     /// ### Example
     /// ```rust
     /// # struct Service { ready: bool }
-- 
cgit 1.4.1-3-g733a5


From d5429eab8aee46fd2148f99b8f9ba394addb5ba7 Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Sat, 4 Mar 2023 17:28:53 +0100
Subject: Add new `redundant_async_block` lint

---
 CHANGELOG.md                                   |  1 +
 clippy_lints/src/declared_lints.rs             |  1 +
 clippy_lints/src/lib.rs                        |  2 +
 clippy_lints/src/redundant_async_block.rs      | 84 ++++++++++++++++++++++++++
 tests/ui/async_yields_async.fixed              |  1 +
 tests/ui/async_yields_async.rs                 |  1 +
 tests/ui/async_yields_async.stderr             | 12 ++--
 tests/ui/redundant_async_block.fixed           | 64 ++++++++++++++++++++
 tests/ui/redundant_async_block.rs              | 64 ++++++++++++++++++++
 tests/ui/redundant_async_block.stderr          | 28 +++++++++
 tests/ui/redundant_closure_call_fixable.fixed  |  1 +
 tests/ui/redundant_closure_call_fixable.rs     |  1 +
 tests/ui/redundant_closure_call_fixable.stderr | 12 ++--
 13 files changed, 260 insertions(+), 12 deletions(-)
 create mode 100644 clippy_lints/src/redundant_async_block.rs
 create mode 100644 tests/ui/redundant_async_block.fixed
 create mode 100644 tests/ui/redundant_async_block.rs
 create mode 100644 tests/ui/redundant_async_block.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 62cc7437b82..d797b30f47b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4836,6 +4836,7 @@ Released 2018-09-13
 [`read_zero_byte_vec`]: https://rust-lang.github.io/rust-clippy/master/index.html#read_zero_byte_vec
 [`recursive_format_impl`]: https://rust-lang.github.io/rust-clippy/master/index.html#recursive_format_impl
 [`redundant_allocation`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_allocation
+[`redundant_async_block`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_async_block
 [`redundant_clone`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_clone
 [`redundant_closure`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_closure
 [`redundant_closure_call`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_closure_call
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 462fcb6483d..d3b9cc67579 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -519,6 +519,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::ranges::REVERSED_EMPTY_RANGES_INFO,
     crate::rc_clone_in_vec_init::RC_CLONE_IN_VEC_INIT_INFO,
     crate::read_zero_byte_vec::READ_ZERO_BYTE_VEC_INFO,
+    crate::redundant_async_block::REDUNDANT_ASYNC_BLOCK_INFO,
     crate::redundant_clone::REDUNDANT_CLONE_INFO,
     crate::redundant_closure_call::REDUNDANT_CLOSURE_CALL_INFO,
     crate::redundant_else::REDUNDANT_ELSE_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 6d4ec527756..ea1e0ab506c 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -251,6 +251,7 @@ mod question_mark_used;
 mod ranges;
 mod rc_clone_in_vec_init;
 mod read_zero_byte_vec;
+mod redundant_async_block;
 mod redundant_clone;
 mod redundant_closure_call;
 mod redundant_else;
@@ -928,6 +929,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(no_mangle_with_rust_abi::NoMangleWithRustAbi));
     store.register_late_pass(|_| Box::new(collection_is_never_read::CollectionIsNeverRead));
     store.register_late_pass(|_| Box::new(missing_assert_message::MissingAssertMessage));
+    store.register_early_pass(|| Box::new(redundant_async_block::RedundantAsyncBlock));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/redundant_async_block.rs b/clippy_lints/src/redundant_async_block.rs
new file mode 100644
index 00000000000..27ad4308637
--- /dev/null
+++ b/clippy_lints/src/redundant_async_block.rs
@@ -0,0 +1,84 @@
+use clippy_utils::{diagnostics::span_lint_and_sugg, source::snippet};
+use rustc_ast::ast::*;
+use rustc_ast::visit::Visitor as AstVisitor;
+use rustc_errors::Applicability;
+use rustc_lint::{EarlyContext, EarlyLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `async` block that only returns `await` on a future.
+    ///
+    /// ### Why is this bad?
+    /// It is simpler and more efficient to use the future directly.
+    ///
+    /// ### Example
+    /// ```rust
+    /// async fn f() -> i32 {
+    ///     1 + 2
+    /// }
+    ///
+    /// let fut = async {
+    ///     f().await
+    /// };
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// async fn f() -> i32 {
+    ///     1 + 2
+    /// }
+    ///
+    /// let fut = f();
+    /// ```
+    #[clippy::version = "1.69.0"]
+    pub REDUNDANT_ASYNC_BLOCK,
+    complexity,
+    "`async { future.await }` can be replaced by `future`"
+}
+declare_lint_pass!(RedundantAsyncBlock => [REDUNDANT_ASYNC_BLOCK]);
+
+impl EarlyLintPass for RedundantAsyncBlock {
+    fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
+        if expr.span.from_expansion() {
+            return;
+        }
+        if let ExprKind::Async(_, _, block) = &expr.kind && block.stmts.len() == 1 &&
+            let Some(Stmt { kind: StmtKind::Expr(last), .. }) = block.stmts.last() &&
+            let ExprKind::Await(future) = &last.kind &&
+            !future.span.from_expansion() &&
+            !await_in_expr(future)
+        {
+            span_lint_and_sugg(
+                cx,
+                REDUNDANT_ASYNC_BLOCK,
+                expr.span,
+                "this async expression only awaits a single future",
+                "you can reduce it to",
+                snippet(cx, future.span, "..").into_owned(),
+                Applicability::MachineApplicable,
+            );
+        }
+    }
+}
+
+/// Check whether an expression contains `.await`
+fn await_in_expr(expr: &Expr) -> bool {
+    let mut detector = AwaitDetector::default();
+    detector.visit_expr(expr);
+    detector.await_found
+}
+
+#[derive(Default)]
+struct AwaitDetector {
+    await_found: bool,
+}
+
+impl<'ast> AstVisitor<'ast> for AwaitDetector {
+    fn visit_expr(&mut self, ex: &'ast Expr) {
+        match (&ex.kind, self.await_found) {
+            (ExprKind::Await(_), _) => self.await_found = true,
+            (_, false) => rustc_ast::visit::walk_expr(self, ex),
+            _ => (),
+        }
+    }
+}
diff --git a/tests/ui/async_yields_async.fixed b/tests/ui/async_yields_async.fixed
index 3cf380d2b95..579a63ea477 100644
--- a/tests/ui/async_yields_async.fixed
+++ b/tests/ui/async_yields_async.fixed
@@ -2,6 +2,7 @@
 #![feature(lint_reasons)]
 #![feature(async_closure)]
 #![warn(clippy::async_yields_async)]
+#![allow(clippy::redundant_async_block)]
 
 use core::future::Future;
 use core::pin::Pin;
diff --git a/tests/ui/async_yields_async.rs b/tests/ui/async_yields_async.rs
index dd4131b60ab..5aec2fb50f6 100644
--- a/tests/ui/async_yields_async.rs
+++ b/tests/ui/async_yields_async.rs
@@ -2,6 +2,7 @@
 #![feature(lint_reasons)]
 #![feature(async_closure)]
 #![warn(clippy::async_yields_async)]
+#![allow(clippy::redundant_async_block)]
 
 use core::future::Future;
 use core::pin::Pin;
diff --git a/tests/ui/async_yields_async.stderr b/tests/ui/async_yields_async.stderr
index 22ce1c6f647..7f72534832b 100644
--- a/tests/ui/async_yields_async.stderr
+++ b/tests/ui/async_yields_async.stderr
@@ -1,5 +1,5 @@
 error: an async construct yields a type which is itself awaitable
-  --> $DIR/async_yields_async.rs:39:9
+  --> $DIR/async_yields_async.rs:40:9
    |
 LL |        let _h = async {
    |  _____________________-
@@ -19,7 +19,7 @@ LL +         }.await
    |
 
 error: an async construct yields a type which is itself awaitable
-  --> $DIR/async_yields_async.rs:44:9
+  --> $DIR/async_yields_async.rs:45:9
    |
 LL |       let _i = async {
    |  ____________________-
@@ -32,7 +32,7 @@ LL | |     };
    | |_____- outer async construct
 
 error: an async construct yields a type which is itself awaitable
-  --> $DIR/async_yields_async.rs:50:9
+  --> $DIR/async_yields_async.rs:51:9
    |
 LL |        let _j = async || {
    |  ________________________-
@@ -51,7 +51,7 @@ LL +         }.await
    |
 
 error: an async construct yields a type which is itself awaitable
-  --> $DIR/async_yields_async.rs:55:9
+  --> $DIR/async_yields_async.rs:56:9
    |
 LL |       let _k = async || {
    |  _______________________-
@@ -64,7 +64,7 @@ LL | |     };
    | |_____- outer async construct
 
 error: an async construct yields a type which is itself awaitable
-  --> $DIR/async_yields_async.rs:57:23
+  --> $DIR/async_yields_async.rs:58:23
    |
 LL |     let _l = async || CustomFutureType;
    |                       ^^^^^^^^^^^^^^^^
@@ -74,7 +74,7 @@ LL |     let _l = async || CustomFutureType;
    |                       help: consider awaiting this value: `CustomFutureType.await`
 
 error: an async construct yields a type which is itself awaitable
-  --> $DIR/async_yields_async.rs:63:9
+  --> $DIR/async_yields_async.rs:64:9
    |
 LL |       let _m = async || {
    |  _______________________-
diff --git a/tests/ui/redundant_async_block.fixed b/tests/ui/redundant_async_block.fixed
new file mode 100644
index 00000000000..5f9931df45e
--- /dev/null
+++ b/tests/ui/redundant_async_block.fixed
@@ -0,0 +1,64 @@
+// run-rustfix
+
+#![allow(unused)]
+#![warn(clippy::redundant_async_block)]
+
+async fn func1(n: usize) -> usize {
+    n + 1
+}
+
+async fn func2() -> String {
+    let s = String::from("some string");
+    let f = async { (*s).to_owned() };
+    let x = f;
+    x.await
+}
+
+macro_rules! await_in_macro {
+    ($e:expr) => {
+        std::convert::identity($e).await
+    };
+}
+
+async fn func3(n: usize) -> usize {
+    // Do not lint (suggestion would be `std::convert::identity(func1(n))`
+    // which copies code from inside the macro)
+    async move { await_in_macro!(func1(n)) }.await
+}
+
+// This macro should never be linted as `$e` might contain `.await`
+macro_rules! async_await_parameter_in_macro {
+    ($e:expr) => {
+        async { $e.await }
+    };
+}
+
+// MISSED OPPORTUNITY: this macro could be linted as the `async` block does not
+// contain code coming from the parameters
+macro_rules! async_await_in_macro {
+    ($f:expr) => {
+        ($f)(async { func2().await })
+    };
+}
+
+fn main() {
+    let fut1 = async { 17 };
+    let fut2 = fut1;
+
+    let fut1 = async { 25 };
+    let fut2 = fut1;
+
+    let fut = async { 42 };
+
+    // Do not lint: not a single expression
+    let fut = async {
+        func1(10).await;
+        func2().await
+    };
+
+    // Do not lint: expression contains `.await`
+    let fut = async { func1(func2().await.len()).await };
+
+    let fut = async_await_parameter_in_macro!(func2());
+    let fut = async_await_in_macro!(std::convert::identity);
+}
diff --git a/tests/ui/redundant_async_block.rs b/tests/ui/redundant_async_block.rs
new file mode 100644
index 00000000000..de3c9970c65
--- /dev/null
+++ b/tests/ui/redundant_async_block.rs
@@ -0,0 +1,64 @@
+// run-rustfix
+
+#![allow(unused)]
+#![warn(clippy::redundant_async_block)]
+
+async fn func1(n: usize) -> usize {
+    n + 1
+}
+
+async fn func2() -> String {
+    let s = String::from("some string");
+    let f = async { (*s).to_owned() };
+    let x = async { f.await };
+    x.await
+}
+
+macro_rules! await_in_macro {
+    ($e:expr) => {
+        std::convert::identity($e).await
+    };
+}
+
+async fn func3(n: usize) -> usize {
+    // Do not lint (suggestion would be `std::convert::identity(func1(n))`
+    // which copies code from inside the macro)
+    async move { await_in_macro!(func1(n)) }.await
+}
+
+// This macro should never be linted as `$e` might contain `.await`
+macro_rules! async_await_parameter_in_macro {
+    ($e:expr) => {
+        async { $e.await }
+    };
+}
+
+// MISSED OPPORTUNITY: this macro could be linted as the `async` block does not
+// contain code coming from the parameters
+macro_rules! async_await_in_macro {
+    ($f:expr) => {
+        ($f)(async { func2().await })
+    };
+}
+
+fn main() {
+    let fut1 = async { 17 };
+    let fut2 = async { fut1.await };
+
+    let fut1 = async { 25 };
+    let fut2 = async move { fut1.await };
+
+    let fut = async { async { 42 }.await };
+
+    // Do not lint: not a single expression
+    let fut = async {
+        func1(10).await;
+        func2().await
+    };
+
+    // Do not lint: expression contains `.await`
+    let fut = async { func1(func2().await.len()).await };
+
+    let fut = async_await_parameter_in_macro!(func2());
+    let fut = async_await_in_macro!(std::convert::identity);
+}
diff --git a/tests/ui/redundant_async_block.stderr b/tests/ui/redundant_async_block.stderr
new file mode 100644
index 00000000000..b16d96dce84
--- /dev/null
+++ b/tests/ui/redundant_async_block.stderr
@@ -0,0 +1,28 @@
+error: this async expression only awaits a single future
+  --> $DIR/redundant_async_block.rs:13:13
+   |
+LL |     let x = async { f.await };
+   |             ^^^^^^^^^^^^^^^^^ help: you can reduce it to: `f`
+   |
+   = note: `-D clippy::redundant-async-block` implied by `-D warnings`
+
+error: this async expression only awaits a single future
+  --> $DIR/redundant_async_block.rs:46:16
+   |
+LL |     let fut2 = async { fut1.await };
+   |                ^^^^^^^^^^^^^^^^^^^^ help: you can reduce it to: `fut1`
+
+error: this async expression only awaits a single future
+  --> $DIR/redundant_async_block.rs:49:16
+   |
+LL |     let fut2 = async move { fut1.await };
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^ help: you can reduce it to: `fut1`
+
+error: this async expression only awaits a single future
+  --> $DIR/redundant_async_block.rs:51:15
+   |
+LL |     let fut = async { async { 42 }.await };
+   |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: you can reduce it to: `async { 42 }`
+
+error: aborting due to 4 previous errors
+
diff --git a/tests/ui/redundant_closure_call_fixable.fixed b/tests/ui/redundant_closure_call_fixable.fixed
index c0e49ff4caa..b987fd2ce6f 100644
--- a/tests/ui/redundant_closure_call_fixable.fixed
+++ b/tests/ui/redundant_closure_call_fixable.fixed
@@ -2,6 +2,7 @@
 
 #![feature(async_closure)]
 #![warn(clippy::redundant_closure_call)]
+#![allow(clippy::redundant_async_block)]
 #![allow(unused)]
 
 async fn something() -> u32 {
diff --git a/tests/ui/redundant_closure_call_fixable.rs b/tests/ui/redundant_closure_call_fixable.rs
index 9e6e54348a8..633a2979d5d 100644
--- a/tests/ui/redundant_closure_call_fixable.rs
+++ b/tests/ui/redundant_closure_call_fixable.rs
@@ -2,6 +2,7 @@
 
 #![feature(async_closure)]
 #![warn(clippy::redundant_closure_call)]
+#![allow(clippy::redundant_async_block)]
 #![allow(unused)]
 
 async fn something() -> u32 {
diff --git a/tests/ui/redundant_closure_call_fixable.stderr b/tests/ui/redundant_closure_call_fixable.stderr
index d71bcba2a82..8a1f0771659 100644
--- a/tests/ui/redundant_closure_call_fixable.stderr
+++ b/tests/ui/redundant_closure_call_fixable.stderr
@@ -1,5 +1,5 @@
 error: try not to call a closure in the expression where it is declared
-  --> $DIR/redundant_closure_call_fixable.rs:16:13
+  --> $DIR/redundant_closure_call_fixable.rs:17:13
    |
 LL |     let a = (|| 42)();
    |             ^^^^^^^^^ help: try doing something like: `42`
@@ -7,7 +7,7 @@ LL |     let a = (|| 42)();
    = note: `-D clippy::redundant-closure-call` implied by `-D warnings`
 
 error: try not to call a closure in the expression where it is declared
-  --> $DIR/redundant_closure_call_fixable.rs:17:13
+  --> $DIR/redundant_closure_call_fixable.rs:18:13
    |
 LL |       let b = (async || {
    |  _____________^
@@ -27,7 +27,7 @@ LL ~     };
    |
 
 error: try not to call a closure in the expression where it is declared
-  --> $DIR/redundant_closure_call_fixable.rs:22:13
+  --> $DIR/redundant_closure_call_fixable.rs:23:13
    |
 LL |       let c = (|| {
    |  _____________^
@@ -47,13 +47,13 @@ LL ~     };
    |
 
 error: try not to call a closure in the expression where it is declared
-  --> $DIR/redundant_closure_call_fixable.rs:27:13
+  --> $DIR/redundant_closure_call_fixable.rs:28:13
    |
 LL |     let d = (async || something().await)();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try doing something like: `async { something().await }`
 
 error: try not to call a closure in the expression where it is declared
-  --> $DIR/redundant_closure_call_fixable.rs:36:13
+  --> $DIR/redundant_closure_call_fixable.rs:37:13
    |
 LL |             (|| m!())()
    |             ^^^^^^^^^^^ help: try doing something like: `m!()`
@@ -64,7 +64,7 @@ LL |     m2!();
    = note: this error originates in the macro `m2` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: try not to call a closure in the expression where it is declared
-  --> $DIR/redundant_closure_call_fixable.rs:31:13
+  --> $DIR/redundant_closure_call_fixable.rs:32:13
    |
 LL |             (|| 0)()
    |             ^^^^^^^^ help: try doing something like: `0`
-- 
cgit 1.4.1-3-g733a5


From ca3bf94c431efa5355f3928e3bfd587ae125bd38 Mon Sep 17 00:00:00 2001
From: blyxyas <blyxyas@gmail.com>
Date: Wed, 8 Mar 2023 17:31:00 +0100
Subject: Add `let_with_type_underscore` lint

---
 CHANGELOG.md                                 |  1 +
 clippy_lints/src/declared_lints.rs           |  1 +
 clippy_lints/src/let_with_type_underscore.rs | 45 ++++++++++++++++++++++++
 clippy_lints/src/lib.rs                      |  2 ++
 tests/ui/crashes/ice-6179.rs                 |  2 +-
 tests/ui/default_numeric_fallback_f64.fixed  |  3 +-
 tests/ui/default_numeric_fallback_f64.rs     |  3 +-
 tests/ui/default_numeric_fallback_f64.stderr | 48 ++++++++++++-------------
 tests/ui/default_numeric_fallback_i32.fixed  |  3 +-
 tests/ui/default_numeric_fallback_i32.rs     |  3 +-
 tests/ui/default_numeric_fallback_i32.stderr | 52 ++++++++++++++--------------
 tests/ui/let_with_type_underscore.rs         | 19 ++++++++++
 tests/ui/let_with_type_underscore.stderr     | 39 +++++++++++++++++++++
 tests/ui/manual_rem_euclid.fixed             |  1 +
 tests/ui/manual_rem_euclid.rs                |  1 +
 tests/ui/manual_rem_euclid.stderr            | 20 +++++------
 16 files changed, 178 insertions(+), 65 deletions(-)
 create mode 100644 clippy_lints/src/let_with_type_underscore.rs
 create mode 100644 tests/ui/let_with_type_underscore.rs
 create mode 100644 tests/ui/let_with_type_underscore.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index d797b30f47b..82911231ec9 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4643,6 +4643,7 @@ Released 2018-09-13
 [`let_underscore_must_use`]: https://rust-lang.github.io/rust-clippy/master/index.html#let_underscore_must_use
 [`let_underscore_untyped`]: https://rust-lang.github.io/rust-clippy/master/index.html#let_underscore_untyped
 [`let_unit_value`]: https://rust-lang.github.io/rust-clippy/master/index.html#let_unit_value
+[`let_with_type_underscore`]: https://rust-lang.github.io/rust-clippy/master/index.html#let_with_type_underscore
 [`linkedlist`]: https://rust-lang.github.io/rust-clippy/master/index.html#linkedlist
 [`logic_bug`]: https://rust-lang.github.io/rust-clippy/master/index.html#logic_bug
 [`lossy_float_literal`]: https://rust-lang.github.io/rust-clippy/master/index.html#lossy_float_literal
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index d3b9cc67579..cc6024b87cd 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -227,6 +227,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::let_underscore::LET_UNDERSCORE_LOCK_INFO,
     crate::let_underscore::LET_UNDERSCORE_MUST_USE_INFO,
     crate::let_underscore::LET_UNDERSCORE_UNTYPED_INFO,
+    crate::let_with_type_underscore::LET_WITH_TYPE_UNDERSCORE_INFO,
     crate::lifetimes::EXTRA_UNUSED_LIFETIMES_INFO,
     crate::lifetimes::NEEDLESS_LIFETIMES_INFO,
     crate::literal_representation::DECIMAL_LITERAL_REPRESENTATION_INFO,
diff --git a/clippy_lints/src/let_with_type_underscore.rs b/clippy_lints/src/let_with_type_underscore.rs
new file mode 100644
index 00000000000..ba51973f2f9
--- /dev/null
+++ b/clippy_lints/src/let_with_type_underscore.rs
@@ -0,0 +1,45 @@
+use clippy_utils::diagnostics::span_lint_and_help;
+use rustc_hir::*;
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::lint::in_external_macro;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Detects when a variable is declared with an explicit type of `_`.
+    /// ### Why is this bad?
+    /// It adds noise, `: _` provides zero clarity or utility.
+    /// ### Example
+    /// ```rust,ignore
+    /// let my_number: _ = 1;
+    /// ```
+    /// Use instead:
+    /// ```rust,ignore
+    /// let my_number = 1;
+    /// ```
+    #[clippy::version = "1.69.0"]
+    pub LET_WITH_TYPE_UNDERSCORE,
+    complexity,
+    "unneeded underscore type (`_`) in a variable declaration"
+}
+declare_lint_pass!(UnderscoreTyped => [LET_WITH_TYPE_UNDERSCORE]);
+
+impl LateLintPass<'_> for UnderscoreTyped {
+    fn check_local<'tcx>(&mut self, cx: &LateContext<'tcx>, local: &'tcx Local<'tcx>) {
+        if_chain! {
+            if !in_external_macro(cx.tcx.sess, local.span);
+            if let Some(ty) = local.ty; // Ensure that it has a type defined
+            if let TyKind::Infer = &ty.kind; // that type is '_'
+            if local.span.ctxt() == ty.span.ctxt();
+            then {
+                span_lint_and_help(cx,
+                    LET_WITH_TYPE_UNDERSCORE,
+                    local.span,
+                    "variable declared with type underscore",
+                    Some(ty.span.with_lo(local.pat.span.hi())),
+                    "remove the explicit type `_` declaration"
+                )
+            }
+        };
+    }
+}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index ea1e0ab506c..ce50c4657d8 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -167,6 +167,7 @@ mod large_stack_arrays;
 mod len_zero;
 mod let_if_seq;
 mod let_underscore;
+mod let_with_type_underscore;
 mod lifetimes;
 mod literal_representation;
 mod loops;
@@ -930,6 +931,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(collection_is_never_read::CollectionIsNeverRead));
     store.register_late_pass(|_| Box::new(missing_assert_message::MissingAssertMessage));
     store.register_early_pass(|| Box::new(redundant_async_block::RedundantAsyncBlock));
+    store.register_late_pass(|_| Box::new(let_with_type_underscore::UnderscoreTyped));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/tests/ui/crashes/ice-6179.rs b/tests/ui/crashes/ice-6179.rs
index 4fe92d356c4..ce1895851e2 100644
--- a/tests/ui/crashes/ice-6179.rs
+++ b/tests/ui/crashes/ice-6179.rs
@@ -2,7 +2,7 @@
 //! The ICE is mainly caused by using `hir_ty_to_ty`. See the discussion in the PR for details.
 
 #![warn(clippy::use_self)]
-#![allow(dead_code)]
+#![allow(dead_code, clippy::let_with_type_underscore)]
 
 struct Foo;
 
diff --git a/tests/ui/default_numeric_fallback_f64.fixed b/tests/ui/default_numeric_fallback_f64.fixed
index a370ccc7696..a9e5fd159af 100644
--- a/tests/ui/default_numeric_fallback_f64.fixed
+++ b/tests/ui/default_numeric_fallback_f64.fixed
@@ -9,7 +9,8 @@
     clippy::unnecessary_operation,
     clippy::branches_sharing_code,
     clippy::match_single_binding,
-    clippy::let_unit_value
+    clippy::let_unit_value,
+    clippy::let_with_type_underscore
 )]
 
 #[macro_use]
diff --git a/tests/ui/default_numeric_fallback_f64.rs b/tests/ui/default_numeric_fallback_f64.rs
index 2476fe95141..085f8f452b2 100644
--- a/tests/ui/default_numeric_fallback_f64.rs
+++ b/tests/ui/default_numeric_fallback_f64.rs
@@ -9,7 +9,8 @@
     clippy::unnecessary_operation,
     clippy::branches_sharing_code,
     clippy::match_single_binding,
-    clippy::let_unit_value
+    clippy::let_unit_value,
+    clippy::let_with_type_underscore
 )]
 
 #[macro_use]
diff --git a/tests/ui/default_numeric_fallback_f64.stderr b/tests/ui/default_numeric_fallback_f64.stderr
index 5df2f642388..44c6f1a9bea 100644
--- a/tests/ui/default_numeric_fallback_f64.stderr
+++ b/tests/ui/default_numeric_fallback_f64.stderr
@@ -1,5 +1,5 @@
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_f64.rs:21:17
+  --> $DIR/default_numeric_fallback_f64.rs:22:17
    |
 LL |         let x = 0.12;
    |                 ^^^^ help: consider adding suffix: `0.12_f64`
@@ -7,139 +7,139 @@ LL |         let x = 0.12;
    = note: `-D clippy::default-numeric-fallback` implied by `-D warnings`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_f64.rs:22:18
+  --> $DIR/default_numeric_fallback_f64.rs:23:18
    |
 LL |         let x = [1., 2., 3.];
    |                  ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_f64.rs:22:22
+  --> $DIR/default_numeric_fallback_f64.rs:23:22
    |
 LL |         let x = [1., 2., 3.];
    |                      ^^ help: consider adding suffix: `2.0_f64`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_f64.rs:22:26
+  --> $DIR/default_numeric_fallback_f64.rs:23:26
    |
 LL |         let x = [1., 2., 3.];
    |                          ^^ help: consider adding suffix: `3.0_f64`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_f64.rs:23:28
+  --> $DIR/default_numeric_fallback_f64.rs:24:28
    |
 LL |         let x = if true { (1., 2.) } else { (3., 4.) };
    |                            ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_f64.rs:23:32
+  --> $DIR/default_numeric_fallback_f64.rs:24:32
    |
 LL |         let x = if true { (1., 2.) } else { (3., 4.) };
    |                                ^^ help: consider adding suffix: `2.0_f64`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_f64.rs:23:46
+  --> $DIR/default_numeric_fallback_f64.rs:24:46
    |
 LL |         let x = if true { (1., 2.) } else { (3., 4.) };
    |                                              ^^ help: consider adding suffix: `3.0_f64`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_f64.rs:23:50
+  --> $DIR/default_numeric_fallback_f64.rs:24:50
    |
 LL |         let x = if true { (1., 2.) } else { (3., 4.) };
    |                                                  ^^ help: consider adding suffix: `4.0_f64`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_f64.rs:24:23
+  --> $DIR/default_numeric_fallback_f64.rs:25:23
    |
 LL |         let x = match 1. {
    |                       ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_f64.rs:25:18
+  --> $DIR/default_numeric_fallback_f64.rs:26:18
    |
 LL |             _ => 1.,
    |                  ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_f64.rs:44:21
+  --> $DIR/default_numeric_fallback_f64.rs:45:21
    |
 LL |             let y = 1.;
    |                     ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_f64.rs:52:21
+  --> $DIR/default_numeric_fallback_f64.rs:53:21
    |
 LL |             let y = 1.;
    |                     ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_f64.rs:58:21
+  --> $DIR/default_numeric_fallback_f64.rs:59:21
    |
 LL |             let y = 1.;
    |                     ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_f64.rs:66:21
+  --> $DIR/default_numeric_fallback_f64.rs:67:21
    |
 LL |             let y = 1.;
    |                     ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_f64.rs:78:9
+  --> $DIR/default_numeric_fallback_f64.rs:79:9
    |
 LL |         1.
    |         ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_f64.rs:84:27
+  --> $DIR/default_numeric_fallback_f64.rs:85:27
    |
 LL |         let f = || -> _ { 1. };
    |                           ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_f64.rs:88:29
+  --> $DIR/default_numeric_fallback_f64.rs:89:29
    |
 LL |         let f = || -> f64 { 1. };
    |                             ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_f64.rs:102:21
+  --> $DIR/default_numeric_fallback_f64.rs:103:21
    |
 LL |         generic_arg(1.);
    |                     ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_f64.rs:105:32
+  --> $DIR/default_numeric_fallback_f64.rs:106:32
    |
 LL |         let x: _ = generic_arg(1.);
    |                                ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_f64.rs:123:28
+  --> $DIR/default_numeric_fallback_f64.rs:124:28
    |
 LL |         GenericStruct { x: 1. };
    |                            ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_f64.rs:126:36
+  --> $DIR/default_numeric_fallback_f64.rs:127:36
    |
 LL |         let _ = GenericStruct { x: 1. };
    |                                    ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_f64.rs:144:24
+  --> $DIR/default_numeric_fallback_f64.rs:145:24
    |
 LL |         GenericEnum::X(1.);
    |                        ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_f64.rs:164:23
+  --> $DIR/default_numeric_fallback_f64.rs:165:23
    |
 LL |         s.generic_arg(1.);
    |                       ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_f64.rs:171:21
+  --> $DIR/default_numeric_fallback_f64.rs:172:21
    |
 LL |             let x = 22.;
    |                     ^^^ help: consider adding suffix: `22.0_f64`
diff --git a/tests/ui/default_numeric_fallback_i32.fixed b/tests/ui/default_numeric_fallback_i32.fixed
index 3f4994f0453..63ac4d5aeb6 100644
--- a/tests/ui/default_numeric_fallback_i32.fixed
+++ b/tests/ui/default_numeric_fallback_i32.fixed
@@ -9,7 +9,8 @@
     clippy::no_effect,
     clippy::unnecessary_operation,
     clippy::branches_sharing_code,
-    clippy::let_unit_value
+    clippy::let_unit_value,
+    clippy::let_with_type_underscore
 )]
 
 #[macro_use]
diff --git a/tests/ui/default_numeric_fallback_i32.rs b/tests/ui/default_numeric_fallback_i32.rs
index 2df0e09787f..28e6eceb80e 100644
--- a/tests/ui/default_numeric_fallback_i32.rs
+++ b/tests/ui/default_numeric_fallback_i32.rs
@@ -9,7 +9,8 @@
     clippy::no_effect,
     clippy::unnecessary_operation,
     clippy::branches_sharing_code,
-    clippy::let_unit_value
+    clippy::let_unit_value,
+    clippy::let_with_type_underscore
 )]
 
 #[macro_use]
diff --git a/tests/ui/default_numeric_fallback_i32.stderr b/tests/ui/default_numeric_fallback_i32.stderr
index 6f219c3fc2b..dd91574d5b3 100644
--- a/tests/ui/default_numeric_fallback_i32.stderr
+++ b/tests/ui/default_numeric_fallback_i32.stderr
@@ -1,5 +1,5 @@
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:21:17
+  --> $DIR/default_numeric_fallback_i32.rs:22:17
    |
 LL |         let x = 22;
    |                 ^^ help: consider adding suffix: `22_i32`
@@ -7,151 +7,151 @@ LL |         let x = 22;
    = note: `-D clippy::default-numeric-fallback` implied by `-D warnings`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:22:18
+  --> $DIR/default_numeric_fallback_i32.rs:23:18
    |
 LL |         let x = [1, 2, 3];
    |                  ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:22:21
+  --> $DIR/default_numeric_fallback_i32.rs:23:21
    |
 LL |         let x = [1, 2, 3];
    |                     ^ help: consider adding suffix: `2_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:22:24
+  --> $DIR/default_numeric_fallback_i32.rs:23:24
    |
 LL |         let x = [1, 2, 3];
    |                        ^ help: consider adding suffix: `3_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:23:28
+  --> $DIR/default_numeric_fallback_i32.rs:24:28
    |
 LL |         let x = if true { (1, 2) } else { (3, 4) };
    |                            ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:23:31
+  --> $DIR/default_numeric_fallback_i32.rs:24:31
    |
 LL |         let x = if true { (1, 2) } else { (3, 4) };
    |                               ^ help: consider adding suffix: `2_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:23:44
+  --> $DIR/default_numeric_fallback_i32.rs:24:44
    |
 LL |         let x = if true { (1, 2) } else { (3, 4) };
    |                                            ^ help: consider adding suffix: `3_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:23:47
+  --> $DIR/default_numeric_fallback_i32.rs:24:47
    |
 LL |         let x = if true { (1, 2) } else { (3, 4) };
    |                                               ^ help: consider adding suffix: `4_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:24:23
+  --> $DIR/default_numeric_fallback_i32.rs:25:23
    |
 LL |         let x = match 1 {
    |                       ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:25:13
+  --> $DIR/default_numeric_fallback_i32.rs:26:13
    |
 LL |             1 => 1,
    |             ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:25:18
+  --> $DIR/default_numeric_fallback_i32.rs:26:18
    |
 LL |             1 => 1,
    |                  ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:26:18
+  --> $DIR/default_numeric_fallback_i32.rs:27:18
    |
 LL |             _ => 2,
    |                  ^ help: consider adding suffix: `2_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:45:21
+  --> $DIR/default_numeric_fallback_i32.rs:46:21
    |
 LL |             let y = 1;
    |                     ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:53:21
+  --> $DIR/default_numeric_fallback_i32.rs:54:21
    |
 LL |             let y = 1;
    |                     ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:59:21
+  --> $DIR/default_numeric_fallback_i32.rs:60:21
    |
 LL |             let y = 1;
    |                     ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:67:21
+  --> $DIR/default_numeric_fallback_i32.rs:68:21
    |
 LL |             let y = 1;
    |                     ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:79:9
+  --> $DIR/default_numeric_fallback_i32.rs:80:9
    |
 LL |         1
    |         ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:85:27
+  --> $DIR/default_numeric_fallback_i32.rs:86:27
    |
 LL |         let f = || -> _ { 1 };
    |                           ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:89:29
+  --> $DIR/default_numeric_fallback_i32.rs:90:29
    |
 LL |         let f = || -> i32 { 1 };
    |                             ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:103:21
+  --> $DIR/default_numeric_fallback_i32.rs:104:21
    |
 LL |         generic_arg(1);
    |                     ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:106:32
+  --> $DIR/default_numeric_fallback_i32.rs:107:32
    |
 LL |         let x: _ = generic_arg(1);
    |                                ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:124:28
+  --> $DIR/default_numeric_fallback_i32.rs:125:28
    |
 LL |         GenericStruct { x: 1 };
    |                            ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:127:36
+  --> $DIR/default_numeric_fallback_i32.rs:128:36
    |
 LL |         let _ = GenericStruct { x: 1 };
    |                                    ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:145:24
+  --> $DIR/default_numeric_fallback_i32.rs:146:24
    |
 LL |         GenericEnum::X(1);
    |                        ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:165:23
+  --> $DIR/default_numeric_fallback_i32.rs:166:23
    |
 LL |         s.generic_arg(1);
    |                       ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:172:21
+  --> $DIR/default_numeric_fallback_i32.rs:173:21
    |
 LL |             let x = 22;
    |                     ^^ help: consider adding suffix: `22_i32`
diff --git a/tests/ui/let_with_type_underscore.rs b/tests/ui/let_with_type_underscore.rs
new file mode 100644
index 00000000000..175718b94c8
--- /dev/null
+++ b/tests/ui/let_with_type_underscore.rs
@@ -0,0 +1,19 @@
+#![allow(unused)]
+#![warn(clippy::let_with_type_underscore)]
+#![allow(clippy::let_unit_value)]
+
+fn func() -> &'static str {
+    ""
+}
+
+fn main() {
+    // Will lint
+    let x: _ = 1;
+    let _: _ = 2;
+    let x: _ = func();
+
+    let x = 1; // Will not lint, Rust inferres this to an integer before Clippy
+    let x = func();
+    let x: Vec<_> = Vec::<u32>::new();
+    let x: [_; 1] = [1];
+}
diff --git a/tests/ui/let_with_type_underscore.stderr b/tests/ui/let_with_type_underscore.stderr
new file mode 100644
index 00000000000..16bf83c708f
--- /dev/null
+++ b/tests/ui/let_with_type_underscore.stderr
@@ -0,0 +1,39 @@
+error: variable declared with type underscore
+  --> $DIR/let_with_type_underscore.rs:11:5
+   |
+LL |     let x: _ = 1;
+   |     ^^^^^^^^^^^^^
+   |
+help: remove the explicit type `_` declaration
+  --> $DIR/let_with_type_underscore.rs:11:10
+   |
+LL |     let x: _ = 1;
+   |          ^^^
+   = note: `-D clippy::let-with-type-underscore` implied by `-D warnings`
+
+error: variable declared with type underscore
+  --> $DIR/let_with_type_underscore.rs:12:5
+   |
+LL |     let _: _ = 2;
+   |     ^^^^^^^^^^^^^
+   |
+help: remove the explicit type `_` declaration
+  --> $DIR/let_with_type_underscore.rs:12:10
+   |
+LL |     let _: _ = 2;
+   |          ^^^
+
+error: variable declared with type underscore
+  --> $DIR/let_with_type_underscore.rs:13:5
+   |
+LL |     let x: _ = func();
+   |     ^^^^^^^^^^^^^^^^^^
+   |
+help: remove the explicit type `_` declaration
+  --> $DIR/let_with_type_underscore.rs:13:10
+   |
+LL |     let x: _ = func();
+   |          ^^^
+
+error: aborting due to 3 previous errors
+
diff --git a/tests/ui/manual_rem_euclid.fixed b/tests/ui/manual_rem_euclid.fixed
index 4cdc0546a74..6916a284a20 100644
--- a/tests/ui/manual_rem_euclid.fixed
+++ b/tests/ui/manual_rem_euclid.fixed
@@ -2,6 +2,7 @@
 // aux-build:macro_rules.rs
 
 #![warn(clippy::manual_rem_euclid)]
+#![allow(clippy::let_with_type_underscore)]
 
 #[macro_use]
 extern crate macro_rules;
diff --git a/tests/ui/manual_rem_euclid.rs b/tests/ui/manual_rem_euclid.rs
index 58a9e20f38b..412dbddb426 100644
--- a/tests/ui/manual_rem_euclid.rs
+++ b/tests/ui/manual_rem_euclid.rs
@@ -2,6 +2,7 @@
 // aux-build:macro_rules.rs
 
 #![warn(clippy::manual_rem_euclid)]
+#![allow(clippy::let_with_type_underscore)]
 
 #[macro_use]
 extern crate macro_rules;
diff --git a/tests/ui/manual_rem_euclid.stderr b/tests/ui/manual_rem_euclid.stderr
index e3122a588b6..6d06654638b 100644
--- a/tests/ui/manual_rem_euclid.stderr
+++ b/tests/ui/manual_rem_euclid.stderr
@@ -1,5 +1,5 @@
 error: manual `rem_euclid` implementation
-  --> $DIR/manual_rem_euclid.rs:19:18
+  --> $DIR/manual_rem_euclid.rs:20:18
    |
 LL |     let _: i32 = ((value % 4) + 4) % 4;
    |                  ^^^^^^^^^^^^^^^^^^^^^ help: consider using: `value.rem_euclid(4)`
@@ -7,31 +7,31 @@ LL |     let _: i32 = ((value % 4) + 4) % 4;
    = note: `-D clippy::manual-rem-euclid` implied by `-D warnings`
 
 error: manual `rem_euclid` implementation
-  --> $DIR/manual_rem_euclid.rs:20:18
+  --> $DIR/manual_rem_euclid.rs:21:18
    |
 LL |     let _: i32 = (4 + (value % 4)) % 4;
    |                  ^^^^^^^^^^^^^^^^^^^^^ help: consider using: `value.rem_euclid(4)`
 
 error: manual `rem_euclid` implementation
-  --> $DIR/manual_rem_euclid.rs:21:18
+  --> $DIR/manual_rem_euclid.rs:22:18
    |
 LL |     let _: i32 = (value % 4 + 4) % 4;
    |                  ^^^^^^^^^^^^^^^^^^^ help: consider using: `value.rem_euclid(4)`
 
 error: manual `rem_euclid` implementation
-  --> $DIR/manual_rem_euclid.rs:22:18
+  --> $DIR/manual_rem_euclid.rs:23:18
    |
 LL |     let _: i32 = (4 + value % 4) % 4;
    |                  ^^^^^^^^^^^^^^^^^^^ help: consider using: `value.rem_euclid(4)`
 
 error: manual `rem_euclid` implementation
-  --> $DIR/manual_rem_euclid.rs:23:22
+  --> $DIR/manual_rem_euclid.rs:24:22
    |
 LL |     let _: i32 = 1 + (4 + value % 4) % 4;
    |                      ^^^^^^^^^^^^^^^^^^^ help: consider using: `value.rem_euclid(4)`
 
 error: manual `rem_euclid` implementation
-  --> $DIR/manual_rem_euclid.rs:12:22
+  --> $DIR/manual_rem_euclid.rs:13:22
    |
 LL |         let _: i32 = ((value % 4) + 4) % 4;
    |                      ^^^^^^^^^^^^^^^^^^^^^ help: consider using: `value.rem_euclid(4)`
@@ -42,25 +42,25 @@ LL |     internal_rem_euclid!();
    = note: this error originates in the macro `internal_rem_euclid` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: manual `rem_euclid` implementation
-  --> $DIR/manual_rem_euclid.rs:49:5
+  --> $DIR/manual_rem_euclid.rs:50:5
    |
 LL |     ((num % 4) + 4) % 4
    |     ^^^^^^^^^^^^^^^^^^^ help: consider using: `num.rem_euclid(4)`
 
 error: manual `rem_euclid` implementation
-  --> $DIR/manual_rem_euclid.rs:54:5
+  --> $DIR/manual_rem_euclid.rs:55:5
    |
 LL |     ((num % 4) + 4) % 4
    |     ^^^^^^^^^^^^^^^^^^^ help: consider using: `num.rem_euclid(4)`
 
 error: manual `rem_euclid` implementation
-  --> $DIR/manual_rem_euclid.rs:66:18
+  --> $DIR/manual_rem_euclid.rs:67:18
    |
 LL |     let _: i32 = ((x % 4) + 4) % 4;
    |                  ^^^^^^^^^^^^^^^^^ help: consider using: `x.rem_euclid(4)`
 
 error: manual `rem_euclid` implementation
-  --> $DIR/manual_rem_euclid.rs:79:18
+  --> $DIR/manual_rem_euclid.rs:80:18
    |
 LL |     let _: i32 = ((x % 4) + 4) % 4;
    |                  ^^^^^^^^^^^^^^^^^ help: consider using: `x.rem_euclid(4)`
-- 
cgit 1.4.1-3-g733a5


From 797d8bff0807acbd36d079401fc99dbf042f71e9 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Fri, 10 Mar 2023 11:07:28 -0500
Subject: Don't lint `manual_clamp` in const contexts.

---
 clippy_lints/src/manual_clamp.rs |  7 ++++---
 tests/ui/manual_clamp.rs         | 19 +++++++++++++++++++
 2 files changed, 23 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_clamp.rs b/clippy_lints/src/manual_clamp.rs
index f239736d38a..440362b96b4 100644
--- a/clippy_lints/src/manual_clamp.rs
+++ b/clippy_lints/src/manual_clamp.rs
@@ -6,7 +6,8 @@ use clippy_utils::ty::implements_trait;
 use clippy_utils::visitors::is_const_evaluatable;
 use clippy_utils::MaybePath;
 use clippy_utils::{
-    eq_expr_value, is_diag_trait_item, is_trait_method, path_res, path_to_local_id, peel_blocks, peel_blocks_with_stmt,
+    eq_expr_value, in_constant, is_diag_trait_item, is_trait_method, path_res, path_to_local_id, peel_blocks,
+    peel_blocks_with_stmt,
 };
 use itertools::Itertools;
 use rustc_errors::Applicability;
@@ -117,7 +118,7 @@ impl<'tcx> LateLintPass<'tcx> for ManualClamp {
         if !self.msrv.meets(msrvs::CLAMP) {
             return;
         }
-        if !expr.span.from_expansion() {
+        if !expr.span.from_expansion() && !in_constant(cx, expr.hir_id) {
             let suggestion = is_if_elseif_else_pattern(cx, expr)
                 .or_else(|| is_max_min_pattern(cx, expr))
                 .or_else(|| is_call_max_min_pattern(cx, expr))
@@ -130,7 +131,7 @@ impl<'tcx> LateLintPass<'tcx> for ManualClamp {
     }
 
     fn check_block(&mut self, cx: &LateContext<'tcx>, block: &'tcx Block<'tcx>) {
-        if !self.msrv.meets(msrvs::CLAMP) {
+        if !self.msrv.meets(msrvs::CLAMP) || in_constant(cx, block.hir_id) {
             return;
         }
         for suggestion in is_two_if_pattern(cx, block) {
diff --git a/tests/ui/manual_clamp.rs b/tests/ui/manual_clamp.rs
index f7902e6fd53..cdfd8e4c3fe 100644
--- a/tests/ui/manual_clamp.rs
+++ b/tests/ui/manual_clamp.rs
@@ -326,3 +326,22 @@ fn msrv_1_50() {
         input
     };
 }
+
+const fn _const() {
+    let (input, min, max) = (0, -1, 2);
+    let _ = if input < min {
+        min
+    } else if input > max {
+        max
+    } else {
+        input
+    };
+
+    let mut x = input;
+    if max < x {
+        let x = max;
+    }
+    if min > x {
+        x = min;
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 0f1474ea270fb3b5f7c0db295b2817028acdb97a Mon Sep 17 00:00:00 2001
From: blyxyas <blyxyas@gmail.com>
Date: Sat, 11 Mar 2023 00:23:58 +0100
Subject: Add `allow_attribute` lint

---
 CHANGELOG.md                        |  1 +
 clippy_lints/src/allow_attribute.rs | 91 +++++++++++++++++++++++++++++++++++++
 clippy_lints/src/declared_lints.rs  |  1 +
 clippy_lints/src/lib.rs             |  6 +++
 tests/ui/allow_attribute.fixed      | 18 ++++++++
 tests/ui/allow_attribute.rs         | 18 ++++++++
 tests/ui/allow_attribute.stderr     | 10 ++++
 7 files changed, 145 insertions(+)
 create mode 100644 clippy_lints/src/allow_attribute.rs
 create mode 100644 tests/ui/allow_attribute.fixed
 create mode 100644 tests/ui/allow_attribute.rs
 create mode 100644 tests/ui/allow_attribute.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index da7042f4440..2b00fd962ca 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4382,6 +4382,7 @@ Released 2018-09-13
 <!-- begin autogenerated links to lint list -->
 [`absurd_extreme_comparisons`]: https://rust-lang.github.io/rust-clippy/master/index.html#absurd_extreme_comparisons
 [`alloc_instead_of_core`]: https://rust-lang.github.io/rust-clippy/master/index.html#alloc_instead_of_core
+[`allow_attribute`]: https://rust-lang.github.io/rust-clippy/master/index.html#allow_attribute
 [`allow_attributes_without_reason`]: https://rust-lang.github.io/rust-clippy/master/index.html#allow_attributes_without_reason
 [`almost_complete_letter_range`]: https://rust-lang.github.io/rust-clippy/master/index.html#almost_complete_letter_range
 [`almost_complete_range`]: https://rust-lang.github.io/rust-clippy/master/index.html#almost_complete_range
diff --git a/clippy_lints/src/allow_attribute.rs b/clippy_lints/src/allow_attribute.rs
new file mode 100644
index 00000000000..2970d467f6f
--- /dev/null
+++ b/clippy_lints/src/allow_attribute.rs
@@ -0,0 +1,91 @@
+use ast::{AttrStyle, MetaItemKind};
+use clippy_utils::{diagnostics::span_lint_and_sugg, source::snippet};
+use rustc_ast as ast;
+use rustc_errors::Applicability;
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::{symbol::Ident, BytePos};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Detects uses of the `#[allow]` attribute and suggests to replace it with the new `#[expect]` attribute implemented by `#![feature(lint_reasons)]` ([RFC 2383](https://rust-lang.github.io/rfcs/2383-lint-reasons.html))
+    /// ### Why is this bad?
+    /// Using `#[allow]` isn't bad, but `#[expect]` may be preferred as it lints if the code **doesn't** produce a warning.
+    /// ### Example
+    /// ```rust
+    /// #[allow(unused_mut)]
+    /// fn foo() -> usize {
+    ///    let mut a = Vec::new();
+    ///    a.len()
+    ///}
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// #[expect(unused_mut)]
+    /// fn foo() -> usize {
+    ///     let mut a = Vec::new();
+    ///     a.len()
+    /// }
+    /// ```
+    #[clippy::version = "1.69.0"]
+    pub ALLOW_ATTRIBUTE,
+    restriction,
+    "`#[allow]` will not trigger if a warning isn't found. `#[expect]` triggers if there are no warnings."
+}
+
+pub struct AllowAttribute {
+    pub lint_reasons_active: bool,
+}
+
+impl_lint_pass!(AllowAttribute => [ALLOW_ATTRIBUTE]);
+
+impl LateLintPass<'_> for AllowAttribute {
+    // Separate each crate's features.
+    fn check_crate_post(&mut self, _: &LateContext<'_>) {
+        self.lint_reasons_active = false;
+    }
+    fn check_attribute(&mut self, cx: &LateContext<'_>, attr: &ast::Attribute) {
+        // Check inner attributes
+
+        if_chain! {
+            if let AttrStyle::Inner = attr.style;
+            if attr.ident()
+            .unwrap_or(Ident::with_dummy_span(sym!(empty))) // Will not trigger if doesn't have an ident.
+            .name == sym!(feature);
+            if let ast::AttrKind::Normal(normal) = &attr.kind;
+            if let Some(MetaItemKind::List(list)) = normal.item.meta_kind();
+            if list[0].ident().unwrap().name == sym!(lint_reasons);
+            then {
+                self.lint_reasons_active = true;
+            }
+        }
+
+        // Check outer attributes
+
+        if_chain! {
+            if let AttrStyle::Outer = attr.style;
+            if attr.ident()
+            .unwrap_or(Ident::with_dummy_span(sym!(empty))) // Will not trigger if doesn't have an ident.
+            .name == sym!(allow);
+            if self.lint_reasons_active;
+            then {
+                span_lint_and_sugg(
+                    cx,
+                    ALLOW_ATTRIBUTE,
+                    attr.span,
+                    "#[allow] attribute found",
+                    "replace it with",
+                    format!("#[expect{})]", snippet(
+                        cx,
+                        attr.ident().unwrap().span
+                        .with_lo(
+                            attr.ident().unwrap().span.hi() + BytePos(2) // Cut [(
+                        )
+                        .with_hi(
+                            attr.meta().unwrap().span.hi() - BytePos(2) // Cut )]
+                        )
+                        , "...")), Applicability::MachineApplicable);
+            }
+        }
+    }
+}
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index cc6024b87cd..73f74d59f4a 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -35,6 +35,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::utils::internal_lints::produce_ice::PRODUCE_ICE_INFO,
     #[cfg(feature = "internal")]
     crate::utils::internal_lints::unnecessary_def_path::UNNECESSARY_DEF_PATH_INFO,
+    crate::allow_attribute::ALLOW_ATTRIBUTE_INFO,
     crate::almost_complete_range::ALMOST_COMPLETE_RANGE_INFO,
     crate::approx_const::APPROX_CONSTANT_INFO,
     crate::as_conversions::AS_CONVERSIONS_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 491732be208..51da5d1ba49 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -67,6 +67,7 @@ mod declared_lints;
 mod renamed_lints;
 
 // begin lints modules, do not remove this comment, it’s used in `update_lints`
+mod allow_attribute;
 mod almost_complete_range;
 mod approx_const;
 mod as_conversions;
@@ -933,6 +934,11 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(missing_assert_message::MissingAssertMessage));
     store.register_early_pass(|| Box::new(redundant_async_block::RedundantAsyncBlock));
     store.register_late_pass(|_| Box::new(let_with_type_underscore::UnderscoreTyped));
+    store.register_late_pass(|_| {
+        Box::new(allow_attribute::AllowAttribute {
+            lint_reasons_active: false,
+        })
+    });
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/tests/ui/allow_attribute.fixed b/tests/ui/allow_attribute.fixed
new file mode 100644
index 00000000000..5f445a0bd96
--- /dev/null
+++ b/tests/ui/allow_attribute.fixed
@@ -0,0 +1,18 @@
+// run-rustfix
+#![allow(unused)]
+#![warn(clippy::allow_attribute)]
+#![feature(lint_reasons)]
+
+fn main() {}
+
+// Using clippy::needless_borrow just as a placeholder, it isn't relevant.
+
+// Should lint
+#[expect(dead_code)]
+struct T1;
+
+struct T2; // Should not lint
+#[deny(clippy::needless_borrow)] // Should not lint
+struct T3;
+#[warn(clippy::needless_borrow)] // Should not lint
+struct T4;
diff --git a/tests/ui/allow_attribute.rs b/tests/ui/allow_attribute.rs
new file mode 100644
index 00000000000..36d2e3e27ab
--- /dev/null
+++ b/tests/ui/allow_attribute.rs
@@ -0,0 +1,18 @@
+// run-rustfix
+#![allow(unused)]
+#![warn(clippy::allow_attribute)]
+#![feature(lint_reasons)]
+
+fn main() {}
+
+// Using clippy::needless_borrow just as a placeholder, it isn't relevant.
+
+// Should lint
+#[allow(dead_code)]
+struct T1;
+
+struct T2; // Should not lint
+#[deny(clippy::needless_borrow)] // Should not lint
+struct T3;
+#[warn(clippy::needless_borrow)] // Should not lint
+struct T4;
diff --git a/tests/ui/allow_attribute.stderr b/tests/ui/allow_attribute.stderr
new file mode 100644
index 00000000000..6f90661577c
--- /dev/null
+++ b/tests/ui/allow_attribute.stderr
@@ -0,0 +1,10 @@
+error: #[allow] attribute found
+  --> $DIR/allow_attribute.rs:11:1
+   |
+LL | #[allow(dead_code)]
+   | ^^^^^^^^^^^^^^^^^^^ help: replace it with: `#[expect(dead_code)]`
+   |
+   = note: `-D clippy::allow-attribute` implied by `-D warnings`
+
+error: aborting due to previous error
+
-- 
cgit 1.4.1-3-g733a5


From 59568962aed2c4aff72360e4fbd3b9c04371dbec Mon Sep 17 00:00:00 2001
From: blyxyas <blyxyas@gmail.com>
Date: Sat, 11 Mar 2023 00:48:50 +0100
Subject: Fix code fragment

---
 clippy_lints/src/allow_attribute.rs | 1 +
 1 file changed, 1 insertion(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/allow_attribute.rs b/clippy_lints/src/allow_attribute.rs
index 2970d467f6f..805c804119a 100644
--- a/clippy_lints/src/allow_attribute.rs
+++ b/clippy_lints/src/allow_attribute.rs
@@ -21,6 +21,7 @@ declare_clippy_lint! {
     /// ```
     /// Use instead:
     /// ```rust
+    /// # #![feature(lint_reasons)]
     /// #[expect(unused_mut)]
     /// fn foo() -> usize {
     ///     let mut a = Vec::new();
-- 
cgit 1.4.1-3-g733a5


From 1cf72183cfe0a29708130f59c79176128b06fcae Mon Sep 17 00:00:00 2001
From: blyxyas <blyxyas@gmail.com>
Date: Sat, 11 Mar 2023 01:08:03 +0100
Subject: Add ignore flag to code fragments

---
 clippy_lints/src/allow_attribute.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/allow_attribute.rs b/clippy_lints/src/allow_attribute.rs
index 805c804119a..2258b973307 100644
--- a/clippy_lints/src/allow_attribute.rs
+++ b/clippy_lints/src/allow_attribute.rs
@@ -12,7 +12,7 @@ declare_clippy_lint! {
     /// ### Why is this bad?
     /// Using `#[allow]` isn't bad, but `#[expect]` may be preferred as it lints if the code **doesn't** produce a warning.
     /// ### Example
-    /// ```rust
+    /// ```rust,ignore
     /// #[allow(unused_mut)]
     /// fn foo() -> usize {
     ///    let mut a = Vec::new();
@@ -20,7 +20,7 @@ declare_clippy_lint! {
     ///}
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```rust,ignore
     /// # #![feature(lint_reasons)]
     /// #[expect(unused_mut)]
     /// fn foo() -> usize {
-- 
cgit 1.4.1-3-g733a5


From 2d572d4a9c20a11a3aa75a7fdd9168cc95c60d4c Mon Sep 17 00:00:00 2001
From: blyxyas <blyxyas@gmail.com>
Date: Sat, 11 Mar 2023 13:11:27 +0100
Subject: Replace list indexing for `.get` (fail-safe)

---
 clippy_lints/src/allow_attribute.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/allow_attribute.rs b/clippy_lints/src/allow_attribute.rs
index 2258b973307..defd14da9ef 100644
--- a/clippy_lints/src/allow_attribute.rs
+++ b/clippy_lints/src/allow_attribute.rs
@@ -55,7 +55,8 @@ impl LateLintPass<'_> for AllowAttribute {
             .name == sym!(feature);
             if let ast::AttrKind::Normal(normal) = &attr.kind;
             if let Some(MetaItemKind::List(list)) = normal.item.meta_kind();
-            if list[0].ident().unwrap().name == sym!(lint_reasons);
+            if let Some(symbol) = list.get(0);
+            if symbol.ident().unwrap().name == sym!(lint_reasons);
             then {
                 self.lint_reasons_active = true;
             }
-- 
cgit 1.4.1-3-g733a5


From d65c9a5700454ab2a3bd81dccff610ad13855d14 Mon Sep 17 00:00:00 2001
From: blyxyas <blyxyas@gmail.com>
Date: Sat, 11 Mar 2023 21:30:34 +0100
Subject: Extend tests + improve description + general improvement

---
 clippy_lints/src/allow_attribute.rs | 84 ++++++++++++++++---------------------
 clippy_lints/src/lib.rs             |  6 +--
 tests/ui/allow_attribute.fixed      |  7 ++++
 tests/ui/allow_attribute.rs         |  7 ++++
 tests/ui/allow_attribute.stderr     | 12 ++++--
 5 files changed, 59 insertions(+), 57 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/allow_attribute.rs b/clippy_lints/src/allow_attribute.rs
index defd14da9ef..28fc45d0554 100644
--- a/clippy_lints/src/allow_attribute.rs
+++ b/clippy_lints/src/allow_attribute.rs
@@ -1,16 +1,27 @@
-use ast::{AttrStyle, MetaItemKind};
-use clippy_utils::{diagnostics::span_lint_and_sugg, source::snippet};
+use ast::AttrStyle;
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use rustc_ast as ast;
 use rustc_errors::Applicability;
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::{symbol::Ident, BytePos};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
-    /// ### What it does
-    /// Detects uses of the `#[allow]` attribute and suggests to replace it with the new `#[expect]` attribute implemented by `#![feature(lint_reasons)]` ([RFC 2383](https://rust-lang.github.io/rfcs/2383-lint-reasons.html))
+        /// Detects uses of the `#[allow]` attribute and suggests replacing it with
+    /// the `#[expect]` (See [RFC 2383](https://rust-lang.github.io/rfcs/2383-lint-reasons.html))
+    ///
+    /// The expect attribute is still unstable and requires the `lint_reasons`
+    /// on nightly. It can be enabled by adding `#![feature(lint_reasons)]` to
+    /// the crate root.
+    ///
+    /// This lint only warns outer attributes (`#[allow]`), as inner attributes
+    /// (`#![allow]`) are usually used to enable or disable lints on a global scale.
+    ///
     /// ### Why is this bad?
-    /// Using `#[allow]` isn't bad, but `#[expect]` may be preferred as it lints if the code **doesn't** produce a warning.
+    ///
+    /// `#[expect]` attributes suppress the lint emission, but emit a warning, if
+    /// the expectation is unfulfilled. This can be useful to be notified when the
+    /// lint is no longer triggered.
+    ///
     /// ### Example
     /// ```rust,ignore
     /// #[allow(unused_mut)]
@@ -34,59 +45,34 @@ declare_clippy_lint! {
     "`#[allow]` will not trigger if a warning isn't found. `#[expect]` triggers if there are no warnings."
 }
 
-pub struct AllowAttribute {
-    pub lint_reasons_active: bool,
-}
-
-impl_lint_pass!(AllowAttribute => [ALLOW_ATTRIBUTE]);
+declare_lint_pass!(AllowAttribute => [ALLOW_ATTRIBUTE]);
 
 impl LateLintPass<'_> for AllowAttribute {
     // Separate each crate's features.
-    fn check_crate_post(&mut self, _: &LateContext<'_>) {
-        self.lint_reasons_active = false;
-    }
     fn check_attribute(&mut self, cx: &LateContext<'_>, attr: &ast::Attribute) {
-        // Check inner attributes
-
-        if_chain! {
-            if let AttrStyle::Inner = attr.style;
-            if attr.ident()
-            .unwrap_or(Ident::with_dummy_span(sym!(empty))) // Will not trigger if doesn't have an ident.
-            .name == sym!(feature);
-            if let ast::AttrKind::Normal(normal) = &attr.kind;
-            if let Some(MetaItemKind::List(list)) = normal.item.meta_kind();
-            if let Some(symbol) = list.get(0);
-            if symbol.ident().unwrap().name == sym!(lint_reasons);
-            then {
-                self.lint_reasons_active = true;
-            }
-        }
-
-        // Check outer attributes
-
         if_chain! {
+            if cx.tcx.features().lint_reasons;
             if let AttrStyle::Outer = attr.style;
-            if attr.ident()
-            .unwrap_or(Ident::with_dummy_span(sym!(empty))) // Will not trigger if doesn't have an ident.
-            .name == sym!(allow);
-            if self.lint_reasons_active;
+            if let Some(ident) = attr.ident();
+            if ident.name == rustc_span::symbol::sym::allow;
             then {
                 span_lint_and_sugg(
                     cx,
                     ALLOW_ATTRIBUTE,
-                    attr.span,
+                    ident.span,
                     "#[allow] attribute found",
-                    "replace it with",
-                    format!("#[expect{})]", snippet(
-                        cx,
-                        attr.ident().unwrap().span
-                        .with_lo(
-                            attr.ident().unwrap().span.hi() + BytePos(2) // Cut [(
-                        )
-                        .with_hi(
-                            attr.meta().unwrap().span.hi() - BytePos(2) // Cut )]
-                        )
-                        , "...")), Applicability::MachineApplicable);
+                    "replace it with", "expect".into()
+                    // format!("expect{}", snippet(
+                    //     cx,
+                    //     ident.span
+                    //     .with_lo(
+                    //         ident.span.hi() + BytePos(2) // Cut *(
+                    //     )
+                    //     .with_hi(
+                    //         attr.meta().unwrap().span.hi() - BytePos(1) // Cut )
+                    //     )
+                    //     , "..."))
+                    , Applicability::MachineApplicable);
             }
         }
     }
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 51da5d1ba49..a3c65a69c99 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -934,11 +934,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(missing_assert_message::MissingAssertMessage));
     store.register_early_pass(|| Box::new(redundant_async_block::RedundantAsyncBlock));
     store.register_late_pass(|_| Box::new(let_with_type_underscore::UnderscoreTyped));
-    store.register_late_pass(|_| {
-        Box::new(allow_attribute::AllowAttribute {
-            lint_reasons_active: false,
-        })
-    });
+    store.register_late_pass(|_| Box::new(allow_attribute::AllowAttribute));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/tests/ui/allow_attribute.fixed b/tests/ui/allow_attribute.fixed
index 5f445a0bd96..01759ced09d 100644
--- a/tests/ui/allow_attribute.fixed
+++ b/tests/ui/allow_attribute.fixed
@@ -16,3 +16,10 @@ struct T2; // Should not lint
 struct T3;
 #[warn(clippy::needless_borrow)] // Should not lint
 struct T4;
+// `panic = "unwind"` should always be true
+#[cfg_attr(panic = "unwind", expect(dead_code))]
+struct CfgT;
+
+fn ignore_inner_attr() {
+    #![allow(unused)] // Should not lint
+}
diff --git a/tests/ui/allow_attribute.rs b/tests/ui/allow_attribute.rs
index 36d2e3e27ab..b8e341fe9e4 100644
--- a/tests/ui/allow_attribute.rs
+++ b/tests/ui/allow_attribute.rs
@@ -16,3 +16,10 @@ struct T2; // Should not lint
 struct T3;
 #[warn(clippy::needless_borrow)] // Should not lint
 struct T4;
+// `panic = "unwind"` should always be true
+#[cfg_attr(panic = "unwind", allow(dead_code))]
+struct CfgT;
+
+fn ignore_inner_attr() {
+    #![allow(unused)] // Should not lint
+}
diff --git a/tests/ui/allow_attribute.stderr b/tests/ui/allow_attribute.stderr
index 6f90661577c..58b7323b068 100644
--- a/tests/ui/allow_attribute.stderr
+++ b/tests/ui/allow_attribute.stderr
@@ -1,10 +1,16 @@
 error: #[allow] attribute found
-  --> $DIR/allow_attribute.rs:11:1
+  --> $DIR/allow_attribute.rs:11:3
    |
 LL | #[allow(dead_code)]
-   | ^^^^^^^^^^^^^^^^^^^ help: replace it with: `#[expect(dead_code)]`
+   |   ^^^^^ help: replace it with: `expect`
    |
    = note: `-D clippy::allow-attribute` implied by `-D warnings`
 
-error: aborting due to previous error
+error: #[allow] attribute found
+  --> $DIR/allow_attribute.rs:20:30
+   |
+LL | #[cfg_attr(panic = "unwind", allow(dead_code))]
+   |                              ^^^^^ help: replace it with: `expect`
+
+error: aborting due to 2 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 8a9492aa03792f17c7b63b15d10ae9813daa4c4a Mon Sep 17 00:00:00 2001
From: J-ZhengLi <lizheng135@huawei.com>
Date: Thu, 16 Feb 2023 17:47:28 +0800
Subject: enhance [`ifs_same_cond`] to lint same immutable method calls as well

---
 clippy_lints/src/copies.rs    | 26 +++++++++++++++++++++++---
 tests/ui/ifs_same_cond.rs     | 10 ++++++++++
 tests/ui/ifs_same_cond.stderr | 14 +++++++++++++-
 3 files changed, 46 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/copies.rs b/clippy_lints/src/copies.rs
index f10c35cde52..d729a5430c7 100644
--- a/clippy_lints/src/copies.rs
+++ b/clippy_lints/src/copies.rs
@@ -3,8 +3,8 @@ use clippy_utils::source::{first_line_of_span, indent_of, reindent_multiline, sn
 use clippy_utils::ty::needs_ordered_drop;
 use clippy_utils::visitors::for_each_expr;
 use clippy_utils::{
-    capture_local_usage, eq_expr_value, get_enclosing_block, hash_expr, hash_stmt, if_sequence, is_else_clause,
-    is_lint_allowed, path_to_local, search_same, ContainsName, HirEqInterExpr, SpanlessEq,
+    capture_local_usage, eq_expr_value, find_binding_init, get_enclosing_block, hash_expr, hash_stmt, if_sequence,
+    is_else_clause, is_lint_allowed, path_to_local, search_same, ContainsName, HirEqInterExpr, SpanlessEq,
 };
 use core::iter;
 use core::ops::ControlFlow;
@@ -549,7 +549,27 @@ fn check_for_warn_of_moved_symbol(cx: &LateContext<'_>, symbols: &[(HirId, Symbo
 
 /// Implementation of `IFS_SAME_COND`.
 fn lint_same_cond(cx: &LateContext<'_>, conds: &[&Expr<'_>]) {
-    for (i, j) in search_same(conds, |e| hash_expr(cx, e), |lhs, rhs| eq_expr_value(cx, lhs, rhs)) {
+    for (i, j) in search_same(
+        conds,
+        |e| hash_expr(cx, e),
+        |lhs, rhs| {
+            // If any side (ex. lhs) is a method call, and the caller is not mutable,
+            // then we can ignore side effects?
+            if let ExprKind::MethodCall(_, caller, _, _) = lhs.kind {
+                if path_to_local(caller)
+                    .and_then(|hir_id| find_binding_init(cx, hir_id))
+                    .is_some()
+                {
+                    // caller is not declared as mutable
+                    SpanlessEq::new(cx).eq_expr(lhs, rhs)
+                } else {
+                    false
+                }
+            } else {
+                eq_expr_value(cx, lhs, rhs)
+            }
+        },
+    ) {
         span_lint_and_note(
             cx,
             IFS_SAME_COND,
diff --git a/tests/ui/ifs_same_cond.rs b/tests/ui/ifs_same_cond.rs
index 9850fc0919e..e68ec6a8573 100644
--- a/tests/ui/ifs_same_cond.rs
+++ b/tests/ui/ifs_same_cond.rs
@@ -43,4 +43,14 @@ fn ifs_same_cond() {
     }
 }
 
+fn issue10272() {
+    let a = String::from("ha");
+    if a.contains("ah") {
+    } else if a.contains("ah") {
+        // Trigger this lint
+    } else if a.contains("ha") {
+    } else if a == "wow" {
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/ifs_same_cond.stderr b/tests/ui/ifs_same_cond.stderr
index 4113087327a..9519f6904cb 100644
--- a/tests/ui/ifs_same_cond.stderr
+++ b/tests/ui/ifs_same_cond.stderr
@@ -35,5 +35,17 @@ note: same as this
 LL |     if 2 * a == 1 {
    |        ^^^^^^^^^^
 
-error: aborting due to 3 previous errors
+error: this `if` has the same condition as a previous `if`
+  --> $DIR/ifs_same_cond.rs:49:15
+   |
+LL |     } else if a.contains("ah") {
+   |               ^^^^^^^^^^^^^^^^
+   |
+note: same as this
+  --> $DIR/ifs_same_cond.rs:48:8
+   |
+LL |     if a.contains("ah") {
+   |        ^^^^^^^^^^^^^^^^
+
+error: aborting due to 4 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From f0ae2b71ca4053db3b86c20e7d612ecc11d50ee2 Mon Sep 17 00:00:00 2001
From: J-ZhengLi <lizheng135@huawei.com>
Date: Fri, 24 Feb 2023 10:46:07 +0800
Subject: make [`ifs_same_cond`] use `ignore_interior_mutablility`
 configuration

---
 clippy_lints/src/copies.rs                   | 70 ++++++++++++++++++++++------
 clippy_lints/src/lib.rs                      |  3 +-
 clippy_lints/src/utils/conf.rs               |  2 +-
 tests/ui-toml/ifs_same_cond/clippy.toml      |  1 +
 tests/ui-toml/ifs_same_cond/ifs_same_cond.rs | 24 ++++++++++
 tests/ui/ifs_same_cond.rs                    |  8 ++++
 6 files changed, 91 insertions(+), 17 deletions(-)
 create mode 100644 tests/ui-toml/ifs_same_cond/clippy.toml
 create mode 100644 tests/ui-toml/ifs_same_cond/ifs_same_cond.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/copies.rs b/clippy_lints/src/copies.rs
index d729a5430c7..39f8f7220f1 100644
--- a/clippy_lints/src/copies.rs
+++ b/clippy_lints/src/copies.rs
@@ -3,16 +3,19 @@ use clippy_utils::source::{first_line_of_span, indent_of, reindent_multiline, sn
 use clippy_utils::ty::needs_ordered_drop;
 use clippy_utils::visitors::for_each_expr;
 use clippy_utils::{
-    capture_local_usage, eq_expr_value, find_binding_init, get_enclosing_block, hash_expr, hash_stmt, if_sequence,
-    is_else_clause, is_lint_allowed, path_to_local, search_same, ContainsName, HirEqInterExpr, SpanlessEq,
+    capture_local_usage, def_path_def_ids, eq_expr_value, find_binding_init, get_enclosing_block, hash_expr, hash_stmt,
+    if_sequence, is_else_clause, is_lint_allowed, path_to_local, search_same, ContainsName, HirEqInterExpr, SpanlessEq,
 };
 use core::iter;
 use core::ops::ControlFlow;
+use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Applicability;
+use rustc_hir::def_id::DefId;
 use rustc_hir::intravisit;
 use rustc_hir::{BinOpKind, Block, Expr, ExprKind, HirId, HirIdSet, Stmt, StmtKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_middle::query::Key;
+use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::hygiene::walk_chain;
 use rustc_span::source_map::SourceMap;
 use rustc_span::{BytePos, Span, Symbol};
@@ -159,7 +162,19 @@ declare_clippy_lint! {
     "`if` statement with shared code in all blocks"
 }
 
-declare_lint_pass!(CopyAndPaste => [
+pub struct CopyAndPaste {
+    ignore_interior_mutability: Vec<String>,
+}
+
+impl CopyAndPaste {
+    pub fn new(ignore_interior_mutability: Vec<String>) -> Self {
+        Self {
+            ignore_interior_mutability,
+        }
+    }
+}
+
+impl_lint_pass!(CopyAndPaste => [
     IFS_SAME_COND,
     SAME_FUNCTIONS_IN_IF_CONDITION,
     IF_SAME_THEN_ELSE,
@@ -170,7 +185,14 @@ impl<'tcx> LateLintPass<'tcx> for CopyAndPaste {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if !expr.span.from_expansion() && matches!(expr.kind, ExprKind::If(..)) && !is_else_clause(cx.tcx, expr) {
             let (conds, blocks) = if_sequence(expr);
-            lint_same_cond(cx, &conds);
+            let mut ignored_ty_ids = FxHashSet::default();
+            for ignored_ty in &self.ignore_interior_mutability {
+                let path: Vec<&str> = ignored_ty.split("::").collect();
+                for id in def_path_def_ids(cx, path.as_slice()) {
+                    ignored_ty_ids.insert(id);
+                }
+            }
+            lint_same_cond(cx, &conds, &ignored_ty_ids);
             lint_same_fns_in_if_cond(cx, &conds);
             let all_same =
                 !is_lint_allowed(cx, IF_SAME_THEN_ELSE, expr.hir_id) && lint_if_same_then_else(cx, &conds, &blocks);
@@ -547,23 +569,41 @@ fn check_for_warn_of_moved_symbol(cx: &LateContext<'_>, symbols: &[(HirId, Symbo
     })
 }
 
+fn method_caller_is_ignored_or_mutable(
+    cx: &LateContext<'_>,
+    caller_expr: &Expr<'_>,
+    ignored_ty_ids: &FxHashSet<DefId>,
+) -> bool {
+    let caller_ty = cx.typeck_results().expr_ty(caller_expr);
+    let is_ignored_ty = if let Some(adt_id) = caller_ty.ty_adt_id() && ignored_ty_ids.contains(&adt_id) {
+        true
+    } else {
+        false
+    };
+
+    if is_ignored_ty
+        || caller_ty.is_mutable_ptr()
+        || path_to_local(caller_expr)
+            .and_then(|hid| find_binding_init(cx, hid))
+            .is_none()
+    {
+        return true;
+    }
+
+    false
+}
+
 /// Implementation of `IFS_SAME_COND`.
-fn lint_same_cond(cx: &LateContext<'_>, conds: &[&Expr<'_>]) {
+fn lint_same_cond(cx: &LateContext<'_>, conds: &[&Expr<'_>], ignored_ty_ids: &FxHashSet<DefId>) {
     for (i, j) in search_same(
         conds,
         |e| hash_expr(cx, e),
         |lhs, rhs| {
-            // If any side (ex. lhs) is a method call, and the caller is not mutable,
-            // then we can ignore side effects?
             if let ExprKind::MethodCall(_, caller, _, _) = lhs.kind {
-                if path_to_local(caller)
-                    .and_then(|hir_id| find_binding_init(cx, hir_id))
-                    .is_some()
-                {
-                    // caller is not declared as mutable
-                    SpanlessEq::new(cx).eq_expr(lhs, rhs)
-                } else {
+                if method_caller_is_ignored_or_mutable(cx, caller, ignored_ty_ids) {
                     false
+                } else {
+                    SpanlessEq::new(cx).eq_expr(lhs, rhs)
                 }
             } else {
                 eq_expr_value(cx, lhs, rhs)
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 491732be208..bde84686cc1 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -656,7 +656,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(empty_enum::EmptyEnum));
     store.register_late_pass(|_| Box::new(invalid_upcast_comparisons::InvalidUpcastComparisons));
     store.register_late_pass(|_| Box::new(regex::Regex));
-    store.register_late_pass(|_| Box::new(copies::CopyAndPaste));
+    let ignore_interior_mutability = conf.ignore_interior_mutability.clone();
+    store.register_late_pass(move |_| Box::new(copies::CopyAndPaste::new(ignore_interior_mutability.clone())));
     store.register_late_pass(|_| Box::new(copy_iterator::CopyIterator));
     store.register_late_pass(|_| Box::new(format::UselessFormat));
     store.register_late_pass(|_| Box::new(swap::Swap));
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 1c7f3e96db8..8ba252425a3 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -437,7 +437,7 @@ define_Conf! {
     ///
     /// The maximum size of the `Err`-variant in a `Result` returned from a function
     (large_error_threshold: u64 = 128),
-    /// Lint: MUTABLE_KEY_TYPE.
+    /// Lint: MUTABLE_KEY_TYPE, IFS_SAME_COND.
     ///
     /// A list of paths to types that should be treated like `Arc`, i.e. ignored but
     /// for the generic parameters for determining interior mutability
diff --git a/tests/ui-toml/ifs_same_cond/clippy.toml b/tests/ui-toml/ifs_same_cond/clippy.toml
new file mode 100644
index 00000000000..1615d970c68
--- /dev/null
+++ b/tests/ui-toml/ifs_same_cond/clippy.toml
@@ -0,0 +1 @@
+ignore-interior-mutability = ["std::cell::Cell"]
\ No newline at end of file
diff --git a/tests/ui-toml/ifs_same_cond/ifs_same_cond.rs b/tests/ui-toml/ifs_same_cond/ifs_same_cond.rs
new file mode 100644
index 00000000000..92438e7d1f2
--- /dev/null
+++ b/tests/ui-toml/ifs_same_cond/ifs_same_cond.rs
@@ -0,0 +1,24 @@
+#![warn(clippy::ifs_same_cond)]
+#![allow(clippy::if_same_then_else, clippy::comparison_chain)]
+
+fn main() {}
+
+fn issue10272() {
+    use std::cell::Cell;
+
+    let x = Cell::new(true);
+    if x.get() {
+    } else if !x.take() {
+    } else if x.get() {
+        // ok, x is interior mutable type
+    } else {
+    }
+
+    let a = [Cell::new(true)];
+    if a[0].get() {
+    } else if a[0].take() {
+    } else if a[0].get() {
+        // ok, a contains interior mutable type
+    } else {
+    }
+}
diff --git a/tests/ui/ifs_same_cond.rs b/tests/ui/ifs_same_cond.rs
index e68ec6a8573..ae91611c472 100644
--- a/tests/ui/ifs_same_cond.rs
+++ b/tests/ui/ifs_same_cond.rs
@@ -51,6 +51,14 @@ fn issue10272() {
     } else if a.contains("ha") {
     } else if a == "wow" {
     }
+
+    let p: *mut i8 = std::ptr::null_mut();
+    if p.is_null() {
+    } else if p.align_offset(0) == 0 {
+    } else if p.is_null() {
+        // ok, p is mutable pointer
+    } else {
+    }
 }
 
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From f4ccb06d699b91b8de8b797a584ce185d6856ec2 Mon Sep 17 00:00:00 2001
From: J-ZhengLi <lizheng135@huawei.com>
Date: Mon, 13 Mar 2023 20:17:30 +0800
Subject: extract `is_interior_mutable_type` from [`mut_key`] to
 `clippy_utils::ty`;

fix configuration of [`ifs_same_cond`];

add some style improvement for [`ifs_same_cond`];
---
 clippy_lints/src/copies.rs                       | 52 +++++++++-----------
 clippy_lints/src/mut_key.rs                      | 60 +++++-------------------
 clippy_utils/src/ty.rs                           | 44 +++++++++++++++++
 tests/ui-toml/ifs_same_cond/clippy.toml          |  2 +-
 tests/ui-toml/ifs_same_cond/ifs_same_cond.rs     | 12 ++---
 tests/ui-toml/ifs_same_cond/ifs_same_cond.stderr | 15 ++++++
 tests/ui/ifs_same_cond.rs                        |  8 ++++
 7 files changed, 107 insertions(+), 86 deletions(-)
 create mode 100644 tests/ui-toml/ifs_same_cond/ifs_same_cond.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/copies.rs b/clippy_lints/src/copies.rs
index 39f8f7220f1..970f5004993 100644
--- a/clippy_lints/src/copies.rs
+++ b/clippy_lints/src/copies.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::{span_lint_and_note, span_lint_and_then};
 use clippy_utils::source::{first_line_of_span, indent_of, reindent_multiline, snippet, snippet_opt};
-use clippy_utils::ty::needs_ordered_drop;
+use clippy_utils::ty::{is_interior_mut_ty, needs_ordered_drop};
 use clippy_utils::visitors::for_each_expr;
 use clippy_utils::{
     capture_local_usage, def_path_def_ids, eq_expr_value, find_binding_init, get_enclosing_block, hash_expr, hash_stmt,
@@ -8,9 +8,8 @@ use clippy_utils::{
 };
 use core::iter;
 use core::ops::ControlFlow;
-use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Applicability;
-use rustc_hir::def_id::DefId;
+use rustc_hir::def_id::DefIdSet;
 use rustc_hir::intravisit;
 use rustc_hir::{BinOpKind, Block, Expr, ExprKind, HirId, HirIdSet, Stmt, StmtKind};
 use rustc_lint::{LateContext, LateLintPass};
@@ -164,12 +163,14 @@ declare_clippy_lint! {
 
 pub struct CopyAndPaste {
     ignore_interior_mutability: Vec<String>,
+    ignored_ty_ids: DefIdSet,
 }
 
 impl CopyAndPaste {
     pub fn new(ignore_interior_mutability: Vec<String>) -> Self {
         Self {
             ignore_interior_mutability,
+            ignored_ty_ids: DefIdSet::new(),
         }
     }
 }
@@ -182,17 +183,18 @@ impl_lint_pass!(CopyAndPaste => [
 ]);
 
 impl<'tcx> LateLintPass<'tcx> for CopyAndPaste {
+    fn check_crate(&mut self, cx: &LateContext<'tcx>) {
+        for ignored_ty in &self.ignore_interior_mutability {
+            let path: Vec<&str> = ignored_ty.split("::").collect();
+            for id in def_path_def_ids(cx, path.as_slice()) {
+                self.ignored_ty_ids.insert(id);
+            }
+        }
+    }
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if !expr.span.from_expansion() && matches!(expr.kind, ExprKind::If(..)) && !is_else_clause(cx.tcx, expr) {
             let (conds, blocks) = if_sequence(expr);
-            let mut ignored_ty_ids = FxHashSet::default();
-            for ignored_ty in &self.ignore_interior_mutability {
-                let path: Vec<&str> = ignored_ty.split("::").collect();
-                for id in def_path_def_ids(cx, path.as_slice()) {
-                    ignored_ty_ids.insert(id);
-                }
-            }
-            lint_same_cond(cx, &conds, &ignored_ty_ids);
+            lint_same_cond(cx, &conds, &self.ignored_ty_ids);
             lint_same_fns_in_if_cond(cx, &conds);
             let all_same =
                 !is_lint_allowed(cx, IF_SAME_THEN_ELSE, expr.hir_id) && lint_if_same_then_else(cx, &conds, &blocks);
@@ -569,38 +571,30 @@ fn check_for_warn_of_moved_symbol(cx: &LateContext<'_>, symbols: &[(HirId, Symbo
     })
 }
 
-fn method_caller_is_ignored_or_mutable(
-    cx: &LateContext<'_>,
-    caller_expr: &Expr<'_>,
-    ignored_ty_ids: &FxHashSet<DefId>,
-) -> bool {
+fn method_caller_is_mutable(cx: &LateContext<'_>, caller_expr: &Expr<'_>, ignored_ty_ids: &DefIdSet) -> bool {
     let caller_ty = cx.typeck_results().expr_ty(caller_expr);
-    let is_ignored_ty = if let Some(adt_id) = caller_ty.ty_adt_id() && ignored_ty_ids.contains(&adt_id) {
-        true
-    } else {
-        false
-    };
+    // Check if given type has inner mutability and was not set to ignored by the configuration
+    let is_inner_mut_ty = is_interior_mut_ty(cx, caller_ty)
+        && !matches!(caller_ty.ty_adt_id(), Some(adt_id) if ignored_ty_ids.contains(&adt_id));
 
-    if is_ignored_ty
+    is_inner_mut_ty
         || caller_ty.is_mutable_ptr()
+        // `find_binding_init` will return the binding iff its not mutable
         || path_to_local(caller_expr)
             .and_then(|hid| find_binding_init(cx, hid))
             .is_none()
-    {
-        return true;
-    }
-
-    false
 }
 
 /// Implementation of `IFS_SAME_COND`.
-fn lint_same_cond(cx: &LateContext<'_>, conds: &[&Expr<'_>], ignored_ty_ids: &FxHashSet<DefId>) {
+fn lint_same_cond(cx: &LateContext<'_>, conds: &[&Expr<'_>], ignored_ty_ids: &DefIdSet) {
     for (i, j) in search_same(
         conds,
         |e| hash_expr(cx, e),
         |lhs, rhs| {
+            // Ignore eq_expr side effects iff one of the expressin kind is a method call
+            // and the caller is not a mutable, including inner mutable type.
             if let ExprKind::MethodCall(_, caller, _, _) = lhs.kind {
-                if method_caller_is_ignored_or_mutable(cx, caller, ignored_ty_ids) {
+                if method_caller_is_mutable(cx, caller, ignored_ty_ids) {
                     false
                 } else {
                     SpanlessEq::new(cx).eq_expr(lhs, rhs)
diff --git a/clippy_lints/src/mut_key.rs b/clippy_lints/src/mut_key.rs
index 8aa814b7405..309f67521a3 100644
--- a/clippy_lints/src/mut_key.rs
+++ b/clippy_lints/src/mut_key.rs
@@ -1,10 +1,11 @@
 use clippy_utils::diagnostics::span_lint;
+use clippy_utils::ty::is_interior_mut_ty;
 use clippy_utils::{def_path_def_ids, trait_ref_of_method};
 use rustc_data_structures::fx::FxHashSet;
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty::TypeVisitableExt;
-use rustc_middle::ty::{Adt, Array, Ref, Slice, Tuple, Ty};
+use rustc_middle::query::Key;
+use rustc_middle::ty::{Adt, Ty};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::def_id::LocalDefId;
 use rustc_span::source_map::Span;
@@ -153,53 +154,18 @@ impl MutableKeyType {
             let is_keyed_type = [sym::HashMap, sym::BTreeMap, sym::HashSet, sym::BTreeSet]
                 .iter()
                 .any(|diag_item| cx.tcx.is_diagnostic_item(*diag_item, def.did()));
-            if is_keyed_type && self.is_interior_mutable_type(cx, substs.type_at(0)) {
-                span_lint(cx, MUTABLE_KEY_TYPE, span, "mutable key type");
+            if !is_keyed_type {
+                return;
             }
-        }
-    }
 
-    /// Determines if a type contains interior mutability which would affect its implementation of
-    /// [`Hash`] or [`Ord`].
-    fn is_interior_mutable_type<'tcx>(&self, cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
-        match *ty.kind() {
-            Ref(_, inner_ty, mutbl) => mutbl == hir::Mutability::Mut || self.is_interior_mutable_type(cx, inner_ty),
-            Slice(inner_ty) => self.is_interior_mutable_type(cx, inner_ty),
-            Array(inner_ty, size) => {
-                size.try_eval_target_usize(cx.tcx, cx.param_env)
-                    .map_or(true, |u| u != 0)
-                    && self.is_interior_mutable_type(cx, inner_ty)
-            },
-            Tuple(fields) => fields.iter().any(|ty| self.is_interior_mutable_type(cx, ty)),
-            Adt(def, substs) => {
-                // Special case for collections in `std` who's impl of `Hash` or `Ord` delegates to
-                // that of their type parameters.  Note: we don't include `HashSet` and `HashMap`
-                // because they have no impl for `Hash` or `Ord`.
-                let def_id = def.did();
-                let is_std_collection = [
-                    sym::Option,
-                    sym::Result,
-                    sym::LinkedList,
-                    sym::Vec,
-                    sym::VecDeque,
-                    sym::BTreeMap,
-                    sym::BTreeSet,
-                    sym::Rc,
-                    sym::Arc,
-                ]
-                .iter()
-                .any(|diag_item| cx.tcx.is_diagnostic_item(*diag_item, def_id));
-                let is_box = Some(def_id) == cx.tcx.lang_items().owned_box();
-                if is_std_collection || is_box || self.ignore_mut_def_ids.contains(&def_id) {
-                    // The type is mutable if any of its type parameters are
-                    substs.types().any(|ty| self.is_interior_mutable_type(cx, ty))
-                } else {
-                    !ty.has_escaping_bound_vars()
-                        && cx.tcx.layout_of(cx.param_env.and(ty)).is_ok()
-                        && !ty.is_freeze(cx.tcx, cx.param_env)
-                }
-            },
-            _ => false,
+            let subst_ty = substs.type_at(0);
+            // Determines if a type contains interior mutability which would affect its implementation of
+            // [`Hash`] or [`Ord`].
+            if is_interior_mut_ty(cx, subst_ty)
+                && !matches!(subst_ty.ty_adt_id(), Some(adt_id) if self.ignore_mut_def_ids.contains(&adt_id))
+            {
+                span_lint(cx, MUTABLE_KEY_TYPE, span, "mutable key type");
+            }
         }
     }
 }
diff --git a/clippy_utils/src/ty.rs b/clippy_utils/src/ty.rs
index e0ea3952785..f1c6f1dddd8 100644
--- a/clippy_utils/src/ty.rs
+++ b/clippy_utils/src/ty.rs
@@ -1121,3 +1121,47 @@ pub fn make_normalized_projection<'tcx>(
     }
     helper(tcx, param_env, make_projection(tcx, container_id, assoc_ty, substs)?)
 }
+
+/// Check if given type has inner mutability such as [`std::cell::Cell`] or [`std::cell::RefCell`]
+/// etc.
+pub fn is_interior_mut_ty<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
+    match *ty.kind() {
+        ty::Ref(_, inner_ty, mutbl) => mutbl == Mutability::Mut || is_interior_mut_ty(cx, inner_ty),
+        ty::Slice(inner_ty) => is_interior_mut_ty(cx, inner_ty),
+        ty::Array(inner_ty, size) => {
+            size.try_eval_target_usize(cx.tcx, cx.param_env)
+                .map_or(true, |u| u != 0)
+                && is_interior_mut_ty(cx, inner_ty)
+        },
+        ty::Tuple(fields) => fields.iter().any(|ty| is_interior_mut_ty(cx, ty)),
+        ty::Adt(def, substs) => {
+            // Special case for collections in `std` who's impl of `Hash` or `Ord` delegates to
+            // that of their type parameters.  Note: we don't include `HashSet` and `HashMap`
+            // because they have no impl for `Hash` or `Ord`.
+            let def_id = def.did();
+            let is_std_collection = [
+                sym::Option,
+                sym::Result,
+                sym::LinkedList,
+                sym::Vec,
+                sym::VecDeque,
+                sym::BTreeMap,
+                sym::BTreeSet,
+                sym::Rc,
+                sym::Arc,
+            ]
+            .iter()
+            .any(|diag_item| cx.tcx.is_diagnostic_item(*diag_item, def_id));
+            let is_box = Some(def_id) == cx.tcx.lang_items().owned_box();
+            if is_std_collection || is_box {
+                // The type is mutable if any of its type parameters are
+                substs.types().any(|ty| is_interior_mut_ty(cx, ty))
+            } else {
+                !ty.has_escaping_bound_vars()
+                    && cx.tcx.layout_of(cx.param_env.and(ty)).is_ok()
+                    && !ty.is_freeze(cx.tcx, cx.param_env)
+            }
+        },
+        _ => false,
+    }
+}
diff --git a/tests/ui-toml/ifs_same_cond/clippy.toml b/tests/ui-toml/ifs_same_cond/clippy.toml
index 1615d970c68..90a36ecd920 100644
--- a/tests/ui-toml/ifs_same_cond/clippy.toml
+++ b/tests/ui-toml/ifs_same_cond/clippy.toml
@@ -1 +1 @@
-ignore-interior-mutability = ["std::cell::Cell"]
\ No newline at end of file
+ignore-interior-mutability = ["std::cell::Cell"]
diff --git a/tests/ui-toml/ifs_same_cond/ifs_same_cond.rs b/tests/ui-toml/ifs_same_cond/ifs_same_cond.rs
index 92438e7d1f2..d623ac7e020 100644
--- a/tests/ui-toml/ifs_same_cond/ifs_same_cond.rs
+++ b/tests/ui-toml/ifs_same_cond/ifs_same_cond.rs
@@ -6,19 +6,13 @@ fn main() {}
 fn issue10272() {
     use std::cell::Cell;
 
+    // Because the `ignore-interior-mutability` configuration
+    // is set to ignore for `std::cell::Cell`, the following `get()` calls
+    // should trigger warning
     let x = Cell::new(true);
     if x.get() {
     } else if !x.take() {
     } else if x.get() {
-        // ok, x is interior mutable type
-    } else {
-    }
-
-    let a = [Cell::new(true)];
-    if a[0].get() {
-    } else if a[0].take() {
-    } else if a[0].get() {
-        // ok, a contains interior mutable type
     } else {
     }
 }
diff --git a/tests/ui-toml/ifs_same_cond/ifs_same_cond.stderr b/tests/ui-toml/ifs_same_cond/ifs_same_cond.stderr
new file mode 100644
index 00000000000..2841f62bc94
--- /dev/null
+++ b/tests/ui-toml/ifs_same_cond/ifs_same_cond.stderr
@@ -0,0 +1,15 @@
+error: this `if` has the same condition as a previous `if`
+  --> $DIR/ifs_same_cond.rs:15:15
+   |
+LL |     } else if x.get() {
+   |               ^^^^^^^
+   |
+note: same as this
+  --> $DIR/ifs_same_cond.rs:13:8
+   |
+LL |     if x.get() {
+   |        ^^^^^^^
+   = note: `-D clippy::ifs-same-cond` implied by `-D warnings`
+
+error: aborting due to previous error
+
diff --git a/tests/ui/ifs_same_cond.rs b/tests/ui/ifs_same_cond.rs
index ae91611c472..9ce9a87626a 100644
--- a/tests/ui/ifs_same_cond.rs
+++ b/tests/ui/ifs_same_cond.rs
@@ -59,6 +59,14 @@ fn issue10272() {
         // ok, p is mutable pointer
     } else {
     }
+
+    let x = std::cell::Cell::new(true);
+    if x.get() {
+    } else if !x.take() {
+    } else if x.get() {
+        // ok, x is interior mutable type
+    } else {
+    }
 }
 
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 555f56862e10cda545c9b7de21f68c7d62266c35 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Thu, 9 Mar 2023 17:31:10 +0000
Subject: Fix semicolon insertion in `match_single_binding`

---
 clippy_lints/src/matches/match_single_binding.rs |  21 +++--
 tests/ui/match_single_binding.fixed              |  41 +++++++--
 tests/ui/match_single_binding.rs                 |  55 +++++++++--
 tests/ui/match_single_binding.stderr             | 111 +++++++++++++++++++----
 tests/ui/match_single_binding2.fixed             |   4 +-
 tests/ui/match_single_binding2.stderr            |   4 +-
 6 files changed, 192 insertions(+), 44 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/match_single_binding.rs b/clippy_lints/src/matches/match_single_binding.rs
index eec5c1143d4..89da7a55cbd 100644
--- a/clippy_lints/src/matches/match_single_binding.rs
+++ b/clippy_lints/src/matches/match_single_binding.rs
@@ -3,7 +3,7 @@ use clippy_utils::macros::HirNode;
 use clippy_utils::source::{indent_of, snippet, snippet_block_with_context, snippet_with_applicability};
 use clippy_utils::{get_parent_expr, is_refutable, peel_blocks};
 use rustc_errors::Applicability;
-use rustc_hir::{Arm, Expr, ExprKind, Node, PatKind};
+use rustc_hir::{Arm, Expr, ExprKind, Node, PatKind, StmtKind};
 use rustc_lint::LateContext;
 use rustc_span::Span;
 
@@ -24,22 +24,27 @@ pub(crate) fn check<'a>(cx: &LateContext<'a>, ex: &Expr<'a>, arms: &[Arm<'_>], e
     let bind_names = arms[0].pat.span;
     let match_body = peel_blocks(arms[0].body);
     let mut app = Applicability::MaybeIncorrect;
-    let (snippet_body, from_macro) = snippet_block_with_context(
+    let mut snippet_body = snippet_block_with_context(
         cx,
         match_body.span,
         arms[0].span.ctxt(),
         "..",
         Some(expr.span),
         &mut app,
-    );
-    let mut snippet_body = snippet_body.to_string();
+    )
+    .0
+    .to_string();
 
     // Do we need to add ';' to suggestion ?
-    if matches!(match_body.kind, ExprKind::Block(..)) {
-        // macro + expr_ty(body) == ()
-        if from_macro && cx.typeck_results().expr_ty(match_body).is_unit() {
-            snippet_body.push(';');
+    if let Node::Stmt(stmt) = cx.tcx.hir().get_parent(expr.hir_id)
+        && let StmtKind::Expr(_) = stmt.kind
+        && match match_body.kind {
+            // We don't need to add a ; to blocks, unless that block is from a macro expansion
+            ExprKind::Block(block, _) => block.span.from_expansion(),
+            _ => true,
         }
+    {
+        snippet_body.push(';');
     }
 
     match arms[0].pat.kind {
diff --git a/tests/ui/match_single_binding.fixed b/tests/ui/match_single_binding.fixed
index 6cfb6661a03..201301cc9b7 100644
--- a/tests/ui/match_single_binding.fixed
+++ b/tests/ui/match_single_binding.fixed
@@ -1,7 +1,12 @@
 // run-rustfix
 #![warn(clippy::match_single_binding)]
-#![allow(unused_variables)]
-#![allow(clippy::toplevel_ref_arg, clippy::uninlined_format_args)]
+#![allow(
+    unused,
+    clippy::let_unit_value,
+    clippy::no_effect,
+    clippy::toplevel_ref_arg,
+    clippy::uninlined_format_args
+)]
 
 struct Point {
     x: i32,
@@ -109,10 +114,9 @@ fn main() {
 
     // Lint
     let x = 1;
-    println!("Not an array index start");
+    println!("Not an array index start")
 }
 
-#[allow(dead_code)]
 fn issue_8723() {
     let (mut val, idx) = ("a b", 1);
 
@@ -125,16 +129,15 @@ fn issue_8723() {
     let _ = val;
 }
 
-#[allow(dead_code)]
+fn side_effects() {}
+
 fn issue_9575() {
-    fn side_effects() {}
     let _ = || {
         side_effects();
-        println!("Needs curlies");
+        println!("Needs curlies")
     };
 }
 
-#[allow(dead_code)]
 fn issue_9725(r: Option<u32>) {
     let x = r;
     match x {
@@ -146,3 +149,25 @@ fn issue_9725(r: Option<u32>) {
         },
     };
 }
+
+fn issue_10447() -> usize {
+    ();
+
+    let a = ();
+
+    side_effects();
+
+    let b = side_effects();
+
+    println!("1");
+
+    let c = println!("1");
+
+    let in_expr = [
+        (),
+        side_effects(),
+        println!("1"),
+    ];
+
+    2
+}
diff --git a/tests/ui/match_single_binding.rs b/tests/ui/match_single_binding.rs
index f188aeb5f2f..8b047b19ce9 100644
--- a/tests/ui/match_single_binding.rs
+++ b/tests/ui/match_single_binding.rs
@@ -1,7 +1,12 @@
 // run-rustfix
 #![warn(clippy::match_single_binding)]
-#![allow(unused_variables)]
-#![allow(clippy::toplevel_ref_arg, clippy::uninlined_format_args)]
+#![allow(
+    unused,
+    clippy::let_unit_value,
+    clippy::no_effect,
+    clippy::toplevel_ref_arg,
+    clippy::uninlined_format_args
+)]
 
 struct Point {
     x: i32,
@@ -127,7 +132,6 @@ fn main() {
     }
 }
 
-#[allow(dead_code)]
 fn issue_8723() {
     let (mut val, idx) = ("a b", 1);
 
@@ -141,15 +145,14 @@ fn issue_8723() {
     let _ = val;
 }
 
-#[allow(dead_code)]
+fn side_effects() {}
+
 fn issue_9575() {
-    fn side_effects() {}
     let _ = || match side_effects() {
         _ => println!("Needs curlies"),
     };
 }
 
-#[allow(dead_code)]
 fn issue_9725(r: Option<u32>) {
     match r {
         x => match x {
@@ -162,3 +165,43 @@ fn issue_9725(r: Option<u32>) {
         },
     };
 }
+
+fn issue_10447() -> usize {
+    match 1 {
+        _ => (),
+    }
+
+    let a = match 1 {
+        _ => (),
+    };
+
+    match 1 {
+        _ => side_effects(),
+    }
+
+    let b = match 1 {
+        _ => side_effects(),
+    };
+
+    match 1 {
+        _ => println!("1"),
+    }
+
+    let c = match 1 {
+        _ => println!("1"),
+    };
+
+    let in_expr = [
+        match 1 {
+            _ => (),
+        },
+        match 1 {
+            _ => side_effects(),
+        },
+        match 1 {
+            _ => println!("1"),
+        },
+    ];
+
+    2
+}
diff --git a/tests/ui/match_single_binding.stderr b/tests/ui/match_single_binding.stderr
index e960d64ad2b..9d16af76c6a 100644
--- a/tests/ui/match_single_binding.stderr
+++ b/tests/ui/match_single_binding.stderr
@@ -1,5 +1,5 @@
 error: this match could be written as a `let` statement
-  --> $DIR/match_single_binding.rs:28:5
+  --> $DIR/match_single_binding.rs:33:5
    |
 LL | /     match (a, b, c) {
 LL | |         (x, y, z) => {
@@ -18,7 +18,7 @@ LL +     }
    |
 
 error: this match could be written as a `let` statement
-  --> $DIR/match_single_binding.rs:34:5
+  --> $DIR/match_single_binding.rs:39:5
    |
 LL | /     match (a, b, c) {
 LL | |         (x, y, z) => println!("{} {} {}", x, y, z),
@@ -32,7 +32,7 @@ LL +     println!("{} {} {}", x, y, z);
    |
 
 error: this match could be replaced by its body itself
-  --> $DIR/match_single_binding.rs:51:5
+  --> $DIR/match_single_binding.rs:56:5
    |
 LL | /     match a {
 LL | |         _ => println!("whatever"),
@@ -40,7 +40,7 @@ LL | |     }
    | |_____^ help: consider using the match body instead: `println!("whatever");`
 
 error: this match could be replaced by its body itself
-  --> $DIR/match_single_binding.rs:55:5
+  --> $DIR/match_single_binding.rs:60:5
    |
 LL | /     match a {
 LL | |         _ => {
@@ -59,7 +59,7 @@ LL +     }
    |
 
 error: this match could be replaced by its body itself
-  --> $DIR/match_single_binding.rs:62:5
+  --> $DIR/match_single_binding.rs:67:5
    |
 LL | /     match a {
 LL | |         _ => {
@@ -81,7 +81,7 @@ LL +     }
    |
 
 error: this match could be written as a `let` statement
-  --> $DIR/match_single_binding.rs:72:5
+  --> $DIR/match_single_binding.rs:77:5
    |
 LL | /     match p {
 LL | |         Point { x, y } => println!("Coords: ({}, {})", x, y),
@@ -95,7 +95,7 @@ LL +     println!("Coords: ({}, {})", x, y);
    |
 
 error: this match could be written as a `let` statement
-  --> $DIR/match_single_binding.rs:76:5
+  --> $DIR/match_single_binding.rs:81:5
    |
 LL | /     match p {
 LL | |         Point { x: x1, y: y1 } => println!("Coords: ({}, {})", x1, y1),
@@ -109,7 +109,7 @@ LL +     println!("Coords: ({}, {})", x1, y1);
    |
 
 error: this match could be written as a `let` statement
-  --> $DIR/match_single_binding.rs:81:5
+  --> $DIR/match_single_binding.rs:86:5
    |
 LL | /     match x {
 LL | |         ref r => println!("Got a reference to {}", r),
@@ -123,7 +123,7 @@ LL +     println!("Got a reference to {}", r);
    |
 
 error: this match could be written as a `let` statement
-  --> $DIR/match_single_binding.rs:86:5
+  --> $DIR/match_single_binding.rs:91:5
    |
 LL | /     match x {
 LL | |         ref mut mr => println!("Got a mutable reference to {}", mr),
@@ -137,7 +137,7 @@ LL +     println!("Got a mutable reference to {}", mr);
    |
 
 error: this match could be written as a `let` statement
-  --> $DIR/match_single_binding.rs:90:5
+  --> $DIR/match_single_binding.rs:95:5
    |
 LL | /     let product = match coords() {
 LL | |         Point { x, y } => x * y,
@@ -151,7 +151,7 @@ LL +     let product = x * y;
    |
 
 error: this match could be written as a `let` statement
-  --> $DIR/match_single_binding.rs:98:18
+  --> $DIR/match_single_binding.rs:103:18
    |
 LL |           .map(|i| match i.unwrap() {
    |  __________________^
@@ -168,16 +168,16 @@ LL ~         })
    |
 
 error: this match could be replaced by its body itself
-  --> $DIR/match_single_binding.rs:124:5
+  --> $DIR/match_single_binding.rs:129:5
    |
 LL | /     match x {
 LL | |         // =>
 LL | |         _ => println!("Not an array index start"),
 LL | |     }
-   | |_____^ help: consider using the match body instead: `println!("Not an array index start");`
+   | |_____^ help: consider using the match body instead: `println!("Not an array index start")`
 
 error: this assignment could be simplified
-  --> $DIR/match_single_binding.rs:134:5
+  --> $DIR/match_single_binding.rs:138:5
    |
 LL | /     val = match val.split_at(idx) {
 LL | |         (pre, suf) => {
@@ -197,7 +197,7 @@ LL ~     };
    |
 
 error: this match could be replaced by its scrutinee and body
-  --> $DIR/match_single_binding.rs:147:16
+  --> $DIR/match_single_binding.rs:151:16
    |
 LL |       let _ = || match side_effects() {
    |  ________________^
@@ -209,12 +209,12 @@ help: consider using the scrutinee and body instead
    |
 LL ~     let _ = || {
 LL +         side_effects();
-LL +         println!("Needs curlies");
+LL +         println!("Needs curlies")
 LL ~     };
    |
 
 error: this match could be written as a `let` statement
-  --> $DIR/match_single_binding.rs:154:5
+  --> $DIR/match_single_binding.rs:157:5
    |
 LL | /     match r {
 LL | |         x => match x {
@@ -238,5 +238,80 @@ LL +         },
 LL ~     };
    |
 
-error: aborting due to 15 previous errors
+error: this match could be replaced by its body itself
+  --> $DIR/match_single_binding.rs:170:5
+   |
+LL | /     match 1 {
+LL | |         _ => (),
+LL | |     }
+   | |_____^ help: consider using the match body instead: `();`
+
+error: this match could be replaced by its body itself
+  --> $DIR/match_single_binding.rs:174:13
+   |
+LL |       let a = match 1 {
+   |  _____________^
+LL | |         _ => (),
+LL | |     };
+   | |_____^ help: consider using the match body instead: `()`
+
+error: this match could be replaced by its body itself
+  --> $DIR/match_single_binding.rs:178:5
+   |
+LL | /     match 1 {
+LL | |         _ => side_effects(),
+LL | |     }
+   | |_____^ help: consider using the match body instead: `side_effects();`
+
+error: this match could be replaced by its body itself
+  --> $DIR/match_single_binding.rs:182:13
+   |
+LL |       let b = match 1 {
+   |  _____________^
+LL | |         _ => side_effects(),
+LL | |     };
+   | |_____^ help: consider using the match body instead: `side_effects()`
+
+error: this match could be replaced by its body itself
+  --> $DIR/match_single_binding.rs:186:5
+   |
+LL | /     match 1 {
+LL | |         _ => println!("1"),
+LL | |     }
+   | |_____^ help: consider using the match body instead: `println!("1");`
+
+error: this match could be replaced by its body itself
+  --> $DIR/match_single_binding.rs:190:13
+   |
+LL |       let c = match 1 {
+   |  _____________^
+LL | |         _ => println!("1"),
+LL | |     };
+   | |_____^ help: consider using the match body instead: `println!("1")`
+
+error: this match could be replaced by its body itself
+  --> $DIR/match_single_binding.rs:195:9
+   |
+LL | /         match 1 {
+LL | |             _ => (),
+LL | |         },
+   | |_________^ help: consider using the match body instead: `()`
+
+error: this match could be replaced by its body itself
+  --> $DIR/match_single_binding.rs:198:9
+   |
+LL | /         match 1 {
+LL | |             _ => side_effects(),
+LL | |         },
+   | |_________^ help: consider using the match body instead: `side_effects()`
+
+error: this match could be replaced by its body itself
+  --> $DIR/match_single_binding.rs:201:9
+   |
+LL | /         match 1 {
+LL | |             _ => println!("1"),
+LL | |         },
+   | |_________^ help: consider using the match body instead: `println!("1")`
+
+error: aborting due to 24 previous errors
 
diff --git a/tests/ui/match_single_binding2.fixed b/tests/ui/match_single_binding2.fixed
index 6a7db67e311..e3cf56a4293 100644
--- a/tests/ui/match_single_binding2.fixed
+++ b/tests/ui/match_single_binding2.fixed
@@ -30,7 +30,7 @@ fn main() {
         #[rustfmt::skip]
         Some((first, _second)) => {
             let (a, b) = get_tup();
-            println!("a {:?} and b {:?}", a, b);
+            println!("a {:?} and b {:?}", a, b)
         },
         None => println!("nothing"),
     }
@@ -49,5 +49,5 @@ fn main() {
         0 => 1,
         _ => 2,
     };
-    println!("Single branch");
+    println!("Single branch")
 }
diff --git a/tests/ui/match_single_binding2.stderr b/tests/ui/match_single_binding2.stderr
index 22bf7d8be4a..e180b93e76d 100644
--- a/tests/ui/match_single_binding2.stderr
+++ b/tests/ui/match_single_binding2.stderr
@@ -27,7 +27,7 @@ LL | |             }
 help: consider using a `let` statement
    |
 LL ~             let (a, b) = get_tup();
-LL +             println!("a {:?} and b {:?}", a, b);
+LL +             println!("a {:?} and b {:?}", a, b)
    |
 
 error: this match could be replaced by its scrutinee and body
@@ -61,7 +61,7 @@ LL ~     match x {
 LL +         0 => 1,
 LL +         _ => 2,
 LL +     };
-LL +     println!("Single branch");
+LL +     println!("Single branch")
    |
 
 error: aborting due to 4 previous errors
-- 
cgit 1.4.1-3-g733a5


From 6631480a7b7cb7b3e7d53c9c4cd7915f7ebc3110 Mon Sep 17 00:00:00 2001
From: blyxyas <blyxyas@gmail.com>
Date: Mon, 13 Mar 2023 19:13:56 +0100
Subject: Fix false positive with `a = a`

---
 clippy_lints/src/swap.rs | 1 +
 tests/ui/swap.fixed      | 8 ++++++++
 tests/ui/swap.rs         | 8 ++++++++
 3 files changed, 17 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/swap.rs b/clippy_lints/src/swap.rs
index 1aeac724ab1..5087c19e5f3 100644
--- a/clippy_lints/src/swap.rs
+++ b/clippy_lints/src/swap.rs
@@ -190,6 +190,7 @@ fn check_suspicious_swap(cx: &LateContext<'_>, block: &Block<'_>) {
             && first.span.eq_ctxt(second.span)
             && is_same(cx, lhs0, rhs1)
             && is_same(cx, lhs1, rhs0)
+			&& !is_same(cx, lhs1, rhs1) // Ignore a = b; a = a (#10421)
             && let Some(lhs_sugg) = match &lhs0 {
                 ExprOrIdent::Expr(expr) => Sugg::hir_opt(cx, expr),
                 ExprOrIdent::Ident(ident) => Some(Sugg::NonParen(ident.as_str().into())),
diff --git a/tests/ui/swap.fixed b/tests/ui/swap.fixed
index 04008c0d9b3..775b0dbde88 100644
--- a/tests/ui/swap.fixed
+++ b/tests/ui/swap.fixed
@@ -186,3 +186,11 @@ const fn issue_9864(mut u: u32) -> u32 {
     v = temp;
     u + v
 }
+
+#[allow(clippy::let_and_return)]
+const fn issue_10421(x: u32) -> u32 {
+    let a = x;
+    let a = a;
+    let a = a;
+    a
+}
diff --git a/tests/ui/swap.rs b/tests/ui/swap.rs
index ef8a81c8341..bc9a78b49c7 100644
--- a/tests/ui/swap.rs
+++ b/tests/ui/swap.rs
@@ -215,3 +215,11 @@ const fn issue_9864(mut u: u32) -> u32 {
     v = temp;
     u + v
 }
+
+#[allow(clippy::let_and_return)]
+const fn issue_10421(x: u32) -> u32 {
+    let a = x;
+    let a = a;
+    let a = a;
+    a
+}
-- 
cgit 1.4.1-3-g733a5


From 5924b46543853ea8d8bbbe886a09036c4fa5a087 Mon Sep 17 00:00:00 2001
From: Simonas Kazlauskas <git@kazlauskas.me>
Date: Tue, 14 Mar 2023 12:44:23 +0200
Subject: Fix documentation for `derived_hash_with_manual_eq`

The documentation retained "vice versa" from the previous incarnation of
the lint but the lint itself no longer lints against manual `Hash`
implementations with a derived `PartialEq`.

I also adjusted the documentation for `PartialOrd`-`Ord` lint as "vice
versa" seemed a little confusing to me there (as to what it was refering
to exactly.)
---
 clippy_lints/src/derive.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/derive.rs b/clippy_lints/src/derive.rs
index b8428d66a5d..1a9dad47839 100644
--- a/clippy_lints/src/derive.rs
+++ b/clippy_lints/src/derive.rs
@@ -24,8 +24,8 @@ use rustc_span::sym;
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for deriving `Hash` but implementing `PartialEq`
-    /// explicitly or vice versa.
+    /// Lints against manual `PartialEq` implementations for types with a derived `Hash`
+    /// implementation.
     ///
     /// ### Why is this bad?
     /// The implementation of these traits must agree (for
@@ -54,8 +54,8 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for deriving `Ord` but implementing `PartialOrd`
-    /// explicitly or vice versa.
+    /// Lints against manual `PartialOrd` and `Ord` implementations for types with a derived `Ord`
+    /// or `PartialOrd` implementation.
     ///
     /// ### Why is this bad?
     /// The implementation of these traits must agree (for
-- 
cgit 1.4.1-3-g733a5


From 3eea49446bae42709b96bd36a0eb2c0966b6b4ac Mon Sep 17 00:00:00 2001
From: blyxyas <blyxyas@gmail.com>
Date: Tue, 14 Mar 2023 20:59:39 +0100
Subject: Ignore external macros

---
 clippy_lints/src/swap.rs | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/swap.rs b/clippy_lints/src/swap.rs
index 5087c19e5f3..938ca3a6cee 100644
--- a/clippy_lints/src/swap.rs
+++ b/clippy_lints/src/swap.rs
@@ -6,7 +6,8 @@ use clippy_utils::{can_mut_borrow_both, eq_expr_value, in_constant, std_or_core}
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Block, Expr, ExprKind, PatKind, QPath, Stmt, StmtKind};
-use rustc_lint::{LateContext, LateLintPass};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Spanned;
@@ -75,7 +76,9 @@ declare_lint_pass!(Swap => [MANUAL_SWAP, ALMOST_SWAPPED]);
 impl<'tcx> LateLintPass<'tcx> for Swap {
     fn check_block(&mut self, cx: &LateContext<'tcx>, block: &'tcx Block<'_>) {
         check_manual_swap(cx, block);
-        check_suspicious_swap(cx, block);
+        if !in_external_macro(cx.sess(), block.span) {
+            check_suspicious_swap(cx, block);
+        }
         check_xor_swap(cx, block);
     }
 }
-- 
cgit 1.4.1-3-g733a5


From 4b9cb857f9b6da4e3b274601a6c439aac8a2c425 Mon Sep 17 00:00:00 2001
From: blyxyas <blyxyas@gmail.com>
Date: Wed, 15 Mar 2023 23:18:25 +0100
Subject: Rename lint

---
 CHANGELOG.md                         |  2 +-
 clippy_lints/src/allow_attribute.rs  | 79 ------------------------------------
 clippy_lints/src/allow_attributes.rs | 79 ++++++++++++++++++++++++++++++++++++
 clippy_lints/src/declared_lints.rs   |  2 +-
 clippy_lints/src/lib.rs              |  4 +-
 tests/ui/allow_attribute.fixed       | 25 ------------
 tests/ui/allow_attribute.rs          | 25 ------------
 tests/ui/allow_attribute.stderr      | 16 --------
 tests/ui/allow_attributes.fixed      | 25 ++++++++++++
 tests/ui/allow_attributes.rs         | 25 ++++++++++++
 tests/ui/allow_attributes.stderr     | 16 ++++++++
 11 files changed, 149 insertions(+), 149 deletions(-)
 delete mode 100644 clippy_lints/src/allow_attribute.rs
 create mode 100644 clippy_lints/src/allow_attributes.rs
 delete mode 100644 tests/ui/allow_attribute.fixed
 delete mode 100644 tests/ui/allow_attribute.rs
 delete mode 100644 tests/ui/allow_attribute.stderr
 create mode 100644 tests/ui/allow_attributes.fixed
 create mode 100644 tests/ui/allow_attributes.rs
 create mode 100644 tests/ui/allow_attributes.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 2b00fd962ca..c090a844858 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4382,7 +4382,7 @@ Released 2018-09-13
 <!-- begin autogenerated links to lint list -->
 [`absurd_extreme_comparisons`]: https://rust-lang.github.io/rust-clippy/master/index.html#absurd_extreme_comparisons
 [`alloc_instead_of_core`]: https://rust-lang.github.io/rust-clippy/master/index.html#alloc_instead_of_core
-[`allow_attribute`]: https://rust-lang.github.io/rust-clippy/master/index.html#allow_attribute
+[`allow_attributes`]: https://rust-lang.github.io/rust-clippy/master/index.html#allow_attributes
 [`allow_attributes_without_reason`]: https://rust-lang.github.io/rust-clippy/master/index.html#allow_attributes_without_reason
 [`almost_complete_letter_range`]: https://rust-lang.github.io/rust-clippy/master/index.html#almost_complete_letter_range
 [`almost_complete_range`]: https://rust-lang.github.io/rust-clippy/master/index.html#almost_complete_range
diff --git a/clippy_lints/src/allow_attribute.rs b/clippy_lints/src/allow_attribute.rs
deleted file mode 100644
index 28fc45d0554..00000000000
--- a/clippy_lints/src/allow_attribute.rs
+++ /dev/null
@@ -1,79 +0,0 @@
-use ast::AttrStyle;
-use clippy_utils::diagnostics::span_lint_and_sugg;
-use rustc_ast as ast;
-use rustc_errors::Applicability;
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-
-declare_clippy_lint! {
-        /// Detects uses of the `#[allow]` attribute and suggests replacing it with
-    /// the `#[expect]` (See [RFC 2383](https://rust-lang.github.io/rfcs/2383-lint-reasons.html))
-    ///
-    /// The expect attribute is still unstable and requires the `lint_reasons`
-    /// on nightly. It can be enabled by adding `#![feature(lint_reasons)]` to
-    /// the crate root.
-    ///
-    /// This lint only warns outer attributes (`#[allow]`), as inner attributes
-    /// (`#![allow]`) are usually used to enable or disable lints on a global scale.
-    ///
-    /// ### Why is this bad?
-    ///
-    /// `#[expect]` attributes suppress the lint emission, but emit a warning, if
-    /// the expectation is unfulfilled. This can be useful to be notified when the
-    /// lint is no longer triggered.
-    ///
-    /// ### Example
-    /// ```rust,ignore
-    /// #[allow(unused_mut)]
-    /// fn foo() -> usize {
-    ///    let mut a = Vec::new();
-    ///    a.len()
-    ///}
-    /// ```
-    /// Use instead:
-    /// ```rust,ignore
-    /// # #![feature(lint_reasons)]
-    /// #[expect(unused_mut)]
-    /// fn foo() -> usize {
-    ///     let mut a = Vec::new();
-    ///     a.len()
-    /// }
-    /// ```
-    #[clippy::version = "1.69.0"]
-    pub ALLOW_ATTRIBUTE,
-    restriction,
-    "`#[allow]` will not trigger if a warning isn't found. `#[expect]` triggers if there are no warnings."
-}
-
-declare_lint_pass!(AllowAttribute => [ALLOW_ATTRIBUTE]);
-
-impl LateLintPass<'_> for AllowAttribute {
-    // Separate each crate's features.
-    fn check_attribute(&mut self, cx: &LateContext<'_>, attr: &ast::Attribute) {
-        if_chain! {
-            if cx.tcx.features().lint_reasons;
-            if let AttrStyle::Outer = attr.style;
-            if let Some(ident) = attr.ident();
-            if ident.name == rustc_span::symbol::sym::allow;
-            then {
-                span_lint_and_sugg(
-                    cx,
-                    ALLOW_ATTRIBUTE,
-                    ident.span,
-                    "#[allow] attribute found",
-                    "replace it with", "expect".into()
-                    // format!("expect{}", snippet(
-                    //     cx,
-                    //     ident.span
-                    //     .with_lo(
-                    //         ident.span.hi() + BytePos(2) // Cut *(
-                    //     )
-                    //     .with_hi(
-                    //         attr.meta().unwrap().span.hi() - BytePos(1) // Cut )
-                    //     )
-                    //     , "..."))
-                    , Applicability::MachineApplicable);
-            }
-        }
-    }
-}
diff --git a/clippy_lints/src/allow_attributes.rs b/clippy_lints/src/allow_attributes.rs
new file mode 100644
index 00000000000..3d660a11ea3
--- /dev/null
+++ b/clippy_lints/src/allow_attributes.rs
@@ -0,0 +1,79 @@
+use ast::AttrStyle;
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use rustc_ast as ast;
+use rustc_errors::Applicability;
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+        /// Detects uses of the `#[allow]` attribute and suggests replacing it with
+    /// the `#[expect]` (See [RFC 2383](https://rust-lang.github.io/rfcs/2383-lint-reasons.html))
+    ///
+    /// The expect attribute is still unstable and requires the `lint_reasons`
+    /// on nightly. It can be enabled by adding `#![feature(lint_reasons)]` to
+    /// the crate root.
+    ///
+    /// This lint only warns outer attributes (`#[allow]`), as inner attributes
+    /// (`#![allow]`) are usually used to enable or disable lints on a global scale.
+    ///
+    /// ### Why is this bad?
+    ///
+    /// `#[expect]` attributes suppress the lint emission, but emit a warning, if
+    /// the expectation is unfulfilled. This can be useful to be notified when the
+    /// lint is no longer triggered.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// #[allow(unused_mut)]
+    /// fn foo() -> usize {
+    ///    let mut a = Vec::new();
+    ///    a.len()
+    ///}
+    /// ```
+    /// Use instead:
+    /// ```rust,ignore
+    /// # #![feature(lint_reasons)]
+    /// #[expect(unused_mut)]
+    /// fn foo() -> usize {
+    ///     let mut a = Vec::new();
+    ///     a.len()
+    /// }
+    /// ```
+    #[clippy::version = "1.69.0"]
+    pub ALLOW_ATTRIBUTES,
+    restriction,
+    "`#[allow]` will not trigger if a warning isn't found. `#[expect]` triggers if there are no warnings."
+}
+
+declare_lint_pass!(AllowAttribute => [ALLOW_ATTRIBUTES]);
+
+impl LateLintPass<'_> for AllowAttribute {
+    // Separate each crate's features.
+    fn check_attribute(&mut self, cx: &LateContext<'_>, attr: &ast::Attribute) {
+        if_chain! {
+            if cx.tcx.features().lint_reasons;
+            if let AttrStyle::Outer = attr.style;
+            if let Some(ident) = attr.ident();
+            if ident.name == rustc_span::symbol::sym::allow;
+            then {
+                span_lint_and_sugg(
+                    cx,
+                    ALLOW_ATTRIBUTES,
+                    ident.span,
+                    "#[allow] attribute found",
+                    "replace it with", "expect".into()
+                    // format!("expect{}", snippet(
+                    //     cx,
+                    //     ident.span
+                    //     .with_lo(
+                    //         ident.span.hi() + BytePos(2) // Cut *(
+                    //     )
+                    //     .with_hi(
+                    //         attr.meta().unwrap().span.hi() - BytePos(1) // Cut )
+                    //     )
+                    //     , "..."))
+                    , Applicability::MachineApplicable);
+            }
+        }
+    }
+}
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 73f74d59f4a..25f15973490 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -35,7 +35,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::utils::internal_lints::produce_ice::PRODUCE_ICE_INFO,
     #[cfg(feature = "internal")]
     crate::utils::internal_lints::unnecessary_def_path::UNNECESSARY_DEF_PATH_INFO,
-    crate::allow_attribute::ALLOW_ATTRIBUTE_INFO,
+    crate::allow_attributes::ALLOW_ATTRIBUTES_INFO,
     crate::almost_complete_range::ALMOST_COMPLETE_RANGE_INFO,
     crate::approx_const::APPROX_CONSTANT_INFO,
     crate::as_conversions::AS_CONVERSIONS_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index a3c65a69c99..c455c3e3058 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -67,7 +67,7 @@ mod declared_lints;
 mod renamed_lints;
 
 // begin lints modules, do not remove this comment, it’s used in `update_lints`
-mod allow_attribute;
+mod allow_attributes;
 mod almost_complete_range;
 mod approx_const;
 mod as_conversions;
@@ -934,7 +934,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(missing_assert_message::MissingAssertMessage));
     store.register_early_pass(|| Box::new(redundant_async_block::RedundantAsyncBlock));
     store.register_late_pass(|_| Box::new(let_with_type_underscore::UnderscoreTyped));
-    store.register_late_pass(|_| Box::new(allow_attribute::AllowAttribute));
+    store.register_late_pass(|_| Box::new(allow_attributes::AllowAttribute));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/tests/ui/allow_attribute.fixed b/tests/ui/allow_attribute.fixed
deleted file mode 100644
index 01759ced09d..00000000000
--- a/tests/ui/allow_attribute.fixed
+++ /dev/null
@@ -1,25 +0,0 @@
-// run-rustfix
-#![allow(unused)]
-#![warn(clippy::allow_attribute)]
-#![feature(lint_reasons)]
-
-fn main() {}
-
-// Using clippy::needless_borrow just as a placeholder, it isn't relevant.
-
-// Should lint
-#[expect(dead_code)]
-struct T1;
-
-struct T2; // Should not lint
-#[deny(clippy::needless_borrow)] // Should not lint
-struct T3;
-#[warn(clippy::needless_borrow)] // Should not lint
-struct T4;
-// `panic = "unwind"` should always be true
-#[cfg_attr(panic = "unwind", expect(dead_code))]
-struct CfgT;
-
-fn ignore_inner_attr() {
-    #![allow(unused)] // Should not lint
-}
diff --git a/tests/ui/allow_attribute.rs b/tests/ui/allow_attribute.rs
deleted file mode 100644
index b8e341fe9e4..00000000000
--- a/tests/ui/allow_attribute.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-// run-rustfix
-#![allow(unused)]
-#![warn(clippy::allow_attribute)]
-#![feature(lint_reasons)]
-
-fn main() {}
-
-// Using clippy::needless_borrow just as a placeholder, it isn't relevant.
-
-// Should lint
-#[allow(dead_code)]
-struct T1;
-
-struct T2; // Should not lint
-#[deny(clippy::needless_borrow)] // Should not lint
-struct T3;
-#[warn(clippy::needless_borrow)] // Should not lint
-struct T4;
-// `panic = "unwind"` should always be true
-#[cfg_attr(panic = "unwind", allow(dead_code))]
-struct CfgT;
-
-fn ignore_inner_attr() {
-    #![allow(unused)] // Should not lint
-}
diff --git a/tests/ui/allow_attribute.stderr b/tests/ui/allow_attribute.stderr
deleted file mode 100644
index 58b7323b068..00000000000
--- a/tests/ui/allow_attribute.stderr
+++ /dev/null
@@ -1,16 +0,0 @@
-error: #[allow] attribute found
-  --> $DIR/allow_attribute.rs:11:3
-   |
-LL | #[allow(dead_code)]
-   |   ^^^^^ help: replace it with: `expect`
-   |
-   = note: `-D clippy::allow-attribute` implied by `-D warnings`
-
-error: #[allow] attribute found
-  --> $DIR/allow_attribute.rs:20:30
-   |
-LL | #[cfg_attr(panic = "unwind", allow(dead_code))]
-   |                              ^^^^^ help: replace it with: `expect`
-
-error: aborting due to 2 previous errors
-
diff --git a/tests/ui/allow_attributes.fixed b/tests/ui/allow_attributes.fixed
new file mode 100644
index 00000000000..b8dd0619e6d
--- /dev/null
+++ b/tests/ui/allow_attributes.fixed
@@ -0,0 +1,25 @@
+// run-rustfix
+#![allow(unused)]
+#![warn(clippy::allow_attributes)]
+#![feature(lint_reasons)]
+
+fn main() {}
+
+// Using clippy::needless_borrow just as a placeholder, it isn't relevant.
+
+// Should lint
+#[expect(dead_code)]
+struct T1;
+
+struct T2; // Should not lint
+#[deny(clippy::needless_borrow)] // Should not lint
+struct T3;
+#[warn(clippy::needless_borrow)] // Should not lint
+struct T4;
+// `panic = "unwind"` should always be true
+#[cfg_attr(panic = "unwind", expect(dead_code))]
+struct CfgT;
+
+fn ignore_inner_attr() {
+    #![allow(unused)] // Should not lint
+}
diff --git a/tests/ui/allow_attributes.rs b/tests/ui/allow_attributes.rs
new file mode 100644
index 00000000000..295f560906a
--- /dev/null
+++ b/tests/ui/allow_attributes.rs
@@ -0,0 +1,25 @@
+// run-rustfix
+#![allow(unused)]
+#![warn(clippy::allow_attributes)]
+#![feature(lint_reasons)]
+
+fn main() {}
+
+// Using clippy::needless_borrow just as a placeholder, it isn't relevant.
+
+// Should lint
+#[allow(dead_code)]
+struct T1;
+
+struct T2; // Should not lint
+#[deny(clippy::needless_borrow)] // Should not lint
+struct T3;
+#[warn(clippy::needless_borrow)] // Should not lint
+struct T4;
+// `panic = "unwind"` should always be true
+#[cfg_attr(panic = "unwind", allow(dead_code))]
+struct CfgT;
+
+fn ignore_inner_attr() {
+    #![allow(unused)] // Should not lint
+}
diff --git a/tests/ui/allow_attributes.stderr b/tests/ui/allow_attributes.stderr
new file mode 100644
index 00000000000..681837e9ed7
--- /dev/null
+++ b/tests/ui/allow_attributes.stderr
@@ -0,0 +1,16 @@
+error: #[allow] attribute found
+  --> $DIR/allow_attributes.rs:11:3
+   |
+LL | #[allow(dead_code)]
+   |   ^^^^^ help: replace it with: `expect`
+   |
+   = note: `-D clippy::allow-attributes` implied by `-D warnings`
+
+error: #[allow] attribute found
+  --> $DIR/allow_attributes.rs:20:30
+   |
+LL | #[cfg_attr(panic = "unwind", allow(dead_code))]
+   |                              ^^^^^ help: replace it with: `expect`
+
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 1cab0cbaf0dddb4cd403c4a0c391315801a22835 Mon Sep 17 00:00:00 2001
From: blyxyas <blyxyas@gmail.com>
Date: Wed, 15 Mar 2023 23:20:52 +0100
Subject: Fix formatting, remove commented code, etc...

---
 clippy_lints/src/allow_attributes.rs | 22 +++++++---------------
 1 file changed, 7 insertions(+), 15 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/allow_attributes.rs b/clippy_lints/src/allow_attributes.rs
index 3d660a11ea3..15d46e954a9 100644
--- a/clippy_lints/src/allow_attributes.rs
+++ b/clippy_lints/src/allow_attributes.rs
@@ -6,7 +6,7 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
-        /// Detects uses of the `#[allow]` attribute and suggests replacing it with
+    /// Detects uses of the `#[allow]` attribute and suggests replacing it with
     /// the `#[expect]` (See [RFC 2383](https://rust-lang.github.io/rfcs/2383-lint-reasons.html))
     ///
     /// The expect attribute is still unstable and requires the `lint_reasons`
@@ -28,11 +28,11 @@ declare_clippy_lint! {
     /// fn foo() -> usize {
     ///    let mut a = Vec::new();
     ///    a.len()
-    ///}
+    /// }
     /// ```
     /// Use instead:
     /// ```rust,ignore
-    /// # #![feature(lint_reasons)]
+    /// #![feature(lint_reasons)]
     /// #[expect(unused_mut)]
     /// fn foo() -> usize {
     ///     let mut a = Vec::new();
@@ -61,18 +61,10 @@ impl LateLintPass<'_> for AllowAttribute {
                     ALLOW_ATTRIBUTES,
                     ident.span,
                     "#[allow] attribute found",
-                    "replace it with", "expect".into()
-                    // format!("expect{}", snippet(
-                    //     cx,
-                    //     ident.span
-                    //     .with_lo(
-                    //         ident.span.hi() + BytePos(2) // Cut *(
-                    //     )
-                    //     .with_hi(
-                    //         attr.meta().unwrap().span.hi() - BytePos(1) // Cut )
-                    //     )
-                    //     , "..."))
-                    , Applicability::MachineApplicable);
+                    "replace it with",
+                    "expect".into(),
+                    Applicability::MachineApplicable,
+                );
             }
         }
     }
-- 
cgit 1.4.1-3-g733a5


From afe27ba1a2fbf902ecb5bd02590871be5f46f34d Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Sun, 5 Mar 2023 12:38:23 +0100
Subject: Issue function modifiers in the right order in manual_async_fn lint

---
 clippy_lints/src/manual_async_fn.rs | 14 ++++++++---
 tests/ui/manual_async_fn.fixed      |  6 +++++
 tests/ui/manual_async_fn.rs         | 12 ++++++++++
 tests/ui/manual_async_fn.stderr     | 47 ++++++++++++++++++++++++++++++++++++-
 4 files changed, 75 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_async_fn.rs b/clippy_lints/src/manual_async_fn.rs
index 3778eb4c732..af52090d8a4 100644
--- a/clippy_lints/src/manual_async_fn.rs
+++ b/clippy_lints/src/manual_async_fn.rs
@@ -6,7 +6,7 @@ use rustc_errors::Applicability;
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::{
     AsyncGeneratorKind, Block, Body, Closure, Expr, ExprKind, FnDecl, FnRetTy, GeneratorKind, GenericArg, GenericBound,
-    ItemKind, LifetimeName, Term, TraitRef, Ty, TyKind, TypeBindingKind,
+    ImplItem, Item, ItemKind, LifetimeName, Node, Term, TraitRef, Ty, TyKind, TypeBindingKind,
 };
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -46,7 +46,7 @@ impl<'tcx> LateLintPass<'tcx> for ManualAsyncFn {
         decl: &'tcx FnDecl<'_>,
         body: &'tcx Body<'_>,
         span: Span,
-        _: LocalDefId,
+        def_id: LocalDefId,
     ) {
         if_chain! {
             if let Some(header) = kind.header();
@@ -60,6 +60,8 @@ impl<'tcx> LateLintPass<'tcx> for ManualAsyncFn {
             if let ExprKind::Block(block, _) = body.value.kind;
             if block.stmts.is_empty();
             if let Some(closure_body) = desugared_async_block(cx, block);
+            if let Node::Item(Item {vis_span, ..}) | Node::ImplItem(ImplItem {vis_span, ..}) =
+                cx.tcx.hir().get_by_def_id(def_id);
             then {
                 let header_span = span.with_hi(ret_ty.span.hi());
 
@@ -70,15 +72,21 @@ impl<'tcx> LateLintPass<'tcx> for ManualAsyncFn {
                     "this function can be simplified using the `async fn` syntax",
                     |diag| {
                         if_chain! {
+                            if let Some(vis_snip) = snippet_opt(cx, *vis_span);
                             if let Some(header_snip) = snippet_opt(cx, header_span);
                             if let Some(ret_pos) = position_before_rarrow(&header_snip);
                             if let Some((ret_sugg, ret_snip)) = suggested_ret(cx, output);
                             then {
+                                let header_snip = if !vis_snip.is_empty() {
+                                    format!("{} async {}", vis_snip, &header_snip[vis_snip.len() + 1..ret_pos])
+                                } else {
+                                    format!("async {}", &header_snip[..ret_pos])
+                                };
                                 let help = format!("make the function `async` and {ret_sugg}");
                                 diag.span_suggestion(
                                     header_span,
                                     help,
-                                    format!("async {}{ret_snip}", &header_snip[..ret_pos]),
+                                    format!("{header_snip}{ret_snip}"),
                                     Applicability::MachineApplicable
                                 );
 
diff --git a/tests/ui/manual_async_fn.fixed b/tests/ui/manual_async_fn.fixed
index b7e46a4a8cc..5cc4a43af7e 100644
--- a/tests/ui/manual_async_fn.fixed
+++ b/tests/ui/manual_async_fn.fixed
@@ -107,4 +107,10 @@ mod issue_5765 {
     }
 }
 
+pub async fn issue_10450() -> i32 { 42 }
+
+pub(crate) async fn issue_10450_2() -> i32 { 42 }
+
+pub(self) async fn issue_10450_3() -> i32 { 42 }
+
 fn main() {}
diff --git a/tests/ui/manual_async_fn.rs b/tests/ui/manual_async_fn.rs
index b05429da662..ba504b8a823 100644
--- a/tests/ui/manual_async_fn.rs
+++ b/tests/ui/manual_async_fn.rs
@@ -127,4 +127,16 @@ mod issue_5765 {
     }
 }
 
+pub fn issue_10450() -> impl Future<Output = i32> {
+    async { 42 }
+}
+
+pub(crate) fn issue_10450_2() -> impl Future<Output = i32> {
+    async { 42 }
+}
+
+pub(self) fn issue_10450_3() -> impl Future<Output = i32> {
+    async { 42 }
+}
+
 fn main() {}
diff --git a/tests/ui/manual_async_fn.stderr b/tests/ui/manual_async_fn.stderr
index 0a903ed6fd4..f5ee3eb7ccc 100644
--- a/tests/ui/manual_async_fn.stderr
+++ b/tests/ui/manual_async_fn.stderr
@@ -161,5 +161,50 @@ help: move the body of the async block to the enclosing function
 LL | fn explicit<'a, 'b>(_: &'a i32, _: &'b i32) -> impl Future<Output = i32> + 'a + 'b { 42 }
    |                                                                                    ~~~~~~
 
-error: aborting due to 10 previous errors
+error: this function can be simplified using the `async fn` syntax
+  --> $DIR/manual_async_fn.rs:130:1
+   |
+LL | pub fn issue_10450() -> impl Future<Output = i32> {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: make the function `async` and return the output of the future directly
+   |
+LL | pub async fn issue_10450() -> i32 {
+   | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+help: move the body of the async block to the enclosing function
+   |
+LL | pub fn issue_10450() -> impl Future<Output = i32> { 42 }
+   |                                                   ~~~~~~
+
+error: this function can be simplified using the `async fn` syntax
+  --> $DIR/manual_async_fn.rs:134:1
+   |
+LL | pub(crate) fn issue_10450_2() -> impl Future<Output = i32> {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: make the function `async` and return the output of the future directly
+   |
+LL | pub(crate) async fn issue_10450_2() -> i32 {
+   | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+help: move the body of the async block to the enclosing function
+   |
+LL | pub(crate) fn issue_10450_2() -> impl Future<Output = i32> { 42 }
+   |                                                            ~~~~~~
+
+error: this function can be simplified using the `async fn` syntax
+  --> $DIR/manual_async_fn.rs:138:1
+   |
+LL | pub(self) fn issue_10450_3() -> impl Future<Output = i32> {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: make the function `async` and return the output of the future directly
+   |
+LL | pub(self) async fn issue_10450_3() -> i32 {
+   | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+help: move the body of the async block to the enclosing function
+   |
+LL | pub(self) fn issue_10450_3() -> impl Future<Output = i32> { 42 }
+   |                                                           ~~~~~~
+
+error: aborting due to 13 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 9546517a842f31be2258a70ae940dd9071e2913a Mon Sep 17 00:00:00 2001
From: blyxyas <blyxyas@gmail.com>
Date: Thu, 16 Mar 2023 19:48:23 +0100
Subject: Add external macro test + Now it works

---
 clippy_lints/src/swap.rs          |  5 ++---
 tests/ui/auxiliary/macro_rules.rs | 10 ++++++++++
 tests/ui/swap.fixed               | 10 +++-------
 tests/ui/swap.rs                  | 10 +++-------
 tests/ui/swap.stderr              | 34 +++++++++++++++++-----------------
 5 files changed, 35 insertions(+), 34 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/swap.rs b/clippy_lints/src/swap.rs
index 938ca3a6cee..50298898d03 100644
--- a/clippy_lints/src/swap.rs
+++ b/clippy_lints/src/swap.rs
@@ -76,9 +76,7 @@ declare_lint_pass!(Swap => [MANUAL_SWAP, ALMOST_SWAPPED]);
 impl<'tcx> LateLintPass<'tcx> for Swap {
     fn check_block(&mut self, cx: &LateContext<'tcx>, block: &'tcx Block<'_>) {
         check_manual_swap(cx, block);
-        if !in_external_macro(cx.sess(), block.span) {
-            check_suspicious_swap(cx, block);
-        }
+        check_suspicious_swap(cx, block);
         check_xor_swap(cx, block);
     }
 }
@@ -191,6 +189,7 @@ fn check_suspicious_swap(cx: &LateContext<'_>, block: &Block<'_>) {
         if let Some((lhs0, rhs0)) = parse(first)
             && let Some((lhs1, rhs1)) = parse(second)
             && first.span.eq_ctxt(second.span)
+			&& !in_external_macro(&cx.sess(), first.span)
             && is_same(cx, lhs0, rhs1)
             && is_same(cx, lhs1, rhs0)
 			&& !is_same(cx, lhs1, rhs1) // Ignore a = b; a = a (#10421)
diff --git a/tests/ui/auxiliary/macro_rules.rs b/tests/ui/auxiliary/macro_rules.rs
index 1dc92c1b92b..a9bb61451dc 100644
--- a/tests/ui/auxiliary/macro_rules.rs
+++ b/tests/ui/auxiliary/macro_rules.rs
@@ -27,3 +27,13 @@ macro_rules! mut_mut {
         let mut_mut_ty: &mut &mut u32 = &mut &mut 1u32;
     };
 }
+
+#[macro_export]
+macro_rules! issue_10421 {
+    () => {
+        let mut a = 1;
+        let mut b = 2;
+        a = b;
+        b = a;
+    };
+}
diff --git a/tests/ui/swap.fixed b/tests/ui/swap.fixed
index 78d8eedc38a..9703674d1a4 100644
--- a/tests/ui/swap.fixed
+++ b/tests/ui/swap.fixed
@@ -1,4 +1,5 @@
 // run-rustfix
+// aux-build: macro_rules.rs
 
 #![warn(clippy::all)]
 #![allow(
@@ -188,13 +189,8 @@ const fn issue_9864(mut u: u32) -> u32 {
     u + v
 }
 
-macro_rules! issue_10421 {
-    () => {
-        let a = 1;
-        let b = a;
-        let b = b;
-    };
-}
+#[macro_use]
+extern crate macro_rules;
 
 const fn issue_10421(x: u32) -> u32 {
     issue_10421!();
diff --git a/tests/ui/swap.rs b/tests/ui/swap.rs
index c995af8ecf9..a0228065e46 100644
--- a/tests/ui/swap.rs
+++ b/tests/ui/swap.rs
@@ -1,4 +1,5 @@
 // run-rustfix
+// aux-build: macro_rules.rs
 
 #![warn(clippy::all)]
 #![allow(
@@ -217,13 +218,8 @@ const fn issue_9864(mut u: u32) -> u32 {
     u + v
 }
 
-macro_rules! issue_10421 {
-    () => {
-        let a = 1;
-        let b = a;
-        let b = b;
-    };
-}
+#[macro_use]
+extern crate macro_rules;
 
 const fn issue_10421(x: u32) -> u32 {
     issue_10421!();
diff --git a/tests/ui/swap.stderr b/tests/ui/swap.stderr
index e9dacb3119e..0c246268499 100644
--- a/tests/ui/swap.stderr
+++ b/tests/ui/swap.stderr
@@ -1,5 +1,5 @@
 error: this looks like you are swapping `bar.a` and `bar.b` manually
-  --> $DIR/swap.rs:26:5
+  --> $DIR/swap.rs:27:5
    |
 LL | /     let temp = bar.a;
 LL | |     bar.a = bar.b;
@@ -10,7 +10,7 @@ LL | |     bar.b = temp;
    = note: `-D clippy::manual-swap` implied by `-D warnings`
 
 error: this looks like you are swapping elements of `foo` manually
-  --> $DIR/swap.rs:38:5
+  --> $DIR/swap.rs:39:5
    |
 LL | /     let temp = foo[0];
 LL | |     foo[0] = foo[1];
@@ -18,7 +18,7 @@ LL | |     foo[1] = temp;
    | |__________________^ help: try: `foo.swap(0, 1);`
 
 error: this looks like you are swapping elements of `foo` manually
-  --> $DIR/swap.rs:47:5
+  --> $DIR/swap.rs:48:5
    |
 LL | /     let temp = foo[0];
 LL | |     foo[0] = foo[1];
@@ -26,7 +26,7 @@ LL | |     foo[1] = temp;
    | |__________________^ help: try: `foo.swap(0, 1);`
 
 error: this looks like you are swapping elements of `foo` manually
-  --> $DIR/swap.rs:66:5
+  --> $DIR/swap.rs:67:5
    |
 LL | /     let temp = foo[0];
 LL | |     foo[0] = foo[1];
@@ -34,7 +34,7 @@ LL | |     foo[1] = temp;
    | |__________________^ help: try: `foo.swap(0, 1);`
 
 error: this looks like you are swapping `a` and `b` manually
-  --> $DIR/swap.rs:77:5
+  --> $DIR/swap.rs:78:5
    |
 LL | /     a ^= b;
 LL | |     b ^= a;
@@ -42,7 +42,7 @@ LL | |     a ^= b;
    | |___________^ help: try: `std::mem::swap(&mut a, &mut b);`
 
 error: this looks like you are swapping `bar.a` and `bar.b` manually
-  --> $DIR/swap.rs:85:5
+  --> $DIR/swap.rs:86:5
    |
 LL | /     bar.a ^= bar.b;
 LL | |     bar.b ^= bar.a;
@@ -50,7 +50,7 @@ LL | |     bar.a ^= bar.b;
    | |___________________^ help: try: `std::mem::swap(&mut bar.a, &mut bar.b);`
 
 error: this looks like you are swapping elements of `foo` manually
-  --> $DIR/swap.rs:93:5
+  --> $DIR/swap.rs:94:5
    |
 LL | /     foo[0] ^= foo[1];
 LL | |     foo[1] ^= foo[0];
@@ -58,7 +58,7 @@ LL | |     foo[0] ^= foo[1];
    | |_____________________^ help: try: `foo.swap(0, 1);`
 
 error: this looks like you are swapping `foo[0][1]` and `bar[1][0]` manually
-  --> $DIR/swap.rs:122:5
+  --> $DIR/swap.rs:123:5
    |
 LL | /     let temp = foo[0][1];
 LL | |     foo[0][1] = bar[1][0];
@@ -68,7 +68,7 @@ LL | |     bar[1][0] = temp;
    = note: or maybe you should use `std::mem::replace`?
 
 error: this looks like you are swapping `a` and `b` manually
-  --> $DIR/swap.rs:136:7
+  --> $DIR/swap.rs:137:7
    |
 LL |       ; let t = a;
    |  _______^
@@ -79,7 +79,7 @@ LL | |     b = t;
    = note: or maybe you should use `std::mem::replace`?
 
 error: this looks like you are swapping `c.0` and `a` manually
-  --> $DIR/swap.rs:145:7
+  --> $DIR/swap.rs:146:7
    |
 LL |       ; let t = c.0;
    |  _______^
@@ -90,7 +90,7 @@ LL | |     a = t;
    = note: or maybe you should use `std::mem::replace`?
 
 error: this looks like you are swapping `b` and `a` manually
-  --> $DIR/swap.rs:171:5
+  --> $DIR/swap.rs:172:5
    |
 LL | /     let t = b;
 LL | |     b = a;
@@ -100,7 +100,7 @@ LL | |     a = t;
    = note: or maybe you should use `std::mem::replace`?
 
 error: this looks like you are trying to swap `a` and `b`
-  --> $DIR/swap.rs:133:5
+  --> $DIR/swap.rs:134:5
    |
 LL | /     a = b;
 LL | |     b = a;
@@ -110,7 +110,7 @@ LL | |     b = a;
    = note: `-D clippy::almost-swapped` implied by `-D warnings`
 
 error: this looks like you are trying to swap `c.0` and `a`
-  --> $DIR/swap.rs:142:5
+  --> $DIR/swap.rs:143:5
    |
 LL | /     c.0 = a;
 LL | |     a = c.0;
@@ -119,7 +119,7 @@ LL | |     a = c.0;
    = note: or maybe you should use `std::mem::replace`?
 
 error: this looks like you are trying to swap `a` and `b`
-  --> $DIR/swap.rs:149:5
+  --> $DIR/swap.rs:150:5
    |
 LL | /     let a = b;
 LL | |     let b = a;
@@ -128,7 +128,7 @@ LL | |     let b = a;
    = note: or maybe you should use `std::mem::replace`?
 
 error: this looks like you are trying to swap `d` and `c`
-  --> $DIR/swap.rs:154:5
+  --> $DIR/swap.rs:155:5
    |
 LL | /     d = c;
 LL | |     c = d;
@@ -137,7 +137,7 @@ LL | |     c = d;
    = note: or maybe you should use `std::mem::replace`?
 
 error: this looks like you are trying to swap `a` and `b`
-  --> $DIR/swap.rs:158:5
+  --> $DIR/swap.rs:159:5
    |
 LL | /     let a = b;
 LL | |     b = a;
@@ -146,7 +146,7 @@ LL | |     b = a;
    = note: or maybe you should use `std::mem::replace`?
 
 error: this looks like you are swapping `s.0.x` and `s.0.y` manually
-  --> $DIR/swap.rs:206:5
+  --> $DIR/swap.rs:207:5
    |
 LL | /     let t = s.0.x;
 LL | |     s.0.x = s.0.y;
-- 
cgit 1.4.1-3-g733a5


From ffabdab8cf1499e1857d9ebcac2c410220137025 Mon Sep 17 00:00:00 2001
From: "Samuel \"Sam\" Tardieu" <sam@rfc1149.net>
Date: Sat, 11 Mar 2023 10:20:44 +0100
Subject: New lint to detect `&std::path::MAIN_SEPARATOR.to_string()`

---
 CHANGELOG.md                                  |  1 +
 clippy_lints/src/declared_lints.rs            |  1 +
 clippy_lints/src/lib.rs                       |  2 +
 clippy_lints/src/manual_main_separator_str.rs | 72 +++++++++++++++++++++++++++
 clippy_utils/src/msrvs.rs                     |  1 +
 clippy_utils/src/paths.rs                     |  1 +
 tests/ui/manual_main_separator_str.fixed      | 39 +++++++++++++++
 tests/ui/manual_main_separator_str.rs         | 39 +++++++++++++++
 tests/ui/manual_main_separator_str.stderr     | 28 +++++++++++
 9 files changed, 184 insertions(+)
 create mode 100644 clippy_lints/src/manual_main_separator_str.rs
 create mode 100644 tests/ui/manual_main_separator_str.fixed
 create mode 100644 tests/ui/manual_main_separator_str.rs
 create mode 100644 tests/ui/manual_main_separator_str.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index c090a844858..47a503510c1 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4662,6 +4662,7 @@ Released 2018-09-13
 [`manual_instant_elapsed`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_instant_elapsed
 [`manual_is_ascii_check`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_is_ascii_check
 [`manual_let_else`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_let_else
+[`manual_main_separator_str`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_main_separator_str
 [`manual_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_map
 [`manual_memcpy`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_memcpy
 [`manual_non_exhaustive`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_non_exhaustive
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 25f15973490..2331e857b1f 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -263,6 +263,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::manual_clamp::MANUAL_CLAMP_INFO,
     crate::manual_is_ascii_check::MANUAL_IS_ASCII_CHECK_INFO,
     crate::manual_let_else::MANUAL_LET_ELSE_INFO,
+    crate::manual_main_separator_str::MANUAL_MAIN_SEPARATOR_STR_INFO,
     crate::manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE_INFO,
     crate::manual_rem_euclid::MANUAL_REM_EUCLID_INFO,
     crate::manual_retain::MANUAL_RETAIN_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 4bb0e2ec96c..100cba45679 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -180,6 +180,7 @@ mod manual_bits;
 mod manual_clamp;
 mod manual_is_ascii_check;
 mod manual_let_else;
+mod manual_main_separator_str;
 mod manual_non_exhaustive;
 mod manual_rem_euclid;
 mod manual_retain;
@@ -936,6 +937,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_early_pass(|| Box::new(redundant_async_block::RedundantAsyncBlock));
     store.register_late_pass(|_| Box::new(let_with_type_underscore::UnderscoreTyped));
     store.register_late_pass(|_| Box::new(allow_attributes::AllowAttribute));
+    store.register_late_pass(move |_| Box::new(manual_main_separator_str::ManualMainSeparatorStr::new(msrv())));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/manual_main_separator_str.rs b/clippy_lints/src/manual_main_separator_str.rs
new file mode 100644
index 00000000000..a6d318f952c
--- /dev/null
+++ b/clippy_lints/src/manual_main_separator_str.rs
@@ -0,0 +1,72 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::msrvs::{self, Msrv};
+use clippy_utils::{is_trait_method, match_def_path, paths, peel_hir_expr_refs};
+use rustc_errors::Applicability;
+use rustc_hir::def::{DefKind, Res};
+use rustc_hir::*;
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty;
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::sym;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for references on `std::path::MAIN_SEPARATOR.to_string()` used
+    /// to build a `&str`.
+    ///
+    /// ### Why is this bad?
+    /// There exists a `std::path::MAIN_SEPARATOR_STR` which does not require
+    /// an extra memory allocation.
+    ///
+    /// ### Example
+    /// ```rust
+    /// let s: &str = &std::path::MAIN_SEPARATOR.to_string();
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// let s: &str = std::path::MAIN_SEPARATOR_STR;
+    /// ```
+    #[clippy::version = "1.70.0"]
+    pub MANUAL_MAIN_SEPARATOR_STR,
+    complexity,
+    "`&std::path::MAIN_SEPARATOR.to_string()` can be replaced by `std::path::MAIN_SEPARATOR_STR`"
+}
+
+pub struct ManualMainSeparatorStr {
+    msrv: Msrv,
+}
+
+impl ManualMainSeparatorStr {
+    #[must_use]
+    pub fn new(msrv: Msrv) -> Self {
+        Self { msrv }
+    }
+}
+
+impl_lint_pass!(ManualMainSeparatorStr => [MANUAL_MAIN_SEPARATOR_STR]);
+
+impl LateLintPass<'_> for ManualMainSeparatorStr {
+    fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
+        if self.msrv.meets(msrvs::PATH_MAIN_SEPARATOR_STR) &&
+            let (target, _) = peel_hir_expr_refs(expr) &&
+            is_trait_method(cx, target, sym::ToString) &&
+            let ExprKind::MethodCall(path, receiver, &[], _) = target.kind &&
+            path.ident.name == sym::to_string &&
+            let ExprKind::Path(QPath::Resolved(None, path)) = receiver.kind &&
+            let Res::Def(DefKind::Const, receiver_def_id) = path.res &&
+            match_def_path(cx, receiver_def_id, &paths::PATH_MAIN_SEPARATOR) &&
+            let ty::Ref(_, ty, Mutability::Not) = cx.typeck_results().expr_ty_adjusted(expr).kind() &&
+            ty.is_str()
+            {
+                span_lint_and_sugg(
+                    cx,
+                    MANUAL_MAIN_SEPARATOR_STR,
+                    expr.span,
+                    "taking a reference on `std::path::MAIN_SEPARATOR` conversion to `String`",
+                    "replace with",
+                    "std::path::MAIN_SEPARATOR_STR".to_owned(),
+                    Applicability::MachineApplicable,
+                );
+            }
+    }
+}
diff --git a/clippy_utils/src/msrvs.rs b/clippy_utils/src/msrvs.rs
index dbf9f3b621d..e05de2dc99c 100644
--- a/clippy_utils/src/msrvs.rs
+++ b/clippy_utils/src/msrvs.rs
@@ -19,6 +19,7 @@ macro_rules! msrv_aliases {
 
 // names may refer to stabilized feature flags or library items
 msrv_aliases! {
+    1,68,0 { PATH_MAIN_SEPARATOR_STR }
     1,65,0 { LET_ELSE }
     1,62,0 { BOOL_THEN_SOME, DEFAULT_ENUM_ATTRIBUTE }
     1,58,0 { FORMAT_ARGS_CAPTURE, PATTERN_TRAIT_CHAR_ARRAY }
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index 4aae0f7284e..c919575bfe9 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -67,6 +67,7 @@ pub const PARKING_LOT_MUTEX_GUARD: [&str; 3] = ["lock_api", "mutex", "MutexGuard
 pub const PARKING_LOT_RWLOCK_READ_GUARD: [&str; 3] = ["lock_api", "rwlock", "RwLockReadGuard"];
 pub const PARKING_LOT_RWLOCK_WRITE_GUARD: [&str; 3] = ["lock_api", "rwlock", "RwLockWriteGuard"];
 pub const PATH_BUF_AS_PATH: [&str; 4] = ["std", "path", "PathBuf", "as_path"];
+pub const PATH_MAIN_SEPARATOR: [&str; 3] = ["std", "path", "MAIN_SEPARATOR"];
 pub const PATH_TO_PATH_BUF: [&str; 4] = ["std", "path", "Path", "to_path_buf"];
 pub const PEEKABLE: [&str; 5] = ["core", "iter", "adapters", "peekable", "Peekable"];
 pub const PERMISSIONS: [&str; 3] = ["std", "fs", "Permissions"];
diff --git a/tests/ui/manual_main_separator_str.fixed b/tests/ui/manual_main_separator_str.fixed
new file mode 100644
index 00000000000..50f46d6b355
--- /dev/null
+++ b/tests/ui/manual_main_separator_str.fixed
@@ -0,0 +1,39 @@
+// run-rustfix
+
+#![allow(unused)]
+#![warn(clippy::manual_main_separator_str)]
+
+use std::path::MAIN_SEPARATOR;
+
+fn len(s: &str) -> usize {
+    s.len()
+}
+
+struct U<'a> {
+    f: &'a str,
+    g: &'a String,
+}
+
+struct V<T> {
+    f: T,
+}
+
+fn main() {
+    // Should lint
+    let _: &str = std::path::MAIN_SEPARATOR_STR;
+    let _ = len(std::path::MAIN_SEPARATOR_STR);
+    let _: Vec<u16> = std::path::MAIN_SEPARATOR_STR.encode_utf16().collect();
+
+    // Should lint for field `f` only
+    let _ = U {
+        f: std::path::MAIN_SEPARATOR_STR,
+        g: &MAIN_SEPARATOR.to_string(),
+    };
+
+    // Should not lint
+    let _: &String = &MAIN_SEPARATOR.to_string();
+    let _ = &MAIN_SEPARATOR.to_string();
+    let _ = V {
+        f: &MAIN_SEPARATOR.to_string(),
+    };
+}
diff --git a/tests/ui/manual_main_separator_str.rs b/tests/ui/manual_main_separator_str.rs
new file mode 100644
index 00000000000..2dbb9e66151
--- /dev/null
+++ b/tests/ui/manual_main_separator_str.rs
@@ -0,0 +1,39 @@
+// run-rustfix
+
+#![allow(unused)]
+#![warn(clippy::manual_main_separator_str)]
+
+use std::path::MAIN_SEPARATOR;
+
+fn len(s: &str) -> usize {
+    s.len()
+}
+
+struct U<'a> {
+    f: &'a str,
+    g: &'a String,
+}
+
+struct V<T> {
+    f: T,
+}
+
+fn main() {
+    // Should lint
+    let _: &str = &MAIN_SEPARATOR.to_string();
+    let _ = len(&MAIN_SEPARATOR.to_string());
+    let _: Vec<u16> = MAIN_SEPARATOR.to_string().encode_utf16().collect();
+
+    // Should lint for field `f` only
+    let _ = U {
+        f: &MAIN_SEPARATOR.to_string(),
+        g: &MAIN_SEPARATOR.to_string(),
+    };
+
+    // Should not lint
+    let _: &String = &MAIN_SEPARATOR.to_string();
+    let _ = &MAIN_SEPARATOR.to_string();
+    let _ = V {
+        f: &MAIN_SEPARATOR.to_string(),
+    };
+}
diff --git a/tests/ui/manual_main_separator_str.stderr b/tests/ui/manual_main_separator_str.stderr
new file mode 100644
index 00000000000..e6cefde66a7
--- /dev/null
+++ b/tests/ui/manual_main_separator_str.stderr
@@ -0,0 +1,28 @@
+error: taking a reference on `std::path::MAIN_SEPARATOR` conversion to `String`
+  --> $DIR/manual_main_separator_str.rs:23:19
+   |
+LL |     let _: &str = &MAIN_SEPARATOR.to_string();
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `std::path::MAIN_SEPARATOR_STR`
+   |
+   = note: `-D clippy::manual-main-separator-str` implied by `-D warnings`
+
+error: taking a reference on `std::path::MAIN_SEPARATOR` conversion to `String`
+  --> $DIR/manual_main_separator_str.rs:24:17
+   |
+LL |     let _ = len(&MAIN_SEPARATOR.to_string());
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `std::path::MAIN_SEPARATOR_STR`
+
+error: taking a reference on `std::path::MAIN_SEPARATOR` conversion to `String`
+  --> $DIR/manual_main_separator_str.rs:25:23
+   |
+LL |     let _: Vec<u16> = MAIN_SEPARATOR.to_string().encode_utf16().collect();
+   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `std::path::MAIN_SEPARATOR_STR`
+
+error: taking a reference on `std::path::MAIN_SEPARATOR` conversion to `String`
+  --> $DIR/manual_main_separator_str.rs:29:12
+   |
+LL |         f: &MAIN_SEPARATOR.to_string(),
+   |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `std::path::MAIN_SEPARATOR_STR`
+
+error: aborting due to 4 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 4fdae81c70bfa1481eebc7ebec09f121c6eaf53c Mon Sep 17 00:00:00 2001
From: csmoe <csmoe@msn.com>
Date: Mon, 27 Feb 2023 11:57:32 +0000
Subject: add large future lint

---
 CHANGELOG.md                                       |  3 +-
 clippy_lints/src/declared_lints.rs                 |  1 +
 clippy_lints/src/large_futures.rs                  | 90 ++++++++++++++++++++++
 clippy_lints/src/lib.rs                            |  3 +
 clippy_lints/src/utils/conf.rs                     |  4 +
 tests/ui-toml/large_futures/clippy.toml            |  1 +
 tests/ui-toml/large_futures/large_futures.fixed    | 29 +++++++
 tests/ui-toml/large_futures/large_futures.rs       | 29 +++++++
 tests/ui-toml/large_futures/large_futures.stderr   | 10 +++
 .../toml_unknown_key/conf_unknown_key.stderr       |  1 +
 tests/ui/large_futures.fixed                       | 41 ++++++++++
 tests/ui/large_futures.rs                          | 41 ++++++++++
 tests/ui/large_futures.stderr                      | 40 ++++++++++
 13 files changed, 292 insertions(+), 1 deletion(-)
 create mode 100644 clippy_lints/src/large_futures.rs
 create mode 100644 tests/ui-toml/large_futures/clippy.toml
 create mode 100644 tests/ui-toml/large_futures/large_futures.fixed
 create mode 100644 tests/ui-toml/large_futures/large_futures.rs
 create mode 100644 tests/ui-toml/large_futures/large_futures.stderr
 create mode 100644 tests/ui/large_futures.fixed
 create mode 100644 tests/ui/large_futures.rs
 create mode 100644 tests/ui/large_futures.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 765826ed867..0352f956dfb 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -278,7 +278,7 @@ Released 2022-12-15
   [#9490](https://github.com/rust-lang/rust-clippy/pull/9490)
 * [`almost_complete_letter_range`]: No longer lints in external macros
   [#9467](https://github.com/rust-lang/rust-clippy/pull/9467)
-* [`drop_copy`]: No longer lints on idiomatic cases in match arms 
+* [`drop_copy`]: No longer lints on idiomatic cases in match arms
   [#9491](https://github.com/rust-lang/rust-clippy/pull/9491)
 * [`question_mark`]: No longer lints in const context
   [#9487](https://github.com/rust-lang/rust-clippy/pull/9487)
@@ -4485,6 +4485,7 @@ Released 2018-09-13
 [`large_const_arrays`]: https://rust-lang.github.io/rust-clippy/master/index.html#large_const_arrays
 [`large_digit_groups`]: https://rust-lang.github.io/rust-clippy/master/index.html#large_digit_groups
 [`large_enum_variant`]: https://rust-lang.github.io/rust-clippy/master/index.html#large_enum_variant
+[`large_futures`]: https://rust-lang.github.io/rust-clippy/master/index.html#large_futures
 [`large_include_file`]: https://rust-lang.github.io/rust-clippy/master/index.html#large_include_file
 [`large_stack_arrays`]: https://rust-lang.github.io/rust-clippy/master/index.html#large_stack_arrays
 [`large_types_passed_by_value`]: https://rust-lang.github.io/rust-clippy/master/index.html#large_types_passed_by_value
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index cd5dd7a5706..208112b4025 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -216,6 +216,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::iter_not_returning_iterator::ITER_NOT_RETURNING_ITERATOR_INFO,
     crate::large_const_arrays::LARGE_CONST_ARRAYS_INFO,
     crate::large_enum_variant::LARGE_ENUM_VARIANT_INFO,
+    crate::large_futures::LARGE_FUTURES_INFO,
     crate::large_include_file::LARGE_INCLUDE_FILE_INFO,
     crate::large_stack_arrays::LARGE_STACK_ARRAYS_INFO,
     crate::len_zero::COMPARISON_TO_EMPTY_INFO,
diff --git a/clippy_lints/src/large_futures.rs b/clippy_lints/src/large_futures.rs
new file mode 100644
index 00000000000..494bb2a97d2
--- /dev/null
+++ b/clippy_lints/src/large_futures.rs
@@ -0,0 +1,90 @@
+use clippy_utils::source::snippet;
+use clippy_utils::{diagnostics::span_lint_and_sugg, ty::implements_trait};
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind, LangItem, MatchSource, QPath};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_target::abi::Size;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// It checks for the size of a `Future` created by `async fn` or `async {}`.
+    ///
+    /// ### Why is this bad?
+    /// Due to the current [unideal implemention](https://github.com/rust-lang/rust/issues/69826) of `Generator`,
+    /// large size of a `Future` may cause stack overflows.
+    ///
+    /// ### Example
+    /// ```rust
+    /// async fn wait(f: impl std::future::Future<Output = ()>) {}
+    ///
+    /// async fn big_fut(arg: [u8; 1024]) {}
+    ///
+    /// pub async fn test() {
+    ///     let fut = big_fut([0u8; 1024]);
+    ///     wait(fut).await;
+    /// }
+    /// ```
+    ///
+    /// `Box::pin` the big future instead.
+    ///
+    /// ```rust
+    /// async fn wait(f: impl std::future::Future<Output = ()>) {}
+    ///
+    /// async fn big_fut(arg: [u8; 1024]) {}
+    ///
+    /// pub async fn test() {
+    ///     let fut = Box::pin(big_fut([0u8; 1024]));
+    ///     wait(fut).await;
+    /// }
+    /// ```
+    #[clippy::version = "1.68.0"]
+    pub LARGE_FUTURES,
+    pedantic,
+    "large future may lead to unexpected stack overflows"
+}
+
+#[derive(Copy, Clone)]
+pub struct LargeFuture {
+    future_size_threshold: u64,
+}
+
+impl LargeFuture {
+    pub fn new(future_size_threshold: u64) -> Self {
+        Self { future_size_threshold }
+    }
+}
+
+impl_lint_pass!(LargeFuture => [LARGE_FUTURES]);
+
+impl<'tcx> LateLintPass<'tcx> for LargeFuture {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
+        if let ExprKind::Match(expr, _, MatchSource::AwaitDesugar) = expr.kind {
+            if let ExprKind::Call(func, [expr, ..]) = expr.kind {
+                if matches!(
+                    func.kind,
+                    ExprKind::Path(QPath::LangItem(LangItem::IntoFutureIntoFuture, ..))
+                ) {
+                    let ty = cx.typeck_results().expr_ty(expr);
+                    if let Some(future_trait_def_id) = cx.tcx.lang_items().future_trait()
+                        && implements_trait(cx, ty, future_trait_def_id, &[]) {
+                            if let Ok(layout) = cx.tcx.layout_of(cx.param_env.and(ty)) {
+                                let size = layout.layout.size();
+                                if size >= Size::from_bytes(self.future_size_threshold) {
+                                    span_lint_and_sugg(
+                                        cx,
+                                        LARGE_FUTURES,
+                                        expr.span,
+                                        &format!("large future with a size of {} bytes", size.bytes()),
+                                        "consider `Box::pin` on it",
+                                        format!("Box::pin({})", snippet(cx, expr.span, "..")),
+                                        Applicability::MachineApplicable,
+                                    );
+                                }
+                            }
+                        }
+                }
+            }
+        }
+    }
+}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 145cf524652..155aa106322 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -161,6 +161,7 @@ mod items_after_statements;
 mod iter_not_returning_iterator;
 mod large_const_arrays;
 mod large_enum_variant;
+mod large_futures;
 mod large_include_file;
 mod large_stack_arrays;
 mod len_zero;
@@ -800,6 +801,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(move |_| Box::new(dereference::Dereferencing::new(msrv())));
     store.register_late_pass(|_| Box::new(option_if_let_else::OptionIfLetElse));
     store.register_late_pass(|_| Box::new(future_not_send::FutureNotSend));
+    let future_size_threshold = conf.future_size_threshold;
+    store.register_late_pass(move |_| Box::new(large_futures::LargeFuture::new(future_size_threshold)));
     store.register_late_pass(|_| Box::new(if_let_mutex::IfLetMutex));
     store.register_late_pass(|_| Box::new(if_not_else::IfNotElse));
     store.register_late_pass(|_| Box::new(equatable_if_let::PatternEquality));
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 5f74de5a288..639f8d95877 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -459,6 +459,10 @@ define_Conf! {
     /// Whether to **only** check for missing documentation in items visible within the current
     /// crate. For example, `pub(crate)` items.
     (missing_docs_in_crate_items: bool = false),
+    /// Lint: LARGE_FUTURES.
+    ///
+    /// The maximum byte size a `Future` can have, before it triggers the `clippy::large_futures` lint
+    (future_size_threshold: u64 = 16 * 1024),
 }
 
 /// Search for the configuration file.
diff --git a/tests/ui-toml/large_futures/clippy.toml b/tests/ui-toml/large_futures/clippy.toml
new file mode 100644
index 00000000000..61bb17fdf6b
--- /dev/null
+++ b/tests/ui-toml/large_futures/clippy.toml
@@ -0,0 +1 @@
+future-size-threshold = 1024
diff --git a/tests/ui-toml/large_futures/large_futures.fixed b/tests/ui-toml/large_futures/large_futures.fixed
new file mode 100644
index 00000000000..1238c512b0f
--- /dev/null
+++ b/tests/ui-toml/large_futures/large_futures.fixed
@@ -0,0 +1,29 @@
+// run-rustfix
+
+#![warn(clippy::large_futures)]
+
+fn main() {}
+
+pub async fn should_warn() {
+    let x = [0u8; 1024];
+    async {}.await;
+    dbg!(x);
+}
+
+pub async fn should_not_warn() {
+    let x = [0u8; 1020];
+    async {}.await;
+    dbg!(x);
+}
+
+pub async fn bar() {
+    Box::pin(should_warn()).await;
+
+    async {
+        let x = [0u8; 1024];
+        dbg!(x);
+    }
+    .await;
+
+    should_not_warn().await;
+}
diff --git a/tests/ui-toml/large_futures/large_futures.rs b/tests/ui-toml/large_futures/large_futures.rs
new file mode 100644
index 00000000000..80039d9047b
--- /dev/null
+++ b/tests/ui-toml/large_futures/large_futures.rs
@@ -0,0 +1,29 @@
+// run-rustfix
+
+#![warn(clippy::large_futures)]
+
+fn main() {}
+
+pub async fn should_warn() {
+    let x = [0u8; 1024];
+    async {}.await;
+    dbg!(x);
+}
+
+pub async fn should_not_warn() {
+    let x = [0u8; 1020];
+    async {}.await;
+    dbg!(x);
+}
+
+pub async fn bar() {
+    should_warn().await;
+
+    async {
+        let x = [0u8; 1024];
+        dbg!(x);
+    }
+    .await;
+
+    should_not_warn().await;
+}
diff --git a/tests/ui-toml/large_futures/large_futures.stderr b/tests/ui-toml/large_futures/large_futures.stderr
new file mode 100644
index 00000000000..f7895f8eaf7
--- /dev/null
+++ b/tests/ui-toml/large_futures/large_futures.stderr
@@ -0,0 +1,10 @@
+error: large future with a size of 1026 bytes
+  --> $DIR/large_futures.rs:20:5
+   |
+LL |     should_warn().await;
+   |     ^^^^^^^^^^^^^ help: consider `Box::pin` on it: `Box::pin(should_warn())`
+   |
+   = note: `-D clippy::large-futures` implied by `-D warnings`
+
+error: aborting due to previous error
+
diff --git a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
index 6a246afac76..8447c31722d 100644
--- a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
+++ b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
@@ -24,6 +24,7 @@ error: error reading Clippy's configuration file `$DIR/clippy.toml`: unknown fie
            enforced-import-renames
            enum-variant-name-threshold
            enum-variant-size-threshold
+           future-size-threshold
            ignore-interior-mutability
            large-error-threshold
            literal-representation-threshold
diff --git a/tests/ui/large_futures.fixed b/tests/ui/large_futures.fixed
new file mode 100644
index 00000000000..9d839998afd
--- /dev/null
+++ b/tests/ui/large_futures.fixed
@@ -0,0 +1,41 @@
+// run-rustfix
+
+#![feature(generators)]
+#![warn(clippy::large_futures)]
+#![allow(clippy::future_not_send)]
+#![allow(clippy::manual_async_fn)]
+
+async fn big_fut(_arg: [u8; 1024 * 16]) {}
+
+async fn wait() {
+    let f = async {
+        Box::pin(big_fut([0u8; 1024 * 16])).await;
+    };
+    Box::pin(f).await
+}
+async fn calls_fut(fut: impl std::future::Future<Output = ()>) {
+    loop {
+        Box::pin(wait()).await;
+        if true {
+            return fut.await;
+        } else {
+            Box::pin(wait()).await;
+        }
+    }
+}
+
+pub async fn test() {
+    let fut = big_fut([0u8; 1024 * 16]);
+    Box::pin(foo()).await;
+    Box::pin(calls_fut(fut)).await;
+}
+
+pub fn foo() -> impl std::future::Future<Output = ()> {
+    async {
+        let x = [0i32; 1024 * 16];
+        async {}.await;
+        dbg!(x);
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/large_futures.rs b/tests/ui/large_futures.rs
new file mode 100644
index 00000000000..8b7aaa61b88
--- /dev/null
+++ b/tests/ui/large_futures.rs
@@ -0,0 +1,41 @@
+// run-rustfix
+
+#![feature(generators)]
+#![warn(clippy::large_futures)]
+#![allow(clippy::future_not_send)]
+#![allow(clippy::manual_async_fn)]
+
+async fn big_fut(_arg: [u8; 1024 * 16]) {}
+
+async fn wait() {
+    let f = async {
+        big_fut([0u8; 1024 * 16]).await;
+    };
+    f.await
+}
+async fn calls_fut(fut: impl std::future::Future<Output = ()>) {
+    loop {
+        wait().await;
+        if true {
+            return fut.await;
+        } else {
+            wait().await;
+        }
+    }
+}
+
+pub async fn test() {
+    let fut = big_fut([0u8; 1024 * 16]);
+    foo().await;
+    calls_fut(fut).await;
+}
+
+pub fn foo() -> impl std::future::Future<Output = ()> {
+    async {
+        let x = [0i32; 1024 * 16];
+        async {}.await;
+        dbg!(x);
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/large_futures.stderr b/tests/ui/large_futures.stderr
new file mode 100644
index 00000000000..557455299a9
--- /dev/null
+++ b/tests/ui/large_futures.stderr
@@ -0,0 +1,40 @@
+error: large future with a size of 16385 bytes
+  --> $DIR/large_futures.rs:12:9
+   |
+LL |         big_fut([0u8; 1024 * 16]).await;
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider `Box::pin` on it: `Box::pin(big_fut([0u8; 1024 * 16]))`
+   |
+   = note: `-D clippy::large-futures` implied by `-D warnings`
+
+error: large future with a size of 16386 bytes
+  --> $DIR/large_futures.rs:14:5
+   |
+LL |     f.await
+   |     ^ help: consider `Box::pin` on it: `Box::pin(f)`
+
+error: large future with a size of 16387 bytes
+  --> $DIR/large_futures.rs:18:9
+   |
+LL |         wait().await;
+   |         ^^^^^^ help: consider `Box::pin` on it: `Box::pin(wait())`
+
+error: large future with a size of 16387 bytes
+  --> $DIR/large_futures.rs:22:13
+   |
+LL |             wait().await;
+   |             ^^^^^^ help: consider `Box::pin` on it: `Box::pin(wait())`
+
+error: large future with a size of 65540 bytes
+  --> $DIR/large_futures.rs:29:5
+   |
+LL |     foo().await;
+   |     ^^^^^ help: consider `Box::pin` on it: `Box::pin(foo())`
+
+error: large future with a size of 49159 bytes
+  --> $DIR/large_futures.rs:30:5
+   |
+LL |     calls_fut(fut).await;
+   |     ^^^^^^^^^^^^^^ help: consider `Box::pin` on it: `Box::pin(calls_fut(fut))`
+
+error: aborting due to 6 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 728ee6f8cdddd9bc7deda8271419c7cedfdf518a Mon Sep 17 00:00:00 2001
From: "Samuel \"Sam\" Tardieu" <sam@rfc1149.net>
Date: Tue, 21 Mar 2023 20:18:47 +0100
Subject: Really dogfood clippy
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The dogfood success condition was inverted in `tests/dogfood.rs`:

```rust
  assert!(!failed_packages.is_empty(), …);
```

while instead the `failed_packages` collection must be empty:

```rust
  assert!(failed_packages.is_empty(), …);
```

And indeed, several clippy lint source files were not clean and had to be
fixed in the process.
---
 clippy_lints/src/let_with_type_underscore.rs  | 2 +-
 clippy_lints/src/manual_async_fn.rs           | 7 ++++---
 clippy_lints/src/manual_main_separator_str.rs | 4 +++-
 clippy_lints/src/redundant_async_block.rs     | 2 +-
 clippy_lints/src/swap.rs                      | 4 ++--
 clippy_lints/src/wildcard_imports.rs          | 8 +++-----
 tests/dogfood.rs                              | 4 ++--
 7 files changed, 16 insertions(+), 15 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/let_with_type_underscore.rs b/clippy_lints/src/let_with_type_underscore.rs
index ba51973f2f9..c01e3882d52 100644
--- a/clippy_lints/src/let_with_type_underscore.rs
+++ b/clippy_lints/src/let_with_type_underscore.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_help;
-use rustc_hir::*;
+use rustc_hir::{Local, TyKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
diff --git a/clippy_lints/src/manual_async_fn.rs b/clippy_lints/src/manual_async_fn.rs
index af52090d8a4..c7254b32d0b 100644
--- a/clippy_lints/src/manual_async_fn.rs
+++ b/clippy_lints/src/manual_async_fn.rs
@@ -77,11 +77,12 @@ impl<'tcx> LateLintPass<'tcx> for ManualAsyncFn {
                             if let Some(ret_pos) = position_before_rarrow(&header_snip);
                             if let Some((ret_sugg, ret_snip)) = suggested_ret(cx, output);
                             then {
-                                let header_snip = if !vis_snip.is_empty() {
-                                    format!("{} async {}", vis_snip, &header_snip[vis_snip.len() + 1..ret_pos])
-                                } else {
+                                let header_snip = if vis_snip.is_empty() {
                                     format!("async {}", &header_snip[..ret_pos])
+                                } else {
+                                    format!("{} async {}", vis_snip, &header_snip[vis_snip.len() + 1..ret_pos])
                                 };
+
                                 let help = format!("make the function `async` and {ret_sugg}");
                                 diag.span_suggestion(
                                     header_span,
diff --git a/clippy_lints/src/manual_main_separator_str.rs b/clippy_lints/src/manual_main_separator_str.rs
index a6d318f952c..c292bbe4e93 100644
--- a/clippy_lints/src/manual_main_separator_str.rs
+++ b/clippy_lints/src/manual_main_separator_str.rs
@@ -3,7 +3,7 @@ use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::{is_trait_method, match_def_path, paths, peel_hir_expr_refs};
 use rustc_errors::Applicability;
 use rustc_hir::def::{DefKind, Res};
-use rustc_hir::*;
+use rustc_hir::{Expr, ExprKind, Mutability, QPath};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
@@ -69,4 +69,6 @@ impl LateLintPass<'_> for ManualMainSeparatorStr {
                 );
             }
     }
+
+    extract_msrv_attr!(LateContext);
 }
diff --git a/clippy_lints/src/redundant_async_block.rs b/clippy_lints/src/redundant_async_block.rs
index 27ad4308637..b2adbcead00 100644
--- a/clippy_lints/src/redundant_async_block.rs
+++ b/clippy_lints/src/redundant_async_block.rs
@@ -1,5 +1,5 @@
 use clippy_utils::{diagnostics::span_lint_and_sugg, source::snippet};
-use rustc_ast::ast::*;
+use rustc_ast::ast::{Expr, ExprKind, Stmt, StmtKind};
 use rustc_ast::visit::Visitor as AstVisitor;
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass};
diff --git a/clippy_lints/src/swap.rs b/clippy_lints/src/swap.rs
index 50298898d03..f7eef03d1d4 100644
--- a/clippy_lints/src/swap.rs
+++ b/clippy_lints/src/swap.rs
@@ -189,7 +189,7 @@ fn check_suspicious_swap(cx: &LateContext<'_>, block: &Block<'_>) {
         if let Some((lhs0, rhs0)) = parse(first)
             && let Some((lhs1, rhs1)) = parse(second)
             && first.span.eq_ctxt(second.span)
-			&& !in_external_macro(&cx.sess(), first.span)
+			&& !in_external_macro(cx.sess(), first.span)
             && is_same(cx, lhs0, rhs1)
             && is_same(cx, lhs1, rhs0)
 			&& !is_same(cx, lhs1, rhs1) // Ignore a = b; a = a (#10421)
@@ -260,8 +260,8 @@ fn parse<'a, 'hir>(stmt: &'a Stmt<'hir>) -> Option<(ExprOrIdent<'hir>, &'a Expr<
 /// Implementation of the xor case for `MANUAL_SWAP` lint.
 fn check_xor_swap(cx: &LateContext<'_>, block: &Block<'_>) {
     for [s1, s2, s3] in block.stmts.array_windows::<3>() {
+        let ctxt = s1.span.ctxt();
         if_chain! {
-            let ctxt = s1.span.ctxt();
             if let Some((lhs0, rhs0)) = extract_sides_of_xor_assign(s1, ctxt);
             if let Some((lhs1, rhs1)) = extract_sides_of_xor_assign(s2, ctxt);
             if let Some((lhs2, rhs2)) = extract_sides_of_xor_assign(s3, ctxt);
diff --git a/clippy_lints/src/wildcard_imports.rs b/clippy_lints/src/wildcard_imports.rs
index e105452e1c5..36f910c983f 100644
--- a/clippy_lints/src/wildcard_imports.rs
+++ b/clippy_lints/src/wildcard_imports.rs
@@ -158,12 +158,10 @@ impl LateLintPass<'_> for WildcardImports {
                 let mut imports = used_imports.items().map(ToString::to_string).into_sorted_stable_ord(false);
                 let imports_string = if imports.len() == 1 {
                     imports.pop().unwrap()
+                } else if braced_glob {
+                    imports.join(", ")
                 } else {
-                    if braced_glob {
-                        imports.join(", ")
-                    } else {
-                        format!("{{{}}}", imports.join(", "))
-                    }
+                    format!("{{{}}}", imports.join(", "))
                 };
 
                 let sugg = if braced_glob {
diff --git a/tests/dogfood.rs b/tests/dogfood.rs
index 9643c2c9707..3a5d478fa31 100644
--- a/tests/dogfood.rs
+++ b/tests/dogfood.rs
@@ -37,10 +37,10 @@ fn dogfood_clippy() {
     }
 
     assert!(
-        !failed_packages.is_empty(),
+        failed_packages.is_empty(),
         "Dogfood failed for packages `{}`",
         failed_packages.iter().format(", "),
-    )
+    );
 }
 
 #[test]
-- 
cgit 1.4.1-3-g733a5


From 7f44530f54002401ba771bcc19f56f4950b22bb1 Mon Sep 17 00:00:00 2001
From: bluthej <joffrey.bluthe@e.email>
Date: Sat, 18 Mar 2023 10:43:02 +0100
Subject: Create `clear_with_drain` lint

---
 CHANGELOG.md                                 |  1 +
 clippy_lints/src/declared_lints.rs           |  1 +
 clippy_lints/src/methods/clear_with_drain.rs |  8 ++++++++
 clippy_lints/src/methods/mod.rs              | 21 +++++++++++++++++++++
 tests/ui/clear_with_drain.rs                 | 12 ++++++++++++
 5 files changed, 43 insertions(+)
 create mode 100644 clippy_lints/src/methods/clear_with_drain.rs
 create mode 100644 tests/ui/clear_with_drain.rs

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 47a503510c1..81d0ff80968 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4441,6 +4441,7 @@ Released 2018-09-13
 [`chars_last_cmp`]: https://rust-lang.github.io/rust-clippy/master/index.html#chars_last_cmp
 [`chars_next_cmp`]: https://rust-lang.github.io/rust-clippy/master/index.html#chars_next_cmp
 [`checked_conversions`]: https://rust-lang.github.io/rust-clippy/master/index.html#checked_conversions
+[`clear_with_drain`]: https://rust-lang.github.io/rust-clippy/master/index.html#clear_with_drain
 [`clone_double_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#clone_double_ref
 [`clone_on_copy`]: https://rust-lang.github.io/rust-clippy/master/index.html#clone_on_copy
 [`clone_on_ref_ptr`]: https://rust-lang.github.io/rust-clippy/master/index.html#clone_on_ref_ptr
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 2331e857b1f..f7b108c923a 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -307,6 +307,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::methods::CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS_INFO,
     crate::methods::CHARS_LAST_CMP_INFO,
     crate::methods::CHARS_NEXT_CMP_INFO,
+    crate::methods::CLEAR_WITH_DRAIN_INFO,
     crate::methods::CLONED_INSTEAD_OF_COPIED_INFO,
     crate::methods::CLONE_DOUBLE_REF_INFO,
     crate::methods::CLONE_ON_COPY_INFO,
diff --git a/clippy_lints/src/methods/clear_with_drain.rs b/clippy_lints/src/methods/clear_with_drain.rs
new file mode 100644
index 00000000000..9e55852ef7a
--- /dev/null
+++ b/clippy_lints/src/methods/clear_with_drain.rs
@@ -0,0 +1,8 @@
+use rustc_lint::{LateContext, LintContext};
+
+use super::CLEAR_WITH_DRAIN;
+
+// TODO: Adjust the parameters as necessary
+pub(super) fn check(cx: &LateContext) {
+    todo!();
+}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 56e3988bf09..859284b6a5c 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -9,6 +9,7 @@ mod chars_last_cmp;
 mod chars_last_cmp_with_unwrap;
 mod chars_next_cmp;
 mod chars_next_cmp_with_unwrap;
+mod clear_with_drain;
 mod clone_on_copy;
 mod clone_on_ref_ptr;
 mod cloned_instead_of_copied;
@@ -3190,6 +3191,25 @@ declare_clippy_lint! {
     "single command line argument that looks like it should be multiple arguments"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    ///
+    /// ### Why is this bad?
+    ///
+    /// ### Example
+    /// ```rust
+    /// // example code where clippy issues a warning
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// // example code which does not raise clippy warning
+    /// ```
+    #[clippy::version = "1.69.0"]
+    pub CLEAR_WITH_DRAIN,
+    nursery,
+    "default lint description"
+}
+
 pub struct Methods {
     avoid_breaking_exported_api: bool,
     msrv: Msrv,
@@ -3318,6 +3338,7 @@ impl_lint_pass!(Methods => [
     SEEK_TO_START_INSTEAD_OF_REWIND,
     NEEDLESS_COLLECT,
     SUSPICIOUS_COMMAND_ARG_SPACE,
+    CLEAR_WITH_DRAIN,
 ]);
 
 /// Extracts a method call name, args, and `Span` of the method name.
diff --git a/tests/ui/clear_with_drain.rs b/tests/ui/clear_with_drain.rs
new file mode 100644
index 00000000000..bb3a371cc08
--- /dev/null
+++ b/tests/ui/clear_with_drain.rs
@@ -0,0 +1,12 @@
+#![allow(unused)]
+#![warn(clippy::clear_with_drain)]
+
+fn main() {
+    let mut vec: Vec<i32> = Vec::new();
+    //Lint
+    vec.drain(..);
+    vec.drain(0..vec.len());
+
+    // Dont Lint
+    let iter = vec.drain(..);
+}
-- 
cgit 1.4.1-3-g733a5


From 349708655ea924bb34861025e3ee6d99d58e3f8d Mon Sep 17 00:00:00 2001
From: "Samuel \"Sam\" Tardieu" <sam@rfc1149.net>
Date: Sun, 12 Mar 2023 14:06:13 +0100
Subject: Do not propose to remove `async move` if variables are captured by
 ref

---
 clippy_lints/src/redundant_async_block.rs | 37 +++++++++++++++++++++++-
 tests/ui/redundant_async_block.fixed      | 47 +++++++++++++++++++++++++++++++
 tests/ui/redundant_async_block.rs         | 47 +++++++++++++++++++++++++++++++
 tests/ui/redundant_async_block.stderr     | 22 +++++++++++----
 4 files changed, 147 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/redundant_async_block.rs b/clippy_lints/src/redundant_async_block.rs
index 27ad4308637..24dcd52b93e 100644
--- a/clippy_lints/src/redundant_async_block.rs
+++ b/clippy_lints/src/redundant_async_block.rs
@@ -32,7 +32,7 @@ declare_clippy_lint! {
     /// ```
     #[clippy::version = "1.69.0"]
     pub REDUNDANT_ASYNC_BLOCK,
-    complexity,
+    nursery,
     "`async { future.await }` can be replaced by `future`"
 }
 declare_lint_pass!(RedundantAsyncBlock => [REDUNDANT_ASYNC_BLOCK]);
@@ -48,6 +48,11 @@ impl EarlyLintPass for RedundantAsyncBlock {
             !future.span.from_expansion() &&
             !await_in_expr(future)
         {
+            if captures_value(last) {
+                // If the async block captures variables then there is no equivalence.
+                return;
+            }
+
             span_lint_and_sugg(
                 cx,
                 REDUNDANT_ASYNC_BLOCK,
@@ -82,3 +87,33 @@ impl<'ast> AstVisitor<'ast> for AwaitDetector {
         }
     }
 }
+
+/// Check whether an expression may have captured a local variable.
+/// This is done by looking for paths with only one segment, except as
+/// a prefix of `.await` since this would be captured by value.
+///
+/// This function will sometimes return `true` even tough there are no
+/// captures happening: at the AST level, it is impossible to
+/// dinstinguish a function call from a call to a closure which comes
+/// from the local environment.
+fn captures_value(expr: &Expr) -> bool {
+    let mut detector = CaptureDetector::default();
+    detector.visit_expr(expr);
+    detector.capture_found
+}
+
+#[derive(Default)]
+struct CaptureDetector {
+    capture_found: bool,
+}
+
+impl<'ast> AstVisitor<'ast> for CaptureDetector {
+    fn visit_expr(&mut self, ex: &'ast Expr) {
+        match (&ex.kind, self.capture_found) {
+            (ExprKind::Await(fut), _) if matches!(fut.kind, ExprKind::Path(..)) => (),
+            (ExprKind::Path(_, path), _) if path.segments.len() == 1 => self.capture_found = true,
+            (_, false) => rustc_ast::visit::walk_expr(self, ex),
+            _ => (),
+        }
+    }
+}
diff --git a/tests/ui/redundant_async_block.fixed b/tests/ui/redundant_async_block.fixed
index 5f9931df45e..d26b7a332cb 100644
--- a/tests/ui/redundant_async_block.fixed
+++ b/tests/ui/redundant_async_block.fixed
@@ -3,6 +3,8 @@
 #![allow(unused)]
 #![warn(clippy::redundant_async_block)]
 
+use std::future::Future;
+
 async fn func1(n: usize) -> usize {
     n + 1
 }
@@ -62,3 +64,48 @@ fn main() {
     let fut = async_await_parameter_in_macro!(func2());
     let fut = async_await_in_macro!(std::convert::identity);
 }
+
+#[allow(clippy::let_and_return)]
+fn capture_local() -> impl Future<Output = i32> {
+    // Lint
+    let fut = async { 17 };
+    fut
+}
+
+fn capture_local_closure(s: &str) -> impl Future<Output = &str> {
+    let f = move || std::future::ready(s);
+    // Do not lint: `f` would not live long enough
+    async move { f().await }
+}
+
+#[allow(clippy::let_and_return)]
+fn capture_arg(s: &str) -> impl Future<Output = &str> {
+    // Lint
+    let fut = async move { s };
+    fut
+}
+
+#[derive(Debug, Clone)]
+struct F {}
+
+impl F {
+    async fn run(&self) {}
+}
+
+pub async fn run() {
+    let f = F {};
+    let c = f.clone();
+    // Do not lint: `c` would not live long enough
+    spawn(async move { c.run().await });
+    let _f = f;
+}
+
+fn spawn<F: Future + 'static>(_: F) {}
+
+async fn work(_: &str) {}
+
+fn capture() {
+    let val = "Hello World".to_owned();
+    // Do not lint: `val` would not live long enough
+    spawn(async { work(&{ val }).await });
+}
diff --git a/tests/ui/redundant_async_block.rs b/tests/ui/redundant_async_block.rs
index de3c9970c65..04726e62805 100644
--- a/tests/ui/redundant_async_block.rs
+++ b/tests/ui/redundant_async_block.rs
@@ -3,6 +3,8 @@
 #![allow(unused)]
 #![warn(clippy::redundant_async_block)]
 
+use std::future::Future;
+
 async fn func1(n: usize) -> usize {
     n + 1
 }
@@ -62,3 +64,48 @@ fn main() {
     let fut = async_await_parameter_in_macro!(func2());
     let fut = async_await_in_macro!(std::convert::identity);
 }
+
+#[allow(clippy::let_and_return)]
+fn capture_local() -> impl Future<Output = i32> {
+    // Lint
+    let fut = async { 17 };
+    async move { fut.await }
+}
+
+fn capture_local_closure(s: &str) -> impl Future<Output = &str> {
+    let f = move || std::future::ready(s);
+    // Do not lint: `f` would not live long enough
+    async move { f().await }
+}
+
+#[allow(clippy::let_and_return)]
+fn capture_arg(s: &str) -> impl Future<Output = &str> {
+    // Lint
+    let fut = async move { s };
+    async move { fut.await }
+}
+
+#[derive(Debug, Clone)]
+struct F {}
+
+impl F {
+    async fn run(&self) {}
+}
+
+pub async fn run() {
+    let f = F {};
+    let c = f.clone();
+    // Do not lint: `c` would not live long enough
+    spawn(async move { c.run().await });
+    let _f = f;
+}
+
+fn spawn<F: Future + 'static>(_: F) {}
+
+async fn work(_: &str) {}
+
+fn capture() {
+    let val = "Hello World".to_owned();
+    // Do not lint: `val` would not live long enough
+    spawn(async { work(&{ val }).await });
+}
diff --git a/tests/ui/redundant_async_block.stderr b/tests/ui/redundant_async_block.stderr
index b16d96dce84..1a1c1603e08 100644
--- a/tests/ui/redundant_async_block.stderr
+++ b/tests/ui/redundant_async_block.stderr
@@ -1,5 +1,5 @@
 error: this async expression only awaits a single future
-  --> $DIR/redundant_async_block.rs:13:13
+  --> $DIR/redundant_async_block.rs:15:13
    |
 LL |     let x = async { f.await };
    |             ^^^^^^^^^^^^^^^^^ help: you can reduce it to: `f`
@@ -7,22 +7,34 @@ LL |     let x = async { f.await };
    = note: `-D clippy::redundant-async-block` implied by `-D warnings`
 
 error: this async expression only awaits a single future
-  --> $DIR/redundant_async_block.rs:46:16
+  --> $DIR/redundant_async_block.rs:48:16
    |
 LL |     let fut2 = async { fut1.await };
    |                ^^^^^^^^^^^^^^^^^^^^ help: you can reduce it to: `fut1`
 
 error: this async expression only awaits a single future
-  --> $DIR/redundant_async_block.rs:49:16
+  --> $DIR/redundant_async_block.rs:51:16
    |
 LL |     let fut2 = async move { fut1.await };
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^ help: you can reduce it to: `fut1`
 
 error: this async expression only awaits a single future
-  --> $DIR/redundant_async_block.rs:51:15
+  --> $DIR/redundant_async_block.rs:53:15
    |
 LL |     let fut = async { async { 42 }.await };
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: you can reduce it to: `async { 42 }`
 
-error: aborting due to 4 previous errors
+error: this async expression only awaits a single future
+  --> $DIR/redundant_async_block.rs:72:5
+   |
+LL |     async move { fut.await }
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^ help: you can reduce it to: `fut`
+
+error: this async expression only awaits a single future
+  --> $DIR/redundant_async_block.rs:85:5
+   |
+LL |     async move { fut.await }
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^ help: you can reduce it to: `fut`
+
+error: aborting due to 6 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From b138bb587bfc2c0e5a3a55820848cc9b2f26149b Mon Sep 17 00:00:00 2001
From: "Samuel \"Sam\" Tardieu" <sam@rfc1149.net>
Date: Wed, 22 Mar 2023 00:34:35 +0100
Subject: Do not propose to simplify a not expression coming from a macro

---
 clippy_lints/src/booleans.rs | 25 +++++++++++++------------
 tests/ui/nonminimal_bool.rs  | 29 +++++++++++++++++++++++++++++
 2 files changed, 42 insertions(+), 12 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/booleans.rs b/clippy_lints/src/booleans.rs
index e8106beec37..29fde9336c0 100644
--- a/clippy_lints/src/booleans.rs
+++ b/clippy_lints/src/booleans.rs
@@ -495,18 +495,19 @@ struct NotSimplificationVisitor<'a, 'tcx> {
 
 impl<'a, 'tcx> Visitor<'tcx> for NotSimplificationVisitor<'a, 'tcx> {
     fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
-        if let ExprKind::Unary(UnOp::Not, inner) = &expr.kind {
-            if let Some(suggestion) = simplify_not(self.cx, inner) {
-                span_lint_and_sugg(
-                    self.cx,
-                    NONMINIMAL_BOOL,
-                    expr.span,
-                    "this boolean expression can be simplified",
-                    "try",
-                    suggestion,
-                    Applicability::MachineApplicable,
-                );
-            }
+        if let ExprKind::Unary(UnOp::Not, inner) = &expr.kind &&
+            !inner.span.from_expansion() &&
+            let Some(suggestion) = simplify_not(self.cx, inner)
+        {
+            span_lint_and_sugg(
+                self.cx,
+                NONMINIMAL_BOOL,
+                expr.span,
+                "this boolean expression can be simplified",
+                "try",
+                suggestion,
+                Applicability::MachineApplicable,
+            );
         }
 
         walk_expr(self, expr);
diff --git a/tests/ui/nonminimal_bool.rs b/tests/ui/nonminimal_bool.rs
index e9b4367ca65..3b5a374b4a7 100644
--- a/tests/ui/nonminimal_bool.rs
+++ b/tests/ui/nonminimal_bool.rs
@@ -63,3 +63,32 @@ fn issue9428() {
         println!("foo");
     }
 }
+
+fn issue_10523() {
+    macro_rules! a {
+        ($v:expr) => {
+            $v.is_some()
+        };
+    }
+    let x: Option<u32> = None;
+    if !a!(x) {}
+}
+
+fn issue_10523_1() {
+    macro_rules! a {
+        ($v:expr) => {
+            !$v.is_some()
+        };
+    }
+    let x: Option<u32> = None;
+    if a!(x) {}
+}
+
+fn issue_10523_2() {
+    macro_rules! a {
+        () => {
+            !None::<u32>.is_some()
+        };
+    }
+    if a!() {}
+}
-- 
cgit 1.4.1-3-g733a5


From 85d428101dc757f7aa41e47696c94683d8398903 Mon Sep 17 00:00:00 2001
From: bluthej <joffrey.bluthe@e.email>
Date: Sat, 18 Mar 2023 11:34:30 +0100
Subject: Pull `is_full_range` method from `iter_with_drain`

Rename method to `is_range_full` because the type is actually
`RangeFull`.

Method moved to `clippy_utils` for reuse in `clear_with_drain`.
---
 clippy_lints/src/methods/iter_with_drain.rs | 23 +++--------------------
 clippy_utils/src/lib.rs                     | 21 ++++++++++++++++++++-
 2 files changed, 23 insertions(+), 21 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/iter_with_drain.rs b/clippy_lints/src/methods/iter_with_drain.rs
index 3da230e12d7..ea92e3a549f 100644
--- a/clippy_lints/src/methods/iter_with_drain.rs
+++ b/clippy_lints/src/methods/iter_with_drain.rs
@@ -1,9 +1,8 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::higher::Range;
-use clippy_utils::is_integer_const;
-use rustc_ast::ast::RangeLimits;
+use clippy_utils::is_range_full;
 use rustc_errors::Applicability;
-use rustc_hir::{Expr, ExprKind, QPath};
+use rustc_hir::{Expr, ExprKind};
 use rustc_lint::LateContext;
 use rustc_span::symbol::sym;
 use rustc_span::Span;
@@ -16,7 +15,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'_>, span
         && let Some(ty_name) = cx.tcx.get_diagnostic_name(adt.did())
         && matches!(ty_name, sym::Vec | sym::VecDeque)
         && let Some(range) = Range::hir(arg)
-        && is_full_range(cx, recv, range)
+        && is_range_full(cx, recv, range)
     {
         span_lint_and_sugg(
             cx,
@@ -29,19 +28,3 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'_>, span
         );
     };
 }
-
-fn is_full_range(cx: &LateContext<'_>, container: &Expr<'_>, range: Range<'_>) -> bool {
-    range.start.map_or(true, |e| is_integer_const(cx, e, 0))
-        && range.end.map_or(true, |e| {
-            if range.limits == RangeLimits::HalfOpen
-                && let ExprKind::Path(QPath::Resolved(None, container_path)) = container.kind
-                && let ExprKind::MethodCall(name, self_arg, [], _) = e.kind
-                && name.ident.name == sym::len
-                && let ExprKind::Path(QPath::Resolved(None, path)) = self_arg.kind
-            {
-                container_path.res == path.res
-            } else {
-                false
-            }
-        })
-}
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 44b6b9f7b0b..0fdbd7a6341 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -78,7 +78,7 @@ use std::sync::OnceLock;
 use std::sync::{Mutex, MutexGuard};
 
 use if_chain::if_chain;
-use rustc_ast::ast::{self, LitKind};
+use rustc_ast::ast::{self, LitKind, RangeLimits};
 use rustc_ast::Attribute;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_data_structures::unhash::UnhashMap;
@@ -115,6 +115,7 @@ use rustc_span::Span;
 use rustc_target::abi::Integer;
 
 use crate::consts::{constant, Constant};
+use crate::higher::Range;
 use crate::ty::{can_partially_move_ty, expr_sig, is_copy, is_recursively_primitive_type, ty_is_fn_once_param};
 use crate::visitors::for_each_expr;
 
@@ -1491,6 +1492,24 @@ pub fn is_else_clause(tcx: TyCtxt<'_>, expr: &Expr<'_>) -> bool {
     }
 }
 
+/// Checks whether the given `Range` is equivalent to a `RangeFull`.
+/// Inclusive ranges are not considered because they already constitute a lint.
+pub fn is_range_full(cx: &LateContext<'_>, container: &Expr<'_>, range: Range<'_>) -> bool {
+    range.start.map_or(true, |e| is_integer_const(cx, e, 0))
+        && range.end.map_or(true, |e| {
+            if range.limits == RangeLimits::HalfOpen
+                && let ExprKind::Path(QPath::Resolved(None, container_path)) = container.kind
+                && let ExprKind::MethodCall(name, self_arg, [], _) = e.kind
+                && name.ident.name == sym::len
+                && let ExprKind::Path(QPath::Resolved(None, path)) = self_arg.kind
+            {
+                container_path.res == path.res
+            } else {
+                false
+            }
+        })
+}
+
 /// Checks whether the given expression is a constant integer of the given value.
 /// unlike `is_integer_literal`, this version does const folding
 pub fn is_integer_const(cx: &LateContext<'_>, e: &Expr<'_>, value: u128) -> bool {
-- 
cgit 1.4.1-3-g733a5


From 484c82e0418325df5d25e8d0e11e10a5d1371502 Mon Sep 17 00:00:00 2001
From: bluthej <joffrey.bluthe@e.email>
Date: Mon, 20 Mar 2023 18:46:18 +0100
Subject: Update lint declaration

---
 clippy_lints/src/methods/mod.rs | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 859284b6a5c..4e74ac6af2b 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3193,21 +3193,27 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
+    /// Checks for usage of `.drain(..)` for the sole purpose of clearing a `Vec`.
     ///
     /// ### Why is this bad?
+    /// This creates an unnecessary iterator that is dropped immediately.
+    ///
+    /// Calling `.clear()` also makes the intent clearer.
     ///
     /// ### Example
     /// ```rust
-    /// // example code where clippy issues a warning
+    /// let mut v = vec![1, 2, 3];
+    /// v.drain(..);
     /// ```
     /// Use instead:
     /// ```rust
-    /// // example code which does not raise clippy warning
+    /// let mut v = vec![1, 2, 3];
+    /// v.clear();
     /// ```
     #[clippy::version = "1.69.0"]
     pub CLEAR_WITH_DRAIN,
     nursery,
-    "default lint description"
+    "calling `drain` in order to `clear` a `Vec`"
 }
 
 pub struct Methods {
-- 
cgit 1.4.1-3-g733a5


From c7e3e304d5d2ac82dbebe5f3d3e0611b407d81be Mon Sep 17 00:00:00 2001
From: bluthej <joffrey.bluthe@e.email>
Date: Tue, 21 Mar 2023 22:08:37 +0100
Subject: Add the lint logic

---
 clippy_lints/src/methods/clear_with_drain.rs | 27 ++++++++++++++++++++++++---
 clippy_lints/src/methods/mod.rs              | 10 ++++++++--
 2 files changed, 32 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/clear_with_drain.rs b/clippy_lints/src/methods/clear_with_drain.rs
index 9e55852ef7a..ac6c0e57257 100644
--- a/clippy_lints/src/methods/clear_with_drain.rs
+++ b/clippy_lints/src/methods/clear_with_drain.rs
@@ -1,8 +1,29 @@
-use rustc_lint::{LateContext, LintContext};
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::higher::Range;
+use clippy_utils::is_range_full;
+use clippy_utils::ty::is_type_diagnostic_item;
+use rustc_errors::Applicability;
+use rustc_hir::Expr;
+use rustc_lint::LateContext;
+use rustc_span::symbol::sym;
+use rustc_span::Span;
 
 use super::CLEAR_WITH_DRAIN;
 
 // TODO: Adjust the parameters as necessary
-pub(super) fn check(cx: &LateContext) {
-    todo!();
+// see clippy_lints/src/methods/mod.rs to add call to this check in `check_methods`
+pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'_>, span: Span, arg: &Expr<'_>) {
+    let ty = cx.typeck_results().expr_ty(recv);
+    if is_type_diagnostic_item(cx, ty, sym::Vec) && let Some(range) = Range::hir(arg) && is_range_full(cx, recv, range)
+    {
+        span_lint_and_sugg(
+            cx,
+            CLEAR_WITH_DRAIN,
+            span.with_hi(expr.span.hi()),
+            "`drain` used to clear a `Vec`",
+            "try",
+            "clear()".to_string(),
+            Applicability::MachineApplicable,
+        );
+    }
 }
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 4e74ac6af2b..257bc4eccc3 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -111,7 +111,7 @@ use clippy_utils::ty::{contains_ty_adt_constructor_opaque, implements_trait, is_
 use clippy_utils::{contains_return, is_bool, is_trait_method, iter_input_pats, return_ty};
 use if_chain::if_chain;
 use rustc_hir as hir;
-use rustc_hir::{Expr, ExprKind, TraitItem, TraitItemKind};
+use rustc_hir::{Expr, ExprKind, Node, Stmt, StmtKind, TraitItem, TraitItemKind};
 use rustc_hir_analysis::hir_ty_to_ty;
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
@@ -3590,7 +3590,13 @@ impl Methods {
                     _ => {},
                 },
                 ("drain", [arg]) => {
-                    iter_with_drain::check(cx, expr, recv, span, arg);
+                if let Node::Stmt(Stmt { hir_id: _, kind, .. }) = cx.tcx.hir().get_parent(expr.hir_id)
+                    && matches!(kind, StmtKind::Semi(_))
+                    {
+                        clear_with_drain::check(cx, expr, recv, span, arg);
+                    } else {
+                        iter_with_drain::check(cx, expr, recv, span, arg);
+                    }
                 },
                 ("ends_with", [arg]) => {
                     if let ExprKind::MethodCall(.., span) = expr.kind {
-- 
cgit 1.4.1-3-g733a5


From e8ec242a61e7fcadf1a8cb3c6f7ec162b5e2726e Mon Sep 17 00:00:00 2001
From: bluthej <joffrey.bluthe@e.email>
Date: Tue, 21 Mar 2023 22:46:59 +0100
Subject: Finish tests - add rustfix

---
 clippy_lints/src/methods/clear_with_drain.rs |  2 --
 tests/ui/clear_with_drain.fixed              | 40 ++++++++++++++++++++++++++++
 tests/ui/clear_with_drain.rs                 |  1 +
 tests/ui/clear_with_drain.stderr             | 28 +++++++++++++++++++
 4 files changed, 69 insertions(+), 2 deletions(-)
 create mode 100644 tests/ui/clear_with_drain.fixed
 create mode 100644 tests/ui/clear_with_drain.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/clear_with_drain.rs b/clippy_lints/src/methods/clear_with_drain.rs
index ac6c0e57257..bf7e7d12405 100644
--- a/clippy_lints/src/methods/clear_with_drain.rs
+++ b/clippy_lints/src/methods/clear_with_drain.rs
@@ -10,8 +10,6 @@ use rustc_span::Span;
 
 use super::CLEAR_WITH_DRAIN;
 
-// TODO: Adjust the parameters as necessary
-// see clippy_lints/src/methods/mod.rs to add call to this check in `check_methods`
 pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'_>, span: Span, arg: &Expr<'_>) {
     let ty = cx.typeck_results().expr_ty(recv);
     if is_type_diagnostic_item(cx, ty, sym::Vec) && let Some(range) = Range::hir(arg) && is_range_full(cx, recv, range)
diff --git a/tests/ui/clear_with_drain.fixed b/tests/ui/clear_with_drain.fixed
new file mode 100644
index 00000000000..62b0af08eea
--- /dev/null
+++ b/tests/ui/clear_with_drain.fixed
@@ -0,0 +1,40 @@
+// run-rustfix
+#![allow(unused)]
+#![warn(clippy::clear_with_drain)]
+
+fn range() {
+    let (mut u, mut v) = (vec![1, 2, 3], vec![1, 2, 3]);
+    let iter = u.drain(0..u.len()); // Yay
+    v.clear(); // Nay
+}
+
+fn range_from() {
+    let (mut u, mut v) = (vec![1, 2, 3], vec![1, 2, 3]);
+    let iter = u.drain(0..); // Yay
+    v.clear(); // Nay
+}
+
+fn range_full() {
+    let (mut u, mut v) = (vec![1, 2, 3], vec![1, 2, 3]);
+    let iter = u.drain(..); // Yay
+    v.clear(); // Nay
+}
+
+fn range_to() {
+    let (mut u, mut v) = (vec![1, 2, 3], vec![1, 2, 3]);
+    let iter = u.drain(..u.len()); // Yay
+    v.clear(); // Nay
+}
+
+fn partial_drains() {
+    let mut v = vec![1, 2, 3];
+    v.drain(1..); // Yay
+
+    let mut v = vec![1, 2, 3];
+    v.drain(..v.len() - 1); // Yay
+
+    let mut v = vec![1, 2, 3];
+    v.drain(1..v.len() - 1); // Yay
+}
+
+fn main() {}
diff --git a/tests/ui/clear_with_drain.rs b/tests/ui/clear_with_drain.rs
index 28119deaebb..721af7d2ea7 100644
--- a/tests/ui/clear_with_drain.rs
+++ b/tests/ui/clear_with_drain.rs
@@ -1,3 +1,4 @@
+// run-rustfix
 #![allow(unused)]
 #![warn(clippy::clear_with_drain)]
 
diff --git a/tests/ui/clear_with_drain.stderr b/tests/ui/clear_with_drain.stderr
new file mode 100644
index 00000000000..0d6d8263e10
--- /dev/null
+++ b/tests/ui/clear_with_drain.stderr
@@ -0,0 +1,28 @@
+error: `drain` used to clear a `Vec`
+  --> $DIR/clear_with_drain.rs:8:7
+   |
+LL |     v.drain(0..v.len()); // Nay
+   |       ^^^^^^^^^^^^^^^^^ help: try: `clear()`
+   |
+   = note: `-D clippy::clear-with-drain` implied by `-D warnings`
+
+error: `drain` used to clear a `Vec`
+  --> $DIR/clear_with_drain.rs:14:7
+   |
+LL |     v.drain(0..); // Nay
+   |       ^^^^^^^^^^ help: try: `clear()`
+
+error: `drain` used to clear a `Vec`
+  --> $DIR/clear_with_drain.rs:20:7
+   |
+LL |     v.drain(..); // Nay
+   |       ^^^^^^^^^ help: try: `clear()`
+
+error: `drain` used to clear a `Vec`
+  --> $DIR/clear_with_drain.rs:26:7
+   |
+LL |     v.drain(..v.len()); // Nay
+   |       ^^^^^^^^^^^^^^^^ help: try: `clear()`
+
+error: aborting due to 4 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 966d5b0e348c9bd29eb1d9ddc2c2cf42555a25b7 Mon Sep 17 00:00:00 2001
From: Nilstrieb <48135649+Nilstrieb@users.noreply.github.com>
Date: Wed, 22 Mar 2023 22:12:19 +0100
Subject: Cache `has_sig_drop_attr` for `significant_drop_tightening`

The lint is very slow as it doesn't cache the deeply nested check for
the attribute. If we cache it, we can reduce the time spent on checking
`rustc_borrowck` from 28s to 9s, which is a nice improvement. In the
profile, the time inside `has_sig_drop_attr` goes from 66% to 0.2%,
which is a lot more reasonable.

See the PR for nice graphs.
---
 clippy_lints/src/significant_drop_tightening.rs | 38 ++++++++++++++++++++-----
 1 file changed, 31 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/significant_drop_tightening.rs b/clippy_lints/src/significant_drop_tightening.rs
index e2d90edec5a..c3e99aa0055 100644
--- a/clippy_lints/src/significant_drop_tightening.rs
+++ b/clippy_lints/src/significant_drop_tightening.rs
@@ -1,9 +1,9 @@
-use crate::FxHashSet;
 use clippy_utils::{
     diagnostics::span_lint_and_then,
     get_attr,
     source::{indent_of, snippet},
 };
+use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_errors::{Applicability, Diagnostic};
 use rustc_hir::{
     self as hir,
@@ -58,6 +58,7 @@ impl_lint_pass!(SignificantDropTightening<'_> => [SIGNIFICANT_DROP_TIGHTENING]);
 pub struct SignificantDropTightening<'tcx> {
     /// Auxiliary structure used to avoid having to verify the same type multiple times.
     seen_types: FxHashSet<Ty<'tcx>>,
+    type_cache: FxHashMap<Ty<'tcx>, bool>,
 }
 
 impl<'tcx> SignificantDropTightening<'tcx> {
@@ -118,7 +119,7 @@ impl<'tcx> SignificantDropTightening<'tcx> {
         stmt: &hir::Stmt<'_>,
         cb: impl Fn(&mut SigDropAuxParams),
     ) {
-        let mut sig_drop_finder = SigDropFinder::new(cx, &mut self.seen_types);
+        let mut sig_drop_finder = SigDropFinder::new(cx, &mut self.seen_types, &mut self.type_cache);
         sig_drop_finder.visit_expr(expr);
         if sig_drop_finder.has_sig_drop {
             cb(sdap);
@@ -296,15 +297,24 @@ impl Default for SigDropAuxParams {
 struct SigDropChecker<'cx, 'sdt, 'tcx> {
     cx: &'cx LateContext<'tcx>,
     seen_types: &'sdt mut FxHashSet<Ty<'tcx>>,
+    type_cache: &'sdt mut FxHashMap<Ty<'tcx>, bool>,
 }
 
 impl<'cx, 'sdt, 'tcx> SigDropChecker<'cx, 'sdt, 'tcx> {
-    pub(crate) fn new(cx: &'cx LateContext<'tcx>, seen_types: &'sdt mut FxHashSet<Ty<'tcx>>) -> Self {
+    pub(crate) fn new(
+        cx: &'cx LateContext<'tcx>,
+        seen_types: &'sdt mut FxHashSet<Ty<'tcx>>,
+        type_cache: &'sdt mut FxHashMap<Ty<'tcx>, bool>,
+    ) -> Self {
         seen_types.clear();
-        Self { cx, seen_types }
+        Self {
+            cx,
+            seen_types,
+            type_cache,
+        }
     }
 
-    pub(crate) fn has_sig_drop_attr(&mut self, ty: Ty<'tcx>) -> bool {
+    pub(crate) fn has_sig_drop_attr_uncached(&mut self, ty: Ty<'tcx>) -> bool {
         if let Some(adt) = ty.ty_adt_def() {
             let mut iter = get_attr(
                 self.cx.sess(),
@@ -340,6 +350,16 @@ impl<'cx, 'sdt, 'tcx> SigDropChecker<'cx, 'sdt, 'tcx> {
         }
     }
 
+    pub(crate) fn has_sig_drop_attr(&mut self, ty: Ty<'tcx>) -> bool {
+        // The borrow checker prevents us from using something fancier like or_insert_with.
+        if let Some(ty) = self.type_cache.get(&ty) {
+            return *ty;
+        }
+        let value = self.has_sig_drop_attr_uncached(ty);
+        self.type_cache.insert(ty, value);
+        value
+    }
+
     fn has_seen_ty(&mut self, ty: Ty<'tcx>) -> bool {
         !self.seen_types.insert(ty)
     }
@@ -353,11 +373,15 @@ struct SigDropFinder<'cx, 'sdt, 'tcx> {
 }
 
 impl<'cx, 'sdt, 'tcx> SigDropFinder<'cx, 'sdt, 'tcx> {
-    fn new(cx: &'cx LateContext<'tcx>, seen_types: &'sdt mut FxHashSet<Ty<'tcx>>) -> Self {
+    fn new(
+        cx: &'cx LateContext<'tcx>,
+        seen_types: &'sdt mut FxHashSet<Ty<'tcx>>,
+        type_cache: &'sdt mut FxHashMap<Ty<'tcx>, bool>,
+    ) -> Self {
         Self {
             cx,
             has_sig_drop: false,
-            sig_drop_checker: SigDropChecker::new(cx, seen_types),
+            sig_drop_checker: SigDropChecker::new(cx, seen_types, type_cache),
         }
     }
 }
-- 
cgit 1.4.1-3-g733a5


From ecc201253ee060071442f6f0c1a52b380aa3b3af Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Thu, 23 Mar 2023 18:58:10 +0000
Subject: Wrap transmutes_expressible_as_ptr_casts suggestions in parentheses

---
 .../src/transmute/transmutes_expressible_as_ptr_casts.rs      | 11 +++++++++--
 tests/ui/transmutes_expressible_as_ptr_casts.fixed            |  8 +++++++-
 tests/ui/transmutes_expressible_as_ptr_casts.rs               |  8 +++++++-
 tests/ui/transmutes_expressible_as_ptr_casts.stderr           |  8 +++++++-
 4 files changed, 30 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/transmute/transmutes_expressible_as_ptr_casts.rs b/clippy_lints/src/transmute/transmutes_expressible_as_ptr_casts.rs
index 8530b43243f..85cd74f23ef 100644
--- a/clippy_lints/src/transmute/transmutes_expressible_as_ptr_casts.rs
+++ b/clippy_lints/src/transmute/transmutes_expressible_as_ptr_casts.rs
@@ -2,8 +2,9 @@ use super::utils::check_cast;
 use super::TRANSMUTES_EXPRESSIBLE_AS_PTR_CASTS;
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::sugg::Sugg;
+use rustc_ast::ExprPrecedence;
 use rustc_errors::Applicability;
-use rustc_hir::Expr;
+use rustc_hir::{Expr, Node};
 use rustc_lint::LateContext;
 use rustc_middle::ty::{cast::CastKind, Ty};
 
@@ -19,7 +20,7 @@ pub(super) fn check<'tcx>(
 ) -> bool {
     use CastKind::{AddrPtrCast, ArrayPtrCast, FnPtrAddrCast, FnPtrPtrCast, PtrAddrCast, PtrPtrCast};
     let mut app = Applicability::MachineApplicable;
-    let sugg = match check_cast(cx, e, from_ty, to_ty) {
+    let mut sugg = match check_cast(cx, e, from_ty, to_ty) {
         Some(PtrPtrCast | AddrPtrCast | ArrayPtrCast | FnPtrPtrCast | FnPtrAddrCast) => {
             Sugg::hir_with_context(cx, arg, e.span.ctxt(), "..", &mut app)
                 .as_ty(to_ty.to_string())
@@ -39,6 +40,12 @@ pub(super) fn check<'tcx>(
         _ => return false,
     };
 
+    if let Node::Expr(parent) = cx.tcx.hir().get_parent(e.hir_id)
+        && parent.precedence().order() > ExprPrecedence::Cast.order()
+    {
+        sugg = format!("({sugg})");
+    }
+
     span_lint_and_sugg(
         cx,
         TRANSMUTES_EXPRESSIBLE_AS_PTR_CASTS,
diff --git a/tests/ui/transmutes_expressible_as_ptr_casts.fixed b/tests/ui/transmutes_expressible_as_ptr_casts.fixed
index 55307506eb3..cc84ba25bd0 100644
--- a/tests/ui/transmutes_expressible_as_ptr_casts.fixed
+++ b/tests/ui/transmutes_expressible_as_ptr_casts.fixed
@@ -4,7 +4,7 @@
 // would otherwise be responsible for
 #![warn(clippy::useless_transmute)]
 #![warn(clippy::transmute_ptr_to_ptr)]
-#![allow(dead_code, unused_unsafe, clippy::borrow_as_ptr)]
+#![allow(unused, clippy::borrow_as_ptr)]
 
 use std::mem::{size_of, transmute};
 
@@ -77,3 +77,9 @@ fn cannot_be_expressed_as_pointer_cast(in_param: Single) -> Pair {
 
     unsafe { transmute::<Single, Pair>(in_param) }
 }
+
+fn issue_10449() {
+    fn f() {}
+
+    let _x: u8 = unsafe { *(f as *const u8) };
+}
diff --git a/tests/ui/transmutes_expressible_as_ptr_casts.rs b/tests/ui/transmutes_expressible_as_ptr_casts.rs
index e7360f3f9dc..aa65ab4dd24 100644
--- a/tests/ui/transmutes_expressible_as_ptr_casts.rs
+++ b/tests/ui/transmutes_expressible_as_ptr_casts.rs
@@ -4,7 +4,7 @@
 // would otherwise be responsible for
 #![warn(clippy::useless_transmute)]
 #![warn(clippy::transmute_ptr_to_ptr)]
-#![allow(dead_code, unused_unsafe, clippy::borrow_as_ptr)]
+#![allow(unused, clippy::borrow_as_ptr)]
 
 use std::mem::{size_of, transmute};
 
@@ -77,3 +77,9 @@ fn cannot_be_expressed_as_pointer_cast(in_param: Single) -> Pair {
 
     unsafe { transmute::<Single, Pair>(in_param) }
 }
+
+fn issue_10449() {
+    fn f() {}
+
+    let _x: u8 = unsafe { *std::mem::transmute::<fn(), *const u8>(f) };
+}
diff --git a/tests/ui/transmutes_expressible_as_ptr_casts.stderr b/tests/ui/transmutes_expressible_as_ptr_casts.stderr
index e862fcb67a4..58f5162c78e 100644
--- a/tests/ui/transmutes_expressible_as_ptr_casts.stderr
+++ b/tests/ui/transmutes_expressible_as_ptr_casts.stderr
@@ -58,5 +58,11 @@ error: transmute from a reference to a pointer
 LL |     unsafe { transmute::<&[i32; 1], *const u8>(in_param) }
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `in_param as *const [i32; 1] as *const u8`
 
-error: aborting due to 9 previous errors
+error: transmute from `fn()` to `*const u8` which could be expressed as a pointer cast instead
+  --> $DIR/transmutes_expressible_as_ptr_casts.rs:84:28
+   |
+LL |     let _x: u8 = unsafe { *std::mem::transmute::<fn(), *const u8>(f) };
+   |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `(f as *const u8)`
+
+error: aborting due to 10 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From d7d3dbf06022c3ec020c3906afa0090ad5ae239c Mon Sep 17 00:00:00 2001
From: "Samuel \"Sam\" Tardieu" <sam@rfc1149.net>
Date: Sat, 11 Mar 2023 12:44:18 +0100
Subject: New lint: detect unnecessary struct building

---
 CHANGELOG.md                                       |  1 +
 clippy_lints/src/declared_lints.rs                 |  1 +
 clippy_lints/src/lib.rs                            |  2 +
 .../src/unnecessary_struct_initialization.rs       | 84 ++++++++++++++++++++++
 tests/ui/needless_update.rs                        |  2 +-
 tests/ui/no_effect.rs                              |  7 +-
 tests/ui/no_effect.stderr                          | 60 ++++++++--------
 tests/ui/unnecessary_operation.fixed               |  8 ++-
 tests/ui/unnecessary_operation.rs                  |  8 ++-
 tests/ui/unnecessary_operation.stderr              | 40 +++++------
 tests/ui/unnecessary_struct_initialization.fixed   | 73 +++++++++++++++++++
 tests/ui/unnecessary_struct_initialization.rs      | 77 ++++++++++++++++++++
 tests/ui/unnecessary_struct_initialization.stderr  | 46 ++++++++++++
 13 files changed, 355 insertions(+), 54 deletions(-)
 create mode 100644 clippy_lints/src/unnecessary_struct_initialization.rs
 create mode 100644 tests/ui/unnecessary_struct_initialization.fixed
 create mode 100644 tests/ui/unnecessary_struct_initialization.rs
 create mode 100644 tests/ui/unnecessary_struct_initialization.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 47a503510c1..1323f973ccf 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4987,6 +4987,7 @@ Released 2018-09-13
 [`unnecessary_safety_doc`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_safety_doc
 [`unnecessary_self_imports`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_self_imports
 [`unnecessary_sort_by`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_sort_by
+[`unnecessary_struct_initialization`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_struct_initialization
 [`unnecessary_to_owned`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_to_owned
 [`unnecessary_unwrap`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_unwrap
 [`unnecessary_wraps`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_wraps
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 2331e857b1f..8ca91301472 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -618,6 +618,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::unnamed_address::VTABLE_ADDRESS_COMPARISONS_INFO,
     crate::unnecessary_owned_empty_strings::UNNECESSARY_OWNED_EMPTY_STRINGS_INFO,
     crate::unnecessary_self_imports::UNNECESSARY_SELF_IMPORTS_INFO,
+    crate::unnecessary_struct_initialization::UNNECESSARY_STRUCT_INITIALIZATION_INFO,
     crate::unnecessary_wraps::UNNECESSARY_WRAPS_INFO,
     crate::unnested_or_patterns::UNNESTED_OR_PATTERNS_INFO,
     crate::unsafe_removed_from_name::UNSAFE_REMOVED_FROM_NAME_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 100cba45679..c9210bf73f8 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -302,6 +302,7 @@ mod unit_types;
 mod unnamed_address;
 mod unnecessary_owned_empty_strings;
 mod unnecessary_self_imports;
+mod unnecessary_struct_initialization;
 mod unnecessary_wraps;
 mod unnested_or_patterns;
 mod unsafe_removed_from_name;
@@ -938,6 +939,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(let_with_type_underscore::UnderscoreTyped));
     store.register_late_pass(|_| Box::new(allow_attributes::AllowAttribute));
     store.register_late_pass(move |_| Box::new(manual_main_separator_str::ManualMainSeparatorStr::new(msrv())));
+    store.register_late_pass(|_| Box::new(unnecessary_struct_initialization::UnnecessaryStruct));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/unnecessary_struct_initialization.rs b/clippy_lints/src/unnecessary_struct_initialization.rs
new file mode 100644
index 00000000000..af0b4b1592f
--- /dev/null
+++ b/clippy_lints/src/unnecessary_struct_initialization.rs
@@ -0,0 +1,84 @@
+use clippy_utils::{diagnostics::span_lint_and_sugg, get_parent_expr, path_to_local, source::snippet, ty::is_copy};
+use rustc_hir::{BindingAnnotation, Expr, ExprKind, Node, PatKind, UnOp};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for initialization of a `struct` by copying a base without setting
+    /// any field.
+    ///
+    /// ### Why is this bad?
+    /// Readibility suffers from unnecessary struct building.
+    ///
+    /// ### Example
+    /// ```rust
+    /// struct S { s: String }
+    ///
+    /// let a = S { s: String::from("Hello, world!") };
+    /// let b = S { ..a };
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// struct S { s: String }
+    ///
+    /// let a = S { s: String::from("Hello, world!") };
+    /// let b = a;
+    /// ```
+    #[clippy::version = "1.70.0"]
+    pub UNNECESSARY_STRUCT_INITIALIZATION,
+    complexity,
+    "struct built from a base that can be written mode concisely"
+}
+declare_lint_pass!(UnnecessaryStruct => [UNNECESSARY_STRUCT_INITIALIZATION]);
+
+impl LateLintPass<'_> for UnnecessaryStruct {
+    fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
+        if let ExprKind::Struct(_, &[], Some(base)) = expr.kind {
+            if let Some(parent) = get_parent_expr(cx, expr) &&
+                let parent_ty = cx.typeck_results().expr_ty_adjusted(parent) &&
+                parent_ty.is_any_ptr()
+            {
+                if is_copy(cx, cx.typeck_results().expr_ty(expr)) && path_to_local(base).is_some() {
+                    // When the type implements `Copy`, a reference to the new struct works on the
+                    // copy. Using the original would borrow it.
+                    return;
+                }
+
+                if parent_ty.is_mutable_ptr() && !is_mutable(cx, base) {
+                    // The original can be used in a mutable reference context only if it is mutable.
+                    return;
+                }
+            }
+
+            // TODO: do not propose to replace *XX if XX is not Copy
+            if let ExprKind::Unary(UnOp::Deref, target) = base.kind &&
+                matches!(target.kind, ExprKind::Path(..)) &&
+                !is_copy(cx, cx.typeck_results().expr_ty(expr))
+            {
+                // `*base` cannot be used instead of the struct in the general case if it is not Copy.
+                return;
+            }
+
+            span_lint_and_sugg(
+                cx,
+                UNNECESSARY_STRUCT_INITIALIZATION,
+                expr.span,
+                "unnecessary struct building",
+                "replace with",
+                snippet(cx, base.span, "..").into_owned(),
+                rustc_errors::Applicability::MachineApplicable,
+            );
+        }
+    }
+}
+
+fn is_mutable(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+    if let Some(hir_id) = path_to_local(expr) &&
+        let Node::Pat(pat) = cx.tcx.hir().get(hir_id)
+    {
+        matches!(pat.kind, PatKind::Binding(BindingAnnotation::MUT, ..))
+    } else {
+        true
+    }
+}
diff --git a/tests/ui/needless_update.rs b/tests/ui/needless_update.rs
index b93ff048a62..4e8517cad10 100644
--- a/tests/ui/needless_update.rs
+++ b/tests/ui/needless_update.rs
@@ -1,5 +1,5 @@
 #![warn(clippy::needless_update)]
-#![allow(clippy::no_effect)]
+#![allow(clippy::no_effect, clippy::unnecessary_struct_initialization)]
 
 struct S {
     pub a: i32,
diff --git a/tests/ui/no_effect.rs b/tests/ui/no_effect.rs
index f08eb092e6b..ac8b1e756f2 100644
--- a/tests/ui/no_effect.rs
+++ b/tests/ui/no_effect.rs
@@ -1,7 +1,12 @@
 #![feature(box_syntax, fn_traits, unboxed_closures)]
 #![warn(clippy::no_effect_underscore_binding)]
 #![allow(dead_code, path_statements)]
-#![allow(clippy::deref_addrof, clippy::redundant_field_names, clippy::uninlined_format_args)]
+#![allow(
+    clippy::deref_addrof,
+    clippy::redundant_field_names,
+    clippy::uninlined_format_args,
+    clippy::unnecessary_struct_initialization
+)]
 
 struct Unit;
 struct Tuple(i32);
diff --git a/tests/ui/no_effect.stderr b/tests/ui/no_effect.stderr
index 6a1e636f9a6..2efefd2b2a3 100644
--- a/tests/ui/no_effect.stderr
+++ b/tests/ui/no_effect.stderr
@@ -1,5 +1,5 @@
 error: statement with no effect
-  --> $DIR/no_effect.rs:92:5
+  --> $DIR/no_effect.rs:97:5
    |
 LL |     0;
    |     ^^
@@ -7,157 +7,157 @@ LL |     0;
    = note: `-D clippy::no-effect` implied by `-D warnings`
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:93:5
+  --> $DIR/no_effect.rs:98:5
    |
 LL |     s2;
    |     ^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:94:5
+  --> $DIR/no_effect.rs:99:5
    |
 LL |     Unit;
    |     ^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:95:5
+  --> $DIR/no_effect.rs:100:5
    |
 LL |     Tuple(0);
    |     ^^^^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:96:5
+  --> $DIR/no_effect.rs:101:5
    |
 LL |     Struct { field: 0 };
    |     ^^^^^^^^^^^^^^^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:97:5
+  --> $DIR/no_effect.rs:102:5
    |
 LL |     Struct { ..s };
    |     ^^^^^^^^^^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:98:5
+  --> $DIR/no_effect.rs:103:5
    |
 LL |     Union { a: 0 };
    |     ^^^^^^^^^^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:99:5
+  --> $DIR/no_effect.rs:104:5
    |
 LL |     Enum::Tuple(0);
    |     ^^^^^^^^^^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:100:5
+  --> $DIR/no_effect.rs:105:5
    |
 LL |     Enum::Struct { field: 0 };
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:101:5
+  --> $DIR/no_effect.rs:106:5
    |
 LL |     5 + 6;
    |     ^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:102:5
+  --> $DIR/no_effect.rs:107:5
    |
 LL |     *&42;
    |     ^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:103:5
+  --> $DIR/no_effect.rs:108:5
    |
 LL |     &6;
    |     ^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:104:5
+  --> $DIR/no_effect.rs:109:5
    |
 LL |     (5, 6, 7);
    |     ^^^^^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:105:5
+  --> $DIR/no_effect.rs:110:5
    |
 LL |     box 42;
    |     ^^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:106:5
+  --> $DIR/no_effect.rs:111:5
    |
 LL |     ..;
    |     ^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:107:5
+  --> $DIR/no_effect.rs:112:5
    |
 LL |     5..;
    |     ^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:108:5
+  --> $DIR/no_effect.rs:113:5
    |
 LL |     ..5;
    |     ^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:109:5
+  --> $DIR/no_effect.rs:114:5
    |
 LL |     5..6;
    |     ^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:110:5
+  --> $DIR/no_effect.rs:115:5
    |
 LL |     5..=6;
    |     ^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:111:5
+  --> $DIR/no_effect.rs:116:5
    |
 LL |     [42, 55];
    |     ^^^^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:112:5
+  --> $DIR/no_effect.rs:117:5
    |
 LL |     [42, 55][1];
    |     ^^^^^^^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:113:5
+  --> $DIR/no_effect.rs:118:5
    |
 LL |     (42, 55).1;
    |     ^^^^^^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:114:5
+  --> $DIR/no_effect.rs:119:5
    |
 LL |     [42; 55];
    |     ^^^^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:115:5
+  --> $DIR/no_effect.rs:120:5
    |
 LL |     [42; 55][13];
    |     ^^^^^^^^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:117:5
+  --> $DIR/no_effect.rs:122:5
    |
 LL |     || x += 5;
    |     ^^^^^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:119:5
+  --> $DIR/no_effect.rs:124:5
    |
 LL |     FooString { s: s };
    |     ^^^^^^^^^^^^^^^^^^^
 
 error: binding to `_` prefixed variable with no side-effect
-  --> $DIR/no_effect.rs:120:5
+  --> $DIR/no_effect.rs:125:5
    |
 LL |     let _unused = 1;
    |     ^^^^^^^^^^^^^^^^
@@ -165,19 +165,19 @@ LL |     let _unused = 1;
    = note: `-D clippy::no-effect-underscore-binding` implied by `-D warnings`
 
 error: binding to `_` prefixed variable with no side-effect
-  --> $DIR/no_effect.rs:121:5
+  --> $DIR/no_effect.rs:126:5
    |
 LL |     let _penguin = || println!("Some helpful closure");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: binding to `_` prefixed variable with no side-effect
-  --> $DIR/no_effect.rs:122:5
+  --> $DIR/no_effect.rs:127:5
    |
 LL |     let _duck = Struct { field: 0 };
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: binding to `_` prefixed variable with no side-effect
-  --> $DIR/no_effect.rs:123:5
+  --> $DIR/no_effect.rs:128:5
    |
 LL |     let _cat = [2, 4, 6, 8][2];
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/unnecessary_operation.fixed b/tests/ui/unnecessary_operation.fixed
index d37163570ab..ec931c726ee 100644
--- a/tests/ui/unnecessary_operation.fixed
+++ b/tests/ui/unnecessary_operation.fixed
@@ -1,7 +1,13 @@
 // run-rustfix
 
 #![feature(box_syntax)]
-#![allow(clippy::deref_addrof, dead_code, unused, clippy::no_effect)]
+#![allow(
+    clippy::deref_addrof,
+    dead_code,
+    unused,
+    clippy::no_effect,
+    clippy::unnecessary_struct_initialization
+)]
 #![warn(clippy::unnecessary_operation)]
 
 struct Tuple(i32);
diff --git a/tests/ui/unnecessary_operation.rs b/tests/ui/unnecessary_operation.rs
index a14fd4bca0e..d896df32e41 100644
--- a/tests/ui/unnecessary_operation.rs
+++ b/tests/ui/unnecessary_operation.rs
@@ -1,7 +1,13 @@
 // run-rustfix
 
 #![feature(box_syntax)]
-#![allow(clippy::deref_addrof, dead_code, unused, clippy::no_effect)]
+#![allow(
+    clippy::deref_addrof,
+    dead_code,
+    unused,
+    clippy::no_effect,
+    clippy::unnecessary_struct_initialization
+)]
 #![warn(clippy::unnecessary_operation)]
 
 struct Tuple(i32);
diff --git a/tests/ui/unnecessary_operation.stderr b/tests/ui/unnecessary_operation.stderr
index f66d08ecb82..c183082ec86 100644
--- a/tests/ui/unnecessary_operation.stderr
+++ b/tests/ui/unnecessary_operation.stderr
@@ -1,5 +1,5 @@
 error: unnecessary operation
-  --> $DIR/unnecessary_operation.rs:51:5
+  --> $DIR/unnecessary_operation.rs:57:5
    |
 LL |     Tuple(get_number());
    |     ^^^^^^^^^^^^^^^^^^^^ help: statement can be reduced to: `get_number();`
@@ -7,109 +7,109 @@ LL |     Tuple(get_number());
    = note: `-D clippy::unnecessary-operation` implied by `-D warnings`
 
 error: unnecessary operation
-  --> $DIR/unnecessary_operation.rs:52:5
+  --> $DIR/unnecessary_operation.rs:58:5
    |
 LL |     Struct { field: get_number() };
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: statement can be reduced to: `get_number();`
 
 error: unnecessary operation
-  --> $DIR/unnecessary_operation.rs:53:5
+  --> $DIR/unnecessary_operation.rs:59:5
    |
 LL |     Struct { ..get_struct() };
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: statement can be reduced to: `get_struct();`
 
 error: unnecessary operation
-  --> $DIR/unnecessary_operation.rs:54:5
+  --> $DIR/unnecessary_operation.rs:60:5
    |
 LL |     Enum::Tuple(get_number());
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: statement can be reduced to: `get_number();`
 
 error: unnecessary operation
-  --> $DIR/unnecessary_operation.rs:55:5
+  --> $DIR/unnecessary_operation.rs:61:5
    |
 LL |     Enum::Struct { field: get_number() };
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: statement can be reduced to: `get_number();`
 
 error: unnecessary operation
-  --> $DIR/unnecessary_operation.rs:56:5
+  --> $DIR/unnecessary_operation.rs:62:5
    |
 LL |     5 + get_number();
    |     ^^^^^^^^^^^^^^^^^ help: statement can be reduced to: `5;get_number();`
 
 error: unnecessary operation
-  --> $DIR/unnecessary_operation.rs:57:5
+  --> $DIR/unnecessary_operation.rs:63:5
    |
 LL |     *&get_number();
    |     ^^^^^^^^^^^^^^^ help: statement can be reduced to: `get_number();`
 
 error: unnecessary operation
-  --> $DIR/unnecessary_operation.rs:58:5
+  --> $DIR/unnecessary_operation.rs:64:5
    |
 LL |     &get_number();
    |     ^^^^^^^^^^^^^^ help: statement can be reduced to: `get_number();`
 
 error: unnecessary operation
-  --> $DIR/unnecessary_operation.rs:59:5
+  --> $DIR/unnecessary_operation.rs:65:5
    |
 LL |     (5, 6, get_number());
    |     ^^^^^^^^^^^^^^^^^^^^^ help: statement can be reduced to: `5;6;get_number();`
 
 error: unnecessary operation
-  --> $DIR/unnecessary_operation.rs:60:5
+  --> $DIR/unnecessary_operation.rs:66:5
    |
 LL |     box get_number();
    |     ^^^^^^^^^^^^^^^^^ help: statement can be reduced to: `get_number();`
 
 error: unnecessary operation
-  --> $DIR/unnecessary_operation.rs:61:5
+  --> $DIR/unnecessary_operation.rs:67:5
    |
 LL |     get_number()..;
    |     ^^^^^^^^^^^^^^^ help: statement can be reduced to: `get_number();`
 
 error: unnecessary operation
-  --> $DIR/unnecessary_operation.rs:62:5
+  --> $DIR/unnecessary_operation.rs:68:5
    |
 LL |     ..get_number();
    |     ^^^^^^^^^^^^^^^ help: statement can be reduced to: `get_number();`
 
 error: unnecessary operation
-  --> $DIR/unnecessary_operation.rs:63:5
+  --> $DIR/unnecessary_operation.rs:69:5
    |
 LL |     5..get_number();
    |     ^^^^^^^^^^^^^^^^ help: statement can be reduced to: `5;get_number();`
 
 error: unnecessary operation
-  --> $DIR/unnecessary_operation.rs:64:5
+  --> $DIR/unnecessary_operation.rs:70:5
    |
 LL |     [42, get_number()];
    |     ^^^^^^^^^^^^^^^^^^^ help: statement can be reduced to: `42;get_number();`
 
 error: unnecessary operation
-  --> $DIR/unnecessary_operation.rs:65:5
+  --> $DIR/unnecessary_operation.rs:71:5
    |
 LL |     [42, 55][get_usize()];
    |     ^^^^^^^^^^^^^^^^^^^^^^ help: statement can be written as: `assert!([42, 55].len() > get_usize());`
 
 error: unnecessary operation
-  --> $DIR/unnecessary_operation.rs:66:5
+  --> $DIR/unnecessary_operation.rs:72:5
    |
 LL |     (42, get_number()).1;
    |     ^^^^^^^^^^^^^^^^^^^^^ help: statement can be reduced to: `42;get_number();`
 
 error: unnecessary operation
-  --> $DIR/unnecessary_operation.rs:67:5
+  --> $DIR/unnecessary_operation.rs:73:5
    |
 LL |     [get_number(); 55];
    |     ^^^^^^^^^^^^^^^^^^^ help: statement can be reduced to: `get_number();`
 
 error: unnecessary operation
-  --> $DIR/unnecessary_operation.rs:68:5
+  --> $DIR/unnecessary_operation.rs:74:5
    |
 LL |     [42; 55][get_usize()];
    |     ^^^^^^^^^^^^^^^^^^^^^^ help: statement can be written as: `assert!([42; 55].len() > get_usize());`
 
 error: unnecessary operation
-  --> $DIR/unnecessary_operation.rs:69:5
+  --> $DIR/unnecessary_operation.rs:75:5
    |
 LL | /     {
 LL | |         get_number()
@@ -117,7 +117,7 @@ LL | |     };
    | |______^ help: statement can be reduced to: `get_number();`
 
 error: unnecessary operation
-  --> $DIR/unnecessary_operation.rs:72:5
+  --> $DIR/unnecessary_operation.rs:78:5
    |
 LL | /     FooString {
 LL | |         s: String::from("blah"),
diff --git a/tests/ui/unnecessary_struct_initialization.fixed b/tests/ui/unnecessary_struct_initialization.fixed
new file mode 100644
index 00000000000..b47129e4a36
--- /dev/null
+++ b/tests/ui/unnecessary_struct_initialization.fixed
@@ -0,0 +1,73 @@
+// run-rustfix
+
+#![allow(unused)]
+#![warn(clippy::unnecessary_struct_initialization)]
+
+struct S {
+    f: String,
+}
+
+#[derive(Clone, Copy)]
+struct T {
+    f: u32,
+}
+
+struct U {
+    f: u32,
+}
+
+impl Clone for U {
+    fn clone(&self) -> Self {
+        // Do not lint: `Self` does not implement `Copy`
+        Self { ..*self }
+    }
+}
+
+#[derive(Copy)]
+struct V {
+    f: u32,
+}
+
+impl Clone for V {
+    fn clone(&self) -> Self {
+        // Lint: `Self` implements `Copy`
+        *self
+    }
+}
+
+fn main() {
+    // Should lint: `a` would be consumed anyway
+    let a = S { f: String::from("foo") };
+    let mut b = a;
+
+    // Should lint: `b` would be consumed, and is mutable
+    let c = &mut b;
+
+    // Should not lint as `d` is not mutable
+    let d = S { f: String::from("foo") };
+    let e = &mut S { ..d };
+
+    // Should lint as `f` would be consumed anyway
+    let f = S { f: String::from("foo") };
+    let g = &f;
+
+    // Should lint: the result of an expression is mutable
+    let h = &mut *Box::new(S { f: String::from("foo") });
+
+    // Should not lint: `m` would be both alive and borrowed
+    let m = T { f: 17 };
+    let n = &T { ..m };
+
+    // Should not lint: `m` should not be modified
+    let o = &mut T { ..m };
+    o.f = 32;
+    assert_eq!(m.f, 17);
+
+    // Should not lint: `m` should not be modified
+    let o = &mut T { ..m } as *mut T;
+    unsafe { &mut *o }.f = 32;
+    assert_eq!(m.f, 17);
+
+    // Should lint: the result of an expression is mutable and temporary
+    let p = &mut *Box::new(T { f: 5 });
+}
diff --git a/tests/ui/unnecessary_struct_initialization.rs b/tests/ui/unnecessary_struct_initialization.rs
new file mode 100644
index 00000000000..63b11c626e5
--- /dev/null
+++ b/tests/ui/unnecessary_struct_initialization.rs
@@ -0,0 +1,77 @@
+// run-rustfix
+
+#![allow(unused)]
+#![warn(clippy::unnecessary_struct_initialization)]
+
+struct S {
+    f: String,
+}
+
+#[derive(Clone, Copy)]
+struct T {
+    f: u32,
+}
+
+struct U {
+    f: u32,
+}
+
+impl Clone for U {
+    fn clone(&self) -> Self {
+        // Do not lint: `Self` does not implement `Copy`
+        Self { ..*self }
+    }
+}
+
+#[derive(Copy)]
+struct V {
+    f: u32,
+}
+
+impl Clone for V {
+    fn clone(&self) -> Self {
+        // Lint: `Self` implements `Copy`
+        Self { ..*self }
+    }
+}
+
+fn main() {
+    // Should lint: `a` would be consumed anyway
+    let a = S { f: String::from("foo") };
+    let mut b = S { ..a };
+
+    // Should lint: `b` would be consumed, and is mutable
+    let c = &mut S { ..b };
+
+    // Should not lint as `d` is not mutable
+    let d = S { f: String::from("foo") };
+    let e = &mut S { ..d };
+
+    // Should lint as `f` would be consumed anyway
+    let f = S { f: String::from("foo") };
+    let g = &S { ..f };
+
+    // Should lint: the result of an expression is mutable
+    let h = &mut S {
+        ..*Box::new(S { f: String::from("foo") })
+    };
+
+    // Should not lint: `m` would be both alive and borrowed
+    let m = T { f: 17 };
+    let n = &T { ..m };
+
+    // Should not lint: `m` should not be modified
+    let o = &mut T { ..m };
+    o.f = 32;
+    assert_eq!(m.f, 17);
+
+    // Should not lint: `m` should not be modified
+    let o = &mut T { ..m } as *mut T;
+    unsafe { &mut *o }.f = 32;
+    assert_eq!(m.f, 17);
+
+    // Should lint: the result of an expression is mutable and temporary
+    let p = &mut T {
+        ..*Box::new(T { f: 5 })
+    };
+}
diff --git a/tests/ui/unnecessary_struct_initialization.stderr b/tests/ui/unnecessary_struct_initialization.stderr
new file mode 100644
index 00000000000..ca497057702
--- /dev/null
+++ b/tests/ui/unnecessary_struct_initialization.stderr
@@ -0,0 +1,46 @@
+error: unnecessary struct building
+  --> $DIR/unnecessary_struct_initialization.rs:34:9
+   |
+LL |         Self { ..*self }
+   |         ^^^^^^^^^^^^^^^^ help: replace with: `*self`
+   |
+   = note: `-D clippy::unnecessary-struct-initialization` implied by `-D warnings`
+
+error: unnecessary struct building
+  --> $DIR/unnecessary_struct_initialization.rs:41:17
+   |
+LL |     let mut b = S { ..a };
+   |                 ^^^^^^^^^ help: replace with: `a`
+
+error: unnecessary struct building
+  --> $DIR/unnecessary_struct_initialization.rs:44:18
+   |
+LL |     let c = &mut S { ..b };
+   |                  ^^^^^^^^^ help: replace with: `b`
+
+error: unnecessary struct building
+  --> $DIR/unnecessary_struct_initialization.rs:52:14
+   |
+LL |     let g = &S { ..f };
+   |              ^^^^^^^^^ help: replace with: `f`
+
+error: unnecessary struct building
+  --> $DIR/unnecessary_struct_initialization.rs:55:18
+   |
+LL |       let h = &mut S {
+   |  __________________^
+LL | |         ..*Box::new(S { f: String::from("foo") })
+LL | |     };
+   | |_____^ help: replace with: `*Box::new(S { f: String::from("foo") })`
+
+error: unnecessary struct building
+  --> $DIR/unnecessary_struct_initialization.rs:74:18
+   |
+LL |       let p = &mut T {
+   |  __________________^
+LL | |         ..*Box::new(T { f: 5 })
+LL | |     };
+   | |_____^ help: replace with: `*Box::new(T { f: 5 })`
+
+error: aborting due to 6 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 50d92d0b60a0ac28b5311e0a04e3353af862079c Mon Sep 17 00:00:00 2001
From: Michael Krasnitski <michael.krasnitski@gmail.com>
Date: Wed, 22 Mar 2023 22:34:53 -0400
Subject: Add suggestions to `extra_unused_type_parameters`

---
 clippy_lints/src/extra_unused_type_parameters.rs   | 177 ++++++++++++++-------
 .../extra_unused_type_parameters/clippy.toml       |   1 +
 .../extra_unused_type_parameters.rs                |   9 ++
 tests/ui/extra_unused_type_parameters.fixed        | 105 ++++++++++++
 tests/ui/extra_unused_type_parameters.rs           |  11 +-
 tests/ui/extra_unused_type_parameters.stderr       |  79 ++++-----
 tests/ui/extra_unused_type_parameters_unfixable.rs |  24 +++
 .../extra_unused_type_parameters_unfixable.stderr  |  27 ++++
 8 files changed, 320 insertions(+), 113 deletions(-)
 create mode 100644 tests/ui-toml/extra_unused_type_parameters/clippy.toml
 create mode 100644 tests/ui-toml/extra_unused_type_parameters/extra_unused_type_parameters.rs
 create mode 100644 tests/ui/extra_unused_type_parameters.fixed
 create mode 100644 tests/ui/extra_unused_type_parameters_unfixable.rs
 create mode 100644 tests/ui/extra_unused_type_parameters_unfixable.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/extra_unused_type_parameters.rs b/clippy_lints/src/extra_unused_type_parameters.rs
index 20565e1d232..eeb4de8b58f 100644
--- a/clippy_lints/src/extra_unused_type_parameters.rs
+++ b/clippy_lints/src/extra_unused_type_parameters.rs
@@ -1,10 +1,10 @@
-use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_then};
 use clippy_utils::trait_ref_of_method;
-use rustc_data_structures::fx::FxHashMap;
-use rustc_errors::MultiSpan;
+use rustc_data_structures::fx::{FxHashMap, FxHashSet};
+use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_impl_item, walk_item, walk_param_bound, walk_ty, Visitor};
 use rustc_hir::{
-    BodyId, ExprKind, GenericBound, GenericParamKind, Generics, ImplItem, ImplItemKind, Item, ItemKind,
+    BodyId, ExprKind, GenericBound, GenericParam, GenericParamKind, Generics, ImplItem, ImplItemKind, Item, ItemKind,
     PredicateOrigin, Ty, TyKind, WherePredicate,
 };
 use rustc_lint::{LateContext, LateLintPass, LintContext};
@@ -53,13 +53,19 @@ impl ExtraUnusedTypeParameters {
         }
     }
 
-    /// Don't lint external macros or functions with empty bodies. Also, don't lint public items if
-    /// the `avoid_breaking_exported_api` config option is set.
-    fn check_false_positive(&self, cx: &LateContext<'_>, span: Span, def_id: LocalDefId, body_id: BodyId) -> bool {
+    /// Don't lint external macros or functions with empty bodies. Also, don't lint exported items
+    /// if the `avoid_breaking_exported_api` config option is set.
+    fn is_empty_exported_or_macro(
+        &self,
+        cx: &LateContext<'_>,
+        span: Span,
+        def_id: LocalDefId,
+        body_id: BodyId,
+    ) -> bool {
         let body = cx.tcx.hir().body(body_id).value;
         let fn_empty = matches!(&body.kind, ExprKind::Block(blk, None) if blk.stmts.is_empty() && blk.expr.is_none());
         let is_exported = cx.effective_visibilities.is_exported(def_id);
-        in_external_macro(cx.sess(), span) || (self.avoid_breaking_exported_api && is_exported) || fn_empty
+        in_external_macro(cx.sess(), span) || fn_empty || (is_exported && self.avoid_breaking_exported_api)
     }
 }
 
@@ -69,85 +75,129 @@ impl_lint_pass!(ExtraUnusedTypeParameters => [EXTRA_UNUSED_TYPE_PARAMETERS]);
 /// trait bounds those parameters have.
 struct TypeWalker<'cx, 'tcx> {
     cx: &'cx LateContext<'tcx>,
-    /// Collection of all the function's type parameters.
+    /// Collection of the function's type parameters. Once the function has been walked, this will
+    /// contain only unused type parameters.
     ty_params: FxHashMap<DefId, Span>,
-    /// Collection of any (inline) trait bounds corresponding to each type parameter.
-    bounds: FxHashMap<DefId, Span>,
+    /// Collection of any inline trait bounds corresponding to each type parameter.
+    inline_bounds: FxHashMap<DefId, Span>,
+    /// Collection of any type parameters with trait bounds that appear in a where clause.
+    where_bounds: FxHashSet<DefId>,
     /// The entire `Generics` object of the function, useful for querying purposes.
     generics: &'tcx Generics<'tcx>,
-    /// The value of this will remain `true` if *every* parameter:
-    ///   1. Is a type parameter, and
-    ///   2. Goes unused in the function.
-    /// Otherwise, if any type parameters end up being used, or if any lifetime or const-generic
-    /// parameters are present, this will be set to `false`.
-    all_params_unused: bool,
 }
 
 impl<'cx, 'tcx> TypeWalker<'cx, 'tcx> {
     fn new(cx: &'cx LateContext<'tcx>, generics: &'tcx Generics<'tcx>) -> Self {
-        let mut all_params_unused = true;
         let ty_params = generics
             .params
             .iter()
-            .filter_map(|param| {
-                if let GenericParamKind::Type { synthetic, .. } = param.kind {
-                    (!synthetic).then_some((param.def_id.into(), param.span))
-                } else {
-                    if !param.is_elided_lifetime() {
-                        all_params_unused = false;
-                    }
-                    None
-                }
+            .filter_map(|param| match param.kind {
+                GenericParamKind::Type { synthetic, .. } if !synthetic => Some((param.def_id.into(), param.span)),
+                _ => None,
             })
             .collect();
 
         Self {
             cx,
             ty_params,
-            bounds: FxHashMap::default(),
+            inline_bounds: FxHashMap::default(),
+            where_bounds: FxHashSet::default(),
             generics,
-            all_params_unused,
         }
     }
 
-    fn mark_param_used(&mut self, def_id: DefId) {
-        if self.ty_params.remove(&def_id).is_some() {
-            self.all_params_unused = false;
-        }
+    fn get_bound_span(&self, param: &'tcx GenericParam<'tcx>) -> Span {
+        self.inline_bounds
+            .get(&param.def_id.to_def_id())
+            .map_or(param.span, |bound_span| param.span.with_hi(bound_span.hi()))
+    }
+
+    fn emit_help(&self, spans: Vec<Span>, msg: &str, help: &'static str) {
+        span_lint_and_help(self.cx, EXTRA_UNUSED_TYPE_PARAMETERS, spans, msg, None, help);
+    }
+
+    fn emit_sugg(&self, spans: Vec<Span>, msg: &str, help: &'static str) {
+        let suggestions: Vec<(Span, String)> = spans.iter().copied().zip(std::iter::repeat(String::new())).collect();
+        span_lint_and_then(self.cx, EXTRA_UNUSED_TYPE_PARAMETERS, spans, msg, |diag| {
+            diag.multipart_suggestion(help, suggestions, Applicability::MachineApplicable);
+        });
     }
 
     fn emit_lint(&self) {
-        let (msg, help) = match self.ty_params.len() {
+        let explicit_params = self
+            .generics
+            .params
+            .iter()
+            .filter(|param| !param.is_elided_lifetime() && !param.is_impl_trait())
+            .collect::<Vec<_>>();
+
+        let extra_params = explicit_params
+            .iter()
+            .enumerate()
+            .filter(|(_, param)| self.ty_params.contains_key(&param.def_id.to_def_id()))
+            .collect::<Vec<_>>();
+
+        let (msg, help) = match extra_params.len() {
             0 => return,
             1 => (
-                "type parameter goes unused in function definition",
+                format!(
+                    "type parameter `{}` goes unused in function definition",
+                    extra_params[0].1.name.ident()
+                ),
                 "consider removing the parameter",
             ),
             _ => (
-                "type parameters go unused in function definition",
+                format!(
+                    "type parameters go unused in function definition: {}",
+                    extra_params
+                        .iter()
+                        .map(|(_, param)| param.name.ident().to_string())
+                        .collect::<Vec<_>>()
+                        .join(", ")
+                ),
                 "consider removing the parameters",
             ),
         };
 
-        let source_map = self.cx.sess().source_map();
-        let span = if self.all_params_unused {
-            self.generics.span.into() // Remove the entire list of generics
+        // If any parameters are bounded in where clauses, don't try to form a suggestion.
+        // Otherwise, the leftover where bound would produce code that wouldn't compile.
+        if extra_params
+            .iter()
+            .any(|(_, param)| self.where_bounds.contains(&param.def_id.to_def_id()))
+        {
+            let spans = extra_params
+                .iter()
+                .map(|(_, param)| self.get_bound_span(param))
+                .collect::<Vec<_>>();
+            self.emit_help(spans, &msg, help);
         } else {
-            MultiSpan::from_spans(
-                self.ty_params
+            let spans = if explicit_params.len() == extra_params.len() {
+                vec![self.generics.span] // Remove the entire list of generics
+            } else {
+                let mut end: Option<LocalDefId> = None;
+                extra_params
                     .iter()
-                    .map(|(def_id, &span)| {
-                        // Extend the span past any trait bounds, and include the comma at the end.
-                        let span_to_extend = self.bounds.get(def_id).copied().map_or(span, Span::shrink_to_hi);
-                        let comma_range = source_map.span_extend_to_next_char(span_to_extend, '>', false);
-                        let comma_span = source_map.span_through_char(comma_range, ',');
-                        span.with_hi(comma_span.hi())
+                    .rev()
+                    .map(|(idx, param)| {
+                        if let Some(next) = explicit_params.get(idx + 1) && end != Some(next.def_id) {
+                        // Extend the current span forward, up until the next param in the list.
+                        param.span.until(next.span)
+                    } else {
+                        // Extend the current span back to include the comma following the previous
+                        // param. If the span of the next param in the list has already been
+                        // extended, we continue the chain. This is why we're iterating in reverse.
+                        end = Some(param.def_id);
+
+                        // idx will never be 0, else we'd be removing the entire list of generics
+                        let prev = explicit_params[idx - 1];
+                        let prev_span = self.get_bound_span(prev);
+                        self.get_bound_span(param).with_lo(prev_span.hi())
+                    }
                     })
-                    .collect(),
-            )
+                    .collect()
+            };
+            self.emit_sugg(spans, &msg, help);
         };
-
-        span_lint_and_help(self.cx, EXTRA_UNUSED_TYPE_PARAMETERS, span, msg, None, help);
     }
 }
 
@@ -162,7 +212,7 @@ impl<'cx, 'tcx> Visitor<'tcx> for TypeWalker<'cx, 'tcx> {
 
     fn visit_ty(&mut self, t: &'tcx Ty<'tcx>) {
         if let Some((def_id, _)) = t.peel_refs().as_generic_param() {
-            self.mark_param_used(def_id);
+            self.ty_params.remove(&def_id);
         } else if let TyKind::OpaqueDef(id, _, _) = t.kind {
             // Explicitly walk OpaqueDef. Normally `walk_ty` would do the job, but it calls
             // `visit_nested_item`, which checks that `Self::NestedFilter::INTER` is set. We're
@@ -176,9 +226,18 @@ impl<'cx, 'tcx> Visitor<'tcx> for TypeWalker<'cx, 'tcx> {
 
     fn visit_where_predicate(&mut self, predicate: &'tcx WherePredicate<'tcx>) {
         if let WherePredicate::BoundPredicate(predicate) = predicate {
-            // Collect spans for any bounds on type parameters. We only keep bounds that appear in
-            // the list of generics (not in a where-clause).
+            // Collect spans for any bounds on type parameters.
             if let Some((def_id, _)) = predicate.bounded_ty.peel_refs().as_generic_param() {
+                match predicate.origin {
+                    PredicateOrigin::GenericParam => {
+                        self.inline_bounds.insert(def_id, predicate.span);
+                    },
+                    PredicateOrigin::WhereClause => {
+                        self.where_bounds.insert(def_id);
+                    },
+                    PredicateOrigin::ImplTrait => (),
+                }
+
                 // If the bound contains non-public traits, err on the safe side and don't lint the
                 // corresponding parameter.
                 if !predicate
@@ -187,12 +246,10 @@ impl<'cx, 'tcx> Visitor<'tcx> for TypeWalker<'cx, 'tcx> {
                     .filter_map(bound_to_trait_def_id)
                     .all(|id| self.cx.effective_visibilities.is_exported(id))
                 {
-                    self.mark_param_used(def_id);
-                } else if let PredicateOrigin::GenericParam = predicate.origin {
-                    self.bounds.insert(def_id, predicate.span);
+                    self.ty_params.remove(&def_id);
                 }
             }
-            // Only walk the right-hand side of where-bounds
+            // Only walk the right-hand side of where bounds
             for bound in predicate.bounds {
                 walk_param_bound(self, bound);
             }
@@ -207,7 +264,7 @@ impl<'cx, 'tcx> Visitor<'tcx> for TypeWalker<'cx, 'tcx> {
 impl<'tcx> LateLintPass<'tcx> for ExtraUnusedTypeParameters {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
         if let ItemKind::Fn(_, generics, body_id) = item.kind
-            && !self.check_false_positive(cx, item.span, item.owner_id.def_id, body_id)
+            && !self.is_empty_exported_or_macro(cx, item.span, item.owner_id.def_id, body_id)
         {
             let mut walker = TypeWalker::new(cx, generics);
             walk_item(&mut walker, item);
@@ -219,7 +276,7 @@ impl<'tcx> LateLintPass<'tcx> for ExtraUnusedTypeParameters {
         // Only lint on inherent methods, not trait methods.
         if let ImplItemKind::Fn(.., body_id) = item.kind
             && trait_ref_of_method(cx, item.owner_id.def_id).is_none()
-            && !self.check_false_positive(cx, item.span, item.owner_id.def_id, body_id)
+            && !self.is_empty_exported_or_macro(cx, item.span, item.owner_id.def_id, body_id)
         {
             let mut walker = TypeWalker::new(cx, item.generics);
             walk_impl_item(&mut walker, item);
diff --git a/tests/ui-toml/extra_unused_type_parameters/clippy.toml b/tests/ui-toml/extra_unused_type_parameters/clippy.toml
new file mode 100644
index 00000000000..5f304987aa9
--- /dev/null
+++ b/tests/ui-toml/extra_unused_type_parameters/clippy.toml
@@ -0,0 +1 @@
+avoid-breaking-exported-api = true
diff --git a/tests/ui-toml/extra_unused_type_parameters/extra_unused_type_parameters.rs b/tests/ui-toml/extra_unused_type_parameters/extra_unused_type_parameters.rs
new file mode 100644
index 00000000000..5655232455c
--- /dev/null
+++ b/tests/ui-toml/extra_unused_type_parameters/extra_unused_type_parameters.rs
@@ -0,0 +1,9 @@
+pub struct S;
+
+impl S {
+    pub fn exported_fn<T>() {
+        unimplemented!();
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/extra_unused_type_parameters.fixed b/tests/ui/extra_unused_type_parameters.fixed
new file mode 100644
index 00000000000..19e71862558
--- /dev/null
+++ b/tests/ui/extra_unused_type_parameters.fixed
@@ -0,0 +1,105 @@
+// run-rustfix
+
+#![allow(unused, clippy::needless_lifetimes)]
+#![warn(clippy::extra_unused_type_parameters)]
+
+fn unused_ty(x: u8) {
+    unimplemented!()
+}
+
+fn unused_multi(x: u8) {
+    unimplemented!()
+}
+
+fn unused_with_lt<'a>(x: &'a u8) {
+    unimplemented!()
+}
+
+fn used_ty<T>(x: T, y: u8) {}
+
+fn used_ref<'a, T>(x: &'a T) {}
+
+fn used_ret<T: Default>(x: u8) -> T {
+    T::default()
+}
+
+fn unused_bounded<U>(x: U) {
+    unimplemented!();
+}
+
+fn some_unused<B, C>(b: B, c: C) {
+    unimplemented!();
+}
+
+fn used_opaque<A>(iter: impl Iterator<Item = A>) -> usize {
+    iter.count()
+}
+
+fn used_ret_opaque<A>() -> impl Iterator<Item = A> {
+    std::iter::empty()
+}
+
+fn used_vec_box<T>(x: Vec<Box<T>>) {}
+
+fn used_body<T: Default + ToString>() -> String {
+    T::default().to_string()
+}
+
+fn used_closure<T: Default + ToString>() -> impl Fn() {
+    || println!("{}", T::default().to_string())
+}
+
+struct S;
+
+impl S {
+    fn unused_ty_impl(&self) {
+        unimplemented!()
+    }
+}
+
+// Don't lint on trait methods
+trait Foo {
+    fn bar<T>(&self);
+}
+
+impl Foo for S {
+    fn bar<T>(&self) {}
+}
+
+fn skip_index<A, Iter>(iter: Iter, index: usize) -> impl Iterator<Item = A>
+where
+    Iter: Iterator<Item = A>,
+{
+    iter.enumerate()
+        .filter_map(move |(i, a)| if i == index { None } else { Some(a) })
+}
+
+fn unused_opaque(dummy: impl Default) {
+    unimplemented!()
+}
+
+mod unexported_trait_bounds {
+    mod private {
+        pub trait Private {}
+    }
+
+    fn priv_trait_bound<T: private::Private>() {
+        unimplemented!();
+    }
+
+    fn unused_with_priv_trait_bound<T: private::Private>() {
+        unimplemented!();
+    }
+}
+
+mod issue10319 {
+    fn assert_send<T: Send>() {}
+
+    fn assert_send_where<T>()
+    where
+        T: Send,
+    {
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/extra_unused_type_parameters.rs b/tests/ui/extra_unused_type_parameters.rs
index 48017434276..e53bb587e89 100644
--- a/tests/ui/extra_unused_type_parameters.rs
+++ b/tests/ui/extra_unused_type_parameters.rs
@@ -1,3 +1,5 @@
+// run-rustfix
+
 #![allow(unused, clippy::needless_lifetimes)]
 #![warn(clippy::extra_unused_type_parameters)]
 
@@ -21,14 +23,7 @@ fn used_ret<T: Default>(x: u8) -> T {
     T::default()
 }
 
-fn unused_bounded<T: Default, U>(x: U) {
-    unimplemented!();
-}
-
-fn unused_where_clause<T, U>(x: U)
-where
-    T: Default,
-{
+fn unused_bounded<T: Default, U, V: Default>(x: U) {
     unimplemented!();
 }
 
diff --git a/tests/ui/extra_unused_type_parameters.stderr b/tests/ui/extra_unused_type_parameters.stderr
index 86c88fc9bf0..c042a5a2290 100644
--- a/tests/ui/extra_unused_type_parameters.stderr
+++ b/tests/ui/extra_unused_type_parameters.stderr
@@ -1,75 +1,64 @@
-error: type parameter goes unused in function definition
-  --> $DIR/extra_unused_type_parameters.rs:4:13
+error: type parameter `T` goes unused in function definition
+  --> $DIR/extra_unused_type_parameters.rs:6:13
    |
 LL | fn unused_ty<T>(x: u8) {
-   |             ^^^
+   |             ^^^ help: consider removing the parameter
    |
-   = help: consider removing the parameter
    = note: `-D clippy::extra-unused-type-parameters` implied by `-D warnings`
 
-error: type parameters go unused in function definition
-  --> $DIR/extra_unused_type_parameters.rs:8:16
+error: type parameters go unused in function definition: T, U
+  --> $DIR/extra_unused_type_parameters.rs:10:16
    |
 LL | fn unused_multi<T, U>(x: u8) {
-   |                ^^^^^^
-   |
-   = help: consider removing the parameters
+   |                ^^^^^^ help: consider removing the parameters
 
-error: type parameter goes unused in function definition
-  --> $DIR/extra_unused_type_parameters.rs:12:23
+error: type parameter `T` goes unused in function definition
+  --> $DIR/extra_unused_type_parameters.rs:14:21
    |
 LL | fn unused_with_lt<'a, T>(x: &'a u8) {
-   |                       ^
-   |
-   = help: consider removing the parameter
+   |                     ^^^ help: consider removing the parameter
 
-error: type parameter goes unused in function definition
-  --> $DIR/extra_unused_type_parameters.rs:24:19
+error: type parameters go unused in function definition: T, V
+  --> $DIR/extra_unused_type_parameters.rs:26:19
    |
-LL | fn unused_bounded<T: Default, U>(x: U) {
-   |                   ^^^^^^^^^^^
+LL | fn unused_bounded<T: Default, U, V: Default>(x: U) {
+   |                   ^^^^^^^^^^^^ ^^^^^^^^^^^^
    |
-   = help: consider removing the parameter
-
-error: type parameter goes unused in function definition
-  --> $DIR/extra_unused_type_parameters.rs:28:24
+help: consider removing the parameters
    |
-LL | fn unused_where_clause<T, U>(x: U)
-   |                        ^^
+LL - fn unused_bounded<T: Default, U, V: Default>(x: U) {
+LL + fn unused_bounded<U>(x: U) {
    |
-   = help: consider removing the parameter
 
-error: type parameters go unused in function definition
-  --> $DIR/extra_unused_type_parameters.rs:35:16
+error: type parameters go unused in function definition: A, D, E
+  --> $DIR/extra_unused_type_parameters.rs:30:16
    |
 LL | fn some_unused<A, B, C, D: Iterator<Item = (B, C)>, E>(b: B, c: C) {
-   |                ^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^
+   |                ^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider removing the parameters
+   |
+LL - fn some_unused<A, B, C, D: Iterator<Item = (B, C)>, E>(b: B, c: C) {
+LL + fn some_unused<B, C>(b: B, c: C) {
    |
-   = help: consider removing the parameters
 
-error: type parameter goes unused in function definition
-  --> $DIR/extra_unused_type_parameters.rs:60:22
+error: type parameter `T` goes unused in function definition
+  --> $DIR/extra_unused_type_parameters.rs:55:22
    |
 LL |     fn unused_ty_impl<T>(&self) {
-   |                      ^^^
-   |
-   = help: consider removing the parameter
+   |                      ^^^ help: consider removing the parameter
 
-error: type parameters go unused in function definition
-  --> $DIR/extra_unused_type_parameters.rs:82:17
+error: type parameters go unused in function definition: A, B
+  --> $DIR/extra_unused_type_parameters.rs:77:17
    |
 LL | fn unused_opaque<A, B>(dummy: impl Default) {
-   |                 ^^^^^^
-   |
-   = help: consider removing the parameters
+   |                 ^^^^^^ help: consider removing the parameters
 
-error: type parameter goes unused in function definition
-  --> $DIR/extra_unused_type_parameters.rs:95:58
+error: type parameter `U` goes unused in function definition
+  --> $DIR/extra_unused_type_parameters.rs:90:56
    |
 LL |     fn unused_with_priv_trait_bound<T: private::Private, U>() {
-   |                                                          ^
-   |
-   = help: consider removing the parameter
+   |                                                        ^^^ help: consider removing the parameter
 
-error: aborting due to 9 previous errors
+error: aborting due to 8 previous errors
 
diff --git a/tests/ui/extra_unused_type_parameters_unfixable.rs b/tests/ui/extra_unused_type_parameters_unfixable.rs
new file mode 100644
index 00000000000..10b39aa8f2c
--- /dev/null
+++ b/tests/ui/extra_unused_type_parameters_unfixable.rs
@@ -0,0 +1,24 @@
+#![warn(clippy::extra_unused_type_parameters)]
+
+fn unused_where_clause<T, U>(x: U)
+where
+    T: Default,
+{
+    unimplemented!();
+}
+
+fn unused_multi_where_clause<T, U, V: Default>(x: U)
+where
+    T: Default,
+{
+    unimplemented!();
+}
+
+fn unused_all_where_clause<T, U: Default, V: Default>()
+where
+    T: Default,
+{
+    unimplemented!();
+}
+
+fn main() {}
diff --git a/tests/ui/extra_unused_type_parameters_unfixable.stderr b/tests/ui/extra_unused_type_parameters_unfixable.stderr
new file mode 100644
index 00000000000..a9580cc894f
--- /dev/null
+++ b/tests/ui/extra_unused_type_parameters_unfixable.stderr
@@ -0,0 +1,27 @@
+error: type parameter `T` goes unused in function definition
+  --> $DIR/extra_unused_type_parameters_unfixable.rs:3:24
+   |
+LL | fn unused_where_clause<T, U>(x: U)
+   |                        ^
+   |
+   = help: consider removing the parameter
+   = note: `-D clippy::extra-unused-type-parameters` implied by `-D warnings`
+
+error: type parameters go unused in function definition: T, V
+  --> $DIR/extra_unused_type_parameters_unfixable.rs:10:30
+   |
+LL | fn unused_multi_where_clause<T, U, V: Default>(x: U)
+   |                              ^     ^^^^^^^^^^
+   |
+   = help: consider removing the parameters
+
+error: type parameters go unused in function definition: T, U, V
+  --> $DIR/extra_unused_type_parameters_unfixable.rs:17:28
+   |
+LL | fn unused_all_where_clause<T, U: Default, V: Default>()
+   |                            ^  ^^^^^^^^^^  ^^^^^^^^^^
+   |
+   = help: consider removing the parameters
+
+error: aborting due to 3 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 982c81ad2847f2736bc907b806b620ec2ac8fd11 Mon Sep 17 00:00:00 2001
From: FixedThink <41233185+FixedThink@users.noreply.github.com>
Date: Fri, 24 Mar 2023 16:08:27 +0100
Subject: docs fix: unknown field `allowed-locales`

changelog: fix: Replace the nonexistent `allowed-locales` in the `DISALLOWED_SCRIPT_IDENTS` docs with `allowed-scripts`.
---
 clippy_lints/src/disallowed_script_idents.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/disallowed_script_idents.rs b/clippy_lints/src/disallowed_script_idents.rs
index 084190f0013..c9fad98e437 100644
--- a/clippy_lints/src/disallowed_script_idents.rs
+++ b/clippy_lints/src/disallowed_script_idents.rs
@@ -32,7 +32,7 @@ declare_clippy_lint! {
     /// ### Example
     /// ```rust
     /// // Assuming that `clippy.toml` contains the following line:
-    /// // allowed-locales = ["Latin", "Cyrillic"]
+    /// // allowed-scripts = ["Latin", "Cyrillic"]
     /// let counter = 10; // OK, latin is allowed.
     /// let счётчик = 10; // OK, cyrillic is allowed.
     /// let zähler = 10; // OK, it's still latin.
-- 
cgit 1.4.1-3-g733a5


From b13f99c7e75e8769865dfe896b8ac3d2bb28cfb1 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Fri, 24 Mar 2023 15:29:30 +0000
Subject: Fix allow attribute, items from macros in `items_after_statements`

---
 clippy_lints/src/items_after_statements.rs | 31 ++++++-------
 clippy_lints/src/lib.rs                    |  2 +-
 tests/ui/item_after_statement.rs           | 53 ----------------------
 tests/ui/item_after_statement.stderr       | 33 --------------
 tests/ui/items_after_statement.rs          | 70 ++++++++++++++++++++++++++++++
 tests/ui/items_after_statement.stderr      | 33 ++++++++++++++
 6 files changed, 120 insertions(+), 102 deletions(-)
 delete mode 100644 tests/ui/item_after_statement.rs
 delete mode 100644 tests/ui/item_after_statement.stderr
 create mode 100644 tests/ui/items_after_statement.rs
 create mode 100644 tests/ui/items_after_statement.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/items_after_statements.rs b/clippy_lints/src/items_after_statements.rs
index 46d439b4497..a7ec57e2850 100644
--- a/clippy_lints/src/items_after_statements.rs
+++ b/clippy_lints/src/items_after_statements.rs
@@ -1,8 +1,8 @@
 //! lint when items are used after statements
 
-use clippy_utils::diagnostics::span_lint;
-use rustc_ast::ast::{Block, ItemKind, StmtKind};
-use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
+use clippy_utils::diagnostics::span_lint_hir;
+use rustc_hir::{Block, ItemKind, StmtKind};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
@@ -52,33 +52,34 @@ declare_clippy_lint! {
 
 declare_lint_pass!(ItemsAfterStatements => [ITEMS_AFTER_STATEMENTS]);
 
-impl EarlyLintPass for ItemsAfterStatements {
-    fn check_block(&mut self, cx: &EarlyContext<'_>, item: &Block) {
-        if in_external_macro(cx.sess(), item.span) {
+impl LateLintPass<'_> for ItemsAfterStatements {
+    fn check_block(&mut self, cx: &LateContext<'_>, block: &Block<'_>) {
+        if in_external_macro(cx.sess(), block.span) {
             return;
         }
 
-        // skip initial items and trailing semicolons
-        let stmts = item
+        // skip initial items
+        let stmts = block
             .stmts
             .iter()
-            .map(|stmt| &stmt.kind)
-            .skip_while(|s| matches!(**s, StmtKind::Item(..) | StmtKind::Empty));
+            .skip_while(|stmt| matches!(stmt.kind, StmtKind::Item(..)));
 
         // lint on all further items
         for stmt in stmts {
-            if let StmtKind::Item(ref it) = *stmt {
-                if in_external_macro(cx.sess(), it.span) {
+            if let StmtKind::Item(item_id) = stmt.kind {
+                let item = cx.tcx.hir().item(item_id);
+                if in_external_macro(cx.sess(), item.span) || !item.span.eq_ctxt(block.span) {
                     return;
                 }
-                if let ItemKind::MacroDef(..) = it.kind {
+                if let ItemKind::Macro(..) = item.kind {
                     // do not lint `macro_rules`, but continue processing further statements
                     continue;
                 }
-                span_lint(
+                span_lint_hir(
                     cx,
                     ITEMS_AFTER_STATEMENTS,
-                    it.span,
+                    item.hir_id(),
+                    item.span,
                     "adding items after statements is confusing, since items exist from the \
                      start of the scope",
                 );
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index c9210bf73f8..f6cea7e2daf 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -747,7 +747,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_early_pass(|| Box::new(unused_unit::UnusedUnit));
     store.register_late_pass(|_| Box::new(returns::Return));
     store.register_early_pass(|| Box::new(collapsible_if::CollapsibleIf));
-    store.register_early_pass(|| Box::new(items_after_statements::ItemsAfterStatements));
+    store.register_late_pass(|_| Box::new(items_after_statements::ItemsAfterStatements));
     store.register_early_pass(|| Box::new(precedence::Precedence));
     store.register_late_pass(|_| Box::new(needless_parens_on_range_literals::NeedlessParensOnRangeLiterals));
     store.register_early_pass(|| Box::new(needless_continue::NeedlessContinue));
diff --git a/tests/ui/item_after_statement.rs b/tests/ui/item_after_statement.rs
deleted file mode 100644
index 5e92dcab1f5..00000000000
--- a/tests/ui/item_after_statement.rs
+++ /dev/null
@@ -1,53 +0,0 @@
-#![warn(clippy::items_after_statements)]
-#![allow(clippy::uninlined_format_args)]
-
-fn ok() {
-    fn foo() {
-        println!("foo");
-    }
-    foo();
-}
-
-fn last() {
-    foo();
-    fn foo() {
-        println!("foo");
-    }
-}
-
-fn main() {
-    foo();
-    fn foo() {
-        println!("foo");
-    }
-    foo();
-}
-
-fn mac() {
-    let mut a = 5;
-    println!("{}", a);
-    // do not lint this, because it needs to be after `a`
-    macro_rules! b {
-        () => {{
-            a = 6;
-            fn say_something() {
-                println!("something");
-            }
-        }};
-    }
-    b!();
-    println!("{}", a);
-}
-
-fn semicolon() {
-    struct S {
-        a: u32,
-    };
-    impl S {
-        fn new(a: u32) -> Self {
-            Self { a }
-        }
-    }
-
-    let _ = S::new(3);
-}
diff --git a/tests/ui/item_after_statement.stderr b/tests/ui/item_after_statement.stderr
deleted file mode 100644
index 2523c53ac53..00000000000
--- a/tests/ui/item_after_statement.stderr
+++ /dev/null
@@ -1,33 +0,0 @@
-error: adding items after statements is confusing, since items exist from the start of the scope
-  --> $DIR/item_after_statement.rs:13:5
-   |
-LL | /     fn foo() {
-LL | |         println!("foo");
-LL | |     }
-   | |_____^
-   |
-   = note: `-D clippy::items-after-statements` implied by `-D warnings`
-
-error: adding items after statements is confusing, since items exist from the start of the scope
-  --> $DIR/item_after_statement.rs:20:5
-   |
-LL | /     fn foo() {
-LL | |         println!("foo");
-LL | |     }
-   | |_____^
-
-error: adding items after statements is confusing, since items exist from the start of the scope
-  --> $DIR/item_after_statement.rs:33:13
-   |
-LL | /             fn say_something() {
-LL | |                 println!("something");
-LL | |             }
-   | |_____________^
-...
-LL |       b!();
-   |       ---- in this macro invocation
-   |
-   = note: this error originates in the macro `b` (in Nightly builds, run with -Z macro-backtrace for more info)
-
-error: aborting due to 3 previous errors
-
diff --git a/tests/ui/items_after_statement.rs b/tests/ui/items_after_statement.rs
new file mode 100644
index 00000000000..f12cb8f22e2
--- /dev/null
+++ b/tests/ui/items_after_statement.rs
@@ -0,0 +1,70 @@
+#![warn(clippy::items_after_statements)]
+#![allow(clippy::uninlined_format_args)]
+
+fn ok() {
+    fn foo() {
+        println!("foo");
+    }
+    foo();
+}
+
+fn last() {
+    foo();
+    fn foo() {
+        println!("foo");
+    }
+}
+
+fn main() {
+    foo();
+    fn foo() {
+        println!("foo");
+    }
+    foo();
+}
+
+fn mac() {
+    let mut a = 5;
+    println!("{}", a);
+    // do not lint this, because it needs to be after `a`
+    macro_rules! b {
+        () => {{
+            a = 6;
+            fn say_something() {
+                println!("something");
+            }
+        }};
+    }
+    b!();
+    println!("{}", a);
+}
+
+fn semicolon() {
+    struct S {
+        a: u32,
+    };
+    impl S {
+        fn new(a: u32) -> Self {
+            Self { a }
+        }
+    }
+
+    let _ = S::new(3);
+}
+
+fn item_from_macro() {
+    macro_rules! static_assert_size {
+        ($ty:ty, $size:expr) => {
+            const _: [(); $size] = [(); ::std::mem::size_of::<$ty>()];
+        };
+    }
+
+    let _ = 1;
+    static_assert_size!(u32, 4);
+}
+
+fn allow_attribute() {
+    let _ = 1;
+    #[allow(clippy::items_after_statements)]
+    const _: usize = 1;
+}
diff --git a/tests/ui/items_after_statement.stderr b/tests/ui/items_after_statement.stderr
new file mode 100644
index 00000000000..f69635a977b
--- /dev/null
+++ b/tests/ui/items_after_statement.stderr
@@ -0,0 +1,33 @@
+error: adding items after statements is confusing, since items exist from the start of the scope
+  --> $DIR/items_after_statement.rs:13:5
+   |
+LL | /     fn foo() {
+LL | |         println!("foo");
+LL | |     }
+   | |_____^
+   |
+   = note: `-D clippy::items-after-statements` implied by `-D warnings`
+
+error: adding items after statements is confusing, since items exist from the start of the scope
+  --> $DIR/items_after_statement.rs:20:5
+   |
+LL | /     fn foo() {
+LL | |         println!("foo");
+LL | |     }
+   | |_____^
+
+error: adding items after statements is confusing, since items exist from the start of the scope
+  --> $DIR/items_after_statement.rs:33:13
+   |
+LL | /             fn say_something() {
+LL | |                 println!("something");
+LL | |             }
+   | |_____________^
+...
+LL |       b!();
+   |       ---- in this macro invocation
+   |
+   = note: this error originates in the macro `b` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: aborting due to 3 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 52c4dc65d942efd2c74e8c9b3334ee268a8522ae Mon Sep 17 00:00:00 2001
From: J-ZhengLi <lizheng135@huawei.com>
Date: Tue, 14 Mar 2023 09:15:23 +0800
Subject: fix [`cast_possible_truncation`] offering wrong suggestion when
 casting from float

suggest `try_into` when casting to wildcard type;
fix [`cast_possible_truncation`] suggesting useless parenthesis;

remove suggesting for float to float conversion in [`cast_possible_truncation`]

style nit
---
 clippy_lints/src/casts/cast_possible_truncation.rs |  42 +++++---
 tests/ui/cast.rs                                   |   6 ++
 tests/ui/cast.stderr                               | 112 ++++++++++++---------
 3 files changed, 100 insertions(+), 60 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/cast_possible_truncation.rs b/clippy_lints/src/casts/cast_possible_truncation.rs
index 823970e35ab..95c2ecbf791 100644
--- a/clippy_lints/src/casts/cast_possible_truncation.rs
+++ b/clippy_lints/src/casts/cast_possible_truncation.rs
@@ -2,8 +2,9 @@ use clippy_utils::consts::{constant, Constant};
 use clippy_utils::diagnostics::{span_lint, span_lint_and_then};
 use clippy_utils::expr_or_init;
 use clippy_utils::source::snippet;
+use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::{get_discriminant_value, is_isize_or_usize};
-use rustc_errors::{Applicability, SuggestionStyle};
+use rustc_errors::{Applicability, Diagnostic, SuggestionStyle};
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::LateContext;
@@ -163,19 +164,34 @@ pub(super) fn check(
         _ => return,
     };
 
-    let name_of_cast_from = snippet(cx, cast_expr.span, "..");
-    let cast_to_snip = snippet(cx, cast_to_span, "..");
-    let suggestion = format!("{cast_to_snip}::try_from({name_of_cast_from})");
-
     span_lint_and_then(cx, CAST_POSSIBLE_TRUNCATION, expr.span, &msg, |diag| {
         diag.help("if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...");
-        diag.span_suggestion_with_style(
-            expr.span,
-            "... or use `try_from` and handle the error accordingly",
-            suggestion,
-            Applicability::Unspecified,
-            // always show the suggestion in a separate line
-            SuggestionStyle::ShowAlways,
-        );
+        if !cast_from.is_floating_point() {
+            offer_suggestion(cx, expr, cast_expr, cast_to_span, diag);
+        }
     });
 }
+
+fn offer_suggestion(
+    cx: &LateContext<'_>,
+    expr: &Expr<'_>,
+    cast_expr: &Expr<'_>,
+    cast_to_span: Span,
+    diag: &mut Diagnostic,
+) {
+    let cast_to_snip = snippet(cx, cast_to_span, "..");
+    let suggestion = if cast_to_snip == "_" {
+        format!("{}.try_into()", Sugg::hir(cx, cast_expr, "..").maybe_par())
+    } else {
+        format!("{cast_to_snip}::try_from({})", Sugg::hir(cx, cast_expr, ".."))
+    };
+
+    diag.span_suggestion_with_style(
+        expr.span,
+        "... or use `try_from` and handle the error accordingly",
+        suggestion,
+        Applicability::Unspecified,
+        // always show the suggestion in a separate line
+        SuggestionStyle::ShowAlways,
+    );
+}
diff --git a/tests/ui/cast.rs b/tests/ui/cast.rs
index 8b2673c2a7f..a86b85706a3 100644
--- a/tests/ui/cast.rs
+++ b/tests/ui/cast.rs
@@ -29,6 +29,12 @@ fn main() {
     1f64 as isize;
     1f64 as usize;
     1f32 as u32 as u16;
+    {
+        let _x: i8 = 1i32 as _;
+        1f32 as i32;
+        1f64 as i32;
+        1f32 as u8;
+    }
     // Test clippy::cast_possible_wrap
     1u8 as i8;
     1u16 as i16;
diff --git a/tests/ui/cast.stderr b/tests/ui/cast.stderr
index 451078de23b..65ecf1aa37a 100644
--- a/tests/ui/cast.stderr
+++ b/tests/ui/cast.stderr
@@ -44,10 +44,6 @@ LL |     1f32 as i32;
    |
    = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
    = note: `-D clippy::cast-possible-truncation` implied by `-D warnings`
-help: ... or use `try_from` and handle the error accordingly
-   |
-LL |     i32::try_from(1f32);
-   |     ~~~~~~~~~~~~~~~~~~~
 
 error: casting `f32` to `u32` may truncate the value
   --> $DIR/cast.rs:25:5
@@ -56,10 +52,6 @@ LL |     1f32 as u32;
    |     ^^^^^^^^^^^
    |
    = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
-help: ... or use `try_from` and handle the error accordingly
-   |
-LL |     u32::try_from(1f32);
-   |     ~~~~~~~~~~~~~~~~~~~
 
 error: casting `f32` to `u32` may lose the sign of the value
   --> $DIR/cast.rs:25:5
@@ -76,10 +68,6 @@ LL |     1f64 as f32;
    |     ^^^^^^^^^^^
    |
    = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
-help: ... or use `try_from` and handle the error accordingly
-   |
-LL |     f32::try_from(1f64);
-   |     ~~~~~~~~~~~~~~~~~~~
 
 error: casting `i32` to `i8` may truncate the value
   --> $DIR/cast.rs:27:5
@@ -112,10 +100,6 @@ LL |     1f64 as isize;
    |     ^^^^^^^^^^^^^
    |
    = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
-help: ... or use `try_from` and handle the error accordingly
-   |
-LL |     isize::try_from(1f64);
-   |     ~~~~~~~~~~~~~~~~~~~~~
 
 error: casting `f64` to `usize` may truncate the value
   --> $DIR/cast.rs:30:5
@@ -124,10 +108,6 @@ LL |     1f64 as usize;
    |     ^^^^^^^^^^^^^
    |
    = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
-help: ... or use `try_from` and handle the error accordingly
-   |
-LL |     usize::try_from(1f64);
-   |     ~~~~~~~~~~~~~~~~~~~~~
 
 error: casting `f64` to `usize` may lose the sign of the value
   --> $DIR/cast.rs:30:5
@@ -154,10 +134,6 @@ LL |     1f32 as u32 as u16;
    |     ^^^^^^^^^^^
    |
    = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
-help: ... or use `try_from` and handle the error accordingly
-   |
-LL |     u32::try_from(1f32) as u16;
-   |     ~~~~~~~~~~~~~~~~~~~
 
 error: casting `f32` to `u32` may lose the sign of the value
   --> $DIR/cast.rs:31:5
@@ -165,8 +141,50 @@ error: casting `f32` to `u32` may lose the sign of the value
 LL |     1f32 as u32 as u16;
    |     ^^^^^^^^^^^
 
+error: casting `i32` to `i8` may truncate the value
+  --> $DIR/cast.rs:33:22
+   |
+LL |         let _x: i8 = 1i32 as _;
+   |                      ^^^^^^^^^
+   |
+   = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
+help: ... or use `try_from` and handle the error accordingly
+   |
+LL |         let _x: i8 = 1i32.try_into();
+   |                      ~~~~~~~~~~~~~~~
+
+error: casting `f32` to `i32` may truncate the value
+  --> $DIR/cast.rs:34:9
+   |
+LL |         1f32 as i32;
+   |         ^^^^^^^^^^^
+   |
+   = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
+
+error: casting `f64` to `i32` may truncate the value
+  --> $DIR/cast.rs:35:9
+   |
+LL |         1f64 as i32;
+   |         ^^^^^^^^^^^
+   |
+   = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
+
+error: casting `f32` to `u8` may truncate the value
+  --> $DIR/cast.rs:36:9
+   |
+LL |         1f32 as u8;
+   |         ^^^^^^^^^^
+   |
+   = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
+
+error: casting `f32` to `u8` may lose the sign of the value
+  --> $DIR/cast.rs:36:9
+   |
+LL |         1f32 as u8;
+   |         ^^^^^^^^^^
+
 error: casting `u8` to `i8` may wrap around the value
-  --> $DIR/cast.rs:33:5
+  --> $DIR/cast.rs:39:5
    |
 LL |     1u8 as i8;
    |     ^^^^^^^^^
@@ -174,43 +192,43 @@ LL |     1u8 as i8;
    = note: `-D clippy::cast-possible-wrap` implied by `-D warnings`
 
 error: casting `u16` to `i16` may wrap around the value
-  --> $DIR/cast.rs:34:5
+  --> $DIR/cast.rs:40:5
    |
 LL |     1u16 as i16;
    |     ^^^^^^^^^^^
 
 error: casting `u32` to `i32` may wrap around the value
-  --> $DIR/cast.rs:35:5
+  --> $DIR/cast.rs:41:5
    |
 LL |     1u32 as i32;
    |     ^^^^^^^^^^^
 
 error: casting `u64` to `i64` may wrap around the value
-  --> $DIR/cast.rs:36:5
+  --> $DIR/cast.rs:42:5
    |
 LL |     1u64 as i64;
    |     ^^^^^^^^^^^
 
 error: casting `usize` to `isize` may wrap around the value
-  --> $DIR/cast.rs:37:5
+  --> $DIR/cast.rs:43:5
    |
 LL |     1usize as isize;
    |     ^^^^^^^^^^^^^^^
 
 error: casting `i32` to `u32` may lose the sign of the value
-  --> $DIR/cast.rs:40:5
+  --> $DIR/cast.rs:46:5
    |
 LL |     -1i32 as u32;
    |     ^^^^^^^^^^^^
 
 error: casting `isize` to `usize` may lose the sign of the value
-  --> $DIR/cast.rs:42:5
+  --> $DIR/cast.rs:48:5
    |
 LL |     -1isize as usize;
    |     ^^^^^^^^^^^^^^^^
 
 error: casting `i64` to `i8` may truncate the value
-  --> $DIR/cast.rs:109:5
+  --> $DIR/cast.rs:115:5
    |
 LL |     (-99999999999i64).min(1) as i8; // should be linted because signed
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -222,7 +240,7 @@ LL |     i8::try_from((-99999999999i64).min(1)); // should be linted because sig
    |     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 error: casting `u64` to `u8` may truncate the value
-  --> $DIR/cast.rs:121:5
+  --> $DIR/cast.rs:127:5
    |
 LL |     999999u64.clamp(0, 256) as u8; // should still be linted
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -234,7 +252,7 @@ LL |     u8::try_from(999999u64.clamp(0, 256)); // should still be linted
    |     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 error: casting `main::E2` to `u8` may truncate the value
-  --> $DIR/cast.rs:142:21
+  --> $DIR/cast.rs:148:21
    |
 LL |             let _ = self as u8;
    |                     ^^^^^^^^^^
@@ -246,7 +264,7 @@ LL |             let _ = u8::try_from(self);
    |                     ~~~~~~~~~~~~~~~~~~
 
 error: casting `main::E2::B` to `u8` will truncate the value
-  --> $DIR/cast.rs:143:21
+  --> $DIR/cast.rs:149:21
    |
 LL |             let _ = Self::B as u8;
    |                     ^^^^^^^^^^^^^
@@ -254,7 +272,7 @@ LL |             let _ = Self::B as u8;
    = note: `-D clippy::cast-enum-truncation` implied by `-D warnings`
 
 error: casting `main::E5` to `i8` may truncate the value
-  --> $DIR/cast.rs:179:21
+  --> $DIR/cast.rs:185:21
    |
 LL |             let _ = self as i8;
    |                     ^^^^^^^^^^
@@ -266,13 +284,13 @@ LL |             let _ = i8::try_from(self);
    |                     ~~~~~~~~~~~~~~~~~~
 
 error: casting `main::E5::A` to `i8` will truncate the value
-  --> $DIR/cast.rs:180:21
+  --> $DIR/cast.rs:186:21
    |
 LL |             let _ = Self::A as i8;
    |                     ^^^^^^^^^^^^^
 
 error: casting `main::E6` to `i16` may truncate the value
-  --> $DIR/cast.rs:194:21
+  --> $DIR/cast.rs:200:21
    |
 LL |             let _ = self as i16;
    |                     ^^^^^^^^^^^
@@ -284,7 +302,7 @@ LL |             let _ = i16::try_from(self);
    |                     ~~~~~~~~~~~~~~~~~~~
 
 error: casting `main::E7` to `usize` may truncate the value on targets with 32-bit wide pointers
-  --> $DIR/cast.rs:209:21
+  --> $DIR/cast.rs:215:21
    |
 LL |             let _ = self as usize;
    |                     ^^^^^^^^^^^^^
@@ -296,7 +314,7 @@ LL |             let _ = usize::try_from(self);
    |                     ~~~~~~~~~~~~~~~~~~~~~
 
 error: casting `main::E10` to `u16` may truncate the value
-  --> $DIR/cast.rs:250:21
+  --> $DIR/cast.rs:256:21
    |
 LL |             let _ = self as u16;
    |                     ^^^^^^^^^^^
@@ -308,7 +326,7 @@ LL |             let _ = u16::try_from(self);
    |                     ~~~~~~~~~~~~~~~~~~~
 
 error: casting `u32` to `u8` may truncate the value
-  --> $DIR/cast.rs:258:13
+  --> $DIR/cast.rs:264:13
    |
 LL |     let c = (q >> 16) as u8;
    |             ^^^^^^^^^^^^^^^
@@ -316,11 +334,11 @@ LL |     let c = (q >> 16) as u8;
    = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
 help: ... or use `try_from` and handle the error accordingly
    |
-LL |     let c = u8::try_from((q >> 16));
-   |             ~~~~~~~~~~~~~~~~~~~~~~~
+LL |     let c = u8::try_from(q >> 16);
+   |             ~~~~~~~~~~~~~~~~~~~~~
 
 error: casting `u32` to `u8` may truncate the value
-  --> $DIR/cast.rs:261:13
+  --> $DIR/cast.rs:267:13
    |
 LL |     let c = (q / 1000) as u8;
    |             ^^^^^^^^^^^^^^^^
@@ -328,8 +346,8 @@ LL |     let c = (q / 1000) as u8;
    = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
 help: ... or use `try_from` and handle the error accordingly
    |
-LL |     let c = u8::try_from((q / 1000));
-   |             ~~~~~~~~~~~~~~~~~~~~~~~~
+LL |     let c = u8::try_from(q / 1000);
+   |             ~~~~~~~~~~~~~~~~~~~~~~
 
-error: aborting due to 36 previous errors
+error: aborting due to 41 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From a6f56cbdbaa6c65019278676a136299838ced65f Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Sun, 26 Mar 2023 14:16:38 +0000
Subject: Move unnecessary_struct_initialization to nursery

---
 clippy_lints/src/unnecessary_struct_initialization.rs | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unnecessary_struct_initialization.rs b/clippy_lints/src/unnecessary_struct_initialization.rs
index af0b4b1592f..084b031982d 100644
--- a/clippy_lints/src/unnecessary_struct_initialization.rs
+++ b/clippy_lints/src/unnecessary_struct_initialization.rs
@@ -9,7 +9,7 @@ declare_clippy_lint! {
     /// any field.
     ///
     /// ### Why is this bad?
-    /// Readibility suffers from unnecessary struct building.
+    /// Readability suffers from unnecessary struct building.
     ///
     /// ### Example
     /// ```rust
@@ -25,9 +25,13 @@ declare_clippy_lint! {
     /// let a = S { s: String::from("Hello, world!") };
     /// let b = a;
     /// ```
+    ///
+    /// ### Known Problems
+    /// Has false positives when the base is a place expression that cannot be
+    /// moved out of, see [#10547](https://github.com/rust-lang/rust-clippy/issues/10547).
     #[clippy::version = "1.70.0"]
     pub UNNECESSARY_STRUCT_INITIALIZATION,
-    complexity,
+    nursery,
     "struct built from a base that can be written mode concisely"
 }
 declare_lint_pass!(UnnecessaryStruct => [UNNECESSARY_STRUCT_INITIALIZATION]);
-- 
cgit 1.4.1-3-g733a5


From 2493be2196f6ba16eaea25915c25d93f1c2664b5 Mon Sep 17 00:00:00 2001
From: bluthej <joffrey.bluthe@e.email>
Date: Sun, 26 Mar 2023 18:25:15 +0200
Subject: Improve `is_range_full` implementation

Make this function work with signed integer types by extracting the
underlying type and finding the min and max values.

Change the signature to make it more consistent:
- The range is now given as an `Expr` in order to extract the type
- The container's path is now passed, and only as an `Option` so that
  the function can be called in the general case without a container
---
 clippy_lints/src/methods/clear_with_drain.rs |  7 +--
 clippy_lints/src/methods/iter_with_drain.rs  |  7 ++-
 clippy_utils/src/lib.rs                      | 71 +++++++++++++++++++++++-----
 3 files changed, 65 insertions(+), 20 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/clear_with_drain.rs b/clippy_lints/src/methods/clear_with_drain.rs
index bf7e7d12405..24496bd4689 100644
--- a/clippy_lints/src/methods/clear_with_drain.rs
+++ b/clippy_lints/src/methods/clear_with_drain.rs
@@ -1,9 +1,8 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::higher::Range;
 use clippy_utils::is_range_full;
 use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_errors::Applicability;
-use rustc_hir::Expr;
+use rustc_hir::{Expr, ExprKind, QPath};
 use rustc_lint::LateContext;
 use rustc_span::symbol::sym;
 use rustc_span::Span;
@@ -12,7 +11,9 @@ use super::CLEAR_WITH_DRAIN;
 
 pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'_>, span: Span, arg: &Expr<'_>) {
     let ty = cx.typeck_results().expr_ty(recv);
-    if is_type_diagnostic_item(cx, ty, sym::Vec) && let Some(range) = Range::hir(arg) && is_range_full(cx, recv, range)
+    if is_type_diagnostic_item(cx, ty, sym::Vec)
+        && let ExprKind::Path(QPath::Resolved(None, container_path)) = recv.kind
+        && is_range_full(cx, arg, Some(container_path))
     {
         span_lint_and_sugg(
             cx,
diff --git a/clippy_lints/src/methods/iter_with_drain.rs b/clippy_lints/src/methods/iter_with_drain.rs
index ea92e3a549f..f6772c5c6b3 100644
--- a/clippy_lints/src/methods/iter_with_drain.rs
+++ b/clippy_lints/src/methods/iter_with_drain.rs
@@ -1,8 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::higher::Range;
 use clippy_utils::is_range_full;
 use rustc_errors::Applicability;
-use rustc_hir::{Expr, ExprKind};
+use rustc_hir::{Expr, ExprKind, QPath};
 use rustc_lint::LateContext;
 use rustc_span::symbol::sym;
 use rustc_span::Span;
@@ -14,8 +13,8 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'_>, span
         && let Some(adt) = cx.typeck_results().expr_ty(recv).ty_adt_def()
         && let Some(ty_name) = cx.tcx.get_diagnostic_name(adt.did())
         && matches!(ty_name, sym::Vec | sym::VecDeque)
-        && let Some(range) = Range::hir(arg)
-        && is_range_full(cx, recv, range)
+        && let ExprKind::Path(QPath::Resolved(None, container_path)) = recv.kind
+        && is_range_full(cx, arg, Some(container_path))
     {
         span_lint_and_sugg(
             cx,
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index e8225feb33d..2e839fdf472 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -96,6 +96,7 @@ use rustc_hir::{
 use rustc_lexer::{tokenize, TokenKind};
 use rustc_lint::{LateContext, Level, Lint, LintContext};
 use rustc_middle::hir::place::PlaceBase;
+use rustc_middle::mir::ConstantKind;
 use rustc_middle::ty as rustc_ty;
 use rustc_middle::ty::adjustment::{Adjust, Adjustment, AutoBorrow};
 use rustc_middle::ty::binding::BindingMode;
@@ -114,7 +115,7 @@ use rustc_span::symbol::{kw, Ident, Symbol};
 use rustc_span::Span;
 use rustc_target::abi::Integer;
 
-use crate::consts::{constant, Constant};
+use crate::consts::{constant, miri_to_const, Constant};
 use crate::higher::Range;
 use crate::ty::{can_partially_move_ty, expr_sig, is_copy, is_recursively_primitive_type, ty_is_fn_once_param};
 use crate::visitors::for_each_expr;
@@ -1492,22 +1493,66 @@ pub fn is_else_clause(tcx: TyCtxt<'_>, expr: &Expr<'_>) -> bool {
     }
 }
 
-/// Checks whether the given `Range` is equivalent to a `RangeFull`.
-/// Inclusive ranges are not considered because they already constitute a lint.
-pub fn is_range_full(cx: &LateContext<'_>, container: &Expr<'_>, range: Range<'_>) -> bool {
-    range.start.map_or(true, |e| is_integer_const(cx, e, 0))
-        && range.end.map_or(true, |e| {
-            if range.limits == RangeLimits::HalfOpen
-                && let ExprKind::Path(QPath::Resolved(None, container_path)) = container.kind
-                && let ExprKind::MethodCall(name, self_arg, [], _) = e.kind
-                && name.ident.name == sym::len
-                && let ExprKind::Path(QPath::Resolved(None, path)) = self_arg.kind
+/// Checks whether the given `Expr` is a range equivalent to a `RangeFull`.
+/// For the lower bound, this means that:
+/// - either there is none
+/// - or it is the smallest value that can be represented by the range's integer type
+/// For the upper bound, this means that:
+/// - either there is none
+/// - or it is the largest value that can be represented by the range's integer type and is
+///   inclusive
+/// - or it is a call to some container's `len` method and is exclusive, and the range is passed to
+///   a method call on that same container (e.g. `v.drain(..v.len())`)
+/// If the given `Expr` is not some kind of range, the function returns `false`.
+pub fn is_range_full(cx: &LateContext<'_>, expr: &Expr<'_>, container_path: Option<&Path<'_>>) -> bool {
+    let ty = cx.typeck_results().expr_ty(expr);
+    if let Some(Range { start, end, limits }) = Range::hir(expr) {
+        let start_is_none_or_min = start.map_or(true, |start| {
+            if let rustc_ty::Adt(_, subst) = ty.kind()
+                && let bnd_ty = subst.type_at(0)
+                && let Some(min_val) = bnd_ty.numeric_min_val(cx.tcx)
+                && let const_val = cx.tcx.valtree_to_const_val((bnd_ty, min_val.to_valtree()))
+                && let min_const_kind = ConstantKind::from_value(const_val, bnd_ty)
+                && let Some(min_const) = miri_to_const(cx.tcx, min_const_kind)
+                && let Some((start_const, _)) = constant(cx, cx.typeck_results(), start)
             {
-                container_path.res == path.res
+                start_const == min_const
             } else {
                 false
             }
-        })
+        });
+        let end_is_none_or_max = end.map_or(true, |end| {
+            match limits {
+                RangeLimits::Closed => {
+                    if let rustc_ty::Adt(_, subst) = ty.kind()
+                        && let bnd_ty = subst.type_at(0)
+                        && let Some(max_val) = bnd_ty.numeric_max_val(cx.tcx)
+                        && let const_val = cx.tcx.valtree_to_const_val((bnd_ty, max_val.to_valtree()))
+                        && let max_const_kind = ConstantKind::from_value(const_val, bnd_ty)
+                        && let Some(max_const) = miri_to_const(cx.tcx, max_const_kind)
+                        && let Some((end_const, _)) = constant(cx, cx.typeck_results(), end)
+                    {
+                        end_const == max_const
+                    } else {
+                        false
+                    }
+                },
+                RangeLimits::HalfOpen => {
+                    if let Some(container_path) = container_path
+                        && let ExprKind::MethodCall(name, self_arg, [], _) = end.kind
+                        && name.ident.name == sym::len
+                        && let ExprKind::Path(QPath::Resolved(None, path)) = self_arg.kind
+                    {
+                        container_path.res == path.res
+                    } else {
+                        false
+                    }
+                },
+            }
+        });
+        return start_is_none_or_min && end_is_none_or_max;
+    }
+    false
 }
 
 /// Checks whether the given expression is a constant integer of the given value.
-- 
cgit 1.4.1-3-g733a5


From 022f76d432f3e3289af68845d9169c1866c14d70 Mon Sep 17 00:00:00 2001
From: Micha White <botahamec@outlook.com>
Date: Sat, 2 Jul 2022 18:42:08 -0400
Subject: Added the new lint with some docs and tests

---
 CHANGELOG.md                                |  1 +
 clippy_lints/src/declared_lints.rs          |  1 +
 clippy_lints/src/lib.rs                     |  2 +
 clippy_lints/src/unnecessary_box_returns.rs | 88 +++++++++++++++++++++++++++++
 tests/ui/unnecessary_box_returns.rs         | 31 ++++++++++
 tests/ui/unnecessary_box_returns.stderr     | 19 +++++++
 6 files changed, 142 insertions(+)
 create mode 100644 clippy_lints/src/unnecessary_box_returns.rs
 create mode 100644 tests/ui/unnecessary_box_returns.rs
 create mode 100644 tests/ui/unnecessary_box_returns.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 1323f973ccf..1a37ff2e171 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4974,6 +4974,7 @@ Released 2018-09-13
 [`unit_hash`]: https://rust-lang.github.io/rust-clippy/master/index.html#unit_hash
 [`unit_return_expecting_ord`]: https://rust-lang.github.io/rust-clippy/master/index.html#unit_return_expecting_ord
 [`unknown_clippy_lints`]: https://rust-lang.github.io/rust-clippy/master/index.html#unknown_clippy_lints
+[`unnecessary_box_returns`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_box_returns
 [`unnecessary_cast`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_cast
 [`unnecessary_filter_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_filter_map
 [`unnecessary_find_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_find_map
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 8ca91301472..89076e5d294 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -616,6 +616,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::unit_types::UNIT_CMP_INFO,
     crate::unnamed_address::FN_ADDRESS_COMPARISONS_INFO,
     crate::unnamed_address::VTABLE_ADDRESS_COMPARISONS_INFO,
+    crate::unnecessary_box_returns::UNNECESSARY_BOX_RETURNS_INFO,
     crate::unnecessary_owned_empty_strings::UNNECESSARY_OWNED_EMPTY_STRINGS_INFO,
     crate::unnecessary_self_imports::UNNECESSARY_SELF_IMPORTS_INFO,
     crate::unnecessary_struct_initialization::UNNECESSARY_STRUCT_INITIALIZATION_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index c9210bf73f8..c172ee263c6 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -300,6 +300,7 @@ mod uninit_vec;
 mod unit_return_expecting_ord;
 mod unit_types;
 mod unnamed_address;
+mod unnecessary_box_returns;
 mod unnecessary_owned_empty_strings;
 mod unnecessary_self_imports;
 mod unnecessary_struct_initialization;
@@ -940,6 +941,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(allow_attributes::AllowAttribute));
     store.register_late_pass(move |_| Box::new(manual_main_separator_str::ManualMainSeparatorStr::new(msrv())));
     store.register_late_pass(|_| Box::new(unnecessary_struct_initialization::UnnecessaryStruct));
+    store.register_late_pass(|_| Box::new(unnecessary_box_returns::UnnecessaryBoxReturns));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/unnecessary_box_returns.rs b/clippy_lints/src/unnecessary_box_returns.rs
new file mode 100644
index 00000000000..533ee026500
--- /dev/null
+++ b/clippy_lints/src/unnecessary_box_returns.rs
@@ -0,0 +1,88 @@
+use clippy_utils::diagnostics::span_lint_and_then;
+use rustc_errors::Applicability;
+use rustc_hir::{def_id::LocalDefId, intravisit::FnKind, Body, FnDecl, FnRetTy};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::Span;
+
+declare_clippy_lint! {
+    /// ### What it does
+    ///
+    /// Checks for a return type containing a `Box<T>` where `T` implements `Sized`
+    ///
+    /// ### Why is this bad?
+    ///
+    /// It's better to just return `T` in these cases. The caller may not need
+    /// the value to be boxed, and it's expensive to free the memory once the
+    /// `Box<T>` been dropped.
+    ///
+    /// ### Example
+    /// ```rust
+    /// fn foo() -> Box<String> {
+    ///     Box::new(String::from("Hello, world!"))
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// fn foo() -> String {
+    ///     String::from("Hello, world!")
+    /// }
+    /// ```
+    #[clippy::version = "1.70.0"]
+    pub UNNECESSARY_BOX_RETURNS,
+    pedantic,
+    "Needlessly returning a Box"
+}
+declare_lint_pass!(UnnecessaryBoxReturns => [UNNECESSARY_BOX_RETURNS]);
+
+impl LateLintPass<'_> for UnnecessaryBoxReturns {
+    fn check_fn(
+        &mut self,
+        cx: &LateContext<'_>,
+        fn_kind: FnKind<'_>,
+        decl: &FnDecl<'_>,
+        _: &Body<'_>,
+        _: Span,
+        def_id: LocalDefId,
+    ) {
+        // it's unclear what part of a closure you would span, so for now it's ignored
+        // if this is changed, please also make sure not to call `hir_ty_to_ty` below
+        if matches!(fn_kind, FnKind::Closure) {
+            return;
+        }
+
+        let FnRetTy::Return(return_ty_hir) = &decl.output else { return };
+
+        let return_ty = cx
+            .tcx
+            .erase_late_bound_regions(cx.tcx.fn_sig(def_id).skip_binder())
+            .output();
+
+        if !return_ty.is_box() {
+            return;
+        }
+
+        let boxed_ty = return_ty.boxed_ty();
+
+        // it's sometimes useful to return Box<T> if T is unsized, so don't lint those
+        if boxed_ty.is_sized(cx.tcx, cx.param_env) {
+            span_lint_and_then(
+                cx,
+                UNNECESSARY_BOX_RETURNS,
+                return_ty_hir.span,
+                format!("boxed return of the sized type `{boxed_ty}`").as_str(),
+                |diagnostic| {
+                    diagnostic.span_suggestion(
+                        return_ty_hir.span,
+                        "try",
+                        boxed_ty.to_string(),
+                        // the return value and function callers also needs to
+                        // be changed, so this can't be MachineApplicable
+                        Applicability::Unspecified,
+                    );
+                    diagnostic.help("changing this also requires a change to the return expressions in this function");
+                },
+            );
+        }
+    }
+}
diff --git a/tests/ui/unnecessary_box_returns.rs b/tests/ui/unnecessary_box_returns.rs
new file mode 100644
index 00000000000..49e24878c82
--- /dev/null
+++ b/tests/ui/unnecessary_box_returns.rs
@@ -0,0 +1,31 @@
+#![warn(clippy::unnecessary_box_returns)]
+
+struct Foo {}
+
+// lint
+fn boxed_usize() -> Box<usize> {
+    Box::new(5)
+}
+
+// lint
+fn boxed_foo() -> Box<Foo> {
+    Box::new(Foo {})
+}
+
+// don't lint: str is unsized
+fn boxed_str() -> Box<str> {
+    "Hello, world!".to_string().into_boxed_str()
+}
+
+// don't lint: this has an unspecified return type
+fn default() {}
+
+// don't lint: this doesn't return a Box
+fn string() -> String {
+    String::from("Hello, world")
+}
+
+fn main() {
+    // don't lint: this is a closure
+    let a = || -> Box<usize> { Box::new(5) };
+}
diff --git a/tests/ui/unnecessary_box_returns.stderr b/tests/ui/unnecessary_box_returns.stderr
new file mode 100644
index 00000000000..8acaf33de04
--- /dev/null
+++ b/tests/ui/unnecessary_box_returns.stderr
@@ -0,0 +1,19 @@
+error: boxed return of the sized type `usize`
+  --> $DIR/unnecessary_box_returns.rs:6:21
+   |
+LL | fn boxed_usize() -> Box<usize> {
+   |                     ^^^^^^^^^^ help: try: `usize`
+   |
+   = help: changing this also requires a change to the return expressions in this function
+   = note: `-D clippy::unnecessary-box-returns` implied by `-D warnings`
+
+error: boxed return of the sized type `Foo`
+  --> $DIR/unnecessary_box_returns.rs:11:19
+   |
+LL | fn boxed_foo() -> Box<Foo> {
+   |                   ^^^^^^^^ help: try: `Foo`
+   |
+   = help: changing this also requires a change to the return expressions in this function
+
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 1b55c81db565d8e94146b9e2a7ed54f242e349ec Mon Sep 17 00:00:00 2001
From: Micha White <botahamec@outlook.com>
Date: Sun, 26 Feb 2023 12:11:47 -0500
Subject: Lint on trait declarations, not implementations

---
 clippy_lints/src/unnecessary_box_returns.rs | 96 ++++++++++++++++-------------
 tests/ui/unnecessary_box_returns.rs         | 19 ++++++
 tests/ui/unnecessary_box_returns.stderr     | 24 ++++++--
 3 files changed, 91 insertions(+), 48 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unnecessary_box_returns.rs b/clippy_lints/src/unnecessary_box_returns.rs
index 533ee026500..77c1506e542 100644
--- a/clippy_lints/src/unnecessary_box_returns.rs
+++ b/clippy_lints/src/unnecessary_box_returns.rs
@@ -1,9 +1,8 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use rustc_errors::Applicability;
-use rustc_hir::{def_id::LocalDefId, intravisit::FnKind, Body, FnDecl, FnRetTy};
+use rustc_hir::{def_id::LocalDefId, FnDecl, FnRetTy, ImplItemKind, Item, ItemKind, Node, TraitItem, TraitItemKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::Span;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -35,54 +34,63 @@ declare_clippy_lint! {
 }
 declare_lint_pass!(UnnecessaryBoxReturns => [UNNECESSARY_BOX_RETURNS]);
 
-impl LateLintPass<'_> for UnnecessaryBoxReturns {
-    fn check_fn(
-        &mut self,
-        cx: &LateContext<'_>,
-        fn_kind: FnKind<'_>,
-        decl: &FnDecl<'_>,
-        _: &Body<'_>,
-        _: Span,
-        def_id: LocalDefId,
-    ) {
-        // it's unclear what part of a closure you would span, so for now it's ignored
-        // if this is changed, please also make sure not to call `hir_ty_to_ty` below
-        if matches!(fn_kind, FnKind::Closure) {
-            return;
-        }
+fn check_fn_decl(cx: &LateContext<'_>, decl: &FnDecl<'_>, def_id: LocalDefId) {
+    let FnRetTy::Return(return_ty_hir) = &decl.output else { return };
 
-        let FnRetTy::Return(return_ty_hir) = &decl.output else { return };
+    let return_ty = cx
+        .tcx
+        .erase_late_bound_regions(cx.tcx.fn_sig(def_id).skip_binder())
+        .output();
 
-        let return_ty = cx
-            .tcx
-            .erase_late_bound_regions(cx.tcx.fn_sig(def_id).skip_binder())
-            .output();
+    if !return_ty.is_box() {
+        return;
+    }
 
-        if !return_ty.is_box() {
+    let boxed_ty = return_ty.boxed_ty();
+
+    // it's sometimes useful to return Box<T> if T is unsized, so don't lint those
+    if boxed_ty.is_sized(cx.tcx, cx.param_env) {
+        span_lint_and_then(
+            cx,
+            UNNECESSARY_BOX_RETURNS,
+            return_ty_hir.span,
+            format!("boxed return of the sized type `{boxed_ty}`").as_str(),
+            |diagnostic| {
+                diagnostic.span_suggestion(
+                    return_ty_hir.span,
+                    "try",
+                    boxed_ty.to_string(),
+                    // the return value and function callers also needs to
+                    // be changed, so this can't be MachineApplicable
+                    Applicability::Unspecified,
+                );
+                diagnostic.help("changing this also requires a change to the return expressions in this function");
+            },
+        );
+    }
+}
+
+impl LateLintPass<'_> for UnnecessaryBoxReturns {
+    fn check_trait_item(&mut self, cx: &LateContext<'_>, item: &TraitItem<'_>) {
+        let TraitItemKind::Fn(signature, _) = &item.kind else { return };
+        check_fn_decl(cx, signature.decl, item.owner_id.def_id);
+    }
+
+    fn check_impl_item(&mut self, cx: &LateContext<'_>, item: &rustc_hir::ImplItem<'_>) {
+        // Ignore implementations of traits, because the lint should be on the
+        // trait, not on the implmentation of it.
+        let Node::Item(parent) = cx.tcx.hir().get_parent(item.hir_id()) else { return };
+        let ItemKind::Impl(parent) = parent.kind else { return };
+        if parent.of_trait.is_some() {
             return;
         }
 
-        let boxed_ty = return_ty.boxed_ty();
+        let ImplItemKind::Fn(signature, ..) = &item.kind else { return };
+        check_fn_decl(cx, signature.decl, item.owner_id.def_id);
+    }
 
-        // it's sometimes useful to return Box<T> if T is unsized, so don't lint those
-        if boxed_ty.is_sized(cx.tcx, cx.param_env) {
-            span_lint_and_then(
-                cx,
-                UNNECESSARY_BOX_RETURNS,
-                return_ty_hir.span,
-                format!("boxed return of the sized type `{boxed_ty}`").as_str(),
-                |diagnostic| {
-                    diagnostic.span_suggestion(
-                        return_ty_hir.span,
-                        "try",
-                        boxed_ty.to_string(),
-                        // the return value and function callers also needs to
-                        // be changed, so this can't be MachineApplicable
-                        Applicability::Unspecified,
-                    );
-                    diagnostic.help("changing this also requires a change to the return expressions in this function");
-                },
-            );
-        }
+    fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
+        let ItemKind::Fn(signature, ..) = &item.kind else { return };
+        check_fn_decl(cx, signature.decl, item.owner_id.def_id);
     }
 }
diff --git a/tests/ui/unnecessary_box_returns.rs b/tests/ui/unnecessary_box_returns.rs
index 49e24878c82..399266f90b0 100644
--- a/tests/ui/unnecessary_box_returns.rs
+++ b/tests/ui/unnecessary_box_returns.rs
@@ -1,7 +1,26 @@
 #![warn(clippy::unnecessary_box_returns)]
 
+trait Bar {
+    // lint
+    fn baz(&self) -> Box<usize>;
+}
+
 struct Foo {}
 
+impl Bar for Foo {
+    // don't lint: this is a problem with the trait, not the implementation
+    fn baz(&self) -> Box<usize> {
+        Box::new(42)
+    }
+}
+
+impl Foo {
+    fn baz(&self) -> Box<usize> {
+        // lint
+        Box::new(13)
+    }
+}
+
 // lint
 fn boxed_usize() -> Box<usize> {
     Box::new(5)
diff --git a/tests/ui/unnecessary_box_returns.stderr b/tests/ui/unnecessary_box_returns.stderr
index 8acaf33de04..a431e37a201 100644
--- a/tests/ui/unnecessary_box_returns.stderr
+++ b/tests/ui/unnecessary_box_returns.stderr
@@ -1,19 +1,35 @@
 error: boxed return of the sized type `usize`
-  --> $DIR/unnecessary_box_returns.rs:6:21
+  --> $DIR/unnecessary_box_returns.rs:5:22
+   |
+LL |     fn baz(&self) -> Box<usize>;
+   |                      ^^^^^^^^^^ help: try: `usize`
+   |
+   = help: changing this also requires a change to the return expressions in this function
+   = note: `-D clippy::unnecessary-box-returns` implied by `-D warnings`
+
+error: boxed return of the sized type `usize`
+  --> $DIR/unnecessary_box_returns.rs:18:22
+   |
+LL |     fn baz(&self) -> Box<usize> {
+   |                      ^^^^^^^^^^ help: try: `usize`
+   |
+   = help: changing this also requires a change to the return expressions in this function
+
+error: boxed return of the sized type `usize`
+  --> $DIR/unnecessary_box_returns.rs:25:21
    |
 LL | fn boxed_usize() -> Box<usize> {
    |                     ^^^^^^^^^^ help: try: `usize`
    |
    = help: changing this also requires a change to the return expressions in this function
-   = note: `-D clippy::unnecessary-box-returns` implied by `-D warnings`
 
 error: boxed return of the sized type `Foo`
-  --> $DIR/unnecessary_box_returns.rs:11:19
+  --> $DIR/unnecessary_box_returns.rs:30:19
    |
 LL | fn boxed_foo() -> Box<Foo> {
    |                   ^^^^^^^^ help: try: `Foo`
    |
    = help: changing this also requires a change to the return expressions in this function
 
-error: aborting due to 2 previous errors
+error: aborting due to 4 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From a143fb7a11695c45545e6a207f677bd1112032d7 Mon Sep 17 00:00:00 2001
From: Micha White <botahamec@outlook.com>
Date: Sun, 26 Feb 2023 13:17:34 -0500
Subject: Avoid breaking exported API

---
 book/src/lint_configuration.md              |  1 +
 clippy_lints/src/lib.rs                     |  6 ++-
 clippy_lints/src/unnecessary_box_returns.rs | 84 +++++++++++++++++------------
 clippy_lints/src/utils/conf.rs              |  2 +-
 tests/ui/unnecessary_box_returns.rs         |  9 +++-
 tests/ui/unnecessary_box_returns.stderr     |  6 +--
 6 files changed, 68 insertions(+), 40 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/book/src/lint_configuration.md b/book/src/lint_configuration.md
index 9ed6627b741..dbd1a404150 100644
--- a/book/src/lint_configuration.md
+++ b/book/src/lint_configuration.md
@@ -130,6 +130,7 @@ Suppress lints whenever the suggested change would cause breakage for other crat
 * [option_option](https://rust-lang.github.io/rust-clippy/master/index.html#option_option)
 * [linkedlist](https://rust-lang.github.io/rust-clippy/master/index.html#linkedlist)
 * [rc_mutex](https://rust-lang.github.io/rust-clippy/master/index.html#rc_mutex)
+* [unnecessary_box_returns](https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_box_returns)
 
 
 ### msrv
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index c172ee263c6..117732c6efe 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -941,7 +941,11 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(allow_attributes::AllowAttribute));
     store.register_late_pass(move |_| Box::new(manual_main_separator_str::ManualMainSeparatorStr::new(msrv())));
     store.register_late_pass(|_| Box::new(unnecessary_struct_initialization::UnnecessaryStruct));
-    store.register_late_pass(|_| Box::new(unnecessary_box_returns::UnnecessaryBoxReturns));
+    store.register_late_pass(move |_| {
+        Box::new(unnecessary_box_returns::UnnecessaryBoxReturns::new(
+            avoid_breaking_exported_api,
+        ))
+    });
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/unnecessary_box_returns.rs b/clippy_lints/src/unnecessary_box_returns.rs
index 77c1506e542..10aee89606d 100644
--- a/clippy_lints/src/unnecessary_box_returns.rs
+++ b/clippy_lints/src/unnecessary_box_returns.rs
@@ -2,7 +2,7 @@ use clippy_utils::diagnostics::span_lint_and_then;
 use rustc_errors::Applicability;
 use rustc_hir::{def_id::LocalDefId, FnDecl, FnRetTy, ImplItemKind, Item, ItemKind, Node, TraitItem, TraitItemKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -32,48 +32,66 @@ declare_clippy_lint! {
     pedantic,
     "Needlessly returning a Box"
 }
-declare_lint_pass!(UnnecessaryBoxReturns => [UNNECESSARY_BOX_RETURNS]);
 
-fn check_fn_decl(cx: &LateContext<'_>, decl: &FnDecl<'_>, def_id: LocalDefId) {
-    let FnRetTy::Return(return_ty_hir) = &decl.output else { return };
+pub struct UnnecessaryBoxReturns {
+    avoid_breaking_exported_api: bool,
+}
 
-    let return_ty = cx
-        .tcx
-        .erase_late_bound_regions(cx.tcx.fn_sig(def_id).skip_binder())
-        .output();
+impl_lint_pass!(UnnecessaryBoxReturns => [UNNECESSARY_BOX_RETURNS]);
 
-    if !return_ty.is_box() {
-        return;
+impl UnnecessaryBoxReturns {
+    pub fn new(avoid_breaking_exported_api: bool) -> Self {
+        Self {
+            avoid_breaking_exported_api,
+        }
     }
 
-    let boxed_ty = return_ty.boxed_ty();
+    fn check_fn_decl(&mut self, cx: &LateContext<'_>, decl: &FnDecl<'_>, def_id: LocalDefId) {
+        // we don't want to tell someone to break an exported function if they ask us not to
+        if self.avoid_breaking_exported_api && cx.effective_visibilities.is_exported(def_id) {
+            return;
+        }
+
+        let FnRetTy::Return(return_ty_hir) = &decl.output else { return };
+
+        let return_ty = cx
+            .tcx
+            .erase_late_bound_regions(cx.tcx.fn_sig(def_id).skip_binder())
+            .output();
 
-    // it's sometimes useful to return Box<T> if T is unsized, so don't lint those
-    if boxed_ty.is_sized(cx.tcx, cx.param_env) {
-        span_lint_and_then(
-            cx,
-            UNNECESSARY_BOX_RETURNS,
-            return_ty_hir.span,
-            format!("boxed return of the sized type `{boxed_ty}`").as_str(),
-            |diagnostic| {
-                diagnostic.span_suggestion(
-                    return_ty_hir.span,
-                    "try",
-                    boxed_ty.to_string(),
-                    // the return value and function callers also needs to
-                    // be changed, so this can't be MachineApplicable
-                    Applicability::Unspecified,
-                );
-                diagnostic.help("changing this also requires a change to the return expressions in this function");
-            },
-        );
+        if !return_ty.is_box() {
+            return;
+        }
+
+        let boxed_ty = return_ty.boxed_ty();
+
+        // it's sometimes useful to return Box<T> if T is unsized, so don't lint those
+        if boxed_ty.is_sized(cx.tcx, cx.param_env) {
+            span_lint_and_then(
+                cx,
+                UNNECESSARY_BOX_RETURNS,
+                return_ty_hir.span,
+                format!("boxed return of the sized type `{boxed_ty}`").as_str(),
+                |diagnostic| {
+                    diagnostic.span_suggestion(
+                        return_ty_hir.span,
+                        "try",
+                        boxed_ty.to_string(),
+                        // the return value and function callers also needs to
+                        // be changed, so this can't be MachineApplicable
+                        Applicability::Unspecified,
+                    );
+                    diagnostic.help("changing this also requires a change to the return expressions in this function");
+                },
+            );
+        }
     }
 }
 
 impl LateLintPass<'_> for UnnecessaryBoxReturns {
     fn check_trait_item(&mut self, cx: &LateContext<'_>, item: &TraitItem<'_>) {
         let TraitItemKind::Fn(signature, _) = &item.kind else { return };
-        check_fn_decl(cx, signature.decl, item.owner_id.def_id);
+        self.check_fn_decl(cx, signature.decl, item.owner_id.def_id);
     }
 
     fn check_impl_item(&mut self, cx: &LateContext<'_>, item: &rustc_hir::ImplItem<'_>) {
@@ -86,11 +104,11 @@ impl LateLintPass<'_> for UnnecessaryBoxReturns {
         }
 
         let ImplItemKind::Fn(signature, ..) = &item.kind else { return };
-        check_fn_decl(cx, signature.decl, item.owner_id.def_id);
+        self.check_fn_decl(cx, signature.decl, item.owner_id.def_id);
     }
 
     fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
         let ItemKind::Fn(signature, ..) = &item.kind else { return };
-        check_fn_decl(cx, signature.decl, item.owner_id.def_id);
+        self.check_fn_decl(cx, signature.decl, item.owner_id.def_id);
     }
 }
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 8ba252425a3..5384ae01f92 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -249,7 +249,7 @@ define_Conf! {
     /// arithmetic-side-effects-allowed-unary = ["SomeType", "AnotherType"]
     /// ```
     (arithmetic_side_effects_allowed_unary: rustc_data_structures::fx::FxHashSet<String> = <_>::default()),
-    /// Lint: ENUM_VARIANT_NAMES, LARGE_TYPES_PASSED_BY_VALUE, TRIVIALLY_COPY_PASS_BY_REF, UNNECESSARY_WRAPS, UNUSED_SELF, UPPER_CASE_ACRONYMS, WRONG_SELF_CONVENTION, BOX_COLLECTION, REDUNDANT_ALLOCATION, RC_BUFFER, VEC_BOX, OPTION_OPTION, LINKEDLIST, RC_MUTEX.
+    /// Lint: ENUM_VARIANT_NAMES, LARGE_TYPES_PASSED_BY_VALUE, TRIVIALLY_COPY_PASS_BY_REF, UNNECESSARY_WRAPS, UNUSED_SELF, UPPER_CASE_ACRONYMS, WRONG_SELF_CONVENTION, BOX_COLLECTION, REDUNDANT_ALLOCATION, RC_BUFFER, VEC_BOX, OPTION_OPTION, LINKEDLIST, RC_MUTEX, UNNECESSARY_BOX_RETURNS.
     ///
     /// Suppress lints whenever the suggested change would cause breakage for other crates.
     (avoid_breaking_exported_api: bool = true),
diff --git a/tests/ui/unnecessary_box_returns.rs b/tests/ui/unnecessary_box_returns.rs
index 399266f90b0..f2f6aae380e 100644
--- a/tests/ui/unnecessary_box_returns.rs
+++ b/tests/ui/unnecessary_box_returns.rs
@@ -5,7 +5,7 @@ trait Bar {
     fn baz(&self) -> Box<usize>;
 }
 
-struct Foo {}
+pub struct Foo {}
 
 impl Bar for Foo {
     // don't lint: this is a problem with the trait, not the implementation
@@ -27,7 +27,12 @@ fn boxed_usize() -> Box<usize> {
 }
 
 // lint
-fn boxed_foo() -> Box<Foo> {
+fn _boxed_foo() -> Box<Foo> {
+    Box::new(Foo {})
+}
+
+// don't lint: this is exported
+pub fn boxed_foo() -> Box<Foo> {
     Box::new(Foo {})
 }
 
diff --git a/tests/ui/unnecessary_box_returns.stderr b/tests/ui/unnecessary_box_returns.stderr
index a431e37a201..0870af5f28f 100644
--- a/tests/ui/unnecessary_box_returns.stderr
+++ b/tests/ui/unnecessary_box_returns.stderr
@@ -24,10 +24,10 @@ LL | fn boxed_usize() -> Box<usize> {
    = help: changing this also requires a change to the return expressions in this function
 
 error: boxed return of the sized type `Foo`
-  --> $DIR/unnecessary_box_returns.rs:30:19
+  --> $DIR/unnecessary_box_returns.rs:30:20
    |
-LL | fn boxed_foo() -> Box<Foo> {
-   |                   ^^^^^^^^ help: try: `Foo`
+LL | fn _boxed_foo() -> Box<Foo> {
+   |                    ^^^^^^^^ help: try: `Foo`
    |
    = help: changing this also requires a change to the return expressions in this function
 
-- 
cgit 1.4.1-3-g733a5


From 76d13bb7fa20ba316c75023c66d74fed8e1881df Mon Sep 17 00:00:00 2001
From: Micha White <botahamec@outlook.com>
Date: Sun, 26 Mar 2023 11:00:10 -0400
Subject: Don't lint functions with "box" in their name

---
 clippy_lints/src/unnecessary_box_returns.rs | 14 ++++++++++----
 tests/ui/unnecessary_box_returns.rs         | 13 +++++++++----
 tests/ui/unnecessary_box_returns.stderr     | 12 ++++++------
 3 files changed, 25 insertions(+), 14 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unnecessary_box_returns.rs b/clippy_lints/src/unnecessary_box_returns.rs
index 10aee89606d..912bcda630b 100644
--- a/clippy_lints/src/unnecessary_box_returns.rs
+++ b/clippy_lints/src/unnecessary_box_returns.rs
@@ -3,6 +3,7 @@ use rustc_errors::Applicability;
 use rustc_hir::{def_id::LocalDefId, FnDecl, FnRetTy, ImplItemKind, Item, ItemKind, Node, TraitItem, TraitItemKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::Symbol;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -46,12 +47,17 @@ impl UnnecessaryBoxReturns {
         }
     }
 
-    fn check_fn_decl(&mut self, cx: &LateContext<'_>, decl: &FnDecl<'_>, def_id: LocalDefId) {
+    fn check_fn_item(&mut self, cx: &LateContext<'_>, decl: &FnDecl<'_>, def_id: LocalDefId, name: Symbol) {
         // we don't want to tell someone to break an exported function if they ask us not to
         if self.avoid_breaking_exported_api && cx.effective_visibilities.is_exported(def_id) {
             return;
         }
 
+        // functions which contain the word "box" are exempt from this lint
+        if name.as_str().contains("box") {
+            return;
+        }
+
         let FnRetTy::Return(return_ty_hir) = &decl.output else { return };
 
         let return_ty = cx
@@ -91,7 +97,7 @@ impl UnnecessaryBoxReturns {
 impl LateLintPass<'_> for UnnecessaryBoxReturns {
     fn check_trait_item(&mut self, cx: &LateContext<'_>, item: &TraitItem<'_>) {
         let TraitItemKind::Fn(signature, _) = &item.kind else { return };
-        self.check_fn_decl(cx, signature.decl, item.owner_id.def_id);
+        self.check_fn_item(cx, signature.decl, item.owner_id.def_id, item.ident.name);
     }
 
     fn check_impl_item(&mut self, cx: &LateContext<'_>, item: &rustc_hir::ImplItem<'_>) {
@@ -104,11 +110,11 @@ impl LateLintPass<'_> for UnnecessaryBoxReturns {
         }
 
         let ImplItemKind::Fn(signature, ..) = &item.kind else { return };
-        self.check_fn_decl(cx, signature.decl, item.owner_id.def_id);
+        self.check_fn_item(cx, signature.decl, item.owner_id.def_id, item.ident.name);
     }
 
     fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
         let ItemKind::Fn(signature, ..) = &item.kind else { return };
-        self.check_fn_decl(cx, signature.decl, item.owner_id.def_id);
+        self.check_fn_item(cx, signature.decl, item.owner_id.def_id, item.ident.name);
     }
 }
diff --git a/tests/ui/unnecessary_box_returns.rs b/tests/ui/unnecessary_box_returns.rs
index f2f6aae380e..fe60d929759 100644
--- a/tests/ui/unnecessary_box_returns.rs
+++ b/tests/ui/unnecessary_box_returns.rs
@@ -22,25 +22,30 @@ impl Foo {
 }
 
 // lint
-fn boxed_usize() -> Box<usize> {
+fn bxed_usize() -> Box<usize> {
     Box::new(5)
 }
 
 // lint
-fn _boxed_foo() -> Box<Foo> {
+fn _bxed_foo() -> Box<Foo> {
     Box::new(Foo {})
 }
 
 // don't lint: this is exported
-pub fn boxed_foo() -> Box<Foo> {
+pub fn bxed_foo() -> Box<Foo> {
     Box::new(Foo {})
 }
 
 // don't lint: str is unsized
-fn boxed_str() -> Box<str> {
+fn bxed_str() -> Box<str> {
     "Hello, world!".to_string().into_boxed_str()
 }
 
+// don't lint: function contains the word, "box"
+fn boxed_usize() -> Box<usize> {
+    Box::new(7)
+}
+
 // don't lint: this has an unspecified return type
 fn default() {}
 
diff --git a/tests/ui/unnecessary_box_returns.stderr b/tests/ui/unnecessary_box_returns.stderr
index 0870af5f28f..b17512c10a1 100644
--- a/tests/ui/unnecessary_box_returns.stderr
+++ b/tests/ui/unnecessary_box_returns.stderr
@@ -16,18 +16,18 @@ LL |     fn baz(&self) -> Box<usize> {
    = help: changing this also requires a change to the return expressions in this function
 
 error: boxed return of the sized type `usize`
-  --> $DIR/unnecessary_box_returns.rs:25:21
+  --> $DIR/unnecessary_box_returns.rs:25:20
    |
-LL | fn boxed_usize() -> Box<usize> {
-   |                     ^^^^^^^^^^ help: try: `usize`
+LL | fn bxed_usize() -> Box<usize> {
+   |                    ^^^^^^^^^^ help: try: `usize`
    |
    = help: changing this also requires a change to the return expressions in this function
 
 error: boxed return of the sized type `Foo`
-  --> $DIR/unnecessary_box_returns.rs:30:20
+  --> $DIR/unnecessary_box_returns.rs:30:19
    |
-LL | fn _boxed_foo() -> Box<Foo> {
-   |                    ^^^^^^^^ help: try: `Foo`
+LL | fn _bxed_foo() -> Box<Foo> {
+   |                   ^^^^^^^^ help: try: `Foo`
    |
    = help: changing this also requires a change to the return expressions in this function
 
-- 
cgit 1.4.1-3-g733a5


From 3259b48568c4fe19b60a47011c9fe424b707533c Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Tue, 28 Mar 2023 12:22:22 +0000
Subject: Migrate `format_args.rs` to `rustc_ast::FormatArgs`

No longer lints empty precisions `{:.}` as the spans aren't available
---
 clippy_lints/Cargo.toml                            |   1 +
 clippy_lints/src/format_args.rs                    | 210 ++++++++++++---------
 clippy_lints/src/utils/format_args_collector.rs    |  79 +++++++-
 clippy_utils/src/macros.rs                         |  73 ++++---
 .../uninlined_format_args.stderr                   |  22 +--
 tests/ui/uninlined_format_args.fixed               |   2 +-
 tests/ui/uninlined_format_args.stderr              |  14 +-
 tests/ui/unused_format_specs.fixed                 |  18 --
 tests/ui/unused_format_specs.rs                    |  18 --
 tests/ui/unused_format_specs.stderr                |  54 ------
 tests/ui/unused_format_specs_unfixable.stderr      |  12 +-
 11 files changed, 264 insertions(+), 239 deletions(-)
 delete mode 100644 tests/ui/unused_format_specs.fixed
 delete mode 100644 tests/ui/unused_format_specs.rs
 delete mode 100644 tests/ui/unused_format_specs.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/Cargo.toml b/clippy_lints/Cargo.toml
index 6701bedfe5e..5c6040f63f5 100644
--- a/clippy_lints/Cargo.toml
+++ b/clippy_lints/Cargo.toml
@@ -9,6 +9,7 @@ keywords = ["clippy", "lint", "plugin"]
 edition = "2021"
 
 [dependencies]
+arrayvec = { version = "0.7", default-features = false }
 cargo_metadata = "0.15.3"
 clippy_utils = { path = "../clippy_utils" }
 declare_clippy_lint = { path = "../declare_clippy_lint" }
diff --git a/clippy_lints/src/format_args.rs b/clippy_lints/src/format_args.rs
index e7caed65bf2..08e45ed7d0e 100644
--- a/clippy_lints/src/format_args.rs
+++ b/clippy_lints/src/format_args.rs
@@ -1,27 +1,31 @@
+use arrayvec::ArrayVec;
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::is_diag_trait_item;
-use clippy_utils::macros::FormatParamKind::{Implicit, Named, NamedInline, Numbered, Starred};
 use clippy_utils::macros::{
-    is_assert_macro, is_format_macro, is_panic, root_macro_call, Count, FormatArg, FormatArgsExpn, FormatParam,
-    FormatParamUsage,
+    find_format_arg_expr, find_format_args, format_arg_removal_span, format_placeholder_format_span, is_assert_macro,
+    is_format_macro, is_panic, root_macro_call, root_macro_call_first_node, FormatParamUsage,
 };
 use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::{implements_trait, is_type_lang_item};
 use if_chain::if_chain;
 use itertools::Itertools;
+use rustc_ast::{
+    FormatArgPosition, FormatArgPositionKind, FormatArgsPiece, FormatArgumentKind, FormatCount, FormatOptions,
+    FormatPlaceholder, FormatTrait,
+};
 use rustc_errors::{
     Applicability,
     SuggestionStyle::{CompletelyHidden, ShowCode},
 };
-use rustc_hir::{Expr, ExprKind, HirId, LangItem, QPath};
+use rustc_hir::{Expr, ExprKind, LangItem};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::ty::adjustment::{Adjust, Adjustment};
 use rustc_middle::ty::Ty;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::def_id::DefId;
 use rustc_span::edition::Edition::Edition2021;
-use rustc_span::{sym, ExpnData, ExpnKind, Span, Symbol};
+use rustc_span::{sym, Span, Symbol};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -184,72 +188,79 @@ impl FormatArgs {
 
 impl<'tcx> LateLintPass<'tcx> for FormatArgs {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
-        if let Some(format_args) = FormatArgsExpn::parse(cx, expr)
-            && let expr_expn_data = expr.span.ctxt().outer_expn_data()
-            && let outermost_expn_data = outermost_expn_data(expr_expn_data)
-            && let Some(macro_def_id) = outermost_expn_data.macro_def_id
-            && is_format_macro(cx, macro_def_id)
-            && let ExpnKind::Macro(_, name) = outermost_expn_data.kind
-        {
-            for arg in &format_args.args {
-                check_unused_format_specifier(cx, arg);
-                if !arg.format.is_default() {
-                    continue;
-                }
-                if is_aliased(&format_args, arg.param.value.hir_id) {
-                    continue;
+        let Some(macro_call) = root_macro_call_first_node(cx, expr) else { return };
+        if !is_format_macro(cx, macro_call.def_id) {
+            return;
+        }
+        let name = cx.tcx.item_name(macro_call.def_id);
+
+        find_format_args(cx, expr, macro_call.expn, |format_args| {
+            for piece in &format_args.template {
+                if let FormatArgsPiece::Placeholder(placeholder) = piece
+                    && let Ok(index) = placeholder.argument.index
+                    && let Some(arg) = format_args.arguments.all_args().get(index)
+                {
+                    let arg_expr = find_format_arg_expr(expr, arg);
+
+                    check_unused_format_specifier(cx, placeholder, arg_expr);
+
+                    if placeholder.format_trait != FormatTrait::Display
+                        || placeholder.format_options != FormatOptions::default()
+                        || is_aliased(format_args, index)
+                    {
+                        continue;
+                    }
+
+                    if let Ok(arg_hir_expr) = arg_expr {
+                        check_format_in_format_args(cx, macro_call.span, name, arg_hir_expr);
+                        check_to_string_in_format_args(cx, name, arg_hir_expr);
+                    }
                 }
-                check_format_in_format_args(cx, outermost_expn_data.call_site, name, arg.param.value);
-                check_to_string_in_format_args(cx, name, arg.param.value);
             }
+
             if self.msrv.meets(msrvs::FORMAT_ARGS_CAPTURE) {
-                check_uninlined_args(cx, &format_args, outermost_expn_data.call_site, macro_def_id, self.ignore_mixed);
+                check_uninlined_args(cx, format_args, macro_call.span, macro_call.def_id, self.ignore_mixed);
             }
-        }
+        });
     }
 
     extract_msrv_attr!(LateContext);
 }
 
-fn check_unused_format_specifier(cx: &LateContext<'_>, arg: &FormatArg<'_>) {
-    let param_ty = cx.typeck_results().expr_ty(arg.param.value).peel_refs();
+fn check_unused_format_specifier(
+    cx: &LateContext<'_>,
+    placeholder: &FormatPlaceholder,
+    arg_expr: Result<&Expr<'_>, &rustc_ast::Expr>,
+) {
+    let ty_or_ast_expr = arg_expr.map(|expr| cx.typeck_results().expr_ty(expr).peel_refs());
 
-    if let Count::Implied(Some(mut span)) = arg.format.precision
-        && !span.is_empty()
-    {
-        span_lint_and_then(
-            cx,
-            UNUSED_FORMAT_SPECS,
-            span,
-            "empty precision specifier has no effect",
-            |diag| {
-                if param_ty.is_floating_point() {
-                    diag.note("a precision specifier is not required to format floats");
-                }
+    let is_format_args = match ty_or_ast_expr {
+        Ok(ty) => is_type_lang_item(cx, ty, LangItem::FormatArguments),
+        Err(expr) => matches!(expr.peel_parens_and_refs().kind, rustc_ast::ExprKind::FormatArgs(_)),
+    };
 
-                if arg.format.is_default() {
-                    // If there's no other specifiers remove the `:` too
-                    span = arg.format_span();
-                }
+    let options = &placeholder.format_options;
 
-                diag.span_suggestion_verbose(span, "remove the `.`", "", Applicability::MachineApplicable);
-            },
-        );
-    }
+    let arg_span = match arg_expr {
+        Ok(expr) => expr.span,
+        Err(expr) => expr.span,
+    };
 
-    if is_type_lang_item(cx, param_ty, LangItem::FormatArguments) && !arg.format.is_default_for_trait() {
+    if let Some(placeholder_span) = placeholder.span
+        && is_format_args
+        && *options != FormatOptions::default()
+    {
         span_lint_and_then(
             cx,
             UNUSED_FORMAT_SPECS,
-            arg.span,
+            placeholder_span,
             "format specifiers have no effect on `format_args!()`",
             |diag| {
-                let mut suggest_format = |spec, span| {
+                let mut suggest_format = |spec| {
                     let message = format!("for the {spec} to apply consider using `format!()`");
 
-                    if let Some(mac_call) = root_macro_call(arg.param.value.span)
+                    if let Some(mac_call) = root_macro_call(arg_span)
                         && cx.tcx.is_diagnostic_item(sym::format_args_macro, mac_call.def_id)
-                        && arg.span.eq_ctxt(mac_call.span)
                     {
                         diag.span_suggestion(
                             cx.sess().source_map().span_until_char(mac_call.span, '!'),
@@ -257,25 +268,27 @@ fn check_unused_format_specifier(cx: &LateContext<'_>, arg: &FormatArg<'_>) {
                             "format",
                             Applicability::MaybeIncorrect,
                         );
-                    } else if let Some(span) = span {
-                        diag.span_help(span, message);
+                    } else {
+                        diag.help(message);
                     }
                 };
 
-                if !arg.format.width.is_implied() {
-                    suggest_format("width", arg.format.width.span());
+                if options.width.is_some() {
+                    suggest_format("width");
                 }
 
-                if !arg.format.precision.is_implied() {
-                    suggest_format("precision", arg.format.precision.span());
+                if options.precision.is_some() {
+                    suggest_format("precision");
                 }
 
-                diag.span_suggestion_verbose(
-                    arg.format_span(),
-                    "if the current behavior is intentional, remove the format specifiers",
-                    "",
-                    Applicability::MaybeIncorrect,
-                );
+                if let Some(format_span) = format_placeholder_format_span(placeholder) {
+                    diag.span_suggestion_verbose(
+                        format_span,
+                        "if the current behavior is intentional, remove the format specifiers",
+                        "",
+                        Applicability::MaybeIncorrect,
+                    );
+                }
             },
         );
     }
@@ -283,12 +296,12 @@ fn check_unused_format_specifier(cx: &LateContext<'_>, arg: &FormatArg<'_>) {
 
 fn check_uninlined_args(
     cx: &LateContext<'_>,
-    args: &FormatArgsExpn<'_>,
+    args: &rustc_ast::FormatArgs,
     call_site: Span,
     def_id: DefId,
     ignore_mixed: bool,
 ) {
-    if args.format_string.span.from_expansion() {
+    if args.span.from_expansion() {
         return;
     }
     if call_site.edition() < Edition2021 && (is_panic(cx, def_id) || is_assert_macro(cx, def_id)) {
@@ -303,7 +316,13 @@ fn check_uninlined_args(
     // we cannot remove any other arguments in the format string,
     // because the index numbers might be wrong after inlining.
     // Example of an un-inlinable format:  print!("{}{1}", foo, 2)
-    if !args.params().all(|p| check_one_arg(args, &p, &mut fixes, ignore_mixed)) || fixes.is_empty() {
+    for (pos, usage) in format_arg_positions(args) {
+        if !check_one_arg(args, pos, usage, &mut fixes, ignore_mixed) {
+            return;
+        }
+    }
+
+    if fixes.is_empty() {
         return;
     }
 
@@ -332,38 +351,36 @@ fn check_uninlined_args(
 }
 
 fn check_one_arg(
-    args: &FormatArgsExpn<'_>,
-    param: &FormatParam<'_>,
+    args: &rustc_ast::FormatArgs,
+    pos: &FormatArgPosition,
+    usage: FormatParamUsage,
     fixes: &mut Vec<(Span, String)>,
     ignore_mixed: bool,
 ) -> bool {
-    if matches!(param.kind, Implicit | Starred | Named(_) | Numbered)
-        && let ExprKind::Path(QPath::Resolved(None, path)) = param.value.kind
-        && let [segment] = path.segments
+    let index = pos.index.unwrap();
+    let arg = &args.arguments.all_args()[index];
+
+    if !matches!(arg.kind, FormatArgumentKind::Captured(_))
+        && let rustc_ast::ExprKind::Path(None, path) = &arg.expr.kind
+        && let [segment] = path.segments.as_slice()
         && segment.args.is_none()
-        && let Some(arg_span) = args.value_with_prev_comma_span(param.value.hir_id)
+        && let Some(arg_span) = format_arg_removal_span(args, index)
+        && let Some(pos_span) = pos.span
     {
-        let replacement = match param.usage {
+        let replacement = match usage {
             FormatParamUsage::Argument => segment.ident.name.to_string(),
             FormatParamUsage::Width => format!("{}$", segment.ident.name),
             FormatParamUsage::Precision => format!(".{}$", segment.ident.name),
         };
-        fixes.push((param.span, replacement));
+        fixes.push((pos_span, replacement));
         fixes.push((arg_span, String::new()));
         true  // successful inlining, continue checking
     } else {
         // Do not continue inlining (return false) in case
         // * if we can't inline a numbered argument, e.g. `print!("{0} ...", foo.bar, ...)`
         // * if allow_mixed_uninlined_format_args is false and this arg hasn't been inlined already
-        param.kind != Numbered && (!ignore_mixed || matches!(param.kind, NamedInline(_)))
-    }
-}
-
-fn outermost_expn_data(expn_data: ExpnData) -> ExpnData {
-    if expn_data.call_site.from_expansion() {
-        outermost_expn_data(expn_data.call_site.ctxt().outer_expn_data())
-    } else {
-        expn_data
+        pos.kind != FormatArgPositionKind::Number
+            && (!ignore_mixed || matches!(arg.kind, FormatArgumentKind::Captured(_)))
     }
 }
 
@@ -438,10 +455,31 @@ fn check_to_string_in_format_args(cx: &LateContext<'_>, name: Symbol, value: &Ex
     }
 }
 
-/// Returns true if `hir_id` is referred to by multiple format params
-fn is_aliased(args: &FormatArgsExpn<'_>, hir_id: HirId) -> bool {
-    args.params()
-        .filter(|param| param.value.hir_id == hir_id)
+fn format_arg_positions(
+    format_args: &rustc_ast::FormatArgs,
+) -> impl Iterator<Item = (&FormatArgPosition, FormatParamUsage)> {
+    format_args.template.iter().flat_map(|piece| match piece {
+        FormatArgsPiece::Placeholder(placeholder) => {
+            let mut positions = ArrayVec::<_, 3>::new();
+
+            positions.push((&placeholder.argument, FormatParamUsage::Argument));
+            if let Some(FormatCount::Argument(position)) = &placeholder.format_options.width {
+                positions.push((position, FormatParamUsage::Width));
+            }
+            if let Some(FormatCount::Argument(position)) = &placeholder.format_options.precision {
+                positions.push((position, FormatParamUsage::Precision));
+            }
+
+            positions
+        },
+        FormatArgsPiece::Literal(_) => ArrayVec::new(),
+    })
+}
+
+/// Returns true if the format argument at `index` is referred to by multiple format params
+fn is_aliased(format_args: &rustc_ast::FormatArgs, index: usize) -> bool {
+    format_arg_positions(format_args)
+        .filter(|(position, _)| position.index == Ok(index))
         .at_most_one()
         .is_err()
 }
diff --git a/clippy_lints/src/utils/format_args_collector.rs b/clippy_lints/src/utils/format_args_collector.rs
index be56b842b98..09fcb82c37c 100644
--- a/clippy_lints/src/utils/format_args_collector.rs
+++ b/clippy_lints/src/utils/format_args_collector.rs
@@ -1,7 +1,12 @@
 use clippy_utils::macros::collect_ast_format_args;
-use rustc_ast::{Expr, ExprKind};
+use clippy_utils::source::snippet_opt;
+use itertools::Itertools;
+use rustc_ast::{Expr, ExprKind, FormatArgs};
+use rustc_lexer::{tokenize, TokenKind};
 use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::hygiene;
+use std::iter::once;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -15,9 +20,79 @@ declare_clippy_lint! {
 declare_lint_pass!(FormatArgsCollector => [FORMAT_ARGS_COLLECTOR]);
 
 impl EarlyLintPass for FormatArgsCollector {
-    fn check_expr(&mut self, _: &EarlyContext<'_>, expr: &Expr) {
+    fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
         if let ExprKind::FormatArgs(args) = &expr.kind {
+            if has_span_from_proc_macro(cx, args) {
+                return;
+            }
+
             collect_ast_format_args(expr.span, args);
         }
     }
 }
+
+/// Detects if the format string or an argument has its span set by a proc macro to something inside
+/// a macro callsite, e.g.
+///
+/// ```ignore
+/// println!(some_proc_macro!("input {}"), a);
+/// ```
+///
+/// Where `some_proc_macro` expands to
+///
+/// ```ignore
+/// println!("output {}", a);
+/// ```
+///
+/// But with the span of `"output {}"` set to the macro input
+///
+/// ```ignore
+/// println!(some_proc_macro!("input {}"), a);
+/// //                        ^^^^^^^^^^
+/// ```
+fn has_span_from_proc_macro(cx: &EarlyContext<'_>, args: &FormatArgs) -> bool {
+    let ctxt = args.span.ctxt();
+
+    // `format!("{} {} {c}", "one", "two", c = "three")`
+    //                       ^^^^^  ^^^^^      ^^^^^^^
+    let argument_span = args
+        .arguments
+        .explicit_args()
+        .iter()
+        .map(|argument| hygiene::walk_chain(argument.expr.span, ctxt));
+
+    // `format!("{} {} {c}", "one", "two", c = "three")`
+    //                     ^^     ^^     ^^^^^^
+    let between_spans = once(args.span)
+        .chain(argument_span)
+        .tuple_windows()
+        .map(|(start, end)| start.between(end));
+
+    for between_span in between_spans {
+        let mut seen_comma = false;
+
+        let Some(snippet) = snippet_opt(cx, between_span) else { return true };
+        for token in tokenize(&snippet) {
+            match token.kind {
+                TokenKind::LineComment { .. } | TokenKind::BlockComment { .. } | TokenKind::Whitespace => {},
+                TokenKind::Comma if !seen_comma => seen_comma = true,
+                // named arguments, `start_val, name = end_val`
+                //                            ^^^^^^^^^ between_span
+                TokenKind::Ident | TokenKind::Eq if seen_comma => {},
+                // An unexpected token usually indicates that we crossed a macro boundary
+                //
+                // `println!(some_proc_macro!("input {}"), a)`
+                //                                      ^^^ between_span
+                // `println!("{}", val!(x))`
+                //               ^^^^^^^ between_span
+                _ => return true,
+            }
+        }
+
+        if !seen_comma {
+            return true;
+        }
+    }
+
+    false
+}
diff --git a/clippy_utils/src/macros.rs b/clippy_utils/src/macros.rs
index c0e32068eca..b03e0d4a1ca 100644
--- a/clippy_utils/src/macros.rs
+++ b/clippy_utils/src/macros.rs
@@ -6,7 +6,7 @@ use crate::visitors::{for_each_expr, Descend};
 use arrayvec::ArrayVec;
 use itertools::{izip, Either, Itertools};
 use rustc_ast::ast::LitKind;
-use rustc_ast::FormatArgs;
+use rustc_ast::{FormatArgs, FormatArgument, FormatPlaceholder};
 use rustc_data_structures::fx::FxHashMap;
 use rustc_hir::intravisit::{walk_expr, Visitor};
 use rustc_hir::{self as hir, Expr, ExprField, ExprKind, HirId, LangItem, Node, QPath, TyKind};
@@ -391,30 +391,67 @@ pub fn collect_ast_format_args(span: Span, format_args: &FormatArgs) {
     });
 }
 
-/// Calls `callback` with an AST [`FormatArgs`] node if one is found
+/// Calls `callback` with an AST [`FormatArgs`] node if a `format_args` expansion is found as a
+/// descendant of `expn_id`
 pub fn find_format_args(cx: &LateContext<'_>, start: &Expr<'_>, expn_id: ExpnId, callback: impl FnOnce(&FormatArgs)) {
     let format_args_expr = for_each_expr(start, |expr| {
         let ctxt = expr.span.ctxt();
-        if ctxt == start.span.ctxt() {
-            ControlFlow::Continue(Descend::Yes)
-        } else if ctxt.outer_expn().is_descendant_of(expn_id)
-            && macro_backtrace(expr.span)
+        if ctxt.outer_expn().is_descendant_of(expn_id) {
+            if macro_backtrace(expr.span)
                 .map(|macro_call| cx.tcx.item_name(macro_call.def_id))
                 .any(|name| matches!(name, sym::const_format_args | sym::format_args | sym::format_args_nl))
-        {
-            ControlFlow::Break(expr)
+            {
+                ControlFlow::Break(expr)
+            } else {
+                ControlFlow::Continue(Descend::Yes)
+            }
         } else {
             ControlFlow::Continue(Descend::No)
         }
     });
 
-    if let Some(format_args_expr) = format_args_expr {
+    if let Some(expr) = format_args_expr {
         AST_FORMAT_ARGS.with(|ast_format_args| {
-            ast_format_args.borrow().get(&format_args_expr.span).map(callback);
+            ast_format_args.borrow().get(&expr.span).map(callback);
         });
     }
 }
 
+/// Attempt to find the [`rustc_hir::Expr`] that corresponds to the [`FormatArgument`]'s value, if
+/// it cannot be found it will return the [`rustc_ast::Expr`].
+pub fn find_format_arg_expr<'hir, 'ast>(
+    start: &'hir Expr<'hir>,
+    target: &'ast FormatArgument,
+) -> Result<&'hir rustc_hir::Expr<'hir>, &'ast rustc_ast::Expr> {
+    for_each_expr(start, |expr| {
+        if expr.span == target.expr.span {
+            ControlFlow::Break(expr)
+        } else {
+            ControlFlow::Continue(())
+        }
+    })
+    .ok_or(&target.expr)
+}
+
+/// Span of the `:` and format specifiers
+///
+/// ```ignore
+/// format!("{:.}"), format!("{foo:.}")
+///           ^^                  ^^
+/// ```
+pub fn format_placeholder_format_span(placeholder: &FormatPlaceholder) -> Option<Span> {
+    let base = placeholder.span?.data();
+
+    // `base.hi` is `{...}|`, subtract 1 byte (the length of '}') so that it points before the closing
+    // brace `{...|}`
+    Some(Span::new(
+        placeholder.argument.span?.hi(),
+        base.hi - BytePos(1),
+        base.ctxt,
+        base.parent,
+    ))
+}
+
 /// Returns the [`Span`] of the value at `index` extended to the previous comma, e.g. for the value
 /// `10`
 ///
@@ -897,22 +934,6 @@ pub struct FormatArg<'tcx> {
     pub span: Span,
 }
 
-impl<'tcx> FormatArg<'tcx> {
-    /// Span of the `:` and format specifiers
-    ///
-    /// ```ignore
-    /// format!("{:.}"), format!("{foo:.}")
-    ///           ^^                  ^^
-    /// ```
-    pub fn format_span(&self) -> Span {
-        let base = self.span.data();
-
-        // `base.hi` is `{...}|`, subtract 1 byte (the length of '}') so that it points before the closing
-        // brace `{...|}`
-        Span::new(self.param.span.hi(), base.hi - BytePos(1), base.ctxt, base.parent)
-    }
-}
-
 /// A parsed `format_args!` expansion.
 #[derive(Debug)]
 pub struct FormatArgsExpn<'tcx> {
diff --git a/tests/ui-toml/allow_mixed_uninlined_format_args/uninlined_format_args.stderr b/tests/ui-toml/allow_mixed_uninlined_format_args/uninlined_format_args.stderr
index ee941762196..1be0cda12fc 100644
--- a/tests/ui-toml/allow_mixed_uninlined_format_args/uninlined_format_args.stderr
+++ b/tests/ui-toml/allow_mixed_uninlined_format_args/uninlined_format_args.stderr
@@ -11,29 +11,29 @@ LL -     println!("val='{}'", local_i32);
 LL +     println!("val='{local_i32}'");
    |
 
-error: literal with an empty format string
-  --> $DIR/uninlined_format_args.rs:10:35
+error: variables can be used directly in the `format!` string
+  --> $DIR/uninlined_format_args.rs:10:5
    |
 LL |     println!("Hello {} is {:.*}", "x", local_i32, local_f64);
-   |                                   ^^^
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = note: `-D clippy::print-literal` implied by `-D warnings`
-help: try this
+help: change this to
    |
 LL -     println!("Hello {} is {:.*}", "x", local_i32, local_f64);
-LL +     println!("Hello x is {:.*}", local_i32, local_f64);
+LL +     println!("Hello {} is {local_f64:.local_i32$}", "x");
    |
 
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:10:5
+error: literal with an empty format string
+  --> $DIR/uninlined_format_args.rs:10:35
    |
 LL |     println!("Hello {} is {:.*}", "x", local_i32, local_f64);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                                   ^^^
    |
-help: change this to
+   = note: `-D clippy::print-literal` implied by `-D warnings`
+help: try this
    |
 LL -     println!("Hello {} is {:.*}", "x", local_i32, local_f64);
-LL +     println!("Hello {} is {local_f64:.local_i32$}", "x");
+LL +     println!("Hello x is {:.*}", local_i32, local_f64);
    |
 
 error: variables can be used directly in the `format!` string
diff --git a/tests/ui/uninlined_format_args.fixed b/tests/ui/uninlined_format_args.fixed
index 1475d781c67..5ecb9a5bf9e 100644
--- a/tests/ui/uninlined_format_args.fixed
+++ b/tests/ui/uninlined_format_args.fixed
@@ -119,7 +119,7 @@ fn tester(fn_arg: i32) {
     println!("Width = {local_i32}, value with width = {local_f64:local_i32$}");
     println!("{local_i32:width$.prec$}");
     println!("{width:width$.prec$}");
-    println!("{}", format!("{local_i32}"));
+    println!("{}", format!("{}", local_i32));
     my_println!("{}", local_i32);
     my_println_args!("{}", local_i32);
 
diff --git a/tests/ui/uninlined_format_args.stderr b/tests/ui/uninlined_format_args.stderr
index a12abf8bef8..dc4af6ef42e 100644
--- a/tests/ui/uninlined_format_args.stderr
+++ b/tests/ui/uninlined_format_args.stderr
@@ -774,18 +774,6 @@ LL -     println!("{:w$.p$}", w = width, p = prec);
 LL +     println!("{width:width$.prec$}");
    |
 
-error: variables can be used directly in the `format!` string
-  --> $DIR/uninlined_format_args.rs:125:20
-   |
-LL |     println!("{}", format!("{}", local_i32));
-   |                    ^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: change this to
-   |
-LL -     println!("{}", format!("{}", local_i32));
-LL +     println!("{}", format!("{local_i32}"));
-   |
-
 error: variables can be used directly in the `format!` string
   --> $DIR/uninlined_format_args.rs:143:5
    |
@@ -856,5 +844,5 @@ LL -     println!("expand='{}'", local_i32);
 LL +     println!("expand='{local_i32}'");
    |
 
-error: aborting due to 72 previous errors
+error: aborting due to 71 previous errors
 
diff --git a/tests/ui/unused_format_specs.fixed b/tests/ui/unused_format_specs.fixed
deleted file mode 100644
index 2930722b42d..00000000000
--- a/tests/ui/unused_format_specs.fixed
+++ /dev/null
@@ -1,18 +0,0 @@
-// run-rustfix
-
-#![warn(clippy::unused_format_specs)]
-#![allow(unused)]
-
-fn main() {
-    let f = 1.0f64;
-    println!("{}", 1.0);
-    println!("{f} {f:?}");
-
-    println!("{}", 1);
-}
-
-fn should_not_lint() {
-    let f = 1.0f64;
-    println!("{:.1}", 1.0);
-    println!("{f:.w$} {f:.*?}", 3, w = 2);
-}
diff --git a/tests/ui/unused_format_specs.rs b/tests/ui/unused_format_specs.rs
deleted file mode 100644
index ee192a000d4..00000000000
--- a/tests/ui/unused_format_specs.rs
+++ /dev/null
@@ -1,18 +0,0 @@
-// run-rustfix
-
-#![warn(clippy::unused_format_specs)]
-#![allow(unused)]
-
-fn main() {
-    let f = 1.0f64;
-    println!("{:.}", 1.0);
-    println!("{f:.} {f:.?}");
-
-    println!("{:.}", 1);
-}
-
-fn should_not_lint() {
-    let f = 1.0f64;
-    println!("{:.1}", 1.0);
-    println!("{f:.w$} {f:.*?}", 3, w = 2);
-}
diff --git a/tests/ui/unused_format_specs.stderr b/tests/ui/unused_format_specs.stderr
deleted file mode 100644
index 7231c17e74c..00000000000
--- a/tests/ui/unused_format_specs.stderr
+++ /dev/null
@@ -1,54 +0,0 @@
-error: empty precision specifier has no effect
-  --> $DIR/unused_format_specs.rs:8:17
-   |
-LL |     println!("{:.}", 1.0);
-   |                 ^
-   |
-   = note: a precision specifier is not required to format floats
-   = note: `-D clippy::unused-format-specs` implied by `-D warnings`
-help: remove the `.`
-   |
-LL -     println!("{:.}", 1.0);
-LL +     println!("{}", 1.0);
-   |
-
-error: empty precision specifier has no effect
-  --> $DIR/unused_format_specs.rs:9:18
-   |
-LL |     println!("{f:.} {f:.?}");
-   |                  ^
-   |
-   = note: a precision specifier is not required to format floats
-help: remove the `.`
-   |
-LL -     println!("{f:.} {f:.?}");
-LL +     println!("{f} {f:.?}");
-   |
-
-error: empty precision specifier has no effect
-  --> $DIR/unused_format_specs.rs:9:24
-   |
-LL |     println!("{f:.} {f:.?}");
-   |                        ^
-   |
-   = note: a precision specifier is not required to format floats
-help: remove the `.`
-   |
-LL -     println!("{f:.} {f:.?}");
-LL +     println!("{f:.} {f:?}");
-   |
-
-error: empty precision specifier has no effect
-  --> $DIR/unused_format_specs.rs:11:17
-   |
-LL |     println!("{:.}", 1);
-   |                 ^
-   |
-help: remove the `.`
-   |
-LL -     println!("{:.}", 1);
-LL +     println!("{}", 1);
-   |
-
-error: aborting due to 4 previous errors
-
diff --git a/tests/ui/unused_format_specs_unfixable.stderr b/tests/ui/unused_format_specs_unfixable.stderr
index 9f1890282e6..cb7156b6baf 100644
--- a/tests/ui/unused_format_specs_unfixable.stderr
+++ b/tests/ui/unused_format_specs_unfixable.stderr
@@ -37,11 +37,7 @@ error: format specifiers have no effect on `format_args!()`
 LL |     println!("{:5}.", format_args_from_macro!());
    |               ^^^^
    |
-help: for the width to apply consider using `format!()`
-  --> $DIR/unused_format_specs_unfixable.rs:16:17
-   |
-LL |     println!("{:5}.", format_args_from_macro!());
-   |                 ^
+   = help: for the width to apply consider using `format!()`
 help: if the current behavior is intentional, remove the format specifiers
    |
 LL -     println!("{:5}.", format_args_from_macro!());
@@ -54,11 +50,7 @@ error: format specifiers have no effect on `format_args!()`
 LL |     println!("{args:5}");
    |               ^^^^^^^^
    |
-help: for the width to apply consider using `format!()`
-  --> $DIR/unused_format_specs_unfixable.rs:19:21
-   |
-LL |     println!("{args:5}");
-   |                     ^
+   = help: for the width to apply consider using `format!()`
 help: if the current behavior is intentional, remove the format specifiers
    |
 LL -     println!("{args:5}");
-- 
cgit 1.4.1-3-g733a5


From 6589d794927451ed5d503b108e0e6900bbf91d3d Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Tue, 28 Mar 2023 21:28:57 +0000
Subject: Replace remaining usage of `FormatArgsExpn`

---
 clippy_lints/src/explicit_write.rs          |  29 +-
 clippy_lints/src/format.rs                  |  91 ++--
 clippy_lints/src/format_impl.rs             |  60 ++-
 clippy_lints/src/methods/expect_fun_call.rs |  27 +-
 clippy_utils/src/lib.rs                     |   1 -
 clippy_utils/src/macros.rs                  | 727 +---------------------------
 6 files changed, 132 insertions(+), 803 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/explicit_write.rs b/clippy_lints/src/explicit_write.rs
index c0ea6f338a2..315df6c714f 100644
--- a/clippy_lints/src/explicit_write.rs
+++ b/clippy_lints/src/explicit_write.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::macros::FormatArgsExpn;
+use clippy_utils::macros::{find_format_args, format_args_inputs_span};
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::{is_expn_of, match_function_call, paths};
 use if_chain::if_chain;
@@ -8,7 +8,7 @@ use rustc_hir::def::Res;
 use rustc_hir::{BindingAnnotation, Block, BlockCheckMode, Expr, ExprKind, Node, PatKind, QPath, Stmt, StmtKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::sym;
+use rustc_span::{sym, ExpnId};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -43,23 +43,22 @@ declare_lint_pass!(ExplicitWrite => [EXPLICIT_WRITE]);
 
 impl<'tcx> LateLintPass<'tcx> for ExplicitWrite {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if_chain! {
-            // match call to unwrap
-            if let ExprKind::MethodCall(unwrap_fun, write_call, [], _) = expr.kind;
-            if unwrap_fun.ident.name == sym::unwrap;
+        // match call to unwrap
+        if let ExprKind::MethodCall(unwrap_fun, write_call, [], _) = expr.kind
+            && unwrap_fun.ident.name == sym::unwrap
             // match call to write_fmt
-            if let ExprKind::MethodCall(write_fun, write_recv, [write_arg], _) = look_in_block(cx, &write_call.kind);
-            if write_fun.ident.name == sym!(write_fmt);
+            && let ExprKind::MethodCall(write_fun, write_recv, [write_arg], _) = look_in_block(cx, &write_call.kind)
+            && write_fun.ident.name == sym!(write_fmt)
             // match calls to std::io::stdout() / std::io::stderr ()
-            if let Some(dest_name) = if match_function_call(cx, write_recv, &paths::STDOUT).is_some() {
+            && let Some(dest_name) = if match_function_call(cx, write_recv, &paths::STDOUT).is_some() {
                 Some("stdout")
             } else if match_function_call(cx, write_recv, &paths::STDERR).is_some() {
                 Some("stderr")
             } else {
                 None
-            };
-            if let Some(format_args) = FormatArgsExpn::parse(cx, write_arg);
-            then {
+            }
+        {
+            find_format_args(cx, write_arg, ExpnId::root(), |format_args| {
                 let calling_macro =
                     // ordering is important here, since `writeln!` uses `write!` internally
                     if is_expn_of(write_call.span, "writeln").is_some() {
@@ -92,7 +91,7 @@ impl<'tcx> LateLintPass<'tcx> for ExplicitWrite {
                 let mut applicability = Applicability::MachineApplicable;
                 let inputs_snippet = snippet_with_applicability(
                     cx,
-                    format_args.inputs_span(),
+                    format_args_inputs_span(format_args),
                     "..",
                     &mut applicability,
                 );
@@ -104,8 +103,8 @@ impl<'tcx> LateLintPass<'tcx> for ExplicitWrite {
                     "try this",
                     format!("{prefix}{sugg_mac}!({inputs_snippet})"),
                     applicability,
-                )
-            }
+                );
+            });
         }
     }
 }
diff --git a/clippy_lints/src/format.rs b/clippy_lints/src/format.rs
index 8040938c626..d34d6e9279e 100644
--- a/clippy_lints/src/format.rs
+++ b/clippy_lints/src/format.rs
@@ -1,14 +1,13 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::macros::{root_macro_call_first_node, FormatArgsExpn};
-use clippy_utils::source::snippet_with_context;
+use clippy_utils::macros::{find_format_arg_expr, find_format_args, root_macro_call_first_node};
+use clippy_utils::source::{snippet_opt, snippet_with_context};
 use clippy_utils::sugg::Sugg;
-use if_chain::if_chain;
+use rustc_ast::{FormatArgsPiece, FormatOptions, FormatTrait};
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::symbol::kw;
 use rustc_span::{sym, Span};
 
 declare_clippy_lint! {
@@ -44,55 +43,53 @@ declare_lint_pass!(UselessFormat => [USELESS_FORMAT]);
 
 impl<'tcx> LateLintPass<'tcx> for UselessFormat {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        let (format_args, call_site) = if_chain! {
-            if let Some(macro_call) = root_macro_call_first_node(cx, expr);
-            if cx.tcx.is_diagnostic_item(sym::format_macro, macro_call.def_id);
-            if let Some(format_args) = FormatArgsExpn::find_nested(cx, expr, macro_call.expn);
-            then {
-                (format_args, macro_call.span)
-            } else {
-                return
-            }
-        };
+        let Some(macro_call) = root_macro_call_first_node(cx, expr) else { return };
+        if !cx.tcx.is_diagnostic_item(sym::format_macro, macro_call.def_id) {
+            return;
+        }
+
+        find_format_args(cx, expr, macro_call.expn, |format_args| {
+            let mut applicability = Applicability::MachineApplicable;
+            let call_site = macro_call.span;
 
-        let mut applicability = Applicability::MachineApplicable;
-        if format_args.args.is_empty() {
-            match *format_args.format_string.parts {
-                [] => span_useless_format_empty(cx, call_site, "String::new()".to_owned(), applicability),
-                [_] => {
+            match (format_args.arguments.all_args(), &format_args.template[..]) {
+                ([], []) => span_useless_format_empty(cx, call_site, "String::new()".to_owned(), applicability),
+                ([], [_]) => {
                     // Simulate macro expansion, converting {{ and }} to { and }.
-                    let s_expand = format_args.format_string.snippet.replace("{{", "{").replace("}}", "}");
+                    let Some(snippet) = snippet_opt(cx, format_args.span) else { return };
+                    let s_expand = snippet.replace("{{", "{").replace("}}", "}");
                     let sugg = format!("{s_expand}.to_string()");
                     span_useless_format(cx, call_site, sugg, applicability);
                 },
-                [..] => {},
-            }
-        } else if let [arg] = &*format_args.args {
-            let value = arg.param.value;
-            if_chain! {
-                if format_args.format_string.parts == [kw::Empty];
-                if arg.format.is_default();
-                if match cx.typeck_results().expr_ty(value).peel_refs().kind() {
-                    ty::Adt(adt, _) => Some(adt.did()) == cx.tcx.lang_items().string(),
-                    ty::Str => true,
-                    _ => false,
-                };
-                then {
-                    let is_new_string = match value.kind {
-                        ExprKind::Binary(..) => true,
-                        ExprKind::MethodCall(path, ..) => path.ident.name == sym::to_string,
-                        _ => false,
-                    };
-                    let sugg = if is_new_string {
-                        snippet_with_context(cx, value.span, call_site.ctxt(), "..", &mut applicability).0.into_owned()
-                    } else {
-                        let sugg = Sugg::hir_with_context(cx, value, call_site.ctxt(), "<arg>", &mut applicability);
-                        format!("{}.to_string()", sugg.maybe_par())
-                    };
-                    span_useless_format(cx, call_site, sugg, applicability);
-                }
+                ([arg], [piece]) => {
+                    if let Ok(value) = find_format_arg_expr(expr, arg)
+                        && let FormatArgsPiece::Placeholder(placeholder) = piece
+                        && placeholder.format_trait == FormatTrait::Display
+                        && placeholder.format_options == FormatOptions::default()
+                        && match cx.typeck_results().expr_ty(value).peel_refs().kind() {
+                            ty::Adt(adt, _) => Some(adt.did()) == cx.tcx.lang_items().string(),
+                            ty::Str => true,
+                            _ => false,
+                        }
+                    {
+                        let is_new_string = match value.kind {
+                            ExprKind::Binary(..) => true,
+                            ExprKind::MethodCall(path, ..) => path.ident.name == sym::to_string,
+                            _ => false,
+                        };
+                        let sugg = if is_new_string {
+                            snippet_with_context(cx, value.span, call_site.ctxt(), "..", &mut applicability).0.into_owned()
+                        } else {
+                            let sugg = Sugg::hir_with_context(cx, value, call_site.ctxt(), "<arg>", &mut applicability);
+                            format!("{}.to_string()", sugg.maybe_par())
+                        };
+                        span_useless_format(cx, call_site, sugg, applicability);
+
+                    }
+                },
+                _ => {},
             }
-        };
+        });
     }
 }
 
diff --git a/clippy_lints/src/format_impl.rs b/clippy_lints/src/format_impl.rs
index ed1342a5465..e3ddbfb5981 100644
--- a/clippy_lints/src/format_impl.rs
+++ b/clippy_lints/src/format_impl.rs
@@ -1,11 +1,13 @@
 use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg};
-use clippy_utils::macros::{is_format_macro, root_macro_call_first_node, FormatArg, FormatArgsExpn};
+use clippy_utils::macros::{find_format_arg_expr, find_format_args, is_format_macro, root_macro_call_first_node};
 use clippy_utils::{get_parent_as_impl, is_diag_trait_item, path_to_local, peel_ref_operators};
 use if_chain::if_chain;
+use rustc_ast::{FormatArgsPiece, FormatTrait};
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, Impl, ImplItem, ImplItemKind, QPath};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::Span;
 use rustc_span::{sym, symbol::kw, Symbol};
 
 declare_clippy_lint! {
@@ -89,7 +91,7 @@ declare_clippy_lint! {
 }
 
 #[derive(Clone, Copy)]
-struct FormatTrait {
+struct FormatTraitNames {
     /// e.g. `sym::Display`
     name: Symbol,
     /// `f` in `fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {}`
@@ -99,7 +101,7 @@ struct FormatTrait {
 #[derive(Default)]
 pub struct FormatImpl {
     // Whether we are inside Display or Debug trait impl - None for neither
-    format_trait_impl: Option<FormatTrait>,
+    format_trait_impl: Option<FormatTraitNames>,
 }
 
 impl FormatImpl {
@@ -161,43 +163,57 @@ fn check_to_string_in_display(cx: &LateContext<'_>, expr: &Expr<'_>) {
     }
 }
 
-fn check_self_in_format_args<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, impl_trait: FormatTrait) {
+fn check_self_in_format_args<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, impl_trait: FormatTraitNames) {
     // Check each arg in format calls - do we ever use Display on self (directly or via deref)?
-    if_chain! {
-        if let Some(outer_macro) = root_macro_call_first_node(cx, expr);
-        if let macro_def_id = outer_macro.def_id;
-        if let Some(format_args) = FormatArgsExpn::find_nested(cx, expr, outer_macro.expn);
-        if is_format_macro(cx, macro_def_id);
-        then {
-            for arg in format_args.args {
-                if arg.format.r#trait != impl_trait.name {
-                    continue;
+    if let Some(outer_macro) = root_macro_call_first_node(cx, expr)
+        && let macro_def_id = outer_macro.def_id
+        && is_format_macro(cx, macro_def_id)
+    {
+        find_format_args(cx, expr, outer_macro.expn, |format_args| {
+            for piece in &format_args.template {
+                if let FormatArgsPiece::Placeholder(placeholder) = piece
+                    && let trait_name = match placeholder.format_trait {
+                        FormatTrait::Display => sym::Display,
+                        FormatTrait::Debug => sym::Debug,
+                        FormatTrait::LowerExp => sym!(LowerExp),
+                        FormatTrait::UpperExp => sym!(UpperExp),
+                        FormatTrait::Octal => sym!(Octal),
+                        FormatTrait::Pointer => sym::Pointer,
+                        FormatTrait::Binary => sym!(Binary),
+                        FormatTrait::LowerHex => sym!(LowerHex),
+                        FormatTrait::UpperHex => sym!(UpperHex),
+                    }
+                    && trait_name == impl_trait.name
+                    && let Ok(index) = placeholder.argument.index
+                    && let Some(arg) = format_args.arguments.all_args().get(index)
+                    && let Ok(arg_expr) = find_format_arg_expr(expr, arg)
+                {
+                    check_format_arg_self(cx, expr.span, arg_expr, impl_trait);
                 }
-                check_format_arg_self(cx, expr, &arg, impl_trait);
             }
-        }
+        });
     }
 }
 
-fn check_format_arg_self(cx: &LateContext<'_>, expr: &Expr<'_>, arg: &FormatArg<'_>, impl_trait: FormatTrait) {
+fn check_format_arg_self(cx: &LateContext<'_>, span: Span, arg: &Expr<'_>, impl_trait: FormatTraitNames) {
     // Handle multiple dereferencing of references e.g. &&self
     // Handle dereference of &self -> self that is equivalent (i.e. via *self in fmt() impl)
     // Since the argument to fmt is itself a reference: &self
-    let reference = peel_ref_operators(cx, arg.param.value);
+    let reference = peel_ref_operators(cx, arg);
     let map = cx.tcx.hir();
     // Is the reference self?
     if path_to_local(reference).map(|x| map.name(x)) == Some(kw::SelfLower) {
-        let FormatTrait { name, .. } = impl_trait;
+        let FormatTraitNames { name, .. } = impl_trait;
         span_lint(
             cx,
             RECURSIVE_FORMAT_IMPL,
-            expr.span,
+            span,
             &format!("using `self` as `{name}` in `impl {name}` will cause infinite recursion"),
         );
     }
 }
 
-fn check_print_in_format_impl(cx: &LateContext<'_>, expr: &Expr<'_>, impl_trait: FormatTrait) {
+fn check_print_in_format_impl(cx: &LateContext<'_>, expr: &Expr<'_>, impl_trait: FormatTraitNames) {
     if_chain! {
         if let Some(macro_call) = root_macro_call_first_node(cx, expr);
         if let Some(name) = cx.tcx.get_diagnostic_name(macro_call.def_id);
@@ -227,7 +243,7 @@ fn check_print_in_format_impl(cx: &LateContext<'_>, expr: &Expr<'_>, impl_trait:
     }
 }
 
-fn is_format_trait_impl(cx: &LateContext<'_>, impl_item: &ImplItem<'_>) -> Option<FormatTrait> {
+fn is_format_trait_impl(cx: &LateContext<'_>, impl_item: &ImplItem<'_>) -> Option<FormatTraitNames> {
     if_chain! {
         if impl_item.ident.name == sym::fmt;
         if let ImplItemKind::Fn(_, body_id) = impl_item.kind;
@@ -241,7 +257,7 @@ fn is_format_trait_impl(cx: &LateContext<'_>, impl_item: &ImplItem<'_>) -> Optio
                 .and_then(|param| param.pat.simple_ident())
                 .map(|ident| ident.name);
 
-            Some(FormatTrait {
+            Some(FormatTraitNames {
                 name,
                 formatter_name,
             })
diff --git a/clippy_lints/src/methods/expect_fun_call.rs b/clippy_lints/src/methods/expect_fun_call.rs
index a22285058d4..92d21bb8932 100644
--- a/clippy_lints/src/methods/expect_fun_call.rs
+++ b/clippy_lints/src/methods/expect_fun_call.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::macros::{root_macro_call_first_node, FormatArgsExpn};
+use clippy_utils::macros::{find_format_args, format_args_inputs_span, root_macro_call_first_node};
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::{is_type_diagnostic_item, is_type_lang_item};
 use rustc_errors::Applicability;
@@ -136,18 +136,19 @@ pub(super) fn check<'tcx>(
         if !cx.tcx.is_diagnostic_item(sym::format_macro, macro_call.def_id) {
             return;
         }
-        let Some(format_args) = FormatArgsExpn::find_nested(cx, arg_root, macro_call.expn) else { return };
-        let span = format_args.inputs_span();
-        let sugg = snippet_with_applicability(cx, span, "..", &mut applicability);
-        span_lint_and_sugg(
-            cx,
-            EXPECT_FUN_CALL,
-            span_replace_word,
-            &format!("use of `{name}` followed by a function call"),
-            "try this",
-            format!("unwrap_or_else({closure_args} panic!({sugg}))"),
-            applicability,
-        );
+        find_format_args(cx, arg_root, macro_call.expn, |format_args| {
+            let span = format_args_inputs_span(format_args);
+            let sugg = snippet_with_applicability(cx, span, "..", &mut applicability);
+            span_lint_and_sugg(
+                cx,
+                EXPECT_FUN_CALL,
+                span_replace_word,
+                &format!("use of `{name}` followed by a function call"),
+                "try this",
+                format!("unwrap_or_else({closure_args} panic!({sugg}))"),
+                applicability,
+            );
+        });
         return;
     }
 
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 2e839fdf472..f4af00599cd 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -33,7 +33,6 @@ extern crate rustc_lexer;
 extern crate rustc_lint;
 extern crate rustc_middle;
 extern crate rustc_mir_dataflow;
-extern crate rustc_parse_format;
 extern crate rustc_session;
 extern crate rustc_span;
 extern crate rustc_target;
diff --git a/clippy_utils/src/macros.rs b/clippy_utils/src/macros.rs
index b03e0d4a1ca..62d388a5ece 100644
--- a/clippy_utils/src/macros.rs
+++ b/clippy_utils/src/macros.rs
@@ -1,24 +1,16 @@
 #![allow(clippy::similar_names)] // `expr` and `expn`
 
-use crate::source::snippet_opt;
 use crate::visitors::{for_each_expr, Descend};
 
 use arrayvec::ArrayVec;
-use itertools::{izip, Either, Itertools};
-use rustc_ast::ast::LitKind;
 use rustc_ast::{FormatArgs, FormatArgument, FormatPlaceholder};
 use rustc_data_structures::fx::FxHashMap;
-use rustc_hir::intravisit::{walk_expr, Visitor};
-use rustc_hir::{self as hir, Expr, ExprField, ExprKind, HirId, LangItem, Node, QPath, TyKind};
-use rustc_lexer::unescape::unescape_literal;
-use rustc_lexer::{tokenize, unescape, LiteralKind, TokenKind};
+use rustc_hir::{self as hir, Expr, ExprKind, HirId, Node, QPath};
 use rustc_lint::LateContext;
-use rustc_parse_format::{self as rpf, Alignment};
 use rustc_span::def_id::DefId;
 use rustc_span::hygiene::{self, MacroKind, SyntaxContext};
-use rustc_span::{sym, BytePos, ExpnData, ExpnId, ExpnKind, Pos, Span, SpanData, Symbol};
+use rustc_span::{sym, BytePos, ExpnData, ExpnId, ExpnKind, Span, Symbol};
 use std::cell::RefCell;
-use std::iter::{once, zip};
 use std::ops::ControlFlow;
 use std::sync::atomic::{AtomicBool, Ordering};
 
@@ -226,11 +218,11 @@ pub enum PanicExpn<'a> {
     /// A single argument that implements `Display` - `panic!("{}", object)`
     Display(&'a Expr<'a>),
     /// Anything else - `panic!("error {}: {}", a, b)`
-    Format(FormatArgsExpn<'a>),
+    Format(&'a Expr<'a>),
 }
 
 impl<'a> PanicExpn<'a> {
-    pub fn parse(cx: &LateContext<'_>, expr: &'a Expr<'a>) -> Option<Self> {
+    pub fn parse(expr: &'a Expr<'a>) -> Option<Self> {
         let ExprKind::Call(callee, [arg, rest @ ..]) = &expr.kind else { return None };
         let ExprKind::Path(QPath::Resolved(_, path)) = &callee.kind else { return None };
         let result = match path.segments.last().unwrap().ident.as_str() {
@@ -240,7 +232,7 @@ impl<'a> PanicExpn<'a> {
                 let ExprKind::AddrOf(_, _, e) = &arg.kind else { return None };
                 Self::Display(e)
             },
-            "panic_fmt" => Self::Format(FormatArgsExpn::parse(cx, arg)?),
+            "panic_fmt" => Self::Format(arg),
             // Since Rust 1.52, `assert_{eq,ne}` macros expand to use:
             // `core::panicking::assert_failed(.., left_val, right_val, None | Some(format_args!(..)));`
             "assert_failed" => {
@@ -252,7 +244,7 @@ impl<'a> PanicExpn<'a> {
                 // `msg_arg` is either `None` (no custom message) or `Some(format_args!(..))` (custom message)
                 let msg_arg = &rest[2];
                 match msg_arg.kind {
-                    ExprKind::Call(_, [fmt_arg]) => Self::Format(FormatArgsExpn::parse(cx, fmt_arg)?),
+                    ExprKind::Call(_, [fmt_arg]) => Self::Format(fmt_arg),
                     _ => Self::Empty,
                 }
             },
@@ -304,7 +296,7 @@ fn find_assert_args_inner<'a, const N: usize>(
     let mut args = ArrayVec::new();
     let panic_expn = for_each_expr(expr, |e| {
         if args.is_full() {
-            match PanicExpn::parse(cx, e) {
+            match PanicExpn::parse(e) {
                 Some(expn) => ControlFlow::Break(expn),
                 None => ControlFlow::Continue(Descend::Yes),
             }
@@ -452,6 +444,21 @@ pub fn format_placeholder_format_span(placeholder: &FormatPlaceholder) -> Option
     ))
 }
 
+/// Span covering the format string and values
+///
+/// ```ignore
+/// format("{}.{}", 10, 11)
+/// //     ^^^^^^^^^^^^^^^
+/// ```
+pub fn format_args_inputs_span(format_args: &FormatArgs) -> Span {
+    match format_args.arguments.explicit_args() {
+        [] => format_args.span,
+        [.., last] => format_args
+            .span
+            .to(hygiene::walk_chain(last.expr.span, format_args.span.ctxt())),
+    }
+}
+
 /// Returns the [`Span`] of the value at `index` extended to the previous comma, e.g. for the value
 /// `10`
 ///
@@ -473,251 +480,6 @@ pub fn format_arg_removal_span(format_args: &FormatArgs, index: usize) -> Option
     Some(current.with_lo(prev.hi()))
 }
 
-/// The format string doesn't exist in the HIR, so we reassemble it from source code
-#[derive(Debug)]
-pub struct FormatString {
-    /// Span of the whole format string literal, including `[r#]"`.
-    pub span: Span,
-    /// Snippet of the whole format string literal, including `[r#]"`.
-    pub snippet: String,
-    /// If the string is raw `r"..."`/`r#""#`, how many `#`s does it have on each side.
-    pub style: Option<usize>,
-    /// The unescaped value of the format string, e.g. `"val – {}"` for the literal
-    /// `"val \u{2013} {}"`.
-    pub unescaped: String,
-    /// The format string split by format args like `{..}`.
-    pub parts: Vec<Symbol>,
-}
-
-impl FormatString {
-    fn new(cx: &LateContext<'_>, pieces: &Expr<'_>) -> Option<Self> {
-        // format_args!(r"a {} b \", 1);
-        //
-        // expands to
-        //
-        // ::core::fmt::Arguments::new_v1(&["a ", " b \\"],
-        //      &[::core::fmt::ArgumentV1::new_display(&1)]);
-        //
-        // where `pieces` is the expression `&["a ", " b \\"]`. It has the span of `r"a {} b \"`
-        let span = pieces.span;
-        let snippet = snippet_opt(cx, span)?;
-
-        let (inner, style) = match tokenize(&snippet).next()?.kind {
-            TokenKind::Literal { kind, .. } => {
-                let style = match kind {
-                    LiteralKind::Str { .. } => None,
-                    LiteralKind::RawStr { n_hashes: Some(n), .. } => Some(n.into()),
-                    _ => return None,
-                };
-
-                let start = style.map_or(1, |n| 2 + n);
-                let end = snippet.len() - style.map_or(1, |n| 1 + n);
-
-                (&snippet[start..end], style)
-            },
-            _ => return None,
-        };
-
-        let mode = if style.is_some() {
-            unescape::Mode::RawStr
-        } else {
-            unescape::Mode::Str
-        };
-
-        let mut unescaped = String::with_capacity(inner.len());
-        // Sometimes the original string comes from a macro which accepts a malformed string, such as in a
-        // #[display(""somestring)] attribute (accepted by the `displaythis` crate). Reconstructing the
-        // string from the span will not be possible, so we will just return None here.
-        let mut unparsable = false;
-        unescape_literal(inner, mode, &mut |_, ch| match ch {
-            Ok(ch) => unescaped.push(ch),
-            Err(e) if !e.is_fatal() => (),
-            Err(_) => unparsable = true,
-        });
-        if unparsable {
-            return None;
-        }
-
-        let mut parts = Vec::new();
-        let _: Option<!> = for_each_expr(pieces, |expr| {
-            if let ExprKind::Lit(lit) = &expr.kind
-                && let LitKind::Str(symbol, _) = lit.node
-            {
-                parts.push(symbol);
-            }
-            ControlFlow::Continue(())
-        });
-
-        Some(Self {
-            span,
-            snippet,
-            style,
-            unescaped,
-            parts,
-        })
-    }
-}
-
-struct FormatArgsValues<'tcx> {
-    /// Values passed after the format string and implicit captures. `[1, z + 2, x]` for
-    /// `format!("{x} {} {}", 1, z + 2)`.
-    value_args: Vec<&'tcx Expr<'tcx>>,
-    /// Maps an `rt::v1::Argument::position` or an `rt::v1::Count::Param` to its index in
-    /// `value_args`
-    pos_to_value_index: Vec<usize>,
-    /// Used to check if a value is declared inline & to resolve `InnerSpan`s.
-    format_string_span: SpanData,
-}
-
-impl<'tcx> FormatArgsValues<'tcx> {
-    fn new_empty(format_string_span: SpanData) -> Self {
-        Self {
-            value_args: Vec::new(),
-            pos_to_value_index: Vec::new(),
-            format_string_span,
-        }
-    }
-
-    fn new(args: &'tcx Expr<'tcx>, format_string_span: SpanData) -> Self {
-        let mut pos_to_value_index = Vec::new();
-        let mut value_args = Vec::new();
-        let _: Option<!> = for_each_expr(args, |expr| {
-            if expr.span.ctxt() == args.span.ctxt() {
-                // ArgumentV1::new_<format_trait>(<val>)
-                // ArgumentV1::from_usize(<val>)
-                if let ExprKind::Call(callee, [val]) = expr.kind
-                    && let ExprKind::Path(QPath::TypeRelative(ty, _)) = callee.kind
-                    && let TyKind::Path(QPath::LangItem(LangItem::FormatArgument, _, _)) = ty.kind
-                {
-                    let val_idx = if val.span.ctxt() == expr.span.ctxt()
-                        && let ExprKind::Field(_, field) = val.kind
-                        && let Ok(idx) = field.name.as_str().parse()
-                    {
-                        // tuple index
-                        idx
-                    } else {
-                        // assume the value expression is passed directly
-                        pos_to_value_index.len()
-                    };
-
-                    pos_to_value_index.push(val_idx);
-                }
-                ControlFlow::Continue(Descend::Yes)
-            } else {
-                // assume that any expr with a differing span is a value
-                value_args.push(expr);
-                ControlFlow::Continue(Descend::No)
-            }
-        });
-
-        Self {
-            value_args,
-            pos_to_value_index,
-            format_string_span,
-        }
-    }
-}
-
-/// The positions of a format argument's value, precision and width
-///
-/// A position is an index into the second argument of `Arguments::new_v1[_formatted]`
-#[derive(Debug, Default, Copy, Clone)]
-struct ParamPosition {
-    /// The position stored in `rt::v1::Argument::position`.
-    value: usize,
-    /// The position stored in `rt::v1::FormatSpec::width` if it is a `Count::Param`.
-    width: Option<usize>,
-    /// The position stored in `rt::v1::FormatSpec::precision` if it is a `Count::Param`.
-    precision: Option<usize>,
-}
-
-impl<'tcx> Visitor<'tcx> for ParamPosition {
-    fn visit_expr_field(&mut self, field: &'tcx ExprField<'tcx>) {
-        match field.ident.name {
-            sym::position => {
-                if let ExprKind::Lit(lit) = &field.expr.kind
-                    && let LitKind::Int(pos, _) = lit.node
-                {
-                    self.value = pos as usize;
-                }
-            },
-            sym::precision => {
-                self.precision = parse_count(field.expr);
-            },
-            sym::width => {
-                self.width = parse_count(field.expr);
-            },
-            _ => walk_expr(self, field.expr),
-        }
-    }
-}
-
-fn parse_count(expr: &Expr<'_>) -> Option<usize> {
-    // <::core::fmt::rt::v1::Count>::Param(1usize),
-    if let ExprKind::Call(ctor, [val]) = expr.kind
-        && let ExprKind::Path(QPath::TypeRelative(_, path)) = ctor.kind
-            && path.ident.name == sym::Param
-            && let ExprKind::Lit(lit) = &val.kind
-            && let LitKind::Int(pos, _) = lit.node
-    {
-        Some(pos as usize)
-    } else {
-        None
-    }
-}
-
-/// Parses the `fmt` arg of `Arguments::new_v1_formatted(pieces, args, fmt, _)`
-fn parse_rt_fmt<'tcx>(fmt_arg: &'tcx Expr<'tcx>) -> Option<impl Iterator<Item = ParamPosition> + 'tcx> {
-    if let ExprKind::AddrOf(.., array) = fmt_arg.kind
-        && let ExprKind::Array(specs) = array.kind
-    {
-        Some(specs.iter().map(|spec| {
-            if let ExprKind::Call(f, args) = spec.kind
-                && let ExprKind::Path(QPath::TypeRelative(ty, f)) = f.kind
-                && let TyKind::Path(QPath::LangItem(LangItem::FormatPlaceholder, _, _)) = ty.kind
-                && f.ident.name == sym::new
-                && let [position, _fill, _align, _flags, precision, width] = args
-                && let ExprKind::Lit(position) = &position.kind
-                && let LitKind::Int(position, _) = position.node {
-                    ParamPosition {
-                        value: position as usize,
-                        width: parse_count(width),
-                        precision: parse_count(precision),
-                    }
-            } else {
-                ParamPosition::default()
-            }
-        }))
-    } else {
-        None
-    }
-}
-
-/// `Span::from_inner`, but for `rustc_parse_format`'s `InnerSpan`
-fn span_from_inner(base: SpanData, inner: rpf::InnerSpan) -> Span {
-    Span::new(
-        base.lo + BytePos::from_usize(inner.start),
-        base.lo + BytePos::from_usize(inner.end),
-        base.ctxt,
-        base.parent,
-    )
-}
-
-/// How a format parameter is used in the format string
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-pub enum FormatParamKind {
-    /// An implicit parameter , such as `{}` or `{:?}`.
-    Implicit,
-    /// A parameter with an explicit number, e.g. `{1}`, `{0:?}`, or `{:.0$}`
-    Numbered,
-    /// A parameter with an asterisk precision. e.g. `{:.*}`.
-    Starred,
-    /// A named parameter with a named `value_arg`, such as the `x` in `format!("{x}", x = 1)`.
-    Named(Symbol),
-    /// An implicit named parameter, such as the `y` in `format!("{y}")`.
-    NamedInline(Symbol),
-}
-
 /// Where a format parameter is being used in the format string
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub enum FormatParamUsage {
@@ -729,451 +491,6 @@ pub enum FormatParamUsage {
     Precision,
 }
 
-/// A `FormatParam` is any place in a `FormatArgument` that refers to a supplied value, e.g.
-///
-/// ```
-/// let precision = 2;
-/// format!("{:.precision$}", 0.1234);
-/// ```
-///
-/// has two `FormatParam`s, a [`FormatParamKind::Implicit`] `.kind` with a `.value` of `0.1234`
-/// and a [`FormatParamKind::NamedInline("precision")`] `.kind` with a `.value` of `2`
-#[derive(Debug, Copy, Clone)]
-pub struct FormatParam<'tcx> {
-    /// The expression this parameter refers to.
-    pub value: &'tcx Expr<'tcx>,
-    /// How this parameter refers to its `value`.
-    pub kind: FormatParamKind,
-    /// Where this format param is being used - argument/width/precision
-    pub usage: FormatParamUsage,
-    /// Span of the parameter, may be zero width. Includes the whitespace of implicit parameters.
-    ///
-    /// ```text
-    /// format!("{}, {  }, {0}, {name}", ...);
-    ///          ^    ~~    ~    ~~~~
-    /// ```
-    pub span: Span,
-}
-
-impl<'tcx> FormatParam<'tcx> {
-    fn new(
-        mut kind: FormatParamKind,
-        usage: FormatParamUsage,
-        position: usize,
-        inner: rpf::InnerSpan,
-        values: &FormatArgsValues<'tcx>,
-    ) -> Option<Self> {
-        let value_index = *values.pos_to_value_index.get(position)?;
-        let value = *values.value_args.get(value_index)?;
-        let span = span_from_inner(values.format_string_span, inner);
-
-        // if a param is declared inline, e.g. `format!("{x}")`, the generated expr's span points
-        // into the format string
-        if let FormatParamKind::Named(name) = kind && values.format_string_span.contains(value.span.data()) {
-            kind = FormatParamKind::NamedInline(name);
-        }
-
-        Some(Self {
-            value,
-            kind,
-            usage,
-            span,
-        })
-    }
-}
-
-/// Used by [width](https://doc.rust-lang.org/std/fmt/#width) and
-/// [precision](https://doc.rust-lang.org/std/fmt/#precision) specifiers.
-#[derive(Debug, Copy, Clone)]
-pub enum Count<'tcx> {
-    /// Specified with a literal number, stores the value.
-    Is(usize, Span),
-    /// Specified using `$` and `*` syntaxes. The `*` format is still considered to be
-    /// `FormatParamKind::Numbered`.
-    Param(FormatParam<'tcx>),
-    /// Not specified.
-    Implied(Option<Span>),
-}
-
-impl<'tcx> Count<'tcx> {
-    fn new(
-        usage: FormatParamUsage,
-        count: rpf::Count<'_>,
-        position: Option<usize>,
-        inner: Option<rpf::InnerSpan>,
-        values: &FormatArgsValues<'tcx>,
-    ) -> Option<Self> {
-        let span = inner.map(|inner| span_from_inner(values.format_string_span, inner));
-
-        Some(match count {
-            rpf::Count::CountIs(val) => Self::Is(val, span?),
-            rpf::Count::CountIsName(name, _) => Self::Param(FormatParam::new(
-                FormatParamKind::Named(Symbol::intern(name)),
-                usage,
-                position?,
-                inner?,
-                values,
-            )?),
-            rpf::Count::CountIsParam(_) => Self::Param(FormatParam::new(
-                FormatParamKind::Numbered,
-                usage,
-                position?,
-                inner?,
-                values,
-            )?),
-            rpf::Count::CountIsStar(_) => Self::Param(FormatParam::new(
-                FormatParamKind::Starred,
-                usage,
-                position?,
-                inner?,
-                values,
-            )?),
-            rpf::Count::CountImplied => Self::Implied(span),
-        })
-    }
-
-    pub fn is_implied(self) -> bool {
-        matches!(self, Count::Implied(_))
-    }
-
-    pub fn param(self) -> Option<FormatParam<'tcx>> {
-        match self {
-            Count::Param(param) => Some(param),
-            _ => None,
-        }
-    }
-
-    pub fn span(self) -> Option<Span> {
-        match self {
-            Count::Is(_, span) => Some(span),
-            Count::Param(param) => Some(param.span),
-            Count::Implied(span) => span,
-        }
-    }
-}
-
-/// Specification for the formatting of an argument in the format string. See
-/// <https://doc.rust-lang.org/std/fmt/index.html#formatting-parameters> for the precise meanings.
-#[derive(Debug)]
-pub struct FormatSpec<'tcx> {
-    /// Optionally specified character to fill alignment with.
-    pub fill: Option<char>,
-    /// Optionally specified alignment.
-    pub align: Alignment,
-    /// Whether all flag options are set to default (no flags specified).
-    pub no_flags: bool,
-    /// Represents either the maximum width or the integer precision.
-    pub precision: Count<'tcx>,
-    /// The minimum width, will be padded according to `width`/`align`
-    pub width: Count<'tcx>,
-    /// The formatting trait used by the argument, e.g. `sym::Display` for `{}`, `sym::Debug` for
-    /// `{:?}`.
-    pub r#trait: Symbol,
-    pub trait_span: Option<Span>,
-}
-
-impl<'tcx> FormatSpec<'tcx> {
-    fn new(spec: rpf::FormatSpec<'_>, positions: ParamPosition, values: &FormatArgsValues<'tcx>) -> Option<Self> {
-        Some(Self {
-            fill: spec.fill,
-            align: spec.align,
-            no_flags: spec.sign.is_none() && !spec.alternate && !spec.zero_pad && spec.debug_hex.is_none(),
-            precision: Count::new(
-                FormatParamUsage::Precision,
-                spec.precision,
-                positions.precision,
-                spec.precision_span,
-                values,
-            )?,
-            width: Count::new(
-                FormatParamUsage::Width,
-                spec.width,
-                positions.width,
-                spec.width_span,
-                values,
-            )?,
-            r#trait: match spec.ty {
-                "" => sym::Display,
-                "?" => sym::Debug,
-                "o" => sym!(Octal),
-                "x" => sym!(LowerHex),
-                "X" => sym!(UpperHex),
-                "p" => sym::Pointer,
-                "b" => sym!(Binary),
-                "e" => sym!(LowerExp),
-                "E" => sym!(UpperExp),
-                _ => return None,
-            },
-            trait_span: spec
-                .ty_span
-                .map(|span| span_from_inner(values.format_string_span, span)),
-        })
-    }
-
-    /// Returns true if this format spec is unchanged from the default. e.g. returns true for `{}`,
-    /// `{foo}` and `{2}`, but false for `{:?}`, `{foo:5}` and `{3:.5}`
-    pub fn is_default(&self) -> bool {
-        self.r#trait == sym::Display && self.is_default_for_trait()
-    }
-
-    /// Has no other formatting specifiers than setting the format trait. returns true for `{}`,
-    /// `{foo}`, `{:?}`, but false for `{foo:5}`, `{3:.5?}`
-    pub fn is_default_for_trait(&self) -> bool {
-        self.width.is_implied() && self.precision.is_implied() && self.align == Alignment::AlignUnknown && self.no_flags
-    }
-}
-
-/// A format argument, such as `{}`, `{foo:?}`.
-#[derive(Debug)]
-pub struct FormatArg<'tcx> {
-    /// The parameter the argument refers to.
-    pub param: FormatParam<'tcx>,
-    /// How to format `param`.
-    pub format: FormatSpec<'tcx>,
-    /// span of the whole argument, `{..}`.
-    pub span: Span,
-}
-
-/// A parsed `format_args!` expansion.
-#[derive(Debug)]
-pub struct FormatArgsExpn<'tcx> {
-    /// The format string literal.
-    pub format_string: FormatString,
-    /// The format arguments, such as `{:?}`.
-    pub args: Vec<FormatArg<'tcx>>,
-    /// Has an added newline due to `println!()`/`writeln!()`/etc. The last format string part will
-    /// include this added newline.
-    pub newline: bool,
-    /// Spans of the commas between the format string and explicit values, excluding any trailing
-    /// comma
-    ///
-    /// ```ignore
-    /// format!("..", 1, 2, 3,)
-    /// //          ^  ^  ^
-    /// ```
-    comma_spans: Vec<Span>,
-    /// Explicit values passed after the format string, ignoring implicit captures. `[1, z + 2]` for
-    /// `format!("{x} {} {y}", 1, z + 2)`.
-    explicit_values: Vec<&'tcx Expr<'tcx>>,
-}
-
-impl<'tcx> FormatArgsExpn<'tcx> {
-    /// Gets the spans of the commas inbetween the format string and explicit args, not including
-    /// any trailing comma
-    ///
-    /// ```ignore
-    /// format!("{} {}", a, b)
-    /// //             ^  ^
-    /// ```
-    ///
-    /// Ensures that the format string and values aren't coming from a proc macro that sets the
-    /// output span to that of its input
-    fn comma_spans(cx: &LateContext<'_>, explicit_values: &[&Expr<'_>], fmt_span: Span) -> Option<Vec<Span>> {
-        // `format!("{} {} {c}", "one", "two", c = "three")`
-        //                       ^^^^^  ^^^^^      ^^^^^^^
-        let value_spans = explicit_values
-            .iter()
-            .map(|val| hygiene::walk_chain(val.span, fmt_span.ctxt()));
-
-        // `format!("{} {} {c}", "one", "two", c = "three")`
-        //                     ^^     ^^     ^^^^^^
-        let between_spans = once(fmt_span)
-            .chain(value_spans)
-            .tuple_windows()
-            .map(|(start, end)| start.between(end));
-
-        let mut comma_spans = Vec::new();
-        for between_span in between_spans {
-            let mut offset = 0;
-            let mut seen_comma = false;
-
-            for token in tokenize(&snippet_opt(cx, between_span)?) {
-                match token.kind {
-                    TokenKind::LineComment { .. } | TokenKind::BlockComment { .. } | TokenKind::Whitespace => {},
-                    TokenKind::Comma if !seen_comma => {
-                        seen_comma = true;
-
-                        let base = between_span.data();
-                        comma_spans.push(Span::new(
-                            base.lo + BytePos(offset),
-                            base.lo + BytePos(offset + 1),
-                            base.ctxt,
-                            base.parent,
-                        ));
-                    },
-                    // named arguments, `start_val, name = end_val`
-                    //                            ^^^^^^^^^ between_span
-                    TokenKind::Ident | TokenKind::Eq if seen_comma => {},
-                    // An unexpected token usually indicates the format string or a value came from a proc macro output
-                    // that sets the span of its output to an input, e.g. `println!(some_proc_macro!("input"), ..)` that
-                    // emits a string literal with the span set to that of `"input"`
-                    _ => return None,
-                }
-                offset += token.len;
-            }
-
-            if !seen_comma {
-                return None;
-            }
-        }
-
-        Some(comma_spans)
-    }
-
-    pub fn parse(cx: &LateContext<'_>, expr: &'tcx Expr<'tcx>) -> Option<Self> {
-        let macro_name = macro_backtrace(expr.span)
-            .map(|macro_call| cx.tcx.item_name(macro_call.def_id))
-            .find(|&name| matches!(name, sym::const_format_args | sym::format_args | sym::format_args_nl))?;
-        let newline = macro_name == sym::format_args_nl;
-
-        // ::core::fmt::Arguments::new_const(pieces)
-        // ::core::fmt::Arguments::new_v1(pieces, args)
-        // ::core::fmt::Arguments::new_v1_formatted(pieces, args, fmt, _unsafe_arg)
-        if let ExprKind::Call(callee, [pieces, rest @ ..]) = expr.kind
-            && let ExprKind::Path(QPath::TypeRelative(ty, seg)) = callee.kind
-            && let TyKind::Path(QPath::LangItem(LangItem::FormatArguments, _, _)) = ty.kind
-            && matches!(seg.ident.as_str(), "new_const" | "new_v1" | "new_v1_formatted")
-        {
-            let format_string = FormatString::new(cx, pieces)?;
-
-            let mut parser = rpf::Parser::new(
-                &format_string.unescaped,
-                format_string.style,
-                Some(format_string.snippet.clone()),
-                // `format_string.unescaped` does not contain the appended newline
-                false,
-                rpf::ParseMode::Format,
-            );
-
-            let parsed_args = parser
-                .by_ref()
-                .filter_map(|piece| match piece {
-                    rpf::Piece::NextArgument(a) => Some(a),
-                    rpf::Piece::String(_) => None,
-                })
-                .collect_vec();
-            if !parser.errors.is_empty() {
-                return None;
-            }
-
-            let positions = if let Some(fmt_arg) = rest.get(1) {
-                // If the argument contains format specs, `new_v1_formatted(_, _, fmt, _)`, parse
-                // them.
-
-                Either::Left(parse_rt_fmt(fmt_arg)?)
-            } else {
-                // If no format specs are given, the positions are in the given order and there are
-                // no `precision`/`width`s to consider.
-
-                Either::Right((0..).map(|n| ParamPosition {
-                    value: n,
-                    width: None,
-                    precision: None,
-                }))
-            };
-
-            let values = if let Some(args) = rest.first() {
-                FormatArgsValues::new(args, format_string.span.data())
-            } else {
-                FormatArgsValues::new_empty(format_string.span.data())
-            };
-
-            let args = izip!(positions, parsed_args, parser.arg_places)
-                .map(|(position, parsed_arg, arg_span)| {
-                    Some(FormatArg {
-                        param: FormatParam::new(
-                            match parsed_arg.position {
-                                rpf::Position::ArgumentImplicitlyIs(_) => FormatParamKind::Implicit,
-                                rpf::Position::ArgumentIs(_) => FormatParamKind::Numbered,
-                                // NamedInline is handled by `FormatParam::new()`
-                                rpf::Position::ArgumentNamed(name) => FormatParamKind::Named(Symbol::intern(name)),
-                            },
-                            FormatParamUsage::Argument,
-                            position.value,
-                            parsed_arg.position_span,
-                            &values,
-                        )?,
-                        format: FormatSpec::new(parsed_arg.format, position, &values)?,
-                        span: span_from_inner(values.format_string_span, arg_span),
-                    })
-                })
-                .collect::<Option<Vec<_>>>()?;
-
-            let mut explicit_values = values.value_args;
-            // remove values generated for implicitly captured vars
-            let len = explicit_values
-                .iter()
-                .take_while(|val| !format_string.span.contains(val.span))
-                .count();
-            explicit_values.truncate(len);
-
-            let comma_spans = Self::comma_spans(cx, &explicit_values, format_string.span)?;
-
-            Some(Self {
-                format_string,
-                args,
-                newline,
-                comma_spans,
-                explicit_values,
-            })
-        } else {
-            None
-        }
-    }
-
-    pub fn find_nested(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, expn_id: ExpnId) -> Option<Self> {
-        for_each_expr(expr, |e| {
-            let e_ctxt = e.span.ctxt();
-            if e_ctxt == expr.span.ctxt() {
-                ControlFlow::Continue(Descend::Yes)
-            } else if e_ctxt.outer_expn().is_descendant_of(expn_id) {
-                if let Some(args) = FormatArgsExpn::parse(cx, e) {
-                    ControlFlow::Break(args)
-                } else {
-                    ControlFlow::Continue(Descend::No)
-                }
-            } else {
-                ControlFlow::Continue(Descend::No)
-            }
-        })
-    }
-
-    /// Source callsite span of all inputs
-    pub fn inputs_span(&self) -> Span {
-        match *self.explicit_values {
-            [] => self.format_string.span,
-            [.., last] => self
-                .format_string
-                .span
-                .to(hygiene::walk_chain(last.span, self.format_string.span.ctxt())),
-        }
-    }
-
-    /// Get the span of a value expanded to the previous comma, e.g. for the value `10`
-    ///
-    /// ```ignore
-    /// format("{}.{}", 10, 11)
-    /// //            ^^^^
-    /// ```
-    pub fn value_with_prev_comma_span(&self, value_id: HirId) -> Option<Span> {
-        for (comma_span, value) in zip(&self.comma_spans, &self.explicit_values) {
-            if value.hir_id == value_id {
-                return Some(comma_span.to(hygiene::walk_chain(value.span, comma_span.ctxt())));
-            }
-        }
-
-        None
-    }
-
-    /// Iterator of all format params, both values and those referenced by `width`/`precision`s.
-    pub fn params(&'tcx self) -> impl Iterator<Item = FormatParam<'tcx>> {
-        self.args
-            .iter()
-            .flat_map(|arg| [Some(arg.param), arg.format.precision.param(), arg.format.width.param()])
-            .flatten()
-    }
-}
-
 /// A node with a `HirId` and a `Span`
 pub trait HirNode {
     fn hir_id(&self) -> HirId;
-- 
cgit 1.4.1-3-g733a5


From 6681914b541d32f0dbd991498dc36d6b44674aa2 Mon Sep 17 00:00:00 2001
From: asquared31415 <34665709+asquared31415@users.noreply.github.com>
Date: Tue, 28 Mar 2023 23:30:20 -0400
Subject: make cast_possible_wrap not lint on conversions for sizes that cannot
 wrap, and make it work correctly for 16 bit {u,i}size

---
 clippy_lints/src/casts/cast_possible_wrap.rs |  82 +++++++++++++++-----
 clippy_lints/src/casts/mod.rs                |   7 +-
 tests/ui/cast.rs                             |   8 ++
 tests/ui/cast.stderr                         | 112 +++++++++++++++++++++++----
 4 files changed, 171 insertions(+), 38 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/cast_possible_wrap.rs b/clippy_lints/src/casts/cast_possible_wrap.rs
index 28ecdea7ea0..e872d190c82 100644
--- a/clippy_lints/src/casts/cast_possible_wrap.rs
+++ b/clippy_lints/src/casts/cast_possible_wrap.rs
@@ -1,41 +1,81 @@
 use clippy_utils::diagnostics::span_lint;
-use clippy_utils::ty::is_isize_or_usize;
 use rustc_hir::Expr;
 use rustc_lint::LateContext;
 use rustc_middle::ty::Ty;
 
 use super::{utils, CAST_POSSIBLE_WRAP};
 
+// this should be kept in sync with the allowed bit widths of `usize` and `isize`
+const ALLOWED_POINTER_SIZES: [u64; 3] = [16, 32, 64];
+
+// whether the lint should be emitted, and the required pointer size, if it matters
+enum EmitState {
+    NoLint,
+    LintAlways,
+    LintOnPtrSize(u64),
+}
+
 pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_from: Ty<'_>, cast_to: Ty<'_>) {
     if !(cast_from.is_integral() && cast_to.is_integral()) {
         return;
     }
 
-    let arch_64_suffix = " on targets with 64-bit wide pointers";
-    let arch_32_suffix = " on targets with 32-bit wide pointers";
-    let cast_unsigned_to_signed = !cast_from.is_signed() && cast_to.is_signed();
+    // emit a lint if a cast is:
+    // 1. unsigned to signed
+    // and
+    // 2. either:
+    //    2a. between two types of constant size that are always the same size
+    //    2b. between one target-dependent size and one constant size integer,
+    //        and the constant integer is in the allowed set of target dependent sizes
+    //        (the ptr size could be chosen to be the same as the constant size)
+
+    if cast_from.is_signed() || !cast_to.is_signed() {
+        return;
+    }
+
     let from_nbits = utils::int_ty_to_nbits(cast_from, cx.tcx);
     let to_nbits = utils::int_ty_to_nbits(cast_to, cx.tcx);
 
-    let (should_lint, suffix) = match (is_isize_or_usize(cast_from), is_isize_or_usize(cast_to)) {
-        (true, true) | (false, false) => (to_nbits == from_nbits && cast_unsigned_to_signed, ""),
-        (true, false) => (to_nbits <= 32 && cast_unsigned_to_signed, arch_32_suffix),
-        (false, true) => (
-            cast_unsigned_to_signed,
-            if from_nbits == 64 {
-                arch_64_suffix
+    let should_lint = match (cast_from.is_ptr_sized_integral(), cast_to.is_ptr_sized_integral()) {
+        (true, true) => {
+            // casts between two ptr sized integers are trivially always the same size
+            // so do not depend on any specific pointer size to be the same
+            EmitState::LintAlways
+        },
+        (true, false) => {
+            // the first type is `usize` and the second is a constant sized signed integer
+            if ALLOWED_POINTER_SIZES.contains(&to_nbits) {
+                EmitState::LintOnPtrSize(to_nbits)
+            } else {
+                EmitState::NoLint
+            }
+        },
+        (false, true) => {
+            // the first type is a constant sized unsigned integer, and the second is `isize`
+            if ALLOWED_POINTER_SIZES.contains(&from_nbits) {
+                EmitState::LintOnPtrSize(from_nbits)
+            } else {
+                EmitState::NoLint
+            }
+        },
+        (false, false) => {
+            // the types are both a constant known size
+            // and do not depend on any specific pointer size to be the same
+            if from_nbits == to_nbits {
+                EmitState::LintAlways
             } else {
-                arch_32_suffix
-            },
+                EmitState::NoLint
+            }
+        },
+    };
+
+    let message = match should_lint {
+        EmitState::NoLint => return,
+        EmitState::LintAlways => format!("casting `{cast_from}` to `{cast_to}` may wrap around the value"),
+        EmitState::LintOnPtrSize(ptr_size) => format!(
+            "casting `{cast_from}` to `{cast_to}` may wrap around the value on targets with {ptr_size}-bit wide pointers",
         ),
     };
 
-    if should_lint {
-        span_lint(
-            cx,
-            CAST_POSSIBLE_WRAP,
-            expr.span,
-            &format!("casting `{cast_from}` to `{cast_to}` may wrap around the value{suffix}",),
-        );
-    }
+    span_lint(cx, CAST_POSSIBLE_WRAP, expr.span, message.as_str());
 }
diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index 362f70d12d1..877bee5e4d1 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -118,9 +118,10 @@ declare_clippy_lint! {
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for casts from an unsigned type to a signed type of
-    /// the same size. Performing such a cast is a 'no-op' for the compiler,
-    /// i.e., nothing is changed at the bit level, and the binary representation of
-    /// the value is reinterpreted. This can cause wrapping if the value is too big
+    /// the same size, or possibly smaller due to target dependent integers.
+    /// Performing such a cast is a 'no-op' for the compiler, i.e., nothing is
+    /// changed at the bit level, and the binary representation of the value is
+    /// reinterpreted. This can cause wrapping if the value is too big
     /// for the target signed type. However, the cast works as defined, so this lint
     /// is `Allow` by default.
     ///
diff --git a/tests/ui/cast.rs b/tests/ui/cast.rs
index a86b85706a3..60a0eabf55b 100644
--- a/tests/ui/cast.rs
+++ b/tests/ui/cast.rs
@@ -41,6 +41,14 @@ fn main() {
     1u32 as i32;
     1u64 as i64;
     1usize as isize;
+    1usize as i8; // should not wrap, usize is never 8 bits
+    1usize as i16; // wraps on 16 bit ptr size
+    1usize as i32; // wraps on 32 bit ptr size
+    1usize as i64; // wraps on 64 bit ptr size
+    1u8 as isize; // should not wrap, isize is never 8 bits
+    1u16 as isize; // wraps on 16 bit ptr size
+    1u32 as isize; // wraps on 32 bit ptr size
+    1u64 as isize; // wraps on 64 bit ptr size
     // Test clippy::cast_sign_loss
     1i32 as u32;
     -1i32 as u32;
diff --git a/tests/ui/cast.stderr b/tests/ui/cast.stderr
index 65ecf1aa37a..a7d78a95d59 100644
--- a/tests/ui/cast.stderr
+++ b/tests/ui/cast.stderr
@@ -215,20 +215,104 @@ error: casting `usize` to `isize` may wrap around the value
 LL |     1usize as isize;
    |     ^^^^^^^^^^^^^^^
 
-error: casting `i32` to `u32` may lose the sign of the value
+error: casting `usize` to `i8` may truncate the value
+  --> $DIR/cast.rs:44:5
+   |
+LL |     1usize as i8; // should not wrap, usize is never 8 bits
+   |     ^^^^^^^^^^^^
+   |
+   = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
+help: ... or use `try_from` and handle the error accordingly
+   |
+LL |     i8::try_from(1usize); // should not wrap, usize is never 8 bits
+   |     ~~~~~~~~~~~~~~~~~~~~
+
+error: casting `usize` to `i16` may truncate the value
+  --> $DIR/cast.rs:45:5
+   |
+LL |     1usize as i16; // wraps on 16 bit ptr size
+   |     ^^^^^^^^^^^^^
+   |
+   = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
+help: ... or use `try_from` and handle the error accordingly
+   |
+LL |     i16::try_from(1usize); // wraps on 16 bit ptr size
+   |     ~~~~~~~~~~~~~~~~~~~~~
+
+error: casting `usize` to `i16` may wrap around the value on targets with 16-bit wide pointers
+  --> $DIR/cast.rs:45:5
+   |
+LL |     1usize as i16; // wraps on 16 bit ptr size
+   |     ^^^^^^^^^^^^^
+
+error: casting `usize` to `i32` may truncate the value on targets with 64-bit wide pointers
   --> $DIR/cast.rs:46:5
    |
+LL |     1usize as i32; // wraps on 32 bit ptr size
+   |     ^^^^^^^^^^^^^
+   |
+   = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
+help: ... or use `try_from` and handle the error accordingly
+   |
+LL |     i32::try_from(1usize); // wraps on 32 bit ptr size
+   |     ~~~~~~~~~~~~~~~~~~~~~
+
+error: casting `usize` to `i32` may wrap around the value on targets with 32-bit wide pointers
+  --> $DIR/cast.rs:46:5
+   |
+LL |     1usize as i32; // wraps on 32 bit ptr size
+   |     ^^^^^^^^^^^^^
+
+error: casting `usize` to `i64` may wrap around the value on targets with 64-bit wide pointers
+  --> $DIR/cast.rs:47:5
+   |
+LL |     1usize as i64; // wraps on 64 bit ptr size
+   |     ^^^^^^^^^^^^^
+
+error: casting `u16` to `isize` may wrap around the value on targets with 16-bit wide pointers
+  --> $DIR/cast.rs:49:5
+   |
+LL |     1u16 as isize; // wraps on 16 bit ptr size
+   |     ^^^^^^^^^^^^^
+
+error: casting `u32` to `isize` may wrap around the value on targets with 32-bit wide pointers
+  --> $DIR/cast.rs:50:5
+   |
+LL |     1u32 as isize; // wraps on 32 bit ptr size
+   |     ^^^^^^^^^^^^^
+
+error: casting `u64` to `isize` may truncate the value on targets with 32-bit wide pointers
+  --> $DIR/cast.rs:51:5
+   |
+LL |     1u64 as isize; // wraps on 64 bit ptr size
+   |     ^^^^^^^^^^^^^
+   |
+   = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
+help: ... or use `try_from` and handle the error accordingly
+   |
+LL |     isize::try_from(1u64); // wraps on 64 bit ptr size
+   |     ~~~~~~~~~~~~~~~~~~~~~
+
+error: casting `u64` to `isize` may wrap around the value on targets with 64-bit wide pointers
+  --> $DIR/cast.rs:51:5
+   |
+LL |     1u64 as isize; // wraps on 64 bit ptr size
+   |     ^^^^^^^^^^^^^
+
+error: casting `i32` to `u32` may lose the sign of the value
+  --> $DIR/cast.rs:54:5
+   |
 LL |     -1i32 as u32;
    |     ^^^^^^^^^^^^
 
 error: casting `isize` to `usize` may lose the sign of the value
-  --> $DIR/cast.rs:48:5
+  --> $DIR/cast.rs:56:5
    |
 LL |     -1isize as usize;
    |     ^^^^^^^^^^^^^^^^
 
 error: casting `i64` to `i8` may truncate the value
-  --> $DIR/cast.rs:115:5
+  --> $DIR/cast.rs:123:5
    |
 LL |     (-99999999999i64).min(1) as i8; // should be linted because signed
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -240,7 +324,7 @@ LL |     i8::try_from((-99999999999i64).min(1)); // should be linted because sig
    |     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 error: casting `u64` to `u8` may truncate the value
-  --> $DIR/cast.rs:127:5
+  --> $DIR/cast.rs:135:5
    |
 LL |     999999u64.clamp(0, 256) as u8; // should still be linted
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -252,7 +336,7 @@ LL |     u8::try_from(999999u64.clamp(0, 256)); // should still be linted
    |     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 error: casting `main::E2` to `u8` may truncate the value
-  --> $DIR/cast.rs:148:21
+  --> $DIR/cast.rs:156:21
    |
 LL |             let _ = self as u8;
    |                     ^^^^^^^^^^
@@ -264,7 +348,7 @@ LL |             let _ = u8::try_from(self);
    |                     ~~~~~~~~~~~~~~~~~~
 
 error: casting `main::E2::B` to `u8` will truncate the value
-  --> $DIR/cast.rs:149:21
+  --> $DIR/cast.rs:157:21
    |
 LL |             let _ = Self::B as u8;
    |                     ^^^^^^^^^^^^^
@@ -272,7 +356,7 @@ LL |             let _ = Self::B as u8;
    = note: `-D clippy::cast-enum-truncation` implied by `-D warnings`
 
 error: casting `main::E5` to `i8` may truncate the value
-  --> $DIR/cast.rs:185:21
+  --> $DIR/cast.rs:193:21
    |
 LL |             let _ = self as i8;
    |                     ^^^^^^^^^^
@@ -284,13 +368,13 @@ LL |             let _ = i8::try_from(self);
    |                     ~~~~~~~~~~~~~~~~~~
 
 error: casting `main::E5::A` to `i8` will truncate the value
-  --> $DIR/cast.rs:186:21
+  --> $DIR/cast.rs:194:21
    |
 LL |             let _ = Self::A as i8;
    |                     ^^^^^^^^^^^^^
 
 error: casting `main::E6` to `i16` may truncate the value
-  --> $DIR/cast.rs:200:21
+  --> $DIR/cast.rs:208:21
    |
 LL |             let _ = self as i16;
    |                     ^^^^^^^^^^^
@@ -302,7 +386,7 @@ LL |             let _ = i16::try_from(self);
    |                     ~~~~~~~~~~~~~~~~~~~
 
 error: casting `main::E7` to `usize` may truncate the value on targets with 32-bit wide pointers
-  --> $DIR/cast.rs:215:21
+  --> $DIR/cast.rs:223:21
    |
 LL |             let _ = self as usize;
    |                     ^^^^^^^^^^^^^
@@ -314,7 +398,7 @@ LL |             let _ = usize::try_from(self);
    |                     ~~~~~~~~~~~~~~~~~~~~~
 
 error: casting `main::E10` to `u16` may truncate the value
-  --> $DIR/cast.rs:256:21
+  --> $DIR/cast.rs:264:21
    |
 LL |             let _ = self as u16;
    |                     ^^^^^^^^^^^
@@ -326,7 +410,7 @@ LL |             let _ = u16::try_from(self);
    |                     ~~~~~~~~~~~~~~~~~~~
 
 error: casting `u32` to `u8` may truncate the value
-  --> $DIR/cast.rs:264:13
+  --> $DIR/cast.rs:272:13
    |
 LL |     let c = (q >> 16) as u8;
    |             ^^^^^^^^^^^^^^^
@@ -338,7 +422,7 @@ LL |     let c = u8::try_from(q >> 16);
    |             ~~~~~~~~~~~~~~~~~~~~~
 
 error: casting `u32` to `u8` may truncate the value
-  --> $DIR/cast.rs:267:13
+  --> $DIR/cast.rs:275:13
    |
 LL |     let c = (q / 1000) as u8;
    |             ^^^^^^^^^^^^^^^^
@@ -349,5 +433,5 @@ help: ... or use `try_from` and handle the error accordingly
 LL |     let c = u8::try_from(q / 1000);
    |             ~~~~~~~~~~~~~~~~~~~~~~
 
-error: aborting due to 41 previous errors
+error: aborting due to 51 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 4f5a019d6e836ff4b56154bf6c646cc358310fa9 Mon Sep 17 00:00:00 2001
From: csmoe <csmoe@msn.com>
Date: Wed, 29 Mar 2023 15:12:20 +0800
Subject: Update clippy_lints/src/large_futures.rs

Co-authored-by: Fridtjof Stoldt <xFrednet@gmail.com>
---
 clippy_lints/src/large_futures.rs                | 45 +++++++++----------
 tests/ui-toml/large_futures/large_futures.fixed  | 29 ------------
 tests/ui-toml/large_futures/large_futures.rs     |  2 -
 tests/ui-toml/large_futures/large_futures.stderr |  2 +-
 tests/ui/large_futures.fixed                     | 41 -----------------
 tests/ui/large_futures.rs                        | 24 +++++++++-
 tests/ui/large_futures.stderr                    | 56 +++++++++++++++++++++---
 7 files changed, 93 insertions(+), 106 deletions(-)
 delete mode 100644 tests/ui-toml/large_futures/large_futures.fixed
 delete mode 100644 tests/ui/large_futures.fixed

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/large_futures.rs b/clippy_lints/src/large_futures.rs
index 494bb2a97d2..1b054481371 100644
--- a/clippy_lints/src/large_futures.rs
+++ b/clippy_lints/src/large_futures.rs
@@ -59,31 +59,28 @@ impl_lint_pass!(LargeFuture => [LARGE_FUTURES]);
 
 impl<'tcx> LateLintPass<'tcx> for LargeFuture {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
+        if matches!(expr.span.ctxt().outer_expn_data().kind, rustc_span::ExpnKind::Macro(..)) {
+            return;
+        }
         if let ExprKind::Match(expr, _, MatchSource::AwaitDesugar) = expr.kind {
-            if let ExprKind::Call(func, [expr, ..]) = expr.kind {
-                if matches!(
-                    func.kind,
-                    ExprKind::Path(QPath::LangItem(LangItem::IntoFutureIntoFuture, ..))
-                ) {
-                    let ty = cx.typeck_results().expr_ty(expr);
-                    if let Some(future_trait_def_id) = cx.tcx.lang_items().future_trait()
-                        && implements_trait(cx, ty, future_trait_def_id, &[]) {
-                            if let Ok(layout) = cx.tcx.layout_of(cx.param_env.and(ty)) {
-                                let size = layout.layout.size();
-                                if size >= Size::from_bytes(self.future_size_threshold) {
-                                    span_lint_and_sugg(
-                                        cx,
-                                        LARGE_FUTURES,
-                                        expr.span,
-                                        &format!("large future with a size of {} bytes", size.bytes()),
-                                        "consider `Box::pin` on it",
-                                        format!("Box::pin({})", snippet(cx, expr.span, "..")),
-                                        Applicability::MachineApplicable,
-                                    );
-                                }
-                            }
-                        }
-                }
+            if let ExprKind::Call(func, [expr, ..]) = expr.kind
+                && let ExprKind::Path(QPath::LangItem(LangItem::IntoFutureIntoFuture, ..)) = func.kind
+                && let ty = cx.typeck_results().expr_ty(expr)
+                && let Some(future_trait_def_id) = cx.tcx.lang_items().future_trait()
+                && implements_trait(cx, ty, future_trait_def_id, &[])
+                && let Ok(layout) = cx.tcx.layout_of(cx.param_env.and(ty))
+                && let size = layout.layout.size()
+                && size >= Size::from_bytes(self.future_size_threshold)
+            {
+                span_lint_and_sugg(
+                    cx,
+                    LARGE_FUTURES,
+                    expr.span,
+                    &format!("large future with a size of {} bytes", size.bytes()),
+                    "consider `Box::pin` on it",
+                    format!("Box::pin({})", snippet(cx, expr.span, "..")),
+                    Applicability::Unspecified,
+                );
             }
         }
     }
diff --git a/tests/ui-toml/large_futures/large_futures.fixed b/tests/ui-toml/large_futures/large_futures.fixed
deleted file mode 100644
index 1238c512b0f..00000000000
--- a/tests/ui-toml/large_futures/large_futures.fixed
+++ /dev/null
@@ -1,29 +0,0 @@
-// run-rustfix
-
-#![warn(clippy::large_futures)]
-
-fn main() {}
-
-pub async fn should_warn() {
-    let x = [0u8; 1024];
-    async {}.await;
-    dbg!(x);
-}
-
-pub async fn should_not_warn() {
-    let x = [0u8; 1020];
-    async {}.await;
-    dbg!(x);
-}
-
-pub async fn bar() {
-    Box::pin(should_warn()).await;
-
-    async {
-        let x = [0u8; 1024];
-        dbg!(x);
-    }
-    .await;
-
-    should_not_warn().await;
-}
diff --git a/tests/ui-toml/large_futures/large_futures.rs b/tests/ui-toml/large_futures/large_futures.rs
index 80039d9047b..4158df8b5ff 100644
--- a/tests/ui-toml/large_futures/large_futures.rs
+++ b/tests/ui-toml/large_futures/large_futures.rs
@@ -1,5 +1,3 @@
-// run-rustfix
-
 #![warn(clippy::large_futures)]
 
 fn main() {}
diff --git a/tests/ui-toml/large_futures/large_futures.stderr b/tests/ui-toml/large_futures/large_futures.stderr
index f7895f8eaf7..b92734de2f0 100644
--- a/tests/ui-toml/large_futures/large_futures.stderr
+++ b/tests/ui-toml/large_futures/large_futures.stderr
@@ -1,5 +1,5 @@
 error: large future with a size of 1026 bytes
-  --> $DIR/large_futures.rs:20:5
+  --> $DIR/large_futures.rs:18:5
    |
 LL |     should_warn().await;
    |     ^^^^^^^^^^^^^ help: consider `Box::pin` on it: `Box::pin(should_warn())`
diff --git a/tests/ui/large_futures.fixed b/tests/ui/large_futures.fixed
deleted file mode 100644
index 9d839998afd..00000000000
--- a/tests/ui/large_futures.fixed
+++ /dev/null
@@ -1,41 +0,0 @@
-// run-rustfix
-
-#![feature(generators)]
-#![warn(clippy::large_futures)]
-#![allow(clippy::future_not_send)]
-#![allow(clippy::manual_async_fn)]
-
-async fn big_fut(_arg: [u8; 1024 * 16]) {}
-
-async fn wait() {
-    let f = async {
-        Box::pin(big_fut([0u8; 1024 * 16])).await;
-    };
-    Box::pin(f).await
-}
-async fn calls_fut(fut: impl std::future::Future<Output = ()>) {
-    loop {
-        Box::pin(wait()).await;
-        if true {
-            return fut.await;
-        } else {
-            Box::pin(wait()).await;
-        }
-    }
-}
-
-pub async fn test() {
-    let fut = big_fut([0u8; 1024 * 16]);
-    Box::pin(foo()).await;
-    Box::pin(calls_fut(fut)).await;
-}
-
-pub fn foo() -> impl std::future::Future<Output = ()> {
-    async {
-        let x = [0i32; 1024 * 16];
-        async {}.await;
-        dbg!(x);
-    }
-}
-
-fn main() {}
diff --git a/tests/ui/large_futures.rs b/tests/ui/large_futures.rs
index 8b7aaa61b88..4a8ba995da5 100644
--- a/tests/ui/large_futures.rs
+++ b/tests/ui/large_futures.rs
@@ -1,5 +1,3 @@
-// run-rustfix
-
 #![feature(generators)]
 #![warn(clippy::large_futures)]
 #![allow(clippy::future_not_send)]
@@ -38,4 +36,26 @@ pub fn foo() -> impl std::future::Future<Output = ()> {
     }
 }
 
+pub async fn lines() {
+    async {
+        let x = [0i32; 1024 * 16];
+        async {}.await;
+        println!("{:?}", x);
+    }
+    .await;
+}
+
+pub async fn macro_expn() {
+    macro_rules! macro_ {
+        () => {
+            async {
+                let x = [0i32; 1024 * 16];
+                async {}.await;
+                println!("macro: {:?}", x);
+            }
+        };
+    }
+    macro_!().await
+}
+
 fn main() {}
diff --git a/tests/ui/large_futures.stderr b/tests/ui/large_futures.stderr
index 557455299a9..67e0fceff6e 100644
--- a/tests/ui/large_futures.stderr
+++ b/tests/ui/large_futures.stderr
@@ -1,5 +1,5 @@
 error: large future with a size of 16385 bytes
-  --> $DIR/large_futures.rs:12:9
+  --> $DIR/large_futures.rs:10:9
    |
 LL |         big_fut([0u8; 1024 * 16]).await;
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider `Box::pin` on it: `Box::pin(big_fut([0u8; 1024 * 16]))`
@@ -7,34 +7,76 @@ LL |         big_fut([0u8; 1024 * 16]).await;
    = note: `-D clippy::large-futures` implied by `-D warnings`
 
 error: large future with a size of 16386 bytes
-  --> $DIR/large_futures.rs:14:5
+  --> $DIR/large_futures.rs:12:5
    |
 LL |     f.await
    |     ^ help: consider `Box::pin` on it: `Box::pin(f)`
 
 error: large future with a size of 16387 bytes
-  --> $DIR/large_futures.rs:18:9
+  --> $DIR/large_futures.rs:16:9
    |
 LL |         wait().await;
    |         ^^^^^^ help: consider `Box::pin` on it: `Box::pin(wait())`
 
 error: large future with a size of 16387 bytes
-  --> $DIR/large_futures.rs:22:13
+  --> $DIR/large_futures.rs:20:13
    |
 LL |             wait().await;
    |             ^^^^^^ help: consider `Box::pin` on it: `Box::pin(wait())`
 
 error: large future with a size of 65540 bytes
-  --> $DIR/large_futures.rs:29:5
+  --> $DIR/large_futures.rs:27:5
    |
 LL |     foo().await;
    |     ^^^^^ help: consider `Box::pin` on it: `Box::pin(foo())`
 
 error: large future with a size of 49159 bytes
-  --> $DIR/large_futures.rs:30:5
+  --> $DIR/large_futures.rs:28:5
    |
 LL |     calls_fut(fut).await;
    |     ^^^^^^^^^^^^^^ help: consider `Box::pin` on it: `Box::pin(calls_fut(fut))`
 
-error: aborting due to 6 previous errors
+error: large future with a size of 65540 bytes
+  --> $DIR/large_futures.rs:40:5
+   |
+LL | /     async {
+LL | |         let x = [0i32; 1024 * 16];
+LL | |         async {}.await;
+LL | |         println!("{:?}", x);
+LL | |     }
+   | |_____^
+   |
+help: consider `Box::pin` on it
+   |
+LL ~     Box::pin(async {
+LL +         let x = [0i32; 1024 * 16];
+LL +         async {}.await;
+LL +         println!("{:?}", x);
+LL +     })
+   |
+
+error: large future with a size of 65540 bytes
+  --> $DIR/large_futures.rs:51:13
+   |
+LL | /             async {
+LL | |                 let x = [0i32; 1024 * 16];
+LL | |                 async {}.await;
+LL | |                 println!("macro: {:?}", x);
+LL | |             }
+   | |_____________^
+...
+LL |       macro_!().await
+   |       --------- in this macro invocation
+   |
+   = note: this error originates in the macro `macro_` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: consider `Box::pin` on it
+   |
+LL ~             Box::pin(async {
+LL +                 let x = [0i32; 1024 * 16];
+LL +                 async {}.await;
+LL +                 println!("macro: {:?}", x);
+LL +             })
+   |
+
+error: aborting due to 8 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From a2165533e1b5797e1043b961b4d5aaa599e8a305 Mon Sep 17 00:00:00 2001
From: Elliot Bobrow <elliotgreybobrow@gmail.com>
Date: Wed, 29 Mar 2023 18:19:29 -0700
Subject: fix `single_component_path_imports` FP

---
 clippy_lints/src/single_component_path_imports.rs | 59 ++++++++++++++++++-----
 tests/ui/single_component_path_imports.fixed      |  6 +++
 tests/ui/single_component_path_imports.rs         |  6 +++
 tests/ui/single_component_path_imports.stderr     |  4 +-
 4 files changed, 60 insertions(+), 15 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/single_component_path_imports.rs b/clippy_lints/src/single_component_path_imports.rs
index d46f6a6352c..5743dd21c28 100644
--- a/clippy_lints/src/single_component_path_imports.rs
+++ b/clippy_lints/src/single_component_path_imports.rs
@@ -1,6 +1,7 @@
 use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg};
 use rustc_ast::node_id::{NodeId, NodeMap};
-use rustc_ast::{ptr::P, Crate, Item, ItemKind, MacroDef, ModKind, UseTreeKind};
+use rustc_ast::visit::{walk_expr, Visitor};
+use rustc_ast::{ptr::P, Crate, Expr, ExprKind, Item, ItemKind, MacroDef, ModKind, Ty, TyKind, UseTreeKind};
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
@@ -55,7 +56,7 @@ impl EarlyLintPass for SingleComponentPathImports {
             return;
         }
 
-        self.check_mod(cx, &krate.items);
+        self.check_mod(&krate.items);
     }
 
     fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {
@@ -84,8 +85,43 @@ impl EarlyLintPass for SingleComponentPathImports {
     }
 }
 
+#[derive(Default)]
+struct ImportUsageVisitor {
+    // keep track of imports reused with `self` keyword, such as `self::std` in the example below.
+    // Removing the `use std;` would make this a compile error (#10549)
+    // ```
+    // use std;
+    //
+    // fn main() {
+    //     let _ = self::std::io::stdout();
+    // }
+    // ```
+    imports_referenced_with_self: Vec<Symbol>,
+}
+
+impl<'tcx> Visitor<'tcx> for ImportUsageVisitor {
+    fn visit_expr(&mut self, expr: &Expr) {
+        if let ExprKind::Path(_, path) = &expr.kind
+            && path.segments.len() > 1
+            && path.segments[0].ident.name == kw::SelfLower
+        {
+            self.imports_referenced_with_self.push(path.segments[1].ident.name);
+        }
+        walk_expr(self, expr);
+    }
+
+    fn visit_ty(&mut self, ty: &Ty) {
+        if let TyKind::Path(_, path) = &ty.kind
+            && path.segments.len() > 1
+            && path.segments[0].ident.name == kw::SelfLower
+        {
+            self.imports_referenced_with_self.push(path.segments[1].ident.name);
+        }
+    }
+}
+
 impl SingleComponentPathImports {
-    fn check_mod(&mut self, cx: &EarlyContext<'_>, items: &[P<Item>]) {
+    fn check_mod(&mut self, items: &[P<Item>]) {
         // keep track of imports reused with `self` keyword, such as `self::crypto_hash` in the example
         // below. Removing the `use crypto_hash;` would make this a compile error
         // ```
@@ -108,18 +144,16 @@ impl SingleComponentPathImports {
         // ```
         let mut macros = Vec::new();
 
+        let mut import_usage_visitor = ImportUsageVisitor::default();
         for item in items {
-            self.track_uses(
-                cx,
-                item,
-                &mut imports_reused_with_self,
-                &mut single_use_usages,
-                &mut macros,
-            );
+            self.track_uses(item, &mut imports_reused_with_self, &mut single_use_usages, &mut macros);
+            import_usage_visitor.visit_item(item);
         }
 
         for usage in single_use_usages {
-            if !imports_reused_with_self.contains(&usage.name) {
+            if !imports_reused_with_self.contains(&usage.name)
+                && !import_usage_visitor.imports_referenced_with_self.contains(&usage.name)
+            {
                 self.found.entry(usage.item_id).or_default().push(usage);
             }
         }
@@ -127,7 +161,6 @@ impl SingleComponentPathImports {
 
     fn track_uses(
         &mut self,
-        cx: &EarlyContext<'_>,
         item: &Item,
         imports_reused_with_self: &mut Vec<Symbol>,
         single_use_usages: &mut Vec<SingleUse>,
@@ -139,7 +172,7 @@ impl SingleComponentPathImports {
 
         match &item.kind {
             ItemKind::Mod(_, ModKind::Loaded(ref items, ..)) => {
-                self.check_mod(cx, items);
+                self.check_mod(items);
             },
             ItemKind::MacroDef(MacroDef { macro_rules: true, .. }) => {
                 macros.push(item.ident.name);
diff --git a/tests/ui/single_component_path_imports.fixed b/tests/ui/single_component_path_imports.fixed
index 4c40739d6f5..8c96c4715d3 100644
--- a/tests/ui/single_component_path_imports.fixed
+++ b/tests/ui/single_component_path_imports.fixed
@@ -2,9 +2,11 @@
 #![warn(clippy::single_component_path_imports)]
 #![allow(unused_imports)]
 
+use core;
 
 use serde as edres;
 pub use serde;
+use std;
 
 macro_rules! m {
     () => {
@@ -17,6 +19,10 @@ fn main() {
 
     // False positive #5154, shouldn't trigger lint.
     m!();
+
+    // False positive #10549
+    let _ = self::std::io::stdout();
+    let _ = 0 as self::core::ffi::c_uint;
 }
 
 mod hello_mod {
diff --git a/tests/ui/single_component_path_imports.rs b/tests/ui/single_component_path_imports.rs
index 9280bab3c71..8434bf7eaf1 100644
--- a/tests/ui/single_component_path_imports.rs
+++ b/tests/ui/single_component_path_imports.rs
@@ -2,9 +2,11 @@
 #![warn(clippy::single_component_path_imports)]
 #![allow(unused_imports)]
 
+use core;
 use regex;
 use serde as edres;
 pub use serde;
+use std;
 
 macro_rules! m {
     () => {
@@ -17,6 +19,10 @@ fn main() {
 
     // False positive #5154, shouldn't trigger lint.
     m!();
+
+    // False positive #10549
+    let _ = self::std::io::stdout();
+    let _ = 0 as self::core::ffi::c_uint;
 }
 
 mod hello_mod {
diff --git a/tests/ui/single_component_path_imports.stderr b/tests/ui/single_component_path_imports.stderr
index 71dcc25d6e5..d69a86470a5 100644
--- a/tests/ui/single_component_path_imports.stderr
+++ b/tests/ui/single_component_path_imports.stderr
@@ -1,5 +1,5 @@
 error: this import is redundant
-  --> $DIR/single_component_path_imports.rs:5:1
+  --> $DIR/single_component_path_imports.rs:6:1
    |
 LL | use regex;
    | ^^^^^^^^^^ help: remove it entirely
@@ -7,7 +7,7 @@ LL | use regex;
    = note: `-D clippy::single-component-path-imports` implied by `-D warnings`
 
 error: this import is redundant
-  --> $DIR/single_component_path_imports.rs:23:5
+  --> $DIR/single_component_path_imports.rs:29:5
    |
 LL |     use regex;
    |     ^^^^^^^^^^ help: remove it entirely
-- 
cgit 1.4.1-3-g733a5


From 17f80456d18c954cd82a1232807ae8c5bc1cb5cb Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Thu, 30 Mar 2023 16:17:11 +0000
Subject: Ignore `file!()` macro in `print_literal`, `write_literal`

---
 clippy_lints/src/write.rs         | 14 ++++++++++----
 tests/ui/auxiliary/proc_macros.rs |  2 +-
 tests/ui/print_literal.rs         |  4 ++++
 3 files changed, 15 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs
index 8114a8463fa..d7c94b909bd 100644
--- a/clippy_lints/src/write.rs
+++ b/clippy_lints/src/write.rs
@@ -463,12 +463,18 @@ fn check_literal(cx: &LateContext<'_>, format_args: &FormatArgs, name: &str) {
             && let Some(value_string) = snippet_opt(cx, arg.expr.span)
     {
             let (replacement, replace_raw) = match lit.kind {
-                LitKind::Str | LitKind::StrRaw(_)  => extract_str_literal(&value_string),
+                LitKind::Str | LitKind::StrRaw(_)  => match extract_str_literal(&value_string) {
+                    Some(extracted) => extracted,
+                    None => return,
+                },
                 LitKind::Char => (
                     match lit.symbol.as_str() {
                         "\"" => "\\\"",
                         "\\'" => "'",
-                        _ => &value_string[1..value_string.len() - 1],
+                        _ => match value_string.strip_prefix('\'').and_then(|s| s.strip_suffix('\'')) {
+                            Some(stripped) => stripped,
+                            None => return,
+                        },
                     }
                     .to_string(),
                     false,
@@ -533,13 +539,13 @@ fn check_literal(cx: &LateContext<'_>, format_args: &FormatArgs, name: &str) {
 /// `r#"a"#` -> (`a`, true)
 ///
 /// `"b"` -> (`b`, false)
-fn extract_str_literal(literal: &str) -> (String, bool) {
+fn extract_str_literal(literal: &str) -> Option<(String, bool)> {
     let (literal, raw) = match literal.strip_prefix('r') {
         Some(stripped) => (stripped.trim_matches('#'), true),
         None => (literal, false),
     };
 
-    (literal[1..literal.len() - 1].to_string(), raw)
+    Some((literal.strip_prefix('"')?.strip_suffix('"')?.to_string(), raw))
 }
 
 enum UnescapeErr {
diff --git a/tests/ui/auxiliary/proc_macros.rs b/tests/ui/auxiliary/proc_macros.rs
index 325be83a0d7..3d5beab1eff 100644
--- a/tests/ui/auxiliary/proc_macros.rs
+++ b/tests/ui/auxiliary/proc_macros.rs
@@ -63,7 +63,7 @@ fn group_with_span(delimiter: Delimiter, stream: TokenStream, span: Span) -> Gro
 /// Token used to escape the following token from the macro's span rules.
 const ESCAPE_CHAR: char = '$';
 
-/// Takes a single token followed by a sequence tokens. Returns the sequence of tokens with their
+/// Takes a single token followed by a sequence of tokens. Returns the sequence of tokens with their
 /// span set to that of the first token. Tokens may be escaped with either `#ident` or `#(tokens)`.
 #[proc_macro]
 pub fn with_span(input: TokenStream) -> TokenStream {
diff --git a/tests/ui/print_literal.rs b/tests/ui/print_literal.rs
index 86f908f66b8..538513e9156 100644
--- a/tests/ui/print_literal.rs
+++ b/tests/ui/print_literal.rs
@@ -38,4 +38,8 @@ fn main() {
     // named args shouldn't change anything either
     println!("{foo} {bar}", foo = "hello", bar = "world");
     println!("{bar} {foo}", foo = "hello", bar = "world");
+
+    // The string literal from `file!()` has a callsite span that isn't marked as coming from an
+    // expansion
+    println!("file: {}", file!());
 }
-- 
cgit 1.4.1-3-g733a5


From 41b367fa5f0127ed7d245f517aaed9b8f4855974 Mon Sep 17 00:00:00 2001
From: Yuri Astrakhan <YuriAstrakhan@gmail.com>
Date: Sat, 11 Mar 2023 18:50:50 -0500
Subject: Gramar, and spelin kleanup

A few minor cleanups in various markdown files, mostly focusing on spelling and ignoring non-compilable codeblocks.
---
 README.md                                          |  6 ++---
 book/src/README.md                                 |  2 +-
 book/src/configuration.md                          |  8 +++----
 book/src/development/README.md                     |  2 +-
 book/src/development/adding_lints.md               | 24 +++++++++----------
 book/src/development/basics.md                     |  2 +-
 book/src/development/common_tools_writing_lints.md | 14 +++++------
 book/src/development/infrastructure/book.md        |  4 ++--
 .../development/infrastructure/changelog_update.md |  2 +-
 book/src/development/infrastructure/release.md     |  2 +-
 book/src/development/infrastructure/sync.md        |  8 +++----
 book/src/development/proposals/README.md           |  2 +-
 book/src/development/proposals/roadmap-2021.md     |  6 ++---
 .../development/proposals/syntax-tree-patterns.md  | 28 +++++++++++-----------
 book/src/installation.md                           |  4 ++--
 book/src/lint_configuration.md                     |  8 +++----
 book/src/lints.md                                  | 10 ++++----
 book/src/usage.md                                  |  4 ++--
 clippy_lints/src/utils/conf.rs                     |  8 +++----
 etc/relicense/RELICENSE_DOCUMENTATION.md           |  4 ++--
 lintcheck/README.md                                |  2 +-
 21 files changed, 75 insertions(+), 75 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/README.md b/README.md
index b69ed8900a4..85798e0e80c 100644
--- a/README.md
+++ b/README.md
@@ -11,7 +11,7 @@ Lints are divided into categories, each with a default [lint level](https://doc.
 You can choose how much Clippy is supposed to ~~annoy~~ help you by changing the lint level by category.
 
 | Category              | Description                                                                         | Default level |
-| --------------------- | ----------------------------------------------------------------------------------- | ------------- |
+|-----------------------|-------------------------------------------------------------------------------------|---------------|
 | `clippy::all`         | all lints that are on by default (correctness, suspicious, style, complexity, perf) | **warn/deny** |
 | `clippy::correctness` | code that is outright wrong or useless                                              | **deny**      |
 | `clippy::suspicious`  | code that is most likely wrong or useless                                           | **warn**      |
@@ -130,7 +130,7 @@ for example.
 
 You can add Clippy to Travis CI in the same way you use it locally:
 
-```yml
+```yaml
 language: rust
 rust:
   - stable
@@ -253,7 +253,7 @@ rust-version = "1.30"
 
 The MSRV can also be specified as an attribute, like below.
 
-```rust
+```rust,ignore
 #![feature(custom_inner_attributes)]
 #![clippy::msrv = "1.30.0"]
 
diff --git a/book/src/README.md b/book/src/README.md
index df4a1f2702e..3b627096268 100644
--- a/book/src/README.md
+++ b/book/src/README.md
@@ -14,7 +14,7 @@ much Clippy is supposed to ~~annoy~~ help you by changing the lint level by
 category.
 
 | Category              | Description                                                                         | Default level |
-| --------------------- | ----------------------------------------------------------------------------------- | ------------- |
+|-----------------------|-------------------------------------------------------------------------------------|---------------|
 | `clippy::all`         | all lints that are on by default (correctness, suspicious, style, complexity, perf) | **warn/deny** |
 | `clippy::correctness` | code that is outright wrong or useless                                              | **deny**      |
 | `clippy::suspicious`  | code that is most likely wrong or useless                                           | **warn**      |
diff --git a/book/src/configuration.md b/book/src/configuration.md
index 87f4a697af9..4947d3d1226 100644
--- a/book/src/configuration.md
+++ b/book/src/configuration.md
@@ -3,7 +3,7 @@
 > **Note:** The configuration file is unstable and may be deprecated in the future.
 
 Some lints can be configured in a TOML file named `clippy.toml` or `.clippy.toml`. It contains a
-basic `variable = value` mapping eg.
+basic `variable = value` mapping e.g.
 
 ```toml
 avoid-breaking-exported-api = false
@@ -60,7 +60,7 @@ And to warn on `lint_name`, run
 cargo clippy -- -W clippy::lint_name
 ```
 
-This also works with lint groups. For example you can run Clippy with warnings for all lints enabled:
+This also works with lint groups. For example, you can run Clippy with warnings for all lints enabled:
 
 ```terminal
 cargo clippy -- -W clippy::pedantic
@@ -84,7 +84,7 @@ msrv = "1.30.0"
 
 The MSRV can also be specified as an attribute, like below.
 
-```rust
+```rust,ignore
 #![feature(custom_inner_attributes)]
 #![clippy::msrv = "1.30.0"]
 
@@ -96,7 +96,7 @@ fn main() {
 You can also omit the patch version when specifying the MSRV, so `msrv = 1.30`
 is equivalent to `msrv = 1.30.0`.
 
-Note: `custom_inner_attributes` is an unstable feature so it has to be enabled explicitly.
+Note: `custom_inner_attributes` is an unstable feature, so it has to be enabled explicitly.
 
 Lints that recognize this configuration option can be
 found [here](https://rust-lang.github.io/rust-clippy/master/index.html#msrv)
diff --git a/book/src/development/README.md b/book/src/development/README.md
index 5cf7201cffa..616e6d182b7 100644
--- a/book/src/development/README.md
+++ b/book/src/development/README.md
@@ -5,7 +5,7 @@ making Clippy better by contributing to it. In that case, welcome to the
 project!
 
 > _Note:_ If you're just interested in using Clippy, there's nothing to see from
-> this point onward and you should return to one of the earlier chapters.
+> this point onward, and you should return to one of the earlier chapters.
 
 ## Getting started
 
diff --git a/book/src/development/adding_lints.md b/book/src/development/adding_lints.md
index 0f5ee7103de..3f4088e74ea 100644
--- a/book/src/development/adding_lints.md
+++ b/book/src/development/adding_lints.md
@@ -24,7 +24,7 @@ because that's clearly a non-descriptive name.
   - [Lint passes](#lint-passes)
   - [Emitting a lint](#emitting-a-lint)
   - [Adding the lint logic](#adding-the-lint-logic)
-  - [Specifying the lint's minimum supported Rust version (MSRV)](#specifying-the-lints-minimum-supported-rust-version-msrv)
+  - [Specifying the lint's minimum supported Rust version (MSRV)](#specifying-the-lints-minimum-supported-rust-version--msrv-)
   - [Author lint](#author-lint)
   - [Print HIR lint](#print-hir-lint)
   - [Documentation](#documentation)
@@ -275,7 +275,7 @@ When declaring a new lint by hand and `cargo dev update_lints` is used, the lint
 pass may have to be registered manually in the `register_plugins` function in
 `clippy_lints/src/lib.rs`:
 
-```rust
+```rust,ignore
 store.register_early_pass(|| Box::new(foo_functions::FooFunctions));
 ```
 
@@ -301,7 +301,7 @@ either [`EarlyLintPass`][early_lint_pass] or [`LateLintPass`][late_lint_pass].
 
 In short, the `LateLintPass` has access to type information while the
 `EarlyLintPass` doesn't. If you don't need access to type information, use the
-`EarlyLintPass`. The `EarlyLintPass` is also faster. However linting speed
+`EarlyLintPass`. The `EarlyLintPass` is also faster. However, linting speed
 hasn't really been a concern with Clippy so far.
 
 Since we don't need type information for checking the function name, we used
@@ -318,7 +318,7 @@ implementation of the lint logic.
 
 Let's start by implementing the `EarlyLintPass` for our `FooFunctions`:
 
-```rust
+```rust,ignore
 impl EarlyLintPass for FooFunctions {
     fn check_fn(&mut self, cx: &EarlyContext<'_>, fn_kind: FnKind<'_>, span: Span, _: NodeId) {
         // TODO: Emit lint here
@@ -337,10 +337,10 @@ variety of lint emission functions. They can all be found in
 [`clippy_utils/src/diagnostics.rs`][diagnostics].
 
 `span_lint_and_help` seems most appropriate in this case. It allows us to
-provide an extra help message and we can't really suggest a better name
+provide an extra help message, and we can't really suggest a better name
 automatically. This is how it looks:
 
-```rust
+```rust,ignore
 impl EarlyLintPass for FooFunctions {
     fn check_fn(&mut self, cx: &EarlyContext<'_>, fn_kind: FnKind<'_>, span: Span, _: NodeId) {
         span_lint_and_help(
@@ -479,7 +479,7 @@ the value from `clippy.toml`. This can be accounted for using the
 `extract_msrv_attr!(LintContext)` macro and passing
 `LateContext`/`EarlyContext`.
 
-```rust
+```rust,ignore
 impl<'tcx> LateLintPass<'tcx> for ManualStrip {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         ...
@@ -493,7 +493,7 @@ the lint's test file, `tests/ui/manual_strip.rs` in this example. It should
 have a case for the version below the MSRV and one with the same contents but
 for the MSRV version itself.
 
-```rust
+```rust,ignore
 ...
 
 #[clippy::msrv = "1.44"]
@@ -524,7 +524,7 @@ define_Conf! {
 
 If you have trouble implementing your lint, there is also the internal `author`
 lint to generate Clippy code that detects the offending pattern. It does not
-work for all of the Rust syntax, but can give a good starting point.
+work for all the Rust syntax, but can give a good starting point.
 
 The quickest way to use it, is the [Rust playground:
 play.rust-lang.org][author_example]. Put the code you want to lint into the
@@ -617,7 +617,7 @@ output in the `stdout` part.
 
 ## PR Checklist
 
-Before submitting your PR make sure you followed all of the basic requirements:
+Before submitting your PR make sure you followed all the basic requirements:
 
 <!-- Sync this with `.github/PULL_REQUEST_TEMPLATE` -->
 
@@ -637,7 +637,7 @@ for some users. Adding a configuration is done in the following steps:
 
 1. Adding a new configuration entry to [`clippy_lints::utils::conf`] like this:
 
-   ```rust
+   ```rust,ignore
    /// Lint: LINT_NAME.
    ///
    /// <The configuration field doc comment>
@@ -690,7 +690,7 @@ for some users. Adding a configuration is done in the following steps:
    configuration value is now cloned or copied into a local value that is then
    passed to the impl struct like this:
 
-   ```rust
+   ```rust,ignore
    // Default generated registration:
    store.register_*_pass(|| box module::StructName);
 
diff --git a/book/src/development/basics.md b/book/src/development/basics.md
index 6fb53236e6f..b07d3de7187 100644
--- a/book/src/development/basics.md
+++ b/book/src/development/basics.md
@@ -125,7 +125,7 @@ We follow a rustc no merge-commit policy. See
 ## Common Abbreviations
 
 | Abbreviation | Meaning                                |
-| ------------ | -------------------------------------- |
+|--------------|----------------------------------------|
 | UB           | Undefined Behavior                     |
 | FP           | False Positive                         |
 | FN           | False Negative                         |
diff --git a/book/src/development/common_tools_writing_lints.md b/book/src/development/common_tools_writing_lints.md
index f5aa06e4bf6..09171d86a20 100644
--- a/book/src/development/common_tools_writing_lints.md
+++ b/book/src/development/common_tools_writing_lints.md
@@ -3,7 +3,7 @@
 You may need following tooltips to catch up with common operations.
 
 - [Common tools for writing lints](#common-tools-for-writing-lints)
-  - [Retrieving the type of an expression](#retrieving-the-type-of-an-expression)
+  - [Retrieving the type of expression](#retrieving-the-type-of-expression)
   - [Checking if an expr is calling a specific method](#checking-if-an-expr-is-calling-a-specific-method)
   - [Checking for a specific type](#checking-for-a-specific-type)
   - [Checking if a type implements a specific trait](#checking-if-a-type-implements-a-specific-trait)
@@ -16,7 +16,7 @@ Useful Rustc dev guide links:
 - [Type checking](https://rustc-dev-guide.rust-lang.org/type-checking.html)
 - [Ty module](https://rustc-dev-guide.rust-lang.org/ty.html)
 
-## Retrieving the type of an expression
+## Retrieving the type of expression
 
 Sometimes you may want to retrieve the type `Ty` of an expression `Expr`, for
 example to answer following questions:
@@ -45,7 +45,7 @@ impl LateLintPass<'_> for MyStructLint {
 }
 ```
 
-Similarly in [`TypeckResults`][TypeckResults] methods, you have the
+Similarly, in [`TypeckResults`][TypeckResults] methods, you have the
 [`pat_ty()`][pat_ty] method to retrieve a type from a pattern.
 
 Two noticeable items here:
@@ -192,7 +192,7 @@ functions to deal with macros:
 - `span.from_expansion()`: detects if a span is from macro expansion or
   desugaring. Checking this is a common first step in a lint.
 
-   ```rust
+   ```rust,ignore
    if expr.span.from_expansion() {
        // just forget it
        return;
@@ -203,11 +203,11 @@ functions to deal with macros:
   if so, which macro call expanded it. It is sometimes useful to check if the
   context of two spans are equal.
 
-  ```rust
+  ```rust,ignore
   // expands to `1 + 0`, but don't lint
   1 + mac!()
   ```
-  ```rust
+  ```rust,ignore
   if left.span.ctxt() != right.span.ctxt() {
       // the coder most likely cannot modify this expression
       return;
@@ -246,7 +246,7 @@ functions to deal with macros:
   `macro_rules!` with `a == $b`, `$b` is expanded to some expression with a
   different context from `a`.
 
-   ```rust
+   ```rust,ignore
    macro_rules! m {
        ($a:expr, $b:expr) => {
            if $a.is_some() {
diff --git a/book/src/development/infrastructure/book.md b/book/src/development/infrastructure/book.md
index dbd624ecd73..de5de4bebaa 100644
--- a/book/src/development/infrastructure/book.md
+++ b/book/src/development/infrastructure/book.md
@@ -13,7 +13,7 @@ guide to Clippy that you're reading right now. The Clippy book is formatted with
 While not strictly necessary since the book source is simply Markdown text
 files, having mdBook locally will allow you to build, test and serve the book
 locally to view changes before you commit them to the repository. You likely
-already have `cargo` installed, so the easiest option is to simply:
+already have `cargo` installed, so the easiest option is to:
 
 ```shell
 cargo install mdbook
@@ -26,7 +26,7 @@ instructions for other options.
 
 The book's
 [src](https://github.com/rust-lang/rust-clippy/tree/master/book/src)
-directory contains all of the markdown files used to generate the book. If you
+directory contains all the markdown files used to generate the book. If you
 want to see your changes in real time, you can use the mdBook `serve` command to
 run a web server locally that will automatically update changes as they are
 made. From the top level of your `rust-clippy` directory:
diff --git a/book/src/development/infrastructure/changelog_update.md b/book/src/development/infrastructure/changelog_update.md
index d1ac7237b5e..df9b1bbe18f 100644
--- a/book/src/development/infrastructure/changelog_update.md
+++ b/book/src/development/infrastructure/changelog_update.md
@@ -101,7 +101,7 @@ Look for the [`beta-accepted`] label and make sure to also include the PRs with
 that label in the changelog. If you can, remove the `beta-accepted` labels
 **after** the changelog PR was merged.
 
-> _Note:_ Some of those PRs might even got backported to the previous `beta`.
+> _Note:_ Some of those PRs might even get backported to the previous `beta`.
 > Those have to be included in the changelog of the _previous_ release.
 
 ### 4. Update `clippy::version` attributes
diff --git a/book/src/development/infrastructure/release.md b/book/src/development/infrastructure/release.md
index 0572281803e..98fabf8e89a 100644
--- a/book/src/development/infrastructure/release.md
+++ b/book/src/development/infrastructure/release.md
@@ -44,7 +44,7 @@ $ git push origin backport_remerge  # This can be pushed to your fork
 ```
 
 After this, open a PR to the master branch. In this PR, the commit hash of the
-`HEAD` of the `beta` branch must exists. In addition to that, no files should be
+`HEAD` of the `beta` branch must exist. In addition to that, no files should be
 changed by this PR.
 
 ## Update the `beta` branch
diff --git a/book/src/development/infrastructure/sync.md b/book/src/development/infrastructure/sync.md
index 02cfc11b55a..7fb127c6284 100644
--- a/book/src/development/infrastructure/sync.md
+++ b/book/src/development/infrastructure/sync.md
@@ -47,7 +47,7 @@ sudo chown --reference=/usr/lib/git-core/git-subtree~ /usr/lib/git-core/git-subt
 
 > _Note:_ If you are a Debian user, `dash` is the shell used by default for
 > scripts instead of `sh`. This shell has a hardcoded recursion limit set to
-> 1000. In order to make this process work, you need to force the script to run
+> 1,000. In order to make this process work, you need to force the script to run
 > `bash` instead. You can do this by editing the first line of the `git-subtree`
 > script and changing `sh` to `bash`.
 
@@ -71,10 +71,10 @@ $ git remote add clippy-local /path/to/rust-clippy
 
 ## Performing the sync from [`rust-lang/rust`] to Clippy
 
-Here is a TL;DR version of the sync process (all of the following commands have
+Here is a TL;DR version of the sync process (all the following commands have
 to be run inside the `rust` directory):
 
-1. Clone the [`rust-lang/rust`] repository or make sure it is up to date.
+1. Clone the [`rust-lang/rust`] repository or make sure it is up-to-date.
 2. Checkout the commit from the latest available nightly. You can get it using
    `rustup check`.
 3. Sync the changes to the rust-copy of Clippy to your Clippy fork:
@@ -107,7 +107,7 @@ to be run inside the `rust` directory):
 
 ## Performing the sync from Clippy to [`rust-lang/rust`]
 
-All of the following commands have to be run inside the `rust` directory.
+All the following commands have to be run inside the `rust` directory.
 
 1. Make sure you have checked out the latest `master` of `rust-lang/rust`.
 2. Sync the `rust-lang/rust-clippy` master to the rust-copy of Clippy:
diff --git a/book/src/development/proposals/README.md b/book/src/development/proposals/README.md
index 78fe34ebf8f..059c22ce1ce 100644
--- a/book/src/development/proposals/README.md
+++ b/book/src/development/proposals/README.md
@@ -6,6 +6,6 @@ or around Clippy in the long run.
 Besides adding more and more lints and improve the lints that Clippy already
 has, Clippy is also interested in making the experience of its users, developers
 and maintainers better over time. Projects that address bigger picture things
-like this usually take more time and it is useful to have a proposal for those
+like this usually take more time, and it is useful to have a proposal for those
 first. This is the place where such proposals are collected, so that we can
 refer to them when working on them.
diff --git a/book/src/development/proposals/roadmap-2021.md b/book/src/development/proposals/roadmap-2021.md
index fe8b080f56f..4406616bbb6 100644
--- a/book/src/development/proposals/roadmap-2021.md
+++ b/book/src/development/proposals/roadmap-2021.md
@@ -52,8 +52,8 @@ In the following, plans to improve the usability are covered.
 
 #### No Output After `cargo check`
 
-Currently when `cargo clippy` is run after `cargo check`, it does not produce
-any output. This is especially problematic since `rust-analyzer` is on the rise
+Currently, when `cargo clippy` is run after `cargo check`, it does not produce
+any output. This is especially problematic since `rust-analyzer` is on the rise,
 and it uses `cargo check` for checking code. A fix is already implemented, but
 it still has to be pushed over the finish line. This also includes the
 stabilization of the `cargo clippy --fix` command or the support of multi-span
@@ -221,7 +221,7 @@ regarding the user facing issues.
 
 Rust's roadmap process was established by [RFC 1728] in 2016. Since then every
 year a roadmap was published, that defined the bigger plans for the coming
-years. This years roadmap can be found [here][Rust Roadmap 2021].
+years. This year roadmap can be found [here][Rust Roadmap 2021].
 
 [RFC 1728]: https://rust-lang.github.io/rfcs/1728-north-star.html
 
diff --git a/book/src/development/proposals/syntax-tree-patterns.md b/book/src/development/proposals/syntax-tree-patterns.md
index ea4978011b1..36d722609f4 100644
--- a/book/src/development/proposals/syntax-tree-patterns.md
+++ b/book/src/development/proposals/syntax-tree-patterns.md
@@ -16,7 +16,7 @@ lints. For non-trivial lints, it often requires nested pattern matching of AST /
 HIR nodes. For example, testing that an expression is a boolean literal requires
 the following checks:
 
-```rust
+```rust,ignore
 if let ast::ExprKind::Lit(lit) = &expr.node {
     if let ast::LitKind::Bool(_) = &lit.node {
         ...
@@ -28,7 +28,7 @@ Writing this kind of matching code quickly becomes a complex task and the
 resulting code is often hard to comprehend. The code below shows a simplified
 version of the pattern matching required by the `collapsible_if` lint:
 
-```rust
+```rust,ignore
 // simplified version of the collapsible_if lint
 if let ast::ExprKind::If(check, then, None) = &expr.node {
     if then.stmts.len() == 1 {
@@ -111,7 +111,7 @@ expressions that are boolean literals with value `false`.
 
 The pattern can then be used to implement lints in the following way:
 
-```rust
+```rust,ignore
 ...
 
 impl EarlyLintPass for MyAwesomeLint {
@@ -346,7 +346,7 @@ pattern!{
 one could get references to the nodes that matched the subpatterns in the
 following way:
 
-```rust
+```rust,ignore
 ...
 fn check_expr(expr: &syntax::ast::Expr) {
     if let Some(result) = my_pattern(expr) {
@@ -372,7 +372,7 @@ matches arrays that consist of any number of literal expressions. Because those
 expressions are named `foo`, the result struct contains a `foo` attribute which
 is a vector of expressions:
 
-```rust
+```rust,ignore
 ...
 if let Some(result) = my_pattern_seq(expr) {
     result.foo        // type: Vec<&syntax::ast::Expr>
@@ -394,7 +394,7 @@ In the pattern above, the `bar` name is only defined if the pattern matches a
 boolean literal. If it matches an integer literal, the name isn't set. To
 account for this, the result struct's `bar` attribute is an option type:
 
-```rust
+```rust,ignore
 ...
 if let Some(result) = my_pattern_alt(expr) {
     result.bar        // type: Option<&bool>
@@ -404,7 +404,7 @@ if let Some(result) = my_pattern_alt(expr) {
 It's also possible to use a name in multiple alternation branches if they have
 compatible types:
 
-```rust
+```rust,ignore
 pattern!{
     // matches if expression is a boolean or integer literal
     my_pattern_mult: Expr =
@@ -519,7 +519,7 @@ The `Alt`, `Seq` and `Opt` structs look like these:
 > Note: The current implementation can be found
 > [here](https://github.com/fkohlgrueber/pattern-matching/blob/dfb3bc9fbab69cec7c91e72564a63ebaa2ede638/pattern-match/src/matchers.rs#L35-L60).
 
-```rust
+```rust,ignore
 pub enum Alt<T> {
     Any,
     Elmt(Box<T>),
@@ -580,7 +580,7 @@ implementations is the `IsMatch` trait. It defines how to match *PatternTree*
 nodes against specific syntax tree nodes. A simplified implementation of the
 `IsMatch` trait is shown below:
 
-```rust
+```rust,ignore
 pub trait IsMatch<O> {
     fn is_match(&self, other: &'o O) -> bool;
 }
@@ -619,7 +619,7 @@ approach (matching against the coarse pattern first and checking for additional
 properties later) might be slower than the current practice of checking for
 structure and additional properties in one pass. For example, the following lint
 
-```rust
+```rust,ignore
 pattern!{
     pat_if_without_else: Expr =
         If(
@@ -644,7 +644,7 @@ first matches against the pattern and then checks that the `then` block doesn't
 start with a comment. Using clippy's current approach, it's possible to check
 for these conditions earlier:
 
-```rust
+```rust,ignore
 fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &ast::Expr) {
     if_chain! {
         if let ast::ExprKind::If(ref check, ref then, None) = expr.node;
@@ -708,7 +708,7 @@ is similar to actual Rust syntax (probably like the `quote!` macro). For
 example, a pattern that matches `if` expressions that have `false` in their
 condition could look like this:
 
-```rust
+```rust,ignore
 if false {
     #[*]
 }
@@ -742,7 +742,7 @@ affects the structure of the resulting AST. `1 + 0 + 0` is parsed as `(1 + 0) +
 Another example of a problem would be named submatches. Take a look at this
 pattern:
 
-```rust
+```rust,ignore
 fn test() {
     1 #foo
 }
@@ -862,7 +862,7 @@ op b` and recommends changing it to `a op= b` requires that both occurrences of
 `a` are the same. Using `=#...` as syntax for backreferences, the lint could be
 implemented like this:
 
-```rust
+```rust,ignore
 pattern!{
     assign_op_pattern: Expr =
         Assign(_#target, Binary(_, =#target, _)
diff --git a/book/src/installation.md b/book/src/installation.md
index cce888b17d4..d54fff9deba 100644
--- a/book/src/installation.md
+++ b/book/src/installation.md
@@ -17,8 +17,8 @@ $ rustup component add clippy [--toolchain=<name>]
 
 ## From Source
 
-Take a look at the [Basics] chapter in the Clippy developer guide to find step
-by step instructions on how to build and install Clippy from source.
+Take a look at the [Basics] chapter in the Clippy developer guide to find step-by-step
+instructions on how to build and install Clippy from source.
 
 [Basics]: development/basics.md#install-from-source
 [Usage]: usage.md
diff --git a/book/src/lint_configuration.md b/book/src/lint_configuration.md
index 4415a05251e..78e1a55cff3 100644
--- a/book/src/lint_configuration.md
+++ b/book/src/lint_configuration.md
@@ -195,7 +195,7 @@ The maximum cognitive complexity a function can have
 ### disallowed-names
 The list of disallowed names to lint about. NB: `bar` is not here since it has legitimate uses. The value
 `".."` can be used as part of the list to indicate, that the configured values should be appended to the
-default configuration of Clippy. By default any configuration will replace the default value.
+default configuration of Clippy. By default, any configuration will replace the default value.
 
 **Default Value:** `["foo", "baz", "quux"]` (`Vec<String>`)
 
@@ -205,7 +205,7 @@ default configuration of Clippy. By default any configuration will replace the d
 ### doc-valid-idents
 The list of words this lint should not consider as identifiers needing ticks. The value
 `".."` can be used as part of the list to indicate, that the configured values should be appended to the
-default configuration of Clippy. By default any configuraction will replace the default value. For example:
+default configuration of Clippy. By default, any configuration will replace the default value. For example:
 * `doc-valid-idents = ["ClipPy"]` would replace the default list with `["ClipPy"]`.
 * `doc-valid-idents = ["ClipPy", ".."]` would append `ClipPy` to the default list.
 
@@ -415,7 +415,7 @@ For internal testing only, ignores the current `publish` settings in the Cargo m
 Enforce the named macros always use the braces specified.
 
 A `MacroMatcher` can be added like so `{ name = "macro_name", brace = "(" }`. If the macro
-is could be used with a full path two `MacroMatcher`s have to be added one with the full path
+could be used with a full path two `MacroMatcher`s have to be added one with the full path
 `crate_name::macro_name` and one with just the macro name.
 
 **Default Value:** `[]` (`Vec<crate::nonstandard_macro_braces::MacroMatcher>`)
@@ -449,7 +449,7 @@ Whether to apply the raw pointer heuristic to determine if a type is `Send`.
 
 ### max-suggested-slice-pattern-length
 When Clippy suggests using a slice pattern, this is the maximum number of elements allowed in
-the slice pattern that is suggested. If more elements would be necessary, the lint is suppressed.
+the slice pattern that is suggested. If more elements are necessary, the lint is suppressed.
 For example, `[_, _, _, e, ..]` is a slice pattern with 4 elements.
 
 **Default Value:** `3` (`u64`)
diff --git a/book/src/lints.md b/book/src/lints.md
index 35e30960b56..442dc63914e 100644
--- a/book/src/lints.md
+++ b/book/src/lints.md
@@ -17,7 +17,7 @@ The different lint groups were defined in the [Clippy 1.0 RFC].
 The `clippy::correctness` group is the only lint group in Clippy which lints are
 deny-by-default and abort the compilation when triggered. This is for good
 reason: If you see a `correctness` lint, it means that your code is outright
-wrong or useless and you should try to fix it.
+wrong or useless, and you should try to fix it.
 
 Lints in this category are carefully picked and should be free of false
 positives. So just `#[allow]`ing those lints is not recommended.
@@ -41,7 +41,7 @@ simplify your code. It mostly focuses on code that can be written in a shorter
 and more readable way, while preserving the semantics.
 
 If you should see a complexity lint, it usually means that you can remove or
-replace some code and it is recommended to do so. However, if you need the more
+replace some code, and it is recommended to do so. However, if you need the more
 complex code for some expressiveness reason, it is recommended to allow
 complexity lints on a case-by-case basis.
 
@@ -50,9 +50,9 @@ complexity lints on a case-by-case basis.
 The `clippy::perf` group gives you suggestions on how you can increase the
 performance of your code. Those lints are mostly about code that the compiler
 can't trivially optimize, but has to be written in a slightly different way to
-make the optimizer's job easier.
+make the optimizer job easier.
 
-Perf lints are usually easy to apply and it is recommended to do so.
+Perf lints are usually easy to apply, and it is recommended to do so.
 
 ## Style
 
@@ -91,7 +91,7 @@ and your use case.
 
 Lints from this group will restrict you in some way. If you enable a restriction
 lint for your crate it is recommended to also fix code that this lint triggers
-on. However, those lints are really strict by design and you might want to
+on. However, those lints are really strict by design, and you might want to
 `#[allow]` them in some special cases, with a comment justifying that.
 
 ## Cargo
diff --git a/book/src/usage.md b/book/src/usage.md
index 61a90445d75..32084a9199b 100644
--- a/book/src/usage.md
+++ b/book/src/usage.md
@@ -19,7 +19,7 @@ cargo clippy
 ### Lint configuration
 
 The above command will run the default set of lints, which are included in the
-lint group `clippy::all`. You might want to use even more lints or you might not
+lint group `clippy::all`. You might want to use even more lints, or you may not
 agree with every Clippy lint, and for that there are ways to configure lint
 levels.
 
@@ -98,7 +98,7 @@ other of Clippy's lint groups.
 You can configure lint levels in source code the same way you can configure
 `rustc` lints:
 
-```rust
+```rust,ignore
 #![allow(clippy::style)]
 
 #[warn(clippy::double_neg)]
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index e1c9dd10117..f75a5cf7196 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -275,13 +275,13 @@ define_Conf! {
     ///
     /// The list of disallowed names to lint about. NB: `bar` is not here since it has legitimate uses. The value
     /// `".."` can be used as part of the list to indicate, that the configured values should be appended to the
-    /// default configuration of Clippy. By default any configuration will replace the default value.
+    /// default configuration of Clippy. By default, any configuration will replace the default value.
     (disallowed_names: Vec<String> = super::DEFAULT_DISALLOWED_NAMES.iter().map(ToString::to_string).collect()),
     /// Lint: DOC_MARKDOWN.
     ///
     /// The list of words this lint should not consider as identifiers needing ticks. The value
     /// `".."` can be used as part of the list to indicate, that the configured values should be appended to the
-    /// default configuration of Clippy. By default any configuraction will replace the default value. For example:
+    /// default configuration of Clippy. By default, any configuration will replace the default value. For example:
     /// * `doc-valid-idents = ["ClipPy"]` would replace the default list with `["ClipPy"]`.
     /// * `doc-valid-idents = ["ClipPy", ".."]` would append `ClipPy` to the default list.
     ///
@@ -390,7 +390,7 @@ define_Conf! {
     /// Enforce the named macros always use the braces specified.
     ///
     /// A `MacroMatcher` can be added like so `{ name = "macro_name", brace = "(" }`. If the macro
-    /// is could be used with a full path two `MacroMatcher`s have to be added one with the full path
+    /// could be used with a full path two `MacroMatcher`s have to be added one with the full path
     /// `crate_name::macro_name` and one with just the macro name.
     (standard_macro_braces: Vec<crate::nonstandard_macro_braces::MacroMatcher> = Vec::new()),
     /// Lint: MISSING_ENFORCED_IMPORT_RENAMES.
@@ -408,7 +408,7 @@ define_Conf! {
     /// Lint: INDEX_REFUTABLE_SLICE.
     ///
     /// When Clippy suggests using a slice pattern, this is the maximum number of elements allowed in
-    /// the slice pattern that is suggested. If more elements would be necessary, the lint is suppressed.
+    /// the slice pattern that is suggested. If more elements are necessary, the lint is suppressed.
     /// For example, `[_, _, _, e, ..]` is a slice pattern with 4 elements.
     (max_suggested_slice_pattern_length: u64 = 3),
     /// Lint: AWAIT_HOLDING_INVALID_TYPE.
diff --git a/etc/relicense/RELICENSE_DOCUMENTATION.md b/etc/relicense/RELICENSE_DOCUMENTATION.md
index fcd7abbf3f1..ffb99cde4f8 100644
--- a/etc/relicense/RELICENSE_DOCUMENTATION.md
+++ b/etc/relicense/RELICENSE_DOCUMENTATION.md
@@ -35,7 +35,7 @@ relicensing are archived on GitHub. We also have saved Wayback Machine copies of
 
 The usernames of commenters on these issues can be found in relicense_comments.txt
 
-There are a couple people in relicense_comments.txt who are not found in contributors.txt:
+There are a few people in relicense_comments.txt who are not found in contributors.txt:
 
 - @EpocSquadron has [made minor text contributions to the
   README](https://github.com/rust-lang/rust-clippy/commits?author=EpocSquadron) which have since been overwritten, and
@@ -55,7 +55,7 @@ There are a couple people in relicense_comments.txt who are not found in contrib
   we rewrote (see below)
 
 
-Two of these contributors had nonminor contributions (#2184, #427) requiring a rewrite, carried out in #3251
+Two of these contributors had non-minor contributions (#2184, #427) requiring a rewrite, carried out in #3251
 ([archive](http://web.archive.org/web/20181005192411/https://github.com/rust-lang-nursery/rust-clippy/pull/3251),
 [screenshot](https://user-images.githubusercontent.com/1617736/46573515-5cb69580-c94b-11e8-86e5-b456452121b2.png))
 
diff --git a/lintcheck/README.md b/lintcheck/README.md
index e997eb47e32..faf3ce9093a 100644
--- a/lintcheck/README.md
+++ b/lintcheck/README.md
@@ -16,7 +16,7 @@ or
 cargo lintcheck
 ```
 
-By default the logs will be saved into
+By default, the logs will be saved into
 `lintcheck-logs/lintcheck_crates_logs.txt`.
 
 You can set a custom sources.toml by adding `--crates-toml custom.toml` or using
-- 
cgit 1.4.1-3-g733a5


From 6601d85c22a0e5b632e3332991c45058ed420ba2 Mon Sep 17 00:00:00 2001
From: "Samuel \"Sam\" Tardieu" <sam@rfc1149.net>
Date: Wed, 22 Mar 2023 22:56:17 +0100
Subject: Flag `bufreader.lines().filter_map(Result::ok)` as suspicious

---
 CHANGELOG.md                            |   1 +
 clippy_lints/src/declared_lints.rs      |   1 +
 clippy_lints/src/lib.rs                 |   2 +
 clippy_lints/src/lines_filter_map_ok.rs | 100 ++++++++++++++++++++++++++++++++
 clippy_utils/src/paths.rs               |   2 +
 tests/ui/lines_filter_map_ok.fixed      |  29 +++++++++
 tests/ui/lines_filter_map_ok.rs         |  29 +++++++++
 tests/ui/lines_filter_map_ok.stderr     |  51 ++++++++++++++++
 8 files changed, 215 insertions(+)
 create mode 100644 clippy_lints/src/lines_filter_map_ok.rs
 create mode 100644 tests/ui/lines_filter_map_ok.fixed
 create mode 100644 tests/ui/lines_filter_map_ok.rs
 create mode 100644 tests/ui/lines_filter_map_ok.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index f54bfbfa472..239631777e9 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4647,6 +4647,7 @@ Released 2018-09-13
 [`let_underscore_untyped`]: https://rust-lang.github.io/rust-clippy/master/index.html#let_underscore_untyped
 [`let_unit_value`]: https://rust-lang.github.io/rust-clippy/master/index.html#let_unit_value
 [`let_with_type_underscore`]: https://rust-lang.github.io/rust-clippy/master/index.html#let_with_type_underscore
+[`lines_filter_map_ok`]: https://rust-lang.github.io/rust-clippy/master/index.html#lines_filter_map_ok
 [`linkedlist`]: https://rust-lang.github.io/rust-clippy/master/index.html#linkedlist
 [`logic_bug`]: https://rust-lang.github.io/rust-clippy/master/index.html#logic_bug
 [`lossy_float_literal`]: https://rust-lang.github.io/rust-clippy/master/index.html#lossy_float_literal
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index f07c7f0534c..7836e5ccb9a 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -232,6 +232,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::let_with_type_underscore::LET_WITH_TYPE_UNDERSCORE_INFO,
     crate::lifetimes::EXTRA_UNUSED_LIFETIMES_INFO,
     crate::lifetimes::NEEDLESS_LIFETIMES_INFO,
+    crate::lines_filter_map_ok::LINES_FILTER_MAP_OK_INFO,
     crate::literal_representation::DECIMAL_LITERAL_REPRESENTATION_INFO,
     crate::literal_representation::INCONSISTENT_DIGIT_GROUPING_INFO,
     crate::literal_representation::LARGE_DIGIT_GROUPS_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 75c53a09d79..ce055f16240 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -171,6 +171,7 @@ mod let_if_seq;
 mod let_underscore;
 mod let_with_type_underscore;
 mod lifetimes;
+mod lines_filter_map_ok;
 mod literal_representation;
 mod loops;
 mod macro_use;
@@ -949,6 +950,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
             avoid_breaking_exported_api,
         ))
     });
+    store.register_late_pass(|_| Box::new(lines_filter_map_ok::LinesFilterMapOk));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/lines_filter_map_ok.rs b/clippy_lints/src/lines_filter_map_ok.rs
new file mode 100644
index 00000000000..b0f9276475d
--- /dev/null
+++ b/clippy_lints/src/lines_filter_map_ok.rs
@@ -0,0 +1,100 @@
+use clippy_utils::{
+    diagnostics::span_lint_and_then, is_diag_item_method, is_trait_method, match_def_path, path_to_local_id, paths,
+    ty::match_type,
+};
+use rustc_errors::Applicability;
+use rustc_hir::{Body, Closure, Expr, ExprKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::sym;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Detect uses of `lines.filter_map(Result::ok)` or `lines.flat_map(Result::ok)`
+    /// when `lines` has type `std::io::Lines`.
+    ///
+    /// ### Why is this bad?
+    /// `Lines` instances might produce a never-ending stream of `Err`, in which case
+    /// `filter_map(Result::ok)` will enter an infinite loop while waiting for an
+    /// `Ok` variant. Calling `next()` once is sufficient to enter the infinite loop,
+    /// even in the absence of explicit loops in the user code.
+    ///
+    /// This situation can arise when working with user-provided paths. On some platforms,
+    /// `std::fs::File::open(path)` might return `Ok(fs)` even when `path` is a directory,
+    /// but any later attempt to read from `fs` will return an error.
+    ///
+    /// ### Known problems
+    /// This lint suggests replacing `filter_map()` or `flat_map()` applied to a `Lines`
+    /// instance in all cases. There two cases where the suggestion might not be
+    /// appropriate or necessary:
+    ///
+    /// - If the `Lines` instance can never produce any error, or if an error is produced
+    ///   only once just before terminating the iterator, using `map_while()` is not
+    ///   necessary but will not do any harm.
+    /// - If the `Lines` instance can produce intermittent errors then recover and produce
+    ///   successful results, using `map_while()` would stop at the first error.
+    ///
+    /// ### Example
+    /// ```rust
+    /// # use std::{fs::File, io::{self, BufRead, BufReader}};
+    /// # let _ = || -> io::Result<()> {
+    /// let mut lines = BufReader::new(File::open("some-path")?).lines().filter_map(Result::ok);
+    /// // If "some-path" points to a directory, the next statement never terminates:
+    /// let first_line: Option<String> = lines.next();
+    /// # Ok(()) };
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// # use std::{fs::File, io::{self, BufRead, BufReader}};
+    /// # let _ = || -> io::Result<()> {
+    /// let mut lines = BufReader::new(File::open("some-path")?).lines().map_while(Result::ok);
+    /// let first_line: Option<String> = lines.next();
+    /// # Ok(()) };
+    /// ```
+    #[clippy::version = "1.70.0"]
+    pub LINES_FILTER_MAP_OK,
+    suspicious,
+    "filtering `std::io::Lines` with `filter_map()` or `flat_map()` might cause an infinite loop"
+}
+declare_lint_pass!(LinesFilterMapOk => [LINES_FILTER_MAP_OK]);
+
+impl LateLintPass<'_> for LinesFilterMapOk {
+    fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
+        if let ExprKind::MethodCall(fm_method, fm_receiver, [fm_arg], fm_span) = expr.kind &&
+            is_trait_method(cx, expr, sym::Iterator) &&
+            (fm_method.ident.as_str() == "filter_map" || fm_method.ident.as_str() == "flat_map") &&
+            match_type(cx, cx.typeck_results().expr_ty_adjusted(fm_receiver), &paths::STD_IO_LINES)
+        {
+            let lint = match &fm_arg.kind {
+                // Detect `Result::ok`
+                ExprKind::Path(qpath) =>
+                    cx.qpath_res(qpath, fm_arg.hir_id).opt_def_id().map(|did|
+                        match_def_path(cx, did, &paths::CORE_RESULT_OK_METHOD)).unwrap_or_default(),
+                // Detect `|x| x.ok()`
+                ExprKind::Closure(Closure { body, .. }) =>
+                    if let Body { params: [param], value, .. } = cx.tcx.hir().body(*body) &&
+                        let ExprKind::MethodCall(method, receiver, [], _) = value.kind &&
+                        path_to_local_id(receiver, param.pat.hir_id) &&
+                        let Some(method_did) = cx.typeck_results().type_dependent_def_id(value.hir_id)
+                    {
+                        is_diag_item_method(cx, method_did, sym::Result) && method.ident.as_str() == "ok"
+                    } else {
+                        false
+                    }
+                _ => false,
+            };
+            if lint {
+                span_lint_and_then(cx,
+                    LINES_FILTER_MAP_OK,
+                    fm_span,
+                    &format!("`{}()` will run forever if the iterator repeatedly produces an `Err`", fm_method.ident),
+                    |diag| {
+                        diag.span_note(
+                            fm_receiver.span,
+                            "this expression returning a `std::io::Lines` may produce an infinite number of `Err` in case of a read error");
+                        diag.span_suggestion(fm_span, "replace with", "map_while(Result::ok)", Applicability::MaybeIncorrect);
+                    });
+                }
+        }
+    }
+}
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index c919575bfe9..9be2d0eae80 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -23,6 +23,7 @@ pub const CLONE_TRAIT_METHOD: [&str; 4] = ["core", "clone", "Clone", "clone"];
 pub const CORE_ITER_CLONED: [&str; 6] = ["core", "iter", "traits", "iterator", "Iterator", "cloned"];
 pub const CORE_ITER_COPIED: [&str; 6] = ["core", "iter", "traits", "iterator", "Iterator", "copied"];
 pub const CORE_ITER_FILTER: [&str; 6] = ["core", "iter", "traits", "iterator", "Iterator", "filter"];
+pub const CORE_RESULT_OK_METHOD: [&str; 4] = ["core", "result", "Result", "ok"];
 pub const CSTRING_AS_C_STR: [&str; 5] = ["alloc", "ffi", "c_str", "CString", "as_c_str"];
 pub const DEFAULT_TRAIT_METHOD: [&str; 4] = ["core", "default", "Default", "default"];
 pub const DEREF_MUT_TRAIT_METHOD: [&str; 5] = ["core", "ops", "deref", "DerefMut", "deref_mut"];
@@ -113,6 +114,7 @@ pub const STDERR: [&str; 4] = ["std", "io", "stdio", "stderr"];
 pub const STDOUT: [&str; 4] = ["std", "io", "stdio", "stdout"];
 pub const CONVERT_IDENTITY: [&str; 3] = ["core", "convert", "identity"];
 pub const STD_FS_CREATE_DIR: [&str; 3] = ["std", "fs", "create_dir"];
+pub const STD_IO_LINES: [&str; 3] = ["std", "io", "Lines"];
 pub const STD_IO_SEEK: [&str; 3] = ["std", "io", "Seek"];
 pub const STD_IO_SEEK_FROM_CURRENT: [&str; 4] = ["std", "io", "SeekFrom", "Current"];
 pub const STD_IO_SEEKFROM_START: [&str; 4] = ["std", "io", "SeekFrom", "Start"];
diff --git a/tests/ui/lines_filter_map_ok.fixed b/tests/ui/lines_filter_map_ok.fixed
new file mode 100644
index 00000000000..f4033cd8ed8
--- /dev/null
+++ b/tests/ui/lines_filter_map_ok.fixed
@@ -0,0 +1,29 @@
+// run-rustfix
+
+#![allow(unused, clippy::map_identity)]
+#![warn(clippy::lines_filter_map_ok)]
+
+use std::io::{self, BufRead, BufReader};
+
+fn main() -> io::Result<()> {
+    let f = std::fs::File::open("/")?;
+    // Lint
+    BufReader::new(f).lines().map_while(Result::ok).for_each(|_| ());
+    // Lint
+    let f = std::fs::File::open("/")?;
+    BufReader::new(f).lines().map_while(Result::ok).for_each(|_| ());
+    let s = "foo\nbar\nbaz\n";
+    // Lint
+    io::stdin().lines().map_while(Result::ok).for_each(|_| ());
+    // Lint
+    io::stdin().lines().map_while(Result::ok).for_each(|_| ());
+    // Do not lint (not a `Lines` iterator)
+    io::stdin()
+        .lines()
+        .map(std::convert::identity)
+        .filter_map(|x| x.ok())
+        .for_each(|_| ());
+    // Do not lint (not a `Result::ok()` extractor)
+    io::stdin().lines().filter_map(|x| x.err()).for_each(|_| ());
+    Ok(())
+}
diff --git a/tests/ui/lines_filter_map_ok.rs b/tests/ui/lines_filter_map_ok.rs
new file mode 100644
index 00000000000..7e11816b2ac
--- /dev/null
+++ b/tests/ui/lines_filter_map_ok.rs
@@ -0,0 +1,29 @@
+// run-rustfix
+
+#![allow(unused, clippy::map_identity)]
+#![warn(clippy::lines_filter_map_ok)]
+
+use std::io::{self, BufRead, BufReader};
+
+fn main() -> io::Result<()> {
+    let f = std::fs::File::open("/")?;
+    // Lint
+    BufReader::new(f).lines().filter_map(Result::ok).for_each(|_| ());
+    // Lint
+    let f = std::fs::File::open("/")?;
+    BufReader::new(f).lines().flat_map(Result::ok).for_each(|_| ());
+    let s = "foo\nbar\nbaz\n";
+    // Lint
+    io::stdin().lines().filter_map(Result::ok).for_each(|_| ());
+    // Lint
+    io::stdin().lines().filter_map(|x| x.ok()).for_each(|_| ());
+    // Do not lint (not a `Lines` iterator)
+    io::stdin()
+        .lines()
+        .map(std::convert::identity)
+        .filter_map(|x| x.ok())
+        .for_each(|_| ());
+    // Do not lint (not a `Result::ok()` extractor)
+    io::stdin().lines().filter_map(|x| x.err()).for_each(|_| ());
+    Ok(())
+}
diff --git a/tests/ui/lines_filter_map_ok.stderr b/tests/ui/lines_filter_map_ok.stderr
new file mode 100644
index 00000000000..cddd403d589
--- /dev/null
+++ b/tests/ui/lines_filter_map_ok.stderr
@@ -0,0 +1,51 @@
+error: `filter_map()` will run forever if the iterator repeatedly produces an `Err`
+  --> $DIR/lines_filter_map_ok.rs:11:31
+   |
+LL |     BufReader::new(f).lines().filter_map(Result::ok).for_each(|_| ());
+   |                               ^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `map_while(Result::ok)`
+   |
+note: this expression returning a `std::io::Lines` may produce an infinite number of `Err` in case of a read error
+  --> $DIR/lines_filter_map_ok.rs:11:5
+   |
+LL |     BufReader::new(f).lines().filter_map(Result::ok).for_each(|_| ());
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
+   = note: `-D clippy::lines-filter-map-ok` implied by `-D warnings`
+
+error: `flat_map()` will run forever if the iterator repeatedly produces an `Err`
+  --> $DIR/lines_filter_map_ok.rs:14:31
+   |
+LL |     BufReader::new(f).lines().flat_map(Result::ok).for_each(|_| ());
+   |                               ^^^^^^^^^^^^^^^^^^^^ help: replace with: `map_while(Result::ok)`
+   |
+note: this expression returning a `std::io::Lines` may produce an infinite number of `Err` in case of a read error
+  --> $DIR/lines_filter_map_ok.rs:14:5
+   |
+LL |     BufReader::new(f).lines().flat_map(Result::ok).for_each(|_| ());
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: `filter_map()` will run forever if the iterator repeatedly produces an `Err`
+  --> $DIR/lines_filter_map_ok.rs:17:25
+   |
+LL |     io::stdin().lines().filter_map(Result::ok).for_each(|_| ());
+   |                         ^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `map_while(Result::ok)`
+   |
+note: this expression returning a `std::io::Lines` may produce an infinite number of `Err` in case of a read error
+  --> $DIR/lines_filter_map_ok.rs:17:5
+   |
+LL |     io::stdin().lines().filter_map(Result::ok).for_each(|_| ());
+   |     ^^^^^^^^^^^^^^^^^^^
+
+error: `filter_map()` will run forever if the iterator repeatedly produces an `Err`
+  --> $DIR/lines_filter_map_ok.rs:19:25
+   |
+LL |     io::stdin().lines().filter_map(|x| x.ok()).for_each(|_| ());
+   |                         ^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `map_while(Result::ok)`
+   |
+note: this expression returning a `std::io::Lines` may produce an infinite number of `Err` in case of a read error
+  --> $DIR/lines_filter_map_ok.rs:19:5
+   |
+LL |     io::stdin().lines().filter_map(|x| x.ok()).for_each(|_| ());
+   |     ^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 4 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From b2856a763e2dcb4ffeaf918a7c0d54f6e950cc21 Mon Sep 17 00:00:00 2001
From: blyxyas <blyxyas@gmail.com>
Date: Fri, 24 Mar 2023 22:39:26 +0100
Subject: Add `tests_outside_test_module` lint

---
 CHANGELOG.md                                  |   1 +
 clippy_lints/src/declared_lints.rs            |   1 +
 clippy_lints/src/lib.rs                       |   2 +
 clippy_lints/src/tests_outside_test_module.rs | 101 ++++++++++++++++++++++++++
 tests/ui/tests_outside_test_module.rs         |  18 +++++
 tests/ui/tests_outside_test_module.stderr     |  11 +++
 6 files changed, 134 insertions(+)
 create mode 100644 clippy_lints/src/tests_outside_test_module.rs
 create mode 100644 tests/ui/tests_outside_test_module.rs
 create mode 100644 tests/ui/tests_outside_test_module.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 239631777e9..ba10cb53ec9 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4936,6 +4936,7 @@ Released 2018-09-13
 [`tabs_in_doc_comments`]: https://rust-lang.github.io/rust-clippy/master/index.html#tabs_in_doc_comments
 [`temporary_assignment`]: https://rust-lang.github.io/rust-clippy/master/index.html#temporary_assignment
 [`temporary_cstring_as_ptr`]: https://rust-lang.github.io/rust-clippy/master/index.html#temporary_cstring_as_ptr
+[`tests_outside_test_module`]: https://rust-lang.github.io/rust-clippy/master/index.html#tests_outside_test_module
 [`to_digit_is_some`]: https://rust-lang.github.io/rust-clippy/master/index.html#to_digit_is_some
 [`to_string_in_display`]: https://rust-lang.github.io/rust-clippy/master/index.html#to_string_in_display
 [`to_string_in_format_args`]: https://rust-lang.github.io/rust-clippy/master/index.html#to_string_in_format_args
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 7836e5ccb9a..b4510557033 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -577,6 +577,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::swap_ptr_to_ref::SWAP_PTR_TO_REF_INFO,
     crate::tabs_in_doc_comments::TABS_IN_DOC_COMMENTS_INFO,
     crate::temporary_assignment::TEMPORARY_ASSIGNMENT_INFO,
+    crate::tests_outside_test_module::TESTS_OUTSIDE_TEST_MODULE_INFO,
     crate::to_digit_is_some::TO_DIGIT_IS_SOME_INFO,
     crate::trailing_empty_array::TRAILING_EMPTY_ARRAY_INFO,
     crate::trait_bounds::TRAIT_DUPLICATION_IN_BOUNDS_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index ce055f16240..c63abf0979d 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -291,6 +291,7 @@ mod swap;
 mod swap_ptr_to_ref;
 mod tabs_in_doc_comments;
 mod temporary_assignment;
+mod tests_outside_test_module;
 mod to_digit_is_some;
 mod trailing_empty_array;
 mod trait_bounds;
@@ -951,6 +952,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         ))
     });
     store.register_late_pass(|_| Box::new(lines_filter_map_ok::LinesFilterMapOk));
+    store.register_late_pass(|_| Box::new(tests_outside_test_module::TestsOutsideTestModule::new()));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/tests_outside_test_module.rs b/clippy_lints/src/tests_outside_test_module.rs
new file mode 100644
index 00000000000..d14a292a52f
--- /dev/null
+++ b/clippy_lints/src/tests_outside_test_module.rs
@@ -0,0 +1,101 @@
+use clippy_utils::{diagnostics::span_lint_and_note, is_in_cfg_test, is_in_test_function, is_test_module_or_function};
+use rustc_data_structures::sync::par_for_each_in;
+use rustc_hir::{intravisit::FnKind, Body, FnDecl, HirId, ItemKind, Mod};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::{def_id::LocalDefId, Span};
+
+declare_clippy_lint! {
+    /// ### What it does
+    ///
+    /// Triggers when a testing function (marked with the `#[test]` attribute) isn't inside a testing module (marked with `#[cfg(test)]`).
+    ///
+    /// ### Why is this bad?
+    ///
+    /// The idiomatic (and more performant) way of writing tests is inside a testing module (flagged with `#[cfg(test)]`), having test functions outside of this module is confusing and may lead to them being "hidden".
+    ///
+    /// ### Example
+    /// ```rust
+    /// #[test]
+    /// fn my_cool_test() {
+    ///     // [...]
+    /// }
+    ///
+    /// #[cfg(test)]
+    /// mod tests {
+    ///     // [...]
+    /// }
+    ///
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// #[cfg(test)]
+    /// mod tests {
+    ///     #[test]
+    ///     fn my_cool_test() {
+    ///         // [...]
+    ///     }
+    /// }
+    /// ```
+    #[clippy::version = "1.70.0"]
+    pub TESTS_OUTSIDE_TEST_MODULE,
+    restriction,
+    "The test function `my_cool_test` is outside the testing module `tests`."
+}
+
+pub(crate) struct TestsOutsideTestModule {
+    pub test_mod_exists: bool,
+}
+
+impl TestsOutsideTestModule {
+    pub fn new() -> Self {
+        Self { test_mod_exists: false }
+    }
+}
+
+impl_lint_pass!(TestsOutsideTestModule => [TESTS_OUTSIDE_TEST_MODULE]);
+
+impl LateLintPass<'_> for TestsOutsideTestModule {
+    fn check_mod(&mut self, cx: &LateContext<'_>, _: &Mod<'_>, _: HirId) {
+        self.test_mod_exists = false;
+
+        // par_for_each_item uses Fn, while par_for_each_in uses FnMut
+        par_for_each_in(cx.tcx.hir_crate_items(()).items(), |itemid| {
+            let item = cx.tcx.hir().item(itemid);
+            if_chain! {
+                if matches!(item.kind, ItemKind::Mod(_));
+                if is_test_module_or_function(cx.tcx, item);
+                then {
+                    self.test_mod_exists = true;
+                }
+            }
+        });
+    }
+
+    fn check_fn(
+        &mut self,
+        cx: &LateContext<'_>,
+        kind: FnKind<'_>,
+        _: &FnDecl<'_>,
+        body: &Body<'_>,
+        sp: Span,
+        _: LocalDefId,
+    ) {
+        if_chain! {
+            if !matches!(kind, FnKind::Closure);
+            if self.test_mod_exists;
+            if is_in_test_function(cx.tcx, body.id().hir_id);
+            if !is_in_cfg_test(cx.tcx, body.id().hir_id);
+            then {
+                span_lint_and_note(
+                    cx,
+                    TESTS_OUTSIDE_TEST_MODULE,
+                    sp,
+                    "this function marked with #[test] is outside a #[cfg(test)] module",
+                    None,
+                    "move it to a testing module marked with #[cfg(test)]",
+                );
+            }
+        }
+    }
+}
diff --git a/tests/ui/tests_outside_test_module.rs b/tests/ui/tests_outside_test_module.rs
new file mode 100644
index 00000000000..1982b1d0107
--- /dev/null
+++ b/tests/ui/tests_outside_test_module.rs
@@ -0,0 +1,18 @@
+// compile-flags: --test
+#![allow(unused)]
+#![warn(clippy::tests_outside_test_module)]
+
+fn main() {
+    // test code goes here
+}
+
+// Should lint
+#[test]
+fn my_test() {}
+
+#[cfg(test)]
+mod tests {
+    // Should not lint
+    #[test]
+    fn my_test() {}
+}
diff --git a/tests/ui/tests_outside_test_module.stderr b/tests/ui/tests_outside_test_module.stderr
new file mode 100644
index 00000000000..125a79d6edf
--- /dev/null
+++ b/tests/ui/tests_outside_test_module.stderr
@@ -0,0 +1,11 @@
+error: this function marked with #[test] is outside a #[cfg(test)] module
+  --> $DIR/tests_outside_test_module.rs:11:1
+   |
+LL | fn my_test() {}
+   | ^^^^^^^^^^^^^^^
+   |
+   = note: move it to a testing module marked with #[cfg(test)]
+   = note: `-D clippy::tests-outside-test-module` implied by `-D warnings`
+
+error: aborting due to previous error
+
-- 
cgit 1.4.1-3-g733a5


From 05650b7215bfda4c03cab8acc16b83e67139d7de Mon Sep 17 00:00:00 2001
From: Caio <c410.f3r@gmail.com>
Date: Sun, 2 Apr 2023 07:50:25 -0300
Subject: [arithmetic_side_effects] Fix #10583

---
 clippy_lints/src/operators/arithmetic_side_effects.rs | 12 ++++++++++--
 tests/ui/arithmetic_side_effects.rs                   |  4 ++++
 tests/ui/arithmetic_side_effects.stderr               | 14 +++++++++++++-
 3 files changed, 27 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/operators/arithmetic_side_effects.rs b/clippy_lints/src/operators/arithmetic_side_effects.rs
index 25e8de94863..e5713735672 100644
--- a/clippy_lints/src/operators/arithmetic_side_effects.rs
+++ b/clippy_lints/src/operators/arithmetic_side_effects.rs
@@ -154,10 +154,18 @@ impl ArithmeticSideEffects {
                 Self::literal_integer(cx, actual_rhs),
             ) {
                 (None, None) => false,
-                (None, Some(n)) | (Some(n), None) => match (&op.node, n) {
+                (None, Some(n)) => match (&op.node, n) {
                     // Division and module are always valid if applied to non-zero integers
                     (hir::BinOpKind::Div | hir::BinOpKind::Rem, local_n) if local_n != 0 => true,
-                    // Addition or subtracting zeros is always a no-op
+                    // Adding or subtracting zeros is always a no-op
+                    (hir::BinOpKind::Add | hir::BinOpKind::Sub, 0)
+                    // Multiplication by 1 or 0 will never overflow
+                    | (hir::BinOpKind::Mul, 0 | 1)
+                    => true,
+                    _ => false,
+                },
+                (Some(n), None) => match (&op.node, n) {
+                    // Adding or subtracting zeros is always a no-op
                     (hir::BinOpKind::Add | hir::BinOpKind::Sub, 0)
                     // Multiplication by 1 or 0 will never overflow
                     | (hir::BinOpKind::Mul, 0 | 1)
diff --git a/tests/ui/arithmetic_side_effects.rs b/tests/ui/arithmetic_side_effects.rs
index ee7d2ba444b..3c06676d722 100644
--- a/tests/ui/arithmetic_side_effects.rs
+++ b/tests/ui/arithmetic_side_effects.rs
@@ -425,4 +425,8 @@ pub fn integer_arithmetic() {
     i ^= i;
 }
 
+pub fn issue_10583(a: u16) -> u16 {
+    10 / a
+}
+
 fn main() {}
diff --git a/tests/ui/arithmetic_side_effects.stderr b/tests/ui/arithmetic_side_effects.stderr
index 3895f08964c..2c8ee2884e7 100644
--- a/tests/ui/arithmetic_side_effects.stderr
+++ b/tests/ui/arithmetic_side_effects.stderr
@@ -576,6 +576,12 @@ error: arithmetic operation that can potentially result in unexpected side-effec
 LL |     i * 2;
    |     ^^^^^
 
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:394:5
+   |
+LL |     1 % i / 2;
+   |     ^^^^^
+
 error: arithmetic operation that can potentially result in unexpected side-effects
   --> $DIR/arithmetic_side_effects.rs:395:5
    |
@@ -642,5 +648,11 @@ error: arithmetic operation that can potentially result in unexpected side-effec
 LL |     i %= var2;
    |     ^^^^^^^^^
 
-error: aborting due to 107 previous errors
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:429:5
+   |
+LL |     10 / a
+   |     ^^^^^^
+
+error: aborting due to 109 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 36047b0216b9fb4741e8927c7e6b644727e02fdf Mon Sep 17 00:00:00 2001
From: blyxyas <blyxyas@gmail.com>
Date: Sun, 2 Apr 2023 16:18:03 +0200
Subject: Fix `nonminimal_bool` `#[allow]` attributes.

---
 clippy_lints/src/booleans.rs | 39 +++++++++++++++++++++------------------
 tests/ui/nonminimal_bool.rs  | 18 ++++++++++++++++++
 2 files changed, 39 insertions(+), 18 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/booleans.rs b/clippy_lints/src/booleans.rs
index 29fde9336c0..455f0df7cd0 100644
--- a/clippy_lints/src/booleans.rs
+++ b/clippy_lints/src/booleans.rs
@@ -7,7 +7,7 @@ use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_expr, FnKind, Visitor};
 use rustc_hir::{BinOpKind, Body, Expr, ExprKind, FnDecl, UnOp};
-use rustc_lint::{LateContext, LateLintPass};
+use rustc_lint::{LateContext, LateLintPass, Level};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::def_id::LocalDefId;
 use rustc_span::source_map::Span;
@@ -430,23 +430,25 @@ impl<'a, 'tcx> NonminimalBoolVisitor<'a, 'tcx> {
                 }
             }
             let nonminimal_bool_lint = |suggestions: Vec<_>| {
-                span_lint_hir_and_then(
-                    self.cx,
-                    NONMINIMAL_BOOL,
-                    e.hir_id,
-                    e.span,
-                    "this boolean expression can be simplified",
-                    |diag| {
-                        diag.span_suggestions(
-                            e.span,
-                            "try",
-                            suggestions.into_iter(),
-                            // nonminimal_bool can produce minimal but
-                            // not human readable expressions (#3141)
-                            Applicability::Unspecified,
-                        );
-                    },
-                );
+                if self.cx.tcx.lint_level_at_node(NONMINIMAL_BOOL, e.hir_id).0 != Level::Allow {
+                    span_lint_hir_and_then(
+                        self.cx,
+                        NONMINIMAL_BOOL,
+                        e.hir_id,
+                        e.span,
+                        "this boolean expression can be simplified",
+                        |diag| {
+                            diag.span_suggestions(
+                                e.span,
+                                "try",
+                                suggestions.into_iter(),
+                                // nonminimal_bool can produce minimal but
+                                // not human readable expressions (#3141)
+                                Applicability::Unspecified,
+                            );
+                        },
+                    );
+                }
             };
             if improvements.is_empty() {
                 let mut visitor = NotSimplificationVisitor { cx: self.cx };
@@ -498,6 +500,7 @@ impl<'a, 'tcx> Visitor<'tcx> for NotSimplificationVisitor<'a, 'tcx> {
         if let ExprKind::Unary(UnOp::Not, inner) = &expr.kind &&
             !inner.span.from_expansion() &&
             let Some(suggestion) = simplify_not(self.cx, inner)
+			&& self.cx.tcx.lint_level_at_node(NONMINIMAL_BOOL, expr.hir_id).0 != Level::Allow
         {
             span_lint_and_sugg(
                 self.cx,
diff --git a/tests/ui/nonminimal_bool.rs b/tests/ui/nonminimal_bool.rs
index 3b5a374b4a7..80cc7c60f56 100644
--- a/tests/ui/nonminimal_bool.rs
+++ b/tests/ui/nonminimal_bool.rs
@@ -92,3 +92,21 @@ fn issue_10523_2() {
     }
     if a!() {}
 }
+
+fn issue_10435() {
+    let x = vec![0];
+    let y = vec![1];
+    let z = vec![2];
+
+    // vvv Should not lint
+    #[allow(clippy::nonminimal_bool)]
+    if !x.is_empty() && !(y.is_empty() || z.is_empty()) {
+        println!("{}", line!());
+    }
+
+    // vvv Should not lint (#10435 talks about a bug where it lints)
+    #[allow(clippy::nonminimal_bool)]
+    if !(x == [0]) {
+        println!("{}", line!());
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From e2742a0ea24b4c596514021d0c94ff5a78ff0757 Mon Sep 17 00:00:00 2001
From: blyxyas <blyxyas@gmail.com>
Date: Mon, 3 Apr 2023 01:27:53 +0200
Subject: Fix `double_must_use` for async functions

---
 clippy_lints/src/functions/must_use.rs | 7 ++++---
 tests/ui/double_must_use.rs            | 6 ++++++
 2 files changed, 10 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/functions/must_use.rs b/clippy_lints/src/functions/must_use.rs
index 1e9e826631c..56acd31b1d2 100644
--- a/clippy_lints/src/functions/must_use.rs
+++ b/clippy_lints/src/functions/must_use.rs
@@ -23,7 +23,8 @@ use super::{DOUBLE_MUST_USE, MUST_USE_CANDIDATE, MUST_USE_UNIT};
 pub(super) fn check_item<'tcx>(cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) {
     let attrs = cx.tcx.hir().attrs(item.hir_id());
     let attr = cx.tcx.get_attr(item.owner_id, sym::must_use);
-    if let hir::ItemKind::Fn(ref sig, _generics, ref body_id) = item.kind {
+    if let hir::ItemKind::Fn(ref sig, _generics, ref body_id) = item.kind && !sig.header.is_async() /* (#10486) */ {
+
         let is_public = cx.effective_visibilities.is_exported(item.owner_id.def_id);
         let fn_header_span = item.span.with_hi(sig.decl.output.span().hi());
         if let Some(attr) = attr {
@@ -43,7 +44,7 @@ pub(super) fn check_item<'tcx>(cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>
 }
 
 pub(super) fn check_impl_item<'tcx>(cx: &LateContext<'tcx>, item: &'tcx hir::ImplItem<'_>) {
-    if let hir::ImplItemKind::Fn(ref sig, ref body_id) = item.kind {
+    if let hir::ImplItemKind::Fn(ref sig, ref body_id) = item.kind && !sig.header.is_async() /* (#10486) */ {
         let is_public = cx.effective_visibilities.is_exported(item.owner_id.def_id);
         let fn_header_span = item.span.with_hi(sig.decl.output.span().hi());
         let attrs = cx.tcx.hir().attrs(item.hir_id());
@@ -65,7 +66,7 @@ pub(super) fn check_impl_item<'tcx>(cx: &LateContext<'tcx>, item: &'tcx hir::Imp
 }
 
 pub(super) fn check_trait_item<'tcx>(cx: &LateContext<'tcx>, item: &'tcx hir::TraitItem<'_>) {
-    if let hir::TraitItemKind::Fn(ref sig, ref eid) = item.kind {
+    if let hir::TraitItemKind::Fn(ref sig, ref eid) = item.kind && !sig.header.is_async() /* (#10486) */ {
         let is_public = cx.effective_visibilities.is_exported(item.owner_id.def_id);
         let fn_header_span = item.span.with_hi(sig.decl.output.span().hi());
 
diff --git a/tests/ui/double_must_use.rs b/tests/ui/double_must_use.rs
index 05e087b08bc..a4cd8630de5 100644
--- a/tests/ui/double_must_use.rs
+++ b/tests/ui/double_must_use.rs
@@ -21,6 +21,12 @@ pub fn must_use_with_note() -> Result<(), ()> {
     unimplemented!();
 }
 
+// vvvv Should not lint (#10486)
+#[must_use]
+async fn async_must_use() -> usize {
+    unimplemented!();
+}
+
 fn main() {
     must_use_result();
     must_use_tuple();
-- 
cgit 1.4.1-3-g733a5


From d60274355894c0e0768b034ab538aa0625fc2a91 Mon Sep 17 00:00:00 2001
From: blyxyas <blyxyas@gmail.com>
Date: Mon, 3 Apr 2023 15:15:43 +0200
Subject: only focus on `double_must_use` + Add `Result<(), ()>` test

---
 clippy_lints/src/functions/must_use.rs | 17 +++++++++--------
 tests/ui/double_must_use.rs            |  5 +++++
 2 files changed, 14 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/functions/must_use.rs b/clippy_lints/src/functions/must_use.rs
index 56acd31b1d2..ab68d7a3726 100644
--- a/clippy_lints/src/functions/must_use.rs
+++ b/clippy_lints/src/functions/must_use.rs
@@ -1,3 +1,4 @@
+use hir::FnSig;
 use rustc_ast::ast::Attribute;
 use rustc_errors::Applicability;
 use rustc_hir::def_id::DefIdSet;
@@ -23,12 +24,11 @@ use super::{DOUBLE_MUST_USE, MUST_USE_CANDIDATE, MUST_USE_UNIT};
 pub(super) fn check_item<'tcx>(cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) {
     let attrs = cx.tcx.hir().attrs(item.hir_id());
     let attr = cx.tcx.get_attr(item.owner_id, sym::must_use);
-    if let hir::ItemKind::Fn(ref sig, _generics, ref body_id) = item.kind && !sig.header.is_async() /* (#10486) */ {
-
+    if let hir::ItemKind::Fn(ref sig, _generics, ref body_id) = item.kind {
         let is_public = cx.effective_visibilities.is_exported(item.owner_id.def_id);
         let fn_header_span = item.span.with_hi(sig.decl.output.span().hi());
         if let Some(attr) = attr {
-            check_needless_must_use(cx, sig.decl, item.owner_id, item.span, fn_header_span, attr);
+            check_needless_must_use(cx, sig.decl, item.owner_id, item.span, fn_header_span, attr, sig);
         } else if is_public && !is_proc_macro(attrs) && !attrs.iter().any(|a| a.has_name(sym::no_mangle)) {
             check_must_use_candidate(
                 cx,
@@ -44,13 +44,13 @@ pub(super) fn check_item<'tcx>(cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>
 }
 
 pub(super) fn check_impl_item<'tcx>(cx: &LateContext<'tcx>, item: &'tcx hir::ImplItem<'_>) {
-    if let hir::ImplItemKind::Fn(ref sig, ref body_id) = item.kind && !sig.header.is_async() /* (#10486) */ {
+    if let hir::ImplItemKind::Fn(ref sig, ref body_id) = item.kind {
         let is_public = cx.effective_visibilities.is_exported(item.owner_id.def_id);
         let fn_header_span = item.span.with_hi(sig.decl.output.span().hi());
         let attrs = cx.tcx.hir().attrs(item.hir_id());
         let attr = cx.tcx.get_attr(item.owner_id, sym::must_use);
         if let Some(attr) = attr {
-            check_needless_must_use(cx, sig.decl, item.owner_id, item.span, fn_header_span, attr);
+            check_needless_must_use(cx, sig.decl, item.owner_id, item.span, fn_header_span, attr, sig);
         } else if is_public && !is_proc_macro(attrs) && trait_ref_of_method(cx, item.owner_id.def_id).is_none() {
             check_must_use_candidate(
                 cx,
@@ -66,14 +66,14 @@ pub(super) fn check_impl_item<'tcx>(cx: &LateContext<'tcx>, item: &'tcx hir::Imp
 }
 
 pub(super) fn check_trait_item<'tcx>(cx: &LateContext<'tcx>, item: &'tcx hir::TraitItem<'_>) {
-    if let hir::TraitItemKind::Fn(ref sig, ref eid) = item.kind && !sig.header.is_async() /* (#10486) */ {
+    if let hir::TraitItemKind::Fn(ref sig, ref eid) = item.kind {
         let is_public = cx.effective_visibilities.is_exported(item.owner_id.def_id);
         let fn_header_span = item.span.with_hi(sig.decl.output.span().hi());
 
         let attrs = cx.tcx.hir().attrs(item.hir_id());
         let attr = cx.tcx.get_attr(item.owner_id, sym::must_use);
         if let Some(attr) = attr {
-            check_needless_must_use(cx, sig.decl, item.owner_id, item.span, fn_header_span, attr);
+            check_needless_must_use(cx, sig.decl, item.owner_id, item.span, fn_header_span, attr, sig);
         } else if let hir::TraitFn::Provided(eid) = *eid {
             let body = cx.tcx.hir().body(eid);
             if attr.is_none() && is_public && !is_proc_macro(attrs) {
@@ -98,6 +98,7 @@ fn check_needless_must_use(
     item_span: Span,
     fn_header_span: Span,
     attr: &Attribute,
+    sig: &FnSig<'_>,
 ) {
     if in_external_macro(cx.sess(), item_span) {
         return;
@@ -112,7 +113,7 @@ fn check_needless_must_use(
                 diag.span_suggestion(attr.span, "remove the attribute", "", Applicability::MachineApplicable);
             },
         );
-    } else if attr.value_str().is_none() && is_must_use_ty(cx, return_ty(cx, item_id)) {
+    } else if attr.value_str().is_none() && is_must_use_ty(cx, return_ty(cx, item_id)) && !sig.header.is_async() {
         span_lint_and_help(
             cx,
             DOUBLE_MUST_USE,
diff --git a/tests/ui/double_must_use.rs b/tests/ui/double_must_use.rs
index a4cd8630de5..26a387b3cf0 100644
--- a/tests/ui/double_must_use.rs
+++ b/tests/ui/double_must_use.rs
@@ -27,6 +27,11 @@ async fn async_must_use() -> usize {
     unimplemented!();
 }
 
+#[must_use]
+async fn async_must_use_result() -> Result<(), ()> {
+    Ok(())
+}
+
 fn main() {
     must_use_result();
     must_use_tuple();
-- 
cgit 1.4.1-3-g733a5


From afdfbf8fdea085f62ec64537135170a748c991d4 Mon Sep 17 00:00:00 2001
From: bhould287 <bhould287@gmail.com>
Date: Sat, 1 Apr 2023 21:30:39 +0100
Subject: Show multiple clippy.toml warnings with `sess.warn` instead of
 `eprintln!`

---
 clippy_lints/src/lib.rs                               | 14 +++++++++-----
 clippy_lints/src/utils/conf.rs                        | 19 ++++++++++---------
 src/driver.rs                                         |  2 +-
 .../multiple_config_files/warn/src/main.stderr        |  6 ++++--
 4 files changed, 24 insertions(+), 17 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index ce055f16240..51e21765953 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -348,13 +348,17 @@ pub fn register_pre_expansion_lints(store: &mut rustc_lint::LintStore, sess: &Se
 }
 
 #[doc(hidden)]
-pub fn read_conf(sess: &Session, path: &io::Result<Option<PathBuf>>) -> Conf {
+pub fn read_conf(sess: &Session, path: &io::Result<(Option<PathBuf>, Vec<String>)>) -> Conf {
+    if let Ok((_, warnings)) = path {
+        for warning in warnings {
+            sess.warn(warning);
+        }
+    }
     let file_name = match path {
-        Ok(Some(path)) => path,
-        Ok(None) => return Conf::default(),
+        Ok((Some(path), _)) => path,
+        Ok((None, _)) => return Conf::default(),
         Err(error) => {
-            sess.struct_err(format!("error finding Clippy's configuration file: {error}"))
-                .emit();
+            sess.err(format!("error finding Clippy's configuration file: {error}"));
             return Conf::default();
         },
     };
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index f75a5cf7196..25626897b51 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -470,7 +470,7 @@ define_Conf! {
 /// # Errors
 ///
 /// Returns any unexpected filesystem error encountered when searching for the config file
-pub fn lookup_conf_file() -> io::Result<Option<PathBuf>> {
+pub fn lookup_conf_file() -> io::Result<(Option<PathBuf>, Vec<String>)> {
     /// Possible filename to search for.
     const CONFIG_FILE_NAMES: [&str; 2] = [".clippy.toml", "clippy.toml"];
 
@@ -481,6 +481,7 @@ pub fn lookup_conf_file() -> io::Result<Option<PathBuf>> {
         .map_or_else(|| PathBuf::from("."), PathBuf::from);
 
     let mut found_config: Option<PathBuf> = None;
+    let mut warnings = vec![];
 
     loop {
         for config_file_name in &CONFIG_FILE_NAMES {
@@ -491,12 +492,12 @@ pub fn lookup_conf_file() -> io::Result<Option<PathBuf>> {
                     Ok(md) if md.is_dir() => {},
                     Ok(_) => {
                         // warn if we happen to find two config files #8323
-                        if let Some(ref found_config_) = found_config {
-                            eprintln!(
-                                "Using config file `{}`\nWarning: `{}` will be ignored.",
-                                found_config_.display(),
-                                config_file.display(),
-                            );
+                        if let Some(ref found_config) = found_config {
+                            warnings.push(format!(
+                                "using config file `{}`, `{}` will be ignored",
+                                found_config.display(),
+                                config_file.display()
+                            ));
                         } else {
                             found_config = Some(config_file);
                         }
@@ -506,12 +507,12 @@ pub fn lookup_conf_file() -> io::Result<Option<PathBuf>> {
         }
 
         if found_config.is_some() {
-            return Ok(found_config);
+            return Ok((found_config, warnings));
         }
 
         // If the current directory has no parent, we're done searching.
         if !current.pop() {
-            return Ok(None);
+            return Ok((None, warnings));
         }
     }
 }
diff --git a/src/driver.rs b/src/driver.rs
index f08393c303e..39f2bf9aa19 100644
--- a/src/driver.rs
+++ b/src/driver.rs
@@ -130,7 +130,7 @@ impl rustc_driver::Callbacks for ClippyCallbacks {
     #[allow(rustc::bad_opt_access)]
     fn config(&mut self, config: &mut interface::Config) {
         let conf_path = clippy_lints::lookup_conf_file();
-        let conf_path_string = if let Ok(Some(path)) = &conf_path {
+        let conf_path_string = if let Ok((Some(path), _)) = &conf_path {
             path.to_str().map(String::from)
         } else {
             None
diff --git a/tests/ui-cargo/multiple_config_files/warn/src/main.stderr b/tests/ui-cargo/multiple_config_files/warn/src/main.stderr
index 98697e001f9..aa1b3c638a0 100644
--- a/tests/ui-cargo/multiple_config_files/warn/src/main.stderr
+++ b/tests/ui-cargo/multiple_config_files/warn/src/main.stderr
@@ -1,2 +1,4 @@
-Using config file `$SRC_DIR/.clippy.toml`
-Warning: `$SRC_DIR/clippy.toml` will be ignored.
+warning: using config file `$SRC_DIR/.clippy.toml`, `$SRC_DIR/clippy.toml` will be ignored
+
+warning: 1 warning emitted
+
-- 
cgit 1.4.1-3-g733a5


From a37eb4dfc97cdcbd177ccc0fda1909014b145635 Mon Sep 17 00:00:00 2001
From: blyxyas <blyxyas@gmail.com>
Date: Mon, 3 Apr 2023 16:01:30 +0200
Subject: Fix false negative on `Result<(), ()>`

---
 clippy_lints/src/functions/must_use.rs | 12 +++++++++++-
 tests/ui/double_must_use.stderr        | 10 +++++++++-
 2 files changed, 20 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/functions/must_use.rs b/clippy_lints/src/functions/must_use.rs
index ab68d7a3726..d0ad2628264 100644
--- a/clippy_lints/src/functions/must_use.rs
+++ b/clippy_lints/src/functions/must_use.rs
@@ -3,6 +3,7 @@ use rustc_ast::ast::Attribute;
 use rustc_errors::Applicability;
 use rustc_hir::def_id::DefIdSet;
 use rustc_hir::{self as hir, def::Res, QPath};
+use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::{LateContext, LintContext};
 use rustc_middle::{
     lint::in_external_macro,
@@ -113,7 +114,16 @@ fn check_needless_must_use(
                 diag.span_suggestion(attr.span, "remove the attribute", "", Applicability::MachineApplicable);
             },
         );
-    } else if attr.value_str().is_none() && is_must_use_ty(cx, return_ty(cx, item_id)) && !sig.header.is_async() {
+    } else if attr.value_str().is_none() && is_must_use_ty(cx, return_ty(cx, item_id)) {
+        // Ignore async functions unless Future::Output type is a must_use type
+        if sig.header.is_async() {
+            let infcx = cx.tcx.infer_ctxt().build();
+            if let Some(future_ty) = infcx.get_impl_future_output_ty(return_ty(cx, item_id))
+			&& !is_must_use_ty(cx, future_ty) {
+				return;
+			}
+        }
+
         span_lint_and_help(
             cx,
             DOUBLE_MUST_USE,
diff --git a/tests/ui/double_must_use.stderr b/tests/ui/double_must_use.stderr
index 3d34557a881..49ab2ea3e12 100644
--- a/tests/ui/double_must_use.stderr
+++ b/tests/ui/double_must_use.stderr
@@ -23,5 +23,13 @@ LL | pub fn must_use_array() -> [Result<(), ()>; 1] {
    |
    = help: either add some descriptive text or remove the attribute
 
-error: aborting due to 3 previous errors
+error: this function has an empty `#[must_use]` attribute, but returns a type already marked as `#[must_use]`
+  --> $DIR/double_must_use.rs:31:1
+   |
+LL | async fn async_must_use_result() -> Result<(), ()> {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: either add some descriptive text or remove the attribute
+
+error: aborting due to 4 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 3b22352d0d16034e112e58b032f1bf0fc1c818ba Mon Sep 17 00:00:00 2001
From: bhould287 <bhould287@gmail.com>
Date: Sat, 1 Apr 2023 21:29:05 +0100
Subject: Fix bug with getting parent directories in `lookup_conf_file`

---
 clippy_lints/src/utils/conf.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 25626897b51..896a01af37d 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -478,7 +478,8 @@ pub fn lookup_conf_file() -> io::Result<(Option<PathBuf>, Vec<String>)> {
     // If neither of those exist, use ".".
     let mut current = env::var_os("CLIPPY_CONF_DIR")
         .or_else(|| env::var_os("CARGO_MANIFEST_DIR"))
-        .map_or_else(|| PathBuf::from("."), PathBuf::from);
+        .map_or_else(|| PathBuf::from("."), PathBuf::from)
+        .canonicalize()?;
 
     let mut found_config: Option<PathBuf> = None;
     let mut warnings = vec![];
-- 
cgit 1.4.1-3-g733a5


From bd2a5b2322729137b26b899947e777c41c9aae96 Mon Sep 17 00:00:00 2001
From: blyxyas <blyxyas@gmail.com>
Date: Mon, 3 Apr 2023 18:42:00 +0200
Subject: Remove check for `#[cfg(test)]`

---
 clippy_lints/src/lib.rs                       |  2 +-
 clippy_lints/src/tests_outside_test_module.rs | 36 +++------------------------
 2 files changed, 5 insertions(+), 33 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index c63abf0979d..c16d6621518 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -952,7 +952,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         ))
     });
     store.register_late_pass(|_| Box::new(lines_filter_map_ok::LinesFilterMapOk));
-    store.register_late_pass(|_| Box::new(tests_outside_test_module::TestsOutsideTestModule::new()));
+    store.register_late_pass(|_| Box::new(tests_outside_test_module::TestsOutsideTestModule));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/tests_outside_test_module.rs b/clippy_lints/src/tests_outside_test_module.rs
index d14a292a52f..e454008c68d 100644
--- a/clippy_lints/src/tests_outside_test_module.rs
+++ b/clippy_lints/src/tests_outside_test_module.rs
@@ -1,8 +1,7 @@
-use clippy_utils::{diagnostics::span_lint_and_note, is_in_cfg_test, is_in_test_function, is_test_module_or_function};
-use rustc_data_structures::sync::par_for_each_in;
-use rustc_hir::{intravisit::FnKind, Body, FnDecl, HirId, ItemKind, Mod};
+use clippy_utils::{diagnostics::span_lint_and_note, is_in_cfg_test, is_in_test_function};
+use rustc_hir::{intravisit::FnKind, Body, FnDecl};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::{def_id::LocalDefId, Span};
 
 declare_clippy_lint! {
@@ -43,35 +42,9 @@ declare_clippy_lint! {
     "The test function `my_cool_test` is outside the testing module `tests`."
 }
 
-pub(crate) struct TestsOutsideTestModule {
-    pub test_mod_exists: bool,
-}
-
-impl TestsOutsideTestModule {
-    pub fn new() -> Self {
-        Self { test_mod_exists: false }
-    }
-}
-
-impl_lint_pass!(TestsOutsideTestModule => [TESTS_OUTSIDE_TEST_MODULE]);
+declare_lint_pass!(TestsOutsideTestModule => [TESTS_OUTSIDE_TEST_MODULE]);
 
 impl LateLintPass<'_> for TestsOutsideTestModule {
-    fn check_mod(&mut self, cx: &LateContext<'_>, _: &Mod<'_>, _: HirId) {
-        self.test_mod_exists = false;
-
-        // par_for_each_item uses Fn, while par_for_each_in uses FnMut
-        par_for_each_in(cx.tcx.hir_crate_items(()).items(), |itemid| {
-            let item = cx.tcx.hir().item(itemid);
-            if_chain! {
-                if matches!(item.kind, ItemKind::Mod(_));
-                if is_test_module_or_function(cx.tcx, item);
-                then {
-                    self.test_mod_exists = true;
-                }
-            }
-        });
-    }
-
     fn check_fn(
         &mut self,
         cx: &LateContext<'_>,
@@ -83,7 +56,6 @@ impl LateLintPass<'_> for TestsOutsideTestModule {
     ) {
         if_chain! {
             if !matches!(kind, FnKind::Closure);
-            if self.test_mod_exists;
             if is_in_test_function(cx.tcx, body.id().hir_id);
             if !is_in_cfg_test(cx.tcx, body.id().hir_id);
             then {
-- 
cgit 1.4.1-3-g733a5


From c12748fab3a14beae4958f13551e7e6c52298490 Mon Sep 17 00:00:00 2001
From: feniljain <fkjainco@gmail.com>
Date: Sat, 1 Apr 2023 16:33:17 +0530
Subject: fix(needless_return): do not trigger on ambiguous match arms return

---
 clippy_lints/src/returns.rs     | 32 +++++++++++++++++++++++++-------
 tests/ui/needless_return.fixed  |  6 +++---
 tests/ui/needless_return.stderr | 12 ++++++------
 3 files changed, 34 insertions(+), 16 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
index f0d7dd23a67..b8172b74dc0 100644
--- a/clippy_lints/src/returns.rs
+++ b/clippy_lints/src/returns.rs
@@ -9,7 +9,7 @@ use rustc_hir::intravisit::FnKind;
 use rustc_hir::{Block, Body, Expr, ExprKind, FnDecl, LangItem, MatchSource, PatKind, QPath, StmtKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_middle::ty::subst::GenericArgKind;
+use rustc_middle::ty::{self, subst::GenericArgKind, Ty};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::def_id::LocalDefId;
 use rustc_span::source_map::Span;
@@ -175,7 +175,7 @@ impl<'tcx> LateLintPass<'tcx> for Return {
                 } else {
                     RetReplacement::Empty
                 };
-                check_final_expr(cx, body.value, vec![], replacement);
+                check_final_expr(cx, body.value, vec![], replacement, None);
             },
             FnKind::ItemFn(..) | FnKind::Method(..) => {
                 check_block_return(cx, &body.value.kind, sp, vec![]);
@@ -188,11 +188,11 @@ impl<'tcx> LateLintPass<'tcx> for Return {
 fn check_block_return<'tcx>(cx: &LateContext<'tcx>, expr_kind: &ExprKind<'tcx>, sp: Span, mut semi_spans: Vec<Span>) {
     if let ExprKind::Block(block, _) = expr_kind {
         if let Some(block_expr) = block.expr {
-            check_final_expr(cx, block_expr, semi_spans, RetReplacement::Empty);
+            check_final_expr(cx, block_expr, semi_spans, RetReplacement::Empty, None);
         } else if let Some(stmt) = block.stmts.iter().last() {
             match stmt.kind {
                 StmtKind::Expr(expr) => {
-                    check_final_expr(cx, expr, semi_spans, RetReplacement::Empty);
+                    check_final_expr(cx, expr, semi_spans, RetReplacement::Empty, None);
                 },
                 StmtKind::Semi(semi_expr) => {
                     // Remove ending semicolons and any whitespace ' ' in between.
@@ -202,7 +202,7 @@ fn check_block_return<'tcx>(cx: &LateContext<'tcx>, expr_kind: &ExprKind<'tcx>,
                             span_find_starting_semi(cx.sess().source_map(), semi_span.with_hi(sp.hi()));
                         semi_spans.push(semi_span_to_remove);
                     }
-                    check_final_expr(cx, semi_expr, semi_spans, RetReplacement::Empty);
+                    check_final_expr(cx, semi_expr, semi_spans, RetReplacement::Empty, None);
                 },
                 _ => (),
             }
@@ -216,6 +216,7 @@ fn check_final_expr<'tcx>(
     semi_spans: Vec<Span>, /* containing all the places where we would need to remove semicolons if finding an
                             * needless return */
     replacement: RetReplacement<'tcx>,
+    match_ty_opt: Option<Ty<'_>>,
 ) {
     let peeled_drop_expr = expr.peel_drop_temps();
     match &peeled_drop_expr.kind {
@@ -244,7 +245,22 @@ fn check_final_expr<'tcx>(
                     RetReplacement::Expr(snippet, applicability)
                 }
             } else {
-                replacement
+                match match_ty_opt {
+                    Some(match_ty) => {
+                        match match_ty.kind() {
+                            // If the code got till here with
+                            // tuple not getting detected before it,
+                            // then we are sure it's going to be Unit
+                            // type
+                            ty::Tuple(_) => RetReplacement::Unit,
+                            // We don't want to anything in this case
+                            // cause we can't predict what the user would
+                            // want here
+                            _ => return,
+                        }
+                    },
+                    None => replacement,
+                }
             };
 
             if !cx.tcx.hir().attrs(expr.hir_id).is_empty() {
@@ -268,8 +284,9 @@ fn check_final_expr<'tcx>(
         // note, if without else is going to be a type checking error anyways
         // (except for unit type functions) so we don't match it
         ExprKind::Match(_, arms, MatchSource::Normal) => {
+            let match_ty = cx.typeck_results().expr_ty(peeled_drop_expr);
             for arm in arms.iter() {
-                check_final_expr(cx, arm.body, semi_spans.clone(), RetReplacement::Unit);
+                check_final_expr(cx, arm.body, semi_spans.clone(), RetReplacement::Empty, Some(match_ty));
             }
         },
         // if it's a whole block, check it
@@ -293,6 +310,7 @@ fn emit_return_lint(cx: &LateContext<'_>, ret_span: Span, semi_spans: Vec<Span>,
     if ret_span.from_expansion() {
         return;
     }
+
     let applicability = replacement.applicability().unwrap_or(Applicability::MachineApplicable);
     let return_replacement = replacement.to_string();
     let sugg_help = replacement.sugg_help();
diff --git a/tests/ui/needless_return.fixed b/tests/ui/needless_return.fixed
index 0f525dd294c..38ae448618c 100644
--- a/tests/ui/needless_return.fixed
+++ b/tests/ui/needless_return.fixed
@@ -81,7 +81,7 @@ fn test_void_if_fun(b: bool) {
 fn test_void_match(x: u32) {
     match x {
         0 => (),
-        _ => (),
+        _ =>(),
     }
 }
 
@@ -91,7 +91,7 @@ fn test_nested_match(x: u32) {
         1 => {
             let _ = 42;
         },
-        _ => (),
+        _ =>(),
     }
 }
 
@@ -196,7 +196,7 @@ async fn async_test_void_if_fun(b: bool) {
 async fn async_test_void_match(x: u32) {
     match x {
         0 => (),
-        _ => (),
+        _ =>(),
     }
 }
 
diff --git a/tests/ui/needless_return.stderr b/tests/ui/needless_return.stderr
index 87d0cd3e14c..5d471a3c521 100644
--- a/tests/ui/needless_return.stderr
+++ b/tests/ui/needless_return.stderr
@@ -118,10 +118,10 @@ LL | |         return;
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:87:14
+  --> $DIR/needless_return.rs:87:13
    |
 LL |         _ => return,
-   |              ^^^^^^
+   |             ^^^^^^^
    |
    = help: replace `return` with a unit value
 
@@ -136,10 +136,10 @@ LL | |             return;
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:98:14
+  --> $DIR/needless_return.rs:98:13
    |
 LL |         _ => return,
-   |              ^^^^^^
+   |             ^^^^^^^
    |
    = help: replace `return` with a unit value
 
@@ -296,10 +296,10 @@ LL | |         return;
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:207:14
+  --> $DIR/needless_return.rs:207:13
    |
 LL |         _ => return,
-   |              ^^^^^^
+   |             ^^^^^^^
    |
    = help: replace `return` with a unit value
 
-- 
cgit 1.4.1-3-g733a5


From b2f919182045773ee2a4091ef071ffd3183efe45 Mon Sep 17 00:00:00 2001
From: blyxyas <blyxyas@gmail.com>
Date: Tue, 4 Apr 2023 11:42:32 +0200
Subject: Fix formatting and lint description

---
 clippy_lints/src/tests_outside_test_module.rs | 12 +++++-------
 1 file changed, 5 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/tests_outside_test_module.rs b/clippy_lints/src/tests_outside_test_module.rs
index e454008c68d..0a0a77082e0 100644
--- a/clippy_lints/src/tests_outside_test_module.rs
+++ b/clippy_lints/src/tests_outside_test_module.rs
@@ -6,13 +6,11 @@ use rustc_span::{def_id::LocalDefId, Span};
 
 declare_clippy_lint! {
     /// ### What it does
-    ///
-    /// Triggers when a testing function (marked with the `#[test]` attribute) isn't inside a testing module (marked with `#[cfg(test)]`).
-    ///
+    /// Triggers when a testing function (marked with the `#[test]` attribute) isn't inside a testing module
+    /// (marked with `#[cfg(test)]`).
     /// ### Why is this bad?
-    ///
-    /// The idiomatic (and more performant) way of writing tests is inside a testing module (flagged with `#[cfg(test)]`), having test functions outside of this module is confusing and may lead to them being "hidden".
-    ///
+    /// The idiomatic (and more performant) way of writing tests is inside a testing module (flagged with `#[cfg(test)]`),
+    /// having test functions outside of this module is confusing and may lead to them being "hidden".
     /// ### Example
     /// ```rust
     /// #[test]
@@ -39,7 +37,7 @@ declare_clippy_lint! {
     #[clippy::version = "1.70.0"]
     pub TESTS_OUTSIDE_TEST_MODULE,
     restriction,
-    "The test function `my_cool_test` is outside the testing module `tests`."
+    "A test function is outside the testing module."
 }
 
 declare_lint_pass!(TestsOutsideTestModule => [TESTS_OUTSIDE_TEST_MODULE]);
-- 
cgit 1.4.1-3-g733a5


From 2891d8f72f8e598177c0bf6c1d56ad2e70a1f536 Mon Sep 17 00:00:00 2001
From: "Samuel \"Sam\" Tardieu" <sam@rfc1149.net>
Date: Sun, 26 Mar 2023 17:11:34 +0200
Subject: Make redundant_async_block a more complete late pass

This lets us detect more complex situations: `async { x.await }` is
simplified into `x` if:

- `x` is an expression without side-effect
- or `x` is an async block itself

In both cases, no part of the `async` expression can be part of a macro
expansion.
---
 clippy_lints/src/lib.rs                   |   2 +-
 clippy_lints/src/redundant_async_block.rs | 145 ++++++++++++++---------------
 tests/ui/redundant_async_block.fixed      | 148 +++++++++++++++++++++++-------
 tests/ui/redundant_async_block.rs         | 148 +++++++++++++++++++++++-------
 tests/ui/redundant_async_block.stderr     |  46 ++++++++--
 5 files changed, 338 insertions(+), 151 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index c9210bf73f8..4638af8da9f 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -935,7 +935,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(no_mangle_with_rust_abi::NoMangleWithRustAbi));
     store.register_late_pass(|_| Box::new(collection_is_never_read::CollectionIsNeverRead));
     store.register_late_pass(|_| Box::new(missing_assert_message::MissingAssertMessage));
-    store.register_early_pass(|| Box::new(redundant_async_block::RedundantAsyncBlock));
+    store.register_late_pass(|_| Box::new(redundant_async_block::RedundantAsyncBlock));
     store.register_late_pass(|_| Box::new(let_with_type_underscore::UnderscoreTyped));
     store.register_late_pass(|_| Box::new(allow_attributes::AllowAttribute));
     store.register_late_pass(move |_| Box::new(manual_main_separator_str::ManualMainSeparatorStr::new(msrv())));
diff --git a/clippy_lints/src/redundant_async_block.rs b/clippy_lints/src/redundant_async_block.rs
index 2d30e77d55d..a0f831764d0 100644
--- a/clippy_lints/src/redundant_async_block.rs
+++ b/clippy_lints/src/redundant_async_block.rs
@@ -1,8 +1,15 @@
-use clippy_utils::{diagnostics::span_lint_and_sugg, source::snippet};
-use rustc_ast::ast::{Expr, ExprKind, Stmt, StmtKind};
-use rustc_ast::visit::Visitor as AstVisitor;
+use std::ops::ControlFlow;
+
+use clippy_utils::{
+    diagnostics::span_lint_and_sugg,
+    peel_blocks,
+    source::{snippet, walk_span_to_context},
+    visitors::for_each_expr,
+};
 use rustc_errors::Applicability;
-use rustc_lint::{EarlyContext, EarlyLintPass};
+use rustc_hir::{AsyncGeneratorKind, Closure, Expr, ExprKind, GeneratorKind, MatchSource};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::{lint::in_external_macro, ty::UpvarCapture};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
@@ -14,106 +21,88 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust
-    /// async fn f() -> i32 {
-    ///     1 + 2
-    /// }
-    ///
+    /// let f = async {
+    ///    1 + 2
+    /// };
     /// let fut = async {
-    ///     f().await
+    ///     f.await
     /// };
     /// ```
     /// Use instead:
     /// ```rust
-    /// async fn f() -> i32 {
-    ///     1 + 2
-    /// }
-    ///
-    /// let fut = f();
+    /// let f = async {
+    ///    1 + 2
+    /// };
+    /// let fut = f;
     /// ```
     #[clippy::version = "1.69.0"]
     pub REDUNDANT_ASYNC_BLOCK,
-    nursery,
+    complexity,
     "`async { future.await }` can be replaced by `future`"
 }
 declare_lint_pass!(RedundantAsyncBlock => [REDUNDANT_ASYNC_BLOCK]);
 
-impl EarlyLintPass for RedundantAsyncBlock {
-    fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
-        if expr.span.from_expansion() {
-            return;
-        }
-        if let ExprKind::Async(_, _, block) = &expr.kind && block.stmts.len() == 1 &&
-            let Some(Stmt { kind: StmtKind::Expr(last), .. }) = block.stmts.last() &&
-            let ExprKind::Await(future) = &last.kind &&
-            !future.span.from_expansion() &&
-            !await_in_expr(future)
+impl<'tcx> LateLintPass<'tcx> for RedundantAsyncBlock {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        let span = expr.span;
+        if !in_external_macro(cx.tcx.sess, span) &&
+            let Some(body_expr) = desugar_async_block(cx, expr) &&
+            let Some(expr) = desugar_await(peel_blocks(body_expr)) &&
+            // The await prefix must not come from a macro as its content could change in the future.
+            expr.span.ctxt() == body_expr.span.ctxt() &&
+            // An async block does not have immediate side-effects from a `.await` point-of-view.
+            (!expr.can_have_side_effects() || desugar_async_block(cx, expr).is_some()) &&
+            let Some(shortened_span) = walk_span_to_context(expr.span, span.ctxt())
         {
-            if captures_value(last) {
-                // If the async block captures variables then there is no equivalence.
-                return;
-            }
-
             span_lint_and_sugg(
                 cx,
                 REDUNDANT_ASYNC_BLOCK,
-                expr.span,
+                span,
                 "this async expression only awaits a single future",
                 "you can reduce it to",
-                snippet(cx, future.span, "..").into_owned(),
+                snippet(cx, shortened_span, "..").into_owned(),
                 Applicability::MachineApplicable,
             );
         }
     }
 }
 
-/// Check whether an expression contains `.await`
-fn await_in_expr(expr: &Expr) -> bool {
-    let mut detector = AwaitDetector::default();
-    detector.visit_expr(expr);
-    detector.await_found
-}
-
-#[derive(Default)]
-struct AwaitDetector {
-    await_found: bool,
-}
-
-impl<'ast> AstVisitor<'ast> for AwaitDetector {
-    fn visit_expr(&mut self, ex: &'ast Expr) {
-        match (&ex.kind, self.await_found) {
-            (ExprKind::Await(_), _) => self.await_found = true,
-            (_, false) => rustc_ast::visit::walk_expr(self, ex),
-            _ => (),
-        }
+/// If `expr` is a desugared `async` block, return the original expression if it does not capture
+/// any variable by ref.
+fn desugar_async_block<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<&'tcx Expr<'tcx>> {
+    if let ExprKind::Closure(Closure { body, def_id, .. }) = expr.kind &&
+        let body = cx.tcx.hir().body(*body) &&
+        matches!(body.generator_kind, Some(GeneratorKind::Async(AsyncGeneratorKind::Block)))
+    {
+        cx
+            .typeck_results()
+            .closure_min_captures
+            .get(def_id)
+            .map_or(true, |m| {
+                m.values().all(|places| {
+                    places
+                        .iter()
+                        .all(|place| matches!(place.info.capture_kind, UpvarCapture::ByValue))
+                })
+            })
+            .then_some(body.value)
+    } else {
+        None
     }
 }
 
-/// Check whether an expression may have captured a local variable.
-/// This is done by looking for paths with only one segment, except as
-/// a prefix of `.await` since this would be captured by value.
-///
-/// This function will sometimes return `true` even tough there are no
-/// captures happening: at the AST level, it is impossible to
-/// dinstinguish a function call from a call to a closure which comes
-/// from the local environment.
-fn captures_value(expr: &Expr) -> bool {
-    let mut detector = CaptureDetector::default();
-    detector.visit_expr(expr);
-    detector.capture_found
-}
-
-#[derive(Default)]
-struct CaptureDetector {
-    capture_found: bool,
-}
-
-impl<'ast> AstVisitor<'ast> for CaptureDetector {
-    fn visit_expr(&mut self, ex: &'ast Expr) {
-        match (&ex.kind, self.capture_found) {
-            (ExprKind::Await(fut), _) if matches!(fut.kind, ExprKind::Path(..)) => (),
-            (ExprKind::Path(_, path), _) if path.segments.len() == 1 => self.capture_found = true,
-            (_, false) => rustc_ast::visit::walk_expr(self, ex),
-            _ => (),
-        }
+/// If `expr` is a desugared `.await`, return the original expression if it does not come from a
+/// macro expansion.
+fn desugar_await<'tcx>(expr: &'tcx Expr<'_>) -> Option<&'tcx Expr<'tcx>> {
+    if let ExprKind::Match(match_value, _, MatchSource::AwaitDesugar) = expr.kind &&
+        let ExprKind::Call(_, [into_future_arg]) = match_value.kind &&
+        let ctxt = expr.span.ctxt() &&
+        for_each_expr(into_future_arg, |e|
+            walk_span_to_context(e.span, ctxt)
+                .map_or(ControlFlow::Break(()), |_| ControlFlow::Continue(()))).is_none()
+    {
+        Some(into_future_arg)
+    } else {
+        None
     }
 }
diff --git a/tests/ui/redundant_async_block.fixed b/tests/ui/redundant_async_block.fixed
index d26b7a332cb..ad96993c4a7 100644
--- a/tests/ui/redundant_async_block.fixed
+++ b/tests/ui/redundant_async_block.fixed
@@ -1,6 +1,6 @@
 // run-rustfix
 
-#![allow(unused)]
+#![allow(unused, clippy::manual_async_fn)]
 #![warn(clippy::redundant_async_block)]
 
 use std::future::Future;
@@ -16,40 +16,16 @@ async fn func2() -> String {
     x.await
 }
 
-macro_rules! await_in_macro {
-    ($e:expr) => {
-        std::convert::identity($e).await
-    };
-}
-
-async fn func3(n: usize) -> usize {
-    // Do not lint (suggestion would be `std::convert::identity(func1(n))`
-    // which copies code from inside the macro)
-    async move { await_in_macro!(func1(n)) }.await
-}
-
-// This macro should never be linted as `$e` might contain `.await`
-macro_rules! async_await_parameter_in_macro {
-    ($e:expr) => {
-        async { $e.await }
-    };
-}
-
-// MISSED OPPORTUNITY: this macro could be linted as the `async` block does not
-// contain code coming from the parameters
-macro_rules! async_await_in_macro {
-    ($f:expr) => {
-        ($f)(async { func2().await })
-    };
-}
-
 fn main() {
     let fut1 = async { 17 };
+    // Lint
     let fut2 = fut1;
 
     let fut1 = async { 25 };
+    // Lint
     let fut2 = fut1;
 
+    // Lint
     let fut = async { 42 };
 
     // Do not lint: not a single expression
@@ -60,15 +36,12 @@ fn main() {
 
     // Do not lint: expression contains `.await`
     let fut = async { func1(func2().await.len()).await };
-
-    let fut = async_await_parameter_in_macro!(func2());
-    let fut = async_await_in_macro!(std::convert::identity);
 }
 
 #[allow(clippy::let_and_return)]
 fn capture_local() -> impl Future<Output = i32> {
-    // Lint
     let fut = async { 17 };
+    // Lint
     fut
 }
 
@@ -80,11 +53,39 @@ fn capture_local_closure(s: &str) -> impl Future<Output = &str> {
 
 #[allow(clippy::let_and_return)]
 fn capture_arg(s: &str) -> impl Future<Output = &str> {
-    // Lint
     let fut = async move { s };
+    // Lint
     fut
 }
 
+fn capture_future_arg<T>(f: impl Future<Output = T>) -> impl Future<Output = T> {
+    // Lint
+    f
+}
+
+fn capture_func_result<FN, F, T>(f: FN) -> impl Future<Output = T>
+where
+    F: Future<Output = T>,
+    FN: FnOnce() -> F,
+{
+    // Do not lint, as f() would be evaluated prematurely
+    async { f().await }
+}
+
+fn double_future(f: impl Future<Output = impl Future<Output = u32>>) -> impl Future<Output = u32> {
+    // Do not lint, we will get a `.await` outside a `.async`
+    async { f.await.await }
+}
+
+fn await_in_async<F, R>(f: F) -> impl Future<Output = u32>
+where
+    F: FnOnce() -> R,
+    R: Future<Output = u32>,
+{
+    // Lint
+    async { f().await + 1 }
+}
+
 #[derive(Debug, Clone)]
 struct F {}
 
@@ -109,3 +110,84 @@ fn capture() {
     // Do not lint: `val` would not live long enough
     spawn(async { work(&{ val }).await });
 }
+
+fn await_from_macro() -> impl Future<Output = u32> {
+    macro_rules! mac {
+        ($e:expr) => {
+            $e.await
+        };
+    }
+    // Do not lint: the macro may change in the future
+    // or return different things depending on its argument
+    async { mac!(async { 42 }) }
+}
+
+fn async_expr_from_macro() -> impl Future<Output = u32> {
+    macro_rules! mac {
+        () => {
+            async { 42 }
+        };
+    }
+    // Do not lint: the macro may change in the future
+    async { mac!().await }
+}
+
+fn async_expr_from_macro_deep() -> impl Future<Output = u32> {
+    macro_rules! mac {
+        () => {
+            async { 42 }
+        };
+    }
+    // Do not lint: the macro may change in the future
+    async { ({ mac!() }).await }
+}
+
+fn all_from_macro() -> impl Future<Output = u32> {
+    macro_rules! mac {
+        () => {
+            // Lint
+            async { 42 }
+        };
+    }
+    mac!()
+}
+
+fn parts_from_macro() -> impl Future<Output = u32> {
+    macro_rules! mac {
+        ($e: expr) => {
+            // Do not lint: `$e` might not always be side-effect free
+            async { $e.await }
+        };
+    }
+    mac!(async { 42 })
+}
+
+fn safe_parts_from_macro() -> impl Future<Output = u32> {
+    macro_rules! mac {
+        ($e: expr) => {
+            // Lint
+            async { $e }
+        };
+    }
+    mac!(42)
+}
+
+fn parts_from_macro_deep() -> impl Future<Output = u32> {
+    macro_rules! mac {
+        ($e: expr) => {
+            // Do not lint: `$e` might not always be side-effect free
+            async { ($e,).0.await }
+        };
+    }
+    let f = std::future::ready(42);
+    mac!(f)
+}
+
+fn await_from_macro_deep() -> impl Future<Output = u32> {
+    macro_rules! mac {
+        ($e:expr) => {{ $e }.await};
+    }
+    // Do not lint: the macro may change in the future
+    // or return different things depending on its argument
+    async { mac!(async { 42 }) }
+}
diff --git a/tests/ui/redundant_async_block.rs b/tests/ui/redundant_async_block.rs
index 04726e62805..7ae23558369 100644
--- a/tests/ui/redundant_async_block.rs
+++ b/tests/ui/redundant_async_block.rs
@@ -1,6 +1,6 @@
 // run-rustfix
 
-#![allow(unused)]
+#![allow(unused, clippy::manual_async_fn)]
 #![warn(clippy::redundant_async_block)]
 
 use std::future::Future;
@@ -16,40 +16,16 @@ async fn func2() -> String {
     x.await
 }
 
-macro_rules! await_in_macro {
-    ($e:expr) => {
-        std::convert::identity($e).await
-    };
-}
-
-async fn func3(n: usize) -> usize {
-    // Do not lint (suggestion would be `std::convert::identity(func1(n))`
-    // which copies code from inside the macro)
-    async move { await_in_macro!(func1(n)) }.await
-}
-
-// This macro should never be linted as `$e` might contain `.await`
-macro_rules! async_await_parameter_in_macro {
-    ($e:expr) => {
-        async { $e.await }
-    };
-}
-
-// MISSED OPPORTUNITY: this macro could be linted as the `async` block does not
-// contain code coming from the parameters
-macro_rules! async_await_in_macro {
-    ($f:expr) => {
-        ($f)(async { func2().await })
-    };
-}
-
 fn main() {
     let fut1 = async { 17 };
+    // Lint
     let fut2 = async { fut1.await };
 
     let fut1 = async { 25 };
+    // Lint
     let fut2 = async move { fut1.await };
 
+    // Lint
     let fut = async { async { 42 }.await };
 
     // Do not lint: not a single expression
@@ -60,15 +36,12 @@ fn main() {
 
     // Do not lint: expression contains `.await`
     let fut = async { func1(func2().await.len()).await };
-
-    let fut = async_await_parameter_in_macro!(func2());
-    let fut = async_await_in_macro!(std::convert::identity);
 }
 
 #[allow(clippy::let_and_return)]
 fn capture_local() -> impl Future<Output = i32> {
-    // Lint
     let fut = async { 17 };
+    // Lint
     async move { fut.await }
 }
 
@@ -80,11 +53,39 @@ fn capture_local_closure(s: &str) -> impl Future<Output = &str> {
 
 #[allow(clippy::let_and_return)]
 fn capture_arg(s: &str) -> impl Future<Output = &str> {
-    // Lint
     let fut = async move { s };
+    // Lint
     async move { fut.await }
 }
 
+fn capture_future_arg<T>(f: impl Future<Output = T>) -> impl Future<Output = T> {
+    // Lint
+    async { f.await }
+}
+
+fn capture_func_result<FN, F, T>(f: FN) -> impl Future<Output = T>
+where
+    F: Future<Output = T>,
+    FN: FnOnce() -> F,
+{
+    // Do not lint, as f() would be evaluated prematurely
+    async { f().await }
+}
+
+fn double_future(f: impl Future<Output = impl Future<Output = u32>>) -> impl Future<Output = u32> {
+    // Do not lint, we will get a `.await` outside a `.async`
+    async { f.await.await }
+}
+
+fn await_in_async<F, R>(f: F) -> impl Future<Output = u32>
+where
+    F: FnOnce() -> R,
+    R: Future<Output = u32>,
+{
+    // Lint
+    async { async { f().await + 1 }.await }
+}
+
 #[derive(Debug, Clone)]
 struct F {}
 
@@ -109,3 +110,84 @@ fn capture() {
     // Do not lint: `val` would not live long enough
     spawn(async { work(&{ val }).await });
 }
+
+fn await_from_macro() -> impl Future<Output = u32> {
+    macro_rules! mac {
+        ($e:expr) => {
+            $e.await
+        };
+    }
+    // Do not lint: the macro may change in the future
+    // or return different things depending on its argument
+    async { mac!(async { 42 }) }
+}
+
+fn async_expr_from_macro() -> impl Future<Output = u32> {
+    macro_rules! mac {
+        () => {
+            async { 42 }
+        };
+    }
+    // Do not lint: the macro may change in the future
+    async { mac!().await }
+}
+
+fn async_expr_from_macro_deep() -> impl Future<Output = u32> {
+    macro_rules! mac {
+        () => {
+            async { 42 }
+        };
+    }
+    // Do not lint: the macro may change in the future
+    async { ({ mac!() }).await }
+}
+
+fn all_from_macro() -> impl Future<Output = u32> {
+    macro_rules! mac {
+        () => {
+            // Lint
+            async { async { 42 }.await }
+        };
+    }
+    mac!()
+}
+
+fn parts_from_macro() -> impl Future<Output = u32> {
+    macro_rules! mac {
+        ($e: expr) => {
+            // Do not lint: `$e` might not always be side-effect free
+            async { $e.await }
+        };
+    }
+    mac!(async { 42 })
+}
+
+fn safe_parts_from_macro() -> impl Future<Output = u32> {
+    macro_rules! mac {
+        ($e: expr) => {
+            // Lint
+            async { async { $e }.await }
+        };
+    }
+    mac!(42)
+}
+
+fn parts_from_macro_deep() -> impl Future<Output = u32> {
+    macro_rules! mac {
+        ($e: expr) => {
+            // Do not lint: `$e` might not always be side-effect free
+            async { ($e,).0.await }
+        };
+    }
+    let f = std::future::ready(42);
+    mac!(f)
+}
+
+fn await_from_macro_deep() -> impl Future<Output = u32> {
+    macro_rules! mac {
+        ($e:expr) => {{ $e }.await};
+    }
+    // Do not lint: the macro may change in the future
+    // or return different things depending on its argument
+    async { mac!(async { 42 }) }
+}
diff --git a/tests/ui/redundant_async_block.stderr b/tests/ui/redundant_async_block.stderr
index 1a1c1603e08..f3dcb09b444 100644
--- a/tests/ui/redundant_async_block.stderr
+++ b/tests/ui/redundant_async_block.stderr
@@ -7,34 +7,68 @@ LL |     let x = async { f.await };
    = note: `-D clippy::redundant-async-block` implied by `-D warnings`
 
 error: this async expression only awaits a single future
-  --> $DIR/redundant_async_block.rs:48:16
+  --> $DIR/redundant_async_block.rs:22:16
    |
 LL |     let fut2 = async { fut1.await };
    |                ^^^^^^^^^^^^^^^^^^^^ help: you can reduce it to: `fut1`
 
 error: this async expression only awaits a single future
-  --> $DIR/redundant_async_block.rs:51:16
+  --> $DIR/redundant_async_block.rs:26:16
    |
 LL |     let fut2 = async move { fut1.await };
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^ help: you can reduce it to: `fut1`
 
 error: this async expression only awaits a single future
-  --> $DIR/redundant_async_block.rs:53:15
+  --> $DIR/redundant_async_block.rs:29:15
    |
 LL |     let fut = async { async { 42 }.await };
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: you can reduce it to: `async { 42 }`
 
 error: this async expression only awaits a single future
-  --> $DIR/redundant_async_block.rs:72:5
+  --> $DIR/redundant_async_block.rs:45:5
    |
 LL |     async move { fut.await }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^ help: you can reduce it to: `fut`
 
 error: this async expression only awaits a single future
-  --> $DIR/redundant_async_block.rs:85:5
+  --> $DIR/redundant_async_block.rs:58:5
    |
 LL |     async move { fut.await }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^ help: you can reduce it to: `fut`
 
-error: aborting due to 6 previous errors
+error: this async expression only awaits a single future
+  --> $DIR/redundant_async_block.rs:63:5
+   |
+LL |     async { f.await }
+   |     ^^^^^^^^^^^^^^^^^ help: you can reduce it to: `f`
+
+error: this async expression only awaits a single future
+  --> $DIR/redundant_async_block.rs:86:5
+   |
+LL |     async { async { f().await + 1 }.await }
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: you can reduce it to: `async { f().await + 1 }`
+
+error: this async expression only awaits a single future
+  --> $DIR/redundant_async_block.rs:149:13
+   |
+LL |             async { async { 42 }.await }
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: you can reduce it to: `async { 42 }`
+...
+LL |     mac!()
+   |     ------ in this macro invocation
+   |
+   = note: this error originates in the macro `mac` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: this async expression only awaits a single future
+  --> $DIR/redundant_async_block.rs:169:13
+   |
+LL |             async { async { $e }.await }
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: you can reduce it to: `async { $e }`
+...
+LL |     mac!(42)
+   |     -------- in this macro invocation
+   |
+   = note: this error originates in the macro `mac` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: aborting due to 10 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 9cf57d0a8f95c51b0faeda4ce5c5b4cd629f1cae Mon Sep 17 00:00:00 2001
From: feniljain <fkjainco@gmail.com>
Date: Wed, 5 Apr 2023 20:03:45 +0530
Subject: fix(needles_return): correct span selection for text replacement

---
 clippy_lints/src/returns.rs     |  2 +-
 tests/ui/needless_return.fixed  |  6 +++---
 tests/ui/needless_return.stderr | 12 ++++++------
 3 files changed, 10 insertions(+), 10 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
index b8172b74dc0..df126d7617e 100644
--- a/clippy_lints/src/returns.rs
+++ b/clippy_lints/src/returns.rs
@@ -286,7 +286,7 @@ fn check_final_expr<'tcx>(
         ExprKind::Match(_, arms, MatchSource::Normal) => {
             let match_ty = cx.typeck_results().expr_ty(peeled_drop_expr);
             for arm in arms.iter() {
-                check_final_expr(cx, arm.body, semi_spans.clone(), RetReplacement::Empty, Some(match_ty));
+                check_final_expr(cx, arm.body, semi_spans.clone(), RetReplacement::Unit, Some(match_ty));
             }
         },
         // if it's a whole block, check it
diff --git a/tests/ui/needless_return.fixed b/tests/ui/needless_return.fixed
index 47a9f031a42..57c08996ce2 100644
--- a/tests/ui/needless_return.fixed
+++ b/tests/ui/needless_return.fixed
@@ -81,7 +81,7 @@ fn test_void_if_fun(b: bool) {
 fn test_void_match(x: u32) {
     match x {
         0 => (),
-        _ =>(),
+        _ => (),
     }
 }
 
@@ -91,7 +91,7 @@ fn test_nested_match(x: u32) {
         1 => {
             let _ = 42;
         },
-        _ =>(),
+        _ => (),
     }
 }
 
@@ -196,7 +196,7 @@ async fn async_test_void_if_fun(b: bool) {
 async fn async_test_void_match(x: u32) {
     match x {
         0 => (),
-        _ =>(),
+        _ => (),
     }
 }
 
diff --git a/tests/ui/needless_return.stderr b/tests/ui/needless_return.stderr
index 5d471a3c521..87d0cd3e14c 100644
--- a/tests/ui/needless_return.stderr
+++ b/tests/ui/needless_return.stderr
@@ -118,10 +118,10 @@ LL | |         return;
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:87:13
+  --> $DIR/needless_return.rs:87:14
    |
 LL |         _ => return,
-   |             ^^^^^^^
+   |              ^^^^^^
    |
    = help: replace `return` with a unit value
 
@@ -136,10 +136,10 @@ LL | |             return;
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:98:13
+  --> $DIR/needless_return.rs:98:14
    |
 LL |         _ => return,
-   |             ^^^^^^^
+   |              ^^^^^^
    |
    = help: replace `return` with a unit value
 
@@ -296,10 +296,10 @@ LL | |         return;
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:207:13
+  --> $DIR/needless_return.rs:207:14
    |
 LL |         _ => return,
-   |             ^^^^^^^
+   |              ^^^^^^
    |
    = help: replace `return` with a unit value
 
-- 
cgit 1.4.1-3-g733a5


From 008e07d4e8e434933e1ba25a5c324a3a9d46dd7b Mon Sep 17 00:00:00 2001
From: J-ZhengLi <lizheng135@huawei.com>
Date: Thu, 6 Apr 2023 16:16:22 +0800
Subject: fix [mem_replace_option_with_none] not considering field variables

---
 clippy_lints/src/mem_replace.rs | 71 ++++++++++++++++-------------------------
 tests/ui/mem_replace.fixed      | 34 ++++++++++++++++++++
 tests/ui/mem_replace.rs         | 34 ++++++++++++++++++++
 tests/ui/mem_replace.stderr     | 26 ++++++++++++++-
 4 files changed, 121 insertions(+), 44 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/mem_replace.rs b/clippy_lints/src/mem_replace.rs
index 35024ec1224..8a921d4af16 100644
--- a/clippy_lints/src/mem_replace.rs
+++ b/clippy_lints/src/mem_replace.rs
@@ -1,12 +1,13 @@
 use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::{snippet, snippet_with_applicability};
+use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::is_non_aggregate_primitive_type;
-use clippy_utils::{is_default_equivalent, is_res_lang_ctor, path_res};
+use clippy_utils::{is_default_equivalent, is_res_lang_ctor, path_res, peel_ref_operators};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::LangItem::OptionNone;
-use rustc_hir::{BorrowKind, Expr, ExprKind, Mutability, QPath};
+use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
@@ -101,40 +102,26 @@ declare_clippy_lint! {
 impl_lint_pass!(MemReplace =>
     [MEM_REPLACE_OPTION_WITH_NONE, MEM_REPLACE_WITH_UNINIT, MEM_REPLACE_WITH_DEFAULT]);
 
-fn check_replace_option_with_none(cx: &LateContext<'_>, src: &Expr<'_>, dest: &Expr<'_>, expr_span: Span) {
-    // Check that second argument is `Option::None`
-    if is_res_lang_ctor(cx, path_res(cx, src), OptionNone) {
-        // Since this is a late pass (already type-checked),
-        // and we already know that the second argument is an
-        // `Option`, we do not need to check the first
-        // argument's type. All that's left is to get
-        // replacee's path.
-        let replaced_path = match dest.kind {
-            ExprKind::AddrOf(BorrowKind::Ref, Mutability::Mut, replaced) => {
-                if let ExprKind::Path(QPath::Resolved(None, replaced_path)) = replaced.kind {
-                    replaced_path
-                } else {
-                    return;
-                }
-            },
-            ExprKind::Path(QPath::Resolved(None, replaced_path)) => replaced_path,
-            _ => return,
-        };
-
-        let mut applicability = Applicability::MachineApplicable;
-        span_lint_and_sugg(
-            cx,
-            MEM_REPLACE_OPTION_WITH_NONE,
-            expr_span,
-            "replacing an `Option` with `None`",
-            "consider `Option::take()` instead",
-            format!(
-                "{}.take()",
-                snippet_with_applicability(cx, replaced_path.span, "", &mut applicability)
-            ),
-            applicability,
-        );
-    }
+fn check_replace_option_with_none(cx: &LateContext<'_>, dest: &Expr<'_>, expr_span: Span) {
+    // Since this is a late pass (already type-checked),
+    // and we already know that the second argument is an
+    // `Option`, we do not need to check the first
+    // argument's type. All that's left is to get
+    // the replacee's expr after peeling off the `&mut`
+    let sugg_expr = peel_ref_operators(cx, dest);
+    let mut applicability = Applicability::MachineApplicable;
+    span_lint_and_sugg(
+        cx,
+        MEM_REPLACE_OPTION_WITH_NONE,
+        expr_span,
+        "replacing an `Option` with `None`",
+        "consider `Option::take()` instead",
+        format!(
+            "{}.take()",
+            Sugg::hir_with_context(cx, sugg_expr, expr_span.ctxt(), "", &mut applicability).maybe_par()
+        ),
+        applicability,
+    );
 }
 
 fn check_replace_with_uninit(cx: &LateContext<'_>, src: &Expr<'_>, dest: &Expr<'_>, expr_span: Span) {
@@ -200,10 +187,6 @@ fn check_replace_with_default(cx: &LateContext<'_>, src: &Expr<'_>, dest: &Expr<
     if is_non_aggregate_primitive_type(expr_type) {
         return;
     }
-    // disable lint for Option since it is covered in another lint
-    if is_res_lang_ctor(cx, path_res(cx, src), OptionNone) {
-        return;
-    }
     if is_default_equivalent(cx, src) && !in_external_macro(cx.tcx.sess, expr_span) {
         span_lint_and_then(
             cx,
@@ -246,11 +229,13 @@ impl<'tcx> LateLintPass<'tcx> for MemReplace {
             if let Some(def_id) = cx.qpath_res(func_qpath, func.hir_id).opt_def_id();
             if cx.tcx.is_diagnostic_item(sym::mem_replace, def_id);
             then {
-                check_replace_option_with_none(cx, src, dest, expr.span);
-                check_replace_with_uninit(cx, src, dest, expr.span);
-                if self.msrv.meets(msrvs::MEM_TAKE) {
+                // Check that second argument is `Option::None`
+                if is_res_lang_ctor(cx, path_res(cx, src), OptionNone) {
+                    check_replace_option_with_none(cx, dest, expr.span);
+                } else if self.msrv.meets(msrvs::MEM_TAKE) {
                     check_replace_with_default(cx, src, dest, expr.span);
                 }
+                check_replace_with_uninit(cx, src, dest, expr.span);
             }
         }
     }
diff --git a/tests/ui/mem_replace.fixed b/tests/ui/mem_replace.fixed
index 874d5584330..7fd340173af 100644
--- a/tests/ui/mem_replace.fixed
+++ b/tests/ui/mem_replace.fixed
@@ -90,3 +90,37 @@ fn msrv_1_40() {
     let mut s = String::from("foo");
     let _ = std::mem::take(&mut s);
 }
+
+fn issue9824() {
+    struct Foo<'a>(Option<&'a str>);
+    impl<'a> std::ops::Deref for Foo<'a> {
+        type Target = Option<&'a str>;
+
+        fn deref(&self) -> &Self::Target {
+            &self.0
+        }
+    }
+    impl<'a> std::ops::DerefMut for Foo<'a> {
+        fn deref_mut(&mut self) -> &mut Self::Target {
+            &mut self.0
+        }
+    }
+
+    struct Bar {
+        opt: Option<u8>,
+        val: String,
+    }
+
+    let mut f = Foo(Some("foo"));
+    let mut b = Bar {
+        opt: Some(1),
+        val: String::from("bar"),
+    };
+
+    // replace option with none
+    let _ = f.0.take();
+    let _ = (*f).take();
+    let _ = b.opt.take();
+    // replace with default
+    let _ = std::mem::take(&mut b.val);
+}
diff --git a/tests/ui/mem_replace.rs b/tests/ui/mem_replace.rs
index f4f3bff5144..fa2903addbc 100644
--- a/tests/ui/mem_replace.rs
+++ b/tests/ui/mem_replace.rs
@@ -90,3 +90,37 @@ fn msrv_1_40() {
     let mut s = String::from("foo");
     let _ = std::mem::replace(&mut s, String::default());
 }
+
+fn issue9824() {
+    struct Foo<'a>(Option<&'a str>);
+    impl<'a> std::ops::Deref for Foo<'a> {
+        type Target = Option<&'a str>;
+
+        fn deref(&self) -> &Self::Target {
+            &self.0
+        }
+    }
+    impl<'a> std::ops::DerefMut for Foo<'a> {
+        fn deref_mut(&mut self) -> &mut Self::Target {
+            &mut self.0
+        }
+    }
+
+    struct Bar {
+        opt: Option<u8>,
+        val: String,
+    }
+
+    let mut f = Foo(Some("foo"));
+    let mut b = Bar {
+        opt: Some(1),
+        val: String::from("bar"),
+    };
+
+    // replace option with none
+    let _ = std::mem::replace(&mut f.0, None);
+    let _ = std::mem::replace(&mut *f, None);
+    let _ = std::mem::replace(&mut b.opt, None);
+    // replace with default
+    let _ = std::mem::replace(&mut b.val, String::default());
+}
diff --git a/tests/ui/mem_replace.stderr b/tests/ui/mem_replace.stderr
index caa127f76ee..58b57be7507 100644
--- a/tests/ui/mem_replace.stderr
+++ b/tests/ui/mem_replace.stderr
@@ -122,5 +122,29 @@ error: replacing a value of type `T` with `T::default()` is better expressed usi
 LL |     let _ = std::mem::replace(&mut s, String::default());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::mem::take(&mut s)`
 
-error: aborting due to 20 previous errors
+error: replacing an `Option` with `None`
+  --> $DIR/mem_replace.rs:121:13
+   |
+LL |     let _ = std::mem::replace(&mut f.0, None);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider `Option::take()` instead: `f.0.take()`
+
+error: replacing an `Option` with `None`
+  --> $DIR/mem_replace.rs:122:13
+   |
+LL |     let _ = std::mem::replace(&mut *f, None);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider `Option::take()` instead: `(*f).take()`
+
+error: replacing an `Option` with `None`
+  --> $DIR/mem_replace.rs:123:13
+   |
+LL |     let _ = std::mem::replace(&mut b.opt, None);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider `Option::take()` instead: `b.opt.take()`
+
+error: replacing a value of type `T` with `T::default()` is better expressed using `std::mem::take`
+  --> $DIR/mem_replace.rs:125:13
+   |
+LL |     let _ = std::mem::replace(&mut b.val, String::default());
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::mem::take(&mut b.val)`
+
+error: aborting due to 24 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From b66aa09b951dace249fad3376c2d97c95d11b6a9 Mon Sep 17 00:00:00 2001
From: Michael Schubart <michael@schubart.net>
Date: Sun, 19 Mar 2023 09:29:32 +0000
Subject: Add [`manual_slice_size_calculation`]

---
 CHANGELOG.md                                      |  1 +
 clippy_lints/src/declared_lints.rs                |  1 +
 clippy_lints/src/lib.rs                           |  2 +
 clippy_lints/src/manual_slice_size_calculation.rs | 90 +++++++++++++++++++++++
 tests/ui/manual_slice_size_calculation.rs         | 30 ++++++++
 tests/ui/manual_slice_size_calculation.stderr     | 27 +++++++
 6 files changed, 151 insertions(+)
 create mode 100644 clippy_lints/src/manual_slice_size_calculation.rs
 create mode 100644 tests/ui/manual_slice_size_calculation.rs
 create mode 100644 tests/ui/manual_slice_size_calculation.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index ba10cb53ec9..f615b27bf68 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4674,6 +4674,7 @@ Released 2018-09-13
 [`manual_rem_euclid`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_rem_euclid
 [`manual_retain`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_retain
 [`manual_saturating_arithmetic`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_saturating_arithmetic
+[`manual_slice_size_calculation`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_slice_size_calculation
 [`manual_split_once`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_split_once
 [`manual_str_repeat`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_str_repeat
 [`manual_string_new`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_string_new
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index b4510557033..09ae6b8ee57 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -269,6 +269,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE_INFO,
     crate::manual_rem_euclid::MANUAL_REM_EUCLID_INFO,
     crate::manual_retain::MANUAL_RETAIN_INFO,
+    crate::manual_slice_size_calculation::MANUAL_SLICE_SIZE_CALCULATION_INFO,
     crate::manual_string_new::MANUAL_STRING_NEW_INFO,
     crate::manual_strip::MANUAL_STRIP_INFO,
     crate::map_unit_fn::OPTION_MAP_UNIT_FN_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 82d63ddca6d..f842e629c53 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -186,6 +186,7 @@ mod manual_main_separator_str;
 mod manual_non_exhaustive;
 mod manual_rem_euclid;
 mod manual_retain;
+mod manual_slice_size_calculation;
 mod manual_string_new;
 mod manual_strip;
 mod map_unit_fn;
@@ -957,6 +958,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     });
     store.register_late_pass(|_| Box::new(lines_filter_map_ok::LinesFilterMapOk));
     store.register_late_pass(|_| Box::new(tests_outside_test_module::TestsOutsideTestModule));
+    store.register_late_pass(|_| Box::new(manual_slice_size_calculation::ManualSliceSizeCalculation));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/manual_slice_size_calculation.rs b/clippy_lints/src/manual_slice_size_calculation.rs
new file mode 100644
index 00000000000..2659f347778
--- /dev/null
+++ b/clippy_lints/src/manual_slice_size_calculation.rs
@@ -0,0 +1,90 @@
+use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::in_constant;
+use rustc_hir::{BinOpKind, Expr, ExprKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::symbol::sym;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// When `a` is `&[T]`, detect `a.len() * size_of::<T>()` and suggest `size_of_val(a)`
+    /// instead.
+    ///
+    /// ### Why is this better?
+    /// * Shorter to write
+    /// * Removes the need for the human and the compiler to worry about overflow in the
+    ///   multiplication
+    /// * Potentially faster at runtime as rust emits special no-wrapping flags when it
+    ///   calculates the byte length
+    /// * Less turbofishing
+    ///
+    /// ### Example
+    /// ```rust
+    /// # let data : &[i32] = &[1, 2, 3];
+    /// let newlen = data.len() * std::mem::size_of::<i32>();
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// # let data : &[i32] = &[1, 2, 3];
+    /// let newlen = std::mem::size_of_val(data);
+    /// ```
+    #[clippy::version = "1.70.0"]
+    pub MANUAL_SLICE_SIZE_CALCULATION,
+    complexity,
+    "manual slice size calculation"
+}
+declare_lint_pass!(ManualSliceSizeCalculation => [MANUAL_SLICE_SIZE_CALCULATION]);
+
+impl<'tcx> LateLintPass<'tcx> for ManualSliceSizeCalculation {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
+        // Does not apply inside const because size_of_value is not cost in stable.
+        if !in_constant(cx, expr.hir_id)
+            && let ExprKind::Binary(ref op, left, right) = expr.kind
+            && BinOpKind::Mul == op.node
+            && let Some(_receiver) = simplify(cx, left, right)
+        {
+            span_lint_and_help(
+                cx,
+                MANUAL_SLICE_SIZE_CALCULATION,
+                expr.span,
+                "manual slice size calculation",
+                None,
+                "consider using std::mem::size_of_value instead");
+        }
+    }
+}
+
+fn simplify<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr1: &'tcx Expr<'tcx>,
+    expr2: &'tcx Expr<'tcx>,
+) -> Option<&'tcx Expr<'tcx>> {
+    simplify_half(cx, expr1, expr2).or_else(|| simplify_half(cx, expr2, expr1))
+}
+
+fn simplify_half<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr1: &'tcx Expr<'tcx>,
+    expr2: &'tcx Expr<'tcx>,
+) -> Option<&'tcx Expr<'tcx>> {
+    if
+        // expr1 is `[T1].len()`?
+        let ExprKind::MethodCall(method_path, receiver, _, _) = expr1.kind
+        && method_path.ident.name == sym::len
+        && let receiver_ty = cx.typeck_results().expr_ty(receiver)
+        && let ty::Slice(ty1) = receiver_ty.peel_refs().kind()
+        // expr2 is `size_of::<T2>()`?
+        && let ExprKind::Call(func, _) = expr2.kind
+        && let ExprKind::Path(ref func_qpath) = func.kind
+        && let Some(def_id) = cx.qpath_res(func_qpath, func.hir_id).opt_def_id()
+        && cx.tcx.is_diagnostic_item(sym::mem_size_of, def_id)
+        && let Some(ty2) = cx.typeck_results().node_substs(func.hir_id).types().next()
+        // T1 == T2?
+        && *ty1 == ty2
+    {
+        Some(receiver)
+    } else {
+        None
+    }
+}
diff --git a/tests/ui/manual_slice_size_calculation.rs b/tests/ui/manual_slice_size_calculation.rs
new file mode 100644
index 00000000000..8ec4ae0aed7
--- /dev/null
+++ b/tests/ui/manual_slice_size_calculation.rs
@@ -0,0 +1,30 @@
+#![allow(unused)]
+#![warn(clippy::manual_slice_size_calculation)]
+
+use core::mem::{align_of, size_of};
+
+fn main() {
+    let v_i32 = Vec::<i32>::new();
+    let s_i32 = v_i32.as_slice();
+
+    // True positives:
+    let _ = s_i32.len() * size_of::<i32>(); // WARNING
+    let _ = size_of::<i32>() * s_i32.len(); // WARNING
+    let _ = size_of::<i32>() * s_i32.len() * 5; // WARNING
+
+    // True negatives:
+    let _ = size_of::<i32>() + s_i32.len(); // Ok, not a multiplication
+    let _ = size_of::<i32>() * s_i32.partition_point(|_| true); // Ok, not len()
+    let _ = size_of::<i32>() * v_i32.len(); // Ok, not a slice
+    let _ = align_of::<i32>() * s_i32.len(); // Ok, not size_of()
+    let _ = size_of::<u32>() * s_i32.len(); // Ok, different types
+
+    // False negatives:
+    let _ = 5 * size_of::<i32>() * s_i32.len(); // Ok (MISSED OPPORTUNITY)
+    let _ = size_of::<i32>() * 5 * s_i32.len(); // Ok (MISSED OPPORTUNITY)
+}
+
+const fn _const(s_i32: &[i32]) {
+    // True negative:
+    let _ = s_i32.len() * size_of::<i32>(); // Ok, can't use size_of_val in const
+}
diff --git a/tests/ui/manual_slice_size_calculation.stderr b/tests/ui/manual_slice_size_calculation.stderr
new file mode 100644
index 00000000000..33de9fad4d3
--- /dev/null
+++ b/tests/ui/manual_slice_size_calculation.stderr
@@ -0,0 +1,27 @@
+error: manual slice size calculation
+  --> $DIR/manual_slice_size_calculation.rs:11:13
+   |
+LL |     let _ = s_i32.len() * size_of::<i32>(); // WARNING
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using std::mem::size_of_value instead
+   = note: `-D clippy::manual-slice-size-calculation` implied by `-D warnings`
+
+error: manual slice size calculation
+  --> $DIR/manual_slice_size_calculation.rs:12:13
+   |
+LL |     let _ = size_of::<i32>() * s_i32.len(); // WARNING
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using std::mem::size_of_value instead
+
+error: manual slice size calculation
+  --> $DIR/manual_slice_size_calculation.rs:13:13
+   |
+LL |     let _ = size_of::<i32>() * s_i32.len() * 5; // WARNING
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using std::mem::size_of_value instead
+
+error: aborting due to 3 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 67e836d4cfe4905dd1c4caa1d14f2aa7f76cc42a Mon Sep 17 00:00:00 2001
From: Robert Bastian <robertbastian@google.com>
Date: Thu, 6 Apr 2023 16:06:56 +0200
Subject: fix

---
 clippy_lints/src/octal_escapes.rs | 94 ++++++++++++++++++++-------------------
 tests/ui/octal_escapes.rs         |  1 +
 tests/ui/octal_escapes.stderr     | 18 +++++++-
 3 files changed, 67 insertions(+), 46 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/octal_escapes.rs b/clippy_lints/src/octal_escapes.rs
index 7376ab0c846..6d3865080a6 100644
--- a/clippy_lints/src/octal_escapes.rs
+++ b/clippy_lints/src/octal_escapes.rs
@@ -76,8 +76,8 @@ fn check_lit(cx: &EarlyContext<'_>, lit: &Lit, span: Span, is_string: bool) {
         if ch == '\\' {
             if let Some((_, '0')) = iter.next() {
                 // collect up to two further octal digits
-                if let Some((mut to, '0'..='7')) = iter.next() {
-                    if let Some((_, '0'..='7')) = iter.peek() {
+                if let Some((mut to, _)) = iter.next_if(|(_, ch)| matches!(ch, '0'..='7')) {
+                    if iter.next_if(|(_, ch)| matches!(ch, '0'..='7')).is_some() {
                         to += 1;
                     }
                     found.push((from, to + 1));
@@ -90,32 +90,6 @@ fn check_lit(cx: &EarlyContext<'_>, lit: &Lit, span: Span, is_string: bool) {
         return;
     }
 
-    // construct two suggestion strings, one with \x escapes with octal meaning
-    // as in C, and one with \x00 for null bytes.
-    let mut suggest_1 = if is_string { "\"" } else { "b\"" }.to_string();
-    let mut suggest_2 = suggest_1.clone();
-    let mut index = 0;
-    for (from, to) in found {
-        suggest_1.push_str(&contents[index..from]);
-        suggest_2.push_str(&contents[index..from]);
-
-        // construct a replacement escape
-        // the maximum value is \077, or \x3f, so u8 is sufficient here
-        if let Ok(n) = u8::from_str_radix(&contents[from + 1..to], 8) {
-            write!(suggest_1, "\\x{n:02x}").unwrap();
-        }
-
-        // append the null byte as \x00 and the following digits literally
-        suggest_2.push_str("\\x00");
-        suggest_2.push_str(&contents[from + 2..to]);
-
-        index = to;
-    }
-    suggest_1.push_str(&contents[index..]);
-    suggest_1.push('"');
-    suggest_2.push_str(&contents[index..]);
-    suggest_2.push('"');
-
     span_lint_and_then(
         cx,
         OCTAL_ESCAPES,
@@ -129,23 +103,53 @@ fn check_lit(cx: &EarlyContext<'_>, lit: &Lit, span: Span, is_string: bool) {
                 "octal escapes are not supported, `\\0` is always a null {}",
                 if is_string { "character" } else { "byte" }
             ));
-            // suggestion 1: equivalent hex escape
-            diag.span_suggestion(
-                span,
-                "if an octal escape was intended, use the hexadecimal representation instead",
-                suggest_1,
-                Applicability::MaybeIncorrect,
-            );
-            // suggestion 2: unambiguous null byte
-            diag.span_suggestion(
-                span,
-                format!(
-                    "if the null {} is intended, disambiguate using",
-                    if is_string { "character" } else { "byte" }
-                ),
-                suggest_2,
-                Applicability::MaybeIncorrect,
-            );
+
+            // Generate suggestions if the string is not too long (~ 5 lines)
+            if contents.len() < 400 {
+                // construct two suggestion strings, one with \x escapes with octal meaning
+                // as in C, and one with \x00 for null bytes.
+                let mut suggest_1 = if is_string { "\"" } else { "b\"" }.to_string();
+                let mut suggest_2 = suggest_1.clone();
+                let mut index = 0;
+                for (from, to) in found {
+                    suggest_1.push_str(&contents[index..from]);
+                    suggest_2.push_str(&contents[index..from]);
+
+                    // construct a replacement escape
+                    // the maximum value is \077, or \x3f, so u8 is sufficient here
+                    if let Ok(n) = u8::from_str_radix(&contents[from + 1..to], 8) {
+                        write!(suggest_1, "\\x{n:02x}").unwrap();
+                    }
+
+                    // append the null byte as \x00 and the following digits literally
+                    suggest_2.push_str("\\x00");
+                    suggest_2.push_str(&contents[from + 2..to]);
+
+                    index = to;
+                }
+                suggest_1.push_str(&contents[index..]);
+                suggest_2.push_str(&contents[index..]);
+
+                suggest_1.push('"');
+                suggest_2.push('"');
+                // suggestion 1: equivalent hex escape
+                diag.span_suggestion(
+                    span,
+                    "if an octal escape was intended, use the hexadecimal representation instead",
+                    suggest_1,
+                    Applicability::MaybeIncorrect,
+                );
+                // suggestion 2: unambiguous null byte
+                diag.span_suggestion(
+                    span,
+                    format!(
+                        "if the null {} is intended, disambiguate using",
+                        if is_string { "character" } else { "byte" }
+                    ),
+                    suggest_2,
+                    Applicability::MaybeIncorrect,
+                );
+            }
         },
     );
 }
diff --git a/tests/ui/octal_escapes.rs b/tests/ui/octal_escapes.rs
index 53145ef0fd2..61ea9660457 100644
--- a/tests/ui/octal_escapes.rs
+++ b/tests/ui/octal_escapes.rs
@@ -17,4 +17,5 @@ fn main() {
     let _good3 = "\0\0";
     let _good4 = "X\0\0X";
     let _good5 = "锈\0锈";
+    let _good6 = "\0\\01";
 }
diff --git a/tests/ui/octal_escapes.stderr b/tests/ui/octal_escapes.stderr
index 295dc1798e3..aa362e96321 100644
--- a/tests/ui/octal_escapes.stderr
+++ b/tests/ui/octal_escapes.stderr
@@ -63,6 +63,22 @@ help: if the null character is intended, disambiguate using
 LL |     let _bad4 = "/x001234567";
    |                 ~~~~~~~~~~~~~
 
+error: octal-looking escape in string literal
+  --> $DIR/octal_escapes.rs:9:17
+   |
+LL |     let _bad5 = "/0/03";
+   |                 ^^^^^^^
+   |
+   = help: octal escapes are not supported, `/0` is always a null character
+help: if an octal escape was intended, use the hexadecimal representation instead
+   |
+LL |     let _bad5 = "/0/x03";
+   |                 ~~~~~~~~
+help: if the null character is intended, disambiguate using
+   |
+LL |     let _bad5 = "/0/x003";
+   |                 ~~~~~~~~~
+
 error: octal-looking escape in string literal
   --> $DIR/octal_escapes.rs:10:17
    |
@@ -127,5 +143,5 @@ help: if the null character is intended, disambiguate using
 LL |     let _bad9 = "锈/x0011锈";
    |                 ~~~~~~~~~~~~
 
-error: aborting due to 8 previous errors
+error: aborting due to 9 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From b1c784d31f3361b3093466d61b8e62c997b1d086 Mon Sep 17 00:00:00 2001
From: Michael Schubart <michael@schubart.net>
Date: Fri, 7 Apr 2023 08:00:53 +0900
Subject: Fix false negatives by using `expr_or_init`

---
 clippy_lints/src/manual_slice_size_calculation.rs |  5 ++++-
 tests/ui/manual_slice_size_calculation.rs         | 12 +++++------
 tests/ui/manual_slice_size_calculation.stderr     | 26 ++++++++++++++++++++++-
 3 files changed, 35 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_slice_size_calculation.rs b/clippy_lints/src/manual_slice_size_calculation.rs
index 2659f347778..92ee79453a3 100644
--- a/clippy_lints/src/manual_slice_size_calculation.rs
+++ b/clippy_lints/src/manual_slice_size_calculation.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_help;
-use clippy_utils::in_constant;
+use clippy_utils::{expr_or_init, in_constant};
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
@@ -60,6 +60,9 @@ fn simplify<'tcx>(
     expr1: &'tcx Expr<'tcx>,
     expr2: &'tcx Expr<'tcx>,
 ) -> Option<&'tcx Expr<'tcx>> {
+    let expr1 = expr_or_init(cx, expr1);
+    let expr2 = expr_or_init(cx, expr2);
+
     simplify_half(cx, expr1, expr2).or_else(|| simplify_half(cx, expr2, expr1))
 }
 
diff --git a/tests/ui/manual_slice_size_calculation.rs b/tests/ui/manual_slice_size_calculation.rs
index 2cb8c4c2ad3..5082f931f3c 100644
--- a/tests/ui/manual_slice_size_calculation.rs
+++ b/tests/ui/manual_slice_size_calculation.rs
@@ -12,6 +12,12 @@ fn main() {
     let _ = size_of::<i32>() * s_i32.len(); // WARNING
     let _ = size_of::<i32>() * s_i32.len() * 5; // WARNING
 
+    let len = s_i32.len();
+    let size = size_of::<i32>();
+    let _ = len * size_of::<i32>(); // WARNING
+    let _ = s_i32.len() * size; // WARNING
+    let _ = len * size; // WARNING
+
     // True negatives:
     let _ = size_of::<i32>() + s_i32.len(); // Ok, not a multiplication
     let _ = size_of::<i32>() * s_i32.partition_point(|_| true); // Ok, not len()
@@ -22,12 +28,6 @@ fn main() {
     // False negatives:
     let _ = 5 * size_of::<i32>() * s_i32.len(); // Ok (MISSED OPPORTUNITY)
     let _ = size_of::<i32>() * 5 * s_i32.len(); // Ok (MISSED OPPORTUNITY)
-
-    let len = s_i32.len();
-    let size = size_of::<i32>();
-    let _ = len * size_of::<i32>(); // Ok (MISSED OPPORTUNITY)
-    let _ = s_i32.len() * size; // Ok (MISSED OPPORTUNITY)
-    let _ = len * size; // Ok (MISSED OPPORTUNITY)
 }
 
 const fn _const(s_i32: &[i32]) {
diff --git a/tests/ui/manual_slice_size_calculation.stderr b/tests/ui/manual_slice_size_calculation.stderr
index 33de9fad4d3..4a24fc60a0f 100644
--- a/tests/ui/manual_slice_size_calculation.stderr
+++ b/tests/ui/manual_slice_size_calculation.stderr
@@ -23,5 +23,29 @@ LL |     let _ = size_of::<i32>() * s_i32.len() * 5; // WARNING
    |
    = help: consider using std::mem::size_of_value instead
 
-error: aborting due to 3 previous errors
+error: manual slice size calculation
+  --> $DIR/manual_slice_size_calculation.rs:17:13
+   |
+LL |     let _ = len * size_of::<i32>(); // WARNING
+   |             ^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using std::mem::size_of_value instead
+
+error: manual slice size calculation
+  --> $DIR/manual_slice_size_calculation.rs:18:13
+   |
+LL |     let _ = s_i32.len() * size; // WARNING
+   |             ^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using std::mem::size_of_value instead
+
+error: manual slice size calculation
+  --> $DIR/manual_slice_size_calculation.rs:19:13
+   |
+LL |     let _ = len * size; // WARNING
+   |             ^^^^^^^^^^
+   |
+   = help: consider using std::mem::size_of_value instead
+
+error: aborting due to 6 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 5d01e6e96cc72694529a32c42459b20ddf665507 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Mon, 13 Mar 2023 13:06:31 +0100
Subject: new lint: suspicious_doc_comments

---
 CHANGELOG.md                                      |   1 +
 clippy_lints/src/declared_lints.rs                |   1 +
 clippy_lints/src/lib.rs                           |   2 +
 clippy_lints/src/suspicious_doc_comments.rs       |  94 ++++++++++++++++++
 tests/ui/suspicious_doc_comments.fixed            |  81 +++++++++++++++
 tests/ui/suspicious_doc_comments.rs               |  81 +++++++++++++++
 tests/ui/suspicious_doc_comments.stderr           | 114 ++++++++++++++++++++++
 tests/ui/suspicious_doc_comments_unfixable.rs     |  16 +++
 tests/ui/suspicious_doc_comments_unfixable.stderr |  37 +++++++
 9 files changed, 427 insertions(+)
 create mode 100644 clippy_lints/src/suspicious_doc_comments.rs
 create mode 100644 tests/ui/suspicious_doc_comments.fixed
 create mode 100644 tests/ui/suspicious_doc_comments.rs
 create mode 100644 tests/ui/suspicious_doc_comments.stderr
 create mode 100644 tests/ui/suspicious_doc_comments_unfixable.rs
 create mode 100644 tests/ui/suspicious_doc_comments_unfixable.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index f615b27bf68..559b560dde4 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4925,6 +4925,7 @@ Released 2018-09-13
 [`suspicious_arithmetic_impl`]: https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_arithmetic_impl
 [`suspicious_assignment_formatting`]: https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_assignment_formatting
 [`suspicious_command_arg_space`]: https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_command_arg_space
+[`suspicious_doc_comments`]: https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_doc_comments
 [`suspicious_else_formatting`]: https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_else_formatting
 [`suspicious_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_map
 [`suspicious_op_assign_impl`]: https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_op_assign_impl
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 09ae6b8ee57..f24dab62780 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -569,6 +569,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::strings::STR_TO_STRING_INFO,
     crate::strings::TRIM_SPLIT_WHITESPACE_INFO,
     crate::strlen_on_c_strings::STRLEN_ON_C_STRINGS_INFO,
+    crate::suspicious_doc_comments::SUSPICIOUS_DOC_COMMENTS_INFO,
     crate::suspicious_operation_groupings::SUSPICIOUS_OPERATION_GROUPINGS_INFO,
     crate::suspicious_trait_impl::SUSPICIOUS_ARITHMETIC_IMPL_INFO,
     crate::suspicious_trait_impl::SUSPICIOUS_OP_ASSIGN_IMPL_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 2a0f219331e..bac82eca817 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -284,6 +284,7 @@ mod slow_vector_initialization;
 mod std_instead_of_core;
 mod strings;
 mod strlen_on_c_strings;
+mod suspicious_doc_comments;
 mod suspicious_operation_groupings;
 mod suspicious_trait_impl;
 mod suspicious_xor_used_as_pow;
@@ -958,6 +959,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(lines_filter_map_ok::LinesFilterMapOk));
     store.register_late_pass(|_| Box::new(tests_outside_test_module::TestsOutsideTestModule));
     store.register_late_pass(|_| Box::new(manual_slice_size_calculation::ManualSliceSizeCalculation));
+    store.register_early_pass(|| Box::new(suspicious_doc_comments::SuspiciousDocComments));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/suspicious_doc_comments.rs b/clippy_lints/src/suspicious_doc_comments.rs
new file mode 100644
index 00000000000..e5746ca99ca
--- /dev/null
+++ b/clippy_lints/src/suspicious_doc_comments.rs
@@ -0,0 +1,94 @@
+use clippy_utils::diagnostics::{multispan_sugg_with_applicability, span_lint_and_then};
+use if_chain::if_chain;
+use rustc_ast::{token::CommentKind, AttrKind, AttrStyle, Attribute, Item};
+use rustc_errors::Applicability;
+use rustc_lint::{EarlyContext, EarlyLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::Span;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Detects the use of outer doc comments (`///`, `/**`) followed by a bang (`!`): `///!`
+    ///
+    /// ### Why is this bad?
+    /// Triple-slash comments (known as "outer doc comments") apply to items that follow it.
+    /// An outer doc comment followed by a bang (i.e. `///!`) has no specific meaning.
+    ///
+    /// The user most likely meant to write an inner doc comment (`//!`, `/*!`), which
+    /// applies to the parent item (i.e. the item that the comment is contained in,
+    /// usually a module or crate).
+    ///
+    /// ### Known problems
+    /// Inner doc comments can only appear before items, so there are certain cases where the suggestion
+    /// made by this lint is not valid code. For example:
+    /// ```rs
+    /// fn foo() {}
+    /// ///!
+    /// fn bar() {}
+    /// ```
+    /// This lint detects the doc comment and suggests changing it to `//!`, but an inner doc comment
+    /// is not valid at that position.
+    ///
+    /// ### Example
+    /// In this example, the doc comment is attached to the *function*, rather than the *module*.
+    /// ```rust
+    /// pub mod util {
+    ///     ///! This module contains utility functions.
+    ///
+    ///     pub fn dummy() {}
+    /// }
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust
+    /// pub mod util {
+    ///     //! This module contains utility functions.
+    ///
+    ///     pub fn dummy() {}
+    /// }
+    /// ```
+    #[clippy::version = "1.70.0"]
+    pub SUSPICIOUS_DOC_COMMENTS,
+    suspicious,
+    "suspicious usage of (outer) doc comments"
+}
+declare_lint_pass!(SuspiciousDocComments => [SUSPICIOUS_DOC_COMMENTS]);
+
+const WARNING: &str = "this is an outer doc comment and does not apply to the parent module or crate";
+const HELP: &str = "use an inner doc comment to document the parent module or crate";
+
+impl EarlyLintPass for SuspiciousDocComments {
+    fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {
+        let replacements = collect_doc_comment_replacements(&item.attrs);
+
+        if let Some(((lo_span, _), (hi_span, _))) = replacements.first().zip(replacements.last()) {
+            let span = lo_span.to(*hi_span);
+
+            span_lint_and_then(cx, SUSPICIOUS_DOC_COMMENTS, span, WARNING, |diag| {
+                multispan_sugg_with_applicability(diag, HELP, Applicability::MaybeIncorrect, replacements);
+            });
+        }
+    }
+}
+
+fn collect_doc_comment_replacements(attrs: &[Attribute]) -> Vec<(Span, String)> {
+    attrs
+        .iter()
+        .filter_map(|attr| {
+            if_chain! {
+                if let AttrKind::DocComment(com_kind, sym) = attr.kind;
+                if let AttrStyle::Outer = attr.style;
+                if let Some(com) = sym.as_str().strip_prefix('!');
+                then {
+                    let sugg = match com_kind {
+                        CommentKind::Line => format!("//!{com}"),
+                        CommentKind::Block => format!("/*!{com}*/")
+                    };
+                    Some((attr.span, sugg))
+                } else {
+                    None
+                }
+            }
+        })
+        .collect()
+}
diff --git a/tests/ui/suspicious_doc_comments.fixed b/tests/ui/suspicious_doc_comments.fixed
new file mode 100644
index 00000000000..b404df94d3c
--- /dev/null
+++ b/tests/ui/suspicious_doc_comments.fixed
@@ -0,0 +1,81 @@
+// run-rustfix
+#![allow(unused)]
+#![warn(clippy::suspicious_doc_comments)]
+
+//! Real module documentation.
+//! Fake module documentation.
+fn baz() {}
+
+pub mod singleline_outer_doc {
+    //! This module contains useful functions.
+
+    pub fn bar() {}
+}
+
+pub mod singleline_inner_doc {
+    //! This module contains useful functions.
+
+    pub fn bar() {}
+}
+
+pub mod multiline_outer_doc {
+    /*! This module contains useful functions.
+     */
+
+    pub fn bar() {}
+}
+
+pub mod multiline_inner_doc {
+    /*! This module contains useful functions.
+     */
+
+    pub fn bar() {}
+}
+
+pub mod multiline_outer_doc2 {
+    //! This module
+    //! contains
+    //! useful functions.
+
+    pub fn bar() {}
+}
+
+pub mod multiline_outer_doc3 {
+    //! a
+    //! b
+
+    /// c
+    pub fn bar() {}
+}
+
+pub mod multiline_outer_doc4 {
+    //! a
+    /// b
+    pub fn bar() {}
+}
+
+pub mod multiline_outer_doc_gap {
+    //! a
+
+    //! b
+    pub fn bar() {}
+}
+
+pub mod multiline_outer_doc_commented {
+    /////! This outer doc comment was commented out.
+    pub fn bar() {}
+}
+
+pub mod outer_doc_macro {
+    //! Very cool macro
+    macro_rules! x {
+        () => {};
+    }
+}
+
+pub mod useless_outer_doc {
+    //! Huh.
+    use std::mem;
+}
+
+fn main() {}
diff --git a/tests/ui/suspicious_doc_comments.rs b/tests/ui/suspicious_doc_comments.rs
new file mode 100644
index 00000000000..46eff51e220
--- /dev/null
+++ b/tests/ui/suspicious_doc_comments.rs
@@ -0,0 +1,81 @@
+// run-rustfix
+#![allow(unused)]
+#![warn(clippy::suspicious_doc_comments)]
+
+//! Real module documentation.
+///! Fake module documentation.
+fn baz() {}
+
+pub mod singleline_outer_doc {
+    ///! This module contains useful functions.
+
+    pub fn bar() {}
+}
+
+pub mod singleline_inner_doc {
+    //! This module contains useful functions.
+
+    pub fn bar() {}
+}
+
+pub mod multiline_outer_doc {
+    /**! This module contains useful functions.
+     */
+
+    pub fn bar() {}
+}
+
+pub mod multiline_inner_doc {
+    /*! This module contains useful functions.
+     */
+
+    pub fn bar() {}
+}
+
+pub mod multiline_outer_doc2 {
+    ///! This module
+    ///! contains
+    ///! useful functions.
+
+    pub fn bar() {}
+}
+
+pub mod multiline_outer_doc3 {
+    ///! a
+    ///! b
+
+    /// c
+    pub fn bar() {}
+}
+
+pub mod multiline_outer_doc4 {
+    ///! a
+    /// b
+    pub fn bar() {}
+}
+
+pub mod multiline_outer_doc_gap {
+    ///! a
+
+    ///! b
+    pub fn bar() {}
+}
+
+pub mod multiline_outer_doc_commented {
+    /////! This outer doc comment was commented out.
+    pub fn bar() {}
+}
+
+pub mod outer_doc_macro {
+    ///! Very cool macro
+    macro_rules! x {
+        () => {};
+    }
+}
+
+pub mod useless_outer_doc {
+    ///! Huh.
+    use std::mem;
+}
+
+fn main() {}
diff --git a/tests/ui/suspicious_doc_comments.stderr b/tests/ui/suspicious_doc_comments.stderr
new file mode 100644
index 00000000000..6c167df2787
--- /dev/null
+++ b/tests/ui/suspicious_doc_comments.stderr
@@ -0,0 +1,114 @@
+error: this is an outer doc comment and does not apply to the parent module or crate
+  --> $DIR/suspicious_doc_comments.rs:6:1
+   |
+LL | ///! Fake module documentation.
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::suspicious-doc-comments` implied by `-D warnings`
+help: use an inner doc comment to document the parent module or crate
+   |
+LL | //! Fake module documentation.
+   |
+
+error: this is an outer doc comment and does not apply to the parent module or crate
+  --> $DIR/suspicious_doc_comments.rs:10:5
+   |
+LL |     ///! This module contains useful functions.
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use an inner doc comment to document the parent module or crate
+   |
+LL |     //! This module contains useful functions.
+   |
+
+error: this is an outer doc comment and does not apply to the parent module or crate
+  --> $DIR/suspicious_doc_comments.rs:22:5
+   |
+LL | /     /**! This module contains useful functions.
+LL | |      */
+   | |_______^
+   |
+help: use an inner doc comment to document the parent module or crate
+   |
+LL ~     /*! This module contains useful functions.
+LL +      */
+   |
+
+error: this is an outer doc comment and does not apply to the parent module or crate
+  --> $DIR/suspicious_doc_comments.rs:36:5
+   |
+LL | /     ///! This module
+LL | |     ///! contains
+LL | |     ///! useful functions.
+   | |__________________________^
+   |
+help: use an inner doc comment to document the parent module or crate
+   |
+LL ~     //! This module
+LL ~     //! contains
+LL ~     //! useful functions.
+   |
+
+error: this is an outer doc comment and does not apply to the parent module or crate
+  --> $DIR/suspicious_doc_comments.rs:44:5
+   |
+LL | /     ///! a
+LL | |     ///! b
+   | |__________^
+   |
+help: use an inner doc comment to document the parent module or crate
+   |
+LL ~     //! a
+LL ~     //! b
+   |
+
+error: this is an outer doc comment and does not apply to the parent module or crate
+  --> $DIR/suspicious_doc_comments.rs:52:5
+   |
+LL |     ///! a
+   |     ^^^^^^
+   |
+help: use an inner doc comment to document the parent module or crate
+   |
+LL |     //! a
+   |
+
+error: this is an outer doc comment and does not apply to the parent module or crate
+  --> $DIR/suspicious_doc_comments.rs:58:5
+   |
+LL | /     ///! a
+LL | |
+LL | |     ///! b
+   | |__________^
+   |
+help: use an inner doc comment to document the parent module or crate
+   |
+LL ~     //! a
+LL | 
+LL ~     //! b
+   |
+
+error: this is an outer doc comment and does not apply to the parent module or crate
+  --> $DIR/suspicious_doc_comments.rs:70:5
+   |
+LL |     ///! Very cool macro
+   |     ^^^^^^^^^^^^^^^^^^^^
+   |
+help: use an inner doc comment to document the parent module or crate
+   |
+LL |     //! Very cool macro
+   |
+
+error: this is an outer doc comment and does not apply to the parent module or crate
+  --> $DIR/suspicious_doc_comments.rs:77:5
+   |
+LL |     ///! Huh.
+   |     ^^^^^^^^^
+   |
+help: use an inner doc comment to document the parent module or crate
+   |
+LL |     //! Huh.
+   |
+
+error: aborting due to 9 previous errors
+
diff --git a/tests/ui/suspicious_doc_comments_unfixable.rs b/tests/ui/suspicious_doc_comments_unfixable.rs
new file mode 100644
index 00000000000..ad98c7f4966
--- /dev/null
+++ b/tests/ui/suspicious_doc_comments_unfixable.rs
@@ -0,0 +1,16 @@
+#![allow(unused)]
+#![warn(clippy::suspicious_doc_comments)]
+
+///! a
+///! b
+/// c
+///! d
+pub fn foo() {}
+
+///! a
+///! b
+/// c
+///! d
+use std::mem;
+
+fn main() {}
diff --git a/tests/ui/suspicious_doc_comments_unfixable.stderr b/tests/ui/suspicious_doc_comments_unfixable.stderr
new file mode 100644
index 00000000000..f89146dad36
--- /dev/null
+++ b/tests/ui/suspicious_doc_comments_unfixable.stderr
@@ -0,0 +1,37 @@
+error: this is an outer doc comment and does not apply to the parent module or crate
+  --> $DIR/suspicious_doc_comments_unfixable.rs:4:1
+   |
+LL | / ///! a
+LL | | ///! b
+LL | | /// c
+LL | | ///! d
+   | |______^
+   |
+   = note: `-D clippy::suspicious-doc-comments` implied by `-D warnings`
+help: use an inner doc comment to document the parent module or crate
+   |
+LL + //! a
+LL + //! b
+LL | /// c
+LL + //! d
+   |
+
+error: this is an outer doc comment and does not apply to the parent module or crate
+  --> $DIR/suspicious_doc_comments_unfixable.rs:10:1
+   |
+LL | / ///! a
+LL | | ///! b
+LL | | /// c
+LL | | ///! d
+   | |______^
+   |
+help: use an inner doc comment to document the parent module or crate
+   |
+LL + //! a
+LL + //! b
+LL | /// c
+LL + //! d
+   |
+
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 9ec542873cde1332baf2a0ed33088ba98eba25cf Mon Sep 17 00:00:00 2001
From: bluthej <joffrey.bluthe@e.email>
Date: Thu, 6 Apr 2023 07:49:59 +0200
Subject: Add 5 other container types and start testing

---
 clippy_lints/src/methods/clear_with_drain.rs | 33 +++++++++++++++++++-----
 clippy_lints/src/methods/mod.rs              | 11 ++++----
 tests/ui/clear_with_drain.fixed              | 25 +++++++++++++++++-
 tests/ui/clear_with_drain.rs                 | 25 +++++++++++++++++-
 tests/ui/clear_with_drain.stderr             | 38 +++++++++++++++++++++++-----
 5 files changed, 112 insertions(+), 20 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/clear_with_drain.rs b/clippy_lints/src/methods/clear_with_drain.rs
index 24496bd4689..4f5b7762e3c 100644
--- a/clippy_lints/src/methods/clear_with_drain.rs
+++ b/clippy_lints/src/methods/clear_with_drain.rs
@@ -2,6 +2,7 @@ use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::is_range_full;
 use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_errors::Applicability;
+use rustc_hir as hir;
 use rustc_hir::{Expr, ExprKind, QPath};
 use rustc_lint::LateContext;
 use rustc_span::symbol::sym;
@@ -9,17 +10,37 @@ use rustc_span::Span;
 
 use super::CLEAR_WITH_DRAIN;
 
-pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'_>, span: Span, arg: &Expr<'_>) {
-    let ty = cx.typeck_results().expr_ty(recv);
-    if is_type_diagnostic_item(cx, ty, sym::Vec)
-        && let ExprKind::Path(QPath::Resolved(None, container_path)) = recv.kind
-        && is_range_full(cx, arg, Some(container_path))
+const ACCEPTABLE_TYPES_WITH_ARG: [rustc_span::Symbol; 3] = [sym::String, sym::Vec, sym::VecDeque];
+
+const ACCEPTABLE_TYPES_WITHOUT_ARG: [rustc_span::Symbol; 3] = [sym::BinaryHeap, sym::HashMap, sym::HashSet];
+
+pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'_>, span: Span, arg: Option<&Expr<'_>>) {
+    if let Some(arg) = arg {
+        if match_acceptable_type(cx, recv, &ACCEPTABLE_TYPES_WITH_ARG)
+            && let ExprKind::Path(QPath::Resolved(None, container_path)) = recv.kind
+            && is_range_full(cx, arg, Some(container_path))
+        {
+            suggest(cx, expr, recv, span);
+        }
+    } else if match_acceptable_type(cx, recv, &ACCEPTABLE_TYPES_WITHOUT_ARG) {
+        suggest(cx, expr, recv, span);
+    }
+}
+
+fn match_acceptable_type(cx: &LateContext<'_>, expr: &hir::Expr<'_>, types: &[rustc_span::Symbol]) -> bool {
+    let expr_ty = cx.typeck_results().expr_ty(expr).peel_refs();
+    types.iter().any(|&ty| is_type_diagnostic_item(cx, expr_ty, ty))
+}
+
+fn suggest(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'_>, span: Span) {
+    if let Some(adt) = cx.typeck_results().expr_ty(recv).ty_adt_def()
+        && let Some(ty_name) = cx.tcx.get_diagnostic_name(adt.did())
     {
         span_lint_and_sugg(
             cx,
             CLEAR_WITH_DRAIN,
             span.with_hi(expr.span.hi()),
-            "`drain` used to clear a `Vec`",
+            &format!("`drain` used to clear a `{}`", ty_name),
             "try",
             "clear()".to_string(),
             Applicability::MachineApplicable,
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 257bc4eccc3..c25f1b60aa5 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3589,12 +3589,13 @@ impl Methods {
                     Some(("bytes", recv2, [], _, _)) => bytes_count_to_len::check(cx, expr, recv, recv2),
                     _ => {},
                 },
-                ("drain", [arg]) => {
-                if let Node::Stmt(Stmt { hir_id: _, kind, .. }) = cx.tcx.hir().get_parent(expr.hir_id)
-                    && matches!(kind, StmtKind::Semi(_))
+                ("drain", ..) => {
+                    if let Node::Stmt(Stmt { hir_id: _, kind, .. }) = cx.tcx.hir().get_parent(expr.hir_id)
+                        && matches!(kind, StmtKind::Semi(_))
+                        && args.len() <= 1
                     {
-                        clear_with_drain::check(cx, expr, recv, span, arg);
-                    } else {
+                        clear_with_drain::check(cx, expr, recv, span, args.first());
+                    } else if let [arg] = args {
                         iter_with_drain::check(cx, expr, recv, span, arg);
                     }
                 },
diff --git a/tests/ui/clear_with_drain.fixed b/tests/ui/clear_with_drain.fixed
index 9c4dc010ca7..dd02cc9148f 100644
--- a/tests/ui/clear_with_drain.fixed
+++ b/tests/ui/clear_with_drain.fixed
@@ -2,6 +2,11 @@
 #![allow(unused)]
 #![warn(clippy::clear_with_drain)]
 
+use std::collections::BinaryHeap;
+use std::collections::HashMap;
+use std::collections::HashSet;
+use std::collections::VecDeque;
+
 fn range() {
     let mut v = vec![1, 2, 3];
     let iter = v.drain(0..v.len()); // Yay
@@ -83,4 +88,22 @@ fn partial_drains() {
     let w: Vec<i8> = v.drain(1..v.len() - 1).collect(); // Yay
 }
 
-fn main() {}
+fn main() {
+    let mut deque: VecDeque<_> = [1, 2, 3].into();
+    deque.clear();
+
+    let mut set = HashSet::from([1, 2, 3]);
+    set.clear();
+
+    let mut a = HashMap::new();
+    a.insert(1, "a");
+    a.insert(2, "b");
+    a.clear();
+
+    let mut heap = BinaryHeap::from([1, 3]);
+    heap.clear();
+
+    // Not firing for now because `String` is not reckognized by `is_type_diagnostic_item`
+    let mut s = String::from("α is alpha, β is beta");
+    s.drain(..);
+}
diff --git a/tests/ui/clear_with_drain.rs b/tests/ui/clear_with_drain.rs
index f00dbab234c..af2fe503d9a 100644
--- a/tests/ui/clear_with_drain.rs
+++ b/tests/ui/clear_with_drain.rs
@@ -2,6 +2,11 @@
 #![allow(unused)]
 #![warn(clippy::clear_with_drain)]
 
+use std::collections::BinaryHeap;
+use std::collections::HashMap;
+use std::collections::HashSet;
+use std::collections::VecDeque;
+
 fn range() {
     let mut v = vec![1, 2, 3];
     let iter = v.drain(0..v.len()); // Yay
@@ -83,4 +88,22 @@ fn partial_drains() {
     let w: Vec<i8> = v.drain(1..v.len() - 1).collect(); // Yay
 }
 
-fn main() {}
+fn main() {
+    let mut deque: VecDeque<_> = [1, 2, 3].into();
+    deque.drain(..);
+
+    let mut set = HashSet::from([1, 2, 3]);
+    set.drain();
+
+    let mut a = HashMap::new();
+    a.insert(1, "a");
+    a.insert(2, "b");
+    a.drain();
+
+    let mut heap = BinaryHeap::from([1, 3]);
+    heap.drain();
+
+    // Not firing for now because `String` is not reckognized by `is_type_diagnostic_item`
+    let mut s = String::from("α is alpha, β is beta");
+    s.drain(..);
+}
diff --git a/tests/ui/clear_with_drain.stderr b/tests/ui/clear_with_drain.stderr
index c88aa1a23cb..2c0cc846de2 100644
--- a/tests/ui/clear_with_drain.stderr
+++ b/tests/ui/clear_with_drain.stderr
@@ -1,5 +1,5 @@
 error: `drain` used to clear a `Vec`
-  --> $DIR/clear_with_drain.rs:17:7
+  --> $DIR/clear_with_drain.rs:22:7
    |
 LL |     v.drain(0..v.len()); // Nay
    |       ^^^^^^^^^^^^^^^^^ help: try: `clear()`
@@ -7,34 +7,58 @@ LL |     v.drain(0..v.len()); // Nay
    = note: `-D clippy::clear-with-drain` implied by `-D warnings`
 
 error: `drain` used to clear a `Vec`
-  --> $DIR/clear_with_drain.rs:20:7
+  --> $DIR/clear_with_drain.rs:25:7
    |
 LL |     v.drain(usize::MIN..v.len()); // Nay
    |       ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `clear()`
 
 error: `drain` used to clear a `Vec`
-  --> $DIR/clear_with_drain.rs:35:7
+  --> $DIR/clear_with_drain.rs:40:7
    |
 LL |     v.drain(0..); // Nay
    |       ^^^^^^^^^^ help: try: `clear()`
 
 error: `drain` used to clear a `Vec`
-  --> $DIR/clear_with_drain.rs:38:7
+  --> $DIR/clear_with_drain.rs:43:7
    |
 LL |     v.drain(usize::MIN..); // Nay
    |       ^^^^^^^^^^^^^^^^^^^ help: try: `clear()`
 
 error: `drain` used to clear a `Vec`
-  --> $DIR/clear_with_drain.rs:52:7
+  --> $DIR/clear_with_drain.rs:57:7
    |
 LL |     v.drain(..); // Nay
    |       ^^^^^^^^^ help: try: `clear()`
 
 error: `drain` used to clear a `Vec`
-  --> $DIR/clear_with_drain.rs:66:7
+  --> $DIR/clear_with_drain.rs:71:7
    |
 LL |     v.drain(..v.len()); // Nay
    |       ^^^^^^^^^^^^^^^^ help: try: `clear()`
 
-error: aborting due to 6 previous errors
+error: `drain` used to clear a `VecDeque`
+  --> $DIR/clear_with_drain.rs:93:11
+   |
+LL |     deque.drain(..);
+   |           ^^^^^^^^^ help: try: `clear()`
+
+error: `drain` used to clear a `HashSet`
+  --> $DIR/clear_with_drain.rs:96:9
+   |
+LL |     set.drain();
+   |         ^^^^^^^ help: try: `clear()`
+
+error: `drain` used to clear a `HashMap`
+  --> $DIR/clear_with_drain.rs:101:7
+   |
+LL |     a.drain();
+   |       ^^^^^^^ help: try: `clear()`
+
+error: `drain` used to clear a `BinaryHeap`
+  --> $DIR/clear_with_drain.rs:104:10
+   |
+LL |     heap.drain();
+   |          ^^^^^^^ help: try: `clear()`
+
+error: aborting due to 10 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 5b57e5cec84a9c3c2f6240c9f0f4071f391fe6ab Mon Sep 17 00:00:00 2001
From: bluthej <joffrey.bluthe@e.email>
Date: Sun, 9 Apr 2023 12:20:59 +0200
Subject: Fix false negative with `String` and add tests

`String` is currently not a diagnostic item so it needs special
treatment
---
 clippy_lints/src/methods/clear_with_drain.rs |  12 +-
 tests/ui/clear_with_drain.fixed              | 333 +++++++++++++++++++++++----
 tests/ui/clear_with_drain.rs                 | 333 +++++++++++++++++++++++----
 tests/ui/clear_with_drain.stderr             | 104 +++++++--
 4 files changed, 675 insertions(+), 107 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/clear_with_drain.rs b/clippy_lints/src/methods/clear_with_drain.rs
index 4f5b7762e3c..6ce3fdae407 100644
--- a/clippy_lints/src/methods/clear_with_drain.rs
+++ b/clippy_lints/src/methods/clear_with_drain.rs
@@ -1,16 +1,17 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::is_range_full;
-use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::ty::{is_type_diagnostic_item, is_type_lang_item};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
-use rustc_hir::{Expr, ExprKind, QPath};
+use rustc_hir::{Expr, ExprKind, LangItem, QPath};
 use rustc_lint::LateContext;
 use rustc_span::symbol::sym;
 use rustc_span::Span;
 
 use super::CLEAR_WITH_DRAIN;
 
-const ACCEPTABLE_TYPES_WITH_ARG: [rustc_span::Symbol; 3] = [sym::String, sym::Vec, sym::VecDeque];
+// Add `String` here when it is added to diagnostic items
+const ACCEPTABLE_TYPES_WITH_ARG: [rustc_span::Symbol; 2] = [sym::Vec, sym::VecDeque];
 
 const ACCEPTABLE_TYPES_WITHOUT_ARG: [rustc_span::Symbol; 3] = [sym::BinaryHeap, sym::HashMap, sym::HashSet];
 
@@ -30,11 +31,14 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'_>, span
 fn match_acceptable_type(cx: &LateContext<'_>, expr: &hir::Expr<'_>, types: &[rustc_span::Symbol]) -> bool {
     let expr_ty = cx.typeck_results().expr_ty(expr).peel_refs();
     types.iter().any(|&ty| is_type_diagnostic_item(cx, expr_ty, ty))
+    // String type is a lang item but not a diagnostic item for now so we need a separate check
+        || is_type_lang_item(cx, expr_ty, LangItem::String)
 }
 
 fn suggest(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'_>, span: Span) {
     if let Some(adt) = cx.typeck_results().expr_ty(recv).ty_adt_def()
-        && let Some(ty_name) = cx.tcx.get_diagnostic_name(adt.did())
+    // Use `opt_item_name` while `String` is not a diagnostic item
+        && let Some(ty_name) = cx.tcx.opt_item_name(adt.did())
     {
         span_lint_and_sugg(
             cx,
diff --git a/tests/ui/clear_with_drain.fixed b/tests/ui/clear_with_drain.fixed
index dd02cc9148f..2d9545eeed1 100644
--- a/tests/ui/clear_with_drain.fixed
+++ b/tests/ui/clear_with_drain.fixed
@@ -2,108 +2,357 @@
 #![allow(unused)]
 #![warn(clippy::clear_with_drain)]
 
-use std::collections::BinaryHeap;
-use std::collections::HashMap;
-use std::collections::HashSet;
-use std::collections::VecDeque;
+use std::collections::{BinaryHeap, HashMap, HashSet, VecDeque};
 
-fn range() {
+fn vec_range() {
+    // Do not lint because iterator is assigned
     let mut v = vec![1, 2, 3];
-    let iter = v.drain(0..v.len()); // Yay
+    let iter = v.drain(0..v.len());
 
+    // Do not lint because iterator is used
     let mut v = vec![1, 2, 3];
-    let n = v.drain(0..v.len()).count(); // Yay
+    let n = v.drain(0..v.len()).count();
 
+    // Do not lint because iterator is assigned and used
     let mut v = vec![1, 2, 3];
-    let iter = v.drain(usize::MIN..v.len()); // Yay
+    let iter = v.drain(usize::MIN..v.len());
     let n = iter.count();
 
+    // Do lint
     let mut v = vec![1, 2, 3];
-    v.clear(); // Nay
+    v.clear();
 
+    // Do lint
     let mut v = vec![1, 2, 3];
-    v.clear(); // Nay
+    v.clear();
 }
 
-fn range_from() {
+fn vec_range_from() {
+    // Do not lint because iterator is assigned
     let mut v = vec![1, 2, 3];
-    let iter = v.drain(0..); // Yay
+    let iter = v.drain(0..);
 
+    // Do not lint because iterator is assigned and used
     let mut v = vec![1, 2, 3];
-    let mut iter = v.drain(0..); // Yay
+    let mut iter = v.drain(0..);
     let next = iter.next();
 
+    // Do not lint because iterator is used
     let mut v = vec![1, 2, 3];
-    let next = v.drain(usize::MIN..).next(); // Yay
+    let next = v.drain(usize::MIN..).next();
 
+    // Do lint
     let mut v = vec![1, 2, 3];
-    v.clear(); // Nay
+    v.clear();
 
+    // Do lint
     let mut v = vec![1, 2, 3];
-    v.clear(); // Nay
+    v.clear();
 }
 
-fn range_full() {
+fn vec_range_full() {
+    // Do not lint because iterator is assigned
     let mut v = vec![1, 2, 3];
-    let iter = v.drain(..); // Yay
+    let iter = v.drain(..);
 
+    // Do not lint because iterator is used
     let mut v = vec![1, 2, 3];
-    // Yay
     for x in v.drain(..) {
         let y = format!("x = {x}");
     }
 
+    // Do lint
     let mut v = vec![1, 2, 3];
-    v.clear(); // Nay
+    v.clear();
 }
 
-fn range_to() {
+fn vec_range_to() {
+    // Do not lint because iterator is assigned
     let mut v = vec![1, 2, 3];
-    let iter = v.drain(..v.len()); // Yay
+    let iter = v.drain(..v.len());
 
+    // Do not lint because iterator is assigned and used
     let mut v = vec![1, 2, 3];
-    let iter = v.drain(..v.len()); // Yay
+    let iter = v.drain(..v.len());
     for x in iter {
         let y = format!("x = {x}");
     }
 
+    // Do lint
     let mut v = vec![1, 2, 3];
-    v.clear(); // Nay
+    v.clear();
 }
 
-fn partial_drains() {
+fn vec_partial_drains() {
+    // Do not lint any of these because the ranges are not full
+
     let mut v = vec![1, 2, 3];
-    v.drain(1..); // Yay
+    v.drain(1..);
     let mut v = vec![1, 2, 3];
-    v.drain(1..).max(); // Yay
+    v.drain(1..).max();
 
     let mut v = vec![1, 2, 3];
-    v.drain(..v.len() - 1); // Yay
+    v.drain(..v.len() - 1);
     let mut v = vec![1, 2, 3];
-    v.drain(..v.len() - 1).min(); // Yay
+    v.drain(..v.len() - 1).min();
 
     let mut v = vec![1, 2, 3];
-    v.drain(1..v.len() - 1); // Yay
+    v.drain(1..v.len() - 1);
     let mut v = vec![1, 2, 3];
-    let w: Vec<i8> = v.drain(1..v.len() - 1).collect(); // Yay
+    let w: Vec<i8> = v.drain(1..v.len() - 1).collect();
+}
+
+fn vec_deque_range() {
+    // Do not lint because iterator is assigned
+    let mut deque = VecDeque::from([1, 2, 3]);
+    let iter = deque.drain(0..deque.len());
+
+    // Do not lint because iterator is used
+    let mut deque = VecDeque::from([1, 2, 3]);
+    let n = deque.drain(0..deque.len()).count();
+
+    // Do not lint because iterator is assigned and used
+    let mut deque = VecDeque::from([1, 2, 3]);
+    let iter = deque.drain(usize::MIN..deque.len());
+    let n = iter.count();
+
+    // Do lint
+    let mut deque = VecDeque::from([1, 2, 3]);
+    deque.clear();
+
+    // Do lint
+    let mut deque = VecDeque::from([1, 2, 3]);
+    deque.clear();
+}
+
+fn vec_deque_range_from() {
+    // Do not lint because iterator is assigned
+    let mut deque = VecDeque::from([1, 2, 3]);
+    let iter = deque.drain(0..);
+
+    // Do not lint because iterator is assigned and used
+    let mut deque = VecDeque::from([1, 2, 3]);
+    let mut iter = deque.drain(0..);
+    let next = iter.next();
+
+    // Do not lint because iterator is used
+    let mut deque = VecDeque::from([1, 2, 3]);
+    let next = deque.drain(usize::MIN..).next();
+
+    // Do lint
+    let mut deque = VecDeque::from([1, 2, 3]);
+    deque.clear();
+
+    // Do lint
+    let mut deque = VecDeque::from([1, 2, 3]);
+    deque.clear();
+}
+
+fn vec_deque_range_full() {
+    // Do not lint because iterator is assigned
+    let mut deque = VecDeque::from([1, 2, 3]);
+    let iter = deque.drain(..);
+
+    // Do not lint because iterator is used
+    let mut deque = VecDeque::from([1, 2, 3]);
+    for x in deque.drain(..) {
+        let y = format!("x = {x}");
+    }
+
+    // Do lint
+    let mut deque = VecDeque::from([1, 2, 3]);
+    deque.clear();
 }
 
-fn main() {
-    let mut deque: VecDeque<_> = [1, 2, 3].into();
+fn vec_deque_range_to() {
+    // Do not lint because iterator is assigned
+    let mut deque = VecDeque::from([1, 2, 3]);
+    let iter = deque.drain(..deque.len());
+
+    // Do not lint because iterator is assigned and used
+    let mut deque = VecDeque::from([1, 2, 3]);
+    let iter = deque.drain(..deque.len());
+    for x in iter {
+        let y = format!("x = {x}");
+    }
+
+    // Do lint
+    let mut deque = VecDeque::from([1, 2, 3]);
     deque.clear();
+}
+
+fn vec_deque_partial_drains() {
+    // Do not lint any of these because the ranges are not full
+
+    let mut deque = VecDeque::from([1, 2, 3]);
+    deque.drain(1..);
+    let mut deque = VecDeque::from([1, 2, 3]);
+    deque.drain(1..).max();
+
+    let mut deque = VecDeque::from([1, 2, 3]);
+    deque.drain(..deque.len() - 1);
+    let mut deque = VecDeque::from([1, 2, 3]);
+    deque.drain(..deque.len() - 1).min();
+
+    let mut deque = VecDeque::from([1, 2, 3]);
+    deque.drain(1..deque.len() - 1);
+    let mut deque = VecDeque::from([1, 2, 3]);
+    let w: Vec<i8> = deque.drain(1..deque.len() - 1).collect();
+}
+
+fn string_range() {
+    // Do not lint because iterator is assigned
+    let mut s = String::from("Hello, world!");
+    let iter = s.drain(0..s.len());
+
+    // Do not lint because iterator is used
+    let mut s = String::from("Hello, world!");
+    let n = s.drain(0..s.len()).count();
+
+    // Do not lint because iterator is assigned and used
+    let mut s = String::from("Hello, world!");
+    let iter = s.drain(usize::MIN..s.len());
+    let n = iter.count();
+
+    // Do lint
+    let mut s = String::from("Hello, world!");
+    s.clear();
+
+    // Do lint
+    let mut s = String::from("Hello, world!");
+    s.clear();
+}
 
+fn string_range_from() {
+    // Do not lint because iterator is assigned
+    let mut s = String::from("Hello, world!");
+    let iter = s.drain(0..);
+
+    // Do not lint because iterator is assigned and used
+    let mut s = String::from("Hello, world!");
+    let mut iter = s.drain(0..);
+    let next = iter.next();
+
+    // Do not lint because iterator is used
+    let mut s = String::from("Hello, world!");
+    let next = s.drain(usize::MIN..).next();
+
+    // Do lint
+    let mut s = String::from("Hello, world!");
+    s.clear();
+
+    // Do lint
+    let mut s = String::from("Hello, world!");
+    s.clear();
+}
+
+fn string_range_full() {
+    // Do not lint because iterator is assigned
+    let mut s = String::from("Hello, world!");
+    let iter = s.drain(..);
+
+    // Do not lint because iterator is used
+    let mut s = String::from("Hello, world!");
+    for x in s.drain(..) {
+        let y = format!("x = {x}");
+    }
+
+    // Do lint
+    let mut s = String::from("Hello, world!");
+    s.clear();
+}
+
+fn string_range_to() {
+    // Do not lint because iterator is assigned
+    let mut s = String::from("Hello, world!");
+    let iter = s.drain(..s.len());
+
+    // Do not lint because iterator is assigned and used
+    let mut s = String::from("Hello, world!");
+    let iter = s.drain(..s.len());
+    for x in iter {
+        let y = format!("x = {x}");
+    }
+
+    // Do lint
+    let mut s = String::from("Hello, world!");
+    s.clear();
+}
+
+fn string_partial_drains() {
+    // Do not lint any of these because the ranges are not full
+
+    let mut s = String::from("Hello, world!");
+    s.drain(1..);
+    let mut s = String::from("Hello, world!");
+    s.drain(1..).max();
+
+    let mut s = String::from("Hello, world!");
+    s.drain(..s.len() - 1);
+    let mut s = String::from("Hello, world!");
+    s.drain(..s.len() - 1).min();
+
+    let mut s = String::from("Hello, world!");
+    s.drain(1..s.len() - 1);
+    let mut s = String::from("Hello, world!");
+    let w: String = s.drain(1..s.len() - 1).collect();
+}
+
+fn hash_set() {
+    // Do not lint because iterator is assigned
+    let mut set = HashSet::from([1, 2, 3]);
+    let iter = set.drain();
+
+    // Do not lint because iterator is assigned and used
+    let mut set = HashSet::from([1, 2, 3]);
+    let mut iter = set.drain();
+    let next = iter.next();
+
+    // Do not lint because iterator is used
+    let mut set = HashSet::from([1, 2, 3]);
+    let next = set.drain().next();
+
+    // Do lint
     let mut set = HashSet::from([1, 2, 3]);
     set.clear();
+}
 
-    let mut a = HashMap::new();
-    a.insert(1, "a");
-    a.insert(2, "b");
-    a.clear();
+fn hash_map() {
+    // Do not lint because iterator is assigned
+    let mut map = HashMap::from([(1, "a"), (2, "b")]);
+    let iter = map.drain();
 
-    let mut heap = BinaryHeap::from([1, 3]);
-    heap.clear();
+    // Do not lint because iterator is assigned and used
+    let mut map = HashMap::from([(1, "a"), (2, "b")]);
+    let mut iter = map.drain();
+    let next = iter.next();
+
+    // Do not lint because iterator is used
+    let mut map = HashMap::from([(1, "a"), (2, "b")]);
+    let next = map.drain().next();
 
-    // Not firing for now because `String` is not reckognized by `is_type_diagnostic_item`
-    let mut s = String::from("α is alpha, β is beta");
-    s.drain(..);
+    // Do lint
+    let mut map = HashMap::from([(1, "a"), (2, "b")]);
+    map.clear();
 }
+
+fn binary_heap() {
+    // Do not lint because iterator is assigned
+    let mut heap = BinaryHeap::from([1, 2]);
+    let iter = heap.drain();
+
+    // Do not lint because iterator is assigned and used
+    let mut heap = BinaryHeap::from([1, 2]);
+    let mut iter = heap.drain();
+    let next = iter.next();
+
+    // Do not lint because iterator is used
+    let mut heap = BinaryHeap::from([1, 2]);
+    let next = heap.drain().next();
+
+    // Do lint
+    let mut heap = BinaryHeap::from([1, 2]);
+    heap.clear();
+}
+
+fn main() {}
diff --git a/tests/ui/clear_with_drain.rs b/tests/ui/clear_with_drain.rs
index af2fe503d9a..4d60ee46e18 100644
--- a/tests/ui/clear_with_drain.rs
+++ b/tests/ui/clear_with_drain.rs
@@ -2,108 +2,357 @@
 #![allow(unused)]
 #![warn(clippy::clear_with_drain)]
 
-use std::collections::BinaryHeap;
-use std::collections::HashMap;
-use std::collections::HashSet;
-use std::collections::VecDeque;
+use std::collections::{BinaryHeap, HashMap, HashSet, VecDeque};
 
-fn range() {
+fn vec_range() {
+    // Do not lint because iterator is assigned
     let mut v = vec![1, 2, 3];
-    let iter = v.drain(0..v.len()); // Yay
+    let iter = v.drain(0..v.len());
 
+    // Do not lint because iterator is used
     let mut v = vec![1, 2, 3];
-    let n = v.drain(0..v.len()).count(); // Yay
+    let n = v.drain(0..v.len()).count();
 
+    // Do not lint because iterator is assigned and used
     let mut v = vec![1, 2, 3];
-    let iter = v.drain(usize::MIN..v.len()); // Yay
+    let iter = v.drain(usize::MIN..v.len());
     let n = iter.count();
 
+    // Do lint
     let mut v = vec![1, 2, 3];
-    v.drain(0..v.len()); // Nay
+    v.drain(0..v.len());
 
+    // Do lint
     let mut v = vec![1, 2, 3];
-    v.drain(usize::MIN..v.len()); // Nay
+    v.drain(usize::MIN..v.len());
 }
 
-fn range_from() {
+fn vec_range_from() {
+    // Do not lint because iterator is assigned
     let mut v = vec![1, 2, 3];
-    let iter = v.drain(0..); // Yay
+    let iter = v.drain(0..);
 
+    // Do not lint because iterator is assigned and used
     let mut v = vec![1, 2, 3];
-    let mut iter = v.drain(0..); // Yay
+    let mut iter = v.drain(0..);
     let next = iter.next();
 
+    // Do not lint because iterator is used
     let mut v = vec![1, 2, 3];
-    let next = v.drain(usize::MIN..).next(); // Yay
+    let next = v.drain(usize::MIN..).next();
 
+    // Do lint
     let mut v = vec![1, 2, 3];
-    v.drain(0..); // Nay
+    v.drain(0..);
 
+    // Do lint
     let mut v = vec![1, 2, 3];
-    v.drain(usize::MIN..); // Nay
+    v.drain(usize::MIN..);
 }
 
-fn range_full() {
+fn vec_range_full() {
+    // Do not lint because iterator is assigned
     let mut v = vec![1, 2, 3];
-    let iter = v.drain(..); // Yay
+    let iter = v.drain(..);
 
+    // Do not lint because iterator is used
     let mut v = vec![1, 2, 3];
-    // Yay
     for x in v.drain(..) {
         let y = format!("x = {x}");
     }
 
+    // Do lint
     let mut v = vec![1, 2, 3];
-    v.drain(..); // Nay
+    v.drain(..);
 }
 
-fn range_to() {
+fn vec_range_to() {
+    // Do not lint because iterator is assigned
     let mut v = vec![1, 2, 3];
-    let iter = v.drain(..v.len()); // Yay
+    let iter = v.drain(..v.len());
 
+    // Do not lint because iterator is assigned and used
     let mut v = vec![1, 2, 3];
-    let iter = v.drain(..v.len()); // Yay
+    let iter = v.drain(..v.len());
     for x in iter {
         let y = format!("x = {x}");
     }
 
+    // Do lint
     let mut v = vec![1, 2, 3];
-    v.drain(..v.len()); // Nay
+    v.drain(..v.len());
 }
 
-fn partial_drains() {
+fn vec_partial_drains() {
+    // Do not lint any of these because the ranges are not full
+
     let mut v = vec![1, 2, 3];
-    v.drain(1..); // Yay
+    v.drain(1..);
     let mut v = vec![1, 2, 3];
-    v.drain(1..).max(); // Yay
+    v.drain(1..).max();
 
     let mut v = vec![1, 2, 3];
-    v.drain(..v.len() - 1); // Yay
+    v.drain(..v.len() - 1);
     let mut v = vec![1, 2, 3];
-    v.drain(..v.len() - 1).min(); // Yay
+    v.drain(..v.len() - 1).min();
 
     let mut v = vec![1, 2, 3];
-    v.drain(1..v.len() - 1); // Yay
+    v.drain(1..v.len() - 1);
     let mut v = vec![1, 2, 3];
-    let w: Vec<i8> = v.drain(1..v.len() - 1).collect(); // Yay
+    let w: Vec<i8> = v.drain(1..v.len() - 1).collect();
+}
+
+fn vec_deque_range() {
+    // Do not lint because iterator is assigned
+    let mut deque = VecDeque::from([1, 2, 3]);
+    let iter = deque.drain(0..deque.len());
+
+    // Do not lint because iterator is used
+    let mut deque = VecDeque::from([1, 2, 3]);
+    let n = deque.drain(0..deque.len()).count();
+
+    // Do not lint because iterator is assigned and used
+    let mut deque = VecDeque::from([1, 2, 3]);
+    let iter = deque.drain(usize::MIN..deque.len());
+    let n = iter.count();
+
+    // Do lint
+    let mut deque = VecDeque::from([1, 2, 3]);
+    deque.drain(0..deque.len());
+
+    // Do lint
+    let mut deque = VecDeque::from([1, 2, 3]);
+    deque.drain(usize::MIN..deque.len());
+}
+
+fn vec_deque_range_from() {
+    // Do not lint because iterator is assigned
+    let mut deque = VecDeque::from([1, 2, 3]);
+    let iter = deque.drain(0..);
+
+    // Do not lint because iterator is assigned and used
+    let mut deque = VecDeque::from([1, 2, 3]);
+    let mut iter = deque.drain(0..);
+    let next = iter.next();
+
+    // Do not lint because iterator is used
+    let mut deque = VecDeque::from([1, 2, 3]);
+    let next = deque.drain(usize::MIN..).next();
+
+    // Do lint
+    let mut deque = VecDeque::from([1, 2, 3]);
+    deque.drain(0..);
+
+    // Do lint
+    let mut deque = VecDeque::from([1, 2, 3]);
+    deque.drain(usize::MIN..);
 }
 
-fn main() {
-    let mut deque: VecDeque<_> = [1, 2, 3].into();
+fn vec_deque_range_full() {
+    // Do not lint because iterator is assigned
+    let mut deque = VecDeque::from([1, 2, 3]);
+    let iter = deque.drain(..);
+
+    // Do not lint because iterator is used
+    let mut deque = VecDeque::from([1, 2, 3]);
+    for x in deque.drain(..) {
+        let y = format!("x = {x}");
+    }
+
+    // Do lint
+    let mut deque = VecDeque::from([1, 2, 3]);
     deque.drain(..);
+}
+
+fn vec_deque_range_to() {
+    // Do not lint because iterator is assigned
+    let mut deque = VecDeque::from([1, 2, 3]);
+    let iter = deque.drain(..deque.len());
+
+    // Do not lint because iterator is assigned and used
+    let mut deque = VecDeque::from([1, 2, 3]);
+    let iter = deque.drain(..deque.len());
+    for x in iter {
+        let y = format!("x = {x}");
+    }
+
+    // Do lint
+    let mut deque = VecDeque::from([1, 2, 3]);
+    deque.drain(..deque.len());
+}
+
+fn vec_deque_partial_drains() {
+    // Do not lint any of these because the ranges are not full
+
+    let mut deque = VecDeque::from([1, 2, 3]);
+    deque.drain(1..);
+    let mut deque = VecDeque::from([1, 2, 3]);
+    deque.drain(1..).max();
+
+    let mut deque = VecDeque::from([1, 2, 3]);
+    deque.drain(..deque.len() - 1);
+    let mut deque = VecDeque::from([1, 2, 3]);
+    deque.drain(..deque.len() - 1).min();
+
+    let mut deque = VecDeque::from([1, 2, 3]);
+    deque.drain(1..deque.len() - 1);
+    let mut deque = VecDeque::from([1, 2, 3]);
+    let w: Vec<i8> = deque.drain(1..deque.len() - 1).collect();
+}
+
+fn string_range() {
+    // Do not lint because iterator is assigned
+    let mut s = String::from("Hello, world!");
+    let iter = s.drain(0..s.len());
+
+    // Do not lint because iterator is used
+    let mut s = String::from("Hello, world!");
+    let n = s.drain(0..s.len()).count();
+
+    // Do not lint because iterator is assigned and used
+    let mut s = String::from("Hello, world!");
+    let iter = s.drain(usize::MIN..s.len());
+    let n = iter.count();
+
+    // Do lint
+    let mut s = String::from("Hello, world!");
+    s.drain(0..s.len());
+
+    // Do lint
+    let mut s = String::from("Hello, world!");
+    s.drain(usize::MIN..s.len());
+}
+
+fn string_range_from() {
+    // Do not lint because iterator is assigned
+    let mut s = String::from("Hello, world!");
+    let iter = s.drain(0..);
+
+    // Do not lint because iterator is assigned and used
+    let mut s = String::from("Hello, world!");
+    let mut iter = s.drain(0..);
+    let next = iter.next();
+
+    // Do not lint because iterator is used
+    let mut s = String::from("Hello, world!");
+    let next = s.drain(usize::MIN..).next();
 
+    // Do lint
+    let mut s = String::from("Hello, world!");
+    s.drain(0..);
+
+    // Do lint
+    let mut s = String::from("Hello, world!");
+    s.drain(usize::MIN..);
+}
+
+fn string_range_full() {
+    // Do not lint because iterator is assigned
+    let mut s = String::from("Hello, world!");
+    let iter = s.drain(..);
+
+    // Do not lint because iterator is used
+    let mut s = String::from("Hello, world!");
+    for x in s.drain(..) {
+        let y = format!("x = {x}");
+    }
+
+    // Do lint
+    let mut s = String::from("Hello, world!");
+    s.drain(..);
+}
+
+fn string_range_to() {
+    // Do not lint because iterator is assigned
+    let mut s = String::from("Hello, world!");
+    let iter = s.drain(..s.len());
+
+    // Do not lint because iterator is assigned and used
+    let mut s = String::from("Hello, world!");
+    let iter = s.drain(..s.len());
+    for x in iter {
+        let y = format!("x = {x}");
+    }
+
+    // Do lint
+    let mut s = String::from("Hello, world!");
+    s.drain(..s.len());
+}
+
+fn string_partial_drains() {
+    // Do not lint any of these because the ranges are not full
+
+    let mut s = String::from("Hello, world!");
+    s.drain(1..);
+    let mut s = String::from("Hello, world!");
+    s.drain(1..).max();
+
+    let mut s = String::from("Hello, world!");
+    s.drain(..s.len() - 1);
+    let mut s = String::from("Hello, world!");
+    s.drain(..s.len() - 1).min();
+
+    let mut s = String::from("Hello, world!");
+    s.drain(1..s.len() - 1);
+    let mut s = String::from("Hello, world!");
+    let w: String = s.drain(1..s.len() - 1).collect();
+}
+
+fn hash_set() {
+    // Do not lint because iterator is assigned
+    let mut set = HashSet::from([1, 2, 3]);
+    let iter = set.drain();
+
+    // Do not lint because iterator is assigned and used
+    let mut set = HashSet::from([1, 2, 3]);
+    let mut iter = set.drain();
+    let next = iter.next();
+
+    // Do not lint because iterator is used
+    let mut set = HashSet::from([1, 2, 3]);
+    let next = set.drain().next();
+
+    // Do lint
     let mut set = HashSet::from([1, 2, 3]);
     set.drain();
+}
 
-    let mut a = HashMap::new();
-    a.insert(1, "a");
-    a.insert(2, "b");
-    a.drain();
+fn hash_map() {
+    // Do not lint because iterator is assigned
+    let mut map = HashMap::from([(1, "a"), (2, "b")]);
+    let iter = map.drain();
 
-    let mut heap = BinaryHeap::from([1, 3]);
-    heap.drain();
+    // Do not lint because iterator is assigned and used
+    let mut map = HashMap::from([(1, "a"), (2, "b")]);
+    let mut iter = map.drain();
+    let next = iter.next();
 
-    // Not firing for now because `String` is not reckognized by `is_type_diagnostic_item`
-    let mut s = String::from("α is alpha, β is beta");
-    s.drain(..);
+    // Do not lint because iterator is used
+    let mut map = HashMap::from([(1, "a"), (2, "b")]);
+    let next = map.drain().next();
+
+    // Do lint
+    let mut map = HashMap::from([(1, "a"), (2, "b")]);
+    map.drain();
+}
+
+fn binary_heap() {
+    // Do not lint because iterator is assigned
+    let mut heap = BinaryHeap::from([1, 2]);
+    let iter = heap.drain();
+
+    // Do not lint because iterator is assigned and used
+    let mut heap = BinaryHeap::from([1, 2]);
+    let mut iter = heap.drain();
+    let next = iter.next();
+
+    // Do not lint because iterator is used
+    let mut heap = BinaryHeap::from([1, 2]);
+    let next = heap.drain().next();
+
+    // Do lint
+    let mut heap = BinaryHeap::from([1, 2]);
+    heap.drain();
 }
+
+fn main() {}
diff --git a/tests/ui/clear_with_drain.stderr b/tests/ui/clear_with_drain.stderr
index 2c0cc846de2..20158da1121 100644
--- a/tests/ui/clear_with_drain.stderr
+++ b/tests/ui/clear_with_drain.stderr
@@ -1,64 +1,130 @@
 error: `drain` used to clear a `Vec`
-  --> $DIR/clear_with_drain.rs:22:7
+  --> $DIR/clear_with_drain.rs:23:7
    |
-LL |     v.drain(0..v.len()); // Nay
+LL |     v.drain(0..v.len());
    |       ^^^^^^^^^^^^^^^^^ help: try: `clear()`
    |
    = note: `-D clippy::clear-with-drain` implied by `-D warnings`
 
 error: `drain` used to clear a `Vec`
-  --> $DIR/clear_with_drain.rs:25:7
+  --> $DIR/clear_with_drain.rs:27:7
    |
-LL |     v.drain(usize::MIN..v.len()); // Nay
+LL |     v.drain(usize::MIN..v.len());
    |       ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `clear()`
 
 error: `drain` used to clear a `Vec`
-  --> $DIR/clear_with_drain.rs:40:7
+  --> $DIR/clear_with_drain.rs:46:7
    |
-LL |     v.drain(0..); // Nay
+LL |     v.drain(0..);
    |       ^^^^^^^^^^ help: try: `clear()`
 
 error: `drain` used to clear a `Vec`
-  --> $DIR/clear_with_drain.rs:43:7
+  --> $DIR/clear_with_drain.rs:50:7
    |
-LL |     v.drain(usize::MIN..); // Nay
+LL |     v.drain(usize::MIN..);
    |       ^^^^^^^^^^^^^^^^^^^ help: try: `clear()`
 
 error: `drain` used to clear a `Vec`
-  --> $DIR/clear_with_drain.rs:57:7
+  --> $DIR/clear_with_drain.rs:66:7
    |
-LL |     v.drain(..); // Nay
+LL |     v.drain(..);
    |       ^^^^^^^^^ help: try: `clear()`
 
 error: `drain` used to clear a `Vec`
-  --> $DIR/clear_with_drain.rs:71:7
+  --> $DIR/clear_with_drain.rs:83:7
    |
-LL |     v.drain(..v.len()); // Nay
+LL |     v.drain(..v.len());
    |       ^^^^^^^^^^^^^^^^ help: try: `clear()`
 
 error: `drain` used to clear a `VecDeque`
-  --> $DIR/clear_with_drain.rs:93:11
+  --> $DIR/clear_with_drain.rs:121:11
+   |
+LL |     deque.drain(0..deque.len());
+   |           ^^^^^^^^^^^^^^^^^^^^^ help: try: `clear()`
+
+error: `drain` used to clear a `VecDeque`
+  --> $DIR/clear_with_drain.rs:125:11
+   |
+LL |     deque.drain(usize::MIN..deque.len());
+   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `clear()`
+
+error: `drain` used to clear a `VecDeque`
+  --> $DIR/clear_with_drain.rs:144:11
+   |
+LL |     deque.drain(0..);
+   |           ^^^^^^^^^^ help: try: `clear()`
+
+error: `drain` used to clear a `VecDeque`
+  --> $DIR/clear_with_drain.rs:148:11
+   |
+LL |     deque.drain(usize::MIN..);
+   |           ^^^^^^^^^^^^^^^^^^^ help: try: `clear()`
+
+error: `drain` used to clear a `VecDeque`
+  --> $DIR/clear_with_drain.rs:164:11
    |
 LL |     deque.drain(..);
    |           ^^^^^^^^^ help: try: `clear()`
 
+error: `drain` used to clear a `VecDeque`
+  --> $DIR/clear_with_drain.rs:181:11
+   |
+LL |     deque.drain(..deque.len());
+   |           ^^^^^^^^^^^^^^^^^^^^ help: try: `clear()`
+
+error: `drain` used to clear a `String`
+  --> $DIR/clear_with_drain.rs:219:7
+   |
+LL |     s.drain(0..s.len());
+   |       ^^^^^^^^^^^^^^^^^ help: try: `clear()`
+
+error: `drain` used to clear a `String`
+  --> $DIR/clear_with_drain.rs:223:7
+   |
+LL |     s.drain(usize::MIN..s.len());
+   |       ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `clear()`
+
+error: `drain` used to clear a `String`
+  --> $DIR/clear_with_drain.rs:242:7
+   |
+LL |     s.drain(0..);
+   |       ^^^^^^^^^^ help: try: `clear()`
+
+error: `drain` used to clear a `String`
+  --> $DIR/clear_with_drain.rs:246:7
+   |
+LL |     s.drain(usize::MIN..);
+   |       ^^^^^^^^^^^^^^^^^^^ help: try: `clear()`
+
+error: `drain` used to clear a `String`
+  --> $DIR/clear_with_drain.rs:262:7
+   |
+LL |     s.drain(..);
+   |       ^^^^^^^^^ help: try: `clear()`
+
+error: `drain` used to clear a `String`
+  --> $DIR/clear_with_drain.rs:279:7
+   |
+LL |     s.drain(..s.len());
+   |       ^^^^^^^^^^^^^^^^ help: try: `clear()`
+
 error: `drain` used to clear a `HashSet`
-  --> $DIR/clear_with_drain.rs:96:9
+  --> $DIR/clear_with_drain.rs:317:9
    |
 LL |     set.drain();
    |         ^^^^^^^ help: try: `clear()`
 
 error: `drain` used to clear a `HashMap`
-  --> $DIR/clear_with_drain.rs:101:7
+  --> $DIR/clear_with_drain.rs:336:9
    |
-LL |     a.drain();
-   |       ^^^^^^^ help: try: `clear()`
+LL |     map.drain();
+   |         ^^^^^^^ help: try: `clear()`
 
 error: `drain` used to clear a `BinaryHeap`
-  --> $DIR/clear_with_drain.rs:104:10
+  --> $DIR/clear_with_drain.rs:355:10
    |
 LL |     heap.drain();
    |          ^^^^^^^ help: try: `clear()`
 
-error: aborting due to 10 previous errors
+error: aborting due to 21 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From cd0009eb3085c975ecaff6f40af7d1e99714feda Mon Sep 17 00:00:00 2001
From: Caio <c410.f3r@gmail.com>
Date: Sun, 9 Apr 2023 08:16:20 -0300
Subject: Suppress the triggering of some lints in derived structures

---
 .../src/operators/arithmetic_side_effects.rs       |   4 +-
 clippy_lints/src/operators/numeric_arithmetic.rs   |  14 +-
 tests/ui/arithmetic_side_effects.rs                |   7 +
 tests/ui/arithmetic_side_effects.stderr            | 218 ++++++++++-----------
 tests/ui/auxiliary/proc_macro_derive.rs            |  73 ++++++-
 tests/ui/integer_arithmetic.rs                     |   7 +
 tests/ui/integer_arithmetic.stderr                 |  54 ++---
 tests/ui/shadow.rs                                 |   7 +
 tests/ui/shadow.stderr                             |  92 ++++-----
 9 files changed, 290 insertions(+), 186 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/operators/arithmetic_side_effects.rs b/clippy_lints/src/operators/arithmetic_side_effects.rs
index e5713735672..6c050c2cb8b 100644
--- a/clippy_lints/src/operators/arithmetic_side_effects.rs
+++ b/clippy_lints/src/operators/arithmetic_side_effects.rs
@@ -1,4 +1,5 @@
 use super::ARITHMETIC_SIDE_EFFECTS;
+use clippy_utils::is_from_proc_macro;
 use clippy_utils::{
     consts::{constant, constant_simple, Constant},
     diagnostics::span_lint,
@@ -206,8 +207,9 @@ impl ArithmeticSideEffects {
         self.issue_lint(cx, expr);
     }
 
-    fn should_skip_expr(&mut self, cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> bool {
+    fn should_skip_expr<'tcx>(&mut self, cx: &LateContext<'tcx>, expr: &hir::Expr<'tcx>) -> bool {
         is_lint_allowed(cx, ARITHMETIC_SIDE_EFFECTS, expr.hir_id)
+            || is_from_proc_macro(cx, expr)
             || self.expr_span.is_some()
             || self.const_span.map_or(false, |sp| sp.contains(expr.span))
     }
diff --git a/clippy_lints/src/operators/numeric_arithmetic.rs b/clippy_lints/src/operators/numeric_arithmetic.rs
index 777395f452c..ea9696691f9 100644
--- a/clippy_lints/src/operators/numeric_arithmetic.rs
+++ b/clippy_lints/src/operators/numeric_arithmetic.rs
@@ -1,12 +1,12 @@
+use super::{FLOAT_ARITHMETIC, INTEGER_ARITHMETIC};
 use clippy_utils::consts::constant_simple;
 use clippy_utils::diagnostics::span_lint;
+use clippy_utils::is_from_proc_macro;
 use clippy_utils::is_integer_literal;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
 use rustc_span::source_map::Span;
 
-use super::{FLOAT_ARITHMETIC, INTEGER_ARITHMETIC};
-
 #[derive(Default)]
 pub struct Context {
     expr_id: Option<hir::HirId>,
@@ -19,6 +19,10 @@ impl Context {
         self.expr_id.is_some() || self.const_span.map_or(false, |span| span.contains(e.span))
     }
 
+    fn skip_expr_involving_integers<'tcx>(cx: &LateContext<'tcx>, e: &hir::Expr<'tcx>) -> bool {
+        is_from_proc_macro(cx, e)
+    }
+
     pub fn check_binary<'tcx>(
         &mut self,
         cx: &LateContext<'tcx>,
@@ -47,6 +51,9 @@ impl Context {
 
         let (l_ty, r_ty) = (cx.typeck_results().expr_ty(l), cx.typeck_results().expr_ty(r));
         if l_ty.peel_refs().is_integral() && r_ty.peel_refs().is_integral() {
+            if Self::skip_expr_involving_integers(cx, expr) {
+                return;
+            }
             match op {
                 hir::BinOpKind::Div | hir::BinOpKind::Rem => match &r.kind {
                     hir::ExprKind::Lit(_lit) => (),
@@ -79,6 +86,9 @@ impl Context {
         let ty = cx.typeck_results().expr_ty(arg);
         if constant_simple(cx, cx.typeck_results(), expr).is_none() {
             if ty.is_integral() {
+                if Self::skip_expr_involving_integers(cx, expr) {
+                    return;
+                }
                 span_lint(cx, INTEGER_ARITHMETIC, expr.span, "integer arithmetic detected");
                 self.expr_id = Some(expr.hir_id);
             } else if ty.is_floating_point() {
diff --git a/tests/ui/arithmetic_side_effects.rs b/tests/ui/arithmetic_side_effects.rs
index 3c06676d722..ab7e66a264d 100644
--- a/tests/ui/arithmetic_side_effects.rs
+++ b/tests/ui/arithmetic_side_effects.rs
@@ -1,3 +1,5 @@
+// aux-build:proc_macro_derive.rs
+
 #![allow(
     clippy::assign_op_pattern,
     clippy::erasing_op,
@@ -11,6 +13,8 @@
 #![feature(const_mut_refs, inline_const, saturating_int_impl)]
 #![warn(clippy::arithmetic_side_effects)]
 
+extern crate proc_macro_derive;
+
 use core::num::{Saturating, Wrapping};
 
 const ONE: i32 = 1;
@@ -19,6 +23,9 @@ const ZERO: i32 = 0;
 #[derive(Clone, Copy)]
 pub struct Custom;
 
+#[derive(proc_macro_derive::ShadowDerive)]
+pub struct Nothing;
+
 macro_rules! impl_arith {
     ( $( $_trait:ident, $lhs:ty, $rhs:ty, $method:ident; )* ) => {
         $(
diff --git a/tests/ui/arithmetic_side_effects.stderr b/tests/ui/arithmetic_side_effects.stderr
index 2c8ee2884e7..a036cadb9a0 100644
--- a/tests/ui/arithmetic_side_effects.stderr
+++ b/tests/ui/arithmetic_side_effects.stderr
@@ -1,5 +1,5 @@
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:286:5
+  --> $DIR/arithmetic_side_effects.rs:293:5
    |
 LL |     _n += 1;
    |     ^^^^^^^
@@ -7,649 +7,649 @@ LL |     _n += 1;
    = note: `-D clippy::arithmetic-side-effects` implied by `-D warnings`
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:287:5
+  --> $DIR/arithmetic_side_effects.rs:294:5
    |
 LL |     _n += &1;
    |     ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:288:5
+  --> $DIR/arithmetic_side_effects.rs:295:5
    |
 LL |     _n -= 1;
    |     ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:289:5
+  --> $DIR/arithmetic_side_effects.rs:296:5
    |
 LL |     _n -= &1;
    |     ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:290:5
+  --> $DIR/arithmetic_side_effects.rs:297:5
    |
 LL |     _n /= 0;
    |     ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:291:5
+  --> $DIR/arithmetic_side_effects.rs:298:5
    |
 LL |     _n /= &0;
    |     ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:292:5
+  --> $DIR/arithmetic_side_effects.rs:299:5
    |
 LL |     _n %= 0;
    |     ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:293:5
+  --> $DIR/arithmetic_side_effects.rs:300:5
    |
 LL |     _n %= &0;
    |     ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:294:5
+  --> $DIR/arithmetic_side_effects.rs:301:5
    |
 LL |     _n *= 2;
    |     ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:295:5
+  --> $DIR/arithmetic_side_effects.rs:302:5
    |
 LL |     _n *= &2;
    |     ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:296:5
+  --> $DIR/arithmetic_side_effects.rs:303:5
    |
 LL |     _n += -1;
    |     ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:297:5
+  --> $DIR/arithmetic_side_effects.rs:304:5
    |
 LL |     _n += &-1;
    |     ^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:298:5
+  --> $DIR/arithmetic_side_effects.rs:305:5
    |
 LL |     _n -= -1;
    |     ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:299:5
+  --> $DIR/arithmetic_side_effects.rs:306:5
    |
 LL |     _n -= &-1;
    |     ^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:300:5
+  --> $DIR/arithmetic_side_effects.rs:307:5
    |
 LL |     _n /= -0;
    |     ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:301:5
+  --> $DIR/arithmetic_side_effects.rs:308:5
    |
 LL |     _n /= &-0;
    |     ^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:302:5
+  --> $DIR/arithmetic_side_effects.rs:309:5
    |
 LL |     _n %= -0;
    |     ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:303:5
+  --> $DIR/arithmetic_side_effects.rs:310:5
    |
 LL |     _n %= &-0;
    |     ^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:304:5
+  --> $DIR/arithmetic_side_effects.rs:311:5
    |
 LL |     _n *= -2;
    |     ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:305:5
+  --> $DIR/arithmetic_side_effects.rs:312:5
    |
 LL |     _n *= &-2;
    |     ^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:306:5
+  --> $DIR/arithmetic_side_effects.rs:313:5
    |
 LL |     _custom += Custom;
    |     ^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:307:5
+  --> $DIR/arithmetic_side_effects.rs:314:5
    |
 LL |     _custom += &Custom;
    |     ^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:308:5
+  --> $DIR/arithmetic_side_effects.rs:315:5
    |
 LL |     _custom -= Custom;
    |     ^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:309:5
+  --> $DIR/arithmetic_side_effects.rs:316:5
    |
 LL |     _custom -= &Custom;
    |     ^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:310:5
+  --> $DIR/arithmetic_side_effects.rs:317:5
    |
 LL |     _custom /= Custom;
    |     ^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:311:5
+  --> $DIR/arithmetic_side_effects.rs:318:5
    |
 LL |     _custom /= &Custom;
    |     ^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:312:5
+  --> $DIR/arithmetic_side_effects.rs:319:5
    |
 LL |     _custom %= Custom;
    |     ^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:313:5
+  --> $DIR/arithmetic_side_effects.rs:320:5
    |
 LL |     _custom %= &Custom;
    |     ^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:314:5
+  --> $DIR/arithmetic_side_effects.rs:321:5
    |
 LL |     _custom *= Custom;
    |     ^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:315:5
+  --> $DIR/arithmetic_side_effects.rs:322:5
    |
 LL |     _custom *= &Custom;
    |     ^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:316:5
+  --> $DIR/arithmetic_side_effects.rs:323:5
    |
 LL |     _custom >>= Custom;
    |     ^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:317:5
+  --> $DIR/arithmetic_side_effects.rs:324:5
    |
 LL |     _custom >>= &Custom;
    |     ^^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:318:5
+  --> $DIR/arithmetic_side_effects.rs:325:5
    |
 LL |     _custom <<= Custom;
    |     ^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:319:5
+  --> $DIR/arithmetic_side_effects.rs:326:5
    |
 LL |     _custom <<= &Custom;
    |     ^^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:320:5
+  --> $DIR/arithmetic_side_effects.rs:327:5
    |
 LL |     _custom += -Custom;
    |     ^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:321:5
+  --> $DIR/arithmetic_side_effects.rs:328:5
    |
 LL |     _custom += &-Custom;
    |     ^^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:322:5
+  --> $DIR/arithmetic_side_effects.rs:329:5
    |
 LL |     _custom -= -Custom;
    |     ^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:323:5
+  --> $DIR/arithmetic_side_effects.rs:330:5
    |
 LL |     _custom -= &-Custom;
    |     ^^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:324:5
+  --> $DIR/arithmetic_side_effects.rs:331:5
    |
 LL |     _custom /= -Custom;
    |     ^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:325:5
+  --> $DIR/arithmetic_side_effects.rs:332:5
    |
 LL |     _custom /= &-Custom;
    |     ^^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:326:5
+  --> $DIR/arithmetic_side_effects.rs:333:5
    |
 LL |     _custom %= -Custom;
    |     ^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:327:5
+  --> $DIR/arithmetic_side_effects.rs:334:5
    |
 LL |     _custom %= &-Custom;
    |     ^^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:328:5
+  --> $DIR/arithmetic_side_effects.rs:335:5
    |
 LL |     _custom *= -Custom;
    |     ^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:329:5
+  --> $DIR/arithmetic_side_effects.rs:336:5
    |
 LL |     _custom *= &-Custom;
    |     ^^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:330:5
+  --> $DIR/arithmetic_side_effects.rs:337:5
    |
 LL |     _custom >>= -Custom;
    |     ^^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:331:5
+  --> $DIR/arithmetic_side_effects.rs:338:5
    |
 LL |     _custom >>= &-Custom;
    |     ^^^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:332:5
+  --> $DIR/arithmetic_side_effects.rs:339:5
    |
 LL |     _custom <<= -Custom;
    |     ^^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:333:5
+  --> $DIR/arithmetic_side_effects.rs:340:5
    |
 LL |     _custom <<= &-Custom;
    |     ^^^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:336:10
+  --> $DIR/arithmetic_side_effects.rs:343:10
    |
 LL |     _n = _n + 1;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:337:10
+  --> $DIR/arithmetic_side_effects.rs:344:10
    |
 LL |     _n = _n + &1;
    |          ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:338:10
+  --> $DIR/arithmetic_side_effects.rs:345:10
    |
 LL |     _n = 1 + _n;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:339:10
+  --> $DIR/arithmetic_side_effects.rs:346:10
    |
 LL |     _n = &1 + _n;
    |          ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:340:10
+  --> $DIR/arithmetic_side_effects.rs:347:10
    |
 LL |     _n = _n - 1;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:341:10
+  --> $DIR/arithmetic_side_effects.rs:348:10
    |
 LL |     _n = _n - &1;
    |          ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:342:10
+  --> $DIR/arithmetic_side_effects.rs:349:10
    |
 LL |     _n = 1 - _n;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:343:10
+  --> $DIR/arithmetic_side_effects.rs:350:10
    |
 LL |     _n = &1 - _n;
    |          ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:344:10
+  --> $DIR/arithmetic_side_effects.rs:351:10
    |
 LL |     _n = _n / 0;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:345:10
+  --> $DIR/arithmetic_side_effects.rs:352:10
    |
 LL |     _n = _n / &0;
    |          ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:346:10
+  --> $DIR/arithmetic_side_effects.rs:353:10
    |
 LL |     _n = _n % 0;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:347:10
+  --> $DIR/arithmetic_side_effects.rs:354:10
    |
 LL |     _n = _n % &0;
    |          ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:348:10
+  --> $DIR/arithmetic_side_effects.rs:355:10
    |
 LL |     _n = _n * 2;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:349:10
+  --> $DIR/arithmetic_side_effects.rs:356:10
    |
 LL |     _n = _n * &2;
    |          ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:350:10
+  --> $DIR/arithmetic_side_effects.rs:357:10
    |
 LL |     _n = 2 * _n;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:351:10
+  --> $DIR/arithmetic_side_effects.rs:358:10
    |
 LL |     _n = &2 * _n;
    |          ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:352:10
+  --> $DIR/arithmetic_side_effects.rs:359:10
    |
 LL |     _n = 23 + &85;
    |          ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:353:10
+  --> $DIR/arithmetic_side_effects.rs:360:10
    |
 LL |     _n = &23 + 85;
    |          ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:354:10
+  --> $DIR/arithmetic_side_effects.rs:361:10
    |
 LL |     _n = &23 + &85;
    |          ^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:355:15
+  --> $DIR/arithmetic_side_effects.rs:362:15
    |
 LL |     _custom = _custom + _custom;
    |               ^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:356:15
+  --> $DIR/arithmetic_side_effects.rs:363:15
    |
 LL |     _custom = _custom + &_custom;
    |               ^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:357:15
+  --> $DIR/arithmetic_side_effects.rs:364:15
    |
 LL |     _custom = Custom + _custom;
    |               ^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:358:15
+  --> $DIR/arithmetic_side_effects.rs:365:15
    |
 LL |     _custom = &Custom + _custom;
    |               ^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:359:15
+  --> $DIR/arithmetic_side_effects.rs:366:15
    |
 LL |     _custom = _custom - Custom;
    |               ^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:360:15
+  --> $DIR/arithmetic_side_effects.rs:367:15
    |
 LL |     _custom = _custom - &Custom;
    |               ^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:361:15
+  --> $DIR/arithmetic_side_effects.rs:368:15
    |
 LL |     _custom = Custom - _custom;
    |               ^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:362:15
+  --> $DIR/arithmetic_side_effects.rs:369:15
    |
 LL |     _custom = &Custom - _custom;
    |               ^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:363:15
+  --> $DIR/arithmetic_side_effects.rs:370:15
    |
 LL |     _custom = _custom / Custom;
    |               ^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:364:15
+  --> $DIR/arithmetic_side_effects.rs:371:15
    |
 LL |     _custom = _custom / &Custom;
    |               ^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:365:15
+  --> $DIR/arithmetic_side_effects.rs:372:15
    |
 LL |     _custom = _custom % Custom;
    |               ^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:366:15
+  --> $DIR/arithmetic_side_effects.rs:373:15
    |
 LL |     _custom = _custom % &Custom;
    |               ^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:367:15
+  --> $DIR/arithmetic_side_effects.rs:374:15
    |
 LL |     _custom = _custom * Custom;
    |               ^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:368:15
+  --> $DIR/arithmetic_side_effects.rs:375:15
    |
 LL |     _custom = _custom * &Custom;
    |               ^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:369:15
+  --> $DIR/arithmetic_side_effects.rs:376:15
    |
 LL |     _custom = Custom * _custom;
    |               ^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:370:15
+  --> $DIR/arithmetic_side_effects.rs:377:15
    |
 LL |     _custom = &Custom * _custom;
    |               ^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:371:15
+  --> $DIR/arithmetic_side_effects.rs:378:15
    |
 LL |     _custom = Custom + &Custom;
    |               ^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:372:15
+  --> $DIR/arithmetic_side_effects.rs:379:15
    |
 LL |     _custom = &Custom + Custom;
    |               ^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:373:15
+  --> $DIR/arithmetic_side_effects.rs:380:15
    |
 LL |     _custom = &Custom + &Custom;
    |               ^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:374:15
+  --> $DIR/arithmetic_side_effects.rs:381:15
    |
 LL |     _custom = _custom >> _custom;
    |               ^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:375:15
+  --> $DIR/arithmetic_side_effects.rs:382:15
    |
 LL |     _custom = _custom >> &_custom;
    |               ^^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:376:15
+  --> $DIR/arithmetic_side_effects.rs:383:15
    |
 LL |     _custom = Custom << _custom;
    |               ^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:377:15
+  --> $DIR/arithmetic_side_effects.rs:384:15
    |
 LL |     _custom = &Custom << _custom;
    |               ^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:380:10
+  --> $DIR/arithmetic_side_effects.rs:387:10
    |
 LL |     _n = -_n;
    |          ^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:381:10
+  --> $DIR/arithmetic_side_effects.rs:388:10
    |
 LL |     _n = -&_n;
    |          ^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:382:15
+  --> $DIR/arithmetic_side_effects.rs:389:15
    |
 LL |     _custom = -_custom;
    |               ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:383:15
+  --> $DIR/arithmetic_side_effects.rs:390:15
    |
 LL |     _custom = -&_custom;
    |               ^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:392:5
+  --> $DIR/arithmetic_side_effects.rs:399:5
    |
 LL |     1 + i;
    |     ^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:393:5
+  --> $DIR/arithmetic_side_effects.rs:400:5
    |
 LL |     i * 2;
    |     ^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:394:5
+  --> $DIR/arithmetic_side_effects.rs:401:5
    |
 LL |     1 % i / 2;
    |     ^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:395:5
+  --> $DIR/arithmetic_side_effects.rs:402:5
    |
 LL |     i - 2 + 2 - i;
    |     ^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:396:5
+  --> $DIR/arithmetic_side_effects.rs:403:5
    |
 LL |     -i;
    |     ^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:407:5
+  --> $DIR/arithmetic_side_effects.rs:414:5
    |
 LL |     i += 1;
    |     ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:408:5
+  --> $DIR/arithmetic_side_effects.rs:415:5
    |
 LL |     i -= 1;
    |     ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:409:5
+  --> $DIR/arithmetic_side_effects.rs:416:5
    |
 LL |     i *= 2;
    |     ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:411:5
+  --> $DIR/arithmetic_side_effects.rs:418:5
    |
 LL |     i /= 0;
    |     ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:413:5
+  --> $DIR/arithmetic_side_effects.rs:420:5
    |
 LL |     i /= var1;
    |     ^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:414:5
+  --> $DIR/arithmetic_side_effects.rs:421:5
    |
 LL |     i /= var2;
    |     ^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:416:5
+  --> $DIR/arithmetic_side_effects.rs:423:5
    |
 LL |     i %= 0;
    |     ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:418:5
+  --> $DIR/arithmetic_side_effects.rs:425:5
    |
 LL |     i %= var1;
    |     ^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:419:5
+  --> $DIR/arithmetic_side_effects.rs:426:5
    |
 LL |     i %= var2;
    |     ^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:429:5
+  --> $DIR/arithmetic_side_effects.rs:436:5
    |
 LL |     10 / a
    |     ^^^^^^
diff --git a/tests/ui/auxiliary/proc_macro_derive.rs b/tests/ui/auxiliary/proc_macro_derive.rs
index a89a06308d0..13d93f5c275 100644
--- a/tests/ui/auxiliary/proc_macro_derive.rs
+++ b/tests/ui/auxiliary/proc_macro_derive.rs
@@ -9,7 +9,7 @@
 
 extern crate proc_macro;
 
-use proc_macro::{quote, TokenStream};
+use proc_macro::{quote, Delimiter, Group, Ident, Literal, Punct, Spacing, Span, TokenStream, TokenTree};
 
 #[proc_macro_derive(DeriveSomething)]
 pub fn derive(_: TokenStream) -> TokenStream {
@@ -86,3 +86,74 @@ pub fn extra_lifetime(_input: TokenStream) -> TokenStream {
         }
     )
 }
+
+#[allow(unused)]
+#[proc_macro_derive(ArithmeticDerive)]
+pub fn arithmetic_derive(_: TokenStream) -> TokenStream {
+    <TokenStream as FromIterator<TokenTree>>::from_iter(
+        [
+            Ident::new("fn", Span::call_site()).into(),
+            Ident::new("_foo", Span::call_site()).into(),
+            Group::new(Delimiter::Parenthesis, TokenStream::new()).into(),
+            Group::new(
+                Delimiter::Brace,
+                <TokenStream as FromIterator<TokenTree>>::from_iter(
+                    [
+                        Ident::new("let", Span::call_site()).into(),
+                        Ident::new("mut", Span::call_site()).into(),
+                        Ident::new("_n", Span::call_site()).into(),
+                        Punct::new('=', Spacing::Alone).into(),
+                        Literal::i32_unsuffixed(9).into(),
+                        Punct::new(';', Spacing::Alone).into(),
+                        Ident::new("_n", Span::call_site()).into(),
+                        Punct::new('=', Spacing::Alone).into(),
+                        Literal::i32_unsuffixed(9).into(),
+                        Punct::new('/', Spacing::Alone).into(),
+                        Literal::i32_unsuffixed(2).into(),
+                        Punct::new(';', Spacing::Alone).into(),
+                        Ident::new("_n", Span::call_site()).into(),
+                        Punct::new('=', Spacing::Alone).into(),
+                        Punct::new('-', Spacing::Alone).into(),
+                        Ident::new("_n", Span::call_site()).into(),
+                        Punct::new(';', Spacing::Alone).into(),
+                    ]
+                    .into_iter(),
+                ),
+            )
+            .into(),
+        ]
+        .into_iter(),
+    )
+}
+
+#[allow(unused)]
+#[proc_macro_derive(ShadowDerive)]
+pub fn shadow_derive(_: TokenStream) -> TokenStream {
+    <TokenStream as FromIterator<TokenTree>>::from_iter(
+        [
+            Ident::new("fn", Span::call_site()).into(),
+            Ident::new("_foo", Span::call_site()).into(),
+            Group::new(Delimiter::Parenthesis, TokenStream::new()).into(),
+            Group::new(
+                Delimiter::Brace,
+                <TokenStream as FromIterator<TokenTree>>::from_iter(
+                    [
+                        Ident::new("let", Span::call_site()).into(),
+                        Ident::new("_x", Span::call_site()).into(),
+                        Punct::new('=', Spacing::Alone).into(),
+                        Literal::i32_unsuffixed(2).into(),
+                        Punct::new(';', Spacing::Alone).into(),
+                        Ident::new("let", Span::call_site()).into(),
+                        Ident::new("_x", Span::call_site()).into(),
+                        Punct::new('=', Spacing::Alone).into(),
+                        Ident::new("_x", Span::call_site()).into(),
+                        Punct::new(';', Spacing::Alone).into(),
+                    ]
+                    .into_iter(),
+                ),
+            )
+            .into(),
+        ]
+        .into_iter(),
+    )
+}
diff --git a/tests/ui/integer_arithmetic.rs b/tests/ui/integer_arithmetic.rs
index 8dfdee662b9..d253d103127 100644
--- a/tests/ui/integer_arithmetic.rs
+++ b/tests/ui/integer_arithmetic.rs
@@ -1,6 +1,13 @@
+// aux-build:proc_macro_derive.rs
+
 #![warn(clippy::integer_arithmetic, clippy::float_arithmetic)]
 #![allow(clippy::no_effect, clippy::unnecessary_operation, clippy::op_ref)]
 
+extern crate proc_macro_derive;
+
+#[derive(proc_macro_derive::ShadowDerive)]
+pub struct Nothing;
+
 #[rustfmt::skip]
 fn main() {
     let mut i = 1i32;
diff --git a/tests/ui/integer_arithmetic.stderr b/tests/ui/integer_arithmetic.stderr
index 9a795b1f291..add3b6b90fa 100644
--- a/tests/ui/integer_arithmetic.stderr
+++ b/tests/ui/integer_arithmetic.stderr
@@ -1,5 +1,5 @@
 error: this operation will panic at runtime
-  --> $DIR/integer_arithmetic.rs:30:5
+  --> $DIR/integer_arithmetic.rs:37:5
    |
 LL |     i /= 0;
    |     ^^^^^^ attempt to divide `_` by zero
@@ -7,13 +7,13 @@ LL |     i /= 0;
    = note: `#[deny(unconditional_panic)]` on by default
 
 error: this operation will panic at runtime
-  --> $DIR/integer_arithmetic.rs:35:5
+  --> $DIR/integer_arithmetic.rs:42:5
    |
 LL |     i %= 0;
    |     ^^^^^^ attempt to calculate the remainder of `_` with a divisor of zero
 
 error: integer arithmetic detected
-  --> $DIR/integer_arithmetic.rs:9:5
+  --> $DIR/integer_arithmetic.rs:16:5
    |
 LL |     1 + i;
    |     ^^^^^
@@ -21,146 +21,146 @@ LL |     1 + i;
    = note: `-D clippy::integer-arithmetic` implied by `-D warnings`
 
 error: integer arithmetic detected
-  --> $DIR/integer_arithmetic.rs:10:5
+  --> $DIR/integer_arithmetic.rs:17:5
    |
 LL |     i * 2;
    |     ^^^^^
 
 error: integer arithmetic detected
-  --> $DIR/integer_arithmetic.rs:11:5
+  --> $DIR/integer_arithmetic.rs:18:5
    |
 LL | /     1 %
 LL | |     i / 2; // no error, this is part of the expression in the preceding line
    | |_____^
 
 error: integer arithmetic detected
-  --> $DIR/integer_arithmetic.rs:13:5
+  --> $DIR/integer_arithmetic.rs:20:5
    |
 LL |     i - 2 + 2 - i;
    |     ^^^^^^^^^^^^^
 
 error: integer arithmetic detected
-  --> $DIR/integer_arithmetic.rs:14:5
+  --> $DIR/integer_arithmetic.rs:21:5
    |
 LL |     -i;
    |     ^^
 
 error: integer arithmetic detected
-  --> $DIR/integer_arithmetic.rs:15:5
+  --> $DIR/integer_arithmetic.rs:22:5
    |
 LL |     i >> 1;
    |     ^^^^^^
 
 error: integer arithmetic detected
-  --> $DIR/integer_arithmetic.rs:16:5
+  --> $DIR/integer_arithmetic.rs:23:5
    |
 LL |     i << 1;
    |     ^^^^^^
 
 error: integer arithmetic detected
-  --> $DIR/integer_arithmetic.rs:26:5
+  --> $DIR/integer_arithmetic.rs:33:5
    |
 LL |     i += 1;
    |     ^^^^^^
 
 error: integer arithmetic detected
-  --> $DIR/integer_arithmetic.rs:27:5
+  --> $DIR/integer_arithmetic.rs:34:5
    |
 LL |     i -= 1;
    |     ^^^^^^
 
 error: integer arithmetic detected
-  --> $DIR/integer_arithmetic.rs:28:5
+  --> $DIR/integer_arithmetic.rs:35:5
    |
 LL |     i *= 2;
    |     ^^^^^^
 
 error: integer arithmetic detected
-  --> $DIR/integer_arithmetic.rs:31:11
+  --> $DIR/integer_arithmetic.rs:38:11
    |
 LL |     i /= -1;
    |           ^
 
 error: integer arithmetic detected
-  --> $DIR/integer_arithmetic.rs:32:5
+  --> $DIR/integer_arithmetic.rs:39:5
    |
 LL |     i /= var1;
    |     ^^^^^^^^^
 
 error: integer arithmetic detected
-  --> $DIR/integer_arithmetic.rs:33:5
+  --> $DIR/integer_arithmetic.rs:40:5
    |
 LL |     i /= var2;
    |     ^^^^^^^^^
 
 error: integer arithmetic detected
-  --> $DIR/integer_arithmetic.rs:36:11
+  --> $DIR/integer_arithmetic.rs:43:11
    |
 LL |     i %= -1;
    |           ^
 
 error: integer arithmetic detected
-  --> $DIR/integer_arithmetic.rs:37:5
+  --> $DIR/integer_arithmetic.rs:44:5
    |
 LL |     i %= var1;
    |     ^^^^^^^^^
 
 error: integer arithmetic detected
-  --> $DIR/integer_arithmetic.rs:38:5
+  --> $DIR/integer_arithmetic.rs:45:5
    |
 LL |     i %= var2;
    |     ^^^^^^^^^
 
 error: integer arithmetic detected
-  --> $DIR/integer_arithmetic.rs:39:5
+  --> $DIR/integer_arithmetic.rs:46:5
    |
 LL |     i <<= 3;
    |     ^^^^^^^
 
 error: integer arithmetic detected
-  --> $DIR/integer_arithmetic.rs:40:5
+  --> $DIR/integer_arithmetic.rs:47:5
    |
 LL |     i >>= 2;
    |     ^^^^^^^
 
 error: integer arithmetic detected
-  --> $DIR/integer_arithmetic.rs:82:5
+  --> $DIR/integer_arithmetic.rs:89:5
    |
 LL |     3 + &1;
    |     ^^^^^^
 
 error: integer arithmetic detected
-  --> $DIR/integer_arithmetic.rs:83:5
+  --> $DIR/integer_arithmetic.rs:90:5
    |
 LL |     &3 + 1;
    |     ^^^^^^
 
 error: integer arithmetic detected
-  --> $DIR/integer_arithmetic.rs:84:5
+  --> $DIR/integer_arithmetic.rs:91:5
    |
 LL |     &3 + &1;
    |     ^^^^^^^
 
 error: integer arithmetic detected
-  --> $DIR/integer_arithmetic.rs:89:5
+  --> $DIR/integer_arithmetic.rs:96:5
    |
 LL |     a + x
    |     ^^^^^
 
 error: integer arithmetic detected
-  --> $DIR/integer_arithmetic.rs:93:5
+  --> $DIR/integer_arithmetic.rs:100:5
    |
 LL |     x + y
    |     ^^^^^
 
 error: integer arithmetic detected
-  --> $DIR/integer_arithmetic.rs:97:5
+  --> $DIR/integer_arithmetic.rs:104:5
    |
 LL |     x + y
    |     ^^^^^
 
 error: integer arithmetic detected
-  --> $DIR/integer_arithmetic.rs:101:5
+  --> $DIR/integer_arithmetic.rs:108:5
    |
 LL |     (&x + &y)
    |     ^^^^^^^^^
diff --git a/tests/ui/shadow.rs b/tests/ui/shadow.rs
index 1fa9fc749a9..ab7800a2110 100644
--- a/tests/ui/shadow.rs
+++ b/tests/ui/shadow.rs
@@ -1,6 +1,13 @@
+// aux-build:proc_macro_derive.rs
+
 #![warn(clippy::shadow_same, clippy::shadow_reuse, clippy::shadow_unrelated)]
 #![allow(clippy::let_unit_value)]
 
+extern crate proc_macro_derive;
+
+#[derive(proc_macro_derive::ShadowDerive)]
+pub struct Nothing;
+
 fn shadow_same() {
     let x = 1;
     let x = x;
diff --git a/tests/ui/shadow.stderr b/tests/ui/shadow.stderr
index c3d7bc2a536..92bb937d086 100644
--- a/tests/ui/shadow.stderr
+++ b/tests/ui/shadow.stderr
@@ -1,278 +1,278 @@
 error: `x` is shadowed by itself in `x`
-  --> $DIR/shadow.rs:6:9
+  --> $DIR/shadow.rs:13:9
    |
 LL |     let x = x;
    |         ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:5:9
+  --> $DIR/shadow.rs:12:9
    |
 LL |     let x = 1;
    |         ^
    = note: `-D clippy::shadow-same` implied by `-D warnings`
 
 error: `mut x` is shadowed by itself in `&x`
-  --> $DIR/shadow.rs:7:13
+  --> $DIR/shadow.rs:14:13
    |
 LL |     let mut x = &x;
    |             ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:6:9
+  --> $DIR/shadow.rs:13:9
    |
 LL |     let x = x;
    |         ^
 
 error: `x` is shadowed by itself in `&mut x`
-  --> $DIR/shadow.rs:8:9
+  --> $DIR/shadow.rs:15:9
    |
 LL |     let x = &mut x;
    |         ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:7:9
+  --> $DIR/shadow.rs:14:9
    |
 LL |     let mut x = &x;
    |         ^^^^^
 
 error: `x` is shadowed by itself in `*x`
-  --> $DIR/shadow.rs:9:9
+  --> $DIR/shadow.rs:16:9
    |
 LL |     let x = *x;
    |         ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:8:9
+  --> $DIR/shadow.rs:15:9
    |
 LL |     let x = &mut x;
    |         ^
 
 error: `x` is shadowed
-  --> $DIR/shadow.rs:14:9
+  --> $DIR/shadow.rs:21:9
    |
 LL |     let x = x.0;
    |         ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:13:9
+  --> $DIR/shadow.rs:20:9
    |
 LL |     let x = ([[0]], ());
    |         ^
    = note: `-D clippy::shadow-reuse` implied by `-D warnings`
 
 error: `x` is shadowed
-  --> $DIR/shadow.rs:15:9
+  --> $DIR/shadow.rs:22:9
    |
 LL |     let x = x[0];
    |         ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:14:9
+  --> $DIR/shadow.rs:21:9
    |
 LL |     let x = x.0;
    |         ^
 
 error: `x` is shadowed
-  --> $DIR/shadow.rs:16:10
+  --> $DIR/shadow.rs:23:10
    |
 LL |     let [x] = x;
    |          ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:15:9
+  --> $DIR/shadow.rs:22:9
    |
 LL |     let x = x[0];
    |         ^
 
 error: `x` is shadowed
-  --> $DIR/shadow.rs:17:9
+  --> $DIR/shadow.rs:24:9
    |
 LL |     let x = Some(x);
    |         ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:16:10
+  --> $DIR/shadow.rs:23:10
    |
 LL |     let [x] = x;
    |          ^
 
 error: `x` is shadowed
-  --> $DIR/shadow.rs:18:9
+  --> $DIR/shadow.rs:25:9
    |
 LL |     let x = foo(x);
    |         ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:17:9
+  --> $DIR/shadow.rs:24:9
    |
 LL |     let x = Some(x);
    |         ^
 
 error: `x` is shadowed
-  --> $DIR/shadow.rs:19:9
+  --> $DIR/shadow.rs:26:9
    |
 LL |     let x = || x;
    |         ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:18:9
+  --> $DIR/shadow.rs:25:9
    |
 LL |     let x = foo(x);
    |         ^
 
 error: `x` is shadowed
-  --> $DIR/shadow.rs:20:9
+  --> $DIR/shadow.rs:27:9
    |
 LL |     let x = Some(1).map(|_| x)?;
    |         ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:19:9
+  --> $DIR/shadow.rs:26:9
    |
 LL |     let x = || x;
    |         ^
 
 error: `y` is shadowed
-  --> $DIR/shadow.rs:22:9
+  --> $DIR/shadow.rs:29:9
    |
 LL |     let y = match y {
    |         ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:21:9
+  --> $DIR/shadow.rs:28:9
    |
 LL |     let y = 1;
    |         ^
 
 error: `x` shadows a previous, unrelated binding
-  --> $DIR/shadow.rs:31:9
+  --> $DIR/shadow.rs:38:9
    |
 LL |     let x = 2;
    |         ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:30:9
+  --> $DIR/shadow.rs:37:9
    |
 LL |     let x = 1;
    |         ^
    = note: `-D clippy::shadow-unrelated` implied by `-D warnings`
 
 error: `x` shadows a previous, unrelated binding
-  --> $DIR/shadow.rs:36:13
+  --> $DIR/shadow.rs:43:13
    |
 LL |         let x = 1;
    |             ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:35:10
+  --> $DIR/shadow.rs:42:10
    |
 LL |     fn f(x: u32) {
    |          ^
 
 error: `x` shadows a previous, unrelated binding
-  --> $DIR/shadow.rs:41:14
+  --> $DIR/shadow.rs:48:14
    |
 LL |         Some(x) => {
    |              ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:38:9
+  --> $DIR/shadow.rs:45:9
    |
 LL |     let x = 1;
    |         ^
 
 error: `x` shadows a previous, unrelated binding
-  --> $DIR/shadow.rs:42:17
+  --> $DIR/shadow.rs:49:17
    |
 LL |             let x = 1;
    |                 ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:41:14
+  --> $DIR/shadow.rs:48:14
    |
 LL |         Some(x) => {
    |              ^
 
 error: `x` shadows a previous, unrelated binding
-  --> $DIR/shadow.rs:46:17
+  --> $DIR/shadow.rs:53:17
    |
 LL |     if let Some(x) = Some(1) {}
    |                 ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:38:9
+  --> $DIR/shadow.rs:45:9
    |
 LL |     let x = 1;
    |         ^
 
 error: `x` shadows a previous, unrelated binding
-  --> $DIR/shadow.rs:47:20
+  --> $DIR/shadow.rs:54:20
    |
 LL |     while let Some(x) = Some(1) {}
    |                    ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:38:9
+  --> $DIR/shadow.rs:45:9
    |
 LL |     let x = 1;
    |         ^
 
 error: `x` shadows a previous, unrelated binding
-  --> $DIR/shadow.rs:48:15
+  --> $DIR/shadow.rs:55:15
    |
 LL |     let _ = |[x]: [u32; 1]| {
    |               ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:38:9
+  --> $DIR/shadow.rs:45:9
    |
 LL |     let x = 1;
    |         ^
 
 error: `x` shadows a previous, unrelated binding
-  --> $DIR/shadow.rs:49:13
+  --> $DIR/shadow.rs:56:13
    |
 LL |         let x = 1;
    |             ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:48:15
+  --> $DIR/shadow.rs:55:15
    |
 LL |     let _ = |[x]: [u32; 1]| {
    |               ^
 
 error: `y` is shadowed
-  --> $DIR/shadow.rs:52:17
+  --> $DIR/shadow.rs:59:17
    |
 LL |     if let Some(y) = y {}
    |                 ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:51:9
+  --> $DIR/shadow.rs:58:9
    |
 LL |     let y = Some(1);
    |         ^
 
 error: `_b` shadows a previous, unrelated binding
-  --> $DIR/shadow.rs:88:9
+  --> $DIR/shadow.rs:95:9
    |
 LL |     let _b = _a;
    |         ^^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:87:28
+  --> $DIR/shadow.rs:94:28
    |
 LL | pub async fn foo2(_a: i32, _b: i64) {
    |                            ^^
 
 error: `x` shadows a previous, unrelated binding
-  --> $DIR/shadow.rs:94:21
+  --> $DIR/shadow.rs:101:21
    |
 LL |         if let Some(x) = Some(1) { x } else { 1 }
    |                     ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:93:13
+  --> $DIR/shadow.rs:100:13
    |
 LL |         let x = 1;
    |             ^
-- 
cgit 1.4.1-3-g733a5


From 32aa07f8323d0f1896376443b389a95f7b141bf3 Mon Sep 17 00:00:00 2001
From: bluthej <joffrey.bluthe@e.email>
Date: Sun, 9 Apr 2023 13:25:50 +0200
Subject: Fix false negative for `Strings`

`String` is not a diagnostic item and was thus not picked up by
`is_type_diagnostic_item`, leading to a false negative for
`collection_is_never_read`
---
 clippy_lints/src/collection_is_never_read.rs | 18 ++++++++++++------
 tests/ui/collection_is_never_read.rs         | 20 ++++++++++++++++++++
 tests/ui/collection_is_never_read.stderr     | 14 +++++++++++++-
 3 files changed, 45 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/collection_is_never_read.rs b/clippy_lints/src/collection_is_never_read.rs
index 10f2bef268a..15a5b7dd274 100644
--- a/clippy_lints/src/collection_is_never_read.rs
+++ b/clippy_lints/src/collection_is_never_read.rs
@@ -1,9 +1,9 @@
 use clippy_utils::diagnostics::span_lint;
-use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::ty::{is_type_diagnostic_item, is_type_lang_item};
 use clippy_utils::visitors::for_each_expr_with_closures;
 use clippy_utils::{get_enclosing_block, get_parent_node, path_to_local_id};
 use core::ops::ControlFlow;
-use rustc_hir::{Block, ExprKind, HirId, Local, Node, PatKind};
+use rustc_hir::{Block, ExprKind, HirId, LangItem, Local, Node, PatKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::symbol::sym;
@@ -44,7 +44,8 @@ declare_clippy_lint! {
 }
 declare_lint_pass!(CollectionIsNeverRead => [COLLECTION_IS_NEVER_READ]);
 
-static COLLECTIONS: [Symbol; 10] = [
+// Add `String` here when it is added to diagnostic items
+static COLLECTIONS: [Symbol; 9] = [
     sym::BTreeMap,
     sym::BTreeSet,
     sym::BinaryHeap,
@@ -52,7 +53,6 @@ static COLLECTIONS: [Symbol; 10] = [
     sym::HashSet,
     sym::LinkedList,
     sym::Option,
-    sym::String,
     sym::Vec,
     sym::VecDeque,
 ];
@@ -60,8 +60,7 @@ static COLLECTIONS: [Symbol; 10] = [
 impl<'tcx> LateLintPass<'tcx> for CollectionIsNeverRead {
     fn check_local(&mut self, cx: &LateContext<'tcx>, local: &'tcx Local<'tcx>) {
         // Look for local variables whose type is a container. Search surrounding bock for read access.
-        let ty = cx.typeck_results().pat_ty(local.pat);
-        if COLLECTIONS.iter().any(|&sym| is_type_diagnostic_item(cx, ty, sym))
+        if match_acceptable_type(cx, local, &COLLECTIONS)
             && let PatKind::Binding(_, local_id, _, _) = local.pat.kind
             && let Some(enclosing_block) = get_enclosing_block(cx, local.hir_id)
             && has_no_read_access(cx, local_id, enclosing_block)
@@ -71,6 +70,13 @@ impl<'tcx> LateLintPass<'tcx> for CollectionIsNeverRead {
     }
 }
 
+fn match_acceptable_type(cx: &LateContext<'_>, local: &Local<'_>, collections: &[rustc_span::Symbol]) -> bool {
+    let ty = cx.typeck_results().pat_ty(local.pat);
+    collections.iter().any(|&sym| is_type_diagnostic_item(cx, ty, sym))
+    // String type is a lang item but not a diagnostic item for now so we need a separate check
+        || is_type_lang_item(cx, ty, LangItem::String)
+}
+
 fn has_no_read_access<'tcx>(cx: &LateContext<'tcx>, id: HirId, block: &'tcx Block<'tcx>) -> bool {
     let mut has_access = false;
     let mut has_read_access = false;
diff --git a/tests/ui/collection_is_never_read.rs b/tests/ui/collection_is_never_read.rs
index 068a49486cf..ca20031bfbe 100644
--- a/tests/ui/collection_is_never_read.rs
+++ b/tests/ui/collection_is_never_read.rs
@@ -163,3 +163,23 @@ fn function_argument() {
     let x = vec![1, 2, 3]; // Ok
     foo(&x);
 }
+
+fn string() {
+    // Do lint (write without read)
+    let mut s = String::new();
+    s.push_str("Hello, World!");
+
+    // Do not lint (read without write)
+    let mut s = String::from("Hello, World!");
+    let _ = s.len();
+
+    // Do not lint (write and read)
+    let mut s = String::from("Hello, World!");
+    s.push_str("foo, bar");
+    let _ = s.len();
+
+    // Do lint the first line, but not the second
+    let mut s = String::from("Hello, World!");
+    let t = String::from("foo, bar");
+    s = t;
+}
diff --git a/tests/ui/collection_is_never_read.stderr b/tests/ui/collection_is_never_read.stderr
index 7654b74be3d..f5dea96116f 100644
--- a/tests/ui/collection_is_never_read.stderr
+++ b/tests/ui/collection_is_never_read.stderr
@@ -48,5 +48,17 @@ error: collection is never read
 LL |     let x = vec![1, 2, 3]; // WARNING
    |     ^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 8 previous errors
+error: collection is never read
+  --> $DIR/collection_is_never_read.rs:169:5
+   |
+LL |     let mut s = String::new();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: collection is never read
+  --> $DIR/collection_is_never_read.rs:182:5
+   |
+LL |     let mut s = String::from("Hello, World!");
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 10 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 423b54ac121038aefb4b9972dbab9cce13e53086 Mon Sep 17 00:00:00 2001
From: bluthej <joffrey.bluthe@e.email>
Date: Sun, 9 Apr 2023 13:29:27 +0200
Subject: Update documentation for `clear_with_drain`

The specific type `Vec` is replaced with the generic term 'container'
---
 clippy_lints/src/methods/mod.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index c25f1b60aa5..64bf55ba24c 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3193,7 +3193,7 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of `.drain(..)` for the sole purpose of clearing a `Vec`.
+    /// Checks for usage of `.drain(..)` for the sole purpose of clearing a container.
     ///
     /// ### Why is this bad?
     /// This creates an unnecessary iterator that is dropped immediately.
@@ -3213,7 +3213,7 @@ declare_clippy_lint! {
     #[clippy::version = "1.69.0"]
     pub CLEAR_WITH_DRAIN,
     nursery,
-    "calling `drain` in order to `clear` a `Vec`"
+    "calling `drain` in order to `clear` a container"
 }
 
 pub struct Methods {
-- 
cgit 1.4.1-3-g733a5


From 7852962820cf2cdbedf6a9a27b4c3795c09a1cff Mon Sep 17 00:00:00 2001
From: bluthej <joffrey.bluthe@e.email>
Date: Sun, 9 Apr 2023 13:37:02 +0200
Subject: Change `format!` style to please dogfood test

---
 clippy_lints/src/methods/clear_with_drain.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/clear_with_drain.rs b/clippy_lints/src/methods/clear_with_drain.rs
index 6ce3fdae407..67ad58d5a8c 100644
--- a/clippy_lints/src/methods/clear_with_drain.rs
+++ b/clippy_lints/src/methods/clear_with_drain.rs
@@ -44,7 +44,7 @@ fn suggest(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'_>, span: Span) {
             cx,
             CLEAR_WITH_DRAIN,
             span.with_hi(expr.span.hi()),
-            &format!("`drain` used to clear a `{}`", ty_name),
+            &format!("`drain` used to clear a `{ty_name}`"),
             "try",
             "clear()".to_string(),
             Applicability::MachineApplicable,
-- 
cgit 1.4.1-3-g733a5


From 5109a8a840bab0db9909a9ea3237987de45b28be Mon Sep 17 00:00:00 2001
From: Kisaragi <48310258+KisaragiEffective@users.noreply.github.com>
Date: Mon, 10 Apr 2023 00:55:32 +0900
Subject: [missing_const_for_fn] fix #7121

---
 clippy_lints/src/missing_const_for_fn.rs | 1 +
 1 file changed, 1 insertion(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/missing_const_for_fn.rs b/clippy_lints/src/missing_const_for_fn.rs
index 87bd007a26a..0cde9cb08f8 100644
--- a/clippy_lints/src/missing_const_for_fn.rs
+++ b/clippy_lints/src/missing_const_for_fn.rs
@@ -41,6 +41,7 @@ declare_clippy_lint! {
     /// can't be const as it calls a non-const function. Making `a` const and running Clippy again,
     /// will suggest to make `b` const, too.
     ///
+    /// If you are marking public function with const, doing opposite will break API compatibility.
     /// ### Example
     /// ```rust
     /// # struct Foo {
-- 
cgit 1.4.1-3-g733a5


From ba1f19ee3087f6c47a4ba0f06b21361e1d38d90f Mon Sep 17 00:00:00 2001
From: Kisaragi <48310258+KisaragiEffective@users.noreply.github.com>
Date: Mon, 10 Apr 2023 01:31:30 +0900
Subject: apply code review suggestion

Co-authored-by: llogiq <bogusandre@gmail.com>
---
 clippy_lints/src/missing_const_for_fn.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/missing_const_for_fn.rs b/clippy_lints/src/missing_const_for_fn.rs
index 0cde9cb08f8..f1831a30461 100644
--- a/clippy_lints/src/missing_const_for_fn.rs
+++ b/clippy_lints/src/missing_const_for_fn.rs
@@ -41,7 +41,7 @@ declare_clippy_lint! {
     /// can't be const as it calls a non-const function. Making `a` const and running Clippy again,
     /// will suggest to make `b` const, too.
     ///
-    /// If you are marking public function with const, doing opposite will break API compatibility.
+    /// If you are marking a public function with `const`, removing it again will break API compatibility.
     /// ### Example
     /// ```rust
     /// # struct Foo {
-- 
cgit 1.4.1-3-g733a5


From d6fe73db3fea55511db95969d13de5e1f5be327e Mon Sep 17 00:00:00 2001
From: The 8472 <git@infinite-source.de>
Date: Mon, 10 Apr 2023 13:13:09 +0200
Subject: remove unusued feature

---
 clippy_lints/src/lib.rs | 1 -
 1 file changed, 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index bac82eca817..b0ec14855e7 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1,7 +1,6 @@
 #![feature(array_windows)]
 #![feature(binary_heap_into_iter_sorted)]
 #![feature(box_patterns)]
-#![feature(drain_filter)]
 #![feature(if_let_guard)]
 #![feature(iter_intersperse)]
 #![feature(let_chains)]
-- 
cgit 1.4.1-3-g733a5


From 63030acf4ff453da2beb7f43b13cca8fb6cf425a Mon Sep 17 00:00:00 2001
From: Michael Schubart <michael@schubart.net>
Date: Sun, 12 Mar 2023 14:45:22 +0000
Subject: Refactor

---
 clippy_lints/src/collection_is_never_read.rs | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/collection_is_never_read.rs b/clippy_lints/src/collection_is_never_read.rs
index 15a5b7dd274..a5feffa3106 100644
--- a/clippy_lints/src/collection_is_never_read.rs
+++ b/clippy_lints/src/collection_is_never_read.rs
@@ -101,9 +101,9 @@ fn has_no_read_access<'tcx>(cx: &LateContext<'tcx>, id: HirId, block: &'tcx Bloc
             return ControlFlow::Continue(());
         }
 
-        // Method call on `id` in a statement ignores any return value, so it's not a read access:
+        // Look for method call with receiver `id`. It might be a non-read access:
         //
-        // id.foo(...); // Not reading `id`.
+        // id.foo(args)
         //
         // Only assuming this for "official" methods defined on the type. For methods defined in extension
         // traits (identified as local, based on the orphan rule), pessimistically assume that they might
@@ -111,11 +111,15 @@ fn has_no_read_access<'tcx>(cx: &LateContext<'tcx>, id: HirId, block: &'tcx Bloc
         if let Some(Node::Expr(parent)) = get_parent_node(cx.tcx, expr.hir_id)
             && let ExprKind::MethodCall(_, receiver, _, _) = parent.kind
             && path_to_local_id(receiver, id)
-            && let Some(Node::Stmt(..)) = get_parent_node(cx.tcx, parent.hir_id)
             && let Some(method_def_id) = cx.typeck_results().type_dependent_def_id(parent.hir_id)
             && !method_def_id.is_local()
         {
-            return ControlFlow::Continue(());
+            // The method call is a statement, so the return value is not used. That's not a read access:
+            //
+            // id.foo(args);
+            if let Some(Node::Stmt(..)) = get_parent_node(cx.tcx, parent.hir_id) {
+                return ControlFlow::Continue(());
+            }
         }
 
         // Any other access to `id` is a read access. Stop searching.
-- 
cgit 1.4.1-3-g733a5


From 008ba7326b315abd1d6ef693d773b88ccb044ba4 Mon Sep 17 00:00:00 2001
From: Michael Schubart <michael@schubart.net>
Date: Sun, 12 Mar 2023 14:56:14 +0000
Subject: Ignore fake read access

---
 clippy_lints/src/collection_is_never_read.rs |  9 +++++++++
 tests/ui/collection_is_never_read.rs         |  3 +--
 tests/ui/collection_is_never_read.stderr     | 20 +++++++++++++-------
 3 files changed, 23 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/collection_is_never_read.rs b/clippy_lints/src/collection_is_never_read.rs
index a5feffa3106..5e2eb5789f6 100644
--- a/clippy_lints/src/collection_is_never_read.rs
+++ b/clippy_lints/src/collection_is_never_read.rs
@@ -120,6 +120,15 @@ fn has_no_read_access<'tcx>(cx: &LateContext<'tcx>, id: HirId, block: &'tcx Bloc
             if let Some(Node::Stmt(..)) = get_parent_node(cx.tcx, parent.hir_id) {
                 return ControlFlow::Continue(());
             }
+
+            // The method call is not a statement, so its return value is used somehow but its type is the
+            // unit type, so this is not a real read access. Examples:
+            //
+            // let y = x.clear();
+            // println!("{:?}", x.clear());
+            if cx.typeck_results().expr_ty(parent).is_unit() {
+                return ControlFlow::Continue(());
+            }
         }
 
         // Any other access to `id` is a read access. Stop searching.
diff --git a/tests/ui/collection_is_never_read.rs b/tests/ui/collection_is_never_read.rs
index ca20031bfbe..4f9431be72a 100644
--- a/tests/ui/collection_is_never_read.rs
+++ b/tests/ui/collection_is_never_read.rs
@@ -85,9 +85,8 @@ fn shadowing_2() {
 
 #[allow(clippy::let_unit_value)]
 fn fake_read() {
-    let mut x = vec![1, 2, 3]; // Ok
+    let mut x = vec![1, 2, 3]; // WARNING
     x.reverse();
-    // `collection_is_never_read` gets fooled, but other lints should catch this.
     let _: () = x.clear();
 }
 
diff --git a/tests/ui/collection_is_never_read.stderr b/tests/ui/collection_is_never_read.stderr
index f5dea96116f..cfb39298339 100644
--- a/tests/ui/collection_is_never_read.stderr
+++ b/tests/ui/collection_is_never_read.stderr
@@ -25,40 +25,46 @@ LL |     let mut x = HashMap::new(); // WARNING
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: collection is never read
-  --> $DIR/collection_is_never_read.rs:95:5
+  --> $DIR/collection_is_never_read.rs:88:5
    |
 LL |     let mut x = vec![1, 2, 3]; // WARNING
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: collection is never read
-  --> $DIR/collection_is_never_read.rs:102:5
+  --> $DIR/collection_is_never_read.rs:94:5
    |
 LL |     let mut x = vec![1, 2, 3]; // WARNING
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: collection is never read
-  --> $DIR/collection_is_never_read.rs:119:5
+  --> $DIR/collection_is_never_read.rs:101:5
+   |
+LL |     let mut x = vec![1, 2, 3]; // WARNING
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: collection is never read
+  --> $DIR/collection_is_never_read.rs:118:5
    |
 LL |     let mut x = HashSet::new(); // WARNING
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: collection is never read
-  --> $DIR/collection_is_never_read.rs:133:5
+  --> $DIR/collection_is_never_read.rs:132:5
    |
 LL |     let x = vec![1, 2, 3]; // WARNING
    |     ^^^^^^^^^^^^^^^^^^^^^^
 
 error: collection is never read
-  --> $DIR/collection_is_never_read.rs:169:5
+  --> $DIR/collection_is_never_read.rs:168:5
    |
 LL |     let mut s = String::new();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: collection is never read
-  --> $DIR/collection_is_never_read.rs:182:5
+  --> $DIR/collection_is_never_read.rs:181:5
    |
 LL |     let mut s = String::from("Hello, World!");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 10 previous errors
+error: aborting due to 11 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 8f979af3d1e416e26cb5573f70b6766b312b146c Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Tue, 11 Apr 2023 11:17:18 +0000
Subject: Fix UB in `as_ptr_cast_mut` documentation

---
 clippy_lints/src/casts/mod.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index 362f70d12d1..89022a84d40 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -625,14 +625,14 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust
-    /// let string = String::with_capacity(1);
-    /// let ptr = string.as_ptr() as *mut u8;
+    /// let mut vec = Vec::<u8>::with_capacity(1);
+    /// let ptr = vec.as_ptr() as *mut u8;
     /// unsafe { ptr.write(4) }; // UNDEFINED BEHAVIOUR
     /// ```
     /// Use instead:
     /// ```rust
-    /// let mut string = String::with_capacity(1);
-    /// let ptr = string.as_mut_ptr();
+    /// let mut vec = Vec::<u8>::with_capacity(1);
+    /// let ptr = vec.as_mut_ptr();
     /// unsafe { ptr.write(4) };
     /// ```
     #[clippy::version = "1.66.0"]
-- 
cgit 1.4.1-3-g733a5


From 640955692610120a7ff127d20740f34c46457d38 Mon Sep 17 00:00:00 2001
From: bluthej <joffrey.bluthe@e.email>
Date: Wed, 12 Apr 2023 13:48:03 +0200
Subject: Standardize lint formulation

---
 clippy_lints/src/allow_attributes.rs               |  2 +-
 clippy_lints/src/casts/mod.rs                      |  2 +-
 clippy_lints/src/crate_in_macro_def.rs             |  2 +-
 clippy_lints/src/entry.rs                          |  2 +-
 clippy_lints/src/format_impl.rs                    |  2 +-
 clippy_lints/src/formatting.rs                     |  2 +-
 clippy_lints/src/lines_filter_map_ok.rs            |  2 +-
 clippy_lints/src/manual_bits.rs                    |  2 +-
 clippy_lints/src/matches/mod.rs                    |  6 ++--
 clippy_lints/src/methods/mod.rs                    | 32 +++++++++++-----------
 clippy_lints/src/mutex_atomic.rs                   |  6 ++--
 clippy_lints/src/non_copy_const.rs                 |  2 +-
 clippy_lints/src/operators/mod.rs                  |  2 +-
 clippy_lints/src/types/mod.rs                      | 10 +++----
 .../utils/internal_lints/unnecessary_def_path.rs   |  2 +-
 clippy_lints/src/write.rs                          |  2 +-
 16 files changed, 39 insertions(+), 39 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/allow_attributes.rs b/clippy_lints/src/allow_attributes.rs
index 15d46e954a9..b984132acf5 100644
--- a/clippy_lints/src/allow_attributes.rs
+++ b/clippy_lints/src/allow_attributes.rs
@@ -6,7 +6,7 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
-    /// Detects uses of the `#[allow]` attribute and suggests replacing it with
+    /// Checks for usage of the `#[allow]` attribute and suggests replacing it with
     /// the `#[expect]` (See [RFC 2383](https://rust-lang.github.io/rfcs/2383-lint-reasons.html))
     ///
     /// The expect attribute is still unstable and requires the `lint_reasons`
diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index 362f70d12d1..37648f7ba0e 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -506,7 +506,7 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for uses of the `abs()` method that cast the result to unsigned.
+    /// Checks for usage of the `abs()` method that cast the result to unsigned.
     ///
     /// ### Why is this bad?
     /// The `unsigned_abs()` method avoids panic when called on the MIN value.
diff --git a/clippy_lints/src/crate_in_macro_def.rs b/clippy_lints/src/crate_in_macro_def.rs
index b2fe0386f94..7436e9ce811 100644
--- a/clippy_lints/src/crate_in_macro_def.rs
+++ b/clippy_lints/src/crate_in_macro_def.rs
@@ -9,7 +9,7 @@ use rustc_span::{symbol::sym, Span};
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for use of `crate` as opposed to `$crate` in a macro definition.
+    /// Checks for usage of `crate` as opposed to `$crate` in a macro definition.
     ///
     /// ### Why is this bad?
     /// `crate` refers to the macro call's crate, whereas `$crate` refers to the macro definition's
diff --git a/clippy_lints/src/entry.rs b/clippy_lints/src/entry.rs
index 48a54f60253..ee5a875ade7 100644
--- a/clippy_lints/src/entry.rs
+++ b/clippy_lints/src/entry.rs
@@ -19,7 +19,7 @@ use rustc_span::{Span, SyntaxContext, DUMMY_SP};
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for uses of `contains_key` + `insert` on `HashMap`
+    /// Checks for usage of `contains_key` + `insert` on `HashMap`
     /// or `BTreeMap`.
     ///
     /// ### Why is this bad?
diff --git a/clippy_lints/src/format_impl.rs b/clippy_lints/src/format_impl.rs
index e3ddbfb5981..3ddee1842a3 100644
--- a/clippy_lints/src/format_impl.rs
+++ b/clippy_lints/src/format_impl.rs
@@ -51,7 +51,7 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for use of `println`, `print`, `eprintln` or `eprint` in an
+    /// Checks for usage of `println`, `print`, `eprintln` or `eprint` in an
     /// implementation of a formatting trait.
     ///
     /// ### Why is this bad?
diff --git a/clippy_lints/src/formatting.rs b/clippy_lints/src/formatting.rs
index a866a68987d..4762b354392 100644
--- a/clippy_lints/src/formatting.rs
+++ b/clippy_lints/src/formatting.rs
@@ -10,7 +10,7 @@ use rustc_span::source_map::Span;
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for use of the non-existent `=*`, `=!` and `=-`
+    /// Checks for usage of the non-existent `=*`, `=!` and `=-`
     /// operators.
     ///
     /// ### Why is this bad?
diff --git a/clippy_lints/src/lines_filter_map_ok.rs b/clippy_lints/src/lines_filter_map_ok.rs
index b0f9276475d..bba9bb445a7 100644
--- a/clippy_lints/src/lines_filter_map_ok.rs
+++ b/clippy_lints/src/lines_filter_map_ok.rs
@@ -10,7 +10,7 @@ use rustc_span::sym;
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Detect uses of `lines.filter_map(Result::ok)` or `lines.flat_map(Result::ok)`
+    /// Checks for usage of `lines.filter_map(Result::ok)` or `lines.flat_map(Result::ok)`
     /// when `lines` has type `std::io::Lines`.
     ///
     /// ### Why is this bad?
diff --git a/clippy_lints/src/manual_bits.rs b/clippy_lints/src/manual_bits.rs
index bc815dc4a26..4629b22d171 100644
--- a/clippy_lints/src/manual_bits.rs
+++ b/clippy_lints/src/manual_bits.rs
@@ -13,7 +13,7 @@ use rustc_span::sym;
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for uses of `std::mem::size_of::<T>() * 8` when
+    /// Checks for usage of `std::mem::size_of::<T>() * 8` when
     /// `T::BITS` is available.
     ///
     /// ### Why is this bad?
diff --git a/clippy_lints/src/matches/mod.rs b/clippy_lints/src/matches/mod.rs
index 97ecca450fa..87b63eead25 100644
--- a/clippy_lints/src/matches/mod.rs
+++ b/clippy_lints/src/matches/mod.rs
@@ -843,7 +843,7 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usages of `Err(x)?`.
+    /// Checks for usage of `Err(x)?`.
     ///
     /// ### Why is this bad?
     /// The `?` operator is designed to allow calls that
@@ -878,7 +878,7 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usages of `match` which could be implemented using `map`
+    /// Checks for usage of `match` which could be implemented using `map`
     ///
     /// ### Why is this bad?
     /// Using the `map` method is clearer and more concise.
@@ -902,7 +902,7 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usages of `match` which could be implemented using `filter`
+    /// Checks for usage of `match` which could be implemented using `filter`
     ///
     /// ### Why is this bad?
     /// Using the `filter` method is clearer and more concise.
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 64bf55ba24c..c213030f6a8 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -121,7 +121,7 @@ use rustc_span::{sym, Span};
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usages of `cloned()` on an `Iterator` or `Option` where
+    /// Checks for usage of `cloned()` on an `Iterator` or `Option` where
     /// `copied()` could be used instead.
     ///
     /// ### Why is this bad?
@@ -201,7 +201,7 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usages of `Iterator::flat_map()` where `filter_map()` could be
+    /// Checks for usage of `Iterator::flat_map()` where `filter_map()` could be
     /// used instead.
     ///
     /// ### Why is this bad?
@@ -441,7 +441,7 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usages of `_.unwrap_or_else(Default::default)` on `Option` and
+    /// Checks for usage of `_.unwrap_or_else(Default::default)` on `Option` and
     /// `Result` values.
     ///
     /// ### Why is this bad?
@@ -1194,7 +1194,7 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for use of `.iter().nth()` (and the related
+    /// Checks for usage of `.iter().nth()` (and the related
     /// `.iter_mut().nth()`) on standard library types with *O*(1) element access.
     ///
     /// ### Why is this bad?
@@ -1221,7 +1221,7 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for use of `.skip(x).next()` on iterators.
+    /// Checks for usage of `.skip(x).next()` on iterators.
     ///
     /// ### Why is this bad?
     /// `.nth(x)` is cleaner
@@ -1246,7 +1246,7 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for use of `.drain(..)` on `Vec` and `VecDeque` for iteration.
+    /// Checks for usage of `.drain(..)` on `Vec` and `VecDeque` for iteration.
     ///
     /// ### Why is this bad?
     /// `.into_iter()` is simpler with better performance.
@@ -1271,7 +1271,7 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for using `x.get(x.len() - 1)` instead of
+    /// Checks for usage of `x.get(x.len() - 1)` instead of
     /// `x.last()`.
     ///
     /// ### Why is this bad?
@@ -1304,7 +1304,7 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for use of `.get().unwrap()` (or
+    /// Checks for usage of `.get().unwrap()` (or
     /// `.get_mut().unwrap`) on a standard library type which implements `Index`
     ///
     /// ### Why is this bad?
@@ -1475,7 +1475,7 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for using `fold` when a more succinct alternative exists.
+    /// Checks for usage of `fold` when a more succinct alternative exists.
     /// Specifically, this checks for `fold`s which could be replaced by `any`, `all`,
     /// `sum` or `product`.
     ///
@@ -2161,7 +2161,7 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usages of `str::splitn(2, _)`
+    /// Checks for usage of `str::splitn(2, _)`
     ///
     /// ### Why is this bad?
     /// `split_once` is both clearer in intent and slightly more efficient.
@@ -2197,7 +2197,7 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usages of `str::splitn` (or `str::rsplitn`) where using `str::split` would be the same.
+    /// Checks for usage of `str::splitn` (or `str::rsplitn`) where using `str::split` would be the same.
     /// ### Why is this bad?
     /// The function `split` is simpler and there is no performance difference in these cases, considering
     /// that both functions return a lazy iterator.
@@ -2251,7 +2251,7 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for use of `.collect::<Vec<String>>().join("")` on iterators.
+    /// Checks for usage of `.collect::<Vec<String>>().join("")` on iterators.
     ///
     /// ### Why is this bad?
     /// `.collect::<String>()` is more concise and might be more performant
@@ -2377,7 +2377,7 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usages of `.then_some(..).unwrap_or(..)`
+    /// Checks for usage of `.then_some(..).unwrap_or(..)`
     ///
     /// ### Why is this bad?
     /// This can be written more clearly with `if .. else ..`
@@ -2553,7 +2553,7 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for using `x.get(0)` instead of
+    /// Checks for usage of `x.get(0)` instead of
     /// `x.first()`.
     ///
     /// ### Why is this bad?
@@ -2957,7 +2957,7 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Detects uses of `Vec::sort_by` passing in a closure
+    /// Checks for usage of `Vec::sort_by` passing in a closure
     /// which compares the two arguments, either directly or indirectly.
     ///
     /// ### Why is this bad?
@@ -3013,7 +3013,7 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for use of File::read_to_end and File::read_to_string.
+    /// Checks for usage of File::read_to_end and File::read_to_string.
     ///
     /// ### Why is this bad?
     /// `fs::{read, read_to_string}` provide the same functionality when `buf` is empty with fewer imports and no intermediate values.
diff --git a/clippy_lints/src/mutex_atomic.rs b/clippy_lints/src/mutex_atomic.rs
index dc866ab6373..99394b9e5fb 100644
--- a/clippy_lints/src/mutex_atomic.rs
+++ b/clippy_lints/src/mutex_atomic.rs
@@ -1,4 +1,4 @@
-//! Checks for uses of mutex where an atomic value could be used
+//! Checks for usage of mutex where an atomic value could be used
 //!
 //! This lint is **allow** by default
 
@@ -12,7 +12,7 @@ use rustc_span::sym;
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usages of `Mutex<X>` where an atomic will do.
+    /// Checks for usage of `Mutex<X>` where an atomic will do.
     ///
     /// ### Why is this bad?
     /// Using a mutex just to make access to a plain bool or
@@ -49,7 +49,7 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usages of `Mutex<X>` where `X` is an integral
+    /// Checks for usage of `Mutex<X>` where `X` is an integral
     /// type.
     ///
     /// ### Why is this bad?
diff --git a/clippy_lints/src/non_copy_const.rs b/clippy_lints/src/non_copy_const.rs
index 0bedab05eec..9ab6743d369 100644
--- a/clippy_lints/src/non_copy_const.rs
+++ b/clippy_lints/src/non_copy_const.rs
@@ -1,4 +1,4 @@
-//! Checks for uses of const which the type is not `Freeze` (`Cell`-free).
+//! Checks for usage of const which the type is not `Freeze` (`Cell`-free).
 //!
 //! This lint is **warn** by default.
 
diff --git a/clippy_lints/src/operators/mod.rs b/clippy_lints/src/operators/mod.rs
index eba230da6c3..19599731bd6 100644
--- a/clippy_lints/src/operators/mod.rs
+++ b/clippy_lints/src/operators/mod.rs
@@ -685,7 +685,7 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for uses of bitwise and/or operators between booleans, where performance may be improved by using
+    /// Checks for usage of bitwise and/or operators between booleans, where performance may be improved by using
     /// a lazy and.
     ///
     /// ### Why is this bad?
diff --git a/clippy_lints/src/types/mod.rs b/clippy_lints/src/types/mod.rs
index c1f228d5f90..c6834a8fdaa 100644
--- a/clippy_lints/src/types/mod.rs
+++ b/clippy_lints/src/types/mod.rs
@@ -22,7 +22,7 @@ use rustc_span::source_map::Span;
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for use of `Box<T>` where T is a collection such as Vec anywhere in the code.
+    /// Checks for usage of `Box<T>` where T is a collection such as Vec anywhere in the code.
     /// Check the [Box documentation](https://doc.rust-lang.org/std/boxed/index.html) for more information.
     ///
     /// ### Why is this bad?
@@ -52,7 +52,7 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for use of `Vec<Box<T>>` where T: Sized anywhere in the code.
+    /// Checks for usage of `Vec<Box<T>>` where T: Sized anywhere in the code.
     /// Check the [Box documentation](https://doc.rust-lang.org/std/boxed/index.html) for more information.
     ///
     /// ### Why is this bad?
@@ -85,7 +85,7 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for use of `Option<Option<_>>` in function signatures and type
+    /// Checks for usage of `Option<Option<_>>` in function signatures and type
     /// definitions
     ///
     /// ### Why is this bad?
@@ -164,7 +164,7 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for use of `&Box<T>` anywhere in the code.
+    /// Checks for usage of `&Box<T>` anywhere in the code.
     /// Check the [Box documentation](https://doc.rust-lang.org/std/boxed/index.html) for more information.
     ///
     /// ### Why is this bad?
@@ -190,7 +190,7 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for use of redundant allocations anywhere in the code.
+    /// Checks for usage of redundant allocations anywhere in the code.
     ///
     /// ### Why is this bad?
     /// Expressions such as `Rc<&T>`, `Rc<Rc<T>>`, `Rc<Arc<T>>`, `Rc<Box<T>>`, `Arc<&T>`, `Arc<Rc<T>>`,
diff --git a/clippy_lints/src/utils/internal_lints/unnecessary_def_path.rs b/clippy_lints/src/utils/internal_lints/unnecessary_def_path.rs
index 14ed1368e03..00842376628 100644
--- a/clippy_lints/src/utils/internal_lints/unnecessary_def_path.rs
+++ b/clippy_lints/src/utils/internal_lints/unnecessary_def_path.rs
@@ -20,7 +20,7 @@ use std::str;
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usages of def paths when a diagnostic item or a `LangItem` could be used.
+    /// Checks for usage of def paths when a diagnostic item or a `LangItem` could be used.
     ///
     /// ### Why is this bad?
     /// The path for an item is subject to change and is less efficient to look up than a
diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs
index d7c94b909bd..f194dc5d4b2 100644
--- a/clippy_lints/src/write.rs
+++ b/clippy_lints/src/write.rs
@@ -104,7 +104,7 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for use of `Debug` formatting. The purpose of this
+    /// Checks for usage of `Debug` formatting. The purpose of this
     /// lint is to catch debugging remnants.
     ///
     /// ### Why is this bad?
-- 
cgit 1.4.1-3-g733a5


From d6390625dcca846221f42b5cb726bf2a4bc36b1e Mon Sep 17 00:00:00 2001
From: Caio <c410.f3r@gmail.com>
Date: Sat, 15 Apr 2023 16:05:46 -0300
Subject: Address comments

---
 clippy_lints/src/operators/numeric_arithmetic.rs | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/operators/numeric_arithmetic.rs b/clippy_lints/src/operators/numeric_arithmetic.rs
index ea9696691f9..77fd45b199a 100644
--- a/clippy_lints/src/operators/numeric_arithmetic.rs
+++ b/clippy_lints/src/operators/numeric_arithmetic.rs
@@ -19,10 +19,6 @@ impl Context {
         self.expr_id.is_some() || self.const_span.map_or(false, |span| span.contains(e.span))
     }
 
-    fn skip_expr_involving_integers<'tcx>(cx: &LateContext<'tcx>, e: &hir::Expr<'tcx>) -> bool {
-        is_from_proc_macro(cx, e)
-    }
-
     pub fn check_binary<'tcx>(
         &mut self,
         cx: &LateContext<'tcx>,
@@ -51,7 +47,7 @@ impl Context {
 
         let (l_ty, r_ty) = (cx.typeck_results().expr_ty(l), cx.typeck_results().expr_ty(r));
         if l_ty.peel_refs().is_integral() && r_ty.peel_refs().is_integral() {
-            if Self::skip_expr_involving_integers(cx, expr) {
+            if is_from_proc_macro(cx, expr) {
                 return;
             }
             match op {
@@ -86,7 +82,7 @@ impl Context {
         let ty = cx.typeck_results().expr_ty(arg);
         if constant_simple(cx, cx.typeck_results(), expr).is_none() {
             if ty.is_integral() {
-                if Self::skip_expr_involving_integers(cx, expr) {
+                if is_from_proc_macro(cx, expr) {
                     return;
                 }
                 span_lint(cx, INTEGER_ARITHMETIC, expr.span, "integer arithmetic detected");
-- 
cgit 1.4.1-3-g733a5


From 0a81f8257e2317b019406c42575d10bbd33c7268 Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Sun, 16 Apr 2023 23:30:00 -0500
Subject: add `semicolon_outside_block_if_singleline` lint

---
 CHANGELOG.md                                       |  1 +
 clippy_lints/src/declared_lints.rs                 |  1 +
 clippy_lints/src/semicolon_block.rs                | 92 +++++++++++++++++++++-
 .../ui/semicolon_outside_block_if_singleline.fixed | 85 ++++++++++++++++++++
 tests/ui/semicolon_outside_block_if_singleline.rs  | 85 ++++++++++++++++++++
 .../semicolon_outside_block_if_singleline.stderr   | 54 +++++++++++++
 6 files changed, 317 insertions(+), 1 deletion(-)
 create mode 100644 tests/ui/semicolon_outside_block_if_singleline.fixed
 create mode 100644 tests/ui/semicolon_outside_block_if_singleline.rs
 create mode 100644 tests/ui/semicolon_outside_block_if_singleline.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 559b560dde4..a0a7780f4c2 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4884,6 +4884,7 @@ Released 2018-09-13
 [`semicolon_if_nothing_returned`]: https://rust-lang.github.io/rust-clippy/master/index.html#semicolon_if_nothing_returned
 [`semicolon_inside_block`]: https://rust-lang.github.io/rust-clippy/master/index.html#semicolon_inside_block
 [`semicolon_outside_block`]: https://rust-lang.github.io/rust-clippy/master/index.html#semicolon_outside_block
+[`semicolon_outside_block_if_singleline`]: https://rust-lang.github.io/rust-clippy/master/index.html#semicolon_outside_block_if_singleline
 [`separated_literal_suffix`]: https://rust-lang.github.io/rust-clippy/master/index.html#separated_literal_suffix
 [`serde_api_misuse`]: https://rust-lang.github.io/rust-clippy/master/index.html#serde_api_misuse
 [`shadow_reuse`]: https://rust-lang.github.io/rust-clippy/master/index.html#shadow_reuse
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index f24dab62780..70379b6caf1 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -546,6 +546,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::self_named_constructors::SELF_NAMED_CONSTRUCTORS_INFO,
     crate::semicolon_block::SEMICOLON_INSIDE_BLOCK_INFO,
     crate::semicolon_block::SEMICOLON_OUTSIDE_BLOCK_INFO,
+    crate::semicolon_block::SEMICOLON_OUTSIDE_BLOCK_IF_SINGLELINE_INFO,
     crate::semicolon_if_nothing_returned::SEMICOLON_IF_NOTHING_RETURNED_INFO,
     crate::serde_api::SERDE_API_MISUSE_INFO,
     crate::shadow::SHADOW_REUSE_INFO,
diff --git a/clippy_lints/src/semicolon_block.rs b/clippy_lints/src/semicolon_block.rs
index 34a3e5ddf4f..d791100b9b9 100644
--- a/clippy_lints/src/semicolon_block.rs
+++ b/clippy_lints/src/semicolon_block.rs
@@ -64,7 +64,48 @@ declare_clippy_lint! {
     restriction,
     "add a semicolon outside the block"
 }
-declare_lint_pass!(SemicolonBlock => [SEMICOLON_INSIDE_BLOCK, SEMICOLON_OUTSIDE_BLOCK]);
+declare_clippy_lint! {
+    /// ### What it does
+    ///
+    /// Suggests moving the semicolon from a block's final expression outside of
+    /// the block if it's singleline, and inside the block if it's multiline.
+    ///
+    /// ### Why is this bad?
+    ///
+    /// Some may prefer if the  semicolon is outside if a block is only one
+    /// expression, as this allows rustfmt to make it singleline. In the case that
+    /// it isn't, it should be inside.
+    /// Take a look at both `semicolon_inside_block` and `semicolon_outside_block` for alternatives.
+    ///
+    /// ### Example
+    ///
+    /// ```rust
+    /// # fn f(_: u32) {}
+    /// # let x = 0;
+    /// unsafe { f(x); }
+    /// 
+    /// unsafe {
+    ///     let x = 1;
+    ///     f(x)
+    /// };
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// # fn f(_: u32) {}
+    /// # let x = 0;
+    /// unsafe { f(x) };
+    /// 
+    /// unsafe {
+    ///     let x = 1;
+    ///     f(x);
+    /// }
+    /// ```
+    #[clippy::version = "1.68.0"]
+    pub SEMICOLON_OUTSIDE_BLOCK_IF_SINGLELINE,
+    restriction,
+    "add a semicolon inside the block if it's singleline, otherwise outside"
+}
+declare_lint_pass!(SemicolonBlock => [SEMICOLON_INSIDE_BLOCK, SEMICOLON_OUTSIDE_BLOCK, SEMICOLON_OUTSIDE_BLOCK_IF_SINGLELINE]);
 
 impl LateLintPass<'_> for SemicolonBlock {
     fn check_stmt(&mut self, cx: &LateContext<'_>, stmt: &Stmt<'_>) {
@@ -98,6 +139,8 @@ fn semicolon_inside_block(cx: &LateContext<'_>, block: &Block<'_>, tail: &Expr<'
     let insert_span = tail.span.source_callsite().shrink_to_hi();
     let remove_span = semi_span.with_lo(block.span.hi());
 
+    check_semicolon_outside_block_if_singleline(cx, block, remove_span, insert_span, true, "inside");
+
     span_lint_and_then(
         cx,
         SEMICOLON_INSIDE_BLOCK,
@@ -120,6 +163,8 @@ fn semicolon_outside_block(cx: &LateContext<'_>, block: &Block<'_>, tail_stmt_ex
     let semi_span = cx.sess().source_map().stmt_span(semi_span, block.span);
     let remove_span = semi_span.with_lo(tail_stmt_expr.span.source_callsite().hi());
 
+    check_semicolon_outside_block_if_singleline(cx, block, remove_span, insert_span, false, "outside");
+
     span_lint_and_then(
         cx,
         SEMICOLON_OUTSIDE_BLOCK,
@@ -135,3 +180,48 @@ fn semicolon_outside_block(cx: &LateContext<'_>, block: &Block<'_>, tail_stmt_ex
         },
     );
 }
+
+fn check_semicolon_outside_block_if_singleline(
+    cx: &LateContext<'_>,
+    block: &Block<'_>,
+    remove_span: Span,
+    insert_span: Span,
+    inequality: bool,
+    ty: &str,
+) {
+    let remove_line = cx
+        .sess()
+        .source_map()
+        .lookup_line(remove_span.lo())
+        .expect("failed to get `remove_span`'s line")
+        .line;
+    let insert_line = cx
+        .sess()
+        .source_map()
+        .lookup_line(insert_span.lo())
+        .expect("failed to get `insert_span`'s line")
+        .line;
+
+    let eq = if inequality {
+        remove_line != insert_line
+    } else {
+        remove_line == insert_line
+    };
+
+    if eq {
+        span_lint_and_then(
+            cx,
+            SEMICOLON_OUTSIDE_BLOCK_IF_SINGLELINE,
+            block.span,
+            &format!("consider moving the `;` {ty} the block for consistent formatting"),
+            |diag| {
+                multispan_sugg_with_applicability(
+                    diag,
+                    "put the `;` here",
+                    Applicability::MachineApplicable,
+                    [(remove_span, String::new()), (insert_span, ";".to_owned())],
+                );
+            },
+        );
+    }
+}
diff --git a/tests/ui/semicolon_outside_block_if_singleline.fixed b/tests/ui/semicolon_outside_block_if_singleline.fixed
new file mode 100644
index 00000000000..592f9c49ed7
--- /dev/null
+++ b/tests/ui/semicolon_outside_block_if_singleline.fixed
@@ -0,0 +1,85 @@
+// run-rustfix
+#![allow(
+    unused,
+    clippy::unused_unit,
+    clippy::unnecessary_operation,
+    clippy::no_effect,
+    clippy::single_element_loop
+)]
+#![warn(clippy::semicolon_outside_block_if_singleline)]
+
+macro_rules! m {
+    (()) => {
+        ()
+    };
+    (0) => {{
+        0
+    };};
+    (1) => {{
+        1;
+    }};
+    (2) => {{
+        2;
+    }};
+}
+
+fn unit_fn_block() {
+    ()
+}
+
+#[rustfmt::skip]
+fn main() {
+    { unit_fn_block() }
+    unsafe { unit_fn_block() }
+
+    {
+        unit_fn_block()
+    }
+
+    { unit_fn_block() };
+    unsafe { unit_fn_block() };
+
+    { unit_fn_block() };
+    unsafe { unit_fn_block() };
+
+    { unit_fn_block(); };
+    unsafe { unit_fn_block(); };
+
+    {
+        unit_fn_block();
+        unit_fn_block();
+    }
+    {
+        unit_fn_block();
+        unit_fn_block();
+    }
+    {
+        unit_fn_block();
+        unit_fn_block();
+    };
+
+    { m!(()) };
+    { m!(()) };
+    { m!(()); };
+    m!(0);
+    m!(1);
+    m!(2);
+
+    for _ in [()] {
+        unit_fn_block();
+    }
+    for _ in [()] {
+        unit_fn_block()
+    }
+
+    let _d = || {
+        unit_fn_block();
+    };
+    let _d = || {
+        unit_fn_block()
+    };
+
+    { unit_fn_block(); };
+
+    unit_fn_block()
+}
\ No newline at end of file
diff --git a/tests/ui/semicolon_outside_block_if_singleline.rs b/tests/ui/semicolon_outside_block_if_singleline.rs
new file mode 100644
index 00000000000..21dd61445a5
--- /dev/null
+++ b/tests/ui/semicolon_outside_block_if_singleline.rs
@@ -0,0 +1,85 @@
+// run-rustfix
+#![allow(
+    unused,
+    clippy::unused_unit,
+    clippy::unnecessary_operation,
+    clippy::no_effect,
+    clippy::single_element_loop
+)]
+#![warn(clippy::semicolon_outside_block_if_singleline)]
+
+macro_rules! m {
+    (()) => {
+        ()
+    };
+    (0) => {{
+        0
+    };};
+    (1) => {{
+        1;
+    }};
+    (2) => {{
+        2;
+    }};
+}
+
+fn unit_fn_block() {
+    ()
+}
+
+#[rustfmt::skip]
+fn main() {
+    { unit_fn_block() }
+    unsafe { unit_fn_block() }
+
+    {
+        unit_fn_block()
+    }
+
+    { unit_fn_block() };
+    unsafe { unit_fn_block() };
+
+    { unit_fn_block(); }
+    unsafe { unit_fn_block(); }
+
+    { unit_fn_block(); };
+    unsafe { unit_fn_block(); };
+
+    {
+        unit_fn_block();
+        unit_fn_block()
+    };
+    {
+        unit_fn_block();
+        unit_fn_block();
+    }
+    {
+        unit_fn_block();
+        unit_fn_block();
+    };
+
+    { m!(()) };
+    { m!(()); }
+    { m!(()); };
+    m!(0);
+    m!(1);
+    m!(2);
+
+    for _ in [()] {
+        unit_fn_block();
+    }
+    for _ in [()] {
+        unit_fn_block()
+    }
+
+    let _d = || {
+        unit_fn_block();
+    };
+    let _d = || {
+        unit_fn_block()
+    };
+
+    { unit_fn_block(); };
+
+    unit_fn_block()
+}
\ No newline at end of file
diff --git a/tests/ui/semicolon_outside_block_if_singleline.stderr b/tests/ui/semicolon_outside_block_if_singleline.stderr
new file mode 100644
index 00000000000..dda083f2be3
--- /dev/null
+++ b/tests/ui/semicolon_outside_block_if_singleline.stderr
@@ -0,0 +1,54 @@
+error: consider moving the `;` outside the block for consistent formatting
+  --> $DIR/semicolon_outside_block_if_singleline.rs:42:5
+   |
+LL |     { unit_fn_block(); }
+   |     ^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::semicolon-outside-block-if-singleline` implied by `-D warnings`
+help: put the `;` here
+   |
+LL -     { unit_fn_block(); }
+LL +     { unit_fn_block() };
+   |
+
+error: consider moving the `;` outside the block for consistent formatting
+  --> $DIR/semicolon_outside_block_if_singleline.rs:43:5
+   |
+LL |     unsafe { unit_fn_block(); }
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: put the `;` here
+   |
+LL -     unsafe { unit_fn_block(); }
+LL +     unsafe { unit_fn_block() };
+   |
+
+error: consider moving the `;` inside the block for consistent formatting
+  --> $DIR/semicolon_outside_block_if_singleline.rs:48:5
+   |
+LL | /     {
+LL | |         unit_fn_block();
+LL | |         unit_fn_block()
+LL | |     };
+   | |_____^
+   |
+help: put the `;` here
+   |
+LL ~         unit_fn_block();
+LL ~     }
+   |
+
+error: consider moving the `;` outside the block for consistent formatting
+  --> $DIR/semicolon_outside_block_if_singleline.rs:62:5
+   |
+LL |     { m!(()); }
+   |     ^^^^^^^^^^^
+   |
+help: put the `;` here
+   |
+LL -     { m!(()); }
+LL +     { m!(()) };
+   |
+
+error: aborting due to 4 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From dfccebe3e01e8c63ea0fc2833550123e45091e5b Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Sun, 16 Apr 2023 23:36:01 -0500
Subject: make cargo test pass

---
 clippy_lints/src/semicolon_block.rs                  | 4 ++--
 tests/ui/semicolon_outside_block_if_singleline.fixed | 2 +-
 tests/ui/semicolon_outside_block_if_singleline.rs    | 2 +-
 3 files changed, 4 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/semicolon_block.rs b/clippy_lints/src/semicolon_block.rs
index d791100b9b9..eabe0e4619f 100644
--- a/clippy_lints/src/semicolon_block.rs
+++ b/clippy_lints/src/semicolon_block.rs
@@ -83,7 +83,7 @@ declare_clippy_lint! {
     /// # fn f(_: u32) {}
     /// # let x = 0;
     /// unsafe { f(x); }
-    /// 
+    ///
     /// unsafe {
     ///     let x = 1;
     ///     f(x)
@@ -94,7 +94,7 @@ declare_clippy_lint! {
     /// # fn f(_: u32) {}
     /// # let x = 0;
     /// unsafe { f(x) };
-    /// 
+    ///
     /// unsafe {
     ///     let x = 1;
     ///     f(x);
diff --git a/tests/ui/semicolon_outside_block_if_singleline.fixed b/tests/ui/semicolon_outside_block_if_singleline.fixed
index 592f9c49ed7..e1ecbf8588d 100644
--- a/tests/ui/semicolon_outside_block_if_singleline.fixed
+++ b/tests/ui/semicolon_outside_block_if_singleline.fixed
@@ -82,4 +82,4 @@ fn main() {
     { unit_fn_block(); };
 
     unit_fn_block()
-}
\ No newline at end of file
+}
diff --git a/tests/ui/semicolon_outside_block_if_singleline.rs b/tests/ui/semicolon_outside_block_if_singleline.rs
index 21dd61445a5..80fbb4ce2d5 100644
--- a/tests/ui/semicolon_outside_block_if_singleline.rs
+++ b/tests/ui/semicolon_outside_block_if_singleline.rs
@@ -82,4 +82,4 @@ fn main() {
     { unit_fn_block(); };
 
     unit_fn_block()
-}
\ No newline at end of file
+}
-- 
cgit 1.4.1-3-g733a5


From a7c3301b5884b33fc87f2e498f28426dfbcb1a84 Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Sun, 16 Apr 2023 23:56:21 -0500
Subject: refactor

---
 clippy_lints/src/semicolon_block.rs | 90 +++++++++++++++++++++++++------------
 1 file changed, 61 insertions(+), 29 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/semicolon_block.rs b/clippy_lints/src/semicolon_block.rs
index eabe0e4619f..d85d3b58305 100644
--- a/clippy_lints/src/semicolon_block.rs
+++ b/clippy_lints/src/semicolon_block.rs
@@ -125,11 +125,15 @@ impl LateLintPass<'_> for SemicolonBlock {
                     ..
                 } = stmt else { return };
                 semicolon_outside_block(cx, block, expr, span);
+                semicolon_outside_block_if_singleline_check_outside(cx, block, expr, stmt.span)
             },
             StmtKind::Semi(Expr {
                 kind: ExprKind::Block(block @ Block { expr: Some(tail), .. }, _),
                 ..
-            }) if !block.span.from_expansion() => semicolon_inside_block(cx, block, tail, stmt.span),
+            }) if !block.span.from_expansion() => {
+                semicolon_inside_block(cx, block, tail, stmt.span);
+                semicolon_outside_block_if_singleline_check_inside(cx, block, tail, stmt.span)
+            },
             _ => (),
         }
     }
@@ -139,8 +143,6 @@ fn semicolon_inside_block(cx: &LateContext<'_>, block: &Block<'_>, tail: &Expr<'
     let insert_span = tail.span.source_callsite().shrink_to_hi();
     let remove_span = semi_span.with_lo(block.span.hi());
 
-    check_semicolon_outside_block_if_singleline(cx, block, remove_span, insert_span, true, "inside");
-
     span_lint_and_then(
         cx,
         SEMICOLON_INSIDE_BLOCK,
@@ -163,8 +165,6 @@ fn semicolon_outside_block(cx: &LateContext<'_>, block: &Block<'_>, tail_stmt_ex
     let semi_span = cx.sess().source_map().stmt_span(semi_span, block.span);
     let remove_span = semi_span.with_lo(tail_stmt_expr.span.source_callsite().hi());
 
-    check_semicolon_outside_block_if_singleline(cx, block, remove_span, insert_span, false, "outside");
-
     span_lint_and_then(
         cx,
         SEMICOLON_OUTSIDE_BLOCK,
@@ -181,39 +181,54 @@ fn semicolon_outside_block(cx: &LateContext<'_>, block: &Block<'_>, tail_stmt_ex
     );
 }
 
-fn check_semicolon_outside_block_if_singleline(
+fn semicolon_outside_block_if_singleline_check_inside(
     cx: &LateContext<'_>,
     block: &Block<'_>,
-    remove_span: Span,
-    insert_span: Span,
-    inequality: bool,
-    ty: &str,
+    tail: &Expr<'_>,
+    semi_span: Span,
 ) {
-    let remove_line = cx
-        .sess()
-        .source_map()
-        .lookup_line(remove_span.lo())
-        .expect("failed to get `remove_span`'s line")
-        .line;
-    let insert_line = cx
-        .sess()
-        .source_map()
-        .lookup_line(insert_span.lo())
-        .expect("failed to get `insert_span`'s line")
-        .line;
+    let insert_span = tail.span.source_callsite().shrink_to_hi();
+    let remove_span = semi_span.with_lo(block.span.hi());
+
+    let (remove_line, insert_line) = get_line(cx, remove_span, insert_span);
+
+    if insert_line != remove_line {
+        span_lint_and_then(
+            cx,
+            SEMICOLON_OUTSIDE_BLOCK_IF_SINGLELINE,
+            block.span,
+            &format!("consider moving the `;` inside the block for consistent formatting"),
+            |diag| {
+                multispan_sugg_with_applicability(
+                    diag,
+                    "put the `;` here",
+                    Applicability::MachineApplicable,
+                    [(remove_span, String::new()), (insert_span, ";".to_owned())],
+                );
+            },
+        );
+    }
+}
 
-    let eq = if inequality {
-        remove_line != insert_line
-    } else {
-        remove_line == insert_line
-    };
+fn semicolon_outside_block_if_singleline_check_outside(
+    cx: &LateContext<'_>,
+    block: &Block<'_>,
+    tail_stmt_expr: &Expr<'_>,
+    semi_span: Span,
+) {
+    let insert_span = block.span.with_lo(block.span.hi());
+    // account for macro calls
+    let semi_span = cx.sess().source_map().stmt_span(semi_span, block.span);
+    let remove_span = semi_span.with_lo(tail_stmt_expr.span.source_callsite().hi());
+
+    let (remove_line, insert_line) = get_line(cx, remove_span, insert_span);
 
-    if eq {
+    if remove_line == insert_line {
         span_lint_and_then(
             cx,
             SEMICOLON_OUTSIDE_BLOCK_IF_SINGLELINE,
             block.span,
-            &format!("consider moving the `;` {ty} the block for consistent formatting"),
+            &format!("consider moving the `;` outside the block for consistent formatting"),
             |diag| {
                 multispan_sugg_with_applicability(
                     diag,
@@ -225,3 +240,20 @@ fn check_semicolon_outside_block_if_singleline(
         );
     }
 }
+
+fn get_line(cx: &LateContext<'_>, remove_span: Span, insert_span: Span) -> (usize, usize) {
+    let remove_line = cx
+        .sess()
+        .source_map()
+        .lookup_line(remove_span.lo())
+        .expect("failed to get `remove_span`'s line")
+        .line;
+    let insert_line = cx
+        .sess()
+        .source_map()
+        .lookup_line(insert_span.lo())
+        .expect("failed to get `insert_span`'s line")
+        .line;
+
+    (remove_line, insert_line)
+}
-- 
cgit 1.4.1-3-g733a5


From a57445d4d6c14adfd2103796a577805a04bb4db5 Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Sun, 16 Apr 2023 23:59:31 -0500
Subject: make cargo test pass, again

---
 clippy_lints/src/semicolon_block.rs | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/semicolon_block.rs b/clippy_lints/src/semicolon_block.rs
index d85d3b58305..c9689454c63 100644
--- a/clippy_lints/src/semicolon_block.rs
+++ b/clippy_lints/src/semicolon_block.rs
@@ -72,7 +72,7 @@ declare_clippy_lint! {
     ///
     /// ### Why is this bad?
     ///
-    /// Some may prefer if the  semicolon is outside if a block is only one
+    /// Some may prefer if the semicolon is outside if a block is only one
     /// expression, as this allows rustfmt to make it singleline. In the case that
     /// it isn't, it should be inside.
     /// Take a look at both `semicolon_inside_block` and `semicolon_outside_block` for alternatives.
@@ -125,14 +125,14 @@ impl LateLintPass<'_> for SemicolonBlock {
                     ..
                 } = stmt else { return };
                 semicolon_outside_block(cx, block, expr, span);
-                semicolon_outside_block_if_singleline_check_outside(cx, block, expr, stmt.span)
+                semicolon_outside_block_if_singleline_check_outside(cx, block, expr, stmt.span);
             },
             StmtKind::Semi(Expr {
                 kind: ExprKind::Block(block @ Block { expr: Some(tail), .. }, _),
                 ..
             }) if !block.span.from_expansion() => {
                 semicolon_inside_block(cx, block, tail, stmt.span);
-                semicolon_outside_block_if_singleline_check_inside(cx, block, tail, stmt.span)
+                semicolon_outside_block_if_singleline_check_inside(cx, block, tail, stmt.span);
             },
             _ => (),
         }
@@ -197,7 +197,7 @@ fn semicolon_outside_block_if_singleline_check_inside(
             cx,
             SEMICOLON_OUTSIDE_BLOCK_IF_SINGLELINE,
             block.span,
-            &format!("consider moving the `;` inside the block for consistent formatting"),
+            "consider moving the `;` inside the block for consistent formatting",
             |diag| {
                 multispan_sugg_with_applicability(
                     diag,
@@ -228,7 +228,7 @@ fn semicolon_outside_block_if_singleline_check_outside(
             cx,
             SEMICOLON_OUTSIDE_BLOCK_IF_SINGLELINE,
             block.span,
-            &format!("consider moving the `;` outside the block for consistent formatting"),
+            "consider moving the `;` outside the block for consistent formatting",
             |diag| {
                 multispan_sugg_with_applicability(
                     diag,
-- 
cgit 1.4.1-3-g733a5


From 80707aa95faae4acf8b35abf0daf4626afdb446e Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Mon, 17 Apr 2023 00:37:43 -0500
Subject: improve description a bit

---
 clippy_lints/src/semicolon_block.rs | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/semicolon_block.rs b/clippy_lints/src/semicolon_block.rs
index c9689454c63..8cdfbd5c495 100644
--- a/clippy_lints/src/semicolon_block.rs
+++ b/clippy_lints/src/semicolon_block.rs
@@ -72,10 +72,11 @@ declare_clippy_lint! {
     ///
     /// ### Why is this bad?
     ///
-    /// Some may prefer if the semicolon is outside if a block is only one
-    /// expression, as this allows rustfmt to make it singleline. In the case that
-    /// it isn't, it should be inside.
-    /// Take a look at both `semicolon_inside_block` and `semicolon_outside_block` for alternatives.
+    /// Some may prefer if the semicolon is outside of a block if it is only one
+    /// expression, as this allows rustfmt to make it singleline (and may just be
+    /// more readable). In the case that it isn't, it should be inside.
+    /// Take a look at both `semicolon_inside_block` and `semicolon_outside_block`
+    /// for alternatives.
     ///
     /// ### Example
     ///
-- 
cgit 1.4.1-3-g733a5


From 4fb38cfb297cd6ae71a883cf9c98f7083c8cdbcf Mon Sep 17 00:00:00 2001
From: timvisee <tim@visee.me>
Date: Mon, 17 Apr 2023 18:02:04 +0200
Subject: Rename std::mem::size_of_value to std::mem::size_of_val

---
 clippy_lints/src/manual_slice_size_calculation.rs |  4 ++--
 tests/ui/manual_slice_size_calculation.stderr     | 12 ++++++------
 2 files changed, 8 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_slice_size_calculation.rs b/clippy_lints/src/manual_slice_size_calculation.rs
index 92ee79453a3..ba01fd08530 100644
--- a/clippy_lints/src/manual_slice_size_calculation.rs
+++ b/clippy_lints/src/manual_slice_size_calculation.rs
@@ -38,7 +38,7 @@ declare_lint_pass!(ManualSliceSizeCalculation => [MANUAL_SLICE_SIZE_CALCULATION]
 
 impl<'tcx> LateLintPass<'tcx> for ManualSliceSizeCalculation {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
-        // Does not apply inside const because size_of_value is not cost in stable.
+        // Does not apply inside const because size_of_val is not cost in stable.
         if !in_constant(cx, expr.hir_id)
             && let ExprKind::Binary(ref op, left, right) = expr.kind
             && BinOpKind::Mul == op.node
@@ -50,7 +50,7 @@ impl<'tcx> LateLintPass<'tcx> for ManualSliceSizeCalculation {
                 expr.span,
                 "manual slice size calculation",
                 None,
-                "consider using std::mem::size_of_value instead");
+                "consider using std::mem::size_of_val instead");
         }
     }
 }
diff --git a/tests/ui/manual_slice_size_calculation.stderr b/tests/ui/manual_slice_size_calculation.stderr
index 4a24fc60a0f..7698d9782f0 100644
--- a/tests/ui/manual_slice_size_calculation.stderr
+++ b/tests/ui/manual_slice_size_calculation.stderr
@@ -4,7 +4,7 @@ error: manual slice size calculation
 LL |     let _ = s_i32.len() * size_of::<i32>(); // WARNING
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: consider using std::mem::size_of_value instead
+   = help: consider using std::mem::size_of_val instead
    = note: `-D clippy::manual-slice-size-calculation` implied by `-D warnings`
 
 error: manual slice size calculation
@@ -13,7 +13,7 @@ error: manual slice size calculation
 LL |     let _ = size_of::<i32>() * s_i32.len(); // WARNING
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: consider using std::mem::size_of_value instead
+   = help: consider using std::mem::size_of_val instead
 
 error: manual slice size calculation
   --> $DIR/manual_slice_size_calculation.rs:13:13
@@ -21,7 +21,7 @@ error: manual slice size calculation
 LL |     let _ = size_of::<i32>() * s_i32.len() * 5; // WARNING
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: consider using std::mem::size_of_value instead
+   = help: consider using std::mem::size_of_val instead
 
 error: manual slice size calculation
   --> $DIR/manual_slice_size_calculation.rs:17:13
@@ -29,7 +29,7 @@ error: manual slice size calculation
 LL |     let _ = len * size_of::<i32>(); // WARNING
    |             ^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: consider using std::mem::size_of_value instead
+   = help: consider using std::mem::size_of_val instead
 
 error: manual slice size calculation
   --> $DIR/manual_slice_size_calculation.rs:18:13
@@ -37,7 +37,7 @@ error: manual slice size calculation
 LL |     let _ = s_i32.len() * size; // WARNING
    |             ^^^^^^^^^^^^^^^^^^
    |
-   = help: consider using std::mem::size_of_value instead
+   = help: consider using std::mem::size_of_val instead
 
 error: manual slice size calculation
   --> $DIR/manual_slice_size_calculation.rs:19:13
@@ -45,7 +45,7 @@ error: manual slice size calculation
 LL |     let _ = len * size; // WARNING
    |             ^^^^^^^^^^
    |
-   = help: consider using std::mem::size_of_value instead
+   = help: consider using std::mem::size_of_val instead
 
 error: aborting due to 6 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 503fd56a423c8da7958aa3fc611b623270d02fde Mon Sep 17 00:00:00 2001
From: timvisee <tim@visee.me>
Date: Mon, 17 Apr 2023 20:25:42 +0200
Subject: Suggest applicable expression for manual slice size calculation lint

---
 clippy_lints/src/manual_slice_size_calculation.rs | 22 +++++++++++++++-------
 tests/ui/manual_slice_size_calculation.stderr     | 23 ++++++-----------------
 2 files changed, 21 insertions(+), 24 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_slice_size_calculation.rs b/clippy_lints/src/manual_slice_size_calculation.rs
index ba01fd08530..cef5b8361a4 100644
--- a/clippy_lints/src/manual_slice_size_calculation.rs
+++ b/clippy_lints/src/manual_slice_size_calculation.rs
@@ -1,5 +1,7 @@
-use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet_with_context;
 use clippy_utils::{expr_or_init, in_constant};
+use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
@@ -42,15 +44,21 @@ impl<'tcx> LateLintPass<'tcx> for ManualSliceSizeCalculation {
         if !in_constant(cx, expr.hir_id)
             && let ExprKind::Binary(ref op, left, right) = expr.kind
             && BinOpKind::Mul == op.node
-            && let Some(_receiver) = simplify(cx, left, right)
+            && let Some(receiver) = simplify(cx, left, right)
         {
-            span_lint_and_help(
+            let ctxt = expr.span.ctxt();
+            let mut app = Applicability::MachineApplicable;
+            let val_name = snippet_with_context(cx, receiver.span, ctxt, "slice", &mut app).0;
+
+            span_lint_and_sugg(
                 cx,
                 MANUAL_SLICE_SIZE_CALCULATION,
-                expr.span,
-                "manual slice size calculation",
-                None,
-                "consider using std::mem::size_of_val instead");
+                    expr.span,
+                    "manual slice size calculation",
+                    "try",
+                    format!("std::mem::size_of_val({val_name})"),
+                    Applicability::MachineApplicable,
+                );
         }
     }
 }
diff --git a/tests/ui/manual_slice_size_calculation.stderr b/tests/ui/manual_slice_size_calculation.stderr
index 7698d9782f0..b88f523ddcf 100644
--- a/tests/ui/manual_slice_size_calculation.stderr
+++ b/tests/ui/manual_slice_size_calculation.stderr
@@ -2,50 +2,39 @@ error: manual slice size calculation
   --> $DIR/manual_slice_size_calculation.rs:11:13
    |
 LL |     let _ = s_i32.len() * size_of::<i32>(); // WARNING
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::mem::size_of_val(s_i32)`
    |
-   = help: consider using std::mem::size_of_val instead
    = note: `-D clippy::manual-slice-size-calculation` implied by `-D warnings`
 
 error: manual slice size calculation
   --> $DIR/manual_slice_size_calculation.rs:12:13
    |
 LL |     let _ = size_of::<i32>() * s_i32.len(); // WARNING
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: consider using std::mem::size_of_val instead
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::mem::size_of_val(s_i32)`
 
 error: manual slice size calculation
   --> $DIR/manual_slice_size_calculation.rs:13:13
    |
 LL |     let _ = size_of::<i32>() * s_i32.len() * 5; // WARNING
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: consider using std::mem::size_of_val instead
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::mem::size_of_val(s_i32)`
 
 error: manual slice size calculation
   --> $DIR/manual_slice_size_calculation.rs:17:13
    |
 LL |     let _ = len * size_of::<i32>(); // WARNING
-   |             ^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: consider using std::mem::size_of_val instead
+   |             ^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::mem::size_of_val(s_i32)`
 
 error: manual slice size calculation
   --> $DIR/manual_slice_size_calculation.rs:18:13
    |
 LL |     let _ = s_i32.len() * size; // WARNING
-   |             ^^^^^^^^^^^^^^^^^^
-   |
-   = help: consider using std::mem::size_of_val instead
+   |             ^^^^^^^^^^^^^^^^^^ help: try: `std::mem::size_of_val(s_i32)`
 
 error: manual slice size calculation
   --> $DIR/manual_slice_size_calculation.rs:19:13
    |
 LL |     let _ = len * size; // WARNING
-   |             ^^^^^^^^^^
-   |
-   = help: consider using std::mem::size_of_val instead
+   |             ^^^^^^^^^^ help: try: `std::mem::size_of_val(s_i32)`
 
 error: aborting due to 6 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From b8fee8b5047f6a98992424c25f79468313044e1c Mon Sep 17 00:00:00 2001
From: timvisee <tim@visee.me>
Date: Mon, 17 Apr 2023 20:43:16 +0200
Subject: Add run-rustfix marker and test file

---
 clippy_lints/src/manual_slice_size_calculation.rs |  1 +
 tests/ui/manual_slice_size_calculation.fixed      | 37 +++++++++++++++++++++++
 tests/ui/manual_slice_size_calculation.rs         |  1 +
 tests/ui/manual_slice_size_calculation.stderr     | 12 ++++----
 4 files changed, 45 insertions(+), 6 deletions(-)
 create mode 100644 tests/ui/manual_slice_size_calculation.fixed

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_slice_size_calculation.rs b/clippy_lints/src/manual_slice_size_calculation.rs
index cef5b8361a4..d87dbe0a0a4 100644
--- a/clippy_lints/src/manual_slice_size_calculation.rs
+++ b/clippy_lints/src/manual_slice_size_calculation.rs
@@ -1,3 +1,4 @@
+// run-rustfix
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_context;
 use clippy_utils::{expr_or_init, in_constant};
diff --git a/tests/ui/manual_slice_size_calculation.fixed b/tests/ui/manual_slice_size_calculation.fixed
new file mode 100644
index 00000000000..2b18dd58c63
--- /dev/null
+++ b/tests/ui/manual_slice_size_calculation.fixed
@@ -0,0 +1,37 @@
+// run-rustfix
+#![allow(unused)]
+#![warn(clippy::manual_slice_size_calculation)]
+
+use core::mem::{align_of, size_of};
+
+fn main() {
+    let v_i32 = Vec::<i32>::new();
+    let s_i32 = v_i32.as_slice();
+
+    // True positives:
+    let _ = std::mem::size_of_val(s_i32); // WARNING
+    let _ = std::mem::size_of_val(s_i32); // WARNING
+    let _ = std::mem::size_of_val(s_i32) * 5; // WARNING
+
+    let len = s_i32.len();
+    let size = size_of::<i32>();
+    let _ = std::mem::size_of_val(s_i32); // WARNING
+    let _ = std::mem::size_of_val(s_i32); // WARNING
+    let _ = std::mem::size_of_val(s_i32); // WARNING
+
+    // True negatives:
+    let _ = size_of::<i32>() + s_i32.len(); // Ok, not a multiplication
+    let _ = size_of::<i32>() * s_i32.partition_point(|_| true); // Ok, not len()
+    let _ = size_of::<i32>() * v_i32.len(); // Ok, not a slice
+    let _ = align_of::<i32>() * s_i32.len(); // Ok, not size_of()
+    let _ = size_of::<u32>() * s_i32.len(); // Ok, different types
+
+    // False negatives:
+    let _ = 5 * size_of::<i32>() * s_i32.len(); // Ok (MISSED OPPORTUNITY)
+    let _ = size_of::<i32>() * 5 * s_i32.len(); // Ok (MISSED OPPORTUNITY)
+}
+
+const fn _const(s_i32: &[i32]) {
+    // True negative:
+    let _ = s_i32.len() * size_of::<i32>(); // Ok, can't use size_of_val in const
+}
diff --git a/tests/ui/manual_slice_size_calculation.rs b/tests/ui/manual_slice_size_calculation.rs
index 5082f931f3c..04adab76df2 100644
--- a/tests/ui/manual_slice_size_calculation.rs
+++ b/tests/ui/manual_slice_size_calculation.rs
@@ -1,3 +1,4 @@
+// run-rustfix
 #![allow(unused)]
 #![warn(clippy::manual_slice_size_calculation)]
 
diff --git a/tests/ui/manual_slice_size_calculation.stderr b/tests/ui/manual_slice_size_calculation.stderr
index b88f523ddcf..a6217652b88 100644
--- a/tests/ui/manual_slice_size_calculation.stderr
+++ b/tests/ui/manual_slice_size_calculation.stderr
@@ -1,5 +1,5 @@
 error: manual slice size calculation
-  --> $DIR/manual_slice_size_calculation.rs:11:13
+  --> $DIR/manual_slice_size_calculation.rs:12:13
    |
 LL |     let _ = s_i32.len() * size_of::<i32>(); // WARNING
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::mem::size_of_val(s_i32)`
@@ -7,31 +7,31 @@ LL |     let _ = s_i32.len() * size_of::<i32>(); // WARNING
    = note: `-D clippy::manual-slice-size-calculation` implied by `-D warnings`
 
 error: manual slice size calculation
-  --> $DIR/manual_slice_size_calculation.rs:12:13
+  --> $DIR/manual_slice_size_calculation.rs:13:13
    |
 LL |     let _ = size_of::<i32>() * s_i32.len(); // WARNING
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::mem::size_of_val(s_i32)`
 
 error: manual slice size calculation
-  --> $DIR/manual_slice_size_calculation.rs:13:13
+  --> $DIR/manual_slice_size_calculation.rs:14:13
    |
 LL |     let _ = size_of::<i32>() * s_i32.len() * 5; // WARNING
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::mem::size_of_val(s_i32)`
 
 error: manual slice size calculation
-  --> $DIR/manual_slice_size_calculation.rs:17:13
+  --> $DIR/manual_slice_size_calculation.rs:18:13
    |
 LL |     let _ = len * size_of::<i32>(); // WARNING
    |             ^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::mem::size_of_val(s_i32)`
 
 error: manual slice size calculation
-  --> $DIR/manual_slice_size_calculation.rs:18:13
+  --> $DIR/manual_slice_size_calculation.rs:19:13
    |
 LL |     let _ = s_i32.len() * size; // WARNING
    |             ^^^^^^^^^^^^^^^^^^ help: try: `std::mem::size_of_val(s_i32)`
 
 error: manual slice size calculation
-  --> $DIR/manual_slice_size_calculation.rs:19:13
+  --> $DIR/manual_slice_size_calculation.rs:20:13
    |
 LL |     let _ = len * size; // WARNING
    |             ^^^^^^^^^^ help: try: `std::mem::size_of_val(s_i32)`
-- 
cgit 1.4.1-3-g733a5


From a2580db6420aa6ea3ab34c467bb795e9e39ba449 Mon Sep 17 00:00:00 2001
From: timvisee <tim@visee.me>
Date: Mon, 17 Apr 2023 21:16:02 +0200
Subject: Use `clippy_utils::std_or_core` in manual slice size calculation lint

---
 clippy_lints/src/manual_slice_size_calculation.rs | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_slice_size_calculation.rs b/clippy_lints/src/manual_slice_size_calculation.rs
index d87dbe0a0a4..a5bb1c6f9bc 100644
--- a/clippy_lints/src/manual_slice_size_calculation.rs
+++ b/clippy_lints/src/manual_slice_size_calculation.rs
@@ -1,7 +1,7 @@
 // run-rustfix
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_context;
-use clippy_utils::{expr_or_init, in_constant};
+use clippy_utils::{expr_or_init, in_constant, std_or_core};
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
@@ -50,6 +50,7 @@ impl<'tcx> LateLintPass<'tcx> for ManualSliceSizeCalculation {
             let ctxt = expr.span.ctxt();
             let mut app = Applicability::MachineApplicable;
             let val_name = snippet_with_context(cx, receiver.span, ctxt, "slice", &mut app).0;
+            let Some(sugg) = std_or_core(cx) else { return };
 
             span_lint_and_sugg(
                 cx,
@@ -57,7 +58,7 @@ impl<'tcx> LateLintPass<'tcx> for ManualSliceSizeCalculation {
                     expr.span,
                     "manual slice size calculation",
                     "try",
-                    format!("std::mem::size_of_val({val_name})"),
+                    format!("{sugg}::mem::size_of_val({val_name})"),
                     Applicability::MachineApplicable,
                 );
         }
-- 
cgit 1.4.1-3-g733a5


From fa1efa8b104c71721d8317ae59819f6abf2d0ac8 Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Mon, 17 Apr 2023 20:57:56 -0500
Subject: refactor

---
 clippy_lints/src/semicolon_block.rs | 77 +++++++++++--------------------------
 1 file changed, 22 insertions(+), 55 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/semicolon_block.rs b/clippy_lints/src/semicolon_block.rs
index 8cdfbd5c495..7113f0c55d4 100644
--- a/clippy_lints/src/semicolon_block.rs
+++ b/clippy_lints/src/semicolon_block.rs
@@ -126,14 +126,12 @@ impl LateLintPass<'_> for SemicolonBlock {
                     ..
                 } = stmt else { return };
                 semicolon_outside_block(cx, block, expr, span);
-                semicolon_outside_block_if_singleline_check_outside(cx, block, expr, stmt.span);
             },
             StmtKind::Semi(Expr {
                 kind: ExprKind::Block(block @ Block { expr: Some(tail), .. }, _),
                 ..
             }) if !block.span.from_expansion() => {
                 semicolon_inside_block(cx, block, tail, stmt.span);
-                semicolon_outside_block_if_singleline_check_inside(cx, block, tail, stmt.span);
             },
             _ => (),
         }
@@ -144,6 +142,8 @@ fn semicolon_inside_block(cx: &LateContext<'_>, block: &Block<'_>, tail: &Expr<'
     let insert_span = tail.span.source_callsite().shrink_to_hi();
     let remove_span = semi_span.with_lo(block.span.hi());
 
+    semicolon_outside_block_if_singleline(cx, block, remove_span, insert_span, true, "inside");
+
     span_lint_and_then(
         cx,
         SEMICOLON_INSIDE_BLOCK,
@@ -166,6 +166,8 @@ fn semicolon_outside_block(cx: &LateContext<'_>, block: &Block<'_>, tail_stmt_ex
     let semi_span = cx.sess().source_map().stmt_span(semi_span, block.span);
     let remove_span = semi_span.with_lo(tail_stmt_expr.span.source_callsite().hi());
 
+    semicolon_outside_block_if_singleline(cx, block, remove_span, insert_span, false, "outside");
+
     span_lint_and_then(
         cx,
         SEMICOLON_OUTSIDE_BLOCK,
@@ -182,23 +184,28 @@ fn semicolon_outside_block(cx: &LateContext<'_>, block: &Block<'_>, tail_stmt_ex
     );
 }
 
-fn semicolon_outside_block_if_singleline_check_inside(
+fn semicolon_outside_block_if_singleline(
     cx: &LateContext<'_>,
     block: &Block<'_>,
-    tail: &Expr<'_>,
-    semi_span: Span,
+    remove_span: Span,
+    insert_span: Span,
+    inequality: bool,
+    ty: &str,
 ) {
-    let insert_span = tail.span.source_callsite().shrink_to_hi();
-    let remove_span = semi_span.with_lo(block.span.hi());
+    let (remove_line, insert_line) = (get_line(cx, remove_span), get_line(cx, insert_span));
 
-    let (remove_line, insert_line) = get_line(cx, remove_span, insert_span);
+    let eq = if inequality {
+        remove_line != insert_line
+    } else {
+        remove_line == insert_line
+    };
 
-    if insert_line != remove_line {
+    if eq {
         span_lint_and_then(
             cx,
             SEMICOLON_OUTSIDE_BLOCK_IF_SINGLELINE,
             block.span,
-            "consider moving the `;` inside the block for consistent formatting",
+            &format!("consider moving the `;` {ty} the block for consistent formatting"),
             |diag| {
                 multispan_sugg_with_applicability(
                     diag,
@@ -211,50 +218,10 @@ fn semicolon_outside_block_if_singleline_check_inside(
     }
 }
 
-fn semicolon_outside_block_if_singleline_check_outside(
-    cx: &LateContext<'_>,
-    block: &Block<'_>,
-    tail_stmt_expr: &Expr<'_>,
-    semi_span: Span,
-) {
-    let insert_span = block.span.with_lo(block.span.hi());
-    // account for macro calls
-    let semi_span = cx.sess().source_map().stmt_span(semi_span, block.span);
-    let remove_span = semi_span.with_lo(tail_stmt_expr.span.source_callsite().hi());
-
-    let (remove_line, insert_line) = get_line(cx, remove_span, insert_span);
-
-    if remove_line == insert_line {
-        span_lint_and_then(
-            cx,
-            SEMICOLON_OUTSIDE_BLOCK_IF_SINGLELINE,
-            block.span,
-            "consider moving the `;` outside the block for consistent formatting",
-            |diag| {
-                multispan_sugg_with_applicability(
-                    diag,
-                    "put the `;` here",
-                    Applicability::MachineApplicable,
-                    [(remove_span, String::new()), (insert_span, ";".to_owned())],
-                );
-            },
-        );
-    }
-}
-
-fn get_line(cx: &LateContext<'_>, remove_span: Span, insert_span: Span) -> (usize, usize) {
-    let remove_line = cx
-        .sess()
-        .source_map()
-        .lookup_line(remove_span.lo())
-        .expect("failed to get `remove_span`'s line")
-        .line;
-    let insert_line = cx
-        .sess()
+fn get_line(cx: &LateContext<'_>, span: Span) -> usize {
+    cx.sess()
         .source_map()
-        .lookup_line(insert_span.lo())
-        .expect("failed to get `insert_span`'s line")
-        .line;
-
-    (remove_line, insert_line)
+        .lookup_line(span.lo())
+        .expect("failed to get span's line")
+        .line
 }
-- 
cgit 1.4.1-3-g733a5


From 2f4f798f9bb693543356f05afe4e03822b5c51e7 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Tue, 18 Apr 2023 17:54:26 +0000
Subject: Ignore `manual_slice_size_calculation` in code from macro expansions

---
 clippy_lints/src/manual_slice_size_calculation.rs | 18 +++++++++---------
 tests/ui/manual_slice_size_calculation.fixed      |  9 +++++++++
 tests/ui/manual_slice_size_calculation.rs         |  9 +++++++++
 tests/ui/manual_slice_size_calculation.stderr     | 20 +++++++++++++-------
 4 files changed, 40 insertions(+), 16 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_slice_size_calculation.rs b/clippy_lints/src/manual_slice_size_calculation.rs
index a5bb1c6f9bc..703a6b25840 100644
--- a/clippy_lints/src/manual_slice_size_calculation.rs
+++ b/clippy_lints/src/manual_slice_size_calculation.rs
@@ -1,4 +1,3 @@
-// run-rustfix
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_context;
 use clippy_utils::{expr_or_init, in_constant, std_or_core};
@@ -45,6 +44,7 @@ impl<'tcx> LateLintPass<'tcx> for ManualSliceSizeCalculation {
         if !in_constant(cx, expr.hir_id)
             && let ExprKind::Binary(ref op, left, right) = expr.kind
             && BinOpKind::Mul == op.node
+            && !expr.span.from_expansion()
             && let Some(receiver) = simplify(cx, left, right)
         {
             let ctxt = expr.span.ctxt();
@@ -55,12 +55,12 @@ impl<'tcx> LateLintPass<'tcx> for ManualSliceSizeCalculation {
             span_lint_and_sugg(
                 cx,
                 MANUAL_SLICE_SIZE_CALCULATION,
-                    expr.span,
-                    "manual slice size calculation",
-                    "try",
-                    format!("{sugg}::mem::size_of_val({val_name})"),
-                    Applicability::MachineApplicable,
-                );
+                expr.span,
+                "manual slice size calculation",
+                "try",
+                format!("{sugg}::mem::size_of_val({val_name})"),
+                app,
+            );
         }
     }
 }
@@ -81,9 +81,9 @@ fn simplify_half<'tcx>(
     expr1: &'tcx Expr<'tcx>,
     expr2: &'tcx Expr<'tcx>,
 ) -> Option<&'tcx Expr<'tcx>> {
-    if
+    if !expr1.span.from_expansion()
         // expr1 is `[T1].len()`?
-        let ExprKind::MethodCall(method_path, receiver, _, _) = expr1.kind
+        && let ExprKind::MethodCall(method_path, receiver, _, _) = expr1.kind
         && method_path.ident.name == sym::len
         && let receiver_ty = cx.typeck_results().expr_ty(receiver)
         && let ty::Slice(ty1) = receiver_ty.peel_refs().kind()
diff --git a/tests/ui/manual_slice_size_calculation.fixed b/tests/ui/manual_slice_size_calculation.fixed
index 2b18dd58c63..71368a25e22 100644
--- a/tests/ui/manual_slice_size_calculation.fixed
+++ b/tests/ui/manual_slice_size_calculation.fixed
@@ -1,8 +1,12 @@
 // run-rustfix
+// aux-build:proc_macros.rs
 #![allow(unused)]
 #![warn(clippy::manual_slice_size_calculation)]
 
+extern crate proc_macros;
+
 use core::mem::{align_of, size_of};
+use proc_macros::external;
 
 fn main() {
     let v_i32 = Vec::<i32>::new();
@@ -19,6 +23,8 @@ fn main() {
     let _ = std::mem::size_of_val(s_i32); // WARNING
     let _ = std::mem::size_of_val(s_i32); // WARNING
 
+    let _ = std::mem::size_of_val(external!(&[1u64][..]));
+
     // True negatives:
     let _ = size_of::<i32>() + s_i32.len(); // Ok, not a multiplication
     let _ = size_of::<i32>() * s_i32.partition_point(|_| true); // Ok, not len()
@@ -26,6 +32,9 @@ fn main() {
     let _ = align_of::<i32>() * s_i32.len(); // Ok, not size_of()
     let _ = size_of::<u32>() * s_i32.len(); // Ok, different types
 
+    let _ = external!($s_i32.len() * size_of::<i32>());
+    let _ = external!($s_i32.len()) * size_of::<i32>();
+
     // False negatives:
     let _ = 5 * size_of::<i32>() * s_i32.len(); // Ok (MISSED OPPORTUNITY)
     let _ = size_of::<i32>() * 5 * s_i32.len(); // Ok (MISSED OPPORTUNITY)
diff --git a/tests/ui/manual_slice_size_calculation.rs b/tests/ui/manual_slice_size_calculation.rs
index 04adab76df2..5dd14aaede0 100644
--- a/tests/ui/manual_slice_size_calculation.rs
+++ b/tests/ui/manual_slice_size_calculation.rs
@@ -1,8 +1,12 @@
 // run-rustfix
+// aux-build:proc_macros.rs
 #![allow(unused)]
 #![warn(clippy::manual_slice_size_calculation)]
 
+extern crate proc_macros;
+
 use core::mem::{align_of, size_of};
+use proc_macros::external;
 
 fn main() {
     let v_i32 = Vec::<i32>::new();
@@ -19,6 +23,8 @@ fn main() {
     let _ = s_i32.len() * size; // WARNING
     let _ = len * size; // WARNING
 
+    let _ = external!(&[1u64][..]).len() * size_of::<u64>();
+
     // True negatives:
     let _ = size_of::<i32>() + s_i32.len(); // Ok, not a multiplication
     let _ = size_of::<i32>() * s_i32.partition_point(|_| true); // Ok, not len()
@@ -26,6 +32,9 @@ fn main() {
     let _ = align_of::<i32>() * s_i32.len(); // Ok, not size_of()
     let _ = size_of::<u32>() * s_i32.len(); // Ok, different types
 
+    let _ = external!($s_i32.len() * size_of::<i32>());
+    let _ = external!($s_i32.len()) * size_of::<i32>();
+
     // False negatives:
     let _ = 5 * size_of::<i32>() * s_i32.len(); // Ok (MISSED OPPORTUNITY)
     let _ = size_of::<i32>() * 5 * s_i32.len(); // Ok (MISSED OPPORTUNITY)
diff --git a/tests/ui/manual_slice_size_calculation.stderr b/tests/ui/manual_slice_size_calculation.stderr
index a6217652b88..e09d8057a3b 100644
--- a/tests/ui/manual_slice_size_calculation.stderr
+++ b/tests/ui/manual_slice_size_calculation.stderr
@@ -1,5 +1,5 @@
 error: manual slice size calculation
-  --> $DIR/manual_slice_size_calculation.rs:12:13
+  --> $DIR/manual_slice_size_calculation.rs:16:13
    |
 LL |     let _ = s_i32.len() * size_of::<i32>(); // WARNING
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::mem::size_of_val(s_i32)`
@@ -7,34 +7,40 @@ LL |     let _ = s_i32.len() * size_of::<i32>(); // WARNING
    = note: `-D clippy::manual-slice-size-calculation` implied by `-D warnings`
 
 error: manual slice size calculation
-  --> $DIR/manual_slice_size_calculation.rs:13:13
+  --> $DIR/manual_slice_size_calculation.rs:17:13
    |
 LL |     let _ = size_of::<i32>() * s_i32.len(); // WARNING
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::mem::size_of_val(s_i32)`
 
 error: manual slice size calculation
-  --> $DIR/manual_slice_size_calculation.rs:14:13
+  --> $DIR/manual_slice_size_calculation.rs:18:13
    |
 LL |     let _ = size_of::<i32>() * s_i32.len() * 5; // WARNING
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::mem::size_of_val(s_i32)`
 
 error: manual slice size calculation
-  --> $DIR/manual_slice_size_calculation.rs:18:13
+  --> $DIR/manual_slice_size_calculation.rs:22:13
    |
 LL |     let _ = len * size_of::<i32>(); // WARNING
    |             ^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::mem::size_of_val(s_i32)`
 
 error: manual slice size calculation
-  --> $DIR/manual_slice_size_calculation.rs:19:13
+  --> $DIR/manual_slice_size_calculation.rs:23:13
    |
 LL |     let _ = s_i32.len() * size; // WARNING
    |             ^^^^^^^^^^^^^^^^^^ help: try: `std::mem::size_of_val(s_i32)`
 
 error: manual slice size calculation
-  --> $DIR/manual_slice_size_calculation.rs:20:13
+  --> $DIR/manual_slice_size_calculation.rs:24:13
    |
 LL |     let _ = len * size; // WARNING
    |             ^^^^^^^^^^ help: try: `std::mem::size_of_val(s_i32)`
 
-error: aborting due to 6 previous errors
+error: manual slice size calculation
+  --> $DIR/manual_slice_size_calculation.rs:26:13
+   |
+LL |     let _ = external!(&[1u64][..]).len() * size_of::<u64>();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::mem::size_of_val(external!(&[1u64][..]))`
+
+error: aborting due to 7 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 4bc68f9c60c72c9608b49d20907843b37c91f39b Mon Sep 17 00:00:00 2001
From: Lukas Lueg <lukas.lueg@gmail.com>
Date: Sun, 16 Apr 2023 13:35:58 +0200
Subject: Add size-parameter to unecessary_box_returns

Fixes #10641
---
 book/src/lint_configuration.md                         |  9 +++++++++
 clippy_lints/src/lib.rs                                |  2 ++
 clippy_lints/src/unnecessary_box_returns.rs            | 15 +++++++++++----
 clippy_lints/src/utils/conf.rs                         |  4 ++++
 tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr |  1 +
 tests/ui/unnecessary_box_returns.rs                    | 10 ++++++++++
 6 files changed, 37 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/book/src/lint_configuration.md b/book/src/lint_configuration.md
index 78e1a55cff3..a702226e861 100644
--- a/book/src/lint_configuration.md
+++ b/book/src/lint_configuration.md
@@ -55,6 +55,7 @@ Please use that command to update the file and do not edit it by hand.
 | [suppress-restriction-lint-in-const](#suppress-restriction-lint-in-const) | `false` |
 | [missing-docs-in-crate-items](#missing-docs-in-crate-items) | `false` |
 | [future-size-threshold](#future-size-threshold) | `16384` |
+| [unnecessary-box-size](#unnecessary-box-size) | `128` |
 
 ### arithmetic-side-effects-allowed
 Suppress checking of the passed type names in all types of operations.
@@ -561,4 +562,12 @@ The maximum byte size a `Future` can have, before it triggers the `clippy::large
 * [large_futures](https://rust-lang.github.io/rust-clippy/master/index.html#large_futures)
 
 
+### unnecessary-box-size
+The byte size a `T` in `Box<T>` can have, below which it triggers the `clippy::unnecessary_box` lint
+
+**Default Value:** `128` (`u64`)
+
+* [unnecessary_box_returns](https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_box_returns)
+
+
 
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index b0ec14855e7..af2c7803601 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -950,9 +950,11 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(allow_attributes::AllowAttribute));
     store.register_late_pass(move |_| Box::new(manual_main_separator_str::ManualMainSeparatorStr::new(msrv())));
     store.register_late_pass(|_| Box::new(unnecessary_struct_initialization::UnnecessaryStruct));
+    let unnecessary_box_size = conf.unnecessary_box_size;
     store.register_late_pass(move |_| {
         Box::new(unnecessary_box_returns::UnnecessaryBoxReturns::new(
             avoid_breaking_exported_api,
+            unnecessary_box_size,
         ))
     });
     store.register_late_pass(|_| Box::new(lines_filter_map_ok::LinesFilterMapOk));
diff --git a/clippy_lints/src/unnecessary_box_returns.rs b/clippy_lints/src/unnecessary_box_returns.rs
index 912bcda630b..af1c8d83b4f 100644
--- a/clippy_lints/src/unnecessary_box_returns.rs
+++ b/clippy_lints/src/unnecessary_box_returns.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::{diagnostics::span_lint_and_then, ty::approx_ty_size};
 use rustc_errors::Applicability;
 use rustc_hir::{def_id::LocalDefId, FnDecl, FnRetTy, ImplItemKind, Item, ItemKind, Node, TraitItem, TraitItemKind};
 use rustc_lint::{LateContext, LateLintPass};
@@ -10,6 +10,9 @@ declare_clippy_lint! {
     ///
     /// Checks for a return type containing a `Box<T>` where `T` implements `Sized`
     ///
+    /// The lint ignores `Box<T>` where `T` is larger than `unnecessary_box_size`,
+    /// as returning a large `T` directly may be detrimental to performance.
+    ///
     /// ### Why is this bad?
     ///
     /// It's better to just return `T` in these cases. The caller may not need
@@ -36,14 +39,16 @@ declare_clippy_lint! {
 
 pub struct UnnecessaryBoxReturns {
     avoid_breaking_exported_api: bool,
+    maximum_size: u64,
 }
 
 impl_lint_pass!(UnnecessaryBoxReturns => [UNNECESSARY_BOX_RETURNS]);
 
 impl UnnecessaryBoxReturns {
-    pub fn new(avoid_breaking_exported_api: bool) -> Self {
+    pub fn new(avoid_breaking_exported_api: bool, maximum_size: u64) -> Self {
         Self {
             avoid_breaking_exported_api,
+            maximum_size,
         }
     }
 
@@ -71,8 +76,10 @@ impl UnnecessaryBoxReturns {
 
         let boxed_ty = return_ty.boxed_ty();
 
-        // it's sometimes useful to return Box<T> if T is unsized, so don't lint those
-        if boxed_ty.is_sized(cx.tcx, cx.param_env) {
+        // It's sometimes useful to return Box<T> if T is unsized, so don't lint those.
+        // Also, don't lint if we know that T is very large, in which case returning
+        // a Box<T> may be beneficial.
+        if boxed_ty.is_sized(cx.tcx, cx.param_env) && approx_ty_size(cx, boxed_ty) <= self.maximum_size {
             span_lint_and_then(
                 cx,
                 UNNECESSARY_BOX_RETURNS,
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 896a01af37d..67bb499c455 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -463,6 +463,10 @@ define_Conf! {
     ///
     /// The maximum byte size a `Future` can have, before it triggers the `clippy::large_futures` lint
     (future_size_threshold: u64 = 16 * 1024),
+    /// Lint: UNNECESSARY_BOX_RETURNS.
+    ///
+    /// The byte size a `T` in `Box<T>` can have, below which it triggers the `clippy::unnecessary_box` lint
+    (unnecessary_box_size: u64 = 128),
 }
 
 /// Search for the configuration file.
diff --git a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
index 8447c31722d..36b372b36f4 100644
--- a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
+++ b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
@@ -46,6 +46,7 @@ error: error reading Clippy's configuration file `$DIR/clippy.toml`: unknown fie
            too-many-lines-threshold
            trivial-copy-size-limit
            type-complexity-threshold
+           unnecessary-box-size
            unreadable-literal-lint-fractions
            upper-case-acronyms-aggressive
            vec-box-size-threshold
diff --git a/tests/ui/unnecessary_box_returns.rs b/tests/ui/unnecessary_box_returns.rs
index fe60d929759..ce7cc2e97cb 100644
--- a/tests/ui/unnecessary_box_returns.rs
+++ b/tests/ui/unnecessary_box_returns.rs
@@ -54,6 +54,16 @@ fn string() -> String {
     String::from("Hello, world")
 }
 
+struct Huge([u8; 500]);
+struct HasHuge(Box<Huge>);
+
+impl HasHuge {
+    // don't lint: The size of `Huge` is very large
+    fn into_huge(self) -> Box<Huge> {
+        self.0
+    }
+}
+
 fn main() {
     // don't lint: this is a closure
     let a = || -> Box<usize> { Box::new(5) };
-- 
cgit 1.4.1-3-g733a5


From 747ff0656b2f15b13d34161e7652339cd06d80bf Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Wed, 19 Apr 2023 14:55:18 +0200
Subject: Update version attribute for 1.69 lints

---
 clippy_lints/src/functions/mod.rs                 | 2 +-
 clippy_lints/src/methods/mod.rs                   | 2 +-
 clippy_lints/src/multiple_unsafe_ops_per_block.rs | 2 +-
 clippy_lints/src/question_mark_used.rs            | 2 +-
 clippy_lints/src/significant_drop_tightening.rs   | 2 +-
 5 files changed, 5 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/functions/mod.rs b/clippy_lints/src/functions/mod.rs
index 7c5e44bb7dc..ac2d253fe83 100644
--- a/clippy_lints/src/functions/mod.rs
+++ b/clippy_lints/src/functions/mod.rs
@@ -348,7 +348,7 @@ declare_clippy_lint! {
     /// 	// [...]
     /// }
     /// ```
-    #[clippy::version = "1.68.0"]
+    #[clippy::version = "1.69.0"]
     pub IMPL_TRAIT_IN_PARAMS,
     restriction,
     "`impl Trait` is used in the function's parameters"
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index c213030f6a8..9cafbc2e5f5 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3185,7 +3185,7 @@ declare_clippy_lint! {
     /// ```rust
     /// std::process::Command::new("echo").args(["-n", "hello"]).spawn().unwrap();
     /// ```
-    #[clippy::version = "1.67.0"]
+    #[clippy::version = "1.69.0"]
     pub SUSPICIOUS_COMMAND_ARG_SPACE,
     suspicious,
     "single command line argument that looks like it should be multiple arguments"
diff --git a/clippy_lints/src/multiple_unsafe_ops_per_block.rs b/clippy_lints/src/multiple_unsafe_ops_per_block.rs
index 5418616ded0..2abdfacd276 100644
--- a/clippy_lints/src/multiple_unsafe_ops_per_block.rs
+++ b/clippy_lints/src/multiple_unsafe_ops_per_block.rs
@@ -59,7 +59,7 @@ declare_clippy_lint! {
     ///     unsafe { char::from_u32_unchecked(int_value) }
     /// }
     /// ```
-    #[clippy::version = "1.68.0"]
+    #[clippy::version = "1.69.0"]
     pub MULTIPLE_UNSAFE_OPS_PER_BLOCK,
     restriction,
     "more than one unsafe operation per `unsafe` block"
diff --git a/clippy_lints/src/question_mark_used.rs b/clippy_lints/src/question_mark_used.rs
index 9b678e8d753..ff66b8a0095 100644
--- a/clippy_lints/src/question_mark_used.rs
+++ b/clippy_lints/src/question_mark_used.rs
@@ -24,7 +24,7 @@ declare_clippy_lint! {
     /// ```ignore
     /// utility_macro!(expr);
     /// ```
-    #[clippy::version = "pre 1.29.0"]
+    #[clippy::version = "1.69.0"]
     pub QUESTION_MARK_USED,
     restriction,
     "complains if the question mark operator is used"
diff --git a/clippy_lints/src/significant_drop_tightening.rs b/clippy_lints/src/significant_drop_tightening.rs
index 869358fb1ba..003c5e7d151 100644
--- a/clippy_lints/src/significant_drop_tightening.rs
+++ b/clippy_lints/src/significant_drop_tightening.rs
@@ -46,7 +46,7 @@ declare_clippy_lint! {
     ///     do_heavy_computation_that_takes_time(owned_rslt);
     /// }
     /// ```
-    #[clippy::version = "1.67.0"]
+    #[clippy::version = "1.69.0"]
     pub SIGNIFICANT_DROP_TIGHTENING,
     nursery,
     "Searches for elements marked with `#[clippy::has_significant_drop]` that could be early dropped but are in fact dropped at the end of their scopes"
-- 
cgit 1.4.1-3-g733a5


From 3db7352b8180bfd66bae2252139340e53f7d670b Mon Sep 17 00:00:00 2001
From: Caio <c410.f3r@gmail.com>
Date: Wed, 19 Apr 2023 10:58:00 -0300
Subject: [arithmetic_side_effects] Fix #10590

---
 .../src/operators/arithmetic_side_effects.rs       |  31 +++
 tests/ui/arithmetic_side_effects.rs                |  22 ++
 tests/ui/arithmetic_side_effects.stderr            | 268 ++++++++++++---------
 3 files changed, 211 insertions(+), 110 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/operators/arithmetic_side_effects.rs b/clippy_lints/src/operators/arithmetic_side_effects.rs
index 6c050c2cb8b..2e3925f53dd 100644
--- a/clippy_lints/src/operators/arithmetic_side_effects.rs
+++ b/clippy_lints/src/operators/arithmetic_side_effects.rs
@@ -185,6 +185,34 @@ impl ArithmeticSideEffects {
         }
     }
 
+    /// There are some integer methods like `wrapping_div` that will panic depending on the
+    /// provided input.
+    fn manage_method_call<'tcx>(
+        &mut self,
+        args: &[hir::Expr<'tcx>],
+        cx: &LateContext<'tcx>,
+        ps: &hir::PathSegment<'tcx>,
+        receiver: &hir::Expr<'tcx>,
+    ) {
+        const METHODS: &[&str] = &["saturating_div", "wrapping_div", "wrapping_rem", "wrapping_rem_euclid"];
+        let Some(arg) = args.first() else { return; };
+        if constant_simple(cx, cx.typeck_results(), receiver).is_some() {
+            return;
+        }
+        let instance_ty = cx.typeck_results().expr_ty(receiver);
+        if !Self::is_integral(instance_ty) {
+            return;
+        }
+        if METHODS.iter().copied().all(|method| method != ps.ident.as_str()) {
+            return;
+        }
+        let (actual_arg, _) = peel_hir_expr_refs(arg);
+        match Self::literal_integer(cx, actual_arg) {
+            None | Some(0) => self.issue_lint(cx, arg),
+            Some(_) => {},
+        }
+    }
+
     fn manage_unary_ops<'tcx>(
         &mut self,
         cx: &LateContext<'tcx>,
@@ -224,6 +252,9 @@ impl<'tcx> LateLintPass<'tcx> for ArithmeticSideEffects {
             hir::ExprKind::AssignOp(op, lhs, rhs) | hir::ExprKind::Binary(op, lhs, rhs) => {
                 self.manage_bin_ops(cx, expr, op, lhs, rhs);
             },
+            hir::ExprKind::MethodCall(ps, receiver, args, _) => {
+                self.manage_method_call(args, cx, ps, receiver);
+            },
             hir::ExprKind::Unary(un_op, un_expr) => {
                 self.manage_unary_ops(cx, expr, un_expr, *un_op);
             },
diff --git a/tests/ui/arithmetic_side_effects.rs b/tests/ui/arithmetic_side_effects.rs
index ab7e66a264d..840bf989228 100644
--- a/tests/ui/arithmetic_side_effects.rs
+++ b/tests/ui/arithmetic_side_effects.rs
@@ -276,6 +276,17 @@ pub fn non_overflowing_ops_or_ops_already_handled_by_the_compiler_should_not_tri
     _n = &1 * _n;
     _n = 23 + 85;
 
+    // Method
+    _n.saturating_div(1);
+    _n.wrapping_div(1);
+    _n.wrapping_rem(1);
+    _n.wrapping_rem_euclid(1);
+
+    _n.saturating_div(1);
+    _n.checked_div(1);
+    _n.checked_rem(1);
+    _n.checked_rem_euclid(1);
+
     // Unary
     _n = -2147483647;
     _n = -i32::MAX;
@@ -383,6 +394,17 @@ pub fn unknown_ops_or_runtime_ops_that_can_overflow() {
     _custom = Custom << _custom;
     _custom = &Custom << _custom;
 
+    // Method
+    _n.saturating_div(0);
+    _n.wrapping_div(0);
+    _n.wrapping_rem(0);
+    _n.wrapping_rem_euclid(0);
+
+    _n.saturating_div(_n);
+    _n.wrapping_div(_n);
+    _n.wrapping_rem(_n);
+    _n.wrapping_rem_euclid(_n);
+
     // Unary
     _n = -_n;
     _n = -&_n;
diff --git a/tests/ui/arithmetic_side_effects.stderr b/tests/ui/arithmetic_side_effects.stderr
index a036cadb9a0..e9a626643ff 100644
--- a/tests/ui/arithmetic_side_effects.stderr
+++ b/tests/ui/arithmetic_side_effects.stderr
@@ -1,5 +1,5 @@
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:293:5
+  --> $DIR/arithmetic_side_effects.rs:304:5
    |
 LL |     _n += 1;
    |     ^^^^^^^
@@ -7,652 +7,700 @@ LL |     _n += 1;
    = note: `-D clippy::arithmetic-side-effects` implied by `-D warnings`
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:294:5
+  --> $DIR/arithmetic_side_effects.rs:305:5
    |
 LL |     _n += &1;
    |     ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:295:5
+  --> $DIR/arithmetic_side_effects.rs:306:5
    |
 LL |     _n -= 1;
    |     ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:296:5
+  --> $DIR/arithmetic_side_effects.rs:307:5
    |
 LL |     _n -= &1;
    |     ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:297:5
+  --> $DIR/arithmetic_side_effects.rs:308:5
    |
 LL |     _n /= 0;
    |     ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:298:5
+  --> $DIR/arithmetic_side_effects.rs:309:5
    |
 LL |     _n /= &0;
    |     ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:299:5
+  --> $DIR/arithmetic_side_effects.rs:310:5
    |
 LL |     _n %= 0;
    |     ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:300:5
+  --> $DIR/arithmetic_side_effects.rs:311:5
    |
 LL |     _n %= &0;
    |     ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:301:5
+  --> $DIR/arithmetic_side_effects.rs:312:5
    |
 LL |     _n *= 2;
    |     ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:302:5
+  --> $DIR/arithmetic_side_effects.rs:313:5
    |
 LL |     _n *= &2;
    |     ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:303:5
+  --> $DIR/arithmetic_side_effects.rs:314:5
    |
 LL |     _n += -1;
    |     ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:304:5
+  --> $DIR/arithmetic_side_effects.rs:315:5
    |
 LL |     _n += &-1;
    |     ^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:305:5
+  --> $DIR/arithmetic_side_effects.rs:316:5
    |
 LL |     _n -= -1;
    |     ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:306:5
+  --> $DIR/arithmetic_side_effects.rs:317:5
    |
 LL |     _n -= &-1;
    |     ^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:307:5
+  --> $DIR/arithmetic_side_effects.rs:318:5
    |
 LL |     _n /= -0;
    |     ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:308:5
+  --> $DIR/arithmetic_side_effects.rs:319:5
    |
 LL |     _n /= &-0;
    |     ^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:309:5
+  --> $DIR/arithmetic_side_effects.rs:320:5
    |
 LL |     _n %= -0;
    |     ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:310:5
+  --> $DIR/arithmetic_side_effects.rs:321:5
    |
 LL |     _n %= &-0;
    |     ^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:311:5
+  --> $DIR/arithmetic_side_effects.rs:322:5
    |
 LL |     _n *= -2;
    |     ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:312:5
+  --> $DIR/arithmetic_side_effects.rs:323:5
    |
 LL |     _n *= &-2;
    |     ^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:313:5
+  --> $DIR/arithmetic_side_effects.rs:324:5
    |
 LL |     _custom += Custom;
    |     ^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:314:5
+  --> $DIR/arithmetic_side_effects.rs:325:5
    |
 LL |     _custom += &Custom;
    |     ^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:315:5
+  --> $DIR/arithmetic_side_effects.rs:326:5
    |
 LL |     _custom -= Custom;
    |     ^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:316:5
+  --> $DIR/arithmetic_side_effects.rs:327:5
    |
 LL |     _custom -= &Custom;
    |     ^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:317:5
+  --> $DIR/arithmetic_side_effects.rs:328:5
    |
 LL |     _custom /= Custom;
    |     ^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:318:5
+  --> $DIR/arithmetic_side_effects.rs:329:5
    |
 LL |     _custom /= &Custom;
    |     ^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:319:5
+  --> $DIR/arithmetic_side_effects.rs:330:5
    |
 LL |     _custom %= Custom;
    |     ^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:320:5
+  --> $DIR/arithmetic_side_effects.rs:331:5
    |
 LL |     _custom %= &Custom;
    |     ^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:321:5
+  --> $DIR/arithmetic_side_effects.rs:332:5
    |
 LL |     _custom *= Custom;
    |     ^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:322:5
+  --> $DIR/arithmetic_side_effects.rs:333:5
    |
 LL |     _custom *= &Custom;
    |     ^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:323:5
+  --> $DIR/arithmetic_side_effects.rs:334:5
    |
 LL |     _custom >>= Custom;
    |     ^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:324:5
+  --> $DIR/arithmetic_side_effects.rs:335:5
    |
 LL |     _custom >>= &Custom;
    |     ^^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:325:5
+  --> $DIR/arithmetic_side_effects.rs:336:5
    |
 LL |     _custom <<= Custom;
    |     ^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:326:5
+  --> $DIR/arithmetic_side_effects.rs:337:5
    |
 LL |     _custom <<= &Custom;
    |     ^^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:327:5
+  --> $DIR/arithmetic_side_effects.rs:338:5
    |
 LL |     _custom += -Custom;
    |     ^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:328:5
+  --> $DIR/arithmetic_side_effects.rs:339:5
    |
 LL |     _custom += &-Custom;
    |     ^^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:329:5
+  --> $DIR/arithmetic_side_effects.rs:340:5
    |
 LL |     _custom -= -Custom;
    |     ^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:330:5
+  --> $DIR/arithmetic_side_effects.rs:341:5
    |
 LL |     _custom -= &-Custom;
    |     ^^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:331:5
+  --> $DIR/arithmetic_side_effects.rs:342:5
    |
 LL |     _custom /= -Custom;
    |     ^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:332:5
+  --> $DIR/arithmetic_side_effects.rs:343:5
    |
 LL |     _custom /= &-Custom;
    |     ^^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:333:5
+  --> $DIR/arithmetic_side_effects.rs:344:5
    |
 LL |     _custom %= -Custom;
    |     ^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:334:5
+  --> $DIR/arithmetic_side_effects.rs:345:5
    |
 LL |     _custom %= &-Custom;
    |     ^^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:335:5
+  --> $DIR/arithmetic_side_effects.rs:346:5
    |
 LL |     _custom *= -Custom;
    |     ^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:336:5
+  --> $DIR/arithmetic_side_effects.rs:347:5
    |
 LL |     _custom *= &-Custom;
    |     ^^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:337:5
+  --> $DIR/arithmetic_side_effects.rs:348:5
    |
 LL |     _custom >>= -Custom;
    |     ^^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:338:5
+  --> $DIR/arithmetic_side_effects.rs:349:5
    |
 LL |     _custom >>= &-Custom;
    |     ^^^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:339:5
+  --> $DIR/arithmetic_side_effects.rs:350:5
    |
 LL |     _custom <<= -Custom;
    |     ^^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:340:5
+  --> $DIR/arithmetic_side_effects.rs:351:5
    |
 LL |     _custom <<= &-Custom;
    |     ^^^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:343:10
+  --> $DIR/arithmetic_side_effects.rs:354:10
    |
 LL |     _n = _n + 1;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:344:10
+  --> $DIR/arithmetic_side_effects.rs:355:10
    |
 LL |     _n = _n + &1;
    |          ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:345:10
+  --> $DIR/arithmetic_side_effects.rs:356:10
    |
 LL |     _n = 1 + _n;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:346:10
+  --> $DIR/arithmetic_side_effects.rs:357:10
    |
 LL |     _n = &1 + _n;
    |          ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:347:10
+  --> $DIR/arithmetic_side_effects.rs:358:10
    |
 LL |     _n = _n - 1;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:348:10
+  --> $DIR/arithmetic_side_effects.rs:359:10
    |
 LL |     _n = _n - &1;
    |          ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:349:10
+  --> $DIR/arithmetic_side_effects.rs:360:10
    |
 LL |     _n = 1 - _n;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:350:10
+  --> $DIR/arithmetic_side_effects.rs:361:10
    |
 LL |     _n = &1 - _n;
    |          ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:351:10
+  --> $DIR/arithmetic_side_effects.rs:362:10
    |
 LL |     _n = _n / 0;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:352:10
+  --> $DIR/arithmetic_side_effects.rs:363:10
    |
 LL |     _n = _n / &0;
    |          ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:353:10
+  --> $DIR/arithmetic_side_effects.rs:364:10
    |
 LL |     _n = _n % 0;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:354:10
+  --> $DIR/arithmetic_side_effects.rs:365:10
    |
 LL |     _n = _n % &0;
    |          ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:355:10
+  --> $DIR/arithmetic_side_effects.rs:366:10
    |
 LL |     _n = _n * 2;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:356:10
+  --> $DIR/arithmetic_side_effects.rs:367:10
    |
 LL |     _n = _n * &2;
    |          ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:357:10
+  --> $DIR/arithmetic_side_effects.rs:368:10
    |
 LL |     _n = 2 * _n;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:358:10
+  --> $DIR/arithmetic_side_effects.rs:369:10
    |
 LL |     _n = &2 * _n;
    |          ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:359:10
+  --> $DIR/arithmetic_side_effects.rs:370:10
    |
 LL |     _n = 23 + &85;
    |          ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:360:10
+  --> $DIR/arithmetic_side_effects.rs:371:10
    |
 LL |     _n = &23 + 85;
    |          ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:361:10
+  --> $DIR/arithmetic_side_effects.rs:372:10
    |
 LL |     _n = &23 + &85;
    |          ^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:362:15
+  --> $DIR/arithmetic_side_effects.rs:373:15
    |
 LL |     _custom = _custom + _custom;
    |               ^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:363:15
+  --> $DIR/arithmetic_side_effects.rs:374:15
    |
 LL |     _custom = _custom + &_custom;
    |               ^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:364:15
+  --> $DIR/arithmetic_side_effects.rs:375:15
    |
 LL |     _custom = Custom + _custom;
    |               ^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:365:15
+  --> $DIR/arithmetic_side_effects.rs:376:15
    |
 LL |     _custom = &Custom + _custom;
    |               ^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:366:15
+  --> $DIR/arithmetic_side_effects.rs:377:15
    |
 LL |     _custom = _custom - Custom;
    |               ^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:367:15
+  --> $DIR/arithmetic_side_effects.rs:378:15
    |
 LL |     _custom = _custom - &Custom;
    |               ^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:368:15
+  --> $DIR/arithmetic_side_effects.rs:379:15
    |
 LL |     _custom = Custom - _custom;
    |               ^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:369:15
+  --> $DIR/arithmetic_side_effects.rs:380:15
    |
 LL |     _custom = &Custom - _custom;
    |               ^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:370:15
+  --> $DIR/arithmetic_side_effects.rs:381:15
    |
 LL |     _custom = _custom / Custom;
    |               ^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:371:15
+  --> $DIR/arithmetic_side_effects.rs:382:15
    |
 LL |     _custom = _custom / &Custom;
    |               ^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:372:15
+  --> $DIR/arithmetic_side_effects.rs:383:15
    |
 LL |     _custom = _custom % Custom;
    |               ^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:373:15
+  --> $DIR/arithmetic_side_effects.rs:384:15
    |
 LL |     _custom = _custom % &Custom;
    |               ^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:374:15
+  --> $DIR/arithmetic_side_effects.rs:385:15
    |
 LL |     _custom = _custom * Custom;
    |               ^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:375:15
+  --> $DIR/arithmetic_side_effects.rs:386:15
    |
 LL |     _custom = _custom * &Custom;
    |               ^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:376:15
+  --> $DIR/arithmetic_side_effects.rs:387:15
    |
 LL |     _custom = Custom * _custom;
    |               ^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:377:15
+  --> $DIR/arithmetic_side_effects.rs:388:15
    |
 LL |     _custom = &Custom * _custom;
    |               ^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:378:15
+  --> $DIR/arithmetic_side_effects.rs:389:15
    |
 LL |     _custom = Custom + &Custom;
    |               ^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:379:15
+  --> $DIR/arithmetic_side_effects.rs:390:15
    |
 LL |     _custom = &Custom + Custom;
    |               ^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:380:15
+  --> $DIR/arithmetic_side_effects.rs:391:15
    |
 LL |     _custom = &Custom + &Custom;
    |               ^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:381:15
+  --> $DIR/arithmetic_side_effects.rs:392:15
    |
 LL |     _custom = _custom >> _custom;
    |               ^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:382:15
+  --> $DIR/arithmetic_side_effects.rs:393:15
    |
 LL |     _custom = _custom >> &_custom;
    |               ^^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:383:15
+  --> $DIR/arithmetic_side_effects.rs:394:15
    |
 LL |     _custom = Custom << _custom;
    |               ^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:384:15
+  --> $DIR/arithmetic_side_effects.rs:395:15
    |
 LL |     _custom = &Custom << _custom;
    |               ^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:387:10
+  --> $DIR/arithmetic_side_effects.rs:398:23
+   |
+LL |     _n.saturating_div(0);
+   |                       ^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:399:21
+   |
+LL |     _n.wrapping_div(0);
+   |                     ^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:400:21
+   |
+LL |     _n.wrapping_rem(0);
+   |                     ^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:401:28
+   |
+LL |     _n.wrapping_rem_euclid(0);
+   |                            ^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:403:23
+   |
+LL |     _n.saturating_div(_n);
+   |                       ^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:404:21
+   |
+LL |     _n.wrapping_div(_n);
+   |                     ^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:405:21
+   |
+LL |     _n.wrapping_rem(_n);
+   |                     ^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:406:28
+   |
+LL |     _n.wrapping_rem_euclid(_n);
+   |                            ^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:409:10
    |
 LL |     _n = -_n;
    |          ^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:388:10
+  --> $DIR/arithmetic_side_effects.rs:410:10
    |
 LL |     _n = -&_n;
    |          ^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:389:15
+  --> $DIR/arithmetic_side_effects.rs:411:15
    |
 LL |     _custom = -_custom;
    |               ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:390:15
+  --> $DIR/arithmetic_side_effects.rs:412:15
    |
 LL |     _custom = -&_custom;
    |               ^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:399:5
+  --> $DIR/arithmetic_side_effects.rs:421:5
    |
 LL |     1 + i;
    |     ^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:400:5
+  --> $DIR/arithmetic_side_effects.rs:422:5
    |
 LL |     i * 2;
    |     ^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:401:5
+  --> $DIR/arithmetic_side_effects.rs:423:5
    |
 LL |     1 % i / 2;
    |     ^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:402:5
+  --> $DIR/arithmetic_side_effects.rs:424:5
    |
 LL |     i - 2 + 2 - i;
    |     ^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:403:5
+  --> $DIR/arithmetic_side_effects.rs:425:5
    |
 LL |     -i;
    |     ^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:414:5
+  --> $DIR/arithmetic_side_effects.rs:436:5
    |
 LL |     i += 1;
    |     ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:415:5
+  --> $DIR/arithmetic_side_effects.rs:437:5
    |
 LL |     i -= 1;
    |     ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:416:5
+  --> $DIR/arithmetic_side_effects.rs:438:5
    |
 LL |     i *= 2;
    |     ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:418:5
+  --> $DIR/arithmetic_side_effects.rs:440:5
    |
 LL |     i /= 0;
    |     ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:420:5
+  --> $DIR/arithmetic_side_effects.rs:442:5
    |
 LL |     i /= var1;
    |     ^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:421:5
+  --> $DIR/arithmetic_side_effects.rs:443:5
    |
 LL |     i /= var2;
    |     ^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:423:5
+  --> $DIR/arithmetic_side_effects.rs:445:5
    |
 LL |     i %= 0;
    |     ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:425:5
+  --> $DIR/arithmetic_side_effects.rs:447:5
    |
 LL |     i %= var1;
    |     ^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:426:5
+  --> $DIR/arithmetic_side_effects.rs:448:5
    |
 LL |     i %= var2;
    |     ^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> $DIR/arithmetic_side_effects.rs:436:5
+  --> $DIR/arithmetic_side_effects.rs:458:5
    |
 LL |     10 / a
    |     ^^^^^^
 
-error: aborting due to 109 previous errors
+error: aborting due to 117 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 2745c878423dd120b5e17ec6260db455f81a6b71 Mon Sep 17 00:00:00 2001
From: Lukas Lueg <lukas.lueg@gmail.com>
Date: Wed, 19 Apr 2023 20:04:17 +0200
Subject: Dont suggest suboptimal_flops unavailable in nostd

Fixes #10634
---
 clippy_lints/src/floating_point_arithmetic.rs | 13 ++++++++---
 tests/ui/floating_point_arithmetic_nostd.rs   | 31 +++++++++++++++++++++++++++
 2 files changed, 41 insertions(+), 3 deletions(-)
 create mode 100644 tests/ui/floating_point_arithmetic_nostd.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/floating_point_arithmetic.rs b/clippy_lints/src/floating_point_arithmetic.rs
index f95b628e6c3..b50e47e5a1c 100644
--- a/clippy_lints/src/floating_point_arithmetic.rs
+++ b/clippy_lints/src/floating_point_arithmetic.rs
@@ -2,9 +2,10 @@ use clippy_utils::consts::{
     constant, constant_simple, Constant,
     Constant::{Int, F32, F64},
 };
-use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::higher;
-use clippy_utils::{eq_expr_value, get_parent_expr, in_constant, numeric_literal, peel_blocks, sugg};
+use clippy_utils::{
+    diagnostics::span_lint_and_sugg, eq_expr_value, get_parent_expr, higher, in_constant, is_no_std_crate,
+    numeric_literal, peel_blocks, sugg,
+};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind, PathSegment, UnOp};
@@ -452,6 +453,9 @@ fn is_float_mul_expr<'a>(cx: &LateContext<'_>, expr: &'a Expr<'a>) -> Option<(&'
 
 // TODO: Fix rust-lang/rust-clippy#4735
 fn check_mul_add(cx: &LateContext<'_>, expr: &Expr<'_>) {
+    if is_no_std_crate(cx) {
+        return; // The suggested methods are not available in core
+    }
     if let ExprKind::Binary(
         Spanned {
             node: op @ (BinOpKind::Add | BinOpKind::Sub),
@@ -566,6 +570,9 @@ fn are_negated<'a>(cx: &LateContext<'_>, expr1: &'a Expr<'a>, expr2: &'a Expr<'a
 }
 
 fn check_custom_abs(cx: &LateContext<'_>, expr: &Expr<'_>) {
+    if is_no_std_crate(cx) {
+        return; // The suggested methods are not available in core
+    }
     if_chain! {
         if let Some(higher::If { cond, then, r#else: Some(r#else) }) = higher::If::hir(expr);
         let if_body_expr = peel_blocks(then);
diff --git a/tests/ui/floating_point_arithmetic_nostd.rs b/tests/ui/floating_point_arithmetic_nostd.rs
new file mode 100644
index 00000000000..a42c6383cce
--- /dev/null
+++ b/tests/ui/floating_point_arithmetic_nostd.rs
@@ -0,0 +1,31 @@
+#![feature(lang_items, start)]
+#![warn(clippy::imprecise_flops)]
+#![warn(clippy::suboptimal_flops)]
+#![no_std]
+
+// The following should not lint, as the suggested methods {f32,f64}.mul_add()
+// and {f32,f64}::abs() are not available in no_std
+
+pub fn mul_add() {
+    let a: f64 = 1234.567;
+    let b: f64 = 45.67834;
+    let c: f64 = 0.0004;
+    let _ = a * b + c;
+}
+
+fn fake_abs1(num: f64) -> f64 {
+    if num >= 0.0 { num } else { -num }
+}
+
+#[start]
+fn main(_argc: isize, _argv: *const *const u8) -> isize {
+    0
+}
+
+#[panic_handler]
+fn panic(_info: &core::panic::PanicInfo) -> ! {
+    loop {}
+}
+
+#[lang = "eh_personality"]
+extern "C" fn eh_personality() {}
-- 
cgit 1.4.1-3-g733a5


From a3aeec4f75dd0049f6632e26df5aa174b55e730f Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Wed, 19 Apr 2023 21:46:13 -0500
Subject: config instead of new lint and don't panic

---
 CHANGELOG.md                                       |   1 -
 clippy_lints/src/declared_lints.rs                 |   1 -
 clippy_lints/src/lib.rs                            |   9 +-
 clippy_lints/src/semicolon_block.rs                | 127 +++++++--------------
 clippy_lints/src/utils/conf.rs                     |   8 ++
 tests/ui-toml/semicolon_block/both.fixed           |  86 ++++++++++++++
 tests/ui-toml/semicolon_block/both.rs              |  86 ++++++++++++++
 tests/ui-toml/semicolon_block/both.stderr          |  55 +++++++++
 tests/ui-toml/semicolon_block/clippy.toml          |   2 +
 .../semicolon_block/semicolon_inside_block.fixed   |  85 ++++++++++++++
 .../semicolon_block/semicolon_inside_block.rs      |  85 ++++++++++++++
 .../semicolon_block/semicolon_inside_block.stderr  |  18 +++
 .../semicolon_block/semicolon_outside_block.fixed  |  85 ++++++++++++++
 .../semicolon_block/semicolon_outside_block.rs     |  85 ++++++++++++++
 .../semicolon_block/semicolon_outside_block.stderr |  39 +++++++
 .../toml_unknown_key/conf_unknown_key.stderr       |   2 +
 .../ui/semicolon_outside_block_if_singleline.fixed |  85 --------------
 tests/ui/semicolon_outside_block_if_singleline.rs  |  85 --------------
 .../semicolon_outside_block_if_singleline.stderr   |  54 ---------
 19 files changed, 684 insertions(+), 314 deletions(-)
 create mode 100644 tests/ui-toml/semicolon_block/both.fixed
 create mode 100644 tests/ui-toml/semicolon_block/both.rs
 create mode 100644 tests/ui-toml/semicolon_block/both.stderr
 create mode 100644 tests/ui-toml/semicolon_block/clippy.toml
 create mode 100644 tests/ui-toml/semicolon_block/semicolon_inside_block.fixed
 create mode 100644 tests/ui-toml/semicolon_block/semicolon_inside_block.rs
 create mode 100644 tests/ui-toml/semicolon_block/semicolon_inside_block.stderr
 create mode 100644 tests/ui-toml/semicolon_block/semicolon_outside_block.fixed
 create mode 100644 tests/ui-toml/semicolon_block/semicolon_outside_block.rs
 create mode 100644 tests/ui-toml/semicolon_block/semicolon_outside_block.stderr
 delete mode 100644 tests/ui/semicolon_outside_block_if_singleline.fixed
 delete mode 100644 tests/ui/semicolon_outside_block_if_singleline.rs
 delete mode 100644 tests/ui/semicolon_outside_block_if_singleline.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index a0a7780f4c2..559b560dde4 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4884,7 +4884,6 @@ Released 2018-09-13
 [`semicolon_if_nothing_returned`]: https://rust-lang.github.io/rust-clippy/master/index.html#semicolon_if_nothing_returned
 [`semicolon_inside_block`]: https://rust-lang.github.io/rust-clippy/master/index.html#semicolon_inside_block
 [`semicolon_outside_block`]: https://rust-lang.github.io/rust-clippy/master/index.html#semicolon_outside_block
-[`semicolon_outside_block_if_singleline`]: https://rust-lang.github.io/rust-clippy/master/index.html#semicolon_outside_block_if_singleline
 [`separated_literal_suffix`]: https://rust-lang.github.io/rust-clippy/master/index.html#separated_literal_suffix
 [`serde_api_misuse`]: https://rust-lang.github.io/rust-clippy/master/index.html#serde_api_misuse
 [`shadow_reuse`]: https://rust-lang.github.io/rust-clippy/master/index.html#shadow_reuse
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 70379b6caf1..f24dab62780 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -546,7 +546,6 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::self_named_constructors::SELF_NAMED_CONSTRUCTORS_INFO,
     crate::semicolon_block::SEMICOLON_INSIDE_BLOCK_INFO,
     crate::semicolon_block::SEMICOLON_OUTSIDE_BLOCK_INFO,
-    crate::semicolon_block::SEMICOLON_OUTSIDE_BLOCK_IF_SINGLELINE_INFO,
     crate::semicolon_if_nothing_returned::SEMICOLON_IF_NOTHING_RETURNED_INFO,
     crate::serde_api::SERDE_API_MISUSE_INFO,
     crate::shadow::SHADOW_REUSE_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index b0ec14855e7..cb223ce9d16 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -932,7 +932,14 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(from_raw_with_void_ptr::FromRawWithVoidPtr));
     store.register_late_pass(|_| Box::new(suspicious_xor_used_as_pow::ConfusingXorAndPow));
     store.register_late_pass(move |_| Box::new(manual_is_ascii_check::ManualIsAsciiCheck::new(msrv())));
-    store.register_late_pass(|_| Box::new(semicolon_block::SemicolonBlock));
+    let semicolon_inside_block_if_multiline = conf.semicolon_inside_block_if_multiline;
+    let semicolon_outside_block_if_singleline = conf.semicolon_outside_block_if_singleline;
+    store.register_late_pass(move |_| {
+        Box::new(semicolon_block::SemicolonBlock::new(
+            semicolon_inside_block_if_multiline,
+            semicolon_outside_block_if_singleline,
+        ))
+    });
     store.register_late_pass(|_| Box::new(fn_null_check::FnNullCheck));
     store.register_late_pass(|_| Box::new(permissions_set_readonly_false::PermissionsSetReadonlyFalse));
     store.register_late_pass(|_| Box::new(size_of_ref::SizeOfRef));
diff --git a/clippy_lints/src/semicolon_block.rs b/clippy_lints/src/semicolon_block.rs
index 7113f0c55d4..6be43033712 100644
--- a/clippy_lints/src/semicolon_block.rs
+++ b/clippy_lints/src/semicolon_block.rs
@@ -2,7 +2,7 @@ use clippy_utils::diagnostics::{multispan_sugg_with_applicability, span_lint_and
 use rustc_errors::Applicability;
 use rustc_hir::{Block, Expr, ExprKind, Stmt, StmtKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::Span;
 
 declare_clippy_lint! {
@@ -64,49 +64,22 @@ declare_clippy_lint! {
     restriction,
     "add a semicolon outside the block"
 }
-declare_clippy_lint! {
-    /// ### What it does
-    ///
-    /// Suggests moving the semicolon from a block's final expression outside of
-    /// the block if it's singleline, and inside the block if it's multiline.
-    ///
-    /// ### Why is this bad?
-    ///
-    /// Some may prefer if the semicolon is outside of a block if it is only one
-    /// expression, as this allows rustfmt to make it singleline (and may just be
-    /// more readable). In the case that it isn't, it should be inside.
-    /// Take a look at both `semicolon_inside_block` and `semicolon_outside_block`
-    /// for alternatives.
-    ///
-    /// ### Example
-    ///
-    /// ```rust
-    /// # fn f(_: u32) {}
-    /// # let x = 0;
-    /// unsafe { f(x); }
-    ///
-    /// unsafe {
-    ///     let x = 1;
-    ///     f(x)
-    /// };
-    /// ```
-    /// Use instead:
-    /// ```rust
-    /// # fn f(_: u32) {}
-    /// # let x = 0;
-    /// unsafe { f(x) };
-    ///
-    /// unsafe {
-    ///     let x = 1;
-    ///     f(x);
-    /// }
-    /// ```
-    #[clippy::version = "1.68.0"]
-    pub SEMICOLON_OUTSIDE_BLOCK_IF_SINGLELINE,
-    restriction,
-    "add a semicolon inside the block if it's singleline, otherwise outside"
+impl_lint_pass!(SemicolonBlock => [SEMICOLON_INSIDE_BLOCK, SEMICOLON_OUTSIDE_BLOCK]);
+
+#[derive(Copy, Clone)]
+pub struct SemicolonBlock {
+    semicolon_inside_block_if_multiline: bool,
+    semicolon_outside_block_if_singleline: bool,
+}
+
+impl SemicolonBlock {
+    pub fn new(semicolon_inside_block_if_multiline: bool, semicolon_outside_block_if_singleline: bool) -> Self {
+        Self {
+            semicolon_inside_block_if_multiline,
+            semicolon_outside_block_if_singleline,
+        }
+    }
 }
-declare_lint_pass!(SemicolonBlock => [SEMICOLON_INSIDE_BLOCK, SEMICOLON_OUTSIDE_BLOCK, SEMICOLON_OUTSIDE_BLOCK_IF_SINGLELINE]);
 
 impl LateLintPass<'_> for SemicolonBlock {
     fn check_stmt(&mut self, cx: &LateContext<'_>, stmt: &Stmt<'_>) {
@@ -125,24 +98,34 @@ impl LateLintPass<'_> for SemicolonBlock {
                     span,
                     ..
                 } = stmt else { return };
-                semicolon_outside_block(cx, block, expr, span);
+                semicolon_outside_block(self, cx, block, expr, span);
             },
             StmtKind::Semi(Expr {
                 kind: ExprKind::Block(block @ Block { expr: Some(tail), .. }, _),
                 ..
             }) if !block.span.from_expansion() => {
-                semicolon_inside_block(cx, block, tail, stmt.span);
+                semicolon_inside_block(self, cx, block, tail, stmt.span);
             },
             _ => (),
         }
     }
 }
 
-fn semicolon_inside_block(cx: &LateContext<'_>, block: &Block<'_>, tail: &Expr<'_>, semi_span: Span) {
+fn semicolon_inside_block(
+    conf: &mut SemicolonBlock,
+    cx: &LateContext<'_>,
+    block: &Block<'_>,
+    tail: &Expr<'_>,
+    semi_span: Span,
+) {
     let insert_span = tail.span.source_callsite().shrink_to_hi();
     let remove_span = semi_span.with_lo(block.span.hi());
 
-    semicolon_outside_block_if_singleline(cx, block, remove_span, insert_span, true, "inside");
+    if conf.semicolon_inside_block_if_multiline {
+        if get_line(cx, remove_span) == get_line(cx, insert_span) {
+            return;
+        }
+    }
 
     span_lint_and_then(
         cx,
@@ -160,13 +143,17 @@ fn semicolon_inside_block(cx: &LateContext<'_>, block: &Block<'_>, tail: &Expr<'
     );
 }
 
-fn semicolon_outside_block(cx: &LateContext<'_>, block: &Block<'_>, tail_stmt_expr: &Expr<'_>, semi_span: Span) {
+fn semicolon_outside_block(conf: &mut SemicolonBlock, cx: &LateContext<'_>, block: &Block<'_>, tail_stmt_expr: &Expr<'_>, semi_span: Span) {
     let insert_span = block.span.with_lo(block.span.hi());
     // account for macro calls
     let semi_span = cx.sess().source_map().stmt_span(semi_span, block.span);
     let remove_span = semi_span.with_lo(tail_stmt_expr.span.source_callsite().hi());
 
-    semicolon_outside_block_if_singleline(cx, block, remove_span, insert_span, false, "outside");
+    if conf.semicolon_outside_block_if_singleline {
+        if get_line(cx, remove_span) != get_line(cx, insert_span) {
+            return;
+        }
+    }
 
     span_lint_and_then(
         cx,
@@ -184,44 +171,10 @@ fn semicolon_outside_block(cx: &LateContext<'_>, block: &Block<'_>, tail_stmt_ex
     );
 }
 
-fn semicolon_outside_block_if_singleline(
-    cx: &LateContext<'_>,
-    block: &Block<'_>,
-    remove_span: Span,
-    insert_span: Span,
-    inequality: bool,
-    ty: &str,
-) {
-    let (remove_line, insert_line) = (get_line(cx, remove_span), get_line(cx, insert_span));
-
-    let eq = if inequality {
-        remove_line != insert_line
-    } else {
-        remove_line == insert_line
-    };
-
-    if eq {
-        span_lint_and_then(
-            cx,
-            SEMICOLON_OUTSIDE_BLOCK_IF_SINGLELINE,
-            block.span,
-            &format!("consider moving the `;` {ty} the block for consistent formatting"),
-            |diag| {
-                multispan_sugg_with_applicability(
-                    diag,
-                    "put the `;` here",
-                    Applicability::MachineApplicable,
-                    [(remove_span, String::new()), (insert_span, ";".to_owned())],
-                );
-            },
-        );
+fn get_line(cx: &LateContext<'_>, span: Span) -> Option<usize> {
+    if let Ok(line) = cx.sess().source_map().lookup_line(span.lo()) {
+        return Some(line.line);
     }
-}
 
-fn get_line(cx: &LateContext<'_>, span: Span) -> usize {
-    cx.sess()
-        .source_map()
-        .lookup_line(span.lo())
-        .expect("failed to get span's line")
-        .line
+    None
 }
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 896a01af37d..26123549b94 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -463,6 +463,14 @@ define_Conf! {
     ///
     /// The maximum byte size a `Future` can have, before it triggers the `clippy::large_futures` lint
     (future_size_threshold: u64 = 16 * 1024),
+    /// Lint: SEMICOLON_INSIDE_BLOCK.
+    /// 
+    /// Whether to lint only if it's multiline.
+    (semicolon_inside_block_if_multiline: bool = false),
+    /// Lint: SEMICOLON_OUTSIDE_BLOCK.
+    /// 
+    /// Whether to lint only if it's singleline.
+    (semicolon_outside_block_if_singleline: bool = false),
 }
 
 /// Search for the configuration file.
diff --git a/tests/ui-toml/semicolon_block/both.fixed b/tests/ui-toml/semicolon_block/both.fixed
new file mode 100644
index 00000000000..981b661bc78
--- /dev/null
+++ b/tests/ui-toml/semicolon_block/both.fixed
@@ -0,0 +1,86 @@
+// run-rustfix
+#![allow(
+    unused,
+    clippy::unused_unit,
+    clippy::unnecessary_operation,
+    clippy::no_effect,
+    clippy::single_element_loop
+)]
+#![warn(clippy::semicolon_inside_block)]
+#![warn(clippy::semicolon_outside_block)]
+
+macro_rules! m {
+    (()) => {
+        ()
+    };
+    (0) => {{
+        0
+    };};
+    (1) => {{
+        1;
+    }};
+    (2) => {{
+        2;
+    }};
+}
+
+fn unit_fn_block() {
+    ()
+}
+
+#[rustfmt::skip]
+fn main() {
+    { unit_fn_block() }
+    unsafe { unit_fn_block() }
+
+    {
+        unit_fn_block()
+    }
+
+    { unit_fn_block() };
+    unsafe { unit_fn_block() };
+
+    { unit_fn_block() };
+    unsafe { unit_fn_block() };
+
+    { unit_fn_block(); };
+    unsafe { unit_fn_block(); };
+
+    {
+        unit_fn_block();
+        unit_fn_block();
+    }
+    {
+        unit_fn_block();
+        unit_fn_block();
+    }
+    {
+        unit_fn_block();
+        unit_fn_block();
+    };
+
+    { m!(()) };
+    { m!(()) };
+    { m!(()); };
+    m!(0);
+    m!(1);
+    m!(2);
+
+    for _ in [()] {
+        unit_fn_block();
+    }
+    for _ in [()] {
+        unit_fn_block()
+    }
+
+    let _d = || {
+        unit_fn_block();
+    };
+    let _d = || {
+        unit_fn_block()
+    };
+
+    { unit_fn_block(); };
+
+    unit_fn_block()
+}
diff --git a/tests/ui-toml/semicolon_block/both.rs b/tests/ui-toml/semicolon_block/both.rs
new file mode 100644
index 00000000000..d4dcd6e7240
--- /dev/null
+++ b/tests/ui-toml/semicolon_block/both.rs
@@ -0,0 +1,86 @@
+// run-rustfix
+#![allow(
+    unused,
+    clippy::unused_unit,
+    clippy::unnecessary_operation,
+    clippy::no_effect,
+    clippy::single_element_loop
+)]
+#![warn(clippy::semicolon_inside_block)]
+#![warn(clippy::semicolon_outside_block)]
+
+macro_rules! m {
+    (()) => {
+        ()
+    };
+    (0) => {{
+        0
+    };};
+    (1) => {{
+        1;
+    }};
+    (2) => {{
+        2;
+    }};
+}
+
+fn unit_fn_block() {
+    ()
+}
+
+#[rustfmt::skip]
+fn main() {
+    { unit_fn_block() }
+    unsafe { unit_fn_block() }
+
+    {
+        unit_fn_block()
+    }
+
+    { unit_fn_block() };
+    unsafe { unit_fn_block() };
+
+    { unit_fn_block(); }
+    unsafe { unit_fn_block(); }
+
+    { unit_fn_block(); };
+    unsafe { unit_fn_block(); };
+
+    {
+        unit_fn_block();
+        unit_fn_block()
+    };
+    {
+        unit_fn_block();
+        unit_fn_block();
+    }
+    {
+        unit_fn_block();
+        unit_fn_block();
+    };
+
+    { m!(()) };
+    { m!(()); }
+    { m!(()); };
+    m!(0);
+    m!(1);
+    m!(2);
+
+    for _ in [()] {
+        unit_fn_block();
+    }
+    for _ in [()] {
+        unit_fn_block()
+    }
+
+    let _d = || {
+        unit_fn_block();
+    };
+    let _d = || {
+        unit_fn_block()
+    };
+
+    { unit_fn_block(); };
+
+    unit_fn_block()
+}
diff --git a/tests/ui-toml/semicolon_block/both.stderr b/tests/ui-toml/semicolon_block/both.stderr
new file mode 100644
index 00000000000..2f58842eab0
--- /dev/null
+++ b/tests/ui-toml/semicolon_block/both.stderr
@@ -0,0 +1,55 @@
+error: consider moving the `;` outside the block for consistent formatting
+  --> $DIR/both.rs:43:5
+   |
+LL |     { unit_fn_block(); }
+   |     ^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::semicolon-outside-block` implied by `-D warnings`
+help: put the `;` here
+   |
+LL -     { unit_fn_block(); }
+LL +     { unit_fn_block() };
+   |
+
+error: consider moving the `;` outside the block for consistent formatting
+  --> $DIR/both.rs:44:5
+   |
+LL |     unsafe { unit_fn_block(); }
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: put the `;` here
+   |
+LL -     unsafe { unit_fn_block(); }
+LL +     unsafe { unit_fn_block() };
+   |
+
+error: consider moving the `;` inside the block for consistent formatting
+  --> $DIR/both.rs:49:5
+   |
+LL | /     {
+LL | |         unit_fn_block();
+LL | |         unit_fn_block()
+LL | |     };
+   | |______^
+   |
+   = note: `-D clippy::semicolon-inside-block` implied by `-D warnings`
+help: put the `;` here
+   |
+LL ~         unit_fn_block();
+LL ~     }
+   |
+
+error: consider moving the `;` outside the block for consistent formatting
+  --> $DIR/both.rs:63:5
+   |
+LL |     { m!(()); }
+   |     ^^^^^^^^^^^
+   |
+help: put the `;` here
+   |
+LL -     { m!(()); }
+LL +     { m!(()) };
+   |
+
+error: aborting due to 4 previous errors
+
diff --git a/tests/ui-toml/semicolon_block/clippy.toml b/tests/ui-toml/semicolon_block/clippy.toml
new file mode 100644
index 00000000000..cc3bc8cae14
--- /dev/null
+++ b/tests/ui-toml/semicolon_block/clippy.toml
@@ -0,0 +1,2 @@
+semicolon-inside-block-if-multiline = true
+semicolon-outside-block-if-singleline = true
diff --git a/tests/ui-toml/semicolon_block/semicolon_inside_block.fixed b/tests/ui-toml/semicolon_block/semicolon_inside_block.fixed
new file mode 100644
index 00000000000..6a08bc905b1
--- /dev/null
+++ b/tests/ui-toml/semicolon_block/semicolon_inside_block.fixed
@@ -0,0 +1,85 @@
+// run-rustfix
+#![allow(
+    unused,
+    clippy::unused_unit,
+    clippy::unnecessary_operation,
+    clippy::no_effect,
+    clippy::single_element_loop
+)]
+#![warn(clippy::semicolon_inside_block)]
+
+macro_rules! m {
+    (()) => {
+        ()
+    };
+    (0) => {{
+        0
+    };};
+    (1) => {{
+        1;
+    }};
+    (2) => {{
+        2;
+    }};
+}
+
+fn unit_fn_block() {
+    ()
+}
+
+#[rustfmt::skip]
+fn main() {
+    { unit_fn_block() }
+    unsafe { unit_fn_block() }
+
+    {
+        unit_fn_block()
+    }
+
+    { unit_fn_block() };
+    unsafe { unit_fn_block() };
+
+    { unit_fn_block(); }
+    unsafe { unit_fn_block(); }
+
+    { unit_fn_block(); };
+    unsafe { unit_fn_block(); };
+
+    {
+        unit_fn_block();
+        unit_fn_block();
+    }
+    {
+        unit_fn_block();
+        unit_fn_block();
+    }
+    {
+        unit_fn_block();
+        unit_fn_block();
+    };
+
+    { m!(()) };
+    { m!(()); }
+    { m!(()); };
+    m!(0);
+    m!(1);
+    m!(2);
+
+    for _ in [()] {
+        unit_fn_block();
+    }
+    for _ in [()] {
+        unit_fn_block()
+    }
+
+    let _d = || {
+        unit_fn_block();
+    };
+    let _d = || {
+        unit_fn_block()
+    };
+
+    { unit_fn_block(); };
+
+    unit_fn_block()
+}
diff --git a/tests/ui-toml/semicolon_block/semicolon_inside_block.rs b/tests/ui-toml/semicolon_block/semicolon_inside_block.rs
new file mode 100644
index 00000000000..f40848f702e
--- /dev/null
+++ b/tests/ui-toml/semicolon_block/semicolon_inside_block.rs
@@ -0,0 +1,85 @@
+// run-rustfix
+#![allow(
+    unused,
+    clippy::unused_unit,
+    clippy::unnecessary_operation,
+    clippy::no_effect,
+    clippy::single_element_loop
+)]
+#![warn(clippy::semicolon_inside_block)]
+
+macro_rules! m {
+    (()) => {
+        ()
+    };
+    (0) => {{
+        0
+    };};
+    (1) => {{
+        1;
+    }};
+    (2) => {{
+        2;
+    }};
+}
+
+fn unit_fn_block() {
+    ()
+}
+
+#[rustfmt::skip]
+fn main() {
+    { unit_fn_block() }
+    unsafe { unit_fn_block() }
+
+    {
+        unit_fn_block()
+    }
+
+    { unit_fn_block() };
+    unsafe { unit_fn_block() };
+
+    { unit_fn_block(); }
+    unsafe { unit_fn_block(); }
+
+    { unit_fn_block(); };
+    unsafe { unit_fn_block(); };
+
+    {
+        unit_fn_block();
+        unit_fn_block()
+    };
+    {
+        unit_fn_block();
+        unit_fn_block();
+    }
+    {
+        unit_fn_block();
+        unit_fn_block();
+    };
+
+    { m!(()) };
+    { m!(()); }
+    { m!(()); };
+    m!(0);
+    m!(1);
+    m!(2);
+
+    for _ in [()] {
+        unit_fn_block();
+    }
+    for _ in [()] {
+        unit_fn_block()
+    }
+
+    let _d = || {
+        unit_fn_block();
+    };
+    let _d = || {
+        unit_fn_block()
+    };
+
+    { unit_fn_block(); };
+
+    unit_fn_block()
+}
diff --git a/tests/ui-toml/semicolon_block/semicolon_inside_block.stderr b/tests/ui-toml/semicolon_block/semicolon_inside_block.stderr
new file mode 100644
index 00000000000..2569dc4b4e4
--- /dev/null
+++ b/tests/ui-toml/semicolon_block/semicolon_inside_block.stderr
@@ -0,0 +1,18 @@
+error: consider moving the `;` inside the block for consistent formatting
+  --> $DIR/semicolon_inside_block.rs:48:5
+   |
+LL | /     {
+LL | |         unit_fn_block();
+LL | |         unit_fn_block()
+LL | |     };
+   | |______^
+   |
+   = note: `-D clippy::semicolon-inside-block` implied by `-D warnings`
+help: put the `;` here
+   |
+LL ~         unit_fn_block();
+LL ~     }
+   |
+
+error: aborting due to previous error
+
diff --git a/tests/ui-toml/semicolon_block/semicolon_outside_block.fixed b/tests/ui-toml/semicolon_block/semicolon_outside_block.fixed
new file mode 100644
index 00000000000..e2d653dc3c3
--- /dev/null
+++ b/tests/ui-toml/semicolon_block/semicolon_outside_block.fixed
@@ -0,0 +1,85 @@
+// run-rustfix
+#![allow(
+    unused,
+    clippy::unused_unit,
+    clippy::unnecessary_operation,
+    clippy::no_effect,
+    clippy::single_element_loop
+)]
+#![warn(clippy::semicolon_outside_block)]
+
+macro_rules! m {
+    (()) => {
+        ()
+    };
+    (0) => {{
+        0
+    };};
+    (1) => {{
+        1;
+    }};
+    (2) => {{
+        2;
+    }};
+}
+
+fn unit_fn_block() {
+    ()
+}
+
+#[rustfmt::skip]
+fn main() {
+    { unit_fn_block() }
+    unsafe { unit_fn_block() }
+
+    {
+        unit_fn_block()
+    }
+
+    { unit_fn_block() };
+    unsafe { unit_fn_block() };
+
+    { unit_fn_block() };
+    unsafe { unit_fn_block() };
+
+    { unit_fn_block(); };
+    unsafe { unit_fn_block(); };
+
+    {
+        unit_fn_block();
+        unit_fn_block()
+    };
+    {
+        unit_fn_block();
+        unit_fn_block();
+    }
+    {
+        unit_fn_block();
+        unit_fn_block();
+    };
+
+    { m!(()) };
+    { m!(()) };
+    { m!(()); };
+    m!(0);
+    m!(1);
+    m!(2);
+
+    for _ in [()] {
+        unit_fn_block();
+    }
+    for _ in [()] {
+        unit_fn_block()
+    }
+
+    let _d = || {
+        unit_fn_block();
+    };
+    let _d = || {
+        unit_fn_block()
+    };
+
+    { unit_fn_block(); };
+
+    unit_fn_block()
+}
diff --git a/tests/ui-toml/semicolon_block/semicolon_outside_block.rs b/tests/ui-toml/semicolon_block/semicolon_outside_block.rs
new file mode 100644
index 00000000000..7ce46431fac
--- /dev/null
+++ b/tests/ui-toml/semicolon_block/semicolon_outside_block.rs
@@ -0,0 +1,85 @@
+// run-rustfix
+#![allow(
+    unused,
+    clippy::unused_unit,
+    clippy::unnecessary_operation,
+    clippy::no_effect,
+    clippy::single_element_loop
+)]
+#![warn(clippy::semicolon_outside_block)]
+
+macro_rules! m {
+    (()) => {
+        ()
+    };
+    (0) => {{
+        0
+    };};
+    (1) => {{
+        1;
+    }};
+    (2) => {{
+        2;
+    }};
+}
+
+fn unit_fn_block() {
+    ()
+}
+
+#[rustfmt::skip]
+fn main() {
+    { unit_fn_block() }
+    unsafe { unit_fn_block() }
+
+    {
+        unit_fn_block()
+    }
+
+    { unit_fn_block() };
+    unsafe { unit_fn_block() };
+
+    { unit_fn_block(); }
+    unsafe { unit_fn_block(); }
+
+    { unit_fn_block(); };
+    unsafe { unit_fn_block(); };
+
+    {
+        unit_fn_block();
+        unit_fn_block()
+    };
+    {
+        unit_fn_block();
+        unit_fn_block();
+    }
+    {
+        unit_fn_block();
+        unit_fn_block();
+    };
+
+    { m!(()) };
+    { m!(()); }
+    { m!(()); };
+    m!(0);
+    m!(1);
+    m!(2);
+
+    for _ in [()] {
+        unit_fn_block();
+    }
+    for _ in [()] {
+        unit_fn_block()
+    }
+
+    let _d = || {
+        unit_fn_block();
+    };
+    let _d = || {
+        unit_fn_block()
+    };
+
+    { unit_fn_block(); };
+
+    unit_fn_block()
+}
diff --git a/tests/ui-toml/semicolon_block/semicolon_outside_block.stderr b/tests/ui-toml/semicolon_block/semicolon_outside_block.stderr
new file mode 100644
index 00000000000..6dd3577dd09
--- /dev/null
+++ b/tests/ui-toml/semicolon_block/semicolon_outside_block.stderr
@@ -0,0 +1,39 @@
+error: consider moving the `;` outside the block for consistent formatting
+  --> $DIR/semicolon_outside_block.rs:42:5
+   |
+LL |     { unit_fn_block(); }
+   |     ^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::semicolon-outside-block` implied by `-D warnings`
+help: put the `;` here
+   |
+LL -     { unit_fn_block(); }
+LL +     { unit_fn_block() };
+   |
+
+error: consider moving the `;` outside the block for consistent formatting
+  --> $DIR/semicolon_outside_block.rs:43:5
+   |
+LL |     unsafe { unit_fn_block(); }
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: put the `;` here
+   |
+LL -     unsafe { unit_fn_block(); }
+LL +     unsafe { unit_fn_block() };
+   |
+
+error: consider moving the `;` outside the block for consistent formatting
+  --> $DIR/semicolon_outside_block.rs:62:5
+   |
+LL |     { m!(()); }
+   |     ^^^^^^^^^^^
+   |
+help: put the `;` here
+   |
+LL -     { m!(()); }
+LL +     { m!(()) };
+   |
+
+error: aborting due to 3 previous errors
+
diff --git a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
index 8447c31722d..c49c9087946 100644
--- a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
+++ b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
@@ -37,6 +37,8 @@ error: error reading Clippy's configuration file `$DIR/clippy.toml`: unknown fie
            missing-docs-in-crate-items
            msrv
            pass-by-value-size-limit
+           semicolon-inside-block-if-multiline
+           semicolon-outside-block-if-singleline
            single-char-binding-names-threshold
            standard-macro-braces
            suppress-restriction-lint-in-const
diff --git a/tests/ui/semicolon_outside_block_if_singleline.fixed b/tests/ui/semicolon_outside_block_if_singleline.fixed
deleted file mode 100644
index e1ecbf8588d..00000000000
--- a/tests/ui/semicolon_outside_block_if_singleline.fixed
+++ /dev/null
@@ -1,85 +0,0 @@
-// run-rustfix
-#![allow(
-    unused,
-    clippy::unused_unit,
-    clippy::unnecessary_operation,
-    clippy::no_effect,
-    clippy::single_element_loop
-)]
-#![warn(clippy::semicolon_outside_block_if_singleline)]
-
-macro_rules! m {
-    (()) => {
-        ()
-    };
-    (0) => {{
-        0
-    };};
-    (1) => {{
-        1;
-    }};
-    (2) => {{
-        2;
-    }};
-}
-
-fn unit_fn_block() {
-    ()
-}
-
-#[rustfmt::skip]
-fn main() {
-    { unit_fn_block() }
-    unsafe { unit_fn_block() }
-
-    {
-        unit_fn_block()
-    }
-
-    { unit_fn_block() };
-    unsafe { unit_fn_block() };
-
-    { unit_fn_block() };
-    unsafe { unit_fn_block() };
-
-    { unit_fn_block(); };
-    unsafe { unit_fn_block(); };
-
-    {
-        unit_fn_block();
-        unit_fn_block();
-    }
-    {
-        unit_fn_block();
-        unit_fn_block();
-    }
-    {
-        unit_fn_block();
-        unit_fn_block();
-    };
-
-    { m!(()) };
-    { m!(()) };
-    { m!(()); };
-    m!(0);
-    m!(1);
-    m!(2);
-
-    for _ in [()] {
-        unit_fn_block();
-    }
-    for _ in [()] {
-        unit_fn_block()
-    }
-
-    let _d = || {
-        unit_fn_block();
-    };
-    let _d = || {
-        unit_fn_block()
-    };
-
-    { unit_fn_block(); };
-
-    unit_fn_block()
-}
diff --git a/tests/ui/semicolon_outside_block_if_singleline.rs b/tests/ui/semicolon_outside_block_if_singleline.rs
deleted file mode 100644
index 80fbb4ce2d5..00000000000
--- a/tests/ui/semicolon_outside_block_if_singleline.rs
+++ /dev/null
@@ -1,85 +0,0 @@
-// run-rustfix
-#![allow(
-    unused,
-    clippy::unused_unit,
-    clippy::unnecessary_operation,
-    clippy::no_effect,
-    clippy::single_element_loop
-)]
-#![warn(clippy::semicolon_outside_block_if_singleline)]
-
-macro_rules! m {
-    (()) => {
-        ()
-    };
-    (0) => {{
-        0
-    };};
-    (1) => {{
-        1;
-    }};
-    (2) => {{
-        2;
-    }};
-}
-
-fn unit_fn_block() {
-    ()
-}
-
-#[rustfmt::skip]
-fn main() {
-    { unit_fn_block() }
-    unsafe { unit_fn_block() }
-
-    {
-        unit_fn_block()
-    }
-
-    { unit_fn_block() };
-    unsafe { unit_fn_block() };
-
-    { unit_fn_block(); }
-    unsafe { unit_fn_block(); }
-
-    { unit_fn_block(); };
-    unsafe { unit_fn_block(); };
-
-    {
-        unit_fn_block();
-        unit_fn_block()
-    };
-    {
-        unit_fn_block();
-        unit_fn_block();
-    }
-    {
-        unit_fn_block();
-        unit_fn_block();
-    };
-
-    { m!(()) };
-    { m!(()); }
-    { m!(()); };
-    m!(0);
-    m!(1);
-    m!(2);
-
-    for _ in [()] {
-        unit_fn_block();
-    }
-    for _ in [()] {
-        unit_fn_block()
-    }
-
-    let _d = || {
-        unit_fn_block();
-    };
-    let _d = || {
-        unit_fn_block()
-    };
-
-    { unit_fn_block(); };
-
-    unit_fn_block()
-}
diff --git a/tests/ui/semicolon_outside_block_if_singleline.stderr b/tests/ui/semicolon_outside_block_if_singleline.stderr
deleted file mode 100644
index dda083f2be3..00000000000
--- a/tests/ui/semicolon_outside_block_if_singleline.stderr
+++ /dev/null
@@ -1,54 +0,0 @@
-error: consider moving the `;` outside the block for consistent formatting
-  --> $DIR/semicolon_outside_block_if_singleline.rs:42:5
-   |
-LL |     { unit_fn_block(); }
-   |     ^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: `-D clippy::semicolon-outside-block-if-singleline` implied by `-D warnings`
-help: put the `;` here
-   |
-LL -     { unit_fn_block(); }
-LL +     { unit_fn_block() };
-   |
-
-error: consider moving the `;` outside the block for consistent formatting
-  --> $DIR/semicolon_outside_block_if_singleline.rs:43:5
-   |
-LL |     unsafe { unit_fn_block(); }
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: put the `;` here
-   |
-LL -     unsafe { unit_fn_block(); }
-LL +     unsafe { unit_fn_block() };
-   |
-
-error: consider moving the `;` inside the block for consistent formatting
-  --> $DIR/semicolon_outside_block_if_singleline.rs:48:5
-   |
-LL | /     {
-LL | |         unit_fn_block();
-LL | |         unit_fn_block()
-LL | |     };
-   | |_____^
-   |
-help: put the `;` here
-   |
-LL ~         unit_fn_block();
-LL ~     }
-   |
-
-error: consider moving the `;` outside the block for consistent formatting
-  --> $DIR/semicolon_outside_block_if_singleline.rs:62:5
-   |
-LL |     { m!(()); }
-   |     ^^^^^^^^^^^
-   |
-help: put the `;` here
-   |
-LL -     { m!(()); }
-LL +     { m!(()) };
-   |
-
-error: aborting due to 4 previous errors
-
-- 
cgit 1.4.1-3-g733a5


From 41f6d88be588b191d7c49547819671c11c9a84e9 Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Wed, 19 Apr 2023 21:51:58 -0500
Subject: make cargo test pass

---
 clippy_lints/src/semicolon_block.rs | 20 +++++++++++---------
 clippy_lints/src/utils/conf.rs      | 16 ++++++++--------
 2 files changed, 19 insertions(+), 17 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/semicolon_block.rs b/clippy_lints/src/semicolon_block.rs
index 6be43033712..c1c0325b786 100644
--- a/clippy_lints/src/semicolon_block.rs
+++ b/clippy_lints/src/semicolon_block.rs
@@ -121,10 +121,8 @@ fn semicolon_inside_block(
     let insert_span = tail.span.source_callsite().shrink_to_hi();
     let remove_span = semi_span.with_lo(block.span.hi());
 
-    if conf.semicolon_inside_block_if_multiline {
-        if get_line(cx, remove_span) == get_line(cx, insert_span) {
-            return;
-        }
+    if conf.semicolon_inside_block_if_multiline && get_line(cx, remove_span) == get_line(cx, insert_span) {
+        return;
     }
 
     span_lint_and_then(
@@ -143,16 +141,20 @@ fn semicolon_inside_block(
     );
 }
 
-fn semicolon_outside_block(conf: &mut SemicolonBlock, cx: &LateContext<'_>, block: &Block<'_>, tail_stmt_expr: &Expr<'_>, semi_span: Span) {
+fn semicolon_outside_block(
+    conf: &mut SemicolonBlock,
+    cx: &LateContext<'_>,
+    block: &Block<'_>,
+    tail_stmt_expr: &Expr<'_>,
+    semi_span: Span,
+) {
     let insert_span = block.span.with_lo(block.span.hi());
     // account for macro calls
     let semi_span = cx.sess().source_map().stmt_span(semi_span, block.span);
     let remove_span = semi_span.with_lo(tail_stmt_expr.span.source_callsite().hi());
 
-    if conf.semicolon_outside_block_if_singleline {
-        if get_line(cx, remove_span) != get_line(cx, insert_span) {
-            return;
-        }
+    if conf.semicolon_outside_block_if_singleline && get_line(cx, remove_span) != get_line(cx, insert_span) {
+        return;
     }
 
     span_lint_and_then(
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 26123549b94..939f6cd5f1f 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -277,6 +277,14 @@ define_Conf! {
     /// `".."` can be used as part of the list to indicate, that the configured values should be appended to the
     /// default configuration of Clippy. By default, any configuration will replace the default value.
     (disallowed_names: Vec<String> = super::DEFAULT_DISALLOWED_NAMES.iter().map(ToString::to_string).collect()),
+    /// Lint: SEMICOLON_INSIDE_BLOCK.
+    ///
+    /// Whether to lint only if it's multiline.
+    (semicolon_inside_block_if_multiline: bool = false),
+    /// Lint: SEMICOLON_OUTSIDE_BLOCK.
+    ///
+    /// Whether to lint only if it's singleline.
+    (semicolon_outside_block_if_singleline: bool = false),
     /// Lint: DOC_MARKDOWN.
     ///
     /// The list of words this lint should not consider as identifiers needing ticks. The value
@@ -463,14 +471,6 @@ define_Conf! {
     ///
     /// The maximum byte size a `Future` can have, before it triggers the `clippy::large_futures` lint
     (future_size_threshold: u64 = 16 * 1024),
-    /// Lint: SEMICOLON_INSIDE_BLOCK.
-    /// 
-    /// Whether to lint only if it's multiline.
-    (semicolon_inside_block_if_multiline: bool = false),
-    /// Lint: SEMICOLON_OUTSIDE_BLOCK.
-    /// 
-    /// Whether to lint only if it's singleline.
-    (semicolon_outside_block_if_singleline: bool = false),
 }
 
 /// Search for the configuration file.
-- 
cgit 1.4.1-3-g733a5


From def1705a271e317da4ae67d3a92e99fc699c9209 Mon Sep 17 00:00:00 2001
From: Oli Scherer <git-spam-no-reply9815368754983@oli-obk.de>
Date: Thu, 20 Apr 2023 14:37:15 +0000
Subject: Update to a compiletest-rs version that requires `//@` for commands

---
 Cargo.toml                                         |   2 +-
 book/src/development/adding_lints.md               |   2 +-
 clippy_dev/src/update_lints.rs                     |   2 +-
 clippy_lints/src/methods/obfuscated_if_else.rs     |   2 -
 tests/compile-test.rs                              |   3 +-
 .../cargo_common_metadata/fail/src/main.rs         |   2 +-
 .../cargo_common_metadata/fail_publish/src/main.rs |   2 +-
 .../fail_publish_true/src/main.rs                  |   2 +-
 .../cargo_common_metadata/pass/src/main.rs         |   2 +-
 .../pass_publish_empty/src/main.rs                 |   2 +-
 .../pass_publish_false/src/main.rs                 |   2 +-
 tests/ui-cargo/feature_name/fail/src/main.rs       |   2 +-
 tests/ui-cargo/feature_name/pass/src/main.rs       |   2 +-
 .../module_style/fail_mod_remap/src/main.rs        |   2 +-
 .../5041_allow_dev_build/src/main.rs               |   2 +-
 .../multiple_crate_versions/fail/src/main.rs       |   2 +-
 .../multiple_crate_versions/pass/src/main.rs       |   2 +-
 .../wildcard_dependencies/fail/src/main.rs         |   2 +-
 .../wildcard_dependencies/pass/src/main.rs         |   2 +-
 .../ui-internal/collapsible_span_lint_calls.fixed  |   2 +-
 tests/ui-internal/collapsible_span_lint_calls.rs   |   2 +-
 tests/ui-internal/custom_ice_message.rs            |  12 +-
 tests/ui-internal/interning_defined_symbol.fixed   |   2 +-
 tests/ui-internal/interning_defined_symbol.rs      |   2 +-
 tests/ui-internal/invalid_msrv_attr_impl.fixed     |   2 +-
 tests/ui-internal/invalid_msrv_attr_impl.rs        |   2 +-
 tests/ui-internal/outer_expn_data.fixed            |   2 +-
 tests/ui-internal/outer_expn_data.rs               |   2 +-
 tests/ui-internal/unnecessary_def_path.fixed       |   4 +-
 tests/ui-internal/unnecessary_def_path.rs          |   4 +-
 tests/ui-internal/unnecessary_symbol_str.fixed     |   2 +-
 tests/ui-internal/unnecessary_symbol_str.rs        |   2 +-
 .../uninlined_format_args.fixed                    |   2 +-
 .../uninlined_format_args.rs                       |   2 +-
 tests/ui-toml/dbg_macro/dbg_macro.rs               |   2 +-
 .../ui-toml/disallowed_macros/disallowed_macros.rs |   2 +-
 tests/ui-toml/expect_used/expect_used.rs           |   2 +-
 tests/ui-toml/mut_key/mut_key.rs                   |   2 +-
 .../auxiliary/proc_macro_derive.rs                 |   4 +-
 .../conf_nonstandard_macro_braces.fixed            |   4 +-
 .../conf_nonstandard_macro_braces.rs               |   4 +-
 tests/ui-toml/print_macro/print_macro.rs           |   2 +-
 .../conf_disallowed_methods.rs                     |   2 +-
 tests/ui-toml/toml_trivially_copy/test.rs          |   4 +-
 tests/ui-toml/toml_unknown_key/conf_unknown_key.rs |   2 +
 tests/ui-toml/unwrap_used/unwrap_used.rs           |   2 +-
 tests/ui/allow_attributes.fixed                    |   2 +-
 tests/ui/allow_attributes.rs                       |   2 +-
 tests/ui/almost_complete_range.fixed               |   6 +-
 tests/ui/almost_complete_range.rs                  |   6 +-
 tests/ui/arithmetic_side_effects.rs                |   2 +-
 tests/ui/as_conversions.rs                         |   2 +-
 tests/ui/as_underscore.fixed                       |   2 +-
 tests/ui/as_underscore.rs                          |   2 +-
 tests/ui/asm_syntax.rs                             |   4 +-
 tests/ui/assertions_on_result_states.fixed         |   2 +-
 tests/ui/assertions_on_result_states.rs            |   2 +-
 tests/ui/assign_ops.fixed                          |   2 +-
 tests/ui/assign_ops.rs                             |   2 +-
 tests/ui/async_yields_async.fixed                  |   2 +-
 tests/ui/async_yields_async.rs                     |   2 +-
 tests/ui/author/blocks.rs                          |   2 +-
 tests/ui/auxiliary/proc_macro_attr.rs              |   4 +-
 tests/ui/auxiliary/proc_macro_derive.rs            |   4 +-
 .../proc_macro_suspicious_else_formatting.rs       |   4 +-
 tests/ui/auxiliary/proc_macro_unsafe.rs            |   4 +-
 tests/ui/auxiliary/proc_macros.rs                  |   4 +-
 tests/ui/bind_instead_of_map.fixed                 |   2 +-
 tests/ui/bind_instead_of_map.rs                    |   2 +-
 tests/ui/bind_instead_of_map_multipart.fixed       |   2 +-
 tests/ui/bind_instead_of_map_multipart.rs          |   2 +-
 tests/ui/blanket_clippy_restriction_lints.rs       |   2 +-
 tests/ui/blocks_in_if_conditions.fixed             |   2 +-
 tests/ui/blocks_in_if_conditions.rs                |   2 +-
 tests/ui/bool_assert_comparison.fixed              |   2 +-
 tests/ui/bool_assert_comparison.rs                 |   2 +-
 tests/ui/bool_comparison.fixed                     |   2 +-
 tests/ui/bool_comparison.rs                        |   2 +-
 tests/ui/bool_to_int_with_if.fixed                 |   2 +-
 tests/ui/bool_to_int_with_if.rs                    |   2 +-
 tests/ui/borrow_as_ptr.fixed                       |   2 +-
 tests/ui/borrow_as_ptr.rs                          |   2 +-
 tests/ui/borrow_as_ptr_no_std.fixed                |   2 +-
 tests/ui/borrow_as_ptr_no_std.rs                   |   2 +-
 tests/ui/borrow_deref_ref.fixed                    |   2 +-
 tests/ui/borrow_deref_ref.rs                       |   2 +-
 tests/ui/borrow_interior_mutable_const/enums.rs    |   2 +-
 tests/ui/box_default.fixed                         |   2 +-
 tests/ui/box_default.rs                            |   2 +-
 tests/ui/bytes_count_to_len.fixed                  |   2 +-
 tests/ui/bytes_count_to_len.rs                     |   2 +-
 tests/ui/bytes_nth.fixed                           |   2 +-
 tests/ui/bytes_nth.rs                              |   2 +-
 ...case_sensitive_file_extension_comparisons.fixed |   2 +-
 .../case_sensitive_file_extension_comparisons.rs   |   2 +-
 tests/ui/cast_abs_to_unsigned.fixed                |   2 +-
 tests/ui/cast_abs_to_unsigned.rs                   |   2 +-
 tests/ui/cast_lossless_bool.fixed                  |   2 +-
 tests/ui/cast_lossless_bool.rs                     |   2 +-
 tests/ui/cast_lossless_float.fixed                 |   2 +-
 tests/ui/cast_lossless_float.rs                    |   2 +-
 tests/ui/cast_lossless_integer.fixed               |   2 +-
 tests/ui/cast_lossless_integer.rs                  |   2 +-
 tests/ui/cast_raw_slice_pointer_cast.fixed         |   2 +-
 tests/ui/cast_raw_slice_pointer_cast.rs            |   2 +-
 tests/ui/cast_size.rs                              |   2 +-
 tests/ui/cast_size_32bit.rs                        |   2 +-
 tests/ui/cast_size_32bit.stderr                    |  53 +++++++++
 tests/ui/cfg_attr_rustfmt.fixed                    |   2 +-
 tests/ui/cfg_attr_rustfmt.rs                       |   2 +-
 tests/ui/char_lit_as_u8_suggestions.fixed          |   2 +-
 tests/ui/char_lit_as_u8_suggestions.rs             |   2 +-
 tests/ui/checked_conversions.fixed                 |   2 +-
 tests/ui/checked_conversions.rs                    |   2 +-
 tests/ui/clear_with_drain.fixed                    |   2 +-
 tests/ui/clear_with_drain.rs                       |   2 +-
 tests/ui/clone_on_copy.fixed                       |   2 +-
 tests/ui/clone_on_copy.rs                          |   2 +-
 tests/ui/cloned_instead_of_copied.fixed            |   2 +-
 tests/ui/cloned_instead_of_copied.rs               |   2 +-
 tests/ui/cmp_owned/asymmetric_partial_eq.fixed     |   2 +-
 tests/ui/cmp_owned/asymmetric_partial_eq.rs        |   2 +-
 tests/ui/cmp_owned/comparison_flip.fixed           |   2 +-
 tests/ui/cmp_owned/comparison_flip.rs              |   2 +-
 tests/ui/cmp_owned/with_suggestion.fixed           |   2 +-
 tests/ui/cmp_owned/with_suggestion.rs              |   2 +-
 tests/ui/collapsible_else_if.fixed                 |   2 +-
 tests/ui/collapsible_else_if.rs                    |   2 +-
 tests/ui/collapsible_if.fixed                      |   2 +-
 tests/ui/collapsible_if.rs                         |   2 +-
 tests/ui/collapsible_str_replace.fixed             |   2 +-
 tests/ui/collapsible_str_replace.rs                |   2 +-
 tests/ui/comparison_to_empty.fixed                 |   2 +-
 tests/ui/comparison_to_empty.rs                    |   2 +-
 tests/ui/crashes/auxiliary/proc_macro_crash.rs     |   4 +-
 tests/ui/crashes/ice-10148.rs                      |   2 +-
 tests/ui/crashes/ice-3741.rs                       |   2 +-
 tests/ui/crashes/ice-4968.rs                       |   2 +-
 tests/ui/crashes/ice-7272.rs                       |   2 +-
 tests/ui/crashes/ice-7410.rs                       |   6 +-
 tests/ui/crashes/ice-8681.rs                       |   2 +-
 tests/ui/crate_in_macro_def.fixed                  |   2 +-
 tests/ui/crate_in_macro_def.rs                     |   2 +-
 .../ui/crate_level_checks/entrypoint_recursion.rs  |   2 +-
 .../ui/crate_level_checks/no_std_main_recursion.rs |   4 +-
 tests/ui/create_dir.fixed                          |   2 +-
 tests/ui/create_dir.rs                             |   2 +-
 tests/ui/dbg_macro.rs                              |   2 +-
 tests/ui/decimal_literal_representation.fixed      |   2 +-
 tests/ui/decimal_literal_representation.rs         |   2 +-
 tests/ui/def_id_nocore.rs                          |   2 +-
 tests/ui/default_instead_of_iter_empty.fixed       |   2 +-
 tests/ui/default_instead_of_iter_empty.rs          |   2 +-
 tests/ui/default_numeric_fallback_f64.fixed        |   4 +-
 tests/ui/default_numeric_fallback_f64.rs           |   4 +-
 tests/ui/default_numeric_fallback_i32.fixed        |   4 +-
 tests/ui/default_numeric_fallback_i32.rs           |   4 +-
 tests/ui/default_trait_access.fixed                |   4 +-
 tests/ui/default_trait_access.rs                   |   4 +-
 tests/ui/deref_addrof.fixed                        |   4 +-
 tests/ui/deref_addrof.rs                           |   4 +-
 tests/ui/deref_addrof_macro.rs                     |   2 +-
 tests/ui/deref_by_slicing.fixed                    |   2 +-
 tests/ui/deref_by_slicing.rs                       |   2 +-
 tests/ui/derivable_impls.fixed                     |   2 +-
 tests/ui/derivable_impls.rs                        |   2 +-
 tests/ui/derive_partial_eq_without_eq.fixed        |   2 +-
 tests/ui/derive_partial_eq_without_eq.rs           |   2 +-
 tests/ui/doc/doc-fixable.fixed                     |   2 +-
 tests/ui/doc/doc-fixable.rs                        |   2 +-
 tests/ui/doc_unsafe.rs                             |   2 +-
 tests/ui/double_comparison.fixed                   |   2 +-
 tests/ui/double_comparison.rs                      |   2 +-
 tests/ui/duration_subsec.fixed                     |   2 +-
 tests/ui/duration_subsec.rs                        |   2 +-
 tests/ui/empty_drop.fixed                          |   2 +-
 tests/ui/empty_drop.rs                             |   2 +-
 tests/ui/empty_line_after_outer_attribute.rs       |   2 +-
 tests/ui/empty_loop.rs                             |   2 +-
 tests/ui/empty_loop_no_std.rs                      |   4 +-
 tests/ui/empty_structs_with_brackets.fixed         |   2 +-
 tests/ui/empty_structs_with_brackets.rs            |   2 +-
 tests/ui/entry.fixed                               |   4 +-
 tests/ui/entry.rs                                  |   4 +-
 tests/ui/entry_btree.fixed                         |   2 +-
 tests/ui/entry_btree.rs                            |   2 +-
 tests/ui/entry_with_else.fixed                     |   2 +-
 tests/ui/entry_with_else.rs                        |   2 +-
 tests/ui/enum_clike_unportable_variant.rs          |   2 +-
 tests/ui/enum_glob_use.fixed                       |   2 +-
 tests/ui/enum_glob_use.rs                          |   2 +-
 tests/ui/eq_op.rs                                  |   2 +-
 tests/ui/equatable_if_let.fixed                    |   4 +-
 tests/ui/equatable_if_let.rs                       |   4 +-
 tests/ui/err_expect.fixed                          |   2 +-
 tests/ui/err_expect.rs                             |   2 +-
 tests/ui/eta.fixed                                 |   2 +-
 tests/ui/eta.rs                                    |   2 +-
 tests/ui/excessive_precision.fixed                 |   2 +-
 tests/ui/excessive_precision.rs                    |   2 +-
 tests/ui/exhaustive_items.fixed                    |   2 +-
 tests/ui/exhaustive_items.rs                       |   2 +-
 tests/ui/expect_fun_call.fixed                     |   2 +-
 tests/ui/expect_fun_call.rs                        |   2 +-
 tests/ui/explicit_auto_deref.fixed                 |   2 +-
 tests/ui/explicit_auto_deref.rs                    |   2 +-
 tests/ui/explicit_deref_methods.fixed              |   2 +-
 tests/ui/explicit_deref_methods.rs                 |   2 +-
 tests/ui/explicit_write.fixed                      |   2 +-
 tests/ui/explicit_write.rs                         |   2 +-
 tests/ui/extend_with_drain.fixed                   |   2 +-
 tests/ui/extend_with_drain.rs                      |   2 +-
 tests/ui/extra_unused_lifetimes.rs                 |   2 +-
 tests/ui/extra_unused_type_parameters.fixed        |   2 +-
 tests/ui/extra_unused_type_parameters.rs           |   2 +-
 tests/ui/field_reassign_with_default.rs            |   4 +-
 tests/ui/filter_map_identity.fixed                 |   2 +-
 tests/ui/filter_map_identity.rs                    |   2 +-
 tests/ui/filter_map_next_fixable.fixed             |   2 +-
 tests/ui/filter_map_next_fixable.rs                |   2 +-
 tests/ui/flat_map_identity.fixed                   |   2 +-
 tests/ui/flat_map_identity.rs                      |   2 +-
 tests/ui/flat_map_option.fixed                     |   2 +-
 tests/ui/flat_map_option.rs                        |   2 +-
 tests/ui/floating_point_abs.fixed                  |   2 +-
 tests/ui/floating_point_abs.rs                     |   2 +-
 tests/ui/floating_point_exp.fixed                  |   2 +-
 tests/ui/floating_point_exp.rs                     |   2 +-
 tests/ui/floating_point_hypot.fixed                |   2 +-
 tests/ui/floating_point_hypot.rs                   |   2 +-
 tests/ui/floating_point_log.fixed                  |   2 +-
 tests/ui/floating_point_log.rs                     |   2 +-
 tests/ui/floating_point_logbase.fixed              |   2 +-
 tests/ui/floating_point_logbase.rs                 |   2 +-
 tests/ui/floating_point_mul_add.fixed              |   2 +-
 tests/ui/floating_point_mul_add.rs                 |   2 +-
 tests/ui/floating_point_powf.fixed                 |   2 +-
 tests/ui/floating_point_powf.rs                    |   2 +-
 tests/ui/floating_point_powi.fixed                 |   2 +-
 tests/ui/floating_point_powi.rs                    |   2 +-
 tests/ui/floating_point_rad.fixed                  |   2 +-
 tests/ui/floating_point_rad.rs                     |   2 +-
 tests/ui/fn_to_numeric_cast.rs                     |   2 +-
 tests/ui/fn_to_numeric_cast_32bit.rs               |   2 +-
 tests/ui/fn_to_numeric_cast_32bit.stderr           |  14 +--
 tests/ui/for_loop_fixable.fixed                    |   2 +-
 tests/ui/for_loop_fixable.rs                       |   2 +-
 tests/ui/format.fixed                              |   2 +-
 tests/ui/format.rs                                 |   2 +-
 tests/ui/format_args.fixed                         |   2 +-
 tests/ui/format_args.rs                            |   2 +-
 tests/ui/from_iter_instead_of_collect.fixed        |   2 +-
 tests/ui/from_iter_instead_of_collect.rs           |   2 +-
 tests/ui/from_over_into.fixed                      |   2 +-
 tests/ui/from_over_into.rs                         |   2 +-
 tests/ui/get_first.fixed                           |   2 +-
 tests/ui/get_first.rs                              |   2 +-
 tests/ui/get_last_with_len.fixed                   |   2 +-
 tests/ui/get_last_with_len.rs                      |   2 +-
 tests/ui/get_unwrap.fixed                          |   2 +-
 tests/ui/get_unwrap.rs                             |   2 +-
 tests/ui/identity_op.fixed                         |   2 +-
 tests/ui/identity_op.rs                            |   2 +-
 tests/ui/implicit_clone.fixed                      |   2 +-
 tests/ui/implicit_clone.rs                         |   2 +-
 tests/ui/implicit_hasher.rs                        |   2 +-
 tests/ui/implicit_return.fixed                     |   2 +-
 tests/ui/implicit_return.rs                        |   2 +-
 tests/ui/implicit_saturating_add.fixed             |   2 +-
 tests/ui/implicit_saturating_add.rs                |   2 +-
 tests/ui/implicit_saturating_sub.fixed             |   2 +-
 tests/ui/implicit_saturating_sub.rs                |   2 +-
 tests/ui/inconsistent_digit_grouping.fixed         |   2 +-
 tests/ui/inconsistent_digit_grouping.rs            |   2 +-
 tests/ui/inconsistent_struct_constructor.fixed     |   4 +-
 tests/ui/inconsistent_struct_constructor.rs        |   4 +-
 tests/ui/inefficient_to_string.fixed               |   2 +-
 tests/ui/inefficient_to_string.rs                  |   2 +-
 tests/ui/infallible_destructuring_match.fixed      |   2 +-
 tests/ui/infallible_destructuring_match.rs         |   2 +-
 tests/ui/inline_fn_without_body.fixed              |   2 +-
 tests/ui/inline_fn_without_body.rs                 |   2 +-
 tests/ui/int_plus_one.fixed                        |   2 +-
 tests/ui/int_plus_one.rs                           |   2 +-
 tests/ui/integer_arithmetic.rs                     |   2 +-
 tests/ui/into_iter_on_ref.fixed                    |   2 +-
 tests/ui/into_iter_on_ref.rs                       |   2 +-
 tests/ui/invalid_null_ptr_usage.fixed              |   2 +-
 tests/ui/invalid_null_ptr_usage.rs                 |   2 +-
 tests/ui/is_digit_ascii_radix.fixed                |   2 +-
 tests/ui/is_digit_ascii_radix.rs                   |   2 +-
 tests/ui/issue_2356.fixed                          |   2 +-
 tests/ui/issue_2356.rs                             |   2 +-
 tests/ui/iter_cloned_collect.fixed                 |   2 +-
 tests/ui/iter_cloned_collect.rs                    |   2 +-
 tests/ui/iter_count.fixed                          |   4 +-
 tests/ui/iter_count.rs                             |   4 +-
 tests/ui/iter_kv_map.fixed                         |   2 +-
 tests/ui/iter_kv_map.rs                            |   2 +-
 tests/ui/iter_next_slice.fixed                     |   2 +-
 tests/ui/iter_next_slice.rs                        |   2 +-
 tests/ui/iter_nth.rs                               |   2 +-
 tests/ui/iter_nth_zero.fixed                       |   2 +-
 tests/ui/iter_nth_zero.rs                          |   2 +-
 tests/ui/iter_on_empty_collections.fixed           |   2 +-
 tests/ui/iter_on_empty_collections.rs              |   2 +-
 tests/ui/iter_on_single_items.fixed                |   2 +-
 tests/ui/iter_on_single_items.rs                   |   2 +-
 tests/ui/iter_overeager_cloned.fixed               |   2 +-
 tests/ui/iter_overeager_cloned.rs                  |   2 +-
 tests/ui/iter_skip_next.fixed                      |   4 +-
 tests/ui/iter_skip_next.rs                         |   4 +-
 tests/ui/iter_with_drain.fixed                     |   2 +-
 tests/ui/iter_with_drain.rs                        |   2 +-
 tests/ui/large_const_arrays.fixed                  |   2 +-
 tests/ui/large_const_arrays.rs                     |   2 +-
 tests/ui/large_digit_groups.fixed                  |   2 +-
 tests/ui/large_digit_groups.rs                     |   2 +-
 tests/ui/large_enum_variant.rs                     |   2 +-
 tests/ui/large_types_passed_by_value.rs            |   4 +-
 tests/ui/len_zero.fixed                            |   2 +-
 tests/ui/len_zero.rs                               |   2 +-
 tests/ui/len_zero_ranges.fixed                     |   2 +-
 tests/ui/len_zero_ranges.rs                        |   2 +-
 tests/ui/let_unit.fixed                            |   2 +-
 tests/ui/let_unit.rs                               |   2 +-
 tests/ui/lines_filter_map_ok.fixed                 |   2 +-
 tests/ui/lines_filter_map_ok.rs                    |   2 +-
 tests/ui/lossy_float_literal.fixed                 |   2 +-
 tests/ui/lossy_float_literal.rs                    |   2 +-
 tests/ui/macro_use_imports.fixed                   |  10 +-
 tests/ui/macro_use_imports.rs                      |  10 +-
 tests/ui/macro_use_imports_expect.rs               |   8 +-
 tests/ui/manual_assert.edition2018.fixed           |   8 +-
 tests/ui/manual_assert.edition2021.fixed           |   8 +-
 tests/ui/manual_assert.rs                          |   8 +-
 tests/ui/manual_async_fn.fixed                     |   2 +-
 tests/ui/manual_async_fn.rs                        |   2 +-
 tests/ui/manual_bits.fixed                         |   2 +-
 tests/ui/manual_bits.rs                            |   2 +-
 tests/ui/manual_filter.fixed                       |   2 +-
 tests/ui/manual_filter.rs                          |   2 +-
 tests/ui/manual_filter_map.fixed                   |   2 +-
 tests/ui/manual_filter_map.rs                      |   2 +-
 tests/ui/manual_find_fixable.fixed                 |   2 +-
 tests/ui/manual_find_fixable.rs                    |   2 +-
 tests/ui/manual_find_map.fixed                     |   2 +-
 tests/ui/manual_find_map.rs                        |   2 +-
 tests/ui/manual_instant_elapsed.fixed              |   2 +-
 tests/ui/manual_instant_elapsed.rs                 |   2 +-
 tests/ui/manual_is_ascii_check.fixed               |   2 +-
 tests/ui/manual_is_ascii_check.rs                  |   2 +-
 tests/ui/manual_main_separator_str.fixed           |   2 +-
 tests/ui/manual_main_separator_str.rs              |   2 +-
 tests/ui/manual_map_option.fixed                   |   2 +-
 tests/ui/manual_map_option.rs                      |   2 +-
 tests/ui/manual_map_option_2.fixed                 |   2 +-
 tests/ui/manual_map_option_2.rs                    |   2 +-
 tests/ui/manual_ok_or.fixed                        |   2 +-
 tests/ui/manual_ok_or.rs                           |   2 +-
 tests/ui/manual_rem_euclid.fixed                   |   4 +-
 tests/ui/manual_rem_euclid.rs                      |   4 +-
 tests/ui/manual_retain.fixed                       |   2 +-
 tests/ui/manual_retain.rs                          |   2 +-
 tests/ui/manual_saturating_arithmetic.fixed        |   2 +-
 tests/ui/manual_saturating_arithmetic.rs           |   2 +-
 tests/ui/manual_slice_size_calculation.fixed       |   4 +-
 tests/ui/manual_slice_size_calculation.rs          |   4 +-
 tests/ui/manual_split_once.fixed                   |   2 +-
 tests/ui/manual_split_once.rs                      |   2 +-
 tests/ui/manual_str_repeat.fixed                   |   2 +-
 tests/ui/manual_str_repeat.rs                      |   2 +-
 tests/ui/manual_string_new.fixed                   |   2 +-
 tests/ui/manual_string_new.rs                      |   2 +-
 tests/ui/manual_unwrap_or.fixed                    |   2 +-
 tests/ui/manual_unwrap_or.rs                       |   2 +-
 tests/ui/map_clone.fixed                           |   2 +-
 tests/ui/map_clone.rs                              |   2 +-
 tests/ui/map_collect_result_unit.fixed             |   2 +-
 tests/ui/map_collect_result_unit.rs                |   2 +-
 tests/ui/map_flatten_fixable.fixed                 |   2 +-
 tests/ui/map_flatten_fixable.rs                    |   2 +-
 tests/ui/map_identity.fixed                        |   2 +-
 tests/ui/map_identity.rs                           |   2 +-
 tests/ui/map_unwrap_or.rs                          |   2 +-
 tests/ui/map_unwrap_or_fixable.fixed               |   4 +-
 tests/ui/map_unwrap_or_fixable.rs                  |   4 +-
 tests/ui/match_as_ref.fixed                        |   2 +-
 tests/ui/match_as_ref.rs                           |   2 +-
 tests/ui/match_expr_like_matches_macro.fixed       |   2 +-
 tests/ui/match_expr_like_matches_macro.rs          |   2 +-
 tests/ui/match_ref_pats.fixed                      |   2 +-
 tests/ui/match_ref_pats.rs                         |   2 +-
 tests/ui/match_result_ok.fixed                     |   2 +-
 tests/ui/match_result_ok.rs                        |   2 +-
 tests/ui/match_single_binding.fixed                |   2 +-
 tests/ui/match_single_binding.rs                   |   2 +-
 tests/ui/match_single_binding2.fixed               |   2 +-
 tests/ui/match_single_binding2.rs                  |   2 +-
 tests/ui/match_str_case_mismatch.fixed             |   2 +-
 tests/ui/match_str_case_mismatch.rs                |   2 +-
 tests/ui/match_wildcard_for_single_variants.fixed  |   2 +-
 tests/ui/match_wildcard_for_single_variants.rs     |   2 +-
 tests/ui/mem_replace.fixed                         |   2 +-
 tests/ui/mem_replace.rs                            |   2 +-
 tests/ui/mem_replace_macro.rs                      |   2 +-
 tests/ui/methods.rs                                |   2 +-
 tests/ui/methods_fixable.fixed                     |   2 +-
 tests/ui/methods_fixable.rs                        |   2 +-
 tests/ui/mismatched_target_os_non_unix.fixed       |   2 +-
 tests/ui/mismatched_target_os_non_unix.rs          |   2 +-
 tests/ui/mismatched_target_os_unix.fixed           |   2 +-
 tests/ui/mismatched_target_os_unix.rs              |   2 +-
 tests/ui/missing_const_for_fn/cant_be_const.rs     |   4 +-
 tests/ui/missing_doc.rs                            |   4 +-
 tests/ui/missing_doc_impl.rs                       |   2 +-
 tests/ui/missing_spin_loop.fixed                   |   2 +-
 tests/ui/missing_spin_loop.rs                      |   2 +-
 tests/ui/missing_spin_loop_no_std.fixed            |   2 +-
 tests/ui/missing_spin_loop_no_std.rs               |   2 +-
 tests/ui/mistyped_literal_suffix.fixed             |   4 +-
 tests/ui/mistyped_literal_suffix.rs                |   4 +-
 tests/ui/module_name_repetitions.rs                |   2 +-
 tests/ui/multiple_unsafe_ops_per_block.rs          |   2 +-
 tests/ui/must_use_candidates.fixed                 |   2 +-
 tests/ui/must_use_candidates.rs                    |   2 +-
 tests/ui/must_use_unit.fixed                       |   4 +-
 tests/ui/must_use_unit.rs                          |   4 +-
 tests/ui/mut_mut.rs                                |   2 +-
 tests/ui/mut_mutex_lock.fixed                      |   2 +-
 tests/ui/mut_mutex_lock.rs                         |   2 +-
 tests/ui/needless_arbitrary_self_type.fixed        |   2 +-
 tests/ui/needless_arbitrary_self_type.rs           |   2 +-
 tests/ui/needless_arbitrary_self_type_unfixable.rs |   2 +-
 tests/ui/needless_bitwise_bool.fixed               |   2 +-
 tests/ui/needless_bitwise_bool.rs                  |   2 +-
 tests/ui/needless_bool/fixable.fixed               |   2 +-
 tests/ui/needless_bool/fixable.rs                  |   2 +-
 tests/ui/needless_borrow.fixed                     |   2 +-
 tests/ui/needless_borrow.rs                        |   2 +-
 tests/ui/needless_borrowed_ref.fixed               |   2 +-
 tests/ui/needless_borrowed_ref.rs                  |   2 +-
 tests/ui/needless_collect.fixed                    |   2 +-
 tests/ui/needless_collect.rs                       |   2 +-
 tests/ui/needless_for_each_fixable.fixed           |   2 +-
 tests/ui/needless_for_each_fixable.rs              |   2 +-
 tests/ui/needless_late_init.fixed                  |   4 +-
 tests/ui/needless_late_init.rs                     |   4 +-
 tests/ui/needless_lifetimes.fixed                  |   4 +-
 tests/ui/needless_lifetimes.rs                     |   4 +-
 tests/ui/needless_match.fixed                      |   2 +-
 tests/ui/needless_match.rs                         |   2 +-
 tests/ui/needless_option_as_deref.fixed            |   2 +-
 tests/ui/needless_option_as_deref.rs               |   2 +-
 tests/ui/needless_option_take.fixed                |   2 +-
 tests/ui/needless_option_take.rs                   |   2 +-
 tests/ui/needless_parens_on_range_literals.fixed   |   4 +-
 tests/ui/needless_parens_on_range_literals.rs      |   4 +-
 tests/ui/needless_question_mark.fixed              |   2 +-
 tests/ui/needless_question_mark.rs                 |   2 +-
 tests/ui/needless_return.fixed                     |   2 +-
 tests/ui/needless_return.rs                        |   2 +-
 tests/ui/needless_splitn.fixed                     |   4 +-
 tests/ui/needless_splitn.rs                        |   4 +-
 tests/ui/neg_multiply.fixed                        |   2 +-
 tests/ui/neg_multiply.rs                           |   2 +-
 tests/ui/non_octal_unix_permissions.fixed          |   4 +-
 tests/ui/non_octal_unix_permissions.rs             |   4 +-
 tests/ui/nonminimal_bool_methods.fixed             |   2 +-
 tests/ui/nonminimal_bool_methods.rs                |   2 +-
 tests/ui/numbered_fields.fixed                     |   2 +-
 tests/ui/numbered_fields.rs                        |   2 +-
 tests/ui/obfuscated_if_else.fixed                  |   2 +-
 tests/ui/obfuscated_if_else.rs                     |   2 +-
 tests/ui/option_as_ref_deref.fixed                 |   2 +-
 tests/ui/option_as_ref_deref.rs                    |   2 +-
 tests/ui/option_env_unwrap.rs                      |   2 +-
 tests/ui/option_filter_map.fixed                   |   2 +-
 tests/ui/option_filter_map.rs                      |   2 +-
 tests/ui/option_if_let_else.fixed                  |   2 +-
 tests/ui/option_if_let_else.rs                     |   2 +-
 tests/ui/option_map_or_none.fixed                  |   2 +-
 tests/ui/option_map_or_none.rs                     |   2 +-
 tests/ui/option_map_unit_fn_fixable.fixed          |   2 +-
 tests/ui/option_map_unit_fn_fixable.rs             |   2 +-
 tests/ui/or_fun_call.fixed                         |   2 +-
 tests/ui/or_fun_call.rs                            |   2 +-
 tests/ui/or_then_unwrap.fixed                      |   2 +-
 tests/ui/or_then_unwrap.rs                         |   2 +-
 tests/ui/partialeq_to_none.fixed                   |   2 +-
 tests/ui/partialeq_to_none.rs                      |   2 +-
 tests/ui/path_buf_push_overwrite.fixed             |   2 +-
 tests/ui/path_buf_push_overwrite.rs                |   2 +-
 tests/ui/patterns.fixed                            |   2 +-
 tests/ui/patterns.rs                               |   2 +-
 tests/ui/precedence.fixed                          |   2 +-
 tests/ui/precedence.rs                             |   2 +-
 tests/ui/print_stdout_build_script.rs              |   2 +-
 tests/ui/print_with_newline.rs                     |   2 +-
 tests/ui/println_empty_string.fixed                |   2 +-
 tests/ui/println_empty_string.rs                   |   2 +-
 tests/ui/ptr_as_ptr.fixed                          |   4 +-
 tests/ui/ptr_as_ptr.rs                             |   4 +-
 tests/ui/ptr_eq.fixed                              |   2 +-
 tests/ui/ptr_eq.rs                                 |   2 +-
 tests/ui/ptr_offset_with_cast.fixed                |   2 +-
 tests/ui/ptr_offset_with_cast.rs                   |   2 +-
 tests/ui/question_mark.fixed                       |   2 +-
 tests/ui/question_mark.rs                          |   2 +-
 tests/ui/range_contains.fixed                      |   2 +-
 tests/ui/range_contains.rs                         |   2 +-
 tests/ui/range_plus_minus_one.fixed                |   2 +-
 tests/ui/range_plus_minus_one.rs                   |   2 +-
 tests/ui/rc_buffer.fixed                           |   2 +-
 tests/ui/rc_buffer.rs                              |   2 +-
 tests/ui/rc_buffer_arc.fixed                       |   2 +-
 tests/ui/rc_buffer_arc.rs                          |   2 +-
 tests/ui/redundant_allocation_fixable.fixed        |   2 +-
 tests/ui/redundant_allocation_fixable.rs           |   2 +-
 tests/ui/redundant_async_block.fixed               |   2 +-
 tests/ui/redundant_async_block.rs                  |   2 +-
 tests/ui/redundant_clone.fixed                     |   2 +-
 tests/ui/redundant_clone.rs                        |   2 +-
 tests/ui/redundant_closure_call_fixable.fixed      |   2 +-
 tests/ui/redundant_closure_call_fixable.rs         |   2 +-
 tests/ui/redundant_field_names.fixed               |   2 +-
 tests/ui/redundant_field_names.rs                  |   2 +-
 .../ui/redundant_pattern_matching_drop_order.fixed |   2 +-
 tests/ui/redundant_pattern_matching_drop_order.rs  |   2 +-
 tests/ui/redundant_pattern_matching_ipaddr.fixed   |   2 +-
 tests/ui/redundant_pattern_matching_ipaddr.rs      |   2 +-
 tests/ui/redundant_pattern_matching_option.fixed   |   2 +-
 tests/ui/redundant_pattern_matching_option.rs      |   2 +-
 tests/ui/redundant_pattern_matching_poll.fixed     |   2 +-
 tests/ui/redundant_pattern_matching_poll.rs        |   2 +-
 tests/ui/redundant_pattern_matching_result.fixed   |   2 +-
 tests/ui/redundant_pattern_matching_result.rs      |   2 +-
 tests/ui/redundant_pub_crate.fixed                 |   2 +-
 tests/ui/redundant_pub_crate.rs                    |   2 +-
 tests/ui/redundant_slicing.fixed                   |   2 +-
 tests/ui/redundant_slicing.rs                      |   2 +-
 tests/ui/redundant_static_lifetimes.fixed          |   2 +-
 tests/ui/redundant_static_lifetimes.rs             |   2 +-
 tests/ui/rename.fixed                              |   2 +-
 tests/ui/rename.rs                                 |   2 +-
 tests/ui/renamed_builtin_attr.fixed                |   2 +-
 tests/ui/renamed_builtin_attr.rs                   |   2 +-
 tests/ui/repeat_once.fixed                         |   2 +-
 tests/ui/repeat_once.rs                            |   2 +-
 tests/ui/result_map_or_into_option.fixed           |   2 +-
 tests/ui/result_map_or_into_option.rs              |   2 +-
 tests/ui/result_map_unit_fn_fixable.fixed          |   2 +-
 tests/ui/result_map_unit_fn_fixable.rs             |   2 +-
 tests/ui/reversed_empty_ranges_fixable.fixed       |   2 +-
 tests/ui/reversed_empty_ranges_fixable.rs          |   2 +-
 tests/ui/reversed_empty_ranges_loops_fixable.fixed |   2 +-
 tests/ui/reversed_empty_ranges_loops_fixable.rs    |   2 +-
 tests/ui/same_functions_in_if_condition.rs         |   2 +-
 tests/ui/same_functions_in_if_condition.stderr     |   6 +-
 tests/ui/search_is_some.rs                         |   2 +-
 tests/ui/search_is_some_fixable_none.fixed         |   2 +-
 tests/ui/search_is_some_fixable_none.rs            |   2 +-
 tests/ui/search_is_some_fixable_some.fixed         |   2 +-
 tests/ui/search_is_some_fixable_some.rs            |   2 +-
 tests/ui/seek_from_current.fixed                   |   2 +-
 tests/ui/seek_from_current.rs                      |   2 +-
 tests/ui/seek_to_start_instead_of_rewind.fixed     |   2 +-
 tests/ui/seek_to_start_instead_of_rewind.rs        |   2 +-
 tests/ui/semicolon_inside_block.fixed              |   2 +-
 tests/ui/semicolon_inside_block.rs                 |   2 +-
 tests/ui/semicolon_outside_block.fixed             |   2 +-
 tests/ui/semicolon_outside_block.rs                |   2 +-
 tests/ui/shadow.rs                                 |   2 +-
 tests/ui/short_circuit_statement.fixed             |   2 +-
 tests/ui/short_circuit_statement.rs                |   2 +-
 tests/ui/significant_drop_in_scrutinee.rs          |   2 +-
 tests/ui/significant_drop_tightening.fixed         |   2 +-
 tests/ui/significant_drop_tightening.rs            |   2 +-
 tests/ui/single_char_add_str.fixed                 |   2 +-
 tests/ui/single_char_add_str.rs                    |   2 +-
 tests/ui/single_char_pattern.fixed                 |   2 +-
 tests/ui/single_char_pattern.rs                    |   2 +-
 tests/ui/single_component_path_imports.fixed       |   2 +-
 tests/ui/single_component_path_imports.rs          |   2 +-
 tests/ui/single_element_loop.fixed                 |   2 +-
 tests/ui/single_element_loop.rs                    |   2 +-
 tests/ui/single_match_else.rs                      |   2 +-
 tests/ui/skip_while_next.rs                        |   2 +-
 tests/ui/stable_sort_primitive.fixed               |   2 +-
 tests/ui/stable_sort_primitive.rs                  |   2 +-
 tests/ui/starts_ends_with.fixed                    |   2 +-
 tests/ui/starts_ends_with.rs                       |   2 +-
 tests/ui/string_add.rs                             |   2 +-
 tests/ui/string_add_assign.fixed                   |   2 +-
 tests/ui/string_add_assign.rs                      |   2 +-
 tests/ui/string_extend.fixed                       |   2 +-
 tests/ui/string_extend.rs                          |   2 +-
 tests/ui/string_from_utf8_as_bytes.fixed           |   2 +-
 tests/ui/string_from_utf8_as_bytes.rs              |   2 +-
 tests/ui/string_lit_as_bytes.fixed                 |   2 +-
 tests/ui/string_lit_as_bytes.rs                    |   2 +-
 tests/ui/strlen_on_c_strings.fixed                 |   2 +-
 tests/ui/strlen_on_c_strings.rs                    |   2 +-
 tests/ui/suspicious_doc_comments.fixed             |   2 +-
 tests/ui/suspicious_doc_comments.rs                |   2 +-
 tests/ui/suspicious_else_formatting.rs             |   2 +-
 tests/ui/suspicious_operation_groupings.fixed      |   2 +-
 tests/ui/suspicious_operation_groupings.rs         |   2 +-
 tests/ui/swap.fixed                                |   4 +-
 tests/ui/swap.rs                                   |   4 +-
 tests/ui/swap_ptr_to_ref.fixed                     |   2 +-
 tests/ui/swap_ptr_to_ref.rs                        |   2 +-
 tests/ui/tabs_in_doc_comments.fixed                |   2 +-
 tests/ui/tabs_in_doc_comments.rs                   |   2 +-
 tests/ui/tests_outside_test_module.rs              |   2 +-
 tests/ui/to_digit_is_some.fixed                    |   2 +-
 tests/ui/to_digit_is_some.rs                       |   2 +-
 tests/ui/toplevel_ref_arg.fixed                    |   4 +-
 tests/ui/toplevel_ref_arg.rs                       |   4 +-
 tests/ui/toplevel_ref_arg_non_rustfix.rs           |   2 +-
 tests/ui/track-diagnostics.rs                      |   5 +-
 tests/ui/trait_duplication_in_bounds.fixed         |   2 +-
 tests/ui/trait_duplication_in_bounds.rs            |   2 +-
 tests/ui/transmute_32bit.rs                        |   2 +-
 tests/ui/transmute_32bit.stderr                    |  29 +++--
 tests/ui/transmute_64bit.rs                        |   2 +-
 tests/ui/transmute_ptr_to_ref.fixed                |   2 +-
 tests/ui/transmute_ptr_to_ref.rs                   |   2 +-
 tests/ui/transmutes_expressible_as_ptr_casts.fixed |   2 +-
 tests/ui/transmutes_expressible_as_ptr_casts.rs    |   2 +-
 tests/ui/trim_split_whitespace.fixed               |   2 +-
 tests/ui/trim_split_whitespace.rs                  |   2 +-
 tests/ui/trivially_copy_pass_by_ref.rs             |   4 +-
 tests/ui/try_err.fixed                             |   4 +-
 tests/ui/try_err.rs                                |   4 +-
 tests/ui/types.fixed                               |   2 +-
 tests/ui/types.rs                                  |   2 +-
 tests/ui/unchecked_duration_subtraction.fixed      |   2 +-
 tests/ui/unchecked_duration_subtraction.rs         |   2 +-
 tests/ui/undocumented_unsafe_blocks.rs             |   2 +-
 tests/ui/unicode.fixed                             |   4 +-
 tests/ui/unicode.rs                                |   4 +-
 tests/ui/uninlined_format_args.fixed               |   4 +-
 tests/ui/uninlined_format_args.rs                  |   4 +-
 .../uninlined_format_args_panic.edition2018.fixed  |   8 +-
 .../uninlined_format_args_panic.edition2021.fixed  |   8 +-
 tests/ui/uninlined_format_args_panic.rs            |   8 +-
 tests/ui/unit_arg.rs                               |   2 +-
 tests/ui/unit_arg_empty_blocks.fixed               |   2 +-
 tests/ui/unit_arg_empty_blocks.rs                  |   2 +-
 tests/ui/unknown_clippy_lints.fixed                |   2 +-
 tests/ui/unknown_clippy_lints.rs                   |   2 +-
 tests/ui/unnecessary_cast.fixed                    |   2 +-
 tests/ui/unnecessary_cast.rs                       |   2 +-
 tests/ui/unnecessary_fold.fixed                    |   2 +-
 tests/ui/unnecessary_fold.rs                       |   2 +-
 tests/ui/unnecessary_iter_cloned.fixed             |   2 +-
 tests/ui/unnecessary_iter_cloned.rs                |   2 +-
 tests/ui/unnecessary_join.fixed                    |   2 +-
 tests/ui/unnecessary_join.rs                       |   2 +-
 tests/ui/unnecessary_lazy_eval.fixed               |   4 +-
 tests/ui/unnecessary_lazy_eval.rs                  |   4 +-
 tests/ui/unnecessary_operation.fixed               |   2 +-
 tests/ui/unnecessary_operation.rs                  |   2 +-
 tests/ui/unnecessary_owned_empty_strings.fixed     |   2 +-
 tests/ui/unnecessary_owned_empty_strings.rs        |   2 +-
 tests/ui/unnecessary_self_imports.fixed            |   2 +-
 tests/ui/unnecessary_self_imports.rs               |   2 +-
 tests/ui/unnecessary_sort_by.fixed                 |   2 +-
 tests/ui/unnecessary_sort_by.rs                    |   2 +-
 tests/ui/unnecessary_struct_initialization.fixed   |   2 +-
 tests/ui/unnecessary_struct_initialization.rs      |   2 +-
 tests/ui/unnecessary_to_owned.fixed                |   2 +-
 tests/ui/unnecessary_to_owned.rs                   |   2 +-
 tests/ui/unnecessary_unsafety_doc.rs               |   2 +-
 tests/ui/unneeded_wildcard_pattern.fixed           |   2 +-
 tests/ui/unneeded_wildcard_pattern.rs              |   2 +-
 tests/ui/unnested_or_patterns.fixed                |   2 +-
 tests/ui/unnested_or_patterns.rs                   |   2 +-
 tests/ui/unnested_or_patterns2.fixed               |   2 +-
 tests/ui/unnested_or_patterns2.rs                  |   2 +-
 tests/ui/unreadable_literal.fixed                  |   2 +-
 tests/ui/unreadable_literal.rs                     |   2 +-
 tests/ui/unseparated_prefix_literals.fixed         |   4 +-
 tests/ui/unseparated_prefix_literals.rs            |   4 +-
 tests/ui/unused_rounding.fixed                     |   2 +-
 tests/ui/unused_rounding.rs                        |   2 +-
 tests/ui/unused_unit.fixed                         |   2 +-
 tests/ui/unused_unit.rs                            |   2 +-
 tests/ui/unwrap_or_else_default.fixed              |   2 +-
 tests/ui/unwrap_or_else_default.rs                 |   2 +-
 tests/ui/use_self.fixed                            |   4 +-
 tests/ui/use_self.rs                               |   4 +-
 tests/ui/use_self_trait.fixed                      |   2 +-
 tests/ui/use_self_trait.rs                         |   2 +-
 tests/ui/used_underscore_binding.rs                |   2 +-
 tests/ui/useless_asref.fixed                       |   2 +-
 tests/ui/useless_asref.rs                          |   2 +-
 tests/ui/useless_attribute.fixed                   |   4 +-
 tests/ui/useless_attribute.rs                      |   4 +-
 tests/ui/useless_conversion.fixed                  |   2 +-
 tests/ui/useless_conversion.rs                     |   2 +-
 tests/ui/vec.fixed                                 |   2 +-
 tests/ui/vec.rs                                    |   2 +-
 tests/ui/vec_box_sized.fixed                       |   2 +-
 tests/ui/vec_box_sized.rs                          |   2 +-
 tests/ui/while_let_on_iterator.fixed               |   2 +-
 tests/ui/while_let_on_iterator.rs                  |   2 +-
 tests/ui/wildcard_enum_match_arm.fixed             |   4 +-
 tests/ui/wildcard_enum_match_arm.rs                |   4 +-
 tests/ui/wildcard_imports.fixed                    |   6 +-
 tests/ui/wildcard_imports.rs                       |   6 +-
 tests/ui/wildcard_imports_2021.edition2018.fixed   |  10 +-
 tests/ui/wildcard_imports_2021.edition2021.fixed   |  10 +-
 tests/ui/wildcard_imports_2021.rs                  |  10 +-
 tests/ui/wildcard_imports_2021.stderr              | 132 ---------------------
 tests/ui/write_with_newline.rs                     |   4 +-
 tests/ui/write_with_newline.stderr                 |   6 +-
 tests/ui/writeln_empty_string.fixed                |   2 +-
 tests/ui/writeln_empty_string.rs                   |   2 +-
 tests/ui/zero_ptr.fixed                            |   2 +-
 tests/ui/zero_ptr.rs                               |   2 +-
 tests/ui/zero_ptr_no_std.fixed                     |   2 +-
 tests/ui/zero_ptr_no_std.rs                        |   2 +-
 724 files changed, 945 insertions(+), 1009 deletions(-)
 delete mode 100644 tests/ui/wildcard_imports_2021.stderr

(limited to 'clippy_lints/src')

diff --git a/Cargo.toml b/Cargo.toml
index 5bb9f527081..1ec168737b8 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -28,7 +28,7 @@ tempfile = { version = "3.2", optional = true }
 termize = "0.1"
 
 [dev-dependencies]
-compiletest_rs = { version = "0.9", features = ["tmp"] }
+compiletest_rs = { version = "0.10", features = ["tmp"] }
 tester = "0.9"
 regex = "1.5"
 toml = "0.5"
diff --git a/book/src/development/adding_lints.md b/book/src/development/adding_lints.md
index 9dacaaaae5c..ccae8d37420 100644
--- a/book/src/development/adding_lints.md
+++ b/book/src/development/adding_lints.md
@@ -164,7 +164,7 @@ The process of generating the `.stderr` file is the same, and prepending the
 ## Rustfix tests
 
 If the lint you are working on is making use of structured suggestions, the test
-file should include a `// run-rustfix` comment at the top. This will
+file should include a `//@run-rustfix` comment at the top. This will
 additionally run [rustfix] for that test. Rustfix will apply the suggestions
 from the lint to the code of the test file and compare that to the contents of a
 `.fixed` file.
diff --git a/clippy_dev/src/update_lints.rs b/clippy_dev/src/update_lints.rs
index 95222a9acdf..dd90a38f757 100644
--- a/clippy_dev/src/update_lints.rs
+++ b/clippy_dev/src/update_lints.rs
@@ -741,7 +741,7 @@ fn gen_deprecated_lints_test(lints: &[DeprecatedLint]) -> String {
 fn gen_renamed_lints_test(lints: &[RenamedLint]) -> String {
     let mut seen_lints = HashSet::new();
     let mut res: String = GENERATED_FILE_COMMENT.into();
-    res.push_str("// run-rustfix\n\n");
+    res.push_str("//@run-rustfix\n\n");
     for lint in lints {
         if seen_lints.insert(&lint.new_name) {
             writeln!(res, "#![allow({})]", lint.new_name).unwrap();
diff --git a/clippy_lints/src/methods/obfuscated_if_else.rs b/clippy_lints/src/methods/obfuscated_if_else.rs
index 4d7427b2662..eada530d670 100644
--- a/clippy_lints/src/methods/obfuscated_if_else.rs
+++ b/clippy_lints/src/methods/obfuscated_if_else.rs
@@ -1,5 +1,3 @@
-// run-rustfix
-
 use super::OBFUSCATED_IF_ELSE;
 use clippy_utils::{diagnostics::span_lint_and_sugg, source::snippet_with_applicability};
 use rustc_errors::Applicability;
diff --git a/tests/compile-test.rs b/tests/compile-test.rs
index 57890ff3173..35d75cc51c2 100644
--- a/tests/compile-test.rs
+++ b/tests/compile-test.rs
@@ -126,6 +126,7 @@ fn base_config(test_dir: &str) -> compiletest::Config {
     let mut config = compiletest::Config {
         edition: Some("2021".into()),
         mode: TestMode::Ui,
+        strict_headers: true,
         ..Default::default()
     };
 
@@ -424,7 +425,7 @@ fn check_rustfix_coverage() {
                     .binary_search_by_key(&filename, Path::new)
                     .is_ok(),
                 "`{rs_file}` runs `MachineApplicable` diagnostics but is missing a `run-rustfix` annotation. \
-                Please either add `// run-rustfix` at the top of the file or add the file to \
+                Please either add `//@run-rustfix` at the top of the file or add the file to \
                 `RUSTFIX_COVERAGE_KNOWN_EXCEPTIONS` in `tests/compile-test.rs`.",
             );
         }
diff --git a/tests/ui-cargo/cargo_common_metadata/fail/src/main.rs b/tests/ui-cargo/cargo_common_metadata/fail/src/main.rs
index 27841e18aa9..1a69bb24101 100644
--- a/tests/ui-cargo/cargo_common_metadata/fail/src/main.rs
+++ b/tests/ui-cargo/cargo_common_metadata/fail/src/main.rs
@@ -1,4 +1,4 @@
-// compile-flags: --crate-name=cargo_common_metadata
+//@compile-flags: --crate-name=cargo_common_metadata
 #![warn(clippy::cargo_common_metadata)]
 
 fn main() {}
diff --git a/tests/ui-cargo/cargo_common_metadata/fail_publish/src/main.rs b/tests/ui-cargo/cargo_common_metadata/fail_publish/src/main.rs
index 27841e18aa9..1a69bb24101 100644
--- a/tests/ui-cargo/cargo_common_metadata/fail_publish/src/main.rs
+++ b/tests/ui-cargo/cargo_common_metadata/fail_publish/src/main.rs
@@ -1,4 +1,4 @@
-// compile-flags: --crate-name=cargo_common_metadata
+//@compile-flags: --crate-name=cargo_common_metadata
 #![warn(clippy::cargo_common_metadata)]
 
 fn main() {}
diff --git a/tests/ui-cargo/cargo_common_metadata/fail_publish_true/src/main.rs b/tests/ui-cargo/cargo_common_metadata/fail_publish_true/src/main.rs
index 27841e18aa9..1a69bb24101 100644
--- a/tests/ui-cargo/cargo_common_metadata/fail_publish_true/src/main.rs
+++ b/tests/ui-cargo/cargo_common_metadata/fail_publish_true/src/main.rs
@@ -1,4 +1,4 @@
-// compile-flags: --crate-name=cargo_common_metadata
+//@compile-flags: --crate-name=cargo_common_metadata
 #![warn(clippy::cargo_common_metadata)]
 
 fn main() {}
diff --git a/tests/ui-cargo/cargo_common_metadata/pass/src/main.rs b/tests/ui-cargo/cargo_common_metadata/pass/src/main.rs
index 27841e18aa9..1a69bb24101 100644
--- a/tests/ui-cargo/cargo_common_metadata/pass/src/main.rs
+++ b/tests/ui-cargo/cargo_common_metadata/pass/src/main.rs
@@ -1,4 +1,4 @@
-// compile-flags: --crate-name=cargo_common_metadata
+//@compile-flags: --crate-name=cargo_common_metadata
 #![warn(clippy::cargo_common_metadata)]
 
 fn main() {}
diff --git a/tests/ui-cargo/cargo_common_metadata/pass_publish_empty/src/main.rs b/tests/ui-cargo/cargo_common_metadata/pass_publish_empty/src/main.rs
index 27841e18aa9..1a69bb24101 100644
--- a/tests/ui-cargo/cargo_common_metadata/pass_publish_empty/src/main.rs
+++ b/tests/ui-cargo/cargo_common_metadata/pass_publish_empty/src/main.rs
@@ -1,4 +1,4 @@
-// compile-flags: --crate-name=cargo_common_metadata
+//@compile-flags: --crate-name=cargo_common_metadata
 #![warn(clippy::cargo_common_metadata)]
 
 fn main() {}
diff --git a/tests/ui-cargo/cargo_common_metadata/pass_publish_false/src/main.rs b/tests/ui-cargo/cargo_common_metadata/pass_publish_false/src/main.rs
index 27841e18aa9..1a69bb24101 100644
--- a/tests/ui-cargo/cargo_common_metadata/pass_publish_false/src/main.rs
+++ b/tests/ui-cargo/cargo_common_metadata/pass_publish_false/src/main.rs
@@ -1,4 +1,4 @@
-// compile-flags: --crate-name=cargo_common_metadata
+//@compile-flags: --crate-name=cargo_common_metadata
 #![warn(clippy::cargo_common_metadata)]
 
 fn main() {}
diff --git a/tests/ui-cargo/feature_name/fail/src/main.rs b/tests/ui-cargo/feature_name/fail/src/main.rs
index 64f01a98c90..4dd9582aff8 100644
--- a/tests/ui-cargo/feature_name/fail/src/main.rs
+++ b/tests/ui-cargo/feature_name/fail/src/main.rs
@@ -1,4 +1,4 @@
-// compile-flags: --crate-name=feature_name
+//@compile-flags: --crate-name=feature_name
 #![warn(clippy::redundant_feature_names)]
 #![warn(clippy::negative_feature_names)]
 
diff --git a/tests/ui-cargo/feature_name/pass/src/main.rs b/tests/ui-cargo/feature_name/pass/src/main.rs
index 64f01a98c90..4dd9582aff8 100644
--- a/tests/ui-cargo/feature_name/pass/src/main.rs
+++ b/tests/ui-cargo/feature_name/pass/src/main.rs
@@ -1,4 +1,4 @@
-// compile-flags: --crate-name=feature_name
+//@compile-flags: --crate-name=feature_name
 #![warn(clippy::redundant_feature_names)]
 #![warn(clippy::negative_feature_names)]
 
diff --git a/tests/ui-cargo/module_style/fail_mod_remap/src/main.rs b/tests/ui-cargo/module_style/fail_mod_remap/src/main.rs
index ba4c8c873dd..c70d92e359e 100644
--- a/tests/ui-cargo/module_style/fail_mod_remap/src/main.rs
+++ b/tests/ui-cargo/module_style/fail_mod_remap/src/main.rs
@@ -1,4 +1,4 @@
-// compile-flags: --remap-path-prefix {{src-base}}=/remapped
+//@compile-flags: --remap-path-prefix {{src-base}}=/remapped
 
 #![warn(clippy::self_named_module_files)]
 
diff --git a/tests/ui-cargo/multiple_crate_versions/5041_allow_dev_build/src/main.rs b/tests/ui-cargo/multiple_crate_versions/5041_allow_dev_build/src/main.rs
index 1b2d3ec9459..ece260b743d 100644
--- a/tests/ui-cargo/multiple_crate_versions/5041_allow_dev_build/src/main.rs
+++ b/tests/ui-cargo/multiple_crate_versions/5041_allow_dev_build/src/main.rs
@@ -1,4 +1,4 @@
-// compile-flags: --crate-name=multiple_crate_versions
+//@compile-flags: --crate-name=multiple_crate_versions
 #![warn(clippy::multiple_crate_versions)]
 
 fn main() {}
diff --git a/tests/ui-cargo/multiple_crate_versions/fail/src/main.rs b/tests/ui-cargo/multiple_crate_versions/fail/src/main.rs
index 1b2d3ec9459..ece260b743d 100644
--- a/tests/ui-cargo/multiple_crate_versions/fail/src/main.rs
+++ b/tests/ui-cargo/multiple_crate_versions/fail/src/main.rs
@@ -1,4 +1,4 @@
-// compile-flags: --crate-name=multiple_crate_versions
+//@compile-flags: --crate-name=multiple_crate_versions
 #![warn(clippy::multiple_crate_versions)]
 
 fn main() {}
diff --git a/tests/ui-cargo/multiple_crate_versions/pass/src/main.rs b/tests/ui-cargo/multiple_crate_versions/pass/src/main.rs
index 1b2d3ec9459..ece260b743d 100644
--- a/tests/ui-cargo/multiple_crate_versions/pass/src/main.rs
+++ b/tests/ui-cargo/multiple_crate_versions/pass/src/main.rs
@@ -1,4 +1,4 @@
-// compile-flags: --crate-name=multiple_crate_versions
+//@compile-flags: --crate-name=multiple_crate_versions
 #![warn(clippy::multiple_crate_versions)]
 
 fn main() {}
diff --git a/tests/ui-cargo/wildcard_dependencies/fail/src/main.rs b/tests/ui-cargo/wildcard_dependencies/fail/src/main.rs
index 581babfeacb..bb3a39d0720 100644
--- a/tests/ui-cargo/wildcard_dependencies/fail/src/main.rs
+++ b/tests/ui-cargo/wildcard_dependencies/fail/src/main.rs
@@ -1,4 +1,4 @@
-// compile-flags: --crate-name=wildcard_dependencies
+//@compile-flags: --crate-name=wildcard_dependencies
 #![warn(clippy::wildcard_dependencies)]
 
 fn main() {}
diff --git a/tests/ui-cargo/wildcard_dependencies/pass/src/main.rs b/tests/ui-cargo/wildcard_dependencies/pass/src/main.rs
index 581babfeacb..bb3a39d0720 100644
--- a/tests/ui-cargo/wildcard_dependencies/pass/src/main.rs
+++ b/tests/ui-cargo/wildcard_dependencies/pass/src/main.rs
@@ -1,4 +1,4 @@
-// compile-flags: --crate-name=wildcard_dependencies
+//@compile-flags: --crate-name=wildcard_dependencies
 #![warn(clippy::wildcard_dependencies)]
 
 fn main() {}
diff --git a/tests/ui-internal/collapsible_span_lint_calls.fixed b/tests/ui-internal/collapsible_span_lint_calls.fixed
index 9f299d7dec7..72c04bf80b6 100644
--- a/tests/ui-internal/collapsible_span_lint_calls.fixed
+++ b/tests/ui-internal/collapsible_span_lint_calls.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![deny(clippy::internal)]
 #![allow(clippy::missing_clippy_version_attribute)]
 #![feature(rustc_private)]
diff --git a/tests/ui-internal/collapsible_span_lint_calls.rs b/tests/ui-internal/collapsible_span_lint_calls.rs
index 2b113f555e4..76f7c3ce94d 100644
--- a/tests/ui-internal/collapsible_span_lint_calls.rs
+++ b/tests/ui-internal/collapsible_span_lint_calls.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![deny(clippy::internal)]
 #![allow(clippy::missing_clippy_version_attribute)]
 #![feature(rustc_private)]
diff --git a/tests/ui-internal/custom_ice_message.rs b/tests/ui-internal/custom_ice_message.rs
index 837811bdf1e..acb98d7ba98 100644
--- a/tests/ui-internal/custom_ice_message.rs
+++ b/tests/ui-internal/custom_ice_message.rs
@@ -1,9 +1,9 @@
-// rustc-env:RUST_BACKTRACE=0
-// normalize-stderr-test: "Clippy version: .*" -> "Clippy version: foo"
-// normalize-stderr-test: "produce_ice.rs:\d*:\d*" -> "produce_ice.rs"
-// normalize-stderr-test: "', .*clippy_lints" -> "', clippy_lints"
-// normalize-stderr-test: "'rustc'" -> "'<unnamed>'"
-// normalize-stderr-test: "(?ms)query stack during panic:\n.*end of query stack\n" -> ""
+//@rustc-env:RUST_BACKTRACE=0
+//@normalize-stderr-test: "Clippy version: .*" -> "Clippy version: foo"
+//@normalize-stderr-test: "produce_ice.rs:\d*:\d*" -> "produce_ice.rs"
+//@normalize-stderr-test: "', .*clippy_lints" -> "', clippy_lints"
+//@normalize-stderr-test: "'rustc'" -> "'<unnamed>'"
+//@normalize-stderr-test: "(?ms)query stack during panic:\n.*end of query stack\n" -> ""
 
 #![deny(clippy::internal)]
 #![allow(clippy::missing_clippy_version_attribute)]
diff --git a/tests/ui-internal/interning_defined_symbol.fixed b/tests/ui-internal/interning_defined_symbol.fixed
index eaea218e128..a1a10c0798e 100644
--- a/tests/ui-internal/interning_defined_symbol.fixed
+++ b/tests/ui-internal/interning_defined_symbol.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![deny(clippy::internal)]
 #![allow(clippy::missing_clippy_version_attribute, clippy::let_unit_value)]
 #![feature(rustc_private)]
diff --git a/tests/ui-internal/interning_defined_symbol.rs b/tests/ui-internal/interning_defined_symbol.rs
index 7efebb8fae4..32dbfe5dcac 100644
--- a/tests/ui-internal/interning_defined_symbol.rs
+++ b/tests/ui-internal/interning_defined_symbol.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![deny(clippy::internal)]
 #![allow(clippy::missing_clippy_version_attribute, clippy::let_unit_value)]
 #![feature(rustc_private)]
diff --git a/tests/ui-internal/invalid_msrv_attr_impl.fixed b/tests/ui-internal/invalid_msrv_attr_impl.fixed
index 08634063a57..ac0752774f3 100644
--- a/tests/ui-internal/invalid_msrv_attr_impl.fixed
+++ b/tests/ui-internal/invalid_msrv_attr_impl.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![deny(clippy::internal)]
 #![allow(clippy::missing_clippy_version_attribute)]
diff --git a/tests/ui-internal/invalid_msrv_attr_impl.rs b/tests/ui-internal/invalid_msrv_attr_impl.rs
index f8af77e6d39..56f778621a4 100644
--- a/tests/ui-internal/invalid_msrv_attr_impl.rs
+++ b/tests/ui-internal/invalid_msrv_attr_impl.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![deny(clippy::internal)]
 #![allow(clippy::missing_clippy_version_attribute)]
diff --git a/tests/ui-internal/outer_expn_data.fixed b/tests/ui-internal/outer_expn_data.fixed
index bb82faf0c90..d8a08bc9997 100644
--- a/tests/ui-internal/outer_expn_data.fixed
+++ b/tests/ui-internal/outer_expn_data.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![deny(clippy::internal)]
 #![allow(clippy::missing_clippy_version_attribute)]
diff --git a/tests/ui-internal/outer_expn_data.rs b/tests/ui-internal/outer_expn_data.rs
index 187d468b392..f7af0e9d8be 100644
--- a/tests/ui-internal/outer_expn_data.rs
+++ b/tests/ui-internal/outer_expn_data.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![deny(clippy::internal)]
 #![allow(clippy::missing_clippy_version_attribute)]
diff --git a/tests/ui-internal/unnecessary_def_path.fixed b/tests/ui-internal/unnecessary_def_path.fixed
index e474f370a5d..fce24412f84 100644
--- a/tests/ui-internal/unnecessary_def_path.fixed
+++ b/tests/ui-internal/unnecessary_def_path.fixed
@@ -1,5 +1,5 @@
-// run-rustfix
-// aux-build:paths.rs
+//@run-rustfix
+//@aux-build:paths.rs
 #![deny(clippy::internal)]
 #![feature(rustc_private)]
 
diff --git a/tests/ui-internal/unnecessary_def_path.rs b/tests/ui-internal/unnecessary_def_path.rs
index f17fed6c653..b10bc9e46e2 100644
--- a/tests/ui-internal/unnecessary_def_path.rs
+++ b/tests/ui-internal/unnecessary_def_path.rs
@@ -1,5 +1,5 @@
-// run-rustfix
-// aux-build:paths.rs
+//@run-rustfix
+//@aux-build:paths.rs
 #![deny(clippy::internal)]
 #![feature(rustc_private)]
 
diff --git a/tests/ui-internal/unnecessary_symbol_str.fixed b/tests/ui-internal/unnecessary_symbol_str.fixed
index 6033d06e4f6..b802de1cbc6 100644
--- a/tests/ui-internal/unnecessary_symbol_str.fixed
+++ b/tests/ui-internal/unnecessary_symbol_str.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![feature(rustc_private)]
 #![deny(clippy::internal)]
 #![allow(
diff --git a/tests/ui-internal/unnecessary_symbol_str.rs b/tests/ui-internal/unnecessary_symbol_str.rs
index 1bb5d55f0b6..c1bead5bdc9 100644
--- a/tests/ui-internal/unnecessary_symbol_str.rs
+++ b/tests/ui-internal/unnecessary_symbol_str.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![feature(rustc_private)]
 #![deny(clippy::internal)]
 #![allow(
diff --git a/tests/ui-toml/allow_mixed_uninlined_format_args/uninlined_format_args.fixed b/tests/ui-toml/allow_mixed_uninlined_format_args/uninlined_format_args.fixed
index aa8b45b5fe7..23e7bc16d23 100644
--- a/tests/ui-toml/allow_mixed_uninlined_format_args/uninlined_format_args.fixed
+++ b/tests/ui-toml/allow_mixed_uninlined_format_args/uninlined_format_args.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::uninlined_format_args)]
 
 fn main() {
diff --git a/tests/ui-toml/allow_mixed_uninlined_format_args/uninlined_format_args.rs b/tests/ui-toml/allow_mixed_uninlined_format_args/uninlined_format_args.rs
index ad2e4863ee8..d66b2b8ff6a 100644
--- a/tests/ui-toml/allow_mixed_uninlined_format_args/uninlined_format_args.rs
+++ b/tests/ui-toml/allow_mixed_uninlined_format_args/uninlined_format_args.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::uninlined_format_args)]
 
 fn main() {
diff --git a/tests/ui-toml/dbg_macro/dbg_macro.rs b/tests/ui-toml/dbg_macro/dbg_macro.rs
index 5d9ce18f631..21e4fce26e4 100644
--- a/tests/ui-toml/dbg_macro/dbg_macro.rs
+++ b/tests/ui-toml/dbg_macro/dbg_macro.rs
@@ -1,4 +1,4 @@
-// compile-flags: --test
+//@compile-flags: --test
 #![warn(clippy::dbg_macro)]
 
 fn foo(n: u32) -> u32 {
diff --git a/tests/ui-toml/disallowed_macros/disallowed_macros.rs b/tests/ui-toml/disallowed_macros/disallowed_macros.rs
index 2bb5376076e..ba919b48788 100644
--- a/tests/ui-toml/disallowed_macros/disallowed_macros.rs
+++ b/tests/ui-toml/disallowed_macros/disallowed_macros.rs
@@ -1,4 +1,4 @@
-// aux-build:macros.rs
+//@aux-build:macros.rs
 
 #![allow(unused)]
 
diff --git a/tests/ui-toml/expect_used/expect_used.rs b/tests/ui-toml/expect_used/expect_used.rs
index 89f142a150d..9e267c89300 100644
--- a/tests/ui-toml/expect_used/expect_used.rs
+++ b/tests/ui-toml/expect_used/expect_used.rs
@@ -1,4 +1,4 @@
-// compile-flags: --test
+//@compile-flags: --test
 #![warn(clippy::expect_used)]
 
 fn expect_option() {
diff --git a/tests/ui-toml/mut_key/mut_key.rs b/tests/ui-toml/mut_key/mut_key.rs
index 667c51cb4a3..095e0d15448 100644
--- a/tests/ui-toml/mut_key/mut_key.rs
+++ b/tests/ui-toml/mut_key/mut_key.rs
@@ -1,4 +1,4 @@
-// compile-flags: --crate-name mut_key
+//@compile-flags: --crate-name mut_key
 
 #![warn(clippy::mutable_key_type)]
 
diff --git a/tests/ui-toml/nonstandard_macro_braces/auxiliary/proc_macro_derive.rs b/tests/ui-toml/nonstandard_macro_braces/auxiliary/proc_macro_derive.rs
index 6452189a461..f5761c6afeb 100644
--- a/tests/ui-toml/nonstandard_macro_braces/auxiliary/proc_macro_derive.rs
+++ b/tests/ui-toml/nonstandard_macro_braces/auxiliary/proc_macro_derive.rs
@@ -1,5 +1,5 @@
-// compile-flags: --emit=link
-// no-prefer-dynamic
+//@compile-flags: --emit=link
+//@no-prefer-dynamic
 
 #![crate_type = "proc-macro"]
 
diff --git a/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.fixed b/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.fixed
index 01d135764df..e4747bedddb 100644
--- a/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.fixed
+++ b/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.fixed
@@ -1,5 +1,5 @@
-// aux-build:proc_macro_derive.rs
-// run-rustfix
+//@aux-build:proc_macro_derive.rs
+//@run-rustfix
 
 #![warn(clippy::nonstandard_macro_braces)]
 
diff --git a/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.rs b/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.rs
index 72883e8270c..54edded99f4 100644
--- a/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.rs
+++ b/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.rs
@@ -1,5 +1,5 @@
-// aux-build:proc_macro_derive.rs
-// run-rustfix
+//@aux-build:proc_macro_derive.rs
+//@run-rustfix
 
 #![warn(clippy::nonstandard_macro_braces)]
 
diff --git a/tests/ui-toml/print_macro/print_macro.rs b/tests/ui-toml/print_macro/print_macro.rs
index 5aefb6a6b4d..3a8b30cca36 100644
--- a/tests/ui-toml/print_macro/print_macro.rs
+++ b/tests/ui-toml/print_macro/print_macro.rs
@@ -1,4 +1,4 @@
-// compile-flags: --test
+//@compile-flags: --test
 #![warn(clippy::print_stdout)]
 #![warn(clippy::print_stderr)]
 
diff --git a/tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.rs b/tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.rs
index 2f3160c8338..8e1a1710a6c 100644
--- a/tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.rs
+++ b/tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.rs
@@ -1,4 +1,4 @@
-// compile-flags: --crate-name conf_disallowed_methods
+//@compile-flags: --crate-name conf_disallowed_methods
 
 #![warn(clippy::disallowed_methods)]
 
diff --git a/tests/ui-toml/toml_trivially_copy/test.rs b/tests/ui-toml/toml_trivially_copy/test.rs
index fb0e226f3aa..179b1266169 100644
--- a/tests/ui-toml/toml_trivially_copy/test.rs
+++ b/tests/ui-toml/toml_trivially_copy/test.rs
@@ -1,5 +1,5 @@
-// normalize-stderr-test "\(\d+ byte\)" -> "(N byte)"
-// normalize-stderr-test "\(limit: \d+ byte\)" -> "(limit: N byte)"
+//@normalize-stderr-test: "\(\d+ byte\)" -> "(N byte)"
+//@normalize-stderr-test: "\(limit: \d+ byte\)" -> "(limit: N byte)"
 
 #![deny(clippy::trivially_copy_pass_by_ref)]
 
diff --git a/tests/ui-toml/toml_unknown_key/conf_unknown_key.rs b/tests/ui-toml/toml_unknown_key/conf_unknown_key.rs
index f328e4d9d04..569fd2c3553 100644
--- a/tests/ui-toml/toml_unknown_key/conf_unknown_key.rs
+++ b/tests/ui-toml/toml_unknown_key/conf_unknown_key.rs
@@ -1 +1,3 @@
+//@error-pattern: unknown field `foobar`, expected one of
+
 fn main() {}
diff --git a/tests/ui-toml/unwrap_used/unwrap_used.rs b/tests/ui-toml/unwrap_used/unwrap_used.rs
index 6525ea5bfc3..5d3e800cadd 100644
--- a/tests/ui-toml/unwrap_used/unwrap_used.rs
+++ b/tests/ui-toml/unwrap_used/unwrap_used.rs
@@ -1,4 +1,4 @@
-// compile-flags: --test
+//@compile-flags: --test
 
 #![allow(unused_mut, clippy::get_first, clippy::from_iter_instead_of_collect)]
 #![warn(clippy::unwrap_used)]
diff --git a/tests/ui/allow_attributes.fixed b/tests/ui/allow_attributes.fixed
index b8dd0619e6d..f0936b2608e 100644
--- a/tests/ui/allow_attributes.fixed
+++ b/tests/ui/allow_attributes.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![allow(unused)]
 #![warn(clippy::allow_attributes)]
 #![feature(lint_reasons)]
diff --git a/tests/ui/allow_attributes.rs b/tests/ui/allow_attributes.rs
index 295f560906a..2fb9e86126e 100644
--- a/tests/ui/allow_attributes.rs
+++ b/tests/ui/allow_attributes.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![allow(unused)]
 #![warn(clippy::allow_attributes)]
 #![feature(lint_reasons)]
diff --git a/tests/ui/almost_complete_range.fixed b/tests/ui/almost_complete_range.fixed
index a4bf7fe18d5..5cd0dcce6f7 100644
--- a/tests/ui/almost_complete_range.fixed
+++ b/tests/ui/almost_complete_range.fixed
@@ -1,6 +1,6 @@
-// run-rustfix
-// edition:2018
-// aux-build:proc_macros.rs
+//@run-rustfix
+//@edition:2018
+//@aux-build:proc_macros.rs
 
 #![feature(exclusive_range_pattern)]
 #![feature(stmt_expr_attributes)]
diff --git a/tests/ui/almost_complete_range.rs b/tests/ui/almost_complete_range.rs
index 8237c3a1361..db0bfc8afc3 100644
--- a/tests/ui/almost_complete_range.rs
+++ b/tests/ui/almost_complete_range.rs
@@ -1,6 +1,6 @@
-// run-rustfix
-// edition:2018
-// aux-build:proc_macros.rs
+//@run-rustfix
+//@edition:2018
+//@aux-build:proc_macros.rs
 
 #![feature(exclusive_range_pattern)]
 #![feature(stmt_expr_attributes)]
diff --git a/tests/ui/arithmetic_side_effects.rs b/tests/ui/arithmetic_side_effects.rs
index ab7e66a264d..d864fe05800 100644
--- a/tests/ui/arithmetic_side_effects.rs
+++ b/tests/ui/arithmetic_side_effects.rs
@@ -1,4 +1,4 @@
-// aux-build:proc_macro_derive.rs
+//@aux-build:proc_macro_derive.rs
 
 #![allow(
     clippy::assign_op_pattern,
diff --git a/tests/ui/as_conversions.rs b/tests/ui/as_conversions.rs
index c50d4088b5e..890bf0b0a7e 100644
--- a/tests/ui/as_conversions.rs
+++ b/tests/ui/as_conversions.rs
@@ -1,4 +1,4 @@
-// aux-build:proc_macros.rs
+//@aux-build:proc_macros.rs
 
 #![warn(clippy::as_conversions)]
 #![allow(clippy::borrow_as_ptr)]
diff --git a/tests/ui/as_underscore.fixed b/tests/ui/as_underscore.fixed
index 948f6d8e6b1..69af84a0eae 100644
--- a/tests/ui/as_underscore.fixed
+++ b/tests/ui/as_underscore.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::as_underscore)]
 
diff --git a/tests/ui/as_underscore.rs b/tests/ui/as_underscore.rs
index 97785ed08a8..a8cfb81d9a3 100644
--- a/tests/ui/as_underscore.rs
+++ b/tests/ui/as_underscore.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::as_underscore)]
 
diff --git a/tests/ui/asm_syntax.rs b/tests/ui/asm_syntax.rs
index 0220bf3331f..c93995f939a 100644
--- a/tests/ui/asm_syntax.rs
+++ b/tests/ui/asm_syntax.rs
@@ -1,5 +1,5 @@
-// only-x86_64
-// ignore-aarch64
+//@only-x86_64
+//@ignore-aarch64
 
 #[warn(clippy::inline_asm_x86_intel_syntax)]
 mod warn_intel {
diff --git a/tests/ui/assertions_on_result_states.fixed b/tests/ui/assertions_on_result_states.fixed
index 2bb755290c5..ea8b895664c 100644
--- a/tests/ui/assertions_on_result_states.fixed
+++ b/tests/ui/assertions_on_result_states.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::assertions_on_result_states)]
 
 use std::result::Result;
diff --git a/tests/ui/assertions_on_result_states.rs b/tests/ui/assertions_on_result_states.rs
index d8a9bd2f1c4..6fc20f85988 100644
--- a/tests/ui/assertions_on_result_states.rs
+++ b/tests/ui/assertions_on_result_states.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::assertions_on_result_states)]
 
 use std::result::Result;
diff --git a/tests/ui/assign_ops.fixed b/tests/ui/assign_ops.fixed
index da034b51cfd..b50682ea00c 100644
--- a/tests/ui/assign_ops.fixed
+++ b/tests/ui/assign_ops.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 use core::num::Wrapping;
 
diff --git a/tests/ui/assign_ops.rs b/tests/ui/assign_ops.rs
index 337bb02c8a6..780d2d040f1 100644
--- a/tests/ui/assign_ops.rs
+++ b/tests/ui/assign_ops.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 use core::num::Wrapping;
 
diff --git a/tests/ui/async_yields_async.fixed b/tests/ui/async_yields_async.fixed
index 579a63ea477..8d9b023893f 100644
--- a/tests/ui/async_yields_async.fixed
+++ b/tests/ui/async_yields_async.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![feature(lint_reasons)]
 #![feature(async_closure)]
 #![warn(clippy::async_yields_async)]
diff --git a/tests/ui/async_yields_async.rs b/tests/ui/async_yields_async.rs
index 5aec2fb50f6..bed79062f01 100644
--- a/tests/ui/async_yields_async.rs
+++ b/tests/ui/async_yields_async.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![feature(lint_reasons)]
 #![feature(async_closure)]
 #![warn(clippy::async_yields_async)]
diff --git a/tests/ui/author/blocks.rs b/tests/ui/author/blocks.rs
index a7335c01baa..164f7d0d9d6 100644
--- a/tests/ui/author/blocks.rs
+++ b/tests/ui/author/blocks.rs
@@ -1,4 +1,4 @@
-// edition:2018
+//@edition:2018
 
 #![allow(redundant_semicolons, clippy::no_effect)]
 #![feature(stmt_expr_attributes)]
diff --git a/tests/ui/auxiliary/proc_macro_attr.rs b/tests/ui/auxiliary/proc_macro_attr.rs
index b498fece513..92c47b41a38 100644
--- a/tests/ui/auxiliary/proc_macro_attr.rs
+++ b/tests/ui/auxiliary/proc_macro_attr.rs
@@ -1,5 +1,5 @@
-// compile-flags: --emit=link
-// no-prefer-dynamic
+//@compile-flags: --emit=link
+//@no-prefer-dynamic
 
 #![crate_type = "proc-macro"]
 #![feature(repr128, proc_macro_hygiene, proc_macro_quote, box_patterns)]
diff --git a/tests/ui/auxiliary/proc_macro_derive.rs b/tests/ui/auxiliary/proc_macro_derive.rs
index 13d93f5c275..5a924ca1830 100644
--- a/tests/ui/auxiliary/proc_macro_derive.rs
+++ b/tests/ui/auxiliary/proc_macro_derive.rs
@@ -1,5 +1,5 @@
-// compile-flags: --emit=link
-// no-prefer-dynamic
+//@compile-flags: --emit=link
+//@no-prefer-dynamic
 
 #![crate_type = "proc-macro"]
 #![feature(repr128, proc_macro_quote)]
diff --git a/tests/ui/auxiliary/proc_macro_suspicious_else_formatting.rs b/tests/ui/auxiliary/proc_macro_suspicious_else_formatting.rs
index a2ef0fe827c..f13b76e44b0 100644
--- a/tests/ui/auxiliary/proc_macro_suspicious_else_formatting.rs
+++ b/tests/ui/auxiliary/proc_macro_suspicious_else_formatting.rs
@@ -1,5 +1,5 @@
-// compile-flags: --emit=link
-// no-prefer-dynamic
+//@compile-flags: --emit=link
+//@no-prefer-dynamic
 
 #![crate_type = "proc-macro"]
 
diff --git a/tests/ui/auxiliary/proc_macro_unsafe.rs b/tests/ui/auxiliary/proc_macro_unsafe.rs
index 3c40f77469b..c2326678d0d 100644
--- a/tests/ui/auxiliary/proc_macro_unsafe.rs
+++ b/tests/ui/auxiliary/proc_macro_unsafe.rs
@@ -1,5 +1,5 @@
-// compile-flags: --emit=link
-// no-prefer-dynamic
+//@compile-flags: --emit=link
+//@no-prefer-dynamic
 
 #![crate_type = "proc-macro"]
 
diff --git a/tests/ui/auxiliary/proc_macros.rs b/tests/ui/auxiliary/proc_macros.rs
index 3d5beab1eff..94f075ed09c 100644
--- a/tests/ui/auxiliary/proc_macros.rs
+++ b/tests/ui/auxiliary/proc_macros.rs
@@ -1,5 +1,5 @@
-// compile-flags: --emit=link
-// no-prefer-dynamic
+//@compile-flags: --emit=link
+//@no-prefer-dynamic
 
 #![crate_type = "proc-macro"]
 #![feature(let_chains)]
diff --git a/tests/ui/bind_instead_of_map.fixed b/tests/ui/bind_instead_of_map.fixed
index d94e2ac6072..ea2dc2e2293 100644
--- a/tests/ui/bind_instead_of_map.fixed
+++ b/tests/ui/bind_instead_of_map.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![deny(clippy::bind_instead_of_map)]
 #![allow(clippy::uninlined_format_args)]
 
diff --git a/tests/ui/bind_instead_of_map.rs b/tests/ui/bind_instead_of_map.rs
index 86f31f58284..1db58dae538 100644
--- a/tests/ui/bind_instead_of_map.rs
+++ b/tests/ui/bind_instead_of_map.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![deny(clippy::bind_instead_of_map)]
 #![allow(clippy::uninlined_format_args)]
 
diff --git a/tests/ui/bind_instead_of_map_multipart.fixed b/tests/ui/bind_instead_of_map_multipart.fixed
index e1589843226..63c7aafcddb 100644
--- a/tests/ui/bind_instead_of_map_multipart.fixed
+++ b/tests/ui/bind_instead_of_map_multipart.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![deny(clippy::bind_instead_of_map)]
 #![allow(clippy::blocks_in_if_conditions)]
 
diff --git a/tests/ui/bind_instead_of_map_multipart.rs b/tests/ui/bind_instead_of_map_multipart.rs
index 49944403f6d..69b982fa8a2 100644
--- a/tests/ui/bind_instead_of_map_multipart.rs
+++ b/tests/ui/bind_instead_of_map_multipart.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![deny(clippy::bind_instead_of_map)]
 #![allow(clippy::blocks_in_if_conditions)]
 
diff --git a/tests/ui/blanket_clippy_restriction_lints.rs b/tests/ui/blanket_clippy_restriction_lints.rs
index 554745368bc..e1ff25c54cf 100644
--- a/tests/ui/blanket_clippy_restriction_lints.rs
+++ b/tests/ui/blanket_clippy_restriction_lints.rs
@@ -1,4 +1,4 @@
-// compile-flags: -W clippy::restriction
+//@compile-flags: -W clippy::restriction
 
 #![warn(clippy::blanket_clippy_restriction_lints)]
 
diff --git a/tests/ui/blocks_in_if_conditions.fixed b/tests/ui/blocks_in_if_conditions.fixed
index e6e40a9948c..a9f18782e58 100644
--- a/tests/ui/blocks_in_if_conditions.fixed
+++ b/tests/ui/blocks_in_if_conditions.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::blocks_in_if_conditions)]
 #![allow(unused, clippy::let_and_return)]
 #![warn(clippy::nonminimal_bool)]
diff --git a/tests/ui/blocks_in_if_conditions.rs b/tests/ui/blocks_in_if_conditions.rs
index 69387ff5782..0a70317c4d4 100644
--- a/tests/ui/blocks_in_if_conditions.rs
+++ b/tests/ui/blocks_in_if_conditions.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::blocks_in_if_conditions)]
 #![allow(unused, clippy::let_and_return)]
 #![warn(clippy::nonminimal_bool)]
diff --git a/tests/ui/bool_assert_comparison.fixed b/tests/ui/bool_assert_comparison.fixed
index b8dd92906c8..53f63444aef 100644
--- a/tests/ui/bool_assert_comparison.fixed
+++ b/tests/ui/bool_assert_comparison.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(unused, clippy::assertions_on_constants)]
 #![warn(clippy::bool_assert_comparison)]
diff --git a/tests/ui/bool_assert_comparison.rs b/tests/ui/bool_assert_comparison.rs
index 0a8ad34fda5..151d93a9233 100644
--- a/tests/ui/bool_assert_comparison.rs
+++ b/tests/ui/bool_assert_comparison.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(unused, clippy::assertions_on_constants)]
 #![warn(clippy::bool_assert_comparison)]
diff --git a/tests/ui/bool_comparison.fixed b/tests/ui/bool_comparison.fixed
index 5a012ff4d27..670eef6a21d 100644
--- a/tests/ui/bool_comparison.fixed
+++ b/tests/ui/bool_comparison.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::bool_comparison)]
 
diff --git a/tests/ui/bool_comparison.rs b/tests/ui/bool_comparison.rs
index c534bc25c20..72851be635d 100644
--- a/tests/ui/bool_comparison.rs
+++ b/tests/ui/bool_comparison.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::bool_comparison)]
 
diff --git a/tests/ui/bool_to_int_with_if.fixed b/tests/ui/bool_to_int_with_if.fixed
index 37d3e3286a4..9831c3373d4 100644
--- a/tests/ui/bool_to_int_with_if.fixed
+++ b/tests/ui/bool_to_int_with_if.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![feature(let_chains)]
 #![warn(clippy::bool_to_int_with_if)]
diff --git a/tests/ui/bool_to_int_with_if.rs b/tests/ui/bool_to_int_with_if.rs
index ebdf86fd185..5e3047bb32c 100644
--- a/tests/ui/bool_to_int_with_if.rs
+++ b/tests/ui/bool_to_int_with_if.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![feature(let_chains)]
 #![warn(clippy::bool_to_int_with_if)]
diff --git a/tests/ui/borrow_as_ptr.fixed b/tests/ui/borrow_as_ptr.fixed
index ff5c6a8c377..3f440ce0045 100644
--- a/tests/ui/borrow_as_ptr.fixed
+++ b/tests/ui/borrow_as_ptr.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::borrow_as_ptr)]
 
 fn main() {
diff --git a/tests/ui/borrow_as_ptr.rs b/tests/ui/borrow_as_ptr.rs
index 0f62ec6ee58..c1ca9180eef 100644
--- a/tests/ui/borrow_as_ptr.rs
+++ b/tests/ui/borrow_as_ptr.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::borrow_as_ptr)]
 
 fn main() {
diff --git a/tests/ui/borrow_as_ptr_no_std.fixed b/tests/ui/borrow_as_ptr_no_std.fixed
index eaba3b1c20c..10f2727c793 100644
--- a/tests/ui/borrow_as_ptr_no_std.fixed
+++ b/tests/ui/borrow_as_ptr_no_std.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::borrow_as_ptr)]
 #![feature(lang_items, start, libc)]
 #![no_std]
diff --git a/tests/ui/borrow_as_ptr_no_std.rs b/tests/ui/borrow_as_ptr_no_std.rs
index d83f9d1f875..311e9341aac 100644
--- a/tests/ui/borrow_as_ptr_no_std.rs
+++ b/tests/ui/borrow_as_ptr_no_std.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::borrow_as_ptr)]
 #![feature(lang_items, start, libc)]
 #![no_std]
diff --git a/tests/ui/borrow_deref_ref.fixed b/tests/ui/borrow_deref_ref.fixed
index bf4691c5bc9..165e4bc8272 100644
--- a/tests/ui/borrow_deref_ref.fixed
+++ b/tests/ui/borrow_deref_ref.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(dead_code, unused_variables)]
 
diff --git a/tests/ui/borrow_deref_ref.rs b/tests/ui/borrow_deref_ref.rs
index 28c005fdbef..66c8d69bef9 100644
--- a/tests/ui/borrow_deref_ref.rs
+++ b/tests/ui/borrow_deref_ref.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(dead_code, unused_variables)]
 
diff --git a/tests/ui/borrow_interior_mutable_const/enums.rs b/tests/ui/borrow_interior_mutable_const/enums.rs
index 5027db44561..29b08ab3643 100644
--- a/tests/ui/borrow_interior_mutable_const/enums.rs
+++ b/tests/ui/borrow_interior_mutable_const/enums.rs
@@ -1,4 +1,4 @@
-// aux-build:helper.rs
+//@aux-build:helper.rs
 
 #![warn(clippy::borrow_interior_mutable_const)]
 #![allow(clippy::declare_interior_mutable_const)]
diff --git a/tests/ui/box_default.fixed b/tests/ui/box_default.fixed
index 59c0baf8718..6afce208769 100644
--- a/tests/ui/box_default.fixed
+++ b/tests/ui/box_default.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::box_default)]
 
 #[derive(Default)]
diff --git a/tests/ui/box_default.rs b/tests/ui/box_default.rs
index f7d832193a3..09365618e63 100644
--- a/tests/ui/box_default.rs
+++ b/tests/ui/box_default.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::box_default)]
 
 #[derive(Default)]
diff --git a/tests/ui/bytes_count_to_len.fixed b/tests/ui/bytes_count_to_len.fixed
index 860642363b5..fb3d521badd 100644
--- a/tests/ui/bytes_count_to_len.fixed
+++ b/tests/ui/bytes_count_to_len.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::bytes_count_to_len)]
 use std::fs::File;
 use std::io::Read;
diff --git a/tests/ui/bytes_count_to_len.rs b/tests/ui/bytes_count_to_len.rs
index 162730c2842..8e256b8f0b8 100644
--- a/tests/ui/bytes_count_to_len.rs
+++ b/tests/ui/bytes_count_to_len.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::bytes_count_to_len)]
 use std::fs::File;
 use std::io::Read;
diff --git a/tests/ui/bytes_nth.fixed b/tests/ui/bytes_nth.fixed
index a35c679afb7..d3e0f676b29 100644
--- a/tests/ui/bytes_nth.fixed
+++ b/tests/ui/bytes_nth.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(clippy::unnecessary_operation)]
 #![warn(clippy::bytes_nth)]
diff --git a/tests/ui/bytes_nth.rs b/tests/ui/bytes_nth.rs
index 1ecffea5303..b7d813fe296 100644
--- a/tests/ui/bytes_nth.rs
+++ b/tests/ui/bytes_nth.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(clippy::unnecessary_operation)]
 #![warn(clippy::bytes_nth)]
diff --git a/tests/ui/case_sensitive_file_extension_comparisons.fixed b/tests/ui/case_sensitive_file_extension_comparisons.fixed
index 5fbaa64db39..d5af22aefe5 100644
--- a/tests/ui/case_sensitive_file_extension_comparisons.fixed
+++ b/tests/ui/case_sensitive_file_extension_comparisons.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::case_sensitive_file_extension_comparisons)]
 
 use std::string::String;
diff --git a/tests/ui/case_sensitive_file_extension_comparisons.rs b/tests/ui/case_sensitive_file_extension_comparisons.rs
index 3c0d4821f9f..f5f0a0022a4 100644
--- a/tests/ui/case_sensitive_file_extension_comparisons.rs
+++ b/tests/ui/case_sensitive_file_extension_comparisons.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::case_sensitive_file_extension_comparisons)]
 
 use std::string::String;
diff --git a/tests/ui/cast_abs_to_unsigned.fixed b/tests/ui/cast_abs_to_unsigned.fixed
index 8676b562b4f..ef0a93b01d1 100644
--- a/tests/ui/cast_abs_to_unsigned.fixed
+++ b/tests/ui/cast_abs_to_unsigned.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::cast_abs_to_unsigned)]
 #![allow(clippy::uninlined_format_args, unused)]
diff --git a/tests/ui/cast_abs_to_unsigned.rs b/tests/ui/cast_abs_to_unsigned.rs
index 5775af874f8..96ced670a05 100644
--- a/tests/ui/cast_abs_to_unsigned.rs
+++ b/tests/ui/cast_abs_to_unsigned.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::cast_abs_to_unsigned)]
 #![allow(clippy::uninlined_format_args, unused)]
diff --git a/tests/ui/cast_lossless_bool.fixed b/tests/ui/cast_lossless_bool.fixed
index 13b3cf838c9..c321cc64437 100644
--- a/tests/ui/cast_lossless_bool.fixed
+++ b/tests/ui/cast_lossless_bool.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(dead_code)]
 #![warn(clippy::cast_lossless)]
diff --git a/tests/ui/cast_lossless_bool.rs b/tests/ui/cast_lossless_bool.rs
index 3eed2135562..632a718920d 100644
--- a/tests/ui/cast_lossless_bool.rs
+++ b/tests/ui/cast_lossless_bool.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(dead_code)]
 #![warn(clippy::cast_lossless)]
diff --git a/tests/ui/cast_lossless_float.fixed b/tests/ui/cast_lossless_float.fixed
index 32a9c1c4ae1..e72a0096acc 100644
--- a/tests/ui/cast_lossless_float.fixed
+++ b/tests/ui/cast_lossless_float.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(clippy::no_effect, clippy::unnecessary_operation, dead_code)]
 #![warn(clippy::cast_lossless)]
diff --git a/tests/ui/cast_lossless_float.rs b/tests/ui/cast_lossless_float.rs
index 6f5ddcfe09c..dbcbaa9b815 100644
--- a/tests/ui/cast_lossless_float.rs
+++ b/tests/ui/cast_lossless_float.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(clippy::no_effect, clippy::unnecessary_operation, dead_code)]
 #![warn(clippy::cast_lossless)]
diff --git a/tests/ui/cast_lossless_integer.fixed b/tests/ui/cast_lossless_integer.fixed
index 925cbf25368..7dab02084fc 100644
--- a/tests/ui/cast_lossless_integer.fixed
+++ b/tests/ui/cast_lossless_integer.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(clippy::no_effect, clippy::unnecessary_operation, dead_code)]
 #![warn(clippy::cast_lossless)]
diff --git a/tests/ui/cast_lossless_integer.rs b/tests/ui/cast_lossless_integer.rs
index c82bd9108d2..c24f73960b0 100644
--- a/tests/ui/cast_lossless_integer.rs
+++ b/tests/ui/cast_lossless_integer.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(clippy::no_effect, clippy::unnecessary_operation, dead_code)]
 #![warn(clippy::cast_lossless)]
diff --git a/tests/ui/cast_raw_slice_pointer_cast.fixed b/tests/ui/cast_raw_slice_pointer_cast.fixed
index b70c1912951..9b6fee270ee 100644
--- a/tests/ui/cast_raw_slice_pointer_cast.fixed
+++ b/tests/ui/cast_raw_slice_pointer_cast.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::cast_slice_from_raw_parts)]
 
 #[allow(unused_imports, unused_unsafe)]
diff --git a/tests/ui/cast_raw_slice_pointer_cast.rs b/tests/ui/cast_raw_slice_pointer_cast.rs
index c1b316765c9..c0bb8137990 100644
--- a/tests/ui/cast_raw_slice_pointer_cast.rs
+++ b/tests/ui/cast_raw_slice_pointer_cast.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::cast_slice_from_raw_parts)]
 
 #[allow(unused_imports, unused_unsafe)]
diff --git a/tests/ui/cast_size.rs b/tests/ui/cast_size.rs
index 595109be46b..cd2184aea38 100644
--- a/tests/ui/cast_size.rs
+++ b/tests/ui/cast_size.rs
@@ -1,4 +1,4 @@
-// ignore-32bit
+//@ignore-32bit
 #[warn(
     clippy::cast_precision_loss,
     clippy::cast_possible_truncation,
diff --git a/tests/ui/cast_size_32bit.rs b/tests/ui/cast_size_32bit.rs
index 99aac6deca3..7ca20d3ca4a 100644
--- a/tests/ui/cast_size_32bit.rs
+++ b/tests/ui/cast_size_32bit.rs
@@ -1,4 +1,4 @@
-// ignore-64bit
+//@ignore-64bit
 #[warn(
     clippy::cast_precision_loss,
     clippy::cast_possible_truncation,
diff --git a/tests/ui/cast_size_32bit.stderr b/tests/ui/cast_size_32bit.stderr
index 8990c3ba739..fb51783a487 100644
--- a/tests/ui/cast_size_32bit.stderr
+++ b/tests/ui/cast_size_32bit.stderr
@@ -4,7 +4,12 @@ error: casting `isize` to `i8` may truncate the value
 LL |     1isize as i8;
    |     ^^^^^^^^^^^^
    |
+   = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
    = note: `-D clippy::cast-possible-truncation` implied by `-D warnings`
+help: ... or use `try_from` and handle the error accordingly
+   |
+LL |     i8::try_from(1isize);
+   |     ~~~~~~~~~~~~~~~~~~~~
 
 error: casting `isize` to `f64` causes a loss of precision on targets with 64-bit wide pointers (`isize` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
   --> $DIR/cast_size_32bit.rs:15:5
@@ -37,24 +42,48 @@ error: casting `isize` to `i32` may truncate the value on targets with 64-bit wi
    |
 LL |     1isize as i32;
    |     ^^^^^^^^^^^^^
+   |
+   = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
+help: ... or use `try_from` and handle the error accordingly
+   |
+LL |     i32::try_from(1isize);
+   |     ~~~~~~~~~~~~~~~~~~~~~
 
 error: casting `isize` to `u32` may truncate the value on targets with 64-bit wide pointers
   --> $DIR/cast_size_32bit.rs:20:5
    |
 LL |     1isize as u32;
    |     ^^^^^^^^^^^^^
+   |
+   = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
+help: ... or use `try_from` and handle the error accordingly
+   |
+LL |     u32::try_from(1isize);
+   |     ~~~~~~~~~~~~~~~~~~~~~
 
 error: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
   --> $DIR/cast_size_32bit.rs:21:5
    |
 LL |     1usize as u32;
    |     ^^^^^^^^^^^^^
+   |
+   = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
+help: ... or use `try_from` and handle the error accordingly
+   |
+LL |     u32::try_from(1usize);
+   |     ~~~~~~~~~~~~~~~~~~~~~
 
 error: casting `usize` to `i32` may truncate the value on targets with 64-bit wide pointers
   --> $DIR/cast_size_32bit.rs:22:5
    |
 LL |     1usize as i32;
    |     ^^^^^^^^^^^^^
+   |
+   = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
+help: ... or use `try_from` and handle the error accordingly
+   |
+LL |     i32::try_from(1usize);
+   |     ~~~~~~~~~~~~~~~~~~~~~
 
 error: casting `usize` to `i32` may wrap around the value on targets with 32-bit wide pointers
   --> $DIR/cast_size_32bit.rs:22:5
@@ -69,18 +98,36 @@ error: casting `i64` to `isize` may truncate the value on targets with 32-bit wi
    |
 LL |     1i64 as isize;
    |     ^^^^^^^^^^^^^
+   |
+   = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
+help: ... or use `try_from` and handle the error accordingly
+   |
+LL |     isize::try_from(1i64);
+   |     ~~~~~~~~~~~~~~~~~~~~~
 
 error: casting `i64` to `usize` may truncate the value on targets with 32-bit wide pointers
   --> $DIR/cast_size_32bit.rs:25:5
    |
 LL |     1i64 as usize;
    |     ^^^^^^^^^^^^^
+   |
+   = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
+help: ... or use `try_from` and handle the error accordingly
+   |
+LL |     usize::try_from(1i64);
+   |     ~~~~~~~~~~~~~~~~~~~~~
 
 error: casting `u64` to `isize` may truncate the value on targets with 32-bit wide pointers
   --> $DIR/cast_size_32bit.rs:26:5
    |
 LL |     1u64 as isize;
    |     ^^^^^^^^^^^^^
+   |
+   = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
+help: ... or use `try_from` and handle the error accordingly
+   |
+LL |     isize::try_from(1u64);
+   |     ~~~~~~~~~~~~~~~~~~~~~
 
 error: casting `u64` to `isize` may wrap around the value on targets with 64-bit wide pointers
   --> $DIR/cast_size_32bit.rs:26:5
@@ -93,6 +140,12 @@ error: casting `u64` to `usize` may truncate the value on targets with 32-bit wi
    |
 LL |     1u64 as usize;
    |     ^^^^^^^^^^^^^
+   |
+   = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
+help: ... or use `try_from` and handle the error accordingly
+   |
+LL |     usize::try_from(1u64);
+   |     ~~~~~~~~~~~~~~~~~~~~~
 
 error: casting `u32` to `isize` may wrap around the value on targets with 32-bit wide pointers
   --> $DIR/cast_size_32bit.rs:28:5
diff --git a/tests/ui/cfg_attr_rustfmt.fixed b/tests/ui/cfg_attr_rustfmt.fixed
index b970b1209b6..13aadb7d330 100644
--- a/tests/ui/cfg_attr_rustfmt.fixed
+++ b/tests/ui/cfg_attr_rustfmt.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![feature(stmt_expr_attributes)]
 
 #![allow(unused, clippy::no_effect, clippy::unnecessary_operation)]
diff --git a/tests/ui/cfg_attr_rustfmt.rs b/tests/ui/cfg_attr_rustfmt.rs
index 0a8e6a89d8a..769c5d22b9d 100644
--- a/tests/ui/cfg_attr_rustfmt.rs
+++ b/tests/ui/cfg_attr_rustfmt.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![feature(stmt_expr_attributes)]
 
 #![allow(unused, clippy::no_effect, clippy::unnecessary_operation)]
diff --git a/tests/ui/char_lit_as_u8_suggestions.fixed b/tests/ui/char_lit_as_u8_suggestions.fixed
index 3dc3cb4e757..ce2f149dc05 100644
--- a/tests/ui/char_lit_as_u8_suggestions.fixed
+++ b/tests/ui/char_lit_as_u8_suggestions.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::char_lit_as_u8)]
 
diff --git a/tests/ui/char_lit_as_u8_suggestions.rs b/tests/ui/char_lit_as_u8_suggestions.rs
index d379a023494..ffad12fc6f9 100644
--- a/tests/ui/char_lit_as_u8_suggestions.rs
+++ b/tests/ui/char_lit_as_u8_suggestions.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::char_lit_as_u8)]
 
diff --git a/tests/ui/checked_conversions.fixed b/tests/ui/checked_conversions.fixed
index e279ba3147b..188e6d97595 100644
--- a/tests/ui/checked_conversions.fixed
+++ b/tests/ui/checked_conversions.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(
     clippy::cast_lossless,
diff --git a/tests/ui/checked_conversions.rs b/tests/ui/checked_conversions.rs
index 9d7a40995c3..70f0f0975ac 100644
--- a/tests/ui/checked_conversions.rs
+++ b/tests/ui/checked_conversions.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(
     clippy::cast_lossless,
diff --git a/tests/ui/clear_with_drain.fixed b/tests/ui/clear_with_drain.fixed
index 2d9545eeed1..b68c7d867ec 100644
--- a/tests/ui/clear_with_drain.fixed
+++ b/tests/ui/clear_with_drain.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![allow(unused)]
 #![warn(clippy::clear_with_drain)]
 
diff --git a/tests/ui/clear_with_drain.rs b/tests/ui/clear_with_drain.rs
index 4d60ee46e18..0f6562ecad5 100644
--- a/tests/ui/clear_with_drain.rs
+++ b/tests/ui/clear_with_drain.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![allow(unused)]
 #![warn(clippy::clear_with_drain)]
 
diff --git a/tests/ui/clone_on_copy.fixed b/tests/ui/clone_on_copy.fixed
index 72b12227098..a720711585b 100644
--- a/tests/ui/clone_on_copy.fixed
+++ b/tests/ui/clone_on_copy.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(
     unused,
diff --git a/tests/ui/clone_on_copy.rs b/tests/ui/clone_on_copy.rs
index 03e210ebad9..2c5fac8faf5 100644
--- a/tests/ui/clone_on_copy.rs
+++ b/tests/ui/clone_on_copy.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(
     unused,
diff --git a/tests/ui/cloned_instead_of_copied.fixed b/tests/ui/cloned_instead_of_copied.fixed
index ecbfc1feedf..b6e09ab3190 100644
--- a/tests/ui/cloned_instead_of_copied.fixed
+++ b/tests/ui/cloned_instead_of_copied.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::cloned_instead_of_copied)]
 #![allow(unused)]
diff --git a/tests/ui/cloned_instead_of_copied.rs b/tests/ui/cloned_instead_of_copied.rs
index 163dc3dddce..fa9e1a99613 100644
--- a/tests/ui/cloned_instead_of_copied.rs
+++ b/tests/ui/cloned_instead_of_copied.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::cloned_instead_of_copied)]
 #![allow(unused)]
diff --git a/tests/ui/cmp_owned/asymmetric_partial_eq.fixed b/tests/ui/cmp_owned/asymmetric_partial_eq.fixed
index abd059c2308..3bf3deb9b91 100644
--- a/tests/ui/cmp_owned/asymmetric_partial_eq.fixed
+++ b/tests/ui/cmp_owned/asymmetric_partial_eq.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![allow(unused, clippy::redundant_clone, clippy::derive_partial_eq_without_eq)] // See #5700
 
 // Define the types in each module to avoid trait impls leaking between modules.
diff --git a/tests/ui/cmp_owned/asymmetric_partial_eq.rs b/tests/ui/cmp_owned/asymmetric_partial_eq.rs
index 020ef5f840b..10107dc8f86 100644
--- a/tests/ui/cmp_owned/asymmetric_partial_eq.rs
+++ b/tests/ui/cmp_owned/asymmetric_partial_eq.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![allow(unused, clippy::redundant_clone, clippy::derive_partial_eq_without_eq)] // See #5700
 
 // Define the types in each module to avoid trait impls leaking between modules.
diff --git a/tests/ui/cmp_owned/comparison_flip.fixed b/tests/ui/cmp_owned/comparison_flip.fixed
index 44e41bdd114..b1133f2a59f 100644
--- a/tests/ui/cmp_owned/comparison_flip.fixed
+++ b/tests/ui/cmp_owned/comparison_flip.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 use std::fmt::{self, Display};
 
diff --git a/tests/ui/cmp_owned/comparison_flip.rs b/tests/ui/cmp_owned/comparison_flip.rs
index 662673abb62..091a9aa65c0 100644
--- a/tests/ui/cmp_owned/comparison_flip.rs
+++ b/tests/ui/cmp_owned/comparison_flip.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 use std::fmt::{self, Display};
 
diff --git a/tests/ui/cmp_owned/with_suggestion.fixed b/tests/ui/cmp_owned/with_suggestion.fixed
index b28c4378e33..76f90ab2a9d 100644
--- a/tests/ui/cmp_owned/with_suggestion.fixed
+++ b/tests/ui/cmp_owned/with_suggestion.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #[warn(clippy::cmp_owned)]
 #[allow(clippy::unnecessary_operation, clippy::no_effect, unused_must_use, clippy::eq_op)]
diff --git a/tests/ui/cmp_owned/with_suggestion.rs b/tests/ui/cmp_owned/with_suggestion.rs
index c1089010fe1..f3f663670eb 100644
--- a/tests/ui/cmp_owned/with_suggestion.rs
+++ b/tests/ui/cmp_owned/with_suggestion.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #[warn(clippy::cmp_owned)]
 #[allow(clippy::unnecessary_operation, clippy::no_effect, unused_must_use, clippy::eq_op)]
diff --git a/tests/ui/collapsible_else_if.fixed b/tests/ui/collapsible_else_if.fixed
index d6a5a785067..8302cec45e7 100644
--- a/tests/ui/collapsible_else_if.fixed
+++ b/tests/ui/collapsible_else_if.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![allow(clippy::assertions_on_constants, clippy::equatable_if_let)]
 
 #[rustfmt::skip]
diff --git a/tests/ui/collapsible_else_if.rs b/tests/ui/collapsible_else_if.rs
index 4399fc8b2bd..5913dcf41ca 100644
--- a/tests/ui/collapsible_else_if.rs
+++ b/tests/ui/collapsible_else_if.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![allow(clippy::assertions_on_constants, clippy::equatable_if_let)]
 
 #[rustfmt::skip]
diff --git a/tests/ui/collapsible_if.fixed b/tests/ui/collapsible_if.fixed
index 6bb7682bae9..d2aba2ac59b 100644
--- a/tests/ui/collapsible_if.fixed
+++ b/tests/ui/collapsible_if.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![allow(clippy::assertions_on_constants, clippy::equatable_if_let)]
 
 #[rustfmt::skip]
diff --git a/tests/ui/collapsible_if.rs b/tests/ui/collapsible_if.rs
index e216a9ee54c..e0bef7f9c97 100644
--- a/tests/ui/collapsible_if.rs
+++ b/tests/ui/collapsible_if.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![allow(clippy::assertions_on_constants, clippy::equatable_if_let)]
 
 #[rustfmt::skip]
diff --git a/tests/ui/collapsible_str_replace.fixed b/tests/ui/collapsible_str_replace.fixed
index 9792ae9ed6b..ba6c1769a9a 100644
--- a/tests/ui/collapsible_str_replace.fixed
+++ b/tests/ui/collapsible_str_replace.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(unused)]
 #![warn(clippy::collapsible_str_replace)]
diff --git a/tests/ui/collapsible_str_replace.rs b/tests/ui/collapsible_str_replace.rs
index baee185b79e..f5871be65be 100644
--- a/tests/ui/collapsible_str_replace.rs
+++ b/tests/ui/collapsible_str_replace.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(unused)]
 #![warn(clippy::collapsible_str_replace)]
diff --git a/tests/ui/comparison_to_empty.fixed b/tests/ui/comparison_to_empty.fixed
index 261024caca7..dd2615ab25c 100644
--- a/tests/ui/comparison_to_empty.fixed
+++ b/tests/ui/comparison_to_empty.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::comparison_to_empty)]
 
diff --git a/tests/ui/comparison_to_empty.rs b/tests/ui/comparison_to_empty.rs
index 98ddd974951..5462784c6ac 100644
--- a/tests/ui/comparison_to_empty.rs
+++ b/tests/ui/comparison_to_empty.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::comparison_to_empty)]
 
diff --git a/tests/ui/crashes/auxiliary/proc_macro_crash.rs b/tests/ui/crashes/auxiliary/proc_macro_crash.rs
index 5ff2af7cd82..66419656a32 100644
--- a/tests/ui/crashes/auxiliary/proc_macro_crash.rs
+++ b/tests/ui/crashes/auxiliary/proc_macro_crash.rs
@@ -1,5 +1,5 @@
-// compile-flags: --emit=link
-// no-prefer-dynamic
+//@compile-flags: --emit=link
+//@no-prefer-dynamic
 // ^ compiletest by default builds all aux files as dylibs, but we don't want that for proc-macro
 // crates. If we don't set this, compiletest will override the `crate_type` attribute below and
 // compile this as dylib. Removing this then causes the test to fail because a `dylib` crate can't
diff --git a/tests/ui/crashes/ice-10148.rs b/tests/ui/crashes/ice-10148.rs
index 1ab3570c907..c7f0224820e 100644
--- a/tests/ui/crashes/ice-10148.rs
+++ b/tests/ui/crashes/ice-10148.rs
@@ -1,4 +1,4 @@
-// aux-build:../../auxiliary/proc_macros.rs
+//@aux-build:../../auxiliary/proc_macros.rs
 
 extern crate proc_macros;
 
diff --git a/tests/ui/crashes/ice-3741.rs b/tests/ui/crashes/ice-3741.rs
index 1253ddcfaeb..3106a2e7216 100644
--- a/tests/ui/crashes/ice-3741.rs
+++ b/tests/ui/crashes/ice-3741.rs
@@ -1,4 +1,4 @@
-// aux-build:proc_macro_crash.rs
+//@aux-build:proc_macro_crash.rs
 
 #![warn(clippy::suspicious_else_formatting)]
 
diff --git a/tests/ui/crashes/ice-4968.rs b/tests/ui/crashes/ice-4968.rs
index e0510d942c2..ac724ac93e3 100644
--- a/tests/ui/crashes/ice-4968.rs
+++ b/tests/ui/crashes/ice-4968.rs
@@ -1,4 +1,4 @@
-// check-pass
+//@check-pass
 
 // Test for https://github.com/rust-lang/rust-clippy/issues/4968
 
diff --git a/tests/ui/crashes/ice-7272.rs b/tests/ui/crashes/ice-7272.rs
index 57ab6ca14f8..e949038c8d0 100644
--- a/tests/ui/crashes/ice-7272.rs
+++ b/tests/ui/crashes/ice-7272.rs
@@ -1,4 +1,4 @@
-// aux-build:ice-7272-aux.rs
+//@aux-build:ice-7272-aux.rs
 
 #![allow(clippy::no_effect)]
 
diff --git a/tests/ui/crashes/ice-7410.rs b/tests/ui/crashes/ice-7410.rs
index 85fa4210321..ffe20ab1c31 100644
--- a/tests/ui/crashes/ice-7410.rs
+++ b/tests/ui/crashes/ice-7410.rs
@@ -1,6 +1,6 @@
-// compile-flags: -Clink-arg=-nostartfiles
-// ignore-macos
-// ignore-windows
+//@compile-flags: -Clink-arg=-nostartfiles
+//@ignore-macos
+//@ignore-windows
 
 #![feature(lang_items, start, libc)]
 #![no_std]
diff --git a/tests/ui/crashes/ice-8681.rs b/tests/ui/crashes/ice-8681.rs
index ee14f011f63..607b9caa324 100644
--- a/tests/ui/crashes/ice-8681.rs
+++ b/tests/ui/crashes/ice-8681.rs
@@ -1,4 +1,4 @@
-// aux-build: ice-8681-aux.rs
+//@aux-build: ice-8681-aux.rs
 
 #![warn(clippy::undocumented_unsafe_blocks)]
 
diff --git a/tests/ui/crate_in_macro_def.fixed b/tests/ui/crate_in_macro_def.fixed
index 9fc594be311..12a7b9470b3 100644
--- a/tests/ui/crate_in_macro_def.fixed
+++ b/tests/ui/crate_in_macro_def.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::crate_in_macro_def)]
 
 mod hygienic {
diff --git a/tests/ui/crate_in_macro_def.rs b/tests/ui/crate_in_macro_def.rs
index ac456108e4a..a1a9eabf639 100644
--- a/tests/ui/crate_in_macro_def.rs
+++ b/tests/ui/crate_in_macro_def.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::crate_in_macro_def)]
 
 mod hygienic {
diff --git a/tests/ui/crate_level_checks/entrypoint_recursion.rs b/tests/ui/crate_level_checks/entrypoint_recursion.rs
index 1b3bcece6f1..d6cd594d7c9 100644
--- a/tests/ui/crate_level_checks/entrypoint_recursion.rs
+++ b/tests/ui/crate_level_checks/entrypoint_recursion.rs
@@ -1,4 +1,4 @@
-// ignore-macos
+//@ignore-macos
 
 #![feature(rustc_attrs)]
 
diff --git a/tests/ui/crate_level_checks/no_std_main_recursion.rs b/tests/ui/crate_level_checks/no_std_main_recursion.rs
index e1c9fe30a9d..a382135bb69 100644
--- a/tests/ui/crate_level_checks/no_std_main_recursion.rs
+++ b/tests/ui/crate_level_checks/no_std_main_recursion.rs
@@ -1,5 +1,5 @@
-// compile-flags: -Clink-arg=-nostartfiles
-// ignore-macos
+//@compile-flags: -Clink-arg=-nostartfiles
+//@ignore-macos
 
 #![feature(lang_items, start, libc)]
 #![no_std]
diff --git a/tests/ui/create_dir.fixed b/tests/ui/create_dir.fixed
index 8ed53a56ac0..5de3e9fea0b 100644
--- a/tests/ui/create_dir.fixed
+++ b/tests/ui/create_dir.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![allow(unused_must_use)]
 #![warn(clippy::create_dir)]
 
diff --git a/tests/ui/create_dir.rs b/tests/ui/create_dir.rs
index 19c8fc24ba2..d375bfb4a68 100644
--- a/tests/ui/create_dir.rs
+++ b/tests/ui/create_dir.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![allow(unused_must_use)]
 #![warn(clippy::create_dir)]
 
diff --git a/tests/ui/dbg_macro.rs b/tests/ui/dbg_macro.rs
index 25294e8c766..8701e3cd29f 100644
--- a/tests/ui/dbg_macro.rs
+++ b/tests/ui/dbg_macro.rs
@@ -1,4 +1,4 @@
-// compile-flags: --test
+//@compile-flags: --test
 #![warn(clippy::dbg_macro)]
 
 fn foo(n: u32) -> u32 {
diff --git a/tests/ui/decimal_literal_representation.fixed b/tests/ui/decimal_literal_representation.fixed
index de391465125..a6eb8c21457 100644
--- a/tests/ui/decimal_literal_representation.fixed
+++ b/tests/ui/decimal_literal_representation.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #[warn(clippy::decimal_literal_representation)]
 #[allow(unused_variables)]
diff --git a/tests/ui/decimal_literal_representation.rs b/tests/ui/decimal_literal_representation.rs
index 55d07698e7e..7c666d6d7a6 100644
--- a/tests/ui/decimal_literal_representation.rs
+++ b/tests/ui/decimal_literal_representation.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #[warn(clippy::decimal_literal_representation)]
 #[allow(unused_variables)]
diff --git a/tests/ui/def_id_nocore.rs b/tests/ui/def_id_nocore.rs
index 1af77d1a25b..f7819068ac5 100644
--- a/tests/ui/def_id_nocore.rs
+++ b/tests/ui/def_id_nocore.rs
@@ -1,4 +1,4 @@
-// ignore-macos
+//@ignore-macos
 
 #![feature(no_core, lang_items, start)]
 #![no_core]
diff --git a/tests/ui/default_instead_of_iter_empty.fixed b/tests/ui/default_instead_of_iter_empty.fixed
index f1abfdcd6ce..f44d34576f6 100644
--- a/tests/ui/default_instead_of_iter_empty.fixed
+++ b/tests/ui/default_instead_of_iter_empty.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::default_instead_of_iter_empty)]
 #![allow(dead_code)]
 use std::collections::HashMap;
diff --git a/tests/ui/default_instead_of_iter_empty.rs b/tests/ui/default_instead_of_iter_empty.rs
index 2630519c46d..1c649df253c 100644
--- a/tests/ui/default_instead_of_iter_empty.rs
+++ b/tests/ui/default_instead_of_iter_empty.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::default_instead_of_iter_empty)]
 #![allow(dead_code)]
 use std::collections::HashMap;
diff --git a/tests/ui/default_numeric_fallback_f64.fixed b/tests/ui/default_numeric_fallback_f64.fixed
index 42c15d6a70b..9520efe6329 100644
--- a/tests/ui/default_numeric_fallback_f64.fixed
+++ b/tests/ui/default_numeric_fallback_f64.fixed
@@ -1,5 +1,5 @@
-// run-rustfix
-// aux-build:proc_macros.rs
+//@run-rustfix
+//@aux-build:proc_macros.rs
 
 #![warn(clippy::default_numeric_fallback)]
 #![allow(
diff --git a/tests/ui/default_numeric_fallback_f64.rs b/tests/ui/default_numeric_fallback_f64.rs
index 7da7ea254e9..cacbdb4a95b 100644
--- a/tests/ui/default_numeric_fallback_f64.rs
+++ b/tests/ui/default_numeric_fallback_f64.rs
@@ -1,5 +1,5 @@
-// run-rustfix
-// aux-build:proc_macros.rs
+//@run-rustfix
+//@aux-build:proc_macros.rs
 
 #![warn(clippy::default_numeric_fallback)]
 #![allow(
diff --git a/tests/ui/default_numeric_fallback_i32.fixed b/tests/ui/default_numeric_fallback_i32.fixed
index b7485b73dcd..fbabb8bcf8e 100644
--- a/tests/ui/default_numeric_fallback_i32.fixed
+++ b/tests/ui/default_numeric_fallback_i32.fixed
@@ -1,5 +1,5 @@
-// run-rustfix
-// aux-build:proc_macros.rs
+//@run-rustfix
+//@aux-build:proc_macros.rs
 
 #![feature(lint_reasons)]
 #![warn(clippy::default_numeric_fallback)]
diff --git a/tests/ui/default_numeric_fallback_i32.rs b/tests/ui/default_numeric_fallback_i32.rs
index 7307d31354e..7bfc390e4bf 100644
--- a/tests/ui/default_numeric_fallback_i32.rs
+++ b/tests/ui/default_numeric_fallback_i32.rs
@@ -1,5 +1,5 @@
-// run-rustfix
-// aux-build:proc_macros.rs
+//@run-rustfix
+//@aux-build:proc_macros.rs
 
 #![feature(lint_reasons)]
 #![warn(clippy::default_numeric_fallback)]
diff --git a/tests/ui/default_trait_access.fixed b/tests/ui/default_trait_access.fixed
index 7842ef3ec40..bf5dca97641 100644
--- a/tests/ui/default_trait_access.fixed
+++ b/tests/ui/default_trait_access.fixed
@@ -1,5 +1,5 @@
-// run-rustfix
-// aux-build: proc_macros.rs
+//@run-rustfix
+//@aux-build: proc_macros.rs
 #![deny(clippy::default_trait_access)]
 #![allow(dead_code, unused_imports)]
 #![allow(clippy::uninlined_format_args)]
diff --git a/tests/ui/default_trait_access.rs b/tests/ui/default_trait_access.rs
index cbb3e59c970..5e8e9ce85b1 100644
--- a/tests/ui/default_trait_access.rs
+++ b/tests/ui/default_trait_access.rs
@@ -1,5 +1,5 @@
-// run-rustfix
-// aux-build: proc_macros.rs
+//@run-rustfix
+//@aux-build: proc_macros.rs
 #![deny(clippy::default_trait_access)]
 #![allow(dead_code, unused_imports)]
 #![allow(clippy::uninlined_format_args)]
diff --git a/tests/ui/deref_addrof.fixed b/tests/ui/deref_addrof.fixed
index ca5c03304c7..b27d3bc1002 100644
--- a/tests/ui/deref_addrof.fixed
+++ b/tests/ui/deref_addrof.fixed
@@ -1,5 +1,5 @@
-// run-rustfix
-// aux-build:proc_macros.rs
+//@run-rustfix
+//@aux-build:proc_macros.rs
 
 #![allow(clippy::return_self_not_must_use)]
 #![warn(clippy::deref_addrof)]
diff --git a/tests/ui/deref_addrof.rs b/tests/ui/deref_addrof.rs
index 3db5fafe944..825090c7c12 100644
--- a/tests/ui/deref_addrof.rs
+++ b/tests/ui/deref_addrof.rs
@@ -1,5 +1,5 @@
-// run-rustfix
-// aux-build:proc_macros.rs
+//@run-rustfix
+//@aux-build:proc_macros.rs
 
 #![allow(clippy::return_self_not_must_use)]
 #![warn(clippy::deref_addrof)]
diff --git a/tests/ui/deref_addrof_macro.rs b/tests/ui/deref_addrof_macro.rs
index 57c0be3f51e..c7e60f36506 100644
--- a/tests/ui/deref_addrof_macro.rs
+++ b/tests/ui/deref_addrof_macro.rs
@@ -1,4 +1,4 @@
-// aux-build:proc_macros.rs
+//@aux-build:proc_macros.rs
 
 #![warn(clippy::deref_addrof)]
 
diff --git a/tests/ui/deref_by_slicing.fixed b/tests/ui/deref_by_slicing.fixed
index 257393e56ff..f91a425c65d 100644
--- a/tests/ui/deref_by_slicing.fixed
+++ b/tests/ui/deref_by_slicing.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::deref_by_slicing)]
 #![allow(clippy::borrow_deref_ref)]
diff --git a/tests/ui/deref_by_slicing.rs b/tests/ui/deref_by_slicing.rs
index e288046f927..1bfdd0a981b 100644
--- a/tests/ui/deref_by_slicing.rs
+++ b/tests/ui/deref_by_slicing.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::deref_by_slicing)]
 #![allow(clippy::borrow_deref_ref)]
diff --git a/tests/ui/derivable_impls.fixed b/tests/ui/derivable_impls.fixed
index 89ec33a0d8f..aa0efb85c29 100644
--- a/tests/ui/derivable_impls.fixed
+++ b/tests/ui/derivable_impls.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(dead_code)]
 
diff --git a/tests/ui/derivable_impls.rs b/tests/ui/derivable_impls.rs
index def6e41162f..8dc999ad586 100644
--- a/tests/ui/derivable_impls.rs
+++ b/tests/ui/derivable_impls.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(dead_code)]
 
diff --git a/tests/ui/derive_partial_eq_without_eq.fixed b/tests/ui/derive_partial_eq_without_eq.fixed
index bbbe467590f..a1f29430c30 100644
--- a/tests/ui/derive_partial_eq_without_eq.fixed
+++ b/tests/ui/derive_partial_eq_without_eq.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(unused)]
 #![warn(clippy::derive_partial_eq_without_eq)]
diff --git a/tests/ui/derive_partial_eq_without_eq.rs b/tests/ui/derive_partial_eq_without_eq.rs
index 88d6fbd1af7..ff4d888559b 100644
--- a/tests/ui/derive_partial_eq_without_eq.rs
+++ b/tests/ui/derive_partial_eq_without_eq.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(unused)]
 #![warn(clippy::derive_partial_eq_without_eq)]
diff --git a/tests/ui/doc/doc-fixable.fixed b/tests/ui/doc/doc-fixable.fixed
index ecb0bf3644e..d3aa2816cb6 100644
--- a/tests/ui/doc/doc-fixable.fixed
+++ b/tests/ui/doc/doc-fixable.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 //! This file tests for the `DOC_MARKDOWN` lint.
 
 #![allow(dead_code, incomplete_features)]
diff --git a/tests/ui/doc/doc-fixable.rs b/tests/ui/doc/doc-fixable.rs
index 11c48dd103d..d1e7d8017d7 100644
--- a/tests/ui/doc/doc-fixable.rs
+++ b/tests/ui/doc/doc-fixable.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 //! This file tests for the `DOC_MARKDOWN` lint.
 
 #![allow(dead_code, incomplete_features)]
diff --git a/tests/ui/doc_unsafe.rs b/tests/ui/doc_unsafe.rs
index 30674ce3708..0c8eac5ccff 100644
--- a/tests/ui/doc_unsafe.rs
+++ b/tests/ui/doc_unsafe.rs
@@ -1,4 +1,4 @@
-// aux-build:proc_macros.rs
+//@aux-build:proc_macros.rs
 
 #![allow(clippy::let_unit_value)]
 
diff --git a/tests/ui/double_comparison.fixed b/tests/ui/double_comparison.fixed
index bb6cdaa667d..c80ff671a5d 100644
--- a/tests/ui/double_comparison.fixed
+++ b/tests/ui/double_comparison.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 fn main() {
     let x = 1;
diff --git a/tests/ui/double_comparison.rs b/tests/ui/double_comparison.rs
index 9a2a9068a28..bc78694aa68 100644
--- a/tests/ui/double_comparison.rs
+++ b/tests/ui/double_comparison.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 fn main() {
     let x = 1;
diff --git a/tests/ui/duration_subsec.fixed b/tests/ui/duration_subsec.fixed
index d92b8998e88..bfd30f0042d 100644
--- a/tests/ui/duration_subsec.fixed
+++ b/tests/ui/duration_subsec.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![allow(dead_code, clippy::needless_borrow)]
 #![warn(clippy::duration_subsec)]
 
diff --git a/tests/ui/duration_subsec.rs b/tests/ui/duration_subsec.rs
index 08da804996d..860233f084f 100644
--- a/tests/ui/duration_subsec.rs
+++ b/tests/ui/duration_subsec.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![allow(dead_code, clippy::needless_borrow)]
 #![warn(clippy::duration_subsec)]
 
diff --git a/tests/ui/empty_drop.fixed b/tests/ui/empty_drop.fixed
index 2e1b768461a..fd0a9a7081e 100644
--- a/tests/ui/empty_drop.fixed
+++ b/tests/ui/empty_drop.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::empty_drop)]
 #![allow(unused)]
 
diff --git a/tests/ui/empty_drop.rs b/tests/ui/empty_drop.rs
index 75232b0334d..6c15cb93302 100644
--- a/tests/ui/empty_drop.rs
+++ b/tests/ui/empty_drop.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::empty_drop)]
 #![allow(unused)]
 
diff --git a/tests/ui/empty_line_after_outer_attribute.rs b/tests/ui/empty_line_after_outer_attribute.rs
index 697412c0027..269e66ea0a8 100644
--- a/tests/ui/empty_line_after_outer_attribute.rs
+++ b/tests/ui/empty_line_after_outer_attribute.rs
@@ -1,4 +1,4 @@
-// aux-build:proc_macro_attr.rs
+//@aux-build:proc_macro_attr.rs
 #![warn(clippy::empty_line_after_outer_attr)]
 #![allow(clippy::assertions_on_constants)]
 #![feature(custom_inner_attributes)]
diff --git a/tests/ui/empty_loop.rs b/tests/ui/empty_loop.rs
index 6a8e6b550c1..54e8fb4907c 100644
--- a/tests/ui/empty_loop.rs
+++ b/tests/ui/empty_loop.rs
@@ -1,4 +1,4 @@
-// aux-build:proc_macros.rs
+//@aux-build:proc_macros.rs
 
 #![warn(clippy::empty_loop)]
 
diff --git a/tests/ui/empty_loop_no_std.rs b/tests/ui/empty_loop_no_std.rs
index e742b396fcd..d564b2d24f5 100644
--- a/tests/ui/empty_loop_no_std.rs
+++ b/tests/ui/empty_loop_no_std.rs
@@ -1,5 +1,5 @@
-// compile-flags: -Clink-arg=-nostartfiles
-// ignore-macos
+//@compile-flags: -Clink-arg=-nostartfiles
+//@ignore-macos
 
 #![warn(clippy::empty_loop)]
 #![feature(lang_items, start, libc)]
diff --git a/tests/ui/empty_structs_with_brackets.fixed b/tests/ui/empty_structs_with_brackets.fixed
index 80f07603b8d..6fab3020839 100644
--- a/tests/ui/empty_structs_with_brackets.fixed
+++ b/tests/ui/empty_structs_with_brackets.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::empty_structs_with_brackets)]
 #![allow(dead_code)]
 
diff --git a/tests/ui/empty_structs_with_brackets.rs b/tests/ui/empty_structs_with_brackets.rs
index 1d1ed4c7690..0caa3c49cd6 100644
--- a/tests/ui/empty_structs_with_brackets.rs
+++ b/tests/ui/empty_structs_with_brackets.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::empty_structs_with_brackets)]
 #![allow(dead_code)]
 
diff --git a/tests/ui/entry.fixed b/tests/ui/entry.fixed
index dbe09e0ff3c..7e82390605c 100644
--- a/tests/ui/entry.fixed
+++ b/tests/ui/entry.fixed
@@ -1,5 +1,5 @@
-// needs-asm-support
-// run-rustfix
+//@needs-asm-support
+//@run-rustfix
 
 #![allow(unused, clippy::needless_pass_by_value, clippy::collapsible_if)]
 #![warn(clippy::map_entry)]
diff --git a/tests/ui/entry.rs b/tests/ui/entry.rs
index 30fed34fc5d..742c9322535 100644
--- a/tests/ui/entry.rs
+++ b/tests/ui/entry.rs
@@ -1,5 +1,5 @@
-// needs-asm-support
-// run-rustfix
+//@needs-asm-support
+//@run-rustfix
 
 #![allow(unused, clippy::needless_pass_by_value, clippy::collapsible_if)]
 #![warn(clippy::map_entry)]
diff --git a/tests/ui/entry_btree.fixed b/tests/ui/entry_btree.fixed
index 94979104556..3baaacffd20 100644
--- a/tests/ui/entry_btree.fixed
+++ b/tests/ui/entry_btree.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::map_entry)]
 #![allow(dead_code)]
diff --git a/tests/ui/entry_btree.rs b/tests/ui/entry_btree.rs
index 080c1d959e8..770e8e91da2 100644
--- a/tests/ui/entry_btree.rs
+++ b/tests/ui/entry_btree.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::map_entry)]
 #![allow(dead_code)]
diff --git a/tests/ui/entry_with_else.fixed b/tests/ui/entry_with_else.fixed
index 2332fa6313f..71fe04fd648 100644
--- a/tests/ui/entry_with_else.fixed
+++ b/tests/ui/entry_with_else.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(unused, clippy::needless_pass_by_value, clippy::collapsible_if)]
 #![warn(clippy::map_entry)]
diff --git a/tests/ui/entry_with_else.rs b/tests/ui/entry_with_else.rs
index 2ff0c038efe..80f74649a60 100644
--- a/tests/ui/entry_with_else.rs
+++ b/tests/ui/entry_with_else.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(unused, clippy::needless_pass_by_value, clippy::collapsible_if)]
 #![warn(clippy::map_entry)]
diff --git a/tests/ui/enum_clike_unportable_variant.rs b/tests/ui/enum_clike_unportable_variant.rs
index 7d6842f5b54..f17556ea907 100644
--- a/tests/ui/enum_clike_unportable_variant.rs
+++ b/tests/ui/enum_clike_unportable_variant.rs
@@ -1,4 +1,4 @@
-// ignore-x86
+//@ignore-x86
 
 #![warn(clippy::enum_clike_unportable_variant)]
 #![allow(unused, non_upper_case_globals)]
diff --git a/tests/ui/enum_glob_use.fixed b/tests/ui/enum_glob_use.fixed
index a98216758bb..419370ffb1d 100644
--- a/tests/ui/enum_glob_use.fixed
+++ b/tests/ui/enum_glob_use.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::enum_glob_use)]
 #![allow(unused)]
diff --git a/tests/ui/enum_glob_use.rs b/tests/ui/enum_glob_use.rs
index 5d929c9731d..645ed98325c 100644
--- a/tests/ui/enum_glob_use.rs
+++ b/tests/ui/enum_glob_use.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::enum_glob_use)]
 #![allow(unused)]
diff --git a/tests/ui/eq_op.rs b/tests/ui/eq_op.rs
index e7379550265..cdd33ebe582 100644
--- a/tests/ui/eq_op.rs
+++ b/tests/ui/eq_op.rs
@@ -1,4 +1,4 @@
-// compile-flags: --test
+//@compile-flags: --test
 
 #![warn(clippy::eq_op)]
 #![allow(clippy::double_parens, clippy::identity_op, clippy::nonminimal_bool)]
diff --git a/tests/ui/equatable_if_let.fixed b/tests/ui/equatable_if_let.fixed
index 007702ab550..53e62760bef 100644
--- a/tests/ui/equatable_if_let.fixed
+++ b/tests/ui/equatable_if_let.fixed
@@ -1,5 +1,5 @@
-// run-rustfix
-// aux-build:proc_macros.rs
+//@run-rustfix
+//@aux-build:proc_macros.rs
 
 #![allow(unused_variables, dead_code, clippy::derive_partial_eq_without_eq)]
 #![warn(clippy::equatable_if_let)]
diff --git a/tests/ui/equatable_if_let.rs b/tests/ui/equatable_if_let.rs
index 3bda7977645..55918a5bb11 100644
--- a/tests/ui/equatable_if_let.rs
+++ b/tests/ui/equatable_if_let.rs
@@ -1,5 +1,5 @@
-// run-rustfix
-// aux-build:proc_macros.rs
+//@run-rustfix
+//@aux-build:proc_macros.rs
 
 #![allow(unused_variables, dead_code, clippy::derive_partial_eq_without_eq)]
 #![warn(clippy::equatable_if_let)]
diff --git a/tests/ui/err_expect.fixed b/tests/ui/err_expect.fixed
index b63cbd8a8e6..6ade6f54689 100644
--- a/tests/ui/err_expect.fixed
+++ b/tests/ui/err_expect.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(unused)]
 
diff --git a/tests/ui/err_expect.rs b/tests/ui/err_expect.rs
index c081a745fb4..a93fb59493f 100644
--- a/tests/ui/err_expect.rs
+++ b/tests/ui/err_expect.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(unused)]
 
diff --git a/tests/ui/eta.fixed b/tests/ui/eta.fixed
index dc129591eac..b1baf462c0f 100644
--- a/tests/ui/eta.fixed
+++ b/tests/ui/eta.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::redundant_closure, clippy::redundant_closure_for_method_calls)]
 #![allow(unused)]
 #![allow(
diff --git a/tests/ui/eta.rs b/tests/ui/eta.rs
index 025fd6a0b7a..e113c3d6cd6 100644
--- a/tests/ui/eta.rs
+++ b/tests/ui/eta.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::redundant_closure, clippy::redundant_closure_for_method_calls)]
 #![allow(unused)]
 #![allow(
diff --git a/tests/ui/excessive_precision.fixed b/tests/ui/excessive_precision.fixed
index b74bda182be..0a07957386c 100644
--- a/tests/ui/excessive_precision.fixed
+++ b/tests/ui/excessive_precision.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::excessive_precision)]
 #![allow(dead_code, unused_variables, clippy::print_literal)]
 
diff --git a/tests/ui/excessive_precision.rs b/tests/ui/excessive_precision.rs
index 6e84a71f24c..62a832caa67 100644
--- a/tests/ui/excessive_precision.rs
+++ b/tests/ui/excessive_precision.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::excessive_precision)]
 #![allow(dead_code, unused_variables, clippy::print_literal)]
 
diff --git a/tests/ui/exhaustive_items.fixed b/tests/ui/exhaustive_items.fixed
index c209f5b4b72..6c7b1cab6f2 100644
--- a/tests/ui/exhaustive_items.fixed
+++ b/tests/ui/exhaustive_items.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![deny(clippy::exhaustive_enums, clippy::exhaustive_structs)]
 #![allow(unused)]
diff --git a/tests/ui/exhaustive_items.rs b/tests/ui/exhaustive_items.rs
index 6f59dbf2da5..d205bac2d2a 100644
--- a/tests/ui/exhaustive_items.rs
+++ b/tests/ui/exhaustive_items.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![deny(clippy::exhaustive_enums, clippy::exhaustive_structs)]
 #![allow(unused)]
diff --git a/tests/ui/expect_fun_call.fixed b/tests/ui/expect_fun_call.fixed
index 15172ae345c..8e97054fb6b 100644
--- a/tests/ui/expect_fun_call.fixed
+++ b/tests/ui/expect_fun_call.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::expect_fun_call)]
 #![allow(clippy::to_string_in_format_args, clippy::uninlined_format_args)]
 
diff --git a/tests/ui/expect_fun_call.rs b/tests/ui/expect_fun_call.rs
index 0f448d00417..31e6bcc7ff6 100644
--- a/tests/ui/expect_fun_call.rs
+++ b/tests/ui/expect_fun_call.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::expect_fun_call)]
 #![allow(clippy::to_string_in_format_args, clippy::uninlined_format_args)]
 
diff --git a/tests/ui/explicit_auto_deref.fixed b/tests/ui/explicit_auto_deref.fixed
index 5d40c850424..71a5ed96d5c 100644
--- a/tests/ui/explicit_auto_deref.fixed
+++ b/tests/ui/explicit_auto_deref.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![feature(closure_lifetime_binder)]
 #![warn(clippy::explicit_auto_deref)]
diff --git a/tests/ui/explicit_auto_deref.rs b/tests/ui/explicit_auto_deref.rs
index 79e03f4d76c..9d0cafa150f 100644
--- a/tests/ui/explicit_auto_deref.rs
+++ b/tests/ui/explicit_auto_deref.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![feature(closure_lifetime_binder)]
 #![warn(clippy::explicit_auto_deref)]
diff --git a/tests/ui/explicit_deref_methods.fixed b/tests/ui/explicit_deref_methods.fixed
index 6d32bbece1e..77e9f5fc1fd 100644
--- a/tests/ui/explicit_deref_methods.fixed
+++ b/tests/ui/explicit_deref_methods.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::explicit_deref_methods)]
 #![allow(unused_variables)]
 #![allow(
diff --git a/tests/ui/explicit_deref_methods.rs b/tests/ui/explicit_deref_methods.rs
index 779909e4238..0c2cc7c2c3a 100644
--- a/tests/ui/explicit_deref_methods.rs
+++ b/tests/ui/explicit_deref_methods.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::explicit_deref_methods)]
 #![allow(unused_variables)]
 #![allow(
diff --git a/tests/ui/explicit_write.fixed b/tests/ui/explicit_write.fixed
index 862c3fea9ee..213485bc221 100644
--- a/tests/ui/explicit_write.fixed
+++ b/tests/ui/explicit_write.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::explicit_write)]
 #![allow(unused_imports)]
 #![allow(clippy::uninlined_format_args)]
diff --git a/tests/ui/explicit_write.rs b/tests/ui/explicit_write.rs
index 41d7c225573..64acd7108bf 100644
--- a/tests/ui/explicit_write.rs
+++ b/tests/ui/explicit_write.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::explicit_write)]
 #![allow(unused_imports)]
 #![allow(clippy::uninlined_format_args)]
diff --git a/tests/ui/extend_with_drain.fixed b/tests/ui/extend_with_drain.fixed
index 71ebad24c16..594f2f6d413 100644
--- a/tests/ui/extend_with_drain.fixed
+++ b/tests/ui/extend_with_drain.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::extend_with_drain)]
 #![allow(clippy::iter_with_drain)]
 use std::collections::BinaryHeap;
diff --git a/tests/ui/extend_with_drain.rs b/tests/ui/extend_with_drain.rs
index e9f011abb0e..3e2ad02052d 100644
--- a/tests/ui/extend_with_drain.rs
+++ b/tests/ui/extend_with_drain.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::extend_with_drain)]
 #![allow(clippy::iter_with_drain)]
 use std::collections::BinaryHeap;
diff --git a/tests/ui/extra_unused_lifetimes.rs b/tests/ui/extra_unused_lifetimes.rs
index d6631e01290..cdfaf8d3afe 100644
--- a/tests/ui/extra_unused_lifetimes.rs
+++ b/tests/ui/extra_unused_lifetimes.rs
@@ -1,4 +1,4 @@
-// aux-build:proc_macro_derive.rs
+//@aux-build:proc_macro_derive.rs
 
 #![allow(
     unused,
diff --git a/tests/ui/extra_unused_type_parameters.fixed b/tests/ui/extra_unused_type_parameters.fixed
index 19e71862558..adcd1f6d407 100644
--- a/tests/ui/extra_unused_type_parameters.fixed
+++ b/tests/ui/extra_unused_type_parameters.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(unused, clippy::needless_lifetimes)]
 #![warn(clippy::extra_unused_type_parameters)]
diff --git a/tests/ui/extra_unused_type_parameters.rs b/tests/ui/extra_unused_type_parameters.rs
index e53bb587e89..c4c5227ac91 100644
--- a/tests/ui/extra_unused_type_parameters.rs
+++ b/tests/ui/extra_unused_type_parameters.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(unused, clippy::needless_lifetimes)]
 #![warn(clippy::extra_unused_type_parameters)]
diff --git a/tests/ui/field_reassign_with_default.rs b/tests/ui/field_reassign_with_default.rs
index 0e208b3ed0e..2045b1eebcd 100644
--- a/tests/ui/field_reassign_with_default.rs
+++ b/tests/ui/field_reassign_with_default.rs
@@ -1,5 +1,5 @@
-// aux-build:proc_macro_derive.rs
-// aux-build:proc_macros.rs
+//@aux-build:proc_macro_derive.rs
+//@aux-build:proc_macros.rs
 
 #![warn(clippy::field_reassign_with_default)]
 
diff --git a/tests/ui/filter_map_identity.fixed b/tests/ui/filter_map_identity.fixed
index a5860aa49b3..44665b451ad 100644
--- a/tests/ui/filter_map_identity.fixed
+++ b/tests/ui/filter_map_identity.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(unused_imports, clippy::needless_return)]
 #![warn(clippy::filter_map_identity)]
diff --git a/tests/ui/filter_map_identity.rs b/tests/ui/filter_map_identity.rs
index 7e998b9cdf7..9832acb013f 100644
--- a/tests/ui/filter_map_identity.rs
+++ b/tests/ui/filter_map_identity.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(unused_imports, clippy::needless_return)]
 #![warn(clippy::filter_map_identity)]
diff --git a/tests/ui/filter_map_next_fixable.fixed b/tests/ui/filter_map_next_fixable.fixed
index 462d46169fc..efb37f8b1b7 100644
--- a/tests/ui/filter_map_next_fixable.fixed
+++ b/tests/ui/filter_map_next_fixable.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::all, clippy::pedantic)]
 #![allow(unused)]
diff --git a/tests/ui/filter_map_next_fixable.rs b/tests/ui/filter_map_next_fixable.rs
index 2ea00cf7307..b10e20d359e 100644
--- a/tests/ui/filter_map_next_fixable.rs
+++ b/tests/ui/filter_map_next_fixable.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::all, clippy::pedantic)]
 #![allow(unused)]
diff --git a/tests/ui/flat_map_identity.fixed b/tests/ui/flat_map_identity.fixed
index 1f4b880ef5b..97091d6f1a5 100644
--- a/tests/ui/flat_map_identity.fixed
+++ b/tests/ui/flat_map_identity.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(unused_imports, clippy::needless_return)]
 #![warn(clippy::flat_map_identity)]
diff --git a/tests/ui/flat_map_identity.rs b/tests/ui/flat_map_identity.rs
index de14a06d4e6..5607683a5d0 100644
--- a/tests/ui/flat_map_identity.rs
+++ b/tests/ui/flat_map_identity.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(unused_imports, clippy::needless_return)]
 #![warn(clippy::flat_map_identity)]
diff --git a/tests/ui/flat_map_option.fixed b/tests/ui/flat_map_option.fixed
index 6a34f008995..eeab864c42f 100644
--- a/tests/ui/flat_map_option.fixed
+++ b/tests/ui/flat_map_option.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::flat_map_option)]
 #![allow(clippy::redundant_closure, clippy::unnecessary_filter_map)]
 
diff --git a/tests/ui/flat_map_option.rs b/tests/ui/flat_map_option.rs
index 2479abddbf0..ebc389f7f02 100644
--- a/tests/ui/flat_map_option.rs
+++ b/tests/ui/flat_map_option.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::flat_map_option)]
 #![allow(clippy::redundant_closure, clippy::unnecessary_filter_map)]
 
diff --git a/tests/ui/floating_point_abs.fixed b/tests/ui/floating_point_abs.fixed
index ca747fefc64..0cc572822e7 100644
--- a/tests/ui/floating_point_abs.fixed
+++ b/tests/ui/floating_point_abs.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![feature(const_fn_floating_point_arithmetic)]
 #![warn(clippy::suboptimal_flops)]
 
diff --git a/tests/ui/floating_point_abs.rs b/tests/ui/floating_point_abs.rs
index e4b60657497..6c732d398f0 100644
--- a/tests/ui/floating_point_abs.rs
+++ b/tests/ui/floating_point_abs.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![feature(const_fn_floating_point_arithmetic)]
 #![warn(clippy::suboptimal_flops)]
 
diff --git a/tests/ui/floating_point_exp.fixed b/tests/ui/floating_point_exp.fixed
index b9e3d89c2b2..1a33b8153ec 100644
--- a/tests/ui/floating_point_exp.fixed
+++ b/tests/ui/floating_point_exp.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::imprecise_flops)]
 #![allow(clippy::unnecessary_cast)]
 
diff --git a/tests/ui/floating_point_exp.rs b/tests/ui/floating_point_exp.rs
index ef008dd9be0..4f4a5ec81ac 100644
--- a/tests/ui/floating_point_exp.rs
+++ b/tests/ui/floating_point_exp.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::imprecise_flops)]
 #![allow(clippy::unnecessary_cast)]
 
diff --git a/tests/ui/floating_point_hypot.fixed b/tests/ui/floating_point_hypot.fixed
index bbe411b3f48..431cb270978 100644
--- a/tests/ui/floating_point_hypot.fixed
+++ b/tests/ui/floating_point_hypot.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::imprecise_flops)]
 
 fn main() {
diff --git a/tests/ui/floating_point_hypot.rs b/tests/ui/floating_point_hypot.rs
index 586fd170ea1..e5506ed391c 100644
--- a/tests/ui/floating_point_hypot.rs
+++ b/tests/ui/floating_point_hypot.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::imprecise_flops)]
 
 fn main() {
diff --git a/tests/ui/floating_point_log.fixed b/tests/ui/floating_point_log.fixed
index ee540646160..6582c0a0f6c 100644
--- a/tests/ui/floating_point_log.fixed
+++ b/tests/ui/floating_point_log.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![allow(dead_code, clippy::double_parens, clippy::unnecessary_cast)]
 #![warn(clippy::suboptimal_flops, clippy::imprecise_flops)]
 
diff --git a/tests/ui/floating_point_log.rs b/tests/ui/floating_point_log.rs
index 0590670a50b..854d269fff5 100644
--- a/tests/ui/floating_point_log.rs
+++ b/tests/ui/floating_point_log.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![allow(dead_code, clippy::double_parens, clippy::unnecessary_cast)]
 #![warn(clippy::suboptimal_flops, clippy::imprecise_flops)]
 
diff --git a/tests/ui/floating_point_logbase.fixed b/tests/ui/floating_point_logbase.fixed
index 7347bf72cbe..0783ecee1ee 100644
--- a/tests/ui/floating_point_logbase.fixed
+++ b/tests/ui/floating_point_logbase.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::suboptimal_flops)]
 #![allow(clippy::unnecessary_cast)]
 
diff --git a/tests/ui/floating_point_logbase.rs b/tests/ui/floating_point_logbase.rs
index ba5b8d40692..80fcfab6825 100644
--- a/tests/ui/floating_point_logbase.rs
+++ b/tests/ui/floating_point_logbase.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::suboptimal_flops)]
 #![allow(clippy::unnecessary_cast)]
 
diff --git a/tests/ui/floating_point_mul_add.fixed b/tests/ui/floating_point_mul_add.fixed
index d3e536ba350..8848981a11d 100644
--- a/tests/ui/floating_point_mul_add.fixed
+++ b/tests/ui/floating_point_mul_add.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![feature(const_fn_floating_point_arithmetic)]
 #![warn(clippy::suboptimal_flops)]
 
diff --git a/tests/ui/floating_point_mul_add.rs b/tests/ui/floating_point_mul_add.rs
index 5d4a9e35cfc..b0edf5cb210 100644
--- a/tests/ui/floating_point_mul_add.rs
+++ b/tests/ui/floating_point_mul_add.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![feature(const_fn_floating_point_arithmetic)]
 #![warn(clippy::suboptimal_flops)]
 
diff --git a/tests/ui/floating_point_powf.fixed b/tests/ui/floating_point_powf.fixed
index f7f93de2957..1e660b140c5 100644
--- a/tests/ui/floating_point_powf.fixed
+++ b/tests/ui/floating_point_powf.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::suboptimal_flops, clippy::imprecise_flops)]
 #![allow(clippy::unnecessary_cast)]
 
diff --git a/tests/ui/floating_point_powf.rs b/tests/ui/floating_point_powf.rs
index 499fc0e15e4..71c2f529205 100644
--- a/tests/ui/floating_point_powf.rs
+++ b/tests/ui/floating_point_powf.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::suboptimal_flops, clippy::imprecise_flops)]
 #![allow(clippy::unnecessary_cast)]
 
diff --git a/tests/ui/floating_point_powi.fixed b/tests/ui/floating_point_powi.fixed
index 8ffd4cc5137..41d5288d6e0 100644
--- a/tests/ui/floating_point_powi.fixed
+++ b/tests/ui/floating_point_powi.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::suboptimal_flops)]
 #![allow(clippy::unnecessary_cast)]
 
diff --git a/tests/ui/floating_point_powi.rs b/tests/ui/floating_point_powi.rs
index 9ae3455a134..7951aab31be 100644
--- a/tests/ui/floating_point_powi.rs
+++ b/tests/ui/floating_point_powi.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::suboptimal_flops)]
 #![allow(clippy::unnecessary_cast)]
 
diff --git a/tests/ui/floating_point_rad.fixed b/tests/ui/floating_point_rad.fixed
index 27674b8a455..af236452712 100644
--- a/tests/ui/floating_point_rad.fixed
+++ b/tests/ui/floating_point_rad.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![feature(const_fn_floating_point_arithmetic)]
 #![warn(clippy::suboptimal_flops)]
 
diff --git a/tests/ui/floating_point_rad.rs b/tests/ui/floating_point_rad.rs
index f1ea73df398..d7612c56a3e 100644
--- a/tests/ui/floating_point_rad.rs
+++ b/tests/ui/floating_point_rad.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![feature(const_fn_floating_point_arithmetic)]
 #![warn(clippy::suboptimal_flops)]
 
diff --git a/tests/ui/fn_to_numeric_cast.rs b/tests/ui/fn_to_numeric_cast.rs
index a456c085c87..4f6af870889 100644
--- a/tests/ui/fn_to_numeric_cast.rs
+++ b/tests/ui/fn_to_numeric_cast.rs
@@ -1,4 +1,4 @@
-// ignore-32bit
+//@ignore-32bit
 
 #![warn(clippy::fn_to_numeric_cast, clippy::fn_to_numeric_cast_with_truncation)]
 
diff --git a/tests/ui/fn_to_numeric_cast_32bit.rs b/tests/ui/fn_to_numeric_cast_32bit.rs
index 04ee985c086..62ce97f098d 100644
--- a/tests/ui/fn_to_numeric_cast_32bit.rs
+++ b/tests/ui/fn_to_numeric_cast_32bit.rs
@@ -1,4 +1,4 @@
-// ignore-64bit
+//@ignore-64bit
 
 #![warn(clippy::fn_to_numeric_cast, clippy::fn_to_numeric_cast_with_truncation)]
 
diff --git a/tests/ui/fn_to_numeric_cast_32bit.stderr b/tests/ui/fn_to_numeric_cast_32bit.stderr
index 08dd611d675..671347d2bcd 100644
--- a/tests/ui/fn_to_numeric_cast_32bit.stderr
+++ b/tests/ui/fn_to_numeric_cast_32bit.stderr
@@ -12,19 +12,19 @@ error: casting function pointer `foo` to `i16`, which truncates the value
 LL |     let _ = foo as i16;
    |             ^^^^^^^^^^ help: try: `foo as usize`
 
-error: casting function pointer `foo` to `i32`
+error: casting function pointer `foo` to `i32`, which truncates the value
   --> $DIR/fn_to_numeric_cast_32bit.rs:12:13
    |
 LL |     let _ = foo as i32;
    |             ^^^^^^^^^^ help: try: `foo as usize`
-   |
-   = note: `-D clippy::fn-to-numeric-cast` implied by `-D warnings`
 
 error: casting function pointer `foo` to `i64`
   --> $DIR/fn_to_numeric_cast_32bit.rs:13:13
    |
 LL |     let _ = foo as i64;
    |             ^^^^^^^^^^ help: try: `foo as usize`
+   |
+   = note: `-D clippy::fn-to-numeric-cast` implied by `-D warnings`
 
 error: casting function pointer `foo` to `i128`
   --> $DIR/fn_to_numeric_cast_32bit.rs:14:13
@@ -50,7 +50,7 @@ error: casting function pointer `foo` to `u16`, which truncates the value
 LL |     let _ = foo as u16;
    |             ^^^^^^^^^^ help: try: `foo as usize`
 
-error: casting function pointer `foo` to `u32`
+error: casting function pointer `foo` to `u32`, which truncates the value
   --> $DIR/fn_to_numeric_cast_32bit.rs:19:13
    |
 LL |     let _ = foo as u32;
@@ -80,7 +80,7 @@ error: casting function pointer `abc` to `i16`, which truncates the value
 LL |     let _ = abc as i16;
    |             ^^^^^^^^^^ help: try: `abc as usize`
 
-error: casting function pointer `abc` to `i32`
+error: casting function pointer `abc` to `i32`, which truncates the value
   --> $DIR/fn_to_numeric_cast_32bit.rs:36:13
    |
 LL |     let _ = abc as i32;
@@ -116,7 +116,7 @@ error: casting function pointer `abc` to `u16`, which truncates the value
 LL |     let _ = abc as u16;
    |             ^^^^^^^^^^ help: try: `abc as usize`
 
-error: casting function pointer `abc` to `u32`
+error: casting function pointer `abc` to `u32`, which truncates the value
   --> $DIR/fn_to_numeric_cast_32bit.rs:43:13
    |
 LL |     let _ = abc as u32;
@@ -134,7 +134,7 @@ error: casting function pointer `abc` to `u128`
 LL |     let _ = abc as u128;
    |             ^^^^^^^^^^^ help: try: `abc as usize`
 
-error: casting function pointer `f` to `i32`
+error: casting function pointer `f` to `i32`, which truncates the value
   --> $DIR/fn_to_numeric_cast_32bit.rs:52:5
    |
 LL |     f as i32
diff --git a/tests/ui/for_loop_fixable.fixed b/tests/ui/for_loop_fixable.fixed
index e9dd38fe40e..f578c98da15 100644
--- a/tests/ui/for_loop_fixable.fixed
+++ b/tests/ui/for_loop_fixable.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![allow(dead_code, unused)]
 #![allow(clippy::uninlined_format_args)]
 
diff --git a/tests/ui/for_loop_fixable.rs b/tests/ui/for_loop_fixable.rs
index 534fb4dd4ef..42bc6de0c7d 100644
--- a/tests/ui/for_loop_fixable.rs
+++ b/tests/ui/for_loop_fixable.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![allow(dead_code, unused)]
 #![allow(clippy::uninlined_format_args)]
 
diff --git a/tests/ui/format.fixed b/tests/ui/format.fixed
index beedf2c1db2..9288956f513 100644
--- a/tests/ui/format.fixed
+++ b/tests/ui/format.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::useless_format)]
 #![allow(
     unused_tuple_struct_fields,
diff --git a/tests/ui/format.rs b/tests/ui/format.rs
index e805f181889..b2b817e0f4c 100644
--- a/tests/ui/format.rs
+++ b/tests/ui/format.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::useless_format)]
 #![allow(
     unused_tuple_struct_fields,
diff --git a/tests/ui/format_args.fixed b/tests/ui/format_args.fixed
index 825e122be5a..ea383686135 100644
--- a/tests/ui/format_args.fixed
+++ b/tests/ui/format_args.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::to_string_in_format_args)]
 #![allow(unused)]
 #![allow(
diff --git a/tests/ui/format_args.rs b/tests/ui/format_args.rs
index a41e53389e5..bfb32449246 100644
--- a/tests/ui/format_args.rs
+++ b/tests/ui/format_args.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::to_string_in_format_args)]
 #![allow(unused)]
 #![allow(
diff --git a/tests/ui/from_iter_instead_of_collect.fixed b/tests/ui/from_iter_instead_of_collect.fixed
index 48f8093311c..915ff4fb079 100644
--- a/tests/ui/from_iter_instead_of_collect.fixed
+++ b/tests/ui/from_iter_instead_of_collect.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::from_iter_instead_of_collect)]
 #![allow(unused_imports, unused_tuple_struct_fields)]
diff --git a/tests/ui/from_iter_instead_of_collect.rs b/tests/ui/from_iter_instead_of_collect.rs
index ebe0ad278be..e926f8c529d 100644
--- a/tests/ui/from_iter_instead_of_collect.rs
+++ b/tests/ui/from_iter_instead_of_collect.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::from_iter_instead_of_collect)]
 #![allow(unused_imports, unused_tuple_struct_fields)]
diff --git a/tests/ui/from_over_into.fixed b/tests/ui/from_over_into.fixed
index 72d635c2ccd..fc6d937060d 100644
--- a/tests/ui/from_over_into.fixed
+++ b/tests/ui/from_over_into.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![feature(type_alias_impl_trait)]
 #![warn(clippy::from_over_into)]
diff --git a/tests/ui/from_over_into.rs b/tests/ui/from_over_into.rs
index 965f4d5d785..fe1ebee35f1 100644
--- a/tests/ui/from_over_into.rs
+++ b/tests/ui/from_over_into.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![feature(type_alias_impl_trait)]
 #![warn(clippy::from_over_into)]
diff --git a/tests/ui/get_first.fixed b/tests/ui/get_first.fixed
index def58afa4fb..ef132b79611 100644
--- a/tests/ui/get_first.fixed
+++ b/tests/ui/get_first.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::get_first)]
 use std::collections::BTreeMap;
 use std::collections::HashMap;
diff --git a/tests/ui/get_first.rs b/tests/ui/get_first.rs
index 85a381854cd..4d872235614 100644
--- a/tests/ui/get_first.rs
+++ b/tests/ui/get_first.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::get_first)]
 use std::collections::BTreeMap;
 use std::collections::HashMap;
diff --git a/tests/ui/get_last_with_len.fixed b/tests/ui/get_last_with_len.fixed
index 1e90b37687a..a58dfda7988 100644
--- a/tests/ui/get_last_with_len.fixed
+++ b/tests/ui/get_last_with_len.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::get_last_with_len)]
 #![allow(unused)]
diff --git a/tests/ui/get_last_with_len.rs b/tests/ui/get_last_with_len.rs
index d63a731bd52..d626656c78f 100644
--- a/tests/ui/get_last_with_len.rs
+++ b/tests/ui/get_last_with_len.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::get_last_with_len)]
 #![allow(unused)]
diff --git a/tests/ui/get_unwrap.fixed b/tests/ui/get_unwrap.fixed
index 5827fc7d76e..4950c47ddeb 100644
--- a/tests/ui/get_unwrap.fixed
+++ b/tests/ui/get_unwrap.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(unused_mut, clippy::from_iter_instead_of_collect, clippy::get_first)]
 #![warn(clippy::unwrap_used)]
diff --git a/tests/ui/get_unwrap.rs b/tests/ui/get_unwrap.rs
index a2a323c14fb..6b1e8edb7bd 100644
--- a/tests/ui/get_unwrap.rs
+++ b/tests/ui/get_unwrap.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(unused_mut, clippy::from_iter_instead_of_collect, clippy::get_first)]
 #![warn(clippy::unwrap_used)]
diff --git a/tests/ui/identity_op.fixed b/tests/ui/identity_op.fixed
index cac69ef42c4..beb16000eca 100644
--- a/tests/ui/identity_op.fixed
+++ b/tests/ui/identity_op.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::identity_op)]
 #![allow(unused)]
 #![allow(
diff --git a/tests/ui/identity_op.rs b/tests/ui/identity_op.rs
index 33201aad4f6..072e00c00f0 100644
--- a/tests/ui/identity_op.rs
+++ b/tests/ui/identity_op.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::identity_op)]
 #![allow(unused)]
 #![allow(
diff --git a/tests/ui/implicit_clone.fixed b/tests/ui/implicit_clone.fixed
index 8ccc3da7b47..e62db8b40be 100644
--- a/tests/ui/implicit_clone.fixed
+++ b/tests/ui/implicit_clone.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::implicit_clone)]
 #![allow(clippy::clone_on_copy, clippy::redundant_clone)]
 use std::borrow::Borrow;
diff --git a/tests/ui/implicit_clone.rs b/tests/ui/implicit_clone.rs
index 59333312607..88352b06af3 100644
--- a/tests/ui/implicit_clone.rs
+++ b/tests/ui/implicit_clone.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::implicit_clone)]
 #![allow(clippy::clone_on_copy, clippy::redundant_clone)]
 use std::borrow::Borrow;
diff --git a/tests/ui/implicit_hasher.rs b/tests/ui/implicit_hasher.rs
index 35d08a07bc3..ca7c1221372 100644
--- a/tests/ui/implicit_hasher.rs
+++ b/tests/ui/implicit_hasher.rs
@@ -1,4 +1,4 @@
-// aux-build:proc_macros.rs
+//@aux-build:proc_macros.rs
 
 #![deny(clippy::implicit_hasher)]
 #![allow(unused)]
diff --git a/tests/ui/implicit_return.fixed b/tests/ui/implicit_return.fixed
index 5e55b8b6739..64813eafda6 100644
--- a/tests/ui/implicit_return.fixed
+++ b/tests/ui/implicit_return.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![feature(lint_reasons)]
 #![warn(clippy::implicit_return)]
 #![allow(clippy::needless_return, clippy::needless_bool, unused, clippy::never_loop)]
diff --git a/tests/ui/implicit_return.rs b/tests/ui/implicit_return.rs
index 76f0a980352..39d47b110db 100644
--- a/tests/ui/implicit_return.rs
+++ b/tests/ui/implicit_return.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![feature(lint_reasons)]
 #![warn(clippy::implicit_return)]
 #![allow(clippy::needless_return, clippy::needless_bool, unused, clippy::never_loop)]
diff --git a/tests/ui/implicit_saturating_add.fixed b/tests/ui/implicit_saturating_add.fixed
index 7d363d59a6f..7fc510d6b41 100644
--- a/tests/ui/implicit_saturating_add.fixed
+++ b/tests/ui/implicit_saturating_add.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(unused)]
 #![warn(clippy::implicit_saturating_add)]
diff --git a/tests/ui/implicit_saturating_add.rs b/tests/ui/implicit_saturating_add.rs
index 31a5916277f..3dcd91f42fe 100644
--- a/tests/ui/implicit_saturating_add.rs
+++ b/tests/ui/implicit_saturating_add.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(unused)]
 #![warn(clippy::implicit_saturating_add)]
diff --git a/tests/ui/implicit_saturating_sub.fixed b/tests/ui/implicit_saturating_sub.fixed
index 93df81b1a7f..1a11db0982f 100644
--- a/tests/ui/implicit_saturating_sub.fixed
+++ b/tests/ui/implicit_saturating_sub.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![allow(unused_assignments, unused_mut, clippy::assign_op_pattern)]
 #![warn(clippy::implicit_saturating_sub)]
 
diff --git a/tests/ui/implicit_saturating_sub.rs b/tests/ui/implicit_saturating_sub.rs
index 8340bc8264d..9369df67430 100644
--- a/tests/ui/implicit_saturating_sub.rs
+++ b/tests/ui/implicit_saturating_sub.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![allow(unused_assignments, unused_mut, clippy::assign_op_pattern)]
 #![warn(clippy::implicit_saturating_sub)]
 
diff --git a/tests/ui/inconsistent_digit_grouping.fixed b/tests/ui/inconsistent_digit_grouping.fixed
index dd683e7f746..06919809ee9 100644
--- a/tests/ui/inconsistent_digit_grouping.fixed
+++ b/tests/ui/inconsistent_digit_grouping.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #[warn(clippy::inconsistent_digit_grouping)]
 #[deny(clippy::unreadable_literal)]
 #[allow(unused_variables, clippy::excessive_precision)]
diff --git a/tests/ui/inconsistent_digit_grouping.rs b/tests/ui/inconsistent_digit_grouping.rs
index d5d27c853c2..04d9125f2bf 100644
--- a/tests/ui/inconsistent_digit_grouping.rs
+++ b/tests/ui/inconsistent_digit_grouping.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #[warn(clippy::inconsistent_digit_grouping)]
 #[deny(clippy::unreadable_literal)]
 #[allow(unused_variables, clippy::excessive_precision)]
diff --git a/tests/ui/inconsistent_struct_constructor.fixed b/tests/ui/inconsistent_struct_constructor.fixed
index 5aaa00f8517..620d45e6828 100644
--- a/tests/ui/inconsistent_struct_constructor.fixed
+++ b/tests/ui/inconsistent_struct_constructor.fixed
@@ -1,5 +1,5 @@
-// run-rustfix
-// aux-build:proc_macros.rs
+//@run-rustfix
+//@aux-build:proc_macros.rs
 
 #![warn(clippy::inconsistent_struct_constructor)]
 #![allow(clippy::redundant_field_names)]
diff --git a/tests/ui/inconsistent_struct_constructor.rs b/tests/ui/inconsistent_struct_constructor.rs
index 2b2dd7f59a4..10ffadcb2ba 100644
--- a/tests/ui/inconsistent_struct_constructor.rs
+++ b/tests/ui/inconsistent_struct_constructor.rs
@@ -1,5 +1,5 @@
-// run-rustfix
-// aux-build:proc_macros.rs
+//@run-rustfix
+//@aux-build:proc_macros.rs
 
 #![warn(clippy::inconsistent_struct_constructor)]
 #![allow(clippy::redundant_field_names)]
diff --git a/tests/ui/inefficient_to_string.fixed b/tests/ui/inefficient_to_string.fixed
index c972b9419ef..557f7fb7358 100644
--- a/tests/ui/inefficient_to_string.fixed
+++ b/tests/ui/inefficient_to_string.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![deny(clippy::inefficient_to_string)]
 
 use std::borrow::Cow;
diff --git a/tests/ui/inefficient_to_string.rs b/tests/ui/inefficient_to_string.rs
index acdc55aa0d6..6503001e345 100644
--- a/tests/ui/inefficient_to_string.rs
+++ b/tests/ui/inefficient_to_string.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![deny(clippy::inefficient_to_string)]
 
 use std::borrow::Cow;
diff --git a/tests/ui/infallible_destructuring_match.fixed b/tests/ui/infallible_destructuring_match.fixed
index 61985e56b76..e396ae94aaa 100644
--- a/tests/ui/infallible_destructuring_match.fixed
+++ b/tests/ui/infallible_destructuring_match.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![feature(exhaustive_patterns, never_type)]
 #![allow(dead_code, unreachable_code, unused_variables)]
 #![allow(clippy::let_and_return)]
diff --git a/tests/ui/infallible_destructuring_match.rs b/tests/ui/infallible_destructuring_match.rs
index f2768245bbc..3fce7bbb6c7 100644
--- a/tests/ui/infallible_destructuring_match.rs
+++ b/tests/ui/infallible_destructuring_match.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![feature(exhaustive_patterns, never_type)]
 #![allow(dead_code, unreachable_code, unused_variables)]
 #![allow(clippy::let_and_return)]
diff --git a/tests/ui/inline_fn_without_body.fixed b/tests/ui/inline_fn_without_body.fixed
index fe21a71a42c..9c5819558fe 100644
--- a/tests/ui/inline_fn_without_body.fixed
+++ b/tests/ui/inline_fn_without_body.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::inline_fn_without_body)]
 #![allow(clippy::inline_always)]
diff --git a/tests/ui/inline_fn_without_body.rs b/tests/ui/inline_fn_without_body.rs
index 50746989466..43ffaf8122b 100644
--- a/tests/ui/inline_fn_without_body.rs
+++ b/tests/ui/inline_fn_without_body.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::inline_fn_without_body)]
 #![allow(clippy::inline_always)]
diff --git a/tests/ui/int_plus_one.fixed b/tests/ui/int_plus_one.fixed
index 642830f24f5..5a36ec462d4 100644
--- a/tests/ui/int_plus_one.fixed
+++ b/tests/ui/int_plus_one.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #[allow(clippy::no_effect, clippy::unnecessary_operation)]
 #[warn(clippy::int_plus_one)]
diff --git a/tests/ui/int_plus_one.rs b/tests/ui/int_plus_one.rs
index 0755a0c79d2..bffa4afd6b0 100644
--- a/tests/ui/int_plus_one.rs
+++ b/tests/ui/int_plus_one.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #[allow(clippy::no_effect, clippy::unnecessary_operation)]
 #[warn(clippy::int_plus_one)]
diff --git a/tests/ui/integer_arithmetic.rs b/tests/ui/integer_arithmetic.rs
index d253d103127..ab9b6094c2c 100644
--- a/tests/ui/integer_arithmetic.rs
+++ b/tests/ui/integer_arithmetic.rs
@@ -1,4 +1,4 @@
-// aux-build:proc_macro_derive.rs
+//@aux-build:proc_macro_derive.rs
 
 #![warn(clippy::integer_arithmetic, clippy::float_arithmetic)]
 #![allow(clippy::no_effect, clippy::unnecessary_operation, clippy::op_ref)]
diff --git a/tests/ui/into_iter_on_ref.fixed b/tests/ui/into_iter_on_ref.fixed
index b77f17944d8..9f550acb157 100644
--- a/tests/ui/into_iter_on_ref.fixed
+++ b/tests/ui/into_iter_on_ref.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![allow(clippy::useless_vec, clippy::needless_borrow)]
 #![warn(clippy::into_iter_on_ref)]
 
diff --git a/tests/ui/into_iter_on_ref.rs b/tests/ui/into_iter_on_ref.rs
index 3854bb05af8..3381ae04dce 100644
--- a/tests/ui/into_iter_on_ref.rs
+++ b/tests/ui/into_iter_on_ref.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![allow(clippy::useless_vec, clippy::needless_borrow)]
 #![warn(clippy::into_iter_on_ref)]
 
diff --git a/tests/ui/invalid_null_ptr_usage.fixed b/tests/ui/invalid_null_ptr_usage.fixed
index 4f5322ebf20..9264fb7e9e7 100644
--- a/tests/ui/invalid_null_ptr_usage.fixed
+++ b/tests/ui/invalid_null_ptr_usage.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 fn main() {
     unsafe {
diff --git a/tests/ui/invalid_null_ptr_usage.rs b/tests/ui/invalid_null_ptr_usage.rs
index ae51c52d8af..80c942d7757 100644
--- a/tests/ui/invalid_null_ptr_usage.rs
+++ b/tests/ui/invalid_null_ptr_usage.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 fn main() {
     unsafe {
diff --git a/tests/ui/is_digit_ascii_radix.fixed b/tests/ui/is_digit_ascii_radix.fixed
index c0ba647d707..bc43303a680 100644
--- a/tests/ui/is_digit_ascii_radix.fixed
+++ b/tests/ui/is_digit_ascii_radix.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::is_digit_ascii_radix)]
 
diff --git a/tests/ui/is_digit_ascii_radix.rs b/tests/ui/is_digit_ascii_radix.rs
index 68e3f3243d9..93cba5c8e4e 100644
--- a/tests/ui/is_digit_ascii_radix.rs
+++ b/tests/ui/is_digit_ascii_radix.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::is_digit_ascii_radix)]
 
diff --git a/tests/ui/issue_2356.fixed b/tests/ui/issue_2356.fixed
index a73ee0fb2e5..a69f5ebdc08 100644
--- a/tests/ui/issue_2356.fixed
+++ b/tests/ui/issue_2356.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![deny(clippy::while_let_on_iterator)]
 #![allow(unused_mut)]
 #![allow(clippy::uninlined_format_args)]
diff --git a/tests/ui/issue_2356.rs b/tests/ui/issue_2356.rs
index 9dd9069609b..50e1bce1f8c 100644
--- a/tests/ui/issue_2356.rs
+++ b/tests/ui/issue_2356.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![deny(clippy::while_let_on_iterator)]
 #![allow(unused_mut)]
 #![allow(clippy::uninlined_format_args)]
diff --git a/tests/ui/iter_cloned_collect.fixed b/tests/ui/iter_cloned_collect.fixed
index 9b862133580..88f08bb991b 100644
--- a/tests/ui/iter_cloned_collect.fixed
+++ b/tests/ui/iter_cloned_collect.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(unused)]
 
diff --git a/tests/ui/iter_cloned_collect.rs b/tests/ui/iter_cloned_collect.rs
index 639f50665f2..d3438b7f51a 100644
--- a/tests/ui/iter_cloned_collect.rs
+++ b/tests/ui/iter_cloned_collect.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(unused)]
 
diff --git a/tests/ui/iter_count.fixed b/tests/ui/iter_count.fixed
index 90a6eef7526..4367a12f820 100644
--- a/tests/ui/iter_count.fixed
+++ b/tests/ui/iter_count.fixed
@@ -1,5 +1,5 @@
-// run-rustfix
-// aux-build:option_helpers.rs
+//@run-rustfix
+//@aux-build:option_helpers.rs
 
 #![warn(clippy::iter_count)]
 #![allow(
diff --git a/tests/ui/iter_count.rs b/tests/ui/iter_count.rs
index 6681a480a28..8c7543cf03b 100644
--- a/tests/ui/iter_count.rs
+++ b/tests/ui/iter_count.rs
@@ -1,5 +1,5 @@
-// run-rustfix
-// aux-build:option_helpers.rs
+//@run-rustfix
+//@aux-build:option_helpers.rs
 
 #![warn(clippy::iter_count)]
 #![allow(
diff --git a/tests/ui/iter_kv_map.fixed b/tests/ui/iter_kv_map.fixed
index f2a4c284cb1..64201b553fd 100644
--- a/tests/ui/iter_kv_map.fixed
+++ b/tests/ui/iter_kv_map.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::iter_kv_map)]
 #![allow(unused_mut, clippy::redundant_clone, clippy::suspicious_map, clippy::map_identity)]
diff --git a/tests/ui/iter_kv_map.rs b/tests/ui/iter_kv_map.rs
index ad6564df408..ec0231ba572 100644
--- a/tests/ui/iter_kv_map.rs
+++ b/tests/ui/iter_kv_map.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::iter_kv_map)]
 #![allow(unused_mut, clippy::redundant_clone, clippy::suspicious_map, clippy::map_identity)]
diff --git a/tests/ui/iter_next_slice.fixed b/tests/ui/iter_next_slice.fixed
index f612d26aaab..d862abc34e0 100644
--- a/tests/ui/iter_next_slice.fixed
+++ b/tests/ui/iter_next_slice.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::iter_next_slice)]
 
 fn main() {
diff --git a/tests/ui/iter_next_slice.rs b/tests/ui/iter_next_slice.rs
index 5195f1c8667..da6fc46e428 100644
--- a/tests/ui/iter_next_slice.rs
+++ b/tests/ui/iter_next_slice.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::iter_next_slice)]
 
 fn main() {
diff --git a/tests/ui/iter_nth.rs b/tests/ui/iter_nth.rs
index 9c21dd82ee4..e7fb97d4fbc 100644
--- a/tests/ui/iter_nth.rs
+++ b/tests/ui/iter_nth.rs
@@ -1,4 +1,4 @@
-// aux-build:option_helpers.rs
+//@aux-build:option_helpers.rs
 
 #![warn(clippy::iter_nth)]
 
diff --git a/tests/ui/iter_nth_zero.fixed b/tests/ui/iter_nth_zero.fixed
index f23671c26e4..587b0d1d366 100644
--- a/tests/ui/iter_nth_zero.fixed
+++ b/tests/ui/iter_nth_zero.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::iter_nth_zero)]
 use std::collections::HashSet;
diff --git a/tests/ui/iter_nth_zero.rs b/tests/ui/iter_nth_zero.rs
index 7c968d49845..93b576ec56f 100644
--- a/tests/ui/iter_nth_zero.rs
+++ b/tests/ui/iter_nth_zero.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::iter_nth_zero)]
 use std::collections::HashSet;
diff --git a/tests/ui/iter_on_empty_collections.fixed b/tests/ui/iter_on_empty_collections.fixed
index bd9b07aefbf..4616f0cdc45 100644
--- a/tests/ui/iter_on_empty_collections.fixed
+++ b/tests/ui/iter_on_empty_collections.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::iter_on_empty_collections)]
 #![allow(clippy::iter_next_slice, clippy::redundant_clone)]
 
diff --git a/tests/ui/iter_on_empty_collections.rs b/tests/ui/iter_on_empty_collections.rs
index e15ba94bd46..81cc7265e11 100644
--- a/tests/ui/iter_on_empty_collections.rs
+++ b/tests/ui/iter_on_empty_collections.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::iter_on_empty_collections)]
 #![allow(clippy::iter_next_slice, clippy::redundant_clone)]
 
diff --git a/tests/ui/iter_on_single_items.fixed b/tests/ui/iter_on_single_items.fixed
index 1fa4b03641b..80dbe454b47 100644
--- a/tests/ui/iter_on_single_items.fixed
+++ b/tests/ui/iter_on_single_items.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::iter_on_single_items)]
 #![allow(clippy::iter_next_slice, clippy::redundant_clone)]
 
diff --git a/tests/ui/iter_on_single_items.rs b/tests/ui/iter_on_single_items.rs
index ea96d8066c5..71c8c7a3f94 100644
--- a/tests/ui/iter_on_single_items.rs
+++ b/tests/ui/iter_on_single_items.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::iter_on_single_items)]
 #![allow(clippy::iter_next_slice, clippy::redundant_clone)]
 
diff --git a/tests/ui/iter_overeager_cloned.fixed b/tests/ui/iter_overeager_cloned.fixed
index c100705d017..bf576e9cbfb 100644
--- a/tests/ui/iter_overeager_cloned.fixed
+++ b/tests/ui/iter_overeager_cloned.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::iter_overeager_cloned, clippy::redundant_clone, clippy::filter_next)]
 #![allow(dead_code, clippy::let_unit_value)]
 
diff --git a/tests/ui/iter_overeager_cloned.rs b/tests/ui/iter_overeager_cloned.rs
index 2caa8802066..df42d88eff0 100644
--- a/tests/ui/iter_overeager_cloned.rs
+++ b/tests/ui/iter_overeager_cloned.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::iter_overeager_cloned, clippy::redundant_clone, clippy::filter_next)]
 #![allow(dead_code, clippy::let_unit_value)]
 
diff --git a/tests/ui/iter_skip_next.fixed b/tests/ui/iter_skip_next.fixed
index d56d623b526..8f2cefc4304 100644
--- a/tests/ui/iter_skip_next.fixed
+++ b/tests/ui/iter_skip_next.fixed
@@ -1,5 +1,5 @@
-// run-rustfix
-// aux-build:option_helpers.rs
+//@run-rustfix
+//@aux-build:option_helpers.rs
 
 #![warn(clippy::iter_skip_next)]
 #![allow(clippy::disallowed_names)]
diff --git a/tests/ui/iter_skip_next.rs b/tests/ui/iter_skip_next.rs
index 3ec5d1b8214..71d83384f3a 100644
--- a/tests/ui/iter_skip_next.rs
+++ b/tests/ui/iter_skip_next.rs
@@ -1,5 +1,5 @@
-// run-rustfix
-// aux-build:option_helpers.rs
+//@run-rustfix
+//@aux-build:option_helpers.rs
 
 #![warn(clippy::iter_skip_next)]
 #![allow(clippy::disallowed_names)]
diff --git a/tests/ui/iter_with_drain.fixed b/tests/ui/iter_with_drain.fixed
index 0330d554926..24a95c4d0fe 100644
--- a/tests/ui/iter_with_drain.fixed
+++ b/tests/ui/iter_with_drain.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 // will emits unused mut warnings after fixing
 #![allow(unused_mut)]
 // will emits needless collect warnings after fixing
diff --git a/tests/ui/iter_with_drain.rs b/tests/ui/iter_with_drain.rs
index 993936fb8de..a118c981ee3 100644
--- a/tests/ui/iter_with_drain.rs
+++ b/tests/ui/iter_with_drain.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 // will emits unused mut warnings after fixing
 #![allow(unused_mut)]
 // will emits needless collect warnings after fixing
diff --git a/tests/ui/large_const_arrays.fixed b/tests/ui/large_const_arrays.fixed
index c5af07c8a17..f7ce6fbe6bb 100644
--- a/tests/ui/large_const_arrays.fixed
+++ b/tests/ui/large_const_arrays.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::large_const_arrays)]
 #![allow(dead_code)]
diff --git a/tests/ui/large_const_arrays.rs b/tests/ui/large_const_arrays.rs
index a160b9f8ad5..002ac77ddda 100644
--- a/tests/ui/large_const_arrays.rs
+++ b/tests/ui/large_const_arrays.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::large_const_arrays)]
 #![allow(dead_code)]
diff --git a/tests/ui/large_digit_groups.fixed b/tests/ui/large_digit_groups.fixed
index ea18dac0683..f42fcd96d79 100644
--- a/tests/ui/large_digit_groups.fixed
+++ b/tests/ui/large_digit_groups.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::large_digit_groups)]
 
 fn main() {
diff --git a/tests/ui/large_digit_groups.rs b/tests/ui/large_digit_groups.rs
index ac116d5dbda..3db9da6a3a5 100644
--- a/tests/ui/large_digit_groups.rs
+++ b/tests/ui/large_digit_groups.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::large_digit_groups)]
 
 fn main() {
diff --git a/tests/ui/large_enum_variant.rs b/tests/ui/large_enum_variant.rs
index f09f8ae0ccc..ea8bc5b4aca 100644
--- a/tests/ui/large_enum_variant.rs
+++ b/tests/ui/large_enum_variant.rs
@@ -1,4 +1,4 @@
-// aux-build:proc_macros.rs
+//@aux-build:proc_macros.rs
 
 #![allow(dead_code)]
 #![allow(unused_variables)]
diff --git a/tests/ui/large_types_passed_by_value.rs b/tests/ui/large_types_passed_by_value.rs
index 7601b5c66fa..f9e3c7192ad 100644
--- a/tests/ui/large_types_passed_by_value.rs
+++ b/tests/ui/large_types_passed_by_value.rs
@@ -1,5 +1,5 @@
-// normalize-stderr-test "\(\d+ byte\)" -> "(N byte)"
-// normalize-stderr-test "\(limit: \d+ byte\)" -> "(limit: N byte)"
+//@normalize-stderr-test: "\(\d+ byte\)" -> "(N byte)"
+//@normalize-stderr-test: "\(limit: \d+ byte\)" -> "(limit: N byte)"
 
 #![warn(clippy::large_types_passed_by_value)]
 
diff --git a/tests/ui/len_zero.fixed b/tests/ui/len_zero.fixed
index c1c0b5ae40f..34b2021df45 100644
--- a/tests/ui/len_zero.fixed
+++ b/tests/ui/len_zero.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::len_zero)]
 #![allow(dead_code, unused, clippy::len_without_is_empty)]
diff --git a/tests/ui/len_zero.rs b/tests/ui/len_zero.rs
index cc2eb05b6bf..c83ae2ac553 100644
--- a/tests/ui/len_zero.rs
+++ b/tests/ui/len_zero.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::len_zero)]
 #![allow(dead_code, unused, clippy::len_without_is_empty)]
diff --git a/tests/ui/len_zero_ranges.fixed b/tests/ui/len_zero_ranges.fixed
index 79781766242..4b1241ec86b 100644
--- a/tests/ui/len_zero_ranges.fixed
+++ b/tests/ui/len_zero_ranges.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::len_zero)]
 #![allow(unused)]
diff --git a/tests/ui/len_zero_ranges.rs b/tests/ui/len_zero_ranges.rs
index a0eb51cc976..4b47132c766 100644
--- a/tests/ui/len_zero_ranges.rs
+++ b/tests/ui/len_zero_ranges.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::len_zero)]
 #![allow(unused)]
diff --git a/tests/ui/let_unit.fixed b/tests/ui/let_unit.fixed
index 76ff0645f41..8ba89ec78bb 100644
--- a/tests/ui/let_unit.fixed
+++ b/tests/ui/let_unit.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![feature(lint_reasons)]
 #![warn(clippy::let_unit_value)]
diff --git a/tests/ui/let_unit.rs b/tests/ui/let_unit.rs
index 895ccfe366a..7e8764a482a 100644
--- a/tests/ui/let_unit.rs
+++ b/tests/ui/let_unit.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![feature(lint_reasons)]
 #![warn(clippy::let_unit_value)]
diff --git a/tests/ui/lines_filter_map_ok.fixed b/tests/ui/lines_filter_map_ok.fixed
index f4033cd8ed8..64114f6585d 100644
--- a/tests/ui/lines_filter_map_ok.fixed
+++ b/tests/ui/lines_filter_map_ok.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(unused, clippy::map_identity)]
 #![warn(clippy::lines_filter_map_ok)]
diff --git a/tests/ui/lines_filter_map_ok.rs b/tests/ui/lines_filter_map_ok.rs
index 7e11816b2ac..5aedc686336 100644
--- a/tests/ui/lines_filter_map_ok.rs
+++ b/tests/ui/lines_filter_map_ok.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(unused, clippy::map_identity)]
 #![warn(clippy::lines_filter_map_ok)]
diff --git a/tests/ui/lossy_float_literal.fixed b/tests/ui/lossy_float_literal.fixed
index 24e372354fc..a2088575610 100644
--- a/tests/ui/lossy_float_literal.fixed
+++ b/tests/ui/lossy_float_literal.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::lossy_float_literal)]
 
 fn main() {
diff --git a/tests/ui/lossy_float_literal.rs b/tests/ui/lossy_float_literal.rs
index 3dcf98fa0bd..1a75f214c85 100644
--- a/tests/ui/lossy_float_literal.rs
+++ b/tests/ui/lossy_float_literal.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::lossy_float_literal)]
 
 fn main() {
diff --git a/tests/ui/macro_use_imports.fixed b/tests/ui/macro_use_imports.fixed
index 15f7a099a7d..9208fbcb783 100644
--- a/tests/ui/macro_use_imports.fixed
+++ b/tests/ui/macro_use_imports.fixed
@@ -1,8 +1,8 @@
-// aux-build:macro_rules.rs
-// aux-build:macro_use_helper.rs
-// aux-build:proc_macro_derive.rs
-// run-rustfix
-// ignore-32bit
+//@aux-build:macro_rules.rs
+//@aux-build:macro_use_helper.rs
+//@aux-build:proc_macro_derive.rs
+//@run-rustfix
+//@ignore-32bit
 
 #![feature(lint_reasons)]
 #![allow(unused_imports, unreachable_code, unused_variables, dead_code, unused_attributes)]
diff --git a/tests/ui/macro_use_imports.rs b/tests/ui/macro_use_imports.rs
index b1a28733294..925a2c61f8d 100644
--- a/tests/ui/macro_use_imports.rs
+++ b/tests/ui/macro_use_imports.rs
@@ -1,8 +1,8 @@
-// aux-build:macro_rules.rs
-// aux-build:macro_use_helper.rs
-// aux-build:proc_macro_derive.rs
-// run-rustfix
-// ignore-32bit
+//@aux-build:macro_rules.rs
+//@aux-build:macro_use_helper.rs
+//@aux-build:proc_macro_derive.rs
+//@run-rustfix
+//@ignore-32bit
 
 #![feature(lint_reasons)]
 #![allow(unused_imports, unreachable_code, unused_variables, dead_code, unused_attributes)]
diff --git a/tests/ui/macro_use_imports_expect.rs b/tests/ui/macro_use_imports_expect.rs
index 5aac5af26db..b9677851b92 100644
--- a/tests/ui/macro_use_imports_expect.rs
+++ b/tests/ui/macro_use_imports_expect.rs
@@ -1,7 +1,7 @@
-// aux-build:macro_rules.rs
-// aux-build:macro_use_helper.rs
-// aux-build:proc_macro_derive.rs
-// ignore-32bit
+//@aux-build:macro_rules.rs
+//@aux-build:macro_use_helper.rs
+//@aux-build:proc_macro_derive.rs
+//@ignore-32bit
 
 #![feature(lint_reasons)]
 #![allow(unused_imports, unreachable_code, unused_variables, dead_code, unused_attributes)]
diff --git a/tests/ui/manual_assert.edition2018.fixed b/tests/ui/manual_assert.edition2018.fixed
index 8c7e919bf62..ab9b375dc03 100644
--- a/tests/ui/manual_assert.edition2018.fixed
+++ b/tests/ui/manual_assert.edition2018.fixed
@@ -1,7 +1,7 @@
-// revisions: edition2018 edition2021
-//[edition2018] edition:2018
-//[edition2021] edition:2021
-// run-rustfix
+//@revisions: edition2018 edition2021
+//@[edition2018] edition:2018
+//@[edition2021] edition:2021
+//@run-rustfix
 
 #![warn(clippy::manual_assert)]
 #![allow(dead_code, unused_doc_comments)]
diff --git a/tests/ui/manual_assert.edition2021.fixed b/tests/ui/manual_assert.edition2021.fixed
index 8c7e919bf62..ab9b375dc03 100644
--- a/tests/ui/manual_assert.edition2021.fixed
+++ b/tests/ui/manual_assert.edition2021.fixed
@@ -1,7 +1,7 @@
-// revisions: edition2018 edition2021
-//[edition2018] edition:2018
-//[edition2021] edition:2021
-// run-rustfix
+//@revisions: edition2018 edition2021
+//@[edition2018] edition:2018
+//@[edition2021] edition:2021
+//@run-rustfix
 
 #![warn(clippy::manual_assert)]
 #![allow(dead_code, unused_doc_comments)]
diff --git a/tests/ui/manual_assert.rs b/tests/ui/manual_assert.rs
index f037c5b8405..eac52d1b5de 100644
--- a/tests/ui/manual_assert.rs
+++ b/tests/ui/manual_assert.rs
@@ -1,7 +1,7 @@
-// revisions: edition2018 edition2021
-//[edition2018] edition:2018
-//[edition2021] edition:2021
-// run-rustfix
+//@revisions: edition2018 edition2021
+//@[edition2018] edition:2018
+//@[edition2021] edition:2021
+//@run-rustfix
 
 #![warn(clippy::manual_assert)]
 #![allow(dead_code, unused_doc_comments)]
diff --git a/tests/ui/manual_async_fn.fixed b/tests/ui/manual_async_fn.fixed
index 5cc4a43af7e..e458f0d254f 100644
--- a/tests/ui/manual_async_fn.fixed
+++ b/tests/ui/manual_async_fn.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::manual_async_fn)]
 #![allow(unused)]
 
diff --git a/tests/ui/manual_async_fn.rs b/tests/ui/manual_async_fn.rs
index ba504b8a823..dd5ca1c9b5b 100644
--- a/tests/ui/manual_async_fn.rs
+++ b/tests/ui/manual_async_fn.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::manual_async_fn)]
 #![allow(unused)]
 
diff --git a/tests/ui/manual_bits.fixed b/tests/ui/manual_bits.fixed
index e7f8cd878ca..037de0262e2 100644
--- a/tests/ui/manual_bits.fixed
+++ b/tests/ui/manual_bits.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::manual_bits)]
 #![allow(
diff --git a/tests/ui/manual_bits.rs b/tests/ui/manual_bits.rs
index 7b1d1549528..b15a531ec17 100644
--- a/tests/ui/manual_bits.rs
+++ b/tests/ui/manual_bits.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::manual_bits)]
 #![allow(
diff --git a/tests/ui/manual_filter.fixed b/tests/ui/manual_filter.fixed
index ef6780dc96d..755caa664d5 100644
--- a/tests/ui/manual_filter.fixed
+++ b/tests/ui/manual_filter.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::manual_filter)]
 #![allow(unused_variables, dead_code)]
diff --git a/tests/ui/manual_filter.rs b/tests/ui/manual_filter.rs
index ea0ce83172b..faccfe9db12 100644
--- a/tests/ui/manual_filter.rs
+++ b/tests/ui/manual_filter.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::manual_filter)]
 #![allow(unused_variables, dead_code)]
diff --git a/tests/ui/manual_filter_map.fixed b/tests/ui/manual_filter_map.fixed
index 4936dc9b2e0..831323089e7 100644
--- a/tests/ui/manual_filter_map.fixed
+++ b/tests/ui/manual_filter_map.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![allow(dead_code)]
 #![warn(clippy::manual_filter_map)]
 #![allow(clippy::redundant_closure)] // FIXME suggestion may have redundant closure
diff --git a/tests/ui/manual_filter_map.rs b/tests/ui/manual_filter_map.rs
index 8c67e827b4c..2692303d313 100644
--- a/tests/ui/manual_filter_map.rs
+++ b/tests/ui/manual_filter_map.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![allow(dead_code)]
 #![warn(clippy::manual_filter_map)]
 #![allow(clippy::redundant_closure)] // FIXME suggestion may have redundant closure
diff --git a/tests/ui/manual_find_fixable.fixed b/tests/ui/manual_find_fixable.fixed
index 2bce6e624c9..9c5eb20c81c 100644
--- a/tests/ui/manual_find_fixable.fixed
+++ b/tests/ui/manual_find_fixable.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::manual_find)]
 #![allow(unused)]
 #![allow(clippy::needless_return, clippy::uninlined_format_args)]
diff --git a/tests/ui/manual_find_fixable.rs b/tests/ui/manual_find_fixable.rs
index f5c6de37a25..7b670320ee3 100644
--- a/tests/ui/manual_find_fixable.rs
+++ b/tests/ui/manual_find_fixable.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::manual_find)]
 #![allow(unused)]
 #![allow(clippy::needless_return, clippy::uninlined_format_args)]
diff --git a/tests/ui/manual_find_map.fixed b/tests/ui/manual_find_map.fixed
index 54302beceff..554613a30a9 100644
--- a/tests/ui/manual_find_map.fixed
+++ b/tests/ui/manual_find_map.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![allow(dead_code)]
 #![warn(clippy::manual_find_map)]
 #![allow(clippy::redundant_closure)] // FIXME suggestion may have redundant closure
diff --git a/tests/ui/manual_find_map.rs b/tests/ui/manual_find_map.rs
index afcc1825a9a..d6245758f9d 100644
--- a/tests/ui/manual_find_map.rs
+++ b/tests/ui/manual_find_map.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![allow(dead_code)]
 #![warn(clippy::manual_find_map)]
 #![allow(clippy::redundant_closure)] // FIXME suggestion may have redundant closure
diff --git a/tests/ui/manual_instant_elapsed.fixed b/tests/ui/manual_instant_elapsed.fixed
index 85a91543c89..55073c3b57c 100644
--- a/tests/ui/manual_instant_elapsed.fixed
+++ b/tests/ui/manual_instant_elapsed.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::manual_instant_elapsed)]
 #![allow(clippy::unnecessary_operation)]
 #![allow(clippy::unchecked_duration_subtraction)]
diff --git a/tests/ui/manual_instant_elapsed.rs b/tests/ui/manual_instant_elapsed.rs
index c98cb15b916..c9029a04940 100644
--- a/tests/ui/manual_instant_elapsed.rs
+++ b/tests/ui/manual_instant_elapsed.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::manual_instant_elapsed)]
 #![allow(clippy::unnecessary_operation)]
 #![allow(clippy::unchecked_duration_subtraction)]
diff --git a/tests/ui/manual_is_ascii_check.fixed b/tests/ui/manual_is_ascii_check.fixed
index 5b2b44c2fdb..87e86658668 100644
--- a/tests/ui/manual_is_ascii_check.fixed
+++ b/tests/ui/manual_is_ascii_check.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(unused, dead_code)]
 #![warn(clippy::manual_is_ascii_check)]
diff --git a/tests/ui/manual_is_ascii_check.rs b/tests/ui/manual_is_ascii_check.rs
index c9433f33a1b..931f0f20276 100644
--- a/tests/ui/manual_is_ascii_check.rs
+++ b/tests/ui/manual_is_ascii_check.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(unused, dead_code)]
 #![warn(clippy::manual_is_ascii_check)]
diff --git a/tests/ui/manual_main_separator_str.fixed b/tests/ui/manual_main_separator_str.fixed
index 50f46d6b355..7e7da8f20bb 100644
--- a/tests/ui/manual_main_separator_str.fixed
+++ b/tests/ui/manual_main_separator_str.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(unused)]
 #![warn(clippy::manual_main_separator_str)]
diff --git a/tests/ui/manual_main_separator_str.rs b/tests/ui/manual_main_separator_str.rs
index 2dbb9e66151..cf90e12efc3 100644
--- a/tests/ui/manual_main_separator_str.rs
+++ b/tests/ui/manual_main_separator_str.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(unused)]
 #![warn(clippy::manual_main_separator_str)]
diff --git a/tests/ui/manual_map_option.fixed b/tests/ui/manual_map_option.fixed
index e12ea7ec145..e8ff65cad6a 100644
--- a/tests/ui/manual_map_option.fixed
+++ b/tests/ui/manual_map_option.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::manual_map)]
 #![allow(
diff --git a/tests/ui/manual_map_option.rs b/tests/ui/manual_map_option.rs
index 325a6db06c4..b06a96451ce 100644
--- a/tests/ui/manual_map_option.rs
+++ b/tests/ui/manual_map_option.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::manual_map)]
 #![allow(
diff --git a/tests/ui/manual_map_option_2.fixed b/tests/ui/manual_map_option_2.fixed
index ebf3f8cabd4..dc722878248 100644
--- a/tests/ui/manual_map_option_2.fixed
+++ b/tests/ui/manual_map_option_2.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::manual_map)]
 #![allow(clippy::toplevel_ref_arg)]
diff --git a/tests/ui/manual_map_option_2.rs b/tests/ui/manual_map_option_2.rs
index 1382d9af0aa..c495ab0fa6e 100644
--- a/tests/ui/manual_map_option_2.rs
+++ b/tests/ui/manual_map_option_2.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::manual_map)]
 #![allow(clippy::toplevel_ref_arg)]
diff --git a/tests/ui/manual_ok_or.fixed b/tests/ui/manual_ok_or.fixed
index fc8511626b3..d8901dc3b03 100644
--- a/tests/ui/manual_ok_or.fixed
+++ b/tests/ui/manual_ok_or.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::manual_ok_or)]
 #![allow(clippy::or_fun_call)]
 #![allow(clippy::disallowed_names)]
diff --git a/tests/ui/manual_ok_or.rs b/tests/ui/manual_ok_or.rs
index b5303d33f5f..7188a521357 100644
--- a/tests/ui/manual_ok_or.rs
+++ b/tests/ui/manual_ok_or.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::manual_ok_or)]
 #![allow(clippy::or_fun_call)]
 #![allow(clippy::disallowed_names)]
diff --git a/tests/ui/manual_rem_euclid.fixed b/tests/ui/manual_rem_euclid.fixed
index 1f6df1b0a86..f2e44e56f02 100644
--- a/tests/ui/manual_rem_euclid.fixed
+++ b/tests/ui/manual_rem_euclid.fixed
@@ -1,5 +1,5 @@
-// run-rustfix
-// aux-build:proc_macros.rs
+//@run-rustfix
+//@aux-build:proc_macros.rs
 
 #![warn(clippy::manual_rem_euclid)]
 #![allow(clippy::let_with_type_underscore)]
diff --git a/tests/ui/manual_rem_euclid.rs b/tests/ui/manual_rem_euclid.rs
index b275e8a38d2..b2329c33a47 100644
--- a/tests/ui/manual_rem_euclid.rs
+++ b/tests/ui/manual_rem_euclid.rs
@@ -1,5 +1,5 @@
-// run-rustfix
-// aux-build:proc_macros.rs
+//@run-rustfix
+//@aux-build:proc_macros.rs
 
 #![warn(clippy::manual_rem_euclid)]
 #![allow(clippy::let_with_type_underscore)]
diff --git a/tests/ui/manual_retain.fixed b/tests/ui/manual_retain.fixed
index 8f25fea678f..d3cac666763 100644
--- a/tests/ui/manual_retain.fixed
+++ b/tests/ui/manual_retain.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::manual_retain)]
 #![allow(unused, clippy::redundant_clone)]
 use std::collections::BTreeMap;
diff --git a/tests/ui/manual_retain.rs b/tests/ui/manual_retain.rs
index e6b3995a689..34f0c4d5029 100644
--- a/tests/ui/manual_retain.rs
+++ b/tests/ui/manual_retain.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::manual_retain)]
 #![allow(unused, clippy::redundant_clone)]
 use std::collections::BTreeMap;
diff --git a/tests/ui/manual_saturating_arithmetic.fixed b/tests/ui/manual_saturating_arithmetic.fixed
index c4f53c446c9..7dd4521fa78 100644
--- a/tests/ui/manual_saturating_arithmetic.fixed
+++ b/tests/ui/manual_saturating_arithmetic.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(unused_imports)]
 
diff --git a/tests/ui/manual_saturating_arithmetic.rs b/tests/ui/manual_saturating_arithmetic.rs
index cd83cf6e65e..463ee069289 100644
--- a/tests/ui/manual_saturating_arithmetic.rs
+++ b/tests/ui/manual_saturating_arithmetic.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(unused_imports)]
 
diff --git a/tests/ui/manual_slice_size_calculation.fixed b/tests/ui/manual_slice_size_calculation.fixed
index 71368a25e22..ac85bd8d3ac 100644
--- a/tests/ui/manual_slice_size_calculation.fixed
+++ b/tests/ui/manual_slice_size_calculation.fixed
@@ -1,5 +1,5 @@
-// run-rustfix
-// aux-build:proc_macros.rs
+//@run-rustfix
+//@aux-build:proc_macros.rs
 #![allow(unused)]
 #![warn(clippy::manual_slice_size_calculation)]
 
diff --git a/tests/ui/manual_slice_size_calculation.rs b/tests/ui/manual_slice_size_calculation.rs
index 5dd14aaede0..1f824b12bc2 100644
--- a/tests/ui/manual_slice_size_calculation.rs
+++ b/tests/ui/manual_slice_size_calculation.rs
@@ -1,5 +1,5 @@
-// run-rustfix
-// aux-build:proc_macros.rs
+//@run-rustfix
+//@aux-build:proc_macros.rs
 #![allow(unused)]
 #![warn(clippy::manual_slice_size_calculation)]
 
diff --git a/tests/ui/manual_split_once.fixed b/tests/ui/manual_split_once.fixed
index 50b02019cc2..e317c597109 100644
--- a/tests/ui/manual_split_once.fixed
+++ b/tests/ui/manual_split_once.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::manual_split_once)]
 #![allow(unused, clippy::iter_skip_next, clippy::iter_nth_zero)]
diff --git a/tests/ui/manual_split_once.rs b/tests/ui/manual_split_once.rs
index e1e8b71a9de..7e2dc22bc46 100644
--- a/tests/ui/manual_split_once.rs
+++ b/tests/ui/manual_split_once.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::manual_split_once)]
 #![allow(unused, clippy::iter_skip_next, clippy::iter_nth_zero)]
diff --git a/tests/ui/manual_str_repeat.fixed b/tests/ui/manual_str_repeat.fixed
index 3d56f2a0ded..9468c3df904 100644
--- a/tests/ui/manual_str_repeat.fixed
+++ b/tests/ui/manual_str_repeat.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::manual_str_repeat)]
 
diff --git a/tests/ui/manual_str_repeat.rs b/tests/ui/manual_str_repeat.rs
index e8240a949db..baa0a10260d 100644
--- a/tests/ui/manual_str_repeat.rs
+++ b/tests/ui/manual_str_repeat.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::manual_str_repeat)]
 
diff --git a/tests/ui/manual_string_new.fixed b/tests/ui/manual_string_new.fixed
index a376411bfbc..0d1bab23304 100644
--- a/tests/ui/manual_string_new.fixed
+++ b/tests/ui/manual_string_new.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::manual_string_new)]
 
diff --git a/tests/ui/manual_string_new.rs b/tests/ui/manual_string_new.rs
index 6bfc52fb1bc..2392ebfc322 100644
--- a/tests/ui/manual_string_new.rs
+++ b/tests/ui/manual_string_new.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::manual_string_new)]
 
diff --git a/tests/ui/manual_unwrap_or.fixed b/tests/ui/manual_unwrap_or.fixed
index 7d68978216c..c17634bffe3 100644
--- a/tests/ui/manual_unwrap_or.fixed
+++ b/tests/ui/manual_unwrap_or.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![allow(dead_code)]
 #![allow(unused_variables, clippy::unnecessary_wraps)]
 
diff --git a/tests/ui/manual_unwrap_or.rs b/tests/ui/manual_unwrap_or.rs
index b937fe6f977..6d49a6949fa 100644
--- a/tests/ui/manual_unwrap_or.rs
+++ b/tests/ui/manual_unwrap_or.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![allow(dead_code)]
 #![allow(unused_variables, clippy::unnecessary_wraps)]
 
diff --git a/tests/ui/map_clone.fixed b/tests/ui/map_clone.fixed
index 0860dcf8e0d..d7474f35719 100644
--- a/tests/ui/map_clone.fixed
+++ b/tests/ui/map_clone.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::map_clone)]
 #![allow(
     clippy::clone_on_copy,
diff --git a/tests/ui/map_clone.rs b/tests/ui/map_clone.rs
index b6987336834..74978ae8006 100644
--- a/tests/ui/map_clone.rs
+++ b/tests/ui/map_clone.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::map_clone)]
 #![allow(
     clippy::clone_on_copy,
diff --git a/tests/ui/map_collect_result_unit.fixed b/tests/ui/map_collect_result_unit.fixed
index e66c9cc2420..b00c2cf284e 100644
--- a/tests/ui/map_collect_result_unit.fixed
+++ b/tests/ui/map_collect_result_unit.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::map_collect_result_unit)]
 
 fn main() {
diff --git a/tests/ui/map_collect_result_unit.rs b/tests/ui/map_collect_result_unit.rs
index 6f08f4c3c53..ad2198ec1fe 100644
--- a/tests/ui/map_collect_result_unit.rs
+++ b/tests/ui/map_collect_result_unit.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::map_collect_result_unit)]
 
 fn main() {
diff --git a/tests/ui/map_flatten_fixable.fixed b/tests/ui/map_flatten_fixable.fixed
index 8e2f11389f8..14816de1a63 100644
--- a/tests/ui/map_flatten_fixable.fixed
+++ b/tests/ui/map_flatten_fixable.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::all, clippy::pedantic)]
 #![allow(clippy::let_underscore_untyped)]
diff --git a/tests/ui/map_flatten_fixable.rs b/tests/ui/map_flatten_fixable.rs
index a783a99c4ff..f38a00a59fa 100644
--- a/tests/ui/map_flatten_fixable.rs
+++ b/tests/ui/map_flatten_fixable.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::all, clippy::pedantic)]
 #![allow(clippy::let_underscore_untyped)]
diff --git a/tests/ui/map_identity.fixed b/tests/ui/map_identity.fixed
index 2256e51f2d0..7fb7d8c1218 100644
--- a/tests/ui/map_identity.fixed
+++ b/tests/ui/map_identity.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::map_identity)]
 #![allow(clippy::needless_return)]
 
diff --git a/tests/ui/map_identity.rs b/tests/ui/map_identity.rs
index ccfdc9ea76d..7891c242628 100644
--- a/tests/ui/map_identity.rs
+++ b/tests/ui/map_identity.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::map_identity)]
 #![allow(clippy::needless_return)]
 
diff --git a/tests/ui/map_unwrap_or.rs b/tests/ui/map_unwrap_or.rs
index 32631024ca5..cb25d8567aa 100644
--- a/tests/ui/map_unwrap_or.rs
+++ b/tests/ui/map_unwrap_or.rs
@@ -1,4 +1,4 @@
-// aux-build:option_helpers.rs
+//@aux-build:option_helpers.rs
 
 #![warn(clippy::map_unwrap_or)]
 #![allow(clippy::uninlined_format_args, clippy::unnecessary_lazy_evaluations)]
diff --git a/tests/ui/map_unwrap_or_fixable.fixed b/tests/ui/map_unwrap_or_fixable.fixed
index bd5b4f7165a..ea5b6a6691e 100644
--- a/tests/ui/map_unwrap_or_fixable.fixed
+++ b/tests/ui/map_unwrap_or_fixable.fixed
@@ -1,5 +1,5 @@
-// run-rustfix
-// aux-build:option_helpers.rs
+//@run-rustfix
+//@aux-build:option_helpers.rs
 
 #![warn(clippy::map_unwrap_or)]
 
diff --git a/tests/ui/map_unwrap_or_fixable.rs b/tests/ui/map_unwrap_or_fixable.rs
index 0b892caf20e..f8bb9d8ca6a 100644
--- a/tests/ui/map_unwrap_or_fixable.rs
+++ b/tests/ui/map_unwrap_or_fixable.rs
@@ -1,5 +1,5 @@
-// run-rustfix
-// aux-build:option_helpers.rs
+//@run-rustfix
+//@aux-build:option_helpers.rs
 
 #![warn(clippy::map_unwrap_or)]
 
diff --git a/tests/ui/match_as_ref.fixed b/tests/ui/match_as_ref.fixed
index ddfa1e741ad..8fa3f532587 100644
--- a/tests/ui/match_as_ref.fixed
+++ b/tests/ui/match_as_ref.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(unused)]
 #![warn(clippy::match_as_ref)]
diff --git a/tests/ui/match_as_ref.rs b/tests/ui/match_as_ref.rs
index 025d475ae13..02a17791426 100644
--- a/tests/ui/match_as_ref.rs
+++ b/tests/ui/match_as_ref.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(unused)]
 #![warn(clippy::match_as_ref)]
diff --git a/tests/ui/match_expr_like_matches_macro.fixed b/tests/ui/match_expr_like_matches_macro.fixed
index 55cd15bd5c3..7215660da67 100644
--- a/tests/ui/match_expr_like_matches_macro.fixed
+++ b/tests/ui/match_expr_like_matches_macro.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::match_like_matches_macro)]
 #![allow(
diff --git a/tests/ui/match_expr_like_matches_macro.rs b/tests/ui/match_expr_like_matches_macro.rs
index 5d645e108e5..afdf1069f5e 100644
--- a/tests/ui/match_expr_like_matches_macro.rs
+++ b/tests/ui/match_expr_like_matches_macro.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::match_like_matches_macro)]
 #![allow(
diff --git a/tests/ui/match_ref_pats.fixed b/tests/ui/match_ref_pats.fixed
index cf37fc6dc90..50c3dcc1e0a 100644
--- a/tests/ui/match_ref_pats.fixed
+++ b/tests/ui/match_ref_pats.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::match_ref_pats)]
 #![allow(dead_code, unused_variables)]
 #![allow(clippy::enum_variant_names, clippy::equatable_if_let, clippy::uninlined_format_args)]
diff --git a/tests/ui/match_ref_pats.rs b/tests/ui/match_ref_pats.rs
index 3220b97d1b5..d29ddacc04a 100644
--- a/tests/ui/match_ref_pats.rs
+++ b/tests/ui/match_ref_pats.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::match_ref_pats)]
 #![allow(dead_code, unused_variables)]
 #![allow(clippy::enum_variant_names, clippy::equatable_if_let, clippy::uninlined_format_args)]
diff --git a/tests/ui/match_result_ok.fixed b/tests/ui/match_result_ok.fixed
index 10ae1ee5245..fe67b225fa1 100644
--- a/tests/ui/match_result_ok.fixed
+++ b/tests/ui/match_result_ok.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::match_result_ok)]
 #![allow(dead_code)]
 #![allow(clippy::boxed_local, clippy::uninlined_format_args)]
diff --git a/tests/ui/match_result_ok.rs b/tests/ui/match_result_ok.rs
index bc2c4b50e27..eac382e1f62 100644
--- a/tests/ui/match_result_ok.rs
+++ b/tests/ui/match_result_ok.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::match_result_ok)]
 #![allow(dead_code)]
 #![allow(clippy::boxed_local, clippy::uninlined_format_args)]
diff --git a/tests/ui/match_single_binding.fixed b/tests/ui/match_single_binding.fixed
index 201301cc9b7..7c29bb08e64 100644
--- a/tests/ui/match_single_binding.fixed
+++ b/tests/ui/match_single_binding.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::match_single_binding)]
 #![allow(
     unused,
diff --git a/tests/ui/match_single_binding.rs b/tests/ui/match_single_binding.rs
index 8b047b19ce9..c068d5e17c3 100644
--- a/tests/ui/match_single_binding.rs
+++ b/tests/ui/match_single_binding.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::match_single_binding)]
 #![allow(
     unused,
diff --git a/tests/ui/match_single_binding2.fixed b/tests/ui/match_single_binding2.fixed
index e3cf56a4293..adfb4ba91f7 100644
--- a/tests/ui/match_single_binding2.fixed
+++ b/tests/ui/match_single_binding2.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::match_single_binding)]
 #![allow(unused_variables)]
 #![allow(clippy::uninlined_format_args)]
diff --git a/tests/ui/match_single_binding2.rs b/tests/ui/match_single_binding2.rs
index 5a4bb8441ff..b5cfe3654a5 100644
--- a/tests/ui/match_single_binding2.rs
+++ b/tests/ui/match_single_binding2.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::match_single_binding)]
 #![allow(unused_variables)]
 #![allow(clippy::uninlined_format_args)]
diff --git a/tests/ui/match_str_case_mismatch.fixed b/tests/ui/match_str_case_mismatch.fixed
index e436bcf495f..cd53b1f06fa 100644
--- a/tests/ui/match_str_case_mismatch.fixed
+++ b/tests/ui/match_str_case_mismatch.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::match_str_case_mismatch)]
 #![allow(dead_code)]
 
diff --git a/tests/ui/match_str_case_mismatch.rs b/tests/ui/match_str_case_mismatch.rs
index 92e2a000ade..6885305662a 100644
--- a/tests/ui/match_str_case_mismatch.rs
+++ b/tests/ui/match_str_case_mismatch.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::match_str_case_mismatch)]
 #![allow(dead_code)]
 
diff --git a/tests/ui/match_wildcard_for_single_variants.fixed b/tests/ui/match_wildcard_for_single_variants.fixed
index 9fd3739b69c..d2e6fef0759 100644
--- a/tests/ui/match_wildcard_for_single_variants.fixed
+++ b/tests/ui/match_wildcard_for_single_variants.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::match_wildcard_for_single_variants)]
 #![allow(dead_code)]
diff --git a/tests/ui/match_wildcard_for_single_variants.rs b/tests/ui/match_wildcard_for_single_variants.rs
index 9a5c849e6ec..cff0c896065 100644
--- a/tests/ui/match_wildcard_for_single_variants.rs
+++ b/tests/ui/match_wildcard_for_single_variants.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::match_wildcard_for_single_variants)]
 #![allow(dead_code)]
diff --git a/tests/ui/mem_replace.fixed b/tests/ui/mem_replace.fixed
index 7fd340173af..d37e97b0a06 100644
--- a/tests/ui/mem_replace.fixed
+++ b/tests/ui/mem_replace.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(unused)]
 #![warn(
diff --git a/tests/ui/mem_replace.rs b/tests/ui/mem_replace.rs
index fa2903addbc..34e37f3dbbb 100644
--- a/tests/ui/mem_replace.rs
+++ b/tests/ui/mem_replace.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(unused)]
 #![warn(
diff --git a/tests/ui/mem_replace_macro.rs b/tests/ui/mem_replace_macro.rs
index 3932e7d00c1..132873858b7 100644
--- a/tests/ui/mem_replace_macro.rs
+++ b/tests/ui/mem_replace_macro.rs
@@ -1,4 +1,4 @@
-// aux-build:proc_macros.rs
+//@aux-build:proc_macros.rs
 #![warn(clippy::mem_replace_with_default)]
 
 extern crate proc_macros;
diff --git a/tests/ui/methods.rs b/tests/ui/methods.rs
index 1519e4da934..e0e2cac30a2 100644
--- a/tests/ui/methods.rs
+++ b/tests/ui/methods.rs
@@ -1,4 +1,4 @@
-// aux-build:option_helpers.rs
+//@aux-build:option_helpers.rs
 
 #![warn(clippy::all, clippy::pedantic)]
 #![allow(
diff --git a/tests/ui/methods_fixable.fixed b/tests/ui/methods_fixable.fixed
index ee7c1b0da6d..dcbed5a4d99 100644
--- a/tests/ui/methods_fixable.fixed
+++ b/tests/ui/methods_fixable.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::filter_next)]
 
diff --git a/tests/ui/methods_fixable.rs b/tests/ui/methods_fixable.rs
index 6d0f1b7bd51..3a976d23527 100644
--- a/tests/ui/methods_fixable.rs
+++ b/tests/ui/methods_fixable.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::filter_next)]
 
diff --git a/tests/ui/mismatched_target_os_non_unix.fixed b/tests/ui/mismatched_target_os_non_unix.fixed
index f219a570e7f..f58e9a429b6 100644
--- a/tests/ui/mismatched_target_os_non_unix.fixed
+++ b/tests/ui/mismatched_target_os_non_unix.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::mismatched_target_os)]
 #![allow(unused)]
diff --git a/tests/ui/mismatched_target_os_non_unix.rs b/tests/ui/mismatched_target_os_non_unix.rs
index 8a8ae756a4f..e00224f5ceb 100644
--- a/tests/ui/mismatched_target_os_non_unix.rs
+++ b/tests/ui/mismatched_target_os_non_unix.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::mismatched_target_os)]
 #![allow(unused)]
diff --git a/tests/ui/mismatched_target_os_unix.fixed b/tests/ui/mismatched_target_os_unix.fixed
index 7d9d406d99d..330587a3c4c 100644
--- a/tests/ui/mismatched_target_os_unix.fixed
+++ b/tests/ui/mismatched_target_os_unix.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::mismatched_target_os)]
 #![allow(unused)]
diff --git a/tests/ui/mismatched_target_os_unix.rs b/tests/ui/mismatched_target_os_unix.rs
index c1177f1eedc..5a90019a2e4 100644
--- a/tests/ui/mismatched_target_os_unix.rs
+++ b/tests/ui/mismatched_target_os_unix.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::mismatched_target_os)]
 #![allow(unused)]
diff --git a/tests/ui/missing_const_for_fn/cant_be_const.rs b/tests/ui/missing_const_for_fn/cant_be_const.rs
index e6f88c6e622..5db73a7b8ea 100644
--- a/tests/ui/missing_const_for_fn/cant_be_const.rs
+++ b/tests/ui/missing_const_for_fn/cant_be_const.rs
@@ -2,8 +2,8 @@
 //! compilation error.
 //! The .stderr output of this test should be empty. Otherwise it's a bug somewhere.
 
-// aux-build:helper.rs
-// aux-build:../../auxiliary/proc_macros.rs
+//@aux-build:helper.rs
+//@aux-build:../../auxiliary/proc_macros.rs
 
 #![warn(clippy::missing_const_for_fn)]
 #![feature(start)]
diff --git a/tests/ui/missing_doc.rs b/tests/ui/missing_doc.rs
index 5752048949c..bf587e774f7 100644
--- a/tests/ui/missing_doc.rs
+++ b/tests/ui/missing_doc.rs
@@ -1,5 +1,5 @@
-// needs-asm-support
-// aux-build: proc_macros.rs
+//@needs-asm-support
+//@aux-build: proc_macros.rs
 
 #![warn(clippy::missing_docs_in_private_items)]
 // When denying at the crate level, be sure to not get random warnings from the
diff --git a/tests/ui/missing_doc_impl.rs b/tests/ui/missing_doc_impl.rs
index e2d49b0907d..520ddbe16b8 100644
--- a/tests/ui/missing_doc_impl.rs
+++ b/tests/ui/missing_doc_impl.rs
@@ -1,4 +1,4 @@
-// aux-build: proc_macros.rs
+//@aux-build: proc_macros.rs
 
 #![warn(clippy::missing_docs_in_private_items)]
 #![allow(dead_code)]
diff --git a/tests/ui/missing_spin_loop.fixed b/tests/ui/missing_spin_loop.fixed
index aa89e04d26e..a15298dc37b 100644
--- a/tests/ui/missing_spin_loop.fixed
+++ b/tests/ui/missing_spin_loop.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::missing_spin_loop)]
 #![allow(clippy::bool_comparison)]
 #![allow(unused_braces)]
diff --git a/tests/ui/missing_spin_loop.rs b/tests/ui/missing_spin_loop.rs
index 88745e47732..be74581ecd0 100644
--- a/tests/ui/missing_spin_loop.rs
+++ b/tests/ui/missing_spin_loop.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::missing_spin_loop)]
 #![allow(clippy::bool_comparison)]
 #![allow(unused_braces)]
diff --git a/tests/ui/missing_spin_loop_no_std.fixed b/tests/ui/missing_spin_loop_no_std.fixed
index bb4b4795516..960e5c05fb6 100644
--- a/tests/ui/missing_spin_loop_no_std.fixed
+++ b/tests/ui/missing_spin_loop_no_std.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::missing_spin_loop)]
 #![feature(lang_items, start, libc)]
 #![no_std]
diff --git a/tests/ui/missing_spin_loop_no_std.rs b/tests/ui/missing_spin_loop_no_std.rs
index a19bc72baf8..e532ca62dc5 100644
--- a/tests/ui/missing_spin_loop_no_std.rs
+++ b/tests/ui/missing_spin_loop_no_std.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::missing_spin_loop)]
 #![feature(lang_items, start, libc)]
 #![no_std]
diff --git a/tests/ui/mistyped_literal_suffix.fixed b/tests/ui/mistyped_literal_suffix.fixed
index 9a47d7c56ed..62cfeafdc49 100644
--- a/tests/ui/mistyped_literal_suffix.fixed
+++ b/tests/ui/mistyped_literal_suffix.fixed
@@ -1,5 +1,5 @@
-// run-rustfix
-// aux-build: proc_macros.rs
+//@run-rustfix
+//@aux-build: proc_macros.rs
 
 #![allow(
     dead_code,
diff --git a/tests/ui/mistyped_literal_suffix.rs b/tests/ui/mistyped_literal_suffix.rs
index 04261cba55a..f83b7c3dbda 100644
--- a/tests/ui/mistyped_literal_suffix.rs
+++ b/tests/ui/mistyped_literal_suffix.rs
@@ -1,5 +1,5 @@
-// run-rustfix
-// aux-build: proc_macros.rs
+//@run-rustfix
+//@aux-build: proc_macros.rs
 
 #![allow(
     dead_code,
diff --git a/tests/ui/module_name_repetitions.rs b/tests/ui/module_name_repetitions.rs
index ebaa77cc283..fb2c7612343 100644
--- a/tests/ui/module_name_repetitions.rs
+++ b/tests/ui/module_name_repetitions.rs
@@ -1,4 +1,4 @@
-// compile-flags: --test
+//@compile-flags: --test
 
 #![warn(clippy::module_name_repetitions)]
 #![allow(dead_code)]
diff --git a/tests/ui/multiple_unsafe_ops_per_block.rs b/tests/ui/multiple_unsafe_ops_per_block.rs
index 9082f1675a8..73ef35c8c36 100644
--- a/tests/ui/multiple_unsafe_ops_per_block.rs
+++ b/tests/ui/multiple_unsafe_ops_per_block.rs
@@ -1,4 +1,4 @@
-// aux-build:proc_macros.rs
+//@aux-build:proc_macros.rs
 #![allow(unused)]
 #![allow(deref_nullptr)]
 #![allow(clippy::unnecessary_operation)]
diff --git a/tests/ui/must_use_candidates.fixed b/tests/ui/must_use_candidates.fixed
index bbbb3cf621e..0c275504d36 100644
--- a/tests/ui/must_use_candidates.fixed
+++ b/tests/ui/must_use_candidates.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![feature(never_type)]
 #![allow(unused_mut, unused_tuple_struct_fields, clippy::redundant_allocation)]
 #![warn(clippy::must_use_candidate)]
diff --git a/tests/ui/must_use_candidates.rs b/tests/ui/must_use_candidates.rs
index 94d3c83bdb9..d1c9267732f 100644
--- a/tests/ui/must_use_candidates.rs
+++ b/tests/ui/must_use_candidates.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![feature(never_type)]
 #![allow(unused_mut, unused_tuple_struct_fields, clippy::redundant_allocation)]
 #![warn(clippy::must_use_candidate)]
diff --git a/tests/ui/must_use_unit.fixed b/tests/ui/must_use_unit.fixed
index b7d375ff80e..4f7cf4e56d1 100644
--- a/tests/ui/must_use_unit.fixed
+++ b/tests/ui/must_use_unit.fixed
@@ -1,5 +1,5 @@
-//run-rustfix
-// aux-build:proc_macros.rs
+//@run-rustfix
+//@aux-build:proc_macros.rs
 
 #![warn(clippy::must_use_unit)]
 #![allow(clippy::unused_unit)]
diff --git a/tests/ui/must_use_unit.rs b/tests/ui/must_use_unit.rs
index 74d6b4ca865..3a814ce1685 100644
--- a/tests/ui/must_use_unit.rs
+++ b/tests/ui/must_use_unit.rs
@@ -1,5 +1,5 @@
-//run-rustfix
-// aux-build:proc_macros.rs
+//@run-rustfix
+//@aux-build:proc_macros.rs
 
 #![warn(clippy::must_use_unit)]
 #![allow(clippy::unused_unit)]
diff --git a/tests/ui/mut_mut.rs b/tests/ui/mut_mut.rs
index 06bb085442a..d838098de11 100644
--- a/tests/ui/mut_mut.rs
+++ b/tests/ui/mut_mut.rs
@@ -1,4 +1,4 @@
-// aux-build:proc_macros.rs
+//@aux-build:proc_macros.rs
 #![warn(clippy::mut_mut)]
 #![allow(unused)]
 #![allow(clippy::no_effect, clippy::uninlined_format_args, clippy::unnecessary_operation)]
diff --git a/tests/ui/mut_mutex_lock.fixed b/tests/ui/mut_mutex_lock.fixed
index ecad10a8290..433817a4e03 100644
--- a/tests/ui/mut_mutex_lock.fixed
+++ b/tests/ui/mut_mutex_lock.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![allow(dead_code, unused_mut)]
 #![warn(clippy::mut_mutex_lock)]
 
diff --git a/tests/ui/mut_mutex_lock.rs b/tests/ui/mut_mutex_lock.rs
index f2b1d6fbfbc..567a0b59e70 100644
--- a/tests/ui/mut_mutex_lock.rs
+++ b/tests/ui/mut_mutex_lock.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![allow(dead_code, unused_mut)]
 #![warn(clippy::mut_mutex_lock)]
 
diff --git a/tests/ui/needless_arbitrary_self_type.fixed b/tests/ui/needless_arbitrary_self_type.fixed
index 9da21eb6b29..d7eb1a047ed 100644
--- a/tests/ui/needless_arbitrary_self_type.fixed
+++ b/tests/ui/needless_arbitrary_self_type.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::needless_arbitrary_self_type)]
 #![allow(unused_mut, clippy::needless_lifetimes)]
diff --git a/tests/ui/needless_arbitrary_self_type.rs b/tests/ui/needless_arbitrary_self_type.rs
index 17aeaaf97ac..85a2a957f29 100644
--- a/tests/ui/needless_arbitrary_self_type.rs
+++ b/tests/ui/needless_arbitrary_self_type.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::needless_arbitrary_self_type)]
 #![allow(unused_mut, clippy::needless_lifetimes)]
diff --git a/tests/ui/needless_arbitrary_self_type_unfixable.rs b/tests/ui/needless_arbitrary_self_type_unfixable.rs
index 02b43cce2bd..00871f9f450 100644
--- a/tests/ui/needless_arbitrary_self_type_unfixable.rs
+++ b/tests/ui/needless_arbitrary_self_type_unfixable.rs
@@ -1,4 +1,4 @@
-// aux-build:proc_macro_attr.rs
+//@aux-build:proc_macro_attr.rs
 
 #![warn(clippy::needless_arbitrary_self_type)]
 
diff --git a/tests/ui/needless_bitwise_bool.fixed b/tests/ui/needless_bitwise_bool.fixed
index 5e1ea663a10..7543ab72ca2 100644
--- a/tests/ui/needless_bitwise_bool.fixed
+++ b/tests/ui/needless_bitwise_bool.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::needless_bitwise_bool)]
 
diff --git a/tests/ui/needless_bitwise_bool.rs b/tests/ui/needless_bitwise_bool.rs
index f3075fba0a2..2cea701dce6 100644
--- a/tests/ui/needless_bitwise_bool.rs
+++ b/tests/ui/needless_bitwise_bool.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::needless_bitwise_bool)]
 
diff --git a/tests/ui/needless_bool/fixable.fixed b/tests/ui/needless_bool/fixable.fixed
index 89dc13fd5b1..f860852e7b7 100644
--- a/tests/ui/needless_bool/fixable.fixed
+++ b/tests/ui/needless_bool/fixable.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::needless_bool)]
 #![allow(
diff --git a/tests/ui/needless_bool/fixable.rs b/tests/ui/needless_bool/fixable.rs
index c11d9472e8d..6680dab5b6d 100644
--- a/tests/ui/needless_bool/fixable.rs
+++ b/tests/ui/needless_bool/fixable.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::needless_bool)]
 #![allow(
diff --git a/tests/ui/needless_borrow.fixed b/tests/ui/needless_borrow.fixed
index 4cb7f6b687f..425e6eb6200 100644
--- a/tests/ui/needless_borrow.fixed
+++ b/tests/ui/needless_borrow.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![feature(lint_reasons)]
 #![allow(
     unused,
diff --git a/tests/ui/needless_borrow.rs b/tests/ui/needless_borrow.rs
index 9a01190ed8d..3f7fa4a9d7d 100644
--- a/tests/ui/needless_borrow.rs
+++ b/tests/ui/needless_borrow.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![feature(lint_reasons)]
 #![allow(
     unused,
diff --git a/tests/ui/needless_borrowed_ref.fixed b/tests/ui/needless_borrowed_ref.fixed
index 0c47ceb7b67..6663520da8a 100644
--- a/tests/ui/needless_borrowed_ref.fixed
+++ b/tests/ui/needless_borrowed_ref.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::needless_borrowed_reference)]
 #![allow(
diff --git a/tests/ui/needless_borrowed_ref.rs b/tests/ui/needless_borrowed_ref.rs
index f883bb0c889..6c8efd2ce18 100644
--- a/tests/ui/needless_borrowed_ref.rs
+++ b/tests/ui/needless_borrowed_ref.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::needless_borrowed_reference)]
 #![allow(
diff --git a/tests/ui/needless_collect.fixed b/tests/ui/needless_collect.fixed
index 2659ad38488..024c22de225 100644
--- a/tests/ui/needless_collect.fixed
+++ b/tests/ui/needless_collect.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(unused, clippy::suspicious_map, clippy::iter_count)]
 
diff --git a/tests/ui/needless_collect.rs b/tests/ui/needless_collect.rs
index 535ec82982b..7ed7babec30 100644
--- a/tests/ui/needless_collect.rs
+++ b/tests/ui/needless_collect.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(unused, clippy::suspicious_map, clippy::iter_count)]
 
diff --git a/tests/ui/needless_for_each_fixable.fixed b/tests/ui/needless_for_each_fixable.fixed
index 09e671b88e1..a04f9ec651e 100644
--- a/tests/ui/needless_for_each_fixable.fixed
+++ b/tests/ui/needless_for_each_fixable.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::needless_for_each)]
 #![allow(unused)]
 #![allow(
diff --git a/tests/ui/needless_for_each_fixable.rs b/tests/ui/needless_for_each_fixable.rs
index abb4045b919..4975c705081 100644
--- a/tests/ui/needless_for_each_fixable.rs
+++ b/tests/ui/needless_for_each_fixable.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::needless_for_each)]
 #![allow(unused)]
 #![allow(
diff --git a/tests/ui/needless_late_init.fixed b/tests/ui/needless_late_init.fixed
index 86d899bb46c..92f7b3f777a 100644
--- a/tests/ui/needless_late_init.fixed
+++ b/tests/ui/needless_late_init.fixed
@@ -1,5 +1,5 @@
-// run-rustfix
-// aux-build:proc_macros.rs
+//@run-rustfix
+//@aux-build:proc_macros.rs
 #![feature(let_chains)]
 #![allow(unused)]
 #![allow(
diff --git a/tests/ui/needless_late_init.rs b/tests/ui/needless_late_init.rs
index 969afb38edf..be378c42f95 100644
--- a/tests/ui/needless_late_init.rs
+++ b/tests/ui/needless_late_init.rs
@@ -1,5 +1,5 @@
-// run-rustfix
-// aux-build:proc_macros.rs
+//@run-rustfix
+//@aux-build:proc_macros.rs
 #![feature(let_chains)]
 #![allow(unused)]
 #![allow(
diff --git a/tests/ui/needless_lifetimes.fixed b/tests/ui/needless_lifetimes.fixed
index e6ead69d148..7b99042f744 100644
--- a/tests/ui/needless_lifetimes.fixed
+++ b/tests/ui/needless_lifetimes.fixed
@@ -1,5 +1,5 @@
-// run-rustfix
-// aux-build:proc_macros.rs
+//@run-rustfix
+//@aux-build:proc_macros.rs
 
 #![warn(clippy::needless_lifetimes)]
 #![allow(
diff --git a/tests/ui/needless_lifetimes.rs b/tests/ui/needless_lifetimes.rs
index 06eb430506f..6fcf1efc2ee 100644
--- a/tests/ui/needless_lifetimes.rs
+++ b/tests/ui/needless_lifetimes.rs
@@ -1,5 +1,5 @@
-// run-rustfix
-// aux-build:proc_macros.rs
+//@run-rustfix
+//@aux-build:proc_macros.rs
 
 #![warn(clippy::needless_lifetimes)]
 #![allow(
diff --git a/tests/ui/needless_match.fixed b/tests/ui/needless_match.fixed
index 7e47406798c..d8a0400a4f0 100644
--- a/tests/ui/needless_match.fixed
+++ b/tests/ui/needless_match.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::needless_match)]
 #![allow(clippy::manual_map)]
 #![allow(dead_code)]
diff --git a/tests/ui/needless_match.rs b/tests/ui/needless_match.rs
index 809c694bf40..3de9bd6d7a1 100644
--- a/tests/ui/needless_match.rs
+++ b/tests/ui/needless_match.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::needless_match)]
 #![allow(clippy::manual_map)]
 #![allow(dead_code)]
diff --git a/tests/ui/needless_option_as_deref.fixed b/tests/ui/needless_option_as_deref.fixed
index acd22c6bb43..70015fccf9e 100644
--- a/tests/ui/needless_option_as_deref.fixed
+++ b/tests/ui/needless_option_as_deref.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(unused)]
 #![warn(clippy::needless_option_as_deref)]
diff --git a/tests/ui/needless_option_as_deref.rs b/tests/ui/needless_option_as_deref.rs
index 61eda5052a2..e2e35360cb3 100644
--- a/tests/ui/needless_option_as_deref.rs
+++ b/tests/ui/needless_option_as_deref.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(unused)]
 #![warn(clippy::needless_option_as_deref)]
diff --git a/tests/ui/needless_option_take.fixed b/tests/ui/needless_option_take.fixed
index 29691e81666..bfc6d20d5a3 100644
--- a/tests/ui/needless_option_take.fixed
+++ b/tests/ui/needless_option_take.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 fn main() {
     println!("Testing non erroneous option_take_on_temporary");
diff --git a/tests/ui/needless_option_take.rs b/tests/ui/needless_option_take.rs
index 9f4109eb463..697eeab4207 100644
--- a/tests/ui/needless_option_take.rs
+++ b/tests/ui/needless_option_take.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 fn main() {
     println!("Testing non erroneous option_take_on_temporary");
diff --git a/tests/ui/needless_parens_on_range_literals.fixed b/tests/ui/needless_parens_on_range_literals.fixed
index f11330a8916..9b98f6ea7f7 100644
--- a/tests/ui/needless_parens_on_range_literals.fixed
+++ b/tests/ui/needless_parens_on_range_literals.fixed
@@ -1,5 +1,5 @@
-// run-rustfix
-// edition:2018
+//@run-rustfix
+//@edition:2018
 
 #![warn(clippy::needless_parens_on_range_literals)]
 #![allow(clippy::almost_complete_range)]
diff --git a/tests/ui/needless_parens_on_range_literals.rs b/tests/ui/needless_parens_on_range_literals.rs
index 671c0009e23..088e7b2b98f 100644
--- a/tests/ui/needless_parens_on_range_literals.rs
+++ b/tests/ui/needless_parens_on_range_literals.rs
@@ -1,5 +1,5 @@
-// run-rustfix
-// edition:2018
+//@run-rustfix
+//@edition:2018
 
 #![warn(clippy::needless_parens_on_range_literals)]
 #![allow(clippy::almost_complete_range)]
diff --git a/tests/ui/needless_question_mark.fixed b/tests/ui/needless_question_mark.fixed
index 7eaca571992..679b73d404a 100644
--- a/tests/ui/needless_question_mark.fixed
+++ b/tests/ui/needless_question_mark.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::needless_question_mark)]
 #![allow(
diff --git a/tests/ui/needless_question_mark.rs b/tests/ui/needless_question_mark.rs
index 960bc7b7898..a993d3ec35d 100644
--- a/tests/ui/needless_question_mark.rs
+++ b/tests/ui/needless_question_mark.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::needless_question_mark)]
 #![allow(
diff --git a/tests/ui/needless_return.fixed b/tests/ui/needless_return.fixed
index 57c08996ce2..ee4e5007dc5 100644
--- a/tests/ui/needless_return.fixed
+++ b/tests/ui/needless_return.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![feature(lint_reasons)]
 #![feature(yeet_expr)]
diff --git a/tests/ui/needless_return.rs b/tests/ui/needless_return.rs
index 7c1feefbe32..cd999db4f40 100644
--- a/tests/ui/needless_return.rs
+++ b/tests/ui/needless_return.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![feature(lint_reasons)]
 #![feature(yeet_expr)]
diff --git a/tests/ui/needless_splitn.fixed b/tests/ui/needless_splitn.fixed
index 5496031fefa..30a038312c8 100644
--- a/tests/ui/needless_splitn.fixed
+++ b/tests/ui/needless_splitn.fixed
@@ -1,5 +1,5 @@
-// run-rustfix
-// edition:2018
+//@run-rustfix
+//@edition:2018
 
 #![warn(clippy::needless_splitn)]
 #![allow(clippy::iter_skip_next, clippy::iter_nth_zero, clippy::manual_split_once)]
diff --git a/tests/ui/needless_splitn.rs b/tests/ui/needless_splitn.rs
index 35c2465bae1..1b0b9a5981a 100644
--- a/tests/ui/needless_splitn.rs
+++ b/tests/ui/needless_splitn.rs
@@ -1,5 +1,5 @@
-// run-rustfix
-// edition:2018
+//@run-rustfix
+//@edition:2018
 
 #![warn(clippy::needless_splitn)]
 #![allow(clippy::iter_skip_next, clippy::iter_nth_zero, clippy::manual_split_once)]
diff --git a/tests/ui/neg_multiply.fixed b/tests/ui/neg_multiply.fixed
index 58ab9e85678..e07e7c88d68 100644
--- a/tests/ui/neg_multiply.fixed
+++ b/tests/ui/neg_multiply.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::neg_multiply)]
 #![allow(clippy::no_effect, clippy::unnecessary_operation, clippy::precedence)]
 #![allow(unused)]
diff --git a/tests/ui/neg_multiply.rs b/tests/ui/neg_multiply.rs
index 581290dc72e..2887af7b421 100644
--- a/tests/ui/neg_multiply.rs
+++ b/tests/ui/neg_multiply.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::neg_multiply)]
 #![allow(clippy::no_effect, clippy::unnecessary_operation, clippy::precedence)]
 #![allow(unused)]
diff --git a/tests/ui/non_octal_unix_permissions.fixed b/tests/ui/non_octal_unix_permissions.fixed
index a9b2dcfb085..89d12752834 100644
--- a/tests/ui/non_octal_unix_permissions.fixed
+++ b/tests/ui/non_octal_unix_permissions.fixed
@@ -1,5 +1,5 @@
-// ignore-windows
-// run-rustfix
+//@ignore-windows
+//@run-rustfix
 #![warn(clippy::non_octal_unix_permissions)]
 use std::fs::{DirBuilder, File, OpenOptions, Permissions};
 use std::os::unix::fs::{DirBuilderExt, OpenOptionsExt, PermissionsExt};
diff --git a/tests/ui/non_octal_unix_permissions.rs b/tests/ui/non_octal_unix_permissions.rs
index 7d2922f494e..1b3a322d726 100644
--- a/tests/ui/non_octal_unix_permissions.rs
+++ b/tests/ui/non_octal_unix_permissions.rs
@@ -1,5 +1,5 @@
-// ignore-windows
-// run-rustfix
+//@ignore-windows
+//@run-rustfix
 #![warn(clippy::non_octal_unix_permissions)]
 use std::fs::{DirBuilder, File, OpenOptions, Permissions};
 use std::os::unix::fs::{DirBuilderExt, OpenOptionsExt, PermissionsExt};
diff --git a/tests/ui/nonminimal_bool_methods.fixed b/tests/ui/nonminimal_bool_methods.fixed
index aad44089de4..05802a2c865 100644
--- a/tests/ui/nonminimal_bool_methods.fixed
+++ b/tests/ui/nonminimal_bool_methods.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![allow(unused, clippy::diverging_sub_expression)]
 #![warn(clippy::nonminimal_bool)]
 
diff --git a/tests/ui/nonminimal_bool_methods.rs b/tests/ui/nonminimal_bool_methods.rs
index b9074da8427..cd5b576fa07 100644
--- a/tests/ui/nonminimal_bool_methods.rs
+++ b/tests/ui/nonminimal_bool_methods.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![allow(unused, clippy::diverging_sub_expression)]
 #![warn(clippy::nonminimal_bool)]
 
diff --git a/tests/ui/numbered_fields.fixed b/tests/ui/numbered_fields.fixed
index 68c987eb4c6..a52845e53a4 100644
--- a/tests/ui/numbered_fields.fixed
+++ b/tests/ui/numbered_fields.fixed
@@ -1,4 +1,4 @@
-//run-rustfix
+//@run-rustfix
 #![warn(clippy::init_numbered_fields)]
 #![allow(unused_tuple_struct_fields)]
 
diff --git a/tests/ui/numbered_fields.rs b/tests/ui/numbered_fields.rs
index 2ef4fb4de53..ca93f7dce59 100644
--- a/tests/ui/numbered_fields.rs
+++ b/tests/ui/numbered_fields.rs
@@ -1,4 +1,4 @@
-//run-rustfix
+//@run-rustfix
 #![warn(clippy::init_numbered_fields)]
 #![allow(unused_tuple_struct_fields)]
 
diff --git a/tests/ui/obfuscated_if_else.fixed b/tests/ui/obfuscated_if_else.fixed
index 62d932c2c6b..9e4f97253f8 100644
--- a/tests/ui/obfuscated_if_else.fixed
+++ b/tests/ui/obfuscated_if_else.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::obfuscated_if_else)]
 
diff --git a/tests/ui/obfuscated_if_else.rs b/tests/ui/obfuscated_if_else.rs
index 273be9092a7..c2351d64c1c 100644
--- a/tests/ui/obfuscated_if_else.rs
+++ b/tests/ui/obfuscated_if_else.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::obfuscated_if_else)]
 
diff --git a/tests/ui/option_as_ref_deref.fixed b/tests/ui/option_as_ref_deref.fixed
index d124d133faa..e1c0fa3f7fd 100644
--- a/tests/ui/option_as_ref_deref.fixed
+++ b/tests/ui/option_as_ref_deref.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(unused, clippy::redundant_clone)]
 #![warn(clippy::option_as_ref_deref)]
diff --git a/tests/ui/option_as_ref_deref.rs b/tests/ui/option_as_ref_deref.rs
index 86e354c6716..6f4917fd149 100644
--- a/tests/ui/option_as_ref_deref.rs
+++ b/tests/ui/option_as_ref_deref.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(unused, clippy::redundant_clone)]
 #![warn(clippy::option_as_ref_deref)]
diff --git a/tests/ui/option_env_unwrap.rs b/tests/ui/option_env_unwrap.rs
index 9a56cf40d8a..ee1fe3f1fc0 100644
--- a/tests/ui/option_env_unwrap.rs
+++ b/tests/ui/option_env_unwrap.rs
@@ -1,4 +1,4 @@
-// aux-build:proc_macros.rs
+//@aux-build:proc_macros.rs
 #![warn(clippy::option_env_unwrap)]
 #![allow(clippy::map_flatten)]
 
diff --git a/tests/ui/option_filter_map.fixed b/tests/ui/option_filter_map.fixed
index b20f73f3110..93c250cfa73 100644
--- a/tests/ui/option_filter_map.fixed
+++ b/tests/ui/option_filter_map.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::option_filter_map)]
 #![allow(clippy::map_flatten)]
 
diff --git a/tests/ui/option_filter_map.rs b/tests/ui/option_filter_map.rs
index 7abaaa0fb83..2c5f03250b9 100644
--- a/tests/ui/option_filter_map.rs
+++ b/tests/ui/option_filter_map.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::option_filter_map)]
 #![allow(clippy::map_flatten)]
 
diff --git a/tests/ui/option_if_let_else.fixed b/tests/ui/option_if_let_else.fixed
index 0456005dce4..f7d2cf2c7d8 100644
--- a/tests/ui/option_if_let_else.fixed
+++ b/tests/ui/option_if_let_else.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::option_if_let_else)]
 #![allow(
     unused_tuple_struct_fields,
diff --git a/tests/ui/option_if_let_else.rs b/tests/ui/option_if_let_else.rs
index 23b148752cb..1534572f6a2 100644
--- a/tests/ui/option_if_let_else.rs
+++ b/tests/ui/option_if_let_else.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::option_if_let_else)]
 #![allow(
     unused_tuple_struct_fields,
diff --git a/tests/ui/option_map_or_none.fixed b/tests/ui/option_map_or_none.fixed
index 04bfac7735f..501757647bf 100644
--- a/tests/ui/option_map_or_none.fixed
+++ b/tests/ui/option_map_or_none.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(clippy::bind_instead_of_map)]
 
diff --git a/tests/ui/option_map_or_none.rs b/tests/ui/option_map_or_none.rs
index bb84f8a48f4..4d8704e737d 100644
--- a/tests/ui/option_map_or_none.rs
+++ b/tests/ui/option_map_or_none.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(clippy::bind_instead_of_map)]
 
diff --git a/tests/ui/option_map_unit_fn_fixable.fixed b/tests/ui/option_map_unit_fn_fixable.fixed
index 00264dcceaa..8f64451edf3 100644
--- a/tests/ui/option_map_unit_fn_fixable.fixed
+++ b/tests/ui/option_map_unit_fn_fixable.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::option_map_unit_fn)]
 #![allow(unused)]
 #![allow(clippy::uninlined_format_args, clippy::unnecessary_wraps)]
diff --git a/tests/ui/option_map_unit_fn_fixable.rs b/tests/ui/option_map_unit_fn_fixable.rs
index f3363ebce54..2bf7a8e0f7d 100644
--- a/tests/ui/option_map_unit_fn_fixable.rs
+++ b/tests/ui/option_map_unit_fn_fixable.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::option_map_unit_fn)]
 #![allow(unused)]
 #![allow(clippy::uninlined_format_args, clippy::unnecessary_wraps)]
diff --git a/tests/ui/or_fun_call.fixed b/tests/ui/or_fun_call.fixed
index be9a65506e1..f723a55f77f 100644
--- a/tests/ui/or_fun_call.fixed
+++ b/tests/ui/or_fun_call.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::or_fun_call)]
 #![allow(dead_code)]
 #![allow(clippy::borrow_as_ptr, clippy::uninlined_format_args, clippy::unnecessary_wraps)]
diff --git a/tests/ui/or_fun_call.rs b/tests/ui/or_fun_call.rs
index 628c9704638..61ef6e27f32 100644
--- a/tests/ui/or_fun_call.rs
+++ b/tests/ui/or_fun_call.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::or_fun_call)]
 #![allow(dead_code)]
 #![allow(clippy::borrow_as_ptr, clippy::uninlined_format_args, clippy::unnecessary_wraps)]
diff --git a/tests/ui/or_then_unwrap.fixed b/tests/ui/or_then_unwrap.fixed
index 844cc4b7a09..40badac4424 100644
--- a/tests/ui/or_then_unwrap.fixed
+++ b/tests/ui/or_then_unwrap.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::or_then_unwrap)]
 #![allow(clippy::map_identity, clippy::let_unit_value)]
diff --git a/tests/ui/or_then_unwrap.rs b/tests/ui/or_then_unwrap.rs
index 1528ef9be96..76c9942fe6c 100644
--- a/tests/ui/or_then_unwrap.rs
+++ b/tests/ui/or_then_unwrap.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::or_then_unwrap)]
 #![allow(clippy::map_identity, clippy::let_unit_value)]
diff --git a/tests/ui/partialeq_to_none.fixed b/tests/ui/partialeq_to_none.fixed
index 4644ea8f51d..81a716bd276 100644
--- a/tests/ui/partialeq_to_none.fixed
+++ b/tests/ui/partialeq_to_none.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::partialeq_to_none)]
 
 struct Foobar;
diff --git a/tests/ui/partialeq_to_none.rs b/tests/ui/partialeq_to_none.rs
index 61011b3a8c5..f454715fa30 100644
--- a/tests/ui/partialeq_to_none.rs
+++ b/tests/ui/partialeq_to_none.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::partialeq_to_none)]
 
 struct Foobar;
diff --git a/tests/ui/path_buf_push_overwrite.fixed b/tests/ui/path_buf_push_overwrite.fixed
index ef8856830fc..393fc6e1c69 100644
--- a/tests/ui/path_buf_push_overwrite.fixed
+++ b/tests/ui/path_buf_push_overwrite.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 use std::path::PathBuf;
 
 #[warn(clippy::all, clippy::path_buf_push_overwrite)]
diff --git a/tests/ui/path_buf_push_overwrite.rs b/tests/ui/path_buf_push_overwrite.rs
index 6e2d483f454..18de6e06412 100644
--- a/tests/ui/path_buf_push_overwrite.rs
+++ b/tests/ui/path_buf_push_overwrite.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 use std::path::PathBuf;
 
 #[warn(clippy::all, clippy::path_buf_push_overwrite)]
diff --git a/tests/ui/patterns.fixed b/tests/ui/patterns.fixed
index cd69014326e..a1da47d84fd 100644
--- a/tests/ui/patterns.fixed
+++ b/tests/ui/patterns.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::all)]
 #![allow(unused)]
 #![allow(clippy::uninlined_format_args)]
diff --git a/tests/ui/patterns.rs b/tests/ui/patterns.rs
index 9128da420c0..399066b813e 100644
--- a/tests/ui/patterns.rs
+++ b/tests/ui/patterns.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::all)]
 #![allow(unused)]
 #![allow(clippy::uninlined_format_args)]
diff --git a/tests/ui/precedence.fixed b/tests/ui/precedence.fixed
index 163bd044c17..af4d5636b61 100644
--- a/tests/ui/precedence.fixed
+++ b/tests/ui/precedence.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::precedence)]
 #![allow(unused_must_use, clippy::no_effect, clippy::unnecessary_operation)]
 #![allow(clippy::identity_op)]
diff --git a/tests/ui/precedence.rs b/tests/ui/precedence.rs
index 8c849e3209b..e23ae912786 100644
--- a/tests/ui/precedence.rs
+++ b/tests/ui/precedence.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::precedence)]
 #![allow(unused_must_use, clippy::no_effect, clippy::unnecessary_operation)]
 #![allow(clippy::identity_op)]
diff --git a/tests/ui/print_stdout_build_script.rs b/tests/ui/print_stdout_build_script.rs
index 997ebef8a69..91448cb0faf 100644
--- a/tests/ui/print_stdout_build_script.rs
+++ b/tests/ui/print_stdout_build_script.rs
@@ -1,4 +1,4 @@
-// compile-flags: --crate-name=build_script_build
+//@compile-flags: --crate-name=build_script_build
 
 #![warn(clippy::print_stdout)]
 
diff --git a/tests/ui/print_with_newline.rs b/tests/ui/print_with_newline.rs
index b8c29d207ad..ff79ca75ffa 100644
--- a/tests/ui/print_with_newline.rs
+++ b/tests/ui/print_with_newline.rs
@@ -1,5 +1,5 @@
 // FIXME: Ideally these suggestions would be fixed via rustfix. Blocked by rust-lang/rust#53934
-// // run-rustfix
+//
 
 #![allow(clippy::print_literal)]
 #![warn(clippy::print_with_newline)]
diff --git a/tests/ui/println_empty_string.fixed b/tests/ui/println_empty_string.fixed
index 9760680927a..abf951ae22d 100644
--- a/tests/ui/println_empty_string.fixed
+++ b/tests/ui/println_empty_string.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![allow(clippy::match_single_binding)]
 
 fn main() {
diff --git a/tests/ui/println_empty_string.rs b/tests/ui/println_empty_string.rs
index 80fdb3e6e21..fd86e2543cc 100644
--- a/tests/ui/println_empty_string.rs
+++ b/tests/ui/println_empty_string.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![allow(clippy::match_single_binding)]
 
 fn main() {
diff --git a/tests/ui/ptr_as_ptr.fixed b/tests/ui/ptr_as_ptr.fixed
index ee7b998a0b2..2c2567d67cd 100644
--- a/tests/ui/ptr_as_ptr.fixed
+++ b/tests/ui/ptr_as_ptr.fixed
@@ -1,5 +1,5 @@
-// run-rustfix
-// aux-build:proc_macros.rs
+//@run-rustfix
+//@aux-build:proc_macros.rs
 
 #![warn(clippy::ptr_as_ptr)]
 
diff --git a/tests/ui/ptr_as_ptr.rs b/tests/ui/ptr_as_ptr.rs
index c88329ce4ec..6000e5c08ac 100644
--- a/tests/ui/ptr_as_ptr.rs
+++ b/tests/ui/ptr_as_ptr.rs
@@ -1,5 +1,5 @@
-// run-rustfix
-// aux-build:proc_macros.rs
+//@run-rustfix
+//@aux-build:proc_macros.rs
 
 #![warn(clippy::ptr_as_ptr)]
 
diff --git a/tests/ui/ptr_eq.fixed b/tests/ui/ptr_eq.fixed
index 209081e6e80..d5fa273d41f 100644
--- a/tests/ui/ptr_eq.fixed
+++ b/tests/ui/ptr_eq.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::ptr_eq)]
 
 macro_rules! mac {
diff --git a/tests/ui/ptr_eq.rs b/tests/ui/ptr_eq.rs
index 69162870807..e033366a4aa 100644
--- a/tests/ui/ptr_eq.rs
+++ b/tests/ui/ptr_eq.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::ptr_eq)]
 
 macro_rules! mac {
diff --git a/tests/ui/ptr_offset_with_cast.fixed b/tests/ui/ptr_offset_with_cast.fixed
index c57e2990fb9..f69bc131898 100644
--- a/tests/ui/ptr_offset_with_cast.fixed
+++ b/tests/ui/ptr_offset_with_cast.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![allow(clippy::unnecessary_cast)]
 
 fn main() {
diff --git a/tests/ui/ptr_offset_with_cast.rs b/tests/ui/ptr_offset_with_cast.rs
index 3de7997acdd..eae36c27729 100644
--- a/tests/ui/ptr_offset_with_cast.rs
+++ b/tests/ui/ptr_offset_with_cast.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![allow(clippy::unnecessary_cast)]
 
 fn main() {
diff --git a/tests/ui/question_mark.fixed b/tests/ui/question_mark.fixed
index 5c49d46da72..7f1660f31fa 100644
--- a/tests/ui/question_mark.fixed
+++ b/tests/ui/question_mark.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![allow(unreachable_code)]
 #![allow(dead_code)]
 #![allow(clippy::unnecessary_wraps)]
diff --git a/tests/ui/question_mark.rs b/tests/ui/question_mark.rs
index d057df6a9b3..a90eae50ed4 100644
--- a/tests/ui/question_mark.rs
+++ b/tests/ui/question_mark.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![allow(unreachable_code)]
 #![allow(dead_code)]
 #![allow(clippy::unnecessary_wraps)]
diff --git a/tests/ui/range_contains.fixed b/tests/ui/range_contains.fixed
index 4923731fe45..0a92ee7c8dd 100644
--- a/tests/ui/range_contains.fixed
+++ b/tests/ui/range_contains.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::manual_range_contains)]
 #![allow(unused)]
diff --git a/tests/ui/range_contains.rs b/tests/ui/range_contains.rs
index d623ccb5da6..7a83be60957 100644
--- a/tests/ui/range_contains.rs
+++ b/tests/ui/range_contains.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::manual_range_contains)]
 #![allow(unused)]
diff --git a/tests/ui/range_plus_minus_one.fixed b/tests/ui/range_plus_minus_one.fixed
index a16a3e54d45..79c133cb5e3 100644
--- a/tests/ui/range_plus_minus_one.fixed
+++ b/tests/ui/range_plus_minus_one.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(unused_parens)]
 #![allow(clippy::iter_with_drain)]
diff --git a/tests/ui/range_plus_minus_one.rs b/tests/ui/range_plus_minus_one.rs
index bd6cb4d21be..689a6b7a17c 100644
--- a/tests/ui/range_plus_minus_one.rs
+++ b/tests/ui/range_plus_minus_one.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(unused_parens)]
 #![allow(clippy::iter_with_drain)]
diff --git a/tests/ui/rc_buffer.fixed b/tests/ui/rc_buffer.fixed
index 8910c01b1fc..4cba292c1b7 100644
--- a/tests/ui/rc_buffer.fixed
+++ b/tests/ui/rc_buffer.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::rc_buffer)]
 #![allow(dead_code, unused_imports)]
 
diff --git a/tests/ui/rc_buffer.rs b/tests/ui/rc_buffer.rs
index 1e63a43262e..d8a9aa2786d 100644
--- a/tests/ui/rc_buffer.rs
+++ b/tests/ui/rc_buffer.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::rc_buffer)]
 #![allow(dead_code, unused_imports)]
 
diff --git a/tests/ui/rc_buffer_arc.fixed b/tests/ui/rc_buffer_arc.fixed
index 13dd6f5fcd1..ac51ac9e467 100644
--- a/tests/ui/rc_buffer_arc.fixed
+++ b/tests/ui/rc_buffer_arc.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::rc_buffer)]
 #![allow(dead_code, unused_imports)]
 
diff --git a/tests/ui/rc_buffer_arc.rs b/tests/ui/rc_buffer_arc.rs
index 1a521bfeb7c..21dc27bc5fa 100644
--- a/tests/ui/rc_buffer_arc.rs
+++ b/tests/ui/rc_buffer_arc.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::rc_buffer)]
 #![allow(dead_code, unused_imports)]
 
diff --git a/tests/ui/redundant_allocation_fixable.fixed b/tests/ui/redundant_allocation_fixable.fixed
index 6db02718c70..edb7715f42c 100644
--- a/tests/ui/redundant_allocation_fixable.fixed
+++ b/tests/ui/redundant_allocation_fixable.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::all)]
 #![allow(clippy::boxed_local, clippy::needless_pass_by_value)]
 #![allow(clippy::disallowed_names, unused_variables, dead_code)]
diff --git a/tests/ui/redundant_allocation_fixable.rs b/tests/ui/redundant_allocation_fixable.rs
index c15806f30c0..c59422dd966 100644
--- a/tests/ui/redundant_allocation_fixable.rs
+++ b/tests/ui/redundant_allocation_fixable.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::all)]
 #![allow(clippy::boxed_local, clippy::needless_pass_by_value)]
 #![allow(clippy::disallowed_names, unused_variables, dead_code)]
diff --git a/tests/ui/redundant_async_block.fixed b/tests/ui/redundant_async_block.fixed
index ad96993c4a7..328958491ee 100644
--- a/tests/ui/redundant_async_block.fixed
+++ b/tests/ui/redundant_async_block.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(unused, clippy::manual_async_fn)]
 #![warn(clippy::redundant_async_block)]
diff --git a/tests/ui/redundant_async_block.rs b/tests/ui/redundant_async_block.rs
index 7ae23558369..cd189b31555 100644
--- a/tests/ui/redundant_async_block.rs
+++ b/tests/ui/redundant_async_block.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(unused, clippy::manual_async_fn)]
 #![warn(clippy::redundant_async_block)]
diff --git a/tests/ui/redundant_clone.fixed b/tests/ui/redundant_clone.fixed
index 00b42745093..8bebb5183bc 100644
--- a/tests/ui/redundant_clone.fixed
+++ b/tests/ui/redundant_clone.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 // rustfix-only-machine-applicable
 #![feature(lint_reasons)]
 #![allow(clippy::drop_non_drop, clippy::implicit_clone, clippy::uninlined_format_args)]
diff --git a/tests/ui/redundant_clone.rs b/tests/ui/redundant_clone.rs
index f899127db8d..b4bd5d16b1a 100644
--- a/tests/ui/redundant_clone.rs
+++ b/tests/ui/redundant_clone.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 // rustfix-only-machine-applicable
 #![feature(lint_reasons)]
 #![allow(clippy::drop_non_drop, clippy::implicit_clone, clippy::uninlined_format_args)]
diff --git a/tests/ui/redundant_closure_call_fixable.fixed b/tests/ui/redundant_closure_call_fixable.fixed
index b987fd2ce6f..61aed2733fe 100644
--- a/tests/ui/redundant_closure_call_fixable.fixed
+++ b/tests/ui/redundant_closure_call_fixable.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![feature(async_closure)]
 #![warn(clippy::redundant_closure_call)]
diff --git a/tests/ui/redundant_closure_call_fixable.rs b/tests/ui/redundant_closure_call_fixable.rs
index 633a2979d5d..56b28663539 100644
--- a/tests/ui/redundant_closure_call_fixable.rs
+++ b/tests/ui/redundant_closure_call_fixable.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![feature(async_closure)]
 #![warn(clippy::redundant_closure_call)]
diff --git a/tests/ui/redundant_field_names.fixed b/tests/ui/redundant_field_names.fixed
index 276266a2dd8..d2a65399da6 100644
--- a/tests/ui/redundant_field_names.fixed
+++ b/tests/ui/redundant_field_names.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::redundant_field_names)]
 #![allow(clippy::extra_unused_type_parameters, clippy::no_effect, dead_code, unused_variables)]
diff --git a/tests/ui/redundant_field_names.rs b/tests/ui/redundant_field_names.rs
index f674141c138..605ffd21e2f 100644
--- a/tests/ui/redundant_field_names.rs
+++ b/tests/ui/redundant_field_names.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::redundant_field_names)]
 #![allow(clippy::extra_unused_type_parameters, clippy::no_effect, dead_code, unused_variables)]
diff --git a/tests/ui/redundant_pattern_matching_drop_order.fixed b/tests/ui/redundant_pattern_matching_drop_order.fixed
index ce3229f1759..bebdf89716f 100644
--- a/tests/ui/redundant_pattern_matching_drop_order.fixed
+++ b/tests/ui/redundant_pattern_matching_drop_order.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 // Issue #5746
 #![warn(clippy::redundant_pattern_matching)]
diff --git a/tests/ui/redundant_pattern_matching_drop_order.rs b/tests/ui/redundant_pattern_matching_drop_order.rs
index 29b8543cf47..8fb6ed5f7ec 100644
--- a/tests/ui/redundant_pattern_matching_drop_order.rs
+++ b/tests/ui/redundant_pattern_matching_drop_order.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 // Issue #5746
 #![warn(clippy::redundant_pattern_matching)]
diff --git a/tests/ui/redundant_pattern_matching_ipaddr.fixed b/tests/ui/redundant_pattern_matching_ipaddr.fixed
index 21bae909555..a9faf12cd5a 100644
--- a/tests/ui/redundant_pattern_matching_ipaddr.fixed
+++ b/tests/ui/redundant_pattern_matching_ipaddr.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::all, clippy::redundant_pattern_matching)]
 #![allow(unused_must_use)]
 #![allow(
diff --git a/tests/ui/redundant_pattern_matching_ipaddr.rs b/tests/ui/redundant_pattern_matching_ipaddr.rs
index 4dd9171677e..574671d03d1 100644
--- a/tests/ui/redundant_pattern_matching_ipaddr.rs
+++ b/tests/ui/redundant_pattern_matching_ipaddr.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::all, clippy::redundant_pattern_matching)]
 #![allow(unused_must_use)]
 #![allow(
diff --git a/tests/ui/redundant_pattern_matching_option.fixed b/tests/ui/redundant_pattern_matching_option.fixed
index a89845c1dd3..87100b97288 100644
--- a/tests/ui/redundant_pattern_matching_option.fixed
+++ b/tests/ui/redundant_pattern_matching_option.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::all)]
 #![warn(clippy::redundant_pattern_matching)]
diff --git a/tests/ui/redundant_pattern_matching_option.rs b/tests/ui/redundant_pattern_matching_option.rs
index d6f44403487..0b69e13f655 100644
--- a/tests/ui/redundant_pattern_matching_option.rs
+++ b/tests/ui/redundant_pattern_matching_option.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::all)]
 #![warn(clippy::redundant_pattern_matching)]
diff --git a/tests/ui/redundant_pattern_matching_poll.fixed b/tests/ui/redundant_pattern_matching_poll.fixed
index 3645f2c4bfd..bf3e692202c 100644
--- a/tests/ui/redundant_pattern_matching_poll.fixed
+++ b/tests/ui/redundant_pattern_matching_poll.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::all)]
 #![warn(clippy::redundant_pattern_matching)]
diff --git a/tests/ui/redundant_pattern_matching_poll.rs b/tests/ui/redundant_pattern_matching_poll.rs
index 866c71b7cfa..892a21d9d29 100644
--- a/tests/ui/redundant_pattern_matching_poll.rs
+++ b/tests/ui/redundant_pattern_matching_poll.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::all)]
 #![warn(clippy::redundant_pattern_matching)]
diff --git a/tests/ui/redundant_pattern_matching_result.fixed b/tests/ui/redundant_pattern_matching_result.fixed
index 42348df4480..c48d1522935 100644
--- a/tests/ui/redundant_pattern_matching_result.fixed
+++ b/tests/ui/redundant_pattern_matching_result.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::all)]
 #![warn(clippy::redundant_pattern_matching)]
 #![allow(deprecated, unused_must_use)]
diff --git a/tests/ui/redundant_pattern_matching_result.rs b/tests/ui/redundant_pattern_matching_result.rs
index 5949cb2271c..26f37d169fa 100644
--- a/tests/ui/redundant_pattern_matching_result.rs
+++ b/tests/ui/redundant_pattern_matching_result.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::all)]
 #![warn(clippy::redundant_pattern_matching)]
 #![allow(deprecated, unused_must_use)]
diff --git a/tests/ui/redundant_pub_crate.fixed b/tests/ui/redundant_pub_crate.fixed
index 106947de68c..f65c0fdd35d 100644
--- a/tests/ui/redundant_pub_crate.fixed
+++ b/tests/ui/redundant_pub_crate.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![allow(dead_code)]
 #![warn(clippy::redundant_pub_crate)]
 
diff --git a/tests/ui/redundant_pub_crate.rs b/tests/ui/redundant_pub_crate.rs
index f96cfd31843..fb07fed98be 100644
--- a/tests/ui/redundant_pub_crate.rs
+++ b/tests/ui/redundant_pub_crate.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![allow(dead_code)]
 #![warn(clippy::redundant_pub_crate)]
 
diff --git a/tests/ui/redundant_slicing.fixed b/tests/ui/redundant_slicing.fixed
index 8dd8d309237..56ddca71903 100644
--- a/tests/ui/redundant_slicing.fixed
+++ b/tests/ui/redundant_slicing.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(unused, clippy::deref_by_slicing)]
 #![warn(clippy::redundant_slicing)]
diff --git a/tests/ui/redundant_slicing.rs b/tests/ui/redundant_slicing.rs
index 51c16dd8d65..d67b6665e26 100644
--- a/tests/ui/redundant_slicing.rs
+++ b/tests/ui/redundant_slicing.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(unused, clippy::deref_by_slicing)]
 #![warn(clippy::redundant_slicing)]
diff --git a/tests/ui/redundant_static_lifetimes.fixed b/tests/ui/redundant_static_lifetimes.fixed
index bca777a890c..2651735d103 100644
--- a/tests/ui/redundant_static_lifetimes.fixed
+++ b/tests/ui/redundant_static_lifetimes.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(unused)]
 
diff --git a/tests/ui/redundant_static_lifetimes.rs b/tests/ui/redundant_static_lifetimes.rs
index afe7644816d..7286652899d 100644
--- a/tests/ui/redundant_static_lifetimes.rs
+++ b/tests/ui/redundant_static_lifetimes.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(unused)]
 
diff --git a/tests/ui/rename.fixed b/tests/ui/rename.fixed
index 5076f61334d..e8a00a9e7f7 100644
--- a/tests/ui/rename.fixed
+++ b/tests/ui/rename.fixed
@@ -2,7 +2,7 @@
 // Use that command to update this file and do not edit by hand.
 // Manual edits will be overwritten.
 
-// run-rustfix
+//@run-rustfix
 
 #![allow(clippy::almost_complete_range)]
 #![allow(clippy::disallowed_names)]
diff --git a/tests/ui/rename.rs b/tests/ui/rename.rs
index 64bc1ca7116..c8ea70c2bcb 100644
--- a/tests/ui/rename.rs
+++ b/tests/ui/rename.rs
@@ -2,7 +2,7 @@
 // Use that command to update this file and do not edit by hand.
 // Manual edits will be overwritten.
 
-// run-rustfix
+//@run-rustfix
 
 #![allow(clippy::almost_complete_range)]
 #![allow(clippy::disallowed_names)]
diff --git a/tests/ui/renamed_builtin_attr.fixed b/tests/ui/renamed_builtin_attr.fixed
index cb91b841d2c..0334c1e1a29 100644
--- a/tests/ui/renamed_builtin_attr.fixed
+++ b/tests/ui/renamed_builtin_attr.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #[clippy::cognitive_complexity = "1"]
 fn main() {}
diff --git a/tests/ui/renamed_builtin_attr.rs b/tests/ui/renamed_builtin_attr.rs
index b3ce2758067..d350370c244 100644
--- a/tests/ui/renamed_builtin_attr.rs
+++ b/tests/ui/renamed_builtin_attr.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #[clippy::cyclomatic_complexity = "1"]
 fn main() {}
diff --git a/tests/ui/repeat_once.fixed b/tests/ui/repeat_once.fixed
index dc197e50300..c517bfcc6aa 100644
--- a/tests/ui/repeat_once.fixed
+++ b/tests/ui/repeat_once.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::repeat_once)]
 #[allow(unused, clippy::redundant_clone)]
 fn main() {
diff --git a/tests/ui/repeat_once.rs b/tests/ui/repeat_once.rs
index 0ec5127117c..9a30b47418f 100644
--- a/tests/ui/repeat_once.rs
+++ b/tests/ui/repeat_once.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::repeat_once)]
 #[allow(unused, clippy::redundant_clone)]
 fn main() {
diff --git a/tests/ui/result_map_or_into_option.fixed b/tests/ui/result_map_or_into_option.fixed
index 331531b5165..119ff25918a 100644
--- a/tests/ui/result_map_or_into_option.fixed
+++ b/tests/ui/result_map_or_into_option.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::result_map_or_into_option)]
 
diff --git a/tests/ui/result_map_or_into_option.rs b/tests/ui/result_map_or_into_option.rs
index 3058480e2ad..eeeef830af0 100644
--- a/tests/ui/result_map_or_into_option.rs
+++ b/tests/ui/result_map_or_into_option.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::result_map_or_into_option)]
 
diff --git a/tests/ui/result_map_unit_fn_fixable.fixed b/tests/ui/result_map_unit_fn_fixable.fixed
index d8b56237e98..0583d29277b 100644
--- a/tests/ui/result_map_unit_fn_fixable.fixed
+++ b/tests/ui/result_map_unit_fn_fixable.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::result_map_unit_fn)]
 #![allow(unused)]
 #![allow(clippy::uninlined_format_args)]
diff --git a/tests/ui/result_map_unit_fn_fixable.rs b/tests/ui/result_map_unit_fn_fixable.rs
index 44f50d21109..7ad3bdd04bd 100644
--- a/tests/ui/result_map_unit_fn_fixable.rs
+++ b/tests/ui/result_map_unit_fn_fixable.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::result_map_unit_fn)]
 #![allow(unused)]
 #![allow(clippy::uninlined_format_args)]
diff --git a/tests/ui/reversed_empty_ranges_fixable.fixed b/tests/ui/reversed_empty_ranges_fixable.fixed
index c67edb36c67..30dfc977681 100644
--- a/tests/ui/reversed_empty_ranges_fixable.fixed
+++ b/tests/ui/reversed_empty_ranges_fixable.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::reversed_empty_ranges)]
 #![allow(clippy::uninlined_format_args)]
 
diff --git a/tests/ui/reversed_empty_ranges_fixable.rs b/tests/ui/reversed_empty_ranges_fixable.rs
index 0a4fef5bfe8..1837249eae1 100644
--- a/tests/ui/reversed_empty_ranges_fixable.rs
+++ b/tests/ui/reversed_empty_ranges_fixable.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::reversed_empty_ranges)]
 #![allow(clippy::uninlined_format_args)]
 
diff --git a/tests/ui/reversed_empty_ranges_loops_fixable.fixed b/tests/ui/reversed_empty_ranges_loops_fixable.fixed
index 78401e463d5..a74569599c7 100644
--- a/tests/ui/reversed_empty_ranges_loops_fixable.fixed
+++ b/tests/ui/reversed_empty_ranges_loops_fixable.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::reversed_empty_ranges)]
 #![allow(clippy::uninlined_format_args)]
 
diff --git a/tests/ui/reversed_empty_ranges_loops_fixable.rs b/tests/ui/reversed_empty_ranges_loops_fixable.rs
index f9e0f7fcd6d..42f9957dfbd 100644
--- a/tests/ui/reversed_empty_ranges_loops_fixable.rs
+++ b/tests/ui/reversed_empty_ranges_loops_fixable.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::reversed_empty_ranges)]
 #![allow(clippy::uninlined_format_args)]
 
diff --git a/tests/ui/same_functions_in_if_condition.rs b/tests/ui/same_functions_in_if_condition.rs
index e6198a1bc9a..aea1507cc5b 100644
--- a/tests/ui/same_functions_in_if_condition.rs
+++ b/tests/ui/same_functions_in_if_condition.rs
@@ -1,5 +1,5 @@
 #![feature(adt_const_params)]
-#![warn(clippy::same_functions_in_if_condition)]
+#![deny(clippy::same_functions_in_if_condition)]
 // ifs_same_cond warning is different from `ifs_same_cond`.
 // clippy::if_same_then_else, clippy::comparison_chain -- all empty blocks
 #![allow(incomplete_features)]
diff --git a/tests/ui/same_functions_in_if_condition.stderr b/tests/ui/same_functions_in_if_condition.stderr
index f352ade150e..aade3b1fa45 100644
--- a/tests/ui/same_functions_in_if_condition.stderr
+++ b/tests/ui/same_functions_in_if_condition.stderr
@@ -9,7 +9,11 @@ note: same as this
    |
 LL |     if function() {
    |        ^^^^^^^^^^
-   = note: `-D clippy::same-functions-in-if-condition` implied by `-D warnings`
+note: the lint level is defined here
+  --> $DIR/same_functions_in_if_condition.rs:2:9
+   |
+LL | #![deny(clippy::same_functions_in_if_condition)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this `if` has the same function call as a previous `if`
   --> $DIR/same_functions_in_if_condition.rs:42:15
diff --git a/tests/ui/search_is_some.rs b/tests/ui/search_is_some.rs
index 72f335153c1..670599b0dcf 100644
--- a/tests/ui/search_is_some.rs
+++ b/tests/ui/search_is_some.rs
@@ -1,4 +1,4 @@
-// aux-build:option_helpers.rs
+//@aux-build:option_helpers.rs
 #![warn(clippy::search_is_some)]
 #![allow(dead_code)]
 extern crate option_helpers;
diff --git a/tests/ui/search_is_some_fixable_none.fixed b/tests/ui/search_is_some_fixable_none.fixed
index 5190c5304c7..9386618c123 100644
--- a/tests/ui/search_is_some_fixable_none.fixed
+++ b/tests/ui/search_is_some_fixable_none.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![allow(dead_code, clippy::explicit_auto_deref)]
 #![warn(clippy::search_is_some)]
 
diff --git a/tests/ui/search_is_some_fixable_none.rs b/tests/ui/search_is_some_fixable_none.rs
index 310d87333a9..6b2537a96c2 100644
--- a/tests/ui/search_is_some_fixable_none.rs
+++ b/tests/ui/search_is_some_fixable_none.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![allow(dead_code, clippy::explicit_auto_deref)]
 #![warn(clippy::search_is_some)]
 
diff --git a/tests/ui/search_is_some_fixable_some.fixed b/tests/ui/search_is_some_fixable_some.fixed
index 385a9986aba..e9116fc59f1 100644
--- a/tests/ui/search_is_some_fixable_some.fixed
+++ b/tests/ui/search_is_some_fixable_some.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![allow(dead_code, clippy::explicit_auto_deref)]
 #![warn(clippy::search_is_some)]
 
diff --git a/tests/ui/search_is_some_fixable_some.rs b/tests/ui/search_is_some_fixable_some.rs
index 67e190ee378..b1528399457 100644
--- a/tests/ui/search_is_some_fixable_some.rs
+++ b/tests/ui/search_is_some_fixable_some.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![allow(dead_code, clippy::explicit_auto_deref)]
 #![warn(clippy::search_is_some)]
 
diff --git a/tests/ui/seek_from_current.fixed b/tests/ui/seek_from_current.fixed
index 1309c91b81c..34c33baf686 100644
--- a/tests/ui/seek_from_current.fixed
+++ b/tests/ui/seek_from_current.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::seek_from_current)]
 
 use std::fs::File;
diff --git a/tests/ui/seek_from_current.rs b/tests/ui/seek_from_current.rs
index 5d9b1424cf6..22bcff1bc40 100644
--- a/tests/ui/seek_from_current.rs
+++ b/tests/ui/seek_from_current.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::seek_from_current)]
 
 use std::fs::File;
diff --git a/tests/ui/seek_to_start_instead_of_rewind.fixed b/tests/ui/seek_to_start_instead_of_rewind.fixed
index dc24d447c60..d8a6e6985d4 100644
--- a/tests/ui/seek_to_start_instead_of_rewind.fixed
+++ b/tests/ui/seek_to_start_instead_of_rewind.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![allow(unused)]
 #![warn(clippy::seek_to_start_instead_of_rewind)]
 
diff --git a/tests/ui/seek_to_start_instead_of_rewind.rs b/tests/ui/seek_to_start_instead_of_rewind.rs
index 4adde2c4018..fc6a6433c2b 100644
--- a/tests/ui/seek_to_start_instead_of_rewind.rs
+++ b/tests/ui/seek_to_start_instead_of_rewind.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![allow(unused)]
 #![warn(clippy::seek_to_start_instead_of_rewind)]
 
diff --git a/tests/ui/semicolon_inside_block.fixed b/tests/ui/semicolon_inside_block.fixed
index 42e97e1ca35..ee359f60cbd 100644
--- a/tests/ui/semicolon_inside_block.fixed
+++ b/tests/ui/semicolon_inside_block.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![allow(
     unused,
     clippy::unused_unit,
diff --git a/tests/ui/semicolon_inside_block.rs b/tests/ui/semicolon_inside_block.rs
index f40848f702e..e8516f79b20 100644
--- a/tests/ui/semicolon_inside_block.rs
+++ b/tests/ui/semicolon_inside_block.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![allow(
     unused,
     clippy::unused_unit,
diff --git a/tests/ui/semicolon_outside_block.fixed b/tests/ui/semicolon_outside_block.fixed
index 091eaa7518e..034c7f8c7c1 100644
--- a/tests/ui/semicolon_outside_block.fixed
+++ b/tests/ui/semicolon_outside_block.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![allow(
     unused,
     clippy::unused_unit,
diff --git a/tests/ui/semicolon_outside_block.rs b/tests/ui/semicolon_outside_block.rs
index 7ce46431fac..4dc956d8a4b 100644
--- a/tests/ui/semicolon_outside_block.rs
+++ b/tests/ui/semicolon_outside_block.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![allow(
     unused,
     clippy::unused_unit,
diff --git a/tests/ui/shadow.rs b/tests/ui/shadow.rs
index ab7800a2110..03337ec3564 100644
--- a/tests/ui/shadow.rs
+++ b/tests/ui/shadow.rs
@@ -1,4 +1,4 @@
-// aux-build:proc_macro_derive.rs
+//@aux-build:proc_macro_derive.rs
 
 #![warn(clippy::shadow_same, clippy::shadow_reuse, clippy::shadow_unrelated)]
 #![allow(clippy::let_unit_value)]
diff --git a/tests/ui/short_circuit_statement.fixed b/tests/ui/short_circuit_statement.fixed
index dd22ecab0b5..1737d501441 100644
--- a/tests/ui/short_circuit_statement.fixed
+++ b/tests/ui/short_circuit_statement.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::short_circuit_statement)]
 #![allow(clippy::nonminimal_bool)]
diff --git a/tests/ui/short_circuit_statement.rs b/tests/ui/short_circuit_statement.rs
index 73a55bf1f5e..ab93aa1ca5c 100644
--- a/tests/ui/short_circuit_statement.rs
+++ b/tests/ui/short_circuit_statement.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::short_circuit_statement)]
 #![allow(clippy::nonminimal_bool)]
diff --git a/tests/ui/significant_drop_in_scrutinee.rs b/tests/ui/significant_drop_in_scrutinee.rs
index c65df9ece38..8c48b21f188 100644
--- a/tests/ui/significant_drop_in_scrutinee.rs
+++ b/tests/ui/significant_drop_in_scrutinee.rs
@@ -1,5 +1,5 @@
 // FIXME: Ideally these suggestions would be fixed via rustfix. Blocked by rust-lang/rust#53934
-// // run-rustfix
+//
 #![warn(clippy::significant_drop_in_scrutinee)]
 #![allow(dead_code, unused_assignments)]
 #![allow(clippy::match_single_binding, clippy::single_match, clippy::uninlined_format_args)]
diff --git a/tests/ui/significant_drop_tightening.fixed b/tests/ui/significant_drop_tightening.fixed
index da998c610bd..ee7f2b0631a 100644
--- a/tests/ui/significant_drop_tightening.fixed
+++ b/tests/ui/significant_drop_tightening.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::significant_drop_tightening)]
 
diff --git a/tests/ui/significant_drop_tightening.rs b/tests/ui/significant_drop_tightening.rs
index 83823f95f68..9c139deb95f 100644
--- a/tests/ui/significant_drop_tightening.rs
+++ b/tests/ui/significant_drop_tightening.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::significant_drop_tightening)]
 
diff --git a/tests/ui/single_char_add_str.fixed b/tests/ui/single_char_add_str.fixed
index 63a6d37a9cc..cbcf1ab21c9 100644
--- a/tests/ui/single_char_add_str.fixed
+++ b/tests/ui/single_char_add_str.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::single_char_add_str)]
 
 macro_rules! get_string {
diff --git a/tests/ui/single_char_add_str.rs b/tests/ui/single_char_add_str.rs
index a799ea7d885..a1f005cc833 100644
--- a/tests/ui/single_char_add_str.rs
+++ b/tests/ui/single_char_add_str.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::single_char_add_str)]
 
 macro_rules! get_string {
diff --git a/tests/ui/single_char_pattern.fixed b/tests/ui/single_char_pattern.fixed
index 68e26726724..dba89872070 100644
--- a/tests/ui/single_char_pattern.fixed
+++ b/tests/ui/single_char_pattern.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(unused_must_use)]
 
diff --git a/tests/ui/single_char_pattern.rs b/tests/ui/single_char_pattern.rs
index 186202d78ec..6a145a14bfd 100644
--- a/tests/ui/single_char_pattern.rs
+++ b/tests/ui/single_char_pattern.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(unused_must_use)]
 
diff --git a/tests/ui/single_component_path_imports.fixed b/tests/ui/single_component_path_imports.fixed
index 8c96c4715d3..d4d2cbbe57a 100644
--- a/tests/ui/single_component_path_imports.fixed
+++ b/tests/ui/single_component_path_imports.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::single_component_path_imports)]
 #![allow(unused_imports)]
 
diff --git a/tests/ui/single_component_path_imports.rs b/tests/ui/single_component_path_imports.rs
index 8434bf7eaf1..80d72115f43 100644
--- a/tests/ui/single_component_path_imports.rs
+++ b/tests/ui/single_component_path_imports.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::single_component_path_imports)]
 #![allow(unused_imports)]
 
diff --git a/tests/ui/single_element_loop.fixed b/tests/ui/single_element_loop.fixed
index a0dcc0172e8..1697a0cf29b 100644
--- a/tests/ui/single_element_loop.fixed
+++ b/tests/ui/single_element_loop.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 // Tests from for_loop.rs that don't have suggestions
 
 #[warn(clippy::single_element_loop)]
diff --git a/tests/ui/single_element_loop.rs b/tests/ui/single_element_loop.rs
index bc014035c98..860424f42dd 100644
--- a/tests/ui/single_element_loop.rs
+++ b/tests/ui/single_element_loop.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 // Tests from for_loop.rs that don't have suggestions
 
 #[warn(clippy::single_element_loop)]
diff --git a/tests/ui/single_match_else.rs b/tests/ui/single_match_else.rs
index 3c86f41f3a6..c8ac768b60f 100644
--- a/tests/ui/single_match_else.rs
+++ b/tests/ui/single_match_else.rs
@@ -1,4 +1,4 @@
-// aux-build: proc_macros.rs
+//@aux-build: proc_macros.rs
 #![warn(clippy::single_match_else)]
 #![allow(clippy::needless_return, clippy::no_effect, clippy::uninlined_format_args)]
 
diff --git a/tests/ui/skip_while_next.rs b/tests/ui/skip_while_next.rs
index a551c19d98b..62574e2c8ce 100644
--- a/tests/ui/skip_while_next.rs
+++ b/tests/ui/skip_while_next.rs
@@ -1,4 +1,4 @@
-// aux-build:option_helpers.rs
+//@aux-build:option_helpers.rs
 
 #![warn(clippy::skip_while_next)]
 #![allow(clippy::disallowed_names)]
diff --git a/tests/ui/stable_sort_primitive.fixed b/tests/ui/stable_sort_primitive.fixed
index f5f18169df2..1370dd2df4d 100644
--- a/tests/ui/stable_sort_primitive.fixed
+++ b/tests/ui/stable_sort_primitive.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::stable_sort_primitive)]
 
 fn main() {
diff --git a/tests/ui/stable_sort_primitive.rs b/tests/ui/stable_sort_primitive.rs
index 8149c5638e0..cd344dd1238 100644
--- a/tests/ui/stable_sort_primitive.rs
+++ b/tests/ui/stable_sort_primitive.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::stable_sort_primitive)]
 
 fn main() {
diff --git a/tests/ui/starts_ends_with.fixed b/tests/ui/starts_ends_with.fixed
index 983fac7afe6..29d56f852ed 100644
--- a/tests/ui/starts_ends_with.fixed
+++ b/tests/ui/starts_ends_with.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![allow(dead_code, unused_must_use)]
 
 fn main() {}
diff --git a/tests/ui/starts_ends_with.rs b/tests/ui/starts_ends_with.rs
index e3335dd2e2e..56bbe2574d4 100644
--- a/tests/ui/starts_ends_with.rs
+++ b/tests/ui/starts_ends_with.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![allow(dead_code, unused_must_use)]
 
 fn main() {}
diff --git a/tests/ui/string_add.rs b/tests/ui/string_add.rs
index 20edbe31fa9..de78dfe4d69 100644
--- a/tests/ui/string_add.rs
+++ b/tests/ui/string_add.rs
@@ -1,4 +1,4 @@
-// aux-build:proc_macros.rs
+//@aux-build:proc_macros.rs
 
 extern crate proc_macros;
 use proc_macros::external;
diff --git a/tests/ui/string_add_assign.fixed b/tests/ui/string_add_assign.fixed
index b687f43b254..616c6daaf66 100644
--- a/tests/ui/string_add_assign.fixed
+++ b/tests/ui/string_add_assign.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #[allow(clippy::string_add, unused)]
 #[warn(clippy::string_add_assign)]
diff --git a/tests/ui/string_add_assign.rs b/tests/ui/string_add_assign.rs
index e5dbde108fb..e1f8859757c 100644
--- a/tests/ui/string_add_assign.rs
+++ b/tests/ui/string_add_assign.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #[allow(clippy::string_add, unused)]
 #[warn(clippy::string_add_assign)]
diff --git a/tests/ui/string_extend.fixed b/tests/ui/string_extend.fixed
index d200d7310fc..65c9abff3d4 100644
--- a/tests/ui/string_extend.fixed
+++ b/tests/ui/string_extend.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #[derive(Copy, Clone)]
 struct HasChars;
diff --git a/tests/ui/string_extend.rs b/tests/ui/string_extend.rs
index 0dd96a3b210..5f72ffe2fda 100644
--- a/tests/ui/string_extend.rs
+++ b/tests/ui/string_extend.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #[derive(Copy, Clone)]
 struct HasChars;
diff --git a/tests/ui/string_from_utf8_as_bytes.fixed b/tests/ui/string_from_utf8_as_bytes.fixed
index 6e665cdd563..9b315ae2b55 100644
--- a/tests/ui/string_from_utf8_as_bytes.fixed
+++ b/tests/ui/string_from_utf8_as_bytes.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::string_from_utf8_as_bytes)]
 
 fn main() {
diff --git a/tests/ui/string_from_utf8_as_bytes.rs b/tests/ui/string_from_utf8_as_bytes.rs
index 670d206d367..043dd235082 100644
--- a/tests/ui/string_from_utf8_as_bytes.rs
+++ b/tests/ui/string_from_utf8_as_bytes.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::string_from_utf8_as_bytes)]
 
 fn main() {
diff --git a/tests/ui/string_lit_as_bytes.fixed b/tests/ui/string_lit_as_bytes.fixed
index 506187fc125..058f2aa54da 100644
--- a/tests/ui/string_lit_as_bytes.fixed
+++ b/tests/ui/string_lit_as_bytes.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(dead_code, unused_variables)]
 #![warn(clippy::string_lit_as_bytes)]
diff --git a/tests/ui/string_lit_as_bytes.rs b/tests/ui/string_lit_as_bytes.rs
index 2c339f1ddb8..b550bea001f 100644
--- a/tests/ui/string_lit_as_bytes.rs
+++ b/tests/ui/string_lit_as_bytes.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(dead_code, unused_variables)]
 #![warn(clippy::string_lit_as_bytes)]
diff --git a/tests/ui/strlen_on_c_strings.fixed b/tests/ui/strlen_on_c_strings.fixed
index 947a59bcc02..ef207e28cca 100644
--- a/tests/ui/strlen_on_c_strings.fixed
+++ b/tests/ui/strlen_on_c_strings.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::strlen_on_c_strings)]
 #![allow(dead_code)]
diff --git a/tests/ui/strlen_on_c_strings.rs b/tests/ui/strlen_on_c_strings.rs
index 1237f1ab03a..03ec5f79d09 100644
--- a/tests/ui/strlen_on_c_strings.rs
+++ b/tests/ui/strlen_on_c_strings.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::strlen_on_c_strings)]
 #![allow(dead_code)]
diff --git a/tests/ui/suspicious_doc_comments.fixed b/tests/ui/suspicious_doc_comments.fixed
index b404df94d3c..bffda1cc412 100644
--- a/tests/ui/suspicious_doc_comments.fixed
+++ b/tests/ui/suspicious_doc_comments.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![allow(unused)]
 #![warn(clippy::suspicious_doc_comments)]
 
diff --git a/tests/ui/suspicious_doc_comments.rs b/tests/ui/suspicious_doc_comments.rs
index 46eff51e220..cdd972ee30f 100644
--- a/tests/ui/suspicious_doc_comments.rs
+++ b/tests/ui/suspicious_doc_comments.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![allow(unused)]
 #![warn(clippy::suspicious_doc_comments)]
 
diff --git a/tests/ui/suspicious_else_formatting.rs b/tests/ui/suspicious_else_formatting.rs
index 21753e5dc6a..e0153cdd8cd 100644
--- a/tests/ui/suspicious_else_formatting.rs
+++ b/tests/ui/suspicious_else_formatting.rs
@@ -1,4 +1,4 @@
-// aux-build:proc_macro_suspicious_else_formatting.rs
+//@aux-build:proc_macro_suspicious_else_formatting.rs
 
 #![warn(clippy::suspicious_else_formatting)]
 #![allow(clippy::if_same_then_else, clippy::let_unit_value)]
diff --git a/tests/ui/suspicious_operation_groupings.fixed b/tests/ui/suspicious_operation_groupings.fixed
index ede8a39fed7..0e37701ec48 100644
--- a/tests/ui/suspicious_operation_groupings.fixed
+++ b/tests/ui/suspicious_operation_groupings.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::suspicious_operation_groupings)]
 #![allow(dead_code, unused_parens, clippy::eq_op)]
 
diff --git a/tests/ui/suspicious_operation_groupings.rs b/tests/ui/suspicious_operation_groupings.rs
index 26ce97bb37f..dd4f3b71c37 100644
--- a/tests/ui/suspicious_operation_groupings.rs
+++ b/tests/ui/suspicious_operation_groupings.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::suspicious_operation_groupings)]
 #![allow(dead_code, unused_parens, clippy::eq_op)]
 
diff --git a/tests/ui/swap.fixed b/tests/ui/swap.fixed
index 9703674d1a4..fd3569cf362 100644
--- a/tests/ui/swap.fixed
+++ b/tests/ui/swap.fixed
@@ -1,5 +1,5 @@
-// run-rustfix
-// aux-build: macro_rules.rs
+//@run-rustfix
+//@aux-build: macro_rules.rs
 
 #![warn(clippy::all)]
 #![allow(
diff --git a/tests/ui/swap.rs b/tests/ui/swap.rs
index a0228065e46..34fbce0524b 100644
--- a/tests/ui/swap.rs
+++ b/tests/ui/swap.rs
@@ -1,5 +1,5 @@
-// run-rustfix
-// aux-build: macro_rules.rs
+//@run-rustfix
+//@aux-build: macro_rules.rs
 
 #![warn(clippy::all)]
 #![allow(
diff --git a/tests/ui/swap_ptr_to_ref.fixed b/tests/ui/swap_ptr_to_ref.fixed
index 596b6ee919b..3bede3017a1 100644
--- a/tests/ui/swap_ptr_to_ref.fixed
+++ b/tests/ui/swap_ptr_to_ref.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::swap_ptr_to_ref)]
 
diff --git a/tests/ui/swap_ptr_to_ref.rs b/tests/ui/swap_ptr_to_ref.rs
index 282f571211d..726b09d3764 100644
--- a/tests/ui/swap_ptr_to_ref.rs
+++ b/tests/ui/swap_ptr_to_ref.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::swap_ptr_to_ref)]
 
diff --git a/tests/ui/tabs_in_doc_comments.fixed b/tests/ui/tabs_in_doc_comments.fixed
index 4bc4bc86c76..21020182c24 100644
--- a/tests/ui/tabs_in_doc_comments.fixed
+++ b/tests/ui/tabs_in_doc_comments.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::tabs_in_doc_comments)]
 #[allow(dead_code)]
diff --git a/tests/ui/tabs_in_doc_comments.rs b/tests/ui/tabs_in_doc_comments.rs
index 9db3416e659..df704267dd2 100644
--- a/tests/ui/tabs_in_doc_comments.rs
+++ b/tests/ui/tabs_in_doc_comments.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::tabs_in_doc_comments)]
 #[allow(dead_code)]
diff --git a/tests/ui/tests_outside_test_module.rs b/tests/ui/tests_outside_test_module.rs
index 1982b1d0107..21fdfdf9005 100644
--- a/tests/ui/tests_outside_test_module.rs
+++ b/tests/ui/tests_outside_test_module.rs
@@ -1,4 +1,4 @@
-// compile-flags: --test
+//@compile-flags: --test
 #![allow(unused)]
 #![warn(clippy::tests_outside_test_module)]
 
diff --git a/tests/ui/to_digit_is_some.fixed b/tests/ui/to_digit_is_some.fixed
index 3c5e9642714..dc9be66d48a 100644
--- a/tests/ui/to_digit_is_some.fixed
+++ b/tests/ui/to_digit_is_some.fixed
@@ -1,4 +1,4 @@
-//run-rustfix
+//@run-rustfix
 
 #![warn(clippy::to_digit_is_some)]
 
diff --git a/tests/ui/to_digit_is_some.rs b/tests/ui/to_digit_is_some.rs
index 4f247c06cee..d2a09ac30de 100644
--- a/tests/ui/to_digit_is_some.rs
+++ b/tests/ui/to_digit_is_some.rs
@@ -1,4 +1,4 @@
-//run-rustfix
+//@run-rustfix
 
 #![warn(clippy::to_digit_is_some)]
 
diff --git a/tests/ui/toplevel_ref_arg.fixed b/tests/ui/toplevel_ref_arg.fixed
index 174c858a47d..ea30c1fda6f 100644
--- a/tests/ui/toplevel_ref_arg.fixed
+++ b/tests/ui/toplevel_ref_arg.fixed
@@ -1,5 +1,5 @@
-// run-rustfix
-// aux-build:proc_macros.rs
+//@run-rustfix
+//@aux-build:proc_macros.rs
 #![warn(clippy::toplevel_ref_arg)]
 #![allow(clippy::uninlined_format_args, unused)]
 
diff --git a/tests/ui/toplevel_ref_arg.rs b/tests/ui/toplevel_ref_arg.rs
index 4b81a06112f..7a3d33e5be5 100644
--- a/tests/ui/toplevel_ref_arg.rs
+++ b/tests/ui/toplevel_ref_arg.rs
@@ -1,5 +1,5 @@
-// run-rustfix
-// aux-build:proc_macros.rs
+//@run-rustfix
+//@aux-build:proc_macros.rs
 #![warn(clippy::toplevel_ref_arg)]
 #![allow(clippy::uninlined_format_args, unused)]
 
diff --git a/tests/ui/toplevel_ref_arg_non_rustfix.rs b/tests/ui/toplevel_ref_arg_non_rustfix.rs
index 2047593e7e4..8aaf47b1bd0 100644
--- a/tests/ui/toplevel_ref_arg_non_rustfix.rs
+++ b/tests/ui/toplevel_ref_arg_non_rustfix.rs
@@ -1,4 +1,4 @@
-// aux-build:proc_macros.rs
+//@aux-build:proc_macros.rs
 
 #![warn(clippy::toplevel_ref_arg)]
 #![allow(unused)]
diff --git a/tests/ui/track-diagnostics.rs b/tests/ui/track-diagnostics.rs
index fa9221ed02d..6ab0bce770e 100644
--- a/tests/ui/track-diagnostics.rs
+++ b/tests/ui/track-diagnostics.rs
@@ -1,9 +1,8 @@
-// compile-flags: -Z track-diagnostics
-// error-pattern: created at
+//@compile-flags: -Z track-diagnostics
 
 // Normalize the emitted location so this doesn't need
 // updating everytime someone adds or removes a line.
-// normalize-stderr-test ".rs:\d+:\d+" -> ".rs:LL:CC"
+//@normalize-stderr-test: ".rs:\d+:\d+" -> ".rs:LL:CC"
 
 struct A;
 struct B;
diff --git a/tests/ui/trait_duplication_in_bounds.fixed b/tests/ui/trait_duplication_in_bounds.fixed
index 4ce5d421782..eef8024b131 100644
--- a/tests/ui/trait_duplication_in_bounds.fixed
+++ b/tests/ui/trait_duplication_in_bounds.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![deny(clippy::trait_duplication_in_bounds)]
 #![allow(unused)]
 
diff --git a/tests/ui/trait_duplication_in_bounds.rs b/tests/ui/trait_duplication_in_bounds.rs
index 7f2e96a22e6..a7a1caf2880 100644
--- a/tests/ui/trait_duplication_in_bounds.rs
+++ b/tests/ui/trait_duplication_in_bounds.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![deny(clippy::trait_duplication_in_bounds)]
 #![allow(unused)]
 
diff --git a/tests/ui/transmute_32bit.rs b/tests/ui/transmute_32bit.rs
index ffe22b12f55..8e1316ca39d 100644
--- a/tests/ui/transmute_32bit.rs
+++ b/tests/ui/transmute_32bit.rs
@@ -1,4 +1,4 @@
-// ignore-64bit
+//@ignore-64bit
 
 #[warn(clippy::wrong_transmute)]
 fn main() {
diff --git a/tests/ui/transmute_32bit.stderr b/tests/ui/transmute_32bit.stderr
index 040519564b9..75ddca60d2a 100644
--- a/tests/ui/transmute_32bit.stderr
+++ b/tests/ui/transmute_32bit.stderr
@@ -1,28 +1,39 @@
-error: transmute from a `f32` to a pointer
+error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
   --> $DIR/transmute_32bit.rs:6:31
    |
 LL |         let _: *const usize = std::mem::transmute(6.0f32);
-   |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                               ^^^^^^^^^^^^^^^^^^^
    |
-   = note: `-D clippy::wrong-transmute` implied by `-D warnings`
+   = note: source type: `f32` (32 bits)
+   = note: target type: `*const usize` (64 bits)
 
-error: transmute from a `f32` to a pointer
+error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
   --> $DIR/transmute_32bit.rs:8:29
    |
 LL |         let _: *mut usize = std::mem::transmute(6.0f32);
-   |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                             ^^^^^^^^^^^^^^^^^^^
+   |
+   = note: source type: `f32` (32 bits)
+   = note: target type: `*mut usize` (64 bits)
 
-error: transmute from a `char` to a pointer
+error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
   --> $DIR/transmute_32bit.rs:10:31
    |
 LL |         let _: *const usize = std::mem::transmute('x');
-   |                               ^^^^^^^^^^^^^^^^^^^^^^^^
+   |                               ^^^^^^^^^^^^^^^^^^^
+   |
+   = note: source type: `char` (32 bits)
+   = note: target type: `*const usize` (64 bits)
 
-error: transmute from a `char` to a pointer
+error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
   --> $DIR/transmute_32bit.rs:12:29
    |
 LL |         let _: *mut usize = std::mem::transmute('x');
-   |                             ^^^^^^^^^^^^^^^^^^^^^^^^
+   |                             ^^^^^^^^^^^^^^^^^^^
+   |
+   = note: source type: `char` (32 bits)
+   = note: target type: `*mut usize` (64 bits)
 
 error: aborting due to 4 previous errors
 
+For more information about this error, try `rustc --explain E0512`.
diff --git a/tests/ui/transmute_64bit.rs b/tests/ui/transmute_64bit.rs
index 00dc0b2c360..ceecf9b279f 100644
--- a/tests/ui/transmute_64bit.rs
+++ b/tests/ui/transmute_64bit.rs
@@ -1,4 +1,4 @@
-// ignore-32bit
+//@ignore-32bit
 
 #[warn(clippy::wrong_transmute)]
 fn main() {
diff --git a/tests/ui/transmute_ptr_to_ref.fixed b/tests/ui/transmute_ptr_to_ref.fixed
index 074dae5fb28..575dadde906 100644
--- a/tests/ui/transmute_ptr_to_ref.fixed
+++ b/tests/ui/transmute_ptr_to_ref.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::transmute_ptr_to_ref)]
 #![allow(clippy::match_single_binding)]
diff --git a/tests/ui/transmute_ptr_to_ref.rs b/tests/ui/transmute_ptr_to_ref.rs
index 2edc122cf47..4238ff80478 100644
--- a/tests/ui/transmute_ptr_to_ref.rs
+++ b/tests/ui/transmute_ptr_to_ref.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::transmute_ptr_to_ref)]
 #![allow(clippy::match_single_binding)]
diff --git a/tests/ui/transmutes_expressible_as_ptr_casts.fixed b/tests/ui/transmutes_expressible_as_ptr_casts.fixed
index cc84ba25bd0..05aa86c479a 100644
--- a/tests/ui/transmutes_expressible_as_ptr_casts.fixed
+++ b/tests/ui/transmutes_expressible_as_ptr_casts.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::transmutes_expressible_as_ptr_casts)]
 // These two warnings currently cover the cases transmutes_expressible_as_ptr_casts
 // would otherwise be responsible for
diff --git a/tests/ui/transmutes_expressible_as_ptr_casts.rs b/tests/ui/transmutes_expressible_as_ptr_casts.rs
index aa65ab4dd24..29fa6914cfd 100644
--- a/tests/ui/transmutes_expressible_as_ptr_casts.rs
+++ b/tests/ui/transmutes_expressible_as_ptr_casts.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::transmutes_expressible_as_ptr_casts)]
 // These two warnings currently cover the cases transmutes_expressible_as_ptr_casts
 // would otherwise be responsible for
diff --git a/tests/ui/trim_split_whitespace.fixed b/tests/ui/trim_split_whitespace.fixed
index e4d352f7367..7909b319ddd 100644
--- a/tests/ui/trim_split_whitespace.fixed
+++ b/tests/ui/trim_split_whitespace.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::trim_split_whitespace)]
 #![allow(clippy::let_unit_value)]
 
diff --git a/tests/ui/trim_split_whitespace.rs b/tests/ui/trim_split_whitespace.rs
index f98451a9837..0cf58979fb2 100644
--- a/tests/ui/trim_split_whitespace.rs
+++ b/tests/ui/trim_split_whitespace.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::trim_split_whitespace)]
 #![allow(clippy::let_unit_value)]
 
diff --git a/tests/ui/trivially_copy_pass_by_ref.rs b/tests/ui/trivially_copy_pass_by_ref.rs
index c0af011d33d..48615583156 100644
--- a/tests/ui/trivially_copy_pass_by_ref.rs
+++ b/tests/ui/trivially_copy_pass_by_ref.rs
@@ -1,5 +1,5 @@
-// normalize-stderr-test "\(\d+ byte\)" -> "(N byte)"
-// normalize-stderr-test "\(limit: \d+ byte\)" -> "(limit: N byte)"
+//@normalize-stderr-test: "\(\d+ byte\)" -> "(N byte)"
+//@normalize-stderr-test: "\(limit: \d+ byte\)" -> "(limit: N byte)"
 #![deny(clippy::trivially_copy_pass_by_ref)]
 #![allow(
     clippy::disallowed_names,
diff --git a/tests/ui/try_err.fixed b/tests/ui/try_err.fixed
index dc497b1690f..dc773ad4bad 100644
--- a/tests/ui/try_err.fixed
+++ b/tests/ui/try_err.fixed
@@ -1,5 +1,5 @@
-// run-rustfix
-// aux-build:proc_macros.rs
+//@run-rustfix
+//@aux-build:proc_macros.rs
 
 #![deny(clippy::try_err)]
 #![allow(clippy::unnecessary_wraps, clippy::needless_question_mark)]
diff --git a/tests/ui/try_err.rs b/tests/ui/try_err.rs
index 86aeb75cd96..7a7433a7ec2 100644
--- a/tests/ui/try_err.rs
+++ b/tests/ui/try_err.rs
@@ -1,5 +1,5 @@
-// run-rustfix
-// aux-build:proc_macros.rs
+//@run-rustfix
+//@aux-build:proc_macros.rs
 
 #![deny(clippy::try_err)]
 #![allow(clippy::unnecessary_wraps, clippy::needless_question_mark)]
diff --git a/tests/ui/types.fixed b/tests/ui/types.fixed
index 417da42edf1..4a2616a7a22 100644
--- a/tests/ui/types.fixed
+++ b/tests/ui/types.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(dead_code, unused_variables)]
 #![warn(clippy::cast_lossless)]
diff --git a/tests/ui/types.rs b/tests/ui/types.rs
index b16e9e538b1..5e0917907db 100644
--- a/tests/ui/types.rs
+++ b/tests/ui/types.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(dead_code, unused_variables)]
 #![warn(clippy::cast_lossless)]
diff --git a/tests/ui/unchecked_duration_subtraction.fixed b/tests/ui/unchecked_duration_subtraction.fixed
index a0e49a8beb1..757d1592184 100644
--- a/tests/ui/unchecked_duration_subtraction.fixed
+++ b/tests/ui/unchecked_duration_subtraction.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::unchecked_duration_subtraction)]
 
 use std::time::{Duration, Instant};
diff --git a/tests/ui/unchecked_duration_subtraction.rs b/tests/ui/unchecked_duration_subtraction.rs
index a14a7ea57cc..da7faab6753 100644
--- a/tests/ui/unchecked_duration_subtraction.rs
+++ b/tests/ui/unchecked_duration_subtraction.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::unchecked_duration_subtraction)]
 
 use std::time::{Duration, Instant};
diff --git a/tests/ui/undocumented_unsafe_blocks.rs b/tests/ui/undocumented_unsafe_blocks.rs
index c05eb447b2e..229d150851a 100644
--- a/tests/ui/undocumented_unsafe_blocks.rs
+++ b/tests/ui/undocumented_unsafe_blocks.rs
@@ -1,4 +1,4 @@
-// aux-build:proc_macro_unsafe.rs
+//@aux-build:proc_macro_unsafe.rs
 
 #![warn(clippy::undocumented_unsafe_blocks, clippy::unnecessary_safety_comment)]
 #![allow(clippy::let_unit_value, clippy::missing_safety_doc)]
diff --git a/tests/ui/unicode.fixed b/tests/ui/unicode.fixed
index 94b4723452f..910968afa7f 100644
--- a/tests/ui/unicode.fixed
+++ b/tests/ui/unicode.fixed
@@ -1,5 +1,5 @@
-// run-rustfix
-// compile-flags: --test
+//@run-rustfix
+//@compile-flags: --test
 #![allow(dead_code)]
 
 #[warn(clippy::invisible_characters)]
diff --git a/tests/ui/unicode.rs b/tests/ui/unicode.rs
index 6ad0b255b94..bc4b84d3435 100644
--- a/tests/ui/unicode.rs
+++ b/tests/ui/unicode.rs
@@ -1,5 +1,5 @@
-// run-rustfix
-// compile-flags: --test
+//@run-rustfix
+//@compile-flags: --test
 #![allow(dead_code)]
 
 #[warn(clippy::invisible_characters)]
diff --git a/tests/ui/uninlined_format_args.fixed b/tests/ui/uninlined_format_args.fixed
index 3122081a44f..e25d123dd51 100644
--- a/tests/ui/uninlined_format_args.fixed
+++ b/tests/ui/uninlined_format_args.fixed
@@ -1,5 +1,5 @@
-// aux-build:proc_macros.rs
-// run-rustfix
+//@aux-build:proc_macros.rs
+//@run-rustfix
 #![warn(clippy::uninlined_format_args)]
 #![allow(named_arguments_used_positionally, unused)]
 #![allow(clippy::eq_op, clippy::format_in_format_args, clippy::print_literal)]
diff --git a/tests/ui/uninlined_format_args.rs b/tests/ui/uninlined_format_args.rs
index b153ef256e0..6793ec24441 100644
--- a/tests/ui/uninlined_format_args.rs
+++ b/tests/ui/uninlined_format_args.rs
@@ -1,5 +1,5 @@
-// aux-build:proc_macros.rs
-// run-rustfix
+//@aux-build:proc_macros.rs
+//@run-rustfix
 #![warn(clippy::uninlined_format_args)]
 #![allow(named_arguments_used_positionally, unused)]
 #![allow(clippy::eq_op, clippy::format_in_format_args, clippy::print_literal)]
diff --git a/tests/ui/uninlined_format_args_panic.edition2018.fixed b/tests/ui/uninlined_format_args_panic.edition2018.fixed
index 52b5343c351..559050b3df6 100644
--- a/tests/ui/uninlined_format_args_panic.edition2018.fixed
+++ b/tests/ui/uninlined_format_args_panic.edition2018.fixed
@@ -1,7 +1,7 @@
-// revisions: edition2018 edition2021
-//[edition2018] edition:2018
-//[edition2021] edition:2021
-// run-rustfix
+//@revisions: edition2018 edition2021
+//@[edition2018] edition:2018
+//@[edition2021] edition:2021
+//@run-rustfix
 
 #![warn(clippy::uninlined_format_args)]
 
diff --git a/tests/ui/uninlined_format_args_panic.edition2021.fixed b/tests/ui/uninlined_format_args_panic.edition2021.fixed
index ee72065e28a..3a753b49caf 100644
--- a/tests/ui/uninlined_format_args_panic.edition2021.fixed
+++ b/tests/ui/uninlined_format_args_panic.edition2021.fixed
@@ -1,7 +1,7 @@
-// revisions: edition2018 edition2021
-//[edition2018] edition:2018
-//[edition2021] edition:2021
-// run-rustfix
+//@revisions: edition2018 edition2021
+//@[edition2018] edition:2018
+//@[edition2021] edition:2021
+//@run-rustfix
 
 #![warn(clippy::uninlined_format_args)]
 
diff --git a/tests/ui/uninlined_format_args_panic.rs b/tests/ui/uninlined_format_args_panic.rs
index b4a0a0f496e..83fbb9afd2a 100644
--- a/tests/ui/uninlined_format_args_panic.rs
+++ b/tests/ui/uninlined_format_args_panic.rs
@@ -1,7 +1,7 @@
-// revisions: edition2018 edition2021
-//[edition2018] edition:2018
-//[edition2021] edition:2021
-// run-rustfix
+//@revisions: edition2018 edition2021
+//@[edition2018] edition:2018
+//@[edition2021] edition:2021
+//@run-rustfix
 
 #![warn(clippy::uninlined_format_args)]
 
diff --git a/tests/ui/unit_arg.rs b/tests/ui/unit_arg.rs
index 674ae4f1df9..d082063c8e8 100644
--- a/tests/ui/unit_arg.rs
+++ b/tests/ui/unit_arg.rs
@@ -1,4 +1,4 @@
-// aux-build: proc_macros.rs
+//@aux-build: proc_macros.rs
 #![warn(clippy::unit_arg)]
 #![allow(unused_must_use, unused_variables)]
 #![allow(
diff --git a/tests/ui/unit_arg_empty_blocks.fixed b/tests/ui/unit_arg_empty_blocks.fixed
index 5787471a32c..8c065115a74 100644
--- a/tests/ui/unit_arg_empty_blocks.fixed
+++ b/tests/ui/unit_arg_empty_blocks.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::unit_arg)]
 #![allow(unused_must_use, unused_variables)]
 #![allow(clippy::no_effect, clippy::uninlined_format_args)]
diff --git a/tests/ui/unit_arg_empty_blocks.rs b/tests/ui/unit_arg_empty_blocks.rs
index 6a42c2ccf42..af166b56ff4 100644
--- a/tests/ui/unit_arg_empty_blocks.rs
+++ b/tests/ui/unit_arg_empty_blocks.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::unit_arg)]
 #![allow(unused_must_use, unused_variables)]
 #![allow(clippy::no_effect, clippy::uninlined_format_args)]
diff --git a/tests/ui/unknown_clippy_lints.fixed b/tests/ui/unknown_clippy_lints.fixed
index 4249ff8a958..0c269d650c8 100644
--- a/tests/ui/unknown_clippy_lints.fixed
+++ b/tests/ui/unknown_clippy_lints.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::pedantic)]
 // Should suggest lowercase
diff --git a/tests/ui/unknown_clippy_lints.rs b/tests/ui/unknown_clippy_lints.rs
index 5db345f5444..b60042923ea 100644
--- a/tests/ui/unknown_clippy_lints.rs
+++ b/tests/ui/unknown_clippy_lints.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::pedantic)]
 // Should suggest lowercase
diff --git a/tests/ui/unnecessary_cast.fixed b/tests/ui/unnecessary_cast.fixed
index 2f7e2997e73..bcc231ea7bc 100644
--- a/tests/ui/unnecessary_cast.fixed
+++ b/tests/ui/unnecessary_cast.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::unnecessary_cast)]
 #![allow(
     unused_must_use,
diff --git a/tests/ui/unnecessary_cast.rs b/tests/ui/unnecessary_cast.rs
index 54dd46ba59f..282b2f1283e 100644
--- a/tests/ui/unnecessary_cast.rs
+++ b/tests/ui/unnecessary_cast.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::unnecessary_cast)]
 #![allow(
     unused_must_use,
diff --git a/tests/ui/unnecessary_fold.fixed b/tests/ui/unnecessary_fold.fixed
index 52300a3b640..2bed14973ca 100644
--- a/tests/ui/unnecessary_fold.fixed
+++ b/tests/ui/unnecessary_fold.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(dead_code)]
 
diff --git a/tests/ui/unnecessary_fold.rs b/tests/ui/unnecessary_fold.rs
index 4028d80c0a3..a3cec8ea3d5 100644
--- a/tests/ui/unnecessary_fold.rs
+++ b/tests/ui/unnecessary_fold.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(dead_code)]
 
diff --git a/tests/ui/unnecessary_iter_cloned.fixed b/tests/ui/unnecessary_iter_cloned.fixed
index e01e9f07baf..a0f8dd1a200 100644
--- a/tests/ui/unnecessary_iter_cloned.fixed
+++ b/tests/ui/unnecessary_iter_cloned.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(unused_assignments)]
 #![warn(clippy::unnecessary_to_owned)]
diff --git a/tests/ui/unnecessary_iter_cloned.rs b/tests/ui/unnecessary_iter_cloned.rs
index 6ef2966c8b7..98f2dfe7549 100644
--- a/tests/ui/unnecessary_iter_cloned.rs
+++ b/tests/ui/unnecessary_iter_cloned.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(unused_assignments)]
 #![warn(clippy::unnecessary_to_owned)]
diff --git a/tests/ui/unnecessary_join.fixed b/tests/ui/unnecessary_join.fixed
index 34795396025..e102df62599 100644
--- a/tests/ui/unnecessary_join.fixed
+++ b/tests/ui/unnecessary_join.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::unnecessary_join)]
 #![allow(clippy::uninlined_format_args)]
 
diff --git a/tests/ui/unnecessary_join.rs b/tests/ui/unnecessary_join.rs
index 344918cd2a2..b87c15bc126 100644
--- a/tests/ui/unnecessary_join.rs
+++ b/tests/ui/unnecessary_join.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::unnecessary_join)]
 #![allow(clippy::uninlined_format_args)]
 
diff --git a/tests/ui/unnecessary_lazy_eval.fixed b/tests/ui/unnecessary_lazy_eval.fixed
index 3b93800f8b7..c3728886ec9 100644
--- a/tests/ui/unnecessary_lazy_eval.fixed
+++ b/tests/ui/unnecessary_lazy_eval.fixed
@@ -1,5 +1,5 @@
-// run-rustfix
-// aux-build: proc_macros.rs
+//@run-rustfix
+//@aux-build: proc_macros.rs
 #![warn(clippy::unnecessary_lazy_evaluations)]
 #![allow(clippy::redundant_closure)]
 #![allow(clippy::bind_instead_of_map)]
diff --git a/tests/ui/unnecessary_lazy_eval.rs b/tests/ui/unnecessary_lazy_eval.rs
index 2851c0c5190..76e50fa5b03 100644
--- a/tests/ui/unnecessary_lazy_eval.rs
+++ b/tests/ui/unnecessary_lazy_eval.rs
@@ -1,5 +1,5 @@
-// run-rustfix
-// aux-build: proc_macros.rs
+//@run-rustfix
+//@aux-build: proc_macros.rs
 #![warn(clippy::unnecessary_lazy_evaluations)]
 #![allow(clippy::redundant_closure)]
 #![allow(clippy::bind_instead_of_map)]
diff --git a/tests/ui/unnecessary_operation.fixed b/tests/ui/unnecessary_operation.fixed
index b046694f8c6..fbd2d34591f 100644
--- a/tests/ui/unnecessary_operation.fixed
+++ b/tests/ui/unnecessary_operation.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(
     clippy::deref_addrof,
diff --git a/tests/ui/unnecessary_operation.rs b/tests/ui/unnecessary_operation.rs
index 9ed9679e938..b45298a6dc4 100644
--- a/tests/ui/unnecessary_operation.rs
+++ b/tests/ui/unnecessary_operation.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(
     clippy::deref_addrof,
diff --git a/tests/ui/unnecessary_owned_empty_strings.fixed b/tests/ui/unnecessary_owned_empty_strings.fixed
index 40052c41039..af12fd1d63d 100644
--- a/tests/ui/unnecessary_owned_empty_strings.fixed
+++ b/tests/ui/unnecessary_owned_empty_strings.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::unnecessary_owned_empty_strings)]
 
diff --git a/tests/ui/unnecessary_owned_empty_strings.rs b/tests/ui/unnecessary_owned_empty_strings.rs
index 2304dff5192..a460b21af8c 100644
--- a/tests/ui/unnecessary_owned_empty_strings.rs
+++ b/tests/ui/unnecessary_owned_empty_strings.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::unnecessary_owned_empty_strings)]
 
diff --git a/tests/ui/unnecessary_self_imports.fixed b/tests/ui/unnecessary_self_imports.fixed
index 1185eaa1d55..7fc978d3ef7 100644
--- a/tests/ui/unnecessary_self_imports.fixed
+++ b/tests/ui/unnecessary_self_imports.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::unnecessary_self_imports)]
 #![allow(unused_imports, dead_code)]
 
diff --git a/tests/ui/unnecessary_self_imports.rs b/tests/ui/unnecessary_self_imports.rs
index 56bfbc09402..02424bc12b0 100644
--- a/tests/ui/unnecessary_self_imports.rs
+++ b/tests/ui/unnecessary_self_imports.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::unnecessary_self_imports)]
 #![allow(unused_imports, dead_code)]
 
diff --git a/tests/ui/unnecessary_sort_by.fixed b/tests/ui/unnecessary_sort_by.fixed
index 21e2da474a8..165cabd8298 100644
--- a/tests/ui/unnecessary_sort_by.fixed
+++ b/tests/ui/unnecessary_sort_by.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(clippy::stable_sort_primitive)]
 
diff --git a/tests/ui/unnecessary_sort_by.rs b/tests/ui/unnecessary_sort_by.rs
index 3365bf6e119..8a2158d5a84 100644
--- a/tests/ui/unnecessary_sort_by.rs
+++ b/tests/ui/unnecessary_sort_by.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(clippy::stable_sort_primitive)]
 
diff --git a/tests/ui/unnecessary_struct_initialization.fixed b/tests/ui/unnecessary_struct_initialization.fixed
index b47129e4a36..bdf746cf2c4 100644
--- a/tests/ui/unnecessary_struct_initialization.fixed
+++ b/tests/ui/unnecessary_struct_initialization.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(unused)]
 #![warn(clippy::unnecessary_struct_initialization)]
diff --git a/tests/ui/unnecessary_struct_initialization.rs b/tests/ui/unnecessary_struct_initialization.rs
index 63b11c626e5..7271e2f957a 100644
--- a/tests/ui/unnecessary_struct_initialization.rs
+++ b/tests/ui/unnecessary_struct_initialization.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(unused)]
 #![warn(clippy::unnecessary_struct_initialization)]
diff --git a/tests/ui/unnecessary_to_owned.fixed b/tests/ui/unnecessary_to_owned.fixed
index 345f6d604c4..c879fdc3b6a 100644
--- a/tests/ui/unnecessary_to_owned.fixed
+++ b/tests/ui/unnecessary_to_owned.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(clippy::needless_borrow, clippy::ptr_arg)]
 #![warn(clippy::unnecessary_to_owned)]
diff --git a/tests/ui/unnecessary_to_owned.rs b/tests/ui/unnecessary_to_owned.rs
index 7eb53df39e5..10588beb263 100644
--- a/tests/ui/unnecessary_to_owned.rs
+++ b/tests/ui/unnecessary_to_owned.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(clippy::needless_borrow, clippy::ptr_arg)]
 #![warn(clippy::unnecessary_to_owned)]
diff --git a/tests/ui/unnecessary_unsafety_doc.rs b/tests/ui/unnecessary_unsafety_doc.rs
index 431093ab369..373b18470f6 100644
--- a/tests/ui/unnecessary_unsafety_doc.rs
+++ b/tests/ui/unnecessary_unsafety_doc.rs
@@ -1,4 +1,4 @@
-// aux-build:proc_macros.rs
+//@aux-build:proc_macros.rs
 
 #![allow(clippy::let_unit_value)]
 #![warn(clippy::unnecessary_safety_doc)]
diff --git a/tests/ui/unneeded_wildcard_pattern.fixed b/tests/ui/unneeded_wildcard_pattern.fixed
index 12c3461c955..16c2de760e5 100644
--- a/tests/ui/unneeded_wildcard_pattern.fixed
+++ b/tests/ui/unneeded_wildcard_pattern.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![feature(stmt_expr_attributes)]
 #![deny(clippy::unneeded_wildcard_pattern)]
 
diff --git a/tests/ui/unneeded_wildcard_pattern.rs b/tests/ui/unneeded_wildcard_pattern.rs
index 4ac01d5d23b..9d9eae1d903 100644
--- a/tests/ui/unneeded_wildcard_pattern.rs
+++ b/tests/ui/unneeded_wildcard_pattern.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![feature(stmt_expr_attributes)]
 #![deny(clippy::unneeded_wildcard_pattern)]
 
diff --git a/tests/ui/unnested_or_patterns.fixed b/tests/ui/unnested_or_patterns.fixed
index 0a8e7b34dfa..8ec35ba4eea 100644
--- a/tests/ui/unnested_or_patterns.fixed
+++ b/tests/ui/unnested_or_patterns.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![feature(box_patterns)]
 #![warn(clippy::unnested_or_patterns)]
diff --git a/tests/ui/unnested_or_patterns.rs b/tests/ui/unnested_or_patterns.rs
index 2c454adfe89..efdb91b2402 100644
--- a/tests/ui/unnested_or_patterns.rs
+++ b/tests/ui/unnested_or_patterns.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![feature(box_patterns)]
 #![warn(clippy::unnested_or_patterns)]
diff --git a/tests/ui/unnested_or_patterns2.fixed b/tests/ui/unnested_or_patterns2.fixed
index d3539d79815..de40e936747 100644
--- a/tests/ui/unnested_or_patterns2.fixed
+++ b/tests/ui/unnested_or_patterns2.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![feature(box_patterns)]
 #![warn(clippy::unnested_or_patterns)]
diff --git a/tests/ui/unnested_or_patterns2.rs b/tests/ui/unnested_or_patterns2.rs
index 9cea5cdea69..87f66d26c46 100644
--- a/tests/ui/unnested_or_patterns2.rs
+++ b/tests/ui/unnested_or_patterns2.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![feature(box_patterns)]
 #![warn(clippy::unnested_or_patterns)]
diff --git a/tests/ui/unreadable_literal.fixed b/tests/ui/unreadable_literal.fixed
index 13e5feb1926..f5e87648a23 100644
--- a/tests/ui/unreadable_literal.fixed
+++ b/tests/ui/unreadable_literal.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::unreadable_literal)]
 #![allow(unused_tuple_struct_fields)]
diff --git a/tests/ui/unreadable_literal.rs b/tests/ui/unreadable_literal.rs
index 82f04e7ced5..426bdf7d732 100644
--- a/tests/ui/unreadable_literal.rs
+++ b/tests/ui/unreadable_literal.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::unreadable_literal)]
 #![allow(unused_tuple_struct_fields)]
diff --git a/tests/ui/unseparated_prefix_literals.fixed b/tests/ui/unseparated_prefix_literals.fixed
index f0c2ba7ccdf..b6241612d9d 100644
--- a/tests/ui/unseparated_prefix_literals.fixed
+++ b/tests/ui/unseparated_prefix_literals.fixed
@@ -1,5 +1,5 @@
-// run-rustfix
-// aux-build:proc_macro_derive.rs
+//@run-rustfix
+//@aux-build:proc_macro_derive.rs
 
 #![warn(clippy::unseparated_literal_suffix)]
 #![allow(dead_code)]
diff --git a/tests/ui/unseparated_prefix_literals.rs b/tests/ui/unseparated_prefix_literals.rs
index f44880b4147..ae583f4bde3 100644
--- a/tests/ui/unseparated_prefix_literals.rs
+++ b/tests/ui/unseparated_prefix_literals.rs
@@ -1,5 +1,5 @@
-// run-rustfix
-// aux-build:proc_macro_derive.rs
+//@run-rustfix
+//@aux-build:proc_macro_derive.rs
 
 #![warn(clippy::unseparated_literal_suffix)]
 #![allow(dead_code)]
diff --git a/tests/ui/unused_rounding.fixed b/tests/ui/unused_rounding.fixed
index f6f734c05ed..f02b55502a0 100644
--- a/tests/ui/unused_rounding.fixed
+++ b/tests/ui/unused_rounding.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::unused_rounding)]
 
 fn main() {
diff --git a/tests/ui/unused_rounding.rs b/tests/ui/unused_rounding.rs
index a0267d8144a..c7bd4906d0b 100644
--- a/tests/ui/unused_rounding.rs
+++ b/tests/ui/unused_rounding.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::unused_rounding)]
 
 fn main() {
diff --git a/tests/ui/unused_unit.fixed b/tests/ui/unused_unit.fixed
index 3dd640b86f0..7b8f7847dbf 100644
--- a/tests/ui/unused_unit.fixed
+++ b/tests/ui/unused_unit.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 // The output for humans should just highlight the whole span without showing
 // the suggested replacement, but we also want to test that suggested
diff --git a/tests/ui/unused_unit.rs b/tests/ui/unused_unit.rs
index bddecf06fb7..fdde1ecadf0 100644
--- a/tests/ui/unused_unit.rs
+++ b/tests/ui/unused_unit.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 // The output for humans should just highlight the whole span without showing
 // the suggested replacement, but we also want to test that suggested
diff --git a/tests/ui/unwrap_or_else_default.fixed b/tests/ui/unwrap_or_else_default.fixed
index 84f779569ff..59a0ca3f192 100644
--- a/tests/ui/unwrap_or_else_default.fixed
+++ b/tests/ui/unwrap_or_else_default.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::unwrap_or_else_default)]
 #![allow(dead_code)]
diff --git a/tests/ui/unwrap_or_else_default.rs b/tests/ui/unwrap_or_else_default.rs
index 1735bd5808e..97cafa336ed 100644
--- a/tests/ui/unwrap_or_else_default.rs
+++ b/tests/ui/unwrap_or_else_default.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::unwrap_or_else_default)]
 #![allow(dead_code)]
diff --git a/tests/ui/use_self.fixed b/tests/ui/use_self.fixed
index 3ac6217312a..89ea14759b7 100644
--- a/tests/ui/use_self.fixed
+++ b/tests/ui/use_self.fixed
@@ -1,5 +1,5 @@
-// run-rustfix
-// aux-build:proc_macro_derive.rs
+//@run-rustfix
+//@aux-build:proc_macro_derive.rs
 
 #![warn(clippy::use_self)]
 #![allow(dead_code, unreachable_code)]
diff --git a/tests/ui/use_self.rs b/tests/ui/use_self.rs
index 9dc5d1e3f9b..49e5bcb7ed9 100644
--- a/tests/ui/use_self.rs
+++ b/tests/ui/use_self.rs
@@ -1,5 +1,5 @@
-// run-rustfix
-// aux-build:proc_macro_derive.rs
+//@run-rustfix
+//@aux-build:proc_macro_derive.rs
 
 #![warn(clippy::use_self)]
 #![allow(dead_code, unreachable_code)]
diff --git a/tests/ui/use_self_trait.fixed b/tests/ui/use_self_trait.fixed
index 4e779308d02..4623aeeb0eb 100644
--- a/tests/ui/use_self_trait.fixed
+++ b/tests/ui/use_self_trait.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::use_self)]
 #![allow(dead_code)]
diff --git a/tests/ui/use_self_trait.rs b/tests/ui/use_self_trait.rs
index 325dc73b21e..d7d76dd9623 100644
--- a/tests/ui/use_self_trait.rs
+++ b/tests/ui/use_self_trait.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![warn(clippy::use_self)]
 #![allow(dead_code)]
diff --git a/tests/ui/used_underscore_binding.rs b/tests/ui/used_underscore_binding.rs
index 8c29e15b145..c672eff1c27 100644
--- a/tests/ui/used_underscore_binding.rs
+++ b/tests/ui/used_underscore_binding.rs
@@ -1,4 +1,4 @@
-// aux-build:proc_macro_derive.rs
+//@aux-build:proc_macro_derive.rs
 #![feature(rustc_private)]
 #![warn(clippy::all)]
 #![warn(clippy::used_underscore_binding)]
diff --git a/tests/ui/useless_asref.fixed b/tests/ui/useless_asref.fixed
index 38e4b9201e6..490d36ae6d6 100644
--- a/tests/ui/useless_asref.fixed
+++ b/tests/ui/useless_asref.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![deny(clippy::useless_asref)]
 #![allow(clippy::explicit_auto_deref, clippy::uninlined_format_args)]
 
diff --git a/tests/ui/useless_asref.rs b/tests/ui/useless_asref.rs
index f1e83f9d396..f2681af924d 100644
--- a/tests/ui/useless_asref.rs
+++ b/tests/ui/useless_asref.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![deny(clippy::useless_asref)]
 #![allow(clippy::explicit_auto_deref, clippy::uninlined_format_args)]
 
diff --git a/tests/ui/useless_attribute.fixed b/tests/ui/useless_attribute.fixed
index 871e4fb5c3a..de6660c95e6 100644
--- a/tests/ui/useless_attribute.fixed
+++ b/tests/ui/useless_attribute.fixed
@@ -1,5 +1,5 @@
-// run-rustfix
-// aux-build:proc_macro_derive.rs
+//@run-rustfix
+//@aux-build:proc_macro_derive.rs
 
 #![allow(unused)]
 #![warn(clippy::useless_attribute)]
diff --git a/tests/ui/useless_attribute.rs b/tests/ui/useless_attribute.rs
index cb50736ba39..8de4331e8a6 100644
--- a/tests/ui/useless_attribute.rs
+++ b/tests/ui/useless_attribute.rs
@@ -1,5 +1,5 @@
-// run-rustfix
-// aux-build:proc_macro_derive.rs
+//@run-rustfix
+//@aux-build:proc_macro_derive.rs
 
 #![allow(unused)]
 #![warn(clippy::useless_attribute)]
diff --git a/tests/ui/useless_conversion.fixed b/tests/ui/useless_conversion.fixed
index 94b206d8e58..01eb6c5b080 100644
--- a/tests/ui/useless_conversion.fixed
+++ b/tests/ui/useless_conversion.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![deny(clippy::useless_conversion)]
 #![allow(clippy::unnecessary_wraps)]
diff --git a/tests/ui/useless_conversion.rs b/tests/ui/useless_conversion.rs
index c7ae927941b..34b43a6299b 100644
--- a/tests/ui/useless_conversion.rs
+++ b/tests/ui/useless_conversion.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![deny(clippy::useless_conversion)]
 #![allow(clippy::unnecessary_wraps)]
diff --git a/tests/ui/vec.fixed b/tests/ui/vec.fixed
index 2518d804915..d77a4dd8e0b 100644
--- a/tests/ui/vec.fixed
+++ b/tests/ui/vec.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::useless_vec)]
 #![allow(clippy::nonstandard_macro_braces, clippy::uninlined_format_args)]
 
diff --git a/tests/ui/vec.rs b/tests/ui/vec.rs
index e1492e2f3ae..dfed3a29a03 100644
--- a/tests/ui/vec.rs
+++ b/tests/ui/vec.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::useless_vec)]
 #![allow(clippy::nonstandard_macro_braces, clippy::uninlined_format_args)]
 
diff --git a/tests/ui/vec_box_sized.fixed b/tests/ui/vec_box_sized.fixed
index a40d91fdb18..0d0f710b558 100644
--- a/tests/ui/vec_box_sized.fixed
+++ b/tests/ui/vec_box_sized.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(dead_code)]
 
diff --git a/tests/ui/vec_box_sized.rs b/tests/ui/vec_box_sized.rs
index 843bbb64e71..fd3a7543ee1 100644
--- a/tests/ui/vec_box_sized.rs
+++ b/tests/ui/vec_box_sized.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(dead_code)]
 
diff --git a/tests/ui/while_let_on_iterator.fixed b/tests/ui/while_let_on_iterator.fixed
index 5afa0a89f82..c2f216a8911 100644
--- a/tests/ui/while_let_on_iterator.fixed
+++ b/tests/ui/while_let_on_iterator.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::while_let_on_iterator)]
 #![allow(dead_code, unreachable_code, unused_mut)]
 #![allow(
diff --git a/tests/ui/while_let_on_iterator.rs b/tests/ui/while_let_on_iterator.rs
index 3de586c9d8f..971bd5f0c4a 100644
--- a/tests/ui/while_let_on_iterator.rs
+++ b/tests/ui/while_let_on_iterator.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 #![warn(clippy::while_let_on_iterator)]
 #![allow(dead_code, unreachable_code, unused_mut)]
 #![allow(
diff --git a/tests/ui/wildcard_enum_match_arm.fixed b/tests/ui/wildcard_enum_match_arm.fixed
index 293bf75a717..ccb40acfbe1 100644
--- a/tests/ui/wildcard_enum_match_arm.fixed
+++ b/tests/ui/wildcard_enum_match_arm.fixed
@@ -1,5 +1,5 @@
-// run-rustfix
-// aux-build:non-exhaustive-enum.rs
+//@run-rustfix
+//@aux-build:non-exhaustive-enum.rs
 #![deny(clippy::wildcard_enum_match_arm)]
 #![allow(dead_code, unreachable_code, unused_variables)]
 #![allow(
diff --git a/tests/ui/wildcard_enum_match_arm.rs b/tests/ui/wildcard_enum_match_arm.rs
index decd86165f3..3ce00b021a5 100644
--- a/tests/ui/wildcard_enum_match_arm.rs
+++ b/tests/ui/wildcard_enum_match_arm.rs
@@ -1,5 +1,5 @@
-// run-rustfix
-// aux-build:non-exhaustive-enum.rs
+//@run-rustfix
+//@aux-build:non-exhaustive-enum.rs
 #![deny(clippy::wildcard_enum_match_arm)]
 #![allow(dead_code, unreachable_code, unused_variables)]
 #![allow(
diff --git a/tests/ui/wildcard_imports.fixed b/tests/ui/wildcard_imports.fixed
index 0baec6f0b64..bd845361fa8 100644
--- a/tests/ui/wildcard_imports.fixed
+++ b/tests/ui/wildcard_imports.fixed
@@ -1,6 +1,6 @@
-// edition:2015
-// run-rustfix
-// aux-build:wildcard_imports_helper.rs
+//@edition:2015
+//@run-rustfix
+//@aux-build:wildcard_imports_helper.rs
 
 // the 2015 edition here is needed because edition 2018 changed the module system
 // (see https://doc.rust-lang.org/edition-guide/rust-2018/path-changes.html) which means the lint
diff --git a/tests/ui/wildcard_imports.rs b/tests/ui/wildcard_imports.rs
index db591d56ab4..fb51f7bdfcc 100644
--- a/tests/ui/wildcard_imports.rs
+++ b/tests/ui/wildcard_imports.rs
@@ -1,6 +1,6 @@
-// edition:2015
-// run-rustfix
-// aux-build:wildcard_imports_helper.rs
+//@edition:2015
+//@run-rustfix
+//@aux-build:wildcard_imports_helper.rs
 
 // the 2015 edition here is needed because edition 2018 changed the module system
 // (see https://doc.rust-lang.org/edition-guide/rust-2018/path-changes.html) which means the lint
diff --git a/tests/ui/wildcard_imports_2021.edition2018.fixed b/tests/ui/wildcard_imports_2021.edition2018.fixed
index 6d534a10edc..3aea013fb3a 100644
--- a/tests/ui/wildcard_imports_2021.edition2018.fixed
+++ b/tests/ui/wildcard_imports_2021.edition2018.fixed
@@ -1,8 +1,8 @@
-// revisions: edition2018 edition2021
-//[edition2018] edition:2018
-//[edition2021] edition:2021
-// run-rustfix
-// aux-build:wildcard_imports_helper.rs
+//@revisions: edition2018 edition2021
+//@[edition2018] edition:2018
+//@[edition2021] edition:2021
+//@run-rustfix
+//@aux-build:wildcard_imports_helper.rs
 
 #![warn(clippy::wildcard_imports)]
 #![allow(unused, clippy::unnecessary_wraps, clippy::let_unit_value)]
diff --git a/tests/ui/wildcard_imports_2021.edition2021.fixed b/tests/ui/wildcard_imports_2021.edition2021.fixed
index 6d534a10edc..3aea013fb3a 100644
--- a/tests/ui/wildcard_imports_2021.edition2021.fixed
+++ b/tests/ui/wildcard_imports_2021.edition2021.fixed
@@ -1,8 +1,8 @@
-// revisions: edition2018 edition2021
-//[edition2018] edition:2018
-//[edition2021] edition:2021
-// run-rustfix
-// aux-build:wildcard_imports_helper.rs
+//@revisions: edition2018 edition2021
+//@[edition2018] edition:2018
+//@[edition2021] edition:2021
+//@run-rustfix
+//@aux-build:wildcard_imports_helper.rs
 
 #![warn(clippy::wildcard_imports)]
 #![allow(unused, clippy::unnecessary_wraps, clippy::let_unit_value)]
diff --git a/tests/ui/wildcard_imports_2021.rs b/tests/ui/wildcard_imports_2021.rs
index b5ed58e6813..40c2d07527d 100644
--- a/tests/ui/wildcard_imports_2021.rs
+++ b/tests/ui/wildcard_imports_2021.rs
@@ -1,8 +1,8 @@
-// revisions: edition2018 edition2021
-//[edition2018] edition:2018
-//[edition2021] edition:2021
-// run-rustfix
-// aux-build:wildcard_imports_helper.rs
+//@revisions: edition2018 edition2021
+//@[edition2018] edition:2018
+//@[edition2021] edition:2021
+//@run-rustfix
+//@aux-build:wildcard_imports_helper.rs
 
 #![warn(clippy::wildcard_imports)]
 #![allow(unused, clippy::unnecessary_wraps, clippy::let_unit_value)]
diff --git a/tests/ui/wildcard_imports_2021.stderr b/tests/ui/wildcard_imports_2021.stderr
deleted file mode 100644
index 92f6d31530f..00000000000
--- a/tests/ui/wildcard_imports_2021.stderr
+++ /dev/null
@@ -1,132 +0,0 @@
-error: usage of wildcard import
-  --> $DIR/wildcard_imports_2021.rs:9:5
-   |
-LL | use crate::fn_mod::*;
-   |     ^^^^^^^^^^^^^^^^ help: try: `crate::fn_mod::foo`
-   |
-   = note: `-D clippy::wildcard-imports` implied by `-D warnings`
-
-error: usage of wildcard import
-  --> $DIR/wildcard_imports_2021.rs:10:5
-   |
-LL | use crate::mod_mod::*;
-   |     ^^^^^^^^^^^^^^^^^ help: try: `crate::mod_mod::inner_mod`
-
-error: usage of wildcard import
-  --> $DIR/wildcard_imports_2021.rs:11:5
-   |
-LL | use crate::multi_fn_mod::*;
-   |     ^^^^^^^^^^^^^^^^^^^^^^ help: try: `crate::multi_fn_mod::{multi_bar, multi_foo, multi_inner_mod}`
-
-error: usage of wildcard import
-  --> $DIR/wildcard_imports_2021.rs:12:5
-   |
-LL | use crate::struct_mod::*;
-   |     ^^^^^^^^^^^^^^^^^^^^ help: try: `crate::struct_mod::{A, inner_struct_mod}`
-
-error: usage of wildcard import
-  --> $DIR/wildcard_imports_2021.rs:15:5
-   |
-LL | use wildcard_imports_helper::inner::inner_for_self_import::*;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `wildcard_imports_helper::inner::inner_for_self_import::inner_extern_bar`
-
-error: usage of wildcard import
-  --> $DIR/wildcard_imports_2021.rs:17:5
-   |
-LL | use wildcard_imports_helper::*;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `wildcard_imports_helper::{ExternA, extern_foo}`
-
-error: usage of wildcard import
-  --> $DIR/wildcard_imports_2021.rs:87:13
-   |
-LL |         use crate::fn_mod::*;
-   |             ^^^^^^^^^^^^^^^^ help: try: `crate::fn_mod::foo`
-
-error: usage of wildcard import
-  --> $DIR/wildcard_imports_2021.rs:93:75
-   |
-LL |         use wildcard_imports_helper::inner::inner_for_self_import::{self, *};
-   |                                                                           ^ help: try: `inner_extern_foo`
-
-error: usage of wildcard import
-  --> $DIR/wildcard_imports_2021.rs:94:13
-   |
-LL |         use wildcard_imports_helper::*;
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `wildcard_imports_helper::{ExternA, extern_foo}`
-
-error: usage of wildcard import
-  --> $DIR/wildcard_imports_2021.rs:105:20
-   |
-LL |         use self::{inner::*, inner2::*};
-   |                    ^^^^^^^^ help: try: `inner::inner_foo`
-
-error: usage of wildcard import
-  --> $DIR/wildcard_imports_2021.rs:105:30
-   |
-LL |         use self::{inner::*, inner2::*};
-   |                              ^^^^^^^^^ help: try: `inner2::inner_bar`
-
-error: usage of wildcard import
-  --> $DIR/wildcard_imports_2021.rs:112:13
-   |
-LL |         use wildcard_imports_helper::*;
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `wildcard_imports_helper::{ExternExportedEnum, ExternExportedStruct, extern_exported}`
-
-error: usage of wildcard import
-  --> $DIR/wildcard_imports_2021.rs:141:9
-   |
-LL |     use crate::in_fn_test::*;
-   |         ^^^^^^^^^^^^^^^^^^^^ help: try: `crate::in_fn_test::{ExportedEnum, ExportedStruct, exported}`
-
-error: usage of wildcard import
-  --> $DIR/wildcard_imports_2021.rs:150:9
-   |
-LL |     use crate:: in_fn_test::  * ;
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `crate:: in_fn_test::exported`
-
-error: usage of wildcard import
-  --> $DIR/wildcard_imports_2021.rs:151:9
-   |
-LL |       use crate:: fn_mod::
-   |  _________^
-LL | |         *;
-   | |_________^ help: try: `crate:: fn_mod::foo`
-
-error: usage of wildcard import
-  --> $DIR/wildcard_imports_2021.rs:162:13
-   |
-LL |         use super::*;
-   |             ^^^^^^^^ help: try: `super::foofoo`
-
-error: usage of wildcard import
-  --> $DIR/wildcard_imports_2021.rs:197:17
-   |
-LL |             use super::*;
-   |                 ^^^^^^^^ help: try: `super::insidefoo`
-
-error: usage of wildcard import
-  --> $DIR/wildcard_imports_2021.rs:205:13
-   |
-LL |         use crate::super_imports::*;
-   |             ^^^^^^^^^^^^^^^^^^^^^^^ help: try: `crate::super_imports::foofoo`
-
-error: usage of wildcard import
-  --> $DIR/wildcard_imports_2021.rs:214:17
-   |
-LL |             use super::super::*;
-   |                 ^^^^^^^^^^^^^^^ help: try: `super::super::foofoo`
-
-error: usage of wildcard import
-  --> $DIR/wildcard_imports_2021.rs:223:13
-   |
-LL |         use super::super::super_imports::*;
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `super::super::super_imports::foofoo`
-
-error: usage of wildcard import
-  --> $DIR/wildcard_imports_2021.rs:231:13
-   |
-LL |         use super::*;
-   |             ^^^^^^^^ help: try: `super::foofoo`
-
-error: aborting due to 21 previous errors
-
diff --git a/tests/ui/write_with_newline.rs b/tests/ui/write_with_newline.rs
index b79364c8758..35bd9e7f3a0 100644
--- a/tests/ui/write_with_newline.rs
+++ b/tests/ui/write_with_newline.rs
@@ -1,5 +1,5 @@
 // FIXME: Ideally these suggestions would be fixed via rustfix. Blocked by rust-lang/rust#53934
-// // run-rustfix
+//
 
 #![allow(clippy::write_literal)]
 #![warn(clippy::write_with_newline)]
@@ -54,7 +54,7 @@ fn main() {
     // Don't warn on CRLF (#4208)
     write!(v, "\r\n");
     write!(v, "foo\r\n");
-    write!(v, "\\r\n"); //~ ERROR
+    write!(v, "\\r\n");
     write!(v, "foo\rbar\n");
 
     // Ignore expanded format strings
diff --git a/tests/ui/write_with_newline.stderr b/tests/ui/write_with_newline.stderr
index 2baaea166d8..9035275b29d 100644
--- a/tests/ui/write_with_newline.stderr
+++ b/tests/ui/write_with_newline.stderr
@@ -106,13 +106,13 @@ LL ~         v
 error: using `write!()` with a format string that ends in a single newline
   --> $DIR/write_with_newline.rs:57:5
    |
-LL |     write!(v, "/r/n"); //~ ERROR
+LL |     write!(v, "/r/n");
    |     ^^^^^^^^^^^^^^^^^^
    |
 help: use `writeln!` instead
    |
-LL -     write!(v, "/r/n"); //~ ERROR
-LL +     writeln!(v, "/r"); //~ ERROR
+LL -     write!(v, "/r/n");
+LL +     writeln!(v, "/r");
    |
 
 error: aborting due to 9 previous errors
diff --git a/tests/ui/writeln_empty_string.fixed b/tests/ui/writeln_empty_string.fixed
index e7d94acd130..45dedd9ead6 100644
--- a/tests/ui/writeln_empty_string.fixed
+++ b/tests/ui/writeln_empty_string.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(unused_must_use)]
 #![warn(clippy::writeln_empty_string)]
diff --git a/tests/ui/writeln_empty_string.rs b/tests/ui/writeln_empty_string.rs
index 662c62f0211..3b9f51a15d2 100644
--- a/tests/ui/writeln_empty_string.rs
+++ b/tests/ui/writeln_empty_string.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![allow(unused_must_use)]
 #![warn(clippy::writeln_empty_string)]
diff --git a/tests/ui/zero_ptr.fixed b/tests/ui/zero_ptr.fixed
index 489aa4121a3..bed38ecafc7 100644
--- a/tests/ui/zero_ptr.fixed
+++ b/tests/ui/zero_ptr.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 pub fn foo(_const: *const f32, _mut: *mut i64) {}
 
 fn main() {
diff --git a/tests/ui/zero_ptr.rs b/tests/ui/zero_ptr.rs
index c3b55ef9ebd..b7b778915a8 100644
--- a/tests/ui/zero_ptr.rs
+++ b/tests/ui/zero_ptr.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 pub fn foo(_const: *const f32, _mut: *mut i64) {}
 
 fn main() {
diff --git a/tests/ui/zero_ptr_no_std.fixed b/tests/ui/zero_ptr_no_std.fixed
index 8906c776977..7afd80ccaca 100644
--- a/tests/ui/zero_ptr_no_std.fixed
+++ b/tests/ui/zero_ptr_no_std.fixed
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![feature(lang_items, start, libc)]
 #![no_std]
diff --git a/tests/ui/zero_ptr_no_std.rs b/tests/ui/zero_ptr_no_std.rs
index 379c1b18d29..05a0587d22b 100644
--- a/tests/ui/zero_ptr_no_std.rs
+++ b/tests/ui/zero_ptr_no_std.rs
@@ -1,4 +1,4 @@
-// run-rustfix
+//@run-rustfix
 
 #![feature(lang_items, start, libc)]
 #![no_std]
-- 
cgit 1.4.1-3-g733a5


From 0b16f80c40f650cb5929b2405fd269c62752a8fa Mon Sep 17 00:00:00 2001
From: Caio <c410.f3r@gmail.com>
Date: Thu, 20 Apr 2023 14:59:02 -0300
Subject: [arithmetic_side_effects] Cache symbols

---
 clippy_lints/src/operators/arithmetic_side_effects.rs | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/operators/arithmetic_side_effects.rs b/clippy_lints/src/operators/arithmetic_side_effects.rs
index 2e3925f53dd..fafcf257094 100644
--- a/clippy_lints/src/operators/arithmetic_side_effects.rs
+++ b/clippy_lints/src/operators/arithmetic_side_effects.rs
@@ -11,7 +11,10 @@ use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::Ty;
 use rustc_session::impl_lint_pass;
-use rustc_span::source_map::{Span, Spanned};
+use rustc_span::{
+    source_map::{Span, Spanned},
+    Symbol,
+};
 
 const HARD_CODED_ALLOWED_BINARY: &[[&str; 2]] = &[
     ["f32", "f32"],
@@ -21,6 +24,7 @@ const HARD_CODED_ALLOWED_BINARY: &[[&str; 2]] = &[
     ["std::string::String", "&str"],
 ];
 const HARD_CODED_ALLOWED_UNARY: &[&str] = &["f32", "f64", "std::num::Saturating", "std::num::Wrapping"];
+const INTEGER_METHODS: &[&str] = &["saturating_div", "wrapping_div", "wrapping_rem", "wrapping_rem_euclid"];
 
 #[derive(Debug)]
 pub struct ArithmeticSideEffects {
@@ -29,6 +33,7 @@ pub struct ArithmeticSideEffects {
     // Used to check whether expressions are constants, such as in enum discriminants and consts
     const_span: Option<Span>,
     expr_span: Option<Span>,
+    integer_methods: FxHashSet<Symbol>,
 }
 
 impl_lint_pass!(ArithmeticSideEffects => [ARITHMETIC_SIDE_EFFECTS]);
@@ -54,6 +59,7 @@ impl ArithmeticSideEffects {
             allowed_unary,
             const_span: None,
             expr_span: None,
+            integer_methods: INTEGER_METHODS.iter().map(|el| Symbol::intern(el)).collect(),
         }
     }
 
@@ -194,7 +200,6 @@ impl ArithmeticSideEffects {
         ps: &hir::PathSegment<'tcx>,
         receiver: &hir::Expr<'tcx>,
     ) {
-        const METHODS: &[&str] = &["saturating_div", "wrapping_div", "wrapping_rem", "wrapping_rem_euclid"];
         let Some(arg) = args.first() else { return; };
         if constant_simple(cx, cx.typeck_results(), receiver).is_some() {
             return;
@@ -203,7 +208,7 @@ impl ArithmeticSideEffects {
         if !Self::is_integral(instance_ty) {
             return;
         }
-        if METHODS.iter().copied().all(|method| method != ps.ident.as_str()) {
+        if !self.integer_methods.contains(&ps.ident.name) {
             return;
         }
         let (actual_arg, _) = peel_hir_expr_refs(arg);
-- 
cgit 1.4.1-3-g733a5


From 7077bde9d2d08e8f93025b457f1d158eeca92c4e Mon Sep 17 00:00:00 2001
From: Arpad Borsos <swatinem@swatinem.de>
Date: Thu, 20 Apr 2023 20:59:59 +0200
Subject: Fix typo in significant_drop_tightening

---
 clippy_lints/src/significant_drop_tightening.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/significant_drop_tightening.rs b/clippy_lints/src/significant_drop_tightening.rs
index 003c5e7d151..b930b2c8dd7 100644
--- a/clippy_lints/src/significant_drop_tightening.rs
+++ b/clippy_lints/src/significant_drop_tightening.rs
@@ -17,7 +17,7 @@ use rustc_span::{symbol::Ident, Span, DUMMY_SP};
 declare_clippy_lint! {
     /// ### What it does
     ///
-    /// Searches for elements marked with `#[clippy::significant_drop]` that could be early
+    /// Searches for elements marked with `#[clippy::has_significant_drop]` that could be early
     /// dropped but are in fact dropped at the end of their scopes. In other words, enforces the
     /// "tightening" of their possible lifetimes.
     ///
-- 
cgit 1.4.1-3-g733a5


From b8d6964bcef97da4641d19be59d30814e2a38b9c Mon Sep 17 00:00:00 2001
From: J-ZhengLi <lizheng135@huawei.com>
Date: Fri, 21 Apr 2023 16:56:17 +0800
Subject: make [`len_zero`] lint not spanning over parenthesis

---
 clippy_lints/src/len_zero.rs | 22 ++++++++++++----------
 tests/ui/len_zero.fixed      |  4 ++++
 tests/ui/len_zero.rs         |  4 ++++
 tests/ui/len_zero.stderr     | 16 ++++++++++++++--
 4 files changed, 34 insertions(+), 12 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/len_zero.rs b/clippy_lints/src/len_zero.rs
index 0805b4b1979..fec9c6f626c 100644
--- a/clippy_lints/src/len_zero.rs
+++ b/clippy_lints/src/len_zero.rs
@@ -168,25 +168,27 @@ impl<'tcx> LateLintPass<'tcx> for LenZero {
         }
 
         if let ExprKind::Binary(Spanned { node: cmp, .. }, left, right) = expr.kind {
+            // expr.span might contains parenthesis, see issue #10529
+            let actual_span = left.span.with_hi(right.span.hi());
             match cmp {
                 BinOpKind::Eq => {
-                    check_cmp(cx, expr.span, left, right, "", 0); // len == 0
-                    check_cmp(cx, expr.span, right, left, "", 0); // 0 == len
+                    check_cmp(cx, actual_span, left, right, "", 0); // len == 0
+                    check_cmp(cx, actual_span, right, left, "", 0); // 0 == len
                 },
                 BinOpKind::Ne => {
-                    check_cmp(cx, expr.span, left, right, "!", 0); // len != 0
-                    check_cmp(cx, expr.span, right, left, "!", 0); // 0 != len
+                    check_cmp(cx, actual_span, left, right, "!", 0); // len != 0
+                    check_cmp(cx, actual_span, right, left, "!", 0); // 0 != len
                 },
                 BinOpKind::Gt => {
-                    check_cmp(cx, expr.span, left, right, "!", 0); // len > 0
-                    check_cmp(cx, expr.span, right, left, "", 1); // 1 > len
+                    check_cmp(cx, actual_span, left, right, "!", 0); // len > 0
+                    check_cmp(cx, actual_span, right, left, "", 1); // 1 > len
                 },
                 BinOpKind::Lt => {
-                    check_cmp(cx, expr.span, left, right, "", 1); // len < 1
-                    check_cmp(cx, expr.span, right, left, "!", 0); // 0 < len
+                    check_cmp(cx, actual_span, left, right, "", 1); // len < 1
+                    check_cmp(cx, actual_span, right, left, "!", 0); // 0 < len
                 },
-                BinOpKind::Ge => check_cmp(cx, expr.span, left, right, "!", 1), // len >= 1
-                BinOpKind::Le => check_cmp(cx, expr.span, right, left, "!", 1), // 1 <= len
+                BinOpKind::Ge => check_cmp(cx, actual_span, left, right, "!", 1), // len >= 1
+                BinOpKind::Le => check_cmp(cx, actual_span, right, left, "!", 1), // 1 <= len
                 _ => (),
             }
         }
diff --git a/tests/ui/len_zero.fixed b/tests/ui/len_zero.fixed
index 34b2021df45..2c22abd7e4b 100644
--- a/tests/ui/len_zero.fixed
+++ b/tests/ui/len_zero.fixed
@@ -176,6 +176,10 @@ fn main() {
         // No error; `HasWrongIsEmpty` does not have `.is_empty()`.
         println!("Or this!");
     }
+
+    // issue #10529
+    (!has_is_empty.is_empty()).then(|| println!("This can happen."));
+    (has_is_empty.is_empty()).then(|| println!("Or this!"));
 }
 
 fn test_slice(b: &[u8]) {
diff --git a/tests/ui/len_zero.rs b/tests/ui/len_zero.rs
index c83ae2ac553..a011ff97644 100644
--- a/tests/ui/len_zero.rs
+++ b/tests/ui/len_zero.rs
@@ -176,6 +176,10 @@ fn main() {
         // No error; `HasWrongIsEmpty` does not have `.is_empty()`.
         println!("Or this!");
     }
+
+    // issue #10529
+    (has_is_empty.len() > 0).then(|| println!("This can happen."));
+    (has_is_empty.len() == 0).then(|| println!("Or this!"));
 }
 
 fn test_slice(b: &[u8]) {
diff --git a/tests/ui/len_zero.stderr b/tests/ui/len_zero.stderr
index b6f13780253..396cfb75fb6 100644
--- a/tests/ui/len_zero.stderr
+++ b/tests/ui/len_zero.stderr
@@ -123,10 +123,22 @@ LL |     if with_is_empty.len() == 0 {
    |        ^^^^^^^^^^^^^^^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `with_is_empty.is_empty()`
 
 error: length comparison to zero
-  --> $DIR/len_zero.rs:182:8
+  --> $DIR/len_zero.rs:181:6
+   |
+LL |     (has_is_empty.len() > 0).then(|| println!("This can happen."));
+   |      ^^^^^^^^^^^^^^^^^^^^^^ help: using `!is_empty` is clearer and more explicit: `!has_is_empty.is_empty()`
+
+error: length comparison to zero
+  --> $DIR/len_zero.rs:182:6
+   |
+LL |     (has_is_empty.len() == 0).then(|| println!("Or this!"));
+   |      ^^^^^^^^^^^^^^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `has_is_empty.is_empty()`
+
+error: length comparison to zero
+  --> $DIR/len_zero.rs:186:8
    |
 LL |     if b.len() != 0 {}
    |        ^^^^^^^^^^^^ help: using `!is_empty` is clearer and more explicit: `!b.is_empty()`
 
-error: aborting due to 21 previous errors
+error: aborting due to 23 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 85d7de25a987b72ffb6552e852a4c8f661dfb1c8 Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Fri, 21 Apr 2023 05:12:14 -0500
Subject: fix false positive

---
 clippy_lints/src/allow_attributes.rs        | 4 +++-
 tests/ui/allow_attributes_false_positive.rs | 6 ++++++
 2 files changed, 9 insertions(+), 1 deletion(-)
 create mode 100644 tests/ui/allow_attributes_false_positive.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/allow_attributes.rs b/clippy_lints/src/allow_attributes.rs
index b984132acf5..add73d0aeee 100644
--- a/clippy_lints/src/allow_attributes.rs
+++ b/clippy_lints/src/allow_attributes.rs
@@ -2,7 +2,8 @@ use ast::AttrStyle;
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use rustc_ast as ast;
 use rustc_errors::Applicability;
-use rustc_lint::{LateContext, LateLintPass};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
@@ -51,6 +52,7 @@ impl LateLintPass<'_> for AllowAttribute {
     // Separate each crate's features.
     fn check_attribute(&mut self, cx: &LateContext<'_>, attr: &ast::Attribute) {
         if_chain! {
+            if !in_external_macro(cx.sess(), attr.span);
             if cx.tcx.features().lint_reasons;
             if let AttrStyle::Outer = attr.style;
             if let Some(ident) = attr.ident();
diff --git a/tests/ui/allow_attributes_false_positive.rs b/tests/ui/allow_attributes_false_positive.rs
new file mode 100644
index 00000000000..a34a5d91ef5
--- /dev/null
+++ b/tests/ui/allow_attributes_false_positive.rs
@@ -0,0 +1,6 @@
+#![allow(unused)]
+#![warn(clippy::allow_attributes)]
+#![feature(lint_reasons)]
+#![crate_type = "proc-macro"]
+
+fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 5fc1c79019519f7e02f8bfe59ca6df50c629c470 Mon Sep 17 00:00:00 2001
From: J-ZhengLi <lizheng135@huawei.com>
Date: Sat, 22 Apr 2023 11:17:10 +0800
Subject: bump up `regex-syntax` dependency version to 0.7.0

---
 clippy_lints/Cargo.toml   |  2 +-
 clippy_lints/src/regex.rs | 23 +++++++++++------------
 tests/ui/regex.rs         |  2 ++
 tests/ui/regex.stderr     | 40 ++++++++++++++--------------------------
 4 files changed, 28 insertions(+), 39 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/Cargo.toml b/clippy_lints/Cargo.toml
index 5c6040f63f5..11d9c7f89fe 100644
--- a/clippy_lints/Cargo.toml
+++ b/clippy_lints/Cargo.toml
@@ -17,7 +17,7 @@ if_chain = "1.0"
 itertools = "0.10.1"
 pulldown-cmark = { version = "0.9", default-features = false }
 quine-mc_cluskey = "0.2"
-regex-syntax = "0.6"
+regex-syntax = "0.7"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = { version = "1.0", optional = true }
 tempfile = { version = "3.3.0", optional = true }
diff --git a/clippy_lints/src/regex.rs b/clippy_lints/src/regex.rs
index 9e6c6c73d4f..4b2634ee902 100644
--- a/clippy_lints/src/regex.rs
+++ b/clippy_lints/src/regex.rs
@@ -129,30 +129,32 @@ fn const_str<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> Option<String>
 }
 
 fn is_trivial_regex(s: &regex_syntax::hir::Hir) -> Option<&'static str> {
-    use regex_syntax::hir::Anchor::{EndText, StartText};
-    use regex_syntax::hir::HirKind::{Alternation, Anchor, Concat, Empty, Literal};
+    use regex_syntax::hir::HirKind::{Alternation, Concat, Empty, Literal, Look};
+    use regex_syntax::hir::Look as HirLook;
 
     let is_literal = |e: &[regex_syntax::hir::Hir]| e.iter().all(|e| matches!(*e.kind(), Literal(_)));
 
     match *s.kind() {
-        Empty | Anchor(_) => Some("the regex is unlikely to be useful as it is"),
+        Empty | Look(_) => Some("the regex is unlikely to be useful as it is"),
         Literal(_) => Some("consider using `str::contains`"),
         Alternation(ref exprs) => {
-            if exprs.iter().all(|e| e.kind().is_empty()) {
+            if exprs.iter().all(|e| matches!(e.kind(), Empty)) {
                 Some("the regex is unlikely to be useful as it is")
             } else {
                 None
             }
         },
         Concat(ref exprs) => match (exprs[0].kind(), exprs[exprs.len() - 1].kind()) {
-            (&Anchor(StartText), &Anchor(EndText)) if exprs[1..(exprs.len() - 1)].is_empty() => {
+            (&Look(HirLook::Start), &Look(HirLook::End)) if exprs[1..(exprs.len() - 1)].is_empty() => {
                 Some("consider using `str::is_empty`")
             },
-            (&Anchor(StartText), &Anchor(EndText)) if is_literal(&exprs[1..(exprs.len() - 1)]) => {
+            (&Look(HirLook::Start), &Look(HirLook::End)) if is_literal(&exprs[1..(exprs.len() - 1)]) => {
                 Some("consider using `==` on `str`s")
             },
-            (&Anchor(StartText), &Literal(_)) if is_literal(&exprs[1..]) => Some("consider using `str::starts_with`"),
-            (&Literal(_), &Anchor(EndText)) if is_literal(&exprs[1..(exprs.len() - 1)]) => {
+            (&Look(HirLook::Start), &Literal(_)) if is_literal(&exprs[1..]) => {
+                Some("consider using `str::starts_with`")
+            },
+            (&Literal(_), &Look(HirLook::End)) if is_literal(&exprs[1..(exprs.len() - 1)]) => {
                 Some("consider using `str::ends_with`")
             },
             _ if is_literal(exprs) => Some("consider using `str::contains`"),
@@ -175,10 +177,7 @@ fn check_set<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, utf8: bool) {
 }
 
 fn check_regex<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, utf8: bool) {
-    let mut parser = regex_syntax::ParserBuilder::new()
-        .unicode(true)
-        .allow_invalid_utf8(!utf8)
-        .build();
+    let mut parser = regex_syntax::ParserBuilder::new().unicode(true).utf8(!utf8).build();
 
     if let ExprKind::Lit(ref lit) = expr.kind {
         if let LitKind::Str(ref r, style) = lit.node {
diff --git a/tests/ui/regex.rs b/tests/ui/regex.rs
index ab8ac97a0e7..a5f79b139bc 100644
--- a/tests/ui/regex.rs
+++ b/tests/ui/regex.rs
@@ -34,8 +34,10 @@ fn syntax_error() {
     let set_error = RegexSet::new(&[OPENING_PAREN, r"[a-z]+\.(com|org|net)"]);
     let bset_error = BRegexSet::new(&[OPENING_PAREN, r"[a-z]+\.(com|org|net)"]);
 
+    // These following three cases are considering valid since regex-1.8.0
     let raw_string_error = Regex::new(r"[...\/...]");
     let raw_string_error = Regex::new(r#"[...\/...]"#);
+    let _ = Regex::new(r"(?<hi>hi)").unwrap();
 
     let escaped_string_span = Regex::new("\\b\\c");
 
diff --git a/tests/ui/regex.stderr b/tests/ui/regex.stderr
index c2440f39e0a..6b8a772e7f0 100644
--- a/tests/ui/regex.stderr
+++ b/tests/ui/regex.stderr
@@ -82,23 +82,11 @@ error: regex parse error:
 LL |     let bset_error = BRegexSet::new(&[OPENING_PAREN, r"[a-z]+/.(com|org|net)"]);
    |                                       ^^^^^^^^^^^^^
 
-error: regex syntax error: unrecognized escape sequence
-  --> $DIR/regex.rs:37:45
-   |
-LL |     let raw_string_error = Regex::new(r"[...//...]");
-   |                                             ^^
-
-error: regex syntax error: unrecognized escape sequence
-  --> $DIR/regex.rs:38:46
-   |
-LL |     let raw_string_error = Regex::new(r#"[...//...]"#);
-   |                                              ^^
-
 error: regex parse error:
            /b/c
              ^^
        error: unrecognized escape sequence
-  --> $DIR/regex.rs:40:42
+  --> $DIR/regex.rs:42:42
    |
 LL |     let escaped_string_span = Regex::new("/b/c");
    |                                          ^^^^^^^^
@@ -106,13 +94,13 @@ LL |     let escaped_string_span = Regex::new("/b/c");
    = help: consider using a raw string literal: `r".."`
 
 error: regex syntax error: duplicate flag
-  --> $DIR/regex.rs:42:34
+  --> $DIR/regex.rs:44:34
    |
 LL |     let aux_span = Regex::new("(?ixi)");
    |                                  ^ ^
 
 error: trivial regex
-  --> $DIR/regex.rs:46:33
+  --> $DIR/regex.rs:48:33
    |
 LL |     let trivial_eq = Regex::new("^foobar$");
    |                                 ^^^^^^^^^^
@@ -120,7 +108,7 @@ LL |     let trivial_eq = Regex::new("^foobar$");
    = help: consider using `==` on `str`s
 
 error: trivial regex
-  --> $DIR/regex.rs:48:48
+  --> $DIR/regex.rs:50:48
    |
 LL |     let trivial_eq_builder = RegexBuilder::new("^foobar$");
    |                                                ^^^^^^^^^^
@@ -128,7 +116,7 @@ LL |     let trivial_eq_builder = RegexBuilder::new("^foobar$");
    = help: consider using `==` on `str`s
 
 error: trivial regex
-  --> $DIR/regex.rs:50:42
+  --> $DIR/regex.rs:52:42
    |
 LL |     let trivial_starts_with = Regex::new("^foobar");
    |                                          ^^^^^^^^^
@@ -136,7 +124,7 @@ LL |     let trivial_starts_with = Regex::new("^foobar");
    = help: consider using `str::starts_with`
 
 error: trivial regex
-  --> $DIR/regex.rs:52:40
+  --> $DIR/regex.rs:54:40
    |
 LL |     let trivial_ends_with = Regex::new("foobar$");
    |                                        ^^^^^^^^^
@@ -144,7 +132,7 @@ LL |     let trivial_ends_with = Regex::new("foobar$");
    = help: consider using `str::ends_with`
 
 error: trivial regex
-  --> $DIR/regex.rs:54:39
+  --> $DIR/regex.rs:56:39
    |
 LL |     let trivial_contains = Regex::new("foobar");
    |                                       ^^^^^^^^
@@ -152,7 +140,7 @@ LL |     let trivial_contains = Regex::new("foobar");
    = help: consider using `str::contains`
 
 error: trivial regex
-  --> $DIR/regex.rs:56:39
+  --> $DIR/regex.rs:58:39
    |
 LL |     let trivial_contains = Regex::new(NOT_A_REAL_REGEX);
    |                                       ^^^^^^^^^^^^^^^^
@@ -160,7 +148,7 @@ LL |     let trivial_contains = Regex::new(NOT_A_REAL_REGEX);
    = help: consider using `str::contains`
 
 error: trivial regex
-  --> $DIR/regex.rs:58:40
+  --> $DIR/regex.rs:60:40
    |
 LL |     let trivial_backslash = Regex::new("a/.b");
    |                                        ^^^^^^^
@@ -168,7 +156,7 @@ LL |     let trivial_backslash = Regex::new("a/.b");
    = help: consider using `str::contains`
 
 error: trivial regex
-  --> $DIR/regex.rs:61:36
+  --> $DIR/regex.rs:63:36
    |
 LL |     let trivial_empty = Regex::new("");
    |                                    ^^
@@ -176,7 +164,7 @@ LL |     let trivial_empty = Regex::new("");
    = help: the regex is unlikely to be useful as it is
 
 error: trivial regex
-  --> $DIR/regex.rs:63:36
+  --> $DIR/regex.rs:65:36
    |
 LL |     let trivial_empty = Regex::new("^");
    |                                    ^^^
@@ -184,7 +172,7 @@ LL |     let trivial_empty = Regex::new("^");
    = help: the regex is unlikely to be useful as it is
 
 error: trivial regex
-  --> $DIR/regex.rs:65:36
+  --> $DIR/regex.rs:67:36
    |
 LL |     let trivial_empty = Regex::new("^$");
    |                                    ^^^^
@@ -192,12 +180,12 @@ LL |     let trivial_empty = Regex::new("^$");
    = help: consider using `str::is_empty`
 
 error: trivial regex
-  --> $DIR/regex.rs:67:44
+  --> $DIR/regex.rs:69:44
    |
 LL |     let binary_trivial_empty = BRegex::new("^$");
    |                                            ^^^^
    |
    = help: consider using `str::is_empty`
 
-error: aborting due to 25 previous errors
+error: aborting due to 23 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 397f36a78c426b26252af61e7a521e5b948ed17e Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Sat, 22 Apr 2023 14:53:15 +0000
Subject: Fix `#[allow(clippy::enum_variant_names)]` directly on variants

---
 clippy_lints/src/enum_variants.rs |  8 +++++---
 tests/ui/enum_variants.rs         | 10 ++++++++++
 2 files changed, 15 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/enum_variants.rs b/clippy_lints/src/enum_variants.rs
index 4c69dacf381..faac6340419 100644
--- a/clippy_lints/src/enum_variants.rs
+++ b/clippy_lints/src/enum_variants.rs
@@ -1,6 +1,6 @@
 //! lint on enum variants that are prefixed or suffixed by the same characters
 
-use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
+use clippy_utils::diagnostics::{span_lint, span_lint_and_help, span_lint_hir};
 use clippy_utils::source::is_present_in_source;
 use clippy_utils::str_utils::{camel_case_split, count_match_end, count_match_start};
 use rustc_hir::{EnumDef, Item, ItemKind, Variant};
@@ -135,9 +135,10 @@ fn check_enum_start(cx: &LateContext<'_>, item_name: &str, variant: &Variant<'_>
         && name.chars().nth(item_name_chars).map_or(false, |c| !c.is_lowercase())
         && name.chars().nth(item_name_chars + 1).map_or(false, |c| !c.is_numeric())
     {
-        span_lint(
+        span_lint_hir(
             cx,
             ENUM_VARIANT_NAMES,
+            variant.hir_id,
             variant.span,
             "variant name starts with the enum's name",
         );
@@ -149,9 +150,10 @@ fn check_enum_end(cx: &LateContext<'_>, item_name: &str, variant: &Variant<'_>)
     let item_name_chars = item_name.chars().count();
 
     if count_match_end(item_name, name).char_count == item_name_chars {
-        span_lint(
+        span_lint_hir(
             cx,
             ENUM_VARIANT_NAMES,
+            variant.hir_id,
             variant.span,
             "variant name ends with the enum's name",
         );
diff --git a/tests/ui/enum_variants.rs b/tests/ui/enum_variants.rs
index efed12ee2ef..531652a0e00 100644
--- a/tests/ui/enum_variants.rs
+++ b/tests/ui/enum_variants.rs
@@ -179,4 +179,14 @@ mod issue9018 {
     }
 }
 
+mod allow_attributes_on_variants {
+    enum Enum {
+        #[allow(clippy::enum_variant_names)]
+        EnumStartsWith,
+        #[allow(clippy::enum_variant_names)]
+        EndsWithEnum,
+        Foo,
+    }
+}
+
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 0354cee1372ac80028588f9a2f2772c868b0a21c Mon Sep 17 00:00:00 2001
From: blyxyas <blyxyas@gmail.com>
Date: Fri, 31 Mar 2023 09:06:39 +0200
Subject: Add lint `items_after_test_module`

---
 CHANGELOG.md                                |  1 +
 clippy_lints/src/declared_lints.rs          |  1 +
 clippy_lints/src/items_after_test_module.rs | 82 +++++++++++++++++++++++++++++
 clippy_lints/src/lib.rs                     |  2 +
 tests/ui/items_after_test_module.rs         | 24 +++++++++
 tests/ui/items_after_test_module.stderr     | 19 +++++++
 6 files changed, 129 insertions(+)
 create mode 100644 clippy_lints/src/items_after_test_module.rs
 create mode 100644 tests/ui/items_after_test_module.rs
 create mode 100644 tests/ui/items_after_test_module.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 10dd28a8f6a..d7102d2474e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4730,6 +4730,7 @@ Released 2018-09-13
 [`invisible_characters`]: https://rust-lang.github.io/rust-clippy/master/index.html#invisible_characters
 [`is_digit_ascii_radix`]: https://rust-lang.github.io/rust-clippy/master/index.html#is_digit_ascii_radix
 [`items_after_statements`]: https://rust-lang.github.io/rust-clippy/master/index.html#items_after_statements
+[`items_after_test_module`]: https://rust-lang.github.io/rust-clippy/master/index.html#items_after_test_module
 [`iter_cloned_collect`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_cloned_collect
 [`iter_count`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_count
 [`iter_kv_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_kv_map
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index f24dab62780..0c66d36a1d6 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -215,6 +215,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::invalid_upcast_comparisons::INVALID_UPCAST_COMPARISONS_INFO,
     crate::invalid_utf8_in_unchecked::INVALID_UTF8_IN_UNCHECKED_INFO,
     crate::items_after_statements::ITEMS_AFTER_STATEMENTS_INFO,
+    crate::items_after_test_module::ITEMS_AFTER_TEST_MODULE_INFO,
     crate::iter_not_returning_iterator::ITER_NOT_RETURNING_ITERATOR_INFO,
     crate::large_const_arrays::LARGE_CONST_ARRAYS_INFO,
     crate::large_enum_variant::LARGE_ENUM_VARIANT_INFO,
diff --git a/clippy_lints/src/items_after_test_module.rs b/clippy_lints/src/items_after_test_module.rs
new file mode 100644
index 00000000000..9d949a44c02
--- /dev/null
+++ b/clippy_lints/src/items_after_test_module.rs
@@ -0,0 +1,82 @@
+use clippy_utils::{diagnostics::span_lint_and_help, is_in_cfg_test};
+use rustc_hir::{HirId, ItemId, ItemKind, Mod};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_middle::lint::in_external_macro;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::sym;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Triggers if an item is declared after the testing module marked with `#[cfg(test)]`.
+    /// ### Why is this bad?
+    /// Having items declared after the testing module is confusing and may lead to bad test coverage.
+    /// ### Example
+    /// ```rust
+    /// #[cfg(test)]
+    /// mod tests {
+    ///     // [...]
+    /// }
+    ///
+    /// fn my_function() {
+    ///     // [...]
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// fn my_function() {
+    ///     // [...]
+    /// }
+    ///
+    /// #[cfg(test)]
+    /// mod tests {
+    ///     // [...]
+    /// }
+    /// ```
+    #[clippy::version = "1.70.0"]
+    pub ITEMS_AFTER_TEST_MODULE,
+    style,
+    "An item was found after the testing module `tests`"
+}
+
+declare_lint_pass!(ItemsAfterTestModule => [ITEMS_AFTER_TEST_MODULE]);
+
+impl LateLintPass<'_> for ItemsAfterTestModule {
+    fn check_mod(&mut self, cx: &LateContext<'_>, _: &Mod<'_>, _: HirId) {
+        let mut was_test_mod_visited = false;
+        let mut test_mod_hash: Option<u128> = None;
+
+        let hir = cx.tcx.hir();
+        let items = hir.items().collect::<Vec<ItemId>>();
+
+        for itid in &items {
+            let item = hir.item(*itid);
+
+            if_chain! {
+            if was_test_mod_visited;
+            if cx.sess().source_map().lookup_char_pos(item.span.lo()).file.name_hash
+            == test_mod_hash.unwrap(); // Will never fail
+            if !matches!(item.kind, ItemKind::Mod(_) | ItemKind::Macro(_, _));
+            if !is_in_cfg_test(cx.tcx, itid.hir_id()); // The item isn't in the testing module itself
+
+            if !in_external_macro(cx.sess(), item.span);
+            then {
+                span_lint_and_help(cx, ITEMS_AFTER_TEST_MODULE, item.span, "an item was found after the testing module", None, "move the item to before the testing module was defined");
+            }};
+
+            if matches!(item.kind, ItemKind::Mod(_)) {
+                for attr in cx.tcx.get_attrs(item.owner_id.to_def_id(), sym::cfg) {
+                    if_chain! {
+                                if attr.has_name(sym::cfg);
+                                if let Some(mitems) = attr.meta_item_list();
+                                if let [mitem] = &*mitems;
+                                if mitem.has_name(sym::test);
+                                then {
+                                    was_test_mod_visited = true;
+                    test_mod_hash = Some(cx.sess().source_map().lookup_char_pos(item.span.lo()).file.name_hash);
+                                }
+                            }
+                }
+            }
+        }
+    }
+}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index af2c7803601..573ffe349ec 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -158,6 +158,7 @@ mod int_plus_one;
 mod invalid_upcast_comparisons;
 mod invalid_utf8_in_unchecked;
 mod items_after_statements;
+mod items_after_test_module;
 mod iter_not_returning_iterator;
 mod large_const_arrays;
 mod large_enum_variant;
@@ -961,6 +962,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(tests_outside_test_module::TestsOutsideTestModule));
     store.register_late_pass(|_| Box::new(manual_slice_size_calculation::ManualSliceSizeCalculation));
     store.register_early_pass(|| Box::new(suspicious_doc_comments::SuspiciousDocComments));
+    store.register_late_pass(|_| Box::new(items_after_test_module::ItemsAfterTestModule));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/tests/ui/items_after_test_module.rs b/tests/ui/items_after_test_module.rs
new file mode 100644
index 00000000000..735c06e51ff
--- /dev/null
+++ b/tests/ui/items_after_test_module.rs
@@ -0,0 +1,24 @@
+// compile-flags: --test
+#![allow(unused)]
+#![warn(clippy::items_after_test_module)]
+
+fn main() {}
+
+fn should_not_lint() {}
+
+#[allow(dead_code)]
+#[allow(unused)] // Some attributes to check that span replacement is good enough
+#[allow(clippy::allow_attributes)]
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn hi() {}
+}
+
+fn should_lint() {}
+
+const SHOULD_ALSO_LINT: usize = 1;
+
+macro_rules! should_not_lint {
+    () => {};
+}
diff --git a/tests/ui/items_after_test_module.stderr b/tests/ui/items_after_test_module.stderr
new file mode 100644
index 00000000000..53ca4746476
--- /dev/null
+++ b/tests/ui/items_after_test_module.stderr
@@ -0,0 +1,19 @@
+error: an item was found after the testing module
+  --> $DIR/items_after_test_module.rs:18:1
+   |
+LL | fn should_lint() {}
+   | ^^^^^^^^^^^^^^^^^^^
+   |
+   = help: move the item to before the testing module was defined
+   = note: `-D clippy::items-after-test-module` implied by `-D warnings`
+
+error: an item was found after the testing module
+  --> $DIR/items_after_test_module.rs:20:1
+   |
+LL | const SHOULD_ALSO_LINT: usize = 1;
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: move the item to before the testing module was defined
+
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 1ac8dc51bc379136cbcba737e63ba619f9524269 Mon Sep 17 00:00:00 2001
From: blyxyas <blyxyas@gmail.com>
Date: Wed, 12 Apr 2023 20:17:26 +0200
Subject: Compact emmited lint

---
 clippy_lints/src/items_after_test_module.rs | 33 +++++++++++++++--------------
 tests/ui/items_after_test_module.rs         |  3 +--
 tests/ui/items_after_test_module.stderr     | 26 +++++++++++------------
 3 files changed, 30 insertions(+), 32 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/items_after_test_module.rs b/clippy_lints/src/items_after_test_module.rs
index 9d949a44c02..52d716feea0 100644
--- a/clippy_lints/src/items_after_test_module.rs
+++ b/clippy_lints/src/items_after_test_module.rs
@@ -3,7 +3,7 @@ use rustc_hir::{HirId, ItemId, ItemKind, Mod};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::sym;
+use rustc_span::{sym, Span};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -43,38 +43,39 @@ declare_lint_pass!(ItemsAfterTestModule => [ITEMS_AFTER_TEST_MODULE]);
 impl LateLintPass<'_> for ItemsAfterTestModule {
     fn check_mod(&mut self, cx: &LateContext<'_>, _: &Mod<'_>, _: HirId) {
         let mut was_test_mod_visited = false;
-        let mut test_mod_hash: Option<u128> = None;
+        let mut test_mod_span: Option<Span> = None;
 
         let hir = cx.tcx.hir();
         let items = hir.items().collect::<Vec<ItemId>>();
 
-        for itid in &items {
+        for (i, itid) in items.iter().enumerate() {
             let item = hir.item(*itid);
 
             if_chain! {
             if was_test_mod_visited;
+            if i == (items.len() - 3 /* Weird magic number (HIR-translation behaviour) */);
             if cx.sess().source_map().lookup_char_pos(item.span.lo()).file.name_hash
-            == test_mod_hash.unwrap(); // Will never fail
-            if !matches!(item.kind, ItemKind::Mod(_) | ItemKind::Macro(_, _));
+            == cx.sess().source_map().lookup_char_pos(test_mod_span.unwrap().lo()).file.name_hash; // Will never fail
+            if !matches!(item.kind, ItemKind::Mod(_));
             if !is_in_cfg_test(cx.tcx, itid.hir_id()); // The item isn't in the testing module itself
-
             if !in_external_macro(cx.sess(), item.span);
+
             then {
-                span_lint_and_help(cx, ITEMS_AFTER_TEST_MODULE, item.span, "an item was found after the testing module", None, "move the item to before the testing module was defined");
+                span_lint_and_help(cx, ITEMS_AFTER_TEST_MODULE, test_mod_span.unwrap().with_hi(item.span.hi()), "items were found after the testing module", None, "move the items to before the testing module was defined");
             }};
 
             if matches!(item.kind, ItemKind::Mod(_)) {
                 for attr in cx.tcx.get_attrs(item.owner_id.to_def_id(), sym::cfg) {
                     if_chain! {
-                                if attr.has_name(sym::cfg);
-                                if let Some(mitems) = attr.meta_item_list();
-                                if let [mitem] = &*mitems;
-                                if mitem.has_name(sym::test);
-                                then {
-                                    was_test_mod_visited = true;
-                    test_mod_hash = Some(cx.sess().source_map().lookup_char_pos(item.span.lo()).file.name_hash);
-                                }
-                            }
+                        if attr.has_name(sym::cfg);
+                        if let Some(mitems) = attr.meta_item_list();
+                        if let [mitem] = &*mitems;
+                        if mitem.has_name(sym::test);
+                        then {
+                            was_test_mod_visited = true;
+                            test_mod_span = Some(item.span);
+                        }
+                    }
                 }
             }
         }
diff --git a/tests/ui/items_after_test_module.rs b/tests/ui/items_after_test_module.rs
index 735c06e51ff..5136b2557ec 100644
--- a/tests/ui/items_after_test_module.rs
+++ b/tests/ui/items_after_test_module.rs
@@ -1,4 +1,4 @@
-// compile-flags: --test
+//@compile-flags: --test
 #![allow(unused)]
 #![warn(clippy::items_after_test_module)]
 
@@ -18,7 +18,6 @@ mod tests {
 fn should_lint() {}
 
 const SHOULD_ALSO_LINT: usize = 1;
-
 macro_rules! should_not_lint {
     () => {};
 }
diff --git a/tests/ui/items_after_test_module.stderr b/tests/ui/items_after_test_module.stderr
index 53ca4746476..8f1616dabc1 100644
--- a/tests/ui/items_after_test_module.stderr
+++ b/tests/ui/items_after_test_module.stderr
@@ -1,19 +1,17 @@
-error: an item was found after the testing module
-  --> $DIR/items_after_test_module.rs:18:1
+error: items were found after the testing module
+  --> $DIR/items_after_test_module.rs:13:1
    |
-LL | fn should_lint() {}
-   | ^^^^^^^^^^^^^^^^^^^
+LL | / mod tests {
+LL | |     #[test]
+LL | |     fn hi() {}
+LL | | }
+...  |
+LL | |     () => {};
+LL | | }
+   | |_^
    |
-   = help: move the item to before the testing module was defined
+   = help: move the items to before the testing module was defined
    = note: `-D clippy::items-after-test-module` implied by `-D warnings`
 
-error: an item was found after the testing module
-  --> $DIR/items_after_test_module.rs:20:1
-   |
-LL | const SHOULD_ALSO_LINT: usize = 1;
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: move the item to before the testing module was defined
-
-error: aborting due to 2 previous errors
+error: aborting due to previous error
 
-- 
cgit 1.4.1-3-g733a5


From 628605e07a2a9a546ba698f1a50311b16832f227 Mon Sep 17 00:00:00 2001
From: Renato Lochetti <renato.lochetti@gmail.com>
Date: Sat, 22 Apr 2023 20:28:08 +0100
Subject: Ignore `shadow` warns in code from macro expansions

---
 clippy_lints/src/shadow.rs |  2 +-
 tests/ui/shadow.rs         | 12 ++++++
 tests/ui/shadow.stderr     | 92 +++++++++++++++++++++++-----------------------
 3 files changed, 59 insertions(+), 47 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/shadow.rs b/clippy_lints/src/shadow.rs
index ae7d19624ba..993f9373d85 100644
--- a/clippy_lints/src/shadow.rs
+++ b/clippy_lints/src/shadow.rs
@@ -108,7 +108,7 @@ impl<'tcx> LateLintPass<'tcx> for Shadow {
     fn check_pat(&mut self, cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>) {
         let PatKind::Binding(_, id, ident, _) = pat.kind else { return };
 
-        if pat.span.desugaring_kind().is_some() {
+        if pat.span.desugaring_kind().is_some() || pat.span.from_expansion() {
             return;
         }
 
diff --git a/tests/ui/shadow.rs b/tests/ui/shadow.rs
index 03337ec3564..2c0fc3e3fd8 100644
--- a/tests/ui/shadow.rs
+++ b/tests/ui/shadow.rs
@@ -8,6 +8,12 @@ extern crate proc_macro_derive;
 #[derive(proc_macro_derive::ShadowDerive)]
 pub struct Nothing;
 
+macro_rules! reuse {
+    ($v:ident) => {
+        let $v = $v + 1;
+    };
+}
+
 fn shadow_same() {
     let x = 1;
     let x = x;
@@ -33,6 +39,12 @@ fn shadow_reuse() -> Option<()> {
     None
 }
 
+fn shadow_reuse_macro() {
+    let x = 1;
+    // this should not warn
+    reuse!(x);
+}
+
 fn shadow_unrelated() {
     let x = 1;
     let x = 2;
diff --git a/tests/ui/shadow.stderr b/tests/ui/shadow.stderr
index 92bb937d086..8321f6df224 100644
--- a/tests/ui/shadow.stderr
+++ b/tests/ui/shadow.stderr
@@ -1,278 +1,278 @@
 error: `x` is shadowed by itself in `x`
-  --> $DIR/shadow.rs:13:9
+  --> $DIR/shadow.rs:19:9
    |
 LL |     let x = x;
    |         ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:12:9
+  --> $DIR/shadow.rs:18:9
    |
 LL |     let x = 1;
    |         ^
    = note: `-D clippy::shadow-same` implied by `-D warnings`
 
 error: `mut x` is shadowed by itself in `&x`
-  --> $DIR/shadow.rs:14:13
+  --> $DIR/shadow.rs:20:13
    |
 LL |     let mut x = &x;
    |             ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:13:9
+  --> $DIR/shadow.rs:19:9
    |
 LL |     let x = x;
    |         ^
 
 error: `x` is shadowed by itself in `&mut x`
-  --> $DIR/shadow.rs:15:9
+  --> $DIR/shadow.rs:21:9
    |
 LL |     let x = &mut x;
    |         ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:14:9
+  --> $DIR/shadow.rs:20:9
    |
 LL |     let mut x = &x;
    |         ^^^^^
 
 error: `x` is shadowed by itself in `*x`
-  --> $DIR/shadow.rs:16:9
+  --> $DIR/shadow.rs:22:9
    |
 LL |     let x = *x;
    |         ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:15:9
+  --> $DIR/shadow.rs:21:9
    |
 LL |     let x = &mut x;
    |         ^
 
 error: `x` is shadowed
-  --> $DIR/shadow.rs:21:9
+  --> $DIR/shadow.rs:27:9
    |
 LL |     let x = x.0;
    |         ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:20:9
+  --> $DIR/shadow.rs:26:9
    |
 LL |     let x = ([[0]], ());
    |         ^
    = note: `-D clippy::shadow-reuse` implied by `-D warnings`
 
 error: `x` is shadowed
-  --> $DIR/shadow.rs:22:9
+  --> $DIR/shadow.rs:28:9
    |
 LL |     let x = x[0];
    |         ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:21:9
+  --> $DIR/shadow.rs:27:9
    |
 LL |     let x = x.0;
    |         ^
 
 error: `x` is shadowed
-  --> $DIR/shadow.rs:23:10
+  --> $DIR/shadow.rs:29:10
    |
 LL |     let [x] = x;
    |          ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:22:9
+  --> $DIR/shadow.rs:28:9
    |
 LL |     let x = x[0];
    |         ^
 
 error: `x` is shadowed
-  --> $DIR/shadow.rs:24:9
+  --> $DIR/shadow.rs:30:9
    |
 LL |     let x = Some(x);
    |         ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:23:10
+  --> $DIR/shadow.rs:29:10
    |
 LL |     let [x] = x;
    |          ^
 
 error: `x` is shadowed
-  --> $DIR/shadow.rs:25:9
+  --> $DIR/shadow.rs:31:9
    |
 LL |     let x = foo(x);
    |         ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:24:9
+  --> $DIR/shadow.rs:30:9
    |
 LL |     let x = Some(x);
    |         ^
 
 error: `x` is shadowed
-  --> $DIR/shadow.rs:26:9
+  --> $DIR/shadow.rs:32:9
    |
 LL |     let x = || x;
    |         ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:25:9
+  --> $DIR/shadow.rs:31:9
    |
 LL |     let x = foo(x);
    |         ^
 
 error: `x` is shadowed
-  --> $DIR/shadow.rs:27:9
+  --> $DIR/shadow.rs:33:9
    |
 LL |     let x = Some(1).map(|_| x)?;
    |         ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:26:9
+  --> $DIR/shadow.rs:32:9
    |
 LL |     let x = || x;
    |         ^
 
 error: `y` is shadowed
-  --> $DIR/shadow.rs:29:9
+  --> $DIR/shadow.rs:35:9
    |
 LL |     let y = match y {
    |         ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:28:9
+  --> $DIR/shadow.rs:34:9
    |
 LL |     let y = 1;
    |         ^
 
 error: `x` shadows a previous, unrelated binding
-  --> $DIR/shadow.rs:38:9
+  --> $DIR/shadow.rs:50:9
    |
 LL |     let x = 2;
    |         ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:37:9
+  --> $DIR/shadow.rs:49:9
    |
 LL |     let x = 1;
    |         ^
    = note: `-D clippy::shadow-unrelated` implied by `-D warnings`
 
 error: `x` shadows a previous, unrelated binding
-  --> $DIR/shadow.rs:43:13
+  --> $DIR/shadow.rs:55:13
    |
 LL |         let x = 1;
    |             ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:42:10
+  --> $DIR/shadow.rs:54:10
    |
 LL |     fn f(x: u32) {
    |          ^
 
 error: `x` shadows a previous, unrelated binding
-  --> $DIR/shadow.rs:48:14
+  --> $DIR/shadow.rs:60:14
    |
 LL |         Some(x) => {
    |              ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:45:9
+  --> $DIR/shadow.rs:57:9
    |
 LL |     let x = 1;
    |         ^
 
 error: `x` shadows a previous, unrelated binding
-  --> $DIR/shadow.rs:49:17
+  --> $DIR/shadow.rs:61:17
    |
 LL |             let x = 1;
    |                 ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:48:14
+  --> $DIR/shadow.rs:60:14
    |
 LL |         Some(x) => {
    |              ^
 
 error: `x` shadows a previous, unrelated binding
-  --> $DIR/shadow.rs:53:17
+  --> $DIR/shadow.rs:65:17
    |
 LL |     if let Some(x) = Some(1) {}
    |                 ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:45:9
+  --> $DIR/shadow.rs:57:9
    |
 LL |     let x = 1;
    |         ^
 
 error: `x` shadows a previous, unrelated binding
-  --> $DIR/shadow.rs:54:20
+  --> $DIR/shadow.rs:66:20
    |
 LL |     while let Some(x) = Some(1) {}
    |                    ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:45:9
+  --> $DIR/shadow.rs:57:9
    |
 LL |     let x = 1;
    |         ^
 
 error: `x` shadows a previous, unrelated binding
-  --> $DIR/shadow.rs:55:15
+  --> $DIR/shadow.rs:67:15
    |
 LL |     let _ = |[x]: [u32; 1]| {
    |               ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:45:9
+  --> $DIR/shadow.rs:57:9
    |
 LL |     let x = 1;
    |         ^
 
 error: `x` shadows a previous, unrelated binding
-  --> $DIR/shadow.rs:56:13
+  --> $DIR/shadow.rs:68:13
    |
 LL |         let x = 1;
    |             ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:55:15
+  --> $DIR/shadow.rs:67:15
    |
 LL |     let _ = |[x]: [u32; 1]| {
    |               ^
 
 error: `y` is shadowed
-  --> $DIR/shadow.rs:59:17
+  --> $DIR/shadow.rs:71:17
    |
 LL |     if let Some(y) = y {}
    |                 ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:58:9
+  --> $DIR/shadow.rs:70:9
    |
 LL |     let y = Some(1);
    |         ^
 
 error: `_b` shadows a previous, unrelated binding
-  --> $DIR/shadow.rs:95:9
+  --> $DIR/shadow.rs:107:9
    |
 LL |     let _b = _a;
    |         ^^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:94:28
+  --> $DIR/shadow.rs:106:28
    |
 LL | pub async fn foo2(_a: i32, _b: i64) {
    |                            ^^
 
 error: `x` shadows a previous, unrelated binding
-  --> $DIR/shadow.rs:101:21
+  --> $DIR/shadow.rs:113:21
    |
 LL |         if let Some(x) = Some(1) { x } else { 1 }
    |                     ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:100:13
+  --> $DIR/shadow.rs:112:13
    |
 LL |         let x = 1;
    |             ^
-- 
cgit 1.4.1-3-g733a5


From bdd05456b1deba85fdeef948b20362145d63c1ec Mon Sep 17 00:00:00 2001
From: blyxyas <blyxyas@gmail.com>
Date: Sun, 23 Apr 2023 12:05:52 +0200
Subject: Ignore `impl Trait`(s)

---
 clippy_lints/src/let_underscore.rs     | 15 +++++++++++++--
 tests/ui/let_underscore_untyped.rs     |  5 +++++
 tests/ui/let_underscore_untyped.stderr | 20 ++++++--------------
 3 files changed, 24 insertions(+), 16 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/let_underscore.rs b/clippy_lints/src/let_underscore.rs
index 51b5de27de8..637b7de920e 100644
--- a/clippy_lints/src/let_underscore.rs
+++ b/clippy_lints/src/let_underscore.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::ty::{implements_trait, is_must_use_ty, match_type};
 use clippy_utils::{is_must_use_func_call, paths};
-use rustc_hir::{Local, PatKind};
+use rustc_hir::{ExprKind, Local, PatKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::subst::GenericArgKind;
@@ -189,7 +189,18 @@ impl<'tcx> LateLintPass<'tcx> for LetUnderscore {
 
             if local.pat.default_binding_modes && local.ty.is_none() {
                 // When `default_binding_modes` is true, the `let` keyword is present.
-                span_lint_and_help(
+
+				// Ignore function calls that return impl traits...
+				if let Some(init) = local.init &&
+				matches!(init.kind, ExprKind::Call(_, _) | ExprKind::MethodCall(_, _, _, _)) {
+					let expr_ty = cx.typeck_results().expr_ty(init);
+					if expr_ty.is_impl_trait() {
+						return;
+					}
+				}
+
+
+				span_lint_and_help(
                     cx,
                     LET_UNDERSCORE_UNTYPED,
                     local.span,
diff --git a/tests/ui/let_underscore_untyped.rs b/tests/ui/let_underscore_untyped.rs
index bcb33c5c7e3..8486137d3a6 100644
--- a/tests/ui/let_underscore_untyped.rs
+++ b/tests/ui/let_underscore_untyped.rs
@@ -28,6 +28,10 @@ fn f() -> Box<dyn Display> {
     Box::new(1)
 }
 
+fn g() -> impl Fn() {
+    || {}
+}
+
 fn main() {
     let _ = a();
     let _ = b(1);
@@ -35,6 +39,7 @@ fn main() {
     let _ = d(&1);
     let _ = e();
     let _ = f();
+    let _ = g();
 
     _ = a();
     _ = b(1);
diff --git a/tests/ui/let_underscore_untyped.stderr b/tests/ui/let_underscore_untyped.stderr
index 36c3d1214d6..47e76ea1d04 100644
--- a/tests/ui/let_underscore_untyped.stderr
+++ b/tests/ui/let_underscore_untyped.stderr
@@ -1,5 +1,5 @@
 error: non-binding `let` without a type annotation
-  --> $DIR/let_underscore_untyped.rs:32:5
+  --> $DIR/let_underscore_untyped.rs:36:5
    |
 LL |     let _ = a();
    |     ^^^^^^^^^^^^
@@ -8,7 +8,7 @@ LL |     let _ = a();
    = note: `-D clippy::let-underscore-untyped` implied by `-D warnings`
 
 error: non-binding `let` without a type annotation
-  --> $DIR/let_underscore_untyped.rs:33:5
+  --> $DIR/let_underscore_untyped.rs:37:5
    |
 LL |     let _ = b(1);
    |     ^^^^^^^^^^^^^
@@ -16,15 +16,7 @@ LL |     let _ = b(1);
    = help: consider adding a type annotation or removing the `let` keyword
 
 error: non-binding `let` without a type annotation
-  --> $DIR/let_underscore_untyped.rs:34:5
-   |
-LL |     let _ = c();
-   |     ^^^^^^^^^^^^
-   |
-   = help: consider adding a type annotation or removing the `let` keyword
-
-error: non-binding `let` without a type annotation
-  --> $DIR/let_underscore_untyped.rs:35:5
+  --> $DIR/let_underscore_untyped.rs:39:5
    |
 LL |     let _ = d(&1);
    |     ^^^^^^^^^^^^^^
@@ -32,7 +24,7 @@ LL |     let _ = d(&1);
    = help: consider adding a type annotation or removing the `let` keyword
 
 error: non-binding `let` without a type annotation
-  --> $DIR/let_underscore_untyped.rs:36:5
+  --> $DIR/let_underscore_untyped.rs:40:5
    |
 LL |     let _ = e();
    |     ^^^^^^^^^^^^
@@ -40,12 +32,12 @@ LL |     let _ = e();
    = help: consider adding a type annotation or removing the `let` keyword
 
 error: non-binding `let` without a type annotation
-  --> $DIR/let_underscore_untyped.rs:37:5
+  --> $DIR/let_underscore_untyped.rs:41:5
    |
 LL |     let _ = f();
    |     ^^^^^^^^^^^^
    |
    = help: consider adding a type annotation or removing the `let` keyword
 
-error: aborting due to 6 previous errors
+error: aborting due to 5 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From acf50a7dc685ad5267e2fcff5a1545d5e56f5c44 Mon Sep 17 00:00:00 2001
From: blyxyas <blyxyas@gmail.com>
Date: Sun, 23 Apr 2023 12:52:45 +0200
Subject: Improve the help message + add a help span

---
 clippy_lints/src/let_underscore.rs     | 10 ++++++++--
 tests/ui/let_underscore_untyped.stderr | 30 +++++++++++++++++++++++++-----
 2 files changed, 33 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/let_underscore.rs b/clippy_lints/src/let_underscore.rs
index 637b7de920e..16772a9d598 100644
--- a/clippy_lints/src/let_underscore.rs
+++ b/clippy_lints/src/let_underscore.rs
@@ -6,6 +6,7 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::subst::GenericArgKind;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::{BytePos, Span};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -205,8 +206,13 @@ impl<'tcx> LateLintPass<'tcx> for LetUnderscore {
                     LET_UNDERSCORE_UNTYPED,
                     local.span,
                     "non-binding `let` without a type annotation",
-                    None,
-                    "consider adding a type annotation or removing the `let` keyword",
+                    Some(
+						Span::new(local.pat.span.hi(),
+						local.pat.span.hi() + BytePos(1),
+						local.pat.span.ctxt(),
+						local.pat.span.parent()
+					)),
+                    "consider adding a type annotation",
                 );
             }
         }
diff --git a/tests/ui/let_underscore_untyped.stderr b/tests/ui/let_underscore_untyped.stderr
index 47e76ea1d04..6844cb998f7 100644
--- a/tests/ui/let_underscore_untyped.stderr
+++ b/tests/ui/let_underscore_untyped.stderr
@@ -4,7 +4,11 @@ error: non-binding `let` without a type annotation
 LL |     let _ = a();
    |     ^^^^^^^^^^^^
    |
-   = help: consider adding a type annotation or removing the `let` keyword
+help: consider adding a type annotation
+  --> $DIR/let_underscore_untyped.rs:36:10
+   |
+LL |     let _ = a();
+   |          ^
    = note: `-D clippy::let-underscore-untyped` implied by `-D warnings`
 
 error: non-binding `let` without a type annotation
@@ -13,7 +17,11 @@ error: non-binding `let` without a type annotation
 LL |     let _ = b(1);
    |     ^^^^^^^^^^^^^
    |
-   = help: consider adding a type annotation or removing the `let` keyword
+help: consider adding a type annotation
+  --> $DIR/let_underscore_untyped.rs:37:10
+   |
+LL |     let _ = b(1);
+   |          ^
 
 error: non-binding `let` without a type annotation
   --> $DIR/let_underscore_untyped.rs:39:5
@@ -21,7 +29,11 @@ error: non-binding `let` without a type annotation
 LL |     let _ = d(&1);
    |     ^^^^^^^^^^^^^^
    |
-   = help: consider adding a type annotation or removing the `let` keyword
+help: consider adding a type annotation
+  --> $DIR/let_underscore_untyped.rs:39:10
+   |
+LL |     let _ = d(&1);
+   |          ^
 
 error: non-binding `let` without a type annotation
   --> $DIR/let_underscore_untyped.rs:40:5
@@ -29,7 +41,11 @@ error: non-binding `let` without a type annotation
 LL |     let _ = e();
    |     ^^^^^^^^^^^^
    |
-   = help: consider adding a type annotation or removing the `let` keyword
+help: consider adding a type annotation
+  --> $DIR/let_underscore_untyped.rs:40:10
+   |
+LL |     let _ = e();
+   |          ^
 
 error: non-binding `let` without a type annotation
   --> $DIR/let_underscore_untyped.rs:41:5
@@ -37,7 +53,11 @@ error: non-binding `let` without a type annotation
 LL |     let _ = f();
    |     ^^^^^^^^^^^^
    |
-   = help: consider adding a type annotation or removing the `let` keyword
+help: consider adding a type annotation
+  --> $DIR/let_underscore_untyped.rs:41:10
+   |
+LL |     let _ = f();
+   |          ^
 
 error: aborting due to 5 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 69da902f417547831009a4957037cd21b5aab678 Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Sun, 26 Feb 2023 15:44:04 +0100
Subject: Detect if expressions with boolean assignments to the same target

---
 CHANGELOG.md                         |  1 +
 clippy_lints/src/declared_lints.rs   |  1 +
 clippy_lints/src/needless_bool.rs    | 71 ++++++++++++++++++++++++++++++++++--
 tests/ui/needless_bool_assign.fixed  | 33 +++++++++++++++++
 tests/ui/needless_bool_assign.rs     | 45 +++++++++++++++++++++++
 tests/ui/needless_bool_assign.stderr | 53 +++++++++++++++++++++++++++
 6 files changed, 201 insertions(+), 3 deletions(-)
 create mode 100644 tests/ui/needless_bool_assign.fixed
 create mode 100644 tests/ui/needless_bool_assign.rs
 create mode 100644 tests/ui/needless_bool_assign.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 10dd28a8f6a..f3f43830f56 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4863,6 +4863,7 @@ Released 2018-09-13
 [`needless_arbitrary_self_type`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_arbitrary_self_type
 [`needless_bitwise_bool`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_bitwise_bool
 [`needless_bool`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_bool
+[`needless_bool_assign`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_bool_assign
 [`needless_borrow`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow
 [`needless_borrowed_reference`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrowed_reference
 [`needless_collect`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_collect
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index f24dab62780..9633f0d55f7 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -445,6 +445,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::needless_arbitrary_self_type::NEEDLESS_ARBITRARY_SELF_TYPE_INFO,
     crate::needless_bool::BOOL_COMPARISON_INFO,
     crate::needless_bool::NEEDLESS_BOOL_INFO,
+    crate::needless_bool::NEEDLESS_BOOL_ASSIGN_INFO,
     crate::needless_borrowed_ref::NEEDLESS_BORROWED_REFERENCE_INFO,
     crate::needless_continue::NEEDLESS_CONTINUE_INFO,
     crate::needless_for_each::NEEDLESS_FOR_EACH_INFO,
diff --git a/clippy_lints/src/needless_bool.rs b/clippy_lints/src/needless_bool.rs
index c87059bf61d..bd2e39e6ed6 100644
--- a/clippy_lints/src/needless_bool.rs
+++ b/clippy_lints/src/needless_bool.rs
@@ -3,10 +3,12 @@
 //! This lint is **warn** by default
 
 use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg};
-use clippy_utils::higher;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::sugg::Sugg;
-use clippy_utils::{get_parent_node, is_else_clause, is_expn_of, peel_blocks, peel_blocks_with_stmt};
+use clippy_utils::{
+    get_parent_node, is_else_clause, is_expn_of, peel_blocks, peel_blocks_with_stmt, span_extract_comment,
+};
+use clippy_utils::{higher, SpanlessEq};
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Block, Expr, ExprKind, HirId, Node, UnOp};
@@ -77,7 +79,39 @@ declare_clippy_lint! {
     "comparing a variable to a boolean, e.g., `if x == true` or `if x != true`"
 }
 
-declare_lint_pass!(NeedlessBool => [NEEDLESS_BOOL]);
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for expressions of the form `if c { x = true } else { x = false }`
+    /// (or vice versa) and suggest assigning the variable directly from the
+    /// condition.
+    ///
+    /// ### Why is this bad?
+    /// Redundant code.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// # fn must_keep(x: i32, y: i32) -> bool { x == y }
+    /// # let x = 32; let y = 10;
+    /// # let mut skip: bool;
+    /// if must_keep(x, y) {
+    ///     skip = false;
+    /// } else {
+    ///     skip = true;
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust,ignore
+    /// # fn must_keep(x: i32, y: i32) -> bool { x == y }
+    /// # let x = 32; let y = 10;
+    /// # let mut skip: bool;
+    /// skip = !must_keep(x, y);
+    /// ```
+    #[clippy::version = "1.69.0"]
+    pub NEEDLESS_BOOL_ASSIGN,
+    complexity,
+    "setting the same boolean variable in both branches of an if-statement"
+}
+declare_lint_pass!(NeedlessBool => [NEEDLESS_BOOL, NEEDLESS_BOOL_ASSIGN]);
 
 fn condition_needs_parentheses(e: &Expr<'_>) -> bool {
     let mut inner = e;
@@ -173,6 +207,29 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessBool {
                     _ => (),
                 }
             }
+            if let Some((lhs_a, a)) = fetch_assign(then) &&
+                let Some((lhs_b, b)) = fetch_assign(r#else) &&
+                SpanlessEq::new(cx).eq_expr(lhs_a, lhs_b) &&
+                span_extract_comment(cx.tcx.sess.source_map(), e.span).is_empty()
+            {
+                let mut applicability = Applicability::MachineApplicable;
+                let cond = Sugg::hir_with_applicability(cx, cond, "..", &mut applicability);
+                let lhs = snippet_with_applicability(cx, lhs_a.span, "..", &mut applicability);
+                let sugg = if a == b {
+                    format!("{cond}; {lhs} = {a:?};")
+                } else {
+                    format!("{lhs} = {};", if a { cond } else { !cond })
+                };
+                span_lint_and_sugg(
+                    cx,
+                    NEEDLESS_BOOL_ASSIGN,
+                    e.span,
+                    "this if-then-else expression assigns a bool literal",
+                    "you can reduce it to",
+                    sugg,
+                    applicability
+                );
+            }
         }
     }
 }
@@ -376,3 +433,11 @@ fn fetch_bool_expr(expr: &Expr<'_>) -> Option<bool> {
     }
     None
 }
+
+fn fetch_assign<'tcx>(expr: &'tcx Expr<'tcx>) -> Option<(&'tcx Expr<'tcx>, bool)> {
+    if let ExprKind::Assign(lhs, rhs, _) = peel_blocks_with_stmt(expr).kind {
+        fetch_bool_expr(rhs).map(|b| (lhs, b))
+    } else {
+        None
+    }
+}
diff --git a/tests/ui/needless_bool_assign.fixed b/tests/ui/needless_bool_assign.fixed
new file mode 100644
index 00000000000..3ed31d4d711
--- /dev/null
+++ b/tests/ui/needless_bool_assign.fixed
@@ -0,0 +1,33 @@
+//@run-rustfix
+
+#![allow(unused)]
+#![warn(clippy::needless_bool_assign)]
+
+fn random() -> bool {
+    true
+}
+
+fn main() {
+    struct Data {
+        field: bool,
+    };
+    let mut a = Data { field: false };
+    a.field = random() && random();
+    a.field = !(random() && random());
+    // Do not lint…
+    if random() {
+        a.field = false;
+    } else {
+        // …to avoid losing this comment
+        a.field = true
+    }
+    // This one also triggers lint `clippy::if_same_then_else`
+    // which does not suggest a rewrite.
+    random(); a.field = true;
+    let mut b = false;
+    if random() {
+        a.field = false;
+    } else {
+        b = true;
+    }
+}
diff --git a/tests/ui/needless_bool_assign.rs b/tests/ui/needless_bool_assign.rs
new file mode 100644
index 00000000000..efaeb67fa45
--- /dev/null
+++ b/tests/ui/needless_bool_assign.rs
@@ -0,0 +1,45 @@
+//@run-rustfix
+
+#![allow(unused)]
+#![warn(clippy::needless_bool_assign)]
+
+fn random() -> bool {
+    true
+}
+
+fn main() {
+    struct Data {
+        field: bool,
+    };
+    let mut a = Data { field: false };
+    if random() && random() {
+        a.field = true;
+    } else {
+        a.field = false
+    }
+    if random() && random() {
+        a.field = false;
+    } else {
+        a.field = true
+    }
+    // Do not lint…
+    if random() {
+        a.field = false;
+    } else {
+        // …to avoid losing this comment
+        a.field = true
+    }
+    // This one also triggers lint `clippy::if_same_then_else`
+    // which does not suggest a rewrite.
+    if random() {
+        a.field = true;
+    } else {
+        a.field = true;
+    }
+    let mut b = false;
+    if random() {
+        a.field = false;
+    } else {
+        b = true;
+    }
+}
diff --git a/tests/ui/needless_bool_assign.stderr b/tests/ui/needless_bool_assign.stderr
new file mode 100644
index 00000000000..601bbed5493
--- /dev/null
+++ b/tests/ui/needless_bool_assign.stderr
@@ -0,0 +1,53 @@
+error: this if-then-else expression assigns a bool literal
+  --> $DIR/needless_bool_assign.rs:15:5
+   |
+LL | /     if random() && random() {
+LL | |         a.field = true;
+LL | |     } else {
+LL | |         a.field = false
+LL | |     }
+   | |_____^ help: you can reduce it to: `a.field = random() && random();`
+   |
+   = note: `-D clippy::needless-bool-assign` implied by `-D warnings`
+
+error: this if-then-else expression assigns a bool literal
+  --> $DIR/needless_bool_assign.rs:20:5
+   |
+LL | /     if random() && random() {
+LL | |         a.field = false;
+LL | |     } else {
+LL | |         a.field = true
+LL | |     }
+   | |_____^ help: you can reduce it to: `a.field = !(random() && random());`
+
+error: this if-then-else expression assigns a bool literal
+  --> $DIR/needless_bool_assign.rs:34:5
+   |
+LL | /     if random() {
+LL | |         a.field = true;
+LL | |     } else {
+LL | |         a.field = true;
+LL | |     }
+   | |_____^ help: you can reduce it to: `random(); a.field = true;`
+
+error: this `if` has identical blocks
+  --> $DIR/needless_bool_assign.rs:34:17
+   |
+LL |       if random() {
+   |  _________________^
+LL | |         a.field = true;
+LL | |     } else {
+   | |_____^
+   |
+note: same as this
+  --> $DIR/needless_bool_assign.rs:36:12
+   |
+LL |       } else {
+   |  ____________^
+LL | |         a.field = true;
+LL | |     }
+   | |_____^
+   = note: `#[deny(clippy::if_same_then_else)]` on by default
+
+error: aborting due to 4 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From d2061faf9e7774bf8bc3ac6842cd2a095e1f2597 Mon Sep 17 00:00:00 2001
From: Josh Soref <2119212+jsoref@users.noreply.github.com>
Date: Thu, 13 Apr 2023 17:59:01 -0400
Subject: Spelling

* applying
* binding
* complex
* constituent
* demonstrate
* desugaring
* exact
* expression
* for
* functionalities
* github
* implementation
* infers
* multiple conflicting traits
* mutable
* necessarily
* nightly
* nonexistent
* optional
* parameter
* reassignments
* resources
* substitution
* suggestion
* that
* that array is
* using the

Signed-off-by: Josh Soref <2119212+jsoref@users.noreply.github.com>
---
 .../src/development/proposals/syntax-tree-patterns.md |  2 +-
 clippy_lints/src/casts/mod.rs                         |  2 +-
 clippy_lints/src/copies.rs                            |  2 +-
 clippy_lints/src/formatting.rs                        |  2 +-
 clippy_lints/src/from_over_into.rs                    |  2 +-
 clippy_lints/src/functions/misnamed_getters.rs        |  2 +-
 clippy_lints/src/functions/mod.rs                     |  2 +-
 clippy_lints/src/large_futures.rs                     |  2 +-
 clippy_lints/src/loops/manual_memcpy.rs               |  2 +-
 clippy_lints/src/manual_assert.rs                     |  2 +-
 clippy_lints/src/manual_let_else.rs                   |  2 +-
 clippy_lints/src/manual_retain.rs                     |  2 +-
 clippy_lints/src/missing_trait_methods.rs             |  2 +-
 clippy_lints/src/slow_vector_initialization.rs        |  2 +-
 clippy_lints/src/trailing_empty_array.rs              |  2 +-
 clippy_lints/src/types/mod.rs                         |  4 ++--
 clippy_lints/src/unnecessary_box_returns.rs           |  2 +-
 clippy_utils/src/ty.rs                                |  4 ++--
 lintcheck/src/main.rs                                 |  2 +-
 tests/ui/auxiliary/proc_macro_attr.rs                 |  2 +-
 tests/ui/cast_slice_different_sizes.rs                |  2 +-
 tests/ui/crashes/ice_exact_size.rs                    | 19 +++++++++++++++++++
 tests/ui/crashes/ice_exacte_size.rs                   | 19 -------------------
 tests/ui/from_over_into.stderr                        | 10 +++++-----
 tests/ui/from_over_into_unfixable.stderr              |  6 +++---
 tests/ui/let_with_type_underscore.rs                  |  2 +-
 tests/ui/manual_retain.fixed                          |  4 ++--
 tests/ui/manual_retain.rs                             |  4 ++--
 tests/ui/needless_for_each_fixable.fixed              |  2 +-
 tests/ui/needless_for_each_fixable.rs                 |  2 +-
 tests/ui/no_mangle_with_rust_abi.rs                   |  2 +-
 tests/ui/option_if_let_else.fixed                     |  2 +-
 tests/ui/option_if_let_else.rs                        |  2 +-
 tests/ui/same_name_method.rs                          |  2 +-
 tests/ui/trailing_empty_array.rs                      |  2 +-
 tests/ui/uninit.rs                                    |  4 ++--
 util/gh-pages/index.html                              |  2 +-
 37 files changed, 65 insertions(+), 65 deletions(-)
 create mode 100644 tests/ui/crashes/ice_exact_size.rs
 delete mode 100644 tests/ui/crashes/ice_exacte_size.rs

(limited to 'clippy_lints/src')

diff --git a/book/src/development/proposals/syntax-tree-patterns.md b/book/src/development/proposals/syntax-tree-patterns.md
index 36d722609f4..285488cec55 100644
--- a/book/src/development/proposals/syntax-tree-patterns.md
+++ b/book/src/development/proposals/syntax-tree-patterns.md
@@ -139,7 +139,7 @@ whether the pattern matched.
 
 ## Pattern syntax
 
-The following examples demonstate the pattern syntax:
+The following examples demonstrate the pattern syntax:
 
 
 #### Any (`_`)
diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index d74bd57fe45..cfeb75eed3b 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -638,7 +638,7 @@ declare_clippy_lint! {
     #[clippy::version = "1.66.0"]
     pub AS_PTR_CAST_MUT,
     nursery,
-    "casting the result of the `&self`-taking `as_ptr` to a mutabe pointer"
+    "casting the result of the `&self`-taking `as_ptr` to a mutable pointer"
 }
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/copies.rs b/clippy_lints/src/copies.rs
index 970f5004993..1c321f46e2d 100644
--- a/clippy_lints/src/copies.rs
+++ b/clippy_lints/src/copies.rs
@@ -591,7 +591,7 @@ fn lint_same_cond(cx: &LateContext<'_>, conds: &[&Expr<'_>], ignored_ty_ids: &De
         conds,
         |e| hash_expr(cx, e),
         |lhs, rhs| {
-            // Ignore eq_expr side effects iff one of the expressin kind is a method call
+            // Ignore eq_expr side effects iff one of the expression kind is a method call
             // and the caller is not a mutable, including inner mutable type.
             if let ExprKind::MethodCall(_, caller, _, _) = lhs.kind {
                 if method_caller_is_mutable(cx, caller, ignored_ty_ids) {
diff --git a/clippy_lints/src/formatting.rs b/clippy_lints/src/formatting.rs
index 4762b354392..62b419a5226 100644
--- a/clippy_lints/src/formatting.rs
+++ b/clippy_lints/src/formatting.rs
@@ -10,7 +10,7 @@ use rustc_span::source_map::Span;
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of the non-existent `=*`, `=!` and `=-`
+    /// Checks for usage of the nonexistent `=*`, `=!` and `=-`
     /// operators.
     ///
     /// ### Why is this bad?
diff --git a/clippy_lints/src/from_over_into.rs b/clippy_lints/src/from_over_into.rs
index bd66ace4500..10ce2a0f0c7 100644
--- a/clippy_lints/src/from_over_into.rs
+++ b/clippy_lints/src/from_over_into.rs
@@ -94,7 +94,7 @@ impl<'tcx> LateLintPass<'tcx> for FromOverInto {
                         );
                     }
 
-                    let message = format!("replace the `Into` implentation with `From<{}>`", middle_trait_ref.self_ty());
+                    let message = format!("replace the `Into` implementation with `From<{}>`", middle_trait_ref.self_ty());
                     if let Some(suggestions) = convert_to_from(cx, into_trait_seg, target_ty, self_ty, impl_item_ref) {
                         diag.multipart_suggestion(message, suggestions, Applicability::MachineApplicable);
                     } else {
diff --git a/clippy_lints/src/functions/misnamed_getters.rs b/clippy_lints/src/functions/misnamed_getters.rs
index e5945939e60..b244b913314 100644
--- a/clippy_lints/src/functions/misnamed_getters.rs
+++ b/clippy_lints/src/functions/misnamed_getters.rs
@@ -40,7 +40,7 @@ pub fn check_fn(cx: &LateContext<'_>, kind: FnKind<'_>, decl: &FnDecl<'_>, body:
     };
 
     // Body must be &(mut) <self_data>.name
-    // self_data is not neccessarilly self, to also lint sub-getters, etc…
+    // self_data is not necessarily self, to also lint sub-getters, etc…
 
     let block_expr = if_chain! {
         if let ExprKind::Block(block,_) = body.value.kind;
diff --git a/clippy_lints/src/functions/mod.rs b/clippy_lints/src/functions/mod.rs
index 7c5e44bb7dc..c485bf8a473 100644
--- a/clippy_lints/src/functions/mod.rs
+++ b/clippy_lints/src/functions/mod.rs
@@ -330,7 +330,7 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Lints when `impl Trait` is being used in a function's paremeters.
+    /// Lints when `impl Trait` is being used in a function's parameters.
     /// ### Why is this bad?
     /// Turbofish syntax (`::<>`) cannot be used when `impl Trait` is being used, making `impl Trait` less powerful. Readability may also be a factor.
     ///
diff --git a/clippy_lints/src/large_futures.rs b/clippy_lints/src/large_futures.rs
index 1b054481371..0ca31033b16 100644
--- a/clippy_lints/src/large_futures.rs
+++ b/clippy_lints/src/large_futures.rs
@@ -11,7 +11,7 @@ declare_clippy_lint! {
     /// It checks for the size of a `Future` created by `async fn` or `async {}`.
     ///
     /// ### Why is this bad?
-    /// Due to the current [unideal implemention](https://github.com/rust-lang/rust/issues/69826) of `Generator`,
+    /// Due to the current [unideal implementation](https://github.com/rust-lang/rust/issues/69826) of `Generator`,
     /// large size of a `Future` may cause stack overflows.
     ///
     /// ### Example
diff --git a/clippy_lints/src/loops/manual_memcpy.rs b/clippy_lints/src/loops/manual_memcpy.rs
index c87fc4f90e2..d4c3f76b864 100644
--- a/clippy_lints/src/loops/manual_memcpy.rs
+++ b/clippy_lints/src/loops/manual_memcpy.rs
@@ -15,7 +15,7 @@ use rustc_span::symbol::sym;
 use std::fmt::Display;
 use std::iter::Iterator;
 
-/// Checks for for loops that sequentially copy items from one slice-like
+/// Checks for `for` loops that sequentially copy items from one slice-like
 /// object to another.
 pub(super) fn check<'tcx>(
     cx: &LateContext<'tcx>,
diff --git a/clippy_lints/src/manual_assert.rs b/clippy_lints/src/manual_assert.rs
index ce5d657bcf0..45ea5aab4c2 100644
--- a/clippy_lints/src/manual_assert.rs
+++ b/clippy_lints/src/manual_assert.rs
@@ -64,7 +64,7 @@ impl<'tcx> LateLintPass<'tcx> for ManualAssert {
             };
             let cond_sugg = sugg::Sugg::hir_with_applicability(cx, cond, "..", &mut applicability).maybe_par();
             let sugg = format!("assert!({not}{cond_sugg}, {format_args_snip});");
-            // we show to the user the suggestion without the comments, but when applicating the fix, include the comments in the block
+            // we show to the user the suggestion without the comments, but when applying the fix, include the comments in the block
             span_lint_and_then(
                 cx,
                 MANUAL_ASSERT,
diff --git a/clippy_lints/src/manual_let_else.rs b/clippy_lints/src/manual_let_else.rs
index 98e698c6c2a..1247370b74a 100644
--- a/clippy_lints/src/manual_let_else.rs
+++ b/clippy_lints/src/manual_let_else.rs
@@ -101,7 +101,7 @@ impl<'tcx> LateLintPass<'tcx> for ManualLetElse {
                 if source != MatchSource::Normal {
                     return;
                 }
-                // Any other number than two arms doesn't (neccessarily)
+                // Any other number than two arms doesn't (necessarily)
                 // have a trivial mapping to let else.
                 if arms.len() != 2 {
                     return;
diff --git a/clippy_lints/src/manual_retain.rs b/clippy_lints/src/manual_retain.rs
index 72cdb9c1736..5259066eb71 100644
--- a/clippy_lints/src/manual_retain.rs
+++ b/clippy_lints/src/manual_retain.rs
@@ -46,7 +46,7 @@ declare_clippy_lint! {
     #[clippy::version = "1.64.0"]
     pub MANUAL_RETAIN,
     perf,
-    "`retain()` is simpler and the same functionalitys"
+    "`retain()` is simpler and the same functionalities"
 }
 
 pub struct ManualRetain {
diff --git a/clippy_lints/src/missing_trait_methods.rs b/clippy_lints/src/missing_trait_methods.rs
index e99081ad062..1adecd2caac 100644
--- a/clippy_lints/src/missing_trait_methods.rs
+++ b/clippy_lints/src/missing_trait_methods.rs
@@ -12,7 +12,7 @@ declare_clippy_lint! {
     /// Checks if a provided method is used implicitly by a trait
     /// implementation. A usage example would be a wrapper where every method
     /// should perform some operation before delegating to the inner type's
-    /// implemenation.
+    /// implementation.
     ///
     /// This lint should typically be enabled on a specific trait `impl` item
     /// rather than globally.
diff --git a/clippy_lints/src/slow_vector_initialization.rs b/clippy_lints/src/slow_vector_initialization.rs
index a2109038a05..858135c8d46 100644
--- a/clippy_lints/src/slow_vector_initialization.rs
+++ b/clippy_lints/src/slow_vector_initialization.rs
@@ -74,7 +74,7 @@ enum InitializationType<'tcx> {
 
 impl<'tcx> LateLintPass<'tcx> for SlowVectorInit {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        // Matches initialization on reassignements. For example: `vec = Vec::with_capacity(100)`
+        // Matches initialization on reassignments. For example: `vec = Vec::with_capacity(100)`
         if_chain! {
             if let ExprKind::Assign(left, right, _) = expr.kind;
 
diff --git a/clippy_lints/src/trailing_empty_array.rs b/clippy_lints/src/trailing_empty_array.rs
index 1382c1a40da..f40229e03a2 100644
--- a/clippy_lints/src/trailing_empty_array.rs
+++ b/clippy_lints/src/trailing_empty_array.rs
@@ -60,7 +60,7 @@ fn is_struct_with_trailing_zero_sized_array(cx: &LateContext<'_>, item: &Item<'_
         if let Some(last_field) = data.fields().last();
         if let rustc_hir::TyKind::Array(_, rustc_hir::ArrayLen::Body(length)) = last_field.ty.kind;
 
-        // Then check if that that array zero-sized
+        // Then check if that array is zero-sized
         let length = Const::from_anon_const(cx.tcx, length.def_id);
         let length = length.try_eval_target_usize(cx.tcx, cx.param_env);
         if let Some(length) = length;
diff --git a/clippy_lints/src/types/mod.rs b/clippy_lints/src/types/mod.rs
index c6834a8fdaa..3c873a5901d 100644
--- a/clippy_lints/src/types/mod.rs
+++ b/clippy_lints/src/types/mod.rs
@@ -90,8 +90,8 @@ declare_clippy_lint! {
     ///
     /// ### Why is this bad?
     /// `Option<_>` represents an optional value. `Option<Option<_>>`
-    /// represents an optional optional value which is logically the same thing as an optional
-    /// value but has an unneeded extra level of wrapping.
+    /// represents an optional value which itself wraps an optional. This is logically the
+    /// same thing as an optional value but has an unneeded extra level of wrapping.
     ///
     /// If you have a case where `Some(Some(_))`, `Some(None)` and `None` are distinct cases,
     /// consider a custom `enum` instead, with clear names for each case.
diff --git a/clippy_lints/src/unnecessary_box_returns.rs b/clippy_lints/src/unnecessary_box_returns.rs
index 912bcda630b..407a38779aa 100644
--- a/clippy_lints/src/unnecessary_box_returns.rs
+++ b/clippy_lints/src/unnecessary_box_returns.rs
@@ -102,7 +102,7 @@ impl LateLintPass<'_> for UnnecessaryBoxReturns {
 
     fn check_impl_item(&mut self, cx: &LateContext<'_>, item: &rustc_hir::ImplItem<'_>) {
         // Ignore implementations of traits, because the lint should be on the
-        // trait, not on the implmentation of it.
+        // trait, not on the implementation of it.
         let Node::Item(parent) = cx.tcx.hir().get_parent(item.hir_id()) else { return };
         let ItemKind::Impl(parent) = parent.kind else { return };
         if parent.of_trait.is_some() {
diff --git a/clippy_utils/src/ty.rs b/clippy_utils/src/ty.rs
index 9449f0b5567..3fcab34047e 100644
--- a/clippy_utils/src/ty.rs
+++ b/clippy_utils/src/ty.rs
@@ -93,7 +93,7 @@ pub fn contains_ty_adt_constructor_opaque<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'
                     for &(predicate, _span) in cx.tcx.explicit_item_bounds(def_id) {
                         match predicate.kind().skip_binder() {
                             // For `impl Trait<U>`, it will register a predicate of `T: Trait<U>`, so we go through
-                            // and check substituions to find `U`.
+                            // and check substitutions to find `U`.
                             ty::PredicateKind::Clause(ty::Clause::Trait(trait_predicate)) => {
                                 if trait_predicate
                                     .trait_ref
@@ -1101,7 +1101,7 @@ pub fn make_projection<'tcx>(
 ///
 /// This function is for associated types which are "known" to be valid with the given
 /// substitutions, and as such, will only return `None` when debug assertions are disabled in order
-/// to prevent ICE's. With debug assertions enabled this will check that that type normalization
+/// to prevent ICE's. With debug assertions enabled this will check that type normalization
 /// succeeds as well as everything checked by `make_projection`.
 pub fn make_normalized_projection<'tcx>(
     tcx: TyCtxt<'tcx>,
diff --git a/lintcheck/src/main.rs b/lintcheck/src/main.rs
index 23c85298027..03d1877d6c6 100644
--- a/lintcheck/src/main.rs
+++ b/lintcheck/src/main.rs
@@ -421,7 +421,7 @@ impl Crate {
             {
                 let subcrate = &stderr[63..];
                 println!(
-                    "ERROR: failed to apply some suggetion to {} / to (sub)crate {subcrate}",
+                    "ERROR: failed to apply some suggestion to {} / to (sub)crate {subcrate}",
                     self.name
                 );
             }
diff --git a/tests/ui/auxiliary/proc_macro_attr.rs b/tests/ui/auxiliary/proc_macro_attr.rs
index b498fece513..9b4b3aef64a 100644
--- a/tests/ui/auxiliary/proc_macro_attr.rs
+++ b/tests/ui/auxiliary/proc_macro_attr.rs
@@ -82,7 +82,7 @@ pub fn rename_my_lifetimes(_args: TokenStream, input: TokenStream) -> TokenStrea
                     elided += 1;
 
                     // HACK: Syn uses `Span` from the proc_macro2 crate, and does not seem to reexport it.
-                    // In order to avoid adding the dependency, get a default span from a non-existent token.
+                    // In order to avoid adding the dependency, get a default span from a nonexistent token.
                     // A default span is needed to mark the code as coming from expansion.
                     let span = Star::default().span();
 
diff --git a/tests/ui/cast_slice_different_sizes.rs b/tests/ui/cast_slice_different_sizes.rs
index 24d7eb28a19..b77f01883bf 100644
--- a/tests/ui/cast_slice_different_sizes.rs
+++ b/tests/ui/cast_slice_different_sizes.rs
@@ -23,7 +23,7 @@ fn main() {
         r_x as *const [i32]
     } as *const [u8];
 
-    // Check that resores of the same size are detected through blocks
+    // Check that resources of the same size are detected through blocks
     let restore_block_1 = { r_x as *const [i32] } as *const [u8] as *const [u32];
     let restore_block_2 = { ({ r_x as *const [i32] }) as *const [u8] } as *const [u32];
     let restore_block_3 = {
diff --git a/tests/ui/crashes/ice_exact_size.rs b/tests/ui/crashes/ice_exact_size.rs
new file mode 100644
index 00000000000..30e4b11ec0b
--- /dev/null
+++ b/tests/ui/crashes/ice_exact_size.rs
@@ -0,0 +1,19 @@
+#![deny(clippy::all)]
+
+/// Test for https://github.com/rust-lang/rust-clippy/issues/1336
+
+#[allow(dead_code)]
+struct Foo;
+
+impl Iterator for Foo {
+    type Item = ();
+
+    fn next(&mut self) -> Option<()> {
+        let _ = self.len() == 0;
+        unimplemented!()
+    }
+}
+
+impl ExactSizeIterator for Foo {}
+
+fn main() {}
diff --git a/tests/ui/crashes/ice_exacte_size.rs b/tests/ui/crashes/ice_exacte_size.rs
deleted file mode 100644
index 30e4b11ec0b..00000000000
--- a/tests/ui/crashes/ice_exacte_size.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-#![deny(clippy::all)]
-
-/// Test for https://github.com/rust-lang/rust-clippy/issues/1336
-
-#[allow(dead_code)]
-struct Foo;
-
-impl Iterator for Foo {
-    type Item = ();
-
-    fn next(&mut self) -> Option<()> {
-        let _ = self.len() == 0;
-        unimplemented!()
-    }
-}
-
-impl ExactSizeIterator for Foo {}
-
-fn main() {}
diff --git a/tests/ui/from_over_into.stderr b/tests/ui/from_over_into.stderr
index 3c4d011d6fb..990b905c1b1 100644
--- a/tests/ui/from_over_into.stderr
+++ b/tests/ui/from_over_into.stderr
@@ -5,7 +5,7 @@ LL | impl Into<StringWrapper> for String {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::from-over-into` implied by `-D warnings`
-help: replace the `Into` implentation with `From<std::string::String>`
+help: replace the `Into` implementation with `From<std::string::String>`
    |
 LL ~ impl From<String> for StringWrapper {
 LL ~     fn from(val: String) -> Self {
@@ -18,7 +18,7 @@ error: an implementation of `From` is preferred since it gives you `Into<_>` for
 LL | impl Into<SelfType> for String {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-help: replace the `Into` implentation with `From<std::string::String>`
+help: replace the `Into` implementation with `From<std::string::String>`
    |
 LL ~ impl From<String> for SelfType {
 LL ~     fn from(val: String) -> Self {
@@ -31,7 +31,7 @@ error: an implementation of `From` is preferred since it gives you `Into<_>` for
 LL | impl Into<SelfKeywords> for X {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-help: replace the `Into` implentation with `From<X>`
+help: replace the `Into` implementation with `From<X>`
    |
 LL ~ impl From<X> for SelfKeywords {
 LL ~     fn from(val: X) -> Self {
@@ -48,7 +48,7 @@ LL | impl core::convert::Into<bool> for crate::ExplicitPaths {
    |
    = help: `impl From<Local> for Foreign` is allowed by the orphan rules, for more information see
            https://doc.rust-lang.org/reference/items/implementations.html#trait-implementation-coherence
-help: replace the `Into` implentation with `From<ExplicitPaths>`
+help: replace the `Into` implementation with `From<ExplicitPaths>`
    |
 LL ~ impl core::convert::From<crate::ExplicitPaths> for bool {
 LL ~     fn from(mut val: crate::ExplicitPaths) -> Self {
@@ -64,7 +64,7 @@ error: an implementation of `From` is preferred since it gives you `Into<_>` for
 LL |     impl<T> Into<FromOverInto<T>> for Vec<T> {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-help: replace the `Into` implentation with `From<std::vec::Vec<T>>`
+help: replace the `Into` implementation with `From<std::vec::Vec<T>>`
    |
 LL ~     impl<T> From<Vec<T>> for FromOverInto<T> {
 LL ~         fn from(val: Vec<T>) -> Self {
diff --git a/tests/ui/from_over_into_unfixable.stderr b/tests/ui/from_over_into_unfixable.stderr
index 6f6ce351921..251f1d84e74 100644
--- a/tests/ui/from_over_into_unfixable.stderr
+++ b/tests/ui/from_over_into_unfixable.stderr
@@ -4,7 +4,7 @@ error: an implementation of `From` is preferred since it gives you `Into<_>` for
 LL | impl Into<InMacro> for String {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: replace the `Into` implentation with `From<std::string::String>`
+   = help: replace the `Into` implementation with `From<std::string::String>`
    = note: `-D clippy::from-over-into` implied by `-D warnings`
 
 error: an implementation of `From` is preferred since it gives you `Into<_>` for free where the reverse isn't true
@@ -13,7 +13,7 @@ error: an implementation of `From` is preferred since it gives you `Into<_>` for
 LL | impl Into<WeirdUpperSelf> for &'static [u8] {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: replace the `Into` implentation with `From<&'static [u8]>`
+   = help: replace the `Into` implementation with `From<&'static [u8]>`
 
 error: an implementation of `From` is preferred since it gives you `Into<_>` for free where the reverse isn't true
   --> $DIR/from_over_into_unfixable.rs:28:1
@@ -23,7 +23,7 @@ LL | impl Into<u8> for ContainsVal {
    |
    = help: `impl From<Local> for Foreign` is allowed by the orphan rules, for more information see
            https://doc.rust-lang.org/reference/items/implementations.html#trait-implementation-coherence
-   = help: replace the `Into` implentation with `From<ContainsVal>`
+   = help: replace the `Into` implementation with `From<ContainsVal>`
 
 error: aborting due to 3 previous errors
 
diff --git a/tests/ui/let_with_type_underscore.rs b/tests/ui/let_with_type_underscore.rs
index 175718b94c8..7c1835e8cd1 100644
--- a/tests/ui/let_with_type_underscore.rs
+++ b/tests/ui/let_with_type_underscore.rs
@@ -12,7 +12,7 @@ fn main() {
     let _: _ = 2;
     let x: _ = func();
 
-    let x = 1; // Will not lint, Rust inferres this to an integer before Clippy
+    let x = 1; // Will not lint, Rust infers this to an integer before Clippy
     let x = func();
     let x: Vec<_> = Vec::<u32>::new();
     let x: [_; 1] = [1];
diff --git a/tests/ui/manual_retain.fixed b/tests/ui/manual_retain.fixed
index 8f25fea678f..fa3773dc908 100644
--- a/tests/ui/manual_retain.fixed
+++ b/tests/ui/manual_retain.fixed
@@ -23,8 +23,8 @@ fn main() {
 }
 
 fn binary_heap_retain() {
-    // NOTE: Do not lint now, because binary_heap_retain is nighyly API.
-    // And we need to add a test case for msrv if we update this implmention.
+    // NOTE: Do not lint now, because binary_heap_retain is nightly API.
+    // And we need to add a test case for msrv if we update this implementation.
     // https://github.com/rust-lang/rust/issues/71503
     let mut heap = BinaryHeap::from([1, 2, 3]);
     heap = heap.into_iter().filter(|x| x % 2 == 0).collect();
diff --git a/tests/ui/manual_retain.rs b/tests/ui/manual_retain.rs
index e6b3995a689..f982a105597 100644
--- a/tests/ui/manual_retain.rs
+++ b/tests/ui/manual_retain.rs
@@ -23,8 +23,8 @@ fn main() {
 }
 
 fn binary_heap_retain() {
-    // NOTE: Do not lint now, because binary_heap_retain is nighyly API.
-    // And we need to add a test case for msrv if we update this implmention.
+    // NOTE: Do not lint now, because binary_heap_retain is nightly API.
+    // And we need to add a test case for msrv if we update this implementation.
     // https://github.com/rust-lang/rust/issues/71503
     let mut heap = BinaryHeap::from([1, 2, 3]);
     heap = heap.into_iter().filter(|x| x % 2 == 0).collect();
diff --git a/tests/ui/needless_for_each_fixable.fixed b/tests/ui/needless_for_each_fixable.fixed
index 09e671b88e1..5ee7f1fb2b6 100644
--- a/tests/ui/needless_for_each_fixable.fixed
+++ b/tests/ui/needless_for_each_fixable.fixed
@@ -110,7 +110,7 @@ fn should_not_lint() {
         }),
     }
 
-    // `for_each` is in a let bingind.
+    // `for_each` is in a let binding.
     let _ = v.iter().for_each(|elem| {
         acc += elem;
     });
diff --git a/tests/ui/needless_for_each_fixable.rs b/tests/ui/needless_for_each_fixable.rs
index abb4045b919..ec4da9eb997 100644
--- a/tests/ui/needless_for_each_fixable.rs
+++ b/tests/ui/needless_for_each_fixable.rs
@@ -110,7 +110,7 @@ fn should_not_lint() {
         }),
     }
 
-    // `for_each` is in a let bingind.
+    // `for_each` is in a let binding.
     let _ = v.iter().for_each(|elem| {
         acc += elem;
     });
diff --git a/tests/ui/no_mangle_with_rust_abi.rs b/tests/ui/no_mangle_with_rust_abi.rs
index b32e721110e..818119f7be5 100644
--- a/tests/ui/no_mangle_with_rust_abi.rs
+++ b/tests/ui/no_mangle_with_rust_abi.rs
@@ -25,7 +25,7 @@ fn rust_abi_multiline_function_really_long_name_to_overflow_args_to_multiple_lin
     0
 }
 
-// Must not run on functions that explicitly opt in to Rust ABI with `extern "Rust"`
+// Must not run on functions that explicitly opt in to using the Rust ABI with `extern "Rust"`
 #[no_mangle]
 #[rustfmt::skip]
 extern "Rust" fn rust_abi_fn_explicit_opt_in(arg_one: u32, arg_two: usize) {}
diff --git a/tests/ui/option_if_let_else.fixed b/tests/ui/option_if_let_else.fixed
index 0456005dce4..d4343c98d27 100644
--- a/tests/ui/option_if_let_else.fixed
+++ b/tests/ui/option_if_let_else.fixed
@@ -97,7 +97,7 @@ enum DummyEnum {
     Two,
 }
 
-// should not warn since there is a compled complex subpat
+// should not warn since there is a complex subpat
 // see #7991
 fn complex_subpat() -> DummyEnum {
     let x = Some(DummyEnum::One(1));
diff --git a/tests/ui/option_if_let_else.rs b/tests/ui/option_if_let_else.rs
index 23b148752cb..c78e31fed96 100644
--- a/tests/ui/option_if_let_else.rs
+++ b/tests/ui/option_if_let_else.rs
@@ -120,7 +120,7 @@ enum DummyEnum {
     Two,
 }
 
-// should not warn since there is a compled complex subpat
+// should not warn since there is a complex subpat
 // see #7991
 fn complex_subpat() -> DummyEnum {
     let x = Some(DummyEnum::One(1));
diff --git a/tests/ui/same_name_method.rs b/tests/ui/same_name_method.rs
index daef95a425c..f31a7e33c4b 100644
--- a/tests/ui/same_name_method.rs
+++ b/tests/ui/same_name_method.rs
@@ -62,7 +62,7 @@ mod should_lint {
         impl T1 for S {}
     }
 
-    mod multiply_conflicit_trait {
+    mod multiple_conflicting_traits {
         use crate::{T1, T2};
 
         struct S;
diff --git a/tests/ui/trailing_empty_array.rs b/tests/ui/trailing_empty_array.rs
index 8e3749eef35..928475b5f35 100644
--- a/tests/ui/trailing_empty_array.rs
+++ b/tests/ui/trailing_empty_array.rs
@@ -144,7 +144,7 @@ struct ReprCAlign {
 
 // NOTE: because of https://doc.rust-lang.org/stable/reference/type-layout.html#primitive-representation-of-enums-with-fields and I'm not sure when in the compilation pipeline that would happen
 #[repr(C)]
-enum DontLintAnonymousStructsFromDesuraging {
+enum DontLintAnonymousStructsFromDesugaring {
     A(u32),
     B(f32, [u64; 0]),
     C { x: u32, y: [u64; 0] },
diff --git a/tests/ui/uninit.rs b/tests/ui/uninit.rs
index c996de89422..2d567630e15 100644
--- a/tests/ui/uninit.rs
+++ b/tests/ui/uninit.rs
@@ -17,10 +17,10 @@ fn main() {
     // This is OK, because `MaybeUninit` allows uninitialized data.
     let _: MaybeUninit<usize> = unsafe { MaybeUninit::uninit().assume_init() };
 
-    // This is OK, because all constitutent types are uninit-compatible.
+    // This is OK, because all constituent types are uninit-compatible.
     let _: (MaybeUninit<usize>, MaybeUninit<bool>) = unsafe { MaybeUninit::uninit().assume_init() };
 
-    // This is OK, because all constitutent types are uninit-compatible.
+    // This is OK, because all constituent types are uninit-compatible.
     let _: (MaybeUninit<usize>, [MaybeUninit<bool>; 2]) = unsafe { MaybeUninit::uninit().assume_init() };
 
     // This is OK, because our own MaybeUninit is just as fine as the one from core.
diff --git a/util/gh-pages/index.html b/util/gh-pages/index.html
index e46ad2c6e0e..8791debad72 100644
--- a/util/gh-pages/index.html
+++ b/util/gh-pages/index.html
@@ -564,7 +564,7 @@ Otherwise, have a great day =^.^=
     </div>
 
     <a href="https://github.com/rust-lang/rust-clippy">
-        <img style="position: absolute; top: 0; right: 0; border: 0; clip-path: polygon(0% 0%, 100% 0%, 100% 100%);" src="https://s3.amazonaws.com/github/ribbons/forkme_right_darkblue_121621.png" alt="Fork me on Github"/>
+        <img style="position: absolute; top: 0; right: 0; border: 0; clip-path: polygon(0% 0%, 100% 0%, 100% 100%);" src="https://s3.amazonaws.com/github/ribbons/forkme_right_darkblue_121621.png" alt="Fork me on GitHub"/>
     </a>
 
     <script src="https://cdnjs.cloudflare.com/ajax/libs/markdown-it/12.3.2/markdown-it.min.js"></script>
-- 
cgit 1.4.1-3-g733a5


From e8726b20b2a64b4553c87d02a330fd2bc62064bd Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Sun, 23 Apr 2023 21:34:42 +0200
Subject: also check for rest pat in `redundant_pattern_matching`

---
 clippy_lints/src/indexing_slicing.rs               |  2 +-
 .../src/matches/redundant_pattern_match.rs         |  7 +++++--
 tests/ui/redundant_pattern_matching_option.fixed   |  2 ++
 tests/ui/redundant_pattern_matching_option.rs      |  2 ++
 tests/ui/redundant_pattern_matching_option.stderr  | 24 ++++++++++++++--------
 5 files changed, 25 insertions(+), 12 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/indexing_slicing.rs b/clippy_lints/src/indexing_slicing.rs
index c384172fbde..924a361c0f6 100644
--- a/clippy_lints/src/indexing_slicing.rs
+++ b/clippy_lints/src/indexing_slicing.rs
@@ -170,7 +170,7 @@ impl<'tcx> LateLintPass<'tcx> for IndexingSlicing {
                         return;
                     }
                     // Index is a constant uint.
-                    if let Some(..) = constant(cx, cx.typeck_results(), index) {
+                    if constant(cx, cx.typeck_results(), index).is_some() {
                         // Let rustc's `const_err` lint handle constant `usize` indexing on arrays.
                         return;
                     }
diff --git a/clippy_lints/src/matches/redundant_pattern_match.rs b/clippy_lints/src/matches/redundant_pattern_match.rs
index fb9f9c1122f..af121f317cd 100644
--- a/clippy_lints/src/matches/redundant_pattern_match.rs
+++ b/clippy_lints/src/matches/redundant_pattern_match.rs
@@ -63,8 +63,11 @@ fn find_sugg_for_if_let<'tcx>(
     // Determine which function should be used, and the type contained by the corresponding
     // variant.
     let (good_method, inner_ty) = match check_pat.kind {
-        PatKind::TupleStruct(ref qpath, [sub_pat], _) => {
-            if let PatKind::Wild = sub_pat.kind {
+        PatKind::TupleStruct(ref qpath, args, rest) => {
+            let is_wildcard = matches!(args.first().map(|p| &p.kind), Some(PatKind::Wild));
+            let is_rest = matches!((args, rest.as_opt_usize()), ([], Some(_)));
+
+            if is_wildcard || is_rest {
                 let res = cx.typeck_results().qpath_res(qpath, check_pat.hir_id);
                 let Some(id) = res.opt_def_id().map(|ctor_id| cx.tcx.parent(ctor_id)) else { return };
                 let lang_items = cx.tcx.lang_items();
diff --git a/tests/ui/redundant_pattern_matching_option.fixed b/tests/ui/redundant_pattern_matching_option.fixed
index 87100b97288..d62f7d26a35 100644
--- a/tests/ui/redundant_pattern_matching_option.fixed
+++ b/tests/ui/redundant_pattern_matching_option.fixed
@@ -54,6 +54,8 @@ fn main() {
     } else {
         3
     };
+
+    if gen_opt().is_some() {}
 }
 
 fn gen_opt() -> Option<()> {
diff --git a/tests/ui/redundant_pattern_matching_option.rs b/tests/ui/redundant_pattern_matching_option.rs
index 0b69e13f655..d6429426573 100644
--- a/tests/ui/redundant_pattern_matching_option.rs
+++ b/tests/ui/redundant_pattern_matching_option.rs
@@ -63,6 +63,8 @@ fn main() {
     } else {
         3
     };
+
+    if let Some(..) = gen_opt() {}
 }
 
 fn gen_opt() -> Option<()> {
diff --git a/tests/ui/redundant_pattern_matching_option.stderr b/tests/ui/redundant_pattern_matching_option.stderr
index 27ff812ba45..7c5a047e455 100644
--- a/tests/ui/redundant_pattern_matching_option.stderr
+++ b/tests/ui/redundant_pattern_matching_option.stderr
@@ -89,31 +89,37 @@ 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:80:12
+  --> $DIR/redundant_pattern_matching_option.rs:67:12
+   |
+LL |     if let Some(..) = gen_opt() {}
+   |     -------^^^^^^^^------------ help: try this: `if gen_opt().is_some()`
+
+error: redundant pattern matching, consider using `is_some()`
+  --> $DIR/redundant_pattern_matching_option.rs:82: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:82:12
+  --> $DIR/redundant_pattern_matching_option.rs:84: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:84:15
+  --> $DIR/redundant_pattern_matching_option.rs:86: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:86:15
+  --> $DIR/redundant_pattern_matching_option.rs:88: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:88:5
+  --> $DIR/redundant_pattern_matching_option.rs:90:5
    |
 LL | /     match Some(42) {
 LL | |         Some(_) => true,
@@ -122,7 +128,7 @@ LL | |     };
    | |_____^ help: try this: `Some(42).is_some()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:93:5
+  --> $DIR/redundant_pattern_matching_option.rs:95:5
    |
 LL | /     match None::<()> {
 LL | |         Some(_) => false,
@@ -131,16 +137,16 @@ LL | |     };
    | |_____^ help: try this: `None::<()>.is_none()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:101:12
+  --> $DIR/redundant_pattern_matching_option.rs:103:12
    |
 LL |     if let None = *(&None::<()>) {}
    |     -------^^^^----------------- help: try this: `if (&None::<()>).is_none()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:102:12
+  --> $DIR/redundant_pattern_matching_option.rs:104:12
    |
 LL |     if let None = *&None::<()> {}
    |     -------^^^^--------------- help: try this: `if (&None::<()>).is_none()`
 
-error: aborting due to 21 previous errors
+error: aborting due to 22 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From acfb2c45ba337b3265ab35dee5c94d3641c3ccf7 Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Tue, 18 Apr 2023 02:14:00 -0500
Subject: don't check if from macro invocation

---
 clippy_lints/src/strings.rs         |  4 ++++
 tests/ui/string_lit_as_bytes.fixed  |  8 ++++++++
 tests/ui/string_lit_as_bytes.rs     |  8 ++++++++
 tests/ui/string_lit_as_bytes.stderr | 12 ++++++------
 4 files changed, 26 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/strings.rs b/clippy_lints/src/strings.rs
index b2f4b310915..c8ea151ffce 100644
--- a/clippy_lints/src/strings.rs
+++ b/clippy_lints/src/strings.rs
@@ -253,6 +253,10 @@ impl<'tcx> LateLintPass<'tcx> for StringLitAsBytes {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
         use rustc_ast::LitKind;
 
+        if e.span.from_expansion() {
+            return;
+        }
+
         if_chain! {
             // Find std::str::converts::from_utf8
             if let Some(args) = match_function_call(cx, e, &paths::STR_FROM_UTF8);
diff --git a/tests/ui/string_lit_as_bytes.fixed b/tests/ui/string_lit_as_bytes.fixed
index 058f2aa54da..14cb799d916 100644
--- a/tests/ui/string_lit_as_bytes.fixed
+++ b/tests/ui/string_lit_as_bytes.fixed
@@ -3,6 +3,12 @@
 #![allow(dead_code, unused_variables)]
 #![warn(clippy::string_lit_as_bytes)]
 
+macro_rules! b {
+    ($b:literal) => {
+        const C: &[u8] = $b.as_bytes();
+    }
+}
+
 fn str_lit_as_bytes() {
     let bs = b"hello there";
 
@@ -11,6 +17,8 @@ fn str_lit_as_bytes() {
     let bs = b"lit to string".to_vec();
     let bs = b"lit to owned".to_vec();
 
+    b!("aaa");
+
     // no warning, because these cannot be written as byte string literals:
     let ubs = "☃".as_bytes();
     let ubs = "hello there! this is a very long string".as_bytes();
diff --git a/tests/ui/string_lit_as_bytes.rs b/tests/ui/string_lit_as_bytes.rs
index b550bea001f..44b468e6bf0 100644
--- a/tests/ui/string_lit_as_bytes.rs
+++ b/tests/ui/string_lit_as_bytes.rs
@@ -3,6 +3,12 @@
 #![allow(dead_code, unused_variables)]
 #![warn(clippy::string_lit_as_bytes)]
 
+macro_rules! b {
+    ($b:literal) => {
+        const C: &[u8] = $b.as_bytes();
+    }
+}
+
 fn str_lit_as_bytes() {
     let bs = "hello there".as_bytes();
 
@@ -11,6 +17,8 @@ fn str_lit_as_bytes() {
     let bs = "lit to string".to_string().into_bytes();
     let bs = "lit to owned".to_owned().into_bytes();
 
+    b!("aaa");
+
     // no warning, because these cannot be written as byte string literals:
     let ubs = "☃".as_bytes();
     let ubs = "hello there! this is a very long string".as_bytes();
diff --git a/tests/ui/string_lit_as_bytes.stderr b/tests/ui/string_lit_as_bytes.stderr
index f47d6161c6c..5be3eb9f2ff 100644
--- a/tests/ui/string_lit_as_bytes.stderr
+++ b/tests/ui/string_lit_as_bytes.stderr
@@ -1,5 +1,5 @@
 error: calling `as_bytes()` on a string literal
-  --> $DIR/string_lit_as_bytes.rs:7:14
+  --> $DIR/string_lit_as_bytes.rs:13:14
    |
 LL |     let bs = "hello there".as_bytes();
    |              ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using a byte string literal instead: `b"hello there"`
@@ -7,31 +7,31 @@ LL |     let bs = "hello there".as_bytes();
    = note: `-D clippy::string-lit-as-bytes` implied by `-D warnings`
 
 error: calling `as_bytes()` on a string literal
-  --> $DIR/string_lit_as_bytes.rs:9:14
+  --> $DIR/string_lit_as_bytes.rs:15:14
    |
 LL |     let bs = r###"raw string with 3# plus " ""###.as_bytes();
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using a byte string literal instead: `br###"raw string with 3# plus " ""###`
 
 error: calling `into_bytes()` on a string literal
-  --> $DIR/string_lit_as_bytes.rs:11:14
+  --> $DIR/string_lit_as_bytes.rs:17:14
    |
 LL |     let bs = "lit to string".to_string().into_bytes();
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using a byte string literal instead: `b"lit to string".to_vec()`
 
 error: calling `into_bytes()` on a string literal
-  --> $DIR/string_lit_as_bytes.rs:12:14
+  --> $DIR/string_lit_as_bytes.rs:18:14
    |
 LL |     let bs = "lit to owned".to_owned().into_bytes();
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using a byte string literal instead: `b"lit to owned".to_vec()`
 
 error: calling `as_bytes()` on `include_str!(..)`
-  --> $DIR/string_lit_as_bytes.rs:25:22
+  --> $DIR/string_lit_as_bytes.rs:33:22
    |
 LL |     let includestr = include_str!("string_lit_as_bytes.rs").as_bytes();
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `include_bytes!(..)` instead: `include_bytes!("string_lit_as_bytes.rs")`
 
 error: calling `as_bytes()` on a string literal
-  --> $DIR/string_lit_as_bytes.rs:27:13
+  --> $DIR/string_lit_as_bytes.rs:35:13
    |
 LL |     let _ = "string with newline/t/n".as_bytes();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using a byte string literal instead: `b"string with newline/t/n"`
-- 
cgit 1.4.1-3-g733a5


From 14a6fa4a34d24ec81fe562b71966471efcbb32b2 Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Wed, 19 Apr 2023 21:09:27 -0500
Subject: use in_external_macro

---
 clippy_lints/src/strings.rs         |  5 +----
 tests/ui/auxiliary/macro_rules.rs   |  7 +++++++
 tests/ui/string_lit_as_bytes.fixed  | 10 ++++++++--
 tests/ui/string_lit_as_bytes.rs     | 10 ++++++++--
 tests/ui/string_lit_as_bytes.stderr | 25 ++++++++++++++++++-------
 5 files changed, 42 insertions(+), 15 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/strings.rs b/clippy_lints/src/strings.rs
index c8ea151ffce..5b588e914fd 100644
--- a/clippy_lints/src/strings.rs
+++ b/clippy_lints/src/strings.rs
@@ -253,10 +253,6 @@ impl<'tcx> LateLintPass<'tcx> for StringLitAsBytes {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
         use rustc_ast::LitKind;
 
-        if e.span.from_expansion() {
-            return;
-        }
-
         if_chain! {
             // Find std::str::converts::from_utf8
             if let Some(args) = match_function_call(cx, e, &paths::STR_FROM_UTF8);
@@ -296,6 +292,7 @@ impl<'tcx> LateLintPass<'tcx> for StringLitAsBytes {
         }
 
         if_chain! {
+            if !in_external_macro(cx.sess(), e.span);
             if let ExprKind::MethodCall(path, receiver, ..) = &e.kind;
             if path.ident.name == sym!(as_bytes);
             if let ExprKind::Lit(lit) = &receiver.kind;
diff --git a/tests/ui/auxiliary/macro_rules.rs b/tests/ui/auxiliary/macro_rules.rs
index a9bb61451dc..e5bb906663c 100644
--- a/tests/ui/auxiliary/macro_rules.rs
+++ b/tests/ui/auxiliary/macro_rules.rs
@@ -21,6 +21,13 @@ macro_rules! string_add {
     };
 }
 
+#[macro_export]
+macro_rules! string_lit_as_bytes {
+    ($s:literal) => {
+        const C: &[u8] = $s.as_bytes();
+    };
+}
+
 #[macro_export]
 macro_rules! mut_mut {
     () => {
diff --git a/tests/ui/string_lit_as_bytes.fixed b/tests/ui/string_lit_as_bytes.fixed
index 91cdf179b82..3fc11b8b088 100644
--- a/tests/ui/string_lit_as_bytes.fixed
+++ b/tests/ui/string_lit_as_bytes.fixed
@@ -1,11 +1,15 @@
 //@run-rustfix
+//@aux-build:macro_rules.rs
 
 #![allow(dead_code, unused_variables)]
 #![warn(clippy::string_lit_as_bytes)]
 
+#[macro_use]
+extern crate macro_rules;
+
 macro_rules! b {
     ($b:literal) => {
-        const C: &[u8] = $b.as_bytes();
+        const B: &[u8] = b"warning";
     };
 }
 
@@ -17,7 +21,9 @@ fn str_lit_as_bytes() {
     let bs = b"lit to string".to_vec();
     let bs = b"lit to owned".to_vec();
 
-    b!("aaa");
+    b!("warning");
+
+    string_lit_as_bytes!("no warning");
 
     // no warning, because these cannot be written as byte string literals:
     let ubs = "☃".as_bytes();
diff --git a/tests/ui/string_lit_as_bytes.rs b/tests/ui/string_lit_as_bytes.rs
index 7ca383567a3..7d54acf630e 100644
--- a/tests/ui/string_lit_as_bytes.rs
+++ b/tests/ui/string_lit_as_bytes.rs
@@ -1,11 +1,15 @@
 //@run-rustfix
+//@aux-build:macro_rules.rs
 
 #![allow(dead_code, unused_variables)]
 #![warn(clippy::string_lit_as_bytes)]
 
+#[macro_use]
+extern crate macro_rules;
+
 macro_rules! b {
     ($b:literal) => {
-        const C: &[u8] = $b.as_bytes();
+        const B: &[u8] = $b.as_bytes();
     };
 }
 
@@ -17,7 +21,9 @@ fn str_lit_as_bytes() {
     let bs = "lit to string".to_string().into_bytes();
     let bs = "lit to owned".to_owned().into_bytes();
 
-    b!("aaa");
+    b!("warning");
+
+    string_lit_as_bytes!("no warning");
 
     // no warning, because these cannot be written as byte string literals:
     let ubs = "☃".as_bytes();
diff --git a/tests/ui/string_lit_as_bytes.stderr b/tests/ui/string_lit_as_bytes.stderr
index 5be3eb9f2ff..61b4e210e0f 100644
--- a/tests/ui/string_lit_as_bytes.stderr
+++ b/tests/ui/string_lit_as_bytes.stderr
@@ -1,5 +1,5 @@
 error: calling `as_bytes()` on a string literal
-  --> $DIR/string_lit_as_bytes.rs:13:14
+  --> $DIR/string_lit_as_bytes.rs:17:14
    |
 LL |     let bs = "hello there".as_bytes();
    |              ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using a byte string literal instead: `b"hello there"`
@@ -7,34 +7,45 @@ LL |     let bs = "hello there".as_bytes();
    = note: `-D clippy::string-lit-as-bytes` implied by `-D warnings`
 
 error: calling `as_bytes()` on a string literal
-  --> $DIR/string_lit_as_bytes.rs:15:14
+  --> $DIR/string_lit_as_bytes.rs:19:14
    |
 LL |     let bs = r###"raw string with 3# plus " ""###.as_bytes();
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using a byte string literal instead: `br###"raw string with 3# plus " ""###`
 
 error: calling `into_bytes()` on a string literal
-  --> $DIR/string_lit_as_bytes.rs:17:14
+  --> $DIR/string_lit_as_bytes.rs:21:14
    |
 LL |     let bs = "lit to string".to_string().into_bytes();
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using a byte string literal instead: `b"lit to string".to_vec()`
 
 error: calling `into_bytes()` on a string literal
-  --> $DIR/string_lit_as_bytes.rs:18:14
+  --> $DIR/string_lit_as_bytes.rs:22:14
    |
 LL |     let bs = "lit to owned".to_owned().into_bytes();
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using a byte string literal instead: `b"lit to owned".to_vec()`
 
+error: calling `as_bytes()` on a string literal
+  --> $DIR/string_lit_as_bytes.rs:12:26
+   |
+LL |         const B: &[u8] = $b.as_bytes();
+   |                          ^^^^^^^^^^^^^ help: consider using a byte string literal instead: `b"warning"`
+...
+LL |     b!("warning");
+   |     ------------- in this macro invocation
+   |
+   = note: this error originates in the macro `b` (in Nightly builds, run with -Z macro-backtrace for more info)
+
 error: calling `as_bytes()` on `include_str!(..)`
-  --> $DIR/string_lit_as_bytes.rs:33:22
+  --> $DIR/string_lit_as_bytes.rs:39:22
    |
 LL |     let includestr = include_str!("string_lit_as_bytes.rs").as_bytes();
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `include_bytes!(..)` instead: `include_bytes!("string_lit_as_bytes.rs")`
 
 error: calling `as_bytes()` on a string literal
-  --> $DIR/string_lit_as_bytes.rs:35:13
+  --> $DIR/string_lit_as_bytes.rs:41:13
    |
 LL |     let _ = "string with newline/t/n".as_bytes();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using a byte string literal instead: `b"string with newline/t/n"`
 
-error: aborting due to 6 previous errors
+error: aborting due to 7 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From aa6c27a74e00e8e98cd3ce3e0db6149bb5bc7bcf Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Tue, 25 Apr 2023 11:14:52 -0500
Subject: change names to not be implicitly negative

---
 clippy_lints/src/lib.rs                            |   8 +-
 clippy_lints/src/semicolon_block.rs                | 132 ++++++++++-----------
 clippy_lints/src/utils/conf.rs                     |   4 +-
 tests/ui-toml/semicolon_block/clippy.toml          |   4 +-
 .../toml_unknown_key/conf_unknown_key.stderr       |   4 +-
 5 files changed, 73 insertions(+), 79 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index cb223ce9d16..d8bfb84537d 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -932,12 +932,12 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(from_raw_with_void_ptr::FromRawWithVoidPtr));
     store.register_late_pass(|_| Box::new(suspicious_xor_used_as_pow::ConfusingXorAndPow));
     store.register_late_pass(move |_| Box::new(manual_is_ascii_check::ManualIsAsciiCheck::new(msrv())));
-    let semicolon_inside_block_if_multiline = conf.semicolon_inside_block_if_multiline;
-    let semicolon_outside_block_if_singleline = conf.semicolon_outside_block_if_singleline;
+    let semicolon_inside_block_ignore_singleline = conf.semicolon_inside_block_ignore_singleline;
+    let semicolon_outside_block_ignore_multiline = conf.semicolon_outside_block_ignore_multiline;
     store.register_late_pass(move |_| {
         Box::new(semicolon_block::SemicolonBlock::new(
-            semicolon_inside_block_if_multiline,
-            semicolon_outside_block_if_singleline,
+            semicolon_inside_block_ignore_singleline,
+            semicolon_outside_block_ignore_multiline,
         ))
     });
     store.register_late_pass(|_| Box::new(fn_null_check::FnNullCheck));
diff --git a/clippy_lints/src/semicolon_block.rs b/clippy_lints/src/semicolon_block.rs
index c1c0325b786..419d7991f0e 100644
--- a/clippy_lints/src/semicolon_block.rs
+++ b/clippy_lints/src/semicolon_block.rs
@@ -68,17 +68,73 @@ impl_lint_pass!(SemicolonBlock => [SEMICOLON_INSIDE_BLOCK, SEMICOLON_OUTSIDE_BLO
 
 #[derive(Copy, Clone)]
 pub struct SemicolonBlock {
-    semicolon_inside_block_if_multiline: bool,
-    semicolon_outside_block_if_singleline: bool,
+    semicolon_inside_block_ignore_singleline: bool,
+    semicolon_outside_block_ignore_multiline: bool,
 }
 
 impl SemicolonBlock {
-    pub fn new(semicolon_inside_block_if_multiline: bool, semicolon_outside_block_if_singleline: bool) -> Self {
+    pub fn new(semicolon_inside_block_ignore_singleline: bool, semicolon_outside_block_ignore_multiline: bool) -> Self {
         Self {
-            semicolon_inside_block_if_multiline,
-            semicolon_outside_block_if_singleline,
+            semicolon_inside_block_ignore_singleline,
+            semicolon_outside_block_ignore_multiline,
         }
     }
+
+    fn semicolon_inside_block(self, cx: &LateContext<'_>, block: &Block<'_>, tail: &Expr<'_>, semi_span: Span) {
+        let insert_span = tail.span.source_callsite().shrink_to_hi();
+        let remove_span = semi_span.with_lo(block.span.hi());
+
+        if self.semicolon_inside_block_ignore_singleline && get_line(cx, remove_span) == get_line(cx, insert_span) {
+            return;
+        }
+
+        span_lint_and_then(
+            cx,
+            SEMICOLON_INSIDE_BLOCK,
+            semi_span,
+            "consider moving the `;` inside the block for consistent formatting",
+            |diag| {
+                multispan_sugg_with_applicability(
+                    diag,
+                    "put the `;` here",
+                    Applicability::MachineApplicable,
+                    [(remove_span, String::new()), (insert_span, ";".to_owned())],
+                );
+            },
+        );
+    }
+
+    fn semicolon_outside_block(
+        self,
+        cx: &LateContext<'_>,
+        block: &Block<'_>,
+        tail_stmt_expr: &Expr<'_>,
+        semi_span: Span,
+    ) {
+        let insert_span = block.span.with_lo(block.span.hi());
+        // account for macro calls
+        let semi_span = cx.sess().source_map().stmt_span(semi_span, block.span);
+        let remove_span = semi_span.with_lo(tail_stmt_expr.span.source_callsite().hi());
+
+        if self.semicolon_outside_block_ignore_multiline && get_line(cx, remove_span) != get_line(cx, insert_span) {
+            return;
+        }
+
+        span_lint_and_then(
+            cx,
+            SEMICOLON_OUTSIDE_BLOCK,
+            block.span,
+            "consider moving the `;` outside the block for consistent formatting",
+            |diag| {
+                multispan_sugg_with_applicability(
+                    diag,
+                    "put the `;` here",
+                    Applicability::MachineApplicable,
+                    [(remove_span, String::new()), (insert_span, ";".to_owned())],
+                );
+            },
+        );
+    }
 }
 
 impl LateLintPass<'_> for SemicolonBlock {
@@ -98,81 +154,19 @@ impl LateLintPass<'_> for SemicolonBlock {
                     span,
                     ..
                 } = stmt else { return };
-                semicolon_outside_block(self, cx, block, expr, span);
+                self.semicolon_outside_block(cx, block, expr, span);
             },
             StmtKind::Semi(Expr {
                 kind: ExprKind::Block(block @ Block { expr: Some(tail), .. }, _),
                 ..
             }) if !block.span.from_expansion() => {
-                semicolon_inside_block(self, cx, block, tail, stmt.span);
+                self.semicolon_inside_block(cx, block, tail, stmt.span);
             },
             _ => (),
         }
     }
 }
 
-fn semicolon_inside_block(
-    conf: &mut SemicolonBlock,
-    cx: &LateContext<'_>,
-    block: &Block<'_>,
-    tail: &Expr<'_>,
-    semi_span: Span,
-) {
-    let insert_span = tail.span.source_callsite().shrink_to_hi();
-    let remove_span = semi_span.with_lo(block.span.hi());
-
-    if conf.semicolon_inside_block_if_multiline && get_line(cx, remove_span) == get_line(cx, insert_span) {
-        return;
-    }
-
-    span_lint_and_then(
-        cx,
-        SEMICOLON_INSIDE_BLOCK,
-        semi_span,
-        "consider moving the `;` inside the block for consistent formatting",
-        |diag| {
-            multispan_sugg_with_applicability(
-                diag,
-                "put the `;` here",
-                Applicability::MachineApplicable,
-                [(remove_span, String::new()), (insert_span, ";".to_owned())],
-            );
-        },
-    );
-}
-
-fn semicolon_outside_block(
-    conf: &mut SemicolonBlock,
-    cx: &LateContext<'_>,
-    block: &Block<'_>,
-    tail_stmt_expr: &Expr<'_>,
-    semi_span: Span,
-) {
-    let insert_span = block.span.with_lo(block.span.hi());
-    // account for macro calls
-    let semi_span = cx.sess().source_map().stmt_span(semi_span, block.span);
-    let remove_span = semi_span.with_lo(tail_stmt_expr.span.source_callsite().hi());
-
-    if conf.semicolon_outside_block_if_singleline && get_line(cx, remove_span) != get_line(cx, insert_span) {
-        return;
-    }
-
-    span_lint_and_then(
-        cx,
-        SEMICOLON_OUTSIDE_BLOCK,
-        block.span,
-        "consider moving the `;` outside the block for consistent formatting",
-        |diag| {
-            multispan_sugg_with_applicability(
-                diag,
-                "put the `;` here",
-                Applicability::MachineApplicable,
-                [(remove_span, String::new()), (insert_span, ";".to_owned())],
-            );
-        },
-    );
-}
-
 fn get_line(cx: &LateContext<'_>, span: Span) -> Option<usize> {
     if let Ok(line) = cx.sess().source_map().lookup_line(span.lo()) {
         return Some(line.line);
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 939f6cd5f1f..18a6e2a4a3a 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -280,11 +280,11 @@ define_Conf! {
     /// Lint: SEMICOLON_INSIDE_BLOCK.
     ///
     /// Whether to lint only if it's multiline.
-    (semicolon_inside_block_if_multiline: bool = false),
+    (semicolon_inside_block_ignore_singleline: bool = false),
     /// Lint: SEMICOLON_OUTSIDE_BLOCK.
     ///
     /// Whether to lint only if it's singleline.
-    (semicolon_outside_block_if_singleline: bool = false),
+    (semicolon_outside_block_ignore_multiline: bool = false),
     /// Lint: DOC_MARKDOWN.
     ///
     /// The list of words this lint should not consider as identifiers needing ticks. The value
diff --git a/tests/ui-toml/semicolon_block/clippy.toml b/tests/ui-toml/semicolon_block/clippy.toml
index cc3bc8cae14..4d03e88deba 100644
--- a/tests/ui-toml/semicolon_block/clippy.toml
+++ b/tests/ui-toml/semicolon_block/clippy.toml
@@ -1,2 +1,2 @@
-semicolon-inside-block-if-multiline = true
-semicolon-outside-block-if-singleline = true
+semicolon-inside-block-ignore-singleline = true
+semicolon-outside-block-ignore-multiline = true
diff --git a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
index c49c9087946..1e0d7499c7e 100644
--- a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
+++ b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
@@ -37,8 +37,8 @@ error: error reading Clippy's configuration file `$DIR/clippy.toml`: unknown fie
            missing-docs-in-crate-items
            msrv
            pass-by-value-size-limit
-           semicolon-inside-block-if-multiline
-           semicolon-outside-block-if-singleline
+           semicolon-inside-block-ignore-singleline
+           semicolon-outside-block-ignore-multiline
            single-char-binding-names-threshold
            standard-macro-braces
            suppress-restriction-lint-in-const
-- 
cgit 1.4.1-3-g733a5


From 9428138562bad89fc2d7d011fe276cd198e6155a Mon Sep 17 00:00:00 2001
From: Icxolu <10486322+Icxolu@users.noreply.github.com>
Date: Tue, 25 Apr 2023 20:44:09 +0200
Subject: adds lint to detect construction of unit struct using `default`

Using `default` to construct a unit struct increases code complexity and
adds a function call. This can be avoided by simply removing the call to
`default` and simply construct by name.
---
 CHANGELOG.md                                       |  1 +
 clippy_lints/src/declared_lints.rs                 |  1 +
 .../src/default_constructed_unit_struct.rs         | 66 ++++++++++++++++++++
 clippy_lints/src/lib.rs                            |  2 +
 tests/ui/default_constructed_unit_struct.rs        | 72 ++++++++++++++++++++++
 tests/ui/default_constructed_unit_struct.stderr    | 28 +++++++++
 6 files changed, 170 insertions(+)
 create mode 100644 clippy_lints/src/default_constructed_unit_struct.rs
 create mode 100644 tests/ui/default_constructed_unit_struct.rs
 create mode 100644 tests/ui/default_constructed_unit_struct.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 23f4f97ee07..735ac59758a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4582,6 +4582,7 @@ Released 2018-09-13
 [`debug_assert_with_mut_call`]: https://rust-lang.github.io/rust-clippy/master/index.html#debug_assert_with_mut_call
 [`decimal_literal_representation`]: https://rust-lang.github.io/rust-clippy/master/index.html#decimal_literal_representation
 [`declare_interior_mutable_const`]: https://rust-lang.github.io/rust-clippy/master/index.html#declare_interior_mutable_const
+[`default_constructed_unit_struct`]: https://rust-lang.github.io/rust-clippy/master/index.html#default_constructed_unit_struct
 [`default_instead_of_iter_empty`]: https://rust-lang.github.io/rust-clippy/master/index.html#default_instead_of_iter_empty
 [`default_numeric_fallback`]: https://rust-lang.github.io/rust-clippy/master/index.html#default_numeric_fallback
 [`default_trait_access`]: https://rust-lang.github.io/rust-clippy/master/index.html#default_trait_access
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 4aebd0b7d01..bf30f5b52f7 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -105,6 +105,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::dbg_macro::DBG_MACRO_INFO,
     crate::default::DEFAULT_TRAIT_ACCESS_INFO,
     crate::default::FIELD_REASSIGN_WITH_DEFAULT_INFO,
+    crate::default_constructed_unit_struct::DEFAULT_CONSTRUCTED_UNIT_STRUCT_INFO,
     crate::default_instead_of_iter_empty::DEFAULT_INSTEAD_OF_ITER_EMPTY_INFO,
     crate::default_numeric_fallback::DEFAULT_NUMERIC_FALLBACK_INFO,
     crate::default_union_representation::DEFAULT_UNION_REPRESENTATION_INFO,
diff --git a/clippy_lints/src/default_constructed_unit_struct.rs b/clippy_lints/src/default_constructed_unit_struct.rs
new file mode 100644
index 00000000000..a04f7b9d9a9
--- /dev/null
+++ b/clippy_lints/src/default_constructed_unit_struct.rs
@@ -0,0 +1,66 @@
+use clippy_utils::{diagnostics::span_lint_and_sugg, is_from_proc_macro, match_def_path, paths};
+use hir::{def::Res, ExprKind};
+use rustc_errors::Applicability;
+use rustc_hir as hir;
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Check for construction on unit struct using `default`.
+    ///
+    /// ### Why is this bad?
+    /// This adds code complexity and an unnecessary function call.
+    ///
+    /// ### Example
+    /// ```rust
+    /// #[derive(Default)]
+    /// struct S<T> {
+    ///     _marker: PhantomData<T>
+    /// }
+    ///
+    /// let _: S<i32> = S {
+    ///     _marker: PhantomData::default()
+    /// };
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// let _: S<i32> = Something {
+    ///     _marker: PhantomData
+    /// }
+    /// ```
+    #[clippy::version = "1.71.0"]
+    pub DEFAULT_CONSTRUCTED_UNIT_STRUCT,
+    complexity,
+    "unit structs can be contructed without calling `default`"
+}
+declare_lint_pass!(DefaultConstructedUnitStruct => [DEFAULT_CONSTRUCTED_UNIT_STRUCT]);
+
+impl LateLintPass<'_> for DefaultConstructedUnitStruct {
+    fn check_expr<'tcx>(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'tcx>) {
+        if_chain!(
+            // make sure we have a call to `Default::default`
+            if let hir::ExprKind::Call(fn_expr, &[]) = expr.kind;
+            if let ExprKind::Path(ref qpath) = fn_expr.kind;
+            if let Res::Def(_, def_id) = cx.qpath_res(qpath, fn_expr.hir_id);
+            if match_def_path(cx, def_id, &paths::DEFAULT_TRAIT_METHOD);
+            // make sure we have a struct with no fields (unit struct)
+            if let ty::Adt(def, ..) = cx.typeck_results().expr_ty(expr).kind();
+            if def.is_struct() && def.is_payloadfree()
+                && !def.non_enum_variant().is_field_list_non_exhaustive()
+                && !is_from_proc_macro(cx, expr);
+            then {
+                span_lint_and_sugg(
+                    cx,
+                    DEFAULT_CONSTRUCTED_UNIT_STRUCT,
+                    qpath.last_segment_span(),
+                    "Use of `default` to create a unit struct.",
+                    "remove this call to `default`",
+                    String::new(),
+                    Applicability::MachineApplicable,
+                )
+            }
+        );
+    }
+}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 48dbecc9f6a..9af0b17e27b 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -94,6 +94,7 @@ mod crate_in_macro_def;
 mod create_dir;
 mod dbg_macro;
 mod default;
+mod default_constructed_unit_struct;
 mod default_instead_of_iter_empty;
 mod default_numeric_fallback;
 mod default_union_representation;
@@ -970,6 +971,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(manual_slice_size_calculation::ManualSliceSizeCalculation));
     store.register_early_pass(|| Box::new(suspicious_doc_comments::SuspiciousDocComments));
     store.register_late_pass(|_| Box::new(items_after_test_module::ItemsAfterTestModule));
+    store.register_late_pass(|_| Box::new(default_constructed_unit_struct::DefaultConstructedUnitStruct));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/tests/ui/default_constructed_unit_struct.rs b/tests/ui/default_constructed_unit_struct.rs
new file mode 100644
index 00000000000..b64da9b863a
--- /dev/null
+++ b/tests/ui/default_constructed_unit_struct.rs
@@ -0,0 +1,72 @@
+#![allow(unused)]
+#![warn(clippy::default_constructed_unit_struct)]
+use std::marker::PhantomData;
+
+#[derive(Default)]
+struct UnitStruct;
+
+#[derive(Default)]
+struct TupleStruct(usize);
+
+// no lint for derived impl
+#[derive(Default)]
+struct NormalStruct {
+    inner: PhantomData<usize>,
+}
+
+struct NonDefaultStruct;
+
+impl NonDefaultStruct {
+    fn default() -> Self {
+        Self
+    }
+}
+
+#[derive(Default)]
+enum SomeEnum {
+    #[default]
+    Unit,
+    Tuple(UnitStruct),
+    Struct {
+        inner: usize,
+    },
+}
+
+impl NormalStruct {
+    fn new() -> Self {
+        // should lint
+        Self {
+            inner: PhantomData::default(),
+        }
+    }
+}
+
+#[derive(Default)]
+struct GenericStruct<T> {
+    t: T,
+}
+
+impl<T: Default> GenericStruct<T> {
+    fn new() -> Self {
+        // should not lint
+        Self { t: T::default() }
+    }
+}
+
+#[derive(Default)]
+#[non_exhaustive]
+struct NonExhaustiveStruct;
+
+fn main() {
+    // should lint
+    let _ = PhantomData::<usize>::default();
+    let _: PhantomData<i32> = PhantomData::default();
+    let _ = UnitStruct::default();
+
+    // should not lint
+    let _ = TupleStruct::default();
+    let _ = NormalStruct::default();
+    let _ = NonExhaustiveStruct::default();
+    let _ = SomeEnum::default();
+    let _ = NonDefaultStruct::default();
+}
diff --git a/tests/ui/default_constructed_unit_struct.stderr b/tests/ui/default_constructed_unit_struct.stderr
new file mode 100644
index 00000000000..13439414f4a
--- /dev/null
+++ b/tests/ui/default_constructed_unit_struct.stderr
@@ -0,0 +1,28 @@
+error: Use of `default` to create a unit struct.
+  --> $DIR/default_constructed_unit_struct.rs:39:33
+   |
+LL |             inner: PhantomData::default(),
+   |                                 ^^^^^^^ help: remove this call to `default`
+   |
+   = note: `-D clippy::default-constructed-unit-struct` implied by `-D warnings`
+
+error: Use of `default` to create a unit struct.
+  --> $DIR/default_constructed_unit_struct.rs:62:35
+   |
+LL |     let _ = PhantomData::<usize>::default();
+   |                                   ^^^^^^^ help: remove this call to `default`
+
+error: Use of `default` to create a unit struct.
+  --> $DIR/default_constructed_unit_struct.rs:63:44
+   |
+LL |     let _: PhantomData<i32> = PhantomData::default();
+   |                                            ^^^^^^^ help: remove this call to `default`
+
+error: Use of `default` to create a unit struct.
+  --> $DIR/default_constructed_unit_struct.rs:64:25
+   |
+LL |     let _ = UnitStruct::default();
+   |                         ^^^^^^^ help: remove this call to `default`
+
+error: aborting due to 4 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 273c898aefeaec89b547f07bce98ad34aee8d38a Mon Sep 17 00:00:00 2001
From: blyxyas <blyxyas@gmail.com>
Date: Thu, 27 Apr 2023 16:43:51 +0200
Subject: Fix #10713 and move the tests to a subdir

---
 clippy_lints/src/items_after_test_module.rs        | 15 +++++++-------
 tests/ui/items_after_test_module.rs                | 23 ----------------------
 tests/ui/items_after_test_module.stderr            | 17 ----------------
 tests/ui/items_after_test_module/block_module.rs   | 23 ++++++++++++++++++++++
 .../ui/items_after_test_module/block_module.stderr | 17 ++++++++++++++++
 .../ui/items_after_test_module/imported_module.rs  | 17 ++++++++++++++++
 .../items_after_test_module/imported_module.stderr |  0
 tests/ui/items_after_test_module/tests/mod.rs      |  1 +
 8 files changed, 66 insertions(+), 47 deletions(-)
 delete mode 100644 tests/ui/items_after_test_module.rs
 delete mode 100644 tests/ui/items_after_test_module.stderr
 create mode 100644 tests/ui/items_after_test_module/block_module.rs
 create mode 100644 tests/ui/items_after_test_module/block_module.stderr
 create mode 100644 tests/ui/items_after_test_module/imported_module.rs
 create mode 100644 tests/ui/items_after_test_module/imported_module.stderr
 create mode 100644 tests/ui/items_after_test_module/tests/mod.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/items_after_test_module.rs b/clippy_lints/src/items_after_test_module.rs
index 52d716feea0..96097575c9c 100644
--- a/clippy_lints/src/items_after_test_module.rs
+++ b/clippy_lints/src/items_after_test_module.rs
@@ -64,20 +64,21 @@ impl LateLintPass<'_> for ItemsAfterTestModule {
                 span_lint_and_help(cx, ITEMS_AFTER_TEST_MODULE, test_mod_span.unwrap().with_hi(item.span.hi()), "items were found after the testing module", None, "move the items to before the testing module was defined");
             }};
 
-            if matches!(item.kind, ItemKind::Mod(_)) {
-                for attr in cx.tcx.get_attrs(item.owner_id.to_def_id(), sym::cfg) {
-                    if_chain! {
-                        if attr.has_name(sym::cfg);
+            if let ItemKind::Mod(module) = item.kind && item.span.hi() == module.spans.inner_span.hi() {
+			// Check that it works the same way, the only I way I've found for #10713
+				for attr in cx.tcx.get_attrs(item.owner_id.to_def_id(), sym::cfg) {
+					if_chain! {
+						if attr.has_name(sym::cfg);
                         if let Some(mitems) = attr.meta_item_list();
                         if let [mitem] = &*mitems;
                         if mitem.has_name(sym::test);
                         then {
-                            was_test_mod_visited = true;
-                            test_mod_span = Some(item.span);
+							was_test_mod_visited = true;
+                            test_mod_span = Some(module.spans.inner_span.with_lo(item.span.lo()));
                         }
                     }
                 }
-            }
+			}
         }
     }
 }
diff --git a/tests/ui/items_after_test_module.rs b/tests/ui/items_after_test_module.rs
deleted file mode 100644
index 5136b2557ec..00000000000
--- a/tests/ui/items_after_test_module.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-//@compile-flags: --test
-#![allow(unused)]
-#![warn(clippy::items_after_test_module)]
-
-fn main() {}
-
-fn should_not_lint() {}
-
-#[allow(dead_code)]
-#[allow(unused)] // Some attributes to check that span replacement is good enough
-#[allow(clippy::allow_attributes)]
-#[cfg(test)]
-mod tests {
-    #[test]
-    fn hi() {}
-}
-
-fn should_lint() {}
-
-const SHOULD_ALSO_LINT: usize = 1;
-macro_rules! should_not_lint {
-    () => {};
-}
diff --git a/tests/ui/items_after_test_module.stderr b/tests/ui/items_after_test_module.stderr
deleted file mode 100644
index 8f1616dabc1..00000000000
--- a/tests/ui/items_after_test_module.stderr
+++ /dev/null
@@ -1,17 +0,0 @@
-error: items were found after the testing module
-  --> $DIR/items_after_test_module.rs:13:1
-   |
-LL | / mod tests {
-LL | |     #[test]
-LL | |     fn hi() {}
-LL | | }
-...  |
-LL | |     () => {};
-LL | | }
-   | |_^
-   |
-   = help: move the items to before the testing module was defined
-   = note: `-D clippy::items-after-test-module` implied by `-D warnings`
-
-error: aborting due to previous error
-
diff --git a/tests/ui/items_after_test_module/block_module.rs b/tests/ui/items_after_test_module/block_module.rs
new file mode 100644
index 00000000000..5136b2557ec
--- /dev/null
+++ b/tests/ui/items_after_test_module/block_module.rs
@@ -0,0 +1,23 @@
+//@compile-flags: --test
+#![allow(unused)]
+#![warn(clippy::items_after_test_module)]
+
+fn main() {}
+
+fn should_not_lint() {}
+
+#[allow(dead_code)]
+#[allow(unused)] // Some attributes to check that span replacement is good enough
+#[allow(clippy::allow_attributes)]
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn hi() {}
+}
+
+fn should_lint() {}
+
+const SHOULD_ALSO_LINT: usize = 1;
+macro_rules! should_not_lint {
+    () => {};
+}
diff --git a/tests/ui/items_after_test_module/block_module.stderr b/tests/ui/items_after_test_module/block_module.stderr
new file mode 100644
index 00000000000..597f1b9510c
--- /dev/null
+++ b/tests/ui/items_after_test_module/block_module.stderr
@@ -0,0 +1,17 @@
+error: items were found after the testing module
+  --> $DIR/block_module.rs:13:1
+   |
+LL | / mod tests {
+LL | |     #[test]
+LL | |     fn hi() {}
+LL | | }
+...  |
+LL | |     () => {};
+LL | | }
+   | |_^
+   |
+   = help: move the items to before the testing module was defined
+   = note: `-D clippy::items-after-test-module` implied by `-D warnings`
+
+error: aborting due to previous error
+
diff --git a/tests/ui/items_after_test_module/imported_module.rs b/tests/ui/items_after_test_module/imported_module.rs
new file mode 100644
index 00000000000..819b6c8a9e0
--- /dev/null
+++ b/tests/ui/items_after_test_module/imported_module.rs
@@ -0,0 +1,17 @@
+//@compile-flags: --test
+#![allow(unused)]
+#![warn(clippy::items_after_test_module)]
+
+fn main() {}
+
+fn should_not_lint() {}
+
+#[cfg(test)]
+mod tests; // Should not lint
+
+fn should_lint() {}
+
+const SHOULD_ALSO_LINT: usize = 1;
+macro_rules! should_not_lint {
+    () => {};
+}
diff --git a/tests/ui/items_after_test_module/imported_module.stderr b/tests/ui/items_after_test_module/imported_module.stderr
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/tests/ui/items_after_test_module/tests/mod.rs b/tests/ui/items_after_test_module/tests/mod.rs
new file mode 100644
index 00000000000..f328e4d9d04
--- /dev/null
+++ b/tests/ui/items_after_test_module/tests/mod.rs
@@ -0,0 +1 @@
+fn main() {}
-- 
cgit 1.4.1-3-g733a5


From f37054b396cc67f2633d929c35cd88ecdb383ba8 Mon Sep 17 00:00:00 2001
From: blyxyas <blyxyas@gmail.com>
Date: Fri, 28 Apr 2023 20:19:36 +0200
Subject: Remove useless span magic

---
 clippy_lints/src/items_after_test_module.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/items_after_test_module.rs b/clippy_lints/src/items_after_test_module.rs
index 96097575c9c..b992d689aa9 100644
--- a/clippy_lints/src/items_after_test_module.rs
+++ b/clippy_lints/src/items_after_test_module.rs
@@ -74,7 +74,7 @@ impl LateLintPass<'_> for ItemsAfterTestModule {
                         if mitem.has_name(sym::test);
                         then {
 							was_test_mod_visited = true;
-                            test_mod_span = Some(module.spans.inner_span.with_lo(item.span.lo()));
+                            test_mod_span = Some(item.span);
                         }
                     }
                 }
-- 
cgit 1.4.1-3-g733a5


From 2ed254e29f237c90bafdc1c064f98c61cf42f685 Mon Sep 17 00:00:00 2001
From: Lukas Lueg <lukas.lueg@gmail.com>
Date: Sat, 29 Apr 2023 14:18:31 +0200
Subject: Clarify docs for RESULT_LARGE_ERR

---
 clippy_lints/src/functions/mod.rs | 5 +++++
 1 file changed, 5 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/functions/mod.rs b/clippy_lints/src/functions/mod.rs
index 1528a7be09c..ee10334c67f 100644
--- a/clippy_lints/src/functions/mod.rs
+++ b/clippy_lints/src/functions/mod.rs
@@ -252,6 +252,11 @@ declare_clippy_lint! {
     /// A `Result` is at least as large as the `Err`-variant. While we
     /// expect that variant to be seldomly used, the compiler needs to reserve
     /// and move that much memory every single time.
+    /// Furthermore, errors are often simply passed up the call-stack, making
+    /// use of the `?`-operator and its type-conversion mechanics. If the
+    /// `Err`-variant further up the call-stack stores the `Err`-variant in
+    /// question (as library code often does), it itself needs to be at least
+    /// as large, propagating the problem.
     ///
     /// ### Known problems
     /// The size determined by Clippy is platform-dependent.
-- 
cgit 1.4.1-3-g733a5


From bb58083ce59b44c54866a4d8305f59c7e7742593 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Tue, 4 Apr 2023 08:16:37 +0200
Subject: new lint: `while_pop_unwrap`

---
 CHANGELOG.md                         |   1 +
 clippy_lints/src/declared_lints.rs   |   1 +
 clippy_lints/src/lib.rs              |   1 +
 clippy_lints/src/loops/mod.rs        |   3 +
 clippy_lints/src/while_pop_unwrap.rs | 126 +++++++++++++++++++++++++++++++++++
 clippy_utils/src/paths.rs            |   4 ++
 tests/ui/while_pop_unwrap.rs         |  47 +++++++++++++
 tests/ui/while_pop_unwrap.stderr     |  43 ++++++++++++
 8 files changed, 226 insertions(+)
 create mode 100644 clippy_lints/src/while_pop_unwrap.rs
 create mode 100644 tests/ui/while_pop_unwrap.rs
 create mode 100644 tests/ui/while_pop_unwrap.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 23f4f97ee07..da03f5c012b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5160,6 +5160,7 @@ Released 2018-09-13
 [`while_immutable_condition`]: https://rust-lang.github.io/rust-clippy/master/index.html#while_immutable_condition
 [`while_let_loop`]: https://rust-lang.github.io/rust-clippy/master/index.html#while_let_loop
 [`while_let_on_iterator`]: https://rust-lang.github.io/rust-clippy/master/index.html#while_let_on_iterator
+[`while_pop_unwrap`]: https://rust-lang.github.io/rust-clippy/master/index.html#while_pop_unwrap
 [`wildcard_dependencies`]: https://rust-lang.github.io/rust-clippy/master/index.html#wildcard_dependencies
 [`wildcard_enum_match_arm`]: https://rust-lang.github.io/rust-clippy/master/index.html#wildcard_enum_match_arm
 [`wildcard_imports`]: https://rust-lang.github.io/rust-clippy/master/index.html#wildcard_imports
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 4aebd0b7d01..ddc4b139670 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -645,6 +645,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::useless_conversion::USELESS_CONVERSION_INFO,
     crate::vec::USELESS_VEC_INFO,
     crate::vec_init_then_push::VEC_INIT_THEN_PUSH_INFO,
+    crate::while_pop_unwrap::WHILE_POP_UNWRAP_INFO,
     crate::wildcard_imports::ENUM_GLOB_USE_INFO,
     crate::wildcard_imports::WILDCARD_IMPORTS_INFO,
     crate::write::PRINTLN_EMPTY_STRING_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 48dbecc9f6a..0d594612b79 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -324,6 +324,7 @@ mod use_self;
 mod useless_conversion;
 mod vec;
 mod vec_init_then_push;
+mod while_pop_unwrap;
 mod wildcard_imports;
 mod write;
 mod zero_div_zero;
diff --git a/clippy_lints/src/loops/mod.rs b/clippy_lints/src/loops/mod.rs
index 610a0233eee..90012694062 100644
--- a/clippy_lints/src/loops/mod.rs
+++ b/clippy_lints/src/loops/mod.rs
@@ -25,6 +25,8 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
 use utils::{make_iterator_snippet, IncrementVisitor, InitializeVisitor};
 
+use crate::while_pop_unwrap;
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for for-loops that manually copy items between
@@ -643,6 +645,7 @@ impl<'tcx> LateLintPass<'tcx> for Loops {
         if let Some(higher::While { condition, body }) = higher::While::hir(expr) {
             while_immutable_condition::check(cx, condition, body);
             missing_spin_loop::check(cx, condition, body);
+            while_pop_unwrap::check(cx, condition, body);
         }
     }
 }
diff --git a/clippy_lints/src/while_pop_unwrap.rs b/clippy_lints/src/while_pop_unwrap.rs
new file mode 100644
index 00000000000..fc77febad6b
--- /dev/null
+++ b/clippy_lints/src/while_pop_unwrap.rs
@@ -0,0 +1,126 @@
+use clippy_utils::{diagnostics::span_lint_and_then, match_def_path, paths, source::snippet};
+use rustc_errors::Applicability;
+use rustc_hir::*;
+use rustc_lint::LateContext;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::{symbol::Ident, Span};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Looks for loops that check for emptiness of a `Vec` in the condition and pop an element
+    /// in the body as a separate operation.
+    ///
+    /// ### Why is this bad?
+    /// Such loops can be written in a more idiomatic way by using a while..let loop and directly
+    /// pattern matching on the return value of `Vec::pop()`.
+    ///
+    /// ### Example
+    /// ```rust
+    /// let mut numbers = vec![1, 2, 3, 4, 5];
+    /// while !numbers.is_empty() {
+    ///     let number = numbers.pop().unwrap();
+    ///     // use `number`
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// let mut numbers = vec![1, 2, 3, 4, 5];
+    /// while let Some(number) = numbers.pop() {
+    ///     // use `number`
+    /// }
+    /// ```
+    #[clippy::version = "1.70.0"]
+    pub WHILE_POP_UNWRAP,
+    style,
+    "checking for emptiness of a `Vec` in the loop condition and popping an element in the body"
+}
+declare_lint_pass!(WhilePopUnwrap => [WHILE_POP_UNWRAP]);
+
+fn report_lint<'tcx>(
+    cx: &LateContext<'tcx>,
+    pop_span: Span,
+    ident: Option<Ident>,
+    loop_span: Span,
+    receiver_span: Span,
+) {
+    span_lint_and_then(
+        cx,
+        WHILE_POP_UNWRAP,
+        pop_span,
+        "you seem to be trying to pop elements from a `Vec` in a loop",
+        |diag| {
+            diag.span_suggestion(
+                loop_span,
+                "try",
+                format!(
+                    "while let Some({}) = {}.pop()",
+                    ident.as_ref().map(Ident::as_str).unwrap_or("element"),
+                    snippet(cx, receiver_span, "..")
+                ),
+                Applicability::MaybeIncorrect,
+            )
+            .note("this while loop can be written in a more idiomatic way");
+        },
+    );
+}
+
+fn match_method_call(cx: &LateContext<'_>, expr: &Expr<'_>, method: &[&str]) -> bool {
+    if let ExprKind::MethodCall(..) = expr.kind
+        && let Some(id) = cx.typeck_results().type_dependent_def_id(expr.hir_id)
+        && match_def_path(cx, id, method)
+    {
+        true
+    } else {
+        false
+    }
+}
+
+fn is_vec_pop<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>) -> bool {
+    match_method_call(cx, expr, &paths::VEC_POP)
+}
+
+fn is_vec_pop_unwrap<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>) -> bool {
+    if let ExprKind::MethodCall(_, inner, ..) = expr.kind
+        && (match_method_call(cx, expr, &paths::OPTION_UNWRAP) || match_method_call(cx, expr, &paths::OPTION_EXPECT))
+        && is_vec_pop(cx, inner)
+    {
+        true
+    } else {
+        false
+    }
+}
+
+fn check_local<'tcx>(cx: &LateContext<'tcx>, stmt: &Stmt<'_>, loop_span: Span, recv_span: Span) {
+    if let StmtKind::Local(local) = stmt.kind
+        && let PatKind::Binding(.., ident, _) = local.pat.kind
+        && let Some(init) = local.init
+        && let ExprKind::MethodCall(_, inner, ..) = init.kind
+        && is_vec_pop_unwrap(cx, init)
+    {
+        report_lint(cx, init.span.to(inner.span), Some(ident), loop_span, recv_span);
+    }
+}
+
+fn check_call_arguments<'tcx>(cx: &LateContext<'tcx>, stmt: &Stmt<'_>, loop_span: Span, recv_span: Span) {
+    if let StmtKind::Semi(expr) | StmtKind::Expr(expr) = stmt.kind {
+        if let ExprKind::MethodCall(_, _, args, _) | ExprKind::Call(_, args) = expr.kind {
+            let offending_arg = args.iter().find_map(|arg| is_vec_pop_unwrap(cx, arg).then(|| arg.span));
+
+            if let Some(offending_arg) = offending_arg {
+                report_lint(cx, offending_arg, None, loop_span, recv_span);
+            }
+        }
+    }
+}
+
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, cond: &'tcx Expr<'_>, body: &'tcx Expr<'_>) {
+    if let ExprKind::Unary(UnOp::Not, cond) = cond.kind
+        && let ExprKind::MethodCall(_, Expr { span: recv_span, .. }, _, _) = cond.kind
+        && match_method_call(cx, cond, &paths::VEC_IS_EMPTY)
+        && let ExprKind::Block(body, _) = body.kind
+        && let Some(stmt) = body.stmts.first()
+    {
+        check_local(cx, stmt, cond.span, *recv_span);
+        check_call_arguments(cx, stmt, cond.span, *recv_span);
+    }
+}
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index 9be2d0eae80..0f0792fdaa9 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -159,3 +159,7 @@ pub const WEAK_RC: [&str; 3] = ["alloc", "rc", "Weak"];
 pub const PTR_NON_NULL: [&str; 4] = ["core", "ptr", "non_null", "NonNull"];
 pub const INSTANT_NOW: [&str; 4] = ["std", "time", "Instant", "now"];
 pub const INSTANT: [&str; 3] = ["std", "time", "Instant"];
+pub const VEC_IS_EMPTY: [&str; 4] = ["alloc", "vec", "Vec", "is_empty"];
+pub const VEC_POP: [&str; 4] = ["alloc", "vec", "Vec", "pop"];
+pub const OPTION_UNWRAP: [&str; 4] = ["core", "option", "Option", "unwrap"];
+pub const OPTION_EXPECT: [&str; 4] = ["core", "option", "Option", "expect"];
diff --git a/tests/ui/while_pop_unwrap.rs b/tests/ui/while_pop_unwrap.rs
new file mode 100644
index 00000000000..1b6de8f1f89
--- /dev/null
+++ b/tests/ui/while_pop_unwrap.rs
@@ -0,0 +1,47 @@
+#![allow(unused)]
+#![warn(clippy::while_pop_unwrap)]
+
+struct VecInStruct {
+    numbers: Vec<i32>,
+    unrelated: String,
+}
+
+fn accept_i32(_: i32) {}
+
+fn main() {
+    let mut numbers = vec![1, 2, 3, 4, 5];
+    while !numbers.is_empty() {
+        let number = numbers.pop().unwrap();
+    }
+
+    let mut val = VecInStruct {
+        numbers: vec![1, 2, 3, 4, 5],
+        unrelated: String::new(),
+    };
+    while !val.numbers.is_empty() {
+        let number = val.numbers.pop().unwrap();
+    }
+
+    while !numbers.is_empty() {
+        accept_i32(numbers.pop().unwrap());
+    }
+
+    while !numbers.is_empty() {
+        accept_i32(numbers.pop().expect(""));
+    }
+
+    // This should not warn. It "conditionally" pops elements.
+    while !numbers.is_empty() {
+        if true {
+            accept_i32(numbers.pop().unwrap());
+        }
+    }
+
+    // This should also not warn. It conditionally pops elements.
+    while !numbers.is_empty() {
+        if false {
+            continue;
+        }
+        accept_i32(numbers.pop().unwrap());
+    }
+}
diff --git a/tests/ui/while_pop_unwrap.stderr b/tests/ui/while_pop_unwrap.stderr
new file mode 100644
index 00000000000..8dc77db8b5a
--- /dev/null
+++ b/tests/ui/while_pop_unwrap.stderr
@@ -0,0 +1,43 @@
+error: you seem to be trying to pop elements from a `Vec` in a loop
+  --> $DIR/while_pop_unwrap.rs:14:22
+   |
+LL |     while !numbers.is_empty() {
+   |            ------------------ help: try: `while let Some(number) = numbers.pop()`
+LL |         let number = numbers.pop().unwrap();
+   |                      ^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: this while loop can be written in a more idiomatic way
+   = note: `-D clippy::while-pop-unwrap` implied by `-D warnings`
+
+error: you seem to be trying to pop elements from a `Vec` in a loop
+  --> $DIR/while_pop_unwrap.rs:22:22
+   |
+LL |     while !val.numbers.is_empty() {
+   |            ---------------------- help: try: `while let Some(number) = val.numbers.pop()`
+LL |         let number = val.numbers.pop().unwrap();
+   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: this while loop can be written in a more idiomatic way
+
+error: you seem to be trying to pop elements from a `Vec` in a loop
+  --> $DIR/while_pop_unwrap.rs:26:20
+   |
+LL |     while !numbers.is_empty() {
+   |            ------------------ help: try: `while let Some(element) = numbers.pop()`
+LL |         accept_i32(numbers.pop().unwrap());
+   |                    ^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: this while loop can be written in a more idiomatic way
+
+error: you seem to be trying to pop elements from a `Vec` in a loop
+  --> $DIR/while_pop_unwrap.rs:30:20
+   |
+LL |     while !numbers.is_empty() {
+   |            ------------------ help: try: `while let Some(element) = numbers.pop()`
+LL |         accept_i32(numbers.pop().expect(""));
+   |                    ^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: this while loop can be written in a more idiomatic way
+
+error: aborting due to 4 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From bcdcc34ba95cd27cab6da68fcac820ca6968d3e2 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Sat, 15 Apr 2023 23:01:53 +0200
Subject: elide lifetimes, get rid of glob import

---
 clippy_lints/src/while_pop_unwrap.rs | 24 ++++++++++--------------
 1 file changed, 10 insertions(+), 14 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/while_pop_unwrap.rs b/clippy_lints/src/while_pop_unwrap.rs
index fc77febad6b..0a3f08888a3 100644
--- a/clippy_lints/src/while_pop_unwrap.rs
+++ b/clippy_lints/src/while_pop_unwrap.rs
@@ -1,6 +1,6 @@
 use clippy_utils::{diagnostics::span_lint_and_then, match_def_path, paths, source::snippet};
 use rustc_errors::Applicability;
-use rustc_hir::*;
+use rustc_hir::{Expr, ExprKind, PatKind, Stmt, StmtKind, UnOp};
 use rustc_lint::LateContext;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::{symbol::Ident, Span};
@@ -36,13 +36,7 @@ declare_clippy_lint! {
 }
 declare_lint_pass!(WhilePopUnwrap => [WHILE_POP_UNWRAP]);
 
-fn report_lint<'tcx>(
-    cx: &LateContext<'tcx>,
-    pop_span: Span,
-    ident: Option<Ident>,
-    loop_span: Span,
-    receiver_span: Span,
-) {
+fn report_lint(cx: &LateContext<'_>, pop_span: Span, ident: Option<Ident>, loop_span: Span, receiver_span: Span) {
     span_lint_and_then(
         cx,
         WHILE_POP_UNWRAP,
@@ -54,7 +48,7 @@ fn report_lint<'tcx>(
                 "try",
                 format!(
                     "while let Some({}) = {}.pop()",
-                    ident.as_ref().map(Ident::as_str).unwrap_or("element"),
+                    ident.as_ref().map_or("element", Ident::as_str),
                     snippet(cx, receiver_span, "..")
                 ),
                 Applicability::MaybeIncorrect,
@@ -75,11 +69,11 @@ fn match_method_call(cx: &LateContext<'_>, expr: &Expr<'_>, method: &[&str]) ->
     }
 }
 
-fn is_vec_pop<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>) -> bool {
+fn is_vec_pop(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
     match_method_call(cx, expr, &paths::VEC_POP)
 }
 
-fn is_vec_pop_unwrap<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>) -> bool {
+fn is_vec_pop_unwrap(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
     if let ExprKind::MethodCall(_, inner, ..) = expr.kind
         && (match_method_call(cx, expr, &paths::OPTION_UNWRAP) || match_method_call(cx, expr, &paths::OPTION_EXPECT))
         && is_vec_pop(cx, inner)
@@ -90,7 +84,7 @@ fn is_vec_pop_unwrap<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>) -> bool {
     }
 }
 
-fn check_local<'tcx>(cx: &LateContext<'tcx>, stmt: &Stmt<'_>, loop_span: Span, recv_span: Span) {
+fn check_local(cx: &LateContext<'_>, stmt: &Stmt<'_>, loop_span: Span, recv_span: Span) {
     if let StmtKind::Local(local) = stmt.kind
         && let PatKind::Binding(.., ident, _) = local.pat.kind
         && let Some(init) = local.init
@@ -101,10 +95,12 @@ fn check_local<'tcx>(cx: &LateContext<'tcx>, stmt: &Stmt<'_>, loop_span: Span, r
     }
 }
 
-fn check_call_arguments<'tcx>(cx: &LateContext<'tcx>, stmt: &Stmt<'_>, loop_span: Span, recv_span: Span) {
+fn check_call_arguments(cx: &LateContext<'_>, stmt: &Stmt<'_>, loop_span: Span, recv_span: Span) {
     if let StmtKind::Semi(expr) | StmtKind::Expr(expr) = stmt.kind {
         if let ExprKind::MethodCall(_, _, args, _) | ExprKind::Call(_, args) = expr.kind {
-            let offending_arg = args.iter().find_map(|arg| is_vec_pop_unwrap(cx, arg).then(|| arg.span));
+            let offending_arg = args
+                .iter()
+                .find_map(|arg| is_vec_pop_unwrap(cx, arg).then_some(arg.span));
 
             if let Some(offending_arg) = offending_arg {
                 report_lint(cx, offending_arg, None, loop_span, recv_span);
-- 
cgit 1.4.1-3-g733a5


From 1d08325293f0dcccd29700d6b14755f8fbd5f076 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Tue, 18 Apr 2023 00:14:56 +0200
Subject: move lint to loops, emit proper suggestion, more tests

---
 clippy_lints/src/declared_lints.rs         |   2 +-
 clippy_lints/src/lib.rs                    |   1 -
 clippy_lints/src/loops/mod.rs              |  38 ++++++++-
 clippy_lints/src/loops/while_pop_unwrap.rs | 109 ++++++++++++++++++++++++++
 clippy_lints/src/utils/author.rs           |   2 +-
 clippy_lints/src/while_pop_unwrap.rs       | 122 -----------------------------
 clippy_utils/src/higher.rs                 |   6 +-
 tests/ui/while_pop_unwrap.fixed            |  93 ++++++++++++++++++++++
 tests/ui/while_pop_unwrap.rs               |  46 +++++++++++
 tests/ui/while_pop_unwrap.stderr           |  82 ++++++++++++++-----
 10 files changed, 351 insertions(+), 150 deletions(-)
 create mode 100644 clippy_lints/src/loops/while_pop_unwrap.rs
 delete mode 100644 clippy_lints/src/while_pop_unwrap.rs
 create mode 100644 tests/ui/while_pop_unwrap.fixed

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index ddc4b139670..ff418092e4b 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -258,6 +258,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::loops::WHILE_IMMUTABLE_CONDITION_INFO,
     crate::loops::WHILE_LET_LOOP_INFO,
     crate::loops::WHILE_LET_ON_ITERATOR_INFO,
+    crate::loops::WHILE_POP_UNWRAP_INFO,
     crate::macro_use::MACRO_USE_IMPORTS_INFO,
     crate::main_recursion::MAIN_RECURSION_INFO,
     crate::manual_assert::MANUAL_ASSERT_INFO,
@@ -645,7 +646,6 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::useless_conversion::USELESS_CONVERSION_INFO,
     crate::vec::USELESS_VEC_INFO,
     crate::vec_init_then_push::VEC_INIT_THEN_PUSH_INFO,
-    crate::while_pop_unwrap::WHILE_POP_UNWRAP_INFO,
     crate::wildcard_imports::ENUM_GLOB_USE_INFO,
     crate::wildcard_imports::WILDCARD_IMPORTS_INFO,
     crate::write::PRINTLN_EMPTY_STRING_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 0d594612b79..48dbecc9f6a 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -324,7 +324,6 @@ mod use_self;
 mod useless_conversion;
 mod vec;
 mod vec_init_then_push;
-mod while_pop_unwrap;
 mod wildcard_imports;
 mod write;
 mod zero_div_zero;
diff --git a/clippy_lints/src/loops/mod.rs b/clippy_lints/src/loops/mod.rs
index 90012694062..02197e9c187 100644
--- a/clippy_lints/src/loops/mod.rs
+++ b/clippy_lints/src/loops/mod.rs
@@ -17,6 +17,7 @@ mod utils;
 mod while_immutable_condition;
 mod while_let_loop;
 mod while_let_on_iterator;
+mod while_pop_unwrap;
 
 use clippy_utils::higher;
 use rustc_hir::{Expr, ExprKind, LoopSource, Pat};
@@ -25,8 +26,6 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
 use utils::{make_iterator_snippet, IncrementVisitor, InitializeVisitor};
 
-use crate::while_pop_unwrap;
-
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for for-loops that manually copy items between
@@ -577,6 +576,36 @@ declare_clippy_lint! {
     "manual implementation of `Iterator::find`"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Looks for loops that check for emptiness of a `Vec` in the condition and pop an element
+    /// in the body as a separate operation.
+    ///
+    /// ### Why is this bad?
+    /// Such loops can be written in a more idiomatic way by using a while..let loop and directly
+    /// pattern matching on the return value of `Vec::pop()`.
+    ///
+    /// ### Example
+    /// ```rust
+    /// let mut numbers = vec![1, 2, 3, 4, 5];
+    /// while !numbers.is_empty() {
+    ///     let number = numbers.pop().unwrap();
+    ///     // use `number`
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// let mut numbers = vec![1, 2, 3, 4, 5];
+    /// while let Some(number) = numbers.pop() {
+    ///     // use `number`
+    /// }
+    /// ```
+    #[clippy::version = "1.70.0"]
+    pub WHILE_POP_UNWRAP,
+    style,
+    "checking for emptiness of a `Vec` in the loop condition and popping an element in the body"
+}
+
 declare_lint_pass!(Loops => [
     MANUAL_MEMCPY,
     MANUAL_FLATTEN,
@@ -596,6 +625,7 @@ declare_lint_pass!(Loops => [
     SINGLE_ELEMENT_LOOP,
     MISSING_SPIN_LOOP,
     MANUAL_FIND,
+    WHILE_POP_UNWRAP
 ]);
 
 impl<'tcx> LateLintPass<'tcx> for Loops {
@@ -642,10 +672,10 @@ impl<'tcx> LateLintPass<'tcx> for Loops {
 
         while_let_on_iterator::check(cx, expr);
 
-        if let Some(higher::While { condition, body }) = higher::While::hir(expr) {
+        if let Some(higher::While { condition, body, span }) = higher::While::hir(expr) {
             while_immutable_condition::check(cx, condition, body);
             missing_spin_loop::check(cx, condition, body);
-            while_pop_unwrap::check(cx, condition, body);
+            while_pop_unwrap::check(cx, condition, body, span);
         }
     }
 }
diff --git a/clippy_lints/src/loops/while_pop_unwrap.rs b/clippy_lints/src/loops/while_pop_unwrap.rs
new file mode 100644
index 00000000000..1e31184b34d
--- /dev/null
+++ b/clippy_lints/src/loops/while_pop_unwrap.rs
@@ -0,0 +1,109 @@
+use clippy_utils::{
+    diagnostics::{multispan_sugg_with_applicability, span_lint_and_then},
+    match_def_path, paths,
+    source::snippet,
+    SpanlessEq,
+};
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind, Pat, Stmt, StmtKind, UnOp};
+use rustc_lint::LateContext;
+use rustc_span::Span;
+use std::borrow::Cow;
+
+use super::WHILE_POP_UNWRAP;
+
+/// The kind of statement that the `pop()` call appeared in.
+///
+/// Depending on whether the value was assigned to a variable or not changes what pattern
+/// we use for the suggestion.
+enum PopStmt<'hir> {
+    /// `x.pop().unwrap()` was and assigned to a variable.
+    /// The pattern of this local variable will be used and the local statement
+    /// is deleted in the suggestion.
+    Local(&'hir Pat<'hir>),
+    /// `x.pop().unwrap()` appeared in an arbitrary expression and was not assigned to a variable.
+    /// The suggestion will use some placeholder identifier and the `x.pop().unwrap()` expression
+    /// is replaced with that identifier.
+    Anonymous,
+}
+
+fn report_lint(cx: &LateContext<'_>, pop_span: Span, pop_stmt_kind: PopStmt<'_>, loop_span: Span, receiver_span: Span) {
+    span_lint_and_then(
+        cx,
+        WHILE_POP_UNWRAP,
+        pop_span,
+        "you seem to be trying to pop elements from a `Vec` in a loop",
+        |diag| {
+            let (pat, pop_replacement) = match &pop_stmt_kind {
+                PopStmt::Local(pat) => (snippet(cx, pat.span, ".."), String::new()),
+                PopStmt::Anonymous => (Cow::Borrowed("element"), "element".into()),
+            };
+
+            let loop_replacement = format!("while let Some({}) = {}.pop()", pat, snippet(cx, receiver_span, ".."));
+            multispan_sugg_with_applicability(
+                diag,
+                "consider using a `while..let` loop",
+                Applicability::MachineApplicable,
+                [(loop_span, loop_replacement), (pop_span, pop_replacement)],
+            );
+        },
+    );
+}
+
+fn match_method_call(cx: &LateContext<'_>, expr: &Expr<'_>, method: &[&str]) -> bool {
+    if let ExprKind::MethodCall(..) = expr.kind
+        && let Some(id) = cx.typeck_results().type_dependent_def_id(expr.hir_id)
+    {
+        match_def_path(cx, id, method)
+    } else {
+        false
+    }
+}
+
+fn is_vec_pop_unwrap(cx: &LateContext<'_>, expr: &Expr<'_>, is_empty_recv: &Expr<'_>) -> bool {
+    if (match_method_call(cx, expr, &paths::OPTION_UNWRAP) || match_method_call(cx, expr, &paths::OPTION_EXPECT))
+        && let ExprKind::MethodCall(_, unwrap_recv, ..) = expr.kind
+        && match_method_call(cx, unwrap_recv, &paths::VEC_POP)
+        && let ExprKind::MethodCall(_, pop_recv, ..) = unwrap_recv.kind
+    {
+        // make sure they're the same `Vec`
+        SpanlessEq::new(cx).eq_expr(pop_recv, is_empty_recv)
+    } else {
+        false
+    }
+}
+
+fn check_local(cx: &LateContext<'_>, stmt: &Stmt<'_>, is_empty_recv: &Expr<'_>, loop_span: Span) {
+    if let StmtKind::Local(local) = stmt.kind
+        && let Some(init) = local.init
+        && is_vec_pop_unwrap(cx, init, is_empty_recv)
+    {
+        report_lint(cx, stmt.span, PopStmt::Local(&local.pat), loop_span, is_empty_recv.span);
+    }
+}
+
+fn check_call_arguments(cx: &LateContext<'_>, stmt: &Stmt<'_>, is_empty_recv: &Expr<'_>, loop_span: Span) {
+    if let StmtKind::Semi(expr) | StmtKind::Expr(expr) = stmt.kind {
+        if let ExprKind::MethodCall(.., args, _) | ExprKind::Call(_, args) = expr.kind {
+            let offending_arg = args
+                .iter()
+                .find_map(|arg| is_vec_pop_unwrap(cx, arg, is_empty_recv).then_some(arg.span));
+
+            if let Some(offending_arg) = offending_arg {
+                report_lint(cx, offending_arg, PopStmt::Anonymous, loop_span, is_empty_recv.span);
+            }
+        }
+    }
+}
+
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, full_cond: &'tcx Expr<'_>, body: &'tcx Expr<'_>, loop_span: Span) {
+    if let ExprKind::Unary(UnOp::Not, cond) = full_cond.kind
+        && let ExprKind::MethodCall(_, is_empty_recv, _, _) = cond.kind
+        && match_method_call(cx, cond, &paths::VEC_IS_EMPTY)
+        && let ExprKind::Block(body, _) = body.kind
+        && let Some(stmt) = body.stmts.first()
+    {
+        check_local(cx, stmt, is_empty_recv, loop_span);
+        check_call_arguments(cx, stmt, is_empty_recv, loop_span);
+    }
+}
diff --git a/clippy_lints/src/utils/author.rs b/clippy_lints/src/utils/author.rs
index 1f632916c57..108077b9d15 100644
--- a/clippy_lints/src/utils/author.rs
+++ b/clippy_lints/src/utils/author.rs
@@ -333,7 +333,7 @@ impl<'a, 'tcx> PrintVisitor<'a, 'tcx> {
 
     #[allow(clippy::too_many_lines)]
     fn expr(&self, expr: &Binding<&hir::Expr<'_>>) {
-        if let Some(higher::While { condition, body }) = higher::While::hir(expr.value) {
+        if let Some(higher::While { condition, body, .. }) = higher::While::hir(expr.value) {
             bind!(self, condition, body);
             chain!(
                 self,
diff --git a/clippy_lints/src/while_pop_unwrap.rs b/clippy_lints/src/while_pop_unwrap.rs
deleted file mode 100644
index 0a3f08888a3..00000000000
--- a/clippy_lints/src/while_pop_unwrap.rs
+++ /dev/null
@@ -1,122 +0,0 @@
-use clippy_utils::{diagnostics::span_lint_and_then, match_def_path, paths, source::snippet};
-use rustc_errors::Applicability;
-use rustc_hir::{Expr, ExprKind, PatKind, Stmt, StmtKind, UnOp};
-use rustc_lint::LateContext;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::{symbol::Ident, Span};
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Looks for loops that check for emptiness of a `Vec` in the condition and pop an element
-    /// in the body as a separate operation.
-    ///
-    /// ### Why is this bad?
-    /// Such loops can be written in a more idiomatic way by using a while..let loop and directly
-    /// pattern matching on the return value of `Vec::pop()`.
-    ///
-    /// ### Example
-    /// ```rust
-    /// let mut numbers = vec![1, 2, 3, 4, 5];
-    /// while !numbers.is_empty() {
-    ///     let number = numbers.pop().unwrap();
-    ///     // use `number`
-    /// }
-    /// ```
-    /// Use instead:
-    /// ```rust
-    /// let mut numbers = vec![1, 2, 3, 4, 5];
-    /// while let Some(number) = numbers.pop() {
-    ///     // use `number`
-    /// }
-    /// ```
-    #[clippy::version = "1.70.0"]
-    pub WHILE_POP_UNWRAP,
-    style,
-    "checking for emptiness of a `Vec` in the loop condition and popping an element in the body"
-}
-declare_lint_pass!(WhilePopUnwrap => [WHILE_POP_UNWRAP]);
-
-fn report_lint(cx: &LateContext<'_>, pop_span: Span, ident: Option<Ident>, loop_span: Span, receiver_span: Span) {
-    span_lint_and_then(
-        cx,
-        WHILE_POP_UNWRAP,
-        pop_span,
-        "you seem to be trying to pop elements from a `Vec` in a loop",
-        |diag| {
-            diag.span_suggestion(
-                loop_span,
-                "try",
-                format!(
-                    "while let Some({}) = {}.pop()",
-                    ident.as_ref().map_or("element", Ident::as_str),
-                    snippet(cx, receiver_span, "..")
-                ),
-                Applicability::MaybeIncorrect,
-            )
-            .note("this while loop can be written in a more idiomatic way");
-        },
-    );
-}
-
-fn match_method_call(cx: &LateContext<'_>, expr: &Expr<'_>, method: &[&str]) -> bool {
-    if let ExprKind::MethodCall(..) = expr.kind
-        && let Some(id) = cx.typeck_results().type_dependent_def_id(expr.hir_id)
-        && match_def_path(cx, id, method)
-    {
-        true
-    } else {
-        false
-    }
-}
-
-fn is_vec_pop(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-    match_method_call(cx, expr, &paths::VEC_POP)
-}
-
-fn is_vec_pop_unwrap(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-    if let ExprKind::MethodCall(_, inner, ..) = expr.kind
-        && (match_method_call(cx, expr, &paths::OPTION_UNWRAP) || match_method_call(cx, expr, &paths::OPTION_EXPECT))
-        && is_vec_pop(cx, inner)
-    {
-        true
-    } else {
-        false
-    }
-}
-
-fn check_local(cx: &LateContext<'_>, stmt: &Stmt<'_>, loop_span: Span, recv_span: Span) {
-    if let StmtKind::Local(local) = stmt.kind
-        && let PatKind::Binding(.., ident, _) = local.pat.kind
-        && let Some(init) = local.init
-        && let ExprKind::MethodCall(_, inner, ..) = init.kind
-        && is_vec_pop_unwrap(cx, init)
-    {
-        report_lint(cx, init.span.to(inner.span), Some(ident), loop_span, recv_span);
-    }
-}
-
-fn check_call_arguments(cx: &LateContext<'_>, stmt: &Stmt<'_>, loop_span: Span, recv_span: Span) {
-    if let StmtKind::Semi(expr) | StmtKind::Expr(expr) = stmt.kind {
-        if let ExprKind::MethodCall(_, _, args, _) | ExprKind::Call(_, args) = expr.kind {
-            let offending_arg = args
-                .iter()
-                .find_map(|arg| is_vec_pop_unwrap(cx, arg).then_some(arg.span));
-
-            if let Some(offending_arg) = offending_arg {
-                report_lint(cx, offending_arg, None, loop_span, recv_span);
-            }
-        }
-    }
-}
-
-pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, cond: &'tcx Expr<'_>, body: &'tcx Expr<'_>) {
-    if let ExprKind::Unary(UnOp::Not, cond) = cond.kind
-        && let ExprKind::MethodCall(_, Expr { span: recv_span, .. }, _, _) = cond.kind
-        && match_method_call(cx, cond, &paths::VEC_IS_EMPTY)
-        && let ExprKind::Block(body, _) = body.kind
-        && let Some(stmt) = body.stmts.first()
-    {
-        check_local(cx, stmt, cond.span, *recv_span);
-        check_call_arguments(cx, stmt, cond.span, *recv_span);
-    }
-}
diff --git a/clippy_utils/src/higher.rs b/clippy_utils/src/higher.rs
index 50bef370930..a61e4c38088 100644
--- a/clippy_utils/src/higher.rs
+++ b/clippy_utils/src/higher.rs
@@ -311,6 +311,8 @@ pub struct While<'hir> {
     pub condition: &'hir Expr<'hir>,
     /// `while` loop body
     pub body: &'hir Expr<'hir>,
+    /// Span of the loop header
+    pub span: Span,
 }
 
 impl<'hir> While<'hir> {
@@ -336,10 +338,10 @@ impl<'hir> While<'hir> {
             },
             _,
             LoopSource::While,
-            _,
+            span,
         ) = expr.kind
         {
-            return Some(Self { condition, body });
+            return Some(Self { condition, body, span });
         }
         None
     }
diff --git a/tests/ui/while_pop_unwrap.fixed b/tests/ui/while_pop_unwrap.fixed
new file mode 100644
index 00000000000..a635e054e6e
--- /dev/null
+++ b/tests/ui/while_pop_unwrap.fixed
@@ -0,0 +1,93 @@
+// run-rustfix
+
+#![allow(unused)]
+#![warn(clippy::while_pop_unwrap)]
+
+struct VecInStruct {
+    numbers: Vec<i32>,
+    unrelated: String,
+}
+
+struct Foo {
+    a: i32,
+    b: i32,
+}
+
+fn accept_i32(_: i32) {}
+fn accept_optional_i32(_: Option<i32>) {}
+fn accept_i32_tuple(_: (i32, i32)) {}
+
+fn main() {
+    let mut numbers = vec![1, 2, 3, 4, 5];
+    while let Some(number) = numbers.pop() {
+        
+    }
+
+    let mut val = VecInStruct {
+        numbers: vec![1, 2, 3, 4, 5],
+        unrelated: String::new(),
+    };
+    while let Some(number) = val.numbers.pop() {
+        
+    }
+
+    while let Some(element) = numbers.pop() {
+        accept_i32(element);
+    }
+
+    while let Some(element) = numbers.pop() {
+        accept_i32(element);
+    }
+
+    // This should not warn. It "conditionally" pops elements.
+    while !numbers.is_empty() {
+        if true {
+            accept_i32(numbers.pop().unwrap());
+        }
+    }
+
+    // This should also not warn. It conditionally pops elements.
+    while !numbers.is_empty() {
+        if false {
+            continue;
+        }
+        accept_i32(numbers.pop().unwrap());
+    }
+
+    // This should not warn. It pops elements, but does not unwrap it.
+    // Might handle the Option in some other arbitrary way.
+    while !numbers.is_empty() {
+        accept_optional_i32(numbers.pop());
+    }
+
+    let unrelated_vec: Vec<String> = Vec::new();
+    // This should not warn. It pops elements from a different vector.
+    while !unrelated_vec.is_empty() {
+        accept_i32(numbers.pop().unwrap());
+    }
+
+    macro_rules! generate_loop {
+        () => {
+            while !numbers.is_empty() {
+                accept_i32(numbers.pop().unwrap());
+            }
+        };
+    }
+    // Do not warn if the loop is in a macro.
+    generate_loop!();
+
+    // Try other kinds of patterns
+    let mut numbers = vec![(0, 0), (1, 1), (2, 2)];
+    while let Some((a, b)) = numbers.pop() {
+        
+    }
+
+    while let Some(element) = numbers.pop() {
+        accept_i32_tuple(element);
+    }
+
+    let mut results = vec![Foo { a: 1, b: 2 }, Foo { a: 3, b: 4 }];
+    while let Some(Foo { a, b }) = results.pop() {
+        
+    }
+}
diff --git a/tests/ui/while_pop_unwrap.rs b/tests/ui/while_pop_unwrap.rs
index 1b6de8f1f89..820ff211086 100644
--- a/tests/ui/while_pop_unwrap.rs
+++ b/tests/ui/while_pop_unwrap.rs
@@ -1,3 +1,5 @@
+// run-rustfix
+
 #![allow(unused)]
 #![warn(clippy::while_pop_unwrap)]
 
@@ -6,7 +8,14 @@ struct VecInStruct {
     unrelated: String,
 }
 
+struct Foo {
+    a: i32,
+    b: i32,
+}
+
 fn accept_i32(_: i32) {}
+fn accept_optional_i32(_: Option<i32>) {}
+fn accept_i32_tuple(_: (i32, i32)) {}
 
 fn main() {
     let mut numbers = vec![1, 2, 3, 4, 5];
@@ -44,4 +53,41 @@ fn main() {
         }
         accept_i32(numbers.pop().unwrap());
     }
+
+    // This should not warn. It pops elements, but does not unwrap it.
+    // Might handle the Option in some other arbitrary way.
+    while !numbers.is_empty() {
+        accept_optional_i32(numbers.pop());
+    }
+
+    let unrelated_vec: Vec<String> = Vec::new();
+    // This should not warn. It pops elements from a different vector.
+    while !unrelated_vec.is_empty() {
+        accept_i32(numbers.pop().unwrap());
+    }
+
+    macro_rules! generate_loop {
+        () => {
+            while !numbers.is_empty() {
+                accept_i32(numbers.pop().unwrap());
+            }
+        };
+    }
+    // Do not warn if the loop is in a macro.
+    generate_loop!();
+
+    // Try other kinds of patterns
+    let mut numbers = vec![(0, 0), (1, 1), (2, 2)];
+    while !numbers.is_empty() {
+        let (a, b) = numbers.pop().unwrap();
+    }
+
+    while !numbers.is_empty() {
+        accept_i32_tuple(numbers.pop().unwrap());
+    }
+
+    let mut results = vec![Foo { a: 1, b: 2 }, Foo { a: 3, b: 4 }];
+    while !results.is_empty() {
+        let Foo { a, b } = results.pop().unwrap();
+    }
 }
diff --git a/tests/ui/while_pop_unwrap.stderr b/tests/ui/while_pop_unwrap.stderr
index 8dc77db8b5a..f8a6cfcda0e 100644
--- a/tests/ui/while_pop_unwrap.stderr
+++ b/tests/ui/while_pop_unwrap.stderr
@@ -1,43 +1,87 @@
 error: you seem to be trying to pop elements from a `Vec` in a loop
-  --> $DIR/while_pop_unwrap.rs:14:22
+  --> $DIR/while_pop_unwrap.rs:23:9
    |
-LL |     while !numbers.is_empty() {
-   |            ------------------ help: try: `while let Some(number) = numbers.pop()`
 LL |         let number = numbers.pop().unwrap();
-   |                      ^^^^^^^^^^^^^^^^^^^^^^
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = note: this while loop can be written in a more idiomatic way
    = note: `-D clippy::while-pop-unwrap` implied by `-D warnings`
+help: consider using a `while..let` loop
+   |
+LL ~     while let Some(number) = numbers.pop() {
+LL ~         
+   |
 
 error: you seem to be trying to pop elements from a `Vec` in a loop
-  --> $DIR/while_pop_unwrap.rs:22:22
+  --> $DIR/while_pop_unwrap.rs:31:9
    |
-LL |     while !val.numbers.is_empty() {
-   |            ---------------------- help: try: `while let Some(number) = val.numbers.pop()`
 LL |         let number = val.numbers.pop().unwrap();
-   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider using a `while..let` loop
+   |
+LL ~     while let Some(number) = val.numbers.pop() {
+LL ~         
    |
-   = note: this while loop can be written in a more idiomatic way
 
 error: you seem to be trying to pop elements from a `Vec` in a loop
-  --> $DIR/while_pop_unwrap.rs:26:20
+  --> $DIR/while_pop_unwrap.rs:35:20
    |
-LL |     while !numbers.is_empty() {
-   |            ------------------ help: try: `while let Some(element) = numbers.pop()`
 LL |         accept_i32(numbers.pop().unwrap());
    |                    ^^^^^^^^^^^^^^^^^^^^^^
    |
-   = note: this while loop can be written in a more idiomatic way
+help: consider using a `while..let` loop
+   |
+LL ~     while let Some(element) = numbers.pop() {
+LL ~         accept_i32(element);
+   |
 
 error: you seem to be trying to pop elements from a `Vec` in a loop
-  --> $DIR/while_pop_unwrap.rs:30:20
+  --> $DIR/while_pop_unwrap.rs:39:20
    |
-LL |     while !numbers.is_empty() {
-   |            ------------------ help: try: `while let Some(element) = numbers.pop()`
 LL |         accept_i32(numbers.pop().expect(""));
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = note: this while loop can be written in a more idiomatic way
+help: consider using a `while..let` loop
+   |
+LL ~     while let Some(element) = numbers.pop() {
+LL ~         accept_i32(element);
+   |
+
+error: you seem to be trying to pop elements from a `Vec` in a loop
+  --> $DIR/while_pop_unwrap.rs:82:9
+   |
+LL |         let (a, b) = numbers.pop().unwrap();
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider using a `while..let` loop
+   |
+LL ~     while let Some((a, b)) = numbers.pop() {
+LL ~         
+   |
+
+error: you seem to be trying to pop elements from a `Vec` in a loop
+  --> $DIR/while_pop_unwrap.rs:86:26
+   |
+LL |         accept_i32_tuple(numbers.pop().unwrap());
+   |                          ^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider using a `while..let` loop
+   |
+LL ~     while let Some(element) = numbers.pop() {
+LL ~         accept_i32_tuple(element);
+   |
+
+error: you seem to be trying to pop elements from a `Vec` in a loop
+  --> $DIR/while_pop_unwrap.rs:91:9
+   |
+LL |         let Foo { a, b } = results.pop().unwrap();
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider using a `while..let` loop
+   |
+LL ~     while let Some(Foo { a, b }) = results.pop() {
+LL ~         
+   |
 
-error: aborting due to 4 previous errors
+error: aborting due to 7 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From ab9b7a5ad23bd2cb2097719ad9439277b8f5d987 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Tue, 18 Apr 2023 00:25:39 +0200
Subject: remove unnecessary reference

---
 clippy_lints/src/loops/while_pop_unwrap.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/while_pop_unwrap.rs b/clippy_lints/src/loops/while_pop_unwrap.rs
index 1e31184b34d..fc6797d72c0 100644
--- a/clippy_lints/src/loops/while_pop_unwrap.rs
+++ b/clippy_lints/src/loops/while_pop_unwrap.rs
@@ -34,7 +34,7 @@ fn report_lint(cx: &LateContext<'_>, pop_span: Span, pop_stmt_kind: PopStmt<'_>,
         pop_span,
         "you seem to be trying to pop elements from a `Vec` in a loop",
         |diag| {
-            let (pat, pop_replacement) = match &pop_stmt_kind {
+            let (pat, pop_replacement) = match pop_stmt_kind {
                 PopStmt::Local(pat) => (snippet(cx, pat.span, ".."), String::new()),
                 PopStmt::Anonymous => (Cow::Borrowed("element"), "element".into()),
             };
@@ -78,7 +78,7 @@ fn check_local(cx: &LateContext<'_>, stmt: &Stmt<'_>, is_empty_recv: &Expr<'_>,
         && let Some(init) = local.init
         && is_vec_pop_unwrap(cx, init, is_empty_recv)
     {
-        report_lint(cx, stmt.span, PopStmt::Local(&local.pat), loop_span, is_empty_recv.span);
+        report_lint(cx, stmt.span, PopStmt::Local(local.pat), loop_span, is_empty_recv.span);
     }
 }
 
-- 
cgit 1.4.1-3-g733a5


From f10e39fd2be243b7f0d4f82f56420ba1cbd4a7bb Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Tue, 18 Apr 2023 00:40:03 +0200
Subject: make PopStmt copy+clone

---
 clippy_lints/src/loops/while_pop_unwrap.rs | 1 +
 1 file changed, 1 insertion(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/while_pop_unwrap.rs b/clippy_lints/src/loops/while_pop_unwrap.rs
index fc6797d72c0..3a583396230 100644
--- a/clippy_lints/src/loops/while_pop_unwrap.rs
+++ b/clippy_lints/src/loops/while_pop_unwrap.rs
@@ -16,6 +16,7 @@ use super::WHILE_POP_UNWRAP;
 ///
 /// Depending on whether the value was assigned to a variable or not changes what pattern
 /// we use for the suggestion.
+#[derive(Copy, Clone)]
 enum PopStmt<'hir> {
     /// `x.pop().unwrap()` was and assigned to a variable.
     /// The pattern of this local variable will be used and the local statement
-- 
cgit 1.4.1-3-g733a5


From 8d8178f93184d09cf1e3f813257d6aeb19d08c57 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Wed, 19 Apr 2023 22:26:50 +0200
Subject: rename lint to `manual_while_let_some`

---
 CHANGELOG.md                                    |   2 +-
 clippy_lints/src/declared_lints.rs              |   2 +-
 clippy_lints/src/loops/manual_while_let_some.rs | 110 ++++++++++++++++++++++++
 clippy_lints/src/loops/mod.rs                   |  10 +--
 clippy_lints/src/loops/while_pop_unwrap.rs      | 110 ------------------------
 tests/ui/manual_while_let_some.fixed            |  93 ++++++++++++++++++++
 tests/ui/manual_while_let_some.rs               |  93 ++++++++++++++++++++
 tests/ui/manual_while_let_some.stderr           |  87 +++++++++++++++++++
 tests/ui/while_pop_unwrap.fixed                 |  93 --------------------
 tests/ui/while_pop_unwrap.rs                    |  93 --------------------
 tests/ui/while_pop_unwrap.stderr                |  87 -------------------
 11 files changed, 390 insertions(+), 390 deletions(-)
 create mode 100644 clippy_lints/src/loops/manual_while_let_some.rs
 delete mode 100644 clippy_lints/src/loops/while_pop_unwrap.rs
 create mode 100644 tests/ui/manual_while_let_some.fixed
 create mode 100644 tests/ui/manual_while_let_some.rs
 create mode 100644 tests/ui/manual_while_let_some.stderr
 delete mode 100644 tests/ui/while_pop_unwrap.fixed
 delete mode 100644 tests/ui/while_pop_unwrap.rs
 delete mode 100644 tests/ui/while_pop_unwrap.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index da03f5c012b..d1e98a93940 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4797,6 +4797,7 @@ Released 2018-09-13
 [`manual_strip`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_strip
 [`manual_swap`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_swap
 [`manual_unwrap_or`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_unwrap_or
+[`manual_while_let_some`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_while_let_some
 [`many_single_char_names`]: https://rust-lang.github.io/rust-clippy/master/index.html#many_single_char_names
 [`map_clone`]: https://rust-lang.github.io/rust-clippy/master/index.html#map_clone
 [`map_collect_result_unit`]: https://rust-lang.github.io/rust-clippy/master/index.html#map_collect_result_unit
@@ -5160,7 +5161,6 @@ Released 2018-09-13
 [`while_immutable_condition`]: https://rust-lang.github.io/rust-clippy/master/index.html#while_immutable_condition
 [`while_let_loop`]: https://rust-lang.github.io/rust-clippy/master/index.html#while_let_loop
 [`while_let_on_iterator`]: https://rust-lang.github.io/rust-clippy/master/index.html#while_let_on_iterator
-[`while_pop_unwrap`]: https://rust-lang.github.io/rust-clippy/master/index.html#while_pop_unwrap
 [`wildcard_dependencies`]: https://rust-lang.github.io/rust-clippy/master/index.html#wildcard_dependencies
 [`wildcard_enum_match_arm`]: https://rust-lang.github.io/rust-clippy/master/index.html#wildcard_enum_match_arm
 [`wildcard_imports`]: https://rust-lang.github.io/rust-clippy/master/index.html#wildcard_imports
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index ff418092e4b..44e725be710 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -249,6 +249,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::loops::MANUAL_FIND_INFO,
     crate::loops::MANUAL_FLATTEN_INFO,
     crate::loops::MANUAL_MEMCPY_INFO,
+    crate::loops::MANUAL_WHILE_LET_SOME_INFO,
     crate::loops::MISSING_SPIN_LOOP_INFO,
     crate::loops::MUT_RANGE_BOUND_INFO,
     crate::loops::NEEDLESS_RANGE_LOOP_INFO,
@@ -258,7 +259,6 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::loops::WHILE_IMMUTABLE_CONDITION_INFO,
     crate::loops::WHILE_LET_LOOP_INFO,
     crate::loops::WHILE_LET_ON_ITERATOR_INFO,
-    crate::loops::WHILE_POP_UNWRAP_INFO,
     crate::macro_use::MACRO_USE_IMPORTS_INFO,
     crate::main_recursion::MAIN_RECURSION_INFO,
     crate::manual_assert::MANUAL_ASSERT_INFO,
diff --git a/clippy_lints/src/loops/manual_while_let_some.rs b/clippy_lints/src/loops/manual_while_let_some.rs
new file mode 100644
index 00000000000..cb9c84be4c7
--- /dev/null
+++ b/clippy_lints/src/loops/manual_while_let_some.rs
@@ -0,0 +1,110 @@
+use clippy_utils::{
+    diagnostics::{multispan_sugg_with_applicability, span_lint_and_then},
+    match_def_path, paths,
+    source::snippet,
+    SpanlessEq,
+};
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind, Pat, Stmt, StmtKind, UnOp};
+use rustc_lint::LateContext;
+use rustc_span::Span;
+use std::borrow::Cow;
+
+use super::MANUAL_WHILE_LET_SOME;
+
+/// The kind of statement that the `pop()` call appeared in.
+///
+/// Depending on whether the value was assigned to a variable or not changes what pattern
+/// we use for the suggestion.
+#[derive(Copy, Clone)]
+enum PopStmt<'hir> {
+    /// `x.pop().unwrap()` was and assigned to a variable.
+    /// The pattern of this local variable will be used and the local statement
+    /// is deleted in the suggestion.
+    Local(&'hir Pat<'hir>),
+    /// `x.pop().unwrap()` appeared in an arbitrary expression and was not assigned to a variable.
+    /// The suggestion will use some placeholder identifier and the `x.pop().unwrap()` expression
+    /// is replaced with that identifier.
+    Anonymous,
+}
+
+fn report_lint(cx: &LateContext<'_>, pop_span: Span, pop_stmt_kind: PopStmt<'_>, loop_span: Span, receiver_span: Span) {
+    span_lint_and_then(
+        cx,
+        MANUAL_WHILE_LET_SOME,
+        pop_span,
+        "you seem to be trying to pop elements from a `Vec` in a loop",
+        |diag| {
+            let (pat, pop_replacement) = match pop_stmt_kind {
+                PopStmt::Local(pat) => (snippet(cx, pat.span, ".."), String::new()),
+                PopStmt::Anonymous => (Cow::Borrowed("element"), "element".into()),
+            };
+
+            let loop_replacement = format!("while let Some({}) = {}.pop()", pat, snippet(cx, receiver_span, ".."));
+            multispan_sugg_with_applicability(
+                diag,
+                "consider using a `while..let` loop",
+                Applicability::MachineApplicable,
+                [(loop_span, loop_replacement), (pop_span, pop_replacement)],
+            );
+        },
+    );
+}
+
+fn match_method_call(cx: &LateContext<'_>, expr: &Expr<'_>, method: &[&str]) -> bool {
+    if let ExprKind::MethodCall(..) = expr.kind
+        && let Some(id) = cx.typeck_results().type_dependent_def_id(expr.hir_id)
+    {
+        match_def_path(cx, id, method)
+    } else {
+        false
+    }
+}
+
+fn is_vec_pop_unwrap(cx: &LateContext<'_>, expr: &Expr<'_>, is_empty_recv: &Expr<'_>) -> bool {
+    if (match_method_call(cx, expr, &paths::OPTION_UNWRAP) || match_method_call(cx, expr, &paths::OPTION_EXPECT))
+        && let ExprKind::MethodCall(_, unwrap_recv, ..) = expr.kind
+        && match_method_call(cx, unwrap_recv, &paths::VEC_POP)
+        && let ExprKind::MethodCall(_, pop_recv, ..) = unwrap_recv.kind
+    {
+        // make sure they're the same `Vec`
+        SpanlessEq::new(cx).eq_expr(pop_recv, is_empty_recv)
+    } else {
+        false
+    }
+}
+
+fn check_local(cx: &LateContext<'_>, stmt: &Stmt<'_>, is_empty_recv: &Expr<'_>, loop_span: Span) {
+    if let StmtKind::Local(local) = stmt.kind
+        && let Some(init) = local.init
+        && is_vec_pop_unwrap(cx, init, is_empty_recv)
+    {
+        report_lint(cx, stmt.span, PopStmt::Local(local.pat), loop_span, is_empty_recv.span);
+    }
+}
+
+fn check_call_arguments(cx: &LateContext<'_>, stmt: &Stmt<'_>, is_empty_recv: &Expr<'_>, loop_span: Span) {
+    if let StmtKind::Semi(expr) | StmtKind::Expr(expr) = stmt.kind {
+        if let ExprKind::MethodCall(.., args, _) | ExprKind::Call(_, args) = expr.kind {
+            let offending_arg = args
+                .iter()
+                .find_map(|arg| is_vec_pop_unwrap(cx, arg, is_empty_recv).then_some(arg.span));
+
+            if let Some(offending_arg) = offending_arg {
+                report_lint(cx, offending_arg, PopStmt::Anonymous, loop_span, is_empty_recv.span);
+            }
+        }
+    }
+}
+
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, full_cond: &'tcx Expr<'_>, body: &'tcx Expr<'_>, loop_span: Span) {
+    if let ExprKind::Unary(UnOp::Not, cond) = full_cond.kind
+        && let ExprKind::MethodCall(_, is_empty_recv, _, _) = cond.kind
+        && match_method_call(cx, cond, &paths::VEC_IS_EMPTY)
+        && let ExprKind::Block(body, _) = body.kind
+        && let Some(stmt) = body.stmts.first()
+    {
+        check_local(cx, stmt, is_empty_recv, loop_span);
+        check_call_arguments(cx, stmt, is_empty_recv, loop_span);
+    }
+}
diff --git a/clippy_lints/src/loops/mod.rs b/clippy_lints/src/loops/mod.rs
index 02197e9c187..f83ad388a74 100644
--- a/clippy_lints/src/loops/mod.rs
+++ b/clippy_lints/src/loops/mod.rs
@@ -7,6 +7,7 @@ mod iter_next_loop;
 mod manual_find;
 mod manual_flatten;
 mod manual_memcpy;
+mod manual_while_let_some;
 mod missing_spin_loop;
 mod mut_range_bound;
 mod needless_range_loop;
@@ -17,7 +18,6 @@ mod utils;
 mod while_immutable_condition;
 mod while_let_loop;
 mod while_let_on_iterator;
-mod while_pop_unwrap;
 
 use clippy_utils::higher;
 use rustc_hir::{Expr, ExprKind, LoopSource, Pat};
@@ -582,7 +582,7 @@ declare_clippy_lint! {
     /// in the body as a separate operation.
     ///
     /// ### Why is this bad?
-    /// Such loops can be written in a more idiomatic way by using a while..let loop and directly
+    /// Such loops can be written in a more idiomatic way by using a while-let loop and directly
     /// pattern matching on the return value of `Vec::pop()`.
     ///
     /// ### Example
@@ -601,7 +601,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     #[clippy::version = "1.70.0"]
-    pub WHILE_POP_UNWRAP,
+    pub MANUAL_WHILE_LET_SOME,
     style,
     "checking for emptiness of a `Vec` in the loop condition and popping an element in the body"
 }
@@ -625,7 +625,7 @@ declare_lint_pass!(Loops => [
     SINGLE_ELEMENT_LOOP,
     MISSING_SPIN_LOOP,
     MANUAL_FIND,
-    WHILE_POP_UNWRAP
+    MANUAL_WHILE_LET_SOME
 ]);
 
 impl<'tcx> LateLintPass<'tcx> for Loops {
@@ -675,7 +675,7 @@ impl<'tcx> LateLintPass<'tcx> for Loops {
         if let Some(higher::While { condition, body, span }) = higher::While::hir(expr) {
             while_immutable_condition::check(cx, condition, body);
             missing_spin_loop::check(cx, condition, body);
-            while_pop_unwrap::check(cx, condition, body, span);
+            manual_while_let_some::check(cx, condition, body, span);
         }
     }
 }
diff --git a/clippy_lints/src/loops/while_pop_unwrap.rs b/clippy_lints/src/loops/while_pop_unwrap.rs
deleted file mode 100644
index 3a583396230..00000000000
--- a/clippy_lints/src/loops/while_pop_unwrap.rs
+++ /dev/null
@@ -1,110 +0,0 @@
-use clippy_utils::{
-    diagnostics::{multispan_sugg_with_applicability, span_lint_and_then},
-    match_def_path, paths,
-    source::snippet,
-    SpanlessEq,
-};
-use rustc_errors::Applicability;
-use rustc_hir::{Expr, ExprKind, Pat, Stmt, StmtKind, UnOp};
-use rustc_lint::LateContext;
-use rustc_span::Span;
-use std::borrow::Cow;
-
-use super::WHILE_POP_UNWRAP;
-
-/// The kind of statement that the `pop()` call appeared in.
-///
-/// Depending on whether the value was assigned to a variable or not changes what pattern
-/// we use for the suggestion.
-#[derive(Copy, Clone)]
-enum PopStmt<'hir> {
-    /// `x.pop().unwrap()` was and assigned to a variable.
-    /// The pattern of this local variable will be used and the local statement
-    /// is deleted in the suggestion.
-    Local(&'hir Pat<'hir>),
-    /// `x.pop().unwrap()` appeared in an arbitrary expression and was not assigned to a variable.
-    /// The suggestion will use some placeholder identifier and the `x.pop().unwrap()` expression
-    /// is replaced with that identifier.
-    Anonymous,
-}
-
-fn report_lint(cx: &LateContext<'_>, pop_span: Span, pop_stmt_kind: PopStmt<'_>, loop_span: Span, receiver_span: Span) {
-    span_lint_and_then(
-        cx,
-        WHILE_POP_UNWRAP,
-        pop_span,
-        "you seem to be trying to pop elements from a `Vec` in a loop",
-        |diag| {
-            let (pat, pop_replacement) = match pop_stmt_kind {
-                PopStmt::Local(pat) => (snippet(cx, pat.span, ".."), String::new()),
-                PopStmt::Anonymous => (Cow::Borrowed("element"), "element".into()),
-            };
-
-            let loop_replacement = format!("while let Some({}) = {}.pop()", pat, snippet(cx, receiver_span, ".."));
-            multispan_sugg_with_applicability(
-                diag,
-                "consider using a `while..let` loop",
-                Applicability::MachineApplicable,
-                [(loop_span, loop_replacement), (pop_span, pop_replacement)],
-            );
-        },
-    );
-}
-
-fn match_method_call(cx: &LateContext<'_>, expr: &Expr<'_>, method: &[&str]) -> bool {
-    if let ExprKind::MethodCall(..) = expr.kind
-        && let Some(id) = cx.typeck_results().type_dependent_def_id(expr.hir_id)
-    {
-        match_def_path(cx, id, method)
-    } else {
-        false
-    }
-}
-
-fn is_vec_pop_unwrap(cx: &LateContext<'_>, expr: &Expr<'_>, is_empty_recv: &Expr<'_>) -> bool {
-    if (match_method_call(cx, expr, &paths::OPTION_UNWRAP) || match_method_call(cx, expr, &paths::OPTION_EXPECT))
-        && let ExprKind::MethodCall(_, unwrap_recv, ..) = expr.kind
-        && match_method_call(cx, unwrap_recv, &paths::VEC_POP)
-        && let ExprKind::MethodCall(_, pop_recv, ..) = unwrap_recv.kind
-    {
-        // make sure they're the same `Vec`
-        SpanlessEq::new(cx).eq_expr(pop_recv, is_empty_recv)
-    } else {
-        false
-    }
-}
-
-fn check_local(cx: &LateContext<'_>, stmt: &Stmt<'_>, is_empty_recv: &Expr<'_>, loop_span: Span) {
-    if let StmtKind::Local(local) = stmt.kind
-        && let Some(init) = local.init
-        && is_vec_pop_unwrap(cx, init, is_empty_recv)
-    {
-        report_lint(cx, stmt.span, PopStmt::Local(local.pat), loop_span, is_empty_recv.span);
-    }
-}
-
-fn check_call_arguments(cx: &LateContext<'_>, stmt: &Stmt<'_>, is_empty_recv: &Expr<'_>, loop_span: Span) {
-    if let StmtKind::Semi(expr) | StmtKind::Expr(expr) = stmt.kind {
-        if let ExprKind::MethodCall(.., args, _) | ExprKind::Call(_, args) = expr.kind {
-            let offending_arg = args
-                .iter()
-                .find_map(|arg| is_vec_pop_unwrap(cx, arg, is_empty_recv).then_some(arg.span));
-
-            if let Some(offending_arg) = offending_arg {
-                report_lint(cx, offending_arg, PopStmt::Anonymous, loop_span, is_empty_recv.span);
-            }
-        }
-    }
-}
-
-pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, full_cond: &'tcx Expr<'_>, body: &'tcx Expr<'_>, loop_span: Span) {
-    if let ExprKind::Unary(UnOp::Not, cond) = full_cond.kind
-        && let ExprKind::MethodCall(_, is_empty_recv, _, _) = cond.kind
-        && match_method_call(cx, cond, &paths::VEC_IS_EMPTY)
-        && let ExprKind::Block(body, _) = body.kind
-        && let Some(stmt) = body.stmts.first()
-    {
-        check_local(cx, stmt, is_empty_recv, loop_span);
-        check_call_arguments(cx, stmt, is_empty_recv, loop_span);
-    }
-}
diff --git a/tests/ui/manual_while_let_some.fixed b/tests/ui/manual_while_let_some.fixed
new file mode 100644
index 00000000000..75738209bad
--- /dev/null
+++ b/tests/ui/manual_while_let_some.fixed
@@ -0,0 +1,93 @@
+// run-rustfix
+
+#![allow(unused)]
+#![warn(clippy::manual_while_let_some)]
+
+struct VecInStruct {
+    numbers: Vec<i32>,
+    unrelated: String,
+}
+
+struct Foo {
+    a: i32,
+    b: i32,
+}
+
+fn accept_i32(_: i32) {}
+fn accept_optional_i32(_: Option<i32>) {}
+fn accept_i32_tuple(_: (i32, i32)) {}
+
+fn main() {
+    let mut numbers = vec![1, 2, 3, 4, 5];
+    while let Some(number) = numbers.pop() {
+        
+    }
+
+    let mut val = VecInStruct {
+        numbers: vec![1, 2, 3, 4, 5],
+        unrelated: String::new(),
+    };
+    while let Some(number) = val.numbers.pop() {
+        
+    }
+
+    while let Some(element) = numbers.pop() {
+        accept_i32(element);
+    }
+
+    while let Some(element) = numbers.pop() {
+        accept_i32(element);
+    }
+
+    // This should not warn. It "conditionally" pops elements.
+    while !numbers.is_empty() {
+        if true {
+            accept_i32(numbers.pop().unwrap());
+        }
+    }
+
+    // This should also not warn. It conditionally pops elements.
+    while !numbers.is_empty() {
+        if false {
+            continue;
+        }
+        accept_i32(numbers.pop().unwrap());
+    }
+
+    // This should not warn. It pops elements, but does not unwrap it.
+    // Might handle the Option in some other arbitrary way.
+    while !numbers.is_empty() {
+        accept_optional_i32(numbers.pop());
+    }
+
+    let unrelated_vec: Vec<String> = Vec::new();
+    // This should not warn. It pops elements from a different vector.
+    while !unrelated_vec.is_empty() {
+        accept_i32(numbers.pop().unwrap());
+    }
+
+    macro_rules! generate_loop {
+        () => {
+            while !numbers.is_empty() {
+                accept_i32(numbers.pop().unwrap());
+            }
+        };
+    }
+    // Do not warn if the loop comes from a macro.
+    generate_loop!();
+
+    // Try other kinds of patterns
+    let mut numbers = vec![(0, 0), (1, 1), (2, 2)];
+    while let Some((a, b)) = numbers.pop() {
+        
+    }
+
+    while let Some(element) = numbers.pop() {
+        accept_i32_tuple(element);
+    }
+
+    let mut results = vec![Foo { a: 1, b: 2 }, Foo { a: 3, b: 4 }];
+    while let Some(Foo { a, b }) = results.pop() {
+        
+    }
+}
diff --git a/tests/ui/manual_while_let_some.rs b/tests/ui/manual_while_let_some.rs
new file mode 100644
index 00000000000..142c1471598
--- /dev/null
+++ b/tests/ui/manual_while_let_some.rs
@@ -0,0 +1,93 @@
+// run-rustfix
+
+#![allow(unused)]
+#![warn(clippy::manual_while_let_some)]
+
+struct VecInStruct {
+    numbers: Vec<i32>,
+    unrelated: String,
+}
+
+struct Foo {
+    a: i32,
+    b: i32,
+}
+
+fn accept_i32(_: i32) {}
+fn accept_optional_i32(_: Option<i32>) {}
+fn accept_i32_tuple(_: (i32, i32)) {}
+
+fn main() {
+    let mut numbers = vec![1, 2, 3, 4, 5];
+    while !numbers.is_empty() {
+        let number = numbers.pop().unwrap();
+    }
+
+    let mut val = VecInStruct {
+        numbers: vec![1, 2, 3, 4, 5],
+        unrelated: String::new(),
+    };
+    while !val.numbers.is_empty() {
+        let number = val.numbers.pop().unwrap();
+    }
+
+    while !numbers.is_empty() {
+        accept_i32(numbers.pop().unwrap());
+    }
+
+    while !numbers.is_empty() {
+        accept_i32(numbers.pop().expect(""));
+    }
+
+    // This should not warn. It "conditionally" pops elements.
+    while !numbers.is_empty() {
+        if true {
+            accept_i32(numbers.pop().unwrap());
+        }
+    }
+
+    // This should also not warn. It conditionally pops elements.
+    while !numbers.is_empty() {
+        if false {
+            continue;
+        }
+        accept_i32(numbers.pop().unwrap());
+    }
+
+    // This should not warn. It pops elements, but does not unwrap it.
+    // Might handle the Option in some other arbitrary way.
+    while !numbers.is_empty() {
+        accept_optional_i32(numbers.pop());
+    }
+
+    let unrelated_vec: Vec<String> = Vec::new();
+    // This should not warn. It pops elements from a different vector.
+    while !unrelated_vec.is_empty() {
+        accept_i32(numbers.pop().unwrap());
+    }
+
+    macro_rules! generate_loop {
+        () => {
+            while !numbers.is_empty() {
+                accept_i32(numbers.pop().unwrap());
+            }
+        };
+    }
+    // Do not warn if the loop comes from a macro.
+    generate_loop!();
+
+    // Try other kinds of patterns
+    let mut numbers = vec![(0, 0), (1, 1), (2, 2)];
+    while !numbers.is_empty() {
+        let (a, b) = numbers.pop().unwrap();
+    }
+
+    while !numbers.is_empty() {
+        accept_i32_tuple(numbers.pop().unwrap());
+    }
+
+    let mut results = vec![Foo { a: 1, b: 2 }, Foo { a: 3, b: 4 }];
+    while !results.is_empty() {
+        let Foo { a, b } = results.pop().unwrap();
+    }
+}
diff --git a/tests/ui/manual_while_let_some.stderr b/tests/ui/manual_while_let_some.stderr
new file mode 100644
index 00000000000..633fe05c49b
--- /dev/null
+++ b/tests/ui/manual_while_let_some.stderr
@@ -0,0 +1,87 @@
+error: you seem to be trying to pop elements from a `Vec` in a loop
+  --> $DIR/manual_while_let_some.rs:23:9
+   |
+LL |         let number = numbers.pop().unwrap();
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::manual-while-let-some` implied by `-D warnings`
+help: consider using a `while..let` loop
+   |
+LL ~     while let Some(number) = numbers.pop() {
+LL ~         
+   |
+
+error: you seem to be trying to pop elements from a `Vec` in a loop
+  --> $DIR/manual_while_let_some.rs:31:9
+   |
+LL |         let number = val.numbers.pop().unwrap();
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider using a `while..let` loop
+   |
+LL ~     while let Some(number) = val.numbers.pop() {
+LL ~         
+   |
+
+error: you seem to be trying to pop elements from a `Vec` in a loop
+  --> $DIR/manual_while_let_some.rs:35:20
+   |
+LL |         accept_i32(numbers.pop().unwrap());
+   |                    ^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider using a `while..let` loop
+   |
+LL ~     while let Some(element) = numbers.pop() {
+LL ~         accept_i32(element);
+   |
+
+error: you seem to be trying to pop elements from a `Vec` in a loop
+  --> $DIR/manual_while_let_some.rs:39:20
+   |
+LL |         accept_i32(numbers.pop().expect(""));
+   |                    ^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider using a `while..let` loop
+   |
+LL ~     while let Some(element) = numbers.pop() {
+LL ~         accept_i32(element);
+   |
+
+error: you seem to be trying to pop elements from a `Vec` in a loop
+  --> $DIR/manual_while_let_some.rs:82:9
+   |
+LL |         let (a, b) = numbers.pop().unwrap();
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider using a `while..let` loop
+   |
+LL ~     while let Some((a, b)) = numbers.pop() {
+LL ~         
+   |
+
+error: you seem to be trying to pop elements from a `Vec` in a loop
+  --> $DIR/manual_while_let_some.rs:86:26
+   |
+LL |         accept_i32_tuple(numbers.pop().unwrap());
+   |                          ^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider using a `while..let` loop
+   |
+LL ~     while let Some(element) = numbers.pop() {
+LL ~         accept_i32_tuple(element);
+   |
+
+error: you seem to be trying to pop elements from a `Vec` in a loop
+  --> $DIR/manual_while_let_some.rs:91:9
+   |
+LL |         let Foo { a, b } = results.pop().unwrap();
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider using a `while..let` loop
+   |
+LL ~     while let Some(Foo { a, b }) = results.pop() {
+LL ~         
+   |
+
+error: aborting due to 7 previous errors
+
diff --git a/tests/ui/while_pop_unwrap.fixed b/tests/ui/while_pop_unwrap.fixed
deleted file mode 100644
index a635e054e6e..00000000000
--- a/tests/ui/while_pop_unwrap.fixed
+++ /dev/null
@@ -1,93 +0,0 @@
-// run-rustfix
-
-#![allow(unused)]
-#![warn(clippy::while_pop_unwrap)]
-
-struct VecInStruct {
-    numbers: Vec<i32>,
-    unrelated: String,
-}
-
-struct Foo {
-    a: i32,
-    b: i32,
-}
-
-fn accept_i32(_: i32) {}
-fn accept_optional_i32(_: Option<i32>) {}
-fn accept_i32_tuple(_: (i32, i32)) {}
-
-fn main() {
-    let mut numbers = vec![1, 2, 3, 4, 5];
-    while let Some(number) = numbers.pop() {
-        
-    }
-
-    let mut val = VecInStruct {
-        numbers: vec![1, 2, 3, 4, 5],
-        unrelated: String::new(),
-    };
-    while let Some(number) = val.numbers.pop() {
-        
-    }
-
-    while let Some(element) = numbers.pop() {
-        accept_i32(element);
-    }
-
-    while let Some(element) = numbers.pop() {
-        accept_i32(element);
-    }
-
-    // This should not warn. It "conditionally" pops elements.
-    while !numbers.is_empty() {
-        if true {
-            accept_i32(numbers.pop().unwrap());
-        }
-    }
-
-    // This should also not warn. It conditionally pops elements.
-    while !numbers.is_empty() {
-        if false {
-            continue;
-        }
-        accept_i32(numbers.pop().unwrap());
-    }
-
-    // This should not warn. It pops elements, but does not unwrap it.
-    // Might handle the Option in some other arbitrary way.
-    while !numbers.is_empty() {
-        accept_optional_i32(numbers.pop());
-    }
-
-    let unrelated_vec: Vec<String> = Vec::new();
-    // This should not warn. It pops elements from a different vector.
-    while !unrelated_vec.is_empty() {
-        accept_i32(numbers.pop().unwrap());
-    }
-
-    macro_rules! generate_loop {
-        () => {
-            while !numbers.is_empty() {
-                accept_i32(numbers.pop().unwrap());
-            }
-        };
-    }
-    // Do not warn if the loop is in a macro.
-    generate_loop!();
-
-    // Try other kinds of patterns
-    let mut numbers = vec![(0, 0), (1, 1), (2, 2)];
-    while let Some((a, b)) = numbers.pop() {
-        
-    }
-
-    while let Some(element) = numbers.pop() {
-        accept_i32_tuple(element);
-    }
-
-    let mut results = vec![Foo { a: 1, b: 2 }, Foo { a: 3, b: 4 }];
-    while let Some(Foo { a, b }) = results.pop() {
-        
-    }
-}
diff --git a/tests/ui/while_pop_unwrap.rs b/tests/ui/while_pop_unwrap.rs
deleted file mode 100644
index 820ff211086..00000000000
--- a/tests/ui/while_pop_unwrap.rs
+++ /dev/null
@@ -1,93 +0,0 @@
-// run-rustfix
-
-#![allow(unused)]
-#![warn(clippy::while_pop_unwrap)]
-
-struct VecInStruct {
-    numbers: Vec<i32>,
-    unrelated: String,
-}
-
-struct Foo {
-    a: i32,
-    b: i32,
-}
-
-fn accept_i32(_: i32) {}
-fn accept_optional_i32(_: Option<i32>) {}
-fn accept_i32_tuple(_: (i32, i32)) {}
-
-fn main() {
-    let mut numbers = vec![1, 2, 3, 4, 5];
-    while !numbers.is_empty() {
-        let number = numbers.pop().unwrap();
-    }
-
-    let mut val = VecInStruct {
-        numbers: vec![1, 2, 3, 4, 5],
-        unrelated: String::new(),
-    };
-    while !val.numbers.is_empty() {
-        let number = val.numbers.pop().unwrap();
-    }
-
-    while !numbers.is_empty() {
-        accept_i32(numbers.pop().unwrap());
-    }
-
-    while !numbers.is_empty() {
-        accept_i32(numbers.pop().expect(""));
-    }
-
-    // This should not warn. It "conditionally" pops elements.
-    while !numbers.is_empty() {
-        if true {
-            accept_i32(numbers.pop().unwrap());
-        }
-    }
-
-    // This should also not warn. It conditionally pops elements.
-    while !numbers.is_empty() {
-        if false {
-            continue;
-        }
-        accept_i32(numbers.pop().unwrap());
-    }
-
-    // This should not warn. It pops elements, but does not unwrap it.
-    // Might handle the Option in some other arbitrary way.
-    while !numbers.is_empty() {
-        accept_optional_i32(numbers.pop());
-    }
-
-    let unrelated_vec: Vec<String> = Vec::new();
-    // This should not warn. It pops elements from a different vector.
-    while !unrelated_vec.is_empty() {
-        accept_i32(numbers.pop().unwrap());
-    }
-
-    macro_rules! generate_loop {
-        () => {
-            while !numbers.is_empty() {
-                accept_i32(numbers.pop().unwrap());
-            }
-        };
-    }
-    // Do not warn if the loop is in a macro.
-    generate_loop!();
-
-    // Try other kinds of patterns
-    let mut numbers = vec![(0, 0), (1, 1), (2, 2)];
-    while !numbers.is_empty() {
-        let (a, b) = numbers.pop().unwrap();
-    }
-
-    while !numbers.is_empty() {
-        accept_i32_tuple(numbers.pop().unwrap());
-    }
-
-    let mut results = vec![Foo { a: 1, b: 2 }, Foo { a: 3, b: 4 }];
-    while !results.is_empty() {
-        let Foo { a, b } = results.pop().unwrap();
-    }
-}
diff --git a/tests/ui/while_pop_unwrap.stderr b/tests/ui/while_pop_unwrap.stderr
deleted file mode 100644
index f8a6cfcda0e..00000000000
--- a/tests/ui/while_pop_unwrap.stderr
+++ /dev/null
@@ -1,87 +0,0 @@
-error: you seem to be trying to pop elements from a `Vec` in a loop
-  --> $DIR/while_pop_unwrap.rs:23:9
-   |
-LL |         let number = numbers.pop().unwrap();
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: `-D clippy::while-pop-unwrap` implied by `-D warnings`
-help: consider using a `while..let` loop
-   |
-LL ~     while let Some(number) = numbers.pop() {
-LL ~         
-   |
-
-error: you seem to be trying to pop elements from a `Vec` in a loop
-  --> $DIR/while_pop_unwrap.rs:31:9
-   |
-LL |         let number = val.numbers.pop().unwrap();
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: consider using a `while..let` loop
-   |
-LL ~     while let Some(number) = val.numbers.pop() {
-LL ~         
-   |
-
-error: you seem to be trying to pop elements from a `Vec` in a loop
-  --> $DIR/while_pop_unwrap.rs:35:20
-   |
-LL |         accept_i32(numbers.pop().unwrap());
-   |                    ^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: consider using a `while..let` loop
-   |
-LL ~     while let Some(element) = numbers.pop() {
-LL ~         accept_i32(element);
-   |
-
-error: you seem to be trying to pop elements from a `Vec` in a loop
-  --> $DIR/while_pop_unwrap.rs:39:20
-   |
-LL |         accept_i32(numbers.pop().expect(""));
-   |                    ^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: consider using a `while..let` loop
-   |
-LL ~     while let Some(element) = numbers.pop() {
-LL ~         accept_i32(element);
-   |
-
-error: you seem to be trying to pop elements from a `Vec` in a loop
-  --> $DIR/while_pop_unwrap.rs:82:9
-   |
-LL |         let (a, b) = numbers.pop().unwrap();
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: consider using a `while..let` loop
-   |
-LL ~     while let Some((a, b)) = numbers.pop() {
-LL ~         
-   |
-
-error: you seem to be trying to pop elements from a `Vec` in a loop
-  --> $DIR/while_pop_unwrap.rs:86:26
-   |
-LL |         accept_i32_tuple(numbers.pop().unwrap());
-   |                          ^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: consider using a `while..let` loop
-   |
-LL ~     while let Some(element) = numbers.pop() {
-LL ~         accept_i32_tuple(element);
-   |
-
-error: you seem to be trying to pop elements from a `Vec` in a loop
-  --> $DIR/while_pop_unwrap.rs:91:9
-   |
-LL |         let Foo { a, b } = results.pop().unwrap();
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: consider using a `while..let` loop
-   |
-LL ~     while let Some(Foo { a, b }) = results.pop() {
-LL ~         
-   |
-
-error: aborting due to 7 previous errors
-
-- 
cgit 1.4.1-3-g733a5


From 032bc11fd482cc99fd3f85f053855b3e3e6ad18a Mon Sep 17 00:00:00 2001
From: Icxolu <10486322+Icxolu@users.noreply.github.com>
Date: Sat, 29 Apr 2023 21:11:34 +0200
Subject: fix diagnostic message style

Co-authored-by: Ruby Lazuli <general@patchmixolydic.com>
---
 clippy_lints/src/default_constructed_unit_struct.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/default_constructed_unit_struct.rs b/clippy_lints/src/default_constructed_unit_struct.rs
index a04f7b9d9a9..d518c8e7c56 100644
--- a/clippy_lints/src/default_constructed_unit_struct.rs
+++ b/clippy_lints/src/default_constructed_unit_struct.rs
@@ -55,7 +55,7 @@ impl LateLintPass<'_> for DefaultConstructedUnitStruct {
                     cx,
                     DEFAULT_CONSTRUCTED_UNIT_STRUCT,
                     qpath.last_segment_span(),
-                    "Use of `default` to create a unit struct.",
+                    "use of `default` to create a unit struct",
                     "remove this call to `default`",
                     String::new(),
                     Applicability::MachineApplicable,
-- 
cgit 1.4.1-3-g733a5


From cc607fe32ed69ac35b60e962803a2fb2133471cd Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Sun, 30 Apr 2023 01:30:15 +0200
Subject: don't remove `dbg!` in arbitrary expressions

---
 clippy_lints/src/dbg_macro.rs | 38 +++++++++++++++++++--------
 tests/ui/dbg_macro.rs         |  8 ++++++
 tests/ui/dbg_macro.stderr     | 60 +++++++++++++++++++++++++++++++++----------
 3 files changed, 82 insertions(+), 24 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/dbg_macro.rs b/clippy_lints/src/dbg_macro.rs
index 799e71e847a..cea712f2fee 100644
--- a/clippy_lints/src/dbg_macro.rs
+++ b/clippy_lints/src/dbg_macro.rs
@@ -3,10 +3,10 @@ use clippy_utils::macros::root_macro_call_first_node;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::{is_in_cfg_test, is_in_test_function};
 use rustc_errors::Applicability;
-use rustc_hir::{Expr, ExprKind};
-use rustc_lint::{LateContext, LateLintPass};
+use rustc_hir::{Expr, ExprKind, Node, Stmt, StmtKind};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::sym;
+use rustc_span::{sym, Span};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -31,6 +31,11 @@ declare_clippy_lint! {
     "`dbg!` macro is intended as a debugging tool"
 }
 
+fn span_including_semi(cx: &LateContext<'_>, span: Span) -> Span {
+    let span = cx.sess().source_map().span_extend_to_next_char(span, ';', true);
+    span.with_hi(span.hi() + rustc_span::BytePos(1))
+}
+
 #[derive(Copy, Clone)]
 pub struct DbgMacro {
     allow_dbg_in_tests: bool,
@@ -55,13 +60,24 @@ impl LateLintPass<'_> for DbgMacro {
                 return;
             }
             let mut applicability = Applicability::MachineApplicable;
-            let suggestion = match expr.peel_drop_temps().kind {
-                // dbg!()
-                ExprKind::Block(_, _) => String::new(),
-                // dbg!(1)
-                ExprKind::Match(val, ..) => {
-                    snippet_with_applicability(cx, val.span.source_callsite(), "..", &mut applicability).to_string()
+
+            let (sugg_span, suggestion) = match expr.peel_drop_temps().kind {
+                ExprKind::Block(..) => match cx.tcx.hir().find_parent(expr.hir_id) {
+                    // dbg!() as a standalone statement, suggest removing the whole statement entirely
+                    Some(Node::Stmt(
+                        stmt @ Stmt {
+                            kind: StmtKind::Semi(_),
+                            ..
+                        },
+                    )) => (span_including_semi(cx, stmt.span.source_callsite()), String::new()),
+                    // empty dbg!() in arbitrary position (e.g. `foo(dbg!())`), suggest replacing with `foo(())`
+                    _ => (macro_call.span, String::from("()")),
                 },
+                // dbg!(1)
+                ExprKind::Match(val, ..) => (
+                    macro_call.span,
+                    snippet_with_applicability(cx, val.span.source_callsite(), "..", &mut applicability).to_string(),
+                ),
                 // dbg!(2, 3)
                 ExprKind::Tup(
                     [
@@ -82,7 +98,7 @@ impl LateLintPass<'_> for DbgMacro {
                         "..",
                         &mut applicability,
                     );
-                    format!("({snippet})")
+                    (macro_call.span, format!("({snippet})"))
                 },
                 _ => return,
             };
@@ -90,7 +106,7 @@ impl LateLintPass<'_> for DbgMacro {
             span_lint_and_sugg(
                 cx,
                 DBG_MACRO,
-                macro_call.span,
+                sugg_span,
                 "the `dbg!` macro is intended as a debugging tool",
                 "remove the invocation before committing it to a version control system",
                 suggestion,
diff --git a/tests/ui/dbg_macro.rs b/tests/ui/dbg_macro.rs
index 8701e3cd29f..ae2075e7dad 100644
--- a/tests/ui/dbg_macro.rs
+++ b/tests/ui/dbg_macro.rs
@@ -4,6 +4,7 @@
 fn foo(n: u32) -> u32 {
     if let Some(n) = dbg!(n.checked_sub(4)) { n } else { n }
 }
+fn bar(_: ()) {}
 
 fn factorial(n: u32) -> u32 {
     if dbg!(n <= 1) {
@@ -21,6 +22,13 @@ fn main() {
     dbg!(1, 2, 3, 4, 5);
 }
 
+fn issue9914() {
+    dbg!();
+    #[allow(clippy::let_unit_value)]
+    let _ = dbg!();
+    bar(dbg!());
+}
+
 mod issue7274 {
     trait Thing<'b> {
         fn foo(&self);
diff --git a/tests/ui/dbg_macro.stderr b/tests/ui/dbg_macro.stderr
index ddb5f1342e9..34329a06b97 100644
--- a/tests/ui/dbg_macro.stderr
+++ b/tests/ui/dbg_macro.stderr
@@ -11,7 +11,7 @@ LL |     if let Some(n) = n.checked_sub(4) { n } else { n }
    |                      ~~~~~~~~~~~~~~~~
 
 error: the `dbg!` macro is intended as a debugging tool
-  --> $DIR/dbg_macro.rs:9:8
+  --> $DIR/dbg_macro.rs:10:8
    |
 LL |     if dbg!(n <= 1) {
    |        ^^^^^^^^^^^^
@@ -22,7 +22,7 @@ LL |     if n <= 1 {
    |        ~~~~~~
 
 error: the `dbg!` macro is intended as a debugging tool
-  --> $DIR/dbg_macro.rs:10:9
+  --> $DIR/dbg_macro.rs:11:9
    |
 LL |         dbg!(1)
    |         ^^^^^^^
@@ -33,7 +33,7 @@ LL |         1
    |
 
 error: the `dbg!` macro is intended as a debugging tool
-  --> $DIR/dbg_macro.rs:12:9
+  --> $DIR/dbg_macro.rs:13:9
    |
 LL |         dbg!(n * factorial(n - 1))
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -44,7 +44,7 @@ LL |         n * factorial(n - 1)
    |
 
 error: the `dbg!` macro is intended as a debugging tool
-  --> $DIR/dbg_macro.rs:17:5
+  --> $DIR/dbg_macro.rs:18:5
    |
 LL |     dbg!(42);
    |     ^^^^^^^^
@@ -55,7 +55,7 @@ LL |     42;
    |     ~~
 
 error: the `dbg!` macro is intended as a debugging tool
-  --> $DIR/dbg_macro.rs:18:5
+  --> $DIR/dbg_macro.rs:19:5
    |
 LL |     dbg!(dbg!(dbg!(42)));
    |     ^^^^^^^^^^^^^^^^^^^^
@@ -66,7 +66,7 @@ LL |     dbg!(dbg!(42));
    |     ~~~~~~~~~~~~~~
 
 error: the `dbg!` macro is intended as a debugging tool
-  --> $DIR/dbg_macro.rs:19:14
+  --> $DIR/dbg_macro.rs:20:14
    |
 LL |     foo(3) + dbg!(factorial(4));
    |              ^^^^^^^^^^^^^^^^^^
@@ -77,7 +77,7 @@ LL |     foo(3) + factorial(4);
    |              ~~~~~~~~~~~~
 
 error: the `dbg!` macro is intended as a debugging tool
-  --> $DIR/dbg_macro.rs:20:5
+  --> $DIR/dbg_macro.rs:21:5
    |
 LL |     dbg!(1, 2, dbg!(3, 4));
    |     ^^^^^^^^^^^^^^^^^^^^^^
@@ -88,7 +88,7 @@ LL |     (1, 2, dbg!(3, 4));
    |     ~~~~~~~~~~~~~~~~~~
 
 error: the `dbg!` macro is intended as a debugging tool
-  --> $DIR/dbg_macro.rs:21:5
+  --> $DIR/dbg_macro.rs:22:5
    |
 LL |     dbg!(1, 2, 3, 4, 5);
    |     ^^^^^^^^^^^^^^^^^^^
@@ -99,7 +99,41 @@ LL |     (1, 2, 3, 4, 5);
    |     ~~~~~~~~~~~~~~~
 
 error: the `dbg!` macro is intended as a debugging tool
-  --> $DIR/dbg_macro.rs:41:9
+  --> $DIR/dbg_macro.rs:26:5
+   |
+LL |     dbg!();
+   |     ^^^^^^^
+   |
+help: remove the invocation before committing it to a version control system
+   |
+LL -     dbg!();
+LL +     
+   |
+
+error: the `dbg!` macro is intended as a debugging tool
+  --> $DIR/dbg_macro.rs:28:13
+   |
+LL |     let _ = dbg!();
+   |             ^^^^^^
+   |
+help: remove the invocation before committing it to a version control system
+   |
+LL |     let _ = ();
+   |             ~~
+
+error: the `dbg!` macro is intended as a debugging tool
+  --> $DIR/dbg_macro.rs:29:9
+   |
+LL |     bar(dbg!());
+   |         ^^^^^^
+   |
+help: remove the invocation before committing it to a version control system
+   |
+LL |     bar(());
+   |         ~~
+
+error: the `dbg!` macro is intended as a debugging tool
+  --> $DIR/dbg_macro.rs:49:9
    |
 LL |         dbg!(2);
    |         ^^^^^^^
@@ -110,7 +144,7 @@ LL |         2;
    |         ~
 
 error: the `dbg!` macro is intended as a debugging tool
-  --> $DIR/dbg_macro.rs:47:5
+  --> $DIR/dbg_macro.rs:55:5
    |
 LL |     dbg!(1);
    |     ^^^^^^^
@@ -121,7 +155,7 @@ LL |     1;
    |     ~
 
 error: the `dbg!` macro is intended as a debugging tool
-  --> $DIR/dbg_macro.rs:52:5
+  --> $DIR/dbg_macro.rs:60:5
    |
 LL |     dbg!(1);
    |     ^^^^^^^
@@ -132,7 +166,7 @@ LL |     1;
    |     ~
 
 error: the `dbg!` macro is intended as a debugging tool
-  --> $DIR/dbg_macro.rs:58:9
+  --> $DIR/dbg_macro.rs:66:9
    |
 LL |         dbg!(1);
    |         ^^^^^^^
@@ -142,5 +176,5 @@ help: remove the invocation before committing it to a version control system
 LL |         1;
    |         ~
 
-error: aborting due to 13 previous errors
+error: aborting due to 16 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 478555d468d54105a0202220b7632b08a992b9be Mon Sep 17 00:00:00 2001
From: John Kelly <johnharrykelly@gmail.com>
Date: Sun, 30 Apr 2023 13:16:04 +0100
Subject: wip

---
 clippy_lints/src/trait_bounds.rs        | 45 ++++++++++++++++++++++++++++++---
 tests/ui/trait_duplication_in_bounds.rs |  8 ++++++
 2 files changed, 50 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/trait_bounds.rs b/clippy_lints/src/trait_bounds.rs
index b5f11b4acae..13651c978e9 100644
--- a/clippy_lints/src/trait_bounds.rs
+++ b/clippy_lints/src/trait_bounds.rs
@@ -9,7 +9,7 @@ use rustc_data_structures::unhash::UnhashMap;
 use rustc_errors::Applicability;
 use rustc_hir::def::Res;
 use rustc_hir::{
-    GenericArg, GenericBound, Generics, Item, ItemKind, Node, Path, PathSegment, PredicateOrigin, QPath,
+    GenericArg, GenericBound, Generics, Item, ItemKind, MutTy, Node, Path, PathSegment, PredicateOrigin, QPath,
     TraitBoundModifier, TraitItem, TraitRef, Ty, TyKind, WherePredicate,
 };
 use rustc_lint::{LateContext, LateLintPass};
@@ -37,12 +37,12 @@ declare_clippy_lint! {
     #[clippy::version = "1.38.0"]
     pub TYPE_REPETITION_IN_BOUNDS,
     nursery,
-    "types are repeated unnecessary in trait bounds use `+` instead of using `T: _, T: _`"
+    "types are repeated unnecessarily in trait bounds, use `+` instead of using `T: _, T: _`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for cases where generics are being used and multiple
+    /// Checks for cases where generics or trait objects are being used and multiple
     /// syntax specifications for trait bounds are used simultaneously.
     ///
     /// ### Why is this bad?
@@ -167,6 +167,45 @@ impl<'tcx> LateLintPass<'tcx> for TraitBounds {
             }
         }
     }
+
+    fn check_ty(&mut self, cx: &LateContext<'tcx>, ty: &'tcx Ty<'tcx>) {
+        let TyKind::Ref(
+            ..,
+            MutTy {
+                ty: Ty {
+                    kind: TyKind::TraitObject(
+                        bounds,
+                        ..
+                    ),
+                    ..
+                },
+                ..
+            }
+        ) = ty.kind else { return; };
+
+        if bounds.len() < 2 {
+            return;
+        }
+
+        let mut seen_def_ids = FxHashSet::default();
+
+        for bound in bounds.iter() {
+            let Some(def_id) = bound.trait_ref.trait_def_id() else { continue; };
+
+            let already_seen = !seen_def_ids.insert(def_id);
+
+            if already_seen {
+                span_lint_and_help(
+                    cx,
+                    TRAIT_DUPLICATION_IN_BOUNDS,
+                    bound.span,
+                    "this trait bound is already specified in trait declaration",
+                    None,
+                    "consider removing this trait bound",
+                );
+            }
+        }
+    }
 }
 
 impl TraitBounds {
diff --git a/tests/ui/trait_duplication_in_bounds.rs b/tests/ui/trait_duplication_in_bounds.rs
index a7a1caf2880..f4f4a9fcb08 100644
--- a/tests/ui/trait_duplication_in_bounds.rs
+++ b/tests/ui/trait_duplication_in_bounds.rs
@@ -109,4 +109,12 @@ fn qualified_path<T: std::clone::Clone + Clone + foo::Clone>(arg0: T) {
     unimplemented!();
 }
 
+fn good_trait_object(arg0: &(dyn Any + Send)) {
+    unimplemented!();
+}
+
+fn bad_trait_object(arg0: &(dyn Any + Send + Send)) {
+    unimplemented!();
+}
+
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 1eff408ca44ae15ffd6592714487f168a5549bcc Mon Sep 17 00:00:00 2001
From: John Kelly <johnharrykelly@gmail.com>
Date: Sun, 30 Apr 2023 13:45:45 +0100
Subject: WIP

---
 clippy_lints/src/trait_bounds.rs            |  5 +++--
 tests/ui/trait_duplication_in_bounds.fixed  | 10 ++++++++++
 tests/ui/trait_duplication_in_bounds.rs     |  2 ++
 tests/ui/trait_duplication_in_bounds.stderr | 25 ++++++++++++++++---------
 4 files changed, 31 insertions(+), 11 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/trait_bounds.rs b/clippy_lints/src/trait_bounds.rs
index 13651c978e9..1af2c594243 100644
--- a/clippy_lints/src/trait_bounds.rs
+++ b/clippy_lints/src/trait_bounds.rs
@@ -195,13 +195,14 @@ impl<'tcx> LateLintPass<'tcx> for TraitBounds {
             let already_seen = !seen_def_ids.insert(def_id);
 
             if already_seen {
-                span_lint_and_help(
+                span_lint_and_sugg(
                     cx,
                     TRAIT_DUPLICATION_IN_BOUNDS,
                     bound.span,
                     "this trait bound is already specified in trait declaration",
-                    None,
                     "consider removing this trait bound",
+                    "".to_string(),
+                    Applicability::MaybeIncorrect,
                 );
             }
         }
diff --git a/tests/ui/trait_duplication_in_bounds.fixed b/tests/ui/trait_duplication_in_bounds.fixed
index eef8024b131..fdac0e4cb1e 100644
--- a/tests/ui/trait_duplication_in_bounds.fixed
+++ b/tests/ui/trait_duplication_in_bounds.fixed
@@ -2,6 +2,8 @@
 #![deny(clippy::trait_duplication_in_bounds)]
 #![allow(unused)]
 
+use std::any::Any;
+
 fn bad_foo<T: Clone + Copy, U: Clone + Copy>(arg0: T, argo1: U) {
     unimplemented!();
 }
@@ -109,4 +111,12 @@ fn qualified_path<T: std::clone::Clone + foo::Clone>(arg0: T) {
     unimplemented!();
 }
 
+fn good_trait_object(arg0: &(dyn Any + Send)) {
+    unimplemented!();
+}
+
+fn bad_trait_object(arg0: &(dyn Any + Send)) {
+    unimplemented!();
+}
+
 fn main() {}
diff --git a/tests/ui/trait_duplication_in_bounds.rs b/tests/ui/trait_duplication_in_bounds.rs
index f4f4a9fcb08..a0300da5555 100644
--- a/tests/ui/trait_duplication_in_bounds.rs
+++ b/tests/ui/trait_duplication_in_bounds.rs
@@ -2,6 +2,8 @@
 #![deny(clippy::trait_duplication_in_bounds)]
 #![allow(unused)]
 
+use std::any::Any;
+
 fn bad_foo<T: Clone + Clone + Clone + Copy, U: Clone + Copy>(arg0: T, argo1: U) {
     unimplemented!();
 }
diff --git a/tests/ui/trait_duplication_in_bounds.stderr b/tests/ui/trait_duplication_in_bounds.stderr
index af800ba7888..a6508eb86f3 100644
--- a/tests/ui/trait_duplication_in_bounds.stderr
+++ b/tests/ui/trait_duplication_in_bounds.stderr
@@ -1,5 +1,5 @@
 error: these bounds contain repeated elements
-  --> $DIR/trait_duplication_in_bounds.rs:5:15
+  --> $DIR/trait_duplication_in_bounds.rs:7:15
    |
 LL | fn bad_foo<T: Clone + Clone + Clone + Copy, U: Clone + Copy>(arg0: T, argo1: U) {
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Clone + Copy`
@@ -11,46 +11,53 @@ LL | #![deny(clippy::trait_duplication_in_bounds)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: these where clauses contain repeated elements
-  --> $DIR/trait_duplication_in_bounds.rs:11:8
+  --> $DIR/trait_duplication_in_bounds.rs:13:8
    |
 LL |     T: Clone + Clone + Clone + Copy,
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Clone + Copy`
 
 error: these bounds contain repeated elements
-  --> $DIR/trait_duplication_in_bounds.rs:39:26
+  --> $DIR/trait_duplication_in_bounds.rs:41:26
    |
 LL | trait BadSelfTraitBound: Clone + Clone + Clone {
    |                          ^^^^^^^^^^^^^^^^^^^^^ help: try: `Clone`
 
 error: these where clauses contain repeated elements
-  --> $DIR/trait_duplication_in_bounds.rs:46:15
+  --> $DIR/trait_duplication_in_bounds.rs:48:15
    |
 LL |         Self: Clone + Clone + Clone;
    |               ^^^^^^^^^^^^^^^^^^^^^ help: try: `Clone`
 
 error: these bounds contain repeated elements
-  --> $DIR/trait_duplication_in_bounds.rs:60:24
+  --> $DIR/trait_duplication_in_bounds.rs:62:24
    |
 LL | trait BadTraitBound<T: Clone + Clone + Clone + Copy, U: Clone + Copy> {
    |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Clone + Copy`
 
 error: these where clauses contain repeated elements
-  --> $DIR/trait_duplication_in_bounds.rs:67:12
+  --> $DIR/trait_duplication_in_bounds.rs:69:12
    |
 LL |         T: Clone + Clone + Clone + Copy,
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Clone + Copy`
 
 error: these bounds contain repeated elements
-  --> $DIR/trait_duplication_in_bounds.rs:100:19
+  --> $DIR/trait_duplication_in_bounds.rs:102:19
    |
 LL | fn bad_generic<T: GenericTrait<u64> + GenericTrait<u32> + GenericTrait<u64>>(arg0: T) {
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `GenericTrait<u64> + GenericTrait<u32>`
 
 error: these bounds contain repeated elements
-  --> $DIR/trait_duplication_in_bounds.rs:108:22
+  --> $DIR/trait_duplication_in_bounds.rs:110:22
    |
 LL | fn qualified_path<T: std::clone::Clone + Clone + foo::Clone>(arg0: T) {
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::clone::Clone + foo::Clone`
 
-error: aborting due to 8 previous errors
+error: this trait bound is already specified in trait declaration
+  --> $DIR/trait_duplication_in_bounds.rs:118:46
+   |
+LL | fn bad_trait_object(arg0: &(dyn Any + Send + Send)) {
+   |                                              ^^^^ help: consider removing this trait bound
+   |
+
+error: aborting due to 9 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 0fb3f3b25667c2e9c56a7fd83019cafec7ada1cf Mon Sep 17 00:00:00 2001
From: John Kelly <johnharrykelly@gmail.com>
Date: Sun, 30 Apr 2023 14:10:26 +0100
Subject: WIP

---
 clippy_lints/src/trait_bounds.rs | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/trait_bounds.rs b/clippy_lints/src/trait_bounds.rs
index 1af2c594243..4c70bae7529 100644
--- a/clippy_lints/src/trait_bounds.rs
+++ b/clippy_lints/src/trait_bounds.rs
@@ -177,6 +177,7 @@ impl<'tcx> LateLintPass<'tcx> for TraitBounds {
                         bounds,
                         ..
                     ),
+                    span,
                     ..
                 },
                 ..
@@ -189,6 +190,12 @@ impl<'tcx> LateLintPass<'tcx> for TraitBounds {
 
         let mut seen_def_ids = FxHashSet::default();
 
+        let traits = bounds
+            .iter()
+            .filter_map(|b| snippet_opt(cx, b.span))
+            .collect::<Vec<_>>();
+        let traits = traits.join(" + ");
+
         for bound in bounds.iter() {
             let Some(def_id) = bound.trait_ref.trait_def_id() else { continue; };
 
@@ -198,10 +205,10 @@ impl<'tcx> LateLintPass<'tcx> for TraitBounds {
                 span_lint_and_sugg(
                     cx,
                     TRAIT_DUPLICATION_IN_BOUNDS,
-                    bound.span,
+                    *span,
                     "this trait bound is already specified in trait declaration",
                     "consider removing this trait bound",
-                    "".to_string(),
+                    traits.clone(),
                     Applicability::MaybeIncorrect,
                 );
             }
-- 
cgit 1.4.1-3-g733a5


From 8db21e9a9c63496271b5db11af665ada036fac4d Mon Sep 17 00:00:00 2001
From: John Kelly <johnharrykelly@gmail.com>
Date: Sun, 30 Apr 2023 14:14:47 +0100
Subject: WIP

---
 clippy_lints/src/trait_bounds.rs | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/trait_bounds.rs b/clippy_lints/src/trait_bounds.rs
index 4c70bae7529..2c1c63e808b 100644
--- a/clippy_lints/src/trait_bounds.rs
+++ b/clippy_lints/src/trait_bounds.rs
@@ -177,7 +177,6 @@ impl<'tcx> LateLintPass<'tcx> for TraitBounds {
                         bounds,
                         ..
                     ),
-                    span,
                     ..
                 },
                 ..
@@ -188,6 +187,12 @@ impl<'tcx> LateLintPass<'tcx> for TraitBounds {
             return;
         }
 
+        let mut bounds_span = Span::default();
+
+        for bound in bounds.iter() {
+            bounds_span = bounds_span.to(bound.span);
+        }
+
         let mut seen_def_ids = FxHashSet::default();
 
         let traits = bounds
@@ -205,7 +210,7 @@ impl<'tcx> LateLintPass<'tcx> for TraitBounds {
                 span_lint_and_sugg(
                     cx,
                     TRAIT_DUPLICATION_IN_BOUNDS,
-                    *span,
+                    bounds_span,
                     "this trait bound is already specified in trait declaration",
                     "consider removing this trait bound",
                     traits.clone(),
-- 
cgit 1.4.1-3-g733a5


From b9788fef298815c2b8366a42ef0c8113170d11ed Mon Sep 17 00:00:00 2001
From: John Kelly <johnharrykelly@gmail.com>
Date: Sun, 30 Apr 2023 14:34:46 +0100
Subject: Working

---
 clippy_lints/src/trait_bounds.rs            | 45 ++++++++++++++++-------------
 tests/ui/trait_duplication_in_bounds.stderr |  5 ++--
 2 files changed, 27 insertions(+), 23 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/trait_bounds.rs b/clippy_lints/src/trait_bounds.rs
index 2c1c63e808b..8de0f92109b 100644
--- a/clippy_lints/src/trait_bounds.rs
+++ b/clippy_lints/src/trait_bounds.rs
@@ -187,37 +187,42 @@ impl<'tcx> LateLintPass<'tcx> for TraitBounds {
             return;
         }
 
-        let mut bounds_span = Span::default();
+        let mut bounds_span = bounds[0].span;
 
-        for bound in bounds.iter() {
+        for bound in bounds.iter().skip(1) {
             bounds_span = bounds_span.to(bound.span);
         }
 
         let mut seen_def_ids = FxHashSet::default();
-
-        let traits = bounds
-            .iter()
-            .filter_map(|b| snippet_opt(cx, b.span))
-            .collect::<Vec<_>>();
-        let traits = traits.join(" + ");
+        let mut fixed_traits = Vec::new();
 
         for bound in bounds.iter() {
             let Some(def_id) = bound.trait_ref.trait_def_id() else { continue; };
 
-            let already_seen = !seen_def_ids.insert(def_id);
-
-            if already_seen {
-                span_lint_and_sugg(
-                    cx,
-                    TRAIT_DUPLICATION_IN_BOUNDS,
-                    bounds_span,
-                    "this trait bound is already specified in trait declaration",
-                    "consider removing this trait bound",
-                    traits.clone(),
-                    Applicability::MaybeIncorrect,
-                );
+            let new_trait = seen_def_ids.insert(def_id);
+
+            if new_trait {
+                fixed_traits.push(bound);
             }
         }
+
+        let fixed_trait_snippet = fixed_traits
+            .iter()
+            .filter_map(|b| snippet_opt(cx, b.span))
+            .collect::<Vec<_>>()
+            .join(" + ");
+
+        if bounds.len() != fixed_traits.len() {
+            span_lint_and_sugg(
+                cx,
+                TRAIT_DUPLICATION_IN_BOUNDS,
+                bounds_span,
+                "this trait bound is already specified in trait declaration",
+                "try",
+                fixed_trait_snippet,
+                Applicability::MaybeIncorrect,
+            );
+        }
     }
 }
 
diff --git a/tests/ui/trait_duplication_in_bounds.stderr b/tests/ui/trait_duplication_in_bounds.stderr
index a6508eb86f3..539b6114ca3 100644
--- a/tests/ui/trait_duplication_in_bounds.stderr
+++ b/tests/ui/trait_duplication_in_bounds.stderr
@@ -53,11 +53,10 @@ LL | fn qualified_path<T: std::clone::Clone + Clone + foo::Clone>(arg0: T) {
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::clone::Clone + foo::Clone`
 
 error: this trait bound is already specified in trait declaration
-  --> $DIR/trait_duplication_in_bounds.rs:118:46
+  --> $DIR/trait_duplication_in_bounds.rs:118:33
    |
 LL | fn bad_trait_object(arg0: &(dyn Any + Send + Send)) {
-   |                                              ^^^^ help: consider removing this trait bound
-   |
+   |                                 ^^^^^^^^^^^^^^^^^ help: try: `Any + Send`
 
 error: aborting due to 9 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 57490542419e50a22eca2b4aa79e2a64ad39c4cd Mon Sep 17 00:00:00 2001
From: blyxyas <blyxyas@gmail.com>
Date: Mon, 1 May 2023 12:39:20 +0200
Subject: globally ignore `#[no_std]` crates

---
 clippy_lints/src/floating_point_arithmetic.rs | 10 ++--------
 1 file changed, 2 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/floating_point_arithmetic.rs b/clippy_lints/src/floating_point_arithmetic.rs
index da3d0da994c..e221905580c 100644
--- a/clippy_lints/src/floating_point_arithmetic.rs
+++ b/clippy_lints/src/floating_point_arithmetic.rs
@@ -453,9 +453,6 @@ fn is_float_mul_expr<'a>(cx: &LateContext<'_>, expr: &'a Expr<'a>) -> Option<(&'
 
 // TODO: Fix rust-lang/rust-clippy#4735
 fn check_mul_add(cx: &LateContext<'_>, expr: &Expr<'_>) {
-    if is_no_std_crate(cx) {
-        return; // The suggested methods are not available in core
-    }
     if let ExprKind::Binary(
         Spanned {
             node: op @ (BinOpKind::Add | BinOpKind::Sub),
@@ -570,9 +567,6 @@ fn are_negated<'a>(cx: &LateContext<'_>, expr1: &'a Expr<'a>, expr2: &'a Expr<'a
 }
 
 fn check_custom_abs(cx: &LateContext<'_>, expr: &Expr<'_>) {
-    if is_no_std_crate(cx) {
-        return; // The suggested methods are not available in core
-    }
     if_chain! {
         if let Some(higher::If { cond, then, r#else: Some(r#else) }) = higher::If::hir(expr);
         let if_body_expr = peel_blocks(then);
@@ -737,8 +731,8 @@ fn check_radians(cx: &LateContext<'_>, expr: &Expr<'_>) {
 
 impl<'tcx> LateLintPass<'tcx> for FloatingPointArithmetic {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        // All of these operations are currently not const.
-        if in_constant(cx, expr.hir_id) {
+        // All of these operations are currently not const and are in std.
+        if in_constant(cx, expr.hir_id) || is_no_std_crate(cx) {
             return;
         }
 
-- 
cgit 1.4.1-3-g733a5


From 220a9db64215df07f730cd01322a0c8b658629cd Mon Sep 17 00:00:00 2001
From: Icxolu <10486322+Icxolu@users.noreply.github.com>
Date: Mon, 1 May 2023 20:12:34 +0200
Subject: fixed span and corrected test output

---
 .../src/default_constructed_unit_struct.rs         |  2 +-
 tests/ui/default_constructed_unit_struct.stderr    | 24 +++++++++++-----------
 2 files changed, 13 insertions(+), 13 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/default_constructed_unit_struct.rs b/clippy_lints/src/default_constructed_unit_struct.rs
index d518c8e7c56..d261cdd44a5 100644
--- a/clippy_lints/src/default_constructed_unit_struct.rs
+++ b/clippy_lints/src/default_constructed_unit_struct.rs
@@ -54,7 +54,7 @@ impl LateLintPass<'_> for DefaultConstructedUnitStruct {
                 span_lint_and_sugg(
                     cx,
                     DEFAULT_CONSTRUCTED_UNIT_STRUCT,
-                    qpath.last_segment_span(),
+                    expr.span.with_lo(qpath.qself_span().hi()),
                     "use of `default` to create a unit struct",
                     "remove this call to `default`",
                     String::new(),
diff --git a/tests/ui/default_constructed_unit_struct.stderr b/tests/ui/default_constructed_unit_struct.stderr
index 13439414f4a..952d4019644 100644
--- a/tests/ui/default_constructed_unit_struct.stderr
+++ b/tests/ui/default_constructed_unit_struct.stderr
@@ -1,28 +1,28 @@
-error: Use of `default` to create a unit struct.
-  --> $DIR/default_constructed_unit_struct.rs:39:33
+error: use of `default` to create a unit struct
+  --> $DIR/default_constructed_unit_struct.rs:39:31
    |
 LL |             inner: PhantomData::default(),
-   |                                 ^^^^^^^ help: remove this call to `default`
+   |                               ^^^^^^^^^^^ help: remove this call to `default`
    |
    = note: `-D clippy::default-constructed-unit-struct` implied by `-D warnings`
 
-error: Use of `default` to create a unit struct.
-  --> $DIR/default_constructed_unit_struct.rs:62:35
+error: use of `default` to create a unit struct
+  --> $DIR/default_constructed_unit_struct.rs:62:33
    |
 LL |     let _ = PhantomData::<usize>::default();
-   |                                   ^^^^^^^ help: remove this call to `default`
+   |                                 ^^^^^^^^^^^ help: remove this call to `default`
 
-error: Use of `default` to create a unit struct.
-  --> $DIR/default_constructed_unit_struct.rs:63:44
+error: use of `default` to create a unit struct
+  --> $DIR/default_constructed_unit_struct.rs:63:42
    |
 LL |     let _: PhantomData<i32> = PhantomData::default();
-   |                                            ^^^^^^^ help: remove this call to `default`
+   |                                          ^^^^^^^^^^^ help: remove this call to `default`
 
-error: Use of `default` to create a unit struct.
-  --> $DIR/default_constructed_unit_struct.rs:64:25
+error: use of `default` to create a unit struct
+  --> $DIR/default_constructed_unit_struct.rs:64:23
    |
 LL |     let _ = UnitStruct::default();
-   |                         ^^^^^^^ help: remove this call to `default`
+   |                       ^^^^^^^^^^^ help: remove this call to `default`
 
 error: aborting due to 4 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From cbd0135bd2d2e546ca4c2c2147798d1f7c547128 Mon Sep 17 00:00:00 2001
From: John Kelly <johnharrykelly@gmail.com>
Date: Tue, 2 May 2023 18:15:02 +0100
Subject: Update trait_bounds.rs

---
 clippy_lints/src/trait_bounds.rs | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/trait_bounds.rs b/clippy_lints/src/trait_bounds.rs
index 8de0f92109b..ac61fb157b4 100644
--- a/clippy_lints/src/trait_bounds.rs
+++ b/clippy_lints/src/trait_bounds.rs
@@ -206,13 +206,13 @@ impl<'tcx> LateLintPass<'tcx> for TraitBounds {
             }
         }
 
-        let fixed_trait_snippet = fixed_traits
-            .iter()
-            .filter_map(|b| snippet_opt(cx, b.span))
-            .collect::<Vec<_>>()
-            .join(" + ");
-
         if bounds.len() != fixed_traits.len() {
+            let fixed_trait_snippet = fixed_traits
+                .iter()
+                .filter_map(|b| snippet_opt(cx, b.span))
+                .collect::<Vec<_>>()
+                .join(" + ");
+
             span_lint_and_sugg(
                 cx,
                 TRAIT_DUPLICATION_IN_BOUNDS,
-- 
cgit 1.4.1-3-g733a5


From 122793b4947c2691efcb2ab6450c251a25311aaf Mon Sep 17 00:00:00 2001
From: John Kelly <johnharrykelly@gmail.com>
Date: Tue, 2 May 2023 18:21:23 +0100
Subject: Update trait_bounds.rs

---
 clippy_lints/src/trait_bounds.rs | 81 +++++++++++++++++-----------------------
 1 file changed, 35 insertions(+), 46 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/trait_bounds.rs b/clippy_lints/src/trait_bounds.rs
index ac61fb157b4..5acd44dccaf 100644
--- a/clippy_lints/src/trait_bounds.rs
+++ b/clippy_lints/src/trait_bounds.rs
@@ -9,7 +9,7 @@ use rustc_data_structures::unhash::UnhashMap;
 use rustc_errors::Applicability;
 use rustc_hir::def::Res;
 use rustc_hir::{
-    GenericArg, GenericBound, Generics, Item, ItemKind, MutTy, Node, Path, PathSegment, PredicateOrigin, QPath,
+    GenericArg, GenericBound, Generics, Item, ItemKind, Node, Path, PathSegment, PredicateOrigin, QPath,
     TraitBoundModifier, TraitItem, TraitRef, Ty, TyKind, WherePredicate,
 };
 use rustc_lint::{LateContext, LateLintPass};
@@ -169,60 +169,49 @@ impl<'tcx> LateLintPass<'tcx> for TraitBounds {
     }
 
     fn check_ty(&mut self, cx: &LateContext<'tcx>, ty: &'tcx Ty<'tcx>) {
-        let TyKind::Ref(
-            ..,
-            MutTy {
-                ty: Ty {
-                    kind: TyKind::TraitObject(
-                        bounds,
-                        ..
-                    ),
-                    ..
-                },
-                ..
-            }
-        ) = ty.kind else { return; };
+        if_chain! {
+            if let TyKind::Ref(.., mut_ty) = &ty.kind;
+            if let TyKind::TraitObject(bounds, ..) = mut_ty.ty.kind;
+            if bounds.len() > 2;
+            then {
+                let mut bounds_span = bounds[0].span;
 
-        if bounds.len() < 2 {
-            return;
-        }
+                for bound in bounds.iter().skip(1) {
+                    bounds_span = bounds_span.to(bound.span);
+                }
 
-        let mut bounds_span = bounds[0].span;
+                let mut seen_def_ids = FxHashSet::default();
+                let mut fixed_traits = Vec::new();
 
-        for bound in bounds.iter().skip(1) {
-            bounds_span = bounds_span.to(bound.span);
-        }
+                for bound in bounds.iter() {
+                    let Some(def_id) = bound.trait_ref.trait_def_id() else { continue; };
 
-        let mut seen_def_ids = FxHashSet::default();
-        let mut fixed_traits = Vec::new();
+                    let new_trait = seen_def_ids.insert(def_id);
 
-        for bound in bounds.iter() {
-            let Some(def_id) = bound.trait_ref.trait_def_id() else { continue; };
+                    if new_trait {
+                        fixed_traits.push(bound);
+                    }
+                }
 
-            let new_trait = seen_def_ids.insert(def_id);
+                if bounds.len() != fixed_traits.len() {
+                    let fixed_trait_snippet = fixed_traits
+                        .iter()
+                        .filter_map(|b| snippet_opt(cx, b.span))
+                        .collect::<Vec<_>>()
+                        .join(" + ");
 
-            if new_trait {
-                fixed_traits.push(bound);
+                    span_lint_and_sugg(
+                        cx,
+                        TRAIT_DUPLICATION_IN_BOUNDS,
+                        bounds_span,
+                        "this trait bound is already specified in trait declaration",
+                        "try",
+                        fixed_trait_snippet,
+                        Applicability::MaybeIncorrect,
+                    );
+                }
             }
         }
-
-        if bounds.len() != fixed_traits.len() {
-            let fixed_trait_snippet = fixed_traits
-                .iter()
-                .filter_map(|b| snippet_opt(cx, b.span))
-                .collect::<Vec<_>>()
-                .join(" + ");
-
-            span_lint_and_sugg(
-                cx,
-                TRAIT_DUPLICATION_IN_BOUNDS,
-                bounds_span,
-                "this trait bound is already specified in trait declaration",
-                "try",
-                fixed_trait_snippet,
-                Applicability::MaybeIncorrect,
-            );
-        }
     }
 }
 
-- 
cgit 1.4.1-3-g733a5


From 0dd2501e0d06684de5836a00d5e039f25793fd74 Mon Sep 17 00:00:00 2001
From: blyxyas <blyxyas@gmail.com>
Date: Tue, 2 May 2023 20:47:18 +0200
Subject: Don't ignore `check_radians`

---
 clippy_lints/src/floating_point_arithmetic.rs | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/floating_point_arithmetic.rs b/clippy_lints/src/floating_point_arithmetic.rs
index e221905580c..a1a2c398a8a 100644
--- a/clippy_lints/src/floating_point_arithmetic.rs
+++ b/clippy_lints/src/floating_point_arithmetic.rs
@@ -732,14 +732,14 @@ fn check_radians(cx: &LateContext<'_>, expr: &Expr<'_>) {
 impl<'tcx> LateLintPass<'tcx> for FloatingPointArithmetic {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         // All of these operations are currently not const and are in std.
-        if in_constant(cx, expr.hir_id) || is_no_std_crate(cx) {
+        if in_constant(cx, expr.hir_id) {
             return;
         }
 
         if let ExprKind::MethodCall(path, receiver, args, _) = &expr.kind {
             let recv_ty = cx.typeck_results().expr_ty(receiver);
 
-            if recv_ty.is_floating_point() {
+            if recv_ty.is_floating_point() && !is_no_std_crate(cx) {
                 match path.ident.name.as_str() {
                     "ln" => check_ln1p(cx, expr, receiver),
                     "log" => check_log_base(cx, expr, receiver, args),
@@ -750,10 +750,12 @@ impl<'tcx> LateLintPass<'tcx> for FloatingPointArithmetic {
                 }
             }
         } else {
-            check_expm1(cx, expr);
-            check_mul_add(cx, expr);
-            check_custom_abs(cx, expr);
-            check_log_division(cx, expr);
+            if !is_no_std_crate(cx) {
+                check_expm1(cx, expr);
+                check_mul_add(cx, expr);
+                check_custom_abs(cx, expr);
+                check_log_division(cx, expr);
+            }
             check_radians(cx, expr);
         }
     }
-- 
cgit 1.4.1-3-g733a5


From 4e049036313759df55c4c68ad87e1cd7ad5cf214 Mon Sep 17 00:00:00 2001
From: Icxolu <10486322+Icxolu@users.noreply.github.com>
Date: Wed, 3 May 2023 19:25:25 +0200
Subject: rename to plural form

---
 CHANGELOG.md                                       |  2 +-
 clippy_lints/src/declared_lints.rs                 |  2 +-
 .../src/default_constructed_unit_struct.rs         | 66 --------------------
 .../src/default_constructed_unit_structs.rs        | 66 ++++++++++++++++++++
 clippy_lints/src/lib.rs                            |  4 +-
 tests/ui/default_constructed_unit_struct.rs        | 72 ----------------------
 tests/ui/default_constructed_unit_struct.stderr    | 28 ---------
 tests/ui/default_constructed_unit_structs.rs       | 72 ++++++++++++++++++++++
 tests/ui/default_constructed_unit_structs.stderr   | 28 +++++++++
 9 files changed, 170 insertions(+), 170 deletions(-)
 delete mode 100644 clippy_lints/src/default_constructed_unit_struct.rs
 create mode 100644 clippy_lints/src/default_constructed_unit_structs.rs
 delete mode 100644 tests/ui/default_constructed_unit_struct.rs
 delete mode 100644 tests/ui/default_constructed_unit_struct.stderr
 create mode 100644 tests/ui/default_constructed_unit_structs.rs
 create mode 100644 tests/ui/default_constructed_unit_structs.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 735ac59758a..31ad00536c5 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4582,7 +4582,7 @@ Released 2018-09-13
 [`debug_assert_with_mut_call`]: https://rust-lang.github.io/rust-clippy/master/index.html#debug_assert_with_mut_call
 [`decimal_literal_representation`]: https://rust-lang.github.io/rust-clippy/master/index.html#decimal_literal_representation
 [`declare_interior_mutable_const`]: https://rust-lang.github.io/rust-clippy/master/index.html#declare_interior_mutable_const
-[`default_constructed_unit_struct`]: https://rust-lang.github.io/rust-clippy/master/index.html#default_constructed_unit_struct
+[`default_constructed_unit_structs`]: https://rust-lang.github.io/rust-clippy/master/index.html#default_constructed_unit_structs
 [`default_instead_of_iter_empty`]: https://rust-lang.github.io/rust-clippy/master/index.html#default_instead_of_iter_empty
 [`default_numeric_fallback`]: https://rust-lang.github.io/rust-clippy/master/index.html#default_numeric_fallback
 [`default_trait_access`]: https://rust-lang.github.io/rust-clippy/master/index.html#default_trait_access
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index bf30f5b52f7..d3f5cb6e5f4 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -105,7 +105,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::dbg_macro::DBG_MACRO_INFO,
     crate::default::DEFAULT_TRAIT_ACCESS_INFO,
     crate::default::FIELD_REASSIGN_WITH_DEFAULT_INFO,
-    crate::default_constructed_unit_struct::DEFAULT_CONSTRUCTED_UNIT_STRUCT_INFO,
+    crate::default_constructed_unit_structs::DEFAULT_CONSTRUCTED_UNIT_STRUCTS_INFO,
     crate::default_instead_of_iter_empty::DEFAULT_INSTEAD_OF_ITER_EMPTY_INFO,
     crate::default_numeric_fallback::DEFAULT_NUMERIC_FALLBACK_INFO,
     crate::default_union_representation::DEFAULT_UNION_REPRESENTATION_INFO,
diff --git a/clippy_lints/src/default_constructed_unit_struct.rs b/clippy_lints/src/default_constructed_unit_struct.rs
deleted file mode 100644
index d261cdd44a5..00000000000
--- a/clippy_lints/src/default_constructed_unit_struct.rs
+++ /dev/null
@@ -1,66 +0,0 @@
-use clippy_utils::{diagnostics::span_lint_and_sugg, is_from_proc_macro, match_def_path, paths};
-use hir::{def::Res, ExprKind};
-use rustc_errors::Applicability;
-use rustc_hir as hir;
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Check for construction on unit struct using `default`.
-    ///
-    /// ### Why is this bad?
-    /// This adds code complexity and an unnecessary function call.
-    ///
-    /// ### Example
-    /// ```rust
-    /// #[derive(Default)]
-    /// struct S<T> {
-    ///     _marker: PhantomData<T>
-    /// }
-    ///
-    /// let _: S<i32> = S {
-    ///     _marker: PhantomData::default()
-    /// };
-    /// ```
-    /// Use instead:
-    /// ```rust
-    /// let _: S<i32> = Something {
-    ///     _marker: PhantomData
-    /// }
-    /// ```
-    #[clippy::version = "1.71.0"]
-    pub DEFAULT_CONSTRUCTED_UNIT_STRUCT,
-    complexity,
-    "unit structs can be contructed without calling `default`"
-}
-declare_lint_pass!(DefaultConstructedUnitStruct => [DEFAULT_CONSTRUCTED_UNIT_STRUCT]);
-
-impl LateLintPass<'_> for DefaultConstructedUnitStruct {
-    fn check_expr<'tcx>(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'tcx>) {
-        if_chain!(
-            // make sure we have a call to `Default::default`
-            if let hir::ExprKind::Call(fn_expr, &[]) = expr.kind;
-            if let ExprKind::Path(ref qpath) = fn_expr.kind;
-            if let Res::Def(_, def_id) = cx.qpath_res(qpath, fn_expr.hir_id);
-            if match_def_path(cx, def_id, &paths::DEFAULT_TRAIT_METHOD);
-            // make sure we have a struct with no fields (unit struct)
-            if let ty::Adt(def, ..) = cx.typeck_results().expr_ty(expr).kind();
-            if def.is_struct() && def.is_payloadfree()
-                && !def.non_enum_variant().is_field_list_non_exhaustive()
-                && !is_from_proc_macro(cx, expr);
-            then {
-                span_lint_and_sugg(
-                    cx,
-                    DEFAULT_CONSTRUCTED_UNIT_STRUCT,
-                    expr.span.with_lo(qpath.qself_span().hi()),
-                    "use of `default` to create a unit struct",
-                    "remove this call to `default`",
-                    String::new(),
-                    Applicability::MachineApplicable,
-                )
-            }
-        );
-    }
-}
diff --git a/clippy_lints/src/default_constructed_unit_structs.rs b/clippy_lints/src/default_constructed_unit_structs.rs
new file mode 100644
index 00000000000..a79923e9715
--- /dev/null
+++ b/clippy_lints/src/default_constructed_unit_structs.rs
@@ -0,0 +1,66 @@
+use clippy_utils::{diagnostics::span_lint_and_sugg, is_from_proc_macro, match_def_path, paths};
+use hir::{def::Res, ExprKind};
+use rustc_errors::Applicability;
+use rustc_hir as hir;
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Check for construction on unit struct using `default`.
+    ///
+    /// ### Why is this bad?
+    /// This adds code complexity and an unnecessary function call.
+    ///
+    /// ### Example
+    /// ```rust
+    /// #[derive(Default)]
+    /// struct S<T> {
+    ///     _marker: PhantomData<T>
+    /// }
+    ///
+    /// let _: S<i32> = S {
+    ///     _marker: PhantomData::default()
+    /// };
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// let _: S<i32> = Something {
+    ///     _marker: PhantomData
+    /// }
+    /// ```
+    #[clippy::version = "1.71.0"]
+    pub DEFAULT_CONSTRUCTED_UNIT_STRUCTS,
+    complexity,
+    "unit structs can be contructed without calling `default`"
+}
+declare_lint_pass!(DefaultConstructedUnitStructs => [DEFAULT_CONSTRUCTED_UNIT_STRUCTS]);
+
+impl LateLintPass<'_> for DefaultConstructedUnitStructs {
+    fn check_expr<'tcx>(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'tcx>) {
+        if_chain!(
+            // make sure we have a call to `Default::default`
+            if let hir::ExprKind::Call(fn_expr, &[]) = expr.kind;
+            if let ExprKind::Path(ref qpath) = fn_expr.kind;
+            if let Res::Def(_, def_id) = cx.qpath_res(qpath, fn_expr.hir_id);
+            if match_def_path(cx, def_id, &paths::DEFAULT_TRAIT_METHOD);
+            // make sure we have a struct with no fields (unit struct)
+            if let ty::Adt(def, ..) = cx.typeck_results().expr_ty(expr).kind();
+            if def.is_struct() && def.is_payloadfree()
+                && !def.non_enum_variant().is_field_list_non_exhaustive()
+                && !is_from_proc_macro(cx, expr);
+            then {
+                span_lint_and_sugg(
+                    cx,
+                    DEFAULT_CONSTRUCTED_UNIT_STRUCTS,
+                    expr.span.with_lo(qpath.qself_span().hi()),
+                    "use of `default` to create a unit struct",
+                    "remove this call to `default`",
+                    String::new(),
+                    Applicability::MachineApplicable,
+                )
+            }
+        );
+    }
+}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 9af0b17e27b..657a3d1f431 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -94,7 +94,7 @@ mod crate_in_macro_def;
 mod create_dir;
 mod dbg_macro;
 mod default;
-mod default_constructed_unit_struct;
+mod default_constructed_unit_structs;
 mod default_instead_of_iter_empty;
 mod default_numeric_fallback;
 mod default_union_representation;
@@ -971,7 +971,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(manual_slice_size_calculation::ManualSliceSizeCalculation));
     store.register_early_pass(|| Box::new(suspicious_doc_comments::SuspiciousDocComments));
     store.register_late_pass(|_| Box::new(items_after_test_module::ItemsAfterTestModule));
-    store.register_late_pass(|_| Box::new(default_constructed_unit_struct::DefaultConstructedUnitStruct));
+    store.register_late_pass(|_| Box::new(default_constructed_unit_structs::DefaultConstructedUnitStructs));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/tests/ui/default_constructed_unit_struct.rs b/tests/ui/default_constructed_unit_struct.rs
deleted file mode 100644
index b64da9b863a..00000000000
--- a/tests/ui/default_constructed_unit_struct.rs
+++ /dev/null
@@ -1,72 +0,0 @@
-#![allow(unused)]
-#![warn(clippy::default_constructed_unit_struct)]
-use std::marker::PhantomData;
-
-#[derive(Default)]
-struct UnitStruct;
-
-#[derive(Default)]
-struct TupleStruct(usize);
-
-// no lint for derived impl
-#[derive(Default)]
-struct NormalStruct {
-    inner: PhantomData<usize>,
-}
-
-struct NonDefaultStruct;
-
-impl NonDefaultStruct {
-    fn default() -> Self {
-        Self
-    }
-}
-
-#[derive(Default)]
-enum SomeEnum {
-    #[default]
-    Unit,
-    Tuple(UnitStruct),
-    Struct {
-        inner: usize,
-    },
-}
-
-impl NormalStruct {
-    fn new() -> Self {
-        // should lint
-        Self {
-            inner: PhantomData::default(),
-        }
-    }
-}
-
-#[derive(Default)]
-struct GenericStruct<T> {
-    t: T,
-}
-
-impl<T: Default> GenericStruct<T> {
-    fn new() -> Self {
-        // should not lint
-        Self { t: T::default() }
-    }
-}
-
-#[derive(Default)]
-#[non_exhaustive]
-struct NonExhaustiveStruct;
-
-fn main() {
-    // should lint
-    let _ = PhantomData::<usize>::default();
-    let _: PhantomData<i32> = PhantomData::default();
-    let _ = UnitStruct::default();
-
-    // should not lint
-    let _ = TupleStruct::default();
-    let _ = NormalStruct::default();
-    let _ = NonExhaustiveStruct::default();
-    let _ = SomeEnum::default();
-    let _ = NonDefaultStruct::default();
-}
diff --git a/tests/ui/default_constructed_unit_struct.stderr b/tests/ui/default_constructed_unit_struct.stderr
deleted file mode 100644
index 952d4019644..00000000000
--- a/tests/ui/default_constructed_unit_struct.stderr
+++ /dev/null
@@ -1,28 +0,0 @@
-error: use of `default` to create a unit struct
-  --> $DIR/default_constructed_unit_struct.rs:39:31
-   |
-LL |             inner: PhantomData::default(),
-   |                               ^^^^^^^^^^^ help: remove this call to `default`
-   |
-   = note: `-D clippy::default-constructed-unit-struct` implied by `-D warnings`
-
-error: use of `default` to create a unit struct
-  --> $DIR/default_constructed_unit_struct.rs:62:33
-   |
-LL |     let _ = PhantomData::<usize>::default();
-   |                                 ^^^^^^^^^^^ help: remove this call to `default`
-
-error: use of `default` to create a unit struct
-  --> $DIR/default_constructed_unit_struct.rs:63:42
-   |
-LL |     let _: PhantomData<i32> = PhantomData::default();
-   |                                          ^^^^^^^^^^^ help: remove this call to `default`
-
-error: use of `default` to create a unit struct
-  --> $DIR/default_constructed_unit_struct.rs:64:23
-   |
-LL |     let _ = UnitStruct::default();
-   |                       ^^^^^^^^^^^ help: remove this call to `default`
-
-error: aborting due to 4 previous errors
-
diff --git a/tests/ui/default_constructed_unit_structs.rs b/tests/ui/default_constructed_unit_structs.rs
new file mode 100644
index 00000000000..505be09a50e
--- /dev/null
+++ b/tests/ui/default_constructed_unit_structs.rs
@@ -0,0 +1,72 @@
+#![allow(unused)]
+#![warn(clippy::default_constructed_unit_structs)]
+use std::marker::PhantomData;
+
+#[derive(Default)]
+struct UnitStruct;
+
+#[derive(Default)]
+struct TupleStruct(usize);
+
+// no lint for derived impl
+#[derive(Default)]
+struct NormalStruct {
+    inner: PhantomData<usize>,
+}
+
+struct NonDefaultStruct;
+
+impl NonDefaultStruct {
+    fn default() -> Self {
+        Self
+    }
+}
+
+#[derive(Default)]
+enum SomeEnum {
+    #[default]
+    Unit,
+    Tuple(UnitStruct),
+    Struct {
+        inner: usize,
+    },
+}
+
+impl NormalStruct {
+    fn new() -> Self {
+        // should lint
+        Self {
+            inner: PhantomData::default(),
+        }
+    }
+}
+
+#[derive(Default)]
+struct GenericStruct<T> {
+    t: T,
+}
+
+impl<T: Default> GenericStruct<T> {
+    fn new() -> Self {
+        // should not lint
+        Self { t: T::default() }
+    }
+}
+
+#[derive(Default)]
+#[non_exhaustive]
+struct NonExhaustiveStruct;
+
+fn main() {
+    // should lint
+    let _ = PhantomData::<usize>::default();
+    let _: PhantomData<i32> = PhantomData::default();
+    let _ = UnitStruct::default();
+
+    // should not lint
+    let _ = TupleStruct::default();
+    let _ = NormalStruct::default();
+    let _ = NonExhaustiveStruct::default();
+    let _ = SomeEnum::default();
+    let _ = NonDefaultStruct::default();
+}
diff --git a/tests/ui/default_constructed_unit_structs.stderr b/tests/ui/default_constructed_unit_structs.stderr
new file mode 100644
index 00000000000..23ffa278288
--- /dev/null
+++ b/tests/ui/default_constructed_unit_structs.stderr
@@ -0,0 +1,28 @@
+error: use of `default` to create a unit struct
+  --> $DIR/default_constructed_unit_structs.rs:39:31
+   |
+LL |             inner: PhantomData::default(),
+   |                               ^^^^^^^^^^^ help: remove this call to `default`
+   |
+   = note: `-D clippy::default-constructed-unit-structs` implied by `-D warnings`
+
+error: use of `default` to create a unit struct
+  --> $DIR/default_constructed_unit_structs.rs:62:33
+   |
+LL |     let _ = PhantomData::<usize>::default();
+   |                                 ^^^^^^^^^^^ help: remove this call to `default`
+
+error: use of `default` to create a unit struct
+  --> $DIR/default_constructed_unit_structs.rs:63:42
+   |
+LL |     let _: PhantomData<i32> = PhantomData::default();
+   |                                          ^^^^^^^^^^^ help: remove this call to `default`
+
+error: use of `default` to create a unit struct
+  --> $DIR/default_constructed_unit_structs.rs:64:23
+   |
+LL |     let _ = UnitStruct::default();
+   |                       ^^^^^^^^^^^ help: remove this call to `default`
+
+error: aborting due to 4 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 8701009860273828cb6853e1dba79a82e1271619 Mon Sep 17 00:00:00 2001
From: Icxolu <10486322+Icxolu@users.noreply.github.com>
Date: Wed, 3 May 2023 20:06:29 +0200
Subject: add more test cases

---
 .../src/default_constructed_unit_structs.rs        |  8 ++--
 tests/ui/default_constructed_unit_structs.rs       | 45 ++++++++++++++++++++++
 tests/ui/default_constructed_unit_structs.stderr   | 20 ++++++----
 3 files changed, 62 insertions(+), 11 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/default_constructed_unit_structs.rs b/clippy_lints/src/default_constructed_unit_structs.rs
index a79923e9715..dab76a2c41f 100644
--- a/clippy_lints/src/default_constructed_unit_structs.rs
+++ b/clippy_lints/src/default_constructed_unit_structs.rs
@@ -42,14 +42,14 @@ impl LateLintPass<'_> for DefaultConstructedUnitStructs {
         if_chain!(
             // make sure we have a call to `Default::default`
             if let hir::ExprKind::Call(fn_expr, &[]) = expr.kind;
-            if let ExprKind::Path(ref qpath) = fn_expr.kind;
+            if let ExprKind::Path(ref qpath@ hir::QPath::TypeRelative(_,_)) = fn_expr.kind;
             if let Res::Def(_, def_id) = cx.qpath_res(qpath, fn_expr.hir_id);
             if match_def_path(cx, def_id, &paths::DEFAULT_TRAIT_METHOD);
             // make sure we have a struct with no fields (unit struct)
             if let ty::Adt(def, ..) = cx.typeck_results().expr_ty(expr).kind();
-            if def.is_struct() && def.is_payloadfree()
-                && !def.non_enum_variant().is_field_list_non_exhaustive()
-                && !is_from_proc_macro(cx, expr);
+            if def.is_struct();
+            if let var @ ty::VariantDef { ctor: Some((hir::def::CtorKind::Const, _)), .. } = def.non_enum_variant();
+            if !var.is_field_list_non_exhaustive() && !is_from_proc_macro(cx, expr);
             then {
                 span_lint_and_sugg(
                     cx,
diff --git a/tests/ui/default_constructed_unit_structs.rs b/tests/ui/default_constructed_unit_structs.rs
index 505be09a50e..276fc40aa18 100644
--- a/tests/ui/default_constructed_unit_structs.rs
+++ b/tests/ui/default_constructed_unit_structs.rs
@@ -5,9 +5,23 @@ use std::marker::PhantomData;
 #[derive(Default)]
 struct UnitStruct;
 
+impl UnitStruct {
+    fn new() -> Self {
+        //should lint
+        Self::default()
+    }
+}
+
 #[derive(Default)]
 struct TupleStruct(usize);
 
+impl TupleStruct {
+    fn new() -> Self {
+        // should not lint
+        Self(Default::default())
+    }
+}
+
 // no lint for derived impl
 #[derive(Default)]
 struct NormalStruct {
@@ -39,6 +53,13 @@ impl NormalStruct {
             inner: PhantomData::default(),
         }
     }
+
+    fn new2() -> Self {
+        // should not lint
+        Self {
+            inner: Default::default(),
+        }
+    }
 }
 
 #[derive(Default)]
@@ -51,8 +72,29 @@ impl<T: Default> GenericStruct<T> {
         // should not lint
         Self { t: T::default() }
     }
+
+    fn new2() -> Self {
+        // should not lint
+        Self { t: Default::default() }
+    }
+}
+
+struct FakeDefault;
+impl FakeDefault {
+    fn default() -> Self {
+        Self
+    }
 }
 
+impl Default for FakeDefault {
+    fn default() -> Self {
+        Self
+    }
+}
+
+#[derive(Default)]
+struct EmptyStruct {}
+
 #[derive(Default)]
 #[non_exhaustive]
 struct NonExhaustiveStruct;
@@ -69,4 +111,7 @@ fn main() {
     let _ = NonExhaustiveStruct::default();
     let _ = SomeEnum::default();
     let _ = NonDefaultStruct::default();
+    let _ = EmptyStruct::default();
+    let _ = FakeDefault::default();
+    let _ = <FakeDefault as Default>::default();
 }
diff --git a/tests/ui/default_constructed_unit_structs.stderr b/tests/ui/default_constructed_unit_structs.stderr
index 23ffa278288..fa39ef4cda1 100644
--- a/tests/ui/default_constructed_unit_structs.stderr
+++ b/tests/ui/default_constructed_unit_structs.stderr
@@ -1,28 +1,34 @@
 error: use of `default` to create a unit struct
-  --> $DIR/default_constructed_unit_structs.rs:39:31
+  --> $DIR/default_constructed_unit_structs.rs:11:13
    |
-LL |             inner: PhantomData::default(),
-   |                               ^^^^^^^^^^^ help: remove this call to `default`
+LL |         Self::default()
+   |             ^^^^^^^^^^^ help: remove this call to `default`
    |
    = note: `-D clippy::default-constructed-unit-structs` implied by `-D warnings`
 
 error: use of `default` to create a unit struct
-  --> $DIR/default_constructed_unit_structs.rs:62:33
+  --> $DIR/default_constructed_unit_structs.rs:53:31
+   |
+LL |             inner: PhantomData::default(),
+   |                               ^^^^^^^^^^^ help: remove this call to `default`
+
+error: use of `default` to create a unit struct
+  --> $DIR/default_constructed_unit_structs.rs:104:33
    |
 LL |     let _ = PhantomData::<usize>::default();
    |                                 ^^^^^^^^^^^ help: remove this call to `default`
 
 error: use of `default` to create a unit struct
-  --> $DIR/default_constructed_unit_structs.rs:63:42
+  --> $DIR/default_constructed_unit_structs.rs:105:42
    |
 LL |     let _: PhantomData<i32> = PhantomData::default();
    |                                          ^^^^^^^^^^^ help: remove this call to `default`
 
 error: use of `default` to create a unit struct
-  --> $DIR/default_constructed_unit_structs.rs:64:23
+  --> $DIR/default_constructed_unit_structs.rs:106:23
    |
 LL |     let _ = UnitStruct::default();
    |                       ^^^^^^^^^^^ help: remove this call to `default`
 
-error: aborting due to 4 previous errors
+error: aborting due to 5 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 48ae5a071bc32e5fb69669248ab103ecba7509ab Mon Sep 17 00:00:00 2001
From: Icxolu <10486322+Icxolu@users.noreply.github.com>
Date: Wed, 3 May 2023 21:43:10 +0200
Subject: fix lint docs

---
 clippy_lints/src/default_constructed_unit_structs.rs | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/default_constructed_unit_structs.rs b/clippy_lints/src/default_constructed_unit_structs.rs
index dab76a2c41f..e529d81a7e9 100644
--- a/clippy_lints/src/default_constructed_unit_structs.rs
+++ b/clippy_lints/src/default_constructed_unit_structs.rs
@@ -15,6 +15,7 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust
+    /// # use std::marker::PhantomData;
     /// #[derive(Default)]
     /// struct S<T> {
     ///     _marker: PhantomData<T>
@@ -26,9 +27,14 @@ declare_clippy_lint! {
     /// ```
     /// Use instead:
     /// ```rust
-    /// let _: S<i32> = Something {
-    ///     _marker: PhantomData
+    /// # use std::marker::PhantomData;
+    /// struct S<T> {
+    ///     _marker: PhantomData<T>
     /// }
+    ///
+    /// let _: S<i32> = S {
+    ///     _marker: PhantomData
+    /// };
     /// ```
     #[clippy::version = "1.71.0"]
     pub DEFAULT_CONSTRUCTED_UNIT_STRUCTS,
-- 
cgit 1.4.1-3-g733a5


From 68eb864c91a1937859fb5c2c6e96850c3443268c Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Fri, 5 May 2023 18:30:41 +0000
Subject: Ignore expressions from macros in default_constructed_unit_structs

---
 clippy_lints/src/default_constructed_unit_structs.rs |  5 +++--
 tests/ui/default_constructed_unit_structs.fixed      | 18 ++++++++++++++++++
 tests/ui/default_constructed_unit_structs.rs         | 18 ++++++++++++++++++
 tests/ui/default_constructed_unit_structs.stderr     | 10 ++++++++--
 4 files changed, 47 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/default_constructed_unit_structs.rs b/clippy_lints/src/default_constructed_unit_structs.rs
index e529d81a7e9..9bd7a0dc0f3 100644
--- a/clippy_lints/src/default_constructed_unit_structs.rs
+++ b/clippy_lints/src/default_constructed_unit_structs.rs
@@ -1,4 +1,4 @@
-use clippy_utils::{diagnostics::span_lint_and_sugg, is_from_proc_macro, match_def_path, paths};
+use clippy_utils::{diagnostics::span_lint_and_sugg, match_def_path, paths};
 use hir::{def::Res, ExprKind};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
@@ -55,7 +55,8 @@ impl LateLintPass<'_> for DefaultConstructedUnitStructs {
             if let ty::Adt(def, ..) = cx.typeck_results().expr_ty(expr).kind();
             if def.is_struct();
             if let var @ ty::VariantDef { ctor: Some((hir::def::CtorKind::Const, _)), .. } = def.non_enum_variant();
-            if !var.is_field_list_non_exhaustive() && !is_from_proc_macro(cx, expr);
+            if !var.is_field_list_non_exhaustive();
+            if !expr.span.from_expansion() && !qpath.span().from_expansion();
             then {
                 span_lint_and_sugg(
                     cx,
diff --git a/tests/ui/default_constructed_unit_structs.fixed b/tests/ui/default_constructed_unit_structs.fixed
index 4c2d1ea48e1..e1012f38bba 100644
--- a/tests/ui/default_constructed_unit_structs.fixed
+++ b/tests/ui/default_constructed_unit_structs.fixed
@@ -105,6 +105,7 @@ fn main() {
     // should lint
     let _ = PhantomData::<usize>;
     let _: PhantomData<i32> = PhantomData;
+    let _: PhantomData<i32> = std::marker::PhantomData;
     let _ = UnitStruct;
 
     // should not lint
@@ -116,4 +117,21 @@ fn main() {
     let _ = EmptyStruct::default();
     let _ = FakeDefault::default();
     let _ = <FakeDefault as Default>::default();
+
+    macro_rules! in_macro {
+        ($i:ident) => {{
+            let _ = UnitStruct::default();
+            let _ = $i::default();
+        }};
+    }
+
+    in_macro!(UnitStruct);
+
+    macro_rules! struct_from_macro {
+        () => {
+            UnitStruct
+        };
+    }
+
+    let _ = <struct_from_macro!()>::default();
 }
diff --git a/tests/ui/default_constructed_unit_structs.rs b/tests/ui/default_constructed_unit_structs.rs
index 850793dd5de..c7b4313dbf0 100644
--- a/tests/ui/default_constructed_unit_structs.rs
+++ b/tests/ui/default_constructed_unit_structs.rs
@@ -105,6 +105,7 @@ fn main() {
     // should lint
     let _ = PhantomData::<usize>::default();
     let _: PhantomData<i32> = PhantomData::default();
+    let _: PhantomData<i32> = std::marker::PhantomData::default();
     let _ = UnitStruct::default();
 
     // should not lint
@@ -116,4 +117,21 @@ fn main() {
     let _ = EmptyStruct::default();
     let _ = FakeDefault::default();
     let _ = <FakeDefault as Default>::default();
+
+    macro_rules! in_macro {
+        ($i:ident) => {{
+            let _ = UnitStruct::default();
+            let _ = $i::default();
+        }};
+    }
+
+    in_macro!(UnitStruct);
+
+    macro_rules! struct_from_macro {
+        () => {
+            UnitStruct
+        };
+    }
+
+    let _ = <struct_from_macro!()>::default();
 }
diff --git a/tests/ui/default_constructed_unit_structs.stderr b/tests/ui/default_constructed_unit_structs.stderr
index 4058943d087..61a32fb10e5 100644
--- a/tests/ui/default_constructed_unit_structs.stderr
+++ b/tests/ui/default_constructed_unit_structs.stderr
@@ -25,10 +25,16 @@ LL |     let _: PhantomData<i32> = PhantomData::default();
    |                                          ^^^^^^^^^^^ help: remove this call to `default`
 
 error: use of `default` to create a unit struct
-  --> $DIR/default_constructed_unit_structs.rs:108:23
+  --> $DIR/default_constructed_unit_structs.rs:108:55
+   |
+LL |     let _: PhantomData<i32> = std::marker::PhantomData::default();
+   |                                                       ^^^^^^^^^^^ help: remove this call to `default`
+
+error: use of `default` to create a unit struct
+  --> $DIR/default_constructed_unit_structs.rs:109:23
    |
 LL |     let _ = UnitStruct::default();
    |                       ^^^^^^^^^^^ help: remove this call to `default`
 
-error: aborting due to 5 previous errors
+error: aborting due to 6 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From afa2741e6a51f94ec408b78bb7589fa0a0534a3c Mon Sep 17 00:00:00 2001
From: disco07 <koneenok@outlook.fr>
Date: Fri, 5 May 2023 21:33:16 +0200
Subject: redundant_pattern_matching

---
 .../src/matches/redundant_pattern_match.rs         | 91 +++++++++++++++++++-
 tests/ui/redundant_pattern_matching_option.fixed   | 19 +++++
 tests/ui/redundant_pattern_matching_option.rs      | 43 ++++++++++
 tests/ui/redundant_pattern_matching_option.stderr  | 96 +++++++++++++++++++---
 tests/ui/redundant_pattern_matching_result.fixed   | 11 +++
 tests/ui/redundant_pattern_matching_result.rs      | 23 ++++++
 tests/ui/redundant_pattern_matching_result.stderr  | 62 +++++++++++---
 7 files changed, 319 insertions(+), 26 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/redundant_pattern_match.rs b/clippy_lints/src/matches/redundant_pattern_match.rs
index af121f317cd..9656049feeb 100644
--- a/clippy_lints/src/matches/redundant_pattern_match.rs
+++ b/clippy_lints/src/matches/redundant_pattern_match.rs
@@ -186,9 +186,9 @@ fn find_sugg_for_if_let<'tcx>(
 }
 
 pub(super) fn check_match<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, op: &Expr<'_>, arms: &[Arm<'_>]) {
+    //eprintln!("{:#?}", expr);
     if arms.len() == 2 {
         let node_pair = (&arms[0].pat.kind, &arms[1].pat.kind);
-
         let found_good_method = match node_pair {
             (
                 PatKind::TupleStruct(ref path_left, patterns_left, _),
@@ -252,6 +252,68 @@ pub(super) fn check_match<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, op
                     None
                 }
             },
+            (PatKind::TupleStruct(ref path_left, patterns, _), PatKind::Wild) if patterns.len() == 1 => {
+                if let PatKind::Wild = patterns[0].kind {
+                    let ident = match path_left {
+                        QPath::Resolved(_, path) => {
+                            let name = path.segments[0].ident;
+                            Some(name)
+                        },
+                        _ => None,
+                    };
+                    if let Some(name) = ident {
+                        match name.as_str() {
+                            "Ok" => find_good_method_for_matches_macro(
+                                cx,
+                                arms,
+                                path_left,
+                                Item::Lang(ResultOk),
+                                "is_ok()",
+                                "is_err()",
+                            ),
+                            "Some" => find_good_method_for_matches_macro(
+                                cx,
+                                arms,
+                                path_left,
+                                Item::Lang(OptionSome),
+                                "is_some()",
+                                "is_none()",
+                            ),
+                            _ => None,
+                        }
+                    } else {
+                        None
+                    }
+                } else {
+                    None
+                }
+            },
+            (PatKind::Path(ref path_left), PatKind::Wild) => {
+                let ident = match path_left {
+                    QPath::Resolved(_, path) => {
+                        let name = path.segments[0].ident;
+                        Some(name)
+                    },
+                    _ => None,
+                };
+
+                if let Some(name) = ident {
+                    match name.as_str() {
+                        "None" => find_good_method_for_matches_macro(
+                            cx,
+                            arms,
+                            path_left,
+                            Item::Lang(OptionNone),
+                            "is_none()",
+                            "is_some()",
+                        ),
+                        _ => None,
+                    }
+                } else {
+                    None
+                }
+                
+            }
             _ => None,
         };
 
@@ -345,3 +407,30 @@ fn find_good_method_for_match<'a>(
         _ => None,
     }
 }
+
+#[expect(clippy::too_many_arguments)]
+fn find_good_method_for_matches_macro<'a>(
+    cx: &LateContext<'_>,
+    arms: &[Arm<'_>],
+    path_left: &QPath<'_>,
+    expected_item_left: Item,
+    should_be_left: &'a str,
+    should_be_right: &'a str,
+) -> Option<&'a str> {
+    let first_pat = arms[0].pat;
+
+    let body_node_pair = if is_pat_variant(cx, first_pat, path_left, expected_item_left) {
+        (&arms[0].body.kind, &arms[1].body.kind)
+    } else {
+        return None;
+    };
+
+    match body_node_pair {
+        (ExprKind::Lit(lit_left), ExprKind::Lit(lit_right)) => match (&lit_left.node, &lit_right.node) {
+            (LitKind::Bool(true), LitKind::Bool(false)) => Some(should_be_left),
+            (LitKind::Bool(false), LitKind::Bool(true)) => Some(should_be_right),
+            _ => None,
+        },
+        _ => None,
+    }
+}
diff --git a/tests/ui/redundant_pattern_matching_option.fixed b/tests/ui/redundant_pattern_matching_option.fixed
index d62f7d26a35..c22a4d7456e 100644
--- a/tests/ui/redundant_pattern_matching_option.fixed
+++ b/tests/ui/redundant_pattern_matching_option.fixed
@@ -46,6 +46,7 @@ fn main() {
     let _ = if opt.is_some() { true } else { false };
 
     issue6067();
+    issue10726();
 
     let _ = if gen_opt().is_some() {
         1
@@ -88,3 +89,21 @@ fn issue7921() {
     if (&None::<()>).is_none() {}
     if (&None::<()>).is_none() {}
 }
+
+fn issue10726() {
+    Some(42).is_some();
+
+    Some(42).is_none();
+
+    Some(42).is_none();
+
+    Some(42).is_some();
+
+    None::<()>.is_none();
+
+    None::<()>.is_none();
+
+    None::<()>.is_none();
+
+    None::<()>.is_some();
+}
diff --git a/tests/ui/redundant_pattern_matching_option.rs b/tests/ui/redundant_pattern_matching_option.rs
index d6429426573..cd96e0d29a5 100644
--- a/tests/ui/redundant_pattern_matching_option.rs
+++ b/tests/ui/redundant_pattern_matching_option.rs
@@ -55,6 +55,7 @@ fn main() {
     let _ = if let Some(_) = opt { true } else { false };
 
     issue6067();
+    issue10726();
 
     let _ = if let Some(_) = gen_opt() {
         1
@@ -103,3 +104,45 @@ fn issue7921() {
     if let None = *(&None::<()>) {}
     if let None = *&None::<()> {}
 }
+
+fn issue10726() {
+    match Some(42) {
+        Some(_) => true,
+        _ => false,
+    };
+
+    match Some(42) {
+        Some(_) => false,
+        _ => true,
+    };
+
+    match Some(42) {
+        None => true,
+        _ => false,
+    };
+
+    match Some(42) {
+        None => false,
+        _ => true,
+    };
+
+    match None::<()> {
+        Some(_) => false,
+        _ => true,
+    };
+
+    match None::<()> {
+        Some(_) => false,
+        _ => true,
+    };
+
+    match None::<()> {
+        None => true,
+        _ => false,
+    };
+
+    match None::<()> {
+        None => false,
+        _ => true,
+    };
+}
diff --git a/tests/ui/redundant_pattern_matching_option.stderr b/tests/ui/redundant_pattern_matching_option.stderr
index 7c5a047e455..d397297074b 100644
--- a/tests/ui/redundant_pattern_matching_option.stderr
+++ b/tests/ui/redundant_pattern_matching_option.stderr
@@ -77,49 +77,49 @@ LL |     let _ = 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:59:20
+  --> $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:61:19
+  --> $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:67:12
+  --> $DIR/redundant_pattern_matching_option.rs:68:12
    |
 LL |     if let Some(..) = gen_opt() {}
    |     -------^^^^^^^^------------ help: try this: `if gen_opt().is_some()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/redundant_pattern_matching_option.rs:82:12
+  --> $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:84:12
+  --> $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:86:15
+  --> $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:88:15
+  --> $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:90:5
+  --> $DIR/redundant_pattern_matching_option.rs:91:5
    |
 LL | /     match Some(42) {
 LL | |         Some(_) => true,
@@ -128,7 +128,7 @@ LL | |     };
    | |_____^ help: try this: `Some(42).is_some()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:95:5
+  --> $DIR/redundant_pattern_matching_option.rs:96:5
    |
 LL | /     match None::<()> {
 LL | |         Some(_) => false,
@@ -137,16 +137,88 @@ LL | |     };
    | |_____^ help: try this: `None::<()>.is_none()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:103:12
+  --> $DIR/redundant_pattern_matching_option.rs:104:12
    |
 LL |     if let None = *(&None::<()>) {}
    |     -------^^^^----------------- help: try this: `if (&None::<()>).is_none()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:104:12
+  --> $DIR/redundant_pattern_matching_option.rs:105:12
    |
 LL |     if let None = *&None::<()> {}
    |     -------^^^^--------------- help: try this: `if (&None::<()>).is_none()`
 
-error: aborting due to 22 previous errors
+error: redundant pattern matching, consider using `is_some()`
+  --> $DIR/redundant_pattern_matching_option.rs:109:5
+   |
+LL | /     match Some(42) {
+LL | |         Some(_) => true,
+LL | |         _ => false,
+LL | |     };
+   | |_____^ help: try this: `Some(42).is_some()`
+
+error: redundant pattern matching, consider using `is_none()`
+  --> $DIR/redundant_pattern_matching_option.rs:114:5
+   |
+LL | /     match Some(42) {
+LL | |         Some(_) => false,
+LL | |         _ => true,
+LL | |     };
+   | |_____^ help: try this: `Some(42).is_none()`
+
+error: redundant pattern matching, consider using `is_none()`
+  --> $DIR/redundant_pattern_matching_option.rs:119:5
+   |
+LL | /     match Some(42) {
+LL | |         None => true,
+LL | |         _ => false,
+LL | |     };
+   | |_____^ help: try this: `Some(42).is_none()`
+
+error: redundant pattern matching, consider using `is_some()`
+  --> $DIR/redundant_pattern_matching_option.rs:124:5
+   |
+LL | /     match Some(42) {
+LL | |         None => false,
+LL | |         _ => true,
+LL | |     };
+   | |_____^ help: try this: `Some(42).is_some()`
+
+error: redundant pattern matching, consider using `is_none()`
+  --> $DIR/redundant_pattern_matching_option.rs:129:5
+   |
+LL | /     match None::<()> {
+LL | |         Some(_) => false,
+LL | |         _ => true,
+LL | |     };
+   | |_____^ help: try this: `None::<()>.is_none()`
+
+error: redundant pattern matching, consider using `is_none()`
+  --> $DIR/redundant_pattern_matching_option.rs:134:5
+   |
+LL | /     match None::<()> {
+LL | |         Some(_) => false,
+LL | |         _ => true,
+LL | |     };
+   | |_____^ help: try this: `None::<()>.is_none()`
+
+error: redundant pattern matching, consider using `is_none()`
+  --> $DIR/redundant_pattern_matching_option.rs:139:5
+   |
+LL | /     match None::<()> {
+LL | |         None => true,
+LL | |         _ => false,
+LL | |     };
+   | |_____^ help: try this: `None::<()>.is_none()`
+
+error: redundant pattern matching, consider using `is_some()`
+  --> $DIR/redundant_pattern_matching_option.rs:144:5
+   |
+LL | /     match None::<()> {
+LL | |         None => false,
+LL | |         _ => true,
+LL | |     };
+   | |_____^ help: try this: `None::<()>.is_some()`
+
+error: aborting due to 30 previous errors
 
diff --git a/tests/ui/redundant_pattern_matching_result.fixed b/tests/ui/redundant_pattern_matching_result.fixed
index c48d1522935..a51e14a5b56 100644
--- a/tests/ui/redundant_pattern_matching_result.fixed
+++ b/tests/ui/redundant_pattern_matching_result.fixed
@@ -43,6 +43,7 @@ fn main() {
     issue5504();
     issue6067();
     issue6065();
+    issue10726();
 
     let _ = if gen_res().is_ok() {
         1
@@ -107,3 +108,13 @@ const fn issue6067() {
 
     Err::<i32, i32>(42).is_err();
 }
+
+fn issue10726() {
+    Ok::<i32, i32>(42).is_ok();
+
+    Ok::<i32, i32>(42).is_err();
+
+    Err::<i32, i32>(42).is_err();
+
+    Err::<i32, i32>(42).is_ok();
+}
diff --git a/tests/ui/redundant_pattern_matching_result.rs b/tests/ui/redundant_pattern_matching_result.rs
index 26f37d169fa..709e3d526a8 100644
--- a/tests/ui/redundant_pattern_matching_result.rs
+++ b/tests/ui/redundant_pattern_matching_result.rs
@@ -55,6 +55,7 @@ fn main() {
     issue5504();
     issue6067();
     issue6065();
+    issue10726();
 
     let _ = if let Ok(_) = gen_res() {
         1
@@ -125,3 +126,25 @@ const fn issue6067() {
         Err(_) => true,
     };
 }
+
+fn issue10726() {
+    match Ok::<i32, i32>(42) {
+        Ok(_) => true,
+        _ => false,
+    };
+
+    match Ok::<i32, i32>(42) {
+        Ok(_) => false,
+        _ => true,
+    };
+
+    match Err::<i32, i32>(42) {
+        Ok(_) => false,
+        _ => true,
+    };
+
+    match Err::<i32, i32>(42) {
+        Ok(_) => true,
+        _ => false,
+    };
+}
diff --git a/tests/ui/redundant_pattern_matching_result.stderr b/tests/ui/redundant_pattern_matching_result.stderr
index d6a46babb77..0e8a983bf44 100644
--- a/tests/ui/redundant_pattern_matching_result.stderr
+++ b/tests/ui/redundant_pattern_matching_result.stderr
@@ -73,67 +73,67 @@ 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_ok()`
-  --> $DIR/redundant_pattern_matching_result.rs:59:20
+  --> $DIR/redundant_pattern_matching_result.rs:60:20
    |
 LL |     let _ = if let Ok(_) = gen_res() {
    |             -------^^^^^------------ help: try this: `if gen_res().is_ok()`
 
 error: redundant pattern matching, consider using `is_err()`
-  --> $DIR/redundant_pattern_matching_result.rs:61:19
+  --> $DIR/redundant_pattern_matching_result.rs:62: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_result.rs:84:19
+  --> $DIR/redundant_pattern_matching_result.rs:85: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_result.rs:85:16
+  --> $DIR/redundant_pattern_matching_result.rs:86: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_result.rs:91:12
+  --> $DIR/redundant_pattern_matching_result.rs:92: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_result.rs:92:15
+  --> $DIR/redundant_pattern_matching_result.rs:93:15
    |
 LL |     while let Some(_) = m!() {}
    |     ----------^^^^^^^------- help: try this: `while m!().is_some()`
 
 error: redundant pattern matching, consider using `is_ok()`
-  --> $DIR/redundant_pattern_matching_result.rs:110:12
+  --> $DIR/redundant_pattern_matching_result.rs:111: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_result.rs:112:12
+  --> $DIR/redundant_pattern_matching_result.rs:113: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_result.rs:114:15
+  --> $DIR/redundant_pattern_matching_result.rs:115: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_result.rs:116:15
+  --> $DIR/redundant_pattern_matching_result.rs:117: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_result.rs:118:5
+  --> $DIR/redundant_pattern_matching_result.rs:119:5
    |
 LL | /     match Ok::<i32, i32>(42) {
 LL | |         Ok(_) => true,
@@ -142,7 +142,7 @@ LL | |     };
    | |_____^ help: try this: `Ok::<i32, i32>(42).is_ok()`
 
 error: redundant pattern matching, consider using `is_err()`
-  --> $DIR/redundant_pattern_matching_result.rs:123:5
+  --> $DIR/redundant_pattern_matching_result.rs:124:5
    |
 LL | /     match Err::<i32, i32>(42) {
 LL | |         Ok(_) => false,
@@ -150,5 +150,41 @@ LL | |         Err(_) => true,
 LL | |     };
    | |_____^ help: try this: `Err::<i32, i32>(42).is_err()`
 
-error: aborting due to 22 previous errors
+error: redundant pattern matching, consider using `is_ok()`
+  --> $DIR/redundant_pattern_matching_result.rs:131:5
+   |
+LL | /     match Ok::<i32, i32>(42) {
+LL | |         Ok(_) => true,
+LL | |         _ => false,
+LL | |     };
+   | |_____^ help: try this: `Ok::<i32, i32>(42).is_ok()`
+
+error: redundant pattern matching, consider using `is_err()`
+  --> $DIR/redundant_pattern_matching_result.rs:136:5
+   |
+LL | /     match Ok::<i32, i32>(42) {
+LL | |         Ok(_) => false,
+LL | |         _ => true,
+LL | |     };
+   | |_____^ help: try this: `Ok::<i32, i32>(42).is_err()`
+
+error: redundant pattern matching, consider using `is_err()`
+  --> $DIR/redundant_pattern_matching_result.rs:141:5
+   |
+LL | /     match Err::<i32, i32>(42) {
+LL | |         Ok(_) => false,
+LL | |         _ => true,
+LL | |     };
+   | |_____^ help: try this: `Err::<i32, i32>(42).is_err()`
+
+error: redundant pattern matching, consider using `is_ok()`
+  --> $DIR/redundant_pattern_matching_result.rs:146:5
+   |
+LL | /     match Err::<i32, i32>(42) {
+LL | |         Ok(_) => true,
+LL | |         _ => false,
+LL | |     };
+   | |_____^ help: try this: `Err::<i32, i32>(42).is_ok()`
+
+error: aborting due to 26 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From d2bbe760081f52b2afa237944a78b93097aad51c Mon Sep 17 00:00:00 2001
From: disco07 <koneenok@outlook.fr>
Date: Fri, 5 May 2023 21:49:55 +0200
Subject: redundant_pattern_matching

---
 clippy_lints/src/matches/redundant_pattern_match.rs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/redundant_pattern_match.rs b/clippy_lints/src/matches/redundant_pattern_match.rs
index 9656049feeb..53480a257c5 100644
--- a/clippy_lints/src/matches/redundant_pattern_match.rs
+++ b/clippy_lints/src/matches/redundant_pattern_match.rs
@@ -312,8 +312,7 @@ pub(super) fn check_match<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, op
                 } else {
                     None
                 }
-                
-            }
+            },
             _ => None,
         };
 
-- 
cgit 1.4.1-3-g733a5


From d80ca09f5e254a113f1c6d4a63d12d9e215e0f39 Mon Sep 17 00:00:00 2001
From: Elias Holzmann <9659253+EliasHolzmann@users.noreply.github.com>
Date: Sun, 12 Feb 2023 20:00:19 +0100
Subject: Fix: Some suggestions generated by the option_if_let_else lint did
 not compile

---
 clippy_lints/src/option_if_let_else.rs | 12 ++++++-----
 tests/ui/option_if_let_else.fixed      | 10 +++++++++
 tests/ui/option_if_let_else.rs         | 10 +++++++++
 tests/ui/option_if_let_else.stderr     | 39 +++++++++++++++++++++++++---------
 4 files changed, 56 insertions(+), 15 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/option_if_let_else.rs b/clippy_lints/src/option_if_let_else.rs
index bbbcda069c5..aa6d4004268 100644
--- a/clippy_lints/src/option_if_let_else.rs
+++ b/clippy_lints/src/option_if_let_else.rs
@@ -122,7 +122,7 @@ fn try_get_option_occurrence<'tcx>(
         ExprKind::Unary(UnOp::Deref, inner_expr) | ExprKind::AddrOf(_, _, inner_expr) => inner_expr,
         _ => expr,
     };
-    let inner_pat = try_get_inner_pat(cx, pat)?;
+    let (inner_pat, is_result) = try_get_inner_pat_and_is_result(cx, pat)?;
     if_chain! {
         if let PatKind::Binding(bind_annotation, _, id, None) = inner_pat.kind;
         if let Some(some_captures) = can_move_expr_to_closure(cx, if_then);
@@ -176,7 +176,7 @@ fn try_get_option_occurrence<'tcx>(
                 ),
                 none_expr: format!(
                     "{}{}",
-                    if method_sugg == "map_or" { "" } else { "|| " },
+                    if method_sugg == "map_or" { "" } else if is_result { "|_| " } else { "|| "},
                     Sugg::hir_with_context(cx, none_body, ctxt, "..", &mut app),
                 ),
             });
@@ -186,11 +186,13 @@ fn try_get_option_occurrence<'tcx>(
     None
 }
 
-fn try_get_inner_pat<'tcx>(cx: &LateContext<'tcx>, pat: &Pat<'tcx>) -> Option<&'tcx Pat<'tcx>> {
+fn try_get_inner_pat_and_is_result<'tcx>(cx: &LateContext<'tcx>, pat: &Pat<'tcx>) -> Option<(&'tcx Pat<'tcx>, bool)> {
     if let PatKind::TupleStruct(ref qpath, [inner_pat], ..) = pat.kind {
         let res = cx.qpath_res(qpath, pat.hir_id);
-        if is_res_lang_ctor(cx, res, OptionSome) || is_res_lang_ctor(cx, res, ResultOk) {
-            return Some(inner_pat);
+        if is_res_lang_ctor(cx, res, OptionSome) {
+            return Some((inner_pat, false));
+        } else if is_res_lang_ctor(cx, res, ResultOk) {
+            return Some((inner_pat, true));
         }
     }
     None
diff --git a/tests/ui/option_if_let_else.fixed b/tests/ui/option_if_let_else.fixed
index 57f341e0276..2b8ce5477cc 100644
--- a/tests/ui/option_if_let_else.fixed
+++ b/tests/ui/option_if_let_else.fixed
@@ -92,6 +92,15 @@ fn pattern_to_vec(pattern: &str) -> Vec<String> {
         .collect::<Vec<_>>()
 }
 
+// #10335
+fn test_result_impure_else(variable: Result<u32, &str>) {
+    variable.map_or_else(|_| {
+        println!("Err");
+    }, |binding| {
+        println!("Ok {binding}");
+    })
+}
+
 enum DummyEnum {
     One(u8),
     Two,
@@ -113,6 +122,7 @@ fn main() {
     unop_bad(&None, None);
     let _ = longer_body(None);
     test_map_or_else(None);
+    test_result_impure_else(Ok(42));
     let _ = negative_tests(None);
     let _ = impure_else(None);
 
diff --git a/tests/ui/option_if_let_else.rs b/tests/ui/option_if_let_else.rs
index 19f9f704517..cfbec8cb27d 100644
--- a/tests/ui/option_if_let_else.rs
+++ b/tests/ui/option_if_let_else.rs
@@ -115,6 +115,15 @@ fn pattern_to_vec(pattern: &str) -> Vec<String> {
         .collect::<Vec<_>>()
 }
 
+// #10335
+fn test_result_impure_else(variable: Result<u32, &str>) {
+    if let Ok(binding) = variable {
+        println!("Ok {binding}");
+    } else {
+        println!("Err");
+    }
+}
+
 enum DummyEnum {
     One(u8),
     Two,
@@ -136,6 +145,7 @@ fn main() {
     unop_bad(&None, None);
     let _ = longer_body(None);
     test_map_or_else(None);
+    test_result_impure_else(Ok(42));
     let _ = negative_tests(None);
     let _ = impure_else(None);
 
diff --git a/tests/ui/option_if_let_else.stderr b/tests/ui/option_if_let_else.stderr
index f5e4affb672..91d52fc79b8 100644
--- a/tests/ui/option_if_let_else.stderr
+++ b/tests/ui/option_if_let_else.stderr
@@ -152,14 +152,33 @@ LL | |                 vec![s.to_string()]
 LL | |             }
    | |_____________^ help: try: `s.find('.').map_or_else(|| vec![s.to_string()], |idx| vec![s[..idx].to_string(), s[idx..].to_string()])`
 
+error: use Option::map_or_else instead of an if let/else
+  --> $DIR/option_if_let_else.rs:120:5
+   |
+LL | /     if let Ok(binding) = variable {
+LL | |         println!("Ok {binding}");
+LL | |     } else {
+LL | |         println!("Err");
+LL | |     }
+   | |_____^
+   |
+help: try
+   |
+LL ~     variable.map_or_else(|_| {
+LL +         println!("Err");
+LL +     }, |binding| {
+LL +         println!("Ok {binding}");
+LL +     })
+   |
+
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:133:13
+  --> $DIR/option_if_let_else.rs:142:13
    |
 LL |     let _ = if let Some(x) = optional { x + 2 } else { 5 };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `optional.map_or(5, |x| x + 2)`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:142:13
+  --> $DIR/option_if_let_else.rs:152:13
    |
 LL |       let _ = if let Some(x) = Some(0) {
    |  _____________^
@@ -181,13 +200,13 @@ LL ~         });
    |
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:170:13
+  --> $DIR/option_if_let_else.rs:180:13
    |
 LL |     let _ = if let Some(x) = Some(0) { s.len() + x } else { s.len() };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Some(0).map_or(s.len(), |x| s.len() + x)`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:174:13
+  --> $DIR/option_if_let_else.rs:184:13
    |
 LL |       let _ = if let Some(x) = Some(0) {
    |  _____________^
@@ -207,7 +226,7 @@ LL ~     });
    |
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:213:13
+  --> $DIR/option_if_let_else.rs:223:13
    |
 LL |       let _ = match s {
    |  _____________^
@@ -217,7 +236,7 @@ LL | |     };
    | |_____^ help: try: `s.map_or(1, |string| string.len())`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:217:13
+  --> $DIR/option_if_let_else.rs:227:13
    |
 LL |       let _ = match Some(10) {
    |  _____________^
@@ -227,7 +246,7 @@ LL | |     };
    | |_____^ help: try: `Some(10).map_or(5, |a| a + 1)`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:223:13
+  --> $DIR/option_if_let_else.rs:233:13
    |
 LL |       let _ = match res {
    |  _____________^
@@ -237,7 +256,7 @@ LL | |     };
    | |_____^ help: try: `res.map_or(1, |a| a + 1)`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:227:13
+  --> $DIR/option_if_let_else.rs:237:13
    |
 LL |       let _ = match res {
    |  _____________^
@@ -247,10 +266,10 @@ LL | |     };
    | |_____^ help: try: `res.map_or(1, |a| a + 1)`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:231:13
+  --> $DIR/option_if_let_else.rs:241:13
    |
 LL |     let _ = if let Ok(a) = res { a + 1 } else { 5 };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `res.map_or(5, |a| a + 1)`
 
-error: aborting due to 20 previous errors
+error: aborting due to 21 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 2a4571d959615cf8e2859a0bb8af66cbd9a8af83 Mon Sep 17 00:00:00 2001
From: blyxyas <blyxyas@gmail.com>
Date: Sat, 6 May 2023 08:38:47 +0200
Subject: Minimizing changes

---
 clippy_lints/src/lib.rs                            |  24 +++-
 clippy_lints/src/utils/conf.rs                     |   5 +-
 .../src/utils/internal_lints/metadata_collector.rs | 111 +---------------
 clippy_lints/src/utils/mod.rs                      | 140 +++++++++++++++++++++
 4 files changed, 168 insertions(+), 112 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 657a3d1f431..8b88dab6ae6 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -331,8 +331,11 @@ mod zero_div_zero;
 mod zero_sized_map_values;
 // end lints modules, do not remove this comment, it’s used in `update_lints`
 
-use crate::utils::conf::{format_error, TryConf};
 pub use crate::utils::conf::{lookup_conf_file, Conf};
+use crate::utils::{
+    conf::{format_error, metadata::get_configuration_metadata, TryConf},
+    FindAll,
+};
 
 /// Register all pre expansion lints
 ///
@@ -388,7 +391,7 @@ pub fn read_conf(sess: &Session, path: &io::Result<(Option<PathBuf>, Vec<String>
     conf
 }
 
-#[derive(Default)]
+#[derive(Default)] //~ ERROR no such field
 struct RegistrationGroups {
     all: Vec<LintId>,
     cargo: Vec<LintId>,
@@ -471,7 +474,22 @@ pub(crate) struct LintInfo {
 pub fn explain(name: &str) {
     let target = format!("clippy::{}", name.to_ascii_uppercase());
     match declared_lints::LINTS.iter().find(|info| info.lint.name == target) {
-        Some(info) => print!("{}", info.explanation),
+        Some(info) => {
+            println!("{}", info.explanation);
+            // Check if the lint has configuration
+            let mdconf = get_configuration_metadata();
+            if let Some(config_vec_positions) = mdconf
+                .iter()
+                .find_all(|cconf| cconf.lints.contains(&info.lint.name_lower()[8..].to_owned()))
+            {
+                // If it has, print it
+                println!("### Configuration for {}:", info.lint.name_lower());
+                for position in config_vec_positions {
+                    let conf = &mdconf[position];
+                    println!("    - {}: {} (default: {})", conf.name, conf.doc, conf.default);
+                }
+            }
+        },
         None => println!("unknown lint: {name}"),
     }
 }
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 5f05d971fce..f6de66bb514 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -174,16 +174,15 @@ macro_rules! define_Conf {
             }
         }
 
-        #[cfg(feature = "internal")]
         pub mod metadata {
-            use crate::utils::internal_lints::metadata_collector::ClippyConfiguration;
+            use crate::utils::ClippyConfiguration;
 
             macro_rules! wrap_option {
                 () => (None);
                 ($x:literal) => (Some($x));
             }
 
-            pub(crate) fn get_configuration_metadata() -> Vec<ClippyConfiguration> {
+            pub fn get_configuration_metadata() -> Vec<ClippyConfiguration> {
                 vec![
                     $(
                         {
diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index 3d0d4a52511..7a1cd3effae 100644
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -8,7 +8,11 @@
 //! a simple mistake)
 
 use crate::renamed_lints::RENAMED_LINTS;
-use crate::utils::internal_lints::lint_without_lint_pass::{extract_clippy_version_value, is_lint_ref_type};
+use crate::utils::{
+    collect_configs,
+    internal_lints::lint_without_lint_pass::{extract_clippy_version_value, is_lint_ref_type},
+    ClippyConfiguration,
+};
 
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::ty::{match_type, walk_ptrs_ty_depth};
@@ -520,111 +524,6 @@ impl Serialize for ApplicabilityInfo {
     }
 }
 
-// ==================================================================
-// Configuration
-// ==================================================================
-#[derive(Debug, Clone, Default)]
-pub struct ClippyConfiguration {
-    name: String,
-    config_type: &'static str,
-    default: String,
-    lints: Vec<String>,
-    doc: String,
-    #[allow(dead_code)]
-    deprecation_reason: Option<&'static str>,
-}
-
-impl ClippyConfiguration {
-    pub fn new(
-        name: &'static str,
-        config_type: &'static str,
-        default: String,
-        doc_comment: &'static str,
-        deprecation_reason: Option<&'static str>,
-    ) -> Self {
-        let (lints, doc) = parse_config_field_doc(doc_comment)
-            .unwrap_or_else(|| (vec![], "[ERROR] MALFORMED DOC COMMENT".to_string()));
-
-        Self {
-            name: to_kebab(name),
-            lints,
-            doc,
-            config_type,
-            default,
-            deprecation_reason,
-        }
-    }
-
-    fn to_markdown_paragraph(&self) -> String {
-        format!(
-            "### {}\n{}\n\n**Default Value:** `{}` (`{}`)\n\n{}\n\n",
-            self.name,
-            self.doc
-                .lines()
-                .map(|line| line.strip_prefix("    ").unwrap_or(line))
-                .join("\n"),
-            self.default,
-            self.config_type,
-            self.lints
-                .iter()
-                .map(|name| name.to_string().split_whitespace().next().unwrap().to_string())
-                .map(|name| format!("* [{name}](https://rust-lang.github.io/rust-clippy/master/index.html#{name})"))
-                .join("\n"),
-        )
-    }
-
-    fn to_markdown_table_entry(&self) -> String {
-        format!("| [{}](#{}) | `{}` |", self.name, self.name, self.default)
-    }
-}
-
-fn collect_configs() -> Vec<ClippyConfiguration> {
-    crate::utils::conf::metadata::get_configuration_metadata()
-}
-
-/// This parses the field documentation of the config struct.
-///
-/// ```rust, ignore
-/// parse_config_field_doc(cx, "Lint: LINT_NAME_1, LINT_NAME_2. Papa penguin, papa penguin")
-/// ```
-///
-/// Would yield:
-/// ```rust, ignore
-/// Some(["lint_name_1", "lint_name_2"], "Papa penguin, papa penguin")
-/// ```
-fn parse_config_field_doc(doc_comment: &str) -> Option<(Vec<String>, String)> {
-    const DOC_START: &str = " Lint: ";
-    if_chain! {
-        if doc_comment.starts_with(DOC_START);
-        if let Some(split_pos) = doc_comment.find('.');
-        then {
-            let mut doc_comment = doc_comment.to_string();
-            let mut documentation = doc_comment.split_off(split_pos);
-
-            // Extract lints
-            doc_comment.make_ascii_lowercase();
-            let lints: Vec<String> = doc_comment
-                .split_off(DOC_START.len())
-                .split(", ")
-                .map(str::to_string)
-                .collect();
-
-            // Format documentation correctly
-            // split off leading `.` from lint name list and indent for correct formatting
-            documentation = documentation.trim_start_matches('.').trim().replace("\n ", "\n    ");
-
-            Some((lints, documentation))
-        } else {
-            None
-        }
-    }
-}
-
-/// Transforms a given `snake_case_string` to a tasty `kebab-case-string`
-fn to_kebab(config_name: &str) -> String {
-    config_name.replace('_', "-")
-}
-
 impl fmt::Display for ClippyConfiguration {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> fmt::Result {
         writeln!(
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index dc647af264c..d3ea7cafa80 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -4,3 +4,143 @@ pub mod dump_hir;
 pub mod format_args_collector;
 #[cfg(feature = "internal")]
 pub mod internal_lints;
+#[cfg(feature = "internal")]
+use itertools::Itertools;
+
+/// Transforms a given `snake_case_string` to a tasty `kebab-case-string`
+fn to_kebab(config_name: &str) -> String {
+    config_name.replace('_', "-")
+}
+
+// ==================================================================
+// Configuration
+// ==================================================================
+#[derive(Debug, Clone, Default)] //~ ERROR no such field
+pub struct ClippyConfiguration {
+    pub name: String,
+    #[allow(dead_code)]
+    config_type: &'static str,
+    pub default: String,
+    pub lints: Vec<String>,
+    pub doc: String,
+    #[allow(dead_code)]
+    deprecation_reason: Option<&'static str>,
+}
+
+impl ClippyConfiguration {
+    pub fn new(
+        name: &'static str,
+        config_type: &'static str,
+        default: String,
+        doc_comment: &'static str,
+        deprecation_reason: Option<&'static str>,
+    ) -> Self {
+        let (lints, doc) = parse_config_field_doc(doc_comment)
+            .unwrap_or_else(|| (vec![], "[ERROR] MALFORMED DOC COMMENT".to_string()));
+
+        Self {
+            name: to_kebab(name),
+            lints,
+            doc,
+            config_type,
+            default,
+            deprecation_reason,
+        }
+    }
+
+    #[cfg(feature = "internal")]
+    fn to_markdown_paragraph(&self) -> String {
+        format!(
+            "### {}\n{}\n\n**Default Value:** `{}` (`{}`)\n\n{}\n\n",
+            self.name,
+            self.doc
+                .lines()
+                .map(|line| line.strip_prefix("    ").unwrap_or(line))
+                .join("\n"),
+            self.default,
+            self.config_type,
+            self.lints
+                .iter()
+                .map(|name| name.to_string().split_whitespace().next().unwrap().to_string())
+                .map(|name| format!("* [{name}](https://rust-lang.github.io/rust-clippy/master/index.html#{name})"))
+                .join("\n"),
+        )
+    }
+
+    #[cfg(feature = "internal")]
+    fn to_markdown_table_entry(&self) -> String {
+        format!("| [{}](#{}) | `{}` |", self.name, self.name, self.default)
+    }
+}
+
+#[cfg(feature = "internal")]
+fn collect_configs() -> Vec<ClippyConfiguration> {
+    crate::utils::conf::metadata::get_configuration_metadata()
+}
+
+/// This parses the field documentation of the config struct.
+///
+/// ```rust, ignore
+/// parse_config_field_doc(cx, "Lint: LINT_NAME_1, LINT_NAME_2. Papa penguin, papa penguin")
+/// ```
+///
+/// Would yield:
+/// ```rust, ignore
+/// Some(["lint_name_1", "lint_name_2"], "Papa penguin, papa penguin")
+/// ```
+fn parse_config_field_doc(doc_comment: &str) -> Option<(Vec<String>, String)> {
+    const DOC_START: &str = " Lint: ";
+    if_chain! {
+        if doc_comment.starts_with(DOC_START);
+        if let Some(split_pos) = doc_comment.find('.');
+        then {
+            let mut doc_comment = doc_comment.to_string();
+            let mut documentation = doc_comment.split_off(split_pos);
+
+            // Extract lints
+            doc_comment.make_ascii_lowercase();
+            let lints: Vec<String> = doc_comment
+                .split_off(DOC_START.len())
+                .split(", ")
+                .map(str::to_string)
+                .collect();
+
+            // Format documentation correctly
+            // split off leading `.` from lint name list and indent for correct formatting
+            documentation = documentation.trim_start_matches('.').trim().replace("\n ", "\n    ");
+
+            Some((lints, documentation))
+        } else {
+            None
+        }
+    }
+}
+
+// Shamelessly stolen from find_all (https://github.com/nectariner/find_all)
+pub trait FindAll: Iterator + Sized {
+    fn find_all<P>(&mut self, predicate: P) -> Option<Vec<usize>>
+    where
+        P: FnMut(&Self::Item) -> bool;
+}
+
+impl<I> FindAll for I
+where
+    I: Iterator,
+{
+    fn find_all<P>(&mut self, mut predicate: P) -> Option<Vec<usize>>
+    where
+        P: FnMut(&Self::Item) -> bool,
+    {
+        let mut occurences = Vec::<usize>::default();
+        for (index, element) in self.enumerate() {
+            if predicate(&element) {
+                occurences.push(index);
+            }
+        }
+
+        match occurences.len() {
+            0 => None,
+            _ => Some(occurences),
+        }
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From f4b8cb1b28eedee1b3c0404a9718087d2ee71434 Mon Sep 17 00:00:00 2001
From: Daniel Hofstetter <daniel.hofstetter@42dh.com>
Date: Sat, 6 May 2023 16:21:45 +0200
Subject: Add missing word "are"

---
 clippy_lints/src/lines_filter_map_ok.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lines_filter_map_ok.rs b/clippy_lints/src/lines_filter_map_ok.rs
index bba9bb445a7..09b2032e20f 100644
--- a/clippy_lints/src/lines_filter_map_ok.rs
+++ b/clippy_lints/src/lines_filter_map_ok.rs
@@ -25,7 +25,7 @@ declare_clippy_lint! {
     ///
     /// ### Known problems
     /// This lint suggests replacing `filter_map()` or `flat_map()` applied to a `Lines`
-    /// instance in all cases. There two cases where the suggestion might not be
+    /// instance in all cases. There are two cases where the suggestion might not be
     /// appropriate or necessary:
     ///
     /// - If the `Lines` instance can never produce any error, or if an error is produced
-- 
cgit 1.4.1-3-g733a5


From 9e535f62888b691e50ae8d3cc32af45f2c82528d Mon Sep 17 00:00:00 2001
From: disco07 <koneenok@outlook.fr>
Date: Sun, 7 May 2023 00:59:52 +0200
Subject: fix conflict with matches macro

---
 clippy_lints/src/matches/match_like_matches.rs     | 28 +++++++++++++++++++++-
 .../src/matches/redundant_pattern_match.rs         |  1 -
 tests/ui/match_expr_like_matches_macro.fixed       |  2 +-
 tests/ui/match_expr_like_matches_macro.stderr      |  8 +++----
 4 files changed, 32 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/match_like_matches.rs b/clippy_lints/src/matches/match_like_matches.rs
index 33bc20dad6b..107c2cd844b 100644
--- a/clippy_lints/src/matches/match_like_matches.rs
+++ b/clippy_lints/src/matches/match_like_matches.rs
@@ -1,10 +1,12 @@
+use super::REDUNDANT_PATTERN_MATCHING;
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::is_lint_allowed;
 use clippy_utils::is_wild;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::span_contains_comment;
 use rustc_ast::{Attribute, LitKind};
 use rustc_errors::Applicability;
-use rustc_hir::{Arm, BorrowKind, Expr, ExprKind, Guard, Pat};
+use rustc_hir::{Arm, BorrowKind, Expr, ExprKind, Guard, Pat, PatKind, QPath};
 use rustc_lint::{LateContext, LintContext};
 use rustc_middle::ty;
 use rustc_span::source_map::Spanned;
@@ -99,6 +101,14 @@ where
                 }
             }
 
+            for arm in iter_without_last.clone() {
+                if let Some(pat) = arm.1 {
+                    if !is_lint_allowed(cx, REDUNDANT_PATTERN_MATCHING, pat.hir_id) && is_some(pat.kind) {
+                        return false;
+                    }
+                }
+            }
+
             // The suggestion may be incorrect, because some arms can have `cfg` attributes
             // evaluated into `false` and so such arms will be stripped before.
             let mut applicability = Applicability::MaybeIncorrect;
@@ -170,3 +180,19 @@ fn find_bool_lit(ex: &ExprKind<'_>) -> Option<bool> {
         _ => None,
     }
 }
+
+fn is_some(path_kind: PatKind<'_>) -> bool {
+    match path_kind {
+        PatKind::TupleStruct(ref path_left, patterns, _) if is_wild(&patterns[0]) => match path_left {
+            QPath::Resolved(_, path) => {
+                let name = path.segments[0].ident;
+                if name.as_str() == "Some" {
+                    return true;
+                }
+                return false;
+            },
+            _ => false,
+        },
+        _ => false,
+    }
+}
diff --git a/clippy_lints/src/matches/redundant_pattern_match.rs b/clippy_lints/src/matches/redundant_pattern_match.rs
index 53480a257c5..2ad11995325 100644
--- a/clippy_lints/src/matches/redundant_pattern_match.rs
+++ b/clippy_lints/src/matches/redundant_pattern_match.rs
@@ -186,7 +186,6 @@ fn find_sugg_for_if_let<'tcx>(
 }
 
 pub(super) fn check_match<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, op: &Expr<'_>, arms: &[Arm<'_>]) {
-    //eprintln!("{:#?}", expr);
     if arms.len() == 2 {
         let node_pair = (&arms[0].pat.kind, &arms[1].pat.kind);
         let found_good_method = match node_pair {
diff --git a/tests/ui/match_expr_like_matches_macro.fixed b/tests/ui/match_expr_like_matches_macro.fixed
index 7215660da67..60f59066173 100644
--- a/tests/ui/match_expr_like_matches_macro.fixed
+++ b/tests/ui/match_expr_like_matches_macro.fixed
@@ -15,7 +15,7 @@ fn main() {
     let _y = matches!(x, Some(0));
 
     // Lint
-    let _w = matches!(x, Some(_));
+    let _w = x.is_some();
 
     // Turn into is_none
     let _z = x.is_none();
diff --git a/tests/ui/match_expr_like_matches_macro.stderr b/tests/ui/match_expr_like_matches_macro.stderr
index 46f67ef4900..b72fe10b748 100644
--- a/tests/ui/match_expr_like_matches_macro.stderr
+++ b/tests/ui/match_expr_like_matches_macro.stderr
@@ -10,7 +10,7 @@ LL | |     };
    |
    = note: `-D clippy::match-like-matches-macro` implied by `-D warnings`
 
-error: match expression looks like `matches!` macro
+error: redundant pattern matching, consider using `is_some()`
   --> $DIR/match_expr_like_matches_macro.rs:21:14
    |
 LL |       let _w = match x {
@@ -18,7 +18,9 @@ LL |       let _w = match x {
 LL | |         Some(_) => true,
 LL | |         _ => false,
 LL | |     };
-   | |_____^ help: try this: `matches!(x, Some(_))`
+   | |_____^ help: try this: `x.is_some()`
+   |
+   = note: `-D clippy::redundant-pattern-matching` implied by `-D warnings`
 
 error: redundant pattern matching, consider using `is_none()`
   --> $DIR/match_expr_like_matches_macro.rs:27:14
@@ -29,8 +31,6 @@ LL | |         Some(_) => false,
 LL | |         None => true,
 LL | |     };
    | |_____^ help: try this: `x.is_none()`
-   |
-   = note: `-D clippy::redundant-pattern-matching` implied by `-D warnings`
 
 error: match expression looks like `matches!` macro
   --> $DIR/match_expr_like_matches_macro.rs:33:15
-- 
cgit 1.4.1-3-g733a5


From 630f31ce5ed38d13baf6cd16f26f1251183521c0 Mon Sep 17 00:00:00 2001
From: disco07 <koneenok@outlook.fr>
Date: Sun, 7 May 2023 02:45:11 +0200
Subject: fix conflict with matches macro

---
 clippy_lints/src/matches/match_like_matches.rs     |  15 +-
 .../src/matches/redundant_pattern_match.rs         | 254 ++++++++++-----------
 2 files changed, 133 insertions(+), 136 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/match_like_matches.rs b/clippy_lints/src/matches/match_like_matches.rs
index 107c2cd844b..fe3b440ff58 100644
--- a/clippy_lints/src/matches/match_like_matches.rs
+++ b/clippy_lints/src/matches/match_like_matches.rs
@@ -183,15 +183,12 @@ fn find_bool_lit(ex: &ExprKind<'_>) -> Option<bool> {
 
 fn is_some(path_kind: PatKind<'_>) -> bool {
     match path_kind {
-        PatKind::TupleStruct(ref path_left, patterns, _) if is_wild(&patterns[0]) => match path_left {
-            QPath::Resolved(_, path) => {
-                let name = path.segments[0].ident;
-                if name.as_str() == "Some" {
-                    return true;
-                }
-                return false;
-            },
-            _ => false,
+        PatKind::TupleStruct(QPath::Resolved(_, path), patterns, _) if is_wild(&patterns[0]) => {
+            let name = path.segments[0].ident;
+            if name.as_str() == "Some" {
+                return true;
+            }
+            false
         },
         _ => false,
     }
diff --git a/clippy_lints/src/matches/redundant_pattern_match.rs b/clippy_lints/src/matches/redundant_pattern_match.rs
index 2ad11995325..2ac6d9938eb 100644
--- a/clippy_lints/src/matches/redundant_pattern_match.rs
+++ b/clippy_lints/src/matches/redundant_pattern_match.rs
@@ -188,132 +188,7 @@ fn find_sugg_for_if_let<'tcx>(
 pub(super) fn check_match<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, op: &Expr<'_>, arms: &[Arm<'_>]) {
     if arms.len() == 2 {
         let node_pair = (&arms[0].pat.kind, &arms[1].pat.kind);
-        let found_good_method = match node_pair {
-            (
-                PatKind::TupleStruct(ref path_left, patterns_left, _),
-                PatKind::TupleStruct(ref path_right, patterns_right, _),
-            ) if patterns_left.len() == 1 && patterns_right.len() == 1 => {
-                if let (PatKind::Wild, PatKind::Wild) = (&patterns_left[0].kind, &patterns_right[0].kind) {
-                    find_good_method_for_match(
-                        cx,
-                        arms,
-                        path_left,
-                        path_right,
-                        Item::Lang(ResultOk),
-                        Item::Lang(ResultErr),
-                        "is_ok()",
-                        "is_err()",
-                    )
-                    .or_else(|| {
-                        find_good_method_for_match(
-                            cx,
-                            arms,
-                            path_left,
-                            path_right,
-                            Item::Diag(sym::IpAddr, sym!(V4)),
-                            Item::Diag(sym::IpAddr, sym!(V6)),
-                            "is_ipv4()",
-                            "is_ipv6()",
-                        )
-                    })
-                } else {
-                    None
-                }
-            },
-            (PatKind::TupleStruct(ref path_left, patterns, _), PatKind::Path(ref path_right))
-            | (PatKind::Path(ref path_left), PatKind::TupleStruct(ref path_right, patterns, _))
-                if patterns.len() == 1 =>
-            {
-                if let PatKind::Wild = patterns[0].kind {
-                    find_good_method_for_match(
-                        cx,
-                        arms,
-                        path_left,
-                        path_right,
-                        Item::Lang(OptionSome),
-                        Item::Lang(OptionNone),
-                        "is_some()",
-                        "is_none()",
-                    )
-                    .or_else(|| {
-                        find_good_method_for_match(
-                            cx,
-                            arms,
-                            path_left,
-                            path_right,
-                            Item::Lang(PollReady),
-                            Item::Lang(PollPending),
-                            "is_ready()",
-                            "is_pending()",
-                        )
-                    })
-                } else {
-                    None
-                }
-            },
-            (PatKind::TupleStruct(ref path_left, patterns, _), PatKind::Wild) if patterns.len() == 1 => {
-                if let PatKind::Wild = patterns[0].kind {
-                    let ident = match path_left {
-                        QPath::Resolved(_, path) => {
-                            let name = path.segments[0].ident;
-                            Some(name)
-                        },
-                        _ => None,
-                    };
-                    if let Some(name) = ident {
-                        match name.as_str() {
-                            "Ok" => find_good_method_for_matches_macro(
-                                cx,
-                                arms,
-                                path_left,
-                                Item::Lang(ResultOk),
-                                "is_ok()",
-                                "is_err()",
-                            ),
-                            "Some" => find_good_method_for_matches_macro(
-                                cx,
-                                arms,
-                                path_left,
-                                Item::Lang(OptionSome),
-                                "is_some()",
-                                "is_none()",
-                            ),
-                            _ => None,
-                        }
-                    } else {
-                        None
-                    }
-                } else {
-                    None
-                }
-            },
-            (PatKind::Path(ref path_left), PatKind::Wild) => {
-                let ident = match path_left {
-                    QPath::Resolved(_, path) => {
-                        let name = path.segments[0].ident;
-                        Some(name)
-                    },
-                    _ => None,
-                };
-
-                if let Some(name) = ident {
-                    match name.as_str() {
-                        "None" => find_good_method_for_matches_macro(
-                            cx,
-                            arms,
-                            path_left,
-                            Item::Lang(OptionNone),
-                            "is_none()",
-                            "is_some()",
-                        ),
-                        _ => None,
-                    }
-                } else {
-                    None
-                }
-            },
-            _ => None,
-        };
+        let found_good_method = found_good_method(cx, arms, node_pair);
 
         if let Some(good_method) = found_good_method {
             let span = expr.span.to(op.span);
@@ -339,6 +214,132 @@ pub(super) fn check_match<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, op
     }
 }
 
+fn found_good_method<'a>(
+    cx: &LateContext<'_>,
+    arms: &[Arm<'_>],
+    node: (&PatKind<'_>, &PatKind<'_>),
+) -> Option<&'a str> {
+    match node {
+        (
+            PatKind::TupleStruct(ref path_left, patterns_left, _),
+            PatKind::TupleStruct(ref path_right, patterns_right, _),
+        ) if patterns_left.len() == 1 && patterns_right.len() == 1 => {
+            if let (PatKind::Wild, PatKind::Wild) = (&patterns_left[0].kind, &patterns_right[0].kind) {
+                find_good_method_for_match(
+                    cx,
+                    arms,
+                    path_left,
+                    path_right,
+                    Item::Lang(ResultOk),
+                    Item::Lang(ResultErr),
+                    "is_ok()",
+                    "is_err()",
+                )
+                .or_else(|| {
+                    find_good_method_for_match(
+                        cx,
+                        arms,
+                        path_left,
+                        path_right,
+                        Item::Diag(sym::IpAddr, sym!(V4)),
+                        Item::Diag(sym::IpAddr, sym!(V6)),
+                        "is_ipv4()",
+                        "is_ipv6()",
+                    )
+                })
+            } else {
+                None
+            }
+        },
+        (PatKind::TupleStruct(ref path_left, patterns, _), PatKind::Path(ref path_right))
+        | (PatKind::Path(ref path_left), PatKind::TupleStruct(ref path_right, patterns, _))
+            if patterns.len() == 1 =>
+        {
+            if let PatKind::Wild = patterns[0].kind {
+                find_good_method_for_match(
+                    cx,
+                    arms,
+                    path_left,
+                    path_right,
+                    Item::Lang(OptionSome),
+                    Item::Lang(OptionNone),
+                    "is_some()",
+                    "is_none()",
+                )
+                .or_else(|| {
+                    find_good_method_for_match(
+                        cx,
+                        arms,
+                        path_left,
+                        path_right,
+                        Item::Lang(PollReady),
+                        Item::Lang(PollPending),
+                        "is_ready()",
+                        "is_pending()",
+                    )
+                })
+            } else {
+                None
+            }
+        },
+        (PatKind::TupleStruct(ref path_left, patterns, _), PatKind::Wild) if patterns.len() == 1 => {
+            if let PatKind::Wild = patterns[0].kind {
+                get_good_method(cx, arms, path_left)
+            } else {
+                None
+            }
+        },
+        (PatKind::Path(ref path_left), PatKind::Wild) => {
+            if let Some(name) = get_ident(path_left) {
+                match name.as_str() {
+                    "None" => find_good_method_for_matches_macro(
+                        cx,
+                        arms,
+                        path_left,
+                        Item::Lang(OptionNone),
+                        "is_none()",
+                        "is_some()",
+                    ),
+                    _ => None,
+                }
+            } else {
+                None
+            }
+        },
+        _ => None,
+    }
+}
+
+fn get_ident(path: &QPath<'_>) -> Option<rustc_span::symbol::Ident> {
+    match path {
+        QPath::Resolved(_, path) => {
+            let name = path.segments[0].ident;
+            Some(name)
+        },
+        _ => None,
+    }
+}
+
+fn get_good_method<'a>(cx: &LateContext<'_>, arms: &[Arm<'_>], path_left: &QPath<'_>) -> Option<&'a str> {
+    if let Some(name) = get_ident(path_left) {
+        return match name.as_str() {
+            "Ok" => {
+                find_good_method_for_matches_macro(cx, arms, path_left, Item::Lang(ResultOk), "is_ok()", "is_err()")
+            },
+            "Some" => find_good_method_for_matches_macro(
+                cx,
+                arms,
+                path_left,
+                Item::Lang(OptionSome),
+                "is_some()",
+                "is_none()",
+            ),
+            _ => None,
+        };
+    }
+    None
+}
+
 #[derive(Clone, Copy)]
 enum Item {
     Lang(LangItem),
@@ -406,7 +407,6 @@ fn find_good_method_for_match<'a>(
     }
 }
 
-#[expect(clippy::too_many_arguments)]
 fn find_good_method_for_matches_macro<'a>(
     cx: &LateContext<'_>,
     arms: &[Arm<'_>],
-- 
cgit 1.4.1-3-g733a5


From 450a22f2dc18949ba2db96570dc5270060fabd43 Mon Sep 17 00:00:00 2001
From: disco07 <koneenok@outlook.fr>
Date: Sun, 7 May 2023 02:56:46 +0200
Subject: fix error test

---
 clippy_lints/src/matches/match_like_matches.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/match_like_matches.rs b/clippy_lints/src/matches/match_like_matches.rs
index fe3b440ff58..438d1437562 100644
--- a/clippy_lints/src/matches/match_like_matches.rs
+++ b/clippy_lints/src/matches/match_like_matches.rs
@@ -185,7 +185,7 @@ fn is_some(path_kind: PatKind<'_>) -> bool {
     match path_kind {
         PatKind::TupleStruct(QPath::Resolved(_, path), patterns, _) if is_wild(&patterns[0]) => {
             let name = path.segments[0].ident;
-            if name.as_str() == "Some" {
+            if name.name == rustc_span::sym::Some {
                 return true;
             }
             false
-- 
cgit 1.4.1-3-g733a5


From fb6bf1ebf66497386ea4c90a953b7b287ae19706 Mon Sep 17 00:00:00 2001
From: disco07 <koneenok@outlook.fr>
Date: Sun, 7 May 2023 08:12:36 +0200
Subject: update a func

---
 .../src/matches/redundant_pattern_match.rs         | 26 ++++++++--------------
 1 file changed, 9 insertions(+), 17 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/redundant_pattern_match.rs b/clippy_lints/src/matches/redundant_pattern_match.rs
index 2ac6d9938eb..28478987821 100644
--- a/clippy_lints/src/matches/redundant_pattern_match.rs
+++ b/clippy_lints/src/matches/redundant_pattern_match.rs
@@ -289,23 +289,7 @@ fn found_good_method<'a>(
                 None
             }
         },
-        (PatKind::Path(ref path_left), PatKind::Wild) => {
-            if let Some(name) = get_ident(path_left) {
-                match name.as_str() {
-                    "None" => find_good_method_for_matches_macro(
-                        cx,
-                        arms,
-                        path_left,
-                        Item::Lang(OptionNone),
-                        "is_none()",
-                        "is_some()",
-                    ),
-                    _ => None,
-                }
-            } else {
-                None
-            }
-        },
+        (PatKind::Path(ref path_left), PatKind::Wild) => get_good_method(cx, arms, path_left),
         _ => None,
     }
 }
@@ -334,6 +318,14 @@ fn get_good_method<'a>(cx: &LateContext<'_>, arms: &[Arm<'_>], path_left: &QPath
                 "is_some()",
                 "is_none()",
             ),
+            "None" => find_good_method_for_matches_macro(
+                cx,
+                arms,
+                path_left,
+                Item::Lang(OptionNone),
+                "is_none()",
+                "is_some()",
+            ),
             _ => None,
         };
     }
-- 
cgit 1.4.1-3-g733a5


From 5c8a00923bc435cec37820c32768871b9e8a9ca1 Mon Sep 17 00:00:00 2001
From: John Kelly <johnharrykelly@gmail.com>
Date: Sun, 7 May 2023 10:10:44 +0100
Subject: Comments

---
 clippy_lints/src/trait_bounds.rs | 16 ++++++++++------
 1 file changed, 10 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/trait_bounds.rs b/clippy_lints/src/trait_bounds.rs
index 5acd44dccaf..c4e4410e9fd 100644
--- a/clippy_lints/src/trait_bounds.rs
+++ b/clippy_lints/src/trait_bounds.rs
@@ -174,15 +174,11 @@ impl<'tcx> LateLintPass<'tcx> for TraitBounds {
             if let TyKind::TraitObject(bounds, ..) = mut_ty.ty.kind;
             if bounds.len() > 2;
             then {
-                let mut bounds_span = bounds[0].span;
-
-                for bound in bounds.iter().skip(1) {
-                    bounds_span = bounds_span.to(bound.span);
-                }
-
                 let mut seen_def_ids = FxHashSet::default();
                 let mut fixed_traits = Vec::new();
 
+                // Iterate the bounds and add them to our seen hash
+                // If we haven't yet seen it, add it to the fixed traits
                 for bound in bounds.iter() {
                     let Some(def_id) = bound.trait_ref.trait_def_id() else { continue; };
 
@@ -193,7 +189,15 @@ impl<'tcx> LateLintPass<'tcx> for TraitBounds {
                     }
                 }
 
+                // If the number added to fixed (which are not duplicates) isn't the same as the number found,
+                // there must be 1 or more duplicates
                 if bounds.len() != fixed_traits.len() {
+                    let mut bounds_span = bounds[0].span;
+
+                    for bound in bounds.iter().skip(1) {
+                        bounds_span = bounds_span.to(bound.span);
+                    }
+
                     let fixed_trait_snippet = fixed_traits
                         .iter()
                         .filter_map(|b| snippet_opt(cx, b.span))
-- 
cgit 1.4.1-3-g733a5


From 394b4c1906ed8eb0484f70a7697b452dbb8fa483 Mon Sep 17 00:00:00 2001
From: Renato Lochetti <renato.lochetti@gmail.com>
Date: Sun, 7 May 2023 12:35:17 +0100
Subject: Ignore `borrow_deref_ref` warnings in code from procedural macros.

---
 clippy_lints/src/borrow_deref_ref.rs |  6 ++++--
 tests/ui/borrow_deref_ref.fixed      | 15 +++++++++++++++
 tests/ui/borrow_deref_ref.rs         | 15 +++++++++++++++
 tests/ui/borrow_deref_ref.stderr     |  6 +++---
 4 files changed, 37 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/borrow_deref_ref.rs b/clippy_lints/src/borrow_deref_ref.rs
index c4520d00392..814108ed8a7 100644
--- a/clippy_lints/src/borrow_deref_ref.rs
+++ b/clippy_lints/src/borrow_deref_ref.rs
@@ -1,5 +1,6 @@
 use crate::reference::DEREF_ADDROF;
 use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::is_from_proc_macro;
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::implements_trait;
 use clippy_utils::{get_parent_expr, is_lint_allowed};
@@ -47,8 +48,8 @@ declare_clippy_lint! {
 
 declare_lint_pass!(BorrowDerefRef => [BORROW_DEREF_REF]);
 
-impl LateLintPass<'_> for BorrowDerefRef {
-    fn check_expr(&mut self, cx: &LateContext<'_>, e: &rustc_hir::Expr<'_>) {
+impl<'tcx> LateLintPass<'tcx> for BorrowDerefRef {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &rustc_hir::Expr<'tcx>) {
         if_chain! {
             if !e.span.from_expansion();
             if let ExprKind::AddrOf(_, Mutability::Not, addrof_target) = e.kind;
@@ -58,6 +59,7 @@ impl LateLintPass<'_> for BorrowDerefRef {
             if !matches!(deref_target.kind, ExprKind::Unary(UnOp::Deref, ..) );
             let ref_ty = cx.typeck_results().expr_ty(deref_target);
             if let ty::Ref(_, inner_ty, Mutability::Not) = ref_ty.kind();
+            if !is_from_proc_macro(cx, e);
             then{
 
                 if let Some(parent_expr) = get_parent_expr(cx, e){
diff --git a/tests/ui/borrow_deref_ref.fixed b/tests/ui/borrow_deref_ref.fixed
index 165e4bc8272..75526461792 100644
--- a/tests/ui/borrow_deref_ref.fixed
+++ b/tests/ui/borrow_deref_ref.fixed
@@ -1,7 +1,11 @@
 //@run-rustfix
+//@aux-build: proc_macros.rs
 
 #![allow(dead_code, unused_variables)]
 
+extern crate proc_macros;
+use proc_macros::with_span;
+
 fn main() {}
 
 mod should_lint {
@@ -47,6 +51,17 @@ mod should_not_lint2 {
     }
 }
 
+with_span!(
+    span
+
+    fn just_returning(x: &u32) -> &u32 {
+        x
+    }
+
+    fn dont_lint_proc_macro() {
+        let a = &mut &*just_returning(&12);
+    }
+);
 // this mod explains why we should not lint `& &* (&T)`
 mod false_negative {
     fn foo() {
diff --git a/tests/ui/borrow_deref_ref.rs b/tests/ui/borrow_deref_ref.rs
index 66c8d69bef9..e319d365f7e 100644
--- a/tests/ui/borrow_deref_ref.rs
+++ b/tests/ui/borrow_deref_ref.rs
@@ -1,7 +1,11 @@
 //@run-rustfix
+//@aux-build: proc_macros.rs
 
 #![allow(dead_code, unused_variables)]
 
+extern crate proc_macros;
+use proc_macros::with_span;
+
 fn main() {}
 
 mod should_lint {
@@ -47,6 +51,17 @@ mod should_not_lint2 {
     }
 }
 
+with_span!(
+    span
+
+    fn just_returning(x: &u32) -> &u32 {
+        x
+    }
+
+    fn dont_lint_proc_macro() {
+        let a = &mut &*just_returning(&12);
+    }
+);
 // this mod explains why we should not lint `& &* (&T)`
 mod false_negative {
     fn foo() {
diff --git a/tests/ui/borrow_deref_ref.stderr b/tests/ui/borrow_deref_ref.stderr
index d72de37c69f..1e47cda6796 100644
--- a/tests/ui/borrow_deref_ref.stderr
+++ b/tests/ui/borrow_deref_ref.stderr
@@ -1,5 +1,5 @@
 error: deref on an immutable reference
-  --> $DIR/borrow_deref_ref.rs:10:17
+  --> $DIR/borrow_deref_ref.rs:14:17
    |
 LL |         let b = &*a;
    |                 ^^^ help: if you would like to reborrow, try removing `&*`: `a`
@@ -7,13 +7,13 @@ LL |         let b = &*a;
    = note: `-D clippy::borrow-deref-ref` implied by `-D warnings`
 
 error: deref on an immutable reference
-  --> $DIR/borrow_deref_ref.rs:12:22
+  --> $DIR/borrow_deref_ref.rs:16:22
    |
 LL |         let b = &mut &*bar(&12);
    |                      ^^^^^^^^^^ help: if you would like to reborrow, try removing `&*`: `bar(&12)`
 
 error: deref on an immutable reference
-  --> $DIR/borrow_deref_ref.rs:55:23
+  --> $DIR/borrow_deref_ref.rs:70:23
    |
 LL |         let addr_y = &&*x as *const _ as usize; // assert ok
    |                       ^^^ help: if you would like to reborrow, try removing `&*`: `x`
-- 
cgit 1.4.1-3-g733a5


From 56e8e1a27da1a204a5ed6ace2132c09abe49178b Mon Sep 17 00:00:00 2001
From: NotAPenguin <michiel.vandeginste@gmail.com>
Date: Mon, 8 May 2023 13:20:33 +0200
Subject: new lint: clippy::ref_patterns

---
 CHANGELOG.md                       |  1 +
 clippy_lints/src/declared_lints.rs |  1 +
 clippy_lints/src/lib.rs            |  2 ++
 clippy_lints/src/misc.rs           | 11 +++++++++-
 clippy_lints/src/ref_patterns.rs   | 44 ++++++++++++++++++++++++++++++++++++++
 tests/ui/ref_patterns.rs           | 19 ++++++++++++++++
 tests/ui/ref_patterns.stderr       | 27 +++++++++++++++++++++++
 7 files changed, 104 insertions(+), 1 deletion(-)
 create mode 100644 clippy_lints/src/ref_patterns.rs
 create mode 100644 tests/ui/ref_patterns.rs
 create mode 100644 tests/ui/ref_patterns.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index ebf5b58a586..85d451a87d0 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4978,6 +4978,7 @@ Released 2018-09-13
 [`ref_binding_to_reference`]: https://rust-lang.github.io/rust-clippy/master/index.html#ref_binding_to_reference
 [`ref_in_deref`]: https://rust-lang.github.io/rust-clippy/master/index.html#ref_in_deref
 [`ref_option_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#ref_option_ref
+[`ref_patterns`]: https://rust-lang.github.io/rust-clippy/master/index.html#ref_patterns
 [`regex_macro`]: https://rust-lang.github.io/rust-clippy/master/index.html#regex_macro
 [`repeat_once`]: https://rust-lang.github.io/rust-clippy/master/index.html#repeat_once
 [`replace_consts`]: https://rust-lang.github.io/rust-clippy/master/index.html#replace_consts
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 79d0f6f3607..6614b99713a 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -539,6 +539,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::redundant_slicing::REDUNDANT_SLICING_INFO,
     crate::redundant_static_lifetimes::REDUNDANT_STATIC_LIFETIMES_INFO,
     crate::ref_option_ref::REF_OPTION_REF_INFO,
+    crate::ref_patterns::REF_PATTERNS_INFO,
     crate::reference::DEREF_ADDROF_INFO,
     crate::regex::INVALID_REGEX_INFO,
     crate::regex::TRIVIAL_REGEX_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 3517842a01e..766a701fad8 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -266,6 +266,7 @@ mod redundant_pub_crate;
 mod redundant_slicing;
 mod redundant_static_lifetimes;
 mod ref_option_ref;
+mod ref_patterns;
 mod reference;
 mod regex;
 mod return_self_not_must_use;
@@ -971,6 +972,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(manual_slice_size_calculation::ManualSliceSizeCalculation));
     store.register_early_pass(|| Box::new(suspicious_doc_comments::SuspiciousDocComments));
     store.register_late_pass(|_| Box::new(items_after_test_module::ItemsAfterTestModule));
+    store.register_early_pass(|| Box::new(ref_patterns::RefPatterns));
     store.register_late_pass(|_| Box::new(default_constructed_unit_structs::DefaultConstructedUnitStructs));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
diff --git a/clippy_lints/src/misc.rs b/clippy_lints/src/misc.rs
index 3752b9a946f..303f0125690 100644
--- a/clippy_lints/src/misc.rs
+++ b/clippy_lints/src/misc.rs
@@ -16,9 +16,12 @@ use rustc_span::source_map::{ExpnKind, Span};
 
 use clippy_utils::sugg::Sugg;
 use clippy_utils::{
-    get_parent_expr, in_constant, is_integer_literal, is_no_std_crate, iter_input_pats, last_path_segment, SpanlessEq,
+    get_parent_expr, in_constant, is_integer_literal, is_lint_allowed, is_no_std_crate, iter_input_pats,
+    last_path_segment, SpanlessEq,
 };
 
+use crate::ref_patterns::REF_PATTERNS;
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for function arguments and let bindings denoted as
@@ -162,6 +165,10 @@ impl<'tcx> LateLintPass<'tcx> for LintPass {
             return;
         }
         for arg in iter_input_pats(decl, body) {
+            // Do not emit if clippy::ref_patterns is not allowed to avoid having two lints for the same issue.
+            if !is_lint_allowed(cx, REF_PATTERNS, arg.pat.hir_id) {
+                return;
+            }
             if let PatKind::Binding(BindingAnnotation(ByRef::Yes, _), ..) = arg.pat.kind {
                 span_lint(
                     cx,
@@ -180,6 +187,8 @@ impl<'tcx> LateLintPass<'tcx> for LintPass {
             if let StmtKind::Local(local) = stmt.kind;
             if let PatKind::Binding(BindingAnnotation(ByRef::Yes, mutabl), .., name, None) = local.pat.kind;
             if let Some(init) = local.init;
+            // Do not emit if clippy::ref_patterns is not allowed to avoid having two lints for the same issue.
+            if is_lint_allowed(cx, REF_PATTERNS, local.pat.hir_id);
             then {
                 let ctxt = local.span.ctxt();
                 let mut app = Applicability::MachineApplicable;
diff --git a/clippy_lints/src/ref_patterns.rs b/clippy_lints/src/ref_patterns.rs
new file mode 100644
index 00000000000..b1530eed1c1
--- /dev/null
+++ b/clippy_lints/src/ref_patterns.rs
@@ -0,0 +1,44 @@
+use clippy_utils::diagnostics::span_lint_and_help;
+use rustc_ast::ast::{BindingAnnotation, Pat, PatKind};
+use rustc_lint::{EarlyContext, EarlyLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usages of the `ref` keyword.
+    /// ### Why is this bad?
+    /// The `ref` keyword can be confusing for people unfamiliar with it, and often
+    /// it is more concise to use `&` instead.
+    /// ### Example
+    /// ```rust
+    /// let opt = Some(5);
+    /// if let Some(ref foo) = opt {}
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// let opt = Some(5);
+    /// if let Some(foo) = &opt {}
+    /// ```
+    #[clippy::version = "1.71.0"]
+    pub REF_PATTERNS,
+    restriction,
+    "use of a ref pattern, e.g. Some(ref value)"
+}
+declare_lint_pass!(RefPatterns => [REF_PATTERNS]);
+
+impl EarlyLintPass for RefPatterns {
+    fn check_pat(&mut self, cx: &EarlyContext<'_>, pat: &Pat) {
+        if let PatKind::Ident(BindingAnnotation::REF, _, _) = pat.kind
+                && !pat.span.from_expansion()
+        {
+            span_lint_and_help(
+                cx,
+                REF_PATTERNS,
+                pat.span,
+                "usage of ref pattern",
+                None,
+                "consider using `&` for clarity instead",
+            );
+        }
+    }
+}
diff --git a/tests/ui/ref_patterns.rs b/tests/ui/ref_patterns.rs
new file mode 100644
index 00000000000..c51e0bc76ef
--- /dev/null
+++ b/tests/ui/ref_patterns.rs
@@ -0,0 +1,19 @@
+#![allow(unused)]
+#![warn(clippy::ref_patterns)]
+
+fn use_in_pattern() {
+    let opt = Some(5);
+    match opt {
+        None => {},
+        Some(ref opt) => {},
+    }
+}
+
+fn use_in_binding() {
+    let x = 5;
+    let ref y = x;
+}
+
+fn use_in_parameter(ref x: i32) {}
+
+fn main() {}
diff --git a/tests/ui/ref_patterns.stderr b/tests/ui/ref_patterns.stderr
new file mode 100644
index 00000000000..aa007782683
--- /dev/null
+++ b/tests/ui/ref_patterns.stderr
@@ -0,0 +1,27 @@
+error: usage of ref pattern
+  --> $DIR/ref_patterns.rs:8:14
+   |
+LL |         Some(ref opt) => {},
+   |              ^^^^^^^
+   |
+   = help: consider using `&` for clarity instead
+   = note: `-D clippy::ref-patterns` implied by `-D warnings`
+
+error: usage of ref pattern
+  --> $DIR/ref_patterns.rs:14:9
+   |
+LL |     let ref y = x;
+   |         ^^^^^
+   |
+   = help: consider using `&` for clarity instead
+
+error: usage of ref pattern
+  --> $DIR/ref_patterns.rs:17:21
+   |
+LL | fn use_in_parameter(ref x: i32) {}
+   |                     ^^^^^
+   |
+   = help: consider using `&` for clarity instead
+
+error: aborting due to 3 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 54912410c71bd2547d008c0a5ba3c8c296f1ae74 Mon Sep 17 00:00:00 2001
From: blyxyas <blyxyas@gmail.com>
Date: Sun, 2 Apr 2023 01:51:44 +0200
Subject: `Wildcard_imports` ignore `test.rs` files

---
 clippy_lints/src/wildcard_imports.rs          | 22 +++++++++++++++++++++-
 tests/ui/wildcard_imports/another_file.fixed  | 18 ++++++++++++++++++
 tests/ui/wildcard_imports/another_file.rs     | 18 ++++++++++++++++++
 tests/ui/wildcard_imports/another_file.stderr | 10 ++++++++++
 tests/ui/wildcard_imports/test.rs             | 17 +++++++++++++++++
 tests/ui/wildcard_imports/tests.rs            | 17 +++++++++++++++++
 6 files changed, 101 insertions(+), 1 deletion(-)
 create mode 100644 tests/ui/wildcard_imports/another_file.fixed
 create mode 100644 tests/ui/wildcard_imports/another_file.rs
 create mode 100644 tests/ui/wildcard_imports/another_file.stderr
 create mode 100644 tests/ui/wildcard_imports/test.rs
 create mode 100644 tests/ui/wildcard_imports/tests.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/wildcard_imports.rs b/clippy_lints/src/wildcard_imports.rs
index 36f910c983f..f062cafdd4f 100644
--- a/clippy_lints/src/wildcard_imports.rs
+++ b/clippy_lints/src/wildcard_imports.rs
@@ -7,7 +7,8 @@ use rustc_hir::{
     def::{DefKind, Res},
     Item, ItemKind, PathSegment, UseKind,
 };
-use rustc_lint::{LateContext, LateLintPass};
+use rustc_hir::{HirId, Mod};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::ty;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::symbol::kw;
@@ -102,6 +103,7 @@ declare_clippy_lint! {
 pub struct WildcardImports {
     warn_on_all: bool,
     test_modules_deep: u32,
+    ignore: bool,
 }
 
 impl WildcardImports {
@@ -109,6 +111,7 @@ impl WildcardImports {
         Self {
             warn_on_all,
             test_modules_deep: 0,
+            ignore: false,
         }
     }
 }
@@ -116,7 +119,24 @@ impl WildcardImports {
 impl_lint_pass!(WildcardImports => [ENUM_GLOB_USE, WILDCARD_IMPORTS]);
 
 impl LateLintPass<'_> for WildcardImports {
+    fn check_mod(&mut self, cx: &LateContext<'_>, module: &Mod<'_>, _: HirId) {
+        let filename = cx
+            .sess()
+            .source_map()
+            .span_to_filename(module.spans.inner_span)
+            .display(rustc_span::FileNameDisplayPreference::Local)
+            .to_string();
+
+        if filename.ends_with("test.rs") || filename.ends_with("tests.rs") {
+            self.ignore = true;
+        }
+    }
+
     fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
+        if self.ignore {
+            return;
+        }
+
         if is_test_module_or_function(cx.tcx, item) {
             self.test_modules_deep = self.test_modules_deep.saturating_add(1);
         }
diff --git a/tests/ui/wildcard_imports/another_file.fixed b/tests/ui/wildcard_imports/another_file.fixed
new file mode 100644
index 00000000000..726808e598f
--- /dev/null
+++ b/tests/ui/wildcard_imports/another_file.fixed
@@ -0,0 +1,18 @@
+// run-rustfix
+#![warn(clippy::wildcard_imports)]
+#![allow(unused, clippy::unnecessary_wraps, clippy::let_unit_value)]
+
+// Test for #10580, the lint should **not** ignore it.
+
+fn foofoo() {}
+
+mod outer {
+    mod inner {
+        use super::super::foofoo;
+        fn barbar() {
+            let _ = foofoo();
+        }
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/wildcard_imports/another_file.rs b/tests/ui/wildcard_imports/another_file.rs
new file mode 100644
index 00000000000..057332ef706
--- /dev/null
+++ b/tests/ui/wildcard_imports/another_file.rs
@@ -0,0 +1,18 @@
+// run-rustfix
+#![warn(clippy::wildcard_imports)]
+#![allow(unused, clippy::unnecessary_wraps, clippy::let_unit_value)]
+
+// Test for #10580, the lint should **not** ignore it.
+
+fn foofoo() {}
+
+mod outer {
+    mod inner {
+        use super::super::*;
+        fn barbar() {
+            let _ = foofoo();
+        }
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/wildcard_imports/another_file.stderr b/tests/ui/wildcard_imports/another_file.stderr
new file mode 100644
index 00000000000..56923eff58b
--- /dev/null
+++ b/tests/ui/wildcard_imports/another_file.stderr
@@ -0,0 +1,10 @@
+error: usage of wildcard import
+  --> $DIR/another_file.rs:11:13
+   |
+LL |         use super::super::*;
+   |             ^^^^^^^^^^^^^^^ help: try: `super::super::foofoo`
+   |
+   = note: `-D clippy::wildcard-imports` implied by `-D warnings`
+
+error: aborting due to previous error
+
diff --git a/tests/ui/wildcard_imports/test.rs b/tests/ui/wildcard_imports/test.rs
new file mode 100644
index 00000000000..9029e5ba503
--- /dev/null
+++ b/tests/ui/wildcard_imports/test.rs
@@ -0,0 +1,17 @@
+#![warn(clippy::wildcard_imports)]
+#![allow(unused, clippy::unnecessary_wraps, clippy::let_unit_value)]
+
+// Test for #10580, the lint **should** not ignore it.
+
+fn foofoo() {}
+
+mod outer {
+    mod inner {
+        use super::super::*;
+        fn barbar() {
+            let _ = foofoo();
+        }
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/wildcard_imports/tests.rs b/tests/ui/wildcard_imports/tests.rs
new file mode 100644
index 00000000000..b7483853388
--- /dev/null
+++ b/tests/ui/wildcard_imports/tests.rs
@@ -0,0 +1,17 @@
+#![warn(clippy::wildcard_imports)]
+#![allow(unused, clippy::unnecessary_wraps, clippy::let_unit_value)]
+
+// Test for #10580, the lint **should** ignore it.
+
+fn foofoo() {}
+
+mod outer {
+    mod inner {
+        use super::super::*;
+        fn barbar() {
+            let _ = foofoo();
+        }
+    }
+}
+
+fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 5acc2993e74506780e0a20331f58e78e125aad92 Mon Sep 17 00:00:00 2001
From: blyxyas <blyxyas@gmail.com>
Date: Mon, 3 Apr 2023 14:16:46 +0200
Subject: Really mini minor irrelevant change for formatting

---
 clippy_lints/src/wildcard_imports.rs | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/wildcard_imports.rs b/clippy_lints/src/wildcard_imports.rs
index f062cafdd4f..53ab9e94631 100644
--- a/clippy_lints/src/wildcard_imports.rs
+++ b/clippy_lints/src/wildcard_imports.rs
@@ -127,9 +127,7 @@ impl LateLintPass<'_> for WildcardImports {
             .display(rustc_span::FileNameDisplayPreference::Local)
             .to_string();
 
-        if filename.ends_with("test.rs") || filename.ends_with("tests.rs") {
-            self.ignore = true;
-        }
+        self.ignore = filename.ends_with("test.rs") || filename.ends_with("tests.rs");
     }
 
     fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
-- 
cgit 1.4.1-3-g733a5


From ba0e7e88cb69587bc1e639509999d3f39ee0dae2 Mon Sep 17 00:00:00 2001
From: blyxyas <blyxyas@gmail.com>
Date: Wed, 5 Apr 2023 20:38:44 +0200
Subject: Now the lint ignores any crates with `--cfg test`

---
 clippy_lints/src/wildcard_imports.rs          | 14 ++++----------
 tests/ui/wildcard_imports/another_file.fixed  | 18 ------------------
 tests/ui/wildcard_imports/another_file.rs     | 18 ------------------
 tests/ui/wildcard_imports/another_file.stderr | 10 ----------
 tests/ui/wildcard_imports/test.rs             | 17 -----------------
 tests/ui/wildcard_imports/tests.rs            | 17 -----------------
 tests/ui/wildcard_imports_cfgtest.rs          | 19 +++++++++++++++++++
 7 files changed, 23 insertions(+), 90 deletions(-)
 delete mode 100644 tests/ui/wildcard_imports/another_file.fixed
 delete mode 100644 tests/ui/wildcard_imports/another_file.rs
 delete mode 100644 tests/ui/wildcard_imports/another_file.stderr
 delete mode 100644 tests/ui/wildcard_imports/test.rs
 delete mode 100644 tests/ui/wildcard_imports/tests.rs
 create mode 100644 tests/ui/wildcard_imports_cfgtest.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/wildcard_imports.rs b/clippy_lints/src/wildcard_imports.rs
index 53ab9e94631..0cae6e00a95 100644
--- a/clippy_lints/src/wildcard_imports.rs
+++ b/clippy_lints/src/wildcard_imports.rs
@@ -7,7 +7,6 @@ use rustc_hir::{
     def::{DefKind, Res},
     Item, ItemKind, PathSegment, UseKind,
 };
-use rustc_hir::{HirId, Mod};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::ty;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
@@ -119,15 +118,10 @@ impl WildcardImports {
 impl_lint_pass!(WildcardImports => [ENUM_GLOB_USE, WILDCARD_IMPORTS]);
 
 impl LateLintPass<'_> for WildcardImports {
-    fn check_mod(&mut self, cx: &LateContext<'_>, module: &Mod<'_>, _: HirId) {
-        let filename = cx
-            .sess()
-            .source_map()
-            .span_to_filename(module.spans.inner_span)
-            .display(rustc_span::FileNameDisplayPreference::Local)
-            .to_string();
-
-        self.ignore = filename.ends_with("test.rs") || filename.ends_with("tests.rs");
+    fn check_crate(&mut self, cx: &LateContext<'_>) {
+        if cx.sess().opts.test {
+            self.ignore = true;
+        }
     }
 
     fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
diff --git a/tests/ui/wildcard_imports/another_file.fixed b/tests/ui/wildcard_imports/another_file.fixed
deleted file mode 100644
index 726808e598f..00000000000
--- a/tests/ui/wildcard_imports/another_file.fixed
+++ /dev/null
@@ -1,18 +0,0 @@
-// run-rustfix
-#![warn(clippy::wildcard_imports)]
-#![allow(unused, clippy::unnecessary_wraps, clippy::let_unit_value)]
-
-// Test for #10580, the lint should **not** ignore it.
-
-fn foofoo() {}
-
-mod outer {
-    mod inner {
-        use super::super::foofoo;
-        fn barbar() {
-            let _ = foofoo();
-        }
-    }
-}
-
-fn main() {}
diff --git a/tests/ui/wildcard_imports/another_file.rs b/tests/ui/wildcard_imports/another_file.rs
deleted file mode 100644
index 057332ef706..00000000000
--- a/tests/ui/wildcard_imports/another_file.rs
+++ /dev/null
@@ -1,18 +0,0 @@
-// run-rustfix
-#![warn(clippy::wildcard_imports)]
-#![allow(unused, clippy::unnecessary_wraps, clippy::let_unit_value)]
-
-// Test for #10580, the lint should **not** ignore it.
-
-fn foofoo() {}
-
-mod outer {
-    mod inner {
-        use super::super::*;
-        fn barbar() {
-            let _ = foofoo();
-        }
-    }
-}
-
-fn main() {}
diff --git a/tests/ui/wildcard_imports/another_file.stderr b/tests/ui/wildcard_imports/another_file.stderr
deleted file mode 100644
index 56923eff58b..00000000000
--- a/tests/ui/wildcard_imports/another_file.stderr
+++ /dev/null
@@ -1,10 +0,0 @@
-error: usage of wildcard import
-  --> $DIR/another_file.rs:11:13
-   |
-LL |         use super::super::*;
-   |             ^^^^^^^^^^^^^^^ help: try: `super::super::foofoo`
-   |
-   = note: `-D clippy::wildcard-imports` implied by `-D warnings`
-
-error: aborting due to previous error
-
diff --git a/tests/ui/wildcard_imports/test.rs b/tests/ui/wildcard_imports/test.rs
deleted file mode 100644
index 9029e5ba503..00000000000
--- a/tests/ui/wildcard_imports/test.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-#![warn(clippy::wildcard_imports)]
-#![allow(unused, clippy::unnecessary_wraps, clippy::let_unit_value)]
-
-// Test for #10580, the lint **should** not ignore it.
-
-fn foofoo() {}
-
-mod outer {
-    mod inner {
-        use super::super::*;
-        fn barbar() {
-            let _ = foofoo();
-        }
-    }
-}
-
-fn main() {}
diff --git a/tests/ui/wildcard_imports/tests.rs b/tests/ui/wildcard_imports/tests.rs
deleted file mode 100644
index b7483853388..00000000000
--- a/tests/ui/wildcard_imports/tests.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-#![warn(clippy::wildcard_imports)]
-#![allow(unused, clippy::unnecessary_wraps, clippy::let_unit_value)]
-
-// Test for #10580, the lint **should** ignore it.
-
-fn foofoo() {}
-
-mod outer {
-    mod inner {
-        use super::super::*;
-        fn barbar() {
-            let _ = foofoo();
-        }
-    }
-}
-
-fn main() {}
diff --git a/tests/ui/wildcard_imports_cfgtest.rs b/tests/ui/wildcard_imports_cfgtest.rs
new file mode 100644
index 00000000000..a5e4e92b32c
--- /dev/null
+++ b/tests/ui/wildcard_imports_cfgtest.rs
@@ -0,0 +1,19 @@
+// compile-flags: --test
+
+#![warn(clippy::wildcard_imports)]
+#![allow(unused, clippy::unnecessary_wraps, clippy::let_unit_value)]
+
+// Test for #10580, the lint should ignore it because of the crate's cfg test flag.
+
+fn foofoo() {}
+
+mod outer {
+    mod inner {
+        use super::super::*;
+        fn barbar() {
+            let _ = foofoo();
+        }
+    }
+}
+
+fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 4c3e2ff2a40a54bc37669bbdb0861a50ec418ff3 Mon Sep 17 00:00:00 2001
From: blyxyas <blyxyas@gmail.com>
Date: Mon, 8 May 2023 18:38:41 +0200
Subject: Fix header

---
 clippy_lints/src/wildcard_imports.rs | 10 +---------
 tests/ui/wildcard_imports_cfgtest.rs |  2 +-
 2 files changed, 2 insertions(+), 10 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/wildcard_imports.rs b/clippy_lints/src/wildcard_imports.rs
index 0cae6e00a95..a9089fba3c5 100644
--- a/clippy_lints/src/wildcard_imports.rs
+++ b/clippy_lints/src/wildcard_imports.rs
@@ -102,7 +102,6 @@ declare_clippy_lint! {
 pub struct WildcardImports {
     warn_on_all: bool,
     test_modules_deep: u32,
-    ignore: bool,
 }
 
 impl WildcardImports {
@@ -110,7 +109,6 @@ impl WildcardImports {
         Self {
             warn_on_all,
             test_modules_deep: 0,
-            ignore: false,
         }
     }
 }
@@ -118,14 +116,8 @@ impl WildcardImports {
 impl_lint_pass!(WildcardImports => [ENUM_GLOB_USE, WILDCARD_IMPORTS]);
 
 impl LateLintPass<'_> for WildcardImports {
-    fn check_crate(&mut self, cx: &LateContext<'_>) {
-        if cx.sess().opts.test {
-            self.ignore = true;
-        }
-    }
-
     fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
-        if self.ignore {
+        if cx.sess().is_test_crate() {
             return;
         }
 
diff --git a/tests/ui/wildcard_imports_cfgtest.rs b/tests/ui/wildcard_imports_cfgtest.rs
index a5e4e92b32c..203c4e15b50 100644
--- a/tests/ui/wildcard_imports_cfgtest.rs
+++ b/tests/ui/wildcard_imports_cfgtest.rs
@@ -1,4 +1,4 @@
-// compile-flags: --test
+//@compile-flags: --test
 
 #![warn(clippy::wildcard_imports)]
 #![allow(unused, clippy::unnecessary_wraps, clippy::let_unit_value)]
-- 
cgit 1.4.1-3-g733a5


From b169bdb732c1a0751a32c4ede1c16a3bba3ffb09 Mon Sep 17 00:00:00 2001
From: John Kelly <johnharrykelly@gmail.com>
Date: Tue, 9 May 2023 10:06:38 +0100
Subject: Comments

---
 clippy_lints/src/trait_bounds.rs | 15 ++++++++++-----
 1 file changed, 10 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/trait_bounds.rs b/clippy_lints/src/trait_bounds.rs
index c4e4410e9fd..4ccda15068b 100644
--- a/clippy_lints/src/trait_bounds.rs
+++ b/clippy_lints/src/trait_bounds.rs
@@ -174,8 +174,13 @@ impl<'tcx> LateLintPass<'tcx> for TraitBounds {
             if let TyKind::TraitObject(bounds, ..) = mut_ty.ty.kind;
             if bounds.len() > 2;
             then {
+
+                // Build up a hash of every trait we've seen
+                // When we see a trait for the first time, add it to unique_traits
+                // so we can later use it to build a string of all traits exactly once, without duplicates
+
                 let mut seen_def_ids = FxHashSet::default();
-                let mut fixed_traits = Vec::new();
+                let mut unique_traits = Vec::new();
 
                 // Iterate the bounds and add them to our seen hash
                 // If we haven't yet seen it, add it to the fixed traits
@@ -185,20 +190,20 @@ impl<'tcx> LateLintPass<'tcx> for TraitBounds {
                     let new_trait = seen_def_ids.insert(def_id);
 
                     if new_trait {
-                        fixed_traits.push(bound);
+                        unique_traits.push(bound);
                     }
                 }
 
-                // If the number added to fixed (which are not duplicates) isn't the same as the number found,
+                // If the number of unique traits isn't the same as the number of traits in the bounds,
                 // there must be 1 or more duplicates
-                if bounds.len() != fixed_traits.len() {
+                if bounds.len() != unique_traits.len() {
                     let mut bounds_span = bounds[0].span;
 
                     for bound in bounds.iter().skip(1) {
                         bounds_span = bounds_span.to(bound.span);
                     }
 
-                    let fixed_trait_snippet = fixed_traits
+                    let fixed_trait_snippet = unique_traits
                         .iter()
                         .filter_map(|b| snippet_opt(cx, b.span))
                         .collect::<Vec<_>>()
-- 
cgit 1.4.1-3-g733a5


From 3e8fea612dd8ab8d03aaa264652ced97b800bb91 Mon Sep 17 00:00:00 2001
From: blyxyas <blyxyas@gmail.com>
Date: Tue, 9 May 2023 20:35:03 +0200
Subject: Fix config formatting, less indenting, more spacing

---
 clippy_lints/src/lib.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 8b88dab6ae6..091f30b78c8 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -483,10 +483,10 @@ pub fn explain(name: &str) {
                 .find_all(|cconf| cconf.lints.contains(&info.lint.name_lower()[8..].to_owned()))
             {
                 // If it has, print it
-                println!("### Configuration for {}:", info.lint.name_lower());
+                println!("### Configuration for {}:\n", info.lint.name_lower());
                 for position in config_vec_positions {
                     let conf = &mdconf[position];
-                    println!("    - {}: {} (default: {})", conf.name, conf.doc, conf.default);
+                    println!("  - {}: {} (default: {})", conf.name, conf.doc, conf.default);
                 }
             }
         },
-- 
cgit 1.4.1-3-g733a5


From 342ce3da05eea9f119ecf367052d681a386b1761 Mon Sep 17 00:00:00 2001
From: disco07 <koneenok@outlook.fr>
Date: Tue, 9 May 2023 20:50:47 +0200
Subject: fix reviewer comments

---
 clippy_lints/src/matches/match_like_matches.rs     |  7 +---
 .../src/matches/redundant_pattern_match.rs         |  6 ++-
 tests/ui/redundant_pattern_matching_option.fixed   | 13 +++---
 tests/ui/redundant_pattern_matching_option.rs      | 25 +++--------
 tests/ui/redundant_pattern_matching_option.stderr  | 48 +++-------------------
 tests/ui/redundant_pattern_matching_result.fixed   |  7 +++-
 tests/ui/redundant_pattern_matching_result.rs      | 15 ++++---
 tests/ui/redundant_pattern_matching_result.stderr  | 18 ++++----
 8 files changed, 47 insertions(+), 92 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/match_like_matches.rs b/clippy_lints/src/matches/match_like_matches.rs
index 438d1437562..0064619ef89 100644
--- a/clippy_lints/src/matches/match_like_matches.rs
+++ b/clippy_lints/src/matches/match_like_matches.rs
@@ -183,12 +183,9 @@ fn find_bool_lit(ex: &ExprKind<'_>) -> Option<bool> {
 
 fn is_some(path_kind: PatKind<'_>) -> bool {
     match path_kind {
-        PatKind::TupleStruct(QPath::Resolved(_, path), patterns, _) if is_wild(&patterns[0]) => {
+        PatKind::TupleStruct(QPath::Resolved(_, path), [first, ..], _) if is_wild(first) => {
             let name = path.segments[0].ident;
-            if name.name == rustc_span::sym::Some {
-                return true;
-            }
-            false
+            name.name == rustc_span::sym::Some
         },
         _ => false,
     }
diff --git a/clippy_lints/src/matches/redundant_pattern_match.rs b/clippy_lints/src/matches/redundant_pattern_match.rs
index 28478987821..7a06443f5d9 100644
--- a/clippy_lints/src/matches/redundant_pattern_match.rs
+++ b/clippy_lints/src/matches/redundant_pattern_match.rs
@@ -188,9 +188,8 @@ fn find_sugg_for_if_let<'tcx>(
 pub(super) fn check_match<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, op: &Expr<'_>, arms: &[Arm<'_>]) {
     if arms.len() == 2 {
         let node_pair = (&arms[0].pat.kind, &arms[1].pat.kind);
-        let found_good_method = found_good_method(cx, arms, node_pair);
 
-        if let Some(good_method) = found_good_method {
+        if let Some(good_method) = found_good_method(cx, arms, node_pair) {
             let span = expr.span.to(op.span);
             let result_expr = match &op.kind {
                 ExprKind::AddrOf(_, _, borrowed) => borrowed,
@@ -310,6 +309,9 @@ fn get_good_method<'a>(cx: &LateContext<'_>, arms: &[Arm<'_>], path_left: &QPath
             "Ok" => {
                 find_good_method_for_matches_macro(cx, arms, path_left, Item::Lang(ResultOk), "is_ok()", "is_err()")
             },
+            "Err" => {
+                find_good_method_for_matches_macro(cx, arms, path_left, Item::Lang(ResultErr), "is_err()", "is_ok()")
+            },
             "Some" => find_good_method_for_matches_macro(
                 cx,
                 arms,
diff --git a/tests/ui/redundant_pattern_matching_option.fixed b/tests/ui/redundant_pattern_matching_option.fixed
index c22a4d7456e..2f907f7ae3d 100644
--- a/tests/ui/redundant_pattern_matching_option.fixed
+++ b/tests/ui/redundant_pattern_matching_option.fixed
@@ -95,15 +95,12 @@ fn issue10726() {
 
     Some(42).is_none();
 
-    Some(42).is_none();
-
-    Some(42).is_some();
-
-    None::<()>.is_none();
-
-    None::<()>.is_none();
+    None::<()>.is_some();
 
     None::<()>.is_none();
 
-    None::<()>.is_some();
+    match Some(42) {
+        Some(21) => true,
+        _ => false,
+    };
 }
diff --git a/tests/ui/redundant_pattern_matching_option.rs b/tests/ui/redundant_pattern_matching_option.rs
index cd96e0d29a5..5e80a2b384b 100644
--- a/tests/ui/redundant_pattern_matching_option.rs
+++ b/tests/ui/redundant_pattern_matching_option.rs
@@ -111,29 +111,14 @@ fn issue10726() {
         _ => false,
     };
 
-    match Some(42) {
-        Some(_) => false,
-        _ => true,
-    };
-
     match Some(42) {
         None => true,
         _ => false,
     };
 
-    match Some(42) {
-        None => false,
-        _ => true,
-    };
-
     match None::<()> {
-        Some(_) => false,
-        _ => true,
-    };
-
-    match None::<()> {
-        Some(_) => false,
-        _ => true,
+        Some(_) => true,
+        _ => false,
     };
 
     match None::<()> {
@@ -141,8 +126,8 @@ fn issue10726() {
         _ => false,
     };
 
-    match None::<()> {
-        None => false,
-        _ => true,
+    match Some(42) {
+        Some(21) => true,
+        _ => false,
     };
 }
diff --git a/tests/ui/redundant_pattern_matching_option.stderr b/tests/ui/redundant_pattern_matching_option.stderr
index d397297074b..97de2f1c86f 100644
--- a/tests/ui/redundant_pattern_matching_option.stderr
+++ b/tests/ui/redundant_pattern_matching_option.stderr
@@ -161,49 +161,22 @@ error: redundant pattern matching, consider using `is_none()`
   --> $DIR/redundant_pattern_matching_option.rs:114:5
    |
 LL | /     match Some(42) {
-LL | |         Some(_) => false,
-LL | |         _ => true,
-LL | |     };
-   | |_____^ help: try this: `Some(42).is_none()`
-
-error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:119:5
-   |
-LL | /     match Some(42) {
 LL | |         None => true,
 LL | |         _ => false,
 LL | |     };
    | |_____^ help: try this: `Some(42).is_none()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/redundant_pattern_matching_option.rs:124:5
-   |
-LL | /     match Some(42) {
-LL | |         None => false,
-LL | |         _ => true,
-LL | |     };
-   | |_____^ help: try this: `Some(42).is_some()`
-
-error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:129:5
-   |
-LL | /     match None::<()> {
-LL | |         Some(_) => false,
-LL | |         _ => true,
-LL | |     };
-   | |_____^ help: try this: `None::<()>.is_none()`
-
-error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:134:5
+  --> $DIR/redundant_pattern_matching_option.rs:119:5
    |
 LL | /     match None::<()> {
-LL | |         Some(_) => false,
-LL | |         _ => true,
+LL | |         Some(_) => true,
+LL | |         _ => false,
 LL | |     };
-   | |_____^ help: try this: `None::<()>.is_none()`
+   | |_____^ help: try this: `None::<()>.is_some()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:139:5
+  --> $DIR/redundant_pattern_matching_option.rs:124:5
    |
 LL | /     match None::<()> {
 LL | |         None => true,
@@ -211,14 +184,5 @@ LL | |         _ => false,
 LL | |     };
    | |_____^ help: try this: `None::<()>.is_none()`
 
-error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/redundant_pattern_matching_option.rs:144:5
-   |
-LL | /     match None::<()> {
-LL | |         None => false,
-LL | |         _ => true,
-LL | |     };
-   | |_____^ help: try this: `None::<()>.is_some()`
-
-error: aborting due to 30 previous errors
+error: aborting due to 26 previous errors
 
diff --git a/tests/ui/redundant_pattern_matching_result.fixed b/tests/ui/redundant_pattern_matching_result.fixed
index a51e14a5b56..a242c38e833 100644
--- a/tests/ui/redundant_pattern_matching_result.fixed
+++ b/tests/ui/redundant_pattern_matching_result.fixed
@@ -114,7 +114,12 @@ fn issue10726() {
 
     Ok::<i32, i32>(42).is_err();
 
+    Err::<i32, i32>(42).is_ok();
+
     Err::<i32, i32>(42).is_err();
 
-    Err::<i32, i32>(42).is_ok();
+    match Ok::<i32, i32>(42) {
+        Ok(21) => true,
+        _ => false,
+    };
 }
diff --git a/tests/ui/redundant_pattern_matching_result.rs b/tests/ui/redundant_pattern_matching_result.rs
index 709e3d526a8..a4b0673ae5b 100644
--- a/tests/ui/redundant_pattern_matching_result.rs
+++ b/tests/ui/redundant_pattern_matching_result.rs
@@ -134,17 +134,22 @@ fn issue10726() {
     };
 
     match Ok::<i32, i32>(42) {
-        Ok(_) => false,
-        _ => true,
+        Err(_) => true,
+        _ => false,
     };
 
     match Err::<i32, i32>(42) {
-        Ok(_) => false,
-        _ => true,
+        Ok(_) => true,
+        _ => false,
     };
 
     match Err::<i32, i32>(42) {
-        Ok(_) => true,
+        Err(_) => true,
+        _ => false,
+    };
+
+    match Ok::<i32, i32>(42) {
+        Ok(21) => true,
         _ => false,
     };
 }
diff --git a/tests/ui/redundant_pattern_matching_result.stderr b/tests/ui/redundant_pattern_matching_result.stderr
index 0e8a983bf44..151a7440251 100644
--- a/tests/ui/redundant_pattern_matching_result.stderr
+++ b/tests/ui/redundant_pattern_matching_result.stderr
@@ -163,28 +163,28 @@ error: redundant pattern matching, consider using `is_err()`
   --> $DIR/redundant_pattern_matching_result.rs:136:5
    |
 LL | /     match Ok::<i32, i32>(42) {
-LL | |         Ok(_) => false,
-LL | |         _ => true,
+LL | |         Err(_) => true,
+LL | |         _ => false,
 LL | |     };
    | |_____^ help: try this: `Ok::<i32, i32>(42).is_err()`
 
-error: redundant pattern matching, consider using `is_err()`
+error: redundant pattern matching, consider using `is_ok()`
   --> $DIR/redundant_pattern_matching_result.rs:141:5
    |
 LL | /     match Err::<i32, i32>(42) {
-LL | |         Ok(_) => false,
-LL | |         _ => true,
+LL | |         Ok(_) => true,
+LL | |         _ => false,
 LL | |     };
-   | |_____^ help: try this: `Err::<i32, i32>(42).is_err()`
+   | |_____^ help: try this: `Err::<i32, i32>(42).is_ok()`
 
-error: redundant pattern matching, consider using `is_ok()`
+error: redundant pattern matching, consider using `is_err()`
   --> $DIR/redundant_pattern_matching_result.rs:146:5
    |
 LL | /     match Err::<i32, i32>(42) {
-LL | |         Ok(_) => true,
+LL | |         Err(_) => true,
 LL | |         _ => false,
 LL | |     };
-   | |_____^ help: try this: `Err::<i32, i32>(42).is_ok()`
+   | |_____^ help: try this: `Err::<i32, i32>(42).is_err()`
 
 error: aborting due to 26 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From b7a60547125fd1b0d06547ed038deb4a906afc67 Mon Sep 17 00:00:00 2001
From: blyxyas <blyxyas@gmail.com>
Date: Sun, 23 Apr 2023 01:42:32 +0200
Subject: Refresh Lint Configuration's looks

---
 book/src/lint_configuration.md                     | 504 ++++++++++++---------
 .../src/utils/internal_lints/metadata_collector.rs |  10 +-
 clippy_lints/src/utils/mod.rs                      |   9 +-
 3 files changed, 289 insertions(+), 234 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/book/src/lint_configuration.md b/book/src/lint_configuration.md
index 5646c9b1520..4c888b63793 100644
--- a/book/src/lint_configuration.md
+++ b/book/src/lint_configuration.md
@@ -3,63 +3,14 @@ This file is generated by `cargo collect-metadata`.
 Please use that command to update the file and do not edit it by hand.
 -->
 
-## Lint Configuration Options
-| <div style="width:290px">Option</div> | Default Value |
-|--|--|
-| [arithmetic-side-effects-allowed](#arithmetic-side-effects-allowed) | `{}` |
-| [arithmetic-side-effects-allowed-binary](#arithmetic-side-effects-allowed-binary) | `[]` |
-| [arithmetic-side-effects-allowed-unary](#arithmetic-side-effects-allowed-unary) | `{}` |
-| [avoid-breaking-exported-api](#avoid-breaking-exported-api) | `true` |
-| [msrv](#msrv) | `None` |
-| [cognitive-complexity-threshold](#cognitive-complexity-threshold) | `25` |
-| [disallowed-names](#disallowed-names) | `["foo", "baz", "quux"]` |
-| [semicolon-inside-block-ignore-singleline](#semicolon-inside-block-ignore-singleline) | `false` |
-| [semicolon-outside-block-ignore-multiline](#semicolon-outside-block-ignore-multiline) | `false` |
-| [doc-valid-idents](#doc-valid-idents) | `["KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "DirectX", "ECMAScript", "GPLv2", "GPLv3", "GitHub", "GitLab", "IPv4", "IPv6", "ClojureScript", "CoffeeScript", "JavaScript", "PureScript", "TypeScript", "NaN", "NaNs", "OAuth", "GraphQL", "OCaml", "OpenGL", "OpenMP", "OpenSSH", "OpenSSL", "OpenStreetMap", "OpenDNS", "WebGL", "TensorFlow", "TrueType", "iOS", "macOS", "FreeBSD", "TeX", "LaTeX", "BibTeX", "BibLaTeX", "MinGW", "CamelCase"]` |
-| [too-many-arguments-threshold](#too-many-arguments-threshold) | `7` |
-| [type-complexity-threshold](#type-complexity-threshold) | `250` |
-| [single-char-binding-names-threshold](#single-char-binding-names-threshold) | `4` |
-| [too-large-for-stack](#too-large-for-stack) | `200` |
-| [enum-variant-name-threshold](#enum-variant-name-threshold) | `3` |
-| [enum-variant-size-threshold](#enum-variant-size-threshold) | `200` |
-| [verbose-bit-mask-threshold](#verbose-bit-mask-threshold) | `1` |
-| [literal-representation-threshold](#literal-representation-threshold) | `16384` |
-| [trivial-copy-size-limit](#trivial-copy-size-limit) | `None` |
-| [pass-by-value-size-limit](#pass-by-value-size-limit) | `256` |
-| [too-many-lines-threshold](#too-many-lines-threshold) | `100` |
-| [array-size-threshold](#array-size-threshold) | `512000` |
-| [vec-box-size-threshold](#vec-box-size-threshold) | `4096` |
-| [max-trait-bounds](#max-trait-bounds) | `3` |
-| [max-struct-bools](#max-struct-bools) | `3` |
-| [max-fn-params-bools](#max-fn-params-bools) | `3` |
-| [warn-on-all-wildcard-imports](#warn-on-all-wildcard-imports) | `false` |
-| [disallowed-macros](#disallowed-macros) | `[]` |
-| [disallowed-methods](#disallowed-methods) | `[]` |
-| [disallowed-types](#disallowed-types) | `[]` |
-| [unreadable-literal-lint-fractions](#unreadable-literal-lint-fractions) | `true` |
-| [upper-case-acronyms-aggressive](#upper-case-acronyms-aggressive) | `false` |
-| [matches-for-let-else](#matches-for-let-else) | `WellKnownTypes` |
-| [cargo-ignore-publish](#cargo-ignore-publish) | `false` |
-| [standard-macro-braces](#standard-macro-braces) | `[]` |
-| [enforced-import-renames](#enforced-import-renames) | `[]` |
-| [allowed-scripts](#allowed-scripts) | `["Latin"]` |
-| [enable-raw-pointer-heuristic-for-send](#enable-raw-pointer-heuristic-for-send) | `true` |
-| [max-suggested-slice-pattern-length](#max-suggested-slice-pattern-length) | `3` |
-| [await-holding-invalid-types](#await-holding-invalid-types) | `[]` |
-| [max-include-file-size](#max-include-file-size) | `1000000` |
-| [allow-expect-in-tests](#allow-expect-in-tests) | `false` |
-| [allow-unwrap-in-tests](#allow-unwrap-in-tests) | `false` |
-| [allow-dbg-in-tests](#allow-dbg-in-tests) | `false` |
-| [allow-print-in-tests](#allow-print-in-tests) | `false` |
-| [large-error-threshold](#large-error-threshold) | `128` |
-| [ignore-interior-mutability](#ignore-interior-mutability) | `["bytes::Bytes"]` |
-| [allow-mixed-uninlined-format-args](#allow-mixed-uninlined-format-args) | `true` |
-| [suppress-restriction-lint-in-const](#suppress-restriction-lint-in-const) | `false` |
-| [missing-docs-in-crate-items](#missing-docs-in-crate-items) | `false` |
-| [future-size-threshold](#future-size-threshold) | `16384` |
-| [unnecessary-box-size](#unnecessary-box-size) | `128` |
-
-### arithmetic-side-effects-allowed
+# Lint Configuration Options
+
+The following list shows each configuration option, along with a description, its default value, an example
+and lints affected.
+
+---
+
+## `arithmetic-side-effects-allowed`
 Suppress checking of the passed type names in all types of operations.
 
 If a specific operation is desired, consider using `arithmetic_side_effects_allowed_binary` or `arithmetic_side_effects_allowed_unary` instead.
@@ -77,10 +28,12 @@ A type, say `SomeType`, listed in this configuration has the same behavior of
 
 **Default Value:** `{}` (`rustc_data_structures::fx::FxHashSet<String>`)
 
-* [arithmetic_side_effects](https://rust-lang.github.io/rust-clippy/master/index.html#arithmetic_side_effects)
+---
+**Affected lints:**
+* [`arithmetic_side_effects`](https://rust-lang.github.io/rust-clippy/master/index.html#arithmetic_side_effects)
 
 
-### arithmetic-side-effects-allowed-binary
+## `arithmetic-side-effects-allowed-binary`
 Suppress checking of the passed type pair names in binary operations like addition or
 multiplication.
 
@@ -98,10 +51,12 @@ arithmetic-side-effects-allowed-binary = [["SomeType" , "f32"], ["AnotherType",
 
 **Default Value:** `[]` (`Vec<[String; 2]>`)
 
-* [arithmetic_side_effects](https://rust-lang.github.io/rust-clippy/master/index.html#arithmetic_side_effects)
+---
+**Affected lints:**
+* [`arithmetic_side_effects`](https://rust-lang.github.io/rust-clippy/master/index.html#arithmetic_side_effects)
 
 
-### arithmetic-side-effects-allowed-unary
+## `arithmetic-side-effects-allowed-unary`
 Suppress checking of the passed type names in unary operations like "negation" (`-`).
 
 #### Example
@@ -112,116 +67,130 @@ arithmetic-side-effects-allowed-unary = ["SomeType", "AnotherType"]
 
 **Default Value:** `{}` (`rustc_data_structures::fx::FxHashSet<String>`)
 
-* [arithmetic_side_effects](https://rust-lang.github.io/rust-clippy/master/index.html#arithmetic_side_effects)
+---
+**Affected lints:**
+* [`arithmetic_side_effects`](https://rust-lang.github.io/rust-clippy/master/index.html#arithmetic_side_effects)
 
 
-### avoid-breaking-exported-api
+## `avoid-breaking-exported-api`
 Suppress lints whenever the suggested change would cause breakage for other crates.
 
 **Default Value:** `true` (`bool`)
 
-* [enum_variant_names](https://rust-lang.github.io/rust-clippy/master/index.html#enum_variant_names)
-* [large_types_passed_by_value](https://rust-lang.github.io/rust-clippy/master/index.html#large_types_passed_by_value)
-* [trivially_copy_pass_by_ref](https://rust-lang.github.io/rust-clippy/master/index.html#trivially_copy_pass_by_ref)
-* [unnecessary_wraps](https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_wraps)
-* [unused_self](https://rust-lang.github.io/rust-clippy/master/index.html#unused_self)
-* [upper_case_acronyms](https://rust-lang.github.io/rust-clippy/master/index.html#upper_case_acronyms)
-* [wrong_self_convention](https://rust-lang.github.io/rust-clippy/master/index.html#wrong_self_convention)
-* [box_collection](https://rust-lang.github.io/rust-clippy/master/index.html#box_collection)
-* [redundant_allocation](https://rust-lang.github.io/rust-clippy/master/index.html#redundant_allocation)
-* [rc_buffer](https://rust-lang.github.io/rust-clippy/master/index.html#rc_buffer)
-* [vec_box](https://rust-lang.github.io/rust-clippy/master/index.html#vec_box)
-* [option_option](https://rust-lang.github.io/rust-clippy/master/index.html#option_option)
-* [linkedlist](https://rust-lang.github.io/rust-clippy/master/index.html#linkedlist)
-* [rc_mutex](https://rust-lang.github.io/rust-clippy/master/index.html#rc_mutex)
-* [unnecessary_box_returns](https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_box_returns)
-
-
-### msrv
+---
+**Affected lints:**
+* [`enum_variant_names`](https://rust-lang.github.io/rust-clippy/master/index.html#enum_variant_names)
+* [`large_types_passed_by_value`](https://rust-lang.github.io/rust-clippy/master/index.html#large_types_passed_by_value)
+* [`trivially_copy_pass_by_ref`](https://rust-lang.github.io/rust-clippy/master/index.html#trivially_copy_pass_by_ref)
+* [`unnecessary_wraps`](https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_wraps)
+* [`unused_self`](https://rust-lang.github.io/rust-clippy/master/index.html#unused_self)
+* [`upper_case_acronyms`](https://rust-lang.github.io/rust-clippy/master/index.html#upper_case_acronyms)
+* [`wrong_self_convention`](https://rust-lang.github.io/rust-clippy/master/index.html#wrong_self_convention)
+* [`box_collection`](https://rust-lang.github.io/rust-clippy/master/index.html#box_collection)
+* [`redundant_allocation`](https://rust-lang.github.io/rust-clippy/master/index.html#redundant_allocation)
+* [`rc_buffer`](https://rust-lang.github.io/rust-clippy/master/index.html#rc_buffer)
+* [`vec_box`](https://rust-lang.github.io/rust-clippy/master/index.html#vec_box)
+* [`option_option`](https://rust-lang.github.io/rust-clippy/master/index.html#option_option)
+* [`linkedlist`](https://rust-lang.github.io/rust-clippy/master/index.html#linkedlist)
+* [`rc_mutex`](https://rust-lang.github.io/rust-clippy/master/index.html#rc_mutex)
+* [`unnecessary_box_returns`](https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_box_returns)
+
+
+## `msrv`
 The minimum rust version that the project supports
 
 **Default Value:** `None` (`Option<String>`)
 
-* [manual_split_once](https://rust-lang.github.io/rust-clippy/master/index.html#manual_split_once)
-* [manual_str_repeat](https://rust-lang.github.io/rust-clippy/master/index.html#manual_str_repeat)
-* [cloned_instead_of_copied](https://rust-lang.github.io/rust-clippy/master/index.html#cloned_instead_of_copied)
-* [redundant_field_names](https://rust-lang.github.io/rust-clippy/master/index.html#redundant_field_names)
-* [redundant_static_lifetimes](https://rust-lang.github.io/rust-clippy/master/index.html#redundant_static_lifetimes)
-* [filter_map_next](https://rust-lang.github.io/rust-clippy/master/index.html#filter_map_next)
-* [checked_conversions](https://rust-lang.github.io/rust-clippy/master/index.html#checked_conversions)
-* [manual_range_contains](https://rust-lang.github.io/rust-clippy/master/index.html#manual_range_contains)
-* [use_self](https://rust-lang.github.io/rust-clippy/master/index.html#use_self)
-* [mem_replace_with_default](https://rust-lang.github.io/rust-clippy/master/index.html#mem_replace_with_default)
-* [manual_non_exhaustive](https://rust-lang.github.io/rust-clippy/master/index.html#manual_non_exhaustive)
-* [option_as_ref_deref](https://rust-lang.github.io/rust-clippy/master/index.html#option_as_ref_deref)
-* [map_unwrap_or](https://rust-lang.github.io/rust-clippy/master/index.html#map_unwrap_or)
-* [match_like_matches_macro](https://rust-lang.github.io/rust-clippy/master/index.html#match_like_matches_macro)
-* [manual_strip](https://rust-lang.github.io/rust-clippy/master/index.html#manual_strip)
-* [missing_const_for_fn](https://rust-lang.github.io/rust-clippy/master/index.html#missing_const_for_fn)
-* [unnested_or_patterns](https://rust-lang.github.io/rust-clippy/master/index.html#unnested_or_patterns)
-* [from_over_into](https://rust-lang.github.io/rust-clippy/master/index.html#from_over_into)
-* [ptr_as_ptr](https://rust-lang.github.io/rust-clippy/master/index.html#ptr_as_ptr)
-* [if_then_some_else_none](https://rust-lang.github.io/rust-clippy/master/index.html#if_then_some_else_none)
-* [approx_constant](https://rust-lang.github.io/rust-clippy/master/index.html#approx_constant)
-* [deprecated_cfg_attr](https://rust-lang.github.io/rust-clippy/master/index.html#deprecated_cfg_attr)
-* [index_refutable_slice](https://rust-lang.github.io/rust-clippy/master/index.html#index_refutable_slice)
-* [map_clone](https://rust-lang.github.io/rust-clippy/master/index.html#map_clone)
-* [borrow_as_ptr](https://rust-lang.github.io/rust-clippy/master/index.html#borrow_as_ptr)
-* [manual_bits](https://rust-lang.github.io/rust-clippy/master/index.html#manual_bits)
-* [err_expect](https://rust-lang.github.io/rust-clippy/master/index.html#err_expect)
-* [cast_abs_to_unsigned](https://rust-lang.github.io/rust-clippy/master/index.html#cast_abs_to_unsigned)
-* [uninlined_format_args](https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args)
-* [manual_clamp](https://rust-lang.github.io/rust-clippy/master/index.html#manual_clamp)
-* [manual_let_else](https://rust-lang.github.io/rust-clippy/master/index.html#manual_let_else)
-* [unchecked_duration_subtraction](https://rust-lang.github.io/rust-clippy/master/index.html#unchecked_duration_subtraction)
-* [collapsible_str_replace](https://rust-lang.github.io/rust-clippy/master/index.html#collapsible_str_replace)
-* [seek_from_current](https://rust-lang.github.io/rust-clippy/master/index.html#seek_from_current)
-* [seek_rewind](https://rust-lang.github.io/rust-clippy/master/index.html#seek_rewind)
-* [unnecessary_lazy_evaluations](https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_lazy_evaluations)
-* [transmute_ptr_to_ref](https://rust-lang.github.io/rust-clippy/master/index.html#transmute_ptr_to_ref)
-* [almost_complete_range](https://rust-lang.github.io/rust-clippy/master/index.html#almost_complete_range)
-* [needless_borrow](https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow)
-* [derivable_impls](https://rust-lang.github.io/rust-clippy/master/index.html#derivable_impls)
-* [manual_is_ascii_check](https://rust-lang.github.io/rust-clippy/master/index.html#manual_is_ascii_check)
-* [manual_rem_euclid](https://rust-lang.github.io/rust-clippy/master/index.html#manual_rem_euclid)
-* [manual_retain](https://rust-lang.github.io/rust-clippy/master/index.html#manual_retain)
-
-
-### cognitive-complexity-threshold
+---
+**Affected lints:**
+* [`manual_split_once`](https://rust-lang.github.io/rust-clippy/master/index.html#manual_split_once)
+* [`manual_str_repeat`](https://rust-lang.github.io/rust-clippy/master/index.html#manual_str_repeat)
+* [`cloned_instead_of_copied`](https://rust-lang.github.io/rust-clippy/master/index.html#cloned_instead_of_copied)
+* [`redundant_field_names`](https://rust-lang.github.io/rust-clippy/master/index.html#redundant_field_names)
+* [`redundant_static_lifetimes`](https://rust-lang.github.io/rust-clippy/master/index.html#redundant_static_lifetimes)
+* [`filter_map_next`](https://rust-lang.github.io/rust-clippy/master/index.html#filter_map_next)
+* [`checked_conversions`](https://rust-lang.github.io/rust-clippy/master/index.html#checked_conversions)
+* [`manual_range_contains`](https://rust-lang.github.io/rust-clippy/master/index.html#manual_range_contains)
+* [`use_self`](https://rust-lang.github.io/rust-clippy/master/index.html#use_self)
+* [`mem_replace_with_default`](https://rust-lang.github.io/rust-clippy/master/index.html#mem_replace_with_default)
+* [`manual_non_exhaustive`](https://rust-lang.github.io/rust-clippy/master/index.html#manual_non_exhaustive)
+* [`option_as_ref_deref`](https://rust-lang.github.io/rust-clippy/master/index.html#option_as_ref_deref)
+* [`map_unwrap_or`](https://rust-lang.github.io/rust-clippy/master/index.html#map_unwrap_or)
+* [`match_like_matches_macro`](https://rust-lang.github.io/rust-clippy/master/index.html#match_like_matches_macro)
+* [`manual_strip`](https://rust-lang.github.io/rust-clippy/master/index.html#manual_strip)
+* [`missing_const_for_fn`](https://rust-lang.github.io/rust-clippy/master/index.html#missing_const_for_fn)
+* [`unnested_or_patterns`](https://rust-lang.github.io/rust-clippy/master/index.html#unnested_or_patterns)
+* [`from_over_into`](https://rust-lang.github.io/rust-clippy/master/index.html#from_over_into)
+* [`ptr_as_ptr`](https://rust-lang.github.io/rust-clippy/master/index.html#ptr_as_ptr)
+* [`if_then_some_else_none`](https://rust-lang.github.io/rust-clippy/master/index.html#if_then_some_else_none)
+* [`approx_constant`](https://rust-lang.github.io/rust-clippy/master/index.html#approx_constant)
+* [`deprecated_cfg_attr`](https://rust-lang.github.io/rust-clippy/master/index.html#deprecated_cfg_attr)
+* [`index_refutable_slice`](https://rust-lang.github.io/rust-clippy/master/index.html#index_refutable_slice)
+* [`map_clone`](https://rust-lang.github.io/rust-clippy/master/index.html#map_clone)
+* [`borrow_as_ptr`](https://rust-lang.github.io/rust-clippy/master/index.html#borrow_as_ptr)
+* [`manual_bits`](https://rust-lang.github.io/rust-clippy/master/index.html#manual_bits)
+* [`err_expect`](https://rust-lang.github.io/rust-clippy/master/index.html#err_expect)
+* [`cast_abs_to_unsigned`](https://rust-lang.github.io/rust-clippy/master/index.html#cast_abs_to_unsigned)
+* [`uninlined_format_args`](https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args)
+* [`manual_clamp`](https://rust-lang.github.io/rust-clippy/master/index.html#manual_clamp)
+* [`manual_let_else`](https://rust-lang.github.io/rust-clippy/master/index.html#manual_let_else)
+* [`unchecked_duration_subtraction`](https://rust-lang.github.io/rust-clippy/master/index.html#unchecked_duration_subtraction)
+* [`collapsible_str_replace`](https://rust-lang.github.io/rust-clippy/master/index.html#collapsible_str_replace)
+* [`seek_from_current`](https://rust-lang.github.io/rust-clippy/master/index.html#seek_from_current)
+* [`seek_rewind`](https://rust-lang.github.io/rust-clippy/master/index.html#seek_rewind)
+* [`unnecessary_lazy_evaluations`](https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_lazy_evaluations)
+* [`transmute_ptr_to_ref`](https://rust-lang.github.io/rust-clippy/master/index.html#transmute_ptr_to_ref)
+* [`almost_complete_range`](https://rust-lang.github.io/rust-clippy/master/index.html#almost_complete_range)
+* [`needless_borrow`](https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow)
+* [`derivable_impls`](https://rust-lang.github.io/rust-clippy/master/index.html#derivable_impls)
+* [`manual_is_ascii_check`](https://rust-lang.github.io/rust-clippy/master/index.html#manual_is_ascii_check)
+* [`manual_rem_euclid`](https://rust-lang.github.io/rust-clippy/master/index.html#manual_rem_euclid)
+* [`manual_retain`](https://rust-lang.github.io/rust-clippy/master/index.html#manual_retain)
+
+
+## `cognitive-complexity-threshold`
 The maximum cognitive complexity a function can have
 
 **Default Value:** `25` (`u64`)
 
-* [cognitive_complexity](https://rust-lang.github.io/rust-clippy/master/index.html#cognitive_complexity)
+---
+**Affected lints:**
+* [`cognitive_complexity`](https://rust-lang.github.io/rust-clippy/master/index.html#cognitive_complexity)
 
 
-### disallowed-names
+## `disallowed-names`
 The list of disallowed names to lint about. NB: `bar` is not here since it has legitimate uses. The value
 `".."` can be used as part of the list to indicate, that the configured values should be appended to the
 default configuration of Clippy. By default, any configuration will replace the default value.
 
 **Default Value:** `["foo", "baz", "quux"]` (`Vec<String>`)
 
-* [disallowed_names](https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_names)
+---
+**Affected lints:**
+* [`disallowed_names`](https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_names)
 
 
-### semicolon-inside-block-ignore-singleline
+## `semicolon-inside-block-ignore-singleline`
 Whether to lint only if it's multiline.
 
 **Default Value:** `false` (`bool`)
 
-* [semicolon_inside_block](https://rust-lang.github.io/rust-clippy/master/index.html#semicolon_inside_block)
+---
+**Affected lints:**
+* [`semicolon_inside_block`](https://rust-lang.github.io/rust-clippy/master/index.html#semicolon_inside_block)
 
 
-### semicolon-outside-block-ignore-multiline
+## `semicolon-outside-block-ignore-multiline`
 Whether to lint only if it's singleline.
 
 **Default Value:** `false` (`bool`)
 
-* [semicolon_outside_block](https://rust-lang.github.io/rust-clippy/master/index.html#semicolon_outside_block)
+---
+**Affected lints:**
+* [`semicolon_outside_block`](https://rust-lang.github.io/rust-clippy/master/index.html#semicolon_outside_block)
 
 
-### doc-valid-idents
+## `doc-valid-idents`
 The list of words this lint should not consider as identifiers needing ticks. The value
 `".."` can be used as part of the list to indicate, that the configured values should be appended to the
 default configuration of Clippy. By default, any configuration will replace the default value. For example:
@@ -232,205 +201,255 @@ Default list:
 
 **Default Value:** `["KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "DirectX", "ECMAScript", "GPLv2", "GPLv3", "GitHub", "GitLab", "IPv4", "IPv6", "ClojureScript", "CoffeeScript", "JavaScript", "PureScript", "TypeScript", "NaN", "NaNs", "OAuth", "GraphQL", "OCaml", "OpenGL", "OpenMP", "OpenSSH", "OpenSSL", "OpenStreetMap", "OpenDNS", "WebGL", "TensorFlow", "TrueType", "iOS", "macOS", "FreeBSD", "TeX", "LaTeX", "BibTeX", "BibLaTeX", "MinGW", "CamelCase"]` (`Vec<String>`)
 
-* [doc_markdown](https://rust-lang.github.io/rust-clippy/master/index.html#doc_markdown)
+---
+**Affected lints:**
+* [`doc_markdown`](https://rust-lang.github.io/rust-clippy/master/index.html#doc_markdown)
 
 
-### too-many-arguments-threshold
+## `too-many-arguments-threshold`
 The maximum number of argument a function or method can have
 
 **Default Value:** `7` (`u64`)
 
-* [too_many_arguments](https://rust-lang.github.io/rust-clippy/master/index.html#too_many_arguments)
+---
+**Affected lints:**
+* [`too_many_arguments`](https://rust-lang.github.io/rust-clippy/master/index.html#too_many_arguments)
 
 
-### type-complexity-threshold
+## `type-complexity-threshold`
 The maximum complexity a type can have
 
 **Default Value:** `250` (`u64`)
 
-* [type_complexity](https://rust-lang.github.io/rust-clippy/master/index.html#type_complexity)
+---
+**Affected lints:**
+* [`type_complexity`](https://rust-lang.github.io/rust-clippy/master/index.html#type_complexity)
 
 
-### single-char-binding-names-threshold
+## `single-char-binding-names-threshold`
 The maximum number of single char bindings a scope may have
 
 **Default Value:** `4` (`u64`)
 
-* [many_single_char_names](https://rust-lang.github.io/rust-clippy/master/index.html#many_single_char_names)
+---
+**Affected lints:**
+* [`many_single_char_names`](https://rust-lang.github.io/rust-clippy/master/index.html#many_single_char_names)
 
 
-### too-large-for-stack
+## `too-large-for-stack`
 The maximum size of objects (in bytes) that will be linted. Larger objects are ok on the heap
 
 **Default Value:** `200` (`u64`)
 
-* [boxed_local](https://rust-lang.github.io/rust-clippy/master/index.html#boxed_local)
-* [useless_vec](https://rust-lang.github.io/rust-clippy/master/index.html#useless_vec)
+---
+**Affected lints:**
+* [`boxed_local`](https://rust-lang.github.io/rust-clippy/master/index.html#boxed_local)
+* [`useless_vec`](https://rust-lang.github.io/rust-clippy/master/index.html#useless_vec)
 
 
-### enum-variant-name-threshold
+## `enum-variant-name-threshold`
 The minimum number of enum variants for the lints about variant names to trigger
 
 **Default Value:** `3` (`u64`)
 
-* [enum_variant_names](https://rust-lang.github.io/rust-clippy/master/index.html#enum_variant_names)
+---
+**Affected lints:**
+* [`enum_variant_names`](https://rust-lang.github.io/rust-clippy/master/index.html#enum_variant_names)
 
 
-### enum-variant-size-threshold
+## `enum-variant-size-threshold`
 The maximum size of an enum's variant to avoid box suggestion
 
 **Default Value:** `200` (`u64`)
 
-* [large_enum_variant](https://rust-lang.github.io/rust-clippy/master/index.html#large_enum_variant)
+---
+**Affected lints:**
+* [`large_enum_variant`](https://rust-lang.github.io/rust-clippy/master/index.html#large_enum_variant)
 
 
-### verbose-bit-mask-threshold
+## `verbose-bit-mask-threshold`
 The maximum allowed size of a bit mask before suggesting to use 'trailing_zeros'
 
 **Default Value:** `1` (`u64`)
 
-* [verbose_bit_mask](https://rust-lang.github.io/rust-clippy/master/index.html#verbose_bit_mask)
+---
+**Affected lints:**
+* [`verbose_bit_mask`](https://rust-lang.github.io/rust-clippy/master/index.html#verbose_bit_mask)
 
 
-### literal-representation-threshold
+## `literal-representation-threshold`
 The lower bound for linting decimal literals
 
 **Default Value:** `16384` (`u64`)
 
-* [decimal_literal_representation](https://rust-lang.github.io/rust-clippy/master/index.html#decimal_literal_representation)
+---
+**Affected lints:**
+* [`decimal_literal_representation`](https://rust-lang.github.io/rust-clippy/master/index.html#decimal_literal_representation)
 
 
-### trivial-copy-size-limit
+## `trivial-copy-size-limit`
 The maximum size (in bytes) to consider a `Copy` type for passing by value instead of by reference.
 
 **Default Value:** `None` (`Option<u64>`)
 
-* [trivially_copy_pass_by_ref](https://rust-lang.github.io/rust-clippy/master/index.html#trivially_copy_pass_by_ref)
+---
+**Affected lints:**
+* [`trivially_copy_pass_by_ref`](https://rust-lang.github.io/rust-clippy/master/index.html#trivially_copy_pass_by_ref)
 
 
-### pass-by-value-size-limit
+## `pass-by-value-size-limit`
 The minimum size (in bytes) to consider a type for passing by reference instead of by value.
 
 **Default Value:** `256` (`u64`)
 
-* [large_types_passed_by_value](https://rust-lang.github.io/rust-clippy/master/index.html#large_types_passed_by_value)
+---
+**Affected lints:**
+* [`large_types_passed_by_value`](https://rust-lang.github.io/rust-clippy/master/index.html#large_types_passed_by_value)
 
 
-### too-many-lines-threshold
+## `too-many-lines-threshold`
 The maximum number of lines a function or method can have
 
 **Default Value:** `100` (`u64`)
 
-* [too_many_lines](https://rust-lang.github.io/rust-clippy/master/index.html#too_many_lines)
+---
+**Affected lints:**
+* [`too_many_lines`](https://rust-lang.github.io/rust-clippy/master/index.html#too_many_lines)
 
 
-### array-size-threshold
+## `array-size-threshold`
 The maximum allowed size for arrays on the stack
 
 **Default Value:** `512000` (`u64`)
 
-* [large_stack_arrays](https://rust-lang.github.io/rust-clippy/master/index.html#large_stack_arrays)
-* [large_const_arrays](https://rust-lang.github.io/rust-clippy/master/index.html#large_const_arrays)
+---
+**Affected lints:**
+* [`large_stack_arrays`](https://rust-lang.github.io/rust-clippy/master/index.html#large_stack_arrays)
+* [`large_const_arrays`](https://rust-lang.github.io/rust-clippy/master/index.html#large_const_arrays)
 
 
-### vec-box-size-threshold
+## `vec-box-size-threshold`
 The size of the boxed type in bytes, where boxing in a `Vec` is allowed
 
 **Default Value:** `4096` (`u64`)
 
-* [vec_box](https://rust-lang.github.io/rust-clippy/master/index.html#vec_box)
+---
+**Affected lints:**
+* [`vec_box`](https://rust-lang.github.io/rust-clippy/master/index.html#vec_box)
 
 
-### max-trait-bounds
+## `max-trait-bounds`
 The maximum number of bounds a trait can have to be linted
 
 **Default Value:** `3` (`u64`)
 
-* [type_repetition_in_bounds](https://rust-lang.github.io/rust-clippy/master/index.html#type_repetition_in_bounds)
+---
+**Affected lints:**
+* [`type_repetition_in_bounds`](https://rust-lang.github.io/rust-clippy/master/index.html#type_repetition_in_bounds)
 
 
-### max-struct-bools
+## `max-struct-bools`
 The maximum number of bool fields a struct can have
 
 **Default Value:** `3` (`u64`)
 
-* [struct_excessive_bools](https://rust-lang.github.io/rust-clippy/master/index.html#struct_excessive_bools)
+---
+**Affected lints:**
+* [`struct_excessive_bools`](https://rust-lang.github.io/rust-clippy/master/index.html#struct_excessive_bools)
 
 
-### max-fn-params-bools
+## `max-fn-params-bools`
 The maximum number of bool parameters a function can have
 
 **Default Value:** `3` (`u64`)
 
-* [fn_params_excessive_bools](https://rust-lang.github.io/rust-clippy/master/index.html#fn_params_excessive_bools)
+---
+**Affected lints:**
+* [`fn_params_excessive_bools`](https://rust-lang.github.io/rust-clippy/master/index.html#fn_params_excessive_bools)
 
 
-### warn-on-all-wildcard-imports
+## `warn-on-all-wildcard-imports`
 Whether to allow certain wildcard imports (prelude, super in tests).
 
 **Default Value:** `false` (`bool`)
 
-* [wildcard_imports](https://rust-lang.github.io/rust-clippy/master/index.html#wildcard_imports)
+---
+**Affected lints:**
+* [`wildcard_imports`](https://rust-lang.github.io/rust-clippy/master/index.html#wildcard_imports)
 
 
-### disallowed-macros
+## `disallowed-macros`
 The list of disallowed macros, written as fully qualified paths.
 
 **Default Value:** `[]` (`Vec<crate::utils::conf::DisallowedPath>`)
 
-* [disallowed_macros](https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_macros)
+---
+**Affected lints:**
+* [`disallowed_macros`](https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_macros)
 
 
-### disallowed-methods
+## `disallowed-methods`
 The list of disallowed methods, written as fully qualified paths.
 
 **Default Value:** `[]` (`Vec<crate::utils::conf::DisallowedPath>`)
 
-* [disallowed_methods](https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_methods)
+---
+**Affected lints:**
+* [`disallowed_methods`](https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_methods)
 
 
-### disallowed-types
+## `disallowed-types`
 The list of disallowed types, written as fully qualified paths.
 
 **Default Value:** `[]` (`Vec<crate::utils::conf::DisallowedPath>`)
 
-* [disallowed_types](https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_types)
+---
+**Affected lints:**
+* [`disallowed_types`](https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_types)
 
 
-### unreadable-literal-lint-fractions
+## `unreadable-literal-lint-fractions`
 Should the fraction of a decimal be linted to include separators.
 
 **Default Value:** `true` (`bool`)
 
-* [unreadable_literal](https://rust-lang.github.io/rust-clippy/master/index.html#unreadable_literal)
+---
+**Affected lints:**
+* [`unreadable_literal`](https://rust-lang.github.io/rust-clippy/master/index.html#unreadable_literal)
 
 
-### upper-case-acronyms-aggressive
+## `upper-case-acronyms-aggressive`
 Enables verbose mode. Triggers if there is more than one uppercase char next to each other
 
 **Default Value:** `false` (`bool`)
 
-* [upper_case_acronyms](https://rust-lang.github.io/rust-clippy/master/index.html#upper_case_acronyms)
+---
+**Affected lints:**
+* [`upper_case_acronyms`](https://rust-lang.github.io/rust-clippy/master/index.html#upper_case_acronyms)
 
 
-### matches-for-let-else
+## `matches-for-let-else`
 Whether the matches should be considered by the lint, and whether there should
 be filtering for common types.
 
 **Default Value:** `WellKnownTypes` (`crate::manual_let_else::MatchLintBehaviour`)
 
-* [manual_let_else](https://rust-lang.github.io/rust-clippy/master/index.html#manual_let_else)
+---
+**Affected lints:**
+* [`manual_let_else`](https://rust-lang.github.io/rust-clippy/master/index.html#manual_let_else)
 
 
-### cargo-ignore-publish
+## `cargo-ignore-publish`
 For internal testing only, ignores the current `publish` settings in the Cargo manifest.
 
 **Default Value:** `false` (`bool`)
 
-* [_cargo_common_metadata](https://rust-lang.github.io/rust-clippy/master/index.html#_cargo_common_metadata)
+---
+**Affected lints:**
+* [`_cargo_common_metadata`](https://rust-lang.github.io/rust-clippy/master/index.html#_cargo_common_metadata)
 
 
-### standard-macro-braces
+## `standard-macro-braces`
 Enforce the named macros always use the braces specified.
 
 A `MacroMatcher` can be added like so `{ name = "macro_name", brace = "(" }`. If the macro
@@ -439,119 +458,147 @@ could be used with a full path two `MacroMatcher`s have to be added one with the
 
 **Default Value:** `[]` (`Vec<crate::nonstandard_macro_braces::MacroMatcher>`)
 
-* [nonstandard_macro_braces](https://rust-lang.github.io/rust-clippy/master/index.html#nonstandard_macro_braces)
+---
+**Affected lints:**
+* [`nonstandard_macro_braces`](https://rust-lang.github.io/rust-clippy/master/index.html#nonstandard_macro_braces)
 
 
-### enforced-import-renames
+## `enforced-import-renames`
 The list of imports to always rename, a fully qualified path followed by the rename.
 
 **Default Value:** `[]` (`Vec<crate::utils::conf::Rename>`)
 
-* [missing_enforced_import_renames](https://rust-lang.github.io/rust-clippy/master/index.html#missing_enforced_import_renames)
+---
+**Affected lints:**
+* [`missing_enforced_import_renames`](https://rust-lang.github.io/rust-clippy/master/index.html#missing_enforced_import_renames)
 
 
-### allowed-scripts
+## `allowed-scripts`
 The list of unicode scripts allowed to be used in the scope.
 
 **Default Value:** `["Latin"]` (`Vec<String>`)
 
-* [disallowed_script_idents](https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_script_idents)
+---
+**Affected lints:**
+* [`disallowed_script_idents`](https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_script_idents)
 
 
-### enable-raw-pointer-heuristic-for-send
+## `enable-raw-pointer-heuristic-for-send`
 Whether to apply the raw pointer heuristic to determine if a type is `Send`.
 
 **Default Value:** `true` (`bool`)
 
-* [non_send_fields_in_send_ty](https://rust-lang.github.io/rust-clippy/master/index.html#non_send_fields_in_send_ty)
+---
+**Affected lints:**
+* [`non_send_fields_in_send_ty`](https://rust-lang.github.io/rust-clippy/master/index.html#non_send_fields_in_send_ty)
 
 
-### max-suggested-slice-pattern-length
+## `max-suggested-slice-pattern-length`
 When Clippy suggests using a slice pattern, this is the maximum number of elements allowed in
 the slice pattern that is suggested. If more elements are necessary, the lint is suppressed.
 For example, `[_, _, _, e, ..]` is a slice pattern with 4 elements.
 
 **Default Value:** `3` (`u64`)
 
-* [index_refutable_slice](https://rust-lang.github.io/rust-clippy/master/index.html#index_refutable_slice)
+---
+**Affected lints:**
+* [`index_refutable_slice`](https://rust-lang.github.io/rust-clippy/master/index.html#index_refutable_slice)
 
 
-### await-holding-invalid-types
+## `await-holding-invalid-types`
 
 
 **Default Value:** `[]` (`Vec<crate::utils::conf::DisallowedPath>`)
 
-* [await_holding_invalid_type](https://rust-lang.github.io/rust-clippy/master/index.html#await_holding_invalid_type)
+---
+**Affected lints:**
+* [`await_holding_invalid_type`](https://rust-lang.github.io/rust-clippy/master/index.html#await_holding_invalid_type)
 
 
-### max-include-file-size
+## `max-include-file-size`
 The maximum size of a file included via `include_bytes!()` or `include_str!()`, in bytes
 
 **Default Value:** `1000000` (`u64`)
 
-* [large_include_file](https://rust-lang.github.io/rust-clippy/master/index.html#large_include_file)
+---
+**Affected lints:**
+* [`large_include_file`](https://rust-lang.github.io/rust-clippy/master/index.html#large_include_file)
 
 
-### allow-expect-in-tests
+## `allow-expect-in-tests`
 Whether `expect` should be allowed in test functions or `#[cfg(test)]`
 
 **Default Value:** `false` (`bool`)
 
-* [expect_used](https://rust-lang.github.io/rust-clippy/master/index.html#expect_used)
+---
+**Affected lints:**
+* [`expect_used`](https://rust-lang.github.io/rust-clippy/master/index.html#expect_used)
 
 
-### allow-unwrap-in-tests
+## `allow-unwrap-in-tests`
 Whether `unwrap` should be allowed in test functions or `#[cfg(test)]`
 
 **Default Value:** `false` (`bool`)
 
-* [unwrap_used](https://rust-lang.github.io/rust-clippy/master/index.html#unwrap_used)
+---
+**Affected lints:**
+* [`unwrap_used`](https://rust-lang.github.io/rust-clippy/master/index.html#unwrap_used)
 
 
-### allow-dbg-in-tests
+## `allow-dbg-in-tests`
 Whether `dbg!` should be allowed in test functions or `#[cfg(test)]`
 
 **Default Value:** `false` (`bool`)
 
-* [dbg_macro](https://rust-lang.github.io/rust-clippy/master/index.html#dbg_macro)
+---
+**Affected lints:**
+* [`dbg_macro`](https://rust-lang.github.io/rust-clippy/master/index.html#dbg_macro)
 
 
-### allow-print-in-tests
+## `allow-print-in-tests`
 Whether print macros (ex. `println!`) should be allowed in test functions or `#[cfg(test)]`
 
 **Default Value:** `false` (`bool`)
 
-* [print_stdout](https://rust-lang.github.io/rust-clippy/master/index.html#print_stdout)
-* [print_stderr](https://rust-lang.github.io/rust-clippy/master/index.html#print_stderr)
+---
+**Affected lints:**
+* [`print_stdout`](https://rust-lang.github.io/rust-clippy/master/index.html#print_stdout)
+* [`print_stderr`](https://rust-lang.github.io/rust-clippy/master/index.html#print_stderr)
 
 
-### large-error-threshold
+## `large-error-threshold`
 The maximum size of the `Err`-variant in a `Result` returned from a function
 
 **Default Value:** `128` (`u64`)
 
-* [result_large_err](https://rust-lang.github.io/rust-clippy/master/index.html#result_large_err)
+---
+**Affected lints:**
+* [`result_large_err`](https://rust-lang.github.io/rust-clippy/master/index.html#result_large_err)
 
 
-### ignore-interior-mutability
+## `ignore-interior-mutability`
 A list of paths to types that should be treated like `Arc`, i.e. ignored but
 for the generic parameters for determining interior mutability
 
 **Default Value:** `["bytes::Bytes"]` (`Vec<String>`)
 
-* [mutable_key_type](https://rust-lang.github.io/rust-clippy/master/index.html#mutable_key_type)
-* [ifs_same_cond](https://rust-lang.github.io/rust-clippy/master/index.html#ifs_same_cond)
+---
+**Affected lints:**
+* [`mutable_key_type`](https://rust-lang.github.io/rust-clippy/master/index.html#mutable_key_type)
+* [`ifs_same_cond`](https://rust-lang.github.io/rust-clippy/master/index.html#ifs_same_cond)
 
 
-### allow-mixed-uninlined-format-args
+## `allow-mixed-uninlined-format-args`
 Whether to allow mixed uninlined format args, e.g. `format!("{} {}", a, foo.bar)`
 
 **Default Value:** `true` (`bool`)
 
-* [uninlined_format_args](https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args)
+---
+**Affected lints:**
+* [`uninlined_format_args`](https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args)
 
 
-### suppress-restriction-lint-in-const
+## `suppress-restriction-lint-in-const`
 Whether to suppress a restriction lint in constant code. In same
 cases the restructured operation might not be unavoidable, as the
 suggested counterparts are unavailable in constant code. This
@@ -560,32 +607,39 @@ if no suggestion can be made.
 
 **Default Value:** `false` (`bool`)
 
-* [indexing_slicing](https://rust-lang.github.io/rust-clippy/master/index.html#indexing_slicing)
+---
+**Affected lints:**
+* [`indexing_slicing`](https://rust-lang.github.io/rust-clippy/master/index.html#indexing_slicing)
 
 
-### missing-docs-in-crate-items
+## `missing-docs-in-crate-items`
 Whether to **only** check for missing documentation in items visible within the current
 crate. For example, `pub(crate)` items.
 
 **Default Value:** `false` (`bool`)
 
-* [missing_docs_in_private_items](https://rust-lang.github.io/rust-clippy/master/index.html#missing_docs_in_private_items)
+---
+**Affected lints:**
+* [`missing_docs_in_private_items`](https://rust-lang.github.io/rust-clippy/master/index.html#missing_docs_in_private_items)
 
 
-### future-size-threshold
+## `future-size-threshold`
 The maximum byte size a `Future` can have, before it triggers the `clippy::large_futures` lint
 
 **Default Value:** `16384` (`u64`)
 
-* [large_futures](https://rust-lang.github.io/rust-clippy/master/index.html#large_futures)
+---
+**Affected lints:**
+* [`large_futures`](https://rust-lang.github.io/rust-clippy/master/index.html#large_futures)
 
 
-### unnecessary-box-size
+## `unnecessary-box-size`
 The byte size a `T` in `Box<T>` can have, below which it triggers the `clippy::unnecessary_box` lint
 
 **Default Value:** `128` (`u64`)
 
-* [unnecessary_box_returns](https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_box_returns)
-
+---
+**Affected lints:**
+* [`unnecessary_box_returns`](https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_box_returns)
 
 
diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index 7a1cd3effae..2a9aba0a116 100644
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -195,8 +195,14 @@ This lint has the following configuration variables:
 
     fn get_markdown_docs(&self) -> String {
         format!(
-            "## Lint Configuration Options\n| <div style=\"width:290px\">Option</div> | Default Value |\n|--|--|\n{}\n\n{}\n",
-            self.configs_to_markdown(ClippyConfiguration::to_markdown_table_entry),
+            r#"# Lint Configuration Options
+
+The following list shows each configuration option, along with a description, its default value, an example
+and lints affected.
+
+---
+
+{}"#,
             self.configs_to_markdown(ClippyConfiguration::to_markdown_paragraph),
         )
     }
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index d3ea7cafa80..884edec2d79 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -51,7 +51,7 @@ impl ClippyConfiguration {
     #[cfg(feature = "internal")]
     fn to_markdown_paragraph(&self) -> String {
         format!(
-            "### {}\n{}\n\n**Default Value:** `{}` (`{}`)\n\n{}\n\n",
+            "## `{}`\n{}\n\n**Default Value:** `{}` (`{}`)\n\n---\n**Affected lints:**\n{}\n\n",
             self.name,
             self.doc
                 .lines()
@@ -62,15 +62,10 @@ impl ClippyConfiguration {
             self.lints
                 .iter()
                 .map(|name| name.to_string().split_whitespace().next().unwrap().to_string())
-                .map(|name| format!("* [{name}](https://rust-lang.github.io/rust-clippy/master/index.html#{name})"))
+                .map(|name| format!("* [`{name}`](https://rust-lang.github.io/rust-clippy/master/index.html#{name})"))
                 .join("\n"),
         )
     }
-
-    #[cfg(feature = "internal")]
-    fn to_markdown_table_entry(&self) -> String {
-        format!("| [{}](#{}) | `{}` |", self.name, self.name, self.default)
-    }
 }
 
 #[cfg(feature = "internal")]
-- 
cgit 1.4.1-3-g733a5


From c5d4b04dd51bc470469c72ee22816a2c634b8a3d Mon Sep 17 00:00:00 2001
From: "Samuel \"Sam\" Tardieu" <sam@rfc1149.net>
Date: Wed, 10 May 2023 21:06:36 +0200
Subject: needless_bool: do not simplify code if it loses comments

---
 clippy_lints/src/needless_bool.rs     |  5 ++---
 tests/ui/needless_bool/fixable.fixed  |  7 +++++++
 tests/ui/needless_bool/fixable.rs     |  7 +++++++
 tests/ui/needless_bool/fixable.stderr | 24 ++++++++++++------------
 4 files changed, 28 insertions(+), 15 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/needless_bool.rs b/clippy_lints/src/needless_bool.rs
index 71281a0b40b..62af42a3961 100644
--- a/clippy_lints/src/needless_bool.rs
+++ b/clippy_lints/src/needless_bool.rs
@@ -146,7 +146,7 @@ fn is_parent_stmt(cx: &LateContext<'_>, id: HirId) -> bool {
 impl<'tcx> LateLintPass<'tcx> for NeedlessBool {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
         use self::Expression::{Bool, RetBool};
-        if e.span.from_expansion() {
+        if e.span.from_expansion() || !span_extract_comment(cx.tcx.sess.source_map(), e.span).is_empty() {
             return;
         }
         if let Some(higher::If {
@@ -209,8 +209,7 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessBool {
             }
             if let Some((lhs_a, a)) = fetch_assign(then) &&
                 let Some((lhs_b, b)) = fetch_assign(r#else) &&
-                SpanlessEq::new(cx).eq_expr(lhs_a, lhs_b) &&
-                span_extract_comment(cx.tcx.sess.source_map(), e.span).is_empty()
+                SpanlessEq::new(cx).eq_expr(lhs_a, lhs_b)
             {
                 let mut applicability = Applicability::MachineApplicable;
                 let cond = Sugg::hir_with_applicability(cx, cond, "..", &mut applicability);
diff --git a/tests/ui/needless_bool/fixable.fixed b/tests/ui/needless_bool/fixable.fixed
index f860852e7b7..bf1911881c8 100644
--- a/tests/ui/needless_bool/fixable.fixed
+++ b/tests/ui/needless_bool/fixable.fixed
@@ -63,6 +63,13 @@ fn main() {
     needless_bool2(x);
     needless_bool3(x);
     needless_bool_condition();
+
+    if a == b {
+        true
+    } else {
+        // Do not lint as this comment might be important
+        false
+    };
 }
 
 fn bool_ret3(x: bool) -> bool {
diff --git a/tests/ui/needless_bool/fixable.rs b/tests/ui/needless_bool/fixable.rs
index 6680dab5b6d..a6c465d4fbd 100644
--- a/tests/ui/needless_bool/fixable.rs
+++ b/tests/ui/needless_bool/fixable.rs
@@ -99,6 +99,13 @@ fn main() {
     needless_bool2(x);
     needless_bool3(x);
     needless_bool_condition();
+
+    if a == b {
+        true
+    } else {
+        // Do not lint as this comment might be important
+        false
+    };
 }
 
 fn bool_ret3(x: bool) -> bool {
diff --git a/tests/ui/needless_bool/fixable.stderr b/tests/ui/needless_bool/fixable.stderr
index d2c48376f76..fa906374fb3 100644
--- a/tests/ui/needless_bool/fixable.stderr
+++ b/tests/ui/needless_bool/fixable.stderr
@@ -91,7 +91,7 @@ LL | |     };
    | |_____^ help: you can reduce it to: `a < b`
 
 error: this if-then-else expression returns a bool literal
-  --> $DIR/fixable.rs:105:5
+  --> $DIR/fixable.rs:112:5
    |
 LL | /     if x {
 LL | |         return true;
@@ -101,7 +101,7 @@ LL | |     };
    | |_____^ help: you can reduce it to: `return x`
 
 error: this if-then-else expression returns a bool literal
-  --> $DIR/fixable.rs:113:5
+  --> $DIR/fixable.rs:120:5
    |
 LL | /     if x {
 LL | |         return false;
@@ -111,7 +111,7 @@ LL | |     };
    | |_____^ help: you can reduce it to: `return !x`
 
 error: this if-then-else expression returns a bool literal
-  --> $DIR/fixable.rs:121:5
+  --> $DIR/fixable.rs:128:5
    |
 LL | /     if x && y {
 LL | |         return true;
@@ -121,7 +121,7 @@ LL | |     };
    | |_____^ help: you can reduce it to: `return x && y`
 
 error: this if-then-else expression returns a bool literal
-  --> $DIR/fixable.rs:129:5
+  --> $DIR/fixable.rs:136:5
    |
 LL | /     if x && y {
 LL | |         return false;
@@ -131,7 +131,7 @@ LL | |     };
    | |_____^ help: you can reduce it to: `return !(x && y)`
 
 error: equality checks against true are unnecessary
-  --> $DIR/fixable.rs:137:8
+  --> $DIR/fixable.rs:144:8
    |
 LL |     if x == true {};
    |        ^^^^^^^^^ help: try simplifying it as shown: `x`
@@ -139,25 +139,25 @@ LL |     if x == true {};
    = note: `-D clippy::bool-comparison` implied by `-D warnings`
 
 error: equality checks against false can be replaced by a negation
-  --> $DIR/fixable.rs:141:8
+  --> $DIR/fixable.rs:148:8
    |
 LL |     if x == false {};
    |        ^^^^^^^^^^ help: try simplifying it as shown: `!x`
 
 error: equality checks against true are unnecessary
-  --> $DIR/fixable.rs:151:8
+  --> $DIR/fixable.rs:158:8
    |
 LL |     if x == true {};
    |        ^^^^^^^^^ help: try simplifying it as shown: `x`
 
 error: equality checks against false can be replaced by a negation
-  --> $DIR/fixable.rs:152:8
+  --> $DIR/fixable.rs:159:8
    |
 LL |     if x == false {};
    |        ^^^^^^^^^^ help: try simplifying it as shown: `!x`
 
 error: this if-then-else expression returns a bool literal
-  --> $DIR/fixable.rs:161:12
+  --> $DIR/fixable.rs:168:12
    |
 LL |       } else if returns_bool() {
    |  ____________^
@@ -168,7 +168,7 @@ LL | |     };
    | |_____^ help: you can reduce it to: `{ !returns_bool() }`
 
 error: this if-then-else expression returns a bool literal
-  --> $DIR/fixable.rs:174:5
+  --> $DIR/fixable.rs:181:5
    |
 LL | /     if unsafe { no(4) } & 1 != 0 {
 LL | |         true
@@ -178,13 +178,13 @@ LL | |     };
    | |_____^ help: you can reduce it to: `(unsafe { no(4) } & 1 != 0)`
 
 error: this if-then-else expression returns a bool literal
-  --> $DIR/fixable.rs:179:30
+  --> $DIR/fixable.rs:186:30
    |
 LL |     let _brackets_unneeded = if unsafe { no(4) } & 1 != 0 { true } else { false };
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: you can reduce it to: `unsafe { no(4) } & 1 != 0`
 
 error: this if-then-else expression returns a bool literal
-  --> $DIR/fixable.rs:182:9
+  --> $DIR/fixable.rs:189:9
    |
 LL |         if unsafe { no(4) } & 1 != 0 { true } else { false }
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: you can reduce it to: `(unsafe { no(4) } & 1 != 0)`
-- 
cgit 1.4.1-3-g733a5


From 0a4cfbf1f85b283586a446234b72662d32602fea Mon Sep 17 00:00:00 2001
From: Jake Swensen <jake@swensen.io>
Date: Sun, 2 Apr 2023 15:32:10 -0500
Subject: fix: warn on empty line outer AttrKind::DocComment

changelog: [`empty_line_after_doc_comments`]: add lint for checking
empty lines after rustdoc comments.

Fixes: #10395
---
 CHANGELOG.md                                  |   1 +
 clippy_lints/src/attrs.rs                     |  76 +++++++++++++--
 clippy_lints/src/declared_lints.rs            |   1 +
 tests/ui/empty_line_after_doc_comments.rs     | 132 ++++++++++++++++++++++++++
 tests/ui/empty_line_after_doc_comments.stderr |  36 +++++++
 5 files changed, 238 insertions(+), 8 deletions(-)
 create mode 100644 tests/ui/empty_line_after_doc_comments.rs
 create mode 100644 tests/ui/empty_line_after_doc_comments.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 10dd28a8f6a..83aaeee8c18 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4619,6 +4619,7 @@ Released 2018-09-13
 [`else_if_without_else`]: https://rust-lang.github.io/rust-clippy/master/index.html#else_if_without_else
 [`empty_drop`]: https://rust-lang.github.io/rust-clippy/master/index.html#empty_drop
 [`empty_enum`]: https://rust-lang.github.io/rust-clippy/master/index.html#empty_enum
+[`empty_line_after_doc_comments`]: https://rust-lang.github.io/rust-clippy/master/index.html#empty_line_after_doc_comments
 [`empty_line_after_outer_attr`]: https://rust-lang.github.io/rust-clippy/master/index.html#empty_line_after_outer_attr
 [`empty_loop`]: https://rust-lang.github.io/rust-clippy/master/index.html#empty_loop
 [`empty_structs_with_brackets`]: https://rust-lang.github.io/rust-clippy/master/index.html#empty_structs_with_brackets
diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs
index 751c262673b..93d88391a79 100644
--- a/clippy_lints/src/attrs.rs
+++ b/clippy_lints/src/attrs.rs
@@ -176,6 +176,52 @@ declare_clippy_lint! {
     "empty line after outer attribute"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for empty lines after documenation comments.
+    ///
+    /// ### Why is this bad?
+    /// The documentation comment was most likely meant to be an inner attribute or regular comment.
+    /// If it was intended to be a documentation comment, then the empty line should be removed to
+    /// be more idiomatic.
+    ///
+    /// ### Known problems
+    /// Only detects empty lines immediately following the documentation. If the doc comment is followed
+    /// by an attribute and then an empty line, this lint will not trigger. Use `empty_line_after_outer_attr`
+    /// in combination with this lint to detect both cases.
+    ///
+    /// Does not detect empty lines after doc attributes (e.g. `#[doc = ""]`).
+    ///
+    /// ### Example
+    /// ```rust
+    /// /// Some doc comment with a blank line after it.
+    ///
+    /// fn not_quite_good_code() { }
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust
+    /// /// Good (no blank line)
+    /// fn this_is_fine() { }
+    /// ```
+    ///
+    /// ```rust
+    /// // Good (convert to a regular comment)
+    ///
+    /// fn this_is_fine_too() { }
+    /// ```
+    ///
+    /// ```rust
+    /// //! Good (convert to a comment on an inner attribute)
+    ///
+    /// fn this_is_fine_as_well() { }
+    /// ```
+    #[clippy::version = "1.70.0"]
+    pub EMPTY_LINE_AFTER_DOC_COMMENTS,
+    nursery,
+    "empty line after documentation comments"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for `warn`/`deny`/`forbid` attributes targeting the whole clippy::restriction category.
@@ -604,6 +650,7 @@ impl_lint_pass!(EarlyAttributes => [
     DEPRECATED_CFG_ATTR,
     MISMATCHED_TARGET_OS,
     EMPTY_LINE_AFTER_OUTER_ATTR,
+    EMPTY_LINE_AFTER_DOC_COMMENTS,
 ]);
 
 impl EarlyLintPass for EarlyAttributes {
@@ -619,10 +666,16 @@ impl EarlyLintPass for EarlyAttributes {
     extract_msrv_attr!(EarlyContext);
 }
 
+/// Check for empty lines after outer attributes.
+///
+/// Attributes and documenation comments are both considered outer attributes
+/// by the AST. However, the average user likely considers them to be different.
+/// Checking for empty lines after each of these attributes is split into two different
+/// lints but can share the same logic.
 fn check_empty_line_after_outer_attr(cx: &EarlyContext<'_>, item: &rustc_ast::Item) {
     let mut iter = item.attrs.iter().peekable();
     while let Some(attr) = iter.next() {
-        if matches!(attr.kind, AttrKind::Normal(..))
+        if (matches!(attr.kind, AttrKind::Normal(..)) || matches!(attr.kind, AttrKind::DocComment(..)))
             && attr.style == AttrStyle::Outer
             && is_present_in_source(cx, attr.span)
         {
@@ -639,13 +692,20 @@ fn check_empty_line_after_outer_attr(cx: &EarlyContext<'_>, item: &rustc_ast::It
                 let lines = without_block_comments(lines);
 
                 if lines.iter().filter(|l| l.trim().is_empty()).count() > 2 {
-                    span_lint(
-                        cx,
-                        EMPTY_LINE_AFTER_OUTER_ATTR,
-                        begin_of_attr_to_item,
-                        "found an empty line after an outer attribute. \
-                        Perhaps you forgot to add a `!` to make it an inner attribute?",
-                    );
+                    let (lint_msg, lint_type) = match attr.kind {
+                        AttrKind::DocComment(..) => (
+                            "found an empty line after a doc comment. \
+                            Perhaps you need to use `//!` to make a comment on a module, remove the empty line, or make a regular comment with `//`?",
+                            EMPTY_LINE_AFTER_DOC_COMMENTS,
+                        ),
+                        AttrKind::Normal(..) => (
+                            "found an empty line after an outer attribute. \
+                            Perhaps you forgot to add a `!` to make it an inner attribute?",
+                            EMPTY_LINE_AFTER_OUTER_ATTR,
+                        ),
+                    };
+
+                    span_lint(cx, lint_type, begin_of_attr_to_item, lint_msg);
                 }
             }
         }
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index f24dab62780..260be34a795 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -48,6 +48,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::attrs::BLANKET_CLIPPY_RESTRICTION_LINTS_INFO,
     crate::attrs::DEPRECATED_CFG_ATTR_INFO,
     crate::attrs::DEPRECATED_SEMVER_INFO,
+    crate::attrs::EMPTY_LINE_AFTER_DOC_COMMENTS_INFO,
     crate::attrs::EMPTY_LINE_AFTER_OUTER_ATTR_INFO,
     crate::attrs::INLINE_ALWAYS_INFO,
     crate::attrs::MISMATCHED_TARGET_OS_INFO,
diff --git a/tests/ui/empty_line_after_doc_comments.rs b/tests/ui/empty_line_after_doc_comments.rs
new file mode 100644
index 00000000000..e843770f578
--- /dev/null
+++ b/tests/ui/empty_line_after_doc_comments.rs
@@ -0,0 +1,132 @@
+//@aux-build:proc_macro_attr.rs
+#![warn(clippy::empty_line_after_doc_comments)]
+#![allow(clippy::assertions_on_constants)]
+#![feature(custom_inner_attributes)]
+#![rustfmt::skip]
+
+#[macro_use]
+extern crate proc_macro_attr;
+
+mod some_mod {
+    //! This doc comment should *NOT* produce a warning
+
+    mod some_inner_mod {
+        fn some_noop() {}
+    }
+}
+
+/// This should produce a warning
+
+fn with_doc_and_newline() { assert!(true)}
+
+// This should *NOT* produce a warning
+#[crate_type = "lib"]
+
+/// some comment
+fn with_one_newline_and_comment() { assert!(true) }
+
+// This should *NOT* produce a warning
+#[crate_type = "lib"]
+/// some comment
+fn with_no_newline_and_comment() { assert!(true) }
+
+
+// This should *NOT* produce a warning
+#[crate_type = "lib"]
+
+fn with_one_newline() { assert!(true) }
+
+// This should *NOT* produce a warning
+#[crate_type = "lib"]
+
+
+fn with_two_newlines() { assert!(true) }
+
+
+// This should *NOT* produce a warning
+#[crate_type = "lib"]
+
+enum Baz {
+    One,
+    Two
+}
+
+// This should *NOT* produce a warning
+#[crate_type = "lib"]
+
+struct Foo {
+    one: isize,
+    two: isize
+}
+
+// This should *NOT* produce a warning
+#[crate_type = "lib"]
+
+mod foo {
+}
+
+/// This doc comment should produce a warning
+
+/** This is also a doc comment and should produce a warning
+ */
+
+// This should *NOT* produce a warning
+#[allow(non_camel_case_types)]
+#[allow(missing_docs)]
+#[allow(missing_docs)]
+fn three_attributes() { assert!(true) }
+
+// This should *NOT* produce a warning
+#[doc = "
+Returns the escaped value of the textual representation of
+
+"]
+pub fn function() -> bool {
+    true
+}
+
+// This should *NOT* produce a warning
+#[derive(Clone, Copy)]
+pub enum FooFighter {
+    Bar1,
+
+    Bar2,
+
+    Bar3,
+
+    Bar4
+}
+
+// This should *NOT* produce a warning because the empty line is inside a block comment
+#[crate_type = "lib"]
+/*
+
+*/
+pub struct S;
+
+// This should *NOT* produce a warning
+#[crate_type = "lib"]
+/* test */
+pub struct T;
+
+// This should *NOT* produce a warning
+// See https://github.com/rust-lang/rust-clippy/issues/5567
+#[fake_async_trait]
+pub trait Bazz {
+    fn foo() -> Vec<u8> {
+        let _i = "";
+
+
+
+        vec![]
+    }
+}
+
+#[derive(Clone, Copy)]
+#[dummy(string = "first line
+
+second line
+")]
+pub struct Args;
+
+fn main() {}
diff --git a/tests/ui/empty_line_after_doc_comments.stderr b/tests/ui/empty_line_after_doc_comments.stderr
new file mode 100644
index 00000000000..2ca1b51679e
--- /dev/null
+++ b/tests/ui/empty_line_after_doc_comments.stderr
@@ -0,0 +1,36 @@
+error: found an empty line after a doc comment. Perhaps you need to use `//!` to make a comment on a module, remove the empty line, or make a regular comment with `//`?
+  --> $DIR/empty_line_after_doc_comments.rs:18:1
+   |
+LL | / /// This should produce a warning
+LL | |
+LL | | fn with_doc_and_newline() { assert!(true)}
+   | |_
+   |
+   = note: `-D clippy::empty-line-after-doc-comments` implied by `-D warnings`
+
+error: found an empty line after a doc comment. Perhaps you need to use `//!` to make a comment on a module, remove the empty line, or make a regular comment with `//`?
+  --> $DIR/empty_line_after_doc_comments.rs:68:1
+   |
+LL | / /// This doc comment should produce a warning
+LL | |
+LL | | /** This is also a doc comment and should produce a warning
+LL | |  */
+...  |
+LL | | #[allow(missing_docs)]
+LL | | fn three_attributes() { assert!(true) }
+   | |_
+
+error: found an empty line after a doc comment. Perhaps you need to use `//!` to make a comment on a module, remove the empty line, or make a regular comment with `//`?
+  --> $DIR/empty_line_after_doc_comments.rs:70:1
+   |
+LL | / /** This is also a doc comment and should produce a warning
+LL | |  */
+LL | |
+LL | | // This should *NOT* produce a warning
+...  |
+LL | | #[allow(missing_docs)]
+LL | | fn three_attributes() { assert!(true) }
+   | |_
+
+error: aborting due to 3 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From a8834bc46ab948c8978b5fcbe0a7aa4760783338 Mon Sep 17 00:00:00 2001
From: Icxolu <10486322+Icxolu@users.noreply.github.com>
Date: Thu, 4 May 2023 22:44:35 +0200
Subject: add lint `manual_next_back`

checks for manual reverse iteration (`.rev().next()`) of a
`DoubleEndedIterator`
---
 CHANGELOG.md                                 |  1 +
 clippy_lints/src/declared_lints.rs           |  1 +
 clippy_lints/src/methods/manual_next_back.rs | 38 ++++++++++++++++++++++++++++
 clippy_lints/src/methods/mod.rs              | 26 +++++++++++++++++++
 tests/ui/manual_next_back.fixed              | 36 ++++++++++++++++++++++++++
 tests/ui/manual_next_back.rs                 | 36 ++++++++++++++++++++++++++
 tests/ui/manual_next_back.stderr             | 16 ++++++++++++
 7 files changed, 154 insertions(+)
 create mode 100644 clippy_lints/src/methods/manual_next_back.rs
 create mode 100644 tests/ui/manual_next_back.fixed
 create mode 100644 tests/ui/manual_next_back.rs
 create mode 100644 tests/ui/manual_next_back.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 85d451a87d0..4cb937e8766 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4785,6 +4785,7 @@ Released 2018-09-13
 [`manual_main_separator_str`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_main_separator_str
 [`manual_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_map
 [`manual_memcpy`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_memcpy
+[`manual_next_back`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_next_back
 [`manual_non_exhaustive`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_non_exhaustive
 [`manual_ok_or`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_ok_or
 [`manual_range_contains`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_range_contains
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 6614b99713a..982d5a802f5 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -351,6 +351,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::methods::ITER_WITH_DRAIN_INFO,
     crate::methods::MANUAL_FILTER_MAP_INFO,
     crate::methods::MANUAL_FIND_MAP_INFO,
+    crate::methods::MANUAL_NEXT_BACK_INFO,
     crate::methods::MANUAL_OK_OR_INFO,
     crate::methods::MANUAL_SATURATING_ARITHMETIC_INFO,
     crate::methods::MANUAL_SPLIT_ONCE_INFO,
diff --git a/clippy_lints/src/methods/manual_next_back.rs b/clippy_lints/src/methods/manual_next_back.rs
new file mode 100644
index 00000000000..5f3fec53827
--- /dev/null
+++ b/clippy_lints/src/methods/manual_next_back.rs
@@ -0,0 +1,38 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::is_trait_method;
+use clippy_utils::ty::implements_trait;
+use rustc_errors::Applicability;
+use rustc_hir::Expr;
+use rustc_lint::LateContext;
+use rustc_span::symbol::sym;
+
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx Expr<'_>,
+    rev_call: &'tcx Expr<'_>,
+    rev_recv: &'tcx Expr<'_>,
+) {
+    let rev_recv_ty = cx.typeck_results().expr_ty(rev_recv);
+
+    // check that the receiver of `rev` implements `DoubleEndedIterator` and
+    // that `rev` and `next` come from `Iterator`
+    if cx
+        .tcx
+        .get_diagnostic_item(sym::DoubleEndedIterator)
+        .map_or(false, |double_ended_iterator| {
+            implements_trait(cx, rev_recv_ty, double_ended_iterator, &[])
+        })
+        && is_trait_method(cx, rev_call, sym::Iterator)
+        && is_trait_method(cx, expr, sym::Iterator)
+    {
+        span_lint_and_sugg(
+            cx,
+            super::MANUAL_NEXT_BACK,
+            expr.span.with_lo(rev_recv.span.hi()),
+            "manual backwards iteration",
+            "use",
+            String::from(".next_back()"),
+            Applicability::MachineApplicable,
+        );
+    }
+}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 06b88e34d24..cb86917464b 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -45,6 +45,7 @@ mod iter_overeager_cloned;
 mod iter_skip_next;
 mod iter_with_drain;
 mod iterator_step_by_zero;
+mod manual_next_back;
 mod manual_ok_or;
 mod manual_saturating_arithmetic;
 mod manual_str_repeat;
@@ -3193,6 +3194,29 @@ declare_clippy_lint! {
     "calling `drain` in order to `clear` a container"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `.rev().next()` on a `DoubleEndedIterator`
+    ///
+    /// ### Why is this bad?
+    /// `.next_back()` is cleaner.
+    ///
+    /// ### Example
+    /// ```rust
+    /// # let foo = [0; 10];
+    /// foo.iter().rev().next();
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// # let foo = [0; 10];
+    /// foo.iter().next_back();
+    /// ```
+    #[clippy::version = "1.71.0"]
+    pub MANUAL_NEXT_BACK,
+    style,
+    "manual reverse iteration of `DoubleEndedIterator`"
+}
+
 pub struct Methods {
     avoid_breaking_exported_api: bool,
     msrv: Msrv,
@@ -3321,6 +3345,7 @@ impl_lint_pass!(Methods => [
     NEEDLESS_COLLECT,
     SUSPICIOUS_COMMAND_ARG_SPACE,
     CLEAR_WITH_DRAIN,
+    MANUAL_NEXT_BACK,
 ]);
 
 /// Extracts a method call name, args, and `Span` of the method name.
@@ -3677,6 +3702,7 @@ impl Methods {
                             ("iter", []) => iter_next_slice::check(cx, expr, recv2),
                             ("skip", [arg]) => iter_skip_next::check(cx, expr, recv2, arg),
                             ("skip_while", [_]) => skip_while_next::check(cx, expr),
+                            ("rev", [])=> manual_next_back::check(cx, expr, recv, recv2),
                             _ => {},
                         }
                     }
diff --git a/tests/ui/manual_next_back.fixed b/tests/ui/manual_next_back.fixed
new file mode 100644
index 00000000000..e8a47063ad6
--- /dev/null
+++ b/tests/ui/manual_next_back.fixed
@@ -0,0 +1,36 @@
+//@run-rustfix
+
+#![allow(unused)]
+#![warn(clippy::manual_next_back)]
+
+struct FakeIter(std::ops::Range<i32>);
+
+impl FakeIter {
+    fn rev(self) -> Self {
+        self
+    }
+
+    fn next(&self) {}
+}
+
+impl DoubleEndedIterator for FakeIter {
+    fn next_back(&mut self) -> Option<Self::Item> {
+        self.0.next_back()
+    }
+}
+
+impl Iterator for FakeIter {
+    type Item = i32;
+    fn next(&mut self) -> Option<Self::Item> {
+        self.0.next()
+    }
+}
+
+fn main() {
+    // should not lint
+    FakeIter(0..10).rev().next();
+
+    // should lint
+    let _ = (0..10).next_back().unwrap();
+    let _ = "something".bytes().next_back();
+}
diff --git a/tests/ui/manual_next_back.rs b/tests/ui/manual_next_back.rs
new file mode 100644
index 00000000000..9ec89242241
--- /dev/null
+++ b/tests/ui/manual_next_back.rs
@@ -0,0 +1,36 @@
+//@run-rustfix
+
+#![allow(unused)]
+#![warn(clippy::manual_next_back)]
+
+struct FakeIter(std::ops::Range<i32>);
+
+impl FakeIter {
+    fn rev(self) -> Self {
+        self
+    }
+
+    fn next(&self) {}
+}
+
+impl DoubleEndedIterator for FakeIter {
+    fn next_back(&mut self) -> Option<Self::Item> {
+        self.0.next_back()
+    }
+}
+
+impl Iterator for FakeIter {
+    type Item = i32;
+    fn next(&mut self) -> Option<Self::Item> {
+        self.0.next()
+    }
+}
+
+fn main() {
+    // should not lint
+    FakeIter(0..10).rev().next();
+
+    // should lint
+    let _ = (0..10).rev().next().unwrap();
+    let _ = "something".bytes().rev().next();
+}
diff --git a/tests/ui/manual_next_back.stderr b/tests/ui/manual_next_back.stderr
new file mode 100644
index 00000000000..94ccaa9e4cc
--- /dev/null
+++ b/tests/ui/manual_next_back.stderr
@@ -0,0 +1,16 @@
+error: manual backwards iteration
+  --> $DIR/manual_next_back.rs:34:20
+   |
+LL |     let _ = (0..10).rev().next().unwrap();
+   |                    ^^^^^^^^^^^^^ help: use: `.next_back()`
+   |
+   = note: `-D clippy::manual-next-back` implied by `-D warnings`
+
+error: manual backwards iteration
+  --> $DIR/manual_next_back.rs:35:32
+   |
+LL |     let _ = "something".bytes().rev().next();
+   |                                ^^^^^^^^^^^^^ help: use: `.next_back()`
+
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 891fffef0ced6a62406db1b9c7742cc064af96ba Mon Sep 17 00:00:00 2001
From: Caio <c410.f3r@gmail.com>
Date: Sat, 13 May 2023 23:24:33 -0300
Subject: Consider referenced allowed or hard-coded types

---
 clippy_lints/src/operators/arithmetic_side_effects.rs | 10 +++++-----
 tests/ui/arithmetic_side_effects.rs                   |  8 ++++++++
 2 files changed, 13 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/operators/arithmetic_side_effects.rs b/clippy_lints/src/operators/arithmetic_side_effects.rs
index f72595987ee..c80e2ff7057 100644
--- a/clippy_lints/src/operators/arithmetic_side_effects.rs
+++ b/clippy_lints/src/operators/arithmetic_side_effects.rs
@@ -21,7 +21,7 @@ const HARD_CODED_ALLOWED_BINARY: &[[&str; 2]] = &[
     ["f64", "f64"],
     ["std::num::Saturating", "std::num::Saturating"],
     ["std::num::Wrapping", "std::num::Wrapping"],
-    ["std::string::String", "&str"],
+    ["std::string::String", "str"],
 ];
 const HARD_CODED_ALLOWED_UNARY: &[&str] = &["f32", "f64", "std::num::Saturating", "std::num::Wrapping"];
 const INTEGER_METHODS: &[&str] = &["saturating_div", "wrapping_div", "wrapping_rem", "wrapping_rem_euclid"];
@@ -144,8 +144,10 @@ impl ArithmeticSideEffects {
         ) {
             return;
         };
-        let lhs_ty = cx.typeck_results().expr_ty(lhs);
-        let rhs_ty = cx.typeck_results().expr_ty(rhs);
+        let (actual_lhs, lhs_ref_counter) = peel_hir_expr_refs(lhs);
+        let (actual_rhs, rhs_ref_counter) = peel_hir_expr_refs(rhs);
+        let lhs_ty = cx.typeck_results().expr_ty(actual_lhs).peel_refs();
+        let rhs_ty = cx.typeck_results().expr_ty(actual_rhs).peel_refs();
         if self.has_allowed_binary(lhs_ty, rhs_ty) {
             return;
         }
@@ -154,8 +156,6 @@ impl ArithmeticSideEffects {
                 // At least for integers, shifts are already handled by the CTFE
                 return;
             }
-            let (actual_lhs, lhs_ref_counter) = peel_hir_expr_refs(lhs);
-            let (actual_rhs, rhs_ref_counter) = peel_hir_expr_refs(rhs);
             match (
                 Self::literal_integer(cx, actual_lhs),
                 Self::literal_integer(cx, actual_rhs),
diff --git a/tests/ui/arithmetic_side_effects.rs b/tests/ui/arithmetic_side_effects.rs
index ab408bdf261..f95af1017bc 100644
--- a/tests/ui/arithmetic_side_effects.rs
+++ b/tests/ui/arithmetic_side_effects.rs
@@ -458,4 +458,12 @@ pub fn issue_10583(a: u16) -> u16 {
     10 / a
 }
 
+pub fn issue_10767() {
+    let n = &1.0;
+    n + n;
+    3.1_f32 + &1.2_f32;
+    &3.4_f32 + 1.5_f32;
+    &3.5_f32 + &1.3_f32;
+}
+
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From e234dfa63ea36ac2d9ecf245e681b1dbac644140 Mon Sep 17 00:00:00 2001
From: Renato Lochetti <renato.lochetti@gmail.com>
Date: Sun, 14 May 2023 10:26:48 +0100
Subject: Ignoring `let_underscore_untyped` warnings in code from proc macros

---
 clippy_lints/src/let_underscore.rs     | 26 ++++++++++++++++----------
 tests/ui/let_underscore_untyped.rs     | 14 ++++++++++++++
 tests/ui/let_underscore_untyped.stderr | 20 ++++++++++----------
 3 files changed, 40 insertions(+), 20 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/let_underscore.rs b/clippy_lints/src/let_underscore.rs
index 16772a9d598..20a675d053e 100644
--- a/clippy_lints/src/let_underscore.rs
+++ b/clippy_lints/src/let_underscore.rs
@@ -1,4 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::is_from_proc_macro;
 use clippy_utils::ty::{implements_trait, is_must_use_ty, match_type};
 use clippy_utils::{is_must_use_func_call, paths};
 use rustc_hir::{ExprKind, Local, PatKind};
@@ -138,7 +139,7 @@ const SYNC_GUARD_PATHS: [&[&str]; 3] = [
 ];
 
 impl<'tcx> LateLintPass<'tcx> for LetUnderscore {
-    fn check_local(&mut self, cx: &LateContext<'_>, local: &Local<'_>) {
+    fn check_local(&mut self, cx: &LateContext<'tcx>, local: &Local<'tcx>) {
         if !in_external_macro(cx.tcx.sess, local.span)
             && let PatKind::Wild = local.pat.kind
             && let Some(init) = local.init
@@ -191,15 +192,20 @@ impl<'tcx> LateLintPass<'tcx> for LetUnderscore {
             if local.pat.default_binding_modes && local.ty.is_none() {
                 // When `default_binding_modes` is true, the `let` keyword is present.
 
-				// Ignore function calls that return impl traits...
-				if let Some(init) = local.init &&
-				matches!(init.kind, ExprKind::Call(_, _) | ExprKind::MethodCall(_, _, _, _)) {
-					let expr_ty = cx.typeck_results().expr_ty(init);
-					if expr_ty.is_impl_trait() {
-						return;
-					}
-				}
-
+				if let Some(init) = local.init {
+                    // Ignore function calls that return impl traits...
+                    if matches!(init.kind, ExprKind::Call(_, _) | ExprKind::MethodCall(_, _, _, _)) {
+                        let expr_ty = cx.typeck_results().expr_ty(init);
+                        if expr_ty.is_impl_trait() {
+                            return;
+                        }
+                    }
+    
+                    // Ignore if it is from a procedural macro...
+                    if is_from_proc_macro(cx, init) {
+                        return;
+                    }
+                }
 
 				span_lint_and_help(
                     cx,
diff --git a/tests/ui/let_underscore_untyped.rs b/tests/ui/let_underscore_untyped.rs
index 8486137d3a6..05ecd9b281a 100644
--- a/tests/ui/let_underscore_untyped.rs
+++ b/tests/ui/let_underscore_untyped.rs
@@ -1,6 +1,12 @@
+//@aux-build: proc_macros.rs
+
 #![allow(unused)]
 #![warn(clippy::let_underscore_untyped)]
 
+extern crate proc_macros;
+use proc_macros::with_span;
+
+use clippy_utils::is_from_proc_macro;
 use std::future::Future;
 use std::{boxed::Box, fmt::Display};
 
@@ -32,6 +38,14 @@ fn g() -> impl Fn() {
     || {}
 }
 
+with_span!(
+    span
+
+    fn dont_lint_proc_macro() {
+        let _ = a();
+    }
+);
+
 fn main() {
     let _ = a();
     let _ = b(1);
diff --git a/tests/ui/let_underscore_untyped.stderr b/tests/ui/let_underscore_untyped.stderr
index 6844cb998f7..bbf2508af10 100644
--- a/tests/ui/let_underscore_untyped.stderr
+++ b/tests/ui/let_underscore_untyped.stderr
@@ -1,60 +1,60 @@
 error: non-binding `let` without a type annotation
-  --> $DIR/let_underscore_untyped.rs:36:5
+  --> $DIR/let_underscore_untyped.rs:50:5
    |
 LL |     let _ = a();
    |     ^^^^^^^^^^^^
    |
 help: consider adding a type annotation
-  --> $DIR/let_underscore_untyped.rs:36:10
+  --> $DIR/let_underscore_untyped.rs:50:10
    |
 LL |     let _ = a();
    |          ^
    = note: `-D clippy::let-underscore-untyped` implied by `-D warnings`
 
 error: non-binding `let` without a type annotation
-  --> $DIR/let_underscore_untyped.rs:37:5
+  --> $DIR/let_underscore_untyped.rs:51:5
    |
 LL |     let _ = b(1);
    |     ^^^^^^^^^^^^^
    |
 help: consider adding a type annotation
-  --> $DIR/let_underscore_untyped.rs:37:10
+  --> $DIR/let_underscore_untyped.rs:51:10
    |
 LL |     let _ = b(1);
    |          ^
 
 error: non-binding `let` without a type annotation
-  --> $DIR/let_underscore_untyped.rs:39:5
+  --> $DIR/let_underscore_untyped.rs:53:5
    |
 LL |     let _ = d(&1);
    |     ^^^^^^^^^^^^^^
    |
 help: consider adding a type annotation
-  --> $DIR/let_underscore_untyped.rs:39:10
+  --> $DIR/let_underscore_untyped.rs:53:10
    |
 LL |     let _ = d(&1);
    |          ^
 
 error: non-binding `let` without a type annotation
-  --> $DIR/let_underscore_untyped.rs:40:5
+  --> $DIR/let_underscore_untyped.rs:54:5
    |
 LL |     let _ = e();
    |     ^^^^^^^^^^^^
    |
 help: consider adding a type annotation
-  --> $DIR/let_underscore_untyped.rs:40:10
+  --> $DIR/let_underscore_untyped.rs:54:10
    |
 LL |     let _ = e();
    |          ^
 
 error: non-binding `let` without a type annotation
-  --> $DIR/let_underscore_untyped.rs:41:5
+  --> $DIR/let_underscore_untyped.rs:55:5
    |
 LL |     let _ = f();
    |     ^^^^^^^^^^^^
    |
 help: consider adding a type annotation
-  --> $DIR/let_underscore_untyped.rs:41:10
+  --> $DIR/let_underscore_untyped.rs:55:10
    |
 LL |     let _ = f();
    |          ^
-- 
cgit 1.4.1-3-g733a5


From df200aaf39184258ad2fb5d2d9a4682fb069bbd5 Mon Sep 17 00:00:00 2001
From: Renato Lochetti <renato.lochetti@gmail.com>
Date: Sun, 14 May 2023 10:38:32 +0100
Subject: fixing fmt

---
 clippy_lints/src/let_underscore.rs | 1 -
 1 file changed, 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/let_underscore.rs b/clippy_lints/src/let_underscore.rs
index 20a675d053e..0596ea732f3 100644
--- a/clippy_lints/src/let_underscore.rs
+++ b/clippy_lints/src/let_underscore.rs
@@ -200,7 +200,6 @@ impl<'tcx> LateLintPass<'tcx> for LetUnderscore {
                             return;
                         }
                     }
-    
                     // Ignore if it is from a procedural macro...
                     if is_from_proc_macro(cx, init) {
                         return;
-- 
cgit 1.4.1-3-g733a5


From 493b2ae8dc8f077a4a54fa5f9aca095dedb15e73 Mon Sep 17 00:00:00 2001
From: Caio <c410.f3r@gmail.com>
Date: Sun, 14 May 2023 08:37:12 -0300
Subject: Rename integer_arithmetic

---
 clippy_lints/src/declared_lints.rs               |   1 -
 clippy_lints/src/operators/mod.rs                |  27 ----
 clippy_lints/src/operators/numeric_arithmetic.rs |  45 +-----
 clippy_lints/src/renamed_lints.rs                |   1 +
 tests/ui/float_arithmetic.rs                     |   2 +-
 tests/ui/integer_arithmetic.rs                   | 109 ---------------
 tests/ui/integer_arithmetic.stderr               | 169 -----------------------
 tests/ui/needless_return.fixed                   |   5 +-
 tests/ui/needless_return.rs                      |   5 +-
 tests/ui/needless_return.stderr                  |  26 ++--
 tests/ui/rename.fixed                            |   2 +
 tests/ui/rename.rs                               |   2 +
 tests/ui/rename.stderr                           |  94 +++++++------
 13 files changed, 81 insertions(+), 407 deletions(-)
 delete mode 100644 tests/ui/integer_arithmetic.rs
 delete mode 100644 tests/ui/integer_arithmetic.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index a3a6f1746bc..40c64efaa37 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -491,7 +491,6 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::operators::FLOAT_EQUALITY_WITHOUT_ABS_INFO,
     crate::operators::IDENTITY_OP_INFO,
     crate::operators::INEFFECTIVE_BIT_MASK_INFO,
-    crate::operators::INTEGER_ARITHMETIC_INFO,
     crate::operators::INTEGER_DIVISION_INFO,
     crate::operators::MISREFACTORED_ASSIGN_OP_INFO,
     crate::operators::MODULO_ARITHMETIC_INFO,
diff --git a/clippy_lints/src/operators/mod.rs b/clippy_lints/src/operators/mod.rs
index 19599731bd6..d63a836e73d 100644
--- a/clippy_lints/src/operators/mod.rs
+++ b/clippy_lints/src/operators/mod.rs
@@ -96,32 +96,6 @@ declare_clippy_lint! {
     "any arithmetic expression that can cause side effects like overflows or panics"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for integer arithmetic operations which could overflow or panic.
-    ///
-    /// Specifically, checks for any operators (`+`, `-`, `*`, `<<`, etc) which are capable
-    /// of overflowing according to the [Rust
-    /// Reference](https://doc.rust-lang.org/reference/expressions/operator-expr.html#overflow),
-    /// or which can panic (`/`, `%`). No bounds analysis or sophisticated reasoning is
-    /// attempted.
-    ///
-    /// ### Why is this bad?
-    /// Integer overflow will trigger a panic in debug builds or will wrap in
-    /// release mode. Division by zero will cause a panic in either mode. In some applications one
-    /// wants explicitly checked, wrapping or saturating arithmetic.
-    ///
-    /// ### Example
-    /// ```rust
-    /// # let a = 0;
-    /// a + 1;
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub INTEGER_ARITHMETIC,
-    restriction,
-    "any integer arithmetic expression which could overflow or panic"
-}
-
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for float arithmetic.
@@ -787,7 +761,6 @@ pub struct Operators {
 impl_lint_pass!(Operators => [
     ABSURD_EXTREME_COMPARISONS,
     ARITHMETIC_SIDE_EFFECTS,
-    INTEGER_ARITHMETIC,
     FLOAT_ARITHMETIC,
     ASSIGN_OP_PATTERN,
     MISREFACTORED_ASSIGN_OP,
diff --git a/clippy_lints/src/operators/numeric_arithmetic.rs b/clippy_lints/src/operators/numeric_arithmetic.rs
index 77fd45b199a..102845ceed0 100644
--- a/clippy_lints/src/operators/numeric_arithmetic.rs
+++ b/clippy_lints/src/operators/numeric_arithmetic.rs
@@ -1,8 +1,6 @@
-use super::{FLOAT_ARITHMETIC, INTEGER_ARITHMETIC};
+use super::FLOAT_ARITHMETIC;
 use clippy_utils::consts::constant_simple;
 use clippy_utils::diagnostics::span_lint;
-use clippy_utils::is_from_proc_macro;
-use clippy_utils::is_integer_literal;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
 use rustc_span::source_map::Span;
@@ -45,31 +43,8 @@ impl Context {
             _ => (),
         }
 
-        let (l_ty, r_ty) = (cx.typeck_results().expr_ty(l), cx.typeck_results().expr_ty(r));
-        if l_ty.peel_refs().is_integral() && r_ty.peel_refs().is_integral() {
-            if is_from_proc_macro(cx, expr) {
-                return;
-            }
-            match op {
-                hir::BinOpKind::Div | hir::BinOpKind::Rem => match &r.kind {
-                    hir::ExprKind::Lit(_lit) => (),
-                    hir::ExprKind::Unary(hir::UnOp::Neg, expr) => {
-                        if is_integer_literal(expr, 1) {
-                            span_lint(cx, INTEGER_ARITHMETIC, expr.span, "integer arithmetic detected");
-                            self.expr_id = Some(expr.hir_id);
-                        }
-                    },
-                    _ => {
-                        span_lint(cx, INTEGER_ARITHMETIC, expr.span, "integer arithmetic detected");
-                        self.expr_id = Some(expr.hir_id);
-                    },
-                },
-                _ => {
-                    span_lint(cx, INTEGER_ARITHMETIC, expr.span, "integer arithmetic detected");
-                    self.expr_id = Some(expr.hir_id);
-                },
-            }
-        } else if r_ty.peel_refs().is_floating_point() && r_ty.peel_refs().is_floating_point() {
+        let (_, r_ty) = (cx.typeck_results().expr_ty(l), cx.typeck_results().expr_ty(r));
+        if r_ty.peel_refs().is_floating_point() && r_ty.peel_refs().is_floating_point() {
             span_lint(cx, FLOAT_ARITHMETIC, expr.span, "floating-point arithmetic detected");
             self.expr_id = Some(expr.hir_id);
         }
@@ -80,17 +55,9 @@ impl Context {
             return;
         }
         let ty = cx.typeck_results().expr_ty(arg);
-        if constant_simple(cx, cx.typeck_results(), expr).is_none() {
-            if ty.is_integral() {
-                if is_from_proc_macro(cx, expr) {
-                    return;
-                }
-                span_lint(cx, INTEGER_ARITHMETIC, expr.span, "integer arithmetic detected");
-                self.expr_id = Some(expr.hir_id);
-            } else if ty.is_floating_point() {
-                span_lint(cx, FLOAT_ARITHMETIC, expr.span, "floating-point arithmetic detected");
-                self.expr_id = Some(expr.hir_id);
-            }
+        if constant_simple(cx, cx.typeck_results(), expr).is_none() && ty.is_floating_point() {
+            span_lint(cx, FLOAT_ARITHMETIC, expr.span, "floating-point arithmetic detected");
+            self.expr_id = Some(expr.hir_id);
         }
     }
 
diff --git a/clippy_lints/src/renamed_lints.rs b/clippy_lints/src/renamed_lints.rs
index 5e81a01a461..79d2ca15988 100644
--- a/clippy_lints/src/renamed_lints.rs
+++ b/clippy_lints/src/renamed_lints.rs
@@ -15,6 +15,7 @@ pub static RENAMED_LINTS: &[(&str, &str)] = &[
     ("clippy::eval_order_dependence", "clippy::mixed_read_write_in_expression"),
     ("clippy::identity_conversion", "clippy::useless_conversion"),
     ("clippy::if_let_some_result", "clippy::match_result_ok"),
+    ("clippy::integer_arithmetic", "clippy::arithmetic_side_effects"),
     ("clippy::logic_bug", "clippy::overly_complex_bool_expr"),
     ("clippy::new_without_default_derive", "clippy::new_without_default"),
     ("clippy::option_and_then_some", "clippy::bind_instead_of_map"),
diff --git a/tests/ui/float_arithmetic.rs b/tests/ui/float_arithmetic.rs
index 60fa7569eb9..a928c35e8bc 100644
--- a/tests/ui/float_arithmetic.rs
+++ b/tests/ui/float_arithmetic.rs
@@ -1,4 +1,4 @@
-#![warn(clippy::integer_arithmetic, clippy::float_arithmetic)]
+#![warn(clippy::arithmetic_side_effects, clippy::float_arithmetic)]
 #![allow(
     unused,
     clippy::shadow_reuse,
diff --git a/tests/ui/integer_arithmetic.rs b/tests/ui/integer_arithmetic.rs
deleted file mode 100644
index ab9b6094c2c..00000000000
--- a/tests/ui/integer_arithmetic.rs
+++ /dev/null
@@ -1,109 +0,0 @@
-//@aux-build:proc_macro_derive.rs
-
-#![warn(clippy::integer_arithmetic, clippy::float_arithmetic)]
-#![allow(clippy::no_effect, clippy::unnecessary_operation, clippy::op_ref)]
-
-extern crate proc_macro_derive;
-
-#[derive(proc_macro_derive::ShadowDerive)]
-pub struct Nothing;
-
-#[rustfmt::skip]
-fn main() {
-    let mut i = 1i32;
-    let mut var1 = 13i32;
-    let mut var2 = -1i32;
-    1 + i;
-    i * 2;
-    1 %
-    i / 2; // no error, this is part of the expression in the preceding line
-    i - 2 + 2 - i;
-    -i;
-    i >> 1;
-    i << 1;
-
-    // no error, overflows are checked by `overflowing_literals`
-    -1;
-    -(-1);
-
-    i & 1; // no wrapping
-    i | 1;
-    i ^ 1;
-
-    i += 1;
-    i -= 1;
-    i *= 2;
-    i /= 2;
-    i /= 0;
-    i /= -1;
-    i /= var1;
-    i /= var2;
-    i %= 2;
-    i %= 0;
-    i %= -1;
-    i %= var1;
-    i %= var2;
-    i <<= 3;
-    i >>= 2;
-
-    // no errors
-    i |= 1;
-    i &= 1;
-    i ^= i;
-
-    // No errors for the following items because they are constant expressions
-    enum Foo {
-        Bar = -2,
-    }
-    struct Baz([i32; 1 + 1]);
-    union Qux {
-        field: [i32; 1 + 1],
-    }
-    type Alias = [i32; 1 + 1];
-
-    const FOO: i32 = -2;
-    static BAR: i32 = -2;
-
-    let _: [i32; 1 + 1] = [0, 0];
-
-    let _: [i32; 1 + 1] = {
-        let a: [i32; 1 + 1] = [0, 0];
-        a
-    };
-
-    trait Trait {
-        const ASSOC: i32 = 1 + 1;
-    }
-
-    impl Trait for Foo {
-        const ASSOC: i32 = {
-            let _: [i32; 1 + 1];
-            fn foo() {}
-            1 + 1
-        };
-    }
-}
-
-// warn on references as well! (#5328)
-pub fn int_arith_ref() {
-    3 + &1;
-    &3 + 1;
-    &3 + &1;
-}
-
-pub fn foo(x: &i32) -> i32 {
-    let a = 5;
-    a + x
-}
-
-pub fn bar(x: &i32, y: &i32) -> i32 {
-    x + y
-}
-
-pub fn baz(x: i32, y: &i32) -> i32 {
-    x + y
-}
-
-pub fn qux(x: i32, y: i32) -> i32 {
-    (&x + &y)
-}
diff --git a/tests/ui/integer_arithmetic.stderr b/tests/ui/integer_arithmetic.stderr
deleted file mode 100644
index add3b6b90fa..00000000000
--- a/tests/ui/integer_arithmetic.stderr
+++ /dev/null
@@ -1,169 +0,0 @@
-error: this operation will panic at runtime
-  --> $DIR/integer_arithmetic.rs:37:5
-   |
-LL |     i /= 0;
-   |     ^^^^^^ attempt to divide `_` by zero
-   |
-   = note: `#[deny(unconditional_panic)]` on by default
-
-error: this operation will panic at runtime
-  --> $DIR/integer_arithmetic.rs:42:5
-   |
-LL |     i %= 0;
-   |     ^^^^^^ attempt to calculate the remainder of `_` with a divisor of zero
-
-error: integer arithmetic detected
-  --> $DIR/integer_arithmetic.rs:16:5
-   |
-LL |     1 + i;
-   |     ^^^^^
-   |
-   = note: `-D clippy::integer-arithmetic` implied by `-D warnings`
-
-error: integer arithmetic detected
-  --> $DIR/integer_arithmetic.rs:17:5
-   |
-LL |     i * 2;
-   |     ^^^^^
-
-error: integer arithmetic detected
-  --> $DIR/integer_arithmetic.rs:18:5
-   |
-LL | /     1 %
-LL | |     i / 2; // no error, this is part of the expression in the preceding line
-   | |_____^
-
-error: integer arithmetic detected
-  --> $DIR/integer_arithmetic.rs:20:5
-   |
-LL |     i - 2 + 2 - i;
-   |     ^^^^^^^^^^^^^
-
-error: integer arithmetic detected
-  --> $DIR/integer_arithmetic.rs:21:5
-   |
-LL |     -i;
-   |     ^^
-
-error: integer arithmetic detected
-  --> $DIR/integer_arithmetic.rs:22:5
-   |
-LL |     i >> 1;
-   |     ^^^^^^
-
-error: integer arithmetic detected
-  --> $DIR/integer_arithmetic.rs:23:5
-   |
-LL |     i << 1;
-   |     ^^^^^^
-
-error: integer arithmetic detected
-  --> $DIR/integer_arithmetic.rs:33:5
-   |
-LL |     i += 1;
-   |     ^^^^^^
-
-error: integer arithmetic detected
-  --> $DIR/integer_arithmetic.rs:34:5
-   |
-LL |     i -= 1;
-   |     ^^^^^^
-
-error: integer arithmetic detected
-  --> $DIR/integer_arithmetic.rs:35:5
-   |
-LL |     i *= 2;
-   |     ^^^^^^
-
-error: integer arithmetic detected
-  --> $DIR/integer_arithmetic.rs:38:11
-   |
-LL |     i /= -1;
-   |           ^
-
-error: integer arithmetic detected
-  --> $DIR/integer_arithmetic.rs:39:5
-   |
-LL |     i /= var1;
-   |     ^^^^^^^^^
-
-error: integer arithmetic detected
-  --> $DIR/integer_arithmetic.rs:40:5
-   |
-LL |     i /= var2;
-   |     ^^^^^^^^^
-
-error: integer arithmetic detected
-  --> $DIR/integer_arithmetic.rs:43:11
-   |
-LL |     i %= -1;
-   |           ^
-
-error: integer arithmetic detected
-  --> $DIR/integer_arithmetic.rs:44:5
-   |
-LL |     i %= var1;
-   |     ^^^^^^^^^
-
-error: integer arithmetic detected
-  --> $DIR/integer_arithmetic.rs:45:5
-   |
-LL |     i %= var2;
-   |     ^^^^^^^^^
-
-error: integer arithmetic detected
-  --> $DIR/integer_arithmetic.rs:46:5
-   |
-LL |     i <<= 3;
-   |     ^^^^^^^
-
-error: integer arithmetic detected
-  --> $DIR/integer_arithmetic.rs:47:5
-   |
-LL |     i >>= 2;
-   |     ^^^^^^^
-
-error: integer arithmetic detected
-  --> $DIR/integer_arithmetic.rs:89:5
-   |
-LL |     3 + &1;
-   |     ^^^^^^
-
-error: integer arithmetic detected
-  --> $DIR/integer_arithmetic.rs:90:5
-   |
-LL |     &3 + 1;
-   |     ^^^^^^
-
-error: integer arithmetic detected
-  --> $DIR/integer_arithmetic.rs:91:5
-   |
-LL |     &3 + &1;
-   |     ^^^^^^^
-
-error: integer arithmetic detected
-  --> $DIR/integer_arithmetic.rs:96:5
-   |
-LL |     a + x
-   |     ^^^^^
-
-error: integer arithmetic detected
-  --> $DIR/integer_arithmetic.rs:100:5
-   |
-LL |     x + y
-   |     ^^^^^
-
-error: integer arithmetic detected
-  --> $DIR/integer_arithmetic.rs:104:5
-   |
-LL |     x + y
-   |     ^^^^^
-
-error: integer arithmetic detected
-  --> $DIR/integer_arithmetic.rs:108:5
-   |
-LL |     (&x + &y)
-   |     ^^^^^^^^^
-
-error: aborting due to 27 previous errors
-
diff --git a/tests/ui/needless_return.fixed b/tests/ui/needless_return.fixed
index ee4e5007dc5..d49ae5d8636 100644
--- a/tests/ui/needless_return.fixed
+++ b/tests/ui/needless_return.fixed
@@ -231,8 +231,9 @@ fn needless_return_macro() -> String {
 }
 
 fn issue_9361() -> i32 {
-    #[allow(clippy::integer_arithmetic)]
-    return 1 + 2;
+    let n = 1;
+    #[allow(clippy::arithmetic_side_effects)]
+    return n + n;
 }
 
 fn issue8336(x: i32) -> bool {
diff --git a/tests/ui/needless_return.rs b/tests/ui/needless_return.rs
index cd999db4f40..36763826174 100644
--- a/tests/ui/needless_return.rs
+++ b/tests/ui/needless_return.rs
@@ -239,8 +239,9 @@ fn needless_return_macro() -> String {
 }
 
 fn issue_9361() -> i32 {
-    #[allow(clippy::integer_arithmetic)]
-    return 1 + 2;
+    let n = 1;
+    #[allow(clippy::arithmetic_side_effects)]
+    return n + n;
 }
 
 fn issue8336(x: i32) -> bool {
diff --git a/tests/ui/needless_return.stderr b/tests/ui/needless_return.stderr
index 87d0cd3e14c..05f6038cd25 100644
--- a/tests/ui/needless_return.stderr
+++ b/tests/ui/needless_return.stderr
@@ -328,7 +328,7 @@ LL |     return format!("Hello {}", "world!");
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:249:9
+  --> $DIR/needless_return.rs:250:9
    |
 LL |         return true;
    |         ^^^^^^^^^^^
@@ -336,7 +336,7 @@ LL |         return true;
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:251:9
+  --> $DIR/needless_return.rs:252:9
    |
 LL |         return false;
    |         ^^^^^^^^^^^^
@@ -344,7 +344,7 @@ LL |         return false;
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:258:13
+  --> $DIR/needless_return.rs:259:13
    |
 LL |             return 10;
    |             ^^^^^^^^^
@@ -352,7 +352,7 @@ LL |             return 10;
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:261:13
+  --> $DIR/needless_return.rs:262:13
    |
 LL |             return 100;
    |             ^^^^^^^^^^
@@ -360,7 +360,7 @@ LL |             return 100;
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:269:9
+  --> $DIR/needless_return.rs:270:9
    |
 LL |         return 0;
    |         ^^^^^^^^
@@ -368,7 +368,7 @@ LL |         return 0;
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:276:13
+  --> $DIR/needless_return.rs:277:13
    |
 LL |             return *(x as *const isize);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -376,7 +376,7 @@ LL |             return *(x as *const isize);
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:278:13
+  --> $DIR/needless_return.rs:279:13
    |
 LL |             return !*(x as *const isize);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -384,7 +384,7 @@ LL |             return !*(x as *const isize);
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:285:20
+  --> $DIR/needless_return.rs:286:20
    |
 LL |           let _ = 42;
    |  ____________________^
@@ -395,7 +395,7 @@ LL | |         return;
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:292:20
+  --> $DIR/needless_return.rs:293:20
    |
 LL |         let _ = 42; return;
    |                    ^^^^^^^
@@ -403,7 +403,7 @@ LL |         let _ = 42; return;
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:304:9
+  --> $DIR/needless_return.rs:305:9
    |
 LL |         return Ok(format!("ok!"));
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -411,7 +411,7 @@ LL |         return Ok(format!("ok!"));
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:306:9
+  --> $DIR/needless_return.rs:307:9
    |
 LL |         return Err(format!("err!"));
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -419,7 +419,7 @@ LL |         return Err(format!("err!"));
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:312:9
+  --> $DIR/needless_return.rs:313:9
    |
 LL |         return if true { 1 } else { 2 };
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -427,7 +427,7 @@ LL |         return if true { 1 } else { 2 };
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:316:9
+  --> $DIR/needless_return.rs:317:9
    |
 LL |         return if b1 { 0 } else { 1 } | if b2 { 2 } else { 3 } | if b3 { 4 } else { 5 };
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/rename.fixed b/tests/ui/rename.fixed
index aa3b4f53d72..104c8191712 100644
--- a/tests/ui/rename.fixed
+++ b/tests/ui/rename.fixed
@@ -16,6 +16,7 @@
 #![allow(clippy::mixed_read_write_in_expression)]
 #![allow(clippy::useless_conversion)]
 #![allow(clippy::match_result_ok)]
+#![allow(clippy::arithmetic_side_effects)]
 #![allow(clippy::overly_complex_bool_expr)]
 #![allow(clippy::new_without_default)]
 #![allow(clippy::bind_instead_of_map)]
@@ -53,6 +54,7 @@
 #![warn(clippy::mixed_read_write_in_expression)]
 #![warn(clippy::useless_conversion)]
 #![warn(clippy::match_result_ok)]
+#![warn(clippy::arithmetic_side_effects)]
 #![warn(clippy::overly_complex_bool_expr)]
 #![warn(clippy::new_without_default)]
 #![warn(clippy::bind_instead_of_map)]
diff --git a/tests/ui/rename.rs b/tests/ui/rename.rs
index 600ec79fcbf..c7fc7a47a4a 100644
--- a/tests/ui/rename.rs
+++ b/tests/ui/rename.rs
@@ -16,6 +16,7 @@
 #![allow(clippy::mixed_read_write_in_expression)]
 #![allow(clippy::useless_conversion)]
 #![allow(clippy::match_result_ok)]
+#![allow(clippy::arithmetic_side_effects)]
 #![allow(clippy::overly_complex_bool_expr)]
 #![allow(clippy::new_without_default)]
 #![allow(clippy::bind_instead_of_map)]
@@ -53,6 +54,7 @@
 #![warn(clippy::eval_order_dependence)]
 #![warn(clippy::identity_conversion)]
 #![warn(clippy::if_let_some_result)]
+#![warn(clippy::integer_arithmetic)]
 #![warn(clippy::logic_bug)]
 #![warn(clippy::new_without_default_derive)]
 #![warn(clippy::option_and_then_some)]
diff --git a/tests/ui/rename.stderr b/tests/ui/rename.stderr
index 70d15408b9f..d44bd9c4d2a 100644
--- a/tests/ui/rename.stderr
+++ b/tests/ui/rename.stderr
@@ -1,5 +1,5 @@
 error: lint `clippy::almost_complete_letter_range` has been renamed to `clippy::almost_complete_range`
-  --> $DIR/rename.rs:43:9
+  --> $DIR/rename.rs:44:9
    |
 LL | #![warn(clippy::almost_complete_letter_range)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::almost_complete_range`
@@ -7,256 +7,262 @@ LL | #![warn(clippy::almost_complete_letter_range)]
    = note: `-D renamed-and-removed-lints` implied by `-D warnings`
 
 error: lint `clippy::blacklisted_name` has been renamed to `clippy::disallowed_names`
-  --> $DIR/rename.rs:44:9
+  --> $DIR/rename.rs:45:9
    |
 LL | #![warn(clippy::blacklisted_name)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::disallowed_names`
 
 error: lint `clippy::block_in_if_condition_expr` has been renamed to `clippy::blocks_in_if_conditions`
-  --> $DIR/rename.rs:45:9
+  --> $DIR/rename.rs:46:9
    |
 LL | #![warn(clippy::block_in_if_condition_expr)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::blocks_in_if_conditions`
 
 error: lint `clippy::block_in_if_condition_stmt` has been renamed to `clippy::blocks_in_if_conditions`
-  --> $DIR/rename.rs:46:9
+  --> $DIR/rename.rs:47:9
    |
 LL | #![warn(clippy::block_in_if_condition_stmt)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::blocks_in_if_conditions`
 
 error: lint `clippy::box_vec` has been renamed to `clippy::box_collection`
-  --> $DIR/rename.rs:47:9
+  --> $DIR/rename.rs:48:9
    |
 LL | #![warn(clippy::box_vec)]
    |         ^^^^^^^^^^^^^^^ help: use the new name: `clippy::box_collection`
 
 error: lint `clippy::const_static_lifetime` has been renamed to `clippy::redundant_static_lifetimes`
-  --> $DIR/rename.rs:48:9
+  --> $DIR/rename.rs:49:9
    |
 LL | #![warn(clippy::const_static_lifetime)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::redundant_static_lifetimes`
 
 error: lint `clippy::cyclomatic_complexity` has been renamed to `clippy::cognitive_complexity`
-  --> $DIR/rename.rs:49:9
+  --> $DIR/rename.rs:50:9
    |
 LL | #![warn(clippy::cyclomatic_complexity)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::cognitive_complexity`
 
 error: lint `clippy::derive_hash_xor_eq` has been renamed to `clippy::derived_hash_with_manual_eq`
-  --> $DIR/rename.rs:50:9
+  --> $DIR/rename.rs:51:9
    |
 LL | #![warn(clippy::derive_hash_xor_eq)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::derived_hash_with_manual_eq`
 
 error: lint `clippy::disallowed_method` has been renamed to `clippy::disallowed_methods`
-  --> $DIR/rename.rs:51:9
+  --> $DIR/rename.rs:52:9
    |
 LL | #![warn(clippy::disallowed_method)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::disallowed_methods`
 
 error: lint `clippy::disallowed_type` has been renamed to `clippy::disallowed_types`
-  --> $DIR/rename.rs:52:9
+  --> $DIR/rename.rs:53:9
    |
 LL | #![warn(clippy::disallowed_type)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::disallowed_types`
 
 error: lint `clippy::eval_order_dependence` has been renamed to `clippy::mixed_read_write_in_expression`
-  --> $DIR/rename.rs:53:9
+  --> $DIR/rename.rs:54:9
    |
 LL | #![warn(clippy::eval_order_dependence)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::mixed_read_write_in_expression`
 
 error: lint `clippy::identity_conversion` has been renamed to `clippy::useless_conversion`
-  --> $DIR/rename.rs:54:9
+  --> $DIR/rename.rs:55:9
    |
 LL | #![warn(clippy::identity_conversion)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::useless_conversion`
 
 error: lint `clippy::if_let_some_result` has been renamed to `clippy::match_result_ok`
-  --> $DIR/rename.rs:55:9
+  --> $DIR/rename.rs:56:9
    |
 LL | #![warn(clippy::if_let_some_result)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::match_result_ok`
 
+error: lint `clippy::integer_arithmetic` has been renamed to `clippy::arithmetic_side_effects`
+  --> $DIR/rename.rs:57:9
+   |
+LL | #![warn(clippy::integer_arithmetic)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::arithmetic_side_effects`
+
 error: lint `clippy::logic_bug` has been renamed to `clippy::overly_complex_bool_expr`
-  --> $DIR/rename.rs:56:9
+  --> $DIR/rename.rs:58:9
    |
 LL | #![warn(clippy::logic_bug)]
    |         ^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::overly_complex_bool_expr`
 
 error: lint `clippy::new_without_default_derive` has been renamed to `clippy::new_without_default`
-  --> $DIR/rename.rs:57:9
+  --> $DIR/rename.rs:59:9
    |
 LL | #![warn(clippy::new_without_default_derive)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::new_without_default`
 
 error: lint `clippy::option_and_then_some` has been renamed to `clippy::bind_instead_of_map`
-  --> $DIR/rename.rs:58:9
+  --> $DIR/rename.rs:60:9
    |
 LL | #![warn(clippy::option_and_then_some)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::bind_instead_of_map`
 
 error: lint `clippy::option_expect_used` has been renamed to `clippy::expect_used`
-  --> $DIR/rename.rs:59:9
+  --> $DIR/rename.rs:61:9
    |
 LL | #![warn(clippy::option_expect_used)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::expect_used`
 
 error: lint `clippy::option_map_unwrap_or` has been renamed to `clippy::map_unwrap_or`
-  --> $DIR/rename.rs:60:9
+  --> $DIR/rename.rs:62:9
    |
 LL | #![warn(clippy::option_map_unwrap_or)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::map_unwrap_or`
 
 error: lint `clippy::option_map_unwrap_or_else` has been renamed to `clippy::map_unwrap_or`
-  --> $DIR/rename.rs:61:9
+  --> $DIR/rename.rs:63:9
    |
 LL | #![warn(clippy::option_map_unwrap_or_else)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::map_unwrap_or`
 
 error: lint `clippy::option_unwrap_used` has been renamed to `clippy::unwrap_used`
-  --> $DIR/rename.rs:62:9
+  --> $DIR/rename.rs:64:9
    |
 LL | #![warn(clippy::option_unwrap_used)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::unwrap_used`
 
 error: lint `clippy::ref_in_deref` has been renamed to `clippy::needless_borrow`
-  --> $DIR/rename.rs:63:9
+  --> $DIR/rename.rs:65:9
    |
 LL | #![warn(clippy::ref_in_deref)]
    |         ^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::needless_borrow`
 
 error: lint `clippy::result_expect_used` has been renamed to `clippy::expect_used`
-  --> $DIR/rename.rs:64:9
+  --> $DIR/rename.rs:66:9
    |
 LL | #![warn(clippy::result_expect_used)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::expect_used`
 
 error: lint `clippy::result_map_unwrap_or_else` has been renamed to `clippy::map_unwrap_or`
-  --> $DIR/rename.rs:65:9
+  --> $DIR/rename.rs:67:9
    |
 LL | #![warn(clippy::result_map_unwrap_or_else)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::map_unwrap_or`
 
 error: lint `clippy::result_unwrap_used` has been renamed to `clippy::unwrap_used`
-  --> $DIR/rename.rs:66:9
+  --> $DIR/rename.rs:68:9
    |
 LL | #![warn(clippy::result_unwrap_used)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::unwrap_used`
 
 error: lint `clippy::single_char_push_str` has been renamed to `clippy::single_char_add_str`
-  --> $DIR/rename.rs:67:9
+  --> $DIR/rename.rs:69:9
    |
 LL | #![warn(clippy::single_char_push_str)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::single_char_add_str`
 
 error: lint `clippy::stutter` has been renamed to `clippy::module_name_repetitions`
-  --> $DIR/rename.rs:68:9
+  --> $DIR/rename.rs:70:9
    |
 LL | #![warn(clippy::stutter)]
    |         ^^^^^^^^^^^^^^^ help: use the new name: `clippy::module_name_repetitions`
 
 error: lint `clippy::to_string_in_display` has been renamed to `clippy::recursive_format_impl`
-  --> $DIR/rename.rs:69:9
+  --> $DIR/rename.rs:71:9
    |
 LL | #![warn(clippy::to_string_in_display)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::recursive_format_impl`
 
 error: lint `clippy::zero_width_space` has been renamed to `clippy::invisible_characters`
-  --> $DIR/rename.rs:70:9
+  --> $DIR/rename.rs:72:9
    |
 LL | #![warn(clippy::zero_width_space)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::invisible_characters`
 
 error: lint `clippy::clone_double_ref` has been renamed to `suspicious_double_ref_op`
-  --> $DIR/rename.rs:71:9
+  --> $DIR/rename.rs:73:9
    |
 LL | #![warn(clippy::clone_double_ref)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `suspicious_double_ref_op`
 
 error: lint `clippy::drop_bounds` has been renamed to `drop_bounds`
-  --> $DIR/rename.rs:72:9
+  --> $DIR/rename.rs:74:9
    |
 LL | #![warn(clippy::drop_bounds)]
    |         ^^^^^^^^^^^^^^^^^^^ help: use the new name: `drop_bounds`
 
 error: lint `clippy::for_loop_over_option` has been renamed to `for_loops_over_fallibles`
-  --> $DIR/rename.rs:73:9
+  --> $DIR/rename.rs:75:9
    |
 LL | #![warn(clippy::for_loop_over_option)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `for_loops_over_fallibles`
 
 error: lint `clippy::for_loop_over_result` has been renamed to `for_loops_over_fallibles`
-  --> $DIR/rename.rs:74:9
+  --> $DIR/rename.rs:76:9
    |
 LL | #![warn(clippy::for_loop_over_result)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `for_loops_over_fallibles`
 
 error: lint `clippy::for_loops_over_fallibles` has been renamed to `for_loops_over_fallibles`
-  --> $DIR/rename.rs:75:9
+  --> $DIR/rename.rs:77:9
    |
 LL | #![warn(clippy::for_loops_over_fallibles)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `for_loops_over_fallibles`
 
 error: lint `clippy::into_iter_on_array` has been renamed to `array_into_iter`
-  --> $DIR/rename.rs:76:9
+  --> $DIR/rename.rs:78:9
    |
 LL | #![warn(clippy::into_iter_on_array)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `array_into_iter`
 
 error: lint `clippy::invalid_atomic_ordering` has been renamed to `invalid_atomic_ordering`
-  --> $DIR/rename.rs:77:9
+  --> $DIR/rename.rs:79:9
    |
 LL | #![warn(clippy::invalid_atomic_ordering)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `invalid_atomic_ordering`
 
 error: lint `clippy::invalid_ref` has been renamed to `invalid_value`
-  --> $DIR/rename.rs:78:9
+  --> $DIR/rename.rs:80:9
    |
 LL | #![warn(clippy::invalid_ref)]
    |         ^^^^^^^^^^^^^^^^^^^ help: use the new name: `invalid_value`
 
 error: lint `clippy::let_underscore_drop` has been renamed to `let_underscore_drop`
-  --> $DIR/rename.rs:79:9
+  --> $DIR/rename.rs:81:9
    |
 LL | #![warn(clippy::let_underscore_drop)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `let_underscore_drop`
 
 error: lint `clippy::mem_discriminant_non_enum` has been renamed to `enum_intrinsics_non_enums`
-  --> $DIR/rename.rs:80:9
+  --> $DIR/rename.rs:82:9
    |
 LL | #![warn(clippy::mem_discriminant_non_enum)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `enum_intrinsics_non_enums`
 
 error: lint `clippy::panic_params` has been renamed to `non_fmt_panics`
-  --> $DIR/rename.rs:81:9
+  --> $DIR/rename.rs:83:9
    |
 LL | #![warn(clippy::panic_params)]
    |         ^^^^^^^^^^^^^^^^^^^^ help: use the new name: `non_fmt_panics`
 
 error: lint `clippy::positional_named_format_parameters` has been renamed to `named_arguments_used_positionally`
-  --> $DIR/rename.rs:82:9
+  --> $DIR/rename.rs:84:9
    |
 LL | #![warn(clippy::positional_named_format_parameters)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `named_arguments_used_positionally`
 
 error: lint `clippy::temporary_cstring_as_ptr` has been renamed to `temporary_cstring_as_ptr`
-  --> $DIR/rename.rs:83:9
+  --> $DIR/rename.rs:85:9
    |
 LL | #![warn(clippy::temporary_cstring_as_ptr)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `temporary_cstring_as_ptr`
 
 error: lint `clippy::unknown_clippy_lints` has been renamed to `unknown_lints`
-  --> $DIR/rename.rs:84:9
+  --> $DIR/rename.rs:86:9
    |
 LL | #![warn(clippy::unknown_clippy_lints)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `unknown_lints`
 
 error: lint `clippy::unused_label` has been renamed to `unused_labels`
-  --> $DIR/rename.rs:85:9
+  --> $DIR/rename.rs:87:9
    |
 LL | #![warn(clippy::unused_label)]
    |         ^^^^^^^^^^^^^^^^^^^^ help: use the new name: `unused_labels`
 
-error: aborting due to 43 previous errors
+error: aborting due to 44 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 84f89f30ebda5485badac09b34d666fbab243a19 Mon Sep 17 00:00:00 2001
From: Icxolu <10486322+Icxolu@users.noreply.github.com>
Date: Sat, 13 May 2023 11:47:05 +0200
Subject: enhance `needless_collect`

Updates `needless_collect` to lint for collecting into a method or
function argument thats taking an `IntoIterator` (for example `extend`).
Every `Iterator` trivially implements `IntoIterator` and colleting it
only causes an unnecessary allocation.
---
 clippy_lints/src/methods/needless_collect.rs | 68 +++++++++++++++++++++++++++-
 tests/ui/needless_collect.fixed              | 12 +++++
 tests/ui/needless_collect.rs                 | 12 +++++
 tests/ui/needless_collect.stderr             | 26 ++++++++++-
 4 files changed, 115 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/needless_collect.rs b/clippy_lints/src/methods/needless_collect.rs
index 0b0c6adc504..6841aaf626c 100644
--- a/clippy_lints/src/methods/needless_collect.rs
+++ b/clippy_lints/src/methods/needless_collect.rs
@@ -1,6 +1,5 @@
 use super::NEEDLESS_COLLECT;
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_hir_and_then};
-use clippy_utils::higher;
 use clippy_utils::source::{snippet, snippet_with_applicability};
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::{is_type_diagnostic_item, make_normalized_projection, make_projection};
@@ -8,6 +7,7 @@ use clippy_utils::{
     can_move_expr_to_closure, get_enclosing_block, get_parent_node, is_trait_method, path_to_local, path_to_local_id,
     CaptureKind,
 };
+use clippy_utils::{fn_def_id, higher};
 use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::{Applicability, MultiSpan};
 use rustc_hir::intravisit::{walk_block, walk_expr, Visitor};
@@ -16,7 +16,7 @@ use rustc_hir::{
 };
 use rustc_lint::LateContext;
 use rustc_middle::hir::nested_filter;
-use rustc_middle::ty::{self, AssocKind, EarlyBinder, GenericArg, GenericArgKind, Ty};
+use rustc_middle::ty::{self, AssocKind, Clause, EarlyBinder, GenericArg, GenericArgKind, PredicateKind, Ty};
 use rustc_span::symbol::Ident;
 use rustc_span::{sym, Span, Symbol};
 
@@ -32,6 +32,8 @@ pub(super) fn check<'tcx>(
     if let Some(parent) = get_parent_node(cx.tcx, collect_expr.hir_id) {
         match parent {
             Node::Expr(parent) => {
+                check_collect_into_intoiterator(cx, parent, collect_expr, call_span, iter_expr);
+
                 if let ExprKind::MethodCall(name, _, args @ ([] | [_]), _) = parent.kind {
                     let mut app = Applicability::MachineApplicable;
                     let name = name.ident.as_str();
@@ -134,6 +136,68 @@ pub(super) fn check<'tcx>(
     }
 }
 
+/// checks for for collecting into a (generic) method or function argument
+/// taking an `IntoIterator`
+fn check_collect_into_intoiterator<'tcx>(
+    cx: &LateContext<'tcx>,
+    parent: &'tcx Expr<'tcx>,
+    collect_expr: &'tcx Expr<'tcx>,
+    call_span: Span,
+    iter_expr: &'tcx Expr<'tcx>,
+) {
+    if let Some(id) = fn_def_id(cx, parent) {
+        let args = match parent.kind {
+            ExprKind::Call(_, args) | ExprKind::MethodCall(_, _, args, _) => args,
+            _ => &[],
+        };
+        // find the argument index of the `collect_expr` in the
+        // function / method call
+        if let Some(arg_idx) = args.iter().position(|e| e.hir_id == collect_expr.hir_id).map(|i| {
+            if matches!(parent.kind, ExprKind::MethodCall(_, _, _, _)) {
+                i + 1
+            } else {
+                i
+            }
+        }) {
+            // extract the input types of the function/method call
+            // that contains `collect_expr`
+            let inputs = cx
+                .tcx
+                .liberate_late_bound_regions(id, cx.tcx.fn_sig(id).subst_identity())
+                .inputs();
+
+            // map IntoIterator generic bounds to their signature
+            // types and check whether the argument type is an
+            // `IntoIterator`
+            if cx
+                .tcx
+                .param_env(id)
+                .caller_bounds()
+                .into_iter()
+                .filter_map(|p| {
+                    if let PredicateKind::Clause(Clause::Trait(t)) = p.kind().skip_binder()
+                            && cx.tcx.is_diagnostic_item(sym::IntoIterator,t.trait_ref.def_id) {
+                                Some(t.self_ty())
+                            } else {
+                                None
+                            }
+                })
+                .any(|ty| ty == inputs[arg_idx])
+            {
+                span_lint_and_sugg(
+                    cx,
+                    NEEDLESS_COLLECT,
+                    call_span.with_lo(iter_expr.span.hi()),
+                    NEEDLESS_COLLECT_MSG,
+                    "remove this call",
+                    String::new(),
+                    Applicability::MachineApplicable,
+                );
+            }
+        }
+    }
+}
+
 /// Checks if the given method call matches the expected signature of `([&[mut]] self) -> bool`
 fn is_is_empty_sig(cx: &LateContext<'_>, call_id: HirId) -> bool {
     cx.typeck_results().type_dependent_def_id(call_id).map_or(false, |id| {
diff --git a/tests/ui/needless_collect.fixed b/tests/ui/needless_collect.fixed
index 024c22de225..b7e80af5015 100644
--- a/tests/ui/needless_collect.fixed
+++ b/tests/ui/needless_collect.fixed
@@ -62,4 +62,16 @@ fn main() {
 
     let _ = sample.iter().next().is_none();
     let _ = sample.iter().any(|x| x == &0);
+
+    #[allow(clippy::double_parens)]
+    {
+        Vec::<u8>::new().extend((0..10));
+        foo((0..10));
+        bar((0..10).collect::<Vec<_>>(), (0..10));
+        baz((0..10), (), ('a'..='z'))
+    }
 }
+
+fn foo(_: impl IntoIterator<Item = usize>) {}
+fn bar<I: IntoIterator<Item = usize>>(_: Vec<usize>, _: I) {}
+fn baz<I: IntoIterator<Item = usize>>(_: I, _: (), _: impl IntoIterator<Item = char>) {}
diff --git a/tests/ui/needless_collect.rs b/tests/ui/needless_collect.rs
index 7ed7babec30..680b6fa5b55 100644
--- a/tests/ui/needless_collect.rs
+++ b/tests/ui/needless_collect.rs
@@ -62,4 +62,16 @@ fn main() {
 
     let _ = sample.iter().collect::<VecWrapper<_>>().is_empty();
     let _ = sample.iter().collect::<VecWrapper<_>>().contains(&&0);
+
+    #[allow(clippy::double_parens)]
+    {
+        Vec::<u8>::new().extend((0..10).collect::<Vec<_>>());
+        foo((0..10).collect::<Vec<_>>());
+        bar((0..10).collect::<Vec<_>>(), (0..10).collect::<Vec<_>>());
+        baz((0..10), (), ('a'..='z').collect::<Vec<_>>())
+    }
 }
+
+fn foo(_: impl IntoIterator<Item = usize>) {}
+fn bar<I: IntoIterator<Item = usize>>(_: Vec<usize>, _: I) {}
+fn baz<I: IntoIterator<Item = usize>>(_: I, _: (), _: impl IntoIterator<Item = char>) {}
diff --git a/tests/ui/needless_collect.stderr b/tests/ui/needless_collect.stderr
index 584d2a1d835..ad22a7b057e 100644
--- a/tests/ui/needless_collect.stderr
+++ b/tests/ui/needless_collect.stderr
@@ -90,5 +90,29 @@ error: avoid using `collect()` when not needed
 LL |     let _ = sample.iter().collect::<VecWrapper<_>>().contains(&&0);
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `any(|x| x == &0)`
 
-error: aborting due to 15 previous errors
+error: avoid using `collect()` when not needed
+  --> $DIR/needless_collect.rs:68:40
+   |
+LL |         Vec::<u8>::new().extend((0..10).collect::<Vec<_>>());
+   |                                        ^^^^^^^^^^^^^^^^^^^^ help: remove this call
+
+error: avoid using `collect()` when not needed
+  --> $DIR/needless_collect.rs:69:20
+   |
+LL |         foo((0..10).collect::<Vec<_>>());
+   |                    ^^^^^^^^^^^^^^^^^^^^ help: remove this call
+
+error: avoid using `collect()` when not needed
+  --> $DIR/needless_collect.rs:70:49
+   |
+LL |         bar((0..10).collect::<Vec<_>>(), (0..10).collect::<Vec<_>>());
+   |                                                 ^^^^^^^^^^^^^^^^^^^^ help: remove this call
+
+error: avoid using `collect()` when not needed
+  --> $DIR/needless_collect.rs:71:37
+   |
+LL |         baz((0..10), (), ('a'..='z').collect::<Vec<_>>())
+   |                                     ^^^^^^^^^^^^^^^^^^^^ help: remove this call
+
+error: aborting due to 19 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 1190c02bb89c8e127b449ec3cf7fcb51f0cfe0fd Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Sun, 14 May 2023 12:21:23 -0500
Subject: fix #10773

---
 clippy_lints/src/useless_conversion.rs | 13 ++++++++++++-
 tests/ui/useless_conversion.fixed      |  6 ++++++
 tests/ui/useless_conversion.rs         |  6 ++++++
 tests/ui/useless_conversion.stderr     | 32 ++++++++++++++++----------------
 4 files changed, 40 insertions(+), 17 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/useless_conversion.rs b/clippy_lints/src/useless_conversion.rs
index ddbe6b2c790..3d5c0514b58 100644
--- a/clippy_lints/src/useless_conversion.rs
+++ b/clippy_lints/src/useless_conversion.rs
@@ -5,7 +5,8 @@ use clippy_utils::ty::{is_copy, is_type_diagnostic_item, same_type_and_consts};
 use clippy_utils::{get_parent_expr, is_trait_method, match_def_path, path_to_local, paths};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
-use rustc_hir::{BindingAnnotation, Expr, ExprKind, HirId, MatchSource, Node, PatKind};
+use rustc_hir::def::{DefKind, Res};
+use rustc_hir::{BindingAnnotation, Expr, ExprKind, HirId, MatchSource, Node, PatKind, QPath, TyKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
@@ -138,6 +139,7 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
                 if_chain! {
                     if let ExprKind::Path(ref qpath) = path.kind;
                     if let Some(def_id) = cx.qpath_res(qpath, path.hir_id).opt_def_id();
+                    if !is_ty_alias(qpath);
                     then {
                         let a = cx.typeck_results().expr_ty(e);
                         let b = cx.typeck_results().expr_ty(arg);
@@ -195,3 +197,12 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
         }
     }
 }
+
+/// `cx.qpath_res` seems to return `AssocFn` so we do this instead
+fn is_ty_alias(qpath: &QPath<'_>) -> bool {
+    match *qpath {
+        QPath::Resolved(_, path) => matches!(path.res, Res::Def(DefKind::TyAlias, ..)),
+        QPath::TypeRelative(ty, _) if let TyKind::Path(qpath) = ty.kind => is_ty_alias(&qpath),
+        _ => false,
+    }
+}
diff --git a/tests/ui/useless_conversion.fixed b/tests/ui/useless_conversion.fixed
index 01eb6c5b080..c16caa38fe9 100644
--- a/tests/ui/useless_conversion.fixed
+++ b/tests/ui/useless_conversion.fixed
@@ -33,6 +33,11 @@ fn test_issue_3913() -> Result<(), std::io::Error> {
     Ok(())
 }
 
+fn dont_lint_on_type_alias() {
+    type A = i32;
+    _ = A::from(0i32);
+}
+
 fn dont_lint_into_iter_on_immutable_local_implementing_iterator_in_expr() {
     let text = "foo\r\nbar\n\nbaz\n";
     let lines = text.lines();
@@ -106,6 +111,7 @@ fn main() {
     test_questionmark().unwrap();
     test_issue_3913().unwrap();
 
+    dont_lint_on_type_alias();
     dont_lint_into_iter_on_immutable_local_implementing_iterator_in_expr();
     lint_into_iter_on_mutable_local_implementing_iterator_in_expr();
     lint_into_iter_on_expr_implementing_iterator();
diff --git a/tests/ui/useless_conversion.rs b/tests/ui/useless_conversion.rs
index 34b43a6299b..c75a2bce4ca 100644
--- a/tests/ui/useless_conversion.rs
+++ b/tests/ui/useless_conversion.rs
@@ -33,6 +33,11 @@ fn test_issue_3913() -> Result<(), std::io::Error> {
     Ok(())
 }
 
+fn dont_lint_on_type_alias() {
+    type A = i32;
+    _ = A::from(0i32);
+}
+
 fn dont_lint_into_iter_on_immutable_local_implementing_iterator_in_expr() {
     let text = "foo\r\nbar\n\nbaz\n";
     let lines = text.lines();
@@ -106,6 +111,7 @@ fn main() {
     test_questionmark().unwrap();
     test_issue_3913().unwrap();
 
+    dont_lint_on_type_alias();
     dont_lint_into_iter_on_immutable_local_implementing_iterator_in_expr();
     lint_into_iter_on_mutable_local_implementing_iterator_in_expr();
     lint_into_iter_on_expr_implementing_iterator();
diff --git a/tests/ui/useless_conversion.stderr b/tests/ui/useless_conversion.stderr
index be067c6843a..4dca3aac533 100644
--- a/tests/ui/useless_conversion.stderr
+++ b/tests/ui/useless_conversion.stderr
@@ -23,97 +23,97 @@ LL |         let _: i32 = 0i32.into();
    |                      ^^^^^^^^^^^ help: consider removing `.into()`: `0i32`
 
 error: useless conversion to the same type: `std::str::Lines<'_>`
-  --> $DIR/useless_conversion.rs:45:22
+  --> $DIR/useless_conversion.rs:50:22
    |
 LL |     if Some("ok") == lines.into_iter().next() {}
    |                      ^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `lines`
 
 error: useless conversion to the same type: `std::str::Lines<'_>`
-  --> $DIR/useless_conversion.rs:50:21
+  --> $DIR/useless_conversion.rs:55:21
    |
 LL |     let mut lines = text.lines().into_iter();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `text.lines()`
 
 error: useless conversion to the same type: `std::str::Lines<'_>`
-  --> $DIR/useless_conversion.rs:56:22
+  --> $DIR/useless_conversion.rs:61:22
    |
 LL |     if Some("ok") == text.lines().into_iter().next() {}
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `text.lines()`
 
 error: useless conversion to the same type: `std::ops::Range<i32>`
-  --> $DIR/useless_conversion.rs:62:13
+  --> $DIR/useless_conversion.rs:67:13
    |
 LL |     let _ = NUMBERS.into_iter().next();
    |             ^^^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `NUMBERS`
 
 error: useless conversion to the same type: `std::ops::Range<i32>`
-  --> $DIR/useless_conversion.rs:67:17
+  --> $DIR/useless_conversion.rs:72:17
    |
 LL |     let mut n = NUMBERS.into_iter();
    |                 ^^^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `NUMBERS`
 
 error: useless conversion to the same type: `std::string::String`
-  --> $DIR/useless_conversion.rs:128:21
+  --> $DIR/useless_conversion.rs:134:21
    |
 LL |     let _: String = "foo".to_string().into();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into()`: `"foo".to_string()`
 
 error: useless conversion to the same type: `std::string::String`
-  --> $DIR/useless_conversion.rs:129:21
+  --> $DIR/useless_conversion.rs:135:21
    |
 LL |     let _: String = From::from("foo".to_string());
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `From::from()`: `"foo".to_string()`
 
 error: useless conversion to the same type: `std::string::String`
-  --> $DIR/useless_conversion.rs:130:13
+  --> $DIR/useless_conversion.rs:136:13
    |
 LL |     let _ = String::from("foo".to_string());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `String::from()`: `"foo".to_string()`
 
 error: useless conversion to the same type: `std::string::String`
-  --> $DIR/useless_conversion.rs:131:13
+  --> $DIR/useless_conversion.rs:137:13
    |
 LL |     let _ = String::from(format!("A: {:04}", 123));
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `String::from()`: `format!("A: {:04}", 123)`
 
 error: useless conversion to the same type: `std::str::Lines<'_>`
-  --> $DIR/useless_conversion.rs:132:13
+  --> $DIR/useless_conversion.rs:138:13
    |
 LL |     let _ = "".lines().into_iter();
    |             ^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `"".lines()`
 
 error: useless conversion to the same type: `std::vec::IntoIter<i32>`
-  --> $DIR/useless_conversion.rs:133:13
+  --> $DIR/useless_conversion.rs:139:13
    |
 LL |     let _ = vec![1, 2, 3].into_iter().into_iter();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `vec![1, 2, 3].into_iter()`
 
 error: useless conversion to the same type: `std::string::String`
-  --> $DIR/useless_conversion.rs:134:21
+  --> $DIR/useless_conversion.rs:140:21
    |
 LL |     let _: String = format!("Hello {}", "world").into();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into()`: `format!("Hello {}", "world")`
 
 error: useless conversion to the same type: `i32`
-  --> $DIR/useless_conversion.rs:139:13
+  --> $DIR/useless_conversion.rs:145:13
    |
 LL |     let _ = i32::from(a + b) * 3;
    |             ^^^^^^^^^^^^^^^^ help: consider removing `i32::from()`: `(a + b)`
 
 error: useless conversion to the same type: `Foo<'a'>`
-  --> $DIR/useless_conversion.rs:145:23
+  --> $DIR/useless_conversion.rs:151:23
    |
 LL |     let _: Foo<'a'> = s2.into();
    |                       ^^^^^^^^^ help: consider removing `.into()`: `s2`
 
 error: useless conversion to the same type: `Foo<'a'>`
-  --> $DIR/useless_conversion.rs:147:13
+  --> $DIR/useless_conversion.rs:153:13
    |
 LL |     let _ = Foo::<'a'>::from(s3);
    |             ^^^^^^^^^^^^^^^^^^^^ help: consider removing `Foo::<'a'>::from()`: `s3`
 
 error: useless conversion to the same type: `std::vec::IntoIter<Foo<'a'>>`
-  --> $DIR/useless_conversion.rs:149:13
+  --> $DIR/useless_conversion.rs:155:13
    |
 LL |     let _ = vec![s4, s4, s4].into_iter().into_iter();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `vec![s4, s4, s4].into_iter()`
-- 
cgit 1.4.1-3-g733a5


From a36d9a7820be9040de8e56ec1852e2920377b935 Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Sun, 14 May 2023 12:39:08 -0500
Subject: move `is_ty_alias` to `clippy_utils`

---
 clippy_lints/src/useless_conversion.rs | 13 ++-----------
 clippy_utils/src/lib.rs                | 10 ++++++++++
 2 files changed, 12 insertions(+), 11 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/useless_conversion.rs b/clippy_lints/src/useless_conversion.rs
index 3d5c0514b58..28c3fc859e3 100644
--- a/clippy_lints/src/useless_conversion.rs
+++ b/clippy_lints/src/useless_conversion.rs
@@ -1,12 +1,12 @@
 use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg};
+use clippy_utils::is_ty_alias;
 use clippy_utils::source::{snippet, snippet_with_context};
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::{is_copy, is_type_diagnostic_item, same_type_and_consts};
 use clippy_utils::{get_parent_expr, is_trait_method, match_def_path, path_to_local, paths};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
-use rustc_hir::def::{DefKind, Res};
-use rustc_hir::{BindingAnnotation, Expr, ExprKind, HirId, MatchSource, Node, PatKind, QPath, TyKind};
+use rustc_hir::{BindingAnnotation, Expr, ExprKind, HirId, MatchSource, Node, PatKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
@@ -197,12 +197,3 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
         }
     }
 }
-
-/// `cx.qpath_res` seems to return `AssocFn` so we do this instead
-fn is_ty_alias(qpath: &QPath<'_>) -> bool {
-    match *qpath {
-        QPath::Resolved(_, path) => matches!(path.res, Res::Def(DefKind::TyAlias, ..)),
-        QPath::TypeRelative(ty, _) if let TyKind::Path(qpath) = ty.kind => is_ty_alias(&qpath),
-        _ => false,
-    }
-}
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 964104fc31d..2e27c260f74 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -1,5 +1,6 @@
 #![feature(array_chunks)]
 #![feature(box_patterns)]
+#![feature(if_let_guard)]
 #![feature(let_chains)]
 #![feature(lint_reasons)]
 #![feature(never_type)]
@@ -282,6 +283,15 @@ pub fn is_wild(pat: &Pat<'_>) -> bool {
     matches!(pat.kind, PatKind::Wild)
 }
 
+/// Checks if the given `QPath` belongs to a type alias.
+pub fn is_ty_alias(qpath: &QPath<'_>) -> bool {
+    match *qpath {
+        QPath::Resolved(_, path) => matches!(path.res, Res::Def(DefKind::TyAlias, ..)),
+        QPath::TypeRelative(ty, _) if let TyKind::Path(qpath) = ty.kind => { is_ty_alias(&qpath) },
+        _ => false,
+    }
+}
+
 /// Checks if the method call given in `expr` belongs to the given trait.
 /// This is a deprecated function, consider using [`is_trait_method`].
 pub fn match_trait_method(cx: &LateContext<'_>, expr: &Expr<'_>, path: &[&str]) -> bool {
-- 
cgit 1.4.1-3-g733a5


From 8c191add8788cb13ac988021617f673709babb16 Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Sun, 14 May 2023 19:25:23 -0500
Subject: the implementation!!

---
 CHANGELOG.md                                 |  1 +
 clippy_lints/src/casts/mod.rs                | 33 ++++++++++++++++-
 clippy_lints/src/casts/ptr_cast_constness.rs | 35 ++++++++++++++++++
 clippy_lints/src/declared_lints.rs           |  1 +
 tests/ui/ptr_cast_constness.fixed            | 55 ++++++++++++++++++++++++++++
 tests/ui/ptr_cast_constness.rs               | 55 ++++++++++++++++++++++++++++
 tests/ui/ptr_cast_constness.stderr           | 46 +++++++++++++++++++++++
 7 files changed, 225 insertions(+), 1 deletion(-)
 create mode 100644 clippy_lints/src/casts/ptr_cast_constness.rs
 create mode 100644 tests/ui/ptr_cast_constness.fixed
 create mode 100644 tests/ui/ptr_cast_constness.rs
 create mode 100644 tests/ui/ptr_cast_constness.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index dafa3f3a139..223dd698978 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4948,6 +4948,7 @@ Released 2018-09-13
 [`println_empty_string`]: https://rust-lang.github.io/rust-clippy/master/index.html#println_empty_string
 [`ptr_arg`]: https://rust-lang.github.io/rust-clippy/master/index.html#ptr_arg
 [`ptr_as_ptr`]: https://rust-lang.github.io/rust-clippy/master/index.html#ptr_as_ptr
+[`ptr_cast_constness`]: https://rust-lang.github.io/rust-clippy/master/index.html#ptr_cast_constness
 [`ptr_eq`]: https://rust-lang.github.io/rust-clippy/master/index.html#ptr_eq
 [`ptr_offset_with_cast`]: https://rust-lang.github.io/rust-clippy/master/index.html#ptr_offset_with_cast
 [`pub_enum_variant_names`]: https://rust-lang.github.io/rust-clippy/master/index.html#pub_enum_variant_names
diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index cfeb75eed3b..ee2f0f8855e 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -18,6 +18,7 @@ mod fn_to_numeric_cast;
 mod fn_to_numeric_cast_any;
 mod fn_to_numeric_cast_with_truncation;
 mod ptr_as_ptr;
+mod ptr_cast_constness;
 mod unnecessary_cast;
 mod utils;
 
@@ -399,7 +400,7 @@ declare_clippy_lint! {
     /// namely `*const T` to `*const U` and `*mut T` to `*mut U`.
     ///
     /// ### Why is this bad?
-    /// Though `as` casts between raw pointers is not terrible, `pointer::cast` is safer because
+    /// Though `as` casts between raw pointers are not terrible, `pointer::cast` is safer because
     /// it cannot accidentally change the pointer's mutability nor cast the pointer to other types like `usize`.
     ///
     /// ### Example
@@ -422,6 +423,34 @@ declare_clippy_lint! {
     "casting using `as` from and to raw pointers that doesn't change its mutability, where `pointer::cast` could take the place of `as`"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `as` casts between raw pointers which change its constness, namely `*const T` to
+    /// `*mut T` and `*mut T` to `*const T`.
+    ///
+    /// ### Why is this bad?
+    /// Though `as` casts between raw pointers are not terrible, `pointer::cast_mut` and
+    /// `pointer::cast_const` are safer because they cannot accidentally cast the pointer to another
+    /// type.
+    ///
+    /// ### Example
+    /// ```rust
+    /// let ptr: *const u32 = &42_u32;
+    /// let mut_ptr = ptr as *mut u32;
+    /// let ptr = mut_ptr as *const u32;
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// let ptr: *const u32 = &42_u32;
+    /// let mut_ptr = ptr.cast_mut();
+    /// let ptr = mut_ptr.cast_const();
+    /// ```
+    #[clippy::version = "1.65.0"]
+    pub PTR_CAST_CONSTNESS,
+    pedantic,
+    "TODO"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for casts from an enum type to an integral type which will definitely truncate the
@@ -689,6 +718,7 @@ impl_lint_pass!(Casts => [
     FN_TO_NUMERIC_CAST_WITH_TRUNCATION,
     CHAR_LIT_AS_U8,
     PTR_AS_PTR,
+    PTR_CAST_CONSTNESS,
     CAST_ENUM_TRUNCATION,
     CAST_ENUM_CONSTRUCTOR,
     CAST_ABS_TO_UNSIGNED,
@@ -722,6 +752,7 @@ impl<'tcx> LateLintPass<'tcx> for Casts {
                 return;
             }
             cast_slice_from_raw_parts::check(cx, expr, cast_expr, cast_to, &self.msrv);
+            ptr_cast_constness::check(cx, expr, cast_expr, cast_from, cast_to);
             as_ptr_cast_mut::check(cx, expr, cast_expr, cast_to);
             fn_to_numeric_cast_any::check(cx, expr, cast_expr, cast_from, cast_to);
             fn_to_numeric_cast::check(cx, expr, cast_expr, cast_from, cast_to);
diff --git a/clippy_lints/src/casts/ptr_cast_constness.rs b/clippy_lints/src/casts/ptr_cast_constness.rs
new file mode 100644
index 00000000000..0a95b36a599
--- /dev/null
+++ b/clippy_lints/src/casts/ptr_cast_constness.rs
@@ -0,0 +1,35 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::sugg::Sugg;
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, Mutability};
+use rustc_lint::LateContext;
+use rustc_middle::ty::{self, Ty, TypeAndMut};
+
+use super::PTR_CAST_CONSTNESS;
+
+pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_expr: &Expr<'_>, cast_from: Ty<'_>, cast_to: Ty<'_>) {
+    if_chain! {
+        if let ty::RawPtr(TypeAndMut { mutbl: from_mutbl, .. }) = cast_from.kind();
+        if let ty::RawPtr(TypeAndMut { mutbl: to_mutbl, .. }) = cast_to.kind();
+        if !matches!((from_mutbl, to_mutbl),
+            (Mutability::Not, Mutability::Not) | (Mutability::Mut, Mutability::Mut));
+        then {
+            let sugg = Sugg::hir(cx, cast_expr, "_");
+            let constness = match *to_mutbl {
+                Mutability::Not => "const",
+                Mutability::Mut => "mut",
+            };
+
+            span_lint_and_sugg(
+                cx,
+                PTR_CAST_CONSTNESS,
+                expr.span,
+                "`as` casting between raw pointers while changing its constness",
+                &format!("try `pointer::cast_{constness}`, a safer alternative"),
+                format!("{}.cast_{constness}()", sugg.maybe_par()),
+                Applicability::MachineApplicable,
+            );
+        }
+    }
+}
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index a3a6f1746bc..beeeb322b4d 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -89,6 +89,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::casts::FN_TO_NUMERIC_CAST_ANY_INFO,
     crate::casts::FN_TO_NUMERIC_CAST_WITH_TRUNCATION_INFO,
     crate::casts::PTR_AS_PTR_INFO,
+    crate::casts::PTR_CAST_CONSTNESS_INFO,
     crate::casts::UNNECESSARY_CAST_INFO,
     crate::checked_conversions::CHECKED_CONVERSIONS_INFO,
     crate::cognitive_complexity::COGNITIVE_COMPLEXITY_INFO,
diff --git a/tests/ui/ptr_cast_constness.fixed b/tests/ui/ptr_cast_constness.fixed
new file mode 100644
index 00000000000..bb7b00b50ab
--- /dev/null
+++ b/tests/ui/ptr_cast_constness.fixed
@@ -0,0 +1,55 @@
+//@run-rustfix
+//@aux-build:proc_macros.rs
+
+#![warn(clippy::ptr_cast_constness)]
+
+extern crate proc_macros;
+use proc_macros::{external, inline_macros};
+
+#[inline_macros]
+fn main() {
+    let ptr: *const u32 = &42_u32;
+    let mut_ptr: *mut u32 = &mut 42_u32;
+
+    let _ = ptr as *const i32;
+    let _ = mut_ptr as *mut i32;
+
+    // Make sure the lint can handle the difference in their operator precedences.
+    unsafe {
+        let ptr_ptr: *const *const u32 = &ptr;
+        let _ = (*ptr_ptr).cast_mut();
+    }
+
+    let _ = ptr.cast_mut();
+    let _ = mut_ptr.cast_const();
+
+    // Lint this, since pointer::cast_mut and pointer::cast_const have ?Sized
+    let ptr_of_array: *const [u32; 4] = &[1, 2, 3, 4];
+    let _ = ptr_of_array as *const [u32];
+    let _ = ptr_of_array as *const dyn std::fmt::Debug;
+
+    // Make sure the lint is triggered inside a macro
+    let _ = inline!($ptr as *const i32);
+
+    // Do not lint inside macros from external crates
+    let _ = external!($ptr as *const i32);
+}
+
+#[clippy::msrv = "1.64"]
+fn _msrv_1_37() {
+    let ptr: *const u32 = &42_u32;
+    let mut_ptr: *mut u32 = &mut 42_u32;
+
+    // `pointer::cast_const` and `pointer::cast_mut` were stabilized in 1.65. Do not lint this
+    let _ = ptr.cast_mut();
+    let _ = mut_ptr.cast_const();
+}
+
+#[clippy::msrv = "1.65"]
+fn _msrv_1_38() {
+    let ptr: *const u32 = &42_u32;
+    let mut_ptr: *mut u32 = &mut 42_u32;
+
+    let _ = ptr.cast_mut();
+    let _ = mut_ptr.cast_const();
+}
diff --git a/tests/ui/ptr_cast_constness.rs b/tests/ui/ptr_cast_constness.rs
new file mode 100644
index 00000000000..a560d36d117
--- /dev/null
+++ b/tests/ui/ptr_cast_constness.rs
@@ -0,0 +1,55 @@
+//@run-rustfix
+//@aux-build:proc_macros.rs
+
+#![warn(clippy::ptr_cast_constness)]
+
+extern crate proc_macros;
+use proc_macros::{external, inline_macros};
+
+#[inline_macros]
+fn main() {
+    let ptr: *const u32 = &42_u32;
+    let mut_ptr: *mut u32 = &mut 42_u32;
+
+    let _ = ptr as *const i32;
+    let _ = mut_ptr as *mut i32;
+
+    // Make sure the lint can handle the difference in their operator precedences.
+    unsafe {
+        let ptr_ptr: *const *const u32 = &ptr;
+        let _ = *ptr_ptr as *mut i32;
+    }
+
+    let _ = ptr as *mut i32;
+    let _ = mut_ptr as *const i32;
+
+    // Lint this, since pointer::cast_mut and pointer::cast_const have ?Sized
+    let ptr_of_array: *const [u32; 4] = &[1, 2, 3, 4];
+    let _ = ptr_of_array as *const [u32];
+    let _ = ptr_of_array as *const dyn std::fmt::Debug;
+
+    // Make sure the lint is triggered inside a macro
+    let _ = inline!($ptr as *const i32);
+
+    // Do not lint inside macros from external crates
+    let _ = external!($ptr as *const i32);
+}
+
+#[clippy::msrv = "1.64"]
+fn _msrv_1_37() {
+    let ptr: *const u32 = &42_u32;
+    let mut_ptr: *mut u32 = &mut 42_u32;
+
+    // `pointer::cast_const` and `pointer::cast_mut` were stabilized in 1.65. Do not lint this
+    let _ = ptr as *mut i32;
+    let _ = mut_ptr as *const i32;
+}
+
+#[clippy::msrv = "1.65"]
+fn _msrv_1_38() {
+    let ptr: *const u32 = &42_u32;
+    let mut_ptr: *mut u32 = &mut 42_u32;
+
+    let _ = ptr as *mut i32;
+    let _ = mut_ptr as *const i32;
+}
diff --git a/tests/ui/ptr_cast_constness.stderr b/tests/ui/ptr_cast_constness.stderr
new file mode 100644
index 00000000000..e665e2971c4
--- /dev/null
+++ b/tests/ui/ptr_cast_constness.stderr
@@ -0,0 +1,46 @@
+error: `as` casting between raw pointers while changing its constness
+  --> $DIR/ptr_cast_constness.rs:20:17
+   |
+LL |         let _ = *ptr_ptr as *mut i32;
+   |                 ^^^^^^^^^^^^^^^^^^^^ help: try `pointer::cast_mut`, a safer alternative: `(*ptr_ptr).cast_mut()`
+   |
+   = note: `-D clippy::ptr-cast-constness` implied by `-D warnings`
+
+error: `as` casting between raw pointers while changing its constness
+  --> $DIR/ptr_cast_constness.rs:23:13
+   |
+LL |     let _ = ptr as *mut i32;
+   |             ^^^^^^^^^^^^^^^ help: try `pointer::cast_mut`, a safer alternative: `ptr.cast_mut()`
+
+error: `as` casting between raw pointers while changing its constness
+  --> $DIR/ptr_cast_constness.rs:24:13
+   |
+LL |     let _ = mut_ptr as *const i32;
+   |             ^^^^^^^^^^^^^^^^^^^^^ help: try `pointer::cast_const`, a safer alternative: `mut_ptr.cast_const()`
+
+error: `as` casting between raw pointers while changing its constness
+  --> $DIR/ptr_cast_constness.rs:44:13
+   |
+LL |     let _ = ptr as *mut i32;
+   |             ^^^^^^^^^^^^^^^ help: try `pointer::cast_mut`, a safer alternative: `ptr.cast_mut()`
+
+error: `as` casting between raw pointers while changing its constness
+  --> $DIR/ptr_cast_constness.rs:45:13
+   |
+LL |     let _ = mut_ptr as *const i32;
+   |             ^^^^^^^^^^^^^^^^^^^^^ help: try `pointer::cast_const`, a safer alternative: `mut_ptr.cast_const()`
+
+error: `as` casting between raw pointers while changing its constness
+  --> $DIR/ptr_cast_constness.rs:53:13
+   |
+LL |     let _ = ptr as *mut i32;
+   |             ^^^^^^^^^^^^^^^ help: try `pointer::cast_mut`, a safer alternative: `ptr.cast_mut()`
+
+error: `as` casting between raw pointers while changing its constness
+  --> $DIR/ptr_cast_constness.rs:54:13
+   |
+LL |     let _ = mut_ptr as *const i32;
+   |             ^^^^^^^^^^^^^^^^^^^^^ help: try `pointer::cast_const`, a safer alternative: `mut_ptr.cast_const()`
+
+error: aborting due to 7 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From c5a914b181d4f4c06354f7afd4b66f346a92f8a8 Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Sun, 14 May 2023 19:31:12 -0500
Subject: check msrv

---
 clippy_lints/src/casts/mod.rs                |  2 +-
 clippy_lints/src/casts/ptr_cast_constness.rs | 13 +++++++++++--
 tests/ui/ptr_cast_constness.fixed            |  4 ++--
 tests/ui/ptr_cast_constness.stderr           | 14 +-------------
 4 files changed, 15 insertions(+), 18 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index ee2f0f8855e..07650bdd7b8 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -752,7 +752,7 @@ impl<'tcx> LateLintPass<'tcx> for Casts {
                 return;
             }
             cast_slice_from_raw_parts::check(cx, expr, cast_expr, cast_to, &self.msrv);
-            ptr_cast_constness::check(cx, expr, cast_expr, cast_from, cast_to);
+            ptr_cast_constness::check(cx, expr, cast_expr, cast_from, cast_to, &self.msrv);
             as_ptr_cast_mut::check(cx, expr, cast_expr, cast_to);
             fn_to_numeric_cast_any::check(cx, expr, cast_expr, cast_from, cast_to);
             fn_to_numeric_cast::check(cx, expr, cast_expr, cast_from, cast_to);
diff --git a/clippy_lints/src/casts/ptr_cast_constness.rs b/clippy_lints/src/casts/ptr_cast_constness.rs
index 0a95b36a599..059694c34c0 100644
--- a/clippy_lints/src/casts/ptr_cast_constness.rs
+++ b/clippy_lints/src/casts/ptr_cast_constness.rs
@@ -1,15 +1,24 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::sugg::Sugg;
+use clippy_utils::{diagnostics::span_lint_and_sugg, msrvs::Msrv};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, Mutability};
 use rustc_lint::LateContext;
 use rustc_middle::ty::{self, Ty, TypeAndMut};
+use rustc_semver::RustcVersion;
 
 use super::PTR_CAST_CONSTNESS;
 
-pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_expr: &Expr<'_>, cast_from: Ty<'_>, cast_to: Ty<'_>) {
+pub(super) fn check(
+    cx: &LateContext<'_>,
+    expr: &Expr<'_>,
+    cast_expr: &Expr<'_>,
+    cast_from: Ty<'_>,
+    cast_to: Ty<'_>,
+    msrv: &Msrv,
+) {
     if_chain! {
+        if msrv.meets(RustcVersion::new(1,65,0));
         if let ty::RawPtr(TypeAndMut { mutbl: from_mutbl, .. }) = cast_from.kind();
         if let ty::RawPtr(TypeAndMut { mutbl: to_mutbl, .. }) = cast_to.kind();
         if !matches!((from_mutbl, to_mutbl),
diff --git a/tests/ui/ptr_cast_constness.fixed b/tests/ui/ptr_cast_constness.fixed
index bb7b00b50ab..dc7acdae69c 100644
--- a/tests/ui/ptr_cast_constness.fixed
+++ b/tests/ui/ptr_cast_constness.fixed
@@ -41,8 +41,8 @@ fn _msrv_1_37() {
     let mut_ptr: *mut u32 = &mut 42_u32;
 
     // `pointer::cast_const` and `pointer::cast_mut` were stabilized in 1.65. Do not lint this
-    let _ = ptr.cast_mut();
-    let _ = mut_ptr.cast_const();
+    let _ = ptr as *mut i32;
+    let _ = mut_ptr as *const i32;
 }
 
 #[clippy::msrv = "1.65"]
diff --git a/tests/ui/ptr_cast_constness.stderr b/tests/ui/ptr_cast_constness.stderr
index e665e2971c4..43816c87c19 100644
--- a/tests/ui/ptr_cast_constness.stderr
+++ b/tests/ui/ptr_cast_constness.stderr
@@ -18,18 +18,6 @@ error: `as` casting between raw pointers while changing its constness
 LL |     let _ = mut_ptr as *const i32;
    |             ^^^^^^^^^^^^^^^^^^^^^ help: try `pointer::cast_const`, a safer alternative: `mut_ptr.cast_const()`
 
-error: `as` casting between raw pointers while changing its constness
-  --> $DIR/ptr_cast_constness.rs:44:13
-   |
-LL |     let _ = ptr as *mut i32;
-   |             ^^^^^^^^^^^^^^^ help: try `pointer::cast_mut`, a safer alternative: `ptr.cast_mut()`
-
-error: `as` casting between raw pointers while changing its constness
-  --> $DIR/ptr_cast_constness.rs:45:13
-   |
-LL |     let _ = mut_ptr as *const i32;
-   |             ^^^^^^^^^^^^^^^^^^^^^ help: try `pointer::cast_const`, a safer alternative: `mut_ptr.cast_const()`
-
 error: `as` casting between raw pointers while changing its constness
   --> $DIR/ptr_cast_constness.rs:53:13
    |
@@ -42,5 +30,5 @@ error: `as` casting between raw pointers while changing its constness
 LL |     let _ = mut_ptr as *const i32;
    |             ^^^^^^^^^^^^^^^^^^^^^ help: try `pointer::cast_const`, a safer alternative: `mut_ptr.cast_const()`
 
-error: aborting due to 7 previous errors
+error: aborting due to 5 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From f6a0437e74494b3f887286540333abfc691055b4 Mon Sep 17 00:00:00 2001
From: Catherine <114838443+Centri3@users.noreply.github.com>
Date: Mon, 15 May 2023 13:14:45 -0500
Subject: Update clippy_lints/src/casts/ptr_cast_constness.rs

Co-authored-by: llogiq <bogusandre@gmail.com>
---
 clippy_lints/src/casts/ptr_cast_constness.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/ptr_cast_constness.rs b/clippy_lints/src/casts/ptr_cast_constness.rs
index 059694c34c0..f8327b04b0f 100644
--- a/clippy_lints/src/casts/ptr_cast_constness.rs
+++ b/clippy_lints/src/casts/ptr_cast_constness.rs
@@ -21,8 +21,8 @@ pub(super) fn check(
         if msrv.meets(RustcVersion::new(1,65,0));
         if let ty::RawPtr(TypeAndMut { mutbl: from_mutbl, .. }) = cast_from.kind();
         if let ty::RawPtr(TypeAndMut { mutbl: to_mutbl, .. }) = cast_to.kind();
-        if !matches!((from_mutbl, to_mutbl),
-            (Mutability::Not, Mutability::Not) | (Mutability::Mut, Mutability::Mut));
+        if matches!((from_mutbl, to_mutbl),
+            (Mutability::Not, Mutability::Mut) | (Mutability::Mut, Mutability::Not));
         then {
             let sugg = Sugg::hir(cx, cast_expr, "_");
             let constness = match *to_mutbl {
-- 
cgit 1.4.1-3-g733a5


From f0be0ee1aa5314f6c7bb6949a8afe19e84ead35a Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Mon, 15 May 2023 21:33:56 +0200
Subject: handle nested macros and add tests for them

---
 clippy_lints/src/dbg_macro.rs | 51 ++++++++++++++++++++++++++++++-------------
 tests/ui/dbg_macro.rs         | 19 ++++++++++++++++
 tests/ui/dbg_macro.stderr     | 38 +++++++++++++++++++++++++-------
 3 files changed, 85 insertions(+), 23 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/dbg_macro.rs b/clippy_lints/src/dbg_macro.rs
index cea712f2fee..ea17e7a6071 100644
--- a/clippy_lints/src/dbg_macro.rs
+++ b/clippy_lints/src/dbg_macro.rs
@@ -3,10 +3,10 @@ use clippy_utils::macros::root_macro_call_first_node;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::{is_in_cfg_test, is_in_test_function};
 use rustc_errors::Applicability;
-use rustc_hir::{Expr, ExprKind, Node, Stmt, StmtKind};
+use rustc_hir::{Expr, ExprKind, Node};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::{sym, Span};
+use rustc_span::{sym, BytePos, Pos, Span};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -31,9 +31,29 @@ declare_clippy_lint! {
     "`dbg!` macro is intended as a debugging tool"
 }
 
-fn span_including_semi(cx: &LateContext<'_>, span: Span) -> Span {
-    let span = cx.sess().source_map().span_extend_to_next_char(span, ';', true);
-    span.with_hi(span.hi() + rustc_span::BytePos(1))
+/// Gets the span of the statement up to the next semicolon, if and only if the next
+/// non-whitespace character actually is a semicolon.
+/// E.g.
+/// ```rust,ignore
+/// 
+///    dbg!();
+///    ^^^^^^^  this span is returned
+///
+///   foo!(dbg!());
+///             no span is returned
+/// ```
+fn span_including_semi(cx: &LateContext<'_>, span: Span) -> Option<Span> {
+    let sm = cx.sess().source_map();
+    let sf = sm.lookup_source_file(span.hi());
+    let src = sf.src.as_ref()?.get(span.hi().to_usize()..)?;
+    let first_non_whitespace = src.find(|c: char| !c.is_whitespace())?;
+
+    if src.as_bytes()[first_non_whitespace] == b';' {
+        let hi = span.hi() + BytePos::from_usize(first_non_whitespace + 1);
+        Some(span.with_hi(hi))
+    } else {
+        None
+    }
 }
 
 #[derive(Copy, Clone)]
@@ -62,16 +82,17 @@ impl LateLintPass<'_> for DbgMacro {
             let mut applicability = Applicability::MachineApplicable;
 
             let (sugg_span, suggestion) = match expr.peel_drop_temps().kind {
-                ExprKind::Block(..) => match cx.tcx.hir().find_parent(expr.hir_id) {
-                    // dbg!() as a standalone statement, suggest removing the whole statement entirely
-                    Some(Node::Stmt(
-                        stmt @ Stmt {
-                            kind: StmtKind::Semi(_),
-                            ..
-                        },
-                    )) => (span_including_semi(cx, stmt.span.source_callsite()), String::new()),
-                    // empty dbg!() in arbitrary position (e.g. `foo(dbg!())`), suggest replacing with `foo(())`
-                    _ => (macro_call.span, String::from("()")),
+                // dbg!()
+                ExprKind::Block(..) => {
+                    // If the `dbg!` macro is a "free" statement and not contained within other expressions,
+                    // remove the whole statement.
+                    if let Some(Node::Stmt(stmt)) = cx.tcx.hir().find_parent(expr.hir_id)
+                        && let Some(span) = span_including_semi(cx, stmt.span.source_callsite())
+                    {
+                        (span, String::new())
+                    } else {
+                        (macro_call.span, String::from("()"))
+                    }
                 },
                 // dbg!(1)
                 ExprKind::Match(val, ..) => (
diff --git a/tests/ui/dbg_macro.rs b/tests/ui/dbg_macro.rs
index ae2075e7dad..10788d40481 100644
--- a/tests/ui/dbg_macro.rs
+++ b/tests/ui/dbg_macro.rs
@@ -23,10 +23,29 @@ fn main() {
 }
 
 fn issue9914() {
+    macro_rules! foo {
+        ($x:expr) => {
+            $x;
+        };
+    }
+    macro_rules! foo2 {
+        ($x:expr) => {
+            $x;
+        };
+    }
+    macro_rules! expand_to_dbg {
+        () => {
+            dbg!();
+        };
+    }
+
     dbg!();
     #[allow(clippy::let_unit_value)]
     let _ = dbg!();
     bar(dbg!());
+    foo!(dbg!());
+    foo2!(foo!(dbg!()));
+    expand_to_dbg!();
 }
 
 mod issue7274 {
diff --git a/tests/ui/dbg_macro.stderr b/tests/ui/dbg_macro.stderr
index 34329a06b97..530e7663317 100644
--- a/tests/ui/dbg_macro.stderr
+++ b/tests/ui/dbg_macro.stderr
@@ -99,7 +99,7 @@ LL |     (1, 2, 3, 4, 5);
    |     ~~~~~~~~~~~~~~~
 
 error: the `dbg!` macro is intended as a debugging tool
-  --> $DIR/dbg_macro.rs:26:5
+  --> $DIR/dbg_macro.rs:42:5
    |
 LL |     dbg!();
    |     ^^^^^^^
@@ -111,7 +111,7 @@ LL +
    |
 
 error: the `dbg!` macro is intended as a debugging tool
-  --> $DIR/dbg_macro.rs:28:13
+  --> $DIR/dbg_macro.rs:44:13
    |
 LL |     let _ = dbg!();
    |             ^^^^^^
@@ -122,7 +122,7 @@ LL |     let _ = ();
    |             ~~
 
 error: the `dbg!` macro is intended as a debugging tool
-  --> $DIR/dbg_macro.rs:29:9
+  --> $DIR/dbg_macro.rs:45:9
    |
 LL |     bar(dbg!());
    |         ^^^^^^
@@ -133,7 +133,29 @@ LL |     bar(());
    |         ~~
 
 error: the `dbg!` macro is intended as a debugging tool
-  --> $DIR/dbg_macro.rs:49:9
+  --> $DIR/dbg_macro.rs:46:10
+   |
+LL |     foo!(dbg!());
+   |          ^^^^^^
+   |
+help: remove the invocation before committing it to a version control system
+   |
+LL |     foo!(());
+   |          ~~
+
+error: the `dbg!` macro is intended as a debugging tool
+  --> $DIR/dbg_macro.rs:47:16
+   |
+LL |     foo2!(foo!(dbg!()));
+   |                ^^^^^^
+   |
+help: remove the invocation before committing it to a version control system
+   |
+LL |     foo2!(foo!(()));
+   |                ~~
+
+error: the `dbg!` macro is intended as a debugging tool
+  --> $DIR/dbg_macro.rs:68:9
    |
 LL |         dbg!(2);
    |         ^^^^^^^
@@ -144,7 +166,7 @@ LL |         2;
    |         ~
 
 error: the `dbg!` macro is intended as a debugging tool
-  --> $DIR/dbg_macro.rs:55:5
+  --> $DIR/dbg_macro.rs:74:5
    |
 LL |     dbg!(1);
    |     ^^^^^^^
@@ -155,7 +177,7 @@ LL |     1;
    |     ~
 
 error: the `dbg!` macro is intended as a debugging tool
-  --> $DIR/dbg_macro.rs:60:5
+  --> $DIR/dbg_macro.rs:79:5
    |
 LL |     dbg!(1);
    |     ^^^^^^^
@@ -166,7 +188,7 @@ LL |     1;
    |     ~
 
 error: the `dbg!` macro is intended as a debugging tool
-  --> $DIR/dbg_macro.rs:66:9
+  --> $DIR/dbg_macro.rs:85:9
    |
 LL |         dbg!(1);
    |         ^^^^^^^
@@ -176,5 +198,5 @@ help: remove the invocation before committing it to a version control system
 LL |         1;
    |         ~
 
-error: aborting due to 16 previous errors
+error: aborting due to 18 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 79eb06c6ec8838f6929ee54681de346f1b6bbde4 Mon Sep 17 00:00:00 2001
From: Mick van Gelderen <mickvangelderen@gmail.com>
Date: Mon, 15 May 2023 22:24:37 +0200
Subject: Remove unnecessary  from  example

---
 clippy_lints/src/methods/mod.rs | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index cb86917464b..02d4a9aa08f 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3133,8 +3133,11 @@ declare_clippy_lint! {
     /// ### Example
     /// ```rust
     /// # let iterator = vec![1].into_iter();
-    /// let len = iterator.clone().collect::<Vec<_>>().len();
-    /// // should be
+    /// let len = iterator.collect::<Vec<_>>().len();
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// # let iterator = vec![1].into_iter();
     /// let len = iterator.count();
     /// ```
     #[clippy::version = "1.30.0"]
-- 
cgit 1.4.1-3-g733a5


From 2d9d81fc1e881f4ccf84c0509ffc23c8086cdcc6 Mon Sep 17 00:00:00 2001
From: Renato Lochetti <renato.lochetti@gmail.com>
Date: Tue, 16 May 2023 09:34:20 +0100
Subject: Checking for proc_macro not only when local.init is Some

---
 clippy_lints/src/let_underscore.rs | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/let_underscore.rs b/clippy_lints/src/let_underscore.rs
index 0596ea732f3..34a9d217606 100644
--- a/clippy_lints/src/let_underscore.rs
+++ b/clippy_lints/src/let_underscore.rs
@@ -192,18 +192,18 @@ impl<'tcx> LateLintPass<'tcx> for LetUnderscore {
             if local.pat.default_binding_modes && local.ty.is_none() {
                 // When `default_binding_modes` is true, the `let` keyword is present.
 
-				if let Some(init) = local.init {
-                    // Ignore function calls that return impl traits...
-                    if matches!(init.kind, ExprKind::Call(_, _) | ExprKind::MethodCall(_, _, _, _)) {
-                        let expr_ty = cx.typeck_results().expr_ty(init);
-                        if expr_ty.is_impl_trait() {
-                            return;
-                        }
-                    }
-                    // Ignore if it is from a procedural macro...
-                    if is_from_proc_macro(cx, init) {
-                        return;
-                    }
+				// Ignore function calls that return impl traits...
+				if let Some(init) = local.init &&
+				matches!(init.kind, ExprKind::Call(_, _) | ExprKind::MethodCall(_, _, _, _)) {
+					let expr_ty = cx.typeck_results().expr_ty(init);
+					if expr_ty.is_impl_trait() {
+						return;
+					}
+				}
+
+                // Ignore if it is from a procedural macro...
+                if is_from_proc_macro(cx, init) {
+                    return;
                 }
 
 				span_lint_and_help(
-- 
cgit 1.4.1-3-g733a5


From 4ff1cd365df96c4d0aef5b899ac248ff11799c36 Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Tue, 16 May 2023 11:20:00 -0500
Subject: add description and rename msrv tests

---
 clippy_lints/src/casts/mod.rs                | 2 +-
 clippy_lints/src/casts/ptr_cast_constness.rs | 4 ++--
 clippy_utils/src/msrvs.rs                    | 2 +-
 tests/ui/ptr_cast_constness.fixed            | 4 ++--
 tests/ui/ptr_cast_constness.rs               | 4 ++--
 5 files changed, 8 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index 07650bdd7b8..a2f8546d3a6 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -448,7 +448,7 @@ declare_clippy_lint! {
     #[clippy::version = "1.65.0"]
     pub PTR_CAST_CONSTNESS,
     pedantic,
-    "TODO"
+    "casting using `as` from and to raw pointers to change constness when specialized methods apply"
 }
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/casts/ptr_cast_constness.rs b/clippy_lints/src/casts/ptr_cast_constness.rs
index f8327b04b0f..ab015f8822e 100644
--- a/clippy_lints/src/casts/ptr_cast_constness.rs
+++ b/clippy_lints/src/casts/ptr_cast_constness.rs
@@ -1,3 +1,4 @@
+use clippy_utils::msrvs::POINTER_CAST_CONSTNESS;
 use clippy_utils::sugg::Sugg;
 use clippy_utils::{diagnostics::span_lint_and_sugg, msrvs::Msrv};
 use if_chain::if_chain;
@@ -5,7 +6,6 @@ use rustc_errors::Applicability;
 use rustc_hir::{Expr, Mutability};
 use rustc_lint::LateContext;
 use rustc_middle::ty::{self, Ty, TypeAndMut};
-use rustc_semver::RustcVersion;
 
 use super::PTR_CAST_CONSTNESS;
 
@@ -18,7 +18,7 @@ pub(super) fn check(
     msrv: &Msrv,
 ) {
     if_chain! {
-        if msrv.meets(RustcVersion::new(1,65,0));
+        if msrv.meets(POINTER_CAST_CONSTNESS);
         if let ty::RawPtr(TypeAndMut { mutbl: from_mutbl, .. }) = cast_from.kind();
         if let ty::RawPtr(TypeAndMut { mutbl: to_mutbl, .. }) = cast_to.kind();
         if matches!((from_mutbl, to_mutbl),
diff --git a/clippy_utils/src/msrvs.rs b/clippy_utils/src/msrvs.rs
index e05de2dc99c..6f102308f0b 100644
--- a/clippy_utils/src/msrvs.rs
+++ b/clippy_utils/src/msrvs.rs
@@ -20,7 +20,7 @@ macro_rules! msrv_aliases {
 // names may refer to stabilized feature flags or library items
 msrv_aliases! {
     1,68,0 { PATH_MAIN_SEPARATOR_STR }
-    1,65,0 { LET_ELSE }
+    1,65,0 { LET_ELSE, POINTER_CAST_CONSTNESS }
     1,62,0 { BOOL_THEN_SOME, DEFAULT_ENUM_ATTRIBUTE }
     1,58,0 { FORMAT_ARGS_CAPTURE, PATTERN_TRAIT_CHAR_ARRAY }
     1,55,0 { SEEK_REWIND }
diff --git a/tests/ui/ptr_cast_constness.fixed b/tests/ui/ptr_cast_constness.fixed
index dc7acdae69c..24de573d083 100644
--- a/tests/ui/ptr_cast_constness.fixed
+++ b/tests/ui/ptr_cast_constness.fixed
@@ -36,7 +36,7 @@ fn main() {
 }
 
 #[clippy::msrv = "1.64"]
-fn _msrv_1_37() {
+fn _msrv_1_64() {
     let ptr: *const u32 = &42_u32;
     let mut_ptr: *mut u32 = &mut 42_u32;
 
@@ -46,7 +46,7 @@ fn _msrv_1_37() {
 }
 
 #[clippy::msrv = "1.65"]
-fn _msrv_1_38() {
+fn _msrv_1_65() {
     let ptr: *const u32 = &42_u32;
     let mut_ptr: *mut u32 = &mut 42_u32;
 
diff --git a/tests/ui/ptr_cast_constness.rs b/tests/ui/ptr_cast_constness.rs
index a560d36d117..63d973a9fca 100644
--- a/tests/ui/ptr_cast_constness.rs
+++ b/tests/ui/ptr_cast_constness.rs
@@ -36,7 +36,7 @@ fn main() {
 }
 
 #[clippy::msrv = "1.64"]
-fn _msrv_1_37() {
+fn _msrv_1_64() {
     let ptr: *const u32 = &42_u32;
     let mut_ptr: *mut u32 = &mut 42_u32;
 
@@ -46,7 +46,7 @@ fn _msrv_1_37() {
 }
 
 #[clippy::msrv = "1.65"]
-fn _msrv_1_38() {
+fn _msrv_1_65() {
     let ptr: *const u32 = &42_u32;
     let mut_ptr: *mut u32 = &mut 42_u32;
 
-- 
cgit 1.4.1-3-g733a5


From 97467e4aa39d20273014195bb7362d6bace047ea Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Tue, 16 May 2023 16:29:31 -0500
Subject: change `clippy::version` to 1.71.0

---
 clippy_lints/src/casts/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index a2f8546d3a6..d62639caca1 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -445,7 +445,7 @@ declare_clippy_lint! {
     /// let mut_ptr = ptr.cast_mut();
     /// let ptr = mut_ptr.cast_const();
     /// ```
-    #[clippy::version = "1.65.0"]
+    #[clippy::version = "1.71.0"]
     pub PTR_CAST_CONSTNESS,
     pedantic,
     "casting using `as` from and to raw pointers to change constness when specialized methods apply"
-- 
cgit 1.4.1-3-g733a5


From ae40b7f8cc261832862b407b7772c2798236db95 Mon Sep 17 00:00:00 2001
From: Catherine <114838443+Centri3@users.noreply.github.com>
Date: Tue, 16 May 2023 18:11:20 -0500
Subject: fix example heading in `string_slice`

---
 clippy_lints/src/strings.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/strings.rs b/clippy_lints/src/strings.rs
index 5b588e914fd..483f860a8b5 100644
--- a/clippy_lints/src/strings.rs
+++ b/clippy_lints/src/strings.rs
@@ -132,7 +132,7 @@ declare_clippy_lint! {
     /// Probably lots of false positives. If an index comes from a known valid position (e.g.
     /// obtained via `char_indices` over the same string), it is totally OK.
     ///
-    /// # Example
+    /// ### Example
     /// ```rust,should_panic
     /// &"Ölkanne"[1..];
     /// ```
-- 
cgit 1.4.1-3-g733a5


From 83a4b0987f54afbfaad8fed61882231a6632bc71 Mon Sep 17 00:00:00 2001
From: est31 <MTest31@outlook.com>
Date: Thu, 18 May 2023 07:56:04 +0200
Subject: Fix formatting of if let chain

---
 clippy_lints/src/manual_let_else.rs | 93 +++++++++++++++++++------------------
 1 file changed, 47 insertions(+), 46 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_let_else.rs b/clippy_lints/src/manual_let_else.rs
index 3f8b42ffe80..855bbf4c668 100644
--- a/clippy_lints/src/manual_let_else.rs
+++ b/clippy_lints/src/manual_let_else.rs
@@ -77,53 +77,54 @@ impl<'tcx> LateLintPass<'tcx> for ManualLetElse {
             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, local.pat, let_pat, if_else);
-                }
-            },
-            IfLetOrMatch::Match(match_expr, arms, source) => {
-                if self.matches_behaviour == MatchLintBehaviour::Never {
-                    return;
-                }
-                if source != MatchSource::Normal {
-                    return;
-                }
-                // Any other number than two arms doesn't (necessarily)
-                // have a trivial mapping to let else.
-                if arms.len() != 2 {
-                    return;
-                }
-                // Guards don't give us an easy mapping either
-                if arms.iter().any(|arm| arm.guard.is_some()) {
-                    return;
-                }
-                let check_types = self.matches_behaviour == MatchLintBehaviour::WellKnownTypes;
-                let diverging_arm_opt = arms
-                    .iter()
-                    .enumerate()
-                    .find(|(_, arm)| expr_diverges(cx, arm.body) && pat_allowed_for_else(cx, arm.pat, check_types));
-                let Some((idx, diverging_arm)) = diverging_arm_opt else { return; };
-                // If the non-diverging arm is the first one, its pattern can be reused in a let/else statement.
-                // However, if it arrives in second position, its pattern may cover some cases already covered
-                // by the diverging one.
-                // TODO: accept the non-diverging arm as a second position if patterns are disjointed.
-                if idx == 0 {
-                    return;
-                }
-                let pat_arm = &arms[1 - idx];
-                if !expr_is_simple_identity(pat_arm.pat, pat_arm.body) {
-                    return;
-                }
+            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, local.pat, let_pat, if_else);
+                    }
+                },
+                IfLetOrMatch::Match(match_expr, arms, source) => {
+                    if self.matches_behaviour == MatchLintBehaviour::Never {
+                        return;
+                    }
+                    if source != MatchSource::Normal {
+                        return;
+                    }
+                    // Any other number than two arms doesn't (necessarily)
+                    // have a trivial mapping to let else.
+                    if arms.len() != 2 {
+                        return;
+                    }
+                    // Guards don't give us an easy mapping either
+                    if arms.iter().any(|arm| arm.guard.is_some()) {
+                        return;
+                    }
+                    let check_types = self.matches_behaviour == MatchLintBehaviour::WellKnownTypes;
+                    let diverging_arm_opt = arms
+                        .iter()
+                        .enumerate()
+                        .find(|(_, arm)| expr_diverges(cx, arm.body) && pat_allowed_for_else(cx, arm.pat, check_types));
+                    let Some((idx, diverging_arm)) = diverging_arm_opt else { return; };
+                    // If the non-diverging arm is the first one, its pattern can be reused in a let/else statement.
+                    // However, if it arrives in second position, its pattern may cover some cases already covered
+                    // by the diverging one.
+                    // TODO: accept the non-diverging arm as a second position if patterns are disjointed.
+                    if idx == 0 {
+                        return;
+                    }
+                    let pat_arm = &arms[1 - idx];
+                    if !expr_is_simple_identity(pat_arm.pat, pat_arm.body) {
+                        return;
+                    }
 
-                emit_manual_let_else(cx, stmt.span, match_expr, local.pat, pat_arm.pat, diverging_arm.body);
-            },
-        }
+                    emit_manual_let_else(cx, stmt.span, match_expr, local.pat, pat_arm.pat, diverging_arm.body);
+                },
+            }
         };
     }
 
-- 
cgit 1.4.1-3-g733a5


From ef38662d044714f55c87a12571bd30da51c199aa Mon Sep 17 00:00:00 2001
From: est31 <MTest31@outlook.com>
Date: Thu, 18 May 2023 10:33:35 +0200
Subject: Some improvements to the manual_let_else lint suggestions

* Replace variables inside | patterns in the if let: let v = if let V::A(v) | V::B(v) = v { v } else ...
* Support nested patterns: let v = if let Ok(Ok(Ok(v))) = v { v } else ...
* Support tuple structs with more than one arg: let v = V::W(v, _) = v { v } else ...
* Correctly handle .. in tuple struct patterns: let v = V::X(v, ..) = v { v } else ...
---
 clippy_lints/src/manual_let_else.rs   | 71 +++++++++++++++++++++++++----------
 tests/ui/manual_let_else.rs           | 16 ++++++--
 tests/ui/manual_let_else.stderr       | 35 ++++++++++++++---
 tests/ui/manual_let_else_match.rs     |  2 +-
 tests/ui/manual_let_else_match.stderr |  4 +-
 5 files changed, 97 insertions(+), 31 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_let_else.rs b/clippy_lints/src/manual_let_else.rs
index 855bbf4c668..389b0a4a62d 100644
--- a/clippy_lints/src/manual_let_else.rs
+++ b/clippy_lints/src/manual_let_else.rs
@@ -146,10 +146,9 @@ fn emit_manual_let_else(
         "this could be rewritten as `let...else`",
         |diag| {
             // This is far from perfect, for example there needs to be:
-            // * mut additions for the bindings
-            // * renamings of the bindings for `PatKind::Or`
+            // * tracking for multi-binding cases: let (foo, bar) = if let (Some(foo), Ok(bar)) = ...
+            // * renamings of the bindings for many `PatKind`s like structs, slices, etc.
             // * 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_expr, _) = snippet_with_context(cx, expr.span, span.ctxt(), "", &mut app);
@@ -160,28 +159,62 @@ fn emit_manual_let_else(
             } else {
                 format!("{{ {sn_else} }}")
             };
-            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 sn_bl = replace_in_pattern(cx, span, local, pat, &mut app);
             let sugg = format!("let {sn_bl} = {sn_expr} else {else_bl};");
             diag.span_suggestion(span, "consider writing", sugg, app);
         },
     );
 }
 
+// replaces the locals in the pattern
+fn replace_in_pattern(
+    cx: &LateContext<'_>,
+    span: Span,
+    local: &Pat<'_>,
+    pat: &Pat<'_>,
+    app: &mut Applicability,
+) -> String {
+    let mut bindings_count = 0;
+    pat.each_binding_or_first(&mut |_, _, _, _| bindings_count += 1);
+    // If the pattern creates multiple bindings, exit early,
+    // as otherwise we might paste the pattern to the positions of multiple bindings.
+    if bindings_count > 1 {
+        let (sn_pat, _) = snippet_with_context(cx, pat.span, span.ctxt(), "", app);
+        return sn_pat.into_owned();
+    }
+
+    match pat.kind {
+        PatKind::Binding(..) => {
+            let (sn_bdg, _) = snippet_with_context(cx, local.span, span.ctxt(), "", app);
+            return sn_bdg.to_string();
+        },
+        PatKind::Or(pats) => {
+            let patterns = pats
+                .iter()
+                .map(|pat| replace_in_pattern(cx, span, local, pat, app))
+                .collect::<Vec<_>>();
+            let or_pat = patterns.join(" | ");
+            return format!("({or_pat})");
+        },
+        // Replace the variable name iff `TupleStruct` has one argument like `Variant(v)`.
+        PatKind::TupleStruct(ref w, args, dot_dot_pos) => {
+            let mut args = args
+                .iter()
+                .map(|pat| replace_in_pattern(cx, span, local, pat, app))
+                .collect::<Vec<_>>();
+            if let Some(pos) = dot_dot_pos.as_opt_usize() {
+                args.insert(pos, "..".to_owned());
+            }
+            let args = args.join(", ");
+            let sn_wrapper = cx.sess().source_map().span_to_snippet(w.span()).unwrap_or_default();
+            return format!("{sn_wrapper}({args})");
+        },
+        _ => {},
+    }
+    let (sn_pat, _) = snippet_with_context(cx, pat.span, span.ctxt(), "", app);
+    sn_pat.into_owned()
+}
+
 /// Check whether an expression is divergent. May give false negatives.
 fn expr_diverges(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
     struct V<'cx, 'tcx> {
diff --git a/tests/ui/manual_let_else.rs b/tests/ui/manual_let_else.rs
index 3996d775f55..351ea0e4f50 100644
--- a/tests/ui/manual_let_else.rs
+++ b/tests/ui/manual_let_else.rs
@@ -146,10 +146,20 @@ fn fire() {
         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 };
+
+    // `mut v` is inserted into the pattern
+    let mut v = if let Variant::B(b) = e() { b } else { return };
+
+    // Nesting works
+    let nested = Ok(Some(e()));
+    let v = if let Ok(Some(Variant::B(b))) | Err(Some(Variant::A(b, _))) = nested {
+        b
+    } else {
+        return;
+    };
+    // dot dot works
+    let v = if let Variant::A(.., a) = e() { a } else { return };
 }
 
 fn not_fire() {
diff --git a/tests/ui/manual_let_else.stderr b/tests/ui/manual_let_else.stderr
index f6f56f7b00e..0e876797134 100644
--- a/tests/ui/manual_let_else.stderr
+++ b/tests/ui/manual_let_else.stderr
@@ -260,19 +260,42 @@ LL |     create_binding_if_some!(w, g());
    = 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:150:5
+  --> $DIR/manual_let_else.rs:149: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 };`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let Variant::A(v, 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 };`
+LL |     let mut v = if let Variant::B(b) = e() { b } else { return };
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let Variant::B(mut v) = e() else { return };`
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:262:5
+  --> $DIR/manual_let_else.rs:156:5
+   |
+LL | /     let v = if let Ok(Some(Variant::B(b))) | Err(Some(Variant::A(b, _))) = nested {
+LL | |         b
+LL | |     } else {
+LL | |         return;
+LL | |     };
+   | |______^
+   |
+help: consider writing
+   |
+LL ~     let (Ok(Some(Variant::B(v))) | Err(Some(Variant::A(v, _)))) = nested else {
+LL +         return;
+LL +     };
+   |
+
+error: this could be rewritten as `let...else`
+  --> $DIR/manual_let_else.rs:162:5
+   |
+LL |     let v = if let Variant::A(.., a) = e() { a } else { return };
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let Variant::A(.., v) = e() else { return };`
+
+error: this could be rewritten as `let...else`
+  --> $DIR/manual_let_else.rs:272:5
    |
 LL | /     let _ = match ff {
 LL | |         Some(value) => value,
@@ -280,5 +303,5 @@ LL | |         _ => macro_call!(),
 LL | |     };
    | |______^ help: consider writing: `let Some(_) = ff else { macro_call!() };`
 
-error: aborting due to 20 previous errors
+error: aborting due to 22 previous errors
 
diff --git a/tests/ui/manual_let_else_match.rs b/tests/ui/manual_let_else_match.rs
index 73b74679125..dfca3b023cd 100644
--- a/tests/ui/manual_let_else_match.rs
+++ b/tests/ui/manual_let_else_match.rs
@@ -68,7 +68,7 @@ fn fire() {
     let f = Variant::Bar(1);
 
     let _value = match f {
-        Variant::Bar(_) | Variant::Baz(_) => (),
+        Variant::Bar(v) | Variant::Baz(v) => v,
         _ => return,
     };
 
diff --git a/tests/ui/manual_let_else_match.stderr b/tests/ui/manual_let_else_match.stderr
index bacc14dc967..13ed35bc1d5 100644
--- a/tests/ui/manual_let_else_match.stderr
+++ b/tests/ui/manual_let_else_match.stderr
@@ -58,10 +58,10 @@ error: this could be rewritten as `let...else`
   --> $DIR/manual_let_else_match.rs:70:5
    |
 LL | /     let _value = match f {
-LL | |         Variant::Bar(_) | Variant::Baz(_) => (),
+LL | |         Variant::Bar(v) | Variant::Baz(v) => v,
 LL | |         _ => return,
 LL | |     };
-   | |______^ help: consider writing: `let (Variant::Bar(_) | Variant::Baz(_)) = f else { return };`
+   | |______^ help: consider writing: `let (Variant::Bar(_value) | Variant::Baz(_value)) = f else { return };`
 
 error: this could be rewritten as `let...else`
   --> $DIR/manual_let_else_match.rs:76:5
-- 
cgit 1.4.1-3-g733a5


From cfa5aa2aad8e11508c4d57ee3113c8d0620a88d5 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Thu, 18 May 2023 12:33:52 +0000
Subject: Don't suggest unnameable types in box_default, let_underscore_untyped

---
 clippy_lints/src/box_default.rs    |  9 ++++++---
 clippy_lints/src/let_underscore.rs | 17 ++++++++---------
 tests/ui/box_default.fixed         |  9 ++++++++-
 tests/ui/box_default.rs            |  9 ++++++++-
 tests/ui/box_default.stderr        |  8 ++++----
 tests/ui/let_underscore_untyped.rs |  1 +
 6 files changed, 35 insertions(+), 18 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/box_default.rs b/clippy_lints/src/box_default.rs
index dfa949d1af2..e42c3fe2432 100644
--- a/clippy_lints/src/box_default.rs
+++ b/clippy_lints/src/box_default.rs
@@ -8,7 +8,9 @@ use rustc_hir::{
     Block, Expr, ExprKind, Local, Node, QPath, TyKind,
 };
 use rustc_lint::{LateContext, LateLintPass, LintContext};
-use rustc_middle::{lint::in_external_macro, ty::print::with_forced_trimmed_paths};
+use rustc_middle::lint::in_external_macro;
+use rustc_middle::ty::print::with_forced_trimmed_paths;
+use rustc_middle::ty::IsSuggestable;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::sym;
 
@@ -49,7 +51,6 @@ impl LateLintPass<'_> for BoxDefault {
             && path_def_id(cx, ty).map_or(false, |id| Some(id) == cx.tcx.lang_items().owned_box())
             && is_default_equivalent(cx, arg)
         {
-            let arg_ty = cx.typeck_results().expr_ty(arg);
             span_lint_and_sugg(
                 cx,
                 BOX_DEFAULT,
@@ -58,8 +59,10 @@ impl LateLintPass<'_> for BoxDefault {
                 "try",
                 if is_plain_default(arg_path) || given_type(cx, expr) {
                     "Box::default()".into()
-                } else {
+                } else if let Some(arg_ty) = cx.typeck_results().expr_ty(arg).make_suggestable(cx.tcx, true) {
                     with_forced_trimmed_paths!(format!("Box::<{arg_ty}>::default()"))
+                } else {
+                    return
                 },
                 Applicability::MachineApplicable
             );
diff --git a/clippy_lints/src/let_underscore.rs b/clippy_lints/src/let_underscore.rs
index 34a9d217606..e6614180920 100644
--- a/clippy_lints/src/let_underscore.rs
+++ b/clippy_lints/src/let_underscore.rs
@@ -2,10 +2,11 @@ use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::is_from_proc_macro;
 use clippy_utils::ty::{implements_trait, is_must_use_ty, match_type};
 use clippy_utils::{is_must_use_func_call, paths};
-use rustc_hir::{ExprKind, Local, PatKind};
+use rustc_hir::{Local, PatKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::subst::GenericArgKind;
+use rustc_middle::ty::IsSuggestable;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::{BytePos, Span};
 
@@ -192,14 +193,12 @@ impl<'tcx> LateLintPass<'tcx> for LetUnderscore {
             if local.pat.default_binding_modes && local.ty.is_none() {
                 // When `default_binding_modes` is true, the `let` keyword is present.
 
-				// Ignore function calls that return impl traits...
-				if let Some(init) = local.init &&
-				matches!(init.kind, ExprKind::Call(_, _) | ExprKind::MethodCall(_, _, _, _)) {
-					let expr_ty = cx.typeck_results().expr_ty(init);
-					if expr_ty.is_impl_trait() {
-						return;
-					}
-				}
+                // Ignore unnameable types
+                if let Some(init) = local.init
+                    && !cx.typeck_results().expr_ty(init).is_suggestable(cx.tcx, true)
+                {
+                    return;
+                }
 
                 // Ignore if it is from a procedural macro...
                 if is_from_proc_macro(cx, init) {
diff --git a/tests/ui/box_default.fixed b/tests/ui/box_default.fixed
index e6331290420..fb066d8982e 100644
--- a/tests/ui/box_default.fixed
+++ b/tests/ui/box_default.fixed
@@ -1,6 +1,6 @@
 //@run-rustfix
 #![warn(clippy::box_default)]
-#![allow(clippy::default_constructed_unit_structs)]
+#![allow(unused, clippy::default_constructed_unit_structs)]
 
 #[derive(Default)]
 struct ImplementsDefault;
@@ -35,6 +35,13 @@ fn main() {
     let _more = ret_ty_fn();
     call_ty_fn(Box::default());
     issue_10381();
+
+    // `Box::<Option<_>>::default()` would be valid here, but not `Box::default()` or
+    // `Box::<Option<[closure@...]>::default()`
+    //
+    // Would have a suggestion after https://github.com/rust-lang/rust/blob/fdd030127cc68afec44a8d3f6341525dd34e50ae/compiler/rustc_middle/src/ty/diagnostics.rs#L554-L563
+    let mut unnameable = Box::new(Option::default());
+    let _ = unnameable.insert(|| {});
 }
 
 fn ret_ty_fn() -> Box<bool> {
diff --git a/tests/ui/box_default.rs b/tests/ui/box_default.rs
index 34a05a29c5a..2882170492c 100644
--- a/tests/ui/box_default.rs
+++ b/tests/ui/box_default.rs
@@ -1,6 +1,6 @@
 //@run-rustfix
 #![warn(clippy::box_default)]
-#![allow(clippy::default_constructed_unit_structs)]
+#![allow(unused, clippy::default_constructed_unit_structs)]
 
 #[derive(Default)]
 struct ImplementsDefault;
@@ -35,6 +35,13 @@ fn main() {
     let _more = ret_ty_fn();
     call_ty_fn(Box::new(u8::default()));
     issue_10381();
+
+    // `Box::<Option<_>>::default()` would be valid here, but not `Box::default()` or
+    // `Box::<Option<[closure@...]>::default()`
+    //
+    // Would have a suggestion after https://github.com/rust-lang/rust/blob/fdd030127cc68afec44a8d3f6341525dd34e50ae/compiler/rustc_middle/src/ty/diagnostics.rs#L554-L563
+    let mut unnameable = Box::new(Option::default());
+    let _ = unnameable.insert(|| {});
 }
 
 fn ret_ty_fn() -> Box<bool> {
diff --git a/tests/ui/box_default.stderr b/tests/ui/box_default.stderr
index c9834863601..13dfc5ae48a 100644
--- a/tests/ui/box_default.stderr
+++ b/tests/ui/box_default.stderr
@@ -73,25 +73,25 @@ LL |     call_ty_fn(Box::new(u8::default()));
    |                ^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Box::default()`
 
 error: `Box::new(_)` of default value
-  --> $DIR/box_default.rs:41:5
+  --> $DIR/box_default.rs:48:5
    |
 LL |     Box::new(bool::default())
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Box::<bool>::default()`
 
 error: `Box::new(_)` of default value
-  --> $DIR/box_default.rs:58:28
+  --> $DIR/box_default.rs:65:28
    |
 LL |     let _: Box<dyn Read> = Box::new(ImplementsDefault::default());
    |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Box::<ImplementsDefault>::default()`
 
 error: `Box::new(_)` of default value
-  --> $DIR/box_default.rs:67:17
+  --> $DIR/box_default.rs:74:17
    |
 LL |         let _ = Box::new(WeirdPathed::default());
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Box::<WeirdPathed>::default()`
 
 error: `Box::new(_)` of default value
-  --> $DIR/box_default.rs:79:18
+  --> $DIR/box_default.rs:86:18
    |
 LL |             Some(Box::new(Foo::default()))
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Box::<Foo>::default()`
diff --git a/tests/ui/let_underscore_untyped.rs b/tests/ui/let_underscore_untyped.rs
index 05ecd9b281a..2c313ff35d5 100644
--- a/tests/ui/let_underscore_untyped.rs
+++ b/tests/ui/let_underscore_untyped.rs
@@ -54,6 +54,7 @@ fn main() {
     let _ = e();
     let _ = f();
     let _ = g();
+    let closure = || {};
 
     _ = a();
     _ = b(1);
-- 
cgit 1.4.1-3-g733a5


From 0b3c2ed81152a927c91c02d9d94762d2c65254a2 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Tue, 7 Mar 2023 22:51:35 -0500
Subject: Search for inactive `cfg` attributes and empty macro expansion
 through the entire block

---
 clippy_lints/src/matches/mod.rs |  13 ++--
 clippy_utils/src/hir_utils.rs   | 156 ++++++++++++++++++++++++++++------------
 clippy_utils/src/lib.rs         |  34 ++++-----
 clippy_utils/src/source.rs      |  52 +++++++++++++-
 tests/ui/match_same_arms.rs     |  48 ++++++++++++-
 5 files changed, 229 insertions(+), 74 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/mod.rs b/clippy_lints/src/matches/mod.rs
index 87b63eead25..55ec9d4474f 100644
--- a/clippy_lints/src/matches/mod.rs
+++ b/clippy_lints/src/matches/mod.rs
@@ -25,9 +25,9 @@ mod wild_in_or_pats;
 
 use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::{snippet_opt, walk_span_to_context};
-use clippy_utils::{higher, in_constant, is_span_match};
+use clippy_utils::{higher, in_constant, is_span_match, tokenize_with_text};
 use rustc_hir::{Arm, Expr, ExprKind, Local, MatchSource, Pat};
-use rustc_lexer::{tokenize, TokenKind};
+use rustc_lexer::TokenKind;
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
@@ -1147,12 +1147,7 @@ fn span_contains_cfg(cx: &LateContext<'_>, s: Span) -> bool {
         // Assume true. This would require either an invalid span, or one which crosses file boundaries.
         return true;
     };
-    let mut pos = 0usize;
-    let mut iter = tokenize(&snip).map(|t| {
-        let start = pos;
-        pos += t.len as usize;
-        (t.kind, start..pos)
-    });
+    let mut iter = tokenize_with_text(&snip);
 
     // Search for the token sequence [`#`, `[`, `cfg`]
     while iter.any(|(t, _)| matches!(t, TokenKind::Pound)) {
@@ -1163,7 +1158,7 @@ fn span_contains_cfg(cx: &LateContext<'_>, s: Span) -> bool {
             )
         });
         if matches!(iter.next(), Some((TokenKind::OpenBracket, _)))
-            && matches!(iter.next(), Some((TokenKind::Ident, range)) if &snip[range.clone()] == "cfg")
+            && matches!(iter.next(), Some((TokenKind::Ident, "cfg")))
         {
             return true;
         }
diff --git a/clippy_utils/src/hir_utils.rs b/clippy_utils/src/hir_utils.rs
index 9b7408d5133..3561e760ac9 100644
--- a/clippy_utils/src/hir_utils.rs
+++ b/clippy_utils/src/hir_utils.rs
@@ -1,6 +1,7 @@
 use crate::consts::constant_simple;
 use crate::macros::macro_backtrace;
-use crate::source::snippet_opt;
+use crate::source::{get_source_text, snippet_opt, walk_span_to_context, SpanRange};
+use crate::tokenize_with_text;
 use rustc_ast::ast::InlineAsmTemplatePiece;
 use rustc_data_structures::fx::FxHasher;
 use rustc_hir::def::Res;
@@ -13,8 +14,9 @@ use rustc_hir::{
 use rustc_lexer::{tokenize, TokenKind};
 use rustc_lint::LateContext;
 use rustc_middle::ty::TypeckResults;
-use rustc_span::{sym, Symbol};
+use rustc_span::{sym, BytePos, Symbol, SyntaxContext};
 use std::hash::{Hash, Hasher};
+use std::ops::Range;
 
 /// Callback that is called when two expressions are not equal in the sense of `SpanlessEq`, but
 /// other conditions would make them equal.
@@ -127,51 +129,83 @@ impl HirEqInterExpr<'_, '_, '_> {
 
     /// Checks whether two blocks are the same.
     fn eq_block(&mut self, left: &Block<'_>, right: &Block<'_>) -> bool {
-        match (left.stmts, left.expr, right.stmts, right.expr) {
-            ([], None, [], None) => {
-                // For empty blocks, check to see if the tokens are equal. This will catch the case where a macro
-                // expanded to nothing, or the cfg attribute was used.
-                let (Some(left), Some(right)) = (
-                    snippet_opt(self.inner.cx, left.span),
-                    snippet_opt(self.inner.cx, right.span),
-                ) else { return true };
-                let mut left_pos = 0;
-                let left = tokenize(&left)
-                    .map(|t| {
-                        let end = left_pos + t.len as usize;
-                        let s = &left[left_pos..end];
-                        left_pos = end;
-                        (t, s)
-                    })
-                    .filter(|(t, _)| {
-                        !matches!(
-                            t.kind,
-                            TokenKind::LineComment { .. } | TokenKind::BlockComment { .. } | TokenKind::Whitespace
-                        )
-                    })
-                    .map(|(_, s)| s);
-                let mut right_pos = 0;
-                let right = tokenize(&right)
-                    .map(|t| {
-                        let end = right_pos + t.len as usize;
-                        let s = &right[right_pos..end];
-                        right_pos = end;
-                        (t, s)
-                    })
-                    .filter(|(t, _)| {
-                        !matches!(
-                            t.kind,
-                            TokenKind::LineComment { .. } | TokenKind::BlockComment { .. } | TokenKind::Whitespace
-                        )
-                    })
-                    .map(|(_, s)| s);
-                left.eq(right)
-            },
-            _ => {
-                over(left.stmts, right.stmts, |l, r| self.eq_stmt(l, r))
-                    && both(&left.expr, &right.expr, |l, r| self.eq_expr(l, r))
-            },
+        use TokenKind::{BlockComment, LineComment, Semi, Whitespace};
+        if left.stmts.len() != right.stmts.len() {
+            return false;
         }
+        let lspan = left.span.data();
+        let rspan = right.span.data();
+        if lspan.ctxt != SyntaxContext::root() && rspan.ctxt != SyntaxContext::root() {
+            // Don't try to check in between statements inside macros.
+            return over(left.stmts, right.stmts, |left, right| self.eq_stmt(left, right))
+                && both(&left.expr, &right.expr, |left, right| self.eq_expr(left, right));
+        }
+        if lspan.ctxt != rspan.ctxt {
+            return false;
+        }
+
+        let mut lstart = lspan.lo;
+        let mut rstart = rspan.lo;
+
+        for (left, right) in left.stmts.iter().zip(right.stmts) {
+            if !self.eq_stmt(left, right) {
+                return false;
+            }
+            let Some(lstmt_span) = walk_span_to_context(left.span, lspan.ctxt) else {
+                return false;
+            };
+            let Some(rstmt_span) = walk_span_to_context(right.span, rspan.ctxt) else {
+                return false;
+            };
+            let lstmt_span = lstmt_span.data();
+            let rstmt_span = rstmt_span.data();
+
+            if lstmt_span.lo < lstart && rstmt_span.lo < rstart {
+                // Can happen when macros expand to multiple statements, or rearrange statements.
+                // Nothing in between the statements to check in this case.
+                continue;
+            } else if lstmt_span.lo < lstart || rstmt_span.lo < rstart {
+                // Only one of the blocks had a weird macro.
+                return false;
+            }
+            if !eq_span_tokens(self.inner.cx, lstart..lstmt_span.lo, rstart..rstmt_span.lo, |t| {
+                !matches!(t, Whitespace | LineComment { .. } | BlockComment { .. } | Semi)
+            }) {
+                return false;
+            }
+
+            lstart = lstmt_span.hi;
+            rstart = rstmt_span.hi;
+        }
+
+        let (lend, rend) = match (left.expr, right.expr) {
+            (Some(left), Some(right)) => {
+                if !self.eq_expr(left, right) {
+                    return false;
+                }
+                let Some(lexpr_span) = walk_span_to_context(left.span, lspan.ctxt) else {
+                    return false;
+                };
+                let Some(rexpr_span) = walk_span_to_context(right.span, rspan.ctxt) else {
+                    return false;
+                };
+                (lexpr_span.lo(), rexpr_span.lo())
+            },
+            (None, None) => (lspan.hi, rspan.hi),
+            (Some(_), None) | (None, Some(_)) => return false,
+        };
+
+        if lend < lstart && rend < rstart {
+            // Can happen when macros rearrange the input.
+            // Nothing in between the statements to check in this case.
+            return true;
+        } else if lend < lstart || rend < rstart {
+            // Only one of the blocks had a weird macro
+            return false;
+        }
+        eq_span_tokens(self.inner.cx, lstart..lend, rstart..rend, |t| {
+            !matches!(t, Whitespace | LineComment { .. } | BlockComment { .. } | Semi)
+        })
     }
 
     fn should_ignore(&mut self, expr: &Expr<'_>) -> bool {
@@ -1038,3 +1072,33 @@ pub fn hash_expr(cx: &LateContext<'_>, e: &Expr<'_>) -> u64 {
     h.hash_expr(e);
     h.finish()
 }
+
+fn eq_span_tokens(
+    cx: &LateContext<'_>,
+    left: impl SpanRange,
+    right: impl SpanRange,
+    pred: impl Fn(TokenKind) -> bool,
+) -> bool {
+    fn f(cx: &LateContext<'_>, left: Range<BytePos>, right: Range<BytePos>, pred: impl Fn(TokenKind) -> bool) -> bool {
+        if let Some(lsrc) = get_source_text(cx, left)
+            && let Some(lsrc) = lsrc.as_str()
+            && let Some(rsrc) = get_source_text(cx, right)
+            && let Some(rsrc) = rsrc.as_str()
+        {
+            let pred = |t: &(_, _)| pred(t.0);
+            let map = |(_, x)| x;
+
+            let ltok = tokenize_with_text(lsrc)
+                .filter(pred)
+                .map(map);
+            let rtok = tokenize_with_text(rsrc)
+                .filter(pred)
+                .map(map);
+            ltok.eq(rtok)
+        } else {
+            // Unable to access the source. Conservatively assume the blocks aren't equal.
+            false
+        }
+    }
+    f(cx, left.into_range(), right.into_range(), pred)
+}
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 2e27c260f74..2ddd2ade6ae 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -77,6 +77,7 @@ use std::sync::OnceLock;
 use std::sync::{Mutex, MutexGuard};
 
 use if_chain::if_chain;
+use itertools::Itertools;
 use rustc_ast::ast::{self, LitKind, RangeLimits};
 use rustc_ast::Attribute;
 use rustc_data_structures::fx::FxHashMap;
@@ -2490,6 +2491,17 @@ pub fn walk_to_expr_usage<'tcx, T>(
     None
 }
 
+/// Tokenizes the input while keeping the text associated with each token.
+pub fn tokenize_with_text(s: &str) -> impl Iterator<Item = (TokenKind, &str)> {
+    let mut pos = 0;
+    tokenize(s).map(move |t| {
+        let end = pos + t.len;
+        let range = pos as usize..end as usize;
+        pos = end;
+        (t.kind, s.get(range).unwrap_or_default())
+    })
+}
+
 /// Checks whether a given span has any comment token
 /// This checks for all types of comment: line "//", block "/**", doc "///" "//!"
 pub fn span_contains_comment(sm: &SourceMap, span: Span) -> bool {
@@ -2506,23 +2518,11 @@ pub fn span_contains_comment(sm: &SourceMap, span: Span) -> bool {
 /// Comments are returned wrapped with their relevant delimiters
 pub fn span_extract_comment(sm: &SourceMap, span: Span) -> String {
     let snippet = sm.span_to_snippet(span).unwrap_or_default();
-    let mut comments_buf: Vec<String> = Vec::new();
-    let mut index: usize = 0;
-
-    for token in tokenize(&snippet) {
-        let token_range = index..(index + token.len as usize);
-        index += token.len as usize;
-        match token.kind {
-            TokenKind::BlockComment { .. } | TokenKind::LineComment { .. } => {
-                if let Some(comment) = snippet.get(token_range) {
-                    comments_buf.push(comment.to_string());
-                }
-            },
-            _ => (),
-        }
-    }
-
-    comments_buf.join("\n")
+    let res = tokenize_with_text(&snippet)
+        .filter(|(t, _)| matches!(t, TokenKind::BlockComment { .. } | TokenKind::LineComment { .. }))
+        .map(|(_, s)| s)
+        .join("\n");
+    res
 }
 
 pub fn span_find_starting_semi(sm: &SourceMap, span: Span) -> Span {
diff --git a/clippy_utils/src/source.rs b/clippy_utils/src/source.rs
index 62fa37660fa..0f60290644a 100644
--- a/clippy_utils/src/source.rs
+++ b/clippy_utils/src/source.rs
@@ -2,14 +2,64 @@
 
 #![allow(clippy::module_name_repetitions)]
 
+use rustc_data_structures::sync::Lrc;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LintContext};
 use rustc_session::Session;
-use rustc_span::hygiene;
 use rustc_span::source_map::{original_sp, SourceMap};
+use rustc_span::{hygiene, SourceFile};
 use rustc_span::{BytePos, Pos, Span, SpanData, SyntaxContext, DUMMY_SP};
 use std::borrow::Cow;
+use std::ops::Range;
+
+/// A type which can be converted to the range portion of a `Span`.
+pub trait SpanRange {
+    fn into_range(self) -> Range<BytePos>;
+}
+impl SpanRange for Span {
+    fn into_range(self) -> Range<BytePos> {
+        let data = self.data();
+        data.lo..data.hi
+    }
+}
+impl SpanRange for SpanData {
+    fn into_range(self) -> Range<BytePos> {
+        self.lo..self.hi
+    }
+}
+impl SpanRange for Range<BytePos> {
+    fn into_range(self) -> Range<BytePos> {
+        self
+    }
+}
+
+pub struct SourceFileRange {
+    pub sf: Lrc<SourceFile>,
+    pub range: Range<usize>,
+}
+impl SourceFileRange {
+    /// Attempts to get the text from the source file. This can fail if the source text isn't
+    /// loaded.
+    pub fn as_str(&self) -> Option<&str> {
+        self.sf.src.as_ref().and_then(|x| x.get(self.range.clone()))
+    }
+}
+
+/// Gets the source file, and range in the file, of the given span. Returns `None` if the span
+/// extends through multiple files, or is malformed.
+pub fn get_source_text(cx: &impl LintContext, sp: impl SpanRange) -> Option<SourceFileRange> {
+    fn f(sm: &SourceMap, sp: Range<BytePos>) -> Option<SourceFileRange> {
+        let start = sm.lookup_byte_offset(sp.start);
+        let end = sm.lookup_byte_offset(sp.end);
+        if !Lrc::ptr_eq(&start.sf, &end.sf) || start.pos > end.pos {
+            return None;
+        }
+        let range = start.pos.to_usize()..end.pos.to_usize();
+        Some(SourceFileRange { sf: start.sf, range })
+    }
+    f(cx.sess().source_map(), sp.into_range())
+}
 
 /// Like `snippet_block`, but add braces if the expr is not an `ExprKind::Block`.
 pub fn expr_block<T: LintContext>(
diff --git a/tests/ui/match_same_arms.rs b/tests/ui/match_same_arms.rs
index 0b9342c9c42..15410734dec 100644
--- a/tests/ui/match_same_arms.rs
+++ b/tests/ui/match_same_arms.rs
@@ -53,4 +53,50 @@ mod issue4244 {
     }
 }
 
-fn main() {}
+macro_rules! m {
+    (foo) => {};
+    (bar) => {};
+}
+
+fn main() {
+    let x = 0;
+    let _ = match 0 {
+        0 => {
+            m!(foo);
+            x
+        },
+        1 => {
+            m!(bar);
+            x
+        },
+        _ => 1,
+    };
+
+    let _ = match 0 {
+        0 => {
+            let mut x = 0;
+            #[cfg(not_enabled)]
+            {
+                x = 5;
+            }
+            #[cfg(not(not_enabled))]
+            {
+                x = 6;
+            }
+            x
+        },
+        1 => {
+            let mut x = 0;
+            #[cfg(also_not_enabled)]
+            {
+                x = 5;
+            }
+            #[cfg(not(also_not_enabled))]
+            {
+                x = 6;
+            }
+            x
+        },
+        _ => 0,
+    };
+}
-- 
cgit 1.4.1-3-g733a5


From 5351170744bdc6dfca0f57908cd072cfa84a3f30 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Thu, 9 Mar 2023 15:46:46 -0500
Subject: Slightly refactor constant evaluation and add detection for empty
 macro expansion and `cfg`ed statements.

---
 clippy_lints/src/assertions_on_constants.rs        |   2 +-
 clippy_lints/src/casts/cast_nan_to_int.rs          |   4 +-
 clippy_lints/src/casts/cast_possible_truncation.rs |   2 +-
 clippy_lints/src/casts/cast_sign_loss.rs           |   2 +-
 clippy_lints/src/floating_point_arithmetic.rs      |  22 ++---
 clippy_lints/src/fn_null_check.rs                  |   6 +-
 clippy_lints/src/implicit_saturating_add.rs        |   4 +-
 clippy_lints/src/index_refutable_slice.rs          |   2 +-
 clippy_lints/src/indexing_slicing.rs               |   8 +-
 clippy_lints/src/manual_strip.rs                   |   2 +-
 clippy_lints/src/matches/overlapping_arms.rs       |   4 +-
 clippy_lints/src/methods/iter_nth_zero.rs          |   2 +-
 clippy_lints/src/methods/iterator_step_by_zero.rs  |   2 +-
 clippy_lints/src/methods/mod.rs                    |   4 +-
 clippy_lints/src/methods/repeat_once.rs            |   4 +-
 clippy_lints/src/methods/str_splitn.rs             |   2 +-
 .../src/operators/absurd_extreme_comparisons.rs    |   2 +-
 .../src/operators/arithmetic_side_effects.rs       |   2 +-
 clippy_lints/src/operators/bit_mask.rs             |   2 +-
 clippy_lints/src/operators/cmp_nan.rs              |   2 +-
 clippy_lints/src/operators/duration_subsec.rs      |   2 +-
 clippy_lints/src/operators/float_cmp.rs            |  57 +++++------
 clippy_lints/src/operators/modulo_arithmetic.rs    |   6 +-
 clippy_lints/src/ranges.rs                         |   8 +-
 clippy_lints/src/regex.rs                          |   2 +-
 clippy_lints/src/transmute/transmute_null_to_fn.rs |   4 +-
 clippy_lints/src/transmute/transmuting_null.rs     |   5 +-
 clippy_lints/src/vec.rs                            |   2 +-
 clippy_utils/src/consts.rs                         | 107 ++++++++++++++-------
 clippy_utils/src/hir_utils.rs                      |   2 +
 clippy_utils/src/lib.rs                            |   2 +-
 tests/ui/match_same_arms.rs                        |  12 +++
 32 files changed, 163 insertions(+), 126 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/assertions_on_constants.rs b/clippy_lints/src/assertions_on_constants.rs
index a36df55d0bd..a8dc0cb3b58 100644
--- a/clippy_lints/src/assertions_on_constants.rs
+++ b/clippy_lints/src/assertions_on_constants.rs
@@ -38,7 +38,7 @@ impl<'tcx> LateLintPass<'tcx> for AssertionsOnConstants {
             _ => return,
         };
         let Some((condition, panic_expn)) = find_assert_args(cx, e, macro_call.expn) else { return };
-        let Some((Constant::Bool(val), _)) = constant(cx, cx.typeck_results(), condition) else { return };
+        let Some(Constant::Bool(val)) = constant(cx, cx.typeck_results(), condition) else { return };
         if val {
             span_lint_and_help(
                 cx,
diff --git a/clippy_lints/src/casts/cast_nan_to_int.rs b/clippy_lints/src/casts/cast_nan_to_int.rs
index 322dc41b3a1..da756129db3 100644
--- a/clippy_lints/src/casts/cast_nan_to_int.rs
+++ b/clippy_lints/src/casts/cast_nan_to_int.rs
@@ -21,8 +21,8 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_expr: &Expr<'_>,
 
 fn is_known_nan(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
     match constant(cx, cx.typeck_results(), e) {
-        Some((Constant::F64(n), _)) => n.is_nan(),
-        Some((Constant::F32(n), _)) => n.is_nan(),
+        Some(Constant::F64(n)) => n.is_nan(),
+        Some(Constant::F32(n)) => n.is_nan(),
         _ => false,
     }
 }
diff --git a/clippy_lints/src/casts/cast_possible_truncation.rs b/clippy_lints/src/casts/cast_possible_truncation.rs
index 95c2ecbf791..84b99ad5c24 100644
--- a/clippy_lints/src/casts/cast_possible_truncation.rs
+++ b/clippy_lints/src/casts/cast_possible_truncation.rs
@@ -15,7 +15,7 @@ use rustc_target::abi::IntegerType;
 use super::{utils, CAST_ENUM_TRUNCATION, CAST_POSSIBLE_TRUNCATION};
 
 fn constant_int(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<u128> {
-    if let Some((Constant::Int(c), _)) = constant(cx, cx.typeck_results(), expr) {
+    if let Some(Constant::Int(c)) = constant(cx, cx.typeck_results(), expr) {
         Some(c)
     } else {
         None
diff --git a/clippy_lints/src/casts/cast_sign_loss.rs b/clippy_lints/src/casts/cast_sign_loss.rs
index a20a97d4e56..a83dfd94dc2 100644
--- a/clippy_lints/src/casts/cast_sign_loss.rs
+++ b/clippy_lints/src/casts/cast_sign_loss.rs
@@ -29,7 +29,7 @@ fn should_lint(cx: &LateContext<'_>, cast_op: &Expr<'_>, cast_from: Ty<'_>, cast
             // Don't lint for positive constants.
             let const_val = constant(cx, cx.typeck_results(), cast_op);
             if_chain! {
-                if let Some((Constant::Int(n), _)) = const_val;
+                if let Some(Constant::Int(n)) = const_val;
                 if let ty::Int(ity) = *cast_from.kind();
                 if sext(cx.tcx, n, ity) >= 0;
                 then {
diff --git a/clippy_lints/src/floating_point_arithmetic.rs b/clippy_lints/src/floating_point_arithmetic.rs
index a1a2c398a8a..3c55a563af4 100644
--- a/clippy_lints/src/floating_point_arithmetic.rs
+++ b/clippy_lints/src/floating_point_arithmetic.rs
@@ -114,7 +114,7 @@ declare_lint_pass!(FloatingPointArithmetic => [
 // Returns the specialized log method for a given base if base is constant
 // and is one of 2, 10 and e
 fn get_specialized_log_method(cx: &LateContext<'_>, base: &Expr<'_>) -> Option<&'static str> {
-    if let Some((value, _)) = constant(cx, cx.typeck_results(), base) {
+    if let Some(value) = constant(cx, cx.typeck_results(), base) {
         if F32(2.0) == value || F64(2.0) == value {
             return Some("log2");
         } else if F32(10.0) == value || F64(10.0) == value {
@@ -193,8 +193,8 @@ fn check_ln1p(cx: &LateContext<'_>, expr: &Expr<'_>, receiver: &Expr<'_>) {
             constant(cx, cx.typeck_results(), lhs),
             constant(cx, cx.typeck_results(), rhs),
         ) {
-            (Some((value, _)), _) if F32(1.0) == value || F64(1.0) == value => rhs,
-            (_, Some((value, _))) if F32(1.0) == value || F64(1.0) == value => lhs,
+            (Some(value), _) if F32(1.0) == value || F64(1.0) == value => rhs,
+            (_, Some(value)) if F32(1.0) == value || F64(1.0) == value => lhs,
             _ => return,
         };
 
@@ -237,7 +237,7 @@ fn get_integer_from_float_constant(value: &Constant) -> Option<i32> {
 
 fn check_powf(cx: &LateContext<'_>, expr: &Expr<'_>, receiver: &Expr<'_>, args: &[Expr<'_>]) {
     // Check receiver
-    if let Some((value, _)) = constant(cx, cx.typeck_results(), receiver) {
+    if let Some(value) = constant(cx, cx.typeck_results(), receiver) {
         if let Some(method) = if F32(f32_consts::E) == value || F64(f64_consts::E) == value {
             Some("exp")
         } else if F32(2.0) == value || F64(2.0) == value {
@@ -258,7 +258,7 @@ fn check_powf(cx: &LateContext<'_>, expr: &Expr<'_>, receiver: &Expr<'_>, args:
     }
 
     // Check argument
-    if let Some((value, _)) = constant(cx, cx.typeck_results(), &args[0]) {
+    if let Some(value) = constant(cx, cx.typeck_results(), &args[0]) {
         let (lint, help, suggestion) = if F32(1.0 / 2.0) == value || F64(1.0 / 2.0) == value {
             (
                 SUBOPTIMAL_FLOPS,
@@ -298,7 +298,7 @@ fn check_powf(cx: &LateContext<'_>, expr: &Expr<'_>, receiver: &Expr<'_>, args:
 }
 
 fn check_powi(cx: &LateContext<'_>, expr: &Expr<'_>, receiver: &Expr<'_>, args: &[Expr<'_>]) {
-    if let Some((value, _)) = constant(cx, cx.typeck_results(), &args[0]) {
+    if let Some(value) = constant(cx, cx.typeck_results(), &args[0]) {
         if value == Int(2) {
             if let Some(parent) = get_parent_expr(cx, expr) {
                 if let Some(grandparent) = get_parent_expr(cx, parent) {
@@ -384,8 +384,8 @@ fn detect_hypot(cx: &LateContext<'_>, receiver: &Expr<'_>) -> Option<String> {
                 _
             ) = &add_rhs.kind;
             if lmethod_name.as_str() == "powi" && rmethod_name.as_str() == "powi";
-            if let Some((lvalue, _)) = constant(cx, cx.typeck_results(), largs_1);
-            if let Some((rvalue, _)) = constant(cx, cx.typeck_results(), rargs_1);
+            if let Some(lvalue) = constant(cx, cx.typeck_results(), largs_1);
+            if let Some(rvalue) = constant(cx, cx.typeck_results(), rargs_1);
             if Int(2) == lvalue && Int(2) == rvalue;
             then {
                 return Some(format!("{}.hypot({})", Sugg::hir(cx, largs_0, "..").maybe_par(), Sugg::hir(cx, rargs_0, "..")));
@@ -416,7 +416,7 @@ fn check_expm1(cx: &LateContext<'_>, expr: &Expr<'_>) {
     if_chain! {
         if let ExprKind::Binary(Spanned { node: BinOpKind::Sub, .. }, lhs, rhs) = expr.kind;
         if cx.typeck_results().expr_ty(lhs).is_floating_point();
-        if let Some((value, _)) = constant(cx, cx.typeck_results(), rhs);
+        if let Some(value) = constant(cx, cx.typeck_results(), rhs);
         if F32(1.0) == value || F64(1.0) == value;
         if let ExprKind::MethodCall(path, self_arg, ..) = &lhs.kind;
         if cx.typeck_results().expr_ty(self_arg).is_floating_point();
@@ -669,8 +669,8 @@ fn check_radians(cx: &LateContext<'_>, expr: &Expr<'_>) {
             mul_lhs,
             mul_rhs,
         ) = &div_lhs.kind;
-        if let Some((rvalue, _)) = constant(cx, cx.typeck_results(), div_rhs);
-        if let Some((lvalue, _)) = constant(cx, cx.typeck_results(), mul_rhs);
+        if let Some(rvalue) = constant(cx, cx.typeck_results(), div_rhs);
+        if let Some(lvalue) = constant(cx, cx.typeck_results(), mul_rhs);
         then {
             // TODO: also check for constant values near PI/180 or 180/PI
             if (F32(f32_consts::PI) == rvalue || F64(f64_consts::PI) == rvalue) &&
diff --git a/clippy_lints/src/fn_null_check.rs b/clippy_lints/src/fn_null_check.rs
index d8f4a5fe221..521045a9fed 100644
--- a/clippy_lints/src/fn_null_check.rs
+++ b/clippy_lints/src/fn_null_check.rs
@@ -89,11 +89,7 @@ impl<'tcx> LateLintPass<'tcx> for FnNullCheck {
 
                     // Catching:
                     // (fn_ptr as *<const/mut> <ty>) == <const that evaluates to null_ptr>
-                    _ if matches!(
-                        constant(cx, cx.typeck_results(), to_check),
-                        Some((Constant::RawPtr(0), _))
-                    ) =>
-                    {
+                    _ if matches!(constant(cx, cx.typeck_results(), to_check), Some(Constant::RawPtr(0))) => {
                         lint_expr(cx, expr);
                     },
 
diff --git a/clippy_lints/src/implicit_saturating_add.rs b/clippy_lints/src/implicit_saturating_add.rs
index 012aa5a1d1d..ee7973b82ab 100644
--- a/clippy_lints/src/implicit_saturating_add.rs
+++ b/clippy_lints/src/implicit_saturating_add.rs
@@ -101,10 +101,10 @@ fn get_int_max(ty: Ty<'_>) -> Option<u128> {
 fn get_const<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>) -> Option<(u128, BinOpKind, &'tcx Expr<'tcx>)> {
     if let ExprKind::Binary(op, l, r) = expr.kind {
         let tr = cx.typeck_results();
-        if let Some((Constant::Int(c), _)) = constant(cx, tr, r) {
+        if let Some(Constant::Int(c)) = constant(cx, tr, r) {
             return Some((c, op.node, l));
         };
-        if let Some((Constant::Int(c), _)) = constant(cx, tr, l) {
+        if let Some(Constant::Int(c)) = constant(cx, tr, l) {
             return Some((c, invert_op(op.node)?, r));
         }
     }
diff --git a/clippy_lints/src/index_refutable_slice.rs b/clippy_lints/src/index_refutable_slice.rs
index bdeddf44df7..7a269e98ff1 100644
--- a/clippy_lints/src/index_refutable_slice.rs
+++ b/clippy_lints/src/index_refutable_slice.rs
@@ -254,7 +254,7 @@ impl<'a, 'tcx> Visitor<'tcx> for SliceIndexLintingVisitor<'a, 'tcx> {
                 let parent_id = map.parent_id(expr.hir_id);
                 if let Some(hir::Node::Expr(parent_expr)) = map.find(parent_id);
                 if let hir::ExprKind::Index(_, index_expr) = parent_expr.kind;
-                if let Some((Constant::Int(index_value), _)) = constant(cx, cx.typeck_results(), index_expr);
+                if let Some(Constant::Int(index_value)) = constant(cx, cx.typeck_results(), index_expr);
                 if let Ok(index_value) = index_value.try_into();
                 if index_value < max_suggested_slice;
 
diff --git a/clippy_lints/src/indexing_slicing.rs b/clippy_lints/src/indexing_slicing.rs
index 924a361c0f6..22c14d9b04d 100644
--- a/clippy_lints/src/indexing_slicing.rs
+++ b/clippy_lints/src/indexing_slicing.rs
@@ -191,18 +191,14 @@ impl<'tcx> LateLintPass<'tcx> for IndexingSlicing {
 /// Returns a tuple of options with the start and end (exclusive) values of
 /// the range. If the start or end is not constant, None is returned.
 fn to_const_range(cx: &LateContext<'_>, range: higher::Range<'_>, array_size: u128) -> (Option<u128>, Option<u128>) {
-    let s = range
-        .start
-        .map(|expr| constant(cx, cx.typeck_results(), expr).map(|(c, _)| c));
+    let s = range.start.map(|expr| constant(cx, cx.typeck_results(), expr));
     let start = match s {
         Some(Some(Constant::Int(x))) => Some(x),
         Some(_) => None,
         None => Some(0),
     };
 
-    let e = range
-        .end
-        .map(|expr| constant(cx, cx.typeck_results(), expr).map(|(c, _)| c));
+    let e = range.end.map(|expr| constant(cx, cx.typeck_results(), expr));
     let end = match e {
         Some(Some(Constant::Int(x))) => {
             if range.limits == RangeLimits::Closed {
diff --git a/clippy_lints/src/manual_strip.rs b/clippy_lints/src/manual_strip.rs
index 7d28c111624..93d977a5c96 100644
--- a/clippy_lints/src/manual_strip.rs
+++ b/clippy_lints/src/manual_strip.rs
@@ -144,7 +144,7 @@ fn len_arg<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<&'tcx E
 
 // Returns the length of the `expr` if it's a constant string or char.
 fn constant_length(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<u128> {
-    let (value, _) = constant(cx, cx.typeck_results(), expr)?;
+    let value = constant(cx, cx.typeck_results(), expr)?;
     match value {
         Constant::Str(value) => Some(value.len() as u128),
         Constant::Char(value) => Some(value.len_utf8() as u128),
diff --git a/clippy_lints/src/matches/overlapping_arms.rs b/clippy_lints/src/matches/overlapping_arms.rs
index ae69ca8a339..abf2525a61c 100644
--- a/clippy_lints/src/matches/overlapping_arms.rs
+++ b/clippy_lints/src/matches/overlapping_arms.rs
@@ -34,7 +34,7 @@ fn all_ranges<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>], ty: Ty<'tcx>)
             if let Arm { pat, guard: None, .. } = *arm {
                 if let PatKind::Range(ref lhs, ref rhs, range_end) = pat.kind {
                     let lhs_const = match lhs {
-                        Some(lhs) => constant(cx, cx.typeck_results(), lhs)?.0,
+                        Some(lhs) => constant(cx, cx.typeck_results(), lhs)?,
                         None => {
                             let min_val_const = ty.numeric_min_val(cx.tcx)?;
                             let min_constant = mir::ConstantKind::from_value(
@@ -45,7 +45,7 @@ fn all_ranges<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>], ty: Ty<'tcx>)
                         },
                     };
                     let rhs_const = match rhs {
-                        Some(rhs) => constant(cx, cx.typeck_results(), rhs)?.0,
+                        Some(rhs) => constant(cx, cx.typeck_results(), rhs)?,
                         None => {
                             let max_val_const = ty.numeric_max_val(cx.tcx)?;
                             let max_constant = mir::ConstantKind::from_value(
diff --git a/clippy_lints/src/methods/iter_nth_zero.rs b/clippy_lints/src/methods/iter_nth_zero.rs
index c830958d5c8..d1609eebfdc 100644
--- a/clippy_lints/src/methods/iter_nth_zero.rs
+++ b/clippy_lints/src/methods/iter_nth_zero.rs
@@ -13,7 +13,7 @@ use super::ITER_NTH_ZERO;
 pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr<'_>, arg: &hir::Expr<'_>) {
     if_chain! {
         if is_trait_method(cx, expr, sym::Iterator);
-        if let Some((Constant::Int(0), _)) = constant(cx, cx.typeck_results(), arg);
+        if let Some(Constant::Int(0)) = constant(cx, cx.typeck_results(), arg);
         then {
             let mut applicability = Applicability::MachineApplicable;
             span_lint_and_sugg(
diff --git a/clippy_lints/src/methods/iterator_step_by_zero.rs b/clippy_lints/src/methods/iterator_step_by_zero.rs
index 64c09214a76..b631cd00cda 100644
--- a/clippy_lints/src/methods/iterator_step_by_zero.rs
+++ b/clippy_lints/src/methods/iterator_step_by_zero.rs
@@ -9,7 +9,7 @@ use super::ITERATOR_STEP_BY_ZERO;
 
 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &hir::Expr<'_>, arg: &'tcx hir::Expr<'_>) {
     if is_trait_method(cx, expr, sym::Iterator) {
-        if let Some((Constant::Int(0), _)) = constant(cx, cx.typeck_results(), arg) {
+        if let Some(Constant::Int(0)) = constant(cx, cx.typeck_results(), arg) {
             span_lint(
                 cx,
                 ITERATOR_STEP_BY_ZERO,
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 02d4a9aa08f..9a594d964ab 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3770,13 +3770,13 @@ impl Methods {
                     unnecessary_sort_by::check(cx, expr, recv, arg, true);
                 },
                 ("splitn" | "rsplitn", [count_arg, pat_arg]) => {
-                    if let Some((Constant::Int(count), _)) = constant(cx, cx.typeck_results(), count_arg) {
+                    if let Some(Constant::Int(count)) = constant(cx, cx.typeck_results(), count_arg) {
                         suspicious_splitn::check(cx, name, expr, recv, count);
                         str_splitn::check(cx, name, expr, recv, pat_arg, count, &self.msrv);
                     }
                 },
                 ("splitn_mut" | "rsplitn_mut", [count_arg, _]) => {
-                    if let Some((Constant::Int(count), _)) = constant(cx, cx.typeck_results(), count_arg) {
+                    if let Some(Constant::Int(count)) = constant(cx, cx.typeck_results(), count_arg) {
                         suspicious_splitn::check(cx, name, expr, recv, count);
                     }
                 },
diff --git a/clippy_lints/src/methods/repeat_once.rs b/clippy_lints/src/methods/repeat_once.rs
index a345ec813ff..bb4cdd2a6fa 100644
--- a/clippy_lints/src/methods/repeat_once.rs
+++ b/clippy_lints/src/methods/repeat_once.rs
@@ -1,4 +1,4 @@
-use clippy_utils::consts::{constant_context, Constant};
+use clippy_utils::consts::{constant, Constant};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::is_type_lang_item;
@@ -14,7 +14,7 @@ pub(super) fn check<'tcx>(
     recv: &'tcx Expr<'_>,
     repeat_arg: &'tcx Expr<'_>,
 ) {
-    if constant_context(cx, cx.typeck_results()).expr(repeat_arg) == Some(Constant::Int(1)) {
+    if constant(cx, cx.typeck_results(), repeat_arg) == Some(Constant::Int(1)) {
         let ty = cx.typeck_results().expr_ty(recv).peel_refs();
         if ty.is_str() {
             span_lint_and_sugg(
diff --git a/clippy_lints/src/methods/str_splitn.rs b/clippy_lints/src/methods/str_splitn.rs
index 91f7ce1dbe5..5ea12c44184 100644
--- a/clippy_lints/src/methods/str_splitn.rs
+++ b/clippy_lints/src/methods/str_splitn.rs
@@ -316,7 +316,7 @@ fn parse_iter_usage<'tcx>(
                     };
                 },
                 ("nth" | "skip", [idx_expr]) if cx.tcx.trait_of_item(did) == Some(iter_id) => {
-                    if let Some((Constant::Int(idx), _)) = constant(cx, cx.typeck_results(), idx_expr) {
+                    if let Some(Constant::Int(idx)) = constant(cx, cx.typeck_results(), idx_expr) {
                         let span = if name.ident.as_str() == "nth" {
                             e.span
                         } else {
diff --git a/clippy_lints/src/operators/absurd_extreme_comparisons.rs b/clippy_lints/src/operators/absurd_extreme_comparisons.rs
index d29ca37eaeb..f4863600ccc 100644
--- a/clippy_lints/src/operators/absurd_extreme_comparisons.rs
+++ b/clippy_lints/src/operators/absurd_extreme_comparisons.rs
@@ -121,7 +121,7 @@ fn detect_absurd_comparison<'tcx>(
 fn detect_extreme_expr<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<ExtremeExpr<'tcx>> {
     let ty = cx.typeck_results().expr_ty(expr);
 
-    let cv = constant(cx, cx.typeck_results(), expr)?.0;
+    let cv = constant(cx, cx.typeck_results(), expr)?;
 
     let which = match (ty.kind(), cv) {
         (&ty::Bool, Constant::Bool(false)) | (&ty::Uint(_), Constant::Int(0)) => ExtremeType::Minimum,
diff --git a/clippy_lints/src/operators/arithmetic_side_effects.rs b/clippy_lints/src/operators/arithmetic_side_effects.rs
index c80e2ff7057..5c240276b76 100644
--- a/clippy_lints/src/operators/arithmetic_side_effects.rs
+++ b/clippy_lints/src/operators/arithmetic_side_effects.rs
@@ -113,7 +113,7 @@ impl ArithmeticSideEffects {
         if let hir::ExprKind::Lit(lit) = actual.kind && let ast::LitKind::Int(n, _) = lit.node {
             return Some(n)
         }
-        if let Some((Constant::Int(n), _)) = constant(cx, cx.typeck_results(), expr) {
+        if let Some(Constant::Int(n)) = constant(cx, cx.typeck_results(), expr) {
             return Some(n);
         }
         None
diff --git a/clippy_lints/src/operators/bit_mask.rs b/clippy_lints/src/operators/bit_mask.rs
index 1369b3e7462..1fddf0f50e3 100644
--- a/clippy_lints/src/operators/bit_mask.rs
+++ b/clippy_lints/src/operators/bit_mask.rs
@@ -166,7 +166,7 @@ fn check_ineffective_gt(cx: &LateContext<'_>, span: Span, m: u128, c: u128, op:
 }
 
 fn fetch_int_literal(cx: &LateContext<'_>, lit: &Expr<'_>) -> Option<u128> {
-    match constant(cx, cx.typeck_results(), lit)?.0 {
+    match constant(cx, cx.typeck_results(), lit)? {
         Constant::Int(n) => Some(n),
         _ => None,
     }
diff --git a/clippy_lints/src/operators/cmp_nan.rs b/clippy_lints/src/operators/cmp_nan.rs
index 786ae1552ad..e18064b7061 100644
--- a/clippy_lints/src/operators/cmp_nan.rs
+++ b/clippy_lints/src/operators/cmp_nan.rs
@@ -18,7 +18,7 @@ pub(super) fn check(cx: &LateContext<'_>, e: &Expr<'_>, op: BinOpKind, lhs: &Exp
 }
 
 fn is_nan(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
-    if let Some((value, _)) = constant(cx, cx.typeck_results(), e) {
+    if let Some(value) = constant(cx, cx.typeck_results(), e) {
         match value {
             Constant::F32(num) => num.is_nan(),
             Constant::F64(num) => num.is_nan(),
diff --git a/clippy_lints/src/operators/duration_subsec.rs b/clippy_lints/src/operators/duration_subsec.rs
index 49e662cacb0..f120be13836 100644
--- a/clippy_lints/src/operators/duration_subsec.rs
+++ b/clippy_lints/src/operators/duration_subsec.rs
@@ -19,7 +19,7 @@ pub(crate) fn check<'tcx>(
     if op == BinOpKind::Div
         && let ExprKind::MethodCall(method_path, self_arg, [], _) = left.kind
         && is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(self_arg).peel_refs(), sym::Duration)
-        && let Some((Constant::Int(divisor), _)) = constant(cx, cx.typeck_results(), right)
+        && let Some(Constant::Int(divisor)) = constant(cx, cx.typeck_results(), right)
     {
         let suggested_fn = match (method_path.ident.as_str(), divisor) {
             ("subsec_micros", 1_000) | ("subsec_nanos", 1_000_000) => "subsec_millis",
diff --git a/clippy_lints/src/operators/float_cmp.rs b/clippy_lints/src/operators/float_cmp.rs
index 97ddcdb2479..15dff126be7 100644
--- a/clippy_lints/src/operators/float_cmp.rs
+++ b/clippy_lints/src/operators/float_cmp.rs
@@ -1,4 +1,4 @@
-use clippy_utils::consts::{constant, Constant};
+use clippy_utils::consts::{constant_with_source, Constant};
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::get_item_name;
 use clippy_utils::sugg::Sugg;
@@ -18,9 +18,16 @@ pub(crate) fn check<'tcx>(
     right: &'tcx Expr<'_>,
 ) {
     if (op == BinOpKind::Eq || op == BinOpKind::Ne) && (is_float(cx, left) || is_float(cx, right)) {
-        if is_allowed(cx, left) || is_allowed(cx, right) {
-            return;
-        }
+        let left_is_local = match constant_with_source(cx, cx.typeck_results(), left) {
+            Some((c, s)) if !is_allowed(&c) => s.is_local(),
+            Some(_) => return,
+            None => true,
+        };
+        let right_is_local = match constant_with_source(cx, cx.typeck_results(), right) {
+            Some((c, s)) if !is_allowed(&c) => s.is_local(),
+            Some(_) => return,
+            None => true,
+        };
 
         // Allow comparing the results of signum()
         if is_signum(cx, left) && is_signum(cx, right) {
@@ -34,10 +41,7 @@ pub(crate) fn check<'tcx>(
             }
         }
         let is_comparing_arrays = is_array(cx, left) || is_array(cx, right);
-        let (lint, msg) = get_lint_and_message(
-            is_named_constant(cx, left) || is_named_constant(cx, right),
-            is_comparing_arrays,
-        );
+        let (lint, msg) = get_lint_and_message(left_is_local && right_is_local, is_comparing_arrays);
         span_lint_and_then(cx, lint, expr.span, msg, |diag| {
             let lhs = Sugg::hir(cx, left, "..");
             let rhs = Sugg::hir(cx, right, "..");
@@ -59,44 +63,33 @@ pub(crate) fn check<'tcx>(
     }
 }
 
-fn get_lint_and_message(
-    is_comparing_constants: bool,
-    is_comparing_arrays: bool,
-) -> (&'static rustc_lint::Lint, &'static str) {
-    if is_comparing_constants {
+fn get_lint_and_message(is_local: bool, is_comparing_arrays: bool) -> (&'static rustc_lint::Lint, &'static str) {
+    if is_local {
         (
-            FLOAT_CMP_CONST,
+            FLOAT_CMP,
             if is_comparing_arrays {
-                "strict comparison of `f32` or `f64` constant arrays"
+                "strict comparison of `f32` or `f64` arrays"
             } else {
-                "strict comparison of `f32` or `f64` constant"
+                "strict comparison of `f32` or `f64`"
             },
         )
     } else {
         (
-            FLOAT_CMP,
+            FLOAT_CMP_CONST,
             if is_comparing_arrays {
-                "strict comparison of `f32` or `f64` arrays"
+                "strict comparison of `f32` or `f64` constant arrays"
             } else {
-                "strict comparison of `f32` or `f64`"
+                "strict comparison of `f32` or `f64` constant"
             },
         )
     }
 }
 
-fn is_named_constant<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> bool {
-    if let Some((_, res)) = constant(cx, cx.typeck_results(), expr) {
-        res
-    } else {
-        false
-    }
-}
-
-fn is_allowed<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> bool {
-    match constant(cx, cx.typeck_results(), expr) {
-        Some((Constant::F32(f), _)) => f == 0.0 || f.is_infinite(),
-        Some((Constant::F64(f), _)) => f == 0.0 || f.is_infinite(),
-        Some((Constant::Vec(vec), _)) => vec.iter().all(|f| match f {
+fn is_allowed(val: &Constant) -> bool {
+    match val {
+        &Constant::F32(f) => f == 0.0 || f.is_infinite(),
+        &Constant::F64(f) => f == 0.0 || f.is_infinite(),
+        Constant::Vec(vec) => vec.iter().all(|f| match f {
             Constant::F32(f) => *f == 0.0 || (*f).is_infinite(),
             Constant::F64(f) => *f == 0.0 || (*f).is_infinite(),
             _ => false,
diff --git a/clippy_lints/src/operators/modulo_arithmetic.rs b/clippy_lints/src/operators/modulo_arithmetic.rs
index af4e74947f4..a2c3a4d8ba7 100644
--- a/clippy_lints/src/operators/modulo_arithmetic.rs
+++ b/clippy_lints/src/operators/modulo_arithmetic.rs
@@ -40,7 +40,7 @@ struct OperandInfo {
 
 fn analyze_operand(operand: &Expr<'_>, cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<OperandInfo> {
     match constant(cx, cx.typeck_results(), operand) {
-        Some((Constant::Int(v), _)) => match *cx.typeck_results().expr_ty(expr).kind() {
+        Some(Constant::Int(v)) => match *cx.typeck_results().expr_ty(expr).kind() {
             ty::Int(ity) => {
                 let value = sext(cx.tcx, v, ity);
                 return Some(OperandInfo {
@@ -58,10 +58,10 @@ fn analyze_operand(operand: &Expr<'_>, cx: &LateContext<'_>, expr: &Expr<'_>) ->
             },
             _ => {},
         },
-        Some((Constant::F32(f), _)) => {
+        Some(Constant::F32(f)) => {
             return Some(floating_point_operand_info(&f));
         },
-        Some((Constant::F64(f), _)) => {
+        Some(Constant::F64(f)) => {
             return Some(floating_point_operand_info(&f));
         },
         _ => {},
diff --git a/clippy_lints/src/ranges.rs b/clippy_lints/src/ranges.rs
index fc655fe2d0b..dd7ded491e7 100644
--- a/clippy_lints/src/ranges.rs
+++ b/clippy_lints/src/ranges.rs
@@ -319,7 +319,7 @@ fn check_range_bounds<'a>(cx: &'a LateContext<'_>, ex: &'a Expr<'_>) -> Option<R
             _ => return None,
         };
         if let Some(id) = path_to_local(l) {
-            if let Some((c, _)) = constant(cx, cx.typeck_results(), r) {
+            if let Some(c) = constant(cx, cx.typeck_results(), r) {
                 return Some(RangeBounds {
                     val: c,
                     expr: r,
@@ -331,7 +331,7 @@ fn check_range_bounds<'a>(cx: &'a LateContext<'_>, ex: &'a Expr<'_>) -> Option<R
                 });
             }
         } else if let Some(id) = path_to_local(r) {
-            if let Some((c, _)) = constant(cx, cx.typeck_results(), l) {
+            if let Some(c) = constant(cx, cx.typeck_results(), l) {
                 return Some(RangeBounds {
                     val: c,
                     expr: l,
@@ -451,8 +451,8 @@ fn check_reversed_empty_range(cx: &LateContext<'_>, expr: &Expr<'_>) {
         if let Some(higher::Range { start: Some(start), end: Some(end), limits }) = higher::Range::hir(expr);
         let ty = cx.typeck_results().expr_ty(start);
         if let ty::Int(_) | ty::Uint(_) = ty.kind();
-        if let Some((start_idx, _)) = constant(cx, cx.typeck_results(), start);
-        if let Some((end_idx, _)) = constant(cx, cx.typeck_results(), end);
+        if let Some(start_idx) = constant(cx, cx.typeck_results(), start);
+        if let Some(end_idx) = constant(cx, cx.typeck_results(), end);
         if let Some(ordering) = Constant::partial_cmp(cx.tcx, ty, &start_idx, &end_idx);
         if is_empty_range(limits, ordering);
         then {
diff --git a/clippy_lints/src/regex.rs b/clippy_lints/src/regex.rs
index fe5be248700..ef19c6f4617 100644
--- a/clippy_lints/src/regex.rs
+++ b/clippy_lints/src/regex.rs
@@ -122,7 +122,7 @@ fn lint_syntax_error(cx: &LateContext<'_>, error: &regex_syntax::Error, unescape
 }
 
 fn const_str<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> Option<String> {
-    constant(cx, cx.typeck_results(), e).and_then(|(c, _)| match c {
+    constant(cx, cx.typeck_results(), e).and_then(|c| match c {
         Constant::Str(s) => Some(s),
         _ => None,
     })
diff --git a/clippy_lints/src/transmute/transmute_null_to_fn.rs b/clippy_lints/src/transmute/transmute_null_to_fn.rs
index e75d7f6bf1d..4944381da24 100644
--- a/clippy_lints/src/transmute/transmute_null_to_fn.rs
+++ b/clippy_lints/src/transmute/transmute_null_to_fn.rs
@@ -31,9 +31,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, arg: &'t
     match arg.kind {
         // Catching:
         // transmute over constants that resolve to `null`.
-        ExprKind::Path(ref _qpath)
-            if matches!(constant(cx, cx.typeck_results(), arg), Some((Constant::RawPtr(0), _))) =>
-        {
+        ExprKind::Path(ref _qpath) if matches!(constant(cx, cx.typeck_results(), arg), Some(Constant::RawPtr(0))) => {
             lint_expr(cx, expr);
             true
         },
diff --git a/clippy_lints/src/transmute/transmuting_null.rs b/clippy_lints/src/transmute/transmuting_null.rs
index 1e407fc4138..770914e99e1 100644
--- a/clippy_lints/src/transmute/transmuting_null.rs
+++ b/clippy_lints/src/transmute/transmuting_null.rs
@@ -1,4 +1,4 @@
-use clippy_utils::consts::{constant_context, Constant};
+use clippy_utils::consts::{constant, Constant};
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::{is_integer_literal, is_path_diagnostic_item};
 use rustc_hir::{Expr, ExprKind};
@@ -16,9 +16,8 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, arg: &'t
     }
 
     // Catching transmute over constants that resolve to `null`.
-    let mut const_eval_context = constant_context(cx, cx.typeck_results());
     if let ExprKind::Path(ref _qpath) = arg.kind &&
-        let Some(Constant::RawPtr(0)) = const_eval_context.expr(arg)
+        let Some(Constant::RawPtr(0)) = constant(cx, cx.typeck_results(), arg)
     {
         span_lint(cx, TRANSMUTING_NULL, expr.span, LINT_MSG);
         return true;
diff --git a/clippy_lints/src/vec.rs b/clippy_lints/src/vec.rs
index 297a80e5767..7329e508106 100644
--- a/clippy_lints/src/vec.rs
+++ b/clippy_lints/src/vec.rs
@@ -84,7 +84,7 @@ impl UselessVec {
         let mut applicability = Applicability::MachineApplicable;
         let snippet = match *vec_args {
             higher::VecArgs::Repeat(elem, len) => {
-                if let Some((Constant::Int(len_constant), _)) = constant(cx, cx.typeck_results(), len) {
+                if let Some(Constant::Int(len_constant)) = constant(cx, cx.typeck_results(), len) {
                     #[expect(clippy::cast_possible_truncation)]
                     if len_constant as u64 * size_of(cx, elem) > self.too_large_for_stack {
                         return;
diff --git a/clippy_utils/src/consts.rs b/clippy_utils/src/consts.rs
index b52caf6e405..34ca9b2d67e 100644
--- a/clippy_utils/src/consts.rs
+++ b/clippy_utils/src/consts.rs
@@ -1,18 +1,21 @@
 #![allow(clippy::float_cmp)]
 
+use crate::source::{span_source_range, walk_span_to_context};
 use crate::{clip, is_direct_expn_of, sext, unsext};
 use if_chain::if_chain;
 use rustc_ast::ast::{self, LitFloatType, LitKind};
 use rustc_data_structures::sync::Lrc;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::{BinOp, BinOpKind, Block, Expr, ExprKind, HirId, Item, ItemKind, Node, QPath, UnOp};
+use rustc_lexer::tokenize;
 use rustc_lint::LateContext;
 use rustc_middle::mir;
 use rustc_middle::mir::interpret::Scalar;
-use rustc_middle::ty::SubstsRef;
 use rustc_middle::ty::{self, EarlyBinder, FloatTy, ScalarInt, Ty, TyCtxt};
+use rustc_middle::ty::{List, SubstsRef};
 use rustc_middle::{bug, span_bug};
 use rustc_span::symbol::Symbol;
+use rustc_span::SyntaxContext;
 use std::cmp::Ordering::{self, Equal};
 use std::hash::{Hash, Hasher};
 use std::iter;
@@ -227,27 +230,46 @@ pub fn lit_to_mir_constant(lit: &LitKind, ty: Option<Ty<'_>>) -> Constant {
     }
 }
 
+/// The source of a constant value.
+pub enum ConstantSource {
+    /// The value is determined solely from the expression.
+    Local,
+    /// The value is dependent on a defined constant.
+    Constant,
+}
+impl ConstantSource {
+    pub fn is_local(&self) -> bool {
+        matches!(self, Self::Local)
+    }
+}
+
+/// Attempts to evaluate the expression as a constant.
 pub fn constant<'tcx>(
     lcx: &LateContext<'tcx>,
     typeck_results: &ty::TypeckResults<'tcx>,
     e: &Expr<'_>,
-) -> Option<(Constant, bool)> {
-    let mut cx = ConstEvalLateContext {
-        lcx,
-        typeck_results,
-        param_env: lcx.param_env,
-        needed_resolution: false,
-        substs: ty::List::empty(),
-    };
-    cx.expr(e).map(|cst| (cst, cx.needed_resolution))
+) -> Option<Constant> {
+    ConstEvalLateContext::new(lcx, typeck_results).expr(e)
+}
+
+/// Attempts to evaluate the expression as a constant.
+pub fn constant_with_source<'tcx>(
+    lcx: &LateContext<'tcx>,
+    typeck_results: &ty::TypeckResults<'tcx>,
+    e: &Expr<'_>,
+) -> Option<(Constant, ConstantSource)> {
+    let mut ctxt = ConstEvalLateContext::new(lcx, typeck_results);
+    let res = ctxt.expr(e);
+    res.map(|x| (x, ctxt.source))
 }
 
+/// Attempts to evaluate an expression only if it's value is not dependent on other items.
 pub fn constant_simple<'tcx>(
     lcx: &LateContext<'tcx>,
     typeck_results: &ty::TypeckResults<'tcx>,
     e: &Expr<'_>,
 ) -> Option<Constant> {
-    constant(lcx, typeck_results, e).and_then(|(cst, res)| if res { None } else { Some(cst) })
+    constant_with_source(lcx, typeck_results, e).and_then(|(c, s)| s.is_local().then_some(c))
 }
 
 pub fn constant_full_int<'tcx>(
@@ -296,29 +318,25 @@ impl Ord for FullInt {
     }
 }
 
-/// Creates a `ConstEvalLateContext` from the given `LateContext` and `TypeckResults`.
-pub fn constant_context<'a, 'tcx>(
-    lcx: &'a LateContext<'tcx>,
-    typeck_results: &'a ty::TypeckResults<'tcx>,
-) -> ConstEvalLateContext<'a, 'tcx> {
-    ConstEvalLateContext {
-        lcx,
-        typeck_results,
-        param_env: lcx.param_env,
-        needed_resolution: false,
-        substs: ty::List::empty(),
-    }
-}
-
 pub struct ConstEvalLateContext<'a, 'tcx> {
     lcx: &'a LateContext<'tcx>,
     typeck_results: &'a ty::TypeckResults<'tcx>,
     param_env: ty::ParamEnv<'tcx>,
-    needed_resolution: bool,
+    source: ConstantSource,
     substs: SubstsRef<'tcx>,
 }
 
 impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
+    fn new(lcx: &'a LateContext<'tcx>, typeck_results: &'a ty::TypeckResults<'tcx>) -> Self {
+        Self {
+            lcx,
+            typeck_results,
+            param_env: lcx.param_env,
+            source: ConstantSource::Local,
+            substs: List::empty(),
+        }
+    }
+
     /// Simple constant folding: Insert an expression, get a constant or none.
     pub fn expr(&mut self, e: &Expr<'_>) -> Option<Constant> {
         match e.kind {
@@ -453,11 +471,9 @@ impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
                     .const_eval_resolve(self.param_env, mir::UnevaluatedConst::new(def_id, substs), None)
                     .ok()
                     .map(|val| rustc_middle::mir::ConstantKind::from_value(val, ty))?;
-                let result = miri_to_const(self.lcx.tcx, result);
-                if result.is_some() {
-                    self.needed_resolution = true;
-                }
-                result
+                let result = miri_to_const(self.lcx.tcx, result)?;
+                self.source = ConstantSource::Constant;
+                Some(result)
             },
             // FIXME: cover all usable cases.
             _ => None,
@@ -491,8 +507,33 @@ impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
 
     /// A block can only yield a constant if it only has one constant expression.
     fn block(&mut self, block: &Block<'_>) -> Option<Constant> {
-        if block.stmts.is_empty() {
-            block.expr.as_ref().and_then(|b| self.expr(b))
+        if block.stmts.is_empty()
+            && let Some(expr) = block.expr
+        {
+            // Try to detect any `cfg`ed statements or empty macro expansions.
+            let span = block.span.data();
+            if span.ctxt == SyntaxContext::root() {
+                if let Some(expr_span) = walk_span_to_context(expr.span, span.ctxt)
+                    && let expr_lo = expr_span.lo()
+                    && expr_lo >= span.lo
+                    && let Some(src) = span_source_range(self.lcx, span.lo..expr_lo)
+                    && let Some(src) = src.as_str()
+                {
+                    use rustc_lexer::TokenKind::{Whitespace, LineComment, BlockComment, Semi, OpenBrace};
+                    if !tokenize(src)
+                        .map(|t| t.kind)
+                        .filter(|t| !matches!(t, Whitespace | LineComment { .. } | BlockComment { .. } | Semi))
+                        .eq([OpenBrace])
+                    {
+                        self.source = ConstantSource::Constant;
+                    }
+                } else {
+                    // Unable to access the source. Assume a non-local dependency.
+                    self.source = ConstantSource::Constant;
+                }
+            }
+
+            self.expr(expr)
         } else {
             None
         }
diff --git a/clippy_utils/src/hir_utils.rs b/clippy_utils/src/hir_utils.rs
index 3561e760ac9..2aec5a10e5d 100644
--- a/clippy_utils/src/hir_utils.rs
+++ b/clippy_utils/src/hir_utils.rs
@@ -151,6 +151,8 @@ impl HirEqInterExpr<'_, '_, '_> {
             if !self.eq_stmt(left, right) {
                 return false;
             }
+
+            // Try to detect any `cfg`ed statements or empty macro expansions.
             let Some(lstmt_span) = walk_span_to_context(left.span, lspan.ctxt) else {
                 return false;
             };
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 2ddd2ade6ae..c857595b844 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -1547,7 +1547,7 @@ pub fn is_integer_const(cx: &LateContext<'_>, e: &Expr<'_>, value: u128) -> bool
         return true;
     }
     let enclosing_body = cx.tcx.hir().enclosing_body_owner(e.hir_id);
-    if let Some((Constant::Int(v), _)) = constant(cx, cx.tcx.typeck(enclosing_body), e) {
+    if let Some(Constant::Int(v)) = constant(cx, cx.tcx.typeck(enclosing_body), e) {
         return value == v;
     }
     false
diff --git a/tests/ui/match_same_arms.rs b/tests/ui/match_same_arms.rs
index 15410734dec..26e2ca86758 100644
--- a/tests/ui/match_same_arms.rs
+++ b/tests/ui/match_same_arms.rs
@@ -72,6 +72,18 @@ fn main() {
         _ => 1,
     };
 
+    let _ = match 0 {
+        0 => {
+            m!(foo);
+            0
+        },
+        1 => {
+            m!(bar);
+            0
+        },
+        _ => 1,
+    };
+
     let _ = match 0 {
         0 => {
             let mut x = 0;
-- 
cgit 1.4.1-3-g733a5


From ab66a86815a2bb562edef92ef8c308b6958ea734 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Tue, 9 May 2023 11:51:36 +0200
Subject: Add new `UNIQUE_CFG_CONDITION` lint

---
 clippy_lints/src/attrs.rs          | 60 ++++++++++++++++++++++++++++++++++++++
 clippy_lints/src/declared_lints.rs |  1 +
 2 files changed, 61 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs
index 93d88391a79..6678002820a 100644
--- a/clippy_lints/src/attrs.rs
+++ b/clippy_lints/src/attrs.rs
@@ -338,6 +338,30 @@ declare_clippy_lint! {
     "ensures that all `allow` and `expect` attributes have a reason"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `any` and `all` combinators in `cfg` with only one condition.
+    ///
+    /// ### Why is this bad?
+    /// If there is only one condition, no need to wrap it into `any` or `all` combinators.
+    ///
+    /// ### Example
+    /// ```rust
+    /// #[cfg(any(unix))]
+    /// pub struct Bar;
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust
+    /// #[cfg(unix)]
+    /// pub struct Bar;
+    /// ```
+    #[clippy::version = "1.71.0"]
+    pub NON_MINIMAL_CFG,
+    style,
+    "ensure that all `cfg(any())` and `cfg(all())` have more than one condition"
+}
+
 declare_lint_pass!(Attributes => [
     ALLOW_ATTRIBUTES_WITHOUT_REASON,
     INLINE_ALWAYS,
@@ -651,6 +675,7 @@ impl_lint_pass!(EarlyAttributes => [
     MISMATCHED_TARGET_OS,
     EMPTY_LINE_AFTER_OUTER_ATTR,
     EMPTY_LINE_AFTER_DOC_COMMENTS,
+    NON_MINIMAL_CFG,
 ]);
 
 impl EarlyLintPass for EarlyAttributes {
@@ -661,6 +686,7 @@ impl EarlyLintPass for EarlyAttributes {
     fn check_attribute(&mut self, cx: &EarlyContext<'_>, attr: &Attribute) {
         check_deprecated_cfg_attr(cx, attr, &self.msrv);
         check_mismatched_target_os(cx, attr);
+        check_minimal_cfg_condition(cx, attr);
     }
 
     extract_msrv_attr!(EarlyContext);
@@ -750,6 +776,40 @@ fn check_deprecated_cfg_attr(cx: &EarlyContext<'_>, attr: &Attribute, msrv: &Msr
     }
 }
 
+fn check_nested_cfg(cx: &EarlyContext<'_>, items: &[NestedMetaItem]) {
+    for item in items.iter() {
+        if let NestedMetaItem::MetaItem(meta) = item {
+            if !meta.has_name(sym::any) && !meta.has_name(sym::all) {
+                continue;
+            }
+            if let MetaItemKind::List(list) = &meta.kind {
+                check_nested_cfg(cx, list);
+                if list.len() == 1 {
+                    span_lint_and_then(
+                        cx,
+                        NON_MINIMAL_CFG,
+                        meta.span,
+                        "unneeded sub `cfg` when there is only one condition",
+                        |diag| {
+                            if let Some(snippet) = snippet_opt(cx, list[0].span()) {
+                                diag.span_suggestion(meta.span, "try", snippet, Applicability::MaybeIncorrect);
+                            }
+                        },
+                    );
+                }
+            }
+        }
+    }
+}
+
+fn check_minimal_cfg_condition(cx: &EarlyContext<'_>, attr: &Attribute) {
+    if attr.has_name(sym::cfg) &&
+        let Some(items) = attr.meta_item_list()
+    {
+        check_nested_cfg(cx, &items);
+    }
+}
+
 fn check_mismatched_target_os(cx: &EarlyContext<'_>, attr: &Attribute) {
     fn find_os(name: &str) -> Option<&'static str> {
         UNIX_SYSTEMS
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 40c64efaa37..aee43edc478 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -52,6 +52,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::attrs::EMPTY_LINE_AFTER_OUTER_ATTR_INFO,
     crate::attrs::INLINE_ALWAYS_INFO,
     crate::attrs::MISMATCHED_TARGET_OS_INFO,
+    crate::attrs::NON_MINIMAL_CFG_INFO,
     crate::attrs::USELESS_ATTRIBUTE_INFO,
     crate::await_holding_invalid::AWAIT_HOLDING_INVALID_TYPE_INFO,
     crate::await_holding_invalid::AWAIT_HOLDING_LOCK_INFO,
-- 
cgit 1.4.1-3-g733a5


From dbc76a766333bf510de601111f31e3eb42fb0434 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Fri, 19 May 2023 16:23:17 +0200
Subject: Add check for empty cfg `all` condition

---
 clippy_lints/src/attrs.rs        |  8 ++++++++
 tests/ui/non_minimal_cfg.fixed   |  3 +++
 tests/ui/non_minimal_cfg.rs      |  3 +++
 tests/ui/non_minimal_cfg2.rs     |  6 ++++++
 tests/ui/non_minimal_cfg2.stderr | 10 ++++++++++
 5 files changed, 30 insertions(+)
 create mode 100644 tests/ui/non_minimal_cfg2.rs
 create mode 100644 tests/ui/non_minimal_cfg2.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs
index 6678002820a..897495ba108 100644
--- a/clippy_lints/src/attrs.rs
+++ b/clippy_lints/src/attrs.rs
@@ -796,6 +796,14 @@ fn check_nested_cfg(cx: &EarlyContext<'_>, items: &[NestedMetaItem]) {
                             }
                         },
                     );
+                } else if list.is_empty() && meta.has_name(sym::all) {
+                    span_lint_and_then(
+                        cx,
+                        NON_MINIMAL_CFG,
+                        meta.span,
+                        "unneeded sub `cfg` when there is no condition",
+                        |_| {},
+                    );
                 }
             }
         }
diff --git a/tests/ui/non_minimal_cfg.fixed b/tests/ui/non_minimal_cfg.fixed
index ca9a48a3e37..430caafb33e 100644
--- a/tests/ui/non_minimal_cfg.fixed
+++ b/tests/ui/non_minimal_cfg.fixed
@@ -11,4 +11,7 @@ fn wasi() {}
 #[cfg(all(unix, not(windows)))]
 fn the_end() {}
 
+#[cfg(any())]
+fn any() {}
+
 fn main() {}
diff --git a/tests/ui/non_minimal_cfg.rs b/tests/ui/non_minimal_cfg.rs
index bf322236fef..a38ce1c21d6 100644
--- a/tests/ui/non_minimal_cfg.rs
+++ b/tests/ui/non_minimal_cfg.rs
@@ -11,4 +11,7 @@ fn wasi() {}
 #[cfg(all(any(unix), all(not(windows))))]
 fn the_end() {}
 
+#[cfg(any())]
+fn any() {}
+
 fn main() {}
diff --git a/tests/ui/non_minimal_cfg2.rs b/tests/ui/non_minimal_cfg2.rs
new file mode 100644
index 00000000000..a4c6abce387
--- /dev/null
+++ b/tests/ui/non_minimal_cfg2.rs
@@ -0,0 +1,6 @@
+#![allow(unused)]
+
+#[cfg(all())]
+fn all() {}
+
+fn main() {}
diff --git a/tests/ui/non_minimal_cfg2.stderr b/tests/ui/non_minimal_cfg2.stderr
new file mode 100644
index 00000000000..2a9a36fbcef
--- /dev/null
+++ b/tests/ui/non_minimal_cfg2.stderr
@@ -0,0 +1,10 @@
+error: unneeded sub `cfg` when there is no condition
+  --> $DIR/non_minimal_cfg2.rs:3:7
+   |
+LL | #[cfg(all())]
+   |       ^^^^^
+   |
+   = note: `-D clippy::non-minimal-cfg` implied by `-D warnings`
+
+error: aborting due to previous error
+
-- 
cgit 1.4.1-3-g733a5


From 191a901a8d29d292aa20b1161e703f76a4690595 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Sun, 21 May 2023 15:02:51 +0200
Subject: consider array initializer for `large_stack_arrays`

---
 clippy_lints/src/large_stack_arrays.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/large_stack_arrays.rs b/clippy_lints/src/large_stack_arrays.rs
index 32c6312e069..0a5901bce04 100644
--- a/clippy_lints/src/large_stack_arrays.rs
+++ b/clippy_lints/src/large_stack_arrays.rs
@@ -38,7 +38,7 @@ impl_lint_pass!(LargeStackArrays => [LARGE_STACK_ARRAYS]);
 
 impl<'tcx> LateLintPass<'tcx> for LargeStackArrays {
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
-        if let ExprKind::Repeat(_, _) = expr.kind
+        if let ExprKind::Repeat(_, _) | ExprKind::Array(_) = expr.kind
           && let ty::Array(element_type, cst) = cx.typeck_results().expr_ty(expr).kind()
           && let ConstKind::Value(ty::ValTree::Leaf(element_count)) = cst.kind()
           && let Ok(element_count) = element_count.try_to_target_usize(cx.tcx)
-- 
cgit 1.4.1-3-g733a5


From 1e73a9eb4be45092fdd5b76cc50db00970c852f7 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Sun, 21 May 2023 23:07:30 +0200
Subject: do not consider `await` in nested `async` blocks

---
 clippy_lints/src/unused_async.rs | 48 ++++++++++++++++++++++++++++++++++++----
 tests/ui/unused_async.rs         | 20 +++++++++++++++++
 tests/ui/unused_async.stderr     | 21 ++++++++++++++----
 3 files changed, 81 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unused_async.rs b/clippy_lints/src/unused_async.rs
index 55651a28be9..c1339d94637 100644
--- a/clippy_lints/src/unused_async.rs
+++ b/clippy_lints/src/unused_async.rs
@@ -1,5 +1,5 @@
-use clippy_utils::diagnostics::span_lint_and_help;
-use rustc_hir::intravisit::{walk_expr, walk_fn, FnKind, Visitor};
+use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_then};
+use rustc_hir::intravisit::{walk_body, walk_expr, walk_fn, FnKind, Visitor};
 use rustc_hir::{Body, Expr, ExprKind, FnDecl, YieldSource};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::nested_filter;
@@ -42,6 +42,10 @@ declare_lint_pass!(UnusedAsync => [UNUSED_ASYNC]);
 struct AsyncFnVisitor<'a, 'tcx> {
     cx: &'a LateContext<'tcx>,
     found_await: bool,
+    /// Also keep track of `await`s in nested async blocks so we can mention
+    /// it in a note
+    found_await_in_async_block: bool,
+    async_depth: usize,
 }
 
 impl<'a, 'tcx> Visitor<'tcx> for AsyncFnVisitor<'a, 'tcx> {
@@ -49,7 +53,11 @@ impl<'a, 'tcx> Visitor<'tcx> for AsyncFnVisitor<'a, 'tcx> {
 
     fn visit_expr(&mut self, ex: &'tcx Expr<'tcx>) {
         if let ExprKind::Yield(_, YieldSource::Await { .. }) = ex.kind {
-            self.found_await = true;
+            if self.async_depth == 1 {
+                self.found_await = true;
+            } else {
+                self.found_await_in_async_block = true;
+            }
         }
         walk_expr(self, ex);
     }
@@ -57,6 +65,20 @@ impl<'a, 'tcx> Visitor<'tcx> for AsyncFnVisitor<'a, 'tcx> {
     fn nested_visit_map(&mut self) -> Self::Map {
         self.cx.tcx.hir()
     }
+
+    fn visit_body(&mut self, b: &'tcx Body<'tcx>) {
+        let is_async_block = matches!(b.generator_kind, Some(rustc_hir::GeneratorKind::Async(_)));
+
+        if is_async_block {
+            self.async_depth += 1;
+        }
+
+        walk_body(self, b);
+
+        if is_async_block {
+            self.async_depth -= 1;
+        }
+    }
 }
 
 impl<'tcx> LateLintPass<'tcx> for UnusedAsync {
@@ -70,9 +92,27 @@ impl<'tcx> LateLintPass<'tcx> for UnusedAsync {
         def_id: LocalDefId,
     ) {
         if !span.from_expansion() && fn_kind.asyncness().is_async() {
-            let mut visitor = AsyncFnVisitor { cx, found_await: false };
+            let mut visitor = AsyncFnVisitor {
+                cx,
+                found_await: false,
+                async_depth: 0,
+                found_await_in_async_block: false,
+            };
             walk_fn(&mut visitor, fn_kind, fn_decl, body.id(), def_id);
             if !visitor.found_await {
+                span_lint_and_then(
+                    cx,
+                    UNUSED_ASYNC,
+                    span,
+                    "unused `async` for function with no await statements",
+                    |diag| {
+                        diag.help("consider removing the `async` from this function");
+
+                        if visitor.found_await_in_async_block {
+                            diag.note("`await` used in an async block, which does not require the enclosing function to be `async`");
+                        }
+                    },
+                );
                 span_lint_and_help(
                     cx,
                     UNUSED_ASYNC,
diff --git a/tests/ui/unused_async.rs b/tests/ui/unused_async.rs
index 4ca7f29b34c..bfaa5dadfa5 100644
--- a/tests/ui/unused_async.rs
+++ b/tests/ui/unused_async.rs
@@ -3,6 +3,26 @@
 use std::future::Future;
 use std::pin::Pin;
 
+mod issue10800 {
+    #![allow(dead_code, unused_must_use, clippy::no_effect)]
+
+    use std::future::ready;
+
+    async fn async_block_await() {
+        async {
+            ready(()).await;
+        };
+    }
+
+    async fn normal_block_await() {
+        {
+            {
+                ready(()).await;
+            }
+        }
+    }
+}
+
 async fn foo() -> i32 {
     4
 }
diff --git a/tests/ui/unused_async.stderr b/tests/ui/unused_async.stderr
index cff3eccbd32..e39f9b20b88 100644
--- a/tests/ui/unused_async.stderr
+++ b/tests/ui/unused_async.stderr
@@ -1,5 +1,19 @@
 error: unused `async` for function with no await statements
-  --> $DIR/unused_async.rs:6:1
+  --> $DIR/unused_async.rs:11:5
+   |
+LL | /     async fn async_block_await() {
+LL | |         async {
+LL | |             ready(()).await;
+LL | |         };
+LL | |     }
+   | |_____^
+   |
+   = help: consider removing the `async` from this function
+   = note: `await` used in an async block, which does not require the enclosing function to be `async`
+   = note: `-D clippy::unused-async` implied by `-D warnings`
+
+error: unused `async` for function with no await statements
+  --> $DIR/unused_async.rs:26:1
    |
 LL | / async fn foo() -> i32 {
 LL | |     4
@@ -7,10 +21,9 @@ LL | | }
    | |_^
    |
    = help: consider removing the `async` from this function
-   = note: `-D clippy::unused-async` implied by `-D warnings`
 
 error: unused `async` for function with no await statements
-  --> $DIR/unused_async.rs:17:5
+  --> $DIR/unused_async.rs:37:5
    |
 LL | /     async fn unused(&self) -> i32 {
 LL | |         1
@@ -19,5 +32,5 @@ LL | |     }
    |
    = help: consider removing the `async` from this function
 
-error: aborting due to 2 previous errors
+error: aborting due to 3 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 3eeeaa2bc7bff6b9f11dfe99889a4627904de221 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Mon, 22 May 2023 00:01:40 +0200
Subject: remove old span_lint

---
 clippy_lints/src/unused_async.rs | 10 +---------
 1 file changed, 1 insertion(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unused_async.rs b/clippy_lints/src/unused_async.rs
index c1339d94637..4c68cda7aa7 100644
--- a/clippy_lints/src/unused_async.rs
+++ b/clippy_lints/src/unused_async.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_then};
+use clippy_utils::diagnostics::span_lint_and_then;
 use rustc_hir::intravisit::{walk_body, walk_expr, walk_fn, FnKind, Visitor};
 use rustc_hir::{Body, Expr, ExprKind, FnDecl, YieldSource};
 use rustc_lint::{LateContext, LateLintPass};
@@ -113,14 +113,6 @@ impl<'tcx> LateLintPass<'tcx> for UnusedAsync {
                         }
                     },
                 );
-                span_lint_and_help(
-                    cx,
-                    UNUSED_ASYNC,
-                    span,
-                    "unused `async` for function with no await statements",
-                    None,
-                    "consider removing the `async` from this function",
-                );
             }
         }
     }
-- 
cgit 1.4.1-3-g733a5


From e6646eb5fd180d94606f7e5a31f1168db6511dc3 Mon Sep 17 00:00:00 2001
From: "Samuel \"Sam\" Tardieu" <sam@rfc1149.net>
Date: Mon, 22 May 2023 09:38:16 +0200
Subject: needless_else: new lint to check for empty else clauses

---
 CHANGELOG.md                                       |   1 +
 clippy_lints/src/declared_lints.rs                 |   1 +
 clippy_lints/src/lib.rs                            |   2 +
 clippy_lints/src/needless_else.rs                  |  57 +++++++++++
 tests/ui-toml/ifs_same_cond/ifs_same_cond.rs       |   2 +-
 tests/ui/branches_sharing_code/valid_if_blocks.rs  |   6 +-
 .../branches_sharing_code/valid_if_blocks.stderr   |  20 ++--
 tests/ui/crashes/ice-7410.rs                       |   1 +
 tests/ui/ifs_same_cond.rs                          |   2 +-
 tests/ui/needless_else.fixed                       |  40 ++++++++
 tests/ui/needless_else.rs                          |  41 ++++++++
 tests/ui/needless_else.stderr                      |  12 +++
 tests/ui/needless_return.fixed                     |   3 +-
 tests/ui/needless_return.rs                        |   3 +-
 tests/ui/needless_return.stderr                    | 104 ++++++++++-----------
 .../ui/redundant_pattern_matching_drop_order.fixed |   2 +-
 tests/ui/redundant_pattern_matching_drop_order.rs  |   2 +-
 tests/ui/suspicious_else_formatting.rs             |   2 +-
 18 files changed, 231 insertions(+), 70 deletions(-)
 create mode 100644 clippy_lints/src/needless_else.rs
 create mode 100644 tests/ui/needless_else.fixed
 create mode 100644 tests/ui/needless_else.rs
 create mode 100644 tests/ui/needless_else.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 79f2a47110b..3dfc4f7b6a4 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4874,6 +4874,7 @@ Released 2018-09-13
 [`needless_collect`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_collect
 [`needless_continue`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_continue
 [`needless_doctest_main`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_doctest_main
+[`needless_else`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_else
 [`needless_for_each`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_for_each
 [`needless_late_init`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_late_init
 [`needless_lifetimes`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_lifetimes
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 423eee47742..c225e376d14 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -449,6 +449,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::needless_bool::NEEDLESS_BOOL_ASSIGN_INFO,
     crate::needless_borrowed_ref::NEEDLESS_BORROWED_REFERENCE_INFO,
     crate::needless_continue::NEEDLESS_CONTINUE_INFO,
+    crate::needless_else::NEEDLESS_ELSE_INFO,
     crate::needless_for_each::NEEDLESS_FOR_EACH_INFO,
     crate::needless_late_init::NEEDLESS_LATE_INIT_INFO,
     crate::needless_parens_on_range_literals::NEEDLESS_PARENS_ON_RANGE_LITERALS_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index b442a4ac5f6..10404d51ba5 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -218,6 +218,7 @@ mod needless_arbitrary_self_type;
 mod needless_bool;
 mod needless_borrowed_ref;
 mod needless_continue;
+mod needless_else;
 mod needless_for_each;
 mod needless_late_init;
 mod needless_parens_on_range_literals;
@@ -992,6 +993,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(items_after_test_module::ItemsAfterTestModule));
     store.register_early_pass(|| Box::new(ref_patterns::RefPatterns));
     store.register_late_pass(|_| Box::new(default_constructed_unit_structs::DefaultConstructedUnitStructs));
+    store.register_early_pass(|| Box::new(needless_else::NeedlessElse));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/needless_else.rs b/clippy_lints/src/needless_else.rs
new file mode 100644
index 00000000000..8faf033e406
--- /dev/null
+++ b/clippy_lints/src/needless_else.rs
@@ -0,0 +1,57 @@
+use clippy_utils::{diagnostics::span_lint_and_sugg, source::trim_span, span_extract_comment};
+use rustc_ast::ast::{Expr, ExprKind};
+use rustc_errors::Applicability;
+use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for empty `else` branches.
+    ///
+    /// ### Why is this bad?
+    /// An empty else branch does nothing and can be removed.
+    ///
+    /// ### Example
+    /// ```rust
+    ///# fn check() -> bool { true }
+    /// if check() {
+    ///     println!("Check successful!");
+    /// } else {
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    ///# fn check() -> bool { true }
+    /// if check() {
+    ///     println!("Check successful!");
+    /// }
+    /// ```
+    #[clippy::version = "1.71.0"]
+    pub NEEDLESS_ELSE,
+    style,
+    "empty else branch"
+}
+declare_lint_pass!(NeedlessElse => [NEEDLESS_ELSE]);
+
+impl EarlyLintPass for NeedlessElse {
+    fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
+        if let ExprKind::If(_, then_block, Some(else_clause)) = &expr.kind &&
+            let ExprKind::Block(block, _) = &else_clause.kind &&
+            !expr.span.from_expansion() &&
+            !else_clause.span.from_expansion() &&
+            block.stmts.is_empty() {
+                let span = trim_span(cx.sess().source_map(), expr.span.trim_start(then_block.span).unwrap());
+                if span_extract_comment(cx.sess().source_map(), span).is_empty() {
+                    span_lint_and_sugg(
+                        cx,
+                        NEEDLESS_ELSE,
+                        span,
+                        "this else branch is empty",
+                        "you can remove it",
+                        String::new(),
+                        Applicability::MachineApplicable,
+                    );
+                }
+            }
+    }
+}
diff --git a/tests/ui-toml/ifs_same_cond/ifs_same_cond.rs b/tests/ui-toml/ifs_same_cond/ifs_same_cond.rs
index d623ac7e020..4882416c414 100644
--- a/tests/ui-toml/ifs_same_cond/ifs_same_cond.rs
+++ b/tests/ui-toml/ifs_same_cond/ifs_same_cond.rs
@@ -1,5 +1,5 @@
 #![warn(clippy::ifs_same_cond)]
-#![allow(clippy::if_same_then_else, clippy::comparison_chain)]
+#![allow(clippy::if_same_then_else, clippy::comparison_chain, clippy::needless_else)]
 
 fn main() {}
 
diff --git a/tests/ui/branches_sharing_code/valid_if_blocks.rs b/tests/ui/branches_sharing_code/valid_if_blocks.rs
index 2d6055eb6c4..5780ea08937 100644
--- a/tests/ui/branches_sharing_code/valid_if_blocks.rs
+++ b/tests/ui/branches_sharing_code/valid_if_blocks.rs
@@ -1,6 +1,10 @@
 #![deny(clippy::branches_sharing_code, clippy::if_same_then_else)]
 #![allow(dead_code)]
-#![allow(clippy::mixed_read_write_in_expression, clippy::uninlined_format_args)]
+#![allow(
+    clippy::mixed_read_write_in_expression,
+    clippy::uninlined_format_args,
+    clippy::needless_else
+)]
 
 // This tests valid if blocks that shouldn't trigger the lint
 
diff --git a/tests/ui/branches_sharing_code/valid_if_blocks.stderr b/tests/ui/branches_sharing_code/valid_if_blocks.stderr
index ce7fff0122f..a7e72b780af 100644
--- a/tests/ui/branches_sharing_code/valid_if_blocks.stderr
+++ b/tests/ui/branches_sharing_code/valid_if_blocks.stderr
@@ -1,5 +1,5 @@
 error: this `if` has identical blocks
-  --> $DIR/valid_if_blocks.rs:105:14
+  --> $DIR/valid_if_blocks.rs:109:14
    |
 LL |       if false {
    |  ______________^
@@ -7,7 +7,7 @@ LL | |     } else {
    | |_____^
    |
 note: same as this
-  --> $DIR/valid_if_blocks.rs:106:12
+  --> $DIR/valid_if_blocks.rs:110:12
    |
 LL |       } else {
    |  ____________^
@@ -20,7 +20,7 @@ LL | #![deny(clippy::branches_sharing_code, clippy::if_same_then_else)]
    |                                        ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this `if` has identical blocks
-  --> $DIR/valid_if_blocks.rs:116:15
+  --> $DIR/valid_if_blocks.rs:120:15
    |
 LL |       if x == 0 {
    |  _______________^
@@ -31,7 +31,7 @@ LL | |     } else {
    | |_____^
    |
 note: same as this
-  --> $DIR/valid_if_blocks.rs:120:12
+  --> $DIR/valid_if_blocks.rs:124:12
    |
 LL |       } else {
    |  ____________^
@@ -42,19 +42,19 @@ LL | |     }
    | |_____^
 
 error: this `if` has identical blocks
-  --> $DIR/valid_if_blocks.rs:127:23
+  --> $DIR/valid_if_blocks.rs:131:23
    |
 LL |     let _ = if x == 6 { 7 } else { 7 };
    |                       ^^^^^
    |
 note: same as this
-  --> $DIR/valid_if_blocks.rs:127:34
+  --> $DIR/valid_if_blocks.rs:131:34
    |
 LL |     let _ = if x == 6 { 7 } else { 7 };
    |                                  ^^^^^
 
 error: this `if` has identical blocks
-  --> $DIR/valid_if_blocks.rs:133:23
+  --> $DIR/valid_if_blocks.rs:137:23
    |
 LL |       } else if x == 68 {
    |  _______________________^
@@ -66,7 +66,7 @@ LL | |     } else {
    | |_____^
    |
 note: same as this
-  --> $DIR/valid_if_blocks.rs:138:12
+  --> $DIR/valid_if_blocks.rs:142:12
    |
 LL |       } else {
    |  ____________^
@@ -78,7 +78,7 @@ LL | |     };
    | |_____^
 
 error: this `if` has identical blocks
-  --> $DIR/valid_if_blocks.rs:147:23
+  --> $DIR/valid_if_blocks.rs:151:23
    |
 LL |       } else if x == 68 {
    |  _______________________^
@@ -88,7 +88,7 @@ LL | |     } else {
    | |_____^
    |
 note: same as this
-  --> $DIR/valid_if_blocks.rs:150:12
+  --> $DIR/valid_if_blocks.rs:154:12
    |
 LL |       } else {
    |  ____________^
diff --git a/tests/ui/crashes/ice-7410.rs b/tests/ui/crashes/ice-7410.rs
index ffe20ab1c31..a5373cdcae1 100644
--- a/tests/ui/crashes/ice-7410.rs
+++ b/tests/ui/crashes/ice-7410.rs
@@ -6,6 +6,7 @@
 #![no_std]
 #![allow(clippy::if_same_then_else)]
 #![allow(clippy::redundant_pattern_matching)]
+#![allow(clippy::needless_else)]
 
 use core::panic::PanicInfo;
 
diff --git a/tests/ui/ifs_same_cond.rs b/tests/ui/ifs_same_cond.rs
index 9ce9a87626a..f62da157d1b 100644
--- a/tests/ui/ifs_same_cond.rs
+++ b/tests/ui/ifs_same_cond.rs
@@ -1,5 +1,5 @@
 #![warn(clippy::ifs_same_cond)]
-#![allow(clippy::if_same_then_else, clippy::comparison_chain)] // all empty blocks
+#![allow(clippy::if_same_then_else, clippy::comparison_chain, clippy::needless_else)] // all empty blocks
 
 fn ifs_same_cond() {
     let a = 0;
diff --git a/tests/ui/needless_else.fixed b/tests/ui/needless_else.fixed
new file mode 100644
index 00000000000..14f81728a86
--- /dev/null
+++ b/tests/ui/needless_else.fixed
@@ -0,0 +1,40 @@
+//@run-rustfix
+#![allow(unused)]
+#![warn(clippy::needless_else)]
+#![allow(clippy::suspicious_else_formatting)]
+
+macro_rules! mac {
+    ($test:expr) => {
+        if $test {
+            println!("Test successful!");
+        } else {
+        }
+    };
+}
+
+fn main() {
+    let b = std::hint::black_box(true);
+
+    if b {
+        println!("Foobar");
+    } 
+
+    if b {
+        println!("Foobar");
+    } else {
+        // Do not lint because this comment might be important
+    }
+
+    if b {
+        println!("Foobar");
+    } else
+    /* Do not lint because this comment might be important */
+    {
+    }
+
+    // Do not lint because of the expression
+    let _ = if b { 1 } else { 2 };
+
+    // Do not lint because inside a macro
+    mac!(b);
+}
diff --git a/tests/ui/needless_else.rs b/tests/ui/needless_else.rs
new file mode 100644
index 00000000000..fae11818141
--- /dev/null
+++ b/tests/ui/needless_else.rs
@@ -0,0 +1,41 @@
+//@run-rustfix
+#![allow(unused)]
+#![warn(clippy::needless_else)]
+#![allow(clippy::suspicious_else_formatting)]
+
+macro_rules! mac {
+    ($test:expr) => {
+        if $test {
+            println!("Test successful!");
+        } else {
+        }
+    };
+}
+
+fn main() {
+    let b = std::hint::black_box(true);
+
+    if b {
+        println!("Foobar");
+    } else {
+    }
+
+    if b {
+        println!("Foobar");
+    } else {
+        // Do not lint because this comment might be important
+    }
+
+    if b {
+        println!("Foobar");
+    } else
+    /* Do not lint because this comment might be important */
+    {
+    }
+
+    // Do not lint because of the expression
+    let _ = if b { 1 } else { 2 };
+
+    // Do not lint because inside a macro
+    mac!(b);
+}
diff --git a/tests/ui/needless_else.stderr b/tests/ui/needless_else.stderr
new file mode 100644
index 00000000000..a7b2f1959c7
--- /dev/null
+++ b/tests/ui/needless_else.stderr
@@ -0,0 +1,12 @@
+error: this else branch is empty
+  --> $DIR/needless_else.rs:20:7
+   |
+LL |       } else {
+   |  _______^
+LL | |     }
+   | |_____^ help: you can remove it
+   |
+   = note: `-D clippy::needless-else` implied by `-D warnings`
+
+error: aborting due to previous error
+
diff --git a/tests/ui/needless_return.fixed b/tests/ui/needless_return.fixed
index d49ae5d8636..4dabf313963 100644
--- a/tests/ui/needless_return.fixed
+++ b/tests/ui/needless_return.fixed
@@ -7,7 +7,8 @@
     clippy::if_same_then_else,
     clippy::single_match,
     clippy::needless_bool,
-    clippy::equatable_if_let
+    clippy::equatable_if_let,
+    clippy::needless_else
 )]
 #![warn(clippy::needless_return)]
 
diff --git a/tests/ui/needless_return.rs b/tests/ui/needless_return.rs
index 36763826174..542f562b314 100644
--- a/tests/ui/needless_return.rs
+++ b/tests/ui/needless_return.rs
@@ -7,7 +7,8 @@
     clippy::if_same_then_else,
     clippy::single_match,
     clippy::needless_bool,
-    clippy::equatable_if_let
+    clippy::equatable_if_let,
+    clippy::needless_else
 )]
 #![warn(clippy::needless_return)]
 
diff --git a/tests/ui/needless_return.stderr b/tests/ui/needless_return.stderr
index 05f6038cd25..b5a7d61139d 100644
--- a/tests/ui/needless_return.stderr
+++ b/tests/ui/needless_return.stderr
@@ -1,5 +1,5 @@
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:27:5
+  --> $DIR/needless_return.rs:28:5
    |
 LL |     return true;
    |     ^^^^^^^^^^^
@@ -8,7 +8,7 @@ LL |     return true;
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:31:5
+  --> $DIR/needless_return.rs:32:5
    |
 LL |     return true;
    |     ^^^^^^^^^^^
@@ -16,7 +16,7 @@ LL |     return true;
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:36:5
+  --> $DIR/needless_return.rs:37:5
    |
 LL |     return true;;;
    |     ^^^^^^^^^^^
@@ -24,7 +24,7 @@ LL |     return true;;;
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:41:5
+  --> $DIR/needless_return.rs:42:5
    |
 LL |     return true;; ; ;
    |     ^^^^^^^^^^^
@@ -32,7 +32,7 @@ LL |     return true;; ; ;
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:46:9
+  --> $DIR/needless_return.rs:47:9
    |
 LL |         return true;
    |         ^^^^^^^^^^^
@@ -40,7 +40,7 @@ LL |         return true;
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:48:9
+  --> $DIR/needless_return.rs:49:9
    |
 LL |         return false;
    |         ^^^^^^^^^^^^
@@ -48,7 +48,7 @@ LL |         return false;
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:54:17
+  --> $DIR/needless_return.rs:55:17
    |
 LL |         true => return false,
    |                 ^^^^^^^^^^^^
@@ -56,7 +56,7 @@ LL |         true => return false,
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:56:13
+  --> $DIR/needless_return.rs:57:13
    |
 LL |             return true;
    |             ^^^^^^^^^^^
@@ -64,7 +64,7 @@ LL |             return true;
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:63:9
+  --> $DIR/needless_return.rs:64:9
    |
 LL |         return true;
    |         ^^^^^^^^^^^
@@ -72,7 +72,7 @@ LL |         return true;
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:65:16
+  --> $DIR/needless_return.rs:66:16
    |
 LL |     let _ = || return true;
    |                ^^^^^^^^^^^
@@ -80,7 +80,7 @@ LL |     let _ = || return true;
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:69:5
+  --> $DIR/needless_return.rs:70:5
    |
 LL |     return the_answer!();
    |     ^^^^^^^^^^^^^^^^^^^^
@@ -88,7 +88,7 @@ LL |     return the_answer!();
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:72:21
+  --> $DIR/needless_return.rs:73:21
    |
 LL |   fn test_void_fun() {
    |  _____________________^
@@ -98,7 +98,7 @@ LL | |     return;
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:77:11
+  --> $DIR/needless_return.rs:78:11
    |
 LL |       if b {
    |  ___________^
@@ -108,7 +108,7 @@ LL | |         return;
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:79:13
+  --> $DIR/needless_return.rs:80:13
    |
 LL |       } else {
    |  _____________^
@@ -118,7 +118,7 @@ LL | |         return;
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:87:14
+  --> $DIR/needless_return.rs:88:14
    |
 LL |         _ => return,
    |              ^^^^^^
@@ -126,7 +126,7 @@ LL |         _ => return,
    = help: replace `return` with a unit value
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:95:24
+  --> $DIR/needless_return.rs:96:24
    |
 LL |               let _ = 42;
    |  ________________________^
@@ -136,7 +136,7 @@ LL | |             return;
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:98:14
+  --> $DIR/needless_return.rs:99:14
    |
 LL |         _ => return,
    |              ^^^^^^
@@ -144,7 +144,7 @@ LL |         _ => return,
    = help: replace `return` with a unit value
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:111:9
+  --> $DIR/needless_return.rs:112:9
    |
 LL |         return String::from("test");
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -152,7 +152,7 @@ LL |         return String::from("test");
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:113:9
+  --> $DIR/needless_return.rs:114:9
    |
 LL |         return String::new();
    |         ^^^^^^^^^^^^^^^^^^^^
@@ -160,7 +160,7 @@ LL |         return String::new();
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:135:32
+  --> $DIR/needless_return.rs:136:32
    |
 LL |         bar.unwrap_or_else(|_| return)
    |                                ^^^^^^
@@ -168,7 +168,7 @@ LL |         bar.unwrap_or_else(|_| return)
    = help: replace `return` with an empty block
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:139:21
+  --> $DIR/needless_return.rs:140:21
    |
 LL |           let _ = || {
    |  _____________________^
@@ -178,7 +178,7 @@ LL | |             return;
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:142:20
+  --> $DIR/needless_return.rs:143:20
    |
 LL |         let _ = || return;
    |                    ^^^^^^
@@ -186,7 +186,7 @@ LL |         let _ = || return;
    = help: replace `return` with an empty block
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:148:32
+  --> $DIR/needless_return.rs:149:32
    |
 LL |         res.unwrap_or_else(|_| return Foo)
    |                                ^^^^^^^^^^
@@ -194,7 +194,7 @@ LL |         res.unwrap_or_else(|_| return Foo)
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:157:5
+  --> $DIR/needless_return.rs:158:5
    |
 LL |     return true;
    |     ^^^^^^^^^^^
@@ -202,7 +202,7 @@ LL |     return true;
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:161:5
+  --> $DIR/needless_return.rs:162:5
    |
 LL |     return true;
    |     ^^^^^^^^^^^
@@ -210,7 +210,7 @@ LL |     return true;
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:166:9
+  --> $DIR/needless_return.rs:167:9
    |
 LL |         return true;
    |         ^^^^^^^^^^^
@@ -218,7 +218,7 @@ LL |         return true;
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:168:9
+  --> $DIR/needless_return.rs:169:9
    |
 LL |         return false;
    |         ^^^^^^^^^^^^
@@ -226,7 +226,7 @@ LL |         return false;
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:174:17
+  --> $DIR/needless_return.rs:175:17
    |
 LL |         true => return false,
    |                 ^^^^^^^^^^^^
@@ -234,7 +234,7 @@ LL |         true => return false,
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:176:13
+  --> $DIR/needless_return.rs:177:13
    |
 LL |             return true;
    |             ^^^^^^^^^^^
@@ -242,7 +242,7 @@ LL |             return true;
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:183:9
+  --> $DIR/needless_return.rs:184:9
    |
 LL |         return true;
    |         ^^^^^^^^^^^
@@ -250,7 +250,7 @@ LL |         return true;
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:185:16
+  --> $DIR/needless_return.rs:186:16
    |
 LL |     let _ = || return true;
    |                ^^^^^^^^^^^
@@ -258,7 +258,7 @@ LL |     let _ = || return true;
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:189:5
+  --> $DIR/needless_return.rs:190:5
    |
 LL |     return the_answer!();
    |     ^^^^^^^^^^^^^^^^^^^^
@@ -266,7 +266,7 @@ LL |     return the_answer!();
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:192:33
+  --> $DIR/needless_return.rs:193:33
    |
 LL |   async fn async_test_void_fun() {
    |  _________________________________^
@@ -276,7 +276,7 @@ LL | |     return;
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:197:11
+  --> $DIR/needless_return.rs:198:11
    |
 LL |       if b {
    |  ___________^
@@ -286,7 +286,7 @@ LL | |         return;
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:199:13
+  --> $DIR/needless_return.rs:200:13
    |
 LL |       } else {
    |  _____________^
@@ -296,7 +296,7 @@ LL | |         return;
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:207:14
+  --> $DIR/needless_return.rs:208:14
    |
 LL |         _ => return,
    |              ^^^^^^
@@ -304,7 +304,7 @@ LL |         _ => return,
    = help: replace `return` with a unit value
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:220:9
+  --> $DIR/needless_return.rs:221:9
    |
 LL |         return String::from("test");
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -312,7 +312,7 @@ LL |         return String::from("test");
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:222:9
+  --> $DIR/needless_return.rs:223:9
    |
 LL |         return String::new();
    |         ^^^^^^^^^^^^^^^^^^^^
@@ -320,7 +320,7 @@ LL |         return String::new();
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:238:5
+  --> $DIR/needless_return.rs:239:5
    |
 LL |     return format!("Hello {}", "world!");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -328,7 +328,7 @@ LL |     return format!("Hello {}", "world!");
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:250:9
+  --> $DIR/needless_return.rs:251:9
    |
 LL |         return true;
    |         ^^^^^^^^^^^
@@ -336,7 +336,7 @@ LL |         return true;
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:252:9
+  --> $DIR/needless_return.rs:253:9
    |
 LL |         return false;
    |         ^^^^^^^^^^^^
@@ -344,7 +344,7 @@ LL |         return false;
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:259:13
+  --> $DIR/needless_return.rs:260:13
    |
 LL |             return 10;
    |             ^^^^^^^^^
@@ -352,7 +352,7 @@ LL |             return 10;
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:262:13
+  --> $DIR/needless_return.rs:263:13
    |
 LL |             return 100;
    |             ^^^^^^^^^^
@@ -360,7 +360,7 @@ LL |             return 100;
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:270:9
+  --> $DIR/needless_return.rs:271:9
    |
 LL |         return 0;
    |         ^^^^^^^^
@@ -368,7 +368,7 @@ LL |         return 0;
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:277:13
+  --> $DIR/needless_return.rs:278:13
    |
 LL |             return *(x as *const isize);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -376,7 +376,7 @@ LL |             return *(x as *const isize);
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:279:13
+  --> $DIR/needless_return.rs:280:13
    |
 LL |             return !*(x as *const isize);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -384,7 +384,7 @@ LL |             return !*(x as *const isize);
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:286:20
+  --> $DIR/needless_return.rs:287:20
    |
 LL |           let _ = 42;
    |  ____________________^
@@ -395,7 +395,7 @@ LL | |         return;
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:293:20
+  --> $DIR/needless_return.rs:294:20
    |
 LL |         let _ = 42; return;
    |                    ^^^^^^^
@@ -403,7 +403,7 @@ LL |         let _ = 42; return;
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:305:9
+  --> $DIR/needless_return.rs:306:9
    |
 LL |         return Ok(format!("ok!"));
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -411,7 +411,7 @@ LL |         return Ok(format!("ok!"));
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:307:9
+  --> $DIR/needless_return.rs:308:9
    |
 LL |         return Err(format!("err!"));
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -419,7 +419,7 @@ LL |         return Err(format!("err!"));
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:313:9
+  --> $DIR/needless_return.rs:314:9
    |
 LL |         return if true { 1 } else { 2 };
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -427,7 +427,7 @@ LL |         return if true { 1 } else { 2 };
    = help: remove `return`
 
 error: unneeded `return` statement
-  --> $DIR/needless_return.rs:317:9
+  --> $DIR/needless_return.rs:318:9
    |
 LL |         return if b1 { 0 } else { 1 } | if b2 { 2 } else { 3 } | if b3 { 4 } else { 5 };
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/redundant_pattern_matching_drop_order.fixed b/tests/ui/redundant_pattern_matching_drop_order.fixed
index bebdf89716f..481c9b263fb 100644
--- a/tests/ui/redundant_pattern_matching_drop_order.fixed
+++ b/tests/ui/redundant_pattern_matching_drop_order.fixed
@@ -2,7 +2,7 @@
 
 // Issue #5746
 #![warn(clippy::redundant_pattern_matching)]
-#![allow(clippy::if_same_then_else, clippy::equatable_if_let)]
+#![allow(clippy::if_same_then_else, clippy::equatable_if_let, clippy::needless_else)]
 use std::task::Poll::{Pending, Ready};
 
 fn main() {
diff --git a/tests/ui/redundant_pattern_matching_drop_order.rs b/tests/ui/redundant_pattern_matching_drop_order.rs
index 8fb6ed5f7ec..86e46d41e65 100644
--- a/tests/ui/redundant_pattern_matching_drop_order.rs
+++ b/tests/ui/redundant_pattern_matching_drop_order.rs
@@ -2,7 +2,7 @@
 
 // Issue #5746
 #![warn(clippy::redundant_pattern_matching)]
-#![allow(clippy::if_same_then_else, clippy::equatable_if_let)]
+#![allow(clippy::if_same_then_else, clippy::equatable_if_let, clippy::needless_else)]
 use std::task::Poll::{Pending, Ready};
 
 fn main() {
diff --git a/tests/ui/suspicious_else_formatting.rs b/tests/ui/suspicious_else_formatting.rs
index e0153cdd8cd..4823d909208 100644
--- a/tests/ui/suspicious_else_formatting.rs
+++ b/tests/ui/suspicious_else_formatting.rs
@@ -1,7 +1,7 @@
 //@aux-build:proc_macro_suspicious_else_formatting.rs
 
 #![warn(clippy::suspicious_else_formatting)]
-#![allow(clippy::if_same_then_else, clippy::let_unit_value)]
+#![allow(clippy::if_same_then_else, clippy::let_unit_value, clippy::needless_else)]
 
 extern crate proc_macro_suspicious_else_formatting;
 use proc_macro_suspicious_else_formatting::DeriveBadSpan;
-- 
cgit 1.4.1-3-g733a5


From 3e1302fa0c50cc41535b6e23d9cf7e686f4a4fdd Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Mon, 22 May 2023 14:04:13 +0200
Subject: [`match_wild_err_arm`]: do not lint in const contexts

---
 clippy_lints/src/matches/match_wild_err_arm.rs |  7 ++++++-
 tests/ui/match_wild_err_arm.rs                 | 15 ++++++++++++++-
 tests/ui/match_wild_err_arm.stderr             |  8 ++++----
 3 files changed, 24 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/match_wild_err_arm.rs b/clippy_lints/src/matches/match_wild_err_arm.rs
index 42f1e2629d4..6424ac31d9f 100644
--- a/clippy_lints/src/matches/match_wild_err_arm.rs
+++ b/clippy_lints/src/matches/match_wild_err_arm.rs
@@ -2,7 +2,7 @@ use clippy_utils::diagnostics::span_lint_and_note;
 use clippy_utils::macros::{is_panic, root_macro_call};
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::visitors::is_local_used;
-use clippy_utils::{is_wild, peel_blocks_with_stmt};
+use clippy_utils::{in_constant, is_wild, peel_blocks_with_stmt};
 use rustc_hir::{Arm, Expr, PatKind};
 use rustc_lint::LateContext;
 use rustc_span::symbol::{kw, sym};
@@ -10,6 +10,11 @@ use rustc_span::symbol::{kw, sym};
 use super::MATCH_WILD_ERR_ARM;
 
 pub(crate) fn check<'tcx>(cx: &LateContext<'tcx>, ex: &Expr<'tcx>, arms: &[Arm<'tcx>]) {
+    // `unwrap`/`expect` is not (yet) const, so we want to allow this in const contexts for now
+    if in_constant(cx, ex.hir_id) {
+        return;
+    }
+
     let ex_ty = cx.typeck_results().expr_ty(ex).peel_refs();
     if is_type_diagnostic_item(cx, ex_ty, sym::Result) {
         for arm in arms {
diff --git a/tests/ui/match_wild_err_arm.rs b/tests/ui/match_wild_err_arm.rs
index 823be65efe0..5a552e4ae51 100644
--- a/tests/ui/match_wild_err_arm.rs
+++ b/tests/ui/match_wild_err_arm.rs
@@ -1,7 +1,20 @@
 #![feature(exclusive_range_pattern)]
-#![allow(clippy::match_same_arms)]
+#![allow(clippy::match_same_arms, dead_code)]
 #![warn(clippy::match_wild_err_arm)]
 
+fn issue_10635() {
+    enum Error {
+        A,
+        B,
+    }
+
+    // Don't trigger in const contexts. Const unwrap is not yet stable
+    const X: () = match Ok::<_, Error>(()) {
+        Ok(x) => x,
+        Err(_) => panic!(),
+    };
+}
+
 fn match_wild_err_arm() {
     let x: Result<i32, &str> = Ok(3);
 
diff --git a/tests/ui/match_wild_err_arm.stderr b/tests/ui/match_wild_err_arm.stderr
index b016d682698..a9f54feacdb 100644
--- a/tests/ui/match_wild_err_arm.stderr
+++ b/tests/ui/match_wild_err_arm.stderr
@@ -1,5 +1,5 @@
 error: `Err(_)` matches all errors
-  --> $DIR/match_wild_err_arm.rs:11:9
+  --> $DIR/match_wild_err_arm.rs:24:9
    |
 LL |         Err(_) => panic!("err"),
    |         ^^^^^^
@@ -8,7 +8,7 @@ LL |         Err(_) => panic!("err"),
    = note: `-D clippy::match-wild-err-arm` implied by `-D warnings`
 
 error: `Err(_)` matches all errors
-  --> $DIR/match_wild_err_arm.rs:17:9
+  --> $DIR/match_wild_err_arm.rs:30:9
    |
 LL |         Err(_) => panic!(),
    |         ^^^^^^
@@ -16,7 +16,7 @@ LL |         Err(_) => panic!(),
    = note: match each error separately or use the error output, or use `.expect(msg)` if the error case is unreachable
 
 error: `Err(_)` matches all errors
-  --> $DIR/match_wild_err_arm.rs:23:9
+  --> $DIR/match_wild_err_arm.rs:36:9
    |
 LL |         Err(_) => {
    |         ^^^^^^
@@ -24,7 +24,7 @@ LL |         Err(_) => {
    = note: match each error separately or use the error output, or use `.expect(msg)` if the error case is unreachable
 
 error: `Err(_e)` matches all errors
-  --> $DIR/match_wild_err_arm.rs:31:9
+  --> $DIR/match_wild_err_arm.rs:44:9
    |
 LL |         Err(_e) => panic!(),
    |         ^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From 8c82486ea92219d1c0c720fc598abac27c81a966 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Mon, 22 May 2023 16:13:23 +0200
Subject: [`default_constructed_unit_structs`]: do not lint type aliases

---
 .../src/default_constructed_unit_structs.rs        | 15 +++++++++++++--
 clippy_utils/src/lib.rs                            |  2 +-
 tests/ui/default_constructed_unit_structs.fixed    | 22 ++++++++++++++++++++++
 tests/ui/default_constructed_unit_structs.rs       | 22 ++++++++++++++++++++++
 tests/ui/default_constructed_unit_structs.stderr   |  8 ++++----
 5 files changed, 62 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/default_constructed_unit_structs.rs b/clippy_lints/src/default_constructed_unit_structs.rs
index 9bd7a0dc0f3..fb037bbcbf3 100644
--- a/clippy_lints/src/default_constructed_unit_structs.rs
+++ b/clippy_lints/src/default_constructed_unit_structs.rs
@@ -1,4 +1,4 @@
-use clippy_utils::{diagnostics::span_lint_and_sugg, match_def_path, paths};
+use clippy_utils::{diagnostics::span_lint_and_sugg, is_ty_alias, match_def_path, paths};
 use hir::{def::Res, ExprKind};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
@@ -43,12 +43,23 @@ declare_clippy_lint! {
 }
 declare_lint_pass!(DefaultConstructedUnitStructs => [DEFAULT_CONSTRUCTED_UNIT_STRUCTS]);
 
+fn is_alias(ty: hir::Ty<'_>) -> bool {
+    if let hir::TyKind::Path(ref qpath) = ty.kind {
+        is_ty_alias(qpath)
+    } else {
+        false
+    }
+}
+
 impl LateLintPass<'_> for DefaultConstructedUnitStructs {
     fn check_expr<'tcx>(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'tcx>) {
         if_chain!(
             // make sure we have a call to `Default::default`
             if let hir::ExprKind::Call(fn_expr, &[]) = expr.kind;
-            if let ExprKind::Path(ref qpath@ hir::QPath::TypeRelative(_,_)) = fn_expr.kind;
+            if let ExprKind::Path(ref qpath @ hir::QPath::TypeRelative(base, _)) = fn_expr.kind;
+            // make sure this isn't a type alias:
+            // `<Foo as Bar>::Assoc` cannot be used as a constructor
+            if !is_alias(*base);
             if let Res::Def(_, def_id) = cx.qpath_res(qpath, fn_expr.hir_id);
             if match_def_path(cx, def_id, &paths::DEFAULT_TRAIT_METHOD);
             // make sure we have a struct with no fields (unit struct)
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 575c29a6b6f..8c883445a79 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -287,7 +287,7 @@ pub fn is_wild(pat: &Pat<'_>) -> bool {
 /// Checks if the given `QPath` belongs to a type alias.
 pub fn is_ty_alias(qpath: &QPath<'_>) -> bool {
     match *qpath {
-        QPath::Resolved(_, path) => matches!(path.res, Res::Def(DefKind::TyAlias, ..)),
+        QPath::Resolved(_, path) => matches!(path.res, Res::Def(DefKind::TyAlias | DefKind::AssocTy, ..)),
         QPath::TypeRelative(ty, _) if let TyKind::Path(qpath) = ty.kind => { is_ty_alias(&qpath) },
         _ => false,
     }
diff --git a/tests/ui/default_constructed_unit_structs.fixed b/tests/ui/default_constructed_unit_structs.fixed
index e1012f38bba..ac5fe38ff44 100644
--- a/tests/ui/default_constructed_unit_structs.fixed
+++ b/tests/ui/default_constructed_unit_structs.fixed
@@ -101,6 +101,28 @@ struct EmptyStruct {}
 #[non_exhaustive]
 struct NonExhaustiveStruct;
 
+mod issue_10755 {
+    struct Sqlite {}
+
+    trait HasArguments<'q> {
+        type Arguments;
+    }
+
+    impl<'q> HasArguments<'q> for Sqlite {
+        type Arguments = std::marker::PhantomData<&'q ()>;
+    }
+
+    type SqliteArguments<'q> = <Sqlite as HasArguments<'q>>::Arguments;
+
+    fn foo() {
+        // should not lint
+        // type alias cannot be used as a constructor
+        let _ = <Sqlite as HasArguments>::Arguments::default();
+
+        let _ = SqliteArguments::default();
+    }
+}
+
 fn main() {
     // should lint
     let _ = PhantomData::<usize>;
diff --git a/tests/ui/default_constructed_unit_structs.rs b/tests/ui/default_constructed_unit_structs.rs
index c7b4313dbf0..de7f14ffbd9 100644
--- a/tests/ui/default_constructed_unit_structs.rs
+++ b/tests/ui/default_constructed_unit_structs.rs
@@ -101,6 +101,28 @@ struct EmptyStruct {}
 #[non_exhaustive]
 struct NonExhaustiveStruct;
 
+mod issue_10755 {
+    struct Sqlite {}
+
+    trait HasArguments<'q> {
+        type Arguments;
+    }
+
+    impl<'q> HasArguments<'q> for Sqlite {
+        type Arguments = std::marker::PhantomData<&'q ()>;
+    }
+
+    type SqliteArguments<'q> = <Sqlite as HasArguments<'q>>::Arguments;
+
+    fn foo() {
+        // should not lint
+        // type alias cannot be used as a constructor
+        let _ = <Sqlite as HasArguments>::Arguments::default();
+
+        let _ = SqliteArguments::default();
+    }
+}
+
 fn main() {
     // should lint
     let _ = PhantomData::<usize>::default();
diff --git a/tests/ui/default_constructed_unit_structs.stderr b/tests/ui/default_constructed_unit_structs.stderr
index 61a32fb10e5..13abb9149da 100644
--- a/tests/ui/default_constructed_unit_structs.stderr
+++ b/tests/ui/default_constructed_unit_structs.stderr
@@ -13,25 +13,25 @@ LL |             inner: PhantomData::default(),
    |                               ^^^^^^^^^^^ help: remove this call to `default`
 
 error: use of `default` to create a unit struct
-  --> $DIR/default_constructed_unit_structs.rs:106:33
+  --> $DIR/default_constructed_unit_structs.rs:128:33
    |
 LL |     let _ = PhantomData::<usize>::default();
    |                                 ^^^^^^^^^^^ help: remove this call to `default`
 
 error: use of `default` to create a unit struct
-  --> $DIR/default_constructed_unit_structs.rs:107:42
+  --> $DIR/default_constructed_unit_structs.rs:129:42
    |
 LL |     let _: PhantomData<i32> = PhantomData::default();
    |                                          ^^^^^^^^^^^ help: remove this call to `default`
 
 error: use of `default` to create a unit struct
-  --> $DIR/default_constructed_unit_structs.rs:108:55
+  --> $DIR/default_constructed_unit_structs.rs:130:55
    |
 LL |     let _: PhantomData<i32> = std::marker::PhantomData::default();
    |                                                       ^^^^^^^^^^^ help: remove this call to `default`
 
 error: use of `default` to create a unit struct
-  --> $DIR/default_constructed_unit_structs.rs:109:23
+  --> $DIR/default_constructed_unit_structs.rs:131:23
    |
 LL |     let _ = UnitStruct::default();
    |                       ^^^^^^^^^^^ help: remove this call to `default`
-- 
cgit 1.4.1-3-g733a5


From f4b02aa3741299b8226f50ba63ec1f4e27a64d14 Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Mon, 15 May 2023 11:20:04 -0500
Subject: fix #10776

---
 clippy_lints/src/mixed_read_write_in_expression.rs |  6 ++--
 tests/ui/diverging_sub_expression.rs               |  4 +++
 tests/ui/diverging_sub_expression.stderr           | 40 ----------------------
 3 files changed, 6 insertions(+), 44 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/mixed_read_write_in_expression.rs b/clippy_lints/src/mixed_read_write_in_expression.rs
index f0be7771bb1..2dfab259915 100644
--- a/clippy_lints/src/mixed_read_write_in_expression.rs
+++ b/clippy_lints/src/mixed_read_write_in_expression.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::{span_lint, span_lint_and_note};
 use clippy_utils::{get_parent_expr, path_to_local, path_to_local_id};
 use if_chain::if_chain;
-use rustc_hir::intravisit::{walk_expr, Visitor};
+use rustc_hir::intravisit::{walk_block, walk_expr, Visitor};
 use rustc_hir::{BinOpKind, Block, Expr, ExprKind, Guard, HirId, Local, Node, Stmt, StmtKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
@@ -155,6 +155,7 @@ impl<'a, 'tcx> Visitor<'tcx> for DivergenceVisitor<'a, 'tcx> {
                     self.report_diverging_sub_expr(e);
                 }
             },
+            ExprKind::Block(block, ..) => walk_block(self, block),
             _ => {
                 // do not lint expressions referencing objects of type `!`, as that required a
                 // diverging expression
@@ -163,9 +164,6 @@ impl<'a, 'tcx> Visitor<'tcx> for DivergenceVisitor<'a, 'tcx> {
         }
         self.maybe_walk_expr(e);
     }
-    fn visit_block(&mut self, _: &'tcx Block<'_>) {
-        // don't continue over blocks, LateLintPass already does that
-    }
 }
 
 /// Walks up the AST from the given write expression (`vis.write_expr`) looking
diff --git a/tests/ui/diverging_sub_expression.rs b/tests/ui/diverging_sub_expression.rs
index e8f992e6dde..1dd3f3b8bc4 100644
--- a/tests/ui/diverging_sub_expression.rs
+++ b/tests/ui/diverging_sub_expression.rs
@@ -1,5 +1,6 @@
 #![warn(clippy::diverging_sub_expression)]
 #![allow(clippy::match_same_arms, clippy::overly_complex_bool_expr)]
+#![allow(clippy::nonminimal_bool)]
 #[allow(clippy::empty_loop)]
 fn diverge() -> ! {
     loop {}
@@ -35,6 +36,9 @@ fn foobar() {
                 99 => return,
                 _ => true || panic!("boo"),
             },
+            // lint blocks as well
+            15 => true || { return; },
+            16 => false || { return; },
             _ => true || break,
         };
     }
diff --git a/tests/ui/diverging_sub_expression.stderr b/tests/ui/diverging_sub_expression.stderr
index 51a3b0d972e..e69de29bb2d 100644
--- a/tests/ui/diverging_sub_expression.stderr
+++ b/tests/ui/diverging_sub_expression.stderr
@@ -1,40 +0,0 @@
-error: sub-expression diverges
-  --> $DIR/diverging_sub_expression.rs:19:10
-   |
-LL |     b || diverge();
-   |          ^^^^^^^^^
-   |
-   = note: `-D clippy::diverging-sub-expression` implied by `-D warnings`
-
-error: sub-expression diverges
-  --> $DIR/diverging_sub_expression.rs:20:10
-   |
-LL |     b || A.foo();
-   |          ^^^^^^^
-
-error: sub-expression diverges
-  --> $DIR/diverging_sub_expression.rs:29:26
-   |
-LL |             6 => true || return,
-   |                          ^^^^^^
-
-error: sub-expression diverges
-  --> $DIR/diverging_sub_expression.rs:30:26
-   |
-LL |             7 => true || continue,
-   |                          ^^^^^^^^
-
-error: sub-expression diverges
-  --> $DIR/diverging_sub_expression.rs:33:26
-   |
-LL |             3 => true || diverge(),
-   |                          ^^^^^^^^^
-
-error: sub-expression diverges
-  --> $DIR/diverging_sub_expression.rs:38:26
-   |
-LL |             _ => true || break,
-   |                          ^^^^^
-
-error: aborting due to 6 previous errors
-
-- 
cgit 1.4.1-3-g733a5


From 5825b9e3e29c98ca0b8ae74cc5ece8a05747a416 Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Mon, 15 May 2023 14:46:24 -0500
Subject: actually fix it

---
 clippy_lints/src/mixed_read_write_in_expression.rs | 18 +++++++++++++++---
 tests/ui/diverging_sub_expression.rs               |  1 +
 tests/ui/never_loop.stderr                         | 10 +++++++++-
 3 files changed, 25 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/mixed_read_write_in_expression.rs b/clippy_lints/src/mixed_read_write_in_expression.rs
index 2dfab259915..942453498cd 100644
--- a/clippy_lints/src/mixed_read_write_in_expression.rs
+++ b/clippy_lints/src/mixed_read_write_in_expression.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::{span_lint, span_lint_and_note};
 use clippy_utils::{get_parent_expr, path_to_local, path_to_local_id};
 use if_chain::if_chain;
-use rustc_hir::intravisit::{walk_block, walk_expr, Visitor};
+use rustc_hir::intravisit::{walk_expr, Visitor};
 use rustc_hir::{BinOpKind, Block, Expr, ExprKind, Guard, HirId, Local, Node, Stmt, StmtKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
@@ -114,7 +114,7 @@ struct DivergenceVisitor<'a, 'tcx> {
 impl<'a, 'tcx> DivergenceVisitor<'a, 'tcx> {
     fn maybe_walk_expr(&mut self, e: &'tcx Expr<'_>) {
         match e.kind {
-            ExprKind::Closure { .. } => {},
+            ExprKind::Closure(..) | ExprKind::If(..) | ExprKind::Loop(..) => {},
             ExprKind::Match(e, arms, _) => {
                 self.visit_expr(e);
                 for arm in arms {
@@ -128,6 +128,7 @@ impl<'a, 'tcx> DivergenceVisitor<'a, 'tcx> {
             _ => walk_expr(self, e),
         }
     }
+
     fn report_diverging_sub_expr(&mut self, e: &Expr<'_>) {
         span_lint(self.cx, DIVERGING_SUB_EXPRESSION, e.span, "sub-expression diverges");
     }
@@ -136,6 +137,15 @@ impl<'a, 'tcx> DivergenceVisitor<'a, 'tcx> {
 impl<'a, 'tcx> Visitor<'tcx> for DivergenceVisitor<'a, 'tcx> {
     fn visit_expr(&mut self, e: &'tcx Expr<'_>) {
         match e.kind {
+            // fix #10776
+            ExprKind::Block(block, ..) => {
+                if let Some(stmt) = block.stmts.first() && block.stmts.len() == 1 {
+                    match stmt.kind {
+                        StmtKind::Expr(e) | StmtKind::Semi(e) => self.visit_expr(e),
+                        _ => {},
+                    }
+                }
+            },
             ExprKind::Continue(_) | ExprKind::Break(_, _) | ExprKind::Ret(_) => self.report_diverging_sub_expr(e),
             ExprKind::Call(func, _) => {
                 let typ = self.cx.typeck_results().expr_ty(func);
@@ -155,7 +165,6 @@ impl<'a, 'tcx> Visitor<'tcx> for DivergenceVisitor<'a, 'tcx> {
                     self.report_diverging_sub_expr(e);
                 }
             },
-            ExprKind::Block(block, ..) => walk_block(self, block),
             _ => {
                 // do not lint expressions referencing objects of type `!`, as that required a
                 // diverging expression
@@ -164,6 +173,9 @@ impl<'a, 'tcx> Visitor<'tcx> for DivergenceVisitor<'a, 'tcx> {
         }
         self.maybe_walk_expr(e);
     }
+    fn visit_block(&mut self, _: &'tcx Block<'_>) {
+        // don't continue over blocks, LateLintPass already does that
+    }
 }
 
 /// Walks up the AST from the given write expression (`vis.write_expr`) looking
diff --git a/tests/ui/diverging_sub_expression.rs b/tests/ui/diverging_sub_expression.rs
index 1dd3f3b8bc4..510eca21f71 100644
--- a/tests/ui/diverging_sub_expression.rs
+++ b/tests/ui/diverging_sub_expression.rs
@@ -22,6 +22,7 @@ fn main() {
 }
 
 #[allow(dead_code, unused_variables)]
+#[rustfmt::skip]
 fn foobar() {
     loop {
         let x = match 5 {
diff --git a/tests/ui/never_loop.stderr b/tests/ui/never_loop.stderr
index 704d448644e..b2eafb345e3 100644
--- a/tests/ui/never_loop.stderr
+++ b/tests/ui/never_loop.stderr
@@ -126,6 +126,14 @@ LL | |         }
 LL | |     }
    | |_____^
 
+error: sub-expression diverges
+  --> $DIR/never_loop.rs:247:17
+   |
+LL |                 break 'a;
+   |                 ^^^^^^^^
+   |
+   = note: `-D clippy::diverging-sub-expression` implied by `-D warnings`
+
 error: this loop never actually loops
   --> $DIR/never_loop.rs:278:13
    |
@@ -139,5 +147,5 @@ help: if you need the first element of the iterator, try writing
 LL |             if let Some(_) = (0..20).next() {
    |             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-error: aborting due to 12 previous errors
+error: aborting due to 13 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 8ef6240afb00ec9a892cb41c36cde102b688343a Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Tue, 23 May 2023 17:22:23 +0200
Subject: point to `await` expr in note

---
 clippy_lints/src/unused_async.rs | 16 ++++++++++------
 tests/ui/unused_async.stderr     |  6 +++++-
 2 files changed, 15 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unused_async.rs b/clippy_lints/src/unused_async.rs
index 4c68cda7aa7..117dda09222 100644
--- a/clippy_lints/src/unused_async.rs
+++ b/clippy_lints/src/unused_async.rs
@@ -44,7 +44,7 @@ struct AsyncFnVisitor<'a, 'tcx> {
     found_await: bool,
     /// Also keep track of `await`s in nested async blocks so we can mention
     /// it in a note
-    found_await_in_async_block: bool,
+    await_in_async_block: Option<Span>,
     async_depth: usize,
 }
 
@@ -55,8 +55,8 @@ impl<'a, 'tcx> Visitor<'tcx> for AsyncFnVisitor<'a, 'tcx> {
         if let ExprKind::Yield(_, YieldSource::Await { .. }) = ex.kind {
             if self.async_depth == 1 {
                 self.found_await = true;
-            } else {
-                self.found_await_in_async_block = true;
+            } else if self.await_in_async_block.is_none() {
+                self.await_in_async_block = Some(ex.span);
             }
         }
         walk_expr(self, ex);
@@ -96,7 +96,7 @@ impl<'tcx> LateLintPass<'tcx> for UnusedAsync {
                 cx,
                 found_await: false,
                 async_depth: 0,
-                found_await_in_async_block: false,
+                await_in_async_block: None,
             };
             walk_fn(&mut visitor, fn_kind, fn_decl, body.id(), def_id);
             if !visitor.found_await {
@@ -108,8 +108,12 @@ impl<'tcx> LateLintPass<'tcx> for UnusedAsync {
                     |diag| {
                         diag.help("consider removing the `async` from this function");
 
-                        if visitor.found_await_in_async_block {
-                            diag.note("`await` used in an async block, which does not require the enclosing function to be `async`");
+                        if let Some(span) = visitor.await_in_async_block {
+                            diag.span_note(
+                                span,
+                                "`await` used in an async block, which does not require \
+                                the enclosing function to be `async`",
+                            );
                         }
                     },
                 );
diff --git a/tests/ui/unused_async.stderr b/tests/ui/unused_async.stderr
index e39f9b20b88..8ac2066a6b2 100644
--- a/tests/ui/unused_async.stderr
+++ b/tests/ui/unused_async.stderr
@@ -9,7 +9,11 @@ LL | |     }
    | |_____^
    |
    = help: consider removing the `async` from this function
-   = note: `await` used in an async block, which does not require the enclosing function to be `async`
+note: `await` used in an async block, which does not require the enclosing function to be `async`
+  --> $DIR/unused_async.rs:13:23
+   |
+LL |             ready(()).await;
+   |                       ^^^^^
    = note: `-D clippy::unused-async` implied by `-D warnings`
 
 error: unused `async` for function with no await statements
-- 
cgit 1.4.1-3-g733a5


From 47a024e81d288323def492d07de79aae9550ff1e Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Tue, 23 May 2023 22:28:14 +0000
Subject: Display the `needless_return` suggestion

---
 clippy_lints/src/returns.rs     |  28 ++--
 tests/ui/needless_return.stderr | 322 +++++++++++++++++++++++++++++++++-------
 2 files changed, 283 insertions(+), 67 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
index df126d7617e..631ecf1428d 100644
--- a/clippy_lints/src/returns.rs
+++ b/clippy_lints/src/returns.rs
@@ -70,7 +70,7 @@ declare_clippy_lint! {
     "using a return statement like `return expr;` where an expression would suffice"
 }
 
-#[derive(PartialEq, Eq, Clone)]
+#[derive(PartialEq, Eq)]
 enum RetReplacement<'tcx> {
     Empty,
     Block,
@@ -80,7 +80,7 @@ enum RetReplacement<'tcx> {
 }
 
 impl<'tcx> RetReplacement<'tcx> {
-    fn sugg_help(self) -> &'static str {
+    fn sugg_help(&self) -> &'static str {
         match self {
             Self::Empty | Self::Expr(..) => "remove `return`",
             Self::Block => "replace `return` with an empty block",
@@ -88,10 +88,11 @@ impl<'tcx> RetReplacement<'tcx> {
             Self::IfSequence(..) => "remove `return` and wrap the sequence with parentheses",
         }
     }
-    fn applicability(&self) -> Option<Applicability> {
+
+    fn applicability(&self) -> Applicability {
         match self {
-            Self::Expr(_, ap) | Self::IfSequence(_, ap) => Some(*ap),
-            _ => None,
+            Self::Expr(_, ap) | Self::IfSequence(_, ap) => *ap,
+            _ => Applicability::MachineApplicable,
         }
     }
 }
@@ -271,7 +272,7 @@ fn check_final_expr<'tcx>(
                 return;
             }
 
-            emit_return_lint(cx, ret_span, semi_spans, replacement);
+            emit_return_lint(cx, ret_span, semi_spans, &replacement);
         },
         ExprKind::If(_, then, else_clause_opt) => {
             check_block_return(cx, &then.kind, peeled_drop_expr.span, semi_spans.clone());
@@ -306,20 +307,17 @@ fn expr_contains_conjunctive_ifs<'tcx>(expr: &'tcx Expr<'tcx>) -> bool {
     contains_if(expr, false)
 }
 
-fn emit_return_lint(cx: &LateContext<'_>, ret_span: Span, semi_spans: Vec<Span>, replacement: RetReplacement<'_>) {
+fn emit_return_lint(cx: &LateContext<'_>, ret_span: Span, semi_spans: Vec<Span>, replacement: &RetReplacement<'_>) {
     if ret_span.from_expansion() {
         return;
     }
 
-    let applicability = replacement.applicability().unwrap_or(Applicability::MachineApplicable);
-    let return_replacement = replacement.to_string();
-    let sugg_help = replacement.sugg_help();
     span_lint_and_then(cx, NEEDLESS_RETURN, ret_span, "unneeded `return` statement", |diag| {
-        diag.span_suggestion_hidden(ret_span, sugg_help, return_replacement, applicability);
-        // for each parent statement, we need to remove the semicolon
-        for semi_stmt_span in semi_spans {
-            diag.tool_only_span_suggestion(semi_stmt_span, "remove this semicolon", "", applicability);
-        }
+        let suggestions = std::iter::once((ret_span, replacement.to_string()))
+            .chain(semi_spans.into_iter().map(|span| (span, String::new())))
+            .collect();
+
+        diag.multipart_suggestion_verbose(replacement.sugg_help(), suggestions, replacement.applicability());
     });
 }
 
diff --git a/tests/ui/needless_return.stderr b/tests/ui/needless_return.stderr
index b5a7d61139d..1d9d23d3008 100644
--- a/tests/ui/needless_return.stderr
+++ b/tests/ui/needless_return.stderr
@@ -5,7 +5,11 @@ LL |     return true;
    |     ^^^^^^^^^^^
    |
    = note: `-D clippy::needless-return` implied by `-D warnings`
-   = help: remove `return`
+help: remove `return`
+   |
+LL -     return true;
+LL +     true
+   |
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:32:5
@@ -13,7 +17,11 @@ error: unneeded `return` statement
 LL |     return true;
    |     ^^^^^^^^^^^
    |
-   = help: remove `return`
+help: remove `return`
+   |
+LL -     return true;
+LL +     true
+   |
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:37:5
@@ -21,7 +29,11 @@ error: unneeded `return` statement
 LL |     return true;;;
    |     ^^^^^^^^^^^
    |
-   = help: remove `return`
+help: remove `return`
+   |
+LL -     return true;;;
+LL +     true
+   |
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:42:5
@@ -29,7 +41,11 @@ error: unneeded `return` statement
 LL |     return true;; ; ;
    |     ^^^^^^^^^^^
    |
-   = help: remove `return`
+help: remove `return`
+   |
+LL -     return true;; ; ;
+LL +     true
+   |
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:47:9
@@ -37,7 +53,11 @@ error: unneeded `return` statement
 LL |         return true;
    |         ^^^^^^^^^^^
    |
-   = help: remove `return`
+help: remove `return`
+   |
+LL -         return true;
+LL +         true
+   |
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:49:9
@@ -45,7 +65,11 @@ error: unneeded `return` statement
 LL |         return false;
    |         ^^^^^^^^^^^^
    |
-   = help: remove `return`
+help: remove `return`
+   |
+LL -         return false;
+LL +         false
+   |
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:55:17
@@ -53,7 +77,10 @@ error: unneeded `return` statement
 LL |         true => return false,
    |                 ^^^^^^^^^^^^
    |
-   = help: remove `return`
+help: remove `return`
+   |
+LL |         true => false,
+   |                 ~~~~~
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:57:13
@@ -61,7 +88,11 @@ error: unneeded `return` statement
 LL |             return true;
    |             ^^^^^^^^^^^
    |
-   = help: remove `return`
+help: remove `return`
+   |
+LL -             return true;
+LL +             true
+   |
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:64:9
@@ -69,7 +100,11 @@ error: unneeded `return` statement
 LL |         return true;
    |         ^^^^^^^^^^^
    |
-   = help: remove `return`
+help: remove `return`
+   |
+LL -         return true;
+LL +         true
+   |
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:66:16
@@ -77,7 +112,10 @@ error: unneeded `return` statement
 LL |     let _ = || return true;
    |                ^^^^^^^^^^^
    |
-   = help: remove `return`
+help: remove `return`
+   |
+LL |     let _ = || true;
+   |                ~~~~
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:70:5
@@ -85,7 +123,11 @@ error: unneeded `return` statement
 LL |     return the_answer!();
    |     ^^^^^^^^^^^^^^^^^^^^
    |
-   = help: remove `return`
+help: remove `return`
+   |
+LL -     return the_answer!();
+LL +     the_answer!()
+   |
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:73:21
@@ -95,7 +137,12 @@ LL |   fn test_void_fun() {
 LL | |     return;
    | |__________^
    |
-   = help: remove `return`
+help: remove `return`
+   |
+LL - fn test_void_fun() {
+LL -     return;
+LL + fn test_void_fun() {
+   |
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:78:11
@@ -105,7 +152,12 @@ LL |       if b {
 LL | |         return;
    | |______________^
    |
-   = help: remove `return`
+help: remove `return`
+   |
+LL -     if b {
+LL -         return;
+LL +     if b {
+   |
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:80:13
@@ -115,7 +167,12 @@ LL |       } else {
 LL | |         return;
    | |______________^
    |
-   = help: remove `return`
+help: remove `return`
+   |
+LL -     } else {
+LL -         return;
+LL +     } else {
+   |
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:88:14
@@ -123,7 +180,10 @@ error: unneeded `return` statement
 LL |         _ => return,
    |              ^^^^^^
    |
-   = help: replace `return` with a unit value
+help: replace `return` with a unit value
+   |
+LL |         _ => (),
+   |              ~~
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:96:24
@@ -133,7 +193,12 @@ LL |               let _ = 42;
 LL | |             return;
    | |__________________^
    |
-   = help: remove `return`
+help: remove `return`
+   |
+LL -             let _ = 42;
+LL -             return;
+LL +             let _ = 42;
+   |
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:99:14
@@ -141,7 +206,10 @@ error: unneeded `return` statement
 LL |         _ => return,
    |              ^^^^^^
    |
-   = help: replace `return` with a unit value
+help: replace `return` with a unit value
+   |
+LL |         _ => (),
+   |              ~~
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:112:9
@@ -149,7 +217,11 @@ error: unneeded `return` statement
 LL |         return String::from("test");
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: remove `return`
+help: remove `return`
+   |
+LL -         return String::from("test");
+LL +         String::from("test")
+   |
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:114:9
@@ -157,7 +229,11 @@ error: unneeded `return` statement
 LL |         return String::new();
    |         ^^^^^^^^^^^^^^^^^^^^
    |
-   = help: remove `return`
+help: remove `return`
+   |
+LL -         return String::new();
+LL +         String::new()
+   |
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:136:32
@@ -165,7 +241,10 @@ error: unneeded `return` statement
 LL |         bar.unwrap_or_else(|_| return)
    |                                ^^^^^^
    |
-   = help: replace `return` with an empty block
+help: replace `return` with an empty block
+   |
+LL |         bar.unwrap_or_else(|_| {})
+   |                                ~~
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:140:21
@@ -175,7 +254,12 @@ LL |           let _ = || {
 LL | |             return;
    | |__________________^
    |
-   = help: remove `return`
+help: remove `return`
+   |
+LL -         let _ = || {
+LL -             return;
+LL +         let _ = || {
+   |
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:143:20
@@ -183,7 +267,10 @@ error: unneeded `return` statement
 LL |         let _ = || return;
    |                    ^^^^^^
    |
-   = help: replace `return` with an empty block
+help: replace `return` with an empty block
+   |
+LL |         let _ = || {};
+   |                    ~~
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:149:32
@@ -191,7 +278,10 @@ error: unneeded `return` statement
 LL |         res.unwrap_or_else(|_| return Foo)
    |                                ^^^^^^^^^^
    |
-   = help: remove `return`
+help: remove `return`
+   |
+LL |         res.unwrap_or_else(|_| Foo)
+   |                                ~~~
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:158:5
@@ -199,7 +289,11 @@ error: unneeded `return` statement
 LL |     return true;
    |     ^^^^^^^^^^^
    |
-   = help: remove `return`
+help: remove `return`
+   |
+LL -     return true;
+LL +     true
+   |
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:162:5
@@ -207,7 +301,11 @@ error: unneeded `return` statement
 LL |     return true;
    |     ^^^^^^^^^^^
    |
-   = help: remove `return`
+help: remove `return`
+   |
+LL -     return true;
+LL +     true
+   |
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:167:9
@@ -215,7 +313,11 @@ error: unneeded `return` statement
 LL |         return true;
    |         ^^^^^^^^^^^
    |
-   = help: remove `return`
+help: remove `return`
+   |
+LL -         return true;
+LL +         true
+   |
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:169:9
@@ -223,7 +325,11 @@ error: unneeded `return` statement
 LL |         return false;
    |         ^^^^^^^^^^^^
    |
-   = help: remove `return`
+help: remove `return`
+   |
+LL -         return false;
+LL +         false
+   |
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:175:17
@@ -231,7 +337,10 @@ error: unneeded `return` statement
 LL |         true => return false,
    |                 ^^^^^^^^^^^^
    |
-   = help: remove `return`
+help: remove `return`
+   |
+LL |         true => false,
+   |                 ~~~~~
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:177:13
@@ -239,7 +348,11 @@ error: unneeded `return` statement
 LL |             return true;
    |             ^^^^^^^^^^^
    |
-   = help: remove `return`
+help: remove `return`
+   |
+LL -             return true;
+LL +             true
+   |
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:184:9
@@ -247,7 +360,11 @@ error: unneeded `return` statement
 LL |         return true;
    |         ^^^^^^^^^^^
    |
-   = help: remove `return`
+help: remove `return`
+   |
+LL -         return true;
+LL +         true
+   |
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:186:16
@@ -255,7 +372,10 @@ error: unneeded `return` statement
 LL |     let _ = || return true;
    |                ^^^^^^^^^^^
    |
-   = help: remove `return`
+help: remove `return`
+   |
+LL |     let _ = || true;
+   |                ~~~~
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:190:5
@@ -263,7 +383,11 @@ error: unneeded `return` statement
 LL |     return the_answer!();
    |     ^^^^^^^^^^^^^^^^^^^^
    |
-   = help: remove `return`
+help: remove `return`
+   |
+LL -     return the_answer!();
+LL +     the_answer!()
+   |
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:193:33
@@ -273,7 +397,12 @@ LL |   async fn async_test_void_fun() {
 LL | |     return;
    | |__________^
    |
-   = help: remove `return`
+help: remove `return`
+   |
+LL - async fn async_test_void_fun() {
+LL -     return;
+LL + async fn async_test_void_fun() {
+   |
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:198:11
@@ -283,7 +412,12 @@ LL |       if b {
 LL | |         return;
    | |______________^
    |
-   = help: remove `return`
+help: remove `return`
+   |
+LL -     if b {
+LL -         return;
+LL +     if b {
+   |
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:200:13
@@ -293,7 +427,12 @@ LL |       } else {
 LL | |         return;
    | |______________^
    |
-   = help: remove `return`
+help: remove `return`
+   |
+LL -     } else {
+LL -         return;
+LL +     } else {
+   |
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:208:14
@@ -301,7 +440,10 @@ error: unneeded `return` statement
 LL |         _ => return,
    |              ^^^^^^
    |
-   = help: replace `return` with a unit value
+help: replace `return` with a unit value
+   |
+LL |         _ => (),
+   |              ~~
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:221:9
@@ -309,7 +451,11 @@ error: unneeded `return` statement
 LL |         return String::from("test");
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: remove `return`
+help: remove `return`
+   |
+LL -         return String::from("test");
+LL +         String::from("test")
+   |
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:223:9
@@ -317,7 +463,11 @@ error: unneeded `return` statement
 LL |         return String::new();
    |         ^^^^^^^^^^^^^^^^^^^^
    |
-   = help: remove `return`
+help: remove `return`
+   |
+LL -         return String::new();
+LL +         String::new()
+   |
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:239:5
@@ -325,7 +475,11 @@ error: unneeded `return` statement
 LL |     return format!("Hello {}", "world!");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: remove `return`
+help: remove `return`
+   |
+LL -     return format!("Hello {}", "world!");
+LL +     format!("Hello {}", "world!")
+   |
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:251:9
@@ -333,7 +487,13 @@ error: unneeded `return` statement
 LL |         return true;
    |         ^^^^^^^^^^^
    |
-   = help: remove `return`
+help: remove `return`
+   |
+LL ~         true
+LL |     } else {
+LL |         return false;
+LL ~     }
+   |
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:253:9
@@ -341,7 +501,11 @@ error: unneeded `return` statement
 LL |         return false;
    |         ^^^^^^^^^^^^
    |
-   = help: remove `return`
+help: remove `return`
+   |
+LL ~         false
+LL ~     }
+   |
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:260:13
@@ -349,7 +513,14 @@ error: unneeded `return` statement
 LL |             return 10;
    |             ^^^^^^^^^
    |
-   = help: remove `return`
+help: remove `return`
+   |
+LL ~             10
+LL |         },
+ ...
+LL |         },
+LL ~     }
+   |
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:263:13
@@ -357,7 +528,12 @@ error: unneeded `return` statement
 LL |             return 100;
    |             ^^^^^^^^^^
    |
-   = help: remove `return`
+help: remove `return`
+   |
+LL ~             100
+LL |         },
+LL ~     }
+   |
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:271:9
@@ -365,7 +541,11 @@ error: unneeded `return` statement
 LL |         return 0;
    |         ^^^^^^^^
    |
-   = help: remove `return`
+help: remove `return`
+   |
+LL ~         0
+LL ~     }
+   |
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:278:13
@@ -373,7 +553,14 @@ error: unneeded `return` statement
 LL |             return *(x as *const isize);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: remove `return`
+help: remove `return`
+   |
+LL ~             *(x as *const isize)
+LL |         } else {
+LL |             return !*(x as *const isize);
+LL ~         }
+LL ~     }
+   |
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:280:13
@@ -381,7 +568,12 @@ error: unneeded `return` statement
 LL |             return !*(x as *const isize);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: remove `return`
+help: remove `return`
+   |
+LL ~             !*(x as *const isize)
+LL ~         }
+LL ~     }
+   |
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:287:20
@@ -392,7 +584,13 @@ LL | |
 LL | |         return;
    | |______________^
    |
-   = help: remove `return`
+help: remove `return`
+   |
+LL -         let _ = 42;
+LL - 
+LL -         return;
+LL +         let _ = 42;
+   |
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:294:20
@@ -400,7 +598,11 @@ error: unneeded `return` statement
 LL |         let _ = 42; return;
    |                    ^^^^^^^
    |
-   = help: remove `return`
+help: remove `return`
+   |
+LL -         let _ = 42; return;
+LL +         let _ = 42;
+   |
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:306:9
@@ -408,7 +610,11 @@ error: unneeded `return` statement
 LL |         return Ok(format!("ok!"));
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: remove `return`
+help: remove `return`
+   |
+LL -         return Ok(format!("ok!"));
+LL +         Ok(format!("ok!"))
+   |
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:308:9
@@ -416,7 +622,11 @@ error: unneeded `return` statement
 LL |         return Err(format!("err!"));
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: remove `return`
+help: remove `return`
+   |
+LL -         return Err(format!("err!"));
+LL +         Err(format!("err!"))
+   |
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:314:9
@@ -424,7 +634,11 @@ error: unneeded `return` statement
 LL |         return if true { 1 } else { 2 };
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: remove `return`
+help: remove `return`
+   |
+LL -         return if true { 1 } else { 2 };
+LL +         if true { 1 } else { 2 }
+   |
 
 error: unneeded `return` statement
   --> $DIR/needless_return.rs:318:9
@@ -432,7 +646,11 @@ error: unneeded `return` statement
 LL |         return if b1 { 0 } else { 1 } | if b2 { 2 } else { 3 } | if b3 { 4 } else { 5 };
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: remove `return` and wrap the sequence with parentheses
+help: remove `return` and wrap the sequence with parentheses
+   |
+LL -         return if b1 { 0 } else { 1 } | if b2 { 2 } else { 3 } | if b3 { 4 } else { 5 };
+LL +         (if b1 { 0 } else { 1 } | if b2 { 2 } else { 3 } | if b3 { 4 } else { 5 })
+   |
 
 error: aborting due to 52 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 516f4f6aef224137a84f4033935f5e9cb359b273 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Mon, 22 May 2023 23:52:37 +0200
Subject: new lint: `explicit_into_iter_fn_arg`

---
 CHANGELOG.md                                  |   1 +
 clippy_lints/src/declared_lints.rs            |   1 +
 clippy_lints/src/explicit_into_iter_fn_arg.rs | 144 ++++++++++++++++++++++++++
 clippy_lints/src/lib.rs                       |   2 +
 tests/ui/explicit_into_iter_fn_arg.fixed      |  24 +++++
 tests/ui/explicit_into_iter_fn_arg.rs         |  24 +++++
 tests/ui/explicit_into_iter_fn_arg.stderr     |  39 +++++++
 7 files changed, 235 insertions(+)
 create mode 100644 clippy_lints/src/explicit_into_iter_fn_arg.rs
 create mode 100644 tests/ui/explicit_into_iter_fn_arg.fixed
 create mode 100644 tests/ui/explicit_into_iter_fn_arg.rs
 create mode 100644 tests/ui/explicit_into_iter_fn_arg.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index a2648d9faa6..7a127c08197 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4642,6 +4642,7 @@ Released 2018-09-13
 [`explicit_auto_deref`]: https://rust-lang.github.io/rust-clippy/master/index.html#explicit_auto_deref
 [`explicit_counter_loop`]: https://rust-lang.github.io/rust-clippy/master/index.html#explicit_counter_loop
 [`explicit_deref_methods`]: https://rust-lang.github.io/rust-clippy/master/index.html#explicit_deref_methods
+[`explicit_into_iter_fn_arg`]: https://rust-lang.github.io/rust-clippy/master/index.html#explicit_into_iter_fn_arg
 [`explicit_into_iter_loop`]: https://rust-lang.github.io/rust-clippy/master/index.html#explicit_into_iter_loop
 [`explicit_iter_loop`]: https://rust-lang.github.io/rust-clippy/master/index.html#explicit_iter_loop
 [`explicit_write`]: https://rust-lang.github.io/rust-clippy/master/index.html#explicit_write
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 4ade25e1257..fceb6e4b2ae 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -157,6 +157,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::exhaustive_items::EXHAUSTIVE_ENUMS_INFO,
     crate::exhaustive_items::EXHAUSTIVE_STRUCTS_INFO,
     crate::exit::EXIT_INFO,
+    crate::explicit_into_iter_fn_arg::EXPLICIT_INTO_ITER_FN_ARG_INFO,
     crate::explicit_write::EXPLICIT_WRITE_INFO,
     crate::extra_unused_type_parameters::EXTRA_UNUSED_TYPE_PARAMETERS_INFO,
     crate::fallible_impl_from::FALLIBLE_IMPL_FROM_INFO,
diff --git a/clippy_lints/src/explicit_into_iter_fn_arg.rs b/clippy_lints/src/explicit_into_iter_fn_arg.rs
new file mode 100644
index 00000000000..007a3f43449
--- /dev/null
+++ b/clippy_lints/src/explicit_into_iter_fn_arg.rs
@@ -0,0 +1,144 @@
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::source::snippet;
+use clippy_utils::{get_parent_expr, is_trait_method};
+use rustc_errors::Applicability;
+use rustc_hir::def_id::DefId;
+use rustc_hir::*;
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::sym;
+use rustc_span::Span;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for calls to [`IntoIterator::into_iter`](https://doc.rust-lang.org/stable/std/iter/trait.IntoIterator.html#tymethod.into_iter)
+    /// in a call argument that accepts `IntoIterator`.
+    ///
+    /// ### Why is this bad?
+    /// If a function has a generic parameter with an `IntoIterator` trait bound, it means that the function
+    /// will *have* to call `.into_iter()` to get an iterator out of it, thereby making the call to `.into_iter()`
+    /// at call site redundant.
+    ///
+    /// Consider this example:
+    /// ```rs,ignore
+    /// fn foo<T: IntoIterator<Item = u32>>(iter: T) {
+    ///   let it = iter.into_iter();
+    ///                ^^^^^^^^^^^^ the function has to call `.into_iter()` to get the iterator
+    /// }
+    ///
+    /// foo(vec![1, 2, 3].into_iter());
+    ///                  ^^^^^^^^^^^^ ... making this `.into_iter()` call redundant.
+    /// ```
+    ///
+    /// The reason for why calling `.into_iter()` twice (once at call site and again inside of the function) works in the first place
+    /// is because there is a blanket implementation of `IntoIterator` for all types that implement `Iterator` in the standard library,
+    /// in which it simply returns itself, effectively making the second call to `.into_iter()` a "no-op":
+    /// ```rust,ignore
+    /// impl<I: Iterator> IntoIterator for I {
+    ///     type Item = I::Item;
+    ///     type IntoIter = I;
+    ///
+    ///     fn into_iter(self) -> I {
+    ///        self
+    ///     }
+    /// }
+    /// ```
+    ///
+    /// ### Example
+    /// ```rust
+    /// fn even_sum<I: IntoIterator<Item = u32>>(iter: I) -> u32 {
+    ///     iter.into_iter().filter(|&x| x % 2 == 0).sum()
+    /// }
+    ///
+    /// let _ = even_sum(vec![1, 2, 3].into_iter());
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// fn even_sum<I: IntoIterator<Item = u32>>(iter: I) -> u32 {
+    ///     iter.into_iter().filter(|&x| x % 2 == 0).sum()
+    /// }
+    ///
+    /// let _ = even_sum(vec![1, 2, 3]);
+    /// ```
+    #[clippy::version = "1.71.0"]
+    pub EXPLICIT_INTO_ITER_FN_ARG,
+    pedantic,
+    "explicit call to `.into_iter()` in function argument accepting `IntoIterator`"
+}
+declare_lint_pass!(ExplicitIntoIterFnArg => [EXPLICIT_INTO_ITER_FN_ARG]);
+
+enum MethodOrFunction {
+    Method,
+    Function,
+}
+
+/// Returns the span of the `IntoIterator` trait bound in the function pointed to by `fn_did`
+fn into_iter_bound(cx: &LateContext<'_>, fn_did: DefId, param_index: u32) -> Option<Span> {
+    if let Some(into_iter_did) = cx.tcx.get_diagnostic_item(sym::IntoIterator) {
+        cx.tcx
+            .predicates_of(fn_did)
+            .predicates
+            .iter()
+            .find_map(|&(ref pred, span)| {
+                if let ty::PredicateKind::Clause(ty::Clause::Trait(tr)) = pred.kind().skip_binder()
+                    && tr.def_id() == into_iter_did
+                    && tr.self_ty().is_param(param_index)
+                {
+                    Some(span)
+                } else {
+                    None
+                }
+            })
+    } else {
+        None
+    }
+}
+
+impl<'tcx> LateLintPass<'tcx> for ExplicitIntoIterFnArg {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        if expr.span.from_expansion() {
+            return;
+        }
+
+        if let ExprKind::MethodCall(name, recv, ..) = expr.kind
+            && is_trait_method(cx, expr, sym::IntoIterator)
+            && name.ident.name == sym::into_iter
+            && let Some(parent_expr) = get_parent_expr(cx, expr)
+        {
+            let parent_expr = match parent_expr.kind {
+                ExprKind::Call(recv, args) if let ExprKind::Path(ref qpath) = recv.kind => {
+                    cx.qpath_res(qpath, recv.hir_id).opt_def_id()
+                        .map(|did| (did, args, MethodOrFunction::Function))
+                }
+                ExprKind::MethodCall(.., args, _) => {
+                    cx.typeck_results().type_dependent_def_id(parent_expr.hir_id)
+                        .map(|did| (did, args, MethodOrFunction::Method))
+                }
+                _ => None,
+            };
+
+            if let Some((parent_fn_did, args, kind)) = parent_expr
+                && let sig = cx.tcx.fn_sig(parent_fn_did).skip_binder().skip_binder()
+                && let Some(arg_pos) = args.iter().position(|x| x.hir_id == expr.hir_id)
+                && let Some(&into_iter_param) = sig.inputs().get(match kind {
+                    MethodOrFunction::Function => arg_pos,
+                    MethodOrFunction::Method => arg_pos + 1, // skip self arg
+                })
+                && let ty::Param(param) = into_iter_param.kind()
+                && let Some(span) = into_iter_bound(cx, parent_fn_did, param.index)
+            {
+                let sugg = snippet(cx, recv.span.source_callsite(), "<expr>").into_owned();
+                span_lint_and_then(cx, EXPLICIT_INTO_ITER_FN_ARG, expr.span, "explicit call to `.into_iter()` in function argument accepting `IntoIterator`", |diag| {
+                    diag.span_suggestion(
+                        expr.span,
+                        "consider removing `.into_iter()`",
+                        sugg,
+                        Applicability::MachineApplicable,
+                    );
+                    diag.span_note(span, "this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`");
+                });
+            }
+        }
+    }
+}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 10404d51ba5..bfe52e182b2 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -123,6 +123,7 @@ mod eta_reduction;
 mod excessive_bools;
 mod exhaustive_items;
 mod exit;
+mod explicit_into_iter_fn_arg;
 mod explicit_write;
 mod extra_unused_type_parameters;
 mod fallible_impl_from;
@@ -994,6 +995,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_early_pass(|| Box::new(ref_patterns::RefPatterns));
     store.register_late_pass(|_| Box::new(default_constructed_unit_structs::DefaultConstructedUnitStructs));
     store.register_early_pass(|| Box::new(needless_else::NeedlessElse));
+    store.register_late_pass(|_| Box::new(explicit_into_iter_fn_arg::ExplicitIntoIterFnArg));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/tests/ui/explicit_into_iter_fn_arg.fixed b/tests/ui/explicit_into_iter_fn_arg.fixed
new file mode 100644
index 00000000000..219b60bd051
--- /dev/null
+++ b/tests/ui/explicit_into_iter_fn_arg.fixed
@@ -0,0 +1,24 @@
+//@run-rustfix
+
+#![allow(unused)]
+#![warn(clippy::explicit_into_iter_fn_arg)]
+
+fn a<T>(_: T) {}
+fn b<T: IntoIterator<Item = i32>>(_: T) {}
+fn c(_: impl IntoIterator<Item = i32>) {}
+fn d<T>(_: T)
+where
+    T: IntoIterator<Item = i32>,
+{
+}
+fn e<T: IntoIterator<Item = i32>>(_: T) {}
+fn f(_: std::vec::IntoIter<i32>) {}
+
+fn main() {
+    a(vec![1, 2].into_iter());
+    b(vec![1, 2]);
+    c(vec![1, 2]);
+    d(vec![1, 2]);
+    e([&1, &2, &3].into_iter().cloned());
+    f(vec![1, 2].into_iter());
+}
diff --git a/tests/ui/explicit_into_iter_fn_arg.rs b/tests/ui/explicit_into_iter_fn_arg.rs
new file mode 100644
index 00000000000..358f4bc661d
--- /dev/null
+++ b/tests/ui/explicit_into_iter_fn_arg.rs
@@ -0,0 +1,24 @@
+//@run-rustfix
+
+#![allow(unused)]
+#![warn(clippy::explicit_into_iter_fn_arg)]
+
+fn a<T>(_: T) {}
+fn b<T: IntoIterator<Item = i32>>(_: T) {}
+fn c(_: impl IntoIterator<Item = i32>) {}
+fn d<T>(_: T)
+where
+    T: IntoIterator<Item = i32>,
+{
+}
+fn e<T: IntoIterator<Item = i32>>(_: T) {}
+fn f(_: std::vec::IntoIter<i32>) {}
+
+fn main() {
+    a(vec![1, 2].into_iter());
+    b(vec![1, 2].into_iter());
+    c(vec![1, 2].into_iter());
+    d(vec![1, 2].into_iter());
+    e([&1, &2, &3].into_iter().cloned());
+    f(vec![1, 2].into_iter());
+}
diff --git a/tests/ui/explicit_into_iter_fn_arg.stderr b/tests/ui/explicit_into_iter_fn_arg.stderr
new file mode 100644
index 00000000000..a0bd81c21ea
--- /dev/null
+++ b/tests/ui/explicit_into_iter_fn_arg.stderr
@@ -0,0 +1,39 @@
+error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
+  --> $DIR/explicit_into_iter_fn_arg.rs:19:7
+   |
+LL |     b(vec![1, 2].into_iter());
+   |       ^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `vec![1, 2]`
+   |
+note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
+  --> $DIR/explicit_into_iter_fn_arg.rs:7:9
+   |
+LL | fn b<T: IntoIterator<Item = i32>>(_: T) {}
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^
+   = note: `-D clippy::explicit-into-iter-fn-arg` implied by `-D warnings`
+
+error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
+  --> $DIR/explicit_into_iter_fn_arg.rs:20:7
+   |
+LL |     c(vec![1, 2].into_iter());
+   |       ^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `vec![1, 2]`
+   |
+note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
+  --> $DIR/explicit_into_iter_fn_arg.rs:8:14
+   |
+LL | fn c(_: impl IntoIterator<Item = i32>) {}
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
+  --> $DIR/explicit_into_iter_fn_arg.rs:21:7
+   |
+LL |     d(vec![1, 2].into_iter());
+   |       ^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `vec![1, 2]`
+   |
+note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
+  --> $DIR/explicit_into_iter_fn_arg.rs:11:8
+   |
+LL |     T: IntoIterator<Item = i32>,
+   |        ^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 3 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 0181d772a4a9702c3ef2fbe5b1b0bf0d94b8fcd7 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Tue, 23 May 2023 16:56:13 +0200
Subject: dogfood

---
 clippy_lints/src/booleans.rs                  | 2 +-
 clippy_lints/src/explicit_into_iter_fn_arg.rs | 2 +-
 clippy_lints/src/loops/manual_memcpy.rs       | 4 ++--
 3 files changed, 4 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/booleans.rs b/clippy_lints/src/booleans.rs
index 455f0df7cd0..a08113bf9e6 100644
--- a/clippy_lints/src/booleans.rs
+++ b/clippy_lints/src/booleans.rs
@@ -441,7 +441,7 @@ impl<'a, 'tcx> NonminimalBoolVisitor<'a, 'tcx> {
                             diag.span_suggestions(
                                 e.span,
                                 "try",
-                                suggestions.into_iter(),
+                                suggestions,
                                 // nonminimal_bool can produce minimal but
                                 // not human readable expressions (#3141)
                                 Applicability::Unspecified,
diff --git a/clippy_lints/src/explicit_into_iter_fn_arg.rs b/clippy_lints/src/explicit_into_iter_fn_arg.rs
index 007a3f43449..a56d72f0dea 100644
--- a/clippy_lints/src/explicit_into_iter_fn_arg.rs
+++ b/clippy_lints/src/explicit_into_iter_fn_arg.rs
@@ -3,7 +3,7 @@ use clippy_utils::source::snippet;
 use clippy_utils::{get_parent_expr, is_trait_method};
 use rustc_errors::Applicability;
 use rustc_hir::def_id::DefId;
-use rustc_hir::*;
+use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
diff --git a/clippy_lints/src/loops/manual_memcpy.rs b/clippy_lints/src/loops/manual_memcpy.rs
index d4c3f76b864..7d1f8ef29c8 100644
--- a/clippy_lints/src/loops/manual_memcpy.rs
+++ b/clippy_lints/src/loops/manual_memcpy.rs
@@ -51,7 +51,7 @@ pub(super) fn check<'tcx>(
                 iter_b = Some(get_assignment(body));
             }
 
-            let assignments = iter_a.into_iter().flatten().chain(iter_b.into_iter());
+            let assignments = iter_a.into_iter().flatten().chain(iter_b);
 
             let big_sugg = assignments
                 // The only statements in the for loops can be indexed assignments from
@@ -402,7 +402,7 @@ fn get_assignments<'a, 'tcx>(
             StmtKind::Local(..) | StmtKind::Item(..) => None,
             StmtKind::Expr(e) | StmtKind::Semi(e) => Some(e),
         })
-        .chain((*expr).into_iter())
+        .chain(*expr)
         .filter(move |e| {
             if let ExprKind::AssignOp(_, place, _) = e.kind {
                 path_to_local(place).map_or(false, |id| {
-- 
cgit 1.4.1-3-g733a5


From 6a76101d3a46fb1dc21b2ee3044dfac30e3d9a1d Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Wed, 24 May 2023 15:56:28 +0200
Subject: update docs, simplify arg->param map, dont lint on chain

---
 clippy_lints/src/explicit_into_iter_fn_arg.rs | 124 +++++++++++++-------------
 tests/ui/explicit_into_iter_fn_arg.fixed      |  17 +++-
 tests/ui/explicit_into_iter_fn_arg.rs         |  17 +++-
 tests/ui/explicit_into_iter_fn_arg.stderr     |   6 +-
 4 files changed, 90 insertions(+), 74 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/explicit_into_iter_fn_arg.rs b/clippy_lints/src/explicit_into_iter_fn_arg.rs
index a56d72f0dea..ff4144df9b9 100644
--- a/clippy_lints/src/explicit_into_iter_fn_arg.rs
+++ b/clippy_lints/src/explicit_into_iter_fn_arg.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::source::snippet;
+use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::{get_parent_expr, is_trait_method};
 use rustc_errors::Applicability;
 use rustc_hir::def_id::DefId;
@@ -16,50 +16,26 @@ declare_clippy_lint! {
     /// in a call argument that accepts `IntoIterator`.
     ///
     /// ### Why is this bad?
-    /// If a function has a generic parameter with an `IntoIterator` trait bound, it means that the function
-    /// will *have* to call `.into_iter()` to get an iterator out of it, thereby making the call to `.into_iter()`
-    /// at call site redundant.
-    ///
-    /// Consider this example:
-    /// ```rs,ignore
-    /// fn foo<T: IntoIterator<Item = u32>>(iter: T) {
-    ///   let it = iter.into_iter();
-    ///                ^^^^^^^^^^^^ the function has to call `.into_iter()` to get the iterator
-    /// }
-    ///
-    /// foo(vec![1, 2, 3].into_iter());
-    ///                  ^^^^^^^^^^^^ ... making this `.into_iter()` call redundant.
-    /// ```
-    ///
-    /// The reason for why calling `.into_iter()` twice (once at call site and again inside of the function) works in the first place
-    /// is because there is a blanket implementation of `IntoIterator` for all types that implement `Iterator` in the standard library,
-    /// in which it simply returns itself, effectively making the second call to `.into_iter()` a "no-op":
-    /// ```rust,ignore
-    /// impl<I: Iterator> IntoIterator for I {
-    ///     type Item = I::Item;
-    ///     type IntoIter = I;
-    ///
-    ///     fn into_iter(self) -> I {
-    ///        self
-    ///     }
-    /// }
-    /// ```
+    /// If a generic parameter has an `IntoIterator` bound, there is no need to call `.into_iter()` at call site.
+    /// Calling `IntoIterator::into_iter()` on a value implies that its type already implements `IntoIterator`,
+    /// so you can just pass the value as is.
     ///
     /// ### Example
     /// ```rust
-    /// fn even_sum<I: IntoIterator<Item = u32>>(iter: I) -> u32 {
+    /// fn even_sum<I: IntoIterator<Item = i32>>(iter: I) -> i32 {
     ///     iter.into_iter().filter(|&x| x % 2 == 0).sum()
     /// }
     ///
-    /// let _ = even_sum(vec![1, 2, 3].into_iter());
+    /// let _ = even_sum([1, 2, 3].into_iter());
+    /// //                        ^^^^^^^^^^^^ redundant. `[i32; 3]` implements `IntoIterator`
     /// ```
     /// Use instead:
     /// ```rust
-    /// fn even_sum<I: IntoIterator<Item = u32>>(iter: I) -> u32 {
+    /// fn even_sum<I: IntoIterator<Item = i32>>(iter: I) -> i32 {
     ///     iter.into_iter().filter(|&x| x % 2 == 0).sum()
     /// }
     ///
-    /// let _ = even_sum(vec![1, 2, 3]);
+    /// let _ = even_sum([1, 2, 3]);
     /// ```
     #[clippy::version = "1.71.0"]
     pub EXPLICIT_INTO_ITER_FN_ARG,
@@ -73,23 +49,41 @@ enum MethodOrFunction {
     Function,
 }
 
+impl MethodOrFunction {
+    /// Maps the argument position in `pos` to the parameter position.
+    /// For methods, `self` is skipped.
+    fn param_pos(self, pos: usize) -> usize {
+        match self {
+            MethodOrFunction::Method => pos + 1,
+            MethodOrFunction::Function => pos,
+        }
+    }
+}
+
 /// Returns the span of the `IntoIterator` trait bound in the function pointed to by `fn_did`
-fn into_iter_bound(cx: &LateContext<'_>, fn_did: DefId, param_index: u32) -> Option<Span> {
-    if let Some(into_iter_did) = cx.tcx.get_diagnostic_item(sym::IntoIterator) {
-        cx.tcx
-            .predicates_of(fn_did)
-            .predicates
-            .iter()
-            .find_map(|&(ref pred, span)| {
-                if let ty::PredicateKind::Clause(ty::Clause::Trait(tr)) = pred.kind().skip_binder()
-                    && tr.def_id() == into_iter_did
-                    && tr.self_ty().is_param(param_index)
-                {
-                    Some(span)
-                } else {
-                    None
-                }
-            })
+fn into_iter_bound(cx: &LateContext<'_>, fn_did: DefId, into_iter_did: DefId, param_index: u32) -> Option<Span> {
+    cx.tcx
+        .predicates_of(fn_did)
+        .predicates
+        .iter()
+        .find_map(|&(ref pred, span)| {
+            if let ty::PredicateKind::Clause(ty::Clause::Trait(tr)) = pred.kind().skip_binder()
+                && tr.def_id() == into_iter_did
+                && tr.self_ty().is_param(param_index)
+            {
+                Some(span)
+            } else {
+                None
+            }
+        })
+}
+
+fn into_iter_call<'hir>(cx: &LateContext<'_>, expr: &'hir Expr<'hir>) -> Option<&'hir Expr<'hir>> {
+    if let ExprKind::MethodCall(name, recv, _, _) = expr.kind
+        && is_trait_method(cx, expr, sym::IntoIterator)
+        && name.ident.name == sym::into_iter
+    {
+        Some(recv)
     } else {
         None
     }
@@ -101,40 +95,44 @@ impl<'tcx> LateLintPass<'tcx> for ExplicitIntoIterFnArg {
             return;
         }
 
-        if let ExprKind::MethodCall(name, recv, ..) = expr.kind
-            && is_trait_method(cx, expr, sym::IntoIterator)
-            && name.ident.name == sym::into_iter
-            && let Some(parent_expr) = get_parent_expr(cx, expr)
+        if let Some(recv) = into_iter_call(cx, expr)
+            && let Some(parent) = get_parent_expr(cx, expr)
+            // Make sure that this is not a chained into_iter call (i.e. `x.into_iter().into_iter()`)
+            // That case is already covered by `useless_conversion` and we don't want to lint twice
+            // with two contradicting suggestions.
+            && into_iter_call(cx, parent).is_none()
+            && into_iter_call(cx, recv).is_none()
+            && let Some(into_iter_did) = cx.tcx.get_diagnostic_item(sym::IntoIterator)
         {
-            let parent_expr = match parent_expr.kind {
+
+            let parent = match parent.kind {
                 ExprKind::Call(recv, args) if let ExprKind::Path(ref qpath) = recv.kind => {
                     cx.qpath_res(qpath, recv.hir_id).opt_def_id()
                         .map(|did| (did, args, MethodOrFunction::Function))
                 }
                 ExprKind::MethodCall(.., args, _) => {
-                    cx.typeck_results().type_dependent_def_id(parent_expr.hir_id)
+                    cx.typeck_results().type_dependent_def_id(parent.hir_id)
                         .map(|did| (did, args, MethodOrFunction::Method))
                 }
                 _ => None,
             };
 
-            if let Some((parent_fn_did, args, kind)) = parent_expr
+            if let Some((parent_fn_did, args, kind)) = parent
                 && let sig = cx.tcx.fn_sig(parent_fn_did).skip_binder().skip_binder()
                 && let Some(arg_pos) = args.iter().position(|x| x.hir_id == expr.hir_id)
-                && let Some(&into_iter_param) = sig.inputs().get(match kind {
-                    MethodOrFunction::Function => arg_pos,
-                    MethodOrFunction::Method => arg_pos + 1, // skip self arg
-                })
+                && let Some(&into_iter_param) = sig.inputs().get(kind.param_pos(arg_pos))
                 && let ty::Param(param) = into_iter_param.kind()
-                && let Some(span) = into_iter_bound(cx, parent_fn_did, param.index)
+                && let Some(span) = into_iter_bound(cx, parent_fn_did, into_iter_did, param.index)
             {
-                let sugg = snippet(cx, recv.span.source_callsite(), "<expr>").into_owned();
+                let mut applicability = Applicability::MachineApplicable;
+                let sugg = snippet_with_applicability(cx, recv.span.source_callsite(), "<expr>", &mut applicability).into_owned();
+
                 span_lint_and_then(cx, EXPLICIT_INTO_ITER_FN_ARG, expr.span, "explicit call to `.into_iter()` in function argument accepting `IntoIterator`", |diag| {
                     diag.span_suggestion(
                         expr.span,
                         "consider removing `.into_iter()`",
                         sugg,
-                        Applicability::MachineApplicable,
+                        applicability,
                     );
                     diag.span_note(span, "this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`");
                 });
diff --git a/tests/ui/explicit_into_iter_fn_arg.fixed b/tests/ui/explicit_into_iter_fn_arg.fixed
index 219b60bd051..9d778faf8e0 100644
--- a/tests/ui/explicit_into_iter_fn_arg.fixed
+++ b/tests/ui/explicit_into_iter_fn_arg.fixed
@@ -1,6 +1,6 @@
 //@run-rustfix
 
-#![allow(unused)]
+#![allow(unused, clippy::useless_conversion)]
 #![warn(clippy::explicit_into_iter_fn_arg)]
 
 fn a<T>(_: T) {}
@@ -11,7 +11,6 @@ where
     T: IntoIterator<Item = i32>,
 {
 }
-fn e<T: IntoIterator<Item = i32>>(_: T) {}
 fn f(_: std::vec::IntoIter<i32>) {}
 
 fn main() {
@@ -19,6 +18,16 @@ fn main() {
     b(vec![1, 2]);
     c(vec![1, 2]);
     d(vec![1, 2]);
-    e([&1, &2, &3].into_iter().cloned());
-    f(vec![1, 2].into_iter());
+    b([&1, &2, &3].into_iter().cloned());
+
+    // Don't lint chained `.into_iter().into_iter()` calls. Covered by useless_conversion.
+    b(vec![1, 2].into_iter().into_iter());
+    b(vec![1, 2].into_iter().into_iter().into_iter());
+
+    macro_rules! macro_generated {
+        () => {
+            vec![1, 2].into_iter()
+        };
+    }
+    b(macro_generated!());
 }
diff --git a/tests/ui/explicit_into_iter_fn_arg.rs b/tests/ui/explicit_into_iter_fn_arg.rs
index 358f4bc661d..1e051fd06ec 100644
--- a/tests/ui/explicit_into_iter_fn_arg.rs
+++ b/tests/ui/explicit_into_iter_fn_arg.rs
@@ -1,6 +1,6 @@
 //@run-rustfix
 
-#![allow(unused)]
+#![allow(unused, clippy::useless_conversion)]
 #![warn(clippy::explicit_into_iter_fn_arg)]
 
 fn a<T>(_: T) {}
@@ -11,7 +11,6 @@ where
     T: IntoIterator<Item = i32>,
 {
 }
-fn e<T: IntoIterator<Item = i32>>(_: T) {}
 fn f(_: std::vec::IntoIter<i32>) {}
 
 fn main() {
@@ -19,6 +18,16 @@ fn main() {
     b(vec![1, 2].into_iter());
     c(vec![1, 2].into_iter());
     d(vec![1, 2].into_iter());
-    e([&1, &2, &3].into_iter().cloned());
-    f(vec![1, 2].into_iter());
+    b([&1, &2, &3].into_iter().cloned());
+
+    // Don't lint chained `.into_iter().into_iter()` calls. Covered by useless_conversion.
+    b(vec![1, 2].into_iter().into_iter());
+    b(vec![1, 2].into_iter().into_iter().into_iter());
+
+    macro_rules! macro_generated {
+        () => {
+            vec![1, 2].into_iter()
+        };
+    }
+    b(macro_generated!());
 }
diff --git a/tests/ui/explicit_into_iter_fn_arg.stderr b/tests/ui/explicit_into_iter_fn_arg.stderr
index a0bd81c21ea..14b95fb097a 100644
--- a/tests/ui/explicit_into_iter_fn_arg.stderr
+++ b/tests/ui/explicit_into_iter_fn_arg.stderr
@@ -1,5 +1,5 @@
 error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
-  --> $DIR/explicit_into_iter_fn_arg.rs:19:7
+  --> $DIR/explicit_into_iter_fn_arg.rs:18:7
    |
 LL |     b(vec![1, 2].into_iter());
    |       ^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `vec![1, 2]`
@@ -12,7 +12,7 @@ LL | fn b<T: IntoIterator<Item = i32>>(_: T) {}
    = note: `-D clippy::explicit-into-iter-fn-arg` implied by `-D warnings`
 
 error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
-  --> $DIR/explicit_into_iter_fn_arg.rs:20:7
+  --> $DIR/explicit_into_iter_fn_arg.rs:19:7
    |
 LL |     c(vec![1, 2].into_iter());
    |       ^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `vec![1, 2]`
@@ -24,7 +24,7 @@ LL | fn c(_: impl IntoIterator<Item = i32>) {}
    |              ^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
-  --> $DIR/explicit_into_iter_fn_arg.rs:21:7
+  --> $DIR/explicit_into_iter_fn_arg.rs:20:7
    |
 LL |     d(vec![1, 2].into_iter());
    |       ^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `vec![1, 2]`
-- 
cgit 1.4.1-3-g733a5


From 7f7979f80b9ff1d886701f2efccd72aa9921c9fa Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Wed, 24 May 2023 10:53:31 -0500
Subject: emit `unnecessary_cast` on raw pointers as well

---
 clippy_lints/src/casts/mod.rs              |  4 +-
 clippy_lints/src/casts/unnecessary_cast.rs | 38 +++++++++++++--
 tests/ui/as_ptr_cast_mut.stderr            | 16 ++++++-
 tests/ui/cast_slice_different_sizes.rs     |  2 +-
 tests/ui/crashes/ice-1782.rs               |  1 +
 tests/ui/from_raw_with_void_ptr.rs         |  1 +
 tests/ui/from_raw_with_void_ptr.stderr     | 20 ++++----
 tests/ui/transmute_ptr_to_ref.fixed        |  2 +-
 tests/ui/transmute_ptr_to_ref.rs           |  2 +-
 tests/ui/unnecessary_cast.fixed            | 14 ++++++
 tests/ui/unnecessary_cast.rs               | 14 ++++++
 tests/ui/unnecessary_cast.stderr           | 76 +++++++++++++++++-------------
 12 files changed, 138 insertions(+), 52 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index d62639caca1..bf38aab94a9 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -175,8 +175,8 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for casts to the same type, casts of int literals to integer types
-    /// and casts of float literals to float types.
+    /// Checks for casts to the same type, casts of int literals to integer types, casts of float
+    /// literals to float types and casts between raw pointers without changing type or constness.
     ///
     /// ### Why is this bad?
     /// It's just unnecessary.
diff --git a/clippy_lints/src/casts/unnecessary_cast.rs b/clippy_lints/src/casts/unnecessary_cast.rs
index 804ae841100..08ed8a63e1a 100644
--- a/clippy_lints/src/casts/unnecessary_cast.rs
+++ b/clippy_lints/src/casts/unnecessary_cast.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::numeric_literal::NumericLiteral;
 use clippy_utils::source::snippet_opt;
-use clippy_utils::{get_parent_expr, path_to_local};
+use clippy_utils::{get_parent_expr, is_ty_alias, path_to_local};
 use if_chain::if_chain;
 use rustc_ast::{LitFloatType, LitIntType, LitKind};
 use rustc_errors::Applicability;
@@ -20,6 +20,38 @@ pub(super) fn check<'tcx>(
     cast_from: Ty<'tcx>,
     cast_to: Ty<'tcx>,
 ) -> bool {
+    let cast_str = snippet_opt(cx, cast_expr.span).unwrap_or_default();
+
+    if_chain! {
+        if let ty::RawPtr(..) = cast_from.kind();
+        // check both mutability and type are the same
+        if cast_from.kind() == cast_to.kind();
+        if let ExprKind::Cast(_, cast_to_hir) = expr.kind;
+        then {
+            if_chain! {
+                if let TyKind::Path(qpath) = cast_to_hir.kind;
+                if is_ty_alias(&qpath);
+                then {
+                    return false;
+                }
+            }
+
+            if let TyKind::Infer = cast_to_hir.kind {
+                return false;
+            }
+
+            span_lint_and_sugg(
+                cx,
+                UNNECESSARY_CAST,
+                expr.span,
+                &format!("casting raw pointers to the same type and constness is unnecessary (`{cast_from}` -> `{cast_to}`)"),
+                "try",
+                cast_str.clone(),
+                Applicability::MachineApplicable,
+            );
+        }
+    }
+
     // skip non-primitive type cast
     if_chain! {
         if let ExprKind::Cast(_, cast_to) = expr.kind;
@@ -27,12 +59,10 @@ pub(super) fn check<'tcx>(
         if let Res::PrimTy(_) = path.res;
         then {}
         else {
-            return false
+            return false;
         }
     }
 
-    let cast_str = snippet_opt(cx, cast_expr.span).unwrap_or_default();
-
     if let Some(lit) = get_numeric_literal(cast_expr) {
         let literal_str = &cast_str;
 
diff --git a/tests/ui/as_ptr_cast_mut.stderr b/tests/ui/as_ptr_cast_mut.stderr
index 2189c3d2f85..c45d669fd73 100644
--- a/tests/ui/as_ptr_cast_mut.stderr
+++ b/tests/ui/as_ptr_cast_mut.stderr
@@ -12,5 +12,19 @@ error: casting the result of `as_ptr` to *mut i8
 LL |     let _: *mut i8 = string.as_ptr() as *mut _;
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `string.as_mut_ptr()`
 
-error: aborting due to 2 previous errors
+error: casting raw pointers to the same type and constness is unnecessary (`*mut u8` -> `*mut u8`)
+  --> $DIR/as_ptr_cast_mut.rs:25:13
+   |
+LL |     let _ = string.as_mut_ptr() as *mut u8;
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `string.as_mut_ptr()`
+   |
+   = note: `-D clippy::unnecessary-cast` implied by `-D warnings`
+
+error: casting raw pointers to the same type and constness is unnecessary (`*mut u8` -> `*mut u8`)
+  --> $DIR/as_ptr_cast_mut.rs:29:13
+   |
+LL |     let _ = nn.as_ptr() as *mut u8;
+   |             ^^^^^^^^^^^^^^^^^^^^^^ help: try: `nn.as_ptr()`
+
+error: aborting due to 4 previous errors
 
diff --git a/tests/ui/cast_slice_different_sizes.rs b/tests/ui/cast_slice_different_sizes.rs
index b77f01883bf..27e03ebb719 100644
--- a/tests/ui/cast_slice_different_sizes.rs
+++ b/tests/ui/cast_slice_different_sizes.rs
@@ -1,4 +1,4 @@
-#![allow(clippy::let_unit_value)]
+#![allow(clippy::let_unit_value, clippy::unnecessary_cast)]
 
 fn main() {
     let x: [i32; 3] = [1_i32, 2, 3];
diff --git a/tests/ui/crashes/ice-1782.rs b/tests/ui/crashes/ice-1782.rs
index 81af88962a6..19ab03418ee 100644
--- a/tests/ui/crashes/ice-1782.rs
+++ b/tests/ui/crashes/ice-1782.rs
@@ -1,4 +1,5 @@
 #![allow(dead_code, unused_variables)]
+#![allow(clippy::unnecessary_cast)]
 
 /// Should not trigger an ICE in `SpanlessEq` / `consts::constant`
 ///
diff --git a/tests/ui/from_raw_with_void_ptr.rs b/tests/ui/from_raw_with_void_ptr.rs
index 8484da2415a..95ef6425fad 100644
--- a/tests/ui/from_raw_with_void_ptr.rs
+++ b/tests/ui/from_raw_with_void_ptr.rs
@@ -1,4 +1,5 @@
 #![warn(clippy::from_raw_with_void_ptr)]
+#![allow(clippy::unnecessary_cast)]
 
 use std::ffi::c_void;
 use std::rc::Rc;
diff --git a/tests/ui/from_raw_with_void_ptr.stderr b/tests/ui/from_raw_with_void_ptr.stderr
index 96e4af12ba3..1963d08014b 100644
--- a/tests/ui/from_raw_with_void_ptr.stderr
+++ b/tests/ui/from_raw_with_void_ptr.stderr
@@ -1,60 +1,60 @@
 error: creating a `Box` from a void raw pointer
-  --> $DIR/from_raw_with_void_ptr.rs:10:22
+  --> $DIR/from_raw_with_void_ptr.rs:11:22
    |
 LL |     let _ = unsafe { Box::from_raw(ptr) };
    |                      ^^^^^^^^^^^^^^^^^^
    |
 help: cast this to a pointer of the appropriate type
-  --> $DIR/from_raw_with_void_ptr.rs:10:36
+  --> $DIR/from_raw_with_void_ptr.rs:11:36
    |
 LL |     let _ = unsafe { Box::from_raw(ptr) };
    |                                    ^^^
    = note: `-D clippy::from-raw-with-void-ptr` implied by `-D warnings`
 
 error: creating a `Rc` from a void raw pointer
-  --> $DIR/from_raw_with_void_ptr.rs:21:22
+  --> $DIR/from_raw_with_void_ptr.rs:22:22
    |
 LL |     let _ = unsafe { Rc::from_raw(ptr) };
    |                      ^^^^^^^^^^^^^^^^^
    |
 help: cast this to a pointer of the appropriate type
-  --> $DIR/from_raw_with_void_ptr.rs:21:35
+  --> $DIR/from_raw_with_void_ptr.rs:22:35
    |
 LL |     let _ = unsafe { Rc::from_raw(ptr) };
    |                                   ^^^
 
 error: creating a `Arc` from a void raw pointer
-  --> $DIR/from_raw_with_void_ptr.rs:25:22
+  --> $DIR/from_raw_with_void_ptr.rs:26:22
    |
 LL |     let _ = unsafe { Arc::from_raw(ptr) };
    |                      ^^^^^^^^^^^^^^^^^^
    |
 help: cast this to a pointer of the appropriate type
-  --> $DIR/from_raw_with_void_ptr.rs:25:36
+  --> $DIR/from_raw_with_void_ptr.rs:26:36
    |
 LL |     let _ = unsafe { Arc::from_raw(ptr) };
    |                                    ^^^
 
 error: creating a `Weak` from a void raw pointer
-  --> $DIR/from_raw_with_void_ptr.rs:29:22
+  --> $DIR/from_raw_with_void_ptr.rs:30:22
    |
 LL |     let _ = unsafe { std::rc::Weak::from_raw(ptr) };
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: cast this to a pointer of the appropriate type
-  --> $DIR/from_raw_with_void_ptr.rs:29:46
+  --> $DIR/from_raw_with_void_ptr.rs:30:46
    |
 LL |     let _ = unsafe { std::rc::Weak::from_raw(ptr) };
    |                                              ^^^
 
 error: creating a `Weak` from a void raw pointer
-  --> $DIR/from_raw_with_void_ptr.rs:33:22
+  --> $DIR/from_raw_with_void_ptr.rs:34:22
    |
 LL |     let _ = unsafe { std::sync::Weak::from_raw(ptr) };
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: cast this to a pointer of the appropriate type
-  --> $DIR/from_raw_with_void_ptr.rs:33:48
+  --> $DIR/from_raw_with_void_ptr.rs:34:48
    |
 LL |     let _ = unsafe { std::sync::Weak::from_raw(ptr) };
    |                                                ^^^
diff --git a/tests/ui/transmute_ptr_to_ref.fixed b/tests/ui/transmute_ptr_to_ref.fixed
index 575dadde906..215f0ac1842 100644
--- a/tests/ui/transmute_ptr_to_ref.fixed
+++ b/tests/ui/transmute_ptr_to_ref.fixed
@@ -1,7 +1,7 @@
 //@run-rustfix
 
 #![warn(clippy::transmute_ptr_to_ref)]
-#![allow(clippy::match_single_binding)]
+#![allow(clippy::match_single_binding, clippy::unnecessary_cast)]
 
 unsafe fn _ptr_to_ref<T, U>(p: *const T, m: *mut T, o: *const U, om: *mut U) {
     let _: &T = &*p;
diff --git a/tests/ui/transmute_ptr_to_ref.rs b/tests/ui/transmute_ptr_to_ref.rs
index 4238ff80478..3528e137903 100644
--- a/tests/ui/transmute_ptr_to_ref.rs
+++ b/tests/ui/transmute_ptr_to_ref.rs
@@ -1,7 +1,7 @@
 //@run-rustfix
 
 #![warn(clippy::transmute_ptr_to_ref)]
-#![allow(clippy::match_single_binding)]
+#![allow(clippy::match_single_binding, clippy::unnecessary_cast)]
 
 unsafe fn _ptr_to_ref<T, U>(p: *const T, m: *mut T, o: *const U, om: *mut U) {
     let _: &T = std::mem::transmute(p);
diff --git a/tests/ui/unnecessary_cast.fixed b/tests/ui/unnecessary_cast.fixed
index bcc231ea7bc..7038a2915cb 100644
--- a/tests/ui/unnecessary_cast.fixed
+++ b/tests/ui/unnecessary_cast.fixed
@@ -8,6 +8,9 @@
     clippy::unnecessary_operation
 )]
 
+type PtrConstU8 = *const u8;
+type PtrMutU8 = *mut u8;
+
 #[rustfmt::skip]
 fn main() {
     // Test cast_unnecessary
@@ -22,6 +25,17 @@ fn main() {
     1_i32;
     1_f32;
 
+    [1u8, 2].as_ptr();
+    [1u8, 2].as_ptr() as *mut u8;
+    [1u8, 2].as_mut_ptr();
+    [1u8, 2].as_mut_ptr() as *const u8;
+    [1u8, 2].as_ptr() as PtrConstU8;
+    [1u8, 2].as_ptr() as PtrMutU8;
+    [1u8, 2].as_mut_ptr() as PtrMutU8;
+    [1u8, 2].as_mut_ptr() as PtrConstU8;
+    let _: *const u8 = [1u8, 2].as_ptr() as _;
+    let _: *mut u8 = [1u8, 2].as_mut_ptr() as _;
+
     // macro version
     macro_rules! foo {
         ($a:ident, $b:ident) => {
diff --git a/tests/ui/unnecessary_cast.rs b/tests/ui/unnecessary_cast.rs
index 282b2f1283e..5e766405809 100644
--- a/tests/ui/unnecessary_cast.rs
+++ b/tests/ui/unnecessary_cast.rs
@@ -8,6 +8,9 @@
     clippy::unnecessary_operation
 )]
 
+type PtrConstU8 = *const u8;
+type PtrMutU8 = *mut u8;
+
 #[rustfmt::skip]
 fn main() {
     // Test cast_unnecessary
@@ -22,6 +25,17 @@ fn main() {
     1_i32 as i32;
     1_f32 as f32;
 
+    [1u8, 2].as_ptr() as *const u8;
+    [1u8, 2].as_ptr() as *mut u8;
+    [1u8, 2].as_mut_ptr() as *mut u8;
+    [1u8, 2].as_mut_ptr() as *const u8;
+    [1u8, 2].as_ptr() as PtrConstU8;
+    [1u8, 2].as_ptr() as PtrMutU8;
+    [1u8, 2].as_mut_ptr() as PtrMutU8;
+    [1u8, 2].as_mut_ptr() as PtrConstU8;
+    let _: *const u8 = [1u8, 2].as_ptr() as _;
+    let _: *mut u8 = [1u8, 2].as_mut_ptr() as _;
+
     // macro version
     macro_rules! foo {
         ($a:ident, $b:ident) => {
diff --git a/tests/ui/unnecessary_cast.stderr b/tests/ui/unnecessary_cast.stderr
index fcee4ee2a65..077274c2337 100644
--- a/tests/ui/unnecessary_cast.stderr
+++ b/tests/ui/unnecessary_cast.stderr
@@ -1,5 +1,5 @@
 error: casting integer literal to `i32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:14:5
+  --> $DIR/unnecessary_cast.rs:17:5
    |
 LL |     1i32 as i32;
    |     ^^^^^^^^^^^ help: try: `1_i32`
@@ -7,184 +7,196 @@ LL |     1i32 as i32;
    = note: `-D clippy::unnecessary-cast` implied by `-D warnings`
 
 error: casting float literal to `f32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:15:5
+  --> $DIR/unnecessary_cast.rs:18:5
    |
 LL |     1f32 as f32;
    |     ^^^^^^^^^^^ help: try: `1_f32`
 
 error: casting to the same type is unnecessary (`bool` -> `bool`)
-  --> $DIR/unnecessary_cast.rs:16:5
+  --> $DIR/unnecessary_cast.rs:19:5
    |
 LL |     false as bool;
    |     ^^^^^^^^^^^^^ help: try: `false`
 
 error: casting integer literal to `i32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:19:5
+  --> $DIR/unnecessary_cast.rs:22:5
    |
 LL |     -1_i32 as i32;
    |     ^^^^^^^^^^^^^ help: try: `-1_i32`
 
 error: casting integer literal to `i32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:20:5
+  --> $DIR/unnecessary_cast.rs:23:5
    |
 LL |     - 1_i32 as i32;
    |     ^^^^^^^^^^^^^^ help: try: `- 1_i32`
 
 error: casting float literal to `f32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:21:5
+  --> $DIR/unnecessary_cast.rs:24:5
    |
 LL |     -1f32 as f32;
    |     ^^^^^^^^^^^^ help: try: `-1_f32`
 
 error: casting integer literal to `i32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:22:5
+  --> $DIR/unnecessary_cast.rs:25:5
    |
 LL |     1_i32 as i32;
    |     ^^^^^^^^^^^^ help: try: `1_i32`
 
 error: casting float literal to `f32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:23:5
+  --> $DIR/unnecessary_cast.rs:26:5
    |
 LL |     1_f32 as f32;
    |     ^^^^^^^^^^^^ help: try: `1_f32`
 
+error: casting raw pointers to the same type and constness is unnecessary (`*const u8` -> `*const u8`)
+  --> $DIR/unnecessary_cast.rs:28:5
+   |
+LL |     [1u8, 2].as_ptr() as *const u8;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `[1u8, 2].as_ptr()`
+
+error: casting raw pointers to the same type and constness is unnecessary (`*mut u8` -> `*mut u8`)
+  --> $DIR/unnecessary_cast.rs:30:5
+   |
+LL |     [1u8, 2].as_mut_ptr() as *mut u8;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `[1u8, 2].as_mut_ptr()`
+
 error: casting integer literal to `f32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:64:9
+  --> $DIR/unnecessary_cast.rs:78:9
    |
 LL |         100 as f32;
    |         ^^^^^^^^^^ help: try: `100_f32`
 
 error: casting integer literal to `f64` is unnecessary
-  --> $DIR/unnecessary_cast.rs:65:9
+  --> $DIR/unnecessary_cast.rs:79:9
    |
 LL |         100 as f64;
    |         ^^^^^^^^^^ help: try: `100_f64`
 
 error: casting integer literal to `f64` is unnecessary
-  --> $DIR/unnecessary_cast.rs:66:9
+  --> $DIR/unnecessary_cast.rs:80:9
    |
 LL |         100_i32 as f64;
    |         ^^^^^^^^^^^^^^ help: try: `100_f64`
 
 error: casting integer literal to `f32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:67:17
+  --> $DIR/unnecessary_cast.rs:81:17
    |
 LL |         let _ = -100 as f32;
    |                 ^^^^^^^^^^^ help: try: `-100_f32`
 
 error: casting integer literal to `f64` is unnecessary
-  --> $DIR/unnecessary_cast.rs:68:17
+  --> $DIR/unnecessary_cast.rs:82:17
    |
 LL |         let _ = -100 as f64;
    |                 ^^^^^^^^^^^ help: try: `-100_f64`
 
 error: casting integer literal to `f64` is unnecessary
-  --> $DIR/unnecessary_cast.rs:69:17
+  --> $DIR/unnecessary_cast.rs:83:17
    |
 LL |         let _ = -100_i32 as f64;
    |                 ^^^^^^^^^^^^^^^ help: try: `-100_f64`
 
 error: casting float literal to `f32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:70:9
+  --> $DIR/unnecessary_cast.rs:84:9
    |
 LL |         100. as f32;
    |         ^^^^^^^^^^^ help: try: `100_f32`
 
 error: casting float literal to `f64` is unnecessary
-  --> $DIR/unnecessary_cast.rs:71:9
+  --> $DIR/unnecessary_cast.rs:85:9
    |
 LL |         100. as f64;
    |         ^^^^^^^^^^^ help: try: `100_f64`
 
 error: casting integer literal to `u32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:83:9
+  --> $DIR/unnecessary_cast.rs:97:9
    |
 LL |         1 as u32;
    |         ^^^^^^^^ help: try: `1_u32`
 
 error: casting integer literal to `i32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:84:9
+  --> $DIR/unnecessary_cast.rs:98:9
    |
 LL |         0x10 as i32;
    |         ^^^^^^^^^^^ help: try: `0x10_i32`
 
 error: casting integer literal to `usize` is unnecessary
-  --> $DIR/unnecessary_cast.rs:85:9
+  --> $DIR/unnecessary_cast.rs:99:9
    |
 LL |         0b10 as usize;
    |         ^^^^^^^^^^^^^ help: try: `0b10_usize`
 
 error: casting integer literal to `u16` is unnecessary
-  --> $DIR/unnecessary_cast.rs:86:9
+  --> $DIR/unnecessary_cast.rs:100:9
    |
 LL |         0o73 as u16;
    |         ^^^^^^^^^^^ help: try: `0o73_u16`
 
 error: casting integer literal to `u32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:87:9
+  --> $DIR/unnecessary_cast.rs:101:9
    |
 LL |         1_000_000_000 as u32;
    |         ^^^^^^^^^^^^^^^^^^^^ help: try: `1_000_000_000_u32`
 
 error: casting float literal to `f64` is unnecessary
-  --> $DIR/unnecessary_cast.rs:89:9
+  --> $DIR/unnecessary_cast.rs:103:9
    |
 LL |         1.0 as f64;
    |         ^^^^^^^^^^ help: try: `1.0_f64`
 
 error: casting float literal to `f32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:90:9
+  --> $DIR/unnecessary_cast.rs:104:9
    |
 LL |         0.5 as f32;
    |         ^^^^^^^^^^ help: try: `0.5_f32`
 
 error: casting integer literal to `i32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:94:17
+  --> $DIR/unnecessary_cast.rs:108:17
    |
 LL |         let _ = -1 as i32;
    |                 ^^^^^^^^^ help: try: `-1_i32`
 
 error: casting float literal to `f32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:95:17
+  --> $DIR/unnecessary_cast.rs:109:17
    |
 LL |         let _ = -1.0 as f32;
    |                 ^^^^^^^^^^^ help: try: `-1.0_f32`
 
 error: casting to the same type is unnecessary (`i32` -> `i32`)
-  --> $DIR/unnecessary_cast.rs:101:18
+  --> $DIR/unnecessary_cast.rs:115:18
    |
 LL |         let _ = &(x as i32);
    |                  ^^^^^^^^^^ help: try: `{ x }`
 
 error: casting integer literal to `i32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:107:22
+  --> $DIR/unnecessary_cast.rs:121:22
    |
 LL |         let _: i32 = -(1) as i32;
    |                      ^^^^^^^^^^^ help: try: `-1_i32`
 
 error: casting integer literal to `i64` is unnecessary
-  --> $DIR/unnecessary_cast.rs:109:22
+  --> $DIR/unnecessary_cast.rs:123:22
    |
 LL |         let _: i64 = -(1) as i64;
    |                      ^^^^^^^^^^^ help: try: `-1_i64`
 
 error: casting float literal to `f64` is unnecessary
-  --> $DIR/unnecessary_cast.rs:116:22
+  --> $DIR/unnecessary_cast.rs:130:22
    |
 LL |         let _: f64 = (-8.0 as f64).exp();
    |                      ^^^^^^^^^^^^^ help: try: `(-8.0_f64)`
 
 error: casting float literal to `f64` is unnecessary
-  --> $DIR/unnecessary_cast.rs:118:23
+  --> $DIR/unnecessary_cast.rs:132:23
    |
 LL |         let _: f64 = -(8.0 as f64).exp(); // should suggest `-8.0_f64.exp()` here not to change code behavior
    |                       ^^^^^^^^^^^^ help: try: `8.0_f64`
 
 error: casting to the same type is unnecessary (`f32` -> `f32`)
-  --> $DIR/unnecessary_cast.rs:126:20
+  --> $DIR/unnecessary_cast.rs:140:20
    |
 LL |         let _num = foo() as f32;
    |                    ^^^^^^^^^^^^ help: try: `foo()`
 
-error: aborting due to 31 previous errors
+error: aborting due to 33 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 021b7398e1c37c75c250e3b81a1b46622ce683c9 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Wed, 24 May 2023 21:39:06 +0000
Subject: Ignore #[cfg]'d out code in needless_else

---
 clippy_lints/src/needless_else.rs | 42 +++++++++++++++++++++------------------
 tests/ui/needless_else.fixed      | 17 ++++++++++++++++
 tests/ui/needless_else.rs         | 17 ++++++++++++++++
 tests/ui/needless_else.stderr     |  2 +-
 4 files changed, 58 insertions(+), 20 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/needless_else.rs b/clippy_lints/src/needless_else.rs
index 8faf033e406..4ff1bf7ffc0 100644
--- a/clippy_lints/src/needless_else.rs
+++ b/clippy_lints/src/needless_else.rs
@@ -1,4 +1,5 @@
-use clippy_utils::{diagnostics::span_lint_and_sugg, source::trim_span, span_extract_comment};
+use clippy_utils::source::snippet_opt;
+use clippy_utils::{diagnostics::span_lint_and_sugg, source::trim_span};
 use rustc_ast::ast::{Expr, ExprKind};
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
@@ -35,23 +36,26 @@ declare_lint_pass!(NeedlessElse => [NEEDLESS_ELSE]);
 
 impl EarlyLintPass for NeedlessElse {
     fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
-        if let ExprKind::If(_, then_block, Some(else_clause)) = &expr.kind &&
-            let ExprKind::Block(block, _) = &else_clause.kind &&
-            !expr.span.from_expansion() &&
-            !else_clause.span.from_expansion() &&
-            block.stmts.is_empty() {
-                let span = trim_span(cx.sess().source_map(), expr.span.trim_start(then_block.span).unwrap());
-                if span_extract_comment(cx.sess().source_map(), span).is_empty() {
-                    span_lint_and_sugg(
-                        cx,
-                        NEEDLESS_ELSE,
-                        span,
-                        "this else branch is empty",
-                        "you can remove it",
-                        String::new(),
-                        Applicability::MachineApplicable,
-                    );
-                }
-            }
+        if let ExprKind::If(_, then_block, Some(else_clause)) = &expr.kind
+            && let ExprKind::Block(block, _) = &else_clause.kind
+            && !expr.span.from_expansion()
+            && !else_clause.span.from_expansion()
+            && block.stmts.is_empty()
+            && let Some(trimmed) = expr.span.trim_start(then_block.span)
+            && let span = trim_span(cx.sess().source_map(), trimmed)
+            && let Some(else_snippet) = snippet_opt(cx, span)
+            // Ignore else blocks that contain comments or #[cfg]s
+            && !else_snippet.contains(['/', '#'])
+        {
+            span_lint_and_sugg(
+                cx,
+                NEEDLESS_ELSE,
+                span,
+                "this else branch is empty",
+                "you can remove it",
+                String::new(),
+                Applicability::MachineApplicable,
+            );
+        }
     }
 }
diff --git a/tests/ui/needless_else.fixed b/tests/ui/needless_else.fixed
index 14f81728a86..06a16162790 100644
--- a/tests/ui/needless_else.fixed
+++ b/tests/ui/needless_else.fixed
@@ -12,6 +12,10 @@ macro_rules! mac {
     };
 }
 
+macro_rules! empty_expansion {
+    () => {};
+}
+
 fn main() {
     let b = std::hint::black_box(true);
 
@@ -37,4 +41,17 @@ fn main() {
 
     // Do not lint because inside a macro
     mac!(b);
+
+    if b {
+        println!("Foobar");
+    } else {
+        #[cfg(foo)]
+        "Do not lint cfg'd out code"
+    }
+
+    if b {
+        println!("Foobar");
+    } else {
+        empty_expansion!();
+    }
 }
diff --git a/tests/ui/needless_else.rs b/tests/ui/needless_else.rs
index fae11818141..728032c47a6 100644
--- a/tests/ui/needless_else.rs
+++ b/tests/ui/needless_else.rs
@@ -12,6 +12,10 @@ macro_rules! mac {
     };
 }
 
+macro_rules! empty_expansion {
+    () => {};
+}
+
 fn main() {
     let b = std::hint::black_box(true);
 
@@ -38,4 +42,17 @@ fn main() {
 
     // Do not lint because inside a macro
     mac!(b);
+
+    if b {
+        println!("Foobar");
+    } else {
+        #[cfg(foo)]
+        "Do not lint cfg'd out code"
+    }
+
+    if b {
+        println!("Foobar");
+    } else {
+        empty_expansion!();
+    }
 }
diff --git a/tests/ui/needless_else.stderr b/tests/ui/needless_else.stderr
index a7b2f1959c7..ea693085164 100644
--- a/tests/ui/needless_else.stderr
+++ b/tests/ui/needless_else.stderr
@@ -1,5 +1,5 @@
 error: this else branch is empty
-  --> $DIR/needless_else.rs:20:7
+  --> $DIR/needless_else.rs:24:7
    |
 LL |       } else {
    |  _______^
-- 
cgit 1.4.1-3-g733a5


From 0b507c6f0434ced76da4bf068551b93b6df47a5f Mon Sep 17 00:00:00 2001
From: disco07 <koneenok@outlook.fr>
Date: Fri, 26 May 2023 06:16:39 +0200
Subject: redundant pattern matches! result

---
 clippy_lints/src/matches/mod.rs                    |  8 +++-
 .../src/matches/redundant_pattern_match.rs         | 21 ++++------
 tests/ui/redundant_pattern_matching_option.fixed   | 12 ++++++
 tests/ui/redundant_pattern_matching_option.rs      | 12 ++++++
 tests/ui/redundant_pattern_matching_option.stderr  | 44 +++++++++++++--------
 tests/ui/redundant_pattern_matching_result.fixed   | 15 +++++++
 tests/ui/redundant_pattern_matching_result.rs      | 15 +++++++
 tests/ui/redundant_pattern_matching_result.stderr  | 46 ++++++++++++++--------
 8 files changed, 125 insertions(+), 48 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/mod.rs b/clippy_lints/src/matches/mod.rs
index 55ec9d4474f..0d91051632a 100644
--- a/clippy_lints/src/matches/mod.rs
+++ b/clippy_lints/src/matches/mod.rs
@@ -25,7 +25,7 @@ mod wild_in_or_pats;
 
 use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::{snippet_opt, walk_span_to_context};
-use clippy_utils::{higher, in_constant, is_span_match, tokenize_with_text};
+use clippy_utils::{higher, in_constant, is_direct_expn_of, is_span_match, tokenize_with_text};
 use rustc_hir::{Arm, Expr, ExprKind, Local, MatchSource, Pat};
 use rustc_lexer::TokenKind;
 use rustc_lint::{LateContext, LateLintPass, LintContext};
@@ -974,12 +974,16 @@ impl_lint_pass!(Matches => [
 
 impl<'tcx> LateLintPass<'tcx> for Matches {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if in_external_macro(cx.sess(), expr.span) {
+        if is_direct_expn_of(expr.span, "matches").is_none() && in_external_macro(cx.sess(), expr.span) {
             return;
         }
         let from_expansion = expr.span.from_expansion();
 
         if let ExprKind::Match(ex, arms, source) = expr.kind {
+            if is_direct_expn_of(expr.span, "matches").is_some() {
+                redundant_pattern_match::check_match(cx, expr, ex, arms);
+            }
+
             if source == MatchSource::Normal && !is_span_match(cx, expr.span) {
                 return;
             }
diff --git a/clippy_lints/src/matches/redundant_pattern_match.rs b/clippy_lints/src/matches/redundant_pattern_match.rs
index e81e09da425..479cfd83512 100644
--- a/clippy_lints/src/matches/redundant_pattern_match.rs
+++ b/clippy_lints/src/matches/redundant_pattern_match.rs
@@ -1,10 +1,10 @@
 use super::REDUNDANT_PATTERN_MATCHING;
-use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::{snippet, walk_span_to_context};
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::{is_type_diagnostic_item, needs_ordered_drop};
 use clippy_utils::visitors::any_temporaries_need_ordered_drop;
-use clippy_utils::{higher, is_trait_method};
+use clippy_utils::{higher, is_expn_of, is_trait_method};
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
@@ -190,24 +190,19 @@ pub(super) fn check_match<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, op
         let node_pair = (&arms[0].pat.kind, &arms[1].pat.kind);
 
         if let Some(good_method) = found_good_method(cx, arms, node_pair) {
-            let span = expr.span.to(op.span);
+            let span = is_expn_of(expr.span, "matches").unwrap_or(expr.span.to(op.span));
             let result_expr = match &op.kind {
                 ExprKind::AddrOf(_, _, borrowed) => borrowed,
                 _ => op,
             };
-            span_lint_and_then(
+            span_lint_and_sugg(
                 cx,
                 REDUNDANT_PATTERN_MATCHING,
-                expr.span,
+                span,
                 &format!("redundant pattern matching, consider using `{good_method}`"),
-                |diag| {
-                    diag.span_suggestion(
-                        span,
-                        "try this",
-                        format!("{}.{good_method}", snippet(cx, result_expr.span, "_")),
-                        Applicability::MaybeIncorrect, // snippet
-                    );
-                },
+                "try this",
+                format!("{}.{good_method}", snippet(cx, result_expr.span, "_")),
+                Applicability::MachineApplicable,
             );
         }
     }
diff --git a/tests/ui/redundant_pattern_matching_option.fixed b/tests/ui/redundant_pattern_matching_option.fixed
index accdf1da9dd..dae931541d4 100644
--- a/tests/ui/redundant_pattern_matching_option.fixed
+++ b/tests/ui/redundant_pattern_matching_option.fixed
@@ -47,6 +47,7 @@ fn main() {
 
     issue6067();
     issue10726();
+    issue10803();
 
     let _ = if gen_opt().is_some() {
         1
@@ -107,3 +108,14 @@ fn issue10726() {
         _ => false,
     };
 }
+
+fn issue10803() {
+    let x = Some(42);
+
+    let _ = x.is_some();
+
+    let _ = x.is_none();
+
+    // Don't lint
+    let _ = matches!(x, Some(16));
+}
diff --git a/tests/ui/redundant_pattern_matching_option.rs b/tests/ui/redundant_pattern_matching_option.rs
index ec684bdf71c..3f2fa3f53ce 100644
--- a/tests/ui/redundant_pattern_matching_option.rs
+++ b/tests/ui/redundant_pattern_matching_option.rs
@@ -56,6 +56,7 @@ fn main() {
 
     issue6067();
     issue10726();
+    issue10803();
 
     let _ = if let Some(_) = gen_opt() {
         1
@@ -134,3 +135,14 @@ fn issue10726() {
         _ => false,
     };
 }
+
+fn issue10803() {
+    let x = Some(42);
+
+    let _ = matches!(x, Some(_));
+
+    let _ = matches!(x, None);
+
+    // Don't lint
+    let _ = matches!(x, Some(16));
+}
diff --git a/tests/ui/redundant_pattern_matching_option.stderr b/tests/ui/redundant_pattern_matching_option.stderr
index a69eb390520..93760ce97a8 100644
--- a/tests/ui/redundant_pattern_matching_option.stderr
+++ b/tests/ui/redundant_pattern_matching_option.stderr
@@ -77,49 +77,49 @@ LL |     let _ = 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
+  --> $DIR/redundant_pattern_matching_option.rs:61: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
+  --> $DIR/redundant_pattern_matching_option.rs:63: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:68:12
+  --> $DIR/redundant_pattern_matching_option.rs:69:12
    |
 LL |     if let Some(..) = gen_opt() {}
    |     -------^^^^^^^^------------ help: try this: `if gen_opt().is_some()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/redundant_pattern_matching_option.rs:83:12
+  --> $DIR/redundant_pattern_matching_option.rs:84: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
+  --> $DIR/redundant_pattern_matching_option.rs:86: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
+  --> $DIR/redundant_pattern_matching_option.rs:88: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
+  --> $DIR/redundant_pattern_matching_option.rs:90: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
+  --> $DIR/redundant_pattern_matching_option.rs:92:5
    |
 LL | /     match Some(42) {
 LL | |         Some(_) => true,
@@ -128,7 +128,7 @@ LL | |     };
    | |_____^ help: try this: `Some(42).is_some()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:96:5
+  --> $DIR/redundant_pattern_matching_option.rs:97:5
    |
 LL | /     match None::<()> {
 LL | |         Some(_) => false,
@@ -137,19 +137,19 @@ LL | |     };
    | |_____^ help: try this: `None::<()>.is_none()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:104:12
+  --> $DIR/redundant_pattern_matching_option.rs:105:12
    |
 LL |     if let None = *(&None::<()>) {}
    |     -------^^^^----------------- help: try this: `if (&None::<()>).is_none()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:105:12
+  --> $DIR/redundant_pattern_matching_option.rs:106: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:111:5
+  --> $DIR/redundant_pattern_matching_option.rs:112:5
    |
 LL | /     match x {
 LL | |         Some(_) => true,
@@ -158,7 +158,7 @@ LL | |     };
    | |_____^ help: try this: `x.is_some()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:116:5
+  --> $DIR/redundant_pattern_matching_option.rs:117:5
    |
 LL | /     match x {
 LL | |         None => true,
@@ -167,7 +167,7 @@ LL | |     };
    | |_____^ help: try this: `x.is_none()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:121:5
+  --> $DIR/redundant_pattern_matching_option.rs:122:5
    |
 LL | /     match x {
 LL | |         Some(_) => false,
@@ -176,7 +176,7 @@ LL | |     };
    | |_____^ help: try this: `x.is_none()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/redundant_pattern_matching_option.rs:126:5
+  --> $DIR/redundant_pattern_matching_option.rs:127:5
    |
 LL | /     match x {
 LL | |         None => false,
@@ -184,5 +184,17 @@ LL | |         _ => true,
 LL | |     };
    | |_____^ help: try this: `x.is_some()`
 
-error: aborting due to 26 previous errors
+error: redundant pattern matching, consider using `is_some()`
+  --> $DIR/redundant_pattern_matching_option.rs:142:13
+   |
+LL |     let _ = matches!(x, Some(_));
+   |             ^^^^^^^^^^^^^^^^^^^^ help: try this: `x.is_some()`
+
+error: redundant pattern matching, consider using `is_none()`
+  --> $DIR/redundant_pattern_matching_option.rs:144:13
+   |
+LL |     let _ = matches!(x, None);
+   |             ^^^^^^^^^^^^^^^^^ help: try this: `x.is_none()`
+
+error: aborting due to 28 previous errors
 
diff --git a/tests/ui/redundant_pattern_matching_result.fixed b/tests/ui/redundant_pattern_matching_result.fixed
index e4032ae44b7..d77a2af7616 100644
--- a/tests/ui/redundant_pattern_matching_result.fixed
+++ b/tests/ui/redundant_pattern_matching_result.fixed
@@ -44,6 +44,7 @@ fn main() {
     issue6067();
     issue6065();
     issue10726();
+    issue10803();
 
     let _ = if gen_res().is_ok() {
         1
@@ -133,3 +134,17 @@ fn issue10726() {
         _ => true,
     };
 }
+
+fn issue10803() {
+    let x: Result<i32, i32> = Ok(42);
+
+    let _ = x.is_ok();
+
+    let _ = x.is_err();
+
+    // Don't lint
+    let _ = matches!(x, Ok(16));
+
+    // Don't lint
+    let _ = matches!(x, Err(16));
+}
diff --git a/tests/ui/redundant_pattern_matching_result.rs b/tests/ui/redundant_pattern_matching_result.rs
index 39eb10df878..aa884ac6bb1 100644
--- a/tests/ui/redundant_pattern_matching_result.rs
+++ b/tests/ui/redundant_pattern_matching_result.rs
@@ -56,6 +56,7 @@ fn main() {
     issue6067();
     issue6065();
     issue10726();
+    issue10803();
 
     let _ = if let Ok(_) = gen_res() {
         1
@@ -163,3 +164,17 @@ fn issue10726() {
         _ => true,
     };
 }
+
+fn issue10803() {
+    let x: Result<i32, i32> = Ok(42);
+
+    let _ = matches!(x, Ok(_));
+
+    let _ = matches!(x, Err(_));
+
+    // Don't lint
+    let _ = matches!(x, Ok(16));
+
+    // Don't lint
+    let _ = matches!(x, Err(16));
+}
diff --git a/tests/ui/redundant_pattern_matching_result.stderr b/tests/ui/redundant_pattern_matching_result.stderr
index 5893ae4dcc4..b462f7f41b9 100644
--- a/tests/ui/redundant_pattern_matching_result.stderr
+++ b/tests/ui/redundant_pattern_matching_result.stderr
@@ -73,67 +73,67 @@ 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_ok()`
-  --> $DIR/redundant_pattern_matching_result.rs:60:20
+  --> $DIR/redundant_pattern_matching_result.rs:61:20
    |
 LL |     let _ = if let Ok(_) = gen_res() {
    |             -------^^^^^------------ help: try this: `if gen_res().is_ok()`
 
 error: redundant pattern matching, consider using `is_err()`
-  --> $DIR/redundant_pattern_matching_result.rs:62:19
+  --> $DIR/redundant_pattern_matching_result.rs:63: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_result.rs:85:19
+  --> $DIR/redundant_pattern_matching_result.rs:86: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_result.rs:86:16
+  --> $DIR/redundant_pattern_matching_result.rs:87: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_result.rs:92:12
+  --> $DIR/redundant_pattern_matching_result.rs:93: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_result.rs:93:15
+  --> $DIR/redundant_pattern_matching_result.rs:94:15
    |
 LL |     while let Some(_) = m!() {}
    |     ----------^^^^^^^------- help: try this: `while m!().is_some()`
 
 error: redundant pattern matching, consider using `is_ok()`
-  --> $DIR/redundant_pattern_matching_result.rs:111:12
+  --> $DIR/redundant_pattern_matching_result.rs:112: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_result.rs:113:12
+  --> $DIR/redundant_pattern_matching_result.rs:114: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_result.rs:115:15
+  --> $DIR/redundant_pattern_matching_result.rs:116: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_result.rs:117:15
+  --> $DIR/redundant_pattern_matching_result.rs:118: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_result.rs:119:5
+  --> $DIR/redundant_pattern_matching_result.rs:120:5
    |
 LL | /     match Ok::<i32, i32>(42) {
 LL | |         Ok(_) => true,
@@ -142,7 +142,7 @@ LL | |     };
    | |_____^ help: try this: `Ok::<i32, i32>(42).is_ok()`
 
 error: redundant pattern matching, consider using `is_err()`
-  --> $DIR/redundant_pattern_matching_result.rs:124:5
+  --> $DIR/redundant_pattern_matching_result.rs:125:5
    |
 LL | /     match Err::<i32, i32>(42) {
 LL | |         Ok(_) => false,
@@ -151,7 +151,7 @@ LL | |     };
    | |_____^ help: try this: `Err::<i32, i32>(42).is_err()`
 
 error: redundant pattern matching, consider using `is_ok()`
-  --> $DIR/redundant_pattern_matching_result.rs:134:5
+  --> $DIR/redundant_pattern_matching_result.rs:135:5
    |
 LL | /     match x {
 LL | |         Ok(_) => true,
@@ -160,7 +160,7 @@ LL | |     };
    | |_____^ help: try this: `x.is_ok()`
 
 error: redundant pattern matching, consider using `is_err()`
-  --> $DIR/redundant_pattern_matching_result.rs:139:5
+  --> $DIR/redundant_pattern_matching_result.rs:140:5
    |
 LL | /     match x {
 LL | |         Ok(_) => false,
@@ -169,7 +169,7 @@ LL | |     };
    | |_____^ help: try this: `x.is_err()`
 
 error: redundant pattern matching, consider using `is_err()`
-  --> $DIR/redundant_pattern_matching_result.rs:144:5
+  --> $DIR/redundant_pattern_matching_result.rs:145:5
    |
 LL | /     match x {
 LL | |         Err(_) => true,
@@ -178,7 +178,7 @@ LL | |     };
    | |_____^ help: try this: `x.is_err()`
 
 error: redundant pattern matching, consider using `is_ok()`
-  --> $DIR/redundant_pattern_matching_result.rs:149:5
+  --> $DIR/redundant_pattern_matching_result.rs:150:5
    |
 LL | /     match x {
 LL | |         Err(_) => false,
@@ -186,5 +186,17 @@ LL | |         _ => true,
 LL | |     };
    | |_____^ help: try this: `x.is_ok()`
 
-error: aborting due to 26 previous errors
+error: redundant pattern matching, consider using `is_ok()`
+  --> $DIR/redundant_pattern_matching_result.rs:171:13
+   |
+LL |     let _ = matches!(x, Ok(_));
+   |             ^^^^^^^^^^^^^^^^^^ help: try this: `x.is_ok()`
+
+error: redundant pattern matching, consider using `is_err()`
+  --> $DIR/redundant_pattern_matching_result.rs:173:13
+   |
+LL |     let _ = matches!(x, Err(_));
+   |             ^^^^^^^^^^^^^^^^^^^ help: try this: `x.is_err()`
+
+error: aborting due to 28 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From ffc2bc83b024a547ceecf3117149c1fbe9f560df Mon Sep 17 00:00:00 2001
From: Renato Lochetti <renato.lochetti@gmail.com>
Date: Sun, 28 May 2023 12:53:03 +0100
Subject: Fixing `invalid_regex` with invalid UTF8. Also, adding more test
 cases

---
 clippy_lints/src/regex.rs |  2 +-
 tests/ui/regex.rs         |  7 +++++++
 tests/ui/regex.stderr     | 30 ++++++++++++++++++------------
 3 files changed, 26 insertions(+), 13 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/regex.rs b/clippy_lints/src/regex.rs
index ef19c6f4617..674f8bf4c0f 100644
--- a/clippy_lints/src/regex.rs
+++ b/clippy_lints/src/regex.rs
@@ -177,7 +177,7 @@ fn check_set<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, utf8: bool) {
 }
 
 fn check_regex<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, utf8: bool) {
-    let mut parser = regex_syntax::ParserBuilder::new().unicode(true).utf8(!utf8).build();
+    let mut parser = regex_syntax::ParserBuilder::new().unicode(true).utf8(utf8).build();
 
     if let ExprKind::Lit(lit) = expr.kind {
         if let LitKind::Str(ref r, style) = lit.node {
diff --git a/tests/ui/regex.rs b/tests/ui/regex.rs
index a5f79b139bc..1c8e47ab594 100644
--- a/tests/ui/regex.rs
+++ b/tests/ui/regex.rs
@@ -42,6 +42,11 @@ fn syntax_error() {
     let escaped_string_span = Regex::new("\\b\\c");
 
     let aux_span = Regex::new("(?ixi)");
+
+    let should_not_lint = Regex::new("(?u).");
+    let should_not_lint = BRegex::new("(?u).");
+    let invalid_utf8_should_not_lint = BRegex::new("(?-u).");
+    let invalid_utf8_should_lint = Regex::new("(?-u).");
 }
 
 fn trivial_regex() {
@@ -71,6 +76,8 @@ fn trivial_regex() {
     // non-trivial regexes
     let non_trivial_dot = Regex::new("a.b");
     let non_trivial_dot_builder = RegexBuilder::new("a.b");
+    let non_trivial_dot = Regex::new(".");
+    let non_trivial_dot = BRegex::new(".");
     let non_trivial_eq = Regex::new("^foo|bar$");
     let non_trivial_starts_with = Regex::new("^foo|bar");
     let non_trivial_ends_with = Regex::new("^foo|bar");
diff --git a/tests/ui/regex.stderr b/tests/ui/regex.stderr
index 6b8a772e7f0..1e8a21283cd 100644
--- a/tests/ui/regex.stderr
+++ b/tests/ui/regex.stderr
@@ -99,8 +99,14 @@ error: regex syntax error: duplicate flag
 LL |     let aux_span = Regex::new("(?ixi)");
    |                                  ^ ^
 
+error: regex syntax error: pattern can match invalid UTF-8
+  --> $DIR/regex.rs:49:53
+   |
+LL |     let invalid_utf8_should_lint = Regex::new("(?-u).");
+   |                                                     ^
+
 error: trivial regex
-  --> $DIR/regex.rs:48:33
+  --> $DIR/regex.rs:53:33
    |
 LL |     let trivial_eq = Regex::new("^foobar$");
    |                                 ^^^^^^^^^^
@@ -108,7 +114,7 @@ LL |     let trivial_eq = Regex::new("^foobar$");
    = help: consider using `==` on `str`s
 
 error: trivial regex
-  --> $DIR/regex.rs:50:48
+  --> $DIR/regex.rs:55:48
    |
 LL |     let trivial_eq_builder = RegexBuilder::new("^foobar$");
    |                                                ^^^^^^^^^^
@@ -116,7 +122,7 @@ LL |     let trivial_eq_builder = RegexBuilder::new("^foobar$");
    = help: consider using `==` on `str`s
 
 error: trivial regex
-  --> $DIR/regex.rs:52:42
+  --> $DIR/regex.rs:57:42
    |
 LL |     let trivial_starts_with = Regex::new("^foobar");
    |                                          ^^^^^^^^^
@@ -124,7 +130,7 @@ LL |     let trivial_starts_with = Regex::new("^foobar");
    = help: consider using `str::starts_with`
 
 error: trivial regex
-  --> $DIR/regex.rs:54:40
+  --> $DIR/regex.rs:59:40
    |
 LL |     let trivial_ends_with = Regex::new("foobar$");
    |                                        ^^^^^^^^^
@@ -132,7 +138,7 @@ LL |     let trivial_ends_with = Regex::new("foobar$");
    = help: consider using `str::ends_with`
 
 error: trivial regex
-  --> $DIR/regex.rs:56:39
+  --> $DIR/regex.rs:61:39
    |
 LL |     let trivial_contains = Regex::new("foobar");
    |                                       ^^^^^^^^
@@ -140,7 +146,7 @@ LL |     let trivial_contains = Regex::new("foobar");
    = help: consider using `str::contains`
 
 error: trivial regex
-  --> $DIR/regex.rs:58:39
+  --> $DIR/regex.rs:63:39
    |
 LL |     let trivial_contains = Regex::new(NOT_A_REAL_REGEX);
    |                                       ^^^^^^^^^^^^^^^^
@@ -148,7 +154,7 @@ LL |     let trivial_contains = Regex::new(NOT_A_REAL_REGEX);
    = help: consider using `str::contains`
 
 error: trivial regex
-  --> $DIR/regex.rs:60:40
+  --> $DIR/regex.rs:65:40
    |
 LL |     let trivial_backslash = Regex::new("a/.b");
    |                                        ^^^^^^^
@@ -156,7 +162,7 @@ LL |     let trivial_backslash = Regex::new("a/.b");
    = help: consider using `str::contains`
 
 error: trivial regex
-  --> $DIR/regex.rs:63:36
+  --> $DIR/regex.rs:68:36
    |
 LL |     let trivial_empty = Regex::new("");
    |                                    ^^
@@ -164,7 +170,7 @@ LL |     let trivial_empty = Regex::new("");
    = help: the regex is unlikely to be useful as it is
 
 error: trivial regex
-  --> $DIR/regex.rs:65:36
+  --> $DIR/regex.rs:70:36
    |
 LL |     let trivial_empty = Regex::new("^");
    |                                    ^^^
@@ -172,7 +178,7 @@ LL |     let trivial_empty = Regex::new("^");
    = help: the regex is unlikely to be useful as it is
 
 error: trivial regex
-  --> $DIR/regex.rs:67:36
+  --> $DIR/regex.rs:72:36
    |
 LL |     let trivial_empty = Regex::new("^$");
    |                                    ^^^^
@@ -180,12 +186,12 @@ LL |     let trivial_empty = Regex::new("^$");
    = help: consider using `str::is_empty`
 
 error: trivial regex
-  --> $DIR/regex.rs:69:44
+  --> $DIR/regex.rs:74:44
    |
 LL |     let binary_trivial_empty = BRegex::new("^$");
    |                                            ^^^^
    |
    = help: consider using `str::is_empty`
 
-error: aborting due to 23 previous errors
+error: aborting due to 24 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From c10876e6c569ec33c4e4c9db14ffec46435e0300 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Sun, 28 May 2023 21:50:08 +0000
Subject: from_over_into: Show suggestions for non-Self expanded paths

---
 clippy_lints/src/from_over_into.rs   |  3 ++-
 tests/ui/from_over_into.fixed        |  9 +++++++++
 tests/ui/from_over_into.rs           |  9 +++++++++
 tests/ui/from_over_into.stderr       | 18 ++++++++++++++++--
 tests/ui/from_over_into_unfixable.rs |  6 +++---
 5 files changed, 39 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/from_over_into.rs b/clippy_lints/src/from_over_into.rs
index 10ce2a0f0c7..eb967e3f95e 100644
--- a/clippy_lints/src/from_over_into.rs
+++ b/clippy_lints/src/from_over_into.rs
@@ -134,9 +134,10 @@ impl<'a, 'tcx> Visitor<'tcx> for SelfFinder<'a, 'tcx> {
                 kw::SelfUpper => self.upper.push(segment.ident.span),
                 _ => continue,
             }
+
+            self.invalid |= segment.ident.span.from_expansion();
         }
 
-        self.invalid |= path.span.from_expansion();
         if !self.invalid {
             walk_path(self, path);
         }
diff --git a/tests/ui/from_over_into.fixed b/tests/ui/from_over_into.fixed
index d18f9387565..00895e594f6 100644
--- a/tests/ui/from_over_into.fixed
+++ b/tests/ui/from_over_into.fixed
@@ -60,6 +60,15 @@ impl From<String> for A {
     }
 }
 
+struct PathInExpansion;
+
+impl From<PathInExpansion> for String {
+    fn from(val: PathInExpansion) -> Self {
+        // non self/Self paths in expansions are fine
+        panic!()
+    }
+}
+
 #[clippy::msrv = "1.40"]
 fn msrv_1_40() {
     struct FromOverInto<T>(Vec<T>);
diff --git a/tests/ui/from_over_into.rs b/tests/ui/from_over_into.rs
index de8ff0b06bd..7f8c76693fd 100644
--- a/tests/ui/from_over_into.rs
+++ b/tests/ui/from_over_into.rs
@@ -60,6 +60,15 @@ impl From<String> for A {
     }
 }
 
+struct PathInExpansion;
+
+impl Into<String> for PathInExpansion {
+    fn into(self) -> String {
+        // non self/Self paths in expansions are fine
+        panic!()
+    }
+}
+
 #[clippy::msrv = "1.40"]
 fn msrv_1_40() {
     struct FromOverInto<T>(Vec<T>);
diff --git a/tests/ui/from_over_into.stderr b/tests/ui/from_over_into.stderr
index 6039f86fe67..498b00de5ad 100644
--- a/tests/ui/from_over_into.stderr
+++ b/tests/ui/from_over_into.stderr
@@ -59,7 +59,21 @@ LL ~         val.0
    |
 
 error: an implementation of `From` is preferred since it gives you `Into<_>` for free where the reverse isn't true
-  --> $DIR/from_over_into.rs:78:5
+  --> $DIR/from_over_into.rs:65:1
+   |
+LL | impl Into<String> for PathInExpansion {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: `impl From<Local> for Foreign` is allowed by the orphan rules, for more information see
+           https://doc.rust-lang.org/reference/items/implementations.html#trait-implementation-coherence
+help: replace the `Into` implementation with `From<PathInExpansion>`
+   |
+LL ~ impl From<PathInExpansion> for String {
+LL ~     fn from(val: PathInExpansion) -> Self {
+   |
+
+error: an implementation of `From` is preferred since it gives you `Into<_>` for free where the reverse isn't true
+  --> $DIR/from_over_into.rs:87:5
    |
 LL |     impl<T> Into<FromOverInto<T>> for Vec<T> {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -71,5 +85,5 @@ LL ~         fn from(val: Vec<T>) -> Self {
 LL ~             FromOverInto(val)
    |
 
-error: aborting due to 5 previous errors
+error: aborting due to 6 previous errors
 
diff --git a/tests/ui/from_over_into_unfixable.rs b/tests/ui/from_over_into_unfixable.rs
index 3b280b7488a..7303b805673 100644
--- a/tests/ui/from_over_into_unfixable.rs
+++ b/tests/ui/from_over_into_unfixable.rs
@@ -3,14 +3,14 @@
 struct InMacro(String);
 
 macro_rules! in_macro {
-    ($e:ident) => {
-        $e
+    () => {
+        Self::new()
     };
 }
 
 impl Into<InMacro> for String {
     fn into(self) -> InMacro {
-        InMacro(in_macro!(self))
+        InMacro(in_macro!())
     }
 }
 
-- 
cgit 1.4.1-3-g733a5


From c5b974b55da246ee0850f5b38084f93cf5e0b913 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Mon, 29 May 2023 00:46:15 +0200
Subject: Update version attribute for 1.70 lints

---
 clippy_lints/src/allow_attributes.rs         | 2 +-
 clippy_lints/src/collection_is_never_read.rs | 2 +-
 clippy_lints/src/large_futures.rs            | 2 +-
 clippy_lints/src/let_with_type_underscore.rs | 2 +-
 clippy_lints/src/methods/mod.rs              | 2 +-
 clippy_lints/src/missing_assert_message.rs   | 2 +-
 clippy_lints/src/redundant_async_block.rs    | 2 +-
 7 files changed, 7 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/allow_attributes.rs b/clippy_lints/src/allow_attributes.rs
index add73d0aeee..554efdc58e1 100644
--- a/clippy_lints/src/allow_attributes.rs
+++ b/clippy_lints/src/allow_attributes.rs
@@ -40,7 +40,7 @@ declare_clippy_lint! {
     ///     a.len()
     /// }
     /// ```
-    #[clippy::version = "1.69.0"]
+    #[clippy::version = "1.70.0"]
     pub ALLOW_ATTRIBUTES,
     restriction,
     "`#[allow]` will not trigger if a warning isn't found. `#[expect]` triggers if there are no warnings."
diff --git a/clippy_lints/src/collection_is_never_read.rs b/clippy_lints/src/collection_is_never_read.rs
index 5e2eb5789f6..ac5ac542cf9 100644
--- a/clippy_lints/src/collection_is_never_read.rs
+++ b/clippy_lints/src/collection_is_never_read.rs
@@ -37,7 +37,7 @@ declare_clippy_lint! {
     ///     println!("{sample}");
     /// }
     /// ```
-    #[clippy::version = "1.69.0"]
+    #[clippy::version = "1.70.0"]
     pub COLLECTION_IS_NEVER_READ,
     nursery,
     "a collection is never queried"
diff --git a/clippy_lints/src/large_futures.rs b/clippy_lints/src/large_futures.rs
index 0ca31033b16..087c4a65250 100644
--- a/clippy_lints/src/large_futures.rs
+++ b/clippy_lints/src/large_futures.rs
@@ -38,7 +38,7 @@ declare_clippy_lint! {
     ///     wait(fut).await;
     /// }
     /// ```
-    #[clippy::version = "1.68.0"]
+    #[clippy::version = "1.70.0"]
     pub LARGE_FUTURES,
     pedantic,
     "large future may lead to unexpected stack overflows"
diff --git a/clippy_lints/src/let_with_type_underscore.rs b/clippy_lints/src/let_with_type_underscore.rs
index c01e3882d52..2f10e3d2581 100644
--- a/clippy_lints/src/let_with_type_underscore.rs
+++ b/clippy_lints/src/let_with_type_underscore.rs
@@ -17,7 +17,7 @@ declare_clippy_lint! {
     /// ```rust,ignore
     /// let my_number = 1;
     /// ```
-    #[clippy::version = "1.69.0"]
+    #[clippy::version = "1.70.0"]
     pub LET_WITH_TYPE_UNDERSCORE,
     complexity,
     "unneeded underscore type (`_`) in a variable declaration"
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 9a594d964ab..88cbefbb5d3 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3191,7 +3191,7 @@ declare_clippy_lint! {
     /// let mut v = vec![1, 2, 3];
     /// v.clear();
     /// ```
-    #[clippy::version = "1.69.0"]
+    #[clippy::version = "1.70.0"]
     pub CLEAR_WITH_DRAIN,
     nursery,
     "calling `drain` in order to `clear` a container"
diff --git a/clippy_lints/src/missing_assert_message.rs b/clippy_lints/src/missing_assert_message.rs
index 2214a568d9c..4dbb79334ca 100644
--- a/clippy_lints/src/missing_assert_message.rs
+++ b/clippy_lints/src/missing_assert_message.rs
@@ -36,7 +36,7 @@ declare_clippy_lint! {
     ///     assert!(service.ready, "`service.poll_ready()` must be called first to ensure that service is ready to receive requests");
     /// }
     /// ```
-    #[clippy::version = "1.69.0"]
+    #[clippy::version = "1.70.0"]
     pub MISSING_ASSERT_MESSAGE,
     restriction,
     "checks assertions without a custom panic message"
diff --git a/clippy_lints/src/redundant_async_block.rs b/clippy_lints/src/redundant_async_block.rs
index a0f831764d0..05e52e6b38b 100644
--- a/clippy_lints/src/redundant_async_block.rs
+++ b/clippy_lints/src/redundant_async_block.rs
@@ -35,7 +35,7 @@ declare_clippy_lint! {
     /// };
     /// let fut = f;
     /// ```
-    #[clippy::version = "1.69.0"]
+    #[clippy::version = "1.70.0"]
     pub REDUNDANT_ASYNC_BLOCK,
     complexity,
     "`async { future.await }` can be replaced by `future`"
-- 
cgit 1.4.1-3-g733a5


From d3534a65215dc8b0d071baf7208471f2296fc8a7 Mon Sep 17 00:00:00 2001
From: disco07 <koneenok@outlook.fr>
Date: Tue, 30 May 2023 07:43:10 +0200
Subject: fix issues 10836

---
 clippy_lints/src/booleans.rs    | 29 +++++++++++++++++++++++++++++
 tests/ui/nonminimal_bool.rs     | 16 +++++++++++++++-
 tests/ui/nonminimal_bool.stderr | 26 ++++++++++----------------
 3 files changed, 54 insertions(+), 17 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/booleans.rs b/clippy_lints/src/booleans.rs
index 455f0df7cd0..4bd48185f37 100644
--- a/clippy_lints/src/booleans.rs
+++ b/clippy_lints/src/booleans.rs
@@ -8,10 +8,12 @@ use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_expr, FnKind, Visitor};
 use rustc_hir::{BinOpKind, Body, Expr, ExprKind, FnDecl, UnOp};
 use rustc_lint::{LateContext, LateLintPass, Level};
+use rustc_middle::ty::{self, Ty};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::def_id::LocalDefId;
 use rustc_span::source_map::Span;
 use rustc_span::sym;
+use rustc_span::symbol::Ident;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -89,6 +91,27 @@ impl<'tcx> LateLintPass<'tcx> for NonminimalBool {
     }
 }
 
+fn is_impl_not_trait_with_bool_out<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
+    cx.tcx
+        .lang_items()
+        .not_trait()
+        .filter(|trait_id| implements_trait(cx, ty, *trait_id, &[]))
+        .and_then(|trait_id| {
+            cx.tcx.associated_items(trait_id).find_by_name_and_kind(
+                cx.tcx,
+                Ident::from_str("Output"),
+                ty::AssocKind::Type,
+                trait_id,
+            )
+        })
+        .map_or(false, |assoc_item| {
+            let proj = cx.tcx.mk_projection(assoc_item.def_id, cx.tcx.mk_substs_trait(ty, []));
+            let nty = cx.tcx.normalize_erasing_regions(cx.param_env, proj);
+
+            nty.is_bool()
+        })
+}
+
 struct NonminimalBoolVisitor<'a, 'tcx> {
     cx: &'a LateContext<'tcx>,
 }
@@ -473,6 +496,12 @@ impl<'a, 'tcx> Visitor<'tcx> for NonminimalBoolVisitor<'a, 'tcx> {
                     self.bool_expr(e);
                 },
                 ExprKind::Unary(UnOp::Not, inner) => {
+                    if let ExprKind::Unary(UnOp::Not, ex) = inner.kind {
+                        let ty = self.cx.typeck_results().expr_ty(ex);
+                        if is_impl_not_trait_with_bool_out(self.cx, ty) {
+                            return;
+                        }
+                    }
                     if self.cx.typeck_results().node_types()[inner.hir_id].is_bool() {
                         self.bool_expr(e);
                     }
diff --git a/tests/ui/nonminimal_bool.rs b/tests/ui/nonminimal_bool.rs
index 80cc7c60f56..54cbbdef22e 100644
--- a/tests/ui/nonminimal_bool.rs
+++ b/tests/ui/nonminimal_bool.rs
@@ -10,6 +10,7 @@ fn main() {
     let e: bool = unimplemented!();
     let _ = !true;
     let _ = !false;
+    // vvv Should not lint
     let _ = !!a;
     let _ = false || a;
     // don't lint on cfgs
@@ -54,7 +55,6 @@ fn issue4548() {
 
 fn check_expect() {
     let a: bool = unimplemented!();
-    #[expect(clippy::nonminimal_bool)]
     let _ = !!a;
 }
 
@@ -110,3 +110,17 @@ fn issue_10435() {
         println!("{}", line!());
     }
 }
+
+fn issue10836() {
+    struct Foo(bool);
+    impl std::ops::Not for Foo {
+        type Output = bool;
+
+        fn not(self) -> Self::Output {
+            !self.0
+        }
+    }
+
+    // Should not lint
+    let _: bool = !!Foo(true);
+}
diff --git a/tests/ui/nonminimal_bool.stderr b/tests/ui/nonminimal_bool.stderr
index 91b5805aa97..fa14471301e 100644
--- a/tests/ui/nonminimal_bool.stderr
+++ b/tests/ui/nonminimal_bool.stderr
@@ -13,37 +13,31 @@ LL |     let _ = !false;
    |             ^^^^^^ help: try: `true`
 
 error: this boolean expression can be simplified
-  --> $DIR/nonminimal_bool.rs:13:13
-   |
-LL |     let _ = !!a;
-   |             ^^^ help: try: `a`
-
-error: this boolean expression can be simplified
-  --> $DIR/nonminimal_bool.rs:14:13
+  --> $DIR/nonminimal_bool.rs:15:13
    |
 LL |     let _ = false || a;
    |             ^^^^^^^^^^ help: try: `a`
 
 error: this boolean expression can be simplified
-  --> $DIR/nonminimal_bool.rs:18:13
+  --> $DIR/nonminimal_bool.rs:19:13
    |
 LL |     let _ = !(!a && b);
    |             ^^^^^^^^^^ help: try: `a || !b`
 
 error: this boolean expression can be simplified
-  --> $DIR/nonminimal_bool.rs:19:13
+  --> $DIR/nonminimal_bool.rs:20:13
    |
 LL |     let _ = !(!a || b);
    |             ^^^^^^^^^^ help: try: `a && !b`
 
 error: this boolean expression can be simplified
-  --> $DIR/nonminimal_bool.rs:20:13
+  --> $DIR/nonminimal_bool.rs:21:13
    |
 LL |     let _ = !a && !(b && c);
    |             ^^^^^^^^^^^^^^^ help: try: `!(a || b && c)`
 
 error: this boolean expression can be simplified
-  --> $DIR/nonminimal_bool.rs:28:13
+  --> $DIR/nonminimal_bool.rs:29:13
    |
 LL |     let _ = a == b && c == 5 && a == b;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -56,7 +50,7 @@ LL |     let _ = a == b && c == 5;
    |             ~~~~~~~~~~~~~~~~
 
 error: this boolean expression can be simplified
-  --> $DIR/nonminimal_bool.rs:29:13
+  --> $DIR/nonminimal_bool.rs:30:13
    |
 LL |     let _ = a == b || c == 5 || a == b;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -69,7 +63,7 @@ LL |     let _ = a == b || c == 5;
    |             ~~~~~~~~~~~~~~~~
 
 error: this boolean expression can be simplified
-  --> $DIR/nonminimal_bool.rs:30:13
+  --> $DIR/nonminimal_bool.rs:31:13
    |
 LL |     let _ = a == b && c == 5 && b == a;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -82,7 +76,7 @@ LL |     let _ = a == b && c == 5;
    |             ~~~~~~~~~~~~~~~~
 
 error: this boolean expression can be simplified
-  --> $DIR/nonminimal_bool.rs:31:13
+  --> $DIR/nonminimal_bool.rs:32:13
    |
 LL |     let _ = a != b || !(a != b || c == d);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -95,7 +89,7 @@ LL |     let _ = a != b || c != d;
    |             ~~~~~~~~~~~~~~~~
 
 error: this boolean expression can be simplified
-  --> $DIR/nonminimal_bool.rs:32:13
+  --> $DIR/nonminimal_bool.rs:33:13
    |
 LL |     let _ = a != b && !(a != b && c == d);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -113,5 +107,5 @@ error: this boolean expression can be simplified
 LL |     if matches!(true, true) && true {
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `matches!(true, true)`
 
-error: aborting due to 13 previous errors
+error: aborting due to 12 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 288312463e2dbfac15b5ba2dbbc2d015d5dfb683 Mon Sep 17 00:00:00 2001
From: Charalampos Mitrodimas <charmitro@gmail.com>
Date: Tue, 30 May 2023 21:29:04 +0300
Subject: [`wildcard_imports`] Modules that contain `prelude` are also allowed

This commit fixes #10846 by checking if the path segment contains the
word "prelude".

Signed-off-by: Charalampos Mitrodimas <charmitro@gmail.com>
---
 clippy_lints/src/wildcard_imports.rs          |  9 +++++---
 tests/ui/auxiliary/wildcard_imports_helper.rs |  6 ++++++
 tests/ui/wildcard_imports.fixed               |  2 ++
 tests/ui/wildcard_imports.rs                  |  2 ++
 tests/ui/wildcard_imports.stderr              | 30 +++++++++++++--------------
 5 files changed, 31 insertions(+), 18 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/wildcard_imports.rs b/clippy_lints/src/wildcard_imports.rs
index a9089fba3c5..b6e4cd22789 100644
--- a/clippy_lints/src/wildcard_imports.rs
+++ b/clippy_lints/src/wildcard_imports.rs
@@ -65,8 +65,9 @@ declare_clippy_lint! {
     /// This can lead to confusing error messages at best and to unexpected behavior at worst.
     ///
     /// ### Exceptions
-    /// Wildcard imports are allowed from modules named `prelude`. Many crates (including the standard library)
-    /// provide modules named "prelude" specifically designed for wildcard import.
+    /// Wildcard imports are allowed from modules that their name contains `prelude`. Many crates
+    /// (including the standard library) provide modules named "prelude" specifically designed
+    /// for wildcard import.
     ///
     /// `use super::*` is allowed in test modules. This is defined as any module with "test" in the name.
     ///
@@ -212,7 +213,9 @@ impl WildcardImports {
 // Allow "...prelude::..::*" imports.
 // Many crates have a prelude, and it is imported as a glob by design.
 fn is_prelude_import(segments: &[PathSegment<'_>]) -> bool {
-    segments.iter().any(|ps| ps.ident.name == sym::prelude)
+    segments
+        .iter()
+        .any(|ps| ps.ident.name.as_str().contains(sym::prelude.as_str()))
 }
 
 // Allow "super::*" imports in tests.
diff --git a/tests/ui/auxiliary/wildcard_imports_helper.rs b/tests/ui/auxiliary/wildcard_imports_helper.rs
index d75cdd625f9..44f49c080cd 100644
--- a/tests/ui/auxiliary/wildcard_imports_helper.rs
+++ b/tests/ui/auxiliary/wildcard_imports_helper.rs
@@ -25,3 +25,9 @@ pub mod prelude {
         pub struct PreludeModAnywhere;
     }
 }
+
+pub mod extern_prelude {
+    pub mod v1 {
+        pub struct ExternPreludeModAnywhere;
+    }
+}
diff --git a/tests/ui/wildcard_imports.fixed b/tests/ui/wildcard_imports.fixed
index bd845361fa8..733bbcfbcef 100644
--- a/tests/ui/wildcard_imports.fixed
+++ b/tests/ui/wildcard_imports.fixed
@@ -24,6 +24,7 @@ use wildcard_imports_helper::inner::inner_for_self_import::inner_extern_bar;
 use wildcard_imports_helper::{ExternA, extern_foo};
 
 use std::io::prelude::*;
+use wildcard_imports_helper::extern_prelude::v1::*;
 use wildcard_imports_helper::prelude::v1::*;
 
 struct ReadFoo;
@@ -81,6 +82,7 @@ fn main() {
     let _ = inner_struct_mod::C;
     let _ = ExternA;
     let _ = PreludeModAnywhere;
+    let _ = ExternPreludeModAnywhere;
 
     double_struct_import_test!();
     double_struct_import_test!();
diff --git a/tests/ui/wildcard_imports.rs b/tests/ui/wildcard_imports.rs
index fb51f7bdfcc..4acdd374bde 100644
--- a/tests/ui/wildcard_imports.rs
+++ b/tests/ui/wildcard_imports.rs
@@ -24,6 +24,7 @@ use wildcard_imports_helper::inner::inner_for_self_import::*;
 use wildcard_imports_helper::*;
 
 use std::io::prelude::*;
+use wildcard_imports_helper::extern_prelude::v1::*;
 use wildcard_imports_helper::prelude::v1::*;
 
 struct ReadFoo;
@@ -81,6 +82,7 @@ fn main() {
     let _ = inner_struct_mod::C;
     let _ = ExternA;
     let _ = PreludeModAnywhere;
+    let _ = ExternPreludeModAnywhere;
 
     double_struct_import_test!();
     double_struct_import_test!();
diff --git a/tests/ui/wildcard_imports.stderr b/tests/ui/wildcard_imports.stderr
index 6b469cdfc44..235be2d5708 100644
--- a/tests/ui/wildcard_imports.stderr
+++ b/tests/ui/wildcard_imports.stderr
@@ -37,55 +37,55 @@ LL | use wildcard_imports_helper::*;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `wildcard_imports_helper::{ExternA, extern_foo}`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:95:13
+  --> $DIR/wildcard_imports.rs:97:13
    |
 LL |         use crate::fn_mod::*;
    |             ^^^^^^^^^^^^^^^^ help: try: `crate::fn_mod::foo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:101:75
+  --> $DIR/wildcard_imports.rs:103:75
    |
 LL |         use wildcard_imports_helper::inner::inner_for_self_import::{self, *};
    |                                                                           ^ help: try: `inner_extern_foo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:102:13
+  --> $DIR/wildcard_imports.rs:104:13
    |
 LL |         use wildcard_imports_helper::*;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `wildcard_imports_helper::{ExternA, extern_foo}`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:113:20
+  --> $DIR/wildcard_imports.rs:115:20
    |
 LL |         use self::{inner::*, inner2::*};
    |                    ^^^^^^^^ help: try: `inner::inner_foo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:113:30
+  --> $DIR/wildcard_imports.rs:115:30
    |
 LL |         use self::{inner::*, inner2::*};
    |                              ^^^^^^^^^ help: try: `inner2::inner_bar`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:120:13
+  --> $DIR/wildcard_imports.rs:122:13
    |
 LL |         use wildcard_imports_helper::*;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `wildcard_imports_helper::{ExternExportedEnum, ExternExportedStruct, extern_exported}`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:149:9
+  --> $DIR/wildcard_imports.rs:151:9
    |
 LL |     use crate::in_fn_test::*;
    |         ^^^^^^^^^^^^^^^^^^^^ help: try: `crate::in_fn_test::{ExportedEnum, ExportedStruct, exported}`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:158:9
+  --> $DIR/wildcard_imports.rs:160:9
    |
 LL |     use crate:: in_fn_test::  * ;
    |         ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `crate:: in_fn_test::exported`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:159:9
+  --> $DIR/wildcard_imports.rs:161:9
    |
 LL |       use crate:: fn_mod::
    |  _________^
@@ -93,37 +93,37 @@ LL | |         *;
    | |_________^ help: try: `crate:: fn_mod::foo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:170:13
+  --> $DIR/wildcard_imports.rs:172:13
    |
 LL |         use super::*;
    |             ^^^^^^^^ help: try: `super::foofoo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:205:17
+  --> $DIR/wildcard_imports.rs:207:17
    |
 LL |             use super::*;
    |                 ^^^^^^^^ help: try: `super::insidefoo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:213:13
+  --> $DIR/wildcard_imports.rs:215:13
    |
 LL |         use super_imports::*;
    |             ^^^^^^^^^^^^^^^^ help: try: `super_imports::foofoo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:222:17
+  --> $DIR/wildcard_imports.rs:224:17
    |
 LL |             use super::super::*;
    |                 ^^^^^^^^^^^^^^^ help: try: `super::super::foofoo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:231:13
+  --> $DIR/wildcard_imports.rs:233:13
    |
 LL |         use super::super::super_imports::*;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `super::super::super_imports::foofoo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:239:13
+  --> $DIR/wildcard_imports.rs:241:13
    |
 LL |         use super::*;
    |             ^^^^^^^^ help: try: `super::foofoo`
-- 
cgit 1.4.1-3-g733a5


From de1f410018b6ec176a5584896ce017ab3f3edf91 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Tue, 30 May 2023 22:32:26 +0200
Subject: merge `explicit_into_iter_fn_arg` into `useless_conversion`

---
 CHANGELOG.md                                  |   1 -
 clippy_lints/src/declared_lints.rs            |   1 -
 clippy_lints/src/explicit_into_iter_fn_arg.rs | 142 --------------------------
 clippy_lints/src/lib.rs                       |   2 -
 clippy_lints/src/useless_conversion.rs        | 121 ++++++++++++++++++++--
 tests/ui/explicit_into_iter_fn_arg.fixed      |  33 ------
 tests/ui/explicit_into_iter_fn_arg.rs         |  33 ------
 tests/ui/explicit_into_iter_fn_arg.stderr     |  39 -------
 tests/ui/useless_conversion.fixed             |  29 ++++++
 tests/ui/useless_conversion.rs                |  29 ++++++
 tests/ui/useless_conversion.stderr            |  62 ++++++++++-
 11 files changed, 234 insertions(+), 258 deletions(-)
 delete mode 100644 clippy_lints/src/explicit_into_iter_fn_arg.rs
 delete mode 100644 tests/ui/explicit_into_iter_fn_arg.fixed
 delete mode 100644 tests/ui/explicit_into_iter_fn_arg.rs
 delete mode 100644 tests/ui/explicit_into_iter_fn_arg.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 7a127c08197..a2648d9faa6 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4642,7 +4642,6 @@ Released 2018-09-13
 [`explicit_auto_deref`]: https://rust-lang.github.io/rust-clippy/master/index.html#explicit_auto_deref
 [`explicit_counter_loop`]: https://rust-lang.github.io/rust-clippy/master/index.html#explicit_counter_loop
 [`explicit_deref_methods`]: https://rust-lang.github.io/rust-clippy/master/index.html#explicit_deref_methods
-[`explicit_into_iter_fn_arg`]: https://rust-lang.github.io/rust-clippy/master/index.html#explicit_into_iter_fn_arg
 [`explicit_into_iter_loop`]: https://rust-lang.github.io/rust-clippy/master/index.html#explicit_into_iter_loop
 [`explicit_iter_loop`]: https://rust-lang.github.io/rust-clippy/master/index.html#explicit_iter_loop
 [`explicit_write`]: https://rust-lang.github.io/rust-clippy/master/index.html#explicit_write
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index fceb6e4b2ae..4ade25e1257 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -157,7 +157,6 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::exhaustive_items::EXHAUSTIVE_ENUMS_INFO,
     crate::exhaustive_items::EXHAUSTIVE_STRUCTS_INFO,
     crate::exit::EXIT_INFO,
-    crate::explicit_into_iter_fn_arg::EXPLICIT_INTO_ITER_FN_ARG_INFO,
     crate::explicit_write::EXPLICIT_WRITE_INFO,
     crate::extra_unused_type_parameters::EXTRA_UNUSED_TYPE_PARAMETERS_INFO,
     crate::fallible_impl_from::FALLIBLE_IMPL_FROM_INFO,
diff --git a/clippy_lints/src/explicit_into_iter_fn_arg.rs b/clippy_lints/src/explicit_into_iter_fn_arg.rs
deleted file mode 100644
index ff4144df9b9..00000000000
--- a/clippy_lints/src/explicit_into_iter_fn_arg.rs
+++ /dev/null
@@ -1,142 +0,0 @@
-use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::{get_parent_expr, is_trait_method};
-use rustc_errors::Applicability;
-use rustc_hir::def_id::DefId;
-use rustc_hir::{Expr, ExprKind};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::sym;
-use rustc_span::Span;
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for calls to [`IntoIterator::into_iter`](https://doc.rust-lang.org/stable/std/iter/trait.IntoIterator.html#tymethod.into_iter)
-    /// in a call argument that accepts `IntoIterator`.
-    ///
-    /// ### Why is this bad?
-    /// If a generic parameter has an `IntoIterator` bound, there is no need to call `.into_iter()` at call site.
-    /// Calling `IntoIterator::into_iter()` on a value implies that its type already implements `IntoIterator`,
-    /// so you can just pass the value as is.
-    ///
-    /// ### Example
-    /// ```rust
-    /// fn even_sum<I: IntoIterator<Item = i32>>(iter: I) -> i32 {
-    ///     iter.into_iter().filter(|&x| x % 2 == 0).sum()
-    /// }
-    ///
-    /// let _ = even_sum([1, 2, 3].into_iter());
-    /// //                        ^^^^^^^^^^^^ redundant. `[i32; 3]` implements `IntoIterator`
-    /// ```
-    /// Use instead:
-    /// ```rust
-    /// fn even_sum<I: IntoIterator<Item = i32>>(iter: I) -> i32 {
-    ///     iter.into_iter().filter(|&x| x % 2 == 0).sum()
-    /// }
-    ///
-    /// let _ = even_sum([1, 2, 3]);
-    /// ```
-    #[clippy::version = "1.71.0"]
-    pub EXPLICIT_INTO_ITER_FN_ARG,
-    pedantic,
-    "explicit call to `.into_iter()` in function argument accepting `IntoIterator`"
-}
-declare_lint_pass!(ExplicitIntoIterFnArg => [EXPLICIT_INTO_ITER_FN_ARG]);
-
-enum MethodOrFunction {
-    Method,
-    Function,
-}
-
-impl MethodOrFunction {
-    /// Maps the argument position in `pos` to the parameter position.
-    /// For methods, `self` is skipped.
-    fn param_pos(self, pos: usize) -> usize {
-        match self {
-            MethodOrFunction::Method => pos + 1,
-            MethodOrFunction::Function => pos,
-        }
-    }
-}
-
-/// Returns the span of the `IntoIterator` trait bound in the function pointed to by `fn_did`
-fn into_iter_bound(cx: &LateContext<'_>, fn_did: DefId, into_iter_did: DefId, param_index: u32) -> Option<Span> {
-    cx.tcx
-        .predicates_of(fn_did)
-        .predicates
-        .iter()
-        .find_map(|&(ref pred, span)| {
-            if let ty::PredicateKind::Clause(ty::Clause::Trait(tr)) = pred.kind().skip_binder()
-                && tr.def_id() == into_iter_did
-                && tr.self_ty().is_param(param_index)
-            {
-                Some(span)
-            } else {
-                None
-            }
-        })
-}
-
-fn into_iter_call<'hir>(cx: &LateContext<'_>, expr: &'hir Expr<'hir>) -> Option<&'hir Expr<'hir>> {
-    if let ExprKind::MethodCall(name, recv, _, _) = expr.kind
-        && is_trait_method(cx, expr, sym::IntoIterator)
-        && name.ident.name == sym::into_iter
-    {
-        Some(recv)
-    } else {
-        None
-    }
-}
-
-impl<'tcx> LateLintPass<'tcx> for ExplicitIntoIterFnArg {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if expr.span.from_expansion() {
-            return;
-        }
-
-        if let Some(recv) = into_iter_call(cx, expr)
-            && let Some(parent) = get_parent_expr(cx, expr)
-            // Make sure that this is not a chained into_iter call (i.e. `x.into_iter().into_iter()`)
-            // That case is already covered by `useless_conversion` and we don't want to lint twice
-            // with two contradicting suggestions.
-            && into_iter_call(cx, parent).is_none()
-            && into_iter_call(cx, recv).is_none()
-            && let Some(into_iter_did) = cx.tcx.get_diagnostic_item(sym::IntoIterator)
-        {
-
-            let parent = match parent.kind {
-                ExprKind::Call(recv, args) if let ExprKind::Path(ref qpath) = recv.kind => {
-                    cx.qpath_res(qpath, recv.hir_id).opt_def_id()
-                        .map(|did| (did, args, MethodOrFunction::Function))
-                }
-                ExprKind::MethodCall(.., args, _) => {
-                    cx.typeck_results().type_dependent_def_id(parent.hir_id)
-                        .map(|did| (did, args, MethodOrFunction::Method))
-                }
-                _ => None,
-            };
-
-            if let Some((parent_fn_did, args, kind)) = parent
-                && let sig = cx.tcx.fn_sig(parent_fn_did).skip_binder().skip_binder()
-                && let Some(arg_pos) = args.iter().position(|x| x.hir_id == expr.hir_id)
-                && let Some(&into_iter_param) = sig.inputs().get(kind.param_pos(arg_pos))
-                && let ty::Param(param) = into_iter_param.kind()
-                && let Some(span) = into_iter_bound(cx, parent_fn_did, into_iter_did, param.index)
-            {
-                let mut applicability = Applicability::MachineApplicable;
-                let sugg = snippet_with_applicability(cx, recv.span.source_callsite(), "<expr>", &mut applicability).into_owned();
-
-                span_lint_and_then(cx, EXPLICIT_INTO_ITER_FN_ARG, expr.span, "explicit call to `.into_iter()` in function argument accepting `IntoIterator`", |diag| {
-                    diag.span_suggestion(
-                        expr.span,
-                        "consider removing `.into_iter()`",
-                        sugg,
-                        applicability,
-                    );
-                    diag.span_note(span, "this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`");
-                });
-            }
-        }
-    }
-}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index bfe52e182b2..10404d51ba5 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -123,7 +123,6 @@ mod eta_reduction;
 mod excessive_bools;
 mod exhaustive_items;
 mod exit;
-mod explicit_into_iter_fn_arg;
 mod explicit_write;
 mod extra_unused_type_parameters;
 mod fallible_impl_from;
@@ -995,7 +994,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_early_pass(|| Box::new(ref_patterns::RefPatterns));
     store.register_late_pass(|_| Box::new(default_constructed_unit_structs::DefaultConstructedUnitStructs));
     store.register_early_pass(|| Box::new(needless_else::NeedlessElse));
-    store.register_late_pass(|_| Box::new(explicit_into_iter_fn_arg::ExplicitIntoIterFnArg));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/useless_conversion.rs b/clippy_lints/src/useless_conversion.rs
index 28c3fc859e3..6f1e9d5f9de 100644
--- a/clippy_lints/src/useless_conversion.rs
+++ b/clippy_lints/src/useless_conversion.rs
@@ -1,16 +1,17 @@
-use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg};
+use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::is_ty_alias;
-use clippy_utils::source::{snippet, snippet_with_context};
+use clippy_utils::source::{snippet, snippet_with_applicability, snippet_with_context};
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::{is_copy, is_type_diagnostic_item, same_type_and_consts};
 use clippy_utils::{get_parent_expr, is_trait_method, match_def_path, path_to_local, paths};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
+use rustc_hir::def_id::DefId;
 use rustc_hir::{BindingAnnotation, Expr, ExprKind, HirId, MatchSource, Node, PatKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::sym;
+use rustc_span::{sym, Span};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -43,6 +44,65 @@ pub struct UselessConversion {
 
 impl_lint_pass!(UselessConversion => [USELESS_CONVERSION]);
 
+enum MethodOrFunction {
+    Method,
+    Function,
+}
+
+impl MethodOrFunction {
+    /// Maps the argument position in `pos` to the parameter position.
+    /// For methods, `self` is skipped.
+    fn param_pos(self, pos: usize) -> usize {
+        match self {
+            MethodOrFunction::Method => pos + 1,
+            MethodOrFunction::Function => pos,
+        }
+    }
+}
+
+/// Returns the span of the `IntoIterator` trait bound in the function pointed to by `fn_did`
+fn into_iter_bound(cx: &LateContext<'_>, fn_did: DefId, into_iter_did: DefId, param_index: u32) -> Option<Span> {
+    cx.tcx
+        .predicates_of(fn_did)
+        .predicates
+        .iter()
+        .find_map(|&(ref pred, span)| {
+            if let ty::PredicateKind::Clause(ty::Clause::Trait(tr)) = pred.kind().skip_binder()
+                && tr.def_id() == into_iter_did
+                && tr.self_ty().is_param(param_index)
+            {
+                Some(span)
+            } else {
+                None
+            }
+        })
+}
+
+/// Extracts the receiver of a `.into_iter()` method call.
+fn into_iter_call<'hir>(cx: &LateContext<'_>, expr: &'hir Expr<'hir>) -> Option<&'hir Expr<'hir>> {
+    if let ExprKind::MethodCall(name, recv, _, _) = expr.kind
+        && is_trait_method(cx, expr, sym::IntoIterator)
+        && name.ident.name == sym::into_iter
+    {
+        Some(recv)
+    } else {
+        None
+    }
+}
+
+/// Same as [`into_iter_call`], but tries to look for the innermost `.into_iter()` call, e.g.:
+/// `foo.into_iter().into_iter()`
+///  ^^^  we want this expression
+fn into_iter_deep_call<'hir>(cx: &LateContext<'_>, mut expr: &'hir Expr<'hir>) -> Option<&'hir Expr<'hir>> {
+    loop {
+        if let Some(recv) = into_iter_call(cx, expr) {
+            expr = recv;
+        } else {
+            return Some(expr);
+        }
+    }
+}
+
 #[expect(clippy::too_many_lines)]
 impl<'tcx> LateLintPass<'tcx> for UselessConversion {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
@@ -82,9 +142,58 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
                         );
                     }
                 }
-                if is_trait_method(cx, e, sym::IntoIterator) && name.ident.name == sym::into_iter {
-                    if get_parent_expr(cx, e).is_some() &&
-                       let Some(id) = path_to_local(recv) &&
+                if let Some(into_iter_recv) = into_iter_call(cx, e)
+                    // Make sure that there is no parent expression, or if there is, make sure it's not a `.into_iter()` call.
+                    // The reason for that is that we only want to lint once (the outermost call)
+                    // in cases like `foo.into_iter().into_iter()`
+                    && get_parent_expr(cx, e)
+                        .and_then(|parent| into_iter_call(cx, parent))
+                        .is_none()
+                {
+                    if let Some(parent) = get_parent_expr(cx, e) {
+                        let parent_fn = match parent.kind {
+                            ExprKind::Call(recv, args) if let ExprKind::Path(ref qpath) = recv.kind => {
+                                cx.qpath_res(qpath, recv.hir_id).opt_def_id()
+                                    .map(|did| (did, args, MethodOrFunction::Function))
+                            }
+                            ExprKind::MethodCall(.., args, _) => {
+                                cx.typeck_results().type_dependent_def_id(parent.hir_id)
+                                    .map(|did| (did, args, MethodOrFunction::Method))
+                            }
+                            _ => None,
+                        };
+
+                        if let Some((parent_fn_did, args, kind)) = parent_fn
+                            && let Some(into_iter_did) = cx.tcx.get_diagnostic_item(sym::IntoIterator)
+                            && let sig = cx.tcx.fn_sig(parent_fn_did).skip_binder().skip_binder()
+                            && let Some(arg_pos) = args.iter().position(|x| x.hir_id == e.hir_id)
+                            && let Some(&into_iter_param) = sig.inputs().get(kind.param_pos(arg_pos))
+                            && let ty::Param(param) = into_iter_param.kind()
+                            && let Some(span) = into_iter_bound(cx, parent_fn_did, into_iter_did, param.index)
+                            // Get the "innermost" `.into_iter()` call, e.g. given this expression:
+                            // `foo.into_iter().into_iter()`
+                            //  ^^^
+                            //  We want this span
+                            && let Some(into_iter_recv) = into_iter_deep_call(cx, into_iter_recv)
+                        {
+                            let mut applicability = Applicability::MachineApplicable;
+                            let sugg = snippet_with_applicability(cx, into_iter_recv.span.source_callsite(), "<expr>", &mut applicability).into_owned();
+                            span_lint_and_then(cx, USELESS_CONVERSION, e.span, "explicit call to `.into_iter()` in function argument accepting `IntoIterator`", |diag| {
+                                diag.span_suggestion(
+                                    e.span,
+                                    "consider removing `.into_iter()`",
+                                    sugg,
+                                    applicability,
+                                );
+                                diag.span_note(span, "this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`");
+                            });
+
+                            // Early return to avoid linting again with contradicting suggestions
+                            return;
+                        }
+                    }
+
+                    if let Some(id) = path_to_local(recv) &&
                        let Node::Pat(pat) = cx.tcx.hir().get(id) &&
                        let PatKind::Binding(ann, ..) = pat.kind &&
                        ann != BindingAnnotation::MUT
diff --git a/tests/ui/explicit_into_iter_fn_arg.fixed b/tests/ui/explicit_into_iter_fn_arg.fixed
deleted file mode 100644
index 9d778faf8e0..00000000000
--- a/tests/ui/explicit_into_iter_fn_arg.fixed
+++ /dev/null
@@ -1,33 +0,0 @@
-//@run-rustfix
-
-#![allow(unused, clippy::useless_conversion)]
-#![warn(clippy::explicit_into_iter_fn_arg)]
-
-fn a<T>(_: T) {}
-fn b<T: IntoIterator<Item = i32>>(_: T) {}
-fn c(_: impl IntoIterator<Item = i32>) {}
-fn d<T>(_: T)
-where
-    T: IntoIterator<Item = i32>,
-{
-}
-fn f(_: std::vec::IntoIter<i32>) {}
-
-fn main() {
-    a(vec![1, 2].into_iter());
-    b(vec![1, 2]);
-    c(vec![1, 2]);
-    d(vec![1, 2]);
-    b([&1, &2, &3].into_iter().cloned());
-
-    // Don't lint chained `.into_iter().into_iter()` calls. Covered by useless_conversion.
-    b(vec![1, 2].into_iter().into_iter());
-    b(vec![1, 2].into_iter().into_iter().into_iter());
-
-    macro_rules! macro_generated {
-        () => {
-            vec![1, 2].into_iter()
-        };
-    }
-    b(macro_generated!());
-}
diff --git a/tests/ui/explicit_into_iter_fn_arg.rs b/tests/ui/explicit_into_iter_fn_arg.rs
deleted file mode 100644
index 1e051fd06ec..00000000000
--- a/tests/ui/explicit_into_iter_fn_arg.rs
+++ /dev/null
@@ -1,33 +0,0 @@
-//@run-rustfix
-
-#![allow(unused, clippy::useless_conversion)]
-#![warn(clippy::explicit_into_iter_fn_arg)]
-
-fn a<T>(_: T) {}
-fn b<T: IntoIterator<Item = i32>>(_: T) {}
-fn c(_: impl IntoIterator<Item = i32>) {}
-fn d<T>(_: T)
-where
-    T: IntoIterator<Item = i32>,
-{
-}
-fn f(_: std::vec::IntoIter<i32>) {}
-
-fn main() {
-    a(vec![1, 2].into_iter());
-    b(vec![1, 2].into_iter());
-    c(vec![1, 2].into_iter());
-    d(vec![1, 2].into_iter());
-    b([&1, &2, &3].into_iter().cloned());
-
-    // Don't lint chained `.into_iter().into_iter()` calls. Covered by useless_conversion.
-    b(vec![1, 2].into_iter().into_iter());
-    b(vec![1, 2].into_iter().into_iter().into_iter());
-
-    macro_rules! macro_generated {
-        () => {
-            vec![1, 2].into_iter()
-        };
-    }
-    b(macro_generated!());
-}
diff --git a/tests/ui/explicit_into_iter_fn_arg.stderr b/tests/ui/explicit_into_iter_fn_arg.stderr
deleted file mode 100644
index 14b95fb097a..00000000000
--- a/tests/ui/explicit_into_iter_fn_arg.stderr
+++ /dev/null
@@ -1,39 +0,0 @@
-error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
-  --> $DIR/explicit_into_iter_fn_arg.rs:18:7
-   |
-LL |     b(vec![1, 2].into_iter());
-   |       ^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `vec![1, 2]`
-   |
-note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
-  --> $DIR/explicit_into_iter_fn_arg.rs:7:9
-   |
-LL | fn b<T: IntoIterator<Item = i32>>(_: T) {}
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^
-   = note: `-D clippy::explicit-into-iter-fn-arg` implied by `-D warnings`
-
-error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
-  --> $DIR/explicit_into_iter_fn_arg.rs:19:7
-   |
-LL |     c(vec![1, 2].into_iter());
-   |       ^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `vec![1, 2]`
-   |
-note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
-  --> $DIR/explicit_into_iter_fn_arg.rs:8:14
-   |
-LL | fn c(_: impl IntoIterator<Item = i32>) {}
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
-  --> $DIR/explicit_into_iter_fn_arg.rs:20:7
-   |
-LL |     d(vec![1, 2].into_iter());
-   |       ^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `vec![1, 2]`
-   |
-note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
-  --> $DIR/explicit_into_iter_fn_arg.rs:11:8
-   |
-LL |     T: IntoIterator<Item = i32>,
-   |        ^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: aborting due to 3 previous errors
-
diff --git a/tests/ui/useless_conversion.fixed b/tests/ui/useless_conversion.fixed
index c16caa38fe9..e9563b8a60a 100644
--- a/tests/ui/useless_conversion.fixed
+++ b/tests/ui/useless_conversion.fixed
@@ -155,6 +155,35 @@ fn main() {
     let _ = vec![s4, s4, s4].into_iter();
 }
 
+#[allow(dead_code)]
+fn explicit_into_iter_fn_arg() {
+    fn a<T>(_: T) {}
+    fn b<T: IntoIterator<Item = i32>>(_: T) {}
+    fn c(_: impl IntoIterator<Item = i32>) {}
+    fn d<T>(_: T)
+    where
+        T: IntoIterator<Item = i32>,
+    {
+    }
+    fn f(_: std::vec::IntoIter<i32>) {}
+
+    a(vec![1, 2].into_iter());
+    b(vec![1, 2]);
+    c(vec![1, 2]);
+    d(vec![1, 2]);
+    b([&1, &2, &3].into_iter().cloned());
+
+    b(vec![1, 2]);
+    b(vec![1, 2]);
+
+    macro_rules! macro_generated {
+        () => {
+            vec![1, 2].into_iter()
+        };
+    }
+    b(macro_generated!());
+}
+
 #[derive(Copy, Clone)]
 struct Foo<const C: char>;
 
diff --git a/tests/ui/useless_conversion.rs b/tests/ui/useless_conversion.rs
index c75a2bce4ca..c2f4e3117d2 100644
--- a/tests/ui/useless_conversion.rs
+++ b/tests/ui/useless_conversion.rs
@@ -155,6 +155,35 @@ fn main() {
     let _ = vec![s4, s4, s4].into_iter().into_iter();
 }
 
+#[allow(dead_code)]
+fn explicit_into_iter_fn_arg() {
+    fn a<T>(_: T) {}
+    fn b<T: IntoIterator<Item = i32>>(_: T) {}
+    fn c(_: impl IntoIterator<Item = i32>) {}
+    fn d<T>(_: T)
+    where
+        T: IntoIterator<Item = i32>,
+    {
+    }
+    fn f(_: std::vec::IntoIter<i32>) {}
+
+    a(vec![1, 2].into_iter());
+    b(vec![1, 2].into_iter());
+    c(vec![1, 2].into_iter());
+    d(vec![1, 2].into_iter());
+    b([&1, &2, &3].into_iter().cloned());
+
+    b(vec![1, 2].into_iter().into_iter());
+    b(vec![1, 2].into_iter().into_iter().into_iter());
+
+    macro_rules! macro_generated {
+        () => {
+            vec![1, 2].into_iter()
+        };
+    }
+    b(macro_generated!());
+}
+
 #[derive(Copy, Clone)]
 struct Foo<const C: char>;
 
diff --git a/tests/ui/useless_conversion.stderr b/tests/ui/useless_conversion.stderr
index 4dca3aac533..68f38faab59 100644
--- a/tests/ui/useless_conversion.stderr
+++ b/tests/ui/useless_conversion.stderr
@@ -118,5 +118,65 @@ error: useless conversion to the same type: `std::vec::IntoIter<Foo<'a'>>`
 LL |     let _ = vec![s4, s4, s4].into_iter().into_iter();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `vec![s4, s4, s4].into_iter()`
 
-error: aborting due to 19 previous errors
+error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
+  --> $DIR/useless_conversion.rs:171:7
+   |
+LL |     b(vec![1, 2].into_iter());
+   |       ^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `vec![1, 2]`
+   |
+note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
+  --> $DIR/useless_conversion.rs:161:13
+   |
+LL |     fn b<T: IntoIterator<Item = i32>>(_: T) {}
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
+  --> $DIR/useless_conversion.rs:172:7
+   |
+LL |     c(vec![1, 2].into_iter());
+   |       ^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `vec![1, 2]`
+   |
+note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
+  --> $DIR/useless_conversion.rs:162:18
+   |
+LL |     fn c(_: impl IntoIterator<Item = i32>) {}
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
+  --> $DIR/useless_conversion.rs:173:7
+   |
+LL |     d(vec![1, 2].into_iter());
+   |       ^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `vec![1, 2]`
+   |
+note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
+  --> $DIR/useless_conversion.rs:165:12
+   |
+LL |         T: IntoIterator<Item = i32>,
+   |            ^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
+  --> $DIR/useless_conversion.rs:176:7
+   |
+LL |     b(vec![1, 2].into_iter().into_iter());
+   |       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `vec![1, 2]`
+   |
+note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
+  --> $DIR/useless_conversion.rs:161:13
+   |
+LL |     fn b<T: IntoIterator<Item = i32>>(_: T) {}
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
+  --> $DIR/useless_conversion.rs:177:7
+   |
+LL |     b(vec![1, 2].into_iter().into_iter().into_iter());
+   |       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `vec![1, 2]`
+   |
+note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
+  --> $DIR/useless_conversion.rs:161:13
+   |
+LL |     fn b<T: IntoIterator<Item = i32>>(_: T) {}
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 24 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From e4927f98fa53a9d4dd466a9035f71fb1c2a5940b Mon Sep 17 00:00:00 2001
From: disco07 <koneenok@outlook.fr>
Date: Wed, 31 May 2023 00:17:26 +0200
Subject: change booleans file and update tests

---
 clippy_lints/src/booleans.rs    | 32 +++-----------------------------
 tests/ui/nonminimal_bool.rs     |  2 +-
 tests/ui/nonminimal_bool.stderr | 26 ++++++++++++++++----------
 3 files changed, 20 insertions(+), 40 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/booleans.rs b/clippy_lints/src/booleans.rs
index 4bd48185f37..ff0102255a0 100644
--- a/clippy_lints/src/booleans.rs
+++ b/clippy_lints/src/booleans.rs
@@ -8,12 +8,10 @@ use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_expr, FnKind, Visitor};
 use rustc_hir::{BinOpKind, Body, Expr, ExprKind, FnDecl, UnOp};
 use rustc_lint::{LateContext, LateLintPass, Level};
-use rustc_middle::ty::{self, Ty};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::def_id::LocalDefId;
 use rustc_span::source_map::Span;
 use rustc_span::sym;
-use rustc_span::symbol::Ident;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -90,28 +88,6 @@ impl<'tcx> LateLintPass<'tcx> for NonminimalBool {
         NonminimalBoolVisitor { cx }.visit_body(body);
     }
 }
-
-fn is_impl_not_trait_with_bool_out<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
-    cx.tcx
-        .lang_items()
-        .not_trait()
-        .filter(|trait_id| implements_trait(cx, ty, *trait_id, &[]))
-        .and_then(|trait_id| {
-            cx.tcx.associated_items(trait_id).find_by_name_and_kind(
-                cx.tcx,
-                Ident::from_str("Output"),
-                ty::AssocKind::Type,
-                trait_id,
-            )
-        })
-        .map_or(false, |assoc_item| {
-            let proj = cx.tcx.mk_projection(assoc_item.def_id, cx.tcx.mk_substs_trait(ty, []));
-            let nty = cx.tcx.normalize_erasing_regions(cx.param_env, proj);
-
-            nty.is_bool()
-        })
-}
-
 struct NonminimalBoolVisitor<'a, 'tcx> {
     cx: &'a LateContext<'tcx>,
 }
@@ -496,11 +472,9 @@ impl<'a, 'tcx> Visitor<'tcx> for NonminimalBoolVisitor<'a, 'tcx> {
                     self.bool_expr(e);
                 },
                 ExprKind::Unary(UnOp::Not, inner) => {
-                    if let ExprKind::Unary(UnOp::Not, ex) = inner.kind {
-                        let ty = self.cx.typeck_results().expr_ty(ex);
-                        if is_impl_not_trait_with_bool_out(self.cx, ty) {
-                            return;
-                        }
+                    if let ExprKind::Unary(UnOp::Not, ex) = inner.kind &&
+                    !self.cx.typeck_results().node_types()[ex.hir_id].is_bool() {
+                        return;
                     }
                     if self.cx.typeck_results().node_types()[inner.hir_id].is_bool() {
                         self.bool_expr(e);
diff --git a/tests/ui/nonminimal_bool.rs b/tests/ui/nonminimal_bool.rs
index 54cbbdef22e..fec6b7713ee 100644
--- a/tests/ui/nonminimal_bool.rs
+++ b/tests/ui/nonminimal_bool.rs
@@ -10,7 +10,6 @@ fn main() {
     let e: bool = unimplemented!();
     let _ = !true;
     let _ = !false;
-    // vvv Should not lint
     let _ = !!a;
     let _ = false || a;
     // don't lint on cfgs
@@ -55,6 +54,7 @@ fn issue4548() {
 
 fn check_expect() {
     let a: bool = unimplemented!();
+    #[expect(clippy::nonminimal_bool)]
     let _ = !!a;
 }
 
diff --git a/tests/ui/nonminimal_bool.stderr b/tests/ui/nonminimal_bool.stderr
index fa14471301e..91b5805aa97 100644
--- a/tests/ui/nonminimal_bool.stderr
+++ b/tests/ui/nonminimal_bool.stderr
@@ -13,31 +13,37 @@ LL |     let _ = !false;
    |             ^^^^^^ help: try: `true`
 
 error: this boolean expression can be simplified
-  --> $DIR/nonminimal_bool.rs:15:13
+  --> $DIR/nonminimal_bool.rs:13:13
+   |
+LL |     let _ = !!a;
+   |             ^^^ help: try: `a`
+
+error: this boolean expression can be simplified
+  --> $DIR/nonminimal_bool.rs:14:13
    |
 LL |     let _ = false || a;
    |             ^^^^^^^^^^ help: try: `a`
 
 error: this boolean expression can be simplified
-  --> $DIR/nonminimal_bool.rs:19:13
+  --> $DIR/nonminimal_bool.rs:18:13
    |
 LL |     let _ = !(!a && b);
    |             ^^^^^^^^^^ help: try: `a || !b`
 
 error: this boolean expression can be simplified
-  --> $DIR/nonminimal_bool.rs:20:13
+  --> $DIR/nonminimal_bool.rs:19:13
    |
 LL |     let _ = !(!a || b);
    |             ^^^^^^^^^^ help: try: `a && !b`
 
 error: this boolean expression can be simplified
-  --> $DIR/nonminimal_bool.rs:21:13
+  --> $DIR/nonminimal_bool.rs:20:13
    |
 LL |     let _ = !a && !(b && c);
    |             ^^^^^^^^^^^^^^^ help: try: `!(a || b && c)`
 
 error: this boolean expression can be simplified
-  --> $DIR/nonminimal_bool.rs:29:13
+  --> $DIR/nonminimal_bool.rs:28:13
    |
 LL |     let _ = a == b && c == 5 && a == b;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -50,7 +56,7 @@ LL |     let _ = a == b && c == 5;
    |             ~~~~~~~~~~~~~~~~
 
 error: this boolean expression can be simplified
-  --> $DIR/nonminimal_bool.rs:30:13
+  --> $DIR/nonminimal_bool.rs:29:13
    |
 LL |     let _ = a == b || c == 5 || a == b;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -63,7 +69,7 @@ LL |     let _ = a == b || c == 5;
    |             ~~~~~~~~~~~~~~~~
 
 error: this boolean expression can be simplified
-  --> $DIR/nonminimal_bool.rs:31:13
+  --> $DIR/nonminimal_bool.rs:30:13
    |
 LL |     let _ = a == b && c == 5 && b == a;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -76,7 +82,7 @@ LL |     let _ = a == b && c == 5;
    |             ~~~~~~~~~~~~~~~~
 
 error: this boolean expression can be simplified
-  --> $DIR/nonminimal_bool.rs:32:13
+  --> $DIR/nonminimal_bool.rs:31:13
    |
 LL |     let _ = a != b || !(a != b || c == d);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -89,7 +95,7 @@ LL |     let _ = a != b || c != d;
    |             ~~~~~~~~~~~~~~~~
 
 error: this boolean expression can be simplified
-  --> $DIR/nonminimal_bool.rs:33:13
+  --> $DIR/nonminimal_bool.rs:32:13
    |
 LL |     let _ = a != b && !(a != b && c == d);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -107,5 +113,5 @@ error: this boolean expression can be simplified
 LL |     if matches!(true, true) && true {
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `matches!(true, true)`
 
-error: aborting due to 12 previous errors
+error: aborting due to 13 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From d4b388eb43719543aaa9680f5aa03b69d024ea38 Mon Sep 17 00:00:00 2001
From: MarcusGrass <marcus.grass@protonmail.com>
Date: Wed, 31 May 2023 17:46:05 +0200
Subject: Add from_over_into replace for type in `Self` reference

---
 clippy_lints/src/from_over_into.rs | 75 +++++++++++++++++++++++++++++++++++++-
 tests/ui/from_over_into.fixed      | 10 +++++
 tests/ui/from_over_into.rs         | 10 +++++
 tests/ui/from_over_into.stderr     | 15 +++++++-
 4 files changed, 108 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/from_over_into.rs b/clippy_lints/src/from_over_into.rs
index 10ce2a0f0c7..e725fb26c22 100644
--- a/clippy_lints/src/from_over_into.rs
+++ b/clippy_lints/src/from_over_into.rs
@@ -163,7 +163,8 @@ fn convert_to_from(
     let PatKind::Binding(.., self_ident, None) = input.pat.kind else { return None };
 
     let from = snippet_opt(cx, self_ty.span)?;
-    let into = snippet_opt(cx, target_ty.span)?;
+    // If Self is used, it refers to `self_ty`, which is now out `from` snippet
+    let into = replace_self(&snippet_opt(cx, target_ty.span)?, &from);
 
     let mut suggestions = vec![
         // impl Into<T> for U  ->  impl From<T> for U
@@ -212,3 +213,75 @@ fn convert_to_from(
 
     Some(suggestions)
 }
+
+fn replace_self(input: &str, replace_with: &str) -> String {
+    const SELF: &str = "Self";
+    let mut chunks = input.split(SELF).peekable();
+    if let Some(first) = chunks.next() {
+        let mut last_ended_with_break = false;
+        // Heuristic, we're making a guess that the expansion probably doesn't exceed `input.len() * 2`
+        let mut output = String::with_capacity(input.len() * 2);
+        if first.is_empty() || first.ends_with(word_break) {
+            last_ended_with_break = true;
+        }
+        output.push_str(first);
+        while let Some(val) = chunks.next() {
+            let is_last = chunks.peek().is_none();
+            if last_ended_with_break && is_last && val.is_empty() {
+                output.push_str(replace_with);
+                break;
+            }
+            let this_starts_with_break = val.starts_with(word_break);
+            let this_ends_with_break = val.ends_with(word_break);
+            if this_starts_with_break && last_ended_with_break {
+                output.push_str(replace_with);
+            } else {
+                output.push_str(SELF);
+            }
+            output.push_str(val);
+            last_ended_with_break = this_ends_with_break;
+        }
+        output
+    } else {
+        input.to_string()
+    }
+}
+
+#[inline]
+fn word_break(ch: char) -> bool {
+    !ch.is_alphanumeric()
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::from_over_into::replace_self;
+
+    #[test]
+    fn replace_doesnt_touch_coincidental_self() {
+        let input = "impl Into<SelfType> for String {";
+        assert_eq!(input, &replace_self(input, "T"));
+    }
+
+    #[test]
+    fn replace_replaces_self() {
+        let input = "impl Into<Self> for String {";
+        assert_eq!("impl Into<String> for String {", &replace_self(input, "String"));
+    }
+    #[test]
+    fn replace_replaces_self_many() {
+        let input = "impl Into<Self<Self<SelfSelfSelfSelf>>> for Self {";
+        assert_eq!(
+            "impl Into<String<String<SelfSelfSelfSelf>>> for String {",
+            &replace_self(input, "String")
+        );
+    }
+
+    #[test]
+    fn replace_replaces_self_many_starts_ends_self() {
+        let input = "Self impl Into<Self<Self<SelfSelf>>> for Self";
+        assert_eq!(
+            "String impl Into<String<String<SelfSelf>>> for String",
+            &replace_self(input, "String")
+        );
+    }
+}
diff --git a/tests/ui/from_over_into.fixed b/tests/ui/from_over_into.fixed
index d18f9387565..f1333bb39a8 100644
--- a/tests/ui/from_over_into.fixed
+++ b/tests/ui/from_over_into.fixed
@@ -88,4 +88,14 @@ impl Into<Opaque> for IntoOpaque {
     fn into(self) -> Opaque {}
 }
 
+pub struct Lval<T>(T);
+
+pub struct Rval<T>(T);
+
+impl<T> From<Lval<T>> for Rval<Lval<T>> {
+    fn from(val: Lval<T>) -> Self {
+        Rval(val)
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/from_over_into.rs b/tests/ui/from_over_into.rs
index de8ff0b06bd..4fb91971db9 100644
--- a/tests/ui/from_over_into.rs
+++ b/tests/ui/from_over_into.rs
@@ -88,4 +88,14 @@ impl Into<Opaque> for IntoOpaque {
     fn into(self) -> Opaque {}
 }
 
+pub struct Lval<T>(T);
+
+pub struct Rval<T>(T);
+
+impl<T> Into<Rval<Self>> for Lval<T> {
+    fn into(self) -> Rval<Self> {
+        Rval(self)
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/from_over_into.stderr b/tests/ui/from_over_into.stderr
index 6039f86fe67..c514bb6146c 100644
--- a/tests/ui/from_over_into.stderr
+++ b/tests/ui/from_over_into.stderr
@@ -71,5 +71,18 @@ LL ~         fn from(val: Vec<T>) -> Self {
 LL ~             FromOverInto(val)
    |
 
-error: aborting due to 5 previous errors
+error: an implementation of `From` is preferred since it gives you `Into<_>` for free where the reverse isn't true
+  --> $DIR/from_over_into.rs:95:1
+   |
+LL | impl<T> Into<Rval<Self>> for Lval<T> {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: replace the `Into` implementation with `From<Lval<T>>`
+   |
+LL ~ impl<T> From<Lval<T>> for Rval<Lval<T>> {
+LL ~     fn from(val: Lval<T>) -> Self {
+LL ~         Rval(val)
+   |
+
+error: aborting due to 6 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From f74ec6b1b858c13449dc4cfd9231a3a0d82e50df Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Sun, 9 Apr 2023 04:56:03 +0200
Subject: new lint: `missing_field_in_debug`

move some strings into consts, more tests

s/missing_field_in_debug/missing_fields_in_debug

dont trigger in macro expansions

make dogfood tests happy

minor cleanups

replace HashSet with FxHashSet

replace match_def_path with match_type

if_chain -> let chains, fix markdown, allow newtype pattern

fmt

consider string literal in `.field()` calls as used

don't intern defined symbol, remove mentions of 'debug_tuple'

special-case PD, account for field access through `Deref`
---
 CHANGELOG.md                                |   1 +
 clippy_lints/src/declared_lints.rs          |   1 +
 clippy_lints/src/lib.rs                     |   2 +
 clippy_lints/src/missing_fields_in_debug.rs | 311 +++++++++++++++++++++++++++
 clippy_utils/src/paths.rs                   |   2 +
 tests/ui/missing_fields_in_debug.rs         | 319 ++++++++++++++++++++++++++++
 tests/ui/missing_fields_in_debug.stderr     | 113 ++++++++++
 7 files changed, 749 insertions(+)
 create mode 100644 clippy_lints/src/missing_fields_in_debug.rs
 create mode 100644 tests/ui/missing_fields_in_debug.rs
 create mode 100644 tests/ui/missing_fields_in_debug.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index fdf0cacad36..8b609b47d81 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4963,6 +4963,7 @@ Released 2018-09-13
 [`missing_docs_in_private_items`]: https://rust-lang.github.io/rust-clippy/master/index.html#missing_docs_in_private_items
 [`missing_enforced_import_renames`]: https://rust-lang.github.io/rust-clippy/master/index.html#missing_enforced_import_renames
 [`missing_errors_doc`]: https://rust-lang.github.io/rust-clippy/master/index.html#missing_errors_doc
+[`missing_fields_in_debug`]: https://rust-lang.github.io/rust-clippy/master/index.html#missing_fields_in_debug
 [`missing_inline_in_public_items`]: https://rust-lang.github.io/rust-clippy/master/index.html#missing_inline_in_public_items
 [`missing_panics_doc`]: https://rust-lang.github.io/rust-clippy/master/index.html#missing_panics_doc
 [`missing_safety_doc`]: https://rust-lang.github.io/rust-clippy/master/index.html#missing_safety_doc
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 4ade25e1257..a7067d8b86a 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -430,6 +430,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::missing_const_for_fn::MISSING_CONST_FOR_FN_INFO,
     crate::missing_doc::MISSING_DOCS_IN_PRIVATE_ITEMS_INFO,
     crate::missing_enforced_import_rename::MISSING_ENFORCED_IMPORT_RENAMES_INFO,
+    crate::missing_fields_in_debug::MISSING_FIELDS_IN_DEBUG_INFO,
     crate::missing_inline::MISSING_INLINE_IN_PUBLIC_ITEMS_INFO,
     crate::missing_trait_methods::MISSING_TRAIT_METHODS_INFO,
     crate::mixed_read_write_in_expression::DIVERGING_SUB_EXPRESSION_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 10404d51ba5..a0a89e4967b 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -203,6 +203,7 @@ mod missing_assert_message;
 mod missing_const_for_fn;
 mod missing_doc;
 mod missing_enforced_import_rename;
+mod missing_fields_in_debug;
 mod missing_inline;
 mod missing_trait_methods;
 mod mixed_read_write_in_expression;
@@ -994,6 +995,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_early_pass(|| Box::new(ref_patterns::RefPatterns));
     store.register_late_pass(|_| Box::new(default_constructed_unit_structs::DefaultConstructedUnitStructs));
     store.register_early_pass(|| Box::new(needless_else::NeedlessElse));
+    store.register_late_pass(|_| Box::new(missing_fields_in_debug::MissingFieldsInDebug));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/missing_fields_in_debug.rs b/clippy_lints/src/missing_fields_in_debug.rs
new file mode 100644
index 00000000000..389a8d04dc2
--- /dev/null
+++ b/clippy_lints/src/missing_fields_in_debug.rs
@@ -0,0 +1,311 @@
+use std::ops::ControlFlow;
+
+use clippy_utils::{
+    diagnostics::span_lint_and_then,
+    paths,
+    ty::match_type,
+    visitors::{for_each_expr, Visitable},
+};
+use rustc_ast::LitKind;
+use rustc_data_structures::fx::FxHashSet;
+use rustc_hir::{
+    def::{DefKind, Res},
+    Expr, ImplItemKind, MatchSource, Node,
+};
+use rustc_hir::{Block, PatKind};
+use rustc_hir::{ExprKind, Impl, ItemKind, QPath, TyKind};
+use rustc_hir::{ImplItem, Item, VariantData};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::TypeckResults;
+use rustc_middle::ty::{EarlyBinder, Ty};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::{sym, Span, Symbol};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for manual [`core::fmt::Debug`](https://doc.rust-lang.org/core/fmt/trait.Debug.html) implementations that do not use all fields.
+    ///
+    /// ### Why is this bad?
+    /// A common mistake is to forget to update manual `Debug` implementations when adding a new field
+    /// to a struct or a new variant to an enum.
+    ///
+    /// At the same time, it also acts as a style lint to suggest using [`core::fmt::DebugStruct::finish_non_exhaustive`](https://doc.rust-lang.org/core/fmt/struct.DebugStruct.html#method.finish_non_exhaustive)
+    /// for the times when the user intentionally wants to leave out certain fields (e.g. to hide implementation details).
+    ///
+    /// ### Known problems
+    /// This lint works based on the `DebugStruct` helper types provided by the `Formatter`,
+    /// so this won't detect `Debug` impls that use the `write!` macro.
+    /// Oftentimes there is more logic to a `Debug` impl if it uses `write!` macro, so it tries
+    /// to be on the conservative side and not lint in those cases in an attempt to prevent false positives.
+    ///
+    /// This lint also does not look through function calls, so calling `.field(self.as_slice())` for example
+    /// does not consider fields used inside of `as_slice()` as used by the `Debug` impl.
+    ///
+    /// Lastly, it also ignores tuple structs as their `DebugTuple` formatter does not have a `finish_non_exhaustive`
+    /// method.
+    ///
+    /// ### Example
+    /// ```rust
+    /// use std::fmt;
+    /// struct Foo {
+    ///     data: String,
+    ///     // implementation detail
+    ///     hidden_data: i32
+    /// }
+    /// impl fmt::Debug for Foo {
+    ///     fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+    ///         formatter
+    ///             .debug_struct("Foo")
+    ///             .field("data", &self.data)
+    ///             .finish()
+    ///     }
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// use std::fmt;
+    /// struct Foo {
+    ///     data: String,
+    ///     // implementation detail
+    ///     hidden_data: i32
+    /// }
+    /// impl fmt::Debug for Foo {
+    ///     fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+    ///         formatter
+    ///             .debug_struct("Foo")
+    ///             .field("data", &self.data)
+    ///             .finish_non_exhaustive()
+    ///     }
+    /// }
+    /// ```
+    #[clippy::version = "1.70.0"]
+    pub MISSING_FIELDS_IN_DEBUG,
+    pedantic,
+    "missing fields in manual `Debug` implementation"
+}
+declare_lint_pass!(MissingFieldsInDebug => [MISSING_FIELDS_IN_DEBUG]);
+
+fn report_lints(cx: &LateContext<'_>, span: Span, span_notes: Vec<(Span, &'static str)>) {
+    span_lint_and_then(
+        cx,
+        MISSING_FIELDS_IN_DEBUG,
+        span,
+        "manual `Debug` impl does not include all fields",
+        |diag| {
+            for (span, note) in span_notes {
+                diag.span_note(span, note);
+            }
+            diag.help("consider including all fields in this `Debug` impl")
+                .help("consider calling `.finish_non_exhaustive()` if you intend to ignore fields");
+        },
+    );
+}
+
+/// Checks if we should lint in a block of code
+///
+/// The way we check for this condition is by checking if there is
+/// a call to `Formatter::debug_struct` but no call to `.finish_non_exhaustive()`.
+fn should_lint<'tcx>(
+    cx: &LateContext<'tcx>,
+    typeck_results: &TypeckResults<'tcx>,
+    block: impl Visitable<'tcx>,
+) -> bool {
+    // Is there a call to `DebugStruct::finish_non_exhaustive`? Don't lint if there is.
+    let mut has_finish_non_exhaustive = false;
+    // Is there a call to `DebugStruct::debug_struct`? Do lint if there is.
+    let mut has_debug_struct = false;
+
+    for_each_expr(block, |expr| {
+        if let ExprKind::MethodCall(path, recv, ..) = &expr.kind {
+            let recv_ty = typeck_results.expr_ty(recv).peel_refs();
+
+            if path.ident.name == sym::debug_struct && match_type(cx, recv_ty, &paths::FORMATTER) {
+                has_debug_struct = true;
+            } else if path.ident.name == sym!(finish_non_exhaustive) && match_type(cx, recv_ty, &paths::DEBUG_STRUCT) {
+                has_finish_non_exhaustive = true;
+            }
+        }
+        ControlFlow::<!, _>::Continue(())
+    });
+
+    !has_finish_non_exhaustive && has_debug_struct
+}
+
+/// Checks if the given expression is a call to `DebugStruct::field`
+/// and the first argument to it is a string literal and if so, returns it
+///
+/// Example: `.field("foo", ....)` returns `Some("foo")`
+fn as_field_call<'tcx>(
+    cx: &LateContext<'tcx>,
+    typeck_results: &TypeckResults<'tcx>,
+    expr: &Expr<'_>,
+) -> Option<Symbol> {
+    if let ExprKind::MethodCall(path, recv, [debug_field, _], _) = &expr.kind
+        && let recv_ty = typeck_results.expr_ty(recv).peel_refs()
+        && match_type(cx, recv_ty, &paths::DEBUG_STRUCT)
+        && path.ident.name == sym::field
+        && let ExprKind::Lit(lit) = &debug_field.kind
+        && let LitKind::Str(sym, ..) = lit.node
+    {
+        Some(sym)
+    } else {
+        None
+    }
+}
+
+/// Attempts to find unused fields assuming that the item is a struct
+fn check_struct<'tcx>(
+    cx: &LateContext<'tcx>,
+    typeck_results: &TypeckResults<'tcx>,
+    block: &'tcx Block<'tcx>,
+    self_ty: Ty<'tcx>,
+    item: &'tcx Item<'tcx>,
+    data: &VariantData<'_>,
+) {
+    // Is there a "direct" field access anywhere (i.e. self.foo)?
+    // We don't want to lint if there is not, because the user might have
+    // a newtype struct and use fields from the wrapped type only.
+    let mut has_direct_field_access = false;
+    let mut field_accesses = FxHashSet::default();
+
+    for_each_expr(block, |expr| {
+        if let ExprKind::Field(target, ident) = expr.kind
+            && let target_ty = typeck_results.expr_ty_adjusted(target).peel_refs()
+            && target_ty == self_ty
+        {
+            field_accesses.insert(ident.name);
+            has_direct_field_access = true;
+        } else if let Some(sym) = as_field_call(cx, typeck_results, expr) {
+            field_accesses.insert(sym);
+        }
+        ControlFlow::<!, _>::Continue(())
+    });
+
+    let span_notes = data
+        .fields()
+        .iter()
+        .filter_map(|field| {
+            let EarlyBinder(field_ty) = cx.tcx.type_of(field.def_id);
+            if field_accesses.contains(&field.ident.name) || field_ty.is_phantom_data() {
+                None
+            } else {
+                Some((field.span, "this field is unused"))
+            }
+        })
+        .collect::<Vec<_>>();
+
+    // only lint if there's also at least one direct field access to allow patterns
+    // where one might have a newtype struct and uses fields from the wrapped type
+    if !span_notes.is_empty() && has_direct_field_access {
+        report_lints(cx, item.span, span_notes);
+    }
+}
+
+/// Attempts to find unused fields in variants assuming that
+/// the item is an enum.
+///
+/// Currently, only simple cases are detected where the user
+/// matches on `self` and calls `debug_struct` inside of the arms
+fn check_enum<'tcx>(
+    cx: &LateContext<'tcx>,
+    typeck_results: &TypeckResults<'tcx>,
+    block: &'tcx Block<'tcx>,
+    self_ty: Ty<'tcx>,
+    item: &'tcx Item<'tcx>,
+) {
+    let Some(arms) = for_each_expr(block, |expr| {
+        if let ExprKind::Match(val, arms, MatchSource::Normal) = expr.kind
+            && let match_ty = typeck_results.expr_ty_adjusted(val).peel_refs()
+            && match_ty == self_ty
+        {
+            ControlFlow::Break(arms)
+        } else {
+            ControlFlow::Continue(())
+        }
+    }) else {
+        return;
+    };
+
+    let mut span_notes = Vec::new();
+
+    for arm in arms {
+        if !should_lint(cx, typeck_results, arm.body) {
+            continue;
+        }
+
+        arm.pat.walk_always(|pat| match pat.kind {
+            PatKind::Wild => span_notes.push((pat.span, "unused field here due to wildcard `_`")),
+            PatKind::Tuple(_, rest) | PatKind::TupleStruct(.., rest) if rest.as_opt_usize().is_some() => {
+                span_notes.push((pat.span, "more unused fields here due to rest pattern `..`"));
+            },
+            PatKind::Struct(.., true) => {
+                span_notes.push((pat.span, "more unused fields here due to rest pattern `..`"));
+            },
+            _ => {},
+        });
+
+        let mut field_accesses = FxHashSet::default();
+        let mut check_field_access = |sym, expr| {
+            if !typeck_results.expr_ty(expr).is_phantom_data() {
+                arm.pat.each_binding(|_, _, _, pat_ident| {
+                    if sym == pat_ident.name {
+                        field_accesses.insert(pat_ident);
+                    }
+                });
+            }
+        };
+
+        for_each_expr(arm.body, |expr| {
+            if let ExprKind::Path(QPath::Resolved(_, path)) = expr.kind && let Some(segment) = path.segments.first()
+            {
+                check_field_access(segment.ident.name, expr);
+            } else if let Some(sym) = as_field_call(cx, typeck_results, expr) {
+                check_field_access(sym, expr);
+            }
+            ControlFlow::<!, _>::Continue(())
+        });
+
+        arm.pat.each_binding(|_, _, span, pat_ident| {
+            if !field_accesses.contains(&pat_ident) {
+                span_notes.push((span, "the field referenced by this binding is unused"));
+            }
+        });
+    }
+
+    if !span_notes.is_empty() {
+        report_lints(cx, item.span, span_notes);
+    }
+}
+
+impl<'tcx> LateLintPass<'tcx> for MissingFieldsInDebug {
+    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx rustc_hir::Item<'tcx>) {
+        // is this an `impl Debug for X` block?
+        if let ItemKind::Impl(Impl { of_trait: Some(trait_ref), self_ty, items, .. }) = item.kind
+            && let Res::Def(DefKind::Trait, trait_def_id) = trait_ref.path.res
+            && let TyKind::Path(QPath::Resolved(_, self_path)) = &self_ty.kind
+            && cx.match_def_path(trait_def_id, &[sym::core, sym::fmt, sym::Debug])
+            // don't trigger if this impl was derived
+            && !cx.tcx.has_attr(item.owner_id, sym::automatically_derived)
+            && !item.span.from_expansion()
+            // find `Debug::fmt` function
+            && let Some(fmt_item) = items.iter().find(|i| i.ident.name == sym::fmt)
+            && let ImplItem { kind: ImplItemKind::Fn(_, body_id), .. } = cx.tcx.hir().impl_item(fmt_item.id)
+            && let body = cx.tcx.hir().body(*body_id)
+            && let ExprKind::Block(block, _) = body.value.kind
+            // inspect `self`
+            && let self_ty = cx.tcx.type_of(self_path.res.def_id()).0.peel_refs()
+            && let Some(self_adt) = self_ty.ty_adt_def()
+            && let Some(self_def_id) = self_adt.did().as_local()
+            && let Some(Node::Item(self_item)) = cx.tcx.hir().find_by_def_id(self_def_id)
+            // NB: can't call cx.typeck_results() as we are not in a body
+            && let typeck_results = cx.tcx.typeck_body(*body_id)
+            && should_lint(cx, typeck_results, block)
+        {
+            match &self_item.kind {
+                ItemKind::Struct(data, _) => check_struct(cx, typeck_results, block, self_ty, item, data),
+                ItemKind::Enum(..) => check_enum(cx, typeck_results, block, self_ty, item),
+                _ => {}
+            }
+        }
+    }
+}
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index 0f0792fdaa9..3a2b0a72a3d 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -163,3 +163,5 @@ pub const VEC_IS_EMPTY: [&str; 4] = ["alloc", "vec", "Vec", "is_empty"];
 pub const VEC_POP: [&str; 4] = ["alloc", "vec", "Vec", "pop"];
 pub const OPTION_UNWRAP: [&str; 4] = ["core", "option", "Option", "unwrap"];
 pub const OPTION_EXPECT: [&str; 4] = ["core", "option", "Option", "expect"];
+pub const FORMATTER: [&str; 3] = ["core", "fmt", "Formatter"];
+pub const DEBUG_STRUCT: [&str; 4] = ["core", "fmt", "builders", "DebugStruct"];
diff --git a/tests/ui/missing_fields_in_debug.rs b/tests/ui/missing_fields_in_debug.rs
new file mode 100644
index 00000000000..72b9e0e2aae
--- /dev/null
+++ b/tests/ui/missing_fields_in_debug.rs
@@ -0,0 +1,319 @@
+#![allow(unused)]
+#![warn(clippy::missing_fields_in_debug)]
+
+use std::fmt;
+use std::marker::PhantomData;
+use std::ops::Deref;
+
+struct NamedStruct1Ignored {
+    data: u8,
+    hidden: u32,
+}
+
+impl fmt::Debug for NamedStruct1Ignored {
+    // unused field: hidden
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        formatter
+            .debug_struct("NamedStruct1Ignored")
+            .field("data", &self.data)
+            .finish()
+    }
+}
+
+struct NamedStructMultipleIgnored {
+    data: u8,
+    hidden: u32,
+    hidden2: String,
+    hidden3: Vec<Vec<i32>>,
+    hidden4: ((((u8), u16), u32), u64),
+}
+
+impl fmt::Debug for NamedStructMultipleIgnored {
+    // unused fields: hidden, hidden2, hidden4
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        formatter
+            .debug_struct("NamedStructMultipleIgnored")
+            .field("data", &self.data)
+            .field("hidden3", &self.hidden3)
+            .finish()
+    }
+}
+
+struct Unit;
+
+// ok
+impl fmt::Debug for Unit {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        formatter.debug_struct("Unit").finish()
+    }
+}
+
+struct UnnamedStruct1Ignored(String);
+
+impl fmt::Debug for UnnamedStruct1Ignored {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        formatter.debug_tuple("UnnamedStruct1Ignored").finish()
+    }
+}
+
+struct UnnamedStructMultipleIgnored(String, Vec<u8>, i32);
+
+// tuple structs are not linted
+impl fmt::Debug for UnnamedStructMultipleIgnored {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        formatter
+            .debug_tuple("UnnamedStructMultipleIgnored")
+            .field(&self.1)
+            .finish()
+    }
+}
+
+struct NamedStructNonExhaustive {
+    a: u8,
+    b: String,
+}
+
+// ok
+impl fmt::Debug for NamedStructNonExhaustive {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        formatter
+            .debug_struct("NamedStructNonExhaustive")
+            .field("a", &self.a)
+            .finish_non_exhaustive() // should not warn here
+    }
+}
+
+struct MultiExprDebugImpl {
+    a: u8,
+    b: String,
+}
+
+// ok
+impl fmt::Debug for MultiExprDebugImpl {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let mut f = formatter.debug_struct("MultiExprDebugImpl");
+        f.field("a", &self.a);
+        f.finish()
+    }
+}
+
+enum SingleVariantEnumUnnamed {
+    A(u8),
+}
+
+// ok
+impl fmt::Debug for SingleVariantEnumUnnamed {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::A(n) => formatter.debug_tuple("A").field(&n).finish(),
+        }
+    }
+}
+
+enum MultiVariantEnum {
+    A(u8),
+    B { a: u8, b: String },
+    C,
+}
+
+impl fmt::Debug for MultiVariantEnum {
+    // match arm Self::B ignores `b`
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::A(n) => formatter.debug_tuple("A").field(&n).finish(),
+            Self::B { a, b } => formatter.debug_struct("B").field("a", &a).finish(),
+            Self::C => formatter.debug_struct("C").finish(),
+        }
+    }
+}
+
+enum MultiVariantEnumOk {
+    A(u8),
+    B { a: u8, b: String },
+    C,
+}
+
+// ok
+impl fmt::Debug for MultiVariantEnumOk {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::A(n) => formatter.debug_tuple("A").field(&n).finish(),
+            Self::B { a, b } => formatter.debug_struct("B").field("a", &a).field("b", &b).finish(),
+            Self::C => formatter.debug_struct("C").finish(),
+        }
+    }
+}
+
+enum MultiVariantEnumNonExhaustive {
+    A(u8),
+    B { a: u8, b: String },
+    C,
+}
+
+// ok
+impl fmt::Debug for MultiVariantEnumNonExhaustive {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::A(n) => formatter.debug_tuple("A").field(&n).finish(),
+            Self::B { a, b } => formatter.debug_struct("B").field("b", &b).finish_non_exhaustive(),
+            Self::C => formatter.debug_struct("C").finish(),
+        }
+    }
+}
+
+enum MultiVariantRest {
+    A(u8),
+    B { a: u8, b: String },
+    C,
+}
+
+impl fmt::Debug for MultiVariantRest {
+    // `a` field ignored due to rest pattern
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::A(n) => formatter.debug_tuple("A").field(&n).finish(),
+            Self::B { b, .. } => formatter.debug_struct("B").field("b", &b).finish(),
+            Self::C => formatter.debug_struct("C").finish(),
+        }
+    }
+}
+
+enum MultiVariantRestNonExhaustive {
+    A(u8),
+    B { a: u8, b: String },
+    C,
+}
+
+// ok
+impl fmt::Debug for MultiVariantRestNonExhaustive {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::A(n) => formatter.debug_tuple("A").field(&n).finish(),
+            Self::B { b, .. } => formatter.debug_struct("B").field("b", &b).finish_non_exhaustive(),
+            Self::C => formatter.debug_struct("C").finish(),
+        }
+    }
+}
+
+enum Wildcard {
+    A(u8),
+    B(String),
+}
+
+// ok
+impl fmt::Debug for Wildcard {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::A(n) => formatter.debug_tuple("A").field(&n).finish(),
+            _ => todo!(),
+        }
+    }
+}
+
+enum Empty {}
+
+// ok
+impl fmt::Debug for Empty {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match *self {}
+    }
+}
+
+#[derive(Debug)]
+struct DerivedStruct {
+    a: u8,
+    b: i32,
+}
+
+#[derive(Debug)]
+enum DerivedEnum {
+    A(i32),
+    B { a: String },
+}
+
+// https://github.com/rust-lang/rust-clippy/pull/10616#discussion_r1166846953
+
+struct Inner {
+    a: usize,
+    b: usize,
+}
+
+struct HasInner {
+    inner: Inner,
+}
+
+impl HasInner {
+    fn get(&self) -> &Inner {
+        &self.inner
+    }
+}
+
+impl fmt::Debug for HasInner {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let inner = self.get();
+
+        f.debug_struct("HasInner")
+            .field("a", &inner.a)
+            .field("b", &inner.b)
+            .finish()
+    }
+}
+
+// https://github.com/rust-lang/rust-clippy/pull/10616#discussion_r1170306053
+struct Foo {
+    a: u8,
+    b: u8,
+}
+
+impl fmt::Debug for Foo {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Foo").field("a", &self.a).field("b", &()).finish()
+    }
+}
+
+// https://github.com/rust-lang/rust-clippy/pull/10616#discussion_r1175473620
+mod comment1175473620 {
+    use super::*;
+
+    struct Inner {
+        a: usize,
+        b: usize,
+    }
+    struct Wrapper(Inner);
+
+    impl Deref for Wrapper {
+        type Target = Inner;
+
+        fn deref(&self) -> &Self::Target {
+            &self.0
+        }
+    }
+
+    impl fmt::Debug for Wrapper {
+        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+            f.debug_struct("Wrapper")
+                .field("a", &self.a)
+                .field("b", &self.b)
+                .finish()
+        }
+    }
+}
+
+// https://github.com/rust-lang/rust-clippy/pull/10616#discussion_r1175488757
+// PhantomData is an exception and does not need to be included
+struct WithPD {
+    a: u8,
+    b: u8,
+    c: PhantomData<String>,
+}
+
+impl fmt::Debug for WithPD {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("WithPD")
+            .field("a", &self.a)
+            .field("b", &self.b)
+            .finish()
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/missing_fields_in_debug.stderr b/tests/ui/missing_fields_in_debug.stderr
new file mode 100644
index 00000000000..1dc7c0d65e5
--- /dev/null
+++ b/tests/ui/missing_fields_in_debug.stderr
@@ -0,0 +1,113 @@
+error: manual `Debug` impl does not include all fields
+  --> $DIR/missing_fields_in_debug.rs:13:1
+   |
+LL | / impl fmt::Debug for NamedStruct1Ignored {
+LL | |     // unused field: hidden
+LL | |     fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+LL | |         formatter
+...  |
+LL | |     }
+LL | | }
+   | |_^
+   |
+note: this field is unused
+  --> $DIR/missing_fields_in_debug.rs:10:5
+   |
+LL |     hidden: u32,
+   |     ^^^^^^^^^^^
+   = help: consider including all fields in this `Debug` impl
+   = help: consider calling `.finish_non_exhaustive()` if you intend to ignore fields
+   = note: `-D clippy::missing-fields-in-debug` implied by `-D warnings`
+
+error: manual `Debug` impl does not include all fields
+  --> $DIR/missing_fields_in_debug.rs:31:1
+   |
+LL | / impl fmt::Debug for NamedStructMultipleIgnored {
+LL | |     // unused fields: hidden, hidden2, hidden4
+LL | |     fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+LL | |         formatter
+...  |
+LL | |     }
+LL | | }
+   | |_^
+   |
+note: this field is unused
+  --> $DIR/missing_fields_in_debug.rs:25:5
+   |
+LL |     hidden: u32,
+   |     ^^^^^^^^^^^
+note: this field is unused
+  --> $DIR/missing_fields_in_debug.rs:26:5
+   |
+LL |     hidden2: String,
+   |     ^^^^^^^^^^^^^^^
+note: this field is unused
+  --> $DIR/missing_fields_in_debug.rs:28:5
+   |
+LL |     hidden4: ((((u8), u16), u32), u64),
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   = help: consider including all fields in this `Debug` impl
+   = help: consider calling `.finish_non_exhaustive()` if you intend to ignore fields
+
+error: manual `Debug` impl does not include all fields
+  --> $DIR/missing_fields_in_debug.rs:92:1
+   |
+LL | / impl fmt::Debug for MultiExprDebugImpl {
+LL | |     fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+LL | |         let mut f = formatter.debug_struct("MultiExprDebugImpl");
+LL | |         f.field("a", &self.a);
+LL | |         f.finish()
+LL | |     }
+LL | | }
+   | |_^
+   |
+note: this field is unused
+  --> $DIR/missing_fields_in_debug.rs:88:5
+   |
+LL |     b: String,
+   |     ^^^^^^^^^
+   = help: consider including all fields in this `Debug` impl
+   = help: consider calling `.finish_non_exhaustive()` if you intend to ignore fields
+
+error: manual `Debug` impl does not include all fields
+  --> $DIR/missing_fields_in_debug.rs:119:1
+   |
+LL | / impl fmt::Debug for MultiVariantEnum {
+LL | |     // match arm Self::B ignores `b`
+LL | |     fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+LL | |         match self {
+...  |
+LL | |     }
+LL | | }
+   | |_^
+   |
+note: the field referenced by this binding is unused
+  --> $DIR/missing_fields_in_debug.rs:124:26
+   |
+LL |             Self::B { a, b } => formatter.debug_struct("B").field("a", &a).finish(),
+   |                          ^
+   = help: consider including all fields in this `Debug` impl
+   = help: consider calling `.finish_non_exhaustive()` if you intend to ignore fields
+
+error: manual `Debug` impl does not include all fields
+  --> $DIR/missing_fields_in_debug.rs:170:1
+   |
+LL | / impl fmt::Debug for MultiVariantRest {
+LL | |     // `a` field ignored due to rest pattern
+LL | |     fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+LL | |         match self {
+...  |
+LL | |     }
+LL | | }
+   | |_^
+   |
+note: more unused fields here due to rest pattern `..`
+  --> $DIR/missing_fields_in_debug.rs:175:13
+   |
+LL |             Self::B { b, .. } => formatter.debug_struct("B").field("b", &b).finish(),
+   |             ^^^^^^^^^^^^^^^^^
+   = help: consider including all fields in this `Debug` impl
+   = help: consider calling `.finish_non_exhaustive()` if you intend to ignore fields
+
+error: aborting due to 5 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From a859b0e6dfae12169d6a239e2a63aef8227e1dce Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Wed, 31 May 2023 23:08:49 +0200
Subject: don't lint enums, update note in lint description

---
 clippy_lints/src/missing_fields_in_debug.rs | 101 +++-------------------
 tests/ui/missing_fields_in_debug.rs         | 128 ----------------------------
 tests/ui/missing_fields_in_debug.stderr     |  42 +--------
 3 files changed, 13 insertions(+), 258 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/missing_fields_in_debug.rs b/clippy_lints/src/missing_fields_in_debug.rs
index 389a8d04dc2..8332d638f92 100644
--- a/clippy_lints/src/missing_fields_in_debug.rs
+++ b/clippy_lints/src/missing_fields_in_debug.rs
@@ -2,22 +2,22 @@ use std::ops::ControlFlow;
 
 use clippy_utils::{
     diagnostics::span_lint_and_then,
-    paths,
+    is_path_lang_item, paths,
     ty::match_type,
     visitors::{for_each_expr, Visitable},
 };
 use rustc_ast::LitKind;
 use rustc_data_structures::fx::FxHashSet;
+use rustc_hir::Block;
 use rustc_hir::{
     def::{DefKind, Res},
-    Expr, ImplItemKind, MatchSource, Node,
+    Expr, ImplItemKind, LangItem, Node,
 };
-use rustc_hir::{Block, PatKind};
 use rustc_hir::{ExprKind, Impl, ItemKind, QPath, TyKind};
 use rustc_hir::{ImplItem, Item, VariantData};
 use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::Ty;
 use rustc_middle::ty::TypeckResults;
-use rustc_middle::ty::{EarlyBinder, Ty};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::{sym, Span, Symbol};
 
@@ -38,11 +38,12 @@ declare_clippy_lint! {
     /// Oftentimes there is more logic to a `Debug` impl if it uses `write!` macro, so it tries
     /// to be on the conservative side and not lint in those cases in an attempt to prevent false positives.
     ///
-    /// This lint also does not look through function calls, so calling `.field(self.as_slice())` for example
-    /// does not consider fields used inside of `as_slice()` as used by the `Debug` impl.
+    /// This lint also does not look through function calls, so calling a function does not consider fields
+    /// used inside of that function as used by the `Debug` impl.
     ///
     /// Lastly, it also ignores tuple structs as their `DebugTuple` formatter does not have a `finish_non_exhaustive`
-    /// method.
+    /// method, as well as enums because their exhaustiveness is already checked by the compiler when matching on the enum,
+    /// making it much less likely to accidentally forget to update the `Debug` impl when adding a new variant.
     ///
     /// ### Example
     /// ```rust
@@ -185,8 +186,7 @@ fn check_struct<'tcx>(
         .fields()
         .iter()
         .filter_map(|field| {
-            let EarlyBinder(field_ty) = cx.tcx.type_of(field.def_id);
-            if field_accesses.contains(&field.ident.name) || field_ty.is_phantom_data() {
+            if field_accesses.contains(&field.ident.name) || is_path_lang_item(cx, field.ty, LangItem::PhantomData) {
                 None
             } else {
                 Some((field.span, "this field is unused"))
@@ -201,82 +201,6 @@ fn check_struct<'tcx>(
     }
 }
 
-/// Attempts to find unused fields in variants assuming that
-/// the item is an enum.
-///
-/// Currently, only simple cases are detected where the user
-/// matches on `self` and calls `debug_struct` inside of the arms
-fn check_enum<'tcx>(
-    cx: &LateContext<'tcx>,
-    typeck_results: &TypeckResults<'tcx>,
-    block: &'tcx Block<'tcx>,
-    self_ty: Ty<'tcx>,
-    item: &'tcx Item<'tcx>,
-) {
-    let Some(arms) = for_each_expr(block, |expr| {
-        if let ExprKind::Match(val, arms, MatchSource::Normal) = expr.kind
-            && let match_ty = typeck_results.expr_ty_adjusted(val).peel_refs()
-            && match_ty == self_ty
-        {
-            ControlFlow::Break(arms)
-        } else {
-            ControlFlow::Continue(())
-        }
-    }) else {
-        return;
-    };
-
-    let mut span_notes = Vec::new();
-
-    for arm in arms {
-        if !should_lint(cx, typeck_results, arm.body) {
-            continue;
-        }
-
-        arm.pat.walk_always(|pat| match pat.kind {
-            PatKind::Wild => span_notes.push((pat.span, "unused field here due to wildcard `_`")),
-            PatKind::Tuple(_, rest) | PatKind::TupleStruct(.., rest) if rest.as_opt_usize().is_some() => {
-                span_notes.push((pat.span, "more unused fields here due to rest pattern `..`"));
-            },
-            PatKind::Struct(.., true) => {
-                span_notes.push((pat.span, "more unused fields here due to rest pattern `..`"));
-            },
-            _ => {},
-        });
-
-        let mut field_accesses = FxHashSet::default();
-        let mut check_field_access = |sym, expr| {
-            if !typeck_results.expr_ty(expr).is_phantom_data() {
-                arm.pat.each_binding(|_, _, _, pat_ident| {
-                    if sym == pat_ident.name {
-                        field_accesses.insert(pat_ident);
-                    }
-                });
-            }
-        };
-
-        for_each_expr(arm.body, |expr| {
-            if let ExprKind::Path(QPath::Resolved(_, path)) = expr.kind && let Some(segment) = path.segments.first()
-            {
-                check_field_access(segment.ident.name, expr);
-            } else if let Some(sym) = as_field_call(cx, typeck_results, expr) {
-                check_field_access(sym, expr);
-            }
-            ControlFlow::<!, _>::Continue(())
-        });
-
-        arm.pat.each_binding(|_, _, span, pat_ident| {
-            if !field_accesses.contains(&pat_ident) {
-                span_notes.push((span, "the field referenced by this binding is unused"));
-            }
-        });
-    }
-
-    if !span_notes.is_empty() {
-        report_lints(cx, item.span, span_notes);
-    }
-}
-
 impl<'tcx> LateLintPass<'tcx> for MissingFieldsInDebug {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx rustc_hir::Item<'tcx>) {
         // is this an `impl Debug for X` block?
@@ -301,10 +225,9 @@ impl<'tcx> LateLintPass<'tcx> for MissingFieldsInDebug {
             && let typeck_results = cx.tcx.typeck_body(*body_id)
             && should_lint(cx, typeck_results, block)
         {
-            match &self_item.kind {
-                ItemKind::Struct(data, _) => check_struct(cx, typeck_results, block, self_ty, item, data),
-                ItemKind::Enum(..) => check_enum(cx, typeck_results, block, self_ty, item),
-                _ => {}
+            // we intentionally only lint structs, see lint description
+            if let ItemKind::Struct(data, _) = &self_item.kind {
+                check_struct(cx, typeck_results, block, self_ty, item, data);
             }
         }
     }
diff --git a/tests/ui/missing_fields_in_debug.rs b/tests/ui/missing_fields_in_debug.rs
index 72b9e0e2aae..c156d394ece 100644
--- a/tests/ui/missing_fields_in_debug.rs
+++ b/tests/ui/missing_fields_in_debug.rs
@@ -97,140 +97,12 @@ impl fmt::Debug for MultiExprDebugImpl {
     }
 }
 
-enum SingleVariantEnumUnnamed {
-    A(u8),
-}
-
-// ok
-impl fmt::Debug for SingleVariantEnumUnnamed {
-    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Self::A(n) => formatter.debug_tuple("A").field(&n).finish(),
-        }
-    }
-}
-
-enum MultiVariantEnum {
-    A(u8),
-    B { a: u8, b: String },
-    C,
-}
-
-impl fmt::Debug for MultiVariantEnum {
-    // match arm Self::B ignores `b`
-    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Self::A(n) => formatter.debug_tuple("A").field(&n).finish(),
-            Self::B { a, b } => formatter.debug_struct("B").field("a", &a).finish(),
-            Self::C => formatter.debug_struct("C").finish(),
-        }
-    }
-}
-
-enum MultiVariantEnumOk {
-    A(u8),
-    B { a: u8, b: String },
-    C,
-}
-
-// ok
-impl fmt::Debug for MultiVariantEnumOk {
-    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Self::A(n) => formatter.debug_tuple("A").field(&n).finish(),
-            Self::B { a, b } => formatter.debug_struct("B").field("a", &a).field("b", &b).finish(),
-            Self::C => formatter.debug_struct("C").finish(),
-        }
-    }
-}
-
-enum MultiVariantEnumNonExhaustive {
-    A(u8),
-    B { a: u8, b: String },
-    C,
-}
-
-// ok
-impl fmt::Debug for MultiVariantEnumNonExhaustive {
-    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Self::A(n) => formatter.debug_tuple("A").field(&n).finish(),
-            Self::B { a, b } => formatter.debug_struct("B").field("b", &b).finish_non_exhaustive(),
-            Self::C => formatter.debug_struct("C").finish(),
-        }
-    }
-}
-
-enum MultiVariantRest {
-    A(u8),
-    B { a: u8, b: String },
-    C,
-}
-
-impl fmt::Debug for MultiVariantRest {
-    // `a` field ignored due to rest pattern
-    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Self::A(n) => formatter.debug_tuple("A").field(&n).finish(),
-            Self::B { b, .. } => formatter.debug_struct("B").field("b", &b).finish(),
-            Self::C => formatter.debug_struct("C").finish(),
-        }
-    }
-}
-
-enum MultiVariantRestNonExhaustive {
-    A(u8),
-    B { a: u8, b: String },
-    C,
-}
-
-// ok
-impl fmt::Debug for MultiVariantRestNonExhaustive {
-    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Self::A(n) => formatter.debug_tuple("A").field(&n).finish(),
-            Self::B { b, .. } => formatter.debug_struct("B").field("b", &b).finish_non_exhaustive(),
-            Self::C => formatter.debug_struct("C").finish(),
-        }
-    }
-}
-
-enum Wildcard {
-    A(u8),
-    B(String),
-}
-
-// ok
-impl fmt::Debug for Wildcard {
-    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Self::A(n) => formatter.debug_tuple("A").field(&n).finish(),
-            _ => todo!(),
-        }
-    }
-}
-
-enum Empty {}
-
-// ok
-impl fmt::Debug for Empty {
-    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match *self {}
-    }
-}
-
 #[derive(Debug)]
 struct DerivedStruct {
     a: u8,
     b: i32,
 }
 
-#[derive(Debug)]
-enum DerivedEnum {
-    A(i32),
-    B { a: String },
-}
-
 // https://github.com/rust-lang/rust-clippy/pull/10616#discussion_r1166846953
 
 struct Inner {
diff --git a/tests/ui/missing_fields_in_debug.stderr b/tests/ui/missing_fields_in_debug.stderr
index 1dc7c0d65e5..ef9d02abab7 100644
--- a/tests/ui/missing_fields_in_debug.stderr
+++ b/tests/ui/missing_fields_in_debug.stderr
@@ -69,45 +69,5 @@ LL |     b: String,
    = help: consider including all fields in this `Debug` impl
    = help: consider calling `.finish_non_exhaustive()` if you intend to ignore fields
 
-error: manual `Debug` impl does not include all fields
-  --> $DIR/missing_fields_in_debug.rs:119:1
-   |
-LL | / impl fmt::Debug for MultiVariantEnum {
-LL | |     // match arm Self::B ignores `b`
-LL | |     fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
-LL | |         match self {
-...  |
-LL | |     }
-LL | | }
-   | |_^
-   |
-note: the field referenced by this binding is unused
-  --> $DIR/missing_fields_in_debug.rs:124:26
-   |
-LL |             Self::B { a, b } => formatter.debug_struct("B").field("a", &a).finish(),
-   |                          ^
-   = help: consider including all fields in this `Debug` impl
-   = help: consider calling `.finish_non_exhaustive()` if you intend to ignore fields
-
-error: manual `Debug` impl does not include all fields
-  --> $DIR/missing_fields_in_debug.rs:170:1
-   |
-LL | / impl fmt::Debug for MultiVariantRest {
-LL | |     // `a` field ignored due to rest pattern
-LL | |     fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
-LL | |         match self {
-...  |
-LL | |     }
-LL | | }
-   | |_^
-   |
-note: more unused fields here due to rest pattern `..`
-  --> $DIR/missing_fields_in_debug.rs:175:13
-   |
-LL |             Self::B { b, .. } => formatter.debug_struct("B").field("b", &b).finish(),
-   |             ^^^^^^^^^^^^^^^^^
-   = help: consider including all fields in this `Debug` impl
-   = help: consider calling `.finish_non_exhaustive()` if you intend to ignore fields
-
-error: aborting due to 5 previous errors
+error: aborting due to 3 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 3ab6aeefb15dd82d21c41265cd441e0cea21c6b0 Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Thu, 25 May 2023 08:02:57 -0500
Subject: `to_xx_bytes` implemented, `from_xx_bytes` todo

Mentioned in #10765
---
 CHANGELOG.md                       |    3 +
 clippy_lints/src/declared_lints.rs |    3 +
 clippy_lints/src/endian_bytes.rs   |  138 +++++
 clippy_lints/src/lib.rs            |    2 +
 tests/ui/endian_bytes.rs           |  163 +++++
 tests/ui/endian_bytes.stderr       | 1152 ++++++++++++++++++++++++++++++++++++
 6 files changed, 1461 insertions(+)
 create mode 100644 clippy_lints/src/endian_bytes.rs
 create mode 100644 tests/ui/endian_bytes.rs
 create mode 100644 tests/ui/endian_bytes.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 8b609b47d81..bfb52854634 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4641,6 +4641,7 @@ Released 2018-09-13
 [`await_holding_lock`]: https://rust-lang.github.io/rust-clippy/master/index.html#await_holding_lock
 [`await_holding_refcell_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#await_holding_refcell_ref
 [`bad_bit_mask`]: https://rust-lang.github.io/rust-clippy/master/index.html#bad_bit_mask
+[`big_endian_bytes`]: https://rust-lang.github.io/rust-clippy/master/index.html#big_endian_bytes
 [`bind_instead_of_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#bind_instead_of_map
 [`blacklisted_name`]: https://rust-lang.github.io/rust-clippy/master/index.html#blacklisted_name
 [`blanket_clippy_restriction_lints`]: https://rust-lang.github.io/rust-clippy/master/index.html#blanket_clippy_restriction_lints
@@ -4811,6 +4812,7 @@ Released 2018-09-13
 [`get_first`]: https://rust-lang.github.io/rust-clippy/master/index.html#get_first
 [`get_last_with_len`]: https://rust-lang.github.io/rust-clippy/master/index.html#get_last_with_len
 [`get_unwrap`]: https://rust-lang.github.io/rust-clippy/master/index.html#get_unwrap
+[`host_endian_bytes`]: https://rust-lang.github.io/rust-clippy/master/index.html#host_endian_bytes
 [`identity_conversion`]: https://rust-lang.github.io/rust-clippy/master/index.html#identity_conversion
 [`identity_op`]: https://rust-lang.github.io/rust-clippy/master/index.html#identity_op
 [`if_let_mutex`]: https://rust-lang.github.io/rust-clippy/master/index.html#if_let_mutex
@@ -4892,6 +4894,7 @@ Released 2018-09-13
 [`let_with_type_underscore`]: https://rust-lang.github.io/rust-clippy/master/index.html#let_with_type_underscore
 [`lines_filter_map_ok`]: https://rust-lang.github.io/rust-clippy/master/index.html#lines_filter_map_ok
 [`linkedlist`]: https://rust-lang.github.io/rust-clippy/master/index.html#linkedlist
+[`little_endian_bytes`]: https://rust-lang.github.io/rust-clippy/master/index.html#little_endian_bytes
 [`logic_bug`]: https://rust-lang.github.io/rust-clippy/master/index.html#logic_bug
 [`lossy_float_literal`]: https://rust-lang.github.io/rust-clippy/master/index.html#lossy_float_literal
 [`macro_use_imports`]: https://rust-lang.github.io/rust-clippy/master/index.html#macro_use_imports
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index a7067d8b86a..aaaa38d4da5 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -143,6 +143,9 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::empty_drop::EMPTY_DROP_INFO,
     crate::empty_enum::EMPTY_ENUM_INFO,
     crate::empty_structs_with_brackets::EMPTY_STRUCTS_WITH_BRACKETS_INFO,
+    crate::endian_bytes::BIG_ENDIAN_BYTES_INFO,
+    crate::endian_bytes::HOST_ENDIAN_BYTES_INFO,
+    crate::endian_bytes::LITTLE_ENDIAN_BYTES_INFO,
     crate::entry::MAP_ENTRY_INFO,
     crate::enum_clike::ENUM_CLIKE_UNPORTABLE_VARIANT_INFO,
     crate::enum_variants::ENUM_VARIANT_NAMES_INFO,
diff --git a/clippy_lints/src/endian_bytes.rs b/clippy_lints/src/endian_bytes.rs
new file mode 100644
index 00000000000..bf6b92644e2
--- /dev/null
+++ b/clippy_lints/src/endian_bytes.rs
@@ -0,0 +1,138 @@
+use clippy_utils::{
+    diagnostics::{span_lint_and_help, span_lint_and_then},
+    is_lint_allowed, match_def_path, path_def_id,
+};
+use rustc_hir::{Expr, ExprKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// ### What it does
+    ///
+    /// ### Why is this bad?
+    ///
+    /// ### Example
+    /// ```rust
+    /// // example code where clippy issues a warning
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// // example code which does not raise clippy warning
+    /// ```
+    #[clippy::version = "1.71.0"]
+    pub HOST_ENDIAN_BYTES,
+    restriction,
+    "disallows usage of the `to_ne_bytes` method"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for the usage of the `to_ne_bytes` method.
+    ///
+    /// ### Why is this bad?
+    /// It's not, but some may prefer to specify the target endianness explicitly.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// let _x = 2i32.to_ne_bytes();
+    /// let _y = 2i64.to_ne_bytes();
+    /// ```
+    #[clippy::version = "1.71.0"]
+    pub LITTLE_ENDIAN_BYTES,
+    restriction,
+    "disallows usage of the `to_le_bytes` method"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for the usage of the `to_le_bytes` method.
+    ///
+    /// ### Why is this bad?
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// // example code where clippy issues a warning
+    /// ```
+    #[clippy::version = "1.71.0"]
+    pub BIG_ENDIAN_BYTES,
+    restriction,
+    "disallows usage of the `to_be_bytes` method"
+}
+
+declare_lint_pass!(EndianBytes => [HOST_ENDIAN_BYTES, LITTLE_ENDIAN_BYTES, BIG_ENDIAN_BYTES]);
+
+impl LateLintPass<'_> for EndianBytes {
+    fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
+        if_chain! {
+            if let ExprKind::MethodCall(method_name, receiver, args, ..) = expr.kind;
+            if let ExprKind::Lit(..) = receiver.kind;
+            if args.is_empty();
+            then {
+                if method_name.ident.name == sym!(to_ne_bytes) {
+                    span_lint_and_help(
+                        cx,
+                        HOST_ENDIAN_BYTES,
+                        expr.span,
+                        "use of the method `to_ne_bytes`",
+                        None,
+                        "consider specifying the desired endianness",
+                    );
+                } else if method_name.ident.name == sym!(to_le_bytes) {
+                    span_lint_and_then(cx, LITTLE_ENDIAN_BYTES, expr.span, "use of the method `to_le_bytes`", |diag| {
+                        if is_lint_allowed(cx, BIG_ENDIAN_BYTES, expr.hir_id) {
+                            diag.help("use `to_be_bytes` instead");
+                        }
+                    });
+                } else if method_name.ident.name == sym!(to_be_bytes) {
+                    span_lint_and_then(cx, BIG_ENDIAN_BYTES, expr.span, "use of the method `to_be_bytes`", |diag| {
+                        if is_lint_allowed(cx, LITTLE_ENDIAN_BYTES, expr.hir_id) {
+                            diag.help("use `to_le_bytes` instead");
+                        }
+                    });
+                }
+
+                // don't waste time also checking from_**_bytes
+                return;
+            }
+        }
+
+        span_lint_and_help(
+            cx,
+            HOST_ENDIAN_BYTES,
+            expr.span,
+            "use of the method `from_ne_bytes`",
+            None,
+            &format!("consider specifying the desired endianness: {expr:?}"),
+        );
+
+        if_chain! {
+            if let ExprKind::Call(function, args) = expr.kind;
+            if let Some(function_def_id) = path_def_id(cx, function);
+            if args.len() == 1;
+            then {
+                if match_def_path(cx, function_def_id, &["from_ne_bytes"]) {
+                    span_lint_and_help(
+                        cx,
+                        HOST_ENDIAN_BYTES,
+                        expr.span,
+                        "use of the method `from_ne_bytes`",
+                        None,
+                        "consider specifying the desired endianness",
+                    );
+                } else if match_def_path(cx, function_def_id, &["from_le_bytes"]) {
+                    span_lint_and_then(cx, LITTLE_ENDIAN_BYTES, expr.span, "use of the method `from_le_bytes`", |diag| {
+                        if is_lint_allowed(cx, BIG_ENDIAN_BYTES, expr.hir_id) {
+                            diag.help("use `from_be_bytes` instead");
+                        }
+                    });
+                } else if match_def_path(cx, function_def_id, &["from_be_bytes"]) {
+                    span_lint_and_then(cx, BIG_ENDIAN_BYTES, expr.span, "use of the method `from_be_bytes`", |diag| {
+                        if is_lint_allowed(cx, LITTLE_ENDIAN_BYTES, expr.hir_id) {
+                            diag.help("use `from_le_bytes` instead");
+                        }
+                    });
+                }
+            }
+        }
+    }
+}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index a0a89e4967b..122fc3feeee 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -114,6 +114,7 @@ mod else_if_without_else;
 mod empty_drop;
 mod empty_enum;
 mod empty_structs_with_brackets;
+mod endian_bytes;
 mod entry;
 mod enum_clike;
 mod enum_variants;
@@ -996,6 +997,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(default_constructed_unit_structs::DefaultConstructedUnitStructs));
     store.register_early_pass(|| Box::new(needless_else::NeedlessElse));
     store.register_late_pass(|_| Box::new(missing_fields_in_debug::MissingFieldsInDebug));
+    store.register_late_pass(|_| Box::new(endian_bytes::EndianBytes));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/tests/ui/endian_bytes.rs b/tests/ui/endian_bytes.rs
new file mode 100644
index 00000000000..1dfda9d53bf
--- /dev/null
+++ b/tests/ui/endian_bytes.rs
@@ -0,0 +1,163 @@
+#![allow(unused)]
+#![allow(clippy::diverging_sub_expression)]
+#![no_main]
+
+#[warn(clippy::host_endian_bytes)]
+fn host() {
+    2u8.to_ne_bytes();
+    2i8.to_ne_bytes();
+    2u16.to_ne_bytes();
+    2i16.to_ne_bytes();
+    2u32.to_ne_bytes();
+    2i32.to_ne_bytes();
+    2u64.to_ne_bytes();
+    2i64.to_ne_bytes();
+    2u128.to_ne_bytes();
+    2i128.to_ne_bytes();
+    2usize.to_ne_bytes();
+    2isize.to_ne_bytes();
+    2.0f32.to_ne_bytes();
+    2.0f64.to_ne_bytes();
+    u8::from_ne_bytes(todo!());
+    i8::from_ne_bytes(todo!());
+    u16::from_ne_bytes(todo!());
+    i16::from_ne_bytes(todo!());
+    u32::from_ne_bytes(todo!());
+    i32::from_ne_bytes(todo!());
+    u64::from_ne_bytes(todo!());
+    i64::from_ne_bytes(todo!());
+    u128::from_ne_bytes(todo!());
+    i128::from_ne_bytes(todo!());
+    f32::from_ne_bytes(todo!());
+    f64::from_ne_bytes(todo!());
+}
+
+#[warn(clippy::little_endian_bytes)]
+fn little() {
+    2u8.to_le_bytes();
+    2i8.to_le_bytes();
+    2u16.to_le_bytes();
+    2i16.to_le_bytes();
+    2u32.to_le_bytes();
+    2i32.to_le_bytes();
+    2u64.to_le_bytes();
+    2i64.to_le_bytes();
+    2u128.to_le_bytes();
+    2i128.to_le_bytes();
+    2usize.to_le_bytes();
+    2isize.to_le_bytes();
+    2.0f32.to_le_bytes();
+    2.0f64.to_le_bytes();
+    u8::from_le_bytes(todo!());
+    i8::from_le_bytes(todo!());
+    u16::from_le_bytes(todo!());
+    i16::from_le_bytes(todo!());
+    u32::from_le_bytes(todo!());
+    i32::from_le_bytes(todo!());
+    u64::from_le_bytes(todo!());
+    i64::from_le_bytes(todo!());
+    u128::from_le_bytes(todo!());
+    i128::from_le_bytes(todo!());
+    usize::from_le_bytes(todo!());
+    isize::from_le_bytes(todo!());
+    f32::from_le_bytes(todo!());
+    f64::from_le_bytes(todo!());
+}
+
+#[warn(clippy::big_endian_bytes)]
+fn big() {
+    2u8.to_be_bytes();
+    2i8.to_be_bytes();
+    2u16.to_be_bytes();
+    2i16.to_be_bytes();
+    2u32.to_be_bytes();
+    2i32.to_be_bytes();
+    2u64.to_be_bytes();
+    2i64.to_be_bytes();
+    2u128.to_be_bytes();
+    2i128.to_be_bytes();
+    2.0f32.to_be_bytes();
+    2.0f64.to_be_bytes();
+    2usize.to_be_bytes();
+    2isize.to_be_bytes();
+    u8::from_be_bytes(todo!());
+    i8::from_be_bytes(todo!());
+    u16::from_be_bytes(todo!());
+    i16::from_be_bytes(todo!());
+    u32::from_be_bytes(todo!());
+    i32::from_be_bytes(todo!());
+    u64::from_be_bytes(todo!());
+    i64::from_be_bytes(todo!());
+    u128::from_be_bytes(todo!());
+    i128::from_be_bytes(todo!());
+    usize::from_be_bytes(todo!());
+    isize::from_be_bytes(todo!());
+    f32::from_be_bytes(todo!());
+    f64::from_be_bytes(todo!());
+}
+
+#[warn(clippy::little_endian_bytes)]
+#[warn(clippy::big_endian_bytes)]
+fn little_no_help() {
+    2u8.to_le_bytes();
+    2i8.to_le_bytes();
+    2u16.to_le_bytes();
+    2i16.to_le_bytes();
+    2u32.to_le_bytes();
+    2i32.to_le_bytes();
+    2u64.to_le_bytes();
+    2i64.to_le_bytes();
+    2u128.to_le_bytes();
+    2i128.to_le_bytes();
+    2usize.to_le_bytes();
+    2isize.to_le_bytes();
+    2.0f32.to_le_bytes();
+    2.0f64.to_le_bytes();
+    u8::from_le_bytes(todo!());
+    i8::from_le_bytes(todo!());
+    u16::from_le_bytes(todo!());
+    i16::from_le_bytes(todo!());
+    u32::from_le_bytes(todo!());
+    i32::from_le_bytes(todo!());
+    u64::from_le_bytes(todo!());
+    i64::from_le_bytes(todo!());
+    u128::from_le_bytes(todo!());
+    i128::from_le_bytes(todo!());
+    usize::from_le_bytes(todo!());
+    isize::from_le_bytes(todo!());
+    f32::from_le_bytes(todo!());
+    f64::from_le_bytes(todo!());
+}
+
+#[warn(clippy::big_endian_bytes)]
+#[warn(clippy::little_endian_bytes)]
+fn big_no_help() {
+    2u8.to_be_bytes();
+    2i8.to_be_bytes();
+    2u16.to_be_bytes();
+    2i16.to_be_bytes();
+    2u32.to_be_bytes();
+    2i32.to_be_bytes();
+    2u64.to_be_bytes();
+    2i64.to_be_bytes();
+    2u128.to_be_bytes();
+    2i128.to_be_bytes();
+    2usize.to_be_bytes();
+    2isize.to_be_bytes();
+    2.0f32.to_be_bytes();
+    2.0f64.to_be_bytes();
+    u8::from_be_bytes(todo!());
+    i8::from_be_bytes(todo!());
+    u16::from_be_bytes(todo!());
+    i16::from_be_bytes(todo!());
+    u32::from_be_bytes(todo!());
+    i32::from_be_bytes(todo!());
+    u64::from_be_bytes(todo!());
+    i64::from_be_bytes(todo!());
+    u128::from_be_bytes(todo!());
+    i128::from_be_bytes(todo!());
+    usize::from_be_bytes(todo!());
+    isize::from_be_bytes(todo!());
+    f32::from_be_bytes(todo!());
+    f64::from_be_bytes(todo!());
+}
diff --git a/tests/ui/endian_bytes.stderr b/tests/ui/endian_bytes.stderr
new file mode 100644
index 00000000000..afbb8e3b16c
--- /dev/null
+++ b/tests/ui/endian_bytes.stderr
@@ -0,0 +1,1152 @@
+error: use of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:6:11
+   |
+LL |   fn host() {
+   |  ___________^
+LL | |     2u8.to_ne_bytes();
+LL | |     2i8.to_ne_bytes();
+LL | |     2u16.to_ne_bytes();
+...  |
+LL | |     f64::from_ne_bytes(todo!());
+LL | | }
+   | |_^
+   |
+   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).202), kind: Block(Block { stmts: [Stmt { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).4), kind: Semi(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).1), kind: MethodCall(PathSegment { ident: to_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).2), res: Err, args: None, infer_args: true }, Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).3), kind: Lit(Spanned { node: Int(2, Unsigned(U8)), span: $DIR/endian_bytes.rs:7:5: 7:8 (#0) }), span: $DIR/endian_bytes.rs:7:5: 7:8 (#0) }, [], $DIR/endian_bytes.rs:7:9: 7:22 (#0)), span: $DIR/endian_bytes.rs:7:5: 7:22 (#0) }), span: $DIR/endian_bytes.rs:7:5: 7:23 (#0) }, Stmt { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).8), kind: Semi(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).5), kind: MethodCall(PathSegment { ident: to_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).6), res: Err, args: None, infer_args: true }, Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).7), kind: Lit(Spanned { node: Int(2, Signed(I8)), span: $DIR/endian_bytes.rs:8:5: 8:8 (#0) }), span: $DIR/endian_bytes.rs:8:5: 8:8 (#0) }, [], $DIR/endian_bytes.rs:8:9: 8:22 (#0)), span: $DIR/endian_bytes.rs:8:5: 8:22 (#0) }), span: $DIR/endian_bytes.rs:8:5: 8:23 (#0) }, Stmt { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).12), kind: Semi(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).9), kind: MethodCall(PathSegment { ident: to_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).10), res: Err, args: None, infer_args: true }, Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).11), kind: Lit(Spanned { node: Int(2, Unsigned(U16)), span: $DIR/endian_bytes.rs:9:5: 9:9 (#0) }), span: $DIR/endian_bytes.rs:9:5: 9:9 (#0) }, [], $DIR/endian_bytes.rs:9:10: 9:23 (#0)), span: $DIR/endian_bytes.rs:9:5: 9:23 (#0) }), span: $DIR/endian_bytes.rs:9:5: 9:24 (#0) }, Stmt { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).16), kind: Semi(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).13), kind: MethodCall(PathSegment { ident: to_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).14), res: Err, args: None, infer_args: true }, Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).15), kind: Lit(Spanned { node: Int(2, Signed(I16)), span: $DIR/endian_bytes.rs:10:5: 10:9 (#0) }), span: $DIR/endian_bytes.rs:10:5: 10:9 (#0) }, [], $DIR/endian_bytes.rs:10:10: 10:23 (#0)), span: $DIR/endian_bytes.rs:10:5: 10:23 (#0) }), span: $DIR/endian_bytes.rs:10:5: 10:24 (#0) }, Stmt { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).20), kind: Semi(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).17), kind: MethodCall(PathSegment { ident: to_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).18), res: Err, args: None, infer_args: true }, Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).19), kind: Lit(Spanned { node: Int(2, Unsigned(U32)), span: $DIR/endian_bytes.rs:11:5: 11:9 (#0) }), span: $DIR/endian_bytes.rs:11:5: 11:9 (#0) }, [], $DIR/endian_bytes.rs:11:10: 11:23 (#0)), span: $DIR/endian_bytes.rs:11:5: 11:23 (#0) }), span: $DIR/endian_bytes.rs:11:5: 11:24 (#0) }, Stmt { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).24), kind: Semi(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).21), kind: MethodCall(PathSegment { ident: to_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).22), res: Err, args: None, infer_args: true }, Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).23), kind: Lit(Spanned { node: Int(2, Signed(I32)), span: $DIR/endian_bytes.rs:12:5: 12:9 (#0) }), span: $DIR/endian_bytes.rs:12:5: 12:9 (#0) }, [], $DIR/endian_bytes.rs:12:10: 12:23 (#0)), span: $DIR/endian_bytes.rs:12:5: 12:23 (#0) }), span: $DIR/endian_bytes.rs:12:5: 12:24 (#0) }, Stmt { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).28), kind: Semi(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).25), kind: MethodCall(PathSegment { ident: to_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).26), res: Err, args: None, infer_args: true }, Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).27), kind: Lit(Spanned { node: Int(2, Unsigned(U64)), span: $DIR/endian_bytes.rs:13:5: 13:9 (#0) }), span: $DIR/endian_bytes.rs:13:5: 13:9 (#0) }, [], $DIR/endian_bytes.rs:13:10: 13:23 (#0)), span: $DIR/endian_bytes.rs:13:5: 13:23 (#0) }), span: $DIR/endian_bytes.rs:13:5: 13:24 (#0) }, Stmt { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).32), kind: Semi(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).29), kind: MethodCall(PathSegment { ident: to_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).30), res: Err, args: None, infer_args: true }, Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).31), kind: Lit(Spanned { node: Int(2, Signed(I64)), span: $DIR/endian_bytes.rs:14:5: 14:9 (#0) }), span: $DIR/endian_bytes.rs:14:5: 14:9 (#0) }, [], $DIR/endian_bytes.rs:14:10: 14:23 (#0)), span: $DIR/endian_bytes.rs:14:5: 14:23 (#0) }), span: $DIR/endian_bytes.rs:14:5: 14:24 (#0) }, Stmt { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).36), kind: Semi(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).33), kind: MethodCall(PathSegment { ident: to_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).34), res: Err, args: None, infer_args: true }, Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).35), kind: Lit(Spanned { node: Int(2, Unsigned(U128)), span: $DIR/endian_bytes.rs:15:5: 15:10 (#0) }), span: $DIR/endian_bytes.rs:15:5: 15:10 (#0) }, [], $DIR/endian_bytes.rs:15:11: 15:24 (#0)), span: $DIR/endian_bytes.rs:15:5: 15:24 (#0) }), span: $DIR/endian_bytes.rs:15:5: 15:25 (#0) }, Stmt { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).40), kind: Semi(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).37), kind: MethodCall(PathSegment { ident: to_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).38), res: Err, args: None, infer_args: true }, Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).39), kind: Lit(Spanned { node: Int(2, Signed(I128)), span: $DIR/endian_bytes.rs:16:5: 16:10 (#0) }), span: $DIR/endian_bytes.rs:16:5: 16:10 (#0) }, [], $DIR/endian_bytes.rs:16:11: 16:24 (#0)), span: $DIR/endian_bytes.rs:16:5: 16:24 (#0) }), span: $DIR/endian_bytes.rs:16:5: 16:25 (#0) }, Stmt { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).44), kind: Semi(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).41), kind: MethodCall(PathSegment { ident: to_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).42), res: Err, args: None, infer_args: true }, Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).43), kind: Lit(Spanned { node: Int(2, Unsigned(Usize)), span: $DIR/endian_bytes.rs:17:5: 17:11 (#0) }), span: $DIR/endian_bytes.rs:17:5: 17:11 (#0) }, [], $DIR/endian_bytes.rs:17:12: 17:25 (#0)), span: $DIR/endian_bytes.rs:17:5: 17:25 (#0) }), span: $DIR/endian_bytes.rs:17:5: 17:26 (#0) }, Stmt { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).48), kind: Semi(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).45), kind: MethodCall(PathSegment { ident: to_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).46), res: Err, args: None, infer_args: true }, Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).47), kind: Lit(Spanned { node: Int(2, Signed(Isize)), span: $DIR/endian_bytes.rs:18:5: 18:11 (#0) }), span: $DIR/endian_bytes.rs:18:5: 18:11 (#0) }, [], $DIR/endian_bytes.rs:18:12: 18:25 (#0)), span: $DIR/endian_bytes.rs:18:5: 18:25 (#0) }), span: $DIR/endian_bytes.rs:18:5: 18:26 (#0) }, Stmt { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).52), kind: Semi(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).49), kind: MethodCall(PathSegment { ident: to_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).50), res: Err, args: None, infer_args: true }, Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).51), kind: Lit(Spanned { node: Float("2.0", Suffixed(F32)), span: $DIR/endian_bytes.rs:19:5: 19:11 (#0) }), span: $DIR/endian_bytes.rs:19:5: 19:11 (#0) }, [], $DIR/endian_bytes.rs:19:12: 19:25 (#0)), span: $DIR/endian_bytes.rs:19:5: 19:25 (#0) }), span: $DIR/endian_bytes.rs:19:5: 19:26 (#0) }, Stmt { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).56), kind: Semi(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).53), kind: MethodCall(PathSegment { ident: to_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).54), res: Err, args: None, infer_args: true }, Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).55), kind: Lit(Spanned { node: Float("2.0", Suffixed(F64)), span: $DIR/endian_bytes.rs:20:5: 20:11 (#0) }), span: $DIR/endian_bytes.rs:20:5: 20:11 (#0) }, [], $DIR/endian_bytes.rs:20:12: 20:25 (#0)), span: $DIR/endian_bytes.rs:20:5: 20:25 (#0) }), span: $DIR/endian_bytes.rs:20:5: 20:26 (#0) }, Stmt { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).68), kind: Semi(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).57), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).58), kind: Path(TypeRelative(Ty { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).60), kind: Path(Resolved(None, Path { span: $DIR/endian_bytes.rs:21:5: 21:7 (#0), res: PrimTy(Uint(U8)), segments: [PathSegment { ident: u8#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).59), res: PrimTy(Uint(U8)), args: None, infer_args: true }] })), span: $DIR/endian_bytes.rs:21:5: 21:7 (#0) }, PathSegment { ident: from_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).61), res: Err, args: None, infer_args: true })), span: $DIR/endian_bytes.rs:21:5: 21:22 (#0) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).62), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).63), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#4), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#4, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).64), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#4, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).65), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#4, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).66), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#4) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).67), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#4) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#4) }]), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:56 (#4) }]), span: $DIR/endian_bytes.rs:21:5: 21:31 (#0) }), span: $DIR/endian_bytes.rs:21:5: 21:32 (#0) }, Stmt { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).80), kind: Semi(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).69), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).70), kind: Path(TypeRelative(Ty { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).72), kind: Path(Resolved(None, Path { span: $DIR/endian_bytes.rs:22:5: 22:7 (#0), res: PrimTy(Int(I8)), segments: [PathSegment { ident: i8#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).71), res: PrimTy(Int(I8)), args: None, infer_args: true }] })), span: $DIR/endian_bytes.rs:22:5: 22:7 (#0) }, PathSegment { ident: from_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).73), res: Err, args: None, infer_args: true })), span: $DIR/endian_bytes.rs:22:5: 22:22 (#0) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).74), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).75), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#5), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#5, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).76), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#5, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).77), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#5, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).78), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#5) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).79), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#5) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#5) }]), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:56 (#5) }]), span: $DIR/endian_bytes.rs:22:5: 22:31 (#0) }), span: $DIR/endian_bytes.rs:22:5: 22:32 (#0) }, Stmt { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).92), kind: Semi(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).81), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).82), kind: Path(TypeRelative(Ty { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).84), kind: Path(Resolved(None, Path { span: $DIR/endian_bytes.rs:23:5: 23:8 (#0), res: PrimTy(Uint(U16)), segments: [PathSegment { ident: u16#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).83), res: PrimTy(Uint(U16)), args: None, infer_args: true }] })), span: $DIR/endian_bytes.rs:23:5: 23:8 (#0) }, PathSegment { ident: from_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).85), res: Err, args: None, infer_args: true })), span: $DIR/endian_bytes.rs:23:5: 23:23 (#0) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).86), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).87), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#6), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#6, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).88), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#6, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).89), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#6, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).90), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#6) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).91), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#6) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#6) }]), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:56 (#6) }]), span: $DIR/endian_bytes.rs:23:5: 23:32 (#0) }), span: $DIR/endian_bytes.rs:23:5: 23:33 (#0) }, Stmt { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).104), kind: Semi(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).93), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).94), kind: Path(TypeRelative(Ty { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).96), kind: Path(Resolved(None, Path { span: $DIR/endian_bytes.rs:24:5: 24:8 (#0), res: PrimTy(Int(I16)), segments: [PathSegment { ident: i16#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).95), res: PrimTy(Int(I16)), args: None, infer_args: true }] })), span: $DIR/endian_bytes.rs:24:5: 24:8 (#0) }, PathSegment { ident: from_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).97), res: Err, args: None, infer_args: true })), span: $DIR/endian_bytes.rs:24:5: 24:23 (#0) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).98), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).99), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#7), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#7, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).100), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#7, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).101), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#7, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).102), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#7) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).103), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#7) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#7) }]), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:56 (#7) }]), span: $DIR/endian_bytes.rs:24:5: 24:32 (#0) }), span: $DIR/endian_bytes.rs:24:5: 24:33 (#0) }, Stmt { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).116), kind: Semi(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).105), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).106), kind: Path(TypeRelative(Ty { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).108), kind: Path(Resolved(None, Path { span: $DIR/endian_bytes.rs:25:5: 25:8 (#0), res: PrimTy(Uint(U32)), segments: [PathSegment { ident: u32#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).107), res: PrimTy(Uint(U32)), args: None, infer_args: true }] })), span: $DIR/endian_bytes.rs:25:5: 25:8 (#0) }, PathSegment { ident: from_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).109), res: Err, args: None, infer_args: true })), span: $DIR/endian_bytes.rs:25:5: 25:23 (#0) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).110), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).111), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#8), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#8, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).112), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#8, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).113), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#8, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).114), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#8) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).115), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#8) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#8) }]), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:56 (#8) }]), span: $DIR/endian_bytes.rs:25:5: 25:32 (#0) }), span: $DIR/endian_bytes.rs:25:5: 25:33 (#0) }, Stmt { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).128), kind: Semi(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).117), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).118), kind: Path(TypeRelative(Ty { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).120), kind: Path(Resolved(None, Path { span: $DIR/endian_bytes.rs:26:5: 26:8 (#0), res: PrimTy(Int(I32)), segments: [PathSegment { ident: i32#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).119), res: PrimTy(Int(I32)), args: None, infer_args: true }] })), span: $DIR/endian_bytes.rs:26:5: 26:8 (#0) }, PathSegment { ident: from_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).121), res: Err, args: None, infer_args: true })), span: $DIR/endian_bytes.rs:26:5: 26:23 (#0) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).122), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).123), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#9), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#9, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).124), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#9, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).125), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#9, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).126), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#9) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).127), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#9) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#9) }]), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:56 (#9) }]), span: $DIR/endian_bytes.rs:26:5: 26:32 (#0) }), span: $DIR/endian_bytes.rs:26:5: 26:33 (#0) }, Stmt { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).140), kind: Semi(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).129), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).130), kind: Path(TypeRelative(Ty { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).132), kind: Path(Resolved(None, Path { span: $DIR/endian_bytes.rs:27:5: 27:8 (#0), res: PrimTy(Uint(U64)), segments: [PathSegment { ident: u64#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).131), res: PrimTy(Uint(U64)), args: None, infer_args: true }] })), span: $DIR/endian_bytes.rs:27:5: 27:8 (#0) }, PathSegment { ident: from_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).133), res: Err, args: None, infer_args: true })), span: $DIR/endian_bytes.rs:27:5: 27:23 (#0) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).134), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).135), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#10), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#10, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).136), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#10, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).137), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#10, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).138), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#10) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).139), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#10) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#10) }]), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:56 (#10) }]), span: $DIR/endian_bytes.rs:27:5: 27:32 (#0) }), span: $DIR/endian_bytes.rs:27:5: 27:33 (#0) }, Stmt { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).152), kind: Semi(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).141), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).142), kind: Path(TypeRelative(Ty { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).144), kind: Path(Resolved(None, Path { span: $DIR/endian_bytes.rs:28:5: 28:8 (#0), res: PrimTy(Int(I64)), segments: [PathSegment { ident: i64#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).143), res: PrimTy(Int(I64)), args: None, infer_args: true }] })), span: $DIR/endian_bytes.rs:28:5: 28:8 (#0) }, PathSegment { ident: from_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).145), res: Err, args: None, infer_args: true })), span: $DIR/endian_bytes.rs:28:5: 28:23 (#0) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).146), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).147), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#11), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#11, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).148), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#11, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).149), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#11, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).150), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#11) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).151), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#11) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#11) }]), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:56 (#11) }]), span: $DIR/endian_bytes.rs:28:5: 28:32 (#0) }), span: $DIR/endian_bytes.rs:28:5: 28:33 (#0) }, Stmt { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).164), kind: Semi(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).153), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).154), kind: Path(TypeRelative(Ty { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).156), kind: Path(Resolved(None, Path { span: $DIR/endian_bytes.rs:29:5: 29:9 (#0), res: PrimTy(Uint(U128)), segments: [PathSegment { ident: u128#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).155), res: PrimTy(Uint(U128)), args: None, infer_args: true }] })), span: $DIR/endian_bytes.rs:29:5: 29:9 (#0) }, PathSegment { ident: from_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).157), res: Err, args: None, infer_args: true })), span: $DIR/endian_bytes.rs:29:5: 29:24 (#0) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).158), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).159), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#12), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#12, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).160), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#12, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).161), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#12, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).162), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#12) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).163), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#12) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#12) }]), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:56 (#12) }]), span: $DIR/endian_bytes.rs:29:5: 29:33 (#0) }), span: $DIR/endian_bytes.rs:29:5: 29:34 (#0) }, Stmt { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).176), kind: Semi(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).165), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).166), kind: Path(TypeRelative(Ty { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).168), kind: Path(Resolved(None, Path { span: $DIR/endian_bytes.rs:30:5: 30:9 (#0), res: PrimTy(Int(I128)), segments: [PathSegment { ident: i128#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).167), res: PrimTy(Int(I128)), args: None, infer_args: true }] })), span: $DIR/endian_bytes.rs:30:5: 30:9 (#0) }, PathSegment { ident: from_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).169), res: Err, args: None, infer_args: true })), span: $DIR/endian_bytes.rs:30:5: 30:24 (#0) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).170), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).171), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#13), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#13, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).172), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#13, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).173), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#13, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).174), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#13) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).175), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#13) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#13) }]), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:56 (#13) }]), span: $DIR/endian_bytes.rs:30:5: 30:33 (#0) }), span: $DIR/endian_bytes.rs:30:5: 30:34 (#0) }, Stmt { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).188), kind: Semi(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).177), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).178), kind: Path(TypeRelative(Ty { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).180), kind: Path(Resolved(None, Path { span: $DIR/endian_bytes.rs:31:5: 31:8 (#0), res: PrimTy(Float(F32)), segments: [PathSegment { ident: f32#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).179), res: PrimTy(Float(F32)), args: None, infer_args: true }] })), span: $DIR/endian_bytes.rs:31:5: 31:8 (#0) }, PathSegment { ident: from_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).181), res: Err, args: None, infer_args: true })), span: $DIR/endian_bytes.rs:31:5: 31:23 (#0) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).182), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).183), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#14), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#14, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).184), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#14, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).185), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#14, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).186), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#14) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).187), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#14) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#14) }]), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:56 (#14) }]), span: $DIR/endian_bytes.rs:31:5: 31:32 (#0) }), span: $DIR/endian_bytes.rs:31:5: 31:33 (#0) }, Stmt { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).200), kind: Semi(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).189), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).190), kind: Path(TypeRelative(Ty { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).192), kind: Path(Resolved(None, Path { span: $DIR/endian_bytes.rs:32:5: 32:8 (#0), res: PrimTy(Float(F64)), segments: [PathSegment { ident: f64#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).191), res: PrimTy(Float(F64)), args: None, infer_args: true }] })), span: $DIR/endian_bytes.rs:32:5: 32:8 (#0) }, PathSegment { ident: from_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).193), res: Err, args: None, infer_args: true })), span: $DIR/endian_bytes.rs:32:5: 32:23 (#0) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).194), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).195), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#15), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#15, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).196), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#15, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).197), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#15, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).198), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#15) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).199), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#15) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#15) }]), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:56 (#15) }]), span: $DIR/endian_bytes.rs:32:5: 32:32 (#0) }), span: $DIR/endian_bytes.rs:32:5: 32:33 (#0) }], expr: None, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).201), rules: DefaultBlock, span: $DIR/endian_bytes.rs:6:11: 33:2 (#0), targeted_by_break: false }, None), span: $DIR/endian_bytes.rs:6:11: 33:2 (#0) }
+   = note: `-D clippy::host-endian-bytes` implied by `-D warnings`
+
+error: use of the method `to_ne_bytes`
+  --> $DIR/endian_bytes.rs:7:5
+   |
+LL |     2u8.to_ne_bytes();
+   |     ^^^^^^^^^^^^^^^^^
+   |
+   = help: consider specifying the desired endianness
+
+error: use of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:7:5
+   |
+LL |     2u8.to_ne_bytes();
+   |     ^^^
+   |
+   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).3), kind: Lit(Spanned { node: Int(2, Unsigned(U8)), span: $DIR/endian_bytes.rs:7:5: 7:8 (#0) }), span: $DIR/endian_bytes.rs:7:5: 7:8 (#0) }
+
+error: use of the method `to_ne_bytes`
+  --> $DIR/endian_bytes.rs:8:5
+   |
+LL |     2i8.to_ne_bytes();
+   |     ^^^^^^^^^^^^^^^^^
+   |
+   = help: consider specifying the desired endianness
+
+error: use of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:8:5
+   |
+LL |     2i8.to_ne_bytes();
+   |     ^^^
+   |
+   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).7), kind: Lit(Spanned { node: Int(2, Signed(I8)), span: $DIR/endian_bytes.rs:8:5: 8:8 (#0) }), span: $DIR/endian_bytes.rs:8:5: 8:8 (#0) }
+
+error: use of the method `to_ne_bytes`
+  --> $DIR/endian_bytes.rs:9:5
+   |
+LL |     2u16.to_ne_bytes();
+   |     ^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider specifying the desired endianness
+
+error: use of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:9:5
+   |
+LL |     2u16.to_ne_bytes();
+   |     ^^^^
+   |
+   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).11), kind: Lit(Spanned { node: Int(2, Unsigned(U16)), span: $DIR/endian_bytes.rs:9:5: 9:9 (#0) }), span: $DIR/endian_bytes.rs:9:5: 9:9 (#0) }
+
+error: use of the method `to_ne_bytes`
+  --> $DIR/endian_bytes.rs:10:5
+   |
+LL |     2i16.to_ne_bytes();
+   |     ^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider specifying the desired endianness
+
+error: use of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:10:5
+   |
+LL |     2i16.to_ne_bytes();
+   |     ^^^^
+   |
+   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).15), kind: Lit(Spanned { node: Int(2, Signed(I16)), span: $DIR/endian_bytes.rs:10:5: 10:9 (#0) }), span: $DIR/endian_bytes.rs:10:5: 10:9 (#0) }
+
+error: use of the method `to_ne_bytes`
+  --> $DIR/endian_bytes.rs:11:5
+   |
+LL |     2u32.to_ne_bytes();
+   |     ^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider specifying the desired endianness
+
+error: use of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:11:5
+   |
+LL |     2u32.to_ne_bytes();
+   |     ^^^^
+   |
+   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).19), kind: Lit(Spanned { node: Int(2, Unsigned(U32)), span: $DIR/endian_bytes.rs:11:5: 11:9 (#0) }), span: $DIR/endian_bytes.rs:11:5: 11:9 (#0) }
+
+error: use of the method `to_ne_bytes`
+  --> $DIR/endian_bytes.rs:12:5
+   |
+LL |     2i32.to_ne_bytes();
+   |     ^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider specifying the desired endianness
+
+error: use of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:12:5
+   |
+LL |     2i32.to_ne_bytes();
+   |     ^^^^
+   |
+   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).23), kind: Lit(Spanned { node: Int(2, Signed(I32)), span: $DIR/endian_bytes.rs:12:5: 12:9 (#0) }), span: $DIR/endian_bytes.rs:12:5: 12:9 (#0) }
+
+error: use of the method `to_ne_bytes`
+  --> $DIR/endian_bytes.rs:13:5
+   |
+LL |     2u64.to_ne_bytes();
+   |     ^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider specifying the desired endianness
+
+error: use of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:13:5
+   |
+LL |     2u64.to_ne_bytes();
+   |     ^^^^
+   |
+   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).27), kind: Lit(Spanned { node: Int(2, Unsigned(U64)), span: $DIR/endian_bytes.rs:13:5: 13:9 (#0) }), span: $DIR/endian_bytes.rs:13:5: 13:9 (#0) }
+
+error: use of the method `to_ne_bytes`
+  --> $DIR/endian_bytes.rs:14:5
+   |
+LL |     2i64.to_ne_bytes();
+   |     ^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider specifying the desired endianness
+
+error: use of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:14:5
+   |
+LL |     2i64.to_ne_bytes();
+   |     ^^^^
+   |
+   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).31), kind: Lit(Spanned { node: Int(2, Signed(I64)), span: $DIR/endian_bytes.rs:14:5: 14:9 (#0) }), span: $DIR/endian_bytes.rs:14:5: 14:9 (#0) }
+
+error: use of the method `to_ne_bytes`
+  --> $DIR/endian_bytes.rs:15:5
+   |
+LL |     2u128.to_ne_bytes();
+   |     ^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider specifying the desired endianness
+
+error: use of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:15:5
+   |
+LL |     2u128.to_ne_bytes();
+   |     ^^^^^
+   |
+   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).35), kind: Lit(Spanned { node: Int(2, Unsigned(U128)), span: $DIR/endian_bytes.rs:15:5: 15:10 (#0) }), span: $DIR/endian_bytes.rs:15:5: 15:10 (#0) }
+
+error: use of the method `to_ne_bytes`
+  --> $DIR/endian_bytes.rs:16:5
+   |
+LL |     2i128.to_ne_bytes();
+   |     ^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider specifying the desired endianness
+
+error: use of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:16:5
+   |
+LL |     2i128.to_ne_bytes();
+   |     ^^^^^
+   |
+   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).39), kind: Lit(Spanned { node: Int(2, Signed(I128)), span: $DIR/endian_bytes.rs:16:5: 16:10 (#0) }), span: $DIR/endian_bytes.rs:16:5: 16:10 (#0) }
+
+error: use of the method `to_ne_bytes`
+  --> $DIR/endian_bytes.rs:17:5
+   |
+LL |     2usize.to_ne_bytes();
+   |     ^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider specifying the desired endianness
+
+error: use of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:17:5
+   |
+LL |     2usize.to_ne_bytes();
+   |     ^^^^^^
+   |
+   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).43), kind: Lit(Spanned { node: Int(2, Unsigned(Usize)), span: $DIR/endian_bytes.rs:17:5: 17:11 (#0) }), span: $DIR/endian_bytes.rs:17:5: 17:11 (#0) }
+
+error: use of the method `to_ne_bytes`
+  --> $DIR/endian_bytes.rs:18:5
+   |
+LL |     2isize.to_ne_bytes();
+   |     ^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider specifying the desired endianness
+
+error: use of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:18:5
+   |
+LL |     2isize.to_ne_bytes();
+   |     ^^^^^^
+   |
+   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).47), kind: Lit(Spanned { node: Int(2, Signed(Isize)), span: $DIR/endian_bytes.rs:18:5: 18:11 (#0) }), span: $DIR/endian_bytes.rs:18:5: 18:11 (#0) }
+
+error: use of the method `to_ne_bytes`
+  --> $DIR/endian_bytes.rs:19:5
+   |
+LL |     2.0f32.to_ne_bytes();
+   |     ^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider specifying the desired endianness
+
+error: use of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:19:5
+   |
+LL |     2.0f32.to_ne_bytes();
+   |     ^^^^^^
+   |
+   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).51), kind: Lit(Spanned { node: Float("2.0", Suffixed(F32)), span: $DIR/endian_bytes.rs:19:5: 19:11 (#0) }), span: $DIR/endian_bytes.rs:19:5: 19:11 (#0) }
+
+error: use of the method `to_ne_bytes`
+  --> $DIR/endian_bytes.rs:20:5
+   |
+LL |     2.0f64.to_ne_bytes();
+   |     ^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider specifying the desired endianness
+
+error: use of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:20:5
+   |
+LL |     2.0f64.to_ne_bytes();
+   |     ^^^^^^
+   |
+   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).55), kind: Lit(Spanned { node: Float("2.0", Suffixed(F64)), span: $DIR/endian_bytes.rs:20:5: 20:11 (#0) }), span: $DIR/endian_bytes.rs:20:5: 20:11 (#0) }
+
+error: use of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:21:5
+   |
+LL |     u8::from_ne_bytes(todo!());
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).57), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).58), kind: Path(TypeRelative(Ty { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).60), kind: Path(Resolved(None, Path { span: $DIR/endian_bytes.rs:21:5: 21:7 (#0), res: PrimTy(Uint(U8)), segments: [PathSegment { ident: u8#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).59), res: PrimTy(Uint(U8)), args: None, infer_args: true }] })), span: $DIR/endian_bytes.rs:21:5: 21:7 (#0) }, PathSegment { ident: from_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).61), res: Err, args: None, infer_args: true })), span: $DIR/endian_bytes.rs:21:5: 21:22 (#0) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).62), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).63), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#4), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#4, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).64), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#4, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).65), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#4, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).66), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#4) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).67), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#4) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#4) }]), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:56 (#4) }]), span: $DIR/endian_bytes.rs:21:5: 21:31 (#0) }
+
+error: use of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:21:5
+   |
+LL |     u8::from_ne_bytes(todo!());
+   |     ^^^^^^^^^^^^^^^^^
+   |
+   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).58), kind: Path(TypeRelative(Ty { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).60), kind: Path(Resolved(None, Path { span: $DIR/endian_bytes.rs:21:5: 21:7 (#0), res: PrimTy(Uint(U8)), segments: [PathSegment { ident: u8#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).59), res: PrimTy(Uint(U8)), args: None, infer_args: true }] })), span: $DIR/endian_bytes.rs:21:5: 21:7 (#0) }, PathSegment { ident: from_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).61), res: Err, args: None, infer_args: true })), span: $DIR/endian_bytes.rs:21:5: 21:22 (#0) }
+
+error: use of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:21:23
+   |
+LL |     u8::from_ne_bytes(todo!());
+   |                       ^^^^^^^
+   |
+   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).62), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).63), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#4), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#4, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).64), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#4, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).65), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#4, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).66), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#4) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).67), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#4) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#4) }]), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:56 (#4) }
+   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: use of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:21:23
+   |
+LL |     u8::from_ne_bytes(todo!());
+   |                       ^^^^^^^
+   |
+   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).63), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#4), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#4, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).64), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#4, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).65), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#4, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).66), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#4) }
+   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: use of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:21:23
+   |
+LL |     u8::from_ne_bytes(todo!());
+   |                       ^^^^^^^
+   |
+   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).67), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#4) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#4) }
+   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: use of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:22:5
+   |
+LL |     i8::from_ne_bytes(todo!());
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).69), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).70), kind: Path(TypeRelative(Ty { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).72), kind: Path(Resolved(None, Path { span: $DIR/endian_bytes.rs:22:5: 22:7 (#0), res: PrimTy(Int(I8)), segments: [PathSegment { ident: i8#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).71), res: PrimTy(Int(I8)), args: None, infer_args: true }] })), span: $DIR/endian_bytes.rs:22:5: 22:7 (#0) }, PathSegment { ident: from_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).73), res: Err, args: None, infer_args: true })), span: $DIR/endian_bytes.rs:22:5: 22:22 (#0) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).74), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).75), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#5), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#5, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).76), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#5, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).77), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#5, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).78), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#5) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).79), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#5) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#5) }]), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:56 (#5) }]), span: $DIR/endian_bytes.rs:22:5: 22:31 (#0) }
+
+error: use of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:22:5
+   |
+LL |     i8::from_ne_bytes(todo!());
+   |     ^^^^^^^^^^^^^^^^^
+   |
+   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).70), kind: Path(TypeRelative(Ty { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).72), kind: Path(Resolved(None, Path { span: $DIR/endian_bytes.rs:22:5: 22:7 (#0), res: PrimTy(Int(I8)), segments: [PathSegment { ident: i8#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).71), res: PrimTy(Int(I8)), args: None, infer_args: true }] })), span: $DIR/endian_bytes.rs:22:5: 22:7 (#0) }, PathSegment { ident: from_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).73), res: Err, args: None, infer_args: true })), span: $DIR/endian_bytes.rs:22:5: 22:22 (#0) }
+
+error: use of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:22:23
+   |
+LL |     i8::from_ne_bytes(todo!());
+   |                       ^^^^^^^
+   |
+   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).74), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).75), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#5), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#5, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).76), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#5, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).77), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#5, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).78), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#5) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).79), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#5) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#5) }]), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:56 (#5) }
+   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: use of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:22:23
+   |
+LL |     i8::from_ne_bytes(todo!());
+   |                       ^^^^^^^
+   |
+   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).75), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#5), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#5, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).76), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#5, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).77), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#5, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).78), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#5) }
+   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: use of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:22:23
+   |
+LL |     i8::from_ne_bytes(todo!());
+   |                       ^^^^^^^
+   |
+   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).79), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#5) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#5) }
+   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: use of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:23:5
+   |
+LL |     u16::from_ne_bytes(todo!());
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).81), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).82), kind: Path(TypeRelative(Ty { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).84), kind: Path(Resolved(None, Path { span: $DIR/endian_bytes.rs:23:5: 23:8 (#0), res: PrimTy(Uint(U16)), segments: [PathSegment { ident: u16#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).83), res: PrimTy(Uint(U16)), args: None, infer_args: true }] })), span: $DIR/endian_bytes.rs:23:5: 23:8 (#0) }, PathSegment { ident: from_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).85), res: Err, args: None, infer_args: true })), span: $DIR/endian_bytes.rs:23:5: 23:23 (#0) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).86), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).87), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#6), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#6, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).88), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#6, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).89), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#6, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).90), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#6) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).91), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#6) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#6) }]), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:56 (#6) }]), span: $DIR/endian_bytes.rs:23:5: 23:32 (#0) }
+
+error: use of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:23:5
+   |
+LL |     u16::from_ne_bytes(todo!());
+   |     ^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).82), kind: Path(TypeRelative(Ty { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).84), kind: Path(Resolved(None, Path { span: $DIR/endian_bytes.rs:23:5: 23:8 (#0), res: PrimTy(Uint(U16)), segments: [PathSegment { ident: u16#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).83), res: PrimTy(Uint(U16)), args: None, infer_args: true }] })), span: $DIR/endian_bytes.rs:23:5: 23:8 (#0) }, PathSegment { ident: from_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).85), res: Err, args: None, infer_args: true })), span: $DIR/endian_bytes.rs:23:5: 23:23 (#0) }
+
+error: use of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:23:24
+   |
+LL |     u16::from_ne_bytes(todo!());
+   |                        ^^^^^^^
+   |
+   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).86), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).87), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#6), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#6, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).88), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#6, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).89), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#6, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).90), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#6) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).91), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#6) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#6) }]), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:56 (#6) }
+   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: use of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:23:24
+   |
+LL |     u16::from_ne_bytes(todo!());
+   |                        ^^^^^^^
+   |
+   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).87), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#6), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#6, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).88), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#6, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).89), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#6, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).90), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#6) }
+   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: use of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:23:24
+   |
+LL |     u16::from_ne_bytes(todo!());
+   |                        ^^^^^^^
+   |
+   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).91), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#6) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#6) }
+   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: use of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:24:5
+   |
+LL |     i16::from_ne_bytes(todo!());
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).93), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).94), kind: Path(TypeRelative(Ty { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).96), kind: Path(Resolved(None, Path { span: $DIR/endian_bytes.rs:24:5: 24:8 (#0), res: PrimTy(Int(I16)), segments: [PathSegment { ident: i16#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).95), res: PrimTy(Int(I16)), args: None, infer_args: true }] })), span: $DIR/endian_bytes.rs:24:5: 24:8 (#0) }, PathSegment { ident: from_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).97), res: Err, args: None, infer_args: true })), span: $DIR/endian_bytes.rs:24:5: 24:23 (#0) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).98), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).99), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#7), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#7, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).100), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#7, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).101), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#7, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).102), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#7) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).103), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#7) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#7) }]), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:56 (#7) }]), span: $DIR/endian_bytes.rs:24:5: 24:32 (#0) }
+
+error: use of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:24:5
+   |
+LL |     i16::from_ne_bytes(todo!());
+   |     ^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).94), kind: Path(TypeRelative(Ty { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).96), kind: Path(Resolved(None, Path { span: $DIR/endian_bytes.rs:24:5: 24:8 (#0), res: PrimTy(Int(I16)), segments: [PathSegment { ident: i16#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).95), res: PrimTy(Int(I16)), args: None, infer_args: true }] })), span: $DIR/endian_bytes.rs:24:5: 24:8 (#0) }, PathSegment { ident: from_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).97), res: Err, args: None, infer_args: true })), span: $DIR/endian_bytes.rs:24:5: 24:23 (#0) }
+
+error: use of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:24:24
+   |
+LL |     i16::from_ne_bytes(todo!());
+   |                        ^^^^^^^
+   |
+   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).98), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).99), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#7), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#7, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).100), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#7, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).101), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#7, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).102), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#7) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).103), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#7) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#7) }]), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:56 (#7) }
+   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: use of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:24:24
+   |
+LL |     i16::from_ne_bytes(todo!());
+   |                        ^^^^^^^
+   |
+   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).99), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#7), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#7, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).100), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#7, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).101), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#7, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).102), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#7) }
+   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: use of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:24:24
+   |
+LL |     i16::from_ne_bytes(todo!());
+   |                        ^^^^^^^
+   |
+   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).103), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#7) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#7) }
+   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: use of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:25:5
+   |
+LL |     u32::from_ne_bytes(todo!());
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).105), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).106), kind: Path(TypeRelative(Ty { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).108), kind: Path(Resolved(None, Path { span: $DIR/endian_bytes.rs:25:5: 25:8 (#0), res: PrimTy(Uint(U32)), segments: [PathSegment { ident: u32#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).107), res: PrimTy(Uint(U32)), args: None, infer_args: true }] })), span: $DIR/endian_bytes.rs:25:5: 25:8 (#0) }, PathSegment { ident: from_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).109), res: Err, args: None, infer_args: true })), span: $DIR/endian_bytes.rs:25:5: 25:23 (#0) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).110), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).111), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#8), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#8, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).112), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#8, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).113), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#8, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).114), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#8) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).115), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#8) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#8) }]), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:56 (#8) }]), span: $DIR/endian_bytes.rs:25:5: 25:32 (#0) }
+
+error: use of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:25:5
+   |
+LL |     u32::from_ne_bytes(todo!());
+   |     ^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).106), kind: Path(TypeRelative(Ty { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).108), kind: Path(Resolved(None, Path { span: $DIR/endian_bytes.rs:25:5: 25:8 (#0), res: PrimTy(Uint(U32)), segments: [PathSegment { ident: u32#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).107), res: PrimTy(Uint(U32)), args: None, infer_args: true }] })), span: $DIR/endian_bytes.rs:25:5: 25:8 (#0) }, PathSegment { ident: from_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).109), res: Err, args: None, infer_args: true })), span: $DIR/endian_bytes.rs:25:5: 25:23 (#0) }
+
+error: use of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:25:24
+   |
+LL |     u32::from_ne_bytes(todo!());
+   |                        ^^^^^^^
+   |
+   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).110), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).111), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#8), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#8, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).112), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#8, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).113), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#8, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).114), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#8) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).115), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#8) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#8) }]), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:56 (#8) }
+   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: use of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:25:24
+   |
+LL |     u32::from_ne_bytes(todo!());
+   |                        ^^^^^^^
+   |
+   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).111), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#8), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#8, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).112), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#8, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).113), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#8, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).114), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#8) }
+   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: use of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:25:24
+   |
+LL |     u32::from_ne_bytes(todo!());
+   |                        ^^^^^^^
+   |
+   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).115), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#8) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#8) }
+   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: use of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:26:5
+   |
+LL |     i32::from_ne_bytes(todo!());
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).117), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).118), kind: Path(TypeRelative(Ty { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).120), kind: Path(Resolved(None, Path { span: $DIR/endian_bytes.rs:26:5: 26:8 (#0), res: PrimTy(Int(I32)), segments: [PathSegment { ident: i32#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).119), res: PrimTy(Int(I32)), args: None, infer_args: true }] })), span: $DIR/endian_bytes.rs:26:5: 26:8 (#0) }, PathSegment { ident: from_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).121), res: Err, args: None, infer_args: true })), span: $DIR/endian_bytes.rs:26:5: 26:23 (#0) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).122), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).123), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#9), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#9, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).124), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#9, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).125), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#9, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).126), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#9) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).127), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#9) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#9) }]), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:56 (#9) }]), span: $DIR/endian_bytes.rs:26:5: 26:32 (#0) }
+
+error: use of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:26:5
+   |
+LL |     i32::from_ne_bytes(todo!());
+   |     ^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).118), kind: Path(TypeRelative(Ty { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).120), kind: Path(Resolved(None, Path { span: $DIR/endian_bytes.rs:26:5: 26:8 (#0), res: PrimTy(Int(I32)), segments: [PathSegment { ident: i32#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).119), res: PrimTy(Int(I32)), args: None, infer_args: true }] })), span: $DIR/endian_bytes.rs:26:5: 26:8 (#0) }, PathSegment { ident: from_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).121), res: Err, args: None, infer_args: true })), span: $DIR/endian_bytes.rs:26:5: 26:23 (#0) }
+
+error: use of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:26:24
+   |
+LL |     i32::from_ne_bytes(todo!());
+   |                        ^^^^^^^
+   |
+   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).122), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).123), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#9), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#9, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).124), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#9, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).125), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#9, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).126), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#9) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).127), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#9) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#9) }]), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:56 (#9) }
+   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: use of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:26:24
+   |
+LL |     i32::from_ne_bytes(todo!());
+   |                        ^^^^^^^
+   |
+   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).123), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#9), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#9, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).124), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#9, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).125), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#9, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).126), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#9) }
+   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: use of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:26:24
+   |
+LL |     i32::from_ne_bytes(todo!());
+   |                        ^^^^^^^
+   |
+   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).127), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#9) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#9) }
+   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: use of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:27:5
+   |
+LL |     u64::from_ne_bytes(todo!());
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).129), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).130), kind: Path(TypeRelative(Ty { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).132), kind: Path(Resolved(None, Path { span: $DIR/endian_bytes.rs:27:5: 27:8 (#0), res: PrimTy(Uint(U64)), segments: [PathSegment { ident: u64#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).131), res: PrimTy(Uint(U64)), args: None, infer_args: true }] })), span: $DIR/endian_bytes.rs:27:5: 27:8 (#0) }, PathSegment { ident: from_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).133), res: Err, args: None, infer_args: true })), span: $DIR/endian_bytes.rs:27:5: 27:23 (#0) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).134), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).135), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#10), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#10, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).136), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#10, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).137), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#10, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).138), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#10) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).139), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#10) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#10) }]), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:56 (#10) }]), span: $DIR/endian_bytes.rs:27:5: 27:32 (#0) }
+
+error: use of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:27:5
+   |
+LL |     u64::from_ne_bytes(todo!());
+   |     ^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).130), kind: Path(TypeRelative(Ty { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).132), kind: Path(Resolved(None, Path { span: $DIR/endian_bytes.rs:27:5: 27:8 (#0), res: PrimTy(Uint(U64)), segments: [PathSegment { ident: u64#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).131), res: PrimTy(Uint(U64)), args: None, infer_args: true }] })), span: $DIR/endian_bytes.rs:27:5: 27:8 (#0) }, PathSegment { ident: from_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).133), res: Err, args: None, infer_args: true })), span: $DIR/endian_bytes.rs:27:5: 27:23 (#0) }
+
+error: use of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:27:24
+   |
+LL |     u64::from_ne_bytes(todo!());
+   |                        ^^^^^^^
+   |
+   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).134), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).135), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#10), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#10, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).136), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#10, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).137), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#10, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).138), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#10) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).139), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#10) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#10) }]), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:56 (#10) }
+   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: use of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:27:24
+   |
+LL |     u64::from_ne_bytes(todo!());
+   |                        ^^^^^^^
+   |
+   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).135), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#10), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#10, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).136), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#10, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).137), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#10, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).138), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#10) }
+   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: use of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:27:24
+   |
+LL |     u64::from_ne_bytes(todo!());
+   |                        ^^^^^^^
+   |
+   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).139), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#10) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#10) }
+   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: use of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:28:5
+   |
+LL |     i64::from_ne_bytes(todo!());
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).141), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).142), kind: Path(TypeRelative(Ty { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).144), kind: Path(Resolved(None, Path { span: $DIR/endian_bytes.rs:28:5: 28:8 (#0), res: PrimTy(Int(I64)), segments: [PathSegment { ident: i64#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).143), res: PrimTy(Int(I64)), args: None, infer_args: true }] })), span: $DIR/endian_bytes.rs:28:5: 28:8 (#0) }, PathSegment { ident: from_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).145), res: Err, args: None, infer_args: true })), span: $DIR/endian_bytes.rs:28:5: 28:23 (#0) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).146), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).147), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#11), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#11, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).148), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#11, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).149), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#11, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).150), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#11) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).151), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#11) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#11) }]), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:56 (#11) }]), span: $DIR/endian_bytes.rs:28:5: 28:32 (#0) }
+
+error: use of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:28:5
+   |
+LL |     i64::from_ne_bytes(todo!());
+   |     ^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).142), kind: Path(TypeRelative(Ty { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).144), kind: Path(Resolved(None, Path { span: $DIR/endian_bytes.rs:28:5: 28:8 (#0), res: PrimTy(Int(I64)), segments: [PathSegment { ident: i64#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).143), res: PrimTy(Int(I64)), args: None, infer_args: true }] })), span: $DIR/endian_bytes.rs:28:5: 28:8 (#0) }, PathSegment { ident: from_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).145), res: Err, args: None, infer_args: true })), span: $DIR/endian_bytes.rs:28:5: 28:23 (#0) }
+
+error: use of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:28:24
+   |
+LL |     i64::from_ne_bytes(todo!());
+   |                        ^^^^^^^
+   |
+   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).146), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).147), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#11), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#11, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).148), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#11, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).149), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#11, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).150), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#11) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).151), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#11) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#11) }]), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:56 (#11) }
+   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: use of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:28:24
+   |
+LL |     i64::from_ne_bytes(todo!());
+   |                        ^^^^^^^
+   |
+   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).147), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#11), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#11, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).148), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#11, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).149), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#11, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).150), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#11) }
+   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: use of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:28:24
+   |
+LL |     i64::from_ne_bytes(todo!());
+   |                        ^^^^^^^
+   |
+   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).151), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#11) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#11) }
+   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: use of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:29:5
+   |
+LL |     u128::from_ne_bytes(todo!());
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).153), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).154), kind: Path(TypeRelative(Ty { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).156), kind: Path(Resolved(None, Path { span: $DIR/endian_bytes.rs:29:5: 29:9 (#0), res: PrimTy(Uint(U128)), segments: [PathSegment { ident: u128#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).155), res: PrimTy(Uint(U128)), args: None, infer_args: true }] })), span: $DIR/endian_bytes.rs:29:5: 29:9 (#0) }, PathSegment { ident: from_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).157), res: Err, args: None, infer_args: true })), span: $DIR/endian_bytes.rs:29:5: 29:24 (#0) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).158), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).159), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#12), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#12, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).160), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#12, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).161), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#12, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).162), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#12) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).163), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#12) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#12) }]), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:56 (#12) }]), span: $DIR/endian_bytes.rs:29:5: 29:33 (#0) }
+
+error: use of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:29:5
+   |
+LL |     u128::from_ne_bytes(todo!());
+   |     ^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).154), kind: Path(TypeRelative(Ty { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).156), kind: Path(Resolved(None, Path { span: $DIR/endian_bytes.rs:29:5: 29:9 (#0), res: PrimTy(Uint(U128)), segments: [PathSegment { ident: u128#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).155), res: PrimTy(Uint(U128)), args: None, infer_args: true }] })), span: $DIR/endian_bytes.rs:29:5: 29:9 (#0) }, PathSegment { ident: from_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).157), res: Err, args: None, infer_args: true })), span: $DIR/endian_bytes.rs:29:5: 29:24 (#0) }
+
+error: use of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:29:25
+   |
+LL |     u128::from_ne_bytes(todo!());
+   |                         ^^^^^^^
+   |
+   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).158), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).159), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#12), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#12, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).160), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#12, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).161), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#12, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).162), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#12) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).163), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#12) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#12) }]), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:56 (#12) }
+   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: use of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:29:25
+   |
+LL |     u128::from_ne_bytes(todo!());
+   |                         ^^^^^^^
+   |
+   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).159), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#12), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#12, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).160), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#12, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).161), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#12, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).162), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#12) }
+   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: use of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:29:25
+   |
+LL |     u128::from_ne_bytes(todo!());
+   |                         ^^^^^^^
+   |
+   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).163), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#12) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#12) }
+   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: use of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:30:5
+   |
+LL |     i128::from_ne_bytes(todo!());
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).165), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).166), kind: Path(TypeRelative(Ty { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).168), kind: Path(Resolved(None, Path { span: $DIR/endian_bytes.rs:30:5: 30:9 (#0), res: PrimTy(Int(I128)), segments: [PathSegment { ident: i128#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).167), res: PrimTy(Int(I128)), args: None, infer_args: true }] })), span: $DIR/endian_bytes.rs:30:5: 30:9 (#0) }, PathSegment { ident: from_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).169), res: Err, args: None, infer_args: true })), span: $DIR/endian_bytes.rs:30:5: 30:24 (#0) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).170), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).171), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#13), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#13, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).172), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#13, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).173), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#13, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).174), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#13) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).175), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#13) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#13) }]), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:56 (#13) }]), span: $DIR/endian_bytes.rs:30:5: 30:33 (#0) }
+
+error: use of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:30:5
+   |
+LL |     i128::from_ne_bytes(todo!());
+   |     ^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).166), kind: Path(TypeRelative(Ty { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).168), kind: Path(Resolved(None, Path { span: $DIR/endian_bytes.rs:30:5: 30:9 (#0), res: PrimTy(Int(I128)), segments: [PathSegment { ident: i128#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).167), res: PrimTy(Int(I128)), args: None, infer_args: true }] })), span: $DIR/endian_bytes.rs:30:5: 30:9 (#0) }, PathSegment { ident: from_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).169), res: Err, args: None, infer_args: true })), span: $DIR/endian_bytes.rs:30:5: 30:24 (#0) }
+
+error: use of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:30:25
+   |
+LL |     i128::from_ne_bytes(todo!());
+   |                         ^^^^^^^
+   |
+   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).170), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).171), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#13), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#13, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).172), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#13, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).173), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#13, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).174), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#13) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).175), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#13) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#13) }]), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:56 (#13) }
+   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: use of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:30:25
+   |
+LL |     i128::from_ne_bytes(todo!());
+   |                         ^^^^^^^
+   |
+   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).171), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#13), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#13, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).172), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#13, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).173), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#13, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).174), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#13) }
+   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: use of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:30:25
+   |
+LL |     i128::from_ne_bytes(todo!());
+   |                         ^^^^^^^
+   |
+   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).175), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#13) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#13) }
+   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: use of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:31:5
+   |
+LL |     f32::from_ne_bytes(todo!());
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).177), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).178), kind: Path(TypeRelative(Ty { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).180), kind: Path(Resolved(None, Path { span: $DIR/endian_bytes.rs:31:5: 31:8 (#0), res: PrimTy(Float(F32)), segments: [PathSegment { ident: f32#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).179), res: PrimTy(Float(F32)), args: None, infer_args: true }] })), span: $DIR/endian_bytes.rs:31:5: 31:8 (#0) }, PathSegment { ident: from_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).181), res: Err, args: None, infer_args: true })), span: $DIR/endian_bytes.rs:31:5: 31:23 (#0) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).182), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).183), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#14), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#14, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).184), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#14, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).185), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#14, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).186), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#14) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).187), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#14) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#14) }]), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:56 (#14) }]), span: $DIR/endian_bytes.rs:31:5: 31:32 (#0) }
+
+error: use of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:31:5
+   |
+LL |     f32::from_ne_bytes(todo!());
+   |     ^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).178), kind: Path(TypeRelative(Ty { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).180), kind: Path(Resolved(None, Path { span: $DIR/endian_bytes.rs:31:5: 31:8 (#0), res: PrimTy(Float(F32)), segments: [PathSegment { ident: f32#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).179), res: PrimTy(Float(F32)), args: None, infer_args: true }] })), span: $DIR/endian_bytes.rs:31:5: 31:8 (#0) }, PathSegment { ident: from_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).181), res: Err, args: None, infer_args: true })), span: $DIR/endian_bytes.rs:31:5: 31:23 (#0) }
+
+error: use of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:31:24
+   |
+LL |     f32::from_ne_bytes(todo!());
+   |                        ^^^^^^^
+   |
+   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).182), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).183), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#14), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#14, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).184), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#14, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).185), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#14, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).186), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#14) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).187), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#14) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#14) }]), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:56 (#14) }
+   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: use of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:31:24
+   |
+LL |     f32::from_ne_bytes(todo!());
+   |                        ^^^^^^^
+   |
+   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).183), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#14), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#14, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).184), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#14, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).185), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#14, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).186), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#14) }
+   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: use of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:31:24
+   |
+LL |     f32::from_ne_bytes(todo!());
+   |                        ^^^^^^^
+   |
+   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).187), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#14) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#14) }
+   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: use of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:32:5
+   |
+LL |     f64::from_ne_bytes(todo!());
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).189), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).190), kind: Path(TypeRelative(Ty { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).192), kind: Path(Resolved(None, Path { span: $DIR/endian_bytes.rs:32:5: 32:8 (#0), res: PrimTy(Float(F64)), segments: [PathSegment { ident: f64#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).191), res: PrimTy(Float(F64)), args: None, infer_args: true }] })), span: $DIR/endian_bytes.rs:32:5: 32:8 (#0) }, PathSegment { ident: from_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).193), res: Err, args: None, infer_args: true })), span: $DIR/endian_bytes.rs:32:5: 32:23 (#0) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).194), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).195), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#15), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#15, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).196), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#15, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).197), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#15, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).198), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#15) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).199), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#15) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#15) }]), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:56 (#15) }]), span: $DIR/endian_bytes.rs:32:5: 32:32 (#0) }
+
+error: use of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:32:5
+   |
+LL |     f64::from_ne_bytes(todo!());
+   |     ^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).190), kind: Path(TypeRelative(Ty { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).192), kind: Path(Resolved(None, Path { span: $DIR/endian_bytes.rs:32:5: 32:8 (#0), res: PrimTy(Float(F64)), segments: [PathSegment { ident: f64#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).191), res: PrimTy(Float(F64)), args: None, infer_args: true }] })), span: $DIR/endian_bytes.rs:32:5: 32:8 (#0) }, PathSegment { ident: from_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).193), res: Err, args: None, infer_args: true })), span: $DIR/endian_bytes.rs:32:5: 32:23 (#0) }
+
+error: use of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:32:24
+   |
+LL |     f64::from_ne_bytes(todo!());
+   |                        ^^^^^^^
+   |
+   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).194), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).195), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#15), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#15, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).196), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#15, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).197), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#15, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).198), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#15) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).199), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#15) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#15) }]), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:56 (#15) }
+   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: use of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:32:24
+   |
+LL |     f64::from_ne_bytes(todo!());
+   |                        ^^^^^^^
+   |
+   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).195), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#15), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#15, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).196), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#15, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).197), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#15, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).198), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#15) }
+   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: use of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:32:24
+   |
+LL |     f64::from_ne_bytes(todo!());
+   |                        ^^^^^^^
+   |
+   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).199), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#15) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#15) }
+   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: use of the method `to_le_bytes`
+  --> $DIR/endian_bytes.rs:37:5
+   |
+LL |     2u8.to_le_bytes();
+   |     ^^^^^^^^^^^^^^^^^
+   |
+   = help: use `to_be_bytes` instead
+   = note: `-D clippy::little-endian-bytes` implied by `-D warnings`
+
+error: use of the method `to_le_bytes`
+  --> $DIR/endian_bytes.rs:38:5
+   |
+LL |     2i8.to_le_bytes();
+   |     ^^^^^^^^^^^^^^^^^
+   |
+   = help: use `to_be_bytes` instead
+
+error: use of the method `to_le_bytes`
+  --> $DIR/endian_bytes.rs:39:5
+   |
+LL |     2u16.to_le_bytes();
+   |     ^^^^^^^^^^^^^^^^^^
+   |
+   = help: use `to_be_bytes` instead
+
+error: use of the method `to_le_bytes`
+  --> $DIR/endian_bytes.rs:40:5
+   |
+LL |     2i16.to_le_bytes();
+   |     ^^^^^^^^^^^^^^^^^^
+   |
+   = help: use `to_be_bytes` instead
+
+error: use of the method `to_le_bytes`
+  --> $DIR/endian_bytes.rs:41:5
+   |
+LL |     2u32.to_le_bytes();
+   |     ^^^^^^^^^^^^^^^^^^
+   |
+   = help: use `to_be_bytes` instead
+
+error: use of the method `to_le_bytes`
+  --> $DIR/endian_bytes.rs:42:5
+   |
+LL |     2i32.to_le_bytes();
+   |     ^^^^^^^^^^^^^^^^^^
+   |
+   = help: use `to_be_bytes` instead
+
+error: use of the method `to_le_bytes`
+  --> $DIR/endian_bytes.rs:43:5
+   |
+LL |     2u64.to_le_bytes();
+   |     ^^^^^^^^^^^^^^^^^^
+   |
+   = help: use `to_be_bytes` instead
+
+error: use of the method `to_le_bytes`
+  --> $DIR/endian_bytes.rs:44:5
+   |
+LL |     2i64.to_le_bytes();
+   |     ^^^^^^^^^^^^^^^^^^
+   |
+   = help: use `to_be_bytes` instead
+
+error: use of the method `to_le_bytes`
+  --> $DIR/endian_bytes.rs:45:5
+   |
+LL |     2u128.to_le_bytes();
+   |     ^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use `to_be_bytes` instead
+
+error: use of the method `to_le_bytes`
+  --> $DIR/endian_bytes.rs:46:5
+   |
+LL |     2i128.to_le_bytes();
+   |     ^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use `to_be_bytes` instead
+
+error: use of the method `to_le_bytes`
+  --> $DIR/endian_bytes.rs:47:5
+   |
+LL |     2usize.to_le_bytes();
+   |     ^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use `to_be_bytes` instead
+
+error: use of the method `to_le_bytes`
+  --> $DIR/endian_bytes.rs:48:5
+   |
+LL |     2isize.to_le_bytes();
+   |     ^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use `to_be_bytes` instead
+
+error: use of the method `to_le_bytes`
+  --> $DIR/endian_bytes.rs:49:5
+   |
+LL |     2.0f32.to_le_bytes();
+   |     ^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use `to_be_bytes` instead
+
+error: use of the method `to_le_bytes`
+  --> $DIR/endian_bytes.rs:50:5
+   |
+LL |     2.0f64.to_le_bytes();
+   |     ^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use `to_be_bytes` instead
+
+error: use of the method `to_be_bytes`
+  --> $DIR/endian_bytes.rs:69:5
+   |
+LL |     2u8.to_be_bytes();
+   |     ^^^^^^^^^^^^^^^^^
+   |
+   = help: use `to_le_bytes` instead
+   = note: `-D clippy::big-endian-bytes` implied by `-D warnings`
+
+error: use of the method `to_be_bytes`
+  --> $DIR/endian_bytes.rs:70:5
+   |
+LL |     2i8.to_be_bytes();
+   |     ^^^^^^^^^^^^^^^^^
+   |
+   = help: use `to_le_bytes` instead
+
+error: use of the method `to_be_bytes`
+  --> $DIR/endian_bytes.rs:71:5
+   |
+LL |     2u16.to_be_bytes();
+   |     ^^^^^^^^^^^^^^^^^^
+   |
+   = help: use `to_le_bytes` instead
+
+error: use of the method `to_be_bytes`
+  --> $DIR/endian_bytes.rs:72:5
+   |
+LL |     2i16.to_be_bytes();
+   |     ^^^^^^^^^^^^^^^^^^
+   |
+   = help: use `to_le_bytes` instead
+
+error: use of the method `to_be_bytes`
+  --> $DIR/endian_bytes.rs:73:5
+   |
+LL |     2u32.to_be_bytes();
+   |     ^^^^^^^^^^^^^^^^^^
+   |
+   = help: use `to_le_bytes` instead
+
+error: use of the method `to_be_bytes`
+  --> $DIR/endian_bytes.rs:74:5
+   |
+LL |     2i32.to_be_bytes();
+   |     ^^^^^^^^^^^^^^^^^^
+   |
+   = help: use `to_le_bytes` instead
+
+error: use of the method `to_be_bytes`
+  --> $DIR/endian_bytes.rs:75:5
+   |
+LL |     2u64.to_be_bytes();
+   |     ^^^^^^^^^^^^^^^^^^
+   |
+   = help: use `to_le_bytes` instead
+
+error: use of the method `to_be_bytes`
+  --> $DIR/endian_bytes.rs:76:5
+   |
+LL |     2i64.to_be_bytes();
+   |     ^^^^^^^^^^^^^^^^^^
+   |
+   = help: use `to_le_bytes` instead
+
+error: use of the method `to_be_bytes`
+  --> $DIR/endian_bytes.rs:77:5
+   |
+LL |     2u128.to_be_bytes();
+   |     ^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use `to_le_bytes` instead
+
+error: use of the method `to_be_bytes`
+  --> $DIR/endian_bytes.rs:78:5
+   |
+LL |     2i128.to_be_bytes();
+   |     ^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use `to_le_bytes` instead
+
+error: use of the method `to_be_bytes`
+  --> $DIR/endian_bytes.rs:79:5
+   |
+LL |     2.0f32.to_be_bytes();
+   |     ^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use `to_le_bytes` instead
+
+error: use of the method `to_be_bytes`
+  --> $DIR/endian_bytes.rs:80:5
+   |
+LL |     2.0f64.to_be_bytes();
+   |     ^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use `to_le_bytes` instead
+
+error: use of the method `to_be_bytes`
+  --> $DIR/endian_bytes.rs:81:5
+   |
+LL |     2usize.to_be_bytes();
+   |     ^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use `to_le_bytes` instead
+
+error: use of the method `to_be_bytes`
+  --> $DIR/endian_bytes.rs:82:5
+   |
+LL |     2isize.to_be_bytes();
+   |     ^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use `to_le_bytes` instead
+
+error: use of the method `to_le_bytes`
+  --> $DIR/endian_bytes.rs:102:5
+   |
+LL |     2u8.to_le_bytes();
+   |     ^^^^^^^^^^^^^^^^^
+
+error: use of the method `to_le_bytes`
+  --> $DIR/endian_bytes.rs:103:5
+   |
+LL |     2i8.to_le_bytes();
+   |     ^^^^^^^^^^^^^^^^^
+
+error: use of the method `to_le_bytes`
+  --> $DIR/endian_bytes.rs:104:5
+   |
+LL |     2u16.to_le_bytes();
+   |     ^^^^^^^^^^^^^^^^^^
+
+error: use of the method `to_le_bytes`
+  --> $DIR/endian_bytes.rs:105:5
+   |
+LL |     2i16.to_le_bytes();
+   |     ^^^^^^^^^^^^^^^^^^
+
+error: use of the method `to_le_bytes`
+  --> $DIR/endian_bytes.rs:106:5
+   |
+LL |     2u32.to_le_bytes();
+   |     ^^^^^^^^^^^^^^^^^^
+
+error: use of the method `to_le_bytes`
+  --> $DIR/endian_bytes.rs:107:5
+   |
+LL |     2i32.to_le_bytes();
+   |     ^^^^^^^^^^^^^^^^^^
+
+error: use of the method `to_le_bytes`
+  --> $DIR/endian_bytes.rs:108:5
+   |
+LL |     2u64.to_le_bytes();
+   |     ^^^^^^^^^^^^^^^^^^
+
+error: use of the method `to_le_bytes`
+  --> $DIR/endian_bytes.rs:109:5
+   |
+LL |     2i64.to_le_bytes();
+   |     ^^^^^^^^^^^^^^^^^^
+
+error: use of the method `to_le_bytes`
+  --> $DIR/endian_bytes.rs:110:5
+   |
+LL |     2u128.to_le_bytes();
+   |     ^^^^^^^^^^^^^^^^^^^
+
+error: use of the method `to_le_bytes`
+  --> $DIR/endian_bytes.rs:111:5
+   |
+LL |     2i128.to_le_bytes();
+   |     ^^^^^^^^^^^^^^^^^^^
+
+error: use of the method `to_le_bytes`
+  --> $DIR/endian_bytes.rs:112:5
+   |
+LL |     2usize.to_le_bytes();
+   |     ^^^^^^^^^^^^^^^^^^^^
+
+error: use of the method `to_le_bytes`
+  --> $DIR/endian_bytes.rs:113:5
+   |
+LL |     2isize.to_le_bytes();
+   |     ^^^^^^^^^^^^^^^^^^^^
+
+error: use of the method `to_le_bytes`
+  --> $DIR/endian_bytes.rs:114:5
+   |
+LL |     2.0f32.to_le_bytes();
+   |     ^^^^^^^^^^^^^^^^^^^^
+
+error: use of the method `to_le_bytes`
+  --> $DIR/endian_bytes.rs:115:5
+   |
+LL |     2.0f64.to_le_bytes();
+   |     ^^^^^^^^^^^^^^^^^^^^
+
+error: use of the method `to_be_bytes`
+  --> $DIR/endian_bytes.rs:135:5
+   |
+LL |     2u8.to_be_bytes();
+   |     ^^^^^^^^^^^^^^^^^
+
+error: use of the method `to_be_bytes`
+  --> $DIR/endian_bytes.rs:136:5
+   |
+LL |     2i8.to_be_bytes();
+   |     ^^^^^^^^^^^^^^^^^
+
+error: use of the method `to_be_bytes`
+  --> $DIR/endian_bytes.rs:137:5
+   |
+LL |     2u16.to_be_bytes();
+   |     ^^^^^^^^^^^^^^^^^^
+
+error: use of the method `to_be_bytes`
+  --> $DIR/endian_bytes.rs:138:5
+   |
+LL |     2i16.to_be_bytes();
+   |     ^^^^^^^^^^^^^^^^^^
+
+error: use of the method `to_be_bytes`
+  --> $DIR/endian_bytes.rs:139:5
+   |
+LL |     2u32.to_be_bytes();
+   |     ^^^^^^^^^^^^^^^^^^
+
+error: use of the method `to_be_bytes`
+  --> $DIR/endian_bytes.rs:140:5
+   |
+LL |     2i32.to_be_bytes();
+   |     ^^^^^^^^^^^^^^^^^^
+
+error: use of the method `to_be_bytes`
+  --> $DIR/endian_bytes.rs:141:5
+   |
+LL |     2u64.to_be_bytes();
+   |     ^^^^^^^^^^^^^^^^^^
+
+error: use of the method `to_be_bytes`
+  --> $DIR/endian_bytes.rs:142:5
+   |
+LL |     2i64.to_be_bytes();
+   |     ^^^^^^^^^^^^^^^^^^
+
+error: use of the method `to_be_bytes`
+  --> $DIR/endian_bytes.rs:143:5
+   |
+LL |     2u128.to_be_bytes();
+   |     ^^^^^^^^^^^^^^^^^^^
+
+error: use of the method `to_be_bytes`
+  --> $DIR/endian_bytes.rs:144:5
+   |
+LL |     2i128.to_be_bytes();
+   |     ^^^^^^^^^^^^^^^^^^^
+
+error: use of the method `to_be_bytes`
+  --> $DIR/endian_bytes.rs:145:5
+   |
+LL |     2usize.to_be_bytes();
+   |     ^^^^^^^^^^^^^^^^^^^^
+
+error: use of the method `to_be_bytes`
+  --> $DIR/endian_bytes.rs:146:5
+   |
+LL |     2isize.to_be_bytes();
+   |     ^^^^^^^^^^^^^^^^^^^^
+
+error: use of the method `to_be_bytes`
+  --> $DIR/endian_bytes.rs:147:5
+   |
+LL |     2.0f32.to_be_bytes();
+   |     ^^^^^^^^^^^^^^^^^^^^
+
+error: use of the method `to_be_bytes`
+  --> $DIR/endian_bytes.rs:148:5
+   |
+LL |     2.0f64.to_be_bytes();
+   |     ^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 145 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 97a0ccc1d312ed763584c28b6d669cffba87c910 Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Thu, 25 May 2023 11:02:54 -0500
Subject: implement `host_endian_bytes` and the other two

---
 clippy_lints/src/endian_bytes.rs |  209 +++--
 tests/ui/endian_bytes.rs         |  260 +++---
 tests/ui/endian_bytes.stderr     | 1657 ++++++++++++++++++--------------------
 3 files changed, 1014 insertions(+), 1112 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/endian_bytes.rs b/clippy_lints/src/endian_bytes.rs
index bf6b92644e2..6486430cf57 100644
--- a/clippy_lints/src/endian_bytes.rs
+++ b/clippy_lints/src/endian_bytes.rs
@@ -1,23 +1,23 @@
-use clippy_utils::{
-    diagnostics::{span_lint_and_help, span_lint_and_then},
-    is_lint_allowed, match_def_path, path_def_id,
-};
+use crate::Lint;
+use clippy_utils::{diagnostics::span_lint_and_then, is_lint_allowed};
 use rustc_hir::{Expr, ExprKind};
-use rustc_lint::{LateContext, LateLintPass};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::Symbol;
+use std::borrow::Cow;
 
 declare_clippy_lint! {
     /// ### What it does
+    /// Checks for the usage of the `to_ne_bytes` method.
     ///
     /// ### Why is this bad?
+    /// It's not, but some may prefer to specify the target endianness explicitly.
     ///
     /// ### Example
-    /// ```rust
-    /// // example code where clippy issues a warning
-    /// ```
-    /// Use instead:
-    /// ```rust
-    /// // example code which does not raise clippy warning
+    /// ```rust,ignore
+    /// let _x = 2i32.to_ne_bytes();
+    /// let _y = 2i64.to_ne_bytes();
     /// ```
     #[clippy::version = "1.71.0"]
     pub HOST_ENDIAN_BYTES,
@@ -27,15 +27,16 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for the usage of the `to_ne_bytes` method.
+    /// Checks for the usage of the `to_le_bytes` method.
     ///
     /// ### Why is this bad?
-    /// It's not, but some may prefer to specify the target endianness explicitly.
+    /// It's not, but some may wish to lint usages of this method, either to suggest using the host
+    /// endianness or big endian.
     ///
     /// ### Example
     /// ```rust,ignore
-    /// let _x = 2i32.to_ne_bytes();
-    /// let _y = 2i64.to_ne_bytes();
+    /// let _x = 2i32.to_le_bytes();
+    /// let _y = 2i64.to_le_bytes();
     /// ```
     #[clippy::version = "1.71.0"]
     pub LITTLE_ENDIAN_BYTES,
@@ -45,13 +46,16 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for the usage of the `to_le_bytes` method.
+    /// Checks for the usage of the `to_be_bytes` method.
     ///
     /// ### Why is this bad?
+    /// It's not, but some may wish to lint usages of this method, either to suggest using the host
+    /// endianness or little endian.
     ///
     /// ### Example
     /// ```rust,ignore
-    /// // example code where clippy issues a warning
+    /// let _x = 2i32.to_be_bytes();
+    /// let _y = 2i64.to_be_bytes();
     /// ```
     #[clippy::version = "1.71.0"]
     pub BIG_ENDIAN_BYTES,
@@ -61,78 +65,133 @@ declare_clippy_lint! {
 
 declare_lint_pass!(EndianBytes => [HOST_ENDIAN_BYTES, LITTLE_ENDIAN_BYTES, BIG_ENDIAN_BYTES]);
 
+#[derive(Clone, Debug)]
+enum LintKind {
+    Host,
+    Little,
+    Big,
+}
+
+impl LintKind {
+    fn allowed(&self, cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+        is_lint_allowed(cx, self.as_lint(), expr.hir_id)
+    }
+
+    fn as_lint(&self) -> &'static Lint {
+        match self {
+            LintKind::Host => HOST_ENDIAN_BYTES,
+            LintKind::Little => LITTLE_ENDIAN_BYTES,
+            LintKind::Big => BIG_ENDIAN_BYTES,
+        }
+    }
+
+    fn to_name(&self, prefix: &str) -> String {
+        match self {
+            LintKind::Host => format!("{prefix}_ne_bytes"),
+            LintKind::Little => format!("{prefix}_le_bytes"),
+            LintKind::Big => format!("{prefix}_be_bytes"),
+        }
+    }
+}
+
 impl LateLintPass<'_> for EndianBytes {
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
+        if in_external_macro(cx.sess(), expr.span) {
+            return;
+        }
+
         if_chain! {
             if let ExprKind::MethodCall(method_name, receiver, args, ..) = expr.kind;
             if let ExprKind::Lit(..) = receiver.kind;
             if args.is_empty();
+            if try_lint_endian_bytes(cx, expr, "to", method_name.ident.name);
             then {
-                if method_name.ident.name == sym!(to_ne_bytes) {
-                    span_lint_and_help(
-                        cx,
-                        HOST_ENDIAN_BYTES,
-                        expr.span,
-                        "use of the method `to_ne_bytes`",
-                        None,
-                        "consider specifying the desired endianness",
-                    );
-                } else if method_name.ident.name == sym!(to_le_bytes) {
-                    span_lint_and_then(cx, LITTLE_ENDIAN_BYTES, expr.span, "use of the method `to_le_bytes`", |diag| {
-                        if is_lint_allowed(cx, BIG_ENDIAN_BYTES, expr.hir_id) {
-                            diag.help("use `to_be_bytes` instead");
-                        }
-                    });
-                } else if method_name.ident.name == sym!(to_be_bytes) {
-                    span_lint_and_then(cx, BIG_ENDIAN_BYTES, expr.span, "use of the method `to_be_bytes`", |diag| {
-                        if is_lint_allowed(cx, LITTLE_ENDIAN_BYTES, expr.hir_id) {
-                            diag.help("use `to_le_bytes` instead");
-                        }
-                    });
-                }
-
-                // don't waste time also checking from_**_bytes
                 return;
             }
         }
 
-        span_lint_and_help(
-            cx,
-            HOST_ENDIAN_BYTES,
-            expr.span,
-            "use of the method `from_ne_bytes`",
-            None,
-            &format!("consider specifying the desired endianness: {expr:?}"),
-        );
-
         if_chain! {
-            if let ExprKind::Call(function, args) = expr.kind;
-            if let Some(function_def_id) = path_def_id(cx, function);
-            if args.len() == 1;
+            if let ExprKind::Call(function, ..) = expr.kind;
+            if let ExprKind::Path(qpath) = function.kind;
+            if let Some(def_id) = cx.qpath_res(&qpath, function.hir_id).opt_def_id();
+            if let Some(function_name) = cx.get_def_path(def_id).last();
+            if cx.typeck_results().expr_ty(expr).is_primitive_ty();
             then {
-                if match_def_path(cx, function_def_id, &["from_ne_bytes"]) {
-                    span_lint_and_help(
-                        cx,
-                        HOST_ENDIAN_BYTES,
-                        expr.span,
-                        "use of the method `from_ne_bytes`",
-                        None,
-                        "consider specifying the desired endianness",
-                    );
-                } else if match_def_path(cx, function_def_id, &["from_le_bytes"]) {
-                    span_lint_and_then(cx, LITTLE_ENDIAN_BYTES, expr.span, "use of the method `from_le_bytes`", |diag| {
-                        if is_lint_allowed(cx, BIG_ENDIAN_BYTES, expr.hir_id) {
-                            diag.help("use `from_be_bytes` instead");
-                        }
-                    });
-                } else if match_def_path(cx, function_def_id, &["from_be_bytes"]) {
-                    span_lint_and_then(cx, BIG_ENDIAN_BYTES, expr.span, "use of the method `from_be_bytes`", |diag| {
-                        if is_lint_allowed(cx, LITTLE_ENDIAN_BYTES, expr.hir_id) {
-                            diag.help("use `from_le_bytes` instead");
-                        }
-                    });
-                }
+                try_lint_endian_bytes(cx, expr, "from", *function_name);
+            }
+        }
+    }
+}
+
+fn try_lint_endian_bytes(cx: &LateContext<'_>, expr: &Expr<'_>, prefix: &str, name: Symbol) -> bool {
+    let ne = format!("{prefix}_ne_bytes");
+    let le = format!("{prefix}_le_bytes");
+    let be = format!("{prefix}_be_bytes");
+
+    let (lint, other_lints) = match name.as_str() {
+        name if name == ne => ((&LintKind::Host), [(&LintKind::Little), (&LintKind::Big)]),
+        name if name == le => ((&LintKind::Little), [(&LintKind::Host), (&LintKind::Big)]),
+        name if name == be => ((&LintKind::Big), [(&LintKind::Host), (&LintKind::Little)]),
+        _ => return false,
+    };
+
+    let mut help = None;
+
+    'build_help: {
+        // all lints disallowed, don't give help here
+        if [&[lint], other_lints.as_slice()]
+            .concat()
+            .iter()
+            .all(|lint| !lint.allowed(cx, expr))
+        {
+            break 'build_help;
+        }
+
+        // ne_bytes and all other lints allowed
+        if lint.to_name(prefix) == ne && other_lints.iter().all(|lint| lint.allowed(cx, expr)) {
+            help = Some(Cow::Borrowed("specify the desired endianness explicitly"));
+            break 'build_help;
+        }
+
+        // le_bytes where ne_bytes allowed but be_bytes is not, or le_bytes where ne_bytes allowed but
+        // le_bytes is not
+        if (lint.to_name(prefix) == le || lint.to_name(prefix) == be) && LintKind::Host.allowed(cx, expr) {
+            help = Some(Cow::Borrowed("use the native endianness instead"));
+            break 'build_help;
+        }
+
+        let allowed_lints = other_lints.iter().filter(|lint| lint.allowed(cx, expr));
+        let len = allowed_lints.clone().count();
+
+        let mut help_str = "use ".to_owned();
+
+        for (i, lint) in allowed_lints.enumerate() {
+            let only_one = len == 1;
+            if !only_one {
+                help_str.push_str("either of ");
+            }
+
+            help_str.push_str(&format!("`{}` ", lint.to_name(prefix)));
+
+            if i != len && !only_one {
+                help_str.push_str("or ");
             }
         }
+
+        help = Some(Cow::Owned(help_str + "instead"));
     }
+
+    span_lint_and_then(
+        cx,
+        lint.as_lint(),
+        expr.span,
+        &format!("usage of the method `{}`", lint.to_name(prefix)),
+        move |diag| {
+            if let Some(help) = help {
+                diag.help(help);
+            }
+        },
+    );
+
+    true
 }
diff --git a/tests/ui/endian_bytes.rs b/tests/ui/endian_bytes.rs
index 1dfda9d53bf..ccee8e20a3c 100644
--- a/tests/ui/endian_bytes.rs
+++ b/tests/ui/endian_bytes.rs
@@ -2,162 +2,126 @@
 #![allow(clippy::diverging_sub_expression)]
 #![no_main]
 
-#[warn(clippy::host_endian_bytes)]
-fn host() {
-    2u8.to_ne_bytes();
-    2i8.to_ne_bytes();
-    2u16.to_ne_bytes();
-    2i16.to_ne_bytes();
-    2u32.to_ne_bytes();
-    2i32.to_ne_bytes();
-    2u64.to_ne_bytes();
-    2i64.to_ne_bytes();
-    2u128.to_ne_bytes();
-    2i128.to_ne_bytes();
-    2usize.to_ne_bytes();
-    2isize.to_ne_bytes();
-    2.0f32.to_ne_bytes();
-    2.0f64.to_ne_bytes();
-    u8::from_ne_bytes(todo!());
-    i8::from_ne_bytes(todo!());
-    u16::from_ne_bytes(todo!());
-    i16::from_ne_bytes(todo!());
-    u32::from_ne_bytes(todo!());
-    i32::from_ne_bytes(todo!());
-    u64::from_ne_bytes(todo!());
-    i64::from_ne_bytes(todo!());
-    u128::from_ne_bytes(todo!());
-    i128::from_ne_bytes(todo!());
-    f32::from_ne_bytes(todo!());
-    f64::from_ne_bytes(todo!());
+macro_rules! fn_body {
+    () => {
+        2u8.to_ne_bytes();
+        2i8.to_ne_bytes();
+        2u16.to_ne_bytes();
+        2i16.to_ne_bytes();
+        2u32.to_ne_bytes();
+        2i32.to_ne_bytes();
+        2u64.to_ne_bytes();
+        2i64.to_ne_bytes();
+        2u128.to_ne_bytes();
+        2i128.to_ne_bytes();
+        2.0f32.to_ne_bytes();
+        2.0f64.to_ne_bytes();
+        2usize.to_ne_bytes();
+        2isize.to_ne_bytes();
+        u8::from_ne_bytes(todo!());
+        i8::from_ne_bytes(todo!());
+        u16::from_ne_bytes(todo!());
+        i16::from_ne_bytes(todo!());
+        u32::from_ne_bytes(todo!());
+        i32::from_ne_bytes(todo!());
+        u64::from_ne_bytes(todo!());
+        i64::from_ne_bytes(todo!());
+        u128::from_ne_bytes(todo!());
+        i128::from_ne_bytes(todo!());
+        usize::from_ne_bytes(todo!());
+        isize::from_ne_bytes(todo!());
+        f32::from_ne_bytes(todo!());
+        f64::from_ne_bytes(todo!());
+
+        2u8.to_le_bytes();
+        2i8.to_le_bytes();
+        2u16.to_le_bytes();
+        2i16.to_le_bytes();
+        2u32.to_le_bytes();
+        2i32.to_le_bytes();
+        2u64.to_le_bytes();
+        2i64.to_le_bytes();
+        2u128.to_le_bytes();
+        2i128.to_le_bytes();
+        2.0f32.to_le_bytes();
+        2.0f64.to_le_bytes();
+        2usize.to_le_bytes();
+        2isize.to_le_bytes();
+        u8::from_le_bytes(todo!());
+        i8::from_le_bytes(todo!());
+        u16::from_le_bytes(todo!());
+        i16::from_le_bytes(todo!());
+        u32::from_le_bytes(todo!());
+        i32::from_le_bytes(todo!());
+        u64::from_le_bytes(todo!());
+        i64::from_le_bytes(todo!());
+        u128::from_le_bytes(todo!());
+        i128::from_le_bytes(todo!());
+        usize::from_le_bytes(todo!());
+        isize::from_le_bytes(todo!());
+        f32::from_le_bytes(todo!());
+        f64::from_le_bytes(todo!());
+    };
 }
 
-#[warn(clippy::little_endian_bytes)]
-fn little() {
-    2u8.to_le_bytes();
-    2i8.to_le_bytes();
-    2u16.to_le_bytes();
-    2i16.to_le_bytes();
-    2u32.to_le_bytes();
-    2i32.to_le_bytes();
-    2u64.to_le_bytes();
-    2i64.to_le_bytes();
-    2u128.to_le_bytes();
-    2i128.to_le_bytes();
-    2usize.to_le_bytes();
-    2isize.to_le_bytes();
-    2.0f32.to_le_bytes();
-    2.0f64.to_le_bytes();
-    u8::from_le_bytes(todo!());
-    i8::from_le_bytes(todo!());
-    u16::from_le_bytes(todo!());
-    i16::from_le_bytes(todo!());
-    u32::from_le_bytes(todo!());
-    i32::from_le_bytes(todo!());
-    u64::from_le_bytes(todo!());
-    i64::from_le_bytes(todo!());
-    u128::from_le_bytes(todo!());
-    i128::from_le_bytes(todo!());
-    usize::from_le_bytes(todo!());
-    isize::from_le_bytes(todo!());
-    f32::from_le_bytes(todo!());
-    f64::from_le_bytes(todo!());
+// bless breaks if I use fn_body too much (oops)
+macro_rules! fn_body_small {
+    () => {
+        2u8.to_ne_bytes();
+        u8::from_ne_bytes(todo!());
+
+        2u8.to_le_bytes();
+        u8::from_le_bytes(todo!());
+
+        2u8.to_be_bytes();
+        u8::from_be_bytes(todo!());
+    };
 }
 
+#[rustfmt::skip]
+#[warn(clippy::host_endian_bytes)]
+fn host() { fn_body!(); }
+
+#[rustfmt::skip]
+#[warn(clippy::little_endian_bytes)]
+fn little() { fn_body!(); }
+
+#[rustfmt::skip]
 #[warn(clippy::big_endian_bytes)]
-fn big() {
-    2u8.to_be_bytes();
-    2i8.to_be_bytes();
-    2u16.to_be_bytes();
-    2i16.to_be_bytes();
-    2u32.to_be_bytes();
-    2i32.to_be_bytes();
-    2u64.to_be_bytes();
-    2i64.to_be_bytes();
-    2u128.to_be_bytes();
-    2i128.to_be_bytes();
-    2.0f32.to_be_bytes();
-    2.0f64.to_be_bytes();
-    2usize.to_be_bytes();
-    2isize.to_be_bytes();
-    u8::from_be_bytes(todo!());
-    i8::from_be_bytes(todo!());
-    u16::from_be_bytes(todo!());
-    i16::from_be_bytes(todo!());
-    u32::from_be_bytes(todo!());
-    i32::from_be_bytes(todo!());
-    u64::from_be_bytes(todo!());
-    i64::from_be_bytes(todo!());
-    u128::from_be_bytes(todo!());
-    i128::from_be_bytes(todo!());
-    usize::from_be_bytes(todo!());
-    isize::from_be_bytes(todo!());
-    f32::from_be_bytes(todo!());
-    f64::from_be_bytes(todo!());
-}
+fn big() { fn_body!(); }
+
+#[rustfmt::skip]
+#[warn(clippy::host_endian_bytes)]
+#[warn(clippy::big_endian_bytes)]
+fn host_encourage_little() { fn_body_small!(); }
+
+#[rustfmt::skip]
+#[warn(clippy::host_endian_bytes)]
+#[warn(clippy::little_endian_bytes)]
+fn host_encourage_big() { fn_body_small!(); }
 
+#[rustfmt::skip]
+#[warn(clippy::host_endian_bytes)]
 #[warn(clippy::little_endian_bytes)]
 #[warn(clippy::big_endian_bytes)]
-fn little_no_help() {
-    2u8.to_le_bytes();
-    2i8.to_le_bytes();
-    2u16.to_le_bytes();
-    2i16.to_le_bytes();
-    2u32.to_le_bytes();
-    2i32.to_le_bytes();
-    2u64.to_le_bytes();
-    2i64.to_le_bytes();
-    2u128.to_le_bytes();
-    2i128.to_le_bytes();
-    2usize.to_le_bytes();
-    2isize.to_le_bytes();
-    2.0f32.to_le_bytes();
-    2.0f64.to_le_bytes();
-    u8::from_le_bytes(todo!());
-    i8::from_le_bytes(todo!());
-    u16::from_le_bytes(todo!());
-    i16::from_le_bytes(todo!());
-    u32::from_le_bytes(todo!());
-    i32::from_le_bytes(todo!());
-    u64::from_le_bytes(todo!());
-    i64::from_le_bytes(todo!());
-    u128::from_le_bytes(todo!());
-    i128::from_le_bytes(todo!());
-    usize::from_le_bytes(todo!());
-    isize::from_le_bytes(todo!());
-    f32::from_le_bytes(todo!());
-    f64::from_le_bytes(todo!());
-}
+fn no_help() { fn_body_small!(); }
+
+#[rustfmt::skip]
+#[warn(clippy::little_endian_bytes)]
+#[warn(clippy::big_endian_bytes)]
+fn little_encourage_host() { fn_body_small!(); }
 
+#[rustfmt::skip]
+#[warn(clippy::host_endian_bytes)]
+#[warn(clippy::little_endian_bytes)]
+fn little_encourage_big() { fn_body_small!(); }
+
+#[rustfmt::skip]
 #[warn(clippy::big_endian_bytes)]
 #[warn(clippy::little_endian_bytes)]
-fn big_no_help() {
-    2u8.to_be_bytes();
-    2i8.to_be_bytes();
-    2u16.to_be_bytes();
-    2i16.to_be_bytes();
-    2u32.to_be_bytes();
-    2i32.to_be_bytes();
-    2u64.to_be_bytes();
-    2i64.to_be_bytes();
-    2u128.to_be_bytes();
-    2i128.to_be_bytes();
-    2usize.to_be_bytes();
-    2isize.to_be_bytes();
-    2.0f32.to_be_bytes();
-    2.0f64.to_be_bytes();
-    u8::from_be_bytes(todo!());
-    i8::from_be_bytes(todo!());
-    u16::from_be_bytes(todo!());
-    i16::from_be_bytes(todo!());
-    u32::from_be_bytes(todo!());
-    i32::from_be_bytes(todo!());
-    u64::from_be_bytes(todo!());
-    i64::from_be_bytes(todo!());
-    u128::from_be_bytes(todo!());
-    i128::from_be_bytes(todo!());
-    usize::from_be_bytes(todo!());
-    isize::from_be_bytes(todo!());
-    f32::from_be_bytes(todo!());
-    f64::from_be_bytes(todo!());
-}
+fn big_encourage_host() { fn_body_small!(); }
+
+#[rustfmt::skip]
+#[warn(clippy::host_endian_bytes)]
+#[warn(clippy::big_endian_bytes)]
+fn big_encourage_little() { fn_body_small!(); }
diff --git a/tests/ui/endian_bytes.stderr b/tests/ui/endian_bytes.stderr
index afbb8e3b16c..ff8d1a98f4f 100644
--- a/tests/ui/endian_bytes.stderr
+++ b/tests/ui/endian_bytes.stderr
@@ -1,1152 +1,1031 @@
-error: use of the method `from_ne_bytes`
-  --> $DIR/endian_bytes.rs:6:11
-   |
-LL |   fn host() {
-   |  ___________^
-LL | |     2u8.to_ne_bytes();
-LL | |     2i8.to_ne_bytes();
-LL | |     2u16.to_ne_bytes();
-...  |
-LL | |     f64::from_ne_bytes(todo!());
-LL | | }
-   | |_^
-   |
-   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).202), kind: Block(Block { stmts: [Stmt { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).4), kind: Semi(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).1), kind: MethodCall(PathSegment { ident: to_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).2), res: Err, args: None, infer_args: true }, Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).3), kind: Lit(Spanned { node: Int(2, Unsigned(U8)), span: $DIR/endian_bytes.rs:7:5: 7:8 (#0) }), span: $DIR/endian_bytes.rs:7:5: 7:8 (#0) }, [], $DIR/endian_bytes.rs:7:9: 7:22 (#0)), span: $DIR/endian_bytes.rs:7:5: 7:22 (#0) }), span: $DIR/endian_bytes.rs:7:5: 7:23 (#0) }, Stmt { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).8), kind: Semi(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).5), kind: MethodCall(PathSegment { ident: to_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).6), res: Err, args: None, infer_args: true }, Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).7), kind: Lit(Spanned { node: Int(2, Signed(I8)), span: $DIR/endian_bytes.rs:8:5: 8:8 (#0) }), span: $DIR/endian_bytes.rs:8:5: 8:8 (#0) }, [], $DIR/endian_bytes.rs:8:9: 8:22 (#0)), span: $DIR/endian_bytes.rs:8:5: 8:22 (#0) }), span: $DIR/endian_bytes.rs:8:5: 8:23 (#0) }, Stmt { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).12), kind: Semi(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).9), kind: MethodCall(PathSegment { ident: to_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).10), res: Err, args: None, infer_args: true }, Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).11), kind: Lit(Spanned { node: Int(2, Unsigned(U16)), span: $DIR/endian_bytes.rs:9:5: 9:9 (#0) }), span: $DIR/endian_bytes.rs:9:5: 9:9 (#0) }, [], $DIR/endian_bytes.rs:9:10: 9:23 (#0)), span: $DIR/endian_bytes.rs:9:5: 9:23 (#0) }), span: $DIR/endian_bytes.rs:9:5: 9:24 (#0) }, Stmt { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).16), kind: Semi(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).13), kind: MethodCall(PathSegment { ident: to_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).14), res: Err, args: None, infer_args: true }, Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).15), kind: Lit(Spanned { node: Int(2, Signed(I16)), span: $DIR/endian_bytes.rs:10:5: 10:9 (#0) }), span: $DIR/endian_bytes.rs:10:5: 10:9 (#0) }, [], $DIR/endian_bytes.rs:10:10: 10:23 (#0)), span: $DIR/endian_bytes.rs:10:5: 10:23 (#0) }), span: $DIR/endian_bytes.rs:10:5: 10:24 (#0) }, Stmt { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).20), kind: Semi(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).17), kind: MethodCall(PathSegment { ident: to_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).18), res: Err, args: None, infer_args: true }, Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).19), kind: Lit(Spanned { node: Int(2, Unsigned(U32)), span: $DIR/endian_bytes.rs:11:5: 11:9 (#0) }), span: $DIR/endian_bytes.rs:11:5: 11:9 (#0) }, [], $DIR/endian_bytes.rs:11:10: 11:23 (#0)), span: $DIR/endian_bytes.rs:11:5: 11:23 (#0) }), span: $DIR/endian_bytes.rs:11:5: 11:24 (#0) }, Stmt { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).24), kind: Semi(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).21), kind: MethodCall(PathSegment { ident: to_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).22), res: Err, args: None, infer_args: true }, Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).23), kind: Lit(Spanned { node: Int(2, Signed(I32)), span: $DIR/endian_bytes.rs:12:5: 12:9 (#0) }), span: $DIR/endian_bytes.rs:12:5: 12:9 (#0) }, [], $DIR/endian_bytes.rs:12:10: 12:23 (#0)), span: $DIR/endian_bytes.rs:12:5: 12:23 (#0) }), span: $DIR/endian_bytes.rs:12:5: 12:24 (#0) }, Stmt { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).28), kind: Semi(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).25), kind: MethodCall(PathSegment { ident: to_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).26), res: Err, args: None, infer_args: true }, Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).27), kind: Lit(Spanned { node: Int(2, Unsigned(U64)), span: $DIR/endian_bytes.rs:13:5: 13:9 (#0) }), span: $DIR/endian_bytes.rs:13:5: 13:9 (#0) }, [], $DIR/endian_bytes.rs:13:10: 13:23 (#0)), span: $DIR/endian_bytes.rs:13:5: 13:23 (#0) }), span: $DIR/endian_bytes.rs:13:5: 13:24 (#0) }, Stmt { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).32), kind: Semi(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).29), kind: MethodCall(PathSegment { ident: to_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).30), res: Err, args: None, infer_args: true }, Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).31), kind: Lit(Spanned { node: Int(2, Signed(I64)), span: $DIR/endian_bytes.rs:14:5: 14:9 (#0) }), span: $DIR/endian_bytes.rs:14:5: 14:9 (#0) }, [], $DIR/endian_bytes.rs:14:10: 14:23 (#0)), span: $DIR/endian_bytes.rs:14:5: 14:23 (#0) }), span: $DIR/endian_bytes.rs:14:5: 14:24 (#0) }, Stmt { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).36), kind: Semi(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).33), kind: MethodCall(PathSegment { ident: to_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).34), res: Err, args: None, infer_args: true }, Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).35), kind: Lit(Spanned { node: Int(2, Unsigned(U128)), span: $DIR/endian_bytes.rs:15:5: 15:10 (#0) }), span: $DIR/endian_bytes.rs:15:5: 15:10 (#0) }, [], $DIR/endian_bytes.rs:15:11: 15:24 (#0)), span: $DIR/endian_bytes.rs:15:5: 15:24 (#0) }), span: $DIR/endian_bytes.rs:15:5: 15:25 (#0) }, Stmt { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).40), kind: Semi(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).37), kind: MethodCall(PathSegment { ident: to_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).38), res: Err, args: None, infer_args: true }, Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).39), kind: Lit(Spanned { node: Int(2, Signed(I128)), span: $DIR/endian_bytes.rs:16:5: 16:10 (#0) }), span: $DIR/endian_bytes.rs:16:5: 16:10 (#0) }, [], $DIR/endian_bytes.rs:16:11: 16:24 (#0)), span: $DIR/endian_bytes.rs:16:5: 16:24 (#0) }), span: $DIR/endian_bytes.rs:16:5: 16:25 (#0) }, Stmt { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).44), kind: Semi(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).41), kind: MethodCall(PathSegment { ident: to_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).42), res: Err, args: None, infer_args: true }, Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).43), kind: Lit(Spanned { node: Int(2, Unsigned(Usize)), span: $DIR/endian_bytes.rs:17:5: 17:11 (#0) }), span: $DIR/endian_bytes.rs:17:5: 17:11 (#0) }, [], $DIR/endian_bytes.rs:17:12: 17:25 (#0)), span: $DIR/endian_bytes.rs:17:5: 17:25 (#0) }), span: $DIR/endian_bytes.rs:17:5: 17:26 (#0) }, Stmt { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).48), kind: Semi(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).45), kind: MethodCall(PathSegment { ident: to_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).46), res: Err, args: None, infer_args: true }, Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).47), kind: Lit(Spanned { node: Int(2, Signed(Isize)), span: $DIR/endian_bytes.rs:18:5: 18:11 (#0) }), span: $DIR/endian_bytes.rs:18:5: 18:11 (#0) }, [], $DIR/endian_bytes.rs:18:12: 18:25 (#0)), span: $DIR/endian_bytes.rs:18:5: 18:25 (#0) }), span: $DIR/endian_bytes.rs:18:5: 18:26 (#0) }, Stmt { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).52), kind: Semi(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).49), kind: MethodCall(PathSegment { ident: to_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).50), res: Err, args: None, infer_args: true }, Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).51), kind: Lit(Spanned { node: Float("2.0", Suffixed(F32)), span: $DIR/endian_bytes.rs:19:5: 19:11 (#0) }), span: $DIR/endian_bytes.rs:19:5: 19:11 (#0) }, [], $DIR/endian_bytes.rs:19:12: 19:25 (#0)), span: $DIR/endian_bytes.rs:19:5: 19:25 (#0) }), span: $DIR/endian_bytes.rs:19:5: 19:26 (#0) }, Stmt { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).56), kind: Semi(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).53), kind: MethodCall(PathSegment { ident: to_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).54), res: Err, args: None, infer_args: true }, Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).55), kind: Lit(Spanned { node: Float("2.0", Suffixed(F64)), span: $DIR/endian_bytes.rs:20:5: 20:11 (#0) }), span: $DIR/endian_bytes.rs:20:5: 20:11 (#0) }, [], $DIR/endian_bytes.rs:20:12: 20:25 (#0)), span: $DIR/endian_bytes.rs:20:5: 20:25 (#0) }), span: $DIR/endian_bytes.rs:20:5: 20:26 (#0) }, Stmt { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).68), kind: Semi(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).57), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).58), kind: Path(TypeRelative(Ty { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).60), kind: Path(Resolved(None, Path { span: $DIR/endian_bytes.rs:21:5: 21:7 (#0), res: PrimTy(Uint(U8)), segments: [PathSegment { ident: u8#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).59), res: PrimTy(Uint(U8)), args: None, infer_args: true }] })), span: $DIR/endian_bytes.rs:21:5: 21:7 (#0) }, PathSegment { ident: from_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).61), res: Err, args: None, infer_args: true })), span: $DIR/endian_bytes.rs:21:5: 21:22 (#0) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).62), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).63), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#4), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#4, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).64), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#4, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).65), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#4, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).66), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#4) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).67), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#4) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#4) }]), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:56 (#4) }]), span: $DIR/endian_bytes.rs:21:5: 21:31 (#0) }), span: $DIR/endian_bytes.rs:21:5: 21:32 (#0) }, Stmt { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).80), kind: Semi(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).69), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).70), kind: Path(TypeRelative(Ty { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).72), kind: Path(Resolved(None, Path { span: $DIR/endian_bytes.rs:22:5: 22:7 (#0), res: PrimTy(Int(I8)), segments: [PathSegment { ident: i8#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).71), res: PrimTy(Int(I8)), args: None, infer_args: true }] })), span: $DIR/endian_bytes.rs:22:5: 22:7 (#0) }, PathSegment { ident: from_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).73), res: Err, args: None, infer_args: true })), span: $DIR/endian_bytes.rs:22:5: 22:22 (#0) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).74), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).75), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#5), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#5, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).76), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#5, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).77), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#5, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).78), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#5) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).79), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#5) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#5) }]), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:56 (#5) }]), span: $DIR/endian_bytes.rs:22:5: 22:31 (#0) }), span: $DIR/endian_bytes.rs:22:5: 22:32 (#0) }, Stmt { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).92), kind: Semi(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).81), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).82), kind: Path(TypeRelative(Ty { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).84), kind: Path(Resolved(None, Path { span: $DIR/endian_bytes.rs:23:5: 23:8 (#0), res: PrimTy(Uint(U16)), segments: [PathSegment { ident: u16#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).83), res: PrimTy(Uint(U16)), args: None, infer_args: true }] })), span: $DIR/endian_bytes.rs:23:5: 23:8 (#0) }, PathSegment { ident: from_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).85), res: Err, args: None, infer_args: true })), span: $DIR/endian_bytes.rs:23:5: 23:23 (#0) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).86), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).87), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#6), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#6, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).88), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#6, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).89), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#6, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).90), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#6) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).91), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#6) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#6) }]), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:56 (#6) }]), span: $DIR/endian_bytes.rs:23:5: 23:32 (#0) }), span: $DIR/endian_bytes.rs:23:5: 23:33 (#0) }, Stmt { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).104), kind: Semi(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).93), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).94), kind: Path(TypeRelative(Ty { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).96), kind: Path(Resolved(None, Path { span: $DIR/endian_bytes.rs:24:5: 24:8 (#0), res: PrimTy(Int(I16)), segments: [PathSegment { ident: i16#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).95), res: PrimTy(Int(I16)), args: None, infer_args: true }] })), span: $DIR/endian_bytes.rs:24:5: 24:8 (#0) }, PathSegment { ident: from_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).97), res: Err, args: None, infer_args: true })), span: $DIR/endian_bytes.rs:24:5: 24:23 (#0) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).98), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).99), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#7), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#7, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).100), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#7, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).101), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#7, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).102), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#7) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).103), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#7) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#7) }]), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:56 (#7) }]), span: $DIR/endian_bytes.rs:24:5: 24:32 (#0) }), span: $DIR/endian_bytes.rs:24:5: 24:33 (#0) }, Stmt { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).116), kind: Semi(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).105), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).106), kind: Path(TypeRelative(Ty { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).108), kind: Path(Resolved(None, Path { span: $DIR/endian_bytes.rs:25:5: 25:8 (#0), res: PrimTy(Uint(U32)), segments: [PathSegment { ident: u32#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).107), res: PrimTy(Uint(U32)), args: None, infer_args: true }] })), span: $DIR/endian_bytes.rs:25:5: 25:8 (#0) }, PathSegment { ident: from_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).109), res: Err, args: None, infer_args: true })), span: $DIR/endian_bytes.rs:25:5: 25:23 (#0) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).110), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).111), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#8), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#8, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).112), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#8, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).113), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#8, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).114), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#8) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).115), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#8) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#8) }]), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:56 (#8) }]), span: $DIR/endian_bytes.rs:25:5: 25:32 (#0) }), span: $DIR/endian_bytes.rs:25:5: 25:33 (#0) }, Stmt { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).128), kind: Semi(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).117), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).118), kind: Path(TypeRelative(Ty { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).120), kind: Path(Resolved(None, Path { span: $DIR/endian_bytes.rs:26:5: 26:8 (#0), res: PrimTy(Int(I32)), segments: [PathSegment { ident: i32#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).119), res: PrimTy(Int(I32)), args: None, infer_args: true }] })), span: $DIR/endian_bytes.rs:26:5: 26:8 (#0) }, PathSegment { ident: from_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).121), res: Err, args: None, infer_args: true })), span: $DIR/endian_bytes.rs:26:5: 26:23 (#0) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).122), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).123), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#9), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#9, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).124), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#9, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).125), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#9, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).126), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#9) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).127), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#9) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#9) }]), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:56 (#9) }]), span: $DIR/endian_bytes.rs:26:5: 26:32 (#0) }), span: $DIR/endian_bytes.rs:26:5: 26:33 (#0) }, Stmt { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).140), kind: Semi(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).129), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).130), kind: Path(TypeRelative(Ty { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).132), kind: Path(Resolved(None, Path { span: $DIR/endian_bytes.rs:27:5: 27:8 (#0), res: PrimTy(Uint(U64)), segments: [PathSegment { ident: u64#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).131), res: PrimTy(Uint(U64)), args: None, infer_args: true }] })), span: $DIR/endian_bytes.rs:27:5: 27:8 (#0) }, PathSegment { ident: from_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).133), res: Err, args: None, infer_args: true })), span: $DIR/endian_bytes.rs:27:5: 27:23 (#0) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).134), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).135), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#10), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#10, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).136), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#10, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).137), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#10, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).138), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#10) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).139), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#10) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#10) }]), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:56 (#10) }]), span: $DIR/endian_bytes.rs:27:5: 27:32 (#0) }), span: $DIR/endian_bytes.rs:27:5: 27:33 (#0) }, Stmt { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).152), kind: Semi(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).141), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).142), kind: Path(TypeRelative(Ty { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).144), kind: Path(Resolved(None, Path { span: $DIR/endian_bytes.rs:28:5: 28:8 (#0), res: PrimTy(Int(I64)), segments: [PathSegment { ident: i64#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).143), res: PrimTy(Int(I64)), args: None, infer_args: true }] })), span: $DIR/endian_bytes.rs:28:5: 28:8 (#0) }, PathSegment { ident: from_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).145), res: Err, args: None, infer_args: true })), span: $DIR/endian_bytes.rs:28:5: 28:23 (#0) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).146), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).147), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#11), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#11, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).148), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#11, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).149), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#11, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).150), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#11) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).151), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#11) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#11) }]), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:56 (#11) }]), span: $DIR/endian_bytes.rs:28:5: 28:32 (#0) }), span: $DIR/endian_bytes.rs:28:5: 28:33 (#0) }, Stmt { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).164), kind: Semi(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).153), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).154), kind: Path(TypeRelative(Ty { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).156), kind: Path(Resolved(None, Path { span: $DIR/endian_bytes.rs:29:5: 29:9 (#0), res: PrimTy(Uint(U128)), segments: [PathSegment { ident: u128#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).155), res: PrimTy(Uint(U128)), args: None, infer_args: true }] })), span: $DIR/endian_bytes.rs:29:5: 29:9 (#0) }, PathSegment { ident: from_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).157), res: Err, args: None, infer_args: true })), span: $DIR/endian_bytes.rs:29:5: 29:24 (#0) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).158), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).159), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#12), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#12, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).160), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#12, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).161), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#12, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).162), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#12) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).163), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#12) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#12) }]), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:56 (#12) }]), span: $DIR/endian_bytes.rs:29:5: 29:33 (#0) }), span: $DIR/endian_bytes.rs:29:5: 29:34 (#0) }, Stmt { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).176), kind: Semi(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).165), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).166), kind: Path(TypeRelative(Ty { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).168), kind: Path(Resolved(None, Path { span: $DIR/endian_bytes.rs:30:5: 30:9 (#0), res: PrimTy(Int(I128)), segments: [PathSegment { ident: i128#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).167), res: PrimTy(Int(I128)), args: None, infer_args: true }] })), span: $DIR/endian_bytes.rs:30:5: 30:9 (#0) }, PathSegment { ident: from_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).169), res: Err, args: None, infer_args: true })), span: $DIR/endian_bytes.rs:30:5: 30:24 (#0) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).170), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).171), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#13), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#13, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).172), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#13, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).173), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#13, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).174), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#13) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).175), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#13) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#13) }]), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:56 (#13) }]), span: $DIR/endian_bytes.rs:30:5: 30:33 (#0) }), span: $DIR/endian_bytes.rs:30:5: 30:34 (#0) }, Stmt { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).188), kind: Semi(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).177), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).178), kind: Path(TypeRelative(Ty { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).180), kind: Path(Resolved(None, Path { span: $DIR/endian_bytes.rs:31:5: 31:8 (#0), res: PrimTy(Float(F32)), segments: [PathSegment { ident: f32#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).179), res: PrimTy(Float(F32)), args: None, infer_args: true }] })), span: $DIR/endian_bytes.rs:31:5: 31:8 (#0) }, PathSegment { ident: from_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).181), res: Err, args: None, infer_args: true })), span: $DIR/endian_bytes.rs:31:5: 31:23 (#0) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).182), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).183), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#14), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#14, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).184), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#14, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).185), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#14, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).186), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#14) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).187), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#14) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#14) }]), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:56 (#14) }]), span: $DIR/endian_bytes.rs:31:5: 31:32 (#0) }), span: $DIR/endian_bytes.rs:31:5: 31:33 (#0) }, Stmt { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).200), kind: Semi(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).189), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).190), kind: Path(TypeRelative(Ty { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).192), kind: Path(Resolved(None, Path { span: $DIR/endian_bytes.rs:32:5: 32:8 (#0), res: PrimTy(Float(F64)), segments: [PathSegment { ident: f64#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).191), res: PrimTy(Float(F64)), args: None, infer_args: true }] })), span: $DIR/endian_bytes.rs:32:5: 32:8 (#0) }, PathSegment { ident: from_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).193), res: Err, args: None, infer_args: true })), span: $DIR/endian_bytes.rs:32:5: 32:23 (#0) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).194), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).195), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#15), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#15, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).196), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#15, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).197), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#15, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).198), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#15) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).199), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#15) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#15) }]), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:56 (#15) }]), span: $DIR/endian_bytes.rs:32:5: 32:32 (#0) }), span: $DIR/endian_bytes.rs:32:5: 32:33 (#0) }], expr: None, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).201), rules: DefaultBlock, span: $DIR/endian_bytes.rs:6:11: 33:2 (#0), targeted_by_break: false }, None), span: $DIR/endian_bytes.rs:6:11: 33:2 (#0) }
-   = note: `-D clippy::host-endian-bytes` implied by `-D warnings`
-
-error: use of the method `to_ne_bytes`
-  --> $DIR/endian_bytes.rs:7:5
-   |
-LL |     2u8.to_ne_bytes();
-   |     ^^^^^^^^^^^^^^^^^
-   |
-   = help: consider specifying the desired endianness
-
-error: use of the method `from_ne_bytes`
-  --> $DIR/endian_bytes.rs:7:5
-   |
-LL |     2u8.to_ne_bytes();
-   |     ^^^
-   |
-   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).3), kind: Lit(Spanned { node: Int(2, Unsigned(U8)), span: $DIR/endian_bytes.rs:7:5: 7:8 (#0) }), span: $DIR/endian_bytes.rs:7:5: 7:8 (#0) }
-
-error: use of the method `to_ne_bytes`
-  --> $DIR/endian_bytes.rs:8:5
-   |
-LL |     2i8.to_ne_bytes();
-   |     ^^^^^^^^^^^^^^^^^
-   |
-   = help: consider specifying the desired endianness
-
-error: use of the method `from_ne_bytes`
-  --> $DIR/endian_bytes.rs:8:5
-   |
-LL |     2i8.to_ne_bytes();
-   |     ^^^
-   |
-   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).7), kind: Lit(Spanned { node: Int(2, Signed(I8)), span: $DIR/endian_bytes.rs:8:5: 8:8 (#0) }), span: $DIR/endian_bytes.rs:8:5: 8:8 (#0) }
-
-error: use of the method `to_ne_bytes`
-  --> $DIR/endian_bytes.rs:9:5
-   |
-LL |     2u16.to_ne_bytes();
-   |     ^^^^^^^^^^^^^^^^^^
-   |
-   = help: consider specifying the desired endianness
-
-error: use of the method `from_ne_bytes`
-  --> $DIR/endian_bytes.rs:9:5
-   |
-LL |     2u16.to_ne_bytes();
-   |     ^^^^
-   |
-   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).11), kind: Lit(Spanned { node: Int(2, Unsigned(U16)), span: $DIR/endian_bytes.rs:9:5: 9:9 (#0) }), span: $DIR/endian_bytes.rs:9:5: 9:9 (#0) }
-
-error: use of the method `to_ne_bytes`
-  --> $DIR/endian_bytes.rs:10:5
-   |
-LL |     2i16.to_ne_bytes();
-   |     ^^^^^^^^^^^^^^^^^^
-   |
-   = help: consider specifying the desired endianness
-
-error: use of the method `from_ne_bytes`
-  --> $DIR/endian_bytes.rs:10:5
+error: usage of the method `to_ne_bytes`
+  --> $DIR/endian_bytes.rs:7:9
    |
-LL |     2i16.to_ne_bytes();
-   |     ^^^^
-   |
-   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).15), kind: Lit(Spanned { node: Int(2, Signed(I16)), span: $DIR/endian_bytes.rs:10:5: 10:9 (#0) }), span: $DIR/endian_bytes.rs:10:5: 10:9 (#0) }
-
-error: use of the method `to_ne_bytes`
-  --> $DIR/endian_bytes.rs:11:5
-   |
-LL |     2u32.to_ne_bytes();
-   |     ^^^^^^^^^^^^^^^^^^
-   |
-   = help: consider specifying the desired endianness
-
-error: use of the method `from_ne_bytes`
-  --> $DIR/endian_bytes.rs:11:5
-   |
-LL |     2u32.to_ne_bytes();
-   |     ^^^^
-   |
-   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).19), kind: Lit(Spanned { node: Int(2, Unsigned(U32)), span: $DIR/endian_bytes.rs:11:5: 11:9 (#0) }), span: $DIR/endian_bytes.rs:11:5: 11:9 (#0) }
-
-error: use of the method `to_ne_bytes`
-  --> $DIR/endian_bytes.rs:12:5
-   |
-LL |     2i32.to_ne_bytes();
-   |     ^^^^^^^^^^^^^^^^^^
-   |
-   = help: consider specifying the desired endianness
-
-error: use of the method `from_ne_bytes`
-  --> $DIR/endian_bytes.rs:12:5
-   |
-LL |     2i32.to_ne_bytes();
-   |     ^^^^
-   |
-   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).23), kind: Lit(Spanned { node: Int(2, Signed(I32)), span: $DIR/endian_bytes.rs:12:5: 12:9 (#0) }), span: $DIR/endian_bytes.rs:12:5: 12:9 (#0) }
-
-error: use of the method `to_ne_bytes`
-  --> $DIR/endian_bytes.rs:13:5
-   |
-LL |     2u64.to_ne_bytes();
-   |     ^^^^^^^^^^^^^^^^^^
-   |
-   = help: consider specifying the desired endianness
-
-error: use of the method `from_ne_bytes`
-  --> $DIR/endian_bytes.rs:13:5
-   |
-LL |     2u64.to_ne_bytes();
-   |     ^^^^
-   |
-   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).27), kind: Lit(Spanned { node: Int(2, Unsigned(U64)), span: $DIR/endian_bytes.rs:13:5: 13:9 (#0) }), span: $DIR/endian_bytes.rs:13:5: 13:9 (#0) }
-
-error: use of the method `to_ne_bytes`
-  --> $DIR/endian_bytes.rs:14:5
-   |
-LL |     2i64.to_ne_bytes();
-   |     ^^^^^^^^^^^^^^^^^^
-   |
-   = help: consider specifying the desired endianness
-
-error: use of the method `from_ne_bytes`
-  --> $DIR/endian_bytes.rs:14:5
-   |
-LL |     2i64.to_ne_bytes();
-   |     ^^^^
-   |
-   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).31), kind: Lit(Spanned { node: Int(2, Signed(I64)), span: $DIR/endian_bytes.rs:14:5: 14:9 (#0) }), span: $DIR/endian_bytes.rs:14:5: 14:9 (#0) }
-
-error: use of the method `to_ne_bytes`
-  --> $DIR/endian_bytes.rs:15:5
-   |
-LL |     2u128.to_ne_bytes();
-   |     ^^^^^^^^^^^^^^^^^^^
-   |
-   = help: consider specifying the desired endianness
-
-error: use of the method `from_ne_bytes`
-  --> $DIR/endian_bytes.rs:15:5
-   |
-LL |     2u128.to_ne_bytes();
-   |     ^^^^^
-   |
-   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).35), kind: Lit(Spanned { node: Int(2, Unsigned(U128)), span: $DIR/endian_bytes.rs:15:5: 15:10 (#0) }), span: $DIR/endian_bytes.rs:15:5: 15:10 (#0) }
-
-error: use of the method `to_ne_bytes`
-  --> $DIR/endian_bytes.rs:16:5
-   |
-LL |     2i128.to_ne_bytes();
-   |     ^^^^^^^^^^^^^^^^^^^
-   |
-   = help: consider specifying the desired endianness
-
-error: use of the method `from_ne_bytes`
-  --> $DIR/endian_bytes.rs:16:5
-   |
-LL |     2i128.to_ne_bytes();
-   |     ^^^^^
-   |
-   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).39), kind: Lit(Spanned { node: Int(2, Signed(I128)), span: $DIR/endian_bytes.rs:16:5: 16:10 (#0) }), span: $DIR/endian_bytes.rs:16:5: 16:10 (#0) }
-
-error: use of the method `to_ne_bytes`
-  --> $DIR/endian_bytes.rs:17:5
-   |
-LL |     2usize.to_ne_bytes();
-   |     ^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: consider specifying the desired endianness
-
-error: use of the method `from_ne_bytes`
-  --> $DIR/endian_bytes.rs:17:5
-   |
-LL |     2usize.to_ne_bytes();
-   |     ^^^^^^
-   |
-   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).43), kind: Lit(Spanned { node: Int(2, Unsigned(Usize)), span: $DIR/endian_bytes.rs:17:5: 17:11 (#0) }), span: $DIR/endian_bytes.rs:17:5: 17:11 (#0) }
-
-error: use of the method `to_ne_bytes`
-  --> $DIR/endian_bytes.rs:18:5
-   |
-LL |     2isize.to_ne_bytes();
-   |     ^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: consider specifying the desired endianness
-
-error: use of the method `from_ne_bytes`
-  --> $DIR/endian_bytes.rs:18:5
-   |
-LL |     2isize.to_ne_bytes();
-   |     ^^^^^^
-   |
-   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).47), kind: Lit(Spanned { node: Int(2, Signed(Isize)), span: $DIR/endian_bytes.rs:18:5: 18:11 (#0) }), span: $DIR/endian_bytes.rs:18:5: 18:11 (#0) }
-
-error: use of the method `to_ne_bytes`
-  --> $DIR/endian_bytes.rs:19:5
-   |
-LL |     2.0f32.to_ne_bytes();
-   |     ^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: consider specifying the desired endianness
-
-error: use of the method `from_ne_bytes`
-  --> $DIR/endian_bytes.rs:19:5
-   |
-LL |     2.0f32.to_ne_bytes();
-   |     ^^^^^^
-   |
-   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).51), kind: Lit(Spanned { node: Float("2.0", Suffixed(F32)), span: $DIR/endian_bytes.rs:19:5: 19:11 (#0) }), span: $DIR/endian_bytes.rs:19:5: 19:11 (#0) }
-
-error: use of the method `to_ne_bytes`
-  --> $DIR/endian_bytes.rs:20:5
-   |
-LL |     2.0f64.to_ne_bytes();
-   |     ^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: consider specifying the desired endianness
-
-error: use of the method `from_ne_bytes`
-  --> $DIR/endian_bytes.rs:20:5
-   |
-LL |     2.0f64.to_ne_bytes();
-   |     ^^^^^^
-   |
-   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).55), kind: Lit(Spanned { node: Float("2.0", Suffixed(F64)), span: $DIR/endian_bytes.rs:20:5: 20:11 (#0) }), span: $DIR/endian_bytes.rs:20:5: 20:11 (#0) }
-
-error: use of the method `from_ne_bytes`
-  --> $DIR/endian_bytes.rs:21:5
-   |
-LL |     u8::from_ne_bytes(todo!());
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).57), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).58), kind: Path(TypeRelative(Ty { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).60), kind: Path(Resolved(None, Path { span: $DIR/endian_bytes.rs:21:5: 21:7 (#0), res: PrimTy(Uint(U8)), segments: [PathSegment { ident: u8#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).59), res: PrimTy(Uint(U8)), args: None, infer_args: true }] })), span: $DIR/endian_bytes.rs:21:5: 21:7 (#0) }, PathSegment { ident: from_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).61), res: Err, args: None, infer_args: true })), span: $DIR/endian_bytes.rs:21:5: 21:22 (#0) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).62), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).63), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#4), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#4, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).64), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#4, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).65), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#4, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).66), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#4) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).67), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#4) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#4) }]), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:56 (#4) }]), span: $DIR/endian_bytes.rs:21:5: 21:31 (#0) }
-
-error: use of the method `from_ne_bytes`
-  --> $DIR/endian_bytes.rs:21:5
-   |
-LL |     u8::from_ne_bytes(todo!());
-   |     ^^^^^^^^^^^^^^^^^
-   |
-   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).58), kind: Path(TypeRelative(Ty { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).60), kind: Path(Resolved(None, Path { span: $DIR/endian_bytes.rs:21:5: 21:7 (#0), res: PrimTy(Uint(U8)), segments: [PathSegment { ident: u8#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).59), res: PrimTy(Uint(U8)), args: None, infer_args: true }] })), span: $DIR/endian_bytes.rs:21:5: 21:7 (#0) }, PathSegment { ident: from_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).61), res: Err, args: None, infer_args: true })), span: $DIR/endian_bytes.rs:21:5: 21:22 (#0) }
-
-error: use of the method `from_ne_bytes`
-  --> $DIR/endian_bytes.rs:21:23
+LL |         2u8.to_ne_bytes();
+   |         ^^^^^^^^^^^^^^^^^
+...
+LL | fn host() { fn_body!(); }
+   |             ---------- in this macro invocation
    |
-LL |     u8::from_ne_bytes(todo!());
-   |                       ^^^^^^^
-   |
-   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).62), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).63), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#4), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#4, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).64), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#4, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).65), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#4, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).66), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#4) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).67), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#4) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#4) }]), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:56 (#4) }
-   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = help: specify the desired endianness explicitly
+   = note: `-D clippy::host-endian-bytes` implied by `-D warnings`
+   = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `from_ne_bytes`
-  --> $DIR/endian_bytes.rs:21:23
+error: usage of the method `to_ne_bytes`
+  --> $DIR/endian_bytes.rs:8:9
    |
-LL |     u8::from_ne_bytes(todo!());
-   |                       ^^^^^^^
+LL |         2i8.to_ne_bytes();
+   |         ^^^^^^^^^^^^^^^^^
+...
+LL | fn host() { fn_body!(); }
+   |             ---------- in this macro invocation
    |
-   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).63), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#4), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#4, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).64), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#4, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).65), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#4, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).66), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#4) }
-   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = help: specify the desired endianness explicitly
+   = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `from_ne_bytes`
-  --> $DIR/endian_bytes.rs:21:23
+error: usage of the method `to_ne_bytes`
+  --> $DIR/endian_bytes.rs:9:9
    |
-LL |     u8::from_ne_bytes(todo!());
-   |                       ^^^^^^^
+LL |         2u16.to_ne_bytes();
+   |         ^^^^^^^^^^^^^^^^^^
+...
+LL | fn host() { fn_body!(); }
+   |             ---------- in this macro invocation
    |
-   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).67), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#4) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#4) }
-   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = help: specify the desired endianness explicitly
+   = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `from_ne_bytes`
-  --> $DIR/endian_bytes.rs:22:5
+error: usage of the method `to_ne_bytes`
+  --> $DIR/endian_bytes.rs:10:9
    |
-LL |     i8::from_ne_bytes(todo!());
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |         2i16.to_ne_bytes();
+   |         ^^^^^^^^^^^^^^^^^^
+...
+LL | fn host() { fn_body!(); }
+   |             ---------- in this macro invocation
    |
-   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).69), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).70), kind: Path(TypeRelative(Ty { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).72), kind: Path(Resolved(None, Path { span: $DIR/endian_bytes.rs:22:5: 22:7 (#0), res: PrimTy(Int(I8)), segments: [PathSegment { ident: i8#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).71), res: PrimTy(Int(I8)), args: None, infer_args: true }] })), span: $DIR/endian_bytes.rs:22:5: 22:7 (#0) }, PathSegment { ident: from_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).73), res: Err, args: None, infer_args: true })), span: $DIR/endian_bytes.rs:22:5: 22:22 (#0) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).74), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).75), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#5), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#5, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).76), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#5, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).77), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#5, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).78), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#5) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).79), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#5) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#5) }]), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:56 (#5) }]), span: $DIR/endian_bytes.rs:22:5: 22:31 (#0) }
+   = help: specify the desired endianness explicitly
+   = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `from_ne_bytes`
-  --> $DIR/endian_bytes.rs:22:5
+error: usage of the method `to_ne_bytes`
+  --> $DIR/endian_bytes.rs:11:9
    |
-LL |     i8::from_ne_bytes(todo!());
-   |     ^^^^^^^^^^^^^^^^^
+LL |         2u32.to_ne_bytes();
+   |         ^^^^^^^^^^^^^^^^^^
+...
+LL | fn host() { fn_body!(); }
+   |             ---------- in this macro invocation
    |
-   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).70), kind: Path(TypeRelative(Ty { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).72), kind: Path(Resolved(None, Path { span: $DIR/endian_bytes.rs:22:5: 22:7 (#0), res: PrimTy(Int(I8)), segments: [PathSegment { ident: i8#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).71), res: PrimTy(Int(I8)), args: None, infer_args: true }] })), span: $DIR/endian_bytes.rs:22:5: 22:7 (#0) }, PathSegment { ident: from_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).73), res: Err, args: None, infer_args: true })), span: $DIR/endian_bytes.rs:22:5: 22:22 (#0) }
+   = help: specify the desired endianness explicitly
+   = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `from_ne_bytes`
-  --> $DIR/endian_bytes.rs:22:23
+error: usage of the method `to_ne_bytes`
+  --> $DIR/endian_bytes.rs:12:9
    |
-LL |     i8::from_ne_bytes(todo!());
-   |                       ^^^^^^^
+LL |         2i32.to_ne_bytes();
+   |         ^^^^^^^^^^^^^^^^^^
+...
+LL | fn host() { fn_body!(); }
+   |             ---------- in this macro invocation
    |
-   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).74), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).75), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#5), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#5, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).76), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#5, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).77), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#5, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).78), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#5) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).79), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#5) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#5) }]), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:56 (#5) }
-   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = help: specify the desired endianness explicitly
+   = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `from_ne_bytes`
-  --> $DIR/endian_bytes.rs:22:23
+error: usage of the method `to_ne_bytes`
+  --> $DIR/endian_bytes.rs:13:9
    |
-LL |     i8::from_ne_bytes(todo!());
-   |                       ^^^^^^^
+LL |         2u64.to_ne_bytes();
+   |         ^^^^^^^^^^^^^^^^^^
+...
+LL | fn host() { fn_body!(); }
+   |             ---------- in this macro invocation
    |
-   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).75), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#5), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#5, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).76), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#5, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).77), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#5, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).78), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#5) }
-   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = help: specify the desired endianness explicitly
+   = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `from_ne_bytes`
-  --> $DIR/endian_bytes.rs:22:23
+error: usage of the method `to_ne_bytes`
+  --> $DIR/endian_bytes.rs:14:9
    |
-LL |     i8::from_ne_bytes(todo!());
-   |                       ^^^^^^^
+LL |         2i64.to_ne_bytes();
+   |         ^^^^^^^^^^^^^^^^^^
+...
+LL | fn host() { fn_body!(); }
+   |             ---------- in this macro invocation
    |
-   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).79), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#5) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#5) }
-   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = help: specify the desired endianness explicitly
+   = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `from_ne_bytes`
-  --> $DIR/endian_bytes.rs:23:5
+error: usage of the method `to_ne_bytes`
+  --> $DIR/endian_bytes.rs:15:9
    |
-LL |     u16::from_ne_bytes(todo!());
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |         2u128.to_ne_bytes();
+   |         ^^^^^^^^^^^^^^^^^^^
+...
+LL | fn host() { fn_body!(); }
+   |             ---------- in this macro invocation
    |
-   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).81), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).82), kind: Path(TypeRelative(Ty { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).84), kind: Path(Resolved(None, Path { span: $DIR/endian_bytes.rs:23:5: 23:8 (#0), res: PrimTy(Uint(U16)), segments: [PathSegment { ident: u16#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).83), res: PrimTy(Uint(U16)), args: None, infer_args: true }] })), span: $DIR/endian_bytes.rs:23:5: 23:8 (#0) }, PathSegment { ident: from_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).85), res: Err, args: None, infer_args: true })), span: $DIR/endian_bytes.rs:23:5: 23:23 (#0) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).86), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).87), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#6), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#6, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).88), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#6, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).89), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#6, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).90), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#6) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).91), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#6) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#6) }]), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:56 (#6) }]), span: $DIR/endian_bytes.rs:23:5: 23:32 (#0) }
+   = help: specify the desired endianness explicitly
+   = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `from_ne_bytes`
-  --> $DIR/endian_bytes.rs:23:5
+error: usage of the method `to_ne_bytes`
+  --> $DIR/endian_bytes.rs:16:9
    |
-LL |     u16::from_ne_bytes(todo!());
-   |     ^^^^^^^^^^^^^^^^^^
+LL |         2i128.to_ne_bytes();
+   |         ^^^^^^^^^^^^^^^^^^^
+...
+LL | fn host() { fn_body!(); }
+   |             ---------- in this macro invocation
    |
-   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).82), kind: Path(TypeRelative(Ty { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).84), kind: Path(Resolved(None, Path { span: $DIR/endian_bytes.rs:23:5: 23:8 (#0), res: PrimTy(Uint(U16)), segments: [PathSegment { ident: u16#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).83), res: PrimTy(Uint(U16)), args: None, infer_args: true }] })), span: $DIR/endian_bytes.rs:23:5: 23:8 (#0) }, PathSegment { ident: from_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).85), res: Err, args: None, infer_args: true })), span: $DIR/endian_bytes.rs:23:5: 23:23 (#0) }
+   = help: specify the desired endianness explicitly
+   = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `from_ne_bytes`
-  --> $DIR/endian_bytes.rs:23:24
+error: usage of the method `to_ne_bytes`
+  --> $DIR/endian_bytes.rs:17:9
    |
-LL |     u16::from_ne_bytes(todo!());
-   |                        ^^^^^^^
+LL |         2.0f32.to_ne_bytes();
+   |         ^^^^^^^^^^^^^^^^^^^^
+...
+LL | fn host() { fn_body!(); }
+   |             ---------- in this macro invocation
    |
-   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).86), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).87), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#6), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#6, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).88), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#6, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).89), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#6, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).90), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#6) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).91), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#6) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#6) }]), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:56 (#6) }
-   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = help: specify the desired endianness explicitly
+   = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `from_ne_bytes`
-  --> $DIR/endian_bytes.rs:23:24
+error: usage of the method `to_ne_bytes`
+  --> $DIR/endian_bytes.rs:18:9
    |
-LL |     u16::from_ne_bytes(todo!());
-   |                        ^^^^^^^
+LL |         2.0f64.to_ne_bytes();
+   |         ^^^^^^^^^^^^^^^^^^^^
+...
+LL | fn host() { fn_body!(); }
+   |             ---------- in this macro invocation
    |
-   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).87), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#6), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#6, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).88), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#6, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).89), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#6, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).90), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#6) }
-   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = help: specify the desired endianness explicitly
+   = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `from_ne_bytes`
-  --> $DIR/endian_bytes.rs:23:24
+error: usage of the method `to_ne_bytes`
+  --> $DIR/endian_bytes.rs:19:9
    |
-LL |     u16::from_ne_bytes(todo!());
-   |                        ^^^^^^^
+LL |         2usize.to_ne_bytes();
+   |         ^^^^^^^^^^^^^^^^^^^^
+...
+LL | fn host() { fn_body!(); }
+   |             ---------- in this macro invocation
    |
-   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).91), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#6) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#6) }
-   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = help: specify the desired endianness explicitly
+   = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `from_ne_bytes`
-  --> $DIR/endian_bytes.rs:24:5
+error: usage of the method `to_ne_bytes`
+  --> $DIR/endian_bytes.rs:20:9
    |
-LL |     i16::from_ne_bytes(todo!());
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |         2isize.to_ne_bytes();
+   |         ^^^^^^^^^^^^^^^^^^^^
+...
+LL | fn host() { fn_body!(); }
+   |             ---------- in this macro invocation
    |
-   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).93), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).94), kind: Path(TypeRelative(Ty { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).96), kind: Path(Resolved(None, Path { span: $DIR/endian_bytes.rs:24:5: 24:8 (#0), res: PrimTy(Int(I16)), segments: [PathSegment { ident: i16#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).95), res: PrimTy(Int(I16)), args: None, infer_args: true }] })), span: $DIR/endian_bytes.rs:24:5: 24:8 (#0) }, PathSegment { ident: from_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).97), res: Err, args: None, infer_args: true })), span: $DIR/endian_bytes.rs:24:5: 24:23 (#0) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).98), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).99), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#7), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#7, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).100), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#7, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).101), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#7, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).102), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#7) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).103), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#7) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#7) }]), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:56 (#7) }]), span: $DIR/endian_bytes.rs:24:5: 24:32 (#0) }
+   = help: specify the desired endianness explicitly
+   = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `from_ne_bytes`
-  --> $DIR/endian_bytes.rs:24:5
+error: usage of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:21:9
    |
-LL |     i16::from_ne_bytes(todo!());
-   |     ^^^^^^^^^^^^^^^^^^
+LL |         u8::from_ne_bytes(todo!());
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
+...
+LL | fn host() { fn_body!(); }
+   |             ---------- in this macro invocation
    |
-   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).94), kind: Path(TypeRelative(Ty { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).96), kind: Path(Resolved(None, Path { span: $DIR/endian_bytes.rs:24:5: 24:8 (#0), res: PrimTy(Int(I16)), segments: [PathSegment { ident: i16#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).95), res: PrimTy(Int(I16)), args: None, infer_args: true }] })), span: $DIR/endian_bytes.rs:24:5: 24:8 (#0) }, PathSegment { ident: from_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).97), res: Err, args: None, infer_args: true })), span: $DIR/endian_bytes.rs:24:5: 24:23 (#0) }
+   = help: specify the desired endianness explicitly
+   = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `from_ne_bytes`
-  --> $DIR/endian_bytes.rs:24:24
+error: usage of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:22:9
    |
-LL |     i16::from_ne_bytes(todo!());
-   |                        ^^^^^^^
+LL |         i8::from_ne_bytes(todo!());
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
+...
+LL | fn host() { fn_body!(); }
+   |             ---------- in this macro invocation
    |
-   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).98), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).99), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#7), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#7, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).100), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#7, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).101), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#7, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).102), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#7) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).103), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#7) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#7) }]), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:56 (#7) }
-   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = help: specify the desired endianness explicitly
+   = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `from_ne_bytes`
-  --> $DIR/endian_bytes.rs:24:24
+error: usage of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:23:9
    |
-LL |     i16::from_ne_bytes(todo!());
-   |                        ^^^^^^^
+LL |         u16::from_ne_bytes(todo!());
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+...
+LL | fn host() { fn_body!(); }
+   |             ---------- in this macro invocation
    |
-   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).99), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#7), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#7, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).100), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#7, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).101), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#7, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).102), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#7) }
-   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = help: specify the desired endianness explicitly
+   = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `from_ne_bytes`
-  --> $DIR/endian_bytes.rs:24:24
+error: usage of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:24:9
    |
-LL |     i16::from_ne_bytes(todo!());
-   |                        ^^^^^^^
+LL |         i16::from_ne_bytes(todo!());
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+...
+LL | fn host() { fn_body!(); }
+   |             ---------- in this macro invocation
    |
-   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).103), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#7) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#7) }
-   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = help: specify the desired endianness explicitly
+   = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `from_ne_bytes`
-  --> $DIR/endian_bytes.rs:25:5
+error: usage of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:25:9
    |
-LL |     u32::from_ne_bytes(todo!());
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |         u32::from_ne_bytes(todo!());
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+...
+LL | fn host() { fn_body!(); }
+   |             ---------- in this macro invocation
    |
-   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).105), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).106), kind: Path(TypeRelative(Ty { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).108), kind: Path(Resolved(None, Path { span: $DIR/endian_bytes.rs:25:5: 25:8 (#0), res: PrimTy(Uint(U32)), segments: [PathSegment { ident: u32#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).107), res: PrimTy(Uint(U32)), args: None, infer_args: true }] })), span: $DIR/endian_bytes.rs:25:5: 25:8 (#0) }, PathSegment { ident: from_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).109), res: Err, args: None, infer_args: true })), span: $DIR/endian_bytes.rs:25:5: 25:23 (#0) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).110), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).111), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#8), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#8, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).112), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#8, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).113), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#8, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).114), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#8) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).115), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#8) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#8) }]), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:56 (#8) }]), span: $DIR/endian_bytes.rs:25:5: 25:32 (#0) }
+   = help: specify the desired endianness explicitly
+   = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `from_ne_bytes`
-  --> $DIR/endian_bytes.rs:25:5
+error: usage of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:26:9
    |
-LL |     u32::from_ne_bytes(todo!());
-   |     ^^^^^^^^^^^^^^^^^^
+LL |         i32::from_ne_bytes(todo!());
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+...
+LL | fn host() { fn_body!(); }
+   |             ---------- in this macro invocation
    |
-   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).106), kind: Path(TypeRelative(Ty { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).108), kind: Path(Resolved(None, Path { span: $DIR/endian_bytes.rs:25:5: 25:8 (#0), res: PrimTy(Uint(U32)), segments: [PathSegment { ident: u32#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).107), res: PrimTy(Uint(U32)), args: None, infer_args: true }] })), span: $DIR/endian_bytes.rs:25:5: 25:8 (#0) }, PathSegment { ident: from_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).109), res: Err, args: None, infer_args: true })), span: $DIR/endian_bytes.rs:25:5: 25:23 (#0) }
+   = help: specify the desired endianness explicitly
+   = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `from_ne_bytes`
-  --> $DIR/endian_bytes.rs:25:24
+error: usage of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:27:9
    |
-LL |     u32::from_ne_bytes(todo!());
-   |                        ^^^^^^^
+LL |         u64::from_ne_bytes(todo!());
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+...
+LL | fn host() { fn_body!(); }
+   |             ---------- in this macro invocation
    |
-   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).110), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).111), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#8), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#8, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).112), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#8, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).113), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#8, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).114), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#8) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).115), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#8) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#8) }]), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:56 (#8) }
-   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = help: specify the desired endianness explicitly
+   = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `from_ne_bytes`
-  --> $DIR/endian_bytes.rs:25:24
+error: usage of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:28:9
    |
-LL |     u32::from_ne_bytes(todo!());
-   |                        ^^^^^^^
+LL |         i64::from_ne_bytes(todo!());
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+...
+LL | fn host() { fn_body!(); }
+   |             ---------- in this macro invocation
    |
-   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).111), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#8), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#8, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).112), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#8, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).113), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#8, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).114), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#8) }
-   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = help: specify the desired endianness explicitly
+   = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `from_ne_bytes`
-  --> $DIR/endian_bytes.rs:25:24
+error: usage of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:29:9
    |
-LL |     u32::from_ne_bytes(todo!());
-   |                        ^^^^^^^
+LL |         u128::from_ne_bytes(todo!());
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+...
+LL | fn host() { fn_body!(); }
+   |             ---------- in this macro invocation
    |
-   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).115), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#8) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#8) }
-   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = help: specify the desired endianness explicitly
+   = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `from_ne_bytes`
-  --> $DIR/endian_bytes.rs:26:5
+error: usage of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:30:9
    |
-LL |     i32::from_ne_bytes(todo!());
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |         i128::from_ne_bytes(todo!());
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+...
+LL | fn host() { fn_body!(); }
+   |             ---------- in this macro invocation
    |
-   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).117), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).118), kind: Path(TypeRelative(Ty { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).120), kind: Path(Resolved(None, Path { span: $DIR/endian_bytes.rs:26:5: 26:8 (#0), res: PrimTy(Int(I32)), segments: [PathSegment { ident: i32#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).119), res: PrimTy(Int(I32)), args: None, infer_args: true }] })), span: $DIR/endian_bytes.rs:26:5: 26:8 (#0) }, PathSegment { ident: from_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).121), res: Err, args: None, infer_args: true })), span: $DIR/endian_bytes.rs:26:5: 26:23 (#0) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).122), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).123), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#9), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#9, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).124), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#9, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).125), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#9, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).126), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#9) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).127), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#9) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#9) }]), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:56 (#9) }]), span: $DIR/endian_bytes.rs:26:5: 26:32 (#0) }
+   = help: specify the desired endianness explicitly
+   = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `from_ne_bytes`
-  --> $DIR/endian_bytes.rs:26:5
+error: usage of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:31:9
    |
-LL |     i32::from_ne_bytes(todo!());
-   |     ^^^^^^^^^^^^^^^^^^
+LL |         usize::from_ne_bytes(todo!());
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+...
+LL | fn host() { fn_body!(); }
+   |             ---------- in this macro invocation
    |
-   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).118), kind: Path(TypeRelative(Ty { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).120), kind: Path(Resolved(None, Path { span: $DIR/endian_bytes.rs:26:5: 26:8 (#0), res: PrimTy(Int(I32)), segments: [PathSegment { ident: i32#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).119), res: PrimTy(Int(I32)), args: None, infer_args: true }] })), span: $DIR/endian_bytes.rs:26:5: 26:8 (#0) }, PathSegment { ident: from_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).121), res: Err, args: None, infer_args: true })), span: $DIR/endian_bytes.rs:26:5: 26:23 (#0) }
+   = help: specify the desired endianness explicitly
+   = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `from_ne_bytes`
-  --> $DIR/endian_bytes.rs:26:24
+error: usage of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:32:9
    |
-LL |     i32::from_ne_bytes(todo!());
-   |                        ^^^^^^^
+LL |         isize::from_ne_bytes(todo!());
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+...
+LL | fn host() { fn_body!(); }
+   |             ---------- in this macro invocation
    |
-   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).122), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).123), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#9), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#9, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).124), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#9, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).125), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#9, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).126), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#9) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).127), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#9) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#9) }]), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:56 (#9) }
-   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = help: specify the desired endianness explicitly
+   = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `from_ne_bytes`
-  --> $DIR/endian_bytes.rs:26:24
+error: usage of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:33:9
    |
-LL |     i32::from_ne_bytes(todo!());
-   |                        ^^^^^^^
+LL |         f32::from_ne_bytes(todo!());
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+...
+LL | fn host() { fn_body!(); }
+   |             ---------- in this macro invocation
    |
-   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).123), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#9), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#9, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).124), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#9, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).125), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#9, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).126), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#9) }
-   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = help: specify the desired endianness explicitly
+   = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `from_ne_bytes`
-  --> $DIR/endian_bytes.rs:26:24
+error: usage of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:34:9
    |
-LL |     i32::from_ne_bytes(todo!());
-   |                        ^^^^^^^
+LL |         f64::from_ne_bytes(todo!());
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+...
+LL | fn host() { fn_body!(); }
+   |             ---------- in this macro invocation
    |
-   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).127), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#9) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#9) }
-   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = help: specify the desired endianness explicitly
+   = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `from_ne_bytes`
-  --> $DIR/endian_bytes.rs:27:5
+error: usage of the method `to_le_bytes`
+  --> $DIR/endian_bytes.rs:36:9
    |
-LL |     u64::from_ne_bytes(todo!());
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |         2u8.to_le_bytes();
+   |         ^^^^^^^^^^^^^^^^^
+...
+LL | fn little() { fn_body!(); }
+   |               ---------- in this macro invocation
    |
-   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).129), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).130), kind: Path(TypeRelative(Ty { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).132), kind: Path(Resolved(None, Path { span: $DIR/endian_bytes.rs:27:5: 27:8 (#0), res: PrimTy(Uint(U64)), segments: [PathSegment { ident: u64#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).131), res: PrimTy(Uint(U64)), args: None, infer_args: true }] })), span: $DIR/endian_bytes.rs:27:5: 27:8 (#0) }, PathSegment { ident: from_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).133), res: Err, args: None, infer_args: true })), span: $DIR/endian_bytes.rs:27:5: 27:23 (#0) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).134), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).135), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#10), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#10, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).136), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#10, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).137), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#10, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).138), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#10) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).139), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#10) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#10) }]), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:56 (#10) }]), span: $DIR/endian_bytes.rs:27:5: 27:32 (#0) }
+   = help: use the native endianness instead
+   = note: `-D clippy::little-endian-bytes` implied by `-D warnings`
+   = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `from_ne_bytes`
-  --> $DIR/endian_bytes.rs:27:5
+error: usage of the method `to_le_bytes`
+  --> $DIR/endian_bytes.rs:37:9
    |
-LL |     u64::from_ne_bytes(todo!());
-   |     ^^^^^^^^^^^^^^^^^^
+LL |         2i8.to_le_bytes();
+   |         ^^^^^^^^^^^^^^^^^
+...
+LL | fn little() { fn_body!(); }
+   |               ---------- in this macro invocation
    |
-   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).130), kind: Path(TypeRelative(Ty { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).132), kind: Path(Resolved(None, Path { span: $DIR/endian_bytes.rs:27:5: 27:8 (#0), res: PrimTy(Uint(U64)), segments: [PathSegment { ident: u64#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).131), res: PrimTy(Uint(U64)), args: None, infer_args: true }] })), span: $DIR/endian_bytes.rs:27:5: 27:8 (#0) }, PathSegment { ident: from_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).133), res: Err, args: None, infer_args: true })), span: $DIR/endian_bytes.rs:27:5: 27:23 (#0) }
+   = help: use the native endianness instead
+   = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `from_ne_bytes`
-  --> $DIR/endian_bytes.rs:27:24
+error: usage of the method `to_le_bytes`
+  --> $DIR/endian_bytes.rs:38:9
    |
-LL |     u64::from_ne_bytes(todo!());
-   |                        ^^^^^^^
+LL |         2u16.to_le_bytes();
+   |         ^^^^^^^^^^^^^^^^^^
+...
+LL | fn little() { fn_body!(); }
+   |               ---------- in this macro invocation
    |
-   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).134), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).135), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#10), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#10, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).136), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#10, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).137), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#10, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).138), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#10) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).139), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#10) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#10) }]), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:56 (#10) }
-   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = help: use the native endianness instead
+   = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `from_ne_bytes`
-  --> $DIR/endian_bytes.rs:27:24
+error: usage of the method `to_le_bytes`
+  --> $DIR/endian_bytes.rs:39:9
    |
-LL |     u64::from_ne_bytes(todo!());
-   |                        ^^^^^^^
+LL |         2i16.to_le_bytes();
+   |         ^^^^^^^^^^^^^^^^^^
+...
+LL | fn little() { fn_body!(); }
+   |               ---------- in this macro invocation
    |
-   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).135), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#10), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#10, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).136), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#10, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).137), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#10, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).138), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#10) }
-   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = help: use the native endianness instead
+   = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `from_ne_bytes`
-  --> $DIR/endian_bytes.rs:27:24
+error: usage of the method `to_le_bytes`
+  --> $DIR/endian_bytes.rs:40:9
    |
-LL |     u64::from_ne_bytes(todo!());
-   |                        ^^^^^^^
+LL |         2u32.to_le_bytes();
+   |         ^^^^^^^^^^^^^^^^^^
+...
+LL | fn little() { fn_body!(); }
+   |               ---------- in this macro invocation
    |
-   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).139), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#10) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#10) }
-   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = help: use the native endianness instead
+   = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `from_ne_bytes`
-  --> $DIR/endian_bytes.rs:28:5
+error: usage of the method `to_le_bytes`
+  --> $DIR/endian_bytes.rs:41:9
    |
-LL |     i64::from_ne_bytes(todo!());
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |         2i32.to_le_bytes();
+   |         ^^^^^^^^^^^^^^^^^^
+...
+LL | fn little() { fn_body!(); }
+   |               ---------- in this macro invocation
    |
-   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).141), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).142), kind: Path(TypeRelative(Ty { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).144), kind: Path(Resolved(None, Path { span: $DIR/endian_bytes.rs:28:5: 28:8 (#0), res: PrimTy(Int(I64)), segments: [PathSegment { ident: i64#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).143), res: PrimTy(Int(I64)), args: None, infer_args: true }] })), span: $DIR/endian_bytes.rs:28:5: 28:8 (#0) }, PathSegment { ident: from_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).145), res: Err, args: None, infer_args: true })), span: $DIR/endian_bytes.rs:28:5: 28:23 (#0) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).146), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).147), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#11), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#11, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).148), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#11, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).149), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#11, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).150), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#11) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).151), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#11) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#11) }]), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:56 (#11) }]), span: $DIR/endian_bytes.rs:28:5: 28:32 (#0) }
+   = help: use the native endianness instead
+   = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `from_ne_bytes`
-  --> $DIR/endian_bytes.rs:28:5
+error: usage of the method `to_le_bytes`
+  --> $DIR/endian_bytes.rs:42:9
    |
-LL |     i64::from_ne_bytes(todo!());
-   |     ^^^^^^^^^^^^^^^^^^
+LL |         2u64.to_le_bytes();
+   |         ^^^^^^^^^^^^^^^^^^
+...
+LL | fn little() { fn_body!(); }
+   |               ---------- in this macro invocation
    |
-   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).142), kind: Path(TypeRelative(Ty { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).144), kind: Path(Resolved(None, Path { span: $DIR/endian_bytes.rs:28:5: 28:8 (#0), res: PrimTy(Int(I64)), segments: [PathSegment { ident: i64#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).143), res: PrimTy(Int(I64)), args: None, infer_args: true }] })), span: $DIR/endian_bytes.rs:28:5: 28:8 (#0) }, PathSegment { ident: from_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).145), res: Err, args: None, infer_args: true })), span: $DIR/endian_bytes.rs:28:5: 28:23 (#0) }
+   = help: use the native endianness instead
+   = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `from_ne_bytes`
-  --> $DIR/endian_bytes.rs:28:24
+error: usage of the method `to_le_bytes`
+  --> $DIR/endian_bytes.rs:43:9
    |
-LL |     i64::from_ne_bytes(todo!());
-   |                        ^^^^^^^
+LL |         2i64.to_le_bytes();
+   |         ^^^^^^^^^^^^^^^^^^
+...
+LL | fn little() { fn_body!(); }
+   |               ---------- in this macro invocation
    |
-   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).146), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).147), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#11), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#11, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).148), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#11, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).149), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#11, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).150), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#11) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).151), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#11) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#11) }]), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:56 (#11) }
-   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = help: use the native endianness instead
+   = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `from_ne_bytes`
-  --> $DIR/endian_bytes.rs:28:24
+error: usage of the method `to_le_bytes`
+  --> $DIR/endian_bytes.rs:44:9
    |
-LL |     i64::from_ne_bytes(todo!());
-   |                        ^^^^^^^
+LL |         2u128.to_le_bytes();
+   |         ^^^^^^^^^^^^^^^^^^^
+...
+LL | fn little() { fn_body!(); }
+   |               ---------- in this macro invocation
    |
-   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).147), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#11), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#11, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).148), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#11, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).149), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#11, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).150), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#11) }
-   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = help: use the native endianness instead
+   = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `from_ne_bytes`
-  --> $DIR/endian_bytes.rs:28:24
+error: usage of the method `to_le_bytes`
+  --> $DIR/endian_bytes.rs:45:9
    |
-LL |     i64::from_ne_bytes(todo!());
-   |                        ^^^^^^^
+LL |         2i128.to_le_bytes();
+   |         ^^^^^^^^^^^^^^^^^^^
+...
+LL | fn little() { fn_body!(); }
+   |               ---------- in this macro invocation
    |
-   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).151), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#11) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#11) }
-   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = help: use the native endianness instead
+   = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `from_ne_bytes`
-  --> $DIR/endian_bytes.rs:29:5
+error: usage of the method `to_le_bytes`
+  --> $DIR/endian_bytes.rs:46:9
    |
-LL |     u128::from_ne_bytes(todo!());
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |         2.0f32.to_le_bytes();
+   |         ^^^^^^^^^^^^^^^^^^^^
+...
+LL | fn little() { fn_body!(); }
+   |               ---------- in this macro invocation
    |
-   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).153), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).154), kind: Path(TypeRelative(Ty { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).156), kind: Path(Resolved(None, Path { span: $DIR/endian_bytes.rs:29:5: 29:9 (#0), res: PrimTy(Uint(U128)), segments: [PathSegment { ident: u128#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).155), res: PrimTy(Uint(U128)), args: None, infer_args: true }] })), span: $DIR/endian_bytes.rs:29:5: 29:9 (#0) }, PathSegment { ident: from_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).157), res: Err, args: None, infer_args: true })), span: $DIR/endian_bytes.rs:29:5: 29:24 (#0) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).158), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).159), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#12), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#12, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).160), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#12, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).161), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#12, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).162), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#12) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).163), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#12) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#12) }]), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:56 (#12) }]), span: $DIR/endian_bytes.rs:29:5: 29:33 (#0) }
+   = help: use the native endianness instead
+   = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `from_ne_bytes`
-  --> $DIR/endian_bytes.rs:29:5
+error: usage of the method `to_le_bytes`
+  --> $DIR/endian_bytes.rs:47:9
    |
-LL |     u128::from_ne_bytes(todo!());
-   |     ^^^^^^^^^^^^^^^^^^^
+LL |         2.0f64.to_le_bytes();
+   |         ^^^^^^^^^^^^^^^^^^^^
+...
+LL | fn little() { fn_body!(); }
+   |               ---------- in this macro invocation
    |
-   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).154), kind: Path(TypeRelative(Ty { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).156), kind: Path(Resolved(None, Path { span: $DIR/endian_bytes.rs:29:5: 29:9 (#0), res: PrimTy(Uint(U128)), segments: [PathSegment { ident: u128#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).155), res: PrimTy(Uint(U128)), args: None, infer_args: true }] })), span: $DIR/endian_bytes.rs:29:5: 29:9 (#0) }, PathSegment { ident: from_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).157), res: Err, args: None, infer_args: true })), span: $DIR/endian_bytes.rs:29:5: 29:24 (#0) }
+   = help: use the native endianness instead
+   = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `from_ne_bytes`
-  --> $DIR/endian_bytes.rs:29:25
+error: usage of the method `to_le_bytes`
+  --> $DIR/endian_bytes.rs:48:9
    |
-LL |     u128::from_ne_bytes(todo!());
-   |                         ^^^^^^^
+LL |         2usize.to_le_bytes();
+   |         ^^^^^^^^^^^^^^^^^^^^
+...
+LL | fn little() { fn_body!(); }
+   |               ---------- in this macro invocation
    |
-   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).158), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).159), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#12), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#12, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).160), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#12, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).161), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#12, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).162), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#12) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).163), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#12) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#12) }]), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:56 (#12) }
-   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = help: use the native endianness instead
+   = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `from_ne_bytes`
-  --> $DIR/endian_bytes.rs:29:25
+error: usage of the method `to_le_bytes`
+  --> $DIR/endian_bytes.rs:49:9
    |
-LL |     u128::from_ne_bytes(todo!());
-   |                         ^^^^^^^
+LL |         2isize.to_le_bytes();
+   |         ^^^^^^^^^^^^^^^^^^^^
+...
+LL | fn little() { fn_body!(); }
+   |               ---------- in this macro invocation
    |
-   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).159), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#12), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#12, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).160), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#12, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).161), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#12, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).162), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#12) }
-   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = help: use the native endianness instead
+   = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `from_ne_bytes`
-  --> $DIR/endian_bytes.rs:29:25
+error: usage of the method `from_le_bytes`
+  --> $DIR/endian_bytes.rs:50:9
    |
-LL |     u128::from_ne_bytes(todo!());
-   |                         ^^^^^^^
+LL |         u8::from_le_bytes(todo!());
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
+...
+LL | fn little() { fn_body!(); }
+   |               ---------- in this macro invocation
    |
-   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).163), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#12) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#12) }
-   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = help: use the native endianness instead
+   = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `from_ne_bytes`
-  --> $DIR/endian_bytes.rs:30:5
+error: usage of the method `from_le_bytes`
+  --> $DIR/endian_bytes.rs:51:9
    |
-LL |     i128::from_ne_bytes(todo!());
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |         i8::from_le_bytes(todo!());
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
+...
+LL | fn little() { fn_body!(); }
+   |               ---------- in this macro invocation
    |
-   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).165), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).166), kind: Path(TypeRelative(Ty { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).168), kind: Path(Resolved(None, Path { span: $DIR/endian_bytes.rs:30:5: 30:9 (#0), res: PrimTy(Int(I128)), segments: [PathSegment { ident: i128#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).167), res: PrimTy(Int(I128)), args: None, infer_args: true }] })), span: $DIR/endian_bytes.rs:30:5: 30:9 (#0) }, PathSegment { ident: from_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).169), res: Err, args: None, infer_args: true })), span: $DIR/endian_bytes.rs:30:5: 30:24 (#0) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).170), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).171), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#13), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#13, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).172), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#13, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).173), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#13, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).174), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#13) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).175), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#13) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#13) }]), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:56 (#13) }]), span: $DIR/endian_bytes.rs:30:5: 30:33 (#0) }
+   = help: use the native endianness instead
+   = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `from_ne_bytes`
-  --> $DIR/endian_bytes.rs:30:5
+error: usage of the method `from_le_bytes`
+  --> $DIR/endian_bytes.rs:52:9
    |
-LL |     i128::from_ne_bytes(todo!());
-   |     ^^^^^^^^^^^^^^^^^^^
+LL |         u16::from_le_bytes(todo!());
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+...
+LL | fn little() { fn_body!(); }
+   |               ---------- in this macro invocation
    |
-   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).166), kind: Path(TypeRelative(Ty { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).168), kind: Path(Resolved(None, Path { span: $DIR/endian_bytes.rs:30:5: 30:9 (#0), res: PrimTy(Int(I128)), segments: [PathSegment { ident: i128#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).167), res: PrimTy(Int(I128)), args: None, infer_args: true }] })), span: $DIR/endian_bytes.rs:30:5: 30:9 (#0) }, PathSegment { ident: from_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).169), res: Err, args: None, infer_args: true })), span: $DIR/endian_bytes.rs:30:5: 30:24 (#0) }
+   = help: use the native endianness instead
+   = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `from_ne_bytes`
-  --> $DIR/endian_bytes.rs:30:25
+error: usage of the method `from_le_bytes`
+  --> $DIR/endian_bytes.rs:53:9
    |
-LL |     i128::from_ne_bytes(todo!());
-   |                         ^^^^^^^
+LL |         i16::from_le_bytes(todo!());
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+...
+LL | fn little() { fn_body!(); }
+   |               ---------- in this macro invocation
    |
-   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).170), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).171), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#13), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#13, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).172), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#13, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).173), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#13, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).174), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#13) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).175), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#13) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#13) }]), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:56 (#13) }
-   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = help: use the native endianness instead
+   = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `from_ne_bytes`
-  --> $DIR/endian_bytes.rs:30:25
+error: usage of the method `from_le_bytes`
+  --> $DIR/endian_bytes.rs:54:9
    |
-LL |     i128::from_ne_bytes(todo!());
-   |                         ^^^^^^^
+LL |         u32::from_le_bytes(todo!());
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+...
+LL | fn little() { fn_body!(); }
+   |               ---------- in this macro invocation
    |
-   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).171), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#13), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#13, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).172), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#13, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).173), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#13, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).174), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#13) }
-   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = help: use the native endianness instead
+   = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `from_ne_bytes`
-  --> $DIR/endian_bytes.rs:30:25
+error: usage of the method `from_le_bytes`
+  --> $DIR/endian_bytes.rs:55:9
    |
-LL |     i128::from_ne_bytes(todo!());
-   |                         ^^^^^^^
+LL |         i32::from_le_bytes(todo!());
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+...
+LL | fn little() { fn_body!(); }
+   |               ---------- in this macro invocation
    |
-   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).175), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#13) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#13) }
-   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = help: use the native endianness instead
+   = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `from_ne_bytes`
-  --> $DIR/endian_bytes.rs:31:5
+error: usage of the method `from_le_bytes`
+  --> $DIR/endian_bytes.rs:56:9
    |
-LL |     f32::from_ne_bytes(todo!());
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |         u64::from_le_bytes(todo!());
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+...
+LL | fn little() { fn_body!(); }
+   |               ---------- in this macro invocation
    |
-   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).177), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).178), kind: Path(TypeRelative(Ty { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).180), kind: Path(Resolved(None, Path { span: $DIR/endian_bytes.rs:31:5: 31:8 (#0), res: PrimTy(Float(F32)), segments: [PathSegment { ident: f32#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).179), res: PrimTy(Float(F32)), args: None, infer_args: true }] })), span: $DIR/endian_bytes.rs:31:5: 31:8 (#0) }, PathSegment { ident: from_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).181), res: Err, args: None, infer_args: true })), span: $DIR/endian_bytes.rs:31:5: 31:23 (#0) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).182), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).183), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#14), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#14, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).184), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#14, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).185), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#14, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).186), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#14) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).187), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#14) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#14) }]), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:56 (#14) }]), span: $DIR/endian_bytes.rs:31:5: 31:32 (#0) }
+   = help: use the native endianness instead
+   = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `from_ne_bytes`
-  --> $DIR/endian_bytes.rs:31:5
+error: usage of the method `from_le_bytes`
+  --> $DIR/endian_bytes.rs:57:9
    |
-LL |     f32::from_ne_bytes(todo!());
-   |     ^^^^^^^^^^^^^^^^^^
+LL |         i64::from_le_bytes(todo!());
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+...
+LL | fn little() { fn_body!(); }
+   |               ---------- in this macro invocation
    |
-   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).178), kind: Path(TypeRelative(Ty { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).180), kind: Path(Resolved(None, Path { span: $DIR/endian_bytes.rs:31:5: 31:8 (#0), res: PrimTy(Float(F32)), segments: [PathSegment { ident: f32#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).179), res: PrimTy(Float(F32)), args: None, infer_args: true }] })), span: $DIR/endian_bytes.rs:31:5: 31:8 (#0) }, PathSegment { ident: from_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).181), res: Err, args: None, infer_args: true })), span: $DIR/endian_bytes.rs:31:5: 31:23 (#0) }
+   = help: use the native endianness instead
+   = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `from_ne_bytes`
-  --> $DIR/endian_bytes.rs:31:24
+error: usage of the method `from_le_bytes`
+  --> $DIR/endian_bytes.rs:58:9
    |
-LL |     f32::from_ne_bytes(todo!());
-   |                        ^^^^^^^
+LL |         u128::from_le_bytes(todo!());
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+...
+LL | fn little() { fn_body!(); }
+   |               ---------- in this macro invocation
    |
-   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).182), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).183), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#14), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#14, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).184), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#14, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).185), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#14, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).186), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#14) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).187), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#14) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#14) }]), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:56 (#14) }
-   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = help: use the native endianness instead
+   = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `from_ne_bytes`
-  --> $DIR/endian_bytes.rs:31:24
+error: usage of the method `from_le_bytes`
+  --> $DIR/endian_bytes.rs:59:9
    |
-LL |     f32::from_ne_bytes(todo!());
-   |                        ^^^^^^^
+LL |         i128::from_le_bytes(todo!());
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+...
+LL | fn little() { fn_body!(); }
+   |               ---------- in this macro invocation
    |
-   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).183), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#14), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#14, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).184), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#14, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).185), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#14, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).186), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#14) }
-   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = help: use the native endianness instead
+   = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `from_ne_bytes`
-  --> $DIR/endian_bytes.rs:31:24
+error: usage of the method `from_le_bytes`
+  --> $DIR/endian_bytes.rs:60:9
    |
-LL |     f32::from_ne_bytes(todo!());
-   |                        ^^^^^^^
+LL |         usize::from_le_bytes(todo!());
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+...
+LL | fn little() { fn_body!(); }
+   |               ---------- in this macro invocation
    |
-   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).187), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#14) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#14) }
-   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = help: use the native endianness instead
+   = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `from_ne_bytes`
-  --> $DIR/endian_bytes.rs:32:5
+error: usage of the method `from_le_bytes`
+  --> $DIR/endian_bytes.rs:61:9
    |
-LL |     f64::from_ne_bytes(todo!());
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |         isize::from_le_bytes(todo!());
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+...
+LL | fn little() { fn_body!(); }
+   |               ---------- in this macro invocation
    |
-   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).189), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).190), kind: Path(TypeRelative(Ty { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).192), kind: Path(Resolved(None, Path { span: $DIR/endian_bytes.rs:32:5: 32:8 (#0), res: PrimTy(Float(F64)), segments: [PathSegment { ident: f64#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).191), res: PrimTy(Float(F64)), args: None, infer_args: true }] })), span: $DIR/endian_bytes.rs:32:5: 32:8 (#0) }, PathSegment { ident: from_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).193), res: Err, args: None, infer_args: true })), span: $DIR/endian_bytes.rs:32:5: 32:23 (#0) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).194), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).195), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#15), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#15, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).196), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#15, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).197), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#15, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).198), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#15) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).199), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#15) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#15) }]), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:56 (#15) }]), span: $DIR/endian_bytes.rs:32:5: 32:32 (#0) }
+   = help: use the native endianness instead
+   = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `from_ne_bytes`
-  --> $DIR/endian_bytes.rs:32:5
+error: usage of the method `from_le_bytes`
+  --> $DIR/endian_bytes.rs:62:9
    |
-LL |     f64::from_ne_bytes(todo!());
-   |     ^^^^^^^^^^^^^^^^^^
+LL |         f32::from_le_bytes(todo!());
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+...
+LL | fn little() { fn_body!(); }
+   |               ---------- in this macro invocation
    |
-   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).190), kind: Path(TypeRelative(Ty { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).192), kind: Path(Resolved(None, Path { span: $DIR/endian_bytes.rs:32:5: 32:8 (#0), res: PrimTy(Float(F64)), segments: [PathSegment { ident: f64#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).191), res: PrimTy(Float(F64)), args: None, infer_args: true }] })), span: $DIR/endian_bytes.rs:32:5: 32:8 (#0) }, PathSegment { ident: from_ne_bytes#0, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).193), res: Err, args: None, infer_args: true })), span: $DIR/endian_bytes.rs:32:5: 32:23 (#0) }
+   = help: use the native endianness instead
+   = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `from_ne_bytes`
-  --> $DIR/endian_bytes.rs:32:24
+error: usage of the method `from_le_bytes`
+  --> $DIR/endian_bytes.rs:63:9
    |
-LL |     f64::from_ne_bytes(todo!());
-   |                        ^^^^^^^
+LL |         f64::from_le_bytes(todo!());
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+...
+LL | fn little() { fn_body!(); }
+   |               ---------- in this macro invocation
    |
-   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).194), kind: Call(Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).195), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#15), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#15, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).196), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#15, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).197), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#15, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).198), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#15) }, [Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).199), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#15) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#15) }]), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:56 (#15) }
-   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = help: use the native endianness instead
+   = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `from_ne_bytes`
-  --> $DIR/endian_bytes.rs:32:24
+error: usage of the method `to_ne_bytes`
+  --> $DIR/endian_bytes.rs:70:9
    |
-LL |     f64::from_ne_bytes(todo!());
-   |                        ^^^^^^^
+LL |         2u8.to_ne_bytes();
+   |         ^^^^^^^^^^^^^^^^^
+...
+LL | fn host_encourage_little() { fn_body_small!(); }
+   |                              ---------------- in this macro invocation
    |
-   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).195), kind: Path(Resolved(None, Path { span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#15), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), segments: [PathSegment { ident: $crate#15, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).196), res: Err, args: None, infer_args: true }, PathSegment { ident: panicking#15, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).197), res: Def(Mod, DefId(2:8281 ~ core[690e]::panicking)), args: None, infer_args: true }, PathSegment { ident: panic#15, hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).198), res: Def(Fn, DefId(2:8292 ~ core[690e]::panicking::panic)), args: None, infer_args: true }] })), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:9: 773:33 (#15) }
-   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = help: use `to_le_bytes` instead
+   = note: this error originates in the macro `fn_body_small` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `from_ne_bytes`
-  --> $DIR/endian_bytes.rs:32:24
+error: usage of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:71:9
    |
-LL |     f64::from_ne_bytes(todo!());
-   |                        ^^^^^^^
+LL |         u8::from_ne_bytes(todo!());
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
+...
+LL | fn host_encourage_little() { fn_body_small!(); }
+   |                              ---------------- in this macro invocation
    |
-   = help: consider specifying the desired endianness: Expr { hir_id: HirId(DefId(0:3 ~ endian_bytes[6e38]::host).199), kind: Lit(Spanned { node: Str("not yet implemented", Cooked), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#15) }), span: /home/centri/.rustup/toolchains/nightly-2023-05-05-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/macros/mod.rs:773:34: 773:55 (#15) }
-   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = help: use `from_le_bytes` instead
+   = note: this error originates in the macro `fn_body_small` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `to_le_bytes`
-  --> $DIR/endian_bytes.rs:37:5
+error: usage of the method `to_be_bytes`
+  --> $DIR/endian_bytes.rs:76:9
    |
-LL |     2u8.to_le_bytes();
-   |     ^^^^^^^^^^^^^^^^^
+LL |         2u8.to_be_bytes();
+   |         ^^^^^^^^^^^^^^^^^
+...
+LL | fn host_encourage_little() { fn_body_small!(); }
+   |                              ---------------- in this macro invocation
    |
-   = help: use `to_be_bytes` instead
-   = note: `-D clippy::little-endian-bytes` implied by `-D warnings`
+   = help: use `to_le_bytes` instead
+   = note: `-D clippy::big-endian-bytes` implied by `-D warnings`
+   = note: this error originates in the macro `fn_body_small` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `to_le_bytes`
-  --> $DIR/endian_bytes.rs:38:5
+error: usage of the method `from_be_bytes`
+  --> $DIR/endian_bytes.rs:77:9
    |
-LL |     2i8.to_le_bytes();
-   |     ^^^^^^^^^^^^^^^^^
+LL |         u8::from_be_bytes(todo!());
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
+...
+LL | fn host_encourage_little() { fn_body_small!(); }
+   |                              ---------------- in this macro invocation
    |
-   = help: use `to_be_bytes` instead
+   = help: use `from_le_bytes` instead
+   = note: this error originates in the macro `fn_body_small` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `to_le_bytes`
-  --> $DIR/endian_bytes.rs:39:5
+error: usage of the method `to_ne_bytes`
+  --> $DIR/endian_bytes.rs:70:9
    |
-LL |     2u16.to_le_bytes();
-   |     ^^^^^^^^^^^^^^^^^^
+LL |         2u8.to_ne_bytes();
+   |         ^^^^^^^^^^^^^^^^^
+...
+LL | fn host_encourage_big() { fn_body_small!(); }
+   |                           ---------------- in this macro invocation
    |
    = help: use `to_be_bytes` instead
+   = note: this error originates in the macro `fn_body_small` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `to_le_bytes`
-  --> $DIR/endian_bytes.rs:40:5
+error: usage of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:71:9
    |
-LL |     2i16.to_le_bytes();
-   |     ^^^^^^^^^^^^^^^^^^
+LL |         u8::from_ne_bytes(todo!());
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
+...
+LL | fn host_encourage_big() { fn_body_small!(); }
+   |                           ---------------- in this macro invocation
    |
-   = help: use `to_be_bytes` instead
+   = help: use `from_be_bytes` instead
+   = note: this error originates in the macro `fn_body_small` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `to_le_bytes`
-  --> $DIR/endian_bytes.rs:41:5
+error: usage of the method `to_le_bytes`
+  --> $DIR/endian_bytes.rs:73:9
    |
-LL |     2u32.to_le_bytes();
-   |     ^^^^^^^^^^^^^^^^^^
+LL |         2u8.to_le_bytes();
+   |         ^^^^^^^^^^^^^^^^^
+...
+LL | fn host_encourage_big() { fn_body_small!(); }
+   |                           ---------------- in this macro invocation
    |
    = help: use `to_be_bytes` instead
+   = note: this error originates in the macro `fn_body_small` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `to_le_bytes`
-  --> $DIR/endian_bytes.rs:42:5
+error: usage of the method `from_le_bytes`
+  --> $DIR/endian_bytes.rs:74:9
    |
-LL |     2i32.to_le_bytes();
-   |     ^^^^^^^^^^^^^^^^^^
+LL |         u8::from_le_bytes(todo!());
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
+...
+LL | fn host_encourage_big() { fn_body_small!(); }
+   |                           ---------------- in this macro invocation
    |
-   = help: use `to_be_bytes` instead
+   = help: use `from_be_bytes` instead
+   = note: this error originates in the macro `fn_body_small` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `to_le_bytes`
-  --> $DIR/endian_bytes.rs:43:5
+error: usage of the method `to_ne_bytes`
+  --> $DIR/endian_bytes.rs:70:9
    |
-LL |     2u64.to_le_bytes();
-   |     ^^^^^^^^^^^^^^^^^^
+LL |         2u8.to_ne_bytes();
+   |         ^^^^^^^^^^^^^^^^^
+...
+LL | fn no_help() { fn_body_small!(); }
+   |                ---------------- in this macro invocation
    |
-   = help: use `to_be_bytes` instead
+   = note: this error originates in the macro `fn_body_small` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `to_le_bytes`
-  --> $DIR/endian_bytes.rs:44:5
+error: usage of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:71:9
    |
-LL |     2i64.to_le_bytes();
-   |     ^^^^^^^^^^^^^^^^^^
+LL |         u8::from_ne_bytes(todo!());
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
+...
+LL | fn no_help() { fn_body_small!(); }
+   |                ---------------- in this macro invocation
    |
-   = help: use `to_be_bytes` instead
+   = note: this error originates in the macro `fn_body_small` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `to_le_bytes`
-  --> $DIR/endian_bytes.rs:45:5
+error: usage of the method `to_le_bytes`
+  --> $DIR/endian_bytes.rs:73:9
    |
-LL |     2u128.to_le_bytes();
-   |     ^^^^^^^^^^^^^^^^^^^
+LL |         2u8.to_le_bytes();
+   |         ^^^^^^^^^^^^^^^^^
+...
+LL | fn no_help() { fn_body_small!(); }
+   |                ---------------- in this macro invocation
    |
-   = help: use `to_be_bytes` instead
+   = note: this error originates in the macro `fn_body_small` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `to_le_bytes`
-  --> $DIR/endian_bytes.rs:46:5
+error: usage of the method `from_le_bytes`
+  --> $DIR/endian_bytes.rs:74:9
    |
-LL |     2i128.to_le_bytes();
-   |     ^^^^^^^^^^^^^^^^^^^
+LL |         u8::from_le_bytes(todo!());
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
+...
+LL | fn no_help() { fn_body_small!(); }
+   |                ---------------- in this macro invocation
    |
-   = help: use `to_be_bytes` instead
+   = note: this error originates in the macro `fn_body_small` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `to_le_bytes`
-  --> $DIR/endian_bytes.rs:47:5
+error: usage of the method `to_be_bytes`
+  --> $DIR/endian_bytes.rs:76:9
    |
-LL |     2usize.to_le_bytes();
-   |     ^^^^^^^^^^^^^^^^^^^^
+LL |         2u8.to_be_bytes();
+   |         ^^^^^^^^^^^^^^^^^
+...
+LL | fn no_help() { fn_body_small!(); }
+   |                ---------------- in this macro invocation
    |
-   = help: use `to_be_bytes` instead
+   = note: this error originates in the macro `fn_body_small` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `to_le_bytes`
-  --> $DIR/endian_bytes.rs:48:5
+error: usage of the method `from_be_bytes`
+  --> $DIR/endian_bytes.rs:77:9
    |
-LL |     2isize.to_le_bytes();
-   |     ^^^^^^^^^^^^^^^^^^^^
+LL |         u8::from_be_bytes(todo!());
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
+...
+LL | fn no_help() { fn_body_small!(); }
+   |                ---------------- in this macro invocation
    |
-   = help: use `to_be_bytes` instead
+   = note: this error originates in the macro `fn_body_small` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `to_le_bytes`
-  --> $DIR/endian_bytes.rs:49:5
+error: usage of the method `to_le_bytes`
+  --> $DIR/endian_bytes.rs:73:9
    |
-LL |     2.0f32.to_le_bytes();
-   |     ^^^^^^^^^^^^^^^^^^^^
+LL |         2u8.to_le_bytes();
+   |         ^^^^^^^^^^^^^^^^^
+...
+LL | fn little_encourage_host() { fn_body_small!(); }
+   |                              ---------------- in this macro invocation
    |
-   = help: use `to_be_bytes` instead
+   = help: use the native endianness instead
+   = note: this error originates in the macro `fn_body_small` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `to_le_bytes`
-  --> $DIR/endian_bytes.rs:50:5
+error: usage of the method `from_le_bytes`
+  --> $DIR/endian_bytes.rs:74:9
    |
-LL |     2.0f64.to_le_bytes();
-   |     ^^^^^^^^^^^^^^^^^^^^
+LL |         u8::from_le_bytes(todo!());
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
+...
+LL | fn little_encourage_host() { fn_body_small!(); }
+   |                              ---------------- in this macro invocation
    |
-   = help: use `to_be_bytes` instead
+   = help: use the native endianness instead
+   = note: this error originates in the macro `fn_body_small` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `to_be_bytes`
-  --> $DIR/endian_bytes.rs:69:5
+error: usage of the method `to_be_bytes`
+  --> $DIR/endian_bytes.rs:76:9
    |
-LL |     2u8.to_be_bytes();
-   |     ^^^^^^^^^^^^^^^^^
+LL |         2u8.to_be_bytes();
+   |         ^^^^^^^^^^^^^^^^^
+...
+LL | fn little_encourage_host() { fn_body_small!(); }
+   |                              ---------------- in this macro invocation
    |
-   = help: use `to_le_bytes` instead
-   = note: `-D clippy::big-endian-bytes` implied by `-D warnings`
+   = help: use the native endianness instead
+   = note: this error originates in the macro `fn_body_small` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `to_be_bytes`
-  --> $DIR/endian_bytes.rs:70:5
+error: usage of the method `from_be_bytes`
+  --> $DIR/endian_bytes.rs:77:9
    |
-LL |     2i8.to_be_bytes();
-   |     ^^^^^^^^^^^^^^^^^
+LL |         u8::from_be_bytes(todo!());
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
+...
+LL | fn little_encourage_host() { fn_body_small!(); }
+   |                              ---------------- in this macro invocation
    |
-   = help: use `to_le_bytes` instead
+   = help: use the native endianness instead
+   = note: this error originates in the macro `fn_body_small` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `to_be_bytes`
-  --> $DIR/endian_bytes.rs:71:5
+error: usage of the method `to_ne_bytes`
+  --> $DIR/endian_bytes.rs:70:9
    |
-LL |     2u16.to_be_bytes();
-   |     ^^^^^^^^^^^^^^^^^^
+LL |         2u8.to_ne_bytes();
+   |         ^^^^^^^^^^^^^^^^^
+...
+LL | fn little_encourage_big() { fn_body_small!(); }
+   |                             ---------------- in this macro invocation
    |
-   = help: use `to_le_bytes` instead
-
-error: use of the method `to_be_bytes`
-  --> $DIR/endian_bytes.rs:72:5
-   |
-LL |     2i16.to_be_bytes();
-   |     ^^^^^^^^^^^^^^^^^^
-   |
-   = help: use `to_le_bytes` instead
+   = help: use `to_be_bytes` instead
+   = note: this error originates in the macro `fn_body_small` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `to_be_bytes`
-  --> $DIR/endian_bytes.rs:73:5
+error: usage of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:71:9
    |
-LL |     2u32.to_be_bytes();
-   |     ^^^^^^^^^^^^^^^^^^
+LL |         u8::from_ne_bytes(todo!());
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
+...
+LL | fn little_encourage_big() { fn_body_small!(); }
+   |                             ---------------- in this macro invocation
    |
-   = help: use `to_le_bytes` instead
+   = help: use `from_be_bytes` instead
+   = note: this error originates in the macro `fn_body_small` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `to_be_bytes`
-  --> $DIR/endian_bytes.rs:74:5
+error: usage of the method `to_le_bytes`
+  --> $DIR/endian_bytes.rs:73:9
    |
-LL |     2i32.to_be_bytes();
-   |     ^^^^^^^^^^^^^^^^^^
+LL |         2u8.to_le_bytes();
+   |         ^^^^^^^^^^^^^^^^^
+...
+LL | fn little_encourage_big() { fn_body_small!(); }
+   |                             ---------------- in this macro invocation
    |
-   = help: use `to_le_bytes` instead
+   = help: use `to_be_bytes` instead
+   = note: this error originates in the macro `fn_body_small` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `to_be_bytes`
-  --> $DIR/endian_bytes.rs:75:5
+error: usage of the method `from_le_bytes`
+  --> $DIR/endian_bytes.rs:74:9
    |
-LL |     2u64.to_be_bytes();
-   |     ^^^^^^^^^^^^^^^^^^
+LL |         u8::from_le_bytes(todo!());
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
+...
+LL | fn little_encourage_big() { fn_body_small!(); }
+   |                             ---------------- in this macro invocation
    |
-   = help: use `to_le_bytes` instead
+   = help: use `from_be_bytes` instead
+   = note: this error originates in the macro `fn_body_small` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `to_be_bytes`
-  --> $DIR/endian_bytes.rs:76:5
+error: usage of the method `to_le_bytes`
+  --> $DIR/endian_bytes.rs:73:9
    |
-LL |     2i64.to_be_bytes();
-   |     ^^^^^^^^^^^^^^^^^^
+LL |         2u8.to_le_bytes();
+   |         ^^^^^^^^^^^^^^^^^
+...
+LL | fn big_encourage_host() { fn_body_small!(); }
+   |                           ---------------- in this macro invocation
    |
-   = help: use `to_le_bytes` instead
+   = help: use the native endianness instead
+   = note: this error originates in the macro `fn_body_small` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `to_be_bytes`
-  --> $DIR/endian_bytes.rs:77:5
+error: usage of the method `from_le_bytes`
+  --> $DIR/endian_bytes.rs:74:9
    |
-LL |     2u128.to_be_bytes();
-   |     ^^^^^^^^^^^^^^^^^^^
+LL |         u8::from_le_bytes(todo!());
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
+...
+LL | fn big_encourage_host() { fn_body_small!(); }
+   |                           ---------------- in this macro invocation
    |
-   = help: use `to_le_bytes` instead
+   = help: use the native endianness instead
+   = note: this error originates in the macro `fn_body_small` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `to_be_bytes`
-  --> $DIR/endian_bytes.rs:78:5
+error: usage of the method `to_be_bytes`
+  --> $DIR/endian_bytes.rs:76:9
    |
-LL |     2i128.to_be_bytes();
-   |     ^^^^^^^^^^^^^^^^^^^
+LL |         2u8.to_be_bytes();
+   |         ^^^^^^^^^^^^^^^^^
+...
+LL | fn big_encourage_host() { fn_body_small!(); }
+   |                           ---------------- in this macro invocation
    |
-   = help: use `to_le_bytes` instead
+   = help: use the native endianness instead
+   = note: this error originates in the macro `fn_body_small` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `to_be_bytes`
-  --> $DIR/endian_bytes.rs:79:5
+error: usage of the method `from_be_bytes`
+  --> $DIR/endian_bytes.rs:77:9
    |
-LL |     2.0f32.to_be_bytes();
-   |     ^^^^^^^^^^^^^^^^^^^^
+LL |         u8::from_be_bytes(todo!());
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
+...
+LL | fn big_encourage_host() { fn_body_small!(); }
+   |                           ---------------- in this macro invocation
    |
-   = help: use `to_le_bytes` instead
+   = help: use the native endianness instead
+   = note: this error originates in the macro `fn_body_small` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `to_be_bytes`
-  --> $DIR/endian_bytes.rs:80:5
+error: usage of the method `to_ne_bytes`
+  --> $DIR/endian_bytes.rs:70:9
    |
-LL |     2.0f64.to_be_bytes();
-   |     ^^^^^^^^^^^^^^^^^^^^
+LL |         2u8.to_ne_bytes();
+   |         ^^^^^^^^^^^^^^^^^
+...
+LL | fn big_encourage_little() { fn_body_small!(); }
+   |                             ---------------- in this macro invocation
    |
    = help: use `to_le_bytes` instead
+   = note: this error originates in the macro `fn_body_small` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `to_be_bytes`
-  --> $DIR/endian_bytes.rs:81:5
+error: usage of the method `from_ne_bytes`
+  --> $DIR/endian_bytes.rs:71:9
    |
-LL |     2usize.to_be_bytes();
-   |     ^^^^^^^^^^^^^^^^^^^^
+LL |         u8::from_ne_bytes(todo!());
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
+...
+LL | fn big_encourage_little() { fn_body_small!(); }
+   |                             ---------------- in this macro invocation
    |
-   = help: use `to_le_bytes` instead
+   = help: use `from_le_bytes` instead
+   = note: this error originates in the macro `fn_body_small` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `to_be_bytes`
-  --> $DIR/endian_bytes.rs:82:5
+error: usage of the method `to_be_bytes`
+  --> $DIR/endian_bytes.rs:76:9
    |
-LL |     2isize.to_be_bytes();
-   |     ^^^^^^^^^^^^^^^^^^^^
+LL |         2u8.to_be_bytes();
+   |         ^^^^^^^^^^^^^^^^^
+...
+LL | fn big_encourage_little() { fn_body_small!(); }
+   |                             ---------------- in this macro invocation
    |
    = help: use `to_le_bytes` instead
+   = note: this error originates in the macro `fn_body_small` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: use of the method `to_le_bytes`
-  --> $DIR/endian_bytes.rs:102:5
-   |
-LL |     2u8.to_le_bytes();
-   |     ^^^^^^^^^^^^^^^^^
-
-error: use of the method `to_le_bytes`
-  --> $DIR/endian_bytes.rs:103:5
-   |
-LL |     2i8.to_le_bytes();
-   |     ^^^^^^^^^^^^^^^^^
-
-error: use of the method `to_le_bytes`
-  --> $DIR/endian_bytes.rs:104:5
-   |
-LL |     2u16.to_le_bytes();
-   |     ^^^^^^^^^^^^^^^^^^
-
-error: use of the method `to_le_bytes`
-  --> $DIR/endian_bytes.rs:105:5
-   |
-LL |     2i16.to_le_bytes();
-   |     ^^^^^^^^^^^^^^^^^^
-
-error: use of the method `to_le_bytes`
-  --> $DIR/endian_bytes.rs:106:5
+error: usage of the method `from_be_bytes`
+  --> $DIR/endian_bytes.rs:77:9
    |
-LL |     2u32.to_le_bytes();
-   |     ^^^^^^^^^^^^^^^^^^
-
-error: use of the method `to_le_bytes`
-  --> $DIR/endian_bytes.rs:107:5
-   |
-LL |     2i32.to_le_bytes();
-   |     ^^^^^^^^^^^^^^^^^^
-
-error: use of the method `to_le_bytes`
-  --> $DIR/endian_bytes.rs:108:5
-   |
-LL |     2u64.to_le_bytes();
-   |     ^^^^^^^^^^^^^^^^^^
-
-error: use of the method `to_le_bytes`
-  --> $DIR/endian_bytes.rs:109:5
-   |
-LL |     2i64.to_le_bytes();
-   |     ^^^^^^^^^^^^^^^^^^
-
-error: use of the method `to_le_bytes`
-  --> $DIR/endian_bytes.rs:110:5
-   |
-LL |     2u128.to_le_bytes();
-   |     ^^^^^^^^^^^^^^^^^^^
-
-error: use of the method `to_le_bytes`
-  --> $DIR/endian_bytes.rs:111:5
-   |
-LL |     2i128.to_le_bytes();
-   |     ^^^^^^^^^^^^^^^^^^^
-
-error: use of the method `to_le_bytes`
-  --> $DIR/endian_bytes.rs:112:5
-   |
-LL |     2usize.to_le_bytes();
-   |     ^^^^^^^^^^^^^^^^^^^^
-
-error: use of the method `to_le_bytes`
-  --> $DIR/endian_bytes.rs:113:5
-   |
-LL |     2isize.to_le_bytes();
-   |     ^^^^^^^^^^^^^^^^^^^^
-
-error: use of the method `to_le_bytes`
-  --> $DIR/endian_bytes.rs:114:5
-   |
-LL |     2.0f32.to_le_bytes();
-   |     ^^^^^^^^^^^^^^^^^^^^
-
-error: use of the method `to_le_bytes`
-  --> $DIR/endian_bytes.rs:115:5
-   |
-LL |     2.0f64.to_le_bytes();
-   |     ^^^^^^^^^^^^^^^^^^^^
-
-error: use of the method `to_be_bytes`
-  --> $DIR/endian_bytes.rs:135:5
-   |
-LL |     2u8.to_be_bytes();
-   |     ^^^^^^^^^^^^^^^^^
-
-error: use of the method `to_be_bytes`
-  --> $DIR/endian_bytes.rs:136:5
-   |
-LL |     2i8.to_be_bytes();
-   |     ^^^^^^^^^^^^^^^^^
-
-error: use of the method `to_be_bytes`
-  --> $DIR/endian_bytes.rs:137:5
-   |
-LL |     2u16.to_be_bytes();
-   |     ^^^^^^^^^^^^^^^^^^
-
-error: use of the method `to_be_bytes`
-  --> $DIR/endian_bytes.rs:138:5
-   |
-LL |     2i16.to_be_bytes();
-   |     ^^^^^^^^^^^^^^^^^^
-
-error: use of the method `to_be_bytes`
-  --> $DIR/endian_bytes.rs:139:5
-   |
-LL |     2u32.to_be_bytes();
-   |     ^^^^^^^^^^^^^^^^^^
-
-error: use of the method `to_be_bytes`
-  --> $DIR/endian_bytes.rs:140:5
-   |
-LL |     2i32.to_be_bytes();
-   |     ^^^^^^^^^^^^^^^^^^
-
-error: use of the method `to_be_bytes`
-  --> $DIR/endian_bytes.rs:141:5
-   |
-LL |     2u64.to_be_bytes();
-   |     ^^^^^^^^^^^^^^^^^^
-
-error: use of the method `to_be_bytes`
-  --> $DIR/endian_bytes.rs:142:5
-   |
-LL |     2i64.to_be_bytes();
-   |     ^^^^^^^^^^^^^^^^^^
-
-error: use of the method `to_be_bytes`
-  --> $DIR/endian_bytes.rs:143:5
-   |
-LL |     2u128.to_be_bytes();
-   |     ^^^^^^^^^^^^^^^^^^^
-
-error: use of the method `to_be_bytes`
-  --> $DIR/endian_bytes.rs:144:5
-   |
-LL |     2i128.to_be_bytes();
-   |     ^^^^^^^^^^^^^^^^^^^
-
-error: use of the method `to_be_bytes`
-  --> $DIR/endian_bytes.rs:145:5
-   |
-LL |     2usize.to_be_bytes();
-   |     ^^^^^^^^^^^^^^^^^^^^
-
-error: use of the method `to_be_bytes`
-  --> $DIR/endian_bytes.rs:146:5
-   |
-LL |     2isize.to_be_bytes();
-   |     ^^^^^^^^^^^^^^^^^^^^
-
-error: use of the method `to_be_bytes`
-  --> $DIR/endian_bytes.rs:147:5
-   |
-LL |     2.0f32.to_be_bytes();
-   |     ^^^^^^^^^^^^^^^^^^^^
-
-error: use of the method `to_be_bytes`
-  --> $DIR/endian_bytes.rs:148:5
+LL |         u8::from_be_bytes(todo!());
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
+...
+LL | fn big_encourage_little() { fn_body_small!(); }
+   |                             ---------------- in this macro invocation
    |
-LL |     2.0f64.to_be_bytes();
-   |     ^^^^^^^^^^^^^^^^^^^^
+   = help: use `from_le_bytes` instead
+   = note: this error originates in the macro `fn_body_small` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to 145 previous errors
+error: aborting due to 86 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 48d36a7aa3d8281352ac70c240d98c18b0a9adfa Mon Sep 17 00:00:00 2001
From: Catherine <114838443+Centri3@users.noreply.github.com>
Date: Thu, 25 May 2023 11:15:30 -0500
Subject: weird grammar

---
 clippy_lints/src/endian_bytes.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/endian_bytes.rs b/clippy_lints/src/endian_bytes.rs
index 6486430cf57..88e0d4dcd53 100644
--- a/clippy_lints/src/endian_bytes.rs
+++ b/clippy_lints/src/endian_bytes.rs
@@ -30,7 +30,7 @@ declare_clippy_lint! {
     /// Checks for the usage of the `to_le_bytes` method.
     ///
     /// ### Why is this bad?
-    /// It's not, but some may wish to lint usages of this method, either to suggest using the host
+    /// It's not, but some may wish to lint usage of this method, either to suggest using the host
     /// endianness or big endian.
     ///
     /// ### Example
@@ -49,7 +49,7 @@ declare_clippy_lint! {
     /// Checks for the usage of the `to_be_bytes` method.
     ///
     /// ### Why is this bad?
-    /// It's not, but some may wish to lint usages of this method, either to suggest using the host
+    /// It's not, but some may wish to lint usage of this method, either to suggest using the host
     /// endianness or little endian.
     ///
     /// ### Example
-- 
cgit 1.4.1-3-g733a5


From 04b7cae37ec90237682aaff58e7773ad42d22259 Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Thu, 25 May 2023 11:29:43 -0500
Subject: refine output

---
 clippy_lints/src/endian_bytes.rs |  26 ++-
 tests/ui/endian_bytes.rs         |  16 +-
 tests/ui/endian_bytes.stderr     | 384 +++++++++++++++++++--------------------
 3 files changed, 217 insertions(+), 209 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/endian_bytes.rs b/clippy_lints/src/endian_bytes.rs
index 88e0d4dcd53..434125932c4 100644
--- a/clippy_lints/src/endian_bytes.rs
+++ b/clippy_lints/src/endian_bytes.rs
@@ -2,7 +2,7 @@ use crate::Lint;
 use clippy_utils::{diagnostics::span_lint_and_then, is_lint_allowed};
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
-use rustc_middle::lint::in_external_macro;
+use rustc_middle::{lint::in_external_macro, ty::Ty};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::Symbol;
 use std::borrow::Cow;
@@ -102,11 +102,13 @@ impl LateLintPass<'_> for EndianBytes {
 
         if_chain! {
             if let ExprKind::MethodCall(method_name, receiver, args, ..) = expr.kind;
-            if let ExprKind::Lit(..) = receiver.kind;
             if args.is_empty();
-            if try_lint_endian_bytes(cx, expr, "to", method_name.ident.name);
+            let ty = cx.typeck_results().expr_ty(receiver);
+            if ty.is_primitive_ty();
             then {
-                return;
+                if try_lint_endian_bytes(cx, expr, "to", method_name.ident.name, ty) {
+                    return;
+                }
             }
         }
 
@@ -115,15 +117,16 @@ impl LateLintPass<'_> for EndianBytes {
             if let ExprKind::Path(qpath) = function.kind;
             if let Some(def_id) = cx.qpath_res(&qpath, function.hir_id).opt_def_id();
             if let Some(function_name) = cx.get_def_path(def_id).last();
-            if cx.typeck_results().expr_ty(expr).is_primitive_ty();
+            let ty = cx.typeck_results().expr_ty(expr);
+            if ty.is_primitive_ty();
             then {
-                try_lint_endian_bytes(cx, expr, "from", *function_name);
+                try_lint_endian_bytes(cx, expr, "from", *function_name, ty);
             }
         }
     }
 }
 
-fn try_lint_endian_bytes(cx: &LateContext<'_>, expr: &Expr<'_>, prefix: &str, name: Symbol) -> bool {
+fn try_lint_endian_bytes(cx: &LateContext<'_>, expr: &Expr<'_>, prefix: &str, name: Symbol, ty: Ty<'_>) -> bool {
     let ne = format!("{prefix}_ne_bytes");
     let le = format!("{prefix}_le_bytes");
     let be = format!("{prefix}_be_bytes");
@@ -171,7 +174,7 @@ fn try_lint_endian_bytes(cx: &LateContext<'_>, expr: &Expr<'_>, prefix: &str, na
                 help_str.push_str("either of ");
             }
 
-            help_str.push_str(&format!("`{}` ", lint.to_name(prefix)));
+            help_str.push_str(&format!("`{ty}::{}` ", lint.to_name(prefix)));
 
             if i != len && !only_one {
                 help_str.push_str("or ");
@@ -185,7 +188,12 @@ fn try_lint_endian_bytes(cx: &LateContext<'_>, expr: &Expr<'_>, prefix: &str, na
         cx,
         lint.as_lint(),
         expr.span,
-        &format!("usage of the method `{}`", lint.to_name(prefix)),
+        &format!(
+            "usage of the {}`{ty}::{}`{}",
+            if prefix == "from" { "function " } else { "" },
+            lint.to_name(prefix),
+            if prefix == "to" { " method" } else { "" },
+        ),
         move |diag| {
             if let Some(help) = help {
                 diag.help(help);
diff --git a/tests/ui/endian_bytes.rs b/tests/ui/endian_bytes.rs
index ccee8e20a3c..6bf014fc809 100644
--- a/tests/ui/endian_bytes.rs
+++ b/tests/ui/endian_bytes.rs
@@ -65,7 +65,7 @@ macro_rules! fn_body {
 }
 
 // bless breaks if I use fn_body too much (oops)
-macro_rules! fn_body_small {
+macro_rules! fn_body_smol {
     () => {
         2u8.to_ne_bytes();
         u8::from_ne_bytes(todo!());
@@ -93,35 +93,35 @@ fn big() { fn_body!(); }
 #[rustfmt::skip]
 #[warn(clippy::host_endian_bytes)]
 #[warn(clippy::big_endian_bytes)]
-fn host_encourage_little() { fn_body_small!(); }
+fn host_encourage_little() { fn_body_smol!(); }
 
 #[rustfmt::skip]
 #[warn(clippy::host_endian_bytes)]
 #[warn(clippy::little_endian_bytes)]
-fn host_encourage_big() { fn_body_small!(); }
+fn host_encourage_big() { fn_body_smol!(); }
 
 #[rustfmt::skip]
 #[warn(clippy::host_endian_bytes)]
 #[warn(clippy::little_endian_bytes)]
 #[warn(clippy::big_endian_bytes)]
-fn no_help() { fn_body_small!(); }
+fn no_help() { fn_body_smol!(); }
 
 #[rustfmt::skip]
 #[warn(clippy::little_endian_bytes)]
 #[warn(clippy::big_endian_bytes)]
-fn little_encourage_host() { fn_body_small!(); }
+fn little_encourage_host() { fn_body_smol!(); }
 
 #[rustfmt::skip]
 #[warn(clippy::host_endian_bytes)]
 #[warn(clippy::little_endian_bytes)]
-fn little_encourage_big() { fn_body_small!(); }
+fn little_encourage_big() { fn_body_smol!(); }
 
 #[rustfmt::skip]
 #[warn(clippy::big_endian_bytes)]
 #[warn(clippy::little_endian_bytes)]
-fn big_encourage_host() { fn_body_small!(); }
+fn big_encourage_host() { fn_body_smol!(); }
 
 #[rustfmt::skip]
 #[warn(clippy::host_endian_bytes)]
 #[warn(clippy::big_endian_bytes)]
-fn big_encourage_little() { fn_body_small!(); }
+fn big_encourage_little() { fn_body_smol!(); }
diff --git a/tests/ui/endian_bytes.stderr b/tests/ui/endian_bytes.stderr
index ff8d1a98f4f..5e64ea5b5ab 100644
--- a/tests/ui/endian_bytes.stderr
+++ b/tests/ui/endian_bytes.stderr
@@ -1,4 +1,4 @@
-error: usage of the method `to_ne_bytes`
+error: usage of the `u8::to_ne_bytes` method
   --> $DIR/endian_bytes.rs:7:9
    |
 LL |         2u8.to_ne_bytes();
@@ -11,7 +11,7 @@ LL | fn host() { fn_body!(); }
    = note: `-D clippy::host-endian-bytes` implied by `-D warnings`
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `to_ne_bytes`
+error: usage of the `i8::to_ne_bytes` method
   --> $DIR/endian_bytes.rs:8:9
    |
 LL |         2i8.to_ne_bytes();
@@ -23,7 +23,7 @@ LL | fn host() { fn_body!(); }
    = help: specify the desired endianness explicitly
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `to_ne_bytes`
+error: usage of the `u16::to_ne_bytes` method
   --> $DIR/endian_bytes.rs:9:9
    |
 LL |         2u16.to_ne_bytes();
@@ -35,7 +35,7 @@ LL | fn host() { fn_body!(); }
    = help: specify the desired endianness explicitly
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `to_ne_bytes`
+error: usage of the `i16::to_ne_bytes` method
   --> $DIR/endian_bytes.rs:10:9
    |
 LL |         2i16.to_ne_bytes();
@@ -47,7 +47,7 @@ LL | fn host() { fn_body!(); }
    = help: specify the desired endianness explicitly
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `to_ne_bytes`
+error: usage of the `u32::to_ne_bytes` method
   --> $DIR/endian_bytes.rs:11:9
    |
 LL |         2u32.to_ne_bytes();
@@ -59,7 +59,7 @@ LL | fn host() { fn_body!(); }
    = help: specify the desired endianness explicitly
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `to_ne_bytes`
+error: usage of the `i32::to_ne_bytes` method
   --> $DIR/endian_bytes.rs:12:9
    |
 LL |         2i32.to_ne_bytes();
@@ -71,7 +71,7 @@ LL | fn host() { fn_body!(); }
    = help: specify the desired endianness explicitly
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `to_ne_bytes`
+error: usage of the `u64::to_ne_bytes` method
   --> $DIR/endian_bytes.rs:13:9
    |
 LL |         2u64.to_ne_bytes();
@@ -83,7 +83,7 @@ LL | fn host() { fn_body!(); }
    = help: specify the desired endianness explicitly
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `to_ne_bytes`
+error: usage of the `i64::to_ne_bytes` method
   --> $DIR/endian_bytes.rs:14:9
    |
 LL |         2i64.to_ne_bytes();
@@ -95,7 +95,7 @@ LL | fn host() { fn_body!(); }
    = help: specify the desired endianness explicitly
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `to_ne_bytes`
+error: usage of the `u128::to_ne_bytes` method
   --> $DIR/endian_bytes.rs:15:9
    |
 LL |         2u128.to_ne_bytes();
@@ -107,7 +107,7 @@ LL | fn host() { fn_body!(); }
    = help: specify the desired endianness explicitly
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `to_ne_bytes`
+error: usage of the `i128::to_ne_bytes` method
   --> $DIR/endian_bytes.rs:16:9
    |
 LL |         2i128.to_ne_bytes();
@@ -119,7 +119,7 @@ LL | fn host() { fn_body!(); }
    = help: specify the desired endianness explicitly
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `to_ne_bytes`
+error: usage of the `f32::to_ne_bytes` method
   --> $DIR/endian_bytes.rs:17:9
    |
 LL |         2.0f32.to_ne_bytes();
@@ -131,7 +131,7 @@ LL | fn host() { fn_body!(); }
    = help: specify the desired endianness explicitly
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `to_ne_bytes`
+error: usage of the `f64::to_ne_bytes` method
   --> $DIR/endian_bytes.rs:18:9
    |
 LL |         2.0f64.to_ne_bytes();
@@ -143,7 +143,7 @@ LL | fn host() { fn_body!(); }
    = help: specify the desired endianness explicitly
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `to_ne_bytes`
+error: usage of the `usize::to_ne_bytes` method
   --> $DIR/endian_bytes.rs:19:9
    |
 LL |         2usize.to_ne_bytes();
@@ -155,7 +155,7 @@ LL | fn host() { fn_body!(); }
    = help: specify the desired endianness explicitly
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `to_ne_bytes`
+error: usage of the `isize::to_ne_bytes` method
   --> $DIR/endian_bytes.rs:20:9
    |
 LL |         2isize.to_ne_bytes();
@@ -167,7 +167,7 @@ LL | fn host() { fn_body!(); }
    = help: specify the desired endianness explicitly
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `from_ne_bytes`
+error: usage of the function `u8::from_ne_bytes`
   --> $DIR/endian_bytes.rs:21:9
    |
 LL |         u8::from_ne_bytes(todo!());
@@ -179,7 +179,7 @@ LL | fn host() { fn_body!(); }
    = help: specify the desired endianness explicitly
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `from_ne_bytes`
+error: usage of the function `i8::from_ne_bytes`
   --> $DIR/endian_bytes.rs:22:9
    |
 LL |         i8::from_ne_bytes(todo!());
@@ -191,7 +191,7 @@ LL | fn host() { fn_body!(); }
    = help: specify the desired endianness explicitly
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `from_ne_bytes`
+error: usage of the function `u16::from_ne_bytes`
   --> $DIR/endian_bytes.rs:23:9
    |
 LL |         u16::from_ne_bytes(todo!());
@@ -203,7 +203,7 @@ LL | fn host() { fn_body!(); }
    = help: specify the desired endianness explicitly
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `from_ne_bytes`
+error: usage of the function `i16::from_ne_bytes`
   --> $DIR/endian_bytes.rs:24:9
    |
 LL |         i16::from_ne_bytes(todo!());
@@ -215,7 +215,7 @@ LL | fn host() { fn_body!(); }
    = help: specify the desired endianness explicitly
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `from_ne_bytes`
+error: usage of the function `u32::from_ne_bytes`
   --> $DIR/endian_bytes.rs:25:9
    |
 LL |         u32::from_ne_bytes(todo!());
@@ -227,7 +227,7 @@ LL | fn host() { fn_body!(); }
    = help: specify the desired endianness explicitly
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `from_ne_bytes`
+error: usage of the function `i32::from_ne_bytes`
   --> $DIR/endian_bytes.rs:26:9
    |
 LL |         i32::from_ne_bytes(todo!());
@@ -239,7 +239,7 @@ LL | fn host() { fn_body!(); }
    = help: specify the desired endianness explicitly
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `from_ne_bytes`
+error: usage of the function `u64::from_ne_bytes`
   --> $DIR/endian_bytes.rs:27:9
    |
 LL |         u64::from_ne_bytes(todo!());
@@ -251,7 +251,7 @@ LL | fn host() { fn_body!(); }
    = help: specify the desired endianness explicitly
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `from_ne_bytes`
+error: usage of the function `i64::from_ne_bytes`
   --> $DIR/endian_bytes.rs:28:9
    |
 LL |         i64::from_ne_bytes(todo!());
@@ -263,7 +263,7 @@ LL | fn host() { fn_body!(); }
    = help: specify the desired endianness explicitly
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `from_ne_bytes`
+error: usage of the function `u128::from_ne_bytes`
   --> $DIR/endian_bytes.rs:29:9
    |
 LL |         u128::from_ne_bytes(todo!());
@@ -275,7 +275,7 @@ LL | fn host() { fn_body!(); }
    = help: specify the desired endianness explicitly
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `from_ne_bytes`
+error: usage of the function `i128::from_ne_bytes`
   --> $DIR/endian_bytes.rs:30:9
    |
 LL |         i128::from_ne_bytes(todo!());
@@ -287,7 +287,7 @@ LL | fn host() { fn_body!(); }
    = help: specify the desired endianness explicitly
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `from_ne_bytes`
+error: usage of the function `usize::from_ne_bytes`
   --> $DIR/endian_bytes.rs:31:9
    |
 LL |         usize::from_ne_bytes(todo!());
@@ -299,7 +299,7 @@ LL | fn host() { fn_body!(); }
    = help: specify the desired endianness explicitly
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `from_ne_bytes`
+error: usage of the function `isize::from_ne_bytes`
   --> $DIR/endian_bytes.rs:32:9
    |
 LL |         isize::from_ne_bytes(todo!());
@@ -311,7 +311,7 @@ LL | fn host() { fn_body!(); }
    = help: specify the desired endianness explicitly
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `from_ne_bytes`
+error: usage of the function `f32::from_ne_bytes`
   --> $DIR/endian_bytes.rs:33:9
    |
 LL |         f32::from_ne_bytes(todo!());
@@ -323,7 +323,7 @@ LL | fn host() { fn_body!(); }
    = help: specify the desired endianness explicitly
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `from_ne_bytes`
+error: usage of the function `f64::from_ne_bytes`
   --> $DIR/endian_bytes.rs:34:9
    |
 LL |         f64::from_ne_bytes(todo!());
@@ -335,7 +335,7 @@ LL | fn host() { fn_body!(); }
    = help: specify the desired endianness explicitly
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `to_le_bytes`
+error: usage of the `u8::to_le_bytes` method
   --> $DIR/endian_bytes.rs:36:9
    |
 LL |         2u8.to_le_bytes();
@@ -348,7 +348,7 @@ LL | fn little() { fn_body!(); }
    = note: `-D clippy::little-endian-bytes` implied by `-D warnings`
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `to_le_bytes`
+error: usage of the `i8::to_le_bytes` method
   --> $DIR/endian_bytes.rs:37:9
    |
 LL |         2i8.to_le_bytes();
@@ -360,7 +360,7 @@ LL | fn little() { fn_body!(); }
    = help: use the native endianness instead
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `to_le_bytes`
+error: usage of the `u16::to_le_bytes` method
   --> $DIR/endian_bytes.rs:38:9
    |
 LL |         2u16.to_le_bytes();
@@ -372,7 +372,7 @@ LL | fn little() { fn_body!(); }
    = help: use the native endianness instead
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `to_le_bytes`
+error: usage of the `i16::to_le_bytes` method
   --> $DIR/endian_bytes.rs:39:9
    |
 LL |         2i16.to_le_bytes();
@@ -384,7 +384,7 @@ LL | fn little() { fn_body!(); }
    = help: use the native endianness instead
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `to_le_bytes`
+error: usage of the `u32::to_le_bytes` method
   --> $DIR/endian_bytes.rs:40:9
    |
 LL |         2u32.to_le_bytes();
@@ -396,7 +396,7 @@ LL | fn little() { fn_body!(); }
    = help: use the native endianness instead
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `to_le_bytes`
+error: usage of the `i32::to_le_bytes` method
   --> $DIR/endian_bytes.rs:41:9
    |
 LL |         2i32.to_le_bytes();
@@ -408,7 +408,7 @@ LL | fn little() { fn_body!(); }
    = help: use the native endianness instead
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `to_le_bytes`
+error: usage of the `u64::to_le_bytes` method
   --> $DIR/endian_bytes.rs:42:9
    |
 LL |         2u64.to_le_bytes();
@@ -420,7 +420,7 @@ LL | fn little() { fn_body!(); }
    = help: use the native endianness instead
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `to_le_bytes`
+error: usage of the `i64::to_le_bytes` method
   --> $DIR/endian_bytes.rs:43:9
    |
 LL |         2i64.to_le_bytes();
@@ -432,7 +432,7 @@ LL | fn little() { fn_body!(); }
    = help: use the native endianness instead
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `to_le_bytes`
+error: usage of the `u128::to_le_bytes` method
   --> $DIR/endian_bytes.rs:44:9
    |
 LL |         2u128.to_le_bytes();
@@ -444,7 +444,7 @@ LL | fn little() { fn_body!(); }
    = help: use the native endianness instead
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `to_le_bytes`
+error: usage of the `i128::to_le_bytes` method
   --> $DIR/endian_bytes.rs:45:9
    |
 LL |         2i128.to_le_bytes();
@@ -456,7 +456,7 @@ LL | fn little() { fn_body!(); }
    = help: use the native endianness instead
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `to_le_bytes`
+error: usage of the `f32::to_le_bytes` method
   --> $DIR/endian_bytes.rs:46:9
    |
 LL |         2.0f32.to_le_bytes();
@@ -468,7 +468,7 @@ LL | fn little() { fn_body!(); }
    = help: use the native endianness instead
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `to_le_bytes`
+error: usage of the `f64::to_le_bytes` method
   --> $DIR/endian_bytes.rs:47:9
    |
 LL |         2.0f64.to_le_bytes();
@@ -480,7 +480,7 @@ LL | fn little() { fn_body!(); }
    = help: use the native endianness instead
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `to_le_bytes`
+error: usage of the `usize::to_le_bytes` method
   --> $DIR/endian_bytes.rs:48:9
    |
 LL |         2usize.to_le_bytes();
@@ -492,7 +492,7 @@ LL | fn little() { fn_body!(); }
    = help: use the native endianness instead
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `to_le_bytes`
+error: usage of the `isize::to_le_bytes` method
   --> $DIR/endian_bytes.rs:49:9
    |
 LL |         2isize.to_le_bytes();
@@ -504,7 +504,7 @@ LL | fn little() { fn_body!(); }
    = help: use the native endianness instead
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `from_le_bytes`
+error: usage of the function `u8::from_le_bytes`
   --> $DIR/endian_bytes.rs:50:9
    |
 LL |         u8::from_le_bytes(todo!());
@@ -516,7 +516,7 @@ LL | fn little() { fn_body!(); }
    = help: use the native endianness instead
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `from_le_bytes`
+error: usage of the function `i8::from_le_bytes`
   --> $DIR/endian_bytes.rs:51:9
    |
 LL |         i8::from_le_bytes(todo!());
@@ -528,7 +528,7 @@ LL | fn little() { fn_body!(); }
    = help: use the native endianness instead
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `from_le_bytes`
+error: usage of the function `u16::from_le_bytes`
   --> $DIR/endian_bytes.rs:52:9
    |
 LL |         u16::from_le_bytes(todo!());
@@ -540,7 +540,7 @@ LL | fn little() { fn_body!(); }
    = help: use the native endianness instead
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `from_le_bytes`
+error: usage of the function `i16::from_le_bytes`
   --> $DIR/endian_bytes.rs:53:9
    |
 LL |         i16::from_le_bytes(todo!());
@@ -552,7 +552,7 @@ LL | fn little() { fn_body!(); }
    = help: use the native endianness instead
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `from_le_bytes`
+error: usage of the function `u32::from_le_bytes`
   --> $DIR/endian_bytes.rs:54:9
    |
 LL |         u32::from_le_bytes(todo!());
@@ -564,7 +564,7 @@ LL | fn little() { fn_body!(); }
    = help: use the native endianness instead
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `from_le_bytes`
+error: usage of the function `i32::from_le_bytes`
   --> $DIR/endian_bytes.rs:55:9
    |
 LL |         i32::from_le_bytes(todo!());
@@ -576,7 +576,7 @@ LL | fn little() { fn_body!(); }
    = help: use the native endianness instead
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `from_le_bytes`
+error: usage of the function `u64::from_le_bytes`
   --> $DIR/endian_bytes.rs:56:9
    |
 LL |         u64::from_le_bytes(todo!());
@@ -588,7 +588,7 @@ LL | fn little() { fn_body!(); }
    = help: use the native endianness instead
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `from_le_bytes`
+error: usage of the function `i64::from_le_bytes`
   --> $DIR/endian_bytes.rs:57:9
    |
 LL |         i64::from_le_bytes(todo!());
@@ -600,7 +600,7 @@ LL | fn little() { fn_body!(); }
    = help: use the native endianness instead
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `from_le_bytes`
+error: usage of the function `u128::from_le_bytes`
   --> $DIR/endian_bytes.rs:58:9
    |
 LL |         u128::from_le_bytes(todo!());
@@ -612,7 +612,7 @@ LL | fn little() { fn_body!(); }
    = help: use the native endianness instead
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `from_le_bytes`
+error: usage of the function `i128::from_le_bytes`
   --> $DIR/endian_bytes.rs:59:9
    |
 LL |         i128::from_le_bytes(todo!());
@@ -624,7 +624,7 @@ LL | fn little() { fn_body!(); }
    = help: use the native endianness instead
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `from_le_bytes`
+error: usage of the function `usize::from_le_bytes`
   --> $DIR/endian_bytes.rs:60:9
    |
 LL |         usize::from_le_bytes(todo!());
@@ -636,7 +636,7 @@ LL | fn little() { fn_body!(); }
    = help: use the native endianness instead
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `from_le_bytes`
+error: usage of the function `isize::from_le_bytes`
   --> $DIR/endian_bytes.rs:61:9
    |
 LL |         isize::from_le_bytes(todo!());
@@ -648,7 +648,7 @@ LL | fn little() { fn_body!(); }
    = help: use the native endianness instead
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `from_le_bytes`
+error: usage of the function `f32::from_le_bytes`
   --> $DIR/endian_bytes.rs:62:9
    |
 LL |         f32::from_le_bytes(todo!());
@@ -660,7 +660,7 @@ LL | fn little() { fn_body!(); }
    = help: use the native endianness instead
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `from_le_bytes`
+error: usage of the function `f64::from_le_bytes`
   --> $DIR/endian_bytes.rs:63:9
    |
 LL |         f64::from_le_bytes(todo!());
@@ -672,360 +672,360 @@ LL | fn little() { fn_body!(); }
    = help: use the native endianness instead
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `to_ne_bytes`
+error: usage of the `u8::to_ne_bytes` method
   --> $DIR/endian_bytes.rs:70:9
    |
 LL |         2u8.to_ne_bytes();
    |         ^^^^^^^^^^^^^^^^^
 ...
-LL | fn host_encourage_little() { fn_body_small!(); }
-   |                              ---------------- in this macro invocation
+LL | fn host_encourage_little() { fn_body_smol!(); }
+   |                              --------------- in this macro invocation
    |
-   = help: use `to_le_bytes` instead
-   = note: this error originates in the macro `fn_body_small` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = help: use `u8::to_le_bytes` instead
+   = note: this error originates in the macro `fn_body_smol` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `from_ne_bytes`
+error: usage of the function `u8::from_ne_bytes`
   --> $DIR/endian_bytes.rs:71:9
    |
 LL |         u8::from_ne_bytes(todo!());
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
 ...
-LL | fn host_encourage_little() { fn_body_small!(); }
-   |                              ---------------- in this macro invocation
+LL | fn host_encourage_little() { fn_body_smol!(); }
+   |                              --------------- in this macro invocation
    |
-   = help: use `from_le_bytes` instead
-   = note: this error originates in the macro `fn_body_small` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = help: use `u8::from_le_bytes` instead
+   = note: this error originates in the macro `fn_body_smol` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `to_be_bytes`
+error: usage of the `u8::to_be_bytes` method
   --> $DIR/endian_bytes.rs:76:9
    |
 LL |         2u8.to_be_bytes();
    |         ^^^^^^^^^^^^^^^^^
 ...
-LL | fn host_encourage_little() { fn_body_small!(); }
-   |                              ---------------- in this macro invocation
+LL | fn host_encourage_little() { fn_body_smol!(); }
+   |                              --------------- in this macro invocation
    |
-   = help: use `to_le_bytes` instead
+   = help: use `u8::to_le_bytes` instead
    = note: `-D clippy::big-endian-bytes` implied by `-D warnings`
-   = note: this error originates in the macro `fn_body_small` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = note: this error originates in the macro `fn_body_smol` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `from_be_bytes`
+error: usage of the function `u8::from_be_bytes`
   --> $DIR/endian_bytes.rs:77:9
    |
 LL |         u8::from_be_bytes(todo!());
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
 ...
-LL | fn host_encourage_little() { fn_body_small!(); }
-   |                              ---------------- in this macro invocation
+LL | fn host_encourage_little() { fn_body_smol!(); }
+   |                              --------------- in this macro invocation
    |
-   = help: use `from_le_bytes` instead
-   = note: this error originates in the macro `fn_body_small` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = help: use `u8::from_le_bytes` instead
+   = note: this error originates in the macro `fn_body_smol` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `to_ne_bytes`
+error: usage of the `u8::to_ne_bytes` method
   --> $DIR/endian_bytes.rs:70:9
    |
 LL |         2u8.to_ne_bytes();
    |         ^^^^^^^^^^^^^^^^^
 ...
-LL | fn host_encourage_big() { fn_body_small!(); }
-   |                           ---------------- in this macro invocation
+LL | fn host_encourage_big() { fn_body_smol!(); }
+   |                           --------------- in this macro invocation
    |
-   = help: use `to_be_bytes` instead
-   = note: this error originates in the macro `fn_body_small` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = help: use `u8::to_be_bytes` instead
+   = note: this error originates in the macro `fn_body_smol` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `from_ne_bytes`
+error: usage of the function `u8::from_ne_bytes`
   --> $DIR/endian_bytes.rs:71:9
    |
 LL |         u8::from_ne_bytes(todo!());
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
 ...
-LL | fn host_encourage_big() { fn_body_small!(); }
-   |                           ---------------- in this macro invocation
+LL | fn host_encourage_big() { fn_body_smol!(); }
+   |                           --------------- in this macro invocation
    |
-   = help: use `from_be_bytes` instead
-   = note: this error originates in the macro `fn_body_small` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = help: use `u8::from_be_bytes` instead
+   = note: this error originates in the macro `fn_body_smol` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `to_le_bytes`
+error: usage of the `u8::to_le_bytes` method
   --> $DIR/endian_bytes.rs:73:9
    |
 LL |         2u8.to_le_bytes();
    |         ^^^^^^^^^^^^^^^^^
 ...
-LL | fn host_encourage_big() { fn_body_small!(); }
-   |                           ---------------- in this macro invocation
+LL | fn host_encourage_big() { fn_body_smol!(); }
+   |                           --------------- in this macro invocation
    |
-   = help: use `to_be_bytes` instead
-   = note: this error originates in the macro `fn_body_small` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = help: use `u8::to_be_bytes` instead
+   = note: this error originates in the macro `fn_body_smol` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `from_le_bytes`
+error: usage of the function `u8::from_le_bytes`
   --> $DIR/endian_bytes.rs:74:9
    |
 LL |         u8::from_le_bytes(todo!());
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
 ...
-LL | fn host_encourage_big() { fn_body_small!(); }
-   |                           ---------------- in this macro invocation
+LL | fn host_encourage_big() { fn_body_smol!(); }
+   |                           --------------- in this macro invocation
    |
-   = help: use `from_be_bytes` instead
-   = note: this error originates in the macro `fn_body_small` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = help: use `u8::from_be_bytes` instead
+   = note: this error originates in the macro `fn_body_smol` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `to_ne_bytes`
+error: usage of the `u8::to_ne_bytes` method
   --> $DIR/endian_bytes.rs:70:9
    |
 LL |         2u8.to_ne_bytes();
    |         ^^^^^^^^^^^^^^^^^
 ...
-LL | fn no_help() { fn_body_small!(); }
-   |                ---------------- in this macro invocation
+LL | fn no_help() { fn_body_smol!(); }
+   |                --------------- in this macro invocation
    |
-   = note: this error originates in the macro `fn_body_small` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = note: this error originates in the macro `fn_body_smol` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `from_ne_bytes`
+error: usage of the function `u8::from_ne_bytes`
   --> $DIR/endian_bytes.rs:71:9
    |
 LL |         u8::from_ne_bytes(todo!());
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
 ...
-LL | fn no_help() { fn_body_small!(); }
-   |                ---------------- in this macro invocation
+LL | fn no_help() { fn_body_smol!(); }
+   |                --------------- in this macro invocation
    |
-   = note: this error originates in the macro `fn_body_small` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = note: this error originates in the macro `fn_body_smol` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `to_le_bytes`
+error: usage of the `u8::to_le_bytes` method
   --> $DIR/endian_bytes.rs:73:9
    |
 LL |         2u8.to_le_bytes();
    |         ^^^^^^^^^^^^^^^^^
 ...
-LL | fn no_help() { fn_body_small!(); }
-   |                ---------------- in this macro invocation
+LL | fn no_help() { fn_body_smol!(); }
+   |                --------------- in this macro invocation
    |
-   = note: this error originates in the macro `fn_body_small` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = note: this error originates in the macro `fn_body_smol` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `from_le_bytes`
+error: usage of the function `u8::from_le_bytes`
   --> $DIR/endian_bytes.rs:74:9
    |
 LL |         u8::from_le_bytes(todo!());
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
 ...
-LL | fn no_help() { fn_body_small!(); }
-   |                ---------------- in this macro invocation
+LL | fn no_help() { fn_body_smol!(); }
+   |                --------------- in this macro invocation
    |
-   = note: this error originates in the macro `fn_body_small` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = note: this error originates in the macro `fn_body_smol` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `to_be_bytes`
+error: usage of the `u8::to_be_bytes` method
   --> $DIR/endian_bytes.rs:76:9
    |
 LL |         2u8.to_be_bytes();
    |         ^^^^^^^^^^^^^^^^^
 ...
-LL | fn no_help() { fn_body_small!(); }
-   |                ---------------- in this macro invocation
+LL | fn no_help() { fn_body_smol!(); }
+   |                --------------- in this macro invocation
    |
-   = note: this error originates in the macro `fn_body_small` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = note: this error originates in the macro `fn_body_smol` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `from_be_bytes`
+error: usage of the function `u8::from_be_bytes`
   --> $DIR/endian_bytes.rs:77:9
    |
 LL |         u8::from_be_bytes(todo!());
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
 ...
-LL | fn no_help() { fn_body_small!(); }
-   |                ---------------- in this macro invocation
+LL | fn no_help() { fn_body_smol!(); }
+   |                --------------- in this macro invocation
    |
-   = note: this error originates in the macro `fn_body_small` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = note: this error originates in the macro `fn_body_smol` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `to_le_bytes`
+error: usage of the `u8::to_le_bytes` method
   --> $DIR/endian_bytes.rs:73:9
    |
 LL |         2u8.to_le_bytes();
    |         ^^^^^^^^^^^^^^^^^
 ...
-LL | fn little_encourage_host() { fn_body_small!(); }
-   |                              ---------------- in this macro invocation
+LL | fn little_encourage_host() { fn_body_smol!(); }
+   |                              --------------- in this macro invocation
    |
    = help: use the native endianness instead
-   = note: this error originates in the macro `fn_body_small` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = note: this error originates in the macro `fn_body_smol` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `from_le_bytes`
+error: usage of the function `u8::from_le_bytes`
   --> $DIR/endian_bytes.rs:74:9
    |
 LL |         u8::from_le_bytes(todo!());
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
 ...
-LL | fn little_encourage_host() { fn_body_small!(); }
-   |                              ---------------- in this macro invocation
+LL | fn little_encourage_host() { fn_body_smol!(); }
+   |                              --------------- in this macro invocation
    |
    = help: use the native endianness instead
-   = note: this error originates in the macro `fn_body_small` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = note: this error originates in the macro `fn_body_smol` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `to_be_bytes`
+error: usage of the `u8::to_be_bytes` method
   --> $DIR/endian_bytes.rs:76:9
    |
 LL |         2u8.to_be_bytes();
    |         ^^^^^^^^^^^^^^^^^
 ...
-LL | fn little_encourage_host() { fn_body_small!(); }
-   |                              ---------------- in this macro invocation
+LL | fn little_encourage_host() { fn_body_smol!(); }
+   |                              --------------- in this macro invocation
    |
    = help: use the native endianness instead
-   = note: this error originates in the macro `fn_body_small` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = note: this error originates in the macro `fn_body_smol` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `from_be_bytes`
+error: usage of the function `u8::from_be_bytes`
   --> $DIR/endian_bytes.rs:77:9
    |
 LL |         u8::from_be_bytes(todo!());
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
 ...
-LL | fn little_encourage_host() { fn_body_small!(); }
-   |                              ---------------- in this macro invocation
+LL | fn little_encourage_host() { fn_body_smol!(); }
+   |                              --------------- in this macro invocation
    |
    = help: use the native endianness instead
-   = note: this error originates in the macro `fn_body_small` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = note: this error originates in the macro `fn_body_smol` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `to_ne_bytes`
+error: usage of the `u8::to_ne_bytes` method
   --> $DIR/endian_bytes.rs:70:9
    |
 LL |         2u8.to_ne_bytes();
    |         ^^^^^^^^^^^^^^^^^
 ...
-LL | fn little_encourage_big() { fn_body_small!(); }
-   |                             ---------------- in this macro invocation
+LL | fn little_encourage_big() { fn_body_smol!(); }
+   |                             --------------- in this macro invocation
    |
-   = help: use `to_be_bytes` instead
-   = note: this error originates in the macro `fn_body_small` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = help: use `u8::to_be_bytes` instead
+   = note: this error originates in the macro `fn_body_smol` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `from_ne_bytes`
+error: usage of the function `u8::from_ne_bytes`
   --> $DIR/endian_bytes.rs:71:9
    |
 LL |         u8::from_ne_bytes(todo!());
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
 ...
-LL | fn little_encourage_big() { fn_body_small!(); }
-   |                             ---------------- in this macro invocation
+LL | fn little_encourage_big() { fn_body_smol!(); }
+   |                             --------------- in this macro invocation
    |
-   = help: use `from_be_bytes` instead
-   = note: this error originates in the macro `fn_body_small` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = help: use `u8::from_be_bytes` instead
+   = note: this error originates in the macro `fn_body_smol` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `to_le_bytes`
+error: usage of the `u8::to_le_bytes` method
   --> $DIR/endian_bytes.rs:73:9
    |
 LL |         2u8.to_le_bytes();
    |         ^^^^^^^^^^^^^^^^^
 ...
-LL | fn little_encourage_big() { fn_body_small!(); }
-   |                             ---------------- in this macro invocation
+LL | fn little_encourage_big() { fn_body_smol!(); }
+   |                             --------------- in this macro invocation
    |
-   = help: use `to_be_bytes` instead
-   = note: this error originates in the macro `fn_body_small` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = help: use `u8::to_be_bytes` instead
+   = note: this error originates in the macro `fn_body_smol` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `from_le_bytes`
+error: usage of the function `u8::from_le_bytes`
   --> $DIR/endian_bytes.rs:74:9
    |
 LL |         u8::from_le_bytes(todo!());
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
 ...
-LL | fn little_encourage_big() { fn_body_small!(); }
-   |                             ---------------- in this macro invocation
+LL | fn little_encourage_big() { fn_body_smol!(); }
+   |                             --------------- in this macro invocation
    |
-   = help: use `from_be_bytes` instead
-   = note: this error originates in the macro `fn_body_small` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = help: use `u8::from_be_bytes` instead
+   = note: this error originates in the macro `fn_body_smol` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `to_le_bytes`
+error: usage of the `u8::to_le_bytes` method
   --> $DIR/endian_bytes.rs:73:9
    |
 LL |         2u8.to_le_bytes();
    |         ^^^^^^^^^^^^^^^^^
 ...
-LL | fn big_encourage_host() { fn_body_small!(); }
-   |                           ---------------- in this macro invocation
+LL | fn big_encourage_host() { fn_body_smol!(); }
+   |                           --------------- in this macro invocation
    |
    = help: use the native endianness instead
-   = note: this error originates in the macro `fn_body_small` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = note: this error originates in the macro `fn_body_smol` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `from_le_bytes`
+error: usage of the function `u8::from_le_bytes`
   --> $DIR/endian_bytes.rs:74:9
    |
 LL |         u8::from_le_bytes(todo!());
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
 ...
-LL | fn big_encourage_host() { fn_body_small!(); }
-   |                           ---------------- in this macro invocation
+LL | fn big_encourage_host() { fn_body_smol!(); }
+   |                           --------------- in this macro invocation
    |
    = help: use the native endianness instead
-   = note: this error originates in the macro `fn_body_small` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = note: this error originates in the macro `fn_body_smol` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `to_be_bytes`
+error: usage of the `u8::to_be_bytes` method
   --> $DIR/endian_bytes.rs:76:9
    |
 LL |         2u8.to_be_bytes();
    |         ^^^^^^^^^^^^^^^^^
 ...
-LL | fn big_encourage_host() { fn_body_small!(); }
-   |                           ---------------- in this macro invocation
+LL | fn big_encourage_host() { fn_body_smol!(); }
+   |                           --------------- in this macro invocation
    |
    = help: use the native endianness instead
-   = note: this error originates in the macro `fn_body_small` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = note: this error originates in the macro `fn_body_smol` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `from_be_bytes`
+error: usage of the function `u8::from_be_bytes`
   --> $DIR/endian_bytes.rs:77:9
    |
 LL |         u8::from_be_bytes(todo!());
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
 ...
-LL | fn big_encourage_host() { fn_body_small!(); }
-   |                           ---------------- in this macro invocation
+LL | fn big_encourage_host() { fn_body_smol!(); }
+   |                           --------------- in this macro invocation
    |
    = help: use the native endianness instead
-   = note: this error originates in the macro `fn_body_small` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = note: this error originates in the macro `fn_body_smol` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `to_ne_bytes`
+error: usage of the `u8::to_ne_bytes` method
   --> $DIR/endian_bytes.rs:70:9
    |
 LL |         2u8.to_ne_bytes();
    |         ^^^^^^^^^^^^^^^^^
 ...
-LL | fn big_encourage_little() { fn_body_small!(); }
-   |                             ---------------- in this macro invocation
+LL | fn big_encourage_little() { fn_body_smol!(); }
+   |                             --------------- in this macro invocation
    |
-   = help: use `to_le_bytes` instead
-   = note: this error originates in the macro `fn_body_small` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = help: use `u8::to_le_bytes` instead
+   = note: this error originates in the macro `fn_body_smol` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `from_ne_bytes`
+error: usage of the function `u8::from_ne_bytes`
   --> $DIR/endian_bytes.rs:71:9
    |
 LL |         u8::from_ne_bytes(todo!());
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
 ...
-LL | fn big_encourage_little() { fn_body_small!(); }
-   |                             ---------------- in this macro invocation
+LL | fn big_encourage_little() { fn_body_smol!(); }
+   |                             --------------- in this macro invocation
    |
-   = help: use `from_le_bytes` instead
-   = note: this error originates in the macro `fn_body_small` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = help: use `u8::from_le_bytes` instead
+   = note: this error originates in the macro `fn_body_smol` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `to_be_bytes`
+error: usage of the `u8::to_be_bytes` method
   --> $DIR/endian_bytes.rs:76:9
    |
 LL |         2u8.to_be_bytes();
    |         ^^^^^^^^^^^^^^^^^
 ...
-LL | fn big_encourage_little() { fn_body_small!(); }
-   |                             ---------------- in this macro invocation
+LL | fn big_encourage_little() { fn_body_smol!(); }
+   |                             --------------- in this macro invocation
    |
-   = help: use `to_le_bytes` instead
-   = note: this error originates in the macro `fn_body_small` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = help: use `u8::to_le_bytes` instead
+   = note: this error originates in the macro `fn_body_smol` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: usage of the method `from_be_bytes`
+error: usage of the function `u8::from_be_bytes`
   --> $DIR/endian_bytes.rs:77:9
    |
 LL |         u8::from_be_bytes(todo!());
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
 ...
-LL | fn big_encourage_little() { fn_body_small!(); }
-   |                             ---------------- in this macro invocation
+LL | fn big_encourage_little() { fn_body_smol!(); }
+   |                             --------------- in this macro invocation
    |
-   = help: use `from_le_bytes` instead
-   = note: this error originates in the macro `fn_body_small` (in Nightly builds, run with -Z macro-backtrace for more info)
+   = help: use `u8::from_le_bytes` instead
+   = note: this error originates in the macro `fn_body_smol` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: aborting due to 86 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 80ae1ec12d6aa7d5cec840387c14a196296b983c Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Thu, 25 May 2023 11:43:14 -0500
Subject: unidiomatic `if_chain!`

---
 clippy_lints/src/endian_bytes.rs | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/endian_bytes.rs b/clippy_lints/src/endian_bytes.rs
index 434125932c4..05005a791c2 100644
--- a/clippy_lints/src/endian_bytes.rs
+++ b/clippy_lints/src/endian_bytes.rs
@@ -105,10 +105,9 @@ impl LateLintPass<'_> for EndianBytes {
             if args.is_empty();
             let ty = cx.typeck_results().expr_ty(receiver);
             if ty.is_primitive_ty();
+            if try_lint_endian_bytes(cx, expr, "to", method_name.ident.name, ty);
             then {
-                if try_lint_endian_bytes(cx, expr, "to", method_name.ident.name, ty) {
-                    return;
-                }
+                return;
             }
         }
 
-- 
cgit 1.4.1-3-g733a5


From 95e8c0b35a0963aa998aa68d9c74cdb2c5a5e6ab Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Wed, 31 May 2023 17:29:18 -0500
Subject: don't allocate the names

---
 clippy_lints/src/endian_bytes.rs | 48 +++++++++++++++++++++++++++++-----------
 1 file changed, 35 insertions(+), 13 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/endian_bytes.rs b/clippy_lints/src/endian_bytes.rs
index 05005a791c2..19fb74b9050 100644
--- a/clippy_lints/src/endian_bytes.rs
+++ b/clippy_lints/src/endian_bytes.rs
@@ -9,7 +9,7 @@ use std::borrow::Cow;
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for the usage of the `to_ne_bytes` method.
+    /// Checks for the usage of the `to_ne_bytes` method and/or the function `from_ne_bytes`.
     ///
     /// ### Why is this bad?
     /// It's not, but some may prefer to specify the target endianness explicitly.
@@ -27,7 +27,7 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for the usage of the `to_le_bytes` method.
+    /// Checks for the usage of the `to_le_bytes` method and/or the function `from_le_bytes`.
     ///
     /// ### Why is this bad?
     /// It's not, but some may wish to lint usage of this method, either to suggest using the host
@@ -46,7 +46,7 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for the usage of the `to_be_bytes` method.
+    /// Checks for the usage of the `to_be_bytes` method and/or the function `from_be_bytes`.
     ///
     /// ### Why is this bad?
     /// It's not, but some may wish to lint usage of this method, either to suggest using the host
@@ -65,6 +65,10 @@ declare_clippy_lint! {
 
 declare_lint_pass!(EndianBytes => [HOST_ENDIAN_BYTES, LITTLE_ENDIAN_BYTES, BIG_ENDIAN_BYTES]);
 
+const HOST_NAMES: [&str; 2] = ["from_ne_bytes", "to_ne_bytes"];
+const LITTLE_NAMES: [&str; 2] = ["from_le_bytes", "to_le_bytes"];
+const BIG_NAMES: [&str; 2] = ["from_be_bytes", "to_be_bytes"];
+
 #[derive(Clone, Debug)]
 enum LintKind {
     Host,
@@ -85,11 +89,29 @@ impl LintKind {
         }
     }
 
-    fn to_name(&self, prefix: &str) -> String {
+    fn to_name(&self, prefix: &str) -> &str {
         match self {
-            LintKind::Host => format!("{prefix}_ne_bytes"),
-            LintKind::Little => format!("{prefix}_le_bytes"),
-            LintKind::Big => format!("{prefix}_be_bytes"),
+            LintKind::Host => {
+                if prefix == "from" {
+                    HOST_NAMES[0]
+                } else {
+                    HOST_NAMES[1]
+                }
+            },
+            LintKind::Little => {
+                if prefix == "from" {
+                    LITTLE_NAMES[0]
+                } else {
+                    LITTLE_NAMES[1]
+                }
+            },
+            LintKind::Big => {
+                if prefix == "from" {
+                    BIG_NAMES[0]
+                } else {
+                    BIG_NAMES[1]
+                }
+            },
         }
     }
 }
@@ -105,7 +127,7 @@ impl LateLintPass<'_> for EndianBytes {
             if args.is_empty();
             let ty = cx.typeck_results().expr_ty(receiver);
             if ty.is_primitive_ty();
-            if try_lint_endian_bytes(cx, expr, "to", method_name.ident.name, ty);
+            if maybe_lint_endian_bytes(cx, expr, "to", method_name.ident.name, ty);
             then {
                 return;
             }
@@ -119,16 +141,16 @@ impl LateLintPass<'_> for EndianBytes {
             let ty = cx.typeck_results().expr_ty(expr);
             if ty.is_primitive_ty();
             then {
-                try_lint_endian_bytes(cx, expr, "from", *function_name, ty);
+                maybe_lint_endian_bytes(cx, expr, "from", *function_name, ty);
             }
         }
     }
 }
 
-fn try_lint_endian_bytes(cx: &LateContext<'_>, expr: &Expr<'_>, prefix: &str, name: Symbol, ty: Ty<'_>) -> bool {
-    let ne = format!("{prefix}_ne_bytes");
-    let le = format!("{prefix}_le_bytes");
-    let be = format!("{prefix}_be_bytes");
+fn maybe_lint_endian_bytes(cx: &LateContext<'_>, expr: &Expr<'_>, prefix: &str, name: Symbol, ty: Ty<'_>) -> bool {
+    let ne = LintKind::Host.to_name(prefix);
+    let le = LintKind::Little.to_name(prefix);
+    let be = LintKind::Big.to_name(prefix);
 
     let (lint, other_lints) = match name.as_str() {
         name if name == ne => ((&LintKind::Host), [(&LintKind::Little), (&LintKind::Big)]),
-- 
cgit 1.4.1-3-g733a5


From 8188da3614959d2532deb69030f1ba64c8ac16bf Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Wed, 31 May 2023 23:33:30 -0500
Subject: Fix suggestion on fully qualified syntax

---
 clippy_lints/src/dereference.rs        | 32 +++++++++++++++---
 tests/ui/explicit_deref_methods.fixed  | 29 +++++++++++++++-
 tests/ui/explicit_deref_methods.rs     | 29 +++++++++++++++-
 tests/ui/explicit_deref_methods.stderr | 62 +++++++++++++++++++++++++++-------
 4 files changed, 132 insertions(+), 20 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index b27ffe73ffd..96d1bcea6e5 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -155,7 +155,7 @@ impl_lint_pass!(Dereferencing<'_> => [
 
 #[derive(Default)]
 pub struct Dereferencing<'tcx> {
-    state: Option<(State, StateData)>,
+    state: Option<(State<'tcx>, StateData)>,
 
     // While parsing a `deref` method call in ufcs form, the path to the function is itself an
     // expression. This is to store the id of that expression so it can be skipped when
@@ -210,12 +210,13 @@ struct DerefedBorrow {
 }
 
 #[derive(Debug)]
-enum State {
+enum State<'tcx> {
     // Any number of deref method calls.
     DerefMethod {
         // The number of calls in a sequence which changed the referenced type
         ty_changed_count: usize,
         is_final_ufcs: bool,
+        call_args: Option<&'tcx [Expr<'tcx>]>,
         /// The required mutability
         target_mut: Mutability,
     },
@@ -312,10 +313,16 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing<'tcx> {
                             && position.lint_explicit_deref() =>
                     {
                         let ty_changed_count = usize::from(!deref_method_same_type(expr_ty, typeck.expr_ty(sub_expr)));
+                        let (is_final_ufcs, call_args) = if let ExprKind::Call(_, args) = expr.kind {
+                            (true, Some(args))
+                        } else {
+                            (false, None)
+                        };
                         self.state = Some((
                             State::DerefMethod {
                                 ty_changed_count,
-                                is_final_ufcs: matches!(expr.kind, ExprKind::Call(..)),
+                                is_final_ufcs,
+                                call_args,
                                 target_mut,
                             },
                             StateData {
@@ -438,6 +445,7 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing<'tcx> {
                             ty_changed_count + 1
                         },
                         is_final_ufcs: matches!(expr.kind, ExprKind::Call(..)),
+                        call_args: None,
                         target_mut,
                     },
                     data,
@@ -1472,11 +1480,12 @@ fn ty_contains_field(ty: Ty<'_>, name: Symbol) -> bool {
 }
 
 #[expect(clippy::needless_pass_by_value, clippy::too_many_lines)]
-fn report<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, state: State, data: StateData) {
+fn report<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, state: State<'_>, data: StateData) {
     match state {
         State::DerefMethod {
             ty_changed_count,
             is_final_ufcs,
+            call_args,
             target_mut,
         } => {
             let mut app = Applicability::MachineApplicable;
@@ -1503,12 +1512,25 @@ fn report<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, state: State, data
                 "&"
             };
 
-            let expr_str = if !expr_is_macro_call && is_final_ufcs && expr.precedence().order() < PREC_PREFIX {
+            let mut expr_str = if !expr_is_macro_call && is_final_ufcs && expr.precedence().order() < PREC_PREFIX {
                 format!("({expr_str})")
             } else {
                 expr_str.into_owned()
             };
 
+            // Fix #10850, changes suggestion if it's `Foo::deref` instead of `foo.deref`. Since `Foo::deref` is
+            // a `Call` instead of a `MethodCall` this should catch all instances of this, even if it's fully
+            // qualified or whatnot.
+            if is_final_ufcs && let Some(args) = call_args {
+                // Remove ref if it's there
+                let arg = if let ExprKind::AddrOf(.., arg) = args[0].kind {
+                    arg
+                } else {
+                    &args[0]
+                };
+                expr_str = snippet_with_applicability(cx, arg.span, "{ .. }", &mut app).to_string();
+            }
+
             span_lint_and_sugg(
                 cx,
                 EXPLICIT_DEREF_METHODS,
diff --git a/tests/ui/explicit_deref_methods.fixed b/tests/ui/explicit_deref_methods.fixed
index 60482c66da7..6cf7a28cafa 100644
--- a/tests/ui/explicit_deref_methods.fixed
+++ b/tests/ui/explicit_deref_methods.fixed
@@ -1,11 +1,12 @@
 //@run-rustfix
 #![warn(clippy::explicit_deref_methods)]
-#![allow(unused_variables)]
+#![allow(unused_variables, unused_must_use)]
 #![allow(
     clippy::borrow_deref_ref,
     suspicious_double_ref_op,
     clippy::explicit_auto_deref,
     clippy::needless_borrow,
+    clippy::no_effect,
     clippy::uninlined_format_args
 )]
 
@@ -28,6 +29,22 @@ impl Deref for CustomVec {
     }
 }
 
+struct Aaa;
+
+impl Deref for Aaa {
+    type Target = ();
+
+    fn deref(&self) -> &Self::Target {
+        todo!();
+    }
+}
+
+impl DerefMut for Aaa {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        todo!();
+    }
+}
+
 fn main() {
     let a: &mut String = &mut String::from("foo");
 
@@ -58,6 +75,16 @@ fn main() {
     let opt_a = Some(a.clone());
     let b = &*opt_a.unwrap();
 
+    // make sure `Aaa::deref` instead of `aaa.deref()` works as well as fully qualified syntax
+
+    &*Aaa;
+    &mut *Aaa;
+    &*Aaa;
+    &mut *Aaa;
+    let mut aaa = Aaa;
+    &*aaa;
+    &mut *aaa;
+
     // following should not require linting
 
     let cv = CustomVec(vec![0, 42]);
diff --git a/tests/ui/explicit_deref_methods.rs b/tests/ui/explicit_deref_methods.rs
index e3613e216bb..77501fa6b6e 100644
--- a/tests/ui/explicit_deref_methods.rs
+++ b/tests/ui/explicit_deref_methods.rs
@@ -1,11 +1,12 @@
 //@run-rustfix
 #![warn(clippy::explicit_deref_methods)]
-#![allow(unused_variables)]
+#![allow(unused_variables, unused_must_use)]
 #![allow(
     clippy::borrow_deref_ref,
     suspicious_double_ref_op,
     clippy::explicit_auto_deref,
     clippy::needless_borrow,
+    clippy::no_effect,
     clippy::uninlined_format_args
 )]
 
@@ -28,6 +29,22 @@ impl Deref for CustomVec {
     }
 }
 
+struct Aaa;
+
+impl Deref for Aaa {
+    type Target = ();
+
+    fn deref(&self) -> &Self::Target {
+        todo!();
+    }
+}
+
+impl DerefMut for Aaa {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        todo!();
+    }
+}
+
 fn main() {
     let a: &mut String = &mut String::from("foo");
 
@@ -58,6 +75,16 @@ fn main() {
     let opt_a = Some(a.clone());
     let b = opt_a.unwrap().deref();
 
+    // make sure `Aaa::deref` instead of `aaa.deref()` works as well as fully qualified syntax
+
+    Aaa::deref(&Aaa);
+    Aaa::deref_mut(&mut Aaa);
+    <Aaa as Deref>::deref(&Aaa);
+    <Aaa as DerefMut>::deref_mut(&mut Aaa);
+    let mut aaa = Aaa;
+    Aaa::deref(&aaa);
+    Aaa::deref_mut(&mut aaa);
+
     // following should not require linting
 
     let cv = CustomVec(vec![0, 42]);
diff --git a/tests/ui/explicit_deref_methods.stderr b/tests/ui/explicit_deref_methods.stderr
index 4b10ed1377b..30ebcd47b2b 100644
--- a/tests/ui/explicit_deref_methods.stderr
+++ b/tests/ui/explicit_deref_methods.stderr
@@ -1,5 +1,5 @@
 error: explicit `deref` method call
-  --> $DIR/explicit_deref_methods.rs:36:19
+  --> $DIR/explicit_deref_methods.rs:53:19
    |
 LL |     let b: &str = a.deref();
    |                   ^^^^^^^^^ help: try this: `&*a`
@@ -7,70 +7,106 @@ LL |     let b: &str = a.deref();
    = note: `-D clippy::explicit-deref-methods` implied by `-D warnings`
 
 error: explicit `deref_mut` method call
-  --> $DIR/explicit_deref_methods.rs:38:23
+  --> $DIR/explicit_deref_methods.rs:55:23
    |
 LL |     let b: &mut str = a.deref_mut();
    |                       ^^^^^^^^^^^^^ help: try this: `&mut **a`
 
 error: explicit `deref` method call
-  --> $DIR/explicit_deref_methods.rs:41:39
+  --> $DIR/explicit_deref_methods.rs:58:39
    |
 LL |     let b: String = format!("{}, {}", a.deref(), a.deref());
    |                                       ^^^^^^^^^ help: try this: `&*a`
 
 error: explicit `deref` method call
-  --> $DIR/explicit_deref_methods.rs:41:50
+  --> $DIR/explicit_deref_methods.rs:58:50
    |
 LL |     let b: String = format!("{}, {}", a.deref(), a.deref());
    |                                                  ^^^^^^^^^ help: try this: `&*a`
 
 error: explicit `deref` method call
-  --> $DIR/explicit_deref_methods.rs:43:20
+  --> $DIR/explicit_deref_methods.rs:60:20
    |
 LL |     println!("{}", a.deref());
    |                    ^^^^^^^^^ help: try this: `&*a`
 
 error: explicit `deref` method call
-  --> $DIR/explicit_deref_methods.rs:46:11
+  --> $DIR/explicit_deref_methods.rs:63:11
    |
 LL |     match a.deref() {
    |           ^^^^^^^^^ help: try this: `&*a`
 
 error: explicit `deref` method call
-  --> $DIR/explicit_deref_methods.rs:50:28
+  --> $DIR/explicit_deref_methods.rs:67:28
    |
 LL |     let b: String = concat(a.deref());
    |                            ^^^^^^^^^ help: try this: `&*a`
 
 error: explicit `deref` method call
-  --> $DIR/explicit_deref_methods.rs:52:13
+  --> $DIR/explicit_deref_methods.rs:69:13
    |
 LL |     let b = just_return(a).deref();
    |             ^^^^^^^^^^^^^^^^^^^^^^ help: try this: `just_return(a)`
 
 error: explicit `deref` method call
-  --> $DIR/explicit_deref_methods.rs:54:28
+  --> $DIR/explicit_deref_methods.rs:71:28
    |
 LL |     let b: String = concat(just_return(a).deref());
    |                            ^^^^^^^^^^^^^^^^^^^^^^ help: try this: `just_return(a)`
 
 error: explicit `deref` method call
-  --> $DIR/explicit_deref_methods.rs:56:19
+  --> $DIR/explicit_deref_methods.rs:73:19
    |
 LL |     let b: &str = a.deref().deref();
    |                   ^^^^^^^^^^^^^^^^^ help: try this: `&**a`
 
 error: explicit `deref` method call
-  --> $DIR/explicit_deref_methods.rs:59:13
+  --> $DIR/explicit_deref_methods.rs:76:13
    |
 LL |     let b = opt_a.unwrap().deref();
    |             ^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&*opt_a.unwrap()`
 
 error: explicit `deref` method call
-  --> $DIR/explicit_deref_methods.rs:85:31
+  --> $DIR/explicit_deref_methods.rs:80:5
+   |
+LL |     Aaa::deref(&Aaa);
+   |     ^^^^^^^^^^^^^^^^ help: try this: `&*Aaa`
+
+error: explicit `deref_mut` method call
+  --> $DIR/explicit_deref_methods.rs:81:5
+   |
+LL |     Aaa::deref_mut(&mut Aaa);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&mut *Aaa`
+
+error: explicit `deref` method call
+  --> $DIR/explicit_deref_methods.rs:82:5
+   |
+LL |     <Aaa as Deref>::deref(&Aaa);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&*Aaa`
+
+error: explicit `deref_mut` method call
+  --> $DIR/explicit_deref_methods.rs:83:5
+   |
+LL |     <Aaa as DerefMut>::deref_mut(&mut Aaa);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&mut *Aaa`
+
+error: explicit `deref` method call
+  --> $DIR/explicit_deref_methods.rs:85:5
+   |
+LL |     Aaa::deref(&aaa);
+   |     ^^^^^^^^^^^^^^^^ help: try this: `&*aaa`
+
+error: explicit `deref_mut` method call
+  --> $DIR/explicit_deref_methods.rs:86:5
+   |
+LL |     Aaa::deref_mut(&mut aaa);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&mut *aaa`
+
+error: explicit `deref` method call
+  --> $DIR/explicit_deref_methods.rs:112:31
    |
 LL |     let b: &str = expr_deref!(a.deref());
    |                               ^^^^^^^^^ help: try this: `&*a`
 
-error: aborting due to 12 previous errors
+error: aborting due to 18 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 16f1cf8fd4e378d61bb240a8c5bbbeba2d000cb0 Mon Sep 17 00:00:00 2001
From: MarcusGrass <marcus.grass@protonmail.com>
Date: Thu, 1 Jun 2023 10:40:21 +0200
Subject: Ignore from_over_into if it contains Self

---
 clippy_lints/src/from_over_into.rs | 80 +++-----------------------------------
 tests/ui/from_over_into.fixed      |  6 +--
 tests/ui/from_over_into.stderr     | 15 +------
 3 files changed, 10 insertions(+), 91 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/from_over_into.rs b/clippy_lints/src/from_over_into.rs
index e725fb26c22..c4405feaa97 100644
--- a/clippy_lints/src/from_over_into.rs
+++ b/clippy_lints/src/from_over_into.rs
@@ -80,6 +80,11 @@ impl<'tcx> LateLintPass<'tcx> for FromOverInto {
             && cx.tcx.is_diagnostic_item(sym::Into, middle_trait_ref.def_id)
             && !matches!(middle_trait_ref.substs.type_at(1).kind(), ty::Alias(ty::Opaque, _))
         {
+            if !target_ty.find_self_aliases().is_empty() {
+                // It's tricky to expand self-aliases correctly, we'll ignore it to not cause a
+                // bad suggestion/fix.
+                return;
+            }
             span_lint_and_then(
                 cx,
                 FROM_OVER_INTO,
@@ -163,8 +168,7 @@ fn convert_to_from(
     let PatKind::Binding(.., self_ident, None) = input.pat.kind else { return None };
 
     let from = snippet_opt(cx, self_ty.span)?;
-    // If Self is used, it refers to `self_ty`, which is now out `from` snippet
-    let into = replace_self(&snippet_opt(cx, target_ty.span)?, &from);
+    let into = snippet_opt(cx, target_ty.span)?;
 
     let mut suggestions = vec![
         // impl Into<T> for U  ->  impl From<T> for U
@@ -213,75 +217,3 @@ fn convert_to_from(
 
     Some(suggestions)
 }
-
-fn replace_self(input: &str, replace_with: &str) -> String {
-    const SELF: &str = "Self";
-    let mut chunks = input.split(SELF).peekable();
-    if let Some(first) = chunks.next() {
-        let mut last_ended_with_break = false;
-        // Heuristic, we're making a guess that the expansion probably doesn't exceed `input.len() * 2`
-        let mut output = String::with_capacity(input.len() * 2);
-        if first.is_empty() || first.ends_with(word_break) {
-            last_ended_with_break = true;
-        }
-        output.push_str(first);
-        while let Some(val) = chunks.next() {
-            let is_last = chunks.peek().is_none();
-            if last_ended_with_break && is_last && val.is_empty() {
-                output.push_str(replace_with);
-                break;
-            }
-            let this_starts_with_break = val.starts_with(word_break);
-            let this_ends_with_break = val.ends_with(word_break);
-            if this_starts_with_break && last_ended_with_break {
-                output.push_str(replace_with);
-            } else {
-                output.push_str(SELF);
-            }
-            output.push_str(val);
-            last_ended_with_break = this_ends_with_break;
-        }
-        output
-    } else {
-        input.to_string()
-    }
-}
-
-#[inline]
-fn word_break(ch: char) -> bool {
-    !ch.is_alphanumeric()
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::from_over_into::replace_self;
-
-    #[test]
-    fn replace_doesnt_touch_coincidental_self() {
-        let input = "impl Into<SelfType> for String {";
-        assert_eq!(input, &replace_self(input, "T"));
-    }
-
-    #[test]
-    fn replace_replaces_self() {
-        let input = "impl Into<Self> for String {";
-        assert_eq!("impl Into<String> for String {", &replace_self(input, "String"));
-    }
-    #[test]
-    fn replace_replaces_self_many() {
-        let input = "impl Into<Self<Self<SelfSelfSelfSelf>>> for Self {";
-        assert_eq!(
-            "impl Into<String<String<SelfSelfSelfSelf>>> for String {",
-            &replace_self(input, "String")
-        );
-    }
-
-    #[test]
-    fn replace_replaces_self_many_starts_ends_self() {
-        let input = "Self impl Into<Self<Self<SelfSelf>>> for Self";
-        assert_eq!(
-            "String impl Into<String<String<SelfSelf>>> for String",
-            &replace_self(input, "String")
-        );
-    }
-}
diff --git a/tests/ui/from_over_into.fixed b/tests/ui/from_over_into.fixed
index f1333bb39a8..98310ac5c6c 100644
--- a/tests/ui/from_over_into.fixed
+++ b/tests/ui/from_over_into.fixed
@@ -92,9 +92,9 @@ pub struct Lval<T>(T);
 
 pub struct Rval<T>(T);
 
-impl<T> From<Lval<T>> for Rval<Lval<T>> {
-    fn from(val: Lval<T>) -> Self {
-        Rval(val)
+impl<T> Into<Rval<Self>> for Lval<T> {
+    fn into(self) -> Rval<Self> {
+        Rval(self)
     }
 }
 
diff --git a/tests/ui/from_over_into.stderr b/tests/ui/from_over_into.stderr
index c514bb6146c..6039f86fe67 100644
--- a/tests/ui/from_over_into.stderr
+++ b/tests/ui/from_over_into.stderr
@@ -71,18 +71,5 @@ LL ~         fn from(val: Vec<T>) -> Self {
 LL ~             FromOverInto(val)
    |
 
-error: an implementation of `From` is preferred since it gives you `Into<_>` for free where the reverse isn't true
-  --> $DIR/from_over_into.rs:95:1
-   |
-LL | impl<T> Into<Rval<Self>> for Lval<T> {
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: replace the `Into` implementation with `From<Lval<T>>`
-   |
-LL ~ impl<T> From<Lval<T>> for Rval<Lval<T>> {
-LL ~     fn from(val: Lval<T>) -> Self {
-LL ~         Rval(val)
-   |
-
-error: aborting due to 6 previous errors
+error: aborting due to 5 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 5f5e2e2ac137b19f2f2a21562ca34a6edb1a7d8f Mon Sep 17 00:00:00 2001
From: MarcusGrass <marcus.grass@protonmail.com>
Date: Thu, 1 Jun 2023 12:14:55 +0200
Subject: Explain which paths clippy searches for configuration in docs

---
 book/src/configuration.md            | 6 ++++--
 book/src/development/adding_lints.md | 6 ++++--
 clippy_lints/src/utils/conf.rs       | 2 +-
 3 files changed, 9 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/book/src/configuration.md b/book/src/configuration.md
index 1304f6a8c2f..54af30d17e1 100644
--- a/book/src/configuration.md
+++ b/book/src/configuration.md
@@ -2,8 +2,10 @@
 
 > **Note:** The configuration file is unstable and may be deprecated in the future.
 
-Some lints can be configured in a TOML file named `clippy.toml` or `.clippy.toml`. It contains a
-basic `variable = value` mapping e.g.
+Some lints can be configured in a TOML file named `clippy.toml` or `.clippy.toml`, placed in a directory specified by
+the environment variable `CLIPPY_CONF_DIR`, or if that's not found, the environment variable
+[CARGO_MANIFEST_DIR](https://doc.rust-lang.org/cargo/reference/environment-variables.html), or if that isn't
+found, the current directory. It contains a basic `variable = value` mapping e.g.
 
 ```toml
 avoid-breaking-exported-api = false
diff --git a/book/src/development/adding_lints.md b/book/src/development/adding_lints.md
index ccae8d37420..ea3819ccbdf 100644
--- a/book/src/development/adding_lints.md
+++ b/book/src/development/adding_lints.md
@@ -630,8 +630,10 @@ Before submitting your PR make sure you followed all the basic requirements:
 
 ## Adding configuration to a lint
 
-Clippy supports the configuration of lints values using a `clippy.toml` file in
-the workspace directory. Adding a configuration to a lint can be useful for
+Clippy supports the configuration of lints values using a `clippy.toml` file in a directory specified by
+the environment variable `CLIPPY_CONF_DIR`, or if that's not found, the environment variable
+[CARGO_MANIFEST_DIR](https://doc.rust-lang.org/cargo/reference/environment-variables.html), or if that isn't
+found, the current directory. Adding a configuration to a lint can be useful for
 thresholds or to constrain some behavior that can be seen as a false positive
 for some users. Adding a configuration is done in the following steps:
 
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index f6de66bb514..4acff7fd322 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -486,7 +486,7 @@ pub fn lookup_conf_file() -> io::Result<(Option<PathBuf>, Vec<String>)> {
     const CONFIG_FILE_NAMES: [&str; 2] = [".clippy.toml", "clippy.toml"];
 
     // Start looking for a config file in CLIPPY_CONF_DIR, or failing that, CARGO_MANIFEST_DIR.
-    // If neither of those exist, use ".".
+    // If neither of those exist, use ".". (Update documentation if this priority changes)
     let mut current = env::var_os("CLIPPY_CONF_DIR")
         .or_else(|| env::var_os("CARGO_MANIFEST_DIR"))
         .map_or_else(|| PathBuf::from("."), PathBuf::from)
-- 
cgit 1.4.1-3-g733a5


From b2c85b31bbe9dfd841c5d4999ac79cd431489101 Mon Sep 17 00:00:00 2001
From: MarcusGrass <marcus.grass@protonmail.com>
Date: Thu, 1 Jun 2023 16:02:42 +0200
Subject: Move bail into lint to prevent no-linting, move to unfixable

---
 clippy_lints/src/from_over_into.rs       | 10 +++++-----
 tests/ui/from_over_into.fixed            | 10 ----------
 tests/ui/from_over_into.rs               | 10 ----------
 tests/ui/from_over_into_unfixable.rs     | 10 ++++++++++
 tests/ui/from_over_into_unfixable.stderr | 10 +++++++++-
 5 files changed, 24 insertions(+), 26 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/from_over_into.rs b/clippy_lints/src/from_over_into.rs
index c4405feaa97..e25b45eaa2e 100644
--- a/clippy_lints/src/from_over_into.rs
+++ b/clippy_lints/src/from_over_into.rs
@@ -80,11 +80,6 @@ impl<'tcx> LateLintPass<'tcx> for FromOverInto {
             && cx.tcx.is_diagnostic_item(sym::Into, middle_trait_ref.def_id)
             && !matches!(middle_trait_ref.substs.type_at(1).kind(), ty::Alias(ty::Opaque, _))
         {
-            if !target_ty.find_self_aliases().is_empty() {
-                // It's tricky to expand self-aliases correctly, we'll ignore it to not cause a
-                // bad suggestion/fix.
-                return;
-            }
             span_lint_and_then(
                 cx,
                 FROM_OVER_INTO,
@@ -161,6 +156,11 @@ fn convert_to_from(
     self_ty: &Ty<'_>,
     impl_item_ref: &ImplItemRef,
 ) -> Option<Vec<(Span, String)>> {
+    if !target_ty.find_self_aliases().is_empty() {
+        // It's tricky to expand self-aliases correctly, we'll ignore it to not cause a
+        // bad suggestion/fix.
+        return None;
+    }
     let impl_item = cx.tcx.hir().impl_item(impl_item_ref.id);
     let ImplItemKind::Fn(ref sig, body_id) = impl_item.kind else { return None };
     let body = cx.tcx.hir().body(body_id);
diff --git a/tests/ui/from_over_into.fixed b/tests/ui/from_over_into.fixed
index 98310ac5c6c..d18f9387565 100644
--- a/tests/ui/from_over_into.fixed
+++ b/tests/ui/from_over_into.fixed
@@ -88,14 +88,4 @@ impl Into<Opaque> for IntoOpaque {
     fn into(self) -> Opaque {}
 }
 
-pub struct Lval<T>(T);
-
-pub struct Rval<T>(T);
-
-impl<T> Into<Rval<Self>> for Lval<T> {
-    fn into(self) -> Rval<Self> {
-        Rval(self)
-    }
-}
-
 fn main() {}
diff --git a/tests/ui/from_over_into.rs b/tests/ui/from_over_into.rs
index 4fb91971db9..de8ff0b06bd 100644
--- a/tests/ui/from_over_into.rs
+++ b/tests/ui/from_over_into.rs
@@ -88,14 +88,4 @@ impl Into<Opaque> for IntoOpaque {
     fn into(self) -> Opaque {}
 }
 
-pub struct Lval<T>(T);
-
-pub struct Rval<T>(T);
-
-impl<T> Into<Rval<Self>> for Lval<T> {
-    fn into(self) -> Rval<Self> {
-        Rval(self)
-    }
-}
-
 fn main() {}
diff --git a/tests/ui/from_over_into_unfixable.rs b/tests/ui/from_over_into_unfixable.rs
index 3b280b7488a..92d3504bc23 100644
--- a/tests/ui/from_over_into_unfixable.rs
+++ b/tests/ui/from_over_into_unfixable.rs
@@ -32,4 +32,14 @@ impl Into<u8> for ContainsVal {
     }
 }
 
+pub struct Lval<T>(T);
+
+pub struct Rval<T>(T);
+
+impl<T> Into<Rval<Self>> for Lval<T> {
+    fn into(self) -> Rval<Self> {
+        Rval(self)
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/from_over_into_unfixable.stderr b/tests/ui/from_over_into_unfixable.stderr
index 251f1d84e74..2ab9b9d6b17 100644
--- a/tests/ui/from_over_into_unfixable.stderr
+++ b/tests/ui/from_over_into_unfixable.stderr
@@ -25,5 +25,13 @@ LL | impl Into<u8> for ContainsVal {
            https://doc.rust-lang.org/reference/items/implementations.html#trait-implementation-coherence
    = help: replace the `Into` implementation with `From<ContainsVal>`
 
-error: aborting due to 3 previous errors
+error: an implementation of `From` is preferred since it gives you `Into<_>` for free where the reverse isn't true
+  --> $DIR/from_over_into_unfixable.rs:39:1
+   |
+LL | impl<T> Into<Rval<Self>> for Lval<T> {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: replace the `Into` implementation with `From<Lval<T>>`
+
+error: aborting due to 4 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 62eb4e7d7b5568bfcf9e82a61bf3a60aaa739548 Mon Sep 17 00:00:00 2001
From: MarcusGrass <marcus.grass@protonmail.com>
Date: Thu, 1 Jun 2023 15:53:20 +0200
Subject: Bring up Rust lang #37612 as a known problem for let_and_return

---
 clippy_lints/src/returns.rs | 6 ++++++
 1 file changed, 6 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
index 631ecf1428d..92913ddc4aa 100644
--- a/clippy_lints/src/returns.rs
+++ b/clippy_lints/src/returns.rs
@@ -25,6 +25,12 @@ declare_clippy_lint! {
     /// It is just extraneous code. Remove it to make your code
     /// more rusty.
     ///
+    /// ### Known problems
+    /// In the case of some temporaries, e.g. locks, eliding the variable binding could lead
+    /// to deadlocks. See [rust-lang issue 37612](https://github.com/rust-lang/rust/issues/37612).
+    /// This could become relevant if the code is later changed to use the code that would have been
+    /// bound without first assigning it to a let-binding.
+    ///
     /// ### Example
     /// ```rust
     /// fn foo() -> String {
-- 
cgit 1.4.1-3-g733a5


From 0a7366897d35c0dd2ea125fe79e43cb4862dc73b Mon Sep 17 00:00:00 2001
From: est31 <MTest31@outlook.com>
Date: Thu, 1 Jun 2023 18:55:24 +0200
Subject: manual_let_else: only add () around PatKind::Or at the top level

At the top level, () are required, but on the levels below they are not.
---
 clippy_lints/src/manual_let_else.rs   | 13 +++++++++----
 tests/ui/manual_let_else_match.rs     |  5 +++++
 tests/ui/manual_let_else_match.stderr | 13 +++++++++++--
 3 files changed, 25 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_let_else.rs b/clippy_lints/src/manual_let_else.rs
index 389b0a4a62d..d5e847e7183 100644
--- a/clippy_lints/src/manual_let_else.rs
+++ b/clippy_lints/src/manual_let_else.rs
@@ -159,7 +159,7 @@ fn emit_manual_let_else(
             } else {
                 format!("{{ {sn_else} }}")
             };
-            let sn_bl = replace_in_pattern(cx, span, local, pat, &mut app);
+            let sn_bl = replace_in_pattern(cx, span, local, pat, &mut app, true);
             let sugg = format!("let {sn_bl} = {sn_expr} else {else_bl};");
             diag.span_suggestion(span, "consider writing", sugg, app);
         },
@@ -173,6 +173,7 @@ fn replace_in_pattern(
     local: &Pat<'_>,
     pat: &Pat<'_>,
     app: &mut Applicability,
+    top_level: bool,
 ) -> String {
     let mut bindings_count = 0;
     pat.each_binding_or_first(&mut |_, _, _, _| bindings_count += 1);
@@ -191,16 +192,20 @@ fn replace_in_pattern(
         PatKind::Or(pats) => {
             let patterns = pats
                 .iter()
-                .map(|pat| replace_in_pattern(cx, span, local, pat, app))
+                .map(|pat| replace_in_pattern(cx, span, local, pat, app, false))
                 .collect::<Vec<_>>();
             let or_pat = patterns.join(" | ");
-            return format!("({or_pat})");
+            if top_level {
+                return format!("({or_pat})");
+            } else {
+                return or_pat;
+            }
         },
         // Replace the variable name iff `TupleStruct` has one argument like `Variant(v)`.
         PatKind::TupleStruct(ref w, args, dot_dot_pos) => {
             let mut args = args
                 .iter()
-                .map(|pat| replace_in_pattern(cx, span, local, pat, app))
+                .map(|pat| replace_in_pattern(cx, span, local, pat, app, false))
                 .collect::<Vec<_>>();
             if let Some(pos) = dot_dot_pos.as_opt_usize() {
                 args.insert(pos, "..".to_owned());
diff --git a/tests/ui/manual_let_else_match.rs b/tests/ui/manual_let_else_match.rs
index dfca3b023cd..07cd5a53a7c 100644
--- a/tests/ui/manual_let_else_match.rs
+++ b/tests/ui/manual_let_else_match.rs
@@ -72,6 +72,11 @@ fn fire() {
         _ => return,
     };
 
+    let _value = match Some(build_enum()) {
+        Some(Variant::Bar(v) | Variant::Baz(v)) => v,
+        _ => return,
+    };
+
     let data = [1_u8, 2, 3, 4, 0, 0, 0, 0];
     let data = match data.as_slice() {
         [data @ .., 0, 0, 0, 0] | [data @ .., 0, 0] | [data @ .., 0] => data,
diff --git a/tests/ui/manual_let_else_match.stderr b/tests/ui/manual_let_else_match.stderr
index 13ed35bc1d5..ead2f28e609 100644
--- a/tests/ui/manual_let_else_match.stderr
+++ b/tests/ui/manual_let_else_match.stderr
@@ -64,7 +64,16 @@ LL | |     };
    | |______^ help: consider writing: `let (Variant::Bar(_value) | Variant::Baz(_value)) = f else { return };`
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else_match.rs:76:5
+  --> $DIR/manual_let_else_match.rs:75:5
+   |
+LL | /     let _value = match Some(build_enum()) {
+LL | |         Some(Variant::Bar(v) | Variant::Baz(v)) => v,
+LL | |         _ => return,
+LL | |     };
+   | |______^ help: consider writing: `let Some(Variant::Bar(_value) | Variant::Baz(_value)) = Some(build_enum()) else { return };`
+
+error: this could be rewritten as `let...else`
+  --> $DIR/manual_let_else_match.rs:81:5
    |
 LL | /     let data = match data.as_slice() {
 LL | |         [data @ .., 0, 0, 0, 0] | [data @ .., 0, 0] | [data @ .., 0] => data,
@@ -72,5 +81,5 @@ LL | |         _ => return,
 LL | |     };
    | |______^ help: consider writing: `let ([data @ .., 0, 0, 0, 0] | [data @ .., 0, 0] | [data @ .., 0]) = data.as_slice() else { return };`
 
-error: aborting due to 8 previous errors
+error: aborting due to 9 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From eed466281c8d0e3a920a2cde01a5b4b5c0df5f0e Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Thu, 1 Jun 2023 14:29:56 -0500
Subject: ignore `Foo::deref` altogether

---
 clippy_lints/src/dereference.rs        | 47 +++++++++++++---------------------
 tests/ui/explicit_deref_methods.fixed  | 15 ++++++-----
 tests/ui/explicit_deref_methods.rs     |  3 ++-
 tests/ui/explicit_deref_methods.stderr | 40 ++---------------------------
 4 files changed, 30 insertions(+), 75 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index 96d1bcea6e5..93b6e2083b5 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -56,9 +56,11 @@ declare_clippy_lint! {
     /// let b = &*a;
     /// ```
     ///
-    /// This lint excludes:
+    /// This lint excludes all of:
     /// ```rust,ignore
     /// let _ = d.unwrap().deref();
+    /// let _ = Foo::deref(&foo);
+    /// let _ = <Foo as Deref>::deref(&foo);
     /// ```
     #[clippy::version = "1.44.0"]
     pub EXPLICIT_DEREF_METHODS,
@@ -155,7 +157,7 @@ impl_lint_pass!(Dereferencing<'_> => [
 
 #[derive(Default)]
 pub struct Dereferencing<'tcx> {
-    state: Option<(State<'tcx>, StateData)>,
+    state: Option<(State, StateData)>,
 
     // While parsing a `deref` method call in ufcs form, the path to the function is itself an
     // expression. This is to store the id of that expression so it can be skipped when
@@ -210,13 +212,12 @@ struct DerefedBorrow {
 }
 
 #[derive(Debug)]
-enum State<'tcx> {
+enum State {
     // Any number of deref method calls.
     DerefMethod {
         // The number of calls in a sequence which changed the referenced type
         ty_changed_count: usize,
         is_final_ufcs: bool,
-        call_args: Option<&'tcx [Expr<'tcx>]>,
         /// The required mutability
         target_mut: Mutability,
     },
@@ -313,16 +314,10 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing<'tcx> {
                             && position.lint_explicit_deref() =>
                     {
                         let ty_changed_count = usize::from(!deref_method_same_type(expr_ty, typeck.expr_ty(sub_expr)));
-                        let (is_final_ufcs, call_args) = if let ExprKind::Call(_, args) = expr.kind {
-                            (true, Some(args))
-                        } else {
-                            (false, None)
-                        };
                         self.state = Some((
                             State::DerefMethod {
                                 ty_changed_count,
-                                is_final_ufcs,
-                                call_args,
+                                is_final_ufcs: matches!(expr.kind, ExprKind::Call(..)),
                                 target_mut,
                             },
                             StateData {
@@ -445,7 +440,6 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing<'tcx> {
                             ty_changed_count + 1
                         },
                         is_final_ufcs: matches!(expr.kind, ExprKind::Call(..)),
-                        call_args: None,
                         target_mut,
                     },
                     data,
@@ -1480,16 +1474,15 @@ fn ty_contains_field(ty: Ty<'_>, name: Symbol) -> bool {
 }
 
 #[expect(clippy::needless_pass_by_value, clippy::too_many_lines)]
-fn report<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, state: State<'_>, data: StateData) {
+fn report<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, state: State, data: StateData) {
     match state {
         State::DerefMethod {
             ty_changed_count,
             is_final_ufcs,
-            call_args,
             target_mut,
         } => {
             let mut app = Applicability::MachineApplicable;
-            let (expr_str, expr_is_macro_call) = snippet_with_context(cx, expr.span, data.span.ctxt(), "..", &mut app);
+            let (expr_str, _expr_is_macro_call) = snippet_with_context(cx, expr.span, data.span.ctxt(), "..", &mut app);
             let ty = cx.typeck_results().expr_ty(expr);
             let (_, ref_count) = peel_mid_ty_refs(ty);
             let deref_str = if ty_changed_count >= ref_count && ref_count != 0 {
@@ -1512,23 +1505,19 @@ fn report<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, state: State<'_>,
                 "&"
             };
 
-            let mut expr_str = if !expr_is_macro_call && is_final_ufcs && expr.precedence().order() < PREC_PREFIX {
-                format!("({expr_str})")
+            // expr_str (the suggestion) is never shown if is_final_ufcs is true, since it's
+            // `expr.kind == ExprKind::Call`. Therefore, this is, afaik, always unnecessary.
+            /*
+            expr_str = if !expr_is_macro_call && is_final_ufcs && expr.precedence().order() < PREC_PREFIX {
+                Cow::Owned(format!("({expr_str})"))
             } else {
-                expr_str.into_owned()
+                expr_str
             };
+            */
 
-            // Fix #10850, changes suggestion if it's `Foo::deref` instead of `foo.deref`. Since `Foo::deref` is
-            // a `Call` instead of a `MethodCall` this should catch all instances of this, even if it's fully
-            // qualified or whatnot.
-            if is_final_ufcs && let Some(args) = call_args {
-                // Remove ref if it's there
-                let arg = if let ExprKind::AddrOf(.., arg) = args[0].kind {
-                    arg
-                } else {
-                    &args[0]
-                };
-                expr_str = snippet_with_applicability(cx, arg.span, "{ .. }", &mut app).to_string();
+            // Fix #10850, do not lint if it's `Foo::deref` instead of `foo.deref()`.
+            if is_final_ufcs {
+                return;
             }
 
             span_lint_and_sugg(
diff --git a/tests/ui/explicit_deref_methods.fixed b/tests/ui/explicit_deref_methods.fixed
index 6cf7a28cafa..1710b170fb8 100644
--- a/tests/ui/explicit_deref_methods.fixed
+++ b/tests/ui/explicit_deref_methods.fixed
@@ -75,15 +75,16 @@ fn main() {
     let opt_a = Some(a.clone());
     let b = &*opt_a.unwrap();
 
-    // make sure `Aaa::deref` instead of `aaa.deref()` works as well as fully qualified syntax
+    // make sure `Aaa::deref` instead of `aaa.deref()` is not linted, as well as fully qualified
+    // syntax
 
-    &*Aaa;
-    &mut *Aaa;
-    &*Aaa;
-    &mut *Aaa;
+    Aaa::deref(&Aaa);
+    Aaa::deref_mut(&mut Aaa);
+    <Aaa as Deref>::deref(&Aaa);
+    <Aaa as DerefMut>::deref_mut(&mut Aaa);
     let mut aaa = Aaa;
-    &*aaa;
-    &mut *aaa;
+    Aaa::deref(&aaa);
+    Aaa::deref_mut(&mut aaa);
 
     // following should not require linting
 
diff --git a/tests/ui/explicit_deref_methods.rs b/tests/ui/explicit_deref_methods.rs
index 77501fa6b6e..85147e1cb69 100644
--- a/tests/ui/explicit_deref_methods.rs
+++ b/tests/ui/explicit_deref_methods.rs
@@ -75,7 +75,8 @@ fn main() {
     let opt_a = Some(a.clone());
     let b = opt_a.unwrap().deref();
 
-    // make sure `Aaa::deref` instead of `aaa.deref()` works as well as fully qualified syntax
+    // make sure `Aaa::deref` instead of `aaa.deref()` is not linted, as well as fully qualified
+    // syntax
 
     Aaa::deref(&Aaa);
     Aaa::deref_mut(&mut Aaa);
diff --git a/tests/ui/explicit_deref_methods.stderr b/tests/ui/explicit_deref_methods.stderr
index 30ebcd47b2b..592563ffa8c 100644
--- a/tests/ui/explicit_deref_methods.stderr
+++ b/tests/ui/explicit_deref_methods.stderr
@@ -67,46 +67,10 @@ LL |     let b = opt_a.unwrap().deref();
    |             ^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&*opt_a.unwrap()`
 
 error: explicit `deref` method call
-  --> $DIR/explicit_deref_methods.rs:80:5
-   |
-LL |     Aaa::deref(&Aaa);
-   |     ^^^^^^^^^^^^^^^^ help: try this: `&*Aaa`
-
-error: explicit `deref_mut` method call
-  --> $DIR/explicit_deref_methods.rs:81:5
-   |
-LL |     Aaa::deref_mut(&mut Aaa);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&mut *Aaa`
-
-error: explicit `deref` method call
-  --> $DIR/explicit_deref_methods.rs:82:5
-   |
-LL |     <Aaa as Deref>::deref(&Aaa);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&*Aaa`
-
-error: explicit `deref_mut` method call
-  --> $DIR/explicit_deref_methods.rs:83:5
-   |
-LL |     <Aaa as DerefMut>::deref_mut(&mut Aaa);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&mut *Aaa`
-
-error: explicit `deref` method call
-  --> $DIR/explicit_deref_methods.rs:85:5
-   |
-LL |     Aaa::deref(&aaa);
-   |     ^^^^^^^^^^^^^^^^ help: try this: `&*aaa`
-
-error: explicit `deref_mut` method call
-  --> $DIR/explicit_deref_methods.rs:86:5
-   |
-LL |     Aaa::deref_mut(&mut aaa);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&mut *aaa`
-
-error: explicit `deref` method call
-  --> $DIR/explicit_deref_methods.rs:112:31
+  --> $DIR/explicit_deref_methods.rs:113:31
    |
 LL |     let b: &str = expr_deref!(a.deref());
    |                               ^^^^^^^^^ help: try this: `&*a`
 
-error: aborting due to 18 previous errors
+error: aborting due to 12 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 0cc1454db5d9b47ac247de31de8b545b9ae5be39 Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Thu, 1 Jun 2023 18:13:01 -0500
Subject: Fix #10498

---
 clippy_lints/src/let_with_type_underscore.rs |  9 +++++++--
 tests/ui/let_with_type_underscore.rs         |  9 +++++++++
 tests/ui/let_with_type_underscore.stderr     | 12 ++++++------
 3 files changed, 22 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/let_with_type_underscore.rs b/clippy_lints/src/let_with_type_underscore.rs
index 2f10e3d2581..8fcf42564d5 100644
--- a/clippy_lints/src/let_with_type_underscore.rs
+++ b/clippy_lints/src/let_with_type_underscore.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::{diagnostics::span_lint_and_help, is_from_proc_macro};
 use rustc_hir::{Local, TyKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::lint::in_external_macro;
@@ -32,7 +32,12 @@ impl LateLintPass<'_> for UnderscoreTyped {
             if let TyKind::Infer = &ty.kind; // that type is '_'
             if local.span.ctxt() == ty.span.ctxt();
             then {
-                span_lint_and_help(cx,
+                if let Some(init) = local.init && is_from_proc_macro(cx, init) {
+                    return;
+                }
+
+                span_lint_and_help(
+                    cx,
                     LET_WITH_TYPE_UNDERSCORE,
                     local.span,
                     "variable declared with type underscore",
diff --git a/tests/ui/let_with_type_underscore.rs b/tests/ui/let_with_type_underscore.rs
index 7c1835e8cd1..832d0304ffa 100644
--- a/tests/ui/let_with_type_underscore.rs
+++ b/tests/ui/let_with_type_underscore.rs
@@ -1,7 +1,10 @@
+//@aux-build: proc_macros.rs
 #![allow(unused)]
 #![warn(clippy::let_with_type_underscore)]
 #![allow(clippy::let_unit_value)]
 
+extern crate proc_macros;
+
 fn func() -> &'static str {
     ""
 }
@@ -16,4 +19,10 @@ fn main() {
     let x = func();
     let x: Vec<_> = Vec::<u32>::new();
     let x: [_; 1] = [1];
+
+    // do not lint from procedural macros
+    proc_macros::with_span! {
+        span
+        let x: _ = ();
+    };
 }
diff --git a/tests/ui/let_with_type_underscore.stderr b/tests/ui/let_with_type_underscore.stderr
index 16bf83c708f..26400363f5d 100644
--- a/tests/ui/let_with_type_underscore.stderr
+++ b/tests/ui/let_with_type_underscore.stderr
@@ -1,36 +1,36 @@
 error: variable declared with type underscore
-  --> $DIR/let_with_type_underscore.rs:11:5
+  --> $DIR/let_with_type_underscore.rs:14:5
    |
 LL |     let x: _ = 1;
    |     ^^^^^^^^^^^^^
    |
 help: remove the explicit type `_` declaration
-  --> $DIR/let_with_type_underscore.rs:11:10
+  --> $DIR/let_with_type_underscore.rs:14:10
    |
 LL |     let x: _ = 1;
    |          ^^^
    = note: `-D clippy::let-with-type-underscore` implied by `-D warnings`
 
 error: variable declared with type underscore
-  --> $DIR/let_with_type_underscore.rs:12:5
+  --> $DIR/let_with_type_underscore.rs:15:5
    |
 LL |     let _: _ = 2;
    |     ^^^^^^^^^^^^^
    |
 help: remove the explicit type `_` declaration
-  --> $DIR/let_with_type_underscore.rs:12:10
+  --> $DIR/let_with_type_underscore.rs:15:10
    |
 LL |     let _: _ = 2;
    |          ^^^
 
 error: variable declared with type underscore
-  --> $DIR/let_with_type_underscore.rs:13:5
+  --> $DIR/let_with_type_underscore.rs:16:5
    |
 LL |     let x: _ = func();
    |     ^^^^^^^^^^^^^^^^^^
    |
 help: remove the explicit type `_` declaration
-  --> $DIR/let_with_type_underscore.rs:13:10
+  --> $DIR/let_with_type_underscore.rs:16:10
    |
 LL |     let x: _ = func();
    |          ^^^
-- 
cgit 1.4.1-3-g733a5


From 6f13a37499191a19f5115a8cbe8b5431f269ab7e Mon Sep 17 00:00:00 2001
From: beetrees <b@beetr.ee>
Date: Sat, 8 Apr 2023 14:53:50 +0100
Subject: Add spans to `clippy.toml` error messages

---
 Cargo.toml                                         |   2 +-
 clippy_lints/Cargo.toml                            |   2 +-
 clippy_lints/src/lib.rs                            |  39 ++--
 clippy_lints/src/nonstandard_macro_braces.rs       |   2 +-
 clippy_lints/src/utils/conf.rs                     | 207 +++++++++++----------
 lintcheck/Cargo.toml                               |   2 +-
 src/driver.rs                                      |  15 +-
 tests/ui-toml/bad_toml/conf_bad_toml.stderr        |   6 +-
 tests/ui-toml/bad_toml_type/conf_bad_type.stderr   |   6 +-
 .../conf_deprecated_key/conf_deprecated_key.stderr |  12 +-
 tests/ui-toml/duplicated_keys/clippy.toml          |   3 -
 .../ui-toml/duplicated_keys/duplicated_keys.stderr |  12 +-
 .../ui-toml/duplicated_keys_deprecated/clippy.toml |   3 +
 .../duplicated_keys_deprecated/duplicated_keys.rs  |   1 +
 .../duplicated_keys.stderr                         |  14 ++
 .../duplicated_keys_deprecated_2/clippy.toml       |   4 +
 .../duplicated_keys.rs                             |   1 +
 .../duplicated_keys.stderr                         |  14 ++
 tests/ui-toml/toml_unknown_key/clippy.toml         |   4 +-
 .../toml_unknown_key/conf_unknown_key.stderr       |  70 ++++++-
 20 files changed, 278 insertions(+), 141 deletions(-)
 create mode 100644 tests/ui-toml/duplicated_keys_deprecated/clippy.toml
 create mode 100644 tests/ui-toml/duplicated_keys_deprecated/duplicated_keys.rs
 create mode 100644 tests/ui-toml/duplicated_keys_deprecated/duplicated_keys.stderr
 create mode 100644 tests/ui-toml/duplicated_keys_deprecated_2/clippy.toml
 create mode 100644 tests/ui-toml/duplicated_keys_deprecated_2/duplicated_keys.rs
 create mode 100644 tests/ui-toml/duplicated_keys_deprecated_2/duplicated_keys.stderr

(limited to 'clippy_lints/src')

diff --git a/Cargo.toml b/Cargo.toml
index 3c72bb62ed1..8739e458080 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -30,7 +30,7 @@ termize = "0.1"
 compiletest_rs = { version = "0.10", features = ["tmp"] }
 tester = "0.9"
 regex = "1.5"
-toml = "0.5"
+toml = "0.7.3"
 walkdir = "2.3"
 # This is used by the `collect-metadata` alias.
 filetime = "0.2"
diff --git a/clippy_lints/Cargo.toml b/clippy_lints/Cargo.toml
index a0db69b652d..3419d8c7872 100644
--- a/clippy_lints/Cargo.toml
+++ b/clippy_lints/Cargo.toml
@@ -21,7 +21,7 @@ regex-syntax = "0.6"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = { version = "1.0", optional = true }
 tempfile = { version = "3.3.0", optional = true }
-toml = "0.5"
+toml = "0.7.3"
 unicode-normalization = "0.1"
 unicode-script = { version = "0.5", default-features = false }
 semver = "1.0"
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 38f4ecc75b6..b728a445c20 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -334,7 +334,7 @@ mod zero_sized_map_values;
 
 pub use crate::utils::conf::{lookup_conf_file, Conf};
 use crate::utils::{
-    conf::{format_error, metadata::get_configuration_metadata, TryConf},
+    conf::{metadata::get_configuration_metadata, TryConf},
     FindAll,
 };
 
@@ -370,23 +370,36 @@ pub fn read_conf(sess: &Session, path: &io::Result<(Option<PathBuf>, Vec<String>
         },
     };
 
-    let TryConf { conf, errors, warnings } = utils::conf::read(file_name);
+    let TryConf { conf, errors, warnings } = utils::conf::read(sess, file_name);
     // all conf errors are non-fatal, we just use the default conf in case of error
     for error in errors {
-        sess.err(format!(
-            "error reading Clippy's configuration file `{}`: {}",
-            file_name.display(),
-            format_error(error)
-        ));
+        if let Some(span) = error.span {
+            sess.span_err(
+                span,
+                format!("error reading Clippy's configuration file: {}", error.message),
+            );
+        } else {
+            sess.err(format!(
+                "error reading Clippy's configuration file `{}`: {}",
+                file_name.display(),
+                error.message
+            ));
+        }
     }
 
     for warning in warnings {
-        sess.struct_warn(format!(
-            "error reading Clippy's configuration file `{}`: {}",
-            file_name.display(),
-            format_error(warning)
-        ))
-        .emit();
+        if let Some(span) = warning.span {
+            sess.span_warn(
+                span,
+                format!("error reading Clippy's configuration file: {}", warning.message),
+            );
+        } else {
+            sess.warn(format!(
+                "error reading Clippy's configuration file `{}`: {}",
+                file_name.display(),
+                warning.message
+            ));
+        }
     }
 
     conf
diff --git a/clippy_lints/src/nonstandard_macro_braces.rs b/clippy_lints/src/nonstandard_macro_braces.rs
index 6c909e5ed73..2d79a5c9008 100644
--- a/clippy_lints/src/nonstandard_macro_braces.rs
+++ b/clippy_lints/src/nonstandard_macro_braces.rs
@@ -241,7 +241,7 @@ impl<'de> Deserialize<'de> for MacroMatcher {
                 V: de::MapAccess<'de>,
             {
                 let mut name = None;
-                let mut brace: Option<&str> = None;
+                let mut brace: Option<String> = None;
                 while let Some(key) = map.next_key()? {
                     match key {
                         Field::Name => {
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index f6de66bb514..030894b58f7 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -2,12 +2,15 @@
 
 #![allow(clippy::module_name_repetitions)]
 
+use rustc_session::Session;
+use rustc_span::{BytePos, Pos, SourceFile, Span, SyntaxContext};
 use serde::de::{Deserializer, IgnoredAny, IntoDeserializer, MapAccess, Visitor};
 use serde::Deserialize;
-use std::error::Error;
+use std::fmt::{Debug, Display, Formatter};
+use std::ops::Range;
 use std::path::{Path, PathBuf};
 use std::str::FromStr;
-use std::{cmp, env, fmt, fs, io, iter};
+use std::{cmp, env, fmt, fs, io};
 
 #[rustfmt::skip]
 const DEFAULT_DOC_VALID_IDENTS: &[&str] = &[
@@ -67,33 +70,70 @@ impl DisallowedPath {
 #[derive(Default)]
 pub struct TryConf {
     pub conf: Conf,
-    pub errors: Vec<Box<dyn Error>>,
-    pub warnings: Vec<Box<dyn Error>>,
+    pub errors: Vec<ConfError>,
+    pub warnings: Vec<ConfError>,
 }
 
 impl TryConf {
-    fn from_error(error: impl Error + 'static) -> Self {
+    fn from_toml_error(file: &SourceFile, error: &toml::de::Error) -> Self {
+        ConfError::from_toml(file, error).into()
+    }
+}
+
+impl From<ConfError> for TryConf {
+    fn from(value: ConfError) -> Self {
         Self {
             conf: Conf::default(),
-            errors: vec![Box::new(error)],
+            errors: vec![value],
             warnings: vec![],
         }
     }
 }
 
+impl From<io::Error> for TryConf {
+    fn from(value: io::Error) -> Self {
+        ConfError::from(value).into()
+    }
+}
+
 #[derive(Debug)]
-struct ConfError(String);
+pub struct ConfError {
+    pub message: String,
+    pub span: Option<Span>,
+}
+
+impl ConfError {
+    fn from_toml(file: &SourceFile, error: &toml::de::Error) -> Self {
+        if let Some(span) = error.span() {
+            Self::spanned(file, error.message(), span)
+        } else {
+            Self {
+                message: error.message().to_string(),
+                span: None,
+            }
+        }
+    }
 
-impl fmt::Display for ConfError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        <String as fmt::Display>::fmt(&self.0, f)
+    fn spanned(file: &SourceFile, message: impl Into<String>, span: Range<usize>) -> Self {
+        Self {
+            message: message.into(),
+            span: Some(Span::new(
+                file.start_pos + BytePos::from_usize(span.start),
+                file.start_pos + BytePos::from_usize(span.end),
+                SyntaxContext::root(),
+                None,
+            )),
+        }
     }
 }
 
-impl Error for ConfError {}
-
-fn conf_error(s: impl Into<String>) -> Box<dyn Error> {
-    Box::new(ConfError(s.into()))
+impl From<io::Error> for ConfError {
+    fn from(value: io::Error) -> Self {
+        Self {
+            message: value.to_string(),
+            span: None,
+        }
+    }
 }
 
 macro_rules! define_Conf {
@@ -117,20 +157,14 @@ macro_rules! define_Conf {
             }
         }
 
-        impl<'de> Deserialize<'de> for TryConf {
-            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de> {
-                deserializer.deserialize_map(ConfVisitor)
-            }
-        }
-
         #[derive(Deserialize)]
         #[serde(field_identifier, rename_all = "kebab-case")]
         #[allow(non_camel_case_types)]
         enum Field { $($name,)* third_party, }
 
-        struct ConfVisitor;
+        struct ConfVisitor<'a>(&'a SourceFile);
 
-        impl<'de> Visitor<'de> for ConfVisitor {
+        impl<'de> Visitor<'de> for ConfVisitor<'_> {
             type Value = TryConf;
 
             fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
@@ -141,32 +175,38 @@ macro_rules! define_Conf {
                 let mut errors = Vec::new();
                 let mut warnings = Vec::new();
                 $(let mut $name = None;)*
-                // could get `Field` here directly, but get `str` first for diagnostics
-                while let Some(name) = map.next_key::<&str>()? {
-                    match Field::deserialize(name.into_deserializer())? {
-                        $(Field::$name => {
-                            $(warnings.push(conf_error(format!("deprecated field `{}`. {}", name, $dep)));)?
-                            match map.next_value() {
-                                Err(e) => errors.push(conf_error(e.to_string())),
+                // could get `Field` here directly, but get `String` first for diagnostics
+                while let Some(name) = map.next_key::<toml::Spanned<String>>()? {
+                    match Field::deserialize(name.get_ref().as_str().into_deserializer()) {
+                        Err(e) => {
+                            let e: FieldError = e;
+                            errors.push(ConfError::spanned(self.0, e.0, name.span()));
+                        }
+                        $(Ok(Field::$name) => {
+                            $(warnings.push(ConfError::spanned(self.0, format!("deprecated field `{}`. {}", name.get_ref(), $dep), name.span()));)?
+                            let raw_value = map.next_value::<toml::Spanned<toml::Value>>()?;
+                            let value_span = raw_value.span();
+                            match <$ty>::deserialize(raw_value.into_inner()) {
+                                Err(e) => errors.push(ConfError::spanned(self.0, e.to_string().replace('\n', " ").trim(), value_span)),
                                 Ok(value) => match $name {
-                                    Some(_) => errors.push(conf_error(format!("duplicate field `{}`", name))),
+                                    Some(_) => errors.push(ConfError::spanned(self.0, format!("duplicate field `{}`", name.get_ref()), name.span())),
                                     None => {
                                         $name = Some(value);
                                         // $new_conf is the same as one of the defined `$name`s, so
                                         // this variable is defined in line 2 of this function.
                                         $(match $new_conf {
-                                            Some(_) => errors.push(conf_error(concat!(
+                                            Some(_) => errors.push(ConfError::spanned(self.0, concat!(
                                                 "duplicate field `", stringify!($new_conf),
                                                 "` (provided as `", stringify!($name), "`)"
-                                            ))),
+                                            ), name.span())),
                                             None => $new_conf = $name.clone(),
                                         })?
                                     },
                                 }
                             }
                         })*
-                        // white-listed; ignore
-                        Field::third_party => drop(map.next_value::<IgnoredAny>())
+                        // ignore contents of the third_party key
+                        Ok(Field::third_party) => drop(map.next_value::<IgnoredAny>())
                     }
                 }
                 let conf = Conf { $($name: $name.unwrap_or_else(defaults::$name),)* };
@@ -532,19 +572,19 @@ pub fn lookup_conf_file() -> io::Result<(Option<PathBuf>, Vec<String>)> {
 /// Read the `toml` configuration file.
 ///
 /// In case of error, the function tries to continue as much as possible.
-pub fn read(path: &Path) -> TryConf {
-    let content = match fs::read_to_string(path) {
-        Err(e) => return TryConf::from_error(e),
-        Ok(content) => content,
+pub fn read(sess: &Session, path: &Path) -> TryConf {
+    let file = match sess.source_map().load_file(path) {
+        Err(e) => return e.into(),
+        Ok(file) => file,
     };
-    match toml::from_str::<TryConf>(&content) {
+    match toml::de::Deserializer::new(file.src.as_ref().unwrap()).deserialize_map(ConfVisitor(&file)) {
         Ok(mut conf) => {
             extend_vec_if_indicator_present(&mut conf.conf.doc_valid_idents, DEFAULT_DOC_VALID_IDENTS);
             extend_vec_if_indicator_present(&mut conf.conf.disallowed_names, DEFAULT_DISALLOWED_NAMES);
 
             conf
         },
-        Err(e) => TryConf::from_error(e),
+        Err(e) => TryConf::from_toml_error(&file, &e),
     }
 }
 
@@ -556,65 +596,42 @@ fn extend_vec_if_indicator_present(vec: &mut Vec<String>, default: &[&str]) {
 
 const SEPARATOR_WIDTH: usize = 4;
 
-// Check whether the error is "unknown field" and, if so, list the available fields sorted and at
-// least one per line, more if `CLIPPY_TERMINAL_WIDTH` is set and allows it.
-pub fn format_error(error: Box<dyn Error>) -> String {
-    let s = error.to_string();
-
-    if_chain! {
-        if error.downcast::<toml::de::Error>().is_ok();
-        if let Some((prefix, mut fields, suffix)) = parse_unknown_field_message(&s);
-        then {
-            use fmt::Write;
-
-            fields.sort_unstable();
-
-            let (rows, column_widths) = calculate_dimensions(&fields);
-
-            let mut msg = String::from(prefix);
-            for row in 0..rows {
-                writeln!(msg).unwrap();
-                for (column, column_width) in column_widths.iter().copied().enumerate() {
-                    let index = column * rows + row;
-                    let field = fields.get(index).copied().unwrap_or_default();
-                    write!(
-                        msg,
-                        "{:SEPARATOR_WIDTH$}{field:column_width$}",
-                        " "
-                    )
-                    .unwrap();
-                }
-            }
-            write!(msg, "\n{suffix}").unwrap();
-            msg
-        } else {
-            s
-        }
+#[derive(Debug)]
+struct FieldError(String);
+
+impl std::error::Error for FieldError {}
+
+impl Display for FieldError {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        f.pad(&self.0)
     }
 }
 
-// `parse_unknown_field_message` will become unnecessary if
-// https://github.com/alexcrichton/toml-rs/pull/364 is merged.
-fn parse_unknown_field_message(s: &str) -> Option<(&str, Vec<&str>, &str)> {
-    // An "unknown field" message has the following form:
-    //   unknown field `UNKNOWN`, expected one of `FIELD0`, `FIELD1`, ..., `FIELDN` at line X column Y
-    //                                           ^^      ^^^^                     ^^
-    if_chain! {
-        if s.starts_with("unknown field");
-        let slices = s.split("`, `").collect::<Vec<_>>();
-        let n = slices.len();
-        if n >= 2;
-        if let Some((prefix, first_field)) = slices[0].rsplit_once(" `");
-        if let Some((last_field, suffix)) = slices[n - 1].split_once("` ");
-        then {
-            let fields = iter::once(first_field)
-                .chain(slices[1..n - 1].iter().copied())
-                .chain(iter::once(last_field))
-                .collect::<Vec<_>>();
-            Some((prefix, fields, suffix))
-        } else {
-            None
+impl serde::de::Error for FieldError {
+    fn custom<T: Display>(msg: T) -> Self {
+        Self(msg.to_string())
+    }
+
+    fn unknown_field(field: &str, expected: &'static [&'static str]) -> Self {
+        // List the available fields sorted and at least one per line, more if `CLIPPY_TERMINAL_WIDTH` is
+        // set and allows it.
+        use fmt::Write;
+
+        let mut expected = expected.to_vec();
+        expected.sort_unstable();
+
+        let (rows, column_widths) = calculate_dimensions(&expected);
+
+        let mut msg = format!("unknown field `{field}`, expected one of");
+        for row in 0..rows {
+            writeln!(msg).unwrap();
+            for (column, column_width) in column_widths.iter().copied().enumerate() {
+                let index = column * rows + row;
+                let field = expected.get(index).copied().unwrap_or_default();
+                write!(msg, "{:SEPARATOR_WIDTH$}{field:column_width$}", " ").unwrap();
+            }
         }
+        Self(msg)
     }
 }
 
diff --git a/lintcheck/Cargo.toml b/lintcheck/Cargo.toml
index 27d32f39003..a828d123704 100644
--- a/lintcheck/Cargo.toml
+++ b/lintcheck/Cargo.toml
@@ -22,7 +22,7 @@ rayon = "1.5.1"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0.85"
 tar = "0.4"
-toml = "0.5"
+toml = "0.7.3"
 ureq = "2.2"
 walkdir = "2.3"
 
diff --git a/src/driver.rs b/src/driver.rs
index 205905d5091..90ee3ff6eb6 100644
--- a/src/driver.rs
+++ b/src/driver.rs
@@ -74,7 +74,7 @@ fn track_clippy_args(parse_sess: &mut ParseSess, args_env_var: &Option<String>)
 
 /// Track files that may be accessed at runtime in `file_depinfo` so that cargo will re-run clippy
 /// when any of them are modified
-fn track_files(parse_sess: &mut ParseSess, conf_path_string: Option<String>) {
+fn track_files(parse_sess: &mut ParseSess) {
     let file_depinfo = parse_sess.file_depinfo.get_mut();
 
     // Used by `clippy::cargo` lints and to determine the MSRV. `cargo clippy` executes `clippy-driver`
@@ -83,10 +83,7 @@ fn track_files(parse_sess: &mut ParseSess, conf_path_string: Option<String>) {
         file_depinfo.insert(Symbol::intern("Cargo.toml"));
     }
 
-    // `clippy.toml`
-    if let Some(path) = conf_path_string {
-        file_depinfo.insert(Symbol::intern(&path));
-    }
+    // `clippy.toml` will be automatically tracked as it's loaded with `sess.source_map().load_file()`
 
     // During development track the `clippy-driver` executable so that cargo will re-run clippy whenever
     // it is rebuilt
@@ -130,17 +127,11 @@ impl rustc_driver::Callbacks for ClippyCallbacks {
     #[allow(rustc::bad_opt_access)]
     fn config(&mut self, config: &mut interface::Config) {
         let conf_path = clippy_lints::lookup_conf_file();
-        let conf_path_string = if let Ok((Some(path), _)) = &conf_path {
-            path.to_str().map(String::from)
-        } else {
-            None
-        };
-
         let previous = config.register_lints.take();
         let clippy_args_var = self.clippy_args_var.take();
         config.parse_sess_created = Some(Box::new(move |parse_sess| {
             track_clippy_args(parse_sess, &clippy_args_var);
-            track_files(parse_sess, conf_path_string);
+            track_files(parse_sess);
         }));
         config.register_lints = Some(Box::new(move |sess, lint_store| {
             // technically we're ~guaranteed that this is none but might as well call anything that
diff --git a/tests/ui-toml/bad_toml/conf_bad_toml.stderr b/tests/ui-toml/bad_toml/conf_bad_toml.stderr
index 28c1a568a63..5b7e8c0db74 100644
--- a/tests/ui-toml/bad_toml/conf_bad_toml.stderr
+++ b/tests/ui-toml/bad_toml/conf_bad_toml.stderr
@@ -1,4 +1,8 @@
-error: error reading Clippy's configuration file `$DIR/clippy.toml`: expected an equals, found an identifier at line 1 column 4
+error: error reading Clippy's configuration file: expected `.`, `=`
+  --> $DIR/clippy.toml:1:4
+   |
+LL | fn this_is_obviously(not: a, toml: file) {
+   |    ^
 
 error: aborting due to previous error
 
diff --git a/tests/ui-toml/bad_toml_type/conf_bad_type.stderr b/tests/ui-toml/bad_toml_type/conf_bad_type.stderr
index e3ec6019204..386e1135df9 100644
--- a/tests/ui-toml/bad_toml_type/conf_bad_type.stderr
+++ b/tests/ui-toml/bad_toml_type/conf_bad_type.stderr
@@ -1,4 +1,8 @@
-error: error reading Clippy's configuration file `$DIR/clippy.toml`: invalid type: integer `42`, expected a sequence for key `disallowed-names`
+error: error reading Clippy's configuration file: invalid type: integer `42`, expected a sequence
+  --> $DIR/clippy.toml:1:20
+   |
+LL | disallowed-names = 42
+   |                    ^^
 
 error: aborting due to previous error
 
diff --git a/tests/ui-toml/conf_deprecated_key/conf_deprecated_key.stderr b/tests/ui-toml/conf_deprecated_key/conf_deprecated_key.stderr
index 630bad07c5b..123ad94dd09 100644
--- a/tests/ui-toml/conf_deprecated_key/conf_deprecated_key.stderr
+++ b/tests/ui-toml/conf_deprecated_key/conf_deprecated_key.stderr
@@ -1,6 +1,14 @@
-warning: error reading Clippy's configuration file `$DIR/clippy.toml`: deprecated field `cyclomatic-complexity-threshold`. Please use `cognitive-complexity-threshold` instead
+warning: error reading Clippy's configuration file: deprecated field `cyclomatic-complexity-threshold`. Please use `cognitive-complexity-threshold` instead
+  --> $DIR/clippy.toml:2:1
+   |
+LL | cyclomatic-complexity-threshold = 2
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-warning: error reading Clippy's configuration file `$DIR/clippy.toml`: deprecated field `blacklisted-names`. Please use `disallowed-names` instead
+warning: error reading Clippy's configuration file: deprecated field `blacklisted-names`. Please use `disallowed-names` instead
+  --> $DIR/clippy.toml:3:1
+   |
+LL | blacklisted-names = [ "..", "wibble" ]
+   | ^^^^^^^^^^^^^^^^^
 
 error: the function has a cognitive complexity of (3/2)
   --> $DIR/conf_deprecated_key.rs:6:4
diff --git a/tests/ui-toml/duplicated_keys/clippy.toml b/tests/ui-toml/duplicated_keys/clippy.toml
index 63a893cc6c7..55789afc1b7 100644
--- a/tests/ui-toml/duplicated_keys/clippy.toml
+++ b/tests/ui-toml/duplicated_keys/clippy.toml
@@ -1,5 +1,2 @@
 cognitive-complexity-threshold = 2
-# This is the deprecated name for the same key
-cyclomatic-complexity-threshold = 3
-# Check we get duplication warning regardless of order
 cognitive-complexity-threshold = 4
diff --git a/tests/ui-toml/duplicated_keys/duplicated_keys.stderr b/tests/ui-toml/duplicated_keys/duplicated_keys.stderr
index d99490a242d..54997735274 100644
--- a/tests/ui-toml/duplicated_keys/duplicated_keys.stderr
+++ b/tests/ui-toml/duplicated_keys/duplicated_keys.stderr
@@ -1,8 +1,8 @@
-error: error reading Clippy's configuration file `$DIR/clippy.toml`: duplicate field `cognitive_complexity_threshold` (provided as `cyclomatic_complexity_threshold`)
+error: error reading Clippy's configuration file: duplicate key `cognitive-complexity-threshold` in document root
+  --> $DIR/clippy.toml:2:1
+   |
+LL | cognitive-complexity-threshold = 4
+   | ^
 
-error: error reading Clippy's configuration file `$DIR/clippy.toml`: duplicate field `cognitive-complexity-threshold`
-
-warning: error reading Clippy's configuration file `$DIR/clippy.toml`: deprecated field `cyclomatic-complexity-threshold`. Please use `cognitive-complexity-threshold` instead
-
-error: aborting due to 2 previous errors; 1 warning emitted
+error: aborting due to previous error
 
diff --git a/tests/ui-toml/duplicated_keys_deprecated/clippy.toml b/tests/ui-toml/duplicated_keys_deprecated/clippy.toml
new file mode 100644
index 00000000000..7932c43ebd2
--- /dev/null
+++ b/tests/ui-toml/duplicated_keys_deprecated/clippy.toml
@@ -0,0 +1,3 @@
+cognitive-complexity-threshold = 2
+# This is the deprecated name for the same key
+cyclomatic-complexity-threshold = 3
diff --git a/tests/ui-toml/duplicated_keys_deprecated/duplicated_keys.rs b/tests/ui-toml/duplicated_keys_deprecated/duplicated_keys.rs
new file mode 100644
index 00000000000..f328e4d9d04
--- /dev/null
+++ b/tests/ui-toml/duplicated_keys_deprecated/duplicated_keys.rs
@@ -0,0 +1 @@
+fn main() {}
diff --git a/tests/ui-toml/duplicated_keys_deprecated/duplicated_keys.stderr b/tests/ui-toml/duplicated_keys_deprecated/duplicated_keys.stderr
new file mode 100644
index 00000000000..2ae7848f183
--- /dev/null
+++ b/tests/ui-toml/duplicated_keys_deprecated/duplicated_keys.stderr
@@ -0,0 +1,14 @@
+error: error reading Clippy's configuration file: duplicate field `cognitive_complexity_threshold` (provided as `cyclomatic_complexity_threshold`)
+  --> $DIR/clippy.toml:3:1
+   |
+LL | cyclomatic-complexity-threshold = 3
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+warning: error reading Clippy's configuration file: deprecated field `cyclomatic-complexity-threshold`. Please use `cognitive-complexity-threshold` instead
+  --> $DIR/clippy.toml:3:1
+   |
+LL | cyclomatic-complexity-threshold = 3
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to previous error; 1 warning emitted
+
diff --git a/tests/ui-toml/duplicated_keys_deprecated_2/clippy.toml b/tests/ui-toml/duplicated_keys_deprecated_2/clippy.toml
new file mode 100644
index 00000000000..53c634b727e
--- /dev/null
+++ b/tests/ui-toml/duplicated_keys_deprecated_2/clippy.toml
@@ -0,0 +1,4 @@
+# This is the deprecated name for cognitive-complexity-threshold
+cyclomatic-complexity-threshold = 3
+# Check we get duplication warning regardless of order
+cognitive-complexity-threshold = 4
diff --git a/tests/ui-toml/duplicated_keys_deprecated_2/duplicated_keys.rs b/tests/ui-toml/duplicated_keys_deprecated_2/duplicated_keys.rs
new file mode 100644
index 00000000000..f328e4d9d04
--- /dev/null
+++ b/tests/ui-toml/duplicated_keys_deprecated_2/duplicated_keys.rs
@@ -0,0 +1 @@
+fn main() {}
diff --git a/tests/ui-toml/duplicated_keys_deprecated_2/duplicated_keys.stderr b/tests/ui-toml/duplicated_keys_deprecated_2/duplicated_keys.stderr
new file mode 100644
index 00000000000..53ad4271246
--- /dev/null
+++ b/tests/ui-toml/duplicated_keys_deprecated_2/duplicated_keys.stderr
@@ -0,0 +1,14 @@
+error: error reading Clippy's configuration file: duplicate field `cognitive-complexity-threshold`
+  --> $DIR/clippy.toml:4:1
+   |
+LL | cognitive-complexity-threshold = 4
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+warning: error reading Clippy's configuration file: deprecated field `cyclomatic-complexity-threshold`. Please use `cognitive-complexity-threshold` instead
+  --> $DIR/clippy.toml:2:1
+   |
+LL | cyclomatic-complexity-threshold = 3
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to previous error; 1 warning emitted
+
diff --git a/tests/ui-toml/toml_unknown_key/clippy.toml b/tests/ui-toml/toml_unknown_key/clippy.toml
index 554b87cc50b..b77b4580051 100644
--- a/tests/ui-toml/toml_unknown_key/clippy.toml
+++ b/tests/ui-toml/toml_unknown_key/clippy.toml
@@ -1,6 +1,8 @@
 # that one is an error
 foobar = 42
+# so is this one
+barfoo = 53
 
-# that one is white-listed
+# that one is ignored
 [third-party]
 clippy-feature = "nightly"
diff --git a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
index 44710b09648..b6038f031f3 100644
--- a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
+++ b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
@@ -1,4 +1,4 @@
-error: error reading Clippy's configuration file `$DIR/clippy.toml`: unknown field `foobar`, expected one of
+error: error reading Clippy's configuration file: unknown field `foobar`, expected one of
            allow-dbg-in-tests
            allow-expect-in-tests
            allow-mixed-uninlined-format-args
@@ -54,7 +54,71 @@ error: error reading Clippy's configuration file `$DIR/clippy.toml`: unknown fie
            vec-box-size-threshold
            verbose-bit-mask-threshold
            warn-on-all-wildcard-imports
-       at line 5 column 1
+  --> $DIR/clippy.toml:2:1
+   |
+LL | foobar = 42
+   | ^^^^^^
 
-error: aborting due to previous error
+error: error reading Clippy's configuration file: unknown field `barfoo`, expected one of
+           allow-dbg-in-tests
+           allow-expect-in-tests
+           allow-mixed-uninlined-format-args
+           allow-print-in-tests
+           allow-unwrap-in-tests
+           allowed-scripts
+           arithmetic-side-effects-allowed
+           arithmetic-side-effects-allowed-binary
+           arithmetic-side-effects-allowed-unary
+           array-size-threshold
+           avoid-breaking-exported-api
+           await-holding-invalid-types
+           blacklisted-names
+           cargo-ignore-publish
+           cognitive-complexity-threshold
+           cyclomatic-complexity-threshold
+           disallowed-macros
+           disallowed-methods
+           disallowed-names
+           disallowed-types
+           doc-valid-idents
+           enable-raw-pointer-heuristic-for-send
+           enforced-import-renames
+           enum-variant-name-threshold
+           enum-variant-size-threshold
+           future-size-threshold
+           ignore-interior-mutability
+           large-error-threshold
+           literal-representation-threshold
+           matches-for-let-else
+           max-fn-params-bools
+           max-include-file-size
+           max-struct-bools
+           max-suggested-slice-pattern-length
+           max-trait-bounds
+           missing-docs-in-crate-items
+           msrv
+           pass-by-value-size-limit
+           semicolon-inside-block-ignore-singleline
+           semicolon-outside-block-ignore-multiline
+           single-char-binding-names-threshold
+           standard-macro-braces
+           suppress-restriction-lint-in-const
+           third-party
+           too-large-for-stack
+           too-many-arguments-threshold
+           too-many-lines-threshold
+           trivial-copy-size-limit
+           type-complexity-threshold
+           unnecessary-box-size
+           unreadable-literal-lint-fractions
+           upper-case-acronyms-aggressive
+           vec-box-size-threshold
+           verbose-bit-mask-threshold
+           warn-on-all-wildcard-imports
+  --> $DIR/clippy.toml:4:1
+   |
+LL | barfoo = 53
+   | ^^^^^^
+
+error: aborting due to 2 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 0086b6ab0a5a9a6a8e500f5742886097ed453a6d Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Thu, 1 Jun 2023 20:24:41 -0500
Subject: don't lint `allow_attributes` on attributes from proc macros

---
 clippy_lints/src/allow_attributes.rs            |  3 +-
 clippy_lints/src/attrs.rs                       |  9 +++--
 clippy_utils/src/check_proc_macro.rs            | 44 ++++++++++++++++++++++++-
 tests/ui/allow_attributes.fixed                 | 22 +++++++++++--
 tests/ui/allow_attributes.rs                    | 20 ++++++++++-
 tests/ui/allow_attributes.stderr                | 10 ++----
 tests/ui/allow_attributes_false_positive.rs     |  5 ---
 tests/ui/allow_attributes_without_reason.rs     | 18 +++++++++-
 tests/ui/allow_attributes_without_reason.stderr | 28 ++++++++++++----
 9 files changed, 131 insertions(+), 28 deletions(-)
 delete mode 100644 tests/ui/allow_attributes_false_positive.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/allow_attributes.rs b/clippy_lints/src/allow_attributes.rs
index 554efdc58e1..69ccbeb7b06 100644
--- a/clippy_lints/src/allow_attributes.rs
+++ b/clippy_lints/src/allow_attributes.rs
@@ -1,5 +1,5 @@
 use ast::AttrStyle;
-use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::{diagnostics::span_lint_and_sugg, is_from_proc_macro};
 use rustc_ast as ast;
 use rustc_errors::Applicability;
 use rustc_lint::{LateContext, LateLintPass, LintContext};
@@ -57,6 +57,7 @@ impl LateLintPass<'_> for AllowAttribute {
             if let AttrStyle::Outer = attr.style;
             if let Some(ident) = attr.ident();
             if ident.name == rustc_span::symbol::sym::allow;
+            if !is_from_proc_macro(cx, &(attr, cx));
             then {
                 span_lint_and_sugg(
                     cx,
diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs
index 897495ba108..e989cde0f3c 100644
--- a/clippy_lints/src/attrs.rs
+++ b/clippy_lints/src/attrs.rs
@@ -1,9 +1,12 @@
 //! checks for attributes
 
-use clippy_utils::diagnostics::{span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::macros::{is_panic, macro_backtrace};
 use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::{first_line_of_span, is_present_in_source, snippet_opt, without_block_comments};
+use clippy_utils::{
+    diagnostics::{span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then},
+    is_from_proc_macro,
+};
 use if_chain::if_chain;
 use rustc_ast::{AttrKind, AttrStyle, Attribute, LitKind, MetaItemKind, MetaItemLit, NestedMetaItem};
 use rustc_errors::Applicability;
@@ -540,7 +543,7 @@ fn check_clippy_lint_names(cx: &LateContext<'_>, name: Symbol, items: &[NestedMe
     }
 }
 
-fn check_lint_reason(cx: &LateContext<'_>, name: Symbol, items: &[NestedMetaItem], attr: &'_ Attribute) {
+fn check_lint_reason(cx: &LateContext<'_>, name: Symbol, items: &[NestedMetaItem], attr: &Attribute) {
     // Check for the feature
     if !cx.tcx.features().lint_reasons {
         return;
@@ -555,7 +558,7 @@ fn check_lint_reason(cx: &LateContext<'_>, name: Symbol, items: &[NestedMetaItem
     }
 
     // Check if the attribute is in an external macro and therefore out of the developer's control
-    if in_external_macro(cx.sess(), attr.span) {
+    if in_external_macro(cx.sess(), attr.span) || is_from_proc_macro(cx, &(attr, cx)) {
         return;
     }
 
diff --git a/clippy_utils/src/check_proc_macro.rs b/clippy_utils/src/check_proc_macro.rs
index 9edaae85373..8a8ccc30205 100644
--- a/clippy_utils/src/check_proc_macro.rs
+++ b/clippy_utils/src/check_proc_macro.rs
@@ -12,7 +12,11 @@
 //! code was written, and check if the span contains that text. Note this will only work correctly
 //! if the span is not from a `macro_rules` based macro.
 
-use rustc_ast::ast::{IntTy, LitIntType, LitKind, StrStyle, UintTy};
+use rustc_ast::{
+    ast::{AttrKind, Attribute, IntTy, LitIntType, LitKind, StrStyle, UintTy},
+    token::CommentKind,
+    AttrStyle,
+};
 use rustc_hir::{
     intravisit::FnKind, Block, BlockCheckMode, Body, Closure, Destination, Expr, ExprKind, FieldDef, FnHeader, HirId,
     Impl, ImplItem, ImplItemKind, IsAuto, Item, ItemKind, LoopSource, MatchSource, Node, QPath, TraitItem,
@@ -271,6 +275,32 @@ fn fn_kind_pat(tcx: TyCtxt<'_>, kind: &FnKind<'_>, body: &Body<'_>, hir_id: HirI
     (start_pat, end_pat)
 }
 
+fn attr_search_pat(attr: &Attribute) -> (Pat, Pat) {
+    match attr.kind {
+        AttrKind::Normal(..) => {
+            if matches!(attr.style, AttrStyle::Outer) {
+                (Pat::Str("#["), Pat::Str("]"))
+            } else {
+                (Pat::Str("#!["), Pat::Str("]"))
+            }
+        },
+        AttrKind::DocComment(_kind @ CommentKind::Line, ..) => {
+            if matches!(attr.style, AttrStyle::Outer) {
+                (Pat::Str("///"), Pat::Str(""))
+            } else {
+                (Pat::Str("//!"), Pat::Str(""))
+            }
+        },
+        AttrKind::DocComment(_kind @ CommentKind::Block, ..) => {
+            if matches!(attr.style, AttrStyle::Outer) {
+                (Pat::Str("/**"), Pat::Str("*/"))
+            } else {
+                (Pat::Str("/*!"), Pat::Str("*/"))
+            }
+        },
+    }
+}
+
 pub trait WithSearchPat {
     type Context: LintContext;
     fn search_pat(&self, cx: &Self::Context) -> (Pat, Pat);
@@ -310,6 +340,18 @@ impl<'cx> WithSearchPat for (&FnKind<'cx>, &Body<'cx>, HirId, Span) {
     }
 }
 
+impl<'cx> WithSearchPat for (&Attribute, &LateContext<'cx>) {
+    type Context = LateContext<'cx>;
+
+    fn search_pat(&self, _cx: &Self::Context) -> (Pat, Pat) {
+        attr_search_pat(&self.0)
+    }
+
+    fn span(&self) -> Span {
+        self.0.span
+    }
+}
+
 /// Checks if the item likely came from a proc-macro.
 ///
 /// This should be called after `in_external_macro` and the initial pattern matching of the ast as
diff --git a/tests/ui/allow_attributes.fixed b/tests/ui/allow_attributes.fixed
index f0936b2608e..be93c5bffe7 100644
--- a/tests/ui/allow_attributes.fixed
+++ b/tests/ui/allow_attributes.fixed
@@ -1,9 +1,12 @@
 //@run-rustfix
+//@aux-build:proc_macros.rs
 #![allow(unused)]
 #![warn(clippy::allow_attributes)]
 #![feature(lint_reasons)]
+#![no_main]
 
-fn main() {}
+extern crate proc_macros;
+use proc_macros::{external, with_span};
 
 // Using clippy::needless_borrow just as a placeholder, it isn't relevant.
 
@@ -17,9 +20,24 @@ struct T3;
 #[warn(clippy::needless_borrow)] // Should not lint
 struct T4;
 // `panic = "unwind"` should always be true
-#[cfg_attr(panic = "unwind", expect(dead_code))]
+#[cfg_attr(panic = "unwind", allow(dead_code))]
 struct CfgT;
 
+fn ignore_external() {
+    external! {
+        #[allow(clippy::needless_borrow)]
+        fn a() {}
+    }
+}
+
+fn ignore_proc_macro() {
+    with_span! {
+        span
+        #[allow(clippy::needless_borrow)] // Should not lint
+        fn a() {}
+    }
+}
+
 fn ignore_inner_attr() {
     #![allow(unused)] // Should not lint
 }
diff --git a/tests/ui/allow_attributes.rs b/tests/ui/allow_attributes.rs
index 2fb9e86126e..10d2ed1a8a9 100644
--- a/tests/ui/allow_attributes.rs
+++ b/tests/ui/allow_attributes.rs
@@ -1,9 +1,12 @@
 //@run-rustfix
+//@aux-build:proc_macros.rs
 #![allow(unused)]
 #![warn(clippy::allow_attributes)]
 #![feature(lint_reasons)]
+#![no_main]
 
-fn main() {}
+extern crate proc_macros;
+use proc_macros::{external, with_span};
 
 // Using clippy::needless_borrow just as a placeholder, it isn't relevant.
 
@@ -20,6 +23,21 @@ struct T4;
 #[cfg_attr(panic = "unwind", allow(dead_code))]
 struct CfgT;
 
+fn ignore_external() {
+    external! {
+        #[allow(clippy::needless_borrow)] // Should not lint
+        fn a() {}
+    }
+}
+
+fn ignore_proc_macro() {
+    with_span! {
+        span
+        #[allow(clippy::needless_borrow)] // Should not lint
+        fn a() {}
+    }
+}
+
 fn ignore_inner_attr() {
     #![allow(unused)] // Should not lint
 }
diff --git a/tests/ui/allow_attributes.stderr b/tests/ui/allow_attributes.stderr
index 681837e9ed7..37149104a47 100644
--- a/tests/ui/allow_attributes.stderr
+++ b/tests/ui/allow_attributes.stderr
@@ -1,16 +1,10 @@
 error: #[allow] attribute found
-  --> $DIR/allow_attributes.rs:11:3
+  --> $DIR/allow_attributes.rs:14:3
    |
 LL | #[allow(dead_code)]
    |   ^^^^^ help: replace it with: `expect`
    |
    = note: `-D clippy::allow-attributes` implied by `-D warnings`
 
-error: #[allow] attribute found
-  --> $DIR/allow_attributes.rs:20:30
-   |
-LL | #[cfg_attr(panic = "unwind", allow(dead_code))]
-   |                              ^^^^^ help: replace it with: `expect`
-
-error: aborting due to 2 previous errors
+error: aborting due to previous error
 
diff --git a/tests/ui/allow_attributes_false_positive.rs b/tests/ui/allow_attributes_false_positive.rs
deleted file mode 100644
index 5c3407628be..00000000000
--- a/tests/ui/allow_attributes_false_positive.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-#![warn(clippy::allow_attributes)]
-#![feature(lint_reasons)]
-#![crate_type = "proc-macro"]
-
-fn main() {}
diff --git a/tests/ui/allow_attributes_without_reason.rs b/tests/ui/allow_attributes_without_reason.rs
index 1a0d4e88657..95a9fa2aa47 100644
--- a/tests/ui/allow_attributes_without_reason.rs
+++ b/tests/ui/allow_attributes_without_reason.rs
@@ -1,9 +1,15 @@
+//@aux-build:proc_macros.rs
 #![feature(lint_reasons)]
 #![deny(clippy::allow_attributes_without_reason)]
+#![allow(unfulfilled_lint_expectations)]
+
+extern crate proc_macros;
+use proc_macros::{external, with_span};
 
 // These should trigger the lint
 #[allow(dead_code)]
 #[allow(dead_code, deprecated)]
+#[expect(dead_code)]
 // These should be fine
 #[allow(dead_code, reason = "This should be allowed")]
 #[warn(dyn_drop, reason = "Warnings can also have reasons")]
@@ -11,4 +17,14 @@
 #[deny(deref_nullptr)]
 #[forbid(deref_nullptr)]
 
-fn main() {}
+fn main() {
+    external! {
+        #[allow(dead_code)]
+        fn a() {}
+    }
+    with_span! {
+        span
+        #[allow(dead_code)]
+        fn b() {}
+    }
+}
diff --git a/tests/ui/allow_attributes_without_reason.stderr b/tests/ui/allow_attributes_without_reason.stderr
index 23f17e9a7af..96f747d0026 100644
--- a/tests/ui/allow_attributes_without_reason.stderr
+++ b/tests/ui/allow_attributes_without_reason.stderr
@@ -1,23 +1,39 @@
 error: `allow` attribute without specifying a reason
-  --> $DIR/allow_attributes_without_reason.rs:5:1
+  --> $DIR/allow_attributes_without_reason.rs:4:1
    |
-LL | #[allow(dead_code)]
-   | ^^^^^^^^^^^^^^^^^^^
+LL | #![allow(unfulfilled_lint_expectations)]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: try adding a reason at the end with `, reason = ".."`
 note: the lint level is defined here
-  --> $DIR/allow_attributes_without_reason.rs:2:9
+  --> $DIR/allow_attributes_without_reason.rs:3:9
    |
 LL | #![deny(clippy::allow_attributes_without_reason)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: `allow` attribute without specifying a reason
-  --> $DIR/allow_attributes_without_reason.rs:6:1
+  --> $DIR/allow_attributes_without_reason.rs:10:1
+   |
+LL | #[allow(dead_code)]
+   | ^^^^^^^^^^^^^^^^^^^
+   |
+   = help: try adding a reason at the end with `, reason = ".."`
+
+error: `allow` attribute without specifying a reason
+  --> $DIR/allow_attributes_without_reason.rs:11:1
    |
 LL | #[allow(dead_code, deprecated)]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: try adding a reason at the end with `, reason = ".."`
 
-error: aborting due to 2 previous errors
+error: `expect` attribute without specifying a reason
+  --> $DIR/allow_attributes_without_reason.rs:12:1
+   |
+LL | #[expect(dead_code)]
+   | ^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: try adding a reason at the end with `, reason = ".."`
+
+error: aborting due to 4 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 143ff2dfc307b34f2d277c02b3415f384ad3d950 Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Thu, 1 Jun 2023 22:29:06 -0500
Subject: Use type snippet instead of init expr for proc macro check

---
 clippy_lints/src/let_with_type_underscore.rs | 12 ++++++---
 tests/ui/let_with_type_underscore.rs         | 18 +++++++++++--
 tests/ui/let_with_type_underscore.stderr     | 38 +++++++++++++++++++++++-----
 3 files changed, 56 insertions(+), 12 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/let_with_type_underscore.rs b/clippy_lints/src/let_with_type_underscore.rs
index 8fcf42564d5..4f8c5ff58b5 100644
--- a/clippy_lints/src/let_with_type_underscore.rs
+++ b/clippy_lints/src/let_with_type_underscore.rs
@@ -1,4 +1,5 @@
-use clippy_utils::{diagnostics::span_lint_and_help, is_from_proc_macro};
+use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::source::snippet;
 use rustc_hir::{Local, TyKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::lint::in_external_macro;
@@ -32,7 +33,12 @@ impl LateLintPass<'_> for UnderscoreTyped {
             if let TyKind::Infer = &ty.kind; // that type is '_'
             if local.span.ctxt() == ty.span.ctxt();
             then {
-                if let Some(init) = local.init && is_from_proc_macro(cx, init) {
+                let underscore_span = ty.span.with_lo(local.pat.span.hi());
+                let snippet = snippet(cx, underscore_span, ": _");
+
+                // NOTE: Using `is_from_proc_macro` on `init` will require that it's initialized,
+                // this doesn't. Alternatively, `WithSearchPat` can be implemented for `Ty`
+                if !snippet.trim().starts_with(':') && !snippet.trim().ends_with('_') {
                     return;
                 }
 
@@ -41,7 +47,7 @@ impl LateLintPass<'_> for UnderscoreTyped {
                     LET_WITH_TYPE_UNDERSCORE,
                     local.span,
                     "variable declared with type underscore",
-                    Some(ty.span.with_lo(local.pat.span.hi())),
+                    Some(underscore_span),
                     "remove the explicit type `_` declaration"
                 )
             }
diff --git a/tests/ui/let_with_type_underscore.rs b/tests/ui/let_with_type_underscore.rs
index 832d0304ffa..ae1a480bcfc 100644
--- a/tests/ui/let_with_type_underscore.rs
+++ b/tests/ui/let_with_type_underscore.rs
@@ -1,7 +1,7 @@
 //@aux-build: proc_macros.rs
 #![allow(unused)]
 #![warn(clippy::let_with_type_underscore)]
-#![allow(clippy::let_unit_value)]
+#![allow(clippy::let_unit_value, clippy::needless_late_init)]
 
 extern crate proc_macros;
 
@@ -9,20 +9,34 @@ fn func() -> &'static str {
     ""
 }
 
+#[rustfmt::skip]
 fn main() {
     // Will lint
     let x: _ = 1;
     let _: _ = 2;
     let x: _ = func();
+    let x: _;
+    x = ();
 
     let x = 1; // Will not lint, Rust infers this to an integer before Clippy
     let x = func();
     let x: Vec<_> = Vec::<u32>::new();
     let x: [_; 1] = [1];
+    let x : _ = 1;
 
-    // do not lint from procedural macros
+    // Do not lint from procedural macros
     proc_macros::with_span! {
         span
         let x: _ = ();
+        // Late initialization
+        let x: _;
+        x = ();
+        // Ensure weird formatting will not break it (hopefully)
+        let x : _ = 1;
+        let x
+: _ = 1;
+        let                   x :              
+        _;
+        x = ();
     };
 }
diff --git a/tests/ui/let_with_type_underscore.stderr b/tests/ui/let_with_type_underscore.stderr
index 26400363f5d..a749552c7fa 100644
--- a/tests/ui/let_with_type_underscore.stderr
+++ b/tests/ui/let_with_type_underscore.stderr
@@ -1,39 +1,63 @@
 error: variable declared with type underscore
-  --> $DIR/let_with_type_underscore.rs:14:5
+  --> $DIR/let_with_type_underscore.rs:15:5
    |
 LL |     let x: _ = 1;
    |     ^^^^^^^^^^^^^
    |
 help: remove the explicit type `_` declaration
-  --> $DIR/let_with_type_underscore.rs:14:10
+  --> $DIR/let_with_type_underscore.rs:15:10
    |
 LL |     let x: _ = 1;
    |          ^^^
    = note: `-D clippy::let-with-type-underscore` implied by `-D warnings`
 
 error: variable declared with type underscore
-  --> $DIR/let_with_type_underscore.rs:15:5
+  --> $DIR/let_with_type_underscore.rs:16:5
    |
 LL |     let _: _ = 2;
    |     ^^^^^^^^^^^^^
    |
 help: remove the explicit type `_` declaration
-  --> $DIR/let_with_type_underscore.rs:15:10
+  --> $DIR/let_with_type_underscore.rs:16:10
    |
 LL |     let _: _ = 2;
    |          ^^^
 
 error: variable declared with type underscore
-  --> $DIR/let_with_type_underscore.rs:16:5
+  --> $DIR/let_with_type_underscore.rs:17:5
    |
 LL |     let x: _ = func();
    |     ^^^^^^^^^^^^^^^^^^
    |
 help: remove the explicit type `_` declaration
-  --> $DIR/let_with_type_underscore.rs:16:10
+  --> $DIR/let_with_type_underscore.rs:17:10
    |
 LL |     let x: _ = func();
    |          ^^^
 
-error: aborting due to 3 previous errors
+error: variable declared with type underscore
+  --> $DIR/let_with_type_underscore.rs:18:5
+   |
+LL |     let x: _;
+   |     ^^^^^^^^^
+   |
+help: remove the explicit type `_` declaration
+  --> $DIR/let_with_type_underscore.rs:18:10
+   |
+LL |     let x: _;
+   |          ^^^
+
+error: variable declared with type underscore
+  --> $DIR/let_with_type_underscore.rs:25:5
+   |
+LL |     let x : _ = 1;
+   |     ^^^^^^^^^^^^^^
+   |
+help: remove the explicit type `_` declaration
+  --> $DIR/let_with_type_underscore.rs:25:10
+   |
+LL |     let x : _ = 1;
+   |          ^^^^
+
+error: aborting due to 5 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From ad76687b2f2cf041190ca44f7a53d89f84ac552b Mon Sep 17 00:00:00 2001
From: ihciah <ihciah@gmail.com>
Date: Thu, 1 Jun 2023 14:11:28 +0000
Subject: add checking for cfg(features = ...)

---
 CHANGELOG.md                       |  1 +
 clippy_lints/src/attrs.rs          | 57 ++++++++++++++++++++++++++++++++++++++
 clippy_lints/src/declared_lints.rs |  1 +
 tests/ui/cfg_features.rs           | 12 ++++++++
 tests/ui/cfg_features.stderr       | 28 +++++++++++++++++++
 5 files changed, 99 insertions(+)
 create mode 100644 tests/ui/cfg_features.rs
 create mode 100644 tests/ui/cfg_features.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 8b609b47d81..fd619368e8f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4947,6 +4947,7 @@ Released 2018-09-13
 [`match_wild_err_arm`]: https://rust-lang.github.io/rust-clippy/master/index.html#match_wild_err_arm
 [`match_wildcard_for_single_variants`]: https://rust-lang.github.io/rust-clippy/master/index.html#match_wildcard_for_single_variants
 [`maybe_infinite_iter`]: https://rust-lang.github.io/rust-clippy/master/index.html#maybe_infinite_iter
+[`maybe_misused_cfg`]: https://rust-lang.github.io/rust-clippy/master/index.html#maybe_misused_cfg
 [`mem_discriminant_non_enum`]: https://rust-lang.github.io/rust-clippy/master/index.html#mem_discriminant_non_enum
 [`mem_forget`]: https://rust-lang.github.io/rust-clippy/master/index.html#mem_forget
 [`mem_replace_option_with_none`]: https://rust-lang.github.io/rust-clippy/master/index.html#mem_replace_option_with_none
diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs
index 897495ba108..891ee8af82b 100644
--- a/clippy_lints/src/attrs.rs
+++ b/clippy_lints/src/attrs.rs
@@ -362,6 +362,32 @@ declare_clippy_lint! {
     "ensure that all `cfg(any())` and `cfg(all())` have more than one condition"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `#[cfg(features = "...")]` and suggests to replace it with
+    /// `#[cfg(feature = "...")]`.
+    ///
+    /// ### Why is this bad?
+    /// Misspelling `feature` as `features` can be sometimes hard to spot. It
+    /// may cause conditional compilation not work quitely.
+    ///
+    /// ### Example
+    /// ```rust
+    /// #[cfg(features = "some-feature")]
+    /// fn conditional() { }
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust
+    /// #[cfg(feature = "some-feature")]
+    /// fn conditional() { }
+    /// ```
+    #[clippy::version = "1.69.0"]
+    pub MAYBE_MISUSED_CFG,
+    suspicious,
+    "prevent from misusing the wrong attr name"
+}
+
 declare_lint_pass!(Attributes => [
     ALLOW_ATTRIBUTES_WITHOUT_REASON,
     INLINE_ALWAYS,
@@ -676,6 +702,7 @@ impl_lint_pass!(EarlyAttributes => [
     EMPTY_LINE_AFTER_OUTER_ATTR,
     EMPTY_LINE_AFTER_DOC_COMMENTS,
     NON_MINIMAL_CFG,
+    MAYBE_MISUSED_CFG,
 ]);
 
 impl EarlyLintPass for EarlyAttributes {
@@ -687,6 +714,7 @@ impl EarlyLintPass for EarlyAttributes {
         check_deprecated_cfg_attr(cx, attr, &self.msrv);
         check_mismatched_target_os(cx, attr);
         check_minimal_cfg_condition(cx, attr);
+        check_misused_cfg(cx, attr);
     }
 
     extract_msrv_attr!(EarlyContext);
@@ -810,6 +838,27 @@ fn check_nested_cfg(cx: &EarlyContext<'_>, items: &[NestedMetaItem]) {
     }
 }
 
+fn check_nested_misused_cfg(cx: &EarlyContext<'_>, items: &[NestedMetaItem]) {
+    for item in items.iter() {
+        if let NestedMetaItem::MetaItem(meta) = item {
+            if meta.has_name(sym!(features)) && let Some(val) = meta.value_str() {
+                span_lint_and_sugg(
+                    cx,
+                    MAYBE_MISUSED_CFG,
+                    meta.span,
+                    "feature may misspelled as features",
+                    "use",
+                    format!("feature = \"{val}\""),
+                    Applicability::MaybeIncorrect,
+                );
+            }
+            if let MetaItemKind::List(list) = &meta.kind {
+                check_nested_misused_cfg(cx, list);
+            }
+        }
+    }
+}
+
 fn check_minimal_cfg_condition(cx: &EarlyContext<'_>, attr: &Attribute) {
     if attr.has_name(sym::cfg) &&
         let Some(items) = attr.meta_item_list()
@@ -818,6 +867,14 @@ fn check_minimal_cfg_condition(cx: &EarlyContext<'_>, attr: &Attribute) {
     }
 }
 
+fn check_misused_cfg(cx: &EarlyContext<'_>, attr: &Attribute) {
+    if attr.has_name(sym::cfg) &&
+        let Some(items) = attr.meta_item_list()
+    {
+        check_nested_misused_cfg(cx, &items);
+    }
+}
+
 fn check_mismatched_target_os(cx: &EarlyContext<'_>, attr: &Attribute) {
     fn find_os(name: &str) -> Option<&'static str> {
         UNIX_SYSTEMS
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index a7067d8b86a..d867ab39294 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -51,6 +51,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::attrs::EMPTY_LINE_AFTER_DOC_COMMENTS_INFO,
     crate::attrs::EMPTY_LINE_AFTER_OUTER_ATTR_INFO,
     crate::attrs::INLINE_ALWAYS_INFO,
+    crate::attrs::MAYBE_MISUSED_CFG_INFO,
     crate::attrs::MISMATCHED_TARGET_OS_INFO,
     crate::attrs::NON_MINIMAL_CFG_INFO,
     crate::attrs::USELESS_ATTRIBUTE_INFO,
diff --git a/tests/ui/cfg_features.rs b/tests/ui/cfg_features.rs
new file mode 100644
index 00000000000..bc4109c2c89
--- /dev/null
+++ b/tests/ui/cfg_features.rs
@@ -0,0 +1,12 @@
+#![warn(clippy::maybe_misused_cfg)]
+
+fn main() {
+    #[cfg(features = "not-really-a-feature")]
+    let _ = 1 + 2;
+
+    #[cfg(all(feature = "right", features = "wrong"))]
+    let _ = 1 + 2;
+
+    #[cfg(all(features = "wrong1", any(feature = "right", features = "wrong2", feature, features)))]
+    let _ = 1 + 2;
+}
diff --git a/tests/ui/cfg_features.stderr b/tests/ui/cfg_features.stderr
new file mode 100644
index 00000000000..00405985d48
--- /dev/null
+++ b/tests/ui/cfg_features.stderr
@@ -0,0 +1,28 @@
+error: feature may misspelled as features
+  --> $DIR/cfg_features.rs:4:11
+   |
+LL |     #[cfg(features = "not-really-a-feature")]
+   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `feature = "not-really-a-feature"`
+   |
+   = note: `-D clippy::maybe-misused-cfg` implied by `-D warnings`
+
+error: feature may misspelled as features
+  --> $DIR/cfg_features.rs:7:34
+   |
+LL |     #[cfg(all(feature = "right", features = "wrong"))]
+   |                                  ^^^^^^^^^^^^^^^^^^ help: use: `feature = "wrong"`
+
+error: feature may misspelled as features
+  --> $DIR/cfg_features.rs:10:15
+   |
+LL |     #[cfg(all(features = "wrong1", any(feature = "right", features = "wrong2", feature, features)))]
+   |               ^^^^^^^^^^^^^^^^^^^ help: use: `feature = "wrong1"`
+
+error: feature may misspelled as features
+  --> $DIR/cfg_features.rs:10:59
+   |
+LL |     #[cfg(all(features = "wrong1", any(feature = "right", features = "wrong2", feature, features)))]
+   |                                                           ^^^^^^^^^^^^^^^^^^^ help: use: `feature = "wrong2"`
+
+error: aborting due to 4 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 86d57b7bd494f386ce88229622e4522091285f65 Mon Sep 17 00:00:00 2001
From: est31 <MTest31@outlook.com>
Date: Fri, 2 Jun 2023 01:00:03 +0200
Subject: Support multi-binding situations as well as tuple patterns

---
 clippy_lints/src/manual_let_else.rs | 217 ++++++++++++++++++++++++------------
 tests/ui/manual_let_else.rs         |  20 +++-
 tests/ui/manual_let_else.stderr     |  14 ++-
 3 files changed, 174 insertions(+), 77 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_let_else.rs b/clippy_lints/src/manual_let_else.rs
index d5e847e7183..77d673fec24 100644
--- a/clippy_lints/src/manual_let_else.rs
+++ b/clippy_lints/src/manual_let_else.rs
@@ -6,17 +6,18 @@ use clippy_utils::source::snippet_with_context;
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::visitors::{Descend, Visitable};
 use if_chain::if_chain;
-use rustc_data_structures::fx::FxHashSet;
+use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_expr, Visitor};
 use rustc_hir::{Expr, ExprKind, HirId, ItemId, Local, MatchSource, Pat, PatKind, QPath, Stmt, StmtKind, Ty};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::symbol::sym;
+use rustc_span::symbol::{sym, Symbol};
 use rustc_span::Span;
 use serde::Deserialize;
 use std::ops::ControlFlow;
+use std::slice;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -81,11 +82,11 @@ impl<'tcx> LateLintPass<'tcx> for ManualLetElse {
         {
             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(ident_map) = expr_simple_identity_map(local.pat, 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, local.pat, let_pat, if_else);
+                        emit_manual_let_else(cx, stmt.span, if_let_expr, &ident_map, let_pat, if_else);
                     }
                 },
                 IfLetOrMatch::Match(match_expr, arms, source) => {
@@ -118,11 +119,11 @@ impl<'tcx> LateLintPass<'tcx> for ManualLetElse {
                         return;
                     }
                     let pat_arm = &arms[1 - idx];
-                    if !expr_is_simple_identity(pat_arm.pat, pat_arm.body) {
-                        return;
-                    }
+                    let Some(ident_map) = expr_simple_identity_map(local.pat, pat_arm.pat, pat_arm.body) else {
+                        return
+                    };
 
-                    emit_manual_let_else(cx, stmt.span, match_expr, local.pat, pat_arm.pat, diverging_arm.body);
+                    emit_manual_let_else(cx, stmt.span, match_expr, &ident_map, pat_arm.pat, diverging_arm.body);
                 },
             }
         };
@@ -135,7 +136,7 @@ fn emit_manual_let_else(
     cx: &LateContext<'_>,
     span: Span,
     expr: &Expr<'_>,
-    local: &Pat<'_>,
+    ident_map: &FxHashMap<Symbol, &Pat<'_>>,
     pat: &Pat<'_>,
     else_body: &Expr<'_>,
 ) {
@@ -159,62 +160,99 @@ fn emit_manual_let_else(
             } else {
                 format!("{{ {sn_else} }}")
             };
-            let sn_bl = replace_in_pattern(cx, span, local, pat, &mut app, true);
+            let sn_bl = replace_in_pattern(cx, span, ident_map, pat, &mut app, true);
             let sugg = format!("let {sn_bl} = {sn_expr} else {else_bl};");
             diag.span_suggestion(span, "consider writing", sugg, app);
         },
     );
 }
 
-// replaces the locals in the pattern
+/// Replaces the locals in the pattern
+///
+/// For this example:
+///
+/// ```ignore
+/// let (a, FooBar { b, c }) = if let Bar { Some(a_i), b_i } = ex { (a_i, b_i) } else { return };
+/// ```
+///
+/// We have:
+///
+/// ```ignore
+/// pat: Bar { Some(a_i), b_i }
+/// ident_map: (a_i) -> (a), (b_i) -> (FooBar { b, c })
+/// ```
+///
+/// We return:
+///
+/// ```ignore
+/// Bar { Some(a), b_i: FooBar { b, c } }
+/// ```
 fn replace_in_pattern(
     cx: &LateContext<'_>,
     span: Span,
-    local: &Pat<'_>,
+    ident_map: &FxHashMap<Symbol, &Pat<'_>>,
     pat: &Pat<'_>,
     app: &mut Applicability,
     top_level: bool,
 ) -> String {
-    let mut bindings_count = 0;
-    pat.each_binding_or_first(&mut |_, _, _, _| bindings_count += 1);
-    // If the pattern creates multiple bindings, exit early,
-    // as otherwise we might paste the pattern to the positions of multiple bindings.
-    if bindings_count > 1 {
-        let (sn_pat, _) = snippet_with_context(cx, pat.span, span.ctxt(), "", app);
-        return sn_pat.into_owned();
-    }
+    // We put a labeled block here so that we can implement the fallback in this function.
+    // As the function has multiple call sites, implementing the fallback via an Option<T>
+    // return type and unwrap_or_else would cause repetition. Similarly, the function also
+    // invokes the fall back multiple times.
+    'a: {
+        // If the ident map is empty, there is no replacement to do.
+        // The code following this if assumes a non-empty ident_map.
+        if ident_map.is_empty() {
+            break 'a;
+        }
 
-    match pat.kind {
-        PatKind::Binding(..) => {
-            let (sn_bdg, _) = snippet_with_context(cx, local.span, span.ctxt(), "", app);
-            return sn_bdg.to_string();
-        },
-        PatKind::Or(pats) => {
-            let patterns = pats
-                .iter()
-                .map(|pat| replace_in_pattern(cx, span, local, pat, app, false))
-                .collect::<Vec<_>>();
-            let or_pat = patterns.join(" | ");
-            if top_level {
-                return format!("({or_pat})");
-            } else {
+        match pat.kind {
+            PatKind::Binding(_ann, _id, binding_name, opt_subpt) => {
+                let Some(pat_to_put) = ident_map.get(&binding_name.name) else { break 'a };
+                let (sn_ptp, _) = snippet_with_context(cx, pat_to_put.span, span.ctxt(), "", app);
+                if let Some(subpt) = opt_subpt {
+                    let subpt = replace_in_pattern(cx, span, ident_map, subpt, app, false);
+                    return format!("{sn_ptp} @ {subpt}");
+                }
+                return sn_ptp.to_string();
+            },
+            PatKind::Or(pats) => {
+                let patterns = pats
+                    .iter()
+                    .map(|pat| replace_in_pattern(cx, span, ident_map, pat, app, false))
+                    .collect::<Vec<_>>();
+                let or_pat = patterns.join(" | ");
+                if top_level {
+                    return format!("({or_pat})");
+                }
                 return or_pat;
-            }
-        },
-        // Replace the variable name iff `TupleStruct` has one argument like `Variant(v)`.
-        PatKind::TupleStruct(ref w, args, dot_dot_pos) => {
-            let mut args = args
-                .iter()
-                .map(|pat| replace_in_pattern(cx, span, local, pat, app, false))
-                .collect::<Vec<_>>();
-            if let Some(pos) = dot_dot_pos.as_opt_usize() {
-                args.insert(pos, "..".to_owned());
-            }
-            let args = args.join(", ");
-            let sn_wrapper = cx.sess().source_map().span_to_snippet(w.span()).unwrap_or_default();
-            return format!("{sn_wrapper}({args})");
-        },
-        _ => {},
+            },
+            // Replace the variable name iff `TupleStruct` has one argument like `Variant(v)`.
+            PatKind::TupleStruct(ref w, args, dot_dot_pos) => {
+                let mut args = args
+                    .iter()
+                    .map(|pat| replace_in_pattern(cx, span, ident_map, pat, app, false))
+                    .collect::<Vec<_>>();
+                if let Some(pos) = dot_dot_pos.as_opt_usize() {
+                    args.insert(pos, "..".to_owned());
+                }
+                let args = args.join(", ");
+                let sn_wrapper = cx.sess().source_map().span_to_snippet(w.span()).unwrap_or_default();
+                return format!("{sn_wrapper}({args})");
+            },
+            PatKind::Tuple(args, dot_dot_pos) => {
+                let mut args = args
+                    .iter()
+                    .map(|pat| replace_in_pattern(cx, span, ident_map, pat, app, false))
+                    .collect::<Vec<_>>();
+                if let Some(pos) = dot_dot_pos.as_opt_usize() {
+                    args.insert(pos, "..".to_owned());
+                }
+                let args = args.join(", ");
+                return format!("({args})");
+            },
+            _ => {},
+        }
     }
     let (sn_pat, _) = snippet_with_context(cx, pat.span, span.ctxt(), "", app);
     sn_pat.into_owned()
@@ -358,37 +396,74 @@ fn pat_allowed_for_else(cx: &LateContext<'_>, pat: &'_ Pat<'_>, check_types: boo
     !has_disallowed
 }
 
-/// Checks if the passed block is a simple identity referring to bindings created by the pattern
-fn expr_is_simple_identity(pat: &'_ Pat<'_>, expr: &'_ Expr<'_>) -> bool {
-    // We support patterns with multiple bindings and tuples, like:
-    //   let ... = if let (Some(foo), bar) = g() { (foo, bar) } else { ... }
+/// Checks if the passed block is a simple identity referring to bindings created by the pattern,
+/// and if yes, returns a mapping between the relevant sub-pattern and the identifier it corresponds
+/// to.
+///
+/// We support patterns with multiple bindings and tuples, e.g.:
+///
+/// ```ignore
+/// let (foo_o, bar_o) = if let (Some(foo), bar) = g() { (foo, bar) } else { ... }
+/// ```
+///
+/// The expected params would be:
+///
+/// ```ignore
+/// local_pat: (foo_o, bar_o)
+/// let_pat: (Some(foo), bar)
+/// expr: (foo, bar)
+/// ```
+///
+/// We build internal `sub_pats` so that it looks like `[foo_o, bar_o]` and `paths` so that it looks
+/// like `[foo, bar]`. Then we turn that into `FxHashMap [(foo) -> (foo_o), (bar) -> (bar_o)]` which
+/// we return.
+fn expr_simple_identity_map<'a, 'hir>(
+    local_pat: &'a Pat<'hir>,
+    let_pat: &'_ Pat<'hir>,
+    expr: &'_ Expr<'hir>,
+) -> Option<FxHashMap<Symbol, &'a Pat<'hir>>> {
     let peeled = peel_blocks(expr);
-    let paths = match peeled.kind {
-        ExprKind::Tup(exprs) | ExprKind::Array(exprs) => exprs,
-        ExprKind::Path(_) => std::slice::from_ref(peeled),
-        _ => return false,
+    let (sub_pats, paths) = match (local_pat.kind, peeled.kind) {
+        (PatKind::Tuple(pats, _), ExprKind::Tup(exprs)) | (PatKind::Slice(pats, ..), ExprKind::Array(exprs)) => {
+            (pats, exprs)
+        },
+        (_, ExprKind::Path(_)) => (slice::from_ref(local_pat), slice::from_ref(peeled)),
+        _ => return None,
     };
+
+    // There is some length mismatch, which indicates usage of .. in the patterns above e.g.:
+    // let (a, ..) = if let [a, b, _c] = ex { (a, b) } else { ... };
+    // We bail in these cases as they should be rare.
+    if paths.len() != sub_pats.len() {
+        return None;
+    }
+
     let mut pat_bindings = FxHashSet::default();
-    pat.each_binding_or_first(&mut |_ann, _hir_id, _sp, ident| {
+    let_pat.each_binding_or_first(&mut |_ann, _hir_id, _sp, ident| {
         pat_bindings.insert(ident);
     });
     if pat_bindings.len() < paths.len() {
-        return false;
+        // This rebinds some bindings from the outer scope, or it repeats some copy-able bindings multiple
+        // times. We don't support these cases so we bail here. E.g.:
+        // let foo = 0;
+        // let (new_foo, bar, bar_copied) = if let Some(bar) = Some(0) { (foo, bar, bar) } else { .. };
+        return None;
     }
-    for path in paths {
-        if_chain! {
-            if let ExprKind::Path(QPath::Resolved(_ty, path)) = path.kind;
-            if let [path_seg] = path.segments;
-            then {
-                if !pat_bindings.remove(&path_seg.ident) {
-                    return false;
-                }
-            } else {
-                return false;
+    let mut ident_map = FxHashMap::default();
+    for (sub_pat, path) in sub_pats.iter().zip(paths.iter()) {
+        if let ExprKind::Path(QPath::Resolved(_ty, path)) = path.kind &&
+            let [path_seg] = path.segments
+        {
+            let ident = path_seg.ident;
+            if !pat_bindings.remove(&ident) {
+                return None;
             }
+            ident_map.insert(ident.name, sub_pat);
+        } else {
+            return None;
         }
     }
-    true
+    Some(ident_map)
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Deserialize)]
diff --git a/tests/ui/manual_let_else.rs b/tests/ui/manual_let_else.rs
index 351ea0e4f50..61c3a165009 100644
--- a/tests/ui/manual_let_else.rs
+++ b/tests/ui/manual_let_else.rs
@@ -127,8 +127,8 @@ fn fire() {
         return;
     };
 
-    // Tuples supported for the identity block and pattern
-    let v = if let (Some(v_some), w_some) = (g(), 0) {
+    // Tuples supported with multiple bindings
+    let (w, S { v }) = if let (Some(v_some), w_some) = (g().map(|_| S { v: 0 }), 0) {
         (w_some, v_some)
     } else {
         return;
@@ -160,6 +160,9 @@ fn fire() {
     };
     // dot dot works
     let v = if let Variant::A(.., a) = e() { a } else { return };
+
+    // () is preserved: a bit of an edge case but make sure it stays around
+    let w = if let (Some(v), ()) = (g(), ()) { v } else { return };
 }
 
 fn not_fire() {
@@ -284,4 +287,17 @@ fn not_fire() {
         };
         1
     };
+
+    // This would require creation of a suggestion of the form
+    // let v @ (Some(_), _) = (...) else { return };
+    // Which is too advanced for our code, so we just bail.
+    let v = if let (Some(v_some), w_some) = (g(), 0) {
+        (w_some, v_some)
+    } else {
+        return;
+    };
+}
+
+struct S {
+    v: u32,
 }
diff --git a/tests/ui/manual_let_else.stderr b/tests/ui/manual_let_else.stderr
index 0e876797134..4e83e638cdf 100644
--- a/tests/ui/manual_let_else.stderr
+++ b/tests/ui/manual_let_else.stderr
@@ -234,7 +234,7 @@ LL +     };
 error: this could be rewritten as `let...else`
   --> $DIR/manual_let_else.rs:131:5
    |
-LL | /     let v = if let (Some(v_some), w_some) = (g(), 0) {
+LL | /     let (w, S { v }) = if let (Some(v_some), w_some) = (g().map(|_| S { v: 0 }), 0) {
 LL | |         (w_some, v_some)
 LL | |     } else {
 LL | |         return;
@@ -243,7 +243,7 @@ LL | |     };
    |
 help: consider writing
    |
-LL ~     let (Some(v_some), w_some) = (g(), 0) else {
+LL ~     let (Some(S { v }), w) = (g().map(|_| S { v: 0 }), 0) else {
 LL +         return;
 LL +     };
    |
@@ -295,7 +295,13 @@ LL |     let v = if let Variant::A(.., a) = e() { a } else { return };
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let Variant::A(.., v) = e() else { return };`
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:272:5
+  --> $DIR/manual_let_else.rs:165:5
+   |
+LL |     let w = if let (Some(v), ()) = (g(), ()) { v } else { return };
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let (Some(w), ()) = (g(), ()) else { return };`
+
+error: this could be rewritten as `let...else`
+  --> $DIR/manual_let_else.rs:275:5
    |
 LL | /     let _ = match ff {
 LL | |         Some(value) => value,
@@ -303,5 +309,5 @@ LL | |         _ => macro_call!(),
 LL | |     };
    | |______^ help: consider writing: `let Some(_) = ff else { macro_call!() };`
 
-error: aborting due to 22 previous errors
+error: aborting due to 23 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From f5384027012024ab7f28e602b1218ab88463cd79 Mon Sep 17 00:00:00 2001
From: est31 <MTest31@outlook.com>
Date: Fri, 2 Jun 2023 01:25:22 +0200
Subject: Support struct patterns

---
 clippy_lints/src/manual_let_else.rs | 31 +++++++++++++++++++--
 tests/ui/manual_let_else.rs         | 31 +++++++++++++++++++--
 tests/ui/manual_let_else.stderr     | 55 +++++++++++++++++++++++++++++++++++--
 3 files changed, 111 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_let_else.rs b/clippy_lints/src/manual_let_else.rs
index 77d673fec24..59e421c1622 100644
--- a/clippy_lints/src/manual_let_else.rs
+++ b/clippy_lints/src/manual_let_else.rs
@@ -147,8 +147,8 @@ fn emit_manual_let_else(
         "this could be rewritten as `let...else`",
         |diag| {
             // This is far from perfect, for example there needs to be:
-            // * tracking for multi-binding cases: let (foo, bar) = if let (Some(foo), Ok(bar)) = ...
-            // * renamings of the bindings for many `PatKind`s like structs, slices, etc.
+            // * renamings of the bindings for many `PatKind`s like slices, etc.
+            // * limitations in the existing replacement algorithms
             // * unused binding collision detection with existing ones
             // for this to be machine applicable.
             let mut app = Applicability::HasPlaceholders;
@@ -227,6 +227,33 @@ fn replace_in_pattern(
                 }
                 return or_pat;
             },
+            PatKind::Struct(path, fields, has_dot_dot) => {
+                let fields = fields
+                    .iter()
+                    .map(|fld| {
+                        if let PatKind::Binding(_, _, name, None) = fld.pat.kind &&
+                            let Some(pat_to_put) = ident_map.get(&name.name)
+                        {
+                            let (sn_fld_name, _) = snippet_with_context(cx, fld.ident.span, span.ctxt(), "", app);
+                            let (sn_ptp, _) = snippet_with_context(cx, pat_to_put.span, span.ctxt(), "", app);
+                            // TODO: this is a bit of a hack, but it does its job. Ideally, we'd check if pat_to_put is
+                            // a PatKind::Binding but that is also hard to get right.
+                            if sn_fld_name == sn_ptp {
+                                // Field init shorthand
+                                return format!("{sn_fld_name}");
+                            }
+                            return format!("{sn_fld_name}: {sn_ptp}");
+                        }
+                        let (sn_fld, _) = snippet_with_context(cx, fld.span, span.ctxt(), "", app);
+                        sn_fld.into_owned()
+                    })
+                    .collect::<Vec<_>>();
+                let fields_string = fields.join(", ");
+
+                let dot_dot_str = if has_dot_dot { " .." } else { "" };
+                let (sn_pth, _) = snippet_with_context(cx, path.span(), span.ctxt(), "", app);
+                return format!("{sn_pth} {{ {fields_string}{dot_dot_str} }}");
+            },
             // Replace the variable name iff `TupleStruct` has one argument like `Variant(v)`.
             PatKind::TupleStruct(ref w, args, dot_dot_pos) => {
                 let mut args = args
diff --git a/tests/ui/manual_let_else.rs b/tests/ui/manual_let_else.rs
index 61c3a165009..b5c2a5dba34 100644
--- a/tests/ui/manual_let_else.rs
+++ b/tests/ui/manual_let_else.rs
@@ -163,6 +163,27 @@ fn fire() {
 
     // () is preserved: a bit of an edge case but make sure it stays around
     let w = if let (Some(v), ()) = (g(), ()) { v } else { return };
+
+    // Tuple structs work
+    let w = if let Some(S { v: x }) = Some(S { v: 0 }) {
+        x
+    } else {
+        return;
+    };
+
+    // Field init shorthand is suggested
+    let v = if let Some(S { v: x }) = Some(S { v: 0 }) {
+        x
+    } else {
+        return;
+    };
+
+    // Multi-field structs also work
+    let (x, S { v }, w) = if let Some(U { v, w, x }) = None::<U<S<()>>> {
+        (x, v, w)
+    } else {
+        return;
+    };
 }
 
 fn not_fire() {
@@ -298,6 +319,12 @@ fn not_fire() {
     };
 }
 
-struct S {
-    v: u32,
+struct S<T> {
+    v: T,
+}
+
+struct U<T> {
+    v: T,
+    w: T,
+    x: T,
 }
diff --git a/tests/ui/manual_let_else.stderr b/tests/ui/manual_let_else.stderr
index 4e83e638cdf..9d4aef4cad6 100644
--- a/tests/ui/manual_let_else.stderr
+++ b/tests/ui/manual_let_else.stderr
@@ -301,7 +301,58 @@ LL |     let w = if let (Some(v), ()) = (g(), ()) { v } else { return };
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let (Some(w), ()) = (g(), ()) else { return };`
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:275:5
+  --> $DIR/manual_let_else.rs:168:5
+   |
+LL | /     let w = if let Some(S { v: x }) = Some(S { v: 0 }) {
+LL | |         x
+LL | |     } else {
+LL | |         return;
+LL | |     };
+   | |______^
+   |
+help: consider writing
+   |
+LL ~     let Some(S { v: w }) = Some(S { v: 0 }) else {
+LL +         return;
+LL +     };
+   |
+
+error: this could be rewritten as `let...else`
+  --> $DIR/manual_let_else.rs:175:5
+   |
+LL | /     let v = if let Some(S { v: x }) = Some(S { v: 0 }) {
+LL | |         x
+LL | |     } else {
+LL | |         return;
+LL | |     };
+   | |______^
+   |
+help: consider writing
+   |
+LL ~     let Some(S { v }) = Some(S { v: 0 }) else {
+LL +         return;
+LL +     };
+   |
+
+error: this could be rewritten as `let...else`
+  --> $DIR/manual_let_else.rs:182:5
+   |
+LL | /     let (x, S { v }, w) = if let Some(U { v, w, x }) = None::<U<S<()>>> {
+LL | |         (x, v, w)
+LL | |     } else {
+LL | |         return;
+LL | |     };
+   | |______^
+   |
+help: consider writing
+   |
+LL ~     let Some(U { v: S { v }, w, x }) = None::<U<S<()>>> else {
+LL +         return;
+LL +     };
+   |
+
+error: this could be rewritten as `let...else`
+  --> $DIR/manual_let_else.rs:296:5
    |
 LL | /     let _ = match ff {
 LL | |         Some(value) => value,
@@ -309,5 +360,5 @@ LL | |         _ => macro_call!(),
 LL | |     };
    | |______^ help: consider writing: `let Some(_) = ff else { macro_call!() };`
 
-error: aborting due to 23 previous errors
+error: aborting due to 26 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From e29a68113f747a4183c3d8153cb7aa1cd2255d8d Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Fri, 2 Jun 2023 15:13:55 +0000
Subject: Move redundant_clone to nursery

---
 clippy_lints/src/redundant_clone.rs |  2 +-
 tests/ui/redundant_clone.fixed      |  1 +
 tests/ui/redundant_clone.rs         |  1 +
 tests/ui/redundant_clone.stderr     | 60 ++++++++++++++++++-------------------
 tests/ui/unnecessary_to_owned.fixed |  2 +-
 tests/ui/unnecessary_to_owned.rs    |  2 +-
 6 files changed, 35 insertions(+), 33 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/redundant_clone.rs b/clippy_lints/src/redundant_clone.rs
index 944a33cc3e5..685d738cbb7 100644
--- a/clippy_lints/src/redundant_clone.rs
+++ b/clippy_lints/src/redundant_clone.rs
@@ -57,7 +57,7 @@ declare_clippy_lint! {
     /// ```
     #[clippy::version = "1.32.0"]
     pub REDUNDANT_CLONE,
-    perf,
+    nursery,
     "`clone()` of an owned value that is going to be dropped immediately"
 }
 
diff --git a/tests/ui/redundant_clone.fixed b/tests/ui/redundant_clone.fixed
index 8bebb5183bc..cb9583aa6ee 100644
--- a/tests/ui/redundant_clone.fixed
+++ b/tests/ui/redundant_clone.fixed
@@ -1,6 +1,7 @@
 //@run-rustfix
 // rustfix-only-machine-applicable
 #![feature(lint_reasons)]
+#![warn(clippy::redundant_clone)]
 #![allow(clippy::drop_non_drop, clippy::implicit_clone, clippy::uninlined_format_args)]
 
 use std::ffi::OsString;
diff --git a/tests/ui/redundant_clone.rs b/tests/ui/redundant_clone.rs
index b4bd5d16b1a..e5aeacbb56c 100644
--- a/tests/ui/redundant_clone.rs
+++ b/tests/ui/redundant_clone.rs
@@ -1,6 +1,7 @@
 //@run-rustfix
 // rustfix-only-machine-applicable
 #![feature(lint_reasons)]
+#![warn(clippy::redundant_clone)]
 #![allow(clippy::drop_non_drop, clippy::implicit_clone, clippy::uninlined_format_args)]
 
 use std::ffi::OsString;
diff --git a/tests/ui/redundant_clone.stderr b/tests/ui/redundant_clone.stderr
index 782590034d0..bb5c602d63a 100644
--- a/tests/ui/redundant_clone.stderr
+++ b/tests/ui/redundant_clone.stderr
@@ -1,180 +1,180 @@
 error: redundant clone
-  --> $DIR/redundant_clone.rs:10:42
+  --> $DIR/redundant_clone.rs:11:42
    |
 LL |     let _s = ["lorem", "ipsum"].join(" ").to_string();
    |                                          ^^^^^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> $DIR/redundant_clone.rs:10:14
+  --> $DIR/redundant_clone.rs:11:14
    |
 LL |     let _s = ["lorem", "ipsum"].join(" ").to_string();
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    = note: `-D clippy::redundant-clone` implied by `-D warnings`
 
 error: redundant clone
-  --> $DIR/redundant_clone.rs:13:15
+  --> $DIR/redundant_clone.rs:14:15
    |
 LL |     let _s = s.clone();
    |               ^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> $DIR/redundant_clone.rs:13:14
+  --> $DIR/redundant_clone.rs:14:14
    |
 LL |     let _s = s.clone();
    |              ^
 
 error: redundant clone
-  --> $DIR/redundant_clone.rs:16:15
+  --> $DIR/redundant_clone.rs:17:15
    |
 LL |     let _s = s.to_string();
    |               ^^^^^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> $DIR/redundant_clone.rs:16:14
+  --> $DIR/redundant_clone.rs:17:14
    |
 LL |     let _s = s.to_string();
    |              ^
 
 error: redundant clone
-  --> $DIR/redundant_clone.rs:19:15
+  --> $DIR/redundant_clone.rs:20:15
    |
 LL |     let _s = s.to_owned();
    |               ^^^^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> $DIR/redundant_clone.rs:19:14
+  --> $DIR/redundant_clone.rs:20:14
    |
 LL |     let _s = s.to_owned();
    |              ^
 
 error: redundant clone
-  --> $DIR/redundant_clone.rs:21:42
+  --> $DIR/redundant_clone.rs:22:42
    |
 LL |     let _s = Path::new("/a/b/").join("c").to_owned();
    |                                          ^^^^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> $DIR/redundant_clone.rs:21:14
+  --> $DIR/redundant_clone.rs:22:14
    |
 LL |     let _s = Path::new("/a/b/").join("c").to_owned();
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: redundant clone
-  --> $DIR/redundant_clone.rs:23:42
+  --> $DIR/redundant_clone.rs:24:42
    |
 LL |     let _s = Path::new("/a/b/").join("c").to_path_buf();
    |                                          ^^^^^^^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> $DIR/redundant_clone.rs:23:14
+  --> $DIR/redundant_clone.rs:24:14
    |
 LL |     let _s = Path::new("/a/b/").join("c").to_path_buf();
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: redundant clone
-  --> $DIR/redundant_clone.rs:25:29
+  --> $DIR/redundant_clone.rs:26:29
    |
 LL |     let _s = OsString::new().to_owned();
    |                             ^^^^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> $DIR/redundant_clone.rs:25:14
+  --> $DIR/redundant_clone.rs:26:14
    |
 LL |     let _s = OsString::new().to_owned();
    |              ^^^^^^^^^^^^^^^
 
 error: redundant clone
-  --> $DIR/redundant_clone.rs:27:29
+  --> $DIR/redundant_clone.rs:28:29
    |
 LL |     let _s = OsString::new().to_os_string();
    |                             ^^^^^^^^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> $DIR/redundant_clone.rs:27:14
+  --> $DIR/redundant_clone.rs:28:14
    |
 LL |     let _s = OsString::new().to_os_string();
    |              ^^^^^^^^^^^^^^^
 
 error: redundant clone
-  --> $DIR/redundant_clone.rs:38:19
+  --> $DIR/redundant_clone.rs:39:19
    |
 LL |     let _t = tup.0.clone();
    |                   ^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> $DIR/redundant_clone.rs:38:14
+  --> $DIR/redundant_clone.rs:39:14
    |
 LL |     let _t = tup.0.clone();
    |              ^^^^^
 
 error: redundant clone
-  --> $DIR/redundant_clone.rs:70:25
+  --> $DIR/redundant_clone.rs:71:25
    |
 LL |     if b { (a.clone(), a.clone()) } else { (Alpha, a) }
    |                         ^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> $DIR/redundant_clone.rs:70:24
+  --> $DIR/redundant_clone.rs:71:24
    |
 LL |     if b { (a.clone(), a.clone()) } else { (Alpha, a) }
    |                        ^
 
 error: redundant clone
-  --> $DIR/redundant_clone.rs:127:15
+  --> $DIR/redundant_clone.rs:128:15
    |
 LL |     let _s = s.clone();
    |               ^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> $DIR/redundant_clone.rs:127:14
+  --> $DIR/redundant_clone.rs:128:14
    |
 LL |     let _s = s.clone();
    |              ^
 
 error: redundant clone
-  --> $DIR/redundant_clone.rs:128:15
+  --> $DIR/redundant_clone.rs:129:15
    |
 LL |     let _t = t.clone();
    |               ^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> $DIR/redundant_clone.rs:128:14
+  --> $DIR/redundant_clone.rs:129:14
    |
 LL |     let _t = t.clone();
    |              ^
 
 error: redundant clone
-  --> $DIR/redundant_clone.rs:138:19
+  --> $DIR/redundant_clone.rs:139:19
    |
 LL |         let _f = f.clone();
    |                   ^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> $DIR/redundant_clone.rs:138:18
+  --> $DIR/redundant_clone.rs:139:18
    |
 LL |         let _f = f.clone();
    |                  ^
 
 error: redundant clone
-  --> $DIR/redundant_clone.rs:150:14
+  --> $DIR/redundant_clone.rs:151:14
    |
 LL |     let y = x.clone().join("matthias");
    |              ^^^^^^^^ help: remove this
    |
 note: cloned value is neither consumed nor mutated
-  --> $DIR/redundant_clone.rs:150:13
+  --> $DIR/redundant_clone.rs:151:13
    |
 LL |     let y = x.clone().join("matthias");
    |             ^^^^^^^^^
 
 error: redundant clone
-  --> $DIR/redundant_clone.rs:204:11
+  --> $DIR/redundant_clone.rs:205:11
    |
 LL |     foo(&x.clone(), move || {
    |           ^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> $DIR/redundant_clone.rs:204:10
+  --> $DIR/redundant_clone.rs:205:10
    |
 LL |     foo(&x.clone(), move || {
    |          ^
diff --git a/tests/ui/unnecessary_to_owned.fixed b/tests/ui/unnecessary_to_owned.fixed
index c879fdc3b6a..08733906b0e 100644
--- a/tests/ui/unnecessary_to_owned.fixed
+++ b/tests/ui/unnecessary_to_owned.fixed
@@ -1,7 +1,7 @@
 //@run-rustfix
 
 #![allow(clippy::needless_borrow, clippy::ptr_arg)]
-#![warn(clippy::unnecessary_to_owned)]
+#![warn(clippy::unnecessary_to_owned, clippy::redundant_clone)]
 
 use std::borrow::Cow;
 use std::ffi::{CStr, CString, OsStr, OsString};
diff --git a/tests/ui/unnecessary_to_owned.rs b/tests/ui/unnecessary_to_owned.rs
index 10588beb263..e3589ea0d65 100644
--- a/tests/ui/unnecessary_to_owned.rs
+++ b/tests/ui/unnecessary_to_owned.rs
@@ -1,7 +1,7 @@
 //@run-rustfix
 
 #![allow(clippy::needless_borrow, clippy::ptr_arg)]
-#![warn(clippy::unnecessary_to_owned)]
+#![warn(clippy::unnecessary_to_owned, clippy::redundant_clone)]
 
 use std::borrow::Cow;
 use std::ffi::{CStr, CString, OsStr, OsString};
-- 
cgit 1.4.1-3-g733a5


From ad7c44b3e44b2e100fb55d5ced4e367812233dab Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Fri, 2 Jun 2023 13:14:16 -0500
Subject: only lint when `cast_from` and `cast_to`'s ty are the same

---
 clippy_lints/src/casts/ptr_cast_constness.rs | 13 ++++----
 tests/ui/ptr_cast_constness.fixed            | 19 ++++++++----
 tests/ui/ptr_cast_constness.rs               | 29 +++++++++++-------
 tests/ui/ptr_cast_constness.stderr           | 46 ++++++++++++++++++----------
 4 files changed, 67 insertions(+), 40 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/ptr_cast_constness.rs b/clippy_lints/src/casts/ptr_cast_constness.rs
index ab015f8822e..f0c1df01430 100644
--- a/clippy_lints/src/casts/ptr_cast_constness.rs
+++ b/clippy_lints/src/casts/ptr_cast_constness.rs
@@ -9,20 +9,21 @@ use rustc_middle::ty::{self, Ty, TypeAndMut};
 
 use super::PTR_CAST_CONSTNESS;
 
-pub(super) fn check(
+pub(super) fn check<'tcx>(
     cx: &LateContext<'_>,
     expr: &Expr<'_>,
     cast_expr: &Expr<'_>,
-    cast_from: Ty<'_>,
-    cast_to: Ty<'_>,
+    cast_from: Ty<'tcx>,
+    cast_to: Ty<'tcx>,
     msrv: &Msrv,
 ) {
     if_chain! {
         if msrv.meets(POINTER_CAST_CONSTNESS);
-        if let ty::RawPtr(TypeAndMut { mutbl: from_mutbl, .. }) = cast_from.kind();
-        if let ty::RawPtr(TypeAndMut { mutbl: to_mutbl, .. }) = cast_to.kind();
+        if let ty::RawPtr(TypeAndMut { mutbl: from_mutbl, ty: from_ty }) = cast_from.kind();
+        if let ty::RawPtr(TypeAndMut { mutbl: to_mutbl, ty: to_ty }) = cast_to.kind();
         if matches!((from_mutbl, to_mutbl),
             (Mutability::Not, Mutability::Mut) | (Mutability::Mut, Mutability::Not));
+        if from_ty == to_ty;
         then {
             let sugg = Sugg::hir(cx, cast_expr, "_");
             let constness = match *to_mutbl {
@@ -34,7 +35,7 @@ pub(super) fn check(
                 cx,
                 PTR_CAST_CONSTNESS,
                 expr.span,
-                "`as` casting between raw pointers while changing its constness",
+                "`as` casting between raw pointers while changing only its constness",
                 &format!("try `pointer::cast_{constness}`, a safer alternative"),
                 format!("{}.cast_{constness}()", sugg.maybe_par()),
                 Applicability::MachineApplicable,
diff --git a/tests/ui/ptr_cast_constness.fixed b/tests/ui/ptr_cast_constness.fixed
index 24de573d083..36304e4a0f0 100644
--- a/tests/ui/ptr_cast_constness.fixed
+++ b/tests/ui/ptr_cast_constness.fixed
@@ -2,17 +2,24 @@
 //@aux-build:proc_macros.rs
 
 #![warn(clippy::ptr_cast_constness)]
+#![allow(clippy::transmute_ptr_to_ref, unused)]
 
 extern crate proc_macros;
 use proc_macros::{external, inline_macros};
 
+unsafe fn ptr_to_ref<T, U>(p: *const T, om: *mut U) {
+    let _: &mut T = std::mem::transmute(p.cast_mut());
+    let _ = &mut *p.cast_mut();
+    let _: &T = &*(om as *const T);
+}
+
 #[inline_macros]
 fn main() {
     let ptr: *const u32 = &42_u32;
     let mut_ptr: *mut u32 = &mut 42_u32;
 
-    let _ = ptr as *const i32;
-    let _ = mut_ptr as *mut i32;
+    let _ = ptr as *const u32;
+    let _ = mut_ptr as *mut u32;
 
     // Make sure the lint can handle the difference in their operator precedences.
     unsafe {
@@ -29,10 +36,10 @@ fn main() {
     let _ = ptr_of_array as *const dyn std::fmt::Debug;
 
     // Make sure the lint is triggered inside a macro
-    let _ = inline!($ptr as *const i32);
+    let _ = inline!($ptr as *const u32);
 
     // Do not lint inside macros from external crates
-    let _ = external!($ptr as *const i32);
+    let _ = external!($ptr as *const u32);
 }
 
 #[clippy::msrv = "1.64"]
@@ -41,8 +48,8 @@ fn _msrv_1_64() {
     let mut_ptr: *mut u32 = &mut 42_u32;
 
     // `pointer::cast_const` and `pointer::cast_mut` were stabilized in 1.65. Do not lint this
-    let _ = ptr as *mut i32;
-    let _ = mut_ptr as *const i32;
+    let _ = ptr as *mut u32;
+    let _ = mut_ptr as *const u32;
 }
 
 #[clippy::msrv = "1.65"]
diff --git a/tests/ui/ptr_cast_constness.rs b/tests/ui/ptr_cast_constness.rs
index 63d973a9fca..315e828bebe 100644
--- a/tests/ui/ptr_cast_constness.rs
+++ b/tests/ui/ptr_cast_constness.rs
@@ -2,26 +2,33 @@
 //@aux-build:proc_macros.rs
 
 #![warn(clippy::ptr_cast_constness)]
+#![allow(clippy::transmute_ptr_to_ref, unused)]
 
 extern crate proc_macros;
 use proc_macros::{external, inline_macros};
 
+unsafe fn ptr_to_ref<T, U>(p: *const T, om: *mut U) {
+    let _: &mut T = std::mem::transmute(p as *mut T);
+    let _ = &mut *(p as *mut T);
+    let _: &T = &*(om as *const T);
+}
+
 #[inline_macros]
 fn main() {
     let ptr: *const u32 = &42_u32;
     let mut_ptr: *mut u32 = &mut 42_u32;
 
-    let _ = ptr as *const i32;
-    let _ = mut_ptr as *mut i32;
+    let _ = ptr as *const u32;
+    let _ = mut_ptr as *mut u32;
 
     // Make sure the lint can handle the difference in their operator precedences.
     unsafe {
         let ptr_ptr: *const *const u32 = &ptr;
-        let _ = *ptr_ptr as *mut i32;
+        let _ = *ptr_ptr as *mut u32;
     }
 
-    let _ = ptr as *mut i32;
-    let _ = mut_ptr as *const i32;
+    let _ = ptr as *mut u32;
+    let _ = mut_ptr as *const u32;
 
     // Lint this, since pointer::cast_mut and pointer::cast_const have ?Sized
     let ptr_of_array: *const [u32; 4] = &[1, 2, 3, 4];
@@ -29,10 +36,10 @@ fn main() {
     let _ = ptr_of_array as *const dyn std::fmt::Debug;
 
     // Make sure the lint is triggered inside a macro
-    let _ = inline!($ptr as *const i32);
+    let _ = inline!($ptr as *const u32);
 
     // Do not lint inside macros from external crates
-    let _ = external!($ptr as *const i32);
+    let _ = external!($ptr as *const u32);
 }
 
 #[clippy::msrv = "1.64"]
@@ -41,8 +48,8 @@ fn _msrv_1_64() {
     let mut_ptr: *mut u32 = &mut 42_u32;
 
     // `pointer::cast_const` and `pointer::cast_mut` were stabilized in 1.65. Do not lint this
-    let _ = ptr as *mut i32;
-    let _ = mut_ptr as *const i32;
+    let _ = ptr as *mut u32;
+    let _ = mut_ptr as *const u32;
 }
 
 #[clippy::msrv = "1.65"]
@@ -50,6 +57,6 @@ fn _msrv_1_65() {
     let ptr: *const u32 = &42_u32;
     let mut_ptr: *mut u32 = &mut 42_u32;
 
-    let _ = ptr as *mut i32;
-    let _ = mut_ptr as *const i32;
+    let _ = ptr as *mut u32;
+    let _ = mut_ptr as *const u32;
 }
diff --git a/tests/ui/ptr_cast_constness.stderr b/tests/ui/ptr_cast_constness.stderr
index 43816c87c19..0c3ff863685 100644
--- a/tests/ui/ptr_cast_constness.stderr
+++ b/tests/ui/ptr_cast_constness.stderr
@@ -1,34 +1,46 @@
-error: `as` casting between raw pointers while changing its constness
-  --> $DIR/ptr_cast_constness.rs:20:17
+error: `as` casting between raw pointers while changing only its constness
+  --> $DIR/ptr_cast_constness.rs:11:41
    |
-LL |         let _ = *ptr_ptr as *mut i32;
-   |                 ^^^^^^^^^^^^^^^^^^^^ help: try `pointer::cast_mut`, a safer alternative: `(*ptr_ptr).cast_mut()`
+LL |     let _: &mut T = std::mem::transmute(p as *mut T);
+   |                                         ^^^^^^^^^^^ help: try `pointer::cast_mut`, a safer alternative: `p.cast_mut()`
    |
    = note: `-D clippy::ptr-cast-constness` implied by `-D warnings`
 
-error: `as` casting between raw pointers while changing its constness
-  --> $DIR/ptr_cast_constness.rs:23:13
+error: `as` casting between raw pointers while changing only its constness
+  --> $DIR/ptr_cast_constness.rs:12:19
+   |
+LL |     let _ = &mut *(p as *mut T);
+   |                   ^^^^^^^^^^^^^ help: try `pointer::cast_mut`, a safer alternative: `p.cast_mut()`
+
+error: `as` casting between raw pointers while changing only its constness
+  --> $DIR/ptr_cast_constness.rs:27:17
+   |
+LL |         let _ = *ptr_ptr as *mut u32;
+   |                 ^^^^^^^^^^^^^^^^^^^^ help: try `pointer::cast_mut`, a safer alternative: `(*ptr_ptr).cast_mut()`
+
+error: `as` casting between raw pointers while changing only its constness
+  --> $DIR/ptr_cast_constness.rs:30:13
    |
-LL |     let _ = ptr as *mut i32;
+LL |     let _ = ptr as *mut u32;
    |             ^^^^^^^^^^^^^^^ help: try `pointer::cast_mut`, a safer alternative: `ptr.cast_mut()`
 
-error: `as` casting between raw pointers while changing its constness
-  --> $DIR/ptr_cast_constness.rs:24:13
+error: `as` casting between raw pointers while changing only its constness
+  --> $DIR/ptr_cast_constness.rs:31:13
    |
-LL |     let _ = mut_ptr as *const i32;
+LL |     let _ = mut_ptr as *const u32;
    |             ^^^^^^^^^^^^^^^^^^^^^ help: try `pointer::cast_const`, a safer alternative: `mut_ptr.cast_const()`
 
-error: `as` casting between raw pointers while changing its constness
-  --> $DIR/ptr_cast_constness.rs:53:13
+error: `as` casting between raw pointers while changing only its constness
+  --> $DIR/ptr_cast_constness.rs:60:13
    |
-LL |     let _ = ptr as *mut i32;
+LL |     let _ = ptr as *mut u32;
    |             ^^^^^^^^^^^^^^^ help: try `pointer::cast_mut`, a safer alternative: `ptr.cast_mut()`
 
-error: `as` casting between raw pointers while changing its constness
-  --> $DIR/ptr_cast_constness.rs:54:13
+error: `as` casting between raw pointers while changing only its constness
+  --> $DIR/ptr_cast_constness.rs:61:13
    |
-LL |     let _ = mut_ptr as *const i32;
+LL |     let _ = mut_ptr as *const u32;
    |             ^^^^^^^^^^^^^^^^^^^^^ help: try `pointer::cast_const`, a safer alternative: `mut_ptr.cast_const()`
 
-error: aborting due to 5 previous errors
+error: aborting due to 7 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 7ac15f90002b653f9ba61185858581057d731ee0 Mon Sep 17 00:00:00 2001
From: Raghul Nanth A <61490162+NanthR@users.noreply.github.com>
Date: Sun, 7 May 2023 12:10:04 +0530
Subject: Add lint to check lint formulation messages

Fix lints that don't conform to the standard formulation
---
 clippy_lints/Cargo.toml                            |  3 +-
 clippy_lints/src/casts/mod.rs                      |  2 +-
 clippy_lints/src/declared_lints.rs                 |  2 +
 .../src/default_constructed_unit_structs.rs        |  2 +-
 clippy_lints/src/lib.rs                            |  3 +
 clippy_lints/src/loops/mod.rs                      |  6 +-
 clippy_lints/src/matches/mod.rs                    |  2 +-
 clippy_lints/src/utils/internal_lints.rs           |  1 +
 .../almost_standard_lint_formulation.rs            | 87 ++++++++++++++++++++++
 .../allow_incorrect_lint_formulations.rs           | 22 ++++++
 tests/ui-internal/check_formulation.rs             | 43 +++++++++++
 tests/ui-internal/check_formulation.stderr         | 19 +++++
 12 files changed, 185 insertions(+), 7 deletions(-)
 create mode 100644 clippy_lints/src/utils/internal_lints/almost_standard_lint_formulation.rs
 create mode 100644 tests/ui-internal/allow_incorrect_lint_formulations.rs
 create mode 100644 tests/ui-internal/check_formulation.rs
 create mode 100644 tests/ui-internal/check_formulation.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/Cargo.toml b/clippy_lints/Cargo.toml
index be9261a4704..c23054443bb 100644
--- a/clippy_lints/Cargo.toml
+++ b/clippy_lints/Cargo.toml
@@ -22,6 +22,7 @@ serde = { version = "1.0", features = ["derive"] }
 serde_json = { version = "1.0", optional = true }
 tempfile = { version = "3.3.0", optional = true }
 toml = "0.7.3"
+regex = { version = "1.5", optional = true }
 unicode-normalization = "0.1"
 unicode-script = { version = "0.5", default-features = false }
 semver = "1.0"
@@ -31,7 +32,7 @@ url = "2.2"
 [features]
 deny-warnings = ["clippy_utils/deny-warnings"]
 # build clippy with internal lints enabled, off by default
-internal = ["clippy_utils/internal", "serde_json", "tempfile"]
+internal = ["clippy_utils/internal", "serde_json", "tempfile", "regex"]
 
 [package.metadata.rust-analyzer]
 # This crate uses #[feature(rustc_private)]
diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index 4e8d5c3bccd..d2166872d93 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -522,7 +522,7 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Check for the usage of `as _` conversion using inferred type.
+    /// Checks for the usage of `as _` conversion using inferred type.
     ///
     /// ### Why is this bad?
     /// The conversion might include lossy conversion and dangerous cast that might go
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index a0b8e055f1d..01ef3ef431c 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -3,6 +3,8 @@
 // Manual edits will be overwritten.
 
 pub(crate) static LINTS: &[&crate::LintInfo] = &[
+    #[cfg(feature = "internal")]
+    crate::utils::internal_lints::almost_standard_lint_formulation::ALMOST_STANDARD_LINT_FORMULATION_INFO,
     #[cfg(feature = "internal")]
     crate::utils::internal_lints::clippy_lints_internal::CLIPPY_LINTS_INTERNAL_INFO,
     #[cfg(feature = "internal")]
diff --git a/clippy_lints/src/default_constructed_unit_structs.rs b/clippy_lints/src/default_constructed_unit_structs.rs
index fb037bbcbf3..ca9514ccc7d 100644
--- a/clippy_lints/src/default_constructed_unit_structs.rs
+++ b/clippy_lints/src/default_constructed_unit_structs.rs
@@ -8,7 +8,7 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Check for construction on unit struct using `default`.
+    /// Checks for construction on unit struct using `default`.
     ///
     /// ### Why is this bad?
     /// This adds code complexity and an unnecessary function call.
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 4a23edb58aa..43ab8a96d86 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -564,6 +564,9 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         store.register_late_pass(|_| Box::<utils::internal_lints::unnecessary_def_path::UnnecessaryDefPath>::default());
         store.register_late_pass(|_| Box::new(utils::internal_lints::outer_expn_data_pass::OuterExpnDataPass));
         store.register_late_pass(|_| Box::new(utils::internal_lints::msrv_attr_impl::MsrvAttrImpl));
+        store.register_late_pass(|_| {
+            Box::new(utils::internal_lints::almost_standard_lint_formulation::AlmostStandardFormulation::new())
+        });
     }
 
     let arithmetic_side_effects_allowed = conf.arithmetic_side_effects_allowed.clone();
diff --git a/clippy_lints/src/loops/mod.rs b/clippy_lints/src/loops/mod.rs
index f83ad388a74..c7c11809752 100644
--- a/clippy_lints/src/loops/mod.rs
+++ b/clippy_lints/src/loops/mod.rs
@@ -479,7 +479,7 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Check for unnecessary `if let` usage in a for loop
+    /// Checks for unnecessary `if let` usage in a for loop
     /// where only the `Some` or `Ok` variant of the iterator element is used.
     ///
     /// ### Why is this bad?
@@ -511,7 +511,7 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Check for empty spin loops
+    /// Checks for empty spin loops
     ///
     /// ### Why is this bad?
     /// The loop body should have something like `thread::park()` or at least
@@ -547,7 +547,7 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Check for manual implementations of Iterator::find
+    /// Checks for manual implementations of Iterator::find
     ///
     /// ### Why is this bad?
     /// It doesn't affect performance, but using `find` is shorter and easier to read.
diff --git a/clippy_lints/src/matches/mod.rs b/clippy_lints/src/matches/mod.rs
index 0d91051632a..2d27be499f9 100644
--- a/clippy_lints/src/matches/mod.rs
+++ b/clippy_lints/src/matches/mod.rs
@@ -777,7 +777,7 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Check for temporaries returned from function calls in a match scrutinee that have the
+    /// Checks for temporaries returned from function calls in a match scrutinee that have the
     /// `clippy::has_significant_drop` attribute.
     ///
     /// ### Why is this bad?
diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs
index 71f6c9909dd..e222a5448c9 100644
--- a/clippy_lints/src/utils/internal_lints.rs
+++ b/clippy_lints/src/utils/internal_lints.rs
@@ -1,3 +1,4 @@
+pub mod almost_standard_lint_formulation;
 pub mod clippy_lints_internal;
 pub mod collapsible_calls;
 pub mod compiler_lint_functions;
diff --git a/clippy_lints/src/utils/internal_lints/almost_standard_lint_formulation.rs b/clippy_lints/src/utils/internal_lints/almost_standard_lint_formulation.rs
new file mode 100644
index 00000000000..e4cb5316a98
--- /dev/null
+++ b/clippy_lints/src/utils/internal_lints/almost_standard_lint_formulation.rs
@@ -0,0 +1,87 @@
+use crate::utils::internal_lints::lint_without_lint_pass::is_lint_ref_type;
+use clippy_utils::diagnostics::span_lint_and_help;
+use regex::Regex;
+use rustc_ast as ast;
+use rustc_hir::{Item, ItemKind, Mutability};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks if lint formulations have a standardized format.
+    ///
+    /// ### Why is this bad?
+    /// It's not neccessarily bad, but we try to enforce a standard in Clippy.
+    ///
+    /// ### Example
+    /// `Checks for use...` can be written as `Checks for usage...` .
+    pub ALMOST_STANDARD_LINT_FORMULATION,
+    internal,
+    "lint formulations must have a standardized format."
+}
+
+impl_lint_pass!(AlmostStandardFormulation => [ALMOST_STANDARD_LINT_FORMULATION]);
+
+pub struct AlmostStandardFormulation {
+    standard_formulations: Vec<StandardFormulations<'static>>,
+}
+
+#[derive(Debug)]
+struct StandardFormulations<'a> {
+    wrong_pattern: Regex,
+    correction: &'a str,
+}
+
+impl AlmostStandardFormulation {
+    pub fn new() -> Self {
+        let standard_formulations = vec![StandardFormulations {
+            wrong_pattern: Regex::new(r"^(Check for|Detects? uses?)").unwrap(),
+            correction: "Checks for",
+        }];
+        Self { standard_formulations }
+    }
+}
+
+impl<'tcx> LateLintPass<'tcx> for AlmostStandardFormulation {
+    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
+        let mut check_next = false;
+        if let ItemKind::Static(ty, Mutability::Not, _) = item.kind {
+            let lines = cx
+                .tcx
+                .hir()
+                .attrs(item.hir_id())
+                .iter()
+                .filter_map(|attr| ast::Attribute::doc_str(attr).map(|sym| (sym, attr)));
+            if is_lint_ref_type(cx, ty) {
+                for (line, attr) in lines {
+                    let cur_line = line.as_str().trim();
+                    if check_next && !cur_line.is_empty() {
+                        for formulation in &self.standard_formulations {
+                            let starts_with_correct_formulation = cur_line.starts_with(formulation.correction);
+                            if !starts_with_correct_formulation && formulation.wrong_pattern.is_match(cur_line) {
+                                if let Some(ident) = attr.ident() {
+                                    span_lint_and_help(
+                                        cx,
+                                        ALMOST_STANDARD_LINT_FORMULATION,
+                                        ident.span,
+                                        "non-standard lint formulation",
+                                        None,
+                                        &format!("try using `{}` instead", formulation.correction),
+                                    );
+                                }
+                                return;
+                            }
+                        }
+                        return;
+                    } else if cur_line.contains("What it does") {
+                        check_next = true;
+                    } else if cur_line.contains("Why is this bad") {
+                        // Formulation documentation is done. Can add check to ensure that missing formulation is added
+                        // and add a check if it matches no accepted formulation
+                        return;
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/tests/ui-internal/allow_incorrect_lint_formulations.rs b/tests/ui-internal/allow_incorrect_lint_formulations.rs
new file mode 100644
index 00000000000..7d1e0f26a1b
--- /dev/null
+++ b/tests/ui-internal/allow_incorrect_lint_formulations.rs
@@ -0,0 +1,22 @@
+#![allow(clippy::almost_standard_lint_formulation)]
+#![feature(rustc_private)]
+
+#[macro_use]
+extern crate rustc_middle;
+#[macro_use]
+extern crate rustc_session;
+extern crate rustc_lint;
+
+declare_tool_lint! {
+    /// # What it does
+    /// Detects uses of incorrect formulations
+    #[clippy::version = "pre 1.29.0"]
+    pub clippy::ALLOWED_INVALID,
+    Warn,
+    "One",
+    report_in_external_macro: true
+}
+
+declare_lint_pass!(Pass => [ALLOWED_INVALID]);
+
+fn main() {}
diff --git a/tests/ui-internal/check_formulation.rs b/tests/ui-internal/check_formulation.rs
new file mode 100644
index 00000000000..d6ebadf04c4
--- /dev/null
+++ b/tests/ui-internal/check_formulation.rs
@@ -0,0 +1,43 @@
+#![warn(clippy::almost_standard_lint_formulation)]
+#![feature(rustc_private)]
+
+#[macro_use]
+extern crate rustc_middle;
+#[macro_use]
+extern crate rustc_session;
+extern crate rustc_lint;
+
+declare_tool_lint! {
+    /// # What it does
+    ///
+    /// Checks for usage of correct lint formulations
+    #[clippy::version = "pre 1.29.0"]
+    pub clippy::VALID,
+    Warn,
+    "One",
+    report_in_external_macro: true
+}
+
+declare_tool_lint! {
+    /// # What it does
+    /// Check for lint formulations that are correct
+    #[clippy::version = "pre 1.29.0"]
+    pub clippy::INVALID1,
+    Warn,
+    "One",
+    report_in_external_macro: true
+}
+
+declare_tool_lint! {
+    /// # What it does
+    /// Detects uses of incorrect formulations
+    #[clippy::version = "pre 1.29.0"]
+    pub clippy::INVALID2,
+    Warn,
+    "One",
+    report_in_external_macro: true
+}
+
+declare_lint_pass!(Pass => [VALID, INVALID1, INVALID2]);
+
+fn main() {}
diff --git a/tests/ui-internal/check_formulation.stderr b/tests/ui-internal/check_formulation.stderr
new file mode 100644
index 00000000000..10eabca4b9d
--- /dev/null
+++ b/tests/ui-internal/check_formulation.stderr
@@ -0,0 +1,19 @@
+error: non-standard lint formulation
+  --> $DIR/check_formulation.rs:23:5
+   |
+LL |     /// Check for lint formulations that are correct
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: try using `Checks for` instead
+   = note: `-D clippy::almost-standard-lint-formulation` implied by `-D warnings`
+
+error: non-standard lint formulation
+  --> $DIR/check_formulation.rs:33:5
+   |
+LL |     /// Detects uses of incorrect formulations
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: try using `Checks for` instead
+
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From a6c36556c89ddd6902be7941cadd28812f63d6ed Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Fri, 2 Jun 2023 14:35:54 -0500
Subject: use enum for `prefix` instead of `&str`

---
 clippy_lints/src/endian_bytes.rs | 61 ++++++++++++++++++----------------------
 1 file changed, 27 insertions(+), 34 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/endian_bytes.rs b/clippy_lints/src/endian_bytes.rs
index 19fb74b9050..8328531deff 100644
--- a/clippy_lints/src/endian_bytes.rs
+++ b/clippy_lints/src/endian_bytes.rs
@@ -76,6 +76,11 @@ enum LintKind {
     Big,
 }
 
+enum Prefix {
+    From,
+    To,
+}
+
 impl LintKind {
     fn allowed(&self, cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
         is_lint_allowed(cx, self.as_lint(), expr.hir_id)
@@ -89,29 +94,13 @@ impl LintKind {
         }
     }
 
-    fn to_name(&self, prefix: &str) -> &str {
+    fn as_name(&self, prefix: &Prefix) -> &str {
+        let index = if matches!(prefix, Prefix::From) { 0 } else { 1 };
+
         match self {
-            LintKind::Host => {
-                if prefix == "from" {
-                    HOST_NAMES[0]
-                } else {
-                    HOST_NAMES[1]
-                }
-            },
-            LintKind::Little => {
-                if prefix == "from" {
-                    LITTLE_NAMES[0]
-                } else {
-                    LITTLE_NAMES[1]
-                }
-            },
-            LintKind::Big => {
-                if prefix == "from" {
-                    BIG_NAMES[0]
-                } else {
-                    BIG_NAMES[1]
-                }
-            },
+            LintKind::Host => HOST_NAMES[index],
+            LintKind::Little => LITTLE_NAMES[index],
+            LintKind::Big => BIG_NAMES[index],
         }
     }
 }
@@ -127,7 +116,7 @@ impl LateLintPass<'_> for EndianBytes {
             if args.is_empty();
             let ty = cx.typeck_results().expr_ty(receiver);
             if ty.is_primitive_ty();
-            if maybe_lint_endian_bytes(cx, expr, "to", method_name.ident.name, ty);
+            if maybe_lint_endian_bytes(cx, expr, &Prefix::To, method_name.ident.name, ty);
             then {
                 return;
             }
@@ -141,16 +130,16 @@ impl LateLintPass<'_> for EndianBytes {
             let ty = cx.typeck_results().expr_ty(expr);
             if ty.is_primitive_ty();
             then {
-                maybe_lint_endian_bytes(cx, expr, "from", *function_name, ty);
+                maybe_lint_endian_bytes(cx, expr, &Prefix::From, *function_name, ty);
             }
         }
     }
 }
 
-fn maybe_lint_endian_bytes(cx: &LateContext<'_>, expr: &Expr<'_>, prefix: &str, name: Symbol, ty: Ty<'_>) -> bool {
-    let ne = LintKind::Host.to_name(prefix);
-    let le = LintKind::Little.to_name(prefix);
-    let be = LintKind::Big.to_name(prefix);
+fn maybe_lint_endian_bytes(cx: &LateContext<'_>, expr: &Expr<'_>, prefix: &Prefix, name: Symbol, ty: Ty<'_>) -> bool {
+    let ne = LintKind::Host.as_name(prefix);
+    let le = LintKind::Little.as_name(prefix);
+    let be = LintKind::Big.as_name(prefix);
 
     let (lint, other_lints) = match name.as_str() {
         name if name == ne => ((&LintKind::Host), [(&LintKind::Little), (&LintKind::Big)]),
@@ -172,14 +161,14 @@ fn maybe_lint_endian_bytes(cx: &LateContext<'_>, expr: &Expr<'_>, prefix: &str,
         }
 
         // ne_bytes and all other lints allowed
-        if lint.to_name(prefix) == ne && other_lints.iter().all(|lint| lint.allowed(cx, expr)) {
+        if lint.as_name(prefix) == ne && other_lints.iter().all(|lint| lint.allowed(cx, expr)) {
             help = Some(Cow::Borrowed("specify the desired endianness explicitly"));
             break 'build_help;
         }
 
         // le_bytes where ne_bytes allowed but be_bytes is not, or le_bytes where ne_bytes allowed but
         // le_bytes is not
-        if (lint.to_name(prefix) == le || lint.to_name(prefix) == be) && LintKind::Host.allowed(cx, expr) {
+        if (lint.as_name(prefix) == le || lint.as_name(prefix) == be) && LintKind::Host.allowed(cx, expr) {
             help = Some(Cow::Borrowed("use the native endianness instead"));
             break 'build_help;
         }
@@ -195,7 +184,7 @@ fn maybe_lint_endian_bytes(cx: &LateContext<'_>, expr: &Expr<'_>, prefix: &str,
                 help_str.push_str("either of ");
             }
 
-            help_str.push_str(&format!("`{ty}::{}` ", lint.to_name(prefix)));
+            help_str.push_str(&format!("`{ty}::{}` ", lint.as_name(prefix)));
 
             if i != len && !only_one {
                 help_str.push_str("or ");
@@ -211,9 +200,13 @@ fn maybe_lint_endian_bytes(cx: &LateContext<'_>, expr: &Expr<'_>, prefix: &str,
         expr.span,
         &format!(
             "usage of the {}`{ty}::{}`{}",
-            if prefix == "from" { "function " } else { "" },
-            lint.to_name(prefix),
-            if prefix == "to" { " method" } else { "" },
+            if matches!(prefix, Prefix::From) {
+                "function "
+            } else {
+                ""
+            },
+            lint.as_name(prefix),
+            if matches!(prefix, Prefix::To) { " method" } else { "" },
         ),
         move |diag| {
             if let Some(help) = help {
-- 
cgit 1.4.1-3-g733a5


From b1a21ae347eac7f6ce5d3bfa368b8ae5fbf1a621 Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Fri, 2 Jun 2023 14:38:03 -0500
Subject: Update endian_bytes.rs

---
 clippy_lints/src/endian_bytes.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/endian_bytes.rs b/clippy_lints/src/endian_bytes.rs
index 8328531deff..bc7dd8534c3 100644
--- a/clippy_lints/src/endian_bytes.rs
+++ b/clippy_lints/src/endian_bytes.rs
@@ -95,7 +95,7 @@ impl LintKind {
     }
 
     fn as_name(&self, prefix: &Prefix) -> &str {
-        let index = if matches!(prefix, Prefix::From) { 0 } else { 1 };
+        let index = usize::from(matches!(prefix, Prefix::To));
 
         match self {
             LintKind::Host => HOST_NAMES[index],
-- 
cgit 1.4.1-3-g733a5


From 5a7e33e5b25c6ee9b71897f2fd1a84d8c839dcf9 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Sat, 3 Jun 2023 19:16:39 +0200
Subject: add plural form to useless_conversion if depth > 0

---
 clippy_lints/src/useless_conversion.rs | 22 +++++++++++-----------
 tests/ui/useless_conversion.stderr     | 10 +++++-----
 2 files changed, 16 insertions(+), 16 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/useless_conversion.rs b/clippy_lints/src/useless_conversion.rs
index 6f1e9d5f9de..c413e92ea91 100644
--- a/clippy_lints/src/useless_conversion.rs
+++ b/clippy_lints/src/useless_conversion.rs
@@ -93,14 +93,13 @@ fn into_iter_call<'hir>(cx: &LateContext<'_>, expr: &'hir Expr<'hir>) -> Option<
 /// Same as [`into_iter_call`], but tries to look for the innermost `.into_iter()` call, e.g.:
 /// `foo.into_iter().into_iter()`
 ///  ^^^  we want this expression
-fn into_iter_deep_call<'hir>(cx: &LateContext<'_>, mut expr: &'hir Expr<'hir>) -> Option<&'hir Expr<'hir>> {
-    loop {
-        if let Some(recv) = into_iter_call(cx, expr) {
-            expr = recv;
-        } else {
-            return Some(expr);
-        }
+fn into_iter_deep_call<'hir>(cx: &LateContext<'_>, mut expr: &'hir Expr<'hir>) -> (&'hir Expr<'hir>, usize) {
+    let mut depth = 0;
+    while let Some(recv) = into_iter_call(cx, expr) {
+        expr = recv;
+        depth += 1;
     }
+    (expr, depth)
 }
 
 #[expect(clippy::too_many_lines)]
@@ -170,18 +169,19 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
                             && let Some(&into_iter_param) = sig.inputs().get(kind.param_pos(arg_pos))
                             && let ty::Param(param) = into_iter_param.kind()
                             && let Some(span) = into_iter_bound(cx, parent_fn_did, into_iter_did, param.index)
+                        {
                             // Get the "innermost" `.into_iter()` call, e.g. given this expression:
                             // `foo.into_iter().into_iter()`
                             //  ^^^
-                            //  We want this span
-                            && let Some(into_iter_recv) = into_iter_deep_call(cx, into_iter_recv)
-                        {
+                            let (into_iter_recv, depth) = into_iter_deep_call(cx, into_iter_recv);
+
+                            let plural = if depth == 0 { "" } else { "s" };
                             let mut applicability = Applicability::MachineApplicable;
                             let sugg = snippet_with_applicability(cx, into_iter_recv.span.source_callsite(), "<expr>", &mut applicability).into_owned();
                             span_lint_and_then(cx, USELESS_CONVERSION, e.span, "explicit call to `.into_iter()` in function argument accepting `IntoIterator`", |diag| {
                                 diag.span_suggestion(
                                     e.span,
-                                    "consider removing `.into_iter()`",
+                                    format!("consider removing the `.into_iter()`{plural}"),
                                     sugg,
                                     applicability,
                                 );
diff --git a/tests/ui/useless_conversion.stderr b/tests/ui/useless_conversion.stderr
index 68f38faab59..4957f73a469 100644
--- a/tests/ui/useless_conversion.stderr
+++ b/tests/ui/useless_conversion.stderr
@@ -122,7 +122,7 @@ error: explicit call to `.into_iter()` in function argument accepting `IntoItera
   --> $DIR/useless_conversion.rs:171:7
    |
 LL |     b(vec![1, 2].into_iter());
-   |       ^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `vec![1, 2]`
+   |       ^^^^^^^^^^^^^^^^^^^^^^ help: consider removing the `.into_iter()`: `vec![1, 2]`
    |
 note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
   --> $DIR/useless_conversion.rs:161:13
@@ -134,7 +134,7 @@ error: explicit call to `.into_iter()` in function argument accepting `IntoItera
   --> $DIR/useless_conversion.rs:172:7
    |
 LL |     c(vec![1, 2].into_iter());
-   |       ^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `vec![1, 2]`
+   |       ^^^^^^^^^^^^^^^^^^^^^^ help: consider removing the `.into_iter()`: `vec![1, 2]`
    |
 note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
   --> $DIR/useless_conversion.rs:162:18
@@ -146,7 +146,7 @@ error: explicit call to `.into_iter()` in function argument accepting `IntoItera
   --> $DIR/useless_conversion.rs:173:7
    |
 LL |     d(vec![1, 2].into_iter());
-   |       ^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `vec![1, 2]`
+   |       ^^^^^^^^^^^^^^^^^^^^^^ help: consider removing the `.into_iter()`: `vec![1, 2]`
    |
 note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
   --> $DIR/useless_conversion.rs:165:12
@@ -158,7 +158,7 @@ error: explicit call to `.into_iter()` in function argument accepting `IntoItera
   --> $DIR/useless_conversion.rs:176:7
    |
 LL |     b(vec![1, 2].into_iter().into_iter());
-   |       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `vec![1, 2]`
+   |       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing the `.into_iter()`s: `vec![1, 2]`
    |
 note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
   --> $DIR/useless_conversion.rs:161:13
@@ -170,7 +170,7 @@ error: explicit call to `.into_iter()` in function argument accepting `IntoItera
   --> $DIR/useless_conversion.rs:177:7
    |
 LL |     b(vec![1, 2].into_iter().into_iter().into_iter());
-   |       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `vec![1, 2]`
+   |       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing the `.into_iter()`s: `vec![1, 2]`
    |
 note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
   --> $DIR/useless_conversion.rs:161:13
-- 
cgit 1.4.1-3-g733a5


From 7fe200ed0586b690cc6a0981fa4e7b74c248e273 Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Sat, 3 Jun 2023 14:31:40 -0500
Subject: derive Copy/PartialEq for `Prefix`

---
 clippy_lints/src/endian_bytes.rs | 19 ++++++++-----------
 1 file changed, 8 insertions(+), 11 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/endian_bytes.rs b/clippy_lints/src/endian_bytes.rs
index bc7dd8534c3..f470987833e 100644
--- a/clippy_lints/src/endian_bytes.rs
+++ b/clippy_lints/src/endian_bytes.rs
@@ -76,6 +76,7 @@ enum LintKind {
     Big,
 }
 
+#[derive(Clone, Copy, PartialEq)]
 enum Prefix {
     From,
     To,
@@ -94,8 +95,8 @@ impl LintKind {
         }
     }
 
-    fn as_name(&self, prefix: &Prefix) -> &str {
-        let index = usize::from(matches!(prefix, Prefix::To));
+    fn as_name(&self, prefix: Prefix) -> &str {
+        let index = usize::from(prefix == Prefix::To);
 
         match self {
             LintKind::Host => HOST_NAMES[index],
@@ -116,7 +117,7 @@ impl LateLintPass<'_> for EndianBytes {
             if args.is_empty();
             let ty = cx.typeck_results().expr_ty(receiver);
             if ty.is_primitive_ty();
-            if maybe_lint_endian_bytes(cx, expr, &Prefix::To, method_name.ident.name, ty);
+            if maybe_lint_endian_bytes(cx, expr, Prefix::To, method_name.ident.name, ty);
             then {
                 return;
             }
@@ -130,13 +131,13 @@ impl LateLintPass<'_> for EndianBytes {
             let ty = cx.typeck_results().expr_ty(expr);
             if ty.is_primitive_ty();
             then {
-                maybe_lint_endian_bytes(cx, expr, &Prefix::From, *function_name, ty);
+                maybe_lint_endian_bytes(cx, expr, Prefix::From, *function_name, ty);
             }
         }
     }
 }
 
-fn maybe_lint_endian_bytes(cx: &LateContext<'_>, expr: &Expr<'_>, prefix: &Prefix, name: Symbol, ty: Ty<'_>) -> bool {
+fn maybe_lint_endian_bytes(cx: &LateContext<'_>, expr: &Expr<'_>, prefix: Prefix, name: Symbol, ty: Ty<'_>) -> bool {
     let ne = LintKind::Host.as_name(prefix);
     let le = LintKind::Little.as_name(prefix);
     let be = LintKind::Big.as_name(prefix);
@@ -200,13 +201,9 @@ fn maybe_lint_endian_bytes(cx: &LateContext<'_>, expr: &Expr<'_>, prefix: &Prefi
         expr.span,
         &format!(
             "usage of the {}`{ty}::{}`{}",
-            if matches!(prefix, Prefix::From) {
-                "function "
-            } else {
-                ""
-            },
+            if prefix == Prefix::From { "function " } else { "" },
             lint.as_name(prefix),
-            if matches!(prefix, Prefix::To) { " method" } else { "" },
+            if prefix == Prefix::To { " method" } else { "" },
         ),
         move |diag| {
             if let Some(help) = help {
-- 
cgit 1.4.1-3-g733a5


From 05bfcbd9113e3f06adcbfdb773e839dfe2ec205b Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Sat, 3 Jun 2023 14:38:16 -0500
Subject: remove tuple

---
 clippy_lints/src/allow_attributes.rs | 6 +++---
 clippy_lints/src/attrs.rs            | 4 ++--
 clippy_utils/src/check_proc_macro.rs | 7 ++++---
 3 files changed, 9 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/allow_attributes.rs b/clippy_lints/src/allow_attributes.rs
index 69ccbeb7b06..eb21184713e 100644
--- a/clippy_lints/src/allow_attributes.rs
+++ b/clippy_lints/src/allow_attributes.rs
@@ -1,4 +1,4 @@
-use ast::AttrStyle;
+use ast::{AttrStyle, Attribute};
 use clippy_utils::{diagnostics::span_lint_and_sugg, is_from_proc_macro};
 use rustc_ast as ast;
 use rustc_errors::Applicability;
@@ -50,14 +50,14 @@ declare_lint_pass!(AllowAttribute => [ALLOW_ATTRIBUTES]);
 
 impl LateLintPass<'_> for AllowAttribute {
     // Separate each crate's features.
-    fn check_attribute(&mut self, cx: &LateContext<'_>, attr: &ast::Attribute) {
+    fn check_attribute<'cx>(&mut self, cx: &LateContext<'cx>, attr: &'cx Attribute) {
         if_chain! {
             if !in_external_macro(cx.sess(), attr.span);
             if cx.tcx.features().lint_reasons;
             if let AttrStyle::Outer = attr.style;
             if let Some(ident) = attr.ident();
             if ident.name == rustc_span::symbol::sym::allow;
-            if !is_from_proc_macro(cx, &(attr, cx));
+            if !is_from_proc_macro(cx, &attr);
             then {
                 span_lint_and_sugg(
                     cx,
diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs
index e989cde0f3c..b882eee8a65 100644
--- a/clippy_lints/src/attrs.rs
+++ b/clippy_lints/src/attrs.rs
@@ -543,7 +543,7 @@ fn check_clippy_lint_names(cx: &LateContext<'_>, name: Symbol, items: &[NestedMe
     }
 }
 
-fn check_lint_reason(cx: &LateContext<'_>, name: Symbol, items: &[NestedMetaItem], attr: &Attribute) {
+fn check_lint_reason<'cx>(cx: &LateContext<'cx>, name: Symbol, items: &[NestedMetaItem], attr: &'cx Attribute) {
     // Check for the feature
     if !cx.tcx.features().lint_reasons {
         return;
@@ -558,7 +558,7 @@ fn check_lint_reason(cx: &LateContext<'_>, name: Symbol, items: &[NestedMetaItem
     }
 
     // Check if the attribute is in an external macro and therefore out of the developer's control
-    if in_external_macro(cx.sess(), attr.span) || is_from_proc_macro(cx, &(attr, cx)) {
+    if in_external_macro(cx.sess(), attr.span) || is_from_proc_macro(cx, &attr) {
         return;
     }
 
diff --git a/clippy_utils/src/check_proc_macro.rs b/clippy_utils/src/check_proc_macro.rs
index fd04f2ddf7c..7e954898460 100644
--- a/clippy_utils/src/check_proc_macro.rs
+++ b/clippy_utils/src/check_proc_macro.rs
@@ -358,15 +358,16 @@ impl<'cx> WithSearchPat for (&FnKind<'cx>, &Body<'cx>, HirId, Span) {
     }
 }
 
-impl<'cx> WithSearchPat for (&Attribute, &LateContext<'cx>) {
+// `Attribute` does not have the `hir` associated lifetime, so we cannot use the macro
+impl<'cx> WithSearchPat for &'cx Attribute {
     type Context = LateContext<'cx>;
 
     fn search_pat(&self, _cx: &Self::Context) -> (Pat, Pat) {
-        attr_search_pat(self.0)
+        attr_search_pat(self)
     }
 
     fn span(&self) -> Span {
-        self.0.span
+        self.span
     }
 }
 
-- 
cgit 1.4.1-3-g733a5


From 01b105725888cab56ef240331b7c32e88ce24121 Mon Sep 17 00:00:00 2001
From: Alessio Cosenza <cosenzaalessio17@gmail.com>
Date: Wed, 29 Mar 2023 00:49:43 +0200
Subject: Add redundant type annotations lint

---
 CHANGELOG.md                                   |   1 +
 clippy_lints/src/declared_lints.rs             |   1 +
 clippy_lints/src/lib.rs                        |   2 +
 clippy_lints/src/redundant_type_annotations.rs | 185 +++++++++++++++++++++++++
 tests/ui/redundant_type_annotations.rs         | 160 +++++++++++++++++++++
 tests/ui/redundant_type_annotations.stderr     |  94 +++++++++++++
 6 files changed, 443 insertions(+)
 create mode 100644 clippy_lints/src/redundant_type_annotations.rs
 create mode 100644 tests/ui/redundant_type_annotations.rs
 create mode 100644 tests/ui/redundant_type_annotations.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 4648af231a4..a65ac4d46de 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5110,6 +5110,7 @@ Released 2018-09-13
 [`redundant_pub_crate`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_pub_crate
 [`redundant_slicing`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_slicing
 [`redundant_static_lifetimes`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_static_lifetimes
+[`redundant_type_annotations`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_type_annotations
 [`ref_binding_to_reference`]: https://rust-lang.github.io/rust-clippy/master/index.html#ref_binding_to_reference
 [`ref_in_deref`]: https://rust-lang.github.io/rust-clippy/master/index.html#ref_in_deref
 [`ref_option_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#ref_option_ref
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 68272e1a77a..d014534cee9 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -543,6 +543,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::redundant_slicing::DEREF_BY_SLICING_INFO,
     crate::redundant_slicing::REDUNDANT_SLICING_INFO,
     crate::redundant_static_lifetimes::REDUNDANT_STATIC_LIFETIMES_INFO,
+    crate::redundant_type_annotations::REDUNDANT_TYPE_ANNOTATIONS_INFO,
     crate::ref_option_ref::REF_OPTION_REF_INFO,
     crate::ref_patterns::REF_PATTERNS_INFO,
     crate::reference::DEREF_ADDROF_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 222b0cc0921..d53c6de5451 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -267,6 +267,7 @@ mod redundant_field_names;
 mod redundant_pub_crate;
 mod redundant_slicing;
 mod redundant_static_lifetimes;
+mod redundant_type_annotations;
 mod ref_option_ref;
 mod ref_patterns;
 mod reference;
@@ -1012,6 +1013,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_early_pass(|| Box::new(needless_else::NeedlessElse));
     store.register_late_pass(|_| Box::new(missing_fields_in_debug::MissingFieldsInDebug));
     store.register_late_pass(|_| Box::new(endian_bytes::EndianBytes));
+    store.register_late_pass(|_| Box::new(redundant_type_annotations::RedundantTypeAnnotations));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/redundant_type_annotations.rs b/clippy_lints/src/redundant_type_annotations.rs
new file mode 100644
index 00000000000..30d06a2cbc7
--- /dev/null
+++ b/clippy_lints/src/redundant_type_annotations.rs
@@ -0,0 +1,185 @@
+use clippy_utils::diagnostics::span_lint;
+use rustc_ast::LitKind;
+use rustc_hir as hir;
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::Ty;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Warns about needless / redundant type annotations.
+    ///
+    /// ### Why is this bad?
+    /// Code without type annotations is shorter and in most cases
+    /// more idiomatic and easier to modify.
+    ///
+    /// ### Example
+    /// ```rust
+    /// let foo: String = String::new();
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// let foo = String::new();
+    /// ```
+    #[clippy::version = "1.70.0"]
+    pub REDUNDANT_TYPE_ANNOTATIONS,
+    pedantic,
+    "warns about needless / redundant type annotations."
+}
+declare_lint_pass!(RedundantTypeAnnotations => [REDUNDANT_TYPE_ANNOTATIONS]);
+
+fn is_same_type<'tcx>(cx: &LateContext<'tcx>, ty_resolved_path: hir::def::Res, func_return_type: Ty<'tcx>) -> bool {
+    // type annotation is primitive
+    if let hir::def::Res::PrimTy(primty) = ty_resolved_path
+        && func_return_type.is_primitive()
+        && let Some(func_return_type_sym) = func_return_type.primitive_symbol()
+    {
+        return primty.name() == func_return_type_sym;
+    }
+
+    // type annotation is any other non generic type
+    if let hir::def::Res::Def(_, defid) = ty_resolved_path
+        && let Some(annotation_ty) = cx.tcx.type_of(defid).no_bound_vars()
+    {
+        return annotation_ty == func_return_type;
+    }
+
+    false
+}
+
+fn func_hir_id_to_func_ty<'tcx>(cx: &LateContext<'tcx>, hir_id: hir::hir_id::HirId) -> Option<Ty<'tcx>> {
+    if let Some((defkind, func_defid)) = cx.typeck_results().type_dependent_def(hir_id)
+        && defkind == hir::def::DefKind::AssocFn
+        && let Some(init_ty) = cx.tcx.type_of(func_defid).no_bound_vars()
+    {
+        Some(init_ty)
+    } else {
+        None
+    }
+}
+
+fn func_ty_to_return_type<'tcx>(cx: &LateContext<'tcx>, func_ty: Ty<'tcx>) -> Option<Ty<'tcx>> {
+    if func_ty.is_fn()
+        && let Some(return_type) = func_ty.fn_sig(cx.tcx).output().no_bound_vars()
+    {
+        Some(return_type)
+    } else {
+        None
+    }
+}
+
+/// Extracts the fn Ty, e.g. `fn() -> std::string::String {f}`
+fn extract_fn_ty<'tcx>(
+    cx: &LateContext<'tcx>,
+    call: &hir::Expr<'tcx>,
+    func_return_path: &hir::QPath<'tcx>,
+) -> Option<Ty<'tcx>> {
+    match func_return_path {
+        // let a: String = f(); where f: fn f() -> String
+        hir::QPath::Resolved(_, resolved_path) => {
+            if let hir::def::Res::Def(_, defid) = resolved_path.res
+                && let Some(middle_ty_init) = cx.tcx.type_of(defid).no_bound_vars()
+            {
+                Some(middle_ty_init)
+            } else {
+                None
+            }
+        },
+        // Associated functions like
+        // let a: String = String::new();
+        // let a: String = String::get_string();
+        hir::QPath::TypeRelative(..) => func_hir_id_to_func_ty(cx, call.hir_id),
+        hir::QPath::LangItem(..) => None,
+    }
+}
+
+fn is_redundant_in_func_call<'tcx>(
+    cx: &LateContext<'tcx>,
+    ty_resolved_path: hir::def::Res,
+    call: &hir::Expr<'tcx>,
+) -> bool {
+    if let hir::ExprKind::Path(init_path) = &call.kind {
+        let func_type = extract_fn_ty(cx, call, init_path);
+
+        if let Some(func_type) = func_type
+            && let Some(init_return_type) = func_ty_to_return_type(cx, func_type)
+        {
+            return is_same_type(cx, ty_resolved_path, init_return_type);
+        }
+    }
+
+    false
+}
+
+impl LateLintPass<'_> for RedundantTypeAnnotations {
+    fn check_local<'tcx>(&mut self, cx: &LateContext<'tcx>, local: &'tcx rustc_hir::Local<'tcx>) {
+        // type annotation part
+        if !local.span.from_expansion()
+            && let Some(ty) = &local.ty
+
+            // initialization part
+            && let Some(init) = local.init
+        {
+            match &init.kind {
+                // When the initialization is a call to a function
+                hir::ExprKind::Call(init_call, _) => {
+                    if let hir::TyKind::Path(ty_path) = &ty.kind
+                        && let hir::QPath::Resolved(_, resolved_path_ty) = ty_path
+
+                        && is_redundant_in_func_call(cx, resolved_path_ty.res, init_call) {
+                        span_lint(cx, REDUNDANT_TYPE_ANNOTATIONS, local.span, "redundant type annotation");
+                    }
+                },
+                hir::ExprKind::MethodCall(_, _, _, _) => {
+                    if let hir::TyKind::Path(ty_path) = &ty.kind
+                        && let hir::QPath::Resolved(_, resolved_path_ty) = ty_path
+
+                        && let Some(func_ty) = func_hir_id_to_func_ty(cx, init.hir_id)
+                        && let Some(return_type) = func_ty_to_return_type(cx, func_ty)
+                        && is_same_type(cx, resolved_path_ty.res, return_type)
+                    {
+                        span_lint(cx, REDUNDANT_TYPE_ANNOTATIONS, local.span, "redundant type annotation");
+                    }
+                },
+                // When the initialization is a path for example u32::MAX
+                hir::ExprKind::Path(init_path) => {
+                    // TODO: check for non primty
+                    if let hir::TyKind::Path(ty_path) = &ty.kind
+                        && let hir::QPath::Resolved(_, resolved_path_ty) = ty_path
+                        && let hir::def::Res::PrimTy(primty) = resolved_path_ty.res
+
+                        && let hir::QPath::TypeRelative(init_ty, _) = init_path
+                        && let hir::TyKind::Path(init_ty_path) = &init_ty.kind
+                        && let hir::QPath::Resolved(_, resolved_init_ty_path) = init_ty_path
+                        && let hir::def::Res::PrimTy(primty_init) = resolved_init_ty_path.res
+
+                        && primty == primty_init
+                    {
+                        span_lint(cx, REDUNDANT_TYPE_ANNOTATIONS, local.span, "redundant type annotation");
+                    }
+                },
+                hir::ExprKind::Lit(init_lit) => {
+                    match init_lit.node {
+                        // In these cases the annotation is redundant
+                        LitKind::Str(..)
+                        | LitKind::ByteStr(..)
+                        | LitKind::Byte(..)
+                        | LitKind::Char(..)
+                        | LitKind::Bool(..)
+                        | LitKind::CStr(..) => {
+                            span_lint(cx, REDUNDANT_TYPE_ANNOTATIONS, local.span, "redundant type annotation");
+                        },
+                        LitKind::Int(..) | LitKind::Float(..) => {
+                            // If the initialization value is a suffixed literal we lint
+                            if init_lit.node.is_suffixed() {
+                                span_lint(cx, REDUNDANT_TYPE_ANNOTATIONS, local.span, "redundant type annotation");
+                            }
+                        },
+                        LitKind::Err => (),
+                    }
+                }
+                _ => ()
+            }
+        };
+    }
+}
diff --git a/tests/ui/redundant_type_annotations.rs b/tests/ui/redundant_type_annotations.rs
new file mode 100644
index 00000000000..5722621e83a
--- /dev/null
+++ b/tests/ui/redundant_type_annotations.rs
@@ -0,0 +1,160 @@
+#![allow(unused)]
+#![warn(clippy::redundant_type_annotations)]
+
+#[derive(Debug, Default)]
+struct Cake<T> {
+    _data: T,
+}
+
+fn make_something<T: Default>() -> T {
+    T::default()
+}
+
+fn make_cake<T: Default>() -> Cake<T> {
+    Cake::<T>::default()
+}
+
+fn plus_one<T: std::ops::Add<u8, Output = T>>(val: T) -> T {
+    val + 1
+}
+
+struct Pie {
+    inner: u32,
+}
+
+enum Pizza {
+    One,
+    Two,
+}
+
+fn return_a_string() -> String {
+    String::new()
+}
+
+fn return_a_struct() -> Pie {
+    Pie { inner: 5 }
+}
+
+fn return_an_enum() -> Pizza {
+    Pizza::One
+}
+
+fn return_an_int() -> u32 {
+    5
+}
+
+impl Pie {
+    fn return_an_int(&self) -> u32 {
+        self.inner
+    }
+
+    fn associated_return_an_int() -> u32 {
+        5
+    }
+
+    fn new() -> Self {
+        Self { inner: 5 }
+    }
+
+    fn associated_return_a_string() -> String {
+        String::from("")
+    }
+
+    fn test_method_call(&self) {
+        let v: u32 = self.return_an_int(); // Should lint
+    }
+}
+
+fn test_generics() {
+    // The type annotation is needed to determine T
+    let _c: Cake<i32> = make_something();
+
+    // The type annotation is needed to determine the topic
+    let _c: Cake<u8> = make_cake();
+
+    // This should lint (doesn't)
+    let _c: Cake<u8> = make_cake::<u8>();
+
+    // This should lint (doesn't)
+    let _c: u8 = make_something::<u8>();
+
+    // This should lint (doesn't)
+    let _c: u8 = plus_one(5_u8);
+
+    // Annotation needed otherwise T is i32
+    let _c: u8 = plus_one(5);
+}
+
+fn test_non_locals() {
+    // This shouldn't lint
+    fn _arg(x: u32) -> u32 {
+        x
+    }
+
+    // This could lint, but probably shouldn't
+    let _closure_arg = |x: u32| x;
+}
+
+fn test_complex_types() {
+    // Shouldn't lint, since the literal will be i32 otherwise
+    let _u8: u8 = 128;
+
+    // Should lint (doesn't)
+    let _tuple_i32: (i32, i32) = (12, 13);
+
+    // Shouldn't lint, since the tuple will be i32 otherwise
+    let _tuple_u32: (u32, u32) = (1, 2);
+
+    // Should lint, since the type is determined by the init value (doesn't)
+    let _tuple_u32: (u32, u32) = (3_u32, 4_u32);
+
+    // Should lint (doesn't)
+    let _array: [i32; 3] = [5, 6, 7];
+
+    // Shouldn't lint
+    let _array: [u32; 2] = [8, 9];
+}
+
+fn test_functions() {
+    // Everything here should lint
+
+    let _return: String = return_a_string();
+
+    let _return: Pie = return_a_struct();
+
+    let _return: Pizza = return_an_enum();
+
+    let _return: u32 = return_an_int();
+
+    let _return: String = String::new();
+
+    let new_pie: Pie = Pie::new();
+
+    let _return: u32 = new_pie.return_an_int();
+
+    let _return: String = String::from("test");
+
+    let _return: u32 = Pie::associated_return_an_int();
+
+    let _return: String = Pie::associated_return_a_string();
+}
+
+fn test_simple_types() {
+    let _var: u32 = u32::MAX;
+
+    // Should lint
+    let _var: u32 = 5_u32;
+
+    // Should lint
+    let _var: &str = "test";
+
+    // Should lint
+    let _var: &[u8] = b"test";
+
+    // Should lint
+    let _var: bool = false;
+}
+
+fn main() {}
+
+// TODO: test refs
diff --git a/tests/ui/redundant_type_annotations.stderr b/tests/ui/redundant_type_annotations.stderr
new file mode 100644
index 00000000000..3356f480860
--- /dev/null
+++ b/tests/ui/redundant_type_annotations.stderr
@@ -0,0 +1,94 @@
+error: redundant type annotation
+  --> $DIR/redundant_type_annotations.rs:64:9
+   |
+LL |         let v: u32 = self.return_an_int(); // Should lint
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::redundant-type-annotations` implied by `-D warnings`
+
+error: redundant type annotation
+  --> $DIR/redundant_type_annotations.rs:121:5
+   |
+LL |     let _return: String = return_a_string();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: redundant type annotation
+  --> $DIR/redundant_type_annotations.rs:123:5
+   |
+LL |     let _return: Pie = return_a_struct();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: redundant type annotation
+  --> $DIR/redundant_type_annotations.rs:125:5
+   |
+LL |     let _return: Pizza = return_an_enum();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: redundant type annotation
+  --> $DIR/redundant_type_annotations.rs:127:5
+   |
+LL |     let _return: u32 = return_an_int();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: redundant type annotation
+  --> $DIR/redundant_type_annotations.rs:129:5
+   |
+LL |     let _return: String = String::new();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: redundant type annotation
+  --> $DIR/redundant_type_annotations.rs:131:5
+   |
+LL |     let new_pie: Pie = Pie::new();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: redundant type annotation
+  --> $DIR/redundant_type_annotations.rs:133:5
+   |
+LL |     let _return: u32 = new_pie.return_an_int();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: redundant type annotation
+  --> $DIR/redundant_type_annotations.rs:137:5
+   |
+LL |     let _return: u32 = Pie::associated_return_an_int();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: redundant type annotation
+  --> $DIR/redundant_type_annotations.rs:139:5
+   |
+LL |     let _return: String = Pie::associated_return_a_string();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: redundant type annotation
+  --> $DIR/redundant_type_annotations.rs:143:5
+   |
+LL |     let _var: u32 = u32::MAX;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: redundant type annotation
+  --> $DIR/redundant_type_annotations.rs:146:5
+   |
+LL |     let _var: u32 = 5_u32;
+   |     ^^^^^^^^^^^^^^^^^^^^^^
+
+error: redundant type annotation
+  --> $DIR/redundant_type_annotations.rs:149:5
+   |
+LL |     let _var: &str = "test";
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: redundant type annotation
+  --> $DIR/redundant_type_annotations.rs:152:5
+   |
+LL |     let _var: &[u8] = b"test";
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: redundant type annotation
+  --> $DIR/redundant_type_annotations.rs:155:5
+   |
+LL |     let _var: bool = false;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 15 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 6776608f21a14fdc9ca3751cdac6ade48b3f0346 Mon Sep 17 00:00:00 2001
From: Alessio Cosenza <cosenzaalessio17@gmail.com>
Date: Tue, 25 Apr 2023 00:28:17 +0200
Subject: Move `redundant_type_annotations` to restriction

---
 clippy_lints/src/redundant_type_annotations.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/redundant_type_annotations.rs b/clippy_lints/src/redundant_type_annotations.rs
index 30d06a2cbc7..f277adfa94d 100644
--- a/clippy_lints/src/redundant_type_annotations.rs
+++ b/clippy_lints/src/redundant_type_annotations.rs
@@ -23,7 +23,7 @@ declare_clippy_lint! {
     /// ```
     #[clippy::version = "1.70.0"]
     pub REDUNDANT_TYPE_ANNOTATIONS,
-    pedantic,
+    restriction,
     "warns about needless / redundant type annotations."
 }
 declare_lint_pass!(RedundantTypeAnnotations => [REDUNDANT_TYPE_ANNOTATIONS]);
-- 
cgit 1.4.1-3-g733a5


From 6f26df1c9a2ca1e4d161c49733c460fd32fddb02 Mon Sep 17 00:00:00 2001
From: Alessio Cosenza <cosenzaalessio17@gmail.com>
Date: Fri, 19 May 2023 17:45:49 +0200
Subject: Extract common logic to function

---
 clippy_lints/src/redundant_type_annotations.rs | 19 +++++++++++++------
 1 file changed, 13 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/redundant_type_annotations.rs b/clippy_lints/src/redundant_type_annotations.rs
index f277adfa94d..da139cdde92 100644
--- a/clippy_lints/src/redundant_type_annotations.rs
+++ b/clippy_lints/src/redundant_type_annotations.rs
@@ -111,6 +111,17 @@ fn is_redundant_in_func_call<'tcx>(
     false
 }
 
+fn extract_primty<'tcx>(ty_kind: &hir::TyKind<'tcx>) -> Option<hir::PrimTy> {
+    if let hir::TyKind::Path(ty_path) = ty_kind
+        && let hir::QPath::Resolved(_, resolved_path_ty) = ty_path
+        && let hir::def::Res::PrimTy(primty) = resolved_path_ty.res
+    {
+        Some(primty)
+    } else {
+        None
+    }
+}
+
 impl LateLintPass<'_> for RedundantTypeAnnotations {
     fn check_local<'tcx>(&mut self, cx: &LateContext<'tcx>, local: &'tcx rustc_hir::Local<'tcx>) {
         // type annotation part
@@ -144,14 +155,10 @@ impl LateLintPass<'_> for RedundantTypeAnnotations {
                 // When the initialization is a path for example u32::MAX
                 hir::ExprKind::Path(init_path) => {
                     // TODO: check for non primty
-                    if let hir::TyKind::Path(ty_path) = &ty.kind
-                        && let hir::QPath::Resolved(_, resolved_path_ty) = ty_path
-                        && let hir::def::Res::PrimTy(primty) = resolved_path_ty.res
+                    if let Some(primty) = extract_primty(&ty.kind)
 
                         && let hir::QPath::TypeRelative(init_ty, _) = init_path
-                        && let hir::TyKind::Path(init_ty_path) = &init_ty.kind
-                        && let hir::QPath::Resolved(_, resolved_init_ty_path) = init_ty_path
-                        && let hir::def::Res::PrimTy(primty_init) = resolved_init_ty_path.res
+                        && let Some(primty_init) = extract_primty(&init_ty.kind)
 
                         && primty == primty_init
                     {
-- 
cgit 1.4.1-3-g733a5


From 29ab954a2b8e9b89215f5cd7159931d283818da6 Mon Sep 17 00:00:00 2001
From: Alessio Cosenza <cosenzaalessio17@gmail.com>
Date: Fri, 19 May 2023 17:46:32 +0200
Subject: Add support to returned refs from `MethodCall`

---
 clippy_lints/src/redundant_type_annotations.rs | 26 +++++++----
 tests/ui/redundant_type_annotations.rs         | 60 ++++++++++++++++----------
 tests/ui/redundant_type_annotations.stderr     | 46 ++++++++++++--------
 3 files changed, 85 insertions(+), 47 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/redundant_type_annotations.rs b/clippy_lints/src/redundant_type_annotations.rs
index da139cdde92..18647891ac6 100644
--- a/clippy_lints/src/redundant_type_annotations.rs
+++ b/clippy_lints/src/redundant_type_annotations.rs
@@ -59,10 +59,8 @@ fn func_hir_id_to_func_ty<'tcx>(cx: &LateContext<'tcx>, hir_id: hir::hir_id::Hir
 }
 
 fn func_ty_to_return_type<'tcx>(cx: &LateContext<'tcx>, func_ty: Ty<'tcx>) -> Option<Ty<'tcx>> {
-    if func_ty.is_fn()
-        && let Some(return_type) = func_ty.fn_sig(cx.tcx).output().no_bound_vars()
-    {
-        Some(return_type)
+    if func_ty.is_fn() {
+        Some(func_ty.fn_sig(cx.tcx).output().skip_binder())
     } else {
         None
     }
@@ -111,7 +109,7 @@ fn is_redundant_in_func_call<'tcx>(
     false
 }
 
-fn extract_primty<'tcx>(ty_kind: &hir::TyKind<'tcx>) -> Option<hir::PrimTy> {
+fn extract_primty(ty_kind: &hir::TyKind<'_>) -> Option<hir::PrimTy> {
     if let hir::TyKind::Path(ty_path) = ty_kind
         && let hir::QPath::Resolved(_, resolved_path_ty) = ty_path
         && let hir::def::Res::PrimTy(primty) = resolved_path_ty.res
@@ -142,12 +140,24 @@ impl LateLintPass<'_> for RedundantTypeAnnotations {
                     }
                 },
                 hir::ExprKind::MethodCall(_, _, _, _) => {
-                    if let hir::TyKind::Path(ty_path) = &ty.kind
-                        && let hir::QPath::Resolved(_, resolved_path_ty) = ty_path
+                    let mut is_ref = false;
+                    let mut ty_kind = &ty.kind;
 
+                    // If the annotation is a ref we "peel" it
+                    if let hir::TyKind::Ref(_, mut_ty) = &ty.kind {
+                        is_ref = true;
+                        ty_kind = &mut_ty.ty.kind;
+                    }
+
+                    if let hir::TyKind::Path(ty_path) = ty_kind
+                        && let hir::QPath::Resolved(_, resolved_path_ty) = ty_path
                         && let Some(func_ty) = func_hir_id_to_func_ty(cx, init.hir_id)
                         && let Some(return_type) = func_ty_to_return_type(cx, func_ty)
-                        && is_same_type(cx, resolved_path_ty.res, return_type)
+                        && is_same_type(cx, resolved_path_ty.res, if is_ref {
+                            return_type.peel_refs()
+                        } else {
+                            return_type
+                        })
                     {
                         span_lint(cx, REDUNDANT_TYPE_ANNOTATIONS, local.span, "redundant type annotation");
                     }
diff --git a/tests/ui/redundant_type_annotations.rs b/tests/ui/redundant_type_annotations.rs
index 5722621e83a..cc507b8d658 100644
--- a/tests/ui/redundant_type_annotations.rs
+++ b/tests/ui/redundant_type_annotations.rs
@@ -18,8 +18,15 @@ fn plus_one<T: std::ops::Add<u8, Output = T>>(val: T) -> T {
     val + 1
 }
 
+#[derive(Default)]
+struct Slice {
+    inner: u32,
+}
+
+#[derive(Default)]
 struct Pie {
     inner: u32,
+    inner_struct: Slice,
 }
 
 enum Pizza {
@@ -32,7 +39,7 @@ fn return_a_string() -> String {
 }
 
 fn return_a_struct() -> Pie {
-    Pie { inner: 5 }
+    Pie::default()
 }
 
 fn return_an_enum() -> Pizza {
@@ -48,12 +55,20 @@ impl Pie {
         self.inner
     }
 
+    fn return_a_ref(&self) -> &u32 {
+        &self.inner
+    }
+
+    fn return_a_ref_to_struct(&self) -> &Slice {
+        &self.inner_struct
+    }
+
     fn associated_return_an_int() -> u32 {
         5
     }
 
     fn new() -> Self {
-        Self { inner: 5 }
+        Self::default()
     }
 
     fn associated_return_a_string() -> String {
@@ -61,7 +76,11 @@ impl Pie {
     }
 
     fn test_method_call(&self) {
-        let v: u32 = self.return_an_int(); // Should lint
+        // Everything here should be lint
+
+        let v: u32 = self.return_an_int();
+        let v: &u32 = self.return_a_ref();
+        let v: &Slice = self.return_a_ref_to_struct();
     }
 }
 
@@ -72,21 +91,24 @@ fn test_generics() {
     // The type annotation is needed to determine the topic
     let _c: Cake<u8> = make_cake();
 
-    // This should lint (doesn't)
+    // This could be lint, but currently doesn't
     let _c: Cake<u8> = make_cake::<u8>();
 
-    // This should lint (doesn't)
+    // This could be lint, but currently doesn't
     let _c: u8 = make_something::<u8>();
 
-    // This should lint (doesn't)
+    // This could be lint, but currently doesn't
     let _c: u8 = plus_one(5_u8);
 
     // Annotation needed otherwise T is i32
     let _c: u8 = plus_one(5);
+
+    // This could be lint, but currently doesn't
+    let _return: String = String::from("test");
 }
 
 fn test_non_locals() {
-    // This shouldn't lint
+    // This shouldn't be lint
     fn _arg(x: u32) -> u32 {
         x
     }
@@ -96,27 +118,27 @@ fn test_non_locals() {
 }
 
 fn test_complex_types() {
-    // Shouldn't lint, since the literal will be i32 otherwise
+    // Shouldn't be lint, since the literal will be i32 otherwise
     let _u8: u8 = 128;
 
-    // Should lint (doesn't)
+    // This could be lint, but currently doesn't
     let _tuple_i32: (i32, i32) = (12, 13);
 
-    // Shouldn't lint, since the tuple will be i32 otherwise
+    // Shouldn't be lint, since the tuple will be i32 otherwise
     let _tuple_u32: (u32, u32) = (1, 2);
 
-    // Should lint, since the type is determined by the init value (doesn't)
+    // Should be lint, since the type is determined by the init value, but currently doesn't
     let _tuple_u32: (u32, u32) = (3_u32, 4_u32);
 
-    // Should lint (doesn't)
+    // This could be lint, but currently doesn't
     let _array: [i32; 3] = [5, 6, 7];
 
-    // Shouldn't lint
+    // Shouldn't be lint
     let _array: [u32; 2] = [8, 9];
 }
 
 fn test_functions() {
-    // Everything here should lint
+    // Everything here should be lint
 
     let _return: String = return_a_string();
 
@@ -132,29 +154,23 @@ fn test_functions() {
 
     let _return: u32 = new_pie.return_an_int();
 
-    let _return: String = String::from("test");
-
     let _return: u32 = Pie::associated_return_an_int();
 
     let _return: String = Pie::associated_return_a_string();
 }
 
 fn test_simple_types() {
+    // Everything here should be lint
+
     let _var: u32 = u32::MAX;
 
-    // Should lint
     let _var: u32 = 5_u32;
 
-    // Should lint
     let _var: &str = "test";
 
-    // Should lint
     let _var: &[u8] = b"test";
 
-    // Should lint
     let _var: bool = false;
 }
 
 fn main() {}
-
-// TODO: test refs
diff --git a/tests/ui/redundant_type_annotations.stderr b/tests/ui/redundant_type_annotations.stderr
index 3356f480860..e8b2fe5c384 100644
--- a/tests/ui/redundant_type_annotations.stderr
+++ b/tests/ui/redundant_type_annotations.stderr
@@ -1,94 +1,106 @@
 error: redundant type annotation
-  --> $DIR/redundant_type_annotations.rs:64:9
+  --> $DIR/redundant_type_annotations.rs:81:9
    |
-LL |         let v: u32 = self.return_an_int(); // Should lint
+LL |         let v: u32 = self.return_an_int();
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::redundant-type-annotations` implied by `-D warnings`
 
 error: redundant type annotation
-  --> $DIR/redundant_type_annotations.rs:121:5
+  --> $DIR/redundant_type_annotations.rs:82:9
+   |
+LL |         let v: &u32 = self.return_a_ref();
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: redundant type annotation
+  --> $DIR/redundant_type_annotations.rs:83:9
+   |
+LL |         let v: &Slice = self.return_a_ref_to_struct();
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: redundant type annotation
+  --> $DIR/redundant_type_annotations.rs:143:5
    |
 LL |     let _return: String = return_a_string();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: redundant type annotation
-  --> $DIR/redundant_type_annotations.rs:123:5
+  --> $DIR/redundant_type_annotations.rs:145:5
    |
 LL |     let _return: Pie = return_a_struct();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: redundant type annotation
-  --> $DIR/redundant_type_annotations.rs:125:5
+  --> $DIR/redundant_type_annotations.rs:147:5
    |
 LL |     let _return: Pizza = return_an_enum();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: redundant type annotation
-  --> $DIR/redundant_type_annotations.rs:127:5
+  --> $DIR/redundant_type_annotations.rs:149:5
    |
 LL |     let _return: u32 = return_an_int();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: redundant type annotation
-  --> $DIR/redundant_type_annotations.rs:129:5
+  --> $DIR/redundant_type_annotations.rs:151:5
    |
 LL |     let _return: String = String::new();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: redundant type annotation
-  --> $DIR/redundant_type_annotations.rs:131:5
+  --> $DIR/redundant_type_annotations.rs:153:5
    |
 LL |     let new_pie: Pie = Pie::new();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: redundant type annotation
-  --> $DIR/redundant_type_annotations.rs:133:5
+  --> $DIR/redundant_type_annotations.rs:155:5
    |
 LL |     let _return: u32 = new_pie.return_an_int();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: redundant type annotation
-  --> $DIR/redundant_type_annotations.rs:137:5
+  --> $DIR/redundant_type_annotations.rs:157:5
    |
 LL |     let _return: u32 = Pie::associated_return_an_int();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: redundant type annotation
-  --> $DIR/redundant_type_annotations.rs:139:5
+  --> $DIR/redundant_type_annotations.rs:159:5
    |
 LL |     let _return: String = Pie::associated_return_a_string();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: redundant type annotation
-  --> $DIR/redundant_type_annotations.rs:143:5
+  --> $DIR/redundant_type_annotations.rs:165:5
    |
 LL |     let _var: u32 = u32::MAX;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: redundant type annotation
-  --> $DIR/redundant_type_annotations.rs:146:5
+  --> $DIR/redundant_type_annotations.rs:167:5
    |
 LL |     let _var: u32 = 5_u32;
    |     ^^^^^^^^^^^^^^^^^^^^^^
 
 error: redundant type annotation
-  --> $DIR/redundant_type_annotations.rs:149:5
+  --> $DIR/redundant_type_annotations.rs:169:5
    |
 LL |     let _var: &str = "test";
    |     ^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: redundant type annotation
-  --> $DIR/redundant_type_annotations.rs:152:5
+  --> $DIR/redundant_type_annotations.rs:171:5
    |
 LL |     let _var: &[u8] = b"test";
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: redundant type annotation
-  --> $DIR/redundant_type_annotations.rs:155:5
+  --> $DIR/redundant_type_annotations.rs:173:5
    |
 LL |     let _var: bool = false;
    |     ^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 15 previous errors
+error: aborting due to 17 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From a9b468f2b51a251d0d718059299d0ccd0e561389 Mon Sep 17 00:00:00 2001
From: Alessio Cosenza <cosenzaalessio17@gmail.com>
Date: Mon, 29 May 2023 11:24:36 +0200
Subject: Add `Limitations` section

---
 clippy_lints/src/redundant_type_annotations.rs | 8 ++++++++
 1 file changed, 8 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/redundant_type_annotations.rs b/clippy_lints/src/redundant_type_annotations.rs
index 18647891ac6..8e9234bba3c 100644
--- a/clippy_lints/src/redundant_type_annotations.rs
+++ b/clippy_lints/src/redundant_type_annotations.rs
@@ -13,6 +13,14 @@ declare_clippy_lint! {
     /// Code without type annotations is shorter and in most cases
     /// more idiomatic and easier to modify.
     ///
+    /// ### Limitations
+    /// This lint doesn't support:
+    ///
+    /// - Generics
+    /// - Refs returned from anything else than a `MethodCall`
+    /// - Complex types (tuples, arrays, etc...)
+    /// - `Path` to anything else than a primitive type.
+    ///
     /// ### Example
     /// ```rust
     /// let foo: String = String::new();
-- 
cgit 1.4.1-3-g733a5


From 6f2497703e7e3b7c4c0c007371ed6870c984769a Mon Sep 17 00:00:00 2001
From: MarcusGrass <34198073+MarcusGrass@users.noreply.github.com>
Date: Mon, 5 Jun 2023 15:48:57 +0200
Subject: Compact issue link

Co-authored-by: Takayuki Nakata <f.seasons017@gmail.com>
---
 clippy_lints/src/returns.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
index 92913ddc4aa..b5686e390ad 100644
--- a/clippy_lints/src/returns.rs
+++ b/clippy_lints/src/returns.rs
@@ -27,7 +27,7 @@ declare_clippy_lint! {
     ///
     /// ### Known problems
     /// In the case of some temporaries, e.g. locks, eliding the variable binding could lead
-    /// to deadlocks. See [rust-lang issue 37612](https://github.com/rust-lang/rust/issues/37612).
+    /// to deadlocks. See [this issue](https://github.com/rust-lang/rust/issues/37612).
     /// This could become relevant if the code is later changed to use the code that would have been
     /// bound without first assigning it to a let-binding.
     ///
-- 
cgit 1.4.1-3-g733a5


From 6ea7cd8ec700c4fbf1397eeef65fad5478965564 Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Mon, 5 Jun 2023 14:38:38 -0500
Subject: Fix #10504, don't lint on derived code

---
 clippy_lints/src/trait_bounds.rs          |  3 +++
 tests/ui/type_repetition_in_bounds.rs     | 15 +++++++++++++++
 tests/ui/type_repetition_in_bounds.stderr |  8 ++++----
 3 files changed, 22 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/trait_bounds.rs b/clippy_lints/src/trait_bounds.rs
index 4ccda15068b..913ef7644aa 100644
--- a/clippy_lints/src/trait_bounds.rs
+++ b/clippy_lints/src/trait_bounds.rs
@@ -260,6 +260,9 @@ impl TraitBounds {
                     SpanlessTy { ty: p.bounded_ty, cx },
                     p.bounds.iter().collect::<Vec<_>>()
                 );
+                if let TyKind::Path(qpath) = p.bounded_ty.kind;
+                if format!("{}:", rustc_hir_pretty::qpath_to_string(&qpath))
+                    == format!("{}:", snippet(cx, p.bounded_ty.span, "_"));
 
                 then {
                     let trait_bounds = v
diff --git a/tests/ui/type_repetition_in_bounds.rs b/tests/ui/type_repetition_in_bounds.rs
index 8b4613b3f6e..1d36f4b3c7b 100644
--- a/tests/ui/type_repetition_in_bounds.rs
+++ b/tests/ui/type_repetition_in_bounds.rs
@@ -1,6 +1,7 @@
 #![deny(clippy::type_repetition_in_bounds)]
 #![allow(clippy::extra_unused_type_parameters)]
 
+use serde::Deserialize;
 use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Sub, SubAssign};
 
 pub fn foo<T>(_t: T)
@@ -70,6 +71,20 @@ mod issue4326 {
     }
 }
 
+// Extern macros shouldn't lint, again (see #10504)
+mod issue10504 {
+    use serde::{Deserialize, Serialize};
+    use std::fmt::Debug;
+    use std::hash::Hash;
+
+    #[derive(Debug, Serialize, Deserialize)]
+    #[serde(bound(
+        serialize = "T: Serialize + Hash + Eq",
+        deserialize = "Box<T>: serde::de::DeserializeOwned + Hash + Eq"
+    ))]
+    struct OpaqueParams<T: ?Sized + Debug>(std::marker::PhantomData<T>);
+}
+
 // Issue #7360
 struct Foo<T, U>
 where
diff --git a/tests/ui/type_repetition_in_bounds.stderr b/tests/ui/type_repetition_in_bounds.stderr
index a90df03c04f..56867f75b07 100644
--- a/tests/ui/type_repetition_in_bounds.stderr
+++ b/tests/ui/type_repetition_in_bounds.stderr
@@ -1,5 +1,5 @@
 error: this type has already been used as a bound predicate
-  --> $DIR/type_repetition_in_bounds.rs:9:5
+  --> $DIR/type_repetition_in_bounds.rs:10:5
    |
 LL |     T: Clone,
    |     ^^^^^^^^
@@ -12,7 +12,7 @@ LL | #![deny(clippy::type_repetition_in_bounds)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this type has already been used as a bound predicate
-  --> $DIR/type_repetition_in_bounds.rs:26:5
+  --> $DIR/type_repetition_in_bounds.rs:27:5
    |
 LL |     Self: Copy + Default + Ord,
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -20,7 +20,7 @@ LL |     Self: Copy + Default + Ord,
    = help: consider combining the bounds: `Self: Clone + Copy + Default + Ord`
 
 error: this type has already been used as a bound predicate
-  --> $DIR/type_repetition_in_bounds.rs:86:5
+  --> $DIR/type_repetition_in_bounds.rs:101:5
    |
 LL |     T: Clone,
    |     ^^^^^^^^
@@ -28,7 +28,7 @@ LL |     T: Clone,
    = help: consider combining the bounds: `T: ?Sized + Clone`
 
 error: this type has already been used as a bound predicate
-  --> $DIR/type_repetition_in_bounds.rs:91:5
+  --> $DIR/type_repetition_in_bounds.rs:106:5
    |
 LL |     T: ?Sized,
    |     ^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From 0250c518449f535a4d38bf17f5b0ba5ecda3f3c9 Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Mon, 5 Jun 2023 14:46:47 -0500
Subject: refactor

---
 clippy_lints/src/trait_bounds.rs | 11 ++++-------
 1 file changed, 4 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/trait_bounds.rs b/clippy_lints/src/trait_bounds.rs
index 913ef7644aa..90c6429ff38 100644
--- a/clippy_lints/src/trait_bounds.rs
+++ b/clippy_lints/src/trait_bounds.rs
@@ -260,9 +260,9 @@ impl TraitBounds {
                     SpanlessTy { ty: p.bounded_ty, cx },
                     p.bounds.iter().collect::<Vec<_>>()
                 );
+                let bounded_ty = snippet(cx, p.bounded_ty.span, "_");
                 if let TyKind::Path(qpath) = p.bounded_ty.kind;
-                if format!("{}:", rustc_hir_pretty::qpath_to_string(&qpath))
-                    == format!("{}:", snippet(cx, p.bounded_ty.span, "_"));
+                if format!("{}:", rustc_hir_pretty::qpath_to_string(&qpath)) == format!("{}:", bounded_ty);
 
                 then {
                     let trait_bounds = v
@@ -272,10 +272,7 @@ impl TraitBounds {
                         .filter_map(get_trait_info_from_bound)
                         .map(|(_, _, span)| snippet_with_applicability(cx, span, "..", &mut applicability))
                         .join(" + ");
-                    let hint_string = format!(
-                        "consider combining the bounds: `{}: {trait_bounds}`",
-                        snippet(cx, p.bounded_ty.span, "_"),
-                    );
+                    let hint_string = format!("consider combining the bounds: `{}: {trait_bounds}`", bounded_ty);
                     span_lint_and_help(
                         cx,
                         TYPE_REPETITION_IN_BOUNDS,
@@ -345,7 +342,7 @@ fn check_trait_bound_duplication(cx: &LateContext<'_>, gen: &'_ Generics<'_>) {
                             "this trait bound is already specified in the where clause",
                             None,
                             "consider removing this trait bound",
-                            );
+                        );
                     }
                 }
             }
-- 
cgit 1.4.1-3-g733a5


From f68ee79864fb51232fb186fda6bf218be50c7e4a Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Mon, 5 Jun 2023 14:53:22 -0500
Subject: Update trait_bounds.rs

---
 clippy_lints/src/trait_bounds.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/trait_bounds.rs b/clippy_lints/src/trait_bounds.rs
index 90c6429ff38..2e6108d6b24 100644
--- a/clippy_lints/src/trait_bounds.rs
+++ b/clippy_lints/src/trait_bounds.rs
@@ -262,7 +262,7 @@ impl TraitBounds {
                 );
                 let bounded_ty = snippet(cx, p.bounded_ty.span, "_");
                 if let TyKind::Path(qpath) = p.bounded_ty.kind;
-                if format!("{}:", rustc_hir_pretty::qpath_to_string(&qpath)) == format!("{}:", bounded_ty);
+                if format!("{}:", rustc_hir_pretty::qpath_to_string(&qpath)) == format!("{bounded_ty}:");
 
                 then {
                     let trait_bounds = v
@@ -272,7 +272,7 @@ impl TraitBounds {
                         .filter_map(get_trait_info_from_bound)
                         .map(|(_, _, span)| snippet_with_applicability(cx, span, "..", &mut applicability))
                         .join(" + ");
-                    let hint_string = format!("consider combining the bounds: `{}: {trait_bounds}`", bounded_ty);
+                    let hint_string = format!("consider combining the bounds: `{bounded_ty}: {trait_bounds}`");
                     span_lint_and_help(
                         cx,
                         TYPE_REPETITION_IN_BOUNDS,
-- 
cgit 1.4.1-3-g733a5


From 1cf95a9d50b0ca8be1687e03db4202cf033d4a74 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Tue, 6 Jun 2023 01:23:42 +0200
Subject: don't call `type_of` on generic params

---
 clippy_lints/src/missing_fields_in_debug.rs | 5 +++++
 1 file changed, 5 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/missing_fields_in_debug.rs b/clippy_lints/src/missing_fields_in_debug.rs
index b6f0de7e504..1138d1163a4 100644
--- a/clippy_lints/src/missing_fields_in_debug.rs
+++ b/clippy_lints/src/missing_fields_in_debug.rs
@@ -207,6 +207,11 @@ impl<'tcx> LateLintPass<'tcx> for MissingFieldsInDebug {
         if let ItemKind::Impl(Impl { of_trait: Some(trait_ref), self_ty, items, .. }) = item.kind
             && let Res::Def(DefKind::Trait, trait_def_id) = trait_ref.path.res
             && let TyKind::Path(QPath::Resolved(_, self_path)) = &self_ty.kind
+            // don't trigger if self is a generic parameter, e.g. `impl<T> Debug for T`
+            // this can only happen in core itself, where the trait is defined,
+            // but it caused ICEs in the past:
+            // https://github.com/rust-lang/rust-clippy/issues/10887
+            && !matches!(self_path.res, Res::Def(DefKind::TyParam, _))
             && cx.match_def_path(trait_def_id, &[sym::core, sym::fmt, sym::Debug])
             // don't trigger if this impl was derived
             && !cx.tcx.has_attr(item.owner_id, sym::automatically_derived)
-- 
cgit 1.4.1-3-g733a5


From 7cd0ec58aa22bf84b7e452aa682d3694542a3399 Mon Sep 17 00:00:00 2001
From: asquared31415 <34665709+asquared31415@users.noreply.github.com>
Date: Tue, 6 Jun 2023 14:58:54 -0400
Subject: add more info link

---
 clippy_lints/src/casts/cast_possible_wrap.rs | 14 +++++++++++---
 tests/ui/cast.stderr                         |  6 ++++++
 2 files changed, 17 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/cast_possible_wrap.rs b/clippy_lints/src/casts/cast_possible_wrap.rs
index e872d190c82..f77d7821539 100644
--- a/clippy_lints/src/casts/cast_possible_wrap.rs
+++ b/clippy_lints/src/casts/cast_possible_wrap.rs
@@ -1,6 +1,5 @@
-use clippy_utils::diagnostics::span_lint;
 use rustc_hir::Expr;
-use rustc_lint::LateContext;
+use rustc_lint::{LateContext, LintContext};
 use rustc_middle::ty::Ty;
 
 use super::{utils, CAST_POSSIBLE_WRAP};
@@ -9,6 +8,7 @@ use super::{utils, CAST_POSSIBLE_WRAP};
 const ALLOWED_POINTER_SIZES: [u64; 3] = [16, 32, 64];
 
 // whether the lint should be emitted, and the required pointer size, if it matters
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
 enum EmitState {
     NoLint,
     LintAlways,
@@ -77,5 +77,13 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_from: Ty<'_>, ca
         ),
     };
 
-    span_lint(cx, CAST_POSSIBLE_WRAP, expr.span, message.as_str());
+    cx.struct_span_lint(CAST_POSSIBLE_WRAP, expr.span, message, |diag| {
+        if let EmitState::LintOnPtrSize(16) = should_lint {
+            diag
+            .note("`usize` and `isize` may be as small as 16 bits on some platforms")
+            .note("for more information see https://doc.rust-lang.org/reference/types/numeric.html#machine-dependent-integer-types")
+        } else {
+            diag
+        }
+    });
 }
diff --git a/tests/ui/cast.stderr b/tests/ui/cast.stderr
index a7d78a95d59..de29af78ef3 100644
--- a/tests/ui/cast.stderr
+++ b/tests/ui/cast.stderr
@@ -244,6 +244,9 @@ error: casting `usize` to `i16` may wrap around the value on targets with 16-bit
    |
 LL |     1usize as i16; // wraps on 16 bit ptr size
    |     ^^^^^^^^^^^^^
+   |
+   = note: `usize` and `isize` may be as small as 16 bits on some platforms
+   = note: for more information see https://doc.rust-lang.org/reference/types/numeric.html#machine-dependent-integer-types
 
 error: casting `usize` to `i32` may truncate the value on targets with 64-bit wide pointers
   --> $DIR/cast.rs:46:5
@@ -274,6 +277,9 @@ error: casting `u16` to `isize` may wrap around the value on targets with 16-bit
    |
 LL |     1u16 as isize; // wraps on 16 bit ptr size
    |     ^^^^^^^^^^^^^
+   |
+   = note: `usize` and `isize` may be as small as 16 bits on some platforms
+   = note: for more information see https://doc.rust-lang.org/reference/types/numeric.html#machine-dependent-integer-types
 
 error: casting `u32` to `isize` may wrap around the value on targets with 32-bit wide pointers
   --> $DIR/cast.rs:50:5
-- 
cgit 1.4.1-3-g733a5


From 566a365d4f7dc865ee1942a49c23617ce5ea6f69 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Tue, 6 Jun 2023 22:29:13 +0200
Subject: make `useless_vec` smarter

---
 clippy_lints/src/vec.rs | 111 ++++++++++++++++++++++++++++++++++++++++++------
 1 file changed, 97 insertions(+), 14 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/vec.rs b/clippy_lints/src/vec.rs
index 7329e508106..ec21f3bb54f 100644
--- a/clippy_lints/src/vec.rs
+++ b/clippy_lints/src/vec.rs
@@ -1,16 +1,21 @@
+use std::ops::ControlFlow;
+
 use clippy_utils::consts::{constant, Constant};
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::higher;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::is_copy;
+use clippy_utils::visitors::for_each_local_use_after_expr;
+use clippy_utils::{get_parent_expr, higher, is_trait_method};
 use if_chain::if_chain;
+use rustc_ast::BindingAnnotation;
 use rustc_errors::Applicability;
-use rustc_hir::{BorrowKind, Expr, ExprKind, Mutability};
+use rustc_hir::{BorrowKind, Expr, ExprKind, Mutability, Node, PatKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::layout::LayoutOf;
 use rustc_middle::ty::{self, Ty};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::Span;
+use rustc_span::sym;
 
 #[expect(clippy::module_name_repetitions)]
 #[derive(Copy, Clone)]
@@ -20,7 +25,7 @@ pub struct UselessVec {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of `&vec![..]` when using `&[..]` would
+    /// Checks for usage of `vec![..]` when using `[..]` would
     /// be possible.
     ///
     /// ### Why is this bad?
@@ -46,16 +51,70 @@ declare_clippy_lint! {
 
 impl_lint_pass!(UselessVec => [USELESS_VEC]);
 
+fn adjusts_to_slice(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
+    if let ty::Ref(_, ty, _) = cx.typeck_results().expr_ty_adjusted(e).kind() {
+        ty.is_slice()
+    } else {
+        false
+    }
+}
+
+/// Checks if the given expression is a method call to a `Vec` method
+/// that also exists on slices. If this returns true, it means that
+/// this expression does not actually require a `Vec` and could just work with an array.
+fn is_allowed_vec_method(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
+    const ALLOWED_METHOD_NAMES: &[&str] = &["len", "as_ptr", "as_slice", "is_empty"];
+
+    if let ExprKind::MethodCall(path, ..) = e.kind {
+        ALLOWED_METHOD_NAMES.contains(&path.ident.name.as_str())
+    } else {
+        is_trait_method(cx, e, sym::IntoIterator)
+    }
+}
+
 impl<'tcx> LateLintPass<'tcx> for UselessVec {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         // search for `&vec![_]` expressions where the adjusted type is `&[_]`
         if_chain! {
-            if let ty::Ref(_, ty, _) = cx.typeck_results().expr_ty_adjusted(expr).kind();
-            if let ty::Slice(..) = ty.kind();
+            if adjusts_to_slice(cx, expr);
             if let ExprKind::AddrOf(BorrowKind::Ref, mutability, addressee) = expr.kind;
             if let Some(vec_args) = higher::VecArgs::hir(cx, addressee);
             then {
-                self.check_vec_macro(cx, &vec_args, mutability, expr.span);
+                self.check_vec_macro(cx, &vec_args, mutability, expr.span, SuggestSlice::Yes);
+            }
+        }
+
+        // search for `let foo = vec![_]` expressions where all uses of `foo`
+        // adjust to slices or call a method that exist on slices (e.g. len)
+        if let Some(vec_args) = higher::VecArgs::hir(cx, expr)
+            && let Node::Local(local) = cx.tcx.hir().get_parent(expr.hir_id)
+            // for now ignore locals with type annotations.
+            // this is to avoid compile errors when doing the suggestion here: let _: Vec<_> = vec![..];
+            && local.ty.is_none()
+            && let PatKind::Binding(BindingAnnotation(_, mutbl), id, ..) = local.pat.kind
+            && is_copy(cx, vec_type(cx.typeck_results().expr_ty_adjusted(expr)))
+        {
+            let only_slice_uses = for_each_local_use_after_expr(cx, id, expr.hir_id, |expr| {
+                // allow indexing into a vec and some set of allowed method calls that exist on slices, too
+                if let Some(parent) = get_parent_expr(cx, expr)
+                    && (adjusts_to_slice(cx, expr)
+                        || matches!(parent.kind, ExprKind::Index(..))
+                        || is_allowed_vec_method(cx, parent))
+                {
+                    ControlFlow::Continue(())
+                } else {
+                    ControlFlow::Break(())
+                }
+            }).is_continue();
+
+            if only_slice_uses {
+                self.check_vec_macro(
+                    cx,
+                    &vec_args,
+                    mutbl,
+                    expr.span.ctxt().outer_expn_data().call_site,
+                    SuggestSlice::No
+                );
             }
         }
 
@@ -67,12 +126,20 @@ impl<'tcx> LateLintPass<'tcx> for UselessVec {
             then {
                 // report the error around the `vec!` not inside `<std macros>:`
                 let span = arg.span.ctxt().outer_expn_data().call_site;
-                self.check_vec_macro(cx, &vec_args, Mutability::Not, span);
+                self.check_vec_macro(cx, &vec_args, Mutability::Not, span, SuggestSlice::Yes);
             }
         }
     }
 }
 
+#[derive(Copy, Clone)]
+enum SuggestSlice {
+    /// Suggest using a slice `&[..]` / `&mut [..]`
+    Yes,
+    /// Suggest using an array: `[..]`
+    No,
+}
+
 impl UselessVec {
     fn check_vec_macro<'tcx>(
         self,
@@ -80,8 +147,15 @@ impl UselessVec {
         vec_args: &higher::VecArgs<'tcx>,
         mutability: Mutability,
         span: Span,
+        suggest_slice: SuggestSlice,
     ) {
         let mut applicability = Applicability::MachineApplicable;
+
+        let (borrow_prefix_mut, borrow_prefix) = match suggest_slice {
+            SuggestSlice::Yes => ("&mut ", "&"),
+            SuggestSlice::No => ("", ""),
+        };
+
         let snippet = match *vec_args {
             higher::VecArgs::Repeat(elem, len) => {
                 if let Some(Constant::Int(len_constant)) = constant(cx, cx.typeck_results(), len) {
@@ -93,14 +167,14 @@ impl UselessVec {
                     match mutability {
                         Mutability::Mut => {
                             format!(
-                                "&mut [{}; {}]",
+                                "{borrow_prefix_mut}[{}; {}]",
                                 snippet_with_applicability(cx, elem.span, "elem", &mut applicability),
                                 snippet_with_applicability(cx, len.span, "len", &mut applicability)
                             )
                         },
                         Mutability::Not => {
                             format!(
-                                "&[{}; {}]",
+                                "{borrow_prefix}[{}; {}]",
                                 snippet_with_applicability(cx, elem.span, "elem", &mut applicability),
                                 snippet_with_applicability(cx, len.span, "len", &mut applicability)
                             )
@@ -120,18 +194,21 @@ impl UselessVec {
                     match mutability {
                         Mutability::Mut => {
                             format!(
-                                "&mut [{}]",
+                                "{borrow_prefix_mut}[{}]",
                                 snippet_with_applicability(cx, span, "..", &mut applicability)
                             )
                         },
                         Mutability::Not => {
-                            format!("&[{}]", snippet_with_applicability(cx, span, "..", &mut applicability))
+                            format!(
+                                "{borrow_prefix}[{}]",
+                                snippet_with_applicability(cx, span, "..", &mut applicability)
+                            )
                         },
                     }
                 } else {
                     match mutability {
-                        Mutability::Mut => "&mut []".into(),
-                        Mutability::Not => "&[]".into(),
+                        Mutability::Mut => format!("{borrow_prefix_mut}[]"),
+                        Mutability::Not => format!("{borrow_prefix}[]"),
                     }
                 }
             },
@@ -142,7 +219,13 @@ impl UselessVec {
             USELESS_VEC,
             span,
             "useless use of `vec!`",
-            "you can use a slice directly",
+            &format!(
+                "you can use {} directly",
+                match suggest_slice {
+                    SuggestSlice::Yes => "a slice",
+                    SuggestSlice::No => "an array",
+                }
+            ),
             snippet,
             applicability,
         );
-- 
cgit 1.4.1-3-g733a5


From ba1fb74bf1633a5150b4843f6d0bde7af2443950 Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Tue, 6 Jun 2023 21:01:14 -0500
Subject: check for `_` instead

---
 clippy_lints/src/let_with_type_underscore.rs | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/let_with_type_underscore.rs b/clippy_lints/src/let_with_type_underscore.rs
index 4f8c5ff58b5..4e9d77ea156 100644
--- a/clippy_lints/src/let_with_type_underscore.rs
+++ b/clippy_lints/src/let_with_type_underscore.rs
@@ -26,19 +26,16 @@ declare_clippy_lint! {
 declare_lint_pass!(UnderscoreTyped => [LET_WITH_TYPE_UNDERSCORE]);
 
 impl LateLintPass<'_> for UnderscoreTyped {
-    fn check_local<'tcx>(&mut self, cx: &LateContext<'tcx>, local: &'tcx Local<'tcx>) {
+    fn check_local(&mut self, cx: &LateContext<'_>, local: &Local<'_>) {
         if_chain! {
             if !in_external_macro(cx.tcx.sess, local.span);
             if let Some(ty) = local.ty; // Ensure that it has a type defined
             if let TyKind::Infer = &ty.kind; // that type is '_'
             if local.span.ctxt() == ty.span.ctxt();
             then {
-                let underscore_span = ty.span.with_lo(local.pat.span.hi());
-                let snippet = snippet(cx, underscore_span, ": _");
-
                 // NOTE: Using `is_from_proc_macro` on `init` will require that it's initialized,
                 // this doesn't. Alternatively, `WithSearchPat` can be implemented for `Ty`
-                if !snippet.trim().starts_with(':') && !snippet.trim().ends_with('_') {
+                if snippet(cx, ty.span, "_").trim() != "_" {
                     return;
                 }
 
@@ -47,7 +44,7 @@ impl LateLintPass<'_> for UnderscoreTyped {
                     LET_WITH_TYPE_UNDERSCORE,
                     local.span,
                     "variable declared with type underscore",
-                    Some(underscore_span),
+                    Some(ty.span.with_lo(local.pat.span.hi())),
                     "remove the explicit type `_` declaration"
                 )
             }
-- 
cgit 1.4.1-3-g733a5


From a434a7715d205959c3a07c9a7fe43e56a128e0c4 Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Tue, 6 Jun 2023 22:16:02 -0500
Subject: `impl WithSearchPat for Ty`

---
 clippy_lints/src/trait_bounds.rs     | 12 ++++++------
 clippy_utils/src/check_proc_macro.rs |  3 ++-
 2 files changed, 8 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/trait_bounds.rs b/clippy_lints/src/trait_bounds.rs
index 2e6108d6b24..f4554fbcf9b 100644
--- a/clippy_lints/src/trait_bounds.rs
+++ b/clippy_lints/src/trait_bounds.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg};
 use clippy_utils::source::{snippet, snippet_opt, snippet_with_applicability};
-use clippy_utils::{SpanlessEq, SpanlessHash};
+use clippy_utils::{is_from_proc_macro, SpanlessEq, SpanlessHash};
 use core::hash::{Hash, Hasher};
 use if_chain::if_chain;
 use itertools::Itertools;
@@ -260,10 +260,7 @@ impl TraitBounds {
                     SpanlessTy { ty: p.bounded_ty, cx },
                     p.bounds.iter().collect::<Vec<_>>()
                 );
-                let bounded_ty = snippet(cx, p.bounded_ty.span, "_");
-                if let TyKind::Path(qpath) = p.bounded_ty.kind;
-                if format!("{}:", rustc_hir_pretty::qpath_to_string(&qpath)) == format!("{bounded_ty}:");
-
+                if !is_from_proc_macro(cx, p.bounded_ty);
                 then {
                     let trait_bounds = v
                         .iter()
@@ -272,7 +269,10 @@ impl TraitBounds {
                         .filter_map(get_trait_info_from_bound)
                         .map(|(_, _, span)| snippet_with_applicability(cx, span, "..", &mut applicability))
                         .join(" + ");
-                    let hint_string = format!("consider combining the bounds: `{bounded_ty}: {trait_bounds}`");
+                    let hint_string = format!(
+                        "consider combining the bounds: `{}: {trait_bounds}`",
+                        snippet(cx, p.bounded_ty.span, "_"),
+                    );
                     span_lint_and_help(
                         cx,
                         TYPE_REPETITION_IN_BOUNDS,
diff --git a/clippy_utils/src/check_proc_macro.rs b/clippy_utils/src/check_proc_macro.rs
index 7f79b8f87dd..05b34986274 100644
--- a/clippy_utils/src/check_proc_macro.rs
+++ b/clippy_utils/src/check_proc_macro.rs
@@ -351,7 +351,8 @@ fn ty_search_pat(ty: &Ty<'_>) -> (Pat, Pat) {
         TyKind::Never => (Pat::Str("!"), Pat::Str("")),
         TyKind::Tup(..) => (Pat::Str("("), Pat::Str(")")),
         TyKind::OpaqueDef(..) => (Pat::Str("impl"), Pat::Str("")),
-        // NOTE: This is missing `TraitObject` and `Path` here. It always return true then.
+        TyKind::Path(qpath) => qpath_search_pat(&qpath),
+        // NOTE: This is missing `TraitObject`. It always return true then.
         _ => (Pat::Str(""), Pat::Str("")),
     }
 }
-- 
cgit 1.4.1-3-g733a5


From 7af77f74da28b51207cb35dd7d627109571eb678 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Wed, 7 Jun 2023 08:54:32 +0200
Subject: don't allow `as_slice` for now

---
 clippy_lints/src/vec.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/vec.rs b/clippy_lints/src/vec.rs
index ec21f3bb54f..467805d90ff 100644
--- a/clippy_lints/src/vec.rs
+++ b/clippy_lints/src/vec.rs
@@ -63,7 +63,7 @@ fn adjusts_to_slice(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
 /// that also exists on slices. If this returns true, it means that
 /// this expression does not actually require a `Vec` and could just work with an array.
 fn is_allowed_vec_method(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
-    const ALLOWED_METHOD_NAMES: &[&str] = &["len", "as_ptr", "as_slice", "is_empty"];
+    const ALLOWED_METHOD_NAMES: &[&str] = &["len", "as_ptr", "is_empty"];
 
     if let ExprKind::MethodCall(path, ..) = e.kind {
         ALLOWED_METHOD_NAMES.contains(&path.ident.name.as_str())
-- 
cgit 1.4.1-3-g733a5


From 3e8f53b51de543feca85af0d413376b18f598cb9 Mon Sep 17 00:00:00 2001
From: Renato Lochetti <renato.lochetti@gmail.com>
Date: Wed, 7 Jun 2023 08:35:39 +0100
Subject: Don't warn if there is a comment between else and curly bracket

---
 clippy_lints/src/formatting.rs         | 6 ++++++
 tests/ui/suspicious_else_formatting.rs | 7 +++++++
 2 files changed, 13 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/formatting.rs b/clippy_lints/src/formatting.rs
index 4762b354392..d03480c2108 100644
--- a/clippy_lints/src/formatting.rs
+++ b/clippy_lints/src/formatting.rs
@@ -236,6 +236,12 @@ fn check_else(cx: &EarlyContext<'_>, expr: &Expr) {
                 }
             }
 
+            // Don't warn if the only thing inside post_else_post_eol is a comment block.
+            let trimmed_post_else_post_eol = post_else_post_eol.trim();
+            if trimmed_post_else_post_eol.starts_with("/*") && trimmed_post_else_post_eol.ends_with("*/") {
+                return
+            }
+
             let else_desc = if is_if(else_) { "if" } else { "{..}" };
             span_lint_and_note(
                 cx,
diff --git a/tests/ui/suspicious_else_formatting.rs b/tests/ui/suspicious_else_formatting.rs
index 4823d909208..a96cc1b090c 100644
--- a/tests/ui/suspicious_else_formatting.rs
+++ b/tests/ui/suspicious_else_formatting.rs
@@ -108,6 +108,13 @@ fn main() {
     else
     {
     }
+
+    //#10273 This is fine. Don't warn
+    if foo() {
+    } else
+    /* whelp */
+    {
+    }
 }
 
 // #7650 - Don't lint. Proc-macro using bad spans for `if` expressions.
-- 
cgit 1.4.1-3-g733a5


From 2c7cf2cfa113e28e82854574eb1227d7c001d84c Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Wed, 7 Jun 2023 22:57:15 +0200
Subject: handle RangeInclusive function desugar

---
 clippy_lints/src/eta_reduction.rs | 10 +++++++-
 tests/ui/eta.fixed                |  6 +++++
 tests/ui/eta.rs                   |  6 +++++
 tests/ui/eta.stderr               | 50 ++++++++++++++++++++++-----------------
 4 files changed, 49 insertions(+), 23 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/eta_reduction.rs b/clippy_lints/src/eta_reduction.rs
index c919b4de65d..fcbf0898890 100644
--- a/clippy_lints/src/eta_reduction.rs
+++ b/clippy_lints/src/eta_reduction.rs
@@ -123,7 +123,14 @@ impl<'tcx> LateLintPass<'tcx> for EtaReduction {
             then {
                 span_lint_and_then(cx, REDUNDANT_CLOSURE, expr.span, "redundant closure", |diag| {
                     if let Some(mut snippet) = snippet_opt(cx, callee.span) {
-                        if let Some(fn_mut_id) = cx.tcx.lang_items().fn_mut_trait()
+                        if let Some(higher::Range {
+                            start: Some(_),
+                            end: Some(_),
+                            limits: rustc_ast::RangeLimits::Closed
+                        }) = higher::Range::hir(body.value) {
+                            // `|x,y| x..=y` becomes `|x, y| RangeInclusive::new(x, y)`
+                            snippet = "core::ops::RangeInclusive::new".to_owned();
+                        } else if let Some(fn_mut_id) = cx.tcx.lang_items().fn_mut_trait()
                             && let args = cx.tcx.erase_late_bound_regions(substs.as_closure().sig()).inputs()
                             && implements_trait(
                                    cx,
@@ -136,6 +143,7 @@ impl<'tcx> LateLintPass<'tcx> for EtaReduction {
                                 // Mutable closure is used after current expr; we cannot consume it.
                                 snippet = format!("&mut {snippet}");
                         }
+
                         diag.span_suggestion(
                             expr.span,
                             "replace the closure with the function itself",
diff --git a/tests/ui/eta.fixed b/tests/ui/eta.fixed
index b1baf462c0f..934deb66362 100644
--- a/tests/ui/eta.fixed
+++ b/tests/ui/eta.fixed
@@ -46,6 +46,12 @@ fn main() {
 
     // issue #7224
     let _: Option<Vec<u32>> = Some(0).map(|_| vec![]);
+
+    // issue #10684
+    fn test<T>(x: impl Fn(usize, usize) -> T) -> T {
+        x(1, 2)
+    }
+    test(core::ops::RangeInclusive::new);
 }
 
 trait TestTrait {
diff --git a/tests/ui/eta.rs b/tests/ui/eta.rs
index e113c3d6cd6..978aecd24b3 100644
--- a/tests/ui/eta.rs
+++ b/tests/ui/eta.rs
@@ -46,6 +46,12 @@ fn main() {
 
     // issue #7224
     let _: Option<Vec<u32>> = Some(0).map(|_| vec![]);
+
+    // issue #10684
+    fn test<T>(x: impl Fn(usize, usize) -> T) -> T {
+        x(1, 2)
+    }
+    test(|start, end| start..=end);
 }
 
 trait TestTrait {
diff --git a/tests/ui/eta.stderr b/tests/ui/eta.stderr
index a521fb86860..1f5db2d5129 100644
--- a/tests/ui/eta.stderr
+++ b/tests/ui/eta.stderr
@@ -31,7 +31,13 @@ LL |     let e = Some(1u8).map(|a| generic(a));
    |                           ^^^^^^^^^^^^^^ help: replace the closure with the function itself: `generic`
 
 error: redundant closure
-  --> $DIR/eta.rs:87:51
+  --> $DIR/eta.rs:54:10
+   |
+LL |     test(|start, end| start..=end);
+   |          ^^^^^^^^^^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `core::ops::RangeInclusive::new`
+
+error: redundant closure
+  --> $DIR/eta.rs:93:51
    |
 LL |     let e = Some(TestStruct { some_ref: &i }).map(|a| a.foo());
    |                                                   ^^^^^^^^^^^ help: replace the closure with the method itself: `TestStruct::foo`
@@ -39,124 +45,124 @@ LL |     let e = Some(TestStruct { some_ref: &i }).map(|a| a.foo());
    = note: `-D clippy::redundant-closure-for-method-calls` implied by `-D warnings`
 
 error: redundant closure
-  --> $DIR/eta.rs:88:51
+  --> $DIR/eta.rs:94:51
    |
 LL |     let e = Some(TestStruct { some_ref: &i }).map(|a| a.trait_foo());
    |                                                   ^^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `TestTrait::trait_foo`
 
 error: redundant closure
-  --> $DIR/eta.rs:90:42
+  --> $DIR/eta.rs:96:42
    |
 LL |     let e = Some(&mut vec![1, 2, 3]).map(|v| v.clear());
    |                                          ^^^^^^^^^^^^^ help: replace the closure with the method itself: `std::vec::Vec::clear`
 
 error: redundant closure
-  --> $DIR/eta.rs:94:29
+  --> $DIR/eta.rs:100:29
    |
 LL |     let e = Some("str").map(|s| s.to_string());
    |                             ^^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `std::string::ToString::to_string`
 
 error: redundant closure
-  --> $DIR/eta.rs:95:27
+  --> $DIR/eta.rs:101:27
    |
 LL |     let e = Some('a').map(|s| s.to_uppercase());
    |                           ^^^^^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `char::to_uppercase`
 
 error: redundant closure
-  --> $DIR/eta.rs:97:65
+  --> $DIR/eta.rs:103:65
    |
 LL |     let e: std::vec::Vec<char> = vec!['a', 'b', 'c'].iter().map(|c| c.to_ascii_uppercase()).collect();
    |                                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `char::to_ascii_uppercase`
 
 error: redundant closure
-  --> $DIR/eta.rs:160:22
+  --> $DIR/eta.rs:166:22
    |
 LL |     requires_fn_once(|| x());
    |                      ^^^^^^ help: replace the closure with the function itself: `x`
 
 error: redundant closure
-  --> $DIR/eta.rs:167:27
+  --> $DIR/eta.rs:173:27
    |
 LL |     let a = Some(1u8).map(|a| foo_ptr(a));
    |                           ^^^^^^^^^^^^^^ help: replace the closure with the function itself: `foo_ptr`
 
 error: redundant closure
-  --> $DIR/eta.rs:172:27
+  --> $DIR/eta.rs:178:27
    |
 LL |     let a = Some(1u8).map(|a| closure(a));
    |                           ^^^^^^^^^^^^^^ help: replace the closure with the function itself: `closure`
 
 error: redundant closure
-  --> $DIR/eta.rs:204:28
+  --> $DIR/eta.rs:210:28
    |
 LL |     x.into_iter().for_each(|x| add_to_res(x));
    |                            ^^^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `&mut add_to_res`
 
 error: redundant closure
-  --> $DIR/eta.rs:205:28
+  --> $DIR/eta.rs:211:28
    |
 LL |     y.into_iter().for_each(|x| add_to_res(x));
    |                            ^^^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `&mut add_to_res`
 
 error: redundant closure
-  --> $DIR/eta.rs:206:28
+  --> $DIR/eta.rs:212:28
    |
 LL |     z.into_iter().for_each(|x| add_to_res(x));
    |                            ^^^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `add_to_res`
 
 error: redundant closure
-  --> $DIR/eta.rs:213:21
+  --> $DIR/eta.rs:219:21
    |
 LL |         Some(1).map(|n| closure(n));
    |                     ^^^^^^^^^^^^^^ help: replace the closure with the function itself: `&mut closure`
 
 error: redundant closure
-  --> $DIR/eta.rs:217:21
+  --> $DIR/eta.rs:223:21
    |
 LL |         Some(1).map(|n| in_loop(n));
    |                     ^^^^^^^^^^^^^^ help: replace the closure with the function itself: `in_loop`
 
 error: redundant closure
-  --> $DIR/eta.rs:310:18
+  --> $DIR/eta.rs:316:18
    |
 LL |     takes_fn_mut(|| f());
    |                  ^^^^^^ help: replace the closure with the function itself: `&mut f`
 
 error: redundant closure
-  --> $DIR/eta.rs:313:19
+  --> $DIR/eta.rs:319:19
    |
 LL |     takes_fn_once(|| f());
    |                   ^^^^^^ help: replace the closure with the function itself: `&mut f`
 
 error: redundant closure
-  --> $DIR/eta.rs:317:26
+  --> $DIR/eta.rs:323:26
    |
 LL |     move || takes_fn_mut(|| f_used_once())
    |                          ^^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `&mut f_used_once`
 
 error: redundant closure
-  --> $DIR/eta.rs:329:19
+  --> $DIR/eta.rs:335:19
    |
 LL |     array_opt.map(|a| a.as_slice());
    |                   ^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `<[u8; 3]>::as_slice`
 
 error: redundant closure
-  --> $DIR/eta.rs:332:19
+  --> $DIR/eta.rs:338:19
    |
 LL |     slice_opt.map(|s| s.len());
    |                   ^^^^^^^^^^^ help: replace the closure with the method itself: `<[u8]>::len`
 
 error: redundant closure
-  --> $DIR/eta.rs:335:17
+  --> $DIR/eta.rs:341:17
    |
 LL |     ptr_opt.map(|p| p.is_null());
    |                 ^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `<*const usize>::is_null`
 
 error: redundant closure
-  --> $DIR/eta.rs:339:17
+  --> $DIR/eta.rs:345:17
    |
 LL |     dyn_opt.map(|d| d.method_on_dyn());
    |                 ^^^^^^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `<dyn TestTrait>::method_on_dyn`
 
-error: aborting due to 26 previous errors
+error: aborting due to 27 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 9ff34acf211c1b2aa7b4a282b2dd38927e137169 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Thu, 8 Jun 2023 00:34:23 +0200
Subject: actually don't lint for inclusive range

---
 clippy_lints/src/eta_reduction.rs | 16 ++++++++--------
 tests/ui/eta.fixed                |  2 +-
 tests/ui/eta.stderr               |  8 +-------
 3 files changed, 10 insertions(+), 16 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/eta_reduction.rs b/clippy_lints/src/eta_reduction.rs
index fcbf0898890..58e62d1f3d3 100644
--- a/clippy_lints/src/eta_reduction.rs
+++ b/clippy_lints/src/eta_reduction.rs
@@ -120,17 +120,17 @@ impl<'tcx> LateLintPass<'tcx> for EtaReduction {
             if !is_type_diagnostic_item(cx, callee_ty_unadjusted, sym::Arc);
             if !is_type_diagnostic_item(cx, callee_ty_unadjusted, sym::Rc);
             if let ty::Closure(_, substs) = *closure_ty.kind();
+            // Don't lint if this is an inclusive range expression.
+            // They desugar to a call to `RangeInclusiveNew` which would have odd suggestions. (#10684)
+            if !matches!(higher::Range::hir(body.value), Some(higher::Range {
+                start: Some(_),
+                end: Some(_),
+                limits: rustc_ast::RangeLimits::Closed
+            }));
             then {
                 span_lint_and_then(cx, REDUNDANT_CLOSURE, expr.span, "redundant closure", |diag| {
                     if let Some(mut snippet) = snippet_opt(cx, callee.span) {
-                        if let Some(higher::Range {
-                            start: Some(_),
-                            end: Some(_),
-                            limits: rustc_ast::RangeLimits::Closed
-                        }) = higher::Range::hir(body.value) {
-                            // `|x,y| x..=y` becomes `|x, y| RangeInclusive::new(x, y)`
-                            snippet = "core::ops::RangeInclusive::new".to_owned();
-                        } else if let Some(fn_mut_id) = cx.tcx.lang_items().fn_mut_trait()
+                        if let Some(fn_mut_id) = cx.tcx.lang_items().fn_mut_trait()
                             && let args = cx.tcx.erase_late_bound_regions(substs.as_closure().sig()).inputs()
                             && implements_trait(
                                    cx,
diff --git a/tests/ui/eta.fixed b/tests/ui/eta.fixed
index 934deb66362..31a94cb10e8 100644
--- a/tests/ui/eta.fixed
+++ b/tests/ui/eta.fixed
@@ -51,7 +51,7 @@ fn main() {
     fn test<T>(x: impl Fn(usize, usize) -> T) -> T {
         x(1, 2)
     }
-    test(core::ops::RangeInclusive::new);
+    test(|start, end| start..=end);
 }
 
 trait TestTrait {
diff --git a/tests/ui/eta.stderr b/tests/ui/eta.stderr
index 1f5db2d5129..19be5fc7389 100644
--- a/tests/ui/eta.stderr
+++ b/tests/ui/eta.stderr
@@ -30,12 +30,6 @@ error: redundant closure
 LL |     let e = Some(1u8).map(|a| generic(a));
    |                           ^^^^^^^^^^^^^^ help: replace the closure with the function itself: `generic`
 
-error: redundant closure
-  --> $DIR/eta.rs:54:10
-   |
-LL |     test(|start, end| start..=end);
-   |          ^^^^^^^^^^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `core::ops::RangeInclusive::new`
-
 error: redundant closure
   --> $DIR/eta.rs:93:51
    |
@@ -164,5 +158,5 @@ error: redundant closure
 LL |     dyn_opt.map(|d| d.method_on_dyn());
    |                 ^^^^^^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `<dyn TestTrait>::method_on_dyn`
 
-error: aborting due to 27 previous errors
+error: aborting due to 26 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 97c10075eca950c34958f2f32bf9956b3945ff42 Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Thu, 20 Apr 2023 01:14:50 -0500
Subject: add the `excessive_*` style lints

---
 CHANGELOG.md                                       |  2 +
 clippy_lints/src/declared_lints.rs                 |  2 +
 clippy_lints/src/excessive_width.rs                | 82 ++++++++++++++++++++++
 clippy_lints/src/lib.rs                            | 11 +++
 clippy_lints/src/utils/conf.rs                     | 12 ++++
 tests/ui-toml/excessive_width/clippy.toml          |  3 +
 tests/ui-toml/excessive_width/excessive_width.rs   | 26 +++++++
 .../ui-toml/excessive_width/excessive_width.stderr | 24 +++++++
 tests/ui/excessive_width.rs                        | 44 ++++++++++++
 tests/ui/excessive_width.stderr                    | 11 +++
 10 files changed, 217 insertions(+)
 create mode 100644 clippy_lints/src/excessive_width.rs
 create mode 100644 tests/ui-toml/excessive_width/clippy.toml
 create mode 100644 tests/ui-toml/excessive_width/excessive_width.rs
 create mode 100644 tests/ui-toml/excessive_width/excessive_width.stderr
 create mode 100644 tests/ui/excessive_width.rs
 create mode 100644 tests/ui/excessive_width.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index a65ac4d46de..76fd81a25c6 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4758,7 +4758,9 @@ Released 2018-09-13
 [`erasing_op`]: https://rust-lang.github.io/rust-clippy/master/index.html#erasing_op
 [`err_expect`]: https://rust-lang.github.io/rust-clippy/master/index.html#err_expect
 [`eval_order_dependence`]: https://rust-lang.github.io/rust-clippy/master/index.html#eval_order_dependence
+[`excessive_indentation`]: https://rust-lang.github.io/rust-clippy/master/index.html#excessive_indentation
 [`excessive_precision`]: https://rust-lang.github.io/rust-clippy/master/index.html#excessive_precision
+[`excessive_width`]: https://rust-lang.github.io/rust-clippy/master/index.html#excessive_width
 [`exhaustive_enums`]: https://rust-lang.github.io/rust-clippy/master/index.html#exhaustive_enums
 [`exhaustive_structs`]: https://rust-lang.github.io/rust-clippy/master/index.html#exhaustive_structs
 [`exit`]: https://rust-lang.github.io/rust-clippy/master/index.html#exit
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index d014534cee9..20911348690 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -159,6 +159,8 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::eta_reduction::REDUNDANT_CLOSURE_FOR_METHOD_CALLS_INFO,
     crate::excessive_bools::FN_PARAMS_EXCESSIVE_BOOLS_INFO,
     crate::excessive_bools::STRUCT_EXCESSIVE_BOOLS_INFO,
+    crate::excessive_width::EXCESSIVE_INDENTATION_INFO,
+    crate::excessive_width::EXCESSIVE_WIDTH_INFO,
     crate::exhaustive_items::EXHAUSTIVE_ENUMS_INFO,
     crate::exhaustive_items::EXHAUSTIVE_STRUCTS_INFO,
     crate::exit::EXIT_INFO,
diff --git a/clippy_lints/src/excessive_width.rs b/clippy_lints/src/excessive_width.rs
new file mode 100644
index 00000000000..84ae54f401e
--- /dev/null
+++ b/clippy_lints/src/excessive_width.rs
@@ -0,0 +1,82 @@
+use clippy_utils::diagnostics::span_lint_and_help;
+use rustc_hir::*;
+use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_middle::lint::in_external_macro;
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::Pos;
+
+// TODO: This still needs to be implemented.
+declare_clippy_lint! {
+    /// ### What it does
+    ///
+    /// Checks for lines which are indented beyond a certain threshold.
+    ///
+    /// ### Why is this bad?
+    ///
+    /// It can severely hinder readability. The default is very generous; if you
+    /// exceed this, it's a sign you should refactor.
+    ///
+    /// ### Example
+    /// TODO
+    /// Use instead:
+    /// TODO
+    #[clippy::version = "1.70.0"]
+    pub EXCESSIVE_INDENTATION,
+    style,
+    "check for lines intended beyond a certain threshold"
+}
+declare_clippy_lint! {
+    /// ### What it does
+    ///
+    /// Checks for lines which are longer than a certain threshold.
+    ///
+    /// ### Why is this bad?
+    ///
+    /// It can severely hinder readability. Almost always, running rustfmt will get this
+    /// below this threshold (or whatever you have set as max_width), but if it fails,
+    /// it's probably a sign you should refactor.
+    ///
+    /// ### Example
+    /// TODO
+    /// Use instead:
+    /// TODO
+    #[clippy::version = "1.70.0"]
+    pub EXCESSIVE_WIDTH,
+    style,
+    "check for lines longer than a certain threshold"
+}
+impl_lint_pass!(ExcessiveWidth => [EXCESSIVE_INDENTATION, EXCESSIVE_WIDTH]);
+
+#[derive(Clone, Copy)]
+pub struct ExcessiveWidth {
+    pub excessive_width_threshold: u64,
+    pub excessive_width_ignore_indentation: bool,
+    pub excessive_indentation_threshold: u64,
+}
+
+impl LateLintPass<'_> for ExcessiveWidth {
+    fn check_stmt(&mut self, cx: &LateContext<'_>, stmt: &Stmt<'_>) {
+        if in_external_macro(cx.sess(), stmt.span) {
+            return;
+        }
+
+        if let Ok(lines) = cx.sess().source_map().span_to_lines(stmt.span).map(|info| info.lines) {
+            for line in &lines {
+                // TODO: yeah, no.
+                if (line.end_col.to_usize()
+                    - line.start_col.to_usize() * self.excessive_width_ignore_indentation as usize)
+                    > self.excessive_width_threshold as usize
+                {
+                    span_lint_and_help(
+                        cx,
+                        EXCESSIVE_WIDTH,
+                        stmt.span,
+                        "this line is too long",
+                        None,
+                        "consider running rustfmt or refactoring this",
+                    );
+                }
+            }
+        }
+    }
+}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index d53c6de5451..8b08861bc1d 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -122,6 +122,7 @@ mod equatable_if_let;
 mod escape;
 mod eta_reduction;
 mod excessive_bools;
+mod excessive_width;
 mod exhaustive_items;
 mod exit;
 mod explicit_write;
@@ -1007,6 +1008,16 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(tests_outside_test_module::TestsOutsideTestModule));
     store.register_late_pass(|_| Box::new(manual_slice_size_calculation::ManualSliceSizeCalculation));
     store.register_early_pass(|| Box::new(suspicious_doc_comments::SuspiciousDocComments));
+    let excessive_width_threshold = conf.excessive_width_threshold;
+    let excessive_width_ignore_indentation = conf.excessive_width_ignore_indentation;
+    let excessive_indentation_threshold = conf.excessive_indentation_threshold;
+    store.register_late_pass(move |_| {
+        Box::new(excessive_width::ExcessiveWidth {
+            excessive_width_threshold,
+            excessive_width_ignore_indentation,
+            excessive_indentation_threshold,
+        })
+    });
     store.register_late_pass(|_| Box::new(items_after_test_module::ItemsAfterTestModule));
     store.register_early_pass(|| Box::new(ref_patterns::RefPatterns));
     store.register_late_pass(|_| Box::new(default_constructed_unit_structs::DefaultConstructedUnitStructs));
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 35f40830681..1bdb5e42418 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -305,6 +305,18 @@ define_Conf! {
     ///
     /// The maximum cognitive complexity a function can have
     (cognitive_complexity_threshold: u64 = 25),
+    /// Lint: EXCESSIVE_WIDTH.
+    ///
+    /// The maximum width a statement can have
+    (excessive_width_threshold: u64 = 100),
+    /// Lint: EXCESSIVE_WIDTH.
+    ///
+    /// Whether to ignore the line's indentation
+    (excessive_width_ignore_indentation: bool = true),
+    /// Lint: EXCESSIVE_INDENTATION.
+    ///
+    /// The maximum indentation a statement can have
+    (excessive_indentation_threshold: u64 = 10),
     /// DEPRECATED LINT: CYCLOMATIC_COMPLEXITY.
     ///
     /// Use the Cognitive Complexity lint instead.
diff --git a/tests/ui-toml/excessive_width/clippy.toml b/tests/ui-toml/excessive_width/clippy.toml
new file mode 100644
index 00000000000..1824c8a3127
--- /dev/null
+++ b/tests/ui-toml/excessive_width/clippy.toml
@@ -0,0 +1,3 @@
+excessive-width-threshold = 20
+excessive-width-ignore-indentation = false
+excessive-indentation-threshold = 3
diff --git a/tests/ui-toml/excessive_width/excessive_width.rs b/tests/ui-toml/excessive_width/excessive_width.rs
new file mode 100644
index 00000000000..261b937e72e
--- /dev/null
+++ b/tests/ui-toml/excessive_width/excessive_width.rs
@@ -0,0 +1,26 @@
+#![allow(unused)]
+#![allow(clippy::identity_op)]
+#![allow(clippy::no_effect)]
+#![warn(clippy::excessive_width)]
+
+static mut C: u32 = 2u32;
+
+#[rustfmt::skip]
+fn main() {
+    let x = 2 * unsafe { C };
+
+    {
+        {
+            // this too, even though it's only 15 characters!
+            ();
+        }
+    }
+
+    {
+        {
+            {
+                println!("this will now emit a warning, how neat!")
+            }
+        }
+    }
+}
diff --git a/tests/ui-toml/excessive_width/excessive_width.stderr b/tests/ui-toml/excessive_width/excessive_width.stderr
new file mode 100644
index 00000000000..00dce391be0
--- /dev/null
+++ b/tests/ui-toml/excessive_width/excessive_width.stderr
@@ -0,0 +1,24 @@
+error: this line is too long
+  --> $DIR/excessive_width.rs:10:5
+   |
+LL |     let x = 2 * unsafe { C };
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider running rustfmt or refactoring this
+   = note: `-D clippy::excessive-width` implied by `-D warnings`
+
+error: this line is too long
+  --> $DIR/excessive_width.rs:12:5
+   |
+LL | /     {
+LL | |         {
+LL | |             // this too, even though it's only 15 characters!
+LL | |             ();
+LL | |         }
+LL | |     }
+   | |_____^
+   |
+   = help: consider running rustfmt or refactoring this
+
+error: aborting due to 2 previous errors
+
diff --git a/tests/ui/excessive_width.rs b/tests/ui/excessive_width.rs
new file mode 100644
index 00000000000..218950f9684
--- /dev/null
+++ b/tests/ui/excessive_width.rs
@@ -0,0 +1,44 @@
+#![allow(unused)]
+#![allow(clippy::identity_op)]
+#![warn(clippy::excessive_width)]
+
+#[rustfmt::skip]
+fn main() {
+    let x = 1;
+
+    let really_long_binding_name_because_this_needs_to_be_over_90_characters_long = 1usize * 200 / 2 * 500 / 1;
+
+    {
+        {
+            {
+                {
+                    {
+                        {
+                            {
+                                {
+                                    {
+                                        {
+                                            {
+                                                {
+                                                    {
+                                                        {
+                                                            {
+                                                                {
+                                                                    println!("highly indented lines do not cause a warning (by default)!")
+                                                                }
+                                                            }
+                                                        }
+                                                    }
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/tests/ui/excessive_width.stderr b/tests/ui/excessive_width.stderr
new file mode 100644
index 00000000000..707a3796b56
--- /dev/null
+++ b/tests/ui/excessive_width.stderr
@@ -0,0 +1,11 @@
+error: this line is too long
+  --> $DIR/excessive_width.rs:9:5
+   |
+LL |     let really_long_binding_name_because_this_needs_to_be_over_90_characters_long = 1usize * 200 / 2 * 500 / 1;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider running rustfmt or refactoring this
+   = note: `-D clippy::excessive-width` implied by `-D warnings`
+
+error: aborting due to previous error
+
-- 
cgit 1.4.1-3-g733a5


From 4af3ac1cd8cf907b142c5cd813f1733289c29063 Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Thu, 20 Apr 2023 01:19:26 -0500
Subject: change it to nursery category

---
 clippy_lints/src/excessive_width.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/excessive_width.rs b/clippy_lints/src/excessive_width.rs
index 84ae54f401e..0e23b39a14e 100644
--- a/clippy_lints/src/excessive_width.rs
+++ b/clippy_lints/src/excessive_width.rs
@@ -22,7 +22,7 @@ declare_clippy_lint! {
     /// TODO
     #[clippy::version = "1.70.0"]
     pub EXCESSIVE_INDENTATION,
-    style,
+    nursery,
     "check for lines intended beyond a certain threshold"
 }
 declare_clippy_lint! {
@@ -42,7 +42,7 @@ declare_clippy_lint! {
     /// TODO
     #[clippy::version = "1.70.0"]
     pub EXCESSIVE_WIDTH,
-    style,
+    nursery,
     "check for lines longer than a certain threshold"
 }
 impl_lint_pass!(ExcessiveWidth => [EXCESSIVE_INDENTATION, EXCESSIVE_WIDTH]);
-- 
cgit 1.4.1-3-g733a5


From e68dbc3308397e68d672f9f70742af41897b06be Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Thu, 20 Apr 2023 08:03:25 -0500
Subject: add `excessive_nesting`

Close code block in example
---
 CHANGELOG.md                                       |   3 +-
 clippy_lints/src/declared_lints.rs                 |   3 +-
 clippy_lints/src/excessive_nesting.rs              | 325 +++++++++++++++++++
 clippy_lints/src/excessive_width.rs                |  82 -----
 clippy_lints/src/lib.rs                            |  14 +-
 clippy_lints/src/utils/conf.rs                     |  14 +-
 .../excessive_nesting/auxiliary/macro_rules.rs     |   7 +
 tests/ui-toml/excessive_nesting/clippy.toml        |   1 +
 .../ui-toml/excessive_nesting/excessive_nesting.rs | 191 +++++++++++
 .../excessive_nesting/excessive_nesting.stderr     | 358 +++++++++++++++++++++
 tests/ui-toml/excessive_width/clippy.toml          |   3 -
 tests/ui-toml/excessive_width/excessive_width.rs   |  26 --
 .../ui-toml/excessive_width/excessive_width.stderr |  24 --
 .../toml_unknown_key/conf_unknown_key.stderr       |   1 +
 tests/ui/auxiliary/macro_rules.rs                  |   1 -
 tests/ui/excessive_width.rs                        |  44 ---
 tests/ui/excessive_width.stderr                    |  11 -
 17 files changed, 893 insertions(+), 215 deletions(-)
 create mode 100644 clippy_lints/src/excessive_nesting.rs
 delete mode 100644 clippy_lints/src/excessive_width.rs
 create mode 100644 tests/ui-toml/excessive_nesting/auxiliary/macro_rules.rs
 create mode 100644 tests/ui-toml/excessive_nesting/clippy.toml
 create mode 100644 tests/ui-toml/excessive_nesting/excessive_nesting.rs
 create mode 100644 tests/ui-toml/excessive_nesting/excessive_nesting.stderr
 delete mode 100644 tests/ui-toml/excessive_width/clippy.toml
 delete mode 100644 tests/ui-toml/excessive_width/excessive_width.rs
 delete mode 100644 tests/ui-toml/excessive_width/excessive_width.stderr
 delete mode 100644 tests/ui/excessive_width.rs
 delete mode 100644 tests/ui/excessive_width.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 76fd81a25c6..69ac2c893d9 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4758,9 +4758,8 @@ Released 2018-09-13
 [`erasing_op`]: https://rust-lang.github.io/rust-clippy/master/index.html#erasing_op
 [`err_expect`]: https://rust-lang.github.io/rust-clippy/master/index.html#err_expect
 [`eval_order_dependence`]: https://rust-lang.github.io/rust-clippy/master/index.html#eval_order_dependence
-[`excessive_indentation`]: https://rust-lang.github.io/rust-clippy/master/index.html#excessive_indentation
+[`excessive_nesting`]: https://rust-lang.github.io/rust-clippy/master/index.html#excessive_nesting
 [`excessive_precision`]: https://rust-lang.github.io/rust-clippy/master/index.html#excessive_precision
-[`excessive_width`]: https://rust-lang.github.io/rust-clippy/master/index.html#excessive_width
 [`exhaustive_enums`]: https://rust-lang.github.io/rust-clippy/master/index.html#exhaustive_enums
 [`exhaustive_structs`]: https://rust-lang.github.io/rust-clippy/master/index.html#exhaustive_structs
 [`exit`]: https://rust-lang.github.io/rust-clippy/master/index.html#exit
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 20911348690..0c51996b625 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -159,8 +159,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::eta_reduction::REDUNDANT_CLOSURE_FOR_METHOD_CALLS_INFO,
     crate::excessive_bools::FN_PARAMS_EXCESSIVE_BOOLS_INFO,
     crate::excessive_bools::STRUCT_EXCESSIVE_BOOLS_INFO,
-    crate::excessive_width::EXCESSIVE_INDENTATION_INFO,
-    crate::excessive_width::EXCESSIVE_WIDTH_INFO,
+    crate::excessive_nesting::EXCESSIVE_NESTING_INFO,
     crate::exhaustive_items::EXHAUSTIVE_ENUMS_INFO,
     crate::exhaustive_items::EXHAUSTIVE_STRUCTS_INFO,
     crate::exit::EXIT_INFO,
diff --git a/clippy_lints/src/excessive_nesting.rs b/clippy_lints/src/excessive_nesting.rs
new file mode 100644
index 00000000000..a60e2442fa2
--- /dev/null
+++ b/clippy_lints/src/excessive_nesting.rs
@@ -0,0 +1,325 @@
+use clippy_utils::diagnostics::span_lint_and_help;
+use rustc_ast::{
+    node_id::NodeId,
+    ptr::P,
+    visit::{FnKind, Visitor},
+    Arm, AssocItemKind, Block, Expr, ExprKind, Inline, Item, ItemKind, Local, LocalKind, ModKind, ModSpans, Pat,
+    PatKind, Stmt, StmtKind,
+};
+use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
+use rustc_middle::lint::in_external_macro;
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::Span;
+use thin_vec::ThinVec;
+
+declare_clippy_lint! {
+    /// ### What it does
+    ///
+    /// Checks for blocks which are indented beyond a certain threshold.
+    ///
+    /// ### Why is this bad?
+    ///
+    /// It can severely hinder readability. The default is very generous; if you
+    /// exceed this, it's a sign you should refactor.
+    ///
+    /// ### Known issues
+    ///
+    /// Nested inline modules will all be linted, rather than just the outermost one
+    /// that applies. This makes the output a bit verbose.
+    ///
+    /// ### Example
+    /// An example clippy.toml configuration:
+    /// ```toml
+    /// # clippy.toml
+    /// excessive-nesting-threshold = 3
+    /// ```
+    /// lib.rs:
+    /// ```rust,ignore
+    /// pub mod a {
+    ///     pub struct X;
+    ///     impl X {
+    ///         pub fn run(&self) {
+    ///             if true {
+    ///                 // etc...
+    ///             }
+    ///         }
+    ///     }
+    /// }
+    /// Use instead:
+    /// a.rs:
+    /// ```rust,ignore
+    /// fn private_run(x: &X) {
+    ///     if true {
+    ///         // etc...
+    ///     }
+    /// }
+    ///
+    /// pub struct X;
+    /// impl X {
+    ///     pub fn run(&self) {
+    ///         private_run(self);
+    ///     }
+    /// }
+    /// ```
+    #[clippy::version = "1.70.0"]
+    pub EXCESSIVE_NESTING,
+    restriction,
+    "checks for blocks nested beyond a certain threshold"
+}
+impl_lint_pass!(ExcessiveNesting => [EXCESSIVE_NESTING]);
+
+#[derive(Clone, Copy)]
+pub struct ExcessiveNesting {
+    pub excessive_nesting_threshold: u64,
+}
+
+impl EarlyLintPass for ExcessiveNesting {
+    fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {
+        let conf = self;
+        NestingVisitor {
+            conf,
+            cx,
+            nest_level: 0,
+        }
+        .visit_item(item);
+    }
+}
+
+struct NestingVisitor<'conf, 'cx> {
+    conf: &'conf ExcessiveNesting,
+    cx: &'cx EarlyContext<'cx>,
+    nest_level: u64,
+}
+
+impl<'conf, 'cx> Visitor<'_> for NestingVisitor<'conf, 'cx> {
+    fn visit_local(&mut self, local: &Local) {
+        self.visit_pat(&local.pat);
+
+        match &local.kind {
+            LocalKind::Init(expr) => self.visit_expr(expr),
+            LocalKind::InitElse(expr, block) => {
+                self.visit_expr(expr);
+                self.visit_block(block);
+            },
+            LocalKind::Decl => (),
+        }
+    }
+
+    fn visit_block(&mut self, block: &Block) {
+        self.nest_level += 1;
+
+        if !check_indent(self, block.span) {
+            for stmt in &block.stmts {
+                self.visit_stmt(stmt);
+            }
+        }
+
+        self.nest_level -= 1;
+    }
+
+    fn visit_stmt(&mut self, stmt: &Stmt) {
+        match &stmt.kind {
+            StmtKind::Local(local) => self.visit_local(local),
+            StmtKind::Item(item) => self.visit_item(item),
+            StmtKind::Expr(expr) | StmtKind::Semi(expr) => self.visit_expr(expr),
+            _ => (),
+        }
+    }
+
+    fn visit_arm(&mut self, arm: &Arm) {
+        self.visit_pat(&arm.pat);
+        if let Some(expr) = &arm.guard {
+            self.visit_expr(expr);
+        }
+        self.visit_expr(&arm.body);
+    }
+
+    // TODO: Is this necessary?
+    fn visit_pat(&mut self, pat: &Pat) {
+        match &pat.kind {
+            PatKind::Box(pat) | PatKind::Ref(pat, ..) | PatKind::Paren(pat) => self.visit_pat(pat),
+            PatKind::Lit(expr) => self.visit_expr(expr),
+            PatKind::Range(start, end, ..) => {
+                if let Some(expr) = start {
+                    self.visit_expr(expr);
+                }
+                if let Some(expr) = end {
+                    self.visit_expr(expr);
+                }
+            },
+            PatKind::Ident(.., pat) if let Some(pat) = pat => {
+                self.visit_pat(pat);
+            },
+            PatKind::Struct(.., pat_fields, _) => {
+                for pat_field in pat_fields {
+                    self.visit_pat(&pat_field.pat);
+                }
+            },
+            PatKind::TupleStruct(.., pats) | PatKind::Or(pats) | PatKind::Tuple(pats) | PatKind::Slice(pats) => {
+                for pat in pats {
+                    self.visit_pat(pat);
+                }
+            },
+            _ => (),
+        }
+    }
+
+    fn visit_expr(&mut self, expr: &Expr) {
+        // This is a mess, but really all it does is extract every expression from every applicable variant
+        // of ExprKind until it finds a Block.
+        match &expr.kind {
+            ExprKind::ConstBlock(anon_const) => self.visit_expr(&anon_const.value),
+            ExprKind::Call(.., args) => {
+                for expr in args {
+                    self.visit_expr(expr);
+                }
+            },
+            ExprKind::MethodCall(method_call) => {
+                for expr in &method_call.args {
+                    self.visit_expr(expr);
+                }
+            },
+            ExprKind::Tup(exprs) | ExprKind::Array(exprs) => {
+                for expr in exprs {
+                    self.visit_expr(expr);
+                }
+            },
+            ExprKind::Binary(.., left, right)
+            | ExprKind::Assign(left, right, ..)
+            | ExprKind::AssignOp(.., left, right)
+            | ExprKind::Index(left, right) => {
+                self.visit_expr(left);
+                self.visit_expr(right);
+            },
+            ExprKind::Let(pat, expr, ..) => {
+                self.visit_pat(pat);
+                self.visit_expr(expr);
+            },
+            ExprKind::Unary(.., expr)
+            | ExprKind::Await(expr)
+            | ExprKind::Field(expr, ..)
+            | ExprKind::AddrOf(.., expr)
+            | ExprKind::Try(expr) => {
+                self.visit_expr(expr);
+            },
+            ExprKind::Repeat(expr, anon_const) => {
+                self.visit_expr(expr);
+                self.visit_expr(&anon_const.value);
+            },
+            ExprKind::If(expr, block, else_expr) => {
+                self.visit_expr(expr);
+                self.visit_block(block);
+
+                if let Some(expr) = else_expr {
+                    self.visit_expr(expr);
+                }
+            },
+            ExprKind::While(expr, block, ..) => {
+                self.visit_expr(expr);
+                self.visit_block(block);
+            },
+            ExprKind::ForLoop(pat, expr, block, ..) => {
+                self.visit_pat(pat);
+                self.visit_expr(expr);
+                self.visit_block(block);
+            },
+            ExprKind::Loop(block, ..)
+            | ExprKind::Block(block, ..)
+            | ExprKind::Async(.., block)
+            | ExprKind::TryBlock(block) => {
+                self.visit_block(block);
+            },
+            ExprKind::Match(expr, arms) => {
+                self.visit_expr(expr);
+
+                for arm in arms {
+                    self.visit_arm(arm);
+                }
+            },
+            ExprKind::Closure(closure) => self.visit_expr(&closure.body),
+            ExprKind::Range(start, end, ..) => {
+                if let Some(expr) = start {
+                    self.visit_expr(expr);
+                }
+                if let Some(expr) = end {
+                    self.visit_expr(expr);
+                }
+            },
+            ExprKind::Break(.., expr) | ExprKind::Ret(expr) | ExprKind::Yield(expr) | ExprKind::Yeet(expr) => {
+                if let Some(expr) = expr {
+                    self.visit_expr(expr);
+                }
+            },
+            ExprKind::Struct(struct_expr) => {
+                for field in &struct_expr.fields {
+                    self.visit_expr(&field.expr);
+                }
+            },
+            _ => (),
+        }
+    }
+
+    fn visit_fn(&mut self, fk: FnKind<'_>, _: Span, _: NodeId) {
+        match fk {
+            FnKind::Fn(.., block) if let Some(block) = block => self.visit_block(block),
+            FnKind::Closure(.., expr) => self.visit_expr(expr),
+            // :/
+            FnKind::Fn(..) => (),
+        }
+    }
+
+    fn visit_item(&mut self, item: &Item) {
+        match &item.kind {
+            ItemKind::Static(static_item) if let Some(expr) = static_item.expr.as_ref() => self.visit_expr(expr),
+            ItemKind::Const(const_item) if let Some(expr) = const_item.expr.as_ref() => self.visit_expr(expr),
+            ItemKind::Fn(fk) if let Some(block) = fk.body.as_ref() => self.visit_block(block),
+            ItemKind::Mod(.., mod_kind)
+                if let ModKind::Loaded(items, Inline::Yes, ModSpans { inner_span, ..}) = mod_kind =>
+            {
+                self.nest_level += 1;
+
+                check_indent(self, *inner_span);
+
+                self.nest_level -= 1;
+            }
+            ItemKind::Trait(trit) => check_trait_and_impl(self, item, &trit.items),
+            ItemKind::Impl(imp) => check_trait_and_impl(self, item, &imp.items),
+            _ => (),
+        }
+    }
+}
+
+fn check_trait_and_impl(visitor: &mut NestingVisitor<'_, '_>, item: &Item, items: &ThinVec<P<Item<AssocItemKind>>>) {
+    visitor.nest_level += 1;
+
+    if !check_indent(visitor, item.span) {
+        for item in items {
+            match &item.kind {
+                AssocItemKind::Const(const_item) if let Some(expr) = const_item.expr.as_ref() => {
+                    visitor.visit_expr(expr);
+                },
+                AssocItemKind::Fn(fk) if let Some(block) = fk.body.as_ref() => visitor.visit_block(block),
+                _ => (),
+            }
+        }
+    }
+
+    visitor.nest_level -= 1;
+}
+
+fn check_indent(visitor: &NestingVisitor<'_, '_>, span: Span) -> bool {
+    if visitor.nest_level > visitor.conf.excessive_nesting_threshold && !in_external_macro(visitor.cx.sess(), span) {
+        span_lint_and_help(
+            visitor.cx,
+            EXCESSIVE_NESTING,
+            span,
+            "this block is too nested",
+            None,
+            "try refactoring your code, extraction is often both easier to read and less nested",
+        );
+
+        return true;
+    }
+
+    false
+}
diff --git a/clippy_lints/src/excessive_width.rs b/clippy_lints/src/excessive_width.rs
deleted file mode 100644
index 0e23b39a14e..00000000000
--- a/clippy_lints/src/excessive_width.rs
+++ /dev/null
@@ -1,82 +0,0 @@
-use clippy_utils::diagnostics::span_lint_and_help;
-use rustc_hir::*;
-use rustc_lint::{LateContext, LateLintPass, LintContext};
-use rustc_middle::lint::in_external_macro;
-use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::Pos;
-
-// TODO: This still needs to be implemented.
-declare_clippy_lint! {
-    /// ### What it does
-    ///
-    /// Checks for lines which are indented beyond a certain threshold.
-    ///
-    /// ### Why is this bad?
-    ///
-    /// It can severely hinder readability. The default is very generous; if you
-    /// exceed this, it's a sign you should refactor.
-    ///
-    /// ### Example
-    /// TODO
-    /// Use instead:
-    /// TODO
-    #[clippy::version = "1.70.0"]
-    pub EXCESSIVE_INDENTATION,
-    nursery,
-    "check for lines intended beyond a certain threshold"
-}
-declare_clippy_lint! {
-    /// ### What it does
-    ///
-    /// Checks for lines which are longer than a certain threshold.
-    ///
-    /// ### Why is this bad?
-    ///
-    /// It can severely hinder readability. Almost always, running rustfmt will get this
-    /// below this threshold (or whatever you have set as max_width), but if it fails,
-    /// it's probably a sign you should refactor.
-    ///
-    /// ### Example
-    /// TODO
-    /// Use instead:
-    /// TODO
-    #[clippy::version = "1.70.0"]
-    pub EXCESSIVE_WIDTH,
-    nursery,
-    "check for lines longer than a certain threshold"
-}
-impl_lint_pass!(ExcessiveWidth => [EXCESSIVE_INDENTATION, EXCESSIVE_WIDTH]);
-
-#[derive(Clone, Copy)]
-pub struct ExcessiveWidth {
-    pub excessive_width_threshold: u64,
-    pub excessive_width_ignore_indentation: bool,
-    pub excessive_indentation_threshold: u64,
-}
-
-impl LateLintPass<'_> for ExcessiveWidth {
-    fn check_stmt(&mut self, cx: &LateContext<'_>, stmt: &Stmt<'_>) {
-        if in_external_macro(cx.sess(), stmt.span) {
-            return;
-        }
-
-        if let Ok(lines) = cx.sess().source_map().span_to_lines(stmt.span).map(|info| info.lines) {
-            for line in &lines {
-                // TODO: yeah, no.
-                if (line.end_col.to_usize()
-                    - line.start_col.to_usize() * self.excessive_width_ignore_indentation as usize)
-                    > self.excessive_width_threshold as usize
-                {
-                    span_lint_and_help(
-                        cx,
-                        EXCESSIVE_WIDTH,
-                        stmt.span,
-                        "this line is too long",
-                        None,
-                        "consider running rustfmt or refactoring this",
-                    );
-                }
-            }
-        }
-    }
-}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 8b08861bc1d..202b4709ad4 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -122,7 +122,7 @@ mod equatable_if_let;
 mod escape;
 mod eta_reduction;
 mod excessive_bools;
-mod excessive_width;
+mod excessive_nesting;
 mod exhaustive_items;
 mod exit;
 mod explicit_write;
@@ -1008,14 +1008,10 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(tests_outside_test_module::TestsOutsideTestModule));
     store.register_late_pass(|_| Box::new(manual_slice_size_calculation::ManualSliceSizeCalculation));
     store.register_early_pass(|| Box::new(suspicious_doc_comments::SuspiciousDocComments));
-    let excessive_width_threshold = conf.excessive_width_threshold;
-    let excessive_width_ignore_indentation = conf.excessive_width_ignore_indentation;
-    let excessive_indentation_threshold = conf.excessive_indentation_threshold;
-    store.register_late_pass(move |_| {
-        Box::new(excessive_width::ExcessiveWidth {
-            excessive_width_threshold,
-            excessive_width_ignore_indentation,
-            excessive_indentation_threshold,
+    let excessive_nesting_threshold = conf.excessive_nesting_threshold;
+    store.register_early_pass(move || {
+        Box::new(excessive_nesting::ExcessiveNesting {
+            excessive_nesting_threshold,
         })
     });
     store.register_late_pass(|_| Box::new(items_after_test_module::ItemsAfterTestModule));
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 1bdb5e42418..cf0da266dc9 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -305,18 +305,10 @@ define_Conf! {
     ///
     /// The maximum cognitive complexity a function can have
     (cognitive_complexity_threshold: u64 = 25),
-    /// Lint: EXCESSIVE_WIDTH.
+    /// Lint: EXCESSIVE_NESTING.
     ///
-    /// The maximum width a statement can have
-    (excessive_width_threshold: u64 = 100),
-    /// Lint: EXCESSIVE_WIDTH.
-    ///
-    /// Whether to ignore the line's indentation
-    (excessive_width_ignore_indentation: bool = true),
-    /// Lint: EXCESSIVE_INDENTATION.
-    ///
-    /// The maximum indentation a statement can have
-    (excessive_indentation_threshold: u64 = 10),
+    /// The maximum amount of nesting a block can reside in
+    (excessive_nesting_threshold: u64 = 10),
     /// DEPRECATED LINT: CYCLOMATIC_COMPLEXITY.
     ///
     /// Use the Cognitive Complexity lint instead.
diff --git a/tests/ui-toml/excessive_nesting/auxiliary/macro_rules.rs b/tests/ui-toml/excessive_nesting/auxiliary/macro_rules.rs
new file mode 100644
index 00000000000..86663db68f2
--- /dev/null
+++ b/tests/ui-toml/excessive_nesting/auxiliary/macro_rules.rs
@@ -0,0 +1,7 @@
+#[rustfmt::skip]
+#[macro_export]
+macro_rules! excessive_nesting {
+    () => {{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{
+        println!("hi!!")
+    }}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}
+}
diff --git a/tests/ui-toml/excessive_nesting/clippy.toml b/tests/ui-toml/excessive_nesting/clippy.toml
new file mode 100644
index 00000000000..10be2751a86
--- /dev/null
+++ b/tests/ui-toml/excessive_nesting/clippy.toml
@@ -0,0 +1 @@
+excessive-nesting-threshold = 3
diff --git a/tests/ui-toml/excessive_nesting/excessive_nesting.rs b/tests/ui-toml/excessive_nesting/excessive_nesting.rs
new file mode 100644
index 00000000000..66fc8166314
--- /dev/null
+++ b/tests/ui-toml/excessive_nesting/excessive_nesting.rs
@@ -0,0 +1,191 @@
+//@aux-build:macro_rules.rs
+#![rustfmt::skip]
+#![feature(custom_inner_attributes)]
+#![allow(unused)]
+#![allow(clippy::let_and_return)]
+#![allow(clippy::redundant_closure_call)]
+#![allow(clippy::no_effect)]
+#![allow(clippy::unnecessary_operation)]
+#![allow(clippy::never_loop)]
+#![warn(clippy::excessive_nesting)]
+#![allow(clippy::collapsible_if)]
+
+#[macro_use]
+extern crate macro_rules;
+
+static X: u32 = {
+    let x = {
+        let y = {
+            let z = {
+                let w = { 3 };
+                w
+            };
+            z
+        };
+        y
+    };
+    x
+};
+
+macro_rules! xx {
+    () => {{
+        {
+            {
+                {
+                    {
+                        {
+                            {
+                                {
+                                    {
+                                        {
+                                            {
+                                                println!("ehe");
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }};
+}
+
+struct A;
+
+impl A {
+    pub fn a(&self, v: u32) {
+        struct B;
+
+        impl B {
+            pub fn b() {
+                struct C;
+
+                impl C {
+                    pub fn c() {}
+                }
+            }
+        }
+    }
+}
+
+struct D { d: u32 }
+
+trait Lol {
+    fn lmao() {
+        fn bb() {
+            fn cc() {
+                let x = { 1 }; // not a warning
+            }
+
+            let x = { 1 }; // warning
+        }
+    }
+}
+
+use a::{b::{c::{d::{e::{f::{}}}}}}; // should not lint
+
+pub mod a {
+    pub mod b {
+        pub mod c {
+            pub mod d {
+                pub mod e {
+                    pub mod f {}
+                }
+            }
+        }
+    }
+}
+
+fn a_but_not(v: u32) {}
+
+fn main() {
+    let a = A;
+
+    a_but_not({{{{{{{{0}}}}}}}});
+    a.a({{{{{{{{{0}}}}}}}}});
+    (0, {{{{{{{1}}}}}}});
+
+    if true {
+        if true {
+            if true {
+                if true {
+                    if true {
+
+                    }
+                }
+            }
+        }
+    }
+
+    let y = (|| {
+        let x = (|| {
+            let y = (|| {
+                let z = (|| {
+                    let w = { 3 };
+                    w
+                })();
+                z
+            })();
+            y
+        })();
+        x
+    })();
+
+    excessive_nesting!(); // ensure this isn't linted in external macros
+    xx!();
+    let boo = true;
+    !{boo as u32 + !{boo as u32 + !{boo as u32}}};
+
+    let mut y = 1;
+    y += {{{{{5}}}}};
+    let z = y + {{{{{{{{{5}}}}}}}}};
+    [0, {{{{{{{{{{0}}}}}}}}}}];
+    let mut xx = [0; {{{{{{{{100}}}}}}}}];
+    xx[{{{{{{{{{{{{{{{{{{{{{{{{3}}}}}}}}}}}}}}}}}}}}}}}}];
+    &mut {{{{{{{{{{y}}}}}}}}}};
+
+    for i in {{{{xx}}}} {{{{{{{{}}}}}}}}
+
+    while let Some(i) = {{{{{{Some(1)}}}}}} {{{{{{{}}}}}}}
+    
+    while {{{{{{{{true}}}}}}}} {{{{{{{{{}}}}}}}}}
+
+    let d = D { d: {{{{{{{{{{{{{{{{{{{{{{{3}}}}}}}}}}}}}}}}}}}}}}} };
+
+    {{{{1;}}}}..{{{{{{3}}}}}};
+    {{{{1;}}}}..={{{{{{{{{{{{{{{{{{{{{{{{{{6}}}}}}}}}}}}}}}}}}}}}}}}}};
+    ..{{{{{{{5}}}}}}};
+    ..={{{{{3}}}}};
+    {{{{{1;}}}}}..;
+
+    loop { break {{{{1}}}} };
+    loop {{{{{{}}}}}}
+
+    match {{{{{{true}}}}}} {
+        true => {{{{}}}},
+        false => {{{{}}}},
+    }
+
+    {
+        {
+            {
+                {
+                    println!("warning! :)");
+                }
+            }
+        }
+    }
+}
+
+async fn b() -> u32 {
+    async fn c() -> u32 {{{{{{{0}}}}}}}
+
+    c().await
+}
+
+async fn a() {
+    {{{{b().await}}}};
+}
diff --git a/tests/ui-toml/excessive_nesting/excessive_nesting.stderr b/tests/ui-toml/excessive_nesting/excessive_nesting.stderr
new file mode 100644
index 00000000000..0bd43da21e2
--- /dev/null
+++ b/tests/ui-toml/excessive_nesting/excessive_nesting.stderr
@@ -0,0 +1,358 @@
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:19:21
+   |
+LL |               let z = {
+   |  _____________________^
+LL | |                 let w = { 3 };
+LL | |                 w
+LL | |             };
+   | |_____________^
+   |
+   = help: try refactoring your code, extraction is often both easier to read and less nested
+   = note: `-D clippy::excessive-nesting` implied by `-D warnings`
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:63:24
+   |
+LL |               pub fn b() {
+   |  ________________________^
+LL | |                 struct C;
+LL | |
+LL | |                 impl C {
+LL | |                     pub fn c() {}
+LL | |                 }
+LL | |             }
+   | |_____________^
+   |
+   = help: try refactoring your code, extraction is often both easier to read and less nested
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:67:32
+   |
+LL |                     pub fn c() {}
+   |                                ^^
+   |
+   = help: try refactoring your code, extraction is often both easier to read and less nested
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:79:21
+   |
+LL |               fn cc() {
+   |  _____________________^
+LL | |                 let x = { 1 }; // not a warning
+LL | |             }
+   | |_____________^
+   |
+   = help: try refactoring your code, extraction is often both easier to read and less nested
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:83:21
+   |
+LL |             let x = { 1 }; // warning
+   |                     ^^^^^
+   |
+   = help: try refactoring your code, extraction is often both easier to read and less nested
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:107:17
+   |
+LL |     a_but_not({{{{{{{{0}}}}}}}});
+   |                 ^^^^^^^^^^^^^
+   |
+   = help: try refactoring your code, extraction is often both easier to read and less nested
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:108:11
+   |
+LL |     a.a({{{{{{{{{0}}}}}}}}});
+   |           ^^^^^^^^^^^^^^^
+   |
+   = help: try refactoring your code, extraction is often both easier to read and less nested
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:109:11
+   |
+LL |     (0, {{{{{{{1}}}}}}});
+   |           ^^^^^^^^^^^
+   |
+   = help: try refactoring your code, extraction is often both easier to read and less nested
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:113:21
+   |
+LL |               if true {
+   |  _____________________^
+LL | |                 if true {
+LL | |                     if true {
+LL | |
+LL | |                     }
+LL | |                 }
+LL | |             }
+   | |_____________^
+   |
+   = help: try refactoring your code, extraction is often both easier to read and less nested
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:33:13
+   |
+LL | /             {
+LL | |                 {
+LL | |                     {
+LL | |                         {
+...  |
+LL | |                 }
+LL | |             }
+   | |_____________^
+...
+LL |       xx!();
+   |       ----- in this macro invocation
+   |
+   = help: try refactoring your code, extraction is often both easier to read and less nested
+   = note: this error originates in the macro `xx` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:140:36
+   |
+LL |     !{boo as u32 + !{boo as u32 + !{boo as u32}}};
+   |                                    ^^^^^^^^^^^^
+   |
+   = help: try refactoring your code, extraction is often both easier to read and less nested
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:143:12
+   |
+LL |     y += {{{{{5}}}}};
+   |            ^^^^^^^
+   |
+   = help: try refactoring your code, extraction is often both easier to read and less nested
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:144:19
+   |
+LL |     let z = y + {{{{{{{{{5}}}}}}}}};
+   |                   ^^^^^^^^^^^^^^^
+   |
+   = help: try refactoring your code, extraction is often both easier to read and less nested
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:145:11
+   |
+LL |     [0, {{{{{{{{{{0}}}}}}}}}}];
+   |           ^^^^^^^^^^^^^^^^^
+   |
+   = help: try refactoring your code, extraction is often both easier to read and less nested
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:146:24
+   |
+LL |     let mut xx = [0; {{{{{{{{100}}}}}}}}];
+   |                        ^^^^^^^^^^^^^^^
+   |
+   = help: try refactoring your code, extraction is often both easier to read and less nested
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:147:10
+   |
+LL |     xx[{{{{{{{{{{{{{{{{{{{{{{{{3}}}}}}}}}}}}}}}}}}}}}}}}];
+   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: try refactoring your code, extraction is often both easier to read and less nested
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:148:12
+   |
+LL |     &mut {{{{{{{{{{y}}}}}}}}}};
+   |            ^^^^^^^^^^^^^^^^^
+   |
+   = help: try refactoring your code, extraction is often both easier to read and less nested
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:150:16
+   |
+LL |     for i in {{{{xx}}}} {{{{{{{{}}}}}}}}
+   |                ^^^^^^
+   |
+   = help: try refactoring your code, extraction is often both easier to read and less nested
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:150:27
+   |
+LL |     for i in {{{{xx}}}} {{{{{{{{}}}}}}}}
+   |                           ^^^^^^^^^^^^
+   |
+   = help: try refactoring your code, extraction is often both easier to read and less nested
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:152:27
+   |
+LL |     while let Some(i) = {{{{{{Some(1)}}}}}} {{{{{{{}}}}}}}
+   |                           ^^^^^^^^^^^^^^^
+   |
+   = help: try refactoring your code, extraction is often both easier to read and less nested
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:152:47
+   |
+LL |     while let Some(i) = {{{{{{Some(1)}}}}}} {{{{{{{}}}}}}}
+   |                                               ^^^^^^^^^^
+   |
+   = help: try refactoring your code, extraction is often both easier to read and less nested
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:154:13
+   |
+LL |     while {{{{{{{{true}}}}}}}} {{{{{{{{{}}}}}}}}}
+   |             ^^^^^^^^^^^^^^^^
+   |
+   = help: try refactoring your code, extraction is often both easier to read and less nested
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:154:34
+   |
+LL |     while {{{{{{{{true}}}}}}}} {{{{{{{{{}}}}}}}}}
+   |                                  ^^^^^^^^^^^^^^
+   |
+   = help: try refactoring your code, extraction is often both easier to read and less nested
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:156:22
+   |
+LL |     let d = D { d: {{{{{{{{{{{{{{{{{{{{{{{3}}}}}}}}}}}}}}}}}}}}}}} };
+   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: try refactoring your code, extraction is often both easier to read and less nested
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:158:7
+   |
+LL |     {{{{1;}}}}..{{{{{{3}}}}}};
+   |       ^^^^^^
+   |
+   = help: try refactoring your code, extraction is often both easier to read and less nested
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:158:19
+   |
+LL |     {{{{1;}}}}..{{{{{{3}}}}}};
+   |                   ^^^^^^^^^
+   |
+   = help: try refactoring your code, extraction is often both easier to read and less nested
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:159:7
+   |
+LL |     {{{{1;}}}}..={{{{{{{{{{{{{{{{{{{{{{{{{{6}}}}}}}}}}}}}}}}}}}}}}}}}};
+   |       ^^^^^^
+   |
+   = help: try refactoring your code, extraction is often both easier to read and less nested
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:159:20
+   |
+LL |     {{{{1;}}}}..={{{{{{{{{{{{{{{{{{{{{{{{{{6}}}}}}}}}}}}}}}}}}}}}}}}}};
+   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: try refactoring your code, extraction is often both easier to read and less nested
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:160:9
+   |
+LL |     ..{{{{{{{5}}}}}}};
+   |         ^^^^^^^^^^^
+   |
+   = help: try refactoring your code, extraction is often both easier to read and less nested
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:161:10
+   |
+LL |     ..={{{{{3}}}}};
+   |          ^^^^^^^
+   |
+   = help: try refactoring your code, extraction is often both easier to read and less nested
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:162:7
+   |
+LL |     {{{{{1;}}}}}..;
+   |       ^^^^^^^^
+   |
+   = help: try refactoring your code, extraction is often both easier to read and less nested
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:164:19
+   |
+LL |     loop { break {{{{1}}}} };
+   |                   ^^^^^^^
+   |
+   = help: try refactoring your code, extraction is often both easier to read and less nested
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:165:12
+   |
+LL |     loop {{{{{{}}}}}}
+   |            ^^^^^^^^
+   |
+   = help: try refactoring your code, extraction is often both easier to read and less nested
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:167:13
+   |
+LL |     match {{{{{{true}}}}}} {
+   |             ^^^^^^^^^^^^
+   |
+   = help: try refactoring your code, extraction is often both easier to read and less nested
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:168:19
+   |
+LL |         true => {{{{}}}},
+   |                   ^^^^
+   |
+   = help: try refactoring your code, extraction is often both easier to read and less nested
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:169:20
+   |
+LL |         false => {{{{}}}},
+   |                    ^^^^
+   |
+   = help: try refactoring your code, extraction is often both easier to read and less nested
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:174:13
+   |
+LL | /             {
+LL | |                 {
+LL | |                     println!("warning! :)");
+LL | |                 }
+LL | |             }
+   | |_____________^
+   |
+   = help: try refactoring your code, extraction is often both easier to read and less nested
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:184:27
+   |
+LL |     async fn c() -> u32 {{{{{{{0}}}}}}}
+   |                           ^^^^^^^^^^^
+   |
+   = help: try refactoring your code, extraction is often both easier to read and less nested
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:184:28
+   |
+LL |     async fn c() -> u32 {{{{{{{0}}}}}}}
+   |                            ^^^^^^^^^
+   |
+   = help: try refactoring your code, extraction is often both easier to read and less nested
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:190:7
+   |
+LL |     {{{{b().await}}}};
+   |       ^^^^^^^^^^^^^
+   |
+   = help: try refactoring your code, extraction is often both easier to read and less nested
+
+error: aborting due to 40 previous errors
+
diff --git a/tests/ui-toml/excessive_width/clippy.toml b/tests/ui-toml/excessive_width/clippy.toml
deleted file mode 100644
index 1824c8a3127..00000000000
--- a/tests/ui-toml/excessive_width/clippy.toml
+++ /dev/null
@@ -1,3 +0,0 @@
-excessive-width-threshold = 20
-excessive-width-ignore-indentation = false
-excessive-indentation-threshold = 3
diff --git a/tests/ui-toml/excessive_width/excessive_width.rs b/tests/ui-toml/excessive_width/excessive_width.rs
deleted file mode 100644
index 261b937e72e..00000000000
--- a/tests/ui-toml/excessive_width/excessive_width.rs
+++ /dev/null
@@ -1,26 +0,0 @@
-#![allow(unused)]
-#![allow(clippy::identity_op)]
-#![allow(clippy::no_effect)]
-#![warn(clippy::excessive_width)]
-
-static mut C: u32 = 2u32;
-
-#[rustfmt::skip]
-fn main() {
-    let x = 2 * unsafe { C };
-
-    {
-        {
-            // this too, even though it's only 15 characters!
-            ();
-        }
-    }
-
-    {
-        {
-            {
-                println!("this will now emit a warning, how neat!")
-            }
-        }
-    }
-}
diff --git a/tests/ui-toml/excessive_width/excessive_width.stderr b/tests/ui-toml/excessive_width/excessive_width.stderr
deleted file mode 100644
index 00dce391be0..00000000000
--- a/tests/ui-toml/excessive_width/excessive_width.stderr
+++ /dev/null
@@ -1,24 +0,0 @@
-error: this line is too long
-  --> $DIR/excessive_width.rs:10:5
-   |
-LL |     let x = 2 * unsafe { C };
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: consider running rustfmt or refactoring this
-   = note: `-D clippy::excessive-width` implied by `-D warnings`
-
-error: this line is too long
-  --> $DIR/excessive_width.rs:12:5
-   |
-LL | /     {
-LL | |         {
-LL | |             // this too, even though it's only 15 characters!
-LL | |             ();
-LL | |         }
-LL | |     }
-   | |_____^
-   |
-   = help: consider running rustfmt or refactoring this
-
-error: aborting due to 2 previous errors
-
diff --git a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
index b6038f031f3..28b6e7aa824 100644
--- a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
+++ b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
@@ -24,6 +24,7 @@ error: error reading Clippy's configuration file: unknown field `foobar`, expect
            enforced-import-renames
            enum-variant-name-threshold
            enum-variant-size-threshold
+           excessive-nesting-threshold
            future-size-threshold
            ignore-interior-mutability
            large-error-threshold
diff --git a/tests/ui/auxiliary/macro_rules.rs b/tests/ui/auxiliary/macro_rules.rs
index e5bb906663c..d9a1e76c077 100644
--- a/tests/ui/auxiliary/macro_rules.rs
+++ b/tests/ui/auxiliary/macro_rules.rs
@@ -1,7 +1,6 @@
 #![allow(dead_code)]
 
 //! Used to test that certain lints don't trigger in imported external macros
-
 #[macro_export]
 macro_rules! try_err {
     () => {
diff --git a/tests/ui/excessive_width.rs b/tests/ui/excessive_width.rs
deleted file mode 100644
index 218950f9684..00000000000
--- a/tests/ui/excessive_width.rs
+++ /dev/null
@@ -1,44 +0,0 @@
-#![allow(unused)]
-#![allow(clippy::identity_op)]
-#![warn(clippy::excessive_width)]
-
-#[rustfmt::skip]
-fn main() {
-    let x = 1;
-
-    let really_long_binding_name_because_this_needs_to_be_over_90_characters_long = 1usize * 200 / 2 * 500 / 1;
-
-    {
-        {
-            {
-                {
-                    {
-                        {
-                            {
-                                {
-                                    {
-                                        {
-                                            {
-                                                {
-                                                    {
-                                                        {
-                                                            {
-                                                                {
-                                                                    println!("highly indented lines do not cause a warning (by default)!")
-                                                                }
-                                                            }
-                                                        }
-                                                    }
-                                                }
-                                            }
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-}
diff --git a/tests/ui/excessive_width.stderr b/tests/ui/excessive_width.stderr
deleted file mode 100644
index 707a3796b56..00000000000
--- a/tests/ui/excessive_width.stderr
+++ /dev/null
@@ -1,11 +0,0 @@
-error: this line is too long
-  --> $DIR/excessive_width.rs:9:5
-   |
-LL |     let really_long_binding_name_because_this_needs_to_be_over_90_characters_long = 1usize * 200 / 2 * 500 / 1;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: consider running rustfmt or refactoring this
-   = note: `-D clippy::excessive-width` implied by `-D warnings`
-
-error: aborting due to previous error
-
-- 
cgit 1.4.1-3-g733a5


From a9da61b1153edd8a8b49226ffd433e0c6a402e38 Mon Sep 17 00:00:00 2001
From: Catherine <114838443+Centri3@users.noreply.github.com>
Date: Fri, 21 Apr 2023 10:59:36 -0500
Subject: couple more notes

---
 clippy_lints/src/excessive_nesting.rs | 4 ++++
 1 file changed, 4 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/excessive_nesting.rs b/clippy_lints/src/excessive_nesting.rs
index a60e2442fa2..604448d2e9c 100644
--- a/clippy_lints/src/excessive_nesting.rs
+++ b/clippy_lints/src/excessive_nesting.rs
@@ -106,6 +106,8 @@ impl<'conf, 'cx> Visitor<'_> for NestingVisitor<'conf, 'cx> {
     }
 
     fn visit_block(&mut self, block: &Block) {
+        // TODO: Can we use some RAII guard instead? Borrow checker seems to hate that
+        // idea but it would be a lot cleaner.
         self.nest_level += 1;
 
         if !check_indent(self, block.span) {
@@ -167,6 +169,8 @@ impl<'conf, 'cx> Visitor<'_> for NestingVisitor<'conf, 'cx> {
     fn visit_expr(&mut self, expr: &Expr) {
         // This is a mess, but really all it does is extract every expression from every applicable variant
         // of ExprKind until it finds a Block.
+        // TODO: clippy_utils has the two functions for_each_expr and for_each_expr_with_closures, can those
+        // be used here or are they not applicable for this case?
         match &expr.kind {
             ExprKind::ConstBlock(anon_const) => self.visit_expr(&anon_const.value),
             ExprKind::Call(.., args) => {
-- 
cgit 1.4.1-3-g733a5


From 88143ac295ba0656b78af8f9413e4074529b42d9 Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Fri, 28 Apr 2023 14:22:24 -0500
Subject: decided against reinventing the wheel

---
 book/src/lint_configuration.md                     |  10 +
 clippy_lints/src/excessive_nesting.rs              | 267 +++------------------
 .../ui-toml/excessive_nesting/excessive_nesting.rs |   7 +-
 .../excessive_nesting/excessive_nesting.stderr     | 177 +++++++-------
 4 files changed, 145 insertions(+), 316 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/book/src/lint_configuration.md b/book/src/lint_configuration.md
index 4c888b63793..4fa6b81c002 100644
--- a/book/src/lint_configuration.md
+++ b/book/src/lint_configuration.md
@@ -158,6 +158,16 @@ The maximum cognitive complexity a function can have
 * [`cognitive_complexity`](https://rust-lang.github.io/rust-clippy/master/index.html#cognitive_complexity)
 
 
+## `excessive-nesting-threshold`
+The maximum amount of nesting a block can reside in
+
+**Default Value:** `10` (`u64`)
+
+---
+**Affected lints:**
+* [`excessive_nesting`](https://rust-lang.github.io/rust-clippy/master/index.html#excessive_nesting)
+
+
 ## `disallowed-names`
 The list of disallowed names to lint about. NB: `bar` is not here since it has legitimate uses. The value
 `".."` can be used as part of the list to indicate, that the configured values should be appended to the
diff --git a/clippy_lints/src/excessive_nesting.rs b/clippy_lints/src/excessive_nesting.rs
index 604448d2e9c..a133bdc2edf 100644
--- a/clippy_lints/src/excessive_nesting.rs
+++ b/clippy_lints/src/excessive_nesting.rs
@@ -1,16 +1,12 @@
 use clippy_utils::diagnostics::span_lint_and_help;
 use rustc_ast::{
-    node_id::NodeId,
-    ptr::P,
-    visit::{FnKind, Visitor},
-    Arm, AssocItemKind, Block, Expr, ExprKind, Inline, Item, ItemKind, Local, LocalKind, ModKind, ModSpans, Pat,
-    PatKind, Stmt, StmtKind,
+    visit::{walk_block, walk_item, Visitor},
+    Block, Crate, Inline, Item, ItemKind, ModKind,
 };
 use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::Span;
-use thin_vec::ThinVec;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -22,11 +18,6 @@ declare_clippy_lint! {
     /// It can severely hinder readability. The default is very generous; if you
     /// exceed this, it's a sign you should refactor.
     ///
-    /// ### Known issues
-    ///
-    /// Nested inline modules will all be linted, rather than just the outermost one
-    /// that applies. This makes the output a bit verbose.
-    ///
     /// ### Example
     /// An example clippy.toml configuration:
     /// ```toml
@@ -74,14 +65,17 @@ pub struct ExcessiveNesting {
 }
 
 impl EarlyLintPass for ExcessiveNesting {
-    fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {
+    fn check_crate(&mut self, cx: &EarlyContext<'_>, krate: &Crate) {
         let conf = self;
-        NestingVisitor {
+        let mut visitor = NestingVisitor {
             conf,
             cx,
             nest_level: 0,
+        };
+
+        for item in &krate.items {
+            visitor.visit_item(item);
         }
-        .visit_item(item);
     }
 }
 
@@ -91,239 +85,52 @@ struct NestingVisitor<'conf, 'cx> {
     nest_level: u64,
 }
 
-impl<'conf, 'cx> Visitor<'_> for NestingVisitor<'conf, 'cx> {
-    fn visit_local(&mut self, local: &Local) {
-        self.visit_pat(&local.pat);
-
-        match &local.kind {
-            LocalKind::Init(expr) => self.visit_expr(expr),
-            LocalKind::InitElse(expr, block) => {
-                self.visit_expr(expr);
-                self.visit_block(block);
-            },
-            LocalKind::Decl => (),
+impl NestingVisitor<'_, '_> {
+    fn check_indent(&self, span: Span) -> bool {
+        if self.nest_level > self.conf.excessive_nesting_threshold && !in_external_macro(self.cx.sess(), span) {
+            span_lint_and_help(
+                self.cx,
+                EXCESSIVE_NESTING,
+                span,
+                "this block is too nested",
+                None,
+                "try refactoring your code to minimize nesting",
+            );
+
+            return true;
         }
+
+        false
     }
+}
 
+impl<'conf, 'cx> Visitor<'_> for NestingVisitor<'conf, 'cx> {
     fn visit_block(&mut self, block: &Block) {
-        // TODO: Can we use some RAII guard instead? Borrow checker seems to hate that
-        // idea but it would be a lot cleaner.
         self.nest_level += 1;
 
-        if !check_indent(self, block.span) {
-            for stmt in &block.stmts {
-                self.visit_stmt(stmt);
-            }
+        if !self.check_indent(block.span) {
+            walk_block(self, block);
         }
 
         self.nest_level -= 1;
     }
 
-    fn visit_stmt(&mut self, stmt: &Stmt) {
-        match &stmt.kind {
-            StmtKind::Local(local) => self.visit_local(local),
-            StmtKind::Item(item) => self.visit_item(item),
-            StmtKind::Expr(expr) | StmtKind::Semi(expr) => self.visit_expr(expr),
-            _ => (),
-        }
-    }
-
-    fn visit_arm(&mut self, arm: &Arm) {
-        self.visit_pat(&arm.pat);
-        if let Some(expr) = &arm.guard {
-            self.visit_expr(expr);
-        }
-        self.visit_expr(&arm.body);
-    }
-
-    // TODO: Is this necessary?
-    fn visit_pat(&mut self, pat: &Pat) {
-        match &pat.kind {
-            PatKind::Box(pat) | PatKind::Ref(pat, ..) | PatKind::Paren(pat) => self.visit_pat(pat),
-            PatKind::Lit(expr) => self.visit_expr(expr),
-            PatKind::Range(start, end, ..) => {
-                if let Some(expr) = start {
-                    self.visit_expr(expr);
-                }
-                if let Some(expr) = end {
-                    self.visit_expr(expr);
-                }
-            },
-            PatKind::Ident(.., pat) if let Some(pat) = pat => {
-                self.visit_pat(pat);
-            },
-            PatKind::Struct(.., pat_fields, _) => {
-                for pat_field in pat_fields {
-                    self.visit_pat(&pat_field.pat);
-                }
-            },
-            PatKind::TupleStruct(.., pats) | PatKind::Or(pats) | PatKind::Tuple(pats) | PatKind::Slice(pats) => {
-                for pat in pats {
-                    self.visit_pat(pat);
-                }
-            },
-            _ => (),
-        }
-    }
-
-    fn visit_expr(&mut self, expr: &Expr) {
-        // This is a mess, but really all it does is extract every expression from every applicable variant
-        // of ExprKind until it finds a Block.
-        // TODO: clippy_utils has the two functions for_each_expr and for_each_expr_with_closures, can those
-        // be used here or are they not applicable for this case?
-        match &expr.kind {
-            ExprKind::ConstBlock(anon_const) => self.visit_expr(&anon_const.value),
-            ExprKind::Call(.., args) => {
-                for expr in args {
-                    self.visit_expr(expr);
-                }
-            },
-            ExprKind::MethodCall(method_call) => {
-                for expr in &method_call.args {
-                    self.visit_expr(expr);
-                }
-            },
-            ExprKind::Tup(exprs) | ExprKind::Array(exprs) => {
-                for expr in exprs {
-                    self.visit_expr(expr);
-                }
-            },
-            ExprKind::Binary(.., left, right)
-            | ExprKind::Assign(left, right, ..)
-            | ExprKind::AssignOp(.., left, right)
-            | ExprKind::Index(left, right) => {
-                self.visit_expr(left);
-                self.visit_expr(right);
-            },
-            ExprKind::Let(pat, expr, ..) => {
-                self.visit_pat(pat);
-                self.visit_expr(expr);
-            },
-            ExprKind::Unary(.., expr)
-            | ExprKind::Await(expr)
-            | ExprKind::Field(expr, ..)
-            | ExprKind::AddrOf(.., expr)
-            | ExprKind::Try(expr) => {
-                self.visit_expr(expr);
-            },
-            ExprKind::Repeat(expr, anon_const) => {
-                self.visit_expr(expr);
-                self.visit_expr(&anon_const.value);
-            },
-            ExprKind::If(expr, block, else_expr) => {
-                self.visit_expr(expr);
-                self.visit_block(block);
-
-                if let Some(expr) = else_expr {
-                    self.visit_expr(expr);
-                }
-            },
-            ExprKind::While(expr, block, ..) => {
-                self.visit_expr(expr);
-                self.visit_block(block);
-            },
-            ExprKind::ForLoop(pat, expr, block, ..) => {
-                self.visit_pat(pat);
-                self.visit_expr(expr);
-                self.visit_block(block);
-            },
-            ExprKind::Loop(block, ..)
-            | ExprKind::Block(block, ..)
-            | ExprKind::Async(.., block)
-            | ExprKind::TryBlock(block) => {
-                self.visit_block(block);
-            },
-            ExprKind::Match(expr, arms) => {
-                self.visit_expr(expr);
-
-                for arm in arms {
-                    self.visit_arm(arm);
-                }
-            },
-            ExprKind::Closure(closure) => self.visit_expr(&closure.body),
-            ExprKind::Range(start, end, ..) => {
-                if let Some(expr) = start {
-                    self.visit_expr(expr);
-                }
-                if let Some(expr) = end {
-                    self.visit_expr(expr);
-                }
-            },
-            ExprKind::Break(.., expr) | ExprKind::Ret(expr) | ExprKind::Yield(expr) | ExprKind::Yeet(expr) => {
-                if let Some(expr) = expr {
-                    self.visit_expr(expr);
-                }
-            },
-            ExprKind::Struct(struct_expr) => {
-                for field in &struct_expr.fields {
-                    self.visit_expr(&field.expr);
-                }
-            },
-            _ => (),
-        }
-    }
-
-    fn visit_fn(&mut self, fk: FnKind<'_>, _: Span, _: NodeId) {
-        match fk {
-            FnKind::Fn(.., block) if let Some(block) = block => self.visit_block(block),
-            FnKind::Closure(.., expr) => self.visit_expr(expr),
-            // :/
-            FnKind::Fn(..) => (),
-        }
-    }
-
     fn visit_item(&mut self, item: &Item) {
         match &item.kind {
-            ItemKind::Static(static_item) if let Some(expr) = static_item.expr.as_ref() => self.visit_expr(expr),
-            ItemKind::Const(const_item) if let Some(expr) = const_item.expr.as_ref() => self.visit_expr(expr),
-            ItemKind::Fn(fk) if let Some(block) = fk.body.as_ref() => self.visit_block(block),
-            ItemKind::Mod(.., mod_kind)
-                if let ModKind::Loaded(items, Inline::Yes, ModSpans { inner_span, ..}) = mod_kind =>
-            {
+            ItemKind::Trait(_) | ItemKind::Impl(_) | ItemKind::Mod(.., ModKind::Loaded(_, Inline::Yes, _)) => {
                 self.nest_level += 1;
 
-                check_indent(self, *inner_span);
+                if !self.check_indent(item.span) {
+                    walk_item(self, item);
+                }
 
                 self.nest_level -= 1;
-            }
-            ItemKind::Trait(trit) => check_trait_and_impl(self, item, &trit.items),
-            ItemKind::Impl(imp) => check_trait_and_impl(self, item, &imp.items),
-            _ => (),
-        }
-    }
-}
-
-fn check_trait_and_impl(visitor: &mut NestingVisitor<'_, '_>, item: &Item, items: &ThinVec<P<Item<AssocItemKind>>>) {
-    visitor.nest_level += 1;
-
-    if !check_indent(visitor, item.span) {
-        for item in items {
-            match &item.kind {
-                AssocItemKind::Const(const_item) if let Some(expr) = const_item.expr.as_ref() => {
-                    visitor.visit_expr(expr);
-                },
-                AssocItemKind::Fn(fk) if let Some(block) = fk.body.as_ref() => visitor.visit_block(block),
-                _ => (),
-            }
+            },
+            // Mod: Don't visit non-inline modules
+            // ForeignMod: I don't think this is necessary, but just incase let's not take any chances (don't want to
+            // cause any false positives)
+            ItemKind::Mod(..) | ItemKind::ForeignMod(..) => {},
+            _ => walk_item(self, item),
         }
     }
-
-    visitor.nest_level -= 1;
-}
-
-fn check_indent(visitor: &NestingVisitor<'_, '_>, span: Span) -> bool {
-    if visitor.nest_level > visitor.conf.excessive_nesting_threshold && !in_external_macro(visitor.cx.sess(), span) {
-        span_lint_and_help(
-            visitor.cx,
-            EXCESSIVE_NESTING,
-            span,
-            "this block is too nested",
-            None,
-            "try refactoring your code, extraction is often both easier to read and less nested",
-        );
-
-        return true;
-    }
-
-    false
 }
diff --git a/tests/ui-toml/excessive_nesting/excessive_nesting.rs b/tests/ui-toml/excessive_nesting/excessive_nesting.rs
index 66fc8166314..62cf5125816 100644
--- a/tests/ui-toml/excessive_nesting/excessive_nesting.rs
+++ b/tests/ui-toml/excessive_nesting/excessive_nesting.rs
@@ -77,7 +77,7 @@ trait Lol {
     fn lmao() {
         fn bb() {
             fn cc() {
-                let x = { 1 }; // not a warning
+                let x = { 1 }; // not a warning, but cc is
             }
 
             let x = { 1 }; // warning
@@ -93,8 +93,8 @@ pub mod a {
             pub mod d {
                 pub mod e {
                     pub mod f {}
-                }
-            }
+                } // not here
+            } // only warning should be here
         }
     }
 }
@@ -139,6 +139,7 @@ fn main() {
     let boo = true;
     !{boo as u32 + !{boo as u32 + !{boo as u32}}};
 
+    // this is a mess, but that's intentional
     let mut y = 1;
     y += {{{{{5}}}}};
     let z = y + {{{{{{{{{5}}}}}}}}};
diff --git a/tests/ui-toml/excessive_nesting/excessive_nesting.stderr b/tests/ui-toml/excessive_nesting/excessive_nesting.stderr
index 0bd43da21e2..c98c6fefe01 100644
--- a/tests/ui-toml/excessive_nesting/excessive_nesting.stderr
+++ b/tests/ui-toml/excessive_nesting/excessive_nesting.stderr
@@ -8,7 +8,7 @@ LL | |                 w
 LL | |             };
    | |_____________^
    |
-   = help: try refactoring your code, extraction is often both easier to read and less nested
+   = help: try refactoring your code to minimize nesting
    = note: `-D clippy::excessive-nesting` implied by `-D warnings`
 
 error: this block is too nested
@@ -24,26 +24,18 @@ LL | |                 }
 LL | |             }
    | |_____________^
    |
-   = help: try refactoring your code, extraction is often both easier to read and less nested
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:67:32
-   |
-LL |                     pub fn c() {}
-   |                                ^^
-   |
-   = help: try refactoring your code, extraction is often both easier to read and less nested
+   = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
   --> $DIR/excessive_nesting.rs:79:21
    |
 LL |               fn cc() {
    |  _____________________^
-LL | |                 let x = { 1 }; // not a warning
+LL | |                 let x = { 1 }; // not a warning, but cc is
 LL | |             }
    | |_____________^
    |
-   = help: try refactoring your code, extraction is often both easier to read and less nested
+   = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
   --> $DIR/excessive_nesting.rs:83:21
@@ -51,7 +43,19 @@ error: this block is too nested
 LL |             let x = { 1 }; // warning
    |                     ^^^^^
    |
-   = help: try refactoring your code, extraction is often both easier to read and less nested
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:93:13
+   |
+LL | /             pub mod d {
+LL | |                 pub mod e {
+LL | |                     pub mod f {}
+LL | |                 } // not here
+LL | |             } // only warning should be here
+   | |_____________^
+   |
+   = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
   --> $DIR/excessive_nesting.rs:107:17
@@ -59,7 +63,7 @@ error: this block is too nested
 LL |     a_but_not({{{{{{{{0}}}}}}}});
    |                 ^^^^^^^^^^^^^
    |
-   = help: try refactoring your code, extraction is often both easier to read and less nested
+   = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
   --> $DIR/excessive_nesting.rs:108:11
@@ -67,7 +71,7 @@ error: this block is too nested
 LL |     a.a({{{{{{{{{0}}}}}}}}});
    |           ^^^^^^^^^^^^^^^
    |
-   = help: try refactoring your code, extraction is often both easier to read and less nested
+   = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
   --> $DIR/excessive_nesting.rs:109:11
@@ -75,7 +79,7 @@ error: this block is too nested
 LL |     (0, {{{{{{{1}}}}}}});
    |           ^^^^^^^^^^^
    |
-   = help: try refactoring your code, extraction is often both easier to read and less nested
+   = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
   --> $DIR/excessive_nesting.rs:113:21
@@ -90,7 +94,22 @@ LL | |                 }
 LL | |             }
    | |_____________^
    |
-   = help: try refactoring your code, extraction is often both easier to read and less nested
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:125:25
+   |
+LL |               let y = (|| {
+   |  _________________________^
+LL | |                 let z = (|| {
+LL | |                     let w = { 3 };
+LL | |                     w
+LL | |                 })();
+LL | |                 z
+LL | |             })();
+   | |_____________^
+   |
+   = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
   --> $DIR/excessive_nesting.rs:33:13
@@ -107,7 +126,7 @@ LL | |             }
 LL |       xx!();
    |       ----- in this macro invocation
    |
-   = help: try refactoring your code, extraction is often both easier to read and less nested
+   = help: try refactoring your code to minimize nesting
    = note: this error originates in the macro `xx` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: this block is too nested
@@ -116,210 +135,210 @@ error: this block is too nested
 LL |     !{boo as u32 + !{boo as u32 + !{boo as u32}}};
    |                                    ^^^^^^^^^^^^
    |
-   = help: try refactoring your code, extraction is often both easier to read and less nested
+   = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:143:12
+  --> $DIR/excessive_nesting.rs:144:12
    |
 LL |     y += {{{{{5}}}}};
    |            ^^^^^^^
    |
-   = help: try refactoring your code, extraction is often both easier to read and less nested
+   = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:144:19
+  --> $DIR/excessive_nesting.rs:145:19
    |
 LL |     let z = y + {{{{{{{{{5}}}}}}}}};
    |                   ^^^^^^^^^^^^^^^
    |
-   = help: try refactoring your code, extraction is often both easier to read and less nested
+   = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:145:11
+  --> $DIR/excessive_nesting.rs:146:11
    |
 LL |     [0, {{{{{{{{{{0}}}}}}}}}}];
    |           ^^^^^^^^^^^^^^^^^
    |
-   = help: try refactoring your code, extraction is often both easier to read and less nested
+   = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:146:24
+  --> $DIR/excessive_nesting.rs:147:24
    |
 LL |     let mut xx = [0; {{{{{{{{100}}}}}}}}];
    |                        ^^^^^^^^^^^^^^^
    |
-   = help: try refactoring your code, extraction is often both easier to read and less nested
+   = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:147:10
+  --> $DIR/excessive_nesting.rs:148:10
    |
 LL |     xx[{{{{{{{{{{{{{{{{{{{{{{{{3}}}}}}}}}}}}}}}}}}}}}}}}];
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: try refactoring your code, extraction is often both easier to read and less nested
+   = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:148:12
+  --> $DIR/excessive_nesting.rs:149:12
    |
 LL |     &mut {{{{{{{{{{y}}}}}}}}}};
    |            ^^^^^^^^^^^^^^^^^
    |
-   = help: try refactoring your code, extraction is often both easier to read and less nested
+   = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:150:16
+  --> $DIR/excessive_nesting.rs:151:16
    |
 LL |     for i in {{{{xx}}}} {{{{{{{{}}}}}}}}
    |                ^^^^^^
    |
-   = help: try refactoring your code, extraction is often both easier to read and less nested
+   = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:150:27
+  --> $DIR/excessive_nesting.rs:151:27
    |
 LL |     for i in {{{{xx}}}} {{{{{{{{}}}}}}}}
    |                           ^^^^^^^^^^^^
    |
-   = help: try refactoring your code, extraction is often both easier to read and less nested
+   = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:152:27
+  --> $DIR/excessive_nesting.rs:153:27
    |
 LL |     while let Some(i) = {{{{{{Some(1)}}}}}} {{{{{{{}}}}}}}
    |                           ^^^^^^^^^^^^^^^
    |
-   = help: try refactoring your code, extraction is often both easier to read and less nested
+   = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:152:47
+  --> $DIR/excessive_nesting.rs:153:47
    |
 LL |     while let Some(i) = {{{{{{Some(1)}}}}}} {{{{{{{}}}}}}}
    |                                               ^^^^^^^^^^
    |
-   = help: try refactoring your code, extraction is often both easier to read and less nested
+   = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:154:13
+  --> $DIR/excessive_nesting.rs:155:13
    |
 LL |     while {{{{{{{{true}}}}}}}} {{{{{{{{{}}}}}}}}}
    |             ^^^^^^^^^^^^^^^^
    |
-   = help: try refactoring your code, extraction is often both easier to read and less nested
+   = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:154:34
+  --> $DIR/excessive_nesting.rs:155:34
    |
 LL |     while {{{{{{{{true}}}}}}}} {{{{{{{{{}}}}}}}}}
    |                                  ^^^^^^^^^^^^^^
    |
-   = help: try refactoring your code, extraction is often both easier to read and less nested
+   = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:156:22
+  --> $DIR/excessive_nesting.rs:157:22
    |
 LL |     let d = D { d: {{{{{{{{{{{{{{{{{{{{{{{3}}}}}}}}}}}}}}}}}}}}}}} };
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: try refactoring your code, extraction is often both easier to read and less nested
+   = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:158:7
+  --> $DIR/excessive_nesting.rs:159:7
    |
 LL |     {{{{1;}}}}..{{{{{{3}}}}}};
    |       ^^^^^^
    |
-   = help: try refactoring your code, extraction is often both easier to read and less nested
+   = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:158:19
+  --> $DIR/excessive_nesting.rs:159:19
    |
 LL |     {{{{1;}}}}..{{{{{{3}}}}}};
    |                   ^^^^^^^^^
    |
-   = help: try refactoring your code, extraction is often both easier to read and less nested
+   = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:159:7
+  --> $DIR/excessive_nesting.rs:160:7
    |
 LL |     {{{{1;}}}}..={{{{{{{{{{{{{{{{{{{{{{{{{{6}}}}}}}}}}}}}}}}}}}}}}}}}};
    |       ^^^^^^
    |
-   = help: try refactoring your code, extraction is often both easier to read and less nested
+   = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:159:20
+  --> $DIR/excessive_nesting.rs:160:20
    |
 LL |     {{{{1;}}}}..={{{{{{{{{{{{{{{{{{{{{{{{{{6}}}}}}}}}}}}}}}}}}}}}}}}}};
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: try refactoring your code, extraction is often both easier to read and less nested
+   = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:160:9
+  --> $DIR/excessive_nesting.rs:161:9
    |
 LL |     ..{{{{{{{5}}}}}}};
    |         ^^^^^^^^^^^
    |
-   = help: try refactoring your code, extraction is often both easier to read and less nested
+   = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:161:10
+  --> $DIR/excessive_nesting.rs:162:10
    |
 LL |     ..={{{{{3}}}}};
    |          ^^^^^^^
    |
-   = help: try refactoring your code, extraction is often both easier to read and less nested
+   = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:162:7
+  --> $DIR/excessive_nesting.rs:163:7
    |
 LL |     {{{{{1;}}}}}..;
    |       ^^^^^^^^
    |
-   = help: try refactoring your code, extraction is often both easier to read and less nested
+   = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:164:19
+  --> $DIR/excessive_nesting.rs:165:19
    |
 LL |     loop { break {{{{1}}}} };
    |                   ^^^^^^^
    |
-   = help: try refactoring your code, extraction is often both easier to read and less nested
+   = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:165:12
+  --> $DIR/excessive_nesting.rs:166:12
    |
 LL |     loop {{{{{{}}}}}}
    |            ^^^^^^^^
    |
-   = help: try refactoring your code, extraction is often both easier to read and less nested
+   = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:167:13
+  --> $DIR/excessive_nesting.rs:168:13
    |
 LL |     match {{{{{{true}}}}}} {
    |             ^^^^^^^^^^^^
    |
-   = help: try refactoring your code, extraction is often both easier to read and less nested
+   = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:168:19
+  --> $DIR/excessive_nesting.rs:169:19
    |
 LL |         true => {{{{}}}},
    |                   ^^^^
    |
-   = help: try refactoring your code, extraction is often both easier to read and less nested
+   = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:169:20
+  --> $DIR/excessive_nesting.rs:170:20
    |
 LL |         false => {{{{}}}},
    |                    ^^^^
    |
-   = help: try refactoring your code, extraction is often both easier to read and less nested
+   = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:174:13
+  --> $DIR/excessive_nesting.rs:175:13
    |
 LL | /             {
 LL | |                 {
@@ -328,31 +347,23 @@ LL | |                 }
 LL | |             }
    | |_____________^
    |
-   = help: try refactoring your code, extraction is often both easier to read and less nested
+   = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:184:27
+  --> $DIR/excessive_nesting.rs:185:27
    |
 LL |     async fn c() -> u32 {{{{{{{0}}}}}}}
    |                           ^^^^^^^^^^^
    |
-   = help: try refactoring your code, extraction is often both easier to read and less nested
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:184:28
-   |
-LL |     async fn c() -> u32 {{{{{{{0}}}}}}}
-   |                            ^^^^^^^^^
-   |
-   = help: try refactoring your code, extraction is often both easier to read and less nested
+   = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:190:7
+  --> $DIR/excessive_nesting.rs:191:7
    |
 LL |     {{{{b().await}}}};
    |       ^^^^^^^^^^^^^
    |
-   = help: try refactoring your code, extraction is often both easier to read and less nested
+   = help: try refactoring your code to minimize nesting
 
 error: aborting due to 40 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 493a23e957f9d639c13bddb19937bd19cbc6cfe2 Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Sat, 6 May 2023 18:43:53 -0500
Subject: check non-inline modules, ignore all macros

---
 clippy_lints/src/excessive_nesting.rs              |  24 ++++-
 tests/ui-toml/excessive_nesting/auxiliary/mod.rs   |  16 +++
 .../ui-toml/excessive_nesting/excessive_nesting.rs |   6 +-
 .../excessive_nesting/excessive_nesting.stderr     | 118 ++++++++++-----------
 4 files changed, 98 insertions(+), 66 deletions(-)
 create mode 100644 tests/ui-toml/excessive_nesting/auxiliary/mod.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/excessive_nesting.rs b/clippy_lints/src/excessive_nesting.rs
index a133bdc2edf..5ade713f816 100644
--- a/clippy_lints/src/excessive_nesting.rs
+++ b/clippy_lints/src/excessive_nesting.rs
@@ -11,7 +11,7 @@ use rustc_span::Span;
 declare_clippy_lint! {
     /// ### What it does
     ///
-    /// Checks for blocks which are indented beyond a certain threshold.
+    /// Checks for blocks which are nested beyond a certain threshold.
     ///
     /// ### Why is this bad?
     ///
@@ -106,6 +106,11 @@ impl NestingVisitor<'_, '_> {
 
 impl<'conf, 'cx> Visitor<'_> for NestingVisitor<'conf, 'cx> {
     fn visit_block(&mut self, block: &Block) {
+        // TODO: Probably not necessary, since any block would already be ignored by the check in visit_item
+        if block.span.from_expansion() {
+            return;
+        }
+
         self.nest_level += 1;
 
         if !self.check_indent(block.span) {
@@ -116,6 +121,10 @@ impl<'conf, 'cx> Visitor<'_> for NestingVisitor<'conf, 'cx> {
     }
 
     fn visit_item(&mut self, item: &Item) {
+        if item.span.from_expansion() {
+            return;
+        }
+
         match &item.kind {
             ItemKind::Trait(_) | ItemKind::Impl(_) | ItemKind::Mod(.., ModKind::Loaded(_, Inline::Yes, _)) => {
                 self.nest_level += 1;
@@ -126,10 +135,15 @@ impl<'conf, 'cx> Visitor<'_> for NestingVisitor<'conf, 'cx> {
 
                 self.nest_level -= 1;
             },
-            // Mod: Don't visit non-inline modules
-            // ForeignMod: I don't think this is necessary, but just incase let's not take any chances (don't want to
-            // cause any false positives)
-            ItemKind::Mod(..) | ItemKind::ForeignMod(..) => {},
+            // Reset nesting level for non-inline modules (since these are in another file)
+            ItemKind::Mod(..) => walk_item(
+                &mut NestingVisitor {
+                    conf: self.conf,
+                    cx: self.cx,
+                    nest_level: 0,
+                },
+                item,
+            ),
             _ => walk_item(self, item),
         }
     }
diff --git a/tests/ui-toml/excessive_nesting/auxiliary/mod.rs b/tests/ui-toml/excessive_nesting/auxiliary/mod.rs
new file mode 100644
index 00000000000..967b3af3bca
--- /dev/null
+++ b/tests/ui-toml/excessive_nesting/auxiliary/mod.rs
@@ -0,0 +1,16 @@
+#![rustfmt::skip]
+
+mod a {
+    mod b {
+        mod c {
+            mod d {
+                mod e {}
+            }
+        }
+    }
+}
+
+fn main() {
+    // this should lint
+    {{{}}}
+}
diff --git a/tests/ui-toml/excessive_nesting/excessive_nesting.rs b/tests/ui-toml/excessive_nesting/excessive_nesting.rs
index 62cf5125816..3e3ac7c923a 100644
--- a/tests/ui-toml/excessive_nesting/excessive_nesting.rs
+++ b/tests/ui-toml/excessive_nesting/excessive_nesting.rs
@@ -10,6 +10,8 @@
 #![warn(clippy::excessive_nesting)]
 #![allow(clippy::collapsible_if)]
 
+mod auxiliary;
+
 #[macro_use]
 extern crate macro_rules;
 
@@ -39,7 +41,7 @@ macro_rules! xx {
                                     {
                                         {
                                             {
-                                                println!("ehe");
+                                                println!("ehe"); // should not lint
                                             }
                                         }
                                     }
@@ -135,7 +137,7 @@ fn main() {
     })();
 
     excessive_nesting!(); // ensure this isn't linted in external macros
-    xx!();
+    xx!(); // ensure this is never linted
     let boo = true;
     !{boo as u32 + !{boo as u32 + !{boo as u32}}};
 
diff --git a/tests/ui-toml/excessive_nesting/excessive_nesting.stderr b/tests/ui-toml/excessive_nesting/excessive_nesting.stderr
index c98c6fefe01..524282d11f7 100644
--- a/tests/ui-toml/excessive_nesting/excessive_nesting.stderr
+++ b/tests/ui-toml/excessive_nesting/excessive_nesting.stderr
@@ -1,5 +1,24 @@
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:19:21
+  --> $DIR/auxiliary/mod.rs:6:13
+   |
+LL | /             mod d {
+LL | |                 mod e {}
+LL | |             }
+   | |_____________^
+   |
+   = help: try refactoring your code to minimize nesting
+   = note: `-D clippy::excessive-nesting` implied by `-D warnings`
+
+error: this block is too nested
+  --> $DIR/auxiliary/mod.rs:15:7
+   |
+LL |     {{{}}}
+   |       ^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:21:21
    |
 LL |               let z = {
    |  _____________________^
@@ -9,10 +28,9 @@ LL | |             };
    | |_____________^
    |
    = help: try refactoring your code to minimize nesting
-   = note: `-D clippy::excessive-nesting` implied by `-D warnings`
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:63:24
+  --> $DIR/excessive_nesting.rs:65:24
    |
 LL |               pub fn b() {
    |  ________________________^
@@ -27,7 +45,7 @@ LL | |             }
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:79:21
+  --> $DIR/excessive_nesting.rs:81:21
    |
 LL |               fn cc() {
    |  _____________________^
@@ -38,7 +56,7 @@ LL | |             }
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:83:21
+  --> $DIR/excessive_nesting.rs:85:21
    |
 LL |             let x = { 1 }; // warning
    |                     ^^^^^
@@ -46,7 +64,7 @@ LL |             let x = { 1 }; // warning
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:93:13
+  --> $DIR/excessive_nesting.rs:95:13
    |
 LL | /             pub mod d {
 LL | |                 pub mod e {
@@ -58,7 +76,7 @@ LL | |             } // only warning should be here
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:107:17
+  --> $DIR/excessive_nesting.rs:109:17
    |
 LL |     a_but_not({{{{{{{{0}}}}}}}});
    |                 ^^^^^^^^^^^^^
@@ -66,7 +84,7 @@ LL |     a_but_not({{{{{{{{0}}}}}}}});
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:108:11
+  --> $DIR/excessive_nesting.rs:110:11
    |
 LL |     a.a({{{{{{{{{0}}}}}}}}});
    |           ^^^^^^^^^^^^^^^
@@ -74,7 +92,7 @@ LL |     a.a({{{{{{{{{0}}}}}}}}});
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:109:11
+  --> $DIR/excessive_nesting.rs:111:11
    |
 LL |     (0, {{{{{{{1}}}}}}});
    |           ^^^^^^^^^^^
@@ -82,7 +100,7 @@ LL |     (0, {{{{{{{1}}}}}}});
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:113:21
+  --> $DIR/excessive_nesting.rs:115:21
    |
 LL |               if true {
    |  _____________________^
@@ -97,7 +115,7 @@ LL | |             }
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:125:25
+  --> $DIR/excessive_nesting.rs:127:25
    |
 LL |               let y = (|| {
    |  _________________________^
@@ -112,25 +130,7 @@ LL | |             })();
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:33:13
-   |
-LL | /             {
-LL | |                 {
-LL | |                     {
-LL | |                         {
-...  |
-LL | |                 }
-LL | |             }
-   | |_____________^
-...
-LL |       xx!();
-   |       ----- in this macro invocation
-   |
-   = help: try refactoring your code to minimize nesting
-   = note: this error originates in the macro `xx` (in Nightly builds, run with -Z macro-backtrace for more info)
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:140:36
+  --> $DIR/excessive_nesting.rs:142:36
    |
 LL |     !{boo as u32 + !{boo as u32 + !{boo as u32}}};
    |                                    ^^^^^^^^^^^^
@@ -138,7 +138,7 @@ LL |     !{boo as u32 + !{boo as u32 + !{boo as u32}}};
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:144:12
+  --> $DIR/excessive_nesting.rs:146:12
    |
 LL |     y += {{{{{5}}}}};
    |            ^^^^^^^
@@ -146,7 +146,7 @@ LL |     y += {{{{{5}}}}};
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:145:19
+  --> $DIR/excessive_nesting.rs:147:19
    |
 LL |     let z = y + {{{{{{{{{5}}}}}}}}};
    |                   ^^^^^^^^^^^^^^^
@@ -154,7 +154,7 @@ LL |     let z = y + {{{{{{{{{5}}}}}}}}};
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:146:11
+  --> $DIR/excessive_nesting.rs:148:11
    |
 LL |     [0, {{{{{{{{{{0}}}}}}}}}}];
    |           ^^^^^^^^^^^^^^^^^
@@ -162,7 +162,7 @@ LL |     [0, {{{{{{{{{{0}}}}}}}}}}];
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:147:24
+  --> $DIR/excessive_nesting.rs:149:24
    |
 LL |     let mut xx = [0; {{{{{{{{100}}}}}}}}];
    |                        ^^^^^^^^^^^^^^^
@@ -170,7 +170,7 @@ LL |     let mut xx = [0; {{{{{{{{100}}}}}}}}];
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:148:10
+  --> $DIR/excessive_nesting.rs:150:10
    |
 LL |     xx[{{{{{{{{{{{{{{{{{{{{{{{{3}}}}}}}}}}}}}}}}}}}}}}}}];
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -178,7 +178,7 @@ LL |     xx[{{{{{{{{{{{{{{{{{{{{{{{{3}}}}}}}}}}}}}}}}}}}}}}}}];
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:149:12
+  --> $DIR/excessive_nesting.rs:151:12
    |
 LL |     &mut {{{{{{{{{{y}}}}}}}}}};
    |            ^^^^^^^^^^^^^^^^^
@@ -186,7 +186,7 @@ LL |     &mut {{{{{{{{{{y}}}}}}}}}};
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:151:16
+  --> $DIR/excessive_nesting.rs:153:16
    |
 LL |     for i in {{{{xx}}}} {{{{{{{{}}}}}}}}
    |                ^^^^^^
@@ -194,7 +194,7 @@ LL |     for i in {{{{xx}}}} {{{{{{{{}}}}}}}}
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:151:27
+  --> $DIR/excessive_nesting.rs:153:27
    |
 LL |     for i in {{{{xx}}}} {{{{{{{{}}}}}}}}
    |                           ^^^^^^^^^^^^
@@ -202,7 +202,7 @@ LL |     for i in {{{{xx}}}} {{{{{{{{}}}}}}}}
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:153:27
+  --> $DIR/excessive_nesting.rs:155:27
    |
 LL |     while let Some(i) = {{{{{{Some(1)}}}}}} {{{{{{{}}}}}}}
    |                           ^^^^^^^^^^^^^^^
@@ -210,7 +210,7 @@ LL |     while let Some(i) = {{{{{{Some(1)}}}}}} {{{{{{{}}}}}}}
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:153:47
+  --> $DIR/excessive_nesting.rs:155:47
    |
 LL |     while let Some(i) = {{{{{{Some(1)}}}}}} {{{{{{{}}}}}}}
    |                                               ^^^^^^^^^^
@@ -218,7 +218,7 @@ LL |     while let Some(i) = {{{{{{Some(1)}}}}}} {{{{{{{}}}}}}}
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:155:13
+  --> $DIR/excessive_nesting.rs:157:13
    |
 LL |     while {{{{{{{{true}}}}}}}} {{{{{{{{{}}}}}}}}}
    |             ^^^^^^^^^^^^^^^^
@@ -226,7 +226,7 @@ LL |     while {{{{{{{{true}}}}}}}} {{{{{{{{{}}}}}}}}}
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:155:34
+  --> $DIR/excessive_nesting.rs:157:34
    |
 LL |     while {{{{{{{{true}}}}}}}} {{{{{{{{{}}}}}}}}}
    |                                  ^^^^^^^^^^^^^^
@@ -234,7 +234,7 @@ LL |     while {{{{{{{{true}}}}}}}} {{{{{{{{{}}}}}}}}}
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:157:22
+  --> $DIR/excessive_nesting.rs:159:22
    |
 LL |     let d = D { d: {{{{{{{{{{{{{{{{{{{{{{{3}}}}}}}}}}}}}}}}}}}}}}} };
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -242,7 +242,7 @@ LL |     let d = D { d: {{{{{{{{{{{{{{{{{{{{{{{3}}}}}}}}}}}}}}}}}}}}}}} };
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:159:7
+  --> $DIR/excessive_nesting.rs:161:7
    |
 LL |     {{{{1;}}}}..{{{{{{3}}}}}};
    |       ^^^^^^
@@ -250,7 +250,7 @@ LL |     {{{{1;}}}}..{{{{{{3}}}}}};
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:159:19
+  --> $DIR/excessive_nesting.rs:161:19
    |
 LL |     {{{{1;}}}}..{{{{{{3}}}}}};
    |                   ^^^^^^^^^
@@ -258,7 +258,7 @@ LL |     {{{{1;}}}}..{{{{{{3}}}}}};
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:160:7
+  --> $DIR/excessive_nesting.rs:162:7
    |
 LL |     {{{{1;}}}}..={{{{{{{{{{{{{{{{{{{{{{{{{{6}}}}}}}}}}}}}}}}}}}}}}}}}};
    |       ^^^^^^
@@ -266,7 +266,7 @@ LL |     {{{{1;}}}}..={{{{{{{{{{{{{{{{{{{{{{{{{{6}}}}}}}}}}}}}}}}}}}}}}}}}};
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:160:20
+  --> $DIR/excessive_nesting.rs:162:20
    |
 LL |     {{{{1;}}}}..={{{{{{{{{{{{{{{{{{{{{{{{{{6}}}}}}}}}}}}}}}}}}}}}}}}}};
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -274,7 +274,7 @@ LL |     {{{{1;}}}}..={{{{{{{{{{{{{{{{{{{{{{{{{{6}}}}}}}}}}}}}}}}}}}}}}}}}};
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:161:9
+  --> $DIR/excessive_nesting.rs:163:9
    |
 LL |     ..{{{{{{{5}}}}}}};
    |         ^^^^^^^^^^^
@@ -282,7 +282,7 @@ LL |     ..{{{{{{{5}}}}}}};
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:162:10
+  --> $DIR/excessive_nesting.rs:164:10
    |
 LL |     ..={{{{{3}}}}};
    |          ^^^^^^^
@@ -290,7 +290,7 @@ LL |     ..={{{{{3}}}}};
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:163:7
+  --> $DIR/excessive_nesting.rs:165:7
    |
 LL |     {{{{{1;}}}}}..;
    |       ^^^^^^^^
@@ -298,7 +298,7 @@ LL |     {{{{{1;}}}}}..;
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:165:19
+  --> $DIR/excessive_nesting.rs:167:19
    |
 LL |     loop { break {{{{1}}}} };
    |                   ^^^^^^^
@@ -306,7 +306,7 @@ LL |     loop { break {{{{1}}}} };
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:166:12
+  --> $DIR/excessive_nesting.rs:168:12
    |
 LL |     loop {{{{{{}}}}}}
    |            ^^^^^^^^
@@ -314,7 +314,7 @@ LL |     loop {{{{{{}}}}}}
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:168:13
+  --> $DIR/excessive_nesting.rs:170:13
    |
 LL |     match {{{{{{true}}}}}} {
    |             ^^^^^^^^^^^^
@@ -322,7 +322,7 @@ LL |     match {{{{{{true}}}}}} {
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:169:19
+  --> $DIR/excessive_nesting.rs:171:19
    |
 LL |         true => {{{{}}}},
    |                   ^^^^
@@ -330,7 +330,7 @@ LL |         true => {{{{}}}},
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:170:20
+  --> $DIR/excessive_nesting.rs:172:20
    |
 LL |         false => {{{{}}}},
    |                    ^^^^
@@ -338,7 +338,7 @@ LL |         false => {{{{}}}},
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:175:13
+  --> $DIR/excessive_nesting.rs:177:13
    |
 LL | /             {
 LL | |                 {
@@ -350,7 +350,7 @@ LL | |             }
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:185:27
+  --> $DIR/excessive_nesting.rs:187:27
    |
 LL |     async fn c() -> u32 {{{{{{{0}}}}}}}
    |                           ^^^^^^^^^^^
@@ -358,12 +358,12 @@ LL |     async fn c() -> u32 {{{{{{{0}}}}}}}
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:191:7
+  --> $DIR/excessive_nesting.rs:193:7
    |
 LL |     {{{{b().await}}}};
    |       ^^^^^^^^^^^^^
    |
    = help: try refactoring your code to minimize nesting
 
-error: aborting due to 40 previous errors
+error: aborting due to 41 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 378d77584acdd4864bf495ce67c932c0f422e6f4 Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Mon, 15 May 2023 15:22:59 -0500
Subject: work with lint attributes

---
 clippy_lints/src/excessive_nesting.rs              |  54 ++-
 clippy_lints/src/lib.rs                            |   1 +
 tests/ui-toml/excessive_nesting/below/clippy.toml  |   1 +
 tests/ui-toml/excessive_nesting/clippy.toml        |   1 -
 .../ui-toml/excessive_nesting/default/clippy.toml  |   1 +
 .../excessive_nesting.below.stderr                 | 369 +++++++++++++++++++++
 .../excessive_nesting.default.stderr               |  43 +++
 .../ui-toml/excessive_nesting/excessive_nesting.rs |   6 +
 .../excessive_nesting/excessive_nesting.stderr     |  70 ++--
 9 files changed, 493 insertions(+), 53 deletions(-)
 create mode 100644 tests/ui-toml/excessive_nesting/below/clippy.toml
 delete mode 100644 tests/ui-toml/excessive_nesting/clippy.toml
 create mode 100644 tests/ui-toml/excessive_nesting/default/clippy.toml
 create mode 100644 tests/ui-toml/excessive_nesting/excessive_nesting.below.stderr
 create mode 100644 tests/ui-toml/excessive_nesting/excessive_nesting.default.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/excessive_nesting.rs b/clippy_lints/src/excessive_nesting.rs
index 5ade713f816..f1aafa3cbc3 100644
--- a/clippy_lints/src/excessive_nesting.rs
+++ b/clippy_lints/src/excessive_nesting.rs
@@ -1,7 +1,8 @@
 use clippy_utils::diagnostics::span_lint_and_help;
 use rustc_ast::{
+    node_id::NodeSet,
     visit::{walk_block, walk_item, Visitor},
-    Block, Crate, Inline, Item, ItemKind, ModKind,
+    Block, Crate, Inline, Item, ItemKind, ModKind, NodeId,
 };
 use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
@@ -52,6 +53,10 @@ declare_clippy_lint! {
     ///     }
     /// }
     /// ```
+    /// lib.rs:
+    /// ```rust,ignore
+    /// pub mod a;
+    /// ```
     #[clippy::version = "1.70.0"]
     pub EXCESSIVE_NESTING,
     restriction,
@@ -59,16 +64,31 @@ declare_clippy_lint! {
 }
 impl_lint_pass!(ExcessiveNesting => [EXCESSIVE_NESTING]);
 
-#[derive(Clone, Copy)]
+#[derive(Clone)]
 pub struct ExcessiveNesting {
     pub excessive_nesting_threshold: u64,
+    pub nodes: NodeSet,
+}
+
+impl ExcessiveNesting {
+    pub fn check_node_id(&self, cx: &EarlyContext<'_>, span: Span, node_id: NodeId) {
+        if self.nodes.contains(&node_id) {
+            span_lint_and_help(
+                cx,
+                EXCESSIVE_NESTING,
+                span,
+                "this block is too nested",
+                None,
+                "try refactoring your code to minimize nesting",
+            );
+        }
+    }
 }
 
 impl EarlyLintPass for ExcessiveNesting {
     fn check_crate(&mut self, cx: &EarlyContext<'_>, krate: &Crate) {
-        let conf = self;
         let mut visitor = NestingVisitor {
-            conf,
+            conf: self,
             cx,
             nest_level: 0,
         };
@@ -77,25 +97,26 @@ impl EarlyLintPass for ExcessiveNesting {
             visitor.visit_item(item);
         }
     }
+
+    fn check_block(&mut self, cx: &EarlyContext<'_>, block: &Block) {
+        self.check_node_id(cx, block.span, block.id);
+    }
+
+    fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {
+        self.check_node_id(cx, item.span, item.id);
+    }
 }
 
 struct NestingVisitor<'conf, 'cx> {
-    conf: &'conf ExcessiveNesting,
+    conf: &'conf mut ExcessiveNesting,
     cx: &'cx EarlyContext<'cx>,
     nest_level: u64,
 }
 
 impl NestingVisitor<'_, '_> {
-    fn check_indent(&self, span: Span) -> bool {
+    fn check_indent(&mut self, span: Span, id: NodeId) -> bool {
         if self.nest_level > self.conf.excessive_nesting_threshold && !in_external_macro(self.cx.sess(), span) {
-            span_lint_and_help(
-                self.cx,
-                EXCESSIVE_NESTING,
-                span,
-                "this block is too nested",
-                None,
-                "try refactoring your code to minimize nesting",
-            );
+            self.conf.nodes.insert(id);
 
             return true;
         }
@@ -106,14 +127,13 @@ impl NestingVisitor<'_, '_> {
 
 impl<'conf, 'cx> Visitor<'_> for NestingVisitor<'conf, 'cx> {
     fn visit_block(&mut self, block: &Block) {
-        // TODO: Probably not necessary, since any block would already be ignored by the check in visit_item
         if block.span.from_expansion() {
             return;
         }
 
         self.nest_level += 1;
 
-        if !self.check_indent(block.span) {
+        if !self.check_indent(block.span, block.id) {
             walk_block(self, block);
         }
 
@@ -129,7 +149,7 @@ impl<'conf, 'cx> Visitor<'_> for NestingVisitor<'conf, 'cx> {
             ItemKind::Trait(_) | ItemKind::Impl(_) | ItemKind::Mod(.., ModKind::Loaded(_, Inline::Yes, _)) => {
                 self.nest_level += 1;
 
-                if !self.check_indent(item.span) {
+                if !self.check_indent(item.span, item.id) {
                     walk_item(self, item);
                 }
 
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 202b4709ad4..189096d7ba9 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1012,6 +1012,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_early_pass(move || {
         Box::new(excessive_nesting::ExcessiveNesting {
             excessive_nesting_threshold,
+            nodes: rustc_ast::node_id::NodeSet::new(),
         })
     });
     store.register_late_pass(|_| Box::new(items_after_test_module::ItemsAfterTestModule));
diff --git a/tests/ui-toml/excessive_nesting/below/clippy.toml b/tests/ui-toml/excessive_nesting/below/clippy.toml
new file mode 100644
index 00000000000..10be2751a86
--- /dev/null
+++ b/tests/ui-toml/excessive_nesting/below/clippy.toml
@@ -0,0 +1 @@
+excessive-nesting-threshold = 3
diff --git a/tests/ui-toml/excessive_nesting/clippy.toml b/tests/ui-toml/excessive_nesting/clippy.toml
deleted file mode 100644
index 10be2751a86..00000000000
--- a/tests/ui-toml/excessive_nesting/clippy.toml
+++ /dev/null
@@ -1 +0,0 @@
-excessive-nesting-threshold = 3
diff --git a/tests/ui-toml/excessive_nesting/default/clippy.toml b/tests/ui-toml/excessive_nesting/default/clippy.toml
new file mode 100644
index 00000000000..b01e482e485
--- /dev/null
+++ b/tests/ui-toml/excessive_nesting/default/clippy.toml
@@ -0,0 +1 @@
+excessive-nesting-threshold = 10
diff --git a/tests/ui-toml/excessive_nesting/excessive_nesting.below.stderr b/tests/ui-toml/excessive_nesting/excessive_nesting.below.stderr
new file mode 100644
index 00000000000..1f069437dfe
--- /dev/null
+++ b/tests/ui-toml/excessive_nesting/excessive_nesting.below.stderr
@@ -0,0 +1,369 @@
+error: this block is too nested
+  --> $DIR/auxiliary/mod.rs:6:13
+   |
+LL | /             mod d {
+LL | |                 mod e {}
+LL | |             }
+   | |_____________^
+   |
+   = help: try refactoring your code to minimize nesting
+   = note: `-D clippy::excessive-nesting` implied by `-D warnings`
+
+error: this block is too nested
+  --> $DIR/auxiliary/mod.rs:15:7
+   |
+LL |     {{{}}}
+   |       ^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:24:21
+   |
+LL |               let z = {
+   |  _____________________^
+LL | |                 let w = { 3 };
+LL | |                 w
+LL | |             };
+   | |_____________^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:68:24
+   |
+LL |               pub fn b() {
+   |  ________________________^
+LL | |                 struct C;
+LL | |
+LL | |                 impl C {
+LL | |                     pub fn c() {}
+LL | |                 }
+LL | |             }
+   | |_____________^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:84:21
+   |
+LL |               fn cc() {
+   |  _____________________^
+LL | |                 let x = { 1 }; // not a warning, but cc is
+LL | |             }
+   | |_____________^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:88:21
+   |
+LL |             let x = { 1 }; // warning
+   |                     ^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:101:13
+   |
+LL | /             pub mod d {
+LL | |                 pub mod e {
+LL | |                     pub mod f {}
+LL | |                 } // not here
+LL | |             } // only warning should be here
+   | |_____________^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:115:17
+   |
+LL |     a_but_not({{{{{{{{0}}}}}}}});
+   |                 ^^^^^^^^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:116:11
+   |
+LL |     a.a({{{{{{{{{0}}}}}}}}});
+   |           ^^^^^^^^^^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:117:11
+   |
+LL |     (0, {{{{{{{1}}}}}}});
+   |           ^^^^^^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:121:21
+   |
+LL |               if true {
+   |  _____________________^
+LL | |                 if true {
+LL | |                     if true {
+LL | |
+LL | |                     }
+LL | |                 }
+LL | |             }
+   | |_____________^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:133:25
+   |
+LL |               let y = (|| {
+   |  _________________________^
+LL | |                 let z = (|| {
+LL | |                     let w = { 3 };
+LL | |                     w
+LL | |                 })();
+LL | |                 z
+LL | |             })();
+   | |_____________^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:148:36
+   |
+LL |     !{boo as u32 + !{boo as u32 + !{boo as u32}}};
+   |                                    ^^^^^^^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:152:12
+   |
+LL |     y += {{{{{5}}}}};
+   |            ^^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:153:19
+   |
+LL |     let z = y + {{{{{{{{{5}}}}}}}}};
+   |                   ^^^^^^^^^^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:154:11
+   |
+LL |     [0, {{{{{{{{{{0}}}}}}}}}}];
+   |           ^^^^^^^^^^^^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:155:24
+   |
+LL |     let mut xx = [0; {{{{{{{{100}}}}}}}}];
+   |                        ^^^^^^^^^^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:156:10
+   |
+LL |     xx[{{{{{{{{{{{{{{{{{{{{{{{{3}}}}}}}}}}}}}}}}}}}}}}}}];
+   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:157:12
+   |
+LL |     &mut {{{{{{{{{{y}}}}}}}}}};
+   |            ^^^^^^^^^^^^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:159:16
+   |
+LL |     for i in {{{{xx}}}} {{{{{{{{}}}}}}}}
+   |                ^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:159:27
+   |
+LL |     for i in {{{{xx}}}} {{{{{{{{}}}}}}}}
+   |                           ^^^^^^^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:161:27
+   |
+LL |     while let Some(i) = {{{{{{Some(1)}}}}}} {{{{{{{}}}}}}}
+   |                           ^^^^^^^^^^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:161:47
+   |
+LL |     while let Some(i) = {{{{{{Some(1)}}}}}} {{{{{{{}}}}}}}
+   |                                               ^^^^^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:163:13
+   |
+LL |     while {{{{{{{{true}}}}}}}} {{{{{{{{{}}}}}}}}}
+   |             ^^^^^^^^^^^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:163:34
+   |
+LL |     while {{{{{{{{true}}}}}}}} {{{{{{{{{}}}}}}}}}
+   |                                  ^^^^^^^^^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:165:22
+   |
+LL |     let d = D { d: {{{{{{{{{{{{{{{{{{{{{{{3}}}}}}}}}}}}}}}}}}}}}}} };
+   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:167:7
+   |
+LL |     {{{{1;}}}}..{{{{{{3}}}}}};
+   |       ^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:167:19
+   |
+LL |     {{{{1;}}}}..{{{{{{3}}}}}};
+   |                   ^^^^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:168:7
+   |
+LL |     {{{{1;}}}}..={{{{{{{{{{{{{{{{{{{{{{{{{{6}}}}}}}}}}}}}}}}}}}}}}}}}};
+   |       ^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:168:20
+   |
+LL |     {{{{1;}}}}..={{{{{{{{{{{{{{{{{{{{{{{{{{6}}}}}}}}}}}}}}}}}}}}}}}}}};
+   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:169:9
+   |
+LL |     ..{{{{{{{5}}}}}}};
+   |         ^^^^^^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:170:10
+   |
+LL |     ..={{{{{3}}}}};
+   |          ^^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:171:7
+   |
+LL |     {{{{{1;}}}}}..;
+   |       ^^^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:173:19
+   |
+LL |     loop { break {{{{1}}}} };
+   |                   ^^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:174:12
+   |
+LL |     loop {{{{{{}}}}}}
+   |            ^^^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:176:13
+   |
+LL |     match {{{{{{true}}}}}} {
+   |             ^^^^^^^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:177:19
+   |
+LL |         true => {{{{}}}},
+   |                   ^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:178:20
+   |
+LL |         false => {{{{}}}},
+   |                    ^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:183:13
+   |
+LL | /             {
+LL | |                 {
+LL | |                     println!("warning! :)");
+LL | |                 }
+LL | |             }
+   | |_____________^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:193:27
+   |
+LL |     async fn c() -> u32 {{{{{{{0}}}}}}}
+   |                           ^^^^^^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:199:7
+   |
+LL |     {{{{b().await}}}};
+   |       ^^^^^^^^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: aborting due to 41 previous errors
+
diff --git a/tests/ui-toml/excessive_nesting/excessive_nesting.default.stderr b/tests/ui-toml/excessive_nesting/excessive_nesting.default.stderr
new file mode 100644
index 00000000000..02fa2cdcf9f
--- /dev/null
+++ b/tests/ui-toml/excessive_nesting/excessive_nesting.default.stderr
@@ -0,0 +1,43 @@
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:154:18
+   |
+LL |     [0, {{{{{{{{{{0}}}}}}}}}}];
+   |                  ^^^
+   |
+   = help: try refactoring your code to minimize nesting
+   = note: `-D clippy::excessive-nesting` implied by `-D warnings`
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:156:17
+   |
+LL |     xx[{{{{{{{{{{{{{{{{{{{{{{{{3}}}}}}}}}}}}}}}}}}}}}}}}];
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:157:19
+   |
+LL |     &mut {{{{{{{{{{y}}}}}}}}}};
+   |                   ^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:165:29
+   |
+LL |     let d = D { d: {{{{{{{{{{{{{{{{{{{{{{{3}}}}}}}}}}}}}}}}}}}}}}} };
+   |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:168:27
+   |
+LL |     {{{{1;}}}}..={{{{{{{{{{{{{{{{{{{{{{{{{{6}}}}}}}}}}}}}}}}}}}}}}}}}};
+   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: aborting due to 5 previous errors
+
diff --git a/tests/ui-toml/excessive_nesting/excessive_nesting.rs b/tests/ui-toml/excessive_nesting/excessive_nesting.rs
index 3e3ac7c923a..745031db1eb 100644
--- a/tests/ui-toml/excessive_nesting/excessive_nesting.rs
+++ b/tests/ui-toml/excessive_nesting/excessive_nesting.rs
@@ -1,4 +1,7 @@
 //@aux-build:macro_rules.rs
+//@revisions: below default
+//@[below] rustc-env:CLIPPY_CONF_DIR=tests/ui-toml/excessive_nesting/below
+//@[default] rustc-env:CLIPPY_CONF_DIR=tests/ui-toml/excessive_nesting/default
 #![rustfmt::skip]
 #![feature(custom_inner_attributes)]
 #![allow(unused)]
@@ -87,6 +90,9 @@ trait Lol {
     }
 }
 
+#[allow(clippy::excessive_nesting)]
+fn l() {{{{{{{{{}}}}}}}}}
+
 use a::{b::{c::{d::{e::{f::{}}}}}}; // should not lint
 
 pub mod a {
diff --git a/tests/ui-toml/excessive_nesting/excessive_nesting.stderr b/tests/ui-toml/excessive_nesting/excessive_nesting.stderr
index 524282d11f7..f1db396fe48 100644
--- a/tests/ui-toml/excessive_nesting/excessive_nesting.stderr
+++ b/tests/ui-toml/excessive_nesting/excessive_nesting.stderr
@@ -64,7 +64,7 @@ LL |             let x = { 1 }; // warning
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:95:13
+  --> $DIR/excessive_nesting.rs:98:13
    |
 LL | /             pub mod d {
 LL | |                 pub mod e {
@@ -76,7 +76,7 @@ LL | |             } // only warning should be here
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:109:17
+  --> $DIR/excessive_nesting.rs:112:17
    |
 LL |     a_but_not({{{{{{{{0}}}}}}}});
    |                 ^^^^^^^^^^^^^
@@ -84,7 +84,7 @@ LL |     a_but_not({{{{{{{{0}}}}}}}});
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:110:11
+  --> $DIR/excessive_nesting.rs:113:11
    |
 LL |     a.a({{{{{{{{{0}}}}}}}}});
    |           ^^^^^^^^^^^^^^^
@@ -92,7 +92,7 @@ LL |     a.a({{{{{{{{{0}}}}}}}}});
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:111:11
+  --> $DIR/excessive_nesting.rs:114:11
    |
 LL |     (0, {{{{{{{1}}}}}}});
    |           ^^^^^^^^^^^
@@ -100,7 +100,7 @@ LL |     (0, {{{{{{{1}}}}}}});
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:115:21
+  --> $DIR/excessive_nesting.rs:118:21
    |
 LL |               if true {
    |  _____________________^
@@ -115,7 +115,7 @@ LL | |             }
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:127:25
+  --> $DIR/excessive_nesting.rs:130:25
    |
 LL |               let y = (|| {
    |  _________________________^
@@ -130,7 +130,7 @@ LL | |             })();
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:142:36
+  --> $DIR/excessive_nesting.rs:145:36
    |
 LL |     !{boo as u32 + !{boo as u32 + !{boo as u32}}};
    |                                    ^^^^^^^^^^^^
@@ -138,7 +138,7 @@ LL |     !{boo as u32 + !{boo as u32 + !{boo as u32}}};
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:146:12
+  --> $DIR/excessive_nesting.rs:149:12
    |
 LL |     y += {{{{{5}}}}};
    |            ^^^^^^^
@@ -146,7 +146,7 @@ LL |     y += {{{{{5}}}}};
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:147:19
+  --> $DIR/excessive_nesting.rs:150:19
    |
 LL |     let z = y + {{{{{{{{{5}}}}}}}}};
    |                   ^^^^^^^^^^^^^^^
@@ -154,7 +154,7 @@ LL |     let z = y + {{{{{{{{{5}}}}}}}}};
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:148:11
+  --> $DIR/excessive_nesting.rs:151:11
    |
 LL |     [0, {{{{{{{{{{0}}}}}}}}}}];
    |           ^^^^^^^^^^^^^^^^^
@@ -162,7 +162,7 @@ LL |     [0, {{{{{{{{{{0}}}}}}}}}}];
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:149:24
+  --> $DIR/excessive_nesting.rs:152:24
    |
 LL |     let mut xx = [0; {{{{{{{{100}}}}}}}}];
    |                        ^^^^^^^^^^^^^^^
@@ -170,7 +170,7 @@ LL |     let mut xx = [0; {{{{{{{{100}}}}}}}}];
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:150:10
+  --> $DIR/excessive_nesting.rs:153:10
    |
 LL |     xx[{{{{{{{{{{{{{{{{{{{{{{{{3}}}}}}}}}}}}}}}}}}}}}}}}];
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -178,7 +178,7 @@ LL |     xx[{{{{{{{{{{{{{{{{{{{{{{{{3}}}}}}}}}}}}}}}}}}}}}}}}];
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:151:12
+  --> $DIR/excessive_nesting.rs:154:12
    |
 LL |     &mut {{{{{{{{{{y}}}}}}}}}};
    |            ^^^^^^^^^^^^^^^^^
@@ -186,7 +186,7 @@ LL |     &mut {{{{{{{{{{y}}}}}}}}}};
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:153:16
+  --> $DIR/excessive_nesting.rs:156:16
    |
 LL |     for i in {{{{xx}}}} {{{{{{{{}}}}}}}}
    |                ^^^^^^
@@ -194,7 +194,7 @@ LL |     for i in {{{{xx}}}} {{{{{{{{}}}}}}}}
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:153:27
+  --> $DIR/excessive_nesting.rs:156:27
    |
 LL |     for i in {{{{xx}}}} {{{{{{{{}}}}}}}}
    |                           ^^^^^^^^^^^^
@@ -202,7 +202,7 @@ LL |     for i in {{{{xx}}}} {{{{{{{{}}}}}}}}
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:155:27
+  --> $DIR/excessive_nesting.rs:158:27
    |
 LL |     while let Some(i) = {{{{{{Some(1)}}}}}} {{{{{{{}}}}}}}
    |                           ^^^^^^^^^^^^^^^
@@ -210,7 +210,7 @@ LL |     while let Some(i) = {{{{{{Some(1)}}}}}} {{{{{{{}}}}}}}
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:155:47
+  --> $DIR/excessive_nesting.rs:158:47
    |
 LL |     while let Some(i) = {{{{{{Some(1)}}}}}} {{{{{{{}}}}}}}
    |                                               ^^^^^^^^^^
@@ -218,7 +218,7 @@ LL |     while let Some(i) = {{{{{{Some(1)}}}}}} {{{{{{{}}}}}}}
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:157:13
+  --> $DIR/excessive_nesting.rs:160:13
    |
 LL |     while {{{{{{{{true}}}}}}}} {{{{{{{{{}}}}}}}}}
    |             ^^^^^^^^^^^^^^^^
@@ -226,7 +226,7 @@ LL |     while {{{{{{{{true}}}}}}}} {{{{{{{{{}}}}}}}}}
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:157:34
+  --> $DIR/excessive_nesting.rs:160:34
    |
 LL |     while {{{{{{{{true}}}}}}}} {{{{{{{{{}}}}}}}}}
    |                                  ^^^^^^^^^^^^^^
@@ -234,7 +234,7 @@ LL |     while {{{{{{{{true}}}}}}}} {{{{{{{{{}}}}}}}}}
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:159:22
+  --> $DIR/excessive_nesting.rs:162:22
    |
 LL |     let d = D { d: {{{{{{{{{{{{{{{{{{{{{{{3}}}}}}}}}}}}}}}}}}}}}}} };
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -242,7 +242,7 @@ LL |     let d = D { d: {{{{{{{{{{{{{{{{{{{{{{{3}}}}}}}}}}}}}}}}}}}}}}} };
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:161:7
+  --> $DIR/excessive_nesting.rs:164:7
    |
 LL |     {{{{1;}}}}..{{{{{{3}}}}}};
    |       ^^^^^^
@@ -250,7 +250,7 @@ LL |     {{{{1;}}}}..{{{{{{3}}}}}};
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:161:19
+  --> $DIR/excessive_nesting.rs:164:19
    |
 LL |     {{{{1;}}}}..{{{{{{3}}}}}};
    |                   ^^^^^^^^^
@@ -258,7 +258,7 @@ LL |     {{{{1;}}}}..{{{{{{3}}}}}};
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:162:7
+  --> $DIR/excessive_nesting.rs:165:7
    |
 LL |     {{{{1;}}}}..={{{{{{{{{{{{{{{{{{{{{{{{{{6}}}}}}}}}}}}}}}}}}}}}}}}}};
    |       ^^^^^^
@@ -266,7 +266,7 @@ LL |     {{{{1;}}}}..={{{{{{{{{{{{{{{{{{{{{{{{{{6}}}}}}}}}}}}}}}}}}}}}}}}}};
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:162:20
+  --> $DIR/excessive_nesting.rs:165:20
    |
 LL |     {{{{1;}}}}..={{{{{{{{{{{{{{{{{{{{{{{{{{6}}}}}}}}}}}}}}}}}}}}}}}}}};
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -274,7 +274,7 @@ LL |     {{{{1;}}}}..={{{{{{{{{{{{{{{{{{{{{{{{{{6}}}}}}}}}}}}}}}}}}}}}}}}}};
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:163:9
+  --> $DIR/excessive_nesting.rs:166:9
    |
 LL |     ..{{{{{{{5}}}}}}};
    |         ^^^^^^^^^^^
@@ -282,7 +282,7 @@ LL |     ..{{{{{{{5}}}}}}};
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:164:10
+  --> $DIR/excessive_nesting.rs:167:10
    |
 LL |     ..={{{{{3}}}}};
    |          ^^^^^^^
@@ -290,7 +290,7 @@ LL |     ..={{{{{3}}}}};
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:165:7
+  --> $DIR/excessive_nesting.rs:168:7
    |
 LL |     {{{{{1;}}}}}..;
    |       ^^^^^^^^
@@ -298,7 +298,7 @@ LL |     {{{{{1;}}}}}..;
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:167:19
+  --> $DIR/excessive_nesting.rs:170:19
    |
 LL |     loop { break {{{{1}}}} };
    |                   ^^^^^^^
@@ -306,7 +306,7 @@ LL |     loop { break {{{{1}}}} };
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:168:12
+  --> $DIR/excessive_nesting.rs:171:12
    |
 LL |     loop {{{{{{}}}}}}
    |            ^^^^^^^^
@@ -314,7 +314,7 @@ LL |     loop {{{{{{}}}}}}
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:170:13
+  --> $DIR/excessive_nesting.rs:173:13
    |
 LL |     match {{{{{{true}}}}}} {
    |             ^^^^^^^^^^^^
@@ -322,7 +322,7 @@ LL |     match {{{{{{true}}}}}} {
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:171:19
+  --> $DIR/excessive_nesting.rs:174:19
    |
 LL |         true => {{{{}}}},
    |                   ^^^^
@@ -330,7 +330,7 @@ LL |         true => {{{{}}}},
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:172:20
+  --> $DIR/excessive_nesting.rs:175:20
    |
 LL |         false => {{{{}}}},
    |                    ^^^^
@@ -338,7 +338,7 @@ LL |         false => {{{{}}}},
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:177:13
+  --> $DIR/excessive_nesting.rs:180:13
    |
 LL | /             {
 LL | |                 {
@@ -350,7 +350,7 @@ LL | |             }
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:187:27
+  --> $DIR/excessive_nesting.rs:190:27
    |
 LL |     async fn c() -> u32 {{{{{{{0}}}}}}}
    |                           ^^^^^^^^^^^
@@ -358,7 +358,7 @@ LL |     async fn c() -> u32 {{{{{{{0}}}}}}}
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:193:7
+  --> $DIR/excessive_nesting.rs:196:7
    |
 LL |     {{{{b().await}}}};
    |       ^^^^^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From 725399a178158be33f0754c423b95b5f7f8b53ac Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Tue, 30 May 2023 12:40:40 -0500
Subject: move to `complexity` but don't lint by default

---
 book/src/lint_configuration.md                     |   2 +-
 clippy_lints/src/excessive_nesting.rs              |  13 +-
 clippy_lints/src/utils/conf.rs                     |   2 +-
 tests/ui-toml/excessive_nesting/below/clippy.toml  |   1 -
 .../ui-toml/excessive_nesting/default/clippy.toml  |   2 +-
 .../excessive_nesting.below.stderr                 | 369 ---------------------
 .../excessive_nesting.default.stderr               |  43 ---
 .../ui-toml/excessive_nesting/excessive_nesting.rs |   4 +-
 .../excessive_nesting/excessive_nesting.set.stderr | 369 +++++++++++++++++++++
 tests/ui-toml/excessive_nesting/set/clippy.toml    |   1 +
 10 files changed, 382 insertions(+), 424 deletions(-)
 delete mode 100644 tests/ui-toml/excessive_nesting/below/clippy.toml
 delete mode 100644 tests/ui-toml/excessive_nesting/excessive_nesting.below.stderr
 create mode 100644 tests/ui-toml/excessive_nesting/excessive_nesting.set.stderr
 create mode 100644 tests/ui-toml/excessive_nesting/set/clippy.toml

(limited to 'clippy_lints/src')

diff --git a/book/src/lint_configuration.md b/book/src/lint_configuration.md
index 4fa6b81c002..3c955c9e574 100644
--- a/book/src/lint_configuration.md
+++ b/book/src/lint_configuration.md
@@ -161,7 +161,7 @@ The maximum cognitive complexity a function can have
 ## `excessive-nesting-threshold`
 The maximum amount of nesting a block can reside in
 
-**Default Value:** `10` (`u64`)
+**Default Value:** `0` (`u64`)
 
 ---
 **Affected lints:**
diff --git a/clippy_lints/src/excessive_nesting.rs b/clippy_lints/src/excessive_nesting.rs
index f1aafa3cbc3..1d68d7f9478 100644
--- a/clippy_lints/src/excessive_nesting.rs
+++ b/clippy_lints/src/excessive_nesting.rs
@@ -11,13 +11,12 @@ use rustc_span::Span;
 
 declare_clippy_lint! {
     /// ### What it does
-    ///
     /// Checks for blocks which are nested beyond a certain threshold.
     ///
-    /// ### Why is this bad?
+    /// Note: Even though this lint is warn-by-default, it will only trigger if a maximum nesting level is defined in the clippy.toml file.
     ///
-    /// It can severely hinder readability. The default is very generous; if you
-    /// exceed this, it's a sign you should refactor.
+    /// ### Why is this bad?
+    /// It can severely hinder readability.
     ///
     /// ### Example
     /// An example clippy.toml configuration:
@@ -59,7 +58,7 @@ declare_clippy_lint! {
     /// ```
     #[clippy::version = "1.70.0"]
     pub EXCESSIVE_NESTING,
-    restriction,
+    complexity,
     "checks for blocks nested beyond a certain threshold"
 }
 impl_lint_pass!(ExcessiveNesting => [EXCESSIVE_NESTING]);
@@ -115,7 +114,9 @@ struct NestingVisitor<'conf, 'cx> {
 
 impl NestingVisitor<'_, '_> {
     fn check_indent(&mut self, span: Span, id: NodeId) -> bool {
-        if self.nest_level > self.conf.excessive_nesting_threshold && !in_external_macro(self.cx.sess(), span) {
+        let threshold = self.conf.excessive_nesting_threshold;
+
+        if threshold != 0 && self.nest_level > threshold && !in_external_macro(self.cx.sess(), span) {
             self.conf.nodes.insert(id);
 
             return true;
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index cf0da266dc9..69143c3c726 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -308,7 +308,7 @@ define_Conf! {
     /// Lint: EXCESSIVE_NESTING.
     ///
     /// The maximum amount of nesting a block can reside in
-    (excessive_nesting_threshold: u64 = 10),
+    (excessive_nesting_threshold: u64 = 0),
     /// DEPRECATED LINT: CYCLOMATIC_COMPLEXITY.
     ///
     /// Use the Cognitive Complexity lint instead.
diff --git a/tests/ui-toml/excessive_nesting/below/clippy.toml b/tests/ui-toml/excessive_nesting/below/clippy.toml
deleted file mode 100644
index 10be2751a86..00000000000
--- a/tests/ui-toml/excessive_nesting/below/clippy.toml
+++ /dev/null
@@ -1 +0,0 @@
-excessive-nesting-threshold = 3
diff --git a/tests/ui-toml/excessive_nesting/default/clippy.toml b/tests/ui-toml/excessive_nesting/default/clippy.toml
index b01e482e485..e8b115a0f7c 100644
--- a/tests/ui-toml/excessive_nesting/default/clippy.toml
+++ b/tests/ui-toml/excessive_nesting/default/clippy.toml
@@ -1 +1 @@
-excessive-nesting-threshold = 10
+excessive-nesting-threshold = 0
diff --git a/tests/ui-toml/excessive_nesting/excessive_nesting.below.stderr b/tests/ui-toml/excessive_nesting/excessive_nesting.below.stderr
deleted file mode 100644
index 1f069437dfe..00000000000
--- a/tests/ui-toml/excessive_nesting/excessive_nesting.below.stderr
+++ /dev/null
@@ -1,369 +0,0 @@
-error: this block is too nested
-  --> $DIR/auxiliary/mod.rs:6:13
-   |
-LL | /             mod d {
-LL | |                 mod e {}
-LL | |             }
-   | |_____________^
-   |
-   = help: try refactoring your code to minimize nesting
-   = note: `-D clippy::excessive-nesting` implied by `-D warnings`
-
-error: this block is too nested
-  --> $DIR/auxiliary/mod.rs:15:7
-   |
-LL |     {{{}}}
-   |       ^^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:24:21
-   |
-LL |               let z = {
-   |  _____________________^
-LL | |                 let w = { 3 };
-LL | |                 w
-LL | |             };
-   | |_____________^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:68:24
-   |
-LL |               pub fn b() {
-   |  ________________________^
-LL | |                 struct C;
-LL | |
-LL | |                 impl C {
-LL | |                     pub fn c() {}
-LL | |                 }
-LL | |             }
-   | |_____________^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:84:21
-   |
-LL |               fn cc() {
-   |  _____________________^
-LL | |                 let x = { 1 }; // not a warning, but cc is
-LL | |             }
-   | |_____________^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:88:21
-   |
-LL |             let x = { 1 }; // warning
-   |                     ^^^^^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:101:13
-   |
-LL | /             pub mod d {
-LL | |                 pub mod e {
-LL | |                     pub mod f {}
-LL | |                 } // not here
-LL | |             } // only warning should be here
-   | |_____________^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:115:17
-   |
-LL |     a_but_not({{{{{{{{0}}}}}}}});
-   |                 ^^^^^^^^^^^^^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:116:11
-   |
-LL |     a.a({{{{{{{{{0}}}}}}}}});
-   |           ^^^^^^^^^^^^^^^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:117:11
-   |
-LL |     (0, {{{{{{{1}}}}}}});
-   |           ^^^^^^^^^^^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:121:21
-   |
-LL |               if true {
-   |  _____________________^
-LL | |                 if true {
-LL | |                     if true {
-LL | |
-LL | |                     }
-LL | |                 }
-LL | |             }
-   | |_____________^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:133:25
-   |
-LL |               let y = (|| {
-   |  _________________________^
-LL | |                 let z = (|| {
-LL | |                     let w = { 3 };
-LL | |                     w
-LL | |                 })();
-LL | |                 z
-LL | |             })();
-   | |_____________^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:148:36
-   |
-LL |     !{boo as u32 + !{boo as u32 + !{boo as u32}}};
-   |                                    ^^^^^^^^^^^^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:152:12
-   |
-LL |     y += {{{{{5}}}}};
-   |            ^^^^^^^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:153:19
-   |
-LL |     let z = y + {{{{{{{{{5}}}}}}}}};
-   |                   ^^^^^^^^^^^^^^^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:154:11
-   |
-LL |     [0, {{{{{{{{{{0}}}}}}}}}}];
-   |           ^^^^^^^^^^^^^^^^^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:155:24
-   |
-LL |     let mut xx = [0; {{{{{{{{100}}}}}}}}];
-   |                        ^^^^^^^^^^^^^^^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:156:10
-   |
-LL |     xx[{{{{{{{{{{{{{{{{{{{{{{{{3}}}}}}}}}}}}}}}}}}}}}}}}];
-   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:157:12
-   |
-LL |     &mut {{{{{{{{{{y}}}}}}}}}};
-   |            ^^^^^^^^^^^^^^^^^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:159:16
-   |
-LL |     for i in {{{{xx}}}} {{{{{{{{}}}}}}}}
-   |                ^^^^^^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:159:27
-   |
-LL |     for i in {{{{xx}}}} {{{{{{{{}}}}}}}}
-   |                           ^^^^^^^^^^^^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:161:27
-   |
-LL |     while let Some(i) = {{{{{{Some(1)}}}}}} {{{{{{{}}}}}}}
-   |                           ^^^^^^^^^^^^^^^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:161:47
-   |
-LL |     while let Some(i) = {{{{{{Some(1)}}}}}} {{{{{{{}}}}}}}
-   |                                               ^^^^^^^^^^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:163:13
-   |
-LL |     while {{{{{{{{true}}}}}}}} {{{{{{{{{}}}}}}}}}
-   |             ^^^^^^^^^^^^^^^^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:163:34
-   |
-LL |     while {{{{{{{{true}}}}}}}} {{{{{{{{{}}}}}}}}}
-   |                                  ^^^^^^^^^^^^^^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:165:22
-   |
-LL |     let d = D { d: {{{{{{{{{{{{{{{{{{{{{{{3}}}}}}}}}}}}}}}}}}}}}}} };
-   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:167:7
-   |
-LL |     {{{{1;}}}}..{{{{{{3}}}}}};
-   |       ^^^^^^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:167:19
-   |
-LL |     {{{{1;}}}}..{{{{{{3}}}}}};
-   |                   ^^^^^^^^^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:168:7
-   |
-LL |     {{{{1;}}}}..={{{{{{{{{{{{{{{{{{{{{{{{{{6}}}}}}}}}}}}}}}}}}}}}}}}}};
-   |       ^^^^^^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:168:20
-   |
-LL |     {{{{1;}}}}..={{{{{{{{{{{{{{{{{{{{{{{{{{6}}}}}}}}}}}}}}}}}}}}}}}}}};
-   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:169:9
-   |
-LL |     ..{{{{{{{5}}}}}}};
-   |         ^^^^^^^^^^^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:170:10
-   |
-LL |     ..={{{{{3}}}}};
-   |          ^^^^^^^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:171:7
-   |
-LL |     {{{{{1;}}}}}..;
-   |       ^^^^^^^^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:173:19
-   |
-LL |     loop { break {{{{1}}}} };
-   |                   ^^^^^^^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:174:12
-   |
-LL |     loop {{{{{{}}}}}}
-   |            ^^^^^^^^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:176:13
-   |
-LL |     match {{{{{{true}}}}}} {
-   |             ^^^^^^^^^^^^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:177:19
-   |
-LL |         true => {{{{}}}},
-   |                   ^^^^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:178:20
-   |
-LL |         false => {{{{}}}},
-   |                    ^^^^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:183:13
-   |
-LL | /             {
-LL | |                 {
-LL | |                     println!("warning! :)");
-LL | |                 }
-LL | |             }
-   | |_____________^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:193:27
-   |
-LL |     async fn c() -> u32 {{{{{{{0}}}}}}}
-   |                           ^^^^^^^^^^^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:199:7
-   |
-LL |     {{{{b().await}}}};
-   |       ^^^^^^^^^^^^^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: aborting due to 41 previous errors
-
diff --git a/tests/ui-toml/excessive_nesting/excessive_nesting.default.stderr b/tests/ui-toml/excessive_nesting/excessive_nesting.default.stderr
index 02fa2cdcf9f..e69de29bb2d 100644
--- a/tests/ui-toml/excessive_nesting/excessive_nesting.default.stderr
+++ b/tests/ui-toml/excessive_nesting/excessive_nesting.default.stderr
@@ -1,43 +0,0 @@
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:154:18
-   |
-LL |     [0, {{{{{{{{{{0}}}}}}}}}}];
-   |                  ^^^
-   |
-   = help: try refactoring your code to minimize nesting
-   = note: `-D clippy::excessive-nesting` implied by `-D warnings`
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:156:17
-   |
-LL |     xx[{{{{{{{{{{{{{{{{{{{{{{{{3}}}}}}}}}}}}}}}}}}}}}}}}];
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:157:19
-   |
-LL |     &mut {{{{{{{{{{y}}}}}}}}}};
-   |                   ^^^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:165:29
-   |
-LL |     let d = D { d: {{{{{{{{{{{{{{{{{{{{{{{3}}}}}}}}}}}}}}}}}}}}}}} };
-   |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:168:27
-   |
-LL |     {{{{1;}}}}..={{{{{{{{{{{{{{{{{{{{{{{{{{6}}}}}}}}}}}}}}}}}}}}}}}}}};
-   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: aborting due to 5 previous errors
-
diff --git a/tests/ui-toml/excessive_nesting/excessive_nesting.rs b/tests/ui-toml/excessive_nesting/excessive_nesting.rs
index 745031db1eb..5e436b97ee8 100644
--- a/tests/ui-toml/excessive_nesting/excessive_nesting.rs
+++ b/tests/ui-toml/excessive_nesting/excessive_nesting.rs
@@ -1,6 +1,6 @@
 //@aux-build:macro_rules.rs
-//@revisions: below default
-//@[below] rustc-env:CLIPPY_CONF_DIR=tests/ui-toml/excessive_nesting/below
+//@revisions: set default
+//@[set] rustc-env:CLIPPY_CONF_DIR=tests/ui-toml/excessive_nesting/set
 //@[default] rustc-env:CLIPPY_CONF_DIR=tests/ui-toml/excessive_nesting/default
 #![rustfmt::skip]
 #![feature(custom_inner_attributes)]
diff --git a/tests/ui-toml/excessive_nesting/excessive_nesting.set.stderr b/tests/ui-toml/excessive_nesting/excessive_nesting.set.stderr
new file mode 100644
index 00000000000..1f069437dfe
--- /dev/null
+++ b/tests/ui-toml/excessive_nesting/excessive_nesting.set.stderr
@@ -0,0 +1,369 @@
+error: this block is too nested
+  --> $DIR/auxiliary/mod.rs:6:13
+   |
+LL | /             mod d {
+LL | |                 mod e {}
+LL | |             }
+   | |_____________^
+   |
+   = help: try refactoring your code to minimize nesting
+   = note: `-D clippy::excessive-nesting` implied by `-D warnings`
+
+error: this block is too nested
+  --> $DIR/auxiliary/mod.rs:15:7
+   |
+LL |     {{{}}}
+   |       ^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:24:21
+   |
+LL |               let z = {
+   |  _____________________^
+LL | |                 let w = { 3 };
+LL | |                 w
+LL | |             };
+   | |_____________^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:68:24
+   |
+LL |               pub fn b() {
+   |  ________________________^
+LL | |                 struct C;
+LL | |
+LL | |                 impl C {
+LL | |                     pub fn c() {}
+LL | |                 }
+LL | |             }
+   | |_____________^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:84:21
+   |
+LL |               fn cc() {
+   |  _____________________^
+LL | |                 let x = { 1 }; // not a warning, but cc is
+LL | |             }
+   | |_____________^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:88:21
+   |
+LL |             let x = { 1 }; // warning
+   |                     ^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:101:13
+   |
+LL | /             pub mod d {
+LL | |                 pub mod e {
+LL | |                     pub mod f {}
+LL | |                 } // not here
+LL | |             } // only warning should be here
+   | |_____________^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:115:17
+   |
+LL |     a_but_not({{{{{{{{0}}}}}}}});
+   |                 ^^^^^^^^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:116:11
+   |
+LL |     a.a({{{{{{{{{0}}}}}}}}});
+   |           ^^^^^^^^^^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:117:11
+   |
+LL |     (0, {{{{{{{1}}}}}}});
+   |           ^^^^^^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:121:21
+   |
+LL |               if true {
+   |  _____________________^
+LL | |                 if true {
+LL | |                     if true {
+LL | |
+LL | |                     }
+LL | |                 }
+LL | |             }
+   | |_____________^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:133:25
+   |
+LL |               let y = (|| {
+   |  _________________________^
+LL | |                 let z = (|| {
+LL | |                     let w = { 3 };
+LL | |                     w
+LL | |                 })();
+LL | |                 z
+LL | |             })();
+   | |_____________^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:148:36
+   |
+LL |     !{boo as u32 + !{boo as u32 + !{boo as u32}}};
+   |                                    ^^^^^^^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:152:12
+   |
+LL |     y += {{{{{5}}}}};
+   |            ^^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:153:19
+   |
+LL |     let z = y + {{{{{{{{{5}}}}}}}}};
+   |                   ^^^^^^^^^^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:154:11
+   |
+LL |     [0, {{{{{{{{{{0}}}}}}}}}}];
+   |           ^^^^^^^^^^^^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:155:24
+   |
+LL |     let mut xx = [0; {{{{{{{{100}}}}}}}}];
+   |                        ^^^^^^^^^^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:156:10
+   |
+LL |     xx[{{{{{{{{{{{{{{{{{{{{{{{{3}}}}}}}}}}}}}}}}}}}}}}}}];
+   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:157:12
+   |
+LL |     &mut {{{{{{{{{{y}}}}}}}}}};
+   |            ^^^^^^^^^^^^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:159:16
+   |
+LL |     for i in {{{{xx}}}} {{{{{{{{}}}}}}}}
+   |                ^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:159:27
+   |
+LL |     for i in {{{{xx}}}} {{{{{{{{}}}}}}}}
+   |                           ^^^^^^^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:161:27
+   |
+LL |     while let Some(i) = {{{{{{Some(1)}}}}}} {{{{{{{}}}}}}}
+   |                           ^^^^^^^^^^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:161:47
+   |
+LL |     while let Some(i) = {{{{{{Some(1)}}}}}} {{{{{{{}}}}}}}
+   |                                               ^^^^^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:163:13
+   |
+LL |     while {{{{{{{{true}}}}}}}} {{{{{{{{{}}}}}}}}}
+   |             ^^^^^^^^^^^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:163:34
+   |
+LL |     while {{{{{{{{true}}}}}}}} {{{{{{{{{}}}}}}}}}
+   |                                  ^^^^^^^^^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:165:22
+   |
+LL |     let d = D { d: {{{{{{{{{{{{{{{{{{{{{{{3}}}}}}}}}}}}}}}}}}}}}}} };
+   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:167:7
+   |
+LL |     {{{{1;}}}}..{{{{{{3}}}}}};
+   |       ^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:167:19
+   |
+LL |     {{{{1;}}}}..{{{{{{3}}}}}};
+   |                   ^^^^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:168:7
+   |
+LL |     {{{{1;}}}}..={{{{{{{{{{{{{{{{{{{{{{{{{{6}}}}}}}}}}}}}}}}}}}}}}}}}};
+   |       ^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:168:20
+   |
+LL |     {{{{1;}}}}..={{{{{{{{{{{{{{{{{{{{{{{{{{6}}}}}}}}}}}}}}}}}}}}}}}}}};
+   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:169:9
+   |
+LL |     ..{{{{{{{5}}}}}}};
+   |         ^^^^^^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:170:10
+   |
+LL |     ..={{{{{3}}}}};
+   |          ^^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:171:7
+   |
+LL |     {{{{{1;}}}}}..;
+   |       ^^^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:173:19
+   |
+LL |     loop { break {{{{1}}}} };
+   |                   ^^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:174:12
+   |
+LL |     loop {{{{{{}}}}}}
+   |            ^^^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:176:13
+   |
+LL |     match {{{{{{true}}}}}} {
+   |             ^^^^^^^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:177:19
+   |
+LL |         true => {{{{}}}},
+   |                   ^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:178:20
+   |
+LL |         false => {{{{}}}},
+   |                    ^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:183:13
+   |
+LL | /             {
+LL | |                 {
+LL | |                     println!("warning! :)");
+LL | |                 }
+LL | |             }
+   | |_____________^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:193:27
+   |
+LL |     async fn c() -> u32 {{{{{{{0}}}}}}}
+   |                           ^^^^^^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:199:7
+   |
+LL |     {{{{b().await}}}};
+   |       ^^^^^^^^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: aborting due to 41 previous errors
+
diff --git a/tests/ui-toml/excessive_nesting/set/clippy.toml b/tests/ui-toml/excessive_nesting/set/clippy.toml
new file mode 100644
index 00000000000..10be2751a86
--- /dev/null
+++ b/tests/ui-toml/excessive_nesting/set/clippy.toml
@@ -0,0 +1 @@
+excessive-nesting-threshold = 3
-- 
cgit 1.4.1-3-g733a5


From 5da34559ee6a1cf34ddfc889513f205c819bc112 Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Wed, 7 Jun 2023 18:22:17 -0500
Subject: Check if from proc macro and better tests

---
 clippy_lints/src/excessive_nesting.rs              |  17 +-
 tests/ui-toml/excessive_nesting/above/clippy.toml  |   1 +
 .../excessive_nesting/auxiliary/macro_rules.rs     |   7 -
 tests/ui-toml/excessive_nesting/auxiliary/mod.rs   |  16 -
 .../excessive_nesting/auxiliary/proc_macros.rs     | 476 +++++++++++++++++++++
 .../ui-toml/excessive_nesting/default/clippy.toml  |   1 -
 .../excessive_nesting.above.stderr                 | 314 ++++++++++++++
 .../excessive_nesting.default.stderr               |   0
 .../ui-toml/excessive_nesting/excessive_nesting.rs |  13 +-
 .../excessive_nesting/excessive_nesting.set.stderr | 100 ++---
 .../excessive_nesting/excessive_nesting.stderr     | 369 ----------------
 .../toml_unknown_key/conf_unknown_key.stderr       |   1 +
 12 files changed, 852 insertions(+), 463 deletions(-)
 create mode 100644 tests/ui-toml/excessive_nesting/above/clippy.toml
 delete mode 100644 tests/ui-toml/excessive_nesting/auxiliary/macro_rules.rs
 delete mode 100644 tests/ui-toml/excessive_nesting/auxiliary/mod.rs
 create mode 100644 tests/ui-toml/excessive_nesting/auxiliary/proc_macros.rs
 delete mode 100644 tests/ui-toml/excessive_nesting/default/clippy.toml
 create mode 100644 tests/ui-toml/excessive_nesting/excessive_nesting.above.stderr
 delete mode 100644 tests/ui-toml/excessive_nesting/excessive_nesting.default.stderr
 delete mode 100644 tests/ui-toml/excessive_nesting/excessive_nesting.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/excessive_nesting.rs b/clippy_lints/src/excessive_nesting.rs
index 1d68d7f9478..1c6cd27789d 100644
--- a/clippy_lints/src/excessive_nesting.rs
+++ b/clippy_lints/src/excessive_nesting.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::{diagnostics::span_lint_and_help, source::snippet};
 use rustc_ast::{
     node_id::NodeSet,
     visit::{walk_block, walk_item, Visitor},
@@ -86,6 +86,10 @@ impl ExcessiveNesting {
 
 impl EarlyLintPass for ExcessiveNesting {
     fn check_crate(&mut self, cx: &EarlyContext<'_>, krate: &Crate) {
+        if self.excessive_nesting_threshold == 0 {
+            return;
+        }
+
         let mut visitor = NestingVisitor {
             conf: self,
             cx,
@@ -114,9 +118,7 @@ struct NestingVisitor<'conf, 'cx> {
 
 impl NestingVisitor<'_, '_> {
     fn check_indent(&mut self, span: Span, id: NodeId) -> bool {
-        let threshold = self.conf.excessive_nesting_threshold;
-
-        if threshold != 0 && self.nest_level > threshold && !in_external_macro(self.cx.sess(), span) {
+        if self.nest_level > self.conf.excessive_nesting_threshold && !in_external_macro(self.cx.sess(), span) {
             self.conf.nodes.insert(id);
 
             return true;
@@ -132,6 +134,13 @@ impl<'conf, 'cx> Visitor<'_> for NestingVisitor<'conf, 'cx> {
             return;
         }
 
+        // TODO: This should be rewritten using `LateLintPass` so we can use `is_from_proc_macro` instead,
+        // but for now, this is fine.
+        let snippet = snippet(self.cx, block.span, "{}").trim().to_owned();
+        if !snippet.starts_with('{') || !snippet.ends_with('}') {
+            return;
+        }
+
         self.nest_level += 1;
 
         if !self.check_indent(block.span, block.id) {
diff --git a/tests/ui-toml/excessive_nesting/above/clippy.toml b/tests/ui-toml/excessive_nesting/above/clippy.toml
new file mode 100644
index 00000000000..e60ac978cac
--- /dev/null
+++ b/tests/ui-toml/excessive_nesting/above/clippy.toml
@@ -0,0 +1 @@
+excessive-nesting-threshold = 4
diff --git a/tests/ui-toml/excessive_nesting/auxiliary/macro_rules.rs b/tests/ui-toml/excessive_nesting/auxiliary/macro_rules.rs
deleted file mode 100644
index 86663db68f2..00000000000
--- a/tests/ui-toml/excessive_nesting/auxiliary/macro_rules.rs
+++ /dev/null
@@ -1,7 +0,0 @@
-#[rustfmt::skip]
-#[macro_export]
-macro_rules! excessive_nesting {
-    () => {{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{
-        println!("hi!!")
-    }}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}
-}
diff --git a/tests/ui-toml/excessive_nesting/auxiliary/mod.rs b/tests/ui-toml/excessive_nesting/auxiliary/mod.rs
deleted file mode 100644
index 967b3af3bca..00000000000
--- a/tests/ui-toml/excessive_nesting/auxiliary/mod.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-#![rustfmt::skip]
-
-mod a {
-    mod b {
-        mod c {
-            mod d {
-                mod e {}
-            }
-        }
-    }
-}
-
-fn main() {
-    // this should lint
-    {{{}}}
-}
diff --git a/tests/ui-toml/excessive_nesting/auxiliary/proc_macros.rs b/tests/ui-toml/excessive_nesting/auxiliary/proc_macros.rs
new file mode 100644
index 00000000000..87620fe91ba
--- /dev/null
+++ b/tests/ui-toml/excessive_nesting/auxiliary/proc_macros.rs
@@ -0,0 +1,476 @@
+//@compile-flags: --emit=link
+//@no-prefer-dynamic
+
+// NOTE: Copied from `ui/auxiliary/proc_macros.rs`, couldn't get `../` to work for some reason
+
+#![crate_type = "proc-macro"]
+#![feature(let_chains)]
+#![feature(proc_macro_span)]
+#![allow(dead_code)]
+
+extern crate proc_macro;
+
+use core::mem;
+use proc_macro::{
+    token_stream::IntoIter,
+    Delimiter::{self, Brace, Parenthesis},
+    Group, Ident, Literal, Punct,
+    Spacing::{self, Alone, Joint},
+    Span, TokenStream, TokenTree as TT,
+};
+
+type Result<T> = core::result::Result<T, TokenStream>;
+
+/// Make a `compile_error!` pointing to the given span.
+fn make_error(msg: &str, span: Span) -> TokenStream {
+    TokenStream::from_iter([
+        TT::Ident(Ident::new("compile_error", span)),
+        TT::Punct(punct_with_span('!', Alone, span)),
+        TT::Group({
+            let mut msg = Literal::string(msg);
+            msg.set_span(span);
+            group_with_span(Parenthesis, TokenStream::from_iter([TT::Literal(msg)]), span)
+        }),
+    ])
+}
+
+fn expect_tt<T>(tt: Option<TT>, f: impl FnOnce(TT) -> Option<T>, expected: &str, span: Span) -> Result<T> {
+    match tt {
+        None => Err(make_error(
+            &format!("unexpected end of input, expected {expected}"),
+            span,
+        )),
+        Some(tt) => {
+            let span = tt.span();
+            match f(tt) {
+                Some(x) => Ok(x),
+                None => Err(make_error(&format!("unexpected token, expected {expected}"), span)),
+            }
+        },
+    }
+}
+
+fn punct_with_span(c: char, spacing: Spacing, span: Span) -> Punct {
+    let mut p = Punct::new(c, spacing);
+    p.set_span(span);
+    p
+}
+
+fn group_with_span(delimiter: Delimiter, stream: TokenStream, span: Span) -> Group {
+    let mut g = Group::new(delimiter, stream);
+    g.set_span(span);
+    g
+}
+
+/// Token used to escape the following token from the macro's span rules.
+const ESCAPE_CHAR: char = '$';
+
+/// Takes a single token followed by a sequence of tokens. Returns the sequence of tokens with their
+/// span set to that of the first token. Tokens may be escaped with either `#ident` or `#(tokens)`.
+#[proc_macro]
+pub fn with_span(input: TokenStream) -> TokenStream {
+    let mut iter = input.into_iter();
+    let span = iter.next().unwrap().span();
+    let mut res = TokenStream::new();
+    if let Err(e) = write_with_span(span, iter, &mut res) {
+        e
+    } else {
+        res
+    }
+}
+
+/// Takes a sequence of tokens and return the tokens with the span set such that they appear to be
+/// from an external macro. Tokens may be escaped with either `#ident` or `#(tokens)`.
+#[proc_macro]
+pub fn external(input: TokenStream) -> TokenStream {
+    let mut res = TokenStream::new();
+    if let Err(e) = write_with_span(Span::mixed_site(), input.into_iter(), &mut res) {
+        e
+    } else {
+        res
+    }
+}
+
+/// Copies all the tokens, replacing all their spans with the given span. Tokens can be escaped
+/// either by `#ident` or `#(tokens)`.
+fn write_with_span(s: Span, mut input: IntoIter, out: &mut TokenStream) -> Result<()> {
+    while let Some(tt) = input.next() {
+        match tt {
+            TT::Punct(p) if p.as_char() == ESCAPE_CHAR => {
+                expect_tt(
+                    input.next(),
+                    |tt| match tt {
+                        tt @ (TT::Ident(_) | TT::Literal(_)) => {
+                            out.extend([tt]);
+                            Some(())
+                        },
+                        TT::Punct(mut p) if p.as_char() == ESCAPE_CHAR => {
+                            p.set_span(s);
+                            out.extend([TT::Punct(p)]);
+                            Some(())
+                        },
+                        TT::Group(g) if g.delimiter() == Parenthesis => {
+                            out.extend([TT::Group(group_with_span(Delimiter::None, g.stream(), g.span()))]);
+                            Some(())
+                        },
+                        _ => None,
+                    },
+                    "an ident, a literal, or parenthesized tokens",
+                    p.span(),
+                )?;
+            },
+            TT::Group(g) => {
+                let mut stream = TokenStream::new();
+                write_with_span(s, g.stream().into_iter(), &mut stream)?;
+                out.extend([TT::Group(group_with_span(g.delimiter(), stream, s))]);
+            },
+            mut tt => {
+                tt.set_span(s);
+                out.extend([tt]);
+            },
+        }
+    }
+    Ok(())
+}
+
+/// Within the item this attribute is attached to, an `inline!` macro is available which expands the
+/// contained tokens as though they came from a macro expansion.
+///
+/// Within the `inline!` macro, any token preceded by `$` is passed as though it were an argument
+/// with an automatically chosen fragment specifier. `$ident` will be passed as `ident`, `$1` or
+/// `$"literal"` will be passed as `literal`, `$'lt` will be passed as `lifetime`, and `$(...)` will
+/// pass the contained tokens as a `tt` sequence (the wrapping parenthesis are removed). If another
+/// specifier is required it can be specified within parenthesis like `$(@expr ...)`. This will
+/// expand the remaining tokens as a single argument.
+///
+/// Multiple `inline!` macros may be nested within each other. This will expand as nested macro
+/// calls. However, any arguments will be passed as though they came from the outermost context.
+#[proc_macro_attribute]
+pub fn inline_macros(args: TokenStream, input: TokenStream) -> TokenStream {
+    let mut args = args.into_iter();
+    let mac_name = match args.next() {
+        Some(TT::Ident(name)) => Some(name),
+        Some(tt) => {
+            return make_error(
+                "unexpected argument, expected either an ident or no arguments",
+                tt.span(),
+            );
+        },
+        None => None,
+    };
+    if let Some(tt) = args.next() {
+        return make_error(
+            "unexpected argument, expected either an ident or no arguments",
+            tt.span(),
+        );
+    };
+
+    let mac_name = if let Some(mac_name) = mac_name {
+        Ident::new(&format!("__inline_mac_{mac_name}"), Span::call_site())
+    } else {
+        let mut input = match LookaheadIter::new(input.clone().into_iter()) {
+            Some(x) => x,
+            None => return input,
+        };
+        loop {
+            match input.next() {
+                None => break Ident::new("__inline_mac", Span::call_site()),
+                Some(TT::Ident(kind)) => match &*kind.to_string() {
+                    "impl" => break Ident::new("__inline_mac_impl", Span::call_site()),
+                    kind @ ("struct" | "enum" | "union" | "fn" | "mod" | "trait" | "type" | "const" | "static") => {
+                        if let TT::Ident(name) = &input.tt {
+                            break Ident::new(&format!("__inline_mac_{kind}_{name}"), Span::call_site());
+                        } else {
+                            break Ident::new(&format!("__inline_mac_{kind}"), Span::call_site());
+                        }
+                    },
+                    _ => {},
+                },
+                _ => {},
+            }
+        }
+    };
+
+    let mut expander = Expander::default();
+    let mut mac = MacWriter::new(mac_name);
+    if let Err(e) = expander.expand(input.into_iter(), &mut mac) {
+        return e;
+    }
+    let mut out = TokenStream::new();
+    mac.finish(&mut out);
+    out.extend(expander.expn);
+    out
+}
+
+/// Wraps a `TokenStream` iterator with a single token lookahead.
+struct LookaheadIter {
+    tt: TT,
+    iter: IntoIter,
+}
+impl LookaheadIter {
+    fn new(mut iter: IntoIter) -> Option<Self> {
+        iter.next().map(|tt| Self { tt, iter })
+    }
+
+    /// Get's the lookahead token, replacing it with the next token in the stream.
+    /// Note: If there isn't a next token, this will not return the lookahead token.
+    fn next(&mut self) -> Option<TT> {
+        self.iter.next().map(|tt| mem::replace(&mut self.tt, tt))
+    }
+}
+
+/// Builds the macro used to implement all the `inline!` macro calls.
+struct MacWriter {
+    name: Ident,
+    macros: TokenStream,
+    next_idx: usize,
+}
+impl MacWriter {
+    fn new(name: Ident) -> Self {
+        Self {
+            name,
+            macros: TokenStream::new(),
+            next_idx: 0,
+        }
+    }
+
+    /// Inserts a new `inline!` call.
+    fn insert(&mut self, name_span: Span, bang_span: Span, body: Group, expander: &mut Expander) -> Result<()> {
+        let idx = self.next_idx;
+        self.next_idx += 1;
+
+        let mut inner = Expander::for_arm(idx);
+        inner.expand(body.stream().into_iter(), self)?;
+        let new_arm = inner.arm.unwrap();
+
+        self.macros.extend([
+            TT::Group(Group::new(Parenthesis, new_arm.args_def)),
+            TT::Punct(Punct::new('=', Joint)),
+            TT::Punct(Punct::new('>', Alone)),
+            TT::Group(Group::new(Parenthesis, inner.expn)),
+            TT::Punct(Punct::new(';', Alone)),
+        ]);
+
+        expander.expn.extend([
+            TT::Ident({
+                let mut name = self.name.clone();
+                name.set_span(name_span);
+                name
+            }),
+            TT::Punct(punct_with_span('!', Alone, bang_span)),
+        ]);
+        let mut call_body = TokenStream::from_iter([TT::Literal(Literal::usize_unsuffixed(idx))]);
+        if let Some(arm) = expander.arm.as_mut() {
+            if !new_arm.args.is_empty() {
+                arm.add_sub_args(new_arm.args, &mut call_body);
+            }
+        } else {
+            call_body.extend(new_arm.args);
+        }
+        let mut g = Group::new(body.delimiter(), call_body);
+        g.set_span(body.span());
+        expander.expn.extend([TT::Group(g)]);
+        Ok(())
+    }
+
+    /// Creates the macro definition.
+    fn finish(self, out: &mut TokenStream) {
+        if self.next_idx != 0 {
+            out.extend([
+                TT::Ident(Ident::new("macro_rules", Span::call_site())),
+                TT::Punct(Punct::new('!', Alone)),
+                TT::Ident(self.name),
+                TT::Group(Group::new(Brace, self.macros)),
+            ])
+        }
+    }
+}
+
+struct MacroArm {
+    args_def: TokenStream,
+    args: Vec<TT>,
+}
+impl MacroArm {
+    fn add_single_arg_def(&mut self, kind: &str, dollar_span: Span, arg_span: Span, out: &mut TokenStream) {
+        let mut name = Ident::new(&format!("_{}", self.args.len()), Span::call_site());
+        self.args_def.extend([
+            TT::Punct(Punct::new('$', Alone)),
+            TT::Ident(name.clone()),
+            TT::Punct(Punct::new(':', Alone)),
+            TT::Ident(Ident::new(kind, Span::call_site())),
+        ]);
+        name.set_span(arg_span);
+        out.extend([TT::Punct(punct_with_span('$', Alone, dollar_span)), TT::Ident(name)]);
+    }
+
+    fn add_parenthesized_arg_def(&mut self, kind: Ident, dollar_span: Span, arg_span: Span, out: &mut TokenStream) {
+        let mut name = Ident::new(&format!("_{}", self.args.len()), Span::call_site());
+        self.args_def.extend([TT::Group(Group::new(
+            Parenthesis,
+            TokenStream::from_iter([
+                TT::Punct(Punct::new('$', Alone)),
+                TT::Ident(name.clone()),
+                TT::Punct(Punct::new(':', Alone)),
+                TT::Ident(kind),
+            ]),
+        ))]);
+        name.set_span(arg_span);
+        out.extend([TT::Punct(punct_with_span('$', Alone, dollar_span)), TT::Ident(name)]);
+    }
+
+    fn add_multi_arg_def(&mut self, dollar_span: Span, arg_span: Span, out: &mut TokenStream) {
+        let mut name = Ident::new(&format!("_{}", self.args.len()), Span::call_site());
+        self.args_def.extend([TT::Group(Group::new(
+            Parenthesis,
+            TokenStream::from_iter([
+                TT::Punct(Punct::new('$', Alone)),
+                TT::Group(Group::new(
+                    Parenthesis,
+                    TokenStream::from_iter([
+                        TT::Punct(Punct::new('$', Alone)),
+                        TT::Ident(name.clone()),
+                        TT::Punct(Punct::new(':', Alone)),
+                        TT::Ident(Ident::new("tt", Span::call_site())),
+                    ]),
+                )),
+                TT::Punct(Punct::new('*', Alone)),
+            ]),
+        ))]);
+        name.set_span(arg_span);
+        out.extend([
+            TT::Punct(punct_with_span('$', Alone, dollar_span)),
+            TT::Group(group_with_span(
+                Parenthesis,
+                TokenStream::from_iter([TT::Punct(punct_with_span('$', Alone, dollar_span)), TT::Ident(name)]),
+                dollar_span,
+            )),
+            TT::Punct(punct_with_span('*', Alone, dollar_span)),
+        ]);
+    }
+
+    fn add_arg(&mut self, dollar_span: Span, tt: TT, input: &mut IntoIter, out: &mut TokenStream) -> Result<()> {
+        match tt {
+            TT::Punct(p) if p.as_char() == ESCAPE_CHAR => out.extend([TT::Punct(p)]),
+            TT::Punct(p) if p.as_char() == '\'' && p.spacing() == Joint => {
+                let lt_name = expect_tt(
+                    input.next(),
+                    |tt| match tt {
+                        TT::Ident(x) => Some(x),
+                        _ => None,
+                    },
+                    "lifetime name",
+                    p.span(),
+                )?;
+                let arg_span = p.span().join(lt_name.span()).unwrap_or(p.span());
+                self.add_single_arg_def("lifetime", dollar_span, arg_span, out);
+                self.args.extend([TT::Punct(p), TT::Ident(lt_name)]);
+            },
+            TT::Ident(x) => {
+                self.add_single_arg_def("ident", dollar_span, x.span(), out);
+                self.args.push(TT::Ident(x));
+            },
+            TT::Literal(x) => {
+                self.add_single_arg_def("literal", dollar_span, x.span(), out);
+                self.args.push(TT::Literal(x));
+            },
+            TT::Group(g) if g.delimiter() == Parenthesis => {
+                let mut inner = g.stream().into_iter();
+                if let Some(TT::Punct(p)) = inner.next()
+                    && p.as_char() == '@'
+                {
+                    let kind = expect_tt(
+                        inner.next(),
+                        |tt| match tt {
+                            TT::Ident(kind) => Some(kind),
+                            _ => None,
+                        },
+                        "a macro fragment specifier",
+                        p.span(),
+                    )?;
+                    self.add_parenthesized_arg_def(kind, dollar_span, g.span(), out);
+                    self.args.push(TT::Group(group_with_span(Parenthesis, inner.collect(), g.span())))
+                } else {
+                    self.add_multi_arg_def(dollar_span, g.span(), out);
+                    self.args.push(TT::Group(g));
+                }
+            },
+            tt => return Err(make_error("unsupported escape", tt.span())),
+        };
+        Ok(())
+    }
+
+    fn add_sub_args(&mut self, args: Vec<TT>, out: &mut TokenStream) {
+        self.add_multi_arg_def(Span::call_site(), Span::call_site(), out);
+        self.args
+            .extend([TT::Group(Group::new(Parenthesis, TokenStream::from_iter(args)))]);
+    }
+}
+
+#[derive(Default)]
+struct Expander {
+    arm: Option<MacroArm>,
+    expn: TokenStream,
+}
+impl Expander {
+    fn for_arm(idx: usize) -> Self {
+        Self {
+            arm: Some(MacroArm {
+                args_def: TokenStream::from_iter([TT::Literal(Literal::usize_unsuffixed(idx))]),
+                args: Vec::new(),
+            }),
+            expn: TokenStream::new(),
+        }
+    }
+
+    fn write_tt(&mut self, tt: TT, mac: &mut MacWriter) -> Result<()> {
+        match tt {
+            TT::Group(g) => {
+                let outer = mem::take(&mut self.expn);
+                self.expand(g.stream().into_iter(), mac)?;
+                let inner = mem::replace(&mut self.expn, outer);
+                self.expn
+                    .extend([TT::Group(group_with_span(g.delimiter(), inner, g.span()))]);
+            },
+            tt => self.expn.extend([tt]),
+        }
+        Ok(())
+    }
+
+    fn expand(&mut self, input: IntoIter, mac: &mut MacWriter) -> Result<()> {
+        let Some(mut input) = LookaheadIter::new(input) else {
+            return Ok(());
+        };
+        while let Some(tt) = input.next() {
+            if let TT::Punct(p) = &tt
+                && p.as_char() == ESCAPE_CHAR
+                && let Some(arm) = self.arm.as_mut()
+            {
+                arm.add_arg(p.span(), mem::replace(&mut input.tt, tt), &mut input.iter, &mut self.expn)?;
+                if input.next().is_none() {
+                    return Ok(());
+                }
+            } else if let TT::Punct(p) = &input.tt
+                && p.as_char() == '!'
+                && let TT::Ident(name) = &tt
+                && name.to_string() == "inline"
+            {
+                let g = expect_tt(
+                    input.iter.next(),
+                    |tt| match tt {
+                        TT::Group(g) => Some(g),
+                        _ => None,
+                    },
+                    "macro arguments",
+                    p.span(),
+                )?;
+                mac.insert(name.span(), p.span(), g, self)?;
+                if input.next().is_none() {
+                    return Ok(());
+                }
+            } else {
+                self.write_tt(tt, mac)?;
+            }
+        }
+        self.write_tt(input.tt, mac)
+    }
+}
diff --git a/tests/ui-toml/excessive_nesting/default/clippy.toml b/tests/ui-toml/excessive_nesting/default/clippy.toml
deleted file mode 100644
index e8b115a0f7c..00000000000
--- a/tests/ui-toml/excessive_nesting/default/clippy.toml
+++ /dev/null
@@ -1 +0,0 @@
-excessive-nesting-threshold = 0
diff --git a/tests/ui-toml/excessive_nesting/excessive_nesting.above.stderr b/tests/ui-toml/excessive_nesting/excessive_nesting.above.stderr
new file mode 100644
index 00000000000..0ec41fbaa07
--- /dev/null
+++ b/tests/ui-toml/excessive_nesting/excessive_nesting.above.stderr
@@ -0,0 +1,314 @@
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:23:25
+   |
+LL |                 let w = { 3 };
+   |                         ^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+   = note: `-D clippy::excessive-nesting` implied by `-D warnings`
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:69:17
+   |
+LL | /                 impl C {
+LL | |                     pub fn c() {}
+LL | |                 }
+   | |_________________^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:83:25
+   |
+LL |                 let x = { 1 }; // not a warning, but cc is
+   |                         ^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:100:17
+   |
+LL | /                 pub mod e {
+LL | |                     pub mod f {}
+LL | |                 } // not here
+   | |_________________^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:113:18
+   |
+LL |     a_but_not({{{{{{{{0}}}}}}}});
+   |                  ^^^^^^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:114:12
+   |
+LL |     a.a({{{{{{{{{0}}}}}}}}});
+   |            ^^^^^^^^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:115:12
+   |
+LL |     (0, {{{{{{{1}}}}}}});
+   |            ^^^^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:120:25
+   |
+LL |                   if true {
+   |  _________________________^
+LL | |                     if true {
+LL | |
+LL | |                     }
+LL | |                 }
+   | |_________________^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:132:29
+   |
+LL |                   let z = (|| {
+   |  _____________________________^
+LL | |                     let w = { 3 };
+LL | |                     w
+LL | |                 })();
+   | |_________________^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:151:13
+   |
+LL |     y += {{{{{5}}}}};
+   |             ^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:152:20
+   |
+LL |     let z = y + {{{{{{{{{5}}}}}}}}};
+   |                    ^^^^^^^^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:153:12
+   |
+LL |     [0, {{{{{{{{{{0}}}}}}}}}}];
+   |            ^^^^^^^^^^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:154:25
+   |
+LL |     let mut xx = [0; {{{{{{{{100}}}}}}}}];
+   |                         ^^^^^^^^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:155:11
+   |
+LL |     xx[{{{{{{{{{{{{{{{{{{{{{{{{3}}}}}}}}}}}}}}}}}}}}}}}}];
+   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:156:13
+   |
+LL |     &mut {{{{{{{{{{y}}}}}}}}}};
+   |             ^^^^^^^^^^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:158:17
+   |
+LL |     for i in {{{{xx}}}} {{{{{{{{}}}}}}}}
+   |                 ^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:158:28
+   |
+LL |     for i in {{{{xx}}}} {{{{{{{{}}}}}}}}
+   |                            ^^^^^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:160:28
+   |
+LL |     while let Some(i) = {{{{{{Some(1)}}}}}} {{{{{{{}}}}}}}
+   |                            ^^^^^^^^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:160:48
+   |
+LL |     while let Some(i) = {{{{{{Some(1)}}}}}} {{{{{{{}}}}}}}
+   |                                                ^^^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:162:14
+   |
+LL |     while {{{{{{{{true}}}}}}}} {{{{{{{{{}}}}}}}}}
+   |              ^^^^^^^^^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:162:35
+   |
+LL |     while {{{{{{{{true}}}}}}}} {{{{{{{{{}}}}}}}}}
+   |                                   ^^^^^^^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:164:23
+   |
+LL |     let d = D { d: {{{{{{{{{{{{{{{{{{{{{{{3}}}}}}}}}}}}}}}}}}}}}}} };
+   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:166:8
+   |
+LL |     {{{{1;}}}}..{{{{{{3}}}}}};
+   |        ^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:166:20
+   |
+LL |     {{{{1;}}}}..{{{{{{3}}}}}};
+   |                    ^^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:167:8
+   |
+LL |     {{{{1;}}}}..={{{{{{{{{{{{{{{{{{{{{{{{{{6}}}}}}}}}}}}}}}}}}}}}}}}}};
+   |        ^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:167:21
+   |
+LL |     {{{{1;}}}}..={{{{{{{{{{{{{{{{{{{{{{{{{{6}}}}}}}}}}}}}}}}}}}}}}}}}};
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:168:10
+   |
+LL |     ..{{{{{{{5}}}}}}};
+   |          ^^^^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:169:11
+   |
+LL |     ..={{{{{3}}}}};
+   |           ^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:170:8
+   |
+LL |     {{{{{1;}}}}}..;
+   |        ^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:172:20
+   |
+LL |     loop { break {{{{1}}}} };
+   |                    ^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:173:13
+   |
+LL |     loop {{{{{{}}}}}}
+   |             ^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:175:14
+   |
+LL |     match {{{{{{true}}}}}} {
+   |              ^^^^^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:176:20
+   |
+LL |         true => {{{{}}}},
+   |                    ^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:177:21
+   |
+LL |         false => {{{{}}}},
+   |                     ^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:183:17
+   |
+LL | /                 {
+LL | |                     println!("warning! :)");
+LL | |                 }
+   | |_________________^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:192:28
+   |
+LL |     async fn c() -> u32 {{{{{{{0}}}}}}}
+   |                            ^^^^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: this block is too nested
+  --> $DIR/excessive_nesting.rs:198:8
+   |
+LL |     {{{{b().await}}}};
+   |        ^^^^^^^^^^^
+   |
+   = help: try refactoring your code to minimize nesting
+
+error: aborting due to 37 previous errors
+
diff --git a/tests/ui-toml/excessive_nesting/excessive_nesting.default.stderr b/tests/ui-toml/excessive_nesting/excessive_nesting.default.stderr
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/tests/ui-toml/excessive_nesting/excessive_nesting.rs b/tests/ui-toml/excessive_nesting/excessive_nesting.rs
index 5e436b97ee8..432c4132b57 100644
--- a/tests/ui-toml/excessive_nesting/excessive_nesting.rs
+++ b/tests/ui-toml/excessive_nesting/excessive_nesting.rs
@@ -1,7 +1,7 @@
-//@aux-build:macro_rules.rs
-//@revisions: set default
+//@aux-build:proc_macros.rs
+//@revisions: set above
 //@[set] rustc-env:CLIPPY_CONF_DIR=tests/ui-toml/excessive_nesting/set
-//@[default] rustc-env:CLIPPY_CONF_DIR=tests/ui-toml/excessive_nesting/default
+//@[above] rustc-env:CLIPPY_CONF_DIR=tests/ui-toml/excessive_nesting/above
 #![rustfmt::skip]
 #![feature(custom_inner_attributes)]
 #![allow(unused)]
@@ -13,10 +13,8 @@
 #![warn(clippy::excessive_nesting)]
 #![allow(clippy::collapsible_if)]
 
-mod auxiliary;
-
 #[macro_use]
-extern crate macro_rules;
+extern crate proc_macros;
 
 static X: u32 = {
     let x = {
@@ -142,7 +140,8 @@ fn main() {
         x
     })();
 
-    excessive_nesting!(); // ensure this isn't linted in external macros
+    external! { {{{{{{{{{{{{{{{{}}}}}}}}}}}}}}}} }; // ensure this isn't linted in external macros
+    with_span! { span {{{{{{{{{{{{}}}}}}}}}}}} }; // don't lint for proc macros
     xx!(); // ensure this is never linted
     let boo = true;
     !{boo as u32 + !{boo as u32 + !{boo as u32}}};
diff --git a/tests/ui-toml/excessive_nesting/excessive_nesting.set.stderr b/tests/ui-toml/excessive_nesting/excessive_nesting.set.stderr
index 1f069437dfe..237cc6c4a90 100644
--- a/tests/ui-toml/excessive_nesting/excessive_nesting.set.stderr
+++ b/tests/ui-toml/excessive_nesting/excessive_nesting.set.stderr
@@ -1,24 +1,5 @@
 error: this block is too nested
-  --> $DIR/auxiliary/mod.rs:6:13
-   |
-LL | /             mod d {
-LL | |                 mod e {}
-LL | |             }
-   | |_____________^
-   |
-   = help: try refactoring your code to minimize nesting
-   = note: `-D clippy::excessive-nesting` implied by `-D warnings`
-
-error: this block is too nested
-  --> $DIR/auxiliary/mod.rs:15:7
-   |
-LL |     {{{}}}
-   |       ^^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:24:21
+  --> $DIR/excessive_nesting.rs:22:21
    |
 LL |               let z = {
    |  _____________________^
@@ -28,9 +9,10 @@ LL | |             };
    | |_____________^
    |
    = help: try refactoring your code to minimize nesting
+   = note: `-D clippy::excessive-nesting` implied by `-D warnings`
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:68:24
+  --> $DIR/excessive_nesting.rs:66:24
    |
 LL |               pub fn b() {
    |  ________________________^
@@ -45,7 +27,7 @@ LL | |             }
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:84:21
+  --> $DIR/excessive_nesting.rs:82:21
    |
 LL |               fn cc() {
    |  _____________________^
@@ -56,7 +38,7 @@ LL | |             }
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:88:21
+  --> $DIR/excessive_nesting.rs:86:21
    |
 LL |             let x = { 1 }; // warning
    |                     ^^^^^
@@ -64,7 +46,7 @@ LL |             let x = { 1 }; // warning
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:101:13
+  --> $DIR/excessive_nesting.rs:99:13
    |
 LL | /             pub mod d {
 LL | |                 pub mod e {
@@ -76,7 +58,7 @@ LL | |             } // only warning should be here
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:115:17
+  --> $DIR/excessive_nesting.rs:113:17
    |
 LL |     a_but_not({{{{{{{{0}}}}}}}});
    |                 ^^^^^^^^^^^^^
@@ -84,7 +66,7 @@ LL |     a_but_not({{{{{{{{0}}}}}}}});
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:116:11
+  --> $DIR/excessive_nesting.rs:114:11
    |
 LL |     a.a({{{{{{{{{0}}}}}}}}});
    |           ^^^^^^^^^^^^^^^
@@ -92,7 +74,7 @@ LL |     a.a({{{{{{{{{0}}}}}}}}});
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:117:11
+  --> $DIR/excessive_nesting.rs:115:11
    |
 LL |     (0, {{{{{{{1}}}}}}});
    |           ^^^^^^^^^^^
@@ -100,7 +82,7 @@ LL |     (0, {{{{{{{1}}}}}}});
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:121:21
+  --> $DIR/excessive_nesting.rs:119:21
    |
 LL |               if true {
    |  _____________________^
@@ -115,7 +97,7 @@ LL | |             }
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:133:25
+  --> $DIR/excessive_nesting.rs:131:25
    |
 LL |               let y = (|| {
    |  _________________________^
@@ -130,7 +112,7 @@ LL | |             })();
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:148:36
+  --> $DIR/excessive_nesting.rs:147:36
    |
 LL |     !{boo as u32 + !{boo as u32 + !{boo as u32}}};
    |                                    ^^^^^^^^^^^^
@@ -138,7 +120,7 @@ LL |     !{boo as u32 + !{boo as u32 + !{boo as u32}}};
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:152:12
+  --> $DIR/excessive_nesting.rs:151:12
    |
 LL |     y += {{{{{5}}}}};
    |            ^^^^^^^
@@ -146,7 +128,7 @@ LL |     y += {{{{{5}}}}};
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:153:19
+  --> $DIR/excessive_nesting.rs:152:19
    |
 LL |     let z = y + {{{{{{{{{5}}}}}}}}};
    |                   ^^^^^^^^^^^^^^^
@@ -154,7 +136,7 @@ LL |     let z = y + {{{{{{{{{5}}}}}}}}};
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:154:11
+  --> $DIR/excessive_nesting.rs:153:11
    |
 LL |     [0, {{{{{{{{{{0}}}}}}}}}}];
    |           ^^^^^^^^^^^^^^^^^
@@ -162,7 +144,7 @@ LL |     [0, {{{{{{{{{{0}}}}}}}}}}];
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:155:24
+  --> $DIR/excessive_nesting.rs:154:24
    |
 LL |     let mut xx = [0; {{{{{{{{100}}}}}}}}];
    |                        ^^^^^^^^^^^^^^^
@@ -170,7 +152,7 @@ LL |     let mut xx = [0; {{{{{{{{100}}}}}}}}];
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:156:10
+  --> $DIR/excessive_nesting.rs:155:10
    |
 LL |     xx[{{{{{{{{{{{{{{{{{{{{{{{{3}}}}}}}}}}}}}}}}}}}}}}}}];
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -178,7 +160,7 @@ LL |     xx[{{{{{{{{{{{{{{{{{{{{{{{{3}}}}}}}}}}}}}}}}}}}}}}}}];
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:157:12
+  --> $DIR/excessive_nesting.rs:156:12
    |
 LL |     &mut {{{{{{{{{{y}}}}}}}}}};
    |            ^^^^^^^^^^^^^^^^^
@@ -186,7 +168,7 @@ LL |     &mut {{{{{{{{{{y}}}}}}}}}};
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:159:16
+  --> $DIR/excessive_nesting.rs:158:16
    |
 LL |     for i in {{{{xx}}}} {{{{{{{{}}}}}}}}
    |                ^^^^^^
@@ -194,7 +176,7 @@ LL |     for i in {{{{xx}}}} {{{{{{{{}}}}}}}}
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:159:27
+  --> $DIR/excessive_nesting.rs:158:27
    |
 LL |     for i in {{{{xx}}}} {{{{{{{{}}}}}}}}
    |                           ^^^^^^^^^^^^
@@ -202,7 +184,7 @@ LL |     for i in {{{{xx}}}} {{{{{{{{}}}}}}}}
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:161:27
+  --> $DIR/excessive_nesting.rs:160:27
    |
 LL |     while let Some(i) = {{{{{{Some(1)}}}}}} {{{{{{{}}}}}}}
    |                           ^^^^^^^^^^^^^^^
@@ -210,7 +192,7 @@ LL |     while let Some(i) = {{{{{{Some(1)}}}}}} {{{{{{{}}}}}}}
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:161:47
+  --> $DIR/excessive_nesting.rs:160:47
    |
 LL |     while let Some(i) = {{{{{{Some(1)}}}}}} {{{{{{{}}}}}}}
    |                                               ^^^^^^^^^^
@@ -218,7 +200,7 @@ LL |     while let Some(i) = {{{{{{Some(1)}}}}}} {{{{{{{}}}}}}}
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:163:13
+  --> $DIR/excessive_nesting.rs:162:13
    |
 LL |     while {{{{{{{{true}}}}}}}} {{{{{{{{{}}}}}}}}}
    |             ^^^^^^^^^^^^^^^^
@@ -226,7 +208,7 @@ LL |     while {{{{{{{{true}}}}}}}} {{{{{{{{{}}}}}}}}}
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:163:34
+  --> $DIR/excessive_nesting.rs:162:34
    |
 LL |     while {{{{{{{{true}}}}}}}} {{{{{{{{{}}}}}}}}}
    |                                  ^^^^^^^^^^^^^^
@@ -234,7 +216,7 @@ LL |     while {{{{{{{{true}}}}}}}} {{{{{{{{{}}}}}}}}}
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:165:22
+  --> $DIR/excessive_nesting.rs:164:22
    |
 LL |     let d = D { d: {{{{{{{{{{{{{{{{{{{{{{{3}}}}}}}}}}}}}}}}}}}}}}} };
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -242,7 +224,7 @@ LL |     let d = D { d: {{{{{{{{{{{{{{{{{{{{{{{3}}}}}}}}}}}}}}}}}}}}}}} };
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:167:7
+  --> $DIR/excessive_nesting.rs:166:7
    |
 LL |     {{{{1;}}}}..{{{{{{3}}}}}};
    |       ^^^^^^
@@ -250,7 +232,7 @@ LL |     {{{{1;}}}}..{{{{{{3}}}}}};
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:167:19
+  --> $DIR/excessive_nesting.rs:166:19
    |
 LL |     {{{{1;}}}}..{{{{{{3}}}}}};
    |                   ^^^^^^^^^
@@ -258,7 +240,7 @@ LL |     {{{{1;}}}}..{{{{{{3}}}}}};
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:168:7
+  --> $DIR/excessive_nesting.rs:167:7
    |
 LL |     {{{{1;}}}}..={{{{{{{{{{{{{{{{{{{{{{{{{{6}}}}}}}}}}}}}}}}}}}}}}}}}};
    |       ^^^^^^
@@ -266,7 +248,7 @@ LL |     {{{{1;}}}}..={{{{{{{{{{{{{{{{{{{{{{{{{{6}}}}}}}}}}}}}}}}}}}}}}}}}};
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:168:20
+  --> $DIR/excessive_nesting.rs:167:20
    |
 LL |     {{{{1;}}}}..={{{{{{{{{{{{{{{{{{{{{{{{{{6}}}}}}}}}}}}}}}}}}}}}}}}}};
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -274,7 +256,7 @@ LL |     {{{{1;}}}}..={{{{{{{{{{{{{{{{{{{{{{{{{{6}}}}}}}}}}}}}}}}}}}}}}}}}};
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:169:9
+  --> $DIR/excessive_nesting.rs:168:9
    |
 LL |     ..{{{{{{{5}}}}}}};
    |         ^^^^^^^^^^^
@@ -282,7 +264,7 @@ LL |     ..{{{{{{{5}}}}}}};
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:170:10
+  --> $DIR/excessive_nesting.rs:169:10
    |
 LL |     ..={{{{{3}}}}};
    |          ^^^^^^^
@@ -290,7 +272,7 @@ LL |     ..={{{{{3}}}}};
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:171:7
+  --> $DIR/excessive_nesting.rs:170:7
    |
 LL |     {{{{{1;}}}}}..;
    |       ^^^^^^^^
@@ -298,7 +280,7 @@ LL |     {{{{{1;}}}}}..;
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:173:19
+  --> $DIR/excessive_nesting.rs:172:19
    |
 LL |     loop { break {{{{1}}}} };
    |                   ^^^^^^^
@@ -306,7 +288,7 @@ LL |     loop { break {{{{1}}}} };
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:174:12
+  --> $DIR/excessive_nesting.rs:173:12
    |
 LL |     loop {{{{{{}}}}}}
    |            ^^^^^^^^
@@ -314,7 +296,7 @@ LL |     loop {{{{{{}}}}}}
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:176:13
+  --> $DIR/excessive_nesting.rs:175:13
    |
 LL |     match {{{{{{true}}}}}} {
    |             ^^^^^^^^^^^^
@@ -322,7 +304,7 @@ LL |     match {{{{{{true}}}}}} {
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:177:19
+  --> $DIR/excessive_nesting.rs:176:19
    |
 LL |         true => {{{{}}}},
    |                   ^^^^
@@ -330,7 +312,7 @@ LL |         true => {{{{}}}},
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:178:20
+  --> $DIR/excessive_nesting.rs:177:20
    |
 LL |         false => {{{{}}}},
    |                    ^^^^
@@ -338,7 +320,7 @@ LL |         false => {{{{}}}},
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:183:13
+  --> $DIR/excessive_nesting.rs:182:13
    |
 LL | /             {
 LL | |                 {
@@ -350,7 +332,7 @@ LL | |             }
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:193:27
+  --> $DIR/excessive_nesting.rs:192:27
    |
 LL |     async fn c() -> u32 {{{{{{{0}}}}}}}
    |                           ^^^^^^^^^^^
@@ -358,12 +340,12 @@ LL |     async fn c() -> u32 {{{{{{{0}}}}}}}
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> $DIR/excessive_nesting.rs:199:7
+  --> $DIR/excessive_nesting.rs:198:7
    |
 LL |     {{{{b().await}}}};
    |       ^^^^^^^^^^^^^
    |
    = help: try refactoring your code to minimize nesting
 
-error: aborting due to 41 previous errors
+error: aborting due to 39 previous errors
 
diff --git a/tests/ui-toml/excessive_nesting/excessive_nesting.stderr b/tests/ui-toml/excessive_nesting/excessive_nesting.stderr
deleted file mode 100644
index f1db396fe48..00000000000
--- a/tests/ui-toml/excessive_nesting/excessive_nesting.stderr
+++ /dev/null
@@ -1,369 +0,0 @@
-error: this block is too nested
-  --> $DIR/auxiliary/mod.rs:6:13
-   |
-LL | /             mod d {
-LL | |                 mod e {}
-LL | |             }
-   | |_____________^
-   |
-   = help: try refactoring your code to minimize nesting
-   = note: `-D clippy::excessive-nesting` implied by `-D warnings`
-
-error: this block is too nested
-  --> $DIR/auxiliary/mod.rs:15:7
-   |
-LL |     {{{}}}
-   |       ^^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:21:21
-   |
-LL |               let z = {
-   |  _____________________^
-LL | |                 let w = { 3 };
-LL | |                 w
-LL | |             };
-   | |_____________^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:65:24
-   |
-LL |               pub fn b() {
-   |  ________________________^
-LL | |                 struct C;
-LL | |
-LL | |                 impl C {
-LL | |                     pub fn c() {}
-LL | |                 }
-LL | |             }
-   | |_____________^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:81:21
-   |
-LL |               fn cc() {
-   |  _____________________^
-LL | |                 let x = { 1 }; // not a warning, but cc is
-LL | |             }
-   | |_____________^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:85:21
-   |
-LL |             let x = { 1 }; // warning
-   |                     ^^^^^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:98:13
-   |
-LL | /             pub mod d {
-LL | |                 pub mod e {
-LL | |                     pub mod f {}
-LL | |                 } // not here
-LL | |             } // only warning should be here
-   | |_____________^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:112:17
-   |
-LL |     a_but_not({{{{{{{{0}}}}}}}});
-   |                 ^^^^^^^^^^^^^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:113:11
-   |
-LL |     a.a({{{{{{{{{0}}}}}}}}});
-   |           ^^^^^^^^^^^^^^^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:114:11
-   |
-LL |     (0, {{{{{{{1}}}}}}});
-   |           ^^^^^^^^^^^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:118:21
-   |
-LL |               if true {
-   |  _____________________^
-LL | |                 if true {
-LL | |                     if true {
-LL | |
-LL | |                     }
-LL | |                 }
-LL | |             }
-   | |_____________^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:130:25
-   |
-LL |               let y = (|| {
-   |  _________________________^
-LL | |                 let z = (|| {
-LL | |                     let w = { 3 };
-LL | |                     w
-LL | |                 })();
-LL | |                 z
-LL | |             })();
-   | |_____________^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:145:36
-   |
-LL |     !{boo as u32 + !{boo as u32 + !{boo as u32}}};
-   |                                    ^^^^^^^^^^^^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:149:12
-   |
-LL |     y += {{{{{5}}}}};
-   |            ^^^^^^^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:150:19
-   |
-LL |     let z = y + {{{{{{{{{5}}}}}}}}};
-   |                   ^^^^^^^^^^^^^^^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:151:11
-   |
-LL |     [0, {{{{{{{{{{0}}}}}}}}}}];
-   |           ^^^^^^^^^^^^^^^^^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:152:24
-   |
-LL |     let mut xx = [0; {{{{{{{{100}}}}}}}}];
-   |                        ^^^^^^^^^^^^^^^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:153:10
-   |
-LL |     xx[{{{{{{{{{{{{{{{{{{{{{{{{3}}}}}}}}}}}}}}}}}}}}}}}}];
-   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:154:12
-   |
-LL |     &mut {{{{{{{{{{y}}}}}}}}}};
-   |            ^^^^^^^^^^^^^^^^^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:156:16
-   |
-LL |     for i in {{{{xx}}}} {{{{{{{{}}}}}}}}
-   |                ^^^^^^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:156:27
-   |
-LL |     for i in {{{{xx}}}} {{{{{{{{}}}}}}}}
-   |                           ^^^^^^^^^^^^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:158:27
-   |
-LL |     while let Some(i) = {{{{{{Some(1)}}}}}} {{{{{{{}}}}}}}
-   |                           ^^^^^^^^^^^^^^^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:158:47
-   |
-LL |     while let Some(i) = {{{{{{Some(1)}}}}}} {{{{{{{}}}}}}}
-   |                                               ^^^^^^^^^^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:160:13
-   |
-LL |     while {{{{{{{{true}}}}}}}} {{{{{{{{{}}}}}}}}}
-   |             ^^^^^^^^^^^^^^^^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:160:34
-   |
-LL |     while {{{{{{{{true}}}}}}}} {{{{{{{{{}}}}}}}}}
-   |                                  ^^^^^^^^^^^^^^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:162:22
-   |
-LL |     let d = D { d: {{{{{{{{{{{{{{{{{{{{{{{3}}}}}}}}}}}}}}}}}}}}}}} };
-   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:164:7
-   |
-LL |     {{{{1;}}}}..{{{{{{3}}}}}};
-   |       ^^^^^^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:164:19
-   |
-LL |     {{{{1;}}}}..{{{{{{3}}}}}};
-   |                   ^^^^^^^^^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:165:7
-   |
-LL |     {{{{1;}}}}..={{{{{{{{{{{{{{{{{{{{{{{{{{6}}}}}}}}}}}}}}}}}}}}}}}}}};
-   |       ^^^^^^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:165:20
-   |
-LL |     {{{{1;}}}}..={{{{{{{{{{{{{{{{{{{{{{{{{{6}}}}}}}}}}}}}}}}}}}}}}}}}};
-   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:166:9
-   |
-LL |     ..{{{{{{{5}}}}}}};
-   |         ^^^^^^^^^^^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:167:10
-   |
-LL |     ..={{{{{3}}}}};
-   |          ^^^^^^^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:168:7
-   |
-LL |     {{{{{1;}}}}}..;
-   |       ^^^^^^^^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:170:19
-   |
-LL |     loop { break {{{{1}}}} };
-   |                   ^^^^^^^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:171:12
-   |
-LL |     loop {{{{{{}}}}}}
-   |            ^^^^^^^^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:173:13
-   |
-LL |     match {{{{{{true}}}}}} {
-   |             ^^^^^^^^^^^^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:174:19
-   |
-LL |         true => {{{{}}}},
-   |                   ^^^^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:175:20
-   |
-LL |         false => {{{{}}}},
-   |                    ^^^^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:180:13
-   |
-LL | /             {
-LL | |                 {
-LL | |                     println!("warning! :)");
-LL | |                 }
-LL | |             }
-   | |_____________^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:190:27
-   |
-LL |     async fn c() -> u32 {{{{{{{0}}}}}}}
-   |                           ^^^^^^^^^^^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: this block is too nested
-  --> $DIR/excessive_nesting.rs:196:7
-   |
-LL |     {{{{b().await}}}};
-   |       ^^^^^^^^^^^^^
-   |
-   = help: try refactoring your code to minimize nesting
-
-error: aborting due to 41 previous errors
-
diff --git a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
index 28b6e7aa824..5ec6f3decc3 100644
--- a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
+++ b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
@@ -86,6 +86,7 @@ error: error reading Clippy's configuration file: unknown field `barfoo`, expect
            enforced-import-renames
            enum-variant-name-threshold
            enum-variant-size-threshold
+           excessive-nesting-threshold
            future-size-threshold
            ignore-interior-mutability
            large-error-threshold
-- 
cgit 1.4.1-3-g733a5


From 339cd14f27e9db4f7b040068abad8a20a0034fa8 Mon Sep 17 00:00:00 2001
From: avborhanian <araam@google.com>
Date: Sun, 4 Jun 2023 10:33:13 -0700
Subject: Adds new lint `arc_with_non_send_or_sync`

---
 CHANGELOG.md                               |  1 +
 clippy_lints/src/arc_with_non_send_sync.rs | 71 ++++++++++++++++++++++++++++++
 clippy_lints/src/declared_lints.rs         |  1 +
 clippy_lints/src/lib.rs                    |  2 +
 tests/ui/arc_with_non_send_sync.rs         | 12 +++++
 tests/ui/arc_with_non_send_sync.stderr     | 11 +++++
 6 files changed, 98 insertions(+)
 create mode 100644 clippy_lints/src/arc_with_non_send_sync.rs
 create mode 100644 tests/ui/arc_with_non_send_sync.rs
 create mode 100644 tests/ui/arc_with_non_send_sync.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index a65ac4d46de..a53567f25c4 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4628,6 +4628,7 @@ Released 2018-09-13
 [`almost_complete_range`]: https://rust-lang.github.io/rust-clippy/master/index.html#almost_complete_range
 [`almost_swapped`]: https://rust-lang.github.io/rust-clippy/master/index.html#almost_swapped
 [`approx_constant`]: https://rust-lang.github.io/rust-clippy/master/index.html#approx_constant
+[`arc_with_non_send_sync`]: https://rust-lang.github.io/rust-clippy/master/index.html#arc_with_non_send_sync
 [`arithmetic_side_effects`]: https://rust-lang.github.io/rust-clippy/master/index.html#arithmetic_side_effects
 [`as_conversions`]: https://rust-lang.github.io/rust-clippy/master/index.html#as_conversions
 [`as_ptr_cast_mut`]: https://rust-lang.github.io/rust-clippy/master/index.html#as_ptr_cast_mut
diff --git a/clippy_lints/src/arc_with_non_send_sync.rs b/clippy_lints/src/arc_with_non_send_sync.rs
new file mode 100644
index 00000000000..2e14f81f8e4
--- /dev/null
+++ b/clippy_lints/src/arc_with_non_send_sync.rs
@@ -0,0 +1,71 @@
+use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::last_path_segment;
+use clippy_utils::ty::{implements_trait, is_type_diagnostic_item};
+use if_chain::if_chain;
+
+use rustc_hir::{Expr, ExprKind};
+use rustc_lint::LateContext;
+use rustc_lint::LateLintPass;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::symbol::sym;
+
+declare_clippy_lint! {
+    /// ### What it does.
+    /// This lint warns when you use `Arc` with a type that does not implement `Send` or `Sync`.
+    ///
+    /// ### Why is this bad?
+    /// Wrapping a type in Arc doesn't add thread safety to the underlying data, so data races
+    /// could occur when touching the underlying data.
+    ///
+    /// ### Example.
+    /// ```rust
+    /// use std::cell::RefCell;
+    /// use std::sync::Arc;
+    ///
+    /// fn main() {
+    ///     // This is safe, as `i32` implements `Send` and `Sync`.
+    ///     let a = Arc::new(42);
+    ///
+    ///     // This is not safe, as `RefCell` does not implement `Sync`.
+    ///     let b = Arc::new(RefCell::new(42));
+    /// }
+    /// ```
+    /// ```
+    #[clippy::version = "1.72.0"]
+    pub ARC_WITH_NON_SEND_SYNC,
+    correctness,
+    "using `Arc` with a type that does not implement `Send` or `Sync`"
+}
+declare_lint_pass!(ArcWithNonSendSync => [ARC_WITH_NON_SEND_SYNC]);
+
+impl LateLintPass<'_> for ArcWithNonSendSync {
+    fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
+        let ty = cx.typeck_results().expr_ty(expr);
+        if_chain! {
+            if is_type_diagnostic_item(cx, ty, sym::Arc);
+            if let ExprKind::Call(func, [arg]) = expr.kind;
+            if let ExprKind::Path(func_path) = func.kind;
+            if last_path_segment(&func_path).ident.name == sym::new;
+            if let arg_ty = cx.typeck_results().expr_ty(arg);
+            if !cx.tcx
+                .lang_items()
+                .sync_trait()
+                .map_or(false, |id| implements_trait(cx, arg_ty, id, &[])) ||
+                !cx.tcx
+                .get_diagnostic_item(sym::Send)
+                .map_or(false, |id| implements_trait(cx, arg_ty, id, &[]));
+
+            then {
+                span_lint_and_help(
+                    cx,
+                    ARC_WITH_NON_SEND_SYNC,
+                    expr.span,
+                    "usage of `Arc<T>` where `T` is not `Send` or `Sync`",
+                    None,
+                    "consider using `Rc<T>` instead or wrapping `T` in a std::sync type like \
+                    Mutex<T>",
+                );
+            }
+        }
+    }
+}
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index d014534cee9..f82118e569f 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -40,6 +40,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::allow_attributes::ALLOW_ATTRIBUTES_INFO,
     crate::almost_complete_range::ALMOST_COMPLETE_RANGE_INFO,
     crate::approx_const::APPROX_CONSTANT_INFO,
+    crate::arc_with_non_send_sync::ARC_WITH_NON_SEND_SYNC_INFO,
     crate::as_conversions::AS_CONVERSIONS_INFO,
     crate::asm_syntax::INLINE_ASM_X86_ATT_SYNTAX_INFO,
     crate::asm_syntax::INLINE_ASM_X86_INTEL_SYNTAX_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index d53c6de5451..2f5932104c1 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -68,6 +68,7 @@ mod renamed_lints;
 mod allow_attributes;
 mod almost_complete_range;
 mod approx_const;
+mod arc_with_non_send_sync;
 mod as_conversions;
 mod asm_syntax;
 mod assertions_on_constants;
@@ -1014,6 +1015,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(missing_fields_in_debug::MissingFieldsInDebug));
     store.register_late_pass(|_| Box::new(endian_bytes::EndianBytes));
     store.register_late_pass(|_| Box::new(redundant_type_annotations::RedundantTypeAnnotations));
+    store.register_late_pass(|_| Box::new(arc_with_non_send_sync::ArcWithNonSendSync));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/tests/ui/arc_with_non_send_sync.rs b/tests/ui/arc_with_non_send_sync.rs
new file mode 100644
index 00000000000..4c2d84be5db
--- /dev/null
+++ b/tests/ui/arc_with_non_send_sync.rs
@@ -0,0 +1,12 @@
+#![warn(clippy::arc_with_non_send_sync)]
+#![allow(unused_variables)]
+use std::cell::RefCell;
+use std::sync::{Arc, Mutex};
+
+fn main() {
+    // This is safe, as `i32` implements `Send` and `Sync`.
+    let a = Arc::new(42);
+
+    // This is not safe, as `RefCell` does not implement `Sync`.
+    let b = Arc::new(RefCell::new(42));
+}
diff --git a/tests/ui/arc_with_non_send_sync.stderr b/tests/ui/arc_with_non_send_sync.stderr
new file mode 100644
index 00000000000..99e38bcc1a2
--- /dev/null
+++ b/tests/ui/arc_with_non_send_sync.stderr
@@ -0,0 +1,11 @@
+error: usage of `Arc<T>` where `T` is not `Send` or `Sync`
+  --> $DIR/arc_with_non_send_sync.rs:11:13
+   |
+LL |     let b = Arc::new(RefCell::new(42));
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using `Rc<T>` instead or wrapping `T` in a std::sync type like Mutex<T>
+   = note: `-D clippy::arc-with-non-send-sync` implied by `-D warnings`
+
+error: aborting due to previous error
+
-- 
cgit 1.4.1-3-g733a5


From 8330887e1b2272b14e334cb28fb85ccf0859f183 Mon Sep 17 00:00:00 2001
From: avborhanian <araam@google.com>
Date: Wed, 7 Jun 2023 20:52:42 -0700
Subject: Updating documentation and lint formatting.

---
 clippy_lints/src/arc_with_non_send_sync.rs | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/arc_with_non_send_sync.rs b/clippy_lints/src/arc_with_non_send_sync.rs
index 2e14f81f8e4..ca2023ee0be 100644
--- a/clippy_lints/src/arc_with_non_send_sync.rs
+++ b/clippy_lints/src/arc_with_non_send_sync.rs
@@ -17,10 +17,10 @@ declare_clippy_lint! {
     /// Wrapping a type in Arc doesn't add thread safety to the underlying data, so data races
     /// could occur when touching the underlying data.
     ///
-    /// ### Example.
+    /// ### Example
     /// ```rust
-    /// use std::cell::RefCell;
-    /// use std::sync::Arc;
+    /// # use std::cell::RefCell;
+    /// # use std::sync::Arc;
     ///
     /// fn main() {
     ///     // This is safe, as `i32` implements `Send` and `Sync`.
@@ -30,7 +30,6 @@ declare_clippy_lint! {
     ///     let b = Arc::new(RefCell::new(42));
     /// }
     /// ```
-    /// ```
     #[clippy::version = "1.72.0"]
     pub ARC_WITH_NON_SEND_SYNC,
     correctness,
@@ -63,7 +62,7 @@ impl LateLintPass<'_> for ArcWithNonSendSync {
                     "usage of `Arc<T>` where `T` is not `Send` or `Sync`",
                     None,
                     "consider using `Rc<T>` instead or wrapping `T` in a std::sync type like \
-                    Mutex<T>",
+                    `Mutex<T>`",
                 );
             }
         }
-- 
cgit 1.4.1-3-g733a5


From 2f5d1c748a5447256048267d3fbc3533d6d7e126 Mon Sep 17 00:00:00 2001
From: avborhanian <araam@google.com>
Date: Thu, 8 Jun 2023 00:22:04 -0700
Subject: Adding extra check to ignore generic args.

---
 clippy_lints/src/arc_with_non_send_sync.rs | 5 +++++
 tests/ui/arc_with_non_send_sync.rs         | 5 +++++
 tests/ui/arc_with_non_send_sync.stderr     | 4 ++--
 3 files changed, 12 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/arc_with_non_send_sync.rs b/clippy_lints/src/arc_with_non_send_sync.rs
index ca2023ee0be..13e938327bb 100644
--- a/clippy_lints/src/arc_with_non_send_sync.rs
+++ b/clippy_lints/src/arc_with_non_send_sync.rs
@@ -6,6 +6,7 @@ use if_chain::if_chain;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::LateContext;
 use rustc_lint::LateLintPass;
+use rustc_middle::ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::symbol::sym;
 
@@ -46,6 +47,10 @@ impl LateLintPass<'_> for ArcWithNonSendSync {
             if let ExprKind::Path(func_path) = func.kind;
             if last_path_segment(&func_path).ident.name == sym::new;
             if let arg_ty = cx.typeck_results().expr_ty(arg);
+            if match arg_ty.kind() {
+                ty::Param(_) => false,
+                _ => true,
+            };
             if !cx.tcx
                 .lang_items()
                 .sync_trait()
diff --git a/tests/ui/arc_with_non_send_sync.rs b/tests/ui/arc_with_non_send_sync.rs
index 4c2d84be5db..ac786f68c12 100644
--- a/tests/ui/arc_with_non_send_sync.rs
+++ b/tests/ui/arc_with_non_send_sync.rs
@@ -3,6 +3,11 @@
 use std::cell::RefCell;
 use std::sync::{Arc, Mutex};
 
+fn foo<T>(x: T) {
+    // Should not lint - purposefully ignoring generic args.
+    let a = Arc::new(x);
+}
+
 fn main() {
     // This is safe, as `i32` implements `Send` and `Sync`.
     let a = Arc::new(42);
diff --git a/tests/ui/arc_with_non_send_sync.stderr b/tests/ui/arc_with_non_send_sync.stderr
index 99e38bcc1a2..fc2fc5f93b1 100644
--- a/tests/ui/arc_with_non_send_sync.stderr
+++ b/tests/ui/arc_with_non_send_sync.stderr
@@ -1,10 +1,10 @@
 error: usage of `Arc<T>` where `T` is not `Send` or `Sync`
-  --> $DIR/arc_with_non_send_sync.rs:11:13
+  --> $DIR/arc_with_non_send_sync.rs:16:13
    |
 LL |     let b = Arc::new(RefCell::new(42));
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: consider using `Rc<T>` instead or wrapping `T` in a std::sync type like Mutex<T>
+   = help: consider using `Rc<T>` instead or wrapping `T` in a std::sync type like `Mutex<T>`
    = note: `-D clippy::arc-with-non-send-sync` implied by `-D warnings`
 
 error: aborting due to previous error
-- 
cgit 1.4.1-3-g733a5


From 20548eba6ceda0563b399f54b06d05b71950aa5c Mon Sep 17 00:00:00 2001
From: avborhanian <araam@google.com>
Date: Thu, 8 Jun 2023 00:38:18 -0700
Subject: Swapping to matches macro.

---
 clippy_lints/src/arc_with_non_send_sync.rs | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/arc_with_non_send_sync.rs b/clippy_lints/src/arc_with_non_send_sync.rs
index 13e938327bb..a1e44668e1a 100644
--- a/clippy_lints/src/arc_with_non_send_sync.rs
+++ b/clippy_lints/src/arc_with_non_send_sync.rs
@@ -47,10 +47,7 @@ impl LateLintPass<'_> for ArcWithNonSendSync {
             if let ExprKind::Path(func_path) = func.kind;
             if last_path_segment(&func_path).ident.name == sym::new;
             if let arg_ty = cx.typeck_results().expr_ty(arg);
-            if match arg_ty.kind() {
-                ty::Param(_) => false,
-                _ => true,
-            };
+            if !matches!(arg_ty.kind(), ty::Param(_));
             if !cx.tcx
                 .lang_items()
                 .sync_trait()
-- 
cgit 1.4.1-3-g733a5


From 96697d2ee7dfe1bc67a7c11ae5f90d38548aaf04 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Thu, 8 Jun 2023 17:05:08 +0000
Subject: Fix `useless_vec` suggestion in `for _ in vec![..]`

---
 clippy_lints/src/lib.rs |  7 ++++++-
 clippy_lints/src/vec.rs | 12 ++++++++----
 tests/ui/vec.fixed      | 37 ++++++++++++++++++++++++-------------
 tests/ui/vec.rs         | 35 +++++++++++++++++++++++------------
 tests/ui/vec.stderr     | 48 +++++++++++++++++++++++++++---------------------
 5 files changed, 88 insertions(+), 51 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 2f5932104c1..2dbdee977b0 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -699,7 +699,12 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     });
     let too_large_for_stack = conf.too_large_for_stack;
     store.register_late_pass(move |_| Box::new(escape::BoxedLocal { too_large_for_stack }));
-    store.register_late_pass(move |_| Box::new(vec::UselessVec { too_large_for_stack }));
+    store.register_late_pass(move |_| {
+        Box::new(vec::UselessVec {
+            too_large_for_stack,
+            msrv: msrv(),
+        })
+    });
     store.register_late_pass(|_| Box::new(panic_unimplemented::PanicUnimplemented));
     store.register_late_pass(|_| Box::new(strings::StringLitAsBytes));
     store.register_late_pass(|_| Box::new(derive::Derive));
diff --git a/clippy_lints/src/vec.rs b/clippy_lints/src/vec.rs
index 467805d90ff..25b6f40762d 100644
--- a/clippy_lints/src/vec.rs
+++ b/clippy_lints/src/vec.rs
@@ -2,6 +2,7 @@ use std::ops::ControlFlow;
 
 use clippy_utils::consts::{constant, Constant};
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::is_copy;
 use clippy_utils::visitors::for_each_local_use_after_expr;
@@ -18,9 +19,10 @@ use rustc_span::source_map::Span;
 use rustc_span::sym;
 
 #[expect(clippy::module_name_repetitions)]
-#[derive(Copy, Clone)]
+#[derive(Clone)]
 pub struct UselessVec {
     pub too_large_for_stack: u64,
+    pub msrv: Msrv,
 }
 
 declare_clippy_lint! {
@@ -122,14 +124,16 @@ impl<'tcx> LateLintPass<'tcx> for UselessVec {
         if_chain! {
             if let Some(higher::ForLoop { arg, .. }) = higher::ForLoop::hir(expr);
             if let Some(vec_args) = higher::VecArgs::hir(cx, arg);
-            if is_copy(cx, vec_type(cx.typeck_results().expr_ty_adjusted(arg)));
+            if self.msrv.meets(msrvs::ARRAY_INTO_ITERATOR);
             then {
                 // report the error around the `vec!` not inside `<std macros>:`
                 let span = arg.span.ctxt().outer_expn_data().call_site;
-                self.check_vec_macro(cx, &vec_args, Mutability::Not, span, SuggestSlice::Yes);
+                self.check_vec_macro(cx, &vec_args, Mutability::Not, span, SuggestSlice::No);
             }
         }
     }
+
+    extract_msrv_attr!(LateContext);
 }
 
 #[derive(Copy, Clone)]
@@ -142,7 +146,7 @@ enum SuggestSlice {
 
 impl UselessVec {
     fn check_vec_macro<'tcx>(
-        self,
+        &mut self,
         cx: &LateContext<'tcx>,
         vec_args: &higher::VecArgs<'tcx>,
         mutability: Mutability,
diff --git a/tests/ui/vec.fixed b/tests/ui/vec.fixed
index 1bdde69f6f4..55329ee843d 100644
--- a/tests/ui/vec.fixed
+++ b/tests/ui/vec.fixed
@@ -1,6 +1,6 @@
 //@run-rustfix
 #![warn(clippy::useless_vec)]
-#![allow(clippy::nonstandard_macro_braces, clippy::uninlined_format_args)]
+#![allow(clippy::nonstandard_macro_braces, clippy::uninlined_format_args, unused)]
 
 use std::rc::Rc;
 
@@ -8,9 +8,6 @@ struct StructWithVec {
     _x: Vec<i32>,
 }
 
-#[derive(Debug)]
-struct NonCopy;
-
 fn on_slice(_: &[u8]) {}
 
 fn on_mut_slice(_: &mut [u8]) {}
@@ -66,14 +63,6 @@ fn main() {
     on_mut_slice(&mut vec![2; line.length]);
     on_mut_slice(&mut vec![2; line.length()]);
 
-    for a in &[1, 2, 3] {
-        println!("{:?}", a);
-    }
-
-    for a in vec![NonCopy, NonCopy] {
-        println!("{:?}", a);
-    }
-
     on_vec(&vec![1; 201]); // Ok, size of `vec` higher than `too_large_for_stack`
     on_mut_vec(&mut vec![1; 201]); // Ok, size of `vec` higher than `too_large_for_stack`
 
@@ -91,7 +80,7 @@ fn main() {
 
     let _x: &[i32] = &[1, 2, 3];
 
-    for _ in &[1, 2, 3] {}
+    for _ in [1, 2, 3] {}
 
     // Don't lint
     let x = vec![1, 2, 3];
@@ -122,3 +111,25 @@ fn main() {
     // Too large
     let _x = vec![1; 201];
 }
+
+#[clippy::msrv = "1.53"]
+fn above() {
+    for a in [1, 2, 3] {
+        let _: usize = a;
+    }
+
+    for a in [String::new(), String::new()] {
+        let _: String = a;
+    }
+}
+
+#[clippy::msrv = "1.52"]
+fn below() {
+    for a in vec![1, 2, 3] {
+        let _: usize = a;
+    }
+
+    for a in vec![String::new(), String::new()] {
+        let _: String = a;
+    }
+}
diff --git a/tests/ui/vec.rs b/tests/ui/vec.rs
index 89c6a72f339..bab316fa620 100644
--- a/tests/ui/vec.rs
+++ b/tests/ui/vec.rs
@@ -1,6 +1,6 @@
 //@run-rustfix
 #![warn(clippy::useless_vec)]
-#![allow(clippy::nonstandard_macro_braces, clippy::uninlined_format_args)]
+#![allow(clippy::nonstandard_macro_braces, clippy::uninlined_format_args, unused)]
 
 use std::rc::Rc;
 
@@ -8,9 +8,6 @@ struct StructWithVec {
     _x: Vec<i32>,
 }
 
-#[derive(Debug)]
-struct NonCopy;
-
 fn on_slice(_: &[u8]) {}
 
 fn on_mut_slice(_: &mut [u8]) {}
@@ -66,14 +63,6 @@ fn main() {
     on_mut_slice(&mut vec![2; line.length]);
     on_mut_slice(&mut vec![2; line.length()]);
 
-    for a in vec![1, 2, 3] {
-        println!("{:?}", a);
-    }
-
-    for a in vec![NonCopy, NonCopy] {
-        println!("{:?}", a);
-    }
-
     on_vec(&vec![1; 201]); // Ok, size of `vec` higher than `too_large_for_stack`
     on_mut_vec(&mut vec![1; 201]); // Ok, size of `vec` higher than `too_large_for_stack`
 
@@ -122,3 +111,25 @@ fn main() {
     // Too large
     let _x = vec![1; 201];
 }
+
+#[clippy::msrv = "1.53"]
+fn above() {
+    for a in vec![1, 2, 3] {
+        let _: usize = a;
+    }
+
+    for a in vec![String::new(), String::new()] {
+        let _: String = a;
+    }
+}
+
+#[clippy::msrv = "1.52"]
+fn below() {
+    for a in vec![1, 2, 3] {
+        let _: usize = a;
+    }
+
+    for a in vec![String::new(), String::new()] {
+        let _: String = a;
+    }
+}
diff --git a/tests/ui/vec.stderr b/tests/ui/vec.stderr
index f94a82d2171..f3a4bf925dd 100644
--- a/tests/ui/vec.stderr
+++ b/tests/ui/vec.stderr
@@ -1,5 +1,5 @@
 error: useless use of `vec!`
-  --> $DIR/vec.rs:34:14
+  --> $DIR/vec.rs:31:14
    |
 LL |     on_slice(&vec![]);
    |              ^^^^^^^ help: you can use a slice directly: `&[]`
@@ -7,82 +7,88 @@ LL |     on_slice(&vec![]);
    = note: `-D clippy::useless-vec` implied by `-D warnings`
 
 error: useless use of `vec!`
-  --> $DIR/vec.rs:36:18
+  --> $DIR/vec.rs:33:18
    |
 LL |     on_mut_slice(&mut vec![]);
    |                  ^^^^^^^^^^^ help: you can use a slice directly: `&mut []`
 
 error: useless use of `vec!`
-  --> $DIR/vec.rs:38:14
+  --> $DIR/vec.rs:35:14
    |
 LL |     on_slice(&vec![1, 2]);
    |              ^^^^^^^^^^^ help: you can use a slice directly: `&[1, 2]`
 
 error: useless use of `vec!`
-  --> $DIR/vec.rs:40:18
+  --> $DIR/vec.rs:37:18
    |
 LL |     on_mut_slice(&mut vec![1, 2]);
    |                  ^^^^^^^^^^^^^^^ help: you can use a slice directly: `&mut [1, 2]`
 
 error: useless use of `vec!`
-  --> $DIR/vec.rs:42:14
+  --> $DIR/vec.rs:39:14
    |
 LL |     on_slice(&vec![1, 2]);
    |              ^^^^^^^^^^^ help: you can use a slice directly: `&[1, 2]`
 
 error: useless use of `vec!`
-  --> $DIR/vec.rs:44:18
+  --> $DIR/vec.rs:41:18
    |
 LL |     on_mut_slice(&mut vec![1, 2]);
    |                  ^^^^^^^^^^^^^^^ help: you can use a slice directly: `&mut [1, 2]`
 
 error: useless use of `vec!`
-  --> $DIR/vec.rs:46:14
+  --> $DIR/vec.rs:43:14
    |
 LL |     on_slice(&vec!(1, 2));
    |              ^^^^^^^^^^^ help: you can use a slice directly: `&[1, 2]`
 
 error: useless use of `vec!`
-  --> $DIR/vec.rs:48:18
+  --> $DIR/vec.rs:45:18
    |
 LL |     on_mut_slice(&mut vec![1, 2]);
    |                  ^^^^^^^^^^^^^^^ help: you can use a slice directly: `&mut [1, 2]`
 
 error: useless use of `vec!`
-  --> $DIR/vec.rs:50:14
+  --> $DIR/vec.rs:47:14
    |
 LL |     on_slice(&vec![1; 2]);
    |              ^^^^^^^^^^^ help: you can use a slice directly: `&[1; 2]`
 
 error: useless use of `vec!`
-  --> $DIR/vec.rs:52:18
+  --> $DIR/vec.rs:49:18
    |
 LL |     on_mut_slice(&mut vec![1; 2]);
    |                  ^^^^^^^^^^^^^^^ help: you can use a slice directly: `&mut [1; 2]`
 
 error: useless use of `vec!`
-  --> $DIR/vec.rs:69:14
-   |
-LL |     for a in vec![1, 2, 3] {
-   |              ^^^^^^^^^^^^^ help: you can use a slice directly: `&[1, 2, 3]`
-
-error: useless use of `vec!`
-  --> $DIR/vec.rs:86:17
+  --> $DIR/vec.rs:75:17
    |
 LL |     let mut x = vec![1, 2, 3];
    |                 ^^^^^^^^^^^^^ help: you can use an array directly: `[1, 2, 3]`
 
 error: useless use of `vec!`
-  --> $DIR/vec.rs:92:22
+  --> $DIR/vec.rs:81:22
    |
 LL |     let _x: &[i32] = &vec![1, 2, 3];
    |                      ^^^^^^^^^^^^^^ help: you can use a slice directly: `&[1, 2, 3]`
 
 error: useless use of `vec!`
-  --> $DIR/vec.rs:94:14
+  --> $DIR/vec.rs:83:14
    |
 LL |     for _ in vec![1, 2, 3] {}
-   |              ^^^^^^^^^^^^^ help: you can use a slice directly: `&[1, 2, 3]`
+   |              ^^^^^^^^^^^^^ help: you can use an array directly: `[1, 2, 3]`
+
+error: useless use of `vec!`
+  --> $DIR/vec.rs:117:14
+   |
+LL |     for a in vec![1, 2, 3] {
+   |              ^^^^^^^^^^^^^ help: you can use an array directly: `[1, 2, 3]`
+
+error: useless use of `vec!`
+  --> $DIR/vec.rs:121:14
+   |
+LL |     for a in vec![String::new(), String::new()] {
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: you can use an array directly: `[String::new(), String::new()]`
 
-error: aborting due to 14 previous errors
+error: aborting due to 15 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 55c9100334ceeccecc75fbdfc5bef321404bc066 Mon Sep 17 00:00:00 2001
From: Renato Lochetti <renato.lochetti@gmail.com>
Date: Thu, 8 Jun 2023 19:04:35 +0100
Subject: Don't ling `as_conversions` in proc macros

---
 clippy_lints/src/as_conversions.rs | 11 ++++++-----
 clippy_lints/src/lib.rs            |  2 +-
 tests/ui/as_conversions.rs         | 11 ++++++++++-
 tests/ui/as_conversions.stderr     |  6 +++---
 4 files changed, 20 insertions(+), 10 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/as_conversions.rs b/clippy_lints/src/as_conversions.rs
index c7a76e5f907..b9dda49ca41 100644
--- a/clippy_lints/src/as_conversions.rs
+++ b/clippy_lints/src/as_conversions.rs
@@ -1,6 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_help;
-use rustc_ast::ast::{Expr, ExprKind};
-use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
+use clippy_utils::is_from_proc_macro;
+use rustc_hir::{Expr, ExprKind};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
@@ -45,9 +46,9 @@ declare_clippy_lint! {
 
 declare_lint_pass!(AsConversions => [AS_CONVERSIONS]);
 
-impl EarlyLintPass for AsConversions {
-    fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
-        if in_external_macro(cx.sess(), expr.span) {
+impl<'tcx> LateLintPass<'tcx> for AsConversions {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &Expr<'tcx>) {
+        if in_external_macro(cx.sess(), expr.span) || is_from_proc_macro(cx, expr) {
             return;
         }
 
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 2f5932104c1..163844f7448 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -839,7 +839,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(move |_| Box::new(large_stack_arrays::LargeStackArrays::new(array_size_threshold)));
     store.register_late_pass(move |_| Box::new(large_const_arrays::LargeConstArrays::new(array_size_threshold)));
     store.register_late_pass(|_| Box::new(floating_point_arithmetic::FloatingPointArithmetic));
-    store.register_early_pass(|| Box::new(as_conversions::AsConversions));
+    store.register_late_pass(|_| Box::new(as_conversions::AsConversions));
     store.register_late_pass(|_| Box::new(let_underscore::LetUnderscore));
     store.register_early_pass(|| Box::<single_component_path_imports::SingleComponentPathImports>::default());
     let max_fn_params_bools = conf.max_fn_params_bools;
diff --git a/tests/ui/as_conversions.rs b/tests/ui/as_conversions.rs
index 890bf0b0a7e..48ca2f6d143 100644
--- a/tests/ui/as_conversions.rs
+++ b/tests/ui/as_conversions.rs
@@ -1,10 +1,11 @@
 //@aux-build:proc_macros.rs
 
 #![warn(clippy::as_conversions)]
-#![allow(clippy::borrow_as_ptr)]
+#![allow(clippy::borrow_as_ptr, unused)]
 
 extern crate proc_macros;
 use proc_macros::external;
+use proc_macros::with_span;
 
 fn main() {
     let i = 0u32 as u64;
@@ -13,3 +14,11 @@ fn main() {
 
     external!(0u32 as u64);
 }
+
+with_span!(
+    span
+
+    fn coverting() {
+        let x = 0u32 as u64;
+    }
+);
diff --git a/tests/ui/as_conversions.stderr b/tests/ui/as_conversions.stderr
index 54037a64997..ca41d1378aa 100644
--- a/tests/ui/as_conversions.stderr
+++ b/tests/ui/as_conversions.stderr
@@ -1,5 +1,5 @@
 error: using a potentially dangerous silent `as` conversion
-  --> $DIR/as_conversions.rs:10:13
+  --> $DIR/as_conversions.rs:11:13
    |
 LL |     let i = 0u32 as u64;
    |             ^^^^^^^^^^^
@@ -8,7 +8,7 @@ LL |     let i = 0u32 as u64;
    = note: `-D clippy::as-conversions` implied by `-D warnings`
 
 error: using a potentially dangerous silent `as` conversion
-  --> $DIR/as_conversions.rs:12:13
+  --> $DIR/as_conversions.rs:13:13
    |
 LL |     let j = &i as *const u64 as *mut u64;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -16,7 +16,7 @@ LL |     let j = &i as *const u64 as *mut u64;
    = help: consider using a safe wrapper for this conversion
 
 error: using a potentially dangerous silent `as` conversion
-  --> $DIR/as_conversions.rs:12:13
+  --> $DIR/as_conversions.rs:13:13
    |
 LL |     let j = &i as *const u64 as *mut u64;
    |             ^^^^^^^^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From 4346c992cb555b79b68265535f5720033f2bdca7 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Thu, 8 Jun 2023 18:08:06 +0000
Subject: Ignore more pointer types in `unnecessary_cast`

---
 clippy_lints/src/casts/unnecessary_cast.rs | 28 +++++++++-------
 tests/ui/unnecessary_cast.fixed            | 13 ++++++++
 tests/ui/unnecessary_cast.rs               | 13 ++++++++
 tests/ui/unnecessary_cast.stderr           | 52 +++++++++++++++---------------
 4 files changed, 69 insertions(+), 37 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/unnecessary_cast.rs b/clippy_lints/src/casts/unnecessary_cast.rs
index 08ed8a63e1a..d3d80ff4100 100644
--- a/clippy_lints/src/casts/unnecessary_cast.rs
+++ b/clippy_lints/src/casts/unnecessary_cast.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::numeric_literal::NumericLiteral;
 use clippy_utils::source::snippet_opt;
-use clippy_utils::{get_parent_expr, is_ty_alias, path_to_local};
+use clippy_utils::{get_parent_expr, is_hir_ty_cfg_dependant, is_ty_alias, path_to_local};
 use if_chain::if_chain;
 use rustc_ast::{LitFloatType, LitIntType, LitKind};
 use rustc_errors::Applicability;
@@ -27,17 +27,23 @@ pub(super) fn check<'tcx>(
         // check both mutability and type are the same
         if cast_from.kind() == cast_to.kind();
         if let ExprKind::Cast(_, cast_to_hir) = expr.kind;
+        // Ignore casts to e.g. type aliases and infer types
+        // - p as pointer_alias
+        // - p as _
+        if let TyKind::Ptr(to_pointee) = cast_to_hir.kind;
         then {
-            if_chain! {
-                if let TyKind::Path(qpath) = cast_to_hir.kind;
-                if is_ty_alias(&qpath);
-                then {
-                    return false;
-                }
-            }
-
-            if let TyKind::Infer = cast_to_hir.kind {
-                return false;
+            match to_pointee.ty.kind {
+                // Ignore casts to pointers that are aliases or cfg dependant, e.g.
+                // - p as *const std::ffi::c_char (alias)
+                // - p as *const std::os::raw::c_char (cfg dependant)
+                TyKind::Path(qpath) => {
+                    if is_ty_alias(&qpath) || is_hir_ty_cfg_dependant(cx, to_pointee.ty) {
+                        return false;
+                    }
+                },
+                // Ignore `p as *const _`
+                TyKind::Infer => return false,
+                _ => {},
             }
 
             span_lint_and_sugg(
diff --git a/tests/ui/unnecessary_cast.fixed b/tests/ui/unnecessary_cast.fixed
index 0fd49e7c815..e74476044d9 100644
--- a/tests/ui/unnecessary_cast.fixed
+++ b/tests/ui/unnecessary_cast.fixed
@@ -45,6 +45,8 @@ fn main() {
     [1u8, 2].as_mut_ptr() as PtrConstU8;
     let _: *const u8 = [1u8, 2].as_ptr() as _;
     let _: *mut u8 = [1u8, 2].as_mut_ptr() as _;
+    let _: *const u8 = [1u8, 2].as_ptr() as *const _;
+    let _: *mut u8 = [1u8, 2].as_mut_ptr() as *mut _;
 
     owo::<u32>([1u32].as_ptr());
     uwu::<u32, u8>([1u32].as_ptr());
@@ -71,6 +73,17 @@ fn main() {
     1 as I32Alias;
     &1 as &I32Alias;
 
+    let i8_ptr: *const i8 = &1;
+    let u8_ptr: *const u8 = &1;
+
+    // cfg dependant pointees
+    i8_ptr as *const std::os::raw::c_char;
+    u8_ptr as *const std::os::raw::c_char;
+
+    // type aliased pointees
+    i8_ptr as *const std::ffi::c_char;
+    u8_ptr as *const std::ffi::c_char;
+
     // issue #9960
     macro_rules! bind_var {
         ($id:ident, $e:expr) => {{
diff --git a/tests/ui/unnecessary_cast.rs b/tests/ui/unnecessary_cast.rs
index 27669492329..a577fd79899 100644
--- a/tests/ui/unnecessary_cast.rs
+++ b/tests/ui/unnecessary_cast.rs
@@ -45,6 +45,8 @@ fn main() {
     [1u8, 2].as_mut_ptr() as PtrConstU8;
     let _: *const u8 = [1u8, 2].as_ptr() as _;
     let _: *mut u8 = [1u8, 2].as_mut_ptr() as _;
+    let _: *const u8 = [1u8, 2].as_ptr() as *const _;
+    let _: *mut u8 = [1u8, 2].as_mut_ptr() as *mut _;
 
     owo::<u32>([1u32].as_ptr()) as *const u32;
     uwu::<u32, u8>([1u32].as_ptr()) as *const u8;
@@ -71,6 +73,17 @@ fn main() {
     1 as I32Alias;
     &1 as &I32Alias;
 
+    let i8_ptr: *const i8 = &1;
+    let u8_ptr: *const u8 = &1;
+
+    // cfg dependant pointees
+    i8_ptr as *const std::os::raw::c_char;
+    u8_ptr as *const std::os::raw::c_char;
+
+    // type aliased pointees
+    i8_ptr as *const std::ffi::c_char;
+    u8_ptr as *const std::ffi::c_char;
+
     // issue #9960
     macro_rules! bind_var {
         ($id:ident, $e:expr) => {{
diff --git a/tests/ui/unnecessary_cast.stderr b/tests/ui/unnecessary_cast.stderr
index 0e511fb4c7a..7f748fcf4c2 100644
--- a/tests/ui/unnecessary_cast.stderr
+++ b/tests/ui/unnecessary_cast.stderr
@@ -73,157 +73,157 @@ LL |     [1u8, 2].as_mut_ptr() as *mut u8;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `[1u8, 2].as_mut_ptr()`
 
 error: casting raw pointers to the same type and constness is unnecessary (`*const u32` -> `*const u32`)
-  --> $DIR/unnecessary_cast.rs:49:5
+  --> $DIR/unnecessary_cast.rs:51:5
    |
 LL |     owo::<u32>([1u32].as_ptr()) as *const u32;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `owo::<u32>([1u32].as_ptr())`
 
 error: casting raw pointers to the same type and constness is unnecessary (`*const u8` -> `*const u8`)
-  --> $DIR/unnecessary_cast.rs:50:5
+  --> $DIR/unnecessary_cast.rs:52:5
    |
 LL |     uwu::<u32, u8>([1u32].as_ptr()) as *const u8;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `uwu::<u32, u8>([1u32].as_ptr())`
 
 error: casting raw pointers to the same type and constness is unnecessary (`*const u32` -> `*const u32`)
-  --> $DIR/unnecessary_cast.rs:52:5
+  --> $DIR/unnecessary_cast.rs:54:5
    |
 LL |     uwu::<u32, u32>([1u32].as_ptr()) as *const u32;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `uwu::<u32, u32>([1u32].as_ptr())`
 
 error: casting integer literal to `f32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:93:9
+  --> $DIR/unnecessary_cast.rs:106:9
    |
 LL |         100 as f32;
    |         ^^^^^^^^^^ help: try: `100_f32`
 
 error: casting integer literal to `f64` is unnecessary
-  --> $DIR/unnecessary_cast.rs:94:9
+  --> $DIR/unnecessary_cast.rs:107:9
    |
 LL |         100 as f64;
    |         ^^^^^^^^^^ help: try: `100_f64`
 
 error: casting integer literal to `f64` is unnecessary
-  --> $DIR/unnecessary_cast.rs:95:9
+  --> $DIR/unnecessary_cast.rs:108:9
    |
 LL |         100_i32 as f64;
    |         ^^^^^^^^^^^^^^ help: try: `100_f64`
 
 error: casting integer literal to `f32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:96:17
+  --> $DIR/unnecessary_cast.rs:109:17
    |
 LL |         let _ = -100 as f32;
    |                 ^^^^^^^^^^^ help: try: `-100_f32`
 
 error: casting integer literal to `f64` is unnecessary
-  --> $DIR/unnecessary_cast.rs:97:17
+  --> $DIR/unnecessary_cast.rs:110:17
    |
 LL |         let _ = -100 as f64;
    |                 ^^^^^^^^^^^ help: try: `-100_f64`
 
 error: casting integer literal to `f64` is unnecessary
-  --> $DIR/unnecessary_cast.rs:98:17
+  --> $DIR/unnecessary_cast.rs:111:17
    |
 LL |         let _ = -100_i32 as f64;
    |                 ^^^^^^^^^^^^^^^ help: try: `-100_f64`
 
 error: casting float literal to `f32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:99:9
+  --> $DIR/unnecessary_cast.rs:112:9
    |
 LL |         100. as f32;
    |         ^^^^^^^^^^^ help: try: `100_f32`
 
 error: casting float literal to `f64` is unnecessary
-  --> $DIR/unnecessary_cast.rs:100:9
+  --> $DIR/unnecessary_cast.rs:113:9
    |
 LL |         100. as f64;
    |         ^^^^^^^^^^^ help: try: `100_f64`
 
 error: casting integer literal to `u32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:112:9
+  --> $DIR/unnecessary_cast.rs:125:9
    |
 LL |         1 as u32;
    |         ^^^^^^^^ help: try: `1_u32`
 
 error: casting integer literal to `i32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:113:9
+  --> $DIR/unnecessary_cast.rs:126:9
    |
 LL |         0x10 as i32;
    |         ^^^^^^^^^^^ help: try: `0x10_i32`
 
 error: casting integer literal to `usize` is unnecessary
-  --> $DIR/unnecessary_cast.rs:114:9
+  --> $DIR/unnecessary_cast.rs:127:9
    |
 LL |         0b10 as usize;
    |         ^^^^^^^^^^^^^ help: try: `0b10_usize`
 
 error: casting integer literal to `u16` is unnecessary
-  --> $DIR/unnecessary_cast.rs:115:9
+  --> $DIR/unnecessary_cast.rs:128:9
    |
 LL |         0o73 as u16;
    |         ^^^^^^^^^^^ help: try: `0o73_u16`
 
 error: casting integer literal to `u32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:116:9
+  --> $DIR/unnecessary_cast.rs:129:9
    |
 LL |         1_000_000_000 as u32;
    |         ^^^^^^^^^^^^^^^^^^^^ help: try: `1_000_000_000_u32`
 
 error: casting float literal to `f64` is unnecessary
-  --> $DIR/unnecessary_cast.rs:118:9
+  --> $DIR/unnecessary_cast.rs:131:9
    |
 LL |         1.0 as f64;
    |         ^^^^^^^^^^ help: try: `1.0_f64`
 
 error: casting float literal to `f32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:119:9
+  --> $DIR/unnecessary_cast.rs:132:9
    |
 LL |         0.5 as f32;
    |         ^^^^^^^^^^ help: try: `0.5_f32`
 
 error: casting integer literal to `i32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:123:17
+  --> $DIR/unnecessary_cast.rs:136:17
    |
 LL |         let _ = -1 as i32;
    |                 ^^^^^^^^^ help: try: `-1_i32`
 
 error: casting float literal to `f32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:124:17
+  --> $DIR/unnecessary_cast.rs:137:17
    |
 LL |         let _ = -1.0 as f32;
    |                 ^^^^^^^^^^^ help: try: `-1.0_f32`
 
 error: casting to the same type is unnecessary (`i32` -> `i32`)
-  --> $DIR/unnecessary_cast.rs:130:18
+  --> $DIR/unnecessary_cast.rs:143:18
    |
 LL |         let _ = &(x as i32);
    |                  ^^^^^^^^^^ help: try: `{ x }`
 
 error: casting integer literal to `i32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:136:22
+  --> $DIR/unnecessary_cast.rs:149:22
    |
 LL |         let _: i32 = -(1) as i32;
    |                      ^^^^^^^^^^^ help: try: `-1_i32`
 
 error: casting integer literal to `i64` is unnecessary
-  --> $DIR/unnecessary_cast.rs:138:22
+  --> $DIR/unnecessary_cast.rs:151:22
    |
 LL |         let _: i64 = -(1) as i64;
    |                      ^^^^^^^^^^^ help: try: `-1_i64`
 
 error: casting float literal to `f64` is unnecessary
-  --> $DIR/unnecessary_cast.rs:145:22
+  --> $DIR/unnecessary_cast.rs:158:22
    |
 LL |         let _: f64 = (-8.0 as f64).exp();
    |                      ^^^^^^^^^^^^^ help: try: `(-8.0_f64)`
 
 error: casting float literal to `f64` is unnecessary
-  --> $DIR/unnecessary_cast.rs:147:23
+  --> $DIR/unnecessary_cast.rs:160:23
    |
 LL |         let _: f64 = -(8.0 as f64).exp(); // should suggest `-8.0_f64.exp()` here not to change code behavior
    |                       ^^^^^^^^^^^^ help: try: `8.0_f64`
 
 error: casting to the same type is unnecessary (`f32` -> `f32`)
-  --> $DIR/unnecessary_cast.rs:155:20
+  --> $DIR/unnecessary_cast.rs:168:20
    |
 LL |         let _num = foo() as f32;
    |                    ^^^^^^^^^^^^ help: try: `foo()`
-- 
cgit 1.4.1-3-g733a5


From dd084940de3947b7d095fcbd6d3381f98470c58b Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Fri, 9 Jun 2023 04:13:00 +0200
Subject: check that the adjusted receiver type matches target

---
 clippy_lints/src/methods/unnecessary_to_owned.rs |  5 ++++
 tests/ui/unnecessary_to_owned.fixed              | 33 ++++++++++++++++++++++++
 tests/ui/unnecessary_to_owned.rs                 | 33 ++++++++++++++++++++++++
 3 files changed, 71 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/unnecessary_to_owned.rs b/clippy_lints/src/methods/unnecessary_to_owned.rs
index 309d2157b76..da7196ed0a8 100644
--- a/clippy_lints/src/methods/unnecessary_to_owned.rs
+++ b/clippy_lints/src/methods/unnecessary_to_owned.rs
@@ -144,6 +144,11 @@ fn check_addr_of_expr(
                 if let Some(deref_trait_id) = cx.tcx.get_diagnostic_item(sym::Deref);
                 if implements_trait(cx, receiver_ty, deref_trait_id, &[]);
                 if cx.get_associated_type(receiver_ty, deref_trait_id, "Target") == Some(target_ty);
+                // Make sure that it's actually calling the right `.to_string()`, (#10033)
+                // *or* this is a `Cow::into_owned()` call (which would be the wrong into_owned receiver (str != Cow)
+                // but that's ok for Cow::into_owned specifically)
+                if cx.typeck_results().expr_ty_adjusted(receiver).peel_refs() == target_ty
+                    || is_cow_into_owned(cx, method_name, method_def_id);
                 then {
                     if n_receiver_refs > 0 {
                         span_lint_and_sugg(
diff --git a/tests/ui/unnecessary_to_owned.fixed b/tests/ui/unnecessary_to_owned.fixed
index 08733906b0e..592a53f3a81 100644
--- a/tests/ui/unnecessary_to_owned.fixed
+++ b/tests/ui/unnecessary_to_owned.fixed
@@ -474,3 +474,36 @@ mod issue_10021 {
         Ok(())
     }
 }
+
+mod issue_10033 {
+    #![allow(dead_code)]
+    use std::{fmt::Display, ops::Deref};
+
+    fn _main() {
+        let f = Foo;
+
+        // Not actually unnecessary - this calls `Foo`'s `Display` impl, not `str`'s (even though `Foo` does
+        // deref to `str`)
+        foo(&f.to_string());
+    }
+
+    fn foo(s: &str) {
+        println!("{}", s);
+    }
+
+    struct Foo;
+
+    impl Deref for Foo {
+        type Target = str;
+
+        fn deref(&self) -> &Self::Target {
+            "str"
+        }
+    }
+
+    impl Display for Foo {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            write!(f, "Foo")
+        }
+    }
+}
diff --git a/tests/ui/unnecessary_to_owned.rs b/tests/ui/unnecessary_to_owned.rs
index e3589ea0d65..f2e48b1c4a6 100644
--- a/tests/ui/unnecessary_to_owned.rs
+++ b/tests/ui/unnecessary_to_owned.rs
@@ -474,3 +474,36 @@ mod issue_10021 {
         Ok(())
     }
 }
+
+mod issue_10033 {
+    #![allow(dead_code)]
+    use std::{fmt::Display, ops::Deref};
+
+    fn _main() {
+        let f = Foo;
+
+        // Not actually unnecessary - this calls `Foo`'s `Display` impl, not `str`'s (even though `Foo` does
+        // deref to `str`)
+        foo(&f.to_string());
+    }
+
+    fn foo(s: &str) {
+        println!("{}", s);
+    }
+
+    struct Foo;
+
+    impl Deref for Foo {
+        type Target = str;
+
+        fn deref(&self) -> &Self::Target {
+            "str"
+        }
+    }
+
+    impl Display for Foo {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            write!(f, "Foo")
+        }
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 0c545c7bccdb45055f8874fa2700afb1ecb69f1d Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Thu, 18 May 2023 22:13:44 -0500
Subject: also lint single expression blocks

Update mixed_read_write_in_expression.rs

Update diverging_sub_expression.stderr
---
 clippy_lints/src/mixed_read_write_in_expression.rs |  8 ++-
 tests/ui/diverging_sub_expression.rs               |  9 +++
 tests/ui/diverging_sub_expression.stderr           | 84 ++++++++++++++++++++++
 3 files changed, 100 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/mixed_read_write_in_expression.rs b/clippy_lints/src/mixed_read_write_in_expression.rs
index 942453498cd..caa3463b864 100644
--- a/clippy_lints/src/mixed_read_write_in_expression.rs
+++ b/clippy_lints/src/mixed_read_write_in_expression.rs
@@ -139,7 +139,13 @@ impl<'a, 'tcx> Visitor<'tcx> for DivergenceVisitor<'a, 'tcx> {
         match e.kind {
             // fix #10776
             ExprKind::Block(block, ..) => {
-                if let Some(stmt) = block.stmts.first() && block.stmts.len() == 1 {
+                if let Some(e) = block.expr {
+                    self.visit_expr(e);
+
+                    return;
+                }
+
+                if let [stmt] = block.stmts && block.stmts.len() == 1 {
                     match stmt.kind {
                         StmtKind::Expr(e) | StmtKind::Semi(e) => self.visit_expr(e),
                         _ => {},
diff --git a/tests/ui/diverging_sub_expression.rs b/tests/ui/diverging_sub_expression.rs
index 510eca21f71..3a4d66c5ba5 100644
--- a/tests/ui/diverging_sub_expression.rs
+++ b/tests/ui/diverging_sub_expression.rs
@@ -40,6 +40,15 @@ fn foobar() {
             // lint blocks as well
             15 => true || { return; },
             16 => false || { return; },
+            // ... and when it's a single expression
+            17 => true || { return },
+            18 => false || { return },
+            // ... but not when there's both an expression and a statement
+            19 => true || { _ = 1; return },
+            20 => false || { _ = 1; return },
+            // ... or multiple statements
+            21 => true || { _ = 1; return; },
+            22 => false || { _ = 1; return; },
             _ => true || break,
         };
     }
diff --git a/tests/ui/diverging_sub_expression.stderr b/tests/ui/diverging_sub_expression.stderr
index e69de29bb2d..e6396de2bb7 100644
--- a/tests/ui/diverging_sub_expression.stderr
+++ b/tests/ui/diverging_sub_expression.stderr
@@ -0,0 +1,84 @@
+error: sub-expression diverges
+  --> $DIR/diverging_sub_expression.rs:20:10
+   |
+LL |     b || diverge();
+   |          ^^^^^^^^^
+   |
+   = note: `-D clippy::diverging-sub-expression` implied by `-D warnings`
+
+error: sub-expression diverges
+  --> $DIR/diverging_sub_expression.rs:21:10
+   |
+LL |     b || A.foo();
+   |          ^^^^^^^
+
+error: sub-expression diverges
+  --> $DIR/diverging_sub_expression.rs:31:26
+   |
+LL |             6 => true || return,
+   |                          ^^^^^^
+
+error: sub-expression diverges
+  --> $DIR/diverging_sub_expression.rs:32:26
+   |
+LL |             7 => true || continue,
+   |                          ^^^^^^^^
+
+error: sub-expression diverges
+  --> $DIR/diverging_sub_expression.rs:35:26
+   |
+LL |             3 => true || diverge(),
+   |                          ^^^^^^^^^
+
+error: sub-expression diverges
+  --> $DIR/diverging_sub_expression.rs:38:30
+   |
+LL |                 _ => true || panic!("boo"),
+   |                              ^^^^^^^^^^^^^
+   |
+   = note: this error originates in the macro `$crate::panic::panic_2021` which comes from the expansion of the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: sub-expression diverges
+  --> $DIR/diverging_sub_expression.rs:41:29
+   |
+LL |             15 => true || { return; },
+   |                             ^^^^^^
+
+error: sub-expression diverges
+  --> $DIR/diverging_sub_expression.rs:42:30
+   |
+LL |             16 => false || { return; },
+   |                              ^^^^^^
+
+error: sub-expression diverges
+  --> $DIR/diverging_sub_expression.rs:44:29
+   |
+LL |             17 => true || { return },
+   |                             ^^^^^^
+
+error: sub-expression diverges
+  --> $DIR/diverging_sub_expression.rs:45:30
+   |
+LL |             18 => false || { return },
+   |                              ^^^^^^
+
+error: sub-expression diverges
+  --> $DIR/diverging_sub_expression.rs:47:36
+   |
+LL |             19 => true || { _ = 1; return },
+   |                                    ^^^^^^
+
+error: sub-expression diverges
+  --> $DIR/diverging_sub_expression.rs:48:37
+   |
+LL |             20 => false || { _ = 1; return },
+   |                                     ^^^^^^
+
+error: sub-expression diverges
+  --> $DIR/diverging_sub_expression.rs:52:26
+   |
+LL |             _ => true || break,
+   |                          ^^^^^
+
+error: aborting due to 13 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From c1c134a28828c21230bb54ca4c70d027725aa175 Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Fri, 9 Jun 2023 11:43:58 -0500
Subject: ensure there are no stmts for expr check

---
 clippy_lints/src/mixed_read_write_in_expression.rs |  4 ++--
 tests/ui/diverging_sub_expression.stderr           | 14 +-------------
 2 files changed, 3 insertions(+), 15 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/mixed_read_write_in_expression.rs b/clippy_lints/src/mixed_read_write_in_expression.rs
index caa3463b864..ac94820b40b 100644
--- a/clippy_lints/src/mixed_read_write_in_expression.rs
+++ b/clippy_lints/src/mixed_read_write_in_expression.rs
@@ -139,13 +139,13 @@ impl<'a, 'tcx> Visitor<'tcx> for DivergenceVisitor<'a, 'tcx> {
         match e.kind {
             // fix #10776
             ExprKind::Block(block, ..) => {
-                if let Some(e) = block.expr {
+                if let Some(e) = block.expr && block.stmts.is_empty() {
                     self.visit_expr(e);
 
                     return;
                 }
 
-                if let [stmt] = block.stmts && block.stmts.len() == 1 {
+                if let [stmt, rest @ ..] = block.stmts && rest.is_empty() {
                     match stmt.kind {
                         StmtKind::Expr(e) | StmtKind::Semi(e) => self.visit_expr(e),
                         _ => {},
diff --git a/tests/ui/diverging_sub_expression.stderr b/tests/ui/diverging_sub_expression.stderr
index e6396de2bb7..f121159ca3e 100644
--- a/tests/ui/diverging_sub_expression.stderr
+++ b/tests/ui/diverging_sub_expression.stderr
@@ -62,23 +62,11 @@ error: sub-expression diverges
 LL |             18 => false || { return },
    |                              ^^^^^^
 
-error: sub-expression diverges
-  --> $DIR/diverging_sub_expression.rs:47:36
-   |
-LL |             19 => true || { _ = 1; return },
-   |                                    ^^^^^^
-
-error: sub-expression diverges
-  --> $DIR/diverging_sub_expression.rs:48:37
-   |
-LL |             20 => false || { _ = 1; return },
-   |                                     ^^^^^^
-
 error: sub-expression diverges
   --> $DIR/diverging_sub_expression.rs:52:26
    |
 LL |             _ => true || break,
    |                          ^^^^^
 
-error: aborting due to 13 previous errors
+error: aborting due to 11 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 35aff1ae8608beb9637eed518bc4f2f57186df42 Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Fri, 9 Jun 2023 15:32:42 -0500
Subject: refactor

---
 clippy_lints/src/mixed_read_write_in_expression.rs | 20 +++++++-------------
 tests/ui/diverging_sub_expression.rs               |  2 ++
 tests/ui/diverging_sub_expression.stderr           |  2 +-
 3 files changed, 10 insertions(+), 14 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/mixed_read_write_in_expression.rs b/clippy_lints/src/mixed_read_write_in_expression.rs
index ac94820b40b..57ec3a1f1e6 100644
--- a/clippy_lints/src/mixed_read_write_in_expression.rs
+++ b/clippy_lints/src/mixed_read_write_in_expression.rs
@@ -138,19 +138,13 @@ impl<'a, 'tcx> Visitor<'tcx> for DivergenceVisitor<'a, 'tcx> {
     fn visit_expr(&mut self, e: &'tcx Expr<'_>) {
         match e.kind {
             // fix #10776
-            ExprKind::Block(block, ..) => {
-                if let Some(e) = block.expr && block.stmts.is_empty() {
-                    self.visit_expr(e);
-
-                    return;
-                }
-
-                if let [stmt, rest @ ..] = block.stmts && rest.is_empty() {
-                    match stmt.kind {
-                        StmtKind::Expr(e) | StmtKind::Semi(e) => self.visit_expr(e),
-                        _ => {},
-                    }
-                }
+            ExprKind::Block(block, ..) => match (block.stmts, block.expr) {
+                ([], Some(e)) => self.visit_expr(e),
+                ([stmt], None) => match stmt.kind {
+                    StmtKind::Expr(e) | StmtKind::Semi(e) => self.visit_expr(e),
+                    _ => {},
+                },
+                _ => {},
             },
             ExprKind::Continue(_) | ExprKind::Break(_, _) | ExprKind::Ret(_) => self.report_diverging_sub_expr(e),
             ExprKind::Call(func, _) => {
diff --git a/tests/ui/diverging_sub_expression.rs b/tests/ui/diverging_sub_expression.rs
index 3a4d66c5ba5..9b1619baf0e 100644
--- a/tests/ui/diverging_sub_expression.rs
+++ b/tests/ui/diverging_sub_expression.rs
@@ -49,6 +49,8 @@ fn foobar() {
             // ... or multiple statements
             21 => true || { _ = 1; return; },
             22 => false || { _ = 1; return; },
+            23 => true || { return; true },
+            24 => true || { return; true },
             _ => true || break,
         };
     }
diff --git a/tests/ui/diverging_sub_expression.stderr b/tests/ui/diverging_sub_expression.stderr
index f121159ca3e..243a5cf5369 100644
--- a/tests/ui/diverging_sub_expression.stderr
+++ b/tests/ui/diverging_sub_expression.stderr
@@ -63,7 +63,7 @@ LL |             18 => false || { return },
    |                              ^^^^^^
 
 error: sub-expression diverges
-  --> $DIR/diverging_sub_expression.rs:52:26
+  --> $DIR/diverging_sub_expression.rs:54:26
    |
 LL |             _ => true || break,
    |                          ^^^^^
-- 
cgit 1.4.1-3-g733a5


From b7fedb88cffd4156a9a36e22912234fe908ad776 Mon Sep 17 00:00:00 2001
From: Catherine <114838443+Centri3@users.noreply.github.com>
Date: Fri, 9 Jun 2023 16:28:01 -0500
Subject: Update excessive_nesting.rs

---
 clippy_lints/src/excessive_nesting.rs | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/excessive_nesting.rs b/clippy_lints/src/excessive_nesting.rs
index 1c6cd27789d..4c8ea1ed18d 100644
--- a/clippy_lints/src/excessive_nesting.rs
+++ b/clippy_lints/src/excessive_nesting.rs
@@ -24,8 +24,8 @@ declare_clippy_lint! {
     /// # clippy.toml
     /// excessive-nesting-threshold = 3
     /// ```
-    /// lib.rs:
     /// ```rust,ignore
+    /// // lib.rs
     /// pub mod a {
     ///     pub struct X;
     ///     impl X {
@@ -36,9 +36,10 @@ declare_clippy_lint! {
     ///         }
     ///     }
     /// }
+    /// ```
     /// Use instead:
-    /// a.rs:
     /// ```rust,ignore
+    /// // a.rs
     /// fn private_run(x: &X) {
     ///     if true {
     ///         // etc...
@@ -52,8 +53,8 @@ declare_clippy_lint! {
     ///     }
     /// }
     /// ```
-    /// lib.rs:
     /// ```rust,ignore
+    /// lib// .rs
     /// pub mod a;
     /// ```
     #[clippy::version = "1.70.0"]
-- 
cgit 1.4.1-3-g733a5


From d1957b87c8e6345c1908f19a7be8efc266aa3ad5 Mon Sep 17 00:00:00 2001
From: Catherine <114838443+Centri3@users.noreply.github.com>
Date: Fri, 9 Jun 2023 16:29:34 -0500
Subject: Update excessive_nesting.rs

---
 clippy_lints/src/excessive_nesting.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/excessive_nesting.rs b/clippy_lints/src/excessive_nesting.rs
index 4c8ea1ed18d..d04d833e630 100644
--- a/clippy_lints/src/excessive_nesting.rs
+++ b/clippy_lints/src/excessive_nesting.rs
@@ -54,7 +54,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     /// ```rust,ignore
-    /// lib// .rs
+    /// // lib.rs
     /// pub mod a;
     /// ```
     #[clippy::version = "1.70.0"]
-- 
cgit 1.4.1-3-g733a5


From b6fa4d43d3d800224f724baa322f301bf09a5031 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sun, 26 Feb 2023 23:16:27 -0500
Subject: Extend `explicit_iter_loop` to all types

---
 clippy_lints/src/lib.rs                      |   2 +-
 clippy_lints/src/loops/explicit_iter_loop.rs | 200 ++++++++++++++++++++++-----
 clippy_lints/src/loops/mod.rs                |  90 ++++++------
 clippy_utils/src/msrvs.rs                    |   2 +-
 clippy_utils/src/ty.rs                       |  48 +++++++
 tests/ui/for_loop_fixable.fixed              |  91 +++++++++++-
 tests/ui/for_loop_fixable.rs                 |  85 +++++++++++-
 tests/ui/for_loop_fixable.stderr             |  28 +++-
 8 files changed, 460 insertions(+), 86 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 22ff5ef5859..30842cd6510 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -679,7 +679,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     });
     store.register_late_pass(|_| Box::<shadow::Shadow>::default());
     store.register_late_pass(|_| Box::new(unit_types::UnitTypes));
-    store.register_late_pass(|_| Box::new(loops::Loops));
+    store.register_late_pass(move |_| Box::new(loops::Loops::new(msrv())));
     store.register_late_pass(|_| Box::<main_recursion::MainRecursion>::default());
     store.register_late_pass(|_| Box::new(lifetimes::Lifetimes));
     store.register_late_pass(|_| Box::new(entry::HashMapPass));
diff --git a/clippy_lints/src/loops/explicit_iter_loop.rs b/clippy_lints/src/loops/explicit_iter_loop.rs
index 151c7f1d5d2..ba66af62375 100644
--- a/clippy_lints/src/loops/explicit_iter_loop.rs
+++ b/clippy_lints/src/loops/explicit_iter_loop.rs
@@ -1,18 +1,37 @@
 use super::EXPLICIT_ITER_LOOP;
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::is_trait_method;
+use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::ty::{implements_trait_with_env, make_normalized_projection_with_regions, normalize_with_regions,
+    make_normalized_projection, implements_trait, is_copy};
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, Mutability};
 use rustc_lint::LateContext;
-use rustc_middle::ty::{self, Ty};
+use rustc_middle::ty::adjustment::{Adjust, Adjustment, AutoBorrow, AutoBorrowMutability};
+use rustc_middle::ty::{self, EarlyBinder, TypeAndMut, Ty};
 use rustc_span::sym;
 
-pub(super) fn check(cx: &LateContext<'_>, self_arg: &Expr<'_>, arg: &Expr<'_>, method_name: &str) {
-    let should_lint = match method_name {
-        "iter" | "iter_mut" => is_ref_iterable_type(cx, self_arg),
-        "into_iter" if is_trait_method(cx, arg, sym::IntoIterator) => {
+pub(super) fn check(cx: &LateContext<'_>, self_arg: &Expr<'_>, call_expr: &Expr<'_>, method_name: &str, msrv: &Msrv) {
+    let borrow_kind = match method_name {
+        "iter" | "iter_mut" => match is_ref_iterable(cx, self_arg, call_expr) {
+            Some((kind, ty)) => {
+                if let ty::Array(_, count) = *ty.peel_refs().kind() {
+                    if !ty.is_ref() {
+                        if !msrv.meets(msrvs::ARRAY_INTO_ITERATOR) {
+                            return;
+                        }
+                    } else if count.try_eval_target_usize(cx.tcx, cx.param_env).map_or(true, |x| x > 32)
+                        && !msrv.meets(msrvs::ARRAY_IMPL_ANY_LEN)
+                    {
+                        return
+                    }
+                }
+                kind
+            },
+            None => return,
+        },
+        "into_iter" if is_trait_method(cx, call_expr, sym::IntoIterator) => {
             let receiver_ty = cx.typeck_results().expr_ty(self_arg);
             let receiver_ty_adjusted = cx.typeck_results().expr_ty_adjusted(self_arg);
             let ref_receiver_ty = cx.tcx.mk_ref(
@@ -22,54 +41,159 @@ pub(super) fn check(cx: &LateContext<'_>, self_arg: &Expr<'_>, arg: &Expr<'_>, m
                     mutbl: Mutability::Not,
                 },
             );
-            receiver_ty_adjusted == ref_receiver_ty
+            if receiver_ty_adjusted == ref_receiver_ty {
+                AdjustKind::None
+            } else {
+                return;
+            }
         },
-        _ => false,
+        _ => return,
     };
 
-    if !should_lint {
-        return;
-    }
-
     let mut applicability = Applicability::MachineApplicable;
     let object = snippet_with_applicability(cx, self_arg.span, "_", &mut applicability);
-    let muta = if method_name == "iter_mut" { "mut " } else { "" };
+    let prefix = match borrow_kind {
+        AdjustKind::None => "",
+        AdjustKind::Borrow => "&",
+        AdjustKind::BorrowMut => "&mut ",
+        AdjustKind::Deref => "*",
+        AdjustKind::Reborrow => "&*",
+        AdjustKind::ReborrowMut => "&mut *",
+    };
     span_lint_and_sugg(
         cx,
         EXPLICIT_ITER_LOOP,
-        arg.span,
+        call_expr.span,
         "it is more concise to loop over references to containers instead of using explicit \
          iteration methods",
         "to write this more concisely, try",
-        format!("&{muta}{object}"),
+        format!("{prefix}{object}"),
         applicability,
     );
 }
 
-/// Returns `true` if the type of expr is one that provides `IntoIterator` impls
-/// for `&T` and `&mut T`, such as `Vec`.
-#[rustfmt::skip]
-fn is_ref_iterable_type(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
-    // no walk_ptrs_ty: calling iter() on a reference can make sense because it
-    // will allow further borrows afterwards
-    let ty = cx.typeck_results().expr_ty(e);
-    is_iterable_array(ty, cx) ||
-    is_type_diagnostic_item(cx, ty, sym::Vec) ||
-    is_type_diagnostic_item(cx, ty, sym::LinkedList) ||
-    is_type_diagnostic_item(cx, ty, sym::HashMap) ||
-    is_type_diagnostic_item(cx, ty, sym::HashSet) ||
-    is_type_diagnostic_item(cx, ty, sym::VecDeque) ||
-    is_type_diagnostic_item(cx, ty, sym::BinaryHeap) ||
-    is_type_diagnostic_item(cx, ty, sym::BTreeMap) ||
-    is_type_diagnostic_item(cx, ty, sym::BTreeSet)
+enum AdjustKind {
+    None,
+    Borrow,
+    BorrowMut,
+    Deref,
+    Reborrow,
+    ReborrowMut,
+}
+impl AdjustKind {
+    fn borrow(mutbl: Mutability) -> Self {
+        match mutbl {
+            Mutability::Not => Self::Borrow,
+            Mutability::Mut => Self::BorrowMut,
+        }
+    }
+
+    fn auto_borrow(mutbl: AutoBorrowMutability) -> Self {
+        match mutbl {
+            AutoBorrowMutability::Not => Self::Borrow,
+            AutoBorrowMutability::Mut { .. } => Self::BorrowMut,
+        }
+    }
+
+    fn reborrow(mutbl: AutoBorrowMutability) -> Self {
+        match mutbl {
+            AutoBorrowMutability::Not => Self::Reborrow,
+            AutoBorrowMutability::Mut { .. } => Self::ReborrowMut,
+        }
+    }
 }
 
-fn is_iterable_array<'tcx>(ty: Ty<'tcx>, cx: &LateContext<'tcx>) -> bool {
-    // IntoIterator is currently only implemented for array sizes <= 32 in rustc
-    match ty.kind() {
-        ty::Array(_, n) => n
-            .try_eval_target_usize(cx.tcx, cx.param_env)
-            .map_or(false, |val| (0..=32).contains(&val)),
-        _ => false,
+/// Checks if an `iter` or `iter_mut` call returns `IntoIterator::IntoIter`. Returns how the
+/// argument needs to be adjusted.
+fn is_ref_iterable<'tcx>(cx: &LateContext<'tcx>, self_arg: &Expr<'_>, call_expr: &Expr<'_>) -> Option<(AdjustKind, Ty<'tcx>)> {
+    let typeck = cx.typeck_results();
+    if let Some(trait_id) = cx.tcx.get_diagnostic_item(sym::IntoIterator)
+        && let Some(fn_id) = typeck.type_dependent_def_id(call_expr.hir_id)
+        && let sig = cx.tcx.liberate_late_bound_regions(fn_id, cx.tcx.fn_sig(fn_id).skip_binder())
+        && let &[req_self_ty, req_res_ty] = &**sig.inputs_and_output
+        && let param_env = cx.tcx.param_env(fn_id)
+        && implements_trait_with_env(cx.tcx, param_env, req_self_ty, trait_id, [])
+        && let Some(into_iter_ty) =
+            make_normalized_projection_with_regions(cx.tcx, param_env, trait_id, sym!(IntoIter), [req_self_ty])
+        && let req_res_ty = normalize_with_regions(cx.tcx, param_env, req_res_ty)
+        && into_iter_ty == req_res_ty
+    {
+        let adjustments = typeck.expr_adjustments(self_arg);
+        let self_ty = typeck.expr_ty(self_arg);
+        let self_is_copy = is_copy(cx, self_ty);
+
+        if adjustments.is_empty() && self_is_copy {
+            return Some((AdjustKind::None, self_ty));
+        }
+
+        let res_ty = cx.tcx.erase_regions(EarlyBinder::bind(req_res_ty).subst(cx.tcx, typeck.node_substs(call_expr.hir_id)));
+        if !adjustments.is_empty() && self_is_copy {
+            if implements_trait(cx, self_ty, trait_id, &[])
+                && let Some(ty) = make_normalized_projection(cx.tcx, cx.param_env, trait_id, sym!(IntoIter), [self_ty])
+                && ty == res_ty
+            {
+                return Some((AdjustKind::None, self_ty));
+            }
+        }
+
+        let mutbl = if let ty::Ref(_, _, mutbl) = *req_self_ty.kind() {
+            Some(mutbl)
+        } else {
+            None
+        };
+        if let Some(mutbl) = mutbl
+            && !self_ty.is_ref()
+        {
+            let self_ty = cx.tcx.mk_ref(cx.tcx.lifetimes.re_erased, TypeAndMut {
+                ty: self_ty,
+                mutbl,
+            });
+            if implements_trait(cx, self_ty, trait_id, &[])
+                && let Some(ty) = make_normalized_projection(cx.tcx, cx.param_env, trait_id, sym!(IntoIter), [self_ty])
+                && ty == res_ty
+            {
+                return Some((AdjustKind::borrow(mutbl), self_ty));
+            }
+        }
+
+        match adjustments {
+            [] => Some((AdjustKind::None, self_ty)),
+            &[Adjustment { kind: Adjust::Deref(_), ..}, Adjustment { kind: Adjust::Borrow(AutoBorrow::Ref(_, mutbl)), target }, ..] => {
+                if target != self_ty
+                    && implements_trait(cx, target, trait_id, &[])
+                    && let Some(ty) = make_normalized_projection(cx.tcx, cx.param_env, trait_id, sym!(IntoIter), [target])
+                    && ty == res_ty
+                {
+                    Some((AdjustKind::reborrow(mutbl), target))
+                } else {
+                    None
+                }
+            }
+            &[Adjustment { kind: Adjust::Deref(_), target }, ..] => {
+                if is_copy(cx, target)
+                    && implements_trait(cx, target, trait_id, &[])
+                    && let Some(ty) = make_normalized_projection(cx.tcx, cx.param_env, trait_id, sym!(IntoIter), [target])
+                    && ty == res_ty
+                {
+                    Some((AdjustKind::Deref, target))
+                } else {
+                    None
+                }
+            }
+            &[Adjustment { kind: Adjust::Borrow(AutoBorrow::Ref(_, mutbl)), target }, ..] => {
+                if self_ty.is_ref()
+                    && implements_trait(cx, target, trait_id, &[])
+                    && let Some(ty) = make_normalized_projection(cx.tcx, cx.param_env, trait_id, sym!(IntoIter), [target])
+                    && ty == res_ty
+                {
+                    Some((AdjustKind::auto_borrow(mutbl), target))
+                } else {
+                    None
+                }
+            }
+            _ => None,
+        }
+    } else {
+        None
     }
 }
diff --git a/clippy_lints/src/loops/mod.rs b/clippy_lints/src/loops/mod.rs
index c7c11809752..068166bdeb2 100644
--- a/clippy_lints/src/loops/mod.rs
+++ b/clippy_lints/src/loops/mod.rs
@@ -20,9 +20,10 @@ mod while_let_loop;
 mod while_let_on_iterator;
 
 use clippy_utils::higher;
+use clippy_utils::msrvs::Msrv;
 use rustc_hir::{Expr, ExprKind, LoopSource, Pat};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::Span;
 use utils::{make_iterator_snippet, IncrementVisitor, InitializeVisitor};
 
@@ -606,7 +607,15 @@ declare_clippy_lint! {
     "checking for emptiness of a `Vec` in the loop condition and popping an element in the body"
 }
 
-declare_lint_pass!(Loops => [
+pub struct Loops {
+    msrv: Msrv,
+}
+impl Loops {
+    pub fn new(msrv: Msrv) -> Self {
+        Self { msrv }
+    }
+}
+impl_lint_pass!(Loops => [
     MANUAL_MEMCPY,
     MANUAL_FLATTEN,
     NEEDLESS_RANGE_LOOP,
@@ -645,7 +654,7 @@ impl<'tcx> LateLintPass<'tcx> for Loops {
             if body.span.from_expansion() {
                 return;
             }
-            check_for_loop(cx, pat, arg, body, expr, span);
+            self.check_for_loop(cx, pat, arg, body, expr, span);
             if let ExprKind::Block(block, _) = body.kind {
                 never_loop::check(cx, block, loop_id, span, for_loop.as_ref());
             }
@@ -680,44 +689,47 @@ impl<'tcx> LateLintPass<'tcx> for Loops {
     }
 }
 
-fn check_for_loop<'tcx>(
-    cx: &LateContext<'tcx>,
-    pat: &'tcx Pat<'_>,
-    arg: &'tcx Expr<'_>,
-    body: &'tcx Expr<'_>,
-    expr: &'tcx Expr<'_>,
-    span: Span,
-) {
-    let is_manual_memcpy_triggered = manual_memcpy::check(cx, pat, arg, body, expr);
-    if !is_manual_memcpy_triggered {
-        needless_range_loop::check(cx, pat, arg, body, expr);
-        explicit_counter_loop::check(cx, pat, arg, body, expr);
+impl Loops {
+    fn check_for_loop<'tcx>(
+        &self,
+        cx: &LateContext<'tcx>,
+        pat: &'tcx Pat<'_>,
+        arg: &'tcx Expr<'_>,
+        body: &'tcx Expr<'_>,
+        expr: &'tcx Expr<'_>,
+        span: Span,
+    ) {
+        let is_manual_memcpy_triggered = manual_memcpy::check(cx, pat, arg, body, expr);
+        if !is_manual_memcpy_triggered {
+            needless_range_loop::check(cx, pat, arg, body, expr);
+            explicit_counter_loop::check(cx, pat, arg, body, expr);
+        }
+        self.check_for_loop_arg(cx, pat, arg);
+        for_kv_map::check(cx, pat, arg, body);
+        mut_range_bound::check(cx, arg, body);
+        single_element_loop::check(cx, pat, arg, body, expr);
+        same_item_push::check(cx, pat, arg, body, expr);
+        manual_flatten::check(cx, pat, arg, body, span);
+        manual_find::check(cx, pat, arg, body, span, expr);
     }
-    check_for_loop_arg(cx, pat, arg);
-    for_kv_map::check(cx, pat, arg, body);
-    mut_range_bound::check(cx, arg, body);
-    single_element_loop::check(cx, pat, arg, body, expr);
-    same_item_push::check(cx, pat, arg, body, expr);
-    manual_flatten::check(cx, pat, arg, body, span);
-    manual_find::check(cx, pat, arg, body, span, expr);
-}
 
-fn check_for_loop_arg(cx: &LateContext<'_>, _: &Pat<'_>, arg: &Expr<'_>) {
-    if let ExprKind::MethodCall(method, self_arg, [], _) = arg.kind {
-        let method_name = method.ident.as_str();
-        // check for looping over x.iter() or x.iter_mut(), could use &x or &mut x
-        match method_name {
-            "iter" | "iter_mut" => {
-                explicit_iter_loop::check(cx, self_arg, arg, method_name);
-            },
-            "into_iter" => {
-                explicit_iter_loop::check(cx, self_arg, arg, method_name);
-                explicit_into_iter_loop::check(cx, self_arg, arg);
-            },
-            "next" => {
-                iter_next_loop::check(cx, arg);
-            },
-            _ => {},
+    fn check_for_loop_arg(&self, cx: &LateContext<'_>, _: &Pat<'_>, arg: &Expr<'_>) {
+        if let ExprKind::MethodCall(method, self_arg, [], _) = arg.kind {
+            let method_name = method.ident.as_str();
+            // check for looping over x.iter() or x.iter_mut(), could use &x or &mut x
+            match method_name {
+                "iter" | "iter_mut" => {
+                    explicit_iter_loop::check(cx, self_arg, arg, method_name, &self.msrv);
+                },
+                "into_iter" => {
+                    explicit_iter_loop::check(cx, self_arg, arg, method_name, &self.msrv);
+                    explicit_into_iter_loop::check(cx, self_arg, arg);
+                },
+                "next" => {
+                    iter_next_loop::check(cx, arg);
+                },
+                _ => {},
+            }
         }
     }
 }
diff --git a/clippy_utils/src/msrvs.rs b/clippy_utils/src/msrvs.rs
index 6f102308f0b..e1b1a6f7184 100644
--- a/clippy_utils/src/msrvs.rs
+++ b/clippy_utils/src/msrvs.rs
@@ -28,7 +28,7 @@ msrv_aliases! {
     1,52,0 { STR_SPLIT_ONCE, REM_EUCLID_CONST }
     1,51,0 { BORROW_AS_PTR, SEEK_FROM_CURRENT, UNSIGNED_ABS }
     1,50,0 { BOOL_THEN, CLAMP }
-    1,47,0 { TAU, IS_ASCII_DIGIT_CONST }
+    1,47,0 { TAU, IS_ASCII_DIGIT_CONST, ARRAY_IMPL_ANY_LEN }
     1,46,0 { CONST_IF_MATCH }
     1,45,0 { STR_STRIP_PREFIX }
     1,43,0 { LOG2_10, LOG10_2 }
diff --git a/clippy_utils/src/ty.rs b/clippy_utils/src/ty.rs
index 7b4ed77e8ed..78b14dc7abb 100644
--- a/clippy_utils/src/ty.rs
+++ b/clippy_utils/src/ty.rs
@@ -1180,3 +1180,51 @@ pub fn is_interior_mut_ty<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
         _ => false,
     }
 }
+
+pub fn make_normalized_projection_with_regions<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    param_env: ParamEnv<'tcx>,
+    container_id: DefId,
+    assoc_ty: Symbol,
+    substs: impl IntoIterator<Item = impl Into<GenericArg<'tcx>>>,
+) -> Option<Ty<'tcx>> {
+    fn helper<'tcx>(tcx: TyCtxt<'tcx>, param_env: ParamEnv<'tcx>, ty: AliasTy<'tcx>) -> Option<Ty<'tcx>> {
+        #[cfg(debug_assertions)]
+        if let Some((i, subst)) = ty
+            .substs
+            .iter()
+            .enumerate()
+            .find(|(_, subst)| subst.has_late_bound_regions())
+        {
+            debug_assert!(
+                false,
+                "substs contain late-bound region at index `{i}` which can't be normalized.\n\
+                    use `TyCtxt::erase_late_bound_regions`\n\
+                    note: subst is `{subst:#?}`",
+            );
+            return None;
+        }
+        let cause = rustc_middle::traits::ObligationCause::dummy();
+        match tcx
+            .infer_ctxt()
+            .build()
+            .at(&cause, param_env)
+            .query_normalize(tcx.mk_projection(ty.def_id, ty.substs))
+        {
+            Ok(ty) => Some(ty.value),
+            Err(e) => {
+                debug_assert!(false, "failed to normalize type `{ty}`: {e:#?}");
+                None
+            },
+        }
+    }
+    helper(tcx, param_env, make_projection(tcx, container_id, assoc_ty, substs)?)
+}
+
+pub fn normalize_with_regions<'tcx>(tcx: TyCtxt<'tcx>, param_env: ParamEnv<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx> {
+    let cause = rustc_middle::traits::ObligationCause::dummy();
+    match tcx.infer_ctxt().build().at(&cause, param_env).query_normalize(ty) {
+        Ok(ty) => ty.value,
+        Err(_) => ty,
+    }
+}
diff --git a/tests/ui/for_loop_fixable.fixed b/tests/ui/for_loop_fixable.fixed
index 3e74e2a02d0..99230856446 100644
--- a/tests/ui/for_loop_fixable.fixed
+++ b/tests/ui/for_loop_fixable.fixed
@@ -1,6 +1,6 @@
 //@run-rustfix
 #![allow(dead_code, unused)]
-#![allow(clippy::uninlined_format_args, clippy::useless_vec)]
+#![allow(clippy::uninlined_format_args, clippy::useless_vec, clippy::deref_addrof)]
 
 use std::collections::*;
 
@@ -52,11 +52,11 @@ fn main() {
 
     for _v in &[1, 2, 3] {}
 
-    for _v in (&mut [1, 2, 3]).iter() {} // no error
+    for _v in &*(&mut [1, 2, 3]) {} // no error
 
     for _v in &[0; 32] {}
 
-    for _v in [0; 33].iter() {} // no error
+    for _v in &[0; 33] {} // no error
 
     let ll: LinkedList<()> = LinkedList::new();
     for _v in &ll {}
@@ -272,7 +272,7 @@ mod issue_4958 {
         let rr = &&t;
 
         // This case is handled by `explicit_iter_loop`. No idea why.
-        for _ in &t {}
+        for _ in t {}
 
         for _ in r {}
 
@@ -307,3 +307,86 @@ mod issue_6900 {
         }
     }
 }
+
+struct IntoIterDiffTy;
+impl IntoIterator for &'_ IntoIterDiffTy {
+    type Item = &'static ();
+    type IntoIter = core::slice::Iter<'static, ()>;
+    fn into_iter(self) -> Self::IntoIter {
+        unimplemented!()
+    }
+}
+impl IntoIterDiffTy {
+    fn iter(&self) -> core::slice::Iter<'static, i32> {
+        unimplemented!()
+    }
+}
+
+struct IntoIterDiffSig;
+impl IntoIterator for &'_ IntoIterDiffSig {
+    type Item = &'static ();
+    type IntoIter = core::slice::Iter<'static, ()>;
+    fn into_iter(self) -> Self::IntoIter {
+        unimplemented!()
+    }
+}
+impl IntoIterDiffSig {
+    fn iter(&self, _: u32) -> core::slice::Iter<'static, ()> {
+        unimplemented!()
+    }
+}
+
+struct IntoIterDiffLt<'a>(&'a ());
+impl<'a> IntoIterator for &'a IntoIterDiffLt<'_> {
+    type Item = &'a ();
+    type IntoIter = core::slice::Iter<'a, ()>;
+    fn into_iter(self) -> Self::IntoIter {
+        unimplemented!()
+    }
+}
+impl<'a> IntoIterDiffLt<'a> {
+    fn iter(&self) -> core::slice::Iter<'a, ()> {
+        unimplemented!()
+    }
+}
+
+struct CustomType;
+impl<'a> IntoIterator for &'a CustomType {
+    type Item = &'a u32;
+    type IntoIter = core::slice::Iter<'a, u32>;
+    fn into_iter(self) -> Self::IntoIter {
+        unimplemented!()
+    }
+}
+impl<'a> IntoIterator for &'a mut CustomType {
+    type Item = &'a mut u32;
+    type IntoIter = core::slice::IterMut<'a, u32>;
+    fn into_iter(self) -> Self::IntoIter {
+        unimplemented!()
+    }
+}
+impl CustomType {
+    fn iter(&self) -> <&'_ Self as IntoIterator>::IntoIter {
+        panic!()
+    }
+
+    fn iter_mut(&mut self) -> core::slice::IterMut<'_, u32> {
+        panic!()
+    }
+}
+
+#[warn(clippy::explicit_iter_loop)]
+fn _f() {
+    let x = IntoIterDiffTy;
+    for _ in x.iter() {}
+
+    let x = IntoIterDiffSig;
+    for _ in x.iter(0) {}
+
+    let x = IntoIterDiffLt(&());
+    for _ in x.iter() {}
+
+    let mut x = CustomType;
+    for _ in &x {}
+    for _ in &mut x {}
+}
diff --git a/tests/ui/for_loop_fixable.rs b/tests/ui/for_loop_fixable.rs
index 45c6760f89e..0d7fe3c0314 100644
--- a/tests/ui/for_loop_fixable.rs
+++ b/tests/ui/for_loop_fixable.rs
@@ -1,6 +1,6 @@
 //@run-rustfix
 #![allow(dead_code, unused)]
-#![allow(clippy::uninlined_format_args, clippy::useless_vec)]
+#![allow(clippy::uninlined_format_args, clippy::useless_vec, clippy::deref_addrof)]
 
 use std::collections::*;
 
@@ -307,3 +307,86 @@ mod issue_6900 {
         }
     }
 }
+
+struct IntoIterDiffTy;
+impl IntoIterator for &'_ IntoIterDiffTy {
+    type Item = &'static ();
+    type IntoIter = core::slice::Iter<'static, ()>;
+    fn into_iter(self) -> Self::IntoIter {
+        unimplemented!()
+    }
+}
+impl IntoIterDiffTy {
+    fn iter(&self) -> core::slice::Iter<'static, i32> {
+        unimplemented!()
+    }
+}
+
+struct IntoIterDiffSig;
+impl IntoIterator for &'_ IntoIterDiffSig {
+    type Item = &'static ();
+    type IntoIter = core::slice::Iter<'static, ()>;
+    fn into_iter(self) -> Self::IntoIter {
+        unimplemented!()
+    }
+}
+impl IntoIterDiffSig {
+    fn iter(&self, _: u32) -> core::slice::Iter<'static, ()> {
+        unimplemented!()
+    }
+}
+
+struct IntoIterDiffLt<'a>(&'a ());
+impl<'a> IntoIterator for &'a IntoIterDiffLt<'_> {
+    type Item = &'a ();
+    type IntoIter = core::slice::Iter<'a, ()>;
+    fn into_iter(self) -> Self::IntoIter {
+        unimplemented!()
+    }
+}
+impl<'a> IntoIterDiffLt<'a> {
+    fn iter(&self) -> core::slice::Iter<'a, ()> {
+        unimplemented!()
+    }
+}
+
+struct CustomType;
+impl<'a> IntoIterator for &'a CustomType {
+    type Item = &'a u32;
+    type IntoIter = core::slice::Iter<'a, u32>;
+    fn into_iter(self) -> Self::IntoIter {
+        unimplemented!()
+    }
+}
+impl<'a> IntoIterator for &'a mut CustomType {
+    type Item = &'a mut u32;
+    type IntoIter = core::slice::IterMut<'a, u32>;
+    fn into_iter(self) -> Self::IntoIter {
+        unimplemented!()
+    }
+}
+impl CustomType {
+    fn iter(&self) -> <&'_ Self as IntoIterator>::IntoIter {
+        panic!()
+    }
+
+    fn iter_mut(&mut self) -> core::slice::IterMut<'_, u32> {
+        panic!()
+    }
+}
+
+#[warn(clippy::explicit_iter_loop)]
+fn _f() {
+    let x = IntoIterDiffTy;
+    for _ in x.iter() {}
+
+    let x = IntoIterDiffSig;
+    for _ in x.iter(0) {}
+
+    let x = IntoIterDiffLt(&());
+    for _ in x.iter() {}
+
+    let mut x = CustomType;
+    for _ in x.iter() {}
+    for _ in x.iter_mut() {}
+}
diff --git a/tests/ui/for_loop_fixable.stderr b/tests/ui/for_loop_fixable.stderr
index ddfe66d675f..4ad23e0b9db 100644
--- a/tests/ui/for_loop_fixable.stderr
+++ b/tests/ui/for_loop_fixable.stderr
@@ -26,12 +26,24 @@ error: it is more concise to loop over references to containers instead of using
 LL |     for _v in [1, 2, 3].iter() {}
    |               ^^^^^^^^^^^^^^^^ help: to write this more concisely, try: `&[1, 2, 3]`
 
+error: it is more concise to loop over references to containers instead of using explicit iteration methods
+  --> $DIR/for_loop_fixable.rs:55:15
+   |
+LL |     for _v in (&mut [1, 2, 3]).iter() {} // no error
+   |               ^^^^^^^^^^^^^^^^^^^^^^^ help: to write this more concisely, try: `&*(&mut [1, 2, 3])`
+
 error: it is more concise to loop over references to containers instead of using explicit iteration methods
   --> $DIR/for_loop_fixable.rs:57:15
    |
 LL |     for _v in [0; 32].iter() {}
    |               ^^^^^^^^^^^^^^ help: to write this more concisely, try: `&[0; 32]`
 
+error: it is more concise to loop over references to containers instead of using explicit iteration methods
+  --> $DIR/for_loop_fixable.rs:59:15
+   |
+LL |     for _v in [0; 33].iter() {} // no error
+   |               ^^^^^^^^^^^^^^ help: to write this more concisely, try: `&[0; 33]`
+
 error: it is more concise to loop over references to containers instead of using explicit iteration methods
   --> $DIR/for_loop_fixable.rs:62:15
    |
@@ -84,7 +96,7 @@ error: it is more concise to loop over references to containers instead of using
   --> $DIR/for_loop_fixable.rs:275:18
    |
 LL |         for _ in t.into_iter() {}
-   |                  ^^^^^^^^^^^^^ help: to write this more concisely, try: `&t`
+   |                  ^^^^^^^^^^^^^ help: to write this more concisely, try: `t`
 
 error: it is more concise to loop over containers instead of using explicit iteration methods
   --> $DIR/for_loop_fixable.rs:277:18
@@ -92,5 +104,17 @@ error: it is more concise to loop over containers instead of using explicit iter
 LL |         for _ in r.into_iter() {}
    |                  ^^^^^^^^^^^^^ help: to write this more concisely, try: `r`
 
-error: aborting due to 15 previous errors
+error: it is more concise to loop over references to containers instead of using explicit iteration methods
+  --> $DIR/for_loop_fixable.rs:390:14
+   |
+LL |     for _ in x.iter() {}
+   |              ^^^^^^^^ help: to write this more concisely, try: `&x`
+
+error: it is more concise to loop over references to containers instead of using explicit iteration methods
+  --> $DIR/for_loop_fixable.rs:391:14
+   |
+LL |     for _ in x.iter_mut() {}
+   |              ^^^^^^^^^^^^ help: to write this more concisely, try: `&mut x`
+
+error: aborting due to 19 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 9d58a426230b5b4200791b9bedee1b14cb971197 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Sat, 10 Jun 2023 01:38:04 +0200
Subject: [`map_unwrap_or`]: don't lint when referenced variable is moved

---
 clippy_lints/src/methods/option_map_unwrap_or.rs | 87 ++++++++++++++++--------
 tests/ui/map_unwrap_or.rs                        | 29 ++++++++
 2 files changed, 88 insertions(+), 28 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/option_map_unwrap_or.rs b/clippy_lints/src/methods/option_map_unwrap_or.rs
index 4c6328481e4..e931c6277f4 100644
--- a/clippy_lints/src/methods/option_map_unwrap_or.rs
+++ b/clippy_lints/src/methods/option_map_unwrap_or.rs
@@ -4,12 +4,17 @@ use clippy_utils::ty::is_copy;
 use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Applicability;
+use rustc_hir::def::Res;
 use rustc_hir::intravisit::{walk_path, Visitor};
+use rustc_hir::ExprKind;
+use rustc_hir::Node;
+use rustc_hir::PatKind;
+use rustc_hir::QPath;
 use rustc_hir::{self, HirId, Path};
 use rustc_lint::LateContext;
 use rustc_middle::hir::nested_filter;
 use rustc_span::source_map::Span;
-use rustc_span::{sym, Symbol};
+use rustc_span::sym;
 
 use super::MAP_UNWRAP_OR;
 
@@ -26,8 +31,22 @@ pub(super) fn check<'tcx>(
     // lint if the caller of `map()` is an `Option`
     if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(recv), sym::Option) {
         if !is_copy(cx, cx.typeck_results().expr_ty(unwrap_arg)) {
-            // Do not lint if the `map` argument uses identifiers in the `map`
-            // argument that are also used in the `unwrap_or` argument
+            // Replacing `.map(<f>).unwrap_or(<a>)` with `.map_or(<a>, <f>)` can sometimes lead to
+            // borrowck errors, see #10579 for one such instance.
+            // In particular, if `a` causes a move and `f` references that moved binding, then we cannot lint:
+            // ```
+            // let x = vec![1, 2];
+            // x.get(0..1).map(|s| s.to_vec()).unwrap_or(x);
+            // ```
+            // This compiles, but changing it to `map_or` will produce a compile error:
+            // ```
+            // let x = vec![1, 2];
+            // x.get(0..1).map_or(x, |s| s.to_vec())
+            //                    ^ moving `x` here
+            // ^^^^^^^^^^^ while it is borrowed here (and later used in the closure)
+            // ```
+            // So, we have to check that `a` is not referenced anywhere (even outside of the `.map` closure!)
+            // before the call to `unwrap_or`.
 
             let mut unwrap_visitor = UnwrapVisitor {
                 cx,
@@ -35,14 +54,18 @@ pub(super) fn check<'tcx>(
             };
             unwrap_visitor.visit_expr(unwrap_arg);
 
-            let mut map_expr_visitor = MapExprVisitor {
+            let mut reference_visitor = ReferenceVisitor {
                 cx,
                 identifiers: unwrap_visitor.identifiers,
-                found_identifier: false,
+                found_reference: false,
+                unwrap_or_span: unwrap_arg.span,
             };
-            map_expr_visitor.visit_expr(map_arg);
 
-            if map_expr_visitor.found_identifier {
+            let map = cx.tcx.hir();
+            let body = map.body(map.body_owned_by(map.enclosing_body_owner(expr.hir_id)));
+            reference_visitor.visit_body(body);
+
+            if reference_visitor.found_reference {
                 return;
             }
         }
@@ -91,14 +114,19 @@ pub(super) fn check<'tcx>(
 
 struct UnwrapVisitor<'a, 'tcx> {
     cx: &'a LateContext<'tcx>,
-    identifiers: FxHashSet<Symbol>,
+    identifiers: FxHashSet<HirId>,
 }
 
 impl<'a, 'tcx> Visitor<'tcx> for UnwrapVisitor<'a, 'tcx> {
     type NestedFilter = nested_filter::All;
 
-    fn visit_path(&mut self, path: &Path<'tcx>, _id: HirId) {
-        self.identifiers.insert(ident(path));
+    fn visit_path(&mut self, path: &Path<'tcx>, _: HirId) {
+        if let Res::Local(local_id) = path.res
+            && let Some(Node::Pat(pat)) = self.cx.tcx.hir().find(local_id)
+            && let PatKind::Binding(_, local_id, ..) = pat.kind
+        {
+            self.identifiers.insert(local_id);
+        }
         walk_path(self, path);
     }
 
@@ -107,32 +135,35 @@ impl<'a, 'tcx> Visitor<'tcx> for UnwrapVisitor<'a, 'tcx> {
     }
 }
 
-struct MapExprVisitor<'a, 'tcx> {
+struct ReferenceVisitor<'a, 'tcx> {
     cx: &'a LateContext<'tcx>,
-    identifiers: FxHashSet<Symbol>,
-    found_identifier: bool,
+    identifiers: FxHashSet<HirId>,
+    found_reference: bool,
+    unwrap_or_span: Span,
 }
 
-impl<'a, 'tcx> Visitor<'tcx> for MapExprVisitor<'a, 'tcx> {
+impl<'a, 'tcx> Visitor<'tcx> for ReferenceVisitor<'a, 'tcx> {
     type NestedFilter = nested_filter::All;
-
-    fn visit_path(&mut self, path: &Path<'tcx>, _id: HirId) {
-        if self.identifiers.contains(&ident(path)) {
-            self.found_identifier = true;
-            return;
+    fn visit_expr(&mut self, expr: &'tcx rustc_hir::Expr<'_>) {
+        // If we haven't found a reference yet, check if this references
+        // one of the locals that was moved in the `unwrap_or` argument.
+        // We are only interested in exprs that appear before the `unwrap_or` call.
+        if !self.found_reference {
+            if expr.span < self.unwrap_or_span
+                && let ExprKind::Path(ref path) = expr.kind
+                && let QPath::Resolved(_, path) = path
+                && let Res::Local(local_id) = path.res
+                && let Some(Node::Pat(pat)) = self.cx.tcx.hir().find(local_id)
+                && let PatKind::Binding(_, local_id, ..) = pat.kind
+                && self.identifiers.contains(&local_id)
+            {
+                self.found_reference = true;
+            }
+            rustc_hir::intravisit::walk_expr(self, expr);
         }
-        walk_path(self, path);
     }
 
     fn nested_visit_map(&mut self) -> Self::Map {
         self.cx.tcx.hir()
     }
 }
-
-fn ident(path: &Path<'_>) -> Symbol {
-    path.segments
-        .last()
-        .expect("segments should be composed of at least 1 element")
-        .ident
-        .name
-}
diff --git a/tests/ui/map_unwrap_or.rs b/tests/ui/map_unwrap_or.rs
index cb25d8567aa..0cd49dd7760 100644
--- a/tests/ui/map_unwrap_or.rs
+++ b/tests/ui/map_unwrap_or.rs
@@ -94,3 +94,32 @@ fn msrv_1_41() {
 
     let _ = res.map(|x| x + 1).unwrap_or_else(|_e| 0);
 }
+
+mod issue_10579 {
+    // Different variations of the same issue.
+    fn v1() {
+        let x = vec![1, 2, 3, 0];
+        let y = x.strip_suffix(&[0]).map(|s| s.to_vec()).unwrap_or(x);
+        println!("{y:?}");
+    }
+    fn v2() {
+        let x = vec![1, 2, 3, 0];
+        let y = Some(()).map(|_| x.to_vec()).unwrap_or(x);
+        println!("{y:?}");
+    }
+    fn v3() {
+        let x = vec![1, 2, 3, 0];
+        let xref = &x;
+        let y = Some(()).map(|_| xref.to_vec()).unwrap_or(x);
+        println!("{y:?}");
+    }
+    fn v4() {
+        struct VecInStruct {
+            v: Vec<u8>,
+        }
+        let s = VecInStruct { v: vec![1, 2, 3, 0] };
+
+        let y = Some(()).map(|_| s.v.clone()).unwrap_or(s.v);
+        println!("{y:?}");
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 482baf2bccaba4a86624fff1483fe2d1d83e53c4 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Mon, 27 Feb 2023 13:28:27 -0500
Subject: Fix `explicit_into_iter_loop` with mutable references

---
 clippy_lints/src/loops/explicit_into_iter_loop.rs | 69 ++++++++++++++++-
 clippy_lints/src/loops/explicit_iter_loop.rs      | 93 ++++++++++++-----------
 clippy_lints/src/loops/mod.rs                     |  7 +-
 tests/ui/explicit_into_iter_loop.fixed            | 34 ++++++---
 tests/ui/explicit_into_iter_loop.rs               | 32 +++++---
 tests/ui/explicit_into_iter_loop.stderr           | 30 +++++++-
 6 files changed, 188 insertions(+), 77 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/explicit_into_iter_loop.rs b/clippy_lints/src/loops/explicit_into_iter_loop.rs
index 175e2b382e3..bf5e018ce92 100644
--- a/clippy_lints/src/loops/explicit_into_iter_loop.rs
+++ b/clippy_lints/src/loops/explicit_into_iter_loop.rs
@@ -5,15 +5,76 @@ use clippy_utils::source::snippet_with_applicability;
 use rustc_errors::Applicability;
 use rustc_hir::Expr;
 use rustc_lint::LateContext;
+use rustc_middle::ty::adjustment::{Adjust, Adjustment, AutoBorrow, AutoBorrowMutability};
 use rustc_span::symbol::sym;
 
+#[derive(Clone, Copy)]
+enum AdjustKind {
+    None,
+    Borrow,
+    BorrowMut,
+    Reborrow,
+    ReborrowMut,
+}
+impl AdjustKind {
+    fn borrow(mutbl: AutoBorrowMutability) -> Self {
+        match mutbl {
+            AutoBorrowMutability::Not => Self::Borrow,
+            AutoBorrowMutability::Mut { .. } => Self::BorrowMut,
+        }
+    }
+
+    fn reborrow(mutbl: AutoBorrowMutability) -> Self {
+        match mutbl {
+            AutoBorrowMutability::Not => Self::Reborrow,
+            AutoBorrowMutability::Mut { .. } => Self::ReborrowMut,
+        }
+    }
+
+    fn display(self) -> &'static str {
+        match self {
+            Self::None => "",
+            Self::Borrow => "&",
+            Self::BorrowMut => "&mut ",
+            Self::Reborrow => "&*",
+            Self::ReborrowMut => "&mut *",
+        }
+    }
+}
+
 pub(super) fn check(cx: &LateContext<'_>, self_arg: &Expr<'_>, call_expr: &Expr<'_>) {
-    let self_ty = cx.typeck_results().expr_ty(self_arg);
-    let self_ty_adjusted = cx.typeck_results().expr_ty_adjusted(self_arg);
-    if !(self_ty == self_ty_adjusted && is_trait_method(cx, call_expr, sym::IntoIterator)) {
+    if !is_trait_method(cx, call_expr, sym::IntoIterator) {
         return;
     }
 
+    let typeck = cx.typeck_results();
+    let self_ty = typeck.expr_ty(self_arg);
+    let adjust = match typeck.expr_adjustments(self_arg) {
+        [] => AdjustKind::None,
+        &[
+            Adjustment {
+                kind: Adjust::Borrow(AutoBorrow::Ref(_, mutbl)),
+                ..
+            },
+        ] => AdjustKind::borrow(mutbl),
+        &[
+            Adjustment {
+                kind: Adjust::Deref(_), ..
+            },
+            Adjustment {
+                kind: Adjust::Borrow(AutoBorrow::Ref(_, mutbl)),
+                target,
+            },
+        ] => {
+            if self_ty == target && matches!(mutbl, AutoBorrowMutability::Not) {
+                AdjustKind::None
+            } else {
+                AdjustKind::reborrow(mutbl)
+            }
+        },
+        _ => return,
+    };
+
     let mut applicability = Applicability::MachineApplicable;
     let object = snippet_with_applicability(cx, self_arg.span, "_", &mut applicability);
     span_lint_and_sugg(
@@ -23,7 +84,7 @@ pub(super) fn check(cx: &LateContext<'_>, self_arg: &Expr<'_>, call_expr: &Expr<
         "it is more concise to loop over containers instead of using explicit \
             iteration methods",
         "to write this more concisely, try",
-        object.to_string(),
+        format!("{}{}", adjust.display(), object.to_string()),
         applicability,
     );
 }
diff --git a/clippy_lints/src/loops/explicit_iter_loop.rs b/clippy_lints/src/loops/explicit_iter_loop.rs
index ba66af62375..621f0e0adca 100644
--- a/clippy_lints/src/loops/explicit_iter_loop.rs
+++ b/clippy_lints/src/loops/explicit_iter_loop.rs
@@ -1,58 +1,39 @@
 use super::EXPLICIT_ITER_LOOP;
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::is_trait_method;
 use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::ty::{implements_trait_with_env, make_normalized_projection_with_regions, normalize_with_regions,
-    make_normalized_projection, implements_trait, is_copy};
+use clippy_utils::ty::{
+    implements_trait, implements_trait_with_env, is_copy, make_normalized_projection,
+    make_normalized_projection_with_regions, normalize_with_regions,
+};
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, Mutability};
 use rustc_lint::LateContext;
 use rustc_middle::ty::adjustment::{Adjust, Adjustment, AutoBorrow, AutoBorrowMutability};
-use rustc_middle::ty::{self, EarlyBinder, TypeAndMut, Ty};
+use rustc_middle::ty::{self, EarlyBinder, Ty, TypeAndMut};
 use rustc_span::sym;
 
-pub(super) fn check(cx: &LateContext<'_>, self_arg: &Expr<'_>, call_expr: &Expr<'_>, method_name: &str, msrv: &Msrv) {
-    let borrow_kind = match method_name {
-        "iter" | "iter_mut" => match is_ref_iterable(cx, self_arg, call_expr) {
-            Some((kind, ty)) => {
-                if let ty::Array(_, count) = *ty.peel_refs().kind() {
-                    if !ty.is_ref() {
-                        if !msrv.meets(msrvs::ARRAY_INTO_ITERATOR) {
-                            return;
-                        }
-                    } else if count.try_eval_target_usize(cx.tcx, cx.param_env).map_or(true, |x| x > 32)
-                        && !msrv.meets(msrvs::ARRAY_IMPL_ANY_LEN)
-                    {
-                        return
-                    }
-                }
-                kind
-            },
-            None => return,
-        },
-        "into_iter" if is_trait_method(cx, call_expr, sym::IntoIterator) => {
-            let receiver_ty = cx.typeck_results().expr_ty(self_arg);
-            let receiver_ty_adjusted = cx.typeck_results().expr_ty_adjusted(self_arg);
-            let ref_receiver_ty = cx.tcx.mk_ref(
-                cx.tcx.lifetimes.re_erased,
-                ty::TypeAndMut {
-                    ty: receiver_ty,
-                    mutbl: Mutability::Not,
-                },
-            );
-            if receiver_ty_adjusted == ref_receiver_ty {
-                AdjustKind::None
-            } else {
+pub(super) fn check(cx: &LateContext<'_>, self_arg: &Expr<'_>, call_expr: &Expr<'_>, msrv: &Msrv) {
+    let Some((adjust, ty)) = is_ref_iterable(cx, self_arg, call_expr) else {
+        return;
+    };
+    if let ty::Array(_, count) = *ty.peel_refs().kind() {
+        if !ty.is_ref() {
+            if !msrv.meets(msrvs::ARRAY_INTO_ITERATOR) {
                 return;
             }
-        },
-        _ => return,
-    };
+        } else if count
+            .try_eval_target_usize(cx.tcx, cx.param_env)
+            .map_or(true, |x| x > 32)
+            && !msrv.meets(msrvs::ARRAY_IMPL_ANY_LEN)
+        {
+            return;
+        }
+    }
 
     let mut applicability = Applicability::MachineApplicable;
     let object = snippet_with_applicability(cx, self_arg.span, "_", &mut applicability);
-    let prefix = match borrow_kind {
+    let prefix = match adjust {
         AdjustKind::None => "",
         AdjustKind::Borrow => "&",
         AdjustKind::BorrowMut => "&mut ",
@@ -105,7 +86,11 @@ impl AdjustKind {
 
 /// Checks if an `iter` or `iter_mut` call returns `IntoIterator::IntoIter`. Returns how the
 /// argument needs to be adjusted.
-fn is_ref_iterable<'tcx>(cx: &LateContext<'tcx>, self_arg: &Expr<'_>, call_expr: &Expr<'_>) -> Option<(AdjustKind, Ty<'tcx>)> {
+fn is_ref_iterable<'tcx>(
+    cx: &LateContext<'tcx>,
+    self_arg: &Expr<'_>,
+    call_expr: &Expr<'_>,
+) -> Option<(AdjustKind, Ty<'tcx>)> {
     let typeck = cx.typeck_results();
     if let Some(trait_id) = cx.tcx.get_diagnostic_item(sym::IntoIterator)
         && let Some(fn_id) = typeck.type_dependent_def_id(call_expr.hir_id)
@@ -158,10 +143,18 @@ fn is_ref_iterable<'tcx>(cx: &LateContext<'tcx>, self_arg: &Expr<'_>, call_expr:
 
         match adjustments {
             [] => Some((AdjustKind::None, self_ty)),
-            &[Adjustment { kind: Adjust::Deref(_), ..}, Adjustment { kind: Adjust::Borrow(AutoBorrow::Ref(_, mutbl)), target }, ..] => {
+            &[
+                Adjustment { kind: Adjust::Deref(_), ..},
+                Adjustment {
+                    kind: Adjust::Borrow(AutoBorrow::Ref(_, mutbl)),
+                    target,
+                },
+                ..
+            ] => {
                 if target != self_ty
                     && implements_trait(cx, target, trait_id, &[])
-                    && let Some(ty) = make_normalized_projection(cx.tcx, cx.param_env, trait_id, sym!(IntoIter), [target])
+                    && let Some(ty) =
+                        make_normalized_projection(cx.tcx, cx.param_env, trait_id, sym!(IntoIter), [target])
                     && ty == res_ty
                 {
                     Some((AdjustKind::reborrow(mutbl), target))
@@ -172,7 +165,8 @@ fn is_ref_iterable<'tcx>(cx: &LateContext<'tcx>, self_arg: &Expr<'_>, call_expr:
             &[Adjustment { kind: Adjust::Deref(_), target }, ..] => {
                 if is_copy(cx, target)
                     && implements_trait(cx, target, trait_id, &[])
-                    && let Some(ty) = make_normalized_projection(cx.tcx, cx.param_env, trait_id, sym!(IntoIter), [target])
+                    && let Some(ty) =
+                        make_normalized_projection(cx.tcx, cx.param_env, trait_id, sym!(IntoIter), [target])
                     && ty == res_ty
                 {
                     Some((AdjustKind::Deref, target))
@@ -180,10 +174,17 @@ fn is_ref_iterable<'tcx>(cx: &LateContext<'tcx>, self_arg: &Expr<'_>, call_expr:
                     None
                 }
             }
-            &[Adjustment { kind: Adjust::Borrow(AutoBorrow::Ref(_, mutbl)), target }, ..] => {
+            &[
+                Adjustment {
+                    kind: Adjust::Borrow(AutoBorrow::Ref(_, mutbl)),
+                    target,
+                },
+                ..
+            ] => {
                 if self_ty.is_ref()
                     && implements_trait(cx, target, trait_id, &[])
-                    && let Some(ty) = make_normalized_projection(cx.tcx, cx.param_env, trait_id, sym!(IntoIter), [target])
+                    && let Some(ty) =
+                        make_normalized_projection(cx.tcx, cx.param_env, trait_id, sym!(IntoIter), [target])
                     && ty == res_ty
                 {
                     Some((AdjustKind::auto_borrow(mutbl), target))
diff --git a/clippy_lints/src/loops/mod.rs b/clippy_lints/src/loops/mod.rs
index 068166bdeb2..1231fefb180 100644
--- a/clippy_lints/src/loops/mod.rs
+++ b/clippy_lints/src/loops/mod.rs
@@ -715,14 +715,11 @@ impl Loops {
 
     fn check_for_loop_arg(&self, cx: &LateContext<'_>, _: &Pat<'_>, arg: &Expr<'_>) {
         if let ExprKind::MethodCall(method, self_arg, [], _) = arg.kind {
-            let method_name = method.ident.as_str();
-            // check for looping over x.iter() or x.iter_mut(), could use &x or &mut x
-            match method_name {
+            match method.ident.as_str() {
                 "iter" | "iter_mut" => {
-                    explicit_iter_loop::check(cx, self_arg, arg, method_name, &self.msrv);
+                    explicit_iter_loop::check(cx, self_arg, arg, &self.msrv);
                 },
                 "into_iter" => {
-                    explicit_iter_loop::check(cx, self_arg, arg, method_name, &self.msrv);
                     explicit_into_iter_loop::check(cx, self_arg, arg);
                 },
                 "next" => {
diff --git a/tests/ui/explicit_into_iter_loop.fixed b/tests/ui/explicit_into_iter_loop.fixed
index bc9ecb1e05a..dcef6340311 100644
--- a/tests/ui/explicit_into_iter_loop.fixed
+++ b/tests/ui/explicit_into_iter_loop.fixed
@@ -7,9 +7,7 @@ fn main() {
     where
         for<'a> &'a T: IntoIterator<Item = &'a String>,
     {
-        for i in iterator {
-            println!("{}", i);
-        }
+        for _ in iterator {}
     }
 
     struct T;
@@ -17,23 +15,39 @@ fn main() {
         type Item = ();
         type IntoIter = std::vec::IntoIter<Self::Item>;
         fn into_iter(self) -> Self::IntoIter {
-            vec![].into_iter()
+            unimplemented!()
         }
     }
 
-    let t = T;
-    let r = &t;
-    let rr = &&t;
-
-    // This case is handled by `explicit_iter_loop`. No idea why.
-    for _ in t.into_iter() {}
+    let mut t = T;
+    for _ in &t {}
 
+    let r = &t;
     for _ in r {}
 
     // No suggestion for this.
     // We'd have to suggest `for _ in *rr {}` which is less clear.
+    let rr = &&t;
     for _ in rr.into_iter() {}
 
+    let mr = &mut t;
+    for _ in &*mr {}
+
+    struct U;
+    impl IntoIterator for &mut U {
+        type Item = ();
+        type IntoIter = std::vec::IntoIter<Self::Item>;
+        fn into_iter(self) -> Self::IntoIter {
+            unimplemented!()
+        }
+    }
+
+    let mut u = U;
+    for _ in &mut u {}
+
+    let mr = &mut u;
+    for _ in &mut *mr {}
+
     // Issue #6900
     struct S;
     impl S {
diff --git a/tests/ui/explicit_into_iter_loop.rs b/tests/ui/explicit_into_iter_loop.rs
index 9b610fe3d11..bc048ed302b 100644
--- a/tests/ui/explicit_into_iter_loop.rs
+++ b/tests/ui/explicit_into_iter_loop.rs
@@ -7,9 +7,7 @@ fn main() {
     where
         for<'a> &'a T: IntoIterator<Item = &'a String>,
     {
-        for i in iterator.into_iter() {
-            println!("{}", i);
-        }
+        for _ in iterator.into_iter() {}
     }
 
     struct T;
@@ -17,23 +15,39 @@ fn main() {
         type Item = ();
         type IntoIter = std::vec::IntoIter<Self::Item>;
         fn into_iter(self) -> Self::IntoIter {
-            vec![].into_iter()
+            unimplemented!()
         }
     }
 
-    let t = T;
-    let r = &t;
-    let rr = &&t;
-
-    // This case is handled by `explicit_iter_loop`. No idea why.
+    let mut t = T;
     for _ in t.into_iter() {}
 
+    let r = &t;
     for _ in r.into_iter() {}
 
     // No suggestion for this.
     // We'd have to suggest `for _ in *rr {}` which is less clear.
+    let rr = &&t;
     for _ in rr.into_iter() {}
 
+    let mr = &mut t;
+    for _ in mr.into_iter() {}
+
+    struct U;
+    impl IntoIterator for &mut U {
+        type Item = ();
+        type IntoIter = std::vec::IntoIter<Self::Item>;
+        fn into_iter(self) -> Self::IntoIter {
+            unimplemented!()
+        }
+    }
+
+    let mut u = U;
+    for _ in u.into_iter() {}
+
+    let mr = &mut u;
+    for _ in mr.into_iter() {}
+
     // Issue #6900
     struct S;
     impl S {
diff --git a/tests/ui/explicit_into_iter_loop.stderr b/tests/ui/explicit_into_iter_loop.stderr
index 1bd2b38a0e7..fa89b884fa0 100644
--- a/tests/ui/explicit_into_iter_loop.stderr
+++ b/tests/ui/explicit_into_iter_loop.stderr
@@ -1,16 +1,40 @@
 error: it is more concise to loop over containers instead of using explicit iteration methods
   --> $DIR/explicit_into_iter_loop.rs:10:18
    |
-LL |         for i in iterator.into_iter() {
+LL |         for _ in iterator.into_iter() {}
    |                  ^^^^^^^^^^^^^^^^^^^^ help: to write this more concisely, try: `iterator`
    |
    = note: `-D clippy::explicit-into-iter-loop` implied by `-D warnings`
 
 error: it is more concise to loop over containers instead of using explicit iteration methods
-  --> $DIR/explicit_into_iter_loop.rs:31:14
+  --> $DIR/explicit_into_iter_loop.rs:23:14
+   |
+LL |     for _ in t.into_iter() {}
+   |              ^^^^^^^^^^^^^ help: to write this more concisely, try: `&t`
+
+error: it is more concise to loop over containers instead of using explicit iteration methods
+  --> $DIR/explicit_into_iter_loop.rs:26:14
    |
 LL |     for _ in r.into_iter() {}
    |              ^^^^^^^^^^^^^ help: to write this more concisely, try: `r`
 
-error: aborting due to 2 previous errors
+error: it is more concise to loop over containers instead of using explicit iteration methods
+  --> $DIR/explicit_into_iter_loop.rs:34:14
+   |
+LL |     for _ in mr.into_iter() {}
+   |              ^^^^^^^^^^^^^^ help: to write this more concisely, try: `&*mr`
+
+error: it is more concise to loop over containers instead of using explicit iteration methods
+  --> $DIR/explicit_into_iter_loop.rs:46:14
+   |
+LL |     for _ in u.into_iter() {}
+   |              ^^^^^^^^^^^^^ help: to write this more concisely, try: `&mut u`
+
+error: it is more concise to loop over containers instead of using explicit iteration methods
+  --> $DIR/explicit_into_iter_loop.rs:49:14
+   |
+LL |     for _ in mr.into_iter() {}
+   |              ^^^^^^^^^^^^^^ help: to write this more concisely, try: `&mut *mr`
+
+error: aborting due to 6 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 949712c90ac2af616fc4e72777c78c2948d3146a Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Mon, 27 Feb 2023 13:53:53 -0500
Subject: Reborrow mutable references in `explicit_iter_loop`

---
 clippy_lints/src/attrs.rs                          |  4 +-
 clippy_lints/src/default_numeric_fallback.rs       |  2 +-
 clippy_lints/src/lifetimes.rs                      |  2 +-
 clippy_lints/src/loops/explicit_into_iter_loop.rs  |  2 +-
 clippy_lints/src/loops/explicit_iter_loop.rs       | 77 ++++++++++++++++------
 clippy_lints/src/loops/mod.rs                      |  2 +
 clippy_lints/src/loops/same_item_push.rs           |  2 +-
 clippy_lints/src/macro_use.rs                      |  2 +-
 clippy_lints/src/matches/match_wild_err_arm.rs     |  2 +-
 .../src/matches/significant_drop_in_scrutinee.rs   |  2 +-
 clippy_lints/src/matches/try_err.rs                |  2 +-
 .../src/misc_early/mixed_case_hex_literals.rs      |  2 +-
 clippy_lints/src/mismatching_type_param_order.rs   |  2 +-
 clippy_lints/src/returns.rs                        |  2 +-
 clippy_lints/src/significant_drop_tightening.rs    |  2 +-
 clippy_lints/src/trait_bounds.rs                   |  4 +-
 .../internal_lints/interning_defined_symbol.rs     |  2 +-
 clippy_utils/src/qualify_min_const_fn.rs           |  4 +-
 clippy_utils/src/ty.rs                             |  2 +-
 clippy_utils/src/usage.rs                          |  2 +-
 lintcheck/src/main.rs                              |  2 +-
 tests/ui/explicit_iter_loop.fixed                  | 14 ++++
 tests/ui/explicit_iter_loop.rs                     | 14 ++++
 tests/ui/explicit_iter_loop.stderr                 | 66 ++++++++++++++-----
 24 files changed, 159 insertions(+), 58 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs
index 89540703bcf..2ba78f99569 100644
--- a/clippy_lints/src/attrs.rs
+++ b/clippy_lints/src/attrs.rs
@@ -808,7 +808,7 @@ fn check_deprecated_cfg_attr(cx: &EarlyContext<'_>, attr: &Attribute, msrv: &Msr
 }
 
 fn check_nested_cfg(cx: &EarlyContext<'_>, items: &[NestedMetaItem]) {
-    for item in items.iter() {
+    for item in items {
         if let NestedMetaItem::MetaItem(meta) = item {
             if !meta.has_name(sym::any) && !meta.has_name(sym::all) {
                 continue;
@@ -842,7 +842,7 @@ fn check_nested_cfg(cx: &EarlyContext<'_>, items: &[NestedMetaItem]) {
 }
 
 fn check_nested_misused_cfg(cx: &EarlyContext<'_>, items: &[NestedMetaItem]) {
-    for item in items.iter() {
+    for item in items {
         if let NestedMetaItem::MetaItem(meta) = item {
             if meta.has_name(sym!(features)) && let Some(val) = meta.value_str() {
                 span_lint_and_sugg(
diff --git a/clippy_lints/src/default_numeric_fallback.rs b/clippy_lints/src/default_numeric_fallback.rs
index 4e1a6cd4d73..e53a9877b20 100644
--- a/clippy_lints/src/default_numeric_fallback.rs
+++ b/clippy_lints/src/default_numeric_fallback.rs
@@ -161,7 +161,7 @@ impl<'a, 'tcx> Visitor<'tcx> for NumericFallbackVisitor<'a, 'tcx> {
                         let fields_def = &variant.fields;
 
                         // Push field type then visit each field expr.
-                        for field in fields.iter() {
+                        for field in *fields {
                             let bound =
                                 fields_def
                                     .iter()
diff --git a/clippy_lints/src/lifetimes.rs b/clippy_lints/src/lifetimes.rs
index 986ffcad883..7bc901e4e7f 100644
--- a/clippy_lints/src/lifetimes.rs
+++ b/clippy_lints/src/lifetimes.rs
@@ -562,7 +562,7 @@ fn has_where_lifetimes<'tcx>(cx: &LateContext<'tcx>, generics: &'tcx Generics<'_
                 // if the bounds define new lifetimes, they are fine to occur
                 let allowed_lts = allowed_lts_from(pred.bound_generic_params);
                 // now walk the bounds
-                for bound in pred.bounds.iter() {
+                for bound in pred.bounds {
                     walk_param_bound(&mut visitor, bound);
                 }
                 // and check that all lifetimes are allowed
diff --git a/clippy_lints/src/loops/explicit_into_iter_loop.rs b/clippy_lints/src/loops/explicit_into_iter_loop.rs
index bf5e018ce92..93d6b808646 100644
--- a/clippy_lints/src/loops/explicit_into_iter_loop.rs
+++ b/clippy_lints/src/loops/explicit_into_iter_loop.rs
@@ -84,7 +84,7 @@ pub(super) fn check(cx: &LateContext<'_>, self_arg: &Expr<'_>, call_expr: &Expr<
         "it is more concise to loop over containers instead of using explicit \
             iteration methods",
         "to write this more concisely, try",
-        format!("{}{}", adjust.display(), object.to_string()),
+        format!("{}{object}", adjust.display()),
         applicability,
     );
 }
diff --git a/clippy_lints/src/loops/explicit_iter_loop.rs b/clippy_lints/src/loops/explicit_iter_loop.rs
index 621f0e0adca..f3347e33077 100644
--- a/clippy_lints/src/loops/explicit_iter_loop.rs
+++ b/clippy_lints/src/loops/explicit_iter_loop.rs
@@ -33,14 +33,6 @@ pub(super) fn check(cx: &LateContext<'_>, self_arg: &Expr<'_>, call_expr: &Expr<
 
     let mut applicability = Applicability::MachineApplicable;
     let object = snippet_with_applicability(cx, self_arg.span, "_", &mut applicability);
-    let prefix = match adjust {
-        AdjustKind::None => "",
-        AdjustKind::Borrow => "&",
-        AdjustKind::BorrowMut => "&mut ",
-        AdjustKind::Deref => "*",
-        AdjustKind::Reborrow => "&*",
-        AdjustKind::ReborrowMut => "&mut *",
-    };
     span_lint_and_sugg(
         cx,
         EXPLICIT_ITER_LOOP,
@@ -48,11 +40,12 @@ pub(super) fn check(cx: &LateContext<'_>, self_arg: &Expr<'_>, call_expr: &Expr<
         "it is more concise to loop over references to containers instead of using explicit \
          iteration methods",
         "to write this more concisely, try",
-        format!("{prefix}{object}"),
+        format!("{}{object}", adjust.display()),
         applicability,
     );
 }
 
+#[derive(Clone, Copy)]
 enum AdjustKind {
     None,
     Borrow,
@@ -76,16 +69,35 @@ impl AdjustKind {
         }
     }
 
-    fn reborrow(mutbl: AutoBorrowMutability) -> Self {
+    fn reborrow(mutbl: Mutability) -> Self {
+        match mutbl {
+            Mutability::Not => Self::Reborrow,
+            Mutability::Mut => Self::ReborrowMut,
+        }
+    }
+
+    fn auto_reborrow(mutbl: AutoBorrowMutability) -> Self {
         match mutbl {
             AutoBorrowMutability::Not => Self::Reborrow,
             AutoBorrowMutability::Mut { .. } => Self::ReborrowMut,
         }
     }
+
+    fn display(self) -> &'static str {
+        match self {
+            Self::None => "",
+            Self::Borrow => "&",
+            Self::BorrowMut => "&mut ",
+            Self::Deref => "*",
+            Self::Reborrow => "&*",
+            Self::ReborrowMut => "&mut *",
+        }
+    }
 }
 
 /// Checks if an `iter` or `iter_mut` call returns `IntoIterator::IntoIter`. Returns how the
 /// argument needs to be adjusted.
+#[expect(clippy::too_many_lines)]
 fn is_ref_iterable<'tcx>(
     cx: &LateContext<'tcx>,
     self_arg: &Expr<'_>,
@@ -108,27 +120,50 @@ fn is_ref_iterable<'tcx>(
         let self_is_copy = is_copy(cx, self_ty);
 
         if adjustments.is_empty() && self_is_copy {
+            // Exact type match, already checked earlier
             return Some((AdjustKind::None, self_ty));
         }
 
-        let res_ty = cx.tcx.erase_regions(EarlyBinder::bind(req_res_ty).subst(cx.tcx, typeck.node_substs(call_expr.hir_id)));
-        if !adjustments.is_empty() && self_is_copy {
-            if implements_trait(cx, self_ty, trait_id, &[])
-                && let Some(ty) = make_normalized_projection(cx.tcx, cx.param_env, trait_id, sym!(IntoIter), [self_ty])
-                && ty == res_ty
-            {
-                return Some((AdjustKind::None, self_ty));
-            }
-        }
-
+        let res_ty = cx.tcx.erase_regions(EarlyBinder::bind(req_res_ty)
+            .subst(cx.tcx, typeck.node_substs(call_expr.hir_id)));
         let mutbl = if let ty::Ref(_, _, mutbl) = *req_self_ty.kind() {
             Some(mutbl)
         } else {
             None
         };
+
+        if !adjustments.is_empty() {
+            if self_is_copy {
+                // Using by value won't consume anything
+                if implements_trait(cx, self_ty, trait_id, &[])
+                    && let Some(ty) =
+                        make_normalized_projection(cx.tcx, cx.param_env, trait_id, sym!(IntoIter), [self_ty])
+                    && ty == res_ty
+                {
+                    return Some((AdjustKind::None, self_ty));
+                }
+            } else if let ty::Ref(region, ty, Mutability::Mut) = *self_ty.kind()
+                && let Some(mutbl) = mutbl
+            {
+                // Attempt to reborrow the mutable reference
+                let self_ty = if mutbl.is_mut() {
+                    self_ty
+                } else {
+                    cx.tcx.mk_ref(region, TypeAndMut { ty, mutbl })
+                };
+                if implements_trait(cx, self_ty, trait_id, &[])
+                    && let Some(ty) =
+                        make_normalized_projection(cx.tcx, cx.param_env, trait_id, sym!(IntoIter), [self_ty])
+                    && ty == res_ty
+                {
+                    return Some((AdjustKind::reborrow(mutbl), self_ty));
+                }
+            }
+        }
         if let Some(mutbl) = mutbl
             && !self_ty.is_ref()
         {
+            // Attempt to borrow
             let self_ty = cx.tcx.mk_ref(cx.tcx.lifetimes.re_erased, TypeAndMut {
                 ty: self_ty,
                 mutbl,
@@ -157,7 +192,7 @@ fn is_ref_iterable<'tcx>(
                         make_normalized_projection(cx.tcx, cx.param_env, trait_id, sym!(IntoIter), [target])
                     && ty == res_ty
                 {
-                    Some((AdjustKind::reborrow(mutbl), target))
+                    Some((AdjustKind::auto_reborrow(mutbl), target))
                 } else {
                     None
                 }
diff --git a/clippy_lints/src/loops/mod.rs b/clippy_lints/src/loops/mod.rs
index 1231fefb180..529189b52ac 100644
--- a/clippy_lints/src/loops/mod.rs
+++ b/clippy_lints/src/loops/mod.rs
@@ -687,6 +687,8 @@ impl<'tcx> LateLintPass<'tcx> for Loops {
             manual_while_let_some::check(cx, condition, body, span);
         }
     }
+
+    extract_msrv_attr!(LateContext);
 }
 
 impl Loops {
diff --git a/clippy_lints/src/loops/same_item_push.rs b/clippy_lints/src/loops/same_item_push.rs
index 9d9341559ac..f7b3b2358a0 100644
--- a/clippy_lints/src/loops/same_item_push.rs
+++ b/clippy_lints/src/loops/same_item_push.rs
@@ -148,7 +148,7 @@ impl<'a, 'tcx> Visitor<'tcx> for SameItemPushVisitor<'a, 'tcx> {
     }
 
     fn visit_block(&mut self, b: &'tcx Block<'_>) {
-        for stmt in b.stmts.iter() {
+        for stmt in b.stmts {
             self.visit_stmt(stmt);
         }
     }
diff --git a/clippy_lints/src/macro_use.rs b/clippy_lints/src/macro_use.rs
index 26ae4b409c7..cb3bda96133 100644
--- a/clippy_lints/src/macro_use.rs
+++ b/clippy_lints/src/macro_use.rs
@@ -101,7 +101,7 @@ impl<'tcx> LateLintPass<'tcx> for MacroUseImports {
             });
             if !id.is_local();
             then {
-                for kid in cx.tcx.module_children(id).iter() {
+                for kid in cx.tcx.module_children(id) {
                     if let Res::Def(DefKind::Macro(_mac_type), mac_id) = kid.res {
                         let span = mac_attr.span;
                         let def_path = cx.tcx.def_path_str(mac_id);
diff --git a/clippy_lints/src/matches/match_wild_err_arm.rs b/clippy_lints/src/matches/match_wild_err_arm.rs
index 6424ac31d9f..de911f7a028 100644
--- a/clippy_lints/src/matches/match_wild_err_arm.rs
+++ b/clippy_lints/src/matches/match_wild_err_arm.rs
@@ -25,7 +25,7 @@ pub(crate) fn check<'tcx>(cx: &LateContext<'tcx>, ex: &Expr<'tcx>, arms: &[Arm<'
                     let mut ident_bind_name = kw::Underscore;
                     if !matching_wild {
                         // Looking for unused bindings (i.e.: `_e`)
-                        for pat in inner.iter() {
+                        for pat in inner {
                             if let PatKind::Binding(_, id, ident, None) = pat.kind {
                                 if ident.as_str().starts_with('_') && !is_local_used(cx, arm.body, id) {
                                     ident_bind_name = ident.name;
diff --git a/clippy_lints/src/matches/significant_drop_in_scrutinee.rs b/clippy_lints/src/matches/significant_drop_in_scrutinee.rs
index 7945275393c..da02de3e667 100644
--- a/clippy_lints/src/matches/significant_drop_in_scrutinee.rs
+++ b/clippy_lints/src/matches/significant_drop_in_scrutinee.rs
@@ -140,7 +140,7 @@ impl<'a, 'tcx> SigDropChecker<'a, 'tcx> {
                     }
                 }
 
-                for generic_arg in b.iter() {
+                for generic_arg in *b {
                     if let GenericArgKind::Type(ty) = generic_arg.unpack() {
                         if self.has_sig_drop_attr(cx, ty) {
                             return true;
diff --git a/clippy_lints/src/matches/try_err.rs b/clippy_lints/src/matches/try_err.rs
index 704c34c32bf..3a7f1e034f3 100644
--- a/clippy_lints/src/matches/try_err.rs
+++ b/clippy_lints/src/matches/try_err.rs
@@ -81,7 +81,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, scrutine
 /// Finds function return type by examining return expressions in match arms.
 fn find_return_type<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx ExprKind<'_>) -> Option<Ty<'tcx>> {
     if let ExprKind::Match(_, arms, MatchSource::TryDesugar) = expr {
-        for arm in arms.iter() {
+        for arm in *arms {
             if let ExprKind::Ret(Some(ret)) = arm.body.kind {
                 return Some(cx.typeck_results().expr_ty(ret));
             }
diff --git a/clippy_lints/src/misc_early/mixed_case_hex_literals.rs b/clippy_lints/src/misc_early/mixed_case_hex_literals.rs
index ddb8b9173a5..9151cc63320 100644
--- a/clippy_lints/src/misc_early/mixed_case_hex_literals.rs
+++ b/clippy_lints/src/misc_early/mixed_case_hex_literals.rs
@@ -13,7 +13,7 @@ pub(super) fn check(cx: &EarlyContext<'_>, lit_span: Span, suffix: &str, lit_sni
         return;
     }
     let mut seen = (false, false);
-    for ch in lit_snip.as_bytes()[2..=maybe_last_sep_idx].iter() {
+    for ch in &lit_snip.as_bytes()[2..=maybe_last_sep_idx] {
         match ch {
             b'a'..=b'f' => seen.0 = true,
             b'A'..=b'F' => seen.1 = true,
diff --git a/clippy_lints/src/mismatching_type_param_order.rs b/clippy_lints/src/mismatching_type_param_order.rs
index 9de4b56b77b..28e041dee0d 100644
--- a/clippy_lints/src/mismatching_type_param_order.rs
+++ b/clippy_lints/src/mismatching_type_param_order.rs
@@ -59,7 +59,7 @@ impl<'tcx> LateLintPass<'tcx> for TypeParamMismatch {
             then {
                 // get the name and span of the generic parameters in the Impl
                 let mut impl_params = Vec::new();
-                for p in generic_args.args.iter() {
+                for p in generic_args.args {
                     match p {
                         GenericArg::Type(Ty {kind: TyKind::Path(QPath::Resolved(_, path)), ..}) =>
                             impl_params.push((path.segments[0].ident.to_string(), path.span)),
diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
index b5686e390ad..958351ad81b 100644
--- a/clippy_lints/src/returns.rs
+++ b/clippy_lints/src/returns.rs
@@ -292,7 +292,7 @@ fn check_final_expr<'tcx>(
         // (except for unit type functions) so we don't match it
         ExprKind::Match(_, arms, MatchSource::Normal) => {
             let match_ty = cx.typeck_results().expr_ty(peeled_drop_expr);
-            for arm in arms.iter() {
+            for arm in *arms {
                 check_final_expr(cx, arm.body, semi_spans.clone(), RetReplacement::Unit, Some(match_ty));
             }
         },
diff --git a/clippy_lints/src/significant_drop_tightening.rs b/clippy_lints/src/significant_drop_tightening.rs
index b930b2c8dd7..f4e56489b09 100644
--- a/clippy_lints/src/significant_drop_tightening.rs
+++ b/clippy_lints/src/significant_drop_tightening.rs
@@ -333,7 +333,7 @@ impl<'cx, 'sdt, 'tcx> SigDropChecker<'cx, 'sdt, 'tcx> {
                         return true;
                     }
                 }
-                for generic_arg in b.iter() {
+                for generic_arg in *b {
                     if let GenericArgKind::Type(ty) = generic_arg.unpack() {
                         if self.has_sig_drop_attr(ty) {
                             return true;
diff --git a/clippy_lints/src/trait_bounds.rs b/clippy_lints/src/trait_bounds.rs
index 4ccda15068b..0dab0126e6c 100644
--- a/clippy_lints/src/trait_bounds.rs
+++ b/clippy_lints/src/trait_bounds.rs
@@ -139,7 +139,7 @@ impl<'tcx> LateLintPass<'tcx> for TraitBounds {
                     ) = cx.tcx.hir().get_if_local(*def_id);
                 then {
                     if self_bounds_map.is_empty() {
-                        for bound in self_bounds.iter() {
+                        for bound in *self_bounds {
                             let Some((self_res, self_segments, _)) = get_trait_info_from_bound(bound) else { continue };
                             self_bounds_map.insert(self_res, self_segments);
                         }
@@ -184,7 +184,7 @@ impl<'tcx> LateLintPass<'tcx> for TraitBounds {
 
                 // Iterate the bounds and add them to our seen hash
                 // If we haven't yet seen it, add it to the fixed traits
-                for bound in bounds.iter() {
+                for bound in bounds {
                     let Some(def_id) = bound.trait_ref.trait_def_id() else { continue; };
 
                     let new_trait = seen_def_ids.insert(def_id);
diff --git a/clippy_lints/src/utils/internal_lints/interning_defined_symbol.rs b/clippy_lints/src/utils/internal_lints/interning_defined_symbol.rs
index f8978e30a8e..dced9fcf9ab 100644
--- a/clippy_lints/src/utils/internal_lints/interning_defined_symbol.rs
+++ b/clippy_lints/src/utils/internal_lints/interning_defined_symbol.rs
@@ -75,7 +75,7 @@ impl<'tcx> LateLintPass<'tcx> for InterningDefinedSymbol {
 
         for &module in &[&paths::KW_MODULE, &paths::SYM_MODULE] {
             for def_id in def_path_def_ids(cx, module) {
-                for item in cx.tcx.module_children(def_id).iter() {
+                for item in cx.tcx.module_children(def_id) {
                     if_chain! {
                         if let Res::Def(DefKind::Const, item_def_id) = item.res;
                         let ty = cx.tcx.type_of(item_def_id).subst_identity();
diff --git a/clippy_utils/src/qualify_min_const_fn.rs b/clippy_utils/src/qualify_min_const_fn.rs
index c0d2c835d63..67369288b70 100644
--- a/clippy_utils/src/qualify_min_const_fn.rs
+++ b/clippy_utils/src/qualify_min_const_fn.rs
@@ -61,7 +61,7 @@ pub fn is_min_const_fn<'tcx>(tcx: TyCtxt<'tcx>, body: &Body<'tcx>, msrv: &Msrv)
         body.local_decls.iter().next().unwrap().source_info.span,
     )?;
 
-    for bb in body.basic_blocks.iter() {
+    for bb in &*body.basic_blocks {
         check_terminator(tcx, body, bb.terminator(), msrv)?;
         for stmt in &bb.statements {
             check_statement(tcx, body, def_id, stmt)?;
@@ -89,7 +89,7 @@ fn check_ty<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>, span: Span) -> McfResult {
                 return Err((span, "function pointers in const fn are unstable".into()));
             },
             ty::Dynamic(preds, _, _) => {
-                for pred in preds.iter() {
+                for pred in *preds {
                     match pred.skip_binder() {
                         ty::ExistentialPredicate::AutoTrait(_) | ty::ExistentialPredicate::Projection(_) => {
                             return Err((
diff --git a/clippy_utils/src/ty.rs b/clippy_utils/src/ty.rs
index 78b14dc7abb..4132a6c4b18 100644
--- a/clippy_utils/src/ty.rs
+++ b/clippy_utils/src/ty.rs
@@ -277,7 +277,7 @@ pub fn is_must_use_ty<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
             false
         },
         ty::Dynamic(binder, _, _) => {
-            for predicate in binder.iter() {
+            for predicate in *binder {
                 if let ty::ExistentialPredicate::Trait(ref trait_ref) = predicate.skip_binder() {
                     if cx.tcx.has_attr(trait_ref.def_id, sym::must_use) {
                         return true;
diff --git a/clippy_utils/src/usage.rs b/clippy_utils/src/usage.rs
index ab3976a13bd..9855085216f 100644
--- a/clippy_utils/src/usage.rs
+++ b/clippy_utils/src/usage.rs
@@ -82,7 +82,7 @@ pub struct ParamBindingIdCollector {
 impl<'tcx> ParamBindingIdCollector {
     fn collect_binding_hir_ids(body: &'tcx hir::Body<'tcx>) -> Vec<hir::HirId> {
         let mut hir_ids: Vec<hir::HirId> = Vec::new();
-        for param in body.params.iter() {
+        for param in body.params {
             let mut finder = ParamBindingIdCollector {
                 binding_hir_ids: Vec::new(),
             };
diff --git a/lintcheck/src/main.rs b/lintcheck/src/main.rs
index 03d1877d6c6..de56a6f8275 100644
--- a/lintcheck/src/main.rs
+++ b/lintcheck/src/main.rs
@@ -474,7 +474,7 @@ fn read_crates(toml_path: &Path) -> (Vec<CrateSource>, RecursiveOptions) {
             });
         } else if let Some(ref versions) = tk.versions {
             // if we have multiple versions, save each one
-            for ver in versions.iter() {
+            for ver in versions {
                 crate_sources.push(CrateSource::CratesIo {
                     name: tk.name.clone(),
                     version: ver.to_string(),
diff --git a/tests/ui/explicit_iter_loop.fixed b/tests/ui/explicit_iter_loop.fixed
index b0de50ed928..746ef813c04 100644
--- a/tests/ui/explicit_iter_loop.fixed
+++ b/tests/ui/explicit_iter_loop.fixed
@@ -17,6 +17,13 @@ fn main() {
     for _ in &vec {}
     for _ in &mut vec {}
 
+    let rvec = &vec;
+    for _ in rvec {}
+
+    let rmvec = &mut vec;
+    for _ in &*rmvec {}
+    for _ in &mut *rmvec {}
+
     for _ in &vec {} // these are fine
     for _ in &mut vec {} // these are fine
 
@@ -29,9 +36,13 @@ fn main() {
 
     let ll: LinkedList<()> = LinkedList::new();
     for _ in &ll {}
+    let rll = &ll;
+    for _ in rll {}
 
     let vd: VecDeque<()> = VecDeque::new();
     for _ in &vd {}
+    let rvd = &vd;
+    for _ in rvd {}
 
     let bh: BinaryHeap<()> = BinaryHeap::new();
     for _ in &bh {}
@@ -137,4 +148,7 @@ fn main() {
     let mut x = CustomType;
     for _ in &x {}
     for _ in &mut x {}
+
+    let r = &x;
+    for _ in r {}
 }
diff --git a/tests/ui/explicit_iter_loop.rs b/tests/ui/explicit_iter_loop.rs
index 33d3bada6e2..fba230ee0ee 100644
--- a/tests/ui/explicit_iter_loop.rs
+++ b/tests/ui/explicit_iter_loop.rs
@@ -17,6 +17,13 @@ fn main() {
     for _ in vec.iter() {}
     for _ in vec.iter_mut() {}
 
+    let rvec = &vec;
+    for _ in rvec.iter() {}
+
+    let rmvec = &mut vec;
+    for _ in rmvec.iter() {}
+    for _ in rmvec.iter_mut() {}
+
     for _ in &vec {} // these are fine
     for _ in &mut vec {} // these are fine
 
@@ -29,9 +36,13 @@ fn main() {
 
     let ll: LinkedList<()> = LinkedList::new();
     for _ in ll.iter() {}
+    let rll = &ll;
+    for _ in rll.iter() {}
 
     let vd: VecDeque<()> = VecDeque::new();
     for _ in vd.iter() {}
+    let rvd = &vd;
+    for _ in rvd.iter() {}
 
     let bh: BinaryHeap<()> = BinaryHeap::new();
     for _ in bh.iter() {}
@@ -137,4 +148,7 @@ fn main() {
     let mut x = CustomType;
     for _ in x.iter() {}
     for _ in x.iter_mut() {}
+
+    let r = &x;
+    for _ in r.iter() {}
 }
diff --git a/tests/ui/explicit_iter_loop.stderr b/tests/ui/explicit_iter_loop.stderr
index 1508080a243..94a264dcea8 100644
--- a/tests/ui/explicit_iter_loop.stderr
+++ b/tests/ui/explicit_iter_loop.stderr
@@ -17,19 +17,37 @@ LL |     for _ in vec.iter_mut() {}
    |              ^^^^^^^^^^^^^^ help: to write this more concisely, try: `&mut vec`
 
 error: it is more concise to loop over references to containers instead of using explicit iteration methods
-  --> $DIR/explicit_iter_loop.rs:23:14
+  --> $DIR/explicit_iter_loop.rs:21:14
+   |
+LL |     for _ in rvec.iter() {}
+   |              ^^^^^^^^^^^ help: to write this more concisely, try: `rvec`
+
+error: it is more concise to loop over references to containers instead of using explicit iteration methods
+  --> $DIR/explicit_iter_loop.rs:24:14
+   |
+LL |     for _ in rmvec.iter() {}
+   |              ^^^^^^^^^^^^ help: to write this more concisely, try: `&*rmvec`
+
+error: it is more concise to loop over references to containers instead of using explicit iteration methods
+  --> $DIR/explicit_iter_loop.rs:25:14
+   |
+LL |     for _ in rmvec.iter_mut() {}
+   |              ^^^^^^^^^^^^^^^^ help: to write this more concisely, try: `&mut *rmvec`
+
+error: it is more concise to loop over references to containers instead of using explicit iteration methods
+  --> $DIR/explicit_iter_loop.rs:30:14
    |
 LL |     for _ in [1, 2, 3].iter() {}
    |              ^^^^^^^^^^^^^^^^ help: to write this more concisely, try: `&[1, 2, 3]`
 
 error: it is more concise to loop over references to containers instead of using explicit iteration methods
-  --> $DIR/explicit_iter_loop.rs:25:14
+  --> $DIR/explicit_iter_loop.rs:32:14
    |
 LL |     for _ in (&mut [1, 2, 3]).iter() {}
    |              ^^^^^^^^^^^^^^^^^^^^^^^ help: to write this more concisely, try: `&*(&mut [1, 2, 3])`
 
 error: the method `iter` doesn't need a mutable reference
-  --> $DIR/explicit_iter_loop.rs:25:14
+  --> $DIR/explicit_iter_loop.rs:32:14
    |
 LL |     for _ in (&mut [1, 2, 3]).iter() {}
    |              ^^^^^^^^^^^^^^^^
@@ -37,70 +55,88 @@ LL |     for _ in (&mut [1, 2, 3]).iter() {}
    = note: `-D clippy::unnecessary-mut-passed` implied by `-D warnings`
 
 error: it is more concise to loop over references to containers instead of using explicit iteration methods
-  --> $DIR/explicit_iter_loop.rs:27:14
+  --> $DIR/explicit_iter_loop.rs:34:14
    |
 LL |     for _ in [0; 32].iter() {}
    |              ^^^^^^^^^^^^^^ help: to write this more concisely, try: `&[0; 32]`
 
 error: it is more concise to loop over references to containers instead of using explicit iteration methods
-  --> $DIR/explicit_iter_loop.rs:28:14
+  --> $DIR/explicit_iter_loop.rs:35:14
    |
 LL |     for _ in [0; 33].iter() {}
    |              ^^^^^^^^^^^^^^ help: to write this more concisely, try: `&[0; 33]`
 
 error: it is more concise to loop over references to containers instead of using explicit iteration methods
-  --> $DIR/explicit_iter_loop.rs:31:14
+  --> $DIR/explicit_iter_loop.rs:38:14
    |
 LL |     for _ in ll.iter() {}
    |              ^^^^^^^^^ help: to write this more concisely, try: `&ll`
 
 error: it is more concise to loop over references to containers instead of using explicit iteration methods
-  --> $DIR/explicit_iter_loop.rs:34:14
+  --> $DIR/explicit_iter_loop.rs:40:14
+   |
+LL |     for _ in rll.iter() {}
+   |              ^^^^^^^^^^ help: to write this more concisely, try: `rll`
+
+error: it is more concise to loop over references to containers instead of using explicit iteration methods
+  --> $DIR/explicit_iter_loop.rs:43:14
    |
 LL |     for _ in vd.iter() {}
    |              ^^^^^^^^^ help: to write this more concisely, try: `&vd`
 
 error: it is more concise to loop over references to containers instead of using explicit iteration methods
-  --> $DIR/explicit_iter_loop.rs:37:14
+  --> $DIR/explicit_iter_loop.rs:45:14
+   |
+LL |     for _ in rvd.iter() {}
+   |              ^^^^^^^^^^ help: to write this more concisely, try: `rvd`
+
+error: it is more concise to loop over references to containers instead of using explicit iteration methods
+  --> $DIR/explicit_iter_loop.rs:48:14
    |
 LL |     for _ in bh.iter() {}
    |              ^^^^^^^^^ help: to write this more concisely, try: `&bh`
 
 error: it is more concise to loop over references to containers instead of using explicit iteration methods
-  --> $DIR/explicit_iter_loop.rs:40:14
+  --> $DIR/explicit_iter_loop.rs:51:14
    |
 LL |     for _ in hm.iter() {}
    |              ^^^^^^^^^ help: to write this more concisely, try: `&hm`
 
 error: it is more concise to loop over references to containers instead of using explicit iteration methods
-  --> $DIR/explicit_iter_loop.rs:43:14
+  --> $DIR/explicit_iter_loop.rs:54:14
    |
 LL |     for _ in bt.iter() {}
    |              ^^^^^^^^^ help: to write this more concisely, try: `&bt`
 
 error: it is more concise to loop over references to containers instead of using explicit iteration methods
-  --> $DIR/explicit_iter_loop.rs:46:14
+  --> $DIR/explicit_iter_loop.rs:57:14
    |
 LL |     for _ in hs.iter() {}
    |              ^^^^^^^^^ help: to write this more concisely, try: `&hs`
 
 error: it is more concise to loop over references to containers instead of using explicit iteration methods
-  --> $DIR/explicit_iter_loop.rs:49:14
+  --> $DIR/explicit_iter_loop.rs:60:14
    |
 LL |     for _ in bs.iter() {}
    |              ^^^^^^^^^ help: to write this more concisely, try: `&bs`
 
 error: it is more concise to loop over references to containers instead of using explicit iteration methods
-  --> $DIR/explicit_iter_loop.rs:138:14
+  --> $DIR/explicit_iter_loop.rs:149:14
    |
 LL |     for _ in x.iter() {}
    |              ^^^^^^^^ help: to write this more concisely, try: `&x`
 
 error: it is more concise to loop over references to containers instead of using explicit iteration methods
-  --> $DIR/explicit_iter_loop.rs:139:14
+  --> $DIR/explicit_iter_loop.rs:150:14
    |
 LL |     for _ in x.iter_mut() {}
    |              ^^^^^^^^^^^^ help: to write this more concisely, try: `&mut x`
 
-error: aborting due to 16 previous errors
+error: it is more concise to loop over references to containers instead of using explicit iteration methods
+  --> $DIR/explicit_iter_loop.rs:153:14
+   |
+LL |     for _ in r.iter() {}
+   |              ^^^^^^^^ help: to write this more concisely, try: `r`
+
+error: aborting due to 22 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 26f50395ba95a4da42b2b1b0d9532a2b9e99cdea Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Sat, 10 Jun 2023 06:43:30 -0500
Subject: Add `needless_if` lint

---
 CHANGELOG.md                                       |  1 +
 clippy_lints/src/declared_lints.rs                 |  1 +
 clippy_lints/src/lib.rs                            |  2 +
 clippy_lints/src/needless_if.rs                    | 66 ++++++++++++++++++++++
 lintcheck/lintcheck_crates.toml                    | 35 +-----------
 tests/ui-internal/if_chain_style.rs                |  7 ++-
 tests/ui-internal/if_chain_style.stderr            | 20 +++----
 tests/ui/auxiliary/proc_macros.rs                  |  2 +-
 tests/ui/blocks_in_if_conditions.fixed             |  2 +-
 tests/ui/blocks_in_if_conditions.rs                |  2 +-
 tests/ui/blocks_in_if_conditions_closure.rs        |  2 +-
 tests/ui/bool_comparison.fixed                     |  1 +
 tests/ui/bool_comparison.rs                        |  1 +
 tests/ui/bool_comparison.stderr                    | 44 +++++++--------
 tests/ui/cmp_owned/asymmetric_partial_eq.fixed     |  7 ++-
 tests/ui/cmp_owned/asymmetric_partial_eq.rs        |  7 ++-
 tests/ui/cmp_owned/asymmetric_partial_eq.stderr    | 12 ++--
 tests/ui/collapsible_else_if.fixed                 |  2 +-
 tests/ui/collapsible_else_if.rs                    |  2 +-
 tests/ui/collapsible_if.fixed                      |  1 +
 tests/ui/collapsible_if.rs                         |  1 +
 tests/ui/collapsible_if.stderr                     | 18 +++---
 tests/ui/crashes/ice-3462.rs                       |  2 +-
 tests/ui/crashes/ice-7169.rs                       |  2 +
 tests/ui/crashes/ice-7169.stderr                   |  2 +-
 tests/ui/disallowed_names.rs                       |  1 +
 tests/ui/disallowed_names.stderr                   | 28 ++++-----
 tests/ui/double_comparison.fixed                   |  1 +
 tests/ui/double_comparison.rs                      |  1 +
 tests/ui/double_comparison.stderr                  | 16 +++---
 tests/ui/equatable_if_let.fixed                    |  7 ++-
 tests/ui/equatable_if_let.rs                       |  7 ++-
 tests/ui/equatable_if_let.stderr                   | 28 ++++-----
 tests/ui/expect_tool_lint_rfc_2383.rs              |  1 +
 tests/ui/expect_tool_lint_rfc_2383.stderr          | 12 ++--
 tests/ui/filetype_is_file.rs                       |  1 +
 tests/ui/filetype_is_file.stderr                   |  6 +-
 tests/ui/fn_null_check.rs                          |  1 +
 tests/ui/fn_null_check.stderr                      | 10 ++--
 tests/ui/if_same_then_else2.rs                     |  1 +
 tests/ui/if_same_then_else2.stderr                 | 24 ++++----
 tests/ui/ifs_same_cond.rs                          |  7 ++-
 tests/ui/ifs_same_cond.stderr                      | 16 +++---
 tests/ui/len_zero.fixed                            |  2 +-
 tests/ui/len_zero.rs                               |  2 +-
 tests/ui/manual_let_else.rs                        |  3 +-
 tests/ui/manual_let_else.stderr                    | 52 ++++++++---------
 tests/ui/match_overlapping_arm.rs                  |  2 +-
 tests/ui/needless_bool/fixable.fixed               |  1 +
 tests/ui/needless_bool/fixable.rs                  |  1 +
 tests/ui/needless_bool/fixable.stderr              | 42 +++++++-------
 tests/ui/needless_borrowed_ref.fixed               |  3 +-
 tests/ui/needless_borrowed_ref.rs                  |  3 +-
 tests/ui/needless_borrowed_ref.stderr              | 34 +++++------
 tests/ui/needless_collect.fixed                    |  2 +-
 tests/ui/needless_collect.rs                       |  2 +-
 tests/ui/needless_collect_indirect.rs              |  1 +
 tests/ui/needless_if.fixed                         | 37 ++++++++++++
 tests/ui/needless_if.rs                            | 37 ++++++++++++
 tests/ui/needless_if.stderr                        | 25 ++++++++
 tests/ui/nonminimal_bool.rs                        |  2 +-
 tests/ui/nonminimal_bool_methods.fixed             |  2 +-
 tests/ui/nonminimal_bool_methods.rs                |  2 +-
 tests/ui/overflow_check_conditional.rs             |  1 +
 tests/ui/overflow_check_conditional.stderr         | 16 +++---
 tests/ui/partialeq_to_none.fixed                   |  2 +-
 tests/ui/partialeq_to_none.rs                      |  2 +-
 .../ui/redundant_pattern_matching_drop_order.fixed |  7 ++-
 tests/ui/redundant_pattern_matching_drop_order.rs  |  7 ++-
 .../redundant_pattern_matching_drop_order.stderr   | 44 +++++++--------
 tests/ui/redundant_pattern_matching_ipaddr.fixed   |  1 +
 tests/ui/redundant_pattern_matching_ipaddr.rs      |  1 +
 tests/ui/redundant_pattern_matching_ipaddr.stderr  | 36 ++++++------
 tests/ui/redundant_pattern_matching_option.fixed   |  1 +
 tests/ui/redundant_pattern_matching_option.rs      |  1 +
 tests/ui/redundant_pattern_matching_option.stderr  | 56 +++++++++---------
 tests/ui/redundant_pattern_matching_poll.fixed     |  1 +
 tests/ui/redundant_pattern_matching_poll.rs        |  1 +
 tests/ui/redundant_pattern_matching_poll.stderr    | 36 ++++++------
 tests/ui/redundant_pattern_matching_result.fixed   |  1 +
 tests/ui/redundant_pattern_matching_result.rs      |  1 +
 tests/ui/redundant_pattern_matching_result.stderr  | 56 +++++++++---------
 tests/ui/shadow.rs                                 |  2 +-
 tests/ui/single_match.fixed                        |  7 ++-
 tests/ui/single_match.rs                           |  7 ++-
 tests/ui/single_match.stderr                       | 36 ++++++------
 tests/ui/starts_ends_with.fixed                    |  2 +-
 tests/ui/starts_ends_with.rs                       |  2 +-
 tests/ui/suspicious_else_formatting.rs             |  7 ++-
 tests/ui/suspicious_else_formatting.stderr         | 18 +++---
 tests/ui/suspicious_unary_op_formatting.rs         |  1 +
 tests/ui/suspicious_unary_op_formatting.stderr     |  8 +--
 tests/ui/unit_cmp.rs                               |  3 +-
 tests/ui/unit_cmp.stderr                           | 12 ++--
 tests/ui/unnecessary_safety_comment.rs             |  2 +-
 tests/ui/unneeded_wildcard_pattern.fixed           |  1 +
 tests/ui/unneeded_wildcard_pattern.rs              |  1 +
 tests/ui/unneeded_wildcard_pattern.stderr          | 28 ++++-----
 tests/ui/unnested_or_patterns.fixed                |  7 ++-
 tests/ui/unnested_or_patterns.rs                   |  7 ++-
 tests/ui/unnested_or_patterns.stderr               | 34 +++++------
 tests/ui/unnested_or_patterns2.fixed               |  2 +-
 tests/ui/unnested_or_patterns2.rs                  |  2 +-
 tests/ui/useless_conversion.fixed                  |  2 +-
 tests/ui/useless_conversion.rs                     |  2 +-
 tests/ui/useless_conversion_try.rs                 |  1 +
 tests/ui/useless_conversion_try.stderr             | 18 +++---
 107 files changed, 692 insertions(+), 456 deletions(-)
 create mode 100644 clippy_lints/src/needless_if.rs
 create mode 100644 tests/ui/needless_if.fixed
 create mode 100644 tests/ui/needless_if.rs
 create mode 100644 tests/ui/needless_if.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 0d00f2c16e7..8a330b35d69 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5008,6 +5008,7 @@ Released 2018-09-13
 [`needless_doctest_main`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_doctest_main
 [`needless_else`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_else
 [`needless_for_each`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_for_each
+[`needless_if`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_if
 [`needless_late_init`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_late_init
 [`needless_lifetimes`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_lifetimes
 [`needless_match`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_match
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index b6ceab26006..874c173f709 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -459,6 +459,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::needless_continue::NEEDLESS_CONTINUE_INFO,
     crate::needless_else::NEEDLESS_ELSE_INFO,
     crate::needless_for_each::NEEDLESS_FOR_EACH_INFO,
+    crate::needless_if::NEEDLESS_IF_INFO,
     crate::needless_late_init::NEEDLESS_LATE_INIT_INFO,
     crate::needless_parens_on_range_literals::NEEDLESS_PARENS_ON_RANGE_LITERALS_INFO,
     crate::needless_pass_by_value::NEEDLESS_PASS_BY_VALUE_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 22ff5ef5859..882c5653c96 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -223,6 +223,7 @@ mod needless_borrowed_ref;
 mod needless_continue;
 mod needless_else;
 mod needless_for_each;
+mod needless_if;
 mod needless_late_init;
 mod needless_parens_on_range_literals;
 mod needless_pass_by_value;
@@ -1029,6 +1030,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(endian_bytes::EndianBytes));
     store.register_late_pass(|_| Box::new(redundant_type_annotations::RedundantTypeAnnotations));
     store.register_late_pass(|_| Box::new(arc_with_non_send_sync::ArcWithNonSendSync));
+    store.register_late_pass(|_| Box::new(needless_if::NeedlessIf));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/needless_if.rs b/clippy_lints/src/needless_if.rs
new file mode 100644
index 00000000000..1568c3533a0
--- /dev/null
+++ b/clippy_lints/src/needless_if.rs
@@ -0,0 +1,66 @@
+use clippy_utils::{diagnostics::span_lint_and_sugg, is_from_proc_macro, source::snippet_with_applicability};
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind, Node};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_middle::lint::in_external_macro;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// ### What it does
+    ///
+    /// ### Why is this bad?
+    ///
+    /// ### Example
+    /// ```rust
+    /// // example code where clippy issues a warning
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// // example code which does not raise clippy warning
+    /// ```
+    #[clippy::version = "1.72.0"]
+    pub NEEDLESS_IF,
+    complexity,
+    "checks for empty if branches"
+}
+declare_lint_pass!(NeedlessIf => [NEEDLESS_IF]);
+
+impl LateLintPass<'_> for NeedlessIf {
+    fn check_expr<'tcx>(&mut self, cx: &LateContext<'tcx>, expr: &Expr<'tcx>) {
+        if let ExprKind::If(if_expr, block, else_expr) = &expr.kind
+            && let ExprKind::Block(block, ..) = block.kind
+            && block.stmts.is_empty()
+            && block.expr.is_none()
+            && else_expr.is_none()
+            && !in_external_macro(cx.sess(), expr.span)
+        {
+            let mut app = Applicability::MachineApplicable;
+            let snippet = snippet_with_applicability(cx, if_expr.span, "{ ... }", &mut app);
+
+            // Ignore `else if`
+            if let Some(parent_id) = cx.tcx.hir().opt_parent_id(expr.hir_id)
+                && let Some(Node::Expr(Expr {
+                    kind: ExprKind::If(_, _, Some(else_expr)),
+                    ..
+                })) = cx.tcx.hir().find(parent_id)
+                && else_expr.hir_id == expr.hir_id
+            {
+                return;
+            }
+
+            if is_from_proc_macro(cx, expr) {
+                return;
+            }
+
+            span_lint_and_sugg(
+                cx,
+                NEEDLESS_IF,
+                expr.span,
+                "this if branch is empty",
+                "you can remove it",
+                format!("{snippet};"),
+                Applicability::MachineApplicable,
+            );
+        }
+    }
+}
diff --git a/lintcheck/lintcheck_crates.toml b/lintcheck/lintcheck_crates.toml
index 52f7fee47b6..066b2657d03 100644
--- a/lintcheck/lintcheck_crates.toml
+++ b/lintcheck/lintcheck_crates.toml
@@ -1,38 +1,7 @@
 [crates]
 # some of these are from cargotest
-cargo = {name = "cargo", versions = ['0.64.0']}
-iron = {name = "iron", versions = ['0.6.1']}
-ripgrep = {name = "ripgrep", versions = ['12.1.1']}
-xsv = {name = "xsv", versions = ['0.13.0']}
-# commented out because of 173K clippy::match_same_arms msgs in language_type.rs
-#tokei = { name = "tokei", versions = ['12.0.4']}
-rayon = {name = "rayon", versions = ['1.5.0']}
-serde = {name = "serde", versions = ['1.0.118']}
-# top 10 crates.io dls
-bitflags = {name = "bitflags", versions = ['1.2.1']}
-# crash = {name = "clippy_crash", path = "/tmp/clippy_crash"}
-libc = {name = "libc", versions = ['0.2.81']}
-log = {name = "log", versions = ['0.4.11']}
-proc-macro2 = {name = "proc-macro2", versions = ['1.0.24']}
-quote = {name = "quote", versions = ['1.0.7']}
-rand = {name = "rand", versions = ['0.7.3']}
-rand_core = {name = "rand_core", versions = ['0.6.0']}
-regex = {name = "regex", versions = ['1.3.2']}
-syn = {name = "syn", versions = ['1.0.54']}
-unicode-xid = {name = "unicode-xid", versions = ['0.2.1']}
-# some more of dtolnays crates
-anyhow = {name = "anyhow", versions = ['1.0.38']}
-async-trait = {name = "async-trait", versions = ['0.1.42']}
-cxx = {name = "cxx", versions = ['1.0.32']}
-ryu = {name = "ryu", versions = ['1.0.5']}
-serde_yaml = {name = "serde_yaml", versions = ['0.8.17']}
-thiserror = {name = "thiserror", versions = ['1.0.24']}
-# some embark crates, there are other interesting crates but
-# unfortunately adding them increases lintcheck runtime drastically
-cfg-expr = {name = "cfg-expr", versions = ['0.7.1']}
-puffin = {name = "puffin", git_url = "https://github.com/EmbarkStudios/puffin", git_hash = "02dd4a3"}
-rpmalloc = {name = "rpmalloc", versions = ['0.2.0']}
-tame-oidc = {name = "tame-oidc", versions = ['0.1.0']}
+bevy = {name = "bevy", versions = ['0.10.1']}
+deno = {name = "deno", versions = ['1.34.2']}
 
 [recursive]
 ignore = [
diff --git a/tests/ui-internal/if_chain_style.rs b/tests/ui-internal/if_chain_style.rs
index b0d89e038aa..b462b20e04c 100644
--- a/tests/ui-internal/if_chain_style.rs
+++ b/tests/ui-internal/if_chain_style.rs
@@ -1,5 +1,10 @@
 #![warn(clippy::if_chain_style)]
-#![allow(clippy::no_effect, clippy::nonminimal_bool, clippy::missing_clippy_version_attribute)]
+#![allow(
+    clippy::needless_if,
+    clippy::no_effect,
+    clippy::nonminimal_bool,
+    clippy::missing_clippy_version_attribute
+)]
 
 extern crate if_chain;
 
diff --git a/tests/ui-internal/if_chain_style.stderr b/tests/ui-internal/if_chain_style.stderr
index d8f1ffb21ba..b12df278652 100644
--- a/tests/ui-internal/if_chain_style.stderr
+++ b/tests/ui-internal/if_chain_style.stderr
@@ -1,5 +1,5 @@
 error: this `if` can be part of the inner `if_chain!`
-  --> $DIR/if_chain_style.rs:9:5
+  --> $DIR/if_chain_style.rs:14:5
    |
 LL | /     if true {
 LL | |         let x = "";
@@ -11,14 +11,14 @@ LL | |     }
    | |_____^
    |
 help: this `let` statement can also be in the `if_chain!`
-  --> $DIR/if_chain_style.rs:10:9
+  --> $DIR/if_chain_style.rs:15:9
    |
 LL |         let x = "";
    |         ^^^^^^^^^^^
    = note: `-D clippy::if-chain-style` implied by `-D warnings`
 
 error: `if a && b;` should be `if a; if b;`
-  --> $DIR/if_chain_style.rs:19:12
+  --> $DIR/if_chain_style.rs:24:12
    |
 LL |           if true
    |  ____________^
@@ -27,25 +27,25 @@ LL | |             && false;
    | |____________________^
 
 error: `let` expression should be inside `then { .. }`
-  --> $DIR/if_chain_style.rs:24:9
+  --> $DIR/if_chain_style.rs:29:9
    |
 LL |         let x = "";
    |         ^^^^^^^^^^^
 
 error: this `if` can be part of the outer `if_chain!`
-  --> $DIR/if_chain_style.rs:35:13
+  --> $DIR/if_chain_style.rs:40:13
    |
 LL |             if true {}
    |             ^^^^^^^^^^
    |
 help: this `let` statement can also be in the `if_chain!`
-  --> $DIR/if_chain_style.rs:33:13
+  --> $DIR/if_chain_style.rs:38:13
    |
 LL |             let x = "";
    |             ^^^^^^^^^^^
 
 error: `if_chain!` only has one `if`
-  --> $DIR/if_chain_style.rs:29:5
+  --> $DIR/if_chain_style.rs:34:5
    |
 LL | /     if_chain! {
 LL | |         // single `if` condition
@@ -59,13 +59,13 @@ LL | |     }
    = note: this error originates in the macro `__if_chain` which comes from the expansion of the macro `if_chain` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: `let` expression should be above the `if_chain!`
-  --> $DIR/if_chain_style.rs:40:9
+  --> $DIR/if_chain_style.rs:45:9
    |
 LL |         let x = "";
    |         ^^^^^^^^^^^
 
 error: this `if_chain!` can be merged with the outer `if_chain!`
-  --> $DIR/if_chain_style.rs:46:13
+  --> $DIR/if_chain_style.rs:51:13
    |
 LL | /             if_chain! {
 LL | |                 if true;
@@ -75,7 +75,7 @@ LL | |             }
    | |_____________^
    |
 help: these `let` statements can also be in the `if_chain!`
-  --> $DIR/if_chain_style.rs:43:13
+  --> $DIR/if_chain_style.rs:48:13
    |
 LL | /             let x = "";
 LL | |             let x = "";
diff --git a/tests/ui/auxiliary/proc_macros.rs b/tests/ui/auxiliary/proc_macros.rs
index 94f075ed09c..5d849bfcf81 100644
--- a/tests/ui/auxiliary/proc_macros.rs
+++ b/tests/ui/auxiliary/proc_macros.rs
@@ -4,7 +4,7 @@
 #![crate_type = "proc-macro"]
 #![feature(let_chains)]
 #![feature(proc_macro_span)]
-#![allow(dead_code)]
+#![allow(clippy::needless_if, dead_code)]
 
 extern crate proc_macro;
 
diff --git a/tests/ui/blocks_in_if_conditions.fixed b/tests/ui/blocks_in_if_conditions.fixed
index a9f18782e58..2a3867ac8fc 100644
--- a/tests/ui/blocks_in_if_conditions.fixed
+++ b/tests/ui/blocks_in_if_conditions.fixed
@@ -1,6 +1,6 @@
 //@run-rustfix
 #![warn(clippy::blocks_in_if_conditions)]
-#![allow(unused, clippy::let_and_return)]
+#![allow(unused, clippy::let_and_return, clippy::needless_if)]
 #![warn(clippy::nonminimal_bool)]
 
 macro_rules! blocky {
diff --git a/tests/ui/blocks_in_if_conditions.rs b/tests/ui/blocks_in_if_conditions.rs
index 0a70317c4d4..704d09fbad3 100644
--- a/tests/ui/blocks_in_if_conditions.rs
+++ b/tests/ui/blocks_in_if_conditions.rs
@@ -1,6 +1,6 @@
 //@run-rustfix
 #![warn(clippy::blocks_in_if_conditions)]
-#![allow(unused, clippy::let_and_return)]
+#![allow(unused, clippy::let_and_return, clippy::needless_if)]
 #![warn(clippy::nonminimal_bool)]
 
 macro_rules! blocky {
diff --git a/tests/ui/blocks_in_if_conditions_closure.rs b/tests/ui/blocks_in_if_conditions_closure.rs
index 169589f6d4e..7da12d89a61 100644
--- a/tests/ui/blocks_in_if_conditions_closure.rs
+++ b/tests/ui/blocks_in_if_conditions_closure.rs
@@ -1,5 +1,5 @@
 #![warn(clippy::blocks_in_if_conditions)]
-#![allow(unused, clippy::let_and_return)]
+#![allow(unused, clippy::let_and_return, clippy::needless_if)]
 
 fn predicate<F: FnOnce(T) -> bool, T>(pfn: F, val: T) -> bool {
     pfn(val)
diff --git a/tests/ui/bool_comparison.fixed b/tests/ui/bool_comparison.fixed
index 670eef6a21d..d6774c03598 100644
--- a/tests/ui/bool_comparison.fixed
+++ b/tests/ui/bool_comparison.fixed
@@ -1,5 +1,6 @@
 //@run-rustfix
 
+#![allow(clippy::needless_if)]
 #![warn(clippy::bool_comparison)]
 
 fn main() {
diff --git a/tests/ui/bool_comparison.rs b/tests/ui/bool_comparison.rs
index 72851be635d..c0483fd7374 100644
--- a/tests/ui/bool_comparison.rs
+++ b/tests/ui/bool_comparison.rs
@@ -1,5 +1,6 @@
 //@run-rustfix
 
+#![allow(clippy::needless_if)]
 #![warn(clippy::bool_comparison)]
 
 fn main() {
diff --git a/tests/ui/bool_comparison.stderr b/tests/ui/bool_comparison.stderr
index 31522d4a525..f4dded365fb 100644
--- a/tests/ui/bool_comparison.stderr
+++ b/tests/ui/bool_comparison.stderr
@@ -1,5 +1,5 @@
 error: equality checks against true are unnecessary
-  --> $DIR/bool_comparison.rs:7:8
+  --> $DIR/bool_comparison.rs:8:8
    |
 LL |     if x == true {
    |        ^^^^^^^^^ help: try simplifying it as shown: `x`
@@ -7,127 +7,127 @@ LL |     if x == true {
    = note: `-D clippy::bool-comparison` implied by `-D warnings`
 
 error: equality checks against false can be replaced by a negation
-  --> $DIR/bool_comparison.rs:12:8
+  --> $DIR/bool_comparison.rs:13:8
    |
 LL |     if x == false {
    |        ^^^^^^^^^^ help: try simplifying it as shown: `!x`
 
 error: equality checks against true are unnecessary
-  --> $DIR/bool_comparison.rs:17:8
+  --> $DIR/bool_comparison.rs:18:8
    |
 LL |     if true == x {
    |        ^^^^^^^^^ help: try simplifying it as shown: `x`
 
 error: equality checks against false can be replaced by a negation
-  --> $DIR/bool_comparison.rs:22:8
+  --> $DIR/bool_comparison.rs:23:8
    |
 LL |     if false == x {
    |        ^^^^^^^^^^ help: try simplifying it as shown: `!x`
 
 error: inequality checks against true can be replaced by a negation
-  --> $DIR/bool_comparison.rs:27:8
+  --> $DIR/bool_comparison.rs:28:8
    |
 LL |     if x != true {
    |        ^^^^^^^^^ help: try simplifying it as shown: `!x`
 
 error: inequality checks against false are unnecessary
-  --> $DIR/bool_comparison.rs:32:8
+  --> $DIR/bool_comparison.rs:33:8
    |
 LL |     if x != false {
    |        ^^^^^^^^^^ help: try simplifying it as shown: `x`
 
 error: inequality checks against true can be replaced by a negation
-  --> $DIR/bool_comparison.rs:37:8
+  --> $DIR/bool_comparison.rs:38:8
    |
 LL |     if true != x {
    |        ^^^^^^^^^ help: try simplifying it as shown: `!x`
 
 error: inequality checks against false are unnecessary
-  --> $DIR/bool_comparison.rs:42:8
+  --> $DIR/bool_comparison.rs:43:8
    |
 LL |     if false != x {
    |        ^^^^^^^^^^ help: try simplifying it as shown: `x`
 
 error: less than comparison against true can be replaced by a negation
-  --> $DIR/bool_comparison.rs:47:8
+  --> $DIR/bool_comparison.rs:48:8
    |
 LL |     if x < true {
    |        ^^^^^^^^ help: try simplifying it as shown: `!x`
 
 error: greater than checks against false are unnecessary
-  --> $DIR/bool_comparison.rs:52:8
+  --> $DIR/bool_comparison.rs:53:8
    |
 LL |     if false < x {
    |        ^^^^^^^^^ help: try simplifying it as shown: `x`
 
 error: greater than checks against false are unnecessary
-  --> $DIR/bool_comparison.rs:57:8
+  --> $DIR/bool_comparison.rs:58:8
    |
 LL |     if x > false {
    |        ^^^^^^^^^ help: try simplifying it as shown: `x`
 
 error: less than comparison against true can be replaced by a negation
-  --> $DIR/bool_comparison.rs:62:8
+  --> $DIR/bool_comparison.rs:63:8
    |
 LL |     if true > x {
    |        ^^^^^^^^ help: try simplifying it as shown: `!x`
 
 error: order comparisons between booleans can be simplified
-  --> $DIR/bool_comparison.rs:68:8
+  --> $DIR/bool_comparison.rs:69:8
    |
 LL |     if x < y {
    |        ^^^^^ help: try simplifying it as shown: `!x & y`
 
 error: order comparisons between booleans can be simplified
-  --> $DIR/bool_comparison.rs:73:8
+  --> $DIR/bool_comparison.rs:74:8
    |
 LL |     if x > y {
    |        ^^^^^ help: try simplifying it as shown: `x & !y`
 
 error: this comparison might be written more concisely
-  --> $DIR/bool_comparison.rs:121:8
+  --> $DIR/bool_comparison.rs:122:8
    |
 LL |     if a == !b {};
    |        ^^^^^^^ help: try simplifying it as shown: `a != b`
 
 error: this comparison might be written more concisely
-  --> $DIR/bool_comparison.rs:122:8
+  --> $DIR/bool_comparison.rs:123:8
    |
 LL |     if !a == b {};
    |        ^^^^^^^ help: try simplifying it as shown: `a != b`
 
 error: this comparison might be written more concisely
-  --> $DIR/bool_comparison.rs:126:8
+  --> $DIR/bool_comparison.rs:127:8
    |
 LL |     if b == !a {};
    |        ^^^^^^^ help: try simplifying it as shown: `b != a`
 
 error: this comparison might be written more concisely
-  --> $DIR/bool_comparison.rs:127:8
+  --> $DIR/bool_comparison.rs:128:8
    |
 LL |     if !b == a {};
    |        ^^^^^^^ help: try simplifying it as shown: `b != a`
 
 error: equality checks against false can be replaced by a negation
-  --> $DIR/bool_comparison.rs:151:8
+  --> $DIR/bool_comparison.rs:152:8
    |
 LL |     if false == m!(func) {}
    |        ^^^^^^^^^^^^^^^^^ help: try simplifying it as shown: `!m!(func)`
 
 error: equality checks against false can be replaced by a negation
-  --> $DIR/bool_comparison.rs:152:8
+  --> $DIR/bool_comparison.rs:153:8
    |
 LL |     if m!(func) == false {}
    |        ^^^^^^^^^^^^^^^^^ help: try simplifying it as shown: `!m!(func)`
 
 error: equality checks against true are unnecessary
-  --> $DIR/bool_comparison.rs:153:8
+  --> $DIR/bool_comparison.rs:154:8
    |
 LL |     if true == m!(func) {}
    |        ^^^^^^^^^^^^^^^^ help: try simplifying it as shown: `m!(func)`
 
 error: equality checks against true are unnecessary
-  --> $DIR/bool_comparison.rs:154:8
+  --> $DIR/bool_comparison.rs:155:8
    |
 LL |     if m!(func) == true {}
    |        ^^^^^^^^^^^^^^^^ help: try simplifying it as shown: `m!(func)`
diff --git a/tests/ui/cmp_owned/asymmetric_partial_eq.fixed b/tests/ui/cmp_owned/asymmetric_partial_eq.fixed
index 3bf3deb9b91..11834634856 100644
--- a/tests/ui/cmp_owned/asymmetric_partial_eq.fixed
+++ b/tests/ui/cmp_owned/asymmetric_partial_eq.fixed
@@ -1,5 +1,10 @@
 //@run-rustfix
-#![allow(unused, clippy::redundant_clone, clippy::derive_partial_eq_without_eq)] // See #5700
+#![allow(
+    unused,
+    clippy::needless_if,
+    clippy::redundant_clone,
+    clippy::derive_partial_eq_without_eq
+)] // See #5700
 
 // Define the types in each module to avoid trait impls leaking between modules.
 macro_rules! impl_types {
diff --git a/tests/ui/cmp_owned/asymmetric_partial_eq.rs b/tests/ui/cmp_owned/asymmetric_partial_eq.rs
index 10107dc8f86..3a25d53a5d0 100644
--- a/tests/ui/cmp_owned/asymmetric_partial_eq.rs
+++ b/tests/ui/cmp_owned/asymmetric_partial_eq.rs
@@ -1,5 +1,10 @@
 //@run-rustfix
-#![allow(unused, clippy::redundant_clone, clippy::derive_partial_eq_without_eq)] // See #5700
+#![allow(
+    unused,
+    clippy::needless_if,
+    clippy::redundant_clone,
+    clippy::derive_partial_eq_without_eq
+)] // See #5700
 
 // Define the types in each module to avoid trait impls leaking between modules.
 macro_rules! impl_types {
diff --git a/tests/ui/cmp_owned/asymmetric_partial_eq.stderr b/tests/ui/cmp_owned/asymmetric_partial_eq.stderr
index 43bf8851fc6..4714a0daaa6 100644
--- a/tests/ui/cmp_owned/asymmetric_partial_eq.stderr
+++ b/tests/ui/cmp_owned/asymmetric_partial_eq.stderr
@@ -1,5 +1,5 @@
 error: this creates an owned instance just for comparison
-  --> $DIR/asymmetric_partial_eq.rs:42:12
+  --> $DIR/asymmetric_partial_eq.rs:47:12
    |
 LL |         if borrowed.to_owned() == owned {}
    |            ^^^^^^^^^^^^^^^^^^^ help: try: `borrowed`
@@ -7,7 +7,7 @@ LL |         if borrowed.to_owned() == owned {}
    = note: `-D clippy::cmp-owned` implied by `-D warnings`
 
 error: this creates an owned instance just for comparison
-  --> $DIR/asymmetric_partial_eq.rs:43:21
+  --> $DIR/asymmetric_partial_eq.rs:48:21
    |
 LL |         if owned == borrowed.to_owned() {}
    |            ---------^^^^^^^^^^^^^^^^^^^
@@ -15,13 +15,13 @@ LL |         if owned == borrowed.to_owned() {}
    |            help: try: `borrowed == owned`
 
 error: this creates an owned instance just for comparison
-  --> $DIR/asymmetric_partial_eq.rs:61:21
+  --> $DIR/asymmetric_partial_eq.rs:66:21
    |
 LL |         if owned == borrowed.to_owned() {}
    |                     ^^^^^^^^^^^^^^^^^^^ help: try: `borrowed`
 
 error: this creates an owned instance just for comparison
-  --> $DIR/asymmetric_partial_eq.rs:62:12
+  --> $DIR/asymmetric_partial_eq.rs:67:12
    |
 LL |         if borrowed.to_owned() == owned {}
    |            ^^^^^^^^^^^^^^^^^^^---------
@@ -29,7 +29,7 @@ LL |         if borrowed.to_owned() == owned {}
    |            help: try: `owned == borrowed`
 
 error: this creates an owned instance just for comparison
-  --> $DIR/asymmetric_partial_eq.rs:88:20
+  --> $DIR/asymmetric_partial_eq.rs:93:20
    |
 LL |         if "Hi" == borrowed.to_string() {}
    |            --------^^^^^^^^^^^^^^^^^^^^
@@ -37,7 +37,7 @@ LL |         if "Hi" == borrowed.to_string() {}
    |            help: try: `borrowed == "Hi"`
 
 error: this creates an owned instance just for comparison
-  --> $DIR/asymmetric_partial_eq.rs:89:12
+  --> $DIR/asymmetric_partial_eq.rs:94:12
    |
 LL |         if borrowed.to_string() == "Hi" {}
    |            ^^^^^^^^^^^^^^^^^^^^ help: try: `borrowed`
diff --git a/tests/ui/collapsible_else_if.fixed b/tests/ui/collapsible_else_if.fixed
index 8302cec45e7..c4116cd8520 100644
--- a/tests/ui/collapsible_else_if.fixed
+++ b/tests/ui/collapsible_else_if.fixed
@@ -1,5 +1,5 @@
 //@run-rustfix
-#![allow(clippy::assertions_on_constants, clippy::equatable_if_let)]
+#![allow(clippy::assertions_on_constants, clippy::equatable_if_let, clippy::needless_if)]
 
 #[rustfmt::skip]
 #[warn(clippy::collapsible_if)]
diff --git a/tests/ui/collapsible_else_if.rs b/tests/ui/collapsible_else_if.rs
index 5913dcf41ca..8f51d0ee508 100644
--- a/tests/ui/collapsible_else_if.rs
+++ b/tests/ui/collapsible_else_if.rs
@@ -1,5 +1,5 @@
 //@run-rustfix
-#![allow(clippy::assertions_on_constants, clippy::equatable_if_let)]
+#![allow(clippy::assertions_on_constants, clippy::equatable_if_let, clippy::needless_if)]
 
 #[rustfmt::skip]
 #[warn(clippy::collapsible_if)]
diff --git a/tests/ui/collapsible_if.fixed b/tests/ui/collapsible_if.fixed
index c6514a55934..e305e1d7a87 100644
--- a/tests/ui/collapsible_if.fixed
+++ b/tests/ui/collapsible_if.fixed
@@ -2,6 +2,7 @@
 #![allow(
     clippy::assertions_on_constants,
     clippy::equatable_if_let,
+    clippy::needless_if,
     clippy::nonminimal_bool,
     clippy::eq_op
 )]
diff --git a/tests/ui/collapsible_if.rs b/tests/ui/collapsible_if.rs
index 2c85b68df63..7c52959d3b5 100644
--- a/tests/ui/collapsible_if.rs
+++ b/tests/ui/collapsible_if.rs
@@ -2,6 +2,7 @@
 #![allow(
     clippy::assertions_on_constants,
     clippy::equatable_if_let,
+    clippy::needless_if,
     clippy::nonminimal_bool,
     clippy::eq_op
 )]
diff --git a/tests/ui/collapsible_if.stderr b/tests/ui/collapsible_if.stderr
index c687bae1acc..4a1a9e8a60a 100644
--- a/tests/ui/collapsible_if.stderr
+++ b/tests/ui/collapsible_if.stderr
@@ -1,5 +1,5 @@
 error: this `if` statement can be collapsed
-  --> $DIR/collapsible_if.rs:14:5
+  --> $DIR/collapsible_if.rs:15:5
    |
 LL | /     if x == "hello" {
 LL | |         if y == "world" {
@@ -17,7 +17,7 @@ LL +     }
    |
 
 error: this `if` statement can be collapsed
-  --> $DIR/collapsible_if.rs:20:5
+  --> $DIR/collapsible_if.rs:21:5
    |
 LL | /     if x == "hello" || x == "world" {
 LL | |         if y == "world" || y == "hello" {
@@ -34,7 +34,7 @@ LL +     }
    |
 
 error: this `if` statement can be collapsed
-  --> $DIR/collapsible_if.rs:26:5
+  --> $DIR/collapsible_if.rs:27:5
    |
 LL | /     if x == "hello" && x == "world" {
 LL | |         if y == "world" || y == "hello" {
@@ -51,7 +51,7 @@ LL +     }
    |
 
 error: this `if` statement can be collapsed
-  --> $DIR/collapsible_if.rs:32:5
+  --> $DIR/collapsible_if.rs:33:5
    |
 LL | /     if x == "hello" || x == "world" {
 LL | |         if y == "world" && y == "hello" {
@@ -68,7 +68,7 @@ LL +     }
    |
 
 error: this `if` statement can be collapsed
-  --> $DIR/collapsible_if.rs:38:5
+  --> $DIR/collapsible_if.rs:39:5
    |
 LL | /     if x == "hello" && x == "world" {
 LL | |         if y == "world" && y == "hello" {
@@ -85,7 +85,7 @@ LL +     }
    |
 
 error: this `if` statement can be collapsed
-  --> $DIR/collapsible_if.rs:44:5
+  --> $DIR/collapsible_if.rs:45:5
    |
 LL | /     if 42 == 1337 {
 LL | |         if 'a' != 'A' {
@@ -102,7 +102,7 @@ LL +     }
    |
 
 error: this `if` statement can be collapsed
-  --> $DIR/collapsible_if.rs:100:5
+  --> $DIR/collapsible_if.rs:101:5
    |
 LL | /     if x == "hello" {
 LL | |         if y == "world" { // Collapsible
@@ -119,7 +119,7 @@ LL +     }
    |
 
 error: this `if` statement can be collapsed
-  --> $DIR/collapsible_if.rs:159:5
+  --> $DIR/collapsible_if.rs:160:5
    |
 LL | /     if matches!(true, true) {
 LL | |         if matches!(true, true) {}
@@ -127,7 +127,7 @@ LL | |     }
    | |_____^ help: collapse nested if block: `if matches!(true, true) && matches!(true, true) {}`
 
 error: this `if` statement can be collapsed
-  --> $DIR/collapsible_if.rs:164:5
+  --> $DIR/collapsible_if.rs:165:5
    |
 LL | /     if matches!(true, true) && truth() {
 LL | |         if matches!(true, true) {}
diff --git a/tests/ui/crashes/ice-3462.rs b/tests/ui/crashes/ice-3462.rs
index b402052882a..21cd9d337cd 100644
--- a/tests/ui/crashes/ice-3462.rs
+++ b/tests/ui/crashes/ice-3462.rs
@@ -1,5 +1,5 @@
 #![warn(clippy::all)]
-#![allow(clippy::disallowed_names, clippy::equatable_if_let)]
+#![allow(clippy::disallowed_names, clippy::equatable_if_let, clippy::needless_if)]
 #![allow(unused)]
 
 /// Test for https://github.com/rust-lang/rust-clippy/issues/3462
diff --git a/tests/ui/crashes/ice-7169.rs b/tests/ui/crashes/ice-7169.rs
index 82095febc19..b203252f0a1 100644
--- a/tests/ui/crashes/ice-7169.rs
+++ b/tests/ui/crashes/ice-7169.rs
@@ -1,3 +1,5 @@
+#![allow(clippy::needless_if)]
+
 #[derive(Default)]
 struct A<T> {
     a: Vec<A<T>>,
diff --git a/tests/ui/crashes/ice-7169.stderr b/tests/ui/crashes/ice-7169.stderr
index 5a9cd32380a..84e0af3f0d0 100644
--- a/tests/ui/crashes/ice-7169.stderr
+++ b/tests/ui/crashes/ice-7169.stderr
@@ -1,5 +1,5 @@
 error: redundant pattern matching, consider using `is_ok()`
-  --> $DIR/ice-7169.rs:8:12
+  --> $DIR/ice-7169.rs:10:12
    |
 LL |     if let Ok(_) = Ok::<_, ()>(A::<String>::default()) {}
    |     -------^^^^^-------------------------------------- help: try this: `if Ok::<_, ()>(A::<String>::default()).is_ok()`
diff --git a/tests/ui/disallowed_names.rs b/tests/ui/disallowed_names.rs
index e937c49f389..5889f04439f 100644
--- a/tests/ui/disallowed_names.rs
+++ b/tests/ui/disallowed_names.rs
@@ -1,5 +1,6 @@
 #![allow(
     dead_code,
+    clippy::needless_if,
     clippy::similar_names,
     clippy::single_match,
     clippy::toplevel_ref_arg,
diff --git a/tests/ui/disallowed_names.stderr b/tests/ui/disallowed_names.stderr
index 78cb55096ff..9ab68b641f1 100644
--- a/tests/ui/disallowed_names.stderr
+++ b/tests/ui/disallowed_names.stderr
@@ -1,5 +1,5 @@
 error: use of a disallowed/placeholder name `foo`
-  --> $DIR/disallowed_names.rs:11:9
+  --> $DIR/disallowed_names.rs:12:9
    |
 LL | fn test(foo: ()) {}
    |         ^^^
@@ -7,79 +7,79 @@ LL | fn test(foo: ()) {}
    = note: `-D clippy::disallowed-names` implied by `-D warnings`
 
 error: use of a disallowed/placeholder name `foo`
-  --> $DIR/disallowed_names.rs:14:9
+  --> $DIR/disallowed_names.rs:15:9
    |
 LL |     let foo = 42;
    |         ^^^
 
 error: use of a disallowed/placeholder name `baz`
-  --> $DIR/disallowed_names.rs:15:9
+  --> $DIR/disallowed_names.rs:16:9
    |
 LL |     let baz = 42;
    |         ^^^
 
 error: use of a disallowed/placeholder name `quux`
-  --> $DIR/disallowed_names.rs:16:9
+  --> $DIR/disallowed_names.rs:17:9
    |
 LL |     let quux = 42;
    |         ^^^^
 
 error: use of a disallowed/placeholder name `foo`
-  --> $DIR/disallowed_names.rs:27:10
+  --> $DIR/disallowed_names.rs:28:10
    |
 LL |         (foo, Some(baz), quux @ Some(_)) => (),
    |          ^^^
 
 error: use of a disallowed/placeholder name `baz`
-  --> $DIR/disallowed_names.rs:27:20
+  --> $DIR/disallowed_names.rs:28:20
    |
 LL |         (foo, Some(baz), quux @ Some(_)) => (),
    |                    ^^^
 
 error: use of a disallowed/placeholder name `quux`
-  --> $DIR/disallowed_names.rs:27:26
+  --> $DIR/disallowed_names.rs:28:26
    |
 LL |         (foo, Some(baz), quux @ Some(_)) => (),
    |                          ^^^^
 
 error: use of a disallowed/placeholder name `foo`
-  --> $DIR/disallowed_names.rs:32:19
+  --> $DIR/disallowed_names.rs:33:19
    |
 LL | fn issue_1647(mut foo: u8) {
    |                   ^^^
 
 error: use of a disallowed/placeholder name `baz`
-  --> $DIR/disallowed_names.rs:33:13
+  --> $DIR/disallowed_names.rs:34:13
    |
 LL |     let mut baz = 0;
    |             ^^^
 
 error: use of a disallowed/placeholder name `quux`
-  --> $DIR/disallowed_names.rs:34:21
+  --> $DIR/disallowed_names.rs:35:21
    |
 LL |     if let Some(mut quux) = Some(42) {}
    |                     ^^^^
 
 error: use of a disallowed/placeholder name `baz`
-  --> $DIR/disallowed_names.rs:38:13
+  --> $DIR/disallowed_names.rs:39:13
    |
 LL |     let ref baz = 0;
    |             ^^^
 
 error: use of a disallowed/placeholder name `quux`
-  --> $DIR/disallowed_names.rs:39:21
+  --> $DIR/disallowed_names.rs:40:21
    |
 LL |     if let Some(ref quux) = Some(42) {}
    |                     ^^^^
 
 error: use of a disallowed/placeholder name `baz`
-  --> $DIR/disallowed_names.rs:43:17
+  --> $DIR/disallowed_names.rs:44:17
    |
 LL |     let ref mut baz = 0;
    |                 ^^^
 
 error: use of a disallowed/placeholder name `quux`
-  --> $DIR/disallowed_names.rs:44:25
+  --> $DIR/disallowed_names.rs:45:25
    |
 LL |     if let Some(ref mut quux) = Some(42) {}
    |                         ^^^^
diff --git a/tests/ui/double_comparison.fixed b/tests/ui/double_comparison.fixed
index c80ff671a5d..f8ca92ef0b3 100644
--- a/tests/ui/double_comparison.fixed
+++ b/tests/ui/double_comparison.fixed
@@ -1,4 +1,5 @@
 //@run-rustfix
+#![allow(clippy::needless_if)]
 
 fn main() {
     let x = 1;
diff --git a/tests/ui/double_comparison.rs b/tests/ui/double_comparison.rs
index bc78694aa68..47ff87bea0a 100644
--- a/tests/ui/double_comparison.rs
+++ b/tests/ui/double_comparison.rs
@@ -1,4 +1,5 @@
 //@run-rustfix
+#![allow(clippy::needless_if)]
 
 fn main() {
     let x = 1;
diff --git a/tests/ui/double_comparison.stderr b/tests/ui/double_comparison.stderr
index 05ef4e25f7f..4df1c28ac48 100644
--- a/tests/ui/double_comparison.stderr
+++ b/tests/ui/double_comparison.stderr
@@ -1,5 +1,5 @@
 error: this binary expression can be simplified
-  --> $DIR/double_comparison.rs:6:8
+  --> $DIR/double_comparison.rs:7:8
    |
 LL |     if x == y || x < y {
    |        ^^^^^^^^^^^^^^^ help: try: `x <= y`
@@ -7,43 +7,43 @@ LL |     if x == y || x < y {
    = note: `-D clippy::double-comparisons` implied by `-D warnings`
 
 error: this binary expression can be simplified
-  --> $DIR/double_comparison.rs:9:8
+  --> $DIR/double_comparison.rs:10:8
    |
 LL |     if x < y || x == y {
    |        ^^^^^^^^^^^^^^^ help: try: `x <= y`
 
 error: this binary expression can be simplified
-  --> $DIR/double_comparison.rs:12:8
+  --> $DIR/double_comparison.rs:13:8
    |
 LL |     if x == y || x > y {
    |        ^^^^^^^^^^^^^^^ help: try: `x >= y`
 
 error: this binary expression can be simplified
-  --> $DIR/double_comparison.rs:15:8
+  --> $DIR/double_comparison.rs:16:8
    |
 LL |     if x > y || x == y {
    |        ^^^^^^^^^^^^^^^ help: try: `x >= y`
 
 error: this binary expression can be simplified
-  --> $DIR/double_comparison.rs:18:8
+  --> $DIR/double_comparison.rs:19:8
    |
 LL |     if x < y || x > y {
    |        ^^^^^^^^^^^^^^ help: try: `x != y`
 
 error: this binary expression can be simplified
-  --> $DIR/double_comparison.rs:21:8
+  --> $DIR/double_comparison.rs:22:8
    |
 LL |     if x > y || x < y {
    |        ^^^^^^^^^^^^^^ help: try: `x != y`
 
 error: this binary expression can be simplified
-  --> $DIR/double_comparison.rs:24:8
+  --> $DIR/double_comparison.rs:25:8
    |
 LL |     if x <= y && x >= y {
    |        ^^^^^^^^^^^^^^^^ help: try: `x == y`
 
 error: this binary expression can be simplified
-  --> $DIR/double_comparison.rs:27:8
+  --> $DIR/double_comparison.rs:28:8
    |
 LL |     if x >= y && x <= y {
    |        ^^^^^^^^^^^^^^^^ help: try: `x == y`
diff --git a/tests/ui/equatable_if_let.fixed b/tests/ui/equatable_if_let.fixed
index 53e62760bef..1869301d224 100644
--- a/tests/ui/equatable_if_let.fixed
+++ b/tests/ui/equatable_if_let.fixed
@@ -1,7 +1,12 @@
 //@run-rustfix
 //@aux-build:proc_macros.rs
 
-#![allow(unused_variables, dead_code, clippy::derive_partial_eq_without_eq)]
+#![allow(
+    unused_variables,
+    dead_code,
+    clippy::derive_partial_eq_without_eq,
+    clippy::needless_if
+)]
 #![warn(clippy::equatable_if_let)]
 
 extern crate proc_macros;
diff --git a/tests/ui/equatable_if_let.rs b/tests/ui/equatable_if_let.rs
index 55918a5bb11..a78aec74a7b 100644
--- a/tests/ui/equatable_if_let.rs
+++ b/tests/ui/equatable_if_let.rs
@@ -1,7 +1,12 @@
 //@run-rustfix
 //@aux-build:proc_macros.rs
 
-#![allow(unused_variables, dead_code, clippy::derive_partial_eq_without_eq)]
+#![allow(
+    unused_variables,
+    dead_code,
+    clippy::derive_partial_eq_without_eq,
+    clippy::needless_if
+)]
 #![warn(clippy::equatable_if_let)]
 
 extern crate proc_macros;
diff --git a/tests/ui/equatable_if_let.stderr b/tests/ui/equatable_if_let.stderr
index a72d87bb7ba..649495dded7 100644
--- a/tests/ui/equatable_if_let.stderr
+++ b/tests/ui/equatable_if_let.stderr
@@ -1,5 +1,5 @@
 error: this pattern matching can be expressed using equality
-  --> $DIR/equatable_if_let.rs:60:8
+  --> $DIR/equatable_if_let.rs:65:8
    |
 LL |     if let 2 = a {}
    |        ^^^^^^^^^ help: try: `a == 2`
@@ -7,79 +7,79 @@ LL |     if let 2 = a {}
    = note: `-D clippy::equatable-if-let` implied by `-D warnings`
 
 error: this pattern matching can be expressed using equality
-  --> $DIR/equatable_if_let.rs:61:8
+  --> $DIR/equatable_if_let.rs:66:8
    |
 LL |     if let Ordering::Greater = a.cmp(&b) {}
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `a.cmp(&b) == Ordering::Greater`
 
 error: this pattern matching can be expressed using equality
-  --> $DIR/equatable_if_let.rs:62:8
+  --> $DIR/equatable_if_let.rs:67:8
    |
 LL |     if let Some(2) = c {}
    |        ^^^^^^^^^^^^^^^ help: try: `c == Some(2)`
 
 error: this pattern matching can be expressed using equality
-  --> $DIR/equatable_if_let.rs:63:8
+  --> $DIR/equatable_if_let.rs:68:8
    |
 LL |     if let Struct { a: 2, b: false } = d {}
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `d == (Struct { a: 2, b: false })`
 
 error: this pattern matching can be expressed using equality
-  --> $DIR/equatable_if_let.rs:64:8
+  --> $DIR/equatable_if_let.rs:69:8
    |
 LL |     if let Enum::TupleVariant(32, 64) = e {}
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `e == Enum::TupleVariant(32, 64)`
 
 error: this pattern matching can be expressed using equality
-  --> $DIR/equatable_if_let.rs:65:8
+  --> $DIR/equatable_if_let.rs:70:8
    |
 LL |     if let Enum::RecordVariant { a: 64, b: 32 } = e {}
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `e == (Enum::RecordVariant { a: 64, b: 32 })`
 
 error: this pattern matching can be expressed using equality
-  --> $DIR/equatable_if_let.rs:66:8
+  --> $DIR/equatable_if_let.rs:71:8
    |
 LL |     if let Enum::UnitVariant = e {}
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `e == Enum::UnitVariant`
 
 error: this pattern matching can be expressed using equality
-  --> $DIR/equatable_if_let.rs:67:8
+  --> $DIR/equatable_if_let.rs:72:8
    |
 LL |     if let (Enum::UnitVariant, &Struct { a: 2, b: false }) = (e, &d) {}
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `(e, &d) == (Enum::UnitVariant, &Struct { a: 2, b: false })`
 
 error: this pattern matching can be expressed using `matches!`
-  --> $DIR/equatable_if_let.rs:76:8
+  --> $DIR/equatable_if_let.rs:81:8
    |
 LL |     if let NotPartialEq::A = f {}
    |        ^^^^^^^^^^^^^^^^^^^^^^^ help: try: `matches!(f, NotPartialEq::A)`
 
 error: this pattern matching can be expressed using equality
-  --> $DIR/equatable_if_let.rs:77:8
+  --> $DIR/equatable_if_let.rs:82:8
    |
 LL |     if let NotStructuralEq::A = g {}
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `g == NotStructuralEq::A`
 
 error: this pattern matching can be expressed using `matches!`
-  --> $DIR/equatable_if_let.rs:78:8
+  --> $DIR/equatable_if_let.rs:83:8
    |
 LL |     if let Some(NotPartialEq::A) = Some(f) {}
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `matches!(Some(f), Some(NotPartialEq::A))`
 
 error: this pattern matching can be expressed using equality
-  --> $DIR/equatable_if_let.rs:79:8
+  --> $DIR/equatable_if_let.rs:84:8
    |
 LL |     if let Some(NotStructuralEq::A) = Some(g) {}
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Some(g) == Some(NotStructuralEq::A)`
 
 error: this pattern matching can be expressed using `matches!`
-  --> $DIR/equatable_if_let.rs:80:8
+  --> $DIR/equatable_if_let.rs:85:8
    |
 LL |     if let NoPartialEqStruct { a: 2, b: false } = h {}
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `matches!(h, NoPartialEqStruct { a: 2, b: false })`
 
 error: this pattern matching can be expressed using equality
-  --> $DIR/equatable_if_let.rs:82:8
+  --> $DIR/equatable_if_let.rs:87:8
    |
 LL |     if let inline!("abc") = "abc" {
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `"abc" == inline!("abc")`
diff --git a/tests/ui/expect_tool_lint_rfc_2383.rs b/tests/ui/expect_tool_lint_rfc_2383.rs
index ca81808a863..7963bf0f3a6 100644
--- a/tests/ui/expect_tool_lint_rfc_2383.rs
+++ b/tests/ui/expect_tool_lint_rfc_2383.rs
@@ -11,6 +11,7 @@
 //! This test can't cover every lint from Clippy, rustdoc and potentially other
 //! tools that will be developed. This therefore only tests a small subset of lints
 #![expect(rustdoc::missing_crate_level_docs)]
+#![allow(clippy::needless_if)]
 
 mod rustc_ok {
     //! See <https://doc.rust-lang.org/rustc/lints/index.html>
diff --git a/tests/ui/expect_tool_lint_rfc_2383.stderr b/tests/ui/expect_tool_lint_rfc_2383.stderr
index 77210ca7a9d..7ce9e855b5e 100644
--- a/tests/ui/expect_tool_lint_rfc_2383.stderr
+++ b/tests/ui/expect_tool_lint_rfc_2383.stderr
@@ -1,5 +1,5 @@
 error: this lint expectation is unfulfilled
-  --> $DIR/expect_tool_lint_rfc_2383.rs:34:14
+  --> $DIR/expect_tool_lint_rfc_2383.rs:35:14
    |
 LL |     #[expect(dead_code)]
    |              ^^^^^^^^^
@@ -7,31 +7,31 @@ LL |     #[expect(dead_code)]
    = note: `-D unfulfilled-lint-expectations` implied by `-D warnings`
 
 error: this lint expectation is unfulfilled
-  --> $DIR/expect_tool_lint_rfc_2383.rs:38:18
+  --> $DIR/expect_tool_lint_rfc_2383.rs:39:18
    |
 LL |         #[expect(illegal_floating_point_literal_pattern)]
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this lint expectation is unfulfilled
-  --> $DIR/expect_tool_lint_rfc_2383.rs:112:14
+  --> $DIR/expect_tool_lint_rfc_2383.rs:113:14
    |
 LL |     #[expect(clippy::almost_swapped)]
    |              ^^^^^^^^^^^^^^^^^^^^^^
 
 error: this lint expectation is unfulfilled
-  --> $DIR/expect_tool_lint_rfc_2383.rs:119:14
+  --> $DIR/expect_tool_lint_rfc_2383.rs:120:14
    |
 LL |     #[expect(clippy::bytes_nth)]
    |              ^^^^^^^^^^^^^^^^^
 
 error: this lint expectation is unfulfilled
-  --> $DIR/expect_tool_lint_rfc_2383.rs:124:14
+  --> $DIR/expect_tool_lint_rfc_2383.rs:125:14
    |
 LL |     #[expect(clippy::if_same_then_else)]
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this lint expectation is unfulfilled
-  --> $DIR/expect_tool_lint_rfc_2383.rs:129:14
+  --> $DIR/expect_tool_lint_rfc_2383.rs:130:14
    |
 LL |     #[expect(clippy::overly_complex_bool_expr)]
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/filetype_is_file.rs b/tests/ui/filetype_is_file.rs
index 5de8fe8cdd7..d3ad36e40b5 100644
--- a/tests/ui/filetype_is_file.rs
+++ b/tests/ui/filetype_is_file.rs
@@ -1,3 +1,4 @@
+#![allow(clippy::needless_if)]
 #![warn(clippy::filetype_is_file)]
 
 fn main() -> std::io::Result<()> {
diff --git a/tests/ui/filetype_is_file.stderr b/tests/ui/filetype_is_file.stderr
index e51a90d6cfd..36142deb309 100644
--- a/tests/ui/filetype_is_file.stderr
+++ b/tests/ui/filetype_is_file.stderr
@@ -1,5 +1,5 @@
 error: `FileType::is_file()` only covers regular files
-  --> $DIR/filetype_is_file.rs:8:8
+  --> $DIR/filetype_is_file.rs:9:8
    |
 LL |     if fs::metadata("foo.txt")?.file_type().is_file() {
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -8,7 +8,7 @@ LL |     if fs::metadata("foo.txt")?.file_type().is_file() {
    = note: `-D clippy::filetype-is-file` implied by `-D warnings`
 
 error: `!FileType::is_file()` only denies regular files
-  --> $DIR/filetype_is_file.rs:13:8
+  --> $DIR/filetype_is_file.rs:14:8
    |
 LL |     if !fs::metadata("foo.txt")?.file_type().is_file() {
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -16,7 +16,7 @@ LL |     if !fs::metadata("foo.txt")?.file_type().is_file() {
    = help: use `FileType::is_dir()` instead
 
 error: `FileType::is_file()` only covers regular files
-  --> $DIR/filetype_is_file.rs:18:9
+  --> $DIR/filetype_is_file.rs:19:9
    |
 LL |     if !fs::metadata("foo.txt")?.file_type().is_file().bitor(true) {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/fn_null_check.rs b/tests/ui/fn_null_check.rs
index df5bc8420d5..dfdea100c8f 100644
--- a/tests/ui/fn_null_check.rs
+++ b/tests/ui/fn_null_check.rs
@@ -1,6 +1,7 @@
 #![allow(unused)]
 #![warn(clippy::fn_null_check)]
 #![allow(clippy::cmp_null)]
+#![allow(clippy::needless_if)]
 #![allow(clippy::ptr_eq)]
 #![allow(clippy::zero_ptr)]
 
diff --git a/tests/ui/fn_null_check.stderr b/tests/ui/fn_null_check.stderr
index 660dd323979..5b9f48a961c 100644
--- a/tests/ui/fn_null_check.stderr
+++ b/tests/ui/fn_null_check.stderr
@@ -1,5 +1,5 @@
 error: function pointer assumed to be nullable, even though it isn't
-  --> $DIR/fn_null_check.rs:13:8
+  --> $DIR/fn_null_check.rs:14:8
    |
 LL |     if (fn_ptr as *mut ()).is_null() {}
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -8,7 +8,7 @@ LL |     if (fn_ptr as *mut ()).is_null() {}
    = note: `-D clippy::fn-null-check` implied by `-D warnings`
 
 error: function pointer assumed to be nullable, even though it isn't
-  --> $DIR/fn_null_check.rs:14:8
+  --> $DIR/fn_null_check.rs:15:8
    |
 LL |     if (fn_ptr as *const u8).is_null() {}
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -16,7 +16,7 @@ LL |     if (fn_ptr as *const u8).is_null() {}
    = help: try wrapping your function pointer type in `Option<T>` instead, and using `is_none` to check for null pointer value
 
 error: function pointer assumed to be nullable, even though it isn't
-  --> $DIR/fn_null_check.rs:15:8
+  --> $DIR/fn_null_check.rs:16:8
    |
 LL |     if (fn_ptr as *const ()) == std::ptr::null() {}
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -24,7 +24,7 @@ LL |     if (fn_ptr as *const ()) == std::ptr::null() {}
    = help: try wrapping your function pointer type in `Option<T>` instead, and using `is_none` to check for null pointer value
 
 error: function pointer assumed to be nullable, even though it isn't
-  --> $DIR/fn_null_check.rs:16:8
+  --> $DIR/fn_null_check.rs:17:8
    |
 LL |     if (fn_ptr as *const ()) == (0 as *const ()) {}
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -32,7 +32,7 @@ LL |     if (fn_ptr as *const ()) == (0 as *const ()) {}
    = help: try wrapping your function pointer type in `Option<T>` instead, and using `is_none` to check for null pointer value
 
 error: function pointer assumed to be nullable, even though it isn't
-  --> $DIR/fn_null_check.rs:17:8
+  --> $DIR/fn_null_check.rs:18:8
    |
 LL |     if (fn_ptr as *const ()) == ZPTR {}
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/if_same_then_else2.rs b/tests/ui/if_same_then_else2.rs
index 58167f4446d..3b9b029d354 100644
--- a/tests/ui/if_same_then_else2.rs
+++ b/tests/ui/if_same_then_else2.rs
@@ -5,6 +5,7 @@
     clippy::equatable_if_let,
     clippy::collapsible_if,
     clippy::ifs_same_cond,
+    clippy::needless_if,
     clippy::needless_return,
     clippy::single_element_loop,
     clippy::branches_sharing_code
diff --git a/tests/ui/if_same_then_else2.stderr b/tests/ui/if_same_then_else2.stderr
index 704cfd9669a..a4d8a74167e 100644
--- a/tests/ui/if_same_then_else2.stderr
+++ b/tests/ui/if_same_then_else2.stderr
@@ -1,5 +1,5 @@
 error: this `if` has identical blocks
-  --> $DIR/if_same_then_else2.rs:14:13
+  --> $DIR/if_same_then_else2.rs:15:13
    |
 LL |       if true {
    |  _____________^
@@ -12,7 +12,7 @@ LL | |     } else {
    | |_____^
    |
 note: same as this
-  --> $DIR/if_same_then_else2.rs:23:12
+  --> $DIR/if_same_then_else2.rs:24:12
    |
 LL |       } else {
    |  ____________^
@@ -26,7 +26,7 @@ LL | |     }
    = note: `-D clippy::if-same-then-else` implied by `-D warnings`
 
 error: this `if` has identical blocks
-  --> $DIR/if_same_then_else2.rs:35:13
+  --> $DIR/if_same_then_else2.rs:36:13
    |
 LL |       if true {
    |  _____________^
@@ -35,7 +35,7 @@ LL | |     } else {
    | |_____^
    |
 note: same as this
-  --> $DIR/if_same_then_else2.rs:37:12
+  --> $DIR/if_same_then_else2.rs:38:12
    |
 LL |       } else {
    |  ____________^
@@ -45,7 +45,7 @@ LL | |     }
    | |_____^
 
 error: this `if` has identical blocks
-  --> $DIR/if_same_then_else2.rs:42:13
+  --> $DIR/if_same_then_else2.rs:43:13
    |
 LL |       if true {
    |  _____________^
@@ -54,7 +54,7 @@ LL | |     } else {
    | |_____^
    |
 note: same as this
-  --> $DIR/if_same_then_else2.rs:44:12
+  --> $DIR/if_same_then_else2.rs:45:12
    |
 LL |       } else {
    |  ____________^
@@ -64,7 +64,7 @@ LL | |     }
    | |_____^
 
 error: this `if` has identical blocks
-  --> $DIR/if_same_then_else2.rs:92:21
+  --> $DIR/if_same_then_else2.rs:93:21
    |
 LL |       let _ = if true {
    |  _____________________^
@@ -73,7 +73,7 @@ LL | |     } else {
    | |_____^
    |
 note: same as this
-  --> $DIR/if_same_then_else2.rs:94:12
+  --> $DIR/if_same_then_else2.rs:95:12
    |
 LL |       } else {
    |  ____________^
@@ -83,7 +83,7 @@ LL | |     };
    | |_____^
 
 error: this `if` has identical blocks
-  --> $DIR/if_same_then_else2.rs:99:13
+  --> $DIR/if_same_then_else2.rs:100:13
    |
 LL |       if true {
    |  _____________^
@@ -92,7 +92,7 @@ LL | |     } else {
    | |_____^
    |
 note: same as this
-  --> $DIR/if_same_then_else2.rs:101:12
+  --> $DIR/if_same_then_else2.rs:102:12
    |
 LL |       } else {
    |  ____________^
@@ -102,7 +102,7 @@ LL | |     }
    | |_____^
 
 error: this `if` has identical blocks
-  --> $DIR/if_same_then_else2.rs:123:20
+  --> $DIR/if_same_then_else2.rs:124:20
    |
 LL |       } else if true {
    |  ____________________^
@@ -112,7 +112,7 @@ LL | |     } else {
    | |_____^
    |
 note: same as this
-  --> $DIR/if_same_then_else2.rs:126:12
+  --> $DIR/if_same_then_else2.rs:127:12
    |
 LL |       } else {
    |  ____________^
diff --git a/tests/ui/ifs_same_cond.rs b/tests/ui/ifs_same_cond.rs
index f62da157d1b..c321b08909f 100644
--- a/tests/ui/ifs_same_cond.rs
+++ b/tests/ui/ifs_same_cond.rs
@@ -1,5 +1,10 @@
 #![warn(clippy::ifs_same_cond)]
-#![allow(clippy::if_same_then_else, clippy::comparison_chain, clippy::needless_else)] // all empty blocks
+#![allow(
+    clippy::if_same_then_else,
+    clippy::comparison_chain,
+    clippy::needless_if,
+    clippy::needless_else
+)] // all empty blocks
 
 fn ifs_same_cond() {
     let a = 0;
diff --git a/tests/ui/ifs_same_cond.stderr b/tests/ui/ifs_same_cond.stderr
index 9519f6904cb..8d70934476c 100644
--- a/tests/ui/ifs_same_cond.stderr
+++ b/tests/ui/ifs_same_cond.stderr
@@ -1,48 +1,48 @@
 error: this `if` has the same condition as a previous `if`
-  --> $DIR/ifs_same_cond.rs:9:15
+  --> $DIR/ifs_same_cond.rs:14:15
    |
 LL |     } else if b {
    |               ^
    |
 note: same as this
-  --> $DIR/ifs_same_cond.rs:8:8
+  --> $DIR/ifs_same_cond.rs:13:8
    |
 LL |     if b {
    |        ^
    = note: `-D clippy::ifs-same-cond` implied by `-D warnings`
 
 error: this `if` has the same condition as a previous `if`
-  --> $DIR/ifs_same_cond.rs:14:15
+  --> $DIR/ifs_same_cond.rs:19:15
    |
 LL |     } else if a == 1 {
    |               ^^^^^^
    |
 note: same as this
-  --> $DIR/ifs_same_cond.rs:13:8
+  --> $DIR/ifs_same_cond.rs:18:8
    |
 LL |     if a == 1 {
    |        ^^^^^^
 
 error: this `if` has the same condition as a previous `if`
-  --> $DIR/ifs_same_cond.rs:20:15
+  --> $DIR/ifs_same_cond.rs:25:15
    |
 LL |     } else if 2 * a == 1 {
    |               ^^^^^^^^^^
    |
 note: same as this
-  --> $DIR/ifs_same_cond.rs:18:8
+  --> $DIR/ifs_same_cond.rs:23:8
    |
 LL |     if 2 * a == 1 {
    |        ^^^^^^^^^^
 
 error: this `if` has the same condition as a previous `if`
-  --> $DIR/ifs_same_cond.rs:49:15
+  --> $DIR/ifs_same_cond.rs:54:15
    |
 LL |     } else if a.contains("ah") {
    |               ^^^^^^^^^^^^^^^^
    |
 note: same as this
-  --> $DIR/ifs_same_cond.rs:48:8
+  --> $DIR/ifs_same_cond.rs:53:8
    |
 LL |     if a.contains("ah") {
    |        ^^^^^^^^^^^^^^^^
diff --git a/tests/ui/len_zero.fixed b/tests/ui/len_zero.fixed
index 2c22abd7e4b..fafee6a0d41 100644
--- a/tests/ui/len_zero.fixed
+++ b/tests/ui/len_zero.fixed
@@ -1,7 +1,7 @@
 //@run-rustfix
 
 #![warn(clippy::len_zero)]
-#![allow(dead_code, unused, clippy::len_without_is_empty)]
+#![allow(dead_code, unused, clippy::needless_if, clippy::len_without_is_empty)]
 
 extern crate core;
 use core::ops::Deref;
diff --git a/tests/ui/len_zero.rs b/tests/ui/len_zero.rs
index a011ff97644..6a9006c4779 100644
--- a/tests/ui/len_zero.rs
+++ b/tests/ui/len_zero.rs
@@ -1,7 +1,7 @@
 //@run-rustfix
 
 #![warn(clippy::len_zero)]
-#![allow(dead_code, unused, clippy::len_without_is_empty)]
+#![allow(dead_code, unused, clippy::needless_if, clippy::len_without_is_empty)]
 
 extern crate core;
 use core::ops::Deref;
diff --git a/tests/ui/manual_let_else.rs b/tests/ui/manual_let_else.rs
index b5c2a5dba34..46241afec94 100644
--- a/tests/ui/manual_let_else.rs
+++ b/tests/ui/manual_let_else.rs
@@ -4,7 +4,8 @@
     clippy::unused_unit,
     clippy::let_unit_value,
     clippy::match_single_binding,
-    clippy::never_loop
+    clippy::never_loop,
+    clippy::needless_if
 )]
 #![warn(clippy::manual_let_else)]
 
diff --git a/tests/ui/manual_let_else.stderr b/tests/ui/manual_let_else.stderr
index 9d4aef4cad6..1eada4f992e 100644
--- a/tests/ui/manual_let_else.stderr
+++ b/tests/ui/manual_let_else.stderr
@@ -1,5 +1,5 @@
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:24:5
+  --> $DIR/manual_let_else.rs:25:5
    |
 LL |     let v = if let Some(v_some) = g() { v_some } else { return };
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let Some(v) = g() else { return };`
@@ -7,7 +7,7 @@ LL |     let v = if let Some(v_some) = g() { v_some } 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:25:5
+  --> $DIR/manual_let_else.rs:26:5
    |
 LL | /     let v = if let Some(v_some) = g() {
 LL | |         v_some
@@ -24,7 +24,7 @@ LL +     };
    |
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:31:5
+  --> $DIR/manual_let_else.rs:32: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:44:9
+  --> $DIR/manual_let_else.rs:45:9
    |
 LL |         let v = if let Some(v_some) = g() { v_some } else { continue };
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let Some(v) = g() else { continue };`
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:45:9
+  --> $DIR/manual_let_else.rs:46:9
    |
 LL |         let v = if let Some(v_some) = g() { v_some } else { break };
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let Some(v) = g() else { break };`
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:49:5
+  --> $DIR/manual_let_else.rs:50:5
    |
 LL |     let v = if let Some(v_some) = g() { v_some } else { panic!() };
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let Some(v) = g() else { panic!() };`
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:52:5
+  --> $DIR/manual_let_else.rs:53:5
    |
 LL | /     let v = if let Some(v_some) = g() {
 LL | |         v_some
@@ -80,7 +80,7 @@ LL +     };
    |
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:59:5
+  --> $DIR/manual_let_else.rs:60:5
    |
 LL | /     let v = if let Some(v_some) = g() {
 LL | |         v_some
@@ -97,7 +97,7 @@ LL +     };
    |
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:66:5
+  --> $DIR/manual_let_else.rs:67:5
    |
 LL | /     let v = if let Some(v_some) = g() {
 LL | |         v_some
@@ -116,7 +116,7 @@ LL +     };
    |
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:76:5
+  --> $DIR/manual_let_else.rs:77:5
    |
 LL | /     let v = if let Some(v_some) = g() {
 LL | |         v_some
@@ -138,13 +138,13 @@ LL +     };
    |
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:86:5
+  --> $DIR/manual_let_else.rs:87:5
    |
 LL |     let v = if let Some(v_some) = g() { v_some } 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:89:5
+  --> $DIR/manual_let_else.rs:90:5
    |
 LL | /     let v = if let Some(v_some) = g() {
 LL | |         v_some
@@ -165,7 +165,7 @@ LL +     };
    |
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:98:5
+  --> $DIR/manual_let_else.rs:99:5
    |
 LL | /     let v = if let Some(v_some) = g() {
 LL | |         v_some
@@ -186,7 +186,7 @@ LL +     } };
    |
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:107:5
+  --> $DIR/manual_let_else.rs:108:5
    |
 LL | /     let v = if let Some(v_some) = g() {
 LL | |         v_some
@@ -215,7 +215,7 @@ LL +     };
    |
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:124:5
+  --> $DIR/manual_let_else.rs:125:5
    |
 LL | /     let (v, w) = if let Some(v_some) = g().map(|v| (v, 42)) {
 LL | |         v_some
@@ -232,7 +232,7 @@ LL +     };
    |
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:131:5
+  --> $DIR/manual_let_else.rs:132:5
    |
 LL | /     let (w, S { v }) = if let (Some(v_some), w_some) = (g().map(|_| S { v: 0 }), 0) {
 LL | |         (w_some, v_some)
@@ -249,7 +249,7 @@ LL +     };
    |
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:140:13
+  --> $DIR/manual_let_else.rs:141:13
    |
 LL |             let $n = if let Some(v) = $e { v } else { return };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let Some($n) = g() else { return };`
@@ -260,19 +260,19 @@ LL |     create_binding_if_some!(w, g());
    = 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:149: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(v, 0) = e() else { return };`
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:152:5
+  --> $DIR/manual_let_else.rs:153:5
    |
 LL |     let mut v = if let Variant::B(b) = e() { b } else { return };
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let Variant::B(mut v) = e() else { return };`
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:156:5
+  --> $DIR/manual_let_else.rs:157:5
    |
 LL | /     let v = if let Ok(Some(Variant::B(b))) | Err(Some(Variant::A(b, _))) = nested {
 LL | |         b
@@ -289,19 +289,19 @@ LL +     };
    |
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:162:5
+  --> $DIR/manual_let_else.rs:163:5
    |
 LL |     let v = if let Variant::A(.., a) = e() { a } else { return };
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let Variant::A(.., v) = e() else { return };`
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:165:5
+  --> $DIR/manual_let_else.rs:166:5
    |
 LL |     let w = if let (Some(v), ()) = (g(), ()) { v } else { return };
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let (Some(w), ()) = (g(), ()) else { return };`
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:168:5
+  --> $DIR/manual_let_else.rs:169:5
    |
 LL | /     let w = if let Some(S { v: x }) = Some(S { v: 0 }) {
 LL | |         x
@@ -318,7 +318,7 @@ LL +     };
    |
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:175:5
+  --> $DIR/manual_let_else.rs:176:5
    |
 LL | /     let v = if let Some(S { v: x }) = Some(S { v: 0 }) {
 LL | |         x
@@ -335,7 +335,7 @@ LL +     };
    |
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:182:5
+  --> $DIR/manual_let_else.rs:183:5
    |
 LL | /     let (x, S { v }, w) = if let Some(U { v, w, x }) = None::<U<S<()>>> {
 LL | |         (x, v, w)
@@ -352,7 +352,7 @@ LL +     };
    |
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:296:5
+  --> $DIR/manual_let_else.rs:297:5
    |
 LL | /     let _ = match ff {
 LL | |         Some(value) => value,
diff --git a/tests/ui/match_overlapping_arm.rs b/tests/ui/match_overlapping_arm.rs
index b4097fa9604..b78c1fd06d4 100644
--- a/tests/ui/match_overlapping_arm.rs
+++ b/tests/ui/match_overlapping_arm.rs
@@ -1,7 +1,7 @@
 #![feature(exclusive_range_pattern)]
 #![warn(clippy::match_overlapping_arm)]
 #![allow(clippy::redundant_pattern_matching)]
-#![allow(clippy::if_same_then_else, clippy::equatable_if_let)]
+#![allow(clippy::if_same_then_else, clippy::equatable_if_let, clippy::needless_if)]
 
 /// Tests for match_overlapping_arm
 
diff --git a/tests/ui/needless_bool/fixable.fixed b/tests/ui/needless_bool/fixable.fixed
index bf1911881c8..7d0e556528f 100644
--- a/tests/ui/needless_bool/fixable.fixed
+++ b/tests/ui/needless_bool/fixable.fixed
@@ -7,6 +7,7 @@
     clippy::no_effect,
     clippy::if_same_then_else,
     clippy::equatable_if_let,
+    clippy::needless_if,
     clippy::needless_return,
     clippy::self_named_constructors
 )]
diff --git a/tests/ui/needless_bool/fixable.rs b/tests/ui/needless_bool/fixable.rs
index a6c465d4fbd..88bfe8af733 100644
--- a/tests/ui/needless_bool/fixable.rs
+++ b/tests/ui/needless_bool/fixable.rs
@@ -7,6 +7,7 @@
     clippy::no_effect,
     clippy::if_same_then_else,
     clippy::equatable_if_let,
+    clippy::needless_if,
     clippy::needless_return,
     clippy::self_named_constructors
 )]
diff --git a/tests/ui/needless_bool/fixable.stderr b/tests/ui/needless_bool/fixable.stderr
index fa906374fb3..1476aea439f 100644
--- a/tests/ui/needless_bool/fixable.stderr
+++ b/tests/ui/needless_bool/fixable.stderr
@@ -1,5 +1,5 @@
 error: this if-then-else expression returns a bool literal
-  --> $DIR/fixable.rs:41:5
+  --> $DIR/fixable.rs:42:5
    |
 LL | /     if x {
 LL | |         true
@@ -11,7 +11,7 @@ LL | |     };
    = note: `-D clippy::needless-bool` implied by `-D warnings`
 
 error: this if-then-else expression returns a bool literal
-  --> $DIR/fixable.rs:46:5
+  --> $DIR/fixable.rs:47:5
    |
 LL | /     if x {
 LL | |         false
@@ -21,7 +21,7 @@ LL | |     };
    | |_____^ help: you can reduce it to: `!x`
 
 error: this if-then-else expression returns a bool literal
-  --> $DIR/fixable.rs:51:5
+  --> $DIR/fixable.rs:52:5
    |
 LL | /     if x && y {
 LL | |         false
@@ -31,7 +31,7 @@ LL | |     };
    | |_____^ help: you can reduce it to: `!(x && y)`
 
 error: this if-then-else expression returns a bool literal
-  --> $DIR/fixable.rs:59:5
+  --> $DIR/fixable.rs:60:5
    |
 LL | /     if a == b {
 LL | |         false
@@ -41,7 +41,7 @@ LL | |     };
    | |_____^ help: you can reduce it to: `a != b`
 
 error: this if-then-else expression returns a bool literal
-  --> $DIR/fixable.rs:64:5
+  --> $DIR/fixable.rs:65:5
    |
 LL | /     if a != b {
 LL | |         false
@@ -51,7 +51,7 @@ LL | |     };
    | |_____^ help: you can reduce it to: `a == b`
 
 error: this if-then-else expression returns a bool literal
-  --> $DIR/fixable.rs:69:5
+  --> $DIR/fixable.rs:70:5
    |
 LL | /     if a < b {
 LL | |         false
@@ -61,7 +61,7 @@ LL | |     };
    | |_____^ help: you can reduce it to: `a >= b`
 
 error: this if-then-else expression returns a bool literal
-  --> $DIR/fixable.rs:74:5
+  --> $DIR/fixable.rs:75:5
    |
 LL | /     if a <= b {
 LL | |         false
@@ -71,7 +71,7 @@ LL | |     };
    | |_____^ help: you can reduce it to: `a > b`
 
 error: this if-then-else expression returns a bool literal
-  --> $DIR/fixable.rs:79:5
+  --> $DIR/fixable.rs:80:5
    |
 LL | /     if a > b {
 LL | |         false
@@ -81,7 +81,7 @@ LL | |     };
    | |_____^ help: you can reduce it to: `a <= b`
 
 error: this if-then-else expression returns a bool literal
-  --> $DIR/fixable.rs:84:5
+  --> $DIR/fixable.rs:85:5
    |
 LL | /     if a >= b {
 LL | |         false
@@ -91,7 +91,7 @@ LL | |     };
    | |_____^ help: you can reduce it to: `a < b`
 
 error: this if-then-else expression returns a bool literal
-  --> $DIR/fixable.rs:112:5
+  --> $DIR/fixable.rs:113:5
    |
 LL | /     if x {
 LL | |         return true;
@@ -101,7 +101,7 @@ LL | |     };
    | |_____^ help: you can reduce it to: `return x`
 
 error: this if-then-else expression returns a bool literal
-  --> $DIR/fixable.rs:120:5
+  --> $DIR/fixable.rs:121:5
    |
 LL | /     if x {
 LL | |         return false;
@@ -111,7 +111,7 @@ LL | |     };
    | |_____^ help: you can reduce it to: `return !x`
 
 error: this if-then-else expression returns a bool literal
-  --> $DIR/fixable.rs:128:5
+  --> $DIR/fixable.rs:129:5
    |
 LL | /     if x && y {
 LL | |         return true;
@@ -121,7 +121,7 @@ LL | |     };
    | |_____^ help: you can reduce it to: `return x && y`
 
 error: this if-then-else expression returns a bool literal
-  --> $DIR/fixable.rs:136:5
+  --> $DIR/fixable.rs:137:5
    |
 LL | /     if x && y {
 LL | |         return false;
@@ -131,7 +131,7 @@ LL | |     };
    | |_____^ help: you can reduce it to: `return !(x && y)`
 
 error: equality checks against true are unnecessary
-  --> $DIR/fixable.rs:144:8
+  --> $DIR/fixable.rs:145:8
    |
 LL |     if x == true {};
    |        ^^^^^^^^^ help: try simplifying it as shown: `x`
@@ -139,25 +139,25 @@ LL |     if x == true {};
    = note: `-D clippy::bool-comparison` implied by `-D warnings`
 
 error: equality checks against false can be replaced by a negation
-  --> $DIR/fixable.rs:148:8
+  --> $DIR/fixable.rs:149:8
    |
 LL |     if x == false {};
    |        ^^^^^^^^^^ help: try simplifying it as shown: `!x`
 
 error: equality checks against true are unnecessary
-  --> $DIR/fixable.rs:158:8
+  --> $DIR/fixable.rs:159:8
    |
 LL |     if x == true {};
    |        ^^^^^^^^^ help: try simplifying it as shown: `x`
 
 error: equality checks against false can be replaced by a negation
-  --> $DIR/fixable.rs:159:8
+  --> $DIR/fixable.rs:160:8
    |
 LL |     if x == false {};
    |        ^^^^^^^^^^ help: try simplifying it as shown: `!x`
 
 error: this if-then-else expression returns a bool literal
-  --> $DIR/fixable.rs:168:12
+  --> $DIR/fixable.rs:169:12
    |
 LL |       } else if returns_bool() {
    |  ____________^
@@ -168,7 +168,7 @@ LL | |     };
    | |_____^ help: you can reduce it to: `{ !returns_bool() }`
 
 error: this if-then-else expression returns a bool literal
-  --> $DIR/fixable.rs:181:5
+  --> $DIR/fixable.rs:182:5
    |
 LL | /     if unsafe { no(4) } & 1 != 0 {
 LL | |         true
@@ -178,13 +178,13 @@ LL | |     };
    | |_____^ help: you can reduce it to: `(unsafe { no(4) } & 1 != 0)`
 
 error: this if-then-else expression returns a bool literal
-  --> $DIR/fixable.rs:186:30
+  --> $DIR/fixable.rs:187:30
    |
 LL |     let _brackets_unneeded = if unsafe { no(4) } & 1 != 0 { true } else { false };
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: you can reduce it to: `unsafe { no(4) } & 1 != 0`
 
 error: this if-then-else expression returns a bool literal
-  --> $DIR/fixable.rs:189:9
+  --> $DIR/fixable.rs:190:9
    |
 LL |         if unsafe { no(4) } & 1 != 0 { true } else { false }
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: you can reduce it to: `(unsafe { no(4) } & 1 != 0)`
diff --git a/tests/ui/needless_borrowed_ref.fixed b/tests/ui/needless_borrowed_ref.fixed
index 6663520da8a..59a38425b06 100644
--- a/tests/ui/needless_borrowed_ref.fixed
+++ b/tests/ui/needless_borrowed_ref.fixed
@@ -5,7 +5,8 @@
     unused,
     irrefutable_let_patterns,
     non_shorthand_field_patterns,
-    clippy::needless_borrow
+    clippy::needless_borrow,
+    clippy::needless_if
 )]
 
 fn main() {}
diff --git a/tests/ui/needless_borrowed_ref.rs b/tests/ui/needless_borrowed_ref.rs
index 6c8efd2ce18..e48b19cb19d 100644
--- a/tests/ui/needless_borrowed_ref.rs
+++ b/tests/ui/needless_borrowed_ref.rs
@@ -5,7 +5,8 @@
     unused,
     irrefutable_let_patterns,
     non_shorthand_field_patterns,
-    clippy::needless_borrow
+    clippy::needless_borrow,
+    clippy::needless_if
 )]
 
 fn main() {}
diff --git a/tests/ui/needless_borrowed_ref.stderr b/tests/ui/needless_borrowed_ref.stderr
index 8d0f0c258dd..35497a01ec2 100644
--- a/tests/ui/needless_borrowed_ref.stderr
+++ b/tests/ui/needless_borrowed_ref.stderr
@@ -1,5 +1,5 @@
 error: this pattern takes a reference on something that is being dereferenced
-  --> $DIR/needless_borrowed_ref.rs:31:34
+  --> $DIR/needless_borrowed_ref.rs:32:34
    |
 LL |     let _ = v.iter_mut().filter(|&ref a| a.is_empty());
    |                                  ^^^^^^
@@ -12,7 +12,7 @@ LL +     let _ = v.iter_mut().filter(|a| a.is_empty());
    |
 
 error: this pattern takes a reference on something that is being dereferenced
-  --> $DIR/needless_borrowed_ref.rs:35:17
+  --> $DIR/needless_borrowed_ref.rs:36:17
    |
 LL |     if let Some(&ref v) = thingy {}
    |                 ^^^^^^
@@ -24,7 +24,7 @@ LL +     if let Some(v) = thingy {}
    |
 
 error: this pattern takes a reference on something that is being dereferenced
-  --> $DIR/needless_borrowed_ref.rs:37:14
+  --> $DIR/needless_borrowed_ref.rs:38:14
    |
 LL |     if let &[&ref a, ref b] = slice_of_refs {}
    |              ^^^^^^
@@ -36,7 +36,7 @@ LL +     if let &[a, ref b] = slice_of_refs {}
    |
 
 error: dereferencing a slice pattern where every element takes a reference
-  --> $DIR/needless_borrowed_ref.rs:39:9
+  --> $DIR/needless_borrowed_ref.rs:40:9
    |
 LL |     let &[ref a, ..] = &array;
    |         ^^^^^^^^^^^^
@@ -48,7 +48,7 @@ LL +     let [a, ..] = &array;
    |
 
 error: dereferencing a slice pattern where every element takes a reference
-  --> $DIR/needless_borrowed_ref.rs:40:9
+  --> $DIR/needless_borrowed_ref.rs:41:9
    |
 LL |     let &[ref a, ref b, ..] = &array;
    |         ^^^^^^^^^^^^^^^^^^^
@@ -60,7 +60,7 @@ LL +     let [a, b, ..] = &array;
    |
 
 error: dereferencing a slice pattern where every element takes a reference
-  --> $DIR/needless_borrowed_ref.rs:42:12
+  --> $DIR/needless_borrowed_ref.rs:43:12
    |
 LL |     if let &[ref a, ref b] = slice {}
    |            ^^^^^^^^^^^^^^^
@@ -72,7 +72,7 @@ LL +     if let [a, b] = slice {}
    |
 
 error: dereferencing a slice pattern where every element takes a reference
-  --> $DIR/needless_borrowed_ref.rs:43:12
+  --> $DIR/needless_borrowed_ref.rs:44:12
    |
 LL |     if let &[ref a, ref b] = &vec[..] {}
    |            ^^^^^^^^^^^^^^^
@@ -84,7 +84,7 @@ LL +     if let [a, b] = &vec[..] {}
    |
 
 error: dereferencing a slice pattern where every element takes a reference
-  --> $DIR/needless_borrowed_ref.rs:45:12
+  --> $DIR/needless_borrowed_ref.rs:46:12
    |
 LL |     if let &[ref a, ref b, ..] = slice {}
    |            ^^^^^^^^^^^^^^^^^^^
@@ -96,7 +96,7 @@ LL +     if let [a, b, ..] = slice {}
    |
 
 error: dereferencing a slice pattern where every element takes a reference
-  --> $DIR/needless_borrowed_ref.rs:46:12
+  --> $DIR/needless_borrowed_ref.rs:47:12
    |
 LL |     if let &[ref a, .., ref b] = slice {}
    |            ^^^^^^^^^^^^^^^^^^^
@@ -108,7 +108,7 @@ LL +     if let [a, .., b] = slice {}
    |
 
 error: dereferencing a slice pattern where every element takes a reference
-  --> $DIR/needless_borrowed_ref.rs:47:12
+  --> $DIR/needless_borrowed_ref.rs:48:12
    |
 LL |     if let &[.., ref a, ref b] = slice {}
    |            ^^^^^^^^^^^^^^^^^^^
@@ -120,7 +120,7 @@ LL +     if let [.., a, b] = slice {}
    |
 
 error: dereferencing a slice pattern where every element takes a reference
-  --> $DIR/needless_borrowed_ref.rs:49:12
+  --> $DIR/needless_borrowed_ref.rs:50:12
    |
 LL |     if let &[ref a, _] = slice {}
    |            ^^^^^^^^^^^
@@ -132,7 +132,7 @@ LL +     if let [a, _] = slice {}
    |
 
 error: dereferencing a tuple pattern where every element takes a reference
-  --> $DIR/needless_borrowed_ref.rs:51:12
+  --> $DIR/needless_borrowed_ref.rs:52:12
    |
 LL |     if let &(ref a, ref b, ref c) = &tuple {}
    |            ^^^^^^^^^^^^^^^^^^^^^^
@@ -144,7 +144,7 @@ LL +     if let (a, b, c) = &tuple {}
    |
 
 error: dereferencing a tuple pattern where every element takes a reference
-  --> $DIR/needless_borrowed_ref.rs:52:12
+  --> $DIR/needless_borrowed_ref.rs:53:12
    |
 LL |     if let &(ref a, _, ref c) = &tuple {}
    |            ^^^^^^^^^^^^^^^^^^
@@ -156,7 +156,7 @@ LL +     if let (a, _, c) = &tuple {}
    |
 
 error: dereferencing a tuple pattern where every element takes a reference
-  --> $DIR/needless_borrowed_ref.rs:53:12
+  --> $DIR/needless_borrowed_ref.rs:54:12
    |
 LL |     if let &(ref a, ..) = &tuple {}
    |            ^^^^^^^^^^^^
@@ -168,7 +168,7 @@ LL +     if let (a, ..) = &tuple {}
    |
 
 error: dereferencing a tuple pattern where every element takes a reference
-  --> $DIR/needless_borrowed_ref.rs:55:12
+  --> $DIR/needless_borrowed_ref.rs:56:12
    |
 LL |     if let &TupleStruct(ref a, ..) = &tuple_struct {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^
@@ -180,7 +180,7 @@ LL +     if let TupleStruct(a, ..) = &tuple_struct {}
    |
 
 error: dereferencing a struct pattern where every field's pattern takes a reference
-  --> $DIR/needless_borrowed_ref.rs:57:12
+  --> $DIR/needless_borrowed_ref.rs:58:12
    |
 LL |       if let &Struct {
    |  ____________^
@@ -199,7 +199,7 @@ LL ~         c: renamed,
    |
 
 error: dereferencing a struct pattern where every field's pattern takes a reference
-  --> $DIR/needless_borrowed_ref.rs:64:12
+  --> $DIR/needless_borrowed_ref.rs:65:12
    |
 LL |     if let &Struct { ref a, b: _, .. } = &s {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/needless_collect.fixed b/tests/ui/needless_collect.fixed
index b7e80af5015..a1a27ca5051 100644
--- a/tests/ui/needless_collect.fixed
+++ b/tests/ui/needless_collect.fixed
@@ -1,6 +1,6 @@
 //@run-rustfix
 
-#![allow(unused, clippy::suspicious_map, clippy::iter_count)]
+#![allow(unused, clippy::needless_if, clippy::suspicious_map, clippy::iter_count)]
 
 use std::collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, LinkedList};
 
diff --git a/tests/ui/needless_collect.rs b/tests/ui/needless_collect.rs
index 680b6fa5b55..237fd9540d6 100644
--- a/tests/ui/needless_collect.rs
+++ b/tests/ui/needless_collect.rs
@@ -1,6 +1,6 @@
 //@run-rustfix
 
-#![allow(unused, clippy::suspicious_map, clippy::iter_count)]
+#![allow(unused, clippy::needless_if, clippy::suspicious_map, clippy::iter_count)]
 
 use std::collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, LinkedList};
 
diff --git a/tests/ui/needless_collect_indirect.rs b/tests/ui/needless_collect_indirect.rs
index 55a7c2c21d9..d3d856c2c65 100644
--- a/tests/ui/needless_collect_indirect.rs
+++ b/tests/ui/needless_collect_indirect.rs
@@ -1,4 +1,5 @@
 #![allow(clippy::uninlined_format_args, clippy::useless_vec)]
+#![allow(clippy::needless_if, clippy::uninlined_format_args)]
 #![warn(clippy::needless_collect)]
 
 use std::collections::{BinaryHeap, HashMap, HashSet, LinkedList, VecDeque};
diff --git a/tests/ui/needless_if.fixed b/tests/ui/needless_if.fixed
new file mode 100644
index 00000000000..7587a397dc9
--- /dev/null
+++ b/tests/ui/needless_if.fixed
@@ -0,0 +1,37 @@
+//@run-rustfix
+//@aux-build:proc_macros.rs
+#![allow(
+    clippy::blocks_in_if_conditions,
+    clippy::if_same_then_else,
+    clippy::ifs_same_cond,
+    clippy::needless_else,
+    clippy::no_effect,
+    unused
+)]
+#![warn(clippy::needless_if)]
+
+extern crate proc_macros;
+use proc_macros::external;
+use proc_macros::with_span;
+
+fn main() {
+    // Lint
+    (true);
+    // Do not lint
+    if (true) {
+    } else {
+    }
+    // Do not lint if `else if` is present
+    if (true) {
+    } else if (true) {
+    }
+    // Ensure clippy does not bork this up, other cases should be added
+    {
+        return;
+    };
+    external! { if (true) {} }
+    with_span! {
+        span
+        if (true) {}
+    }
+}
diff --git a/tests/ui/needless_if.rs b/tests/ui/needless_if.rs
new file mode 100644
index 00000000000..3006995e09d
--- /dev/null
+++ b/tests/ui/needless_if.rs
@@ -0,0 +1,37 @@
+//@run-rustfix
+//@aux-build:proc_macros.rs
+#![allow(
+    clippy::blocks_in_if_conditions,
+    clippy::if_same_then_else,
+    clippy::ifs_same_cond,
+    clippy::needless_else,
+    clippy::no_effect,
+    unused
+)]
+#![warn(clippy::needless_if)]
+
+extern crate proc_macros;
+use proc_macros::external;
+use proc_macros::with_span;
+
+fn main() {
+    // Lint
+    if (true) {}
+    // Do not lint
+    if (true) {
+    } else {
+    }
+    // Do not lint if `else if` is present
+    if (true) {
+    } else if (true) {
+    }
+    // Ensure clippy does not bork this up, other cases should be added
+    if {
+        return;
+    } {}
+    external! { if (true) {} }
+    with_span! {
+        span
+        if (true) {}
+    }
+}
diff --git a/tests/ui/needless_if.stderr b/tests/ui/needless_if.stderr
new file mode 100644
index 00000000000..bbb2a035668
--- /dev/null
+++ b/tests/ui/needless_if.stderr
@@ -0,0 +1,25 @@
+error: this if branch is empty
+  --> $DIR/needless_if.rs:19:5
+   |
+LL |     if (true) {}
+   |     ^^^^^^^^^^^^ help: you can remove it: `(true);`
+   |
+   = note: `-D clippy::needless-if` implied by `-D warnings`
+
+error: this if branch is empty
+  --> $DIR/needless_if.rs:29:5
+   |
+LL | /     if {
+LL | |         return;
+LL | |     } {}
+   | |________^
+   |
+help: you can remove it
+   |
+LL ~     {
+LL +         return;
+LL +     };
+   |
+
+error: aborting due to 2 previous errors
+
diff --git a/tests/ui/nonminimal_bool.rs b/tests/ui/nonminimal_bool.rs
index 73e056c722e..e4aa0937b97 100644
--- a/tests/ui/nonminimal_bool.rs
+++ b/tests/ui/nonminimal_bool.rs
@@ -1,5 +1,5 @@
 #![feature(lint_reasons)]
-#![allow(unused, clippy::diverging_sub_expression)]
+#![allow(unused, clippy::diverging_sub_expression, clippy::needless_if)]
 #![warn(clippy::nonminimal_bool)]
 #![allow(clippy::useless_vec)]
 
diff --git a/tests/ui/nonminimal_bool_methods.fixed b/tests/ui/nonminimal_bool_methods.fixed
index 05802a2c865..294f2aa48f1 100644
--- a/tests/ui/nonminimal_bool_methods.fixed
+++ b/tests/ui/nonminimal_bool_methods.fixed
@@ -1,5 +1,5 @@
 //@run-rustfix
-#![allow(unused, clippy::diverging_sub_expression)]
+#![allow(unused, clippy::diverging_sub_expression, clippy::needless_if)]
 #![warn(clippy::nonminimal_bool)]
 
 fn methods_with_negation() {
diff --git a/tests/ui/nonminimal_bool_methods.rs b/tests/ui/nonminimal_bool_methods.rs
index cd5b576fa07..a165368ab17 100644
--- a/tests/ui/nonminimal_bool_methods.rs
+++ b/tests/ui/nonminimal_bool_methods.rs
@@ -1,5 +1,5 @@
 //@run-rustfix
-#![allow(unused, clippy::diverging_sub_expression)]
+#![allow(unused, clippy::diverging_sub_expression, clippy::needless_if)]
 #![warn(clippy::nonminimal_bool)]
 
 fn methods_with_negation() {
diff --git a/tests/ui/overflow_check_conditional.rs b/tests/ui/overflow_check_conditional.rs
index e1e30114081..14a6b98d07d 100644
--- a/tests/ui/overflow_check_conditional.rs
+++ b/tests/ui/overflow_check_conditional.rs
@@ -1,4 +1,5 @@
 #![warn(clippy::overflow_check_conditional)]
+#![allow(clippy::needless_if)]
 
 fn test(a: u32, b: u32, c: u32) {
     if a + b < a {}
diff --git a/tests/ui/overflow_check_conditional.stderr b/tests/ui/overflow_check_conditional.stderr
index 92d1d8ef911..3ec2298f828 100644
--- a/tests/ui/overflow_check_conditional.stderr
+++ b/tests/ui/overflow_check_conditional.stderr
@@ -1,5 +1,5 @@
 error: you are trying to use classic C overflow conditions that will fail in Rust
-  --> $DIR/overflow_check_conditional.rs:4:8
+  --> $DIR/overflow_check_conditional.rs:5:8
    |
 LL |     if a + b < a {}
    |        ^^^^^^^^^
@@ -7,43 +7,43 @@ LL |     if a + b < a {}
    = note: `-D clippy::overflow-check-conditional` implied by `-D warnings`
 
 error: you are trying to use classic C overflow conditions that will fail in Rust
-  --> $DIR/overflow_check_conditional.rs:5:8
+  --> $DIR/overflow_check_conditional.rs:6:8
    |
 LL |     if a > a + b {}
    |        ^^^^^^^^^
 
 error: you are trying to use classic C overflow conditions that will fail in Rust
-  --> $DIR/overflow_check_conditional.rs:6:8
+  --> $DIR/overflow_check_conditional.rs:7:8
    |
 LL |     if a + b < b {}
    |        ^^^^^^^^^
 
 error: you are trying to use classic C overflow conditions that will fail in Rust
-  --> $DIR/overflow_check_conditional.rs:7:8
+  --> $DIR/overflow_check_conditional.rs:8:8
    |
 LL |     if b > a + b {}
    |        ^^^^^^^^^
 
 error: you are trying to use classic C underflow conditions that will fail in Rust
-  --> $DIR/overflow_check_conditional.rs:8:8
+  --> $DIR/overflow_check_conditional.rs:9:8
    |
 LL |     if a - b > b {}
    |        ^^^^^^^^^
 
 error: you are trying to use classic C underflow conditions that will fail in Rust
-  --> $DIR/overflow_check_conditional.rs:9:8
+  --> $DIR/overflow_check_conditional.rs:10:8
    |
 LL |     if b < a - b {}
    |        ^^^^^^^^^
 
 error: you are trying to use classic C underflow conditions that will fail in Rust
-  --> $DIR/overflow_check_conditional.rs:10:8
+  --> $DIR/overflow_check_conditional.rs:11:8
    |
 LL |     if a - b > a {}
    |        ^^^^^^^^^
 
 error: you are trying to use classic C underflow conditions that will fail in Rust
-  --> $DIR/overflow_check_conditional.rs:11:8
+  --> $DIR/overflow_check_conditional.rs:12:8
    |
 LL |     if a < a - b {}
    |        ^^^^^^^^^
diff --git a/tests/ui/partialeq_to_none.fixed b/tests/ui/partialeq_to_none.fixed
index 2df87a26d6d..95e184b1de6 100644
--- a/tests/ui/partialeq_to_none.fixed
+++ b/tests/ui/partialeq_to_none.fixed
@@ -1,6 +1,6 @@
 //@run-rustfix
 #![warn(clippy::partialeq_to_none)]
-#![allow(clippy::eq_op)]
+#![allow(clippy::eq_op, clippy::needless_if)]
 
 struct Foobar;
 
diff --git a/tests/ui/partialeq_to_none.rs b/tests/ui/partialeq_to_none.rs
index df6233b9afd..4fa50dcc11b 100644
--- a/tests/ui/partialeq_to_none.rs
+++ b/tests/ui/partialeq_to_none.rs
@@ -1,6 +1,6 @@
 //@run-rustfix
 #![warn(clippy::partialeq_to_none)]
-#![allow(clippy::eq_op)]
+#![allow(clippy::eq_op, clippy::needless_if)]
 
 struct Foobar;
 
diff --git a/tests/ui/redundant_pattern_matching_drop_order.fixed b/tests/ui/redundant_pattern_matching_drop_order.fixed
index 481c9b263fb..d1134de5ab4 100644
--- a/tests/ui/redundant_pattern_matching_drop_order.fixed
+++ b/tests/ui/redundant_pattern_matching_drop_order.fixed
@@ -2,7 +2,12 @@
 
 // Issue #5746
 #![warn(clippy::redundant_pattern_matching)]
-#![allow(clippy::if_same_then_else, clippy::equatable_if_let, clippy::needless_else)]
+#![allow(
+    clippy::if_same_then_else,
+    clippy::equatable_if_let,
+    clippy::needless_if,
+    clippy::needless_else
+)]
 use std::task::Poll::{Pending, Ready};
 
 fn main() {
diff --git a/tests/ui/redundant_pattern_matching_drop_order.rs b/tests/ui/redundant_pattern_matching_drop_order.rs
index 86e46d41e65..d144086e791 100644
--- a/tests/ui/redundant_pattern_matching_drop_order.rs
+++ b/tests/ui/redundant_pattern_matching_drop_order.rs
@@ -2,7 +2,12 @@
 
 // Issue #5746
 #![warn(clippy::redundant_pattern_matching)]
-#![allow(clippy::if_same_then_else, clippy::equatable_if_let, clippy::needless_else)]
+#![allow(
+    clippy::if_same_then_else,
+    clippy::equatable_if_let,
+    clippy::needless_if,
+    clippy::needless_else
+)]
 use std::task::Poll::{Pending, Ready};
 
 fn main() {
diff --git a/tests/ui/redundant_pattern_matching_drop_order.stderr b/tests/ui/redundant_pattern_matching_drop_order.stderr
index 23f08103f35..e9ea3f2e688 100644
--- a/tests/ui/redundant_pattern_matching_drop_order.stderr
+++ b/tests/ui/redundant_pattern_matching_drop_order.stderr
@@ -1,5 +1,5 @@
 error: redundant pattern matching, consider using `is_ok()`
-  --> $DIR/redundant_pattern_matching_drop_order.rs:12:12
+  --> $DIR/redundant_pattern_matching_drop_order.rs:17:12
    |
 LL |     if let Ok(_) = m.lock() {}
    |     -------^^^^^----------- help: try this: `if m.lock().is_ok()`
@@ -9,7 +9,7 @@ LL |     if let Ok(_) = m.lock() {}
    = note: `-D clippy::redundant-pattern-matching` implied by `-D warnings`
 
 error: redundant pattern matching, consider using `is_err()`
-  --> $DIR/redundant_pattern_matching_drop_order.rs:13:12
+  --> $DIR/redundant_pattern_matching_drop_order.rs:18:12
    |
 LL |     if let Err(_) = Err::<(), _>(m.lock().unwrap().0) {}
    |     -------^^^^^^------------------------------------ help: try this: `if Err::<(), _>(m.lock().unwrap().0).is_err()`
@@ -18,7 +18,7 @@ LL |     if let Err(_) = Err::<(), _>(m.lock().unwrap().0) {}
    = note: add `#[allow(clippy::redundant_pattern_matching)]` if this is important
 
 error: redundant pattern matching, consider using `is_ok()`
-  --> $DIR/redundant_pattern_matching_drop_order.rs:16:16
+  --> $DIR/redundant_pattern_matching_drop_order.rs:21:16
    |
 LL |         if let Ok(_) = Ok::<_, std::sync::MutexGuard<()>>(()) {}
    |         -------^^^^^----------------------------------------- help: try this: `if Ok::<_, std::sync::MutexGuard<()>>(()).is_ok()`
@@ -27,7 +27,7 @@ LL |         if let Ok(_) = Ok::<_, std::sync::MutexGuard<()>>(()) {}
    = note: add `#[allow(clippy::redundant_pattern_matching)]` if this is important
 
 error: redundant pattern matching, consider using `is_ok()`
-  --> $DIR/redundant_pattern_matching_drop_order.rs:18:12
+  --> $DIR/redundant_pattern_matching_drop_order.rs:23:12
    |
 LL |     if let Ok(_) = Ok::<_, std::sync::MutexGuard<()>>(()) {
    |     -------^^^^^----------------------------------------- help: try this: `if Ok::<_, std::sync::MutexGuard<()>>(()).is_ok()`
@@ -36,31 +36,31 @@ LL |     if let Ok(_) = Ok::<_, std::sync::MutexGuard<()>>(()) {
    = note: add `#[allow(clippy::redundant_pattern_matching)]` if this is important
 
 error: redundant pattern matching, consider using `is_ok()`
-  --> $DIR/redundant_pattern_matching_drop_order.rs:21:12
+  --> $DIR/redundant_pattern_matching_drop_order.rs:26:12
    |
 LL |     if let Ok(_) = Ok::<_, std::sync::MutexGuard<()>>(()) {}
    |     -------^^^^^----------------------------------------- help: try this: `if Ok::<_, std::sync::MutexGuard<()>>(()).is_ok()`
 
 error: redundant pattern matching, consider using `is_err()`
-  --> $DIR/redundant_pattern_matching_drop_order.rs:22:12
+  --> $DIR/redundant_pattern_matching_drop_order.rs:27:12
    |
 LL |     if let Err(_) = Err::<std::sync::MutexGuard<()>, _>(()) {}
    |     -------^^^^^^------------------------------------------ help: try this: `if Err::<std::sync::MutexGuard<()>, _>(()).is_err()`
 
 error: redundant pattern matching, consider using `is_ok()`
-  --> $DIR/redundant_pattern_matching_drop_order.rs:24:12
+  --> $DIR/redundant_pattern_matching_drop_order.rs:29:12
    |
 LL |     if let Ok(_) = Ok::<_, ()>(String::new()) {}
    |     -------^^^^^----------------------------- help: try this: `if Ok::<_, ()>(String::new()).is_ok()`
 
 error: redundant pattern matching, consider using `is_err()`
-  --> $DIR/redundant_pattern_matching_drop_order.rs:25:12
+  --> $DIR/redundant_pattern_matching_drop_order.rs:30:12
    |
 LL |     if let Err(_) = Err::<(), _>((String::new(), ())) {}
    |     -------^^^^^^------------------------------------ help: try this: `if Err::<(), _>((String::new(), ())).is_err()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/redundant_pattern_matching_drop_order.rs:28:12
+  --> $DIR/redundant_pattern_matching_drop_order.rs:33:12
    |
 LL |     if let Some(_) = Some(m.lock()) {}
    |     -------^^^^^^^----------------- help: try this: `if Some(m.lock()).is_some()`
@@ -69,7 +69,7 @@ LL |     if let Some(_) = Some(m.lock()) {}
    = note: add `#[allow(clippy::redundant_pattern_matching)]` if this is important
 
 error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/redundant_pattern_matching_drop_order.rs:29:12
+  --> $DIR/redundant_pattern_matching_drop_order.rs:34:12
    |
 LL |     if let Some(_) = Some(m.lock().unwrap().0) {}
    |     -------^^^^^^^---------------------------- help: try this: `if Some(m.lock().unwrap().0).is_some()`
@@ -78,7 +78,7 @@ LL |     if let Some(_) = Some(m.lock().unwrap().0) {}
    = note: add `#[allow(clippy::redundant_pattern_matching)]` if this is important
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_drop_order.rs:32:16
+  --> $DIR/redundant_pattern_matching_drop_order.rs:37:16
    |
 LL |         if let None = None::<std::sync::MutexGuard<()>> {}
    |         -------^^^^------------------------------------ help: try this: `if None::<std::sync::MutexGuard<()>>.is_none()`
@@ -87,7 +87,7 @@ LL |         if let None = None::<std::sync::MutexGuard<()>> {}
    = note: add `#[allow(clippy::redundant_pattern_matching)]` if this is important
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_drop_order.rs:34:12
+  --> $DIR/redundant_pattern_matching_drop_order.rs:39:12
    |
 LL |     if let None = None::<std::sync::MutexGuard<()>> {
    |     -------^^^^------------------------------------ help: try this: `if None::<std::sync::MutexGuard<()>>.is_none()`
@@ -96,25 +96,25 @@ LL |     if let None = None::<std::sync::MutexGuard<()>> {
    = note: add `#[allow(clippy::redundant_pattern_matching)]` if this is important
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_drop_order.rs:38:12
+  --> $DIR/redundant_pattern_matching_drop_order.rs:43:12
    |
 LL |     if let None = None::<std::sync::MutexGuard<()>> {}
    |     -------^^^^------------------------------------ help: try this: `if None::<std::sync::MutexGuard<()>>.is_none()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/redundant_pattern_matching_drop_order.rs:40:12
+  --> $DIR/redundant_pattern_matching_drop_order.rs:45:12
    |
 LL |     if let Some(_) = Some(String::new()) {}
    |     -------^^^^^^^---------------------- help: try this: `if Some(String::new()).is_some()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/redundant_pattern_matching_drop_order.rs:41:12
+  --> $DIR/redundant_pattern_matching_drop_order.rs:46:12
    |
 LL |     if let Some(_) = Some((String::new(), ())) {}
    |     -------^^^^^^^---------------------------- help: try this: `if Some((String::new(), ())).is_some()`
 
 error: redundant pattern matching, consider using `is_ready()`
-  --> $DIR/redundant_pattern_matching_drop_order.rs:44:12
+  --> $DIR/redundant_pattern_matching_drop_order.rs:49:12
    |
 LL |     if let Ready(_) = Ready(m.lock()) {}
    |     -------^^^^^^^^------------------ help: try this: `if Ready(m.lock()).is_ready()`
@@ -123,7 +123,7 @@ LL |     if let Ready(_) = Ready(m.lock()) {}
    = note: add `#[allow(clippy::redundant_pattern_matching)]` if this is important
 
 error: redundant pattern matching, consider using `is_ready()`
-  --> $DIR/redundant_pattern_matching_drop_order.rs:45:12
+  --> $DIR/redundant_pattern_matching_drop_order.rs:50:12
    |
 LL |     if let Ready(_) = Ready(m.lock().unwrap().0) {}
    |     -------^^^^^^^^----------------------------- help: try this: `if Ready(m.lock().unwrap().0).is_ready()`
@@ -132,7 +132,7 @@ LL |     if let Ready(_) = Ready(m.lock().unwrap().0) {}
    = note: add `#[allow(clippy::redundant_pattern_matching)]` if this is important
 
 error: redundant pattern matching, consider using `is_pending()`
-  --> $DIR/redundant_pattern_matching_drop_order.rs:48:16
+  --> $DIR/redundant_pattern_matching_drop_order.rs:53:16
    |
 LL |         if let Pending = Pending::<std::sync::MutexGuard<()>> {}
    |         -------^^^^^^^--------------------------------------- help: try this: `if Pending::<std::sync::MutexGuard<()>>.is_pending()`
@@ -141,7 +141,7 @@ LL |         if let Pending = Pending::<std::sync::MutexGuard<()>> {}
    = note: add `#[allow(clippy::redundant_pattern_matching)]` if this is important
 
 error: redundant pattern matching, consider using `is_pending()`
-  --> $DIR/redundant_pattern_matching_drop_order.rs:50:12
+  --> $DIR/redundant_pattern_matching_drop_order.rs:55:12
    |
 LL |     if let Pending = Pending::<std::sync::MutexGuard<()>> {
    |     -------^^^^^^^--------------------------------------- help: try this: `if Pending::<std::sync::MutexGuard<()>>.is_pending()`
@@ -150,19 +150,19 @@ LL |     if let Pending = Pending::<std::sync::MutexGuard<()>> {
    = note: add `#[allow(clippy::redundant_pattern_matching)]` if this is important
 
 error: redundant pattern matching, consider using `is_pending()`
-  --> $DIR/redundant_pattern_matching_drop_order.rs:54:12
+  --> $DIR/redundant_pattern_matching_drop_order.rs:59:12
    |
 LL |     if let Pending = Pending::<std::sync::MutexGuard<()>> {}
    |     -------^^^^^^^--------------------------------------- help: try this: `if Pending::<std::sync::MutexGuard<()>>.is_pending()`
 
 error: redundant pattern matching, consider using `is_ready()`
-  --> $DIR/redundant_pattern_matching_drop_order.rs:56:12
+  --> $DIR/redundant_pattern_matching_drop_order.rs:61:12
    |
 LL |     if let Ready(_) = Ready(String::new()) {}
    |     -------^^^^^^^^----------------------- help: try this: `if Ready(String::new()).is_ready()`
 
 error: redundant pattern matching, consider using `is_ready()`
-  --> $DIR/redundant_pattern_matching_drop_order.rs:57:12
+  --> $DIR/redundant_pattern_matching_drop_order.rs:62:12
    |
 LL |     if let Ready(_) = Ready((String::new(), ())) {}
    |     -------^^^^^^^^----------------------------- help: try this: `if Ready((String::new(), ())).is_ready()`
diff --git a/tests/ui/redundant_pattern_matching_ipaddr.fixed b/tests/ui/redundant_pattern_matching_ipaddr.fixed
index a9faf12cd5a..75ed143446c 100644
--- a/tests/ui/redundant_pattern_matching_ipaddr.fixed
+++ b/tests/ui/redundant_pattern_matching_ipaddr.fixed
@@ -4,6 +4,7 @@
 #![allow(
     clippy::match_like_matches_macro,
     clippy::needless_bool,
+    clippy::needless_if,
     clippy::uninlined_format_args
 )]
 
diff --git a/tests/ui/redundant_pattern_matching_ipaddr.rs b/tests/ui/redundant_pattern_matching_ipaddr.rs
index 574671d03d1..9ac77409f79 100644
--- a/tests/ui/redundant_pattern_matching_ipaddr.rs
+++ b/tests/ui/redundant_pattern_matching_ipaddr.rs
@@ -4,6 +4,7 @@
 #![allow(
     clippy::match_like_matches_macro,
     clippy::needless_bool,
+    clippy::needless_if,
     clippy::uninlined_format_args
 )]
 
diff --git a/tests/ui/redundant_pattern_matching_ipaddr.stderr b/tests/ui/redundant_pattern_matching_ipaddr.stderr
index 536b589de54..6d1fb296463 100644
--- a/tests/ui/redundant_pattern_matching_ipaddr.stderr
+++ b/tests/ui/redundant_pattern_matching_ipaddr.stderr
@@ -1,5 +1,5 @@
 error: redundant pattern matching, consider using `is_ipv4()`
-  --> $DIR/redundant_pattern_matching_ipaddr.rs:17:12
+  --> $DIR/redundant_pattern_matching_ipaddr.rs:18:12
    |
 LL |     if let V4(_) = &ipaddr {}
    |     -------^^^^^---------- help: try this: `if ipaddr.is_ipv4()`
@@ -7,31 +7,31 @@ LL |     if let V4(_) = &ipaddr {}
    = note: `-D clippy::redundant-pattern-matching` implied by `-D warnings`
 
 error: redundant pattern matching, consider using `is_ipv4()`
-  --> $DIR/redundant_pattern_matching_ipaddr.rs:19:12
+  --> $DIR/redundant_pattern_matching_ipaddr.rs:20:12
    |
 LL |     if let V4(_) = V4(Ipv4Addr::LOCALHOST) {}
    |     -------^^^^^-------------------------- help: try this: `if V4(Ipv4Addr::LOCALHOST).is_ipv4()`
 
 error: redundant pattern matching, consider using `is_ipv6()`
-  --> $DIR/redundant_pattern_matching_ipaddr.rs:21:12
+  --> $DIR/redundant_pattern_matching_ipaddr.rs:22:12
    |
 LL |     if let V6(_) = V6(Ipv6Addr::LOCALHOST) {}
    |     -------^^^^^-------------------------- help: try this: `if V6(Ipv6Addr::LOCALHOST).is_ipv6()`
 
 error: redundant pattern matching, consider using `is_ipv4()`
-  --> $DIR/redundant_pattern_matching_ipaddr.rs:23:15
+  --> $DIR/redundant_pattern_matching_ipaddr.rs:24:15
    |
 LL |     while let V4(_) = V4(Ipv4Addr::LOCALHOST) {}
    |     ----------^^^^^-------------------------- help: try this: `while V4(Ipv4Addr::LOCALHOST).is_ipv4()`
 
 error: redundant pattern matching, consider using `is_ipv6()`
-  --> $DIR/redundant_pattern_matching_ipaddr.rs:25:15
+  --> $DIR/redundant_pattern_matching_ipaddr.rs:26:15
    |
 LL |     while let V6(_) = V6(Ipv6Addr::LOCALHOST) {}
    |     ----------^^^^^-------------------------- help: try this: `while V6(Ipv6Addr::LOCALHOST).is_ipv6()`
 
 error: redundant pattern matching, consider using `is_ipv4()`
-  --> $DIR/redundant_pattern_matching_ipaddr.rs:35:5
+  --> $DIR/redundant_pattern_matching_ipaddr.rs:36:5
    |
 LL | /     match V4(Ipv4Addr::LOCALHOST) {
 LL | |         V4(_) => true,
@@ -40,7 +40,7 @@ LL | |     };
    | |_____^ help: try this: `V4(Ipv4Addr::LOCALHOST).is_ipv4()`
 
 error: redundant pattern matching, consider using `is_ipv6()`
-  --> $DIR/redundant_pattern_matching_ipaddr.rs:40:5
+  --> $DIR/redundant_pattern_matching_ipaddr.rs:41:5
    |
 LL | /     match V4(Ipv4Addr::LOCALHOST) {
 LL | |         V4(_) => false,
@@ -49,7 +49,7 @@ LL | |     };
    | |_____^ help: try this: `V4(Ipv4Addr::LOCALHOST).is_ipv6()`
 
 error: redundant pattern matching, consider using `is_ipv6()`
-  --> $DIR/redundant_pattern_matching_ipaddr.rs:45:5
+  --> $DIR/redundant_pattern_matching_ipaddr.rs:46:5
    |
 LL | /     match V6(Ipv6Addr::LOCALHOST) {
 LL | |         V4(_) => false,
@@ -58,7 +58,7 @@ LL | |     };
    | |_____^ help: try this: `V6(Ipv6Addr::LOCALHOST).is_ipv6()`
 
 error: redundant pattern matching, consider using `is_ipv4()`
-  --> $DIR/redundant_pattern_matching_ipaddr.rs:50:5
+  --> $DIR/redundant_pattern_matching_ipaddr.rs:51:5
    |
 LL | /     match V6(Ipv6Addr::LOCALHOST) {
 LL | |         V4(_) => true,
@@ -67,49 +67,49 @@ LL | |     };
    | |_____^ help: try this: `V6(Ipv6Addr::LOCALHOST).is_ipv4()`
 
 error: redundant pattern matching, consider using `is_ipv4()`
-  --> $DIR/redundant_pattern_matching_ipaddr.rs:55:20
+  --> $DIR/redundant_pattern_matching_ipaddr.rs:56:20
    |
 LL |     let _ = if let V4(_) = V4(Ipv4Addr::LOCALHOST) {
    |             -------^^^^^-------------------------- help: try this: `if V4(Ipv4Addr::LOCALHOST).is_ipv4()`
 
 error: redundant pattern matching, consider using `is_ipv4()`
-  --> $DIR/redundant_pattern_matching_ipaddr.rs:63:20
+  --> $DIR/redundant_pattern_matching_ipaddr.rs:64:20
    |
 LL |     let _ = if let V4(_) = gen_ipaddr() {
    |             -------^^^^^--------------- help: try this: `if gen_ipaddr().is_ipv4()`
 
 error: redundant pattern matching, consider using `is_ipv6()`
-  --> $DIR/redundant_pattern_matching_ipaddr.rs:65:19
+  --> $DIR/redundant_pattern_matching_ipaddr.rs:66:19
    |
 LL |     } else if let V6(_) = gen_ipaddr() {
    |            -------^^^^^--------------- help: try this: `if gen_ipaddr().is_ipv6()`
 
 error: redundant pattern matching, consider using `is_ipv4()`
-  --> $DIR/redundant_pattern_matching_ipaddr.rs:77:12
+  --> $DIR/redundant_pattern_matching_ipaddr.rs:78:12
    |
 LL |     if let V4(_) = V4(Ipv4Addr::LOCALHOST) {}
    |     -------^^^^^-------------------------- help: try this: `if V4(Ipv4Addr::LOCALHOST).is_ipv4()`
 
 error: redundant pattern matching, consider using `is_ipv6()`
-  --> $DIR/redundant_pattern_matching_ipaddr.rs:79:12
+  --> $DIR/redundant_pattern_matching_ipaddr.rs:80:12
    |
 LL |     if let V6(_) = V6(Ipv6Addr::LOCALHOST) {}
    |     -------^^^^^-------------------------- help: try this: `if V6(Ipv6Addr::LOCALHOST).is_ipv6()`
 
 error: redundant pattern matching, consider using `is_ipv4()`
-  --> $DIR/redundant_pattern_matching_ipaddr.rs:81:15
+  --> $DIR/redundant_pattern_matching_ipaddr.rs:82:15
    |
 LL |     while let V4(_) = V4(Ipv4Addr::LOCALHOST) {}
    |     ----------^^^^^-------------------------- help: try this: `while V4(Ipv4Addr::LOCALHOST).is_ipv4()`
 
 error: redundant pattern matching, consider using `is_ipv6()`
-  --> $DIR/redundant_pattern_matching_ipaddr.rs:83:15
+  --> $DIR/redundant_pattern_matching_ipaddr.rs:84:15
    |
 LL |     while let V6(_) = V6(Ipv6Addr::LOCALHOST) {}
    |     ----------^^^^^-------------------------- help: try this: `while V6(Ipv6Addr::LOCALHOST).is_ipv6()`
 
 error: redundant pattern matching, consider using `is_ipv4()`
-  --> $DIR/redundant_pattern_matching_ipaddr.rs:85:5
+  --> $DIR/redundant_pattern_matching_ipaddr.rs:86:5
    |
 LL | /     match V4(Ipv4Addr::LOCALHOST) {
 LL | |         V4(_) => true,
@@ -118,7 +118,7 @@ LL | |     };
    | |_____^ help: try this: `V4(Ipv4Addr::LOCALHOST).is_ipv4()`
 
 error: redundant pattern matching, consider using `is_ipv6()`
-  --> $DIR/redundant_pattern_matching_ipaddr.rs:90:5
+  --> $DIR/redundant_pattern_matching_ipaddr.rs:91:5
    |
 LL | /     match V6(Ipv6Addr::LOCALHOST) {
 LL | |         V4(_) => false,
diff --git a/tests/ui/redundant_pattern_matching_option.fixed b/tests/ui/redundant_pattern_matching_option.fixed
index dae931541d4..a63ba5809e4 100644
--- a/tests/ui/redundant_pattern_matching_option.fixed
+++ b/tests/ui/redundant_pattern_matching_option.fixed
@@ -5,6 +5,7 @@
 #![allow(
     unused_must_use,
     clippy::needless_bool,
+    clippy::needless_if,
     clippy::match_like_matches_macro,
     clippy::equatable_if_let,
     clippy::if_same_then_else
diff --git a/tests/ui/redundant_pattern_matching_option.rs b/tests/ui/redundant_pattern_matching_option.rs
index 3f2fa3f53ce..631f9091672 100644
--- a/tests/ui/redundant_pattern_matching_option.rs
+++ b/tests/ui/redundant_pattern_matching_option.rs
@@ -5,6 +5,7 @@
 #![allow(
     unused_must_use,
     clippy::needless_bool,
+    clippy::needless_if,
     clippy::match_like_matches_macro,
     clippy::equatable_if_let,
     clippy::if_same_then_else
diff --git a/tests/ui/redundant_pattern_matching_option.stderr b/tests/ui/redundant_pattern_matching_option.stderr
index 93760ce97a8..717b603c496 100644
--- a/tests/ui/redundant_pattern_matching_option.stderr
+++ b/tests/ui/redundant_pattern_matching_option.stderr
@@ -1,5 +1,5 @@
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:14:12
+  --> $DIR/redundant_pattern_matching_option.rs:15:12
    |
 LL |     if let None = None::<()> {}
    |     -------^^^^------------- help: try this: `if None::<()>.is_none()`
@@ -7,43 +7,43 @@ LL |     if let None = 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
+  --> $DIR/redundant_pattern_matching_option.rs:17: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
+  --> $DIR/redundant_pattern_matching_option.rs:19: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
+  --> $DIR/redundant_pattern_matching_option.rs:25: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
+  --> $DIR/redundant_pattern_matching_option.rs:27: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
+  --> $DIR/redundant_pattern_matching_option.rs:29: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
+  --> $DIR/redundant_pattern_matching_option.rs:32: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
+  --> $DIR/redundant_pattern_matching_option.rs:40:5
    |
 LL | /     match Some(42) {
 LL | |         Some(_) => true,
@@ -52,7 +52,7 @@ LL | |     };
    | |_____^ help: try this: `Some(42).is_some()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:44:5
+  --> $DIR/redundant_pattern_matching_option.rs:45:5
    |
 LL | /     match None::<()> {
 LL | |         Some(_) => false,
@@ -61,7 +61,7 @@ LL | |     };
    | |_____^ help: try this: `None::<()>.is_none()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:49:13
+  --> $DIR/redundant_pattern_matching_option.rs:50:13
    |
 LL |       let _ = match None::<()> {
    |  _____________^
@@ -71,55 +71,55 @@ LL | |     };
    | |_____^ help: try this: `None::<()>.is_none()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/redundant_pattern_matching_option.rs:55:20
+  --> $DIR/redundant_pattern_matching_option.rs:56:20
    |
 LL |     let _ = 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:61:20
+  --> $DIR/redundant_pattern_matching_option.rs:62: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:63:19
+  --> $DIR/redundant_pattern_matching_option.rs:64: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:69:12
+  --> $DIR/redundant_pattern_matching_option.rs:70:12
    |
 LL |     if let Some(..) = gen_opt() {}
    |     -------^^^^^^^^------------ help: try this: `if gen_opt().is_some()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/redundant_pattern_matching_option.rs:84:12
+  --> $DIR/redundant_pattern_matching_option.rs:85: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:86:12
+  --> $DIR/redundant_pattern_matching_option.rs:87: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:88:15
+  --> $DIR/redundant_pattern_matching_option.rs:89: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:90:15
+  --> $DIR/redundant_pattern_matching_option.rs:91: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:92:5
+  --> $DIR/redundant_pattern_matching_option.rs:93:5
    |
 LL | /     match Some(42) {
 LL | |         Some(_) => true,
@@ -128,7 +128,7 @@ LL | |     };
    | |_____^ help: try this: `Some(42).is_some()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:97:5
+  --> $DIR/redundant_pattern_matching_option.rs:98:5
    |
 LL | /     match None::<()> {
 LL | |         Some(_) => false,
@@ -137,19 +137,19 @@ LL | |     };
    | |_____^ help: try this: `None::<()>.is_none()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:105:12
+  --> $DIR/redundant_pattern_matching_option.rs:106:12
    |
 LL |     if let None = *(&None::<()>) {}
    |     -------^^^^----------------- help: try this: `if (&None::<()>).is_none()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:106:12
+  --> $DIR/redundant_pattern_matching_option.rs:107: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:112:5
+  --> $DIR/redundant_pattern_matching_option.rs:113:5
    |
 LL | /     match x {
 LL | |         Some(_) => true,
@@ -158,7 +158,7 @@ LL | |     };
    | |_____^ help: try this: `x.is_some()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:117:5
+  --> $DIR/redundant_pattern_matching_option.rs:118:5
    |
 LL | /     match x {
 LL | |         None => true,
@@ -167,7 +167,7 @@ LL | |     };
    | |_____^ help: try this: `x.is_none()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:122:5
+  --> $DIR/redundant_pattern_matching_option.rs:123:5
    |
 LL | /     match x {
 LL | |         Some(_) => false,
@@ -176,7 +176,7 @@ LL | |     };
    | |_____^ help: try this: `x.is_none()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/redundant_pattern_matching_option.rs:127:5
+  --> $DIR/redundant_pattern_matching_option.rs:128:5
    |
 LL | /     match x {
 LL | |         None => false,
@@ -185,13 +185,13 @@ LL | |     };
    | |_____^ help: try this: `x.is_some()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/redundant_pattern_matching_option.rs:142:13
+  --> $DIR/redundant_pattern_matching_option.rs:143:13
    |
 LL |     let _ = matches!(x, Some(_));
    |             ^^^^^^^^^^^^^^^^^^^^ help: try this: `x.is_some()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:144:13
+  --> $DIR/redundant_pattern_matching_option.rs:145:13
    |
 LL |     let _ = matches!(x, None);
    |             ^^^^^^^^^^^^^^^^^ help: try this: `x.is_none()`
diff --git a/tests/ui/redundant_pattern_matching_poll.fixed b/tests/ui/redundant_pattern_matching_poll.fixed
index bf3e692202c..f739deaf58e 100644
--- a/tests/ui/redundant_pattern_matching_poll.fixed
+++ b/tests/ui/redundant_pattern_matching_poll.fixed
@@ -5,6 +5,7 @@
 #![allow(
     unused_must_use,
     clippy::needless_bool,
+    clippy::needless_if,
     clippy::match_like_matches_macro,
     clippy::equatable_if_let,
     clippy::if_same_then_else
diff --git a/tests/ui/redundant_pattern_matching_poll.rs b/tests/ui/redundant_pattern_matching_poll.rs
index 892a21d9d29..88dde02b38b 100644
--- a/tests/ui/redundant_pattern_matching_poll.rs
+++ b/tests/ui/redundant_pattern_matching_poll.rs
@@ -5,6 +5,7 @@
 #![allow(
     unused_must_use,
     clippy::needless_bool,
+    clippy::needless_if,
     clippy::match_like_matches_macro,
     clippy::equatable_if_let,
     clippy::if_same_then_else
diff --git a/tests/ui/redundant_pattern_matching_poll.stderr b/tests/ui/redundant_pattern_matching_poll.stderr
index 1b480f3157f..b89fde35fcf 100644
--- a/tests/ui/redundant_pattern_matching_poll.stderr
+++ b/tests/ui/redundant_pattern_matching_poll.stderr
@@ -1,5 +1,5 @@
 error: redundant pattern matching, consider using `is_pending()`
-  --> $DIR/redundant_pattern_matching_poll.rs:16:12
+  --> $DIR/redundant_pattern_matching_poll.rs:17:12
    |
 LL |     if let Pending = Pending::<()> {}
    |     -------^^^^^^^---------------- help: try this: `if Pending::<()>.is_pending()`
@@ -7,37 +7,37 @@ LL |     if let Pending = Pending::<()> {}
    = note: `-D clippy::redundant-pattern-matching` implied by `-D warnings`
 
 error: redundant pattern matching, consider using `is_ready()`
-  --> $DIR/redundant_pattern_matching_poll.rs:18:12
+  --> $DIR/redundant_pattern_matching_poll.rs:19:12
    |
 LL |     if let Ready(_) = Ready(42) {}
    |     -------^^^^^^^^------------ help: try this: `if Ready(42).is_ready()`
 
 error: redundant pattern matching, consider using `is_ready()`
-  --> $DIR/redundant_pattern_matching_poll.rs:20:12
+  --> $DIR/redundant_pattern_matching_poll.rs:21:12
    |
 LL |     if let Ready(_) = Ready(42) {
    |     -------^^^^^^^^------------ help: try this: `if Ready(42).is_ready()`
 
 error: redundant pattern matching, consider using `is_ready()`
-  --> $DIR/redundant_pattern_matching_poll.rs:26:15
+  --> $DIR/redundant_pattern_matching_poll.rs:27:15
    |
 LL |     while let Ready(_) = Ready(42) {}
    |     ----------^^^^^^^^------------ help: try this: `while Ready(42).is_ready()`
 
 error: redundant pattern matching, consider using `is_pending()`
-  --> $DIR/redundant_pattern_matching_poll.rs:28:15
+  --> $DIR/redundant_pattern_matching_poll.rs:29:15
    |
 LL |     while let Pending = Ready(42) {}
    |     ----------^^^^^^^------------ help: try this: `while Ready(42).is_pending()`
 
 error: redundant pattern matching, consider using `is_pending()`
-  --> $DIR/redundant_pattern_matching_poll.rs:30:15
+  --> $DIR/redundant_pattern_matching_poll.rs:31:15
    |
 LL |     while let Pending = Pending::<()> {}
    |     ----------^^^^^^^---------------- help: try this: `while Pending::<()>.is_pending()`
 
 error: redundant pattern matching, consider using `is_ready()`
-  --> $DIR/redundant_pattern_matching_poll.rs:36:5
+  --> $DIR/redundant_pattern_matching_poll.rs:37:5
    |
 LL | /     match Ready(42) {
 LL | |         Ready(_) => true,
@@ -46,7 +46,7 @@ LL | |     };
    | |_____^ help: try this: `Ready(42).is_ready()`
 
 error: redundant pattern matching, consider using `is_pending()`
-  --> $DIR/redundant_pattern_matching_poll.rs:41:5
+  --> $DIR/redundant_pattern_matching_poll.rs:42:5
    |
 LL | /     match Pending::<()> {
 LL | |         Ready(_) => false,
@@ -55,7 +55,7 @@ LL | |     };
    | |_____^ help: try this: `Pending::<()>.is_pending()`
 
 error: redundant pattern matching, consider using `is_pending()`
-  --> $DIR/redundant_pattern_matching_poll.rs:46:13
+  --> $DIR/redundant_pattern_matching_poll.rs:47:13
    |
 LL |       let _ = match Pending::<()> {
    |  _____________^
@@ -65,49 +65,49 @@ LL | |     };
    | |_____^ help: try this: `Pending::<()>.is_pending()`
 
 error: redundant pattern matching, consider using `is_ready()`
-  --> $DIR/redundant_pattern_matching_poll.rs:52:20
+  --> $DIR/redundant_pattern_matching_poll.rs:53:20
    |
 LL |     let _ = if let Ready(_) = poll { true } else { false };
    |             -------^^^^^^^^------- help: try this: `if poll.is_ready()`
 
 error: redundant pattern matching, consider using `is_ready()`
-  --> $DIR/redundant_pattern_matching_poll.rs:56:20
+  --> $DIR/redundant_pattern_matching_poll.rs:57:20
    |
 LL |     let _ = if let Ready(_) = gen_poll() {
    |             -------^^^^^^^^------------- help: try this: `if gen_poll().is_ready()`
 
 error: redundant pattern matching, consider using `is_pending()`
-  --> $DIR/redundant_pattern_matching_poll.rs:58:19
+  --> $DIR/redundant_pattern_matching_poll.rs:59:19
    |
 LL |     } else if let Pending = gen_poll() {
    |            -------^^^^^^^------------- help: try this: `if gen_poll().is_pending()`
 
 error: redundant pattern matching, consider using `is_ready()`
-  --> $DIR/redundant_pattern_matching_poll.rs:74:12
+  --> $DIR/redundant_pattern_matching_poll.rs:75:12
    |
 LL |     if let Ready(_) = Ready(42) {}
    |     -------^^^^^^^^------------ help: try this: `if Ready(42).is_ready()`
 
 error: redundant pattern matching, consider using `is_pending()`
-  --> $DIR/redundant_pattern_matching_poll.rs:76:12
+  --> $DIR/redundant_pattern_matching_poll.rs:77:12
    |
 LL |     if let Pending = Pending::<()> {}
    |     -------^^^^^^^---------------- help: try this: `if Pending::<()>.is_pending()`
 
 error: redundant pattern matching, consider using `is_ready()`
-  --> $DIR/redundant_pattern_matching_poll.rs:78:15
+  --> $DIR/redundant_pattern_matching_poll.rs:79:15
    |
 LL |     while let Ready(_) = Ready(42) {}
    |     ----------^^^^^^^^------------ help: try this: `while Ready(42).is_ready()`
 
 error: redundant pattern matching, consider using `is_pending()`
-  --> $DIR/redundant_pattern_matching_poll.rs:80:15
+  --> $DIR/redundant_pattern_matching_poll.rs:81:15
    |
 LL |     while let Pending = Pending::<()> {}
    |     ----------^^^^^^^---------------- help: try this: `while Pending::<()>.is_pending()`
 
 error: redundant pattern matching, consider using `is_ready()`
-  --> $DIR/redundant_pattern_matching_poll.rs:82:5
+  --> $DIR/redundant_pattern_matching_poll.rs:83:5
    |
 LL | /     match Ready(42) {
 LL | |         Ready(_) => true,
@@ -116,7 +116,7 @@ LL | |     };
    | |_____^ help: try this: `Ready(42).is_ready()`
 
 error: redundant pattern matching, consider using `is_pending()`
-  --> $DIR/redundant_pattern_matching_poll.rs:87:5
+  --> $DIR/redundant_pattern_matching_poll.rs:88:5
    |
 LL | /     match Pending::<()> {
 LL | |         Ready(_) => false,
diff --git a/tests/ui/redundant_pattern_matching_result.fixed b/tests/ui/redundant_pattern_matching_result.fixed
index d77a2af7616..343e0d04340 100644
--- a/tests/ui/redundant_pattern_matching_result.fixed
+++ b/tests/ui/redundant_pattern_matching_result.fixed
@@ -6,6 +6,7 @@
     clippy::if_same_then_else,
     clippy::match_like_matches_macro,
     clippy::needless_bool,
+    clippy::needless_if,
     clippy::uninlined_format_args,
     clippy::unnecessary_wraps
 )]
diff --git a/tests/ui/redundant_pattern_matching_result.rs b/tests/ui/redundant_pattern_matching_result.rs
index aa884ac6bb1..4d64eafe590 100644
--- a/tests/ui/redundant_pattern_matching_result.rs
+++ b/tests/ui/redundant_pattern_matching_result.rs
@@ -6,6 +6,7 @@
     clippy::if_same_then_else,
     clippy::match_like_matches_macro,
     clippy::needless_bool,
+    clippy::needless_if,
     clippy::uninlined_format_args,
     clippy::unnecessary_wraps
 )]
diff --git a/tests/ui/redundant_pattern_matching_result.stderr b/tests/ui/redundant_pattern_matching_result.stderr
index b462f7f41b9..f6ce666bb4f 100644
--- a/tests/ui/redundant_pattern_matching_result.stderr
+++ b/tests/ui/redundant_pattern_matching_result.stderr
@@ -1,5 +1,5 @@
 error: redundant pattern matching, consider using `is_ok()`
-  --> $DIR/redundant_pattern_matching_result.rs:15:12
+  --> $DIR/redundant_pattern_matching_result.rs:16:12
    |
 LL |     if let Ok(_) = &result {}
    |     -------^^^^^---------- help: try this: `if result.is_ok()`
@@ -7,31 +7,31 @@ LL |     if let Ok(_) = &result {}
    = note: `-D clippy::redundant-pattern-matching` implied by `-D warnings`
 
 error: redundant pattern matching, consider using `is_ok()`
-  --> $DIR/redundant_pattern_matching_result.rs:17:12
+  --> $DIR/redundant_pattern_matching_result.rs:18: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_result.rs:19:12
+  --> $DIR/redundant_pattern_matching_result.rs:20: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_result.rs:21:15
+  --> $DIR/redundant_pattern_matching_result.rs:22: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_result.rs:23:15
+  --> $DIR/redundant_pattern_matching_result.rs:24: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_result.rs:33:5
+  --> $DIR/redundant_pattern_matching_result.rs:34:5
    |
 LL | /     match Ok::<i32, i32>(42) {
 LL | |         Ok(_) => true,
@@ -40,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_result.rs:38:5
+  --> $DIR/redundant_pattern_matching_result.rs:39:5
    |
 LL | /     match Ok::<i32, i32>(42) {
 LL | |         Ok(_) => false,
@@ -49,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_result.rs:43:5
+  --> $DIR/redundant_pattern_matching_result.rs:44:5
    |
 LL | /     match Err::<i32, i32>(42) {
 LL | |         Ok(_) => false,
@@ -58,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_result.rs:48:5
+  --> $DIR/redundant_pattern_matching_result.rs:49:5
    |
 LL | /     match Err::<i32, i32>(42) {
 LL | |         Ok(_) => true,
@@ -67,73 +67,73 @@ LL | |     };
    | |_____^ help: try this: `Err::<i32, i32>(42).is_ok()`
 
 error: redundant pattern matching, consider using `is_ok()`
-  --> $DIR/redundant_pattern_matching_result.rs:53:20
+  --> $DIR/redundant_pattern_matching_result.rs:54: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_ok()`
-  --> $DIR/redundant_pattern_matching_result.rs:61:20
+  --> $DIR/redundant_pattern_matching_result.rs:62:20
    |
 LL |     let _ = if let Ok(_) = gen_res() {
    |             -------^^^^^------------ help: try this: `if gen_res().is_ok()`
 
 error: redundant pattern matching, consider using `is_err()`
-  --> $DIR/redundant_pattern_matching_result.rs:63:19
+  --> $DIR/redundant_pattern_matching_result.rs:64: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_result.rs:86:19
+  --> $DIR/redundant_pattern_matching_result.rs:87: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_result.rs:87:16
+  --> $DIR/redundant_pattern_matching_result.rs:88: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_result.rs:93:12
+  --> $DIR/redundant_pattern_matching_result.rs:94: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_result.rs:94:15
+  --> $DIR/redundant_pattern_matching_result.rs:95:15
    |
 LL |     while let Some(_) = m!() {}
    |     ----------^^^^^^^------- help: try this: `while m!().is_some()`
 
 error: redundant pattern matching, consider using `is_ok()`
-  --> $DIR/redundant_pattern_matching_result.rs:112:12
+  --> $DIR/redundant_pattern_matching_result.rs:113: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_result.rs:114:12
+  --> $DIR/redundant_pattern_matching_result.rs:115: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_result.rs:116:15
+  --> $DIR/redundant_pattern_matching_result.rs:117: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_result.rs:118:15
+  --> $DIR/redundant_pattern_matching_result.rs:119: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_result.rs:120:5
+  --> $DIR/redundant_pattern_matching_result.rs:121:5
    |
 LL | /     match Ok::<i32, i32>(42) {
 LL | |         Ok(_) => true,
@@ -142,7 +142,7 @@ LL | |     };
    | |_____^ help: try this: `Ok::<i32, i32>(42).is_ok()`
 
 error: redundant pattern matching, consider using `is_err()`
-  --> $DIR/redundant_pattern_matching_result.rs:125:5
+  --> $DIR/redundant_pattern_matching_result.rs:126:5
    |
 LL | /     match Err::<i32, i32>(42) {
 LL | |         Ok(_) => false,
@@ -151,7 +151,7 @@ LL | |     };
    | |_____^ help: try this: `Err::<i32, i32>(42).is_err()`
 
 error: redundant pattern matching, consider using `is_ok()`
-  --> $DIR/redundant_pattern_matching_result.rs:135:5
+  --> $DIR/redundant_pattern_matching_result.rs:136:5
    |
 LL | /     match x {
 LL | |         Ok(_) => true,
@@ -160,7 +160,7 @@ LL | |     };
    | |_____^ help: try this: `x.is_ok()`
 
 error: redundant pattern matching, consider using `is_err()`
-  --> $DIR/redundant_pattern_matching_result.rs:140:5
+  --> $DIR/redundant_pattern_matching_result.rs:141:5
    |
 LL | /     match x {
 LL | |         Ok(_) => false,
@@ -169,7 +169,7 @@ LL | |     };
    | |_____^ help: try this: `x.is_err()`
 
 error: redundant pattern matching, consider using `is_err()`
-  --> $DIR/redundant_pattern_matching_result.rs:145:5
+  --> $DIR/redundant_pattern_matching_result.rs:146:5
    |
 LL | /     match x {
 LL | |         Err(_) => true,
@@ -178,7 +178,7 @@ LL | |     };
    | |_____^ help: try this: `x.is_err()`
 
 error: redundant pattern matching, consider using `is_ok()`
-  --> $DIR/redundant_pattern_matching_result.rs:150:5
+  --> $DIR/redundant_pattern_matching_result.rs:151:5
    |
 LL | /     match x {
 LL | |         Err(_) => false,
@@ -187,13 +187,13 @@ LL | |     };
    | |_____^ help: try this: `x.is_ok()`
 
 error: redundant pattern matching, consider using `is_ok()`
-  --> $DIR/redundant_pattern_matching_result.rs:171:13
+  --> $DIR/redundant_pattern_matching_result.rs:172:13
    |
 LL |     let _ = matches!(x, Ok(_));
    |             ^^^^^^^^^^^^^^^^^^ help: try this: `x.is_ok()`
 
 error: redundant pattern matching, consider using `is_err()`
-  --> $DIR/redundant_pattern_matching_result.rs:173:13
+  --> $DIR/redundant_pattern_matching_result.rs:174:13
    |
 LL |     let _ = matches!(x, Err(_));
    |             ^^^^^^^^^^^^^^^^^^^ help: try this: `x.is_err()`
diff --git a/tests/ui/shadow.rs b/tests/ui/shadow.rs
index 2c0fc3e3fd8..c2895718a1a 100644
--- a/tests/ui/shadow.rs
+++ b/tests/ui/shadow.rs
@@ -1,7 +1,7 @@
 //@aux-build:proc_macro_derive.rs
 
 #![warn(clippy::shadow_same, clippy::shadow_reuse, clippy::shadow_unrelated)]
-#![allow(clippy::let_unit_value)]
+#![allow(clippy::let_unit_value, clippy::needless_if)]
 
 extern crate proc_macro_derive;
 
diff --git a/tests/ui/single_match.fixed b/tests/ui/single_match.fixed
index 77a2cf3b991..a54e658bf23 100644
--- a/tests/ui/single_match.fixed
+++ b/tests/ui/single_match.fixed
@@ -1,6 +1,11 @@
 //@run-rustfix
 #![warn(clippy::single_match)]
-#![allow(unused, clippy::uninlined_format_args, clippy::redundant_pattern_matching)]
+#![allow(
+    unused,
+    clippy::uninlined_format_args,
+    clippy::needless_if,
+    clippy::redundant_pattern_matching
+)]
 fn dummy() {}
 
 fn single_match() {
diff --git a/tests/ui/single_match.rs b/tests/ui/single_match.rs
index 8d0ab5b99ad..f296c6c4d1c 100644
--- a/tests/ui/single_match.rs
+++ b/tests/ui/single_match.rs
@@ -1,6 +1,11 @@
 //@run-rustfix
 #![warn(clippy::single_match)]
-#![allow(unused, clippy::uninlined_format_args, clippy::redundant_pattern_matching)]
+#![allow(
+    unused,
+    clippy::uninlined_format_args,
+    clippy::needless_if,
+    clippy::redundant_pattern_matching
+)]
 fn dummy() {}
 
 fn single_match() {
diff --git a/tests/ui/single_match.stderr b/tests/ui/single_match.stderr
index dad66e2ab2e..ef901513240 100644
--- a/tests/ui/single_match.stderr
+++ b/tests/ui/single_match.stderr
@@ -1,5 +1,5 @@
 error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
-  --> $DIR/single_match.rs:9:5
+  --> $DIR/single_match.rs:14:5
    |
 LL | /     match x {
 LL | |         Some(y) => {
@@ -18,7 +18,7 @@ LL ~     };
    |
 
 error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
-  --> $DIR/single_match.rs:17:5
+  --> $DIR/single_match.rs:22:5
    |
 LL | /     match x {
 LL | |         // Note the missing block braces.
@@ -30,7 +30,7 @@ LL | |     }
    | |_____^ help: try this: `if let Some(y) = x { println!("{:?}", y) }`
 
 error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
-  --> $DIR/single_match.rs:26:5
+  --> $DIR/single_match.rs:31:5
    |
 LL | /     match z {
 LL | |         (2..=3, 7..=9) => dummy(),
@@ -39,7 +39,7 @@ LL | |     };
    | |_____^ help: try this: `if let (2..=3, 7..=9) = z { dummy() }`
 
 error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
-  --> $DIR/single_match.rs:55:5
+  --> $DIR/single_match.rs:60:5
    |
 LL | /     match x {
 LL | |         Some(y) => dummy(),
@@ -48,7 +48,7 @@ LL | |     };
    | |_____^ help: try this: `if let Some(y) = x { dummy() }`
 
 error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
-  --> $DIR/single_match.rs:60:5
+  --> $DIR/single_match.rs:65:5
    |
 LL | /     match y {
 LL | |         Ok(y) => dummy(),
@@ -57,7 +57,7 @@ LL | |     };
    | |_____^ help: try this: `if let Ok(y) = y { dummy() }`
 
 error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
-  --> $DIR/single_match.rs:67:5
+  --> $DIR/single_match.rs:72:5
    |
 LL | /     match c {
 LL | |         Cow::Borrowed(..) => dummy(),
@@ -66,7 +66,7 @@ LL | |     };
    | |_____^ help: try this: `if let Cow::Borrowed(..) = c { dummy() }`
 
 error: you seem to be trying to use `match` for an equality check. Consider using `if`
-  --> $DIR/single_match.rs:88:5
+  --> $DIR/single_match.rs:93:5
    |
 LL | /     match x {
 LL | |         "test" => println!(),
@@ -75,7 +75,7 @@ LL | |     }
    | |_____^ help: try this: `if x == "test" { println!() }`
 
 error: you seem to be trying to use `match` for an equality check. Consider using `if`
-  --> $DIR/single_match.rs:101:5
+  --> $DIR/single_match.rs:106:5
    |
 LL | /     match x {
 LL | |         Foo::A => println!(),
@@ -84,7 +84,7 @@ LL | |     }
    | |_____^ help: try this: `if x == Foo::A { println!() }`
 
 error: you seem to be trying to use `match` for an equality check. Consider using `if`
-  --> $DIR/single_match.rs:107:5
+  --> $DIR/single_match.rs:112:5
    |
 LL | /     match x {
 LL | |         FOO_C => println!(),
@@ -93,7 +93,7 @@ LL | |     }
    | |_____^ help: try this: `if x == FOO_C { println!() }`
 
 error: you seem to be trying to use `match` for an equality check. Consider using `if`
-  --> $DIR/single_match.rs:112:5
+  --> $DIR/single_match.rs:117:5
    |
 LL | /     match &&x {
 LL | |         Foo::A => println!(),
@@ -102,7 +102,7 @@ LL | |     }
    | |_____^ help: try this: `if x == Foo::A { println!() }`
 
 error: you seem to be trying to use `match` for an equality check. Consider using `if`
-  --> $DIR/single_match.rs:118:5
+  --> $DIR/single_match.rs:123:5
    |
 LL | /     match &x {
 LL | |         Foo::A => println!(),
@@ -111,7 +111,7 @@ LL | |     }
    | |_____^ help: try this: `if x == &Foo::A { println!() }`
 
 error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
-  --> $DIR/single_match.rs:135:5
+  --> $DIR/single_match.rs:140:5
    |
 LL | /     match x {
 LL | |         Bar::A => println!(),
@@ -120,7 +120,7 @@ LL | |     }
    | |_____^ help: try this: `if let Bar::A = x { println!() }`
 
 error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
-  --> $DIR/single_match.rs:143:5
+  --> $DIR/single_match.rs:148:5
    |
 LL | /     match x {
 LL | |         None => println!(),
@@ -129,7 +129,7 @@ LL | |     };
    | |_____^ help: try this: `if let None = x { println!() }`
 
 error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
-  --> $DIR/single_match.rs:165:5
+  --> $DIR/single_match.rs:170:5
    |
 LL | /     match x {
 LL | |         (Some(_), _) => {},
@@ -138,7 +138,7 @@ LL | |     }
    | |_____^ help: try this: `if let (Some(_), _) = x {}`
 
 error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
-  --> $DIR/single_match.rs:171:5
+  --> $DIR/single_match.rs:176:5
    |
 LL | /     match x {
 LL | |         (Some(E::V), _) => todo!(),
@@ -147,7 +147,7 @@ LL | |     }
    | |_____^ help: try this: `if let (Some(E::V), _) = x { todo!() }`
 
 error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
-  --> $DIR/single_match.rs:177:5
+  --> $DIR/single_match.rs:182:5
    |
 LL | /     match (Some(42), Some(E::V), Some(42)) {
 LL | |         (.., Some(E::V), _) => {},
@@ -156,7 +156,7 @@ LL | |     }
    | |_____^ help: try this: `if let (.., Some(E::V), _) = (Some(42), Some(E::V), Some(42)) {}`
 
 error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
-  --> $DIR/single_match.rs:249:5
+  --> $DIR/single_match.rs:254:5
    |
 LL | /     match bar {
 LL | |         Some(v) => unsafe {
@@ -176,7 +176,7 @@ LL +     } }
    |
 
 error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
-  --> $DIR/single_match.rs:257:5
+  --> $DIR/single_match.rs:262:5
    |
 LL | /     match bar {
 LL | |         #[rustfmt::skip]
diff --git a/tests/ui/starts_ends_with.fixed b/tests/ui/starts_ends_with.fixed
index 29d56f852ed..b7237069dc5 100644
--- a/tests/ui/starts_ends_with.fixed
+++ b/tests/ui/starts_ends_with.fixed
@@ -1,5 +1,5 @@
 //@run-rustfix
-#![allow(dead_code, unused_must_use)]
+#![allow(clippy::needless_if, dead_code, unused_must_use)]
 
 fn main() {}
 
diff --git a/tests/ui/starts_ends_with.rs b/tests/ui/starts_ends_with.rs
index 56bbe2574d4..658312e87e4 100644
--- a/tests/ui/starts_ends_with.rs
+++ b/tests/ui/starts_ends_with.rs
@@ -1,5 +1,5 @@
 //@run-rustfix
-#![allow(dead_code, unused_must_use)]
+#![allow(clippy::needless_if, dead_code, unused_must_use)]
 
 fn main() {}
 
diff --git a/tests/ui/suspicious_else_formatting.rs b/tests/ui/suspicious_else_formatting.rs
index a96cc1b090c..c0856427eae 100644
--- a/tests/ui/suspicious_else_formatting.rs
+++ b/tests/ui/suspicious_else_formatting.rs
@@ -1,7 +1,12 @@
 //@aux-build:proc_macro_suspicious_else_formatting.rs
 
 #![warn(clippy::suspicious_else_formatting)]
-#![allow(clippy::if_same_then_else, clippy::let_unit_value, clippy::needless_else)]
+#![allow(
+    clippy::if_same_then_else,
+    clippy::let_unit_value,
+    clippy::needless_if,
+    clippy::needless_else
+)]
 
 extern crate proc_macro_suspicious_else_formatting;
 use proc_macro_suspicious_else_formatting::DeriveBadSpan;
diff --git a/tests/ui/suspicious_else_formatting.stderr b/tests/ui/suspicious_else_formatting.stderr
index 2e512b47f12..723fdd7e93e 100644
--- a/tests/ui/suspicious_else_formatting.stderr
+++ b/tests/ui/suspicious_else_formatting.stderr
@@ -1,5 +1,5 @@
 error: this looks like an `else {..}` but the `else` is missing
-  --> $DIR/suspicious_else_formatting.rs:17:6
+  --> $DIR/suspicious_else_formatting.rs:22:6
    |
 LL |     } {
    |      ^
@@ -8,7 +8,7 @@ LL |     } {
    = note: `-D clippy::suspicious-else-formatting` implied by `-D warnings`
 
 error: this looks like an `else if` but the `else` is missing
-  --> $DIR/suspicious_else_formatting.rs:21:6
+  --> $DIR/suspicious_else_formatting.rs:26:6
    |
 LL |     } if foo() {
    |      ^
@@ -16,7 +16,7 @@ LL |     } if foo() {
    = note: to remove this lint, add the missing `else` or add a new line before the second `if`
 
 error: this looks like an `else if` but the `else` is missing
-  --> $DIR/suspicious_else_formatting.rs:28:10
+  --> $DIR/suspicious_else_formatting.rs:33:10
    |
 LL |         } if foo() {
    |          ^
@@ -24,7 +24,7 @@ LL |         } if foo() {
    = note: to remove this lint, add the missing `else` or add a new line before the second `if`
 
 error: this looks like an `else if` but the `else` is missing
-  --> $DIR/suspicious_else_formatting.rs:36:10
+  --> $DIR/suspicious_else_formatting.rs:41:10
    |
 LL |         } if foo() {
    |          ^
@@ -32,7 +32,7 @@ LL |         } if foo() {
    = note: to remove this lint, add the missing `else` or add a new line before the second `if`
 
 error: this is an `else {..}` but the formatting might hide it
-  --> $DIR/suspicious_else_formatting.rs:45:6
+  --> $DIR/suspicious_else_formatting.rs:50:6
    |
 LL |       } else
    |  ______^
@@ -42,7 +42,7 @@ LL | |     {
    = note: to remove this lint, remove the `else` or remove the new line between `else` and `{..}`
 
 error: this is an `else if` but the formatting might hide it
-  --> $DIR/suspicious_else_formatting.rs:57:6
+  --> $DIR/suspicious_else_formatting.rs:62:6
    |
 LL |       } else
    |  ______^
@@ -52,7 +52,7 @@ LL | |     if foo() { // the span of the above error should continue here
    = note: to remove this lint, remove the `else` or remove the new line between `else` and `if`
 
 error: this is an `else if` but the formatting might hide it
-  --> $DIR/suspicious_else_formatting.rs:62:6
+  --> $DIR/suspicious_else_formatting.rs:67:6
    |
 LL |       }
    |  ______^
@@ -63,7 +63,7 @@ LL | |     if foo() { // the span of the above error should continue here
    = note: to remove this lint, remove the `else` or remove the new line between `else` and `if`
 
 error: this is an `else {..}` but the formatting might hide it
-  --> $DIR/suspicious_else_formatting.rs:89:6
+  --> $DIR/suspicious_else_formatting.rs:94:6
    |
 LL |       }
    |  ______^
@@ -75,7 +75,7 @@ LL | |     {
    = note: to remove this lint, remove the `else` or remove the new line between `else` and `{..}`
 
 error: this is an `else {..}` but the formatting might hide it
-  --> $DIR/suspicious_else_formatting.rs:97:6
+  --> $DIR/suspicious_else_formatting.rs:102:6
    |
 LL |       }
    |  ______^
diff --git a/tests/ui/suspicious_unary_op_formatting.rs b/tests/ui/suspicious_unary_op_formatting.rs
index 9564e373c24..3c5ca1762fe 100644
--- a/tests/ui/suspicious_unary_op_formatting.rs
+++ b/tests/ui/suspicious_unary_op_formatting.rs
@@ -1,4 +1,5 @@
 #![warn(clippy::suspicious_unary_op_formatting)]
+#![allow(clippy::needless_if)]
 
 #[rustfmt::skip]
 fn main() {
diff --git a/tests/ui/suspicious_unary_op_formatting.stderr b/tests/ui/suspicious_unary_op_formatting.stderr
index 9f1289ccba0..52b0e99a1d3 100644
--- a/tests/ui/suspicious_unary_op_formatting.stderr
+++ b/tests/ui/suspicious_unary_op_formatting.stderr
@@ -1,5 +1,5 @@
 error: by not having a space between `>` and `-` it looks like `>-` is a single operator
-  --> $DIR/suspicious_unary_op_formatting.rs:8:9
+  --> $DIR/suspicious_unary_op_formatting.rs:9:9
    |
 LL |     if a >- 30 {}
    |         ^^^^
@@ -8,7 +8,7 @@ LL |     if a >- 30 {}
    = note: `-D clippy::suspicious-unary-op-formatting` implied by `-D warnings`
 
 error: by not having a space between `>=` and `-` it looks like `>=-` is a single operator
-  --> $DIR/suspicious_unary_op_formatting.rs:9:9
+  --> $DIR/suspicious_unary_op_formatting.rs:10:9
    |
 LL |     if a >=- 30 {}
    |         ^^^^^
@@ -16,7 +16,7 @@ LL |     if a >=- 30 {}
    = help: put a space between `>=` and `-` and remove the space after `-`
 
 error: by not having a space between `&&` and `!` it looks like `&&!` is a single operator
-  --> $DIR/suspicious_unary_op_formatting.rs:14:9
+  --> $DIR/suspicious_unary_op_formatting.rs:15:9
    |
 LL |     if b &&! c {}
    |         ^^^^^
@@ -24,7 +24,7 @@ LL |     if b &&! c {}
    = help: put a space between `&&` and `!` and remove the space after `!`
 
 error: by not having a space between `>` and `-` it looks like `>-` is a single operator
-  --> $DIR/suspicious_unary_op_formatting.rs:16:9
+  --> $DIR/suspicious_unary_op_formatting.rs:17:9
    |
 LL |     if a >-   30 {}
    |         ^^^^^^
diff --git a/tests/ui/unit_cmp.rs b/tests/ui/unit_cmp.rs
index 3d271104361..fc75f548a1b 100644
--- a/tests/ui/unit_cmp.rs
+++ b/tests/ui/unit_cmp.rs
@@ -2,7 +2,8 @@
 #![allow(
     clippy::no_effect,
     clippy::unnecessary_operation,
-    clippy::derive_partial_eq_without_eq
+    clippy::derive_partial_eq_without_eq,
+    clippy::needless_if
 )]
 
 #[derive(PartialEq)]
diff --git a/tests/ui/unit_cmp.stderr b/tests/ui/unit_cmp.stderr
index 41cf19ae685..79c890d644c 100644
--- a/tests/ui/unit_cmp.stderr
+++ b/tests/ui/unit_cmp.stderr
@@ -1,5 +1,5 @@
 error: ==-comparison of unit values detected. This will always be true
-  --> $DIR/unit_cmp.rs:16:8
+  --> $DIR/unit_cmp.rs:17:8
    |
 LL |       if {
    |  ________^
@@ -12,7 +12,7 @@ LL | |     } {}
    = note: `-D clippy::unit-cmp` implied by `-D warnings`
 
 error: >-comparison of unit values detected. This will always be false
-  --> $DIR/unit_cmp.rs:22:8
+  --> $DIR/unit_cmp.rs:23:8
    |
 LL |       if {
    |  ________^
@@ -23,7 +23,7 @@ LL | |     } {}
    | |_____^
 
 error: `assert_eq` of unit values detected. This will always succeed
-  --> $DIR/unit_cmp.rs:28:5
+  --> $DIR/unit_cmp.rs:29:5
    |
 LL | /     assert_eq!(
 LL | |         {
@@ -35,7 +35,7 @@ LL | |     );
    | |_____^
 
 error: `debug_assert_eq` of unit values detected. This will always succeed
-  --> $DIR/unit_cmp.rs:36:5
+  --> $DIR/unit_cmp.rs:37:5
    |
 LL | /     debug_assert_eq!(
 LL | |         {
@@ -47,7 +47,7 @@ LL | |     );
    | |_____^
 
 error: `assert_ne` of unit values detected. This will always fail
-  --> $DIR/unit_cmp.rs:45:5
+  --> $DIR/unit_cmp.rs:46:5
    |
 LL | /     assert_ne!(
 LL | |         {
@@ -59,7 +59,7 @@ LL | |     );
    | |_____^
 
 error: `debug_assert_ne` of unit values detected. This will always fail
-  --> $DIR/unit_cmp.rs:53:5
+  --> $DIR/unit_cmp.rs:54:5
    |
 LL | /     debug_assert_ne!(
 LL | |         {
diff --git a/tests/ui/unnecessary_safety_comment.rs b/tests/ui/unnecessary_safety_comment.rs
index 89fedb145f8..d858701ae8a 100644
--- a/tests/ui/unnecessary_safety_comment.rs
+++ b/tests/ui/unnecessary_safety_comment.rs
@@ -1,5 +1,5 @@
 #![warn(clippy::undocumented_unsafe_blocks, clippy::unnecessary_safety_comment)]
-#![allow(clippy::let_unit_value, clippy::missing_safety_doc)]
+#![allow(clippy::let_unit_value, clippy::missing_safety_doc, clippy::needless_if)]
 
 mod unsafe_items_invalid_comment {
     // SAFETY:
diff --git a/tests/ui/unneeded_wildcard_pattern.fixed b/tests/ui/unneeded_wildcard_pattern.fixed
index 16c2de760e5..d18c65a7709 100644
--- a/tests/ui/unneeded_wildcard_pattern.fixed
+++ b/tests/ui/unneeded_wildcard_pattern.fixed
@@ -1,6 +1,7 @@
 //@run-rustfix
 #![feature(stmt_expr_attributes)]
 #![deny(clippy::unneeded_wildcard_pattern)]
+#![allow(clippy::needless_if)]
 
 fn main() {
     let t = (0, 1, 2, 3);
diff --git a/tests/ui/unneeded_wildcard_pattern.rs b/tests/ui/unneeded_wildcard_pattern.rs
index 9d9eae1d903..c80756c4495 100644
--- a/tests/ui/unneeded_wildcard_pattern.rs
+++ b/tests/ui/unneeded_wildcard_pattern.rs
@@ -1,6 +1,7 @@
 //@run-rustfix
 #![feature(stmt_expr_attributes)]
 #![deny(clippy::unneeded_wildcard_pattern)]
+#![allow(clippy::needless_if)]
 
 fn main() {
     let t = (0, 1, 2, 3);
diff --git a/tests/ui/unneeded_wildcard_pattern.stderr b/tests/ui/unneeded_wildcard_pattern.stderr
index 716d9ecff89..8a004b77e94 100644
--- a/tests/ui/unneeded_wildcard_pattern.stderr
+++ b/tests/ui/unneeded_wildcard_pattern.stderr
@@ -1,5 +1,5 @@
 error: this pattern is unneeded as the `..` pattern can match that element
-  --> $DIR/unneeded_wildcard_pattern.rs:8:18
+  --> $DIR/unneeded_wildcard_pattern.rs:9:18
    |
 LL |     if let (0, .., _) = t {};
    |                  ^^^ help: remove it
@@ -11,79 +11,79 @@ LL | #![deny(clippy::unneeded_wildcard_pattern)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this pattern is unneeded as the `..` pattern can match that element
-  --> $DIR/unneeded_wildcard_pattern.rs:9:16
+  --> $DIR/unneeded_wildcard_pattern.rs:10:16
    |
 LL |     if let (0, _, ..) = t {};
    |                ^^^ help: remove it
 
 error: this pattern is unneeded as the `..` pattern can match that element
-  --> $DIR/unneeded_wildcard_pattern.rs:10:13
+  --> $DIR/unneeded_wildcard_pattern.rs:11:13
    |
 LL |     if let (_, .., 0) = t {};
    |             ^^^ help: remove it
 
 error: this pattern is unneeded as the `..` pattern can match that element
-  --> $DIR/unneeded_wildcard_pattern.rs:11:15
+  --> $DIR/unneeded_wildcard_pattern.rs:12:15
    |
 LL |     if let (.., _, 0) = t {};
    |               ^^^ help: remove it
 
 error: these patterns are unneeded as the `..` pattern can match those elements
-  --> $DIR/unneeded_wildcard_pattern.rs:12:16
+  --> $DIR/unneeded_wildcard_pattern.rs:13:16
    |
 LL |     if let (0, _, _, ..) = t {};
    |                ^^^^^^ help: remove them
 
 error: these patterns are unneeded as the `..` pattern can match those elements
-  --> $DIR/unneeded_wildcard_pattern.rs:13:18
+  --> $DIR/unneeded_wildcard_pattern.rs:14:18
    |
 LL |     if let (0, .., _, _) = t {};
    |                  ^^^^^^ help: remove them
 
 error: these patterns are unneeded as the `..` pattern can match those elements
-  --> $DIR/unneeded_wildcard_pattern.rs:22:22
+  --> $DIR/unneeded_wildcard_pattern.rs:23:22
    |
 LL |         if let (0, .., _, _,) = t {};
    |                      ^^^^^^ help: remove them
 
 error: this pattern is unneeded as the `..` pattern can match that element
-  --> $DIR/unneeded_wildcard_pattern.rs:29:19
+  --> $DIR/unneeded_wildcard_pattern.rs:30:19
    |
 LL |     if let S(0, .., _) = s {};
    |                   ^^^ help: remove it
 
 error: this pattern is unneeded as the `..` pattern can match that element
-  --> $DIR/unneeded_wildcard_pattern.rs:30:17
+  --> $DIR/unneeded_wildcard_pattern.rs:31:17
    |
 LL |     if let S(0, _, ..) = s {};
    |                 ^^^ help: remove it
 
 error: this pattern is unneeded as the `..` pattern can match that element
-  --> $DIR/unneeded_wildcard_pattern.rs:31:14
+  --> $DIR/unneeded_wildcard_pattern.rs:32:14
    |
 LL |     if let S(_, .., 0) = s {};
    |              ^^^ help: remove it
 
 error: this pattern is unneeded as the `..` pattern can match that element
-  --> $DIR/unneeded_wildcard_pattern.rs:32:16
+  --> $DIR/unneeded_wildcard_pattern.rs:33:16
    |
 LL |     if let S(.., _, 0) = s {};
    |                ^^^ help: remove it
 
 error: these patterns are unneeded as the `..` pattern can match those elements
-  --> $DIR/unneeded_wildcard_pattern.rs:33:17
+  --> $DIR/unneeded_wildcard_pattern.rs:34:17
    |
 LL |     if let S(0, _, _, ..) = s {};
    |                 ^^^^^^ help: remove them
 
 error: these patterns are unneeded as the `..` pattern can match those elements
-  --> $DIR/unneeded_wildcard_pattern.rs:34:19
+  --> $DIR/unneeded_wildcard_pattern.rs:35:19
    |
 LL |     if let S(0, .., _, _) = s {};
    |                   ^^^^^^ help: remove them
 
 error: these patterns are unneeded as the `..` pattern can match those elements
-  --> $DIR/unneeded_wildcard_pattern.rs:43:23
+  --> $DIR/unneeded_wildcard_pattern.rs:44:23
    |
 LL |         if let S(0, .., _, _,) = s {};
    |                       ^^^^^^ help: remove them
diff --git a/tests/ui/unnested_or_patterns.fixed b/tests/ui/unnested_or_patterns.fixed
index 8ec35ba4eea..4ce6e866695 100644
--- a/tests/ui/unnested_or_patterns.fixed
+++ b/tests/ui/unnested_or_patterns.fixed
@@ -2,7 +2,12 @@
 
 #![feature(box_patterns)]
 #![warn(clippy::unnested_or_patterns)]
-#![allow(clippy::cognitive_complexity, clippy::match_ref_pats, clippy::upper_case_acronyms)]
+#![allow(
+    clippy::cognitive_complexity,
+    clippy::match_ref_pats,
+    clippy::upper_case_acronyms,
+    clippy::needless_if
+)]
 #![allow(unreachable_patterns, irrefutable_let_patterns, unused)]
 
 fn main() {
diff --git a/tests/ui/unnested_or_patterns.rs b/tests/ui/unnested_or_patterns.rs
index efdb91b2402..07d60fac082 100644
--- a/tests/ui/unnested_or_patterns.rs
+++ b/tests/ui/unnested_or_patterns.rs
@@ -2,7 +2,12 @@
 
 #![feature(box_patterns)]
 #![warn(clippy::unnested_or_patterns)]
-#![allow(clippy::cognitive_complexity, clippy::match_ref_pats, clippy::upper_case_acronyms)]
+#![allow(
+    clippy::cognitive_complexity,
+    clippy::match_ref_pats,
+    clippy::upper_case_acronyms,
+    clippy::needless_if
+)]
 #![allow(unreachable_patterns, irrefutable_let_patterns, unused)]
 
 fn main() {
diff --git a/tests/ui/unnested_or_patterns.stderr b/tests/ui/unnested_or_patterns.stderr
index a1f193db555..d7b582fc8bd 100644
--- a/tests/ui/unnested_or_patterns.stderr
+++ b/tests/ui/unnested_or_patterns.stderr
@@ -1,5 +1,5 @@
 error: unnested or-patterns
-  --> $DIR/unnested_or_patterns.rs:12:12
+  --> $DIR/unnested_or_patterns.rs:17:12
    |
 LL |     if let box 0 | box 2 = Box::new(0) {}
    |            ^^^^^^^^^^^^^
@@ -11,7 +11,7 @@ LL |     if let box (0 | 2) = Box::new(0) {}
    |            ~~~~~~~~~~~
 
 error: unnested or-patterns
-  --> $DIR/unnested_or_patterns.rs:13:12
+  --> $DIR/unnested_or_patterns.rs:18:12
    |
 LL |     if let box ((0 | 1)) | box (2 | 3) | box 4 = Box::new(0) {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -22,7 +22,7 @@ LL |     if let box (0 | 1 | 2 | 3 | 4) = Box::new(0) {}
    |            ~~~~~~~~~~~~~~~~~~~~~~~
 
 error: unnested or-patterns
-  --> $DIR/unnested_or_patterns.rs:15:12
+  --> $DIR/unnested_or_patterns.rs:20:12
    |
 LL |     if let Some(1) | C0 | Some(2) = None {}
    |            ^^^^^^^^^^^^^^^^^^^^^^
@@ -33,7 +33,7 @@ LL |     if let Some(1 | 2) | C0 = None {}
    |            ~~~~~~~~~~~~~~~~
 
 error: unnested or-patterns
-  --> $DIR/unnested_or_patterns.rs:16:12
+  --> $DIR/unnested_or_patterns.rs:21:12
    |
 LL |     if let &mut 0 | &mut 2 = &mut 0 {}
    |            ^^^^^^^^^^^^^^^
@@ -44,7 +44,7 @@ LL |     if let &mut (0 | 2) = &mut 0 {}
    |            ~~~~~~~~~~~~
 
 error: unnested or-patterns
-  --> $DIR/unnested_or_patterns.rs:17:12
+  --> $DIR/unnested_or_patterns.rs:22:12
    |
 LL |     if let x @ 0 | x @ 2 = 0 {}
    |            ^^^^^^^^^^^^^
@@ -55,7 +55,7 @@ LL |     if let x @ (0 | 2) = 0 {}
    |            ~~~~~~~~~~~
 
 error: unnested or-patterns
-  --> $DIR/unnested_or_patterns.rs:18:12
+  --> $DIR/unnested_or_patterns.rs:23:12
    |
 LL |     if let (0, 1) | (0, 2) | (0, 3) = (0, 0) {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -66,7 +66,7 @@ LL |     if let (0, 1 | 2 | 3) = (0, 0) {}
    |            ~~~~~~~~~~~~~~
 
 error: unnested or-patterns
-  --> $DIR/unnested_or_patterns.rs:19:12
+  --> $DIR/unnested_or_patterns.rs:24:12
    |
 LL |     if let (1, 0) | (2, 0) | (3, 0) = (0, 0) {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -77,7 +77,7 @@ LL |     if let (1 | 2 | 3, 0) = (0, 0) {}
    |            ~~~~~~~~~~~~~~
 
 error: unnested or-patterns
-  --> $DIR/unnested_or_patterns.rs:20:12
+  --> $DIR/unnested_or_patterns.rs:25:12
    |
 LL |     if let (x, ..) | (x, 1) | (x, 2) = (0, 1) {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -88,7 +88,7 @@ LL |     if let (x, ..) | (x, 1 | 2) = (0, 1) {}
    |            ~~~~~~~~~~~~~~~~~~~~
 
 error: unnested or-patterns
-  --> $DIR/unnested_or_patterns.rs:21:12
+  --> $DIR/unnested_or_patterns.rs:26:12
    |
 LL |     if let [0] | [1] = [0] {}
    |            ^^^^^^^^^
@@ -99,7 +99,7 @@ LL |     if let [0 | 1] = [0] {}
    |            ~~~~~~~
 
 error: unnested or-patterns
-  --> $DIR/unnested_or_patterns.rs:22:12
+  --> $DIR/unnested_or_patterns.rs:27:12
    |
 LL |     if let [x, 0] | [x, 1] = [0, 1] {}
    |            ^^^^^^^^^^^^^^^
@@ -110,7 +110,7 @@ LL |     if let [x, 0 | 1] = [0, 1] {}
    |            ~~~~~~~~~~
 
 error: unnested or-patterns
-  --> $DIR/unnested_or_patterns.rs:23:12
+  --> $DIR/unnested_or_patterns.rs:28:12
    |
 LL |     if let [x, 0] | [x, 1] | [x, 2] = [0, 1] {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -121,7 +121,7 @@ LL |     if let [x, 0 | 1 | 2] = [0, 1] {}
    |            ~~~~~~~~~~~~~~
 
 error: unnested or-patterns
-  --> $DIR/unnested_or_patterns.rs:24:12
+  --> $DIR/unnested_or_patterns.rs:29:12
    |
 LL |     if let [x, ..] | [x, 1] | [x, 2] = [0, 1] {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -132,7 +132,7 @@ LL |     if let [x, ..] | [x, 1 | 2] = [0, 1] {}
    |            ~~~~~~~~~~~~~~~~~~~~
 
 error: unnested or-patterns
-  --> $DIR/unnested_or_patterns.rs:26:12
+  --> $DIR/unnested_or_patterns.rs:31:12
    |
 LL |     if let TS(0, x) | TS(1, x) = TS(0, 0) {}
    |            ^^^^^^^^^^^^^^^^^^^
@@ -143,7 +143,7 @@ LL |     if let TS(0 | 1, x) = TS(0, 0) {}
    |            ~~~~~~~~~~~~
 
 error: unnested or-patterns
-  --> $DIR/unnested_or_patterns.rs:27:12
+  --> $DIR/unnested_or_patterns.rs:32:12
    |
 LL |     if let TS(1, 0) | TS(2, 0) | TS(3, 0) = TS(0, 0) {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -154,7 +154,7 @@ LL |     if let TS(1 | 2 | 3, 0) = TS(0, 0) {}
    |            ~~~~~~~~~~~~~~~~
 
 error: unnested or-patterns
-  --> $DIR/unnested_or_patterns.rs:28:12
+  --> $DIR/unnested_or_patterns.rs:33:12
    |
 LL |     if let TS(x, ..) | TS(x, 1) | TS(x, 2) = TS(0, 0) {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -165,7 +165,7 @@ LL |     if let TS(x, ..) | TS(x, 1 | 2) = TS(0, 0) {}
    |            ~~~~~~~~~~~~~~~~~~~~~~~~
 
 error: unnested or-patterns
-  --> $DIR/unnested_or_patterns.rs:33:12
+  --> $DIR/unnested_or_patterns.rs:38:12
    |
 LL |     if let S { x: 0, y } | S { y, x: 1 } = (S { x: 0, y: 1 }) {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -176,7 +176,7 @@ LL |     if let S { x: 0 | 1, y } = (S { x: 0, y: 1 }) {}
    |            ~~~~~~~~~~~~~~~~~
 
 error: unnested or-patterns
-  --> $DIR/unnested_or_patterns.rs:44:12
+  --> $DIR/unnested_or_patterns.rs:49:12
    |
 LL |     if let [1] | [53] = [0] {}
    |            ^^^^^^^^^^
diff --git a/tests/ui/unnested_or_patterns2.fixed b/tests/ui/unnested_or_patterns2.fixed
index de40e936747..a88d7f51ac0 100644
--- a/tests/ui/unnested_or_patterns2.fixed
+++ b/tests/ui/unnested_or_patterns2.fixed
@@ -2,7 +2,7 @@
 
 #![feature(box_patterns)]
 #![warn(clippy::unnested_or_patterns)]
-#![allow(clippy::cognitive_complexity, clippy::match_ref_pats)]
+#![allow(clippy::cognitive_complexity, clippy::match_ref_pats, clippy::needless_if)]
 #![allow(unreachable_patterns, irrefutable_let_patterns, unused_variables)]
 
 fn main() {
diff --git a/tests/ui/unnested_or_patterns2.rs b/tests/ui/unnested_or_patterns2.rs
index 87f66d26c46..f6029eee441 100644
--- a/tests/ui/unnested_or_patterns2.rs
+++ b/tests/ui/unnested_or_patterns2.rs
@@ -2,7 +2,7 @@
 
 #![feature(box_patterns)]
 #![warn(clippy::unnested_or_patterns)]
-#![allow(clippy::cognitive_complexity, clippy::match_ref_pats)]
+#![allow(clippy::cognitive_complexity, clippy::match_ref_pats, clippy::needless_if)]
 #![allow(unreachable_patterns, irrefutable_let_patterns, unused_variables)]
 
 fn main() {
diff --git a/tests/ui/useless_conversion.fixed b/tests/ui/useless_conversion.fixed
index e9563b8a60a..5d2c5b11658 100644
--- a/tests/ui/useless_conversion.fixed
+++ b/tests/ui/useless_conversion.fixed
@@ -1,7 +1,7 @@
 //@run-rustfix
 
 #![deny(clippy::useless_conversion)]
-#![allow(clippy::unnecessary_wraps)]
+#![allow(clippy::needless_if, clippy::unnecessary_wraps)]
 
 fn test_generic<T: Copy>(val: T) -> T {
     let _ = val;
diff --git a/tests/ui/useless_conversion.rs b/tests/ui/useless_conversion.rs
index c2f4e3117d2..03a3e3f95ba 100644
--- a/tests/ui/useless_conversion.rs
+++ b/tests/ui/useless_conversion.rs
@@ -1,7 +1,7 @@
 //@run-rustfix
 
 #![deny(clippy::useless_conversion)]
-#![allow(clippy::unnecessary_wraps)]
+#![allow(clippy::needless_if, clippy::unnecessary_wraps)]
 
 fn test_generic<T: Copy>(val: T) -> T {
     let _ = T::from(val);
diff --git a/tests/ui/useless_conversion_try.rs b/tests/ui/useless_conversion_try.rs
index 4acf5b5fa2d..ec0512ce210 100644
--- a/tests/ui/useless_conversion_try.rs
+++ b/tests/ui/useless_conversion_try.rs
@@ -1,4 +1,5 @@
 #![deny(clippy::useless_conversion)]
+#![allow(clippy::needless_if)]
 
 fn test_generic<T: Copy>(val: T) -> T {
     let _ = T::try_from(val).unwrap();
diff --git a/tests/ui/useless_conversion_try.stderr b/tests/ui/useless_conversion_try.stderr
index 9aef9dda6f6..54189f8d286 100644
--- a/tests/ui/useless_conversion_try.stderr
+++ b/tests/ui/useless_conversion_try.stderr
@@ -1,5 +1,5 @@
 error: useless conversion to the same type: `T`
-  --> $DIR/useless_conversion_try.rs:4:13
+  --> $DIR/useless_conversion_try.rs:5:13
    |
 LL |     let _ = T::try_from(val).unwrap();
    |             ^^^^^^^^^^^^^^^^
@@ -12,7 +12,7 @@ LL | #![deny(clippy::useless_conversion)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: useless conversion to the same type: `T`
-  --> $DIR/useless_conversion_try.rs:5:5
+  --> $DIR/useless_conversion_try.rs:6:5
    |
 LL |     val.try_into().unwrap()
    |     ^^^^^^^^^^^^^^
@@ -20,7 +20,7 @@ LL |     val.try_into().unwrap()
    = help: consider removing `.try_into()`
 
 error: useless conversion to the same type: `std::string::String`
-  --> $DIR/useless_conversion_try.rs:27:21
+  --> $DIR/useless_conversion_try.rs:28:21
    |
 LL |     let _: String = "foo".to_string().try_into().unwrap();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -28,7 +28,7 @@ LL |     let _: String = "foo".to_string().try_into().unwrap();
    = help: consider removing `.try_into()`
 
 error: useless conversion to the same type: `std::string::String`
-  --> $DIR/useless_conversion_try.rs:28:21
+  --> $DIR/useless_conversion_try.rs:29:21
    |
 LL |     let _: String = TryFrom::try_from("foo".to_string()).unwrap();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -36,7 +36,7 @@ LL |     let _: String = TryFrom::try_from("foo".to_string()).unwrap();
    = help: consider removing `TryFrom::try_from()`
 
 error: useless conversion to the same type: `std::string::String`
-  --> $DIR/useless_conversion_try.rs:29:13
+  --> $DIR/useless_conversion_try.rs:30:13
    |
 LL |     let _ = String::try_from("foo".to_string()).unwrap();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -44,7 +44,7 @@ LL |     let _ = String::try_from("foo".to_string()).unwrap();
    = help: consider removing `String::try_from()`
 
 error: useless conversion to the same type: `std::string::String`
-  --> $DIR/useless_conversion_try.rs:30:13
+  --> $DIR/useless_conversion_try.rs:31:13
    |
 LL |     let _ = String::try_from(format!("A: {:04}", 123)).unwrap();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -52,7 +52,7 @@ LL |     let _ = String::try_from(format!("A: {:04}", 123)).unwrap();
    = help: consider removing `String::try_from()`
 
 error: useless conversion to the same type: `std::string::String`
-  --> $DIR/useless_conversion_try.rs:31:21
+  --> $DIR/useless_conversion_try.rs:32:21
    |
 LL |     let _: String = format!("Hello {}", "world").try_into().unwrap();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -60,7 +60,7 @@ LL |     let _: String = format!("Hello {}", "world").try_into().unwrap();
    = help: consider removing `.try_into()`
 
 error: useless conversion to the same type: `std::string::String`
-  --> $DIR/useless_conversion_try.rs:32:21
+  --> $DIR/useless_conversion_try.rs:33:21
    |
 LL |     let _: String = String::new().try_into().unwrap();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -68,7 +68,7 @@ LL |     let _: String = String::new().try_into().unwrap();
    = help: consider removing `.try_into()`
 
 error: useless conversion to the same type: `std::string::String`
-  --> $DIR/useless_conversion_try.rs:33:27
+  --> $DIR/useless_conversion_try.rs:34:27
    |
 LL |     let _: String = match String::from("_").try_into() {
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From b303e2053cc0629c58419b80d9655027f06f255e Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Fri, 9 Jun 2023 14:27:34 -0500
Subject: allow disabling module inception on private modules

allow disabling module inception on private modules
---
 book/src/lint_configuration.md                     | 10 +++++++
 clippy_lints/src/enum_variants.rs                  | 31 +++++++++++---------
 clippy_lints/src/lib.rs                            |  2 ++
 clippy_lints/src/utils/conf.rs                     |  4 +++
 tests/ui-toml/module_inception/clippy.toml         |  1 +
 tests/ui-toml/module_inception/module_inception.rs | 34 ++++++++++++++++++++++
 .../module_inception/module_inception.stderr       | 20 +++++++++++++
 .../toml_unknown_key/conf_unknown_key.stderr       |  2 ++
 tests/ui/module_inception.rs                       | 12 ++++++++
 tests/ui/module_inception.stderr                   | 22 ++++++++++++--
 10 files changed, 121 insertions(+), 17 deletions(-)
 create mode 100644 tests/ui-toml/module_inception/clippy.toml
 create mode 100644 tests/ui-toml/module_inception/module_inception.rs
 create mode 100644 tests/ui-toml/module_inception/module_inception.stderr

(limited to 'clippy_lints/src')

diff --git a/book/src/lint_configuration.md b/book/src/lint_configuration.md
index 4c888b63793..2777119984e 100644
--- a/book/src/lint_configuration.md
+++ b/book/src/lint_configuration.md
@@ -643,3 +643,13 @@ The byte size a `T` in `Box<T>` can have, below which it triggers the `clippy::u
 * [`unnecessary_box_returns`](https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_box_returns)
 
 
+## `allow-private-module-inception`
+Whether to allow module inception if it's not public.
+
+**Default Value:** `false` (`bool`)
+
+---
+**Affected lints:**
+* [`module_inception`](https://rust-lang.github.io/rust-clippy/master/index.html#module_inception)
+
+
diff --git a/clippy_lints/src/enum_variants.rs b/clippy_lints/src/enum_variants.rs
index faac6340419..d4df6f7aa2d 100644
--- a/clippy_lints/src/enum_variants.rs
+++ b/clippy_lints/src/enum_variants.rs
@@ -3,7 +3,7 @@
 use clippy_utils::diagnostics::{span_lint, span_lint_and_help, span_lint_hir};
 use clippy_utils::source::is_present_in_source;
 use clippy_utils::str_utils::{camel_case_split, count_match_end, count_match_start};
-use rustc_hir::{EnumDef, Item, ItemKind, Variant};
+use rustc_hir::{EnumDef, Item, ItemKind, OwnerId, Variant};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::Span;
@@ -105,18 +105,20 @@ declare_clippy_lint! {
 }
 
 pub struct EnumVariantNames {
-    modules: Vec<(Symbol, String)>,
+    modules: Vec<(Symbol, String, OwnerId)>,
     threshold: u64,
     avoid_breaking_exported_api: bool,
+    allow_private_module_inception: bool,
 }
 
 impl EnumVariantNames {
     #[must_use]
-    pub fn new(threshold: u64, avoid_breaking_exported_api: bool) -> Self {
+    pub fn new(threshold: u64, avoid_breaking_exported_api: bool, allow_private_module_inception: bool) -> Self {
         Self {
             modules: Vec::new(),
             threshold,
             avoid_breaking_exported_api,
+            allow_private_module_inception,
         }
     }
 }
@@ -252,18 +254,19 @@ impl LateLintPass<'_> for EnumVariantNames {
         let item_name = item.ident.name.as_str();
         let item_camel = to_camel_case(item_name);
         if !item.span.from_expansion() && is_present_in_source(cx, item.span) {
-            if let Some((mod_name, mod_camel)) = self.modules.last() {
+            if let [.., (mod_name, mod_camel, owner_id)] = &*self.modules {
                 // constants don't have surrounding modules
                 if !mod_camel.is_empty() {
-                    if mod_name == &item.ident.name {
-                        if let ItemKind::Mod(..) = item.kind {
-                            span_lint(
-                                cx,
-                                MODULE_INCEPTION,
-                                item.span,
-                                "module has the same name as its containing module",
-                            );
-                        }
+                    if mod_name == &item.ident.name
+                        && let ItemKind::Mod(..) = item.kind
+                        && (!self.allow_private_module_inception || cx.tcx.visibility(owner_id.def_id).is_public())
+                    {
+                        span_lint(
+                            cx,
+                            MODULE_INCEPTION,
+                            item.span,
+                            "module has the same name as its containing module",
+                        );
                     }
                     // The `module_name_repetitions` lint should only trigger if the item has the module in its
                     // name. Having the same name is accepted.
@@ -302,6 +305,6 @@ impl LateLintPass<'_> for EnumVariantNames {
                 check_variant(cx, self.threshold, def, item_name, item.span);
             }
         }
-        self.modules.push((item.ident.name, item_camel));
+        self.modules.push((item.ident.name, item_camel, item.owner_id));
     }
 }
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 43ab8a96d86..3517d2f64f0 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -813,10 +813,12 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         ))
     });
     let enum_variant_name_threshold = conf.enum_variant_name_threshold;
+    let allow_private_module_inception = conf.allow_private_module_inception;
     store.register_late_pass(move |_| {
         Box::new(enum_variants::EnumVariantNames::new(
             enum_variant_name_threshold,
             avoid_breaking_exported_api,
+            allow_private_module_inception,
         ))
     });
     store.register_early_pass(|| Box::new(tabs_in_doc_comments::TabsInDocComments));
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 35f40830681..3952ec7389f 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -514,6 +514,10 @@ define_Conf! {
     ///
     /// The byte size a `T` in `Box<T>` can have, below which it triggers the `clippy::unnecessary_box` lint
     (unnecessary_box_size: u64 = 128),
+    /// Lint: MODULE_INCEPTION.
+    ///
+    /// Whether to allow module inception if it's not public.
+    (allow_private_module_inception: bool = false),
 }
 
 /// Search for the configuration file.
diff --git a/tests/ui-toml/module_inception/clippy.toml b/tests/ui-toml/module_inception/clippy.toml
new file mode 100644
index 00000000000..787620d865c
--- /dev/null
+++ b/tests/ui-toml/module_inception/clippy.toml
@@ -0,0 +1 @@
+allow-private-module-inception = true
diff --git a/tests/ui-toml/module_inception/module_inception.rs b/tests/ui-toml/module_inception/module_inception.rs
new file mode 100644
index 00000000000..cd495c884a4
--- /dev/null
+++ b/tests/ui-toml/module_inception/module_inception.rs
@@ -0,0 +1,34 @@
+#![warn(clippy::module_inception)]
+
+// Lint
+pub mod foo2 {
+    pub mod bar2 {
+        pub mod bar2 {
+            pub mod foo2 {}
+        }
+        pub mod foo2 {}
+    }
+    pub mod foo2 {
+        pub mod bar2 {}
+    }
+}
+
+// Don't lint
+mod foo {
+    pub mod bar {
+        pub mod foo {
+            pub mod bar {}
+        }
+    }
+    pub mod foo {
+        pub mod bar {}
+    }
+}
+
+// No warning. See <https://github.com/rust-lang/rust-clippy/issues/1220>.
+pub mod bar {
+    #[allow(clippy::module_inception)]
+    pub mod bar {}
+}
+
+fn main() {}
diff --git a/tests/ui-toml/module_inception/module_inception.stderr b/tests/ui-toml/module_inception/module_inception.stderr
new file mode 100644
index 00000000000..a5a09c322e1
--- /dev/null
+++ b/tests/ui-toml/module_inception/module_inception.stderr
@@ -0,0 +1,20 @@
+error: module has the same name as its containing module
+  --> $DIR/module_inception.rs:6:9
+   |
+LL | /         pub mod bar2 {
+LL | |             pub mod foo2 {}
+LL | |         }
+   | |_________^
+   |
+   = note: `-D clippy::module-inception` implied by `-D warnings`
+
+error: module has the same name as its containing module
+  --> $DIR/module_inception.rs:11:5
+   |
+LL | /     pub mod foo2 {
+LL | |         pub mod bar2 {}
+LL | |     }
+   | |_____^
+
+error: aborting due to 2 previous errors
+
diff --git a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
index b6038f031f3..22ea45d0622 100644
--- a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
+++ b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
@@ -3,6 +3,7 @@ error: error reading Clippy's configuration file: unknown field `foobar`, expect
            allow-expect-in-tests
            allow-mixed-uninlined-format-args
            allow-print-in-tests
+           allow-private-module-inception
            allow-unwrap-in-tests
            allowed-scripts
            arithmetic-side-effects-allowed
@@ -64,6 +65,7 @@ error: error reading Clippy's configuration file: unknown field `barfoo`, expect
            allow-expect-in-tests
            allow-mixed-uninlined-format-args
            allow-print-in-tests
+           allow-private-module-inception
            allow-unwrap-in-tests
            allowed-scripts
            arithmetic-side-effects-allowed
diff --git a/tests/ui/module_inception.rs b/tests/ui/module_inception.rs
index a23aba9164a..802c3ec39b6 100644
--- a/tests/ui/module_inception.rs
+++ b/tests/ui/module_inception.rs
@@ -1,5 +1,17 @@
 #![warn(clippy::module_inception)]
 
+pub mod foo2 {
+    pub mod bar2 {
+        pub mod bar2 {
+            pub mod foo2 {}
+        }
+        pub mod foo2 {}
+    }
+    pub mod foo2 {
+        pub mod bar2 {}
+    }
+}
+
 mod foo {
     mod bar {
         mod bar {
diff --git a/tests/ui/module_inception.stderr b/tests/ui/module_inception.stderr
index 77564dce9eb..ebb8e296f46 100644
--- a/tests/ui/module_inception.stderr
+++ b/tests/ui/module_inception.stderr
@@ -1,8 +1,8 @@
 error: module has the same name as its containing module
   --> $DIR/module_inception.rs:5:9
    |
-LL | /         mod bar {
-LL | |             mod foo {}
+LL | /         pub mod bar2 {
+LL | |             pub mod foo2 {}
 LL | |         }
    | |_________^
    |
@@ -11,10 +11,26 @@ LL | |         }
 error: module has the same name as its containing module
   --> $DIR/module_inception.rs:10:5
    |
+LL | /     pub mod foo2 {
+LL | |         pub mod bar2 {}
+LL | |     }
+   | |_____^
+
+error: module has the same name as its containing module
+  --> $DIR/module_inception.rs:17:9
+   |
+LL | /         mod bar {
+LL | |             mod foo {}
+LL | |         }
+   | |_________^
+
+error: module has the same name as its containing module
+  --> $DIR/module_inception.rs:22:5
+   |
 LL | /     mod foo {
 LL | |         mod bar {}
 LL | |     }
    | |_____^
 
-error: aborting due to 2 previous errors
+error: aborting due to 4 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From b2bdc37a558e4686e9e1c4eb5d967bdc69485826 Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Sun, 11 Jun 2023 04:55:02 -0500
Subject: add description

add description
---
 clippy_lints/src/needless_if.rs | 16 ++++++++++++----
 1 file changed, 12 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/needless_if.rs b/clippy_lints/src/needless_if.rs
index 1568c3533a0..8e27d3a4009 100644
--- a/clippy_lints/src/needless_if.rs
+++ b/clippy_lints/src/needless_if.rs
@@ -7,16 +7,24 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
     /// ### What it does
+    /// Checks for empty `if` statements with no else branch.
     ///
     /// ### Why is this bad?
+    /// It can be entirely omitted, and often the condition too.
+    ///
+    /// ### Known issues
+    /// This will only suggest to remove the `if` statement, not the condition. Other lints such as
+    /// `no_effect` will take care of removing the condition if it's unnecessary.
     ///
     /// ### Example
-    /// ```rust
-    /// // example code where clippy issues a warning
+    /// ```rust,ignore
+    /// if really_expensive_condition(&i) {}
+    /// if really_expensive_condition_with_side_effects(&mut i) {}
     /// ```
     /// Use instead:
-    /// ```rust
-    /// // example code which does not raise clippy warning
+    /// ```rust,ignore
+    /// // <omitted>
+    /// really_expensive_condition_with_side_effects(&mut i);
     /// ```
     #[clippy::version = "1.72.0"]
     pub NEEDLESS_IF,
-- 
cgit 1.4.1-3-g733a5


From 4c7bc1785d137cb2de667be58d50b89d252c9707 Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Sun, 11 Jun 2023 06:21:31 -0500
Subject: ignore more type aliases in unnecessary_cast

ignore more type aliases in unnecessary_cast
---
 clippy_lints/src/casts/unnecessary_cast.rs | 29 +++++++++++++++++--
 tests/ui/unnecessary_cast.fixed            | 12 +++++++-
 tests/ui/unnecessary_cast.rs               | 12 +++++++-
 tests/ui/unnecessary_cast.stderr           | 46 +++++++++++++++---------------
 4 files changed, 72 insertions(+), 27 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/unnecessary_cast.rs b/clippy_lints/src/casts/unnecessary_cast.rs
index d3d80ff4100..41055c168fc 100644
--- a/clippy_lints/src/casts/unnecessary_cast.rs
+++ b/clippy_lints/src/casts/unnecessary_cast.rs
@@ -6,13 +6,14 @@ use if_chain::if_chain;
 use rustc_ast::{LitFloatType, LitIntType, LitKind};
 use rustc_errors::Applicability;
 use rustc_hir::def::Res;
-use rustc_hir::{Expr, ExprKind, Lit, QPath, TyKind, UnOp};
+use rustc_hir::{Expr, ExprKind, Lit, Node, Path, QPath, TyKind, UnOp};
 use rustc_lint::{LateContext, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::{self, FloatTy, InferTy, Ty};
 
 use super::UNNECESSARY_CAST;
 
+#[expect(clippy::too_many_lines)]
 pub(super) fn check<'tcx>(
     cx: &LateContext<'tcx>,
     expr: &Expr<'tcx>,
@@ -58,7 +59,31 @@ pub(super) fn check<'tcx>(
         }
     }
 
-    // skip non-primitive type cast
+    // skip cast of local to type alias
+    if let ExprKind::Cast(inner, ..) = expr.kind
+        && let ExprKind::Path(qpath) = inner.kind
+        && let QPath::Resolved(None, Path { res, .. }) = qpath
+        && let Res::Local(hir_id) = res
+        && let parent = cx.tcx.hir().get_parent(*hir_id)
+        && let Node::Local(local) = parent
+    {
+        if let Some(ty) = local.ty
+            && let TyKind::Path(qpath) = ty.kind
+            && is_ty_alias(&qpath)
+        {
+            return false;
+        }
+
+        if let Some(expr) = local.init
+            && let ExprKind::Cast(.., cast_to) = expr.kind
+            && let TyKind::Path(qpath) = cast_to.kind
+            && is_ty_alias(&qpath)
+        {
+            return false;
+        }
+    }
+
+    // skip cast to non-primitive type
     if_chain! {
         if let ExprKind::Cast(_, cast_to) = expr.kind;
         if let TyKind::Path(QPath::Resolved(_, path)) = &cast_to.kind;
diff --git a/tests/ui/unnecessary_cast.fixed b/tests/ui/unnecessary_cast.fixed
index e74476044d9..f56cee3a364 100644
--- a/tests/ui/unnecessary_cast.fixed
+++ b/tests/ui/unnecessary_cast.fixed
@@ -66,12 +66,22 @@ fn main() {
     foo!(b, f32);
     foo!(c, f64);
 
+    // do not lint cast from cfg-dependant type
+    let x = 0 as std::ffi::c_ulong;
+    let y = x as u64;
+    let x: std::ffi::c_ulong = 0;
+    let y = x as u64;
+
     // do not lint cast to cfg-dependant type
-    1 as std::os::raw::c_char;
+    let x = 1 as std::os::raw::c_char;
+    let y = x as u64;
 
     // do not lint cast to alias type
     1 as I32Alias;
     &1 as &I32Alias;
+    // or from
+    let x: I32Alias = 1;
+    let y = x as u64;
 
     let i8_ptr: *const i8 = &1;
     let u8_ptr: *const u8 = &1;
diff --git a/tests/ui/unnecessary_cast.rs b/tests/ui/unnecessary_cast.rs
index a577fd79899..b4623df6909 100644
--- a/tests/ui/unnecessary_cast.rs
+++ b/tests/ui/unnecessary_cast.rs
@@ -66,12 +66,22 @@ fn main() {
     foo!(b, f32);
     foo!(c, f64);
 
+    // do not lint cast from cfg-dependant type
+    let x = 0 as std::ffi::c_ulong;
+    let y = x as u64;
+    let x: std::ffi::c_ulong = 0;
+    let y = x as u64;
+
     // do not lint cast to cfg-dependant type
-    1 as std::os::raw::c_char;
+    let x = 1 as std::os::raw::c_char;
+    let y = x as u64;
 
     // do not lint cast to alias type
     1 as I32Alias;
     &1 as &I32Alias;
+    // or from
+    let x: I32Alias = 1;
+    let y = x as u64;
 
     let i8_ptr: *const i8 = &1;
     let u8_ptr: *const u8 = &1;
diff --git a/tests/ui/unnecessary_cast.stderr b/tests/ui/unnecessary_cast.stderr
index 7f748fcf4c2..b52e5c32c8a 100644
--- a/tests/ui/unnecessary_cast.stderr
+++ b/tests/ui/unnecessary_cast.stderr
@@ -91,139 +91,139 @@ LL |     uwu::<u32, u32>([1u32].as_ptr()) as *const u32;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `uwu::<u32, u32>([1u32].as_ptr())`
 
 error: casting integer literal to `f32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:106:9
+  --> $DIR/unnecessary_cast.rs:117:9
    |
 LL |         100 as f32;
    |         ^^^^^^^^^^ help: try: `100_f32`
 
 error: casting integer literal to `f64` is unnecessary
-  --> $DIR/unnecessary_cast.rs:107:9
+  --> $DIR/unnecessary_cast.rs:118:9
    |
 LL |         100 as f64;
    |         ^^^^^^^^^^ help: try: `100_f64`
 
 error: casting integer literal to `f64` is unnecessary
-  --> $DIR/unnecessary_cast.rs:108:9
+  --> $DIR/unnecessary_cast.rs:119:9
    |
 LL |         100_i32 as f64;
    |         ^^^^^^^^^^^^^^ help: try: `100_f64`
 
 error: casting integer literal to `f32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:109:17
+  --> $DIR/unnecessary_cast.rs:120:17
    |
 LL |         let _ = -100 as f32;
    |                 ^^^^^^^^^^^ help: try: `-100_f32`
 
 error: casting integer literal to `f64` is unnecessary
-  --> $DIR/unnecessary_cast.rs:110:17
+  --> $DIR/unnecessary_cast.rs:121:17
    |
 LL |         let _ = -100 as f64;
    |                 ^^^^^^^^^^^ help: try: `-100_f64`
 
 error: casting integer literal to `f64` is unnecessary
-  --> $DIR/unnecessary_cast.rs:111:17
+  --> $DIR/unnecessary_cast.rs:122:17
    |
 LL |         let _ = -100_i32 as f64;
    |                 ^^^^^^^^^^^^^^^ help: try: `-100_f64`
 
 error: casting float literal to `f32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:112:9
+  --> $DIR/unnecessary_cast.rs:123:9
    |
 LL |         100. as f32;
    |         ^^^^^^^^^^^ help: try: `100_f32`
 
 error: casting float literal to `f64` is unnecessary
-  --> $DIR/unnecessary_cast.rs:113:9
+  --> $DIR/unnecessary_cast.rs:124:9
    |
 LL |         100. as f64;
    |         ^^^^^^^^^^^ help: try: `100_f64`
 
 error: casting integer literal to `u32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:125:9
+  --> $DIR/unnecessary_cast.rs:136:9
    |
 LL |         1 as u32;
    |         ^^^^^^^^ help: try: `1_u32`
 
 error: casting integer literal to `i32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:126:9
+  --> $DIR/unnecessary_cast.rs:137:9
    |
 LL |         0x10 as i32;
    |         ^^^^^^^^^^^ help: try: `0x10_i32`
 
 error: casting integer literal to `usize` is unnecessary
-  --> $DIR/unnecessary_cast.rs:127:9
+  --> $DIR/unnecessary_cast.rs:138:9
    |
 LL |         0b10 as usize;
    |         ^^^^^^^^^^^^^ help: try: `0b10_usize`
 
 error: casting integer literal to `u16` is unnecessary
-  --> $DIR/unnecessary_cast.rs:128:9
+  --> $DIR/unnecessary_cast.rs:139:9
    |
 LL |         0o73 as u16;
    |         ^^^^^^^^^^^ help: try: `0o73_u16`
 
 error: casting integer literal to `u32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:129:9
+  --> $DIR/unnecessary_cast.rs:140:9
    |
 LL |         1_000_000_000 as u32;
    |         ^^^^^^^^^^^^^^^^^^^^ help: try: `1_000_000_000_u32`
 
 error: casting float literal to `f64` is unnecessary
-  --> $DIR/unnecessary_cast.rs:131:9
+  --> $DIR/unnecessary_cast.rs:142:9
    |
 LL |         1.0 as f64;
    |         ^^^^^^^^^^ help: try: `1.0_f64`
 
 error: casting float literal to `f32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:132:9
+  --> $DIR/unnecessary_cast.rs:143:9
    |
 LL |         0.5 as f32;
    |         ^^^^^^^^^^ help: try: `0.5_f32`
 
 error: casting integer literal to `i32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:136:17
+  --> $DIR/unnecessary_cast.rs:147:17
    |
 LL |         let _ = -1 as i32;
    |                 ^^^^^^^^^ help: try: `-1_i32`
 
 error: casting float literal to `f32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:137:17
+  --> $DIR/unnecessary_cast.rs:148:17
    |
 LL |         let _ = -1.0 as f32;
    |                 ^^^^^^^^^^^ help: try: `-1.0_f32`
 
 error: casting to the same type is unnecessary (`i32` -> `i32`)
-  --> $DIR/unnecessary_cast.rs:143:18
+  --> $DIR/unnecessary_cast.rs:154:18
    |
 LL |         let _ = &(x as i32);
    |                  ^^^^^^^^^^ help: try: `{ x }`
 
 error: casting integer literal to `i32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:149:22
+  --> $DIR/unnecessary_cast.rs:160:22
    |
 LL |         let _: i32 = -(1) as i32;
    |                      ^^^^^^^^^^^ help: try: `-1_i32`
 
 error: casting integer literal to `i64` is unnecessary
-  --> $DIR/unnecessary_cast.rs:151:22
+  --> $DIR/unnecessary_cast.rs:162:22
    |
 LL |         let _: i64 = -(1) as i64;
    |                      ^^^^^^^^^^^ help: try: `-1_i64`
 
 error: casting float literal to `f64` is unnecessary
-  --> $DIR/unnecessary_cast.rs:158:22
+  --> $DIR/unnecessary_cast.rs:169:22
    |
 LL |         let _: f64 = (-8.0 as f64).exp();
    |                      ^^^^^^^^^^^^^ help: try: `(-8.0_f64)`
 
 error: casting float literal to `f64` is unnecessary
-  --> $DIR/unnecessary_cast.rs:160:23
+  --> $DIR/unnecessary_cast.rs:171:23
    |
 LL |         let _: f64 = -(8.0 as f64).exp(); // should suggest `-8.0_f64.exp()` here not to change code behavior
    |                       ^^^^^^^^^^^^ help: try: `8.0_f64`
 
 error: casting to the same type is unnecessary (`f32` -> `f32`)
-  --> $DIR/unnecessary_cast.rs:168:20
+  --> $DIR/unnecessary_cast.rs:179:20
    |
 LL |         let _num = foo() as f32;
    |                    ^^^^^^^^^^^^ help: try: `foo()`
-- 
cgit 1.4.1-3-g733a5


From 59bca098f906ecf7bef2f0cab95afbcc2d2e66ca Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Sun, 11 Jun 2023 06:50:03 -0500
Subject: don't lint on `if let`

don't lint on `if let`
---
 clippy_lints/src/needless_if.rs | 51 ++++++++++++++++++++++++++++++++---------
 tests/ui/needless_if.fixed      | 30 ++++++++++++++++++++----
 tests/ui/needless_if.rs         | 29 ++++++++++++++++++++---
 tests/ui/needless_if.stderr     | 24 ++++++++++++++-----
 4 files changed, 109 insertions(+), 25 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/needless_if.rs b/clippy_lints/src/needless_if.rs
index 8e27d3a4009..b118516e09b 100644
--- a/clippy_lints/src/needless_if.rs
+++ b/clippy_lints/src/needless_if.rs
@@ -1,20 +1,23 @@
 use clippy_utils::{diagnostics::span_lint_and_sugg, is_from_proc_macro, source::snippet_with_applicability};
 use rustc_errors::Applicability;
-use rustc_hir::{Expr, ExprKind, Node};
+use rustc_hir::{
+    intravisit::{walk_expr, Visitor},
+    Expr, ExprKind, Node,
+};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for empty `if` statements with no else branch.
+    /// Checks for empty `if` branches with no else branch.
     ///
     /// ### Why is this bad?
     /// It can be entirely omitted, and often the condition too.
     ///
     /// ### Known issues
-    /// This will only suggest to remove the `if` statement, not the condition. Other lints such as
-    /// `no_effect` will take care of removing the condition if it's unnecessary.
+    /// This will usually only suggest to remove the `if` statement, not the condition. Other lints
+    /// such as `no_effect` will take care of removing the condition if it's unnecessary.
     ///
     /// ### Example
     /// ```rust,ignore
@@ -42,9 +45,6 @@ impl LateLintPass<'_> for NeedlessIf {
             && else_expr.is_none()
             && !in_external_macro(cx.sess(), expr.span)
         {
-            let mut app = Applicability::MachineApplicable;
-            let snippet = snippet_with_applicability(cx, if_expr.span, "{ ... }", &mut app);
-
             // Ignore `else if`
             if let Some(parent_id) = cx.tcx.hir().opt_parent_id(expr.hir_id)
                 && let Some(Node::Expr(Expr {
@@ -56,19 +56,48 @@ impl LateLintPass<'_> for NeedlessIf {
                 return;
             }
 
-            if is_from_proc_macro(cx, expr) {
+            if is_any_if_let(if_expr) || is_from_proc_macro(cx, expr) {
                 return;
             }
 
+            let mut app = Applicability::MachineApplicable;
+            let snippet = snippet_with_applicability(cx, if_expr.span, "{ ... }", &mut app);
+
             span_lint_and_sugg(
                 cx,
                 NEEDLESS_IF,
                 expr.span,
-                "this if branch is empty",
+                "this `if` branch is empty",
                 "you can remove it",
-                format!("{snippet};"),
-                Applicability::MachineApplicable,
+                if if_expr.can_have_side_effects() {
+                    format!("{snippet};")
+                } else {
+                    String::new()
+                },
+                app,
             );
         }
     }
 }
+
+/// Returns true if any `Expr` contained within this `Expr` is a `Let`, else false.
+///
+/// Really wish `Expr` had a `walk` method...
+fn is_any_if_let(expr: &Expr<'_>) -> bool {
+    let mut v = IsAnyLetVisitor(false);
+
+    v.visit_expr(expr);
+    v.0
+}
+
+struct IsAnyLetVisitor(bool);
+
+impl Visitor<'_> for IsAnyLetVisitor {
+    fn visit_expr(&mut self, expr: &Expr<'_>) {
+        if matches!(expr.kind, ExprKind::Let(..)) {
+            self.0 = true;
+        }
+
+        walk_expr(self, expr);
+    }
+}
diff --git a/tests/ui/needless_if.fixed b/tests/ui/needless_if.fixed
index 7587a397dc9..2abde2ad422 100644
--- a/tests/ui/needless_if.fixed
+++ b/tests/ui/needless_if.fixed
@@ -1,11 +1,13 @@
 //@run-rustfix
 //@aux-build:proc_macros.rs
+#![feature(let_chains)]
 #![allow(
     clippy::blocks_in_if_conditions,
     clippy::if_same_then_else,
     clippy::ifs_same_cond,
     clippy::needless_else,
     clippy::no_effect,
+    clippy::nonminimal_bool,
     unused
 )]
 #![warn(clippy::needless_if)]
@@ -14,21 +16,39 @@ extern crate proc_macros;
 use proc_macros::external;
 use proc_macros::with_span;
 
+fn no_side_effects() -> bool {
+    true
+}
+
+fn has_side_effects(a: &mut u32) -> bool {
+    *a = 1;
+    true
+}
+
 fn main() {
     // Lint
-    (true);
+    
+    // Do not remove the condition
+    no_side_effects();
+    let mut x = 0;
+    has_side_effects(&mut x);
+    assert_eq!(x, 1);
     // Do not lint
     if (true) {
     } else {
     }
+    {
+        return;
+    };
     // Do not lint if `else if` is present
     if (true) {
     } else if (true) {
     }
-    // Ensure clippy does not bork this up, other cases should be added
-    {
-        return;
-    };
+    // Do not lint if any `let` is present
+    if let true = true {}
+    if let true = true && true {}
+    if true && let true = true {}
+    if { if let true = true && true { true } else { false } } && true {}
     external! { if (true) {} }
     with_span! {
         span
diff --git a/tests/ui/needless_if.rs b/tests/ui/needless_if.rs
index 3006995e09d..1608d261a36 100644
--- a/tests/ui/needless_if.rs
+++ b/tests/ui/needless_if.rs
@@ -1,11 +1,13 @@
 //@run-rustfix
 //@aux-build:proc_macros.rs
+#![feature(let_chains)]
 #![allow(
     clippy::blocks_in_if_conditions,
     clippy::if_same_then_else,
     clippy::ifs_same_cond,
     clippy::needless_else,
     clippy::no_effect,
+    clippy::nonminimal_bool,
     unused
 )]
 #![warn(clippy::needless_if)]
@@ -14,21 +16,42 @@ extern crate proc_macros;
 use proc_macros::external;
 use proc_macros::with_span;
 
+fn no_side_effects() -> bool {
+    true
+}
+
+fn has_side_effects(a: &mut u32) -> bool {
+    *a = 1;
+    true
+}
+
 fn main() {
     // Lint
     if (true) {}
+    // Do not remove the condition
+    if no_side_effects() {}
+    let mut x = 0;
+    if has_side_effects(&mut x) {}
+    assert_eq!(x, 1);
     // Do not lint
     if (true) {
     } else {
     }
+    if {
+        return;
+    } {}
     // Do not lint if `else if` is present
     if (true) {
     } else if (true) {
     }
-    // Ensure clippy does not bork this up, other cases should be added
+    // Do not lint if any `let` is present
+    if let true = true {}
+    if let true = true && true {}
+    if true && let true = true {}
     if {
-        return;
-    } {}
+        if let true = true && true { true } else { false }
+    } && true
+    {}
     external! { if (true) {} }
     with_span! {
         span
diff --git a/tests/ui/needless_if.stderr b/tests/ui/needless_if.stderr
index bbb2a035668..4236b0053eb 100644
--- a/tests/ui/needless_if.stderr
+++ b/tests/ui/needless_if.stderr
@@ -1,13 +1,25 @@
-error: this if branch is empty
-  --> $DIR/needless_if.rs:19:5
+error: this `if` branch is empty
+  --> $DIR/needless_if.rs:30:5
    |
 LL |     if (true) {}
-   |     ^^^^^^^^^^^^ help: you can remove it: `(true);`
+   |     ^^^^^^^^^^^^ help: you can remove it
    |
    = note: `-D clippy::needless-if` implied by `-D warnings`
 
-error: this if branch is empty
-  --> $DIR/needless_if.rs:29:5
+error: this `if` branch is empty
+  --> $DIR/needless_if.rs:32:5
+   |
+LL |     if no_side_effects() {}
+   |     ^^^^^^^^^^^^^^^^^^^^^^^ help: you can remove it: `no_side_effects();`
+
+error: this `if` branch is empty
+  --> $DIR/needless_if.rs:34:5
+   |
+LL |     if has_side_effects(&mut x) {}
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: you can remove it: `has_side_effects(&mut x);`
+
+error: this `if` branch is empty
+  --> $DIR/needless_if.rs:40:5
    |
 LL | /     if {
 LL | |         return;
@@ -21,5 +33,5 @@ LL +         return;
 LL +     };
    |
 
-error: aborting due to 2 previous errors
+error: aborting due to 4 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 108c04acf0bdb90e68ec7c12e86c5fbb21548061 Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Sun, 11 Jun 2023 09:43:26 -0500
Subject: Stop visiting once it's found `Let`

---
 clippy_lints/src/needless_if.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/needless_if.rs b/clippy_lints/src/needless_if.rs
index b118516e09b..dbffbd6f0d3 100644
--- a/clippy_lints/src/needless_if.rs
+++ b/clippy_lints/src/needless_if.rs
@@ -96,8 +96,8 @@ impl Visitor<'_> for IsAnyLetVisitor {
     fn visit_expr(&mut self, expr: &Expr<'_>) {
         if matches!(expr.kind, ExprKind::Let(..)) {
             self.0 = true;
+        } else {
+            walk_expr(self, expr);
         }
-
-        walk_expr(self, expr);
     }
 }
-- 
cgit 1.4.1-3-g733a5


From 7280ad9f7b43755703610ed13dc60a58144a1a0f Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Sun, 11 Jun 2023 23:54:48 +0200
Subject: [`redundant_closure_call`]: handle nested closures

---
 clippy_lints/src/lib.rs                        |   1 -
 clippy_lints/src/redundant_closure_call.rs     | 163 ++++++++++++++++++-------
 tests/ui/redundant_closure_call_fixable.fixed  |  40 ++++++
 tests/ui/redundant_closure_call_fixable.rs     |  40 ++++++
 tests/ui/redundant_closure_call_fixable.stderr |  50 ++++++--
 5 files changed, 243 insertions(+), 51 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 2f5932104c1..3e8d6af5302 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -791,7 +791,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_early_pass(|| Box::new(int_plus_one::IntPlusOne));
     store.register_early_pass(|| Box::new(formatting::Formatting));
     store.register_early_pass(|| Box::new(misc_early::MiscEarlyLints));
-    store.register_early_pass(|| Box::new(redundant_closure_call::RedundantClosureCall));
     store.register_late_pass(|_| Box::new(redundant_closure_call::RedundantClosureCall));
     store.register_early_pass(|| Box::new(unused_unit::UnusedUnit));
     store.register_late_pass(|_| Box::new(returns::Return));
diff --git a/clippy_lints/src/redundant_closure_call.rs b/clippy_lints/src/redundant_closure_call.rs
index 2a42e73488f..4e1ffc2fe37 100644
--- a/clippy_lints/src/redundant_closure_call.rs
+++ b/clippy_lints/src/redundant_closure_call.rs
@@ -1,14 +1,14 @@
+use crate::rustc_lint::LintContext;
 use clippy_utils::diagnostics::{span_lint, span_lint_and_then};
+use clippy_utils::get_parent_expr;
 use clippy_utils::sugg::Sugg;
 use if_chain::if_chain;
-use rustc_ast::ast;
-use rustc_ast::visit as ast_visit;
-use rustc_ast::visit::Visitor as AstVisitor;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_hir::intravisit as hir_visit;
 use rustc_hir::intravisit::Visitor as HirVisitor;
-use rustc_lint::{EarlyContext, EarlyLintPass, LateContext, LateLintPass, LintContext};
+use rustc_hir::intravisit::Visitor;
+use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::nested_filter;
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -51,59 +51,136 @@ impl ReturnVisitor {
     }
 }
 
-impl<'ast> ast_visit::Visitor<'ast> for ReturnVisitor {
-    fn visit_expr(&mut self, ex: &'ast ast::Expr) {
-        if let ast::ExprKind::Ret(_) | ast::ExprKind::Try(_) = ex.kind {
+impl<'tcx> Visitor<'tcx> for ReturnVisitor {
+    fn visit_expr(&mut self, ex: &'tcx hir::Expr<'tcx>) {
+        if let hir::ExprKind::Ret(_) | hir::ExprKind::Match(.., hir::MatchSource::TryDesugar) = ex.kind {
             self.found_return = true;
         }
 
-        ast_visit::walk_expr(self, ex);
+        hir_visit::walk_expr(self, ex);
     }
 }
 
-impl EarlyLintPass for RedundantClosureCall {
-    fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &ast::Expr) {
+/// Checks if the body is owned by an async closure
+fn is_async_closure(body: &hir::Body<'_>) -> bool {
+    if let hir::ExprKind::Closure(closure) = body.value.kind
+        && let [resume_ty] = closure.fn_decl.inputs
+        && let hir::TyKind::Path(hir::QPath::LangItem(hir::LangItem::ResumeTy, ..)) = resume_ty.kind
+    {
+        true
+    } else {
+        false
+    }
+}
+
+/// Tries to find the innermost closure:
+/// ```rust
+/// (|| || || || 42)()()()()
+///  ^^^^^^^^^^^^^^          given this nested closure expression
+///           ^^^^^          we want to return this closure
+/// ```
+/// It also has a parameter for how many steps to go in at most, so as to
+/// not take more closures than there are calls.
+fn find_innermost_closure<'tcx>(
+    cx: &LateContext<'tcx>,
+    mut expr: &'tcx hir::Expr<'tcx>,
+    mut steps: usize,
+) -> Option<(&'tcx hir::Expr<'tcx>, &'tcx hir::FnDecl<'tcx>, hir::IsAsync)> {
+    let mut data = None;
+
+    while let hir::ExprKind::Closure(closure) = expr.kind
+        && let body = cx.tcx.hir().body(closure.body)
+        && {
+            let mut visitor = ReturnVisitor::new();
+            visitor.visit_expr(body.value);
+            !visitor.found_return
+        }
+        && steps > 0
+    {
+        expr = body.value;
+        data = Some((body.value, closure.fn_decl, if is_async_closure(body) {
+            hir::IsAsync::Async
+        } else {
+            hir::IsAsync::NotAsync
+        }));
+        steps -= 1;
+    }
+
+    data
+}
+
+/// "Walks up" the chain of calls to find the outermost call expression, and returns the depth:
+/// ```rust
+/// (|| || || 3)()()()
+///                ^^      this is the call expression we were given
+///                    ^^  this is what we want to return (and the depth is 3)
+/// ```
+fn get_parent_call_exprs<'tcx>(
+    cx: &LateContext<'tcx>,
+    mut expr: &'tcx hir::Expr<'tcx>,
+) -> (&'tcx hir::Expr<'tcx>, usize) {
+    let mut depth = 1;
+    while let Some(parent) = get_parent_expr(cx, expr)
+        && let hir::ExprKind::Call(recv, _) = parent.kind
+        && let hir::ExprKind::Call(..) = recv.kind
+    {
+        expr = parent;
+        depth += 1;
+    }
+    (expr, depth)
+}
+
+impl<'tcx> LateLintPass<'tcx> for RedundantClosureCall {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'tcx>) {
         if in_external_macro(cx.sess(), expr.span) {
             return;
         }
-        if_chain! {
-            if let ast::ExprKind::Call(ref paren, _) = expr.kind;
-            if let ast::ExprKind::Paren(ref closure) = paren.kind;
-            if let ast::ExprKind::Closure(box ast::Closure { ref asyncness, ref fn_decl, ref body, .. }) = closure.kind;
-            then {
-                let mut visitor = ReturnVisitor::new();
-                visitor.visit_expr(body);
-                if !visitor.found_return {
-                    span_lint_and_then(
-                        cx,
-                        REDUNDANT_CLOSURE_CALL,
-                        expr.span,
-                        "try not to call a closure in the expression where it is declared",
-                        |diag| {
-                            if fn_decl.inputs.is_empty() {
-                                let mut app = Applicability::MachineApplicable;
-                                let mut hint = Sugg::ast(cx, body, "..", closure.span.ctxt(), &mut app);
-
-                                if asyncness.is_async() {
-                                    // `async x` is a syntax error, so it becomes `async { x }`
-                                    if !matches!(body.kind, ast::ExprKind::Block(_, _)) {
-                                        hint = hint.blockify();
-                                    }
-
-                                    hint = hint.asyncify();
-                                }
-
-                                diag.span_suggestion(expr.span, "try doing something like", hint.to_string(), app);
+
+        if let hir::ExprKind::Call(recv, _) = expr.kind
+            // don't lint if the receiver is a call, too. 
+            // we do this in order to prevent linting multiple times; consider:
+            // `(|| || 1)()()`
+            //           ^^  we only want to lint for this call (but we walk up the calls to consider both calls).
+            // without this check, we'd end up linting twice.
+            && !matches!(recv.kind, hir::ExprKind::Call(..))
+            && let (full_expr, call_depth) = get_parent_call_exprs(cx, expr)
+            && let Some((body, fn_decl, generator_kind)) = find_innermost_closure(cx, recv, call_depth)
+        {
+            span_lint_and_then(
+                cx,
+                REDUNDANT_CLOSURE_CALL,
+                full_expr.span,
+                "try not to call a closure in the expression where it is declared",
+                |diag| {
+                    if fn_decl.inputs.is_empty() {
+                        let mut applicability = Applicability::MachineApplicable;
+                        let mut hint = Sugg::hir_with_context(cx, body, full_expr.span.ctxt(), "..", &mut applicability);
+
+                        if generator_kind.is_async()
+                            && let hir::ExprKind::Closure(closure) = body.kind
+                        {
+                            let async_closure_body = cx.tcx.hir().body(closure.body);
+
+                            // `async x` is a syntax error, so it becomes `async { x }`
+                            if !matches!(async_closure_body.value.kind, hir::ExprKind::Block(_, _)) {
+                                hint = hint.blockify();
                             }
-                        },
-                    );
+
+                            hint = hint.asyncify();
+                        }
+
+                        diag.span_suggestion(
+                            full_expr.span,
+                            "try doing something like",
+                            hint.maybe_par(),
+                            applicability
+                        );
+                    }
                 }
-            }
+            );
         }
     }
-}
 
-impl<'tcx> LateLintPass<'tcx> for RedundantClosureCall {
     fn check_block(&mut self, cx: &LateContext<'tcx>, block: &'tcx hir::Block<'_>) {
         fn count_closure_usage<'tcx>(
             cx: &LateContext<'tcx>,
diff --git a/tests/ui/redundant_closure_call_fixable.fixed b/tests/ui/redundant_closure_call_fixable.fixed
index 61aed2733fe..1a2c1e59261 100644
--- a/tests/ui/redundant_closure_call_fixable.fixed
+++ b/tests/ui/redundant_closure_call_fixable.fixed
@@ -3,6 +3,7 @@
 #![feature(async_closure)]
 #![warn(clippy::redundant_closure_call)]
 #![allow(clippy::redundant_async_block)]
+#![allow(clippy::type_complexity)]
 #![allow(unused)]
 
 async fn something() -> u32 {
@@ -38,4 +39,43 @@ fn main() {
         };
     }
     m2!();
+    issue9956();
+}
+
+fn issue9956() {
+    assert_eq!(43, 42);
+
+    // ... and some more interesting cases I've found while implementing the fix
+
+    // not actually immediately calling the closure:
+    let a = (|| 42);
+    dbg!(a());
+
+    // immediately calling it inside of a macro
+    dbg!(42);
+
+    // immediately calling only one closure, so we can't remove the other ones
+    let a = (|| || 123);
+    dbg!(a()());
+
+    // nested async closures
+    let a = async { 1 };
+    let h = async { a.await };
+
+    // macro expansion tests
+    macro_rules! echo {
+        ($e:expr) => {
+            $e
+        };
+    }
+    let a = 1;
+    assert_eq!(a, 1);
+    let a = 123;
+    assert_eq!(a, 123);
+
+    // chaining calls, but not closures
+    fn x() -> fn() -> fn() -> fn() -> i32 {
+        || || || 42
+    }
+    let _ = x()()()();
 }
diff --git a/tests/ui/redundant_closure_call_fixable.rs b/tests/ui/redundant_closure_call_fixable.rs
index 56b28663539..fec46652189 100644
--- a/tests/ui/redundant_closure_call_fixable.rs
+++ b/tests/ui/redundant_closure_call_fixable.rs
@@ -3,6 +3,7 @@
 #![feature(async_closure)]
 #![warn(clippy::redundant_closure_call)]
 #![allow(clippy::redundant_async_block)]
+#![allow(clippy::type_complexity)]
 #![allow(unused)]
 
 async fn something() -> u32 {
@@ -38,4 +39,43 @@ fn main() {
         };
     }
     m2!();
+    issue9956();
+}
+
+fn issue9956() {
+    assert_eq!((|| || 43)()(), 42);
+
+    // ... and some more interesting cases I've found while implementing the fix
+
+    // not actually immediately calling the closure:
+    let a = (|| 42);
+    dbg!(a());
+
+    // immediately calling it inside of a macro
+    dbg!((|| 42)());
+
+    // immediately calling only one closure, so we can't remove the other ones
+    let a = (|| || || 123)();
+    dbg!(a()());
+
+    // nested async closures
+    let a = (|| || || || async || 1)()()()()();
+    let h = async { a.await };
+
+    // macro expansion tests
+    macro_rules! echo {
+        ($e:expr) => {
+            $e
+        };
+    }
+    let a = (|| echo!(|| echo!(|| 1)))()()();
+    assert_eq!(a, 1);
+    let a = (|| echo!((|| 123)))()();
+    assert_eq!(a, 123);
+
+    // chaining calls, but not closures
+    fn x() -> fn() -> fn() -> fn() -> i32 {
+        || || || 42
+    }
+    let _ = x()()()();
 }
diff --git a/tests/ui/redundant_closure_call_fixable.stderr b/tests/ui/redundant_closure_call_fixable.stderr
index 8a1f0771659..351da54ef31 100644
--- a/tests/ui/redundant_closure_call_fixable.stderr
+++ b/tests/ui/redundant_closure_call_fixable.stderr
@@ -1,5 +1,5 @@
 error: try not to call a closure in the expression where it is declared
-  --> $DIR/redundant_closure_call_fixable.rs:17:13
+  --> $DIR/redundant_closure_call_fixable.rs:18:13
    |
 LL |     let a = (|| 42)();
    |             ^^^^^^^^^ help: try doing something like: `42`
@@ -7,7 +7,7 @@ LL |     let a = (|| 42)();
    = note: `-D clippy::redundant-closure-call` implied by `-D warnings`
 
 error: try not to call a closure in the expression where it is declared
-  --> $DIR/redundant_closure_call_fixable.rs:18:13
+  --> $DIR/redundant_closure_call_fixable.rs:19:13
    |
 LL |       let b = (async || {
    |  _____________^
@@ -27,7 +27,7 @@ LL ~     };
    |
 
 error: try not to call a closure in the expression where it is declared
-  --> $DIR/redundant_closure_call_fixable.rs:23:13
+  --> $DIR/redundant_closure_call_fixable.rs:24:13
    |
 LL |       let c = (|| {
    |  _____________^
@@ -47,13 +47,13 @@ LL ~     };
    |
 
 error: try not to call a closure in the expression where it is declared
-  --> $DIR/redundant_closure_call_fixable.rs:28:13
+  --> $DIR/redundant_closure_call_fixable.rs:29:13
    |
 LL |     let d = (async || something().await)();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try doing something like: `async { something().await }`
 
 error: try not to call a closure in the expression where it is declared
-  --> $DIR/redundant_closure_call_fixable.rs:37:13
+  --> $DIR/redundant_closure_call_fixable.rs:38:13
    |
 LL |             (|| m!())()
    |             ^^^^^^^^^^^ help: try doing something like: `m!()`
@@ -64,7 +64,7 @@ LL |     m2!();
    = note: this error originates in the macro `m2` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: try not to call a closure in the expression where it is declared
-  --> $DIR/redundant_closure_call_fixable.rs:32:13
+  --> $DIR/redundant_closure_call_fixable.rs:33:13
    |
 LL |             (|| 0)()
    |             ^^^^^^^^ help: try doing something like: `0`
@@ -74,5 +74,41 @@ LL |     m2!();
    |
    = note: this error originates in the macro `m` which comes from the expansion of the macro `m2` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to 6 previous errors
+error: try not to call a closure in the expression where it is declared
+  --> $DIR/redundant_closure_call_fixable.rs:46:16
+   |
+LL |     assert_eq!((|| || 43)()(), 42);
+   |                ^^^^^^^^^^^^^^ help: try doing something like: `43`
+
+error: try not to call a closure in the expression where it is declared
+  --> $DIR/redundant_closure_call_fixable.rs:55:10
+   |
+LL |     dbg!((|| 42)());
+   |          ^^^^^^^^^ help: try doing something like: `42`
+
+error: try not to call a closure in the expression where it is declared
+  --> $DIR/redundant_closure_call_fixable.rs:58:13
+   |
+LL |     let a = (|| || || 123)();
+   |             ^^^^^^^^^^^^^^^^ help: try doing something like: `(|| || 123)`
+
+error: try not to call a closure in the expression where it is declared
+  --> $DIR/redundant_closure_call_fixable.rs:62:13
+   |
+LL |     let a = (|| || || || async || 1)()()()()();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try doing something like: `async { 1 }`
+
+error: try not to call a closure in the expression where it is declared
+  --> $DIR/redundant_closure_call_fixable.rs:71:13
+   |
+LL |     let a = (|| echo!(|| echo!(|| 1)))()()();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try doing something like: `1`
+
+error: try not to call a closure in the expression where it is declared
+  --> $DIR/redundant_closure_call_fixable.rs:73:13
+   |
+LL |     let a = (|| echo!((|| 123)))()();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^ help: try doing something like: `123`
+
+error: aborting due to 12 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From e305b0730fedfe3fa8b54dbb285f498a3277baa9 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Mon, 12 Jun 2023 00:20:54 +0200
Subject: fix docs

---
 clippy_lints/src/redundant_closure_call.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/redundant_closure_call.rs b/clippy_lints/src/redundant_closure_call.rs
index 4e1ffc2fe37..d979087a6d7 100644
--- a/clippy_lints/src/redundant_closure_call.rs
+++ b/clippy_lints/src/redundant_closure_call.rs
@@ -74,7 +74,7 @@ fn is_async_closure(body: &hir::Body<'_>) -> bool {
 }
 
 /// Tries to find the innermost closure:
-/// ```rust
+/// ```rust,ignore
 /// (|| || || || 42)()()()()
 ///  ^^^^^^^^^^^^^^          given this nested closure expression
 ///           ^^^^^          we want to return this closure
@@ -110,10 +110,10 @@ fn find_innermost_closure<'tcx>(
 }
 
 /// "Walks up" the chain of calls to find the outermost call expression, and returns the depth:
-/// ```rust
+/// ```rust,ignore
 /// (|| || || 3)()()()
-///                ^^      this is the call expression we were given
-///                    ^^  this is what we want to return (and the depth is 3)
+///             ^^      this is the call expression we were given
+///                 ^^  this is what we want to return (and the depth is 3)
 /// ```
 fn get_parent_call_exprs<'tcx>(
     cx: &LateContext<'tcx>,
-- 
cgit 1.4.1-3-g733a5


From c9daec2585c464f2e7d37756c341b217ca795bde Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Mon, 12 Jun 2023 02:43:23 +0200
Subject: [`unnecessary_fold`]: suggest turbofish if necessary

---
 clippy_lints/src/methods/unnecessary_fold.rs | 124 ++++++++++++++++++++++++---
 tests/ui/unnecessary_fold.fixed              |  24 ++++++
 tests/ui/unnecessary_fold.rs                 |  24 ++++++
 tests/ui/unnecessary_fold.stderr             |  56 +++++++++++-
 4 files changed, 217 insertions(+), 11 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/unnecessary_fold.rs b/clippy_lints/src/methods/unnecessary_fold.rs
index 5a3d12fd790..de29d99cf8d 100644
--- a/clippy_lints/src/methods/unnecessary_fold.rs
+++ b/clippy_lints/src/methods/unnecessary_fold.rs
@@ -7,10 +7,74 @@ use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_hir::PatKind;
 use rustc_lint::LateContext;
+use rustc_middle::ty;
 use rustc_span::{source_map::Span, sym};
 
 use super::UNNECESSARY_FOLD;
 
+/// No turbofish needed in any case.
+fn no_turbofish(_: &LateContext<'_>, _: &hir::Expr<'_>) -> bool {
+    false
+}
+
+/// Turbofish (`::<T>`) may be needed, but can be omitted if we are certain
+/// that the type can be inferred from usage.
+fn turbofish_if_not_inferred(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> bool {
+    let parent = cx.tcx.hir().get_parent(expr.hir_id);
+
+    // some common cases where turbofish isn't needed:
+    // - assigned to a local variable with a type annotation
+    if let hir::Node::Local(local) = parent
+        && local.ty.is_some()
+    {
+        return false;
+    }
+
+    // - part of a function call argument, can be inferred from the function signature (provided that
+    //   the parameter is not a generic type parameter)
+    if let hir::Node::Expr(parent_expr) = parent
+        && let hir::ExprKind::Call(recv, args) = parent_expr.kind
+        && let hir::ExprKind::Path(ref qpath) = recv.kind
+        && let Some(fn_def_id) = cx.qpath_res(qpath, recv.hir_id).opt_def_id()
+        && let fn_sig = cx.tcx.fn_sig(fn_def_id).skip_binder().skip_binder()
+        && let Some(arg_pos) = args.iter().position(|arg| arg.hir_id == expr.hir_id)
+        && let Some(ty) = fn_sig.inputs().get(arg_pos)
+        && !matches!(ty.kind(), ty::Param(_))
+    {
+        return false;
+    }
+
+    // if it's neither of those, stay on the safe side and suggest turbofish,
+    // even if it could work!
+    true
+}
+
+#[derive(Copy, Clone)]
+struct Replacement {
+    method_name: &'static str,
+    has_args: bool,
+    requires_turbofish: fn(&LateContext<'_>, &hir::Expr<'_>) -> bool,
+}
+impl Replacement {
+    /// `any(f)`, `all(f)`
+    pub fn non_generic(method_name: &'static str) -> Self {
+        Self {
+            method_name,
+            has_args: true,
+            requires_turbofish: no_turbofish,
+        }
+    }
+
+    /// `sum::<T>()`, `product::<T>()`
+    pub fn generic(method_name: &'static str) -> Self {
+        Self {
+            method_name,
+            has_args: false,
+            requires_turbofish: turbofish_if_not_inferred,
+        }
+    }
+}
+
 pub(super) fn check(
     cx: &LateContext<'_>,
     expr: &hir::Expr<'_>,
@@ -24,8 +88,7 @@ pub(super) fn check(
         acc: &hir::Expr<'_>,
         fold_span: Span,
         op: hir::BinOpKind,
-        replacement_method_name: &str,
-        replacement_has_args: bool,
+        replacement: Replacement,
     ) {
         if_chain! {
             // Extract the body of the closure passed to fold
@@ -43,18 +106,27 @@ pub(super) fn check(
             if let PatKind::Binding(_, second_arg_id, second_arg_ident, _) = strip_pat_refs(param_b.pat).kind;
 
             if path_to_local_id(left_expr, first_arg_id);
-            if replacement_has_args || path_to_local_id(right_expr, second_arg_id);
+            if replacement.has_args || path_to_local_id(right_expr, second_arg_id);
 
             then {
                 let mut applicability = Applicability::MachineApplicable;
-                let sugg = if replacement_has_args {
+
+                let turbofish = if (replacement.requires_turbofish)(cx, expr) {
+                    format!("::<{}>", cx.typeck_results().expr_ty_adjusted(right_expr).peel_refs())
+                } else {
+                    String::new()
+                };
+
+                let sugg = if replacement.has_args {
                     format!(
-                        "{replacement_method_name}(|{second_arg_ident}| {r})",
+                        "{method}{turbofish}(|{second_arg_ident}| {r})",
+                        method = replacement.method_name,
                         r = snippet_with_applicability(cx, right_expr.span, "EXPR", &mut applicability),
                     )
                 } else {
                     format!(
-                        "{replacement_method_name}()",
+                        "{method}{turbofish}()",
+                        method = replacement.method_name,
                     )
                 };
 
@@ -80,11 +152,43 @@ pub(super) fn check(
     // Check if the first argument to .fold is a suitable literal
     if let hir::ExprKind::Lit(lit) = init.kind {
         match lit.node {
-            ast::LitKind::Bool(false) => check_fold_with_op(cx, expr, acc, fold_span, hir::BinOpKind::Or, "any", true),
-            ast::LitKind::Bool(true) => check_fold_with_op(cx, expr, acc, fold_span, hir::BinOpKind::And, "all", true),
-            ast::LitKind::Int(0, _) => check_fold_with_op(cx, expr, acc, fold_span, hir::BinOpKind::Add, "sum", false),
+            ast::LitKind::Bool(false) => {
+                check_fold_with_op(
+                    cx,
+                    expr,
+                    acc,
+                    fold_span,
+                    hir::BinOpKind::Or,
+                    Replacement::non_generic("any"),
+                );
+            },
+            ast::LitKind::Bool(true) => {
+                check_fold_with_op(
+                    cx,
+                    expr,
+                    acc,
+                    fold_span,
+                    hir::BinOpKind::And,
+                    Replacement::non_generic("all"),
+                );
+            },
+            ast::LitKind::Int(0, _) => check_fold_with_op(
+                cx,
+                expr,
+                acc,
+                fold_span,
+                hir::BinOpKind::Add,
+                Replacement::generic("sum"),
+            ),
             ast::LitKind::Int(1, _) => {
-                check_fold_with_op(cx, expr, acc, fold_span, hir::BinOpKind::Mul, "product", false);
+                check_fold_with_op(
+                    cx,
+                    expr,
+                    acc,
+                    fold_span,
+                    hir::BinOpKind::Mul,
+                    Replacement::generic("product"),
+                );
             },
             _ => (),
         }
diff --git a/tests/ui/unnecessary_fold.fixed b/tests/ui/unnecessary_fold.fixed
index 2bed14973ca..bd1d4a152ae 100644
--- a/tests/ui/unnecessary_fold.fixed
+++ b/tests/ui/unnecessary_fold.fixed
@@ -49,4 +49,28 @@ fn unnecessary_fold_over_multiple_lines() {
         .any(|x| x > 2);
 }
 
+fn issue10000() {
+    use std::collections::HashMap;
+    use std::hash::BuildHasher;
+
+    fn anything<T>(_: T) {}
+    fn num(_: i32) {}
+    fn smoketest_map<S: BuildHasher>(mut map: HashMap<i32, i32, S>) {
+        map.insert(0, 0);
+        assert_eq!(map.values().sum::<i32>(), 0);
+
+        // more cases:
+        let _ = map.values().sum::<i32>();
+        let _ = map.values().product::<i32>();
+        let _: i32 = map.values().sum();
+        let _: i32 = map.values().product();
+        anything(map.values().sum::<i32>());
+        anything(map.values().product::<i32>());
+        num(map.values().sum());
+        num(map.values().product());
+    }
+
+    smoketest_map(HashMap::new());
+}
+
 fn main() {}
diff --git a/tests/ui/unnecessary_fold.rs b/tests/ui/unnecessary_fold.rs
index a3cec8ea3d5..d27cc460c44 100644
--- a/tests/ui/unnecessary_fold.rs
+++ b/tests/ui/unnecessary_fold.rs
@@ -49,4 +49,28 @@ fn unnecessary_fold_over_multiple_lines() {
         .fold(false, |acc, x| acc || x > 2);
 }
 
+fn issue10000() {
+    use std::collections::HashMap;
+    use std::hash::BuildHasher;
+
+    fn anything<T>(_: T) {}
+    fn num(_: i32) {}
+    fn smoketest_map<S: BuildHasher>(mut map: HashMap<i32, i32, S>) {
+        map.insert(0, 0);
+        assert_eq!(map.values().fold(0, |x, y| x + y), 0);
+
+        // more cases:
+        let _ = map.values().fold(0, |x, y| x + y);
+        let _ = map.values().fold(1, |x, y| x * y);
+        let _: i32 = map.values().fold(0, |x, y| x + y);
+        let _: i32 = map.values().fold(1, |x, y| x * y);
+        anything(map.values().fold(0, |x, y| x + y));
+        anything(map.values().fold(1, |x, y| x * y));
+        num(map.values().fold(0, |x, y| x + y));
+        num(map.values().fold(1, |x, y| x * y));
+    }
+
+    smoketest_map(HashMap::new());
+}
+
 fn main() {}
diff --git a/tests/ui/unnecessary_fold.stderr b/tests/ui/unnecessary_fold.stderr
index 22c44588ab7..98979f7477f 100644
--- a/tests/ui/unnecessary_fold.stderr
+++ b/tests/ui/unnecessary_fold.stderr
@@ -36,5 +36,59 @@ error: this `.fold` can be written more succinctly using another method
 LL |         .fold(false, |acc, x| acc || x > 2);
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `any(|x| x > 2)`
 
-error: aborting due to 6 previous errors
+error: this `.fold` can be written more succinctly using another method
+  --> $DIR/unnecessary_fold.rs:60:33
+   |
+LL |         assert_eq!(map.values().fold(0, |x, y| x + y), 0);
+   |                                 ^^^^^^^^^^^^^^^^^^^^^ help: try: `sum::<i32>()`
+
+error: this `.fold` can be written more succinctly using another method
+  --> $DIR/unnecessary_fold.rs:63:30
+   |
+LL |         let _ = map.values().fold(0, |x, y| x + y);
+   |                              ^^^^^^^^^^^^^^^^^^^^^ help: try: `sum::<i32>()`
+
+error: this `.fold` can be written more succinctly using another method
+  --> $DIR/unnecessary_fold.rs:64:30
+   |
+LL |         let _ = map.values().fold(1, |x, y| x * y);
+   |                              ^^^^^^^^^^^^^^^^^^^^^ help: try: `product::<i32>()`
+
+error: this `.fold` can be written more succinctly using another method
+  --> $DIR/unnecessary_fold.rs:65:35
+   |
+LL |         let _: i32 = map.values().fold(0, |x, y| x + y);
+   |                                   ^^^^^^^^^^^^^^^^^^^^^ help: try: `sum()`
+
+error: this `.fold` can be written more succinctly using another method
+  --> $DIR/unnecessary_fold.rs:66:35
+   |
+LL |         let _: i32 = map.values().fold(1, |x, y| x * y);
+   |                                   ^^^^^^^^^^^^^^^^^^^^^ help: try: `product()`
+
+error: this `.fold` can be written more succinctly using another method
+  --> $DIR/unnecessary_fold.rs:67:31
+   |
+LL |         anything(map.values().fold(0, |x, y| x + y));
+   |                               ^^^^^^^^^^^^^^^^^^^^^ help: try: `sum::<i32>()`
+
+error: this `.fold` can be written more succinctly using another method
+  --> $DIR/unnecessary_fold.rs:68:31
+   |
+LL |         anything(map.values().fold(1, |x, y| x * y));
+   |                               ^^^^^^^^^^^^^^^^^^^^^ help: try: `product::<i32>()`
+
+error: this `.fold` can be written more succinctly using another method
+  --> $DIR/unnecessary_fold.rs:69:26
+   |
+LL |         num(map.values().fold(0, |x, y| x + y));
+   |                          ^^^^^^^^^^^^^^^^^^^^^ help: try: `sum()`
+
+error: this `.fold` can be written more succinctly using another method
+  --> $DIR/unnecessary_fold.rs:70:26
+   |
+LL |         num(map.values().fold(1, |x, y| x * y));
+   |                          ^^^^^^^^^^^^^^^^^^^^^ help: try: `product()`
+
+error: aborting due to 15 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 52cfc997afbaff3b0e98f82a06b90c8230c9225b Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Fri, 9 Jun 2023 13:33:30 -0500
Subject: Add lint `single_letter_idents`

---
 CHANGELOG.md                                       |   1 +
 clippy_lints/src/declared_lints.rs                 |   1 +
 clippy_lints/src/lib.rs                            |   7 ++
 clippy_lints/src/single_letter_idents.rs           |  52 +++++++++++
 clippy_lints/src/utils/conf.rs                     |   1 +
 clippy_utils/src/check_proc_macro.rs               |  29 ++++--
 .../toml_unknown_key/conf_unknown_key.stderr       |   2 +
 tests/ui/single_letter_idents.rs                   |  59 ++++++++++++
 tests/ui/single_letter_idents.stderr               | 100 +++++++++++++++++++++
 9 files changed, 246 insertions(+), 6 deletions(-)
 create mode 100644 clippy_lints/src/single_letter_idents.rs
 create mode 100644 tests/ui/single_letter_idents.rs
 create mode 100644 tests/ui/single_letter_idents.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 8a330b35d69..5a03d768fee 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5160,6 +5160,7 @@ Released 2018-09-13
 [`single_char_push_str`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_char_push_str
 [`single_component_path_imports`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_component_path_imports
 [`single_element_loop`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_element_loop
+[`single_letter_idents`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_letter_idents
 [`single_match`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_match
 [`single_match_else`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_match_else
 [`size_of_in_element_count`]: https://rust-lang.github.io/rust-clippy/master/index.html#size_of_in_element_count
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 874c173f709..03c3e153a97 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -567,6 +567,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::significant_drop_tightening::SIGNIFICANT_DROP_TIGHTENING_INFO,
     crate::single_char_lifetime_names::SINGLE_CHAR_LIFETIME_NAMES_INFO,
     crate::single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS_INFO,
+    crate::single_letter_idents::SINGLE_LETTER_IDENTS_INFO,
     crate::size_of_in_element_count::SIZE_OF_IN_ELEMENT_COUNT_INFO,
     crate::size_of_ref::SIZE_OF_REF_INFO,
     crate::slow_vector_initialization::SLOW_VECTOR_INITIALIZATION_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index fd10a9302c0..9b8edc5d77e 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -286,6 +286,7 @@ mod shadow;
 mod significant_drop_tightening;
 mod single_char_lifetime_names;
 mod single_component_path_imports;
+mod single_letter_idents;
 mod size_of_in_element_count;
 mod size_of_ref;
 mod slow_vector_initialization;
@@ -1033,6 +1034,12 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(redundant_type_annotations::RedundantTypeAnnotations));
     store.register_late_pass(|_| Box::new(arc_with_non_send_sync::ArcWithNonSendSync));
     store.register_late_pass(|_| Box::new(needless_if::NeedlessIf));
+    let allowed_idents = conf.allowed_idents.clone();
+    store.register_early_pass(move || {
+        Box::new(single_letter_idents::SingleLetterIdents {
+            allowed_idents: allowed_idents.clone(),
+        })
+    });
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/single_letter_idents.rs b/clippy_lints/src/single_letter_idents.rs
new file mode 100644
index 00000000000..e957b6fec68
--- /dev/null
+++ b/clippy_lints/src/single_letter_idents.rs
@@ -0,0 +1,52 @@
+use clippy_utils::{diagnostics::span_lint, source::snippet};
+use itertools::Itertools;
+use rustc_data_structures::fx::FxHashSet;
+use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
+use rustc_middle::lint::in_external_macro;
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::symbol::Ident;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for idents which comprise of a single letter.
+    ///
+    /// Note: This lint can be very noisy when enabled; it even lints generics! it may be desirable
+    /// to only enable it temporarily.
+    ///
+    /// ### Why is this bad?
+    /// In many cases it's not, but at times it can severely hinder readability. Some codebases may
+    /// wish to disallow this to improve readability.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// for i in collection {
+    ///     let x = i.x;
+    /// }
+    /// ```
+    #[clippy::version = "1.72.0"]
+    pub SINGLE_LETTER_IDENTS,
+    restriction,
+    "disallows idents that can be represented as a char"
+}
+impl_lint_pass!(SingleLetterIdents => [SINGLE_LETTER_IDENTS]);
+
+#[derive(Clone)]
+pub struct SingleLetterIdents {
+    pub allowed_idents: FxHashSet<char>,
+}
+
+impl EarlyLintPass for SingleLetterIdents {
+    fn check_ident(&mut self, cx: &EarlyContext<'_>, ident: Ident) {
+        let str = ident.name.as_str();
+        let chars = str.chars();
+        if let [char, rest @ ..] = chars.collect_vec().as_slice()
+            && rest.is_empty()
+            && self.allowed_idents.get(char).is_none()
+            && !in_external_macro(cx.sess(), ident.span)
+            // Ignore proc macros. Let's implement `WithSearchPat` for early lints someday :)
+            && snippet(cx, ident.span, str) == str
+        {
+            span_lint(cx, SINGLE_LETTER_IDENTS, ident.span, "this ident comprises of a single letter");
+        }
+    }
+}
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 6962299e468..7b5413647c7 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -34,6 +34,7 @@ const DEFAULT_DOC_VALID_IDENTS: &[&str] = &[
     "CamelCase",
 ];
 const DEFAULT_DISALLOWED_NAMES: &[&str] = &["foo", "baz", "quux"];
+const DEFAULT_ALLOWED_IDENTS: &[char] = &['i', 'j', 'x', 'y', 'z', 'n'];
 
 /// Holds information used by `MISSING_ENFORCED_IMPORT_RENAMES` lint.
 #[derive(Clone, Debug, Deserialize)]
diff --git a/clippy_utils/src/check_proc_macro.rs b/clippy_utils/src/check_proc_macro.rs
index bcfac527c8a..c6d0b654f57 100644
--- a/clippy_utils/src/check_proc_macro.rs
+++ b/clippy_utils/src/check_proc_macro.rs
@@ -25,7 +25,7 @@ use rustc_hir::{
 use rustc_lint::{LateContext, LintContext};
 use rustc_middle::ty::TyCtxt;
 use rustc_session::Session;
-use rustc_span::{Span, Symbol};
+use rustc_span::{symbol::Ident, Span, Symbol};
 use rustc_target::spec::abi::Abi;
 
 /// The search pattern to look for. Used by `span_matches_pat`
@@ -344,14 +344,18 @@ fn ty_search_pat(ty: &Ty<'_>) -> (Pat, Pat) {
     }
 }
 
-pub trait WithSearchPat {
+fn ident_search_pat(ident: Ident) -> (Pat, Pat) {
+    (Pat::OwnedStr(ident.name.as_str().to_owned()), Pat::Str(""))
+}
+
+pub trait WithSearchPat<'cx> {
     type Context: LintContext;
     fn search_pat(&self, cx: &Self::Context) -> (Pat, Pat);
     fn span(&self) -> Span;
 }
 macro_rules! impl_with_search_pat {
     ($cx:ident: $ty:ident with $fn:ident $(($tcx:ident))?) => {
-        impl<'cx> WithSearchPat for $ty<'cx> {
+        impl<'cx> WithSearchPat<'cx> for $ty<'cx> {
             type Context = $cx<'cx>;
             #[allow(unused_variables)]
             fn search_pat(&self, cx: &Self::Context) -> (Pat, Pat) {
@@ -372,7 +376,7 @@ impl_with_search_pat!(LateContext: FieldDef with field_def_search_pat);
 impl_with_search_pat!(LateContext: Variant with variant_search_pat);
 impl_with_search_pat!(LateContext: Ty with ty_search_pat);
 
-impl<'cx> WithSearchPat for (&FnKind<'cx>, &Body<'cx>, HirId, Span) {
+impl<'cx> WithSearchPat<'cx> for (&FnKind<'cx>, &Body<'cx>, HirId, Span) {
     type Context = LateContext<'cx>;
 
     fn search_pat(&self, cx: &Self::Context) -> (Pat, Pat) {
@@ -385,7 +389,7 @@ impl<'cx> WithSearchPat for (&FnKind<'cx>, &Body<'cx>, HirId, Span) {
 }
 
 // `Attribute` does not have the `hir` associated lifetime, so we cannot use the macro
-impl<'cx> WithSearchPat for &'cx Attribute {
+impl<'cx> WithSearchPat<'cx> for &'cx Attribute {
     type Context = LateContext<'cx>;
 
     fn search_pat(&self, _cx: &Self::Context) -> (Pat, Pat) {
@@ -397,11 +401,24 @@ impl<'cx> WithSearchPat for &'cx Attribute {
     }
 }
 
+// `Ident` does not have the `hir` associated lifetime, so we cannot use the macro
+impl<'cx> WithSearchPat<'cx> for Ident {
+    type Context = LateContext<'cx>;
+
+    fn search_pat(&self, _cx: &Self::Context) -> (Pat, Pat) {
+        ident_search_pat(*self)
+    }
+
+    fn span(&self) -> Span {
+        self.span
+    }
+}
+
 /// Checks if the item likely came from a proc-macro.
 ///
 /// This should be called after `in_external_macro` and the initial pattern matching of the ast as
 /// it is significantly slower than both of those.
-pub fn is_from_proc_macro<T: WithSearchPat>(cx: &T::Context, item: &T) -> bool {
+pub fn is_from_proc_macro<'cx, T: WithSearchPat<'cx>>(cx: &T::Context, item: &T) -> bool {
     let (start_pat, end_pat) = item.search_pat(cx);
     !span_matches_pat(cx.sess(), item.span(), start_pat, end_pat)
 }
diff --git a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
index c11835f5696..2bc872e07e8 100644
--- a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
+++ b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
@@ -5,6 +5,7 @@ error: error reading Clippy's configuration file: unknown field `foobar`, expect
            allow-print-in-tests
            allow-private-module-inception
            allow-unwrap-in-tests
+           allowed-idents
            allowed-scripts
            arithmetic-side-effects-allowed
            arithmetic-side-effects-allowed-binary
@@ -68,6 +69,7 @@ error: error reading Clippy's configuration file: unknown field `barfoo`, expect
            allow-print-in-tests
            allow-private-module-inception
            allow-unwrap-in-tests
+           allowed-idents
            allowed-scripts
            arithmetic-side-effects-allowed
            arithmetic-side-effects-allowed-binary
diff --git a/tests/ui/single_letter_idents.rs b/tests/ui/single_letter_idents.rs
new file mode 100644
index 00000000000..b33c569d318
--- /dev/null
+++ b/tests/ui/single_letter_idents.rs
@@ -0,0 +1,59 @@
+//@aux-build:proc_macros.rs
+#![allow(nonstandard_style, unused)]
+#![warn(clippy::single_letter_idents)]
+
+extern crate proc_macros;
+use proc_macros::external;
+use proc_macros::with_span;
+
+struct A {
+    a: u32,
+    i: u32,
+    A: u32,
+    I: u32,
+}
+
+struct B(u32);
+
+struct i;
+
+enum C {
+    D,
+    E,
+    F,
+    j,
+}
+
+struct Vec4 {
+    x: u32,
+    y: u32,
+    z: u32,
+    w: u32,
+}
+
+struct AA<T, E>(T, E);
+
+fn main() {
+    // Allowed idents
+    let w = 1;
+    // Ok, not this one
+    // let i = 1;
+    let j = 1;
+    let n = 1;
+    let x = 1;
+    let y = 1;
+    let z = 1;
+
+    for j in 0..1000 {}
+
+    // Do not lint code from external macros
+    external! { for j in 0..1000 {} }
+    // Do not lint code from procedural macros
+    with_span! {
+        span
+        for j in 0..1000 {}
+    }
+}
+
+fn b() {}
+fn owo() {}
diff --git a/tests/ui/single_letter_idents.stderr b/tests/ui/single_letter_idents.stderr
new file mode 100644
index 00000000000..712c1664235
--- /dev/null
+++ b/tests/ui/single_letter_idents.stderr
@@ -0,0 +1,100 @@
+error: this ident comprises of a single letter
+  --> $DIR/single_letter_idents.rs:9:8
+   |
+LL | struct A {
+   |        ^
+   |
+   = note: `-D clippy::single-letter-idents` implied by `-D warnings`
+
+error: this ident comprises of a single letter
+  --> $DIR/single_letter_idents.rs:10:5
+   |
+LL |     a: u32,
+   |     ^
+
+error: this ident comprises of a single letter
+  --> $DIR/single_letter_idents.rs:12:5
+   |
+LL |     A: u32,
+   |     ^
+
+error: this ident comprises of a single letter
+  --> $DIR/single_letter_idents.rs:13:5
+   |
+LL |     I: u32,
+   |     ^
+
+error: this ident comprises of a single letter
+  --> $DIR/single_letter_idents.rs:16:8
+   |
+LL | struct B(u32);
+   |        ^
+
+error: this ident comprises of a single letter
+  --> $DIR/single_letter_idents.rs:20:6
+   |
+LL | enum C {
+   |      ^
+
+error: this ident comprises of a single letter
+  --> $DIR/single_letter_idents.rs:21:5
+   |
+LL |     D,
+   |     ^
+
+error: this ident comprises of a single letter
+  --> $DIR/single_letter_idents.rs:22:5
+   |
+LL |     E,
+   |     ^
+
+error: this ident comprises of a single letter
+  --> $DIR/single_letter_idents.rs:23:5
+   |
+LL |     F,
+   |     ^
+
+error: this ident comprises of a single letter
+  --> $DIR/single_letter_idents.rs:31:5
+   |
+LL |     w: u32,
+   |     ^
+
+error: this ident comprises of a single letter
+  --> $DIR/single_letter_idents.rs:34:11
+   |
+LL | struct AA<T, E>(T, E);
+   |           ^
+
+error: this ident comprises of a single letter
+  --> $DIR/single_letter_idents.rs:34:14
+   |
+LL | struct AA<T, E>(T, E);
+   |              ^
+
+error: this ident comprises of a single letter
+  --> $DIR/single_letter_idents.rs:34:17
+   |
+LL | struct AA<T, E>(T, E);
+   |                 ^
+
+error: this ident comprises of a single letter
+  --> $DIR/single_letter_idents.rs:34:20
+   |
+LL | struct AA<T, E>(T, E);
+   |                    ^
+
+error: this ident comprises of a single letter
+  --> $DIR/single_letter_idents.rs:38:9
+   |
+LL |     let w = 1;
+   |         ^
+
+error: this ident comprises of a single letter
+  --> $DIR/single_letter_idents.rs:58:4
+   |
+LL | fn b() {}
+   |    ^
+
+error: aborting due to 16 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From e2ecb132a5ccf238129acdbaff89bed6023a593e Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Fri, 9 Jun 2023 14:29:34 -0500
Subject: rename the lint

---
 CHANGELOG.md                             |  2 +-
 clippy_lints/src/declared_lints.rs       |  2 +-
 clippy_lints/src/lib.rs                  |  4 +--
 clippy_lints/src/single_char_idents.rs   | 52 ++++++++++++++++++++++++++++++++
 clippy_lints/src/single_letter_idents.rs | 52 --------------------------------
 5 files changed, 56 insertions(+), 56 deletions(-)
 create mode 100644 clippy_lints/src/single_char_idents.rs
 delete mode 100644 clippy_lints/src/single_letter_idents.rs

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5a03d768fee..27a5fc06b07 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5155,12 +5155,12 @@ Released 2018-09-13
 [`significant_drop_tightening`]: https://rust-lang.github.io/rust-clippy/master/index.html#significant_drop_tightening
 [`similar_names`]: https://rust-lang.github.io/rust-clippy/master/index.html#similar_names
 [`single_char_add_str`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_char_add_str
+[`single_char_idents`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_char_idents
 [`single_char_lifetime_names`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_char_lifetime_names
 [`single_char_pattern`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_char_pattern
 [`single_char_push_str`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_char_push_str
 [`single_component_path_imports`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_component_path_imports
 [`single_element_loop`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_element_loop
-[`single_letter_idents`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_letter_idents
 [`single_match`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_match
 [`single_match_else`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_match_else
 [`size_of_in_element_count`]: https://rust-lang.github.io/rust-clippy/master/index.html#size_of_in_element_count
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 03c3e153a97..1c494468226 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -565,9 +565,9 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::shadow::SHADOW_SAME_INFO,
     crate::shadow::SHADOW_UNRELATED_INFO,
     crate::significant_drop_tightening::SIGNIFICANT_DROP_TIGHTENING_INFO,
+    crate::single_char_idents::SINGLE_CHAR_IDENTS_INFO,
     crate::single_char_lifetime_names::SINGLE_CHAR_LIFETIME_NAMES_INFO,
     crate::single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS_INFO,
-    crate::single_letter_idents::SINGLE_LETTER_IDENTS_INFO,
     crate::size_of_in_element_count::SIZE_OF_IN_ELEMENT_COUNT_INFO,
     crate::size_of_ref::SIZE_OF_REF_INFO,
     crate::slow_vector_initialization::SLOW_VECTOR_INITIALIZATION_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 9b8edc5d77e..463e4a429d1 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -284,9 +284,9 @@ mod semicolon_if_nothing_returned;
 mod serde_api;
 mod shadow;
 mod significant_drop_tightening;
+mod single_char_idents;
 mod single_char_lifetime_names;
 mod single_component_path_imports;
-mod single_letter_idents;
 mod size_of_in_element_count;
 mod size_of_ref;
 mod slow_vector_initialization;
@@ -1036,7 +1036,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(needless_if::NeedlessIf));
     let allowed_idents = conf.allowed_idents.clone();
     store.register_early_pass(move || {
-        Box::new(single_letter_idents::SingleLetterIdents {
+        Box::new(single_char_idents::SingleCharIdents {
             allowed_idents: allowed_idents.clone(),
         })
     });
diff --git a/clippy_lints/src/single_char_idents.rs b/clippy_lints/src/single_char_idents.rs
new file mode 100644
index 00000000000..0125b576f43
--- /dev/null
+++ b/clippy_lints/src/single_char_idents.rs
@@ -0,0 +1,52 @@
+use clippy_utils::{diagnostics::span_lint, source::snippet};
+use itertools::Itertools;
+use rustc_data_structures::fx::FxHashSet;
+use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
+use rustc_middle::lint::in_external_macro;
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::symbol::Ident;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for idents which comprise of a single letter.
+    ///
+    /// Note: This lint can be very noisy when enabled; it even lints generics! it may be desirable
+    /// to only enable it temporarily.
+    ///
+    /// ### Why is this bad?
+    /// In many cases it's not, but at times it can severely hinder readability. Some codebases may
+    /// wish to disallow this to improve readability.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// for i in collection {
+    ///     let x = i.x;
+    /// }
+    /// ```
+    #[clippy::version = "1.72.0"]
+    pub SINGLE_CHAR_IDENTS,
+    restriction,
+    "disallows idents that can be represented as a char"
+}
+impl_lint_pass!(SingleCharIdents => [SINGLE_CHAR_IDENTS]);
+
+#[derive(Clone)]
+pub struct SingleCharIdents {
+    pub allowed_idents: FxHashSet<char>,
+}
+
+impl EarlyLintPass for SingleCharIdents {
+    fn check_ident(&mut self, cx: &EarlyContext<'_>, ident: Ident) {
+        let str = ident.name.as_str();
+        let chars = str.chars();
+        if let [char, rest @ ..] = &*chars.collect_vec()
+            && rest.is_empty()
+            && self.allowed_idents.get(char).is_none()
+            && !in_external_macro(cx.sess(), ident.span)
+            // Ignore proc macros. Let's implement `WithSearchPat` for early lints someday :)
+            && snippet(cx, ident.span, str) == str
+        {
+            span_lint(cx, SINGLE_CHAR_IDENTS, ident.span, "this ident comprises of a single char");
+        }
+    }
+}
diff --git a/clippy_lints/src/single_letter_idents.rs b/clippy_lints/src/single_letter_idents.rs
deleted file mode 100644
index e957b6fec68..00000000000
--- a/clippy_lints/src/single_letter_idents.rs
+++ /dev/null
@@ -1,52 +0,0 @@
-use clippy_utils::{diagnostics::span_lint, source::snippet};
-use itertools::Itertools;
-use rustc_data_structures::fx::FxHashSet;
-use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
-use rustc_middle::lint::in_external_macro;
-use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::symbol::Ident;
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for idents which comprise of a single letter.
-    ///
-    /// Note: This lint can be very noisy when enabled; it even lints generics! it may be desirable
-    /// to only enable it temporarily.
-    ///
-    /// ### Why is this bad?
-    /// In many cases it's not, but at times it can severely hinder readability. Some codebases may
-    /// wish to disallow this to improve readability.
-    ///
-    /// ### Example
-    /// ```rust,ignore
-    /// for i in collection {
-    ///     let x = i.x;
-    /// }
-    /// ```
-    #[clippy::version = "1.72.0"]
-    pub SINGLE_LETTER_IDENTS,
-    restriction,
-    "disallows idents that can be represented as a char"
-}
-impl_lint_pass!(SingleLetterIdents => [SINGLE_LETTER_IDENTS]);
-
-#[derive(Clone)]
-pub struct SingleLetterIdents {
-    pub allowed_idents: FxHashSet<char>,
-}
-
-impl EarlyLintPass for SingleLetterIdents {
-    fn check_ident(&mut self, cx: &EarlyContext<'_>, ident: Ident) {
-        let str = ident.name.as_str();
-        let chars = str.chars();
-        if let [char, rest @ ..] = chars.collect_vec().as_slice()
-            && rest.is_empty()
-            && self.allowed_idents.get(char).is_none()
-            && !in_external_macro(cx.sess(), ident.span)
-            // Ignore proc macros. Let's implement `WithSearchPat` for early lints someday :)
-            && snippet(cx, ident.span, str) == str
-        {
-            span_lint(cx, SINGLE_LETTER_IDENTS, ident.span, "this ident comprises of a single letter");
-        }
-    }
-}
-- 
cgit 1.4.1-3-g733a5


From 03c8db048e97835c3431eac5da90e207b0a458f6 Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Fri, 9 Jun 2023 14:45:53 -0500
Subject: make cargo test pass + example

---
 clippy_lints/src/single_char_idents.rs |  11 +++-
 tests/ui/single_char_idents.rs         |  59 +++++++++++++++++++
 tests/ui/single_char_idents.stderr     | 100 +++++++++++++++++++++++++++++++++
 tests/ui/single_letter_idents.rs       |  59 -------------------
 tests/ui/single_letter_idents.stderr   | 100 ---------------------------------
 5 files changed, 168 insertions(+), 161 deletions(-)
 create mode 100644 tests/ui/single_char_idents.rs
 create mode 100644 tests/ui/single_char_idents.stderr
 delete mode 100644 tests/ui/single_letter_idents.rs
 delete mode 100644 tests/ui/single_letter_idents.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/single_char_idents.rs b/clippy_lints/src/single_char_idents.rs
index 0125b576f43..17a2ebe93ed 100644
--- a/clippy_lints/src/single_char_idents.rs
+++ b/clippy_lints/src/single_char_idents.rs
@@ -19,10 +19,17 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust,ignore
-    /// for i in collection {
-    ///     let x = i.x;
+    /// for m in movies {
+    ///	    let title = m.t;
     /// }
     /// ```
+    /// Use instead:
+    /// ```rust,ignore
+    /// for movie in movies {
+    ///     let title = movie.title;
+    /// }
+    /// ```
+    /// ```
     #[clippy::version = "1.72.0"]
     pub SINGLE_CHAR_IDENTS,
     restriction,
diff --git a/tests/ui/single_char_idents.rs b/tests/ui/single_char_idents.rs
new file mode 100644
index 00000000000..386633161fe
--- /dev/null
+++ b/tests/ui/single_char_idents.rs
@@ -0,0 +1,59 @@
+//@aux-build:proc_macros.rs
+#![allow(nonstandard_style, unused)]
+#![warn(clippy::single_char_idents)]
+
+extern crate proc_macros;
+use proc_macros::external;
+use proc_macros::with_span;
+
+struct A {
+    a: u32,
+    i: u32,
+    A: u32,
+    I: u32,
+}
+
+struct B(u32);
+
+struct i;
+
+enum C {
+    D,
+    E,
+    F,
+    j,
+}
+
+struct Vec4 {
+    x: u32,
+    y: u32,
+    z: u32,
+    w: u32,
+}
+
+struct AA<T, E>(T, E);
+
+fn main() {
+    // Allowed idents
+    let w = 1;
+    // Ok, not this one
+    // let i = 1;
+    let j = 1;
+    let n = 1;
+    let x = 1;
+    let y = 1;
+    let z = 1;
+
+    for j in 0..1000 {}
+
+    // Do not lint code from external macros
+    external! { for j in 0..1000 {} }
+    // Do not lint code from procedural macros
+    with_span! {
+        span
+        for j in 0..1000 {}
+    }
+}
+
+fn b() {}
+fn owo() {}
diff --git a/tests/ui/single_char_idents.stderr b/tests/ui/single_char_idents.stderr
new file mode 100644
index 00000000000..ceedab9c0da
--- /dev/null
+++ b/tests/ui/single_char_idents.stderr
@@ -0,0 +1,100 @@
+error: this ident comprises of a single char
+  --> $DIR/single_char_idents.rs:9:8
+   |
+LL | struct A {
+   |        ^
+   |
+   = note: `-D clippy::single-char-idents` implied by `-D warnings`
+
+error: this ident comprises of a single char
+  --> $DIR/single_char_idents.rs:10:5
+   |
+LL |     a: u32,
+   |     ^
+
+error: this ident comprises of a single char
+  --> $DIR/single_char_idents.rs:12:5
+   |
+LL |     A: u32,
+   |     ^
+
+error: this ident comprises of a single char
+  --> $DIR/single_char_idents.rs:13:5
+   |
+LL |     I: u32,
+   |     ^
+
+error: this ident comprises of a single char
+  --> $DIR/single_char_idents.rs:16:8
+   |
+LL | struct B(u32);
+   |        ^
+
+error: this ident comprises of a single char
+  --> $DIR/single_char_idents.rs:20:6
+   |
+LL | enum C {
+   |      ^
+
+error: this ident comprises of a single char
+  --> $DIR/single_char_idents.rs:21:5
+   |
+LL |     D,
+   |     ^
+
+error: this ident comprises of a single char
+  --> $DIR/single_char_idents.rs:22:5
+   |
+LL |     E,
+   |     ^
+
+error: this ident comprises of a single char
+  --> $DIR/single_char_idents.rs:23:5
+   |
+LL |     F,
+   |     ^
+
+error: this ident comprises of a single char
+  --> $DIR/single_char_idents.rs:31:5
+   |
+LL |     w: u32,
+   |     ^
+
+error: this ident comprises of a single char
+  --> $DIR/single_char_idents.rs:34:11
+   |
+LL | struct AA<T, E>(T, E);
+   |           ^
+
+error: this ident comprises of a single char
+  --> $DIR/single_char_idents.rs:34:14
+   |
+LL | struct AA<T, E>(T, E);
+   |              ^
+
+error: this ident comprises of a single char
+  --> $DIR/single_char_idents.rs:34:17
+   |
+LL | struct AA<T, E>(T, E);
+   |                 ^
+
+error: this ident comprises of a single char
+  --> $DIR/single_char_idents.rs:34:20
+   |
+LL | struct AA<T, E>(T, E);
+   |                    ^
+
+error: this ident comprises of a single char
+  --> $DIR/single_char_idents.rs:38:9
+   |
+LL |     let w = 1;
+   |         ^
+
+error: this ident comprises of a single char
+  --> $DIR/single_char_idents.rs:58:4
+   |
+LL | fn b() {}
+   |    ^
+
+error: aborting due to 16 previous errors
+
diff --git a/tests/ui/single_letter_idents.rs b/tests/ui/single_letter_idents.rs
deleted file mode 100644
index b33c569d318..00000000000
--- a/tests/ui/single_letter_idents.rs
+++ /dev/null
@@ -1,59 +0,0 @@
-//@aux-build:proc_macros.rs
-#![allow(nonstandard_style, unused)]
-#![warn(clippy::single_letter_idents)]
-
-extern crate proc_macros;
-use proc_macros::external;
-use proc_macros::with_span;
-
-struct A {
-    a: u32,
-    i: u32,
-    A: u32,
-    I: u32,
-}
-
-struct B(u32);
-
-struct i;
-
-enum C {
-    D,
-    E,
-    F,
-    j,
-}
-
-struct Vec4 {
-    x: u32,
-    y: u32,
-    z: u32,
-    w: u32,
-}
-
-struct AA<T, E>(T, E);
-
-fn main() {
-    // Allowed idents
-    let w = 1;
-    // Ok, not this one
-    // let i = 1;
-    let j = 1;
-    let n = 1;
-    let x = 1;
-    let y = 1;
-    let z = 1;
-
-    for j in 0..1000 {}
-
-    // Do not lint code from external macros
-    external! { for j in 0..1000 {} }
-    // Do not lint code from procedural macros
-    with_span! {
-        span
-        for j in 0..1000 {}
-    }
-}
-
-fn b() {}
-fn owo() {}
diff --git a/tests/ui/single_letter_idents.stderr b/tests/ui/single_letter_idents.stderr
deleted file mode 100644
index 712c1664235..00000000000
--- a/tests/ui/single_letter_idents.stderr
+++ /dev/null
@@ -1,100 +0,0 @@
-error: this ident comprises of a single letter
-  --> $DIR/single_letter_idents.rs:9:8
-   |
-LL | struct A {
-   |        ^
-   |
-   = note: `-D clippy::single-letter-idents` implied by `-D warnings`
-
-error: this ident comprises of a single letter
-  --> $DIR/single_letter_idents.rs:10:5
-   |
-LL |     a: u32,
-   |     ^
-
-error: this ident comprises of a single letter
-  --> $DIR/single_letter_idents.rs:12:5
-   |
-LL |     A: u32,
-   |     ^
-
-error: this ident comprises of a single letter
-  --> $DIR/single_letter_idents.rs:13:5
-   |
-LL |     I: u32,
-   |     ^
-
-error: this ident comprises of a single letter
-  --> $DIR/single_letter_idents.rs:16:8
-   |
-LL | struct B(u32);
-   |        ^
-
-error: this ident comprises of a single letter
-  --> $DIR/single_letter_idents.rs:20:6
-   |
-LL | enum C {
-   |      ^
-
-error: this ident comprises of a single letter
-  --> $DIR/single_letter_idents.rs:21:5
-   |
-LL |     D,
-   |     ^
-
-error: this ident comprises of a single letter
-  --> $DIR/single_letter_idents.rs:22:5
-   |
-LL |     E,
-   |     ^
-
-error: this ident comprises of a single letter
-  --> $DIR/single_letter_idents.rs:23:5
-   |
-LL |     F,
-   |     ^
-
-error: this ident comprises of a single letter
-  --> $DIR/single_letter_idents.rs:31:5
-   |
-LL |     w: u32,
-   |     ^
-
-error: this ident comprises of a single letter
-  --> $DIR/single_letter_idents.rs:34:11
-   |
-LL | struct AA<T, E>(T, E);
-   |           ^
-
-error: this ident comprises of a single letter
-  --> $DIR/single_letter_idents.rs:34:14
-   |
-LL | struct AA<T, E>(T, E);
-   |              ^
-
-error: this ident comprises of a single letter
-  --> $DIR/single_letter_idents.rs:34:17
-   |
-LL | struct AA<T, E>(T, E);
-   |                 ^
-
-error: this ident comprises of a single letter
-  --> $DIR/single_letter_idents.rs:34:20
-   |
-LL | struct AA<T, E>(T, E);
-   |                    ^
-
-error: this ident comprises of a single letter
-  --> $DIR/single_letter_idents.rs:38:9
-   |
-LL |     let w = 1;
-   |         ^
-
-error: this ident comprises of a single letter
-  --> $DIR/single_letter_idents.rs:58:4
-   |
-LL | fn b() {}
-   |    ^
-
-error: aborting due to 16 previous errors
-
-- 
cgit 1.4.1-3-g733a5


From 7cdd87ca4afe3ab7a1a8eb1544db132678335f87 Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Fri, 9 Jun 2023 17:49:35 -0500
Subject: ignore generics and allow arbitrary threshold

---
 CHANGELOG.md                                       |   2 +-
 clippy_lints/src/declared_lints.rs                 |   2 +-
 clippy_lints/src/lib.rs                            |  12 +-
 clippy_lints/src/min_ident_chars.rs                | 133 +++++++++++++++++++++
 clippy_lints/src/single_char_idents.rs             |  59 ---------
 clippy_lints/src/utils/conf.rs                     |  11 +-
 .../min_ident_chars/auxiliary/extern_types.rs      |   3 +
 tests/ui-toml/min_ident_chars/clippy.toml          |   2 +
 tests/ui-toml/min_ident_chars/min_ident_chars.rs   |  17 +++
 .../ui-toml/min_ident_chars/min_ident_chars.stderr |  16 +++
 .../toml_unknown_key/conf_unknown_key.stderr       |   6 +-
 tests/ui/min_ident_chars.rs                        |  59 +++++++++
 tests/ui/min_ident_chars.stderr                    |  70 +++++++++++
 tests/ui/single_char_idents.rs                     |  59 ---------
 tests/ui/single_char_idents.stderr                 | 100 ----------------
 15 files changed, 323 insertions(+), 228 deletions(-)
 create mode 100644 clippy_lints/src/min_ident_chars.rs
 delete mode 100644 clippy_lints/src/single_char_idents.rs
 create mode 100644 tests/ui-toml/min_ident_chars/auxiliary/extern_types.rs
 create mode 100644 tests/ui-toml/min_ident_chars/clippy.toml
 create mode 100644 tests/ui-toml/min_ident_chars/min_ident_chars.rs
 create mode 100644 tests/ui-toml/min_ident_chars/min_ident_chars.stderr
 create mode 100644 tests/ui/min_ident_chars.rs
 create mode 100644 tests/ui/min_ident_chars.stderr
 delete mode 100644 tests/ui/single_char_idents.rs
 delete mode 100644 tests/ui/single_char_idents.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 27a5fc06b07..2d62bfd4f99 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4958,6 +4958,7 @@ Released 2018-09-13
 [`mem_replace_option_with_none`]: https://rust-lang.github.io/rust-clippy/master/index.html#mem_replace_option_with_none
 [`mem_replace_with_default`]: https://rust-lang.github.io/rust-clippy/master/index.html#mem_replace_with_default
 [`mem_replace_with_uninit`]: https://rust-lang.github.io/rust-clippy/master/index.html#mem_replace_with_uninit
+[`min_ident_chars`]: https://rust-lang.github.io/rust-clippy/master/index.html#min_ident_chars
 [`min_max`]: https://rust-lang.github.io/rust-clippy/master/index.html#min_max
 [`misaligned_transmute`]: https://rust-lang.github.io/rust-clippy/master/index.html#misaligned_transmute
 [`mismatched_target_os`]: https://rust-lang.github.io/rust-clippy/master/index.html#mismatched_target_os
@@ -5155,7 +5156,6 @@ Released 2018-09-13
 [`significant_drop_tightening`]: https://rust-lang.github.io/rust-clippy/master/index.html#significant_drop_tightening
 [`similar_names`]: https://rust-lang.github.io/rust-clippy/master/index.html#similar_names
 [`single_char_add_str`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_char_add_str
-[`single_char_idents`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_char_idents
 [`single_char_lifetime_names`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_char_lifetime_names
 [`single_char_pattern`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_char_pattern
 [`single_char_push_str`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_char_push_str
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 1c494468226..769774b27c4 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -416,6 +416,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::methods::VERBOSE_FILE_READS_INFO,
     crate::methods::WRONG_SELF_CONVENTION_INFO,
     crate::methods::ZST_OFFSET_INFO,
+    crate::min_ident_chars::MIN_IDENT_CHARS_INFO,
     crate::minmax::MIN_MAX_INFO,
     crate::misc::SHORT_CIRCUIT_STATEMENT_INFO,
     crate::misc::TOPLEVEL_REF_ARG_INFO,
@@ -565,7 +566,6 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::shadow::SHADOW_SAME_INFO,
     crate::shadow::SHADOW_UNRELATED_INFO,
     crate::significant_drop_tightening::SIGNIFICANT_DROP_TIGHTENING_INFO,
-    crate::single_char_idents::SINGLE_CHAR_IDENTS_INFO,
     crate::single_char_lifetime_names::SINGLE_CHAR_LIFETIME_NAMES_INFO,
     crate::single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS_INFO,
     crate::size_of_in_element_count::SIZE_OF_IN_ELEMENT_COUNT_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 463e4a429d1..dcf1c6f64a4 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -197,6 +197,7 @@ mod matches;
 mod mem_forget;
 mod mem_replace;
 mod methods;
+mod min_ident_chars;
 mod minmax;
 mod misc;
 mod misc_early;
@@ -284,7 +285,6 @@ mod semicolon_if_nothing_returned;
 mod serde_api;
 mod shadow;
 mod significant_drop_tightening;
-mod single_char_idents;
 mod single_char_lifetime_names;
 mod single_component_path_imports;
 mod size_of_in_element_count;
@@ -1034,10 +1034,12 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(redundant_type_annotations::RedundantTypeAnnotations));
     store.register_late_pass(|_| Box::new(arc_with_non_send_sync::ArcWithNonSendSync));
     store.register_late_pass(|_| Box::new(needless_if::NeedlessIf));
-    let allowed_idents = conf.allowed_idents.clone();
-    store.register_early_pass(move || {
-        Box::new(single_char_idents::SingleCharIdents {
-            allowed_idents: allowed_idents.clone(),
+    let allowed_idents_below_min_chars = conf.allowed_idents_below_min_chars.clone();
+    let min_ident_chars_threshold = conf.min_ident_chars_threshold;
+    store.register_late_pass(move |_| {
+        Box::new(min_ident_chars::MinIdentChars {
+            allowed_idents_below_min_chars: allowed_idents_below_min_chars.clone(),
+            min_ident_chars_threshold,
         })
     });
     // add lints here, do not remove this comment, it's used in `new_lint`
diff --git a/clippy_lints/src/min_ident_chars.rs b/clippy_lints/src/min_ident_chars.rs
new file mode 100644
index 00000000000..bbe7fc540e9
--- /dev/null
+++ b/clippy_lints/src/min_ident_chars.rs
@@ -0,0 +1,133 @@
+use clippy_utils::{diagnostics::span_lint, is_from_proc_macro};
+use rustc_data_structures::fx::FxHashSet;
+use rustc_hir::{
+    def::{DefKind, Res},
+    intravisit::{walk_item, Visitor},
+    GenericParamKind, HirId, Item, ItemKind, ItemLocalId, Node,
+};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_middle::lint::in_external_macro;
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+use std::borrow::Cow;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for idents which comprise of a single letter.
+    ///
+    /// Note: This lint can be very noisy when enabled; it may be desirable to only enable it
+    /// temporarily.
+    ///
+    /// ### Why is this bad?
+    /// In many cases it's not, but at times it can severely hinder readability. Some codebases may
+    /// wish to disallow this to improve readability.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// for m in movies {
+    ///	    let title = m.t;
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust,ignore
+    /// for movie in movies {
+    ///     let title = movie.title;
+    /// }
+    /// ```
+    /// ```
+    #[clippy::version = "1.72.0"]
+    pub MIN_IDENT_CHARS,
+    restriction,
+    "disallows idents that are too short"
+}
+impl_lint_pass!(MinIdentChars => [MIN_IDENT_CHARS]);
+
+#[derive(Clone)]
+pub struct MinIdentChars {
+    pub allowed_idents_below_min_chars: FxHashSet<String>,
+    pub min_ident_chars_threshold: u64,
+}
+
+impl LateLintPass<'_> for MinIdentChars {
+    fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
+        if self.min_ident_chars_threshold == 0 {
+            return;
+        }
+
+        walk_item(&mut IdentVisitor { conf: self, cx }, item);
+    }
+}
+
+struct IdentVisitor<'cx, 'tcx> {
+    conf: &'cx MinIdentChars,
+    cx: &'cx LateContext<'tcx>,
+}
+
+#[expect(clippy::cast_possible_truncation)]
+impl Visitor<'_> for IdentVisitor<'_, '_> {
+    fn visit_id(&mut self, hir_id: HirId) {
+        let Self { conf, cx } = *self;
+        // Reimplementation of `find`, as it uses indexing, which can (and will in async functions) panic.
+        // This should probably be fixed on the rustc side, this is just a temporary workaround.
+        // FIXME: Remove me if/when this is fixed in rustc
+        let node = if hir_id.local_id == ItemLocalId::from_u32(0) {
+            // In this case, we can just use `find`, `Owner`'s `node` field is private anyway so we can't
+            // reimplement it even if we wanted to
+            cx.tcx.hir().find(hir_id)
+        } else {
+            let Some(owner) = cx.tcx.hir_owner_nodes(hir_id.owner).as_owner() else {
+                return;
+            };
+            owner.nodes.get(hir_id.local_id).copied().flatten().map(|p| p.node)
+        };
+        let Some(node) = node else {
+            return;
+        };
+        let Some(ident) = node.ident() else {
+            return;
+        };
+
+        let str = ident.as_str();
+        if !in_external_macro(cx.sess(), ident.span)
+            && str.len() <= conf.min_ident_chars_threshold as usize
+            && !str.is_empty()
+            && conf.allowed_idents_below_min_chars.get(&str.to_owned()).is_none()
+        {
+            if let Node::Item(item) = node && let ItemKind::Use(..) = item.kind {
+                return;
+            }
+            // `struct Awa<T>(T)`
+            //                ^
+            if let Node::PathSegment(path) = node {
+                if let Res::Def(def_kind, ..) = path.res && let DefKind::TyParam = def_kind {
+                    return;
+                }
+                if matches!(path.res, Res::PrimTy(..)) || path.res.opt_def_id().is_some_and(|def_id| !def_id.is_local())
+                {
+                    return;
+                }
+            }
+            // `struct Awa<T>(T)`
+            //             ^
+            if let Node::GenericParam(generic_param) = node
+                && let GenericParamKind::Type { .. } = generic_param.kind
+            {
+                return;
+            }
+
+            if is_from_proc_macro(cx, &ident) {
+                return;
+            }
+
+            let help = if conf.min_ident_chars_threshold == 1 {
+                Cow::Borrowed("this ident consists of a single char")
+            } else {
+                Cow::Owned(format!(
+                    "this ident is too short ({} <= {}) ",
+                    str.len(),
+                    conf.min_ident_chars_threshold
+                ))
+            };
+            span_lint(cx, MIN_IDENT_CHARS, ident.span, &help);
+        }
+    }
+}
diff --git a/clippy_lints/src/single_char_idents.rs b/clippy_lints/src/single_char_idents.rs
deleted file mode 100644
index 17a2ebe93ed..00000000000
--- a/clippy_lints/src/single_char_idents.rs
+++ /dev/null
@@ -1,59 +0,0 @@
-use clippy_utils::{diagnostics::span_lint, source::snippet};
-use itertools::Itertools;
-use rustc_data_structures::fx::FxHashSet;
-use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
-use rustc_middle::lint::in_external_macro;
-use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::symbol::Ident;
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for idents which comprise of a single letter.
-    ///
-    /// Note: This lint can be very noisy when enabled; it even lints generics! it may be desirable
-    /// to only enable it temporarily.
-    ///
-    /// ### Why is this bad?
-    /// In many cases it's not, but at times it can severely hinder readability. Some codebases may
-    /// wish to disallow this to improve readability.
-    ///
-    /// ### Example
-    /// ```rust,ignore
-    /// for m in movies {
-    ///	    let title = m.t;
-    /// }
-    /// ```
-    /// Use instead:
-    /// ```rust,ignore
-    /// for movie in movies {
-    ///     let title = movie.title;
-    /// }
-    /// ```
-    /// ```
-    #[clippy::version = "1.72.0"]
-    pub SINGLE_CHAR_IDENTS,
-    restriction,
-    "disallows idents that can be represented as a char"
-}
-impl_lint_pass!(SingleCharIdents => [SINGLE_CHAR_IDENTS]);
-
-#[derive(Clone)]
-pub struct SingleCharIdents {
-    pub allowed_idents: FxHashSet<char>,
-}
-
-impl EarlyLintPass for SingleCharIdents {
-    fn check_ident(&mut self, cx: &EarlyContext<'_>, ident: Ident) {
-        let str = ident.name.as_str();
-        let chars = str.chars();
-        if let [char, rest @ ..] = &*chars.collect_vec()
-            && rest.is_empty()
-            && self.allowed_idents.get(char).is_none()
-            && !in_external_macro(cx.sess(), ident.span)
-            // Ignore proc macros. Let's implement `WithSearchPat` for early lints someday :)
-            && snippet(cx, ident.span, str) == str
-        {
-            span_lint(cx, SINGLE_CHAR_IDENTS, ident.span, "this ident comprises of a single char");
-        }
-    }
-}
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 7b5413647c7..c84d8d8d1f0 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -34,7 +34,7 @@ const DEFAULT_DOC_VALID_IDENTS: &[&str] = &[
     "CamelCase",
 ];
 const DEFAULT_DISALLOWED_NAMES: &[&str] = &["foo", "baz", "quux"];
-const DEFAULT_ALLOWED_IDENTS: &[char] = &['i', 'j', 'x', 'y', 'z', 'n'];
+const DEFAULT_ALLOWED_IDENTS_BELOW_MIN_CHARS: &[&str] = &["i", "j", "x", "y", "z", "n"];
 
 /// Holds information used by `MISSING_ENFORCED_IMPORT_RENAMES` lint.
 #[derive(Clone, Debug, Deserialize)]
@@ -523,6 +523,15 @@ define_Conf! {
     ///
     /// Whether to allow module inception if it's not public.
     (allow_private_module_inception: bool = false),
+    /// Lint: MIN_IDENT_CHARS.
+    ///
+    /// Allowed names below the minimum allowed characters.
+    (allowed_idents_below_min_chars: rustc_data_structures::fx::FxHashSet<String> =
+        super::DEFAULT_ALLOWED_IDENTS_BELOW_MIN_CHARS.iter().map(ToString::to_string).collect()),
+    /// Lint: MIN_IDENT_CHARS.
+    ///
+    /// Minimum chars an ident can have, anything below or equal to this will be linted.
+    (min_ident_chars_threshold: u64 = 1),
 }
 
 /// Search for the configuration file.
diff --git a/tests/ui-toml/min_ident_chars/auxiliary/extern_types.rs b/tests/ui-toml/min_ident_chars/auxiliary/extern_types.rs
new file mode 100644
index 00000000000..06a144f2218
--- /dev/null
+++ b/tests/ui-toml/min_ident_chars/auxiliary/extern_types.rs
@@ -0,0 +1,3 @@
+#![allow(nonstandard_style, unused)]
+
+pub struct Aaa;
diff --git a/tests/ui-toml/min_ident_chars/clippy.toml b/tests/ui-toml/min_ident_chars/clippy.toml
new file mode 100644
index 00000000000..0114ca75014
--- /dev/null
+++ b/tests/ui-toml/min_ident_chars/clippy.toml
@@ -0,0 +1,2 @@
+allowed-idents-below-min-chars = ["Owo", "Uwu", "wha", "t_e", "lse", "_do", "_i_", "put", "her", "_e"]
+min-ident-chars-threshold = 3
diff --git a/tests/ui-toml/min_ident_chars/min_ident_chars.rs b/tests/ui-toml/min_ident_chars/min_ident_chars.rs
new file mode 100644
index 00000000000..33100119ca5
--- /dev/null
+++ b/tests/ui-toml/min_ident_chars/min_ident_chars.rs
@@ -0,0 +1,17 @@
+//@aux-build:extern_types.rs
+#![allow(nonstandard_style, unused)]
+#![warn(clippy::min_ident_chars)]
+
+extern crate extern_types;
+use extern_types::Aaa;
+
+struct Owo {
+    Uwu: u128,
+    aaa: Aaa,
+}
+
+fn main() {
+    let wha = 1;
+    let vvv = 1;
+    let uuu = 1;
+}
diff --git a/tests/ui-toml/min_ident_chars/min_ident_chars.stderr b/tests/ui-toml/min_ident_chars/min_ident_chars.stderr
new file mode 100644
index 00000000000..541f5b10051
--- /dev/null
+++ b/tests/ui-toml/min_ident_chars/min_ident_chars.stderr
@@ -0,0 +1,16 @@
+error: this ident is too short (3 <= 3) 
+  --> $DIR/min_ident_chars.rs:6:19
+   |
+LL | use extern_types::Aaa;
+   |                   ^^^
+   |
+   = note: `-D clippy::min-ident-chars` implied by `-D warnings`
+
+error: this ident is too short (3 <= 3) 
+  --> $DIR/min_ident_chars.rs:10:5
+   |
+LL |     aaa: Aaa,
+   |     ^^^
+
+error: aborting due to 2 previous errors
+
diff --git a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
index 2bc872e07e8..c546d95eb46 100644
--- a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
+++ b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
@@ -5,7 +5,7 @@ error: error reading Clippy's configuration file: unknown field `foobar`, expect
            allow-print-in-tests
            allow-private-module-inception
            allow-unwrap-in-tests
-           allowed-idents
+           allowed-idents-below-min-chars
            allowed-scripts
            arithmetic-side-effects-allowed
            arithmetic-side-effects-allowed-binary
@@ -37,6 +37,7 @@ error: error reading Clippy's configuration file: unknown field `foobar`, expect
            max-struct-bools
            max-suggested-slice-pattern-length
            max-trait-bounds
+           min-ident-chars-threshold
            missing-docs-in-crate-items
            msrv
            pass-by-value-size-limit
@@ -69,7 +70,7 @@ error: error reading Clippy's configuration file: unknown field `barfoo`, expect
            allow-print-in-tests
            allow-private-module-inception
            allow-unwrap-in-tests
-           allowed-idents
+           allowed-idents-below-min-chars
            allowed-scripts
            arithmetic-side-effects-allowed
            arithmetic-side-effects-allowed-binary
@@ -101,6 +102,7 @@ error: error reading Clippy's configuration file: unknown field `barfoo`, expect
            max-struct-bools
            max-suggested-slice-pattern-length
            max-trait-bounds
+           min-ident-chars-threshold
            missing-docs-in-crate-items
            msrv
            pass-by-value-size-limit
diff --git a/tests/ui/min_ident_chars.rs b/tests/ui/min_ident_chars.rs
new file mode 100644
index 00000000000..134c17c553f
--- /dev/null
+++ b/tests/ui/min_ident_chars.rs
@@ -0,0 +1,59 @@
+//@aux-build:proc_macros.rs
+#![allow(nonstandard_style, unused)]
+#![warn(clippy::min_ident_chars)]
+
+extern crate proc_macros;
+use proc_macros::external;
+use proc_macros::with_span;
+
+struct A {
+    a: u32,
+    i: u32,
+    A: u32,
+    I: u32,
+}
+
+struct B(u32);
+
+struct i;
+
+enum C {
+    D,
+    E,
+    F,
+    j,
+}
+
+struct Vec4 {
+    x: u32,
+    y: u32,
+    z: u32,
+    w: u32,
+}
+
+struct AA<T, E>(T, E);
+
+fn main() {
+    // Allowed idents
+    let w = 1;
+    // Ok, not this one
+    // let i = 1;
+    let jz = 1;
+    let nz = 1;
+    let zx = 1;
+    let yz = 1;
+    let zz = 1;
+
+    for j in 0..1000 {}
+
+    // Do not lint code from external macros
+    external! { for j in 0..1000 {} }
+    // Do not lint code from procedural macros
+    with_span! {
+        span
+        for j in 0..1000 {}
+    }
+}
+
+fn b() {}
+fn owo() {}
diff --git a/tests/ui/min_ident_chars.stderr b/tests/ui/min_ident_chars.stderr
new file mode 100644
index 00000000000..4b887617058
--- /dev/null
+++ b/tests/ui/min_ident_chars.stderr
@@ -0,0 +1,70 @@
+error: this ident consists of a single char
+  --> $DIR/min_ident_chars.rs:9:8
+   |
+LL | struct A {
+   |        ^
+   |
+   = note: `-D clippy::min-ident-chars` implied by `-D warnings`
+
+error: this ident consists of a single char
+  --> $DIR/min_ident_chars.rs:10:5
+   |
+LL |     a: u32,
+   |     ^
+
+error: this ident consists of a single char
+  --> $DIR/min_ident_chars.rs:12:5
+   |
+LL |     A: u32,
+   |     ^
+
+error: this ident consists of a single char
+  --> $DIR/min_ident_chars.rs:13:5
+   |
+LL |     I: u32,
+   |     ^
+
+error: this ident consists of a single char
+  --> $DIR/min_ident_chars.rs:16:8
+   |
+LL | struct B(u32);
+   |        ^
+
+error: this ident consists of a single char
+  --> $DIR/min_ident_chars.rs:20:6
+   |
+LL | enum C {
+   |      ^
+
+error: this ident consists of a single char
+  --> $DIR/min_ident_chars.rs:21:5
+   |
+LL |     D,
+   |     ^
+
+error: this ident consists of a single char
+  --> $DIR/min_ident_chars.rs:22:5
+   |
+LL |     E,
+   |     ^
+
+error: this ident consists of a single char
+  --> $DIR/min_ident_chars.rs:23:5
+   |
+LL |     F,
+   |     ^
+
+error: this ident consists of a single char
+  --> $DIR/min_ident_chars.rs:31:5
+   |
+LL |     w: u32,
+   |     ^
+
+error: this ident consists of a single char
+  --> $DIR/min_ident_chars.rs:58:4
+   |
+LL | fn b() {}
+   |    ^
+
+error: aborting due to 11 previous errors
+
diff --git a/tests/ui/single_char_idents.rs b/tests/ui/single_char_idents.rs
deleted file mode 100644
index 386633161fe..00000000000
--- a/tests/ui/single_char_idents.rs
+++ /dev/null
@@ -1,59 +0,0 @@
-//@aux-build:proc_macros.rs
-#![allow(nonstandard_style, unused)]
-#![warn(clippy::single_char_idents)]
-
-extern crate proc_macros;
-use proc_macros::external;
-use proc_macros::with_span;
-
-struct A {
-    a: u32,
-    i: u32,
-    A: u32,
-    I: u32,
-}
-
-struct B(u32);
-
-struct i;
-
-enum C {
-    D,
-    E,
-    F,
-    j,
-}
-
-struct Vec4 {
-    x: u32,
-    y: u32,
-    z: u32,
-    w: u32,
-}
-
-struct AA<T, E>(T, E);
-
-fn main() {
-    // Allowed idents
-    let w = 1;
-    // Ok, not this one
-    // let i = 1;
-    let j = 1;
-    let n = 1;
-    let x = 1;
-    let y = 1;
-    let z = 1;
-
-    for j in 0..1000 {}
-
-    // Do not lint code from external macros
-    external! { for j in 0..1000 {} }
-    // Do not lint code from procedural macros
-    with_span! {
-        span
-        for j in 0..1000 {}
-    }
-}
-
-fn b() {}
-fn owo() {}
diff --git a/tests/ui/single_char_idents.stderr b/tests/ui/single_char_idents.stderr
deleted file mode 100644
index ceedab9c0da..00000000000
--- a/tests/ui/single_char_idents.stderr
+++ /dev/null
@@ -1,100 +0,0 @@
-error: this ident comprises of a single char
-  --> $DIR/single_char_idents.rs:9:8
-   |
-LL | struct A {
-   |        ^
-   |
-   = note: `-D clippy::single-char-idents` implied by `-D warnings`
-
-error: this ident comprises of a single char
-  --> $DIR/single_char_idents.rs:10:5
-   |
-LL |     a: u32,
-   |     ^
-
-error: this ident comprises of a single char
-  --> $DIR/single_char_idents.rs:12:5
-   |
-LL |     A: u32,
-   |     ^
-
-error: this ident comprises of a single char
-  --> $DIR/single_char_idents.rs:13:5
-   |
-LL |     I: u32,
-   |     ^
-
-error: this ident comprises of a single char
-  --> $DIR/single_char_idents.rs:16:8
-   |
-LL | struct B(u32);
-   |        ^
-
-error: this ident comprises of a single char
-  --> $DIR/single_char_idents.rs:20:6
-   |
-LL | enum C {
-   |      ^
-
-error: this ident comprises of a single char
-  --> $DIR/single_char_idents.rs:21:5
-   |
-LL |     D,
-   |     ^
-
-error: this ident comprises of a single char
-  --> $DIR/single_char_idents.rs:22:5
-   |
-LL |     E,
-   |     ^
-
-error: this ident comprises of a single char
-  --> $DIR/single_char_idents.rs:23:5
-   |
-LL |     F,
-   |     ^
-
-error: this ident comprises of a single char
-  --> $DIR/single_char_idents.rs:31:5
-   |
-LL |     w: u32,
-   |     ^
-
-error: this ident comprises of a single char
-  --> $DIR/single_char_idents.rs:34:11
-   |
-LL | struct AA<T, E>(T, E);
-   |           ^
-
-error: this ident comprises of a single char
-  --> $DIR/single_char_idents.rs:34:14
-   |
-LL | struct AA<T, E>(T, E);
-   |              ^
-
-error: this ident comprises of a single char
-  --> $DIR/single_char_idents.rs:34:17
-   |
-LL | struct AA<T, E>(T, E);
-   |                 ^
-
-error: this ident comprises of a single char
-  --> $DIR/single_char_idents.rs:34:20
-   |
-LL | struct AA<T, E>(T, E);
-   |                    ^
-
-error: this ident comprises of a single char
-  --> $DIR/single_char_idents.rs:38:9
-   |
-LL |     let w = 1;
-   |         ^
-
-error: this ident comprises of a single char
-  --> $DIR/single_char_idents.rs:58:4
-   |
-LL | fn b() {}
-   |    ^
-
-error: aborting due to 16 previous errors
-
-- 
cgit 1.4.1-3-g733a5


From 243943ff56c755822968a48d5949f79c1d3a7dfa Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Sat, 10 Jun 2023 04:00:59 -0500
Subject: make it work for locals as well

oopos
---
 book/src/lint_configuration.md                     |  19 ----
 clippy_lints/src/min_ident_chars.rs                |  31 +++++-
 clippy_lints/src/utils/conf.rs                     |   2 +-
 tests/ui-toml/min_ident_chars/min_ident_chars.rs   |   2 +
 .../ui-toml/min_ident_chars/min_ident_chars.stderr |  36 ++++++-
 tests/ui/min_ident_chars.rs                        |  34 ++++--
 tests/ui/min_ident_chars.stderr                    | 114 +++++++++++++++++++--
 7 files changed, 196 insertions(+), 42 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/book/src/lint_configuration.md b/book/src/lint_configuration.md
index 16dc5dcef42..1812d50ed1b 100644
--- a/book/src/lint_configuration.md
+++ b/book/src/lint_configuration.md
@@ -644,22 +644,3 @@ The maximum byte size a `Future` can have, before it triggers the `clippy::large
 
 
 ## `unnecessary-box-size`
-The byte size a `T` in `Box<T>` can have, below which it triggers the `clippy::unnecessary_box` lint
-
-**Default Value:** `128` (`u64`)
-
----
-**Affected lints:**
-* [`unnecessary_box_returns`](https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_box_returns)
-
-
-## `allow-private-module-inception`
-Whether to allow module inception if it's not public.
-
-**Default Value:** `false` (`bool`)
-
----
-**Affected lints:**
-* [`module_inception`](https://rust-lang.github.io/rust-clippy/master/index.html#module_inception)
-
-
diff --git a/clippy_lints/src/min_ident_chars.rs b/clippy_lints/src/min_ident_chars.rs
index bbe7fc540e9..cc027b6f498 100644
--- a/clippy_lints/src/min_ident_chars.rs
+++ b/clippy_lints/src/min_ident_chars.rs
@@ -3,7 +3,7 @@ use rustc_data_structures::fx::FxHashSet;
 use rustc_hir::{
     def::{DefKind, Res},
     intravisit::{walk_item, Visitor},
-    GenericParamKind, HirId, Item, ItemKind, ItemLocalId, Node,
+    GenericParamKind, HirId, Item, ItemKind, ItemLocalId, Node, Pat, PatKind,
 };
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
@@ -55,6 +55,29 @@ impl LateLintPass<'_> for MinIdentChars {
 
         walk_item(&mut IdentVisitor { conf: self, cx }, item);
     }
+
+    // This is necessary as bindings are not visited in `visit_id`. :/
+    #[expect(clippy::cast_possible_truncation)]
+    fn check_pat(&mut self, cx: &LateContext<'_>, pat: &Pat<'_>) {
+        if let PatKind::Binding(_, _, ident, ..) = pat.kind
+            && let str = ident.as_str()
+            && !in_external_macro(cx.sess(), ident.span)
+            && str.len() <= self.min_ident_chars_threshold as usize
+            && !str.is_empty()
+            && self.allowed_idents_below_min_chars.get(&str.to_owned()).is_none()
+        {
+            let help = if self.min_ident_chars_threshold == 1 {
+                Cow::Borrowed("this ident consists of a single char")
+            } else {
+                Cow::Owned(format!(
+                    "this ident is too short ({} <= {})",
+                    str.len(),
+                    self.min_ident_chars_threshold,
+                ))
+            };
+            span_lint(cx, MIN_IDENT_CHARS, ident.span, &help);
+        }
+    }
 }
 
 struct IdentVisitor<'cx, 'tcx> {
@@ -62,8 +85,8 @@ struct IdentVisitor<'cx, 'tcx> {
     cx: &'cx LateContext<'tcx>,
 }
 
-#[expect(clippy::cast_possible_truncation)]
 impl Visitor<'_> for IdentVisitor<'_, '_> {
+    #[expect(clippy::cast_possible_truncation)]
     fn visit_id(&mut self, hir_id: HirId) {
         let Self { conf, cx } = *self;
         // Reimplementation of `find`, as it uses indexing, which can (and will in async functions) panic.
@@ -122,9 +145,9 @@ impl Visitor<'_> for IdentVisitor<'_, '_> {
                 Cow::Borrowed("this ident consists of a single char")
             } else {
                 Cow::Owned(format!(
-                    "this ident is too short ({} <= {}) ",
+                    "this ident is too short ({} <= {})",
                     str.len(),
-                    conf.min_ident_chars_threshold
+                    conf.min_ident_chars_threshold,
                 ))
             };
             span_lint(cx, MIN_IDENT_CHARS, ident.span, &help);
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index c84d8d8d1f0..f050782a16d 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -34,7 +34,7 @@ const DEFAULT_DOC_VALID_IDENTS: &[&str] = &[
     "CamelCase",
 ];
 const DEFAULT_DISALLOWED_NAMES: &[&str] = &["foo", "baz", "quux"];
-const DEFAULT_ALLOWED_IDENTS_BELOW_MIN_CHARS: &[&str] = &["i", "j", "x", "y", "z", "n"];
+const DEFAULT_ALLOWED_IDENTS_BELOW_MIN_CHARS: &[&str] = &["i", "j", "x", "y", "z", "w", "n"];
 
 /// Holds information used by `MISSING_ENFORCED_IMPORT_RENAMES` lint.
 #[derive(Clone, Debug, Deserialize)]
diff --git a/tests/ui-toml/min_ident_chars/min_ident_chars.rs b/tests/ui-toml/min_ident_chars/min_ident_chars.rs
index 33100119ca5..4326c7159c8 100644
--- a/tests/ui-toml/min_ident_chars/min_ident_chars.rs
+++ b/tests/ui-toml/min_ident_chars/min_ident_chars.rs
@@ -14,4 +14,6 @@ fn main() {
     let wha = 1;
     let vvv = 1;
     let uuu = 1;
+    let (mut a, mut b) = (1, 2);
+    for i in 0..1000 {}
 }
diff --git a/tests/ui-toml/min_ident_chars/min_ident_chars.stderr b/tests/ui-toml/min_ident_chars/min_ident_chars.stderr
index 541f5b10051..d9a27628ddb 100644
--- a/tests/ui-toml/min_ident_chars/min_ident_chars.stderr
+++ b/tests/ui-toml/min_ident_chars/min_ident_chars.stderr
@@ -1,4 +1,4 @@
-error: this ident is too short (3 <= 3) 
+error: this ident is too short (3 <= 3)
   --> $DIR/min_ident_chars.rs:6:19
    |
 LL | use extern_types::Aaa;
@@ -6,11 +6,41 @@ LL | use extern_types::Aaa;
    |
    = note: `-D clippy::min-ident-chars` implied by `-D warnings`
 
-error: this ident is too short (3 <= 3) 
+error: this ident is too short (3 <= 3)
   --> $DIR/min_ident_chars.rs:10:5
    |
 LL |     aaa: Aaa,
    |     ^^^
 
-error: aborting due to 2 previous errors
+error: this ident is too short (3 <= 3)
+  --> $DIR/min_ident_chars.rs:15:9
+   |
+LL |     let vvv = 1;
+   |         ^^^
+
+error: this ident is too short (3 <= 3)
+  --> $DIR/min_ident_chars.rs:16:9
+   |
+LL |     let uuu = 1;
+   |         ^^^
+
+error: this ident is too short (1 <= 3)
+  --> $DIR/min_ident_chars.rs:17:14
+   |
+LL |     let (mut a, mut b) = (1, 2);
+   |              ^
+
+error: this ident is too short (1 <= 3)
+  --> $DIR/min_ident_chars.rs:17:21
+   |
+LL |     let (mut a, mut b) = (1, 2);
+   |                     ^
+
+error: this ident is too short (1 <= 3)
+  --> $DIR/min_ident_chars.rs:18:9
+   |
+LL |     for i in 0..1000 {}
+   |         ^
+
+error: aborting due to 7 previous errors
 
diff --git a/tests/ui/min_ident_chars.rs b/tests/ui/min_ident_chars.rs
index 134c17c553f..85608d030ed 100644
--- a/tests/ui/min_ident_chars.rs
+++ b/tests/ui/min_ident_chars.rs
@@ -1,5 +1,5 @@
 //@aux-build:proc_macros.rs
-#![allow(nonstandard_style, unused)]
+#![allow(irrefutable_let_patterns, nonstandard_style, unused)]
 #![warn(clippy::min_ident_chars)]
 
 extern crate proc_macros;
@@ -15,6 +15,10 @@ struct A {
 
 struct B(u32);
 
+struct O {
+    o: u32,
+}
+
 struct i;
 
 enum C {
@@ -38,11 +42,29 @@ fn main() {
     let w = 1;
     // Ok, not this one
     // let i = 1;
-    let jz = 1;
-    let nz = 1;
-    let zx = 1;
-    let yz = 1;
-    let zz = 1;
+    let j = 1;
+    let n = 1;
+    let z = 1;
+    let y = 1;
+    let z = 1;
+    // Implicitly disallowed idents
+    let h = 1;
+    let e = 2;
+    let l = 3;
+    let l = 4;
+    let o = 6;
+    // 2 len does not lint
+    let hi = 0;
+    // Lint
+    let (h, o, w) = (1, 2, 3);
+    for (a, (r, e)) in (0..1000).enumerate().enumerate() {}
+    let you = Vec4 { x: 1, y: 2, z: 3, w: 4 };
+    while let (d, o, _i, n, g) = (true, true, false, false, true) {}
+    let today = true;
+    // Ideally this wouldn't lint, but this would (likely) require global analysis, outta scope
+    // of this lint regardless
+    let o = 1;
+    let o = O { o };
 
     for j in 0..1000 {}
 
diff --git a/tests/ui/min_ident_chars.stderr b/tests/ui/min_ident_chars.stderr
index 4b887617058..cd8825634c3 100644
--- a/tests/ui/min_ident_chars.stderr
+++ b/tests/ui/min_ident_chars.stderr
@@ -31,40 +31,136 @@ LL | struct B(u32);
    |        ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:20:6
+  --> $DIR/min_ident_chars.rs:18:8
+   |
+LL | struct O {
+   |        ^
+
+error: this ident consists of a single char
+  --> $DIR/min_ident_chars.rs:19:5
+   |
+LL |     o: u32,
+   |     ^
+
+error: this ident consists of a single char
+  --> $DIR/min_ident_chars.rs:24:6
    |
 LL | enum C {
    |      ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:21:5
+  --> $DIR/min_ident_chars.rs:25:5
    |
 LL |     D,
    |     ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:22:5
+  --> $DIR/min_ident_chars.rs:26:5
    |
 LL |     E,
    |     ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:23:5
+  --> $DIR/min_ident_chars.rs:27:5
    |
 LL |     F,
    |     ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:31:5
+  --> $DIR/min_ident_chars.rs:51:9
    |
-LL |     w: u32,
-   |     ^
+LL |     let h = 1;
+   |         ^
+
+error: this ident consists of a single char
+  --> $DIR/min_ident_chars.rs:52:9
+   |
+LL |     let e = 2;
+   |         ^
+
+error: this ident consists of a single char
+  --> $DIR/min_ident_chars.rs:53:9
+   |
+LL |     let l = 3;
+   |         ^
+
+error: this ident consists of a single char
+  --> $DIR/min_ident_chars.rs:54:9
+   |
+LL |     let l = 4;
+   |         ^
+
+error: this ident consists of a single char
+  --> $DIR/min_ident_chars.rs:55:9
+   |
+LL |     let o = 6;
+   |         ^
+
+error: this ident consists of a single char
+  --> $DIR/min_ident_chars.rs:59:10
+   |
+LL |     let (h, o, w) = (1, 2, 3);
+   |          ^
+
+error: this ident consists of a single char
+  --> $DIR/min_ident_chars.rs:59:13
+   |
+LL |     let (h, o, w) = (1, 2, 3);
+   |             ^
+
+error: this ident consists of a single char
+  --> $DIR/min_ident_chars.rs:60:10
+   |
+LL |     for (a, (r, e)) in (0..1000).enumerate().enumerate() {}
+   |          ^
+
+error: this ident consists of a single char
+  --> $DIR/min_ident_chars.rs:60:14
+   |
+LL |     for (a, (r, e)) in (0..1000).enumerate().enumerate() {}
+   |              ^
+
+error: this ident consists of a single char
+  --> $DIR/min_ident_chars.rs:60:17
+   |
+LL |     for (a, (r, e)) in (0..1000).enumerate().enumerate() {}
+   |                 ^
+
+error: this ident consists of a single char
+  --> $DIR/min_ident_chars.rs:62:16
+   |
+LL |     while let (d, o, _i, n, g) = (true, true, false, false, true) {}
+   |                ^
+
+error: this ident consists of a single char
+  --> $DIR/min_ident_chars.rs:62:19
+   |
+LL |     while let (d, o, _i, n, g) = (true, true, false, false, true) {}
+   |                   ^
+
+error: this ident consists of a single char
+  --> $DIR/min_ident_chars.rs:62:29
+   |
+LL |     while let (d, o, _i, n, g) = (true, true, false, false, true) {}
+   |                             ^
+
+error: this ident consists of a single char
+  --> $DIR/min_ident_chars.rs:66:9
+   |
+LL |     let o = 1;
+   |         ^
+
+error: this ident consists of a single char
+  --> $DIR/min_ident_chars.rs:67:9
+   |
+LL |     let o = O { o };
+   |         ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:58:4
+  --> $DIR/min_ident_chars.rs:80:4
    |
 LL | fn b() {}
    |    ^
 
-error: aborting due to 11 previous errors
+error: aborting due to 27 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 95d1bff2251ff33e1e8ca2bc0c1941c4e91bc2e4 Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Sat, 10 Jun 2023 09:13:04 -0500
Subject: add to tests and configuration

---
 clippy_lints/src/min_ident_chars.rs | 40 ++++++++++++++++++-------------------
 clippy_lints/src/utils/conf.rs      | 10 +++++++++-
 tests/ui/min_ident_chars.rs         |  5 ++++-
 tests/ui/min_ident_chars.stderr     | 16 +++++++++++++--
 4 files changed, 46 insertions(+), 25 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/min_ident_chars.rs b/clippy_lints/src/min_ident_chars.rs
index cc027b6f498..316c2bf122c 100644
--- a/clippy_lints/src/min_ident_chars.rs
+++ b/clippy_lints/src/min_ident_chars.rs
@@ -8,6 +8,7 @@ use rustc_hir::{
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::Span;
 use std::borrow::Cow;
 
 declare_clippy_lint! {
@@ -56,26 +57,18 @@ impl LateLintPass<'_> for MinIdentChars {
         walk_item(&mut IdentVisitor { conf: self, cx }, item);
     }
 
-    // This is necessary as bindings are not visited in `visit_id`. :/
+    // This is necessary as `Node::Pat`s are not visited in `visit_id`. :/
     #[expect(clippy::cast_possible_truncation)]
     fn check_pat(&mut self, cx: &LateContext<'_>, pat: &Pat<'_>) {
         if let PatKind::Binding(_, _, ident, ..) = pat.kind
             && let str = ident.as_str()
             && !in_external_macro(cx.sess(), ident.span)
             && str.len() <= self.min_ident_chars_threshold as usize
+            && !str.starts_with('_')
             && !str.is_empty()
             && self.allowed_idents_below_min_chars.get(&str.to_owned()).is_none()
         {
-            let help = if self.min_ident_chars_threshold == 1 {
-                Cow::Borrowed("this ident consists of a single char")
-            } else {
-                Cow::Owned(format!(
-                    "this ident is too short ({} <= {})",
-                    str.len(),
-                    self.min_ident_chars_threshold,
-                ))
-            };
-            span_lint(cx, MIN_IDENT_CHARS, ident.span, &help);
+            emit_min_ident_chars(self, cx, str, ident.span);
         }
     }
 }
@@ -112,6 +105,7 @@ impl Visitor<'_> for IdentVisitor<'_, '_> {
         let str = ident.as_str();
         if !in_external_macro(cx.sess(), ident.span)
             && str.len() <= conf.min_ident_chars_threshold as usize
+            && !str.starts_with('_')
             && !str.is_empty()
             && conf.allowed_idents_below_min_chars.get(&str.to_owned()).is_none()
         {
@@ -141,16 +135,20 @@ impl Visitor<'_> for IdentVisitor<'_, '_> {
                 return;
             }
 
-            let help = if conf.min_ident_chars_threshold == 1 {
-                Cow::Borrowed("this ident consists of a single char")
-            } else {
-                Cow::Owned(format!(
-                    "this ident is too short ({} <= {})",
-                    str.len(),
-                    conf.min_ident_chars_threshold,
-                ))
-            };
-            span_lint(cx, MIN_IDENT_CHARS, ident.span, &help);
+            emit_min_ident_chars(conf, cx, str, ident.span);
         }
     }
 }
+
+fn emit_min_ident_chars(conf: &MinIdentChars, cx: &impl LintContext, ident: &str, span: Span) {
+    let help = if conf.min_ident_chars_threshold == 1 {
+        Cow::Borrowed("this ident consists of a single char")
+    } else {
+        Cow::Owned(format!(
+            "this ident is too short ({} <= {})",
+            ident.len(),
+            conf.min_ident_chars_threshold,
+        ))
+    };
+    span_lint(cx, MIN_IDENT_CHARS, span, &help);
+}
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index f050782a16d..0a581e0ab9b 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -525,7 +525,9 @@ define_Conf! {
     (allow_private_module_inception: bool = false),
     /// Lint: MIN_IDENT_CHARS.
     ///
-    /// Allowed names below the minimum allowed characters.
+    /// Allowed names below the minimum allowed characters. The value `".."` can be used as part of
+    /// the list to indicate, that the configured values should be appended to the default
+    /// configuration of Clippy. By default, any configuration will replace the default value.
     (allowed_idents_below_min_chars: rustc_data_structures::fx::FxHashSet<String> =
         super::DEFAULT_ALLOWED_IDENTS_BELOW_MIN_CHARS.iter().map(ToString::to_string).collect()),
     /// Lint: MIN_IDENT_CHARS.
@@ -599,6 +601,12 @@ pub fn read(sess: &Session, path: &Path) -> TryConf {
         Ok(mut conf) => {
             extend_vec_if_indicator_present(&mut conf.conf.doc_valid_idents, DEFAULT_DOC_VALID_IDENTS);
             extend_vec_if_indicator_present(&mut conf.conf.disallowed_names, DEFAULT_DISALLOWED_NAMES);
+            // TODO: THIS SHOULD BE TESTED, this comment will be gone soon
+            if conf.conf.allowed_idents_below_min_chars.contains(&"..".to_owned()) {
+                conf.conf
+                    .allowed_idents_below_min_chars
+                    .extend(DEFAULT_ALLOWED_IDENTS_BELOW_MIN_CHARS.iter().map(ToString::to_string));
+            }
 
             conf
         },
diff --git a/tests/ui/min_ident_chars.rs b/tests/ui/min_ident_chars.rs
index 85608d030ed..c5e03468ef9 100644
--- a/tests/ui/min_ident_chars.rs
+++ b/tests/ui/min_ident_chars.rs
@@ -67,6 +67,7 @@ fn main() {
     let o = O { o };
 
     for j in 0..1000 {}
+    for _ in 0..10 {}
 
     // Do not lint code from external macros
     external! { for j in 0..1000 {} }
@@ -78,4 +79,6 @@ fn main() {
 }
 
 fn b() {}
-fn owo() {}
+fn wrong_pythagoras(a: f32, b: f32) -> f32 {
+    a * a + a * b
+}
diff --git a/tests/ui/min_ident_chars.stderr b/tests/ui/min_ident_chars.stderr
index cd8825634c3..66a63f65756 100644
--- a/tests/ui/min_ident_chars.stderr
+++ b/tests/ui/min_ident_chars.stderr
@@ -157,10 +157,22 @@ LL |     let o = O { o };
    |         ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:80:4
+  --> $DIR/min_ident_chars.rs:81:4
    |
 LL | fn b() {}
    |    ^
 
-error: aborting due to 27 previous errors
+error: this ident consists of a single char
+  --> $DIR/min_ident_chars.rs:82:21
+   |
+LL | fn wrong_pythagoras(a: f32, b: f32) -> f32 {
+   |                     ^
+
+error: this ident consists of a single char
+  --> $DIR/min_ident_chars.rs:82:29
+   |
+LL | fn wrong_pythagoras(a: f32, b: f32) -> f32 {
+   |                             ^
+
+error: aborting due to 29 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 29c1c6e104340b04505572220b29e5e76d7053b9 Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Sun, 11 Jun 2023 14:51:50 -0500
Subject: refactor and add link to issue

---
 clippy_lints/src/min_ident_chars.rs | 33 ++++++++++++++++-----------------
 1 file changed, 16 insertions(+), 17 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/min_ident_chars.rs b/clippy_lints/src/min_ident_chars.rs
index 316c2bf122c..d49bb0ca6e2 100644
--- a/clippy_lints/src/min_ident_chars.rs
+++ b/clippy_lints/src/min_ident_chars.rs
@@ -34,7 +34,6 @@ declare_clippy_lint! {
     ///     let title = movie.title;
     /// }
     /// ```
-    /// ```
     #[clippy::version = "1.72.0"]
     pub MIN_IDENT_CHARS,
     restriction,
@@ -48,6 +47,17 @@ pub struct MinIdentChars {
     pub min_ident_chars_threshold: u64,
 }
 
+impl MinIdentChars {
+    #[expect(clippy::cast_possible_truncation)]
+    fn is_ident_too_short(&self, cx: &LateContext<'_>, str: &str, span: Span) -> bool {
+        !in_external_macro(cx.sess(), span)
+            && str.len() <= self.min_ident_chars_threshold as usize
+            && !str.starts_with('_')
+            && !str.is_empty()
+            && self.allowed_idents_below_min_chars.get(&str.to_owned()).is_none()
+    }
+}
+
 impl LateLintPass<'_> for MinIdentChars {
     fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
         if self.min_ident_chars_threshold == 0 {
@@ -58,15 +68,10 @@ impl LateLintPass<'_> for MinIdentChars {
     }
 
     // This is necessary as `Node::Pat`s are not visited in `visit_id`. :/
-    #[expect(clippy::cast_possible_truncation)]
     fn check_pat(&mut self, cx: &LateContext<'_>, pat: &Pat<'_>) {
         if let PatKind::Binding(_, _, ident, ..) = pat.kind
             && let str = ident.as_str()
-            && !in_external_macro(cx.sess(), ident.span)
-            && str.len() <= self.min_ident_chars_threshold as usize
-            && !str.starts_with('_')
-            && !str.is_empty()
-            && self.allowed_idents_below_min_chars.get(&str.to_owned()).is_none()
+            && self.is_ident_too_short(cx, str, ident.span)
         {
             emit_min_ident_chars(self, cx, str, ident.span);
         }
@@ -79,12 +84,11 @@ struct IdentVisitor<'cx, 'tcx> {
 }
 
 impl Visitor<'_> for IdentVisitor<'_, '_> {
-    #[expect(clippy::cast_possible_truncation)]
     fn visit_id(&mut self, hir_id: HirId) {
         let Self { conf, cx } = *self;
-        // Reimplementation of `find`, as it uses indexing, which can (and will in async functions) panic.
-        // This should probably be fixed on the rustc side, this is just a temporary workaround.
-        // FIXME: Remove me if/when this is fixed in rustc
+        // FIXME(#112534) Reimplementation of `find`, as it uses indexing, which can (and will in
+        // async functions, or really anything async) panic. This should probably be fixed on the
+        // rustc side, this is just a temporary workaround.
         let node = if hir_id.local_id == ItemLocalId::from_u32(0) {
             // In this case, we can just use `find`, `Owner`'s `node` field is private anyway so we can't
             // reimplement it even if we wanted to
@@ -103,12 +107,7 @@ impl Visitor<'_> for IdentVisitor<'_, '_> {
         };
 
         let str = ident.as_str();
-        if !in_external_macro(cx.sess(), ident.span)
-            && str.len() <= conf.min_ident_chars_threshold as usize
-            && !str.starts_with('_')
-            && !str.is_empty()
-            && conf.allowed_idents_below_min_chars.get(&str.to_owned()).is_none()
-        {
+        if conf.is_ident_too_short(cx, str, ident.span) {
             if let Node::Item(item) = node && let ItemKind::Use(..) = item.kind {
                 return;
             }
-- 
cgit 1.4.1-3-g733a5


From 7312a93a069f93b8d82cee08100444540e51ffcb Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Thu, 25 May 2023 19:46:05 +0200
Subject: new lint: `large_stack_frames`

---
 CHANGELOG.md                                       |   1 +
 book/src/lint_configuration.md                     |  10 +-
 clippy_lints/src/declared_lints.rs                 |   1 +
 clippy_lints/src/large_stack_frames.rs             | 162 +++++++++++++++++++++
 clippy_lints/src/lib.rs                            |   3 +
 clippy_lints/src/utils/conf.rs                     |   4 +
 .../toml_unknown_key/conf_unknown_key.stderr       |   1 +
 tests/ui/large_stack_frames.rs                     |  44 ++++++
 tests/ui/large_stack_frames.stderr                 |  37 +++++
 9 files changed, 262 insertions(+), 1 deletion(-)
 create mode 100644 clippy_lints/src/large_stack_frames.rs
 create mode 100644 tests/ui/large_stack_frames.rs
 create mode 100644 tests/ui/large_stack_frames.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 2d62bfd4f99..8624fa136e7 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4815,6 +4815,7 @@ Released 2018-09-13
 [`get_last_with_len`]: https://rust-lang.github.io/rust-clippy/master/index.html#get_last_with_len
 [`get_unwrap`]: https://rust-lang.github.io/rust-clippy/master/index.html#get_unwrap
 [`host_endian_bytes`]: https://rust-lang.github.io/rust-clippy/master/index.html#host_endian_bytes
+[`large_stack_frames`]: https://rust-lang.github.io/rust-clippy/master/index.html#large_stack_frames
 [`identity_conversion`]: https://rust-lang.github.io/rust-clippy/master/index.html#identity_conversion
 [`identity_op`]: https://rust-lang.github.io/rust-clippy/master/index.html#identity_op
 [`if_let_mutex`]: https://rust-lang.github.io/rust-clippy/master/index.html#if_let_mutex
diff --git a/book/src/lint_configuration.md b/book/src/lint_configuration.md
index b2e11d8de67..9e8729a1afe 100644
--- a/book/src/lint_configuration.md
+++ b/book/src/lint_configuration.md
@@ -338,7 +338,15 @@ The maximum allowed size for arrays on the stack
 * [`large_const_arrays`](https://rust-lang.github.io/rust-clippy/master/index.html#large_const_arrays)
 
 
-## `vec-box-size-threshold`
+### stack-size-threshold
+The maximum allowed stack size for functions in bytes
+
+**Default Value:** `512000` (`u64`)
+
+* [large_stack_frames](https://rust-lang.github.io/rust-clippy/master/index.html#large_stack_frames)
+
+
+### vec-box-size-threshold
 The size of the boxed type in bytes, where boxing in a `Vec` is allowed
 
 **Default Value:** `4096` (`u64`)
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 769774b27c4..8fd8705b445 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -198,6 +198,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::functions::TOO_MANY_ARGUMENTS_INFO,
     crate::functions::TOO_MANY_LINES_INFO,
     crate::future_not_send::FUTURE_NOT_SEND_INFO,
+    crate::large_stack_frames::LARGE_STACK_FRAMES_INFO,
     crate::if_let_mutex::IF_LET_MUTEX_INFO,
     crate::if_not_else::IF_NOT_ELSE_INFO,
     crate::if_then_some_else_none::IF_THEN_SOME_ELSE_NONE_INFO,
diff --git a/clippy_lints/src/large_stack_frames.rs b/clippy_lints/src/large_stack_frames.rs
new file mode 100644
index 00000000000..2ab1f669460
--- /dev/null
+++ b/clippy_lints/src/large_stack_frames.rs
@@ -0,0 +1,162 @@
+use std::ops::AddAssign;
+
+use clippy_utils::diagnostics::span_lint_and_then;
+use rustc_hir::def_id::LocalDefId;
+use rustc_hir::intravisit::FnKind;
+use rustc_hir::Body;
+use rustc_hir::FnDecl;
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::declare_tool_lint;
+use rustc_session::impl_lint_pass;
+use rustc_span::Span;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for functions that use a lot of stack space.
+    ///
+    /// This often happens when constructing a large type, such as an array with a lot of elements,
+    /// or constructing *many* smaller-but-still-large structs, or copying around a lot of large types.
+    ///
+    /// This lint is a more general version of [`large_stack_arrays`](https://rust-lang.github.io/rust-clippy/master/#large_stack_arrays)
+    /// that is intended to look at functions as a whole instead of only individual array expressions inside of a function.
+    ///
+    /// ### Why is this bad?
+    /// The stack region of memory is very limited in size (usually *much* smaller than the heap) and attempting to
+    /// use too much will result in a stack overflow and crash the program.
+    /// To avoid this, you should consider allocating large types on the heap instead (e.g. by boxing them).
+    ///
+    /// Keep in mind that the code path to construction of large types does not even need to be reachable;
+    /// it purely needs to *exist* inside of the function to contribute to the stack size.
+    /// For example, this causes a stack overflow even though the branch is unreachable (with `-Zmir-opt-level=0`):
+    /// ```rust,ignore
+    /// fn main() {
+    ///     if false {
+    ///         let x = [0u8; 10000000]; // 10 MB stack array
+    ///         black_box(&x);
+    ///     }
+    /// }
+    /// ```
+    ///
+    /// ### Drawbacks
+    /// False positives. The stack size that clippy sees is an estimated value and can be vastly different
+    /// from the actual stack usage after optimizations passes have run (especially true in release mode).
+    /// Modern compilers are very smart and are able to optimize away a lot of unnecessary stack allocations.
+    /// In debug mode however, it is usually more accurate.
+    ///
+    /// This lint works by summing up the size of all locals and comparing them against a (configurable, but high-by-default)
+    /// threshold.
+    /// Note that "locals" in this context refers to [MIR locals](https://rustc-dev-guide.rust-lang.org/mir/index.html#key-mir-vocabulary),
+    /// i.e. real local variables that the user typed, storage for temporary values, function arguments
+    /// and the return value.
+    ///
+    /// ### Example
+    /// This function creates four 500 KB arrays on the stack. Quite big but just small enough to not trigger `large_stack_arrays`.
+    /// However, looking at the function as a whole, it's clear that this uses a lot of stack space.
+    /// ```rust
+    /// struct QuiteLargeType([u8; 500_000]);
+    /// fn foo() {
+    ///     // ... some function that uses a lot of stack space ...
+    ///     let _x1 = QuiteLargeType([0; 500_000]);
+    ///     let _x2 = QuiteLargeType([0; 500_000]);
+    ///     let _x3 = QuiteLargeType([0; 500_000]);
+    ///     let _x4 = QuiteLargeType([0; 500_000]);
+    /// }
+    /// ```
+    ///
+    /// Instead of doing this, allocate the arrays on the heap.
+    /// This currently requires going through a `Vec` first and then converting it to a `Box`:
+    /// ```rust
+    /// struct NotSoLargeType(Box<[u8]>);
+    ///
+    /// fn foo() {
+    ///     let _x1 = NotSoLargeType(vec![0; 500_000].into_boxed_slice());
+    /// //                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  Now heap allocated.
+    /// //                                                                The size of `NotSoLargeType` is 16 bytes.
+    /// //  ...
+    /// }
+    /// ```
+    #[clippy::version = "1.71.0"]
+    pub LARGE_STACK_FRAMES,
+    nursery,
+    "checks for functions that allocate a lot of stack space"
+}
+
+pub struct LargeStackFrames {
+    maximum_allowed_size: u64,
+}
+
+impl LargeStackFrames {
+    #[must_use]
+    pub fn new(size: u64) -> Self {
+        Self {
+            maximum_allowed_size: size,
+        }
+    }
+}
+
+impl_lint_pass!(LargeStackFrames => [LARGE_STACK_FRAMES]);
+
+#[derive(Copy, Clone)]
+enum Space {
+    Used(u64),
+    Overflow,
+}
+
+impl Space {
+    pub fn exceeds_limit(self, limit: u64) -> bool {
+        match self {
+            Self::Used(used) => used > limit,
+            Self::Overflow => true,
+        }
+    }
+}
+
+impl AddAssign<u64> for Space {
+    fn add_assign(&mut self, rhs: u64) {
+        if let Self::Used(lhs) = self {
+            match lhs.checked_add(rhs) {
+                Some(sum) => *self = Self::Used(sum),
+                None => {
+                    *self = Self::Overflow;
+                },
+            }
+        }
+    }
+}
+
+impl<'tcx> LateLintPass<'tcx> for LargeStackFrames {
+    fn check_fn(
+        &mut self,
+        cx: &LateContext<'tcx>,
+        _: FnKind<'tcx>,
+        _: &'tcx FnDecl<'tcx>,
+        _: &'tcx Body<'tcx>,
+        span: Span,
+        local_def_id: LocalDefId,
+    ) {
+        let def_id = local_def_id.to_def_id();
+
+        let mir = cx.tcx.optimized_mir(def_id);
+        let param_env = cx.tcx.param_env(def_id);
+
+        let mut frame_size = Space::Used(0);
+
+        for local in &mir.local_decls {
+            if let Ok(layout) = cx.tcx.layout_of(param_env.and(local.ty)) {
+                frame_size += layout.size.bytes();
+            }
+        }
+
+        if frame_size.exceeds_limit(self.maximum_allowed_size) {
+            span_lint_and_then(
+                cx,
+                LARGE_STACK_FRAMES,
+                span,
+                "this function allocates a large amount of stack space",
+                |diag| {
+                    diag.note("allocating large amounts of stack space can overflow the stack");
+                },
+            );
+        }
+    }
+}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index dcf1c6f64a4..2fa95e2b447 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -142,6 +142,7 @@ mod from_raw_with_void_ptr;
 mod from_str_radix_10;
 mod functions;
 mod future_not_send;
+mod large_stack_frames;
 mod if_let_mutex;
 mod if_not_else;
 mod if_then_some_else_none;
@@ -1042,6 +1043,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
             min_ident_chars_threshold,
         })
     });
+    let stack_size_threshold = conf.stack_size_threshold;
+    store.register_late_pass(move |_| Box::new(large_stack_frames::LargeStackFrames::new(stack_size_threshold)));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 0a581e0ab9b..f6c7c1fa065 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -387,6 +387,10 @@ define_Conf! {
     ///
     /// The maximum allowed size for arrays on the stack
     (array_size_threshold: u64 = 512_000),
+    /// Lint: LARGE_STACK_FRAMES.
+    ///
+    /// The maximum allowed stack size for functions in bytes
+    (stack_size_threshold: u64 = 512_000),
     /// Lint: VEC_BOX.
     ///
     /// The size of the boxed type in bytes, where boxing in a `Vec` is allowed
diff --git a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
index c546d95eb46..79af9cc9ac0 100644
--- a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
+++ b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
@@ -44,6 +44,7 @@ error: error reading Clippy's configuration file: unknown field `foobar`, expect
            semicolon-inside-block-ignore-singleline
            semicolon-outside-block-ignore-multiline
            single-char-binding-names-threshold
+           stack-size-threshold
            standard-macro-braces
            suppress-restriction-lint-in-const
            third-party
diff --git a/tests/ui/large_stack_frames.rs b/tests/ui/large_stack_frames.rs
new file mode 100644
index 00000000000..cd9d0c8a67a
--- /dev/null
+++ b/tests/ui/large_stack_frames.rs
@@ -0,0 +1,44 @@
+#![allow(unused, incomplete_features)]
+#![warn(clippy::large_stack_frames)]
+#![feature(unsized_locals)]
+
+use std::hint::black_box;
+
+fn generic<T: Default>() {
+    let x = T::default();
+    black_box(&x);
+}
+
+fn unsized_local() {
+    let x: dyn std::fmt::Display = *(Box::new(1) as Box<dyn std::fmt::Display>);
+    black_box(&x);
+}
+
+struct ArrayDefault<const N: usize>([u8; N]);
+
+impl<const N: usize> Default for ArrayDefault<N> {
+    fn default() -> Self {
+        Self([0; N])
+    }
+}
+
+fn many_small_arrays() {
+    let x = [0u8; 500_000];
+    let x2 = [0u8; 500_000];
+    let x3 = [0u8; 500_000];
+    let x4 = [0u8; 500_000];
+    let x5 = [0u8; 500_000];
+    black_box((&x, &x2, &x3, &x4, &x5));
+}
+
+fn large_return_value() -> ArrayDefault<1_000_000> {
+    Default::default()
+}
+
+fn large_fn_arg(x: ArrayDefault<1_000_000>) {
+    black_box(&x);
+}
+
+fn main() {
+    generic::<ArrayDefault<1_000_000>>();
+}
diff --git a/tests/ui/large_stack_frames.stderr b/tests/ui/large_stack_frames.stderr
new file mode 100644
index 00000000000..d57df8596fe
--- /dev/null
+++ b/tests/ui/large_stack_frames.stderr
@@ -0,0 +1,37 @@
+error: this function allocates a large amount of stack space
+  --> $DIR/large_stack_frames.rs:25:1
+   |
+LL | / fn many_small_arrays() {
+LL | |     let x = [0u8; 500_000];
+LL | |     let x2 = [0u8; 500_000];
+LL | |     let x3 = [0u8; 500_000];
+...  |
+LL | |     black_box((&x, &x2, &x3, &x4, &x5));
+LL | | }
+   | |_^
+   |
+   = note: allocating large amounts of stack space can overflow the stack
+   = note: `-D clippy::large-stack-frames` implied by `-D warnings`
+
+error: this function allocates a large amount of stack space
+  --> $DIR/large_stack_frames.rs:34:1
+   |
+LL | / fn large_return_value() -> ArrayDefault<1_000_000> {
+LL | |     Default::default()
+LL | | }
+   | |_^
+   |
+   = note: allocating large amounts of stack space can overflow the stack
+
+error: this function allocates a large amount of stack space
+  --> $DIR/large_stack_frames.rs:38:1
+   |
+LL | / fn large_fn_arg(x: ArrayDefault<1_000_000>) {
+LL | |     black_box(&x);
+LL | | }
+   | |_^
+   |
+   = note: allocating large amounts of stack space can overflow the stack
+
+error: aborting due to 3 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 760f91f895fb1da89a4999c7de35564a18f903aa Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Thu, 25 May 2023 19:52:08 +0200
Subject: `cargo dev update_lints`

---
 CHANGELOG.md                       | 1 +
 clippy_lints/src/declared_lints.rs | 2 +-
 clippy_lints/src/lib.rs            | 2 +-
 3 files changed, 3 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 8624fa136e7..e8337c3b6d0 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4884,6 +4884,7 @@ Released 2018-09-13
 [`large_futures`]: https://rust-lang.github.io/rust-clippy/master/index.html#large_futures
 [`large_include_file`]: https://rust-lang.github.io/rust-clippy/master/index.html#large_include_file
 [`large_stack_arrays`]: https://rust-lang.github.io/rust-clippy/master/index.html#large_stack_arrays
+[`large_stack_frames`]: https://rust-lang.github.io/rust-clippy/master/index.html#large_stack_frames
 [`large_types_passed_by_value`]: https://rust-lang.github.io/rust-clippy/master/index.html#large_types_passed_by_value
 [`len_without_is_empty`]: https://rust-lang.github.io/rust-clippy/master/index.html#len_without_is_empty
 [`len_zero`]: https://rust-lang.github.io/rust-clippy/master/index.html#len_zero
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 8fd8705b445..523faa302dc 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -198,7 +198,6 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::functions::TOO_MANY_ARGUMENTS_INFO,
     crate::functions::TOO_MANY_LINES_INFO,
     crate::future_not_send::FUTURE_NOT_SEND_INFO,
-    crate::large_stack_frames::LARGE_STACK_FRAMES_INFO,
     crate::if_let_mutex::IF_LET_MUTEX_INFO,
     crate::if_not_else::IF_NOT_ELSE_INFO,
     crate::if_then_some_else_none::IF_THEN_SOME_ELSE_NONE_INFO,
@@ -229,6 +228,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::large_futures::LARGE_FUTURES_INFO,
     crate::large_include_file::LARGE_INCLUDE_FILE_INFO,
     crate::large_stack_arrays::LARGE_STACK_ARRAYS_INFO,
+    crate::large_stack_frames::LARGE_STACK_FRAMES_INFO,
     crate::len_zero::COMPARISON_TO_EMPTY_INFO,
     crate::len_zero::LEN_WITHOUT_IS_EMPTY_INFO,
     crate::len_zero::LEN_ZERO_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 2fa95e2b447..71447724790 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -142,7 +142,6 @@ mod from_raw_with_void_ptr;
 mod from_str_radix_10;
 mod functions;
 mod future_not_send;
-mod large_stack_frames;
 mod if_let_mutex;
 mod if_not_else;
 mod if_then_some_else_none;
@@ -169,6 +168,7 @@ mod large_enum_variant;
 mod large_futures;
 mod large_include_file;
 mod large_stack_arrays;
+mod large_stack_frames;
 mod len_zero;
 mod let_if_seq;
 mod let_underscore;
-- 
cgit 1.4.1-3-g733a5


From 52c6ef77fd620f9efc486280fd237adaddd9fc29 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Thu, 25 May 2023 20:07:20 +0200
Subject: fmt

---
 clippy_lints/src/large_stack_frames.rs | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/large_stack_frames.rs b/clippy_lints/src/large_stack_frames.rs
index 2ab1f669460..0da953e6917 100644
--- a/clippy_lints/src/large_stack_frames.rs
+++ b/clippy_lints/src/large_stack_frames.rs
@@ -116,9 +116,7 @@ impl AddAssign<u64> for Space {
         if let Self::Used(lhs) = self {
             match lhs.checked_add(rhs) {
                 Some(sum) => *self = Self::Used(sum),
-                None => {
-                    *self = Self::Overflow;
-                },
+                None => *self = Self::Overflow,
             }
         }
     }
-- 
cgit 1.4.1-3-g733a5


From 6b232fdee9c8d65ca40ce112a83e92a8c395c398 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Thu, 25 May 2023 20:30:38 +0200
Subject: use span_lint_and_note

---
 clippy_lints/src/large_stack_frames.rs | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/large_stack_frames.rs b/clippy_lints/src/large_stack_frames.rs
index 0da953e6917..87daa2e7da0 100644
--- a/clippy_lints/src/large_stack_frames.rs
+++ b/clippy_lints/src/large_stack_frames.rs
@@ -1,6 +1,6 @@
 use std::ops::AddAssign;
 
-use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::diagnostics::span_lint_and_note;
 use rustc_hir::def_id::LocalDefId;
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::Body;
@@ -146,14 +146,13 @@ impl<'tcx> LateLintPass<'tcx> for LargeStackFrames {
         }
 
         if frame_size.exceeds_limit(self.maximum_allowed_size) {
-            span_lint_and_then(
+            span_lint_and_note(
                 cx,
                 LARGE_STACK_FRAMES,
                 span,
                 "this function allocates a large amount of stack space",
-                |diag| {
-                    diag.note("allocating large amounts of stack space can overflow the stack");
-                },
+                None,
+                "allocating large amounts of stack space can overflow the stack",
             );
         }
     }
-- 
cgit 1.4.1-3-g733a5


From 7aa4babb5ce26208d49be1c1fc404962d87a721e Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Wed, 7 Jun 2023 21:08:05 +0200
Subject: rename "drawbacks" to "known issues"

---
 clippy_lints/src/large_stack_frames.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/large_stack_frames.rs b/clippy_lints/src/large_stack_frames.rs
index 87daa2e7da0..d638279b5d1 100644
--- a/clippy_lints/src/large_stack_frames.rs
+++ b/clippy_lints/src/large_stack_frames.rs
@@ -37,7 +37,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     ///
-    /// ### Drawbacks
+    /// ### Known issues
     /// False positives. The stack size that clippy sees is an estimated value and can be vastly different
     /// from the actual stack usage after optimizations passes have run (especially true in release mode).
     /// Modern compilers are very smart and are able to optimize away a lot of unnecessary stack allocations.
-- 
cgit 1.4.1-3-g733a5


From de7d43bc610f5f2ac107d947de1c2438401f7a2b Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Thu, 8 Jun 2023 12:42:12 +0200
Subject: make lint description easier to read, prevent ICE

---
 clippy_lints/src/large_stack_frames.rs | 15 +++++++++------
 1 file changed, 9 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/large_stack_frames.rs b/clippy_lints/src/large_stack_frames.rs
index d638279b5d1..9c0cc978a39 100644
--- a/clippy_lints/src/large_stack_frames.rs
+++ b/clippy_lints/src/large_stack_frames.rs
@@ -1,6 +1,7 @@
 use std::ops::AddAssign;
 
 use clippy_utils::diagnostics::span_lint_and_note;
+use clippy_utils::fn_has_unsatisfiable_preds;
 use rustc_hir::def_id::LocalDefId;
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::Body;
@@ -27,7 +28,7 @@ declare_clippy_lint! {
     ///
     /// Keep in mind that the code path to construction of large types does not even need to be reachable;
     /// it purely needs to *exist* inside of the function to contribute to the stack size.
-    /// For example, this causes a stack overflow even though the branch is unreachable (with `-Zmir-opt-level=0`):
+    /// For example, this causes a stack overflow even though the branch is unreachable:
     /// ```rust,ignore
     /// fn main() {
     ///     if false {
@@ -43,11 +44,9 @@ declare_clippy_lint! {
     /// Modern compilers are very smart and are able to optimize away a lot of unnecessary stack allocations.
     /// In debug mode however, it is usually more accurate.
     ///
-    /// This lint works by summing up the size of all locals and comparing them against a (configurable, but high-by-default)
-    /// threshold.
-    /// Note that "locals" in this context refers to [MIR locals](https://rustc-dev-guide.rust-lang.org/mir/index.html#key-mir-vocabulary),
-    /// i.e. real local variables that the user typed, storage for temporary values, function arguments
-    /// and the return value.
+    /// This lint works by summing up the size of all variables that the user typed, variables that were
+    /// implicitly introduced by the compiler for temporaries, function arguments and the return value,
+    /// and comparing them against a (configurable, but high-by-default).
     ///
     /// ### Example
     /// This function creates four 500 KB arrays on the stack. Quite big but just small enough to not trigger `large_stack_arrays`.
@@ -133,6 +132,10 @@ impl<'tcx> LateLintPass<'tcx> for LargeStackFrames {
         local_def_id: LocalDefId,
     ) {
         let def_id = local_def_id.to_def_id();
+        // Building MIR for `fn`s with unsatisfiable preds results in ICE.
+        if fn_has_unsatisfiable_preds(cx, def_id) {
+            return;
+        }
 
         let mir = cx.tcx.optimized_mir(def_id);
         let param_env = cx.tcx.param_env(def_id);
-- 
cgit 1.4.1-3-g733a5


From b309875fd8e64c2c33d4a4d0576cc40891ad18be Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Mon, 12 Jun 2023 15:48:04 +0200
Subject: [`useless_vec`]: detect unnecessary `vec![_]`

---
 clippy_lints/src/vec.rs | 97 +++++++++++++++++++++----------------------------
 1 file changed, 42 insertions(+), 55 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/vec.rs b/clippy_lints/src/vec.rs
index 25b6f40762d..2a594e750b9 100644
--- a/clippy_lints/src/vec.rs
+++ b/clippy_lints/src/vec.rs
@@ -8,7 +8,6 @@ use clippy_utils::ty::is_copy;
 use clippy_utils::visitors::for_each_local_use_after_expr;
 use clippy_utils::{get_parent_expr, higher, is_trait_method};
 use if_chain::if_chain;
-use rustc_ast::BindingAnnotation;
 use rustc_errors::Applicability;
 use rustc_hir::{BorrowKind, Expr, ExprKind, Mutability, Node, PatKind};
 use rustc_lint::{LateContext, LateLintPass};
@@ -54,11 +53,7 @@ declare_clippy_lint! {
 impl_lint_pass!(UselessVec => [USELESS_VEC]);
 
 fn adjusts_to_slice(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
-    if let ty::Ref(_, ty, _) = cx.typeck_results().expr_ty_adjusted(e).kind() {
-        ty.is_slice()
-    } else {
-        false
-    }
+    matches!(cx.typeck_results().expr_ty_adjusted(e).kind(), ty::Ref(_, ty, _) if ty.is_slice())
 }
 
 /// Checks if the given expression is a method call to a `Vec` method
@@ -76,13 +71,21 @@ fn is_allowed_vec_method(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
 
 impl<'tcx> LateLintPass<'tcx> for UselessVec {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        // search for `&vec![_]` expressions where the adjusted type is `&[_]`
+        // search for `&vec![_]` or `vec![_]` expressions where the adjusted type is `&[_]`
         if_chain! {
             if adjusts_to_slice(cx, expr);
-            if let ExprKind::AddrOf(BorrowKind::Ref, mutability, addressee) = expr.kind;
-            if let Some(vec_args) = higher::VecArgs::hir(cx, addressee);
+            if let Some(vec_args) = higher::VecArgs::hir(cx, expr.peel_borrows());
             then {
-                self.check_vec_macro(cx, &vec_args, mutability, expr.span, SuggestSlice::Yes);
+                let (suggest_slice, span) = if let ExprKind::AddrOf(BorrowKind::Ref, mutability, _) = expr.kind {
+                    // `expr` is `&vec![_]`, so suggest `&[_]` (or `&mut[_]` resp.)
+                    (SuggestedType::SliceRef(mutability), expr.span)
+                } else {
+                    // `expr` is the `vec![_]` expansion, so suggest `[_]`
+                    // and also use the span of the actual `vec![_]` expression
+                    (SuggestedType::Array, expr.span.ctxt().outer_expn_data().call_site)
+                };
+
+                self.check_vec_macro(cx, &vec_args, span, suggest_slice);
             }
         }
 
@@ -93,7 +96,7 @@ impl<'tcx> LateLintPass<'tcx> for UselessVec {
             // for now ignore locals with type annotations.
             // this is to avoid compile errors when doing the suggestion here: let _: Vec<_> = vec![..];
             && local.ty.is_none()
-            && let PatKind::Binding(BindingAnnotation(_, mutbl), id, ..) = local.pat.kind
+            && let PatKind::Binding(_, id, ..) = local.pat.kind
             && is_copy(cx, vec_type(cx.typeck_results().expr_ty_adjusted(expr)))
         {
             let only_slice_uses = for_each_local_use_after_expr(cx, id, expr.hir_id, |expr| {
@@ -113,9 +116,8 @@ impl<'tcx> LateLintPass<'tcx> for UselessVec {
                 self.check_vec_macro(
                     cx,
                     &vec_args,
-                    mutbl,
                     expr.span.ctxt().outer_expn_data().call_site,
-                    SuggestSlice::No
+                    SuggestedType::Array
                 );
             }
         }
@@ -128,7 +130,7 @@ impl<'tcx> LateLintPass<'tcx> for UselessVec {
             then {
                 // report the error around the `vec!` not inside `<std macros>:`
                 let span = arg.span.ctxt().outer_expn_data().call_site;
-                self.check_vec_macro(cx, &vec_args, Mutability::Not, span, SuggestSlice::No);
+                self.check_vec_macro(cx, &vec_args, span, SuggestedType::Array);
             }
         }
     }
@@ -137,11 +139,11 @@ impl<'tcx> LateLintPass<'tcx> for UselessVec {
 }
 
 #[derive(Copy, Clone)]
-enum SuggestSlice {
+enum SuggestedType {
     /// Suggest using a slice `&[..]` / `&mut [..]`
-    Yes,
+    SliceRef(Mutability),
     /// Suggest using an array: `[..]`
-    No,
+    Array,
 }
 
 impl UselessVec {
@@ -149,17 +151,11 @@ impl UselessVec {
         &mut self,
         cx: &LateContext<'tcx>,
         vec_args: &higher::VecArgs<'tcx>,
-        mutability: Mutability,
         span: Span,
-        suggest_slice: SuggestSlice,
+        suggest_slice: SuggestedType,
     ) {
         let mut applicability = Applicability::MachineApplicable;
 
-        let (borrow_prefix_mut, borrow_prefix) = match suggest_slice {
-            SuggestSlice::Yes => ("&mut ", "&"),
-            SuggestSlice::No => ("", ""),
-        };
-
         let snippet = match *vec_args {
             higher::VecArgs::Repeat(elem, len) => {
                 if let Some(Constant::Int(len_constant)) = constant(cx, cx.typeck_results(), len) {
@@ -168,21 +164,13 @@ impl UselessVec {
                         return;
                     }
 
-                    match mutability {
-                        Mutability::Mut => {
-                            format!(
-                                "{borrow_prefix_mut}[{}; {}]",
-                                snippet_with_applicability(cx, elem.span, "elem", &mut applicability),
-                                snippet_with_applicability(cx, len.span, "len", &mut applicability)
-                            )
-                        },
-                        Mutability::Not => {
-                            format!(
-                                "{borrow_prefix}[{}; {}]",
-                                snippet_with_applicability(cx, elem.span, "elem", &mut applicability),
-                                snippet_with_applicability(cx, len.span, "len", &mut applicability)
-                            )
-                        },
+                    let elem = snippet_with_applicability(cx, elem.span, "elem", &mut applicability);
+                    let len = snippet_with_applicability(cx, len.span, "len", &mut applicability);
+
+                    match suggest_slice {
+                        SuggestedType::SliceRef(Mutability::Mut) => format!("&mut [{elem}; {len}]"),
+                        SuggestedType::SliceRef(Mutability::Not) => format!("&[{elem}; {len}]"),
+                        SuggestedType::Array => format!("[{elem}; {len}]"),
                     }
                 } else {
                     return;
@@ -194,25 +182,24 @@ impl UselessVec {
                         return;
                     }
                     let span = args[0].span.to(last.span);
+                    let args = snippet_with_applicability(cx, span, "..", &mut applicability);
 
-                    match mutability {
-                        Mutability::Mut => {
-                            format!(
-                                "{borrow_prefix_mut}[{}]",
-                                snippet_with_applicability(cx, span, "..", &mut applicability)
-                            )
+                    match suggest_slice {
+                        SuggestedType::SliceRef(Mutability::Mut) => {
+                            format!("&mut [{args}]")
+                        },
+                        SuggestedType::SliceRef(Mutability::Not) => {
+                            format!("&[{args}]")
                         },
-                        Mutability::Not => {
-                            format!(
-                                "{borrow_prefix}[{}]",
-                                snippet_with_applicability(cx, span, "..", &mut applicability)
-                            )
+                        SuggestedType::Array => {
+                            format!("[{args}]")
                         },
                     }
                 } else {
-                    match mutability {
-                        Mutability::Mut => format!("{borrow_prefix_mut}[]"),
-                        Mutability::Not => format!("{borrow_prefix}[]"),
+                    match suggest_slice {
+                        SuggestedType::SliceRef(Mutability::Mut) => "&mut []".to_owned(),
+                        SuggestedType::SliceRef(Mutability::Not) => "&[]".to_owned(),
+                        SuggestedType::Array => "[]".to_owned(),
                     }
                 }
             },
@@ -226,8 +213,8 @@ impl UselessVec {
             &format!(
                 "you can use {} directly",
                 match suggest_slice {
-                    SuggestSlice::Yes => "a slice",
-                    SuggestSlice::No => "an array",
+                    SuggestedType::SliceRef(_) => "a slice",
+                    SuggestedType::Array => "an array",
                 }
             ),
             snippet,
-- 
cgit 1.4.1-3-g733a5


From 5e20a572ee6ee956fa74bb63ff9d9ccd45611c8d Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Mon, 12 Jun 2023 15:05:14 +0000
Subject: Don't lint non-statement/faux empty `needless_if`s

---
 clippy_lints/src/needless_if.rs | 78 +++++++++++++----------------------------
 tests/ui/needless_if.fixed      | 65 +++++++++++++++++++++++++---------
 tests/ui/needless_if.rs         | 56 +++++++++++++++++++++++------
 tests/ui/needless_if.stderr     | 56 +++++++++++++++++++++--------
 4 files changed, 161 insertions(+), 94 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/needless_if.rs b/clippy_lints/src/needless_if.rs
index dbffbd6f0d3..ad5c3e1dc82 100644
--- a/clippy_lints/src/needless_if.rs
+++ b/clippy_lints/src/needless_if.rs
@@ -1,9 +1,6 @@
-use clippy_utils::{diagnostics::span_lint_and_sugg, is_from_proc_macro, source::snippet_with_applicability};
+use clippy_utils::{diagnostics::span_lint_and_sugg, higher::If, is_from_proc_macro, source::snippet_opt};
 use rustc_errors::Applicability;
-use rustc_hir::{
-    intravisit::{walk_expr, Visitor},
-    Expr, ExprKind, Node,
-};
+use rustc_hir::{ExprKind, Stmt, StmtKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -37,67 +34,42 @@ declare_clippy_lint! {
 declare_lint_pass!(NeedlessIf => [NEEDLESS_IF]);
 
 impl LateLintPass<'_> for NeedlessIf {
-    fn check_expr<'tcx>(&mut self, cx: &LateContext<'tcx>, expr: &Expr<'tcx>) {
-        if let ExprKind::If(if_expr, block, else_expr) = &expr.kind
-            && let ExprKind::Block(block, ..) = block.kind
+    fn check_stmt<'tcx>(&mut self, cx: &LateContext<'tcx>, stmt: &Stmt<'tcx>) {
+        if let StmtKind::Expr(expr) = stmt.kind
+            && let Some(If {cond, then, r#else: None }) = If::hir(expr)
+            && let ExprKind::Block(block, ..) = then.kind
             && block.stmts.is_empty()
             && block.expr.is_none()
-            && else_expr.is_none()
             && !in_external_macro(cx.sess(), expr.span)
+            && !is_from_proc_macro(cx, expr)
+            && let Some(then_snippet) = snippet_opt(cx, then.span)
+            // Ignore
+            // - empty macro expansions
+            // - empty reptitions in macro expansions
+            // - comments
+            // - #[cfg]'d out code
+            && then_snippet.chars().all(|ch| matches!(ch, '{' | '}') || ch.is_ascii_whitespace())
+            && let Some(cond_snippet) = snippet_opt(cx, cond.span)
         {
-            // Ignore `else if`
-            if let Some(parent_id) = cx.tcx.hir().opt_parent_id(expr.hir_id)
-                && let Some(Node::Expr(Expr {
-                    kind: ExprKind::If(_, _, Some(else_expr)),
-                    ..
-                })) = cx.tcx.hir().find(parent_id)
-                && else_expr.hir_id == expr.hir_id
-            {
-                return;
-            }
-
-            if is_any_if_let(if_expr) || is_from_proc_macro(cx, expr) {
-                return;
-            }
-
-            let mut app = Applicability::MachineApplicable;
-            let snippet = snippet_with_applicability(cx, if_expr.span, "{ ... }", &mut app);
-
             span_lint_and_sugg(
                 cx,
                 NEEDLESS_IF,
-                expr.span,
+                stmt.span,
                 "this `if` branch is empty",
                 "you can remove it",
-                if if_expr.can_have_side_effects() {
-                    format!("{snippet};")
+                if cond.can_have_side_effects() || !cx.tcx.hir().attrs(stmt.hir_id).is_empty() {
+                    // `{ foo }` or `{ foo } && bar` placed into a statement position would be
+                    // interpreted as a block statement, force it to be an expression
+                    if cond_snippet.starts_with('{') {
+                        format!("({cond_snippet});")
+                    } else {
+                        format!("{cond_snippet};")
+                    }
                 } else {
                     String::new()
                 },
-                app,
+                Applicability::MachineApplicable,
             );
         }
     }
 }
-
-/// Returns true if any `Expr` contained within this `Expr` is a `Let`, else false.
-///
-/// Really wish `Expr` had a `walk` method...
-fn is_any_if_let(expr: &Expr<'_>) -> bool {
-    let mut v = IsAnyLetVisitor(false);
-
-    v.visit_expr(expr);
-    v.0
-}
-
-struct IsAnyLetVisitor(bool);
-
-impl Visitor<'_> for IsAnyLetVisitor {
-    fn visit_expr(&mut self, expr: &Expr<'_>) {
-        if matches!(expr.kind, ExprKind::Let(..)) {
-            self.0 = true;
-        } else {
-            walk_expr(self, expr);
-        }
-    }
-}
diff --git a/tests/ui/needless_if.fixed b/tests/ui/needless_if.fixed
index bee579be1bf..8fd945f1a54 100644
--- a/tests/ui/needless_if.fixed
+++ b/tests/ui/needless_if.fixed
@@ -5,9 +5,12 @@
     clippy::blocks_in_if_conditions,
     clippy::if_same_then_else,
     clippy::ifs_same_cond,
+    clippy::let_unit_value,
     clippy::needless_else,
     clippy::no_effect,
     clippy::nonminimal_bool,
+    clippy::short_circuit_statement,
+    clippy::unnecessary_operation,
     unused
 )]
 #![warn(clippy::needless_if)]
@@ -16,12 +19,7 @@ extern crate proc_macros;
 use proc_macros::external;
 use proc_macros::with_span;
 
-fn no_side_effects() -> bool {
-    true
-}
-
-fn has_side_effects(a: &mut u32) -> bool {
-    *a = 1;
+fn maybe_side_effect() -> bool {
     true
 }
 
@@ -29,32 +27,67 @@ fn main() {
     // Lint
     
     // Do not remove the condition
-    no_side_effects();
-    let mut x = 0;
-    has_side_effects(&mut x);
-    assert_eq!(x, 1);
+    maybe_side_effect();
     // Do not lint
     if (true) {
     } else {
     }
-    {
+    ({
         return;
-    };
+    });
     // Do not lint if `else if` is present
     if (true) {
     } else if (true) {
     }
-    // Do not lint if any `let` is present
+    // Do not lint `if let` or let chains
     if let true = true {}
     if let true = true && true {}
     if true && let true = true {}
-    if {
+    // Can lint nested `if let`s
+    ({
         if let true = true && true { true } else { false }
-    } && true
-    {}
+    } && true);
     external! { if (true) {} }
     with_span! {
         span
         if (true) {}
     }
+
+    if true {
+        // comment
+    }
+
+    if true {
+        #[cfg(any())]
+        foo;
+    }
+
+    macro_rules! empty_expansion {
+        () => {};
+    }
+
+    if true {
+        empty_expansion!();
+    }
+
+    macro_rules! empty_repetition {
+        ($($t:tt)*) => {
+            if true {
+                $($t)*
+            }
+        }
+    }
+
+    empty_repetition!();
+
+    // Must be placed into an expression context to not be interpreted as a block
+    ({ maybe_side_effect() });
+    // Would be a block followed by `&&true` - a double reference to `true`
+    ({ maybe_side_effect() } && true);
+
+    // Don't leave trailing attributes
+    #[allow(unused)]
+    true;
+
+    let () = if maybe_side_effect() {};
 }
diff --git a/tests/ui/needless_if.rs b/tests/ui/needless_if.rs
index 1608d261a36..04868299a54 100644
--- a/tests/ui/needless_if.rs
+++ b/tests/ui/needless_if.rs
@@ -5,9 +5,12 @@
     clippy::blocks_in_if_conditions,
     clippy::if_same_then_else,
     clippy::ifs_same_cond,
+    clippy::let_unit_value,
     clippy::needless_else,
     clippy::no_effect,
     clippy::nonminimal_bool,
+    clippy::short_circuit_statement,
+    clippy::unnecessary_operation,
     unused
 )]
 #![warn(clippy::needless_if)]
@@ -16,12 +19,7 @@ extern crate proc_macros;
 use proc_macros::external;
 use proc_macros::with_span;
 
-fn no_side_effects() -> bool {
-    true
-}
-
-fn has_side_effects(a: &mut u32) -> bool {
-    *a = 1;
+fn maybe_side_effect() -> bool {
     true
 }
 
@@ -29,10 +27,7 @@ fn main() {
     // Lint
     if (true) {}
     // Do not remove the condition
-    if no_side_effects() {}
-    let mut x = 0;
-    if has_side_effects(&mut x) {}
-    assert_eq!(x, 1);
+    if maybe_side_effect() {}
     // Do not lint
     if (true) {
     } else {
@@ -44,10 +39,11 @@ fn main() {
     if (true) {
     } else if (true) {
     }
-    // Do not lint if any `let` is present
+    // Do not lint `if let` or let chains
     if let true = true {}
     if let true = true && true {}
     if true && let true = true {}
+    // Can lint nested `if let`s
     if {
         if let true = true && true { true } else { false }
     } && true
@@ -57,4 +53,42 @@ fn main() {
         span
         if (true) {}
     }
+
+    if true {
+        // comment
+    }
+
+    if true {
+        #[cfg(any())]
+        foo;
+    }
+
+    macro_rules! empty_expansion {
+        () => {};
+    }
+
+    if true {
+        empty_expansion!();
+    }
+
+    macro_rules! empty_repetition {
+        ($($t:tt)*) => {
+            if true {
+                $($t)*
+            }
+        }
+    }
+
+    empty_repetition!();
+
+    // Must be placed into an expression context to not be interpreted as a block
+    if { maybe_side_effect() } {}
+    // Would be a block followed by `&&true` - a double reference to `true`
+    if { maybe_side_effect() } && true {}
+
+    // Don't leave trailing attributes
+    #[allow(unused)]
+    if true {}
+
+    let () = if maybe_side_effect() {};
 }
diff --git a/tests/ui/needless_if.stderr b/tests/ui/needless_if.stderr
index 4236b0053eb..5cb42c36921 100644
--- a/tests/ui/needless_if.stderr
+++ b/tests/ui/needless_if.stderr
@@ -1,5 +1,5 @@
 error: this `if` branch is empty
-  --> $DIR/needless_if.rs:30:5
+  --> $DIR/needless_if.rs:28:5
    |
 LL |     if (true) {}
    |     ^^^^^^^^^^^^ help: you can remove it
@@ -7,19 +7,13 @@ LL |     if (true) {}
    = note: `-D clippy::needless-if` implied by `-D warnings`
 
 error: this `if` branch is empty
-  --> $DIR/needless_if.rs:32:5
-   |
-LL |     if no_side_effects() {}
-   |     ^^^^^^^^^^^^^^^^^^^^^^^ help: you can remove it: `no_side_effects();`
-
-error: this `if` branch is empty
-  --> $DIR/needless_if.rs:34:5
+  --> $DIR/needless_if.rs:30:5
    |
-LL |     if has_side_effects(&mut x) {}
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: you can remove it: `has_side_effects(&mut x);`
+LL |     if maybe_side_effect() {}
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^ help: you can remove it: `maybe_side_effect();`
 
 error: this `if` branch is empty
-  --> $DIR/needless_if.rs:40:5
+  --> $DIR/needless_if.rs:35:5
    |
 LL | /     if {
 LL | |         return;
@@ -28,10 +22,44 @@ LL | |     } {}
    |
 help: you can remove it
    |
-LL ~     {
+LL ~     ({
 LL +         return;
-LL +     };
+LL +     });
+   |
+
+error: this `if` branch is empty
+  --> $DIR/needless_if.rs:47:5
+   |
+LL | /     if {
+LL | |         if let true = true && true { true } else { false }
+LL | |     } && true
+LL | |     {}
+   | |______^
+   |
+help: you can remove it
+   |
+LL ~     ({
+LL +         if let true = true && true { true } else { false }
+LL +     } && true);
+   |
+
+error: this `if` branch is empty
+  --> $DIR/needless_if.rs:85:5
+   |
+LL |     if { maybe_side_effect() } {}
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: you can remove it: `({ maybe_side_effect() });`
+
+error: this `if` branch is empty
+  --> $DIR/needless_if.rs:87:5
+   |
+LL |     if { maybe_side_effect() } && true {}
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: you can remove it: `({ maybe_side_effect() } && true);`
+
+error: this `if` branch is empty
+  --> $DIR/needless_if.rs:91:5
    |
+LL |     if true {}
+   |     ^^^^^^^^^^ help: you can remove it: `true;`
 
-error: aborting due to 4 previous errors
+error: aborting due to 7 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From e707447a861739fa3e12e9c05c039c8c9c6b0544 Mon Sep 17 00:00:00 2001
From: Pavan Kumar Sunkara <pavan.sss1991@gmail.com>
Date: Thu, 16 Feb 2023 11:32:12 +0000
Subject: Boilerplate for the new lint

---
 clippy_lints/src/methods/mod.rs                    | 52 ++++++++++++++++++++++
 .../src/methods/unnecessary_literal_unwrap.rs      | 30 +++++++++++++
 tests/ui/unnecessary_literal_unwrap.rs             | 10 +++++
 tests/ui/unwrap_literal.rs                         | 17 -------
 4 files changed, 92 insertions(+), 17 deletions(-)
 create mode 100644 clippy_lints/src/methods/unnecessary_literal_unwrap.rs
 create mode 100644 tests/ui/unnecessary_literal_unwrap.rs
 delete mode 100644 tests/ui/unwrap_literal.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 88cbefbb5d3..f24f00ef6a7 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -93,6 +93,7 @@ mod unnecessary_fold;
 mod unnecessary_iter_cloned;
 mod unnecessary_join;
 mod unnecessary_lazy_eval;
+mod unnecessary_literal_unwrap;
 mod unnecessary_sort_by;
 mod unnecessary_to_owned;
 mod unwrap_or_else_default;
@@ -273,6 +274,56 @@ declare_clippy_lint! {
     "using `.unwrap()` on `Result` or `Option`, which should at least get a better message using `expect()`"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `.unwrap()` or `.unwrap_err()` calls on `Result`s and `.unwrap()` call on `Option`s.
+    ///
+    /// ### Why is this bad?
+    /// It is better to handle the `None` or `Err` case,
+    /// or at least call `.expect(_)` with a more helpful message. Still, for a lot of
+    /// quick-and-dirty code, `unwrap` is a good choice, which is why this lint is
+    /// `Allow` by default.
+    ///
+    /// `result.unwrap()` will let the thread panic on `Err` values.
+    /// Normally, you want to implement more sophisticated error handling,
+    /// and propagate errors upwards with `?` operator.
+    ///
+    /// Even if you want to panic on errors, not all `Error`s implement good
+    /// messages on display. Therefore, it may be beneficial to look at the places
+    /// where they may get displayed. Activate this lint to do just that.
+    ///
+    /// ### Examples
+    /// ```rust
+    /// # let option = Some(1);
+    /// # let result: Result<usize, ()> = Ok(1);
+    /// option.unwrap();
+    /// result.unwrap();
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust
+    /// # let option = Some(1);
+    /// # let result: Result<usize, ()> = Ok(1);
+    /// option.expect("more helpful message");
+    /// result.expect("more helpful message");
+    /// ```
+    ///
+    /// If [expect_used](#expect_used) is enabled, instead:
+    /// ```rust,ignore
+    /// # let option = Some(1);
+    /// # let result: Result<usize, ()> = Ok(1);
+    /// option?;
+    ///
+    /// // or
+    ///
+    /// result?;
+    /// ```
+    #[clippy::version = "1.69.0"]
+    pub UNNECESSARY_LITERAL_UNWRAP,
+    complexity,
+    "checks for calls of `unwrap()` or `expect()` on `Some()` that cannot fail"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for `.expect()` or `.expect_err()` calls on `Result`s and `.expect()` call on `Option`s.
@@ -3814,6 +3865,7 @@ impl Methods {
                         Some(("or", recv, [or_arg], or_span, _)) => {
                             or_then_unwrap::check(cx, expr, recv, or_arg, or_span);
                         },
+                        // unnecessary_literal_unwrap::check(cx, expr, recv);
                         _ => {},
                     }
                     unwrap_used::check(cx, expr, recv, false, self.allow_unwrap_in_tests);
diff --git a/clippy_lints/src/methods/unnecessary_literal_unwrap.rs b/clippy_lints/src/methods/unnecessary_literal_unwrap.rs
new file mode 100644
index 00000000000..39b30b7769d
--- /dev/null
+++ b/clippy_lints/src/methods/unnecessary_literal_unwrap.rs
@@ -0,0 +1,30 @@
+use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::ty::is_type_diagnostic_item;
+use rustc_hir as hir;
+use rustc_lint::LateContext;
+use rustc_span::sym;
+
+use super::UNNECESSARY_LITERAL_UNWRAP;
+
+pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr<'_>) {
+    let obj_ty = cx.typeck_results().expr_ty(recv).peel_refs();
+
+    let mess = if is_type_diagnostic_item(cx, obj_ty, sym::Option) {
+        Some((UNNECESSARY_LITERAL_UNWRAP, "an `Option`", "None", ""))
+    } else {
+        None
+    };
+
+    if let Some((lint, kind, none_value, none_prefix)) = mess {
+        let help = format!("if this value is {none_prefix}`{none_value}`, it will panic");
+
+        span_lint_and_help(
+            cx,
+            lint,
+            expr.span,
+            &format!("used `unwrap()` on {kind} value"),
+            None,
+            &help,
+        );
+    }
+}
diff --git a/tests/ui/unnecessary_literal_unwrap.rs b/tests/ui/unnecessary_literal_unwrap.rs
new file mode 100644
index 00000000000..9ae50517a3e
--- /dev/null
+++ b/tests/ui/unnecessary_literal_unwrap.rs
@@ -0,0 +1,10 @@
+#![warn(clippy::unnecessary_literal_unwrap)]
+
+fn unwrap_option() {
+    let val = Some(1).unwrap();
+    let val = Some(1).expect("this never happens");
+}
+
+fn main() {
+    unwrap_option();
+}
diff --git a/tests/ui/unwrap_literal.rs b/tests/ui/unwrap_literal.rs
deleted file mode 100644
index 917ef2126f5..00000000000
--- a/tests/ui/unwrap_literal.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-#![warn(clippy::unnecessary_unwrap)]
-
-fn unwrap_option() {
-    let val = Some(1).unwrap();
-    let val = Some(1).expect("this never happens");
-}
-
-fn unwrap_result() {
-    let val = Ok(1).unwrap();
-    let val = Err(1).unwrap_err();
-    let val = Ok(1).expect("this never happens");
-}
-
-fn main() {
-    unwrap_option();
-    unwrap_result();
-}
-- 
cgit 1.4.1-3-g733a5


From 5bb768177ee83065191b1f47111ecf63de347cff Mon Sep 17 00:00:00 2001
From: rsdy <p@symmetree.dev>
Date: Thu, 16 Feb 2023 11:49:19 +0000
Subject: Add hook

---
 clippy_lints/src/methods/mod.rs                        | 4 +++-
 clippy_lints/src/methods/unnecessary_literal_unwrap.rs | 2 +-
 2 files changed, 4 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index f24f00ef6a7..9d7b607ec7b 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3865,7 +3865,9 @@ impl Methods {
                         Some(("or", recv, [or_arg], or_span, _)) => {
                             or_then_unwrap::check(cx, expr, recv, or_arg, or_span);
                         },
-                        // unnecessary_literal_unwrap::check(cx, expr, recv);
+			Some((constructor @ "Some", _, _, _, _)) => {
+                            unnecessary_literal_unwrap::check(cx, expr, recv, constructor);
+			}
                         _ => {},
                     }
                     unwrap_used::check(cx, expr, recv, false, self.allow_unwrap_in_tests);
diff --git a/clippy_lints/src/methods/unnecessary_literal_unwrap.rs b/clippy_lints/src/methods/unnecessary_literal_unwrap.rs
index 39b30b7769d..3572f4965ef 100644
--- a/clippy_lints/src/methods/unnecessary_literal_unwrap.rs
+++ b/clippy_lints/src/methods/unnecessary_literal_unwrap.rs
@@ -6,7 +6,7 @@ use rustc_span::sym;
 
 use super::UNNECESSARY_LITERAL_UNWRAP;
 
-pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr<'_>) {
+pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr<'_>, constructor: &str) {
     let obj_ty = cx.typeck_results().expr_ty(recv).peel_refs();
 
     let mess = if is_type_diagnostic_item(cx, obj_ty, sym::Option) {
-- 
cgit 1.4.1-3-g733a5


From 2902359b3c922910b5b5bc1c2fa73c3e8bf2fcfb Mon Sep 17 00:00:00 2001
From: Pavan Kumar Sunkara <pavan.sss1991@gmail.com>
Date: Thu, 16 Feb 2023 11:32:12 +0000
Subject: Add the lint to the lib

---
 clippy_lints/src/declared_lints.rs | 1 +
 clippy_lints/src/methods/mod.rs    | 1 +
 2 files changed, 2 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 523faa302dc..62317dc60eb 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -408,6 +408,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::methods::UNNECESSARY_FOLD_INFO,
     crate::methods::UNNECESSARY_JOIN_INFO,
     crate::methods::UNNECESSARY_LAZY_EVALUATIONS_INFO,
+    crate::methods::UNNECESSARY_LITERAL_UNWRAP_INFO,
     crate::methods::UNNECESSARY_SORT_BY_INFO,
     crate::methods::UNNECESSARY_TO_OWNED_INFO,
     crate::methods::UNWRAP_OR_ELSE_DEFAULT_INFO,
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 9d7b607ec7b..6eb97227e0a 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3400,6 +3400,7 @@ impl_lint_pass!(Methods => [
     SUSPICIOUS_COMMAND_ARG_SPACE,
     CLEAR_WITH_DRAIN,
     MANUAL_NEXT_BACK,
+    UNNECESSARY_LITERAL_UNWRAP,
 ]);
 
 /// Extracts a method call name, args, and `Span` of the method name.
-- 
cgit 1.4.1-3-g733a5


From 0b1bb5fbf3a4d3e73192f95490ce7246f9fd1914 Mon Sep 17 00:00:00 2001
From: Pavan Kumar Sunkara <pavan.sss1991@gmail.com>
Date: Thu, 16 Feb 2023 13:36:51 +0000
Subject: Implement the lint

---
 clippy_lints/src/methods/mod.rs                       |  6 +++---
 .../src/methods/unnecessary_literal_unwrap.rs         | 19 +++++++------------
 tests/ui/unnecessary_literal_unwrap.stderr            | 11 +++++++++++
 3 files changed, 21 insertions(+), 15 deletions(-)
 create mode 100644 tests/ui/unnecessary_literal_unwrap.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 6eb97227e0a..7a7d5a588b0 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3866,11 +3866,11 @@ impl Methods {
                         Some(("or", recv, [or_arg], or_span, _)) => {
                             or_then_unwrap::check(cx, expr, recv, or_arg, or_span);
                         },
-			Some((constructor @ "Some", _, _, _, _)) => {
-                            unnecessary_literal_unwrap::check(cx, expr, recv, constructor);
-			}
                         _ => {},
                     }
+                    if let ExprKind::Call(recv, _) = recv.kind {
+                        unnecessary_literal_unwrap::check(cx, expr, recv, name);
+                    }
                     unwrap_used::check(cx, expr, recv, false, self.allow_unwrap_in_tests);
                 },
                 ("unwrap_err", []) => unwrap_used::check(cx, expr, recv, true, self.allow_unwrap_in_tests),
diff --git a/clippy_lints/src/methods/unnecessary_literal_unwrap.rs b/clippy_lints/src/methods/unnecessary_literal_unwrap.rs
index 3572f4965ef..181e4a06664 100644
--- a/clippy_lints/src/methods/unnecessary_literal_unwrap.rs
+++ b/clippy_lints/src/methods/unnecessary_literal_unwrap.rs
@@ -1,28 +1,23 @@
-use clippy_utils::diagnostics::span_lint_and_help;
-use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::{diagnostics::span_lint_and_help, is_res_lang_ctor, path_res};
 use rustc_hir as hir;
 use rustc_lint::LateContext;
-use rustc_span::sym;
 
 use super::UNNECESSARY_LITERAL_UNWRAP;
 
-pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr<'_>, constructor: &str) {
-    let obj_ty = cx.typeck_results().expr_ty(recv).peel_refs();
-
-    let mess = if is_type_diagnostic_item(cx, obj_ty, sym::Option) {
-        Some((UNNECESSARY_LITERAL_UNWRAP, "an `Option`", "None", ""))
+pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr<'_>, name: &str) {
+    let mess = if is_res_lang_ctor(cx, path_res(cx, recv), hir::LangItem::OptionSome) {
+        Some((UNNECESSARY_LITERAL_UNWRAP, "Some"))
     } else {
         None
     };
 
-    if let Some((lint, kind, none_value, none_prefix)) = mess {
-        let help = format!("if this value is {none_prefix}`{none_value}`, it will panic");
-
+    if let Some((lint, constructor)) = mess {
+        let help = String::new();
         span_lint_and_help(
             cx,
             lint,
             expr.span,
-            &format!("used `unwrap()` on {kind} value"),
+            &format!("used `{name}()` on `{constructor}` value"),
             None,
             &help,
         );
diff --git a/tests/ui/unnecessary_literal_unwrap.stderr b/tests/ui/unnecessary_literal_unwrap.stderr
new file mode 100644
index 00000000000..5f9881b2ae3
--- /dev/null
+++ b/tests/ui/unnecessary_literal_unwrap.stderr
@@ -0,0 +1,11 @@
+error: used `unwrap()` on `Some` value
+  --> $DIR/unnecessary_literal_unwrap.rs:4:15
+   |
+LL |     let val = Some(1).unwrap();
+   |               ^^^^^^^^^^^^^^^^
+   |
+   = help: 
+   = note: `-D clippy::unnecessary-literal-unwrap` implied by `-D warnings`
+
+error: aborting due to previous error
+
-- 
cgit 1.4.1-3-g733a5


From 21b88ce290ee90259fdd35b33923ee330acb0991 Mon Sep 17 00:00:00 2001
From: Pavan Kumar Sunkara <pavan.sss1991@gmail.com>
Date: Thu, 16 Feb 2023 13:44:11 +0000
Subject: Implement the lint for expect

---
 clippy_lints/src/methods/mod.rs            | 13 +++++++++----
 tests/ui/unnecessary_literal_unwrap.stderr | 10 +++++++++-
 2 files changed, 18 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 7a7d5a588b0..cb82aef1ef0 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3658,10 +3658,15 @@ impl Methods {
                         case_sensitive_file_extension_comparisons::check(cx, expr, span, recv, arg);
                     }
                 },
-                ("expect", [_]) => match method_call(recv) {
-                    Some(("ok", recv, [], _, _)) => ok_expect::check(cx, expr, recv),
-                    Some(("err", recv, [], err_span, _)) => err_expect::check(cx, expr, recv, span, err_span, &self.msrv),
-                    _ => expect_used::check(cx, expr, recv, false, self.allow_expect_in_tests),
+                ("expect", [_]) => {
+                    match method_call(recv) {
+                        Some(("ok", recv, [], _, _)) => ok_expect::check(cx, expr, recv),
+                        Some(("err", recv, [], err_span, _)) => err_expect::check(cx, expr, recv, span, err_span, &self.msrv),
+                        _ => expect_used::check(cx, expr, recv, false, self.allow_expect_in_tests),
+                    }
+                    if let ExprKind::Call(recv, _) = recv.kind {
+                        unnecessary_literal_unwrap::check(cx, expr, recv, name);
+                    }
                 },
                 ("expect_err", [_]) => expect_used::check(cx, expr, recv, true, self.allow_expect_in_tests),
                 ("extend", [arg]) => {
diff --git a/tests/ui/unnecessary_literal_unwrap.stderr b/tests/ui/unnecessary_literal_unwrap.stderr
index 5f9881b2ae3..414d4445cae 100644
--- a/tests/ui/unnecessary_literal_unwrap.stderr
+++ b/tests/ui/unnecessary_literal_unwrap.stderr
@@ -7,5 +7,13 @@ LL |     let val = Some(1).unwrap();
    = help: 
    = note: `-D clippy::unnecessary-literal-unwrap` implied by `-D warnings`
 
-error: aborting due to previous error
+error: used `expect()` on `Some` value
+  --> $DIR/unnecessary_literal_unwrap.rs:5:15
+   |
+LL |     let val = Some(1).expect("this never happens");
+   |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: 
+
+error: aborting due to 2 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From daf61974813ba6f9e7513068bc8cce2839fb8939 Mon Sep 17 00:00:00 2001
From: Pavan Kumar Sunkara <pavan.sss1991@gmail.com>
Date: Thu, 16 Feb 2023 14:21:43 +0000
Subject: Implement the suggestion

---
 clippy_lints/src/methods/mod.rs                    |  8 ++++----
 .../src/methods/unnecessary_literal_unwrap.rs      | 22 ++++++++++++++++------
 tests/ui/unnecessary_literal_unwrap.fixed          | 11 +++++++++++
 tests/ui/unnecessary_literal_unwrap.rs             |  1 +
 tests/ui/unnecessary_literal_unwrap.stderr         | 16 ++++++++++++----
 5 files changed, 44 insertions(+), 14 deletions(-)
 create mode 100644 tests/ui/unnecessary_literal_unwrap.fixed

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index cb82aef1ef0..a5c55a42ea5 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3664,8 +3664,8 @@ impl Methods {
                         Some(("err", recv, [], err_span, _)) => err_expect::check(cx, expr, recv, span, err_span, &self.msrv),
                         _ => expect_used::check(cx, expr, recv, false, self.allow_expect_in_tests),
                     }
-                    if let ExprKind::Call(recv, _) = recv.kind {
-                        unnecessary_literal_unwrap::check(cx, expr, recv, name);
+                    if let ExprKind::Call(recv, [arg]) = recv.kind {
+                        unnecessary_literal_unwrap::check(cx, expr, recv, arg, name);
                     }
                 },
                 ("expect_err", [_]) => expect_used::check(cx, expr, recv, true, self.allow_expect_in_tests),
@@ -3873,8 +3873,8 @@ impl Methods {
                         },
                         _ => {},
                     }
-                    if let ExprKind::Call(recv, _) = recv.kind {
-                        unnecessary_literal_unwrap::check(cx, expr, recv, name);
+                    if let ExprKind::Call(recv, [arg]) = recv.kind {
+                        unnecessary_literal_unwrap::check(cx, expr, recv, arg, name);
                     }
                     unwrap_used::check(cx, expr, recv, false, self.allow_unwrap_in_tests);
                 },
diff --git a/clippy_lints/src/methods/unnecessary_literal_unwrap.rs b/clippy_lints/src/methods/unnecessary_literal_unwrap.rs
index 181e4a06664..9a82d7e58ea 100644
--- a/clippy_lints/src/methods/unnecessary_literal_unwrap.rs
+++ b/clippy_lints/src/methods/unnecessary_literal_unwrap.rs
@@ -1,10 +1,11 @@
-use clippy_utils::{diagnostics::span_lint_and_help, is_res_lang_ctor, path_res};
+use clippy_utils::{diagnostics::span_lint_and_then, is_res_lang_ctor, path_res};
+use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
 
 use super::UNNECESSARY_LITERAL_UNWRAP;
 
-pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr<'_>, name: &str) {
+pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr<'_>, arg: &hir::Expr<'_>, name: &str) {
     let mess = if is_res_lang_ctor(cx, path_res(cx, recv), hir::LangItem::OptionSome) {
         Some((UNNECESSARY_LITERAL_UNWRAP, "Some"))
     } else {
@@ -12,14 +13,23 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr
     };
 
     if let Some((lint, constructor)) = mess {
-        let help = String::new();
-        span_lint_and_help(
+        span_lint_and_then(
             cx,
             lint,
             expr.span,
             &format!("used `{name}()` on `{constructor}` value"),
-            None,
-            &help,
+            |diag| {
+                let suggestions = vec![
+                    (recv.span.with_hi(arg.span.lo()), String::new()),
+                    (expr.span.with_lo(arg.span.hi()), String::new()),
+                ];
+
+                diag.multipart_suggestion(
+                    format!("remove the `{constructor}` and `{name}()`"),
+                    suggestions,
+                    Applicability::MachineApplicable,
+                );
+            },
         );
     }
 }
diff --git a/tests/ui/unnecessary_literal_unwrap.fixed b/tests/ui/unnecessary_literal_unwrap.fixed
new file mode 100644
index 00000000000..8696048d332
--- /dev/null
+++ b/tests/ui/unnecessary_literal_unwrap.fixed
@@ -0,0 +1,11 @@
+//run-rustfix
+#![warn(clippy::unnecessary_literal_unwrap)]
+
+fn unwrap_option() {
+    let val = 1;
+    let val = 1;
+}
+
+fn main() {
+    unwrap_option();
+}
diff --git a/tests/ui/unnecessary_literal_unwrap.rs b/tests/ui/unnecessary_literal_unwrap.rs
index 9ae50517a3e..ae41634495b 100644
--- a/tests/ui/unnecessary_literal_unwrap.rs
+++ b/tests/ui/unnecessary_literal_unwrap.rs
@@ -1,3 +1,4 @@
+//run-rustfix
 #![warn(clippy::unnecessary_literal_unwrap)]
 
 fn unwrap_option() {
diff --git a/tests/ui/unnecessary_literal_unwrap.stderr b/tests/ui/unnecessary_literal_unwrap.stderr
index 414d4445cae..00d7f186fc4 100644
--- a/tests/ui/unnecessary_literal_unwrap.stderr
+++ b/tests/ui/unnecessary_literal_unwrap.stderr
@@ -1,19 +1,27 @@
 error: used `unwrap()` on `Some` value
-  --> $DIR/unnecessary_literal_unwrap.rs:4:15
+  --> $DIR/unnecessary_literal_unwrap.rs:5:15
    |
 LL |     let val = Some(1).unwrap();
    |               ^^^^^^^^^^^^^^^^
    |
-   = help: 
    = note: `-D clippy::unnecessary-literal-unwrap` implied by `-D warnings`
+help: remove the `Some` and `unwrap()`
+   |
+LL -     let val = Some(1).unwrap();
+LL +     let val = 1;
+   |
 
 error: used `expect()` on `Some` value
-  --> $DIR/unnecessary_literal_unwrap.rs:5:15
+  --> $DIR/unnecessary_literal_unwrap.rs:6:15
    |
 LL |     let val = Some(1).expect("this never happens");
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: 
+help: remove the `Some` and `expect()`
+   |
+LL -     let val = Some(1).expect("this never happens");
+LL +     let val = 1;
+   |
 
 error: aborting due to 2 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 1d159e7d11d86d030c030ec0ec23a88871289d1b Mon Sep 17 00:00:00 2001
From: rsdy <p@symmetree.dev>
Date: Thu, 16 Feb 2023 14:37:18 +0000
Subject: Recognize `Ok`

---
 .../src/methods/unnecessary_literal_unwrap.rs      |  8 ++--
 tests/ui/unnecessary_literal_unwrap.fixed          | 11 +++++-
 tests/ui/unnecessary_literal_unwrap.rs             | 11 +++++-
 tests/ui/unnecessary_literal_unwrap.stderr         | 46 ++++++++++++++++------
 4 files changed, 58 insertions(+), 18 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/unnecessary_literal_unwrap.rs b/clippy_lints/src/methods/unnecessary_literal_unwrap.rs
index 9a82d7e58ea..0c8a70fedb9 100644
--- a/clippy_lints/src/methods/unnecessary_literal_unwrap.rs
+++ b/clippy_lints/src/methods/unnecessary_literal_unwrap.rs
@@ -7,15 +7,17 @@ use super::UNNECESSARY_LITERAL_UNWRAP;
 
 pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr<'_>, arg: &hir::Expr<'_>, name: &str) {
     let mess = if is_res_lang_ctor(cx, path_res(cx, recv), hir::LangItem::OptionSome) {
-        Some((UNNECESSARY_LITERAL_UNWRAP, "Some"))
+        Some("Some")
+    } else if is_res_lang_ctor(cx, path_res(cx, recv), hir::LangItem::ResultOk) {
+        Some("Ok")
     } else {
         None
     };
 
-    if let Some((lint, constructor)) = mess {
+    if let Some(constructor) = mess {
         span_lint_and_then(
             cx,
-            lint,
+            UNNECESSARY_LITERAL_UNWRAP,
             expr.span,
             &format!("used `{name}()` on `{constructor}` value"),
             |diag| {
diff --git a/tests/ui/unnecessary_literal_unwrap.fixed b/tests/ui/unnecessary_literal_unwrap.fixed
index 8696048d332..b59dec7d48a 100644
--- a/tests/ui/unnecessary_literal_unwrap.fixed
+++ b/tests/ui/unnecessary_literal_unwrap.fixed
@@ -2,10 +2,17 @@
 #![warn(clippy::unnecessary_literal_unwrap)]
 
 fn unwrap_option() {
-    let val = 1;
-    let val = 1;
+    let _val = 1;
+    let _val = 1;
+}
+
+fn unwrap_result() {
+    let _val = 1;
+    let _val = 1;
+    // let val = Err(1).unwrap_err();
 }
 
 fn main() {
     unwrap_option();
+    unwrap_result();
 }
diff --git a/tests/ui/unnecessary_literal_unwrap.rs b/tests/ui/unnecessary_literal_unwrap.rs
index ae41634495b..c46204f7a99 100644
--- a/tests/ui/unnecessary_literal_unwrap.rs
+++ b/tests/ui/unnecessary_literal_unwrap.rs
@@ -2,10 +2,17 @@
 #![warn(clippy::unnecessary_literal_unwrap)]
 
 fn unwrap_option() {
-    let val = Some(1).unwrap();
-    let val = Some(1).expect("this never happens");
+    let _val = Some(1).unwrap();
+    let _val = Some(1).expect("this never happens");
+}
+
+fn unwrap_result() {
+    let _val = Ok::<usize, ()>(1).unwrap();
+    let _val = Ok::<usize, ()>(1).expect("this never happens");
+    // let val = Err(1).unwrap_err();
 }
 
 fn main() {
     unwrap_option();
+    unwrap_result();
 }
diff --git a/tests/ui/unnecessary_literal_unwrap.stderr b/tests/ui/unnecessary_literal_unwrap.stderr
index 00d7f186fc4..c5e3cd1657b 100644
--- a/tests/ui/unnecessary_literal_unwrap.stderr
+++ b/tests/ui/unnecessary_literal_unwrap.stderr
@@ -1,27 +1,51 @@
 error: used `unwrap()` on `Some` value
-  --> $DIR/unnecessary_literal_unwrap.rs:5:15
+  --> $DIR/unnecessary_literal_unwrap.rs:5:16
    |
-LL |     let val = Some(1).unwrap();
-   |               ^^^^^^^^^^^^^^^^
+LL |     let _val = Some(1).unwrap();
+   |                ^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::unnecessary-literal-unwrap` implied by `-D warnings`
 help: remove the `Some` and `unwrap()`
    |
-LL -     let val = Some(1).unwrap();
-LL +     let val = 1;
+LL -     let _val = Some(1).unwrap();
+LL +     let _val = 1;
    |
 
 error: used `expect()` on `Some` value
-  --> $DIR/unnecessary_literal_unwrap.rs:6:15
+  --> $DIR/unnecessary_literal_unwrap.rs:6:16
    |
-LL |     let val = Some(1).expect("this never happens");
-   |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |     let _val = Some(1).expect("this never happens");
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Some` and `expect()`
    |
-LL -     let val = Some(1).expect("this never happens");
-LL +     let val = 1;
+LL -     let _val = Some(1).expect("this never happens");
+LL +     let _val = 1;
    |
 
-error: aborting due to 2 previous errors
+error: used `unwrap()` on `Ok` value
+  --> $DIR/unnecessary_literal_unwrap.rs:10:16
+   |
+LL |     let _val = Ok::<usize, ()>(1).unwrap();
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the `Ok` and `unwrap()`
+   |
+LL -     let _val = Ok::<usize, ()>(1).unwrap();
+LL +     let _val = 1;
+   |
+
+error: used `expect()` on `Ok` value
+  --> $DIR/unnecessary_literal_unwrap.rs:11:16
+   |
+LL |     let _val = Ok::<usize, ()>(1).expect("this never happens");
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the `Ok` and `expect()`
+   |
+LL -     let _val = Ok::<usize, ()>(1).expect("this never happens");
+LL +     let _val = 1;
+   |
+
+error: aborting due to 4 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 8f83502989f8723377082c52c3aa5c086d5fd3f2 Mon Sep 17 00:00:00 2001
From: Pavan Kumar Sunkara <pavan.sss1991@gmail.com>
Date: Thu, 16 Feb 2023 14:43:41 +0000
Subject: Recognize `unwrap_or` methods

---
 clippy_lints/src/methods/mod.rs                    | 36 ++++++++-------
 .../src/methods/unnecessary_literal_unwrap.rs      | 54 +++++++++++-----------
 tests/ui/unnecessary_literal_unwrap.fixed          | 12 +++++
 tests/ui/unnecessary_literal_unwrap.rs             | 12 +++++
 tests/ui/unnecessary_literal_unwrap.stderr         | 50 +++++++++++++++++++-
 5 files changed, 120 insertions(+), 44 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index a5c55a42ea5..5e42123a8da 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3664,9 +3664,7 @@ impl Methods {
                         Some(("err", recv, [], err_span, _)) => err_expect::check(cx, expr, recv, span, err_span, &self.msrv),
                         _ => expect_used::check(cx, expr, recv, false, self.allow_expect_in_tests),
                     }
-                    if let ExprKind::Call(recv, [arg]) = recv.kind {
-                        unnecessary_literal_unwrap::check(cx, expr, recv, arg, name);
-                    }
+                    unnecessary_literal_unwrap::check(cx, expr, recv, name);
                 },
                 ("expect_err", [_]) => expect_used::check(cx, expr, recv, true, self.allow_expect_in_tests),
                 ("extend", [arg]) => {
@@ -3873,24 +3871,28 @@ impl Methods {
                         },
                         _ => {},
                     }
-                    if let ExprKind::Call(recv, [arg]) = recv.kind {
-                        unnecessary_literal_unwrap::check(cx, expr, recv, arg, name);
-                    }
+                    unnecessary_literal_unwrap::check(cx, expr, recv, name);
                     unwrap_used::check(cx, expr, recv, false, self.allow_unwrap_in_tests);
                 },
                 ("unwrap_err", []) => unwrap_used::check(cx, expr, recv, true, self.allow_unwrap_in_tests),
-                ("unwrap_or", [u_arg]) => match method_call(recv) {
-                    Some((arith @ ("checked_add" | "checked_sub" | "checked_mul"), lhs, [rhs], _, _)) => {
-                        manual_saturating_arithmetic::check(cx, expr, lhs, rhs, u_arg, &arith["checked_".len()..]);
-                    },
-                    Some(("map", m_recv, [m_arg], span, _)) => {
-                        option_map_unwrap_or::check(cx, expr, m_recv, m_arg, recv, u_arg, span);
-                    },
-                    Some(("then_some", t_recv, [t_arg], _, _)) => {
-                        obfuscated_if_else::check(cx, expr, t_recv, t_arg, u_arg);
-                    },
-                    _ => {},
+                ("unwrap_or", [u_arg]) => {
+                    match method_call(recv) {
+                        Some((arith @ ("checked_add" | "checked_sub" | "checked_mul"), lhs, [rhs], _, _)) => {
+                            manual_saturating_arithmetic::check(cx, expr, lhs, rhs, u_arg, &arith["checked_".len()..]);
+                        },
+                        Some(("map", m_recv, [m_arg], span, _)) => {
+                            option_map_unwrap_or::check(cx, expr, m_recv, m_arg, recv, u_arg, span);
+                        },
+                        Some(("then_some", t_recv, [t_arg], _, _)) => {
+                            obfuscated_if_else::check(cx, expr, t_recv, t_arg, u_arg);
+                        },
+                        _ => {},
+                    }
+                    unnecessary_literal_unwrap::check(cx, expr, recv, name);
                 },
+                ("unwrap_or_default", []) => {
+                    unnecessary_literal_unwrap::check(cx, expr, recv, name);
+                }
                 ("unwrap_or_else", [u_arg]) => match method_call(recv) {
                     Some(("map", recv, [map_arg], _, _))
                         if map_unwrap_or::check(cx, expr, recv, map_arg, u_arg, &self.msrv) => {},
diff --git a/clippy_lints/src/methods/unnecessary_literal_unwrap.rs b/clippy_lints/src/methods/unnecessary_literal_unwrap.rs
index 0c8a70fedb9..9a9c659b232 100644
--- a/clippy_lints/src/methods/unnecessary_literal_unwrap.rs
+++ b/clippy_lints/src/methods/unnecessary_literal_unwrap.rs
@@ -5,33 +5,35 @@ use rustc_lint::LateContext;
 
 use super::UNNECESSARY_LITERAL_UNWRAP;
 
-pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr<'_>, arg: &hir::Expr<'_>, name: &str) {
-    let mess = if is_res_lang_ctor(cx, path_res(cx, recv), hir::LangItem::OptionSome) {
-        Some("Some")
-    } else if is_res_lang_ctor(cx, path_res(cx, recv), hir::LangItem::ResultOk) {
-        Some("Ok")
-    } else {
-        None
-    };
+pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr<'_>, name: &str) {
+    if let hir::ExprKind::Call(call, [arg]) = recv.kind {
+        let mess = if is_res_lang_ctor(cx, path_res(cx, call), hir::LangItem::OptionSome) {
+            Some("Some")
+        } else if is_res_lang_ctor(cx, path_res(cx, call), hir::LangItem::ResultOk) {
+            Some("Ok")
+        } else {
+            None
+        };
 
-    if let Some(constructor) = mess {
-        span_lint_and_then(
-            cx,
-            UNNECESSARY_LITERAL_UNWRAP,
-            expr.span,
-            &format!("used `{name}()` on `{constructor}` value"),
-            |diag| {
-                let suggestions = vec![
-                    (recv.span.with_hi(arg.span.lo()), String::new()),
-                    (expr.span.with_lo(arg.span.hi()), String::new()),
-                ];
+        if let Some(constructor) = mess {
+            span_lint_and_then(
+                cx,
+                UNNECESSARY_LITERAL_UNWRAP,
+                expr.span,
+                &format!("used `{name}()` on `{constructor}` value"),
+                |diag| {
+                    let suggestions = vec![
+                        (call.span.with_hi(arg.span.lo()), String::new()),
+                        (expr.span.with_lo(arg.span.hi()), String::new()),
+                    ];
 
-                diag.multipart_suggestion(
-                    format!("remove the `{constructor}` and `{name}()`"),
-                    suggestions,
-                    Applicability::MachineApplicable,
-                );
-            },
-        );
+                    diag.multipart_suggestion(
+                        format!("remove the `{constructor}` and `{name}()`"),
+                        suggestions,
+                        Applicability::MachineApplicable,
+                    );
+                },
+            );
+        }
     }
 }
diff --git a/tests/ui/unnecessary_literal_unwrap.fixed b/tests/ui/unnecessary_literal_unwrap.fixed
index b59dec7d48a..55a210bdb98 100644
--- a/tests/ui/unnecessary_literal_unwrap.fixed
+++ b/tests/ui/unnecessary_literal_unwrap.fixed
@@ -12,7 +12,19 @@ fn unwrap_result() {
     // let val = Err(1).unwrap_err();
 }
 
+fn unwrap_methods_option() {
+    let _val = 1;
+    let _val = 1;
+}
+
+fn unwrap_methods_result() {
+    let _val = 1;
+    let _val = 1;
+}
+
 fn main() {
     unwrap_option();
     unwrap_result();
+    unwrap_methods_option();
+    unwrap_methods_result();
 }
diff --git a/tests/ui/unnecessary_literal_unwrap.rs b/tests/ui/unnecessary_literal_unwrap.rs
index c46204f7a99..80f72ce3cf2 100644
--- a/tests/ui/unnecessary_literal_unwrap.rs
+++ b/tests/ui/unnecessary_literal_unwrap.rs
@@ -12,7 +12,19 @@ fn unwrap_result() {
     // let val = Err(1).unwrap_err();
 }
 
+fn unwrap_methods_option() {
+    let _val = Some(1).unwrap_or(2);
+    let _val = Some(1).unwrap_or_default();
+}
+
+fn unwrap_methods_result() {
+    let _val = Ok::<usize, ()>(1).unwrap_or(2);
+    let _val = Ok::<usize, ()>(1).unwrap_or_default();
+}
+
 fn main() {
     unwrap_option();
     unwrap_result();
+    unwrap_methods_option();
+    unwrap_methods_result();
 }
diff --git a/tests/ui/unnecessary_literal_unwrap.stderr b/tests/ui/unnecessary_literal_unwrap.stderr
index c5e3cd1657b..b8b5a612da1 100644
--- a/tests/ui/unnecessary_literal_unwrap.stderr
+++ b/tests/ui/unnecessary_literal_unwrap.stderr
@@ -47,5 +47,53 @@ LL -     let _val = Ok::<usize, ()>(1).expect("this never happens");
 LL +     let _val = 1;
    |
 
-error: aborting due to 4 previous errors
+error: used `unwrap_or()` on `Some` value
+  --> $DIR/unnecessary_literal_unwrap.rs:16:16
+   |
+LL |     let _val = Some(1).unwrap_or(2);
+   |                ^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the `Some` and `unwrap_or()`
+   |
+LL -     let _val = Some(1).unwrap_or(2);
+LL +     let _val = 1;
+   |
+
+error: used `unwrap_or_default()` on `Some` value
+  --> $DIR/unnecessary_literal_unwrap.rs:17:16
+   |
+LL |     let _val = Some(1).unwrap_or_default();
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the `Some` and `unwrap_or_default()`
+   |
+LL -     let _val = Some(1).unwrap_or_default();
+LL +     let _val = 1;
+   |
+
+error: used `unwrap_or()` on `Ok` value
+  --> $DIR/unnecessary_literal_unwrap.rs:21:16
+   |
+LL |     let _val = Ok::<usize, ()>(1).unwrap_or(2);
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the `Ok` and `unwrap_or()`
+   |
+LL -     let _val = Ok::<usize, ()>(1).unwrap_or(2);
+LL +     let _val = 1;
+   |
+
+error: used `unwrap_or_default()` on `Ok` value
+  --> $DIR/unnecessary_literal_unwrap.rs:22:16
+   |
+LL |     let _val = Ok::<usize, ()>(1).unwrap_or_default();
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the `Ok` and `unwrap_or_default()`
+   |
+LL -     let _val = Ok::<usize, ()>(1).unwrap_or_default();
+LL +     let _val = 1;
+   |
+
+error: aborting due to 8 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 7ed7283e0f9de697f8d5c8c2118c4b0b8bc7d6b0 Mon Sep 17 00:00:00 2001
From: Pavan Kumar Sunkara <pavan.sss1991@gmail.com>
Date: Thu, 16 Feb 2023 15:05:56 +0000
Subject: Recognize `unwrap_or_else` method

---
 CHANGELOG.md                               |  1 +
 clippy_lints/src/methods/mod.rs            | 17 +++++++-----
 tests/ui/unnecessary_literal_unwrap.fixed  |  3 +++
 tests/ui/unnecessary_literal_unwrap.rs     |  3 +++
 tests/ui/unnecessary_literal_unwrap.stderr | 42 +++++++++++++++++++++++-------
 5 files changed, 50 insertions(+), 16 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 85fddc97047..abc35e8546f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5248,6 +5248,7 @@ Released 2018-09-13
 [`unnecessary_fold`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_fold
 [`unnecessary_join`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_join
 [`unnecessary_lazy_evaluations`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_lazy_evaluations
+[`unnecessary_literal_unwrap`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_literal_unwrap
 [`unnecessary_mut_passed`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_mut_passed
 [`unnecessary_operation`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_operation
 [`unnecessary_owned_empty_strings`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_owned_empty_strings
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 5e42123a8da..4686adda683 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3893,13 +3893,16 @@ impl Methods {
                 ("unwrap_or_default", []) => {
                     unnecessary_literal_unwrap::check(cx, expr, recv, name);
                 }
-                ("unwrap_or_else", [u_arg]) => match method_call(recv) {
-                    Some(("map", recv, [map_arg], _, _))
-                        if map_unwrap_or::check(cx, expr, recv, map_arg, u_arg, &self.msrv) => {},
-                    _ => {
-                        unwrap_or_else_default::check(cx, expr, recv, u_arg);
-                        unnecessary_lazy_eval::check(cx, expr, recv, u_arg, "unwrap_or");
-                    },
+                ("unwrap_or_else", [u_arg]) => {
+                    match method_call(recv) {
+                        Some(("map", recv, [map_arg], _, _))
+                            if map_unwrap_or::check(cx, expr, recv, map_arg, u_arg, &self.msrv) => {},
+                        _ => {
+                            unwrap_or_else_default::check(cx, expr, recv, u_arg);
+                            unnecessary_lazy_eval::check(cx, expr, recv, u_arg, "unwrap_or");
+                        },
+                    }
+                    unnecessary_literal_unwrap::check(cx, expr, recv, name);
                 },
                 ("zip", [arg]) => {
                     if let ExprKind::MethodCall(name, iter_recv, [], _) = recv.kind
diff --git a/tests/ui/unnecessary_literal_unwrap.fixed b/tests/ui/unnecessary_literal_unwrap.fixed
index 55a210bdb98..a388a7f83d2 100644
--- a/tests/ui/unnecessary_literal_unwrap.fixed
+++ b/tests/ui/unnecessary_literal_unwrap.fixed
@@ -1,5 +1,6 @@
 //run-rustfix
 #![warn(clippy::unnecessary_literal_unwrap)]
+#![allow(clippy::unnecessary_lazy_evaluations)]
 
 fn unwrap_option() {
     let _val = 1;
@@ -15,11 +16,13 @@ fn unwrap_result() {
 fn unwrap_methods_option() {
     let _val = 1;
     let _val = 1;
+    let _val = 1;
 }
 
 fn unwrap_methods_result() {
     let _val = 1;
     let _val = 1;
+    let _val = 1;
 }
 
 fn main() {
diff --git a/tests/ui/unnecessary_literal_unwrap.rs b/tests/ui/unnecessary_literal_unwrap.rs
index 80f72ce3cf2..fe557957dd9 100644
--- a/tests/ui/unnecessary_literal_unwrap.rs
+++ b/tests/ui/unnecessary_literal_unwrap.rs
@@ -1,5 +1,6 @@
 //run-rustfix
 #![warn(clippy::unnecessary_literal_unwrap)]
+#![allow(clippy::unnecessary_lazy_evaluations)]
 
 fn unwrap_option() {
     let _val = Some(1).unwrap();
@@ -15,11 +16,13 @@ fn unwrap_result() {
 fn unwrap_methods_option() {
     let _val = Some(1).unwrap_or(2);
     let _val = Some(1).unwrap_or_default();
+    let _val = Some(1).unwrap_or_else(|| _val);
 }
 
 fn unwrap_methods_result() {
     let _val = Ok::<usize, ()>(1).unwrap_or(2);
     let _val = Ok::<usize, ()>(1).unwrap_or_default();
+    let _val = Ok::<usize, ()>(1).unwrap_or_else(|()| _val);
 }
 
 fn main() {
diff --git a/tests/ui/unnecessary_literal_unwrap.stderr b/tests/ui/unnecessary_literal_unwrap.stderr
index b8b5a612da1..60499fe700b 100644
--- a/tests/ui/unnecessary_literal_unwrap.stderr
+++ b/tests/ui/unnecessary_literal_unwrap.stderr
@@ -1,5 +1,5 @@
 error: used `unwrap()` on `Some` value
-  --> $DIR/unnecessary_literal_unwrap.rs:5:16
+  --> $DIR/unnecessary_literal_unwrap.rs:6:16
    |
 LL |     let _val = Some(1).unwrap();
    |                ^^^^^^^^^^^^^^^^
@@ -12,7 +12,7 @@ LL +     let _val = 1;
    |
 
 error: used `expect()` on `Some` value
-  --> $DIR/unnecessary_literal_unwrap.rs:6:16
+  --> $DIR/unnecessary_literal_unwrap.rs:7:16
    |
 LL |     let _val = Some(1).expect("this never happens");
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -24,7 +24,7 @@ LL +     let _val = 1;
    |
 
 error: used `unwrap()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap.rs:10:16
+  --> $DIR/unnecessary_literal_unwrap.rs:11:16
    |
 LL |     let _val = Ok::<usize, ()>(1).unwrap();
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -36,7 +36,7 @@ LL +     let _val = 1;
    |
 
 error: used `expect()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap.rs:11:16
+  --> $DIR/unnecessary_literal_unwrap.rs:12:16
    |
 LL |     let _val = Ok::<usize, ()>(1).expect("this never happens");
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -48,7 +48,7 @@ LL +     let _val = 1;
    |
 
 error: used `unwrap_or()` on `Some` value
-  --> $DIR/unnecessary_literal_unwrap.rs:16:16
+  --> $DIR/unnecessary_literal_unwrap.rs:17:16
    |
 LL |     let _val = Some(1).unwrap_or(2);
    |                ^^^^^^^^^^^^^^^^^^^^
@@ -60,7 +60,7 @@ LL +     let _val = 1;
    |
 
 error: used `unwrap_or_default()` on `Some` value
-  --> $DIR/unnecessary_literal_unwrap.rs:17:16
+  --> $DIR/unnecessary_literal_unwrap.rs:18:16
    |
 LL |     let _val = Some(1).unwrap_or_default();
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -71,8 +71,20 @@ LL -     let _val = Some(1).unwrap_or_default();
 LL +     let _val = 1;
    |
 
+error: used `unwrap_or_else()` on `Some` value
+  --> $DIR/unnecessary_literal_unwrap.rs:19:16
+   |
+LL |     let _val = Some(1).unwrap_or_else(|| _val);
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the `Some` and `unwrap_or_else()`
+   |
+LL -     let _val = Some(1).unwrap_or_else(|| _val);
+LL +     let _val = 1;
+   |
+
 error: used `unwrap_or()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap.rs:21:16
+  --> $DIR/unnecessary_literal_unwrap.rs:23:16
    |
 LL |     let _val = Ok::<usize, ()>(1).unwrap_or(2);
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -84,7 +96,7 @@ LL +     let _val = 1;
    |
 
 error: used `unwrap_or_default()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap.rs:22:16
+  --> $DIR/unnecessary_literal_unwrap.rs:24:16
    |
 LL |     let _val = Ok::<usize, ()>(1).unwrap_or_default();
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -95,5 +107,17 @@ LL -     let _val = Ok::<usize, ()>(1).unwrap_or_default();
 LL +     let _val = 1;
    |
 
-error: aborting due to 8 previous errors
+error: used `unwrap_or_else()` on `Ok` value
+  --> $DIR/unnecessary_literal_unwrap.rs:25:16
+   |
+LL |     let _val = Ok::<usize, ()>(1).unwrap_or_else(|()| _val);
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the `Ok` and `unwrap_or_else()`
+   |
+LL -     let _val = Ok::<usize, ()>(1).unwrap_or_else(|()| _val);
+LL +     let _val = 1;
+   |
+
+error: aborting due to 10 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 6e0e09c8f7622caa6ea6536f2bbc5c033a9cffa2 Mon Sep 17 00:00:00 2001
From: rsdy <p@symmetree.dev>
Date: Thu, 16 Feb 2023 15:30:09 +0000
Subject: Track init and unwrap of expr

---
 .../src/methods/unnecessary_literal_unwrap.rs      | 22 +++++++++++++++++++---
 tests/ui/unnecessary_literal_unwrap_unfixable.rs   |  6 ++++++
 .../ui/unnecessary_literal_unwrap_unfixable.stderr | 15 +++++++++++++++
 3 files changed, 40 insertions(+), 3 deletions(-)
 create mode 100644 tests/ui/unnecessary_literal_unwrap_unfixable.rs
 create mode 100644 tests/ui/unnecessary_literal_unwrap_unfixable.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/unnecessary_literal_unwrap.rs b/clippy_lints/src/methods/unnecessary_literal_unwrap.rs
index 9a9c659b232..54160a27cb2 100644
--- a/clippy_lints/src/methods/unnecessary_literal_unwrap.rs
+++ b/clippy_lints/src/methods/unnecessary_literal_unwrap.rs
@@ -6,7 +6,9 @@ use rustc_lint::LateContext;
 use super::UNNECESSARY_LITERAL_UNWRAP;
 
 pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr<'_>, name: &str) {
-    if let hir::ExprKind::Call(call, [arg]) = recv.kind {
+    let init = clippy_utils::expr_or_init(cx, recv);
+
+    if let hir::ExprKind::Call(call, [arg]) = init.kind {
         let mess = if is_res_lang_ctor(cx, path_res(cx, call), hir::LangItem::OptionSome) {
             Some("Some")
         } else if is_res_lang_ctor(cx, path_res(cx, call), hir::LangItem::ResultOk) {
@@ -15,7 +17,11 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr
             None
         };
 
-        if let Some(constructor) = mess {
+        let Some(constructor) = mess else {
+	    return;
+	};
+
+        if init.span == recv.span {
             span_lint_and_then(
                 cx,
                 UNNECESSARY_LITERAL_UNWRAP,
@@ -23,7 +29,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr
                 &format!("used `{name}()` on `{constructor}` value"),
                 |diag| {
                     let suggestions = vec![
-                        (call.span.with_hi(arg.span.lo()), String::new()),
+                        (recv.span.with_hi(arg.span.lo()), String::new()),
                         (expr.span.with_lo(arg.span.hi()), String::new()),
                     ];
 
@@ -34,6 +40,16 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr
                     );
                 },
             );
+        } else {
+            span_lint_and_then(
+                cx,
+                UNNECESSARY_LITERAL_UNWRAP,
+                expr.span,
+                &format!("used `{name}()` on `{constructor}` value"),
+                |diag| {
+                    diag.span_help(init.span, format!("remove the `{constructor}` and `{name}()`"));
+                },
+            );
         }
     }
 }
diff --git a/tests/ui/unnecessary_literal_unwrap_unfixable.rs b/tests/ui/unnecessary_literal_unwrap_unfixable.rs
new file mode 100644
index 00000000000..ac3a84934af
--- /dev/null
+++ b/tests/ui/unnecessary_literal_unwrap_unfixable.rs
@@ -0,0 +1,6 @@
+#![warn(clippy::unnecessary_literal_unwrap)]
+
+fn main() {
+    let val = Some(1);
+    let _val2 = val.unwrap();
+}
diff --git a/tests/ui/unnecessary_literal_unwrap_unfixable.stderr b/tests/ui/unnecessary_literal_unwrap_unfixable.stderr
new file mode 100644
index 00000000000..abc789ccda4
--- /dev/null
+++ b/tests/ui/unnecessary_literal_unwrap_unfixable.stderr
@@ -0,0 +1,15 @@
+error: used `unwrap()` on `Some` value
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:5:17
+   |
+LL |     let _val2 = val.unwrap();
+   |                 ^^^^^^^^^^^^
+   |
+help: remove the `Some` and `unwrap()`
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:4:15
+   |
+LL |     let val = Some(1);
+   |               ^^^^^^^
+   = note: `-D clippy::unnecessary-literal-unwrap` implied by `-D warnings`
+
+error: aborting due to previous error
+
-- 
cgit 1.4.1-3-g733a5


From 69af0e13b2662807ba51ffc3a9fe4a9576e100e2 Mon Sep 17 00:00:00 2001
From: Pavan Kumar Sunkara <pavan.sss1991@gmail.com>
Date: Thu, 16 Feb 2023 17:15:19 +0000
Subject: Recognize `Err`

---
 clippy_lints/src/methods/mod.rs                    | 10 ++++--
 .../src/methods/unnecessary_literal_unwrap.rs      | 14 ++++----
 tests/ui/unnecessary_literal_unwrap.fixed          | 11 +++++--
 tests/ui/unnecessary_literal_unwrap.rs             | 11 +++++--
 tests/ui/unnecessary_literal_unwrap.stderr         | 38 ++++++++++++++++++----
 5 files changed, 61 insertions(+), 23 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 4686adda683..66789e6137a 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3666,7 +3666,10 @@ impl Methods {
                     }
                     unnecessary_literal_unwrap::check(cx, expr, recv, name);
                 },
-                ("expect_err", [_]) => expect_used::check(cx, expr, recv, true, self.allow_expect_in_tests),
+                ("expect_err", [_]) => {
+                    unnecessary_literal_unwrap::check(cx, expr, recv, name);
+                    expect_used::check(cx, expr, recv, true, self.allow_expect_in_tests);
+                },
                 ("extend", [arg]) => {
                     string_extend_chars::check(cx, expr, recv, arg);
                     extend_with_drain::check(cx, expr, recv, arg);
@@ -3874,7 +3877,10 @@ impl Methods {
                     unnecessary_literal_unwrap::check(cx, expr, recv, name);
                     unwrap_used::check(cx, expr, recv, false, self.allow_unwrap_in_tests);
                 },
-                ("unwrap_err", []) => unwrap_used::check(cx, expr, recv, true, self.allow_unwrap_in_tests),
+                ("unwrap_err", []) => {
+                    unnecessary_literal_unwrap::check(cx, expr, recv, name);
+                    unwrap_used::check(cx, expr, recv, true, self.allow_unwrap_in_tests)
+                },
                 ("unwrap_or", [u_arg]) => {
                     match method_call(recv) {
                         Some((arith @ ("checked_add" | "checked_sub" | "checked_mul"), lhs, [rhs], _, _)) => {
diff --git a/clippy_lints/src/methods/unnecessary_literal_unwrap.rs b/clippy_lints/src/methods/unnecessary_literal_unwrap.rs
index 54160a27cb2..56d3c16a5d2 100644
--- a/clippy_lints/src/methods/unnecessary_literal_unwrap.rs
+++ b/clippy_lints/src/methods/unnecessary_literal_unwrap.rs
@@ -9,18 +9,16 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr
     let init = clippy_utils::expr_or_init(cx, recv);
 
     if let hir::ExprKind::Call(call, [arg]) = init.kind {
-        let mess = if is_res_lang_ctor(cx, path_res(cx, call), hir::LangItem::OptionSome) {
-            Some("Some")
+        let constructor = if is_res_lang_ctor(cx, path_res(cx, call), hir::LangItem::OptionSome) {
+            "Some"
         } else if is_res_lang_ctor(cx, path_res(cx, call), hir::LangItem::ResultOk) {
-            Some("Ok")
+            "Ok"
+        } else if is_res_lang_ctor(cx, path_res(cx, call), hir::LangItem::ResultErr) {
+            "Err"
         } else {
-            None
+            return;
         };
 
-        let Some(constructor) = mess else {
-	    return;
-	};
-
         if init.span == recv.span {
             span_lint_and_then(
                 cx,
diff --git a/tests/ui/unnecessary_literal_unwrap.fixed b/tests/ui/unnecessary_literal_unwrap.fixed
index a388a7f83d2..9733993d619 100644
--- a/tests/ui/unnecessary_literal_unwrap.fixed
+++ b/tests/ui/unnecessary_literal_unwrap.fixed
@@ -7,10 +7,14 @@ fn unwrap_option() {
     let _val = 1;
 }
 
-fn unwrap_result() {
+fn unwrap_result_ok() {
+    let _val = 1;
+    let _val = 1;
+}
+
+fn unwrap_result_err() {
     let _val = 1;
     let _val = 1;
-    // let val = Err(1).unwrap_err();
 }
 
 fn unwrap_methods_option() {
@@ -27,7 +31,8 @@ fn unwrap_methods_result() {
 
 fn main() {
     unwrap_option();
-    unwrap_result();
+    unwrap_result_ok();
+    unwrap_result_err();
     unwrap_methods_option();
     unwrap_methods_result();
 }
diff --git a/tests/ui/unnecessary_literal_unwrap.rs b/tests/ui/unnecessary_literal_unwrap.rs
index fe557957dd9..775d744c13e 100644
--- a/tests/ui/unnecessary_literal_unwrap.rs
+++ b/tests/ui/unnecessary_literal_unwrap.rs
@@ -7,10 +7,14 @@ fn unwrap_option() {
     let _val = Some(1).expect("this never happens");
 }
 
-fn unwrap_result() {
+fn unwrap_result_ok() {
     let _val = Ok::<usize, ()>(1).unwrap();
     let _val = Ok::<usize, ()>(1).expect("this never happens");
-    // let val = Err(1).unwrap_err();
+}
+
+fn unwrap_result_err() {
+    let _val = Err::<(), usize>(1).unwrap_err();
+    let _val = Err::<(), usize>(1).expect_err("this never happens");
 }
 
 fn unwrap_methods_option() {
@@ -27,7 +31,8 @@ fn unwrap_methods_result() {
 
 fn main() {
     unwrap_option();
-    unwrap_result();
+    unwrap_result_ok();
+    unwrap_result_err();
     unwrap_methods_option();
     unwrap_methods_result();
 }
diff --git a/tests/ui/unnecessary_literal_unwrap.stderr b/tests/ui/unnecessary_literal_unwrap.stderr
index 60499fe700b..622743f8c85 100644
--- a/tests/ui/unnecessary_literal_unwrap.stderr
+++ b/tests/ui/unnecessary_literal_unwrap.stderr
@@ -47,9 +47,33 @@ LL -     let _val = Ok::<usize, ()>(1).expect("this never happens");
 LL +     let _val = 1;
    |
 
-error: used `unwrap_or()` on `Some` value
+error: used `unwrap_err()` on `Err` value
+  --> $DIR/unnecessary_literal_unwrap.rs:16:16
+   |
+LL |     let _val = Err::<(), usize>(1).unwrap_err();
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the `Err` and `unwrap_err()`
+   |
+LL -     let _val = Err::<(), usize>(1).unwrap_err();
+LL +     let _val = 1;
+   |
+
+error: used `expect_err()` on `Err` value
   --> $DIR/unnecessary_literal_unwrap.rs:17:16
    |
+LL |     let _val = Err::<(), usize>(1).expect_err("this never happens");
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the `Err` and `expect_err()`
+   |
+LL -     let _val = Err::<(), usize>(1).expect_err("this never happens");
+LL +     let _val = 1;
+   |
+
+error: used `unwrap_or()` on `Some` value
+  --> $DIR/unnecessary_literal_unwrap.rs:21:16
+   |
 LL |     let _val = Some(1).unwrap_or(2);
    |                ^^^^^^^^^^^^^^^^^^^^
    |
@@ -60,7 +84,7 @@ LL +     let _val = 1;
    |
 
 error: used `unwrap_or_default()` on `Some` value
-  --> $DIR/unnecessary_literal_unwrap.rs:18:16
+  --> $DIR/unnecessary_literal_unwrap.rs:22:16
    |
 LL |     let _val = Some(1).unwrap_or_default();
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -72,7 +96,7 @@ LL +     let _val = 1;
    |
 
 error: used `unwrap_or_else()` on `Some` value
-  --> $DIR/unnecessary_literal_unwrap.rs:19:16
+  --> $DIR/unnecessary_literal_unwrap.rs:23:16
    |
 LL |     let _val = Some(1).unwrap_or_else(|| _val);
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -84,7 +108,7 @@ LL +     let _val = 1;
    |
 
 error: used `unwrap_or()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap.rs:23:16
+  --> $DIR/unnecessary_literal_unwrap.rs:27:16
    |
 LL |     let _val = Ok::<usize, ()>(1).unwrap_or(2);
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -96,7 +120,7 @@ LL +     let _val = 1;
    |
 
 error: used `unwrap_or_default()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap.rs:24:16
+  --> $DIR/unnecessary_literal_unwrap.rs:28:16
    |
 LL |     let _val = Ok::<usize, ()>(1).unwrap_or_default();
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -108,7 +132,7 @@ LL +     let _val = 1;
    |
 
 error: used `unwrap_or_else()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap.rs:25:16
+  --> $DIR/unnecessary_literal_unwrap.rs:29:16
    |
 LL |     let _val = Ok::<usize, ()>(1).unwrap_or_else(|()| _val);
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -119,5 +143,5 @@ LL -     let _val = Ok::<usize, ()>(1).unwrap_or_else(|()| _val);
 LL +     let _val = 1;
    |
 
-error: aborting due to 10 previous errors
+error: aborting due to 12 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 6e4dc93e24866018f2567a7a0baa1955a4c7d868 Mon Sep 17 00:00:00 2001
From: Pavan Kumar Sunkara <pavan.sss1991@gmail.com>
Date: Thu, 16 Feb 2023 22:31:52 +0000
Subject: Support suggesting panics

---
 clippy_lints/src/methods/mod.rs                    | 16 ++--
 .../src/methods/unnecessary_literal_unwrap.rs      | 91 +++++++++++++---------
 tests/ui/unnecessary_literal_unwrap.fixed          | 15 +++-
 tests/ui/unnecessary_literal_unwrap.rs             | 15 +++-
 tests/ui/unnecessary_literal_unwrap.stderr         | 87 +++++++++++++++++----
 5 files changed, 163 insertions(+), 61 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 66789e6137a..912cce39e2e 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3664,10 +3664,10 @@ impl Methods {
                         Some(("err", recv, [], err_span, _)) => err_expect::check(cx, expr, recv, span, err_span, &self.msrv),
                         _ => expect_used::check(cx, expr, recv, false, self.allow_expect_in_tests),
                     }
-                    unnecessary_literal_unwrap::check(cx, expr, recv, name);
+                    unnecessary_literal_unwrap::check(cx, expr, recv, name, args);
                 },
                 ("expect_err", [_]) => {
-                    unnecessary_literal_unwrap::check(cx, expr, recv, name);
+                    unnecessary_literal_unwrap::check(cx, expr, recv, name, args);
                     expect_used::check(cx, expr, recv, true, self.allow_expect_in_tests);
                 },
                 ("extend", [arg]) => {
@@ -3874,12 +3874,12 @@ impl Methods {
                         },
                         _ => {},
                     }
-                    unnecessary_literal_unwrap::check(cx, expr, recv, name);
+                    unnecessary_literal_unwrap::check(cx, expr, recv, name, args);
                     unwrap_used::check(cx, expr, recv, false, self.allow_unwrap_in_tests);
                 },
                 ("unwrap_err", []) => {
-                    unnecessary_literal_unwrap::check(cx, expr, recv, name);
-                    unwrap_used::check(cx, expr, recv, true, self.allow_unwrap_in_tests)
+                    unnecessary_literal_unwrap::check(cx, expr, recv, name, args);
+                    unwrap_used::check(cx, expr, recv, true, self.allow_unwrap_in_tests);
                 },
                 ("unwrap_or", [u_arg]) => {
                     match method_call(recv) {
@@ -3894,10 +3894,10 @@ impl Methods {
                         },
                         _ => {},
                     }
-                    unnecessary_literal_unwrap::check(cx, expr, recv, name);
+                    unnecessary_literal_unwrap::check(cx, expr, recv, name, args);
                 },
                 ("unwrap_or_default", []) => {
-                    unnecessary_literal_unwrap::check(cx, expr, recv, name);
+                    unnecessary_literal_unwrap::check(cx, expr, recv, name, args);
                 }
                 ("unwrap_or_else", [u_arg]) => {
                     match method_call(recv) {
@@ -3908,7 +3908,7 @@ impl Methods {
                             unnecessary_lazy_eval::check(cx, expr, recv, u_arg, "unwrap_or");
                         },
                     }
-                    unnecessary_literal_unwrap::check(cx, expr, recv, name);
+                    unnecessary_literal_unwrap::check(cx, expr, recv, name, args);
                 },
                 ("zip", [arg]) => {
                     if let ExprKind::MethodCall(name, iter_recv, [], _) = recv.kind
diff --git a/clippy_lints/src/methods/unnecessary_literal_unwrap.rs b/clippy_lints/src/methods/unnecessary_literal_unwrap.rs
index 56d3c16a5d2..fe6b86b34f5 100644
--- a/clippy_lints/src/methods/unnecessary_literal_unwrap.rs
+++ b/clippy_lints/src/methods/unnecessary_literal_unwrap.rs
@@ -5,49 +5,68 @@ use rustc_lint::LateContext;
 
 use super::UNNECESSARY_LITERAL_UNWRAP;
 
-pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr<'_>, name: &str) {
+pub(super) fn check(
+    cx: &LateContext<'_>,
+    expr: &hir::Expr<'_>,
+    recv: &hir::Expr<'_>,
+    method: &str,
+    args: &[hir::Expr<'_>],
+) {
     let init = clippy_utils::expr_or_init(cx, recv);
 
-    if let hir::ExprKind::Call(call, [arg]) = init.kind {
-        let constructor = if is_res_lang_ctor(cx, path_res(cx, call), hir::LangItem::OptionSome) {
-            "Some"
+    let (constructor, call_args) = if let hir::ExprKind::Call(call, call_args) = init.kind {
+        if is_res_lang_ctor(cx, path_res(cx, call), hir::LangItem::OptionSome) {
+            ("Some", call_args)
         } else if is_res_lang_ctor(cx, path_res(cx, call), hir::LangItem::ResultOk) {
-            "Ok"
+            ("Ok", call_args)
         } else if is_res_lang_ctor(cx, path_res(cx, call), hir::LangItem::ResultErr) {
-            "Err"
+            ("Err", call_args)
         } else {
             return;
-        };
+        }
+    } else if is_res_lang_ctor(cx, path_res(cx, init), hir::LangItem::OptionNone) {
+        let call_args: &[hir::Expr<'_>] = &[];
+        ("None", call_args)
+    } else {
+        return;
+    };
 
-        if init.span == recv.span {
-            span_lint_and_then(
-                cx,
-                UNNECESSARY_LITERAL_UNWRAP,
-                expr.span,
-                &format!("used `{name}()` on `{constructor}` value"),
-                |diag| {
-                    let suggestions = vec![
-                        (recv.span.with_hi(arg.span.lo()), String::new()),
-                        (expr.span.with_lo(arg.span.hi()), String::new()),
-                    ];
+    let help_message = format!("used `{method}()` on `{constructor}` value");
+    let suggestion_message = format!("remove the `{constructor}` and `{method}()`");
 
-                    diag.multipart_suggestion(
-                        format!("remove the `{constructor}` and `{name}()`"),
-                        suggestions,
-                        Applicability::MachineApplicable,
-                    );
-                },
-            );
-        } else {
-            span_lint_and_then(
-                cx,
-                UNNECESSARY_LITERAL_UNWRAP,
-                expr.span,
-                &format!("used `{name}()` on `{constructor}` value"),
-                |diag| {
-                    diag.span_help(init.span, format!("remove the `{constructor}` and `{name}()`"));
-                },
-            );
-        }
+    if init.span == recv.span {
+        span_lint_and_then(cx, UNNECESSARY_LITERAL_UNWRAP, expr.span, &help_message, |diag| {
+            let suggestions = match (constructor, method) {
+                ("None", "unwrap") => vec![(expr.span, "panic!()".to_string())],
+                ("None", "expect") => vec![
+                    (expr.span.with_hi(args[0].span.lo()), "panic!(".to_string()),
+                    (expr.span.with_lo(args[0].span.hi()), ")".to_string()),
+                ],
+                ("Ok", "unwrap_err") | ("Err", "unwrap") => vec![
+                    (
+                        recv.span.with_hi(call_args[0].span.lo()),
+                        "panic!(\"{:?}\", ".to_string(),
+                    ),
+                    (expr.span.with_lo(call_args[0].span.hi()), ")".to_string()),
+                ],
+                ("Ok", "expect_err") | ("Err", "expect") => vec![
+                    (
+                        recv.span.with_hi(call_args[0].span.lo()),
+                        "panic!(\"{1}: {:?}\", ".to_string(),
+                    ),
+                    (call_args[0].span.with_lo(args[0].span.lo()), ", ".to_string()),
+                ],
+                _ => vec![
+                    (recv.span.with_hi(call_args[0].span.lo()), String::new()),
+                    (expr.span.with_lo(call_args[0].span.hi()), String::new()),
+                ],
+            };
+
+            diag.multipart_suggestion(suggestion_message, suggestions, Applicability::MachineApplicable);
+        });
+    } else {
+        span_lint_and_then(cx, UNNECESSARY_LITERAL_UNWRAP, expr.span, &help_message, |diag| {
+            diag.span_help(init.span, suggestion_message);
+        });
     }
 }
diff --git a/tests/ui/unnecessary_literal_unwrap.fixed b/tests/ui/unnecessary_literal_unwrap.fixed
index 9733993d619..d622c984c52 100644
--- a/tests/ui/unnecessary_literal_unwrap.fixed
+++ b/tests/ui/unnecessary_literal_unwrap.fixed
@@ -1,20 +1,30 @@
 //run-rustfix
 #![warn(clippy::unnecessary_literal_unwrap)]
 #![allow(clippy::unnecessary_lazy_evaluations)]
+#![allow(unreachable_code)]
 
-fn unwrap_option() {
+fn unwrap_option_some() {
     let _val = 1;
     let _val = 1;
 }
 
+fn unwrap_option_none() {
+    panic!();
+    panic!("this always happens");
+}
+
 fn unwrap_result_ok() {
     let _val = 1;
     let _val = 1;
+    panic!("{:?}", 1);
+    panic!("{1}: {:?}", 1, "this always happens");
 }
 
 fn unwrap_result_err() {
     let _val = 1;
     let _val = 1;
+    panic!("{:?}", 1);
+    panic!("{1}: {:?}", 1, "this always happens");
 }
 
 fn unwrap_methods_option() {
@@ -30,7 +40,8 @@ fn unwrap_methods_result() {
 }
 
 fn main() {
-    unwrap_option();
+    unwrap_option_some();
+    unwrap_option_none();
     unwrap_result_ok();
     unwrap_result_err();
     unwrap_methods_option();
diff --git a/tests/ui/unnecessary_literal_unwrap.rs b/tests/ui/unnecessary_literal_unwrap.rs
index 775d744c13e..926265a3471 100644
--- a/tests/ui/unnecessary_literal_unwrap.rs
+++ b/tests/ui/unnecessary_literal_unwrap.rs
@@ -1,20 +1,30 @@
 //run-rustfix
 #![warn(clippy::unnecessary_literal_unwrap)]
 #![allow(clippy::unnecessary_lazy_evaluations)]
+#![allow(unreachable_code)]
 
-fn unwrap_option() {
+fn unwrap_option_some() {
     let _val = Some(1).unwrap();
     let _val = Some(1).expect("this never happens");
 }
 
+fn unwrap_option_none() {
+    None::<usize>.unwrap();
+    None::<usize>.expect("this always happens");
+}
+
 fn unwrap_result_ok() {
     let _val = Ok::<usize, ()>(1).unwrap();
     let _val = Ok::<usize, ()>(1).expect("this never happens");
+    Ok::<usize, ()>(1).unwrap_err();
+    Ok::<usize, ()>(1).expect_err("this always happens");
 }
 
 fn unwrap_result_err() {
     let _val = Err::<(), usize>(1).unwrap_err();
     let _val = Err::<(), usize>(1).expect_err("this never happens");
+    Err::<(), usize>(1).unwrap();
+    Err::<(), usize>(1).expect("this always happens");
 }
 
 fn unwrap_methods_option() {
@@ -30,7 +40,8 @@ fn unwrap_methods_result() {
 }
 
 fn main() {
-    unwrap_option();
+    unwrap_option_some();
+    unwrap_option_none();
     unwrap_result_ok();
     unwrap_result_err();
     unwrap_methods_option();
diff --git a/tests/ui/unnecessary_literal_unwrap.stderr b/tests/ui/unnecessary_literal_unwrap.stderr
index 622743f8c85..1d23bb22bdd 100644
--- a/tests/ui/unnecessary_literal_unwrap.stderr
+++ b/tests/ui/unnecessary_literal_unwrap.stderr
@@ -1,5 +1,5 @@
 error: used `unwrap()` on `Some` value
-  --> $DIR/unnecessary_literal_unwrap.rs:6:16
+  --> $DIR/unnecessary_literal_unwrap.rs:7:16
    |
 LL |     let _val = Some(1).unwrap();
    |                ^^^^^^^^^^^^^^^^
@@ -12,7 +12,7 @@ LL +     let _val = 1;
    |
 
 error: used `expect()` on `Some` value
-  --> $DIR/unnecessary_literal_unwrap.rs:7:16
+  --> $DIR/unnecessary_literal_unwrap.rs:8:16
    |
 LL |     let _val = Some(1).expect("this never happens");
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -23,8 +23,25 @@ LL -     let _val = Some(1).expect("this never happens");
 LL +     let _val = 1;
    |
 
+error: used `unwrap()` on `None` value
+  --> $DIR/unnecessary_literal_unwrap.rs:12:5
+   |
+LL |     None::<usize>.unwrap();
+   |     ^^^^^^^^^^^^^^^^^^^^^^ help: remove the `None` and `unwrap()`: `panic!()`
+
+error: used `expect()` on `None` value
+  --> $DIR/unnecessary_literal_unwrap.rs:13:5
+   |
+LL |     None::<usize>.expect("this always happens");
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the `None` and `expect()`
+   |
+LL |     panic!("this always happens");
+   |     ~~~~~~~                     ~
+
 error: used `unwrap()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap.rs:11:16
+  --> $DIR/unnecessary_literal_unwrap.rs:17:16
    |
 LL |     let _val = Ok::<usize, ()>(1).unwrap();
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -36,7 +53,7 @@ LL +     let _val = 1;
    |
 
 error: used `expect()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap.rs:12:16
+  --> $DIR/unnecessary_literal_unwrap.rs:18:16
    |
 LL |     let _val = Ok::<usize, ()>(1).expect("this never happens");
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -47,8 +64,30 @@ LL -     let _val = Ok::<usize, ()>(1).expect("this never happens");
 LL +     let _val = 1;
    |
 
+error: used `unwrap_err()` on `Ok` value
+  --> $DIR/unnecessary_literal_unwrap.rs:19:5
+   |
+LL |     Ok::<usize, ()>(1).unwrap_err();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the `Ok` and `unwrap_err()`
+   |
+LL |     panic!("{:?}", 1);
+   |     ~~~~~~~~~~~~~~  ~
+
+error: used `expect_err()` on `Ok` value
+  --> $DIR/unnecessary_literal_unwrap.rs:20:5
+   |
+LL |     Ok::<usize, ()>(1).expect_err("this always happens");
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the `Ok` and `expect_err()`
+   |
+LL |     panic!("{1}: {:?}", 1, "this always happens");
+   |     ~~~~~~~~~~~~~~~~~~~  ~
+
 error: used `unwrap_err()` on `Err` value
-  --> $DIR/unnecessary_literal_unwrap.rs:16:16
+  --> $DIR/unnecessary_literal_unwrap.rs:24:16
    |
 LL |     let _val = Err::<(), usize>(1).unwrap_err();
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -60,7 +99,7 @@ LL +     let _val = 1;
    |
 
 error: used `expect_err()` on `Err` value
-  --> $DIR/unnecessary_literal_unwrap.rs:17:16
+  --> $DIR/unnecessary_literal_unwrap.rs:25:16
    |
 LL |     let _val = Err::<(), usize>(1).expect_err("this never happens");
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -71,8 +110,30 @@ LL -     let _val = Err::<(), usize>(1).expect_err("this never happens");
 LL +     let _val = 1;
    |
 
+error: used `unwrap()` on `Err` value
+  --> $DIR/unnecessary_literal_unwrap.rs:26:5
+   |
+LL |     Err::<(), usize>(1).unwrap();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the `Err` and `unwrap()`
+   |
+LL |     panic!("{:?}", 1);
+   |     ~~~~~~~~~~~~~~  ~
+
+error: used `expect()` on `Err` value
+  --> $DIR/unnecessary_literal_unwrap.rs:27:5
+   |
+LL |     Err::<(), usize>(1).expect("this always happens");
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the `Err` and `expect()`
+   |
+LL |     panic!("{1}: {:?}", 1, "this always happens");
+   |     ~~~~~~~~~~~~~~~~~~~  ~
+
 error: used `unwrap_or()` on `Some` value
-  --> $DIR/unnecessary_literal_unwrap.rs:21:16
+  --> $DIR/unnecessary_literal_unwrap.rs:31:16
    |
 LL |     let _val = Some(1).unwrap_or(2);
    |                ^^^^^^^^^^^^^^^^^^^^
@@ -84,7 +145,7 @@ LL +     let _val = 1;
    |
 
 error: used `unwrap_or_default()` on `Some` value
-  --> $DIR/unnecessary_literal_unwrap.rs:22:16
+  --> $DIR/unnecessary_literal_unwrap.rs:32:16
    |
 LL |     let _val = Some(1).unwrap_or_default();
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -96,7 +157,7 @@ LL +     let _val = 1;
    |
 
 error: used `unwrap_or_else()` on `Some` value
-  --> $DIR/unnecessary_literal_unwrap.rs:23:16
+  --> $DIR/unnecessary_literal_unwrap.rs:33:16
    |
 LL |     let _val = Some(1).unwrap_or_else(|| _val);
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -108,7 +169,7 @@ LL +     let _val = 1;
    |
 
 error: used `unwrap_or()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap.rs:27:16
+  --> $DIR/unnecessary_literal_unwrap.rs:37:16
    |
 LL |     let _val = Ok::<usize, ()>(1).unwrap_or(2);
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -120,7 +181,7 @@ LL +     let _val = 1;
    |
 
 error: used `unwrap_or_default()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap.rs:28:16
+  --> $DIR/unnecessary_literal_unwrap.rs:38:16
    |
 LL |     let _val = Ok::<usize, ()>(1).unwrap_or_default();
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -132,7 +193,7 @@ LL +     let _val = 1;
    |
 
 error: used `unwrap_or_else()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap.rs:29:16
+  --> $DIR/unnecessary_literal_unwrap.rs:39:16
    |
 LL |     let _val = Ok::<usize, ()>(1).unwrap_or_else(|()| _val);
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -143,5 +204,5 @@ LL -     let _val = Ok::<usize, ()>(1).unwrap_or_else(|()| _val);
 LL +     let _val = 1;
    |
 
-error: aborting due to 12 previous errors
+error: aborting due to 18 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 6e4c5561be566c164c7519e6e3c6772f2da17cb4 Mon Sep 17 00:00:00 2001
From: Pavan Kumar Sunkara <pavan.sss1991@gmail.com>
Date: Wed, 31 May 2023 20:09:12 +0100
Subject: Preserve type annotations when present

---
 clippy_lints/src/methods/mod.rs                    |  42 +-
 .../src/methods/unnecessary_literal_unwrap.rs      | 109 +++--
 tests/ui/unnecessary_literal_unwrap.fixed          |  31 +-
 tests/ui/unnecessary_literal_unwrap.rs             |  57 ++-
 tests/ui/unnecessary_literal_unwrap.stderr         | 307 ++++++++++--
 tests/ui/unnecessary_literal_unwrap_unfixable.rs   |  84 +++-
 .../ui/unnecessary_literal_unwrap_unfixable.stderr | 526 ++++++++++++++++++---
 7 files changed, 932 insertions(+), 224 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 912cce39e2e..183bd582a48 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -276,52 +276,28 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for `.unwrap()` or `.unwrap_err()` calls on `Result`s and `.unwrap()` call on `Option`s.
+    /// Checks for `.unwrap()` related calls on `Result`s and `Option`s that are constructed.
     ///
     /// ### Why is this bad?
-    /// It is better to handle the `None` or `Err` case,
-    /// or at least call `.expect(_)` with a more helpful message. Still, for a lot of
-    /// quick-and-dirty code, `unwrap` is a good choice, which is why this lint is
-    /// `Allow` by default.
-    ///
-    /// `result.unwrap()` will let the thread panic on `Err` values.
-    /// Normally, you want to implement more sophisticated error handling,
-    /// and propagate errors upwards with `?` operator.
-    ///
-    /// Even if you want to panic on errors, not all `Error`s implement good
-    /// messages on display. Therefore, it may be beneficial to look at the places
-    /// where they may get displayed. Activate this lint to do just that.
+    /// It is better to write the value directly without the indirection.
     ///
     /// ### Examples
     /// ```rust
-    /// # let option = Some(1);
-    /// # let result: Result<usize, ()> = Ok(1);
-    /// option.unwrap();
-    /// result.unwrap();
+    /// let val1 = Some(1).unwrap();
+    /// let val2 = Ok::<_, ()>(1).unwrap();
+    /// let val3 = Err::<(), _>(1).unwrap_err();
     /// ```
     ///
     /// Use instead:
     /// ```rust
-    /// # let option = Some(1);
-    /// # let result: Result<usize, ()> = Ok(1);
-    /// option.expect("more helpful message");
-    /// result.expect("more helpful message");
-    /// ```
-    ///
-    /// If [expect_used](#expect_used) is enabled, instead:
-    /// ```rust,ignore
-    /// # let option = Some(1);
-    /// # let result: Result<usize, ()> = Ok(1);
-    /// option?;
-    ///
-    /// // or
-    ///
-    /// result?;
+    /// let val1 = 1;
+    /// let val2 = 1;
+    /// let val3 = 1;
     /// ```
     #[clippy::version = "1.69.0"]
     pub UNNECESSARY_LITERAL_UNWRAP,
     complexity,
-    "checks for calls of `unwrap()` or `expect()` on `Some()` that cannot fail"
+    "using `unwrap()` related calls on `Result` and `Option` constructors"
 }
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/methods/unnecessary_literal_unwrap.rs b/clippy_lints/src/methods/unnecessary_literal_unwrap.rs
index fe6b86b34f5..7877f6a386c 100644
--- a/clippy_lints/src/methods/unnecessary_literal_unwrap.rs
+++ b/clippy_lints/src/methods/unnecessary_literal_unwrap.rs
@@ -1,10 +1,26 @@
-use clippy_utils::{diagnostics::span_lint_and_then, is_res_lang_ctor, path_res};
+use clippy_utils::{diagnostics::span_lint_and_then, is_res_lang_ctor, last_path_segment, path_res, MaybePath};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
 
 use super::UNNECESSARY_LITERAL_UNWRAP;
 
+fn get_ty_from_args<'a>(args: Option<&'a [hir::GenericArg<'a>]>, index: usize) -> Option<&'a hir::Ty<'a>> {
+    let args = args?;
+
+    if args.len() <= index {
+        return None;
+    }
+
+    match args[index] {
+        hir::GenericArg::Type(ty) => match ty.kind {
+            hir::TyKind::Infer => None,
+            _ => Some(ty),
+        },
+        _ => None,
+    }
+}
+
 pub(super) fn check(
     cx: &LateContext<'_>,
     expr: &hir::Expr<'_>,
@@ -14,19 +30,24 @@ pub(super) fn check(
 ) {
     let init = clippy_utils::expr_or_init(cx, recv);
 
-    let (constructor, call_args) = if let hir::ExprKind::Call(call, call_args) = init.kind {
-        if is_res_lang_ctor(cx, path_res(cx, call), hir::LangItem::OptionSome) {
-            ("Some", call_args)
-        } else if is_res_lang_ctor(cx, path_res(cx, call), hir::LangItem::ResultOk) {
-            ("Ok", call_args)
-        } else if is_res_lang_ctor(cx, path_res(cx, call), hir::LangItem::ResultErr) {
-            ("Err", call_args)
+    let (constructor, call_args, ty) = if let hir::ExprKind::Call(call, call_args) = init.kind {
+        let Some(qpath) = call.qpath_opt() else { return };
+
+        let args = last_path_segment(qpath).args.map(|args| args.args);
+        let res = cx.qpath_res(qpath, call.hir_id());
+
+        if is_res_lang_ctor(cx, res, hir::LangItem::OptionSome) {
+            ("Some", call_args, get_ty_from_args(args, 0))
+        } else if is_res_lang_ctor(cx, res, hir::LangItem::ResultOk) {
+            ("Ok", call_args, get_ty_from_args(args, 0))
+        } else if is_res_lang_ctor(cx, res, hir::LangItem::ResultErr) {
+            ("Err", call_args, get_ty_from_args(args, 1))
         } else {
             return;
         }
     } else if is_res_lang_ctor(cx, path_res(cx, init), hir::LangItem::OptionNone) {
         let call_args: &[hir::Expr<'_>] = &[];
-        ("None", call_args)
+        ("None", call_args, None)
     } else {
         return;
     };
@@ -34,39 +55,41 @@ pub(super) fn check(
     let help_message = format!("used `{method}()` on `{constructor}` value");
     let suggestion_message = format!("remove the `{constructor}` and `{method}()`");
 
-    if init.span == recv.span {
-        span_lint_and_then(cx, UNNECESSARY_LITERAL_UNWRAP, expr.span, &help_message, |diag| {
-            let suggestions = match (constructor, method) {
-                ("None", "unwrap") => vec![(expr.span, "panic!()".to_string())],
-                ("None", "expect") => vec![
-                    (expr.span.with_hi(args[0].span.lo()), "panic!(".to_string()),
-                    (expr.span.with_lo(args[0].span.hi()), ")".to_string()),
-                ],
-                ("Ok", "unwrap_err") | ("Err", "unwrap") => vec![
-                    (
-                        recv.span.with_hi(call_args[0].span.lo()),
-                        "panic!(\"{:?}\", ".to_string(),
-                    ),
-                    (expr.span.with_lo(call_args[0].span.hi()), ")".to_string()),
-                ],
-                ("Ok", "expect_err") | ("Err", "expect") => vec![
-                    (
-                        recv.span.with_hi(call_args[0].span.lo()),
-                        "panic!(\"{1}: {:?}\", ".to_string(),
-                    ),
-                    (call_args[0].span.with_lo(args[0].span.lo()), ", ".to_string()),
-                ],
-                _ => vec![
-                    (recv.span.with_hi(call_args[0].span.lo()), String::new()),
-                    (expr.span.with_lo(call_args[0].span.hi()), String::new()),
-                ],
-            };
+    span_lint_and_then(cx, UNNECESSARY_LITERAL_UNWRAP, expr.span, &help_message, |diag| {
+        let suggestions = match (constructor, method, ty) {
+            ("None", "unwrap", _) => Some(vec![(expr.span, "panic!()".to_string())]),
+            ("None", "expect", _) => Some(vec![
+                (expr.span.with_hi(args[0].span.lo()), "panic!(".to_string()),
+                (expr.span.with_lo(args[0].span.hi()), ")".to_string()),
+            ]),
+            (_, _, Some(_)) => None,
+            ("Ok", "unwrap_err", None) | ("Err", "unwrap", None) => Some(vec![
+                (
+                    recv.span.with_hi(call_args[0].span.lo()),
+                    "panic!(\"{:?}\", ".to_string(),
+                ),
+                (expr.span.with_lo(call_args[0].span.hi()), ")".to_string()),
+            ]),
+            ("Ok", "expect_err", None) | ("Err", "expect", None) => Some(vec![
+                (
+                    recv.span.with_hi(call_args[0].span.lo()),
+                    "panic!(\"{1}: {:?}\", ".to_string(),
+                ),
+                (call_args[0].span.with_lo(args[0].span.lo()), ", ".to_string()),
+            ]),
+            (_, _, None) => Some(vec![
+                (recv.span.with_hi(call_args[0].span.lo()), String::new()),
+                (expr.span.with_lo(call_args[0].span.hi()), String::new()),
+            ]),
+        };
 
-            diag.multipart_suggestion(suggestion_message, suggestions, Applicability::MachineApplicable);
-        });
-    } else {
-        span_lint_and_then(cx, UNNECESSARY_LITERAL_UNWRAP, expr.span, &help_message, |diag| {
-            diag.span_help(init.span, suggestion_message);
-        });
-    }
+        match (init.span == recv.span, suggestions) {
+            (true, Some(suggestions)) => {
+                diag.multipart_suggestion(suggestion_message, suggestions, Applicability::MachineApplicable);
+            },
+            _ => {
+                diag.span_help(init.span, suggestion_message);
+            },
+        }
+    });
 }
diff --git a/tests/ui/unnecessary_literal_unwrap.fixed b/tests/ui/unnecessary_literal_unwrap.fixed
index 41c4dfda47f..630a1bea3c8 100644
--- a/tests/ui/unnecessary_literal_unwrap.fixed
+++ b/tests/ui/unnecessary_literal_unwrap.fixed
@@ -1,14 +1,25 @@
 //@run-rustfix
 #![warn(clippy::unnecessary_literal_unwrap)]
 #![allow(unreachable_code)]
-#![allow(clippy::unnecessary_lazy_evaluations)]
+#![allow(
+    clippy::unnecessary_lazy_evaluations,
+    clippy::diverging_sub_expression,
+    clippy::let_unit_value,
+    clippy::no_effect
+)]
 
 fn unwrap_option_some() {
     let _val = 1;
     let _val = 1;
+
+    1;
+    1;
 }
 
 fn unwrap_option_none() {
+    let _val = panic!();
+    let _val = panic!("this always happens");
+
     panic!();
     panic!("this always happens");
 }
@@ -16,6 +27,11 @@ fn unwrap_option_none() {
 fn unwrap_result_ok() {
     let _val = 1;
     let _val = 1;
+    let _val = panic!("{:?}", 1);
+    let _val = panic!("{1}: {:?}", 1, "this always happens");
+
+    1;
+    1;
     panic!("{:?}", 1);
     panic!("{1}: {:?}", 1, "this always happens");
 }
@@ -23,6 +39,11 @@ fn unwrap_result_ok() {
 fn unwrap_result_err() {
     let _val = 1;
     let _val = 1;
+    let _val = panic!("{:?}", 1);
+    let _val = panic!("{1}: {:?}", 1, "this always happens");
+
+    1;
+    1;
     panic!("{:?}", 1);
     panic!("{1}: {:?}", 1, "this always happens");
 }
@@ -31,12 +52,20 @@ fn unwrap_methods_option() {
     let _val = 1;
     let _val = 1;
     let _val = 1;
+
+    1;
+    1;
+    1;
 }
 
 fn unwrap_methods_result() {
     let _val = 1;
     let _val = 1;
     let _val = 1;
+
+    1;
+    1;
+    1;
 }
 
 fn main() {
diff --git a/tests/ui/unnecessary_literal_unwrap.rs b/tests/ui/unnecessary_literal_unwrap.rs
index f15c063fe54..14f92cb370f 100644
--- a/tests/ui/unnecessary_literal_unwrap.rs
+++ b/tests/ui/unnecessary_literal_unwrap.rs
@@ -1,42 +1,71 @@
 //@run-rustfix
 #![warn(clippy::unnecessary_literal_unwrap)]
 #![allow(unreachable_code)]
-#![allow(clippy::unnecessary_lazy_evaluations)]
+#![allow(
+    clippy::unnecessary_lazy_evaluations,
+    clippy::diverging_sub_expression,
+    clippy::let_unit_value,
+    clippy::no_effect
+)]
 
 fn unwrap_option_some() {
     let _val = Some(1).unwrap();
     let _val = Some(1).expect("this never happens");
+
+    Some(1).unwrap();
+    Some(1).expect("this never happens");
 }
 
 fn unwrap_option_none() {
-    None::<usize>.unwrap();
-    None::<usize>.expect("this always happens");
+    let _val = None::<()>.unwrap();
+    let _val = None::<()>.expect("this always happens");
+
+    None::<()>.unwrap();
+    None::<()>.expect("this always happens");
 }
 
 fn unwrap_result_ok() {
-    let _val = Ok::<usize, ()>(1).unwrap();
-    let _val = Ok::<usize, ()>(1).expect("this never happens");
-    Ok::<usize, ()>(1).unwrap_err();
-    Ok::<usize, ()>(1).expect_err("this always happens");
+    let _val = Ok::<_, ()>(1).unwrap();
+    let _val = Ok::<_, ()>(1).expect("this never happens");
+    let _val = Ok::<_, ()>(1).unwrap_err();
+    let _val = Ok::<_, ()>(1).expect_err("this always happens");
+
+    Ok::<_, ()>(1).unwrap();
+    Ok::<_, ()>(1).expect("this never happens");
+    Ok::<_, ()>(1).unwrap_err();
+    Ok::<_, ()>(1).expect_err("this always happens");
 }
 
 fn unwrap_result_err() {
-    let _val = Err::<(), usize>(1).unwrap_err();
-    let _val = Err::<(), usize>(1).expect_err("this never happens");
-    Err::<(), usize>(1).unwrap();
-    Err::<(), usize>(1).expect("this always happens");
+    let _val = Err::<(), _>(1).unwrap_err();
+    let _val = Err::<(), _>(1).expect_err("this never happens");
+    let _val = Err::<(), _>(1).unwrap();
+    let _val = Err::<(), _>(1).expect("this always happens");
+
+    Err::<(), _>(1).unwrap_err();
+    Err::<(), _>(1).expect_err("this never happens");
+    Err::<(), _>(1).unwrap();
+    Err::<(), _>(1).expect("this always happens");
 }
 
 fn unwrap_methods_option() {
     let _val = Some(1).unwrap_or(2);
     let _val = Some(1).unwrap_or_default();
     let _val = Some(1).unwrap_or_else(|| 2);
+
+    Some(1).unwrap_or(2);
+    Some(1).unwrap_or_default();
+    Some(1).unwrap_or_else(|| 2);
 }
 
 fn unwrap_methods_result() {
-    let _val = Ok::<usize, ()>(1).unwrap_or(2);
-    let _val = Ok::<usize, ()>(1).unwrap_or_default();
-    let _val = Ok::<usize, ()>(1).unwrap_or_else(|_| 2);
+    let _val = Ok::<_, ()>(1).unwrap_or(2);
+    let _val = Ok::<_, ()>(1).unwrap_or_default();
+    let _val = Ok::<_, ()>(1).unwrap_or_else(|_| 2);
+
+    Ok::<_, ()>(1).unwrap_or(2);
+    Ok::<_, ()>(1).unwrap_or_default();
+    Ok::<_, ()>(1).unwrap_or_else(|_| 2);
 }
 
 fn main() {
diff --git a/tests/ui/unnecessary_literal_unwrap.stderr b/tests/ui/unnecessary_literal_unwrap.stderr
index cf057d7fe5a..0c71ee05323 100644
--- a/tests/ui/unnecessary_literal_unwrap.stderr
+++ b/tests/ui/unnecessary_literal_unwrap.stderr
@@ -1,5 +1,5 @@
 error: used `unwrap()` on `Some` value
-  --> $DIR/unnecessary_literal_unwrap.rs:7:16
+  --> $DIR/unnecessary_literal_unwrap.rs:12:16
    |
 LL |     let _val = Some(1).unwrap();
    |                ^^^^^^^^^^^^^^^^
@@ -12,7 +12,7 @@ LL +     let _val = 1;
    |
 
 error: used `expect()` on `Some` value
-  --> $DIR/unnecessary_literal_unwrap.rs:8:16
+  --> $DIR/unnecessary_literal_unwrap.rs:13:16
    |
 LL |     let _val = Some(1).expect("this never happens");
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -23,17 +23,58 @@ LL -     let _val = Some(1).expect("this never happens");
 LL +     let _val = 1;
    |
 
+error: used `unwrap()` on `Some` value
+  --> $DIR/unnecessary_literal_unwrap.rs:15:5
+   |
+LL |     Some(1).unwrap();
+   |     ^^^^^^^^^^^^^^^^
+   |
+help: remove the `Some` and `unwrap()`
+   |
+LL -     Some(1).unwrap();
+LL +     1;
+   |
+
+error: used `expect()` on `Some` value
+  --> $DIR/unnecessary_literal_unwrap.rs:16:5
+   |
+LL |     Some(1).expect("this never happens");
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the `Some` and `expect()`
+   |
+LL -     Some(1).expect("this never happens");
+LL +     1;
+   |
+
 error: used `unwrap()` on `None` value
-  --> $DIR/unnecessary_literal_unwrap.rs:12:5
+  --> $DIR/unnecessary_literal_unwrap.rs:20:16
    |
-LL |     None::<usize>.unwrap();
-   |     ^^^^^^^^^^^^^^^^^^^^^^ help: remove the `None` and `unwrap()`: `panic!()`
+LL |     let _val = None::<()>.unwrap();
+   |                ^^^^^^^^^^^^^^^^^^^ help: remove the `None` and `unwrap()`: `panic!()`
 
 error: used `expect()` on `None` value
-  --> $DIR/unnecessary_literal_unwrap.rs:13:5
+  --> $DIR/unnecessary_literal_unwrap.rs:21:16
    |
-LL |     None::<usize>.expect("this always happens");
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |     let _val = None::<()>.expect("this always happens");
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the `None` and `expect()`
+   |
+LL |     let _val = panic!("this always happens");
+   |                ~~~~~~~                     ~
+
+error: used `unwrap()` on `None` value
+  --> $DIR/unnecessary_literal_unwrap.rs:23:5
+   |
+LL |     None::<()>.unwrap();
+   |     ^^^^^^^^^^^^^^^^^^^ help: remove the `None` and `unwrap()`: `panic!()`
+
+error: used `expect()` on `None` value
+  --> $DIR/unnecessary_literal_unwrap.rs:24:5
+   |
+LL |     None::<()>.expect("this always happens");
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `None` and `expect()`
    |
@@ -41,34 +82,80 @@ LL |     panic!("this always happens");
    |     ~~~~~~~                     ~
 
 error: used `unwrap()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap.rs:17:16
+  --> $DIR/unnecessary_literal_unwrap.rs:28:16
    |
-LL |     let _val = Ok::<usize, ()>(1).unwrap();
-   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |     let _val = Ok::<_, ()>(1).unwrap();
+   |                ^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Ok` and `unwrap()`
    |
-LL -     let _val = Ok::<usize, ()>(1).unwrap();
+LL -     let _val = Ok::<_, ()>(1).unwrap();
 LL +     let _val = 1;
    |
 
 error: used `expect()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap.rs:18:16
+  --> $DIR/unnecessary_literal_unwrap.rs:29:16
    |
-LL |     let _val = Ok::<usize, ()>(1).expect("this never happens");
-   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |     let _val = Ok::<_, ()>(1).expect("this never happens");
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Ok` and `expect()`
    |
-LL -     let _val = Ok::<usize, ()>(1).expect("this never happens");
+LL -     let _val = Ok::<_, ()>(1).expect("this never happens");
 LL +     let _val = 1;
    |
 
 error: used `unwrap_err()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap.rs:19:5
+  --> $DIR/unnecessary_literal_unwrap.rs:30:16
    |
-LL |     Ok::<usize, ()>(1).unwrap_err();
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |     let _val = Ok::<_, ()>(1).unwrap_err();
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the `Ok` and `unwrap_err()`
+   |
+LL |     let _val = panic!("{:?}", 1);
+   |                ~~~~~~~~~~~~~~  ~
+
+error: used `expect_err()` on `Ok` value
+  --> $DIR/unnecessary_literal_unwrap.rs:31:16
+   |
+LL |     let _val = Ok::<_, ()>(1).expect_err("this always happens");
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the `Ok` and `expect_err()`
+   |
+LL |     let _val = panic!("{1}: {:?}", 1, "this always happens");
+   |                ~~~~~~~~~~~~~~~~~~~  ~
+
+error: used `unwrap()` on `Ok` value
+  --> $DIR/unnecessary_literal_unwrap.rs:33:5
+   |
+LL |     Ok::<_, ()>(1).unwrap();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the `Ok` and `unwrap()`
+   |
+LL -     Ok::<_, ()>(1).unwrap();
+LL +     1;
+   |
+
+error: used `expect()` on `Ok` value
+  --> $DIR/unnecessary_literal_unwrap.rs:34:5
+   |
+LL |     Ok::<_, ()>(1).expect("this never happens");
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the `Ok` and `expect()`
+   |
+LL -     Ok::<_, ()>(1).expect("this never happens");
+LL +     1;
+   |
+
+error: used `unwrap_err()` on `Ok` value
+  --> $DIR/unnecessary_literal_unwrap.rs:35:5
+   |
+LL |     Ok::<_, ()>(1).unwrap_err();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Ok` and `unwrap_err()`
    |
@@ -76,10 +163,10 @@ LL |     panic!("{:?}", 1);
    |     ~~~~~~~~~~~~~~  ~
 
 error: used `expect_err()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap.rs:20:5
+  --> $DIR/unnecessary_literal_unwrap.rs:36:5
    |
-LL |     Ok::<usize, ()>(1).expect_err("this always happens");
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |     Ok::<_, ()>(1).expect_err("this always happens");
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Ok` and `expect_err()`
    |
@@ -87,45 +174,91 @@ LL |     panic!("{1}: {:?}", 1, "this always happens");
    |     ~~~~~~~~~~~~~~~~~~~  ~
 
 error: used `unwrap_err()` on `Err` value
-  --> $DIR/unnecessary_literal_unwrap.rs:24:16
+  --> $DIR/unnecessary_literal_unwrap.rs:40:16
    |
-LL |     let _val = Err::<(), usize>(1).unwrap_err();
-   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |     let _val = Err::<(), _>(1).unwrap_err();
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Err` and `unwrap_err()`
    |
-LL -     let _val = Err::<(), usize>(1).unwrap_err();
+LL -     let _val = Err::<(), _>(1).unwrap_err();
 LL +     let _val = 1;
    |
 
 error: used `expect_err()` on `Err` value
-  --> $DIR/unnecessary_literal_unwrap.rs:25:16
+  --> $DIR/unnecessary_literal_unwrap.rs:41:16
    |
-LL |     let _val = Err::<(), usize>(1).expect_err("this never happens");
-   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |     let _val = Err::<(), _>(1).expect_err("this never happens");
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Err` and `expect_err()`
    |
-LL -     let _val = Err::<(), usize>(1).expect_err("this never happens");
+LL -     let _val = Err::<(), _>(1).expect_err("this never happens");
 LL +     let _val = 1;
    |
 
 error: used `unwrap()` on `Err` value
-  --> $DIR/unnecessary_literal_unwrap.rs:26:5
+  --> $DIR/unnecessary_literal_unwrap.rs:42:16
+   |
+LL |     let _val = Err::<(), _>(1).unwrap();
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the `Err` and `unwrap()`
+   |
+LL |     let _val = panic!("{:?}", 1);
+   |                ~~~~~~~~~~~~~~  ~
+
+error: used `expect()` on `Err` value
+  --> $DIR/unnecessary_literal_unwrap.rs:43:16
+   |
+LL |     let _val = Err::<(), _>(1).expect("this always happens");
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the `Err` and `expect()`
    |
-LL |     Err::<(), usize>(1).unwrap();
+LL |     let _val = panic!("{1}: {:?}", 1, "this always happens");
+   |                ~~~~~~~~~~~~~~~~~~~  ~
+
+error: used `unwrap_err()` on `Err` value
+  --> $DIR/unnecessary_literal_unwrap.rs:45:5
+   |
+LL |     Err::<(), _>(1).unwrap_err();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
+help: remove the `Err` and `unwrap_err()`
+   |
+LL -     Err::<(), _>(1).unwrap_err();
+LL +     1;
+   |
+
+error: used `expect_err()` on `Err` value
+  --> $DIR/unnecessary_literal_unwrap.rs:46:5
+   |
+LL |     Err::<(), _>(1).expect_err("this never happens");
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the `Err` and `expect_err()`
+   |
+LL -     Err::<(), _>(1).expect_err("this never happens");
+LL +     1;
+   |
+
+error: used `unwrap()` on `Err` value
+  --> $DIR/unnecessary_literal_unwrap.rs:47:5
+   |
+LL |     Err::<(), _>(1).unwrap();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^
+   |
 help: remove the `Err` and `unwrap()`
    |
 LL |     panic!("{:?}", 1);
    |     ~~~~~~~~~~~~~~  ~
 
 error: used `expect()` on `Err` value
-  --> $DIR/unnecessary_literal_unwrap.rs:27:5
+  --> $DIR/unnecessary_literal_unwrap.rs:48:5
    |
-LL |     Err::<(), usize>(1).expect("this always happens");
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |     Err::<(), _>(1).expect("this always happens");
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Err` and `expect()`
    |
@@ -133,7 +266,7 @@ LL |     panic!("{1}: {:?}", 1, "this always happens");
    |     ~~~~~~~~~~~~~~~~~~~  ~
 
 error: used `unwrap_or()` on `Some` value
-  --> $DIR/unnecessary_literal_unwrap.rs:31:16
+  --> $DIR/unnecessary_literal_unwrap.rs:52:16
    |
 LL |     let _val = Some(1).unwrap_or(2);
    |                ^^^^^^^^^^^^^^^^^^^^
@@ -145,7 +278,7 @@ LL +     let _val = 1;
    |
 
 error: used `unwrap_or_default()` on `Some` value
-  --> $DIR/unnecessary_literal_unwrap.rs:32:16
+  --> $DIR/unnecessary_literal_unwrap.rs:53:16
    |
 LL |     let _val = Some(1).unwrap_or_default();
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -157,7 +290,7 @@ LL +     let _val = 1;
    |
 
 error: used `unwrap_or_else()` on `Some` value
-  --> $DIR/unnecessary_literal_unwrap.rs:33:16
+  --> $DIR/unnecessary_literal_unwrap.rs:54:16
    |
 LL |     let _val = Some(1).unwrap_or_else(|| 2);
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -168,41 +301,113 @@ LL -     let _val = Some(1).unwrap_or_else(|| 2);
 LL +     let _val = 1;
    |
 
+error: used `unwrap_or()` on `Some` value
+  --> $DIR/unnecessary_literal_unwrap.rs:56:5
+   |
+LL |     Some(1).unwrap_or(2);
+   |     ^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the `Some` and `unwrap_or()`
+   |
+LL -     Some(1).unwrap_or(2);
+LL +     1;
+   |
+
+error: used `unwrap_or_default()` on `Some` value
+  --> $DIR/unnecessary_literal_unwrap.rs:57:5
+   |
+LL |     Some(1).unwrap_or_default();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the `Some` and `unwrap_or_default()`
+   |
+LL -     Some(1).unwrap_or_default();
+LL +     1;
+   |
+
+error: used `unwrap_or_else()` on `Some` value
+  --> $DIR/unnecessary_literal_unwrap.rs:58:5
+   |
+LL |     Some(1).unwrap_or_else(|| 2);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the `Some` and `unwrap_or_else()`
+   |
+LL -     Some(1).unwrap_or_else(|| 2);
+LL +     1;
+   |
+
 error: used `unwrap_or()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap.rs:37:16
+  --> $DIR/unnecessary_literal_unwrap.rs:62:16
    |
-LL |     let _val = Ok::<usize, ()>(1).unwrap_or(2);
-   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |     let _val = Ok::<_, ()>(1).unwrap_or(2);
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Ok` and `unwrap_or()`
    |
-LL -     let _val = Ok::<usize, ()>(1).unwrap_or(2);
+LL -     let _val = Ok::<_, ()>(1).unwrap_or(2);
 LL +     let _val = 1;
    |
 
 error: used `unwrap_or_default()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap.rs:38:16
+  --> $DIR/unnecessary_literal_unwrap.rs:63:16
    |
-LL |     let _val = Ok::<usize, ()>(1).unwrap_or_default();
-   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |     let _val = Ok::<_, ()>(1).unwrap_or_default();
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Ok` and `unwrap_or_default()`
    |
-LL -     let _val = Ok::<usize, ()>(1).unwrap_or_default();
+LL -     let _val = Ok::<_, ()>(1).unwrap_or_default();
 LL +     let _val = 1;
    |
 
 error: used `unwrap_or_else()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap.rs:39:16
+  --> $DIR/unnecessary_literal_unwrap.rs:64:16
    |
-LL |     let _val = Ok::<usize, ()>(1).unwrap_or_else(|_| 2);
-   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |     let _val = Ok::<_, ()>(1).unwrap_or_else(|_| 2);
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Ok` and `unwrap_or_else()`
    |
-LL -     let _val = Ok::<usize, ()>(1).unwrap_or_else(|_| 2);
+LL -     let _val = Ok::<_, ()>(1).unwrap_or_else(|_| 2);
 LL +     let _val = 1;
    |
 
-error: aborting due to 18 previous errors
+error: used `unwrap_or()` on `Ok` value
+  --> $DIR/unnecessary_literal_unwrap.rs:66:5
+   |
+LL |     Ok::<_, ()>(1).unwrap_or(2);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the `Ok` and `unwrap_or()`
+   |
+LL -     Ok::<_, ()>(1).unwrap_or(2);
+LL +     1;
+   |
+
+error: used `unwrap_or_default()` on `Ok` value
+  --> $DIR/unnecessary_literal_unwrap.rs:67:5
+   |
+LL |     Ok::<_, ()>(1).unwrap_or_default();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the `Ok` and `unwrap_or_default()`
+   |
+LL -     Ok::<_, ()>(1).unwrap_or_default();
+LL +     1;
+   |
+
+error: used `unwrap_or_else()` on `Ok` value
+  --> $DIR/unnecessary_literal_unwrap.rs:68:5
+   |
+LL |     Ok::<_, ()>(1).unwrap_or_else(|_| 2);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the `Ok` and `unwrap_or_else()`
+   |
+LL -     Ok::<_, ()>(1).unwrap_or_else(|_| 2);
+LL +     1;
+   |
+
+error: aborting due to 36 previous errors
 
diff --git a/tests/ui/unnecessary_literal_unwrap_unfixable.rs b/tests/ui/unnecessary_literal_unwrap_unfixable.rs
index 9ccf6b21447..711fdce3962 100644
--- a/tests/ui/unnecessary_literal_unwrap_unfixable.rs
+++ b/tests/ui/unnecessary_literal_unwrap_unfixable.rs
@@ -1,6 +1,6 @@
 #![warn(clippy::unnecessary_literal_unwrap)]
-#![allow(clippy::unnecessary_lazy_evaluations)]
 #![allow(unreachable_code)]
+#![allow(clippy::unnecessary_lazy_evaluations, clippy::let_unit_value)]
 
 fn unwrap_option_some() {
     let val = Some(1);
@@ -8,26 +8,61 @@ fn unwrap_option_some() {
     let _val2 = val.expect("this never happens");
 }
 
+fn unwrap_option_some_context() {
+    let _val = Some::<usize>([1, 2, 3].iter().sum()).unwrap();
+    let _val = Some::<usize>([1, 2, 3].iter().sum()).expect("this never happens");
+
+    let val = Some::<usize>([1, 2, 3].iter().sum());
+    let _val2 = val.unwrap();
+    let _val2 = val.expect("this never happens");
+}
+
 fn unwrap_option_none() {
-    let val = None::<usize>;
-    val.unwrap();
-    val.expect("this always happens");
+    let val = None::<()>;
+    let _val2 = val.unwrap();
+    let _val2 = val.expect("this always happens");
 }
 
 fn unwrap_result_ok() {
-    let val = Ok::<usize, ()>(1);
+    let val = Ok::<_, ()>(1);
+    let _val2 = val.unwrap();
+    let _val2 = val.expect("this never happens");
+    let _val2 = val.unwrap_err();
+    let _val2 = val.expect_err("this always happens");
+}
+
+fn unwrap_result_ok_context() {
+    let _val = Ok::<usize, ()>([1, 2, 3].iter().sum()).unwrap();
+    let _val = Ok::<usize, ()>([1, 2, 3].iter().sum()).expect("this never happens");
+    let _val = Ok::<usize, ()>([1, 2, 3].iter().sum()).unwrap_err();
+    let _val = Ok::<usize, ()>([1, 2, 3].iter().sum()).expect_err("this always happens");
+
+    let val = Ok::<usize, ()>([1, 2, 3].iter().sum());
     let _val2 = val.unwrap();
     let _val2 = val.expect("this never happens");
-    val.unwrap_err();
-    val.expect_err("this always happens");
+    let _val2 = val.unwrap_err();
+    let _val2 = val.expect_err("this always happens");
 }
 
 fn unwrap_result_err() {
-    let val = Err::<(), usize>(1);
+    let val = Err::<(), _>(1);
+    let _val2 = val.unwrap_err();
+    let _val2 = val.expect_err("this never happens");
+    let _val2 = val.unwrap();
+    let _val2 = val.expect("this always happens");
+}
+
+fn unwrap_result_err_context() {
+    let _val = Err::<(), usize>([1, 2, 3].iter().sum()).unwrap_err();
+    let _val = Err::<(), usize>([1, 2, 3].iter().sum()).expect_err("this never happens");
+    let _val = Err::<(), usize>([1, 2, 3].iter().sum()).unwrap();
+    let _val = Err::<(), usize>([1, 2, 3].iter().sum()).expect("this always happens");
+
+    let val = Err::<(), usize>([1, 2, 3].iter().sum());
     let _val2 = val.unwrap_err();
     let _val2 = val.expect_err("this never happens");
-    val.unwrap();
-    val.expect("this always happens");
+    let _val2 = val.unwrap();
+    let _val2 = val.expect("this always happens");
 }
 
 fn unwrap_methods_option() {
@@ -37,8 +72,30 @@ fn unwrap_methods_option() {
     let _val2 = val.unwrap_or_else(|| 2);
 }
 
+fn unwrap_methods_option_context() {
+    let _val = Some::<usize>([1, 2, 3].iter().sum()).unwrap_or(2);
+    let _val = Some::<usize>([1, 2, 3].iter().sum()).unwrap_or_default();
+    let _val = Some::<usize>([1, 2, 3].iter().sum()).unwrap_or_else(|| 2);
+
+    let val = Some::<usize>([1, 2, 3].iter().sum());
+    let _val2 = val.unwrap_or(2);
+    let _val2 = val.unwrap_or_default();
+    let _val2 = val.unwrap_or_else(|| 2);
+}
+
 fn unwrap_methods_result() {
-    let val = Ok::<usize, ()>(1);
+    let val = Ok::<_, ()>(1);
+    let _val2 = val.unwrap_or(2);
+    let _val2 = val.unwrap_or_default();
+    let _val2 = val.unwrap_or_else(|_| 2);
+}
+
+fn unwrap_methods_result_context() {
+    let _val = Ok::<usize, ()>([1, 2, 3].iter().sum()).unwrap_or(2);
+    let _val = Ok::<usize, ()>([1, 2, 3].iter().sum()).unwrap_or_default();
+    let _val = Ok::<usize, ()>([1, 2, 3].iter().sum()).unwrap_or_else(|_| 2);
+
+    let val = Ok::<usize, ()>([1, 2, 3].iter().sum());
     let _val2 = val.unwrap_or(2);
     let _val2 = val.unwrap_or_default();
     let _val2 = val.unwrap_or_else(|_| 2);
@@ -46,9 +103,14 @@ fn unwrap_methods_result() {
 
 fn main() {
     unwrap_option_some();
+    unwrap_option_some_context();
     unwrap_option_none();
     unwrap_result_ok();
+    unwrap_result_ok_context();
     unwrap_result_err();
+    unwrap_result_err_context();
     unwrap_methods_option();
+    unwrap_methods_option_context();
     unwrap_methods_result();
+    unwrap_methods_result_context();
 }
diff --git a/tests/ui/unnecessary_literal_unwrap_unfixable.stderr b/tests/ui/unnecessary_literal_unwrap_unfixable.stderr
index 7931deeca7f..feb9325b77a 100644
--- a/tests/ui/unnecessary_literal_unwrap_unfixable.stderr
+++ b/tests/ui/unnecessary_literal_unwrap_unfixable.stderr
@@ -23,197 +23,581 @@ help: remove the `Some` and `expect()`
 LL |     let val = Some(1);
    |               ^^^^^^^
 
+error: used `unwrap()` on `Some` value
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:12:16
+   |
+LL |     let _val = Some::<usize>([1, 2, 3].iter().sum()).unwrap();
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the `Some` and `unwrap()`
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:12:16
+   |
+LL |     let _val = Some::<usize>([1, 2, 3].iter().sum()).unwrap();
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: used `expect()` on `Some` value
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:13:16
+   |
+LL |     let _val = Some::<usize>([1, 2, 3].iter().sum()).expect("this never happens");
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the `Some` and `expect()`
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:13:16
+   |
+LL |     let _val = Some::<usize>([1, 2, 3].iter().sum()).expect("this never happens");
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: used `unwrap()` on `Some` value
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:16:17
+   |
+LL |     let _val2 = val.unwrap();
+   |                 ^^^^^^^^^^^^
+   |
+help: remove the `Some` and `unwrap()`
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:15:15
+   |
+LL |     let val = Some::<usize>([1, 2, 3].iter().sum());
+   |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: used `expect()` on `Some` value
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:17:17
+   |
+LL |     let _val2 = val.expect("this never happens");
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the `Some` and `expect()`
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:15:15
+   |
+LL |     let val = Some::<usize>([1, 2, 3].iter().sum());
+   |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
 error: used `unwrap()` on `None` value
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:13:5
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:22:17
    |
-LL |     val.unwrap();
-   |     ^^^^^^^^^^^^
+LL |     let _val2 = val.unwrap();
+   |                 ^^^^^^^^^^^^
    |
 help: remove the `None` and `unwrap()`
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:12:15
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:21:15
    |
-LL |     let val = None::<usize>;
-   |               ^^^^^^^^^^^^^
+LL |     let val = None::<()>;
+   |               ^^^^^^^^^^
 
 error: used `expect()` on `None` value
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:14:5
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:23:17
    |
-LL |     val.expect("this always happens");
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |     let _val2 = val.expect("this always happens");
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `None` and `expect()`
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:12:15
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:21:15
    |
-LL |     let val = None::<usize>;
-   |               ^^^^^^^^^^^^^
+LL |     let val = None::<()>;
+   |               ^^^^^^^^^^
 
 error: used `unwrap()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:19:17
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:28:17
    |
 LL |     let _val2 = val.unwrap();
    |                 ^^^^^^^^^^^^
    |
 help: remove the `Ok` and `unwrap()`
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:18:15
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:27:15
    |
-LL |     let val = Ok::<usize, ()>(1);
-   |               ^^^^^^^^^^^^^^^^^^
+LL |     let val = Ok::<_, ()>(1);
+   |               ^^^^^^^^^^^^^^
 
 error: used `expect()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:20:17
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:29:17
    |
 LL |     let _val2 = val.expect("this never happens");
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Ok` and `expect()`
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:18:15
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:27:15
    |
-LL |     let val = Ok::<usize, ()>(1);
-   |               ^^^^^^^^^^^^^^^^^^
+LL |     let val = Ok::<_, ()>(1);
+   |               ^^^^^^^^^^^^^^
 
 error: used `unwrap_err()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:21:5
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:30:17
    |
-LL |     val.unwrap_err();
-   |     ^^^^^^^^^^^^^^^^
+LL |     let _val2 = val.unwrap_err();
+   |                 ^^^^^^^^^^^^^^^^
    |
 help: remove the `Ok` and `unwrap_err()`
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:18:15
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:27:15
    |
-LL |     let val = Ok::<usize, ()>(1);
-   |               ^^^^^^^^^^^^^^^^^^
+LL |     let val = Ok::<_, ()>(1);
+   |               ^^^^^^^^^^^^^^
 
 error: used `expect_err()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:22:5
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:31:17
    |
-LL |     val.expect_err("this always happens");
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |     let _val2 = val.expect_err("this always happens");
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Ok` and `expect_err()`
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:18:15
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:27:15
+   |
+LL |     let val = Ok::<_, ()>(1);
+   |               ^^^^^^^^^^^^^^
+
+error: used `unwrap()` on `Ok` value
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:35:16
+   |
+LL |     let _val = Ok::<usize, ()>([1, 2, 3].iter().sum()).unwrap();
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the `Ok` and `unwrap()`
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:35:16
+   |
+LL |     let _val = Ok::<usize, ()>([1, 2, 3].iter().sum()).unwrap();
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: used `expect()` on `Ok` value
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:36:16
+   |
+LL |     let _val = Ok::<usize, ()>([1, 2, 3].iter().sum()).expect("this never happens");
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the `Ok` and `expect()`
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:36:16
    |
-LL |     let val = Ok::<usize, ()>(1);
-   |               ^^^^^^^^^^^^^^^^^^
+LL |     let _val = Ok::<usize, ()>([1, 2, 3].iter().sum()).expect("this never happens");
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: used `unwrap_err()` on `Ok` value
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:37:16
+   |
+LL |     let _val = Ok::<usize, ()>([1, 2, 3].iter().sum()).unwrap_err();
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the `Ok` and `unwrap_err()`
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:37:16
+   |
+LL |     let _val = Ok::<usize, ()>([1, 2, 3].iter().sum()).unwrap_err();
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: used `expect_err()` on `Ok` value
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:38:16
+   |
+LL |     let _val = Ok::<usize, ()>([1, 2, 3].iter().sum()).expect_err("this always happens");
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the `Ok` and `expect_err()`
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:38:16
+   |
+LL |     let _val = Ok::<usize, ()>([1, 2, 3].iter().sum()).expect_err("this always happens");
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: used `unwrap()` on `Ok` value
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:41:17
+   |
+LL |     let _val2 = val.unwrap();
+   |                 ^^^^^^^^^^^^
+   |
+help: remove the `Ok` and `unwrap()`
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:40:15
+   |
+LL |     let val = Ok::<usize, ()>([1, 2, 3].iter().sum());
+   |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: used `expect()` on `Ok` value
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:42:17
+   |
+LL |     let _val2 = val.expect("this never happens");
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the `Ok` and `expect()`
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:40:15
+   |
+LL |     let val = Ok::<usize, ()>([1, 2, 3].iter().sum());
+   |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: used `unwrap_err()` on `Ok` value
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:43:17
+   |
+LL |     let _val2 = val.unwrap_err();
+   |                 ^^^^^^^^^^^^^^^^
+   |
+help: remove the `Ok` and `unwrap_err()`
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:40:15
+   |
+LL |     let val = Ok::<usize, ()>([1, 2, 3].iter().sum());
+   |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: used `expect_err()` on `Ok` value
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:44:17
+   |
+LL |     let _val2 = val.expect_err("this always happens");
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the `Ok` and `expect_err()`
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:40:15
+   |
+LL |     let val = Ok::<usize, ()>([1, 2, 3].iter().sum());
+   |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: used `unwrap_err()` on `Err` value
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:27:17
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:49:17
    |
 LL |     let _val2 = val.unwrap_err();
    |                 ^^^^^^^^^^^^^^^^
    |
 help: remove the `Err` and `unwrap_err()`
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:26:15
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:48:15
    |
-LL |     let val = Err::<(), usize>(1);
-   |               ^^^^^^^^^^^^^^^^^^^
+LL |     let val = Err::<(), _>(1);
+   |               ^^^^^^^^^^^^^^^
 
 error: used `expect_err()` on `Err` value
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:28:17
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:50:17
+   |
+LL |     let _val2 = val.expect_err("this never happens");
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the `Err` and `expect_err()`
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:48:15
+   |
+LL |     let val = Err::<(), _>(1);
+   |               ^^^^^^^^^^^^^^^
+
+error: used `unwrap()` on `Err` value
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:51:17
+   |
+LL |     let _val2 = val.unwrap();
+   |                 ^^^^^^^^^^^^
+   |
+help: remove the `Err` and `unwrap()`
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:48:15
+   |
+LL |     let val = Err::<(), _>(1);
+   |               ^^^^^^^^^^^^^^^
+
+error: used `expect()` on `Err` value
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:52:17
+   |
+LL |     let _val2 = val.expect("this always happens");
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the `Err` and `expect()`
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:48:15
+   |
+LL |     let val = Err::<(), _>(1);
+   |               ^^^^^^^^^^^^^^^
+
+error: used `unwrap_err()` on `Err` value
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:56:16
+   |
+LL |     let _val = Err::<(), usize>([1, 2, 3].iter().sum()).unwrap_err();
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the `Err` and `unwrap_err()`
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:56:16
+   |
+LL |     let _val = Err::<(), usize>([1, 2, 3].iter().sum()).unwrap_err();
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: used `expect_err()` on `Err` value
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:57:16
+   |
+LL |     let _val = Err::<(), usize>([1, 2, 3].iter().sum()).expect_err("this never happens");
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the `Err` and `expect_err()`
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:57:16
+   |
+LL |     let _val = Err::<(), usize>([1, 2, 3].iter().sum()).expect_err("this never happens");
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: used `unwrap()` on `Err` value
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:58:16
+   |
+LL |     let _val = Err::<(), usize>([1, 2, 3].iter().sum()).unwrap();
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the `Err` and `unwrap()`
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:58:16
+   |
+LL |     let _val = Err::<(), usize>([1, 2, 3].iter().sum()).unwrap();
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: used `expect()` on `Err` value
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:59:16
+   |
+LL |     let _val = Err::<(), usize>([1, 2, 3].iter().sum()).expect("this always happens");
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the `Err` and `expect()`
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:59:16
+   |
+LL |     let _val = Err::<(), usize>([1, 2, 3].iter().sum()).expect("this always happens");
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: used `unwrap_err()` on `Err` value
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:62:17
+   |
+LL |     let _val2 = val.unwrap_err();
+   |                 ^^^^^^^^^^^^^^^^
+   |
+help: remove the `Err` and `unwrap_err()`
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:61:15
+   |
+LL |     let val = Err::<(), usize>([1, 2, 3].iter().sum());
+   |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: used `expect_err()` on `Err` value
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:63:17
    |
 LL |     let _val2 = val.expect_err("this never happens");
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Err` and `expect_err()`
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:26:15
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:61:15
    |
-LL |     let val = Err::<(), usize>(1);
-   |               ^^^^^^^^^^^^^^^^^^^
+LL |     let val = Err::<(), usize>([1, 2, 3].iter().sum());
+   |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: used `unwrap()` on `Err` value
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:29:5
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:64:17
    |
-LL |     val.unwrap();
-   |     ^^^^^^^^^^^^
+LL |     let _val2 = val.unwrap();
+   |                 ^^^^^^^^^^^^
    |
 help: remove the `Err` and `unwrap()`
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:26:15
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:61:15
    |
-LL |     let val = Err::<(), usize>(1);
-   |               ^^^^^^^^^^^^^^^^^^^
+LL |     let val = Err::<(), usize>([1, 2, 3].iter().sum());
+   |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: used `expect()` on `Err` value
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:30:5
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:65:17
    |
-LL |     val.expect("this always happens");
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |     let _val2 = val.expect("this always happens");
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Err` and `expect()`
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:26:15
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:61:15
    |
-LL |     let val = Err::<(), usize>(1);
-   |               ^^^^^^^^^^^^^^^^^^^
+LL |     let val = Err::<(), usize>([1, 2, 3].iter().sum());
+   |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: used `unwrap_or()` on `Some` value
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:35:17
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:70:17
    |
 LL |     let _val2 = val.unwrap_or(2);
    |                 ^^^^^^^^^^^^^^^^
    |
 help: remove the `Some` and `unwrap_or()`
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:34:15
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:69:15
    |
 LL |     let val = Some(1);
    |               ^^^^^^^
 
 error: used `unwrap_or_default()` on `Some` value
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:36:17
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:71:17
    |
 LL |     let _val2 = val.unwrap_or_default();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Some` and `unwrap_or_default()`
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:34:15
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:69:15
    |
 LL |     let val = Some(1);
    |               ^^^^^^^
 
 error: used `unwrap_or_else()` on `Some` value
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:37:17
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:72:17
    |
 LL |     let _val2 = val.unwrap_or_else(|| 2);
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Some` and `unwrap_or_else()`
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:34:15
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:69:15
    |
 LL |     let val = Some(1);
    |               ^^^^^^^
 
+error: used `unwrap_or()` on `Some` value
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:76:16
+   |
+LL |     let _val = Some::<usize>([1, 2, 3].iter().sum()).unwrap_or(2);
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the `Some` and `unwrap_or()`
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:76:16
+   |
+LL |     let _val = Some::<usize>([1, 2, 3].iter().sum()).unwrap_or(2);
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: used `unwrap_or_default()` on `Some` value
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:77:16
+   |
+LL |     let _val = Some::<usize>([1, 2, 3].iter().sum()).unwrap_or_default();
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the `Some` and `unwrap_or_default()`
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:77:16
+   |
+LL |     let _val = Some::<usize>([1, 2, 3].iter().sum()).unwrap_or_default();
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: used `unwrap_or_else()` on `Some` value
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:78:16
+   |
+LL |     let _val = Some::<usize>([1, 2, 3].iter().sum()).unwrap_or_else(|| 2);
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the `Some` and `unwrap_or_else()`
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:78:16
+   |
+LL |     let _val = Some::<usize>([1, 2, 3].iter().sum()).unwrap_or_else(|| 2);
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: used `unwrap_or()` on `Some` value
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:81:17
+   |
+LL |     let _val2 = val.unwrap_or(2);
+   |                 ^^^^^^^^^^^^^^^^
+   |
+help: remove the `Some` and `unwrap_or()`
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:80:15
+   |
+LL |     let val = Some::<usize>([1, 2, 3].iter().sum());
+   |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: used `unwrap_or_default()` on `Some` value
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:82:17
+   |
+LL |     let _val2 = val.unwrap_or_default();
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the `Some` and `unwrap_or_default()`
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:80:15
+   |
+LL |     let val = Some::<usize>([1, 2, 3].iter().sum());
+   |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: used `unwrap_or_else()` on `Some` value
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:83:17
+   |
+LL |     let _val2 = val.unwrap_or_else(|| 2);
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the `Some` and `unwrap_or_else()`
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:80:15
+   |
+LL |     let val = Some::<usize>([1, 2, 3].iter().sum());
+   |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
 error: used `unwrap_or()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:42:17
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:88:17
    |
 LL |     let _val2 = val.unwrap_or(2);
    |                 ^^^^^^^^^^^^^^^^
    |
 help: remove the `Ok` and `unwrap_or()`
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:41:15
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:87:15
    |
-LL |     let val = Ok::<usize, ()>(1);
-   |               ^^^^^^^^^^^^^^^^^^
+LL |     let val = Ok::<_, ()>(1);
+   |               ^^^^^^^^^^^^^^
 
 error: used `unwrap_or_default()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:43:17
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:89:17
    |
 LL |     let _val2 = val.unwrap_or_default();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Ok` and `unwrap_or_default()`
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:41:15
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:87:15
    |
-LL |     let val = Ok::<usize, ()>(1);
-   |               ^^^^^^^^^^^^^^^^^^
+LL |     let val = Ok::<_, ()>(1);
+   |               ^^^^^^^^^^^^^^
 
 error: used `unwrap_or_else()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:44:17
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:90:17
+   |
+LL |     let _val2 = val.unwrap_or_else(|_| 2);
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the `Ok` and `unwrap_or_else()`
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:87:15
+   |
+LL |     let val = Ok::<_, ()>(1);
+   |               ^^^^^^^^^^^^^^
+
+error: used `unwrap_or()` on `Ok` value
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:94:16
+   |
+LL |     let _val = Ok::<usize, ()>([1, 2, 3].iter().sum()).unwrap_or(2);
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the `Ok` and `unwrap_or()`
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:94:16
+   |
+LL |     let _val = Ok::<usize, ()>([1, 2, 3].iter().sum()).unwrap_or(2);
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: used `unwrap_or_default()` on `Ok` value
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:95:16
+   |
+LL |     let _val = Ok::<usize, ()>([1, 2, 3].iter().sum()).unwrap_or_default();
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the `Ok` and `unwrap_or_default()`
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:95:16
+   |
+LL |     let _val = Ok::<usize, ()>([1, 2, 3].iter().sum()).unwrap_or_default();
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: used `unwrap_or_else()` on `Ok` value
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:96:16
+   |
+LL |     let _val = Ok::<usize, ()>([1, 2, 3].iter().sum()).unwrap_or_else(|_| 2);
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the `Ok` and `unwrap_or_else()`
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:96:16
+   |
+LL |     let _val = Ok::<usize, ()>([1, 2, 3].iter().sum()).unwrap_or_else(|_| 2);
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: used `unwrap_or()` on `Ok` value
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:99:17
+   |
+LL |     let _val2 = val.unwrap_or(2);
+   |                 ^^^^^^^^^^^^^^^^
+   |
+help: remove the `Ok` and `unwrap_or()`
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:98:15
+   |
+LL |     let val = Ok::<usize, ()>([1, 2, 3].iter().sum());
+   |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: used `unwrap_or_default()` on `Ok` value
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:100:17
+   |
+LL |     let _val2 = val.unwrap_or_default();
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the `Ok` and `unwrap_or_default()`
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:98:15
+   |
+LL |     let val = Ok::<usize, ()>([1, 2, 3].iter().sum());
+   |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: used `unwrap_or_else()` on `Ok` value
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:101:17
    |
 LL |     let _val2 = val.unwrap_or_else(|_| 2);
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Ok` and `unwrap_or_else()`
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:41:15
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:98:15
    |
-LL |     let val = Ok::<usize, ()>(1);
-   |               ^^^^^^^^^^^^^^^^^^
+LL |     let val = Ok::<usize, ()>([1, 2, 3].iter().sum());
+   |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 18 previous errors
+error: aborting due to 50 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 6702c7a7a6b47b3aed254e6b2f1575de234511c3 Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Mon, 12 Jun 2023 11:09:52 -0500
Subject: Add lint [`single_range_in_vec_init`]

---
 CHANGELOG.md                                 |   1 +
 clippy_lints/src/declared_lints.rs           |   1 +
 clippy_lints/src/lib.rs                      |   2 +
 clippy_lints/src/single_range_in_vec_init.rs | 153 +++++++++++++++++++++++++++
 tests/ui/single_element_loop.fixed           |   2 +
 tests/ui/single_element_loop.rs              |   2 +
 tests/ui/single_element_loop.stderr          |  14 +--
 tests/ui/single_range_in_vec_init.rs         |  58 ++++++++++
 tests/ui/single_range_in_vec_init.stderr     | 145 +++++++++++++++++++++++++
 tests/ui/while_let_on_iterator.fixed         |   1 +
 tests/ui/while_let_on_iterator.rs            |   1 +
 tests/ui/while_let_on_iterator.stderr        |  52 ++++-----
 12 files changed, 399 insertions(+), 33 deletions(-)
 create mode 100644 clippy_lints/src/single_range_in_vec_init.rs
 create mode 100644 tests/ui/single_range_in_vec_init.rs
 create mode 100644 tests/ui/single_range_in_vec_init.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 85fddc97047..238c2584221 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5164,6 +5164,7 @@ Released 2018-09-13
 [`single_element_loop`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_element_loop
 [`single_match`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_match
 [`single_match_else`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_match_else
+[`single_range_in_vec_init`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_range_in_vec_init
 [`size_of_in_element_count`]: https://rust-lang.github.io/rust-clippy/master/index.html#size_of_in_element_count
 [`size_of_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#size_of_ref
 [`skip_while_next`]: https://rust-lang.github.io/rust-clippy/master/index.html#skip_while_next
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 523faa302dc..ec127857ab2 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -569,6 +569,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::significant_drop_tightening::SIGNIFICANT_DROP_TIGHTENING_INFO,
     crate::single_char_lifetime_names::SINGLE_CHAR_LIFETIME_NAMES_INFO,
     crate::single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS_INFO,
+    crate::single_range_in_vec_init::SINGLE_RANGE_IN_VEC_INIT_INFO,
     crate::size_of_in_element_count::SIZE_OF_IN_ELEMENT_COUNT_INFO,
     crate::size_of_ref::SIZE_OF_REF_INFO,
     crate::slow_vector_initialization::SLOW_VECTOR_INITIALIZATION_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 243d1fd8606..cf6499b9616 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -288,6 +288,7 @@ mod shadow;
 mod significant_drop_tightening;
 mod single_char_lifetime_names;
 mod single_component_path_imports;
+mod single_range_in_vec_init;
 mod size_of_in_element_count;
 mod size_of_ref;
 mod slow_vector_initialization;
@@ -1045,6 +1046,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     });
     let stack_size_threshold = conf.stack_size_threshold;
     store.register_late_pass(move |_| Box::new(large_stack_frames::LargeStackFrames::new(stack_size_threshold)));
+    store.register_late_pass(|_| Box::new(single_range_in_vec_init::SingleRangeInVecInit));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/single_range_in_vec_init.rs b/clippy_lints/src/single_range_in_vec_init.rs
new file mode 100644
index 00000000000..2d3f18a62c0
--- /dev/null
+++ b/clippy_lints/src/single_range_in_vec_init.rs
@@ -0,0 +1,153 @@
+use clippy_utils::{
+    diagnostics::span_lint_and_then,
+    get_trait_def_id,
+    higher::VecArgs,
+    macros::root_macro_call_first_node,
+    source::{snippet_opt, snippet_with_applicability},
+    ty::implements_trait,
+};
+use rustc_ast::{LitIntType, LitKind, UintTy};
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind, LangItem, QPath};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use std::fmt::{self, Display, Formatter};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `Vec` or array initializations that contain only one range.
+    ///
+    /// ### Why is this bad?
+    /// This is almost always incorrect, as it will result in a `Vec` that has only element. Almost
+    /// always, the programmer intended for it to include all elements in the range or for the end
+    /// of the range to be the length instead.
+    ///
+    /// ### Example
+    /// ```rust
+    /// let x = [0..200];
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// // If it was intended to include every element in the range...
+    /// let x = (0..200).collect::<Vec<i32>>();
+    /// // ...Or if 200 was meant to be the len
+    /// let x = [0; 200];
+    /// ```
+    #[clippy::version = "1.72.0"]
+    pub SINGLE_RANGE_IN_VEC_INIT,
+    suspicious,
+    "checks for initialization of `Vec` or arrays which consist of a single range"
+}
+declare_lint_pass!(SingleRangeInVecInit => [SINGLE_RANGE_IN_VEC_INIT]);
+
+enum SuggestedType {
+    Vec,
+    Array,
+}
+
+impl SuggestedType {
+    fn starts_with(&self) -> &'static str {
+        if matches!(self, SuggestedType::Vec) {
+            "vec!"
+        } else {
+            "["
+        }
+    }
+
+    fn ends_with(&self) -> &'static str {
+        if matches!(self, SuggestedType::Vec) { "" } else { "]" }
+    }
+}
+
+impl Display for SuggestedType {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        if matches!(&self, SuggestedType::Vec) {
+            write!(f, "a `Vec`")
+        } else {
+            write!(f, "an array")
+        }
+    }
+}
+
+impl LateLintPass<'_> for SingleRangeInVecInit {
+    fn check_expr<'tcx>(&mut self, cx: &LateContext<'tcx>, expr: &Expr<'tcx>) {
+        // inner_expr: `vec![0..200]` or `[0..200]`
+        //                   ^^^^^^       ^^^^^^^
+        // span: `vec![0..200]` or `[0..200]`
+        //        ^^^^^^^^^^^^      ^^^^^^^^
+        // kind: What to print, an array or a `Vec`
+        let (inner_expr, span, kind) = if let ExprKind::Array([inner_expr]) = expr.kind
+            && !expr.span.from_expansion()
+        {
+            (inner_expr, expr.span, SuggestedType::Array)
+        } else if let Some(macro_call) = root_macro_call_first_node(cx, expr)
+            && let Some(VecArgs::Vec([expr])) = VecArgs::hir(cx, expr)
+        {
+            (expr, macro_call.span, SuggestedType::Vec)
+        } else {
+            return;
+        };
+
+        let ExprKind::Struct(QPath::LangItem(lang_item, ..), [start, end], None) = inner_expr.kind else {
+            return;
+        };
+
+        if matches!(lang_item, LangItem::Range)
+            && let ty = cx.typeck_results().expr_ty(start.expr)
+            && let Some(snippet) = snippet_opt(cx, span)
+            // `is_from_proc_macro` will skip any `vec![]`. Let's not!
+            && snippet.starts_with(kind.starts_with())
+            && snippet.ends_with(kind.ends_with())
+        {
+            let mut app = Applicability::MaybeIncorrect;
+            let start_snippet = snippet_with_applicability(cx, start.span, "...", &mut app);
+            let end_snippet = snippet_with_applicability(cx, end.span, "...", &mut app);
+
+            let should_emit_every_value = if let Some(step_def_id) = get_trait_def_id(cx, &["core", "iter", "Step"])
+                && implements_trait(cx, ty, step_def_id, &[])
+            {
+                true
+            } else {
+                false
+            };
+            let should_emit_of_len = if let Some(copy_def_id) = cx.tcx.lang_items().copy_trait()
+                && implements_trait(cx, ty, copy_def_id, &[])
+                && let ExprKind::Lit(lit_kind) = end.expr.kind
+                && let LitKind::Int(.., suffix_type) = lit_kind.node
+                && let LitIntType::Unsigned(UintTy::Usize) | LitIntType::Unsuffixed = suffix_type
+            {
+                true
+            } else {
+                false
+            };
+
+            if should_emit_every_value || should_emit_of_len {
+                span_lint_and_then(
+                    cx,
+                    SINGLE_RANGE_IN_VEC_INIT,
+                    span,
+                    &format!("{kind} of `Range` that is only one element"),
+                    |diag| {
+                        if should_emit_every_value {
+                            diag.span_suggestion(
+                                span,
+                                "if you wanted a `Vec` that contains every value in the range, try",
+                                format!("({start_snippet}..{end_snippet}).collect::<std::vec::Vec<{ty}>>()"),
+                                app,
+                            );
+                        }
+
+                        if should_emit_of_len {
+                            diag.span_suggestion(
+                                inner_expr.span,
+                                format!("if you wanted {kind} of len {end_snippet}, try"),
+                                format!("{start_snippet}; {end_snippet}"),
+                                app,
+                            );
+                        }
+                    },
+                );
+            }
+        }
+    }
+}
diff --git a/tests/ui/single_element_loop.fixed b/tests/ui/single_element_loop.fixed
index 1697a0cf29b..598f259415d 100644
--- a/tests/ui/single_element_loop.fixed
+++ b/tests/ui/single_element_loop.fixed
@@ -1,6 +1,8 @@
 //@run-rustfix
 // Tests from for_loop.rs that don't have suggestions
 
+#![allow(clippy::single_range_in_vec_init)]
+
 #[warn(clippy::single_element_loop)]
 fn main() {
     let item1 = 2;
diff --git a/tests/ui/single_element_loop.rs b/tests/ui/single_element_loop.rs
index 860424f42dd..3fc461735a4 100644
--- a/tests/ui/single_element_loop.rs
+++ b/tests/ui/single_element_loop.rs
@@ -1,6 +1,8 @@
 //@run-rustfix
 // Tests from for_loop.rs that don't have suggestions
 
+#![allow(clippy::single_range_in_vec_init)]
+
 #[warn(clippy::single_element_loop)]
 fn main() {
     let item1 = 2;
diff --git a/tests/ui/single_element_loop.stderr b/tests/ui/single_element_loop.stderr
index 14437a59745..c40c6198945 100644
--- a/tests/ui/single_element_loop.stderr
+++ b/tests/ui/single_element_loop.stderr
@@ -1,5 +1,5 @@
 error: for loop over a single element
-  --> $DIR/single_element_loop.rs:7:5
+  --> $DIR/single_element_loop.rs:9:5
    |
 LL | /     for item in &[item1] {
 LL | |         dbg!(item);
@@ -16,7 +16,7 @@ LL +     }
    |
 
 error: for loop over a single element
-  --> $DIR/single_element_loop.rs:11:5
+  --> $DIR/single_element_loop.rs:13:5
    |
 LL | /     for item in [item1].iter() {
 LL | |         dbg!(item);
@@ -32,7 +32,7 @@ LL +     }
    |
 
 error: for loop over a single element
-  --> $DIR/single_element_loop.rs:15:5
+  --> $DIR/single_element_loop.rs:17:5
    |
 LL | /     for item in &[0..5] {
 LL | |         dbg!(item);
@@ -48,7 +48,7 @@ LL +     }
    |
 
 error: for loop over a single element
-  --> $DIR/single_element_loop.rs:19:5
+  --> $DIR/single_element_loop.rs:21:5
    |
 LL | /     for item in [0..5].iter_mut() {
 LL | |         dbg!(item);
@@ -64,7 +64,7 @@ LL +     }
    |
 
 error: for loop over a single element
-  --> $DIR/single_element_loop.rs:23:5
+  --> $DIR/single_element_loop.rs:25:5
    |
 LL | /     for item in [0..5] {
 LL | |         dbg!(item);
@@ -80,7 +80,7 @@ LL +     }
    |
 
 error: for loop over a single element
-  --> $DIR/single_element_loop.rs:27:5
+  --> $DIR/single_element_loop.rs:29:5
    |
 LL | /     for item in [0..5].into_iter() {
 LL | |         dbg!(item);
@@ -96,7 +96,7 @@ LL +     }
    |
 
 error: for loop over a single element
-  --> $DIR/single_element_loop.rs:46:5
+  --> $DIR/single_element_loop.rs:48:5
    |
 LL | /     for _ in [42] {
 LL | |         let _f = |n: u32| {
diff --git a/tests/ui/single_range_in_vec_init.rs b/tests/ui/single_range_in_vec_init.rs
new file mode 100644
index 00000000000..abf784e0f0e
--- /dev/null
+++ b/tests/ui/single_range_in_vec_init.rs
@@ -0,0 +1,58 @@
+//@aux-build:proc_macros.rs
+#![allow(clippy::no_effect, clippy::useless_vec, unused)]
+#![warn(clippy::single_range_in_vec_init)]
+#![feature(generic_arg_infer)]
+
+#[macro_use]
+extern crate proc_macros;
+
+macro_rules! a {
+    () => {
+        vec![0..200];
+    };
+}
+
+fn awa<T: PartialOrd>(start: T, end: T) {
+    [start..end];
+}
+
+fn awa_vec<T: PartialOrd>(start: T, end: T) {
+    vec![start..end];
+}
+
+fn main() {
+    // Lint
+    [0..200];
+    vec![0..200];
+    [0u8..200];
+    [0usize..200];
+    [0..200usize];
+    vec![0u8..200];
+    vec![0usize..200];
+    vec![0..200usize];
+    // Only suggest collect
+    [0..200isize];
+    vec![0..200isize];
+    // Do not lint
+    [0..200, 0..100];
+    vec![0..200, 0..100];
+    [0.0..200.0];
+    vec![0.0..200.0];
+    // `Copy` is not implemented for `Range`, so this doesn't matter
+    // [0..200; 2];
+    // [vec!0..200; 2];
+
+    // Unfortunately skips any macros
+    a!();
+
+    // Skip external macros and procedural macros
+    external! {
+        [0..200];
+        vec![0..200];
+    }
+    with_span! {
+        span
+        [0..200];
+        vec![0..200];
+    }
+}
diff --git a/tests/ui/single_range_in_vec_init.stderr b/tests/ui/single_range_in_vec_init.stderr
new file mode 100644
index 00000000000..fc03b2205e2
--- /dev/null
+++ b/tests/ui/single_range_in_vec_init.stderr
@@ -0,0 +1,145 @@
+error: an array of `Range` that is only one element
+  --> $DIR/single_range_in_vec_init.rs:25:5
+   |
+LL |     [0..200];
+   |     ^^^^^^^^
+   |
+   = note: `-D clippy::single-range-in-vec-init` implied by `-D warnings`
+help: if you wanted a `Vec` that contains every value in the range, try
+   |
+LL |     (0..200).collect::<std::vec::Vec<i32>>();
+   |     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+help: if you wanted an array of len 200, try
+   |
+LL |     [0; 200];
+   |      ~~~~~~
+
+error: a `Vec` of `Range` that is only one element
+  --> $DIR/single_range_in_vec_init.rs:26:5
+   |
+LL |     vec![0..200];
+   |     ^^^^^^^^^^^^
+   |
+help: if you wanted a `Vec` that contains every value in the range, try
+   |
+LL |     (0..200).collect::<std::vec::Vec<i32>>();
+   |     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+help: if you wanted a `Vec` of len 200, try
+   |
+LL |     vec![0; 200];
+   |          ~~~~~~
+
+error: an array of `Range` that is only one element
+  --> $DIR/single_range_in_vec_init.rs:27:5
+   |
+LL |     [0u8..200];
+   |     ^^^^^^^^^^
+   |
+help: if you wanted a `Vec` that contains every value in the range, try
+   |
+LL |     (0u8..200).collect::<std::vec::Vec<u8>>();
+   |     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+help: if you wanted an array of len 200, try
+   |
+LL |     [0u8; 200];
+   |      ~~~~~~~~
+
+error: an array of `Range` that is only one element
+  --> $DIR/single_range_in_vec_init.rs:28:5
+   |
+LL |     [0usize..200];
+   |     ^^^^^^^^^^^^^
+   |
+help: if you wanted a `Vec` that contains every value in the range, try
+   |
+LL |     (0usize..200).collect::<std::vec::Vec<usize>>();
+   |     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+help: if you wanted an array of len 200, try
+   |
+LL |     [0usize; 200];
+   |      ~~~~~~~~~~~
+
+error: an array of `Range` that is only one element
+  --> $DIR/single_range_in_vec_init.rs:29:5
+   |
+LL |     [0..200usize];
+   |     ^^^^^^^^^^^^^
+   |
+help: if you wanted a `Vec` that contains every value in the range, try
+   |
+LL |     (0..200usize).collect::<std::vec::Vec<usize>>();
+   |     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+help: if you wanted an array of len 200usize, try
+   |
+LL |     [0; 200usize];
+   |      ~~~~~~~~~~~
+
+error: a `Vec` of `Range` that is only one element
+  --> $DIR/single_range_in_vec_init.rs:30:5
+   |
+LL |     vec![0u8..200];
+   |     ^^^^^^^^^^^^^^
+   |
+help: if you wanted a `Vec` that contains every value in the range, try
+   |
+LL |     (0u8..200).collect::<std::vec::Vec<u8>>();
+   |     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+help: if you wanted a `Vec` of len 200, try
+   |
+LL |     vec![0u8; 200];
+   |          ~~~~~~~~
+
+error: a `Vec` of `Range` that is only one element
+  --> $DIR/single_range_in_vec_init.rs:31:5
+   |
+LL |     vec![0usize..200];
+   |     ^^^^^^^^^^^^^^^^^
+   |
+help: if you wanted a `Vec` that contains every value in the range, try
+   |
+LL |     (0usize..200).collect::<std::vec::Vec<usize>>();
+   |     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+help: if you wanted a `Vec` of len 200, try
+   |
+LL |     vec![0usize; 200];
+   |          ~~~~~~~~~~~
+
+error: a `Vec` of `Range` that is only one element
+  --> $DIR/single_range_in_vec_init.rs:32:5
+   |
+LL |     vec![0..200usize];
+   |     ^^^^^^^^^^^^^^^^^
+   |
+help: if you wanted a `Vec` that contains every value in the range, try
+   |
+LL |     (0..200usize).collect::<std::vec::Vec<usize>>();
+   |     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+help: if you wanted a `Vec` of len 200usize, try
+   |
+LL |     vec![0; 200usize];
+   |          ~~~~~~~~~~~
+
+error: an array of `Range` that is only one element
+  --> $DIR/single_range_in_vec_init.rs:34:5
+   |
+LL |     [0..200isize];
+   |     ^^^^^^^^^^^^^
+   |
+help: if you wanted a `Vec` that contains every value in the range, try
+   |
+LL |     (0..200isize).collect::<std::vec::Vec<isize>>();
+   |     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+error: a `Vec` of `Range` that is only one element
+  --> $DIR/single_range_in_vec_init.rs:35:5
+   |
+LL |     vec![0..200isize];
+   |     ^^^^^^^^^^^^^^^^^
+   |
+help: if you wanted a `Vec` that contains every value in the range, try
+   |
+LL |     (0..200isize).collect::<std::vec::Vec<isize>>();
+   |     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+error: aborting due to 10 previous errors
+
diff --git a/tests/ui/while_let_on_iterator.fixed b/tests/ui/while_let_on_iterator.fixed
index 11f0de07c62..41a380ab8f6 100644
--- a/tests/ui/while_let_on_iterator.fixed
+++ b/tests/ui/while_let_on_iterator.fixed
@@ -6,6 +6,7 @@
     clippy::manual_find,
     clippy::never_loop,
     clippy::redundant_closure_call,
+    clippy::single_range_in_vec_init,
     clippy::uninlined_format_args,
     clippy::useless_vec
 )]
diff --git a/tests/ui/while_let_on_iterator.rs b/tests/ui/while_let_on_iterator.rs
index e54575dd3b4..4c6433880b6 100644
--- a/tests/ui/while_let_on_iterator.rs
+++ b/tests/ui/while_let_on_iterator.rs
@@ -6,6 +6,7 @@
     clippy::manual_find,
     clippy::never_loop,
     clippy::redundant_closure_call,
+    clippy::single_range_in_vec_init,
     clippy::uninlined_format_args,
     clippy::useless_vec
 )]
diff --git a/tests/ui/while_let_on_iterator.stderr b/tests/ui/while_let_on_iterator.stderr
index f8a66f2ad3e..3236765e1db 100644
--- a/tests/ui/while_let_on_iterator.stderr
+++ b/tests/ui/while_let_on_iterator.stderr
@@ -1,5 +1,5 @@
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:15:5
+  --> $DIR/while_let_on_iterator.rs:16:5
    |
 LL |     while let Option::Some(x) = iter.next() {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for x in iter`
@@ -7,151 +7,151 @@ LL |     while let Option::Some(x) = iter.next() {
    = note: `-D clippy::while-let-on-iterator` implied by `-D warnings`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:20:5
+  --> $DIR/while_let_on_iterator.rs:21:5
    |
 LL |     while let Some(x) = iter.next() {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for x in iter`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:25:5
+  --> $DIR/while_let_on_iterator.rs:26:5
    |
 LL |     while let Some(_) = iter.next() {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for _ in iter`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:101:9
+  --> $DIR/while_let_on_iterator.rs:102:9
    |
 LL |         while let Some([..]) = it.next() {}
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for [..] in it`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:108:9
+  --> $DIR/while_let_on_iterator.rs:109:9
    |
 LL |         while let Some([_x]) = it.next() {}
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for [_x] in it`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:121:9
+  --> $DIR/while_let_on_iterator.rs:122:9
    |
 LL |         while let Some(x @ [_]) = it.next() {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for x @ [_] in it`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:141:9
+  --> $DIR/while_let_on_iterator.rs:142:9
    |
 LL |         while let Some(_) = y.next() {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for _ in y`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:198:9
+  --> $DIR/while_let_on_iterator.rs:199:9
    |
 LL |         while let Some(m) = it.next() {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for m in it.by_ref()`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:209:5
+  --> $DIR/while_let_on_iterator.rs:210:5
    |
 LL |     while let Some(n) = it.next() {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for n in it`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:211:9
+  --> $DIR/while_let_on_iterator.rs:212:9
    |
 LL |         while let Some(m) = it.next() {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for m in it`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:220:9
+  --> $DIR/while_let_on_iterator.rs:221:9
    |
 LL |         while let Some(m) = it.next() {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for m in it`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:229:9
+  --> $DIR/while_let_on_iterator.rs:230:9
    |
 LL |         while let Some(m) = it.next() {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for m in it.by_ref()`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:246:9
+  --> $DIR/while_let_on_iterator.rs:247:9
    |
 LL |         while let Some(m) = it.next() {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for m in it.by_ref()`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:261:13
+  --> $DIR/while_let_on_iterator.rs:262:13
    |
 LL |             while let Some(i) = self.0.next() {
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for i in self.0.by_ref()`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:293:13
+  --> $DIR/while_let_on_iterator.rs:294:13
    |
 LL |             while let Some(i) = self.0.0.0.next() {
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for i in self.0.0.0.by_ref()`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:322:5
+  --> $DIR/while_let_on_iterator.rs:323:5
    |
 LL |     while let Some(n) = it.next() {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for n in it.by_ref()`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:334:9
+  --> $DIR/while_let_on_iterator.rs:335:9
    |
 LL |         while let Some(x) = it.next() {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for x in it.by_ref()`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:348:5
+  --> $DIR/while_let_on_iterator.rs:349:5
    |
 LL |     while let Some(x) = it.next() {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for x in it.by_ref()`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:359:5
+  --> $DIR/while_let_on_iterator.rs:360:5
    |
 LL |     while let Some(x) = it.0.next() {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for x in it.0.by_ref()`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:394:5
+  --> $DIR/while_let_on_iterator.rs:395:5
    |
 LL |     while let Some(x) = s.x.next() {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for x in s.x.by_ref()`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:401:5
+  --> $DIR/while_let_on_iterator.rs:402:5
    |
 LL |     while let Some(x) = x[0].next() {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for x in x[0].by_ref()`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:409:9
+  --> $DIR/while_let_on_iterator.rs:410:9
    |
 LL |         while let Some(x) = it.next() {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for x in it`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:419:9
+  --> $DIR/while_let_on_iterator.rs:420:9
    |
 LL |         while let Some(x) = it.next() {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for x in it`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:429:9
+  --> $DIR/while_let_on_iterator.rs:430:9
    |
 LL |         while let Some(x) = it.next() {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for x in it.by_ref()`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:439:9
+  --> $DIR/while_let_on_iterator.rs:440:9
    |
 LL |         while let Some(x) = it.next() {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for x in it`
 
 error: this loop could be written as a `for` loop
-  --> $DIR/while_let_on_iterator.rs:449:5
+  --> $DIR/while_let_on_iterator.rs:450:5
    |
 LL |     while let Some(..) = it.next() {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for _ in it`
-- 
cgit 1.4.1-3-g733a5


From 357e80ea0d19d7081b0a1f91b52053c49ed93bf5 Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Tue, 13 Jun 2023 06:51:56 -0500
Subject: Ignore more type aliases in `unnecessary_cast`

---
 clippy_lints/src/casts/unnecessary_cast.rs | 71 ++++++++++++++++++++++++++--
 tests/ui/auxiliary/extern_fake_libc.rs     | 10 ++++
 tests/ui/unnecessary_cast.fixed            | 27 ++++++++++-
 tests/ui/unnecessary_cast.rs               | 27 ++++++++++-
 tests/ui/unnecessary_cast.stderr           | 76 +++++++++++++++---------------
 5 files changed, 166 insertions(+), 45 deletions(-)
 create mode 100644 tests/ui/auxiliary/extern_fake_libc.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/unnecessary_cast.rs b/clippy_lints/src/casts/unnecessary_cast.rs
index 41055c168fc..71cf2aea0f8 100644
--- a/clippy_lints/src/casts/unnecessary_cast.rs
+++ b/clippy_lints/src/casts/unnecessary_cast.rs
@@ -1,15 +1,17 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::numeric_literal::NumericLiteral;
 use clippy_utils::source::snippet_opt;
-use clippy_utils::{get_parent_expr, is_hir_ty_cfg_dependant, is_ty_alias, path_to_local};
+use clippy_utils::visitors::{for_each_expr, Visitable};
+use clippy_utils::{get_parent_expr, get_parent_node, is_hir_ty_cfg_dependant, is_ty_alias, path_to_local};
 use if_chain::if_chain;
 use rustc_ast::{LitFloatType, LitIntType, LitKind};
 use rustc_errors::Applicability;
-use rustc_hir::def::Res;
+use rustc_hir::def::{DefKind, Res};
 use rustc_hir::{Expr, ExprKind, Lit, Node, Path, QPath, TyKind, UnOp};
 use rustc_lint::{LateContext, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::{self, FloatTy, InferTy, Ty};
+use std::ops::ControlFlow;
 
 use super::UNNECESSARY_CAST;
 
@@ -59,7 +61,7 @@ pub(super) fn check<'tcx>(
         }
     }
 
-    // skip cast of local to type alias
+    // skip cast of local that is a type alias
     if let ExprKind::Cast(inner, ..) = expr.kind
         && let ExprKind::Path(qpath) = inner.kind
         && let QPath::Resolved(None, Path { res, .. }) = qpath
@@ -83,6 +85,11 @@ pub(super) fn check<'tcx>(
         }
     }
 
+    // skip cast of fn call that returns type alias
+    if let ExprKind::Cast(inner, ..) = expr.kind && is_cast_from_ty_alias(cx, inner, cast_from) {
+        return false;
+    }
+
     // skip cast to non-primitive type
     if_chain! {
         if let ExprKind::Cast(_, cast_to) = expr.kind;
@@ -223,3 +230,61 @@ fn fp_ty_mantissa_nbits(typ: Ty<'_>) -> u32 {
         _ => 0,
     }
 }
+
+/// Finds whether an `Expr` returns a type alias.
+///
+/// TODO: Maybe we should move this to `clippy_utils` so others won't need to go down this dark,
+/// dark path reimplementing this (or something similar).
+fn is_cast_from_ty_alias<'tcx>(cx: &LateContext<'tcx>, expr: impl Visitable<'tcx>, cast_from: Ty<'tcx>) -> bool {
+    for_each_expr(expr, |expr| {
+        // Calls are a `Path`, and usage of locals are a `Path`. So, this checks
+        // - call() as i32
+        // - local as i32
+        if let ExprKind::Path(qpath) = expr.kind {
+            let res = cx.qpath_res(&qpath, expr.hir_id);
+            // Function call
+            if let Res::Def(DefKind::Fn, def_id) = res {
+                let Some(snippet) = snippet_opt(cx, cx.tcx.def_span(def_id)) else {
+                    return ControlFlow::Continue(());
+                };
+                // This is the worst part of this entire function. This is the only way I know of to
+                // check whether a function returns a type alias. Sure, you can get the return type
+                // from a function in the current crate as an hir ty, but how do you get it for
+                // external functions?? Simple: It's impossible. So, we check whether a part of the
+                // function's declaration snippet is exactly equal to the `Ty`. That way, we can
+                // see whether it's a type alias.
+                //
+                // Will this work for more complex types? Probably not!
+                if !snippet
+                    .split("->")
+                    .skip(0)
+                    .map(|s| {
+                        s.trim() == cast_from.to_string()
+                            || s.split("where").any(|ty| ty.trim() == cast_from.to_string())
+                    })
+                    .any(|a| a)
+                {
+                    return ControlFlow::Break(());
+                }
+            // Local usage
+            } else if let Res::Local(hir_id) = res
+                && let Some(parent) = get_parent_node(cx.tcx, hir_id)
+                && let Node::Local(l) = parent
+            {
+                if let Some(e) = l.init && is_cast_from_ty_alias(cx, e, cast_from) {
+                    return ControlFlow::Break::<()>(());
+                }
+
+                if let Some(ty) = l.ty
+                    && let TyKind::Path(qpath) = ty.kind
+                    && is_ty_alias(&qpath)
+                {
+                    return ControlFlow::Break::<()>(());
+                }
+            }
+        }
+
+        ControlFlow::Continue(())
+    })
+    .is_some()
+}
diff --git a/tests/ui/auxiliary/extern_fake_libc.rs b/tests/ui/auxiliary/extern_fake_libc.rs
new file mode 100644
index 00000000000..eb5a5d2b836
--- /dev/null
+++ b/tests/ui/auxiliary/extern_fake_libc.rs
@@ -0,0 +1,10 @@
+#![allow(nonstandard_style)]
+#![allow(clippy::missing_safety_doc, unused)]
+
+type pid_t = i32;
+pub unsafe fn getpid() -> pid_t {
+    pid_t::from(0)
+}
+pub fn getpid_SAFE_TRUTH() -> pid_t {
+    unsafe { getpid() }
+}
diff --git a/tests/ui/unnecessary_cast.fixed b/tests/ui/unnecessary_cast.fixed
index f56cee3a364..8efd44baf59 100644
--- a/tests/ui/unnecessary_cast.fixed
+++ b/tests/ui/unnecessary_cast.fixed
@@ -1,13 +1,17 @@
 //@run-rustfix
+//@aux-build:extern_fake_libc.rs
 #![warn(clippy::unnecessary_cast)]
 #![allow(
-    unused,
     clippy::borrow_as_ptr,
     clippy::no_effect,
     clippy::nonstandard_macro_braces,
-    clippy::unnecessary_operation
+    clippy::unnecessary_operation,
+    nonstandard_style,
+    unused
 )]
 
+extern crate extern_fake_libc;
+
 type PtrConstU8 = *const u8;
 type PtrMutU8 = *mut u8;
 
@@ -19,6 +23,21 @@ fn uwu<T, U>(ptr: *const T) -> *const U {
     ptr as *const U
 }
 
+mod fake_libc {
+    type pid_t = i32;
+    pub unsafe fn getpid() -> pid_t {
+        pid_t::from(0)
+    }
+    // Make sure a where clause does not break it
+    pub fn getpid_SAFE_TRUTH<T: Clone>(t: &T) -> pid_t
+    where
+        T: Clone,
+    {
+        t;
+        unsafe { getpid() }
+    }
+}
+
 #[rustfmt::skip]
 fn main() {
     // Test cast_unnecessary
@@ -82,6 +101,10 @@ fn main() {
     // or from
     let x: I32Alias = 1;
     let y = x as u64;
+    fake_libc::getpid_SAFE_TRUTH(&0u32) as i32;
+    extern_fake_libc::getpid_SAFE_TRUTH() as i32;
+    let pid = unsafe { fake_libc::getpid() };
+    pid as i32;
 
     let i8_ptr: *const i8 = &1;
     let u8_ptr: *const u8 = &1;
diff --git a/tests/ui/unnecessary_cast.rs b/tests/ui/unnecessary_cast.rs
index b4623df6909..c7723ef51f9 100644
--- a/tests/ui/unnecessary_cast.rs
+++ b/tests/ui/unnecessary_cast.rs
@@ -1,13 +1,17 @@
 //@run-rustfix
+//@aux-build:extern_fake_libc.rs
 #![warn(clippy::unnecessary_cast)]
 #![allow(
-    unused,
     clippy::borrow_as_ptr,
     clippy::no_effect,
     clippy::nonstandard_macro_braces,
-    clippy::unnecessary_operation
+    clippy::unnecessary_operation,
+    nonstandard_style,
+    unused
 )]
 
+extern crate extern_fake_libc;
+
 type PtrConstU8 = *const u8;
 type PtrMutU8 = *mut u8;
 
@@ -19,6 +23,21 @@ fn uwu<T, U>(ptr: *const T) -> *const U {
     ptr as *const U
 }
 
+mod fake_libc {
+    type pid_t = i32;
+    pub unsafe fn getpid() -> pid_t {
+        pid_t::from(0)
+    }
+    // Make sure a where clause does not break it
+    pub fn getpid_SAFE_TRUTH<T: Clone>(t: &T) -> pid_t
+    where
+        T: Clone,
+    {
+        t;
+        unsafe { getpid() }
+    }
+}
+
 #[rustfmt::skip]
 fn main() {
     // Test cast_unnecessary
@@ -82,6 +101,10 @@ fn main() {
     // or from
     let x: I32Alias = 1;
     let y = x as u64;
+    fake_libc::getpid_SAFE_TRUTH(&0u32) as i32;
+    extern_fake_libc::getpid_SAFE_TRUTH() as i32;
+    let pid = unsafe { fake_libc::getpid() };
+    pid as i32;
 
     let i8_ptr: *const i8 = &1;
     let u8_ptr: *const u8 = &1;
diff --git a/tests/ui/unnecessary_cast.stderr b/tests/ui/unnecessary_cast.stderr
index 618fbd4faaf..f0443556fb4 100644
--- a/tests/ui/unnecessary_cast.stderr
+++ b/tests/ui/unnecessary_cast.stderr
@@ -1,5 +1,5 @@
 error: casting raw pointers to the same type and constness is unnecessary (`*const T` -> `*const T`)
-  --> $DIR/unnecessary_cast.rs:15:5
+  --> $DIR/unnecessary_cast.rs:19:5
    |
 LL |     ptr as *const T
    |     ^^^^^^^^^^^^^^^ help: try: `ptr`
@@ -7,223 +7,223 @@ LL |     ptr as *const T
    = note: `-D clippy::unnecessary-cast` implied by `-D warnings`
 
 error: casting integer literal to `i32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:25:5
+  --> $DIR/unnecessary_cast.rs:44:5
    |
 LL |     1i32 as i32;
    |     ^^^^^^^^^^^ help: try: `1_i32`
 
 error: casting float literal to `f32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:26:5
+  --> $DIR/unnecessary_cast.rs:45:5
    |
 LL |     1f32 as f32;
    |     ^^^^^^^^^^^ help: try: `1_f32`
 
 error: casting to the same type is unnecessary (`bool` -> `bool`)
-  --> $DIR/unnecessary_cast.rs:27:5
+  --> $DIR/unnecessary_cast.rs:46:5
    |
 LL |     false as bool;
    |     ^^^^^^^^^^^^^ help: try: `false`
 
 error: casting integer literal to `i32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:30:5
+  --> $DIR/unnecessary_cast.rs:49:5
    |
 LL |     -1_i32 as i32;
    |     ^^^^^^^^^^^^^ help: try: `-1_i32`
 
 error: casting integer literal to `i32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:31:5
+  --> $DIR/unnecessary_cast.rs:50:5
    |
 LL |     - 1_i32 as i32;
    |     ^^^^^^^^^^^^^^ help: try: `- 1_i32`
 
 error: casting float literal to `f32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:32:5
+  --> $DIR/unnecessary_cast.rs:51:5
    |
 LL |     -1f32 as f32;
    |     ^^^^^^^^^^^^ help: try: `-1_f32`
 
 error: casting integer literal to `i32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:33:5
+  --> $DIR/unnecessary_cast.rs:52:5
    |
 LL |     1_i32 as i32;
    |     ^^^^^^^^^^^^ help: try: `1_i32`
 
 error: casting float literal to `f32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:34:5
+  --> $DIR/unnecessary_cast.rs:53:5
    |
 LL |     1_f32 as f32;
    |     ^^^^^^^^^^^^ help: try: `1_f32`
 
 error: casting raw pointers to the same type and constness is unnecessary (`*const u8` -> `*const u8`)
-  --> $DIR/unnecessary_cast.rs:36:22
+  --> $DIR/unnecessary_cast.rs:55:22
    |
 LL |     let _: *mut u8 = [1u8, 2].as_ptr() as *const u8 as *mut u8;
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `[1u8, 2].as_ptr()`
 
 error: casting raw pointers to the same type and constness is unnecessary (`*const u8` -> `*const u8`)
-  --> $DIR/unnecessary_cast.rs:38:5
+  --> $DIR/unnecessary_cast.rs:57:5
    |
 LL |     [1u8, 2].as_ptr() as *const u8;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `[1u8, 2].as_ptr()`
 
 error: casting raw pointers to the same type and constness is unnecessary (`*mut u8` -> `*mut u8`)
-  --> $DIR/unnecessary_cast.rs:40:5
+  --> $DIR/unnecessary_cast.rs:59:5
    |
 LL |     [1u8, 2].as_mut_ptr() as *mut u8;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `[1u8, 2].as_mut_ptr()`
 
 error: casting raw pointers to the same type and constness is unnecessary (`*const u32` -> `*const u32`)
-  --> $DIR/unnecessary_cast.rs:51:5
+  --> $DIR/unnecessary_cast.rs:70:5
    |
 LL |     owo::<u32>([1u32].as_ptr()) as *const u32;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `owo::<u32>([1u32].as_ptr())`
 
 error: casting raw pointers to the same type and constness is unnecessary (`*const u8` -> `*const u8`)
-  --> $DIR/unnecessary_cast.rs:52:5
+  --> $DIR/unnecessary_cast.rs:71:5
    |
 LL |     uwu::<u32, u8>([1u32].as_ptr()) as *const u8;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `uwu::<u32, u8>([1u32].as_ptr())`
 
 error: casting raw pointers to the same type and constness is unnecessary (`*const u32` -> `*const u32`)
-  --> $DIR/unnecessary_cast.rs:54:5
+  --> $DIR/unnecessary_cast.rs:73:5
    |
 LL |     uwu::<u32, u32>([1u32].as_ptr()) as *const u32;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `uwu::<u32, u32>([1u32].as_ptr())`
 
 error: casting integer literal to `f32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:116:9
+  --> $DIR/unnecessary_cast.rs:139:9
    |
 LL |         100 as f32;
    |         ^^^^^^^^^^ help: try: `100_f32`
 
 error: casting integer literal to `f64` is unnecessary
-  --> $DIR/unnecessary_cast.rs:117:9
+  --> $DIR/unnecessary_cast.rs:140:9
    |
 LL |         100 as f64;
    |         ^^^^^^^^^^ help: try: `100_f64`
 
 error: casting integer literal to `f64` is unnecessary
-  --> $DIR/unnecessary_cast.rs:118:9
+  --> $DIR/unnecessary_cast.rs:141:9
    |
 LL |         100_i32 as f64;
    |         ^^^^^^^^^^^^^^ help: try: `100_f64`
 
 error: casting integer literal to `f32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:119:17
+  --> $DIR/unnecessary_cast.rs:142:17
    |
 LL |         let _ = -100 as f32;
    |                 ^^^^^^^^^^^ help: try: `-100_f32`
 
 error: casting integer literal to `f64` is unnecessary
-  --> $DIR/unnecessary_cast.rs:120:17
+  --> $DIR/unnecessary_cast.rs:143:17
    |
 LL |         let _ = -100 as f64;
    |                 ^^^^^^^^^^^ help: try: `-100_f64`
 
 error: casting integer literal to `f64` is unnecessary
-  --> $DIR/unnecessary_cast.rs:121:17
+  --> $DIR/unnecessary_cast.rs:144:17
    |
 LL |         let _ = -100_i32 as f64;
    |                 ^^^^^^^^^^^^^^^ help: try: `-100_f64`
 
 error: casting float literal to `f32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:122:9
+  --> $DIR/unnecessary_cast.rs:145:9
    |
 LL |         100. as f32;
    |         ^^^^^^^^^^^ help: try: `100_f32`
 
 error: casting float literal to `f64` is unnecessary
-  --> $DIR/unnecessary_cast.rs:123:9
+  --> $DIR/unnecessary_cast.rs:146:9
    |
 LL |         100. as f64;
    |         ^^^^^^^^^^^ help: try: `100_f64`
 
 error: casting integer literal to `u32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:135:9
+  --> $DIR/unnecessary_cast.rs:158:9
    |
 LL |         1 as u32;
    |         ^^^^^^^^ help: try: `1_u32`
 
 error: casting integer literal to `i32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:136:9
+  --> $DIR/unnecessary_cast.rs:159:9
    |
 LL |         0x10 as i32;
    |         ^^^^^^^^^^^ help: try: `0x10_i32`
 
 error: casting integer literal to `usize` is unnecessary
-  --> $DIR/unnecessary_cast.rs:137:9
+  --> $DIR/unnecessary_cast.rs:160:9
    |
 LL |         0b10 as usize;
    |         ^^^^^^^^^^^^^ help: try: `0b10_usize`
 
 error: casting integer literal to `u16` is unnecessary
-  --> $DIR/unnecessary_cast.rs:138:9
+  --> $DIR/unnecessary_cast.rs:161:9
    |
 LL |         0o73 as u16;
    |         ^^^^^^^^^^^ help: try: `0o73_u16`
 
 error: casting integer literal to `u32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:139:9
+  --> $DIR/unnecessary_cast.rs:162:9
    |
 LL |         1_000_000_000 as u32;
    |         ^^^^^^^^^^^^^^^^^^^^ help: try: `1_000_000_000_u32`
 
 error: casting float literal to `f64` is unnecessary
-  --> $DIR/unnecessary_cast.rs:141:9
+  --> $DIR/unnecessary_cast.rs:164:9
    |
 LL |         1.0 as f64;
    |         ^^^^^^^^^^ help: try: `1.0_f64`
 
 error: casting float literal to `f32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:142:9
+  --> $DIR/unnecessary_cast.rs:165:9
    |
 LL |         0.5 as f32;
    |         ^^^^^^^^^^ help: try: `0.5_f32`
 
 error: casting integer literal to `i32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:146:17
+  --> $DIR/unnecessary_cast.rs:169:17
    |
 LL |         let _ = -1 as i32;
    |                 ^^^^^^^^^ help: try: `-1_i32`
 
 error: casting float literal to `f32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:147:17
+  --> $DIR/unnecessary_cast.rs:170:17
    |
 LL |         let _ = -1.0 as f32;
    |                 ^^^^^^^^^^^ help: try: `-1.0_f32`
 
 error: casting to the same type is unnecessary (`i32` -> `i32`)
-  --> $DIR/unnecessary_cast.rs:153:18
+  --> $DIR/unnecessary_cast.rs:176:18
    |
 LL |         let _ = &(x as i32);
    |                  ^^^^^^^^^^ help: try: `{ x }`
 
 error: casting integer literal to `i32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:159:22
+  --> $DIR/unnecessary_cast.rs:182:22
    |
 LL |         let _: i32 = -(1) as i32;
    |                      ^^^^^^^^^^^ help: try: `-1_i32`
 
 error: casting integer literal to `i64` is unnecessary
-  --> $DIR/unnecessary_cast.rs:161:22
+  --> $DIR/unnecessary_cast.rs:184:22
    |
 LL |         let _: i64 = -(1) as i64;
    |                      ^^^^^^^^^^^ help: try: `-1_i64`
 
 error: casting float literal to `f64` is unnecessary
-  --> $DIR/unnecessary_cast.rs:168:22
+  --> $DIR/unnecessary_cast.rs:191:22
    |
 LL |         let _: f64 = (-8.0 as f64).exp();
    |                      ^^^^^^^^^^^^^ help: try: `(-8.0_f64)`
 
 error: casting float literal to `f64` is unnecessary
-  --> $DIR/unnecessary_cast.rs:170:23
+  --> $DIR/unnecessary_cast.rs:193:23
    |
 LL |         let _: f64 = -(8.0 as f64).exp(); // should suggest `-8.0_f64.exp()` here not to change code behavior
    |                       ^^^^^^^^^^^^ help: try: `8.0_f64`
 
 error: casting to the same type is unnecessary (`f32` -> `f32`)
-  --> $DIR/unnecessary_cast.rs:178:20
+  --> $DIR/unnecessary_cast.rs:201:20
    |
 LL |         let _num = foo() as f32;
    |                    ^^^^^^^^^^^^ help: try: `foo()`
-- 
cgit 1.4.1-3-g733a5


From d5b2f113403313a3f79e30832cd029bebfd93958 Mon Sep 17 00:00:00 2001
From: blyxyas <blyxyas@gmail.com>
Date: Sun, 11 Jun 2023 21:55:49 +0200
Subject: Now `cargo collect-metadata` updates the `CHANGELOG.md`

---
 CHANGELOG.md                                       | 59 ++++++++++++++++++++++
 .../src/utils/internal_lints/metadata_collector.rs | 18 +++++++
 clippy_lints/src/utils/mod.rs                      |  7 +++
 3 files changed, 84 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index abc35e8546f..35b1075ff01 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5322,3 +5322,62 @@ Released 2018-09-13
 [`zero_width_space`]: https://rust-lang.github.io/rust-clippy/master/index.html#zero_width_space
 [`zst_offset`]: https://rust-lang.github.io/rust-clippy/master/index.html#zst_offset
 <!-- end autogenerated links to lint list -->
+<!-- begin autogenerated links to configuration documentation -->
+[`arithmetic-side-effects-allowed`]: https://doc.rust-lang.org/clippy/lint_configuration.html#arithmetic-side-effects-allowed
+[`arithmetic-side-effects-allowed-binary`]: https://doc.rust-lang.org/clippy/lint_configuration.html#arithmetic-side-effects-allowed-binary
+[`arithmetic-side-effects-allowed-unary`]: https://doc.rust-lang.org/clippy/lint_configuration.html#arithmetic-side-effects-allowed-unary
+[`avoid-breaking-exported-api`]: https://doc.rust-lang.org/clippy/lint_configuration.html#avoid-breaking-exported-api
+[`msrv`]: https://doc.rust-lang.org/clippy/lint_configuration.html#msrv
+[`cognitive-complexity-threshold`]: https://doc.rust-lang.org/clippy/lint_configuration.html#cognitive-complexity-threshold
+[`excessive-nesting-threshold`]: https://doc.rust-lang.org/clippy/lint_configuration.html#excessive-nesting-threshold
+[`disallowed-names`]: https://doc.rust-lang.org/clippy/lint_configuration.html#disallowed-names
+[`semicolon-inside-block-ignore-singleline`]: https://doc.rust-lang.org/clippy/lint_configuration.html#semicolon-inside-block-ignore-singleline
+[`semicolon-outside-block-ignore-multiline`]: https://doc.rust-lang.org/clippy/lint_configuration.html#semicolon-outside-block-ignore-multiline
+[`doc-valid-idents`]: https://doc.rust-lang.org/clippy/lint_configuration.html#doc-valid-idents
+[`too-many-arguments-threshold`]: https://doc.rust-lang.org/clippy/lint_configuration.html#too-many-arguments-threshold
+[`type-complexity-threshold`]: https://doc.rust-lang.org/clippy/lint_configuration.html#type-complexity-threshold
+[`single-char-binding-names-threshold`]: https://doc.rust-lang.org/clippy/lint_configuration.html#single-char-binding-names-threshold
+[`too-large-for-stack`]: https://doc.rust-lang.org/clippy/lint_configuration.html#too-large-for-stack
+[`enum-variant-name-threshold`]: https://doc.rust-lang.org/clippy/lint_configuration.html#enum-variant-name-threshold
+[`enum-variant-size-threshold`]: https://doc.rust-lang.org/clippy/lint_configuration.html#enum-variant-size-threshold
+[`verbose-bit-mask-threshold`]: https://doc.rust-lang.org/clippy/lint_configuration.html#verbose-bit-mask-threshold
+[`literal-representation-threshold`]: https://doc.rust-lang.org/clippy/lint_configuration.html#literal-representation-threshold
+[`trivial-copy-size-limit`]: https://doc.rust-lang.org/clippy/lint_configuration.html#trivial-copy-size-limit
+[`pass-by-value-size-limit`]: https://doc.rust-lang.org/clippy/lint_configuration.html#pass-by-value-size-limit
+[`too-many-lines-threshold`]: https://doc.rust-lang.org/clippy/lint_configuration.html#too-many-lines-threshold
+[`array-size-threshold`]: https://doc.rust-lang.org/clippy/lint_configuration.html#array-size-threshold
+[`stack-size-threshold`]: https://doc.rust-lang.org/clippy/lint_configuration.html#stack-size-threshold
+[`vec-box-size-threshold`]: https://doc.rust-lang.org/clippy/lint_configuration.html#vec-box-size-threshold
+[`max-trait-bounds`]: https://doc.rust-lang.org/clippy/lint_configuration.html#max-trait-bounds
+[`max-struct-bools`]: https://doc.rust-lang.org/clippy/lint_configuration.html#max-struct-bools
+[`max-fn-params-bools`]: https://doc.rust-lang.org/clippy/lint_configuration.html#max-fn-params-bools
+[`warn-on-all-wildcard-imports`]: https://doc.rust-lang.org/clippy/lint_configuration.html#warn-on-all-wildcard-imports
+[`disallowed-macros`]: https://doc.rust-lang.org/clippy/lint_configuration.html#disallowed-macros
+[`disallowed-methods`]: https://doc.rust-lang.org/clippy/lint_configuration.html#disallowed-methods
+[`disallowed-types`]: https://doc.rust-lang.org/clippy/lint_configuration.html#disallowed-types
+[`unreadable-literal-lint-fractions`]: https://doc.rust-lang.org/clippy/lint_configuration.html#unreadable-literal-lint-fractions
+[`upper-case-acronyms-aggressive`]: https://doc.rust-lang.org/clippy/lint_configuration.html#upper-case-acronyms-aggressive
+[`matches-for-let-else`]: https://doc.rust-lang.org/clippy/lint_configuration.html#matches-for-let-else
+[`cargo-ignore-publish`]: https://doc.rust-lang.org/clippy/lint_configuration.html#cargo-ignore-publish
+[`standard-macro-braces`]: https://doc.rust-lang.org/clippy/lint_configuration.html#standard-macro-braces
+[`enforced-import-renames`]: https://doc.rust-lang.org/clippy/lint_configuration.html#enforced-import-renames
+[`allowed-scripts`]: https://doc.rust-lang.org/clippy/lint_configuration.html#allowed-scripts
+[`enable-raw-pointer-heuristic-for-send`]: https://doc.rust-lang.org/clippy/lint_configuration.html#enable-raw-pointer-heuristic-for-send
+[`max-suggested-slice-pattern-length`]: https://doc.rust-lang.org/clippy/lint_configuration.html#max-suggested-slice-pattern-length
+[`await-holding-invalid-types`]: https://doc.rust-lang.org/clippy/lint_configuration.html#await-holding-invalid-types
+[`max-include-file-size`]: https://doc.rust-lang.org/clippy/lint_configuration.html#max-include-file-size
+[`allow-expect-in-tests`]: https://doc.rust-lang.org/clippy/lint_configuration.html#allow-expect-in-tests
+[`allow-unwrap-in-tests`]: https://doc.rust-lang.org/clippy/lint_configuration.html#allow-unwrap-in-tests
+[`allow-dbg-in-tests`]: https://doc.rust-lang.org/clippy/lint_configuration.html#allow-dbg-in-tests
+[`allow-print-in-tests`]: https://doc.rust-lang.org/clippy/lint_configuration.html#allow-print-in-tests
+[`large-error-threshold`]: https://doc.rust-lang.org/clippy/lint_configuration.html#large-error-threshold
+[`ignore-interior-mutability`]: https://doc.rust-lang.org/clippy/lint_configuration.html#ignore-interior-mutability
+[`allow-mixed-uninlined-format-args`]: https://doc.rust-lang.org/clippy/lint_configuration.html#allow-mixed-uninlined-format-args
+[`suppress-restriction-lint-in-const`]: https://doc.rust-lang.org/clippy/lint_configuration.html#suppress-restriction-lint-in-const
+[`missing-docs-in-crate-items`]: https://doc.rust-lang.org/clippy/lint_configuration.html#missing-docs-in-crate-items
+[`future-size-threshold`]: https://doc.rust-lang.org/clippy/lint_configuration.html#future-size-threshold
+[`unnecessary-box-size`]: https://doc.rust-lang.org/clippy/lint_configuration.html#unnecessary-box-size
+[`allow-private-module-inception`]: https://doc.rust-lang.org/clippy/lint_configuration.html#allow-private-module-inception
+[`allowed-idents-below-min-chars`]: https://doc.rust-lang.org/clippy/lint_configuration.html#allowed-idents-below-min-chars
+[`min-ident-chars-threshold`]: https://doc.rust-lang.org/clippy/lint_configuration.html#min-ident-chars-threshold
+<!-- end autogenerated links to configuration documentation -->
diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index 2a9aba0a116..107a62806a8 100644
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -104,6 +104,8 @@ const APPLICABILITY_UNRESOLVED_STR: &str = "Unresolved";
 /// The version that will be displayed if none has been defined
 const VERSION_DEFAULT_STR: &str = "Unknown";
 
+const CHANGELOG_PATH: &str = "../CHANGELOG.md";
+
 declare_clippy_lint! {
     /// ### What it does
     /// Collects metadata about clippy lints for the website.
@@ -260,6 +262,22 @@ Please use that command to update the file and do not edit it by hand.
             self.get_markdown_docs(),
         )
         .unwrap();
+
+        // Write configuration links to CHANGELOG.md
+        let mut changelog = std::fs::read_to_string(CHANGELOG_PATH).unwrap();
+        let mut changelog_file = OpenOptions::new().read(true).write(true).open(CHANGELOG_PATH).unwrap();
+
+        if let Some(position) = changelog.find("<!-- begin autogenerated links to configuration documentation -->") {
+            // I know this is kinda wasteful, we just don't have regex on `clippy_lints` so... this is the best
+            // we can do AFAIK.
+            changelog = changelog[..position].to_string();
+        }
+        writeln!(
+            changelog_file,
+            "{changelog}<!-- begin autogenerated links to configuration documentation -->\n{}\n<!-- end autogenerated links to configuration documentation -->",
+            self.configs_to_markdown(ClippyConfiguration::to_markdown_link)
+        )
+        .unwrap();
     }
 }
 
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index 884edec2d79..fb08256931f 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -12,6 +12,9 @@ fn to_kebab(config_name: &str) -> String {
     config_name.replace('_', "-")
 }
 
+#[cfg(feature = "internal")]
+const BOOK_CONFIGS_PATH: &str = "https://doc.rust-lang.org/clippy/lint_configuration.html";
+
 // ==================================================================
 // Configuration
 // ==================================================================
@@ -66,6 +69,10 @@ impl ClippyConfiguration {
                 .join("\n"),
         )
     }
+    #[cfg(feature = "internal")]
+    fn to_markdown_link(&self) -> String {
+        format!("[`{}`]: {BOOK_CONFIGS_PATH}#{}", self.name, self.name)
+    }
 }
 
 #[cfg(feature = "internal")]
-- 
cgit 1.4.1-3-g733a5


From bcaf655b70671275ca07b7f5c924f27125ee8c0b Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Tue, 13 Jun 2023 16:41:16 +0200
Subject: Remove dead code in `needless_pass_by_value`

---
 clippy_lints/src/needless_pass_by_value.rs | 29 ++++-------------------------
 1 file changed, 4 insertions(+), 25 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/needless_pass_by_value.rs b/clippy_lints/src/needless_pass_by_value.rs
index 7d53fe65658..3b118239a21 100644
--- a/clippy_lints/src/needless_pass_by_value.rs
+++ b/clippy_lints/src/needless_pass_by_value.rs
@@ -7,13 +7,12 @@ use clippy_utils::ty::{
 use clippy_utils::{get_trait_def_id, is_self, paths};
 use if_chain::if_chain;
 use rustc_ast::ast::Attribute;
-use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::{Applicability, Diagnostic};
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::{
     BindingAnnotation, Body, FnDecl, GenericArg, HirId, Impl, ItemKind, Mutability, Node, PatKind, QPath, TyKind,
 };
-use rustc_hir::{HirIdMap, HirIdSet, LangItem};
+use rustc_hir::{HirIdSet, LangItem};
 use rustc_hir_typeck::expr_use_visitor as euv;
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::{LateContext, LateLintPass};
@@ -136,11 +135,7 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByValue {
 
         // Collect moved variables and spans which will need dereferencings from the
         // function body.
-        let MovedVariablesCtxt {
-            moved_vars,
-            spans_need_deref,
-            ..
-        } = {
+        let MovedVariablesCtxt { moved_vars } = {
             let mut ctx = MovedVariablesCtxt::default();
             let infcx = cx.tcx.infer_ctxt().build();
             euv::ExprUseVisitor::new(&mut ctx, &infcx, fn_def_id, cx.param_env, cx.typeck_results()).consume_body(body);
@@ -211,7 +206,6 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByValue {
                             }
                         }
 
-                        let deref_span = spans_need_deref.get(&canonical_id);
                         if_chain! {
                             if is_type_diagnostic_item(cx, ty, sym::Vec);
                             if let Some(clone_spans) =
@@ -247,7 +241,6 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByValue {
                                 }
 
                                 // cannot be destructured, no need for `*` suggestion
-                                assert!(deref_span.is_none());
                                 return;
                             }
                         }
@@ -275,23 +268,12 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByValue {
                                     );
                                 }
 
-                                assert!(deref_span.is_none());
                                 return;
                             }
                         }
 
-                        let mut spans = vec![(input.span, format!("&{}", snippet(cx, input.span, "_")))];
-
-                        // Suggests adding `*` to dereference the added reference.
-                        if let Some(deref_span) = deref_span {
-                            spans.extend(
-                                deref_span
-                                    .iter()
-                                    .copied()
-                                    .map(|span| (span, format!("*{}", snippet(cx, span, "<expr>")))),
-                            );
-                            spans.sort_by_key(|&(span, _)| span);
-                        }
+                        let spans = vec![(input.span, format!("&{}", snippet(cx, input.span, "_")))];
+
                         multispan_sugg(diag, "consider taking a reference instead", spans);
                     };
 
@@ -320,9 +302,6 @@ fn requires_exact_signature(attrs: &[Attribute]) -> bool {
 #[derive(Default)]
 struct MovedVariablesCtxt {
     moved_vars: HirIdSet,
-    /// Spans which need to be prefixed with `*` for dereferencing the
-    /// suggested additional reference.
-    spans_need_deref: HirIdMap<FxHashSet<Span>>,
 }
 
 impl MovedVariablesCtxt {
-- 
cgit 1.4.1-3-g733a5


From d255e7a53fb62e77cdfa7ce1459fc5a06072e21a Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Tue, 13 Jun 2023 12:29:50 -0500
Subject: [`no_effect`]: suggest adding `return` if applicable

make cargo test pass

Revert "Make it `Unspecified`"

This reverts commit 774863041c1878ab7fb6e27c1c61c04de0e25bc8.

Make it `Unspecified`
---
 clippy_lints/src/no_effect.rs    | 47 +++++++++++++++++++++--
 tests/ui/no_effect_return.rs     | 81 ++++++++++++++++++++++++++++++++++++++++
 tests/ui/no_effect_return.stderr | 70 ++++++++++++++++++++++++++++++++++
 3 files changed, 195 insertions(+), 3 deletions(-)
 create mode 100644 tests/ui/no_effect_return.rs
 create mode 100644 tests/ui/no_effect_return.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/no_effect.rs b/clippy_lints/src/no_effect.rs
index e3712190e67..a4c7da7e48d 100644
--- a/clippy_lints/src/no_effect.rs
+++ b/clippy_lints/src/no_effect.rs
@@ -1,11 +1,16 @@
 use clippy_utils::diagnostics::{span_lint_hir, span_lint_hir_and_then};
-use clippy_utils::is_lint_allowed;
 use clippy_utils::peel_blocks;
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::has_drop;
+use clippy_utils::{get_parent_node, is_lint_allowed};
 use rustc_errors::Applicability;
 use rustc_hir::def::{DefKind, Res};
-use rustc_hir::{is_range_literal, BinOpKind, BlockCheckMode, Expr, ExprKind, PatKind, Stmt, StmtKind, UnsafeSource};
+use rustc_hir::{
+    is_range_literal, BinOpKind, BlockCheckMode, Expr, ExprKind, FnRetTy, ItemKind, Node, PatKind, Stmt, StmtKind,
+    UnsafeSource,
+};
+use rustc_hir_analysis::hir_ty_to_ty;
+use rustc_infer::infer::TyCtxtInferExt as _;
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -86,7 +91,43 @@ impl<'tcx> LateLintPass<'tcx> for NoEffect {
 fn check_no_effect(cx: &LateContext<'_>, stmt: &Stmt<'_>) -> bool {
     if let StmtKind::Semi(expr) = stmt.kind {
         if has_no_effect(cx, expr) {
-            span_lint_hir(cx, NO_EFFECT, expr.hir_id, stmt.span, "statement with no effect");
+            span_lint_hir_and_then(
+                cx,
+                NO_EFFECT,
+                expr.hir_id,
+                stmt.span,
+                "statement with no effect",
+                |diag| {
+                    for parent in cx.tcx.hir().parent_iter(stmt.hir_id) {
+                        if let Node::Item(item) = parent.1
+                            && let ItemKind::Fn(sig, ..) = item.kind
+                            && let FnRetTy::Return(ret_ty) = sig.decl.output
+                            && let Some(Node::Block(block)) = get_parent_node(cx.tcx, stmt.hir_id)
+                            && let [.., final_stmt] = block.stmts
+                            && final_stmt.hir_id == stmt.hir_id
+                        {
+                            let expr_ty = cx.typeck_results().expr_ty(expr);
+                            let mut ret_ty = hir_ty_to_ty(cx.tcx, ret_ty);
+
+                            // Remove `impl Future<Output = T>` to get `T`
+                            if cx.tcx.ty_is_opaque_future(ret_ty) &&
+                                let Some(true_ret_ty) = cx.tcx.infer_ctxt().build().get_impl_future_output_ty(ret_ty)
+                            {
+                                ret_ty = true_ret_ty;
+                            }
+
+                            if ret_ty == expr_ty {
+                                diag.span_suggestion(
+                                    stmt.span.shrink_to_lo(),
+                                    "did you mean to return it?",
+                                    "return ",
+                                    Applicability::MaybeIncorrect,
+                                );
+                            }
+                        }
+                    }
+                },
+            );
             return true;
         }
     } else if let StmtKind::Local(local) = stmt.kind {
diff --git a/tests/ui/no_effect_return.rs b/tests/ui/no_effect_return.rs
new file mode 100644
index 00000000000..231dd063ad8
--- /dev/null
+++ b/tests/ui/no_effect_return.rs
@@ -0,0 +1,81 @@
+#![allow(clippy::unused_unit, dead_code, unused)]
+#![no_main]
+
+use std::ops::ControlFlow;
+
+fn a() -> u32 {
+    {
+        0u32;
+    }
+    0
+}
+
+async fn b() -> u32 {
+    {
+        0u32;
+    }
+    0
+}
+
+type C = i32;
+async fn c() -> C {
+    {
+        0i32 as C;
+    }
+    0
+}
+
+fn d() -> u128 {
+    {
+        // not last stmt
+        0u128;
+        println!("lol");
+    }
+    0
+}
+
+fn e() -> u32 {
+    {
+        // mismatched types
+        0u16;
+    }
+    0
+}
+
+fn f() -> [u16; 1] {
+    {
+        [1u16];
+    }
+    [1]
+}
+
+fn g() -> ControlFlow<()> {
+    {
+        ControlFlow::Break::<()>(());
+    }
+    ControlFlow::Continue(())
+}
+
+fn h() -> Vec<u16> {
+    {
+        // function call, so this won't trigger `no_effect`. not an issue with this change, but the
+        // lint itself (but also not really.)
+        vec![0u16];
+    }
+    vec![]
+}
+
+fn i() -> () {
+    {
+        ();
+    }
+    ()
+}
+
+fn j() {
+    {
+        // does not suggest on function without explicit return type
+        ();
+    }
+    ()
+}
diff --git a/tests/ui/no_effect_return.stderr b/tests/ui/no_effect_return.stderr
new file mode 100644
index 00000000000..779900e1859
--- /dev/null
+++ b/tests/ui/no_effect_return.stderr
@@ -0,0 +1,70 @@
+error: statement with no effect
+  --> $DIR/no_effect_return.rs:8:9
+   |
+LL |         0u32;
+   |         -^^^^
+   |         |
+   |         help: did you mean to return it?: `return`
+   |
+   = note: `-D clippy::no-effect` implied by `-D warnings`
+
+error: statement with no effect
+  --> $DIR/no_effect_return.rs:15:9
+   |
+LL |         0u32;
+   |         -^^^^
+   |         |
+   |         help: did you mean to return it?: `return`
+
+error: statement with no effect
+  --> $DIR/no_effect_return.rs:23:9
+   |
+LL |         0i32 as C;
+   |         -^^^^^^^^^
+   |         |
+   |         help: did you mean to return it?: `return`
+
+error: statement with no effect
+  --> $DIR/no_effect_return.rs:31:9
+   |
+LL |         0u128;
+   |         ^^^^^^
+
+error: statement with no effect
+  --> $DIR/no_effect_return.rs:40:9
+   |
+LL |         0u16;
+   |         ^^^^^
+
+error: statement with no effect
+  --> $DIR/no_effect_return.rs:47:9
+   |
+LL |         [1u16];
+   |         -^^^^^^
+   |         |
+   |         help: did you mean to return it?: `return`
+
+error: statement with no effect
+  --> $DIR/no_effect_return.rs:54:9
+   |
+LL |         ControlFlow::Break::<()>(());
+   |         -^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |         |
+   |         help: did you mean to return it?: `return`
+
+error: statement with no effect
+  --> $DIR/no_effect_return.rs:70:9
+   |
+LL |         ();
+   |         -^^
+   |         |
+   |         help: did you mean to return it?: `return`
+
+error: statement with no effect
+  --> $DIR/no_effect_return.rs:78:9
+   |
+LL |         ();
+   |         ^^^
+
+error: aborting due to 9 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 74a0c9c62f1f8084175f776577ef39e197680171 Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Tue, 13 Jun 2023 14:05:22 -0500
Subject: [`needless_lifetimes`]' suggestion now points at the lifetimes

---
 clippy_lints/src/lifetimes.rs                      |  15 +-
 tests/ui/crashes/ice-2774.stderr                   |   4 +-
 .../crashes/needless_lifetimes_impl_trait.stderr   |   4 +-
 tests/ui/issue_4266.stderr                         |   8 +-
 tests/ui/needless_lifetimes.stderr                 | 184 ++++++++++-----------
 5 files changed, 114 insertions(+), 101 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lifetimes.rs b/clippy_lints/src/lifetimes.rs
index 7bc901e4e7f..852f6736585 100644
--- a/clippy_lints/src/lifetimes.rs
+++ b/clippy_lints/src/lifetimes.rs
@@ -1,5 +1,6 @@
 use clippy_utils::diagnostics::{span_lint, span_lint_and_then};
 use clippy_utils::trait_ref_of_method;
+use itertools::Itertools;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::nested_filter::{self as hir_nested_filter, NestedFilter};
@@ -201,7 +202,19 @@ fn check_fn_inner<'tcx>(
         span_lint_and_then(
             cx,
             NEEDLESS_LIFETIMES,
-            span.with_hi(sig.decl.output.span().hi()),
+            elidable_lts
+                .iter()
+                .map(|&lt| cx.tcx.def_span(lt))
+                .chain(usages.iter().filter_map(|usage| {
+                    if let LifetimeName::Param(def_id) = usage.res
+                        && elidable_lts.contains(&def_id)
+                    {
+                        return Some(usage.ident.span);
+                    }
+
+                    None
+                }))
+                .collect_vec(),
             &format!("the following explicit lifetimes could be elided: {lts}"),
             |diag| {
                 if sig.header.is_async() {
diff --git a/tests/ui/crashes/ice-2774.stderr b/tests/ui/crashes/ice-2774.stderr
index c5ea0b16d1b..a166ccb3ee8 100644
--- a/tests/ui/crashes/ice-2774.stderr
+++ b/tests/ui/crashes/ice-2774.stderr
@@ -1,8 +1,8 @@
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/ice-2774.rs:15:1
+  --> $DIR/ice-2774.rs:15:28
    |
 LL | pub fn add_barfoos_to_foos<'a>(bars: &HashSet<&'a Bar>) {
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                            ^^                  ^^
    |
    = note: `-D clippy::needless-lifetimes` implied by `-D warnings`
 help: elide the lifetimes
diff --git a/tests/ui/crashes/needless_lifetimes_impl_trait.stderr b/tests/ui/crashes/needless_lifetimes_impl_trait.stderr
index 0b0e0ad2684..37484f5ebd7 100644
--- a/tests/ui/crashes/needless_lifetimes_impl_trait.stderr
+++ b/tests/ui/crashes/needless_lifetimes_impl_trait.stderr
@@ -1,8 +1,8 @@
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes_impl_trait.rs:15:5
+  --> $DIR/needless_lifetimes_impl_trait.rs:15:12
    |
 LL |     fn baz<'a>(&'a self) -> impl Foo + 'a {
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |            ^^   ^^                     ^^
    |
 note: the lint level is defined here
   --> $DIR/needless_lifetimes_impl_trait.rs:1:9
diff --git a/tests/ui/issue_4266.stderr b/tests/ui/issue_4266.stderr
index fd553aa4538..5b60646ef21 100644
--- a/tests/ui/issue_4266.stderr
+++ b/tests/ui/issue_4266.stderr
@@ -1,16 +1,16 @@
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/issue_4266.rs:4:1
+  --> $DIR/issue_4266.rs:4:16
    |
 LL | async fn sink1<'a>(_: &'a str) {} // lint
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                ^^      ^^
    |
    = note: `-D clippy::needless-lifetimes` implied by `-D warnings`
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/issue_4266.rs:8:1
+  --> $DIR/issue_4266.rs:8:21
    |
 LL | async fn one_to_one<'a>(s: &'a str) -> &'a str {
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                     ^^      ^^
 
 error: methods called `new` usually take no `self`
   --> $DIR/issue_4266.rs:28:22
diff --git a/tests/ui/needless_lifetimes.stderr b/tests/ui/needless_lifetimes.stderr
index 86acc4e0046..0da67b600a3 100644
--- a/tests/ui/needless_lifetimes.stderr
+++ b/tests/ui/needless_lifetimes.stderr
@@ -1,8 +1,8 @@
 error: the following explicit lifetimes could be elided: 'a, 'b
-  --> $DIR/needless_lifetimes.rs:18:1
+  --> $DIR/needless_lifetimes.rs:18:23
    |
 LL | fn distinct_lifetimes<'a, 'b>(_x: &'a u8, _y: &'b u8, _z: u8) {}
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                       ^^  ^^       ^^          ^^
    |
    = note: `-D clippy::needless-lifetimes` implied by `-D warnings`
 help: elide the lifetimes
@@ -12,10 +12,10 @@ LL + fn distinct_lifetimes(_x: &u8, _y: &u8, _z: u8) {}
    |
 
 error: the following explicit lifetimes could be elided: 'a, 'b
-  --> $DIR/needless_lifetimes.rs:20:1
+  --> $DIR/needless_lifetimes.rs:20:24
    |
 LL | fn distinct_and_static<'a, 'b>(_x: &'a u8, _y: &'b u8, _z: &'static u8) {}
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                        ^^  ^^       ^^          ^^
    |
 help: elide the lifetimes
    |
@@ -24,10 +24,10 @@ LL + fn distinct_and_static(_x: &u8, _y: &u8, _z: &'static u8) {}
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:30:1
+  --> $DIR/needless_lifetimes.rs:30:15
    |
 LL | fn in_and_out<'a>(x: &'a u8, _y: u8) -> &'a u8 {
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |               ^^      ^^                 ^^
    |
 help: elide the lifetimes
    |
@@ -36,10 +36,10 @@ LL + fn in_and_out(x: &u8, _y: u8) -> &u8 {
    |
 
 error: the following explicit lifetimes could be elided: 'b
-  --> $DIR/needless_lifetimes.rs:42:1
+  --> $DIR/needless_lifetimes.rs:42:31
    |
 LL | fn multiple_in_and_out_2a<'a, 'b>(x: &'a u8, _y: &'b u8) -> &'a u8 {
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                               ^^                  ^^
    |
 help: elide the lifetimes
    |
@@ -48,10 +48,10 @@ LL + fn multiple_in_and_out_2a<'a>(x: &'a u8, _y: &u8) -> &'a u8 {
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:49:1
+  --> $DIR/needless_lifetimes.rs:49:27
    |
 LL | fn multiple_in_and_out_2b<'a, 'b>(_x: &'a u8, y: &'b u8) -> &'b u8 {
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                           ^^           ^^
    |
 help: elide the lifetimes
    |
@@ -60,10 +60,10 @@ LL + fn multiple_in_and_out_2b<'b>(_x: &u8, y: &'b u8) -> &'b u8 {
    |
 
 error: the following explicit lifetimes could be elided: 'b
-  --> $DIR/needless_lifetimes.rs:66:1
+  --> $DIR/needless_lifetimes.rs:66:26
    |
 LL | fn deep_reference_1a<'a, 'b>(x: &'a u8, _y: &'b u8) -> Result<&'a u8, ()> {
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                          ^^                  ^^
    |
 help: elide the lifetimes
    |
@@ -72,10 +72,10 @@ LL + fn deep_reference_1a<'a>(x: &'a u8, _y: &u8) -> Result<&'a u8, ()> {
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:73:1
+  --> $DIR/needless_lifetimes.rs:73:22
    |
 LL | fn deep_reference_1b<'a, 'b>(_x: &'a u8, y: &'b u8) -> Result<&'b u8, ()> {
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                      ^^           ^^
    |
 help: elide the lifetimes
    |
@@ -84,10 +84,10 @@ LL + fn deep_reference_1b<'b>(_x: &u8, y: &'b u8) -> Result<&'b u8, ()> {
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:82:1
+  --> $DIR/needless_lifetimes.rs:82:21
    |
 LL | fn deep_reference_3<'a>(x: &'a u8, _y: u8) -> Result<&'a u8, ()> {
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                     ^^      ^^                        ^^
    |
 help: elide the lifetimes
    |
@@ -96,10 +96,10 @@ LL + fn deep_reference_3(x: &u8, _y: u8) -> Result<&u8, ()> {
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:87:1
+  --> $DIR/needless_lifetimes.rs:87:28
    |
 LL | fn where_clause_without_lt<'a, T>(x: &'a u8, _y: u8) -> Result<&'a u8, ()>
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                            ^^         ^^                        ^^
    |
 help: elide the lifetimes
    |
@@ -108,10 +108,10 @@ LL + fn where_clause_without_lt<T>(x: &u8, _y: u8) -> Result<&u8, ()>
    |
 
 error: the following explicit lifetimes could be elided: 'a, 'b
-  --> $DIR/needless_lifetimes.rs:99:1
+  --> $DIR/needless_lifetimes.rs:99:21
    |
 LL | fn lifetime_param_2<'a, 'b>(_x: Ref<'a>, _y: &'b u8) {}
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                     ^^  ^^          ^^        ^^
    |
 help: elide the lifetimes
    |
@@ -120,10 +120,10 @@ LL + fn lifetime_param_2(_x: Ref<'_>, _y: &u8) {}
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:123:1
+  --> $DIR/needless_lifetimes.rs:123:15
    |
 LL | fn fn_bound_2<'a, F, I>(_m: Lt<'a, I>, _f: F) -> Lt<'a, I>
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |               ^^               ^^                   ^^
    |
 help: elide the lifetimes
    |
@@ -132,10 +132,10 @@ LL + fn fn_bound_2<F, I>(_m: Lt<'_, I>, _f: F) -> Lt<'_, I>
    |
 
 error: the following explicit lifetimes could be elided: 's
-  --> $DIR/needless_lifetimes.rs:153:5
+  --> $DIR/needless_lifetimes.rs:153:21
    |
 LL |     fn self_and_out<'s>(&'s self) -> &'s u8 {
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                     ^^   ^^           ^^
    |
 help: elide the lifetimes
    |
@@ -144,10 +144,10 @@ LL +     fn self_and_out(&self) -> &u8 {
    |
 
 error: the following explicit lifetimes could be elided: 't
-  --> $DIR/needless_lifetimes.rs:160:5
+  --> $DIR/needless_lifetimes.rs:160:30
    |
 LL |     fn self_and_in_out_1<'s, 't>(&'s self, _x: &'t u8) -> &'s u8 {
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                              ^^                 ^^
    |
 help: elide the lifetimes
    |
@@ -156,10 +156,10 @@ LL +     fn self_and_in_out_1<'s>(&'s self, _x: &u8) -> &'s u8 {
    |
 
 error: the following explicit lifetimes could be elided: 's
-  --> $DIR/needless_lifetimes.rs:167:5
+  --> $DIR/needless_lifetimes.rs:167:26
    |
 LL |     fn self_and_in_out_2<'s, 't>(&'s self, x: &'t u8) -> &'t u8 {
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                          ^^       ^^
    |
 help: elide the lifetimes
    |
@@ -168,10 +168,10 @@ LL +     fn self_and_in_out_2<'t>(&self, x: &'t u8) -> &'t u8 {
    |
 
 error: the following explicit lifetimes could be elided: 's, 't
-  --> $DIR/needless_lifetimes.rs:171:5
+  --> $DIR/needless_lifetimes.rs:171:29
    |
 LL |     fn distinct_self_and_in<'s, 't>(&'s self, _x: &'t u8) {}
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                             ^^  ^^   ^^            ^^
    |
 help: elide the lifetimes
    |
@@ -180,10 +180,10 @@ LL +     fn distinct_self_and_in(&self, _x: &u8) {}
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:190:1
+  --> $DIR/needless_lifetimes.rs:190:19
    |
 LL | fn struct_with_lt<'a>(_foo: Foo<'a>) -> &'a str {
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                   ^^            ^^       ^^
    |
 help: elide the lifetimes
    |
@@ -192,10 +192,10 @@ LL + fn struct_with_lt(_foo: Foo<'_>) -> &str {
    |
 
 error: the following explicit lifetimes could be elided: 'b
-  --> $DIR/needless_lifetimes.rs:208:1
+  --> $DIR/needless_lifetimes.rs:208:25
    |
 LL | fn struct_with_lt4a<'a, 'b>(_foo: &'a Foo<'b>) -> &'a str {
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                         ^^                ^^
    |
 help: elide the lifetimes
    |
@@ -204,10 +204,10 @@ LL + fn struct_with_lt4a<'a>(_foo: &'a Foo<'_>) -> &'a str {
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:216:1
+  --> $DIR/needless_lifetimes.rs:216:21
    |
 LL | fn struct_with_lt4b<'a, 'b>(_foo: &'a Foo<'b>) -> &'b str {
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                     ^^             ^^
    |
 help: elide the lifetimes
    |
@@ -216,10 +216,10 @@ LL + fn struct_with_lt4b<'b>(_foo: &Foo<'b>) -> &'b str {
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:231:1
+  --> $DIR/needless_lifetimes.rs:231:22
    |
 LL | fn trait_obj_elided2<'a>(_arg: &'a dyn Drop) -> &'a str {
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                      ^^         ^^               ^^
    |
 help: elide the lifetimes
    |
@@ -228,10 +228,10 @@ LL + fn trait_obj_elided2(_arg: &dyn Drop) -> &str {
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:237:1
+  --> $DIR/needless_lifetimes.rs:237:18
    |
 LL | fn alias_with_lt<'a>(_foo: FooAlias<'a>) -> &'a str {
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                  ^^                 ^^       ^^
    |
 help: elide the lifetimes
    |
@@ -240,10 +240,10 @@ LL + fn alias_with_lt(_foo: FooAlias<'_>) -> &str {
    |
 
 error: the following explicit lifetimes could be elided: 'b
-  --> $DIR/needless_lifetimes.rs:255:1
+  --> $DIR/needless_lifetimes.rs:255:24
    |
 LL | fn alias_with_lt4a<'a, 'b>(_foo: &'a FooAlias<'b>) -> &'a str {
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                        ^^                     ^^
    |
 help: elide the lifetimes
    |
@@ -252,10 +252,10 @@ LL + fn alias_with_lt4a<'a>(_foo: &'a FooAlias<'_>) -> &'a str {
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:263:1
+  --> $DIR/needless_lifetimes.rs:263:20
    |
 LL | fn alias_with_lt4b<'a, 'b>(_foo: &'a FooAlias<'b>) -> &'b str {
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                    ^^             ^^
    |
 help: elide the lifetimes
    |
@@ -264,10 +264,10 @@ LL + fn alias_with_lt4b<'b>(_foo: &FooAlias<'b>) -> &'b str {
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:267:1
+  --> $DIR/needless_lifetimes.rs:267:30
    |
 LL | fn named_input_elided_output<'a>(_arg: &'a str) -> &str {
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                              ^^         ^^          ^
    |
 help: elide the lifetimes
    |
@@ -276,10 +276,10 @@ LL + fn named_input_elided_output(_arg: &str) -> &str {
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:275:1
+  --> $DIR/needless_lifetimes.rs:275:19
    |
 LL | fn trait_bound_ok<'a, T: WithLifetime<'static>>(_: &'a u8, _: T) {
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                   ^^                                ^^
    |
 help: elide the lifetimes
    |
@@ -288,10 +288,10 @@ LL + fn trait_bound_ok<T: WithLifetime<'static>>(_: &u8, _: T) {
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:311:1
+  --> $DIR/needless_lifetimes.rs:311:24
    |
 LL | fn out_return_type_lts<'a>(e: &'a str) -> Cow<'a> {
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                        ^^      ^^             ^^
    |
 help: elide the lifetimes
    |
@@ -300,10 +300,10 @@ LL + fn out_return_type_lts(e: &str) -> Cow<'_> {
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:318:9
+  --> $DIR/needless_lifetimes.rs:318:24
    |
 LL |         fn needless_lt<'a>(x: &'a u8) {}
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                        ^^      ^^
    |
 help: elide the lifetimes
    |
@@ -312,10 +312,10 @@ LL +         fn needless_lt(x: &u8) {}
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:322:9
+  --> $DIR/needless_lifetimes.rs:322:24
    |
 LL |         fn needless_lt<'a>(_x: &'a u8) {}
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                        ^^       ^^
    |
 help: elide the lifetimes
    |
@@ -324,10 +324,10 @@ LL +         fn needless_lt(_x: &u8) {}
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:335:9
+  --> $DIR/needless_lifetimes.rs:335:16
    |
 LL |         fn baz<'a>(&'a self) -> impl Foo + 'a {
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                ^^   ^^                     ^^
    |
 help: elide the lifetimes
    |
@@ -336,10 +336,10 @@ LL +         fn baz(&self) -> impl Foo + '_ {
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:367:5
+  --> $DIR/needless_lifetimes.rs:367:55
    |
 LL |     fn impl_trait_elidable_nested_anonymous_lifetimes<'a>(i: &'a i32, f: impl Fn(&i32) -> &i32) -> &'a i32 {
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                                                       ^^      ^^                                    ^^
    |
 help: elide the lifetimes
    |
@@ -348,10 +348,10 @@ LL +     fn impl_trait_elidable_nested_anonymous_lifetimes(i: &i32, f: impl Fn(&
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:376:5
+  --> $DIR/needless_lifetimes.rs:376:26
    |
 LL |     fn generics_elidable<'a, T: Fn(&i32) -> &i32>(i: &'a i32, f: T) -> &'a i32 {
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                          ^^                           ^^                ^^
    |
 help: elide the lifetimes
    |
@@ -360,10 +360,10 @@ LL +     fn generics_elidable<T: Fn(&i32) -> &i32>(i: &i32, f: T) -> &i32 {
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:388:5
+  --> $DIR/needless_lifetimes.rs:388:32
    |
 LL |     fn where_clause_elidadable<'a, T>(i: &'a i32, f: T) -> &'a i32
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                                ^^         ^^                ^^
    |
 help: elide the lifetimes
    |
@@ -372,10 +372,10 @@ LL +     fn where_clause_elidadable<T>(i: &i32, f: T) -> &i32
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:403:5
+  --> $DIR/needless_lifetimes.rs:403:28
    |
 LL |     fn pointer_fn_elidable<'a>(i: &'a i32, f: fn(&i32) -> &i32) -> &'a i32 {
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                            ^^      ^^                               ^^
    |
 help: elide the lifetimes
    |
@@ -384,10 +384,10 @@ LL +     fn pointer_fn_elidable(i: &i32, f: fn(&i32) -> &i32) -> &i32 {
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:416:5
+  --> $DIR/needless_lifetimes.rs:416:28
    |
 LL |     fn nested_fn_pointer_3<'a>(_: &'a i32) -> fn(fn(&i32) -> &i32) -> i32 {
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                            ^^      ^^
    |
 help: elide the lifetimes
    |
@@ -396,10 +396,10 @@ LL +     fn nested_fn_pointer_3(_: &i32) -> fn(fn(&i32) -> &i32) -> i32 {
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:419:5
+  --> $DIR/needless_lifetimes.rs:419:28
    |
 LL |     fn nested_fn_pointer_4<'a>(_: &'a i32) -> impl Fn(fn(&i32)) {
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                            ^^      ^^
    |
 help: elide the lifetimes
    |
@@ -408,10 +408,10 @@ LL +     fn nested_fn_pointer_4(_: &i32) -> impl Fn(fn(&i32)) {
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:441:9
+  --> $DIR/needless_lifetimes.rs:441:21
    |
 LL |         fn implicit<'a>(&'a self) -> &'a () {
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                     ^^   ^^           ^^
    |
 help: elide the lifetimes
    |
@@ -420,10 +420,10 @@ LL +         fn implicit(&self) -> &() {
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:444:9
+  --> $DIR/needless_lifetimes.rs:444:25
    |
 LL |         fn implicit_mut<'a>(&'a mut self) -> &'a () {
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                         ^^   ^^               ^^
    |
 help: elide the lifetimes
    |
@@ -432,10 +432,10 @@ LL +         fn implicit_mut(&mut self) -> &() {
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:455:9
+  --> $DIR/needless_lifetimes.rs:455:31
    |
 LL |         fn lifetime_elsewhere<'a>(self: Box<Self>, here: &'a ()) -> &'a () {
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                               ^^                          ^^         ^^
    |
 help: elide the lifetimes
    |
@@ -444,10 +444,10 @@ LL +         fn lifetime_elsewhere(self: Box<Self>, here: &()) -> &() {
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:461:9
+  --> $DIR/needless_lifetimes.rs:461:21
    |
 LL |         fn implicit<'a>(&'a self) -> &'a ();
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                     ^^   ^^           ^^
    |
 help: elide the lifetimes
    |
@@ -456,10 +456,10 @@ LL +         fn implicit(&self) -> &();
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:462:9
+  --> $DIR/needless_lifetimes.rs:462:30
    |
 LL |         fn implicit_provided<'a>(&'a self) -> &'a () {
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                              ^^   ^^           ^^
    |
 help: elide the lifetimes
    |
@@ -468,10 +468,10 @@ LL +         fn implicit_provided(&self) -> &() {
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:471:9
+  --> $DIR/needless_lifetimes.rs:471:31
    |
 LL |         fn lifetime_elsewhere<'a>(self: Box<Self>, here: &'a ()) -> &'a ();
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                               ^^                          ^^         ^^
    |
 help: elide the lifetimes
    |
@@ -480,10 +480,10 @@ LL +         fn lifetime_elsewhere(self: Box<Self>, here: &()) -> &();
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:472:9
+  --> $DIR/needless_lifetimes.rs:472:40
    |
 LL |         fn lifetime_elsewhere_provided<'a>(self: Box<Self>, here: &'a ()) -> &'a () {
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                                        ^^                          ^^         ^^
    |
 help: elide the lifetimes
    |
@@ -492,10 +492,10 @@ LL +         fn lifetime_elsewhere_provided(self: Box<Self>, here: &()) -> &() {
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:481:5
+  --> $DIR/needless_lifetimes.rs:481:12
    |
 LL |     fn foo<'a>(x: &'a u8, y: &'_ u8) {}
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |            ^^      ^^
    |
 help: elide the lifetimes
    |
@@ -504,10 +504,10 @@ LL +     fn foo(x: &u8, y: &'_ u8) {}
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:483:5
+  --> $DIR/needless_lifetimes.rs:483:12
    |
 LL |     fn bar<'a>(x: &'a u8, y: &'_ u8, z: &'_ u8) {}
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |            ^^      ^^
    |
 help: elide the lifetimes
    |
@@ -516,10 +516,10 @@ LL +     fn bar(x: &u8, y: &'_ u8, z: &'_ u8) {}
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:490:5
+  --> $DIR/needless_lifetimes.rs:490:18
    |
 LL |     fn one_input<'a>(x: &'a u8) -> &'a u8 {
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                  ^^      ^^         ^^
    |
 help: elide the lifetimes
    |
@@ -528,10 +528,10 @@ LL +     fn one_input(x: &u8) -> &u8 {
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:495:5
+  --> $DIR/needless_lifetimes.rs:495:42
    |
 LL |     fn multiple_inputs_output_not_elided<'a, 'b>(x: &'a u8, y: &'b u8, z: &'b u8) -> &'b u8 {
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                                          ^^          ^^
    |
 help: elide the lifetimes
    |
@@ -540,10 +540,10 @@ LL +     fn multiple_inputs_output_not_elided<'b>(x: &u8, y: &'b u8, z: &'b u8)
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> $DIR/needless_lifetimes.rs:511:9
+  --> $DIR/needless_lifetimes.rs:511:22
    |
 LL |         fn one_input<'a>(x: &'a u8) -> &'a u8 {
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                      ^^      ^^         ^^
    |
    = note: this error originates in the macro `__inline_mac_mod_in_macro` (in Nightly builds, run with -Z macro-backtrace for more info)
 help: elide the lifetimes
-- 
cgit 1.4.1-3-g733a5


From d2725402a9e2c753858e221f3e871c7dd9cb7242 Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Tue, 13 Jun 2023 14:55:54 -0500
Subject: [`borrow_as_ptr`]: Ignore temporaries

---
 clippy_lints/src/casts/borrow_as_ptr.rs | 8 +++++++-
 tests/ui/borrow_as_ptr.fixed            | 9 +++++++++
 tests/ui/borrow_as_ptr.rs               | 9 +++++++++
 tests/ui/borrow_as_ptr.stderr           | 4 ++--
 4 files changed, 27 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/borrow_as_ptr.rs b/clippy_lints/src/casts/borrow_as_ptr.rs
index 294d22d34de..e93f2765337 100644
--- a/clippy_lints/src/casts/borrow_as_ptr.rs
+++ b/clippy_lints/src/casts/borrow_as_ptr.rs
@@ -1,6 +1,8 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
+use std::ops::ControlFlow;
+
 use clippy_utils::is_no_std_crate;
 use clippy_utils::source::snippet_with_context;
+use clippy_utils::{diagnostics::span_lint_and_sugg, visitors::for_each_unconsumed_temporary};
 use rustc_errors::Applicability;
 use rustc_hir::{BorrowKind, Expr, ExprKind, Mutability, Ty, TyKind};
 use rustc_lint::LateContext;
@@ -23,6 +25,10 @@ pub(super) fn check<'tcx>(
         };
         let mut app = Applicability::MachineApplicable;
         let snip = snippet_with_context(cx, e.span, cast_expr.span.ctxt(), "..", &mut app).0;
+        // Fix #9884
+        if for_each_unconsumed_temporary(cx, expr, |_| ControlFlow::Break(true)).is_break() {
+            return;
+        }
 
         span_lint_and_sugg(
             cx,
diff --git a/tests/ui/borrow_as_ptr.fixed b/tests/ui/borrow_as_ptr.fixed
index 3f440ce0045..996cc3650ff 100644
--- a/tests/ui/borrow_as_ptr.fixed
+++ b/tests/ui/borrow_as_ptr.fixed
@@ -1,9 +1,18 @@
 //@run-rustfix
 #![warn(clippy::borrow_as_ptr)]
+#![allow(clippy::useless_vec)]
+
+fn a() -> i32 {
+    0
+}
 
 fn main() {
     let val = 1;
     let _p = std::ptr::addr_of!(val);
+    let _p = &0 as *const i32;
+    let _p = &a() as *const i32;
+    let vec = vec![1];
+    let _p = &vec.len() as *const usize;
 
     let mut val_mut = 1;
     let _p_mut = std::ptr::addr_of_mut!(val_mut);
diff --git a/tests/ui/borrow_as_ptr.rs b/tests/ui/borrow_as_ptr.rs
index c1ca9180eef..5eafaeb2fc3 100644
--- a/tests/ui/borrow_as_ptr.rs
+++ b/tests/ui/borrow_as_ptr.rs
@@ -1,9 +1,18 @@
 //@run-rustfix
 #![warn(clippy::borrow_as_ptr)]
+#![allow(clippy::useless_vec)]
+
+fn a() -> i32 {
+    0
+}
 
 fn main() {
     let val = 1;
     let _p = &val as *const i32;
+    let _p = &0 as *const i32;
+    let _p = &a() as *const i32;
+    let vec = vec![1];
+    let _p = &vec.len() as *const usize;
 
     let mut val_mut = 1;
     let _p_mut = &mut val_mut as *mut i32;
diff --git a/tests/ui/borrow_as_ptr.stderr b/tests/ui/borrow_as_ptr.stderr
index be1ed733056..c9990bb6f22 100644
--- a/tests/ui/borrow_as_ptr.stderr
+++ b/tests/ui/borrow_as_ptr.stderr
@@ -1,5 +1,5 @@
 error: borrow as raw pointer
-  --> $DIR/borrow_as_ptr.rs:6:14
+  --> $DIR/borrow_as_ptr.rs:11:14
    |
 LL |     let _p = &val as *const i32;
    |              ^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::addr_of!(val)`
@@ -7,7 +7,7 @@ LL |     let _p = &val as *const i32;
    = note: `-D clippy::borrow-as-ptr` implied by `-D warnings`
 
 error: borrow as raw pointer
-  --> $DIR/borrow_as_ptr.rs:9:18
+  --> $DIR/borrow_as_ptr.rs:18:18
    |
 LL |     let _p_mut = &mut val_mut as *mut i32;
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::addr_of_mut!(val_mut)`
-- 
cgit 1.4.1-3-g733a5


From 062b2099044ed1d65f6100d0d0ca8cd76102246e Mon Sep 17 00:00:00 2001
From: Kisaragi Marine <kisaragi.effective@gmail.com>
Date: Wed, 14 Jun 2023 12:23:02 +0900
Subject: Ignore `main()` in `no_test` code fences

---
 clippy_lints/src/doc.rs               |  5 ++++-
 tests/ui/doc/needless_doctest_main.rs | 19 +++++++++++++++++++
 2 files changed, 23 insertions(+), 1 deletion(-)
 create mode 100644 tests/ui/doc/needless_doctest_main.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/doc.rs b/clippy_lints/src/doc.rs
index 384aca7fead..0617c3ea5e9 100644
--- a/clippy_lints/src/doc.rs
+++ b/clippy_lints/src/doc.rs
@@ -571,6 +571,7 @@ fn check_doc<'a, Events: Iterator<Item = (pulldown_cmark::Event<'a>, Range<usize
     let mut in_link = None;
     let mut in_heading = false;
     let mut is_rust = false;
+    let mut no_test = false;
     let mut edition = None;
     let mut ticks_unbalanced = false;
     let mut text_to_check: Vec<(CowStr<'_>, Span)> = Vec::new();
@@ -584,6 +585,8 @@ fn check_doc<'a, Events: Iterator<Item = (pulldown_cmark::Event<'a>, Range<usize
                         if item == "ignore" {
                             is_rust = false;
                             break;
+                        } else if item == "no_test" {
+                            no_test = true;
                         }
                         if let Some(stripped) = item.strip_prefix("edition") {
                             is_rust = true;
@@ -648,7 +651,7 @@ fn check_doc<'a, Events: Iterator<Item = (pulldown_cmark::Event<'a>, Range<usize
                 headers.errors |= in_heading && trimmed_text == "Errors";
                 headers.panics |= in_heading && trimmed_text == "Panics";
                 if in_code {
-                    if is_rust {
+                    if is_rust && !no_test {
                         let edition = edition.unwrap_or_else(|| cx.tcx.sess.edition());
                         check_code(cx, &text, edition, span);
                     }
diff --git a/tests/ui/doc/needless_doctest_main.rs b/tests/ui/doc/needless_doctest_main.rs
new file mode 100644
index 00000000000..fb32aac9449
--- /dev/null
+++ b/tests/ui/doc/needless_doctest_main.rs
@@ -0,0 +1,19 @@
+#![warn(clippy::needless_doctest_main)]
+//! issue 10491:
+//! ```rust,no_test
+//! use std::collections::HashMap;
+//!
+//! fn main() {
+//!     let mut m = HashMap::new();
+//!     m.insert(1u32, 2u32);
+//! }
+//! ```
+//!
+
+/// some description here
+/// ```rust,no_test
+/// fn main() {
+///     foo()
+/// }
+/// ```
+fn foo() {}
-- 
cgit 1.4.1-3-g733a5


From 72aa180798d9444ff3968ac51fad6da0ca28a7a0 Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Wed, 14 Jun 2023 06:56:38 -0500
Subject: use rustc's criteria for a temporary

---
 clippy_lints/src/casts/borrow_as_ptr.rs | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/borrow_as_ptr.rs b/clippy_lints/src/casts/borrow_as_ptr.rs
index e93f2765337..b7256dd2eae 100644
--- a/clippy_lints/src/casts/borrow_as_ptr.rs
+++ b/clippy_lints/src/casts/borrow_as_ptr.rs
@@ -1,11 +1,10 @@
-use std::ops::ControlFlow;
-
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::is_no_std_crate;
 use clippy_utils::source::snippet_with_context;
-use clippy_utils::{diagnostics::span_lint_and_sugg, visitors::for_each_unconsumed_temporary};
 use rustc_errors::Applicability;
 use rustc_hir::{BorrowKind, Expr, ExprKind, Mutability, Ty, TyKind};
 use rustc_lint::LateContext;
+use rustc_middle::ty::adjustment::Adjust;
 
 use super::BORROW_AS_PTR;
 
@@ -26,7 +25,12 @@ pub(super) fn check<'tcx>(
         let mut app = Applicability::MachineApplicable;
         let snip = snippet_with_context(cx, e.span, cast_expr.span.ctxt(), "..", &mut app).0;
         // Fix #9884
-        if for_each_unconsumed_temporary(cx, expr, |_| ControlFlow::Break(true)).is_break() {
+        if !e.is_place_expr(|base| {
+            cx.typeck_results()
+                .adjustments()
+                .get(base.hir_id)
+                .is_some_and(|x| x.iter().any(|adj| matches!(adj.kind, Adjust::Deref(_))))
+        }) {
             return;
         }
 
-- 
cgit 1.4.1-3-g733a5


From 79f93a655a9a3849c0653a72a5b547776a1522b3 Mon Sep 17 00:00:00 2001
From: Kisaragi Marine <kisaragi.effective@gmail.com>
Date: Wed, 14 Jun 2023 22:07:31 +0900
Subject: missing_panics_doc: pickup expect method

---
 clippy_lints/src/doc.rs            |  4 ++--
 tests/ui/doc/missing_panics_doc.rs | 31 +++++++++++++++++++++++++++++++
 2 files changed, 33 insertions(+), 2 deletions(-)
 create mode 100644 tests/ui/doc/missing_panics_doc.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/doc.rs b/clippy_lints/src/doc.rs
index 0617c3ea5e9..11de7e60697 100644
--- a/clippy_lints/src/doc.rs
+++ b/clippy_lints/src/doc.rs
@@ -916,8 +916,8 @@ impl<'a, 'tcx> Visitor<'tcx> for FindPanicUnwrap<'a, 'tcx> {
             }
         }
 
-        // check for `unwrap`
-        if let Some(arglists) = method_chain_args(expr, &["unwrap"]) {
+        // check for `unwrap` and `expect` both `Option` and `Result`
+        if let Some(arglists) = method_chain_args(expr, &["unwrap"]).or(method_chain_args(expr, &["expect"])) {
             let receiver_ty = self.typeck_results.expr_ty(arglists[0].0).peel_refs();
             if is_type_diagnostic_item(self.cx, receiver_ty, sym::Option)
                 || is_type_diagnostic_item(self.cx, receiver_ty, sym::Result)
diff --git a/tests/ui/doc/missing_panics_doc.rs b/tests/ui/doc/missing_panics_doc.rs
new file mode 100644
index 00000000000..5cb8a9691f4
--- /dev/null
+++ b/tests/ui/doc/missing_panics_doc.rs
@@ -0,0 +1,31 @@
+#![warn(clippy::missing_panics_doc)]
+
+pub fn option_unwrap<T>(v: &[T]) -> &T {
+    let o: Option<&T> = v.last();
+    o.unwrap()
+}
+
+pub fn option_expect<T>(v: &[T]) -> &T {
+    let o: Option<&T> = v.last();
+    o.expect("passed an empty thing")
+}
+
+pub fn result_unwrap<T>(v: &[T]) -> &T {
+    let res: Result<&T, &str> = v.last().ok_or("oh noes");
+    res.unwrap()
+}
+
+pub fn result_expect<T>(v: &[T]) -> &T {
+    let res: Result<&T, &str> = v.last().ok_or("oh noes");
+    res.expect("passed an empty thing")
+}
+
+pub fn last_unwrap(v: &[u32]) -> u32 {
+    *v.last().unwrap()
+}
+
+pub fn last_expect(v: &[u32]) -> u32 {
+    *v.last().expect("passed an empty thing")
+}
+
+fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 27a701a670c5e14b632e205a818d8e32ffdcda44 Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Tue, 13 Jun 2023 13:08:03 -0500
Subject: [`match_same_arms`]: don't lint if `non_exhaustive_omitted_patterns`

formatting :/
---
 clippy_lints/src/matches/match_same_arms.rs    | 29 +++++++------
 clippy_lints/src/matches/mod.rs                |  3 ++
 tests/ui/match_same_arms_non_exhaustive.rs     | 58 ++++++++++++++++++++++++++
 tests/ui/match_same_arms_non_exhaustive.stderr | 29 +++++++++++++
 4 files changed, 107 insertions(+), 12 deletions(-)
 create mode 100644 tests/ui/match_same_arms_non_exhaustive.rs
 create mode 100644 tests/ui/match_same_arms_non_exhaustive.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/match_same_arms.rs b/clippy_lints/src/matches/match_same_arms.rs
index ae8262ace96..3d2fbea63f5 100644
--- a/clippy_lints/src/matches/match_same_arms.rs
+++ b/clippy_lints/src/matches/match_same_arms.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet;
-use clippy_utils::{path_to_local, search_same, SpanlessEq, SpanlessHash};
+use clippy_utils::{is_lint_allowed, path_to_local, search_same, SpanlessEq, SpanlessHash};
 use core::cmp::Ordering;
 use core::iter;
 use core::slice;
@@ -9,6 +9,7 @@ use rustc_ast::ast::LitKind;
 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_middle::ty;
 use rustc_span::Symbol;
@@ -103,17 +104,21 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>]) {
     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) {
-            span_lint_and_then(
-                cx,
-                MATCH_SAME_ARMS,
-                arm1.span,
-                "this match arm has an identical body to the `_` wildcard arm",
-                |diag| {
-                    diag.span_suggestion(arm1.span, "try removing the arm", "", Applicability::MaybeIncorrect)
-                        .help("or try changing either arm body")
-                        .span_note(arm2.span, "`_` wildcard arm here");
-                },
-            );
+            if !cx.tcx.features().non_exhaustive_omitted_patterns_lint
+                || is_lint_allowed(cx, NON_EXHAUSTIVE_OMITTED_PATTERNS, arm2.hir_id)
+            {
+                span_lint_and_then(
+                    cx,
+                    MATCH_SAME_ARMS,
+                    arm1.span,
+                    "this match arm has an identical body to the `_` wildcard arm",
+                    |diag| {
+                        diag.span_suggestion(arm1.span, "try removing the arm", "", Applicability::MaybeIncorrect)
+                            .help("or try changing either arm body")
+                            .span_note(arm2.span, "`_` wildcard arm here");
+                    },
+                );
+            }
         } else {
             let back_block = backwards_blocking_idxs[j];
             let (keep_arm, move_arm) = if back_block < i || (back_block == 0 && forwards_blocking_idxs[i] <= j) {
diff --git a/clippy_lints/src/matches/mod.rs b/clippy_lints/src/matches/mod.rs
index 2d27be499f9..3fbd0867ea9 100644
--- a/clippy_lints/src/matches/mod.rs
+++ b/clippy_lints/src/matches/mod.rs
@@ -559,6 +559,9 @@ declare_clippy_lint! {
     /// ### What it does
     /// Checks for `match` with identical arm bodies.
     ///
+    /// Note: Does not lint on wildcards if the `non_exhaustive_omitted_patterns_lint` feature is
+    /// enabled and disallowed.
+    ///
     /// ### Why is this bad?
     /// This is probably a copy & paste error. If arm bodies
     /// are the same on purpose, you can factor them
diff --git a/tests/ui/match_same_arms_non_exhaustive.rs b/tests/ui/match_same_arms_non_exhaustive.rs
new file mode 100644
index 00000000000..07421173a33
--- /dev/null
+++ b/tests/ui/match_same_arms_non_exhaustive.rs
@@ -0,0 +1,58 @@
+#![feature(non_exhaustive_omitted_patterns_lint)]
+#![warn(clippy::match_same_arms)]
+#![no_main]
+
+use std::sync::atomic::Ordering; // #[non_exhaustive] enum
+
+pub fn f(x: Ordering) {
+    match x {
+        Ordering::Relaxed => println!("relaxed"),
+        Ordering::Release => println!("release"),
+        Ordering::Acquire => println!("acquire"),
+        Ordering::AcqRel | Ordering::SeqCst => panic!(),
+        #[deny(non_exhaustive_omitted_patterns)]
+        _ => panic!(),
+    }
+}
+
+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 => panic!(),
+            _ => panic!(),
+        }
+    }
+}
+
+// Below should still lint
+
+pub fn g(x: Ordering) {
+    match x {
+        Ordering::Relaxed => println!("relaxed"),
+        Ordering::Release => println!("release"),
+        Ordering::Acquire => println!("acquire"),
+        Ordering::AcqRel | Ordering::SeqCst => panic!(),
+        _ => panic!(),
+    }
+}
+
+mod g {
+    use super::*;
+
+    pub fn g(x: Ordering) {
+        match x {
+            Ordering::Relaxed => println!("relaxed"),
+            Ordering::Release => println!("release"),
+            Ordering::Acquire => println!("acquire"),
+            Ordering::AcqRel | Ordering::SeqCst => panic!(),
+            _ => panic!(),
+        }
+    }
+}
diff --git a/tests/ui/match_same_arms_non_exhaustive.stderr b/tests/ui/match_same_arms_non_exhaustive.stderr
new file mode 100644
index 00000000000..088f7d5c062
--- /dev/null
+++ b/tests/ui/match_same_arms_non_exhaustive.stderr
@@ -0,0 +1,29 @@
+error: this match arm has an identical body to the `_` wildcard arm
+  --> $DIR/match_same_arms_non_exhaustive.rs:41:9
+   |
+LL |         Ordering::AcqRel | Ordering::SeqCst => panic!(),
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try removing the arm
+   |
+   = help: or try changing either arm body
+note: `_` wildcard arm here
+  --> $DIR/match_same_arms_non_exhaustive.rs:42:9
+   |
+LL |         _ => panic!(),
+   |         ^^^^^^^^^^^^^
+   = note: `-D clippy::match-same-arms` implied by `-D warnings`
+
+error: this match arm has an identical body to the `_` wildcard arm
+  --> $DIR/match_same_arms_non_exhaustive.rs:54:13
+   |
+LL |             Ordering::AcqRel | Ordering::SeqCst => panic!(),
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try removing the arm
+   |
+   = help: or try changing either arm body
+note: `_` wildcard arm here
+  --> $DIR/match_same_arms_non_exhaustive.rs:55:13
+   |
+LL |             _ => panic!(),
+   |             ^^^^^^^^^^^^^
+
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 830d307d0a4b0bb584bf3552fcbf0e2dc2575aec Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Mon, 12 Jun 2023 12:55:31 -0500
Subject: refactor a bit

---
 clippy_lints/src/single_range_in_vec_init.rs | 38 ++++++++++++----------------
 tests/ui/single_range_in_vec_init.stderr     | 20 +++++++--------
 2 files changed, 26 insertions(+), 32 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/single_range_in_vec_init.rs b/clippy_lints/src/single_range_in_vec_init.rs
index 2d3f18a62c0..dfe8be7a6a6 100644
--- a/clippy_lints/src/single_range_in_vec_init.rs
+++ b/clippy_lints/src/single_range_in_vec_init.rs
@@ -1,10 +1,6 @@
 use clippy_utils::{
-    diagnostics::span_lint_and_then,
-    get_trait_def_id,
-    higher::VecArgs,
-    macros::root_macro_call_first_node,
-    source::{snippet_opt, snippet_with_applicability},
-    ty::implements_trait,
+    diagnostics::span_lint_and_then, get_trait_def_id, higher::VecArgs, macros::root_macro_call_first_node,
+    source::snippet_opt, ty::implements_trait,
 };
 use rustc_ast::{LitIntType, LitKind, UintTy};
 use rustc_errors::Applicability;
@@ -18,9 +14,9 @@ declare_clippy_lint! {
     /// Checks for `Vec` or array initializations that contain only one range.
     ///
     /// ### Why is this bad?
-    /// This is almost always incorrect, as it will result in a `Vec` that has only element. Almost
-    /// always, the programmer intended for it to include all elements in the range or for the end
-    /// of the range to be the length instead.
+    /// This is almost always incorrect, as it will result in a `Vec` that has only one element.
+    /// Almost always, the programmer intended for it to include all elements in the range or for
+    /// the end of the range to be the length instead.
     ///
     /// ### Example
     /// ```rust
@@ -75,8 +71,8 @@ impl LateLintPass<'_> for SingleRangeInVecInit {
         //                   ^^^^^^       ^^^^^^^
         // span: `vec![0..200]` or `[0..200]`
         //        ^^^^^^^^^^^^      ^^^^^^^^
-        // kind: What to print, an array or a `Vec`
-        let (inner_expr, span, kind) = if let ExprKind::Array([inner_expr]) = expr.kind
+        // suggested_type: What to print, "an array" or "a `Vec`"
+        let (inner_expr, span, suggested_type) = if let ExprKind::Array([inner_expr]) = expr.kind
             && !expr.span.from_expansion()
         {
             (inner_expr, expr.span, SuggestedType::Array)
@@ -96,13 +92,11 @@ impl LateLintPass<'_> for SingleRangeInVecInit {
             && let ty = cx.typeck_results().expr_ty(start.expr)
             && let Some(snippet) = snippet_opt(cx, span)
             // `is_from_proc_macro` will skip any `vec![]`. Let's not!
-            && snippet.starts_with(kind.starts_with())
-            && snippet.ends_with(kind.ends_with())
+            && snippet.starts_with(suggested_type.starts_with())
+            && snippet.ends_with(suggested_type.ends_with())
+            && let Some(start_snippet) = snippet_opt(cx, start.span)
+            && let Some(end_snippet) = snippet_opt(cx, end.span)
         {
-            let mut app = Applicability::MaybeIncorrect;
-            let start_snippet = snippet_with_applicability(cx, start.span, "...", &mut app);
-            let end_snippet = snippet_with_applicability(cx, end.span, "...", &mut app);
-
             let should_emit_every_value = if let Some(step_def_id) = get_trait_def_id(cx, &["core", "iter", "Step"])
                 && implements_trait(cx, ty, step_def_id, &[])
             {
@@ -126,23 +120,23 @@ impl LateLintPass<'_> for SingleRangeInVecInit {
                     cx,
                     SINGLE_RANGE_IN_VEC_INIT,
                     span,
-                    &format!("{kind} of `Range` that is only one element"),
+                    &format!("{suggested_type} of `Range` that is only one element"),
                     |diag| {
                         if should_emit_every_value {
                             diag.span_suggestion(
                                 span,
-                                "if you wanted a `Vec` that contains every value in the range, try",
+                                "if you wanted a `Vec` that contains the entire range, try",
                                 format!("({start_snippet}..{end_snippet}).collect::<std::vec::Vec<{ty}>>()"),
-                                app,
+                                Applicability::MaybeIncorrect,
                             );
                         }
 
                         if should_emit_of_len {
                             diag.span_suggestion(
                                 inner_expr.span,
-                                format!("if you wanted {kind} of len {end_snippet}, try"),
+                                format!("if you wanted {suggested_type} of len {end_snippet}, try"),
                                 format!("{start_snippet}; {end_snippet}"),
-                                app,
+                                Applicability::MaybeIncorrect,
                             );
                         }
                     },
diff --git a/tests/ui/single_range_in_vec_init.stderr b/tests/ui/single_range_in_vec_init.stderr
index fc03b2205e2..3e3d521f4a5 100644
--- a/tests/ui/single_range_in_vec_init.stderr
+++ b/tests/ui/single_range_in_vec_init.stderr
@@ -5,7 +5,7 @@ LL |     [0..200];
    |     ^^^^^^^^
    |
    = note: `-D clippy::single-range-in-vec-init` implied by `-D warnings`
-help: if you wanted a `Vec` that contains every value in the range, try
+help: if you wanted a `Vec` that contains the entire range, try
    |
 LL |     (0..200).collect::<std::vec::Vec<i32>>();
    |     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -20,7 +20,7 @@ error: a `Vec` of `Range` that is only one element
 LL |     vec![0..200];
    |     ^^^^^^^^^^^^
    |
-help: if you wanted a `Vec` that contains every value in the range, try
+help: if you wanted a `Vec` that contains the entire range, try
    |
 LL |     (0..200).collect::<std::vec::Vec<i32>>();
    |     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -35,7 +35,7 @@ error: an array of `Range` that is only one element
 LL |     [0u8..200];
    |     ^^^^^^^^^^
    |
-help: if you wanted a `Vec` that contains every value in the range, try
+help: if you wanted a `Vec` that contains the entire range, try
    |
 LL |     (0u8..200).collect::<std::vec::Vec<u8>>();
    |     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -50,7 +50,7 @@ error: an array of `Range` that is only one element
 LL |     [0usize..200];
    |     ^^^^^^^^^^^^^
    |
-help: if you wanted a `Vec` that contains every value in the range, try
+help: if you wanted a `Vec` that contains the entire range, try
    |
 LL |     (0usize..200).collect::<std::vec::Vec<usize>>();
    |     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -65,7 +65,7 @@ error: an array of `Range` that is only one element
 LL |     [0..200usize];
    |     ^^^^^^^^^^^^^
    |
-help: if you wanted a `Vec` that contains every value in the range, try
+help: if you wanted a `Vec` that contains the entire range, try
    |
 LL |     (0..200usize).collect::<std::vec::Vec<usize>>();
    |     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -80,7 +80,7 @@ error: a `Vec` of `Range` that is only one element
 LL |     vec![0u8..200];
    |     ^^^^^^^^^^^^^^
    |
-help: if you wanted a `Vec` that contains every value in the range, try
+help: if you wanted a `Vec` that contains the entire range, try
    |
 LL |     (0u8..200).collect::<std::vec::Vec<u8>>();
    |     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -95,7 +95,7 @@ error: a `Vec` of `Range` that is only one element
 LL |     vec![0usize..200];
    |     ^^^^^^^^^^^^^^^^^
    |
-help: if you wanted a `Vec` that contains every value in the range, try
+help: if you wanted a `Vec` that contains the entire range, try
    |
 LL |     (0usize..200).collect::<std::vec::Vec<usize>>();
    |     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -110,7 +110,7 @@ error: a `Vec` of `Range` that is only one element
 LL |     vec![0..200usize];
    |     ^^^^^^^^^^^^^^^^^
    |
-help: if you wanted a `Vec` that contains every value in the range, try
+help: if you wanted a `Vec` that contains the entire range, try
    |
 LL |     (0..200usize).collect::<std::vec::Vec<usize>>();
    |     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -125,7 +125,7 @@ error: an array of `Range` that is only one element
 LL |     [0..200isize];
    |     ^^^^^^^^^^^^^
    |
-help: if you wanted a `Vec` that contains every value in the range, try
+help: if you wanted a `Vec` that contains the entire range, try
    |
 LL |     (0..200isize).collect::<std::vec::Vec<isize>>();
    |     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -136,7 +136,7 @@ error: a `Vec` of `Range` that is only one element
 LL |     vec![0..200isize];
    |     ^^^^^^^^^^^^^^^^^
    |
-help: if you wanted a `Vec` that contains every value in the range, try
+help: if you wanted a `Vec` that contains the entire range, try
    |
 LL |     (0..200isize).collect::<std::vec::Vec<isize>>();
    |     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-- 
cgit 1.4.1-3-g733a5


From 2ba192695527b1633f63396b3e12bbbdf7b19fef Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Wed, 14 Jun 2023 16:52:02 +0200
Subject: [`derivable_impls`]: don't lint if expr unsize-coerces

---
 clippy_lints/src/derivable_impls.rs | 38 ++++++++++++++++++++++++++++++++-----
 tests/ui/derivable_impls.fixed      | 21 ++++++++++++++++++++
 tests/ui/derivable_impls.rs         | 21 ++++++++++++++++++++
 3 files changed, 75 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/derivable_impls.rs b/clippy_lints/src/derivable_impls.rs
index 8f68f90a2a1..618214f4aa2 100644
--- a/clippy_lints/src/derivable_impls.rs
+++ b/clippy_lints/src/derivable_impls.rs
@@ -8,7 +8,8 @@ use rustc_hir::{
     Body, Expr, ExprKind, GenericArg, Impl, ImplItemKind, Item, ItemKind, Node, PathSegment, QPath, Ty, TyKind,
 };
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty::{Adt, AdtDef, SubstsRef};
+use rustc_middle::ty::adjustment::{Adjust, PointerCast};
+use rustc_middle::ty::{self, Adt, AdtDef, SubstsRef, TypeckResults};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::sym;
 
@@ -75,6 +76,19 @@ fn is_path_self(e: &Expr<'_>) -> bool {
     }
 }
 
+fn contains_trait_object(cx: &LateContext<'_>, ty: ty::Ty<'_>) -> bool {
+    match ty.kind() {
+        ty::TyKind::Ref(_, ty, _) => {
+            contains_trait_object(cx, *ty)
+        },
+        ty::TyKind::Adt(def, substs) => {
+            def.is_box() && substs[0].as_type().map_or(false, |ty| contains_trait_object(cx, ty))
+        }
+        ty::TyKind::Dynamic(..) => true,
+        _ => false,
+    }
+}
+
 fn check_struct<'tcx>(
     cx: &LateContext<'tcx>,
     item: &'tcx Item<'_>,
@@ -82,6 +96,7 @@ fn check_struct<'tcx>(
     func_expr: &Expr<'_>,
     adt_def: AdtDef<'_>,
     substs: SubstsRef<'_>,
+    typeck_results: &'tcx TypeckResults<'tcx>,
 ) {
     if let TyKind::Path(QPath::Resolved(_, p)) = self_ty.kind {
         if let Some(PathSegment { args, .. }) = p.segments.last() {
@@ -96,10 +111,23 @@ fn check_struct<'tcx>(
             }
         }
     }
+
+    // the default() call might unsize coerce to a trait object (e.g. Box<T> to Box<dyn Trait>),
+    // which would not be the same if derived (see #10158).
+    // this closure checks both if the expr is equivalent to a `default()` call and does not
+    // have such coercions.
+    let is_default_without_adjusts = |expr| {
+        is_default_equivalent(cx, expr)
+            && typeck_results.expr_adjustments(expr).iter().all(|adj| {
+                !matches!(adj.kind, Adjust::Pointer(PointerCast::Unsize) 
+                    if contains_trait_object(cx, adj.target))
+            })
+    };
+
     let should_emit = match peel_blocks(func_expr).kind {
-        ExprKind::Tup(fields) => fields.iter().all(|e| is_default_equivalent(cx, e)),
-        ExprKind::Call(callee, args) if is_path_self(callee) => args.iter().all(|e| is_default_equivalent(cx, e)),
-        ExprKind::Struct(_, fields, _) => fields.iter().all(|ef| is_default_equivalent(cx, ef.expr)),
+        ExprKind::Tup(fields) => fields.iter().all(|e| is_default_without_adjusts(e)),
+        ExprKind::Call(callee, args) if is_path_self(callee) => args.iter().all(|e| is_default_without_adjusts(e)),
+        ExprKind::Struct(_, fields, _) => fields.iter().all(|ef| is_default_without_adjusts(ef.expr)),
         _ => false,
     };
 
@@ -197,7 +225,7 @@ impl<'tcx> LateLintPass<'tcx> for DerivableImpls {
 
             then {
                 if adt_def.is_struct() {
-                    check_struct(cx, item, self_ty, func_expr, adt_def, substs);
+                    check_struct(cx, item, self_ty, func_expr, adt_def, substs, cx.tcx.typeck_body(*b));
                 } else if adt_def.is_enum() && self.msrv.meets(msrvs::DEFAULT_ENUM_ATTRIBUTE) {
                     check_enum(cx, item, func_expr, adt_def);
                 }
diff --git a/tests/ui/derivable_impls.fixed b/tests/ui/derivable_impls.fixed
index aa0efb85c29..a10f3d01070 100644
--- a/tests/ui/derivable_impls.fixed
+++ b/tests/ui/derivable_impls.fixed
@@ -268,4 +268,25 @@ impl Default for OtherGenericType {
     }
 }
 
+mod issue10158 {
+    pub trait T {}
+
+    #[derive(Default)]
+    pub struct S {}
+    impl T for S {}
+
+    pub struct Outer {
+        pub inner: Box<dyn T>,
+    }
+
+    impl Default for Outer {
+        fn default() -> Self {
+            Outer {
+                // Box::<S>::default() adjusts to Box<dyn T>
+                inner: Box::<S>::default(),
+            }
+        }
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/derivable_impls.rs b/tests/ui/derivable_impls.rs
index 8dc999ad586..18cef1c5be8 100644
--- a/tests/ui/derivable_impls.rs
+++ b/tests/ui/derivable_impls.rs
@@ -304,4 +304,25 @@ impl Default for OtherGenericType {
     }
 }
 
+mod issue10158 {
+    pub trait T {}
+
+    #[derive(Default)]
+    pub struct S {}
+    impl T for S {}
+
+    pub struct Outer {
+        pub inner: Box<dyn T>,
+    }
+
+    impl Default for Outer {
+        fn default() -> Self {
+            Outer {
+                // Box::<S>::default() adjusts to Box<dyn T>
+                inner: Box::<S>::default(),
+            }
+        }
+    }
+}
+
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 5b6ba204a7de1d5c694a7b25269a25ee68c98830 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Wed, 14 Jun 2023 17:01:57 +0200
Subject: fmt

---
 clippy_lints/src/derivable_impls.rs | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/derivable_impls.rs b/clippy_lints/src/derivable_impls.rs
index 618214f4aa2..4ea58c47709 100644
--- a/clippy_lints/src/derivable_impls.rs
+++ b/clippy_lints/src/derivable_impls.rs
@@ -78,12 +78,10 @@ fn is_path_self(e: &Expr<'_>) -> bool {
 
 fn contains_trait_object(cx: &LateContext<'_>, ty: ty::Ty<'_>) -> bool {
     match ty.kind() {
-        ty::TyKind::Ref(_, ty, _) => {
-            contains_trait_object(cx, *ty)
-        },
+        ty::TyKind::Ref(_, ty, _) => contains_trait_object(cx, *ty),
         ty::TyKind::Adt(def, substs) => {
             def.is_box() && substs[0].as_type().map_or(false, |ty| contains_trait_object(cx, ty))
-        }
+        },
         ty::TyKind::Dynamic(..) => true,
         _ => false,
     }
@@ -119,7 +117,7 @@ fn check_struct<'tcx>(
     let is_default_without_adjusts = |expr| {
         is_default_equivalent(cx, expr)
             && typeck_results.expr_adjustments(expr).iter().all(|adj| {
-                !matches!(adj.kind, Adjust::Pointer(PointerCast::Unsize) 
+                !matches!(adj.kind, Adjust::Pointer(PointerCast::Unsize)
                     if contains_trait_object(cx, adj.target))
             })
     };
-- 
cgit 1.4.1-3-g733a5


From fcb9a382f70125209e3ac4b82ef0e5e67decae65 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Wed, 14 Jun 2023 17:10:26 +0200
Subject: dogfood

---
 clippy_lints/src/derivable_impls.rs | 14 ++++++--------
 1 file changed, 6 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/derivable_impls.rs b/clippy_lints/src/derivable_impls.rs
index 4ea58c47709..55cfe0d6b8b 100644
--- a/clippy_lints/src/derivable_impls.rs
+++ b/clippy_lints/src/derivable_impls.rs
@@ -76,12 +76,10 @@ fn is_path_self(e: &Expr<'_>) -> bool {
     }
 }
 
-fn contains_trait_object(cx: &LateContext<'_>, ty: ty::Ty<'_>) -> bool {
+fn contains_trait_object(ty: ty::Ty<'_>) -> bool {
     match ty.kind() {
-        ty::TyKind::Ref(_, ty, _) => contains_trait_object(cx, *ty),
-        ty::TyKind::Adt(def, substs) => {
-            def.is_box() && substs[0].as_type().map_or(false, |ty| contains_trait_object(cx, ty))
-        },
+        ty::TyKind::Ref(_, ty, _) => contains_trait_object(*ty),
+        ty::TyKind::Adt(def, substs) => def.is_box() && substs[0].as_type().map_or(false, contains_trait_object),
         ty::TyKind::Dynamic(..) => true,
         _ => false,
     }
@@ -118,13 +116,13 @@ fn check_struct<'tcx>(
         is_default_equivalent(cx, expr)
             && typeck_results.expr_adjustments(expr).iter().all(|adj| {
                 !matches!(adj.kind, Adjust::Pointer(PointerCast::Unsize)
-                    if contains_trait_object(cx, adj.target))
+                    if contains_trait_object(adj.target))
             })
     };
 
     let should_emit = match peel_blocks(func_expr).kind {
-        ExprKind::Tup(fields) => fields.iter().all(|e| is_default_without_adjusts(e)),
-        ExprKind::Call(callee, args) if is_path_self(callee) => args.iter().all(|e| is_default_without_adjusts(e)),
+        ExprKind::Tup(fields) => fields.iter().all(is_default_without_adjusts),
+        ExprKind::Call(callee, args) if is_path_self(callee) => args.iter().all(is_default_without_adjusts),
         ExprKind::Struct(_, fields, _) => fields.iter().all(|ef| is_default_without_adjusts(ef.expr)),
         _ => false,
     };
-- 
cgit 1.4.1-3-g733a5


From 4795c919399610d9105fae67492d3eb65c0c1c01 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Wed, 14 Jun 2023 17:15:57 +0200
Subject: fix internal lints

---
 clippy_lints/src/derivable_impls.rs | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/derivable_impls.rs b/clippy_lints/src/derivable_impls.rs
index 55cfe0d6b8b..ec0ca50cfec 100644
--- a/clippy_lints/src/derivable_impls.rs
+++ b/clippy_lints/src/derivable_impls.rs
@@ -4,12 +4,13 @@ use clippy_utils::source::indent_of;
 use clippy_utils::{is_default_equivalent, peel_blocks};
 use rustc_errors::Applicability;
 use rustc_hir::{
+    self as hir,
     def::{CtorKind, CtorOf, DefKind, Res},
-    Body, Expr, ExprKind, GenericArg, Impl, ImplItemKind, Item, ItemKind, Node, PathSegment, QPath, Ty, TyKind,
+    Body, Expr, ExprKind, GenericArg, Impl, ImplItemKind, Item, ItemKind, Node, PathSegment, QPath, TyKind,
 };
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::adjustment::{Adjust, PointerCast};
-use rustc_middle::ty::{self, Adt, AdtDef, SubstsRef, TypeckResults};
+use rustc_middle::ty::{self, Adt, AdtDef, SubstsRef, Ty, TypeckResults};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::sym;
 
@@ -76,11 +77,11 @@ fn is_path_self(e: &Expr<'_>) -> bool {
     }
 }
 
-fn contains_trait_object(ty: ty::Ty<'_>) -> bool {
+fn contains_trait_object(ty: Ty<'_>) -> bool {
     match ty.kind() {
-        ty::TyKind::Ref(_, ty, _) => contains_trait_object(*ty),
-        ty::TyKind::Adt(def, substs) => def.is_box() && substs[0].as_type().map_or(false, contains_trait_object),
-        ty::TyKind::Dynamic(..) => true,
+        ty::Ref(_, ty, _) => contains_trait_object(*ty),
+        ty::Adt(def, substs) => def.is_box() && substs[0].as_type().map_or(false, contains_trait_object),
+        ty::Dynamic(..) => true,
         _ => false,
     }
 }
@@ -88,7 +89,7 @@ fn contains_trait_object(ty: ty::Ty<'_>) -> bool {
 fn check_struct<'tcx>(
     cx: &LateContext<'tcx>,
     item: &'tcx Item<'_>,
-    self_ty: &Ty<'_>,
+    self_ty: &hir::Ty<'_>,
     func_expr: &Expr<'_>,
     adt_def: AdtDef<'_>,
     substs: SubstsRef<'_>,
-- 
cgit 1.4.1-3-g733a5


From 69e892e3a182bedb22e20399d6ba862572be46b2 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Wed, 14 Jun 2023 22:29:57 +0200
Subject: get rid of unnecessary function pointer

---
 clippy_lints/src/methods/unnecessary_fold.rs | 59 ++++++++++++----------------
 1 file changed, 26 insertions(+), 33 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/unnecessary_fold.rs b/clippy_lints/src/methods/unnecessary_fold.rs
index de29d99cf8d..e545abd8ba8 100644
--- a/clippy_lints/src/methods/unnecessary_fold.rs
+++ b/clippy_lints/src/methods/unnecessary_fold.rs
@@ -12,14 +12,10 @@ use rustc_span::{source_map::Span, sym};
 
 use super::UNNECESSARY_FOLD;
 
-/// No turbofish needed in any case.
-fn no_turbofish(_: &LateContext<'_>, _: &hir::Expr<'_>) -> bool {
-    false
-}
-
-/// Turbofish (`::<T>`) may be needed, but can be omitted if we are certain
-/// that the type can be inferred from usage.
-fn turbofish_if_not_inferred(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> bool {
+/// Do we need to suggest turbofish when suggesting a replacement method?
+/// Changing `fold` to `sum` needs it sometimes when the return type can't be
+/// inferred. This checks for some common cases where it can be safely omitted
+fn needs_turbofish(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> bool {
     let parent = cx.tcx.hir().get_parent(expr.hir_id);
 
     // some common cases where turbofish isn't needed:
@@ -53,26 +49,7 @@ fn turbofish_if_not_inferred(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> bool
 struct Replacement {
     method_name: &'static str,
     has_args: bool,
-    requires_turbofish: fn(&LateContext<'_>, &hir::Expr<'_>) -> bool,
-}
-impl Replacement {
-    /// `any(f)`, `all(f)`
-    pub fn non_generic(method_name: &'static str) -> Self {
-        Self {
-            method_name,
-            has_args: true,
-            requires_turbofish: no_turbofish,
-        }
-    }
-
-    /// `sum::<T>()`, `product::<T>()`
-    pub fn generic(method_name: &'static str) -> Self {
-        Self {
-            method_name,
-            has_args: false,
-            requires_turbofish: turbofish_if_not_inferred,
-        }
-    }
+    has_generic_return: bool,
 }
 
 pub(super) fn check(
@@ -111,7 +88,7 @@ pub(super) fn check(
             then {
                 let mut applicability = Applicability::MachineApplicable;
 
-                let turbofish = if (replacement.requires_turbofish)(cx, expr) {
+                let turbofish = if replacement.has_generic_return {
                     format!("::<{}>", cx.typeck_results().expr_ty_adjusted(right_expr).peel_refs())
                 } else {
                     String::new()
@@ -159,7 +136,11 @@ pub(super) fn check(
                     acc,
                     fold_span,
                     hir::BinOpKind::Or,
-                    Replacement::non_generic("any"),
+                    Replacement {
+                        has_args: true,
+                        has_generic_return: false,
+                        method_name: "any",
+                    },
                 );
             },
             ast::LitKind::Bool(true) => {
@@ -169,7 +150,11 @@ pub(super) fn check(
                     acc,
                     fold_span,
                     hir::BinOpKind::And,
-                    Replacement::non_generic("all"),
+                    Replacement {
+                        has_args: true,
+                        has_generic_return: false,
+                        method_name: "all",
+                    },
                 );
             },
             ast::LitKind::Int(0, _) => check_fold_with_op(
@@ -178,7 +163,11 @@ pub(super) fn check(
                 acc,
                 fold_span,
                 hir::BinOpKind::Add,
-                Replacement::generic("sum"),
+                Replacement {
+                    has_args: false,
+                    has_generic_return: needs_turbofish(cx, expr),
+                    method_name: "sum",
+                },
             ),
             ast::LitKind::Int(1, _) => {
                 check_fold_with_op(
@@ -187,7 +176,11 @@ pub(super) fn check(
                     acc,
                     fold_span,
                     hir::BinOpKind::Mul,
-                    Replacement::generic("product"),
+                    Replacement {
+                        has_args: false,
+                        has_generic_return: needs_turbofish(cx, expr),
+                        method_name: "product",
+                    },
                 );
             },
             _ => (),
-- 
cgit 1.4.1-3-g733a5


From d102e2296c2a507c32f3882b296ee65926dfc32f Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Wed, 14 Jun 2023 22:38:06 +0200
Subject: move check_fold_with_op function out

---
 clippy_lints/src/methods/unnecessary_fold.rs | 122 +++++++++++++--------------
 1 file changed, 61 insertions(+), 61 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/unnecessary_fold.rs b/clippy_lints/src/methods/unnecessary_fold.rs
index e545abd8ba8..8ec15a1c1b7 100644
--- a/clippy_lints/src/methods/unnecessary_fold.rs
+++ b/clippy_lints/src/methods/unnecessary_fold.rs
@@ -52,75 +52,75 @@ struct Replacement {
     has_generic_return: bool,
 }
 
-pub(super) fn check(
+fn check_fold_with_op(
     cx: &LateContext<'_>,
     expr: &hir::Expr<'_>,
-    init: &hir::Expr<'_>,
     acc: &hir::Expr<'_>,
     fold_span: Span,
+    op: hir::BinOpKind,
+    replacement: Replacement,
 ) {
-    fn check_fold_with_op(
-        cx: &LateContext<'_>,
-        expr: &hir::Expr<'_>,
-        acc: &hir::Expr<'_>,
-        fold_span: Span,
-        op: hir::BinOpKind,
-        replacement: Replacement,
-    ) {
-        if_chain! {
-            // Extract the body of the closure passed to fold
-            if let hir::ExprKind::Closure(&hir::Closure { body, .. }) = acc.kind;
-            let closure_body = cx.tcx.hir().body(body);
-            let closure_expr = peel_blocks(closure_body.value);
-
-            // Check if the closure body is of the form `acc <op> some_expr(x)`
-            if let hir::ExprKind::Binary(ref bin_op, left_expr, right_expr) = closure_expr.kind;
-            if bin_op.node == op;
-
-            // Extract the names of the two arguments to the closure
-            if let [param_a, param_b] = closure_body.params;
-            if let PatKind::Binding(_, first_arg_id, ..) = strip_pat_refs(param_a.pat).kind;
-            if let PatKind::Binding(_, second_arg_id, second_arg_ident, _) = strip_pat_refs(param_b.pat).kind;
-
-            if path_to_local_id(left_expr, first_arg_id);
-            if replacement.has_args || path_to_local_id(right_expr, second_arg_id);
-
-            then {
-                let mut applicability = Applicability::MachineApplicable;
-
-                let turbofish = if replacement.has_generic_return {
-                    format!("::<{}>", cx.typeck_results().expr_ty_adjusted(right_expr).peel_refs())
-                } else {
-                    String::new()
-                };
-
-                let sugg = if replacement.has_args {
-                    format!(
-                        "{method}{turbofish}(|{second_arg_ident}| {r})",
-                        method = replacement.method_name,
-                        r = snippet_with_applicability(cx, right_expr.span, "EXPR", &mut applicability),
-                    )
-                } else {
-                    format!(
-                        "{method}{turbofish}()",
-                        method = replacement.method_name,
-                    )
-                };
-
-                span_lint_and_sugg(
-                    cx,
-                    UNNECESSARY_FOLD,
-                    fold_span.with_hi(expr.span.hi()),
-                    // TODO #2371 don't suggest e.g., .any(|x| f(x)) if we can suggest .any(f)
-                    "this `.fold` can be written more succinctly using another method",
-                    "try",
-                    sugg,
-                    applicability,
-                );
-            }
+    if_chain! {
+        // Extract the body of the closure passed to fold
+        if let hir::ExprKind::Closure(&hir::Closure { body, .. }) = acc.kind;
+        let closure_body = cx.tcx.hir().body(body);
+        let closure_expr = peel_blocks(closure_body.value);
+
+        // Check if the closure body is of the form `acc <op> some_expr(x)`
+        if let hir::ExprKind::Binary(ref bin_op, left_expr, right_expr) = closure_expr.kind;
+        if bin_op.node == op;
+
+        // Extract the names of the two arguments to the closure
+        if let [param_a, param_b] = closure_body.params;
+        if let PatKind::Binding(_, first_arg_id, ..) = strip_pat_refs(param_a.pat).kind;
+        if let PatKind::Binding(_, second_arg_id, second_arg_ident, _) = strip_pat_refs(param_b.pat).kind;
+
+        if path_to_local_id(left_expr, first_arg_id);
+        if replacement.has_args || path_to_local_id(right_expr, second_arg_id);
+
+        then {
+            let mut applicability = Applicability::MachineApplicable;
+
+            let turbofish = if replacement.has_generic_return {
+                format!("::<{}>", cx.typeck_results().expr_ty_adjusted(right_expr).peel_refs())
+            } else {
+                String::new()
+            };
+
+            let sugg = if replacement.has_args {
+                format!(
+                    "{method}{turbofish}(|{second_arg_ident}| {r})",
+                    method = replacement.method_name,
+                    r = snippet_with_applicability(cx, right_expr.span, "EXPR", &mut applicability),
+                )
+            } else {
+                format!(
+                    "{method}{turbofish}()",
+                    method = replacement.method_name,
+                )
+            };
+
+            span_lint_and_sugg(
+                cx,
+                UNNECESSARY_FOLD,
+                fold_span.with_hi(expr.span.hi()),
+                // TODO #2371 don't suggest e.g., .any(|x| f(x)) if we can suggest .any(f)
+                "this `.fold` can be written more succinctly using another method",
+                "try",
+                sugg,
+                applicability,
+            );
         }
     }
+}
 
+pub(super) fn check(
+    cx: &LateContext<'_>,
+    expr: &hir::Expr<'_>,
+    init: &hir::Expr<'_>,
+    acc: &hir::Expr<'_>,
+    fold_span: Span,
+) {
     // Check that this is a call to Iterator::fold rather than just some function called fold
     if !is_trait_method(cx, expr, sym::Iterator) {
         return;
-- 
cgit 1.4.1-3-g733a5


From a899034927da107f4c51e9055f8c0e194c776228 Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Wed, 14 Jun 2023 07:12:25 -0500
Subject: Don't lint `excessive_precision` on inf

---
 clippy_lints/src/float_literal.rs   | 11 ++++++++---
 tests/ui/excessive_precision.fixed  | 15 ++++++++++++++-
 tests/ui/excessive_precision.rs     | 15 ++++++++++++++-
 tests/ui/excessive_precision.stderr | 30 +++++++++++++++---------------
 tests/ui/lossy_float_literal.fixed  |  4 ++++
 tests/ui/lossy_float_literal.rs     |  4 ++++
 tests/ui/lossy_float_literal.stderr | 22 +++++++++++-----------
 7 files changed, 70 insertions(+), 31 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/float_literal.rs b/clippy_lints/src/float_literal.rs
index 93bf50fd5e7..d182bb62195 100644
--- a/clippy_lints/src/float_literal.rs
+++ b/clippy_lints/src/float_literal.rs
@@ -82,19 +82,24 @@ impl<'tcx> LateLintPass<'tcx> for FloatLiteral {
                     LitFloatType::Suffixed(ast::FloatTy::F64) => Some("f64"),
                     LitFloatType::Unsuffixed => None
                 };
-                let (is_whole, mut float_str) = match fty {
+                let (is_whole, is_inf, mut float_str) = match fty {
                     FloatTy::F32 => {
                         let value = sym_str.parse::<f32>().unwrap();
 
-                        (value.fract() == 0.0, formatter.format(value))
+                        (value.fract() == 0.0, value.is_infinite(), formatter.format(value))
                     },
                     FloatTy::F64 => {
                         let value = sym_str.parse::<f64>().unwrap();
 
-                        (value.fract() == 0.0, formatter.format(value))
+
+                        (value.fract() == 0.0, value.is_infinite(), formatter.format(value))
                     },
                 };
 
+                if is_inf {
+                    return;
+                }
+
                 if is_whole && !sym_str.contains(|c| c == 'e' || c == 'E') {
                     // Normalize the literal by stripping the fractional portion
                     if sym_str.split('.').next().unwrap() != float_str {
diff --git a/tests/ui/excessive_precision.fixed b/tests/ui/excessive_precision.fixed
index 1bcaa33a049..7bb4da453c1 100644
--- a/tests/ui/excessive_precision.fixed
+++ b/tests/ui/excessive_precision.fixed
@@ -1,6 +1,12 @@
 //@run-rustfix
 #![warn(clippy::excessive_precision)]
-#![allow(dead_code, unused_variables, clippy::print_literal, clippy::useless_vec)]
+#![allow(
+    dead_code,
+    overflowing_literals,
+    unused_variables,
+    clippy::print_literal,
+    clippy::useless_vec
+)]
 
 fn main() {
     // Consts
@@ -66,4 +72,11 @@ fn main() {
 
     // issue #7745
     let _ = 0_f64;
+
+    // issue #9910
+    const INF1: f32 = 1.0e+33f32;
+    const INF2: f64 = 1.0e+3300f64;
+    const NEG_INF1: f32 = -1.0e+33f32;
+    const NEG_INF2: f64 = -1.0e+3300f64;
+    const NEG_INF3: f32 = -3.40282357e+38_f32;
 }
diff --git a/tests/ui/excessive_precision.rs b/tests/ui/excessive_precision.rs
index cee937e07e1..e8d6ab6870a 100644
--- a/tests/ui/excessive_precision.rs
+++ b/tests/ui/excessive_precision.rs
@@ -1,6 +1,12 @@
 //@run-rustfix
 #![warn(clippy::excessive_precision)]
-#![allow(dead_code, unused_variables, clippy::print_literal, clippy::useless_vec)]
+#![allow(
+    dead_code,
+    overflowing_literals,
+    unused_variables,
+    clippy::print_literal,
+    clippy::useless_vec
+)]
 
 fn main() {
     // Consts
@@ -66,4 +72,11 @@ fn main() {
 
     // issue #7745
     let _ = 1.000_000_000_000_001e-324_f64;
+
+    // issue #9910
+    const INF1: f32 = 1.0e+33f32;
+    const INF2: f64 = 1.0e+3300f64;
+    const NEG_INF1: f32 = -1.0e+33f32;
+    const NEG_INF2: f64 = -1.0e+3300f64;
+    const NEG_INF3: f32 = -3.40282357e+38_f32;
 }
diff --git a/tests/ui/excessive_precision.stderr b/tests/ui/excessive_precision.stderr
index 42d9d4de193..348ad183d7d 100644
--- a/tests/ui/excessive_precision.stderr
+++ b/tests/ui/excessive_precision.stderr
@@ -1,5 +1,5 @@
 error: float has excessive precision
-  --> $DIR/excessive_precision.rs:15:26
+  --> $DIR/excessive_precision.rs:21:26
    |
 LL |     const BAD32_1: f32 = 0.123_456_789_f32;
    |                          ^^^^^^^^^^^^^^^^^ help: consider changing the type or truncating it to: `0.123_456_79_f32`
@@ -7,85 +7,85 @@ LL |     const BAD32_1: f32 = 0.123_456_789_f32;
    = note: `-D clippy::excessive-precision` implied by `-D warnings`
 
 error: float has excessive precision
-  --> $DIR/excessive_precision.rs:16:26
+  --> $DIR/excessive_precision.rs:22:26
    |
 LL |     const BAD32_2: f32 = 0.123_456_789;
    |                          ^^^^^^^^^^^^^ help: consider changing the type or truncating it to: `0.123_456_79`
 
 error: float has excessive precision
-  --> $DIR/excessive_precision.rs:17:26
+  --> $DIR/excessive_precision.rs:23:26
    |
 LL |     const BAD32_3: f32 = 0.100_000_000_000_1;
    |                          ^^^^^^^^^^^^^^^^^^^ help: consider changing the type or truncating it to: `0.1`
 
 error: float has excessive precision
-  --> $DIR/excessive_precision.rs:18:29
+  --> $DIR/excessive_precision.rs:24:29
    |
 LL |     const BAD32_EDGE: f32 = 1.000_000_9;
    |                             ^^^^^^^^^^^ help: consider changing the type or truncating it to: `1.000_001`
 
 error: float has excessive precision
-  --> $DIR/excessive_precision.rs:22:26
+  --> $DIR/excessive_precision.rs:28:26
    |
 LL |     const BAD64_3: f64 = 0.100_000_000_000_000_000_1;
    |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider changing the type or truncating it to: `0.1`
 
 error: float has excessive precision
-  --> $DIR/excessive_precision.rs:25:22
+  --> $DIR/excessive_precision.rs:31:22
    |
 LL |     println!("{:?}", 8.888_888_888_888_888_888_888);
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider changing the type or truncating it to: `8.888_888_888_888_89`
 
 error: float has excessive precision
-  --> $DIR/excessive_precision.rs:36:22
+  --> $DIR/excessive_precision.rs:42:22
    |
 LL |     let bad32: f32 = 1.123_456_789;
    |                      ^^^^^^^^^^^^^ help: consider changing the type or truncating it to: `1.123_456_8`
 
 error: float has excessive precision
-  --> $DIR/excessive_precision.rs:37:26
+  --> $DIR/excessive_precision.rs:43:26
    |
 LL |     let bad32_suf: f32 = 1.123_456_789_f32;
    |                          ^^^^^^^^^^^^^^^^^ help: consider changing the type or truncating it to: `1.123_456_8_f32`
 
 error: float has excessive precision
-  --> $DIR/excessive_precision.rs:38:21
+  --> $DIR/excessive_precision.rs:44:21
    |
 LL |     let bad32_inf = 1.123_456_789_f32;
    |                     ^^^^^^^^^^^^^^^^^ help: consider changing the type or truncating it to: `1.123_456_8_f32`
 
 error: float has excessive precision
-  --> $DIR/excessive_precision.rs:48:36
+  --> $DIR/excessive_precision.rs:54:36
    |
 LL |     let bad_vec32: Vec<f32> = vec![0.123_456_789];
    |                                    ^^^^^^^^^^^^^ help: consider changing the type or truncating it to: `0.123_456_79`
 
 error: float has excessive precision
-  --> $DIR/excessive_precision.rs:49:36
+  --> $DIR/excessive_precision.rs:55:36
    |
 LL |     let bad_vec64: Vec<f64> = vec![0.123_456_789_123_456_789];
    |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider changing the type or truncating it to: `0.123_456_789_123_456_78`
 
 error: float has excessive precision
-  --> $DIR/excessive_precision.rs:53:24
+  --> $DIR/excessive_precision.rs:59:24
    |
 LL |     let bad_e32: f32 = 1.123_456_788_888e-10;
    |                        ^^^^^^^^^^^^^^^^^^^^^ help: consider changing the type or truncating it to: `1.123_456_8e-10`
 
 error: float has excessive precision
-  --> $DIR/excessive_precision.rs:56:27
+  --> $DIR/excessive_precision.rs:62:27
    |
 LL |     let bad_bige32: f32 = 1.123_456_788_888E-10;
    |                           ^^^^^^^^^^^^^^^^^^^^^ help: consider changing the type or truncating it to: `1.123_456_8E-10`
 
 error: float has excessive precision
-  --> $DIR/excessive_precision.rs:65:13
+  --> $DIR/excessive_precision.rs:71:13
    |
 LL |     let _ = 2.225_073_858_507_201_1e-308_f64;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider changing the type or truncating it to: `2.225_073_858_507_201e-308_f64`
 
 error: float has excessive precision
-  --> $DIR/excessive_precision.rs:68:13
+  --> $DIR/excessive_precision.rs:74:13
    |
 LL |     let _ = 1.000_000_000_000_001e-324_f64;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider changing the type or truncating it to: `0_f64`
diff --git a/tests/ui/lossy_float_literal.fixed b/tests/ui/lossy_float_literal.fixed
index a2088575610..e19f4980cd7 100644
--- a/tests/ui/lossy_float_literal.fixed
+++ b/tests/ui/lossy_float_literal.fixed
@@ -1,5 +1,6 @@
 //@run-rustfix
 #![warn(clippy::lossy_float_literal)]
+#![allow(overflowing_literals, unused)]
 
 fn main() {
     // Lossy whole-number float literals
@@ -32,4 +33,7 @@ fn main() {
     let _: f64 = 1e99;
     let _: f64 = 1E99;
     let _: f32 = 0.1;
+
+    const INF1: f32 = 1000000000000000000000000000000000f32;
+    const NEG_INF1: f32 = -340282357000000000000000000000000000001_f32;
 }
diff --git a/tests/ui/lossy_float_literal.rs b/tests/ui/lossy_float_literal.rs
index 1a75f214c85..a2a1cfb317e 100644
--- a/tests/ui/lossy_float_literal.rs
+++ b/tests/ui/lossy_float_literal.rs
@@ -1,5 +1,6 @@
 //@run-rustfix
 #![warn(clippy::lossy_float_literal)]
+#![allow(overflowing_literals, unused)]
 
 fn main() {
     // Lossy whole-number float literals
@@ -32,4 +33,7 @@ fn main() {
     let _: f64 = 1e99;
     let _: f64 = 1E99;
     let _: f32 = 0.1;
+
+    const INF1: f32 = 1000000000000000000000000000000000f32;
+    const NEG_INF1: f32 = -340282357000000000000000000000000000001_f32;
 }
diff --git a/tests/ui/lossy_float_literal.stderr b/tests/ui/lossy_float_literal.stderr
index d2193c0c819..2d72b16430c 100644
--- a/tests/ui/lossy_float_literal.stderr
+++ b/tests/ui/lossy_float_literal.stderr
@@ -1,5 +1,5 @@
 error: literal cannot be represented as the underlying type without loss of precision
-  --> $DIR/lossy_float_literal.rs:6:18
+  --> $DIR/lossy_float_literal.rs:7:18
    |
 LL |     let _: f32 = 16_777_217.0;
    |                  ^^^^^^^^^^^^ help: consider changing the type or replacing it with: `16_777_216.0`
@@ -7,61 +7,61 @@ LL |     let _: f32 = 16_777_217.0;
    = note: `-D clippy::lossy-float-literal` implied by `-D warnings`
 
 error: literal cannot be represented as the underlying type without loss of precision
-  --> $DIR/lossy_float_literal.rs:7:18
+  --> $DIR/lossy_float_literal.rs:8:18
    |
 LL |     let _: f32 = 16_777_219.0;
    |                  ^^^^^^^^^^^^ help: consider changing the type or replacing it with: `16_777_220.0`
 
 error: literal cannot be represented as the underlying type without loss of precision
-  --> $DIR/lossy_float_literal.rs:8:18
+  --> $DIR/lossy_float_literal.rs:9:18
    |
 LL |     let _: f32 = 16_777_219.;
    |                  ^^^^^^^^^^^ help: consider changing the type or replacing it with: `16_777_220.0`
 
 error: literal cannot be represented as the underlying type without loss of precision
-  --> $DIR/lossy_float_literal.rs:9:18
+  --> $DIR/lossy_float_literal.rs:10:18
    |
 LL |     let _: f32 = 16_777_219.000;
    |                  ^^^^^^^^^^^^^^ help: consider changing the type or replacing it with: `16_777_220.0`
 
 error: literal cannot be represented as the underlying type without loss of precision
-  --> $DIR/lossy_float_literal.rs:10:13
+  --> $DIR/lossy_float_literal.rs:11:13
    |
 LL |     let _ = 16_777_219f32;
    |             ^^^^^^^^^^^^^ help: consider changing the type or replacing it with: `16_777_220_f32`
 
 error: literal cannot be represented as the underlying type without loss of precision
-  --> $DIR/lossy_float_literal.rs:11:19
+  --> $DIR/lossy_float_literal.rs:12:19
    |
 LL |     let _: f32 = -16_777_219.0;
    |                   ^^^^^^^^^^^^ help: consider changing the type or replacing it with: `16_777_220.0`
 
 error: literal cannot be represented as the underlying type without loss of precision
-  --> $DIR/lossy_float_literal.rs:12:18
+  --> $DIR/lossy_float_literal.rs:13:18
    |
 LL |     let _: f64 = 9_007_199_254_740_993.0;
    |                  ^^^^^^^^^^^^^^^^^^^^^^^ help: consider changing the type or replacing it with: `9_007_199_254_740_992.0`
 
 error: literal cannot be represented as the underlying type without loss of precision
-  --> $DIR/lossy_float_literal.rs:13:18
+  --> $DIR/lossy_float_literal.rs:14:18
    |
 LL |     let _: f64 = 9_007_199_254_740_993.;
    |                  ^^^^^^^^^^^^^^^^^^^^^^ help: consider changing the type or replacing it with: `9_007_199_254_740_992.0`
 
 error: literal cannot be represented as the underlying type without loss of precision
-  --> $DIR/lossy_float_literal.rs:14:18
+  --> $DIR/lossy_float_literal.rs:15:18
    |
 LL |     let _: f64 = 9_007_199_254_740_993.00;
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider changing the type or replacing it with: `9_007_199_254_740_992.0`
 
 error: literal cannot be represented as the underlying type without loss of precision
-  --> $DIR/lossy_float_literal.rs:15:13
+  --> $DIR/lossy_float_literal.rs:16:13
    |
 LL |     let _ = 9_007_199_254_740_993f64;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider changing the type or replacing it with: `9_007_199_254_740_992_f64`
 
 error: literal cannot be represented as the underlying type without loss of precision
-  --> $DIR/lossy_float_literal.rs:16:19
+  --> $DIR/lossy_float_literal.rs:17:19
    |
 LL |     let _: f64 = -9_007_199_254_740_993.0;
    |                   ^^^^^^^^^^^^^^^^^^^^^^^ help: consider changing the type or replacing it with: `9_007_199_254_740_992.0`
-- 
cgit 1.4.1-3-g733a5


From 67d5e6ec39a38cd4f2976b7a201d142ad6a0d09e Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Sun, 11 Jun 2023 02:46:28 -0500
Subject: add lint [`needless_clone_impl`]

Update needless_impls.rs
---
 CHANGELOG.md                                     |   1 +
 clippy_lints/src/declared_lints.rs               |   1 +
 clippy_lints/src/lib.rs                          |   2 +
 clippy_lints/src/needless_impls.rs               | 109 +++++++++++++++++++++++
 tests/ui/clone_on_copy_impl.rs                   |   2 +
 tests/ui/derive.rs                               |   2 +-
 tests/ui/needless_clone_impl.fixed               |  69 ++++++++++++++
 tests/ui/needless_clone_impl.rs                  |  71 +++++++++++++++
 tests/ui/needless_clone_impl.stderr              |  13 +++
 tests/ui/unnecessary_struct_initialization.fixed |   2 +-
 tests/ui/unnecessary_struct_initialization.rs    |   2 +-
 11 files changed, 271 insertions(+), 3 deletions(-)
 create mode 100644 clippy_lints/src/needless_impls.rs
 create mode 100644 tests/ui/needless_clone_impl.fixed
 create mode 100644 tests/ui/needless_clone_impl.rs
 create mode 100644 tests/ui/needless_clone_impl.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 218bca40cb0..c0925988ca1 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5005,6 +5005,7 @@ Released 2018-09-13
 [`needless_bool_assign`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_bool_assign
 [`needless_borrow`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow
 [`needless_borrowed_reference`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrowed_reference
+[`needless_clone_impl`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_clone_impl
 [`needless_collect`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_collect
 [`needless_continue`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_continue
 [`needless_doctest_main`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_doctest_main
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 9509e6d016a..1fd70fce14f 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -463,6 +463,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::needless_else::NEEDLESS_ELSE_INFO,
     crate::needless_for_each::NEEDLESS_FOR_EACH_INFO,
     crate::needless_if::NEEDLESS_IF_INFO,
+    crate::needless_impls::NEEDLESS_CLONE_IMPL_INFO,
     crate::needless_late_init::NEEDLESS_LATE_INIT_INFO,
     crate::needless_parens_on_range_literals::NEEDLESS_PARENS_ON_RANGE_LITERALS_INFO,
     crate::needless_pass_by_value::NEEDLESS_PASS_BY_VALUE_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index cf6499b9616..e07959849a3 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -226,6 +226,7 @@ mod needless_continue;
 mod needless_else;
 mod needless_for_each;
 mod needless_if;
+mod needless_impls;
 mod needless_late_init;
 mod needless_parens_on_range_literals;
 mod needless_pass_by_value;
@@ -1047,6 +1048,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     let stack_size_threshold = conf.stack_size_threshold;
     store.register_late_pass(move |_| Box::new(large_stack_frames::LargeStackFrames::new(stack_size_threshold)));
     store.register_late_pass(|_| Box::new(single_range_in_vec_init::SingleRangeInVecInit));
+    store.register_late_pass(|_| Box::new(needless_impls::NeedlessImpls));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/needless_impls.rs b/clippy_lints/src/needless_impls.rs
new file mode 100644
index 00000000000..ccfd55886ec
--- /dev/null
+++ b/clippy_lints/src/needless_impls.rs
@@ -0,0 +1,109 @@
+use clippy_utils::{diagnostics::span_lint_and_sugg, get_parent_node, last_path_segment, ty::implements_trait};
+use rustc_errors::Applicability;
+use rustc_hir::{ExprKind, ImplItem, ImplItemKind, ItemKind, Node, UnOp};
+use rustc_hir_analysis::hir_ty_to_ty;
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::EarlyBinder;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::{sym, symbol};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for manual implementations of `Clone` when `Copy` is already implemented.
+    ///
+    /// ### Why is this bad?
+    /// If both `Clone` and `Copy` are implemented, they must agree. This is done by dereferencing
+    /// `self` in `Clone`'s implementation. Anything else is incorrect.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// #[derive(Eq, PartialEq)]
+    /// struct A(u32);
+    ///
+    /// impl Clone for A {
+    ///     fn clone(&self) -> Self {
+    ///         Self(self.0)
+    ///     }
+    /// }
+    ///
+    /// impl Copy for A {}
+    /// ```
+    /// Use instead:
+    /// ```rust,ignore
+    /// #[derive(Eq, PartialEq)]
+    /// struct A(u32);
+    ///
+    /// impl Clone for A {
+    ///     fn clone(&self) -> Self {
+    ///         *self
+    ///     }
+    /// }
+    ///
+    /// impl Copy for A {}
+    /// ```
+    #[clippy::version = "1.72.0"]
+    pub NEEDLESS_CLONE_IMPL,
+    correctness,
+    "manual implementation of `Clone` on a `Copy` type"
+}
+declare_lint_pass!(NeedlessImpls => [NEEDLESS_CLONE_IMPL]);
+
+impl LateLintPass<'_> for NeedlessImpls {
+    #[expect(clippy::needless_return)]
+    fn check_impl_item(&mut self, cx: &LateContext<'_>, impl_item: &ImplItem<'_>) {
+        let node = get_parent_node(cx.tcx, impl_item.hir_id());
+        let Some(Node::Item(item)) = node else {
+            return;
+        };
+        let ItemKind::Impl(imp) = item.kind else {
+            return;
+        };
+        let Some(trait_impl) = cx.tcx.impl_trait_ref(item.owner_id).map(EarlyBinder::skip_binder) else {
+            return;
+        };
+        let trait_impl_def_id = trait_impl.def_id;
+        if cx.tcx.is_automatically_derived(item.owner_id.to_def_id()) {
+            return;
+        }
+        let ImplItemKind::Fn(_, impl_item_id) = cx.tcx.hir().impl_item(impl_item.impl_item_id()).kind else {
+            return;
+        };
+        let body = cx.tcx.hir().body(impl_item_id);
+        let ExprKind::Block(block, ..) = body.value.kind else {
+            return;
+        };
+        // Above is duplicated from the `duplicate_manual_partial_ord_impl` branch.
+        // Remove it while solving conflicts once that PR is merged.
+
+        // Actual implementation; remove this comment once aforementioned PR is merged
+        if cx.tcx.is_diagnostic_item(sym::Clone, trait_impl_def_id)
+            && impl_item.ident.name == sym::clone
+            && let Some(copy_def_id) = cx.tcx.get_diagnostic_item(sym::Copy)
+            && implements_trait(
+                    cx,
+                    hir_ty_to_ty(cx.tcx, imp.self_ty),
+                    copy_def_id,
+                    trait_impl.substs,
+                )
+        {
+            if block.stmts.is_empty()
+                && let Some(expr) = block.expr
+                && let ExprKind::Unary(UnOp::Deref, inner) = expr.kind
+                && let ExprKind::Path(qpath) = inner.kind
+                && last_path_segment(&qpath).ident.name == symbol::kw::SelfLower
+            {} else {
+                span_lint_and_sugg(
+                    cx,
+                    NEEDLESS_CLONE_IMPL,
+                    block.span,
+                    "manual implementation of `Clone` on a `Copy` type",
+                    "change this to",
+                    "{ *self }".to_owned(),
+                    Applicability::Unspecified,
+                );
+
+                return;
+            }
+        }
+    }
+}
diff --git a/tests/ui/clone_on_copy_impl.rs b/tests/ui/clone_on_copy_impl.rs
index 8f9f2a0db8c..06d8ad48446 100644
--- a/tests/ui/clone_on_copy_impl.rs
+++ b/tests/ui/clone_on_copy_impl.rs
@@ -1,3 +1,5 @@
+#![allow(clippy::needless_clone_impl)]
+
 use std::fmt;
 use std::marker::PhantomData;
 
diff --git a/tests/ui/derive.rs b/tests/ui/derive.rs
index 843e1df8bc6..857cd379fe2 100644
--- a/tests/ui/derive.rs
+++ b/tests/ui/derive.rs
@@ -1,4 +1,4 @@
-#![allow(dead_code)]
+#![allow(clippy::needless_clone_impl, dead_code)]
 #![warn(clippy::expl_impl_clone_on_copy)]
 
 #[derive(Copy)]
diff --git a/tests/ui/needless_clone_impl.fixed b/tests/ui/needless_clone_impl.fixed
new file mode 100644
index 00000000000..05caf485db6
--- /dev/null
+++ b/tests/ui/needless_clone_impl.fixed
@@ -0,0 +1,69 @@
+//@run-rustfix
+#![allow(unused)]
+#![no_main]
+
+// lint
+
+struct A(u32);
+
+impl Clone for A {
+    fn clone(&self) -> Self { *self }
+}
+
+impl Copy for A {}
+
+// do not lint
+
+struct B(u32);
+
+impl Clone for B {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+
+impl Copy for B {}
+
+// do not lint derived (clone's implementation is `*self` here anyway)
+
+#[derive(Clone, Copy)]
+struct C(u32);
+
+// do not lint derived (fr this time)
+
+struct D(u32);
+
+#[automatically_derived]
+impl Clone for D {
+    fn clone(&self) -> Self {
+        Self(self.0)
+    }
+}
+
+impl Copy for D {}
+
+// do not lint if clone is not manually implemented
+
+struct E(u32);
+
+#[automatically_derived]
+impl Clone for E {
+    fn clone(&self) -> Self {
+        Self(self.0)
+    }
+}
+
+impl Copy for E {}
+
+// do not lint since copy has more restrictive bounds
+
+#[derive(Eq, PartialEq)]
+struct Uwu<A: Copy>(A);
+
+impl<A: Copy> Clone for Uwu<A> {
+    fn clone(&self) -> Self {
+        Self(self.0)
+    }
+}
+
+impl<A: std::fmt::Debug + Copy + Clone> Copy for Uwu<A> {}
diff --git a/tests/ui/needless_clone_impl.rs b/tests/ui/needless_clone_impl.rs
new file mode 100644
index 00000000000..e30469e09e8
--- /dev/null
+++ b/tests/ui/needless_clone_impl.rs
@@ -0,0 +1,71 @@
+//@run-rustfix
+#![allow(unused)]
+#![no_main]
+
+// lint
+
+struct A(u32);
+
+impl Clone for A {
+    fn clone(&self) -> Self {
+        Self(self.0)
+    }
+}
+
+impl Copy for A {}
+
+// do not lint
+
+struct B(u32);
+
+impl Clone for B {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+
+impl Copy for B {}
+
+// do not lint derived (clone's implementation is `*self` here anyway)
+
+#[derive(Clone, Copy)]
+struct C(u32);
+
+// do not lint derived (fr this time)
+
+struct D(u32);
+
+#[automatically_derived]
+impl Clone for D {
+    fn clone(&self) -> Self {
+        Self(self.0)
+    }
+}
+
+impl Copy for D {}
+
+// do not lint if clone is not manually implemented
+
+struct E(u32);
+
+#[automatically_derived]
+impl Clone for E {
+    fn clone(&self) -> Self {
+        Self(self.0)
+    }
+}
+
+impl Copy for E {}
+
+// do not lint since copy has more restrictive bounds
+
+#[derive(Eq, PartialEq)]
+struct Uwu<A: Copy>(A);
+
+impl<A: Copy> Clone for Uwu<A> {
+    fn clone(&self) -> Self {
+        Self(self.0)
+    }
+}
+
+impl<A: std::fmt::Debug + Copy + Clone> Copy for Uwu<A> {}
diff --git a/tests/ui/needless_clone_impl.stderr b/tests/ui/needless_clone_impl.stderr
new file mode 100644
index 00000000000..51e2ef4f741
--- /dev/null
+++ b/tests/ui/needless_clone_impl.stderr
@@ -0,0 +1,13 @@
+error: manual implementation of `Clone` on a `Copy` type
+  --> $DIR/needless_clone_impl.rs:10:29
+   |
+LL |       fn clone(&self) -> Self {
+   |  _____________________________^
+LL | |         Self(self.0)
+LL | |     }
+   | |_____^ help: change this to: `{ *self }`
+   |
+   = note: `#[deny(clippy::needless_clone_impl)]` on by default
+
+error: aborting due to previous error
+
diff --git a/tests/ui/unnecessary_struct_initialization.fixed b/tests/ui/unnecessary_struct_initialization.fixed
index bdf746cf2c4..aec9725c4b9 100644
--- a/tests/ui/unnecessary_struct_initialization.fixed
+++ b/tests/ui/unnecessary_struct_initialization.fixed
@@ -1,6 +1,6 @@
 //@run-rustfix
 
-#![allow(unused)]
+#![allow(clippy::needless_clone_impl, unused)]
 #![warn(clippy::unnecessary_struct_initialization)]
 
 struct S {
diff --git a/tests/ui/unnecessary_struct_initialization.rs b/tests/ui/unnecessary_struct_initialization.rs
index 7271e2f957a..a3b9b88dbc2 100644
--- a/tests/ui/unnecessary_struct_initialization.rs
+++ b/tests/ui/unnecessary_struct_initialization.rs
@@ -1,6 +1,6 @@
 //@run-rustfix
 
-#![allow(unused)]
+#![allow(clippy::needless_clone_impl, unused)]
 #![warn(clippy::unnecessary_struct_initialization)]
 
 struct S {
-- 
cgit 1.4.1-3-g733a5


From 10cc1684ceca90f84a42099f09cf0737a7aca35b Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Tue, 13 Jun 2023 05:25:49 -0500
Subject: rename lint and disallow `clone_from`

---
 CHANGELOG.md                                      |   2 +-
 clippy_lints/src/declared_lints.rs                |   2 +-
 clippy_lints/src/incorrect_impls.rs               | 124 ++++++++++++++++++++++
 clippy_lints/src/lib.rs                           |   4 +-
 clippy_lints/src/needless_impls.rs                | 109 -------------------
 tests/ui/clone_on_copy_impl.rs                    |   2 +-
 tests/ui/derive.rs                                |   2 +-
 tests/ui/incorrect_clone_impl_on_copy_type.fixed  |  97 +++++++++++++++++
 tests/ui/incorrect_clone_impl_on_copy_type.rs     | 107 +++++++++++++++++++
 tests/ui/incorrect_clone_impl_on_copy_type.stderr |  40 +++++++
 tests/ui/needless_clone_impl.fixed                |  69 ------------
 tests/ui/needless_clone_impl.rs                   |  71 -------------
 tests/ui/needless_clone_impl.stderr               |  13 ---
 tests/ui/unnecessary_struct_initialization.fixed  |   2 +-
 tests/ui/unnecessary_struct_initialization.rs     |   2 +-
 15 files changed, 376 insertions(+), 270 deletions(-)
 create mode 100644 clippy_lints/src/incorrect_impls.rs
 delete mode 100644 clippy_lints/src/needless_impls.rs
 create mode 100644 tests/ui/incorrect_clone_impl_on_copy_type.fixed
 create mode 100644 tests/ui/incorrect_clone_impl_on_copy_type.rs
 create mode 100644 tests/ui/incorrect_clone_impl_on_copy_type.stderr
 delete mode 100644 tests/ui/needless_clone_impl.fixed
 delete mode 100644 tests/ui/needless_clone_impl.rs
 delete mode 100644 tests/ui/needless_clone_impl.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index c0925988ca1..445e2366cc3 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4833,6 +4833,7 @@ Released 2018-09-13
 [`imprecise_flops`]: https://rust-lang.github.io/rust-clippy/master/index.html#imprecise_flops
 [`inconsistent_digit_grouping`]: https://rust-lang.github.io/rust-clippy/master/index.html#inconsistent_digit_grouping
 [`inconsistent_struct_constructor`]: https://rust-lang.github.io/rust-clippy/master/index.html#inconsistent_struct_constructor
+[`incorrect_clone_impl_on_copy_type`]: https://rust-lang.github.io/rust-clippy/master/index.html#incorrect_clone_impl_on_copy_type
 [`index_refutable_slice`]: https://rust-lang.github.io/rust-clippy/master/index.html#index_refutable_slice
 [`indexing_slicing`]: https://rust-lang.github.io/rust-clippy/master/index.html#indexing_slicing
 [`ineffective_bit_mask`]: https://rust-lang.github.io/rust-clippy/master/index.html#ineffective_bit_mask
@@ -5005,7 +5006,6 @@ Released 2018-09-13
 [`needless_bool_assign`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_bool_assign
 [`needless_borrow`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow
 [`needless_borrowed_reference`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrowed_reference
-[`needless_clone_impl`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_clone_impl
 [`needless_collect`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_collect
 [`needless_continue`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_continue
 [`needless_doctest_main`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_doctest_main
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 1fd70fce14f..2690336648d 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -206,6 +206,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::implicit_saturating_add::IMPLICIT_SATURATING_ADD_INFO,
     crate::implicit_saturating_sub::IMPLICIT_SATURATING_SUB_INFO,
     crate::inconsistent_struct_constructor::INCONSISTENT_STRUCT_CONSTRUCTOR_INFO,
+    crate::incorrect_impls::INCORRECT_CLONE_IMPL_ON_COPY_TYPE_INFO,
     crate::index_refutable_slice::INDEX_REFUTABLE_SLICE_INFO,
     crate::indexing_slicing::INDEXING_SLICING_INFO,
     crate::indexing_slicing::OUT_OF_BOUNDS_INDEXING_INFO,
@@ -463,7 +464,6 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::needless_else::NEEDLESS_ELSE_INFO,
     crate::needless_for_each::NEEDLESS_FOR_EACH_INFO,
     crate::needless_if::NEEDLESS_IF_INFO,
-    crate::needless_impls::NEEDLESS_CLONE_IMPL_INFO,
     crate::needless_late_init::NEEDLESS_LATE_INIT_INFO,
     crate::needless_parens_on_range_literals::NEEDLESS_PARENS_ON_RANGE_LITERALS_INFO,
     crate::needless_pass_by_value::NEEDLESS_PASS_BY_VALUE_INFO,
diff --git a/clippy_lints/src/incorrect_impls.rs b/clippy_lints/src/incorrect_impls.rs
new file mode 100644
index 00000000000..13cc0b23ba3
--- /dev/null
+++ b/clippy_lints/src/incorrect_impls.rs
@@ -0,0 +1,124 @@
+use clippy_utils::{diagnostics::span_lint_and_sugg, get_parent_node, last_path_segment, ty::implements_trait};
+use rustc_errors::Applicability;
+use rustc_hir::{ExprKind, ImplItem, ImplItemKind, ItemKind, Node, UnOp};
+use rustc_hir_analysis::hir_ty_to_ty;
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::EarlyBinder;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::{sym, symbol};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for manual implementations of `Clone` when `Copy` is already implemented.
+    ///
+    /// ### Why is this bad?
+    /// If both `Clone` and `Copy` are implemented, they must agree. This is done by dereferencing
+    /// `self` in `Clone`'s implementation. Anything else is incorrect.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// #[derive(Eq, PartialEq)]
+    /// struct A(u32);
+    ///
+    /// impl Clone for A {
+    ///     fn clone(&self) -> Self {
+    ///         Self(self.0)
+    ///     }
+    /// }
+    ///
+    /// impl Copy for A {}
+    /// ```
+    /// Use instead:
+    /// ```rust,ignore
+    /// #[derive(Eq, PartialEq)]
+    /// struct A(u32);
+    ///
+    /// impl Clone for A {
+    ///     fn clone(&self) -> Self {
+    ///         *self
+    ///     }
+    /// }
+    ///
+    /// impl Copy for A {}
+    /// ```
+    #[clippy::version = "1.72.0"]
+    pub INCORRECT_CLONE_IMPL_ON_COPY_TYPE,
+    correctness,
+    "manual implementation of `Clone` on a `Copy` type"
+}
+declare_lint_pass!(IncorrectImpls => [INCORRECT_CLONE_IMPL_ON_COPY_TYPE]);
+
+impl LateLintPass<'_> for IncorrectImpls {
+    #[expect(clippy::needless_return)]
+    fn check_impl_item(&mut self, cx: &LateContext<'_>, impl_item: &ImplItem<'_>) {
+        let node = get_parent_node(cx.tcx, impl_item.hir_id());
+        let Some(Node::Item(item)) = node else {
+            return;
+        };
+        let ItemKind::Impl(imp) = item.kind else {
+            return;
+        };
+        let Some(trait_impl) = cx.tcx.impl_trait_ref(item.owner_id).map(EarlyBinder::skip_binder) else {
+            return;
+        };
+        let trait_impl_def_id = trait_impl.def_id;
+        if cx.tcx.is_automatically_derived(item.owner_id.to_def_id()) {
+            return;
+        }
+        let ImplItemKind::Fn(_, impl_item_id) = cx.tcx.hir().impl_item(impl_item.impl_item_id()).kind else {
+            return;
+        };
+        let body = cx.tcx.hir().body(impl_item_id);
+        let ExprKind::Block(block, ..) = body.value.kind else {
+            return;
+        };
+        // Above is duplicated from the `duplicate_manual_partial_ord_impl` branch.
+        // Remove it while solving conflicts once that PR is merged.
+
+        // Actual implementation; remove this comment once aforementioned PR is merged
+        if cx.tcx.is_diagnostic_item(sym::Clone, trait_impl_def_id)
+            && let Some(copy_def_id) = cx.tcx.get_diagnostic_item(sym::Copy)
+            && implements_trait(
+                    cx,
+                    hir_ty_to_ty(cx.tcx, imp.self_ty),
+                    copy_def_id,
+                    trait_impl.substs,
+                )
+        {
+            if impl_item.ident.name == sym::clone {
+                if block.stmts.is_empty()
+                    && let Some(expr) = block.expr
+                    && let ExprKind::Unary(UnOp::Deref, inner) = expr.kind
+                    && let ExprKind::Path(qpath) = inner.kind
+                    && last_path_segment(&qpath).ident.name == symbol::kw::SelfLower
+                {} else {
+                    span_lint_and_sugg(
+                        cx,
+                        INCORRECT_CLONE_IMPL_ON_COPY_TYPE,
+                        block.span,
+                        "incorrect implementation of `clone` on a `Copy` type",
+                        "change this to",
+                        "{ *self }".to_owned(),
+                        Applicability::MaybeIncorrect,
+                    );
+
+                    return;
+                }
+            }
+
+            if impl_item.ident.name == sym::clone_from {
+                span_lint_and_sugg(
+                    cx,
+                    INCORRECT_CLONE_IMPL_ON_COPY_TYPE,
+                    impl_item.span,
+                    "incorrect implementation of `clone_from` on a `Copy` type",
+                    "remove this",
+                    String::new(),
+                    Applicability::MaybeIncorrect,
+                );
+
+                return;
+            }
+        }
+    }
+}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index e07959849a3..b254c05d48b 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -150,6 +150,7 @@ mod implicit_return;
 mod implicit_saturating_add;
 mod implicit_saturating_sub;
 mod inconsistent_struct_constructor;
+mod incorrect_impls;
 mod index_refutable_slice;
 mod indexing_slicing;
 mod infinite_iter;
@@ -226,7 +227,6 @@ mod needless_continue;
 mod needless_else;
 mod needless_for_each;
 mod needless_if;
-mod needless_impls;
 mod needless_late_init;
 mod needless_parens_on_range_literals;
 mod needless_pass_by_value;
@@ -1048,7 +1048,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     let stack_size_threshold = conf.stack_size_threshold;
     store.register_late_pass(move |_| Box::new(large_stack_frames::LargeStackFrames::new(stack_size_threshold)));
     store.register_late_pass(|_| Box::new(single_range_in_vec_init::SingleRangeInVecInit));
-    store.register_late_pass(|_| Box::new(needless_impls::NeedlessImpls));
+    store.register_late_pass(|_| Box::new(incorrect_impls::IncorrectImpls));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/needless_impls.rs b/clippy_lints/src/needless_impls.rs
deleted file mode 100644
index ccfd55886ec..00000000000
--- a/clippy_lints/src/needless_impls.rs
+++ /dev/null
@@ -1,109 +0,0 @@
-use clippy_utils::{diagnostics::span_lint_and_sugg, get_parent_node, last_path_segment, ty::implements_trait};
-use rustc_errors::Applicability;
-use rustc_hir::{ExprKind, ImplItem, ImplItemKind, ItemKind, Node, UnOp};
-use rustc_hir_analysis::hir_ty_to_ty;
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty::EarlyBinder;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::{sym, symbol};
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for manual implementations of `Clone` when `Copy` is already implemented.
-    ///
-    /// ### Why is this bad?
-    /// If both `Clone` and `Copy` are implemented, they must agree. This is done by dereferencing
-    /// `self` in `Clone`'s implementation. Anything else is incorrect.
-    ///
-    /// ### Example
-    /// ```rust,ignore
-    /// #[derive(Eq, PartialEq)]
-    /// struct A(u32);
-    ///
-    /// impl Clone for A {
-    ///     fn clone(&self) -> Self {
-    ///         Self(self.0)
-    ///     }
-    /// }
-    ///
-    /// impl Copy for A {}
-    /// ```
-    /// Use instead:
-    /// ```rust,ignore
-    /// #[derive(Eq, PartialEq)]
-    /// struct A(u32);
-    ///
-    /// impl Clone for A {
-    ///     fn clone(&self) -> Self {
-    ///         *self
-    ///     }
-    /// }
-    ///
-    /// impl Copy for A {}
-    /// ```
-    #[clippy::version = "1.72.0"]
-    pub NEEDLESS_CLONE_IMPL,
-    correctness,
-    "manual implementation of `Clone` on a `Copy` type"
-}
-declare_lint_pass!(NeedlessImpls => [NEEDLESS_CLONE_IMPL]);
-
-impl LateLintPass<'_> for NeedlessImpls {
-    #[expect(clippy::needless_return)]
-    fn check_impl_item(&mut self, cx: &LateContext<'_>, impl_item: &ImplItem<'_>) {
-        let node = get_parent_node(cx.tcx, impl_item.hir_id());
-        let Some(Node::Item(item)) = node else {
-            return;
-        };
-        let ItemKind::Impl(imp) = item.kind else {
-            return;
-        };
-        let Some(trait_impl) = cx.tcx.impl_trait_ref(item.owner_id).map(EarlyBinder::skip_binder) else {
-            return;
-        };
-        let trait_impl_def_id = trait_impl.def_id;
-        if cx.tcx.is_automatically_derived(item.owner_id.to_def_id()) {
-            return;
-        }
-        let ImplItemKind::Fn(_, impl_item_id) = cx.tcx.hir().impl_item(impl_item.impl_item_id()).kind else {
-            return;
-        };
-        let body = cx.tcx.hir().body(impl_item_id);
-        let ExprKind::Block(block, ..) = body.value.kind else {
-            return;
-        };
-        // Above is duplicated from the `duplicate_manual_partial_ord_impl` branch.
-        // Remove it while solving conflicts once that PR is merged.
-
-        // Actual implementation; remove this comment once aforementioned PR is merged
-        if cx.tcx.is_diagnostic_item(sym::Clone, trait_impl_def_id)
-            && impl_item.ident.name == sym::clone
-            && let Some(copy_def_id) = cx.tcx.get_diagnostic_item(sym::Copy)
-            && implements_trait(
-                    cx,
-                    hir_ty_to_ty(cx.tcx, imp.self_ty),
-                    copy_def_id,
-                    trait_impl.substs,
-                )
-        {
-            if block.stmts.is_empty()
-                && let Some(expr) = block.expr
-                && let ExprKind::Unary(UnOp::Deref, inner) = expr.kind
-                && let ExprKind::Path(qpath) = inner.kind
-                && last_path_segment(&qpath).ident.name == symbol::kw::SelfLower
-            {} else {
-                span_lint_and_sugg(
-                    cx,
-                    NEEDLESS_CLONE_IMPL,
-                    block.span,
-                    "manual implementation of `Clone` on a `Copy` type",
-                    "change this to",
-                    "{ *self }".to_owned(),
-                    Applicability::Unspecified,
-                );
-
-                return;
-            }
-        }
-    }
-}
diff --git a/tests/ui/clone_on_copy_impl.rs b/tests/ui/clone_on_copy_impl.rs
index 06d8ad48446..b7c186bef77 100644
--- a/tests/ui/clone_on_copy_impl.rs
+++ b/tests/ui/clone_on_copy_impl.rs
@@ -1,4 +1,4 @@
-#![allow(clippy::needless_clone_impl)]
+#![allow(clippy::incorrect_clone_impl_on_copy_type)]
 
 use std::fmt;
 use std::marker::PhantomData;
diff --git a/tests/ui/derive.rs b/tests/ui/derive.rs
index 857cd379fe2..44e18bff83f 100644
--- a/tests/ui/derive.rs
+++ b/tests/ui/derive.rs
@@ -1,4 +1,4 @@
-#![allow(clippy::needless_clone_impl, dead_code)]
+#![allow(clippy::incorrect_clone_impl_on_copy_type, dead_code)]
 #![warn(clippy::expl_impl_clone_on_copy)]
 
 #[derive(Copy)]
diff --git a/tests/ui/incorrect_clone_impl_on_copy_type.fixed b/tests/ui/incorrect_clone_impl_on_copy_type.fixed
new file mode 100644
index 00000000000..ac482dcda1e
--- /dev/null
+++ b/tests/ui/incorrect_clone_impl_on_copy_type.fixed
@@ -0,0 +1,97 @@
+//@run-rustfix
+#![allow(clippy::clone_on_copy, unused)]
+#![no_main]
+
+// lint
+
+struct A(u32);
+
+impl Clone for A {
+    fn clone(&self) -> Self { *self }
+
+    
+}
+
+impl Copy for A {}
+
+// do not lint
+
+struct B(u32);
+
+impl Clone for B {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+
+impl Copy for B {}
+
+// do not lint derived (clone's implementation is `*self` here anyway)
+
+#[derive(Clone, Copy)]
+struct C(u32);
+
+// do not lint derived (fr this time)
+
+struct D(u32);
+
+#[automatically_derived]
+impl Clone for D {
+    fn clone(&self) -> Self {
+        Self(self.0)
+    }
+
+    fn clone_from(&mut self, source: &Self) {
+        source.clone();
+        *self = source.clone();
+    }
+}
+
+impl Copy for D {}
+
+// do not lint if clone is not manually implemented
+
+struct E(u32);
+
+#[automatically_derived]
+impl Clone for E {
+    fn clone(&self) -> Self {
+        Self(self.0)
+    }
+
+    fn clone_from(&mut self, source: &Self) {
+        source.clone();
+        *self = source.clone();
+    }
+}
+
+impl Copy for E {}
+
+// lint since clone is not derived
+
+#[derive(Copy)]
+struct F(u32);
+
+impl Clone for F {
+    fn clone(&self) -> Self { *self }
+
+    
+}
+
+// do not lint since copy has more restrictive bounds
+
+#[derive(Eq, PartialEq)]
+struct Uwu<A: Copy>(A);
+
+impl<A: Copy> Clone for Uwu<A> {
+    fn clone(&self) -> Self {
+        Self(self.0)
+    }
+
+    fn clone_from(&mut self, source: &Self) {
+        source.clone();
+        *self = source.clone();
+    }
+}
+
+impl<A: std::fmt::Debug + Copy + Clone> Copy for Uwu<A> {}
diff --git a/tests/ui/incorrect_clone_impl_on_copy_type.rs b/tests/ui/incorrect_clone_impl_on_copy_type.rs
new file mode 100644
index 00000000000..00775874ff5
--- /dev/null
+++ b/tests/ui/incorrect_clone_impl_on_copy_type.rs
@@ -0,0 +1,107 @@
+//@run-rustfix
+#![allow(clippy::clone_on_copy, unused)]
+#![no_main]
+
+// lint
+
+struct A(u32);
+
+impl Clone for A {
+    fn clone(&self) -> Self {
+        Self(self.0)
+    }
+
+    fn clone_from(&mut self, source: &Self) {
+        source.clone();
+        *self = source.clone();
+    }
+}
+
+impl Copy for A {}
+
+// do not lint
+
+struct B(u32);
+
+impl Clone for B {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+
+impl Copy for B {}
+
+// do not lint derived (clone's implementation is `*self` here anyway)
+
+#[derive(Clone, Copy)]
+struct C(u32);
+
+// do not lint derived (fr this time)
+
+struct D(u32);
+
+#[automatically_derived]
+impl Clone for D {
+    fn clone(&self) -> Self {
+        Self(self.0)
+    }
+
+    fn clone_from(&mut self, source: &Self) {
+        source.clone();
+        *self = source.clone();
+    }
+}
+
+impl Copy for D {}
+
+// do not lint if clone is not manually implemented
+
+struct E(u32);
+
+#[automatically_derived]
+impl Clone for E {
+    fn clone(&self) -> Self {
+        Self(self.0)
+    }
+
+    fn clone_from(&mut self, source: &Self) {
+        source.clone();
+        *self = source.clone();
+    }
+}
+
+impl Copy for E {}
+
+// lint since clone is not derived
+
+#[derive(Copy)]
+struct F(u32);
+
+impl Clone for F {
+    fn clone(&self) -> Self {
+        Self(self.0)
+    }
+
+    fn clone_from(&mut self, source: &Self) {
+        source.clone();
+        *self = source.clone();
+    }
+}
+
+// do not lint since copy has more restrictive bounds
+
+#[derive(Eq, PartialEq)]
+struct Uwu<A: Copy>(A);
+
+impl<A: Copy> Clone for Uwu<A> {
+    fn clone(&self) -> Self {
+        Self(self.0)
+    }
+
+    fn clone_from(&mut self, source: &Self) {
+        source.clone();
+        *self = source.clone();
+    }
+}
+
+impl<A: std::fmt::Debug + Copy + Clone> Copy for Uwu<A> {}
diff --git a/tests/ui/incorrect_clone_impl_on_copy_type.stderr b/tests/ui/incorrect_clone_impl_on_copy_type.stderr
new file mode 100644
index 00000000000..0021841aa86
--- /dev/null
+++ b/tests/ui/incorrect_clone_impl_on_copy_type.stderr
@@ -0,0 +1,40 @@
+error: incorrect implementation of `clone` on a `Copy` type
+  --> $DIR/incorrect_clone_impl_on_copy_type.rs:10:29
+   |
+LL |       fn clone(&self) -> Self {
+   |  _____________________________^
+LL | |         Self(self.0)
+LL | |     }
+   | |_____^ help: change this to: `{ *self }`
+   |
+   = note: `#[deny(clippy::incorrect_clone_impl_on_copy_type)]` on by default
+
+error: incorrect implementation of `clone_from` on a `Copy` type
+  --> $DIR/incorrect_clone_impl_on_copy_type.rs:14:5
+   |
+LL | /     fn clone_from(&mut self, source: &Self) {
+LL | |         source.clone();
+LL | |         *self = source.clone();
+LL | |     }
+   | |_____^ help: remove this
+
+error: incorrect implementation of `clone` on a `Copy` type
+  --> $DIR/incorrect_clone_impl_on_copy_type.rs:81:29
+   |
+LL |       fn clone(&self) -> Self {
+   |  _____________________________^
+LL | |         Self(self.0)
+LL | |     }
+   | |_____^ help: change this to: `{ *self }`
+
+error: incorrect implementation of `clone_from` on a `Copy` type
+  --> $DIR/incorrect_clone_impl_on_copy_type.rs:85:5
+   |
+LL | /     fn clone_from(&mut self, source: &Self) {
+LL | |         source.clone();
+LL | |         *self = source.clone();
+LL | |     }
+   | |_____^ help: remove this
+
+error: aborting due to 4 previous errors
+
diff --git a/tests/ui/needless_clone_impl.fixed b/tests/ui/needless_clone_impl.fixed
deleted file mode 100644
index 05caf485db6..00000000000
--- a/tests/ui/needless_clone_impl.fixed
+++ /dev/null
@@ -1,69 +0,0 @@
-//@run-rustfix
-#![allow(unused)]
-#![no_main]
-
-// lint
-
-struct A(u32);
-
-impl Clone for A {
-    fn clone(&self) -> Self { *self }
-}
-
-impl Copy for A {}
-
-// do not lint
-
-struct B(u32);
-
-impl Clone for B {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-
-impl Copy for B {}
-
-// do not lint derived (clone's implementation is `*self` here anyway)
-
-#[derive(Clone, Copy)]
-struct C(u32);
-
-// do not lint derived (fr this time)
-
-struct D(u32);
-
-#[automatically_derived]
-impl Clone for D {
-    fn clone(&self) -> Self {
-        Self(self.0)
-    }
-}
-
-impl Copy for D {}
-
-// do not lint if clone is not manually implemented
-
-struct E(u32);
-
-#[automatically_derived]
-impl Clone for E {
-    fn clone(&self) -> Self {
-        Self(self.0)
-    }
-}
-
-impl Copy for E {}
-
-// do not lint since copy has more restrictive bounds
-
-#[derive(Eq, PartialEq)]
-struct Uwu<A: Copy>(A);
-
-impl<A: Copy> Clone for Uwu<A> {
-    fn clone(&self) -> Self {
-        Self(self.0)
-    }
-}
-
-impl<A: std::fmt::Debug + Copy + Clone> Copy for Uwu<A> {}
diff --git a/tests/ui/needless_clone_impl.rs b/tests/ui/needless_clone_impl.rs
deleted file mode 100644
index e30469e09e8..00000000000
--- a/tests/ui/needless_clone_impl.rs
+++ /dev/null
@@ -1,71 +0,0 @@
-//@run-rustfix
-#![allow(unused)]
-#![no_main]
-
-// lint
-
-struct A(u32);
-
-impl Clone for A {
-    fn clone(&self) -> Self {
-        Self(self.0)
-    }
-}
-
-impl Copy for A {}
-
-// do not lint
-
-struct B(u32);
-
-impl Clone for B {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-
-impl Copy for B {}
-
-// do not lint derived (clone's implementation is `*self` here anyway)
-
-#[derive(Clone, Copy)]
-struct C(u32);
-
-// do not lint derived (fr this time)
-
-struct D(u32);
-
-#[automatically_derived]
-impl Clone for D {
-    fn clone(&self) -> Self {
-        Self(self.0)
-    }
-}
-
-impl Copy for D {}
-
-// do not lint if clone is not manually implemented
-
-struct E(u32);
-
-#[automatically_derived]
-impl Clone for E {
-    fn clone(&self) -> Self {
-        Self(self.0)
-    }
-}
-
-impl Copy for E {}
-
-// do not lint since copy has more restrictive bounds
-
-#[derive(Eq, PartialEq)]
-struct Uwu<A: Copy>(A);
-
-impl<A: Copy> Clone for Uwu<A> {
-    fn clone(&self) -> Self {
-        Self(self.0)
-    }
-}
-
-impl<A: std::fmt::Debug + Copy + Clone> Copy for Uwu<A> {}
diff --git a/tests/ui/needless_clone_impl.stderr b/tests/ui/needless_clone_impl.stderr
deleted file mode 100644
index 51e2ef4f741..00000000000
--- a/tests/ui/needless_clone_impl.stderr
+++ /dev/null
@@ -1,13 +0,0 @@
-error: manual implementation of `Clone` on a `Copy` type
-  --> $DIR/needless_clone_impl.rs:10:29
-   |
-LL |       fn clone(&self) -> Self {
-   |  _____________________________^
-LL | |         Self(self.0)
-LL | |     }
-   | |_____^ help: change this to: `{ *self }`
-   |
-   = note: `#[deny(clippy::needless_clone_impl)]` on by default
-
-error: aborting due to previous error
-
diff --git a/tests/ui/unnecessary_struct_initialization.fixed b/tests/ui/unnecessary_struct_initialization.fixed
index aec9725c4b9..eae1271d1aa 100644
--- a/tests/ui/unnecessary_struct_initialization.fixed
+++ b/tests/ui/unnecessary_struct_initialization.fixed
@@ -1,6 +1,6 @@
 //@run-rustfix
 
-#![allow(clippy::needless_clone_impl, unused)]
+#![allow(clippy::incorrect_clone_impl_on_copy_type, unused)]
 #![warn(clippy::unnecessary_struct_initialization)]
 
 struct S {
diff --git a/tests/ui/unnecessary_struct_initialization.rs b/tests/ui/unnecessary_struct_initialization.rs
index a3b9b88dbc2..4abd560f84b 100644
--- a/tests/ui/unnecessary_struct_initialization.rs
+++ b/tests/ui/unnecessary_struct_initialization.rs
@@ -1,6 +1,6 @@
 //@run-rustfix
 
-#![allow(clippy::needless_clone_impl, unused)]
+#![allow(clippy::incorrect_clone_impl_on_copy_type, unused)]
 #![warn(clippy::unnecessary_struct_initialization)]
 
 struct S {
-- 
cgit 1.4.1-3-g733a5


From 2748ab9565100dedfe170c899fe1f7f0791677d2 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Sat, 27 May 2023 00:58:44 +0200
Subject: new lint: `drain_collect`

---
 CHANGELOG.md                              |  1 +
 clippy_lints/src/declared_lints.rs        |  1 +
 clippy_lints/src/methods/drain_collect.rs | 77 +++++++++++++++++++++++++++++++
 clippy_lints/src/methods/mod.rs           | 41 ++++++++++++++++
 tests/ui/drain_collect.rs                 | 65 ++++++++++++++++++++++++++
 tests/ui/drain_collect.stderr             | 62 +++++++++++++++++++++++++
 tests/ui/iter_with_drain.fixed            |  2 +-
 tests/ui/iter_with_drain.rs               |  2 +-
 8 files changed, 249 insertions(+), 2 deletions(-)
 create mode 100644 clippy_lints/src/methods/drain_collect.rs
 create mode 100644 tests/ui/drain_collect.rs
 create mode 100644 tests/ui/drain_collect.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 218bca40cb0..ad7a101d38a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4737,6 +4737,7 @@ Released 2018-09-13
 [`double_must_use`]: https://rust-lang.github.io/rust-clippy/master/index.html#double_must_use
 [`double_neg`]: https://rust-lang.github.io/rust-clippy/master/index.html#double_neg
 [`double_parens`]: https://rust-lang.github.io/rust-clippy/master/index.html#double_parens
+[`drain_collect`]: https://rust-lang.github.io/rust-clippy/master/index.html#drain_collect
 [`drop_bounds`]: https://rust-lang.github.io/rust-clippy/master/index.html#drop_bounds
 [`drop_copy`]: https://rust-lang.github.io/rust-clippy/master/index.html#drop_copy
 [`drop_non_drop`]: https://rust-lang.github.io/rust-clippy/master/index.html#drop_non_drop
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 9509e6d016a..b726f343ffe 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -324,6 +324,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::methods::CLONE_ON_COPY_INFO,
     crate::methods::CLONE_ON_REF_PTR_INFO,
     crate::methods::COLLAPSIBLE_STR_REPLACE_INFO,
+    crate::methods::DRAIN_COLLECT_INFO,
     crate::methods::ERR_EXPECT_INFO,
     crate::methods::EXPECT_FUN_CALL_INFO,
     crate::methods::EXPECT_USED_INFO,
diff --git a/clippy_lints/src/methods/drain_collect.rs b/clippy_lints/src/methods/drain_collect.rs
new file mode 100644
index 00000000000..6d9df587518
--- /dev/null
+++ b/clippy_lints/src/methods/drain_collect.rs
@@ -0,0 +1,77 @@
+use crate::methods::DRAIN_COLLECT;
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::is_range_full;
+use clippy_utils::source::snippet;
+use clippy_utils::ty::is_type_lang_item;
+use rustc_errors::Applicability;
+use rustc_hir::Expr;
+use rustc_hir::ExprKind;
+use rustc_hir::LangItem;
+use rustc_hir::Path;
+use rustc_hir::QPath;
+use rustc_lint::LateContext;
+use rustc_middle::query::Key;
+use rustc_middle::ty::Ty;
+use rustc_span::sym;
+use rustc_span::Symbol;
+
+/// Checks if both types match the given diagnostic item, e.g.:
+///
+/// `vec![1,2].drain(..).collect::<Vec<_>>()`
+///  ^^^^^^^^^                     ^^^^^^   true
+/// `vec![1,2].drain(..).collect::<HashSet<_>>()`
+///  ^^^^^^^^^                     ^^^^^^^^^^  false
+fn types_match_diagnostic_item(cx: &LateContext<'_>, expr: Ty<'_>, recv: Ty<'_>, sym: Symbol) -> bool {
+    if let Some(expr_adt_did) = expr.ty_adt_id()
+        && let Some(recv_adt_did) = recv.ty_adt_id()
+    {
+        cx.tcx.is_diagnostic_item(sym, expr_adt_did) && cx.tcx.is_diagnostic_item(sym, recv_adt_did)
+    } else {
+        false
+    }
+}
+
+/// Checks `std::{vec::Vec, collections::VecDeque}`.
+fn check_vec(cx: &LateContext<'_>, args: &[Expr<'_>], expr: Ty<'_>, recv: Ty<'_>, recv_path: &Path<'_>) -> bool {
+    (types_match_diagnostic_item(cx, expr, recv, sym::Vec)
+        || types_match_diagnostic_item(cx, expr, recv, sym::VecDeque))
+        && matches!(args, [arg] if is_range_full(cx, arg, Some(recv_path)))
+}
+
+/// Checks `std::string::String`
+fn check_string(cx: &LateContext<'_>, args: &[Expr<'_>], expr: Ty<'_>, recv: Ty<'_>, recv_path: &Path<'_>) -> bool {
+    is_type_lang_item(cx, expr, LangItem::String)
+        && is_type_lang_item(cx, recv, LangItem::String)
+        && matches!(args, [arg] if is_range_full(cx, arg, Some(recv_path)))
+}
+
+/// Checks `std::collections::{HashSet, HashMap, BinaryHeap}`.
+fn check_collections(cx: &LateContext<'_>, expr: Ty<'_>, recv: Ty<'_>) -> Option<&'static str> {
+    types_match_diagnostic_item(cx, expr, recv, sym::HashSet)
+        .then_some("HashSet")
+        .or_else(|| types_match_diagnostic_item(cx, expr, recv, sym::HashMap).then_some("HashMap"))
+        .or_else(|| types_match_diagnostic_item(cx, expr, recv, sym::BinaryHeap).then_some("BinaryHeap"))
+}
+
+pub(super) fn check(cx: &LateContext<'_>, args: &[Expr<'_>], expr: &Expr<'_>, recv: &Expr<'_>) {
+    let expr_ty = cx.typeck_results().expr_ty(expr);
+    let recv_ty = cx.typeck_results().expr_ty(recv).peel_refs();
+
+    if let ExprKind::Path(QPath::Resolved(_, recv_path)) = recv.kind
+        && let Some(typename) = check_vec(cx, args, expr_ty, recv_ty, recv_path)
+            .then_some("Vec")
+            .or_else(|| check_string(cx, args, expr_ty, recv_ty, recv_path).then_some("String"))
+            .or_else(|| check_collections(cx, expr_ty, recv_ty))
+    {
+        let recv = snippet(cx, recv.span, "<expr>");
+        span_lint_and_sugg(
+            cx,
+            DRAIN_COLLECT,
+            expr.span,
+            &format!("you seem to be trying to move all elements into a new `{typename}`"),
+            "consider using `mem::take`",
+            format!("std::mem::take(&mut {recv})"),
+            Applicability::MachineApplicable,
+        );
+    }
+}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 183bd582a48..faddb036eaa 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -14,6 +14,7 @@ mod clone_on_copy;
 mod clone_on_ref_ptr;
 mod cloned_instead_of_copied;
 mod collapsible_str_replace;
+mod drain_collect;
 mod err_expect;
 mod expect_fun_call;
 mod expect_used;
@@ -3247,6 +3248,42 @@ declare_clippy_lint! {
     "manual reverse iteration of `DoubleEndedIterator`"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for calls to `.drain()` that clear the collection, immediately followed by a call to `.collect()`.
+    ///
+    /// > "Collection" in this context refers to any type with a `drain` method:
+    /// > `Vec`, `VecDeque`, `BinaryHeap`, `HashSet`,`HashMap`, `String`
+    ///
+    /// ### Why is this bad?
+    /// Using `mem::take` is faster as it avoids the allocation.
+    /// When using `mem::take`, the old collection is replaced with an empty one and ownership of
+    /// the old collection is returned.
+    ///
+    /// ### Drawback
+    /// `mem::take(&mut vec)` is almost equivalent to `vec.drain(..).collect()`, except that
+    /// it also moves the **capacity**. The user might have explicitly written it this way
+    /// to keep the capacity on the original `Vec`.
+    ///
+    /// ### Example
+    /// ```rust
+    /// fn remove_all(v: &mut Vec<i32>) -> Vec<i32> {
+    ///     v.drain(..).collect()
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// use std::mem;
+    /// fn remove_all(v: &mut Vec<i32>) -> Vec<i32> {
+    ///     mem::take(v)
+    /// }
+    /// ```
+    #[clippy::version = "1.71.0"]
+    pub DRAIN_COLLECT,
+    perf,
+    "description"
+}
+
 pub struct Methods {
     avoid_breaking_exported_api: bool,
     msrv: Msrv,
@@ -3377,6 +3414,7 @@ impl_lint_pass!(Methods => [
     CLEAR_WITH_DRAIN,
     MANUAL_NEXT_BACK,
     UNNECESSARY_LITERAL_UNWRAP,
+    DRAIN_COLLECT
 ]);
 
 /// Extracts a method call name, args, and `Span` of the method name.
@@ -3606,6 +3644,9 @@ impl Methods {
                                 manual_str_repeat::check(cx, expr, recv, take_self_arg, take_arg);
                             }
                         },
+                        Some(("drain", recv, args, ..)) => {
+                            drain_collect::check(cx, args, expr, recv);
+                        }
                         _ => {},
                     }
                 },
diff --git a/tests/ui/drain_collect.rs b/tests/ui/drain_collect.rs
new file mode 100644
index 00000000000..1bedab75c03
--- /dev/null
+++ b/tests/ui/drain_collect.rs
@@ -0,0 +1,65 @@
+#![deny(clippy::drain_collect)]
+
+use std::collections::{BinaryHeap, HashMap, HashSet, VecDeque};
+
+fn binaryheap(b: &mut BinaryHeap<i32>) -> BinaryHeap<i32> {
+    b.drain().collect()
+}
+
+fn binaryheap_dont_lint(b: &mut BinaryHeap<i32>) -> HashSet<i32> {
+    b.drain().collect()
+}
+
+fn hashmap(b: &mut HashMap<i32, i32>) -> HashMap<i32, i32> {
+    b.drain().collect()
+}
+
+fn hashmap_dont_lint(b: &mut HashMap<i32, i32>) -> Vec<(i32, i32)> {
+    b.drain().collect()
+}
+
+fn hashset(b: &mut HashSet<i32>) -> HashSet<i32> {
+    b.drain().collect()
+}
+
+fn hashset_dont_lint(b: &mut HashSet<i32>) -> Vec<i32> {
+    b.drain().collect()
+}
+
+fn vecdeque(b: &mut VecDeque<i32>) -> VecDeque<i32> {
+    b.drain(..).collect()
+}
+
+fn vecdeque_dont_lint(b: &mut VecDeque<i32>) -> HashSet<i32> {
+    b.drain(..).collect()
+}
+
+fn vec(b: &mut Vec<i32>) -> Vec<i32> {
+    b.drain(..).collect()
+}
+
+fn vec2(b: &mut Vec<i32>) -> Vec<i32> {
+    b.drain(0..).collect()
+}
+
+fn vec3(b: &mut Vec<i32>) -> Vec<i32> {
+    b.drain(..b.len()).collect()
+}
+
+fn vec4(b: &mut Vec<i32>) -> Vec<i32> {
+    b.drain(0..b.len()).collect()
+}
+
+fn vec_dont_lint(b: &mut Vec<i32>) -> HashSet<i32> {
+    b.drain(..).collect()
+}
+
+fn string(b: &mut String) -> String {
+    b.drain(..).collect()
+}
+
+fn string_dont_lint(b: &mut String) -> HashSet<char> {
+    b.drain(..).collect()
+}
+
+fn main() {}
diff --git a/tests/ui/drain_collect.stderr b/tests/ui/drain_collect.stderr
new file mode 100644
index 00000000000..d4e2b4a6fa2
--- /dev/null
+++ b/tests/ui/drain_collect.stderr
@@ -0,0 +1,62 @@
+error: you seem to be trying to move all elements into a new `BinaryHeap`
+  --> $DIR/drain_collect.rs:6:5
+   |
+LL |     b.drain().collect()
+   |     ^^^^^^^^^^^^^^^^^^^ help: consider using `mem::take`: `std::mem::take(&mut b)`
+   |
+note: the lint level is defined here
+  --> $DIR/drain_collect.rs:1:9
+   |
+LL | #![deny(clippy::drain_collect)]
+   |         ^^^^^^^^^^^^^^^^^^^^^
+
+error: you seem to be trying to move all elements into a new `HashMap`
+  --> $DIR/drain_collect.rs:14:5
+   |
+LL |     b.drain().collect()
+   |     ^^^^^^^^^^^^^^^^^^^ help: consider using `mem::take`: `std::mem::take(&mut b)`
+
+error: you seem to be trying to move all elements into a new `HashSet`
+  --> $DIR/drain_collect.rs:22:5
+   |
+LL |     b.drain().collect()
+   |     ^^^^^^^^^^^^^^^^^^^ help: consider using `mem::take`: `std::mem::take(&mut b)`
+
+error: you seem to be trying to move all elements into a new `Vec`
+  --> $DIR/drain_collect.rs:30:5
+   |
+LL |     b.drain(..).collect()
+   |     ^^^^^^^^^^^^^^^^^^^^^ help: consider using `mem::take`: `std::mem::take(&mut b)`
+
+error: you seem to be trying to move all elements into a new `Vec`
+  --> $DIR/drain_collect.rs:38:5
+   |
+LL |     b.drain(..).collect()
+   |     ^^^^^^^^^^^^^^^^^^^^^ help: consider using `mem::take`: `std::mem::take(&mut b)`
+
+error: you seem to be trying to move all elements into a new `Vec`
+  --> $DIR/drain_collect.rs:42:5
+   |
+LL |     b.drain(0..).collect()
+   |     ^^^^^^^^^^^^^^^^^^^^^^ help: consider using `mem::take`: `std::mem::take(&mut b)`
+
+error: you seem to be trying to move all elements into a new `Vec`
+  --> $DIR/drain_collect.rs:46:5
+   |
+LL |     b.drain(..b.len()).collect()
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `mem::take`: `std::mem::take(&mut b)`
+
+error: you seem to be trying to move all elements into a new `Vec`
+  --> $DIR/drain_collect.rs:50:5
+   |
+LL |     b.drain(0..b.len()).collect()
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `mem::take`: `std::mem::take(&mut b)`
+
+error: you seem to be trying to move all elements into a new `String`
+  --> $DIR/drain_collect.rs:58:5
+   |
+LL |     b.drain(..).collect()
+   |     ^^^^^^^^^^^^^^^^^^^^^ help: consider using `mem::take`: `std::mem::take(&mut b)`
+
+error: aborting due to 9 previous errors
+
diff --git a/tests/ui/iter_with_drain.fixed b/tests/ui/iter_with_drain.fixed
index 24a95c4d0fe..7a8c6770101 100644
--- a/tests/ui/iter_with_drain.fixed
+++ b/tests/ui/iter_with_drain.fixed
@@ -2,7 +2,7 @@
 // will emits unused mut warnings after fixing
 #![allow(unused_mut)]
 // will emits needless collect warnings after fixing
-#![allow(clippy::needless_collect)]
+#![allow(clippy::needless_collect, clippy::drain_collect)]
 #![warn(clippy::iter_with_drain)]
 use std::collections::{BinaryHeap, HashMap, HashSet, VecDeque};
 
diff --git a/tests/ui/iter_with_drain.rs b/tests/ui/iter_with_drain.rs
index a118c981ee3..cf3a935c349 100644
--- a/tests/ui/iter_with_drain.rs
+++ b/tests/ui/iter_with_drain.rs
@@ -2,7 +2,7 @@
 // will emits unused mut warnings after fixing
 #![allow(unused_mut)]
 // will emits needless collect warnings after fixing
-#![allow(clippy::needless_collect)]
+#![allow(clippy::needless_collect, clippy::drain_collect)]
 #![warn(clippy::iter_with_drain)]
 use std::collections::{BinaryHeap, HashMap, HashSet, VecDeque};
 
-- 
cgit 1.4.1-3-g733a5


From d2a6ec2d4d7930401d2600edfdac1cd964ebe55c Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Sat, 27 May 2023 01:31:55 +0200
Subject: take into account reborrowing when inserting `&mut` in sugg

---
 clippy_lints/src/methods/drain_collect.rs | 36 ++++++++++-----
 tests/ui/drain_collect.fixed              | 73 +++++++++++++++++++++++++++++++
 tests/ui/drain_collect.rs                 |  8 ++++
 tests/ui/drain_collect.stderr             | 44 +++++++++++--------
 4 files changed, 132 insertions(+), 29 deletions(-)
 create mode 100644 tests/ui/drain_collect.fixed

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/drain_collect.rs b/clippy_lints/src/methods/drain_collect.rs
index 6d9df587518..53f63266073 100644
--- a/clippy_lints/src/methods/drain_collect.rs
+++ b/clippy_lints/src/methods/drain_collect.rs
@@ -11,7 +11,7 @@ use rustc_hir::Path;
 use rustc_hir::QPath;
 use rustc_lint::LateContext;
 use rustc_middle::query::Key;
-use rustc_middle::ty::Ty;
+use rustc_middle::ty;
 use rustc_span::sym;
 use rustc_span::Symbol;
 
@@ -21,7 +21,7 @@ use rustc_span::Symbol;
 ///  ^^^^^^^^^                     ^^^^^^   true
 /// `vec![1,2].drain(..).collect::<HashSet<_>>()`
 ///  ^^^^^^^^^                     ^^^^^^^^^^  false
-fn types_match_diagnostic_item(cx: &LateContext<'_>, expr: Ty<'_>, recv: Ty<'_>, sym: Symbol) -> bool {
+fn types_match_diagnostic_item(cx: &LateContext<'_>, expr: ty::Ty<'_>, recv: ty::Ty<'_>, sym: Symbol) -> bool {
     if let Some(expr_adt_did) = expr.ty_adt_id()
         && let Some(recv_adt_did) = recv.ty_adt_id()
     {
@@ -32,21 +32,33 @@ fn types_match_diagnostic_item(cx: &LateContext<'_>, expr: Ty<'_>, recv: Ty<'_>,
 }
 
 /// Checks `std::{vec::Vec, collections::VecDeque}`.
-fn check_vec(cx: &LateContext<'_>, args: &[Expr<'_>], expr: Ty<'_>, recv: Ty<'_>, recv_path: &Path<'_>) -> bool {
+fn check_vec(
+    cx: &LateContext<'_>,
+    args: &[Expr<'_>],
+    expr: ty::Ty<'_>,
+    recv: ty::Ty<'_>,
+    recv_path: &Path<'_>,
+) -> bool {
     (types_match_diagnostic_item(cx, expr, recv, sym::Vec)
         || types_match_diagnostic_item(cx, expr, recv, sym::VecDeque))
         && matches!(args, [arg] if is_range_full(cx, arg, Some(recv_path)))
 }
 
 /// Checks `std::string::String`
-fn check_string(cx: &LateContext<'_>, args: &[Expr<'_>], expr: Ty<'_>, recv: Ty<'_>, recv_path: &Path<'_>) -> bool {
+fn check_string(
+    cx: &LateContext<'_>,
+    args: &[Expr<'_>],
+    expr: ty::Ty<'_>,
+    recv: ty::Ty<'_>,
+    recv_path: &Path<'_>,
+) -> bool {
     is_type_lang_item(cx, expr, LangItem::String)
         && is_type_lang_item(cx, recv, LangItem::String)
         && matches!(args, [arg] if is_range_full(cx, arg, Some(recv_path)))
 }
 
 /// Checks `std::collections::{HashSet, HashMap, BinaryHeap}`.
-fn check_collections(cx: &LateContext<'_>, expr: Ty<'_>, recv: Ty<'_>) -> Option<&'static str> {
+fn check_collections(cx: &LateContext<'_>, expr: ty::Ty<'_>, recv: ty::Ty<'_>) -> Option<&'static str> {
     types_match_diagnostic_item(cx, expr, recv, sym::HashSet)
         .then_some("HashSet")
         .or_else(|| types_match_diagnostic_item(cx, expr, recv, sym::HashMap).then_some("HashMap"))
@@ -55,13 +67,14 @@ fn check_collections(cx: &LateContext<'_>, expr: Ty<'_>, recv: Ty<'_>) -> Option
 
 pub(super) fn check(cx: &LateContext<'_>, args: &[Expr<'_>], expr: &Expr<'_>, recv: &Expr<'_>) {
     let expr_ty = cx.typeck_results().expr_ty(expr);
-    let recv_ty = cx.typeck_results().expr_ty(recv).peel_refs();
+    let recv_ty = cx.typeck_results().expr_ty(recv);
+    let recv_ty_no_refs = recv_ty.peel_refs();
 
     if let ExprKind::Path(QPath::Resolved(_, recv_path)) = recv.kind
-        && let Some(typename) = check_vec(cx, args, expr_ty, recv_ty, recv_path)
+        && let Some(typename) = check_vec(cx, args, expr_ty, recv_ty_no_refs, recv_path)
             .then_some("Vec")
-            .or_else(|| check_string(cx, args, expr_ty, recv_ty, recv_path).then_some("String"))
-            .or_else(|| check_collections(cx, expr_ty, recv_ty))
+            .or_else(|| check_string(cx, args, expr_ty, recv_ty_no_refs, recv_path).then_some("String"))
+            .or_else(|| check_collections(cx, expr_ty, recv_ty_no_refs))
     {
         let recv = snippet(cx, recv.span, "<expr>");
         span_lint_and_sugg(
@@ -70,7 +83,10 @@ pub(super) fn check(cx: &LateContext<'_>, args: &[Expr<'_>], expr: &Expr<'_>, re
             expr.span,
             &format!("you seem to be trying to move all elements into a new `{typename}`"),
             "consider using `mem::take`",
-            format!("std::mem::take(&mut {recv})"),
+            match recv_ty.kind() {
+                ty::Ref(..) => format!("std::mem::take({recv})"),
+                _ => format!("std::mem::take(&mut {recv})"),
+            },
             Applicability::MachineApplicable,
         );
     }
diff --git a/tests/ui/drain_collect.fixed b/tests/ui/drain_collect.fixed
new file mode 100644
index 00000000000..0d40a648378
--- /dev/null
+++ b/tests/ui/drain_collect.fixed
@@ -0,0 +1,73 @@
+//@run-rustfix
+
+#![deny(clippy::drain_collect)]
+#![allow(dead_code)]
+
+use std::collections::{BinaryHeap, HashMap, HashSet, VecDeque};
+
+fn binaryheap(b: &mut BinaryHeap<i32>) -> BinaryHeap<i32> {
+    std::mem::take(b)
+}
+
+fn binaryheap_dont_lint(b: &mut BinaryHeap<i32>) -> HashSet<i32> {
+    b.drain().collect()
+}
+
+fn hashmap(b: &mut HashMap<i32, i32>) -> HashMap<i32, i32> {
+    std::mem::take(b)
+}
+
+fn hashmap_dont_lint(b: &mut HashMap<i32, i32>) -> Vec<(i32, i32)> {
+    b.drain().collect()
+}
+
+fn hashset(b: &mut HashSet<i32>) -> HashSet<i32> {
+    std::mem::take(b)
+}
+
+fn hashset_dont_lint(b: &mut HashSet<i32>) -> Vec<i32> {
+    b.drain().collect()
+}
+
+fn vecdeque(b: &mut VecDeque<i32>) -> VecDeque<i32> {
+    std::mem::take(b)
+}
+
+fn vecdeque_dont_lint(b: &mut VecDeque<i32>) -> HashSet<i32> {
+    b.drain(..).collect()
+}
+
+fn vec(b: &mut Vec<i32>) -> Vec<i32> {
+    std::mem::take(b)
+}
+
+fn vec2(b: &mut Vec<i32>) -> Vec<i32> {
+    std::mem::take(b)
+}
+
+fn vec3(b: &mut Vec<i32>) -> Vec<i32> {
+    std::mem::take(b)
+}
+
+fn vec4(b: &mut Vec<i32>) -> Vec<i32> {
+    std::mem::take(b)
+}
+
+fn vec_no_reborrow() -> Vec<i32> {
+    let mut b = vec![1, 2, 3];
+    std::mem::take(&mut b)
+}
+
+fn vec_dont_lint(b: &mut Vec<i32>) -> HashSet<i32> {
+    b.drain(..).collect()
+}
+
+fn string(b: &mut String) -> String {
+    std::mem::take(b)
+}
+
+fn string_dont_lint(b: &mut String) -> HashSet<char> {
+    b.drain(..).collect()
+}
+
+fn main() {}
diff --git a/tests/ui/drain_collect.rs b/tests/ui/drain_collect.rs
index 1bedab75c03..7144a1847ca 100644
--- a/tests/ui/drain_collect.rs
+++ b/tests/ui/drain_collect.rs
@@ -1,4 +1,7 @@
+//@run-rustfix
+
 #![deny(clippy::drain_collect)]
+#![allow(dead_code)]
 
 use std::collections::{BinaryHeap, HashMap, HashSet, VecDeque};
 
@@ -50,6 +53,11 @@ fn vec4(b: &mut Vec<i32>) -> Vec<i32> {
     b.drain(0..b.len()).collect()
 }
 
+fn vec_no_reborrow() -> Vec<i32> {
+    let mut b = vec![1, 2, 3];
+    b.drain(..).collect()
+}
+
 fn vec_dont_lint(b: &mut Vec<i32>) -> HashSet<i32> {
     b.drain(..).collect()
 }
diff --git a/tests/ui/drain_collect.stderr b/tests/ui/drain_collect.stderr
index d4e2b4a6fa2..0792f0254cb 100644
--- a/tests/ui/drain_collect.stderr
+++ b/tests/ui/drain_collect.stderr
@@ -1,62 +1,68 @@
 error: you seem to be trying to move all elements into a new `BinaryHeap`
-  --> $DIR/drain_collect.rs:6:5
+  --> $DIR/drain_collect.rs:9:5
    |
 LL |     b.drain().collect()
-   |     ^^^^^^^^^^^^^^^^^^^ help: consider using `mem::take`: `std::mem::take(&mut b)`
+   |     ^^^^^^^^^^^^^^^^^^^ help: consider using `mem::take`: `std::mem::take(b)`
    |
 note: the lint level is defined here
-  --> $DIR/drain_collect.rs:1:9
+  --> $DIR/drain_collect.rs:3:9
    |
 LL | #![deny(clippy::drain_collect)]
    |         ^^^^^^^^^^^^^^^^^^^^^
 
 error: you seem to be trying to move all elements into a new `HashMap`
-  --> $DIR/drain_collect.rs:14:5
+  --> $DIR/drain_collect.rs:17:5
    |
 LL |     b.drain().collect()
-   |     ^^^^^^^^^^^^^^^^^^^ help: consider using `mem::take`: `std::mem::take(&mut b)`
+   |     ^^^^^^^^^^^^^^^^^^^ help: consider using `mem::take`: `std::mem::take(b)`
 
 error: you seem to be trying to move all elements into a new `HashSet`
-  --> $DIR/drain_collect.rs:22:5
+  --> $DIR/drain_collect.rs:25:5
    |
 LL |     b.drain().collect()
-   |     ^^^^^^^^^^^^^^^^^^^ help: consider using `mem::take`: `std::mem::take(&mut b)`
+   |     ^^^^^^^^^^^^^^^^^^^ help: consider using `mem::take`: `std::mem::take(b)`
 
 error: you seem to be trying to move all elements into a new `Vec`
-  --> $DIR/drain_collect.rs:30:5
+  --> $DIR/drain_collect.rs:33:5
    |
 LL |     b.drain(..).collect()
-   |     ^^^^^^^^^^^^^^^^^^^^^ help: consider using `mem::take`: `std::mem::take(&mut b)`
+   |     ^^^^^^^^^^^^^^^^^^^^^ help: consider using `mem::take`: `std::mem::take(b)`
 
 error: you seem to be trying to move all elements into a new `Vec`
-  --> $DIR/drain_collect.rs:38:5
+  --> $DIR/drain_collect.rs:41:5
    |
 LL |     b.drain(..).collect()
-   |     ^^^^^^^^^^^^^^^^^^^^^ help: consider using `mem::take`: `std::mem::take(&mut b)`
+   |     ^^^^^^^^^^^^^^^^^^^^^ help: consider using `mem::take`: `std::mem::take(b)`
 
 error: you seem to be trying to move all elements into a new `Vec`
-  --> $DIR/drain_collect.rs:42:5
+  --> $DIR/drain_collect.rs:45:5
    |
 LL |     b.drain(0..).collect()
-   |     ^^^^^^^^^^^^^^^^^^^^^^ help: consider using `mem::take`: `std::mem::take(&mut b)`
+   |     ^^^^^^^^^^^^^^^^^^^^^^ help: consider using `mem::take`: `std::mem::take(b)`
 
 error: you seem to be trying to move all elements into a new `Vec`
-  --> $DIR/drain_collect.rs:46:5
+  --> $DIR/drain_collect.rs:49:5
    |
 LL |     b.drain(..b.len()).collect()
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `mem::take`: `std::mem::take(&mut b)`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `mem::take`: `std::mem::take(b)`
 
 error: you seem to be trying to move all elements into a new `Vec`
-  --> $DIR/drain_collect.rs:50:5
+  --> $DIR/drain_collect.rs:53:5
    |
 LL |     b.drain(0..b.len()).collect()
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `mem::take`: `std::mem::take(&mut b)`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `mem::take`: `std::mem::take(b)`
 
-error: you seem to be trying to move all elements into a new `String`
+error: you seem to be trying to move all elements into a new `Vec`
   --> $DIR/drain_collect.rs:58:5
    |
 LL |     b.drain(..).collect()
    |     ^^^^^^^^^^^^^^^^^^^^^ help: consider using `mem::take`: `std::mem::take(&mut b)`
 
-error: aborting due to 9 previous errors
+error: you seem to be trying to move all elements into a new `String`
+  --> $DIR/drain_collect.rs:66:5
+   |
+LL |     b.drain(..).collect()
+   |     ^^^^^^^^^^^^^^^^^^^^^ help: consider using `mem::take`: `std::mem::take(b)`
+
+error: aborting due to 10 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 3f3657a3e4ae745339e42e377bef57f2f56ed5ff Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Sat, 27 May 2023 01:50:36 +0200
Subject: make clippy happy

---
 clippy_lints/src/methods/drain_collect.rs | 28 +++++++++-------------------
 1 file changed, 9 insertions(+), 19 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/drain_collect.rs b/clippy_lints/src/methods/drain_collect.rs
index 53f63266073..8bd8f88a214 100644
--- a/clippy_lints/src/methods/drain_collect.rs
+++ b/clippy_lints/src/methods/drain_collect.rs
@@ -12,6 +12,7 @@ use rustc_hir::QPath;
 use rustc_lint::LateContext;
 use rustc_middle::query::Key;
 use rustc_middle::ty;
+use rustc_middle::ty::Ty;
 use rustc_span::sym;
 use rustc_span::Symbol;
 
@@ -21,7 +22,7 @@ use rustc_span::Symbol;
 ///  ^^^^^^^^^                     ^^^^^^   true
 /// `vec![1,2].drain(..).collect::<HashSet<_>>()`
 ///  ^^^^^^^^^                     ^^^^^^^^^^  false
-fn types_match_diagnostic_item(cx: &LateContext<'_>, expr: ty::Ty<'_>, recv: ty::Ty<'_>, sym: Symbol) -> bool {
+fn types_match_diagnostic_item(cx: &LateContext<'_>, expr: Ty<'_>, recv: Ty<'_>, sym: Symbol) -> bool {
     if let Some(expr_adt_did) = expr.ty_adt_id()
         && let Some(recv_adt_did) = recv.ty_adt_id()
     {
@@ -32,33 +33,21 @@ fn types_match_diagnostic_item(cx: &LateContext<'_>, expr: ty::Ty<'_>, recv: ty:
 }
 
 /// Checks `std::{vec::Vec, collections::VecDeque}`.
-fn check_vec(
-    cx: &LateContext<'_>,
-    args: &[Expr<'_>],
-    expr: ty::Ty<'_>,
-    recv: ty::Ty<'_>,
-    recv_path: &Path<'_>,
-) -> bool {
+fn check_vec(cx: &LateContext<'_>, args: &[Expr<'_>], expr: Ty<'_>, recv: Ty<'_>, recv_path: &Path<'_>) -> bool {
     (types_match_diagnostic_item(cx, expr, recv, sym::Vec)
         || types_match_diagnostic_item(cx, expr, recv, sym::VecDeque))
         && matches!(args, [arg] if is_range_full(cx, arg, Some(recv_path)))
 }
 
 /// Checks `std::string::String`
-fn check_string(
-    cx: &LateContext<'_>,
-    args: &[Expr<'_>],
-    expr: ty::Ty<'_>,
-    recv: ty::Ty<'_>,
-    recv_path: &Path<'_>,
-) -> bool {
+fn check_string(cx: &LateContext<'_>, args: &[Expr<'_>], expr: Ty<'_>, recv: Ty<'_>, recv_path: &Path<'_>) -> bool {
     is_type_lang_item(cx, expr, LangItem::String)
         && is_type_lang_item(cx, recv, LangItem::String)
         && matches!(args, [arg] if is_range_full(cx, arg, Some(recv_path)))
 }
 
 /// Checks `std::collections::{HashSet, HashMap, BinaryHeap}`.
-fn check_collections(cx: &LateContext<'_>, expr: ty::Ty<'_>, recv: ty::Ty<'_>) -> Option<&'static str> {
+fn check_collections(cx: &LateContext<'_>, expr: Ty<'_>, recv: Ty<'_>) -> Option<&'static str> {
     types_match_diagnostic_item(cx, expr, recv, sym::HashSet)
         .then_some("HashSet")
         .or_else(|| types_match_diagnostic_item(cx, expr, recv, sym::HashMap).then_some("HashMap"))
@@ -83,9 +72,10 @@ pub(super) fn check(cx: &LateContext<'_>, args: &[Expr<'_>], expr: &Expr<'_>, re
             expr.span,
             &format!("you seem to be trying to move all elements into a new `{typename}`"),
             "consider using `mem::take`",
-            match recv_ty.kind() {
-                ty::Ref(..) => format!("std::mem::take({recv})"),
-                _ => format!("std::mem::take(&mut {recv})"),
+            if let ty::Ref(..) = recv_ty.kind() {
+                format!("std::mem::take({recv})")
+            } else {
+                format!("std::mem::take(&mut {recv})")
             },
             Applicability::MachineApplicable,
         );
-- 
cgit 1.4.1-3-g733a5


From 20ae597ec4dc593bb07bcd436b3ca42fcb64df42 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Thu, 8 Jun 2023 19:54:33 +0200
Subject: add a description

---
 clippy_lints/src/methods/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index faddb036eaa..bed70207f28 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3281,7 +3281,7 @@ declare_clippy_lint! {
     #[clippy::version = "1.71.0"]
     pub DRAIN_COLLECT,
     perf,
-    "description"
+    "calling `.drain(..).collect()` to move all elements into a new collection"
 }
 
 pub struct Methods {
-- 
cgit 1.4.1-3-g733a5


From 5821fbbc3072c16bc941a5e207bfd3a5e401304b Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Thu, 15 Jun 2023 14:16:39 +0200
Subject: add test case for not whole length, move sugg into variable

---
 clippy_lints/src/methods/drain_collect.rs | 12 +++++++-----
 clippy_lints/src/methods/mod.rs           |  2 +-
 tests/ui/drain_collect.fixed              |  4 ++++
 tests/ui/drain_collect.rs                 |  4 ++++
 4 files changed, 16 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/drain_collect.rs b/clippy_lints/src/methods/drain_collect.rs
index 8bd8f88a214..d0c79dc11b0 100644
--- a/clippy_lints/src/methods/drain_collect.rs
+++ b/clippy_lints/src/methods/drain_collect.rs
@@ -66,17 +66,19 @@ pub(super) fn check(cx: &LateContext<'_>, args: &[Expr<'_>], expr: &Expr<'_>, re
             .or_else(|| check_collections(cx, expr_ty, recv_ty_no_refs))
     {
         let recv = snippet(cx, recv.span, "<expr>");
+        let sugg = if let ty::Ref(..) = recv_ty.kind() {
+            format!("std::mem::take({recv})")
+        } else {
+            format!("std::mem::take(&mut {recv})")
+        };
+
         span_lint_and_sugg(
             cx,
             DRAIN_COLLECT,
             expr.span,
             &format!("you seem to be trying to move all elements into a new `{typename}`"),
             "consider using `mem::take`",
-            if let ty::Ref(..) = recv_ty.kind() {
-                format!("std::mem::take({recv})")
-            } else {
-                format!("std::mem::take(&mut {recv})")
-            },
+            sugg,
             Applicability::MachineApplicable,
         );
     }
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index bed70207f28..99c984ba65a 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3260,7 +3260,7 @@ declare_clippy_lint! {
     /// When using `mem::take`, the old collection is replaced with an empty one and ownership of
     /// the old collection is returned.
     ///
-    /// ### Drawback
+    /// ### Known issues
     /// `mem::take(&mut vec)` is almost equivalent to `vec.drain(..).collect()`, except that
     /// it also moves the **capacity**. The user might have explicitly written it this way
     /// to keep the capacity on the original `Vec`.
diff --git a/tests/ui/drain_collect.fixed b/tests/ui/drain_collect.fixed
index 0d40a648378..11001bd319f 100644
--- a/tests/ui/drain_collect.fixed
+++ b/tests/ui/drain_collect.fixed
@@ -70,4 +70,8 @@ fn string_dont_lint(b: &mut String) -> HashSet<char> {
     b.drain(..).collect()
 }
 
+fn not_whole_length(v: &mut Vec<i32>) -> Vec<i32> {
+    v.drain(1..).collect()
+}
+
 fn main() {}
diff --git a/tests/ui/drain_collect.rs b/tests/ui/drain_collect.rs
index 7144a1847ca..373a3ca3506 100644
--- a/tests/ui/drain_collect.rs
+++ b/tests/ui/drain_collect.rs
@@ -70,4 +70,8 @@ fn string_dont_lint(b: &mut String) -> HashSet<char> {
     b.drain(..).collect()
 }
 
+fn not_whole_length(v: &mut Vec<i32>) -> Vec<i32> {
+    v.drain(1..).collect()
+}
+
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 3fe2478ecf19d4d62cbdfcf50d57bc00fe5bb242 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Thu, 15 Jun 2023 22:04:25 +0200
Subject: don't unnecessarily walk more in visitor and add more tests

---
 clippy_lints/src/redundant_closure_call.rs     |  6 +++---
 tests/ui/redundant_closure_call_fixable.fixed  |  7 +++++++
 tests/ui/redundant_closure_call_fixable.rs     |  7 +++++++
 tests/ui/redundant_closure_call_fixable.stderr | 14 +++++++++++++-
 4 files changed, 30 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/redundant_closure_call.rs b/clippy_lints/src/redundant_closure_call.rs
index d979087a6d7..b6ce4ebc28f 100644
--- a/clippy_lints/src/redundant_closure_call.rs
+++ b/clippy_lints/src/redundant_closure_call.rs
@@ -55,9 +55,9 @@ impl<'tcx> Visitor<'tcx> for ReturnVisitor {
     fn visit_expr(&mut self, ex: &'tcx hir::Expr<'tcx>) {
         if let hir::ExprKind::Ret(_) | hir::ExprKind::Match(.., hir::MatchSource::TryDesugar) = ex.kind {
             self.found_return = true;
+        } else {
+            hir_visit::walk_expr(self, ex);
         }
-
-        hir_visit::walk_expr(self, ex);
     }
 }
 
@@ -122,7 +122,7 @@ fn get_parent_call_exprs<'tcx>(
     let mut depth = 1;
     while let Some(parent) = get_parent_expr(cx, expr)
         && let hir::ExprKind::Call(recv, _) = parent.kind
-        && let hir::ExprKind::Call(..) = recv.kind
+        && expr.span == recv.span
     {
         expr = parent;
         depth += 1;
diff --git a/tests/ui/redundant_closure_call_fixable.fixed b/tests/ui/redundant_closure_call_fixable.fixed
index 1a2c1e59261..f3669a669ea 100644
--- a/tests/ui/redundant_closure_call_fixable.fixed
+++ b/tests/ui/redundant_closure_call_fixable.fixed
@@ -78,4 +78,11 @@ fn issue9956() {
         || || || 42
     }
     let _ = x()()()();
+
+    fn bar() -> fn(i32, i32) {
+        foo
+    }
+    fn foo(_: i32, _: i32) {}
+    bar()(42, 5);
+    foo(42, 5);
 }
diff --git a/tests/ui/redundant_closure_call_fixable.rs b/tests/ui/redundant_closure_call_fixable.rs
index fec46652189..db8c7f80df4 100644
--- a/tests/ui/redundant_closure_call_fixable.rs
+++ b/tests/ui/redundant_closure_call_fixable.rs
@@ -78,4 +78,11 @@ fn issue9956() {
         || || || 42
     }
     let _ = x()()()();
+
+    fn bar() -> fn(i32, i32) {
+        foo
+    }
+    fn foo(_: i32, _: i32) {}
+    bar()((|| || 42)()(), 5);
+    foo((|| || 42)()(), 5);
 }
diff --git a/tests/ui/redundant_closure_call_fixable.stderr b/tests/ui/redundant_closure_call_fixable.stderr
index 351da54ef31..618f5e071d6 100644
--- a/tests/ui/redundant_closure_call_fixable.stderr
+++ b/tests/ui/redundant_closure_call_fixable.stderr
@@ -110,5 +110,17 @@ error: try not to call a closure in the expression where it is declared
 LL |     let a = (|| echo!((|| 123)))()();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^ help: try doing something like: `123`
 
-error: aborting due to 12 previous errors
+error: try not to call a closure in the expression where it is declared
+  --> $DIR/redundant_closure_call_fixable.rs:86:11
+   |
+LL |     bar()((|| || 42)()(), 5);
+   |           ^^^^^^^^^^^^^^ help: try doing something like: `42`
+
+error: try not to call a closure in the expression where it is declared
+  --> $DIR/redundant_closure_call_fixable.rs:87:9
+   |
+LL |     foo((|| || 42)()(), 5);
+   |         ^^^^^^^^^^^^^^ help: try doing something like: `42`
+
+error: aborting due to 14 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 73c0c145269a6226f46047c2e9cf5e5810a08dc7 Mon Sep 17 00:00:00 2001
From: Kisaragi <48310258+KisaragiEffective@users.noreply.github.com>
Date: Fri, 16 Jun 2023 16:39:09 +0900
Subject: improve grammer in comment sentence

Co-authored-by: dswij <dharmasw@outlook.com>
---
 clippy_lints/src/doc.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/doc.rs b/clippy_lints/src/doc.rs
index 11de7e60697..815495a7b7a 100644
--- a/clippy_lints/src/doc.rs
+++ b/clippy_lints/src/doc.rs
@@ -916,7 +916,7 @@ impl<'a, 'tcx> Visitor<'tcx> for FindPanicUnwrap<'a, 'tcx> {
             }
         }
 
-        // check for `unwrap` and `expect` both `Option` and `Result`
+        // check for `unwrap` and `expect` for both `Option` and `Result`
         if let Some(arglists) = method_chain_args(expr, &["unwrap"]).or(method_chain_args(expr, &["expect"])) {
             let receiver_ty = self.typeck_results.expr_ty(arglists[0].0).peel_refs();
             if is_type_diagnostic_item(self.cx, receiver_ty, sym::Option)
-- 
cgit 1.4.1-3-g733a5


From a94aac607cbae80984db04e9e4fd1439ef0003e4 Mon Sep 17 00:00:00 2001
From: Martin Fischer <martin@push-f.com>
Date: Fri, 16 Jun 2023 11:51:17 +0200
Subject: Refactor to make following commit pass single_match_else lint

---
 clippy_lints/src/lib.rs | 33 ++++++++++++++++-----------------
 1 file changed, 16 insertions(+), 17 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index b254c05d48b..cd1b63bdba2 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -497,24 +497,23 @@ pub(crate) struct LintInfo {
 
 pub fn explain(name: &str) {
     let target = format!("clippy::{}", name.to_ascii_uppercase());
-    match declared_lints::LINTS.iter().find(|info| info.lint.name == target) {
-        Some(info) => {
-            println!("{}", info.explanation);
-            // Check if the lint has configuration
-            let mdconf = get_configuration_metadata();
-            if let Some(config_vec_positions) = mdconf
-                .iter()
-                .find_all(|cconf| cconf.lints.contains(&info.lint.name_lower()[8..].to_owned()))
-            {
-                // If it has, print it
-                println!("### Configuration for {}:\n", info.lint.name_lower());
-                for position in config_vec_positions {
-                    let conf = &mdconf[position];
-                    println!("  - {}: {} (default: {})", conf.name, conf.doc, conf.default);
-                }
+    if let Some(info) = declared_lints::LINTS.iter().find(|info| info.lint.name == target) {
+        println!("{}", info.explanation);
+        // Check if the lint has configuration
+        let mdconf = get_configuration_metadata();
+        if let Some(config_vec_positions) = mdconf
+            .iter()
+            .find_all(|cconf| cconf.lints.contains(&info.lint.name_lower()[8..].to_owned()))
+        {
+            // If it has, print it
+            println!("### Configuration for {}:\n", info.lint.name_lower());
+            for position in config_vec_positions {
+                let conf = &mdconf[position];
+                println!("  - {}: {} (default: {})", conf.name, conf.doc, conf.default);
             }
-        },
-        None => println!("unknown lint: {name}"),
+        }
+    } else {
+        println!("unknown lint: {name}");
     }
 }
 
-- 
cgit 1.4.1-3-g733a5


From 894d5dafac8cb087a353047f33b4330c2a78cf2d Mon Sep 17 00:00:00 2001
From: Martin Fischer <martin@push-f.com>
Date: Fri, 16 Jun 2023 11:11:20 +0200
Subject: Make `--explain` subcommand return 1 for missing lints

---
 clippy_lints/src/lib.rs | 4 +++-
 src/main.rs             | 4 +++-
 2 files changed, 6 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index cd1b63bdba2..f0a873b91eb 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -495,7 +495,7 @@ pub(crate) struct LintInfo {
     explanation: &'static str,
 }
 
-pub fn explain(name: &str) {
+pub fn explain(name: &str) -> i32 {
     let target = format!("clippy::{}", name.to_ascii_uppercase());
     if let Some(info) = declared_lints::LINTS.iter().find(|info| info.lint.name == target) {
         println!("{}", info.explanation);
@@ -512,8 +512,10 @@ pub fn explain(name: &str) {
                 println!("  - {}: {} (default: {})", conf.name, conf.doc, conf.default);
             }
         }
+        0
     } else {
         println!("unknown lint: {name}");
+        1
     }
 }
 
diff --git a/src/main.rs b/src/main.rs
index 188ff87abfc..300c84a1442 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -57,7 +57,9 @@ pub fn main() {
     if let Some(pos) = env::args().position(|a| a == "--explain") {
         if let Some(mut lint) = env::args().nth(pos + 1) {
             lint.make_ascii_lowercase();
-            clippy_lints::explain(&lint.strip_prefix("clippy::").unwrap_or(&lint).replace('-', "_"));
+            process::exit(clippy_lints::explain(
+                &lint.strip_prefix("clippy::").unwrap_or(&lint).replace('-', "_"),
+            ));
         } else {
             show_help();
         }
-- 
cgit 1.4.1-3-g733a5


From 520228b37741915c65aae2f2d6c0f381156c91cc Mon Sep 17 00:00:00 2001
From: Renato Lochetti <renato.lochetti@gmail.com>
Date: Sun, 4 Jun 2023 13:11:50 +0100
Subject: Adding configuration to allow safety comment above stmt containing
 unsafe block

---
 book/src/lint_configuration.md                     | 10 +++++
 clippy_lints/src/lib.rs                            |  7 +++-
 clippy_lints/src/undocumented_unsafe_blocks.rs     | 44 +++++++++++++++++++---
 clippy_lints/src/utils/conf.rs                     |  4 ++
 .../toml_unknown_key/conf_unknown_key.stderr       |  2 +
 .../ui-toml/undocumented_unsafe_blocks/clippy.toml |  1 +
 .../undocumented_unsafe_blocks.rs                  | 12 ++++++
 tests/ui/undocumented_unsafe_blocks.rs             | 10 +++++
 tests/ui/undocumented_unsafe_blocks.stderr         | 10 ++++-
 9 files changed, 93 insertions(+), 7 deletions(-)
 create mode 100644 tests/ui-toml/undocumented_unsafe_blocks/clippy.toml
 create mode 100644 tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs

(limited to 'clippy_lints/src')

diff --git a/book/src/lint_configuration.md b/book/src/lint_configuration.md
index 085dff8e63b..bd44af66d42 100644
--- a/book/src/lint_configuration.md
+++ b/book/src/lint_configuration.md
@@ -695,3 +695,13 @@ Minimum chars an ident can have, anything below or equal to this will be linted.
 * [`min_ident_chars`](https://rust-lang.github.io/rust-clippy/master/index.html#min_ident_chars)
 
 
+## `accept-comment-above-statement`
+Whether to accept a safety comment to be placed above the statement containing the `usafe` block
+
+**Default Value:** `false` (`bool`)
+
+---
+**Affected lints:**
+* [`undocumented_unsafe_blocks`](https://rust-lang.github.io/rust-clippy/master/index.html#undocumented_unsafe_blocks)
+
+
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index f0a873b91eb..6ea329a9542 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -929,7 +929,12 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
             enable_raw_pointer_heuristic_for_send,
         ))
     });
-    store.register_late_pass(move |_| Box::new(undocumented_unsafe_blocks::UndocumentedUnsafeBlocks));
+    let accept_comment_above_statement = conf.accept_comment_above_statement;
+    store.register_late_pass(move |_| {
+        Box::new(undocumented_unsafe_blocks::UndocumentedUnsafeBlocks::new(
+            accept_comment_above_statement,
+        ))
+    });
     let allow_mixed_uninlined = conf.allow_mixed_uninlined_format_args;
     store.register_late_pass(move |_| Box::new(format_args::FormatArgs::new(msrv(), allow_mixed_uninlined)));
     store.register_late_pass(|_| Box::new(trailing_empty_array::TrailingEmptyArray));
diff --git a/clippy_lints/src/undocumented_unsafe_blocks.rs b/clippy_lints/src/undocumented_unsafe_blocks.rs
index 2920684ade3..bc739dca0b9 100644
--- a/clippy_lints/src/undocumented_unsafe_blocks.rs
+++ b/clippy_lints/src/undocumented_unsafe_blocks.rs
@@ -11,7 +11,7 @@ use rustc_hir::{Block, BlockCheckMode, ItemKind, Node, UnsafeSource};
 use rustc_lexer::{tokenize, TokenKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::{BytePos, Pos, Span, SyntaxContext};
 
 declare_clippy_lint! {
@@ -92,7 +92,20 @@ declare_clippy_lint! {
     "annotating safe code with a safety comment"
 }
 
-declare_lint_pass!(UndocumentedUnsafeBlocks => [UNDOCUMENTED_UNSAFE_BLOCKS, UNNECESSARY_SAFETY_COMMENT]);
+#[derive(Copy, Clone)]
+pub struct UndocumentedUnsafeBlocks {
+    accept_comment_above_statement: bool,
+}
+
+impl UndocumentedUnsafeBlocks {
+    pub fn new(accept_comment_above_statement: bool) -> Self {
+        Self {
+            accept_comment_above_statement,
+        }
+    }
+}
+
+impl_lint_pass!(UndocumentedUnsafeBlocks => [UNDOCUMENTED_UNSAFE_BLOCKS, UNNECESSARY_SAFETY_COMMENT]);
 
 impl<'tcx> LateLintPass<'tcx> for UndocumentedUnsafeBlocks {
     fn check_block(&mut self, cx: &LateContext<'tcx>, block: &'tcx Block<'tcx>) {
@@ -101,7 +114,7 @@ impl<'tcx> LateLintPass<'tcx> for UndocumentedUnsafeBlocks {
             && !is_lint_allowed(cx, UNDOCUMENTED_UNSAFE_BLOCKS, block.hir_id)
             && !is_unsafe_from_proc_macro(cx, block.span)
             && !block_has_safety_comment(cx, block.span)
-            && !block_parents_have_safety_comment(cx, block.hir_id)
+            && !block_parents_have_safety_comment(self.accept_comment_above_statement, cx, block.hir_id)
         {
             let source_map = cx.tcx.sess.source_map();
             let span = if source_map.is_multiline(block.span) {
@@ -313,10 +326,31 @@ fn is_unsafe_from_proc_macro(cx: &LateContext<'_>, span: Span) -> bool {
 
 // Checks if any parent {expression, statement, block, local, const, static}
 // has a safety comment
-fn block_parents_have_safety_comment(cx: &LateContext<'_>, id: hir::HirId) -> bool {
+fn block_parents_have_safety_comment(
+    accept_comment_above_statement: bool,
+    cx: &LateContext<'_>,
+    id: hir::HirId,
+) -> bool {
     if let Some(node) = get_parent_node(cx.tcx, id) {
         return match node {
-            Node::Expr(expr) => !is_branchy(expr) && span_in_body_has_safety_comment(cx, expr.span),
+            Node::Expr(expr) => {
+                if let Some(
+                    Node::Local(hir::Local { span, .. })
+                    | Node::Item(hir::Item {
+                        kind: hir::ItemKind::Const(..) | ItemKind::Static(..),
+                        span,
+                        ..
+                    }),
+                ) = get_parent_node(cx.tcx, expr.hir_id)
+                {
+                    // if unsafe block is part of a let/const/static statement,
+                    // and accept_comment_above_statement is set to true
+                    // we accept the safety comment in the line the precedes this statement.
+                    accept_comment_above_statement && span_in_body_has_safety_comment(cx, *span)
+                } else {
+                    !is_branchy(expr) && span_in_body_has_safety_comment(cx, expr.span)
+                }
+            },
             Node::Stmt(hir::Stmt {
                 kind:
                     hir::StmtKind::Local(hir::Local { span, .. })
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index f6c7c1fa065..fccddfbdb8b 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -538,6 +538,10 @@ define_Conf! {
     ///
     /// Minimum chars an ident can have, anything below or equal to this will be linted.
     (min_ident_chars_threshold: u64 = 1),
+    /// Lint: UNDOCUMENTED_UNSAFE_BLOCKS.
+    ///
+    /// Whether to accept a safety comment to be placed above the statement containing the `usafe` block
+    (accept_comment_above_statement: bool = false),
 }
 
 /// Search for the configuration file.
diff --git a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
index d8ce0e2f55d..db2071ecaaf 100644
--- a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
+++ b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
@@ -1,4 +1,5 @@
 error: error reading Clippy's configuration file: unknown field `foobar`, expected one of
+           accept-comment-above-statement
            allow-dbg-in-tests
            allow-expect-in-tests
            allow-mixed-uninlined-format-args
@@ -65,6 +66,7 @@ LL | foobar = 42
    | ^^^^^^
 
 error: error reading Clippy's configuration file: unknown field `barfoo`, expected one of
+           accept-comment-above-statement
            allow-dbg-in-tests
            allow-expect-in-tests
            allow-mixed-uninlined-format-args
diff --git a/tests/ui-toml/undocumented_unsafe_blocks/clippy.toml b/tests/ui-toml/undocumented_unsafe_blocks/clippy.toml
new file mode 100644
index 00000000000..1c2e7aeaff9
--- /dev/null
+++ b/tests/ui-toml/undocumented_unsafe_blocks/clippy.toml
@@ -0,0 +1 @@
+accept-comment-above-statement = true
diff --git a/tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs b/tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs
new file mode 100644
index 00000000000..ef208f2c390
--- /dev/null
+++ b/tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs
@@ -0,0 +1,12 @@
+#![deny(clippy::undocumented_unsafe_blocks)]
+#![allow(clippy::missing_safety_doc)]
+
+fn main() {
+    // Safety: A safety comment
+    let _some_variable_with_a_very_long_name_to_break_the_line =
+        unsafe { a_function_with_a_very_long_name_to_break_the_line() };
+}
+
+pub unsafe fn a_function_with_a_very_long_name_to_break_the_line() -> u32 {
+    1
+}
diff --git a/tests/ui/undocumented_unsafe_blocks.rs b/tests/ui/undocumented_unsafe_blocks.rs
index 229d150851a..fa86352554b 100644
--- a/tests/ui/undocumented_unsafe_blocks.rs
+++ b/tests/ui/undocumented_unsafe_blocks.rs
@@ -509,4 +509,14 @@ fn issue_9142() {
     };
 }
 
+pub unsafe fn a_function_with_a_very_long_name_to_break_the_line() -> u32 {
+    1
+}
+
+fn issue_10832() {
+    // Safety: A safety comment. But it will warn anyways
+    let _some_variable_with_a_very_long_name_to_break_the_line =
+        unsafe { a_function_with_a_very_long_name_to_break_the_line() };
+}
+
 fn main() {}
diff --git a/tests/ui/undocumented_unsafe_blocks.stderr b/tests/ui/undocumented_unsafe_blocks.stderr
index d1c1bb5ffea..84a8e681f67 100644
--- a/tests/ui/undocumented_unsafe_blocks.stderr
+++ b/tests/ui/undocumented_unsafe_blocks.stderr
@@ -318,5 +318,13 @@ LL |             let bar = unsafe {};
    |
    = help: consider adding a safety comment on the preceding line
 
-error: aborting due to 36 previous errors
+error: unsafe block missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:519:9
+   |
+LL |         unsafe { a_function_with_a_very_long_name_to_break_the_line() };
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: aborting due to 37 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From e2e6a02445980cd7eb213e87ad22e3bb9b074907 Mon Sep 17 00:00:00 2001
From: Renato Lochetti <renato.lochetti@gmail.com>
Date: Mon, 5 Jun 2023 08:55:39 +0100
Subject: Addressing reviewer comments

---
 book/src/lint_configuration.md                       |  2 +-
 clippy_lints/src/undocumented_unsafe_blocks.rs       |  9 ++++++++-
 clippy_lints/src/utils/conf.rs                       |  2 +-
 .../undocumented_unsafe_blocks.rs                    | 12 ++++++++++++
 tests/ui/undocumented_unsafe_blocks.rs               | 12 ++++++++++++
 tests/ui/undocumented_unsafe_blocks.stderr           | 20 ++++++++++++++++++--
 6 files changed, 52 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/book/src/lint_configuration.md b/book/src/lint_configuration.md
index bd44af66d42..78a5f9da461 100644
--- a/book/src/lint_configuration.md
+++ b/book/src/lint_configuration.md
@@ -696,7 +696,7 @@ Minimum chars an ident can have, anything below or equal to this will be linted.
 
 
 ## `accept-comment-above-statement`
-Whether to accept a safety comment to be placed above the statement containing the `usafe` block
+Whether to accept a safety comment to be placed above the statement containing the `unsafe` block
 
 **Default Value:** `false` (`bool`)
 
diff --git a/clippy_lints/src/undocumented_unsafe_blocks.rs b/clippy_lints/src/undocumented_unsafe_blocks.rs
index bc739dca0b9..1676c767a34 100644
--- a/clippy_lints/src/undocumented_unsafe_blocks.rs
+++ b/clippy_lints/src/undocumented_unsafe_blocks.rs
@@ -580,7 +580,14 @@ fn get_body_search_span(cx: &LateContext<'_>) -> Option<Span> {
     for (_, node) in map.parent_iter(body.hir_id) {
         match node {
             Node::Expr(e) => span = e.span,
-            Node::Block(_) | Node::Arm(_) | Node::Stmt(_) | Node::Local(_) => (),
+            Node::Block(_)
+            | Node::Arm(_)
+            | Node::Stmt(_)
+            | Node::Local(_)
+            | Node::Item(hir::Item {
+                kind: hir::ItemKind::Const(..) | ItemKind::Static(..),
+                ..
+            }) => (),
             _ => break,
         }
     }
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index fccddfbdb8b..e8c8d478ffc 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -540,7 +540,7 @@ define_Conf! {
     (min_ident_chars_threshold: u64 = 1),
     /// Lint: UNDOCUMENTED_UNSAFE_BLOCKS.
     ///
-    /// Whether to accept a safety comment to be placed above the statement containing the `usafe` block
+    /// Whether to accept a safety comment to be placed above the statement containing the `unsafe` block
     (accept_comment_above_statement: bool = false),
 }
 
diff --git a/tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs b/tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs
index ef208f2c390..e1ba1b2f67e 100644
--- a/tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs
+++ b/tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs
@@ -5,8 +5,20 @@ fn main() {
     // Safety: A safety comment
     let _some_variable_with_a_very_long_name_to_break_the_line =
         unsafe { a_function_with_a_very_long_name_to_break_the_line() };
+
+    // Safety: Another safety comment
+    const _SOME_CONST_WITH_A_VERY_LONG_NAME_TO_BREAK_THE_LINE: u32 =
+        unsafe { a_const_function_with_a_very_long_name_to_break_the_line() };
+
+    // Safety: Yet another safety comment
+    static _SOME_STATIC_WITH_A_VERY_LONG_NAME_TO_BREAK_THE_LINE: u32 =
+        unsafe { a_const_function_with_a_very_long_name_to_break_the_line() };
 }
 
 pub unsafe fn a_function_with_a_very_long_name_to_break_the_line() -> u32 {
     1
 }
+
+pub const unsafe fn a_const_function_with_a_very_long_name_to_break_the_line() -> u32 {
+    2
+}
diff --git a/tests/ui/undocumented_unsafe_blocks.rs b/tests/ui/undocumented_unsafe_blocks.rs
index fa86352554b..f4e7f1943ae 100644
--- a/tests/ui/undocumented_unsafe_blocks.rs
+++ b/tests/ui/undocumented_unsafe_blocks.rs
@@ -513,10 +513,22 @@ pub unsafe fn a_function_with_a_very_long_name_to_break_the_line() -> u32 {
     1
 }
 
+pub const unsafe fn a_const_function_with_a_very_long_name_to_break_the_line() -> u32 {
+    2
+}
+
 fn issue_10832() {
     // Safety: A safety comment. But it will warn anyways
     let _some_variable_with_a_very_long_name_to_break_the_line =
         unsafe { a_function_with_a_very_long_name_to_break_the_line() };
+
+    // Safety: Another safety comment. But it will warn anyways
+    const _SOME_CONST_WITH_A_VERY_LONG_NAME_TO_BREAK_THE_LINE: u32 =
+        unsafe { a_const_function_with_a_very_long_name_to_break_the_line() };
+
+    // Safety: Yet another safety comment. But it will warn anyways
+    static _SOME_STATIC_WITH_A_VERY_LONG_NAME_TO_BREAK_THE_LINE: u32 =
+        unsafe { a_const_function_with_a_very_long_name_to_break_the_line() };
 }
 
 fn main() {}
diff --git a/tests/ui/undocumented_unsafe_blocks.stderr b/tests/ui/undocumented_unsafe_blocks.stderr
index 84a8e681f67..ee1d3aa285a 100644
--- a/tests/ui/undocumented_unsafe_blocks.stderr
+++ b/tests/ui/undocumented_unsafe_blocks.stderr
@@ -319,12 +319,28 @@ LL |             let bar = unsafe {};
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:519:9
+  --> $DIR/undocumented_unsafe_blocks.rs:523:9
    |
 LL |         unsafe { a_function_with_a_very_long_name_to_break_the_line() };
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: consider adding a safety comment on the preceding line
 
-error: aborting due to 37 previous errors
+error: unsafe block missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:527:9
+   |
+LL |         unsafe { a_const_function_with_a_very_long_name_to_break_the_line() };
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: unsafe block missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:531:9
+   |
+LL |         unsafe { a_const_function_with_a_very_long_name_to_break_the_line() };
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: aborting due to 39 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 1f621af28cd1cca74cf32aebfc7c24a7e9693223 Mon Sep 17 00:00:00 2001
From: dswij <dswijj@gmail.com>
Date: Sat, 17 Jun 2023 23:20:33 +0800
Subject: Exlude `todo!()` from `missing_panics_in_doc`

---
 clippy_lints/src/doc.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/doc.rs b/clippy_lints/src/doc.rs
index 815495a7b7a..87d88f70752 100644
--- a/clippy_lints/src/doc.rs
+++ b/clippy_lints/src/doc.rs
@@ -909,7 +909,7 @@ impl<'a, 'tcx> Visitor<'tcx> for FindPanicUnwrap<'a, 'tcx> {
             if is_panic(self.cx, macro_call.def_id)
                 || matches!(
                     self.cx.tcx.item_name(macro_call.def_id).as_str(),
-                    "assert" | "assert_eq" | "assert_ne" | "todo"
+                    "assert" | "assert_eq" | "assert_ne"
                 )
             {
                 self.panic_span = Some(macro_call.span);
-- 
cgit 1.4.1-3-g733a5


From 6331c943ff85c8d5d86f6db940fd4e9dee3da15f Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Sat, 17 Jun 2023 20:48:56 +0200
Subject: include a ref if argument is not just a numeric literal

---
 clippy_lints/src/methods/get_unwrap.rs | 23 +++++++++++-------
 tests/ui/get_unwrap.fixed              | 13 ++++++++++
 tests/ui/get_unwrap.rs                 | 13 ++++++++++
 tests/ui/get_unwrap.stderr             | 44 +++++++++++++++++++++++++++++++++-
 4 files changed, 84 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/get_unwrap.rs b/clippy_lints/src/methods/get_unwrap.rs
index ffc3a4d780e..209d42ebabd 100644
--- a/clippy_lints/src/methods/get_unwrap.rs
+++ b/clippy_lints/src/methods/get_unwrap.rs
@@ -25,13 +25,13 @@ pub(super) fn check<'tcx>(
     let get_args_str = snippet_with_applicability(cx, get_arg.span, "..", &mut applicability);
     let mut needs_ref;
     let caller_type = if derefs_to_slice(cx, recv, expr_ty).is_some() {
-        needs_ref = get_args_str.parse::<usize>().is_ok();
+        needs_ref = true;
         "slice"
     } else if is_type_diagnostic_item(cx, expr_ty, sym::Vec) {
-        needs_ref = get_args_str.parse::<usize>().is_ok();
+        needs_ref = true;
         "Vec"
     } else if is_type_diagnostic_item(cx, expr_ty, sym::VecDeque) {
-        needs_ref = get_args_str.parse::<usize>().is_ok();
+        needs_ref = true;
         "VecDeque"
     } else if !is_mut && is_type_diagnostic_item(cx, expr_ty, sym::HashMap) {
         needs_ref = true;
@@ -45,16 +45,23 @@ pub(super) fn check<'tcx>(
 
     let mut span = expr.span;
 
-    // Handle the case where the result is immediately dereferenced
-    // by not requiring ref and pulling the dereference into the
-    // suggestion.
+    // Handle the case where the result is immediately dereferenced,
+    // either directly be the user, or as a result of a method call or the like
+    // by not requiring an explicit reference
     if_chain! {
         if needs_ref;
         if let Some(parent) = get_parent_expr(cx, expr);
-        if let hir::ExprKind::Unary(hir::UnOp::Deref, _) = parent.kind;
+        if let hir::ExprKind::Unary(hir::UnOp::Deref, _)
+            | hir::ExprKind::MethodCall(..)
+            | hir::ExprKind::Field(..)
+            | hir::ExprKind::Index(..) = parent.kind;
         then {
+            if let hir::ExprKind::Unary(hir::UnOp::Deref, _) = parent.kind {
+                // if the user explicitly dereferences the result, we can adjust
+                // the span to also include the deref part
+                span = parent.span;
+            }
             needs_ref = false;
-            span = parent.span;
         }
     }
 
diff --git a/tests/ui/get_unwrap.fixed b/tests/ui/get_unwrap.fixed
index 9061c9aa404..3e4c2b499e4 100644
--- a/tests/ui/get_unwrap.fixed
+++ b/tests/ui/get_unwrap.fixed
@@ -69,4 +69,17 @@ fn main() {
         let _ = some_vec[0..1].to_vec();
         let _ = some_vec[0..1].to_vec();
     }
+    issue9909();
+}
+fn issue9909() {
+    let f = &[1, 2, 3];
+
+    let _x: &i32 = &f[1 + 2];
+    // ^ include a borrow in the suggestion, even if the argument is not just a numeric literal
+
+    let _x = f[1 + 2].to_string();
+    // ^ don't include a borrow here
+
+    let _x = f[1 + 2].abs();
+    // ^ don't include a borrow here
 }
diff --git a/tests/ui/get_unwrap.rs b/tests/ui/get_unwrap.rs
index b5e4e472037..a967971a7dc 100644
--- a/tests/ui/get_unwrap.rs
+++ b/tests/ui/get_unwrap.rs
@@ -69,4 +69,17 @@ fn main() {
         let _ = some_vec.get(0..1).unwrap().to_vec();
         let _ = some_vec.get_mut(0..1).unwrap().to_vec();
     }
+    issue9909();
+}
+fn issue9909() {
+    let f = &[1, 2, 3];
+
+    let _x: &i32 = f.get(1 + 2).unwrap();
+    // ^ include a borrow in the suggestion, even if the argument is not just a numeric literal
+
+    let _x = f.get(1 + 2).unwrap().to_string();
+    // ^ don't include a borrow here
+
+    let _x = f.get(1 + 2).unwrap().abs();
+    // ^ don't include a borrow here
 }
diff --git a/tests/ui/get_unwrap.stderr b/tests/ui/get_unwrap.stderr
index a6a34620e92..6221c236830 100644
--- a/tests/ui/get_unwrap.stderr
+++ b/tests/ui/get_unwrap.stderr
@@ -187,5 +187,47 @@ LL |         let _ = some_vec.get_mut(0..1).unwrap().to_vec();
    |
    = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
 
-error: aborting due to 26 previous errors
+error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more concise
+  --> $DIR/get_unwrap.rs:77:20
+   |
+LL |     let _x: &i32 = f.get(1 + 2).unwrap();
+   |                    ^^^^^^^^^^^^^^^^^^^^^ help: try this: `&f[1 + 2]`
+
+error: used `unwrap()` on an `Option` value
+  --> $DIR/get_unwrap.rs:77:20
+   |
+LL |     let _x: &i32 = f.get(1 + 2).unwrap();
+   |                    ^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
+
+error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more concise
+  --> $DIR/get_unwrap.rs:80:14
+   |
+LL |     let _x = f.get(1 + 2).unwrap().to_string();
+   |              ^^^^^^^^^^^^^^^^^^^^^ help: try this: `f[1 + 2]`
+
+error: used `unwrap()` on an `Option` value
+  --> $DIR/get_unwrap.rs:80:14
+   |
+LL |     let _x = f.get(1 + 2).unwrap().to_string();
+   |              ^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
+
+error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more concise
+  --> $DIR/get_unwrap.rs:83:14
+   |
+LL |     let _x = f.get(1 + 2).unwrap().abs();
+   |              ^^^^^^^^^^^^^^^^^^^^^ help: try this: `f[1 + 2]`
+
+error: used `unwrap()` on an `Option` value
+  --> $DIR/get_unwrap.rs:83:14
+   |
+LL |     let _x = f.get(1 + 2).unwrap().abs();
+   |              ^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
+
+error: aborting due to 32 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 0e1caa765e89593fc81015e2e9bfe347339ba0b7 Mon Sep 17 00:00:00 2001
From: Caio <c410.f3r@gmail.com>
Date: Sat, 17 Jun 2023 17:03:31 -0300
Subject: Fix #10792

---
 clippy_lints/src/enum_clike.rs                |   2 +-
 clippy_lints/src/floating_point_arithmetic.rs |   2 +-
 clippy_lints/src/matches/overlapping_arms.rs  |   4 +-
 clippy_lints/src/minmax.rs                    |   8 +-
 clippy_lints/src/operators/float_cmp.rs       |   2 +-
 clippy_lints/src/ranges.rs                    |   6 +-
 clippy_utils/src/consts.rs                    | 143 +++++++++++++++-----------
 clippy_utils/src/lib.rs                       |   4 +-
 tests/ui/arithmetic_side_effects.rs           |  15 +++
 9 files changed, 114 insertions(+), 72 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/enum_clike.rs b/clippy_lints/src/enum_clike.rs
index e275efaba25..d85650712db 100644
--- a/clippy_lints/src/enum_clike.rs
+++ b/clippy_lints/src/enum_clike.rs
@@ -51,7 +51,7 @@ impl<'tcx> LateLintPass<'tcx> for UnportableVariant {
                         .const_eval_poly(def_id.to_def_id())
                         .ok()
                         .map(|val| rustc_middle::mir::ConstantKind::from_value(val, ty));
-                    if let Some(Constant::Int(val)) = constant.and_then(|c| miri_to_const(cx.tcx, c)) {
+                    if let Some(Constant::Int(val)) = constant.and_then(|c| miri_to_const(cx, c)) {
                         if let ty::Adt(adt, _) = ty.kind() {
                             if adt.is_enum() {
                                 ty = adt.repr().discr_type().to_ty(cx.tcx);
diff --git a/clippy_lints/src/floating_point_arithmetic.rs b/clippy_lints/src/floating_point_arithmetic.rs
index 3c55a563af4..5e0fcd74339 100644
--- a/clippy_lints/src/floating_point_arithmetic.rs
+++ b/clippy_lints/src/floating_point_arithmetic.rs
@@ -215,7 +215,7 @@ fn check_ln1p(cx: &LateContext<'_>, expr: &Expr<'_>, receiver: &Expr<'_>) {
 // ranges [-16777215, 16777216) for type f32 as whole number floats outside
 // this range are lossy and ambiguous.
 #[expect(clippy::cast_possible_truncation)]
-fn get_integer_from_float_constant(value: &Constant) -> Option<i32> {
+fn get_integer_from_float_constant(value: &Constant<'_>) -> Option<i32> {
     match value {
         F32(num) if num.fract() == 0.0 => {
             if (-16_777_215.0..16_777_216.0).contains(num) {
diff --git a/clippy_lints/src/matches/overlapping_arms.rs b/clippy_lints/src/matches/overlapping_arms.rs
index abf2525a61c..8be3c178a29 100644
--- a/clippy_lints/src/matches/overlapping_arms.rs
+++ b/clippy_lints/src/matches/overlapping_arms.rs
@@ -41,7 +41,7 @@ fn all_ranges<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>], ty: Ty<'tcx>)
                                 cx.tcx.valtree_to_const_val((ty, min_val_const.to_valtree())),
                                 ty,
                             );
-                            miri_to_const(cx.tcx, min_constant)?
+                            miri_to_const(cx, min_constant)?
                         },
                     };
                     let rhs_const = match rhs {
@@ -52,7 +52,7 @@ fn all_ranges<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>], ty: Ty<'tcx>)
                                 cx.tcx.valtree_to_const_val((ty, max_val_const.to_valtree())),
                                 ty,
                             );
-                            miri_to_const(cx.tcx, max_constant)?
+                            miri_to_const(cx, max_constant)?
                         },
                     };
                     let lhs_val = lhs_const.int_value(cx, ty)?;
diff --git a/clippy_lints/src/minmax.rs b/clippy_lints/src/minmax.rs
index 4f967755bfa..e0904f17b8d 100644
--- a/clippy_lints/src/minmax.rs
+++ b/clippy_lints/src/minmax.rs
@@ -66,7 +66,7 @@ enum MinMax {
     Max,
 }
 
-fn min_max<'a>(cx: &LateContext<'_>, expr: &'a Expr<'a>) -> Option<(MinMax, Constant, &'a Expr<'a>)> {
+fn min_max<'a, 'tcx>(cx: &LateContext<'tcx>, expr: &'a Expr<'a>) -> Option<(MinMax, Constant<'tcx>, &'a Expr<'a>)> {
     match expr.kind {
         ExprKind::Call(path, args) => {
             if let ExprKind::Path(ref qpath) = path.kind {
@@ -99,12 +99,12 @@ fn min_max<'a>(cx: &LateContext<'_>, expr: &'a Expr<'a>) -> Option<(MinMax, Cons
     }
 }
 
-fn fetch_const<'a>(
-    cx: &LateContext<'_>,
+fn fetch_const<'a, 'tcx>(
+    cx: &LateContext<'tcx>,
     receiver: Option<&'a Expr<'a>>,
     args: &'a [Expr<'a>],
     m: MinMax,
-) -> Option<(MinMax, Constant, &'a Expr<'a>)> {
+) -> Option<(MinMax, Constant<'tcx>, &'a Expr<'a>)> {
     let mut args = receiver.into_iter().chain(args);
     let first_arg = args.next()?;
     let second_arg = args.next()?;
diff --git a/clippy_lints/src/operators/float_cmp.rs b/clippy_lints/src/operators/float_cmp.rs
index 15dff126be7..f3e0c58a787 100644
--- a/clippy_lints/src/operators/float_cmp.rs
+++ b/clippy_lints/src/operators/float_cmp.rs
@@ -85,7 +85,7 @@ fn get_lint_and_message(is_local: bool, is_comparing_arrays: bool) -> (&'static
     }
 }
 
-fn is_allowed(val: &Constant) -> bool {
+fn is_allowed(val: &Constant<'_>) -> bool {
     match val {
         &Constant::F32(f) => f == 0.0 || f.is_infinite(),
         &Constant::F64(f) => f == 0.0 || f.is_infinite(),
diff --git a/clippy_lints/src/ranges.rs b/clippy_lints/src/ranges.rs
index dd7ded491e7..d2018aba9e3 100644
--- a/clippy_lints/src/ranges.rs
+++ b/clippy_lints/src/ranges.rs
@@ -296,8 +296,8 @@ fn check_possible_range_contains(
     }
 }
 
-struct RangeBounds<'a> {
-    val: Constant,
+struct RangeBounds<'a, 'tcx> {
+    val: Constant<'tcx>,
     expr: &'a Expr<'a>,
     id: HirId,
     name_span: Span,
@@ -309,7 +309,7 @@ struct RangeBounds<'a> {
 // Takes a binary expression such as x <= 2 as input
 // Breaks apart into various pieces, such as the value of the number,
 // hir id of the variable, and direction/inclusiveness of the operator
-fn check_range_bounds<'a>(cx: &'a LateContext<'_>, ex: &'a Expr<'_>) -> Option<RangeBounds<'a>> {
+fn check_range_bounds<'a, 'tcx>(cx: &'a LateContext<'tcx>, ex: &'a Expr<'_>) -> Option<RangeBounds<'a, 'tcx>> {
     if let ExprKind::Binary(ref op, l, r) = ex.kind {
         let (inclusive, ordering) = match op.node {
             BinOpKind::Gt => (false, Ordering::Greater),
diff --git a/clippy_utils/src/consts.rs b/clippy_utils/src/consts.rs
index cc3183759ae..ff01c2ef7be 100644
--- a/clippy_utils/src/consts.rs
+++ b/clippy_utils/src/consts.rs
@@ -14,7 +14,7 @@ use rustc_middle::mir::interpret::Scalar;
 use rustc_middle::ty::{self, EarlyBinder, FloatTy, ScalarInt, Ty, TyCtxt};
 use rustc_middle::ty::{List, SubstsRef};
 use rustc_middle::{bug, span_bug};
-use rustc_span::symbol::Symbol;
+use rustc_span::symbol::{Ident, Symbol};
 use rustc_span::SyntaxContext;
 use std::cmp::Ordering::{self, Equal};
 use std::hash::{Hash, Hasher};
@@ -22,7 +22,8 @@ use std::iter;
 
 /// A `LitKind`-like enum to fold constant `Expr`s into.
 #[derive(Debug, Clone)]
-pub enum Constant {
+pub enum Constant<'tcx> {
+    Adt(rustc_middle::mir::ConstantKind<'tcx>),
     /// A `String` (e.g., "abc").
     Str(String),
     /// A binary string (e.g., `b"abc"`).
@@ -38,20 +39,20 @@ pub enum Constant {
     /// `true` or `false`.
     Bool(bool),
     /// An array of constants.
-    Vec(Vec<Constant>),
+    Vec(Vec<Constant<'tcx>>),
     /// Also an array, but with only one constant, repeated N times.
-    Repeat(Box<Constant>, u64),
+    Repeat(Box<Constant<'tcx>>, u64),
     /// A tuple of constants.
-    Tuple(Vec<Constant>),
+    Tuple(Vec<Constant<'tcx>>),
     /// A raw pointer.
     RawPtr(u128),
     /// A reference
-    Ref(Box<Constant>),
+    Ref(Box<Constant<'tcx>>),
     /// A literal with syntax error.
     Err,
 }
 
-impl PartialEq for Constant {
+impl<'tcx> PartialEq for Constant<'tcx> {
     fn eq(&self, other: &Self) -> bool {
         match (self, other) {
             (Self::Str(ls), Self::Str(rs)) => ls == rs,
@@ -80,13 +81,16 @@ impl PartialEq for Constant {
     }
 }
 
-impl Hash for Constant {
+impl<'tcx> Hash for Constant<'tcx> {
     fn hash<H>(&self, state: &mut H)
     where
         H: Hasher,
     {
         std::mem::discriminant(self).hash(state);
         match *self {
+            Self::Adt(ref elem) => {
+                elem.hash(state);
+            },
             Self::Str(ref s) => {
                 s.hash(state);
             },
@@ -126,7 +130,7 @@ impl Hash for Constant {
     }
 }
 
-impl Constant {
+impl<'tcx> Constant<'tcx> {
     pub fn partial_cmp(tcx: TyCtxt<'_>, cmp_type: Ty<'_>, left: &Self, right: &Self) -> Option<Ordering> {
         match (left, right) {
             (Self::Str(ls), Self::Str(rs)) => Some(ls.cmp(rs)),
@@ -209,7 +213,7 @@ impl Constant {
 }
 
 /// Parses a `LitKind` to a `Constant`.
-pub fn lit_to_mir_constant(lit: &LitKind, ty: Option<Ty<'_>>) -> Constant {
+pub fn lit_to_mir_constant<'tcx>(lit: &LitKind, ty: Option<Ty<'tcx>>) -> Constant<'tcx> {
     match *lit {
         LitKind::Str(ref is, _) => Constant::Str(is.to_string()),
         LitKind::Byte(b) => Constant::Int(u128::from(b)),
@@ -248,7 +252,7 @@ pub fn constant<'tcx>(
     lcx: &LateContext<'tcx>,
     typeck_results: &ty::TypeckResults<'tcx>,
     e: &Expr<'_>,
-) -> Option<Constant> {
+) -> Option<Constant<'tcx>> {
     ConstEvalLateContext::new(lcx, typeck_results).expr(e)
 }
 
@@ -257,7 +261,7 @@ pub fn constant_with_source<'tcx>(
     lcx: &LateContext<'tcx>,
     typeck_results: &ty::TypeckResults<'tcx>,
     e: &Expr<'_>,
-) -> Option<(Constant, ConstantSource)> {
+) -> Option<(Constant<'tcx>, ConstantSource)> {
     let mut ctxt = ConstEvalLateContext::new(lcx, typeck_results);
     let res = ctxt.expr(e);
     res.map(|x| (x, ctxt.source))
@@ -268,7 +272,7 @@ pub fn constant_simple<'tcx>(
     lcx: &LateContext<'tcx>,
     typeck_results: &ty::TypeckResults<'tcx>,
     e: &Expr<'_>,
-) -> Option<Constant> {
+) -> Option<Constant<'tcx>> {
     constant_with_source(lcx, typeck_results, e).and_then(|(c, s)| s.is_local().then_some(c))
 }
 
@@ -338,7 +342,7 @@ impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
     }
 
     /// Simple constant folding: Insert an expression, get a constant or none.
-    pub fn expr(&mut self, e: &Expr<'_>) -> Option<Constant> {
+    pub fn expr(&mut self, e: &Expr<'_>) -> Option<Constant<'tcx>> {
         match e.kind {
             ExprKind::Path(ref qpath) => self.fetch_path(qpath, e.hir_id, self.typeck_results.expr_ty(e)),
             ExprKind::Block(block, _) => self.block(block),
@@ -392,13 +396,25 @@ impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
             },
             ExprKind::Index(arr, index) => self.index(arr, index),
             ExprKind::AddrOf(_, _, inner) => self.expr(inner).map(|r| Constant::Ref(Box::new(r))),
-            // TODO: add other expressions.
+            ExprKind::Field(ref local_expr, ref field) => {
+                let result = self.expr(local_expr);
+                if let Some(Constant::Adt(constant)) = &self.expr(local_expr)
+                    && let ty::Adt(adt_def, _) = constant.ty().kind()
+                    && adt_def.is_struct()
+                    && let Some(desired_field) = field_of_struct(*adt_def, self.lcx, *constant, field)
+                {
+                    miri_to_const(self.lcx, desired_field)
+                }
+                else {
+                    result
+                }
+            },
             _ => None,
         }
     }
 
     #[expect(clippy::cast_possible_wrap)]
-    fn constant_not(&self, o: &Constant, ty: Ty<'_>) -> Option<Constant> {
+    fn constant_not(&self, o: &Constant<'tcx>, ty: Ty<'_>) -> Option<Constant<'tcx>> {
         use self::Constant::{Bool, Int};
         match *o {
             Bool(b) => Some(Bool(!b)),
@@ -414,7 +430,7 @@ impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
         }
     }
 
-    fn constant_negate(&self, o: &Constant, ty: Ty<'_>) -> Option<Constant> {
+    fn constant_negate(&self, o: &Constant<'tcx>, ty: Ty<'_>) -> Option<Constant<'tcx>> {
         use self::Constant::{Int, F32, F64};
         match *o {
             Int(value) => {
@@ -433,28 +449,25 @@ impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
 
     /// Create `Some(Vec![..])` of all constants, unless there is any
     /// non-constant part.
-    fn multi(&mut self, vec: &[Expr<'_>]) -> Option<Vec<Constant>> {
+    fn multi(&mut self, vec: &[Expr<'_>]) -> Option<Vec<Constant<'tcx>>> {
         vec.iter().map(|elem| self.expr(elem)).collect::<Option<_>>()
     }
 
     /// Lookup a possibly constant expression from an `ExprKind::Path`.
-    fn fetch_path(&mut self, qpath: &QPath<'_>, id: HirId, ty: Ty<'tcx>) -> Option<Constant> {
+    fn fetch_path(&mut self, qpath: &QPath<'_>, id: HirId, ty: Ty<'tcx>) -> Option<Constant<'tcx>> {
         let res = self.typeck_results.qpath_res(qpath, id);
         match res {
             Res::Def(DefKind::Const | DefKind::AssocConst, def_id) => {
                 // Check if this constant is based on `cfg!(..)`,
                 // which is NOT constant for our purposes.
-                if let Some(node) = self.lcx.tcx.hir().get_if_local(def_id) &&
-                let Node::Item(&Item {
-                    kind: ItemKind::Const(_, body_id),
-                    ..
-                }) = node &&
-                let Node::Expr(&Expr {
-                    kind: ExprKind::Lit(_),
-                    span,
-                    ..
-                }) = self.lcx.tcx.hir().get(body_id.hir_id) &&
-                is_direct_expn_of(span, "cfg").is_some() {
+                if let Some(node) = self.lcx.tcx.hir().get_if_local(def_id)
+                    && let Node::Item(Item { kind: ItemKind::Const(_, body_id), .. }) = node
+                    && let Node::Expr(Expr { kind: ExprKind::Lit(_), span, .. }) = self.lcx
+                        .tcx
+                        .hir()
+                        .get(body_id.hir_id)
+                    && is_direct_expn_of(*span, "cfg").is_some()
+                {
                     return None;
                 }
 
@@ -464,23 +477,21 @@ impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
                 } else {
                     EarlyBinder::bind(substs).subst(self.lcx.tcx, self.substs)
                 };
-
                 let result = self
                     .lcx
                     .tcx
                     .const_eval_resolve(self.param_env, mir::UnevaluatedConst::new(def_id, substs), None)
                     .ok()
                     .map(|val| rustc_middle::mir::ConstantKind::from_value(val, ty))?;
-                let result = miri_to_const(self.lcx.tcx, result)?;
+                let result = miri_to_const(self.lcx, result)?;
                 self.source = ConstantSource::Constant;
                 Some(result)
             },
-            // FIXME: cover all usable cases.
             _ => None,
         }
     }
 
-    fn index(&mut self, lhs: &'_ Expr<'_>, index: &'_ Expr<'_>) -> Option<Constant> {
+    fn index(&mut self, lhs: &'_ Expr<'_>, index: &'_ Expr<'_>) -> Option<Constant<'tcx>> {
         let lhs = self.expr(lhs);
         let index = self.expr(index);
 
@@ -506,7 +517,7 @@ impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
     }
 
     /// A block can only yield a constant if it only has one constant expression.
-    fn block(&mut self, block: &Block<'_>) -> Option<Constant> {
+    fn block(&mut self, block: &Block<'_>) -> Option<Constant<'tcx>> {
         if block.stmts.is_empty()
             && let Some(expr) = block.expr
         {
@@ -539,7 +550,7 @@ impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
         }
     }
 
-    fn ifthenelse(&mut self, cond: &Expr<'_>, then: &Expr<'_>, otherwise: Option<&Expr<'_>>) -> Option<Constant> {
+    fn ifthenelse(&mut self, cond: &Expr<'_>, then: &Expr<'_>, otherwise: Option<&Expr<'_>>) -> Option<Constant<'tcx>> {
         if let Some(Constant::Bool(b)) = self.expr(cond) {
             if b {
                 self.expr(then)
@@ -551,7 +562,7 @@ impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
         }
     }
 
-    fn binop(&mut self, op: BinOp, left: &Expr<'_>, right: &Expr<'_>) -> Option<Constant> {
+    fn binop(&mut self, op: BinOp, left: &Expr<'_>, right: &Expr<'_>) -> Option<Constant<'tcx>> {
         let l = self.expr(left)?;
         let r = self.expr(right);
         match (l, r) {
@@ -644,23 +655,21 @@ impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
     }
 }
 
-pub fn miri_to_const<'tcx>(tcx: TyCtxt<'tcx>, result: mir::ConstantKind<'tcx>) -> Option<Constant> {
+pub fn miri_to_const<'tcx>(lcx: &LateContext<'tcx>, result: mir::ConstantKind<'tcx>) -> Option<Constant<'tcx>> {
     use rustc_middle::mir::interpret::ConstValue;
     match result {
-        mir::ConstantKind::Val(ConstValue::Scalar(Scalar::Int(int)), _) => {
-            match result.ty().kind() {
-                ty::Bool => Some(Constant::Bool(int == ScalarInt::TRUE)),
-                ty::Uint(_) | ty::Int(_) => Some(Constant::Int(int.assert_bits(int.size()))),
-                ty::Float(FloatTy::F32) => Some(Constant::F32(f32::from_bits(
-                    int.try_into().expect("invalid f32 bit representation"),
-                ))),
-                ty::Float(FloatTy::F64) => Some(Constant::F64(f64::from_bits(
-                    int.try_into().expect("invalid f64 bit representation"),
-                ))),
-                ty::RawPtr(_) => Some(Constant::RawPtr(int.assert_bits(int.size()))),
-                // FIXME: implement other conversions.
-                _ => None,
-            }
+        mir::ConstantKind::Val(ConstValue::Scalar(Scalar::Int(int)), _) => match result.ty().kind() {
+            ty::Adt(adt_def, _) if adt_def.is_struct() => Some(Constant::Adt(result)),
+            ty::Bool => Some(Constant::Bool(int == ScalarInt::TRUE)),
+            ty::Uint(_) | ty::Int(_) => Some(Constant::Int(int.assert_bits(int.size()))),
+            ty::Float(FloatTy::F32) => Some(Constant::F32(f32::from_bits(
+                int.try_into().expect("invalid f32 bit representation"),
+            ))),
+            ty::Float(FloatTy::F64) => Some(Constant::F64(f64::from_bits(
+                int.try_into().expect("invalid f64 bit representation"),
+            ))),
+            ty::RawPtr(_) => Some(Constant::RawPtr(int.assert_bits(int.size()))),
+            _ => None,
         },
         mir::ConstantKind::Val(ConstValue::Slice { data, start, end }, _) => match result.ty().kind() {
             ty::Ref(_, tam, _) => match tam.kind() {
@@ -676,35 +685,53 @@ pub fn miri_to_const<'tcx>(tcx: TyCtxt<'tcx>, result: mir::ConstantKind<'tcx>) -
             _ => None,
         },
         mir::ConstantKind::Val(ConstValue::ByRef { alloc, offset: _ }, _) => match result.ty().kind() {
+            ty::Adt(adt_def, _) if adt_def.is_struct() => Some(Constant::Adt(result)),
             ty::Array(sub_type, len) => match sub_type.kind() {
-                ty::Float(FloatTy::F32) => match len.kind().try_to_target_usize(tcx) {
+                ty::Float(FloatTy::F32) => match len.kind().try_to_target_usize(lcx.tcx) {
                     Some(len) => alloc
                         .inner()
                         .inspect_with_uninit_and_ptr_outside_interpreter(0..(4 * usize::try_from(len).unwrap()))
                         .to_owned()
                         .array_chunks::<4>()
                         .map(|&chunk| Some(Constant::F32(f32::from_le_bytes(chunk))))
-                        .collect::<Option<Vec<Constant>>>()
+                        .collect::<Option<Vec<Constant<'tcx>>>>()
                         .map(Constant::Vec),
                     _ => None,
                 },
-                ty::Float(FloatTy::F64) => match len.kind().try_to_target_usize(tcx) {
+                ty::Float(FloatTy::F64) => match len.kind().try_to_target_usize(lcx.tcx) {
                     Some(len) => alloc
                         .inner()
                         .inspect_with_uninit_and_ptr_outside_interpreter(0..(8 * usize::try_from(len).unwrap()))
                         .to_owned()
                         .array_chunks::<8>()
                         .map(|&chunk| Some(Constant::F64(f64::from_le_bytes(chunk))))
-                        .collect::<Option<Vec<Constant>>>()
+                        .collect::<Option<Vec<Constant<'tcx>>>>()
                         .map(Constant::Vec),
                     _ => None,
                 },
-                // FIXME: implement other array type conversions.
                 _ => None,
             },
             _ => None,
         },
-        // FIXME: implement other conversions.
         _ => None,
     }
 }
+
+fn field_of_struct<'tcx>(
+    adt_def: ty::AdtDef<'tcx>,
+    lcx: &LateContext<'tcx>,
+    result: mir::ConstantKind<'tcx>,
+    field: &Ident,
+) -> Option<mir::ConstantKind<'tcx>> {
+    let dc = lcx.tcx.destructure_mir_constant(lcx.param_env, result);
+    if let Some(dc_variant) = dc.variant
+        && let Some(variant) = adt_def.variants().get(dc_variant)
+        && let Some(field_idx) = variant.fields.iter().position(|el| el.name == field.name)
+        && let Some(dc_field) = dc.fields.get(field_idx)
+    {
+        Some(*dc_field)
+    }
+    else {
+        None
+    }
+}
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 311f6dbc696..5b5e9fba6af 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -1499,7 +1499,7 @@ pub fn is_range_full(cx: &LateContext<'_>, expr: &Expr<'_>, container_path: Opti
                 && let Some(min_val) = bnd_ty.numeric_min_val(cx.tcx)
                 && let const_val = cx.tcx.valtree_to_const_val((bnd_ty, min_val.to_valtree()))
                 && let min_const_kind = ConstantKind::from_value(const_val, bnd_ty)
-                && let Some(min_const) = miri_to_const(cx.tcx, min_const_kind)
+                && let Some(min_const) = miri_to_const(cx, min_const_kind)
                 && let Some(start_const) = constant(cx, cx.typeck_results(), start)
             {
                 start_const == min_const
@@ -1515,7 +1515,7 @@ pub fn is_range_full(cx: &LateContext<'_>, expr: &Expr<'_>, container_path: Opti
                         && let Some(max_val) = bnd_ty.numeric_max_val(cx.tcx)
                         && let const_val = cx.tcx.valtree_to_const_val((bnd_ty, max_val.to_valtree()))
                         && let max_const_kind = ConstantKind::from_value(const_val, bnd_ty)
-                        && let Some(max_const) = miri_to_const(cx.tcx, max_const_kind)
+                        && let Some(max_const) = miri_to_const(cx, max_const_kind)
                         && let Some(end_const) = constant(cx, cx.typeck_results(), end)
                     {
                         end_const == max_const
diff --git a/tests/ui/arithmetic_side_effects.rs b/tests/ui/arithmetic_side_effects.rs
index f95af1017bc..7dd14e3824d 100644
--- a/tests/ui/arithmetic_side_effects.rs
+++ b/tests/ui/arithmetic_side_effects.rs
@@ -466,4 +466,19 @@ pub fn issue_10767() {
     &3.5_f32 + &1.3_f32;
 }
 
+pub fn issue_10792() {
+    struct One {
+        a: u32,
+    }
+    struct Two {
+        b: u32,
+        c: u64,
+    }
+    const ONE: One = One { a: 1 };
+    const TWO: Two = Two { b: 2, c: 3 };
+    let _ = 10 / ONE.a;
+    let _ = 10 / TWO.b;
+    let _ = 10 / TWO.c;
+}
+
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 07dbcbda12cacb924c2d95719ad598ee9de8738d Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Wed, 14 Jun 2023 06:48:34 -0500
Subject: new lint `single_call_fn`

---
 CHANGELOG.md                       |   1 +
 clippy_lints/src/declared_lints.rs |   1 +
 clippy_lints/src/lib.rs            |   7 ++
 clippy_lints/src/single_call_fn.rs | 132 +++++++++++++++++++++++++++++++++++++
 tests/ui/single_call_fn.rs         |  49 ++++++++++++++
 tests/ui/single_call_fn.stderr     |  31 +++++++++
 6 files changed, 221 insertions(+)
 create mode 100644 clippy_lints/src/single_call_fn.rs
 create mode 100644 tests/ui/single_call_fn.rs
 create mode 100644 tests/ui/single_call_fn.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 3eaa0d199fd..6fb7ac740b0 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5158,6 +5158,7 @@ Released 2018-09-13
 [`significant_drop_in_scrutinee`]: https://rust-lang.github.io/rust-clippy/master/index.html#significant_drop_in_scrutinee
 [`significant_drop_tightening`]: https://rust-lang.github.io/rust-clippy/master/index.html#significant_drop_tightening
 [`similar_names`]: https://rust-lang.github.io/rust-clippy/master/index.html#similar_names
+[`single_call_fn`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_call_fn
 [`single_char_add_str`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_char_add_str
 [`single_char_lifetime_names`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_char_lifetime_names
 [`single_char_pattern`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_char_pattern
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 7690e8f7247..9c1e1f6702d 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -570,6 +570,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::shadow::SHADOW_SAME_INFO,
     crate::shadow::SHADOW_UNRELATED_INFO,
     crate::significant_drop_tightening::SIGNIFICANT_DROP_TIGHTENING_INFO,
+    crate::single_call_fn::SINGLE_CALL_FN_INFO,
     crate::single_char_lifetime_names::SINGLE_CHAR_LIFETIME_NAMES_INFO,
     crate::single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS_INFO,
     crate::single_range_in_vec_init::SINGLE_RANGE_IN_VEC_INIT_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 6ea329a9542..939b1136b46 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -287,6 +287,7 @@ mod semicolon_if_nothing_returned;
 mod serde_api;
 mod shadow;
 mod significant_drop_tightening;
+mod single_call_fn;
 mod single_char_lifetime_names;
 mod single_component_path_imports;
 mod single_range_in_vec_init;
@@ -1055,6 +1056,12 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(move |_| Box::new(large_stack_frames::LargeStackFrames::new(stack_size_threshold)));
     store.register_late_pass(|_| Box::new(single_range_in_vec_init::SingleRangeInVecInit));
     store.register_late_pass(|_| Box::new(incorrect_impls::IncorrectImpls));
+    store.register_late_pass(move |_| {
+        Box::new(single_call_fn::SingleCallFn {
+            avoid_breaking_exported_api,
+            def_id_to_usage: rustc_data_structures::fx::FxHashMap::default(),
+        })
+    });
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/single_call_fn.rs b/clippy_lints/src/single_call_fn.rs
new file mode 100644
index 00000000000..d0fbedee832
--- /dev/null
+++ b/clippy_lints/src/single_call_fn.rs
@@ -0,0 +1,132 @@
+use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::is_from_proc_macro;
+use rustc_data_structures::fx::FxHashMap;
+use rustc_hir::def_id::LocalDefId;
+use rustc_hir::intravisit::{walk_expr, Visitor};
+use rustc_hir::{intravisit::FnKind, Body, Expr, ExprKind, FnDecl};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_middle::hir::nested_filter::OnlyBodies;
+use rustc_middle::lint::in_external_macro;
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::Span;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for functions that are only used once.
+    ///
+    /// ### Why is this bad?
+    /// It's usually not, splitting a function into multiple parts often improves readability and in
+    /// the case of generics, can prevent the compiler from duplicating the function dozens of
+    /// time; instead, only duplicating a thunk. But this can prevent segmentation across a
+    /// codebase, where many small functions are used only once.
+    ///
+    /// Note: If this lint is used, prepare to allow this a lot.
+    ///
+    /// ### Example
+    /// ```rust
+    /// pub fn a<T>(t: &T)
+    /// where
+    ///     T: AsRef<str>,
+    /// {
+    ///     a_inner(t.as_ref())
+    /// }
+    ///
+    /// fn a_inner(t: &str) {
+    ///     /* snip */
+    /// }
+    ///
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// pub fn a<T>(t: &T)
+    /// where
+    ///     T: AsRef<str>,
+    /// {
+    ///     let t = t.as_ref();
+    ///     /* snip */
+    /// }
+    ///
+    /// ```
+    #[clippy::version = "1.72.0"]
+    pub SINGLE_CALL_FN,
+    restriction,
+    "checks for functions that are only used once"
+}
+impl_lint_pass!(SingleCallFn => [SINGLE_CALL_FN]);
+
+#[derive(Clone)]
+pub struct SingleCallFn {
+    pub avoid_breaking_exported_api: bool,
+    pub def_id_to_usage: FxHashMap<LocalDefId, (Span, Vec<Span>)>,
+}
+
+impl<'tcx> LateLintPass<'tcx> for SingleCallFn {
+    fn check_fn(
+        &mut self,
+        cx: &LateContext<'tcx>,
+        kind: FnKind<'tcx>,
+        _: &'tcx FnDecl<'_>,
+        body: &'tcx Body<'_>,
+        span: Span,
+        def_id: LocalDefId,
+    ) {
+        if self.avoid_breaking_exported_api && cx.effective_visibilities.is_exported(def_id)
+            || in_external_macro(cx.sess(), span)
+            || is_from_proc_macro(cx, &(&kind, body, cx.tcx.local_def_id_to_hir_id(def_id), span))
+        {
+            return;
+        }
+
+        self.def_id_to_usage.insert(def_id, (span, vec![]));
+    }
+
+    fn check_crate_post(&mut self, cx: &LateContext<'tcx>) {
+        let mut v = FnUsageVisitor {
+            cx,
+            def_id_to_usage: &mut self.def_id_to_usage,
+        };
+        cx.tcx.hir().visit_all_item_likes_in_crate(&mut v);
+
+        for usage in self.def_id_to_usage.values() {
+            let fn_span = usage.0;
+            if let [usage] = *usage.1 {
+                span_lint_and_help(
+                    cx,
+                    SINGLE_CALL_FN,
+                    fn_span,
+                    "this function is only used once",
+                    Some(usage),
+                    "used here",
+                );
+            }
+        }
+    }
+}
+
+struct FnUsageVisitor<'a, 'tcx> {
+    cx: &'a LateContext<'tcx>,
+    def_id_to_usage: &'a mut FxHashMap<LocalDefId, (Span, Vec<Span>)>,
+}
+
+impl<'a, 'tcx> Visitor<'tcx> for FnUsageVisitor<'a, 'tcx> {
+    type NestedFilter = OnlyBodies;
+
+    fn nested_visit_map(&mut self) -> Self::Map {
+        self.cx.tcx.hir()
+    }
+
+    fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) {
+        let Self { cx, .. } = *self;
+
+        if let ExprKind::Path(qpath) = expr.kind
+            && let res = cx.qpath_res(&qpath, expr.hir_id)
+            && let Some(call_def_id) = res.opt_def_id()
+            && let Some(def_id) = call_def_id.as_local()
+            && let Some(usage) = self.def_id_to_usage.get_mut(&def_id)
+        {
+            usage.1.push(expr.span);
+        }
+
+        walk_expr(self, expr);
+    }
+}
diff --git a/tests/ui/single_call_fn.rs b/tests/ui/single_call_fn.rs
new file mode 100644
index 00000000000..9806eaf3c42
--- /dev/null
+++ b/tests/ui/single_call_fn.rs
@@ -0,0 +1,49 @@
+//@aux-build:proc_macros.rs
+#![allow(unused)]
+#![warn(clippy::single_call_fn)]
+#![no_main]
+
+#[macro_use]
+extern crate proc_macros;
+
+// Do not lint since it's public
+pub fn f() {}
+
+fn g() {
+    f();
+}
+
+fn c() {
+    println!("really");
+    println!("long");
+    println!("function...");
+}
+
+fn d() {
+    c();
+}
+
+fn a() {}
+
+fn b() {
+    a();
+
+    external! {
+        fn lol() {
+            lol_inner();
+        }
+        fn lol_inner() {}
+    }
+    with_span! {
+        span
+        fn lol2() {
+            lol2_inner();
+        }
+        fn lol2_inner() {}
+    }
+}
+
+fn e() {
+    b();
+    b();
+}
diff --git a/tests/ui/single_call_fn.stderr b/tests/ui/single_call_fn.stderr
new file mode 100644
index 00000000000..decf561eed4
--- /dev/null
+++ b/tests/ui/single_call_fn.stderr
@@ -0,0 +1,31 @@
+error: this function is only used once
+  --> $DIR/single_call_fn.rs:26:1
+   |
+LL | fn a() {}
+   | ^^^^^^^^^
+   |
+help: used here
+  --> $DIR/single_call_fn.rs:29:5
+   |
+LL |     a();
+   |     ^
+   = note: `-D clippy::single-call-fn` implied by `-D warnings`
+
+error: this function is only used once
+  --> $DIR/single_call_fn.rs:16:1
+   |
+LL | / fn c() {
+LL | |     println!("really");
+LL | |     println!("long");
+LL | |     println!("function...");
+LL | | }
+   | |_^
+   |
+help: used here
+  --> $DIR/single_call_fn.rs:23:5
+   |
+LL |     c();
+   |     ^
+
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From a8605269bde2c82b5359997fc8cfdfef6a346ccf Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Wed, 14 Jun 2023 07:16:56 -0500
Subject: add test for closures

---
 clippy_lints/src/single_call_fn.rs |  8 +++---
 clippy_lints/src/utils/conf.rs     |  2 +-
 tests/ui/single_call_fn.rs         | 19 +++++++++++++-
 tests/ui/single_call_fn.stderr     | 52 ++++++++++++++++++++++++++++----------
 4 files changed, 61 insertions(+), 20 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/single_call_fn.rs b/clippy_lints/src/single_call_fn.rs
index d0fbedee832..55a19b813b4 100644
--- a/clippy_lints/src/single_call_fn.rs
+++ b/clippy_lints/src/single_call_fn.rs
@@ -88,14 +88,14 @@ impl<'tcx> LateLintPass<'tcx> for SingleCallFn {
         cx.tcx.hir().visit_all_item_likes_in_crate(&mut v);
 
         for usage in self.def_id_to_usage.values() {
-            let fn_span = usage.0;
-            if let [usage] = *usage.1 {
+            let single_call_fn_span = usage.0;
+            if let [caller_span] = *usage.1 {
                 span_lint_and_help(
                     cx,
                     SINGLE_CALL_FN,
-                    fn_span,
+                    single_call_fn_span,
                     "this function is only used once",
-                    Some(usage),
+                    Some(caller_span),
                     "used here",
                 );
             }
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index e8c8d478ffc..987e2abec50 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -289,7 +289,7 @@ define_Conf! {
     /// arithmetic-side-effects-allowed-unary = ["SomeType", "AnotherType"]
     /// ```
     (arithmetic_side_effects_allowed_unary: rustc_data_structures::fx::FxHashSet<String> = <_>::default()),
-    /// Lint: ENUM_VARIANT_NAMES, LARGE_TYPES_PASSED_BY_VALUE, TRIVIALLY_COPY_PASS_BY_REF, UNNECESSARY_WRAPS, UNUSED_SELF, UPPER_CASE_ACRONYMS, WRONG_SELF_CONVENTION, BOX_COLLECTION, REDUNDANT_ALLOCATION, RC_BUFFER, VEC_BOX, OPTION_OPTION, LINKEDLIST, RC_MUTEX, UNNECESSARY_BOX_RETURNS.
+    /// Lint: ENUM_VARIANT_NAMES, LARGE_TYPES_PASSED_BY_VALUE, TRIVIALLY_COPY_PASS_BY_REF, UNNECESSARY_WRAPS, UNUSED_SELF, UPPER_CASE_ACRONYMS, WRONG_SELF_CONVENTION, BOX_COLLECTION, REDUNDANT_ALLOCATION, RC_BUFFER, VEC_BOX, OPTION_OPTION, LINKEDLIST, RC_MUTEX, UNNECESSARY_BOX_RETURNS, SINGLE_CALL_FN.
     ///
     /// Suppress lints whenever the suggested change would cause breakage for other crates.
     (avoid_breaking_exported_api: bool = true),
diff --git a/tests/ui/single_call_fn.rs b/tests/ui/single_call_fn.rs
index 9806eaf3c42..e7f819cc8a1 100644
--- a/tests/ui/single_call_fn.rs
+++ b/tests/ui/single_call_fn.rs
@@ -1,5 +1,5 @@
 //@aux-build:proc_macros.rs
-#![allow(unused)]
+#![allow(clippy::redundant_closure_call, unused)]
 #![warn(clippy::single_call_fn)]
 #![no_main]
 
@@ -9,6 +9,23 @@ extern crate proc_macros;
 // Do not lint since it's public
 pub fn f() {}
 
+fn i() {}
+fn j() {}
+
+fn h() {
+    // Linted
+    let a = i;
+    // Do not lint closures
+    let a = (|| {
+        // Not linted
+        a();
+        // Imo, it's reasonable to lint this as the function is still only being used once. Just in
+        // a closure.
+        j();
+    });
+    a();
+}
+
 fn g() {
     f();
 }
diff --git a/tests/ui/single_call_fn.stderr b/tests/ui/single_call_fn.stderr
index decf561eed4..9ef8c487844 100644
--- a/tests/ui/single_call_fn.stderr
+++ b/tests/ui/single_call_fn.stderr
@@ -1,31 +1,55 @@
 error: this function is only used once
-  --> $DIR/single_call_fn.rs:26:1
+  --> $DIR/single_call_fn.rs:33:1
+   |
+LL | / fn c() {
+LL | |     println!("really");
+LL | |     println!("long");
+LL | |     println!("function...");
+LL | | }
+   | |_^
+   |
+help: used here
+  --> $DIR/single_call_fn.rs:40:5
+   |
+LL |     c();
+   |     ^
+   = note: `-D clippy::single-call-fn` implied by `-D warnings`
+
+error: this function is only used once
+  --> $DIR/single_call_fn.rs:12:1
+   |
+LL | fn i() {}
+   | ^^^^^^^^^
+   |
+help: used here
+  --> $DIR/single_call_fn.rs:17:13
+   |
+LL |     let a = i;
+   |             ^
+
+error: this function is only used once
+  --> $DIR/single_call_fn.rs:43:1
    |
 LL | fn a() {}
    | ^^^^^^^^^
    |
 help: used here
-  --> $DIR/single_call_fn.rs:29:5
+  --> $DIR/single_call_fn.rs:46:5
    |
 LL |     a();
    |     ^
-   = note: `-D clippy::single-call-fn` implied by `-D warnings`
 
 error: this function is only used once
-  --> $DIR/single_call_fn.rs:16:1
+  --> $DIR/single_call_fn.rs:13:1
    |
-LL | / fn c() {
-LL | |     println!("really");
-LL | |     println!("long");
-LL | |     println!("function...");
-LL | | }
-   | |_^
+LL | fn j() {}
+   | ^^^^^^^^^
    |
 help: used here
-  --> $DIR/single_call_fn.rs:23:5
+  --> $DIR/single_call_fn.rs:24:9
    |
-LL |     c();
-   |     ^
+LL |         j();
+   |         ^
 
-error: aborting due to 2 previous errors
+error: aborting due to 4 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 65b93a5b434596a545b97c0ad236e451745c87ff Mon Sep 17 00:00:00 2001
From: hehaoqian <39371646+hehaoqian@users.noreply.github.com>
Date: Sun, 18 Jun 2023 00:19:35 +0800
Subject: Fix false positive of [self_named_module_files] and
 [mod_module_files]

---
 clippy_lints/src/module_style.rs                   |  8 +++++
 tests/workspace.rs                                 | 40 ++++++++++++++++++++++
 tests/workspace_test/Cargo.toml                    |  2 +-
 .../pass_mod_with_dep_in_subdir/Cargo.toml         | 10 ++++++
 .../dep_no_mod/Cargo.toml                          |  9 +++++
 .../dep_no_mod/src/foo.rs                          |  2 ++
 .../dep_no_mod/src/foo/hello.rs                    |  1 +
 .../dep_no_mod/src/lib.rs                          |  5 +++
 .../pass_mod_with_dep_in_subdir/src/bad/mod.rs     |  1 +
 .../pass_mod_with_dep_in_subdir/src/main.rs        | 13 +++++++
 .../pass_mod_with_dep_in_subdir/src/more/foo.rs    |  1 +
 .../src/more/inner/mod.rs                          |  1 +
 .../pass_mod_with_dep_in_subdir/src/more/mod.rs    |  2 ++
 .../pass_no_mod_with_dep_in_subdir/Cargo.toml      | 10 ++++++
 .../dep_with_mod/Cargo.toml                        |  9 +++++
 .../dep_with_mod/src/lib.rs                        |  7 ++++
 .../dep_with_mod/src/with_mod/inner.rs             |  1 +
 .../dep_with_mod/src/with_mod/inner/stuff.rs       |  3 ++
 .../dep_with_mod/src/with_mod/inner/stuff/most.rs  |  1 +
 .../dep_with_mod/src/with_mod/mod.rs               |  3 ++
 .../pass_no_mod_with_dep_in_subdir/src/good.rs     |  1 +
 .../pass_no_mod_with_dep_in_subdir/src/main.rs     |  9 +++++
 22 files changed, 138 insertions(+), 1 deletion(-)
 create mode 100644 tests/workspace_test/module_style/pass_mod_with_dep_in_subdir/Cargo.toml
 create mode 100644 tests/workspace_test/module_style/pass_mod_with_dep_in_subdir/dep_no_mod/Cargo.toml
 create mode 100644 tests/workspace_test/module_style/pass_mod_with_dep_in_subdir/dep_no_mod/src/foo.rs
 create mode 100644 tests/workspace_test/module_style/pass_mod_with_dep_in_subdir/dep_no_mod/src/foo/hello.rs
 create mode 100644 tests/workspace_test/module_style/pass_mod_with_dep_in_subdir/dep_no_mod/src/lib.rs
 create mode 100644 tests/workspace_test/module_style/pass_mod_with_dep_in_subdir/src/bad/mod.rs
 create mode 100644 tests/workspace_test/module_style/pass_mod_with_dep_in_subdir/src/main.rs
 create mode 100644 tests/workspace_test/module_style/pass_mod_with_dep_in_subdir/src/more/foo.rs
 create mode 100644 tests/workspace_test/module_style/pass_mod_with_dep_in_subdir/src/more/inner/mod.rs
 create mode 100644 tests/workspace_test/module_style/pass_mod_with_dep_in_subdir/src/more/mod.rs
 create mode 100644 tests/workspace_test/module_style/pass_no_mod_with_dep_in_subdir/Cargo.toml
 create mode 100644 tests/workspace_test/module_style/pass_no_mod_with_dep_in_subdir/dep_with_mod/Cargo.toml
 create mode 100644 tests/workspace_test/module_style/pass_no_mod_with_dep_in_subdir/dep_with_mod/src/lib.rs
 create mode 100644 tests/workspace_test/module_style/pass_no_mod_with_dep_in_subdir/dep_with_mod/src/with_mod/inner.rs
 create mode 100644 tests/workspace_test/module_style/pass_no_mod_with_dep_in_subdir/dep_with_mod/src/with_mod/inner/stuff.rs
 create mode 100644 tests/workspace_test/module_style/pass_no_mod_with_dep_in_subdir/dep_with_mod/src/with_mod/inner/stuff/most.rs
 create mode 100644 tests/workspace_test/module_style/pass_no_mod_with_dep_in_subdir/dep_with_mod/src/with_mod/mod.rs
 create mode 100644 tests/workspace_test/module_style/pass_no_mod_with_dep_in_subdir/src/good.rs
 create mode 100644 tests/workspace_test/module_style/pass_no_mod_with_dep_in_subdir/src/main.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/module_style.rs b/clippy_lints/src/module_style.rs
index 349fcd2274d..b393db53b36 100644
--- a/clippy_lints/src/module_style.rs
+++ b/clippy_lints/src/module_style.rs
@@ -2,6 +2,7 @@ use rustc_ast::ast;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_lint::{EarlyContext, EarlyLintPass, Level, LintContext};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::def_id::LOCAL_CRATE;
 use rustc_span::{FileName, SourceFile, Span, SyntaxContext};
 use std::ffi::OsStr;
 use std::path::{Component, Path};
@@ -91,6 +92,13 @@ impl EarlyLintPass for ModStyle {
         let mut file_map = FxHashMap::default();
         for file in files.iter() {
             if let FileName::Real(name) = &file.name && let Some(lp) = name.local_path() {
+                if file.cnum != LOCAL_CRATE {
+                    // [#8887](https://github.com/rust-lang/rust-clippy/issues/8887)
+                    // Only check files in the current crate.
+                    // Fix false positive that crate dependency in workspace sub directory
+                    // is checked unintentionally.
+                    continue;
+                }
                 let path = if lp.is_relative() {
                     lp
                 } else if let Ok(relative) = lp.strip_prefix(trim_to_src) {
diff --git a/tests/workspace.rs b/tests/workspace.rs
index c9cbc50546c..699ab2be199 100644
--- a/tests/workspace.rs
+++ b/tests/workspace.rs
@@ -6,6 +6,46 @@ use test_utils::{CARGO_CLIPPY_PATH, IS_RUSTC_TEST_SUITE};
 
 mod test_utils;
 
+#[test]
+fn test_module_style_with_dep_in_subdir() {
+    if IS_RUSTC_TEST_SUITE {
+        return;
+    }
+    let root = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+    let target_dir = root.join("target").join("workspace_test");
+    let cwd = root.join("tests/workspace_test");
+
+    // Make sure we start with a clean state
+    Command::new("cargo")
+        .current_dir(&cwd)
+        .env("CARGO_TARGET_DIR", &target_dir)
+        .arg("clean")
+        .args(["-p", "pass-no-mod-with-dep-in-subdir"])
+        .args(["-p", "pass-mod-with-dep-in-subdir"])
+        .output()
+        .unwrap();
+
+    // [#8887](https://github.com/rust-lang/rust-clippy/issues/8887)
+    // `mod.rs` checks should not be applied to crate dependencies
+    // located in the subdirectory of workspace
+    let output = Command::new(&*CARGO_CLIPPY_PATH)
+        .current_dir(&cwd)
+        .env("CARGO_INCREMENTAL", "0")
+        .env("CARGO_TARGET_DIR", &target_dir)
+        .arg("clippy")
+        .args(["-p", "pass-no-mod-with-dep-in-subdir"])
+        .args(["-p", "pass-mod-with-dep-in-subdir"])
+        .arg("--")
+        .arg("-Cdebuginfo=0") // disable debuginfo to generate less data in the target dir
+        .output()
+        .unwrap();
+
+    println!("status: {}", output.status);
+    println!("stdout: {}", String::from_utf8_lossy(&output.stdout));
+    println!("stderr: {}", String::from_utf8_lossy(&output.stderr));
+    assert!(output.status.success());
+}
+
 #[test]
 fn test_no_deps_ignores_path_deps_in_workspaces() {
     if IS_RUSTC_TEST_SUITE {
diff --git a/tests/workspace_test/Cargo.toml b/tests/workspace_test/Cargo.toml
index bf5b4ca5288..d24b278ccc2 100644
--- a/tests/workspace_test/Cargo.toml
+++ b/tests/workspace_test/Cargo.toml
@@ -4,4 +4,4 @@ version = "0.1.0"
 edition = "2018"
 
 [workspace]
-members = ["subcrate"]
+members = ["subcrate", "module_style/pass_no_mod_with_dep_in_subdir", "module_style/pass_mod_with_dep_in_subdir"]
diff --git a/tests/workspace_test/module_style/pass_mod_with_dep_in_subdir/Cargo.toml b/tests/workspace_test/module_style/pass_mod_with_dep_in_subdir/Cargo.toml
new file mode 100644
index 00000000000..15dcde4e30a
--- /dev/null
+++ b/tests/workspace_test/module_style/pass_mod_with_dep_in_subdir/Cargo.toml
@@ -0,0 +1,10 @@
+[package]
+name = "pass-mod-with-dep-in-subdir"
+version = "0.1.0"
+edition = "2018"
+publish = false
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+dep-no-mod = { path = "dep_no_mod"}
diff --git a/tests/workspace_test/module_style/pass_mod_with_dep_in_subdir/dep_no_mod/Cargo.toml b/tests/workspace_test/module_style/pass_mod_with_dep_in_subdir/dep_no_mod/Cargo.toml
new file mode 100644
index 00000000000..55569bc25ed
--- /dev/null
+++ b/tests/workspace_test/module_style/pass_mod_with_dep_in_subdir/dep_no_mod/Cargo.toml
@@ -0,0 +1,9 @@
+[package]
+name = "dep-no-mod"
+version = "0.1.0"
+edition = "2018"
+publish = false
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
diff --git a/tests/workspace_test/module_style/pass_mod_with_dep_in_subdir/dep_no_mod/src/foo.rs b/tests/workspace_test/module_style/pass_mod_with_dep_in_subdir/dep_no_mod/src/foo.rs
new file mode 100644
index 00000000000..7b0966a4586
--- /dev/null
+++ b/tests/workspace_test/module_style/pass_mod_with_dep_in_subdir/dep_no_mod/src/foo.rs
@@ -0,0 +1,2 @@
+pub mod hello;
+pub struct Thing;
diff --git a/tests/workspace_test/module_style/pass_mod_with_dep_in_subdir/dep_no_mod/src/foo/hello.rs b/tests/workspace_test/module_style/pass_mod_with_dep_in_subdir/dep_no_mod/src/foo/hello.rs
new file mode 100644
index 00000000000..99940dce528
--- /dev/null
+++ b/tests/workspace_test/module_style/pass_mod_with_dep_in_subdir/dep_no_mod/src/foo/hello.rs
@@ -0,0 +1 @@
+pub struct Hello;
diff --git a/tests/workspace_test/module_style/pass_mod_with_dep_in_subdir/dep_no_mod/src/lib.rs b/tests/workspace_test/module_style/pass_mod_with_dep_in_subdir/dep_no_mod/src/lib.rs
new file mode 100644
index 00000000000..c62f9acbf2c
--- /dev/null
+++ b/tests/workspace_test/module_style/pass_mod_with_dep_in_subdir/dep_no_mod/src/lib.rs
@@ -0,0 +1,5 @@
+pub mod foo;
+
+pub fn foo() {
+    let _ = foo::Thing;
+}
diff --git a/tests/workspace_test/module_style/pass_mod_with_dep_in_subdir/src/bad/mod.rs b/tests/workspace_test/module_style/pass_mod_with_dep_in_subdir/src/bad/mod.rs
new file mode 100644
index 00000000000..f19ab10d5fb
--- /dev/null
+++ b/tests/workspace_test/module_style/pass_mod_with_dep_in_subdir/src/bad/mod.rs
@@ -0,0 +1 @@
+pub struct Thing;
diff --git a/tests/workspace_test/module_style/pass_mod_with_dep_in_subdir/src/main.rs b/tests/workspace_test/module_style/pass_mod_with_dep_in_subdir/src/main.rs
new file mode 100644
index 00000000000..5cb4795e945
--- /dev/null
+++ b/tests/workspace_test/module_style/pass_mod_with_dep_in_subdir/src/main.rs
@@ -0,0 +1,13 @@
+#![deny(clippy::self_named_module_files)]
+
+mod bad;
+mod more;
+extern crate dep_no_mod;
+
+fn main() {
+    let _ = bad::Thing;
+    let _ = more::foo::Foo;
+    let _ = more::inner::Inner;
+    let _ = dep_no_mod::foo::Thing;
+    let _ = dep_no_mod::foo::hello::Hello;
+}
diff --git a/tests/workspace_test/module_style/pass_mod_with_dep_in_subdir/src/more/foo.rs b/tests/workspace_test/module_style/pass_mod_with_dep_in_subdir/src/more/foo.rs
new file mode 100644
index 00000000000..4a835673a59
--- /dev/null
+++ b/tests/workspace_test/module_style/pass_mod_with_dep_in_subdir/src/more/foo.rs
@@ -0,0 +1 @@
+pub struct Foo;
diff --git a/tests/workspace_test/module_style/pass_mod_with_dep_in_subdir/src/more/inner/mod.rs b/tests/workspace_test/module_style/pass_mod_with_dep_in_subdir/src/more/inner/mod.rs
new file mode 100644
index 00000000000..aa84f78cc2c
--- /dev/null
+++ b/tests/workspace_test/module_style/pass_mod_with_dep_in_subdir/src/more/inner/mod.rs
@@ -0,0 +1 @@
+pub struct Inner;
diff --git a/tests/workspace_test/module_style/pass_mod_with_dep_in_subdir/src/more/mod.rs b/tests/workspace_test/module_style/pass_mod_with_dep_in_subdir/src/more/mod.rs
new file mode 100644
index 00000000000..d79569f78ff
--- /dev/null
+++ b/tests/workspace_test/module_style/pass_mod_with_dep_in_subdir/src/more/mod.rs
@@ -0,0 +1,2 @@
+pub mod foo;
+pub mod inner;
diff --git a/tests/workspace_test/module_style/pass_no_mod_with_dep_in_subdir/Cargo.toml b/tests/workspace_test/module_style/pass_no_mod_with_dep_in_subdir/Cargo.toml
new file mode 100644
index 00000000000..060cb18dc9f
--- /dev/null
+++ b/tests/workspace_test/module_style/pass_no_mod_with_dep_in_subdir/Cargo.toml
@@ -0,0 +1,10 @@
+[package]
+name = "pass-no-mod-with-dep-in-subdir"
+version = "0.1.0"
+edition = "2018"
+publish = false
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+dep-with-mod = { path = "dep_with_mod"}
diff --git a/tests/workspace_test/module_style/pass_no_mod_with_dep_in_subdir/dep_with_mod/Cargo.toml b/tests/workspace_test/module_style/pass_no_mod_with_dep_in_subdir/dep_with_mod/Cargo.toml
new file mode 100644
index 00000000000..b25725cd561
--- /dev/null
+++ b/tests/workspace_test/module_style/pass_no_mod_with_dep_in_subdir/dep_with_mod/Cargo.toml
@@ -0,0 +1,9 @@
+[package]
+name = "dep-with-mod"
+version = "0.1.0"
+edition = "2018"
+publish = false
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
diff --git a/tests/workspace_test/module_style/pass_no_mod_with_dep_in_subdir/dep_with_mod/src/lib.rs b/tests/workspace_test/module_style/pass_no_mod_with_dep_in_subdir/dep_with_mod/src/lib.rs
new file mode 100644
index 00000000000..4647424f2c2
--- /dev/null
+++ b/tests/workspace_test/module_style/pass_no_mod_with_dep_in_subdir/dep_with_mod/src/lib.rs
@@ -0,0 +1,7 @@
+pub mod with_mod;
+
+pub fn foo() {
+    let _ = with_mod::Thing;
+    let _ = with_mod::inner::stuff::Inner;
+    let _ = with_mod::inner::stuff::most::Snarks;
+}
diff --git a/tests/workspace_test/module_style/pass_no_mod_with_dep_in_subdir/dep_with_mod/src/with_mod/inner.rs b/tests/workspace_test/module_style/pass_no_mod_with_dep_in_subdir/dep_with_mod/src/with_mod/inner.rs
new file mode 100644
index 00000000000..91cd540a28f
--- /dev/null
+++ b/tests/workspace_test/module_style/pass_no_mod_with_dep_in_subdir/dep_with_mod/src/with_mod/inner.rs
@@ -0,0 +1 @@
+pub mod stuff;
diff --git a/tests/workspace_test/module_style/pass_no_mod_with_dep_in_subdir/dep_with_mod/src/with_mod/inner/stuff.rs b/tests/workspace_test/module_style/pass_no_mod_with_dep_in_subdir/dep_with_mod/src/with_mod/inner/stuff.rs
new file mode 100644
index 00000000000..7713fa9d35c
--- /dev/null
+++ b/tests/workspace_test/module_style/pass_no_mod_with_dep_in_subdir/dep_with_mod/src/with_mod/inner/stuff.rs
@@ -0,0 +1,3 @@
+pub mod most;
+
+pub struct Inner;
diff --git a/tests/workspace_test/module_style/pass_no_mod_with_dep_in_subdir/dep_with_mod/src/with_mod/inner/stuff/most.rs b/tests/workspace_test/module_style/pass_no_mod_with_dep_in_subdir/dep_with_mod/src/with_mod/inner/stuff/most.rs
new file mode 100644
index 00000000000..5a5eaf9670f
--- /dev/null
+++ b/tests/workspace_test/module_style/pass_no_mod_with_dep_in_subdir/dep_with_mod/src/with_mod/inner/stuff/most.rs
@@ -0,0 +1 @@
+pub struct Snarks;
diff --git a/tests/workspace_test/module_style/pass_no_mod_with_dep_in_subdir/dep_with_mod/src/with_mod/mod.rs b/tests/workspace_test/module_style/pass_no_mod_with_dep_in_subdir/dep_with_mod/src/with_mod/mod.rs
new file mode 100644
index 00000000000..a12734db7cb
--- /dev/null
+++ b/tests/workspace_test/module_style/pass_no_mod_with_dep_in_subdir/dep_with_mod/src/with_mod/mod.rs
@@ -0,0 +1,3 @@
+pub mod inner;
+
+pub struct Thing;
diff --git a/tests/workspace_test/module_style/pass_no_mod_with_dep_in_subdir/src/good.rs b/tests/workspace_test/module_style/pass_no_mod_with_dep_in_subdir/src/good.rs
new file mode 100644
index 00000000000..f19ab10d5fb
--- /dev/null
+++ b/tests/workspace_test/module_style/pass_no_mod_with_dep_in_subdir/src/good.rs
@@ -0,0 +1 @@
+pub struct Thing;
diff --git a/tests/workspace_test/module_style/pass_no_mod_with_dep_in_subdir/src/main.rs b/tests/workspace_test/module_style/pass_no_mod_with_dep_in_subdir/src/main.rs
new file mode 100644
index 00000000000..42eb99cd7a3
--- /dev/null
+++ b/tests/workspace_test/module_style/pass_no_mod_with_dep_in_subdir/src/main.rs
@@ -0,0 +1,9 @@
+#![deny(clippy::mod_module_files)]
+
+mod good;
+pub use dep_with_mod::with_mod::Thing;
+
+fn main() {
+    let _ = good::Thing;
+    let _ = dep_with_mod::with_mod::Thing;
+}
-- 
cgit 1.4.1-3-g733a5


From c5a9adc2bef3afcaf8bcdb260e218a82911a034e Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Sun, 18 Jun 2023 22:20:10 +0200
Subject: new lint: `type_id_on_box`

---
 CHANGELOG.md                               |  1 +
 clippy_lints/src/declared_lints.rs         |  1 +
 clippy_lints/src/methods/mod.rs            | 35 ++++++++++++++++
 clippy_lints/src/methods/type_id_on_box.rs | 64 ++++++++++++++++++++++++++++++
 tests/ui/type_id_on_box.fixed              | 20 ++++++++++
 tests/ui/type_id_on_box.rs                 | 20 ++++++++++
 tests/ui/type_id_on_box.stderr             | 25 ++++++++++++
 7 files changed, 166 insertions(+)
 create mode 100644 clippy_lints/src/methods/type_id_on_box.rs
 create mode 100644 tests/ui/type_id_on_box.fixed
 create mode 100644 tests/ui/type_id_on_box.rs
 create mode 100644 tests/ui/type_id_on_box.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 269be545b0a..f82a3739259 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5230,6 +5230,7 @@ Released 2018-09-13
 [`trivially_copy_pass_by_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#trivially_copy_pass_by_ref
 [`try_err`]: https://rust-lang.github.io/rust-clippy/master/index.html#try_err
 [`type_complexity`]: https://rust-lang.github.io/rust-clippy/master/index.html#type_complexity
+[`type_id_on_box`]: https://rust-lang.github.io/rust-clippy/master/index.html#type_id_on_box
 [`type_repetition_in_bounds`]: https://rust-lang.github.io/rust-clippy/master/index.html#type_repetition_in_bounds
 [`unchecked_duration_subtraction`]: https://rust-lang.github.io/rust-clippy/master/index.html#unchecked_duration_subtraction
 [`undocumented_unsafe_blocks`]: https://rust-lang.github.io/rust-clippy/master/index.html#undocumented_unsafe_blocks
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 7690e8f7247..0a2db21ca95 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -403,6 +403,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::methods::SUSPICIOUS_MAP_INFO,
     crate::methods::SUSPICIOUS_SPLITN_INFO,
     crate::methods::SUSPICIOUS_TO_OWNED_INFO,
+    crate::methods::TYPE_ID_ON_BOX_INFO,
     crate::methods::UNINIT_ASSUMED_INIT_INFO,
     crate::methods::UNIT_HASH_INFO,
     crate::methods::UNNECESSARY_FILTER_MAP_INFO,
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 99c984ba65a..e98fe99eac7 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -87,6 +87,7 @@ mod suspicious_command_arg_space;
 mod suspicious_map;
 mod suspicious_splitn;
 mod suspicious_to_owned;
+mod type_id_on_box;
 mod uninit_assumed_init;
 mod unit_hash;
 mod unnecessary_filter_map;
@@ -2922,6 +2923,37 @@ declare_clippy_lint! {
     "use of sort() when sort_unstable() is equivalent"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Looks for calls to `<Box<dyn Any> as Any>::type_id`.
+    ///
+    /// ### Why is this bad?
+    /// This most certainly does not do what the user expects and is very easy to miss.
+    /// Calling `type_id` on a `Box<dyn Any>` calls `type_id` on the `Box<..>` itself,
+    /// so this will return the `TypeId` of the `Box<dyn Any>` type (not the type id
+    /// of the value referenced by the box!).
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// use std::any::{Any, TypeId};
+    ///
+    /// let any_box: Box<dyn Any> = Box::new(42_i32);
+    /// assert_eq!(any_box.type_id(), TypeId::of::<i32>()); // ⚠️ this fails!
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// use std::any::{Any, TypeId};
+    ///
+    /// let any_box: Box<dyn Any> = Box::new(42_i32);
+    /// assert_eq!((*any_box).type_id(), TypeId::of::<i32>());
+    /// //          ^ dereference first, to call `type_id` on `dyn Any`
+    /// ```
+    #[clippy::version = "1.47.0"]
+    pub TYPE_ID_ON_BOX,
+    suspicious,
+    "calling `.type_id()` on `Box<dyn Any>`"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Detects `().hash(_)`.
@@ -3878,6 +3910,9 @@ impl Methods {
                 ("to_os_string" | "to_path_buf" | "to_vec", []) => {
                     implicit_clone::check(cx, name, expr, recv);
                 },
+                ("type_id", []) => {
+                    type_id_on_box::check(cx, recv, expr.span);
+                }
                 ("unwrap", []) => {
                     match method_call(recv) {
                         Some(("get", recv, [get_arg], _, _)) => {
diff --git a/clippy_lints/src/methods/type_id_on_box.rs b/clippy_lints/src/methods/type_id_on_box.rs
new file mode 100644
index 00000000000..8ccbd0d8d1b
--- /dev/null
+++ b/clippy_lints/src/methods/type_id_on_box.rs
@@ -0,0 +1,64 @@
+use crate::methods::TYPE_ID_ON_BOX;
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::source::snippet;
+use rustc_errors::Applicability;
+use rustc_hir::Expr;
+use rustc_lint::LateContext;
+use rustc_middle::ty::adjustment::Adjust;
+use rustc_middle::ty::adjustment::Adjustment;
+use rustc_middle::ty::Ty;
+use rustc_middle::ty::{self, ExistentialPredicate};
+use rustc_span::{sym, Span};
+
+fn is_dyn_trait(cx: &LateContext<'_>, ty: Ty<'_>) -> bool {
+    if let ty::Dynamic(preds, ..) = ty.kind() {
+        preds.iter().any(|p| match p.skip_binder() {
+            ExistentialPredicate::Trait(tr) => cx.tcx.is_diagnostic_item(sym::Any, tr.def_id),
+            _ => false,
+        })
+    } else {
+        false
+    }
+}
+
+pub(super) fn check(cx: &LateContext<'_>, receiver: &Expr<'_>, call_span: Span) {
+    let recv_adjusts = cx.typeck_results().expr_adjustments(receiver);
+
+    if let Some(Adjustment { target: recv_ty, .. }) = recv_adjusts.last()
+        && let ty::Ref(_, ty, _) = recv_ty.kind()
+        && let ty::Adt(adt, substs) = ty.kind()
+        && adt.is_box()
+        && is_dyn_trait(cx, substs.type_at(0))
+    {
+        span_lint_and_then(
+            cx,
+            TYPE_ID_ON_BOX,
+            call_span,
+            "calling `.type_id()` on a `Box<dyn Any>`",
+            |diag| {
+                let derefs = recv_adjusts
+                    .iter()
+                    .filter(|adj| matches!(adj.kind, Adjust::Deref(None)))
+                    .count();
+
+                let mut sugg = "*".repeat(derefs + 1);
+                sugg += &snippet(cx, receiver.span, "<expr>");
+
+                diag.note(
+                    "this returns the type id of the literal type `Box<dyn Any>` instead of the \
+                    type id of the boxed value, which is most likely not what you want"
+                )
+                .note(
+                    "if this is intentional, use `TypeId::of::<Box<dyn Any>>()` instead, \
+                    which makes it more clear"
+                )
+                .span_suggestion(
+                    receiver.span,
+                    "consider dereferencing first",
+                    format!("({sugg})"),
+                    Applicability::MaybeIncorrect,
+                );
+            },
+        );
+    }
+}
diff --git a/tests/ui/type_id_on_box.fixed b/tests/ui/type_id_on_box.fixed
new file mode 100644
index 00000000000..fc177afacd4
--- /dev/null
+++ b/tests/ui/type_id_on_box.fixed
@@ -0,0 +1,20 @@
+//@run-rustfix
+
+#![warn(clippy::type_id_on_box)]
+
+use std::any::{Any, TypeId};
+
+fn existential() -> impl Any {
+    Box::new(1) as Box<dyn Any>
+}
+
+fn main() {
+    let any_box: Box<dyn Any> = Box::new(0usize);
+    let _ = (*any_box).type_id();
+    let _ = TypeId::of::<Box<dyn Any>>(); // don't lint, user probably explicitly wants to do this
+    let _ = (*any_box).type_id();
+    let any_box: &Box<dyn Any> = &(Box::new(0usize) as Box<dyn Any>);
+    let _ = (**any_box).type_id(); // 2 derefs are needed here
+    let b = existential();
+    let _ = b.type_id(); // don't lint
+}
diff --git a/tests/ui/type_id_on_box.rs b/tests/ui/type_id_on_box.rs
new file mode 100644
index 00000000000..36cf631a092
--- /dev/null
+++ b/tests/ui/type_id_on_box.rs
@@ -0,0 +1,20 @@
+//@run-rustfix
+
+#![warn(clippy::type_id_on_box)]
+
+use std::any::{Any, TypeId};
+
+fn existential() -> impl Any {
+    Box::new(1) as Box<dyn Any>
+}
+
+fn main() {
+    let any_box: Box<dyn Any> = Box::new(0usize);
+    let _ = any_box.type_id();
+    let _ = TypeId::of::<Box<dyn Any>>(); // don't lint, user probably explicitly wants to do this
+    let _ = (*any_box).type_id();
+    let any_box: &Box<dyn Any> = &(Box::new(0usize) as Box<dyn Any>);
+    let _ = any_box.type_id(); // 2 derefs are needed here
+    let b = existential();
+    let _ = b.type_id(); // don't lint
+}
diff --git a/tests/ui/type_id_on_box.stderr b/tests/ui/type_id_on_box.stderr
new file mode 100644
index 00000000000..47e0e814daf
--- /dev/null
+++ b/tests/ui/type_id_on_box.stderr
@@ -0,0 +1,25 @@
+error: calling `.type_id()` on a `Box<dyn Any>`
+  --> $DIR/type_id_on_box.rs:13:13
+   |
+LL |     let _ = any_box.type_id();
+   |             -------^^^^^^^^^^
+   |             |
+   |             help: consider dereferencing first: `(*any_box)`
+   |
+   = note: this returns the type id of the literal type `Box<dyn Any>` instead of the type id of the boxed value, which is most likely not what you want
+   = note: if this is intentional, use `TypeId::of::<Box<dyn Any>>()` instead, which makes it more clear
+   = note: `-D clippy::type-id-on-box` implied by `-D warnings`
+
+error: calling `.type_id()` on a `Box<dyn Any>`
+  --> $DIR/type_id_on_box.rs:17:13
+   |
+LL |     let _ = any_box.type_id(); // 2 derefs are needed here
+   |             -------^^^^^^^^^^
+   |             |
+   |             help: consider dereferencing first: `(**any_box)`
+   |
+   = note: this returns the type id of the literal type `Box<dyn Any>` instead of the type id of the boxed value, which is most likely not what you want
+   = note: if this is intentional, use `TypeId::of::<Box<dyn Any>>()` instead, which makes it more clear
+
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 9ab1e8e95c45cbe9cdf657bded08a7d874e48fbd Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Sun, 18 Jun 2023 22:27:20 +0200
Subject: that was definitely not the right version

---
 clippy_lints/src/methods/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index e98fe99eac7..255a8cc0a95 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -2948,7 +2948,7 @@ declare_clippy_lint! {
     /// assert_eq!((*any_box).type_id(), TypeId::of::<i32>());
     /// //          ^ dereference first, to call `type_id` on `dyn Any`
     /// ```
-    #[clippy::version = "1.47.0"]
+    #[clippy::version = "1.72.0"]
     pub TYPE_ID_ON_BOX,
     suspicious,
     "calling `.type_id()` on `Box<dyn Any>`"
-- 
cgit 1.4.1-3-g733a5


From 26ac76c15f4a12b2debde692dfff02a08d516f6e Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Sun, 18 Jun 2023 22:36:08 +0200
Subject: add it to the methods lint pass

---
 clippy_lints/src/methods/mod.rs | 1 +
 1 file changed, 1 insertion(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 255a8cc0a95..6c0e15d16d7 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3389,6 +3389,7 @@ impl_lint_pass!(Methods => [
     STRING_EXTEND_CHARS,
     ITER_CLONED_COLLECT,
     ITER_WITH_DRAIN,
+    TYPE_ID_ON_BOX,
     USELESS_ASREF,
     UNNECESSARY_FOLD,
     UNNECESSARY_FILTER_MAP,
-- 
cgit 1.4.1-3-g733a5


From 2cd4a9182a4b4a1030594866414a3100b594343e Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Sat, 17 Jun 2023 20:00:36 -0500
Subject: Ignore functions annotated with `#[test]`

---
 book/src/lint_configuration.md     |  1 +
 clippy_lints/src/single_call_fn.rs |  5 +++--
 tests/ui/single_call_fn.rs         |  9 +++++++++
 tests/ui/single_call_fn.stderr     | 16 ++++++++--------
 4 files changed, 21 insertions(+), 10 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/book/src/lint_configuration.md b/book/src/lint_configuration.md
index 78a5f9da461..cc4caae566f 100644
--- a/book/src/lint_configuration.md
+++ b/book/src/lint_configuration.md
@@ -94,6 +94,7 @@ Suppress lints whenever the suggested change would cause breakage for other crat
 * [`linkedlist`](https://rust-lang.github.io/rust-clippy/master/index.html#linkedlist)
 * [`rc_mutex`](https://rust-lang.github.io/rust-clippy/master/index.html#rc_mutex)
 * [`unnecessary_box_returns`](https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_box_returns)
+* [`single_call_fn`](https://rust-lang.github.io/rust-clippy/master/index.html#single_call_fn)
 
 
 ## `msrv`
diff --git a/clippy_lints/src/single_call_fn.rs b/clippy_lints/src/single_call_fn.rs
index 55a19b813b4..42753d2e951 100644
--- a/clippy_lints/src/single_call_fn.rs
+++ b/clippy_lints/src/single_call_fn.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_help;
-use clippy_utils::is_from_proc_macro;
+use clippy_utils::{is_from_proc_macro, is_in_test_function};
 use rustc_data_structures::fx::FxHashMap;
 use rustc_hir::def_id::LocalDefId;
 use rustc_hir::intravisit::{walk_expr, Visitor};
@@ -12,7 +12,7 @@ use rustc_span::Span;
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for functions that are only used once.
+    /// Checks for functions that are only used once. Does not lint tests.
     ///
     /// ### Why is this bad?
     /// It's usually not, splitting a function into multiple parts often improves readability and in
@@ -73,6 +73,7 @@ impl<'tcx> LateLintPass<'tcx> for SingleCallFn {
         if self.avoid_breaking_exported_api && cx.effective_visibilities.is_exported(def_id)
             || in_external_macro(cx.sess(), span)
             || is_from_proc_macro(cx, &(&kind, body, cx.tcx.local_def_id_to_hir_id(def_id), span))
+            || is_in_test_function(cx.tcx, body.value.hir_id)
         {
             return;
         }
diff --git a/tests/ui/single_call_fn.rs b/tests/ui/single_call_fn.rs
index e7f819cc8a1..bfb773187fb 100644
--- a/tests/ui/single_call_fn.rs
+++ b/tests/ui/single_call_fn.rs
@@ -1,4 +1,5 @@
 //@aux-build:proc_macros.rs
+//@compile-flags: --test
 #![allow(clippy::redundant_closure_call, unused)]
 #![warn(clippy::single_call_fn)]
 #![no_main]
@@ -64,3 +65,11 @@ fn e() {
     b();
     b();
 }
+
+#[test]
+fn k() {}
+
+#[test]
+fn l() {
+    k();
+}
diff --git a/tests/ui/single_call_fn.stderr b/tests/ui/single_call_fn.stderr
index 9ef8c487844..bb92e3cf71a 100644
--- a/tests/ui/single_call_fn.stderr
+++ b/tests/ui/single_call_fn.stderr
@@ -1,5 +1,5 @@
 error: this function is only used once
-  --> $DIR/single_call_fn.rs:33:1
+  --> $DIR/single_call_fn.rs:34:1
    |
 LL | / fn c() {
 LL | |     println!("really");
@@ -9,44 +9,44 @@ LL | | }
    | |_^
    |
 help: used here
-  --> $DIR/single_call_fn.rs:40:5
+  --> $DIR/single_call_fn.rs:41:5
    |
 LL |     c();
    |     ^
    = note: `-D clippy::single-call-fn` implied by `-D warnings`
 
 error: this function is only used once
-  --> $DIR/single_call_fn.rs:12:1
+  --> $DIR/single_call_fn.rs:13:1
    |
 LL | fn i() {}
    | ^^^^^^^^^
    |
 help: used here
-  --> $DIR/single_call_fn.rs:17:13
+  --> $DIR/single_call_fn.rs:18:13
    |
 LL |     let a = i;
    |             ^
 
 error: this function is only used once
-  --> $DIR/single_call_fn.rs:43:1
+  --> $DIR/single_call_fn.rs:44:1
    |
 LL | fn a() {}
    | ^^^^^^^^^
    |
 help: used here
-  --> $DIR/single_call_fn.rs:46:5
+  --> $DIR/single_call_fn.rs:47:5
    |
 LL |     a();
    |     ^
 
 error: this function is only used once
-  --> $DIR/single_call_fn.rs:13:1
+  --> $DIR/single_call_fn.rs:14:1
    |
 LL | fn j() {}
    | ^^^^^^^^^
    |
 help: used here
-  --> $DIR/single_call_fn.rs:24:9
+  --> $DIR/single_call_fn.rs:25:9
    |
 LL |         j();
    |         ^
-- 
cgit 1.4.1-3-g733a5


From e11ebbd5e77d8faa6c1cbd11be6f050199382845 Mon Sep 17 00:00:00 2001
From: hehaoqian <haoqianhe1@gmail.com>
Date: Mon, 19 Jun 2023 08:19:06 +0800
Subject: Move continue into if statement

Co-authored-by: Catherine <114838443+Centri3@users.noreply.github.com>
---
 clippy_lints/src/module_style.rs | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/module_style.rs b/clippy_lints/src/module_style.rs
index b393db53b36..439cae812b7 100644
--- a/clippy_lints/src/module_style.rs
+++ b/clippy_lints/src/module_style.rs
@@ -91,14 +91,14 @@ impl EarlyLintPass for ModStyle {
         // `{ foo => path/to/foo.rs, .. }
         let mut file_map = FxHashMap::default();
         for file in files.iter() {
-            if let FileName::Real(name) = &file.name && let Some(lp) = name.local_path() {
-                if file.cnum != LOCAL_CRATE {
-                    // [#8887](https://github.com/rust-lang/rust-clippy/issues/8887)
-                    // Only check files in the current crate.
-                    // Fix false positive that crate dependency in workspace sub directory
-                    // is checked unintentionally.
-                    continue;
-                }
+            if let FileName::Real(name) = &file.name
+                && let Some(lp) = name.local_path()
+                && file.cnum == LOCAL_CRATE
+            {
+                // [#8887](https://github.com/rust-lang/rust-clippy/issues/8887)
+                // Only check files in the current crate.
+                // Fix false positive that crate dependency in workspace sub directory
+                // is checked unintentionally.
                 let path = if lp.is_relative() {
                     lp
                 } else if let Ok(relative) = lp.strip_prefix(trim_to_src) {
-- 
cgit 1.4.1-3-g733a5


From 66590ba41b21d38aa28e659e282afcbeb0fdbd13 Mon Sep 17 00:00:00 2001
From: Eric Mark Martin <ericmarkmartin@gmail.com>
Date: Mon, 19 Jun 2023 03:44:04 -0400
Subject: use PlaceRef abstractions

---
 clippy_lints/src/redundant_clone.rs      | 15 +++++----------
 clippy_utils/src/qualify_min_const_fn.rs |  7 ++-----
 2 files changed, 7 insertions(+), 15 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/redundant_clone.rs b/clippy_lints/src/redundant_clone.rs
index 685d738cbb7..e36adef555e 100644
--- a/clippy_lints/src/redundant_clone.rs
+++ b/clippy_lints/src/redundant_clone.rs
@@ -320,8 +320,6 @@ fn base_local_and_movability<'tcx>(
     mir: &mir::Body<'tcx>,
     place: mir::Place<'tcx>,
 ) -> (mir::Local, CannotMoveOut) {
-    use rustc_middle::mir::PlaceRef;
-
     // Dereference. You cannot move things out from a borrowed value.
     let mut deref = false;
     // Accessing a field of an ADT that has `Drop`. Moving the field out will cause E0509.
@@ -330,17 +328,14 @@ fn base_local_and_movability<'tcx>(
     // underlying type implements Copy
     let mut slice = false;
 
-    let PlaceRef { local, mut projection } = place.as_ref();
-    while let [base @ .., elem] = projection {
-        projection = base;
+    for (base, elem) in place.as_ref().iter_projections() {
+        let base_ty = base.ty(&mir.local_decls, cx.tcx).ty;
         deref |= matches!(elem, mir::ProjectionElem::Deref);
-        field |= matches!(elem, mir::ProjectionElem::Field(..))
-            && has_drop(cx, mir::Place::ty_from(local, projection, &mir.local_decls, cx.tcx).ty);
-        slice |= matches!(elem, mir::ProjectionElem::Index(..))
-            && !is_copy(cx, mir::Place::ty_from(local, projection, &mir.local_decls, cx.tcx).ty);
+        field |= matches!(elem, mir::ProjectionElem::Field(..)) && has_drop(cx, base_ty);
+        slice |= matches!(elem, mir::ProjectionElem::Index(..)) && !is_copy(cx, base_ty);
     }
 
-    (local, deref || field || slice)
+    (place.local, deref || field || slice)
 }
 
 #[derive(Default)]
diff --git a/clippy_utils/src/qualify_min_const_fn.rs b/clippy_utils/src/qualify_min_const_fn.rs
index dcd372f689d..3e261b20465 100644
--- a/clippy_utils/src/qualify_min_const_fn.rs
+++ b/clippy_utils/src/qualify_min_const_fn.rs
@@ -284,13 +284,10 @@ fn check_operand<'tcx>(tcx: TyCtxt<'tcx>, operand: &Operand<'tcx>, span: Span, b
 }
 
 fn check_place<'tcx>(tcx: TyCtxt<'tcx>, place: Place<'tcx>, span: Span, body: &Body<'tcx>) -> McfResult {
-    let mut cursor = place.projection.as_ref();
-
-    while let [ref proj_base @ .., elem] = *cursor {
-        cursor = proj_base;
+    for (base, elem) in place.as_ref().iter_projections() {
         match elem {
             ProjectionElem::Field(..) => {
-                let base_ty = Place::ty_from(place.local, proj_base, body, tcx).ty;
+                let base_ty = base.ty(body, tcx).ty;
                 if let Some(def) = base_ty.ty_adt_def() {
                     // No union field accesses in `const fn`
                     if def.is_union() {
-- 
cgit 1.4.1-3-g733a5


From d7e723441ed8747e6e280808abd0e99da40d2100 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Mon, 19 Jun 2023 17:18:27 +0200
Subject: [`single_match`]: don't lint if block contains comments

---
 clippy_lints/src/matches/single_match.rs | 24 ++++++++++++++++++++----
 tests/ui/single_match.fixed              | 26 ++++++++++++++++++++++++++
 tests/ui/single_match.rs                 | 26 ++++++++++++++++++++++++++
 3 files changed, 72 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/single_match.rs b/clippy_lints/src/matches/single_match.rs
index ad47c13896c..35627d6c649 100644
--- a/clippy_lints/src/matches/single_match.rs
+++ b/clippy_lints/src/matches/single_match.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::source::{expr_block, snippet};
+use clippy_utils::source::{expr_block, get_source_text, snippet};
 use clippy_utils::ty::{implements_trait, is_type_diagnostic_item, peel_mid_ty_refs};
 use clippy_utils::{is_lint_allowed, is_unit_expr, is_wild, peel_blocks, peel_hir_pat_refs, peel_n_hir_expr_refs};
 use core::cmp::max;
@@ -7,10 +7,26 @@ use rustc_errors::Applicability;
 use rustc_hir::{Arm, BindingAnnotation, Block, Expr, ExprKind, Pat, PatKind};
 use rustc_lint::LateContext;
 use rustc_middle::ty::{self, Ty};
-use rustc_span::sym;
+use rustc_span::{sym, Span};
 
 use super::{MATCH_BOOL, SINGLE_MATCH, SINGLE_MATCH_ELSE};
 
+/// Checks if there are comments contained within a span.
+/// This is a very "naive" check, as it just looks for the literal characters // and /* in the
+/// source text. This won't be accurate if there are potentially expressions contained within the
+/// span, e.g. a string literal `"//"`, but we know that this isn't the case for empty
+/// match arms.
+fn empty_arm_has_comment(cx: &LateContext<'_>, span: Span) -> bool {
+    if let Some(ff) = get_source_text(cx, span)
+        && let Some(text) = ff.as_str()
+    {
+        text.as_bytes().windows(2)
+            .any(|w| w == b"//" || w == b"/*")
+    } else {
+        false
+    }
+}
+
 #[rustfmt::skip]
 pub(crate) fn check(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>], expr: &Expr<'_>) {
     if arms.len() == 2 && arms[0].guard.is_none() && arms[1].guard.is_none() {
@@ -25,7 +41,7 @@ pub(crate) fn check(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>], expr:
             return;
         }
         let els = arms[1].body;
-        let els = if is_unit_expr(peel_blocks(els)) {
+        let els = if is_unit_expr(peel_blocks(els)) && !empty_arm_has_comment(cx, els.span) {
             None
         } else if let ExprKind::Block(Block { stmts, expr: block_expr, .. }, _) = els.kind {
             if stmts.len() == 1 && block_expr.is_none() || stmts.is_empty() && block_expr.is_some() {
@@ -35,7 +51,7 @@ pub(crate) fn check(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>], expr:
             // block with 2+ statements or 1 expr and 1+ statement
             Some(els)
         } else {
-            // not a block, don't lint
+            // not a block or an emtpy block w/ comments, don't lint
             return;
         };
 
diff --git a/tests/ui/single_match.fixed b/tests/ui/single_match.fixed
index a54e658bf23..0da59a53320 100644
--- a/tests/ui/single_match.fixed
+++ b/tests/ui/single_match.fixed
@@ -212,3 +212,29 @@ fn issue_10808(bar: Option<i32>) {
         }
     }
 }
+
+mod issue8634 {
+    struct SomeError(i32, i32);
+
+    fn foo(x: Result<i32, ()>) {
+        match x {
+            Ok(y) => {
+                println!("Yay! {y}");
+            },
+            Err(()) => {
+                // Ignore this error because blah blah blah.
+            },
+        }
+    }
+
+    fn bar(x: Result<i32, SomeError>) {
+        match x {
+            Ok(y) => {
+                println!("Yay! {y}");
+            },
+            Err(_) => {
+                // TODO: Process the error properly.
+            },
+        }
+    }
+}
diff --git a/tests/ui/single_match.rs b/tests/ui/single_match.rs
index f296c6c4d1c..7afadececbf 100644
--- a/tests/ui/single_match.rs
+++ b/tests/ui/single_match.rs
@@ -270,3 +270,29 @@ fn issue_10808(bar: Option<i32>) {
         _ => {},
     }
 }
+
+mod issue8634 {
+    struct SomeError(i32, i32);
+
+    fn foo(x: Result<i32, ()>) {
+        match x {
+            Ok(y) => {
+                println!("Yay! {y}");
+            },
+            Err(()) => {
+                // Ignore this error because blah blah blah.
+            },
+        }
+    }
+
+    fn bar(x: Result<i32, SomeError>) {
+        match x {
+            Ok(y) => {
+                println!("Yay! {y}");
+            },
+            Err(_) => {
+                // TODO: Process the error properly.
+            },
+        }
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 2e856fa99bc2c7f03c65fd89e44ef22509708e0d Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Mon, 19 Jun 2023 20:07:31 +0200
Subject: add test for block comment and add note to description

---
 clippy_lints/src/matches/mod.rs |  5 +++++
 tests/ui/single_match.fixed     | 14 ++++++++++++++
 tests/ui/single_match.rs        | 14 ++++++++++++++
 3 files changed, 33 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/mod.rs b/clippy_lints/src/matches/mod.rs
index 3fbd0867ea9..00fa3eb9bfe 100644
--- a/clippy_lints/src/matches/mod.rs
+++ b/clippy_lints/src/matches/mod.rs
@@ -38,6 +38,11 @@ declare_clippy_lint! {
     /// Checks for matches with a single arm where an `if let`
     /// will usually suffice.
     ///
+    /// This intentionally does not lint if there are comments
+    /// inside of the other arm, so as to allow the user to document
+    /// why having another explicit pattern with an empty body is necessary,
+    /// or because the comments need to be preserved for other reasons.
+    ///
     /// ### Why is this bad?
     /// Just readability – `if let` nests less than a `match`.
     ///
diff --git a/tests/ui/single_match.fixed b/tests/ui/single_match.fixed
index 0da59a53320..e7b1fd6a85f 100644
--- a/tests/ui/single_match.fixed
+++ b/tests/ui/single_match.fixed
@@ -237,4 +237,18 @@ mod issue8634 {
             },
         }
     }
+
+    fn block_comment(x: Result<i32, SomeError>) {
+        match x {
+            Ok(y) => {
+                println!("Yay! {y}");
+            },
+            Err(_) => {
+                /*
+                let's make sure that this also
+                does not lint block comments.
+                */
+            },
+        }
+    }
 }
diff --git a/tests/ui/single_match.rs b/tests/ui/single_match.rs
index 7afadececbf..1515a7053e5 100644
--- a/tests/ui/single_match.rs
+++ b/tests/ui/single_match.rs
@@ -295,4 +295,18 @@ mod issue8634 {
             },
         }
     }
+
+    fn block_comment(x: Result<i32, SomeError>) {
+        match x {
+            Ok(y) => {
+                println!("Yay! {y}");
+            },
+            Err(_) => {
+                /*
+                let's make sure that this also
+                does not lint block comments.
+                */
+            },
+        }
+    }
 }
-- 
cgit 1.4.1-3-g733a5


From 62c9e0b87d5cb08f2c7e8ab00cbb8dcf64324b37 Mon Sep 17 00:00:00 2001
From: blyxyas <blyxyas@gmail.com>
Date: Mon, 19 Jun 2023 20:50:24 +0200
Subject: Ignore in-proc-macros items

---
 clippy_lints/src/items_after_test_module.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/items_after_test_module.rs b/clippy_lints/src/items_after_test_module.rs
index b992d689aa9..40378ee8205 100644
--- a/clippy_lints/src/items_after_test_module.rs
+++ b/clippy_lints/src/items_after_test_module.rs
@@ -1,4 +1,4 @@
-use clippy_utils::{diagnostics::span_lint_and_help, is_in_cfg_test};
+use clippy_utils::{diagnostics::span_lint_and_help, is_from_proc_macro, is_in_cfg_test};
 use rustc_hir::{HirId, ItemId, ItemKind, Mod};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
@@ -59,6 +59,7 @@ impl LateLintPass<'_> for ItemsAfterTestModule {
             if !matches!(item.kind, ItemKind::Mod(_));
             if !is_in_cfg_test(cx.tcx, itid.hir_id()); // The item isn't in the testing module itself
             if !in_external_macro(cx.sess(), item.span);
+            if !is_from_proc_macro(cx, item);
 
             then {
                 span_lint_and_help(cx, ITEMS_AFTER_TEST_MODULE, test_mod_span.unwrap().with_hi(item.span.hi()), "items were found after the testing module", None, "move the items to before the testing module was defined");
-- 
cgit 1.4.1-3-g733a5


From cc2e49f6956bba3131f7c695042fdc4a1aefb179 Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Sun, 18 Jun 2023 14:38:22 -0500
Subject: allow safety comment above attributes

---
 CHANGELOG.md                                       |  1 +
 book/src/lint_configuration.md                     | 10 +++
 clippy_lints/src/lib.rs                            |  2 +
 clippy_lints/src/undocumented_unsafe_blocks.rs     | 81 +++++++++++++++++++---
 clippy_lints/src/utils/conf.rs                     |  4 ++
 .../toml_unknown_key/conf_unknown_key.stderr       |  2 +
 .../ui-toml/undocumented_unsafe_blocks/clippy.toml |  1 +
 .../undocumented_unsafe_blocks.rs                  | 35 +++++++++-
 .../undocumented_unsafe_blocks.stderr              | 74 ++++++++++----------
 9 files changed, 162 insertions(+), 48 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 3eaa0d199fd..f7295ecf42c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5384,4 +5384,5 @@ Released 2018-09-13
 [`allowed-idents-below-min-chars`]: https://doc.rust-lang.org/clippy/lint_configuration.html#allowed-idents-below-min-chars
 [`min-ident-chars-threshold`]: https://doc.rust-lang.org/clippy/lint_configuration.html#min-ident-chars-threshold
 [`accept-comment-above-statement`]: https://doc.rust-lang.org/clippy/lint_configuration.html#accept-comment-above-statement
+[`accept-comment-above-attributes`]: https://doc.rust-lang.org/clippy/lint_configuration.html#accept-comment-above-attributes
 <!-- end autogenerated links to configuration documentation -->
diff --git a/book/src/lint_configuration.md b/book/src/lint_configuration.md
index 78a5f9da461..ccb24a536af 100644
--- a/book/src/lint_configuration.md
+++ b/book/src/lint_configuration.md
@@ -705,3 +705,13 @@ Whether to accept a safety comment to be placed above the statement containing t
 * [`undocumented_unsafe_blocks`](https://rust-lang.github.io/rust-clippy/master/index.html#undocumented_unsafe_blocks)
 
 
+## `accept-comment-above-attributes`
+Whether to accept a safety comment to be placed above the attributes for the `unsafe` block
+
+**Default Value:** `false` (`bool`)
+
+---
+**Affected lints:**
+* [`undocumented_unsafe_blocks`](https://rust-lang.github.io/rust-clippy/master/index.html#undocumented_unsafe_blocks)
+
+
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 6ea329a9542..a0ada107fbf 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -930,9 +930,11 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         ))
     });
     let accept_comment_above_statement = conf.accept_comment_above_statement;
+    let accept_comment_above_attributes = conf.accept_comment_above_attributes;
     store.register_late_pass(move |_| {
         Box::new(undocumented_unsafe_blocks::UndocumentedUnsafeBlocks::new(
             accept_comment_above_statement,
+            accept_comment_above_attributes,
         ))
     });
     let allow_mixed_uninlined = conf.allow_mixed_uninlined_format_args;
diff --git a/clippy_lints/src/undocumented_unsafe_blocks.rs b/clippy_lints/src/undocumented_unsafe_blocks.rs
index 1676c767a34..a9deee96784 100644
--- a/clippy_lints/src/undocumented_unsafe_blocks.rs
+++ b/clippy_lints/src/undocumented_unsafe_blocks.rs
@@ -95,12 +95,14 @@ declare_clippy_lint! {
 #[derive(Copy, Clone)]
 pub struct UndocumentedUnsafeBlocks {
     accept_comment_above_statement: bool,
+    accept_comment_above_attributes: bool,
 }
 
 impl UndocumentedUnsafeBlocks {
-    pub fn new(accept_comment_above_statement: bool) -> Self {
+    pub fn new(accept_comment_above_statement: bool, accept_comment_above_attributes: bool) -> Self {
         Self {
             accept_comment_above_statement,
+            accept_comment_above_attributes,
         }
     }
 }
@@ -114,7 +116,12 @@ impl<'tcx> LateLintPass<'tcx> for UndocumentedUnsafeBlocks {
             && !is_lint_allowed(cx, UNDOCUMENTED_UNSAFE_BLOCKS, block.hir_id)
             && !is_unsafe_from_proc_macro(cx, block.span)
             && !block_has_safety_comment(cx, block.span)
-            && !block_parents_have_safety_comment(self.accept_comment_above_statement, cx, block.hir_id)
+            && !block_parents_have_safety_comment(
+                self.accept_comment_above_statement,
+                self.accept_comment_above_attributes,
+                cx,
+                block.hir_id,
+            )
         {
             let source_map = cx.tcx.sess.source_map();
             let span = if source_map.is_multiline(block.span) {
@@ -328,6 +335,7 @@ fn is_unsafe_from_proc_macro(cx: &LateContext<'_>, span: Span) -> bool {
 // has a safety comment
 fn block_parents_have_safety_comment(
     accept_comment_above_statement: bool,
+    accept_comment_above_attributes: bool,
     cx: &LateContext<'_>,
     id: hir::HirId,
 ) -> bool {
@@ -343,33 +351,77 @@ fn block_parents_have_safety_comment(
                     }),
                 ) = get_parent_node(cx.tcx, expr.hir_id)
                 {
+                    let hir_id = match get_parent_node(cx.tcx, expr.hir_id) {
+                        Some(Node::Local(hir::Local { hir_id, .. })) => *hir_id,
+                        Some(Node::Item(hir::Item { owner_id, .. })) => {
+                            cx.tcx.hir().local_def_id_to_hir_id(owner_id.def_id)
+                        },
+                        _ => unreachable!(),
+                    };
+
                     // if unsafe block is part of a let/const/static statement,
                     // and accept_comment_above_statement is set to true
                     // we accept the safety comment in the line the precedes this statement.
-                    accept_comment_above_statement && span_in_body_has_safety_comment(cx, *span)
+                    accept_comment_above_statement
+                        && span_with_attrs_in_body_has_safety_comment(
+                            cx,
+                            *span,
+                            hir_id,
+                            accept_comment_above_attributes,
+                        )
                 } else {
-                    !is_branchy(expr) && span_in_body_has_safety_comment(cx, expr.span)
+                    !is_branchy(expr)
+                        && span_with_attrs_in_body_has_safety_comment(
+                            cx,
+                            expr.span,
+                            expr.hir_id,
+                            accept_comment_above_attributes,
+                        )
                 }
             },
             Node::Stmt(hir::Stmt {
                 kind:
-                    hir::StmtKind::Local(hir::Local { span, .. })
-                    | hir::StmtKind::Expr(hir::Expr { span, .. })
-                    | hir::StmtKind::Semi(hir::Expr { span, .. }),
+                    hir::StmtKind::Local(hir::Local { span, hir_id, .. })
+                    | hir::StmtKind::Expr(hir::Expr { span, hir_id, .. })
+                    | hir::StmtKind::Semi(hir::Expr { span, hir_id, .. }),
                 ..
             })
-            | Node::Local(hir::Local { span, .. })
-            | Node::Item(hir::Item {
+            | Node::Local(hir::Local { span, hir_id, .. }) => {
+                span_with_attrs_in_body_has_safety_comment(cx, *span, *hir_id, accept_comment_above_attributes)
+            },
+            Node::Item(hir::Item {
                 kind: hir::ItemKind::Const(..) | ItemKind::Static(..),
                 span,
+                owner_id,
                 ..
-            }) => span_in_body_has_safety_comment(cx, *span),
+            }) => span_with_attrs_in_body_has_safety_comment(
+                cx,
+                *span,
+                cx.tcx.hir().local_def_id_to_hir_id(owner_id.def_id),
+                accept_comment_above_attributes,
+            ),
             _ => false,
         };
     }
     false
 }
 
+/// Extends `span` to also include its attributes, then checks if that span has a safety comment.
+fn span_with_attrs_in_body_has_safety_comment(
+    cx: &LateContext<'_>,
+    span: Span,
+    hir_id: HirId,
+    accept_comment_above_attributes: bool,
+) -> bool {
+    let span = if accept_comment_above_attributes {
+        include_attrs_in_span(cx, hir_id, span)
+    } else {
+        span
+    };
+
+    span_in_body_has_safety_comment(cx, span)
+}
+
 /// Checks if an expression is "branchy", e.g. loop, match/if/etc.
 fn is_branchy(expr: &hir::Expr<'_>) -> bool {
     matches!(
@@ -394,6 +446,15 @@ fn block_has_safety_comment(cx: &LateContext<'_>, span: Span) -> bool {
     ) || span_in_body_has_safety_comment(cx, span)
 }
 
+fn include_attrs_in_span(cx: &LateContext<'_>, hir_id: HirId, span: Span) -> Span {
+    span.to(cx
+        .tcx
+        .hir()
+        .attrs(hir_id)
+        .iter()
+        .fold(span, |acc, attr| acc.to(attr.span)))
+}
+
 enum HasSafetyComment {
     Yes(BytePos),
     No,
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index e8c8d478ffc..b04b3177e98 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -542,6 +542,10 @@ define_Conf! {
     ///
     /// Whether to accept a safety comment to be placed above the statement containing the `unsafe` block
     (accept_comment_above_statement: bool = false),
+        /// Lint: UNDOCUMENTED_UNSAFE_BLOCKS.
+    ///
+    /// Whether to accept a safety comment to be placed above the attributes for the `unsafe` block
+    (accept_comment_above_attributes: bool = false),
 }
 
 /// Search for the configuration file.
diff --git a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
index db2071ecaaf..475b15a2414 100644
--- a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
+++ b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
@@ -1,4 +1,5 @@
 error: error reading Clippy's configuration file: unknown field `foobar`, expected one of
+           accept-comment-above-attributes
            accept-comment-above-statement
            allow-dbg-in-tests
            allow-expect-in-tests
@@ -66,6 +67,7 @@ LL | foobar = 42
    | ^^^^^^
 
 error: error reading Clippy's configuration file: unknown field `barfoo`, expected one of
+           accept-comment-above-attributes
            accept-comment-above-statement
            allow-dbg-in-tests
            allow-expect-in-tests
diff --git a/tests/ui-toml/undocumented_unsafe_blocks/clippy.toml b/tests/ui-toml/undocumented_unsafe_blocks/clippy.toml
index 1c2e7aeaff9..e6dbb3d3784 100644
--- a/tests/ui-toml/undocumented_unsafe_blocks/clippy.toml
+++ b/tests/ui-toml/undocumented_unsafe_blocks/clippy.toml
@@ -1 +1,2 @@
 accept-comment-above-statement = true
+accept-comment-above-attributes = true
diff --git a/tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs b/tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs
index 533f90483e5..c0976f0d600 100644
--- a/tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs
+++ b/tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs
@@ -1,7 +1,8 @@
 //@aux-build:proc_macro_unsafe.rs
 
 #![warn(clippy::undocumented_unsafe_blocks, clippy::unnecessary_safety_comment)]
-#![allow(clippy::let_unit_value, clippy::missing_safety_doc)]
+#![allow(deref_nullptr, clippy::let_unit_value, clippy::missing_safety_doc)]
+#![feature(lint_reasons)]
 
 extern crate proc_macro_unsafe;
 
@@ -531,4 +532,36 @@ fn issue_10832() {
         unsafe { a_const_function_with_a_very_long_name_to_break_the_line() };
 }
 
+fn issue_8679<T: Copy>() {
+    // SAFETY:
+    #[allow(unsafe_code)]
+    unsafe {}
+
+    // SAFETY:
+    #[expect(unsafe_code, reason = "totally safe")]
+    unsafe {
+        *std::ptr::null::<T>()
+    };
+
+    // Safety: A safety comment
+    #[allow(unsafe_code)]
+    let _some_variable_with_a_very_long_name_to_break_the_line =
+        unsafe { a_function_with_a_very_long_name_to_break_the_line() };
+
+    // Safety: Another safety comment
+    #[allow(unsafe_code)]
+    const _SOME_CONST_WITH_A_VERY_LONG_NAME_TO_BREAK_THE_LINE: u32 =
+        unsafe { a_const_function_with_a_very_long_name_to_break_the_line() };
+
+    // Safety: Yet another safety comment
+    #[allow(unsafe_code)]
+    static _SOME_STATIC_WITH_A_VERY_LONG_NAME_TO_BREAK_THE_LINE: u32 =
+        unsafe { a_const_function_with_a_very_long_name_to_break_the_line() };
+
+    // SAFETY:
+    #[allow(unsafe_code)]
+    // This also works I guess
+    unsafe {}
+}
+
 fn main() {}
diff --git a/tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.stderr b/tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.stderr
index ac987a9e995..9a0fd059389 100644
--- a/tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.stderr
+++ b/tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.stderr
@@ -1,5 +1,5 @@
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:262:19
+  --> $DIR/undocumented_unsafe_blocks.rs:263:19
    |
 LL |     /* Safety: */ unsafe {}
    |                   ^^^^^^^^^
@@ -8,7 +8,7 @@ LL |     /* Safety: */ unsafe {}
    = note: `-D clippy::undocumented-unsafe-blocks` implied by `-D warnings`
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:266:5
+  --> $DIR/undocumented_unsafe_blocks.rs:267:5
    |
 LL |     unsafe {}
    |     ^^^^^^^^^
@@ -16,7 +16,7 @@ LL |     unsafe {}
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:270:14
+  --> $DIR/undocumented_unsafe_blocks.rs:271:14
    |
 LL |     let _ = [unsafe { 14 }, unsafe { 15 }, 42, unsafe { 16 }];
    |              ^^^^^^^^^^^^^
@@ -24,7 +24,7 @@ LL |     let _ = [unsafe { 14 }, unsafe { 15 }, 42, unsafe { 16 }];
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:270:29
+  --> $DIR/undocumented_unsafe_blocks.rs:271:29
    |
 LL |     let _ = [unsafe { 14 }, unsafe { 15 }, 42, unsafe { 16 }];
    |                             ^^^^^^^^^^^^^
@@ -32,7 +32,7 @@ LL |     let _ = [unsafe { 14 }, unsafe { 15 }, 42, unsafe { 16 }];
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:270:48
+  --> $DIR/undocumented_unsafe_blocks.rs:271:48
    |
 LL |     let _ = [unsafe { 14 }, unsafe { 15 }, 42, unsafe { 16 }];
    |                                                ^^^^^^^^^^^^^
@@ -40,7 +40,7 @@ LL |     let _ = [unsafe { 14 }, unsafe { 15 }, 42, unsafe { 16 }];
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:274:18
+  --> $DIR/undocumented_unsafe_blocks.rs:275:18
    |
 LL |     let _ = (42, unsafe {}, "test", unsafe {});
    |                  ^^^^^^^^^
@@ -48,7 +48,7 @@ LL |     let _ = (42, unsafe {}, "test", unsafe {});
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:274:37
+  --> $DIR/undocumented_unsafe_blocks.rs:275:37
    |
 LL |     let _ = (42, unsafe {}, "test", unsafe {});
    |                                     ^^^^^^^^^
@@ -56,7 +56,7 @@ LL |     let _ = (42, unsafe {}, "test", unsafe {});
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:278:14
+  --> $DIR/undocumented_unsafe_blocks.rs:279:14
    |
 LL |     let _ = *unsafe { &42 };
    |              ^^^^^^^^^^^^^^
@@ -64,7 +64,7 @@ LL |     let _ = *unsafe { &42 };
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:283:19
+  --> $DIR/undocumented_unsafe_blocks.rs:284:19
    |
 LL |     let _ = match unsafe {} {
    |                   ^^^^^^^^^
@@ -72,7 +72,7 @@ LL |     let _ = match unsafe {} {
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:289:14
+  --> $DIR/undocumented_unsafe_blocks.rs:290:14
    |
 LL |     let _ = &unsafe {};
    |              ^^^^^^^^^
@@ -80,7 +80,7 @@ LL |     let _ = &unsafe {};
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:293:14
+  --> $DIR/undocumented_unsafe_blocks.rs:294:14
    |
 LL |     let _ = [unsafe {}; 5];
    |              ^^^^^^^^^
@@ -88,7 +88,7 @@ LL |     let _ = [unsafe {}; 5];
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:297:13
+  --> $DIR/undocumented_unsafe_blocks.rs:298:13
    |
 LL |     let _ = unsafe {};
    |             ^^^^^^^^^
@@ -96,7 +96,7 @@ LL |     let _ = unsafe {};
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:307:8
+  --> $DIR/undocumented_unsafe_blocks.rs:308:8
    |
 LL |     t!(unsafe {});
    |        ^^^^^^^^^
@@ -104,7 +104,7 @@ LL |     t!(unsafe {});
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:313:13
+  --> $DIR/undocumented_unsafe_blocks.rs:314:13
    |
 LL |             unsafe {}
    |             ^^^^^^^^^
@@ -116,7 +116,7 @@ LL |     t!();
    = note: this error originates in the macro `t` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:321:5
+  --> $DIR/undocumented_unsafe_blocks.rs:322:5
    |
 LL |     unsafe {} // SAFETY:
    |     ^^^^^^^^^
@@ -124,7 +124,7 @@ LL |     unsafe {} // SAFETY:
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:325:5
+  --> $DIR/undocumented_unsafe_blocks.rs:326:5
    |
 LL |     unsafe {
    |     ^^^^^^^^
@@ -132,7 +132,7 @@ LL |     unsafe {
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:335:5
+  --> $DIR/undocumented_unsafe_blocks.rs:336:5
    |
 LL |     unsafe {};
    |     ^^^^^^^^^
@@ -140,7 +140,7 @@ LL |     unsafe {};
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:339:20
+  --> $DIR/undocumented_unsafe_blocks.rs:340:20
    |
 LL |     println!("{}", unsafe { String::from_utf8_unchecked(vec![]) });
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -148,7 +148,7 @@ LL |     println!("{}", unsafe { String::from_utf8_unchecked(vec![]) });
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe impl missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:346:5
+  --> $DIR/undocumented_unsafe_blocks.rs:347:5
    |
 LL |     unsafe impl A for () {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^
@@ -156,7 +156,7 @@ LL |     unsafe impl A for () {}
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe impl missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:353:9
+  --> $DIR/undocumented_unsafe_blocks.rs:354:9
    |
 LL |         unsafe impl B for (u32) {}
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -164,7 +164,7 @@ LL |         unsafe impl B for (u32) {}
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe impl missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:374:13
+  --> $DIR/undocumented_unsafe_blocks.rs:375:13
    |
 LL |             unsafe impl T for $t {}
    |             ^^^^^^^^^^^^^^^^^^^^^^^
@@ -176,7 +176,7 @@ LL |     no_safety_comment!(());
    = note: this error originates in the macro `no_safety_comment` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: unsafe impl missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:399:13
+  --> $DIR/undocumented_unsafe_blocks.rs:400:13
    |
 LL |             unsafe impl T for $t {}
    |             ^^^^^^^^^^^^^^^^^^^^^^^
@@ -188,7 +188,7 @@ LL |     no_safety_comment!(());
    = note: this error originates in the macro `no_safety_comment` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: unsafe impl missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:407:5
+  --> $DIR/undocumented_unsafe_blocks.rs:408:5
    |
 LL |     unsafe impl T for (i32) {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -196,7 +196,7 @@ LL |     unsafe impl T for (i32) {}
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe impl missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:399:13
+  --> $DIR/undocumented_unsafe_blocks.rs:400:13
    |
 LL |             unsafe impl T for $t {}
    |             ^^^^^^^^^^^^^^^^^^^^^^^
@@ -208,7 +208,7 @@ LL |     no_safety_comment!(u32);
    = note: this error originates in the macro `no_safety_comment` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: unsafe impl missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:413:5
+  --> $DIR/undocumented_unsafe_blocks.rs:414:5
    |
 LL |     unsafe impl T for (bool) {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -216,7 +216,7 @@ LL |     unsafe impl T for (bool) {}
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe impl missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:459:5
+  --> $DIR/undocumented_unsafe_blocks.rs:460:5
    |
 LL |     unsafe impl NoComment for () {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -224,7 +224,7 @@ LL |     unsafe impl NoComment for () {}
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe impl missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:463:19
+  --> $DIR/undocumented_unsafe_blocks.rs:464:19
    |
 LL |     /* SAFETY: */ unsafe impl InlineComment for () {}
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -232,7 +232,7 @@ LL |     /* SAFETY: */ unsafe impl InlineComment for () {}
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe impl missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:467:5
+  --> $DIR/undocumented_unsafe_blocks.rs:468:5
    |
 LL |     unsafe impl TrailingComment for () {} // SAFETY:
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -240,20 +240,20 @@ LL |     unsafe impl TrailingComment for () {} // SAFETY:
    = help: consider adding a safety comment on the preceding line
 
 error: constant item has unnecessary safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:471:5
+  --> $DIR/undocumented_unsafe_blocks.rs:472:5
    |
 LL |     const BIG_NUMBER: i32 = 1000000;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: consider removing the safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:470:5
+  --> $DIR/undocumented_unsafe_blocks.rs:471:5
    |
 LL |     // SAFETY:
    |     ^^^^^^^^^^
    = note: `-D clippy::unnecessary-safety-comment` implied by `-D warnings`
 
 error: unsafe impl missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:472:5
+  --> $DIR/undocumented_unsafe_blocks.rs:473:5
    |
 LL |     unsafe impl Interference for () {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -261,7 +261,7 @@ LL |     unsafe impl Interference for () {}
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe impl missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:479:5
+  --> $DIR/undocumented_unsafe_blocks.rs:480:5
    |
 LL |     unsafe impl ImplInFn for () {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -269,7 +269,7 @@ LL |     unsafe impl ImplInFn for () {}
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe impl missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:488:1
+  --> $DIR/undocumented_unsafe_blocks.rs:489:1
    |
 LL | unsafe impl CrateRoot for () {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -277,7 +277,7 @@ LL | unsafe impl CrateRoot for () {}
    = help: consider adding a safety comment on the preceding line
 
 error: statement has unnecessary safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:501:5
+  --> $DIR/undocumented_unsafe_blocks.rs:502:5
    |
 LL | /     let _ = {
 LL | |         if unsafe { true } {
@@ -289,13 +289,13 @@ LL | |     };
    | |______^
    |
 help: consider removing the safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:500:5
+  --> $DIR/undocumented_unsafe_blocks.rs:501:5
    |
 LL |     // SAFETY: this is more than one level away, so it should warn
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:502:12
+  --> $DIR/undocumented_unsafe_blocks.rs:503:12
    |
 LL |         if unsafe { true } {
    |            ^^^^^^^^^^^^^^^
@@ -303,7 +303,7 @@ LL |         if unsafe { true } {
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:505:23
+  --> $DIR/undocumented_unsafe_blocks.rs:506:23
    |
 LL |             let bar = unsafe {};
    |                       ^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From 87c28b94635b2ccf5518979b7ab7ee846365653b Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Tue, 20 Jun 2023 17:24:46 +0200
Subject: [`type_repetition_in_bounds`]: respect msrv for combining maybe
 bounds

---
 clippy_lints/src/lib.rs                   |  2 +-
 clippy_lints/src/trait_bounds.rs          | 33 ++++++++++++++++++++++---------
 clippy_utils/src/msrvs.rs                 |  1 +
 tests/ui/type_repetition_in_bounds.rs     | 24 ++++++++++++++++++++++
 tests/ui/type_repetition_in_bounds.stderr | 10 +++++++++-
 5 files changed, 59 insertions(+), 11 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 3fb4e6c8fa5..0008f8f6d46 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -792,7 +792,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(assertions_on_result_states::AssertionsOnResultStates));
     store.register_late_pass(|_| Box::new(inherent_to_string::InherentToString));
     let max_trait_bounds = conf.max_trait_bounds;
-    store.register_late_pass(move |_| Box::new(trait_bounds::TraitBounds::new(max_trait_bounds)));
+    store.register_late_pass(move |_| Box::new(trait_bounds::TraitBounds::new(max_trait_bounds, msrv())));
     store.register_late_pass(|_| Box::new(comparison_chain::ComparisonChain));
     let ignore_interior_mutability = conf.ignore_interior_mutability.clone();
     store.register_late_pass(move |_| Box::new(mut_key::MutableKeyType::new(ignore_interior_mutability.clone())));
diff --git a/clippy_lints/src/trait_bounds.rs b/clippy_lints/src/trait_bounds.rs
index 3917d8f0225..2cf3529bd1b 100644
--- a/clippy_lints/src/trait_bounds.rs
+++ b/clippy_lints/src/trait_bounds.rs
@@ -1,4 +1,5 @@
 use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg};
+use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::{snippet, snippet_opt, snippet_with_applicability};
 use clippy_utils::{is_from_proc_macro, SpanlessEq, SpanlessHash};
 use core::hash::{Hash, Hasher};
@@ -9,7 +10,7 @@ use rustc_data_structures::unhash::UnhashMap;
 use rustc_errors::Applicability;
 use rustc_hir::def::Res;
 use rustc_hir::{
-    GenericArg, GenericBound, Generics, Item, ItemKind, Node, Path, PathSegment, PredicateOrigin, QPath,
+    GenericArg, GenericBound, Generics, Item, ItemKind, LangItem, Node, Path, PathSegment, PredicateOrigin, QPath,
     TraitBoundModifier, TraitItem, TraitRef, Ty, TyKind, WherePredicate,
 };
 use rustc_lint::{LateContext, LateLintPass};
@@ -86,15 +87,16 @@ declare_clippy_lint! {
     "check if the same trait bounds are specified more than once during a generic declaration"
 }
 
-#[derive(Copy, Clone)]
+#[derive(Clone)]
 pub struct TraitBounds {
     max_trait_bounds: u64,
+    msrv: Msrv,
 }
 
 impl TraitBounds {
     #[must_use]
-    pub fn new(max_trait_bounds: u64) -> Self {
-        Self { max_trait_bounds }
+    pub fn new(max_trait_bounds: u64, msrv: Msrv) -> Self {
+        Self { max_trait_bounds, msrv }
     }
 }
 
@@ -222,10 +224,24 @@ impl<'tcx> LateLintPass<'tcx> for TraitBounds {
             }
         }
     }
+
+    extract_msrv_attr!(LateContext);
 }
 
 impl TraitBounds {
-    fn check_type_repetition<'tcx>(self, cx: &LateContext<'tcx>, gen: &'tcx Generics<'_>) {
+    /// Is the given bound a `?Sized` bound, and is combining it (i.e. `T: X + ?Sized`) an error on
+    /// this MSRV? See https://github.com/rust-lang/rust-clippy/issues/8772 for details.
+    fn cannot_combine_maybe_bound(&self, cx: &LateContext<'_>, bound: &GenericBound<'_>) -> bool {
+        if !self.msrv.meets(msrvs::COMBINED_MAYBE_BOUND)
+            && let GenericBound::Trait(tr, TraitBoundModifier::Maybe) = bound
+        {
+            cx.tcx.lang_items().get(LangItem::Sized) == tr.trait_ref.path.res.opt_def_id()
+        } else {
+            false
+        }
+    }
+
+    fn check_type_repetition<'tcx>(&self, cx: &LateContext<'tcx>, gen: &'tcx Generics<'_>) {
         struct SpanlessTy<'cx, 'tcx> {
             ty: &'tcx Ty<'tcx>,
             cx: &'cx LateContext<'tcx>,
@@ -256,10 +272,9 @@ impl TraitBounds {
                 if p.origin != PredicateOrigin::ImplTrait;
                 if p.bounds.len() as u64 <= self.max_trait_bounds;
                 if !p.span.from_expansion();
-                if let Some(ref v) = map.insert(
-                    SpanlessTy { ty: p.bounded_ty, cx },
-                    p.bounds.iter().collect::<Vec<_>>()
-                );
+                let bounds = p.bounds.iter().filter(|b| !self.cannot_combine_maybe_bound(cx, b)).collect::<Vec<_>>();
+                if !bounds.is_empty();
+                if let Some(ref v) = map.insert(SpanlessTy { ty: p.bounded_ty, cx }, bounds);
                 if !is_from_proc_macro(cx, p.bounded_ty);
                 then {
                     let trait_bounds = v
diff --git a/clippy_utils/src/msrvs.rs b/clippy_utils/src/msrvs.rs
index e1b1a6f7184..b1f336461d1 100644
--- a/clippy_utils/src/msrvs.rs
+++ b/clippy_utils/src/msrvs.rs
@@ -47,6 +47,7 @@ msrv_aliases! {
     1,18,0 { HASH_MAP_RETAIN, HASH_SET_RETAIN }
     1,17,0 { FIELD_INIT_SHORTHAND, STATIC_IN_CONST, EXPECT_ERR }
     1,16,0 { STR_REPEAT }
+    1,15,0 { COMBINED_MAYBE_BOUND }
 }
 
 fn parse_msrv(msrv: &str, sess: Option<&Session>, span: Option<Span>) -> Option<RustcVersion> {
diff --git a/tests/ui/type_repetition_in_bounds.rs b/tests/ui/type_repetition_in_bounds.rs
index 1d36f4b3c7b..874d97f7a46 100644
--- a/tests/ui/type_repetition_in_bounds.rs
+++ b/tests/ui/type_repetition_in_bounds.rs
@@ -110,4 +110,28 @@ where
 // This should not lint
 fn impl_trait(_: impl AsRef<str>, _: impl AsRef<str>) {}
 
+#[clippy::msrv = "1.14.0"]
+mod issue8772_fail {
+    pub trait Trait<X, Y, Z> {}
+
+    pub fn f<T: ?Sized, U>(arg: usize)
+    where
+        T: Trait<Option<usize>, Box<[String]>, bool> + 'static,
+        U: Clone + Sync + 'static,
+    {
+    }
+}
+
+#[clippy::msrv = "1.15.0"]
+mod issue8772_pass {
+    pub trait Trait<X, Y, Z> {}
+
+    pub fn f<T: ?Sized, U>(arg: usize)
+    where
+        T: Trait<Option<usize>, Box<[String]>, bool> + 'static,
+        U: Clone + Sync + 'static,
+    {
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/type_repetition_in_bounds.stderr b/tests/ui/type_repetition_in_bounds.stderr
index 56867f75b07..54973c5bda5 100644
--- a/tests/ui/type_repetition_in_bounds.stderr
+++ b/tests/ui/type_repetition_in_bounds.stderr
@@ -35,5 +35,13 @@ LL |     T: ?Sized,
    |
    = help: consider combining the bounds: `T: Clone + ?Sized`
 
-error: aborting due to 4 previous errors
+error: this type has already been used as a bound predicate
+  --> $DIR/type_repetition_in_bounds.rs:131:9
+   |
+LL |         T: Trait<Option<usize>, Box<[String]>, bool> + 'static,
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider combining the bounds: `T: ?Sized + Trait<Option<usize>, Box<[String]>, bool>`
+
+error: aborting due to 5 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 1b6738ba39bf5ecd4d32f95a53966662baabc1e0 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Tue, 20 Jun 2023 17:33:32 +0200
Subject: s/is_dyn_trait/is_dyn_any

---
 clippy_lints/src/methods/type_id_on_box.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/type_id_on_box.rs b/clippy_lints/src/methods/type_id_on_box.rs
index 8ccbd0d8d1b..88adba504aa 100644
--- a/clippy_lints/src/methods/type_id_on_box.rs
+++ b/clippy_lints/src/methods/type_id_on_box.rs
@@ -10,7 +10,7 @@ use rustc_middle::ty::Ty;
 use rustc_middle::ty::{self, ExistentialPredicate};
 use rustc_span::{sym, Span};
 
-fn is_dyn_trait(cx: &LateContext<'_>, ty: Ty<'_>) -> bool {
+fn is_dyn_any(cx: &LateContext<'_>, ty: Ty<'_>) -> bool {
     if let ty::Dynamic(preds, ..) = ty.kind() {
         preds.iter().any(|p| match p.skip_binder() {
             ExistentialPredicate::Trait(tr) => cx.tcx.is_diagnostic_item(sym::Any, tr.def_id),
@@ -28,7 +28,7 @@ pub(super) fn check(cx: &LateContext<'_>, receiver: &Expr<'_>, call_span: Span)
         && let ty::Ref(_, ty, _) = recv_ty.kind()
         && let ty::Adt(adt, substs) = ty.kind()
         && adt.is_box()
-        && is_dyn_trait(cx, substs.type_at(0))
+        && is_dyn_any(cx, substs.type_at(0))
     {
         span_lint_and_then(
             cx,
-- 
cgit 1.4.1-3-g733a5


From 765a6e4a9014977b6f821df164633b3b7f5857f7 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Tue, 20 Jun 2023 17:36:38 +0200
Subject: put issue link between <>

---
 clippy_lints/src/trait_bounds.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/trait_bounds.rs b/clippy_lints/src/trait_bounds.rs
index 2cf3529bd1b..78e27b775fb 100644
--- a/clippy_lints/src/trait_bounds.rs
+++ b/clippy_lints/src/trait_bounds.rs
@@ -230,7 +230,7 @@ impl<'tcx> LateLintPass<'tcx> for TraitBounds {
 
 impl TraitBounds {
     /// Is the given bound a `?Sized` bound, and is combining it (i.e. `T: X + ?Sized`) an error on
-    /// this MSRV? See https://github.com/rust-lang/rust-clippy/issues/8772 for details.
+    /// this MSRV? See <https://github.com/rust-lang/rust-clippy/issues/8772> for details.
     fn cannot_combine_maybe_bound(&self, cx: &LateContext<'_>, bound: &GenericBound<'_>) -> bool {
         if !self.msrv.meets(msrvs::COMBINED_MAYBE_BOUND)
             && let GenericBound::Trait(tr, TraitBoundModifier::Maybe) = bound
-- 
cgit 1.4.1-3-g733a5


From d8d59965f1e6ba0490533c0bbd1ce50a00606d36 Mon Sep 17 00:00:00 2001
From: Catherine <114838443+Centri3@users.noreply.github.com>
Date: Tue, 20 Jun 2023 13:37:03 -0500
Subject: Lint `mem_forget` if fields are `Drop`

---
 clippy_lints/src/mem_forget.rs | 32 ++++++++++++++++++++------------
 tests/ui/mem_forget.rs         |  3 +++
 tests/ui/mem_forget.stderr     |  8 +++++++-
 3 files changed, 30 insertions(+), 13 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/mem_forget.rs b/clippy_lints/src/mem_forget.rs
index d6c235b5a69..fdd55260483 100644
--- a/clippy_lints/src/mem_forget.rs
+++ b/clippy_lints/src/mem_forget.rs
@@ -7,7 +7,7 @@ use rustc_span::sym;
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for usage of `std::mem::forget(t)` where `t` is
-    /// `Drop`.
+    /// `Drop` or has a field that implements `Drop`.
     ///
     /// ### Why is this bad?
     /// `std::mem::forget(t)` prevents `t` from running its
@@ -29,18 +29,26 @@ declare_lint_pass!(MemForget => [MEM_FORGET]);
 
 impl<'tcx> LateLintPass<'tcx> for MemForget {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
-        if let ExprKind::Call(path_expr, [ref first_arg, ..]) = e.kind {
-            if let ExprKind::Path(ref qpath) = path_expr.kind {
-                if let Some(def_id) = cx.qpath_res(qpath, path_expr.hir_id).opt_def_id() {
-                    if cx.tcx.is_diagnostic_item(sym::mem_forget, def_id) {
-                        let forgot_ty = cx.typeck_results().expr_ty(first_arg);
-
-                        if forgot_ty.ty_adt_def().map_or(false, |def| def.has_dtor(cx.tcx)) {
-                            span_lint(cx, MEM_FORGET, e.span, "usage of `mem::forget` on `Drop` type");
-                        }
+        if let ExprKind::Call(path_expr, [ref first_arg, ..]) = e.kind
+            && let ExprKind::Path(ref qpath) = path_expr.kind
+            && let Some(def_id) = cx.qpath_res(qpath, path_expr.hir_id).opt_def_id()
+            && cx.tcx.is_diagnostic_item(sym::mem_forget, def_id)
+            && let forgot_ty = cx.typeck_results().expr_ty(first_arg)
+            && forgot_ty.needs_drop(cx.tcx, cx.param_env)
+        {
+            span_lint(
+                cx,
+                MEM_FORGET,
+                e.span,
+                &format!(
+                    "usage of `mem::forget` on {}",
+                    if forgot_ty.ty_adt_def().map_or(false, |def| def.has_dtor(cx.tcx)) {
+                        "`Drop` type"
+                    } else {
+                        "type with `Drop` fields"
                     }
-                }
-            }
+                ),
+            );
         }
     }
 }
diff --git a/tests/ui/mem_forget.rs b/tests/ui/mem_forget.rs
index edb9d87d032..b6c8d9e53d8 100644
--- a/tests/ui/mem_forget.rs
+++ b/tests/ui/mem_forget.rs
@@ -19,5 +19,8 @@ fn main() {
     let eight: Vec<i32> = vec![8];
     forgetSomething(eight);
 
+    let string = String::new();
+    std::mem::forget(string);
+
     std::mem::forget(7);
 }
diff --git a/tests/ui/mem_forget.stderr b/tests/ui/mem_forget.stderr
index a90d8b1655d..50711120a15 100644
--- a/tests/ui/mem_forget.stderr
+++ b/tests/ui/mem_forget.stderr
@@ -18,5 +18,11 @@ error: usage of `mem::forget` on `Drop` type
 LL |     forgetSomething(eight);
    |     ^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 3 previous errors
+error: usage of `mem::forget` on type with `Drop` fields
+  --> $DIR/mem_forget.rs:23:5
+   |
+LL |     std::mem::forget(string);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 4 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From e3b601a1aa3121f2836c67c855dfcc3964043887 Mon Sep 17 00:00:00 2001
From: Catherine <114838443+Centri3@users.noreply.github.com>
Date: Tue, 20 Jun 2023 18:12:20 -0500
Subject: Add WebAssembly to allowed idents

---
 book/src/lint_configuration.md | 2 +-
 clippy_lints/src/utils/conf.rs | 1 +
 2 files changed, 2 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/book/src/lint_configuration.md b/book/src/lint_configuration.md
index 32cc5d1edcc..6c52563b8ed 100644
--- a/book/src/lint_configuration.md
+++ b/book/src/lint_configuration.md
@@ -210,7 +210,7 @@ default configuration of Clippy. By default, any configuration will replace the
 
 Default list:
 
-**Default Value:** `["KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "DirectX", "ECMAScript", "GPLv2", "GPLv3", "GitHub", "GitLab", "IPv4", "IPv6", "ClojureScript", "CoffeeScript", "JavaScript", "PureScript", "TypeScript", "NaN", "NaNs", "OAuth", "GraphQL", "OCaml", "OpenGL", "OpenMP", "OpenSSH", "OpenSSL", "OpenStreetMap", "OpenDNS", "WebGL", "TensorFlow", "TrueType", "iOS", "macOS", "FreeBSD", "TeX", "LaTeX", "BibTeX", "BibLaTeX", "MinGW", "CamelCase"]` (`Vec<String>`)
+**Default Value:** `["KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "DirectX", "ECMAScript", "GPLv2", "GPLv3", "GitHub", "GitLab", "IPv4", "IPv6", "ClojureScript", "CoffeeScript", "JavaScript", "PureScript", "TypeScript", "WebAssembly", "NaN", "NaNs", "OAuth", "GraphQL", "OCaml", "OpenGL", "OpenMP", "OpenSSH", "OpenSSL", "OpenStreetMap", "OpenDNS", "WebGL", "TensorFlow", "TrueType", "iOS", "macOS", "FreeBSD", "TeX", "LaTeX", "BibTeX", "BibLaTeX", "MinGW", "CamelCase"]` (`Vec<String>`)
 
 ---
 **Affected lints:**
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 3cf2fbf1f28..f5d6cecc59c 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -21,6 +21,7 @@ const DEFAULT_DOC_VALID_IDENTS: &[&str] = &[
     "GitHub", "GitLab",
     "IPv4", "IPv6",
     "ClojureScript", "CoffeeScript", "JavaScript", "PureScript", "TypeScript",
+    "WebAssembly",
     "NaN", "NaNs",
     "OAuth", "GraphQL",
     "OCaml",
-- 
cgit 1.4.1-3-g733a5


From 3122e3d78f91bc28becf205193fc4ce67955520a Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Wed, 21 Jun 2023 09:04:40 +0200
Subject: use let chains, move assignments out of block, add tests

---
 clippy_lints/src/methods/get_unwrap.rs | 30 ++++++++--------------
 tests/ui/get_unwrap.fixed              | 44 +++++++++++++++++++++++++-------
 tests/ui/get_unwrap.rs                 | 44 +++++++++++++++++++++++++-------
 tests/ui/get_unwrap.stderr             | 46 +++++++++++-----------------------
 4 files changed, 95 insertions(+), 69 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/get_unwrap.rs b/clippy_lints/src/methods/get_unwrap.rs
index 209d42ebabd..ba5aae28bd6 100644
--- a/clippy_lints/src/methods/get_unwrap.rs
+++ b/clippy_lints/src/methods/get_unwrap.rs
@@ -3,7 +3,6 @@ use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::get_parent_expr;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::is_type_diagnostic_item;
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
@@ -23,21 +22,16 @@ pub(super) fn check<'tcx>(
     let mut applicability = Applicability::MachineApplicable;
     let expr_ty = cx.typeck_results().expr_ty(recv);
     let get_args_str = snippet_with_applicability(cx, get_arg.span, "..", &mut applicability);
-    let mut needs_ref;
+    let mut needs_ref = true;
     let caller_type = if derefs_to_slice(cx, recv, expr_ty).is_some() {
-        needs_ref = true;
         "slice"
     } else if is_type_diagnostic_item(cx, expr_ty, sym::Vec) {
-        needs_ref = true;
         "Vec"
     } else if is_type_diagnostic_item(cx, expr_ty, sym::VecDeque) {
-        needs_ref = true;
         "VecDeque"
     } else if !is_mut && is_type_diagnostic_item(cx, expr_ty, sym::HashMap) {
-        needs_ref = true;
         "HashMap"
     } else if !is_mut && is_type_diagnostic_item(cx, expr_ty, sym::BTreeMap) {
-        needs_ref = true;
         "BTreeMap"
     } else {
         return; // caller is not a type that we want to lint
@@ -48,21 +42,19 @@ pub(super) fn check<'tcx>(
     // Handle the case where the result is immediately dereferenced,
     // either directly be the user, or as a result of a method call or the like
     // by not requiring an explicit reference
-    if_chain! {
-        if needs_ref;
-        if let Some(parent) = get_parent_expr(cx, expr);
-        if let hir::ExprKind::Unary(hir::UnOp::Deref, _)
+    if needs_ref
+        && let Some(parent) = get_parent_expr(cx, expr)
+        && let hir::ExprKind::Unary(hir::UnOp::Deref, _)
             | hir::ExprKind::MethodCall(..)
             | hir::ExprKind::Field(..)
-            | hir::ExprKind::Index(..) = parent.kind;
-        then {
-            if let hir::ExprKind::Unary(hir::UnOp::Deref, _) = parent.kind {
-                // if the user explicitly dereferences the result, we can adjust
-                // the span to also include the deref part
-                span = parent.span;
-            }
-            needs_ref = false;
+            | hir::ExprKind::Index(..) = parent.kind
+    {
+        if let hir::ExprKind::Unary(hir::UnOp::Deref, _) = parent.kind {
+            // if the user explicitly dereferences the result, we can adjust
+            // the span to also include the deref part
+            span = parent.span;
         }
+        needs_ref = false;
     }
 
     let mut_str = if is_mut { "_mut" } else { "" };
diff --git a/tests/ui/get_unwrap.fixed b/tests/ui/get_unwrap.fixed
index 3e4c2b499e4..f0d28dd9349 100644
--- a/tests/ui/get_unwrap.fixed
+++ b/tests/ui/get_unwrap.fixed
@@ -69,17 +69,43 @@ fn main() {
         let _ = some_vec[0..1].to_vec();
         let _ = some_vec[0..1].to_vec();
     }
-    issue9909();
 }
-fn issue9909() {
-    let f = &[1, 2, 3];
+mod issue9909 {
+    #![allow(clippy::identity_op, clippy::unwrap_used, dead_code)]
 
-    let _x: &i32 = &f[1 + 2];
-    // ^ include a borrow in the suggestion, even if the argument is not just a numeric literal
+    fn reduced() {
+        let f = &[1, 2, 3];
 
-    let _x = f[1 + 2].to_string();
-    // ^ don't include a borrow here
+        let _x: &i32 = &f[1 + 2];
+        // ^ include a borrow in the suggestion, even if the argument is not just a numeric literal
 
-    let _x = f[1 + 2].abs();
-    // ^ don't include a borrow here
+        let _x = f[1 + 2].to_string();
+        // ^ don't include a borrow here
+
+        let _x = f[1 + 2].abs();
+        // ^ don't include a borrow here
+    }
+
+    // original code:
+    fn linidx(row: usize, col: usize) -> usize {
+        row * 1 + col * 3
+    }
+
+    fn main_() {
+        let mut mat = [1.0f32, 5.0, 9.0, 2.0, 6.0, 10.0, 3.0, 7.0, 11.0, 4.0, 8.0, 12.0];
+
+        for i in 0..2 {
+            for j in i + 1..3 {
+                if mat[linidx(j, 3)] > mat[linidx(i, 3)] {
+                    for k in 0..4 {
+                        let (x, rest) = mat.split_at_mut(linidx(i, k) + 1);
+                        let a = x.last_mut().unwrap();
+                        let b = &mut rest[linidx(j, k) - linidx(i, k) - 1];
+                        ::std::mem::swap(a, b);
+                    }
+                }
+            }
+        }
+        assert_eq!([9.0, 5.0, 1.0, 10.0, 6.0, 2.0, 11.0, 7.0, 3.0, 12.0, 8.0, 4.0], mat);
+    }
 }
diff --git a/tests/ui/get_unwrap.rs b/tests/ui/get_unwrap.rs
index a967971a7dc..21c1ecb0af2 100644
--- a/tests/ui/get_unwrap.rs
+++ b/tests/ui/get_unwrap.rs
@@ -69,17 +69,43 @@ fn main() {
         let _ = some_vec.get(0..1).unwrap().to_vec();
         let _ = some_vec.get_mut(0..1).unwrap().to_vec();
     }
-    issue9909();
 }
-fn issue9909() {
-    let f = &[1, 2, 3];
+mod issue9909 {
+    #![allow(clippy::identity_op, clippy::unwrap_used, dead_code)]
 
-    let _x: &i32 = f.get(1 + 2).unwrap();
-    // ^ include a borrow in the suggestion, even if the argument is not just a numeric literal
+    fn reduced() {
+        let f = &[1, 2, 3];
 
-    let _x = f.get(1 + 2).unwrap().to_string();
-    // ^ don't include a borrow here
+        let _x: &i32 = f.get(1 + 2).unwrap();
+        // ^ include a borrow in the suggestion, even if the argument is not just a numeric literal
 
-    let _x = f.get(1 + 2).unwrap().abs();
-    // ^ don't include a borrow here
+        let _x = f.get(1 + 2).unwrap().to_string();
+        // ^ don't include a borrow here
+
+        let _x = f.get(1 + 2).unwrap().abs();
+        // ^ don't include a borrow here
+    }
+
+    // original code:
+    fn linidx(row: usize, col: usize) -> usize {
+        row * 1 + col * 3
+    }
+
+    fn main_() {
+        let mut mat = [1.0f32, 5.0, 9.0, 2.0, 6.0, 10.0, 3.0, 7.0, 11.0, 4.0, 8.0, 12.0];
+
+        for i in 0..2 {
+            for j in i + 1..3 {
+                if mat[linidx(j, 3)] > mat[linidx(i, 3)] {
+                    for k in 0..4 {
+                        let (x, rest) = mat.split_at_mut(linidx(i, k) + 1);
+                        let a = x.last_mut().unwrap();
+                        let b = rest.get_mut(linidx(j, k) - linidx(i, k) - 1).unwrap();
+                        ::std::mem::swap(a, b);
+                    }
+                }
+            }
+        }
+        assert_eq!([9.0, 5.0, 1.0, 10.0, 6.0, 2.0, 11.0, 7.0, 3.0, 12.0, 8.0, 4.0], mat);
+    }
 }
diff --git a/tests/ui/get_unwrap.stderr b/tests/ui/get_unwrap.stderr
index 6221c236830..154083ea654 100644
--- a/tests/ui/get_unwrap.stderr
+++ b/tests/ui/get_unwrap.stderr
@@ -188,46 +188,28 @@ LL |         let _ = some_vec.get_mut(0..1).unwrap().to_vec();
    = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
 
 error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more concise
-  --> $DIR/get_unwrap.rs:77:20
+  --> $DIR/get_unwrap.rs:79:24
    |
-LL |     let _x: &i32 = f.get(1 + 2).unwrap();
-   |                    ^^^^^^^^^^^^^^^^^^^^^ help: try this: `&f[1 + 2]`
-
-error: used `unwrap()` on an `Option` value
-  --> $DIR/get_unwrap.rs:77:20
-   |
-LL |     let _x: &i32 = f.get(1 + 2).unwrap();
-   |                    ^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
+LL |         let _x: &i32 = f.get(1 + 2).unwrap();
+   |                        ^^^^^^^^^^^^^^^^^^^^^ help: try this: `&f[1 + 2]`
 
 error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more concise
-  --> $DIR/get_unwrap.rs:80:14
-   |
-LL |     let _x = f.get(1 + 2).unwrap().to_string();
-   |              ^^^^^^^^^^^^^^^^^^^^^ help: try this: `f[1 + 2]`
-
-error: used `unwrap()` on an `Option` value
-  --> $DIR/get_unwrap.rs:80:14
-   |
-LL |     let _x = f.get(1 + 2).unwrap().to_string();
-   |              ^^^^^^^^^^^^^^^^^^^^^
+  --> $DIR/get_unwrap.rs:82:18
    |
-   = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
+LL |         let _x = f.get(1 + 2).unwrap().to_string();
+   |                  ^^^^^^^^^^^^^^^^^^^^^ help: try this: `f[1 + 2]`
 
 error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more concise
-  --> $DIR/get_unwrap.rs:83:14
+  --> $DIR/get_unwrap.rs:85:18
    |
-LL |     let _x = f.get(1 + 2).unwrap().abs();
-   |              ^^^^^^^^^^^^^^^^^^^^^ help: try this: `f[1 + 2]`
+LL |         let _x = f.get(1 + 2).unwrap().abs();
+   |                  ^^^^^^^^^^^^^^^^^^^^^ help: try this: `f[1 + 2]`
 
-error: used `unwrap()` on an `Option` value
-  --> $DIR/get_unwrap.rs:83:14
-   |
-LL |     let _x = f.get(1 + 2).unwrap().abs();
-   |              ^^^^^^^^^^^^^^^^^^^^^
+error: called `.get_mut().unwrap()` on a slice. Using `[]` is more clear and more concise
+  --> $DIR/get_unwrap.rs:103:33
    |
-   = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
+LL |                         let b = rest.get_mut(linidx(j, k) - linidx(i, k) - 1).unwrap();
+   |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&mut rest[linidx(j, k) - linidx(i, k) - 1]`
 
-error: aborting due to 32 previous errors
+error: aborting due to 30 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From bdb2a1710774e0d77058c81fa3c7182f27565ddd Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Wed, 21 Jun 2023 09:16:25 +0200
Subject: declare needs_ref later

---
 clippy_lints/src/methods/get_unwrap.rs | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/get_unwrap.rs b/clippy_lints/src/methods/get_unwrap.rs
index ba5aae28bd6..e35fb12ed79 100644
--- a/clippy_lints/src/methods/get_unwrap.rs
+++ b/clippy_lints/src/methods/get_unwrap.rs
@@ -22,7 +22,6 @@ pub(super) fn check<'tcx>(
     let mut applicability = Applicability::MachineApplicable;
     let expr_ty = cx.typeck_results().expr_ty(recv);
     let get_args_str = snippet_with_applicability(cx, get_arg.span, "..", &mut applicability);
-    let mut needs_ref = true;
     let caller_type = if derefs_to_slice(cx, recv, expr_ty).is_some() {
         "slice"
     } else if is_type_diagnostic_item(cx, expr_ty, sym::Vec) {
@@ -42,8 +41,7 @@ pub(super) fn check<'tcx>(
     // Handle the case where the result is immediately dereferenced,
     // either directly be the user, or as a result of a method call or the like
     // by not requiring an explicit reference
-    if needs_ref
-        && let Some(parent) = get_parent_expr(cx, expr)
+    let needs_ref = if let Some(parent) = get_parent_expr(cx, expr)
         && let hir::ExprKind::Unary(hir::UnOp::Deref, _)
             | hir::ExprKind::MethodCall(..)
             | hir::ExprKind::Field(..)
@@ -54,8 +52,10 @@ pub(super) fn check<'tcx>(
             // the span to also include the deref part
             span = parent.span;
         }
-        needs_ref = false;
-    }
+        false
+    } else {
+        true
+    };
 
     let mut_str = if is_mut { "_mut" } else { "" };
     let borrow_str = if !needs_ref {
-- 
cgit 1.4.1-3-g733a5


From 716305d4b6976fd778ff9bfad723f7f761e2bd90 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Wed, 21 Jun 2023 16:36:48 +0200
Subject: [`question_mark`]: don't lint inside of `try` block

---
 clippy_lints/src/lib.rs           |   2 +-
 clippy_lints/src/question_mark.rs | 236 ++++++++++++++++++++++----------------
 tests/ui/question_mark.fixed      |  12 ++
 tests/ui/question_mark.rs         |  12 ++
 tests/ui/question_mark.stderr     |  30 ++---
 5 files changed, 178 insertions(+), 114 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 3fb4e6c8fa5..876fcd0f197 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -770,7 +770,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::<useless_conversion::UselessConversion>::default());
     store.register_late_pass(|_| Box::new(implicit_hasher::ImplicitHasher));
     store.register_late_pass(|_| Box::new(fallible_impl_from::FallibleImplFrom));
-    store.register_late_pass(|_| Box::new(question_mark::QuestionMark));
+    store.register_late_pass(|_| Box::<question_mark::QuestionMark>::default());
     store.register_late_pass(|_| Box::new(question_mark_used::QuestionMarkUsed));
     store.register_early_pass(|| Box::new(suspicious_operation_groupings::SuspiciousOperationGroupings));
     store.register_late_pass(|_| Box::new(suspicious_trait_impl::SuspiciousImpl));
diff --git a/clippy_lints/src/question_mark.rs b/clippy_lints/src/question_mark.rs
index 5269bbd1f1a..036ad3e0d15 100644
--- a/clippy_lints/src/question_mark.rs
+++ b/clippy_lints/src/question_mark.rs
@@ -1,19 +1,20 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::higher;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::{
     eq_expr_value, get_parent_node, in_constant, is_else_clause, is_res_lang_ctor, path_to_local, path_to_local_id,
     peel_blocks, peel_blocks_with_stmt,
 };
+use clippy_utils::{higher, is_path_lang_item};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::def::Res;
-use rustc_hir::LangItem::{OptionNone, OptionSome, ResultErr, ResultOk};
+use rustc_hir::LangItem::{self, OptionNone, OptionSome, ResultErr, ResultOk};
 use rustc_hir::{BindingAnnotation, ByRef, Expr, ExprKind, Node, PatKind, PathSegment, QPath};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::Ty;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_tool_lint;
+use rustc_session::impl_lint_pass;
 use rustc_span::{sym, symbol::Symbol};
 
 declare_clippy_lint! {
@@ -41,7 +42,16 @@ declare_clippy_lint! {
     "checks for expressions that could be replaced by the question mark operator"
 }
 
-declare_lint_pass!(QuestionMark => [QUESTION_MARK]);
+#[derive(Default)]
+pub struct QuestionMark {
+    /// Keeps track of how many try blocks we are in at any point during linting.
+    /// This allows us to answer the question "are we inside of a try block"
+    /// very quickly, without having to walk up the parent chain, by simply checking
+    /// if it is greater than zero.
+    /// As for why we need this in the first place: <https://github.com/rust-lang/rust-clippy/issues/8628>
+    try_block_depth: u32,
+}
+impl_lint_pass!(QuestionMark => [QUESTION_MARK]);
 
 enum IfBlockType<'hir> {
     /// An `if x.is_xxx() { a } else { b } ` expression.
@@ -68,98 +78,6 @@ enum IfBlockType<'hir> {
     ),
 }
 
-/// Checks if the given expression on the given context matches the following structure:
-///
-/// ```ignore
-/// if option.is_none() {
-///    return None;
-/// }
-/// ```
-///
-/// ```ignore
-/// if result.is_err() {
-///     return result;
-/// }
-/// ```
-///
-/// If it matches, it will suggest to use the question mark operator instead
-fn check_is_none_or_err_and_early_return<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>) {
-    if_chain! {
-        if let Some(higher::If { cond, then, r#else }) = higher::If::hir(expr);
-        if !is_else_clause(cx.tcx, expr);
-        if let ExprKind::MethodCall(segment, caller, ..) = &cond.kind;
-        let caller_ty = cx.typeck_results().expr_ty(caller);
-        let if_block = IfBlockType::IfIs(caller, caller_ty, segment.ident.name, then, r#else);
-        if is_early_return(sym::Option, cx, &if_block) || is_early_return(sym::Result, cx, &if_block);
-        then {
-            let mut applicability = Applicability::MachineApplicable;
-            let receiver_str = snippet_with_applicability(cx, caller.span, "..", &mut applicability);
-            let by_ref = !caller_ty.is_copy_modulo_regions(cx.tcx, cx.param_env) &&
-                !matches!(caller.kind, ExprKind::Call(..) | ExprKind::MethodCall(..));
-            let sugg = if let Some(else_inner) = r#else {
-                if eq_expr_value(cx, caller, peel_blocks(else_inner)) {
-                    format!("Some({receiver_str}?)")
-                } else {
-                    return;
-                }
-            } else {
-                format!("{receiver_str}{}?;", if by_ref { ".as_ref()" } else { "" })
-            };
-
-            span_lint_and_sugg(
-                cx,
-                QUESTION_MARK,
-                expr.span,
-                "this block may be rewritten with the `?` operator",
-                "replace it with",
-                sugg,
-                applicability,
-            );
-        }
-    }
-}
-
-fn check_if_let_some_or_err_and_early_return<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>) {
-    if_chain! {
-        if let Some(higher::IfLet { let_pat, let_expr, if_then, if_else }) = higher::IfLet::hir(cx, expr);
-        if !is_else_clause(cx.tcx, expr);
-        if let PatKind::TupleStruct(ref path1, [field], ddpos) = let_pat.kind;
-        if ddpos.as_opt_usize().is_none();
-        if let PatKind::Binding(BindingAnnotation(by_ref, _), bind_id, ident, None) = field.kind;
-        let caller_ty = cx.typeck_results().expr_ty(let_expr);
-        let if_block = IfBlockType::IfLet(
-            cx.qpath_res(path1, let_pat.hir_id),
-            caller_ty,
-            ident.name,
-            let_expr,
-            if_then,
-            if_else
-        );
-        if (is_early_return(sym::Option, cx, &if_block) && path_to_local_id(peel_blocks(if_then), bind_id))
-            || is_early_return(sym::Result, cx, &if_block);
-        if if_else.map(|e| eq_expr_value(cx, let_expr, peel_blocks(e))).filter(|e| *e).is_none();
-        then {
-            let mut applicability = Applicability::MachineApplicable;
-            let receiver_str = snippet_with_applicability(cx, let_expr.span, "..", &mut applicability);
-            let requires_semi = matches!(get_parent_node(cx.tcx, expr.hir_id), Some(Node::Stmt(_)));
-            let sugg = format!(
-                "{receiver_str}{}?{}",
-                if by_ref == ByRef::Yes { ".as_ref()" } else { "" },
-                if requires_semi { ";" } else { "" }
-            );
-            span_lint_and_sugg(
-                cx,
-                QUESTION_MARK,
-                expr.span,
-                "this block may be rewritten with the `?` operator",
-                "replace it with",
-                sugg,
-                applicability,
-            );
-        }
-    }
-}
-
 fn is_early_return(smbl: Symbol, cx: &LateContext<'_>, if_block: &IfBlockType<'_>) -> bool {
     match *if_block {
         IfBlockType::IfIs(caller, caller_ty, call_sym, if_then, _) => {
@@ -230,11 +148,133 @@ fn expr_return_none_or_err(
     }
 }
 
+impl QuestionMark {
+    fn inside_try_block(&self) -> bool {
+        self.try_block_depth > 0
+    }
+
+    /// Checks if the given expression on the given context matches the following structure:
+    ///
+    /// ```ignore
+    /// if option.is_none() {
+    ///    return None;
+    /// }
+    /// ```
+    ///
+    /// ```ignore
+    /// if result.is_err() {
+    ///     return result;
+    /// }
+    /// ```
+    ///
+    /// If it matches, it will suggest to use the question mark operator instead
+    fn check_is_none_or_err_and_early_return<'tcx>(&self, cx: &LateContext<'tcx>, expr: &Expr<'tcx>) {
+        if_chain! {
+            if !self.inside_try_block();
+            if let Some(higher::If { cond, then, r#else }) = higher::If::hir(expr);
+            if !is_else_clause(cx.tcx, expr);
+            if let ExprKind::MethodCall(segment, caller, ..) = &cond.kind;
+            let caller_ty = cx.typeck_results().expr_ty(caller);
+            let if_block = IfBlockType::IfIs(caller, caller_ty, segment.ident.name, then, r#else);
+            if is_early_return(sym::Option, cx, &if_block) || is_early_return(sym::Result, cx, &if_block);
+            then {
+                let mut applicability = Applicability::MachineApplicable;
+                let receiver_str = snippet_with_applicability(cx, caller.span, "..", &mut applicability);
+                let by_ref = !caller_ty.is_copy_modulo_regions(cx.tcx, cx.param_env) &&
+                    !matches!(caller.kind, ExprKind::Call(..) | ExprKind::MethodCall(..));
+                let sugg = if let Some(else_inner) = r#else {
+                    if eq_expr_value(cx, caller, peel_blocks(else_inner)) {
+                        format!("Some({receiver_str}?)")
+                    } else {
+                        return;
+                    }
+                } else {
+                    format!("{receiver_str}{}?;", if by_ref { ".as_ref()" } else { "" })
+                };
+
+                span_lint_and_sugg(
+                    cx,
+                    QUESTION_MARK,
+                    expr.span,
+                    "this block may be rewritten with the `?` operator",
+                    "replace it with",
+                    sugg,
+                    applicability,
+                );
+            }
+        }
+    }
+
+    fn check_if_let_some_or_err_and_early_return<'tcx>(&self, cx: &LateContext<'tcx>, expr: &Expr<'tcx>) {
+        if_chain! {
+            if !self.inside_try_block();
+            if let Some(higher::IfLet { let_pat, let_expr, if_then, if_else }) = higher::IfLet::hir(cx, expr);
+            if !is_else_clause(cx.tcx, expr);
+            if let PatKind::TupleStruct(ref path1, [field], ddpos) = let_pat.kind;
+            if ddpos.as_opt_usize().is_none();
+            if let PatKind::Binding(BindingAnnotation(by_ref, _), bind_id, ident, None) = field.kind;
+            let caller_ty = cx.typeck_results().expr_ty(let_expr);
+            let if_block = IfBlockType::IfLet(
+                cx.qpath_res(path1, let_pat.hir_id),
+                caller_ty,
+                ident.name,
+                let_expr,
+                if_then,
+                if_else
+            );
+            if (is_early_return(sym::Option, cx, &if_block) && path_to_local_id(peel_blocks(if_then), bind_id))
+                || is_early_return(sym::Result, cx, &if_block);
+            if if_else.map(|e| eq_expr_value(cx, let_expr, peel_blocks(e))).filter(|e| *e).is_none();
+            then {
+                let mut applicability = Applicability::MachineApplicable;
+                let receiver_str = snippet_with_applicability(cx, let_expr.span, "..", &mut applicability);
+                let requires_semi = matches!(get_parent_node(cx.tcx, expr.hir_id), Some(Node::Stmt(_)));
+                let sugg = format!(
+                    "{receiver_str}{}?{}",
+                    if by_ref == ByRef::Yes { ".as_ref()" } else { "" },
+                    if requires_semi { ";" } else { "" }
+                );
+                span_lint_and_sugg(
+                    cx,
+                    QUESTION_MARK,
+                    expr.span,
+                    "this block may be rewritten with the `?` operator",
+                    "replace it with",
+                    sugg,
+                    applicability,
+                );
+            }
+        }
+    }
+}
+
+fn is_try_block(cx: &LateContext<'_>, bl: &rustc_hir::Block<'_>) -> bool {
+    if let Some(expr) = bl.expr
+        && let rustc_hir::ExprKind::Call(callee, _) = expr.kind
+    {
+        is_path_lang_item(cx, callee, LangItem::TryTraitFromOutput)
+    } else {
+        false
+    }
+}
+
 impl<'tcx> LateLintPass<'tcx> for QuestionMark {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if !in_constant(cx, expr.hir_id) {
-            check_is_none_or_err_and_early_return(cx, expr);
-            check_if_let_some_or_err_and_early_return(cx, expr);
+            self.check_is_none_or_err_and_early_return(cx, expr);
+            self.check_if_let_some_or_err_and_early_return(cx, expr);
+        }
+    }
+
+    fn check_block(&mut self, cx: &LateContext<'tcx>, block: &'tcx rustc_hir::Block<'tcx>) {
+        if is_try_block(cx, block) {
+            self.try_block_depth += 1;
+        }
+    }
+
+    fn check_block_post(&mut self, cx: &LateContext<'tcx>, block: &'tcx rustc_hir::Block<'tcx>) {
+        if is_try_block(cx, block) {
+            self.try_block_depth -= 1;
         }
     }
 }
diff --git a/tests/ui/question_mark.fixed b/tests/ui/question_mark.fixed
index 7f1660f31fa..f257378842b 100644
--- a/tests/ui/question_mark.fixed
+++ b/tests/ui/question_mark.fixed
@@ -1,4 +1,5 @@
 //@run-rustfix
+#![feature(try_blocks)]
 #![allow(unreachable_code)]
 #![allow(dead_code)]
 #![allow(clippy::unnecessary_wraps)]
@@ -227,6 +228,17 @@ fn pattern() -> Result<(), PatternedError> {
 
 fn main() {}
 
+// `?` is not the same as `return None;` if inside of a try block
+fn issue8628(a: Option<u32>) -> Option<u32> {
+    let b: Option<u32> = try {
+        if a.is_none() {
+            return None;
+        }
+        32
+    };
+    b.or(Some(128))
+}
+
 // should not lint, `?` operator not available in const context
 const fn issue9175(option: Option<()>) -> Option<()> {
     if option.is_none() {
diff --git a/tests/ui/question_mark.rs b/tests/ui/question_mark.rs
index a90eae50ed4..29d79b078ac 100644
--- a/tests/ui/question_mark.rs
+++ b/tests/ui/question_mark.rs
@@ -1,4 +1,5 @@
 //@run-rustfix
+#![feature(try_blocks)]
 #![allow(unreachable_code)]
 #![allow(dead_code)]
 #![allow(clippy::unnecessary_wraps)]
@@ -263,6 +264,17 @@ fn pattern() -> Result<(), PatternedError> {
 
 fn main() {}
 
+// `?` is not the same as `return None;` if inside of a try block
+fn issue8628(a: Option<u32>) -> Option<u32> {
+    let b: Option<u32> = try {
+        if a.is_none() {
+            return None;
+        }
+        32
+    };
+    b.or(Some(128))
+}
+
 // should not lint, `?` operator not available in const context
 const fn issue9175(option: Option<()>) -> Option<()> {
     if option.is_none() {
diff --git a/tests/ui/question_mark.stderr b/tests/ui/question_mark.stderr
index 23172d7e535..86d89942cc0 100644
--- a/tests/ui/question_mark.stderr
+++ b/tests/ui/question_mark.stderr
@@ -1,5 +1,5 @@
 error: this block may be rewritten with the `?` operator
-  --> $DIR/question_mark.rs:7:5
+  --> $DIR/question_mark.rs:8:5
    |
 LL | /     if a.is_none() {
 LL | |         return None;
@@ -9,7 +9,7 @@ LL | |     }
    = note: `-D clippy::question-mark` implied by `-D warnings`
 
 error: this block may be rewritten with the `?` operator
-  --> $DIR/question_mark.rs:52:9
+  --> $DIR/question_mark.rs:53:9
    |
 LL | /         if (self.opt).is_none() {
 LL | |             return None;
@@ -17,7 +17,7 @@ LL | |         }
    | |_________^ help: replace it with: `(self.opt)?;`
 
 error: this block may be rewritten with the `?` operator
-  --> $DIR/question_mark.rs:56:9
+  --> $DIR/question_mark.rs:57:9
    |
 LL | /         if self.opt.is_none() {
 LL | |             return None
@@ -25,7 +25,7 @@ LL | |         }
    | |_________^ help: replace it with: `self.opt?;`
 
 error: this block may be rewritten with the `?` operator
-  --> $DIR/question_mark.rs:60:17
+  --> $DIR/question_mark.rs:61:17
    |
 LL |           let _ = if self.opt.is_none() {
    |  _________________^
@@ -36,7 +36,7 @@ LL | |         };
    | |_________^ help: replace it with: `Some(self.opt?)`
 
 error: this block may be rewritten with the `?` operator
-  --> $DIR/question_mark.rs:66:17
+  --> $DIR/question_mark.rs:67:17
    |
 LL |           let _ = if let Some(x) = self.opt {
    |  _________________^
@@ -47,7 +47,7 @@ LL | |         };
    | |_________^ help: replace it with: `self.opt?`
 
 error: this block may be rewritten with the `?` operator
-  --> $DIR/question_mark.rs:83:9
+  --> $DIR/question_mark.rs:84:9
    |
 LL | /         if self.opt.is_none() {
 LL | |             return None;
@@ -55,7 +55,7 @@ LL | |         }
    | |_________^ help: replace it with: `self.opt.as_ref()?;`
 
 error: this block may be rewritten with the `?` operator
-  --> $DIR/question_mark.rs:91:9
+  --> $DIR/question_mark.rs:92:9
    |
 LL | /         if self.opt.is_none() {
 LL | |             return None;
@@ -63,7 +63,7 @@ LL | |         }
    | |_________^ help: replace it with: `self.opt.as_ref()?;`
 
 error: this block may be rewritten with the `?` operator
-  --> $DIR/question_mark.rs:99:9
+  --> $DIR/question_mark.rs:100:9
    |
 LL | /         if self.opt.is_none() {
 LL | |             return None;
@@ -71,7 +71,7 @@ LL | |         }
    | |_________^ help: replace it with: `self.opt.as_ref()?;`
 
 error: this block may be rewritten with the `?` operator
-  --> $DIR/question_mark.rs:106:26
+  --> $DIR/question_mark.rs:107:26
    |
 LL |           let v: &Vec<_> = if let Some(ref v) = self.opt {
    |  __________________________^
@@ -82,7 +82,7 @@ LL | |         };
    | |_________^ help: replace it with: `self.opt.as_ref()?`
 
 error: this block may be rewritten with the `?` operator
-  --> $DIR/question_mark.rs:116:17
+  --> $DIR/question_mark.rs:117:17
    |
 LL |           let v = if let Some(v) = self.opt {
    |  _________________^
@@ -93,7 +93,7 @@ LL | |         };
    | |_________^ help: replace it with: `self.opt?`
 
 error: this block may be rewritten with the `?` operator
-  --> $DIR/question_mark.rs:131:5
+  --> $DIR/question_mark.rs:132:5
    |
 LL | /     if f().is_none() {
 LL | |         return None;
@@ -101,13 +101,13 @@ LL | |     }
    | |_____^ help: replace it with: `f()?;`
 
 error: this block may be rewritten with the `?` operator
-  --> $DIR/question_mark.rs:143:13
+  --> $DIR/question_mark.rs:144:13
    |
 LL |     let _ = if let Ok(x) = x { x } else { return x };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `x?`
 
 error: this block may be rewritten with the `?` operator
-  --> $DIR/question_mark.rs:145:5
+  --> $DIR/question_mark.rs:146:5
    |
 LL | /     if x.is_err() {
 LL | |         return x;
@@ -115,7 +115,7 @@ LL | |     }
    | |_____^ help: replace it with: `x?;`
 
 error: this block may be rewritten with the `?` operator
-  --> $DIR/question_mark.rs:196:5
+  --> $DIR/question_mark.rs:197:5
    |
 LL | /     if let Err(err) = func_returning_result() {
 LL | |         return Err(err);
@@ -123,7 +123,7 @@ LL | |     }
    | |_____^ help: replace it with: `func_returning_result()?;`
 
 error: this block may be rewritten with the `?` operator
-  --> $DIR/question_mark.rs:203:5
+  --> $DIR/question_mark.rs:204:5
    |
 LL | /     if let Err(err) = func_returning_result() {
 LL | |         return Err(err);
-- 
cgit 1.4.1-3-g733a5


From b6f194b48c2b7b1cd6a19592a8376056a826d223 Mon Sep 17 00:00:00 2001
From: Catherine <114838443+Centri3@users.noreply.github.com>
Date: Wed, 21 Jun 2023 15:56:24 -0500
Subject: move to `drop_forget_ref`

---
 clippy_lints/src/declared_lints.rs  |  2 +-
 clippy_lints/src/drop_forget_ref.rs | 46 ++++++++++++++++++++++++++-----
 clippy_lints/src/lib.rs             |  2 --
 clippy_lints/src/mem_forget.rs      | 54 -------------------------------------
 tests/ui/mem_forget.stderr          | 23 ++++++++++++++++
 5 files changed, 64 insertions(+), 63 deletions(-)
 delete mode 100644 clippy_lints/src/mem_forget.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 9c1e1f6702d..0eec18a91bc 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -140,6 +140,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::double_parens::DOUBLE_PARENS_INFO,
     crate::drop_forget_ref::DROP_NON_DROP_INFO,
     crate::drop_forget_ref::FORGET_NON_DROP_INFO,
+    crate::drop_forget_ref::MEM_FORGET_INFO,
     crate::drop_forget_ref::UNDROPPED_MANUALLY_DROPS_INFO,
     crate::duplicate_mod::DUPLICATE_MOD_INFO,
     crate::else_if_without_else::ELSE_IF_WITHOUT_ELSE_INFO,
@@ -310,7 +311,6 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::matches::TRY_ERR_INFO,
     crate::matches::WILDCARD_ENUM_MATCH_ARM_INFO,
     crate::matches::WILDCARD_IN_OR_PATTERNS_INFO,
-    crate::mem_forget::MEM_FORGET_INFO,
     crate::mem_replace::MEM_REPLACE_OPTION_WITH_NONE_INFO,
     crate::mem_replace::MEM_REPLACE_WITH_DEFAULT_INFO,
     crate::mem_replace::MEM_REPLACE_WITH_UNINIT_INFO,
diff --git a/clippy_lints/src/drop_forget_ref.rs b/clippy_lints/src/drop_forget_ref.rs
index 9c60edb1794..36b231023a7 100644
--- a/clippy_lints/src/drop_forget_ref.rs
+++ b/clippy_lints/src/drop_forget_ref.rs
@@ -6,6 +6,7 @@ use rustc_hir::{Arm, Expr, ExprKind, LangItem, Node};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::sym;
+use std::borrow::Cow;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -76,6 +77,27 @@ declare_clippy_lint! {
     "use of safe `std::mem::drop` function to drop a std::mem::ManuallyDrop, which will not drop the inner value"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of `std::mem::forget(t)` where `t` is
+    /// `Drop` or has a field that implements `Drop`.
+    ///
+    /// ### Why is this bad?
+    /// `std::mem::forget(t)` prevents `t` from running its
+    /// destructor, possibly causing leaks.
+    ///
+    /// ### Example
+    /// ```rust
+    /// # use std::mem;
+    /// # use std::rc::Rc;
+    /// mem::forget(Rc::new(55))
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub MEM_FORGET,
+    restriction,
+    "`mem::forget` usage on `Drop` types, likely to cause memory leaks"
+}
+
 const DROP_NON_DROP_SUMMARY: &str = "call to `std::mem::drop` with a value that does not implement `Drop`. \
                                  Dropping such a type only extends its contained lifetimes";
 const FORGET_NON_DROP_SUMMARY: &str = "call to `std::mem::forget` with a value that does not implement `Drop`. \
@@ -84,7 +106,8 @@ const FORGET_NON_DROP_SUMMARY: &str = "call to `std::mem::forget` with a value t
 declare_lint_pass!(DropForgetRef => [
     DROP_NON_DROP,
     FORGET_NON_DROP,
-    UNDROPPED_MANUALLY_DROPS
+    UNDROPPED_MANUALLY_DROPS,
+    MEM_FORGET,
 ]);
 
 impl<'tcx> LateLintPass<'tcx> for DropForgetRef {
@@ -121,18 +144,29 @@ impl<'tcx> LateLintPass<'tcx> for DropForgetRef {
                         || drop_is_single_call_in_arm
                         ) =>
                 {
-                    (DROP_NON_DROP, DROP_NON_DROP_SUMMARY)
-                },
-                sym::mem_forget if !arg_ty.needs_drop(cx.tcx, cx.param_env) => {
-                    (FORGET_NON_DROP, FORGET_NON_DROP_SUMMARY)
+                    (DROP_NON_DROP, DROP_NON_DROP_SUMMARY.into())
                 },
+                sym::mem_forget => {
+                    if arg_ty.needs_drop(cx.tcx, cx.param_env) {
+                        (MEM_FORGET, Cow::Owned(format!(
+                            "usage of `mem::forget` on {}",
+                            if arg_ty.ty_adt_def().map_or(false, |def| def.has_dtor(cx.tcx)) {
+                                "`Drop` type"
+                            } else {
+                                "type with `Drop` fields"
+                            }
+                        )))
+                    } else {
+                        (FORGET_NON_DROP, FORGET_NON_DROP_SUMMARY.into())
+                    }
+                }
                 _ => return,
             };
             span_lint_and_note(
                 cx,
                 lint,
                 expr.span,
-                msg,
+                &msg,
                 Some(arg.span),
                 &format!("argument has type `{arg_ty}`"),
             );
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 3fb4e6c8fa5..71b8af7a821 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -196,7 +196,6 @@ mod manual_strip;
 mod map_unit_fn;
 mod match_result_ok;
 mod matches;
-mod mem_forget;
 mod mem_replace;
 mod methods;
 mod min_ident_chars;
@@ -744,7 +743,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     let missing_docs_in_crate_items = conf.missing_docs_in_crate_items;
     store.register_late_pass(move |_| Box::new(doc::DocMarkdown::new(doc_valid_idents.clone())));
     store.register_late_pass(|_| Box::new(neg_multiply::NegMultiply));
-    store.register_late_pass(|_| Box::new(mem_forget::MemForget));
     store.register_late_pass(|_| Box::new(let_if_seq::LetIfSeq));
     store.register_late_pass(|_| Box::new(mixed_read_write_in_expression::EvalOrderDependence));
     store.register_late_pass(move |_| Box::new(missing_doc::MissingDoc::new(missing_docs_in_crate_items)));
diff --git a/clippy_lints/src/mem_forget.rs b/clippy_lints/src/mem_forget.rs
deleted file mode 100644
index fdd55260483..00000000000
--- a/clippy_lints/src/mem_forget.rs
+++ /dev/null
@@ -1,54 +0,0 @@
-use clippy_utils::diagnostics::span_lint;
-use rustc_hir::{Expr, ExprKind};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::sym;
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for usage of `std::mem::forget(t)` where `t` is
-    /// `Drop` or has a field that implements `Drop`.
-    ///
-    /// ### Why is this bad?
-    /// `std::mem::forget(t)` prevents `t` from running its
-    /// destructor, possibly causing leaks.
-    ///
-    /// ### Example
-    /// ```rust
-    /// # use std::mem;
-    /// # use std::rc::Rc;
-    /// mem::forget(Rc::new(55))
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub MEM_FORGET,
-    restriction,
-    "`mem::forget` usage on `Drop` types, likely to cause memory leaks"
-}
-
-declare_lint_pass!(MemForget => [MEM_FORGET]);
-
-impl<'tcx> LateLintPass<'tcx> for MemForget {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
-        if let ExprKind::Call(path_expr, [ref first_arg, ..]) = e.kind
-            && let ExprKind::Path(ref qpath) = path_expr.kind
-            && let Some(def_id) = cx.qpath_res(qpath, path_expr.hir_id).opt_def_id()
-            && cx.tcx.is_diagnostic_item(sym::mem_forget, def_id)
-            && let forgot_ty = cx.typeck_results().expr_ty(first_arg)
-            && forgot_ty.needs_drop(cx.tcx, cx.param_env)
-        {
-            span_lint(
-                cx,
-                MEM_FORGET,
-                e.span,
-                &format!(
-                    "usage of `mem::forget` on {}",
-                    if forgot_ty.ty_adt_def().map_or(false, |def| def.has_dtor(cx.tcx)) {
-                        "`Drop` type"
-                    } else {
-                        "type with `Drop` fields"
-                    }
-                ),
-            );
-        }
-    }
-}
diff --git a/tests/ui/mem_forget.stderr b/tests/ui/mem_forget.stderr
index 50711120a15..6e3c31804d7 100644
--- a/tests/ui/mem_forget.stderr
+++ b/tests/ui/mem_forget.stderr
@@ -4,6 +4,11 @@ error: usage of `mem::forget` on `Drop` type
 LL |     memstuff::forget(six);
    |     ^^^^^^^^^^^^^^^^^^^^^
    |
+note: argument has type `std::sync::Arc<i32>`
+  --> $DIR/mem_forget.rs:14:22
+   |
+LL |     memstuff::forget(six);
+   |                      ^^^
    = note: `-D clippy::mem-forget` implied by `-D warnings`
 
 error: usage of `mem::forget` on `Drop` type
@@ -11,18 +16,36 @@ error: usage of `mem::forget` on `Drop` type
    |
 LL |     std::mem::forget(seven);
    |     ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: argument has type `std::rc::Rc<i32>`
+  --> $DIR/mem_forget.rs:17:22
+   |
+LL |     std::mem::forget(seven);
+   |                      ^^^^^
 
 error: usage of `mem::forget` on `Drop` type
   --> $DIR/mem_forget.rs:20:5
    |
 LL |     forgetSomething(eight);
    |     ^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: argument has type `std::vec::Vec<i32>`
+  --> $DIR/mem_forget.rs:20:21
+   |
+LL |     forgetSomething(eight);
+   |                     ^^^^^
 
 error: usage of `mem::forget` on type with `Drop` fields
   --> $DIR/mem_forget.rs:23:5
    |
 LL |     std::mem::forget(string);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: argument has type `std::string::String`
+  --> $DIR/mem_forget.rs:23:22
+   |
+LL |     std::mem::forget(string);
+   |                      ^^^^^^
 
 error: aborting due to 4 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 242807a9c1cb24ef5e0d665fa9ac696d2a095c71 Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Tue, 20 Jun 2023 00:39:22 -0500
Subject: Don't lint `iter_nth_zero` in `next`

---
 clippy_lints/src/methods/iter_nth.rs      |  4 ++--
 clippy_lints/src/methods/iter_nth_zero.rs | 35 ++++++++++++++++---------------
 tests/ui/iter_nth.stderr                  |  8 +++----
 tests/ui/iter_nth_zero.fixed              | 15 +++++++++++++
 tests/ui/iter_nth_zero.rs                 | 15 +++++++++++++
 5 files changed, 54 insertions(+), 23 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/iter_nth.rs b/clippy_lints/src/methods/iter_nth.rs
index ceee12784cb..12104310405 100644
--- a/clippy_lints/src/methods/iter_nth.rs
+++ b/clippy_lints/src/methods/iter_nth.rs
@@ -20,9 +20,9 @@ pub(super) fn check<'tcx>(
     let caller_type = if derefs_to_slice(cx, iter_recv, cx.typeck_results().expr_ty(iter_recv)).is_some() {
         "slice"
     } else if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(iter_recv), sym::Vec) {
-        "Vec"
+        "`Vec`"
     } else if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(iter_recv), sym::VecDeque) {
-        "VecDeque"
+        "`VecDeque`"
     } else {
         iter_nth_zero::check(cx, expr, nth_recv, nth_arg);
         return; // caller is not a type that we want to lint
diff --git a/clippy_lints/src/methods/iter_nth_zero.rs b/clippy_lints/src/methods/iter_nth_zero.rs
index d1609eebfdc..e1f950d5a4a 100644
--- a/clippy_lints/src/methods/iter_nth_zero.rs
+++ b/clippy_lints/src/methods/iter_nth_zero.rs
@@ -1,8 +1,8 @@
 use clippy_utils::consts::{constant, Constant};
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::is_trait_method;
 use clippy_utils::source::snippet_with_applicability;
-use if_chain::if_chain;
+use clippy_utils::{is_lang_item_or_ctor, is_trait_method};
+use hir::{LangItem, OwnerNode};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
@@ -11,20 +11,21 @@ use rustc_span::sym;
 use super::ITER_NTH_ZERO;
 
 pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr<'_>, arg: &hir::Expr<'_>) {
-    if_chain! {
-        if is_trait_method(cx, expr, sym::Iterator);
-        if let Some(Constant::Int(0)) = constant(cx, cx.typeck_results(), arg);
-        then {
-            let mut applicability = Applicability::MachineApplicable;
-            span_lint_and_sugg(
-                cx,
-                ITER_NTH_ZERO,
-                expr.span,
-                "called `.nth(0)` on a `std::iter::Iterator`, when `.next()` is equivalent",
-                "try calling `.next()` instead of `.nth(0)`",
-                format!("{}.next()", snippet_with_applicability(cx, recv.span, "..", &mut applicability)),
-                applicability,
-            );
-        }
+    if let OwnerNode::Item(item) = cx.tcx.hir().owner(cx.tcx.hir().get_parent_item(expr.hir_id))
+        && let def_id = item.owner_id.to_def_id()
+        && is_trait_method(cx, expr, sym::Iterator)
+        && let Some(Constant::Int(0)) = constant(cx, cx.typeck_results(), arg)
+        && !is_lang_item_or_ctor(cx, def_id, LangItem::IteratorNext)
+    {
+        let mut app = Applicability::MachineApplicable;
+        span_lint_and_sugg(
+            cx,
+            ITER_NTH_ZERO,
+            expr.span,
+            "called `.nth(0)` on a `std::iter::Iterator`, when `.next()` is equivalent",
+            "try calling `.next()` instead of `.nth(0)`",
+            format!("{}.next()", snippet_with_applicability(cx, recv.span, "..", &mut app)),
+            app,
+        );
     }
 }
diff --git a/tests/ui/iter_nth.stderr b/tests/ui/iter_nth.stderr
index 975a5a62ad5..24be814548a 100644
--- a/tests/ui/iter_nth.stderr
+++ b/tests/ui/iter_nth.stderr
@@ -1,4 +1,4 @@
-error: called `.iter().nth()` on a Vec
+error: called `.iter().nth()` on a `Vec`
   --> $DIR/iter_nth.rs:34:23
    |
 LL |         let bad_vec = some_vec.iter().nth(3);
@@ -23,7 +23,7 @@ LL |         let bad_boxed_slice = boxed_slice.iter().nth(3);
    |
    = help: calling `.get()` is both faster and more readable
 
-error: called `.iter().nth()` on a VecDeque
+error: called `.iter().nth()` on a `VecDeque`
   --> $DIR/iter_nth.rs:37:29
    |
 LL |         let bad_vec_deque = some_vec_deque.iter().nth(3);
@@ -31,7 +31,7 @@ LL |         let bad_vec_deque = some_vec_deque.iter().nth(3);
    |
    = help: calling `.get()` is both faster and more readable
 
-error: called `.iter_mut().nth()` on a Vec
+error: called `.iter_mut().nth()` on a `Vec`
   --> $DIR/iter_nth.rs:42:23
    |
 LL |         let bad_vec = some_vec.iter_mut().nth(3);
@@ -47,7 +47,7 @@ LL |         let bad_slice = &some_vec[..].iter_mut().nth(3);
    |
    = help: calling `.get_mut()` is both faster and more readable
 
-error: called `.iter_mut().nth()` on a VecDeque
+error: called `.iter_mut().nth()` on a `VecDeque`
   --> $DIR/iter_nth.rs:48:29
    |
 LL |         let bad_vec_deque = some_vec_deque.iter_mut().nth(3);
diff --git a/tests/ui/iter_nth_zero.fixed b/tests/ui/iter_nth_zero.fixed
index 587b0d1d366..91f4a7ba0d2 100644
--- a/tests/ui/iter_nth_zero.fixed
+++ b/tests/ui/iter_nth_zero.fixed
@@ -29,3 +29,18 @@ fn main() {
     let mut iter2 = s3.iter();
     let _unwrapped = iter2.next().unwrap();
 }
+
+struct Issue9820;
+
+impl Iterator for Issue9820 {
+    type Item = ();
+
+    fn nth(&mut self, _n: usize) -> Option<Self::Item> {
+        todo!()
+    }
+
+    // Don't lint in implementations of `next`, as calling `next` in `next` is incorrect
+    fn next(&mut self) -> Option<Self::Item> {
+        self.nth(0)
+    }
+}
diff --git a/tests/ui/iter_nth_zero.rs b/tests/ui/iter_nth_zero.rs
index 93b576ec56f..160a895bb7b 100644
--- a/tests/ui/iter_nth_zero.rs
+++ b/tests/ui/iter_nth_zero.rs
@@ -29,3 +29,18 @@ fn main() {
     let mut iter2 = s3.iter();
     let _unwrapped = iter2.nth(0).unwrap();
 }
+
+struct Issue9820;
+
+impl Iterator for Issue9820 {
+    type Item = ();
+
+    fn nth(&mut self, _n: usize) -> Option<Self::Item> {
+        todo!()
+    }
+
+    // Don't lint in implementations of `next`, as calling `next` in `next` is incorrect
+    fn next(&mut self) -> Option<Self::Item> {
+        self.nth(0)
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 6a1084c26fdd9653c0b8940bc5d3894ec9bb7d9d Mon Sep 17 00:00:00 2001
From: Catherine <114838443+Centri3@users.noreply.github.com>
Date: Thu, 22 Jun 2023 04:31:05 -0500
Subject: Check if `if` conditions always evaluate to true in `never_loop`

---
 clippy_lints/src/loops/never_loop.rs | 82 ++++++++++++++++++++++--------------
 clippy_utils/src/consts.rs           |  4 +-
 tests/ui/large_futures.rs            |  1 +
 tests/ui/large_futures.stderr        | 16 +++----
 tests/ui/never_loop.rs               | 38 +++++++++++++++++
 tests/ui/never_loop.stderr           | 40 ++++++++++++------
 6 files changed, 127 insertions(+), 54 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/never_loop.rs b/clippy_lints/src/loops/never_loop.rs
index 5f1fdf00be8..4f2092492aa 100644
--- a/clippy_lints/src/loops/never_loop.rs
+++ b/clippy_lints/src/loops/never_loop.rs
@@ -1,22 +1,23 @@
 use super::utils::make_iterator_snippet;
 use super::NEVER_LOOP;
-use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::consts::constant;
 use clippy_utils::higher::ForLoop;
 use clippy_utils::source::snippet;
+use clippy_utils::{consts::Constant, diagnostics::span_lint_and_then};
 use rustc_errors::Applicability;
 use rustc_hir::{Block, Destination, Expr, ExprKind, HirId, InlineAsmOperand, Pat, Stmt, StmtKind};
 use rustc_lint::LateContext;
 use rustc_span::Span;
 use std::iter::{once, Iterator};
 
-pub(super) fn check(
-    cx: &LateContext<'_>,
-    block: &Block<'_>,
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    block: &Block<'tcx>,
     loop_id: HirId,
     span: Span,
     for_loop: Option<&ForLoop<'_>>,
 ) {
-    match never_loop_block(block, &mut Vec::new(), loop_id) {
+    match never_loop_block(cx, block, &mut Vec::new(), loop_id) {
         NeverLoopResult::AlwaysBreak => {
             span_lint_and_then(cx, NEVER_LOOP, span, "this loop never actually loops", |diag| {
                 if let Some(ForLoop {
@@ -95,7 +96,12 @@ fn combine_branches(b1: NeverLoopResult, b2: NeverLoopResult, ignore_ids: &[HirI
     }
 }
 
-fn never_loop_block(block: &Block<'_>, ignore_ids: &mut Vec<HirId>, main_loop_id: HirId) -> NeverLoopResult {
+fn never_loop_block<'tcx>(
+    cx: &LateContext<'tcx>,
+    block: &Block<'tcx>,
+    ignore_ids: &mut Vec<HirId>,
+    main_loop_id: HirId,
+) -> NeverLoopResult {
     let iter = block
         .stmts
         .iter()
@@ -103,10 +109,10 @@ fn never_loop_block(block: &Block<'_>, ignore_ids: &mut Vec<HirId>, main_loop_id
         .chain(block.expr.map(|expr| (expr, None)));
 
     iter.map(|(e, els)| {
-        let e = never_loop_expr(e, ignore_ids, main_loop_id);
+        let e = never_loop_expr(cx, e, ignore_ids, main_loop_id);
         // els is an else block in a let...else binding
         els.map_or(e, |els| {
-            combine_branches(e, never_loop_block(els, ignore_ids, main_loop_id), ignore_ids)
+            combine_branches(e, never_loop_block(cx, els, ignore_ids, main_loop_id), ignore_ids)
         })
     })
     .fold(NeverLoopResult::Otherwise, combine_seq)
@@ -122,7 +128,12 @@ fn stmt_to_expr<'tcx>(stmt: &Stmt<'tcx>) -> Option<(&'tcx Expr<'tcx>, Option<&'t
 }
 
 #[allow(clippy::too_many_lines)]
-fn never_loop_expr(expr: &Expr<'_>, ignore_ids: &mut Vec<HirId>, main_loop_id: HirId) -> NeverLoopResult {
+fn never_loop_expr<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &Expr<'tcx>,
+    ignore_ids: &mut Vec<HirId>,
+    main_loop_id: HirId,
+) -> NeverLoopResult {
     match expr.kind {
         ExprKind::Unary(_, e)
         | ExprKind::Cast(e, _)
@@ -130,45 +141,51 @@ fn never_loop_expr(expr: &Expr<'_>, ignore_ids: &mut Vec<HirId>, main_loop_id: H
         | ExprKind::Field(e, _)
         | ExprKind::AddrOf(_, _, e)
         | ExprKind::Repeat(e, _)
-        | ExprKind::DropTemps(e) => never_loop_expr(e, ignore_ids, main_loop_id),
-        ExprKind::Let(let_expr) => never_loop_expr(let_expr.init, ignore_ids, main_loop_id),
-        ExprKind::Array(es) | ExprKind::Tup(es) => never_loop_expr_all(&mut es.iter(), ignore_ids, main_loop_id),
+        | ExprKind::DropTemps(e) => never_loop_expr(cx, e, ignore_ids, main_loop_id),
+        ExprKind::Let(let_expr) => never_loop_expr(cx, let_expr.init, ignore_ids, main_loop_id),
+        ExprKind::Array(es) | ExprKind::Tup(es) => never_loop_expr_all(cx, &mut es.iter(), ignore_ids, main_loop_id),
         ExprKind::MethodCall(_, receiver, es, _) => never_loop_expr_all(
+            cx,
             &mut std::iter::once(receiver).chain(es.iter()),
             ignore_ids,
             main_loop_id,
         ),
         ExprKind::Struct(_, fields, base) => {
-            let fields = never_loop_expr_all(&mut fields.iter().map(|f| f.expr), ignore_ids, main_loop_id);
+            let fields = never_loop_expr_all(cx, &mut fields.iter().map(|f| f.expr), ignore_ids, main_loop_id);
             if let Some(base) = base {
-                combine_seq(fields, never_loop_expr(base, ignore_ids, main_loop_id))
+                combine_seq(fields, never_loop_expr(cx, base, ignore_ids, main_loop_id))
             } else {
                 fields
             }
         },
-        ExprKind::Call(e, es) => never_loop_expr_all(&mut once(e).chain(es.iter()), ignore_ids, main_loop_id),
+        ExprKind::Call(e, es) => never_loop_expr_all(cx, &mut once(e).chain(es.iter()), ignore_ids, main_loop_id),
         ExprKind::Binary(_, e1, e2)
         | ExprKind::Assign(e1, e2, _)
         | ExprKind::AssignOp(_, e1, e2)
-        | ExprKind::Index(e1, e2) => never_loop_expr_all(&mut [e1, e2].iter().copied(), ignore_ids, main_loop_id),
+        | ExprKind::Index(e1, e2) => never_loop_expr_all(cx, &mut [e1, e2].iter().copied(), ignore_ids, main_loop_id),
         ExprKind::Loop(b, _, _, _) => {
             // Break can come from the inner loop so remove them.
-            absorb_break(never_loop_block(b, ignore_ids, main_loop_id))
+            absorb_break(never_loop_block(cx, b, ignore_ids, main_loop_id))
         },
         ExprKind::If(e, e2, e3) => {
-            let e1 = never_loop_expr(e, ignore_ids, main_loop_id);
-            let e2 = never_loop_expr(e2, ignore_ids, main_loop_id);
+            let e1 = never_loop_expr(cx, e, ignore_ids, main_loop_id);
+            let e2 = never_loop_expr(cx, e2, ignore_ids, main_loop_id);
+            // If we know the `if` condition evaluates to `true`, don't check everything past it; it
+            // should just return whatever's evaluated for `e1` and `e2` since `e3` is unreachable
+            if let Some(Constant::Bool(true)) = constant(cx, cx.typeck_results(), e) {
+                return combine_seq(e1, e2);
+            }
             let e3 = e3.as_ref().map_or(NeverLoopResult::Otherwise, |e| {
-                never_loop_expr(e, ignore_ids, main_loop_id)
+                never_loop_expr(cx, e, ignore_ids, main_loop_id)
             });
             combine_seq(e1, combine_branches(e2, e3, ignore_ids))
         },
         ExprKind::Match(e, arms, _) => {
-            let e = never_loop_expr(e, ignore_ids, main_loop_id);
+            let e = never_loop_expr(cx, e, ignore_ids, main_loop_id);
             if arms.is_empty() {
                 e
             } else {
-                let arms = never_loop_expr_branch(&mut arms.iter().map(|a| a.body), ignore_ids, main_loop_id);
+                let arms = never_loop_expr_branch(cx, &mut arms.iter().map(|a| a.body), ignore_ids, main_loop_id);
                 combine_seq(e, arms)
             }
         },
@@ -176,7 +193,7 @@ fn never_loop_expr(expr: &Expr<'_>, ignore_ids: &mut Vec<HirId>, main_loop_id: H
             if l.is_some() {
                 ignore_ids.push(b.hir_id);
             }
-            let ret = never_loop_block(b, ignore_ids, main_loop_id);
+            let ret = never_loop_block(cx, b, ignore_ids, main_loop_id);
             if l.is_some() {
                 ignore_ids.pop();
             }
@@ -198,11 +215,11 @@ fn never_loop_expr(expr: &Expr<'_>, ignore_ids: &mut Vec<HirId>, main_loop_id: H
         // checks if break targets a block instead of a loop
         ExprKind::Break(Destination { target_id: Ok(t), .. }, e) if ignore_ids.contains(&t) => e
             .map_or(NeverLoopResult::IgnoreUntilEnd(t), |e| {
-                never_loop_expr(e, ignore_ids, main_loop_id)
+                never_loop_expr(cx, e, ignore_ids, main_loop_id)
             }),
         ExprKind::Break(_, e) | ExprKind::Ret(e) => e.as_ref().map_or(NeverLoopResult::AlwaysBreak, |e| {
             combine_seq(
-                never_loop_expr(e, ignore_ids, main_loop_id),
+                never_loop_expr(cx, e, ignore_ids, main_loop_id),
                 NeverLoopResult::AlwaysBreak,
             )
         }),
@@ -211,12 +228,13 @@ fn never_loop_expr(expr: &Expr<'_>, ignore_ids: &mut Vec<HirId>, main_loop_id: H
             .iter()
             .map(|(o, _)| match o {
                 InlineAsmOperand::In { expr, .. } | InlineAsmOperand::InOut { expr, .. } => {
-                    never_loop_expr(expr, ignore_ids, main_loop_id)
+                    never_loop_expr(cx, expr, ignore_ids, main_loop_id)
                 },
                 InlineAsmOperand::Out { expr, .. } => {
-                    never_loop_expr_all(&mut expr.iter().copied(), ignore_ids, main_loop_id)
+                    never_loop_expr_all(cx, &mut expr.iter().copied(), ignore_ids, main_loop_id)
                 },
                 InlineAsmOperand::SplitInOut { in_expr, out_expr, .. } => never_loop_expr_all(
+                    cx,
                     &mut once(*in_expr).chain(out_expr.iter().copied()),
                     ignore_ids,
                     main_loop_id,
@@ -236,22 +254,24 @@ fn never_loop_expr(expr: &Expr<'_>, ignore_ids: &mut Vec<HirId>, main_loop_id: H
     }
 }
 
-fn never_loop_expr_all<'a, T: Iterator<Item = &'a Expr<'a>>>(
+fn never_loop_expr_all<'tcx, T: Iterator<Item = &'tcx Expr<'tcx>>>(
+    cx: &LateContext<'tcx>,
     es: &mut T,
     ignore_ids: &mut Vec<HirId>,
     main_loop_id: HirId,
 ) -> NeverLoopResult {
-    es.map(|e| never_loop_expr(e, ignore_ids, main_loop_id))
+    es.map(|e| never_loop_expr(cx, e, ignore_ids, main_loop_id))
         .fold(NeverLoopResult::Otherwise, combine_seq)
 }
 
-fn never_loop_expr_branch<'a, T: Iterator<Item = &'a Expr<'a>>>(
+fn never_loop_expr_branch<'tcx, T: Iterator<Item = &'tcx Expr<'tcx>>>(
+    cx: &LateContext<'tcx>,
     e: &mut T,
     ignore_ids: &mut Vec<HirId>,
     main_loop_id: HirId,
 ) -> NeverLoopResult {
     e.fold(NeverLoopResult::AlwaysBreak, |a, b| {
-        combine_branches(a, never_loop_expr(b, ignore_ids, main_loop_id), ignore_ids)
+        combine_branches(a, never_loop_expr(cx, b, ignore_ids, main_loop_id), ignore_ids)
     })
 }
 
diff --git a/clippy_utils/src/consts.rs b/clippy_utils/src/consts.rs
index 72582ba7e78..03dc9ca56ff 100644
--- a/clippy_utils/src/consts.rs
+++ b/clippy_utils/src/consts.rs
@@ -6,7 +6,7 @@ use if_chain::if_chain;
 use rustc_ast::ast::{self, LitFloatType, LitKind};
 use rustc_data_structures::sync::Lrc;
 use rustc_hir::def::{DefKind, Res};
-use rustc_hir::{BinOp, BinOpKind, Block, Expr, ExprKind, HirId, Item, ItemKind, Node, QPath, UnOp};
+use rustc_hir::{AnonConst, BinOp, BinOpKind, Block, Expr, ExprKind, HirId, Item, ItemKind, Node, QPath, UnOp};
 use rustc_lexer::tokenize;
 use rustc_lint::LateContext;
 use rustc_middle::mir;
@@ -344,6 +344,8 @@ impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
     /// Simple constant folding: Insert an expression, get a constant or none.
     pub fn expr(&mut self, e: &Expr<'_>) -> Option<Constant<'tcx>> {
         match e.kind {
+            ExprKind::ConstBlock(AnonConst { body, .. }) => self.expr(self.lcx.tcx.hir().body(body).value),
+            ExprKind::DropTemps(e) => self.expr(e),
             ExprKind::Path(ref qpath) => self.fetch_path(qpath, e.hir_id, self.typeck_results.expr_ty(e)),
             ExprKind::Block(block, _) => self.block(block),
             ExprKind::Lit(lit) => {
diff --git a/tests/ui/large_futures.rs b/tests/ui/large_futures.rs
index 4a8ba995da5..e0f6b3d9d3b 100644
--- a/tests/ui/large_futures.rs
+++ b/tests/ui/large_futures.rs
@@ -1,5 +1,6 @@
 #![feature(generators)]
 #![warn(clippy::large_futures)]
+#![allow(clippy::never_loop)]
 #![allow(clippy::future_not_send)]
 #![allow(clippy::manual_async_fn)]
 
diff --git a/tests/ui/large_futures.stderr b/tests/ui/large_futures.stderr
index 67e0fceff6e..5bcf054884e 100644
--- a/tests/ui/large_futures.stderr
+++ b/tests/ui/large_futures.stderr
@@ -1,5 +1,5 @@
 error: large future with a size of 16385 bytes
-  --> $DIR/large_futures.rs:10:9
+  --> $DIR/large_futures.rs:11:9
    |
 LL |         big_fut([0u8; 1024 * 16]).await;
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider `Box::pin` on it: `Box::pin(big_fut([0u8; 1024 * 16]))`
@@ -7,37 +7,37 @@ LL |         big_fut([0u8; 1024 * 16]).await;
    = note: `-D clippy::large-futures` implied by `-D warnings`
 
 error: large future with a size of 16386 bytes
-  --> $DIR/large_futures.rs:12:5
+  --> $DIR/large_futures.rs:13:5
    |
 LL |     f.await
    |     ^ help: consider `Box::pin` on it: `Box::pin(f)`
 
 error: large future with a size of 16387 bytes
-  --> $DIR/large_futures.rs:16:9
+  --> $DIR/large_futures.rs:17:9
    |
 LL |         wait().await;
    |         ^^^^^^ help: consider `Box::pin` on it: `Box::pin(wait())`
 
 error: large future with a size of 16387 bytes
-  --> $DIR/large_futures.rs:20:13
+  --> $DIR/large_futures.rs:21:13
    |
 LL |             wait().await;
    |             ^^^^^^ help: consider `Box::pin` on it: `Box::pin(wait())`
 
 error: large future with a size of 65540 bytes
-  --> $DIR/large_futures.rs:27:5
+  --> $DIR/large_futures.rs:28:5
    |
 LL |     foo().await;
    |     ^^^^^ help: consider `Box::pin` on it: `Box::pin(foo())`
 
 error: large future with a size of 49159 bytes
-  --> $DIR/large_futures.rs:28:5
+  --> $DIR/large_futures.rs:29:5
    |
 LL |     calls_fut(fut).await;
    |     ^^^^^^^^^^^^^^ help: consider `Box::pin` on it: `Box::pin(calls_fut(fut))`
 
 error: large future with a size of 65540 bytes
-  --> $DIR/large_futures.rs:40:5
+  --> $DIR/large_futures.rs:41:5
    |
 LL | /     async {
 LL | |         let x = [0i32; 1024 * 16];
@@ -56,7 +56,7 @@ LL +     })
    |
 
 error: large future with a size of 65540 bytes
-  --> $DIR/large_futures.rs:51:13
+  --> $DIR/large_futures.rs:52:13
    |
 LL | /             async {
 LL | |                 let x = [0i32; 1024 * 16];
diff --git a/tests/ui/never_loop.rs b/tests/ui/never_loop.rs
index 29821ff96fc..eb179f30e75 100644
--- a/tests/ui/never_loop.rs
+++ b/tests/ui/never_loop.rs
@@ -1,4 +1,6 @@
+#![feature(inline_const)]
 #![allow(
+    clippy::eq_op,
     clippy::single_match,
     unused_assignments,
     unused_variables,
@@ -295,6 +297,42 @@ pub fn test24() {
     }
 }
 
+// Do not lint, we can evaluate `true` to always succeed thus can short-circuit before the `return`
+pub fn test25() {
+    loop {
+        'label: {
+            if const { true } {
+                break 'label;
+            }
+            return;
+        }
+    }
+}
+
+pub fn test26() {
+    loop {
+        'label: {
+            if 1 == 1 {
+                break 'label;
+            }
+            return;
+        }
+    }
+}
+
+pub fn test27() {
+    loop {
+        'label: {
+            let x = true;
+            // Lints because we cannot prove it's always `true`
+            if x {
+                break 'label;
+            }
+            return;
+        }
+    }
+}
+
 fn main() {
     test1();
     test2();
diff --git a/tests/ui/never_loop.stderr b/tests/ui/never_loop.stderr
index b2eafb345e3..0446c09cd5b 100644
--- a/tests/ui/never_loop.stderr
+++ b/tests/ui/never_loop.stderr
@@ -1,5 +1,5 @@
 error: this loop never actually loops
-  --> $DIR/never_loop.rs:10:5
+  --> $DIR/never_loop.rs:12:5
    |
 LL | /     loop {
 LL | |         // clippy::never_loop
@@ -13,7 +13,7 @@ LL | |     }
    = note: `#[deny(clippy::never_loop)]` on by default
 
 error: this loop never actually loops
-  --> $DIR/never_loop.rs:32:5
+  --> $DIR/never_loop.rs:34:5
    |
 LL | /     loop {
 LL | |         // never loops
@@ -23,7 +23,7 @@ LL | |     }
    | |_____^
 
 error: this loop never actually loops
-  --> $DIR/never_loop.rs:52:5
+  --> $DIR/never_loop.rs:54:5
    |
 LL | /     loop {
 LL | |         // never loops
@@ -35,7 +35,7 @@ LL | |     }
    | |_____^
 
 error: this loop never actually loops
-  --> $DIR/never_loop.rs:54:9
+  --> $DIR/never_loop.rs:56:9
    |
 LL | /         while i == 0 {
 LL | |             // never loops
@@ -44,7 +44,7 @@ LL | |         }
    | |_________^
 
 error: this loop never actually loops
-  --> $DIR/never_loop.rs:66:9
+  --> $DIR/never_loop.rs:68:9
    |
 LL | /         loop {
 LL | |             // never loops
@@ -56,7 +56,7 @@ LL | |         }
    | |_________^
 
 error: this loop never actually loops
-  --> $DIR/never_loop.rs:102:5
+  --> $DIR/never_loop.rs:104:5
    |
 LL | /     while let Some(y) = x {
 LL | |         // never loops
@@ -65,7 +65,7 @@ LL | |     }
    | |_____^
 
 error: this loop never actually loops
-  --> $DIR/never_loop.rs:109:5
+  --> $DIR/never_loop.rs:111:5
    |
 LL | /     for x in 0..10 {
 LL | |         // never loops
@@ -82,7 +82,7 @@ LL |     if let Some(x) = (0..10).next() {
    |     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 error: this loop never actually loops
-  --> $DIR/never_loop.rs:157:5
+  --> $DIR/never_loop.rs:159:5
    |
 LL | /     'outer: while a {
 LL | |         // never loops
@@ -94,7 +94,7 @@ LL | |     }
    | |_____^
 
 error: this loop never actually loops
-  --> $DIR/never_loop.rs:172:9
+  --> $DIR/never_loop.rs:174:9
    |
 LL | /         while false {
 LL | |             break 'label;
@@ -102,7 +102,7 @@ LL | |         }
    | |_________^
 
 error: this loop never actually loops
-  --> $DIR/never_loop.rs:223:13
+  --> $DIR/never_loop.rs:225:13
    |
 LL |       let _ = loop {
    |  _____________^
@@ -115,7 +115,7 @@ LL | |     };
    | |_____^
 
 error: this loop never actually loops
-  --> $DIR/never_loop.rs:244:5
+  --> $DIR/never_loop.rs:246:5
    |
 LL | /     'a: loop {
 LL | |         'b: {
@@ -127,7 +127,7 @@ LL | |     }
    | |_____^
 
 error: sub-expression diverges
-  --> $DIR/never_loop.rs:247:17
+  --> $DIR/never_loop.rs:249:17
    |
 LL |                 break 'a;
    |                 ^^^^^^^^
@@ -135,7 +135,7 @@ LL |                 break 'a;
    = note: `-D clippy::diverging-sub-expression` implied by `-D warnings`
 
 error: this loop never actually loops
-  --> $DIR/never_loop.rs:278:13
+  --> $DIR/never_loop.rs:280:13
    |
 LL | /             for _ in 0..20 {
 LL | |                 break 'block;
@@ -147,5 +147,17 @@ help: if you need the first element of the iterator, try writing
 LL |             if let Some(_) = (0..20).next() {
    |             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-error: aborting due to 13 previous errors
+error: this loop never actually loops
+  --> $DIR/never_loop.rs:324:5
+   |
+LL | /     loop {
+LL | |         'label: {
+LL | |             let x = true;
+LL | |             // Lints because we cannot prove it's always `true`
+...  |
+LL | |         }
+LL | |     }
+   | |_____^
+
+error: aborting due to 14 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 33b6d0d206f4519d0a196c1ae490e8e13c8fbcc6 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Thu, 22 Jun 2023 17:19:43 +0200
Subject: rename MSRV alias, add MSRV to lint doc

---
 clippy_lints/src/trait_bounds.rs | 2 +-
 clippy_lints/src/utils/conf.rs   | 2 +-
 clippy_utils/src/msrvs.rs        | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/trait_bounds.rs b/clippy_lints/src/trait_bounds.rs
index 78e27b775fb..6db330dfa61 100644
--- a/clippy_lints/src/trait_bounds.rs
+++ b/clippy_lints/src/trait_bounds.rs
@@ -232,7 +232,7 @@ impl TraitBounds {
     /// Is the given bound a `?Sized` bound, and is combining it (i.e. `T: X + ?Sized`) an error on
     /// this MSRV? See <https://github.com/rust-lang/rust-clippy/issues/8772> for details.
     fn cannot_combine_maybe_bound(&self, cx: &LateContext<'_>, bound: &GenericBound<'_>) -> bool {
-        if !self.msrv.meets(msrvs::COMBINED_MAYBE_BOUND)
+        if !self.msrv.meets(msrvs::MAYBE_BOUND_IN_WHERE)
             && let GenericBound::Trait(tr, TraitBoundModifier::Maybe) = bound
         {
             cx.tcx.lang_items().get(LangItem::Sized) == tr.trait_ref.path.res.opt_def_id()
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 3cf2fbf1f28..54ee960c472 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -293,7 +293,7 @@ define_Conf! {
     ///
     /// Suppress lints whenever the suggested change would cause breakage for other crates.
     (avoid_breaking_exported_api: bool = true),
-    /// Lint: MANUAL_SPLIT_ONCE, MANUAL_STR_REPEAT, CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR, IF_THEN_SOME_ELSE_NONE, APPROX_CONSTANT, DEPRECATED_CFG_ATTR, INDEX_REFUTABLE_SLICE, MAP_CLONE, BORROW_AS_PTR, MANUAL_BITS, ERR_EXPECT, CAST_ABS_TO_UNSIGNED, UNINLINED_FORMAT_ARGS, MANUAL_CLAMP, MANUAL_LET_ELSE, UNCHECKED_DURATION_SUBTRACTION, COLLAPSIBLE_STR_REPLACE, SEEK_FROM_CURRENT, SEEK_REWIND, UNNECESSARY_LAZY_EVALUATIONS, TRANSMUTE_PTR_TO_REF, ALMOST_COMPLETE_RANGE, NEEDLESS_BORROW, DERIVABLE_IMPLS, MANUAL_IS_ASCII_CHECK, MANUAL_REM_EUCLID, MANUAL_RETAIN.
+    /// Lint: MANUAL_SPLIT_ONCE, MANUAL_STR_REPEAT, CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR, IF_THEN_SOME_ELSE_NONE, APPROX_CONSTANT, DEPRECATED_CFG_ATTR, INDEX_REFUTABLE_SLICE, MAP_CLONE, BORROW_AS_PTR, MANUAL_BITS, ERR_EXPECT, CAST_ABS_TO_UNSIGNED, UNINLINED_FORMAT_ARGS, MANUAL_CLAMP, MANUAL_LET_ELSE, UNCHECKED_DURATION_SUBTRACTION, COLLAPSIBLE_STR_REPLACE, SEEK_FROM_CURRENT, SEEK_REWIND, UNNECESSARY_LAZY_EVALUATIONS, TRANSMUTE_PTR_TO_REF, ALMOST_COMPLETE_RANGE, NEEDLESS_BORROW, DERIVABLE_IMPLS, MANUAL_IS_ASCII_CHECK, MANUAL_REM_EUCLID, MANUAL_RETAIN, TYPE_REPETITION_IN_BOUNDS.
     ///
     /// The minimum rust version that the project supports
     (msrv: Option<String> = None),
diff --git a/clippy_utils/src/msrvs.rs b/clippy_utils/src/msrvs.rs
index b1f336461d1..0a4c3418a08 100644
--- a/clippy_utils/src/msrvs.rs
+++ b/clippy_utils/src/msrvs.rs
@@ -47,7 +47,7 @@ msrv_aliases! {
     1,18,0 { HASH_MAP_RETAIN, HASH_SET_RETAIN }
     1,17,0 { FIELD_INIT_SHORTHAND, STATIC_IN_CONST, EXPECT_ERR }
     1,16,0 { STR_REPEAT }
-    1,15,0 { COMBINED_MAYBE_BOUND }
+    1,15,0 { MAYBE_BOUND_IN_WHERE }
 }
 
 fn parse_msrv(msrv: &str, sess: Option<&Session>, span: Option<Span>) -> Option<RustcVersion> {
-- 
cgit 1.4.1-3-g733a5


From db4efe3f6dbe6286b579e3cd6c71d9347ec2f1a5 Mon Sep 17 00:00:00 2001
From: Catherine <114838443+Centri3@users.noreply.github.com>
Date: Sat, 24 Jun 2023 03:03:05 -0500
Subject: Don't lint `ptr_arg` when return type uses Cow's lifetime

---
 clippy_lints/src/ptr.rs | 105 ++++++++++++++++++++++++++++++++----------------
 tests/ui/ptr_arg.rs     |  33 ++++++++++++++-
 tests/ui/ptr_arg.stderr |  60 +++++++++++++++++----------
 3 files changed, 141 insertions(+), 57 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs
index fc550936165..e8854394150 100644
--- a/clippy_lints/src/ptr.rs
+++ b/clippy_lints/src/ptr.rs
@@ -5,6 +5,7 @@ use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::expr_sig;
 use clippy_utils::visitors::contains_unsafe_block;
 use clippy_utils::{get_expr_use_or_unification_node, is_lint_allowed, path_def_id, path_to_local, paths};
+use hir::LifetimeName;
 use if_chain::if_chain;
 use rustc_errors::{Applicability, MultiSpan};
 use rustc_hir::def_id::DefId;
@@ -15,6 +16,7 @@ use rustc_hir::{
     ImplItemKind, ItemKind, Lifetime, Mutability, Node, Param, PatKind, QPath, TraitFn, TraitItem, TraitItemKind,
     TyKind, Unsafety,
 };
+use rustc_hir_analysis::hir_ty_to_ty;
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_infer::traits::{Obligation, ObligationCause};
 use rustc_lint::{LateContext, LateLintPass};
@@ -166,6 +168,7 @@ impl<'tcx> LateLintPass<'tcx> for Ptr {
                 cx,
                 cx.tcx.fn_sig(item.owner_id).subst_identity().skip_binder().inputs(),
                 sig.decl.inputs,
+                &sig.decl.output,
                 &[],
             )
             .filter(|arg| arg.mutability() == Mutability::Not)
@@ -218,7 +221,7 @@ impl<'tcx> LateLintPass<'tcx> for Ptr {
         check_mut_from_ref(cx, sig, Some(body));
         let decl = sig.decl;
         let sig = cx.tcx.fn_sig(item_id).subst_identity().skip_binder();
-        let lint_args: Vec<_> = check_fn_args(cx, sig.inputs(), decl.inputs, body.params)
+        let lint_args: Vec<_> = check_fn_args(cx, sig.inputs(), decl.inputs, &decl.output, body.params)
             .filter(|arg| !is_trait_item || arg.mutability() == Mutability::Not)
             .collect();
         let results = check_ptr_arg_usage(cx, body, &lint_args);
@@ -407,29 +410,27 @@ impl<'tcx> DerefTy<'tcx> {
     }
 }
 
+#[expect(clippy::too_many_lines)]
 fn check_fn_args<'cx, 'tcx: 'cx>(
     cx: &'cx LateContext<'tcx>,
     tys: &'tcx [Ty<'tcx>],
     hir_tys: &'tcx [hir::Ty<'tcx>],
+    ret_ty: &'tcx FnRetTy<'tcx>,
     params: &'tcx [Param<'tcx>],
 ) -> impl Iterator<Item = PtrArg<'tcx>> + 'cx {
     tys.iter()
         .zip(hir_tys.iter())
         .enumerate()
-        .filter_map(|(i, (ty, hir_ty))| {
-            if_chain! {
-                if let ty::Ref(_, ty, mutability) = *ty.kind();
-                if let ty::Adt(adt, substs) = *ty.kind();
-
-                if let TyKind::Ref(lt, ref ty) = hir_ty.kind;
-                if let TyKind::Path(QPath::Resolved(None, path)) = ty.ty.kind;
-
+        .filter_map(move |(i, (ty, hir_ty))| {
+            if let ty::Ref(_, ty, mutability) = *ty.kind()
+                && let  ty::Adt(adt, substs) = *ty.kind()
+                && let TyKind::Ref(lt, ref ty) = hir_ty.kind
+                && let TyKind::Path(QPath::Resolved(None, path)) = ty.ty.kind
                 // Check that the name as typed matches the actual name of the type.
                 // e.g. `fn foo(_: &Foo)` shouldn't trigger the lint when `Foo` is an alias for `Vec`
-                if let [.., name] = path.segments;
-                if cx.tcx.item_name(adt.did()) == name.ident.name;
-
-                then {
+                && let [.., name] = path.segments
+                && cx.tcx.item_name(adt.did()) == name.ident.name
+            {
                     let emission_id = params.get(i).map_or(hir_ty.hir_id, |param| param.hir_id);
                     let (method_renames, deref_ty) = match cx.tcx.get_diagnostic_name(adt.did()) {
                         Some(sym::Vec) => (
@@ -454,30 +455,65 @@ fn check_fn_args<'cx, 'tcx: 'cx>(
                             DerefTy::Path,
                         ),
                         Some(sym::Cow) if mutability == Mutability::Not => {
-                            let ty_name = name.args
+                            if let Some((lifetime, ty)) = name.args
                                 .and_then(|args| {
-                                    args.args.iter().find_map(|a| match a {
-                                        GenericArg::Type(x) => Some(x),
-                                        _ => None,
-                                    })
+                                    if let [GenericArg::Lifetime(lifetime), ty] = args.args {
+                                        return Some((lifetime, ty));
+                                    }
+                                    None
                                 })
-                                .and_then(|arg| snippet_opt(cx, arg.span))
-                                .unwrap_or_else(|| substs.type_at(1).to_string());
-                            span_lint_hir_and_then(
-                                cx,
-                                PTR_ARG,
-                                emission_id,
-                                hir_ty.span,
-                                "using a reference to `Cow` is not recommended",
-                                |diag| {
-                                    diag.span_suggestion(
-                                        hir_ty.span,
-                                        "change this to",
-                                        format!("&{}{ty_name}", mutability.prefix_str()),
-                                        Applicability::Unspecified,
-                                    );
+                            {
+                                if !lifetime.is_anonymous()
+                                    && let FnRetTy::Return(ret_ty) = ret_ty
+                                    && let ret_ty = hir_ty_to_ty(cx.tcx, ret_ty)
+                                    && ret_ty
+                                        .walk()
+                                        .filter_map(|arg| {
+                                            arg.as_region().and_then(|lifetime| {
+                                                match lifetime.kind() {
+                                                    ty::ReEarlyBound(r) => Some(r.def_id),
+                                                    ty::ReLateBound(_, r) => r.kind.get_id(),
+                                                    ty::ReFree(r) => r.bound_region.get_id(),
+                                                    ty::ReStatic
+                                                    | ty::ReVar(_)
+                                                    | ty::RePlaceholder(_)
+                                                    | ty::ReErased
+                                                    | ty::ReError(_) => None,
+                                                }
+                                            })
+                                        })
+                                        .any(|def_id| {
+                                            matches!(
+                                                lifetime.res,
+                                                LifetimeName::Param(param_def_id) if def_id
+                                                    .as_local()
+                                                    .is_some_and(|def_id| def_id == param_def_id),
+                                            )
+                                        })
+                                {
+                                    // `&Cow<'a, T>` when the return type uses 'a is okay
+                                    return None;
                                 }
-                            );
+
+                                let ty_name =
+                                    snippet_opt(cx, ty.span()).unwrap_or_else(|| substs.type_at(1).to_string());
+
+                                span_lint_hir_and_then(
+                                    cx,
+                                    PTR_ARG,
+                                    emission_id,
+                                    hir_ty.span,
+                                    "using a reference to `Cow` is not recommended",
+                                    |diag| {
+                                        diag.span_suggestion(
+                                            hir_ty.span,
+                                            "change this to",
+                                            format!("&{}{ty_name}", mutability.prefix_str()),
+                                            Applicability::Unspecified,
+                                        );
+                                    }
+                                );
+                            }
                             return None;
                         },
                         _ => return None,
@@ -495,7 +531,6 @@ fn check_fn_args<'cx, 'tcx: 'cx>(
                         },
                         deref_ty,
                     });
-                }
             }
             None
         })
diff --git a/tests/ui/ptr_arg.rs b/tests/ui/ptr_arg.rs
index 5f54101ca15..709f74ee6aa 100644
--- a/tests/ui/ptr_arg.rs
+++ b/tests/ui/ptr_arg.rs
@@ -1,5 +1,10 @@
 #![feature(lint_reasons)]
-#![allow(unused, clippy::many_single_char_names, clippy::redundant_clone)]
+#![allow(
+    unused,
+    clippy::many_single_char_names,
+    clippy::needless_lifetimes,
+    clippy::redundant_clone
+)]
 #![warn(clippy::ptr_arg)]
 
 use std::borrow::Cow;
@@ -235,3 +240,29 @@ fn dyn_trait(a: &mut Vec<u32>, b: &mut String, c: &mut PathBuf) {
     takes_dyn(b);
     takes_dyn(c);
 }
+
+mod issue_9218 {
+    use std::borrow::Cow;
+
+    fn cow_non_elided_lifetime<'a>(input: &Cow<'a, str>) -> &'a str {
+        todo!()
+    }
+
+    // This one has an anonymous lifetime so it's not okay
+    fn cow_elided_lifetime<'a>(input: &'a Cow<str>) -> &'a str {
+        todo!()
+    }
+
+    // These two's return types don't use use 'a so it's not okay
+    fn cow_bad_ret_ty_1<'a>(input: &'a Cow<'a, str>) -> &'static str {
+        todo!()
+    }
+    fn cow_bad_ret_ty_2<'a, 'b>(input: &'a Cow<'a, str>) -> &'b str {
+        todo!()
+    }
+
+    // Inferred to be `&'a str`, afaik.
+    fn cow_good_ret_ty<'a>(input: &'a Cow<'a, str>) -> &str {
+        todo!()
+    }
+}
diff --git a/tests/ui/ptr_arg.stderr b/tests/ui/ptr_arg.stderr
index 6b4de98ce88..d663b070b9c 100644
--- a/tests/ui/ptr_arg.stderr
+++ b/tests/ui/ptr_arg.stderr
@@ -1,5 +1,5 @@
 error: writing `&Vec` instead of `&[_]` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:8:14
+  --> $DIR/ptr_arg.rs:13:14
    |
 LL | fn do_vec(x: &Vec<i64>) {
    |              ^^^^^^^^^ help: change this to: `&[i64]`
@@ -7,43 +7,43 @@ LL | fn do_vec(x: &Vec<i64>) {
    = note: `-D clippy::ptr-arg` implied by `-D warnings`
 
 error: writing `&mut Vec` instead of `&mut [_]` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:12:18
+  --> $DIR/ptr_arg.rs:17:18
    |
 LL | fn do_vec_mut(x: &mut Vec<i64>) {
    |                  ^^^^^^^^^^^^^ help: change this to: `&mut [i64]`
 
 error: writing `&String` instead of `&str` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:16:14
+  --> $DIR/ptr_arg.rs:21:14
    |
 LL | fn do_str(x: &String) {
    |              ^^^^^^^ help: change this to: `&str`
 
 error: writing `&mut String` instead of `&mut str` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:20:18
+  --> $DIR/ptr_arg.rs:25:18
    |
 LL | fn do_str_mut(x: &mut String) {
    |                  ^^^^^^^^^^^ help: change this to: `&mut str`
 
 error: writing `&PathBuf` instead of `&Path` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:24:15
+  --> $DIR/ptr_arg.rs:29:15
    |
 LL | fn do_path(x: &PathBuf) {
    |               ^^^^^^^^ help: change this to: `&Path`
 
 error: writing `&mut PathBuf` instead of `&mut Path` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:28:19
+  --> $DIR/ptr_arg.rs:33:19
    |
 LL | fn do_path_mut(x: &mut PathBuf) {
    |                   ^^^^^^^^^^^^ help: change this to: `&mut Path`
 
 error: writing `&Vec` instead of `&[_]` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:36:18
+  --> $DIR/ptr_arg.rs:41:18
    |
 LL |     fn do_vec(x: &Vec<i64>);
    |                  ^^^^^^^^^ help: change this to: `&[i64]`
 
 error: writing `&Vec` instead of `&[_]` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:49:14
+  --> $DIR/ptr_arg.rs:54:14
    |
 LL | fn cloned(x: &Vec<u8>) -> Vec<u8> {
    |              ^^^^^^^^
@@ -60,7 +60,7 @@ LL ~     x.to_owned()
    |
 
 error: writing `&String` instead of `&str` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:58:18
+  --> $DIR/ptr_arg.rs:63:18
    |
 LL | fn str_cloned(x: &String) -> String {
    |                  ^^^^^^^
@@ -76,7 +76,7 @@ LL ~     x.to_owned()
    |
 
 error: writing `&PathBuf` instead of `&Path` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:66:19
+  --> $DIR/ptr_arg.rs:71:19
    |
 LL | fn path_cloned(x: &PathBuf) -> PathBuf {
    |                   ^^^^^^^^
@@ -92,7 +92,7 @@ LL ~     x.to_path_buf()
    |
 
 error: writing `&String` instead of `&str` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:74:44
+  --> $DIR/ptr_arg.rs:79:44
    |
 LL | fn false_positive_capacity(x: &Vec<u8>, y: &String) {
    |                                            ^^^^^^^
@@ -106,19 +106,19 @@ LL ~     let c = y;
    |
 
 error: using a reference to `Cow` is not recommended
-  --> $DIR/ptr_arg.rs:88:25
+  --> $DIR/ptr_arg.rs:93:25
    |
 LL | fn test_cow_with_ref(c: &Cow<[i32]>) {}
    |                         ^^^^^^^^^^^ help: change this to: `&[i32]`
 
 error: writing `&String` instead of `&str` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:117:66
+  --> $DIR/ptr_arg.rs:122:66
    |
 LL |     fn some_allowed(#[allow(clippy::ptr_arg)] _v: &Vec<u32>, _s: &String) {}
    |                                                                  ^^^^^^^ help: change this to: `&str`
 
 error: writing `&Vec` instead of `&[_]` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:146:21
+  --> $DIR/ptr_arg.rs:151:21
    |
 LL |     fn foo_vec(vec: &Vec<u8>) {
    |                     ^^^^^^^^
@@ -131,7 +131,7 @@ LL ~         let _ = vec.to_owned().clone();
    |
 
 error: writing `&PathBuf` instead of `&Path` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:151:23
+  --> $DIR/ptr_arg.rs:156:23
    |
 LL |     fn foo_path(path: &PathBuf) {
    |                       ^^^^^^^^
@@ -144,7 +144,7 @@ LL ~         let _ = path.to_path_buf().clone();
    |
 
 error: writing `&PathBuf` instead of `&Path` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:156:21
+  --> $DIR/ptr_arg.rs:161:21
    |
 LL |     fn foo_str(str: &PathBuf) {
    |                     ^^^^^^^^
@@ -157,28 +157,46 @@ LL ~         let _ = str.to_path_buf().clone();
    |
 
 error: writing `&mut Vec` instead of `&mut [_]` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:162:29
+  --> $DIR/ptr_arg.rs:167:29
    |
 LL | fn mut_vec_slice_methods(v: &mut Vec<u32>) {
    |                             ^^^^^^^^^^^^^ help: change this to: `&mut [u32]`
 
 error: writing `&mut Vec` instead of `&mut [_]` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:224:17
+  --> $DIR/ptr_arg.rs:229:17
    |
 LL | fn dyn_trait(a: &mut Vec<u32>, b: &mut String, c: &mut PathBuf) {
    |                 ^^^^^^^^^^^^^ help: change this to: `&mut [u32]`
 
 error: writing `&mut String` instead of `&mut str` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:224:35
+  --> $DIR/ptr_arg.rs:229:35
    |
 LL | fn dyn_trait(a: &mut Vec<u32>, b: &mut String, c: &mut PathBuf) {
    |                                   ^^^^^^^^^^^ help: change this to: `&mut str`
 
 error: writing `&mut PathBuf` instead of `&mut Path` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:224:51
+  --> $DIR/ptr_arg.rs:229:51
    |
 LL | fn dyn_trait(a: &mut Vec<u32>, b: &mut String, c: &mut PathBuf) {
    |                                                   ^^^^^^^^^^^^ help: change this to: `&mut Path`
 
-error: aborting due to 20 previous errors
+error: using a reference to `Cow` is not recommended
+  --> $DIR/ptr_arg.rs:252:39
+   |
+LL |     fn cow_elided_lifetime<'a>(input: &'a Cow<str>) -> &'a str {
+   |                                       ^^^^^^^^^^^^ help: change this to: `&str`
+
+error: using a reference to `Cow` is not recommended
+  --> $DIR/ptr_arg.rs:257:36
+   |
+LL |     fn cow_bad_ret_ty_1<'a>(input: &'a Cow<'a, str>) -> &'static str {
+   |                                    ^^^^^^^^^^^^^^^^ help: change this to: `&str`
+
+error: using a reference to `Cow` is not recommended
+  --> $DIR/ptr_arg.rs:260:40
+   |
+LL |     fn cow_bad_ret_ty_2<'a, 'b>(input: &'a Cow<'a, str>) -> &'b str {
+   |                                        ^^^^^^^^^^^^^^^^ help: change this to: `&str`
+
+error: aborting due to 23 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From fe856d383f75a9c8341a451033fa03992cfb0b3c Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Sat, 24 Jun 2023 19:54:12 +0200
Subject: [`format_push_string`]: look through match, if, if-let

---
 clippy_lints/src/format_push_string.rs | 23 ++++++++++++++++-----
 tests/ui/format_push_string.rs         | 29 ++++++++++++++++++++++++++
 tests/ui/format_push_string.stderr     | 37 +++++++++++++++++++++++++++++++++-
 3 files changed, 83 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/format_push_string.rs b/clippy_lints/src/format_push_string.rs
index 68c5c3673fe..45f67020c2d 100644
--- a/clippy_lints/src/format_push_string.rs
+++ b/clippy_lints/src/format_push_string.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::ty::is_type_lang_item;
-use clippy_utils::{match_def_path, paths, peel_hir_expr_refs};
-use rustc_hir::{BinOpKind, Expr, ExprKind, LangItem};
+use clippy_utils::{higher, match_def_path, paths};
+use rustc_hir::{BinOpKind, Expr, ExprKind, LangItem, MatchSource};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::sym;
@@ -44,10 +44,24 @@ fn is_string(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
     is_type_lang_item(cx, cx.typeck_results().expr_ty(e).peel_refs(), LangItem::String)
 }
 fn is_format(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
-    if let Some(macro_def_id) = e.span.ctxt().outer_expn_data().macro_def_id {
+    let e = e.peel_blocks().peel_borrows();
+
+    if e.span.from_expansion()
+        && let Some(macro_def_id) = e.span.ctxt().outer_expn_data().macro_def_id
+    {
         cx.tcx.get_diagnostic_name(macro_def_id) == Some(sym::format_macro)
+    } else if let Some(higher::If { then, r#else, .. }) = higher::If::hir(e) {
+        is_format(cx, then) || r#else.is_some_and(|e| is_format(cx, e))
     } else {
-        false
+        match higher::IfLetOrMatch::parse(cx, e) {
+            Some(higher::IfLetOrMatch::Match(_, arms, MatchSource::Normal)) => {
+                arms.iter().any(|arm| is_format(cx, arm.body))
+            },
+            Some(higher::IfLetOrMatch::IfLet(_, _, then, r#else)) => {
+                is_format(cx, then) ||r#else.is_some_and(|e| is_format(cx, e))
+            },
+            _ => false,
+        }
     }
 }
 
@@ -68,7 +82,6 @@ impl<'tcx> LateLintPass<'tcx> for FormatPushString {
             },
             _ => return,
         };
-        let (arg, _) = peel_hir_expr_refs(arg);
         if is_format(cx, arg) {
             span_lint_and_help(
                 cx,
diff --git a/tests/ui/format_push_string.rs b/tests/ui/format_push_string.rs
index 4db13d650eb..89423ffe1cf 100644
--- a/tests/ui/format_push_string.rs
+++ b/tests/ui/format_push_string.rs
@@ -5,3 +5,32 @@ fn main() {
     string += &format!("{:?}", 1234);
     string.push_str(&format!("{:?}", 5678));
 }
+
+mod issue9493 {
+    pub fn u8vec_to_hex(vector: &Vec<u8>, upper: bool) -> String {
+        let mut hex = String::with_capacity(vector.len() * 2);
+        for byte in vector {
+            hex += &(if upper {
+                format!("{byte:02X}")
+            } else {
+                format!("{byte:02x}")
+            });
+        }
+        hex
+    }
+
+    pub fn other_cases() {
+        let mut s = String::new();
+        // if let
+        s += &(if let Some(_a) = Some(1234) {
+            format!("{}", 1234)
+        } else {
+            format!("{}", 1234)
+        });
+        // match
+        s += &(match Some(1234) {
+            Some(_) => format!("{}", 1234),
+            None => format!("{}", 1234),
+        });
+    }
+}
diff --git a/tests/ui/format_push_string.stderr b/tests/ui/format_push_string.stderr
index d7be9a5f206..76762c4a1d1 100644
--- a/tests/ui/format_push_string.stderr
+++ b/tests/ui/format_push_string.stderr
@@ -15,5 +15,40 @@ LL |     string.push_str(&format!("{:?}", 5678));
    |
    = help: consider using `write!` to avoid the extra allocation
 
-error: aborting due to 2 previous errors
+error: `format!(..)` appended to existing `String`
+  --> $DIR/format_push_string.rs:13:13
+   |
+LL | /             hex += &(if upper {
+LL | |                 format!("{byte:02X}")
+LL | |             } else {
+LL | |                 format!("{byte:02x}")
+LL | |             });
+   | |______________^
+   |
+   = help: consider using `write!` to avoid the extra allocation
+
+error: `format!(..)` appended to existing `String`
+  --> $DIR/format_push_string.rs:25:9
+   |
+LL | /         s += &(if let Some(_a) = Some(1234) {
+LL | |             format!("{}", 1234)
+LL | |         } else {
+LL | |             format!("{}", 1234)
+LL | |         });
+   | |__________^
+   |
+   = help: consider using `write!` to avoid the extra allocation
+
+error: `format!(..)` appended to existing `String`
+  --> $DIR/format_push_string.rs:31:9
+   |
+LL | /         s += &(match Some(1234) {
+LL | |             Some(_) => format!("{}", 1234),
+LL | |             None => format!("{}", 1234),
+LL | |         });
+   | |__________^
+   |
+   = help: consider using `write!` to avoid the extra allocation
+
+error: aborting due to 5 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From f0eb40c981fe2de71fe96aa4e91c2164270ba2f9 Mon Sep 17 00:00:00 2001
From: Renato Lochetti <renato.lochetti@gmail.com>
Date: Sat, 24 Jun 2023 19:45:16 -0300
Subject: Avoid linting on procedural macros

---
 clippy_lints/src/extra_unused_type_parameters.rs |  2 ++
 tests/ui/extra_unused_type_parameters.fixed      | 12 ++++++++++++
 tests/ui/extra_unused_type_parameters.rs         | 12 ++++++++++++
 tests/ui/extra_unused_type_parameters.stderr     | 16 ++++++++--------
 4 files changed, 34 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/extra_unused_type_parameters.rs b/clippy_lints/src/extra_unused_type_parameters.rs
index eeb4de8b58f..126bed6789c 100644
--- a/clippy_lints/src/extra_unused_type_parameters.rs
+++ b/clippy_lints/src/extra_unused_type_parameters.rs
@@ -1,4 +1,5 @@
 use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_then};
+use clippy_utils::is_from_proc_macro;
 use clippy_utils::trait_ref_of_method;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_errors::Applicability;
@@ -265,6 +266,7 @@ impl<'tcx> LateLintPass<'tcx> for ExtraUnusedTypeParameters {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
         if let ItemKind::Fn(_, generics, body_id) = item.kind
             && !self.is_empty_exported_or_macro(cx, item.span, item.owner_id.def_id, body_id)
+            && !is_from_proc_macro(cx, item)
         {
             let mut walker = TypeWalker::new(cx, generics);
             walk_item(&mut walker, item);
diff --git a/tests/ui/extra_unused_type_parameters.fixed b/tests/ui/extra_unused_type_parameters.fixed
index adcd1f6d407..03ac9abf498 100644
--- a/tests/ui/extra_unused_type_parameters.fixed
+++ b/tests/ui/extra_unused_type_parameters.fixed
@@ -1,8 +1,12 @@
 //@run-rustfix
+//@aux-build:proc_macros.rs
 
 #![allow(unused, clippy::needless_lifetimes)]
 #![warn(clippy::extra_unused_type_parameters)]
 
+extern crate proc_macros;
+use proc_macros::with_span;
+
 fn unused_ty(x: u8) {
     unimplemented!()
 }
@@ -102,4 +106,12 @@ mod issue10319 {
     }
 }
 
+with_span!(
+    span
+
+    fn should_not_lint<T>(x: u8) {
+        unimplemented!()
+    }
+);
+
 fn main() {}
diff --git a/tests/ui/extra_unused_type_parameters.rs b/tests/ui/extra_unused_type_parameters.rs
index c4c5227ac91..731c89c18dc 100644
--- a/tests/ui/extra_unused_type_parameters.rs
+++ b/tests/ui/extra_unused_type_parameters.rs
@@ -1,8 +1,12 @@
 //@run-rustfix
+//@aux-build:proc_macros.rs
 
 #![allow(unused, clippy::needless_lifetimes)]
 #![warn(clippy::extra_unused_type_parameters)]
 
+extern crate proc_macros;
+use proc_macros::with_span;
+
 fn unused_ty<T>(x: u8) {
     unimplemented!()
 }
@@ -102,4 +106,12 @@ mod issue10319 {
     }
 }
 
+with_span!(
+    span
+
+    fn should_not_lint<T>(x: u8) {
+        unimplemented!()
+    }
+);
+
 fn main() {}
diff --git a/tests/ui/extra_unused_type_parameters.stderr b/tests/ui/extra_unused_type_parameters.stderr
index c042a5a2290..b5277d49861 100644
--- a/tests/ui/extra_unused_type_parameters.stderr
+++ b/tests/ui/extra_unused_type_parameters.stderr
@@ -1,5 +1,5 @@
 error: type parameter `T` goes unused in function definition
-  --> $DIR/extra_unused_type_parameters.rs:6:13
+  --> $DIR/extra_unused_type_parameters.rs:10:13
    |
 LL | fn unused_ty<T>(x: u8) {
    |             ^^^ help: consider removing the parameter
@@ -7,19 +7,19 @@ LL | fn unused_ty<T>(x: u8) {
    = note: `-D clippy::extra-unused-type-parameters` implied by `-D warnings`
 
 error: type parameters go unused in function definition: T, U
-  --> $DIR/extra_unused_type_parameters.rs:10:16
+  --> $DIR/extra_unused_type_parameters.rs:14:16
    |
 LL | fn unused_multi<T, U>(x: u8) {
    |                ^^^^^^ help: consider removing the parameters
 
 error: type parameter `T` goes unused in function definition
-  --> $DIR/extra_unused_type_parameters.rs:14:21
+  --> $DIR/extra_unused_type_parameters.rs:18:21
    |
 LL | fn unused_with_lt<'a, T>(x: &'a u8) {
    |                     ^^^ help: consider removing the parameter
 
 error: type parameters go unused in function definition: T, V
-  --> $DIR/extra_unused_type_parameters.rs:26:19
+  --> $DIR/extra_unused_type_parameters.rs:30:19
    |
 LL | fn unused_bounded<T: Default, U, V: Default>(x: U) {
    |                   ^^^^^^^^^^^^ ^^^^^^^^^^^^
@@ -31,7 +31,7 @@ LL + fn unused_bounded<U>(x: U) {
    |
 
 error: type parameters go unused in function definition: A, D, E
-  --> $DIR/extra_unused_type_parameters.rs:30:16
+  --> $DIR/extra_unused_type_parameters.rs:34:16
    |
 LL | fn some_unused<A, B, C, D: Iterator<Item = (B, C)>, E>(b: B, c: C) {
    |                ^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -43,19 +43,19 @@ LL + fn some_unused<B, C>(b: B, c: C) {
    |
 
 error: type parameter `T` goes unused in function definition
-  --> $DIR/extra_unused_type_parameters.rs:55:22
+  --> $DIR/extra_unused_type_parameters.rs:59:22
    |
 LL |     fn unused_ty_impl<T>(&self) {
    |                      ^^^ help: consider removing the parameter
 
 error: type parameters go unused in function definition: A, B
-  --> $DIR/extra_unused_type_parameters.rs:77:17
+  --> $DIR/extra_unused_type_parameters.rs:81:17
    |
 LL | fn unused_opaque<A, B>(dummy: impl Default) {
    |                 ^^^^^^ help: consider removing the parameters
 
 error: type parameter `U` goes unused in function definition
-  --> $DIR/extra_unused_type_parameters.rs:90:56
+  --> $DIR/extra_unused_type_parameters.rs:94:56
    |
 LL |     fn unused_with_priv_trait_bound<T: private::Private, U>() {
    |                                                        ^^^ help: consider removing the parameter
-- 
cgit 1.4.1-3-g733a5


From a5ae9044fbe53996a6d914de539b0fabd95232b4 Mon Sep 17 00:00:00 2001
From: Catherine <114838443+Centri3@users.noreply.github.com>
Date: Sun, 25 Jun 2023 04:28:40 -0500
Subject: make note less verbose

---
 clippy_lints/src/drop_forget_ref.rs | 28 ++++++++++++++++------------
 tests/ui/mem_forget.stderr          | 24 ++++--------------------
 2 files changed, 20 insertions(+), 32 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/drop_forget_ref.rs b/clippy_lints/src/drop_forget_ref.rs
index 36b231023a7..6f8261ed84e 100644
--- a/clippy_lints/src/drop_forget_ref.rs
+++ b/clippy_lints/src/drop_forget_ref.rs
@@ -120,7 +120,7 @@ impl<'tcx> LateLintPass<'tcx> for DropForgetRef {
             let arg_ty = cx.typeck_results().expr_ty(arg);
             let is_copy = is_copy(cx, arg_ty);
             let drop_is_single_call_in_arm = is_single_call_in_arm(cx, arg, expr);
-            let (lint, msg) = match fn_name {
+            let (lint, msg, note_span) = match fn_name {
                 // early return for uplifted lints: dropping_references, dropping_copy_types, forgetting_references, forgetting_copy_types
                 sym::mem_drop if arg_ty.is_ref() && !drop_is_single_call_in_arm => return,
                 sym::mem_forget if arg_ty.is_ref() => return,
@@ -144,20 +144,24 @@ impl<'tcx> LateLintPass<'tcx> for DropForgetRef {
                         || drop_is_single_call_in_arm
                         ) =>
                 {
-                    (DROP_NON_DROP, DROP_NON_DROP_SUMMARY.into())
+                    (DROP_NON_DROP, DROP_NON_DROP_SUMMARY.into(), Some(arg.span))
                 },
                 sym::mem_forget => {
                     if arg_ty.needs_drop(cx.tcx, cx.param_env) {
-                        (MEM_FORGET, Cow::Owned(format!(
-                            "usage of `mem::forget` on {}",
-                            if arg_ty.ty_adt_def().map_or(false, |def| def.has_dtor(cx.tcx)) {
-                                "`Drop` type"
-                            } else {
-                                "type with `Drop` fields"
-                            }
-                        )))
+                        (
+                            MEM_FORGET,
+                            Cow::Owned(format!(
+                                "usage of `mem::forget` on {}",
+                                if arg_ty.ty_adt_def().map_or(false, |def| def.has_dtor(cx.tcx)) {
+                                    "`Drop` type"
+                                } else {
+                                    "type with `Drop` fields"
+                                }
+                            )),
+                            None,
+                        )
                     } else {
-                        (FORGET_NON_DROP, FORGET_NON_DROP_SUMMARY.into())
+                        (FORGET_NON_DROP, FORGET_NON_DROP_SUMMARY.into(), Some(arg.span))
                     }
                 }
                 _ => return,
@@ -167,7 +171,7 @@ impl<'tcx> LateLintPass<'tcx> for DropForgetRef {
                 lint,
                 expr.span,
                 &msg,
-                Some(arg.span),
+                note_span,
                 &format!("argument has type `{arg_ty}`"),
             );
         }
diff --git a/tests/ui/mem_forget.stderr b/tests/ui/mem_forget.stderr
index 6e3c31804d7..8004b2aa8db 100644
--- a/tests/ui/mem_forget.stderr
+++ b/tests/ui/mem_forget.stderr
@@ -4,11 +4,7 @@ error: usage of `mem::forget` on `Drop` type
 LL |     memstuff::forget(six);
    |     ^^^^^^^^^^^^^^^^^^^^^
    |
-note: argument has type `std::sync::Arc<i32>`
-  --> $DIR/mem_forget.rs:14:22
-   |
-LL |     memstuff::forget(six);
-   |                      ^^^
+   = note: argument has type `std::sync::Arc<i32>`
    = note: `-D clippy::mem-forget` implied by `-D warnings`
 
 error: usage of `mem::forget` on `Drop` type
@@ -17,11 +13,7 @@ error: usage of `mem::forget` on `Drop` type
 LL |     std::mem::forget(seven);
    |     ^^^^^^^^^^^^^^^^^^^^^^^
    |
-note: argument has type `std::rc::Rc<i32>`
-  --> $DIR/mem_forget.rs:17:22
-   |
-LL |     std::mem::forget(seven);
-   |                      ^^^^^
+   = note: argument has type `std::rc::Rc<i32>`
 
 error: usage of `mem::forget` on `Drop` type
   --> $DIR/mem_forget.rs:20:5
@@ -29,11 +21,7 @@ error: usage of `mem::forget` on `Drop` type
 LL |     forgetSomething(eight);
    |     ^^^^^^^^^^^^^^^^^^^^^^
    |
-note: argument has type `std::vec::Vec<i32>`
-  --> $DIR/mem_forget.rs:20:21
-   |
-LL |     forgetSomething(eight);
-   |                     ^^^^^
+   = note: argument has type `std::vec::Vec<i32>`
 
 error: usage of `mem::forget` on type with `Drop` fields
   --> $DIR/mem_forget.rs:23:5
@@ -41,11 +29,7 @@ error: usage of `mem::forget` on type with `Drop` fields
 LL |     std::mem::forget(string);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^
    |
-note: argument has type `std::string::String`
-  --> $DIR/mem_forget.rs:23:22
-   |
-LL |     std::mem::forget(string);
-   |                      ^^^^^^
+   = note: argument has type `std::string::String`
 
 error: aborting due to 4 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 5e17f9f97252d52515b9a6eb75dd6cc8b5ecb70f Mon Sep 17 00:00:00 2001
From: Ben Wiederhake <BenWiederhake.GitHub@gmx.de>
Date: Sun, 25 Jun 2023 12:15:18 +0200
Subject: Skip if_not_else lint for '!= 0'-style checks

---
 clippy_lints/src/if_not_else.rs | 12 +++++++++++-
 tests/ui/if_not_else_bittest.rs | 11 +++++++++++
 2 files changed, 22 insertions(+), 1 deletion(-)
 create mode 100644 tests/ui/if_not_else_bittest.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/if_not_else.rs b/clippy_lints/src/if_not_else.rs
index 3d59b783337..640819890b9 100644
--- a/clippy_lints/src/if_not_else.rs
+++ b/clippy_lints/src/if_not_else.rs
@@ -1,6 +1,7 @@
 //! lint on if branches that could be swapped so no `!` operation is necessary
 //! on the condition
 
+use clippy_utils::consts::{constant_simple, Constant};
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::is_else_clause;
 use rustc_hir::{BinOpKind, Expr, ExprKind, UnOp};
@@ -47,6 +48,13 @@ declare_clippy_lint! {
 
 declare_lint_pass!(IfNotElse => [IF_NOT_ELSE]);
 
+fn is_zero_const(expr: &Expr<'_>, cx: &LateContext<'_>) -> bool {
+    if let Some(value) = constant_simple(cx, cx.typeck_results(), expr) {
+        return Constant::Int(0) == value;
+    }
+    false
+}
+
 impl LateLintPass<'_> for IfNotElse {
     fn check_expr(&mut self, cx: &LateContext<'_>, item: &Expr<'_>) {
         // While loops will be desugared to ExprKind::If. This will cause the lint to fire.
@@ -72,7 +80,9 @@ impl LateLintPass<'_> for IfNotElse {
                             "remove the `!` and swap the blocks of the `if`/`else`",
                         );
                     },
-                    ExprKind::Binary(ref kind, _, _) if kind.node == BinOpKind::Ne => {
+                    ExprKind::Binary(ref kind, _, lhs) if kind.node == BinOpKind::Ne && !is_zero_const(lhs, cx) => {
+                        // Disable firing the lint on `… != 0`, as these are likely to be bit tests.
+                        // For example, `if foo & 0x0F00 != 0 { … } else { … }` already is in the "proper" order.
                         span_lint_and_help(
                             cx,
                             IF_NOT_ELSE,
diff --git a/tests/ui/if_not_else_bittest.rs b/tests/ui/if_not_else_bittest.rs
new file mode 100644
index 00000000000..586ce6ce1bc
--- /dev/null
+++ b/tests/ui/if_not_else_bittest.rs
@@ -0,0 +1,11 @@
+#![deny(clippy::if_not_else)]
+
+fn show_permissions(flags: u32) {
+    if flags & 0x0F00 != 0 {
+        println!("Has the 0x0F00 permission.");
+    } else {
+        println!("The 0x0F00 permission is missing.");
+    }
+}
+
+fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 733a9ea6b906441b755fbcd983c93a466b331070 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Mon, 26 Jun 2023 20:13:06 +0200
Subject: [`option_if_let_else`]: suggest `.as_ref()` if `&Option<_>`

---
 clippy_lints/src/option_if_let_else.rs |  3 +++
 tests/ui/option_if_let_else.fixed      | 18 ++++++++++++++++++
 tests/ui/option_if_let_else.rs         | 24 ++++++++++++++++++++++++
 tests/ui/option_if_let_else.stderr     | 20 +++++++++++++++++++-
 4 files changed, 64 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/option_if_let_else.rs b/clippy_lints/src/option_if_let_else.rs
index aa6d4004268..abdccc47f54 100644
--- a/clippy_lints/src/option_if_let_else.rs
+++ b/clippy_lints/src/option_if_let_else.rs
@@ -140,6 +140,9 @@ fn try_get_option_occurrence<'tcx>(
             let (as_ref, as_mut) = match &expr.kind {
                 ExprKind::AddrOf(_, Mutability::Not, _) => (true, false),
                 ExprKind::AddrOf(_, Mutability::Mut, _) => (false, true),
+                _ if let Some(mutb) = cx.typeck_results().expr_ty(expr).ref_mutability() => {
+                    (mutb == Mutability::Not, mutb == Mutability::Mut)
+                }
                 _ => (bind_annotation == BindingAnnotation::REF, bind_annotation == BindingAnnotation::REF_MUT),
             };
 
diff --git a/tests/ui/option_if_let_else.fixed b/tests/ui/option_if_let_else.fixed
index 2b8ce5477cc..44ab8ebb50a 100644
--- a/tests/ui/option_if_let_else.fixed
+++ b/tests/ui/option_if_let_else.fixed
@@ -198,6 +198,8 @@ fn main() {
     let _ = res.map_or(1, |a| a + 1);
     let _ = res.map_or(1, |a| a + 1);
     let _ = res.map_or(5, |a| a + 1);
+    issue10729::reproduce(&None);
+    issue10729::reproduce2(&mut None);
 }
 
 #[allow(dead_code)]
@@ -208,3 +210,19 @@ fn issue9742() -> Option<&'static str> {
         _ => None,
     }
 }
+
+mod issue10729 {
+    #![allow(clippy::unit_arg)]
+
+    pub fn reproduce(initial: &Option<String>) {
+        // 👇 needs `.as_ref()` because initial is an `&Option<_>`
+        initial.as_ref().map_or({}, |value| do_something(value))
+    }
+
+    pub fn reproduce2(initial: &mut Option<String>) {
+        initial.as_mut().map_or({}, |value| do_something2(value))
+    }
+
+    fn do_something(_value: &str) {}
+    fn do_something2(_value: &mut str) {}
+}
diff --git a/tests/ui/option_if_let_else.rs b/tests/ui/option_if_let_else.rs
index cfbec8cb27d..9358c20ab95 100644
--- a/tests/ui/option_if_let_else.rs
+++ b/tests/ui/option_if_let_else.rs
@@ -239,6 +239,8 @@ fn main() {
         Ok(a) => a + 1,
     };
     let _ = if let Ok(a) = res { a + 1 } else { 5 };
+    issue10729::reproduce(&None);
+    issue10729::reproduce2(&mut None);
 }
 
 #[allow(dead_code)]
@@ -249,3 +251,25 @@ fn issue9742() -> Option<&'static str> {
         _ => None,
     }
 }
+
+mod issue10729 {
+    #![allow(clippy::unit_arg)]
+
+    pub fn reproduce(initial: &Option<String>) {
+        // 👇 needs `.as_ref()` because initial is an `&Option<_>`
+        match initial {
+            Some(value) => do_something(value),
+            None => {},
+        }
+    }
+
+    pub fn reproduce2(initial: &mut Option<String>) {
+        match initial {
+            Some(value) => do_something2(value),
+            None => {},
+        }
+    }
+
+    fn do_something(_value: &str) {}
+    fn do_something2(_value: &mut str) {}
+}
diff --git a/tests/ui/option_if_let_else.stderr b/tests/ui/option_if_let_else.stderr
index 91d52fc79b8..fde27f21690 100644
--- a/tests/ui/option_if_let_else.stderr
+++ b/tests/ui/option_if_let_else.stderr
@@ -271,5 +271,23 @@ error: use Option::map_or instead of an if let/else
 LL |     let _ = if let Ok(a) = res { a + 1 } else { 5 };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `res.map_or(5, |a| a + 1)`
 
-error: aborting due to 21 previous errors
+error: use Option::map_or instead of an if let/else
+  --> $DIR/option_if_let_else.rs:260:9
+   |
+LL | /         match initial {
+LL | |             Some(value) => do_something(value),
+LL | |             None => {},
+LL | |         }
+   | |_________^ help: try: `initial.as_ref().map_or({}, |value| do_something(value))`
+
+error: use Option::map_or instead of an if let/else
+  --> $DIR/option_if_let_else.rs:267:9
+   |
+LL | /         match initial {
+LL | |             Some(value) => do_something2(value),
+LL | |             None => {},
+LL | |         }
+   | |_________^ help: try: `initial.as_mut().map_or({}, |value| do_something2(value))`
+
+error: aborting due to 23 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From d29506794ee270e300d08d57c14ba49e7dc18289 Mon Sep 17 00:00:00 2001
From: Catherine <114838443+Centri3@users.noreply.github.com>
Date: Thu, 22 Jun 2023 22:01:17 -0500
Subject: Don't lint code from external macros

---
 clippy_lints/src/misc_early/mod.rs        |  4 ++++
 tests/ui/patterns.fixed                   | 11 +++++++++++
 tests/ui/patterns.rs                      | 11 +++++++++++
 tests/ui/patterns.stderr                  |  6 +++---
 tests/ui/unneeded_field_pattern.rs        | 14 +++++++++++++-
 tests/ui/unneeded_field_pattern.stderr    |  4 ++--
 tests/ui/unneeded_wildcard_pattern.fixed  |  8 ++++++++
 tests/ui/unneeded_wildcard_pattern.rs     |  8 ++++++++
 tests/ui/unneeded_wildcard_pattern.stderr | 30 +++++++++++++++---------------
 9 files changed, 75 insertions(+), 21 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/misc_early/mod.rs b/clippy_lints/src/misc_early/mod.rs
index 78be6b9e23f..78253ab6cdc 100644
--- a/clippy_lints/src/misc_early/mod.rs
+++ b/clippy_lints/src/misc_early/mod.rs
@@ -339,6 +339,10 @@ impl EarlyLintPass for MiscEarlyLints {
     }
 
     fn check_pat(&mut self, cx: &EarlyContext<'_>, pat: &Pat) {
+        if in_external_macro(cx.sess(), pat.span) {
+            return;
+        }
+
         unneeded_field_pattern::check(cx, pat);
         redundant_pattern::check(cx, pat);
         unneeded_wildcard_pattern::check(cx, pat);
diff --git a/tests/ui/patterns.fixed b/tests/ui/patterns.fixed
index a1da47d84fd..714143e7586 100644
--- a/tests/ui/patterns.fixed
+++ b/tests/ui/patterns.fixed
@@ -1,8 +1,12 @@
 //@run-rustfix
+//@aux-build:proc_macros.rs:proc-macro
 #![warn(clippy::all)]
 #![allow(unused)]
 #![allow(clippy::uninlined_format_args)]
 
+#[macro_use]
+extern crate proc_macros;
+
 fn main() {
     let v = Some(true);
     let s = [0, 1, 2, 3, 4];
@@ -34,4 +38,11 @@ fn main() {
         ref x => println!("vec: {:?}", x),
         ref y if y == &vec![0] => (),
     }
+    external! {
+        let v = Some(true);
+        match v {
+            Some(x) => (),
+            y @ _ => (),
+        }
+    }
 }
diff --git a/tests/ui/patterns.rs b/tests/ui/patterns.rs
index 399066b813e..153e2640701 100644
--- a/tests/ui/patterns.rs
+++ b/tests/ui/patterns.rs
@@ -1,8 +1,12 @@
 //@run-rustfix
+//@aux-build:proc_macros.rs:proc-macro
 #![warn(clippy::all)]
 #![allow(unused)]
 #![allow(clippy::uninlined_format_args)]
 
+#[macro_use]
+extern crate proc_macros;
+
 fn main() {
     let v = Some(true);
     let s = [0, 1, 2, 3, 4];
@@ -34,4 +38,11 @@ fn main() {
         ref x @ _ => println!("vec: {:?}", x),
         ref y if y == &vec![0] => (),
     }
+    external! {
+        let v = Some(true);
+        match v {
+            Some(x) => (),
+            y @ _ => (),
+        }
+    }
 }
diff --git a/tests/ui/patterns.stderr b/tests/ui/patterns.stderr
index 2c46b4eb593..276330d21c4 100644
--- a/tests/ui/patterns.stderr
+++ b/tests/ui/patterns.stderr
@@ -1,5 +1,5 @@
 error: the `y @ _` pattern can be written as just `y`
-  --> $DIR/patterns.rs:11:9
+  --> $DIR/patterns.rs:15:9
    |
 LL |         y @ _ => (),
    |         ^^^^^ help: try: `y`
@@ -7,13 +7,13 @@ LL |         y @ _ => (),
    = note: `-D clippy::redundant-pattern` implied by `-D warnings`
 
 error: the `x @ _` pattern can be written as just `x`
-  --> $DIR/patterns.rs:26:9
+  --> $DIR/patterns.rs:30:9
    |
 LL |         ref mut x @ _ => {
    |         ^^^^^^^^^^^^^ help: try: `ref mut x`
 
 error: the `x @ _` pattern can be written as just `x`
-  --> $DIR/patterns.rs:34:9
+  --> $DIR/patterns.rs:38:9
    |
 LL |         ref x @ _ => println!("vec: {:?}", x),
    |         ^^^^^^^^^ help: try: `ref x`
diff --git a/tests/ui/unneeded_field_pattern.rs b/tests/ui/unneeded_field_pattern.rs
index fa639aa70d6..48ae1cf6640 100644
--- a/tests/ui/unneeded_field_pattern.rs
+++ b/tests/ui/unneeded_field_pattern.rs
@@ -1,5 +1,9 @@
+//@aux-build:proc_macros.rs:proc-macro
 #![warn(clippy::unneeded_field_pattern)]
-#[allow(dead_code, unused)]
+#![allow(dead_code, unused)]
+
+#[macro_use]
+extern crate proc_macros;
 
 struct Foo {
     a: i32,
@@ -19,4 +23,12 @@ fn main() {
         Foo { b: 0, .. } => {}, // should be OK
         Foo { .. } => {},       // and the Force might be with this one
     }
+    external! {
+        let f = Foo { a: 0, b: 0, c: 0 };
+        match f {
+            Foo { a: _, b: 0, .. } => {},
+
+            Foo { a: _, b: _, c: _ } => {},
+        }
+    }
 }
diff --git a/tests/ui/unneeded_field_pattern.stderr b/tests/ui/unneeded_field_pattern.stderr
index 6f7c3154569..3f15684986f 100644
--- a/tests/ui/unneeded_field_pattern.stderr
+++ b/tests/ui/unneeded_field_pattern.stderr
@@ -1,5 +1,5 @@
 error: you matched a field with a wildcard pattern, consider using `..` instead
-  --> $DIR/unneeded_field_pattern.rs:14:15
+  --> $DIR/unneeded_field_pattern.rs:18:15
    |
 LL |         Foo { a: _, b: 0, .. } => {},
    |               ^^^^
@@ -8,7 +8,7 @@ LL |         Foo { a: _, b: 0, .. } => {},
    = note: `-D clippy::unneeded-field-pattern` implied by `-D warnings`
 
 error: all the struct fields are matched to a wildcard pattern, consider using `..`
-  --> $DIR/unneeded_field_pattern.rs:16:9
+  --> $DIR/unneeded_field_pattern.rs:20:9
    |
 LL |         Foo { a: _, b: _, c: _ } => {},
    |         ^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/unneeded_wildcard_pattern.fixed b/tests/ui/unneeded_wildcard_pattern.fixed
index d18c65a7709..2eeba509e83 100644
--- a/tests/ui/unneeded_wildcard_pattern.fixed
+++ b/tests/ui/unneeded_wildcard_pattern.fixed
@@ -1,8 +1,12 @@
 //@run-rustfix
+//@aux-build:proc_macros.rs:proc-macro
 #![feature(stmt_expr_attributes)]
 #![deny(clippy::unneeded_wildcard_pattern)]
 #![allow(clippy::needless_if)]
 
+#[macro_use]
+extern crate proc_macros;
+
 fn main() {
     let t = (0, 1, 2, 3);
 
@@ -43,4 +47,8 @@ fn main() {
     {
         if let S(0, ..,) = s {};
     }
+    external! {
+        let t = (0, 1, 2, 3);
+        if let (0, _, ..) = t {};
+    }
 }
diff --git a/tests/ui/unneeded_wildcard_pattern.rs b/tests/ui/unneeded_wildcard_pattern.rs
index c80756c4495..5416cfaa542 100644
--- a/tests/ui/unneeded_wildcard_pattern.rs
+++ b/tests/ui/unneeded_wildcard_pattern.rs
@@ -1,8 +1,12 @@
 //@run-rustfix
+//@aux-build:proc_macros.rs:proc-macro
 #![feature(stmt_expr_attributes)]
 #![deny(clippy::unneeded_wildcard_pattern)]
 #![allow(clippy::needless_if)]
 
+#[macro_use]
+extern crate proc_macros;
+
 fn main() {
     let t = (0, 1, 2, 3);
 
@@ -43,4 +47,8 @@ fn main() {
     {
         if let S(0, .., _, _,) = s {};
     }
+    external! {
+        let t = (0, 1, 2, 3);
+        if let (0, _, ..) = t {};
+    }
 }
diff --git a/tests/ui/unneeded_wildcard_pattern.stderr b/tests/ui/unneeded_wildcard_pattern.stderr
index 8a004b77e94..ffbdc049506 100644
--- a/tests/ui/unneeded_wildcard_pattern.stderr
+++ b/tests/ui/unneeded_wildcard_pattern.stderr
@@ -1,89 +1,89 @@
 error: this pattern is unneeded as the `..` pattern can match that element
-  --> $DIR/unneeded_wildcard_pattern.rs:9:18
+  --> $DIR/unneeded_wildcard_pattern.rs:13:18
    |
 LL |     if let (0, .., _) = t {};
    |                  ^^^ help: remove it
    |
 note: the lint level is defined here
-  --> $DIR/unneeded_wildcard_pattern.rs:3:9
+  --> $DIR/unneeded_wildcard_pattern.rs:4:9
    |
 LL | #![deny(clippy::unneeded_wildcard_pattern)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this pattern is unneeded as the `..` pattern can match that element
-  --> $DIR/unneeded_wildcard_pattern.rs:10:16
+  --> $DIR/unneeded_wildcard_pattern.rs:14:16
    |
 LL |     if let (0, _, ..) = t {};
    |                ^^^ help: remove it
 
 error: this pattern is unneeded as the `..` pattern can match that element
-  --> $DIR/unneeded_wildcard_pattern.rs:11:13
+  --> $DIR/unneeded_wildcard_pattern.rs:15:13
    |
 LL |     if let (_, .., 0) = t {};
    |             ^^^ help: remove it
 
 error: this pattern is unneeded as the `..` pattern can match that element
-  --> $DIR/unneeded_wildcard_pattern.rs:12:15
+  --> $DIR/unneeded_wildcard_pattern.rs:16:15
    |
 LL |     if let (.., _, 0) = t {};
    |               ^^^ help: remove it
 
 error: these patterns are unneeded as the `..` pattern can match those elements
-  --> $DIR/unneeded_wildcard_pattern.rs:13:16
+  --> $DIR/unneeded_wildcard_pattern.rs:17:16
    |
 LL |     if let (0, _, _, ..) = t {};
    |                ^^^^^^ help: remove them
 
 error: these patterns are unneeded as the `..` pattern can match those elements
-  --> $DIR/unneeded_wildcard_pattern.rs:14:18
+  --> $DIR/unneeded_wildcard_pattern.rs:18:18
    |
 LL |     if let (0, .., _, _) = t {};
    |                  ^^^^^^ help: remove them
 
 error: these patterns are unneeded as the `..` pattern can match those elements
-  --> $DIR/unneeded_wildcard_pattern.rs:23:22
+  --> $DIR/unneeded_wildcard_pattern.rs:27:22
    |
 LL |         if let (0, .., _, _,) = t {};
    |                      ^^^^^^ help: remove them
 
 error: this pattern is unneeded as the `..` pattern can match that element
-  --> $DIR/unneeded_wildcard_pattern.rs:30:19
+  --> $DIR/unneeded_wildcard_pattern.rs:34:19
    |
 LL |     if let S(0, .., _) = s {};
    |                   ^^^ help: remove it
 
 error: this pattern is unneeded as the `..` pattern can match that element
-  --> $DIR/unneeded_wildcard_pattern.rs:31:17
+  --> $DIR/unneeded_wildcard_pattern.rs:35:17
    |
 LL |     if let S(0, _, ..) = s {};
    |                 ^^^ help: remove it
 
 error: this pattern is unneeded as the `..` pattern can match that element
-  --> $DIR/unneeded_wildcard_pattern.rs:32:14
+  --> $DIR/unneeded_wildcard_pattern.rs:36:14
    |
 LL |     if let S(_, .., 0) = s {};
    |              ^^^ help: remove it
 
 error: this pattern is unneeded as the `..` pattern can match that element
-  --> $DIR/unneeded_wildcard_pattern.rs:33:16
+  --> $DIR/unneeded_wildcard_pattern.rs:37:16
    |
 LL |     if let S(.., _, 0) = s {};
    |                ^^^ help: remove it
 
 error: these patterns are unneeded as the `..` pattern can match those elements
-  --> $DIR/unneeded_wildcard_pattern.rs:34:17
+  --> $DIR/unneeded_wildcard_pattern.rs:38:17
    |
 LL |     if let S(0, _, _, ..) = s {};
    |                 ^^^^^^ help: remove them
 
 error: these patterns are unneeded as the `..` pattern can match those elements
-  --> $DIR/unneeded_wildcard_pattern.rs:35:19
+  --> $DIR/unneeded_wildcard_pattern.rs:39:19
    |
 LL |     if let S(0, .., _, _) = s {};
    |                   ^^^^^^ help: remove them
 
 error: these patterns are unneeded as the `..` pattern can match those elements
-  --> $DIR/unneeded_wildcard_pattern.rs:44:23
+  --> $DIR/unneeded_wildcard_pattern.rs:48:23
    |
 LL |         if let S(0, .., _, _,) = s {};
    |                       ^^^^^^ help: remove them
-- 
cgit 1.4.1-3-g733a5


From 9b7d8d1dc7cee007ec90a8c82e159bb504655615 Mon Sep 17 00:00:00 2001
From: darklyspaced <srohanjd@gmail.com>
Date: Mon, 26 Jun 2023 13:13:42 +0800
Subject: suggests `is_some_and` over `map().unwrap_or(false)`

---
 clippy_lints/src/methods/mod.rs                  |  2 ++
 clippy_lints/src/methods/option_map_unwrap_or.rs | 28 +++++++++++++++++++++---
 tests/ui/map_unwrap_or.rs                        |  4 ++++
 tests/ui/map_unwrap_or.stderr                    | 20 +++++++++++++----
 4 files changed, 47 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 99c984ba65a..403fac123a9 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -513,6 +513,7 @@ declare_clippy_lint! {
     /// # let result: Result<usize, ()> = Ok(1);
     /// # fn some_function(foo: ()) -> usize { 1 }
     /// option.map(|a| a + 1).unwrap_or(0);
+    /// option.map(|a| a > 10).unwrap_or(false);
     /// result.map(|a| a + 1).unwrap_or_else(some_function);
     /// ```
     ///
@@ -522,6 +523,7 @@ declare_clippy_lint! {
     /// # let result: Result<usize, ()> = Ok(1);
     /// # fn some_function(foo: ()) -> usize { 1 }
     /// option.map_or(0, |a| a + 1);
+    /// option.is_some_and(|a| a > 10);
     /// result.map_or_else(some_function, |a| a + 1);
     /// ```
     #[clippy::version = "1.45.0"]
diff --git a/clippy_lints/src/methods/option_map_unwrap_or.rs b/clippy_lints/src/methods/option_map_unwrap_or.rs
index e931c6277f4..6a4d288abbf 100644
--- a/clippy_lints/src/methods/option_map_unwrap_or.rs
+++ b/clippy_lints/src/methods/option_map_unwrap_or.rs
@@ -74,16 +74,32 @@ pub(super) fn check<'tcx>(
             return;
         }
 
+        let mut suggest_is_some_and = false;
+        // argument to `unwrap_or` is false; should suggest using `is_some_and`
+        if let ExprKind::Lit(unwrap_lit) = &unwrap_arg.kind {
+            if let rustc_ast::LitKind::Bool(false) = unwrap_lit.node {
+                suggest_is_some_and = true;
+            }
+        }
+
         let mut applicability = Applicability::MachineApplicable;
         // get snippet for unwrap_or()
         let unwrap_snippet = snippet_with_applicability(cx, unwrap_arg.span, "..", &mut applicability);
         // lint message
         // comparing the snippet from source to raw text ("None") below is safe
         // because we already have checked the type.
-        let arg = if unwrap_snippet == "None" { "None" } else { "<a>" };
+        let arg = if unwrap_snippet == "None" {
+            "None"
+        } else if suggest_is_some_and {
+            "false"
+        } else {
+            "<a>"
+        };
         let unwrap_snippet_none = unwrap_snippet == "None";
         let suggest = if unwrap_snippet_none {
             "and_then(<f>)"
+        } else if suggest_is_some_and {
+            "is_some_and(<f>)"
         } else {
             "map_or(<a>, <f>)"
         };
@@ -98,12 +114,18 @@ pub(super) fn check<'tcx>(
             let mut suggestion = vec![
                 (
                     map_span,
-                    String::from(if unwrap_snippet_none { "and_then" } else { "map_or" }),
+                    String::from(if unwrap_snippet_none {
+                        "and_then"
+                    } else if suggest_is_some_and {
+                        "is_some_and"
+                    } else {
+                        "map_or"
+                    }),
                 ),
                 (expr.span.with_lo(unwrap_recv.span.hi()), String::new()),
             ];
 
-            if !unwrap_snippet_none {
+            if !unwrap_snippet_none && !suggest_is_some_and {
                 suggestion.push((map_arg_span.with_hi(map_arg_span.lo()), format!("{unwrap_snippet}, ")));
             }
 
diff --git a/tests/ui/map_unwrap_or.rs b/tests/ui/map_unwrap_or.rs
index 0cd49dd7760..51b88c7cf2e 100644
--- a/tests/ui/map_unwrap_or.rs
+++ b/tests/ui/map_unwrap_or.rs
@@ -56,6 +56,10 @@ fn option_methods() {
         .unwrap_or_else(||
             0
         );
+
+    // Check for `map(f).unwrap_or(false)` use.
+    let _ = opt.map(|x| x > 5).unwrap_or(false);
+
 }
 
 #[rustfmt::skip]
diff --git a/tests/ui/map_unwrap_or.stderr b/tests/ui/map_unwrap_or.stderr
index 41781b050fa..6f23d2e4f88 100644
--- a/tests/ui/map_unwrap_or.stderr
+++ b/tests/ui/map_unwrap_or.stderr
@@ -126,8 +126,20 @@ LL | |             0
 LL | |         );
    | |_________^
 
+error: called `map(<f>).unwrap_or(false)` on an `Option` value. This can be done more directly by calling `is_some_and(<f>)` instead
+  --> $DIR/map_unwrap_or.rs:61:13
+   |
+LL |     let _ = opt.map(|x| x > 5).unwrap_or(false);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `is_some_and(<f>)` instead
+   |
+LL -     let _ = opt.map(|x| x > 5).unwrap_or(false);
+LL +     let _ = opt.is_some_and(|x| x > 5);
+   |
+
 error: called `map(<f>).unwrap_or_else(<g>)` on a `Result` value. This can be done more directly by calling `.map_or_else(<g>, <f>)` instead
-  --> $DIR/map_unwrap_or.rs:67:13
+  --> $DIR/map_unwrap_or.rs:71:13
    |
 LL |       let _ = res.map(|x| {
    |  _____________^
@@ -137,7 +149,7 @@ LL | |     ).unwrap_or_else(|_e| 0);
    | |____________________________^
 
 error: called `map(<f>).unwrap_or_else(<g>)` on a `Result` value. This can be done more directly by calling `.map_or_else(<g>, <f>)` instead
-  --> $DIR/map_unwrap_or.rs:71:13
+  --> $DIR/map_unwrap_or.rs:75:13
    |
 LL |       let _ = res.map(|x| x + 1)
    |  _____________^
@@ -147,10 +159,10 @@ LL | |         });
    | |__________^
 
 error: called `map(<f>).unwrap_or_else(<g>)` on a `Result` value. This can be done more directly by calling `.map_or_else(<g>, <f>)` instead
-  --> $DIR/map_unwrap_or.rs:95:13
+  --> $DIR/map_unwrap_or.rs:99:13
    |
 LL |     let _ = res.map(|x| x + 1).unwrap_or_else(|_e| 0);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `res.map_or_else(|_e| 0, |x| x + 1)`
 
-error: aborting due to 12 previous errors
+error: aborting due to 13 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From c60222dc12c4868a4aee439d98b007b129edc4cb Mon Sep 17 00:00:00 2001
From: darklyspaced <srohanjd@gmail.com>
Date: Mon, 26 Jun 2023 13:39:45 +0800
Subject: changed the msrv to 1.70 to suggest `is_some_and`

if the msrv is not >= 1.70 then the `map_or` is suggested instead of `is_some_and` (even when `unwrap_or` returns false)
---
 clippy_lints/src/methods/mod.rs                  |  2 +-
 clippy_lints/src/methods/option_map_unwrap_or.rs | 12 +++++++----
 clippy_utils/src/msrvs.rs                        |  1 +
 tests/ui/map_unwrap_or.rs                        | 14 +++++++++++++
 tests/ui/map_unwrap_or.stderr                    | 26 +++++++++++++++++++++++-
 5 files changed, 49 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 403fac123a9..b1d3b61aea3 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3906,7 +3906,7 @@ impl Methods {
                             manual_saturating_arithmetic::check(cx, expr, lhs, rhs, u_arg, &arith["checked_".len()..]);
                         },
                         Some(("map", m_recv, [m_arg], span, _)) => {
-                            option_map_unwrap_or::check(cx, expr, m_recv, m_arg, recv, u_arg, span);
+                            option_map_unwrap_or::check(cx, expr, m_recv, m_arg, recv, u_arg, span, &self.msrv);
                         },
                         Some(("then_some", t_recv, [t_arg], _, _)) => {
                             obfuscated_if_else::check(cx, expr, t_recv, t_arg, u_arg);
diff --git a/clippy_lints/src/methods/option_map_unwrap_or.rs b/clippy_lints/src/methods/option_map_unwrap_or.rs
index 6a4d288abbf..4387090fe23 100644
--- a/clippy_lints/src/methods/option_map_unwrap_or.rs
+++ b/clippy_lints/src/methods/option_map_unwrap_or.rs
@@ -1,4 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::is_copy;
 use clippy_utils::ty::is_type_diagnostic_item;
@@ -27,6 +28,7 @@ pub(super) fn check<'tcx>(
     unwrap_recv: &rustc_hir::Expr<'_>,
     unwrap_arg: &'tcx rustc_hir::Expr<'_>,
     map_span: Span,
+    msrv: &Msrv,
 ) {
     // lint if the caller of `map()` is an `Option`
     if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(recv), sym::Option) {
@@ -75,10 +77,12 @@ pub(super) fn check<'tcx>(
         }
 
         let mut suggest_is_some_and = false;
-        // argument to `unwrap_or` is false; should suggest using `is_some_and`
-        if let ExprKind::Lit(unwrap_lit) = &unwrap_arg.kind {
-            if let rustc_ast::LitKind::Bool(false) = unwrap_lit.node {
-                suggest_is_some_and = true;
+        // argument to `unwrap_or` is false & is_some_and is stabilised; should suggest using `is_some_and`
+        if msrv.meets(msrvs::OPT_IS_SOME_AND) {
+            if let ExprKind::Lit(unwrap_lit) = &unwrap_arg.kind {
+                if let rustc_ast::LitKind::Bool(false) = unwrap_lit.node {
+                    suggest_is_some_and = true;
+                }
             }
         }
 
diff --git a/clippy_utils/src/msrvs.rs b/clippy_utils/src/msrvs.rs
index 0a4c3418a08..1541dc8392c 100644
--- a/clippy_utils/src/msrvs.rs
+++ b/clippy_utils/src/msrvs.rs
@@ -19,6 +19,7 @@ macro_rules! msrv_aliases {
 
 // names may refer to stabilized feature flags or library items
 msrv_aliases! {
+    1,70,0 { OPT_IS_SOME_AND }
     1,68,0 { PATH_MAIN_SEPARATOR_STR }
     1,65,0 { LET_ELSE, POINTER_CAST_CONSTNESS }
     1,62,0 { BOOL_THEN_SOME, DEFAULT_ENUM_ATTRIBUTE }
diff --git a/tests/ui/map_unwrap_or.rs b/tests/ui/map_unwrap_or.rs
index 51b88c7cf2e..bb36cb2c598 100644
--- a/tests/ui/map_unwrap_or.rs
+++ b/tests/ui/map_unwrap_or.rs
@@ -99,6 +99,20 @@ fn msrv_1_41() {
     let _ = res.map(|x| x + 1).unwrap_or_else(|_e| 0);
 }
 
+#[clippy::msrv = "1.69"]
+fn msrv_1_69() {
+    let opt: Option<i32> = Some(1);
+
+    let _ = opt.map(|x| x > 5).unwrap_or(false);
+}
+
+#[clippy::msrv = "1.70"]
+fn msrv_1_70() {
+    let opt: Option<i32> = Some(1);
+
+    let _ = opt.map(|x| x > 5).unwrap_or(false);
+}
+
 mod issue_10579 {
     // Different variations of the same issue.
     fn v1() {
diff --git a/tests/ui/map_unwrap_or.stderr b/tests/ui/map_unwrap_or.stderr
index 6f23d2e4f88..9f4a4a9ae6b 100644
--- a/tests/ui/map_unwrap_or.stderr
+++ b/tests/ui/map_unwrap_or.stderr
@@ -164,5 +164,29 @@ error: called `map(<f>).unwrap_or_else(<g>)` on a `Result` value. This can be do
 LL |     let _ = res.map(|x| x + 1).unwrap_or_else(|_e| 0);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `res.map_or_else(|_e| 0, |x| x + 1)`
 
-error: aborting due to 13 previous errors
+error: called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead
+  --> $DIR/map_unwrap_or.rs:106:13
+   |
+LL |     let _ = opt.map(|x| x > 5).unwrap_or(false);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `map_or(<a>, <f>)` instead
+   |
+LL -     let _ = opt.map(|x| x > 5).unwrap_or(false);
+LL +     let _ = opt.map_or(false, |x| x > 5);
+   |
+
+error: called `map(<f>).unwrap_or(false)` on an `Option` value. This can be done more directly by calling `is_some_and(<f>)` instead
+  --> $DIR/map_unwrap_or.rs:113:13
+   |
+LL |     let _ = opt.map(|x| x > 5).unwrap_or(false);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `is_some_and(<f>)` instead
+   |
+LL -     let _ = opt.map(|x| x > 5).unwrap_or(false);
+LL +     let _ = opt.is_some_and(|x| x > 5);
+   |
+
+error: aborting due to 15 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From b832175b2d51a02fdac3bb8110b71f9a1e1d30b4 Mon Sep 17 00:00:00 2001
From: darklyspaced <srohanjd@gmail.com>
Date: Mon, 26 Jun 2023 14:05:41 +0800
Subject: now passes dogfood by wrapping unwrap_recv and unwrap_arg into a
 tuple

was previously failing due to `check` having to many arguments.
---
 clippy_lints/src/methods/mod.rs                  | 2 +-
 clippy_lints/src/methods/option_map_unwrap_or.rs | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index b1d3b61aea3..cdabb168912 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3906,7 +3906,7 @@ impl Methods {
                             manual_saturating_arithmetic::check(cx, expr, lhs, rhs, u_arg, &arith["checked_".len()..]);
                         },
                         Some(("map", m_recv, [m_arg], span, _)) => {
-                            option_map_unwrap_or::check(cx, expr, m_recv, m_arg, recv, u_arg, span, &self.msrv);
+                            option_map_unwrap_or::check(cx, expr, m_recv, m_arg, (recv, u_arg), span, &self.msrv);
                         },
                         Some(("then_some", t_recv, [t_arg], _, _)) => {
                             obfuscated_if_else::check(cx, expr, t_recv, t_arg, u_arg);
diff --git a/clippy_lints/src/methods/option_map_unwrap_or.rs b/clippy_lints/src/methods/option_map_unwrap_or.rs
index 4387090fe23..b0d902e6088 100644
--- a/clippy_lints/src/methods/option_map_unwrap_or.rs
+++ b/clippy_lints/src/methods/option_map_unwrap_or.rs
@@ -25,11 +25,11 @@ pub(super) fn check<'tcx>(
     expr: &rustc_hir::Expr<'_>,
     recv: &rustc_hir::Expr<'_>,
     map_arg: &'tcx rustc_hir::Expr<'_>,
-    unwrap_recv: &rustc_hir::Expr<'_>,
-    unwrap_arg: &'tcx rustc_hir::Expr<'_>,
+    unwrap: (&rustc_hir::Expr<'_>, &'tcx rustc_hir::Expr<'_>),
     map_span: Span,
     msrv: &Msrv,
 ) {
+    let (unwrap_recv, unwrap_arg) = unwrap;
     // lint if the caller of `map()` is an `Option`
     if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(recv), sym::Option) {
         if !is_copy(cx, cx.typeck_results().expr_ty(unwrap_arg)) {
-- 
cgit 1.4.1-3-g733a5


From c378bf9ddf10e191fce5753a02a09bb0ab8961fb Mon Sep 17 00:00:00 2001
From: darklyspaced <srohanjd@gmail.com>
Date: Mon, 26 Jun 2023 14:43:36 +0800
Subject: Revert "now passes dogfood by wrapping unwrap_recv and unwrap_arg
 into a tuple"

This reverts commit 7b91844a3207d90d4200a7b53d0ae1a7a1dca73a.
---
 clippy_lints/src/methods/mod.rs                  | 2 +-
 clippy_lints/src/methods/option_map_unwrap_or.rs | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index cdabb168912..b1d3b61aea3 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3906,7 +3906,7 @@ impl Methods {
                             manual_saturating_arithmetic::check(cx, expr, lhs, rhs, u_arg, &arith["checked_".len()..]);
                         },
                         Some(("map", m_recv, [m_arg], span, _)) => {
-                            option_map_unwrap_or::check(cx, expr, m_recv, m_arg, (recv, u_arg), span, &self.msrv);
+                            option_map_unwrap_or::check(cx, expr, m_recv, m_arg, recv, u_arg, span, &self.msrv);
                         },
                         Some(("then_some", t_recv, [t_arg], _, _)) => {
                             obfuscated_if_else::check(cx, expr, t_recv, t_arg, u_arg);
diff --git a/clippy_lints/src/methods/option_map_unwrap_or.rs b/clippy_lints/src/methods/option_map_unwrap_or.rs
index b0d902e6088..4387090fe23 100644
--- a/clippy_lints/src/methods/option_map_unwrap_or.rs
+++ b/clippy_lints/src/methods/option_map_unwrap_or.rs
@@ -25,11 +25,11 @@ pub(super) fn check<'tcx>(
     expr: &rustc_hir::Expr<'_>,
     recv: &rustc_hir::Expr<'_>,
     map_arg: &'tcx rustc_hir::Expr<'_>,
-    unwrap: (&rustc_hir::Expr<'_>, &'tcx rustc_hir::Expr<'_>),
+    unwrap_recv: &rustc_hir::Expr<'_>,
+    unwrap_arg: &'tcx rustc_hir::Expr<'_>,
     map_span: Span,
     msrv: &Msrv,
 ) {
-    let (unwrap_recv, unwrap_arg) = unwrap;
     // lint if the caller of `map()` is an `Option`
     if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(recv), sym::Option) {
         if !is_copy(cx, cx.typeck_results().expr_ty(unwrap_arg)) {
-- 
cgit 1.4.1-3-g733a5


From ca00b138b21d87cff24d085dd9d9dce2bf26b530 Mon Sep 17 00:00:00 2001
From: darklyspaced <srohanjd@gmail.com>
Date: Mon, 26 Jun 2023 14:47:05 +0800
Subject: ignore too_many_arguments on `check`

---
 clippy_lints/src/methods/option_map_unwrap_or.rs | 1 +
 1 file changed, 1 insertion(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/option_map_unwrap_or.rs b/clippy_lints/src/methods/option_map_unwrap_or.rs
index 4387090fe23..e836a1395a2 100644
--- a/clippy_lints/src/methods/option_map_unwrap_or.rs
+++ b/clippy_lints/src/methods/option_map_unwrap_or.rs
@@ -20,6 +20,7 @@ use rustc_span::sym;
 use super::MAP_UNWRAP_OR;
 
 /// lint use of `map().unwrap_or()` for `Option`s
+#[expect(clippy::too_many_arguments)]
 pub(super) fn check<'tcx>(
     cx: &LateContext<'tcx>,
     expr: &rustc_hir::Expr<'_>,
-- 
cgit 1.4.1-3-g733a5


From a693cbc1bca16c753dfb1aa853e970bd2028634c Mon Sep 17 00:00:00 2001
From: darklyspaced <srohanjd@gmail.com>
Date: Tue, 27 Jun 2023 11:28:45 +0800
Subject: changed msrv name for consistency & changed nested if for style

---
 clippy_lints/src/methods/option_map_unwrap_or.rs | 13 ++++---------
 clippy_utils/src/msrvs.rs                        |  2 +-
 2 files changed, 5 insertions(+), 10 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/option_map_unwrap_or.rs b/clippy_lints/src/methods/option_map_unwrap_or.rs
index e836a1395a2..f4f158c0439 100644
--- a/clippy_lints/src/methods/option_map_unwrap_or.rs
+++ b/clippy_lints/src/methods/option_map_unwrap_or.rs
@@ -77,15 +77,10 @@ pub(super) fn check<'tcx>(
             return;
         }
 
-        let mut suggest_is_some_and = false;
-        // argument to `unwrap_or` is false & is_some_and is stabilised; should suggest using `is_some_and`
-        if msrv.meets(msrvs::OPT_IS_SOME_AND) {
-            if let ExprKind::Lit(unwrap_lit) = &unwrap_arg.kind {
-                if let rustc_ast::LitKind::Bool(false) = unwrap_lit.node {
-                    suggest_is_some_and = true;
-                }
-            }
-        }
+        // is_some_and is stabilised && `unwrap_or` argument is false; suggest `is_some_and` instead
+        let suggest_is_some_and = msrv.meets(msrvs::OPTION_IS_SOME_AND)
+            && matches!(&unwrap_arg.kind, ExprKind::Lit(lit)
+            if matches!(lit.node, rustc_ast::LitKind::Bool(false)));
 
         let mut applicability = Applicability::MachineApplicable;
         // get snippet for unwrap_or()
diff --git a/clippy_utils/src/msrvs.rs b/clippy_utils/src/msrvs.rs
index 1541dc8392c..5aacca45146 100644
--- a/clippy_utils/src/msrvs.rs
+++ b/clippy_utils/src/msrvs.rs
@@ -19,7 +19,7 @@ macro_rules! msrv_aliases {
 
 // names may refer to stabilized feature flags or library items
 msrv_aliases! {
-    1,70,0 { OPT_IS_SOME_AND }
+    1,70,0 { OPTION_IS_SOME_AND }
     1,68,0 { PATH_MAIN_SEPARATOR_STR }
     1,65,0 { LET_ELSE, POINTER_CAST_CONSTNESS }
     1,62,0 { BOOL_THEN_SOME, DEFAULT_ENUM_ATTRIBUTE }
-- 
cgit 1.4.1-3-g733a5


From 1bf74fc303d77be3ceef5b030d9fd73ca6031298 Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Sat, 3 Jun 2023 18:07:36 -0500
Subject: add `needless_raw_string_hashes` lint

add semicolon in doctest
---
 CHANGELOG.md                                   |  1 +
 clippy_lints/src/declared_lints.rs             |  1 +
 clippy_lints/src/lib.rs                        |  1 +
 clippy_lints/src/needless_raw_string_hashes.rs | 73 +++++++++++++++++++++++++
 src/main.rs                                    |  4 +-
 tests/ui/format.fixed                          |  1 +
 tests/ui/format.rs                             |  1 +
 tests/ui/needless_raw_string_hashes.fixed      | 19 +++++++
 tests/ui/needless_raw_string_hashes.rs         | 19 +++++++
 tests/ui/needless_raw_string_hashes.stderr     | 76 ++++++++++++++++++++++++++
 tests/ui/regex.rs                              |  2 +-
 tests/ui/single_char_add_str.fixed             |  1 +
 tests/ui/single_char_add_str.rs                |  1 +
 tests/ui/single_char_add_str.stderr            | 30 +++++-----
 tests/ui/single_char_pattern.fixed             |  2 +-
 tests/ui/single_char_pattern.rs                |  2 +-
 tests/ui/string_lit_as_bytes.fixed             |  2 +-
 tests/ui/string_lit_as_bytes.rs                |  2 +-
 18 files changed, 216 insertions(+), 22 deletions(-)
 create mode 100644 clippy_lints/src/needless_raw_string_hashes.rs
 create mode 100644 tests/ui/needless_raw_string_hashes.fixed
 create mode 100644 tests/ui/needless_raw_string_hashes.rs
 create mode 100644 tests/ui/needless_raw_string_hashes.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 941efb1abff..7cb820b0c43 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5048,6 +5048,7 @@ Released 2018-09-13
 [`needless_pass_by_value`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_pass_by_value
 [`needless_question_mark`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_question_mark
 [`needless_range_loop`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_range_loop
+[`needless_raw_string_hashes`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_raw_string_hashes
 [`needless_return`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_return
 [`needless_splitn`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_splitn
 [`needless_update`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_update
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 0eec18a91bc..8753bcee5ce 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -469,6 +469,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::needless_parens_on_range_literals::NEEDLESS_PARENS_ON_RANGE_LITERALS_INFO,
     crate::needless_pass_by_value::NEEDLESS_PASS_BY_VALUE_INFO,
     crate::needless_question_mark::NEEDLESS_QUESTION_MARK_INFO,
+    crate::needless_raw_string_hashes::NEEDLESS_RAW_STRING_HASHES_INFO,
     crate::needless_update::NEEDLESS_UPDATE_INFO,
     crate::neg_cmp_op_on_partial_ord::NEG_CMP_OP_ON_PARTIAL_ORD_INFO,
     crate::neg_multiply::NEG_MULTIPLY_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 6d77b828f14..aadba6581a1 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -230,6 +230,7 @@ mod needless_late_init;
 mod needless_parens_on_range_literals;
 mod needless_pass_by_value;
 mod needless_question_mark;
+mod needless_raw_string_hashes;
 mod needless_update;
 mod neg_cmp_op_on_partial_ord;
 mod neg_multiply;
diff --git a/clippy_lints/src/needless_raw_string_hashes.rs b/clippy_lints/src/needless_raw_string_hashes.rs
new file mode 100644
index 00000000000..85dffa5613d
--- /dev/null
+++ b/clippy_lints/src/needless_raw_string_hashes.rs
@@ -0,0 +1,73 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use rustc_ast::{
+    ast::{Expr, ExprKind},
+    token::LitKind,
+};
+use rustc_errors::Applicability;
+use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
+use rustc_middle::lint::in_external_macro;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for raw string literals with an unnecessary amount of hashes around them.
+    ///
+    /// ### Why is this bad?
+    /// It's just unnecessary, and makes it look like there's more escaping needed than is actually
+    /// necessary.
+    ///
+    /// ### Example
+    /// ```rust
+    /// let r = r###"Hello, "world"!"###;
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// let r = r#"Hello, "world"!"#;
+    /// ```
+    #[clippy::version = "1.72.0"]
+    pub NEEDLESS_RAW_STRING_HASHES,
+    complexity,
+    "suggests reducing the number of hashes around a raw string literal"
+}
+declare_lint_pass!(NeedlessRawStringHashes => [NEEDLESS_RAW_STRING_HASHES]);
+
+impl EarlyLintPass for NeedlessRawStringHashes {
+    fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
+        if_chain! {
+            if !in_external_macro(cx.sess(), expr.span);
+            if let ExprKind::Lit(lit) = expr.kind;
+            if let LitKind::StrRaw(num) | LitKind::ByteStrRaw(num) | LitKind::CStrRaw(num) = lit.kind;
+            then {
+                let str = lit.symbol.as_str();
+                let mut lowest = 0;
+
+                for i in (0..num).rev() {
+                    if str.contains(&format!("\"{}", "#".repeat(i as usize))) {
+                        lowest = i + 1;
+                        break;
+                    }
+                }
+
+                if lowest < num {
+                    let hashes = "#".repeat(lowest as usize);
+                    let prefix = match lit.kind {
+                        LitKind::StrRaw(..) => "r",
+                        LitKind::ByteStrRaw(..) => "br",
+                        LitKind::CStrRaw(..) => "cr",
+                        _ => unreachable!(),
+                    };
+
+                    span_lint_and_sugg(
+                        cx,
+                        NEEDLESS_RAW_STRING_HASHES,
+                        expr.span,
+                        "unnecessary hashes around raw string literal",
+                        "try",
+                        format!(r#"{prefix}{hashes}"{}"{hashes}"#, lit.symbol),
+                        Applicability::MachineApplicable,
+                    );
+                }
+            }
+        }
+    }
+}
diff --git a/src/main.rs b/src/main.rs
index 300c84a1442..fd0da5a170b 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -6,7 +6,7 @@ use std::env;
 use std::path::PathBuf;
 use std::process::{self, Command};
 
-const CARGO_CLIPPY_HELP: &str = r#"Checks a package to catch common mistakes and improve your Rust code.
+const CARGO_CLIPPY_HELP: &str = r"Checks a package to catch common mistakes and improve your Rust code.
 
 Usage:
     cargo clippy [options] [--] [<opts>...]
@@ -31,7 +31,7 @@ with:
 You can use tool lints to allow or deny lints from your code, e.g.:
 
     #[allow(clippy::needless_lifetimes)]
-"#;
+";
 
 fn show_help() {
     println!("{CARGO_CLIPPY_HELP}");
diff --git a/tests/ui/format.fixed b/tests/ui/format.fixed
index f214cabef67..2e24e07ea26 100644
--- a/tests/ui/format.fixed
+++ b/tests/ui/format.fixed
@@ -7,6 +7,7 @@
     clippy::to_string_in_format_args,
     clippy::needless_borrow,
     clippy::uninlined_format_args,
+    clippy::needless_raw_string_hashes,
     clippy::useless_vec
 )]
 
diff --git a/tests/ui/format.rs b/tests/ui/format.rs
index d9b28a4f7c0..0e64a310b01 100644
--- a/tests/ui/format.rs
+++ b/tests/ui/format.rs
@@ -7,6 +7,7 @@
     clippy::to_string_in_format_args,
     clippy::needless_borrow,
     clippy::uninlined_format_args,
+    clippy::needless_raw_string_hashes,
     clippy::useless_vec
 )]
 
diff --git a/tests/ui/needless_raw_string_hashes.fixed b/tests/ui/needless_raw_string_hashes.fixed
new file mode 100644
index 00000000000..43616860a2e
--- /dev/null
+++ b/tests/ui/needless_raw_string_hashes.fixed
@@ -0,0 +1,19 @@
+//@run-rustfix
+#![allow(clippy::no_effect, unused)]
+#![warn(clippy::needless_raw_string_hashes)]
+#![feature(c_str_literals)]
+
+fn main() {
+    r"aaa";
+    r#"Hello "world"!"#;
+    r####" "### "## "# "####;
+    r###" "aa" "# "## "###;
+    br"aaa";
+    br#"Hello "world"!"#;
+    br####" "### "## "# "####;
+    br###" "aa" "# "## "###;
+    cr"aaa";
+    cr#"Hello "world"!"#;
+    cr####" "### "## "# "####;
+    cr###" "aa" "# "## "###;
+}
diff --git a/tests/ui/needless_raw_string_hashes.rs b/tests/ui/needless_raw_string_hashes.rs
new file mode 100644
index 00000000000..e2d85c52e78
--- /dev/null
+++ b/tests/ui/needless_raw_string_hashes.rs
@@ -0,0 +1,19 @@
+//@run-rustfix
+#![allow(clippy::no_effect, unused)]
+#![warn(clippy::needless_raw_string_hashes)]
+#![feature(c_str_literals)]
+
+fn main() {
+    r#"aaa"#;
+    r##"Hello "world"!"##;
+    r######" "### "## "# "######;
+    r######" "aa" "# "## "######;
+    br#"aaa"#;
+    br##"Hello "world"!"##;
+    br######" "### "## "# "######;
+    br######" "aa" "# "## "######;
+    cr#"aaa"#;
+    cr##"Hello "world"!"##;
+    cr######" "### "## "# "######;
+    cr######" "aa" "# "## "######;
+}
diff --git a/tests/ui/needless_raw_string_hashes.stderr b/tests/ui/needless_raw_string_hashes.stderr
new file mode 100644
index 00000000000..44b878cec40
--- /dev/null
+++ b/tests/ui/needless_raw_string_hashes.stderr
@@ -0,0 +1,76 @@
+error: unnecessary hashes around raw string literal
+  --> $DIR/needless_raw_string_hashes.rs:7:5
+   |
+LL |     r#"aaa"#;
+   |     ^^^^^^^^ help: try: `r"aaa"`
+   |
+   = note: `-D clippy::needless-raw-string-hashes` implied by `-D warnings`
+
+error: unnecessary hashes around raw string literal
+  --> $DIR/needless_raw_string_hashes.rs:8:5
+   |
+LL |     r##"Hello "world"!"##;
+   |     ^^^^^^^^^^^^^^^^^^^^^ help: try: `r#"Hello "world"!"#`
+
+error: unnecessary hashes around raw string literal
+  --> $DIR/needless_raw_string_hashes.rs:9:5
+   |
+LL |     r######" "### "## "# "######;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `r####" "### "## "# "####`
+
+error: unnecessary hashes around raw string literal
+  --> $DIR/needless_raw_string_hashes.rs:10:5
+   |
+LL |     r######" "aa" "# "## "######;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `r###" "aa" "# "## "###`
+
+error: unnecessary hashes around raw string literal
+  --> $DIR/needless_raw_string_hashes.rs:11:5
+   |
+LL |     br#"aaa"#;
+   |     ^^^^^^^^^ help: try: `br"aaa"`
+
+error: unnecessary hashes around raw string literal
+  --> $DIR/needless_raw_string_hashes.rs:12:5
+   |
+LL |     br##"Hello "world"!"##;
+   |     ^^^^^^^^^^^^^^^^^^^^^^ help: try: `br#"Hello "world"!"#`
+
+error: unnecessary hashes around raw string literal
+  --> $DIR/needless_raw_string_hashes.rs:13:5
+   |
+LL |     br######" "### "## "# "######;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `br####" "### "## "# "####`
+
+error: unnecessary hashes around raw string literal
+  --> $DIR/needless_raw_string_hashes.rs:14:5
+   |
+LL |     br######" "aa" "# "## "######;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `br###" "aa" "# "## "###`
+
+error: unnecessary hashes around raw string literal
+  --> $DIR/needless_raw_string_hashes.rs:15:5
+   |
+LL |     cr#"aaa"#;
+   |     ^^^^^^^^^ help: try: `cr"aaa"`
+
+error: unnecessary hashes around raw string literal
+  --> $DIR/needless_raw_string_hashes.rs:16:5
+   |
+LL |     cr##"Hello "world"!"##;
+   |     ^^^^^^^^^^^^^^^^^^^^^^ help: try: `cr#"Hello "world"!"#`
+
+error: unnecessary hashes around raw string literal
+  --> $DIR/needless_raw_string_hashes.rs:17:5
+   |
+LL |     cr######" "### "## "# "######;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `cr####" "### "## "# "####`
+
+error: unnecessary hashes around raw string literal
+  --> $DIR/needless_raw_string_hashes.rs:18:5
+   |
+LL |     cr######" "aa" "# "## "######;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `cr###" "aa" "# "## "###`
+
+error: aborting due to 12 previous errors
+
diff --git a/tests/ui/regex.rs b/tests/ui/regex.rs
index 1c8e47ab594..3b208651946 100644
--- a/tests/ui/regex.rs
+++ b/tests/ui/regex.rs
@@ -1,4 +1,4 @@
-#![allow(unused, clippy::needless_borrow)]
+#![allow(unused, clippy::needless_raw_string_hashes, clippy::needless_borrow)]
 #![warn(clippy::invalid_regex, clippy::trivial_regex)]
 
 extern crate regex;
diff --git a/tests/ui/single_char_add_str.fixed b/tests/ui/single_char_add_str.fixed
index cbcf1ab21c9..2d4c0841219 100644
--- a/tests/ui/single_char_add_str.fixed
+++ b/tests/ui/single_char_add_str.fixed
@@ -1,5 +1,6 @@
 //@run-rustfix
 #![warn(clippy::single_char_add_str)]
+#![allow(clippy::needless_raw_string_hashes)]
 
 macro_rules! get_string {
     () => {
diff --git a/tests/ui/single_char_add_str.rs b/tests/ui/single_char_add_str.rs
index a1f005cc833..463b19da09e 100644
--- a/tests/ui/single_char_add_str.rs
+++ b/tests/ui/single_char_add_str.rs
@@ -1,5 +1,6 @@
 //@run-rustfix
 #![warn(clippy::single_char_add_str)]
+#![allow(clippy::needless_raw_string_hashes)]
 
 macro_rules! get_string {
     () => {
diff --git a/tests/ui/single_char_add_str.stderr b/tests/ui/single_char_add_str.stderr
index 55d91583ad0..3f93c18470e 100644
--- a/tests/ui/single_char_add_str.stderr
+++ b/tests/ui/single_char_add_str.stderr
@@ -1,5 +1,5 @@
 error: calling `push_str()` using a single-character string literal
-  --> $DIR/single_char_add_str.rs:14:5
+  --> $DIR/single_char_add_str.rs:15:5
    |
 LL |     string.push_str("R");
    |     ^^^^^^^^^^^^^^^^^^^^ help: consider using `push` with a character literal: `string.push('R')`
@@ -7,85 +7,85 @@ LL |     string.push_str("R");
    = note: `-D clippy::single-char-add-str` implied by `-D warnings`
 
 error: calling `push_str()` using a single-character string literal
-  --> $DIR/single_char_add_str.rs:15:5
+  --> $DIR/single_char_add_str.rs:16:5
    |
 LL |     string.push_str("'");
    |     ^^^^^^^^^^^^^^^^^^^^ help: consider using `push` with a character literal: `string.push('/'')`
 
 error: calling `push_str()` using a single-character string literal
-  --> $DIR/single_char_add_str.rs:20:5
+  --> $DIR/single_char_add_str.rs:21:5
    |
 LL |     string.push_str("/x52");
    |     ^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `push` with a character literal: `string.push('/x52')`
 
 error: calling `push_str()` using a single-character string literal
-  --> $DIR/single_char_add_str.rs:21:5
+  --> $DIR/single_char_add_str.rs:22:5
    |
 LL |     string.push_str("/u{0052}");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `push` with a character literal: `string.push('/u{0052}')`
 
 error: calling `push_str()` using a single-character string literal
-  --> $DIR/single_char_add_str.rs:22:5
+  --> $DIR/single_char_add_str.rs:23:5
    |
 LL |     string.push_str(r##"a"##);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `push` with a character literal: `string.push('a')`
 
 error: calling `push_str()` using a single-character string literal
-  --> $DIR/single_char_add_str.rs:24:5
+  --> $DIR/single_char_add_str.rs:25:5
    |
 LL |     get_string!().push_str("ö");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `push` with a character literal: `get_string!().push('ö')`
 
 error: calling `insert_str()` using a single-character string literal
-  --> $DIR/single_char_add_str.rs:29:5
+  --> $DIR/single_char_add_str.rs:30:5
    |
 LL |     string.insert_str(0, "R");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `insert` with a character literal: `string.insert(0, 'R')`
 
 error: calling `insert_str()` using a single-character string literal
-  --> $DIR/single_char_add_str.rs:30:5
+  --> $DIR/single_char_add_str.rs:31:5
    |
 LL |     string.insert_str(1, "'");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `insert` with a character literal: `string.insert(1, '/'')`
 
 error: calling `insert_str()` using a single-character string literal
-  --> $DIR/single_char_add_str.rs:35:5
+  --> $DIR/single_char_add_str.rs:36:5
    |
 LL |     string.insert_str(0, "/x52");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `insert` with a character literal: `string.insert(0, '/x52')`
 
 error: calling `insert_str()` using a single-character string literal
-  --> $DIR/single_char_add_str.rs:36:5
+  --> $DIR/single_char_add_str.rs:37:5
    |
 LL |     string.insert_str(0, "/u{0052}");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `insert` with a character literal: `string.insert(0, '/u{0052}')`
 
 error: calling `insert_str()` using a single-character string literal
-  --> $DIR/single_char_add_str.rs:38:5
+  --> $DIR/single_char_add_str.rs:39:5
    |
 LL |     string.insert_str(x, r##"a"##);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `insert` with a character literal: `string.insert(x, 'a')`
 
 error: calling `insert_str()` using a single-character string literal
-  --> $DIR/single_char_add_str.rs:40:5
+  --> $DIR/single_char_add_str.rs:41:5
    |
 LL |     string.insert_str(Y, r##"a"##);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `insert` with a character literal: `string.insert(Y, 'a')`
 
 error: calling `insert_str()` using a single-character string literal
-  --> $DIR/single_char_add_str.rs:41:5
+  --> $DIR/single_char_add_str.rs:42:5
    |
 LL |     string.insert_str(Y, r##"""##);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `insert` with a character literal: `string.insert(Y, '"')`
 
 error: calling `insert_str()` using a single-character string literal
-  --> $DIR/single_char_add_str.rs:42:5
+  --> $DIR/single_char_add_str.rs:43:5
    |
 LL |     string.insert_str(Y, r##"'"##);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `insert` with a character literal: `string.insert(Y, '/'')`
 
 error: calling `insert_str()` using a single-character string literal
-  --> $DIR/single_char_add_str.rs:44:5
+  --> $DIR/single_char_add_str.rs:45:5
    |
 LL |     get_string!().insert_str(1, "?");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `insert` with a character literal: `get_string!().insert(1, '?')`
diff --git a/tests/ui/single_char_pattern.fixed b/tests/ui/single_char_pattern.fixed
index dba89872070..f1dc3ea9894 100644
--- a/tests/ui/single_char_pattern.fixed
+++ b/tests/ui/single_char_pattern.fixed
@@ -1,6 +1,6 @@
 //@run-rustfix
 
-#![allow(unused_must_use)]
+#![allow(clippy::needless_raw_string_hashes, unused_must_use)]
 
 use std::collections::HashSet;
 
diff --git a/tests/ui/single_char_pattern.rs b/tests/ui/single_char_pattern.rs
index 6a145a14bfd..00b38498001 100644
--- a/tests/ui/single_char_pattern.rs
+++ b/tests/ui/single_char_pattern.rs
@@ -1,6 +1,6 @@
 //@run-rustfix
 
-#![allow(unused_must_use)]
+#![allow(clippy::needless_raw_string_hashes, unused_must_use)]
 
 use std::collections::HashSet;
 
diff --git a/tests/ui/string_lit_as_bytes.fixed b/tests/ui/string_lit_as_bytes.fixed
index 3fc11b8b088..0edd81acc7a 100644
--- a/tests/ui/string_lit_as_bytes.fixed
+++ b/tests/ui/string_lit_as_bytes.fixed
@@ -1,7 +1,7 @@
 //@run-rustfix
 //@aux-build:macro_rules.rs
 
-#![allow(dead_code, unused_variables)]
+#![allow(clippy::needless_raw_string_hashes, dead_code, unused_variables)]
 #![warn(clippy::string_lit_as_bytes)]
 
 #[macro_use]
diff --git a/tests/ui/string_lit_as_bytes.rs b/tests/ui/string_lit_as_bytes.rs
index 7d54acf630e..2647f02f0e9 100644
--- a/tests/ui/string_lit_as_bytes.rs
+++ b/tests/ui/string_lit_as_bytes.rs
@@ -1,7 +1,7 @@
 //@run-rustfix
 //@aux-build:macro_rules.rs
 
-#![allow(dead_code, unused_variables)]
+#![allow(clippy::needless_raw_string_hashes, dead_code, unused_variables)]
 #![warn(clippy::string_lit_as_bytes)]
 
 #[macro_use]
-- 
cgit 1.4.1-3-g733a5


From bc744eb82bdf9c4ecb21ade5d7b3516f14da29ad Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Thu, 8 Jun 2023 06:55:47 -0500
Subject: new lint `needless_raw_string` + refactor a bit

Thanks, #112373, for the snippet at line 75!
---
 CHANGELOG.md                                       |   1 +
 clippy_lints/src/declared_lints.rs                 |   3 +-
 clippy_lints/src/lib.rs                            |   2 +-
 clippy_lints/src/needless_raw_string_hashes.rs     |  73 --------------
 clippy_lints/src/raw_strings.rs                    | 109 +++++++++++++++++++++
 clippy_lints/src/utils/conf.rs                     |   6 +-
 .../almost_standard_lint_formulation.rs            |   2 +-
 src/main.rs                                        |   2 +-
 tests/lint_message_convention.rs                   |  30 +++---
 .../conf_disallowed_methods.rs                     |   1 +
 .../conf_disallowed_methods.stderr                 |  28 +++---
 .../toml_unknown_key/conf_unknown_key.stderr       |   2 +
 tests/ui/format.stderr                             |  30 +++---
 tests/ui/needless_raw_string.fixed                 |  16 +++
 tests/ui/needless_raw_string.rs                    |  16 +++
 tests/ui/needless_raw_string.stderr                |  22 +++++
 tests/ui/needless_raw_string_hashes.fixed          |   2 +-
 tests/ui/needless_raw_string_hashes.rs             |   2 +-
 tests/ui/regex.rs                                  |   7 +-
 tests/ui/regex.stderr                              |  48 ++++-----
 tests/ui/single_char_add_str.fixed                 |   2 +-
 tests/ui/single_char_add_str.rs                    |   2 +-
 tests/ui/single_char_pattern.fixed                 |   2 +-
 tests/ui/single_char_pattern.rs                    |   2 +-
 tests/ui/write_literal_2.rs                        |   2 +-
 tests/ui/write_literal_2.stderr                    |  10 +-
 26 files changed, 267 insertions(+), 155 deletions(-)
 delete mode 100644 clippy_lints/src/needless_raw_string_hashes.rs
 create mode 100644 clippy_lints/src/raw_strings.rs
 create mode 100644 tests/ui/needless_raw_string.fixed
 create mode 100644 tests/ui/needless_raw_string.rs
 create mode 100644 tests/ui/needless_raw_string.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 7cb820b0c43..5b17072df40 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5048,6 +5048,7 @@ Released 2018-09-13
 [`needless_pass_by_value`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_pass_by_value
 [`needless_question_mark`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_question_mark
 [`needless_range_loop`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_range_loop
+[`needless_raw_string`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_raw_string
 [`needless_raw_string_hashes`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_raw_string_hashes
 [`needless_return`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_return
 [`needless_splitn`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_splitn
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 8753bcee5ce..c67ed14b3b0 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -469,7 +469,6 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::needless_parens_on_range_literals::NEEDLESS_PARENS_ON_RANGE_LITERALS_INFO,
     crate::needless_pass_by_value::NEEDLESS_PASS_BY_VALUE_INFO,
     crate::needless_question_mark::NEEDLESS_QUESTION_MARK_INFO,
-    crate::needless_raw_string_hashes::NEEDLESS_RAW_STRING_HASHES_INFO,
     crate::needless_update::NEEDLESS_UPDATE_INFO,
     crate::neg_cmp_op_on_partial_ord::NEG_CMP_OP_ON_PARTIAL_ORD_INFO,
     crate::neg_multiply::NEG_MULTIPLY_INFO,
@@ -541,6 +540,8 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::ranges::RANGE_MINUS_ONE_INFO,
     crate::ranges::RANGE_PLUS_ONE_INFO,
     crate::ranges::REVERSED_EMPTY_RANGES_INFO,
+    crate::raw_strings::NEEDLESS_RAW_STRING_INFO,
+    crate::raw_strings::NEEDLESS_RAW_STRING_HASHES_INFO,
     crate::rc_clone_in_vec_init::RC_CLONE_IN_VEC_INIT_INFO,
     crate::read_zero_byte_vec::READ_ZERO_BYTE_VEC_INFO,
     crate::redundant_async_block::REDUNDANT_ASYNC_BLOCK_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index aadba6581a1..e1a7eedd93e 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -230,7 +230,6 @@ mod needless_late_init;
 mod needless_parens_on_range_literals;
 mod needless_pass_by_value;
 mod needless_question_mark;
-mod needless_raw_string_hashes;
 mod needless_update;
 mod neg_cmp_op_on_partial_ord;
 mod neg_multiply;
@@ -263,6 +262,7 @@ mod pub_use;
 mod question_mark;
 mod question_mark_used;
 mod ranges;
+mod raw_strings;
 mod rc_clone_in_vec_init;
 mod read_zero_byte_vec;
 mod redundant_async_block;
diff --git a/clippy_lints/src/needless_raw_string_hashes.rs b/clippy_lints/src/needless_raw_string_hashes.rs
deleted file mode 100644
index 85dffa5613d..00000000000
--- a/clippy_lints/src/needless_raw_string_hashes.rs
+++ /dev/null
@@ -1,73 +0,0 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
-use rustc_ast::{
-    ast::{Expr, ExprKind},
-    token::LitKind,
-};
-use rustc_errors::Applicability;
-use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
-use rustc_middle::lint::in_external_macro;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for raw string literals with an unnecessary amount of hashes around them.
-    ///
-    /// ### Why is this bad?
-    /// It's just unnecessary, and makes it look like there's more escaping needed than is actually
-    /// necessary.
-    ///
-    /// ### Example
-    /// ```rust
-    /// let r = r###"Hello, "world"!"###;
-    /// ```
-    /// Use instead:
-    /// ```rust
-    /// let r = r#"Hello, "world"!"#;
-    /// ```
-    #[clippy::version = "1.72.0"]
-    pub NEEDLESS_RAW_STRING_HASHES,
-    complexity,
-    "suggests reducing the number of hashes around a raw string literal"
-}
-declare_lint_pass!(NeedlessRawStringHashes => [NEEDLESS_RAW_STRING_HASHES]);
-
-impl EarlyLintPass for NeedlessRawStringHashes {
-    fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
-        if_chain! {
-            if !in_external_macro(cx.sess(), expr.span);
-            if let ExprKind::Lit(lit) = expr.kind;
-            if let LitKind::StrRaw(num) | LitKind::ByteStrRaw(num) | LitKind::CStrRaw(num) = lit.kind;
-            then {
-                let str = lit.symbol.as_str();
-                let mut lowest = 0;
-
-                for i in (0..num).rev() {
-                    if str.contains(&format!("\"{}", "#".repeat(i as usize))) {
-                        lowest = i + 1;
-                        break;
-                    }
-                }
-
-                if lowest < num {
-                    let hashes = "#".repeat(lowest as usize);
-                    let prefix = match lit.kind {
-                        LitKind::StrRaw(..) => "r",
-                        LitKind::ByteStrRaw(..) => "br",
-                        LitKind::CStrRaw(..) => "cr",
-                        _ => unreachable!(),
-                    };
-
-                    span_lint_and_sugg(
-                        cx,
-                        NEEDLESS_RAW_STRING_HASHES,
-                        expr.span,
-                        "unnecessary hashes around raw string literal",
-                        "try",
-                        format!(r#"{prefix}{hashes}"{}"{hashes}"#, lit.symbol),
-                        Applicability::MachineApplicable,
-                    );
-                }
-            }
-        }
-    }
-}
diff --git a/clippy_lints/src/raw_strings.rs b/clippy_lints/src/raw_strings.rs
new file mode 100644
index 00000000000..52814693f3c
--- /dev/null
+++ b/clippy_lints/src/raw_strings.rs
@@ -0,0 +1,109 @@
+use clippy_utils::{diagnostics::span_lint_and_sugg, source::snippet};
+use rustc_ast::{
+    ast::{Expr, ExprKind},
+    token::LitKind,
+};
+use rustc_errors::Applicability;
+use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
+use rustc_middle::lint::in_external_macro;
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for raw string literals where a string literal can be used instead.
+    ///
+    /// ### Why is this bad?
+    /// It's just unnecessary.
+    ///
+    /// ### Example
+    /// ```rust
+    /// let r = r"Hello, world!";
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// let r = "Hello, world!";
+    /// ```
+    #[clippy::version = "1.72.0"]
+    pub NEEDLESS_RAW_STRING,
+    complexity,
+    "suggests using a string literal when a raw string literal is unnecessary"
+}
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for raw string literals with an unnecessary amount of hashes around them.
+    ///
+    /// ### Why is this bad?
+    /// It's just unnecessary, and makes it look like there's more escaping needed than is actually
+    /// necessary.
+    ///
+    /// ### Example
+    /// ```rust
+    /// let r = r###"Hello, "world"!"###;
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// let r = r#"Hello, "world"!"#;
+    /// ```
+    #[clippy::version = "1.72.0"]
+    pub NEEDLESS_RAW_STRING_HASHES,
+    complexity,
+    "suggests reducing the number of hashes around a raw string literal"
+}
+impl_lint_pass!(RawStrings => [NEEDLESS_RAW_STRING, NEEDLESS_RAW_STRING_HASHES]);
+
+pub struct RawStrings {
+    pub needless_raw_string_hashes_allow_one: bool,
+}
+
+impl EarlyLintPass for RawStrings {
+    fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
+        if !in_external_macro(cx.sess(), expr.span)
+            && let ExprKind::Lit(lit) = expr.kind
+            && let LitKind::StrRaw(num) | LitKind::ByteStrRaw(num) | LitKind::CStrRaw(num) = lit.kind
+        {
+            let prefix = match lit.kind {
+                LitKind::StrRaw(..) => "r",
+                LitKind::ByteStrRaw(..) => "br",
+                LitKind::CStrRaw(..) => "cr",
+                _ => unreachable!(),
+            };
+            if !snippet(cx, expr.span, prefix).trim().starts_with(prefix) {
+                return;
+            }
+
+            #[allow(clippy::cast_possible_truncation)]
+            let req = lit.symbol.as_str().as_bytes()
+                .split(|&b| b == b'"')
+                .skip(1)
+                .map(|bs| 1 + bs.iter().take_while(|&&b| b == b'#').count() as u8)
+                .max()
+                .unwrap_or(0);
+
+            if req < num {
+                let hashes = "#".repeat(req as usize);
+
+                span_lint_and_sugg(
+                    cx,
+                    NEEDLESS_RAW_STRING_HASHES,
+                    expr.span,
+                    "unnecessary hashes around raw string literal",
+                    "try",
+                    format!(r#"{prefix}{hashes}"{}"{hashes}"#, lit.symbol),
+                    Applicability::MachineApplicable,
+                );
+            }
+
+            if !lit.symbol.as_str().contains(['\\', '"']) {
+                span_lint_and_sugg(
+                    cx,
+                    NEEDLESS_RAW_STRING,
+                    expr.span,
+                    "unnecessary raw string literal",
+                    "try",
+                    format!("{}\"{}\"", prefix.replace('r', ""), lit.symbol),
+                    Applicability::MachineApplicable,
+                );
+            }
+        }
+    }
+}
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 12197666b30..9f88960f7ce 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -543,10 +543,14 @@ define_Conf! {
     ///
     /// Whether to accept a safety comment to be placed above the statement containing the `unsafe` block
     (accept_comment_above_statement: bool = false),
-        /// Lint: UNDOCUMENTED_UNSAFE_BLOCKS.
+    /// Lint: UNDOCUMENTED_UNSAFE_BLOCKS.
     ///
     /// Whether to accept a safety comment to be placed above the attributes for the `unsafe` block
     (accept_comment_above_attributes: bool = false),
+    /// Lint: UNNECESSARY_RAW_STRING_HASHES.
+    ///
+    /// Whether to allow `r#""#` when `r""` can be used
+    (allow_one_hash_in_raw_string: bool = false),
 }
 
 /// Search for the configuration file.
diff --git a/clippy_lints/src/utils/internal_lints/almost_standard_lint_formulation.rs b/clippy_lints/src/utils/internal_lints/almost_standard_lint_formulation.rs
index e4cb5316a98..570a88a0ed2 100644
--- a/clippy_lints/src/utils/internal_lints/almost_standard_lint_formulation.rs
+++ b/clippy_lints/src/utils/internal_lints/almost_standard_lint_formulation.rs
@@ -35,7 +35,7 @@ struct StandardFormulations<'a> {
 impl AlmostStandardFormulation {
     pub fn new() -> Self {
         let standard_formulations = vec![StandardFormulations {
-            wrong_pattern: Regex::new(r"^(Check for|Detects? uses?)").unwrap(),
+            wrong_pattern: Regex::new("^(Check for|Detects? uses?)").unwrap(),
             correction: "Checks for",
         }];
         Self { standard_formulations }
diff --git a/src/main.rs b/src/main.rs
index fd0da5a170b..cdc85cb33ca 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -6,7 +6,7 @@ use std::env;
 use std::path::PathBuf;
 use std::process::{self, Command};
 
-const CARGO_CLIPPY_HELP: &str = r"Checks a package to catch common mistakes and improve your Rust code.
+const CARGO_CLIPPY_HELP: &str = "Checks a package to catch common mistakes and improve your Rust code.
 
 Usage:
     cargo clippy [options] [--] [<opts>...]
diff --git a/tests/lint_message_convention.rs b/tests/lint_message_convention.rs
index 8feea800fdb..15e5cdd6992 100644
--- a/tests/lint_message_convention.rs
+++ b/tests/lint_message_convention.rs
@@ -20,16 +20,16 @@ impl Message {
         // also no punctuation (except for "?" ?) at the end of a line
         static REGEX_SET: LazyLock<RegexSet> = LazyLock::new(|| {
             RegexSet::new([
-                r"error: [A-Z]",
-                r"help: [A-Z]",
-                r"warning: [A-Z]",
-                r"note: [A-Z]",
-                r"try this: [A-Z]",
-                r"error: .*[.!]$",
-                r"help: .*[.!]$",
-                r"warning: .*[.!]$",
-                r"note: .*[.!]$",
-                r"try this: .*[.!]$",
+                "error: [A-Z]",
+                "help: [A-Z]",
+                "warning: [A-Z]",
+                "note: [A-Z]",
+                "try this: [A-Z]",
+                "error: .*[.!]$",
+                "help: .*[.!]$",
+                "warning: .*[.!]$",
+                "note: .*[.!]$",
+                "try this: .*[.!]$",
             ])
             .unwrap()
         });
@@ -39,11 +39,11 @@ impl Message {
         static EXCEPTIONS_SET: LazyLock<RegexSet> = LazyLock::new(|| {
             RegexSet::new([
                 r"\.\.\.$",
-                r".*C-like enum variant discriminant is not portable to 32-bit targets",
-                r".*Intel x86 assembly syntax used",
-                r".*AT&T x86 assembly syntax used",
-                r"note: Clippy version: .*",
-                r"the compiler unexpectedly panicked. this is a bug.",
+                ".*C-like enum variant discriminant is not portable to 32-bit targets",
+                ".*Intel x86 assembly syntax used",
+                ".*AT&T x86 assembly syntax used",
+                "note: Clippy version: .*",
+                "the compiler unexpectedly panicked. this is a bug.",
             ])
             .unwrap()
         });
diff --git a/tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.rs b/tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.rs
index ebbc7fea328..d26bc72787b 100644
--- a/tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.rs
+++ b/tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.rs
@@ -1,5 +1,6 @@
 //@compile-flags: --crate-name conf_disallowed_methods
 
+#![allow(clippy::needless_raw_string)]
 #![warn(clippy::disallowed_methods)]
 #![allow(clippy::useless_vec)]
 
diff --git a/tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.stderr b/tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.stderr
index 3dc83a40780..fc137c225d8 100644
--- a/tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.stderr
+++ b/tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.stderr
@@ -1,5 +1,5 @@
 error: use of a disallowed method `regex::Regex::new`
-  --> $DIR/conf_disallowed_methods.rs:34:14
+  --> $DIR/conf_disallowed_methods.rs:35:14
    |
 LL |     let re = Regex::new(r"ab.*c").unwrap();
    |              ^^^^^^^^^^^^^^^^^^^^
@@ -7,7 +7,7 @@ LL |     let re = Regex::new(r"ab.*c").unwrap();
    = note: `-D clippy::disallowed-methods` implied by `-D warnings`
 
 error: use of a disallowed method `regex::Regex::is_match`
-  --> $DIR/conf_disallowed_methods.rs:35:5
+  --> $DIR/conf_disallowed_methods.rs:36:5
    |
 LL |     re.is_match("abc");
    |     ^^^^^^^^^^^^^^^^^^
@@ -15,73 +15,73 @@ LL |     re.is_match("abc");
    = note: no matching allowed (from clippy.toml)
 
 error: use of a disallowed method `std::iter::Iterator::sum`
-  --> $DIR/conf_disallowed_methods.rs:38:5
+  --> $DIR/conf_disallowed_methods.rs:39:5
    |
 LL |     a.iter().sum::<i32>();
    |     ^^^^^^^^^^^^^^^^^^^^^
 
 error: use of a disallowed method `slice::sort_unstable`
-  --> $DIR/conf_disallowed_methods.rs:40:5
+  --> $DIR/conf_disallowed_methods.rs:41:5
    |
 LL |     a.sort_unstable();
    |     ^^^^^^^^^^^^^^^^^
 
 error: use of a disallowed method `f32::clamp`
-  --> $DIR/conf_disallowed_methods.rs:42:13
+  --> $DIR/conf_disallowed_methods.rs:43:13
    |
 LL |     let _ = 2.0f32.clamp(3.0f32, 4.0f32);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: use of a disallowed method `regex::Regex::new`
-  --> $DIR/conf_disallowed_methods.rs:45:61
+  --> $DIR/conf_disallowed_methods.rs:46:61
    |
 LL |     let indirect: fn(&str) -> Result<Regex, regex::Error> = Regex::new;
    |                                                             ^^^^^^^^^^
 
 error: use of a disallowed method `f32::clamp`
-  --> $DIR/conf_disallowed_methods.rs:48:28
+  --> $DIR/conf_disallowed_methods.rs:49:28
    |
 LL |     let in_call = Box::new(f32::clamp);
    |                            ^^^^^^^^^^
 
 error: use of a disallowed method `regex::Regex::new`
-  --> $DIR/conf_disallowed_methods.rs:49:53
+  --> $DIR/conf_disallowed_methods.rs:50:53
    |
 LL |     let in_method_call = ["^", "$"].into_iter().map(Regex::new);
    |                                                     ^^^^^^^^^^
 
 error: use of a disallowed method `futures::stream::select_all`
-  --> $DIR/conf_disallowed_methods.rs:52:31
+  --> $DIR/conf_disallowed_methods.rs:53:31
    |
 LL |     let same_name_as_module = select_all(vec![empty::<()>()]);
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: use of a disallowed method `conf_disallowed_methods::local_fn`
-  --> $DIR/conf_disallowed_methods.rs:54:5
+  --> $DIR/conf_disallowed_methods.rs:55:5
    |
 LL |     local_fn();
    |     ^^^^^^^^^^
 
 error: use of a disallowed method `conf_disallowed_methods::local_mod::f`
-  --> $DIR/conf_disallowed_methods.rs:55:5
+  --> $DIR/conf_disallowed_methods.rs:56:5
    |
 LL |     local_mod::f();
    |     ^^^^^^^^^^^^^^
 
 error: use of a disallowed method `conf_disallowed_methods::Struct::method`
-  --> $DIR/conf_disallowed_methods.rs:57:5
+  --> $DIR/conf_disallowed_methods.rs:58:5
    |
 LL |     s.method();
    |     ^^^^^^^^^^
 
 error: use of a disallowed method `conf_disallowed_methods::Trait::provided_method`
-  --> $DIR/conf_disallowed_methods.rs:58:5
+  --> $DIR/conf_disallowed_methods.rs:59:5
    |
 LL |     s.provided_method();
    |     ^^^^^^^^^^^^^^^^^^^
 
 error: use of a disallowed method `conf_disallowed_methods::Trait::implemented_method`
-  --> $DIR/conf_disallowed_methods.rs:59:5
+  --> $DIR/conf_disallowed_methods.rs:60:5
    |
 LL |     s.implemented_method();
    |     ^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
index 69678057917..8724dc29d29 100644
--- a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
+++ b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
@@ -4,6 +4,7 @@ error: error reading Clippy's configuration file: unknown field `foobar`, expect
            allow-dbg-in-tests
            allow-expect-in-tests
            allow-mixed-uninlined-format-args
+           allow-one-hash-in-raw-string
            allow-print-in-tests
            allow-private-module-inception
            allow-unwrap-in-tests
@@ -72,6 +73,7 @@ error: error reading Clippy's configuration file: unknown field `barfoo`, expect
            allow-dbg-in-tests
            allow-expect-in-tests
            allow-mixed-uninlined-format-args
+           allow-one-hash-in-raw-string
            allow-print-in-tests
            allow-private-module-inception
            allow-unwrap-in-tests
diff --git a/tests/ui/format.stderr b/tests/ui/format.stderr
index f456c11924e..78a11a3354f 100644
--- a/tests/ui/format.stderr
+++ b/tests/ui/format.stderr
@@ -1,5 +1,5 @@
 error: useless use of `format!`
-  --> $DIR/format.rs:20:5
+  --> $DIR/format.rs:21:5
    |
 LL |     format!("foo");
    |     ^^^^^^^^^^^^^^ help: consider using `.to_string()`: `"foo".to_string()`
@@ -7,19 +7,19 @@ LL |     format!("foo");
    = note: `-D clippy::useless-format` implied by `-D warnings`
 
 error: useless use of `format!`
-  --> $DIR/format.rs:21:5
+  --> $DIR/format.rs:22:5
    |
 LL |     format!("{{}}");
    |     ^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `"{}".to_string()`
 
 error: useless use of `format!`
-  --> $DIR/format.rs:22:5
+  --> $DIR/format.rs:23:5
    |
 LL |     format!("{{}} abc {{}}");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `"{} abc {}".to_string()`
 
 error: useless use of `format!`
-  --> $DIR/format.rs:23:5
+  --> $DIR/format.rs:24:5
    |
 LL | /     format!(
 LL | |         r##"foo {{}}
@@ -34,67 +34,67 @@ LL ~ " bar"##.to_string();
    |
 
 error: useless use of `format!`
-  --> $DIR/format.rs:28:13
+  --> $DIR/format.rs:29:13
    |
 LL |     let _ = format!("");
    |             ^^^^^^^^^^^ help: consider using `String::new()`: `String::new()`
 
 error: useless use of `format!`
-  --> $DIR/format.rs:30:5
+  --> $DIR/format.rs:31:5
    |
 LL |     format!("{}", "foo");
    |     ^^^^^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `"foo".to_string()`
 
 error: useless use of `format!`
-  --> $DIR/format.rs:38:5
+  --> $DIR/format.rs:39:5
    |
 LL |     format!("{}", arg);
    |     ^^^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `arg.to_string()`
 
 error: useless use of `format!`
-  --> $DIR/format.rs:68:5
+  --> $DIR/format.rs:69:5
    |
 LL |     format!("{}", 42.to_string());
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `42.to_string()`
 
 error: useless use of `format!`
-  --> $DIR/format.rs:70:5
+  --> $DIR/format.rs:71:5
    |
 LL |     format!("{}", x.display().to_string());
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `x.display().to_string()`
 
 error: useless use of `format!`
-  --> $DIR/format.rs:74:18
+  --> $DIR/format.rs:75:18
    |
 LL |     let _ = Some(format!("{}", a + "bar"));
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `a + "bar"`
 
 error: useless use of `format!`
-  --> $DIR/format.rs:78:22
+  --> $DIR/format.rs:79:22
    |
 LL |     let _s: String = format!("{}", &*v.join("/n"));
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `(&*v.join("/n")).to_string()`
 
 error: useless use of `format!`
-  --> $DIR/format.rs:84:13
+  --> $DIR/format.rs:85:13
    |
 LL |     let _ = format!("{x}");
    |             ^^^^^^^^^^^^^^ help: consider using `.to_string()`: `x.to_string()`
 
 error: useless use of `format!`
-  --> $DIR/format.rs:86:13
+  --> $DIR/format.rs:87:13
    |
 LL |     let _ = format!("{y}", y = x);
    |             ^^^^^^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `x.to_string()`
 
 error: useless use of `format!`
-  --> $DIR/format.rs:90:13
+  --> $DIR/format.rs:91:13
    |
 LL |     let _ = format!("{abc}");
    |             ^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `abc.to_string()`
 
 error: useless use of `format!`
-  --> $DIR/format.rs:92:13
+  --> $DIR/format.rs:93:13
    |
 LL |     let _ = format!("{xx}");
    |             ^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `xx.to_string()`
diff --git a/tests/ui/needless_raw_string.fixed b/tests/ui/needless_raw_string.fixed
new file mode 100644
index 00000000000..ffc1644335d
--- /dev/null
+++ b/tests/ui/needless_raw_string.fixed
@@ -0,0 +1,16 @@
+//@run-rustfix
+#![allow(clippy::needless_raw_string_hashes, clippy::no_effect, unused)]
+#![warn(clippy::needless_raw_string)]
+#![feature(c_str_literals)]
+
+fn main() {
+    "aaa";
+    r#""aaa""#;
+    r#"\s"#;
+    b"aaa";
+    br#""aaa""#;
+    br#"\s"#;
+    c"aaa";
+    cr#""aaa""#;
+    cr#"\s"#;
+}
diff --git a/tests/ui/needless_raw_string.rs b/tests/ui/needless_raw_string.rs
new file mode 100644
index 00000000000..b06b9a0ec85
--- /dev/null
+++ b/tests/ui/needless_raw_string.rs
@@ -0,0 +1,16 @@
+//@run-rustfix
+#![allow(clippy::needless_raw_string_hashes, clippy::no_effect, unused)]
+#![warn(clippy::needless_raw_string)]
+#![feature(c_str_literals)]
+
+fn main() {
+    r#"aaa"#;
+    r#""aaa""#;
+    r#"\s"#;
+    br#"aaa"#;
+    br#""aaa""#;
+    br#"\s"#;
+    cr#"aaa"#;
+    cr#""aaa""#;
+    cr#"\s"#;
+}
diff --git a/tests/ui/needless_raw_string.stderr b/tests/ui/needless_raw_string.stderr
new file mode 100644
index 00000000000..3eb699dea36
--- /dev/null
+++ b/tests/ui/needless_raw_string.stderr
@@ -0,0 +1,22 @@
+error: unnecessary raw string literal
+  --> $DIR/needless_raw_string.rs:7:5
+   |
+LL |     r#"aaa"#;
+   |     ^^^^^^^^ help: try: `"aaa"`
+   |
+   = note: `-D clippy::needless-raw-string` implied by `-D warnings`
+
+error: unnecessary raw string literal
+  --> $DIR/needless_raw_string.rs:10:5
+   |
+LL |     br#"aaa"#;
+   |     ^^^^^^^^^ help: try: `b"aaa"`
+
+error: unnecessary raw string literal
+  --> $DIR/needless_raw_string.rs:13:5
+   |
+LL |     cr#"aaa"#;
+   |     ^^^^^^^^^ help: try: `c"aaa"`
+
+error: aborting due to 3 previous errors
+
diff --git a/tests/ui/needless_raw_string_hashes.fixed b/tests/ui/needless_raw_string_hashes.fixed
index 43616860a2e..1bfb573719d 100644
--- a/tests/ui/needless_raw_string_hashes.fixed
+++ b/tests/ui/needless_raw_string_hashes.fixed
@@ -1,5 +1,5 @@
 //@run-rustfix
-#![allow(clippy::no_effect, unused)]
+#![allow(clippy::needless_raw_string, clippy::no_effect, unused)]
 #![warn(clippy::needless_raw_string_hashes)]
 #![feature(c_str_literals)]
 
diff --git a/tests/ui/needless_raw_string_hashes.rs b/tests/ui/needless_raw_string_hashes.rs
index e2d85c52e78..dedd774ea0a 100644
--- a/tests/ui/needless_raw_string_hashes.rs
+++ b/tests/ui/needless_raw_string_hashes.rs
@@ -1,5 +1,5 @@
 //@run-rustfix
-#![allow(clippy::no_effect, unused)]
+#![allow(clippy::needless_raw_string, clippy::no_effect, unused)]
 #![warn(clippy::needless_raw_string_hashes)]
 #![feature(c_str_literals)]
 
diff --git a/tests/ui/regex.rs b/tests/ui/regex.rs
index 3b208651946..850c9813462 100644
--- a/tests/ui/regex.rs
+++ b/tests/ui/regex.rs
@@ -1,4 +1,9 @@
-#![allow(unused, clippy::needless_raw_string_hashes, clippy::needless_borrow)]
+#![allow(
+    unused,
+    clippy::needless_raw_string,
+    clippy::needless_raw_string_hashes,
+    clippy::needless_borrow
+)]
 #![warn(clippy::invalid_regex, clippy::trivial_regex)]
 
 extern crate regex;
diff --git a/tests/ui/regex.stderr b/tests/ui/regex.stderr
index c74dc8108fe..21f1cb44460 100644
--- a/tests/ui/regex.stderr
+++ b/tests/ui/regex.stderr
@@ -1,5 +1,5 @@
 error: trivial regex
-  --> $DIR/regex.rs:13:45
+  --> $DIR/regex.rs:18:45
    |
 LL |     let pipe_in_wrong_position = Regex::new("|");
    |                                             ^^^
@@ -8,7 +8,7 @@ LL |     let pipe_in_wrong_position = Regex::new("|");
    = note: `-D clippy::trivial-regex` implied by `-D warnings`
 
 error: trivial regex
-  --> $DIR/regex.rs:14:60
+  --> $DIR/regex.rs:19:60
    |
 LL |     let pipe_in_wrong_position_builder = RegexBuilder::new("|");
    |                                                            ^^^
@@ -16,7 +16,7 @@ LL |     let pipe_in_wrong_position_builder = RegexBuilder::new("|");
    = help: the regex is unlikely to be useful as it is
 
 error: regex syntax error: invalid character class range, the start must be <= the end
-  --> $DIR/regex.rs:15:42
+  --> $DIR/regex.rs:20:42
    |
 LL |     let wrong_char_ranice = Regex::new("[z-a]");
    |                                          ^^^
@@ -24,7 +24,7 @@ LL |     let wrong_char_ranice = Regex::new("[z-a]");
    = note: `-D clippy::invalid-regex` implied by `-D warnings`
 
 error: regex syntax error: invalid character class range, the start must be <= the end
-  --> $DIR/regex.rs:16:37
+  --> $DIR/regex.rs:21:37
    |
 LL |     let some_unicode = Regex::new("[é-è]");
    |                                     ^^^
@@ -33,13 +33,13 @@ error: regex parse error:
            (
            ^
        error: unclosed group
-  --> $DIR/regex.rs:18:33
+  --> $DIR/regex.rs:23:33
    |
 LL |     let some_regex = Regex::new(OPENING_PAREN);
    |                                 ^^^^^^^^^^^^^
 
 error: trivial regex
-  --> $DIR/regex.rs:20:53
+  --> $DIR/regex.rs:25:53
    |
 LL |     let binary_pipe_in_wrong_position = BRegex::new("|");
    |                                                     ^^^
@@ -50,7 +50,7 @@ error: regex parse error:
            (
            ^
        error: unclosed group
-  --> $DIR/regex.rs:21:41
+  --> $DIR/regex.rs:26:41
    |
 LL |     let some_binary_regex = BRegex::new(OPENING_PAREN);
    |                                         ^^^^^^^^^^^^^
@@ -59,7 +59,7 @@ error: regex parse error:
            (
            ^
        error: unclosed group
-  --> $DIR/regex.rs:22:56
+  --> $DIR/regex.rs:27:56
    |
 LL |     let some_binary_regex_builder = BRegexBuilder::new(OPENING_PAREN);
    |                                                        ^^^^^^^^^^^^^
@@ -68,7 +68,7 @@ error: regex parse error:
            (
            ^
        error: unclosed group
-  --> $DIR/regex.rs:34:37
+  --> $DIR/regex.rs:39:37
    |
 LL |     let set_error = RegexSet::new(&[OPENING_PAREN, r"[a-z]+/.(com|org|net)"]);
    |                                     ^^^^^^^^^^^^^
@@ -77,7 +77,7 @@ error: regex parse error:
            (
            ^
        error: unclosed group
-  --> $DIR/regex.rs:35:39
+  --> $DIR/regex.rs:40:39
    |
 LL |     let bset_error = BRegexSet::new(&[OPENING_PAREN, r"[a-z]+/.(com|org|net)"]);
    |                                       ^^^^^^^^^^^^^
@@ -86,7 +86,7 @@ error: regex parse error:
            /b/c
              ^^
        error: unrecognized escape sequence
-  --> $DIR/regex.rs:42:42
+  --> $DIR/regex.rs:47:42
    |
 LL |     let escaped_string_span = Regex::new("//b//c");
    |                                          ^^^^^^^^
@@ -94,19 +94,19 @@ LL |     let escaped_string_span = Regex::new("//b//c");
    = help: consider using a raw string literal: `r".."`
 
 error: regex syntax error: duplicate flag
-  --> $DIR/regex.rs:44:34
+  --> $DIR/regex.rs:49:34
    |
 LL |     let aux_span = Regex::new("(?ixi)");
    |                                  ^ ^
 
 error: regex syntax error: pattern can match invalid UTF-8
-  --> $DIR/regex.rs:49:53
+  --> $DIR/regex.rs:54:53
    |
 LL |     let invalid_utf8_should_lint = Regex::new("(?-u).");
    |                                                     ^
 
 error: trivial regex
-  --> $DIR/regex.rs:53:33
+  --> $DIR/regex.rs:58:33
    |
 LL |     let trivial_eq = Regex::new("^foobar$");
    |                                 ^^^^^^^^^^
@@ -114,7 +114,7 @@ LL |     let trivial_eq = Regex::new("^foobar$");
    = help: consider using `==` on `str`s
 
 error: trivial regex
-  --> $DIR/regex.rs:55:48
+  --> $DIR/regex.rs:60:48
    |
 LL |     let trivial_eq_builder = RegexBuilder::new("^foobar$");
    |                                                ^^^^^^^^^^
@@ -122,7 +122,7 @@ LL |     let trivial_eq_builder = RegexBuilder::new("^foobar$");
    = help: consider using `==` on `str`s
 
 error: trivial regex
-  --> $DIR/regex.rs:57:42
+  --> $DIR/regex.rs:62:42
    |
 LL |     let trivial_starts_with = Regex::new("^foobar");
    |                                          ^^^^^^^^^
@@ -130,7 +130,7 @@ LL |     let trivial_starts_with = Regex::new("^foobar");
    = help: consider using `str::starts_with`
 
 error: trivial regex
-  --> $DIR/regex.rs:59:40
+  --> $DIR/regex.rs:64:40
    |
 LL |     let trivial_ends_with = Regex::new("foobar$");
    |                                        ^^^^^^^^^
@@ -138,7 +138,7 @@ LL |     let trivial_ends_with = Regex::new("foobar$");
    = help: consider using `str::ends_with`
 
 error: trivial regex
-  --> $DIR/regex.rs:61:39
+  --> $DIR/regex.rs:66:39
    |
 LL |     let trivial_contains = Regex::new("foobar");
    |                                       ^^^^^^^^
@@ -146,7 +146,7 @@ LL |     let trivial_contains = Regex::new("foobar");
    = help: consider using `str::contains`
 
 error: trivial regex
-  --> $DIR/regex.rs:63:39
+  --> $DIR/regex.rs:68:39
    |
 LL |     let trivial_contains = Regex::new(NOT_A_REAL_REGEX);
    |                                       ^^^^^^^^^^^^^^^^
@@ -154,7 +154,7 @@ LL |     let trivial_contains = Regex::new(NOT_A_REAL_REGEX);
    = help: consider using `str::contains`
 
 error: trivial regex
-  --> $DIR/regex.rs:65:40
+  --> $DIR/regex.rs:70:40
    |
 LL |     let trivial_backslash = Regex::new("a//.b");
    |                                        ^^^^^^^
@@ -162,7 +162,7 @@ LL |     let trivial_backslash = Regex::new("a//.b");
    = help: consider using `str::contains`
 
 error: trivial regex
-  --> $DIR/regex.rs:68:36
+  --> $DIR/regex.rs:73:36
    |
 LL |     let trivial_empty = Regex::new("");
    |                                    ^^
@@ -170,7 +170,7 @@ LL |     let trivial_empty = Regex::new("");
    = help: the regex is unlikely to be useful as it is
 
 error: trivial regex
-  --> $DIR/regex.rs:70:36
+  --> $DIR/regex.rs:75:36
    |
 LL |     let trivial_empty = Regex::new("^");
    |                                    ^^^
@@ -178,7 +178,7 @@ LL |     let trivial_empty = Regex::new("^");
    = help: the regex is unlikely to be useful as it is
 
 error: trivial regex
-  --> $DIR/regex.rs:72:36
+  --> $DIR/regex.rs:77:36
    |
 LL |     let trivial_empty = Regex::new("^$");
    |                                    ^^^^
@@ -186,7 +186,7 @@ LL |     let trivial_empty = Regex::new("^$");
    = help: consider using `str::is_empty`
 
 error: trivial regex
-  --> $DIR/regex.rs:74:44
+  --> $DIR/regex.rs:79:44
    |
 LL |     let binary_trivial_empty = BRegex::new("^$");
    |                                            ^^^^
diff --git a/tests/ui/single_char_add_str.fixed b/tests/ui/single_char_add_str.fixed
index 2d4c0841219..ee0177776bf 100644
--- a/tests/ui/single_char_add_str.fixed
+++ b/tests/ui/single_char_add_str.fixed
@@ -1,6 +1,6 @@
 //@run-rustfix
 #![warn(clippy::single_char_add_str)]
-#![allow(clippy::needless_raw_string_hashes)]
+#![allow(clippy::needless_raw_string, clippy::needless_raw_string_hashes)]
 
 macro_rules! get_string {
     () => {
diff --git a/tests/ui/single_char_add_str.rs b/tests/ui/single_char_add_str.rs
index 463b19da09e..e3b7d8597c2 100644
--- a/tests/ui/single_char_add_str.rs
+++ b/tests/ui/single_char_add_str.rs
@@ -1,6 +1,6 @@
 //@run-rustfix
 #![warn(clippy::single_char_add_str)]
-#![allow(clippy::needless_raw_string_hashes)]
+#![allow(clippy::needless_raw_string, clippy::needless_raw_string_hashes)]
 
 macro_rules! get_string {
     () => {
diff --git a/tests/ui/single_char_pattern.fixed b/tests/ui/single_char_pattern.fixed
index f1dc3ea9894..920d43318ae 100644
--- a/tests/ui/single_char_pattern.fixed
+++ b/tests/ui/single_char_pattern.fixed
@@ -1,6 +1,6 @@
 //@run-rustfix
 
-#![allow(clippy::needless_raw_string_hashes, unused_must_use)]
+#![allow(clippy::needless_raw_string, clippy::needless_raw_string_hashes, unused_must_use)]
 
 use std::collections::HashSet;
 
diff --git a/tests/ui/single_char_pattern.rs b/tests/ui/single_char_pattern.rs
index 00b38498001..3a53084e30b 100644
--- a/tests/ui/single_char_pattern.rs
+++ b/tests/ui/single_char_pattern.rs
@@ -1,6 +1,6 @@
 //@run-rustfix
 
-#![allow(clippy::needless_raw_string_hashes, unused_must_use)]
+#![allow(clippy::needless_raw_string, clippy::needless_raw_string_hashes, unused_must_use)]
 
 use std::collections::HashSet;
 
diff --git a/tests/ui/write_literal_2.rs b/tests/ui/write_literal_2.rs
index 55a11daa1d3..1d9b9603bd8 100644
--- a/tests/ui/write_literal_2.rs
+++ b/tests/ui/write_literal_2.rs
@@ -1,5 +1,5 @@
 #![allow(unused_must_use)]
-#![warn(clippy::write_literal)]
+#![warn(clippy::needless_raw_string, clippy::write_literal)]
 
 use std::io::Write;
 
diff --git a/tests/ui/write_literal_2.stderr b/tests/ui/write_literal_2.stderr
index bf22738480d..a69d031b011 100644
--- a/tests/ui/write_literal_2.stderr
+++ b/tests/ui/write_literal_2.stderr
@@ -1,3 +1,11 @@
+error: unnecessary raw string literal
+  --> $DIR/write_literal_2.rs:10:24
+   |
+LL |     writeln!(v, r"{}", r"{hello}");
+   |                        ^^^^^^^^^^ help: try: `"{hello}"`
+   |
+   = note: `-D clippy::needless-raw-string` implied by `-D warnings`
+
 error: literal with an empty format string
   --> $DIR/write_literal_2.rs:9:23
    |
@@ -186,5 +194,5 @@ error: literal with an empty format string
 LL |     writeln!(v, r#"{}{}"#, '#', '"'); // hard mode
    |                                 ^^^
 
-error: aborting due to 17 previous errors
+error: aborting due to 18 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From ec765d951611c680e9351cd04c959568979ce231 Mon Sep 17 00:00:00 2001
From: Catherine <114838443+Centri3@users.noreply.github.com>
Date: Thu, 8 Jun 2023 07:24:16 -0500
Subject: Update raw_strings.rs

---
 clippy_lints/src/raw_strings.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/raw_strings.rs b/clippy_lints/src/raw_strings.rs
index 52814693f3c..81afe18ebc6 100644
--- a/clippy_lints/src/raw_strings.rs
+++ b/clippy_lints/src/raw_strings.rs
@@ -71,7 +71,7 @@ impl EarlyLintPass for RawStrings {
                 return;
             }
 
-            #[allow(clippy::cast_possible_truncation)]
+            #[expect(clippy::cast_possible_truncation)]
             let req = lit.symbol.as_str().as_bytes()
                 .split(|&b| b == b'"')
                 .skip(1)
-- 
cgit 1.4.1-3-g733a5


From cb52d19ce106f2ba2c4e1cca860757170c1db2ed Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Fri, 9 Jun 2023 21:40:09 -0500
Subject: don't lint `needless_raw_string_hashes` when it's unnecessary

---
 CHANGELOG.md                               |  1 +
 book/src/lint_configuration.md             | 10 ++++++++++
 clippy_lints/src/raw_strings.rs            | 26 ++++++++++++++------------
 tests/ui/needless_raw_string_hashes.fixed  |  6 +++---
 tests/ui/needless_raw_string_hashes.stderr | 24 +++---------------------
 5 files changed, 31 insertions(+), 36 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5b17072df40..e81e87bf077 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5414,4 +5414,5 @@ Released 2018-09-13
 [`min-ident-chars-threshold`]: https://doc.rust-lang.org/clippy/lint_configuration.html#min-ident-chars-threshold
 [`accept-comment-above-statement`]: https://doc.rust-lang.org/clippy/lint_configuration.html#accept-comment-above-statement
 [`accept-comment-above-attributes`]: https://doc.rust-lang.org/clippy/lint_configuration.html#accept-comment-above-attributes
+[`allow-one-hash-in-raw-string`]: https://doc.rust-lang.org/clippy/lint_configuration.html#allow-one-hash-in-raw-string
 <!-- end autogenerated links to configuration documentation -->
diff --git a/book/src/lint_configuration.md b/book/src/lint_configuration.md
index 9bf7b1949c4..efb48131502 100644
--- a/book/src/lint_configuration.md
+++ b/book/src/lint_configuration.md
@@ -717,3 +717,13 @@ Whether to accept a safety comment to be placed above the attributes for the `un
 * [`undocumented_unsafe_blocks`](https://rust-lang.github.io/rust-clippy/master/index.html#undocumented_unsafe_blocks)
 
 
+## `allow-one-hash-in-raw-string`
+Whether to allow `r#""#` when `r""` can be used
+
+**Default Value:** `false` (`bool`)
+
+---
+**Affected lints:**
+* [`unnecessary_raw_string_hashes`](https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_raw_string_hashes)
+
+
diff --git a/clippy_lints/src/raw_strings.rs b/clippy_lints/src/raw_strings.rs
index 81afe18ebc6..b465c7566f0 100644
--- a/clippy_lints/src/raw_strings.rs
+++ b/clippy_lints/src/raw_strings.rs
@@ -71,6 +71,20 @@ impl EarlyLintPass for RawStrings {
                 return;
             }
 
+            if !lit.symbol.as_str().contains(['\\', '"']) {
+                span_lint_and_sugg(
+                    cx,
+                    NEEDLESS_RAW_STRING,
+                    expr.span,
+                    "unnecessary raw string literal",
+                    "try",
+                    format!("{}\"{}\"", prefix.replace('r', ""), lit.symbol),
+                    Applicability::MachineApplicable,
+                );
+
+                return;
+            }
+
             #[expect(clippy::cast_possible_truncation)]
             let req = lit.symbol.as_str().as_bytes()
                 .split(|&b| b == b'"')
@@ -92,18 +106,6 @@ impl EarlyLintPass for RawStrings {
                     Applicability::MachineApplicable,
                 );
             }
-
-            if !lit.symbol.as_str().contains(['\\', '"']) {
-                span_lint_and_sugg(
-                    cx,
-                    NEEDLESS_RAW_STRING,
-                    expr.span,
-                    "unnecessary raw string literal",
-                    "try",
-                    format!("{}\"{}\"", prefix.replace('r', ""), lit.symbol),
-                    Applicability::MachineApplicable,
-                );
-            }
         }
     }
 }
diff --git a/tests/ui/needless_raw_string_hashes.fixed b/tests/ui/needless_raw_string_hashes.fixed
index 1bfb573719d..8d443dabcb7 100644
--- a/tests/ui/needless_raw_string_hashes.fixed
+++ b/tests/ui/needless_raw_string_hashes.fixed
@@ -4,15 +4,15 @@
 #![feature(c_str_literals)]
 
 fn main() {
-    r"aaa";
+    r#"aaa"#;
     r#"Hello "world"!"#;
     r####" "### "## "# "####;
     r###" "aa" "# "## "###;
-    br"aaa";
+    br#"aaa"#;
     br#"Hello "world"!"#;
     br####" "### "## "# "####;
     br###" "aa" "# "## "###;
-    cr"aaa";
+    cr#"aaa"#;
     cr#"Hello "world"!"#;
     cr####" "### "## "# "####;
     cr###" "aa" "# "## "###;
diff --git a/tests/ui/needless_raw_string_hashes.stderr b/tests/ui/needless_raw_string_hashes.stderr
index 44b878cec40..dff47a2d042 100644
--- a/tests/ui/needless_raw_string_hashes.stderr
+++ b/tests/ui/needless_raw_string_hashes.stderr
@@ -1,16 +1,10 @@
-error: unnecessary hashes around raw string literal
-  --> $DIR/needless_raw_string_hashes.rs:7:5
-   |
-LL |     r#"aaa"#;
-   |     ^^^^^^^^ help: try: `r"aaa"`
-   |
-   = note: `-D clippy::needless-raw-string-hashes` implied by `-D warnings`
-
 error: unnecessary hashes around raw string literal
   --> $DIR/needless_raw_string_hashes.rs:8:5
    |
 LL |     r##"Hello "world"!"##;
    |     ^^^^^^^^^^^^^^^^^^^^^ help: try: `r#"Hello "world"!"#`
+   |
+   = note: `-D clippy::needless-raw-string-hashes` implied by `-D warnings`
 
 error: unnecessary hashes around raw string literal
   --> $DIR/needless_raw_string_hashes.rs:9:5
@@ -24,12 +18,6 @@ error: unnecessary hashes around raw string literal
 LL |     r######" "aa" "# "## "######;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `r###" "aa" "# "## "###`
 
-error: unnecessary hashes around raw string literal
-  --> $DIR/needless_raw_string_hashes.rs:11:5
-   |
-LL |     br#"aaa"#;
-   |     ^^^^^^^^^ help: try: `br"aaa"`
-
 error: unnecessary hashes around raw string literal
   --> $DIR/needless_raw_string_hashes.rs:12:5
    |
@@ -48,12 +36,6 @@ error: unnecessary hashes around raw string literal
 LL |     br######" "aa" "# "## "######;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `br###" "aa" "# "## "###`
 
-error: unnecessary hashes around raw string literal
-  --> $DIR/needless_raw_string_hashes.rs:15:5
-   |
-LL |     cr#"aaa"#;
-   |     ^^^^^^^^^ help: try: `cr"aaa"`
-
 error: unnecessary hashes around raw string literal
   --> $DIR/needless_raw_string_hashes.rs:16:5
    |
@@ -72,5 +54,5 @@ error: unnecessary hashes around raw string literal
 LL |     cr######" "aa" "# "## "######;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `cr###" "aa" "# "## "###`
 
-error: aborting due to 12 previous errors
+error: aborting due to 9 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 8cb6c86996a8ea9e35a4e1c0c38a5a4da00b95dc Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Thu, 15 Jun 2023 14:15:10 -0500
Subject: change category and refactor

Update raw_strings.rs

Revert "new lints for visibility"

This reverts commit 0e5a537d209727169769dc19cf86aef27122c092.

new lints for visibility
---
 CHANGELOG.md                                       |  4 +-
 book/src/lint_configuration.md                     |  2 +-
 clippy_lints/src/declared_lints.rs                 |  2 +-
 clippy_lints/src/lib.rs                            |  6 ++
 clippy_lints/src/raw_strings.rs                    | 64 ++++++++++++++++------
 clippy_lints/src/utils/conf.rs                     |  2 +-
 tests/compile-test.rs                              |  2 +-
 .../conf_disallowed_methods.rs                     |  2 +-
 .../toml_unknown_key/conf_unknown_key.stderr       |  4 +-
 tests/ui/needless_raw_string.fixed                 |  2 +-
 tests/ui/needless_raw_string.rs                    |  2 +-
 tests/ui/needless_raw_string.stderr                |  2 +-
 tests/ui/needless_raw_string_hashes.fixed          |  2 +-
 tests/ui/needless_raw_string_hashes.rs             |  2 +-
 tests/ui/regex.rs                                  |  2 +-
 tests/ui/single_char_add_str.fixed                 |  2 +-
 tests/ui/single_char_add_str.rs                    |  2 +-
 tests/ui/single_char_pattern.fixed                 |  2 +-
 tests/ui/single_char_pattern.rs                    |  2 +-
 tests/ui/write_literal_2.rs                        |  2 +-
 tests/ui/write_literal_2.stderr                    |  2 +-
 21 files changed, 75 insertions(+), 37 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index e81e87bf077..a7284a70a1f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5048,8 +5048,8 @@ Released 2018-09-13
 [`needless_pass_by_value`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_pass_by_value
 [`needless_question_mark`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_question_mark
 [`needless_range_loop`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_range_loop
-[`needless_raw_string`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_raw_string
 [`needless_raw_string_hashes`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_raw_string_hashes
+[`needless_raw_strings`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_raw_strings
 [`needless_return`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_return
 [`needless_splitn`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_splitn
 [`needless_update`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_update
@@ -5414,5 +5414,5 @@ Released 2018-09-13
 [`min-ident-chars-threshold`]: https://doc.rust-lang.org/clippy/lint_configuration.html#min-ident-chars-threshold
 [`accept-comment-above-statement`]: https://doc.rust-lang.org/clippy/lint_configuration.html#accept-comment-above-statement
 [`accept-comment-above-attributes`]: https://doc.rust-lang.org/clippy/lint_configuration.html#accept-comment-above-attributes
-[`allow-one-hash-in-raw-string`]: https://doc.rust-lang.org/clippy/lint_configuration.html#allow-one-hash-in-raw-string
+[`allow-one-hash-in-raw-strings`]: https://doc.rust-lang.org/clippy/lint_configuration.html#allow-one-hash-in-raw-strings
 <!-- end autogenerated links to configuration documentation -->
diff --git a/book/src/lint_configuration.md b/book/src/lint_configuration.md
index efb48131502..293195e858c 100644
--- a/book/src/lint_configuration.md
+++ b/book/src/lint_configuration.md
@@ -717,7 +717,7 @@ Whether to accept a safety comment to be placed above the attributes for the `un
 * [`undocumented_unsafe_blocks`](https://rust-lang.github.io/rust-clippy/master/index.html#undocumented_unsafe_blocks)
 
 
-## `allow-one-hash-in-raw-string`
+## `allow-one-hash-in-raw-strings`
 Whether to allow `r#""#` when `r""` can be used
 
 **Default Value:** `false` (`bool`)
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index c67ed14b3b0..dbd4a53d836 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -540,7 +540,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::ranges::RANGE_MINUS_ONE_INFO,
     crate::ranges::RANGE_PLUS_ONE_INFO,
     crate::ranges::REVERSED_EMPTY_RANGES_INFO,
-    crate::raw_strings::NEEDLESS_RAW_STRING_INFO,
+    crate::raw_strings::NEEDLESS_RAW_STRINGS_INFO,
     crate::raw_strings::NEEDLESS_RAW_STRING_HASHES_INFO,
     crate::rc_clone_in_vec_init::RC_CLONE_IN_VEC_INIT_INFO,
     crate::read_zero_byte_vec::READ_ZERO_BYTE_VEC_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index e1a7eedd93e..d926b7b84ea 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1062,6 +1062,12 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
             def_id_to_usage: rustc_data_structures::fx::FxHashMap::default(),
         })
     });
+    let needless_raw_string_hashes_allow_one = conf.allow_one_hash_in_raw_strings;
+    store.register_early_pass(move || {
+        Box::new(raw_strings::RawStrings {
+            needless_raw_string_hashes_allow_one,
+        })
+    });
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/raw_strings.rs b/clippy_lints/src/raw_strings.rs
index b465c7566f0..f45bb1ef3e1 100644
--- a/clippy_lints/src/raw_strings.rs
+++ b/clippy_lints/src/raw_strings.rs
@@ -1,3 +1,5 @@
+use std::{iter::once, ops::ControlFlow};
+
 use clippy_utils::{diagnostics::span_lint_and_sugg, source::snippet};
 use rustc_ast::{
     ast::{Expr, ExprKind},
@@ -13,7 +15,8 @@ declare_clippy_lint! {
     /// Checks for raw string literals where a string literal can be used instead.
     ///
     /// ### Why is this bad?
-    /// It's just unnecessary.
+    /// It's just unnecessary, but there are many cases where using a raw string literal is more
+    /// idiomatic than a string literal, so it's opt-in.
     ///
     /// ### Example
     /// ```rust
@@ -24,8 +27,8 @@ declare_clippy_lint! {
     /// let r = "Hello, world!";
     /// ```
     #[clippy::version = "1.72.0"]
-    pub NEEDLESS_RAW_STRING,
-    complexity,
+    pub NEEDLESS_RAW_STRINGS,
+    restriction,
     "suggests using a string literal when a raw string literal is unnecessary"
 }
 declare_clippy_lint! {
@@ -46,10 +49,10 @@ declare_clippy_lint! {
     /// ```
     #[clippy::version = "1.72.0"]
     pub NEEDLESS_RAW_STRING_HASHES,
-    complexity,
+    style,
     "suggests reducing the number of hashes around a raw string literal"
 }
-impl_lint_pass!(RawStrings => [NEEDLESS_RAW_STRING, NEEDLESS_RAW_STRING_HASHES]);
+impl_lint_pass!(RawStrings => [NEEDLESS_RAW_STRINGS, NEEDLESS_RAW_STRING_HASHES]);
 
 pub struct RawStrings {
     pub needless_raw_string_hashes_allow_one: bool,
@@ -59,8 +62,9 @@ impl EarlyLintPass for RawStrings {
     fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
         if !in_external_macro(cx.sess(), expr.span)
             && let ExprKind::Lit(lit) = expr.kind
-            && let LitKind::StrRaw(num) | LitKind::ByteStrRaw(num) | LitKind::CStrRaw(num) = lit.kind
+            && let LitKind::StrRaw(max) | LitKind::ByteStrRaw(max) | LitKind::CStrRaw(max) = lit.kind
         {
+            let str = lit.symbol.as_str();
             let prefix = match lit.kind {
                 LitKind::StrRaw(..) => "r",
                 LitKind::ByteStrRaw(..) => "br",
@@ -71,10 +75,10 @@ impl EarlyLintPass for RawStrings {
                 return;
             }
 
-            if !lit.symbol.as_str().contains(['\\', '"']) {
+            if !str.contains(['\\', '"']) {
                 span_lint_and_sugg(
                     cx,
-                    NEEDLESS_RAW_STRING,
+                    NEEDLESS_RAW_STRINGS,
                     expr.span,
                     "unnecessary raw string literal",
                     "try",
@@ -85,15 +89,43 @@ impl EarlyLintPass for RawStrings {
                 return;
             }
 
-            #[expect(clippy::cast_possible_truncation)]
-            let req = lit.symbol.as_str().as_bytes()
-                .split(|&b| b == b'"')
-                .skip(1)
-                .map(|bs| 1 + bs.iter().take_while(|&&b| b == b'#').count() as u8)
-                .max()
-                .unwrap_or(0);
+            let req = {
+                let mut following_quote = false;
+                let mut req = 0;
+                // `once` so a raw string ending in hashes is still checked
+                let num = str.as_bytes().iter().chain(once(&0)).try_fold(0u8, |acc, &b| {
+                    match b {
+                        b'"' => (following_quote, req) = (true, 1),
+                        // I'm a bit surprised the compiler didn't optimize this out, there's no
+                        // branch but it still ends up doing an unnecessary comparison, it's:
+                        // - cmp r9b,1h
+                        // - sbb cl,-1h
+                        // which will add 1 if it's true. With this change, it becomes:
+                        // - add cl,r9b
+                        // isn't that so much nicer?
+                        b'#' => req += u8::from(following_quote),
+                        _ => {
+                            if following_quote {
+                                following_quote = false;
+
+                                if req == max {
+                                    return ControlFlow::Break(req);
+                                }
+
+                                return ControlFlow::Continue(acc.max(req));
+                            }
+                        },
+                    }
+
+                    ControlFlow::Continue(acc)
+                });
+
+                match num {
+                    ControlFlow::Continue(num) | ControlFlow::Break(num) => num,
+                }
+            };
 
-            if req < num {
+            if req < max {
                 let hashes = "#".repeat(req as usize);
 
                 span_lint_and_sugg(
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 9f88960f7ce..9be94920f96 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -550,7 +550,7 @@ define_Conf! {
     /// Lint: UNNECESSARY_RAW_STRING_HASHES.
     ///
     /// Whether to allow `r#""#` when `r""` can be used
-    (allow_one_hash_in_raw_string: bool = false),
+    (allow_one_hash_in_raw_strings: bool = false),
 }
 
 /// Search for the configuration file.
diff --git a/tests/compile-test.rs b/tests/compile-test.rs
index c5e8622bc85..13013f646e5 100644
--- a/tests/compile-test.rs
+++ b/tests/compile-test.rs
@@ -50,7 +50,7 @@ fn base_config(test_dir: &str) -> compiletest::Config {
     config.program.args.push("-Dwarnings".into());
 
     // Normalize away slashes in windows paths.
-    config.stderr_filter(r#"\\"#, "/");
+    config.stderr_filter(r"\\", "/");
 
     //config.build_base = profile_path.join("test").join(test_dir);
     config.program.program = profile_path.join(if cfg!(windows) {
diff --git a/tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.rs b/tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.rs
index d26bc72787b..63fdea710cb 100644
--- a/tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.rs
+++ b/tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.rs
@@ -1,6 +1,6 @@
 //@compile-flags: --crate-name conf_disallowed_methods
 
-#![allow(clippy::needless_raw_string)]
+#![allow(clippy::needless_raw_strings)]
 #![warn(clippy::disallowed_methods)]
 #![allow(clippy::useless_vec)]
 
diff --git a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
index 8724dc29d29..6ba26e97730 100644
--- a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
+++ b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
@@ -4,7 +4,7 @@ error: error reading Clippy's configuration file: unknown field `foobar`, expect
            allow-dbg-in-tests
            allow-expect-in-tests
            allow-mixed-uninlined-format-args
-           allow-one-hash-in-raw-string
+           allow-one-hash-in-raw-strings
            allow-print-in-tests
            allow-private-module-inception
            allow-unwrap-in-tests
@@ -73,7 +73,7 @@ error: error reading Clippy's configuration file: unknown field `barfoo`, expect
            allow-dbg-in-tests
            allow-expect-in-tests
            allow-mixed-uninlined-format-args
-           allow-one-hash-in-raw-string
+           allow-one-hash-in-raw-strings
            allow-print-in-tests
            allow-private-module-inception
            allow-unwrap-in-tests
diff --git a/tests/ui/needless_raw_string.fixed b/tests/ui/needless_raw_string.fixed
index ffc1644335d..6438e46977b 100644
--- a/tests/ui/needless_raw_string.fixed
+++ b/tests/ui/needless_raw_string.fixed
@@ -1,6 +1,6 @@
 //@run-rustfix
 #![allow(clippy::needless_raw_string_hashes, clippy::no_effect, unused)]
-#![warn(clippy::needless_raw_string)]
+#![warn(clippy::needless_raw_strings)]
 #![feature(c_str_literals)]
 
 fn main() {
diff --git a/tests/ui/needless_raw_string.rs b/tests/ui/needless_raw_string.rs
index b06b9a0ec85..f7ddc68265e 100644
--- a/tests/ui/needless_raw_string.rs
+++ b/tests/ui/needless_raw_string.rs
@@ -1,6 +1,6 @@
 //@run-rustfix
 #![allow(clippy::needless_raw_string_hashes, clippy::no_effect, unused)]
-#![warn(clippy::needless_raw_string)]
+#![warn(clippy::needless_raw_strings)]
 #![feature(c_str_literals)]
 
 fn main() {
diff --git a/tests/ui/needless_raw_string.stderr b/tests/ui/needless_raw_string.stderr
index 3eb699dea36..0179978b7b0 100644
--- a/tests/ui/needless_raw_string.stderr
+++ b/tests/ui/needless_raw_string.stderr
@@ -4,7 +4,7 @@ error: unnecessary raw string literal
 LL |     r#"aaa"#;
    |     ^^^^^^^^ help: try: `"aaa"`
    |
-   = note: `-D clippy::needless-raw-string` implied by `-D warnings`
+   = note: `-D clippy::needless-raw-strings` implied by `-D warnings`
 
 error: unnecessary raw string literal
   --> $DIR/needless_raw_string.rs:10:5
diff --git a/tests/ui/needless_raw_string_hashes.fixed b/tests/ui/needless_raw_string_hashes.fixed
index 8d443dabcb7..e4d7d8fb017 100644
--- a/tests/ui/needless_raw_string_hashes.fixed
+++ b/tests/ui/needless_raw_string_hashes.fixed
@@ -1,5 +1,5 @@
 //@run-rustfix
-#![allow(clippy::needless_raw_string, clippy::no_effect, unused)]
+#![allow(clippy::no_effect, unused)]
 #![warn(clippy::needless_raw_string_hashes)]
 #![feature(c_str_literals)]
 
diff --git a/tests/ui/needless_raw_string_hashes.rs b/tests/ui/needless_raw_string_hashes.rs
index dedd774ea0a..e2d85c52e78 100644
--- a/tests/ui/needless_raw_string_hashes.rs
+++ b/tests/ui/needless_raw_string_hashes.rs
@@ -1,5 +1,5 @@
 //@run-rustfix
-#![allow(clippy::needless_raw_string, clippy::no_effect, unused)]
+#![allow(clippy::no_effect, unused)]
 #![warn(clippy::needless_raw_string_hashes)]
 #![feature(c_str_literals)]
 
diff --git a/tests/ui/regex.rs b/tests/ui/regex.rs
index 850c9813462..89d1d949454 100644
--- a/tests/ui/regex.rs
+++ b/tests/ui/regex.rs
@@ -1,6 +1,6 @@
 #![allow(
     unused,
-    clippy::needless_raw_string,
+    clippy::needless_raw_strings,
     clippy::needless_raw_string_hashes,
     clippy::needless_borrow
 )]
diff --git a/tests/ui/single_char_add_str.fixed b/tests/ui/single_char_add_str.fixed
index ee0177776bf..cb301c8bc15 100644
--- a/tests/ui/single_char_add_str.fixed
+++ b/tests/ui/single_char_add_str.fixed
@@ -1,6 +1,6 @@
 //@run-rustfix
 #![warn(clippy::single_char_add_str)]
-#![allow(clippy::needless_raw_string, clippy::needless_raw_string_hashes)]
+#![allow(clippy::needless_raw_strings, clippy::needless_raw_string_hashes)]
 
 macro_rules! get_string {
     () => {
diff --git a/tests/ui/single_char_add_str.rs b/tests/ui/single_char_add_str.rs
index e3b7d8597c2..99baf35ac29 100644
--- a/tests/ui/single_char_add_str.rs
+++ b/tests/ui/single_char_add_str.rs
@@ -1,6 +1,6 @@
 //@run-rustfix
 #![warn(clippy::single_char_add_str)]
-#![allow(clippy::needless_raw_string, clippy::needless_raw_string_hashes)]
+#![allow(clippy::needless_raw_strings, clippy::needless_raw_string_hashes)]
 
 macro_rules! get_string {
     () => {
diff --git a/tests/ui/single_char_pattern.fixed b/tests/ui/single_char_pattern.fixed
index 920d43318ae..7ae62231acc 100644
--- a/tests/ui/single_char_pattern.fixed
+++ b/tests/ui/single_char_pattern.fixed
@@ -1,6 +1,6 @@
 //@run-rustfix
 
-#![allow(clippy::needless_raw_string, clippy::needless_raw_string_hashes, unused_must_use)]
+#![allow(clippy::needless_raw_strings, clippy::needless_raw_string_hashes, unused_must_use)]
 
 use std::collections::HashSet;
 
diff --git a/tests/ui/single_char_pattern.rs b/tests/ui/single_char_pattern.rs
index 3a53084e30b..0604624e767 100644
--- a/tests/ui/single_char_pattern.rs
+++ b/tests/ui/single_char_pattern.rs
@@ -1,6 +1,6 @@
 //@run-rustfix
 
-#![allow(clippy::needless_raw_string, clippy::needless_raw_string_hashes, unused_must_use)]
+#![allow(clippy::needless_raw_strings, clippy::needless_raw_string_hashes, unused_must_use)]
 
 use std::collections::HashSet;
 
diff --git a/tests/ui/write_literal_2.rs b/tests/ui/write_literal_2.rs
index 1d9b9603bd8..805127e2750 100644
--- a/tests/ui/write_literal_2.rs
+++ b/tests/ui/write_literal_2.rs
@@ -1,5 +1,5 @@
 #![allow(unused_must_use)]
-#![warn(clippy::needless_raw_string, clippy::write_literal)]
+#![warn(clippy::needless_raw_strings, clippy::write_literal)]
 
 use std::io::Write;
 
diff --git a/tests/ui/write_literal_2.stderr b/tests/ui/write_literal_2.stderr
index a69d031b011..18591250aad 100644
--- a/tests/ui/write_literal_2.stderr
+++ b/tests/ui/write_literal_2.stderr
@@ -4,7 +4,7 @@ error: unnecessary raw string literal
 LL |     writeln!(v, r"{}", r"{hello}");
    |                        ^^^^^^^^^^ help: try: `"{hello}"`
    |
-   = note: `-D clippy::needless-raw-string` implied by `-D warnings`
+   = note: `-D clippy::needless-raw-strings` implied by `-D warnings`
 
 error: literal with an empty format string
   --> $DIR/write_literal_2.rs:9:23
-- 
cgit 1.4.1-3-g733a5


From 9a8347ded53a14fb381f404abd32302e59ef20a9 Mon Sep 17 00:00:00 2001
From: Catherine <114838443+Centri3@users.noreply.github.com>
Date: Fri, 23 Jun 2023 06:02:39 -0500
Subject: New lint [`redundant_rest_pattern`]

---
 CHANGELOG.md                                       |  1 +
 clippy_lints/src/declared_lints.rs                 |  1 +
 clippy_lints/src/methods/needless_collect.rs       |  2 +-
 clippy_lints/src/methods/str_splitn.rs             |  2 +-
 clippy_lints/src/misc_early/mod.rs                 | 31 +++++++++++++++++
 .../src/misc_early/redundant_rest_pattern.rs       | 26 ++++++++++++++
 clippy_utils/src/sugg.rs                           |  2 +-
 tests/ui/manual_let_else_match.rs                  |  2 +-
 tests/ui/match_on_vec_items.rs                     |  2 +-
 tests/ui/redundant_rest_pattern.fixed              | 27 +++++++++++++++
 tests/ui/redundant_rest_pattern.rs                 | 27 +++++++++++++++
 tests/ui/redundant_rest_pattern.stderr             | 40 ++++++++++++++++++++++
 12 files changed, 158 insertions(+), 5 deletions(-)
 create mode 100644 clippy_lints/src/misc_early/redundant_rest_pattern.rs
 create mode 100644 tests/ui/redundant_rest_pattern.fixed
 create mode 100644 tests/ui/redundant_rest_pattern.rs
 create mode 100644 tests/ui/redundant_rest_pattern.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 941efb1abff..6350d9c118f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5141,6 +5141,7 @@ Released 2018-09-13
 [`redundant_pattern`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_pattern
 [`redundant_pattern_matching`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_pattern_matching
 [`redundant_pub_crate`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_pub_crate
+[`redundant_rest_pattern`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_rest_pattern
 [`redundant_slicing`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_slicing
 [`redundant_static_lifetimes`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_static_lifetimes
 [`redundant_type_annotations`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_type_annotations
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 0eec18a91bc..13b0f9d5ee3 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -431,6 +431,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::misc_early::DUPLICATE_UNDERSCORE_ARGUMENT_INFO,
     crate::misc_early::MIXED_CASE_HEX_LITERALS_INFO,
     crate::misc_early::REDUNDANT_PATTERN_INFO,
+    crate::misc_early::REDUNDANT_REST_PATTERN_INFO,
     crate::misc_early::SEPARATED_LITERAL_SUFFIX_INFO,
     crate::misc_early::UNNEEDED_FIELD_PATTERN_INFO,
     crate::misc_early::UNNEEDED_WILDCARD_PATTERN_INFO,
diff --git a/clippy_lints/src/methods/needless_collect.rs b/clippy_lints/src/methods/needless_collect.rs
index 99f810c27cf..3c3919dffe5 100644
--- a/clippy_lints/src/methods/needless_collect.rs
+++ b/clippy_lints/src/methods/needless_collect.rs
@@ -322,7 +322,7 @@ impl<'tcx> Visitor<'tcx> for IterFunctionVisitor<'_, 'tcx> {
 
     fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) {
         // Check function calls on our collection
-        if let ExprKind::MethodCall(method_name, recv, [args @ ..], _) = &expr.kind {
+        if let ExprKind::MethodCall(method_name, recv, args, _) = &expr.kind {
             if method_name.ident.name == sym!(collect) && is_trait_method(self.cx, expr, sym::Iterator) {
                 self.current_mutably_captured_ids = get_captured_ids(self.cx, self.cx.typeck_results().expr_ty(recv));
                 self.visit_expr(recv);
diff --git a/clippy_lints/src/methods/str_splitn.rs b/clippy_lints/src/methods/str_splitn.rs
index 5ea12c44184..88a3c2620a4 100644
--- a/clippy_lints/src/methods/str_splitn.rs
+++ b/clippy_lints/src/methods/str_splitn.rs
@@ -289,7 +289,7 @@ fn parse_iter_usage<'tcx>(
 ) -> Option<IterUsage> {
     let (kind, span) = match iter.next() {
         Some((_, Node::Expr(e))) if e.span.ctxt() == ctxt => {
-            let ExprKind::MethodCall(name, _, [args @ ..], _) = e.kind else {
+            let ExprKind::MethodCall(name, _, args, _) = e.kind else {
                 return None;
             };
             let did = cx.typeck_results().type_dependent_def_id(e.hir_id)?;
diff --git a/clippy_lints/src/misc_early/mod.rs b/clippy_lints/src/misc_early/mod.rs
index 78253ab6cdc..fcf19f17958 100644
--- a/clippy_lints/src/misc_early/mod.rs
+++ b/clippy_lints/src/misc_early/mod.rs
@@ -3,6 +3,7 @@ mod double_neg;
 mod literal_suffix;
 mod mixed_case_hex_literals;
 mod redundant_pattern;
+mod redundant_rest_pattern;
 mod unneeded_field_pattern;
 mod unneeded_wildcard_pattern;
 mod zero_prefixed_literal;
@@ -318,6 +319,34 @@ declare_clippy_lint! {
     "tuple patterns with a wildcard pattern (`_`) is next to a rest pattern (`..`)"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `[all @ ..]` patterns.
+    ///
+    /// ### Why is this bad?
+    /// In all cases, `all` works fine and can often make code simpler, as you possibly won't need
+    /// to convert from say a `Vec` to a slice by dereferencing.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// if let [all @ ..] = &*v {
+    ///     // NOTE: Type is a slice here
+    ///     println!("all elements: {all:#?}");
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust,ignore
+    /// if let all = v {
+    ///     // NOTE: Type is a `Vec` here
+    ///     println!("all elements: {all:#?}");
+    /// }
+    /// ```
+    #[clippy::version = "1.72.0"]
+    pub REDUNDANT_REST_PATTERN,
+    complexity,
+    "checks for `[all @ ..]` where `all` would suffice"
+}
+
 declare_lint_pass!(MiscEarlyLints => [
     UNNEEDED_FIELD_PATTERN,
     DUPLICATE_UNDERSCORE_ARGUMENT,
@@ -329,6 +358,7 @@ declare_lint_pass!(MiscEarlyLints => [
     BUILTIN_TYPE_SHADOW,
     REDUNDANT_PATTERN,
     UNNEEDED_WILDCARD_PATTERN,
+    REDUNDANT_REST_PATTERN,
 ]);
 
 impl EarlyLintPass for MiscEarlyLints {
@@ -345,6 +375,7 @@ impl EarlyLintPass for MiscEarlyLints {
 
         unneeded_field_pattern::check(cx, pat);
         redundant_pattern::check(cx, pat);
+        redundant_rest_pattern::check(cx, pat);
         unneeded_wildcard_pattern::check(cx, pat);
     }
 
diff --git a/clippy_lints/src/misc_early/redundant_rest_pattern.rs b/clippy_lints/src/misc_early/redundant_rest_pattern.rs
new file mode 100644
index 00000000000..87e1ed8317c
--- /dev/null
+++ b/clippy_lints/src/misc_early/redundant_rest_pattern.rs
@@ -0,0 +1,26 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use rustc_ast::{Pat, PatKind};
+use rustc_errors::Applicability;
+use rustc_lint::{EarlyContext, LintContext};
+use rustc_middle::lint::in_external_macro;
+
+use super::REDUNDANT_REST_PATTERN;
+
+pub(super) fn check(cx: &EarlyContext<'_>, pat: &Pat) {
+    if !in_external_macro(cx.sess(), pat.span)
+        && let PatKind::Slice(slice) = &pat.kind
+        && let [one] = &**slice
+        && let PatKind::Ident(annotation, ident, Some(rest)) = &one.kind
+        && let PatKind::Rest = rest.kind
+    {
+        span_lint_and_sugg(
+            cx,
+            REDUNDANT_REST_PATTERN,
+            pat.span,
+            "using a rest pattern to bind an entire slice to a local",
+            "this is better represented with just the binding",
+            format!("{}{ident}", annotation.prefix_str()),
+            Applicability::MachineApplicable,
+        );
+    }
+}
diff --git a/clippy_utils/src/sugg.rs b/clippy_utils/src/sugg.rs
index f477524eec5..bc3e58169e6 100644
--- a/clippy_utils/src/sugg.rs
+++ b/clippy_utils/src/sugg.rs
@@ -942,7 +942,7 @@ impl<'tcx> Delegate<'tcx> for DerefDelegate<'_, 'tcx> {
                         },
                         // item is used in a call
                         // i.e.: `Call`: `|x| please(x)` or `MethodCall`: `|x| [1, 2, 3].contains(x)`
-                        ExprKind::Call(_, [call_args @ ..]) | ExprKind::MethodCall(_, _, [call_args @ ..], _) => {
+                        ExprKind::Call(_, call_args) | ExprKind::MethodCall(_, _, call_args, _) => {
                             let expr = self.cx.tcx.hir().expect_expr(cmt.hir_id);
                             let arg_ty_kind = self.cx.typeck_results().expr_ty(expr).kind();
 
diff --git a/tests/ui/manual_let_else_match.rs b/tests/ui/manual_let_else_match.rs
index 07cd5a53a7c..073094ea789 100644
--- a/tests/ui/manual_let_else_match.rs
+++ b/tests/ui/manual_let_else_match.rs
@@ -1,5 +1,5 @@
 #![allow(unused_braces, unused_variables, dead_code)]
-#![allow(clippy::collapsible_else_if, clippy::let_unit_value)]
+#![allow(clippy::collapsible_else_if, clippy::let_unit_value, clippy::redundant_rest_pattern)]
 #![warn(clippy::manual_let_else)]
 // Ensure that we don't conflict with match -> if let lints
 #![warn(clippy::single_match_else, clippy::single_match)]
diff --git a/tests/ui/match_on_vec_items.rs b/tests/ui/match_on_vec_items.rs
index d82a736963a..fe214904365 100644
--- a/tests/ui/match_on_vec_items.rs
+++ b/tests/ui/match_on_vec_items.rs
@@ -1,5 +1,5 @@
 #![warn(clippy::match_on_vec_items)]
-#![allow(clippy::useless_vec)]
+#![allow(clippy::redundant_rest_pattern, clippy::useless_vec)]
 
 fn match_with_wildcard() {
     let arr = vec![0, 1, 2, 3];
diff --git a/tests/ui/redundant_rest_pattern.fixed b/tests/ui/redundant_rest_pattern.fixed
new file mode 100644
index 00000000000..d9a98622c42
--- /dev/null
+++ b/tests/ui/redundant_rest_pattern.fixed
@@ -0,0 +1,27 @@
+//@run-rustfix
+//@aux-build:proc_macros.rs
+#![allow(irrefutable_let_patterns, unused)]
+#![warn(clippy::redundant_rest_pattern)]
+
+#[macro_use]
+extern crate proc_macros;
+
+fn main() {
+    if let a = [()] {}
+    if let ref a = [()] {}
+    if let mut a = [()] {}
+    if let ref mut a = [()] {}
+    let v = vec![()];
+    if let a = &*v {}
+    let s = &[()];
+    if let a = s {}
+    // Don't lint
+    if let [..] = &*v {}
+    if let [a] = &*v {}
+    if let [()] = &*v {}
+    if let [first, rest @ ..] = &*v {}
+    if let a = [()] {}
+    external! {
+        if let [a @ ..] = [()] {}
+    }
+}
diff --git a/tests/ui/redundant_rest_pattern.rs b/tests/ui/redundant_rest_pattern.rs
new file mode 100644
index 00000000000..60a12bfd6fb
--- /dev/null
+++ b/tests/ui/redundant_rest_pattern.rs
@@ -0,0 +1,27 @@
+//@run-rustfix
+//@aux-build:proc_macros.rs
+#![allow(irrefutable_let_patterns, unused)]
+#![warn(clippy::redundant_rest_pattern)]
+
+#[macro_use]
+extern crate proc_macros;
+
+fn main() {
+    if let [a @ ..] = [()] {}
+    if let [ref a @ ..] = [()] {}
+    if let [mut a @ ..] = [()] {}
+    if let [ref mut a @ ..] = [()] {}
+    let v = vec![()];
+    if let [a @ ..] = &*v {}
+    let s = &[()];
+    if let [a @ ..] = s {}
+    // Don't lint
+    if let [..] = &*v {}
+    if let [a] = &*v {}
+    if let [()] = &*v {}
+    if let [first, rest @ ..] = &*v {}
+    if let a = [()] {}
+    external! {
+        if let [a @ ..] = [()] {}
+    }
+}
diff --git a/tests/ui/redundant_rest_pattern.stderr b/tests/ui/redundant_rest_pattern.stderr
new file mode 100644
index 00000000000..630909a0a16
--- /dev/null
+++ b/tests/ui/redundant_rest_pattern.stderr
@@ -0,0 +1,40 @@
+error: using a rest pattern to bind an entire slice to a local
+  --> $DIR/redundant_rest_pattern.rs:10:12
+   |
+LL |     if let [a @ ..] = [()] {}
+   |            ^^^^^^^^ help: this is better represented with just the binding: `a`
+   |
+   = note: `-D clippy::redundant-rest-pattern` implied by `-D warnings`
+
+error: using a rest pattern to bind an entire slice to a local
+  --> $DIR/redundant_rest_pattern.rs:11:12
+   |
+LL |     if let [ref a @ ..] = [()] {}
+   |            ^^^^^^^^^^^^ help: this is better represented with just the binding: `ref a`
+
+error: using a rest pattern to bind an entire slice to a local
+  --> $DIR/redundant_rest_pattern.rs:12:12
+   |
+LL |     if let [mut a @ ..] = [()] {}
+   |            ^^^^^^^^^^^^ help: this is better represented with just the binding: `mut a`
+
+error: using a rest pattern to bind an entire slice to a local
+  --> $DIR/redundant_rest_pattern.rs:13:12
+   |
+LL |     if let [ref mut a @ ..] = [()] {}
+   |            ^^^^^^^^^^^^^^^^ help: this is better represented with just the binding: `ref mut a`
+
+error: using a rest pattern to bind an entire slice to a local
+  --> $DIR/redundant_rest_pattern.rs:15:12
+   |
+LL |     if let [a @ ..] = &*v {}
+   |            ^^^^^^^^ help: this is better represented with just the binding: `a`
+
+error: using a rest pattern to bind an entire slice to a local
+  --> $DIR/redundant_rest_pattern.rs:17:12
+   |
+LL |     if let [a @ ..] = s {}
+   |            ^^^^^^^^ help: this is better represented with just the binding: `a`
+
+error: aborting due to 6 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From e9ced12512f0a63667884c0eac10c99d437f31f7 Mon Sep 17 00:00:00 2001
From: Catherine <114838443+Centri3@users.noreply.github.com>
Date: Tue, 27 Jun 2023 06:09:28 -0500
Subject: Rename the lint

---
 CHANGELOG.md                                       |  2 +-
 clippy_lints/src/declared_lints.rs                 |  2 +-
 clippy_lints/src/misc_early/mod.rs                 |  8 ++---
 .../src/misc_early/redundant_at_rest_pattern.rs    | 26 ++++++++++++++
 .../src/misc_early/redundant_rest_pattern.rs       | 26 --------------
 tests/ui/manual_let_else_match.rs                  |  6 +++-
 tests/ui/manual_let_else_match.stderr              | 18 +++++-----
 tests/ui/match_on_vec_items.rs                     |  2 +-
 tests/ui/redundant_at_rest_pattern.fixed           | 27 +++++++++++++++
 tests/ui/redundant_at_rest_pattern.rs              | 27 +++++++++++++++
 tests/ui/redundant_at_rest_pattern.stderr          | 40 ++++++++++++++++++++++
 tests/ui/redundant_rest_pattern.fixed              | 27 ---------------
 tests/ui/redundant_rest_pattern.rs                 | 27 ---------------
 tests/ui/redundant_rest_pattern.stderr             | 40 ----------------------
 14 files changed, 141 insertions(+), 137 deletions(-)
 create mode 100644 clippy_lints/src/misc_early/redundant_at_rest_pattern.rs
 delete mode 100644 clippy_lints/src/misc_early/redundant_rest_pattern.rs
 create mode 100644 tests/ui/redundant_at_rest_pattern.fixed
 create mode 100644 tests/ui/redundant_at_rest_pattern.rs
 create mode 100644 tests/ui/redundant_at_rest_pattern.stderr
 delete mode 100644 tests/ui/redundant_rest_pattern.fixed
 delete mode 100644 tests/ui/redundant_rest_pattern.rs
 delete mode 100644 tests/ui/redundant_rest_pattern.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 6350d9c118f..7b2179bddfd 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5131,6 +5131,7 @@ Released 2018-09-13
 [`recursive_format_impl`]: https://rust-lang.github.io/rust-clippy/master/index.html#recursive_format_impl
 [`redundant_allocation`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_allocation
 [`redundant_async_block`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_async_block
+[`redundant_at_rest_pattern`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_at_rest_pattern
 [`redundant_clone`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_clone
 [`redundant_closure`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_closure
 [`redundant_closure_call`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_closure_call
@@ -5141,7 +5142,6 @@ Released 2018-09-13
 [`redundant_pattern`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_pattern
 [`redundant_pattern_matching`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_pattern_matching
 [`redundant_pub_crate`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_pub_crate
-[`redundant_rest_pattern`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_rest_pattern
 [`redundant_slicing`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_slicing
 [`redundant_static_lifetimes`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_static_lifetimes
 [`redundant_type_annotations`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_type_annotations
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 13b0f9d5ee3..19014888114 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -430,8 +430,8 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::misc_early::DOUBLE_NEG_INFO,
     crate::misc_early::DUPLICATE_UNDERSCORE_ARGUMENT_INFO,
     crate::misc_early::MIXED_CASE_HEX_LITERALS_INFO,
+    crate::misc_early::REDUNDANT_AT_REST_PATTERN_INFO,
     crate::misc_early::REDUNDANT_PATTERN_INFO,
-    crate::misc_early::REDUNDANT_REST_PATTERN_INFO,
     crate::misc_early::SEPARATED_LITERAL_SUFFIX_INFO,
     crate::misc_early::UNNEEDED_FIELD_PATTERN_INFO,
     crate::misc_early::UNNEEDED_WILDCARD_PATTERN_INFO,
diff --git a/clippy_lints/src/misc_early/mod.rs b/clippy_lints/src/misc_early/mod.rs
index fcf19f17958..cff8538095d 100644
--- a/clippy_lints/src/misc_early/mod.rs
+++ b/clippy_lints/src/misc_early/mod.rs
@@ -2,8 +2,8 @@ mod builtin_type_shadow;
 mod double_neg;
 mod literal_suffix;
 mod mixed_case_hex_literals;
+mod redundant_at_rest_pattern;
 mod redundant_pattern;
-mod redundant_rest_pattern;
 mod unneeded_field_pattern;
 mod unneeded_wildcard_pattern;
 mod zero_prefixed_literal;
@@ -342,7 +342,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     #[clippy::version = "1.72.0"]
-    pub REDUNDANT_REST_PATTERN,
+    pub REDUNDANT_AT_REST_PATTERN,
     complexity,
     "checks for `[all @ ..]` where `all` would suffice"
 }
@@ -358,7 +358,7 @@ declare_lint_pass!(MiscEarlyLints => [
     BUILTIN_TYPE_SHADOW,
     REDUNDANT_PATTERN,
     UNNEEDED_WILDCARD_PATTERN,
-    REDUNDANT_REST_PATTERN,
+    REDUNDANT_AT_REST_PATTERN,
 ]);
 
 impl EarlyLintPass for MiscEarlyLints {
@@ -375,7 +375,7 @@ impl EarlyLintPass for MiscEarlyLints {
 
         unneeded_field_pattern::check(cx, pat);
         redundant_pattern::check(cx, pat);
-        redundant_rest_pattern::check(cx, pat);
+        redundant_at_rest_pattern::check(cx, pat);
         unneeded_wildcard_pattern::check(cx, pat);
     }
 
diff --git a/clippy_lints/src/misc_early/redundant_at_rest_pattern.rs b/clippy_lints/src/misc_early/redundant_at_rest_pattern.rs
new file mode 100644
index 00000000000..0c81ee5eced
--- /dev/null
+++ b/clippy_lints/src/misc_early/redundant_at_rest_pattern.rs
@@ -0,0 +1,26 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use rustc_ast::{Pat, PatKind};
+use rustc_errors::Applicability;
+use rustc_lint::{EarlyContext, LintContext};
+use rustc_middle::lint::in_external_macro;
+
+use super::REDUNDANT_AT_REST_PATTERN;
+
+pub(super) fn check(cx: &EarlyContext<'_>, pat: &Pat) {
+    if !in_external_macro(cx.sess(), pat.span)
+        && let PatKind::Slice(slice) = &pat.kind
+        && let [one] = &**slice
+        && let PatKind::Ident(annotation, ident, Some(rest)) = &one.kind
+        && let PatKind::Rest = rest.kind
+    {
+        span_lint_and_sugg(
+            cx,
+            REDUNDANT_AT_REST_PATTERN,
+            pat.span,
+            "using a rest pattern to bind an entire slice to a local",
+            "this is better represented with just the binding",
+            format!("{}{ident}", annotation.prefix_str()),
+            Applicability::MachineApplicable,
+        );
+    }
+}
diff --git a/clippy_lints/src/misc_early/redundant_rest_pattern.rs b/clippy_lints/src/misc_early/redundant_rest_pattern.rs
deleted file mode 100644
index 87e1ed8317c..00000000000
--- a/clippy_lints/src/misc_early/redundant_rest_pattern.rs
+++ /dev/null
@@ -1,26 +0,0 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
-use rustc_ast::{Pat, PatKind};
-use rustc_errors::Applicability;
-use rustc_lint::{EarlyContext, LintContext};
-use rustc_middle::lint::in_external_macro;
-
-use super::REDUNDANT_REST_PATTERN;
-
-pub(super) fn check(cx: &EarlyContext<'_>, pat: &Pat) {
-    if !in_external_macro(cx.sess(), pat.span)
-        && let PatKind::Slice(slice) = &pat.kind
-        && let [one] = &**slice
-        && let PatKind::Ident(annotation, ident, Some(rest)) = &one.kind
-        && let PatKind::Rest = rest.kind
-    {
-        span_lint_and_sugg(
-            cx,
-            REDUNDANT_REST_PATTERN,
-            pat.span,
-            "using a rest pattern to bind an entire slice to a local",
-            "this is better represented with just the binding",
-            format!("{}{ident}", annotation.prefix_str()),
-            Applicability::MachineApplicable,
-        );
-    }
-}
diff --git a/tests/ui/manual_let_else_match.rs b/tests/ui/manual_let_else_match.rs
index 073094ea789..73ff69eec4e 100644
--- a/tests/ui/manual_let_else_match.rs
+++ b/tests/ui/manual_let_else_match.rs
@@ -1,5 +1,9 @@
 #![allow(unused_braces, unused_variables, dead_code)]
-#![allow(clippy::collapsible_else_if, clippy::let_unit_value, clippy::redundant_rest_pattern)]
+#![allow(
+    clippy::collapsible_else_if,
+    clippy::let_unit_value,
+    clippy::redundant_at_rest_pattern
+)]
 #![warn(clippy::manual_let_else)]
 // Ensure that we don't conflict with match -> if let lints
 #![warn(clippy::single_match_else, clippy::single_match)]
diff --git a/tests/ui/manual_let_else_match.stderr b/tests/ui/manual_let_else_match.stderr
index ead2f28e609..3fd9a637605 100644
--- a/tests/ui/manual_let_else_match.stderr
+++ b/tests/ui/manual_let_else_match.stderr
@@ -1,5 +1,5 @@
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else_match.rs:32:5
+  --> $DIR/manual_let_else_match.rs:36:5
    |
 LL | /     let v = match g() {
 LL | |         Some(v_some) => v_some,
@@ -10,7 +10,7 @@ LL | |     };
    = note: `-D clippy::manual-let-else` implied by `-D warnings`
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else_match.rs:37:5
+  --> $DIR/manual_let_else_match.rs:41:5
    |
 LL | /     let v = match g() {
 LL | |         Some(v_some) => v_some,
@@ -19,7 +19,7 @@ LL | |     };
    | |______^ help: consider writing: `let Some(v) = g() else { return };`
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else_match.rs:44:9
+  --> $DIR/manual_let_else_match.rs:48:9
    |
 LL | /         let v = match h() {
 LL | |             (Some(v), None) | (None, Some(v)) => v,
@@ -28,7 +28,7 @@ LL | |         };
    | |__________^ help: consider writing: `let ((Some(v), None) | (None, Some(v))) = h() else { continue };`
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else_match.rs:49:9
+  --> $DIR/manual_let_else_match.rs:53:9
    |
 LL | /         let v = match build_enum() {
 LL | |             Variant::Bar(v) | Variant::Baz(v) => v,
@@ -37,7 +37,7 @@ LL | |         };
    | |__________^ help: consider writing: `let (Variant::Bar(v) | Variant::Baz(v)) = build_enum() else { continue };`
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else_match.rs:57:5
+  --> $DIR/manual_let_else_match.rs:61:5
    |
 LL | /     let v = match f() {
 LL | |         Ok(v) => v,
@@ -46,7 +46,7 @@ LL | |     };
    | |______^ help: consider writing: `let Ok(v) = f() else { return };`
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else_match.rs:63:5
+  --> $DIR/manual_let_else_match.rs:67:5
    |
 LL | /     let v = match f().map_err(|_| ()) {
 LL | |         Ok(v) => v,
@@ -55,7 +55,7 @@ LL | |     };
    | |______^ help: consider writing: `let Ok(v) = f().map_err(|_| ()) else { return };`
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else_match.rs:70:5
+  --> $DIR/manual_let_else_match.rs:74:5
    |
 LL | /     let _value = match f {
 LL | |         Variant::Bar(v) | Variant::Baz(v) => v,
@@ -64,7 +64,7 @@ LL | |     };
    | |______^ help: consider writing: `let (Variant::Bar(_value) | Variant::Baz(_value)) = f else { return };`
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else_match.rs:75:5
+  --> $DIR/manual_let_else_match.rs:79:5
    |
 LL | /     let _value = match Some(build_enum()) {
 LL | |         Some(Variant::Bar(v) | Variant::Baz(v)) => v,
@@ -73,7 +73,7 @@ LL | |     };
    | |______^ help: consider writing: `let Some(Variant::Bar(_value) | Variant::Baz(_value)) = Some(build_enum()) else { return };`
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else_match.rs:81:5
+  --> $DIR/manual_let_else_match.rs:85:5
    |
 LL | /     let data = match data.as_slice() {
 LL | |         [data @ .., 0, 0, 0, 0] | [data @ .., 0, 0] | [data @ .., 0] => data,
diff --git a/tests/ui/match_on_vec_items.rs b/tests/ui/match_on_vec_items.rs
index fe214904365..cf9c279cd2f 100644
--- a/tests/ui/match_on_vec_items.rs
+++ b/tests/ui/match_on_vec_items.rs
@@ -1,5 +1,5 @@
 #![warn(clippy::match_on_vec_items)]
-#![allow(clippy::redundant_rest_pattern, clippy::useless_vec)]
+#![allow(clippy::redundant_at_rest_pattern, clippy::useless_vec)]
 
 fn match_with_wildcard() {
     let arr = vec![0, 1, 2, 3];
diff --git a/tests/ui/redundant_at_rest_pattern.fixed b/tests/ui/redundant_at_rest_pattern.fixed
new file mode 100644
index 00000000000..080cf13b5da
--- /dev/null
+++ b/tests/ui/redundant_at_rest_pattern.fixed
@@ -0,0 +1,27 @@
+//@run-rustfix
+//@aux-build:proc_macros.rs:proc-macro
+#![allow(irrefutable_let_patterns, unused)]
+#![warn(clippy::redundant_at_rest_pattern)]
+
+#[macro_use]
+extern crate proc_macros;
+
+fn main() {
+    if let a = [()] {}
+    if let ref a = [()] {}
+    if let mut a = [()] {}
+    if let ref mut a = [()] {}
+    let v = vec![()];
+    if let a = &*v {}
+    let s = &[()];
+    if let a = s {}
+    // Don't lint
+    if let [..] = &*v {}
+    if let [a] = &*v {}
+    if let [()] = &*v {}
+    if let [first, rest @ ..] = &*v {}
+    if let a = [()] {}
+    external! {
+        if let [a @ ..] = [()] {}
+    }
+}
diff --git a/tests/ui/redundant_at_rest_pattern.rs b/tests/ui/redundant_at_rest_pattern.rs
new file mode 100644
index 00000000000..a8a80282956
--- /dev/null
+++ b/tests/ui/redundant_at_rest_pattern.rs
@@ -0,0 +1,27 @@
+//@run-rustfix
+//@aux-build:proc_macros.rs:proc-macro
+#![allow(irrefutable_let_patterns, unused)]
+#![warn(clippy::redundant_at_rest_pattern)]
+
+#[macro_use]
+extern crate proc_macros;
+
+fn main() {
+    if let [a @ ..] = [()] {}
+    if let [ref a @ ..] = [()] {}
+    if let [mut a @ ..] = [()] {}
+    if let [ref mut a @ ..] = [()] {}
+    let v = vec![()];
+    if let [a @ ..] = &*v {}
+    let s = &[()];
+    if let [a @ ..] = s {}
+    // Don't lint
+    if let [..] = &*v {}
+    if let [a] = &*v {}
+    if let [()] = &*v {}
+    if let [first, rest @ ..] = &*v {}
+    if let a = [()] {}
+    external! {
+        if let [a @ ..] = [()] {}
+    }
+}
diff --git a/tests/ui/redundant_at_rest_pattern.stderr b/tests/ui/redundant_at_rest_pattern.stderr
new file mode 100644
index 00000000000..e2a4d9ffd57
--- /dev/null
+++ b/tests/ui/redundant_at_rest_pattern.stderr
@@ -0,0 +1,40 @@
+error: using a rest pattern to bind an entire slice to a local
+  --> $DIR/redundant_at_rest_pattern.rs:10:12
+   |
+LL |     if let [a @ ..] = [()] {}
+   |            ^^^^^^^^ help: this is better represented with just the binding: `a`
+   |
+   = note: `-D clippy::redundant-at-rest-pattern` implied by `-D warnings`
+
+error: using a rest pattern to bind an entire slice to a local
+  --> $DIR/redundant_at_rest_pattern.rs:11:12
+   |
+LL |     if let [ref a @ ..] = [()] {}
+   |            ^^^^^^^^^^^^ help: this is better represented with just the binding: `ref a`
+
+error: using a rest pattern to bind an entire slice to a local
+  --> $DIR/redundant_at_rest_pattern.rs:12:12
+   |
+LL |     if let [mut a @ ..] = [()] {}
+   |            ^^^^^^^^^^^^ help: this is better represented with just the binding: `mut a`
+
+error: using a rest pattern to bind an entire slice to a local
+  --> $DIR/redundant_at_rest_pattern.rs:13:12
+   |
+LL |     if let [ref mut a @ ..] = [()] {}
+   |            ^^^^^^^^^^^^^^^^ help: this is better represented with just the binding: `ref mut a`
+
+error: using a rest pattern to bind an entire slice to a local
+  --> $DIR/redundant_at_rest_pattern.rs:15:12
+   |
+LL |     if let [a @ ..] = &*v {}
+   |            ^^^^^^^^ help: this is better represented with just the binding: `a`
+
+error: using a rest pattern to bind an entire slice to a local
+  --> $DIR/redundant_at_rest_pattern.rs:17:12
+   |
+LL |     if let [a @ ..] = s {}
+   |            ^^^^^^^^ help: this is better represented with just the binding: `a`
+
+error: aborting due to 6 previous errors
+
diff --git a/tests/ui/redundant_rest_pattern.fixed b/tests/ui/redundant_rest_pattern.fixed
deleted file mode 100644
index d9a98622c42..00000000000
--- a/tests/ui/redundant_rest_pattern.fixed
+++ /dev/null
@@ -1,27 +0,0 @@
-//@run-rustfix
-//@aux-build:proc_macros.rs
-#![allow(irrefutable_let_patterns, unused)]
-#![warn(clippy::redundant_rest_pattern)]
-
-#[macro_use]
-extern crate proc_macros;
-
-fn main() {
-    if let a = [()] {}
-    if let ref a = [()] {}
-    if let mut a = [()] {}
-    if let ref mut a = [()] {}
-    let v = vec![()];
-    if let a = &*v {}
-    let s = &[()];
-    if let a = s {}
-    // Don't lint
-    if let [..] = &*v {}
-    if let [a] = &*v {}
-    if let [()] = &*v {}
-    if let [first, rest @ ..] = &*v {}
-    if let a = [()] {}
-    external! {
-        if let [a @ ..] = [()] {}
-    }
-}
diff --git a/tests/ui/redundant_rest_pattern.rs b/tests/ui/redundant_rest_pattern.rs
deleted file mode 100644
index 60a12bfd6fb..00000000000
--- a/tests/ui/redundant_rest_pattern.rs
+++ /dev/null
@@ -1,27 +0,0 @@
-//@run-rustfix
-//@aux-build:proc_macros.rs
-#![allow(irrefutable_let_patterns, unused)]
-#![warn(clippy::redundant_rest_pattern)]
-
-#[macro_use]
-extern crate proc_macros;
-
-fn main() {
-    if let [a @ ..] = [()] {}
-    if let [ref a @ ..] = [()] {}
-    if let [mut a @ ..] = [()] {}
-    if let [ref mut a @ ..] = [()] {}
-    let v = vec![()];
-    if let [a @ ..] = &*v {}
-    let s = &[()];
-    if let [a @ ..] = s {}
-    // Don't lint
-    if let [..] = &*v {}
-    if let [a] = &*v {}
-    if let [()] = &*v {}
-    if let [first, rest @ ..] = &*v {}
-    if let a = [()] {}
-    external! {
-        if let [a @ ..] = [()] {}
-    }
-}
diff --git a/tests/ui/redundant_rest_pattern.stderr b/tests/ui/redundant_rest_pattern.stderr
deleted file mode 100644
index 630909a0a16..00000000000
--- a/tests/ui/redundant_rest_pattern.stderr
+++ /dev/null
@@ -1,40 +0,0 @@
-error: using a rest pattern to bind an entire slice to a local
-  --> $DIR/redundant_rest_pattern.rs:10:12
-   |
-LL |     if let [a @ ..] = [()] {}
-   |            ^^^^^^^^ help: this is better represented with just the binding: `a`
-   |
-   = note: `-D clippy::redundant-rest-pattern` implied by `-D warnings`
-
-error: using a rest pattern to bind an entire slice to a local
-  --> $DIR/redundant_rest_pattern.rs:11:12
-   |
-LL |     if let [ref a @ ..] = [()] {}
-   |            ^^^^^^^^^^^^ help: this is better represented with just the binding: `ref a`
-
-error: using a rest pattern to bind an entire slice to a local
-  --> $DIR/redundant_rest_pattern.rs:12:12
-   |
-LL |     if let [mut a @ ..] = [()] {}
-   |            ^^^^^^^^^^^^ help: this is better represented with just the binding: `mut a`
-
-error: using a rest pattern to bind an entire slice to a local
-  --> $DIR/redundant_rest_pattern.rs:13:12
-   |
-LL |     if let [ref mut a @ ..] = [()] {}
-   |            ^^^^^^^^^^^^^^^^ help: this is better represented with just the binding: `ref mut a`
-
-error: using a rest pattern to bind an entire slice to a local
-  --> $DIR/redundant_rest_pattern.rs:15:12
-   |
-LL |     if let [a @ ..] = &*v {}
-   |            ^^^^^^^^ help: this is better represented with just the binding: `a`
-
-error: using a rest pattern to bind an entire slice to a local
-  --> $DIR/redundant_rest_pattern.rs:17:12
-   |
-LL |     if let [a @ ..] = s {}
-   |            ^^^^^^^^ help: this is better represented with just the binding: `a`
-
-error: aborting due to 6 previous errors
-
-- 
cgit 1.4.1-3-g733a5


From a43bfefd19a3af040b6cbc5cc607814d9250689a Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Tue, 27 Jun 2023 22:00:00 +0200
Subject: [`unused_async`]: don't lint on async trait impls

---
 clippy_lints/src/unused_async.rs | 18 ++++++++++++++++--
 tests/ui/unused_async.rs         | 14 ++++++++++++++
 tests/ui/unused_async.stderr     |  8 ++++----
 3 files changed, 34 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unused_async.rs b/clippy_lints/src/unused_async.rs
index 117dda09222..21153973dff 100644
--- a/clippy_lints/src/unused_async.rs
+++ b/clippy_lints/src/unused_async.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use rustc_hir::intravisit::{walk_body, walk_expr, walk_fn, FnKind, Visitor};
-use rustc_hir::{Body, Expr, ExprKind, FnDecl, YieldSource};
+use rustc_hir::{Body, Expr, ExprKind, FnDecl, ItemKind, Node, YieldSource};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::nested_filter;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -81,6 +81,20 @@ impl<'a, 'tcx> Visitor<'tcx> for AsyncFnVisitor<'a, 'tcx> {
     }
 }
 
+/// Checks if the `def_id` belongs to a function and that function is part of a trait impl,
+/// in which case we shouldn't lint because `async` is part of the trait definition and therefore
+/// can't be removed.
+fn is_in_trait_impl(cx: &LateContext<'_>, def_id: LocalDefId) -> bool {
+    if let Some(hir_id) = cx.tcx.opt_local_def_id_to_hir_id(def_id)
+        && let Node::Item(item) = cx.tcx.hir().get_parent(hir_id)
+        && let ItemKind::Impl(imp) = item.kind
+    {
+        imp.of_trait.is_some()
+    } else {
+        false
+    }
+}
+
 impl<'tcx> LateLintPass<'tcx> for UnusedAsync {
     fn check_fn(
         &mut self,
@@ -91,7 +105,7 @@ impl<'tcx> LateLintPass<'tcx> for UnusedAsync {
         span: Span,
         def_id: LocalDefId,
     ) {
-        if !span.from_expansion() && fn_kind.asyncness().is_async() {
+        if !span.from_expansion() && fn_kind.asyncness().is_async() && !is_in_trait_impl(cx, def_id) {
             let mut visitor = AsyncFnVisitor {
                 cx,
                 found_await: false,
diff --git a/tests/ui/unused_async.rs b/tests/ui/unused_async.rs
index bfaa5dadfa5..69e46ab4736 100644
--- a/tests/ui/unused_async.rs
+++ b/tests/ui/unused_async.rs
@@ -1,4 +1,6 @@
 #![warn(clippy::unused_async)]
+#![feature(async_fn_in_trait)]
+#![allow(incomplete_features)]
 
 use std::future::Future;
 use std::pin::Pin;
@@ -23,6 +25,18 @@ mod issue10800 {
     }
 }
 
+mod issue10459 {
+    trait HasAsyncMethod {
+        async fn do_something() -> u32;
+    }
+
+    impl HasAsyncMethod for () {
+        async fn do_something() -> u32 {
+            1
+        }
+    }
+}
+
 async fn foo() -> i32 {
     4
 }
diff --git a/tests/ui/unused_async.stderr b/tests/ui/unused_async.stderr
index 8ac2066a6b2..ffae8366b88 100644
--- a/tests/ui/unused_async.stderr
+++ b/tests/ui/unused_async.stderr
@@ -1,5 +1,5 @@
 error: unused `async` for function with no await statements
-  --> $DIR/unused_async.rs:11:5
+  --> $DIR/unused_async.rs:13:5
    |
 LL | /     async fn async_block_await() {
 LL | |         async {
@@ -10,14 +10,14 @@ LL | |     }
    |
    = help: consider removing the `async` from this function
 note: `await` used in an async block, which does not require the enclosing function to be `async`
-  --> $DIR/unused_async.rs:13:23
+  --> $DIR/unused_async.rs:15:23
    |
 LL |             ready(()).await;
    |                       ^^^^^
    = note: `-D clippy::unused-async` implied by `-D warnings`
 
 error: unused `async` for function with no await statements
-  --> $DIR/unused_async.rs:26:1
+  --> $DIR/unused_async.rs:40:1
    |
 LL | / async fn foo() -> i32 {
 LL | |     4
@@ -27,7 +27,7 @@ LL | | }
    = help: consider removing the `async` from this function
 
 error: unused `async` for function with no await statements
-  --> $DIR/unused_async.rs:37:5
+  --> $DIR/unused_async.rs:51:5
    |
 LL | /     async fn unused(&self) -> i32 {
 LL | |         1
-- 
cgit 1.4.1-3-g733a5


From 1d4afc5d8201e591e0019883c0c2c6a0ae93f13b Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Fri, 16 Jun 2023 21:39:02 +0200
Subject: new lint: `manual_range_pattern`

---
 CHANGELOG.md                             |   1 +
 clippy_lints/src/declared_lints.rs       |   1 +
 clippy_lints/src/lib.rs                  |   2 +
 clippy_lints/src/manual_range_pattern.rs | 123 +++++++++++++++++++++++++++++++
 tests/ui/manual_range_pattern.fixed      |  35 +++++++++
 tests/ui/manual_range_pattern.rs         |  35 +++++++++
 tests/ui/manual_range_pattern.stderr     |  51 +++++++++++++
 tests/ui/unnested_or_patterns.fixed      |   3 +-
 tests/ui/unnested_or_patterns.rs         |   3 +-
 tests/ui/unnested_or_patterns.stderr     |  34 ++++-----
 tests/ui/unnested_or_patterns2.fixed     |   7 +-
 tests/ui/unnested_or_patterns2.rs        |   7 +-
 tests/ui/unnested_or_patterns2.stderr    |  16 ++--
 13 files changed, 289 insertions(+), 29 deletions(-)
 create mode 100644 clippy_lints/src/manual_range_pattern.rs
 create mode 100644 tests/ui/manual_range_pattern.fixed
 create mode 100644 tests/ui/manual_range_pattern.rs
 create mode 100644 tests/ui/manual_range_pattern.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index a7284a70a1f..045c269d62a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4949,6 +4949,7 @@ Released 2018-09-13
 [`manual_non_exhaustive`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_non_exhaustive
 [`manual_ok_or`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_ok_or
 [`manual_range_contains`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_range_contains
+[`manual_range_pattern`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_range_pattern
 [`manual_rem_euclid`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_rem_euclid
 [`manual_retain`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_retain
 [`manual_saturating_arithmetic`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_saturating_arithmetic
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index dbd4a53d836..53d92c089ea 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -278,6 +278,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::manual_let_else::MANUAL_LET_ELSE_INFO,
     crate::manual_main_separator_str::MANUAL_MAIN_SEPARATOR_STR_INFO,
     crate::manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE_INFO,
+    crate::manual_range_pattern::MANUAL_RANGE_PATTERN_INFO,
     crate::manual_rem_euclid::MANUAL_REM_EUCLID_INFO,
     crate::manual_retain::MANUAL_RETAIN_INFO,
     crate::manual_slice_size_calculation::MANUAL_SLICE_SIZE_CALCULATION_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index d926b7b84ea..d23dd29f815 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -188,6 +188,7 @@ mod manual_is_ascii_check;
 mod manual_let_else;
 mod manual_main_separator_str;
 mod manual_non_exhaustive;
+mod manual_range_pattern;
 mod manual_rem_euclid;
 mod manual_retain;
 mod manual_slice_size_calculation;
@@ -1068,6 +1069,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
             needless_raw_string_hashes_allow_one,
         })
     });
+    store.register_late_pass(|_| Box::new(manual_range_pattern::ManualRangePattern));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/manual_range_pattern.rs b/clippy_lints/src/manual_range_pattern.rs
new file mode 100644
index 00000000000..0ef75792b7a
--- /dev/null
+++ b/clippy_lints/src/manual_range_pattern.rs
@@ -0,0 +1,123 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use rustc_ast::LitKind;
+use rustc_data_structures::fx::FxHashSet;
+use rustc_errors::Applicability;
+use rustc_hir::Expr;
+use rustc_hir::ExprKind;
+use rustc_hir::PatKind;
+use rustc_hir::RangeEnd;
+use rustc_lint::LintContext;
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::lint::in_external_macro;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Looks for combined OR patterns that are all contained in a specific range,
+    /// e.g. `6 | 4 | 5 | 9 | 7 | 8` can be rewritten as `4..=9`.
+    ///
+    /// ### Why is this bad?
+    /// Using an explicit range is more concise and easier to read.
+    ///
+    /// ### Example
+    /// ```rust
+    /// let x = 6;
+    /// let foo = matches!(x, 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10);
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// let x = 6;
+    /// let foo = matches!(x, 1..=10);
+    /// ```
+    #[clippy::version = "1.72.0"]
+    pub MANUAL_RANGE_PATTERN,
+    complexity,
+    "manually writing range patterns using a combined OR pattern (`|`)"
+}
+declare_lint_pass!(ManualRangePattern => [MANUAL_RANGE_PATTERN]);
+
+fn expr_as_u128(expr: &Expr<'_>) -> Option<u128> {
+    if let ExprKind::Lit(lit) = expr.kind
+        && let LitKind::Int(num, _) = lit.node
+    {
+        Some(num)
+    } else {
+        None
+    }
+}
+
+impl LateLintPass<'_> for ManualRangePattern {
+    fn check_pat(&mut self, cx: &LateContext<'_>, pat: &'_ rustc_hir::Pat<'_>) {
+        if in_external_macro(cx.sess(), pat.span) {
+            return;
+        }
+
+        // a pattern like 1 | 2 seems fine, lint if there are at least 3 alternatives
+        if let PatKind::Or(pats) = pat.kind
+            && pats.len() >= 3
+        {
+            let mut min = u128::MAX;
+            let mut max = 0;
+            let mut numbers_found = FxHashSet::default();
+            let mut ranges_found = Vec::new();
+
+            for pat in pats {
+                if let PatKind::Lit(lit) = pat.kind
+                    && let Some(num) = expr_as_u128(lit)
+                {
+                    numbers_found.insert(num);
+
+                    min = min.min(num);
+                    max = max.max(num);
+                } else if let PatKind::Range(Some(left), Some(right), end) = pat.kind
+                    && let Some(left) = expr_as_u128(left)
+                    && let Some(right) = expr_as_u128(right)
+                    && right >= left
+                {
+                    min = min.min(left);
+                    max = max.max(right);
+                    ranges_found.push(left..=match end {
+                        RangeEnd::Included => right,
+                        RangeEnd::Excluded => right - 1,
+                    });
+                } else {
+                    return;
+                }
+            }
+
+            let contains_whole_range = 'contains: {
+                let mut num = min;
+                while num <= max {
+                    if numbers_found.contains(&num) {
+                        num += 1;
+                    }
+                    // Given a list of (potentially overlapping) ranges like:
+                    // 1..=5, 3..=7, 6..=10
+                    // We want to find the range with the highest end that still contains the current number
+                    else if let Some(range) = ranges_found
+                        .iter()
+                        .filter(|range| range.contains(&num))
+                        .max_by_key(|range| range.end())
+                    {
+                        num = range.end() + 1;
+                    } else {
+                        break 'contains false;
+                    }
+                }
+                break 'contains true;
+            };
+
+            if contains_whole_range {
+                span_lint_and_sugg(
+                    cx,
+                    MANUAL_RANGE_PATTERN,
+                    pat.span,
+                    "this OR pattern can be rewritten using a range",
+                    "try",
+                    format!("{min}..={max}"),
+                    Applicability::MachineApplicable,
+                );
+            }
+        }
+    }
+}
diff --git a/tests/ui/manual_range_pattern.fixed b/tests/ui/manual_range_pattern.fixed
new file mode 100644
index 00000000000..14a5f822d60
--- /dev/null
+++ b/tests/ui/manual_range_pattern.fixed
@@ -0,0 +1,35 @@
+//@run-rustfix
+
+#![allow(unused)]
+#![warn(clippy::manual_range_pattern)]
+#![feature(exclusive_range_pattern)]
+
+fn main() {
+    let f = 6;
+
+    let _ = matches!(f, 1..=10);
+    let _ = matches!(f, 1..=10);
+    let _ = matches!(f, 4 | 2 | 3 | 1 | 5 | 6 | 9 | 8 | 10); // 7 is missing
+    let _ = matches!(f, | 4);
+    let _ = matches!(f, 4 | 5);
+    let _ = matches!(f, 1 | 2147483647);
+    let _ = matches!(f, 0 | 2147483647);
+    let _ = matches!(f, -2147483647 | 2147483647);
+    let _ = matches!(f, 1 | (2..=4));
+    let _ = matches!(f, 1 | (2..4));
+    let _ = matches!(f, 1..=48324729);
+    let _ = matches!(f, 0..=48324730);
+    let _ = matches!(f, 0..=3);
+    #[allow(clippy::match_like_matches_macro)]
+    let _ = match f {
+        1..=10 => true,
+        _ => false,
+    };
+
+    macro_rules! mac {
+        ($e:expr) => {
+            matches!($e, 1..=10)
+        };
+    }
+    mac!(f);
+}
diff --git a/tests/ui/manual_range_pattern.rs b/tests/ui/manual_range_pattern.rs
new file mode 100644
index 00000000000..ea63953af04
--- /dev/null
+++ b/tests/ui/manual_range_pattern.rs
@@ -0,0 +1,35 @@
+//@run-rustfix
+
+#![allow(unused)]
+#![warn(clippy::manual_range_pattern)]
+#![feature(exclusive_range_pattern)]
+
+fn main() {
+    let f = 6;
+
+    let _ = matches!(f, 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10);
+    let _ = matches!(f, 4 | 2 | 3 | 1 | 5 | 6 | 9 | 7 | 8 | 10);
+    let _ = matches!(f, 4 | 2 | 3 | 1 | 5 | 6 | 9 | 8 | 10); // 7 is missing
+    let _ = matches!(f, | 4);
+    let _ = matches!(f, 4 | 5);
+    let _ = matches!(f, 1 | 2147483647);
+    let _ = matches!(f, 0 | 2147483647);
+    let _ = matches!(f, -2147483647 | 2147483647);
+    let _ = matches!(f, 1 | (2..=4));
+    let _ = matches!(f, 1 | (2..4));
+    let _ = matches!(f, (1..=10) | (2..=13) | (14..=48324728) | 48324729);
+    let _ = matches!(f, 0 | (1..=10) | 48324730 | (2..=13) | (14..=48324728) | 48324729);
+    let _ = matches!(f, 0..=1 | 0..=2 | 0..=3);
+    #[allow(clippy::match_like_matches_macro)]
+    let _ = match f {
+        1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 => true,
+        _ => false,
+    };
+
+    macro_rules! mac {
+        ($e:expr) => {
+            matches!($e, 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10)
+        };
+    }
+    mac!(f);
+}
diff --git a/tests/ui/manual_range_pattern.stderr b/tests/ui/manual_range_pattern.stderr
new file mode 100644
index 00000000000..a8969ede4e0
--- /dev/null
+++ b/tests/ui/manual_range_pattern.stderr
@@ -0,0 +1,51 @@
+error: this OR pattern can be rewritten using a range
+  --> $DIR/manual_range_pattern.rs:10:25
+   |
+LL |     let _ = matches!(f, 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10);
+   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `1..=10`
+   |
+   = note: `-D clippy::manual-range-pattern` implied by `-D warnings`
+
+error: this OR pattern can be rewritten using a range
+  --> $DIR/manual_range_pattern.rs:11:25
+   |
+LL |     let _ = matches!(f, 4 | 2 | 3 | 1 | 5 | 6 | 9 | 7 | 8 | 10);
+   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `1..=10`
+
+error: this OR pattern can be rewritten using a range
+  --> $DIR/manual_range_pattern.rs:20:25
+   |
+LL |     let _ = matches!(f, (1..=10) | (2..=13) | (14..=48324728) | 48324729);
+   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `1..=48324729`
+
+error: this OR pattern can be rewritten using a range
+  --> $DIR/manual_range_pattern.rs:21:25
+   |
+LL |     let _ = matches!(f, 0 | (1..=10) | 48324730 | (2..=13) | (14..=48324728) | 48324729);
+   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `0..=48324730`
+
+error: this OR pattern can be rewritten using a range
+  --> $DIR/manual_range_pattern.rs:22:25
+   |
+LL |     let _ = matches!(f, 0..=1 | 0..=2 | 0..=3);
+   |                         ^^^^^^^^^^^^^^^^^^^^^ help: try: `0..=3`
+
+error: this OR pattern can be rewritten using a range
+  --> $DIR/manual_range_pattern.rs:25:9
+   |
+LL |         1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 => true,
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `1..=10`
+
+error: this OR pattern can be rewritten using a range
+  --> $DIR/manual_range_pattern.rs:31:26
+   |
+LL |             matches!($e, 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10)
+   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `1..=10`
+...
+LL |     mac!(f);
+   |     ------- in this macro invocation
+   |
+   = note: this error originates in the macro `mac` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: aborting due to 7 previous errors
+
diff --git a/tests/ui/unnested_or_patterns.fixed b/tests/ui/unnested_or_patterns.fixed
index 4ce6e866695..ca999f241f7 100644
--- a/tests/ui/unnested_or_patterns.fixed
+++ b/tests/ui/unnested_or_patterns.fixed
@@ -6,7 +6,8 @@
     clippy::cognitive_complexity,
     clippy::match_ref_pats,
     clippy::upper_case_acronyms,
-    clippy::needless_if
+    clippy::needless_if,
+    clippy::manual_range_pattern
 )]
 #![allow(unreachable_patterns, irrefutable_let_patterns, unused)]
 
diff --git a/tests/ui/unnested_or_patterns.rs b/tests/ui/unnested_or_patterns.rs
index 07d60fac082..a09c3c66090 100644
--- a/tests/ui/unnested_or_patterns.rs
+++ b/tests/ui/unnested_or_patterns.rs
@@ -6,7 +6,8 @@
     clippy::cognitive_complexity,
     clippy::match_ref_pats,
     clippy::upper_case_acronyms,
-    clippy::needless_if
+    clippy::needless_if,
+    clippy::manual_range_pattern
 )]
 #![allow(unreachable_patterns, irrefutable_let_patterns, unused)]
 
diff --git a/tests/ui/unnested_or_patterns.stderr b/tests/ui/unnested_or_patterns.stderr
index d7b582fc8bd..b997e4ce85f 100644
--- a/tests/ui/unnested_or_patterns.stderr
+++ b/tests/ui/unnested_or_patterns.stderr
@@ -1,5 +1,5 @@
 error: unnested or-patterns
-  --> $DIR/unnested_or_patterns.rs:17:12
+  --> $DIR/unnested_or_patterns.rs:18:12
    |
 LL |     if let box 0 | box 2 = Box::new(0) {}
    |            ^^^^^^^^^^^^^
@@ -11,7 +11,7 @@ LL |     if let box (0 | 2) = Box::new(0) {}
    |            ~~~~~~~~~~~
 
 error: unnested or-patterns
-  --> $DIR/unnested_or_patterns.rs:18:12
+  --> $DIR/unnested_or_patterns.rs:19:12
    |
 LL |     if let box ((0 | 1)) | box (2 | 3) | box 4 = Box::new(0) {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -22,7 +22,7 @@ LL |     if let box (0 | 1 | 2 | 3 | 4) = Box::new(0) {}
    |            ~~~~~~~~~~~~~~~~~~~~~~~
 
 error: unnested or-patterns
-  --> $DIR/unnested_or_patterns.rs:20:12
+  --> $DIR/unnested_or_patterns.rs:21:12
    |
 LL |     if let Some(1) | C0 | Some(2) = None {}
    |            ^^^^^^^^^^^^^^^^^^^^^^
@@ -33,7 +33,7 @@ LL |     if let Some(1 | 2) | C0 = None {}
    |            ~~~~~~~~~~~~~~~~
 
 error: unnested or-patterns
-  --> $DIR/unnested_or_patterns.rs:21:12
+  --> $DIR/unnested_or_patterns.rs:22:12
    |
 LL |     if let &mut 0 | &mut 2 = &mut 0 {}
    |            ^^^^^^^^^^^^^^^
@@ -44,7 +44,7 @@ LL |     if let &mut (0 | 2) = &mut 0 {}
    |            ~~~~~~~~~~~~
 
 error: unnested or-patterns
-  --> $DIR/unnested_or_patterns.rs:22:12
+  --> $DIR/unnested_or_patterns.rs:23:12
    |
 LL |     if let x @ 0 | x @ 2 = 0 {}
    |            ^^^^^^^^^^^^^
@@ -55,7 +55,7 @@ LL |     if let x @ (0 | 2) = 0 {}
    |            ~~~~~~~~~~~
 
 error: unnested or-patterns
-  --> $DIR/unnested_or_patterns.rs:23:12
+  --> $DIR/unnested_or_patterns.rs:24:12
    |
 LL |     if let (0, 1) | (0, 2) | (0, 3) = (0, 0) {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -66,7 +66,7 @@ LL |     if let (0, 1 | 2 | 3) = (0, 0) {}
    |            ~~~~~~~~~~~~~~
 
 error: unnested or-patterns
-  --> $DIR/unnested_or_patterns.rs:24:12
+  --> $DIR/unnested_or_patterns.rs:25:12
    |
 LL |     if let (1, 0) | (2, 0) | (3, 0) = (0, 0) {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -77,7 +77,7 @@ LL |     if let (1 | 2 | 3, 0) = (0, 0) {}
    |            ~~~~~~~~~~~~~~
 
 error: unnested or-patterns
-  --> $DIR/unnested_or_patterns.rs:25:12
+  --> $DIR/unnested_or_patterns.rs:26:12
    |
 LL |     if let (x, ..) | (x, 1) | (x, 2) = (0, 1) {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -88,7 +88,7 @@ LL |     if let (x, ..) | (x, 1 | 2) = (0, 1) {}
    |            ~~~~~~~~~~~~~~~~~~~~
 
 error: unnested or-patterns
-  --> $DIR/unnested_or_patterns.rs:26:12
+  --> $DIR/unnested_or_patterns.rs:27:12
    |
 LL |     if let [0] | [1] = [0] {}
    |            ^^^^^^^^^
@@ -99,7 +99,7 @@ LL |     if let [0 | 1] = [0] {}
    |            ~~~~~~~
 
 error: unnested or-patterns
-  --> $DIR/unnested_or_patterns.rs:27:12
+  --> $DIR/unnested_or_patterns.rs:28:12
    |
 LL |     if let [x, 0] | [x, 1] = [0, 1] {}
    |            ^^^^^^^^^^^^^^^
@@ -110,7 +110,7 @@ LL |     if let [x, 0 | 1] = [0, 1] {}
    |            ~~~~~~~~~~
 
 error: unnested or-patterns
-  --> $DIR/unnested_or_patterns.rs:28:12
+  --> $DIR/unnested_or_patterns.rs:29:12
    |
 LL |     if let [x, 0] | [x, 1] | [x, 2] = [0, 1] {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -121,7 +121,7 @@ LL |     if let [x, 0 | 1 | 2] = [0, 1] {}
    |            ~~~~~~~~~~~~~~
 
 error: unnested or-patterns
-  --> $DIR/unnested_or_patterns.rs:29:12
+  --> $DIR/unnested_or_patterns.rs:30:12
    |
 LL |     if let [x, ..] | [x, 1] | [x, 2] = [0, 1] {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -132,7 +132,7 @@ LL |     if let [x, ..] | [x, 1 | 2] = [0, 1] {}
    |            ~~~~~~~~~~~~~~~~~~~~
 
 error: unnested or-patterns
-  --> $DIR/unnested_or_patterns.rs:31:12
+  --> $DIR/unnested_or_patterns.rs:32:12
    |
 LL |     if let TS(0, x) | TS(1, x) = TS(0, 0) {}
    |            ^^^^^^^^^^^^^^^^^^^
@@ -143,7 +143,7 @@ LL |     if let TS(0 | 1, x) = TS(0, 0) {}
    |            ~~~~~~~~~~~~
 
 error: unnested or-patterns
-  --> $DIR/unnested_or_patterns.rs:32:12
+  --> $DIR/unnested_or_patterns.rs:33:12
    |
 LL |     if let TS(1, 0) | TS(2, 0) | TS(3, 0) = TS(0, 0) {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -154,7 +154,7 @@ LL |     if let TS(1 | 2 | 3, 0) = TS(0, 0) {}
    |            ~~~~~~~~~~~~~~~~
 
 error: unnested or-patterns
-  --> $DIR/unnested_or_patterns.rs:33:12
+  --> $DIR/unnested_or_patterns.rs:34:12
    |
 LL |     if let TS(x, ..) | TS(x, 1) | TS(x, 2) = TS(0, 0) {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -165,7 +165,7 @@ LL |     if let TS(x, ..) | TS(x, 1 | 2) = TS(0, 0) {}
    |            ~~~~~~~~~~~~~~~~~~~~~~~~
 
 error: unnested or-patterns
-  --> $DIR/unnested_or_patterns.rs:38:12
+  --> $DIR/unnested_or_patterns.rs:39:12
    |
 LL |     if let S { x: 0, y } | S { y, x: 1 } = (S { x: 0, y: 1 }) {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -176,7 +176,7 @@ LL |     if let S { x: 0 | 1, y } = (S { x: 0, y: 1 }) {}
    |            ~~~~~~~~~~~~~~~~~
 
 error: unnested or-patterns
-  --> $DIR/unnested_or_patterns.rs:49:12
+  --> $DIR/unnested_or_patterns.rs:50:12
    |
 LL |     if let [1] | [53] = [0] {}
    |            ^^^^^^^^^^
diff --git a/tests/ui/unnested_or_patterns2.fixed b/tests/ui/unnested_or_patterns2.fixed
index a88d7f51ac0..ebaba019cfd 100644
--- a/tests/ui/unnested_or_patterns2.fixed
+++ b/tests/ui/unnested_or_patterns2.fixed
@@ -2,7 +2,12 @@
 
 #![feature(box_patterns)]
 #![warn(clippy::unnested_or_patterns)]
-#![allow(clippy::cognitive_complexity, clippy::match_ref_pats, clippy::needless_if)]
+#![allow(
+    clippy::cognitive_complexity,
+    clippy::match_ref_pats,
+    clippy::needless_if,
+    clippy::manual_range_pattern
+)]
 #![allow(unreachable_patterns, irrefutable_let_patterns, unused_variables)]
 
 fn main() {
diff --git a/tests/ui/unnested_or_patterns2.rs b/tests/ui/unnested_or_patterns2.rs
index f6029eee441..50b6ca585cf 100644
--- a/tests/ui/unnested_or_patterns2.rs
+++ b/tests/ui/unnested_or_patterns2.rs
@@ -2,7 +2,12 @@
 
 #![feature(box_patterns)]
 #![warn(clippy::unnested_or_patterns)]
-#![allow(clippy::cognitive_complexity, clippy::match_ref_pats, clippy::needless_if)]
+#![allow(
+    clippy::cognitive_complexity,
+    clippy::match_ref_pats,
+    clippy::needless_if,
+    clippy::manual_range_pattern
+)]
 #![allow(unreachable_patterns, irrefutable_let_patterns, unused_variables)]
 
 fn main() {
diff --git a/tests/ui/unnested_or_patterns2.stderr b/tests/ui/unnested_or_patterns2.stderr
index 41e8d3fc709..76e890b3a2e 100644
--- a/tests/ui/unnested_or_patterns2.stderr
+++ b/tests/ui/unnested_or_patterns2.stderr
@@ -1,5 +1,5 @@
 error: unnested or-patterns
-  --> $DIR/unnested_or_patterns2.rs:9:12
+  --> $DIR/unnested_or_patterns2.rs:14:12
    |
 LL |     if let Some(Some(0)) | Some(Some(1)) = None {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -11,7 +11,7 @@ LL |     if let Some(Some(0 | 1)) = None {}
    |            ~~~~~~~~~~~~~~~~~
 
 error: unnested or-patterns
-  --> $DIR/unnested_or_patterns2.rs:10:12
+  --> $DIR/unnested_or_patterns2.rs:15:12
    |
 LL |     if let Some(Some(0)) | Some(Some(1) | Some(2)) = None {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -22,7 +22,7 @@ LL |     if let Some(Some(0 | 1 | 2)) = None {}
    |            ~~~~~~~~~~~~~~~~~~~~~
 
 error: unnested or-patterns
-  --> $DIR/unnested_or_patterns2.rs:11:12
+  --> $DIR/unnested_or_patterns2.rs:16:12
    |
 LL |     if let Some(Some(0 | 1) | Some(2)) | Some(Some(3) | Some(4)) = None {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -33,7 +33,7 @@ LL |     if let Some(Some(0 | 1 | 2 | 3 | 4)) = None {}
    |            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 error: unnested or-patterns
-  --> $DIR/unnested_or_patterns2.rs:12:12
+  --> $DIR/unnested_or_patterns2.rs:17:12
    |
 LL |     if let Some(Some(0) | Some(1 | 2)) = None {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -44,7 +44,7 @@ LL |     if let Some(Some(0 | 1 | 2)) = None {}
    |            ~~~~~~~~~~~~~~~~~~~~~
 
 error: unnested or-patterns
-  --> $DIR/unnested_or_patterns2.rs:13:12
+  --> $DIR/unnested_or_patterns2.rs:18:12
    |
 LL |     if let ((0,),) | ((1,) | (2,),) = ((0,),) {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -55,7 +55,7 @@ LL |     if let ((0 | 1 | 2,),) = ((0,),) {}
    |            ~~~~~~~~~~~~~~~
 
 error: unnested or-patterns
-  --> $DIR/unnested_or_patterns2.rs:14:12
+  --> $DIR/unnested_or_patterns2.rs:19:12
    |
 LL |     if let 0 | (1 | 2) = 0 {}
    |            ^^^^^^^^^^^
@@ -66,7 +66,7 @@ LL |     if let 0 | 1 | 2 = 0 {}
    |            ~~~~~~~~~
 
 error: unnested or-patterns
-  --> $DIR/unnested_or_patterns2.rs:15:12
+  --> $DIR/unnested_or_patterns2.rs:20:12
    |
 LL |     if let box (0 | 1) | (box 2 | box (3 | 4)) = Box::new(0) {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -77,7 +77,7 @@ LL |     if let box (0 | 1 | 2 | 3 | 4) = Box::new(0) {}
    |            ~~~~~~~~~~~~~~~~~~~~~~~
 
 error: unnested or-patterns
-  --> $DIR/unnested_or_patterns2.rs:16:12
+  --> $DIR/unnested_or_patterns2.rs:21:12
    |
 LL |     if let box box 0 | box (box 2 | box 4) = Box::new(Box::new(0)) {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From b592d39968210a94d393e2eafa3a11af3011a5a0 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Tue, 20 Jun 2023 10:51:39 +0200
Subject: manual_range_pattern -> manual_range_patterns

---
 CHANGELOG.md                              |   2 +-
 clippy_lints/src/declared_lints.rs        |   2 +-
 clippy_lints/src/lib.rs                   |   4 +-
 clippy_lints/src/manual_range_pattern.rs  | 123 ------------------------------
 clippy_lints/src/manual_range_patterns.rs | 123 ++++++++++++++++++++++++++++++
 tests/ui/manual_range_pattern.fixed       |  35 ---------
 tests/ui/manual_range_pattern.rs          |  35 ---------
 tests/ui/manual_range_pattern.stderr      |  51 -------------
 tests/ui/manual_range_patterns.fixed      |  35 +++++++++
 tests/ui/manual_range_patterns.rs         |  35 +++++++++
 tests/ui/manual_range_patterns.stderr     |  51 +++++++++++++
 tests/ui/unnested_or_patterns.fixed       |   2 +-
 tests/ui/unnested_or_patterns.rs          |   2 +-
 tests/ui/unnested_or_patterns2.fixed      |   2 +-
 tests/ui/unnested_or_patterns2.rs         |   2 +-
 15 files changed, 252 insertions(+), 252 deletions(-)
 delete mode 100644 clippy_lints/src/manual_range_pattern.rs
 create mode 100644 clippy_lints/src/manual_range_patterns.rs
 delete mode 100644 tests/ui/manual_range_pattern.fixed
 delete mode 100644 tests/ui/manual_range_pattern.rs
 delete mode 100644 tests/ui/manual_range_pattern.stderr
 create mode 100644 tests/ui/manual_range_patterns.fixed
 create mode 100644 tests/ui/manual_range_patterns.rs
 create mode 100644 tests/ui/manual_range_patterns.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 045c269d62a..5193db5a35d 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4949,7 +4949,7 @@ Released 2018-09-13
 [`manual_non_exhaustive`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_non_exhaustive
 [`manual_ok_or`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_ok_or
 [`manual_range_contains`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_range_contains
-[`manual_range_pattern`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_range_pattern
+[`manual_range_patterns`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_range_patterns
 [`manual_rem_euclid`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_rem_euclid
 [`manual_retain`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_retain
 [`manual_saturating_arithmetic`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_saturating_arithmetic
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 53d92c089ea..881ff9baf18 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -278,7 +278,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::manual_let_else::MANUAL_LET_ELSE_INFO,
     crate::manual_main_separator_str::MANUAL_MAIN_SEPARATOR_STR_INFO,
     crate::manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE_INFO,
-    crate::manual_range_pattern::MANUAL_RANGE_PATTERN_INFO,
+    crate::manual_range_patterns::MANUAL_RANGE_PATTERNS_INFO,
     crate::manual_rem_euclid::MANUAL_REM_EUCLID_INFO,
     crate::manual_retain::MANUAL_RETAIN_INFO,
     crate::manual_slice_size_calculation::MANUAL_SLICE_SIZE_CALCULATION_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index d23dd29f815..0c71fdccae0 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -188,7 +188,7 @@ mod manual_is_ascii_check;
 mod manual_let_else;
 mod manual_main_separator_str;
 mod manual_non_exhaustive;
-mod manual_range_pattern;
+mod manual_range_patterns;
 mod manual_rem_euclid;
 mod manual_retain;
 mod manual_slice_size_calculation;
@@ -1069,7 +1069,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
             needless_raw_string_hashes_allow_one,
         })
     });
-    store.register_late_pass(|_| Box::new(manual_range_pattern::ManualRangePattern));
+    store.register_late_pass(|_| Box::new(manual_range_patterns::ManualRangePatterns));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/manual_range_pattern.rs b/clippy_lints/src/manual_range_pattern.rs
deleted file mode 100644
index 0ef75792b7a..00000000000
--- a/clippy_lints/src/manual_range_pattern.rs
+++ /dev/null
@@ -1,123 +0,0 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
-use rustc_ast::LitKind;
-use rustc_data_structures::fx::FxHashSet;
-use rustc_errors::Applicability;
-use rustc_hir::Expr;
-use rustc_hir::ExprKind;
-use rustc_hir::PatKind;
-use rustc_hir::RangeEnd;
-use rustc_lint::LintContext;
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::lint::in_external_macro;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Looks for combined OR patterns that are all contained in a specific range,
-    /// e.g. `6 | 4 | 5 | 9 | 7 | 8` can be rewritten as `4..=9`.
-    ///
-    /// ### Why is this bad?
-    /// Using an explicit range is more concise and easier to read.
-    ///
-    /// ### Example
-    /// ```rust
-    /// let x = 6;
-    /// let foo = matches!(x, 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10);
-    /// ```
-    /// Use instead:
-    /// ```rust
-    /// let x = 6;
-    /// let foo = matches!(x, 1..=10);
-    /// ```
-    #[clippy::version = "1.72.0"]
-    pub MANUAL_RANGE_PATTERN,
-    complexity,
-    "manually writing range patterns using a combined OR pattern (`|`)"
-}
-declare_lint_pass!(ManualRangePattern => [MANUAL_RANGE_PATTERN]);
-
-fn expr_as_u128(expr: &Expr<'_>) -> Option<u128> {
-    if let ExprKind::Lit(lit) = expr.kind
-        && let LitKind::Int(num, _) = lit.node
-    {
-        Some(num)
-    } else {
-        None
-    }
-}
-
-impl LateLintPass<'_> for ManualRangePattern {
-    fn check_pat(&mut self, cx: &LateContext<'_>, pat: &'_ rustc_hir::Pat<'_>) {
-        if in_external_macro(cx.sess(), pat.span) {
-            return;
-        }
-
-        // a pattern like 1 | 2 seems fine, lint if there are at least 3 alternatives
-        if let PatKind::Or(pats) = pat.kind
-            && pats.len() >= 3
-        {
-            let mut min = u128::MAX;
-            let mut max = 0;
-            let mut numbers_found = FxHashSet::default();
-            let mut ranges_found = Vec::new();
-
-            for pat in pats {
-                if let PatKind::Lit(lit) = pat.kind
-                    && let Some(num) = expr_as_u128(lit)
-                {
-                    numbers_found.insert(num);
-
-                    min = min.min(num);
-                    max = max.max(num);
-                } else if let PatKind::Range(Some(left), Some(right), end) = pat.kind
-                    && let Some(left) = expr_as_u128(left)
-                    && let Some(right) = expr_as_u128(right)
-                    && right >= left
-                {
-                    min = min.min(left);
-                    max = max.max(right);
-                    ranges_found.push(left..=match end {
-                        RangeEnd::Included => right,
-                        RangeEnd::Excluded => right - 1,
-                    });
-                } else {
-                    return;
-                }
-            }
-
-            let contains_whole_range = 'contains: {
-                let mut num = min;
-                while num <= max {
-                    if numbers_found.contains(&num) {
-                        num += 1;
-                    }
-                    // Given a list of (potentially overlapping) ranges like:
-                    // 1..=5, 3..=7, 6..=10
-                    // We want to find the range with the highest end that still contains the current number
-                    else if let Some(range) = ranges_found
-                        .iter()
-                        .filter(|range| range.contains(&num))
-                        .max_by_key(|range| range.end())
-                    {
-                        num = range.end() + 1;
-                    } else {
-                        break 'contains false;
-                    }
-                }
-                break 'contains true;
-            };
-
-            if contains_whole_range {
-                span_lint_and_sugg(
-                    cx,
-                    MANUAL_RANGE_PATTERN,
-                    pat.span,
-                    "this OR pattern can be rewritten using a range",
-                    "try",
-                    format!("{min}..={max}"),
-                    Applicability::MachineApplicable,
-                );
-            }
-        }
-    }
-}
diff --git a/clippy_lints/src/manual_range_patterns.rs b/clippy_lints/src/manual_range_patterns.rs
new file mode 100644
index 00000000000..65ff555209a
--- /dev/null
+++ b/clippy_lints/src/manual_range_patterns.rs
@@ -0,0 +1,123 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use rustc_ast::LitKind;
+use rustc_data_structures::fx::FxHashSet;
+use rustc_errors::Applicability;
+use rustc_hir::Expr;
+use rustc_hir::ExprKind;
+use rustc_hir::PatKind;
+use rustc_hir::RangeEnd;
+use rustc_lint::LintContext;
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::lint::in_external_macro;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Looks for combined OR patterns that are all contained in a specific range,
+    /// e.g. `6 | 4 | 5 | 9 | 7 | 8` can be rewritten as `4..=9`.
+    ///
+    /// ### Why is this bad?
+    /// Using an explicit range is more concise and easier to read.
+    ///
+    /// ### Example
+    /// ```rust
+    /// let x = 6;
+    /// let foo = matches!(x, 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10);
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// let x = 6;
+    /// let foo = matches!(x, 1..=10);
+    /// ```
+    #[clippy::version = "1.72.0"]
+    pub MANUAL_RANGE_PATTERNS,
+    complexity,
+    "manually writing range patterns using a combined OR pattern (`|`)"
+}
+declare_lint_pass!(ManualRangePatterns => [MANUAL_RANGE_PATTERNS]);
+
+fn expr_as_u128(expr: &Expr<'_>) -> Option<u128> {
+    if let ExprKind::Lit(lit) = expr.kind
+        && let LitKind::Int(num, _) = lit.node
+    {
+        Some(num)
+    } else {
+        None
+    }
+}
+
+impl LateLintPass<'_> for ManualRangePatterns {
+    fn check_pat(&mut self, cx: &LateContext<'_>, pat: &'_ rustc_hir::Pat<'_>) {
+        if in_external_macro(cx.sess(), pat.span) {
+            return;
+        }
+
+        // a pattern like 1 | 2 seems fine, lint if there are at least 3 alternatives
+        if let PatKind::Or(pats) = pat.kind
+            && pats.len() >= 3
+        {
+            let mut min = u128::MAX;
+            let mut max = 0;
+            let mut numbers_found = FxHashSet::default();
+            let mut ranges_found = Vec::new();
+
+            for pat in pats {
+                if let PatKind::Lit(lit) = pat.kind
+                    && let Some(num) = expr_as_u128(lit)
+                {
+                    numbers_found.insert(num);
+
+                    min = min.min(num);
+                    max = max.max(num);
+                } else if let PatKind::Range(Some(left), Some(right), end) = pat.kind
+                    && let Some(left) = expr_as_u128(left)
+                    && let Some(right) = expr_as_u128(right)
+                    && right >= left
+                {
+                    min = min.min(left);
+                    max = max.max(right);
+                    ranges_found.push(left..=match end {
+                        RangeEnd::Included => right,
+                        RangeEnd::Excluded => right - 1,
+                    });
+                } else {
+                    return;
+                }
+            }
+
+            let contains_whole_range = 'contains: {
+                let mut num = min;
+                while num <= max {
+                    if numbers_found.contains(&num) {
+                        num += 1;
+                    }
+                    // Given a list of (potentially overlapping) ranges like:
+                    // 1..=5, 3..=7, 6..=10
+                    // We want to find the range with the highest end that still contains the current number
+                    else if let Some(range) = ranges_found
+                        .iter()
+                        .filter(|range| range.contains(&num))
+                        .max_by_key(|range| range.end())
+                    {
+                        num = range.end() + 1;
+                    } else {
+                        break 'contains false;
+                    }
+                }
+                break 'contains true;
+            };
+
+            if contains_whole_range {
+                span_lint_and_sugg(
+                    cx,
+                    MANUAL_RANGE_PATTERNS,
+                    pat.span,
+                    "this OR pattern can be rewritten using a range",
+                    "try",
+                    format!("{min}..={max}"),
+                    Applicability::MachineApplicable,
+                );
+            }
+        }
+    }
+}
diff --git a/tests/ui/manual_range_pattern.fixed b/tests/ui/manual_range_pattern.fixed
deleted file mode 100644
index 14a5f822d60..00000000000
--- a/tests/ui/manual_range_pattern.fixed
+++ /dev/null
@@ -1,35 +0,0 @@
-//@run-rustfix
-
-#![allow(unused)]
-#![warn(clippy::manual_range_pattern)]
-#![feature(exclusive_range_pattern)]
-
-fn main() {
-    let f = 6;
-
-    let _ = matches!(f, 1..=10);
-    let _ = matches!(f, 1..=10);
-    let _ = matches!(f, 4 | 2 | 3 | 1 | 5 | 6 | 9 | 8 | 10); // 7 is missing
-    let _ = matches!(f, | 4);
-    let _ = matches!(f, 4 | 5);
-    let _ = matches!(f, 1 | 2147483647);
-    let _ = matches!(f, 0 | 2147483647);
-    let _ = matches!(f, -2147483647 | 2147483647);
-    let _ = matches!(f, 1 | (2..=4));
-    let _ = matches!(f, 1 | (2..4));
-    let _ = matches!(f, 1..=48324729);
-    let _ = matches!(f, 0..=48324730);
-    let _ = matches!(f, 0..=3);
-    #[allow(clippy::match_like_matches_macro)]
-    let _ = match f {
-        1..=10 => true,
-        _ => false,
-    };
-
-    macro_rules! mac {
-        ($e:expr) => {
-            matches!($e, 1..=10)
-        };
-    }
-    mac!(f);
-}
diff --git a/tests/ui/manual_range_pattern.rs b/tests/ui/manual_range_pattern.rs
deleted file mode 100644
index ea63953af04..00000000000
--- a/tests/ui/manual_range_pattern.rs
+++ /dev/null
@@ -1,35 +0,0 @@
-//@run-rustfix
-
-#![allow(unused)]
-#![warn(clippy::manual_range_pattern)]
-#![feature(exclusive_range_pattern)]
-
-fn main() {
-    let f = 6;
-
-    let _ = matches!(f, 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10);
-    let _ = matches!(f, 4 | 2 | 3 | 1 | 5 | 6 | 9 | 7 | 8 | 10);
-    let _ = matches!(f, 4 | 2 | 3 | 1 | 5 | 6 | 9 | 8 | 10); // 7 is missing
-    let _ = matches!(f, | 4);
-    let _ = matches!(f, 4 | 5);
-    let _ = matches!(f, 1 | 2147483647);
-    let _ = matches!(f, 0 | 2147483647);
-    let _ = matches!(f, -2147483647 | 2147483647);
-    let _ = matches!(f, 1 | (2..=4));
-    let _ = matches!(f, 1 | (2..4));
-    let _ = matches!(f, (1..=10) | (2..=13) | (14..=48324728) | 48324729);
-    let _ = matches!(f, 0 | (1..=10) | 48324730 | (2..=13) | (14..=48324728) | 48324729);
-    let _ = matches!(f, 0..=1 | 0..=2 | 0..=3);
-    #[allow(clippy::match_like_matches_macro)]
-    let _ = match f {
-        1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 => true,
-        _ => false,
-    };
-
-    macro_rules! mac {
-        ($e:expr) => {
-            matches!($e, 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10)
-        };
-    }
-    mac!(f);
-}
diff --git a/tests/ui/manual_range_pattern.stderr b/tests/ui/manual_range_pattern.stderr
deleted file mode 100644
index a8969ede4e0..00000000000
--- a/tests/ui/manual_range_pattern.stderr
+++ /dev/null
@@ -1,51 +0,0 @@
-error: this OR pattern can be rewritten using a range
-  --> $DIR/manual_range_pattern.rs:10:25
-   |
-LL |     let _ = matches!(f, 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10);
-   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `1..=10`
-   |
-   = note: `-D clippy::manual-range-pattern` implied by `-D warnings`
-
-error: this OR pattern can be rewritten using a range
-  --> $DIR/manual_range_pattern.rs:11:25
-   |
-LL |     let _ = matches!(f, 4 | 2 | 3 | 1 | 5 | 6 | 9 | 7 | 8 | 10);
-   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `1..=10`
-
-error: this OR pattern can be rewritten using a range
-  --> $DIR/manual_range_pattern.rs:20:25
-   |
-LL |     let _ = matches!(f, (1..=10) | (2..=13) | (14..=48324728) | 48324729);
-   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `1..=48324729`
-
-error: this OR pattern can be rewritten using a range
-  --> $DIR/manual_range_pattern.rs:21:25
-   |
-LL |     let _ = matches!(f, 0 | (1..=10) | 48324730 | (2..=13) | (14..=48324728) | 48324729);
-   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `0..=48324730`
-
-error: this OR pattern can be rewritten using a range
-  --> $DIR/manual_range_pattern.rs:22:25
-   |
-LL |     let _ = matches!(f, 0..=1 | 0..=2 | 0..=3);
-   |                         ^^^^^^^^^^^^^^^^^^^^^ help: try: `0..=3`
-
-error: this OR pattern can be rewritten using a range
-  --> $DIR/manual_range_pattern.rs:25:9
-   |
-LL |         1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 => true,
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `1..=10`
-
-error: this OR pattern can be rewritten using a range
-  --> $DIR/manual_range_pattern.rs:31:26
-   |
-LL |             matches!($e, 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10)
-   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `1..=10`
-...
-LL |     mac!(f);
-   |     ------- in this macro invocation
-   |
-   = note: this error originates in the macro `mac` (in Nightly builds, run with -Z macro-backtrace for more info)
-
-error: aborting due to 7 previous errors
-
diff --git a/tests/ui/manual_range_patterns.fixed b/tests/ui/manual_range_patterns.fixed
new file mode 100644
index 00000000000..9eee8f37187
--- /dev/null
+++ b/tests/ui/manual_range_patterns.fixed
@@ -0,0 +1,35 @@
+//@run-rustfix
+
+#![allow(unused)]
+#![warn(clippy::manual_range_patterns)]
+#![feature(exclusive_range_pattern)]
+
+fn main() {
+    let f = 6;
+
+    let _ = matches!(f, 1..=10);
+    let _ = matches!(f, 1..=10);
+    let _ = matches!(f, 4 | 2 | 3 | 1 | 5 | 6 | 9 | 8 | 10); // 7 is missing
+    let _ = matches!(f, | 4);
+    let _ = matches!(f, 4 | 5);
+    let _ = matches!(f, 1 | 2147483647);
+    let _ = matches!(f, 0 | 2147483647);
+    let _ = matches!(f, -2147483647 | 2147483647);
+    let _ = matches!(f, 1 | (2..=4));
+    let _ = matches!(f, 1 | (2..4));
+    let _ = matches!(f, 1..=48324729);
+    let _ = matches!(f, 0..=48324730);
+    let _ = matches!(f, 0..=3);
+    #[allow(clippy::match_like_matches_macro)]
+    let _ = match f {
+        1..=10 => true,
+        _ => false,
+    };
+
+    macro_rules! mac {
+        ($e:expr) => {
+            matches!($e, 1..=10)
+        };
+    }
+    mac!(f);
+}
diff --git a/tests/ui/manual_range_patterns.rs b/tests/ui/manual_range_patterns.rs
new file mode 100644
index 00000000000..10743a7d04c
--- /dev/null
+++ b/tests/ui/manual_range_patterns.rs
@@ -0,0 +1,35 @@
+//@run-rustfix
+
+#![allow(unused)]
+#![warn(clippy::manual_range_patterns)]
+#![feature(exclusive_range_pattern)]
+
+fn main() {
+    let f = 6;
+
+    let _ = matches!(f, 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10);
+    let _ = matches!(f, 4 | 2 | 3 | 1 | 5 | 6 | 9 | 7 | 8 | 10);
+    let _ = matches!(f, 4 | 2 | 3 | 1 | 5 | 6 | 9 | 8 | 10); // 7 is missing
+    let _ = matches!(f, | 4);
+    let _ = matches!(f, 4 | 5);
+    let _ = matches!(f, 1 | 2147483647);
+    let _ = matches!(f, 0 | 2147483647);
+    let _ = matches!(f, -2147483647 | 2147483647);
+    let _ = matches!(f, 1 | (2..=4));
+    let _ = matches!(f, 1 | (2..4));
+    let _ = matches!(f, (1..=10) | (2..=13) | (14..=48324728) | 48324729);
+    let _ = matches!(f, 0 | (1..=10) | 48324730 | (2..=13) | (14..=48324728) | 48324729);
+    let _ = matches!(f, 0..=1 | 0..=2 | 0..=3);
+    #[allow(clippy::match_like_matches_macro)]
+    let _ = match f {
+        1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 => true,
+        _ => false,
+    };
+
+    macro_rules! mac {
+        ($e:expr) => {
+            matches!($e, 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10)
+        };
+    }
+    mac!(f);
+}
diff --git a/tests/ui/manual_range_patterns.stderr b/tests/ui/manual_range_patterns.stderr
new file mode 100644
index 00000000000..bc9e3350164
--- /dev/null
+++ b/tests/ui/manual_range_patterns.stderr
@@ -0,0 +1,51 @@
+error: this OR pattern can be rewritten using a range
+  --> $DIR/manual_range_patterns.rs:10:25
+   |
+LL |     let _ = matches!(f, 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10);
+   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `1..=10`
+   |
+   = note: `-D clippy::manual-range-patterns` implied by `-D warnings`
+
+error: this OR pattern can be rewritten using a range
+  --> $DIR/manual_range_patterns.rs:11:25
+   |
+LL |     let _ = matches!(f, 4 | 2 | 3 | 1 | 5 | 6 | 9 | 7 | 8 | 10);
+   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `1..=10`
+
+error: this OR pattern can be rewritten using a range
+  --> $DIR/manual_range_patterns.rs:20:25
+   |
+LL |     let _ = matches!(f, (1..=10) | (2..=13) | (14..=48324728) | 48324729);
+   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `1..=48324729`
+
+error: this OR pattern can be rewritten using a range
+  --> $DIR/manual_range_patterns.rs:21:25
+   |
+LL |     let _ = matches!(f, 0 | (1..=10) | 48324730 | (2..=13) | (14..=48324728) | 48324729);
+   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `0..=48324730`
+
+error: this OR pattern can be rewritten using a range
+  --> $DIR/manual_range_patterns.rs:22:25
+   |
+LL |     let _ = matches!(f, 0..=1 | 0..=2 | 0..=3);
+   |                         ^^^^^^^^^^^^^^^^^^^^^ help: try: `0..=3`
+
+error: this OR pattern can be rewritten using a range
+  --> $DIR/manual_range_patterns.rs:25:9
+   |
+LL |         1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 => true,
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `1..=10`
+
+error: this OR pattern can be rewritten using a range
+  --> $DIR/manual_range_patterns.rs:31:26
+   |
+LL |             matches!($e, 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10)
+   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `1..=10`
+...
+LL |     mac!(f);
+   |     ------- in this macro invocation
+   |
+   = note: this error originates in the macro `mac` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: aborting due to 7 previous errors
+
diff --git a/tests/ui/unnested_or_patterns.fixed b/tests/ui/unnested_or_patterns.fixed
index ca999f241f7..738045595c0 100644
--- a/tests/ui/unnested_or_patterns.fixed
+++ b/tests/ui/unnested_or_patterns.fixed
@@ -7,7 +7,7 @@
     clippy::match_ref_pats,
     clippy::upper_case_acronyms,
     clippy::needless_if,
-    clippy::manual_range_pattern
+    clippy::manual_range_patterns
 )]
 #![allow(unreachable_patterns, irrefutable_let_patterns, unused)]
 
diff --git a/tests/ui/unnested_or_patterns.rs b/tests/ui/unnested_or_patterns.rs
index a09c3c66090..9e0e7b5def9 100644
--- a/tests/ui/unnested_or_patterns.rs
+++ b/tests/ui/unnested_or_patterns.rs
@@ -7,7 +7,7 @@
     clippy::match_ref_pats,
     clippy::upper_case_acronyms,
     clippy::needless_if,
-    clippy::manual_range_pattern
+    clippy::manual_range_patterns
 )]
 #![allow(unreachable_patterns, irrefutable_let_patterns, unused)]
 
diff --git a/tests/ui/unnested_or_patterns2.fixed b/tests/ui/unnested_or_patterns2.fixed
index ebaba019cfd..11dc3437875 100644
--- a/tests/ui/unnested_or_patterns2.fixed
+++ b/tests/ui/unnested_or_patterns2.fixed
@@ -6,7 +6,7 @@
     clippy::cognitive_complexity,
     clippy::match_ref_pats,
     clippy::needless_if,
-    clippy::manual_range_pattern
+    clippy::manual_range_patterns
 )]
 #![allow(unreachable_patterns, irrefutable_let_patterns, unused_variables)]
 
diff --git a/tests/ui/unnested_or_patterns2.rs b/tests/ui/unnested_or_patterns2.rs
index 50b6ca585cf..b2556082741 100644
--- a/tests/ui/unnested_or_patterns2.rs
+++ b/tests/ui/unnested_or_patterns2.rs
@@ -6,7 +6,7 @@
     clippy::cognitive_complexity,
     clippy::match_ref_pats,
     clippy::needless_if,
-    clippy::manual_range_pattern
+    clippy::manual_range_patterns
 )]
 #![allow(unreachable_patterns, irrefutable_let_patterns, unused_variables)]
 
-- 
cgit 1.4.1-3-g733a5


From 3376c714ee32c1e54f8dd71332d49f200ae87294 Mon Sep 17 00:00:00 2001
From: Catherine <114838443+Centri3@users.noreply.github.com>
Date: Tue, 27 Jun 2023 20:10:25 -0500
Subject: Add note to remove `if` statement altogether

---
 clippy_lints/src/misc_early/mod.rs | 2 ++
 1 file changed, 2 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/misc_early/mod.rs b/clippy_lints/src/misc_early/mod.rs
index cff8538095d..b226b878123 100644
--- a/clippy_lints/src/misc_early/mod.rs
+++ b/clippy_lints/src/misc_early/mod.rs
@@ -340,6 +340,8 @@ declare_clippy_lint! {
     ///     // NOTE: Type is a `Vec` here
     ///     println!("all elements: {all:#?}");
     /// }
+    /// // or
+    /// println!("all elements: {v:#?}");
     /// ```
     #[clippy::version = "1.72.0"]
     pub REDUNDANT_AT_REST_PATTERN,
-- 
cgit 1.4.1-3-g733a5


From 8296a338dba7af1db8a6aff862c4ad46402dc111 Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Fri, 16 Jun 2023 10:51:47 -0500
Subject: new lints for visibility

---
 CHANGELOG.md                          |   3 +
 clippy_lints/src/declared_lints.rs    |   3 +
 clippy_lints/src/lib.rs               |   2 +
 clippy_lints/src/visibility.rs        | 127 ++++++++++++++++++++++++++++++++++
 tests/ui/manual_async_fn.fixed        |   2 +-
 tests/ui/manual_async_fn.rs           |   2 +-
 tests/ui/needless_pub_self.fixed      |  33 +++++++++
 tests/ui/needless_pub_self.rs         |  33 +++++++++
 tests/ui/needless_pub_self.stderr     |  22 ++++++
 tests/ui/pub_with_shorthand.fixed     |  38 ++++++++++
 tests/ui/pub_with_shorthand.rs        |  38 ++++++++++
 tests/ui/pub_with_shorthand.stderr    |  28 ++++++++
 tests/ui/pub_without_shorthand.fixed  |  38 ++++++++++
 tests/ui/pub_without_shorthand.rs     |  38 ++++++++++
 tests/ui/pub_without_shorthand.stderr |  22 ++++++
 15 files changed, 427 insertions(+), 2 deletions(-)
 create mode 100644 clippy_lints/src/visibility.rs
 create mode 100644 tests/ui/needless_pub_self.fixed
 create mode 100644 tests/ui/needless_pub_self.rs
 create mode 100644 tests/ui/needless_pub_self.stderr
 create mode 100644 tests/ui/pub_with_shorthand.fixed
 create mode 100644 tests/ui/pub_with_shorthand.rs
 create mode 100644 tests/ui/pub_with_shorthand.stderr
 create mode 100644 tests/ui/pub_without_shorthand.fixed
 create mode 100644 tests/ui/pub_without_shorthand.rs
 create mode 100644 tests/ui/pub_without_shorthand.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5193db5a35d..4debe304857 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5047,6 +5047,7 @@ Released 2018-09-13
 [`needless_option_take`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_option_take
 [`needless_parens_on_range_literals`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_parens_on_range_literals
 [`needless_pass_by_value`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_pass_by_value
+[`needless_pub_self`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_pub_self
 [`needless_question_mark`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_question_mark
 [`needless_range_loop`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_range_loop
 [`needless_raw_string_hashes`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_raw_string_hashes
@@ -5121,6 +5122,8 @@ Released 2018-09-13
 [`ptr_offset_with_cast`]: https://rust-lang.github.io/rust-clippy/master/index.html#ptr_offset_with_cast
 [`pub_enum_variant_names`]: https://rust-lang.github.io/rust-clippy/master/index.html#pub_enum_variant_names
 [`pub_use`]: https://rust-lang.github.io/rust-clippy/master/index.html#pub_use
+[`pub_with_shorthand`]: https://rust-lang.github.io/rust-clippy/master/index.html#pub_with_shorthand
+[`pub_without_shorthand`]: https://rust-lang.github.io/rust-clippy/master/index.html#pub_without_shorthand
 [`question_mark`]: https://rust-lang.github.io/rust-clippy/master/index.html#question_mark
 [`question_mark_used`]: https://rust-lang.github.io/rust-clippy/master/index.html#question_mark_used
 [`range_minus_one`]: https://rust-lang.github.io/rust-clippy/master/index.html#range_minus_one
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 881ff9baf18..46f4082f0c7 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -666,6 +666,9 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::useless_conversion::USELESS_CONVERSION_INFO,
     crate::vec::USELESS_VEC_INFO,
     crate::vec_init_then_push::VEC_INIT_THEN_PUSH_INFO,
+    crate::visibility::NEEDLESS_PUB_SELF_INFO,
+    crate::visibility::PUB_WITHOUT_SHORTHAND_INFO,
+    crate::visibility::PUB_WITH_SHORTHAND_INFO,
     crate::wildcard_imports::ENUM_GLOB_USE_INFO,
     crate::wildcard_imports::WILDCARD_IMPORTS_INFO,
     crate::write::PRINTLN_EMPTY_STRING_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 0c71fdccae0..2f88fe8dcd5 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -338,6 +338,7 @@ mod use_self;
 mod useless_conversion;
 mod vec;
 mod vec_init_then_push;
+mod visibility;
 mod wildcard_imports;
 mod write;
 mod zero_div_zero;
@@ -1070,6 +1071,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         })
     });
     store.register_late_pass(|_| Box::new(manual_range_patterns::ManualRangePatterns));
+    store.register_early_pass(|| Box::new(visibility::Visibility));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/visibility.rs b/clippy_lints/src/visibility.rs
new file mode 100644
index 00000000000..635d0ab9652
--- /dev/null
+++ b/clippy_lints/src/visibility.rs
@@ -0,0 +1,127 @@
+use clippy_utils::{diagnostics::span_lint_and_sugg, source::snippet_opt};
+use rustc_ast::ast::{Item, VisibilityKind};
+use rustc_errors::Applicability;
+use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
+use rustc_middle::lint::in_external_macro;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::{symbol::kw, Span};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of `pub(self)` and `pub(in self)`.
+    ///
+    /// ### Why is this bad?
+    /// It's unnecessary, omitting the `pub` entirely will give the same results.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// pub(self) type OptBox<T> = Option<Box<T>>;
+    /// ```
+    /// Use instead:
+    /// ```rust,ignore
+    /// type OptBox<T> = Option<Box<T>>;
+    /// ```
+    #[clippy::version = "1.72.0"]
+    pub NEEDLESS_PUB_SELF,
+    complexity,
+    "checks for usage of `pub(self)` and `pub(in self)`."
+}
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for missing usage of the `pub(in <loc>)` shorthand.
+    ///
+    /// ### Why is this bad?
+    /// Consistency. Use it or don't, just be consistent about it.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// pub(super) type OptBox<T> = Option<Box<T>>;
+    /// ```
+    /// Use instead:
+    /// ```rust,ignore
+    /// pub(in super) type OptBox<T> = Option<Box<T>>;
+    /// ```
+    #[clippy::version = "1.72.0"]
+    pub PUB_WITH_SHORTHAND,
+    restriction,
+    "disallows usage of the `pub(<loc>)`, suggesting use of the `in` shorthand"
+}
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of the `pub(in <loc>)` shorthand.
+    ///
+    /// Note: As you cannot write a module's path in `pub(<loc>)`, this will only trigger on
+    /// `pub(super)` and the like.
+    ///
+    /// ### Why is this bad?
+    /// Consistency. Use it or don't, just be consistent about it.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// pub(in super) type OptBox<T> = Option<Box<T>>;
+    /// ```
+    /// Use instead:
+    /// ```rust,ignore
+    /// pub(super) type OptBox<T> = Option<Box<T>>;
+    /// ```
+    #[clippy::version = "1.72.0"]
+    pub PUB_WITHOUT_SHORTHAND,
+    restriction,
+    "disallows usage of the `pub(in <loc>)` shorthand wherever possible"
+}
+declare_lint_pass!(Visibility => [NEEDLESS_PUB_SELF, PUB_WITH_SHORTHAND, PUB_WITHOUT_SHORTHAND]);
+
+impl EarlyLintPass for Visibility {
+    fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {
+        if !in_external_macro(cx.sess(), item.span)
+            && let VisibilityKind::Restricted { path, shorthand, .. } = &item.vis.kind
+        {
+            if **path == kw::SelfLower && let Some(false) = is_from_proc_macro(cx, item.vis.span) {
+                span_lint_and_sugg(
+                    cx,
+                    NEEDLESS_PUB_SELF,
+                    item.vis.span,
+                    &format!("unnecessary `pub({}self)`", if *shorthand { "" } else { "in " }),
+                    "remove it",
+                    String::new(),
+                    Applicability::MachineApplicable,
+                );
+            }
+
+            if (**path == kw::Super || **path == kw::SelfLower || **path == kw::Crate)
+                && !*shorthand
+                && let [.., last] = &*path.segments
+                && let Some(false) = is_from_proc_macro(cx, item.vis.span)
+            {
+                span_lint_and_sugg(
+                    cx,
+                    PUB_WITHOUT_SHORTHAND,
+                    item.vis.span,
+                    "usage of `pub` with `in`",
+                    "remove it",
+                    format!("pub({})", last.ident),
+                    Applicability::MachineApplicable,
+                );
+            }
+
+            if *shorthand
+                && let [.., last] = &*path.segments
+                && let Some(false) = is_from_proc_macro(cx, item.vis.span)
+            {
+                span_lint_and_sugg(
+                    cx,
+                    PUB_WITH_SHORTHAND,
+                    item.vis.span,
+                    "usage of `pub` without `in`",
+                    "add it",
+                    format!("pub(in {})", last.ident),
+                    Applicability::MachineApplicable,
+                );
+            }
+        }
+    }
+}
+
+fn is_from_proc_macro(cx: &EarlyContext<'_>, span: Span) -> Option<bool> {
+    snippet_opt(cx, span).map(|s| !s.starts_with("pub"))
+}
diff --git a/tests/ui/manual_async_fn.fixed b/tests/ui/manual_async_fn.fixed
index e458f0d254f..e609b4b1bdb 100644
--- a/tests/ui/manual_async_fn.fixed
+++ b/tests/ui/manual_async_fn.fixed
@@ -1,6 +1,6 @@
 //@run-rustfix
 #![warn(clippy::manual_async_fn)]
-#![allow(unused)]
+#![allow(clippy::needless_pub_self, unused)]
 
 use std::future::Future;
 
diff --git a/tests/ui/manual_async_fn.rs b/tests/ui/manual_async_fn.rs
index dd5ca1c9b5b..6c1a9edaa11 100644
--- a/tests/ui/manual_async_fn.rs
+++ b/tests/ui/manual_async_fn.rs
@@ -1,6 +1,6 @@
 //@run-rustfix
 #![warn(clippy::manual_async_fn)]
-#![allow(unused)]
+#![allow(clippy::needless_pub_self, unused)]
 
 use std::future::Future;
 
diff --git a/tests/ui/needless_pub_self.fixed b/tests/ui/needless_pub_self.fixed
new file mode 100644
index 00000000000..bf5e70d9a05
--- /dev/null
+++ b/tests/ui/needless_pub_self.fixed
@@ -0,0 +1,33 @@
+//@run-rustfix
+//@aux-build:proc_macros.rs
+#![feature(custom_inner_attributes)]
+#![allow(unused)]
+#![warn(clippy::needless_pub_self)]
+#![no_main]
+#![rustfmt::skip] // rustfmt will remove `in`, understandable
+                  // but very annoying for our purposes!
+
+#[macro_use]
+extern crate proc_macros;
+
+ fn a() {}
+ fn b() {}
+
+pub fn c() {}
+mod a {
+    pub(in super) fn d() {}
+    pub(super) fn e() {}
+     fn f() {}
+}
+
+external! {
+    pub(self) fn g() {}
+    pub(in self) fn h() {}
+}
+with_span! {
+    span
+    pub(self) fn i() {}
+    pub(in self) fn j() {}
+}
+
+// not really anything more to test. just a really simple lint overall
diff --git a/tests/ui/needless_pub_self.rs b/tests/ui/needless_pub_self.rs
new file mode 100644
index 00000000000..a49a6658f8b
--- /dev/null
+++ b/tests/ui/needless_pub_self.rs
@@ -0,0 +1,33 @@
+//@run-rustfix
+//@aux-build:proc_macros.rs
+#![feature(custom_inner_attributes)]
+#![allow(unused)]
+#![warn(clippy::needless_pub_self)]
+#![no_main]
+#![rustfmt::skip] // rustfmt will remove `in`, understandable
+                  // but very annoying for our purposes!
+
+#[macro_use]
+extern crate proc_macros;
+
+pub(self) fn a() {}
+pub(in self) fn b() {}
+
+pub fn c() {}
+mod a {
+    pub(in super) fn d() {}
+    pub(super) fn e() {}
+    pub(self) fn f() {}
+}
+
+external! {
+    pub(self) fn g() {}
+    pub(in self) fn h() {}
+}
+with_span! {
+    span
+    pub(self) fn i() {}
+    pub(in self) fn j() {}
+}
+
+// not really anything more to test. just a really simple lint overall
diff --git a/tests/ui/needless_pub_self.stderr b/tests/ui/needless_pub_self.stderr
new file mode 100644
index 00000000000..3aa2feb5ecd
--- /dev/null
+++ b/tests/ui/needless_pub_self.stderr
@@ -0,0 +1,22 @@
+error: unnecessary `pub(self)`
+  --> $DIR/needless_pub_self.rs:13:1
+   |
+LL | pub(self) fn a() {}
+   | ^^^^^^^^^ help: remove it
+   |
+   = note: `-D clippy::needless-pub-self` implied by `-D warnings`
+
+error: unnecessary `pub(in self)`
+  --> $DIR/needless_pub_self.rs:14:1
+   |
+LL | pub(in self) fn b() {}
+   | ^^^^^^^^^^^^ help: remove it
+
+error: unnecessary `pub(self)`
+  --> $DIR/needless_pub_self.rs:20:5
+   |
+LL |     pub(self) fn f() {}
+   |     ^^^^^^^^^ help: remove it
+
+error: aborting due to 3 previous errors
+
diff --git a/tests/ui/pub_with_shorthand.fixed b/tests/ui/pub_with_shorthand.fixed
new file mode 100644
index 00000000000..c9487ed7fc3
--- /dev/null
+++ b/tests/ui/pub_with_shorthand.fixed
@@ -0,0 +1,38 @@
+//@run-rustfix
+//@aux-build:proc_macros.rs
+#![feature(custom_inner_attributes)]
+#![allow(clippy::needless_pub_self, unused)]
+#![warn(clippy::pub_with_shorthand)]
+#![no_main]
+#![rustfmt::skip] // rustfmt will remove `in`, understandable
+                  // but very annoying for our purposes!
+
+#[macro_use]
+extern crate proc_macros;
+
+pub(in self) fn a() {}
+pub(in self) fn b() {}
+
+pub fn c() {}
+mod a {
+    pub(in super) fn d() {}
+    pub(in super) fn e() {}
+    pub(in self) fn f() {}
+    pub(in crate) fn k() {}
+    pub(in crate) fn m() {}
+    mod b {
+        pub(in crate::a) fn l() {}
+    }
+}
+
+external! {
+    pub(self) fn g() {}
+    pub(in self) fn h() {}
+}
+with_span! {
+    span
+    pub(self) fn i() {}
+    pub(in self) fn j() {}
+}
+
+// not really anything more to test. just a really simple lint overall
diff --git a/tests/ui/pub_with_shorthand.rs b/tests/ui/pub_with_shorthand.rs
new file mode 100644
index 00000000000..e47c926520b
--- /dev/null
+++ b/tests/ui/pub_with_shorthand.rs
@@ -0,0 +1,38 @@
+//@run-rustfix
+//@aux-build:proc_macros.rs
+#![feature(custom_inner_attributes)]
+#![allow(clippy::needless_pub_self, unused)]
+#![warn(clippy::pub_with_shorthand)]
+#![no_main]
+#![rustfmt::skip] // rustfmt will remove `in`, understandable
+                  // but very annoying for our purposes!
+
+#[macro_use]
+extern crate proc_macros;
+
+pub(self) fn a() {}
+pub(in self) fn b() {}
+
+pub fn c() {}
+mod a {
+    pub(in super) fn d() {}
+    pub(super) fn e() {}
+    pub(self) fn f() {}
+    pub(crate) fn k() {}
+    pub(in crate) fn m() {}
+    mod b {
+        pub(in crate::a) fn l() {}
+    }
+}
+
+external! {
+    pub(self) fn g() {}
+    pub(in self) fn h() {}
+}
+with_span! {
+    span
+    pub(self) fn i() {}
+    pub(in self) fn j() {}
+}
+
+// not really anything more to test. just a really simple lint overall
diff --git a/tests/ui/pub_with_shorthand.stderr b/tests/ui/pub_with_shorthand.stderr
new file mode 100644
index 00000000000..323b5a23b24
--- /dev/null
+++ b/tests/ui/pub_with_shorthand.stderr
@@ -0,0 +1,28 @@
+error: usage of `pub` without `in`
+  --> $DIR/pub_with_shorthand.rs:13:1
+   |
+LL | pub(self) fn a() {}
+   | ^^^^^^^^^ help: add it: `pub(in self)`
+   |
+   = note: `-D clippy::pub-with-shorthand` implied by `-D warnings`
+
+error: usage of `pub` without `in`
+  --> $DIR/pub_with_shorthand.rs:19:5
+   |
+LL |     pub(super) fn e() {}
+   |     ^^^^^^^^^^ help: add it: `pub(in super)`
+
+error: usage of `pub` without `in`
+  --> $DIR/pub_with_shorthand.rs:20:5
+   |
+LL |     pub(self) fn f() {}
+   |     ^^^^^^^^^ help: add it: `pub(in self)`
+
+error: usage of `pub` without `in`
+  --> $DIR/pub_with_shorthand.rs:21:5
+   |
+LL |     pub(crate) fn k() {}
+   |     ^^^^^^^^^^ help: add it: `pub(in crate)`
+
+error: aborting due to 4 previous errors
+
diff --git a/tests/ui/pub_without_shorthand.fixed b/tests/ui/pub_without_shorthand.fixed
new file mode 100644
index 00000000000..55159efb5bf
--- /dev/null
+++ b/tests/ui/pub_without_shorthand.fixed
@@ -0,0 +1,38 @@
+//@run-rustfix
+//@aux-build:proc_macros.rs
+#![feature(custom_inner_attributes)]
+#![allow(clippy::needless_pub_self, unused)]
+#![warn(clippy::pub_without_shorthand)]
+#![no_main]
+#![rustfmt::skip] // rustfmt will remove `in`, understandable
+                  // but very annoying for our purposes!
+
+#[macro_use]
+extern crate proc_macros;
+
+pub(self) fn a() {}
+pub(self) fn b() {}
+
+pub fn c() {}
+mod a {
+    pub(super) fn d() {}
+    pub(super) fn e() {}
+    pub(self) fn f() {}
+    pub(crate) fn k() {}
+    pub(crate) fn m() {}
+    mod b {
+        pub(in crate::a) fn l() {}
+    }
+}
+
+external! {
+    pub(self) fn g() {}
+    pub(in self) fn h() {}
+}
+with_span! {
+    span
+    pub(self) fn i() {}
+    pub(in self) fn j() {}
+}
+
+// not really anything more to test. just a really simple lint overall
diff --git a/tests/ui/pub_without_shorthand.rs b/tests/ui/pub_without_shorthand.rs
new file mode 100644
index 00000000000..38f4da85a49
--- /dev/null
+++ b/tests/ui/pub_without_shorthand.rs
@@ -0,0 +1,38 @@
+//@run-rustfix
+//@aux-build:proc_macros.rs
+#![feature(custom_inner_attributes)]
+#![allow(clippy::needless_pub_self, unused)]
+#![warn(clippy::pub_without_shorthand)]
+#![no_main]
+#![rustfmt::skip] // rustfmt will remove `in`, understandable
+                  // but very annoying for our purposes!
+
+#[macro_use]
+extern crate proc_macros;
+
+pub(self) fn a() {}
+pub(in self) fn b() {}
+
+pub fn c() {}
+mod a {
+    pub(in super) fn d() {}
+    pub(super) fn e() {}
+    pub(self) fn f() {}
+    pub(crate) fn k() {}
+    pub(in crate) fn m() {}
+    mod b {
+        pub(in crate::a) fn l() {}
+    }
+}
+
+external! {
+    pub(self) fn g() {}
+    pub(in self) fn h() {}
+}
+with_span! {
+    span
+    pub(self) fn i() {}
+    pub(in self) fn j() {}
+}
+
+// not really anything more to test. just a really simple lint overall
diff --git a/tests/ui/pub_without_shorthand.stderr b/tests/ui/pub_without_shorthand.stderr
new file mode 100644
index 00000000000..a18c9bf8934
--- /dev/null
+++ b/tests/ui/pub_without_shorthand.stderr
@@ -0,0 +1,22 @@
+error: usage of `pub` with `in`
+  --> $DIR/pub_without_shorthand.rs:14:1
+   |
+LL | pub(in self) fn b() {}
+   | ^^^^^^^^^^^^ help: remove it: `pub(self)`
+   |
+   = note: `-D clippy::pub-without-shorthand` implied by `-D warnings`
+
+error: usage of `pub` with `in`
+  --> $DIR/pub_without_shorthand.rs:18:5
+   |
+LL |     pub(in super) fn d() {}
+   |     ^^^^^^^^^^^^^ help: remove it: `pub(super)`
+
+error: usage of `pub` with `in`
+  --> $DIR/pub_without_shorthand.rs:22:5
+   |
+LL |     pub(in crate) fn m() {}
+   |     ^^^^^^^^^^^^^ help: remove it: `pub(crate)`
+
+error: aborting due to 3 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 46aa8abf08057618038c60c11b98a3c6cff927de Mon Sep 17 00:00:00 2001
From: Catherine <114838443+Centri3@users.noreply.github.com>
Date: Tue, 27 Jun 2023 05:25:54 -0500
Subject: Change category and update to `ui_test`

---
 clippy_lints/src/visibility.rs       | 14 +++++++++-----
 tests/ui/needless_pub_self.fixed     |  2 +-
 tests/ui/needless_pub_self.rs        |  2 +-
 tests/ui/pub_with_shorthand.fixed    |  2 +-
 tests/ui/pub_with_shorthand.rs       |  2 +-
 tests/ui/pub_without_shorthand.fixed |  2 +-
 tests/ui/pub_without_shorthand.rs    |  2 +-
 7 files changed, 15 insertions(+), 11 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/visibility.rs b/clippy_lints/src/visibility.rs
index 635d0ab9652..43248bccc13 100644
--- a/clippy_lints/src/visibility.rs
+++ b/clippy_lints/src/visibility.rs
@@ -23,16 +23,18 @@ declare_clippy_lint! {
     /// ```
     #[clippy::version = "1.72.0"]
     pub NEEDLESS_PUB_SELF,
-    complexity,
+    style,
     "checks for usage of `pub(self)` and `pub(in self)`."
 }
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for missing usage of the `pub(in <loc>)` shorthand.
+    /// Checks for usage of `pub(<loc>)` with `in`.
     ///
     /// ### Why is this bad?
     /// Consistency. Use it or don't, just be consistent about it.
     ///
+    /// Also see the `pub_without_shorthand` lint for an alternative.
+    ///
     /// ### Example
     /// ```rust,ignore
     /// pub(super) type OptBox<T> = Option<Box<T>>;
@@ -44,11 +46,11 @@ declare_clippy_lint! {
     #[clippy::version = "1.72.0"]
     pub PUB_WITH_SHORTHAND,
     restriction,
-    "disallows usage of the `pub(<loc>)`, suggesting use of the `in` shorthand"
+    "disallows usage of `pub(<loc>)`, without `in`"
 }
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of the `pub(in <loc>)` shorthand.
+    /// Checks for usage of `pub(<loc>)` without `in`.
     ///
     /// Note: As you cannot write a module's path in `pub(<loc>)`, this will only trigger on
     /// `pub(super)` and the like.
@@ -56,6 +58,8 @@ declare_clippy_lint! {
     /// ### Why is this bad?
     /// Consistency. Use it or don't, just be consistent about it.
     ///
+    /// Also see the `pub_with_shorthand` lint for an alternative.
+    ///
     /// ### Example
     /// ```rust,ignore
     /// pub(in super) type OptBox<T> = Option<Box<T>>;
@@ -67,7 +71,7 @@ declare_clippy_lint! {
     #[clippy::version = "1.72.0"]
     pub PUB_WITHOUT_SHORTHAND,
     restriction,
-    "disallows usage of the `pub(in <loc>)` shorthand wherever possible"
+    "disallows usage of `pub(in <loc>)` with `in`"
 }
 declare_lint_pass!(Visibility => [NEEDLESS_PUB_SELF, PUB_WITH_SHORTHAND, PUB_WITHOUT_SHORTHAND]);
 
diff --git a/tests/ui/needless_pub_self.fixed b/tests/ui/needless_pub_self.fixed
index bf5e70d9a05..672b4c318a8 100644
--- a/tests/ui/needless_pub_self.fixed
+++ b/tests/ui/needless_pub_self.fixed
@@ -1,5 +1,5 @@
 //@run-rustfix
-//@aux-build:proc_macros.rs
+//@aux-build:proc_macros.rs:proc-macro
 #![feature(custom_inner_attributes)]
 #![allow(unused)]
 #![warn(clippy::needless_pub_self)]
diff --git a/tests/ui/needless_pub_self.rs b/tests/ui/needless_pub_self.rs
index a49a6658f8b..5ac1edf8e99 100644
--- a/tests/ui/needless_pub_self.rs
+++ b/tests/ui/needless_pub_self.rs
@@ -1,5 +1,5 @@
 //@run-rustfix
-//@aux-build:proc_macros.rs
+//@aux-build:proc_macros.rs:proc-macro
 #![feature(custom_inner_attributes)]
 #![allow(unused)]
 #![warn(clippy::needless_pub_self)]
diff --git a/tests/ui/pub_with_shorthand.fixed b/tests/ui/pub_with_shorthand.fixed
index c9487ed7fc3..a774faa0a67 100644
--- a/tests/ui/pub_with_shorthand.fixed
+++ b/tests/ui/pub_with_shorthand.fixed
@@ -1,5 +1,5 @@
 //@run-rustfix
-//@aux-build:proc_macros.rs
+//@aux-build:proc_macros.rs:proc-macro
 #![feature(custom_inner_attributes)]
 #![allow(clippy::needless_pub_self, unused)]
 #![warn(clippy::pub_with_shorthand)]
diff --git a/tests/ui/pub_with_shorthand.rs b/tests/ui/pub_with_shorthand.rs
index e47c926520b..4a4bbc18728 100644
--- a/tests/ui/pub_with_shorthand.rs
+++ b/tests/ui/pub_with_shorthand.rs
@@ -1,5 +1,5 @@
 //@run-rustfix
-//@aux-build:proc_macros.rs
+//@aux-build:proc_macros.rs:proc-macro
 #![feature(custom_inner_attributes)]
 #![allow(clippy::needless_pub_self, unused)]
 #![warn(clippy::pub_with_shorthand)]
diff --git a/tests/ui/pub_without_shorthand.fixed b/tests/ui/pub_without_shorthand.fixed
index 55159efb5bf..fdb49ac4d90 100644
--- a/tests/ui/pub_without_shorthand.fixed
+++ b/tests/ui/pub_without_shorthand.fixed
@@ -1,5 +1,5 @@
 //@run-rustfix
-//@aux-build:proc_macros.rs
+//@aux-build:proc_macros.rs:proc-macro
 #![feature(custom_inner_attributes)]
 #![allow(clippy::needless_pub_self, unused)]
 #![warn(clippy::pub_without_shorthand)]
diff --git a/tests/ui/pub_without_shorthand.rs b/tests/ui/pub_without_shorthand.rs
index 38f4da85a49..1f2ef7ece39 100644
--- a/tests/ui/pub_without_shorthand.rs
+++ b/tests/ui/pub_without_shorthand.rs
@@ -1,5 +1,5 @@
 //@run-rustfix
-//@aux-build:proc_macros.rs
+//@aux-build:proc_macros.rs:proc-macro
 #![feature(custom_inner_attributes)]
 #![allow(clippy::needless_pub_self, unused)]
 #![warn(clippy::pub_without_shorthand)]
-- 
cgit 1.4.1-3-g733a5


From b713cd5945501c07990e9845eed7a5e612d1c135 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Wed, 28 Jun 2023 11:35:10 +0200
Subject: move `is_in_trait_method` to utils and rename

---
 clippy_lints/src/unused_async.rs | 19 +++----------------
 clippy_utils/src/lib.rs          | 12 ++++++++++++
 2 files changed, 15 insertions(+), 16 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unused_async.rs b/clippy_lints/src/unused_async.rs
index 21153973dff..5e42cf7e4f3 100644
--- a/clippy_lints/src/unused_async.rs
+++ b/clippy_lints/src/unused_async.rs
@@ -1,6 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::is_def_id_trait_method;
 use rustc_hir::intravisit::{walk_body, walk_expr, walk_fn, FnKind, Visitor};
-use rustc_hir::{Body, Expr, ExprKind, FnDecl, ItemKind, Node, YieldSource};
+use rustc_hir::{Body, Expr, ExprKind, FnDecl, YieldSource};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::nested_filter;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -81,20 +82,6 @@ impl<'a, 'tcx> Visitor<'tcx> for AsyncFnVisitor<'a, 'tcx> {
     }
 }
 
-/// Checks if the `def_id` belongs to a function and that function is part of a trait impl,
-/// in which case we shouldn't lint because `async` is part of the trait definition and therefore
-/// can't be removed.
-fn is_in_trait_impl(cx: &LateContext<'_>, def_id: LocalDefId) -> bool {
-    if let Some(hir_id) = cx.tcx.opt_local_def_id_to_hir_id(def_id)
-        && let Node::Item(item) = cx.tcx.hir().get_parent(hir_id)
-        && let ItemKind::Impl(imp) = item.kind
-    {
-        imp.of_trait.is_some()
-    } else {
-        false
-    }
-}
-
 impl<'tcx> LateLintPass<'tcx> for UnusedAsync {
     fn check_fn(
         &mut self,
@@ -105,7 +92,7 @@ impl<'tcx> LateLintPass<'tcx> for UnusedAsync {
         span: Span,
         def_id: LocalDefId,
     ) {
-        if !span.from_expansion() && fn_kind.asyncness().is_async() && !is_in_trait_impl(cx, def_id) {
+        if !span.from_expansion() && fn_kind.asyncness().is_async() && !is_def_id_trait_method(cx, def_id) {
             let mut visitor = AsyncFnVisitor {
                 cx,
                 found_await: false,
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 078dcef1927..727b59f1f43 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -327,6 +327,18 @@ pub fn is_trait_method(cx: &LateContext<'_>, expr: &Expr<'_>, diag_item: Symbol)
         .map_or(false, |did| is_diag_trait_item(cx, did, diag_item))
 }
 
+/// Checks if the `def_id` belongs to a function that is part of a trait impl.
+pub fn is_def_id_trait_method(cx: &LateContext<'_>, def_id: LocalDefId) -> bool {
+    if let Some(hir_id) = cx.tcx.opt_local_def_id_to_hir_id(def_id)
+        && let Node::Item(item) = cx.tcx.hir().get_parent(hir_id)
+        && let ItemKind::Impl(imp) = item.kind
+    {
+        imp.of_trait.is_some()
+    } else {
+        false
+    }
+}
+
 /// Checks if the given expression is a path referring an item on the trait
 /// that is marked with the given diagnostic item.
 ///
-- 
cgit 1.4.1-3-g733a5


From 70610c00186cd9fd33f357fe2243822a3008049a Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Wed, 28 Jun 2023 12:41:18 +0200
Subject: lint in nested bodies if `try` is in outer body

---
 clippy_lints/src/question_mark.rs | 22 ++++++++++++++++++----
 tests/ui/question_mark.fixed      | 10 ++++++++++
 tests/ui/question_mark.rs         | 14 ++++++++++++++
 tests/ui/question_mark.stderr     | 12 +++++++++++-
 4 files changed, 53 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/question_mark.rs b/clippy_lints/src/question_mark.rs
index 036ad3e0d15..e3d940ad2a4 100644
--- a/clippy_lints/src/question_mark.rs
+++ b/clippy_lints/src/question_mark.rs
@@ -49,7 +49,7 @@ pub struct QuestionMark {
     /// very quickly, without having to walk up the parent chain, by simply checking
     /// if it is greater than zero.
     /// As for why we need this in the first place: <https://github.com/rust-lang/rust-clippy/issues/8628>
-    try_block_depth: u32,
+    try_block_depth_stack: Vec<u32>,
 }
 impl_lint_pass!(QuestionMark => [QUESTION_MARK]);
 
@@ -150,7 +150,7 @@ fn expr_return_none_or_err(
 
 impl QuestionMark {
     fn inside_try_block(&self) -> bool {
-        self.try_block_depth > 0
+        self.try_block_depth_stack.last() > Some(&0)
     }
 
     /// Checks if the given expression on the given context matches the following structure:
@@ -268,13 +268,27 @@ impl<'tcx> LateLintPass<'tcx> for QuestionMark {
 
     fn check_block(&mut self, cx: &LateContext<'tcx>, block: &'tcx rustc_hir::Block<'tcx>) {
         if is_try_block(cx, block) {
-            self.try_block_depth += 1;
+            *self
+                .try_block_depth_stack
+                .last_mut()
+                .expect("blocks are always part of bodies and must have a depth") += 1;
         }
     }
 
+    fn check_body(&mut self, _: &LateContext<'tcx>, _: &'tcx rustc_hir::Body<'tcx>) {
+        self.try_block_depth_stack.push(0);
+    }
+
+    fn check_body_post(&mut self, _: &LateContext<'tcx>, _: &'tcx rustc_hir::Body<'tcx>) {
+        self.try_block_depth_stack.pop();
+    }
+
     fn check_block_post(&mut self, cx: &LateContext<'tcx>, block: &'tcx rustc_hir::Block<'tcx>) {
         if is_try_block(cx, block) {
-            self.try_block_depth -= 1;
+            *self
+                .try_block_depth_stack
+                .last_mut()
+                .expect("blocks are always part of bodies and must have a depth") -= 1;
         }
     }
 }
diff --git a/tests/ui/question_mark.fixed b/tests/ui/question_mark.fixed
index f257378842b..2d8920ccc42 100644
--- a/tests/ui/question_mark.fixed
+++ b/tests/ui/question_mark.fixed
@@ -239,6 +239,16 @@ fn issue8628(a: Option<u32>) -> Option<u32> {
     b.or(Some(128))
 }
 
+fn issue6828_nested_body() -> Option<u32> {
+    try {
+        fn f2(a: Option<i32>) -> Option<i32> {
+            a?;
+            Some(32)
+        }
+        123
+    }
+}
+
 // should not lint, `?` operator not available in const context
 const fn issue9175(option: Option<()>) -> Option<()> {
     if option.is_none() {
diff --git a/tests/ui/question_mark.rs b/tests/ui/question_mark.rs
index 29d79b078ac..69451c17ee7 100644
--- a/tests/ui/question_mark.rs
+++ b/tests/ui/question_mark.rs
@@ -275,6 +275,20 @@ fn issue8628(a: Option<u32>) -> Option<u32> {
     b.or(Some(128))
 }
 
+fn issue6828_nested_body() -> Option<u32> {
+    try {
+        fn f2(a: Option<i32>) -> Option<i32> {
+            if a.is_none() {
+                return None;
+                // do lint here, the outer `try` is not relevant here
+                // https://github.com/rust-lang/rust-clippy/pull/11001#issuecomment-1610636867
+            }
+            Some(32)
+        }
+        123
+    }
+}
+
 // should not lint, `?` operator not available in const context
 const fn issue9175(option: Option<()>) -> Option<()> {
     if option.is_none() {
diff --git a/tests/ui/question_mark.stderr b/tests/ui/question_mark.stderr
index 86d89942cc0..2cfd7586308 100644
--- a/tests/ui/question_mark.stderr
+++ b/tests/ui/question_mark.stderr
@@ -130,5 +130,15 @@ LL | |         return Err(err);
 LL | |     }
    | |_____^ help: replace it with: `func_returning_result()?;`
 
-error: aborting due to 15 previous errors
+error: this block may be rewritten with the `?` operator
+  --> $DIR/question_mark.rs:281:13
+   |
+LL | /             if a.is_none() {
+LL | |                 return None;
+LL | |                 // do lint here, the outer `try` is not relevant here
+LL | |                 // https://github.com/rust-lang/rust-clippy/pull/11001#issuecomment-1610636867
+LL | |             }
+   | |_____________^ help: replace it with: `a?;`
+
+error: aborting due to 16 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 211278bc862f245c11c586f1b2e6ac746ace7399 Mon Sep 17 00:00:00 2001
From: darklyspaced <srohanjd@gmail.com>
Date: Thu, 29 Jun 2023 10:18:38 +0800
Subject: updated list of lints that use msrv

---
 clippy_lints/src/utils/conf.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 12197666b30..5c17b243d7c 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -294,7 +294,7 @@ define_Conf! {
     ///
     /// Suppress lints whenever the suggested change would cause breakage for other crates.
     (avoid_breaking_exported_api: bool = true),
-    /// Lint: MANUAL_SPLIT_ONCE, MANUAL_STR_REPEAT, CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR, IF_THEN_SOME_ELSE_NONE, APPROX_CONSTANT, DEPRECATED_CFG_ATTR, INDEX_REFUTABLE_SLICE, MAP_CLONE, BORROW_AS_PTR, MANUAL_BITS, ERR_EXPECT, CAST_ABS_TO_UNSIGNED, UNINLINED_FORMAT_ARGS, MANUAL_CLAMP, MANUAL_LET_ELSE, UNCHECKED_DURATION_SUBTRACTION, COLLAPSIBLE_STR_REPLACE, SEEK_FROM_CURRENT, SEEK_REWIND, UNNECESSARY_LAZY_EVALUATIONS, TRANSMUTE_PTR_TO_REF, ALMOST_COMPLETE_RANGE, NEEDLESS_BORROW, DERIVABLE_IMPLS, MANUAL_IS_ASCII_CHECK, MANUAL_REM_EUCLID, MANUAL_RETAIN, TYPE_REPETITION_IN_BOUNDS.
+    /// Lint: MANUAL_SPLIT_ONCE, MANUAL_STR_REPEAT, CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, OPTION_MAP_UNWRAP_OR, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR, IF_THEN_SOME_ELSE_NONE, APPROX_CONSTANT, DEPRECATED_CFG_ATTR, INDEX_REFUTABLE_SLICE, MAP_CLONE, BORROW_AS_PTR, MANUAL_BITS, ERR_EXPECT, CAST_ABS_TO_UNSIGNED, UNINLINED_FORMAT_ARGS, MANUAL_CLAMP, MANUAL_LET_ELSE, UNCHECKED_DURATION_SUBTRACTION, COLLAPSIBLE_STR_REPLACE, SEEK_FROM_CURRENT, SEEK_REWIND, UNNECESSARY_LAZY_EVALUATIONS, TRANSMUTE_PTR_TO_REF, ALMOST_COMPLETE_RANGE, NEEDLESS_BORROW, DERIVABLE_IMPLS, MANUAL_IS_ASCII_CHECK, MANUAL_REM_EUCLID, MANUAL_RETAIN, TYPE_REPETITION_IN_BOUNDS.
     ///
     /// The minimum rust version that the project supports
     (msrv: Option<String> = None),
-- 
cgit 1.4.1-3-g733a5


From bfcc8ba444180dfc12bb113d1d500b81c9e87956 Mon Sep 17 00:00:00 2001
From: Catherine <114838443+Centri3@users.noreply.github.com>
Date: Sat, 24 Jun 2023 07:40:09 -0500
Subject: New lint `tuple_array_conversions`

---
 CHANGELOG.md                                |   1 +
 clippy_lints/src/declared_lints.rs          |   1 +
 clippy_lints/src/lib.rs                     |   2 +
 clippy_lints/src/tuple_array_conversions.rs | 187 ++++++++++++++++++++++++++++
 tests/ui/tuple_array_conversions.rs         |  43 +++++++
 tests/ui/tuple_array_conversions.stderr     |  59 +++++++++
 6 files changed, 293 insertions(+)
 create mode 100644 clippy_lints/src/tuple_array_conversions.rs
 create mode 100644 tests/ui/tuple_array_conversions.rs
 create mode 100644 tests/ui/tuple_array_conversions.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 4debe304857..04917871c40 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5262,6 +5262,7 @@ Released 2018-09-13
 [`trivial_regex`]: https://rust-lang.github.io/rust-clippy/master/index.html#trivial_regex
 [`trivially_copy_pass_by_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#trivially_copy_pass_by_ref
 [`try_err`]: https://rust-lang.github.io/rust-clippy/master/index.html#try_err
+[`tuple_array_conversions`]: https://rust-lang.github.io/rust-clippy/master/index.html#tuple_array_conversions
 [`type_complexity`]: https://rust-lang.github.io/rust-clippy/master/index.html#type_complexity
 [`type_repetition_in_bounds`]: https://rust-lang.github.io/rust-clippy/master/index.html#type_repetition_in_bounds
 [`unchecked_duration_subtraction`]: https://rust-lang.github.io/rust-clippy/master/index.html#unchecked_duration_subtraction
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 46f4082f0c7..316645e4066 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -624,6 +624,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::transmute::UNSOUND_COLLECTION_TRANSMUTE_INFO,
     crate::transmute::USELESS_TRANSMUTE_INFO,
     crate::transmute::WRONG_TRANSMUTE_INFO,
+    crate::tuple_array_conversions::TUPLE_ARRAY_CONVERSIONS_INFO,
     crate::types::BORROWED_BOX_INFO,
     crate::types::BOX_COLLECTION_INFO,
     crate::types::LINKEDLIST_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 5ab28b5c70c..39301b5344a 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -311,6 +311,7 @@ mod to_digit_is_some;
 mod trailing_empty_array;
 mod trait_bounds;
 mod transmute;
+mod tuple_array_conversions;
 mod types;
 mod undocumented_unsafe_blocks;
 mod unicode;
@@ -1072,6 +1073,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     });
     store.register_late_pass(|_| Box::new(manual_range_patterns::ManualRangePatterns));
     store.register_early_pass(|| Box::new(visibility::Visibility));
+    store.register_late_pass(|_| Box::new(tuple_array_conversions::TupleArrayConversions));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/tuple_array_conversions.rs b/clippy_lints/src/tuple_array_conversions.rs
new file mode 100644
index 00000000000..9640083f764
--- /dev/null
+++ b/clippy_lints/src/tuple_array_conversions.rs
@@ -0,0 +1,187 @@
+use clippy_utils::{diagnostics::span_lint_and_help, is_from_proc_macro, path_to_local};
+use rustc_hir::*;
+use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_middle::{lint::in_external_macro, ty};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// ### What it does
+    ///
+    /// ### Why is this bad?
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// let t1 = &[(1, 2), (3, 4)];
+    /// let v1: Vec<[u32; 2]> = t1.iter().map(|&(a, b)| [a, b]).collect();
+    /// ```
+    /// Use instead:
+    /// ```rust,ignore
+    /// let t1 = &[(1, 2), (3, 4)];
+    /// let v1: Vec<[u32; 2]> = t1.iter().map(|&t| t.into()).collect();
+    /// ```
+    #[clippy::version = "1.72.0"]
+    pub TUPLE_ARRAY_CONVERSIONS,
+    complexity,
+    "default lint description"
+}
+declare_lint_pass!(TupleArrayConversions => [TUPLE_ARRAY_CONVERSIONS]);
+
+impl LateLintPass<'_> for TupleArrayConversions {
+    fn check_expr<'tcx>(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
+        if !in_external_macro(cx.sess(), expr.span) {
+            _ = check_array(cx, expr) || check_tuple(cx, expr);
+        }
+    }
+}
+
+fn check_array<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
+    let ExprKind::Array(elements) = expr.kind else {
+        return false;
+    };
+    if !(1..=12).contains(&elements.len()) {
+        return false;
+    }
+
+    if let Some(locals) = path_to_locals(cx, elements)
+        && locals.iter().all(|local| {
+            matches!(
+                local,
+                Node::Pat(pat) if matches!(
+                    cx.typeck_results().pat_ty(backtrack_pat(cx, pat)).peel_refs().kind(),
+                    ty::Tuple(_),
+                ),
+            )
+        })
+    {
+        return emit_lint(cx, expr, ToType::Array);
+    }
+
+    if let Some(elements) = elements
+            .iter()
+            .map(|expr| {
+                if let ExprKind::Field(path, _) = expr.kind {
+                    return Some(path);
+                };
+
+                None
+            })
+            .collect::<Option<Vec<&Expr<'_>>>>()
+        && let Some(locals) = path_to_locals(cx, elements)
+        && locals.iter().all(|local| {
+            matches!(
+                local,
+                Node::Pat(pat) if matches!(
+                    cx.typeck_results().pat_ty(backtrack_pat(cx, pat)).peel_refs().kind(),
+                    ty::Tuple(_),
+                ),
+            )
+        })
+    {
+        return emit_lint(cx, expr, ToType::Array);
+    }
+
+    false
+}
+
+fn check_tuple<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
+    let ExprKind::Tup(elements) = expr.kind else {
+        return false;
+    };
+    if !(1..=12).contains(&elements.len()) {
+        return false;
+    };
+    if let Some(locals) = path_to_locals(cx, elements)
+        && locals.iter().all(|local| {
+            matches!(
+                local,
+                Node::Pat(pat) if matches!(
+                    cx.typeck_results().pat_ty(backtrack_pat(cx, pat)).peel_refs().kind(),
+                    ty::Array(_, _),
+                ),
+            )
+        })
+    {
+        return emit_lint(cx, expr, ToType::Tuple);
+    }
+
+    if let Some(elements) = elements
+            .iter()
+            .map(|expr| {
+                if let ExprKind::Index(path, _) = expr.kind {
+                    return Some(path);
+                };
+
+                None
+            })
+            .collect::<Option<Vec<&Expr<'_>>>>()
+        && let Some(locals) = path_to_locals(cx, elements.clone())
+        && locals.iter().all(|local| {
+            matches!(
+                local,
+                Node::Pat(pat) if cx.typeck_results()
+                    .pat_ty(backtrack_pat(cx, pat))
+                    .peel_refs()
+                    .is_array()
+            )
+        })
+    {
+        return emit_lint(cx, expr, ToType::Tuple);
+    }
+
+    false
+}
+
+/// Walks up the `Pat` until it's reached the final containing `Pat`.
+fn backtrack_pat<'tcx>(cx: &LateContext<'tcx>, start: &'tcx Pat<'tcx>) -> &'tcx Pat<'tcx> {
+    let mut end = start;
+    for (_, node) in cx.tcx.hir().parent_iter(start.hir_id) {
+        if let Node::Pat(pat) = node {
+            end = pat;
+        } else {
+            break;
+        }
+    }
+    end
+}
+
+fn path_to_locals<'tcx>(
+    cx: &LateContext<'tcx>,
+    exprs: impl IntoIterator<Item = &'tcx Expr<'tcx>>,
+) -> Option<Vec<Node<'tcx>>> {
+    exprs
+        .into_iter()
+        .map(|element| path_to_local(element).and_then(|local| cx.tcx.hir().find(local)))
+        .collect()
+}
+
+#[derive(Clone, Copy)]
+enum ToType {
+    Array,
+    Tuple,
+}
+
+impl ToType {
+    fn help(self) -> &'static str {
+        match self {
+            ToType::Array => "it looks like you're trying to convert a tuple to an array",
+            ToType::Tuple => "it looks like you're trying to convert an array to a tuple",
+        }
+    }
+}
+
+fn emit_lint<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, to_type: ToType) -> bool {
+    if !is_from_proc_macro(cx, expr) {
+        span_lint_and_help(
+            cx,
+            TUPLE_ARRAY_CONVERSIONS,
+            expr.span,
+            to_type.help(),
+            None,
+            "use `.into()` instead",
+        );
+
+        return true;
+    }
+
+    false
+}
diff --git a/tests/ui/tuple_array_conversions.rs b/tests/ui/tuple_array_conversions.rs
new file mode 100644
index 00000000000..061c05e98d0
--- /dev/null
+++ b/tests/ui/tuple_array_conversions.rs
@@ -0,0 +1,43 @@
+//@aux-build:proc_macros.rs:proc-macro
+#![allow(clippy::useless_vec, unused)]
+#![warn(clippy::tuple_array_conversions)]
+
+#[macro_use]
+extern crate proc_macros;
+
+fn main() {
+    let x = [1, 2];
+    let x = (x[0], x[1]);
+    let x = [x.0, x.1];
+    let x = &[1, 2];
+    let x = (x[0], x[1]);
+
+    let t1: &[(u32, u32)] = &[(1, 2), (3, 4)];
+    let v1: Vec<[u32; 2]> = t1.iter().map(|&(a, b)| [a, b]).collect();
+    t1.iter().for_each(|&(a, b)| _ = [a, b]);
+    let t2: Vec<(u32, u32)> = v1.iter().map(|&[a, b]| (a, b)).collect();
+    t1.iter().for_each(|&(a, b)| _ = [a, b]);
+    // Do not lint
+    let v2: Vec<[u32; 2]> = t1.iter().map(|&t| t.into()).collect();
+    let t3: Vec<(u32, u32)> = v2.iter().map(|&v| v.into()).collect();
+    let x = [1; 13];
+    let x = (x[0], x[1], x[2], x[3], x[4], x[5], x[6], x[7], x[8], x[9], x[10], x[11], x[12]);
+    let x = [x.0, x.1, x.2, x.3, x.4, x.5, x.6, x.7, x.8, x.9, x.10, x.11, x.12];
+    let x = (1, 2);
+    let x = (x.0, x.1);
+    let x = [1, 2];
+    let x = [x[0], x[1]];
+    let x = vec![1, 2];
+    let x = (x[0], x[1]);
+    external! {
+        let t1: &[(u32, u32)] = &[(1, 2), (3, 4)];
+        let v1: Vec<[u32; 2]> = t1.iter().map(|&(a, b)| [a, b]).collect();
+        let t2: Vec<(u32, u32)> = v1.iter().map(|&[a, b]| (a, b)).collect();
+    }
+    with_span! {
+        span
+        let t1: &[(u32, u32)] = &[(1, 2), (3, 4)];
+        let v1: Vec<[u32; 2]> = t1.iter().map(|&(a, b)| [a, b]).collect();
+        let t2: Vec<(u32, u32)> = v1.iter().map(|&[a, b]| (a, b)).collect();
+    }
+}
diff --git a/tests/ui/tuple_array_conversions.stderr b/tests/ui/tuple_array_conversions.stderr
new file mode 100644
index 00000000000..aba461e51f7
--- /dev/null
+++ b/tests/ui/tuple_array_conversions.stderr
@@ -0,0 +1,59 @@
+error: it looks like you're trying to convert an array to a tuple
+  --> $DIR/tuple_array_conversions.rs:10:13
+   |
+LL |     let x = (x[0], x[1]);
+   |             ^^^^^^^^^^^^
+   |
+   = help: use `.into()` instead
+   = note: `-D clippy::tuple-array-conversions` implied by `-D warnings`
+
+error: it looks like you're trying to convert a tuple to an array
+  --> $DIR/tuple_array_conversions.rs:11:13
+   |
+LL |     let x = [x.0, x.1];
+   |             ^^^^^^^^^^
+   |
+   = help: use `.into()` instead
+
+error: it looks like you're trying to convert an array to a tuple
+  --> $DIR/tuple_array_conversions.rs:13:13
+   |
+LL |     let x = (x[0], x[1]);
+   |             ^^^^^^^^^^^^
+   |
+   = help: use `.into()` instead
+
+error: it looks like you're trying to convert a tuple to an array
+  --> $DIR/tuple_array_conversions.rs:16:53
+   |
+LL |     let v1: Vec<[u32; 2]> = t1.iter().map(|&(a, b)| [a, b]).collect();
+   |                                                     ^^^^^^
+   |
+   = help: use `.into()` instead
+
+error: it looks like you're trying to convert a tuple to an array
+  --> $DIR/tuple_array_conversions.rs:17:38
+   |
+LL |     t1.iter().for_each(|&(a, b)| _ = [a, b]);
+   |                                      ^^^^^^
+   |
+   = help: use `.into()` instead
+
+error: it looks like you're trying to convert an array to a tuple
+  --> $DIR/tuple_array_conversions.rs:18:55
+   |
+LL |     let t2: Vec<(u32, u32)> = v1.iter().map(|&[a, b]| (a, b)).collect();
+   |                                                       ^^^^^^
+   |
+   = help: use `.into()` instead
+
+error: it looks like you're trying to convert a tuple to an array
+  --> $DIR/tuple_array_conversions.rs:19:38
+   |
+LL |     t1.iter().for_each(|&(a, b)| _ = [a, b]);
+   |                                      ^^^^^^
+   |
+   = help: use `.into()` instead
+
+error: aborting due to 7 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From b1acbde618084db21339030db44120d84efc93ed Mon Sep 17 00:00:00 2001
From: Catherine <114838443+Centri3@users.noreply.github.com>
Date: Sat, 24 Jun 2023 08:24:13 -0500
Subject: Add msrv check and make test pass

---
 clippy_lints/src/lib.rs                     |   2 +-
 clippy_lints/src/tuple_array_conversions.rs | 153 ++++++++++++++++++----------
 clippy_lints/src/upper_case_acronyms.rs     |   2 +-
 clippy_lints/src/utils/conf.rs              |   2 +-
 clippy_utils/src/msrvs.rs                   |   1 +
 tests/ui/tuple_array_conversions.rs         |  36 ++++++-
 tests/ui/tuple_array_conversions.stderr     |  56 ++++++++--
 7 files changed, 188 insertions(+), 64 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 39301b5344a..87329ee5e14 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1073,7 +1073,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     });
     store.register_late_pass(|_| Box::new(manual_range_patterns::ManualRangePatterns));
     store.register_early_pass(|| Box::new(visibility::Visibility));
-    store.register_late_pass(|_| Box::new(tuple_array_conversions::TupleArrayConversions));
+    store.register_late_pass(move |_| Box::new(tuple_array_conversions::TupleArrayConversions { msrv: msrv() }));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/tuple_array_conversions.rs b/clippy_lints/src/tuple_array_conversions.rs
index 9640083f764..9d5e872bd78 100644
--- a/clippy_lints/src/tuple_array_conversions.rs
+++ b/clippy_lints/src/tuple_array_conversions.rs
@@ -1,13 +1,23 @@
-use clippy_utils::{diagnostics::span_lint_and_help, is_from_proc_macro, path_to_local};
-use rustc_hir::*;
+use clippy_utils::{
+    diagnostics::span_lint_and_help,
+    is_from_proc_macro,
+    msrvs::{self, Msrv},
+    path_to_local,
+};
+use itertools::Itertools;
+use rustc_hir::{Expr, ExprKind, Node, Pat};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::{lint::in_external_macro, ty};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+use std::iter::once;
 
 declare_clippy_lint! {
     /// ### What it does
+    /// Checks for tuple<=>array conversions that are not done with `.into()`.
     ///
     /// ### Why is this bad?
+    /// It's overly complex. `.into()` works for tuples<=>arrays with less than 13 elements and
+    /// conveys the intent a lot better, while also leaving less room for bugs!
     ///
     /// ### Example
     /// ```rust,ignore
@@ -22,16 +32,23 @@ declare_clippy_lint! {
     #[clippy::version = "1.72.0"]
     pub TUPLE_ARRAY_CONVERSIONS,
     complexity,
-    "default lint description"
+    "checks for tuple<=>array conversions that are not done with `.into()`"
+}
+impl_lint_pass!(TupleArrayConversions => [TUPLE_ARRAY_CONVERSIONS]);
+
+#[derive(Clone)]
+pub struct TupleArrayConversions {
+    pub msrv: Msrv,
 }
-declare_lint_pass!(TupleArrayConversions => [TUPLE_ARRAY_CONVERSIONS]);
 
 impl LateLintPass<'_> for TupleArrayConversions {
     fn check_expr<'tcx>(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
-        if !in_external_macro(cx.sess(), expr.span) {
+        if !in_external_macro(cx.sess(), expr.span) && self.msrv.meets(msrvs::TUPLE_ARRAY_CONVERSIONS) {
             _ = check_array(cx, expr) || check_tuple(cx, expr);
         }
     }
+
+    extract_msrv_attr!(LateContext);
 }
 
 fn check_array<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
@@ -42,15 +59,22 @@ fn check_array<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
         return false;
     }
 
-    if let Some(locals) = path_to_locals(cx, elements)
-        && locals.iter().all(|local| {
-            matches!(
-                local,
-                Node::Pat(pat) if matches!(
-                    cx.typeck_results().pat_ty(backtrack_pat(cx, pat)).peel_refs().kind(),
-                    ty::Tuple(_),
-                ),
-            )
+    if let Some(locals) = path_to_locals(cx, &elements.iter().collect_vec())
+        && let [first, rest @ ..] = &*locals
+        && let Node::Pat(first_pat) = first
+        && let first_id = parent_pat(cx, first_pat).hir_id
+        && rest.iter().chain(once(first)).all(|local| {
+            if let Node::Pat(pat) = local
+                && let parent = parent_pat(cx, pat)
+                && parent.hir_id == first_id
+            {
+                return matches!(
+                    cx.typeck_results().pat_ty(parent).peel_refs().kind(),
+                    ty::Tuple(len) if len.len() == elements.len()
+                );
+            }
+
+            false
         })
     {
         return emit_lint(cx, expr, ToType::Array);
@@ -66,15 +90,22 @@ fn check_array<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
                 None
             })
             .collect::<Option<Vec<&Expr<'_>>>>()
-        && let Some(locals) = path_to_locals(cx, elements)
-        && locals.iter().all(|local| {
-            matches!(
-                local,
-                Node::Pat(pat) if matches!(
-                    cx.typeck_results().pat_ty(backtrack_pat(cx, pat)).peel_refs().kind(),
-                    ty::Tuple(_),
-                ),
-            )
+        && let Some(locals) = path_to_locals(cx, &elements)
+        && let [first, rest @ ..] = &*locals
+        && let Node::Pat(first_pat) = first
+        && let first_id = parent_pat(cx, first_pat).hir_id
+        && rest.iter().chain(once(first)).all(|local| {
+            if let Node::Pat(pat) = local
+                && let parent = parent_pat(cx, pat)
+                && parent.hir_id == first_id
+            {
+                return matches!(
+                    cx.typeck_results().pat_ty(parent).peel_refs().kind(),
+                    ty::Tuple(len) if len.len() == elements.len()
+                );
+            }
+
+            false
         })
     {
         return emit_lint(cx, expr, ToType::Array);
@@ -83,6 +114,7 @@ fn check_array<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
     false
 }
 
+#[expect(clippy::cast_possible_truncation)]
 fn check_tuple<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
     let ExprKind::Tup(elements) = expr.kind else {
         return false;
@@ -90,15 +122,23 @@ fn check_tuple<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
     if !(1..=12).contains(&elements.len()) {
         return false;
     };
-    if let Some(locals) = path_to_locals(cx, elements)
-        && locals.iter().all(|local| {
-            matches!(
-                local,
-                Node::Pat(pat) if matches!(
-                    cx.typeck_results().pat_ty(backtrack_pat(cx, pat)).peel_refs().kind(),
-                    ty::Array(_, _),
-                ),
-            )
+
+    if let Some(locals) = path_to_locals(cx, &elements.iter().collect_vec())
+        && let [first, rest @ ..] = &*locals
+        && let Node::Pat(first_pat) = first
+        && let first_id = parent_pat(cx, first_pat).hir_id
+        && rest.iter().chain(once(first)).all(|local| {
+            if let Node::Pat(pat) = local
+                && let parent = parent_pat(cx, pat)
+                && parent.hir_id == first_id
+            {
+                return matches!(
+                    cx.typeck_results().pat_ty(parent).peel_refs().kind(),
+                    ty::Array(_, len) if len.eval_target_usize(cx.tcx, cx.param_env) as usize == elements.len()
+                );
+            }
+
+            false
         })
     {
         return emit_lint(cx, expr, ToType::Tuple);
@@ -114,15 +154,22 @@ fn check_tuple<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
                 None
             })
             .collect::<Option<Vec<&Expr<'_>>>>()
-        && let Some(locals) = path_to_locals(cx, elements.clone())
-        && locals.iter().all(|local| {
-            matches!(
-                local,
-                Node::Pat(pat) if cx.typeck_results()
-                    .pat_ty(backtrack_pat(cx, pat))
-                    .peel_refs()
-                    .is_array()
-            )
+        && let Some(locals) = path_to_locals(cx, &elements)
+        && let [first, rest @ ..] = &*locals
+        && let Node::Pat(first_pat) = first
+        && let first_id = parent_pat(cx, first_pat).hir_id
+        && rest.iter().chain(once(first)).all(|local| {
+            if let Node::Pat(pat) = local
+                && let parent = parent_pat(cx, pat)
+                && parent.hir_id == first_id
+            {
+                return matches!(
+                    cx.typeck_results().pat_ty(parent).peel_refs().kind(),
+                    ty::Array(_, len) if len.eval_target_usize(cx.tcx, cx.param_env) as usize == elements.len()
+                );
+            }
+
+            false
         })
     {
         return emit_lint(cx, expr, ToType::Tuple);
@@ -132,7 +179,7 @@ fn check_tuple<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
 }
 
 /// Walks up the `Pat` until it's reached the final containing `Pat`.
-fn backtrack_pat<'tcx>(cx: &LateContext<'tcx>, start: &'tcx Pat<'tcx>) -> &'tcx Pat<'tcx> {
+fn parent_pat<'tcx>(cx: &LateContext<'tcx>, start: &'tcx Pat<'tcx>) -> &'tcx Pat<'tcx> {
     let mut end = start;
     for (_, node) in cx.tcx.hir().parent_iter(start.hir_id) {
         if let Node::Pat(pat) = node {
@@ -144,12 +191,9 @@ fn backtrack_pat<'tcx>(cx: &LateContext<'tcx>, start: &'tcx Pat<'tcx>) -> &'tcx
     end
 }
 
-fn path_to_locals<'tcx>(
-    cx: &LateContext<'tcx>,
-    exprs: impl IntoIterator<Item = &'tcx Expr<'tcx>>,
-) -> Option<Vec<Node<'tcx>>> {
+fn path_to_locals<'tcx>(cx: &LateContext<'tcx>, exprs: &[&'tcx Expr<'tcx>]) -> Option<Vec<Node<'tcx>>> {
     exprs
-        .into_iter()
+        .iter()
         .map(|element| path_to_local(element).and_then(|local| cx.tcx.hir().find(local)))
         .collect()
 }
@@ -161,12 +205,19 @@ enum ToType {
 }
 
 impl ToType {
-    fn help(self) -> &'static str {
+    fn msg(self) -> &'static str {
         match self {
             ToType::Array => "it looks like you're trying to convert a tuple to an array",
             ToType::Tuple => "it looks like you're trying to convert an array to a tuple",
         }
     }
+
+    fn help(self) -> &'static str {
+        match self {
+            ToType::Array => "use `.into()` instead, or `<[T; N]>::from` if type annotations are needed",
+            ToType::Tuple => "use `.into()` instead, or `<(T0, T1, ..., Tn)>::from` if type annotations are needed",
+        }
+    }
 }
 
 fn emit_lint<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, to_type: ToType) -> bool {
@@ -175,9 +226,9 @@ fn emit_lint<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, to_type: ToTy
             cx,
             TUPLE_ARRAY_CONVERSIONS,
             expr.span,
-            to_type.help(),
+            to_type.msg(),
             None,
-            "use `.into()` instead",
+            to_type.help(),
         );
 
         return true;
diff --git a/clippy_lints/src/upper_case_acronyms.rs b/clippy_lints/src/upper_case_acronyms.rs
index 1d2d3eb12e1..4df1e3299ed 100644
--- a/clippy_lints/src/upper_case_acronyms.rs
+++ b/clippy_lints/src/upper_case_acronyms.rs
@@ -65,7 +65,7 @@ fn correct_ident(ident: &str) -> String {
 
     let mut ident = fragments.clone().next().unwrap();
     for (ref prev, ref curr) in fragments.tuple_windows() {
-        if [prev, curr]
+        if <[&String; 2]>::from((prev, curr))
             .iter()
             .all(|s| s.len() == 1 && s.chars().next().unwrap().is_ascii_uppercase())
         {
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 972e24aac51..89063964622 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -294,7 +294,7 @@ define_Conf! {
     ///
     /// Suppress lints whenever the suggested change would cause breakage for other crates.
     (avoid_breaking_exported_api: bool = true),
-    /// Lint: MANUAL_SPLIT_ONCE, MANUAL_STR_REPEAT, CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, OPTION_MAP_UNWRAP_OR, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR, IF_THEN_SOME_ELSE_NONE, APPROX_CONSTANT, DEPRECATED_CFG_ATTR, INDEX_REFUTABLE_SLICE, MAP_CLONE, BORROW_AS_PTR, MANUAL_BITS, ERR_EXPECT, CAST_ABS_TO_UNSIGNED, UNINLINED_FORMAT_ARGS, MANUAL_CLAMP, MANUAL_LET_ELSE, UNCHECKED_DURATION_SUBTRACTION, COLLAPSIBLE_STR_REPLACE, SEEK_FROM_CURRENT, SEEK_REWIND, UNNECESSARY_LAZY_EVALUATIONS, TRANSMUTE_PTR_TO_REF, ALMOST_COMPLETE_RANGE, NEEDLESS_BORROW, DERIVABLE_IMPLS, MANUAL_IS_ASCII_CHECK, MANUAL_REM_EUCLID, MANUAL_RETAIN, TYPE_REPETITION_IN_BOUNDS.
+    /// Lint: MANUAL_SPLIT_ONCE, MANUAL_STR_REPEAT, CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, OPTION_MAP_UNWRAP_OR, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR, IF_THEN_SOME_ELSE_NONE, APPROX_CONSTANT, DEPRECATED_CFG_ATTR, INDEX_REFUTABLE_SLICE, MAP_CLONE, BORROW_AS_PTR, MANUAL_BITS, ERR_EXPECT, CAST_ABS_TO_UNSIGNED, UNINLINED_FORMAT_ARGS, MANUAL_CLAMP, MANUAL_LET_ELSE, UNCHECKED_DURATION_SUBTRACTION, COLLAPSIBLE_STR_REPLACE, SEEK_FROM_CURRENT, SEEK_REWIND, UNNECESSARY_LAZY_EVALUATIONS, TRANSMUTE_PTR_TO_REF, ALMOST_COMPLETE_RANGE, NEEDLESS_BORROW, DERIVABLE_IMPLS, MANUAL_IS_ASCII_CHECK, MANUAL_REM_EUCLID, MANUAL_RETAIN, TYPE_REPETITION_IN_BOUNDS, TUPLE_ARRAY_CONVERSIONS.
     ///
     /// The minimum rust version that the project supports
     (msrv: Option<String> = None),
diff --git a/clippy_utils/src/msrvs.rs b/clippy_utils/src/msrvs.rs
index 5aacca45146..1f70f11bd67 100644
--- a/clippy_utils/src/msrvs.rs
+++ b/clippy_utils/src/msrvs.rs
@@ -19,6 +19,7 @@ macro_rules! msrv_aliases {
 
 // names may refer to stabilized feature flags or library items
 msrv_aliases! {
+    1,71,0 { TUPLE_ARRAY_CONVERSIONS }
     1,70,0 { OPTION_IS_SOME_AND }
     1,68,0 { PATH_MAIN_SEPARATOR_STR }
     1,65,0 { LET_ELSE, POINTER_CAST_CONSTNESS }
diff --git a/tests/ui/tuple_array_conversions.rs b/tests/ui/tuple_array_conversions.rs
index 061c05e98d0..64aaa53be5c 100644
--- a/tests/ui/tuple_array_conversions.rs
+++ b/tests/ui/tuple_array_conversions.rs
@@ -1,5 +1,5 @@
 //@aux-build:proc_macros.rs:proc-macro
-#![allow(clippy::useless_vec, unused)]
+#![allow(clippy::no_effect, clippy::useless_vec, unused)]
 #![warn(clippy::tuple_array_conversions)]
 
 #[macro_use]
@@ -21,7 +21,9 @@ fn main() {
     let v2: Vec<[u32; 2]> = t1.iter().map(|&t| t.into()).collect();
     let t3: Vec<(u32, u32)> = v2.iter().map(|&v| v.into()).collect();
     let x = [1; 13];
-    let x = (x[0], x[1], x[2], x[3], x[4], x[5], x[6], x[7], x[8], x[9], x[10], x[11], x[12]);
+    let x = (
+        x[0], x[1], x[2], x[3], x[4], x[5], x[6], x[7], x[8], x[9], x[10], x[11], x[12],
+    );
     let x = [x.0, x.1, x.2, x.3, x.4, x.5, x.6, x.7, x.8, x.9, x.10, x.11, x.12];
     let x = (1, 2);
     let x = (x.0, x.1);
@@ -29,6 +31,18 @@ fn main() {
     let x = [x[0], x[1]];
     let x = vec![1, 2];
     let x = (x[0], x[1]);
+    let x = [1; 3];
+    let x = (x[0],);
+    let x = (1, 2, 3);
+    let x = [x.0];
+    let x = (1, 2);
+    let y = (1, 2);
+    [x.0, y.0];
+    [x.0, y.1];
+    // FP
+    let x = [x.0, x.0];
+    let x = (x[0], x[0]);
+    // How can this be fixed?
     external! {
         let t1: &[(u32, u32)] = &[(1, 2), (3, 4)];
         let v1: Vec<[u32; 2]> = t1.iter().map(|&(a, b)| [a, b]).collect();
@@ -41,3 +55,21 @@ fn main() {
         let t2: Vec<(u32, u32)> = v1.iter().map(|&[a, b]| (a, b)).collect();
     }
 }
+
+#[clippy::msrv = "1.70.0"]
+fn msrv_too_low() {
+    let x = [1, 2];
+    let x = (x[0], x[1]);
+    let x = [x.0, x.1];
+    let x = &[1, 2];
+    let x = (x[0], x[1]);
+}
+
+#[clippy::msrv = "1.71.0"]
+fn msrv_juust_right() {
+    let x = [1, 2];
+    let x = (x[0], x[1]);
+    let x = [x.0, x.1];
+    let x = &[1, 2];
+    let x = (x[0], x[1]);
+}
diff --git a/tests/ui/tuple_array_conversions.stderr b/tests/ui/tuple_array_conversions.stderr
index aba461e51f7..d9d59a611a0 100644
--- a/tests/ui/tuple_array_conversions.stderr
+++ b/tests/ui/tuple_array_conversions.stderr
@@ -4,7 +4,7 @@ error: it looks like you're trying to convert an array to a tuple
 LL |     let x = (x[0], x[1]);
    |             ^^^^^^^^^^^^
    |
-   = help: use `.into()` instead
+   = help: use `.into()` instead, or `<(T0, T1, ..., Tn)>::from` if type annotations are needed
    = note: `-D clippy::tuple-array-conversions` implied by `-D warnings`
 
 error: it looks like you're trying to convert a tuple to an array
@@ -13,7 +13,7 @@ error: it looks like you're trying to convert a tuple to an array
 LL |     let x = [x.0, x.1];
    |             ^^^^^^^^^^
    |
-   = help: use `.into()` instead
+   = help: use `.into()` instead, or `<[T; N]>::from` if type annotations are needed
 
 error: it looks like you're trying to convert an array to a tuple
   --> $DIR/tuple_array_conversions.rs:13:13
@@ -21,7 +21,7 @@ error: it looks like you're trying to convert an array to a tuple
 LL |     let x = (x[0], x[1]);
    |             ^^^^^^^^^^^^
    |
-   = help: use `.into()` instead
+   = help: use `.into()` instead, or `<(T0, T1, ..., Tn)>::from` if type annotations are needed
 
 error: it looks like you're trying to convert a tuple to an array
   --> $DIR/tuple_array_conversions.rs:16:53
@@ -29,7 +29,7 @@ error: it looks like you're trying to convert a tuple to an array
 LL |     let v1: Vec<[u32; 2]> = t1.iter().map(|&(a, b)| [a, b]).collect();
    |                                                     ^^^^^^
    |
-   = help: use `.into()` instead
+   = help: use `.into()` instead, or `<[T; N]>::from` if type annotations are needed
 
 error: it looks like you're trying to convert a tuple to an array
   --> $DIR/tuple_array_conversions.rs:17:38
@@ -37,7 +37,7 @@ error: it looks like you're trying to convert a tuple to an array
 LL |     t1.iter().for_each(|&(a, b)| _ = [a, b]);
    |                                      ^^^^^^
    |
-   = help: use `.into()` instead
+   = help: use `.into()` instead, or `<[T; N]>::from` if type annotations are needed
 
 error: it looks like you're trying to convert an array to a tuple
   --> $DIR/tuple_array_conversions.rs:18:55
@@ -45,7 +45,7 @@ error: it looks like you're trying to convert an array to a tuple
 LL |     let t2: Vec<(u32, u32)> = v1.iter().map(|&[a, b]| (a, b)).collect();
    |                                                       ^^^^^^
    |
-   = help: use `.into()` instead
+   = help: use `.into()` instead, or `<(T0, T1, ..., Tn)>::from` if type annotations are needed
 
 error: it looks like you're trying to convert a tuple to an array
   --> $DIR/tuple_array_conversions.rs:19:38
@@ -53,7 +53,47 @@ error: it looks like you're trying to convert a tuple to an array
 LL |     t1.iter().for_each(|&(a, b)| _ = [a, b]);
    |                                      ^^^^^^
    |
-   = help: use `.into()` instead
+   = help: use `.into()` instead, or `<[T; N]>::from` if type annotations are needed
 
-error: aborting due to 7 previous errors
+error: it looks like you're trying to convert a tuple to an array
+  --> $DIR/tuple_array_conversions.rs:43:13
+   |
+LL |     let x = [x.0, x.0];
+   |             ^^^^^^^^^^
+   |
+   = help: use `.into()` instead, or `<[T; N]>::from` if type annotations are needed
+
+error: it looks like you're trying to convert an array to a tuple
+  --> $DIR/tuple_array_conversions.rs:44:13
+   |
+LL |     let x = (x[0], x[0]);
+   |             ^^^^^^^^^^^^
+   |
+   = help: use `.into()` instead, or `<(T0, T1, ..., Tn)>::from` if type annotations are needed
+
+error: it looks like you're trying to convert an array to a tuple
+  --> $DIR/tuple_array_conversions.rs:71:13
+   |
+LL |     let x = (x[0], x[1]);
+   |             ^^^^^^^^^^^^
+   |
+   = help: use `.into()` instead, or `<(T0, T1, ..., Tn)>::from` if type annotations are needed
+
+error: it looks like you're trying to convert a tuple to an array
+  --> $DIR/tuple_array_conversions.rs:72:13
+   |
+LL |     let x = [x.0, x.1];
+   |             ^^^^^^^^^^
+   |
+   = help: use `.into()` instead, or `<[T; N]>::from` if type annotations are needed
+
+error: it looks like you're trying to convert an array to a tuple
+  --> $DIR/tuple_array_conversions.rs:74:13
+   |
+LL |     let x = (x[0], x[1]);
+   |             ^^^^^^^^^^^^
+   |
+   = help: use `.into()` instead, or `<(T0, T1, ..., Tn)>::from` if type annotations are needed
+
+error: aborting due to 12 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 95b24d44a68e3f84c10e392cb19e2db921cbedf8 Mon Sep 17 00:00:00 2001
From: Catherine <114838443+Centri3@users.noreply.github.com>
Date: Sat, 24 Jun 2023 09:40:58 -0500
Subject: Fix FP

---
 clippy_lints/src/tuple_array_conversions.rs | 15 +++++++++++----
 tests/ui/tuple_array_conversions.rs         |  2 --
 tests/ui/tuple_array_conversions.stderr     | 18 +-----------------
 3 files changed, 12 insertions(+), 23 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/tuple_array_conversions.rs b/clippy_lints/src/tuple_array_conversions.rs
index 9d5e872bd78..6564666d186 100644
--- a/clippy_lints/src/tuple_array_conversions.rs
+++ b/clippy_lints/src/tuple_array_conversions.rs
@@ -5,6 +5,7 @@ use clippy_utils::{
     path_to_local,
 };
 use itertools::Itertools;
+use rustc_ast::LitKind;
 use rustc_hir::{Expr, ExprKind, Node, Pat};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::{lint::in_external_macro, ty};
@@ -82,8 +83,9 @@ fn check_array<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
 
     if let Some(elements) = elements
             .iter()
-            .map(|expr| {
-                if let ExprKind::Field(path, _) = expr.kind {
+            .enumerate()
+            .map(|(i, expr)| {
+                if let ExprKind::Field(path, field) = expr.kind && field.as_str() == i.to_string() {
                     return Some(path);
                 };
 
@@ -146,8 +148,13 @@ fn check_tuple<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
 
     if let Some(elements) = elements
             .iter()
-            .map(|expr| {
-                if let ExprKind::Index(path, _) = expr.kind {
+            .enumerate()
+            .map(|(i, expr)| {
+                if let ExprKind::Index(path, index) = expr.kind
+                    && let ExprKind::Lit(lit) = index.kind
+                    && let LitKind::Int(val, _) = lit.node
+                    && val as usize == i
+                {
                     return Some(path);
                 };
 
diff --git a/tests/ui/tuple_array_conversions.rs b/tests/ui/tuple_array_conversions.rs
index 64aaa53be5c..f96a7c97f1a 100644
--- a/tests/ui/tuple_array_conversions.rs
+++ b/tests/ui/tuple_array_conversions.rs
@@ -39,10 +39,8 @@ fn main() {
     let y = (1, 2);
     [x.0, y.0];
     [x.0, y.1];
-    // FP
     let x = [x.0, x.0];
     let x = (x[0], x[0]);
-    // How can this be fixed?
     external! {
         let t1: &[(u32, u32)] = &[(1, 2), (3, 4)];
         let v1: Vec<[u32; 2]> = t1.iter().map(|&(a, b)| [a, b]).collect();
diff --git a/tests/ui/tuple_array_conversions.stderr b/tests/ui/tuple_array_conversions.stderr
index d9d59a611a0..7352b089d6b 100644
--- a/tests/ui/tuple_array_conversions.stderr
+++ b/tests/ui/tuple_array_conversions.stderr
@@ -55,22 +55,6 @@ LL |     t1.iter().for_each(|&(a, b)| _ = [a, b]);
    |
    = help: use `.into()` instead, or `<[T; N]>::from` if type annotations are needed
 
-error: it looks like you're trying to convert a tuple to an array
-  --> $DIR/tuple_array_conversions.rs:43:13
-   |
-LL |     let x = [x.0, x.0];
-   |             ^^^^^^^^^^
-   |
-   = help: use `.into()` instead, or `<[T; N]>::from` if type annotations are needed
-
-error: it looks like you're trying to convert an array to a tuple
-  --> $DIR/tuple_array_conversions.rs:44:13
-   |
-LL |     let x = (x[0], x[0]);
-   |             ^^^^^^^^^^^^
-   |
-   = help: use `.into()` instead, or `<(T0, T1, ..., Tn)>::from` if type annotations are needed
-
 error: it looks like you're trying to convert an array to a tuple
   --> $DIR/tuple_array_conversions.rs:71:13
    |
@@ -95,5 +79,5 @@ LL |     let x = (x[0], x[1]);
    |
    = help: use `.into()` instead, or `<(T0, T1, ..., Tn)>::from` if type annotations are needed
 
-error: aborting due to 12 previous errors
+error: aborting due to 10 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 826edd75ef9bfa1053a39461602611985680f8e7 Mon Sep 17 00:00:00 2001
From: Catherine <114838443+Centri3@users.noreply.github.com>
Date: Sat, 24 Jun 2023 10:08:26 -0500
Subject: heavily refactor

---
 book/src/lint_configuration.md              |   1 +
 clippy_lints/src/tuple_array_conversions.rs | 180 +++++++++++++---------------
 tests/ui/tuple_array_conversions.stderr     |   6 +-
 3 files changed, 89 insertions(+), 98 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/book/src/lint_configuration.md b/book/src/lint_configuration.md
index 8bb3a57ba9a..ae0b5140316 100644
--- a/book/src/lint_configuration.md
+++ b/book/src/lint_configuration.md
@@ -149,6 +149,7 @@ The minimum rust version that the project supports
 * [`manual_rem_euclid`](https://rust-lang.github.io/rust-clippy/master/index.html#manual_rem_euclid)
 * [`manual_retain`](https://rust-lang.github.io/rust-clippy/master/index.html#manual_retain)
 * [`type_repetition_in_bounds`](https://rust-lang.github.io/rust-clippy/master/index.html#type_repetition_in_bounds)
+* [`tuple_array_conversions`](https://rust-lang.github.io/rust-clippy/master/index.html#tuple_array_conversions)
 
 
 ## `cognitive-complexity-threshold`
diff --git a/clippy_lints/src/tuple_array_conversions.rs b/clippy_lints/src/tuple_array_conversions.rs
index 6564666d186..bd983306508 100644
--- a/clippy_lints/src/tuple_array_conversions.rs
+++ b/clippy_lints/src/tuple_array_conversions.rs
@@ -4,9 +4,8 @@ use clippy_utils::{
     msrvs::{self, Msrv},
     path_to_local,
 };
-use itertools::Itertools;
 use rustc_ast::LitKind;
-use rustc_hir::{Expr, ExprKind, Node, Pat};
+use rustc_hir::{Expr, ExprKind, HirId, Node, Pat};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::{lint::in_external_macro, ty};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
@@ -17,8 +16,8 @@ declare_clippy_lint! {
     /// Checks for tuple<=>array conversions that are not done with `.into()`.
     ///
     /// ### Why is this bad?
-    /// It's overly complex. `.into()` works for tuples<=>arrays with less than 13 elements and
-    /// conveys the intent a lot better, while also leaving less room for bugs!
+    /// It's unnecessary complexity. `.into()` works for tuples<=>arrays at or below 12 elements and
+    /// conveys the intent a lot better, while also leaving less room for hard to spot bugs!
     ///
     /// ### Example
     /// ```rust,ignore
@@ -45,26 +44,28 @@ pub struct TupleArrayConversions {
 impl LateLintPass<'_> for TupleArrayConversions {
     fn check_expr<'tcx>(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
         if !in_external_macro(cx.sess(), expr.span) && self.msrv.meets(msrvs::TUPLE_ARRAY_CONVERSIONS) {
-            _ = check_array(cx, expr) || check_tuple(cx, expr);
+            match expr.kind {
+                ExprKind::Array(elements) if (1..=12).contains(&elements.len()) => check_array(cx, expr, elements),
+                ExprKind::Tup(elements) if (1..=12).contains(&elements.len()) => check_tuple(cx, expr, elements),
+                _ => {},
+            }
         }
     }
 
     extract_msrv_attr!(LateContext);
 }
 
-fn check_array<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
-    let ExprKind::Array(elements) = expr.kind else {
-        return false;
-    };
-    if !(1..=12).contains(&elements.len()) {
-        return false;
-    }
-
-    if let Some(locals) = path_to_locals(cx, &elements.iter().collect_vec())
-        && let [first, rest @ ..] = &*locals
-        && let Node::Pat(first_pat) = first
-        && let first_id = parent_pat(cx, first_pat).hir_id
-        && rest.iter().chain(once(first)).all(|local| {
+#[expect(
+    clippy::blocks_in_if_conditions,
+    reason = "not a FP, but this is much easier to understand"
+)]
+fn check_array<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, elements: &'tcx [Expr<'tcx>]) {
+    if should_lint(
+        cx,
+        elements,
+        // This is cursed.
+        Some,
+        |(first_id, local)| {
             if let Node::Pat(pat) = local
                 && let parent = parent_pat(cx, pat)
                 && parent.hir_id == first_id
@@ -76,27 +77,18 @@ fn check_array<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
             }
 
             false
-        })
-    {
-        return emit_lint(cx, expr, ToType::Array);
-    }
-
-    if let Some(elements) = elements
-            .iter()
-            .enumerate()
-            .map(|(i, expr)| {
-                if let ExprKind::Field(path, field) = expr.kind && field.as_str() == i.to_string() {
-                    return Some(path);
-                };
-
-                None
-            })
-            .collect::<Option<Vec<&Expr<'_>>>>()
-        && let Some(locals) = path_to_locals(cx, &elements)
-        && let [first, rest @ ..] = &*locals
-        && let Node::Pat(first_pat) = first
-        && let first_id = parent_pat(cx, first_pat).hir_id
-        && rest.iter().chain(once(first)).all(|local| {
+        },
+    ) || should_lint(
+        cx,
+        elements,
+        |(i, expr)| {
+            if let ExprKind::Field(path, field) = expr.kind && field.as_str() == i.to_string() {
+                return Some((i, path));
+            };
+
+            None
+        },
+        |(first_id, local)| {
             if let Node::Pat(pat) = local
                 && let parent = parent_pat(cx, pat)
                 && parent.hir_id == first_id
@@ -108,29 +100,20 @@ fn check_array<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
             }
 
             false
-        })
-    {
-        return emit_lint(cx, expr, ToType::Array);
+        },
+    ) {
+        emit_lint(cx, expr, ToType::Array);
     }
-
-    false
 }
 
+#[expect(
+    clippy::blocks_in_if_conditions,
+    reason = "not a FP, but this is much easier to understand"
+)]
 #[expect(clippy::cast_possible_truncation)]
-fn check_tuple<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
-    let ExprKind::Tup(elements) = expr.kind else {
-        return false;
-    };
-    if !(1..=12).contains(&elements.len()) {
-        return false;
-    };
-
-    if let Some(locals) = path_to_locals(cx, &elements.iter().collect_vec())
-        && let [first, rest @ ..] = &*locals
-        && let Node::Pat(first_pat) = first
-        && let first_id = parent_pat(cx, first_pat).hir_id
-        && rest.iter().chain(once(first)).all(|local| {
-            if let Node::Pat(pat) = local
+fn check_tuple<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, elements: &'tcx [Expr<'tcx>]) {
+    if should_lint(cx, elements, Some, |(first_id, local)| {
+        if let Node::Pat(pat) = local
                 && let parent = parent_pat(cx, pat)
                 && parent.hir_id == first_id
             {
@@ -140,32 +123,22 @@ fn check_tuple<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
                 );
             }
 
-            false
-        })
-    {
-        return emit_lint(cx, expr, ToType::Tuple);
-    }
+        false
+    }) || should_lint(
+        cx,
+        elements,
+        |(i, expr)| {
+            if let ExprKind::Index(path, index) = expr.kind
+                && let ExprKind::Lit(lit) = index.kind
+                && let LitKind::Int(val, _) = lit.node
+                && val as usize == i
+            {
+                return Some((i, path));
+            };
 
-    if let Some(elements) = elements
-            .iter()
-            .enumerate()
-            .map(|(i, expr)| {
-                if let ExprKind::Index(path, index) = expr.kind
-                    && let ExprKind::Lit(lit) = index.kind
-                    && let LitKind::Int(val, _) = lit.node
-                    && val as usize == i
-                {
-                    return Some(path);
-                };
-
-                None
-            })
-            .collect::<Option<Vec<&Expr<'_>>>>()
-        && let Some(locals) = path_to_locals(cx, &elements)
-        && let [first, rest @ ..] = &*locals
-        && let Node::Pat(first_pat) = first
-        && let first_id = parent_pat(cx, first_pat).hir_id
-        && rest.iter().chain(once(first)).all(|local| {
+            None
+        },
+        |(first_id, local)| {
             if let Node::Pat(pat) = local
                 && let parent = parent_pat(cx, pat)
                 && parent.hir_id == first_id
@@ -177,12 +150,10 @@ fn check_tuple<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
             }
 
             false
-        })
-    {
-        return emit_lint(cx, expr, ToType::Tuple);
+        },
+    ) {
+        emit_lint(cx, expr, ToType::Tuple);
     }
-
-    false
 }
 
 /// Walks up the `Pat` until it's reached the final containing `Pat`.
@@ -198,13 +169,6 @@ fn parent_pat<'tcx>(cx: &LateContext<'tcx>, start: &'tcx Pat<'tcx>) -> &'tcx Pat
     end
 }
 
-fn path_to_locals<'tcx>(cx: &LateContext<'tcx>, exprs: &[&'tcx Expr<'tcx>]) -> Option<Vec<Node<'tcx>>> {
-    exprs
-        .iter()
-        .map(|element| path_to_local(element).and_then(|local| cx.tcx.hir().find(local)))
-        .collect()
-}
-
 #[derive(Clone, Copy)]
 enum ToType {
     Array,
@@ -243,3 +207,29 @@ fn emit_lint<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, to_type: ToTy
 
     false
 }
+
+fn should_lint<'tcx>(
+    cx: &LateContext<'tcx>,
+    elements: &'tcx [Expr<'tcx>],
+    map: impl FnMut((usize, &'tcx Expr<'tcx>)) -> Option<(usize, &Expr<'_>)>,
+    predicate: impl FnMut((HirId, &Node<'tcx>)) -> bool,
+) -> bool {
+    if let Some(elements) = elements
+            .iter()
+            .enumerate()
+            .map(map)
+            .collect::<Option<Vec<_>>>()
+        && let Some(locals) = elements
+            .iter()
+            .map(|(_, element)| path_to_local(element).and_then(|local| cx.tcx.hir().find(local)))
+            .collect::<Option<Vec<_>>>()
+        && let [first, rest @ ..] = &*locals
+        && let Node::Pat(first_pat) = first
+        && let parent = parent_pat(cx, first_pat).hir_id
+        && rest.iter().chain(once(first)).map(|i| (parent, i)).all(predicate)
+    {
+        return true;
+    }
+
+    false
+}
diff --git a/tests/ui/tuple_array_conversions.stderr b/tests/ui/tuple_array_conversions.stderr
index 7352b089d6b..be653e8efb7 100644
--- a/tests/ui/tuple_array_conversions.stderr
+++ b/tests/ui/tuple_array_conversions.stderr
@@ -56,7 +56,7 @@ LL |     t1.iter().for_each(|&(a, b)| _ = [a, b]);
    = help: use `.into()` instead, or `<[T; N]>::from` if type annotations are needed
 
 error: it looks like you're trying to convert an array to a tuple
-  --> $DIR/tuple_array_conversions.rs:71:13
+  --> $DIR/tuple_array_conversions.rs:69:13
    |
 LL |     let x = (x[0], x[1]);
    |             ^^^^^^^^^^^^
@@ -64,7 +64,7 @@ LL |     let x = (x[0], x[1]);
    = help: use `.into()` instead, or `<(T0, T1, ..., Tn)>::from` if type annotations are needed
 
 error: it looks like you're trying to convert a tuple to an array
-  --> $DIR/tuple_array_conversions.rs:72:13
+  --> $DIR/tuple_array_conversions.rs:70:13
    |
 LL |     let x = [x.0, x.1];
    |             ^^^^^^^^^^
@@ -72,7 +72,7 @@ LL |     let x = [x.0, x.1];
    = help: use `.into()` instead, or `<[T; N]>::from` if type annotations are needed
 
 error: it looks like you're trying to convert an array to a tuple
-  --> $DIR/tuple_array_conversions.rs:74:13
+  --> $DIR/tuple_array_conversions.rs:72:13
    |
 LL |     let x = (x[0], x[1]);
    |             ^^^^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From f0619024b876c7a57c83455aa153b3a82fb467b6 Mon Sep 17 00:00:00 2001
From: Caio <c410.f3r@gmail.com>
Date: Sat, 13 May 2023 21:45:03 -0300
Subject: Fix #10413

---
 clippy_lints/src/significant_drop_tightening.rs | 587 +++++++++++++-----------
 tests/ui/significant_drop_tightening.fixed      |  12 +
 tests/ui/significant_drop_tightening.rs         |  12 +
 tests/ui/significant_drop_tightening.stderr     |   6 +-
 4 files changed, 336 insertions(+), 281 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/significant_drop_tightening.rs b/clippy_lints/src/significant_drop_tightening.rs
index f4e56489b09..140dc66badb 100644
--- a/clippy_lints/src/significant_drop_tightening.rs
+++ b/clippy_lints/src/significant_drop_tightening.rs
@@ -1,10 +1,10 @@
 use clippy_utils::{
     diagnostics::span_lint_and_then,
-    get_attr,
+    expr_or_init, get_attr, path_to_local,
     source::{indent_of, snippet},
 };
-use rustc_data_structures::fx::{FxHashMap, FxHashSet};
-use rustc_errors::{Applicability, Diagnostic};
+use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexMap};
+use rustc_errors::Applicability;
 use rustc_hir::{
     self as hir,
     intravisit::{walk_expr, Visitor},
@@ -13,6 +13,7 @@ use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::ty::{subst::GenericArgKind, Ty, TypeAndMut};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::{symbol::Ident, Span, DUMMY_SP};
+use std::borrow::Cow;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -56,255 +57,102 @@ impl_lint_pass!(SignificantDropTightening<'_> => [SIGNIFICANT_DROP_TIGHTENING]);
 
 #[derive(Default)]
 pub struct SignificantDropTightening<'tcx> {
+    apas: FxIndexMap<hir::HirId, AuxParamsAttr>,
     /// Auxiliary structure used to avoid having to verify the same type multiple times.
     seen_types: FxHashSet<Ty<'tcx>>,
     type_cache: FxHashMap<Ty<'tcx>, bool>,
 }
 
-impl<'tcx> SignificantDropTightening<'tcx> {
-    /// Unifies the statements of a block with its return expression.
-    fn all_block_stmts<'ret, 'rslt, 'stmts>(
-        block_stmts: &'stmts [hir::Stmt<'tcx>],
-        dummy_ret_stmt: Option<&'ret hir::Stmt<'tcx>>,
-    ) -> impl Iterator<Item = &'rslt hir::Stmt<'tcx>>
-    where
-        'ret: 'rslt,
-        'stmts: 'rslt,
-    {
-        block_stmts.iter().chain(dummy_ret_stmt)
-    }
-
-    /// Searches for at least one statement that could slow down the release of a significant drop.
-    fn at_least_one_stmt_is_expensive<'stmt>(stmts: impl Iterator<Item = &'stmt hir::Stmt<'tcx>>) -> bool
-    where
-        'tcx: 'stmt,
-    {
-        for stmt in stmts {
-            match stmt.kind {
-                hir::StmtKind::Expr(expr) if let hir::ExprKind::Path(_) = expr.kind => {}
-                hir::StmtKind::Local(local) if let Some(expr) = local.init
-                    && let hir::ExprKind::Path(_) = expr.kind => {},
-                _ => return true
-            };
-        }
-        false
-    }
-
-    /// Verifies if the expression is of type `drop(some_lock_path)` to assert that the temporary
-    /// is already being dropped before the end of its scope.
-    fn has_drop(expr: &'tcx hir::Expr<'_>, init_bind_ident: Ident) -> bool {
-        if let hir::ExprKind::Call(fun, args) = expr.kind
-            && let hir::ExprKind::Path(hir::QPath::Resolved(_, fun_path)) = &fun.kind
-            && let [fun_ident, ..] = fun_path.segments
-            && fun_ident.ident.name == rustc_span::sym::drop
-            && let [first_arg, ..] = args
-            && let hir::ExprKind::Path(hir::QPath::Resolved(_, arg_path)) = &first_arg.kind
-            && let [first_arg_ps, .. ] = arg_path.segments
-        {
-            first_arg_ps.ident == init_bind_ident
-        }
-        else {
-            false
-        }
-    }
-
-    /// Tries to find types marked with `#[has_significant_drop]` of an expression `expr` that is
-    /// originated from `stmt` and then performs common logic on `sdap`.
-    fn modify_sdap_if_sig_drop_exists(
+impl<'tcx> LateLintPass<'tcx> for SignificantDropTightening<'tcx> {
+    fn check_fn(
         &mut self,
         cx: &LateContext<'tcx>,
-        expr: &'tcx hir::Expr<'_>,
-        idx: usize,
-        sdap: &mut SigDropAuxParams,
-        stmt: &hir::Stmt<'_>,
-        cb: impl Fn(&mut SigDropAuxParams),
+        _: hir::intravisit::FnKind<'_>,
+        _: &hir::FnDecl<'_>,
+        body: &'tcx hir::Body<'_>,
+        _: Span,
+        _: hir::def_id::LocalDefId,
     ) {
-        let mut sig_drop_finder = SigDropFinder::new(cx, &mut self.seen_types, &mut self.type_cache);
-        sig_drop_finder.visit_expr(expr);
-        if sig_drop_finder.has_sig_drop {
-            cb(sdap);
-            if sdap.number_of_stmts > 0 {
-                sdap.last_use_stmt_idx = idx;
-                sdap.last_use_stmt_span = stmt.span;
-                if let hir::ExprKind::MethodCall(_, _, _, span) = expr.kind {
-                    sdap.last_use_method_span = span;
-                }
+        self.apas.clear();
+        let initial_dummy_stmt = dummy_stmt_expr(&body.value);
+        let mut ap = AuxParams::new(&mut self.apas, &initial_dummy_stmt);
+        StmtsChecker::new(&mut ap, cx, &mut self.seen_types, &mut self.type_cache).visit_body(body);
+        for apa in ap.apas.values() {
+            if apa.counter <= 1 || !apa.has_expensive_expr_after_last_attr {
+                continue;
             }
-            sdap.number_of_stmts = sdap.number_of_stmts.wrapping_add(1);
-        }
-    }
-
-    /// Shows generic overall messages as well as specialized messages depending on the usage.
-    fn set_suggestions(cx: &LateContext<'tcx>, block_span: Span, diag: &mut Diagnostic, sdap: &SigDropAuxParams) {
-        match sdap.number_of_stmts {
-            0 | 1 => {},
-            2 => {
-                let indent = " ".repeat(indent_of(cx, sdap.last_use_stmt_span).unwrap_or(0));
-                let init_method = snippet(cx, sdap.init_method_span, "..");
-                let usage_method = snippet(cx, sdap.last_use_method_span, "..");
-                let stmt = if let Some(last_use_bind_span) = sdap.last_use_bind_span {
-                    format!(
-                        "\n{indent}let {} = {init_method}.{usage_method};",
-                        snippet(cx, last_use_bind_span, ".."),
-                    )
-                } else {
-                    format!("\n{indent}{init_method}.{usage_method};")
-                };
-                diag.span_suggestion_verbose(
-                    sdap.init_stmt_span,
-                    "merge the temporary construction with its single usage",
-                    stmt,
-                    Applicability::MaybeIncorrect,
-                );
-                diag.span_suggestion(
-                    sdap.last_use_stmt_span,
-                    "remove separated single usage",
-                    "",
-                    Applicability::MaybeIncorrect,
-                );
-            },
-            _ => {
-                diag.span_suggestion(
-                    sdap.last_use_stmt_span.shrink_to_hi(),
-                    "drop the temporary after the end of its last usage",
-                    format!(
-                        "\n{}drop({});",
-                        " ".repeat(indent_of(cx, sdap.last_use_stmt_span).unwrap_or(0)),
-                        sdap.init_bind_ident
-                    ),
-                    Applicability::MaybeIncorrect,
-                );
-            },
-        }
-        diag.note("this might lead to unnecessary resource contention");
-        diag.span_label(
-            block_span,
-            format!(
-                "temporary `{}` is currently being dropped at the end of its contained scope",
-                sdap.init_bind_ident
-            ),
-        );
-    }
-}
-
-impl<'tcx> LateLintPass<'tcx> for SignificantDropTightening<'tcx> {
-    fn check_block(&mut self, cx: &LateContext<'tcx>, block: &'tcx hir::Block<'_>) {
-        let dummy_ret_stmt = block.expr.map(|expr| hir::Stmt {
-            hir_id: hir::HirId::INVALID,
-            kind: hir::StmtKind::Expr(expr),
-            span: DUMMY_SP,
-        });
-        let mut sdap = SigDropAuxParams::default();
-        for (idx, stmt) in Self::all_block_stmts(block.stmts, dummy_ret_stmt.as_ref()).enumerate() {
-            match stmt.kind {
-                hir::StmtKind::Expr(expr) => self.modify_sdap_if_sig_drop_exists(
-                    cx,
-                    expr,
-                    idx,
-                    &mut sdap,
-                    stmt,
-                    |_| {}
-                ),
-                hir::StmtKind::Local(local) if let Some(expr) = local.init => self.modify_sdap_if_sig_drop_exists(
-                    cx,
-                    expr,
-                    idx,
-                    &mut sdap,
-                    stmt,
-                    |local_sdap| {
-                        if local_sdap.number_of_stmts == 0 {
-                            if let hir::PatKind::Binding(_, _, ident, _) = local.pat.kind {
-                                local_sdap.init_bind_ident = ident;
-                            }
-                            if let hir::ExprKind::MethodCall(_, local_expr, _, span) = expr.kind {
-                                local_sdap.init_method_span = local_expr.span.to(span);
-                            }
-                            local_sdap.init_stmt_span = stmt.span;
-                        }
-                        else if let hir::PatKind::Binding(_, _, ident, _) = local.pat.kind {
-                            local_sdap.last_use_bind_span = Some(ident.span);
-                        }
-                    }
-                ),
-                hir::StmtKind::Semi(expr) => {
-                    if Self::has_drop(expr, sdap.init_bind_ident) {
-                        return;
-                    }
-                    self.modify_sdap_if_sig_drop_exists(cx, expr, idx, &mut sdap, stmt, |_| {});
-                },
-                _ => {}
-            };
-        }
-
-        let idx = sdap.last_use_stmt_idx.wrapping_add(1);
-        let stmts_after_last_use = Self::all_block_stmts(block.stmts, dummy_ret_stmt.as_ref()).skip(idx);
-        if sdap.number_of_stmts > 1 && Self::at_least_one_stmt_is_expensive(stmts_after_last_use) {
             span_lint_and_then(
                 cx,
                 SIGNIFICANT_DROP_TIGHTENING,
-                sdap.init_bind_ident.span,
+                apa.first_bind_ident.span,
                 "temporary with significant `Drop` can be early dropped",
                 |diag| {
-                    Self::set_suggestions(cx, block.span, diag, &sdap);
+                    match apa.counter {
+                        0 | 1 => {},
+                        2 => {
+                            let indent = " ".repeat(indent_of(cx, apa.last_stmt_span).unwrap_or(0));
+                            let init_method = snippet(cx, apa.first_method_span, "..");
+                            let usage_method = snippet(cx, apa.last_method_span, "..");
+                            let stmt = if apa.last_bind_ident != Ident::empty() {
+                                format!(
+                                    "\n{indent}let {} = {init_method}.{usage_method};",
+                                    snippet(cx, apa.last_bind_ident.span, ".."),
+                                )
+                            } else {
+                                format!("\n{indent}{init_method}.{usage_method};")
+                            };
+                            diag.span_suggestion_verbose(
+                                apa.first_stmt_span,
+                                "merge the temporary construction with its single usage",
+                                stmt,
+                                Applicability::MaybeIncorrect,
+                            );
+                            diag.span_suggestion(
+                                apa.last_stmt_span,
+                                "remove separated single usage",
+                                "",
+                                Applicability::MaybeIncorrect,
+                            );
+                        },
+                        _ => {
+                            diag.span_suggestion(
+                                apa.last_stmt_span.shrink_to_hi(),
+                                "drop the temporary after the end of its last usage",
+                                format!(
+                                    "\n{}drop({});",
+                                    " ".repeat(indent_of(cx, apa.last_stmt_span).unwrap_or(0)),
+                                    apa.first_bind_ident
+                                ),
+                                Applicability::MaybeIncorrect,
+                            );
+                        },
+                    }
+                    diag.note("this might lead to unnecessary resource contention");
+                    diag.span_label(
+                        apa.first_block_span,
+                        format!(
+                            "temporary `{}` is currently being dropped at the end of its contained scope",
+                            apa.first_bind_ident
+                        ),
+                    );
                 },
             );
         }
     }
 }
 
-/// Auxiliary parameters used on each block check.
-struct SigDropAuxParams {
-    /// The binding or variable that references the initial construction of the type marked with
-    /// `#[has_significant_drop]`.
-    init_bind_ident: Ident,
-    /// Similar to `init_bind_ident` but encompasses the right-hand method call.
-    init_method_span: Span,
-    /// Similar to `init_bind_ident` but encompasses the whole contained statement.
-    init_stmt_span: Span,
-
-    /// The last visited binding or variable span within a block that had any referenced inner type
-    /// marked with `#[has_significant_drop]`.
-    last_use_bind_span: Option<Span>,
-    /// Index of the last visited statement within a block that had any referenced inner type
-    /// marked with `#[has_significant_drop]`.
-    last_use_stmt_idx: usize,
-    /// Similar to `last_use_bind_span` but encompasses the whole contained statement.
-    last_use_stmt_span: Span,
-    /// Similar to `last_use_bind_span` but encompasses the right-hand method call.
-    last_use_method_span: Span,
-
-    /// Total number of statements within a block that have any referenced inner type marked with
-    /// `#[has_significant_drop]`.
-    number_of_stmts: usize,
-}
-
-impl Default for SigDropAuxParams {
-    fn default() -> Self {
-        Self {
-            init_bind_ident: Ident::empty(),
-            init_method_span: DUMMY_SP,
-            init_stmt_span: DUMMY_SP,
-            last_use_bind_span: None,
-            last_use_method_span: DUMMY_SP,
-            last_use_stmt_idx: 0,
-            last_use_stmt_span: DUMMY_SP,
-            number_of_stmts: 0,
-        }
-    }
-}
-
-/// Checks the existence of the `#[has_significant_drop]` attribute
-struct SigDropChecker<'cx, 'sdt, 'tcx> {
+/// Checks the existence of the `#[has_significant_drop]` attribute.
+struct AttrChecker<'cx, 'others, 'tcx> {
     cx: &'cx LateContext<'tcx>,
-    seen_types: &'sdt mut FxHashSet<Ty<'tcx>>,
-    type_cache: &'sdt mut FxHashMap<Ty<'tcx>, bool>,
+    seen_types: &'others mut FxHashSet<Ty<'tcx>>,
+    type_cache: &'others mut FxHashMap<Ty<'tcx>, bool>,
 }
 
-impl<'cx, 'sdt, 'tcx> SigDropChecker<'cx, 'sdt, 'tcx> {
+impl<'cx, 'others, 'tcx> AttrChecker<'cx, 'others, 'tcx> {
     pub(crate) fn new(
         cx: &'cx LateContext<'tcx>,
-        seen_types: &'sdt mut FxHashSet<Ty<'tcx>>,
-        type_cache: &'sdt mut FxHashMap<Ty<'tcx>, bool>,
+        seen_types: &'others mut FxHashSet<Ty<'tcx>>,
+        type_cache: &'others mut FxHashMap<Ty<'tcx>, bool>,
     ) -> Self {
         seen_types.clear();
         Self {
@@ -314,7 +162,17 @@ impl<'cx, 'sdt, 'tcx> SigDropChecker<'cx, 'sdt, 'tcx> {
         }
     }
 
-    pub(crate) fn has_sig_drop_attr_uncached(&mut self, ty: Ty<'tcx>) -> bool {
+    fn has_sig_drop_attr(&mut self, ty: Ty<'tcx>) -> bool {
+        // The borrow checker prevents us from using something fancier like or_insert_with.
+        if let Some(ty) = self.type_cache.get(&ty) {
+            return *ty;
+        }
+        let value = self.has_sig_drop_attr_uncached(ty);
+        self.type_cache.insert(ty, value);
+        value
+    }
+
+    fn has_sig_drop_attr_uncached(&mut self, ty: Ty<'tcx>) -> bool {
         if let Some(adt) = ty.ty_adt_def() {
             let mut iter = get_attr(
                 self.cx.sess(),
@@ -350,73 +208,246 @@ impl<'cx, 'sdt, 'tcx> SigDropChecker<'cx, 'sdt, 'tcx> {
         }
     }
 
-    pub(crate) fn has_sig_drop_attr(&mut self, ty: Ty<'tcx>) -> bool {
-        // The borrow checker prevents us from using something fancier like or_insert_with.
-        if let Some(ty) = self.type_cache.get(&ty) {
-            return *ty;
-        }
-        let value = self.has_sig_drop_attr_uncached(ty);
-        self.type_cache.insert(ty, value);
-        value
-    }
-
     fn has_seen_ty(&mut self, ty: Ty<'tcx>) -> bool {
         !self.seen_types.insert(ty)
     }
 }
 
-/// Performs recursive calls to find any inner type marked with `#[has_significant_drop]`.
-struct SigDropFinder<'cx, 'sdt, 'tcx> {
-    cx: &'cx LateContext<'tcx>,
-    has_sig_drop: bool,
-    sig_drop_checker: SigDropChecker<'cx, 'sdt, 'tcx>,
+struct StmtsChecker<'ap, 'lc, 'others, 'stmt, 'tcx> {
+    ap: &'ap mut AuxParams<'others, 'stmt, 'tcx>,
+    cx: &'lc LateContext<'tcx>,
+    seen_types: &'others mut FxHashSet<Ty<'tcx>>,
+    type_cache: &'others mut FxHashMap<Ty<'tcx>, bool>,
 }
 
-impl<'cx, 'sdt, 'tcx> SigDropFinder<'cx, 'sdt, 'tcx> {
+impl<'ap, 'lc, 'others, 'stmt, 'tcx> StmtsChecker<'ap, 'lc, 'others, 'stmt, 'tcx> {
     fn new(
-        cx: &'cx LateContext<'tcx>,
-        seen_types: &'sdt mut FxHashSet<Ty<'tcx>>,
-        type_cache: &'sdt mut FxHashMap<Ty<'tcx>, bool>,
+        ap: &'ap mut AuxParams<'others, 'stmt, 'tcx>,
+        cx: &'lc LateContext<'tcx>,
+        seen_types: &'others mut FxHashSet<Ty<'tcx>>,
+        type_cache: &'others mut FxHashMap<Ty<'tcx>, bool>,
     ) -> Self {
         Self {
+            ap,
             cx,
-            has_sig_drop: false,
-            sig_drop_checker: SigDropChecker::new(cx, seen_types, type_cache),
+            seen_types,
+            type_cache,
+        }
+    }
+
+    fn manage_has_expensive_expr_after_last_attr(&mut self) {
+        let has_expensive_stmt = match self.ap.curr_stmt.kind {
+            hir::StmtKind::Expr(expr) if !is_expensive_expr(expr) => false,
+            hir::StmtKind::Local(local) if let Some(expr) = local.init
+                && let hir::ExprKind::Path(_) = expr.kind => false,
+            _ => true
+        };
+        if has_expensive_stmt {
+            for apa in self.ap.apas.values_mut() {
+                let last_stmt_is_not_dummy = apa.last_stmt_span != DUMMY_SP;
+                let last_stmt_is_not_curr = self.ap.curr_stmt.span != apa.last_stmt_span;
+                let block_equals_curr = self.ap.curr_block_hir_id == apa.first_block_hir_id;
+                let block_is_ancestor = self
+                    .cx
+                    .tcx
+                    .hir()
+                    .parent_iter(self.ap.curr_block_hir_id)
+                    .any(|(id, _)| id == apa.first_block_hir_id);
+                if last_stmt_is_not_dummy && last_stmt_is_not_curr && (block_equals_curr || block_is_ancestor) {
+                    apa.has_expensive_expr_after_last_attr = true;
+                }
+            }
         }
     }
 }
 
-impl<'cx, 'sdt, 'tcx> Visitor<'tcx> for SigDropFinder<'cx, 'sdt, 'tcx> {
-    fn visit_expr(&mut self, ex: &'tcx hir::Expr<'_>) {
-        if self
-            .sig_drop_checker
-            .has_sig_drop_attr(self.cx.typeck_results().expr_ty(ex))
-        {
-            self.has_sig_drop = true;
-            return;
+impl<'ap, 'lc, 'others, 'stmt, 'tcx> Visitor<'tcx> for StmtsChecker<'ap, 'lc, 'others, 'stmt, 'tcx> {
+    fn visit_block(&mut self, block: &'tcx hir::Block<'tcx>) {
+        self.ap.curr_block_hir_id = block.hir_id;
+        self.ap.curr_block_span = block.span;
+        for stmt in block.stmts.iter() {
+            self.ap.curr_stmt = Cow::Borrowed(stmt);
+            self.visit_stmt(stmt);
+            self.ap.curr_block_hir_id = block.hir_id;
+            self.ap.curr_block_span = block.span;
+            self.manage_has_expensive_expr_after_last_attr();
+        }
+        if let Some(expr) = block.expr {
+            self.ap.curr_stmt = Cow::Owned(dummy_stmt_expr(expr));
+            self.visit_expr(expr);
+            self.ap.curr_block_hir_id = block.hir_id;
+            self.ap.curr_block_span = block.span;
+            self.manage_has_expensive_expr_after_last_attr();
         }
+    }
 
-        match ex.kind {
-            hir::ExprKind::MethodCall(_, expr, ..) => {
-                self.visit_expr(expr);
-            },
-            hir::ExprKind::Array(..)
-            | hir::ExprKind::Assign(..)
-            | hir::ExprKind::AssignOp(..)
-            | hir::ExprKind::Binary(..)
-            | hir::ExprKind::Call(..)
-            | hir::ExprKind::Field(..)
-            | hir::ExprKind::If(..)
-            | hir::ExprKind::Index(..)
-            | hir::ExprKind::Match(..)
-            | hir::ExprKind::Repeat(..)
-            | hir::ExprKind::Ret(..)
-            | hir::ExprKind::Tup(..)
-            | hir::ExprKind::Unary(..)
-            | hir::ExprKind::Yield(..) => {
-                walk_expr(self, ex);
-            },
-            _ => {},
+    fn visit_expr(&mut self, expr: &'tcx hir::Expr<'tcx>) {
+        let modify_apa_params = |apa: &mut AuxParamsAttr| {
+            apa.counter = apa.counter.wrapping_add(1);
+            apa.has_expensive_expr_after_last_attr = false;
+        };
+        let mut ac = AttrChecker::new(self.cx, self.seen_types, self.type_cache);
+        if ac.has_sig_drop_attr(self.cx.typeck_results().expr_ty(expr)) {
+            if let hir::StmtKind::Local(local) = self.ap.curr_stmt.kind
+                && let hir::PatKind::Binding(_, hir_id, ident, _) = local.pat.kind
+                && !self.ap.apas.contains_key(&hir_id)
+                && {
+                    if let Some(local_hir_id) = path_to_local(expr) {
+                        local_hir_id == hir_id
+                    }
+                    else {
+                        true
+                    }
+                }
+            {
+                let mut apa = AuxParamsAttr::default();
+                apa.first_bind_ident = ident;
+                apa.first_block_hir_id = self.ap.curr_block_hir_id;
+                apa.first_block_span = self.ap.curr_block_span;
+                apa.first_method_span = {
+                    let expr_or_init = expr_or_init(self.cx, expr);
+                    if let hir::ExprKind::MethodCall(_, local_expr, _, span) = expr_or_init.kind {
+                        local_expr.span.to(span)
+                    }
+                    else {
+                        expr_or_init.span
+                    }
+                };
+                apa.first_stmt_span = self.ap.curr_stmt.span;
+                modify_apa_params(&mut apa);
+                let _ = self.ap.apas.insert(hir_id, apa);
+            } else {
+                let Some(hir_id) = path_to_local(expr) else { return; };
+                let Some(apa) = self.ap.apas.get_mut(&hir_id) else { return; };
+                match self.ap.curr_stmt.kind {
+                    hir::StmtKind::Local(local) => {
+                        if let hir::PatKind::Binding(_, _, ident, _) = local.pat.kind {
+                            apa.last_bind_ident = ident;
+                        }
+                        if let Some(local_init) = local.init
+                            && let hir::ExprKind::MethodCall(_, _, _, span) = local_init.kind
+                        {
+                            apa.last_method_span = span;
+                        }
+                    },
+                    hir::StmtKind::Semi(expr) => {
+                        if has_drop(expr, &apa.first_bind_ident) {
+                            apa.has_expensive_expr_after_last_attr = false;
+                            apa.last_stmt_span = DUMMY_SP;
+                            return;
+                        }
+                        if let hir::ExprKind::MethodCall(_, _, _, span) = expr.kind {
+                            apa.last_method_span = span;
+                        }
+                    },
+                    _ => {},
+                }
+                apa.last_stmt_span = self.ap.curr_stmt.span;
+                modify_apa_params(apa);
+            }
         }
+        walk_expr(self, expr);
+    }
+}
+
+/// Auxiliary parameters used on each block check of an item
+struct AuxParams<'others, 'stmt, 'tcx> {
+    //// See [AuxParamsAttr].
+    apas: &'others mut FxIndexMap<hir::HirId, AuxParamsAttr>,
+    /// The current block identifier that is being visited.
+    curr_block_hir_id: hir::HirId,
+    /// The current block span that is being visited.
+    curr_block_span: Span,
+    /// The current statement that is being visited.
+    curr_stmt: Cow<'stmt, hir::Stmt<'tcx>>,
+}
+
+impl<'others, 'stmt, 'tcx> AuxParams<'others, 'stmt, 'tcx> {
+    fn new(apas: &'others mut FxIndexMap<hir::HirId, AuxParamsAttr>, curr_stmt: &'stmt hir::Stmt<'tcx>) -> Self {
+        Self {
+            apas,
+            curr_block_hir_id: hir::HirId::INVALID,
+            curr_block_span: DUMMY_SP,
+            curr_stmt: Cow::Borrowed(curr_stmt),
+        }
+    }
+}
+
+/// Auxiliary parameters used on expression created with `#[has_significant_drop]`.
+#[derive(Debug)]
+struct AuxParamsAttr {
+    /// The number of times `#[has_significant_drop]` was referenced.
+    counter: usize,
+    /// If an expensive expression follows the last use of anything marked with
+    /// `#[has_significant_drop]`.
+    has_expensive_expr_after_last_attr: bool,
+
+    /// The identifier of the block that involves the first `#[has_significant_drop]`.
+    first_block_hir_id: hir::HirId,
+    /// The span of the block that involves the first `#[has_significant_drop]`.
+    first_block_span: Span,
+    /// The binding or variable that references the initial construction of the type marked with
+    /// `#[has_significant_drop]`.
+    first_bind_ident: Ident,
+    /// Similar to `init_bind_ident` but encompasses the right-hand method call.
+    first_method_span: Span,
+    /// Similar to `init_bind_ident` but encompasses the whole contained statement.
+    first_stmt_span: Span,
+
+    /// The last visited binding or variable span within a block that had any referenced inner type
+    /// marked with `#[has_significant_drop]`.
+    last_bind_ident: Ident,
+    /// Similar to `last_bind_span` but encompasses the right-hand method call.
+    last_method_span: Span,
+    /// Similar to `last_bind_span` but encompasses the whole contained statement.
+    last_stmt_span: Span,
+}
+
+impl Default for AuxParamsAttr {
+    fn default() -> Self {
+        Self {
+            counter: 0,
+            has_expensive_expr_after_last_attr: false,
+            first_block_hir_id: hir::HirId::INVALID,
+            first_bind_ident: Ident::empty(),
+            first_block_span: DUMMY_SP,
+            first_method_span: DUMMY_SP,
+            first_stmt_span: DUMMY_SP,
+            last_bind_ident: Ident::empty(),
+            last_method_span: DUMMY_SP,
+            last_stmt_span: DUMMY_SP,
+        }
+    }
+}
+
+fn dummy_stmt_expr<'any>(expr: &'any hir::Expr<'any>) -> hir::Stmt<'any> {
+    hir::Stmt {
+        hir_id: hir::HirId::INVALID,
+        kind: hir::StmtKind::Expr(expr),
+        span: DUMMY_SP,
+    }
+}
+
+fn has_drop(expr: &hir::Expr<'_>, first_bind_ident: &Ident) -> bool {
+    if let hir::ExprKind::Call(fun, args) = expr.kind
+        && let hir::ExprKind::Path(hir::QPath::Resolved(_, fun_path)) = &fun.kind
+        && let [fun_ident, ..] = fun_path.segments
+        && fun_ident.ident.name == rustc_span::sym::drop
+        && let [first_arg, ..] = args
+        && let hir::ExprKind::Path(hir::QPath::Resolved(_, arg_path)) = &first_arg.kind
+        && let [first_arg_ps, .. ] = arg_path.segments
+    {
+        &first_arg_ps.ident == first_bind_ident
+    }
+    else {
+        false
+    }
+}
+
+fn is_expensive_expr(expr: &hir::Expr<'_>) -> bool {
+    if let hir::ExprKind::Path(_) = expr.kind {
+        false
+    } else {
+        true
     }
 }
diff --git a/tests/ui/significant_drop_tightening.fixed b/tests/ui/significant_drop_tightening.fixed
index ee7f2b0631a..7b848ead784 100644
--- a/tests/ui/significant_drop_tightening.fixed
+++ b/tests/ui/significant_drop_tightening.fixed
@@ -16,6 +16,18 @@ pub fn complex_return_triggers_the_lint() -> i32 {
     foo()
 }
 
+pub fn issue_10413() {
+    let mutex = Mutex::new(Some(1));
+    let opt = Some(1);
+    if opt.is_some() {
+        let lock = mutex.lock().unwrap();
+        let _ = *lock;
+        if opt.is_some() {
+            let _ = *lock;
+        }
+    }
+}
+
 pub fn path_return_can_be_ignored() -> i32 {
     let mutex = Mutex::new(1);
     let lock = mutex.lock().unwrap();
diff --git a/tests/ui/significant_drop_tightening.rs b/tests/ui/significant_drop_tightening.rs
index 9c139deb95f..36f77cf1bdb 100644
--- a/tests/ui/significant_drop_tightening.rs
+++ b/tests/ui/significant_drop_tightening.rs
@@ -15,6 +15,18 @@ pub fn complex_return_triggers_the_lint() -> i32 {
     foo()
 }
 
+pub fn issue_10413() {
+    let mutex = Mutex::new(Some(1));
+    let opt = Some(1);
+    if opt.is_some() {
+        let lock = mutex.lock().unwrap();
+        let _ = *lock;
+        if opt.is_some() {
+            let _ = *lock;
+        }
+    }
+}
+
 pub fn path_return_can_be_ignored() -> i32 {
     let mutex = Mutex::new(1);
     let lock = mutex.lock().unwrap();
diff --git a/tests/ui/significant_drop_tightening.stderr b/tests/ui/significant_drop_tightening.stderr
index ab8ce356ec7..3bdac0b0a6b 100644
--- a/tests/ui/significant_drop_tightening.stderr
+++ b/tests/ui/significant_drop_tightening.stderr
@@ -23,7 +23,7 @@ LL +     drop(lock);
    |
 
 error: temporary with significant `Drop` can be early dropped
-  --> $DIR/significant_drop_tightening.rs:44:13
+  --> $DIR/significant_drop_tightening.rs:56:13
    |
 LL | /     {
 LL | |         let mutex = Mutex::new(1i32);
@@ -43,7 +43,7 @@ LL +         drop(lock);
    |
 
 error: temporary with significant `Drop` can be early dropped
-  --> $DIR/significant_drop_tightening.rs:65:13
+  --> $DIR/significant_drop_tightening.rs:77:13
    |
 LL | /     {
 LL | |         let mutex = Mutex::new(1i32);
@@ -67,7 +67,7 @@ LL +
    |
 
 error: temporary with significant `Drop` can be early dropped
-  --> $DIR/significant_drop_tightening.rs:71:17
+  --> $DIR/significant_drop_tightening.rs:83:17
    |
 LL | /     {
 LL | |         let mutex = Mutex::new(vec![1i32]);
-- 
cgit 1.4.1-3-g733a5


From fc832f0eb74bb4c4023e359cc90dab941dc2654d Mon Sep 17 00:00:00 2001
From: Caio <c410.f3r@gmail.com>
Date: Thu, 29 Jun 2023 09:30:04 -0300
Subject: Dogfood

---
 clippy_lints/src/significant_drop_tightening.rs | 44 ++++++++++++-------------
 1 file changed, 21 insertions(+), 23 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/significant_drop_tightening.rs b/clippy_lints/src/significant_drop_tightening.rs
index 140dc66badb..fffa8a380c2 100644
--- a/clippy_lints/src/significant_drop_tightening.rs
+++ b/clippy_lints/src/significant_drop_tightening.rs
@@ -74,7 +74,7 @@ impl<'tcx> LateLintPass<'tcx> for SignificantDropTightening<'tcx> {
         _: hir::def_id::LocalDefId,
     ) {
         self.apas.clear();
-        let initial_dummy_stmt = dummy_stmt_expr(&body.value);
+        let initial_dummy_stmt = dummy_stmt_expr(body.value);
         let mut ap = AuxParams::new(&mut self.apas, &initial_dummy_stmt);
         StmtsChecker::new(&mut ap, cx, &mut self.seen_types, &mut self.type_cache).visit_body(body);
         for apa in ap.apas.values() {
@@ -93,13 +93,13 @@ impl<'tcx> LateLintPass<'tcx> for SignificantDropTightening<'tcx> {
                             let indent = " ".repeat(indent_of(cx, apa.last_stmt_span).unwrap_or(0));
                             let init_method = snippet(cx, apa.first_method_span, "..");
                             let usage_method = snippet(cx, apa.last_method_span, "..");
-                            let stmt = if apa.last_bind_ident != Ident::empty() {
+                            let stmt = if apa.last_bind_ident == Ident::empty() {
+                                format!("\n{indent}{init_method}.{usage_method};")
+                            } else {
                                 format!(
                                     "\n{indent}let {} = {init_method}.{usage_method};",
                                     snippet(cx, apa.last_bind_ident.span, ".."),
                                 )
-                            } else {
-                                format!("\n{indent}{init_method}.{usage_method};")
                             };
                             diag.span_suggestion_verbose(
                                 apa.first_stmt_span,
@@ -265,7 +265,7 @@ impl<'ap, 'lc, 'others, 'stmt, 'tcx> Visitor<'tcx> for StmtsChecker<'ap, 'lc, 'o
     fn visit_block(&mut self, block: &'tcx hir::Block<'tcx>) {
         self.ap.curr_block_hir_id = block.hir_id;
         self.ap.curr_block_span = block.span;
-        for stmt in block.stmts.iter() {
+        for stmt in block.stmts {
             self.ap.curr_stmt = Cow::Borrowed(stmt);
             self.visit_stmt(stmt);
             self.ap.curr_block_hir_id = block.hir_id;
@@ -300,20 +300,22 @@ impl<'ap, 'lc, 'others, 'stmt, 'tcx> Visitor<'tcx> for StmtsChecker<'ap, 'lc, 'o
                     }
                 }
             {
-                let mut apa = AuxParamsAttr::default();
-                apa.first_bind_ident = ident;
-                apa.first_block_hir_id = self.ap.curr_block_hir_id;
-                apa.first_block_span = self.ap.curr_block_span;
-                apa.first_method_span = {
-                    let expr_or_init = expr_or_init(self.cx, expr);
-                    if let hir::ExprKind::MethodCall(_, local_expr, _, span) = expr_or_init.kind {
-                        local_expr.span.to(span)
-                    }
-                    else {
-                        expr_or_init.span
-                    }
+                let mut apa = AuxParamsAttr {
+                    first_bind_ident: ident,
+                    first_block_hir_id: self.ap.curr_block_hir_id,
+                    first_block_span: self.ap.curr_block_span,
+                    first_method_span: {
+                        let expr_or_init = expr_or_init(self.cx, expr);
+                        if let hir::ExprKind::MethodCall(_, local_expr, _, span) = expr_or_init.kind {
+                            local_expr.span.to(span)
+                        }
+                        else {
+                            expr_or_init.span
+                        }
+                    },
+                    first_stmt_span: self.ap.curr_stmt.span,
+                    ..Default::default()
                 };
-                apa.first_stmt_span = self.ap.curr_stmt.span;
                 modify_apa_params(&mut apa);
                 let _ = self.ap.apas.insert(hir_id, apa);
             } else {
@@ -445,9 +447,5 @@ fn has_drop(expr: &hir::Expr<'_>, first_bind_ident: &Ident) -> bool {
 }
 
 fn is_expensive_expr(expr: &hir::Expr<'_>) -> bool {
-    if let hir::ExprKind::Path(_) = expr.kind {
-        false
-    } else {
-        true
-    }
+    !matches!(expr.kind, hir::ExprKind::Path(_))
 }
-- 
cgit 1.4.1-3-g733a5


From 648d1ae8e08ab8617d17c4c815a067dd7d7e550f Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Wed, 14 Jun 2023 03:44:05 +0200
Subject: lint on matches and pattern matching

---
 clippy_lints/src/methods/filter_map.rs | 320 +++++++++++++++++++++++++++------
 clippy_utils/src/higher.rs             |   1 +
 tests/ui/manual_filter_map.fixed       |  24 +++
 tests/ui/manual_filter_map.rs          |  28 +++
 tests/ui/manual_filter_map.stderr      |  73 +++++++-
 tests/ui/manual_find_map.stderr        |  53 ++++++
 6 files changed, 440 insertions(+), 59 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/filter_map.rs b/clippy_lints/src/methods/filter_map.rs
index fc80f2eeae0..4271f2041fe 100644
--- a/clippy_lints/src/methods/filter_map.rs
+++ b/clippy_lints/src/methods/filter_map.rs
@@ -1,7 +1,9 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
+use clippy_utils::macros::{is_panic, root_macro_call};
 use clippy_utils::source::{indent_of, reindent_multiline, snippet};
 use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{is_trait_method, path_to_local_id, peel_blocks, SpanlessEq};
+use clippy_utils::{higher, is_trait_method, path_to_local_id, peel_blocks, SpanlessEq};
+use hir::{Body, HirId, MatchSource, Pat};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
@@ -10,7 +12,7 @@ use rustc_hir::{Closure, Expr, ExprKind, PatKind, PathSegment, QPath, UnOp};
 use rustc_lint::LateContext;
 use rustc_middle::ty::adjustment::Adjust;
 use rustc_span::source_map::Span;
-use rustc_span::symbol::{sym, Symbol};
+use rustc_span::symbol::{sym, Ident, Symbol};
 use std::borrow::Cow;
 
 use super::MANUAL_FILTER_MAP;
@@ -50,6 +52,214 @@ fn is_option_filter_map(cx: &LateContext<'_>, filter_arg: &hir::Expr<'_>, map_ar
     is_method(cx, map_arg, sym::unwrap) && is_method(cx, filter_arg, sym!(is_some))
 }
 
+#[derive(Debug, Copy, Clone)]
+enum OffendingFilterExpr<'tcx> {
+    /// `.filter(|opt| opt.is_some())`
+    IsSome {
+        /// The receiver expression
+        receiver: &'tcx Expr<'tcx>,
+        /// If `Some`, then this contains the span of an expression that possibly contains side
+        /// effects: `.filter(|opt| side_effect(opt).is_some())`
+        ///                         ^^^^^^^^^^^^^^^^
+        ///
+        /// We will use this later for warning the user that the suggested fix may change
+        /// the behavior.
+        side_effect_expr_span: Option<Span>,
+    },
+    /// `.filter(|res| res.is_ok())`
+    IsOk {
+        /// The receiver expression
+        receiver: &'tcx Expr<'tcx>,
+        /// See `IsSome`
+        side_effect_expr_span: Option<Span>,
+    },
+    /// `.filter(|enum| matches!(enum, Enum::A(_)))`
+    Matches {
+        /// The DefId of the variant being matched
+        variant_def_id: hir::def_id::DefId,
+    },
+}
+
+#[derive(Debug)]
+enum CalledMethod {
+    OptionIsSome,
+    ResultIsOk,
+}
+
+/// The result of checking a `map` call, returned by `OffendingFilterExpr::check_map_call`
+#[derive(Debug)]
+enum CheckResult<'tcx> {
+    Method {
+        map_arg: &'tcx Expr<'tcx>,
+        /// The method that was called inside of `filter`
+        method: CalledMethod,
+        /// See `OffendingFilterExpr::IsSome`
+        side_effect_expr_span: Option<Span>,
+    },
+    PatternMatching {
+        /// The span of the variant being matched
+        /// if let Some(s) = enum
+        ///        ^^^^^^^
+        variant_span: Span,
+        /// if let Some(s) = enum
+        ///             ^
+        variant_ident: Ident,
+    },
+}
+
+impl<'tcx> OffendingFilterExpr<'tcx> {
+    pub fn check_map_call(
+        &mut self,
+        cx: &LateContext<'tcx>,
+        map_body: &'tcx Body<'tcx>,
+        map_param_id: HirId,
+        filter_param_id: HirId,
+        is_filter_param_ref: bool,
+    ) -> Option<CheckResult<'tcx>> {
+        match *self {
+            OffendingFilterExpr::IsSome {
+                receiver,
+                side_effect_expr_span,
+            }
+            | OffendingFilterExpr::IsOk {
+                receiver,
+                side_effect_expr_span,
+            } => {
+                // check if closure ends with expect() or unwrap()
+                if let ExprKind::MethodCall(seg, map_arg, ..) = map_body.value.kind
+                    && matches!(seg.ident.name, sym::expect | sym::unwrap | sym::unwrap_or)
+                    // .map(|y| f(y).copied().unwrap())
+                    //          ~~~~
+                    && let map_arg_peeled = match map_arg.kind {
+                        ExprKind::MethodCall(method, original_arg, [], _) if acceptable_methods(method) => {
+                            original_arg
+                        },
+                        _ => map_arg,
+                    }
+                    // .map(|y| y[.acceptable_method()].unwrap())
+                    && let simple_equal = (path_to_local_id(receiver, filter_param_id)
+                        && path_to_local_id(map_arg_peeled, map_param_id))
+                    && let eq_fallback = (|a: &Expr<'_>, b: &Expr<'_>| {
+                        // in `filter(|x| ..)`, replace `*x` with `x`
+                        let a_path = if_chain! {
+                            if !is_filter_param_ref;
+                            if let ExprKind::Unary(UnOp::Deref, expr_path) = a.kind;
+                            then { expr_path } else { a }
+                        };
+                        // let the filter closure arg and the map closure arg be equal
+                        path_to_local_id(a_path, filter_param_id)
+                            && path_to_local_id(b, map_param_id)
+                            && cx.typeck_results().expr_ty_adjusted(a) == cx.typeck_results().expr_ty_adjusted(b)
+                    })
+                    && (simple_equal
+                        || SpanlessEq::new(cx).expr_fallback(eq_fallback).eq_expr(receiver, map_arg_peeled))
+                {
+                    Some(CheckResult::Method {
+                        map_arg,
+                        side_effect_expr_span,
+                        method: match self {
+                            OffendingFilterExpr::IsSome { .. } => CalledMethod::OptionIsSome,
+                            OffendingFilterExpr::IsOk { .. } => CalledMethod::ResultIsOk,
+                            OffendingFilterExpr::Matches { .. } => unreachable!("only IsSome and IsOk can get here"),
+                        }
+                    })
+                } else {
+                    None
+                }
+            },
+            OffendingFilterExpr::Matches { variant_def_id } => {
+                let expr_uses_local = |pat: &Pat<'_>, expr: &Expr<'_>| {
+                    if let PatKind::TupleStruct(QPath::Resolved(_, path), [subpat], _) = pat.kind
+                        && let PatKind::Binding(_, local_id, ident, _) = subpat.kind
+                        && path_to_local_id(expr.peel_blocks(), local_id)
+                        && let Some(local_variant_def_id) = path.res.opt_def_id()
+                        && local_variant_def_id == variant_def_id
+                    {
+                        Some((ident, pat.span))
+                    } else {
+                        None
+                    }
+                };
+
+                // look for:
+                // `if let Variant   (v) =         enum { v } else { unreachable!() }`
+                //         ^^^^^^^    ^            ^^^^            ^^^^^^^^^^^^^^^^^^
+                //    variant_span  variant_ident  scrutinee       else_ (blocks peeled later)
+                // OR
+                // `match enum {   Variant       (v) => v,      _ => unreachable!() }`
+                //        ^^^^     ^^^^^^^        ^                  ^^^^^^^^^^^^^^
+                //     scrutinee  variant_span  variant_ident        else_
+                let (scrutinee, else_, variant_ident, variant_span) =
+                    match higher::IfLetOrMatch::parse(cx, map_body.value) {
+                        // For `if let` we want to check that the variant matching arm references the local created by its pattern
+                        Some(higher::IfLetOrMatch::IfLet(sc, pat, then, Some(else_)))
+                            if let Some((ident, span)) = expr_uses_local(pat, then) =>
+                        {
+                            (sc, else_, ident, span)
+                        },
+                        // For `match` we want to check that the "else" arm is the wildcard (`_`) pattern
+                        // and that the variant matching arm references the local created by its pattern
+                        Some(higher::IfLetOrMatch::Match(sc, [arm, wild_arm], MatchSource::Normal))
+                            if let PatKind::Wild = wild_arm.pat.kind
+                                && let Some((ident, span)) = expr_uses_local(arm.pat, arm.body.peel_blocks()) =>
+                        {
+                            (sc, wild_arm.body, ident, span)
+                        },
+                        _ => return None,
+                    };
+
+                if path_to_local_id(scrutinee, map_param_id)
+                    // else branch should be a `panic!` or `unreachable!` macro call
+                    && let Some(mac) = root_macro_call(else_.peel_blocks().span)
+                    && (is_panic(cx, mac.def_id) || cx.tcx.opt_item_name(mac.def_id) == Some(sym::unreachable))
+                {
+                    Some(CheckResult::PatternMatching { variant_span, variant_ident })
+                } else {
+                    None
+                }
+            },
+        }
+    }
+
+    fn hir(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, filter_param_id: HirId) -> Option<Self> {
+        if let ExprKind::MethodCall(path, receiver, [], _) = expr.kind
+            && let Some(recv_ty) = cx.typeck_results().expr_ty(receiver).peel_refs().ty_adt_def()
+        {
+            // we still want to lint if the expression possibly contains side effects,
+            // *but* it can't be machine-applicable then, because that can change the behavior of the program:
+            // .filter(|x| effect(x).is_some()).map(|x| effect(x).unwrap())
+            // vs.
+            // .filter_map(|x| effect(x))
+            // 
+            // the latter only calls `effect` once
+            let side_effect_expr_span = receiver.can_have_side_effects().then_some(receiver.span);
+
+            if cx.tcx.is_diagnostic_item(sym::Option, recv_ty.did())
+                && path.ident.name == sym!(is_some)
+            {
+                Some(Self::IsSome { receiver, side_effect_expr_span })
+            } else if cx.tcx.is_diagnostic_item(sym::Result, recv_ty.did())
+                && path.ident.name == sym!(is_ok)
+            {
+                Some(Self::IsOk { receiver, side_effect_expr_span })
+            } else {
+                None
+            }
+        } else if let Some(macro_call) = root_macro_call(expr.span)
+            && cx.tcx.get_diagnostic_name(macro_call.def_id) == Some(sym::matches_macro)
+            // we know for a fact that the wildcard pattern is the second arm
+            && let ExprKind::Match(scrutinee, [arm, _], _) = expr.kind
+            && path_to_local_id(scrutinee, filter_param_id)
+            && let PatKind::TupleStruct(QPath::Resolved(_, path), ..) = arm.pat.kind
+            && let Some(variant_def_id) = path.res.opt_def_id()
+        {
+            Some(OffendingFilterExpr::Matches { variant_def_id })
+        } else {
+            None
+        }
+    }
+}
+
 /// is `filter(|x| x.is_some()).map(|x| x.unwrap())`
 fn is_filter_some_map_unwrap(
     cx: &LateContext<'_>,
@@ -104,55 +314,18 @@ pub(super) fn check(
         } else {
             (filter_param.pat, false)
         };
-        // closure ends with is_some() or is_ok()
+
         if let PatKind::Binding(_, filter_param_id, _, None) = filter_pat.kind;
-        if let ExprKind::MethodCall(path, filter_arg, [], _) = filter_body.value.kind;
-        if let Some(opt_ty) = cx.typeck_results().expr_ty(filter_arg).peel_refs().ty_adt_def();
-        if let Some(is_result) = if cx.tcx.is_diagnostic_item(sym::Option, opt_ty.did()) {
-            Some(false)
-        } else if cx.tcx.is_diagnostic_item(sym::Result, opt_ty.did()) {
-            Some(true)
-        } else {
-            None
-        };
-        if path.ident.name.as_str() == if is_result { "is_ok" } else { "is_some" };
+        if let Some(mut offending_expr) = OffendingFilterExpr::hir(cx, filter_body.value, filter_param_id);
 
-        // ...map(|x| ...unwrap())
         if let ExprKind::Closure(&Closure { body: map_body_id, .. }) = map_arg.kind;
         let map_body = cx.tcx.hir().body(map_body_id);
         if let [map_param] = map_body.params;
         if let PatKind::Binding(_, map_param_id, map_param_ident, None) = map_param.pat.kind;
-        // closure ends with expect() or unwrap()
-        if let ExprKind::MethodCall(seg, map_arg, ..) = map_body.value.kind;
-        if matches!(seg.ident.name, sym::expect | sym::unwrap | sym::unwrap_or);
-
-        // .filter(..).map(|y| f(y).copied().unwrap())
-        //                     ~~~~
-        let map_arg_peeled = match map_arg.kind {
-            ExprKind::MethodCall(method, original_arg, [], _) if acceptable_methods(method) => {
-                original_arg
-            },
-            _ => map_arg,
-        };
 
-        // .filter(|x| x.is_some()).map(|y| y[.acceptable_method()].unwrap())
-        let simple_equal = path_to_local_id(filter_arg, filter_param_id)
-            && path_to_local_id(map_arg_peeled, map_param_id);
+        if let Some(check_result) =
+            offending_expr.check_map_call(cx, map_body, map_param_id, filter_param_id, is_filter_param_ref);
 
-        let eq_fallback = |a: &Expr<'_>, b: &Expr<'_>| {
-            // in `filter(|x| ..)`, replace `*x` with `x`
-            let a_path = if_chain! {
-                if !is_filter_param_ref;
-                if let ExprKind::Unary(UnOp::Deref, expr_path) = a.kind;
-                then { expr_path } else { a }
-            };
-            // let the filter closure arg and the map closure arg be equal
-            path_to_local_id(a_path, filter_param_id)
-                && path_to_local_id(b, map_param_id)
-                && cx.typeck_results().expr_ty_adjusted(a) == cx.typeck_results().expr_ty_adjusted(b)
-        };
-
-        if simple_equal || SpanlessEq::new(cx).expr_fallback(eq_fallback).eq_expr(filter_arg, map_arg_peeled);
         then {
             let span = filter_span.with_hi(expr.span.hi());
             let (filter_name, lint) = if is_find {
@@ -161,22 +334,53 @@ pub(super) fn check(
                 ("filter", MANUAL_FILTER_MAP)
             };
             let msg = format!("`{filter_name}(..).map(..)` can be simplified as `{filter_name}_map(..)`");
-            let (to_opt, deref) = if is_result {
-                (".ok()", String::new())
-            } else {
-                let derefs = cx.typeck_results()
-                    .expr_adjustments(map_arg)
-                    .iter()
-                    .filter(|adj| matches!(adj.kind, Adjust::Deref(_)))
-                    .count();
 
-                ("", "*".repeat(derefs))
+            let (sugg, note_and_span, applicability) = match check_result {
+                CheckResult::Method { map_arg, method, side_effect_expr_span } => {
+                    let (to_opt, deref) = match method {
+                        CalledMethod::ResultIsOk => (".ok()", String::new()),
+                        CalledMethod::OptionIsSome => {
+                            let derefs = cx.typeck_results()
+                                .expr_adjustments(map_arg)
+                                .iter()
+                                .filter(|adj| matches!(adj.kind, Adjust::Deref(_)))
+                                .count();
+
+                            ("", "*".repeat(derefs))
+                        }
+                    };
+
+                    let sugg = format!(
+                        "{filter_name}_map(|{map_param_ident}| {deref}{}{to_opt})",
+                        snippet(cx, map_arg.span, ".."),
+                    );
+                    let (note_and_span, applicability) = if let Some(span) = side_effect_expr_span {
+                        let note = "the suggestion might change the behavior of the program when merging `filter` and `map`, \
+                            because this expression potentially contains side effects and will only execute once";
+
+                        (Some((note, span)), Applicability::MaybeIncorrect)
+                    } else {
+                        (None, Applicability::MachineApplicable)
+                    };
+
+                    (sugg, note_and_span, applicability)
+                }
+                CheckResult::PatternMatching { variant_span, variant_ident } => {
+                    let pat = snippet(cx, variant_span, "<pattern>");
+
+                    (format!("{filter_name}_map(|{map_param_ident}| match {map_param_ident} {{ \
+                        {pat} => Some({variant_ident}), \
+                        _ => None \
+                    }})"), None, Applicability::MachineApplicable)
+                }
             };
-            let sugg = format!(
-                "{filter_name}_map(|{map_param_ident}| {deref}{}{to_opt})",
-                snippet(cx, map_arg.span, ".."),
-            );
-            span_lint_and_sugg(cx, lint, span, &msg, "try", sugg, Applicability::MachineApplicable);
+            span_lint_and_then(cx, lint, span, &msg, |diag| {
+                diag.span_suggestion(span, "try", sugg, applicability);
+
+                if let Some((note, span)) = note_and_span {
+                    diag.span_note(span, note);
+                }
+            });
         }
     }
 }
diff --git a/clippy_utils/src/higher.rs b/clippy_utils/src/higher.rs
index a61e4c38088..e6dc81127dd 100644
--- a/clippy_utils/src/higher.rs
+++ b/clippy_utils/src/higher.rs
@@ -138,6 +138,7 @@ impl<'hir> IfLet<'hir> {
 }
 
 /// An `if let` or `match` expression. Useful for lints that trigger on one or the other.
+#[derive(Debug)]
 pub enum IfLetOrMatch<'hir> {
     /// Any `match` expression
     Match(&'hir Expr<'hir>, &'hir [Arm<'hir>], MatchSource),
diff --git a/tests/ui/manual_filter_map.fixed b/tests/ui/manual_filter_map.fixed
index 9dd376df2b4..35872a39a71 100644
--- a/tests/ui/manual_filter_map.fixed
+++ b/tests/ui/manual_filter_map.fixed
@@ -120,3 +120,27 @@ fn issue_8920() {
         .iter()
         .filter_map(|f| f.result_field.to_owned().ok());
 }
+
+fn issue8010() {
+    #[derive(Clone)]
+    enum Enum {
+        A(i32),
+        B,
+    }
+
+    let iter = [Enum::A(123), Enum::B].into_iter();
+
+    let _x = iter.clone().filter_map(|x| match x { Enum::A(s) => Some(s), _ => None });
+    let _x = iter.clone().filter(|x| matches!(x, Enum::B)).map(|x| match x {
+        Enum::A(s) => s,
+        _ => unreachable!(),
+    });
+    let _x = iter
+        .clone()
+        .filter_map(|x| match x { Enum::A(s) => Some(s), _ => None });
+    #[allow(clippy::unused_unit)]
+    let _x = iter
+        .clone()
+        .filter(|x| matches!(x, Enum::B))
+        .map(|x| if let Enum::B = x { () } else { unreachable!() });
+}
diff --git a/tests/ui/manual_filter_map.rs b/tests/ui/manual_filter_map.rs
index 6dd1e066aeb..50d8d2722c2 100644
--- a/tests/ui/manual_filter_map.rs
+++ b/tests/ui/manual_filter_map.rs
@@ -133,3 +133,31 @@ fn issue_8920() {
         .filter(|f| f.result_field.is_ok())
         .map(|f| f.result_field.to_owned().unwrap());
 }
+
+fn issue8010() {
+    #[derive(Clone)]
+    enum Enum {
+        A(i32),
+        B,
+    }
+
+    let iter = [Enum::A(123), Enum::B].into_iter();
+
+    let _x = iter.clone().filter(|x| matches!(x, Enum::A(_))).map(|x| match x {
+        Enum::A(s) => s,
+        _ => unreachable!(),
+    });
+    let _x = iter.clone().filter(|x| matches!(x, Enum::B)).map(|x| match x {
+        Enum::A(s) => s,
+        _ => unreachable!(),
+    });
+    let _x = iter
+        .clone()
+        .filter(|x| matches!(x, Enum::A(_)))
+        .map(|x| if let Enum::A(s) = x { s } else { unreachable!() });
+    #[allow(clippy::unused_unit)]
+    let _x = iter
+        .clone()
+        .filter(|x| matches!(x, Enum::B))
+        .map(|x| if let Enum::B = x { () } else { unreachable!() });
+}
diff --git a/tests/ui/manual_filter_map.stderr b/tests/ui/manual_filter_map.stderr
index 882468b0f5f..0e8672c0293 100644
--- a/tests/ui/manual_filter_map.stderr
+++ b/tests/ui/manual_filter_map.stderr
@@ -4,6 +4,11 @@ error: `filter(..).map(..)` can be simplified as `filter_map(..)`
 LL |     let _ = (0..).filter(|n| to_opt(*n).is_some()).map(|a| to_opt(a).unwrap());
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `filter_map(|a| to_opt(a))`
    |
+note: the suggestion might change the behavior of the program when merging `filter` and `map`, because this expression potentially contains side effects and will only execute once
+  --> $DIR/manual_filter_map.rs:9:30
+   |
+LL |     let _ = (0..).filter(|n| to_opt(*n).is_some()).map(|a| to_opt(a).unwrap());
+   |                              ^^^^^^^^^^
    = note: `-D clippy::manual-filter-map` implied by `-D warnings`
 
 error: `filter(..).map(..)` can be simplified as `filter_map(..)`
@@ -11,12 +16,24 @@ error: `filter(..).map(..)` can be simplified as `filter_map(..)`
    |
 LL |     let _ = (0..).filter(|&n| to_opt(n).is_some()).map(|a| to_opt(a).expect("hi"));
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `filter_map(|a| to_opt(a))`
+   |
+note: the suggestion might change the behavior of the program when merging `filter` and `map`, because this expression potentially contains side effects and will only execute once
+  --> $DIR/manual_filter_map.rs:12:31
+   |
+LL |     let _ = (0..).filter(|&n| to_opt(n).is_some()).map(|a| to_opt(a).expect("hi"));
+   |                               ^^^^^^^^^
 
 error: `filter(..).map(..)` can be simplified as `filter_map(..)`
   --> $DIR/manual_filter_map.rs:15:19
    |
 LL |     let _ = (0..).filter(|&n| to_res(n).is_ok()).map(|a| to_res(a).unwrap_or(1));
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `filter_map(|a| to_res(a).ok())`
+   |
+note: the suggestion might change the behavior of the program when merging `filter` and `map`, because this expression potentially contains side effects and will only execute once
+  --> $DIR/manual_filter_map.rs:15:31
+   |
+LL |     let _ = (0..).filter(|&n| to_res(n).is_ok()).map(|a| to_res(a).unwrap_or(1));
+   |                               ^^^^^^^^^
 
 error: `filter(..).map(..)` can be simplified as `filter_map(..)`
   --> $DIR/manual_filter_map.rs:18:10
@@ -25,6 +42,12 @@ LL |           .filter(|&x| to_ref(to_opt(x)).is_some())
    |  __________^
 LL | |         .map(|y| to_ref(to_opt(y)).unwrap());
    | |____________________________________________^ help: try: `filter_map(|y| *to_ref(to_opt(y)))`
+   |
+note: the suggestion might change the behavior of the program when merging `filter` and `map`, because this expression potentially contains side effects and will only execute once
+  --> $DIR/manual_filter_map.rs:18:22
+   |
+LL |         .filter(|&x| to_ref(to_opt(x)).is_some())
+   |                      ^^^^^^^^^^^^^^^^^
 
 error: `filter(..).map(..)` can be simplified as `filter_map(..)`
   --> $DIR/manual_filter_map.rs:21:10
@@ -33,6 +56,12 @@ LL |           .filter(|x| to_ref(to_opt(*x)).is_some())
    |  __________^
 LL | |         .map(|y| to_ref(to_opt(y)).unwrap());
    | |____________________________________________^ help: try: `filter_map(|y| *to_ref(to_opt(y)))`
+   |
+note: the suggestion might change the behavior of the program when merging `filter` and `map`, because this expression potentially contains side effects and will only execute once
+  --> $DIR/manual_filter_map.rs:21:21
+   |
+LL |         .filter(|x| to_ref(to_opt(*x)).is_some())
+   |                     ^^^^^^^^^^^^^^^^^^
 
 error: `filter(..).map(..)` can be simplified as `filter_map(..)`
   --> $DIR/manual_filter_map.rs:25:10
@@ -41,6 +70,12 @@ LL |           .filter(|&x| to_ref(to_res(x)).is_ok())
    |  __________^
 LL | |         .map(|y| to_ref(to_res(y)).unwrap());
    | |____________________________________________^ help: try: `filter_map(|y| to_ref(to_res(y)).ok())`
+   |
+note: the suggestion might change the behavior of the program when merging `filter` and `map`, because this expression potentially contains side effects and will only execute once
+  --> $DIR/manual_filter_map.rs:25:22
+   |
+LL |         .filter(|&x| to_ref(to_res(x)).is_ok())
+   |                      ^^^^^^^^^^^^^^^^^
 
 error: `filter(..).map(..)` can be simplified as `filter_map(..)`
   --> $DIR/manual_filter_map.rs:28:10
@@ -49,6 +84,12 @@ LL |           .filter(|x| to_ref(to_res(*x)).is_ok())
    |  __________^
 LL | |         .map(|y| to_ref(to_res(y)).unwrap());
    | |____________________________________________^ help: try: `filter_map(|y| to_ref(to_res(y)).ok())`
+   |
+note: the suggestion might change the behavior of the program when merging `filter` and `map`, because this expression potentially contains side effects and will only execute once
+  --> $DIR/manual_filter_map.rs:28:21
+   |
+LL |         .filter(|x| to_ref(to_res(*x)).is_ok())
+   |                     ^^^^^^^^^^^^^^^^^^
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
   --> $DIR/manual_filter_map.rs:34:27
@@ -75,6 +116,12 @@ error: `find(..).map(..)` can be simplified as `find_map(..)`
    |
 LL |     iter::<Option<&String>>().find(|&x| to_ref(x).is_some()).map(|y| to_ref(y).cloned().unwrap());
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|y| to_ref(y).cloned())`
+   |
+note: the suggestion might change the behavior of the program when merging `filter` and `map`, because this expression potentially contains side effects and will only execute once
+  --> $DIR/manual_filter_map.rs:37:41
+   |
+LL |     iter::<Option<&String>>().find(|&x| to_ref(x).is_some()).map(|y| to_ref(y).cloned().unwrap());
+   |                                         ^^^^^^^^^
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
   --> $DIR/manual_filter_map.rs:39:30
@@ -117,6 +164,12 @@ error: `find(..).map(..)` can be simplified as `find_map(..)`
    |
 LL |     iter::<Result<&String, ()>>().find(|&x| to_ref(x).is_ok()).map(|y| to_ref(y).cloned().unwrap());
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|y| to_ref(y).cloned().ok())`
+   |
+note: the suggestion might change the behavior of the program when merging `filter` and `map`, because this expression potentially contains side effects and will only execute once
+  --> $DIR/manual_filter_map.rs:45:45
+   |
+LL |     iter::<Result<&String, ()>>().find(|&x| to_ref(x).is_ok()).map(|y| to_ref(y).cloned().unwrap());
+   |                                             ^^^^^^^^^
 
 error: `filter(..).map(..)` can be simplified as `filter_map(..)`
   --> $DIR/manual_filter_map.rs:93:10
@@ -190,5 +243,23 @@ LL |           .filter(|f| f.result_field.is_ok())
 LL | |         .map(|f| f.result_field.to_owned().unwrap());
    | |____________________________________________________^ help: try: `filter_map(|f| f.result_field.to_owned().ok())`
 
-error: aborting due to 27 previous errors
+error: `filter(..).map(..)` can be simplified as `filter_map(..)`
+  --> $DIR/manual_filter_map.rs:146:27
+   |
+LL |       let _x = iter.clone().filter(|x| matches!(x, Enum::A(_))).map(|x| match x {
+   |  ___________________________^
+LL | |         Enum::A(s) => s,
+LL | |         _ => unreachable!(),
+LL | |     });
+   | |______^ help: try: `filter_map(|x| match x { Enum::A(s) => Some(s), _ => None })`
+
+error: `filter(..).map(..)` can be simplified as `filter_map(..)`
+  --> $DIR/manual_filter_map.rs:156:10
+   |
+LL |           .filter(|x| matches!(x, Enum::A(_)))
+   |  __________^
+LL | |         .map(|x| if let Enum::A(s) = x { s } else { unreachable!() });
+   | |_____________________________________________________________________^ help: try: `filter_map(|x| match x { Enum::A(s) => Some(s), _ => None })`
+
+error: aborting due to 29 previous errors
 
diff --git a/tests/ui/manual_find_map.stderr b/tests/ui/manual_find_map.stderr
index 693a06bb559..4e52b5efacf 100644
--- a/tests/ui/manual_find_map.stderr
+++ b/tests/ui/manual_find_map.stderr
@@ -4,6 +4,11 @@ error: `find(..).map(..)` can be simplified as `find_map(..)`
 LL |     let _ = (0..).find(|n| to_opt(*n).is_some()).map(|a| to_opt(a).unwrap());
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|a| to_opt(a))`
    |
+note: the suggestion might change the behavior of the program when merging `filter` and `map`, because this expression potentially contains side effects and will only execute once
+  --> $DIR/manual_find_map.rs:9:28
+   |
+LL |     let _ = (0..).find(|n| to_opt(*n).is_some()).map(|a| to_opt(a).unwrap());
+   |                            ^^^^^^^^^^
    = note: `-D clippy::manual-find-map` implied by `-D warnings`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
@@ -11,12 +16,24 @@ error: `find(..).map(..)` can be simplified as `find_map(..)`
    |
 LL |     let _ = (0..).find(|&n| to_opt(n).is_some()).map(|a| to_opt(a).expect("hi"));
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|a| to_opt(a))`
+   |
+note: the suggestion might change the behavior of the program when merging `filter` and `map`, because this expression potentially contains side effects and will only execute once
+  --> $DIR/manual_find_map.rs:12:29
+   |
+LL |     let _ = (0..).find(|&n| to_opt(n).is_some()).map(|a| to_opt(a).expect("hi"));
+   |                             ^^^^^^^^^
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
   --> $DIR/manual_find_map.rs:15:19
    |
 LL |     let _ = (0..).find(|&n| to_res(n).is_ok()).map(|a| to_res(a).unwrap_or(1));
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|a| to_res(a).ok())`
+   |
+note: the suggestion might change the behavior of the program when merging `filter` and `map`, because this expression potentially contains side effects and will only execute once
+  --> $DIR/manual_find_map.rs:15:29
+   |
+LL |     let _ = (0..).find(|&n| to_res(n).is_ok()).map(|a| to_res(a).unwrap_or(1));
+   |                             ^^^^^^^^^
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
   --> $DIR/manual_find_map.rs:18:10
@@ -25,6 +42,12 @@ LL |           .find(|&x| to_ref(to_opt(x)).is_some())
    |  __________^
 LL | |         .map(|y| to_ref(to_opt(y)).unwrap());
    | |____________________________________________^ help: try: `find_map(|y| *to_ref(to_opt(y)))`
+   |
+note: the suggestion might change the behavior of the program when merging `filter` and `map`, because this expression potentially contains side effects and will only execute once
+  --> $DIR/manual_find_map.rs:18:20
+   |
+LL |         .find(|&x| to_ref(to_opt(x)).is_some())
+   |                    ^^^^^^^^^^^^^^^^^
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
   --> $DIR/manual_find_map.rs:21:10
@@ -33,6 +56,12 @@ LL |           .find(|x| to_ref(to_opt(*x)).is_some())
    |  __________^
 LL | |         .map(|y| to_ref(to_opt(y)).unwrap());
    | |____________________________________________^ help: try: `find_map(|y| *to_ref(to_opt(y)))`
+   |
+note: the suggestion might change the behavior of the program when merging `filter` and `map`, because this expression potentially contains side effects and will only execute once
+  --> $DIR/manual_find_map.rs:21:19
+   |
+LL |         .find(|x| to_ref(to_opt(*x)).is_some())
+   |                   ^^^^^^^^^^^^^^^^^^
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
   --> $DIR/manual_find_map.rs:25:10
@@ -41,6 +70,12 @@ LL |           .find(|&x| to_ref(to_res(x)).is_ok())
    |  __________^
 LL | |         .map(|y| to_ref(to_res(y)).unwrap());
    | |____________________________________________^ help: try: `find_map(|y| to_ref(to_res(y)).ok())`
+   |
+note: the suggestion might change the behavior of the program when merging `filter` and `map`, because this expression potentially contains side effects and will only execute once
+  --> $DIR/manual_find_map.rs:25:20
+   |
+LL |         .find(|&x| to_ref(to_res(x)).is_ok())
+   |                    ^^^^^^^^^^^^^^^^^
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
   --> $DIR/manual_find_map.rs:28:10
@@ -49,6 +84,12 @@ LL |           .find(|x| to_ref(to_res(*x)).is_ok())
    |  __________^
 LL | |         .map(|y| to_ref(to_res(y)).unwrap());
    | |____________________________________________^ help: try: `find_map(|y| to_ref(to_res(y)).ok())`
+   |
+note: the suggestion might change the behavior of the program when merging `filter` and `map`, because this expression potentially contains side effects and will only execute once
+  --> $DIR/manual_find_map.rs:28:19
+   |
+LL |         .find(|x| to_ref(to_res(*x)).is_ok())
+   |                   ^^^^^^^^^^^^^^^^^^
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
   --> $DIR/manual_find_map.rs:34:26
@@ -91,6 +132,12 @@ error: `find(..).map(..)` can be simplified as `find_map(..)`
    |
 LL |     iter::<Option<&String>>().find(|&x| to_ref(x).is_some()).map(|y| to_ref(y).cloned().unwrap());
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|y| to_ref(y).cloned())`
+   |
+note: the suggestion might change the behavior of the program when merging `filter` and `map`, because this expression potentially contains side effects and will only execute once
+  --> $DIR/manual_find_map.rs:40:41
+   |
+LL |     iter::<Option<&String>>().find(|&x| to_ref(x).is_some()).map(|y| to_ref(y).cloned().unwrap());
+   |                                         ^^^^^^^^^
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
   --> $DIR/manual_find_map.rs:42:30
@@ -133,6 +180,12 @@ error: `find(..).map(..)` can be simplified as `find_map(..)`
    |
 LL |     iter::<Result<&String, ()>>().find(|&x| to_ref(x).is_ok()).map(|y| to_ref(y).cloned().unwrap());
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|y| to_ref(y).cloned().ok())`
+   |
+note: the suggestion might change the behavior of the program when merging `filter` and `map`, because this expression potentially contains side effects and will only execute once
+  --> $DIR/manual_find_map.rs:48:45
+   |
+LL |     iter::<Result<&String, ()>>().find(|&x| to_ref(x).is_ok()).map(|y| to_ref(y).cloned().unwrap());
+   |                                             ^^^^^^^^^
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
   --> $DIR/manual_find_map.rs:96:10
-- 
cgit 1.4.1-3-g733a5


From 86391abc704555610af8ba33d910bdd16a877ddb Mon Sep 17 00:00:00 2001
From: est31 <MTest31@outlook.com>
Date: Sun, 11 Jun 2023 06:35:29 +0200
Subject: Don't lint manual_let_else in cases where the question mark operator
 would work

Also, lint question_mark for `let...else` clauses that can be simplified to use `?`.
This lint isn't perfect as it doesn't support the unstable try blocks.
---
 clippy_lints/src/manual_let_else.rs           | 48 ++++++++++++++++++++-
 clippy_lints/src/question_mark.rs             | 33 ++++++++++++++-
 tests/ui/manual_let_else_question_mark.fixed  | 56 ++++++++++++++++++++++++
 tests/ui/manual_let_else_question_mark.rs     | 61 +++++++++++++++++++++++++++
 tests/ui/manual_let_else_question_mark.stderr | 49 +++++++++++++++++++++
 5 files changed, 245 insertions(+), 2 deletions(-)
 create mode 100644 tests/ui/manual_let_else_question_mark.fixed
 create mode 100644 tests/ui/manual_let_else_question_mark.rs
 create mode 100644 tests/ui/manual_let_else_question_mark.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_let_else.rs b/clippy_lints/src/manual_let_else.rs
index 59e421c1622..dcfc365a348 100644
--- a/clippy_lints/src/manual_let_else.rs
+++ b/clippy_lints/src/manual_let_else.rs
@@ -1,14 +1,15 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::higher::IfLetOrMatch;
 use clippy_utils::msrvs::{self, Msrv};
-use clippy_utils::peel_blocks;
 use clippy_utils::source::snippet_with_context;
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::visitors::{Descend, Visitable};
+use clippy_utils::{is_refutable, is_res_lang_ctor, peel_blocks};
 use if_chain::if_chain;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_expr, Visitor};
+use rustc_hir::LangItem::{OptionNone, OptionSome};
 use rustc_hir::{Expr, ExprKind, HirId, ItemId, Local, MatchSource, Pat, PatKind, QPath, Stmt, StmtKind, Ty};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
@@ -85,6 +86,7 @@ impl<'tcx> LateLintPass<'tcx> for ManualLetElse {
                     if let Some(ident_map) = expr_simple_identity_map(local.pat, let_pat, if_then);
                     if let Some(if_else) = if_else;
                     if expr_diverges(cx, if_else);
+                    if pat_and_expr_can_be_question_mark(cx, let_pat, if_else).is_none();
                     then {
                         emit_manual_let_else(cx, stmt.span, if_let_expr, &ident_map, let_pat, if_else);
                     }
@@ -167,6 +169,50 @@ fn emit_manual_let_else(
     );
 }
 
+/// Returns whether the given let pattern and else body can be turned into a question mark
+///
+/// For this example:
+/// ```ignore
+/// let FooBar { a, b } = if let Some(a) = ex { a } else { return None };
+/// ```
+/// We get as parameters:
+/// ```ignore
+/// pat: Some(a)
+/// else_body: return None
+/// ```
+
+/// And for this example:
+/// ```ignore
+/// let Some(FooBar { a, b }) = ex else { return None };
+/// ```
+/// We get as parameters:
+/// ```ignore
+/// pat: Some(FooBar { a, b })
+/// else_body: return None
+/// ```
+
+/// We output `Some(a)` in the first instance, and `Some(FooBar { a, b })` in the second, because
+/// the question mark operator is applicable here. Callers have to check whether we are in a
+/// constant or not.
+pub fn pat_and_expr_can_be_question_mark<'a, 'hir>(
+    cx: &LateContext<'_>,
+    pat: &'a Pat<'hir>,
+    else_body: &Expr<'_>,
+) -> Option<&'a Pat<'hir>> {
+    if let PatKind::TupleStruct(pat_path, [inner_pat], _) = pat.kind &&
+        is_res_lang_ctor(cx, cx.qpath_res(&pat_path, pat.hir_id), OptionSome) &&
+        !is_refutable(cx, inner_pat) &&
+        let else_body = peel_blocks(else_body) &&
+        let ExprKind::Ret(Some(ret_val)) = else_body.kind &&
+        let ExprKind::Path(ret_path) = ret_val.kind &&
+        is_res_lang_ctor(cx, cx.qpath_res(&ret_path, ret_val.hir_id), OptionNone)
+    {
+        Some(inner_pat)
+    } else {
+        None
+    }
+}
+
 /// Replaces the locals in the pattern
 ///
 /// For this example:
diff --git a/clippy_lints/src/question_mark.rs b/clippy_lints/src/question_mark.rs
index e3d940ad2a4..b1eeedc26bd 100644
--- a/clippy_lints/src/question_mark.rs
+++ b/clippy_lints/src/question_mark.rs
@@ -1,3 +1,4 @@
+use crate::manual_let_else::pat_and_expr_can_be_question_mark;
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::is_type_diagnostic_item;
@@ -10,7 +11,9 @@ use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::def::Res;
 use rustc_hir::LangItem::{self, OptionNone, OptionSome, ResultErr, ResultOk};
-use rustc_hir::{BindingAnnotation, ByRef, Expr, ExprKind, Node, PatKind, PathSegment, QPath};
+use rustc_hir::{
+    BindingAnnotation, Block, ByRef, Expr, ExprKind, Local, Node, PatKind, PathSegment, QPath, Stmt, StmtKind,
+};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::Ty;
 use rustc_session::declare_tool_lint;
@@ -78,6 +81,29 @@ enum IfBlockType<'hir> {
     ),
 }
 
+fn check_let_some_else_return_none(cx: &LateContext<'_>, stmt: &Stmt<'_>) {
+    if let StmtKind::Local(Local { pat, init: Some(init_expr), els: Some(els), .. }) = stmt.kind &&
+        let Block { stmts: &[], expr: Some(els), .. } = els &&
+        let Some(inner_pat) = pat_and_expr_can_be_question_mark(cx, pat, els)
+    {
+        let mut applicability = Applicability::MaybeIncorrect;
+        let init_expr_str = snippet_with_applicability(cx, init_expr.span, "..", &mut applicability);
+        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,
+            stmt.span,
+            "this `let...else` may be rewritten with the `?` operator",
+            "replace it with",
+            sugg,
+            applicability,
+        );
+    }
+}
+
 fn is_early_return(smbl: Symbol, cx: &LateContext<'_>, if_block: &IfBlockType<'_>) -> bool {
     match *if_block {
         IfBlockType::IfIs(caller, caller_ty, call_sym, if_then, _) => {
@@ -259,6 +285,11 @@ fn is_try_block(cx: &LateContext<'_>, bl: &rustc_hir::Block<'_>) -> bool {
 }
 
 impl<'tcx> LateLintPass<'tcx> for QuestionMark {
+    fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) {
+        if !in_constant(cx, stmt.hir_id) {
+            check_let_some_else_return_none(cx, stmt);
+        }
+    }
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if !in_constant(cx, expr.hir_id) {
             self.check_is_none_or_err_and_early_return(cx, expr);
diff --git a/tests/ui/manual_let_else_question_mark.fixed b/tests/ui/manual_let_else_question_mark.fixed
new file mode 100644
index 00000000000..617f127b9a8
--- /dev/null
+++ b/tests/ui/manual_let_else_question_mark.fixed
@@ -0,0 +1,56 @@
+//@run-rustfix
+#![allow(unused_braces, unused_variables, dead_code)]
+#![allow(
+    clippy::collapsible_else_if,
+    clippy::unused_unit,
+    clippy::let_unit_value,
+    clippy::match_single_binding,
+    clippy::never_loop
+)]
+#![warn(clippy::manual_let_else, clippy::question_mark)]
+
+enum Variant {
+    A(usize, usize),
+    B(usize),
+    C,
+}
+
+fn g() -> Option<(u8, u8)> {
+    None
+}
+
+fn e() -> Variant {
+    Variant::A(0, 0)
+}
+
+fn main() {}
+
+fn foo() -> Option<()> {
+    // Fire here, normal case
+    let v = g()?;
+
+    // Don't fire here, the pattern is refutable
+    let Variant::A(v, w) = e() else { return None };
+
+    // Fire here, the pattern is irrefutable
+    let (v, w) = g()?;
+
+    // Don't fire manual_let_else in this instance: question mark can be used instead.
+    let v = g()?;
+
+    // Do fire manual_let_else in this instance: question mark cannot be used here due to the return
+    // body.
+    let Some(v) = g() else {
+        return Some(());
+    };
+
+    // Here we could also fire the question_mark lint, but we don't (as it's a match and not an if let).
+    // So we still emit manual_let_else here. For the *resulting* code, we *do* emit the question_mark
+    // lint, so for rustfix reasons, we allow the question_mark lint here.
+    #[allow(clippy::question_mark)]
+    {
+        let Some(v) = g() else { return None };
+    }
+
+    Some(())
+}
diff --git a/tests/ui/manual_let_else_question_mark.rs b/tests/ui/manual_let_else_question_mark.rs
new file mode 100644
index 00000000000..3cf1eca8673
--- /dev/null
+++ b/tests/ui/manual_let_else_question_mark.rs
@@ -0,0 +1,61 @@
+//@run-rustfix
+#![allow(unused_braces, unused_variables, dead_code)]
+#![allow(
+    clippy::collapsible_else_if,
+    clippy::unused_unit,
+    clippy::let_unit_value,
+    clippy::match_single_binding,
+    clippy::never_loop
+)]
+#![warn(clippy::manual_let_else, clippy::question_mark)]
+
+enum Variant {
+    A(usize, usize),
+    B(usize),
+    C,
+}
+
+fn g() -> Option<(u8, u8)> {
+    None
+}
+
+fn e() -> Variant {
+    Variant::A(0, 0)
+}
+
+fn main() {}
+
+fn foo() -> Option<()> {
+    // Fire here, normal case
+    let Some(v) = g() else { return None };
+
+    // Don't fire here, the pattern is refutable
+    let Variant::A(v, w) = e() else { return None };
+
+    // Fire here, the pattern is irrefutable
+    let Some((v, w)) = g() else { return None };
+
+    // Don't fire manual_let_else in this instance: question mark can be used instead.
+    let v = if let Some(v_some) = g() { v_some } else { return None };
+
+    // Do fire manual_let_else in this instance: question mark cannot be used here due to the return
+    // body.
+    let v = if let Some(v_some) = g() {
+        v_some
+    } else {
+        return Some(());
+    };
+
+    // Here we could also fire the question_mark lint, but we don't (as it's a match and not an if let).
+    // So we still emit manual_let_else here. For the *resulting* code, we *do* emit the question_mark
+    // lint, so for rustfix reasons, we allow the question_mark lint here.
+    #[allow(clippy::question_mark)]
+    {
+        let v = match g() {
+            Some(v_some) => v_some,
+            _ => return None,
+        };
+    }
+
+    Some(())
+}
diff --git a/tests/ui/manual_let_else_question_mark.stderr b/tests/ui/manual_let_else_question_mark.stderr
new file mode 100644
index 00000000000..31052acf75c
--- /dev/null
+++ b/tests/ui/manual_let_else_question_mark.stderr
@@ -0,0 +1,49 @@
+error: this `let...else` may be rewritten with the `?` operator
+  --> $DIR/manual_let_else_question_mark.rs:30:5
+   |
+LL |     let Some(v) = g() else { return None };
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `let v = g()?;`
+   |
+   = note: `-D clippy::question-mark` implied by `-D warnings`
+
+error: this `let...else` may be rewritten with the `?` operator
+  --> $DIR/manual_let_else_question_mark.rs:36:5
+   |
+LL |     let Some((v, w)) = g() else { return None };
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `let (v, w) = g()?;`
+
+error: this block may be rewritten with the `?` operator
+  --> $DIR/manual_let_else_question_mark.rs:39:13
+   |
+LL |     let v = if let Some(v_some) = g() { v_some } else { return None };
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `g()?`
+
+error: this could be rewritten as `let...else`
+  --> $DIR/manual_let_else_question_mark.rs:43:5
+   |
+LL | /     let v = if let Some(v_some) = g() {
+LL | |         v_some
+LL | |     } else {
+LL | |         return Some(());
+LL | |     };
+   | |______^
+   |
+   = note: `-D clippy::manual-let-else` implied by `-D warnings`
+help: consider writing
+   |
+LL ~     let Some(v) = g() else {
+LL +         return Some(());
+LL +     };
+   |
+
+error: this could be rewritten as `let...else`
+  --> $DIR/manual_let_else_question_mark.rs:54:9
+   |
+LL | /         let v = match g() {
+LL | |             Some(v_some) => v_some,
+LL | |             _ => return None,
+LL | |         };
+   | |__________^ help: consider writing: `let Some(v) = g() else { return None };`
+
+error: aborting due to 5 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From c6be62159ff6c100786a86b6a5687ded883ace5f Mon Sep 17 00:00:00 2001
From: est31 <MTest31@outlook.com>
Date: Sun, 11 Jun 2023 07:11:47 +0200
Subject: Fix the now stricter lint in manual_rem_euclid.rs

---
 clippy_lints/src/manual_rem_euclid.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_rem_euclid.rs b/clippy_lints/src/manual_rem_euclid.rs
index aafee92713f..0e89ca132ef 100644
--- a/clippy_lints/src/manual_rem_euclid.rs
+++ b/clippy_lints/src/manual_rem_euclid.rs
@@ -119,7 +119,7 @@ fn check_for_either_unsigned_int_constant<'a>(
 }
 
 fn check_for_unsigned_int_constant<'a>(cx: &'a LateContext<'_>, expr: &'a Expr<'_>) -> Option<u128> {
-    let Some(int_const) = constant_full_int(cx, cx.typeck_results(), expr) else { return None };
+    let int_const = constant_full_int(cx, cx.typeck_results(), expr)?;
     match int_const {
         FullInt::S(s) => s.try_into().ok(),
         FullInt::U(u) => Some(u),
-- 
cgit 1.4.1-3-g733a5


From efac83813dda709a835764bcaeb66697becedfe6 Mon Sep 17 00:00:00 2001
From: Catherine <114838443+Centri3@users.noreply.github.com>
Date: Fri, 30 Jun 2023 11:39:33 -0500
Subject: Make `eq_op` suggest `.is_nan()`

---
 clippy_lints/src/operators/eq_op.rs |  9 ++++--
 tests/ui/eq_op.rs                   |  2 ++
 tests/ui/eq_op.stderr               | 56 +++++++++++++++++++++----------------
 3 files changed, 41 insertions(+), 26 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/operators/eq_op.rs b/clippy_lints/src/operators/eq_op.rs
index 67913f7392c..78965b7d6f7 100644
--- a/clippy_lints/src/operators/eq_op.rs
+++ b/clippy_lints/src/operators/eq_op.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint;
+use clippy_utils::diagnostics::{span_lint, span_lint_and_then};
 use clippy_utils::macros::{find_assert_eq_args, first_node_macro_backtrace};
 use clippy_utils::{ast_utils::is_useless_with_eq_exprs, eq_expr_value, is_in_test_function};
 use rustc_hir::{BinOpKind, Expr};
@@ -35,11 +35,16 @@ pub(crate) fn check<'tcx>(
     right: &'tcx Expr<'_>,
 ) {
     if is_useless_with_eq_exprs(op.into()) && eq_expr_value(cx, left, right) && !is_in_test_function(cx.tcx, e.hir_id) {
-        span_lint(
+        span_lint_and_then(
             cx,
             EQ_OP,
             e.span,
             &format!("equal expressions as operands to `{}`", op.as_str()),
+            |diag| {
+                if let BinOpKind::Ne = op && cx.typeck_results().expr_ty(left).is_floating_point() {
+                    diag.note("if you intended to check if the operand is NaN, use `.is_nan()` instead");
+                }
+            },
         );
     }
 }
diff --git a/tests/ui/eq_op.rs b/tests/ui/eq_op.rs
index 38372378168..e973e5ba2fb 100644
--- a/tests/ui/eq_op.rs
+++ b/tests/ui/eq_op.rs
@@ -10,6 +10,8 @@ fn main() {
     let _ = false != false;
     let _ = 1.5 < 1.5;
     let _ = 1u64 >= 1u64;
+    let x = f32::NAN;
+    let _ = x != x;
 
     // casts, methods, parentheses
     let _ = (1u32 as u64) & (1u32 as u64);
diff --git a/tests/ui/eq_op.stderr b/tests/ui/eq_op.stderr
index 2c013b6b6fe..c7fa253bdca 100644
--- a/tests/ui/eq_op.stderr
+++ b/tests/ui/eq_op.stderr
@@ -30,143 +30,151 @@ error: equal expressions as operands to `>=`
 LL |     let _ = 1u64 >= 1u64;
    |             ^^^^^^^^^^^^
 
+error: equal expressions as operands to `!=`
+  --> $DIR/eq_op.rs:14:13
+   |
+LL |     let _ = x != x;
+   |             ^^^^^^
+   |
+   = note: if you intended to check if the operand is NaN, use `.is_nan()` instead
+
 error: equal expressions as operands to `&`
-  --> $DIR/eq_op.rs:15:13
+  --> $DIR/eq_op.rs:17:13
    |
 LL |     let _ = (1u32 as u64) & (1u32 as u64);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: equal expressions as operands to `^`
-  --> $DIR/eq_op.rs:18:17
+  --> $DIR/eq_op.rs:20:17
    |
 LL |         let _ = 1 ^ ((((((1))))));
    |                 ^^^^^^^^^^^^^^^^^
 
 error: equal expressions as operands to `<`
-  --> $DIR/eq_op.rs:22:13
+  --> $DIR/eq_op.rs:24:13
    |
 LL |     let _ = (-(2) < -(2));
    |             ^^^^^^^^^^^^^
 
 error: equal expressions as operands to `==`
-  --> $DIR/eq_op.rs:23:13
+  --> $DIR/eq_op.rs:25:13
    |
 LL |     let _ = ((1 + 1) & (1 + 1) == (1 + 1) & (1 + 1));
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: equal expressions as operands to `&`
-  --> $DIR/eq_op.rs:23:14
+  --> $DIR/eq_op.rs:25:14
    |
 LL |     let _ = ((1 + 1) & (1 + 1) == (1 + 1) & (1 + 1));
    |              ^^^^^^^^^^^^^^^^^
 
 error: equal expressions as operands to `&`
-  --> $DIR/eq_op.rs:23:35
+  --> $DIR/eq_op.rs:25:35
    |
 LL |     let _ = ((1 + 1) & (1 + 1) == (1 + 1) & (1 + 1));
    |                                   ^^^^^^^^^^^^^^^^^
 
 error: equal expressions as operands to `==`
-  --> $DIR/eq_op.rs:24:13
+  --> $DIR/eq_op.rs:26:13
    |
 LL |     let _ = (1 * 2) + (3 * 4) == 1 * 2 + 3 * 4;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: equal expressions as operands to `!=`
-  --> $DIR/eq_op.rs:27:13
+  --> $DIR/eq_op.rs:29:13
    |
 LL |     let _ = ([1] != [1]);
    |             ^^^^^^^^^^^^
 
 error: equal expressions as operands to `!=`
-  --> $DIR/eq_op.rs:28:13
+  --> $DIR/eq_op.rs:30:13
    |
 LL |     let _ = ((1, 2) != (1, 2));
    |             ^^^^^^^^^^^^^^^^^^
 
 error: equal expressions as operands to `==`
-  --> $DIR/eq_op.rs:32:13
+  --> $DIR/eq_op.rs:34:13
    |
 LL |     let _ = 1 + 1 == 2;
    |             ^^^^^^^^^^
 
 error: equal expressions as operands to `==`
-  --> $DIR/eq_op.rs:33:13
+  --> $DIR/eq_op.rs:35:13
    |
 LL |     let _ = 1 - 1 == 0;
    |             ^^^^^^^^^^
 
 error: equal expressions as operands to `-`
-  --> $DIR/eq_op.rs:33:13
+  --> $DIR/eq_op.rs:35:13
    |
 LL |     let _ = 1 - 1 == 0;
    |             ^^^^^
 
 error: equal expressions as operands to `-`
-  --> $DIR/eq_op.rs:35:13
+  --> $DIR/eq_op.rs:37:13
    |
 LL |     let _ = 1 - 1;
    |             ^^^^^
 
 error: equal expressions as operands to `/`
-  --> $DIR/eq_op.rs:36:13
+  --> $DIR/eq_op.rs:38:13
    |
 LL |     let _ = 1 / 1;
    |             ^^^^^
 
 error: equal expressions as operands to `&&`
-  --> $DIR/eq_op.rs:37:13
+  --> $DIR/eq_op.rs:39:13
    |
 LL |     let _ = true && true;
    |             ^^^^^^^^^^^^
 
 error: equal expressions as operands to `||`
-  --> $DIR/eq_op.rs:39:13
+  --> $DIR/eq_op.rs:41:13
    |
 LL |     let _ = true || true;
    |             ^^^^^^^^^^^^
 
 error: equal expressions as operands to `&&`
-  --> $DIR/eq_op.rs:44:13
+  --> $DIR/eq_op.rs:46:13
    |
 LL |     let _ = a == b && b == a;
    |             ^^^^^^^^^^^^^^^^
 
 error: equal expressions as operands to `&&`
-  --> $DIR/eq_op.rs:45:13
+  --> $DIR/eq_op.rs:47:13
    |
 LL |     let _ = a != b && b != a;
    |             ^^^^^^^^^^^^^^^^
 
 error: equal expressions as operands to `&&`
-  --> $DIR/eq_op.rs:46:13
+  --> $DIR/eq_op.rs:48:13
    |
 LL |     let _ = a < b && b > a;
    |             ^^^^^^^^^^^^^^
 
 error: equal expressions as operands to `&&`
-  --> $DIR/eq_op.rs:47:13
+  --> $DIR/eq_op.rs:49:13
    |
 LL |     let _ = a <= b && b >= a;
    |             ^^^^^^^^^^^^^^^^
 
 error: equal expressions as operands to `==`
-  --> $DIR/eq_op.rs:50:13
+  --> $DIR/eq_op.rs:52:13
    |
 LL |     let _ = a == a;
    |             ^^^^^^
 
 error: equal expressions as operands to `/`
-  --> $DIR/eq_op.rs:60:20
+  --> $DIR/eq_op.rs:62:20
    |
 LL |     const D: u32 = A / A;
    |                    ^^^^^
 
 error: equal expressions as operands to `==`
-  --> $DIR/eq_op.rs:91:5
+  --> $DIR/eq_op.rs:93:5
    |
 LL |     (n1.inner.0).0 == (n1.inner.0).0 && (n1.inner.1).0 == (n2.inner.1).0 && (n1.inner.2).0 == (n2.inner.2).0
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 28 previous errors
+error: aborting due to 29 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 20dfaba0351d81748f2c1bbbb8a5e1d8bd77c3cb Mon Sep 17 00:00:00 2001
From: est31 <MTest31@outlook.com>
Date: Fri, 30 Jun 2023 18:41:10 +0200
Subject: Put into one pass

---
 clippy_lints/src/lib.rs             |  3 +-
 clippy_lints/src/manual_let_else.rs | 77 ++++---------------------------------
 clippy_lints/src/question_mark.rs   | 72 +++++++++++++++++++++++++++++++---
 3 files changed, 74 insertions(+), 78 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 5ab28b5c70c..771f13bda15 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -662,7 +662,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     });
     store.register_late_pass(move |_| Box::new(matches::Matches::new(msrv())));
     let matches_for_let_else = conf.matches_for_let_else;
-    store.register_late_pass(move |_| Box::new(manual_let_else::ManualLetElse::new(msrv(), matches_for_let_else)));
     store.register_early_pass(move || Box::new(manual_non_exhaustive::ManualNonExhaustiveStruct::new(msrv())));
     store.register_late_pass(move |_| Box::new(manual_non_exhaustive::ManualNonExhaustiveEnum::new(msrv())));
     store.register_late_pass(move |_| Box::new(manual_strip::ManualStrip::new(msrv())));
@@ -771,7 +770,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::<useless_conversion::UselessConversion>::default());
     store.register_late_pass(|_| Box::new(implicit_hasher::ImplicitHasher));
     store.register_late_pass(|_| Box::new(fallible_impl_from::FallibleImplFrom));
-    store.register_late_pass(|_| Box::<question_mark::QuestionMark>::default());
+    store.register_late_pass(move |_| Box::new(question_mark::QuestionMark::new(msrv(), matches_for_let_else)));
     store.register_late_pass(|_| Box::new(question_mark_used::QuestionMarkUsed));
     store.register_early_pass(|| Box::new(suspicious_operation_groupings::SuspiciousOperationGroupings));
     store.register_late_pass(|_| Box::new(suspicious_trait_impl::SuspiciousImpl));
diff --git a/clippy_lints/src/manual_let_else.rs b/clippy_lints/src/manual_let_else.rs
index dcfc365a348..363018f1381 100644
--- a/clippy_lints/src/manual_let_else.rs
+++ b/clippy_lints/src/manual_let_else.rs
@@ -1,19 +1,19 @@
+use crate::question_mark::{pat_and_expr_can_be_question_mark, QuestionMark};
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::higher::IfLetOrMatch;
-use clippy_utils::msrvs::{self, Msrv};
+use clippy_utils::msrvs;
+use clippy_utils::peel_blocks;
 use clippy_utils::source::snippet_with_context;
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::visitors::{Descend, Visitable};
-use clippy_utils::{is_refutable, is_res_lang_ctor, peel_blocks};
 use if_chain::if_chain;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_expr, Visitor};
-use rustc_hir::LangItem::{OptionNone, OptionSome};
 use rustc_hir::{Expr, ExprKind, HirId, ItemId, Local, MatchSource, Pat, PatKind, QPath, Stmt, StmtKind, Ty};
-use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_lint::{LateContext, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::declare_tool_lint;
 use rustc_span::symbol::{sym, Symbol};
 use rustc_span::Span;
 use serde::Deserialize;
@@ -51,25 +51,8 @@ declare_clippy_lint! {
     "manual implementation of a let...else statement"
 }
 
-pub struct ManualLetElse {
-    msrv: Msrv,
-    matches_behaviour: MatchLintBehaviour,
-}
-
-impl ManualLetElse {
-    #[must_use]
-    pub fn new(msrv: Msrv, matches_behaviour: MatchLintBehaviour) -> Self {
-        Self {
-            msrv,
-            matches_behaviour,
-        }
-    }
-}
-
-impl_lint_pass!(ManualLetElse => [MANUAL_LET_ELSE]);
-
-impl<'tcx> LateLintPass<'tcx> for ManualLetElse {
-    fn check_stmt(&mut self, cx: &LateContext<'_>, stmt: &'tcx Stmt<'tcx>) {
+impl<'tcx> QuestionMark {
+    pub(crate) fn check_manual_let_else(&mut self, cx: &LateContext<'_>, stmt: &'tcx Stmt<'tcx>) {
         if !self.msrv.meets(msrvs::LET_ELSE) || in_external_macro(cx.sess(), stmt.span) {
             return;
         }
@@ -130,8 +113,6 @@ impl<'tcx> LateLintPass<'tcx> for ManualLetElse {
             }
         };
     }
-
-    extract_msrv_attr!(LateContext);
 }
 
 fn emit_manual_let_else(
@@ -169,50 +150,6 @@ fn emit_manual_let_else(
     );
 }
 
-/// Returns whether the given let pattern and else body can be turned into a question mark
-///
-/// For this example:
-/// ```ignore
-/// let FooBar { a, b } = if let Some(a) = ex { a } else { return None };
-/// ```
-/// We get as parameters:
-/// ```ignore
-/// pat: Some(a)
-/// else_body: return None
-/// ```
-
-/// And for this example:
-/// ```ignore
-/// let Some(FooBar { a, b }) = ex else { return None };
-/// ```
-/// We get as parameters:
-/// ```ignore
-/// pat: Some(FooBar { a, b })
-/// else_body: return None
-/// ```
-
-/// We output `Some(a)` in the first instance, and `Some(FooBar { a, b })` in the second, because
-/// the question mark operator is applicable here. Callers have to check whether we are in a
-/// constant or not.
-pub fn pat_and_expr_can_be_question_mark<'a, 'hir>(
-    cx: &LateContext<'_>,
-    pat: &'a Pat<'hir>,
-    else_body: &Expr<'_>,
-) -> Option<&'a Pat<'hir>> {
-    if let PatKind::TupleStruct(pat_path, [inner_pat], _) = pat.kind &&
-        is_res_lang_ctor(cx, cx.qpath_res(&pat_path, pat.hir_id), OptionSome) &&
-        !is_refutable(cx, inner_pat) &&
-        let else_body = peel_blocks(else_body) &&
-        let ExprKind::Ret(Some(ret_val)) = else_body.kind &&
-        let ExprKind::Path(ret_path) = ret_val.kind &&
-        is_res_lang_ctor(cx, cx.qpath_res(&ret_path, ret_val.hir_id), OptionNone)
-    {
-        Some(inner_pat)
-    } else {
-        None
-    }
-}
-
 /// Replaces the locals in the pattern
 ///
 /// For this example:
diff --git a/clippy_lints/src/question_mark.rs b/clippy_lints/src/question_mark.rs
index b1eeedc26bd..d473b6fd5c4 100644
--- a/clippy_lints/src/question_mark.rs
+++ b/clippy_lints/src/question_mark.rs
@@ -1,10 +1,11 @@
-use crate::manual_let_else::pat_and_expr_can_be_question_mark;
+use crate::manual_let_else::{MatchLintBehaviour, MANUAL_LET_ELSE};
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::msrvs::Msrv;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::{
-    eq_expr_value, get_parent_node, in_constant, is_else_clause, is_res_lang_ctor, path_to_local, path_to_local_id,
-    peel_blocks, peel_blocks_with_stmt,
+    eq_expr_value, get_parent_node, in_constant, is_else_clause, is_refutable, is_res_lang_ctor, path_to_local,
+    path_to_local_id, peel_blocks, peel_blocks_with_stmt,
 };
 use clippy_utils::{higher, is_path_lang_item};
 use if_chain::if_chain;
@@ -12,7 +13,7 @@ use rustc_errors::Applicability;
 use rustc_hir::def::Res;
 use rustc_hir::LangItem::{self, OptionNone, OptionSome, ResultErr, ResultOk};
 use rustc_hir::{
-    BindingAnnotation, Block, ByRef, Expr, ExprKind, Local, Node, PatKind, PathSegment, QPath, Stmt, StmtKind,
+    BindingAnnotation, Block, ByRef, Expr, ExprKind, Local, Node, Pat, PatKind, PathSegment, QPath, Stmt, StmtKind,
 };
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::Ty;
@@ -45,8 +46,9 @@ declare_clippy_lint! {
     "checks for expressions that could be replaced by the question mark operator"
 }
 
-#[derive(Default)]
 pub struct QuestionMark {
+    pub(crate) msrv: Msrv,
+    pub(crate) matches_behaviour: MatchLintBehaviour,
     /// Keeps track of how many try blocks we are in at any point during linting.
     /// This allows us to answer the question "are we inside of a try block"
     /// very quickly, without having to walk up the parent chain, by simply checking
@@ -54,7 +56,19 @@ pub struct QuestionMark {
     /// As for why we need this in the first place: <https://github.com/rust-lang/rust-clippy/issues/8628>
     try_block_depth_stack: Vec<u32>,
 }
-impl_lint_pass!(QuestionMark => [QUESTION_MARK]);
+
+impl_lint_pass!(QuestionMark => [QUESTION_MARK, MANUAL_LET_ELSE]);
+
+impl QuestionMark {
+    #[must_use]
+    pub fn new(msrv: Msrv, matches_behaviour: MatchLintBehaviour) -> Self {
+        Self {
+            msrv,
+            matches_behaviour,
+            try_block_depth_stack: Vec::new(),
+        }
+    }
+}
 
 enum IfBlockType<'hir> {
     /// An `if x.is_xxx() { a } else { b } ` expression.
@@ -81,6 +95,50 @@ enum IfBlockType<'hir> {
     ),
 }
 
+/// Returns whether the given let pattern and else body can be turned into a question mark
+///
+/// For this example:
+/// ```ignore
+/// let FooBar { a, b } = if let Some(a) = ex { a } else { return None };
+/// ```
+/// We get as parameters:
+/// ```ignore
+/// pat: Some(a)
+/// else_body: return None
+/// ```
+
+/// And for this example:
+/// ```ignore
+/// let Some(FooBar { a, b }) = ex else { return None };
+/// ```
+/// We get as parameters:
+/// ```ignore
+/// pat: Some(FooBar { a, b })
+/// else_body: return None
+/// ```
+
+/// We output `Some(a)` in the first instance, and `Some(FooBar { a, b })` in the second, because
+/// the question mark operator is applicable here. Callers have to check whether we are in a
+/// constant or not.
+pub(crate) fn pat_and_expr_can_be_question_mark<'a, 'hir>(
+    cx: &LateContext<'_>,
+    pat: &'a Pat<'hir>,
+    else_body: &Expr<'_>,
+) -> Option<&'a Pat<'hir>> {
+    if let PatKind::TupleStruct(pat_path, [inner_pat], _) = pat.kind &&
+        is_res_lang_ctor(cx, cx.qpath_res(&pat_path, pat.hir_id), OptionSome) &&
+        !is_refutable(cx, inner_pat) &&
+        let else_body = peel_blocks(else_body) &&
+        let ExprKind::Ret(Some(ret_val)) = else_body.kind &&
+        let ExprKind::Path(ret_path) = ret_val.kind &&
+        is_res_lang_ctor(cx, cx.qpath_res(&ret_path, ret_val.hir_id), OptionNone)
+    {
+        Some(inner_pat)
+    } else {
+        None
+    }
+}
+
 fn check_let_some_else_return_none(cx: &LateContext<'_>, stmt: &Stmt<'_>) {
     if let StmtKind::Local(Local { pat, init: Some(init_expr), els: Some(els), .. }) = stmt.kind &&
         let Block { stmts: &[], expr: Some(els), .. } = els &&
@@ -289,6 +347,7 @@ impl<'tcx> LateLintPass<'tcx> for QuestionMark {
         if !in_constant(cx, stmt.hir_id) {
             check_let_some_else_return_none(cx, stmt);
         }
+        self.check_manual_let_else(cx, stmt);
     }
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if !in_constant(cx, expr.hir_id) {
@@ -322,4 +381,5 @@ impl<'tcx> LateLintPass<'tcx> for QuestionMark {
                 .expect("blocks are always part of bodies and must have a depth") -= 1;
         }
     }
+    extract_msrv_attr!(LateContext);
 }
-- 
cgit 1.4.1-3-g733a5


From 420f3d11e8cc0f6353f65f578c21ffef3c369314 Mon Sep 17 00:00:00 2001
From: Samuel Moelius <sam@moeli.us>
Date: Sat, 1 Jul 2023 07:08:01 -0400
Subject: "try this" -> "try"

---
 clippy_lints/src/dereference.rs                    |  8 +--
 clippy_lints/src/entry.rs                          |  2 +-
 clippy_lints/src/explicit_write.rs                 |  2 +-
 clippy_lints/src/init_numbered_fields.rs           |  2 +-
 clippy_lints/src/loops/missing_spin_loop.rs        |  2 +-
 clippy_lints/src/map_unit_fn.rs                    |  6 +-
 .../src/matches/infallible_destructuring_match.rs  |  2 +-
 clippy_lints/src/matches/manual_filter.rs          |  2 +-
 clippy_lints/src/matches/manual_map.rs             |  2 +-
 clippy_lints/src/matches/match_as_ref.rs           |  2 +-
 clippy_lints/src/matches/match_like_matches.rs     |  2 +-
 clippy_lints/src/matches/match_on_vec_items.rs     |  2 +-
 clippy_lints/src/matches/match_wild_enum.rs        |  4 +-
 .../src/matches/redundant_pattern_match.rs         |  4 +-
 clippy_lints/src/matches/single_match.rs           |  2 +-
 clippy_lints/src/matches/try_err.rs                |  2 +-
 clippy_lints/src/methods/bind_instead_of_map.rs    |  4 +-
 clippy_lints/src/methods/clone_on_ref_ptr.rs       |  2 +-
 clippy_lints/src/methods/expect_fun_call.rs        |  4 +-
 clippy_lints/src/methods/extend_with_drain.rs      |  2 +-
 clippy_lints/src/methods/filter_map_next.rs        |  2 +-
 clippy_lints/src/methods/filter_next.rs            |  2 +-
 clippy_lints/src/methods/get_unwrap.rs             |  2 +-
 clippy_lints/src/methods/iter_overeager_cloned.rs  |  2 +-
 clippy_lints/src/methods/iter_with_drain.rs        |  2 +-
 clippy_lints/src/methods/manual_str_repeat.rs      |  2 +-
 .../src/methods/map_collect_result_unit.rs         |  2 +-
 clippy_lints/src/methods/map_unwrap_or.rs          |  2 +-
 .../src/methods/needless_option_as_deref.rs        |  2 +-
 clippy_lints/src/methods/or_fun_call.rs            |  4 +-
 clippy_lints/src/methods/or_then_unwrap.rs         |  2 +-
 clippy_lints/src/methods/str_splitn.rs             |  4 +-
 clippy_lints/src/methods/string_extend_chars.rs    |  2 +-
 clippy_lints/src/methods/useless_asref.rs          |  2 +-
 clippy_lints/src/reference.rs                      |  2 +-
 clippy_lints/src/strlen_on_c_strings.rs            |  2 +-
 clippy_lints/src/to_digit_is_some.rs               |  2 +-
 clippy_lints/src/write.rs                          |  2 +-
 tests/lint_message_convention.rs                   |  6 +-
 .../uninlined_format_args.stderr                   |  2 +-
 tests/ui-toml/unwrap_used/unwrap_used.stderr       | 30 ++++-----
 tests/ui/bind_instead_of_map.stderr                |  2 +-
 tests/ui/bind_instead_of_map_multipart.stderr      | 10 +--
 tests/ui/crashes/ice-7169.stderr                   |  2 +-
 tests/ui/crashes/ice-8250.stderr                   |  2 +-
 tests/ui/deref_addrof.stderr                       | 20 +++---
 tests/ui/deref_addrof_double_trigger.stderr        |  6 +-
 tests/ui/entry.stderr                              | 20 +++---
 tests/ui/entry_btree.stderr                        |  2 +-
 tests/ui/entry_with_else.stderr                    | 14 ++--
 tests/ui/expect_fun_call.stderr                    | 30 ++++-----
 tests/ui/explicit_auto_deref.stderr                | 78 +++++++++++-----------
 tests/ui/explicit_deref_methods.stderr             | 24 +++----
 tests/ui/explicit_write.stderr                     | 26 ++++----
 tests/ui/extend_with_drain.stderr                  |  8 +--
 tests/ui/filter_map_next_fixable.stderr            |  4 +-
 tests/ui/get_unwrap.stderr                         | 34 +++++-----
 tests/ui/infallible_destructuring_match.stderr     |  8 +--
 tests/ui/iter_overeager_cloned.stderr              | 14 ++--
 tests/ui/iter_with_drain.stderr                    | 12 ++--
 tests/ui/manual_filter.stderr                      | 30 ++++-----
 tests/ui/manual_map_option.stderr                  | 42 ++++++------
 tests/ui/manual_map_option_2.stderr                | 10 +--
 tests/ui/manual_split_once.stderr                  | 28 ++++----
 tests/ui/manual_str_repeat.stderr                  | 20 +++---
 tests/ui/map_collect_result_unit.stderr            |  4 +-
 tests/ui/map_unwrap_or.stderr                      |  2 +-
 tests/ui/map_unwrap_or_fixable.stderr              |  4 +-
 tests/ui/match_as_ref.stderr                       |  6 +-
 tests/ui/match_expr_like_matches_macro.stderr      | 28 ++++----
 tests/ui/match_on_vec_items.stderr                 | 16 ++---
 tests/ui/match_ref_pats.stderr                     |  4 +-
 tests/ui/match_same_arms2.stderr                   |  2 +-
 tests/ui/match_wildcard_for_single_variants.stderr | 20 +++---
 tests/ui/methods_fixable.stderr                    |  2 +-
 tests/ui/missing_spin_loop.stderr                  | 12 ++--
 tests/ui/missing_spin_loop_no_std.stderr           |  2 +-
 tests/ui/needless_borrow_pat.stderr                | 24 +++----
 tests/ui/needless_option_as_deref.stderr           |  6 +-
 tests/ui/needless_splitn.stderr                    | 26 ++++----
 tests/ui/numbered_fields.stderr                    |  4 +-
 tests/ui/option_map_unit_fn_fixable.stderr         | 38 +++++------
 tests/ui/or_fun_call.stderr                        | 56 ++++++++--------
 tests/ui/or_then_unwrap.stderr                     |  6 +-
 tests/ui/print_literal.stderr                      | 24 +++----
 .../redundant_pattern_matching_drop_order.stderr   | 44 ++++++------
 tests/ui/redundant_pattern_matching_ipaddr.stderr  | 36 +++++-----
 tests/ui/redundant_pattern_matching_option.stderr  | 56 ++++++++--------
 tests/ui/redundant_pattern_matching_poll.stderr    | 36 +++++-----
 tests/ui/redundant_pattern_matching_result.stderr  | 56 ++++++++--------
 tests/ui/ref_binding_to_reference.stderr           | 14 ++--
 tests/ui/result_map_unit_fn_fixable.stderr         | 36 +++++-----
 tests/ui/result_map_unit_fn_unfixable.stderr       | 12 ++--
 tests/ui/single_match.stderr                       | 36 +++++-----
 tests/ui/single_match_else.stderr                  | 18 ++---
 tests/ui/string_extend.stderr                      |  8 +--
 tests/ui/strlen_on_c_strings.stderr                | 14 ++--
 tests/ui/to_digit_is_some.stderr                   |  4 +-
 tests/ui/try_err.stderr                            | 22 +++---
 tests/ui/unnecessary_clone.stderr                  | 12 ++--
 tests/ui/unwrap_or.stderr                          |  4 +-
 tests/ui/useless_asref.stderr                      | 22 +++---
 tests/ui/wildcard_enum_match_arm.stderr            | 12 ++--
 tests/ui/write_literal.stderr                      | 24 +++----
 tests/ui/write_literal_2.stderr                    | 28 ++++----
 105 files changed, 682 insertions(+), 680 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index 73556c1053e..20378849c22 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -589,7 +589,7 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing<'tcx> {
                     pat.spans,
                     "this pattern creates a reference to a reference",
                     |diag| {
-                        diag.multipart_suggestion("try this", replacements, app);
+                        diag.multipart_suggestion("try", replacements, app);
                     },
                 );
             }
@@ -1531,7 +1531,7 @@ fn report<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, state: State, data
                     Mutability::Not => "explicit `deref` method call",
                     Mutability::Mut => "explicit `deref_mut` method call",
                 },
-                "try this",
+                "try",
                 format!("{addr_of_str}{deref_str}{expr_str}"),
                 app,
             );
@@ -1593,7 +1593,7 @@ fn report<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, state: State, data
                         } else {
                             format!("{prefix}{snip}")
                         };
-                    diag.span_suggestion(data.span, "try this", sugg, app);
+                    diag.span_suggestion(data.span, "try", sugg, app);
                 },
             );
         },
@@ -1620,7 +1620,7 @@ fn report<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, state: State, data
                 |diag| {
                     let mut app = Applicability::MachineApplicable;
                     let snip = snippet_with_context(cx, expr.span, data.span.ctxt(), "..", &mut app).0;
-                    diag.span_suggestion(data.span, "try this", snip.into_owned(), app);
+                    diag.span_suggestion(data.span, "try", snip.into_owned(), app);
                 },
             );
         },
diff --git a/clippy_lints/src/entry.rs b/clippy_lints/src/entry.rs
index ee5a875ade7..86e94a62a78 100644
--- a/clippy_lints/src/entry.rs
+++ b/clippy_lints/src/entry.rs
@@ -186,7 +186,7 @@ impl<'tcx> LateLintPass<'tcx> for HashMapPass {
             MAP_ENTRY,
             expr.span,
             &format!("usage of `contains_key` followed by `insert` on a `{}`", map_ty.name()),
-            "try this",
+            "try",
             sugg,
             app,
         );
diff --git a/clippy_lints/src/explicit_write.rs b/clippy_lints/src/explicit_write.rs
index 315df6c714f..4b9ca8c917e 100644
--- a/clippy_lints/src/explicit_write.rs
+++ b/clippy_lints/src/explicit_write.rs
@@ -100,7 +100,7 @@ impl<'tcx> LateLintPass<'tcx> for ExplicitWrite {
                     EXPLICIT_WRITE,
                     expr.span,
                     &format!("use of `{used}.unwrap()`"),
-                    "try this",
+                    "try",
                     format!("{prefix}{sugg_mac}!({inputs_snippet})"),
                     applicability,
                 );
diff --git a/clippy_lints/src/init_numbered_fields.rs b/clippy_lints/src/init_numbered_fields.rs
index 7e1548531f1..f95d2c2edb1 100644
--- a/clippy_lints/src/init_numbered_fields.rs
+++ b/clippy_lints/src/init_numbered_fields.rs
@@ -71,7 +71,7 @@ impl<'tcx> LateLintPass<'tcx> for NumberedFields {
                     INIT_NUMBERED_FIELDS,
                     e.span,
                     "used a field initializer for a tuple struct",
-                    "try this instead",
+                    "try",
                     snippet,
                     appl,
                 );
diff --git a/clippy_lints/src/loops/missing_spin_loop.rs b/clippy_lints/src/loops/missing_spin_loop.rs
index 8412875b11b..f3bfe9e927d 100644
--- a/clippy_lints/src/loops/missing_spin_loop.rs
+++ b/clippy_lints/src/loops/missing_spin_loop.rs
@@ -43,7 +43,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, cond: &'tcx Expr<'_>, body: &'
                 MISSING_SPIN_LOOP,
                 body.span,
                 "busy-waiting loop should at least have a spin loop hint",
-                "try this",
+                "try",
                 (if is_no_std_crate(cx) {
                     "{ core::hint::spin_loop() }"
                 } else {
diff --git a/clippy_lints/src/map_unit_fn.rs b/clippy_lints/src/map_unit_fn.rs
index edcab6968cb..1b3a47e4acd 100644
--- a/clippy_lints/src/map_unit_fn.rs
+++ b/clippy_lints/src/map_unit_fn.rs
@@ -226,7 +226,7 @@ fn lint_map_unit_fn(
         );
 
         span_lint_and_then(cx, lint, expr.span, &msg, |diag| {
-            diag.span_suggestion(stmt.span, "try this", suggestion, applicability);
+            diag.span_suggestion(stmt.span, "try", suggestion, applicability);
         });
     } else if let Some((binding, closure_expr)) = unit_closure(cx, fn_arg) {
         let msg = suggestion_msg("closure", map_type);
@@ -241,7 +241,7 @@ fn lint_map_unit_fn(
                     snippet_with_applicability(cx, var_arg.span, "_", &mut applicability),
                     snippet_with_context(cx, reduced_expr_span, var_arg.span.ctxt(), "_", &mut applicability).0,
                 );
-                diag.span_suggestion(stmt.span, "try this", suggestion, applicability);
+                diag.span_suggestion(stmt.span, "try", suggestion, applicability);
             } else {
                 let suggestion = format!(
                     "if let {0}({1}) = {2} {{ ... }}",
@@ -249,7 +249,7 @@ fn lint_map_unit_fn(
                     snippet(cx, binding.pat.span, "_"),
                     snippet(cx, var_arg.span, "_"),
                 );
-                diag.span_suggestion(stmt.span, "try this", suggestion, Applicability::HasPlaceholders);
+                diag.span_suggestion(stmt.span, "try", suggestion, Applicability::HasPlaceholders);
             }
         });
     }
diff --git a/clippy_lints/src/matches/infallible_destructuring_match.rs b/clippy_lints/src/matches/infallible_destructuring_match.rs
index d18c92caba2..3329f93b73c 100644
--- a/clippy_lints/src/matches/infallible_destructuring_match.rs
+++ b/clippy_lints/src/matches/infallible_destructuring_match.rs
@@ -28,7 +28,7 @@ pub(crate) fn check(cx: &LateContext<'_>, local: &Local<'_>) -> bool {
                 local.span,
                 "you seem to be trying to use `match` to destructure a single infallible pattern. \
                 Consider using `let`",
-                "try this",
+                "try",
                 format!(
                     "let {}({}{}) = {};",
                     snippet_with_applicability(cx, variant_name.span, "..", &mut applicability),
diff --git a/clippy_lints/src/matches/manual_filter.rs b/clippy_lints/src/matches/manual_filter.rs
index f6bf0e7aa1a..e0181a4757c 100644
--- a/clippy_lints/src/matches/manual_filter.rs
+++ b/clippy_lints/src/matches/manual_filter.rs
@@ -143,7 +143,7 @@ fn check<'tcx>(
             MANUAL_FILTER,
             expr.span,
             "manual implementation of `Option::filter`",
-            "try this",
+            "try",
             if sugg_info.needs_brackets {
                 format!(
                     "{{ {}{}.filter({body_str}) }}",
diff --git a/clippy_lints/src/matches/manual_map.rs b/clippy_lints/src/matches/manual_map.rs
index aaba239677f..ed3d8b09fdc 100644
--- a/clippy_lints/src/matches/manual_map.rs
+++ b/clippy_lints/src/matches/manual_map.rs
@@ -58,7 +58,7 @@ fn check<'tcx>(
             MANUAL_MAP,
             expr.span,
             "manual implementation of `Option::map`",
-            "try this",
+            "try",
             if sugg_info.needs_brackets {
                 format!(
                     "{{ {}{}.map({}) }}",
diff --git a/clippy_lints/src/matches/match_as_ref.rs b/clippy_lints/src/matches/match_as_ref.rs
index 2818f030b7a..a6392b7aaec 100644
--- a/clippy_lints/src/matches/match_as_ref.rs
+++ b/clippy_lints/src/matches/match_as_ref.rs
@@ -46,7 +46,7 @@ pub(crate) fn check(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>], expr:
                 MATCH_AS_REF,
                 expr.span,
                 &format!("use `{suggestion}()` instead"),
-                "try this",
+                "try",
                 format!(
                     "{}.{suggestion}(){cast}",
                     snippet_with_applicability(cx, ex.span, "_", &mut applicability),
diff --git a/clippy_lints/src/matches/match_like_matches.rs b/clippy_lints/src/matches/match_like_matches.rs
index 0064619ef89..69f6c59beb3 100644
--- a/clippy_lints/src/matches/match_like_matches.rs
+++ b/clippy_lints/src/matches/match_like_matches.rs
@@ -139,7 +139,7 @@ where
                 MATCH_LIKE_MATCHES_MACRO,
                 expr.span,
                 &format!("{} expression looks like `matches!` macro", if is_if_let { "if let .. else" } else { "match" }),
-                "try this",
+                "try",
                 format!(
                     "{}matches!({}, {pat_and_guard})",
                     if b0 { "" } else { "!" },
diff --git a/clippy_lints/src/matches/match_on_vec_items.rs b/clippy_lints/src/matches/match_on_vec_items.rs
index 2917f85c45f..89dcac4d849 100644
--- a/clippy_lints/src/matches/match_on_vec_items.rs
+++ b/clippy_lints/src/matches/match_on_vec_items.rs
@@ -22,7 +22,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, scrutinee: &'tcx Expr<'_>) {
                 MATCH_ON_VEC_ITEMS,
                 scrutinee.span,
                 "indexing into a vector may panic",
-                "try this",
+                "try",
                 format!(
                     "{}.get({})",
                     snippet(cx, vec.span, ".."),
diff --git a/clippy_lints/src/matches/match_wild_enum.rs b/clippy_lints/src/matches/match_wild_enum.rs
index 3126b590180..8d22ceb47f8 100644
--- a/clippy_lints/src/matches/match_wild_enum.rs
+++ b/clippy_lints/src/matches/match_wild_enum.rs
@@ -143,7 +143,7 @@ pub(crate) fn check(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>]) {
             MATCH_WILDCARD_FOR_SINGLE_VARIANTS,
             wildcard_span,
             "wildcard matches only a single variant and will also match any future added variants",
-            "try this",
+            "try",
             format_suggestion(x),
             Applicability::MaybeIncorrect,
         ),
@@ -161,7 +161,7 @@ pub(crate) fn check(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>]) {
                 WILDCARD_ENUM_MATCH_ARM,
                 wildcard_span,
                 message,
-                "try this",
+                "try",
                 suggestions.join(" | "),
                 Applicability::MaybeIncorrect,
             );
diff --git a/clippy_lints/src/matches/redundant_pattern_match.rs b/clippy_lints/src/matches/redundant_pattern_match.rs
index 479cfd83512..43d2ab9f60e 100644
--- a/clippy_lints/src/matches/redundant_pattern_match.rs
+++ b/clippy_lints/src/matches/redundant_pattern_match.rs
@@ -175,7 +175,7 @@ fn find_sugg_for_if_let<'tcx>(
                 .maybe_par()
                 .to_string();
 
-            diag.span_suggestion(span, "try this", format!("{keyword} {sugg}.{good_method}"), app);
+            diag.span_suggestion(span, "try", format!("{keyword} {sugg}.{good_method}"), app);
 
             if needs_drop {
                 diag.note("this will change drop order of the result, as well as all temporaries");
@@ -200,7 +200,7 @@ pub(super) fn check_match<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, op
                 REDUNDANT_PATTERN_MATCHING,
                 span,
                 &format!("redundant pattern matching, consider using `{good_method}`"),
-                "try this",
+                "try",
                 format!("{}.{good_method}", snippet(cx, result_expr.span, "_")),
                 Applicability::MachineApplicable,
             );
diff --git a/clippy_lints/src/matches/single_match.rs b/clippy_lints/src/matches/single_match.rs
index 35627d6c649..6b05c6bfffd 100644
--- a/clippy_lints/src/matches/single_match.rs
+++ b/clippy_lints/src/matches/single_match.rs
@@ -136,7 +136,7 @@ fn report_single_pattern(
         }
     };
 
-    span_lint_and_sugg(cx, lint, expr.span, msg, "try this", sugg, app);
+    span_lint_and_sugg(cx, lint, expr.span, msg, "try", sugg, app);
 }
 
 fn check_opt_like<'a>(
diff --git a/clippy_lints/src/matches/try_err.rs b/clippy_lints/src/matches/try_err.rs
index 3a7f1e034f3..99a748489b4 100644
--- a/clippy_lints/src/matches/try_err.rs
+++ b/clippy_lints/src/matches/try_err.rs
@@ -70,7 +70,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, scrutine
                 TRY_ERR,
                 expr.span,
                 "returning an `Err(_)` with the `?` operator",
-                "try this",
+                "try",
                 suggestion,
                 applicability,
             );
diff --git a/clippy_lints/src/methods/bind_instead_of_map.rs b/clippy_lints/src/methods/bind_instead_of_map.rs
index 00853348840..883a5505827 100644
--- a/clippy_lints/src/methods/bind_instead_of_map.rs
+++ b/clippy_lints/src/methods/bind_instead_of_map.rs
@@ -87,7 +87,7 @@ pub(crate) trait BindInsteadOfMap {
                     BIND_INSTEAD_OF_MAP,
                     expr.span,
                     &msg,
-                    "try this",
+                    "try",
                     note,
                     app,
                 );
@@ -124,7 +124,7 @@ pub(crate) trait BindInsteadOfMap {
         span_lint_and_then(cx, BIND_INSTEAD_OF_MAP, expr.span, &msg, |diag| {
             multispan_sugg_with_applicability(
                 diag,
-                "try this",
+                "try",
                 Applicability::MachineApplicable,
                 std::iter::once((span, Self::GOOD_METHOD_NAME.into())).chain(
                     suggs
diff --git a/clippy_lints/src/methods/clone_on_ref_ptr.rs b/clippy_lints/src/methods/clone_on_ref_ptr.rs
index 5e8ad0861f3..ddf3c9f27df 100644
--- a/clippy_lints/src/methods/clone_on_ref_ptr.rs
+++ b/clippy_lints/src/methods/clone_on_ref_ptr.rs
@@ -42,7 +42,7 @@ pub(super) fn check(
             CLONE_ON_REF_PTR,
             expr.span,
             "using `.clone()` on a ref-counted pointer",
-            "try this",
+            "try",
             format!("{caller_type}::<{}>::clone(&{snippet})", subst.type_at(0)),
             app,
         );
diff --git a/clippy_lints/src/methods/expect_fun_call.rs b/clippy_lints/src/methods/expect_fun_call.rs
index 92d21bb8932..862a7cec775 100644
--- a/clippy_lints/src/methods/expect_fun_call.rs
+++ b/clippy_lints/src/methods/expect_fun_call.rs
@@ -144,7 +144,7 @@ pub(super) fn check<'tcx>(
                 EXPECT_FUN_CALL,
                 span_replace_word,
                 &format!("use of `{name}` followed by a function call"),
-                "try this",
+                "try",
                 format!("unwrap_or_else({closure_args} panic!({sugg}))"),
                 applicability,
             );
@@ -162,7 +162,7 @@ pub(super) fn check<'tcx>(
         EXPECT_FUN_CALL,
         span_replace_word,
         &format!("use of `{name}` followed by a function call"),
-        "try this",
+        "try",
         format!("unwrap_or_else({closure_args} {{ panic!(\"{{}}\", {arg_root_snippet}) }})"),
         applicability,
     );
diff --git a/clippy_lints/src/methods/extend_with_drain.rs b/clippy_lints/src/methods/extend_with_drain.rs
index 37b28463527..495b266529b 100644
--- a/clippy_lints/src/methods/extend_with_drain.rs
+++ b/clippy_lints/src/methods/extend_with_drain.rs
@@ -31,7 +31,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'_>, arg:
                 EXTEND_WITH_DRAIN,
                 expr.span,
                 "use of `extend` instead of `append` for adding the full range of a second vector",
-                "try this",
+                "try",
                 format!(
                     "{}.append({}{})",
                     snippet_with_applicability(cx, recv.span, "..", &mut applicability),
diff --git a/clippy_lints/src/methods/filter_map_next.rs b/clippy_lints/src/methods/filter_map_next.rs
index 175e04f8ac0..3f89e593148 100644
--- a/clippy_lints/src/methods/filter_map_next.rs
+++ b/clippy_lints/src/methods/filter_map_next.rs
@@ -31,7 +31,7 @@ pub(super) fn check<'tcx>(
                 FILTER_MAP_NEXT,
                 expr.span,
                 msg,
-                "try this",
+                "try",
                 format!("{iter_snippet}.find_map({filter_snippet})"),
                 Applicability::MachineApplicable,
             );
diff --git a/clippy_lints/src/methods/filter_next.rs b/clippy_lints/src/methods/filter_next.rs
index edcec0fc101..ad71b494619 100644
--- a/clippy_lints/src/methods/filter_next.rs
+++ b/clippy_lints/src/methods/filter_next.rs
@@ -31,7 +31,7 @@ pub(super) fn check<'tcx>(
                 FILTER_NEXT,
                 expr.span,
                 msg,
-                "try this",
+                "try",
                 format!("{iter_snippet}.find({filter_snippet})"),
                 Applicability::MachineApplicable,
             );
diff --git a/clippy_lints/src/methods/get_unwrap.rs b/clippy_lints/src/methods/get_unwrap.rs
index e35fb12ed79..a8f090d1de1 100644
--- a/clippy_lints/src/methods/get_unwrap.rs
+++ b/clippy_lints/src/methods/get_unwrap.rs
@@ -71,7 +71,7 @@ pub(super) fn check<'tcx>(
         GET_UNWRAP,
         span,
         &format!("called `.get{mut_str}().unwrap()` on a {caller_type}. Using `[]` is more clear and more concise"),
-        "try this",
+        "try",
         format!(
             "{borrow_str}{}[{get_args_str}]",
             snippet_with_applicability(cx, recv.span, "..", &mut applicability)
diff --git a/clippy_lints/src/methods/iter_overeager_cloned.rs b/clippy_lints/src/methods/iter_overeager_cloned.rs
index b4210d87510..9f7ec19aa59 100644
--- a/clippy_lints/src/methods/iter_overeager_cloned.rs
+++ b/clippy_lints/src/methods/iter_overeager_cloned.rs
@@ -51,7 +51,7 @@ pub(super) fn check<'tcx>(
                 if let Some(mut snip) = snippet_opt(cx, method_span) {
                     snip.push_str(trailing_clone);
                     let replace_span = expr.span.with_lo(cloned_recv.span.hi());
-                    diag.span_suggestion(replace_span, "try this", snip, Applicability::MachineApplicable);
+                    diag.span_suggestion(replace_span, "try", snip, Applicability::MachineApplicable);
                 }
             }
         );
diff --git a/clippy_lints/src/methods/iter_with_drain.rs b/clippy_lints/src/methods/iter_with_drain.rs
index f6772c5c6b3..2ab721ace84 100644
--- a/clippy_lints/src/methods/iter_with_drain.rs
+++ b/clippy_lints/src/methods/iter_with_drain.rs
@@ -21,7 +21,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'_>, span
             ITER_WITH_DRAIN,
             span.with_hi(expr.span.hi()),
             &format!("`drain(..)` used on a `{ty_name}`"),
-            "try this",
+            "try",
             "into_iter()".to_string(),
             Applicability::MaybeIncorrect,
         );
diff --git a/clippy_lints/src/methods/manual_str_repeat.rs b/clippy_lints/src/methods/manual_str_repeat.rs
index a08f7254053..ab13d30d845 100644
--- a/clippy_lints/src/methods/manual_str_repeat.rs
+++ b/clippy_lints/src/methods/manual_str_repeat.rs
@@ -88,7 +88,7 @@ pub(super) fn check(
                 MANUAL_STR_REPEAT,
                 collect_expr.span,
                 "manual implementation of `str::repeat` using iterators",
-                "try this",
+                "try",
                 format!("{val_str}.repeat({count_snip})"),
                 app
             )
diff --git a/clippy_lints/src/methods/map_collect_result_unit.rs b/clippy_lints/src/methods/map_collect_result_unit.rs
index a0300d27870..36c7ddc973c 100644
--- a/clippy_lints/src/methods/map_collect_result_unit.rs
+++ b/clippy_lints/src/methods/map_collect_result_unit.rs
@@ -25,7 +25,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, iter: &hir::Expr
                 MAP_COLLECT_RESULT_UNIT,
                 expr.span,
                 "`.map().collect()` can be replaced with `.try_for_each()`",
-                "try this",
+                "try",
                 format!(
                     "{}.try_for_each({})",
                     snippet(cx, iter.span, ".."),
diff --git a/clippy_lints/src/methods/map_unwrap_or.rs b/clippy_lints/src/methods/map_unwrap_or.rs
index 3122f72ee91..2c60e85fa90 100644
--- a/clippy_lints/src/methods/map_unwrap_or.rs
+++ b/clippy_lints/src/methods/map_unwrap_or.rs
@@ -63,7 +63,7 @@ pub(super) fn check<'tcx>(
                 MAP_UNWRAP_OR,
                 expr.span,
                 msg,
-                "try this",
+                "try",
                 format!("{var_snippet}.map_or_else({unwrap_snippet}, {map_snippet})"),
                 Applicability::MachineApplicable,
             );
diff --git a/clippy_lints/src/methods/needless_option_as_deref.rs b/clippy_lints/src/methods/needless_option_as_deref.rs
index 7030baf19ff..c18bfa1b802 100644
--- a/clippy_lints/src/methods/needless_option_as_deref.rs
+++ b/clippy_lints/src/methods/needless_option_as_deref.rs
@@ -29,7 +29,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'_>, name
             NEEDLESS_OPTION_AS_DEREF,
             expr.span,
             "derefed type is same as origin",
-            "try this",
+            "try",
             snippet_opt(cx, recv.span).unwrap(),
             Applicability::MachineApplicable,
         );
diff --git a/clippy_lints/src/methods/or_fun_call.rs b/clippy_lints/src/methods/or_fun_call.rs
index 7ce28ea93e0..9165c1248f0 100644
--- a/clippy_lints/src/methods/or_fun_call.rs
+++ b/clippy_lints/src/methods/or_fun_call.rs
@@ -62,7 +62,7 @@ pub(super) fn check<'tcx>(
                     OR_FUN_CALL,
                     method_span.with_hi(span.hi()),
                     &format!("use of `{name}` followed by a call to `{path}`"),
-                    "try this",
+                    "try",
                     format!("{sugg}()"),
                     Applicability::MachineApplicable,
                 );
@@ -139,7 +139,7 @@ pub(super) fn check<'tcx>(
                     OR_FUN_CALL,
                     span_replace_word,
                     &format!("use of `{name}` followed by a function call"),
-                    "try this",
+                    "try",
                     format!("{name}_{suffix}({sugg})"),
                     app,
                 );
diff --git a/clippy_lints/src/methods/or_then_unwrap.rs b/clippy_lints/src/methods/or_then_unwrap.rs
index 55ba6e262df..d65082173b3 100644
--- a/clippy_lints/src/methods/or_then_unwrap.rs
+++ b/clippy_lints/src/methods/or_then_unwrap.rs
@@ -50,7 +50,7 @@ pub(super) fn check<'tcx>(
         OR_THEN_UNWRAP,
         unwrap_expr.span.with_lo(or_span.lo()),
         title,
-        "try this",
+        "try",
         suggestion,
         applicability,
     );
diff --git a/clippy_lints/src/methods/str_splitn.rs b/clippy_lints/src/methods/str_splitn.rs
index 88a3c2620a4..41986551da4 100644
--- a/clippy_lints/src/methods/str_splitn.rs
+++ b/clippy_lints/src/methods/str_splitn.rs
@@ -55,7 +55,7 @@ fn lint_needless(cx: &LateContext<'_>, method_name: &str, expr: &Expr<'_>, self_
         NEEDLESS_SPLITN,
         expr.span,
         &format!("unnecessary use of `{r}splitn`"),
-        "try this",
+        "try",
         format!(
             "{}.{r}split({})",
             snippet_with_context(cx, self_arg.span, expr.span.ctxt(), "..", &mut app).0,
@@ -110,7 +110,7 @@ fn check_manual_split_once(
         IterUsageKind::Nth(_) => return,
     };
 
-    span_lint_and_sugg(cx, MANUAL_SPLIT_ONCE, usage.span, msg, "try this", sugg, app);
+    span_lint_and_sugg(cx, MANUAL_SPLIT_ONCE, usage.span, msg, "try", sugg, app);
 }
 
 /// checks for
diff --git a/clippy_lints/src/methods/string_extend_chars.rs b/clippy_lints/src/methods/string_extend_chars.rs
index 2c20c6d752d..c7885f689d7 100644
--- a/clippy_lints/src/methods/string_extend_chars.rs
+++ b/clippy_lints/src/methods/string_extend_chars.rs
@@ -34,7 +34,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr
             STRING_EXTEND_CHARS,
             expr.span,
             "calling `.extend(_.chars())`",
-            "try this",
+            "try",
             format!(
                 "{}.push_str({ref_str}{})",
                 snippet_with_applicability(cx, recv.span, "..", &mut applicability),
diff --git a/clippy_lints/src/methods/useless_asref.rs b/clippy_lints/src/methods/useless_asref.rs
index c1139d84e2f..b5f810eddf4 100644
--- a/clippy_lints/src/methods/useless_asref.rs
+++ b/clippy_lints/src/methods/useless_asref.rs
@@ -37,7 +37,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, call_name: &str,
                 USELESS_ASREF,
                 expr.span,
                 &format!("this call to `{call_name}` does nothing"),
-                "try this",
+                "try",
                 snippet_with_applicability(cx, recvr.span, "..", &mut applicability).to_string(),
                 applicability,
             );
diff --git a/clippy_lints/src/reference.rs b/clippy_lints/src/reference.rs
index a642e2da3ba..db870ec4c5b 100644
--- a/clippy_lints/src/reference.rs
+++ b/clippy_lints/src/reference.rs
@@ -94,7 +94,7 @@ impl EarlyLintPass for DerefAddrOf {
                         DEREF_ADDROF,
                         e.span,
                         "immediately dereferencing a reference",
-                        "try this",
+                        "try",
                         sugg.to_string(),
                         applicability,
                     );
diff --git a/clippy_lints/src/strlen_on_c_strings.rs b/clippy_lints/src/strlen_on_c_strings.rs
index 2f2e84fa35a..b3db5e9a422 100644
--- a/clippy_lints/src/strlen_on_c_strings.rs
+++ b/clippy_lints/src/strlen_on_c_strings.rs
@@ -78,7 +78,7 @@ impl<'tcx> LateLintPass<'tcx> for StrlenOnCStrings {
                     STRLEN_ON_C_STRINGS,
                     span,
                     "using `libc::strlen` on a `CString` or `CStr` value",
-                    "try this",
+                    "try",
                     format!("{val_name}.{method_name}().len()"),
                     app,
                 );
diff --git a/clippy_lints/src/to_digit_is_some.rs b/clippy_lints/src/to_digit_is_some.rs
index 2512500a6be..f1b703fde0e 100644
--- a/clippy_lints/src/to_digit_is_some.rs
+++ b/clippy_lints/src/to_digit_is_some.rs
@@ -82,7 +82,7 @@ impl<'tcx> LateLintPass<'tcx> for ToDigitIsSome {
                         TO_DIGIT_IS_SOME,
                         expr.span,
                         "use of `.to_digit(..).is_some()`",
-                        "try this",
+                        "try",
                         if is_method_call {
                             format!("{char_arg_snip}.is_digit({radix_snip})")
                         } else {
diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs
index f194dc5d4b2..8f1363b6074 100644
--- a/clippy_lints/src/write.rs
+++ b/clippy_lints/src/write.rs
@@ -522,7 +522,7 @@ fn check_literal(cx: &LateContext<'_>, format_args: &FormatArgs, name: &str) {
                     {
                         let replacement = replacement.replace('{', "{{").replace('}', "}}");
                         diag.multipart_suggestion(
-                            "try this",
+                            "try",
                             vec![(*placeholder_span, replacement), (removal_span, String::new())],
                             Applicability::MachineApplicable,
                         );
diff --git a/tests/lint_message_convention.rs b/tests/lint_message_convention.rs
index 15e5cdd6992..98019c75527 100644
--- a/tests/lint_message_convention.rs
+++ b/tests/lint_message_convention.rs
@@ -18,18 +18,20 @@ impl Message {
     fn new(path: PathBuf) -> Self {
         // we don't want the first letter after "error: ", "help: " ... to be capitalized
         // also no punctuation (except for "?" ?) at the end of a line
+        // Prefer "try" over "try this".
         static REGEX_SET: LazyLock<RegexSet> = LazyLock::new(|| {
             RegexSet::new([
                 "error: [A-Z]",
                 "help: [A-Z]",
                 "warning: [A-Z]",
                 "note: [A-Z]",
-                "try this: [A-Z]",
+                "try: [A-Z]",
                 "error: .*[.!]$",
                 "help: .*[.!]$",
                 "warning: .*[.!]$",
                 "note: .*[.!]$",
-                "try this: .*[.!]$",
+                "try: .*[.!]$",
+                "try this",
             ])
             .unwrap()
         });
diff --git a/tests/ui-toml/allow_mixed_uninlined_format_args/uninlined_format_args.stderr b/tests/ui-toml/allow_mixed_uninlined_format_args/uninlined_format_args.stderr
index 6ec79a618de..eb1180e60b8 100644
--- a/tests/ui-toml/allow_mixed_uninlined_format_args/uninlined_format_args.stderr
+++ b/tests/ui-toml/allow_mixed_uninlined_format_args/uninlined_format_args.stderr
@@ -30,7 +30,7 @@ LL |     println!("Hello {} is {:.*}", "x", local_i32, local_f64);
    |                                   ^^^
    |
    = note: `-D clippy::print-literal` implied by `-D warnings`
-help: try this
+help: try
    |
 LL -     println!("Hello {} is {:.*}", "x", local_i32, local_f64);
 LL +     println!("Hello x is {:.*}", local_i32, local_f64);
diff --git a/tests/ui-toml/unwrap_used/unwrap_used.stderr b/tests/ui-toml/unwrap_used/unwrap_used.stderr
index eb66a5cf50b..aed29a51c1d 100644
--- a/tests/ui-toml/unwrap_used/unwrap_used.stderr
+++ b/tests/ui-toml/unwrap_used/unwrap_used.stderr
@@ -2,7 +2,7 @@ error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more co
   --> $DIR/unwrap_used.rs:40:17
    |
 LL |         let _ = boxed_slice.get(1).unwrap();
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&boxed_slice[1]`
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&boxed_slice[1]`
    |
    = note: `-D clippy::get-unwrap` implied by `-D warnings`
 
@@ -19,7 +19,7 @@ error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more co
   --> $DIR/unwrap_used.rs:41:17
    |
 LL |         let _ = some_slice.get(0).unwrap();
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&some_slice[0]`
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&some_slice[0]`
 
 error: used `unwrap()` on an `Option` value
   --> $DIR/unwrap_used.rs:41:17
@@ -33,7 +33,7 @@ error: called `.get().unwrap()` on a Vec. Using `[]` is more clear and more conc
   --> $DIR/unwrap_used.rs:42:17
    |
 LL |         let _ = some_vec.get(0).unwrap();
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&some_vec[0]`
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&some_vec[0]`
 
 error: used `unwrap()` on an `Option` value
   --> $DIR/unwrap_used.rs:42:17
@@ -47,7 +47,7 @@ error: called `.get().unwrap()` on a VecDeque. Using `[]` is more clear and more
   --> $DIR/unwrap_used.rs:43:17
    |
 LL |         let _ = some_vecdeque.get(0).unwrap();
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&some_vecdeque[0]`
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&some_vecdeque[0]`
 
 error: used `unwrap()` on an `Option` value
   --> $DIR/unwrap_used.rs:43:17
@@ -61,7 +61,7 @@ error: called `.get().unwrap()` on a HashMap. Using `[]` is more clear and more
   --> $DIR/unwrap_used.rs:44:17
    |
 LL |         let _ = some_hashmap.get(&1).unwrap();
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&some_hashmap[&1]`
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&some_hashmap[&1]`
 
 error: used `unwrap()` on an `Option` value
   --> $DIR/unwrap_used.rs:44:17
@@ -75,7 +75,7 @@ error: called `.get().unwrap()` on a BTreeMap. Using `[]` is more clear and more
   --> $DIR/unwrap_used.rs:45:17
    |
 LL |         let _ = some_btreemap.get(&1).unwrap();
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&some_btreemap[&1]`
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&some_btreemap[&1]`
 
 error: used `unwrap()` on an `Option` value
   --> $DIR/unwrap_used.rs:45:17
@@ -89,7 +89,7 @@ error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more co
   --> $DIR/unwrap_used.rs:49:21
    |
 LL |         let _: u8 = *boxed_slice.get(1).unwrap();
-   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `boxed_slice[1]`
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `boxed_slice[1]`
 
 error: used `unwrap()` on an `Option` value
   --> $DIR/unwrap_used.rs:49:22
@@ -103,7 +103,7 @@ error: called `.get_mut().unwrap()` on a slice. Using `[]` is more clear and mor
   --> $DIR/unwrap_used.rs:54:9
    |
 LL |         *boxed_slice.get_mut(0).unwrap() = 1;
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `boxed_slice[0]`
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `boxed_slice[0]`
 
 error: used `unwrap()` on an `Option` value
   --> $DIR/unwrap_used.rs:54:10
@@ -117,7 +117,7 @@ error: called `.get_mut().unwrap()` on a slice. Using `[]` is more clear and mor
   --> $DIR/unwrap_used.rs:55:9
    |
 LL |         *some_slice.get_mut(0).unwrap() = 1;
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `some_slice[0]`
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `some_slice[0]`
 
 error: used `unwrap()` on an `Option` value
   --> $DIR/unwrap_used.rs:55:10
@@ -131,7 +131,7 @@ error: called `.get_mut().unwrap()` on a Vec. Using `[]` is more clear and more
   --> $DIR/unwrap_used.rs:56:9
    |
 LL |         *some_vec.get_mut(0).unwrap() = 1;
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `some_vec[0]`
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `some_vec[0]`
 
 error: used `unwrap()` on an `Option` value
   --> $DIR/unwrap_used.rs:56:10
@@ -145,7 +145,7 @@ error: called `.get_mut().unwrap()` on a VecDeque. Using `[]` is more clear and
   --> $DIR/unwrap_used.rs:57:9
    |
 LL |         *some_vecdeque.get_mut(0).unwrap() = 1;
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `some_vecdeque[0]`
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `some_vecdeque[0]`
 
 error: used `unwrap()` on an `Option` value
   --> $DIR/unwrap_used.rs:57:10
@@ -159,7 +159,7 @@ error: called `.get().unwrap()` on a Vec. Using `[]` is more clear and more conc
   --> $DIR/unwrap_used.rs:69:17
    |
 LL |         let _ = some_vec.get(0..1).unwrap().to_vec();
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `some_vec[0..1]`
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `some_vec[0..1]`
 
 error: used `unwrap()` on an `Option` value
   --> $DIR/unwrap_used.rs:69:17
@@ -173,7 +173,7 @@ error: called `.get_mut().unwrap()` on a Vec. Using `[]` is more clear and more
   --> $DIR/unwrap_used.rs:70:17
    |
 LL |         let _ = some_vec.get_mut(0..1).unwrap().to_vec();
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `some_vec[0..1]`
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `some_vec[0..1]`
 
 error: used `unwrap()` on an `Option` value
   --> $DIR/unwrap_used.rs:70:17
@@ -187,13 +187,13 @@ error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more co
   --> $DIR/unwrap_used.rs:77:13
    |
 LL |     let _ = boxed_slice.get(1).unwrap();
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&boxed_slice[1]`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&boxed_slice[1]`
 
 error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more concise
   --> $DIR/unwrap_used.rs:95:17
    |
 LL |         let _ = Box::new([0]).get(1).unwrap();
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&Box::new([0])[1]`
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&Box::new([0])[1]`
 
 error: aborting due to 28 previous errors
 
diff --git a/tests/ui/bind_instead_of_map.stderr b/tests/ui/bind_instead_of_map.stderr
index b6a81d21bb2..f17fee7460d 100644
--- a/tests/ui/bind_instead_of_map.stderr
+++ b/tests/ui/bind_instead_of_map.stderr
@@ -14,7 +14,7 @@ error: using `Option.and_then(|x| Some(y))`, which is more succinctly expressed
   --> $DIR/bind_instead_of_map.rs:10:13
    |
 LL |     let _ = x.and_then(|o| Some(o + 1));
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `x.map(|o| o + 1)`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `x.map(|o| o + 1)`
 
 error: using `Result.and_then(Ok)`, which is a no-op
   --> $DIR/bind_instead_of_map.rs:16:13
diff --git a/tests/ui/bind_instead_of_map_multipart.stderr b/tests/ui/bind_instead_of_map_multipart.stderr
index 0152a93feee..cedbca78561 100644
--- a/tests/ui/bind_instead_of_map_multipart.stderr
+++ b/tests/ui/bind_instead_of_map_multipart.stderr
@@ -9,7 +9,7 @@ note: the lint level is defined here
    |
 LL | #![deny(clippy::bind_instead_of_map)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
-help: try this
+help: try
    |
 LL |     let _ = Some("42").map(|s| if s.len() < 42 { 0 } else { s.len() });
    |                        ~~~                       ~          ~~~~~~~
@@ -20,7 +20,7 @@ error: using `Result.and_then(|x| Ok(y))`, which is more succinctly expressed as
 LL |     let _ = Ok::<_, ()>("42").and_then(|s| if s.len() < 42 { Ok(0) } else { Ok(s.len()) });
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-help: try this
+help: try
    |
 LL |     let _ = Ok::<_, ()>("42").map(|s| if s.len() < 42 { 0 } else { s.len() });
    |                               ~~~                       ~          ~~~~~~~
@@ -31,7 +31,7 @@ error: using `Result.or_else(|x| Err(y))`, which is more succinctly expressed as
 LL |     let _ = Err::<(), _>("42").or_else(|s| if s.len() < 42 { Err(s.len() + 20) } else { Err(s.len()) });
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-help: try this
+help: try
    |
 LL |     let _ = Err::<(), _>("42").map_err(|s| if s.len() < 42 { s.len() + 20 } else { s.len() });
    |                                ~~~~~~~                       ~~~~~~~~~~~~          ~~~~~~~
@@ -48,7 +48,7 @@ LL | |         }
 LL | |     });
    | |______^
    |
-help: try this
+help: try
    |
 LL ~     Some("42").map(|s| {
 LL |         if {
@@ -82,7 +82,7 @@ error: using `Option.and_then(|x| Some(y))`, which is more succinctly expressed
 LL |     let _ = Some("").and_then(|s| if s.len() == 20 { Some(m!()) } else { Some(Some(20)) });
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-help: try this
+help: try
    |
 LL |     let _ = Some("").map(|s| if s.len() == 20 { m!() } else { Some(20) });
    |                      ~~~                        ~~~~          ~~~~~~~~
diff --git a/tests/ui/crashes/ice-7169.stderr b/tests/ui/crashes/ice-7169.stderr
index 84e0af3f0d0..0cd02851640 100644
--- a/tests/ui/crashes/ice-7169.stderr
+++ b/tests/ui/crashes/ice-7169.stderr
@@ -2,7 +2,7 @@ error: redundant pattern matching, consider using `is_ok()`
   --> $DIR/ice-7169.rs:10:12
    |
 LL |     if let Ok(_) = Ok::<_, ()>(A::<String>::default()) {}
-   |     -------^^^^^-------------------------------------- help: try this: `if Ok::<_, ()>(A::<String>::default()).is_ok()`
+   |     -------^^^^^-------------------------------------- help: try: `if Ok::<_, ()>(A::<String>::default()).is_ok()`
    |
    = note: `-D clippy::redundant-pattern-matching` implied by `-D warnings`
 
diff --git a/tests/ui/crashes/ice-8250.stderr b/tests/ui/crashes/ice-8250.stderr
index 8ed8f3b3a06..e6f3644ef34 100644
--- a/tests/ui/crashes/ice-8250.stderr
+++ b/tests/ui/crashes/ice-8250.stderr
@@ -2,7 +2,7 @@ error: unnecessary use of `splitn`
   --> $DIR/ice-8250.rs:2:13
    |
 LL |     let _ = s[1..].splitn(2, '.').next()?;
-   |             ^^^^^^^^^^^^^^^^^^^^^ help: try this: `s[1..].split('.')`
+   |             ^^^^^^^^^^^^^^^^^^^^^ help: try: `s[1..].split('.')`
    |
    = note: `-D clippy::needless-splitn` implied by `-D warnings`
 
diff --git a/tests/ui/deref_addrof.stderr b/tests/ui/deref_addrof.stderr
index e0287522fc5..9dd1e246b3e 100644
--- a/tests/ui/deref_addrof.stderr
+++ b/tests/ui/deref_addrof.stderr
@@ -2,7 +2,7 @@ error: immediately dereferencing a reference
   --> $DIR/deref_addrof.rs:24:13
    |
 LL |     let b = *&a;
-   |             ^^^ help: try this: `a`
+   |             ^^^ help: try: `a`
    |
    = note: `-D clippy::deref-addrof` implied by `-D warnings`
 
@@ -10,49 +10,49 @@ error: immediately dereferencing a reference
   --> $DIR/deref_addrof.rs:26:13
    |
 LL |     let b = *&get_number();
-   |             ^^^^^^^^^^^^^^ help: try this: `get_number()`
+   |             ^^^^^^^^^^^^^^ help: try: `get_number()`
 
 error: immediately dereferencing a reference
   --> $DIR/deref_addrof.rs:31:13
    |
 LL |     let b = *&bytes[1..2][0];
-   |             ^^^^^^^^^^^^^^^^ help: try this: `bytes[1..2][0]`
+   |             ^^^^^^^^^^^^^^^^ help: try: `bytes[1..2][0]`
 
 error: immediately dereferencing a reference
   --> $DIR/deref_addrof.rs:35:13
    |
 LL |     let b = *&(a);
-   |             ^^^^^ help: try this: `(a)`
+   |             ^^^^^ help: try: `(a)`
 
 error: immediately dereferencing a reference
   --> $DIR/deref_addrof.rs:37:13
    |
 LL |     let b = *(&a);
-   |             ^^^^^ help: try this: `a`
+   |             ^^^^^ help: try: `a`
 
 error: immediately dereferencing a reference
   --> $DIR/deref_addrof.rs:40:13
    |
 LL |     let b = *((&a));
-   |             ^^^^^^^ help: try this: `a`
+   |             ^^^^^^^ help: try: `a`
 
 error: immediately dereferencing a reference
   --> $DIR/deref_addrof.rs:42:13
    |
 LL |     let b = *&&a;
-   |             ^^^^ help: try this: `&a`
+   |             ^^^^ help: try: `&a`
 
 error: immediately dereferencing a reference
   --> $DIR/deref_addrof.rs:44:14
    |
 LL |     let b = **&aref;
-   |              ^^^^^^ help: try this: `aref`
+   |              ^^^^^^ help: try: `aref`
 
 error: immediately dereferencing a reference
   --> $DIR/deref_addrof.rs:54:17
    |
 LL |         inline!(*& $(@expr self))
-   |                 ^^^^^^^^^^^^^^^^ help: try this: `$(@expr self)`
+   |                 ^^^^^^^^^^^^^^^^ help: try: `$(@expr self)`
    |
    = note: this error originates in the macro `__inline_mac_impl` (in Nightly builds, run with -Z macro-backtrace for more info)
 
@@ -60,7 +60,7 @@ error: immediately dereferencing a reference
   --> $DIR/deref_addrof.rs:58:17
    |
 LL |         inline!(*&mut $(@expr self))
-   |                 ^^^^^^^^^^^^^^^^^^^ help: try this: `$(@expr self)`
+   |                 ^^^^^^^^^^^^^^^^^^^ help: try: `$(@expr self)`
    |
    = note: this error originates in the macro `__inline_mac_impl` (in Nightly builds, run with -Z macro-backtrace for more info)
 
diff --git a/tests/ui/deref_addrof_double_trigger.stderr b/tests/ui/deref_addrof_double_trigger.stderr
index 2c55a4ed6ac..6fa5069b6b4 100644
--- a/tests/ui/deref_addrof_double_trigger.stderr
+++ b/tests/ui/deref_addrof_double_trigger.stderr
@@ -2,7 +2,7 @@ error: immediately dereferencing a reference
   --> $DIR/deref_addrof_double_trigger.rs:10:14
    |
 LL |     let b = **&&a;
-   |              ^^^^ help: try this: `&a`
+   |              ^^^^ help: try: `&a`
    |
    = note: `-D clippy::deref-addrof` implied by `-D warnings`
 
@@ -10,13 +10,13 @@ error: immediately dereferencing a reference
   --> $DIR/deref_addrof_double_trigger.rs:14:17
    |
 LL |         let y = *&mut x;
-   |                 ^^^^^^^ help: try this: `x`
+   |                 ^^^^^^^ help: try: `x`
 
 error: immediately dereferencing a reference
   --> $DIR/deref_addrof_double_trigger.rs:21:18
    |
 LL |         let y = **&mut &mut x;
-   |                  ^^^^^^^^^^^^ help: try this: `&mut x`
+   |                  ^^^^^^^^^^^^ help: try: `&mut x`
 
 error: aborting due to 3 previous errors
 
diff --git a/tests/ui/entry.stderr b/tests/ui/entry.stderr
index 2c4c49d2522..e8a003e9cf6 100644
--- a/tests/ui/entry.stderr
+++ b/tests/ui/entry.stderr
@@ -4,7 +4,7 @@ error: usage of `contains_key` followed by `insert` on a `HashMap`
 LL | /     if !m.contains_key(&k) {
 LL | |         m.insert(k, v);
 LL | |     }
-   | |_____^ help: try this: `m.entry(k).or_insert(v);`
+   | |_____^ help: try: `m.entry(k).or_insert(v);`
    |
    = note: `-D clippy::map-entry` implied by `-D warnings`
 
@@ -20,7 +20,7 @@ LL | |         }
 LL | |     }
    | |_____^
    |
-help: try this
+help: try
    |
 LL ~     m.entry(k).or_insert_with(|| {
 LL +         if true {
@@ -43,7 +43,7 @@ LL | |         };
 LL | |     }
    | |_____^
    |
-help: try this
+help: try
    |
 LL ~     m.entry(k).or_insert_with(|| {
 LL +         if true {
@@ -66,7 +66,7 @@ LL | |         }
 LL | |     }
    | |_____^
    |
-help: try this
+help: try
    |
 LL ~     if let std::collections::hash_map::Entry::Vacant(e) = m.entry(k) {
 LL +         if true {
@@ -87,7 +87,7 @@ LL | |         m.insert(k, v);
 LL | |     }
    | |_____^
    |
-help: try this
+help: try
    |
 LL ~     m.entry(k).or_insert_with(|| {
 LL +         foo();
@@ -107,7 +107,7 @@ LL | |         };
 LL | |     }
    | |_____^
    |
-help: try this
+help: try
    |
 LL ~     m.entry(k).or_insert_with(|| {
 LL +         match 0 {
@@ -133,7 +133,7 @@ LL | |         };
 LL | |     }
    | |_____^
    |
-help: try this
+help: try
    |
 LL ~     if let std::collections::hash_map::Entry::Vacant(e) = m.entry(k) {
 LL +         match 0 {
@@ -157,7 +157,7 @@ LL | |         }
 LL | |     }
    | |_____^
    |
-help: try this
+help: try
    |
 LL ~     m.entry(k).or_insert_with(|| {
 LL +         foo();
@@ -192,7 +192,7 @@ error: usage of `contains_key` followed by `insert` on a `HashMap`
 LL | /     if !m.contains_key(&m!(k)) {
 LL | |         m.insert(m!(k), m!(v));
 LL | |     }
-   | |_____^ help: try this: `m.entry(m!(k)).or_insert_with(|| m!(v));`
+   | |_____^ help: try: `m.entry(m!(k)).or_insert_with(|| m!(v));`
 
 error: usage of `contains_key` followed by `insert` on a `HashMap`
   --> $DIR/entry.rs:152:5
@@ -204,7 +204,7 @@ LL | |         m.insert(k, v);
 LL | |     }
    | |_____^
    |
-help: try this
+help: try
    |
 LL ~     m.entry(k).or_insert_with(|| {
 LL +         let x = (String::new(), String::new());
diff --git a/tests/ui/entry_btree.stderr b/tests/ui/entry_btree.stderr
index 5c6fcdf1a28..8f41581d6b6 100644
--- a/tests/ui/entry_btree.stderr
+++ b/tests/ui/entry_btree.stderr
@@ -8,7 +8,7 @@ LL | |     }
    | |_____^
    |
    = note: `-D clippy::map-entry` implied by `-D warnings`
-help: try this
+help: try
    |
 LL ~     if let std::collections::btree_map::Entry::Vacant(e) = m.entry(k) {
 LL +         e.insert(v);
diff --git a/tests/ui/entry_with_else.stderr b/tests/ui/entry_with_else.stderr
index e0f6671b460..0d0eb964937 100644
--- a/tests/ui/entry_with_else.stderr
+++ b/tests/ui/entry_with_else.stderr
@@ -9,7 +9,7 @@ LL | |     }
    | |_____^
    |
    = note: `-D clippy::map-entry` implied by `-D warnings`
-help: try this
+help: try
    |
 LL ~     match m.entry(k) {
 LL +         std::collections::hash_map::Entry::Vacant(e) => {
@@ -31,7 +31,7 @@ LL | |         m.insert(k, v2);
 LL | |     }
    | |_____^
    |
-help: try this
+help: try
    |
 LL ~     match m.entry(k) {
 LL +         std::collections::hash_map::Entry::Occupied(mut e) => {
@@ -53,7 +53,7 @@ LL | |         foo();
 LL | |     }
    | |_____^
    |
-help: try this
+help: try
    |
 LL ~     if let std::collections::hash_map::Entry::Vacant(e) = m.entry(k) {
 LL +         e.insert(v);
@@ -72,7 +72,7 @@ LL | |         m.insert(k, v);
 LL | |     }
    | |_____^
    |
-help: try this
+help: try
    |
 LL ~     if let std::collections::hash_map::Entry::Occupied(mut e) = m.entry(k) {
 LL +         e.insert(v);
@@ -91,7 +91,7 @@ LL | |         m.insert(k, v2);
 LL | |     }
    | |_____^
    |
-help: try this
+help: try
    |
 LL ~     match m.entry(k) {
 LL +         std::collections::hash_map::Entry::Vacant(e) => {
@@ -113,7 +113,7 @@ LL | |         m.insert(k, v)
 LL | |     };
    | |_____^
    |
-help: try this
+help: try
    |
 LL ~     match m.entry(k) {
 LL +         std::collections::hash_map::Entry::Occupied(mut e) => {
@@ -137,7 +137,7 @@ LL | |         None
 LL | |     };
    | |_____^
    |
-help: try this
+help: try
    |
 LL ~     if let std::collections::hash_map::Entry::Occupied(mut e) = m.entry(k) {
 LL +         foo();
diff --git a/tests/ui/expect_fun_call.stderr b/tests/ui/expect_fun_call.stderr
index 36fb0e5de15..a621f681d98 100644
--- a/tests/ui/expect_fun_call.stderr
+++ b/tests/ui/expect_fun_call.stderr
@@ -2,7 +2,7 @@ error: use of `expect` followed by a function call
   --> $DIR/expect_fun_call.rs:38:26
    |
 LL |     with_none_and_format.expect(&format!("Error {}: fake error", error_code));
-   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|| panic!("Error {}: fake error", error_code))`
+   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| panic!("Error {}: fake error", error_code))`
    |
    = note: `-D clippy::expect-fun-call` implied by `-D warnings`
 
@@ -10,85 +10,85 @@ error: use of `expect` followed by a function call
   --> $DIR/expect_fun_call.rs:41:26
    |
 LL |     with_none_and_as_str.expect(format!("Error {}: fake error", error_code).as_str());
-   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|| panic!("Error {}: fake error", error_code))`
+   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| panic!("Error {}: fake error", error_code))`
 
 error: use of `expect` followed by a function call
   --> $DIR/expect_fun_call.rs:44:37
    |
 LL |     with_none_and_format_with_macro.expect(format!("Error {}: fake error", one!()).as_str());
-   |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|| panic!("Error {}: fake error", one!()))`
+   |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| panic!("Error {}: fake error", one!()))`
 
 error: use of `expect` followed by a function call
   --> $DIR/expect_fun_call.rs:54:25
    |
 LL |     with_err_and_format.expect(&format!("Error {}: fake error", error_code));
-   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|_| panic!("Error {}: fake error", error_code))`
+   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|_| panic!("Error {}: fake error", error_code))`
 
 error: use of `expect` followed by a function call
   --> $DIR/expect_fun_call.rs:57:25
    |
 LL |     with_err_and_as_str.expect(format!("Error {}: fake error", error_code).as_str());
-   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|_| panic!("Error {}: fake error", error_code))`
+   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|_| panic!("Error {}: fake error", error_code))`
 
 error: use of `expect` followed by a function call
   --> $DIR/expect_fun_call.rs:69:17
    |
 LL |     Some("foo").expect(format!("{} {}", 1, 2).as_ref());
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|| panic!("{} {}", 1, 2))`
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| panic!("{} {}", 1, 2))`
 
 error: use of `expect` followed by a function call
   --> $DIR/expect_fun_call.rs:90:21
    |
 LL |         Some("foo").expect(&get_string());
-   |                     ^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|| { panic!("{}", get_string()) })`
+   |                     ^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| { panic!("{}", get_string()) })`
 
 error: use of `expect` followed by a function call
   --> $DIR/expect_fun_call.rs:91:21
    |
 LL |         Some("foo").expect(get_string().as_ref());
-   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|| { panic!("{}", get_string()) })`
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| { panic!("{}", get_string()) })`
 
 error: use of `expect` followed by a function call
   --> $DIR/expect_fun_call.rs:92:21
    |
 LL |         Some("foo").expect(get_string().as_str());
-   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|| { panic!("{}", get_string()) })`
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| { panic!("{}", get_string()) })`
 
 error: use of `expect` followed by a function call
   --> $DIR/expect_fun_call.rs:94:21
    |
 LL |         Some("foo").expect(get_static_str());
-   |                     ^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|| { panic!("{}", get_static_str()) })`
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| { panic!("{}", get_static_str()) })`
 
 error: use of `expect` followed by a function call
   --> $DIR/expect_fun_call.rs:95:21
    |
 LL |         Some("foo").expect(get_non_static_str(&0));
-   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|| { panic!("{}", get_non_static_str(&0).to_string()) })`
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| { panic!("{}", get_non_static_str(&0).to_string()) })`
 
 error: use of `expect` followed by a function call
   --> $DIR/expect_fun_call.rs:99:16
    |
 LL |     Some(true).expect(&format!("key {}, {}", 1, 2));
-   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|| panic!("key {}, {}", 1, 2))`
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| panic!("key {}, {}", 1, 2))`
 
 error: use of `expect` followed by a function call
   --> $DIR/expect_fun_call.rs:105:17
    |
 LL |         opt_ref.expect(&format!("{:?}", opt_ref));
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|| panic!("{:?}", opt_ref))`
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| panic!("{:?}", opt_ref))`
 
 error: use of `expect` followed by a function call
   --> $DIR/expect_fun_call.rs:109:20
    |
 LL |     format_capture.expect(&format!("{error_code}"));
-   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|| panic!("{error_code}"))`
+   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| panic!("{error_code}"))`
 
 error: use of `expect` followed by a function call
   --> $DIR/expect_fun_call.rs:112:30
    |
 LL |     format_capture_and_value.expect(&format!("{error_code}, {}", 1));
-   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|| panic!("{error_code}, {}", 1))`
+   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| panic!("{error_code}, {}", 1))`
 
 error: aborting due to 15 previous errors
 
diff --git a/tests/ui/explicit_auto_deref.stderr b/tests/ui/explicit_auto_deref.stderr
index 91863abcc5d..afc311e3f7c 100644
--- a/tests/ui/explicit_auto_deref.stderr
+++ b/tests/ui/explicit_auto_deref.stderr
@@ -2,7 +2,7 @@ error: deref which would be done by auto-deref
   --> $DIR/explicit_auto_deref.rs:70:19
    |
 LL |     let _: &str = &*s;
-   |                   ^^^ help: try this: `&s`
+   |                   ^^^ help: try: `&s`
    |
    = note: `-D clippy::explicit-auto-deref` implied by `-D warnings`
 
@@ -10,229 +10,229 @@ error: deref which would be done by auto-deref
   --> $DIR/explicit_auto_deref.rs:71:19
    |
 LL |     let _: &str = &*{ String::new() };
-   |                   ^^^^^^^^^^^^^^^^^^^ help: try this: `&{ String::new() }`
+   |                   ^^^^^^^^^^^^^^^^^^^ help: try: `&{ String::new() }`
 
 error: deref which would be done by auto-deref
   --> $DIR/explicit_auto_deref.rs:72:19
    |
 LL |     let _: &str = &mut *{ String::new() };
-   |                   ^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&mut { String::new() }`
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&mut { String::new() }`
 
 error: deref which would be done by auto-deref
   --> $DIR/explicit_auto_deref.rs:76:11
    |
 LL |     f_str(&*s);
-   |           ^^^ help: try this: `&s`
+   |           ^^^ help: try: `&s`
 
 error: deref which would be done by auto-deref
   --> $DIR/explicit_auto_deref.rs:80:13
    |
 LL |     f_str_t(&*s, &*s); // Don't lint second param.
-   |             ^^^ help: try this: `&s`
+   |             ^^^ help: try: `&s`
 
 error: deref which would be done by auto-deref
   --> $DIR/explicit_auto_deref.rs:83:24
    |
 LL |     let _: &Box<i32> = &**b;
-   |                        ^^^^ help: try this: `&b`
+   |                        ^^^^ help: try: `&b`
 
 error: deref which would be done by auto-deref
   --> $DIR/explicit_auto_deref.rs:89:7
    |
 LL |     c(&*s);
-   |       ^^^ help: try this: `&s`
+   |       ^^^ help: try: `&s`
 
 error: deref which would be done by auto-deref
   --> $DIR/explicit_auto_deref.rs:95:9
    |
 LL |         &**x
-   |         ^^^^ help: try this: `x`
+   |         ^^^^ help: try: `x`
 
 error: deref which would be done by auto-deref
   --> $DIR/explicit_auto_deref.rs:99:11
    |
 LL |         { &**x }
-   |           ^^^^ help: try this: `x`
+   |           ^^^^ help: try: `x`
 
 error: deref which would be done by auto-deref
   --> $DIR/explicit_auto_deref.rs:103:9
    |
 LL |         &**{ x }
-   |         ^^^^^^^^ help: try this: `{ x }`
+   |         ^^^^^^^^ help: try: `{ x }`
 
 error: deref which would be done by auto-deref
   --> $DIR/explicit_auto_deref.rs:107:9
    |
 LL |         &***x
-   |         ^^^^^ help: try this: `x`
+   |         ^^^^^ help: try: `x`
 
 error: deref which would be done by auto-deref
   --> $DIR/explicit_auto_deref.rs:124:12
    |
 LL |         f1(&*x);
-   |            ^^^ help: try this: `&x`
+   |            ^^^ help: try: `&x`
 
 error: deref which would be done by auto-deref
   --> $DIR/explicit_auto_deref.rs:125:12
    |
 LL |         f2(&*x);
-   |            ^^^ help: try this: `&x`
+   |            ^^^ help: try: `&x`
 
 error: deref which would be done by auto-deref
   --> $DIR/explicit_auto_deref.rs:126:12
    |
 LL |         f3(&*x);
-   |            ^^^ help: try this: `&x`
+   |            ^^^ help: try: `&x`
 
 error: deref which would be done by auto-deref
   --> $DIR/explicit_auto_deref.rs:127:27
    |
 LL |         f4.callable_str()(&*x);
-   |                           ^^^ help: try this: `&x`
+   |                           ^^^ help: try: `&x`
 
 error: deref which would be done by auto-deref
   --> $DIR/explicit_auto_deref.rs:128:12
    |
 LL |         f5(&*x);
-   |            ^^^ help: try this: `&x`
+   |            ^^^ help: try: `&x`
 
 error: deref which would be done by auto-deref
   --> $DIR/explicit_auto_deref.rs:129:12
    |
 LL |         f6(&*x);
-   |            ^^^ help: try this: `&x`
+   |            ^^^ help: try: `&x`
 
 error: deref which would be done by auto-deref
   --> $DIR/explicit_auto_deref.rs:130:27
    |
 LL |         f7.callable_str()(&*x);
-   |                           ^^^ help: try this: `&x`
+   |                           ^^^ help: try: `&x`
 
 error: deref which would be done by auto-deref
   --> $DIR/explicit_auto_deref.rs:131:25
    |
 LL |         f8.callable_t()(&*x);
-   |                         ^^^ help: try this: `&x`
+   |                         ^^^ help: try: `&x`
 
 error: deref which would be done by auto-deref
   --> $DIR/explicit_auto_deref.rs:132:12
    |
 LL |         f9(&*x);
-   |            ^^^ help: try this: `&x`
+   |            ^^^ help: try: `&x`
 
 error: deref which would be done by auto-deref
   --> $DIR/explicit_auto_deref.rs:133:13
    |
 LL |         f10(&*x);
-   |             ^^^ help: try this: `&x`
+   |             ^^^ help: try: `&x`
 
 error: deref which would be done by auto-deref
   --> $DIR/explicit_auto_deref.rs:134:26
    |
 LL |         f11.callable_t()(&*x);
-   |                          ^^^ help: try this: `&x`
+   |                          ^^^ help: try: `&x`
 
 error: deref which would be done by auto-deref
   --> $DIR/explicit_auto_deref.rs:138:16
    |
 LL |     let _ = S1(&*s);
-   |                ^^^ help: try this: `&s`
+   |                ^^^ help: try: `&s`
 
 error: deref which would be done by auto-deref
   --> $DIR/explicit_auto_deref.rs:143:21
    |
 LL |     let _ = S2 { s: &*s };
-   |                     ^^^ help: try this: `&s`
+   |                     ^^^ help: try: `&s`
 
 error: deref which would be done by auto-deref
   --> $DIR/explicit_auto_deref.rs:159:30
    |
 LL |             let _ = Self::S1(&**s);
-   |                              ^^^^ help: try this: `s`
+   |                              ^^^^ help: try: `s`
 
 error: deref which would be done by auto-deref
   --> $DIR/explicit_auto_deref.rs:160:35
    |
 LL |             let _ = Self::S2 { s: &**s };
-   |                                   ^^^^ help: try this: `s`
+   |                                   ^^^^ help: try: `s`
 
 error: deref which would be done by auto-deref
   --> $DIR/explicit_auto_deref.rs:163:20
    |
 LL |     let _ = E1::S1(&*s);
-   |                    ^^^ help: try this: `&s`
+   |                    ^^^ help: try: `&s`
 
 error: deref which would be done by auto-deref
   --> $DIR/explicit_auto_deref.rs:164:25
    |
 LL |     let _ = E1::S2 { s: &*s };
-   |                         ^^^ help: try this: `&s`
+   |                         ^^^ help: try: `&s`
 
 error: deref which would be done by auto-deref
   --> $DIR/explicit_auto_deref.rs:182:13
    |
 LL |     let _ = (*b).foo;
-   |             ^^^^ help: try this: `b`
+   |             ^^^^ help: try: `b`
 
 error: deref which would be done by auto-deref
   --> $DIR/explicit_auto_deref.rs:183:13
    |
 LL |     let _ = (**b).foo;
-   |             ^^^^^ help: try this: `b`
+   |             ^^^^^ help: try: `b`
 
 error: deref which would be done by auto-deref
   --> $DIR/explicit_auto_deref.rs:198:19
    |
 LL |     let _ = f_str(*ref_str);
-   |                   ^^^^^^^^ help: try this: `ref_str`
+   |                   ^^^^^^^^ help: try: `ref_str`
 
 error: deref which would be done by auto-deref
   --> $DIR/explicit_auto_deref.rs:200:19
    |
 LL |     let _ = f_str(**ref_ref_str);
-   |                   ^^^^^^^^^^^^^ help: try this: `ref_ref_str`
+   |                   ^^^^^^^^^^^^^ help: try: `ref_ref_str`
 
 error: deref which would be done by auto-deref
   --> $DIR/explicit_auto_deref.rs:210:13
    |
 LL |     f_str(&&*ref_str); // `needless_borrow` will suggest removing both references
-   |             ^^^^^^^^ help: try this: `ref_str`
+   |             ^^^^^^^^ help: try: `ref_str`
 
 error: deref which would be done by auto-deref
   --> $DIR/explicit_auto_deref.rs:211:12
    |
 LL |     f_str(&&**ref_str); // `needless_borrow` will suggest removing only one reference
-   |            ^^^^^^^^^^ help: try this: `ref_str`
+   |            ^^^^^^^^^^ help: try: `ref_str`
 
 error: deref which would be done by auto-deref
   --> $DIR/explicit_auto_deref.rs:220:41
    |
 LL |     let _ = || -> &'static str { return *s };
-   |                                         ^^ help: try this: `s`
+   |                                         ^^ help: try: `s`
 
 error: deref which would be done by auto-deref
   --> $DIR/explicit_auto_deref.rs:239:9
    |
 LL |         &**x
-   |         ^^^^ help: try this: `x`
+   |         ^^^^ help: try: `x`
 
 error: deref which would be done by auto-deref
   --> $DIR/explicit_auto_deref.rs:262:8
    |
 LL |     c1(*x);
-   |        ^^ help: try this: `x`
+   |        ^^ help: try: `x`
 
 error: deref which would be done by auto-deref
   --> $DIR/explicit_auto_deref.rs:265:20
    |
 LL |             return *x;
-   |                    ^^ help: try this: `x`
+   |                    ^^ help: try: `x`
 
 error: deref which would be done by auto-deref
   --> $DIR/explicit_auto_deref.rs:267:9
    |
 LL |         *x
-   |         ^^ help: try this: `x`
+   |         ^^ help: try: `x`
 
 error: aborting due to 39 previous errors
 
diff --git a/tests/ui/explicit_deref_methods.stderr b/tests/ui/explicit_deref_methods.stderr
index d025035b789..362e559b21a 100644
--- a/tests/ui/explicit_deref_methods.stderr
+++ b/tests/ui/explicit_deref_methods.stderr
@@ -2,7 +2,7 @@ error: explicit `deref` method call
   --> $DIR/explicit_deref_methods.rs:54:19
    |
 LL |     let b: &str = a.deref();
-   |                   ^^^^^^^^^ help: try this: `&*a`
+   |                   ^^^^^^^^^ help: try: `&*a`
    |
    = note: `-D clippy::explicit-deref-methods` implied by `-D warnings`
 
@@ -10,67 +10,67 @@ error: explicit `deref_mut` method call
   --> $DIR/explicit_deref_methods.rs:56:23
    |
 LL |     let b: &mut str = a.deref_mut();
-   |                       ^^^^^^^^^^^^^ help: try this: `&mut **a`
+   |                       ^^^^^^^^^^^^^ help: try: `&mut **a`
 
 error: explicit `deref` method call
   --> $DIR/explicit_deref_methods.rs:59:39
    |
 LL |     let b: String = format!("{}, {}", a.deref(), a.deref());
-   |                                       ^^^^^^^^^ help: try this: `&*a`
+   |                                       ^^^^^^^^^ help: try: `&*a`
 
 error: explicit `deref` method call
   --> $DIR/explicit_deref_methods.rs:59:50
    |
 LL |     let b: String = format!("{}, {}", a.deref(), a.deref());
-   |                                                  ^^^^^^^^^ help: try this: `&*a`
+   |                                                  ^^^^^^^^^ help: try: `&*a`
 
 error: explicit `deref` method call
   --> $DIR/explicit_deref_methods.rs:61:20
    |
 LL |     println!("{}", a.deref());
-   |                    ^^^^^^^^^ help: try this: `&*a`
+   |                    ^^^^^^^^^ help: try: `&*a`
 
 error: explicit `deref` method call
   --> $DIR/explicit_deref_methods.rs:64:11
    |
 LL |     match a.deref() {
-   |           ^^^^^^^^^ help: try this: `&*a`
+   |           ^^^^^^^^^ help: try: `&*a`
 
 error: explicit `deref` method call
   --> $DIR/explicit_deref_methods.rs:68:28
    |
 LL |     let b: String = concat(a.deref());
-   |                            ^^^^^^^^^ help: try this: `&*a`
+   |                            ^^^^^^^^^ help: try: `&*a`
 
 error: explicit `deref` method call
   --> $DIR/explicit_deref_methods.rs:70:13
    |
 LL |     let b = just_return(a).deref();
-   |             ^^^^^^^^^^^^^^^^^^^^^^ help: try this: `just_return(a)`
+   |             ^^^^^^^^^^^^^^^^^^^^^^ help: try: `just_return(a)`
 
 error: explicit `deref` method call
   --> $DIR/explicit_deref_methods.rs:72:28
    |
 LL |     let b: String = concat(just_return(a).deref());
-   |                            ^^^^^^^^^^^^^^^^^^^^^^ help: try this: `just_return(a)`
+   |                            ^^^^^^^^^^^^^^^^^^^^^^ help: try: `just_return(a)`
 
 error: explicit `deref` method call
   --> $DIR/explicit_deref_methods.rs:74:19
    |
 LL |     let b: &str = a.deref().deref();
-   |                   ^^^^^^^^^^^^^^^^^ help: try this: `&**a`
+   |                   ^^^^^^^^^^^^^^^^^ help: try: `&**a`
 
 error: explicit `deref` method call
   --> $DIR/explicit_deref_methods.rs:77:13
    |
 LL |     let b = opt_a.unwrap().deref();
-   |             ^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&*opt_a.unwrap()`
+   |             ^^^^^^^^^^^^^^^^^^^^^^ help: try: `&*opt_a.unwrap()`
 
 error: explicit `deref` method call
   --> $DIR/explicit_deref_methods.rs:114:31
    |
 LL |     let b: &str = expr_deref!(a.deref());
-   |                               ^^^^^^^^^ help: try this: `&*a`
+   |                               ^^^^^^^^^ help: try: `&*a`
 
 error: aborting due to 12 previous errors
 
diff --git a/tests/ui/explicit_write.stderr b/tests/ui/explicit_write.stderr
index 457e9c62718..b3aa7274c6d 100644
--- a/tests/ui/explicit_write.stderr
+++ b/tests/ui/explicit_write.stderr
@@ -2,7 +2,7 @@ error: use of `write!(stdout(), ...).unwrap()`
   --> $DIR/explicit_write.rs:24:9
    |
 LL |         write!(std::io::stdout(), "test").unwrap();
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `print!("test")`
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `print!("test")`
    |
    = note: `-D clippy::explicit-write` implied by `-D warnings`
 
@@ -10,73 +10,73 @@ error: use of `write!(stderr(), ...).unwrap()`
   --> $DIR/explicit_write.rs:25:9
    |
 LL |         write!(std::io::stderr(), "test").unwrap();
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `eprint!("test")`
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `eprint!("test")`
 
 error: use of `writeln!(stdout(), ...).unwrap()`
   --> $DIR/explicit_write.rs:26:9
    |
 LL |         writeln!(std::io::stdout(), "test").unwrap();
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `println!("test")`
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `println!("test")`
 
 error: use of `writeln!(stderr(), ...).unwrap()`
   --> $DIR/explicit_write.rs:27:9
    |
 LL |         writeln!(std::io::stderr(), "test").unwrap();
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `eprintln!("test")`
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `eprintln!("test")`
 
 error: use of `stdout().write_fmt(...).unwrap()`
   --> $DIR/explicit_write.rs:28:9
    |
 LL |         std::io::stdout().write_fmt(format_args!("test")).unwrap();
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `print!("test")`
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `print!("test")`
 
 error: use of `stderr().write_fmt(...).unwrap()`
   --> $DIR/explicit_write.rs:29:9
    |
 LL |         std::io::stderr().write_fmt(format_args!("test")).unwrap();
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `eprint!("test")`
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `eprint!("test")`
 
 error: use of `writeln!(stdout(), ...).unwrap()`
   --> $DIR/explicit_write.rs:32:9
    |
 LL |         writeln!(std::io::stdout(), "test/ntest").unwrap();
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `println!("test/ntest")`
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `println!("test/ntest")`
 
 error: use of `writeln!(stderr(), ...).unwrap()`
   --> $DIR/explicit_write.rs:33:9
    |
 LL |         writeln!(std::io::stderr(), "test/ntest").unwrap();
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `eprintln!("test/ntest")`
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `eprintln!("test/ntest")`
 
 error: use of `writeln!(stderr(), ...).unwrap()`
   --> $DIR/explicit_write.rs:36:9
    |
 LL |         writeln!(std::io::stderr(), "with {}", value).unwrap();
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `eprintln!("with {}", value)`
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `eprintln!("with {}", value)`
 
 error: use of `writeln!(stderr(), ...).unwrap()`
   --> $DIR/explicit_write.rs:37:9
    |
 LL |         writeln!(std::io::stderr(), "with {} {}", 2, value).unwrap();
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `eprintln!("with {} {}", 2, value)`
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `eprintln!("with {} {}", 2, value)`
 
 error: use of `writeln!(stderr(), ...).unwrap()`
   --> $DIR/explicit_write.rs:38:9
    |
 LL |         writeln!(std::io::stderr(), "with {value}").unwrap();
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `eprintln!("with {value}")`
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `eprintln!("with {value}")`
 
 error: use of `writeln!(stderr(), ...).unwrap()`
   --> $DIR/explicit_write.rs:39:9
    |
 LL |         writeln!(std::io::stderr(), "macro arg {}", one!()).unwrap();
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `eprintln!("macro arg {}", one!())`
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `eprintln!("macro arg {}", one!())`
 
 error: use of `writeln!(stderr(), ...).unwrap()`
   --> $DIR/explicit_write.rs:41:9
    |
 LL |         writeln!(std::io::stderr(), "{:w$}", value, w = width).unwrap();
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `eprintln!("{:w$}", value, w = width)`
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `eprintln!("{:w$}", value, w = width)`
 
 error: aborting due to 13 previous errors
 
diff --git a/tests/ui/extend_with_drain.stderr b/tests/ui/extend_with_drain.stderr
index da14ddb25b3..eb2dd304d37 100644
--- a/tests/ui/extend_with_drain.stderr
+++ b/tests/ui/extend_with_drain.stderr
@@ -2,7 +2,7 @@ error: use of `extend` instead of `append` for adding the full range of a second
   --> $DIR/extend_with_drain.rs:9:5
    |
 LL |     vec2.extend(vec1.drain(..));
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `vec2.append(&mut vec1)`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec2.append(&mut vec1)`
    |
    = note: `-D clippy::extend-with-drain` implied by `-D warnings`
 
@@ -10,19 +10,19 @@ error: use of `extend` instead of `append` for adding the full range of a second
   --> $DIR/extend_with_drain.rs:14:5
    |
 LL |     vec4.extend(vec3.drain(..));
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `vec4.append(&mut vec3)`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec4.append(&mut vec3)`
 
 error: use of `extend` instead of `append` for adding the full range of a second vector
   --> $DIR/extend_with_drain.rs:18:5
    |
 LL |     vec11.extend(return_vector().drain(..));
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `vec11.append(&mut return_vector())`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec11.append(&mut return_vector())`
 
 error: use of `extend` instead of `append` for adding the full range of a second vector
   --> $DIR/extend_with_drain.rs:49:5
    |
 LL |     y.extend(ref_x.drain(..));
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `y.append(ref_x)`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `y.append(ref_x)`
 
 error: aborting due to 4 previous errors
 
diff --git a/tests/ui/filter_map_next_fixable.stderr b/tests/ui/filter_map_next_fixable.stderr
index a9fc6abe88f..26d9c5e19da 100644
--- a/tests/ui/filter_map_next_fixable.stderr
+++ b/tests/ui/filter_map_next_fixable.stderr
@@ -2,7 +2,7 @@ error: called `filter_map(..).next()` on an `Iterator`. This is more succinctly
   --> $DIR/filter_map_next_fixable.rs:9:32
    |
 LL |     let element: Option<i32> = a.iter().filter_map(|s| s.parse().ok()).next();
-   |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `a.iter().find_map(|s| s.parse().ok())`
+   |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `a.iter().find_map(|s| s.parse().ok())`
    |
    = note: `-D clippy::filter-map-next` implied by `-D warnings`
 
@@ -10,7 +10,7 @@ error: called `filter_map(..).next()` on an `Iterator`. This is more succinctly
   --> $DIR/filter_map_next_fixable.rs:22:26
    |
 LL |     let _: Option<i32> = a.iter().filter_map(|s| s.parse().ok()).next();
-   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `a.iter().find_map(|s| s.parse().ok())`
+   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `a.iter().find_map(|s| s.parse().ok())`
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/get_unwrap.stderr b/tests/ui/get_unwrap.stderr
index fd961420dc4..e705bebac57 100644
--- a/tests/ui/get_unwrap.stderr
+++ b/tests/ui/get_unwrap.stderr
@@ -2,7 +2,7 @@ error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more co
   --> $DIR/get_unwrap.rs:40:17
    |
 LL |         let _ = boxed_slice.get(1).unwrap();
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&boxed_slice[1]`
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&boxed_slice[1]`
    |
 note: the lint level is defined here
   --> $DIR/get_unwrap.rs:10:9
@@ -23,7 +23,7 @@ error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more co
   --> $DIR/get_unwrap.rs:41:17
    |
 LL |         let _ = some_slice.get(0).unwrap();
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&some_slice[0]`
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&some_slice[0]`
 
 error: used `unwrap()` on an `Option` value
   --> $DIR/get_unwrap.rs:41:17
@@ -37,7 +37,7 @@ error: called `.get().unwrap()` on a Vec. Using `[]` is more clear and more conc
   --> $DIR/get_unwrap.rs:42:17
    |
 LL |         let _ = some_vec.get(0).unwrap();
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&some_vec[0]`
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&some_vec[0]`
 
 error: used `unwrap()` on an `Option` value
   --> $DIR/get_unwrap.rs:42:17
@@ -51,7 +51,7 @@ error: called `.get().unwrap()` on a VecDeque. Using `[]` is more clear and more
   --> $DIR/get_unwrap.rs:43:17
    |
 LL |         let _ = some_vecdeque.get(0).unwrap();
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&some_vecdeque[0]`
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&some_vecdeque[0]`
 
 error: used `unwrap()` on an `Option` value
   --> $DIR/get_unwrap.rs:43:17
@@ -65,7 +65,7 @@ error: called `.get().unwrap()` on a HashMap. Using `[]` is more clear and more
   --> $DIR/get_unwrap.rs:44:17
    |
 LL |         let _ = some_hashmap.get(&1).unwrap();
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&some_hashmap[&1]`
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&some_hashmap[&1]`
 
 error: used `unwrap()` on an `Option` value
   --> $DIR/get_unwrap.rs:44:17
@@ -79,7 +79,7 @@ error: called `.get().unwrap()` on a BTreeMap. Using `[]` is more clear and more
   --> $DIR/get_unwrap.rs:45:17
    |
 LL |         let _ = some_btreemap.get(&1).unwrap();
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&some_btreemap[&1]`
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&some_btreemap[&1]`
 
 error: used `unwrap()` on an `Option` value
   --> $DIR/get_unwrap.rs:45:17
@@ -93,7 +93,7 @@ error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more co
   --> $DIR/get_unwrap.rs:49:21
    |
 LL |         let _: u8 = *boxed_slice.get(1).unwrap();
-   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `boxed_slice[1]`
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `boxed_slice[1]`
 
 error: used `unwrap()` on an `Option` value
   --> $DIR/get_unwrap.rs:49:22
@@ -107,7 +107,7 @@ error: called `.get_mut().unwrap()` on a slice. Using `[]` is more clear and mor
   --> $DIR/get_unwrap.rs:54:9
    |
 LL |         *boxed_slice.get_mut(0).unwrap() = 1;
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `boxed_slice[0]`
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `boxed_slice[0]`
 
 error: used `unwrap()` on an `Option` value
   --> $DIR/get_unwrap.rs:54:10
@@ -121,7 +121,7 @@ error: called `.get_mut().unwrap()` on a slice. Using `[]` is more clear and mor
   --> $DIR/get_unwrap.rs:55:9
    |
 LL |         *some_slice.get_mut(0).unwrap() = 1;
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `some_slice[0]`
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `some_slice[0]`
 
 error: used `unwrap()` on an `Option` value
   --> $DIR/get_unwrap.rs:55:10
@@ -135,7 +135,7 @@ error: called `.get_mut().unwrap()` on a Vec. Using `[]` is more clear and more
   --> $DIR/get_unwrap.rs:56:9
    |
 LL |         *some_vec.get_mut(0).unwrap() = 1;
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `some_vec[0]`
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `some_vec[0]`
 
 error: used `unwrap()` on an `Option` value
   --> $DIR/get_unwrap.rs:56:10
@@ -149,7 +149,7 @@ error: called `.get_mut().unwrap()` on a VecDeque. Using `[]` is more clear and
   --> $DIR/get_unwrap.rs:57:9
    |
 LL |         *some_vecdeque.get_mut(0).unwrap() = 1;
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `some_vecdeque[0]`
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `some_vecdeque[0]`
 
 error: used `unwrap()` on an `Option` value
   --> $DIR/get_unwrap.rs:57:10
@@ -163,7 +163,7 @@ error: called `.get().unwrap()` on a Vec. Using `[]` is more clear and more conc
   --> $DIR/get_unwrap.rs:69:17
    |
 LL |         let _ = some_vec.get(0..1).unwrap().to_vec();
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `some_vec[0..1]`
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `some_vec[0..1]`
 
 error: used `unwrap()` on an `Option` value
   --> $DIR/get_unwrap.rs:69:17
@@ -177,7 +177,7 @@ error: called `.get_mut().unwrap()` on a Vec. Using `[]` is more clear and more
   --> $DIR/get_unwrap.rs:70:17
    |
 LL |         let _ = some_vec.get_mut(0..1).unwrap().to_vec();
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `some_vec[0..1]`
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `some_vec[0..1]`
 
 error: used `unwrap()` on an `Option` value
   --> $DIR/get_unwrap.rs:70:17
@@ -191,25 +191,25 @@ error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more co
   --> $DIR/get_unwrap.rs:80:24
    |
 LL |         let _x: &i32 = f.get(1 + 2).unwrap();
-   |                        ^^^^^^^^^^^^^^^^^^^^^ help: try this: `&f[1 + 2]`
+   |                        ^^^^^^^^^^^^^^^^^^^^^ help: try: `&f[1 + 2]`
 
 error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more concise
   --> $DIR/get_unwrap.rs:83:18
    |
 LL |         let _x = f.get(1 + 2).unwrap().to_string();
-   |                  ^^^^^^^^^^^^^^^^^^^^^ help: try this: `f[1 + 2]`
+   |                  ^^^^^^^^^^^^^^^^^^^^^ help: try: `f[1 + 2]`
 
 error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more concise
   --> $DIR/get_unwrap.rs:86:18
    |
 LL |         let _x = f.get(1 + 2).unwrap().abs();
-   |                  ^^^^^^^^^^^^^^^^^^^^^ help: try this: `f[1 + 2]`
+   |                  ^^^^^^^^^^^^^^^^^^^^^ help: try: `f[1 + 2]`
 
 error: called `.get_mut().unwrap()` on a slice. Using `[]` is more clear and more concise
   --> $DIR/get_unwrap.rs:103:33
    |
 LL |                         let b = rest.get_mut(linidx(j, k) - linidx(i, k) - 1).unwrap();
-   |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&mut rest[linidx(j, k) - linidx(i, k) - 1]`
+   |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&mut rest[linidx(j, k) - linidx(i, k) - 1]`
 
 error: aborting due to 30 previous errors
 
diff --git a/tests/ui/infallible_destructuring_match.stderr b/tests/ui/infallible_destructuring_match.stderr
index f8a50f0223d..004260a1d64 100644
--- a/tests/ui/infallible_destructuring_match.stderr
+++ b/tests/ui/infallible_destructuring_match.stderr
@@ -4,7 +4,7 @@ error: you seem to be trying to use `match` to destructure a single infallible p
 LL | /     let data = match wrapper {
 LL | |         SingleVariantEnum::Variant(i) => i,
 LL | |     };
-   | |______^ help: try this: `let SingleVariantEnum::Variant(data) = wrapper;`
+   | |______^ help: try: `let SingleVariantEnum::Variant(data) = wrapper;`
    |
    = note: `-D clippy::infallible-destructuring-match` implied by `-D warnings`
 
@@ -14,7 +14,7 @@ error: you seem to be trying to use `match` to destructure a single infallible p
 LL | /     let data = match wrapper {
 LL | |         TupleStruct(i) => i,
 LL | |     };
-   | |______^ help: try this: `let TupleStruct(data) = wrapper;`
+   | |______^ help: try: `let TupleStruct(data) = wrapper;`
 
 error: you seem to be trying to use `match` to destructure a single infallible pattern. Consider using `let`
   --> $DIR/infallible_destructuring_match.rs:85:5
@@ -22,7 +22,7 @@ error: you seem to be trying to use `match` to destructure a single infallible p
 LL | /     let data = match wrapper {
 LL | |         TupleStructWithNonCopy(ref n) => n,
 LL | |     };
-   | |______^ help: try this: `let TupleStructWithNonCopy(ref data) = wrapper;`
+   | |______^ help: try: `let TupleStructWithNonCopy(ref data) = wrapper;`
 
 error: you seem to be trying to use `match` to destructure a single infallible pattern. Consider using `let`
   --> $DIR/infallible_destructuring_match.rs:104:5
@@ -30,7 +30,7 @@ error: you seem to be trying to use `match` to destructure a single infallible p
 LL | /     let data = match wrapper {
 LL | |         Ok(i) => i,
 LL | |     };
-   | |______^ help: try this: `let Ok(data) = wrapper;`
+   | |______^ help: try: `let Ok(data) = wrapper;`
 
 error: aborting due to 4 previous errors
 
diff --git a/tests/ui/iter_overeager_cloned.stderr b/tests/ui/iter_overeager_cloned.stderr
index dcae7cecd33..eaac48be880 100644
--- a/tests/ui/iter_overeager_cloned.stderr
+++ b/tests/ui/iter_overeager_cloned.stderr
@@ -4,7 +4,7 @@ error: unnecessarily eager cloning of iterator items
 LL |     let _: Option<String> = vec.iter().cloned().last();
    |                             ^^^^^^^^^^----------------
    |                                       |
-   |                                       help: try this: `.last().cloned()`
+   |                                       help: try: `.last().cloned()`
    |
    = note: `-D clippy::iter-overeager-cloned` implied by `-D warnings`
 
@@ -14,7 +14,7 @@ error: unnecessarily eager cloning of iterator items
 LL |     let _: Option<String> = vec.iter().chain(vec.iter()).cloned().next();
    |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^----------------
    |                                                         |
-   |                                                         help: try this: `.next().cloned()`
+   |                                                         help: try: `.next().cloned()`
 
 error: unneeded cloning of iterator items
   --> $DIR/iter_overeager_cloned.rs:12:20
@@ -22,7 +22,7 @@ error: unneeded cloning of iterator items
 LL |     let _: usize = vec.iter().filter(|x| x == &"2").cloned().count();
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-----------------
    |                                                    |
-   |                                                    help: try this: `.count()`
+   |                                                    help: try: `.count()`
    |
    = note: `-D clippy::redundant-clone` implied by `-D warnings`
 
@@ -32,7 +32,7 @@ error: unnecessarily eager cloning of iterator items
 LL |     let _: Vec<_> = vec.iter().cloned().take(2).collect();
    |                     ^^^^^^^^^^-----------------
    |                               |
-   |                               help: try this: `.take(2).cloned()`
+   |                               help: try: `.take(2).cloned()`
 
 error: unnecessarily eager cloning of iterator items
   --> $DIR/iter_overeager_cloned.rs:16:21
@@ -40,7 +40,7 @@ error: unnecessarily eager cloning of iterator items
 LL |     let _: Vec<_> = vec.iter().cloned().skip(2).collect();
    |                     ^^^^^^^^^^-----------------
    |                               |
-   |                               help: try this: `.skip(2).cloned()`
+   |                               help: try: `.skip(2).cloned()`
 
 error: unnecessarily eager cloning of iterator items
   --> $DIR/iter_overeager_cloned.rs:18:13
@@ -48,7 +48,7 @@ error: unnecessarily eager cloning of iterator items
 LL |     let _ = vec.iter().filter(|x| x == &"2").cloned().nth(2);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^----------------
    |                                             |
-   |                                             help: try this: `.nth(2).cloned()`
+   |                                             help: try: `.nth(2).cloned()`
 
 error: unnecessarily eager cloning of iterator items
   --> $DIR/iter_overeager_cloned.rs:20:13
@@ -60,7 +60,7 @@ LL | |         .cloned()
 LL | |         .flatten();
    | |__________________^
    |
-help: try this
+help: try
    |
 LL ~         .iter()
 LL ~         .flatten().cloned();
diff --git a/tests/ui/iter_with_drain.stderr b/tests/ui/iter_with_drain.stderr
index aa394439fa6..bfaed29a099 100644
--- a/tests/ui/iter_with_drain.stderr
+++ b/tests/ui/iter_with_drain.stderr
@@ -2,7 +2,7 @@ error: `drain(..)` used on a `Vec`
   --> $DIR/iter_with_drain.rs:11:34
    |
 LL |     let mut a: BinaryHeap<_> = a.drain(..).collect();
-   |                                  ^^^^^^^^^ help: try this: `into_iter()`
+   |                                  ^^^^^^^^^ help: try: `into_iter()`
    |
    = note: `-D clippy::iter-with-drain` implied by `-D warnings`
 
@@ -10,31 +10,31 @@ error: `drain(..)` used on a `VecDeque`
   --> $DIR/iter_with_drain.rs:14:27
    |
 LL |     let mut a: Vec<_> = a.drain(..).collect();
-   |                           ^^^^^^^^^ help: try this: `into_iter()`
+   |                           ^^^^^^^^^ help: try: `into_iter()`
 
 error: `drain(..)` used on a `Vec`
   --> $DIR/iter_with_drain.rs:15:34
    |
 LL |     let mut a: HashMap<_, _> = a.drain(..).map(|x| (x.clone(), x)).collect();
-   |                                  ^^^^^^^^^ help: try this: `into_iter()`
+   |                                  ^^^^^^^^^ help: try: `into_iter()`
 
 error: `drain(..)` used on a `Vec`
   --> $DIR/iter_with_drain.rs:21:34
    |
 LL |     let mut a: BinaryHeap<_> = a.drain(0..).collect();
-   |                                  ^^^^^^^^^^ help: try this: `into_iter()`
+   |                                  ^^^^^^^^^^ help: try: `into_iter()`
 
 error: `drain(..)` used on a `VecDeque`
   --> $DIR/iter_with_drain.rs:24:27
    |
 LL |     let mut a: Vec<_> = a.drain(..a.len()).collect();
-   |                           ^^^^^^^^^^^^^^^^ help: try this: `into_iter()`
+   |                           ^^^^^^^^^^^^^^^^ help: try: `into_iter()`
 
 error: `drain(..)` used on a `Vec`
   --> $DIR/iter_with_drain.rs:25:34
    |
 LL |     let mut a: HashMap<_, _> = a.drain(0..a.len()).map(|x| (x.clone(), x)).collect();
-   |                                  ^^^^^^^^^^^^^^^^^ help: try this: `into_iter()`
+   |                                  ^^^^^^^^^^^^^^^^^ help: try: `into_iter()`
 
 error: aborting due to 6 previous errors
 
diff --git a/tests/ui/manual_filter.stderr b/tests/ui/manual_filter.stderr
index 53dea922930..f62d3e96059 100644
--- a/tests/ui/manual_filter.stderr
+++ b/tests/ui/manual_filter.stderr
@@ -8,7 +8,7 @@ LL | |             if x > 0 {
 ...  |
 LL | |         },
 LL | |     };
-   | |_____^ help: try this: `Some(0).filter(|&x| x <= 0)`
+   | |_____^ help: try: `Some(0).filter(|&x| x <= 0)`
    |
    = note: `-D clippy::manual-filter` implied by `-D warnings`
 
@@ -22,7 +22,7 @@ LL | |                 None
 ...  |
 LL | |         None => None,
 LL | |     };
-   | |_____^ help: try this: `Some(1).filter(|&x| x <= 0)`
+   | |_____^ help: try: `Some(1).filter(|&x| x <= 0)`
 
 error: manual implementation of `Option::filter`
   --> $DIR/manual_filter.rs:29:5
@@ -34,7 +34,7 @@ LL | |                 None
 ...  |
 LL | |         _ => None,
 LL | |     };
-   | |_____^ help: try this: `Some(2).filter(|&x| x <= 0)`
+   | |_____^ help: try: `Some(2).filter(|&x| x <= 0)`
 
 error: manual implementation of `Option::filter`
   --> $DIR/manual_filter.rs:40:5
@@ -46,7 +46,7 @@ LL | |                 Some(x)
 ...  |
 LL | |         None => None,
 LL | |     };
-   | |_____^ help: try this: `Some(3).filter(|&x| x > 0)`
+   | |_____^ help: try: `Some(3).filter(|&x| x > 0)`
 
 error: manual implementation of `Option::filter`
   --> $DIR/manual_filter.rs:52:5
@@ -58,7 +58,7 @@ LL | |         Some(x) => {
 ...  |
 LL | |         },
 LL | |     };
-   | |_____^ help: try this: `y.filter(|&x| x <= 0)`
+   | |_____^ help: try: `y.filter(|&x| x <= 0)`
 
 error: manual implementation of `Option::filter`
   --> $DIR/manual_filter.rs:64:5
@@ -70,7 +70,7 @@ LL | |                 Some(x)
 ...  |
 LL | |         _ => None,
 LL | |     };
-   | |_____^ help: try this: `Some(5).filter(|&x| x > 0)`
+   | |_____^ help: try: `Some(5).filter(|&x| x > 0)`
 
 error: manual implementation of `Option::filter`
   --> $DIR/manual_filter.rs:75:5
@@ -82,7 +82,7 @@ LL | |                 Some(x)
 ...  |
 LL | |         _ => None,
 LL | |     };
-   | |_____^ help: try this: `Some(6).as_ref().filter(|&x| x > &0)`
+   | |_____^ help: try: `Some(6).as_ref().filter(|&x| x > &0)`
 
 error: manual implementation of `Option::filter`
   --> $DIR/manual_filter.rs:87:5
@@ -94,7 +94,7 @@ LL | |                 Some(x)
 ...  |
 LL | |         _ => None,
 LL | |     };
-   | |_____^ help: try this: `Some(String::new()).filter(|x| external_cond)`
+   | |_____^ help: try: `Some(String::new()).filter(|x| external_cond)`
 
 error: manual implementation of `Option::filter`
   --> $DIR/manual_filter.rs:98:5
@@ -104,7 +104,7 @@ LL | |         if external_cond { Some(x) } else { None }
 LL | |     } else {
 LL | |         None
 LL | |     };
-   | |_____^ help: try this: `Some(7).filter(|&x| external_cond)`
+   | |_____^ help: try: `Some(7).filter(|&x| external_cond)`
 
 error: manual implementation of `Option::filter`
   --> $DIR/manual_filter.rs:104:5
@@ -116,7 +116,7 @@ LL | |                 Some(x)
 ...  |
 LL | |         _ => None,
 LL | |     };
-   | |_____^ help: try this: `Some(8).filter(|&x| x != 0)`
+   | |_____^ help: try: `Some(8).filter(|&x| x != 0)`
 
 error: manual implementation of `Option::filter`
   --> $DIR/manual_filter.rs:115:5
@@ -128,7 +128,7 @@ LL | |                 Some(x)
 ...  |
 LL | |         None => None,
 LL | |     };
-   | |_____^ help: try this: `Some(9).filter(|&x| x > 10 && x < 100)`
+   | |_____^ help: try: `Some(9).filter(|&x| x > 10 && x < 100)`
 
 error: manual implementation of `Option::filter`
   --> $DIR/manual_filter.rs:141:5
@@ -142,7 +142,7 @@ LL | |         None => None,
 LL | |     };
    | |_____^
    |
-help: try this
+help: try
    |
 LL ~     Some(11).filter(|&x| {
 LL +                 println!("foo");
@@ -161,7 +161,7 @@ LL | |                 Some(x)
 ...  |
 LL | |         None => None,
 LL | |     };
-   | |_____^ help: try this: `Some(14).filter(|&x| unsafe { f(x) })`
+   | |_____^ help: try: `Some(14).filter(|&x| unsafe { f(x) })`
 
 error: manual implementation of `Option::filter`
   --> $DIR/manual_filter.rs:195:13
@@ -173,7 +173,7 @@ LL | |             if f(x) { Some(x) } else { None }
 LL | |         },
 LL | |         None => None,
 LL | |     };
-   | |_____^ help: try this: `Some(15).filter(|&x| unsafe { f(x) })`
+   | |_____^ help: try: `Some(15).filter(|&x| unsafe { f(x) })`
 
 error: manual implementation of `Option::filter`
   --> $DIR/manual_filter.rs:205:12
@@ -185,7 +185,7 @@ LL | |         if x % 2 == 0 { Some(x) } else { None }
 LL | |     } else {
 LL | |         None
 LL | |     };
-   | |_____^ help: try this: `{ Some(16).filter(|&x| x % 2 == 0) }`
+   | |_____^ help: try: `{ Some(16).filter(|&x| x % 2 == 0) }`
 
 error: aborting due to 15 previous errors
 
diff --git a/tests/ui/manual_map_option.stderr b/tests/ui/manual_map_option.stderr
index cdc2c0e62a9..3f9caad4e89 100644
--- a/tests/ui/manual_map_option.stderr
+++ b/tests/ui/manual_map_option.stderr
@@ -5,7 +5,7 @@ LL | /     match Some(0) {
 LL | |         Some(_) => Some(2),
 LL | |         None::<u32> => None,
 LL | |     };
-   | |_____^ help: try this: `Some(0).map(|_| 2)`
+   | |_____^ help: try: `Some(0).map(|_| 2)`
    |
    = note: `-D clippy::manual-map` implied by `-D warnings`
 
@@ -16,7 +16,7 @@ LL | /     match Some(0) {
 LL | |         Some(x) => Some(x + 1),
 LL | |         _ => None,
 LL | |     };
-   | |_____^ help: try this: `Some(0).map(|x| x + 1)`
+   | |_____^ help: try: `Some(0).map(|x| x + 1)`
 
 error: manual implementation of `Option::map`
   --> $DIR/manual_map_option.rs:25:5
@@ -25,7 +25,7 @@ LL | /     match Some("") {
 LL | |         Some(x) => Some(x.is_empty()),
 LL | |         None => None,
 LL | |     };
-   | |_____^ help: try this: `Some("").map(|x| x.is_empty())`
+   | |_____^ help: try: `Some("").map(|x| x.is_empty())`
 
 error: manual implementation of `Option::map`
   --> $DIR/manual_map_option.rs:30:5
@@ -35,7 +35,7 @@ LL | |         Some(!x)
 LL | |     } else {
 LL | |         None
 LL | |     };
-   | |_____^ help: try this: `Some(0).map(|x| !x)`
+   | |_____^ help: try: `Some(0).map(|x| !x)`
 
 error: manual implementation of `Option::map`
   --> $DIR/manual_map_option.rs:37:5
@@ -44,7 +44,7 @@ LL | /     match Some(0) {
 LL | |         Some(x) => { Some(std::convert::identity(x)) }
 LL | |         None => { None }
 LL | |     };
-   | |_____^ help: try this: `Some(0).map(std::convert::identity)`
+   | |_____^ help: try: `Some(0).map(std::convert::identity)`
 
 error: manual implementation of `Option::map`
   --> $DIR/manual_map_option.rs:42:5
@@ -53,7 +53,7 @@ LL | /     match Some(&String::new()) {
 LL | |         Some(x) => Some(str::len(x)),
 LL | |         None => None,
 LL | |     };
-   | |_____^ help: try this: `Some(&String::new()).map(|x| str::len(x))`
+   | |_____^ help: try: `Some(&String::new()).map(|x| str::len(x))`
 
 error: manual implementation of `Option::map`
   --> $DIR/manual_map_option.rs:52:5
@@ -62,7 +62,7 @@ LL | /     match &Some([0, 1]) {
 LL | |         Some(x) => Some(x[0]),
 LL | |         &None => None,
 LL | |     };
-   | |_____^ help: try this: `Some([0, 1]).as_ref().map(|x| x[0])`
+   | |_____^ help: try: `Some([0, 1]).as_ref().map(|x| x[0])`
 
 error: manual implementation of `Option::map`
   --> $DIR/manual_map_option.rs:57:5
@@ -71,7 +71,7 @@ LL | /     match &Some(0) {
 LL | |         &Some(x) => Some(x * 2),
 LL | |         None => None,
 LL | |     };
-   | |_____^ help: try this: `Some(0).map(|x| x * 2)`
+   | |_____^ help: try: `Some(0).map(|x| x * 2)`
 
 error: manual implementation of `Option::map`
   --> $DIR/manual_map_option.rs:62:5
@@ -80,7 +80,7 @@ LL | /     match Some(String::new()) {
 LL | |         Some(ref x) => Some(x.is_empty()),
 LL | |         _ => None,
 LL | |     };
-   | |_____^ help: try this: `Some(String::new()).as_ref().map(|x| x.is_empty())`
+   | |_____^ help: try: `Some(String::new()).as_ref().map(|x| x.is_empty())`
 
 error: manual implementation of `Option::map`
   --> $DIR/manual_map_option.rs:67:5
@@ -89,7 +89,7 @@ LL | /     match &&Some(String::new()) {
 LL | |         Some(x) => Some(x.len()),
 LL | |         _ => None,
 LL | |     };
-   | |_____^ help: try this: `Some(String::new()).as_ref().map(|x| x.len())`
+   | |_____^ help: try: `Some(String::new()).as_ref().map(|x| x.len())`
 
 error: manual implementation of `Option::map`
   --> $DIR/manual_map_option.rs:72:5
@@ -98,7 +98,7 @@ LL | /     match &&Some(0) {
 LL | |         &&Some(x) => Some(x + x),
 LL | |         &&_ => None,
 LL | |     };
-   | |_____^ help: try this: `Some(0).map(|x| x + x)`
+   | |_____^ help: try: `Some(0).map(|x| x + x)`
 
 error: manual implementation of `Option::map`
   --> $DIR/manual_map_option.rs:85:9
@@ -107,7 +107,7 @@ LL | /         match &mut Some(String::new()) {
 LL | |             Some(x) => Some(x.push_str("")),
 LL | |             None => None,
 LL | |         };
-   | |_________^ help: try this: `Some(String::new()).as_mut().map(|x| x.push_str(""))`
+   | |_________^ help: try: `Some(String::new()).as_mut().map(|x| x.push_str(""))`
 
 error: manual implementation of `Option::map`
   --> $DIR/manual_map_option.rs:91:5
@@ -116,7 +116,7 @@ LL | /     match &mut Some(String::new()) {
 LL | |         Some(ref x) => Some(x.len()),
 LL | |         None => None,
 LL | |     };
-   | |_____^ help: try this: `Some(String::new()).as_ref().map(|x| x.len())`
+   | |_____^ help: try: `Some(String::new()).as_ref().map(|x| x.len())`
 
 error: manual implementation of `Option::map`
   --> $DIR/manual_map_option.rs:96:5
@@ -125,7 +125,7 @@ LL | /     match &mut &Some(String::new()) {
 LL | |         Some(x) => Some(x.is_empty()),
 LL | |         &mut _ => None,
 LL | |     };
-   | |_____^ help: try this: `Some(String::new()).as_ref().map(|x| x.is_empty())`
+   | |_____^ help: try: `Some(String::new()).as_ref().map(|x| x.is_empty())`
 
 error: manual implementation of `Option::map`
   --> $DIR/manual_map_option.rs:101:5
@@ -134,7 +134,7 @@ LL | /     match Some((0, 1, 2)) {
 LL | |         Some((x, y, z)) => Some(x + y + z),
 LL | |         None => None,
 LL | |     };
-   | |_____^ help: try this: `Some((0, 1, 2)).map(|(x, y, z)| x + y + z)`
+   | |_____^ help: try: `Some((0, 1, 2)).map(|(x, y, z)| x + y + z)`
 
 error: manual implementation of `Option::map`
   --> $DIR/manual_map_option.rs:106:5
@@ -143,7 +143,7 @@ LL | /     match Some([1, 2, 3]) {
 LL | |         Some([first, ..]) => Some(first),
 LL | |         None => None,
 LL | |     };
-   | |_____^ help: try this: `Some([1, 2, 3]).map(|[first, ..]| first)`
+   | |_____^ help: try: `Some([1, 2, 3]).map(|[first, ..]| first)`
 
 error: manual implementation of `Option::map`
   --> $DIR/manual_map_option.rs:111:5
@@ -152,7 +152,7 @@ LL | /     match &Some((String::new(), "test")) {
 LL | |         Some((x, y)) => Some((y, x)),
 LL | |         None => None,
 LL | |     };
-   | |_____^ help: try this: `Some((String::new(), "test")).as_ref().map(|(x, y)| (y, x))`
+   | |_____^ help: try: `Some((String::new(), "test")).as_ref().map(|(x, y)| (y, x))`
 
 error: manual implementation of `Option::map`
   --> $DIR/manual_map_option.rs:169:5
@@ -161,7 +161,7 @@ LL | /     match Some(0) {
 LL | |         Some(x) => Some(vec![x]),
 LL | |         None => None,
 LL | |     };
-   | |_____^ help: try this: `Some(0).map(|x| vec![x])`
+   | |_____^ help: try: `Some(0).map(|x| vec![x])`
 
 error: manual implementation of `Option::map`
   --> $DIR/manual_map_option.rs:174:5
@@ -170,7 +170,7 @@ LL | /     match option_env!("") {
 LL | |         Some(x) => Some(String::from(x)),
 LL | |         None => None,
 LL | |     };
-   | |_____^ help: try this: `option_env!("").map(String::from)`
+   | |_____^ help: try: `option_env!("").map(String::from)`
 
 error: manual implementation of `Option::map`
   --> $DIR/manual_map_option.rs:194:12
@@ -181,7 +181,7 @@ LL | |         Some(x + 1)
 LL | |     } else {
 LL | |         None
 LL | |     };
-   | |_____^ help: try this: `{ Some(0).map(|x| x + 1) }`
+   | |_____^ help: try: `{ Some(0).map(|x| x + 1) }`
 
 error: manual implementation of `Option::map`
   --> $DIR/manual_map_option.rs:202:12
@@ -192,7 +192,7 @@ LL | |         Some(x + 1)
 LL | |     } else {
 LL | |         None
 LL | |     };
-   | |_____^ help: try this: `{ Some(0).map(|x| x + 1) }`
+   | |_____^ help: try: `{ Some(0).map(|x| x + 1) }`
 
 error: aborting due to 21 previous errors
 
diff --git a/tests/ui/manual_map_option_2.stderr b/tests/ui/manual_map_option_2.stderr
index d35b6252fb8..8c78fcffca8 100644
--- a/tests/ui/manual_map_option_2.stderr
+++ b/tests/ui/manual_map_option_2.stderr
@@ -12,7 +12,7 @@ LL | |     };
    | |_____^
    |
    = note: `-D clippy::manual-map` implied by `-D warnings`
-help: try this
+help: try
    |
 LL ~     let _ = Some(0).map(|x| {
 LL +             let y = (String::new(), String::new());
@@ -32,7 +32,7 @@ LL | |         None => None,
 LL | |     };
    | |_____^
    |
-help: try this
+help: try
    |
 LL ~     let _ = s.as_ref().map(|x| {
 LL +             if let Some(ref s) = s { (x.clone(), s) } else { panic!() }
@@ -47,7 +47,7 @@ LL |           let _ = match Some(0) {
 LL | |             Some(x) => Some(f(x)),
 LL | |             None => None,
 LL | |         };
-   | |_________^ help: try this: `Some(0).map(|x| f(x))`
+   | |_________^ help: try: `Some(0).map(|x| f(x))`
 
 error: manual implementation of `Option::map`
   --> $DIR/manual_map_option_2.rs:67:13
@@ -57,7 +57,7 @@ LL |       let _ = match Some(0) {
 LL | |         Some(x) => unsafe { Some(f(x)) },
 LL | |         None => None,
 LL | |     };
-   | |_____^ help: try this: `Some(0).map(|x| unsafe { f(x) })`
+   | |_____^ help: try: `Some(0).map(|x| unsafe { f(x) })`
 
 error: manual implementation of `Option::map`
   --> $DIR/manual_map_option_2.rs:71:13
@@ -67,7 +67,7 @@ LL |       let _ = match Some(0) {
 LL | |         Some(x) => Some(unsafe { f(x) }),
 LL | |         None => None,
 LL | |     };
-   | |_____^ help: try this: `Some(0).map(|x| unsafe { f(x) })`
+   | |_____^ help: try: `Some(0).map(|x| unsafe { f(x) })`
 
 error: aborting due to 5 previous errors
 
diff --git a/tests/ui/manual_split_once.stderr b/tests/ui/manual_split_once.stderr
index 78da5a16cc5..f454f95b41d 100644
--- a/tests/ui/manual_split_once.stderr
+++ b/tests/ui/manual_split_once.stderr
@@ -2,7 +2,7 @@ error: manual implementation of `split_once`
   --> $DIR/manual_split_once.rs:13:13
    |
 LL |     let _ = "key=value".splitn(2, '=').nth(1).unwrap();
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `"key=value".split_once('=').unwrap().1`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `"key=value".split_once('=').unwrap().1`
    |
    = note: `-D clippy::manual-split-once` implied by `-D warnings`
 
@@ -10,73 +10,73 @@ error: manual implementation of `split_once`
   --> $DIR/manual_split_once.rs:14:13
    |
 LL |     let _ = "key=value".splitn(2, '=').skip(1).next().unwrap();
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `"key=value".split_once('=').unwrap().1`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `"key=value".split_once('=').unwrap().1`
 
 error: manual implementation of `split_once`
   --> $DIR/manual_split_once.rs:15:18
    |
 LL |     let (_, _) = "key=value".splitn(2, '=').next_tuple().unwrap();
-   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `"key=value".split_once('=')`
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `"key=value".split_once('=')`
 
 error: manual implementation of `split_once`
   --> $DIR/manual_split_once.rs:18:13
    |
 LL |     let _ = s.splitn(2, '=').nth(1).unwrap();
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `s.split_once('=').unwrap().1`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `s.split_once('=').unwrap().1`
 
 error: manual implementation of `split_once`
   --> $DIR/manual_split_once.rs:21:13
    |
 LL |     let _ = s.splitn(2, '=').nth(1).unwrap();
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `s.split_once('=').unwrap().1`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `s.split_once('=').unwrap().1`
 
 error: manual implementation of `split_once`
   --> $DIR/manual_split_once.rs:24:13
    |
 LL |     let _ = s.splitn(2, '=').skip(1).next().unwrap();
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `s.split_once('=').unwrap().1`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `s.split_once('=').unwrap().1`
 
 error: manual implementation of `split_once`
   --> $DIR/manual_split_once.rs:27:17
    |
 LL |         let _ = s.splitn(2, '=').nth(1)?;
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `s.split_once('=')?.1`
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `s.split_once('=')?.1`
 
 error: manual implementation of `split_once`
   --> $DIR/manual_split_once.rs:28:17
    |
 LL |         let _ = s.splitn(2, '=').skip(1).next()?;
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `s.split_once('=')?.1`
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `s.split_once('=')?.1`
 
 error: manual implementation of `rsplit_once`
   --> $DIR/manual_split_once.rs:29:17
    |
 LL |         let _ = s.rsplitn(2, '=').nth(1)?;
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `s.rsplit_once('=')?.0`
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `s.rsplit_once('=')?.0`
 
 error: manual implementation of `rsplit_once`
   --> $DIR/manual_split_once.rs:30:17
    |
 LL |         let _ = s.rsplitn(2, '=').skip(1).next()?;
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `s.rsplit_once('=')?.0`
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `s.rsplit_once('=')?.0`
 
 error: manual implementation of `rsplit_once`
   --> $DIR/manual_split_once.rs:38:13
    |
 LL |     let _ = "key=value".rsplitn(2, '=').nth(1).unwrap();
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `"key=value".rsplit_once('=').unwrap().0`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `"key=value".rsplit_once('=').unwrap().0`
 
 error: manual implementation of `rsplit_once`
   --> $DIR/manual_split_once.rs:39:18
    |
 LL |     let (_, _) = "key=value".rsplitn(2, '=').next_tuple().unwrap();
-   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `"key=value".rsplit_once('=').map(|(x, y)| (y, x))`
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `"key=value".rsplit_once('=').map(|(x, y)| (y, x))`
 
 error: manual implementation of `rsplit_once`
   --> $DIR/manual_split_once.rs:40:13
    |
 LL |     let _ = s.rsplitn(2, '=').nth(1);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `s.rsplit_once('=').map(|x| x.0)`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `s.rsplit_once('=').map(|x| x.0)`
 
 error: manual implementation of `split_once`
   --> $DIR/manual_split_once.rs:44:5
@@ -182,7 +182,7 @@ error: manual implementation of `split_once`
   --> $DIR/manual_split_once.rs:141:13
    |
 LL |     let _ = "key=value".splitn(2, '=').nth(1).unwrap();
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `"key=value".split_once('=').unwrap().1`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `"key=value".split_once('=').unwrap().1`
 
 error: manual implementation of `split_once`
   --> $DIR/manual_split_once.rs:143:5
diff --git a/tests/ui/manual_str_repeat.stderr b/tests/ui/manual_str_repeat.stderr
index bdfee7cab26..331bb6ea575 100644
--- a/tests/ui/manual_str_repeat.stderr
+++ b/tests/ui/manual_str_repeat.stderr
@@ -2,7 +2,7 @@ error: manual implementation of `str::repeat` using iterators
   --> $DIR/manual_str_repeat.rs:9:21
    |
 LL |     let _: String = std::iter::repeat("test").take(10).collect();
-   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `"test".repeat(10)`
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `"test".repeat(10)`
    |
    = note: `-D clippy::manual-str-repeat` implied by `-D warnings`
 
@@ -10,55 +10,55 @@ error: manual implementation of `str::repeat` using iterators
   --> $DIR/manual_str_repeat.rs:10:21
    |
 LL |     let _: String = std::iter::repeat('x').take(10).collect();
-   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `"x".repeat(10)`
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `"x".repeat(10)`
 
 error: manual implementation of `str::repeat` using iterators
   --> $DIR/manual_str_repeat.rs:11:21
    |
 LL |     let _: String = std::iter::repeat('/'').take(10).collect();
-   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `"'".repeat(10)`
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `"'".repeat(10)`
 
 error: manual implementation of `str::repeat` using iterators
   --> $DIR/manual_str_repeat.rs:12:21
    |
 LL |     let _: String = std::iter::repeat('"').take(10).collect();
-   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `"/"".repeat(10)`
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `"/"".repeat(10)`
 
 error: manual implementation of `str::repeat` using iterators
   --> $DIR/manual_str_repeat.rs:16:13
    |
 LL |     let _ = repeat(x).take(count + 2).collect::<String>();
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `x.repeat(count + 2)`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `x.repeat(count + 2)`
 
 error: manual implementation of `str::repeat` using iterators
   --> $DIR/manual_str_repeat.rs:25:21
    |
 LL |     let _: String = repeat(*x).take(count).collect();
-   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `(*x).repeat(count)`
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `(*x).repeat(count)`
 
 error: manual implementation of `str::repeat` using iterators
   --> $DIR/manual_str_repeat.rs:34:21
    |
 LL |     let _: String = repeat(x).take(count).collect();
-   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `x.repeat(count)`
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `x.repeat(count)`
 
 error: manual implementation of `str::repeat` using iterators
   --> $DIR/manual_str_repeat.rs:46:21
    |
 LL |     let _: String = repeat(Cow::Borrowed("test")).take(count).collect();
-   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `Cow::Borrowed("test").repeat(count)`
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Cow::Borrowed("test").repeat(count)`
 
 error: manual implementation of `str::repeat` using iterators
   --> $DIR/manual_str_repeat.rs:49:21
    |
 LL |     let _: String = repeat(x).take(count).collect();
-   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `x.repeat(count)`
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `x.repeat(count)`
 
 error: manual implementation of `str::repeat` using iterators
   --> $DIR/manual_str_repeat.rs:64:21
    |
 LL |     let _: String = std::iter::repeat("test").take(10).collect();
-   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `"test".repeat(10)`
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `"test".repeat(10)`
 
 error: aborting due to 10 previous errors
 
diff --git a/tests/ui/map_collect_result_unit.stderr b/tests/ui/map_collect_result_unit.stderr
index 8b06e13baa6..596e51e5741 100644
--- a/tests/ui/map_collect_result_unit.stderr
+++ b/tests/ui/map_collect_result_unit.stderr
@@ -2,7 +2,7 @@ error: `.map().collect()` can be replaced with `.try_for_each()`
   --> $DIR/map_collect_result_unit.rs:6:17
    |
 LL |         let _ = (0..3).map(|t| Err(t + 1)).collect::<Result<(), _>>();
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `(0..3).try_for_each(|t| Err(t + 1))`
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `(0..3).try_for_each(|t| Err(t + 1))`
    |
    = note: `-D clippy::map-collect-result-unit` implied by `-D warnings`
 
@@ -10,7 +10,7 @@ error: `.map().collect()` can be replaced with `.try_for_each()`
   --> $DIR/map_collect_result_unit.rs:7:32
    |
 LL |         let _: Result<(), _> = (0..3).map(|t| Err(t + 1)).collect();
-   |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `(0..3).try_for_each(|t| Err(t + 1))`
+   |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `(0..3).try_for_each(|t| Err(t + 1))`
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/map_unwrap_or.stderr b/tests/ui/map_unwrap_or.stderr
index 9f4a4a9ae6b..5b3c61acf74 100644
--- a/tests/ui/map_unwrap_or.stderr
+++ b/tests/ui/map_unwrap_or.stderr
@@ -162,7 +162,7 @@ error: called `map(<f>).unwrap_or_else(<g>)` on a `Result` value. This can be do
   --> $DIR/map_unwrap_or.rs:99:13
    |
 LL |     let _ = res.map(|x| x + 1).unwrap_or_else(|_e| 0);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `res.map_or_else(|_e| 0, |x| x + 1)`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `res.map_or_else(|_e| 0, |x| x + 1)`
 
 error: called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead
   --> $DIR/map_unwrap_or.rs:106:13
diff --git a/tests/ui/map_unwrap_or_fixable.stderr b/tests/ui/map_unwrap_or_fixable.stderr
index 1837bc2ca3b..71dc009f2ce 100644
--- a/tests/ui/map_unwrap_or_fixable.stderr
+++ b/tests/ui/map_unwrap_or_fixable.stderr
@@ -5,7 +5,7 @@ LL |       let _ = opt.map(|x| x + 1)
    |  _____________^
 LL | |         // Should lint even though this call is on a separate line.
 LL | |         .unwrap_or_else(|| 0);
-   | |_____________________________^ help: try this: `opt.map_or_else(|| 0, |x| x + 1)`
+   | |_____________________________^ help: try: `opt.map_or_else(|| 0, |x| x + 1)`
    |
    = note: `-D clippy::map-unwrap-or` implied by `-D warnings`
 
@@ -16,7 +16,7 @@ LL |       let _ = res.map(|x| x + 1)
    |  _____________^
 LL | |         // should lint even though this call is on a separate line
 LL | |         .unwrap_or_else(|_e| 0);
-   | |_______________________________^ help: try this: `res.map_or_else(|_e| 0, |x| x + 1)`
+   | |_______________________________^ help: try: `res.map_or_else(|_e| 0, |x| x + 1)`
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/match_as_ref.stderr b/tests/ui/match_as_ref.stderr
index c3b62849cb3..252abf74bca 100644
--- a/tests/ui/match_as_ref.stderr
+++ b/tests/ui/match_as_ref.stderr
@@ -6,7 +6,7 @@ LL |       let borrowed: Option<&()> = match owned {
 LL | |         None => None,
 LL | |         Some(ref v) => Some(v),
 LL | |     };
-   | |_____^ help: try this: `owned.as_ref()`
+   | |_____^ help: try: `owned.as_ref()`
    |
    = note: `-D clippy::match-as-ref` implied by `-D warnings`
 
@@ -18,7 +18,7 @@ LL |       let borrow_mut: Option<&mut ()> = match mut_owned {
 LL | |         None => None,
 LL | |         Some(ref mut v) => Some(v),
 LL | |     };
-   | |_____^ help: try this: `mut_owned.as_mut()`
+   | |_____^ help: try: `mut_owned.as_mut()`
 
 error: use `as_ref()` instead
   --> $DIR/match_as_ref.rs:30:13
@@ -27,7 +27,7 @@ LL | /             match self.source {
 LL | |                 Some(ref s) => Some(s),
 LL | |                 None => None,
 LL | |             }
-   | |_____________^ help: try this: `self.source.as_ref().map(|x| x as _)`
+   | |_____________^ help: try: `self.source.as_ref().map(|x| x as _)`
 
 error: aborting due to 3 previous errors
 
diff --git a/tests/ui/match_expr_like_matches_macro.stderr b/tests/ui/match_expr_like_matches_macro.stderr
index b72fe10b748..c8c1e5da05f 100644
--- a/tests/ui/match_expr_like_matches_macro.stderr
+++ b/tests/ui/match_expr_like_matches_macro.stderr
@@ -6,7 +6,7 @@ LL |       let _y = match x {
 LL | |         Some(0) => true,
 LL | |         _ => false,
 LL | |     };
-   | |_____^ help: try this: `matches!(x, Some(0))`
+   | |_____^ help: try: `matches!(x, Some(0))`
    |
    = note: `-D clippy::match-like-matches-macro` implied by `-D warnings`
 
@@ -18,7 +18,7 @@ LL |       let _w = match x {
 LL | |         Some(_) => true,
 LL | |         _ => false,
 LL | |     };
-   | |_____^ help: try this: `x.is_some()`
+   | |_____^ help: try: `x.is_some()`
    |
    = note: `-D clippy::redundant-pattern-matching` implied by `-D warnings`
 
@@ -30,7 +30,7 @@ LL |       let _z = match x {
 LL | |         Some(_) => false,
 LL | |         None => true,
 LL | |     };
-   | |_____^ help: try this: `x.is_none()`
+   | |_____^ help: try: `x.is_none()`
 
 error: match expression looks like `matches!` macro
   --> $DIR/match_expr_like_matches_macro.rs:33:15
@@ -40,13 +40,13 @@ LL |       let _zz = match x {
 LL | |         Some(r) if r == 0 => false,
 LL | |         _ => true,
 LL | |     };
-   | |_____^ help: try this: `!matches!(x, Some(r) if r == 0)`
+   | |_____^ help: try: `!matches!(x, Some(r) if r == 0)`
 
 error: if let .. else expression looks like `matches!` macro
   --> $DIR/match_expr_like_matches_macro.rs:39:16
    |
 LL |     let _zzz = if let Some(5) = x { true } else { false };
-   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `matches!(x, Some(5))`
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `matches!(x, Some(5))`
 
 error: match expression looks like `matches!` macro
   --> $DIR/match_expr_like_matches_macro.rs:63:20
@@ -57,7 +57,7 @@ LL | |             E::A(_) => true,
 LL | |             E::B(_) => true,
 LL | |             _ => false,
 LL | |         };
-   | |_________^ help: try this: `matches!(x, E::A(_) | E::B(_))`
+   | |_________^ help: try: `matches!(x, E::A(_) | E::B(_))`
 
 error: match expression looks like `matches!` macro
   --> $DIR/match_expr_like_matches_macro.rs:73:20
@@ -70,7 +70,7 @@ LL | |             }
 LL | |             E::B(_) => true,
 LL | |             _ => false,
 LL | |         };
-   | |_________^ help: try this: `matches!(x, E::A(_) | E::B(_))`
+   | |_________^ help: try: `matches!(x, E::A(_) | E::B(_))`
 
 error: match expression looks like `matches!` macro
   --> $DIR/match_expr_like_matches_macro.rs:83:20
@@ -81,7 +81,7 @@ LL | |             E::B(_) => false,
 LL | |             E::C => false,
 LL | |             _ => true,
 LL | |         };
-   | |_________^ help: try this: `!matches!(x, E::B(_) | E::C)`
+   | |_________^ help: try: `!matches!(x, E::B(_) | E::C)`
 
 error: match expression looks like `matches!` macro
   --> $DIR/match_expr_like_matches_macro.rs:143:18
@@ -91,7 +91,7 @@ LL |           let _z = match &z {
 LL | |             Some(3) => true,
 LL | |             _ => false,
 LL | |         };
-   | |_________^ help: try this: `matches!(z, Some(3))`
+   | |_________^ help: try: `matches!(z, Some(3))`
 
 error: match expression looks like `matches!` macro
   --> $DIR/match_expr_like_matches_macro.rs:152:18
@@ -101,7 +101,7 @@ LL |           let _z = match &z {
 LL | |             Some(3) => true,
 LL | |             _ => false,
 LL | |         };
-   | |_________^ help: try this: `matches!(&z, Some(3))`
+   | |_________^ help: try: `matches!(&z, Some(3))`
 
 error: match expression looks like `matches!` macro
   --> $DIR/match_expr_like_matches_macro.rs:169:21
@@ -111,7 +111,7 @@ LL |               let _ = match &z {
 LL | |                 AnEnum::X => true,
 LL | |                 _ => false,
 LL | |             };
-   | |_____________^ help: try this: `matches!(&z, AnEnum::X)`
+   | |_____________^ help: try: `matches!(&z, AnEnum::X)`
 
 error: match expression looks like `matches!` macro
   --> $DIR/match_expr_like_matches_macro.rs:183:20
@@ -121,7 +121,7 @@ LL |           let _res = match &val {
 LL | |             &Some(ref _a) => true,
 LL | |             _ => false,
 LL | |         };
-   | |_________^ help: try this: `matches!(&val, &Some(ref _a))`
+   | |_________^ help: try: `matches!(&val, &Some(ref _a))`
 
 error: match expression looks like `matches!` macro
   --> $DIR/match_expr_like_matches_macro.rs:195:20
@@ -131,7 +131,7 @@ LL |           let _res = match &val {
 LL | |             &Some(ref _a) => true,
 LL | |             _ => false,
 LL | |         };
-   | |_________^ help: try this: `matches!(&val, &Some(ref _a))`
+   | |_________^ help: try: `matches!(&val, &Some(ref _a))`
 
 error: match expression looks like `matches!` macro
   --> $DIR/match_expr_like_matches_macro.rs:253:14
@@ -141,7 +141,7 @@ LL |       let _y = match Some(5) {
 LL | |         Some(0) => true,
 LL | |         _ => false,
 LL | |     };
-   | |_____^ help: try this: `matches!(Some(5), Some(0))`
+   | |_____^ help: try: `matches!(Some(5), Some(0))`
 
 error: aborting due to 14 previous errors
 
diff --git a/tests/ui/match_on_vec_items.stderr b/tests/ui/match_on_vec_items.stderr
index 9b1f052867e..fc4a3ce1946 100644
--- a/tests/ui/match_on_vec_items.stderr
+++ b/tests/ui/match_on_vec_items.stderr
@@ -2,7 +2,7 @@ error: indexing into a vector may panic
   --> $DIR/match_on_vec_items.rs:10:11
    |
 LL |     match arr[idx] {
-   |           ^^^^^^^^ help: try this: `arr.get(idx)`
+   |           ^^^^^^^^ help: try: `arr.get(idx)`
    |
    = note: `-D clippy::match-on-vec-items` implied by `-D warnings`
 
@@ -10,43 +10,43 @@ error: indexing into a vector may panic
   --> $DIR/match_on_vec_items.rs:17:11
    |
 LL |     match arr[range] {
-   |           ^^^^^^^^^^ help: try this: `arr.get(range)`
+   |           ^^^^^^^^^^ help: try: `arr.get(range)`
 
 error: indexing into a vector may panic
   --> $DIR/match_on_vec_items.rs:30:11
    |
 LL |     match arr[idx] {
-   |           ^^^^^^^^ help: try this: `arr.get(idx)`
+   |           ^^^^^^^^ help: try: `arr.get(idx)`
 
 error: indexing into a vector may panic
   --> $DIR/match_on_vec_items.rs:37:11
    |
 LL |     match arr[range] {
-   |           ^^^^^^^^^^ help: try this: `arr.get(range)`
+   |           ^^^^^^^^^^ help: try: `arr.get(range)`
 
 error: indexing into a vector may panic
   --> $DIR/match_on_vec_items.rs:50:11
    |
 LL |     match arr[idx] {
-   |           ^^^^^^^^ help: try this: `arr.get(idx)`
+   |           ^^^^^^^^ help: try: `arr.get(idx)`
 
 error: indexing into a vector may panic
   --> $DIR/match_on_vec_items.rs:57:11
    |
 LL |     match arr[range] {
-   |           ^^^^^^^^^^ help: try this: `arr.get(range)`
+   |           ^^^^^^^^^^ help: try: `arr.get(range)`
 
 error: indexing into a vector may panic
   --> $DIR/match_on_vec_items.rs:70:11
    |
 LL |     match arr[idx] {
-   |           ^^^^^^^^ help: try this: `arr.get(idx)`
+   |           ^^^^^^^^ help: try: `arr.get(idx)`
 
 error: indexing into a vector may panic
   --> $DIR/match_on_vec_items.rs:77:11
    |
 LL |     match arr[range] {
-   |           ^^^^^^^^^^ help: try this: `arr.get(range)`
+   |           ^^^^^^^^^^ help: try: `arr.get(range)`
 
 error: aborting due to 8 previous errors
 
diff --git a/tests/ui/match_ref_pats.stderr b/tests/ui/match_ref_pats.stderr
index 7d9646c842e..1294e0fe56f 100644
--- a/tests/ui/match_ref_pats.stderr
+++ b/tests/ui/match_ref_pats.stderr
@@ -35,7 +35,7 @@ error: redundant pattern matching, consider using `is_none()`
   --> $DIR/match_ref_pats.rs:38:12
    |
 LL |     if let &None = a {
-   |     -------^^^^^---- help: try this: `if a.is_none()`
+   |     -------^^^^^---- help: try: `if a.is_none()`
    |
    = note: `-D clippy::redundant-pattern-matching` implied by `-D warnings`
 
@@ -43,7 +43,7 @@ error: redundant pattern matching, consider using `is_none()`
   --> $DIR/match_ref_pats.rs:43:12
    |
 LL |     if let &None = &b {
-   |     -------^^^^^----- help: try this: `if b.is_none()`
+   |     -------^^^^^----- help: try: `if b.is_none()`
 
 error: you don't need to add `&` to all patterns
   --> $DIR/match_ref_pats.rs:103:9
diff --git a/tests/ui/match_same_arms2.stderr b/tests/ui/match_same_arms2.stderr
index 7f0c70745ac..a7348187573 100644
--- a/tests/ui/match_same_arms2.stderr
+++ b/tests/ui/match_same_arms2.stderr
@@ -144,7 +144,7 @@ LL | |         E::A => false,
 LL | |         E::B => false,
 LL | |         _ => true,
 LL | |     };
-   | |_____^ help: try this: `!matches!(x, E::A | E::B)`
+   | |_____^ help: try: `!matches!(x, E::A | E::B)`
    |
    = note: `-D clippy::match-like-matches-macro` implied by `-D warnings`
 
diff --git a/tests/ui/match_wildcard_for_single_variants.stderr b/tests/ui/match_wildcard_for_single_variants.stderr
index 105b4c4b41d..40ff4fbd316 100644
--- a/tests/ui/match_wildcard_for_single_variants.stderr
+++ b/tests/ui/match_wildcard_for_single_variants.stderr
@@ -2,7 +2,7 @@ error: wildcard matches only a single variant and will also match any future add
   --> $DIR/match_wildcard_for_single_variants.rs:24:13
    |
 LL |             _ => (),
-   |             ^ help: try this: `Self::Rgb(..)`
+   |             ^ help: try: `Self::Rgb(..)`
    |
    = note: `-D clippy::match-wildcard-for-single-variants` implied by `-D warnings`
 
@@ -10,55 +10,55 @@ error: wildcard matches only a single variant and will also match any future add
   --> $DIR/match_wildcard_for_single_variants.rs:34:9
    |
 LL |         _ => {},
-   |         ^ help: try this: `Foo::C`
+   |         ^ help: try: `Foo::C`
 
 error: wildcard matches only a single variant and will also match any future added variants
   --> $DIR/match_wildcard_for_single_variants.rs:44:9
    |
 LL |         _ => {},
-   |         ^ help: try this: `Color::Blue`
+   |         ^ help: try: `Color::Blue`
 
 error: wildcard matches only a single variant and will also match any future added variants
   --> $DIR/match_wildcard_for_single_variants.rs:52:9
    |
 LL |         _ => {},
-   |         ^ help: try this: `Color::Blue`
+   |         ^ help: try: `Color::Blue`
 
 error: wildcard matches only a single variant and will also match any future added variants
   --> $DIR/match_wildcard_for_single_variants.rs:58:9
    |
 LL |         _ => {},
-   |         ^ help: try this: `Color::Blue`
+   |         ^ help: try: `Color::Blue`
 
 error: wildcard matches only a single variant and will also match any future added variants
   --> $DIR/match_wildcard_for_single_variants.rs:75:9
    |
 LL |         &_ => (),
-   |         ^^ help: try this: `Color::Blue`
+   |         ^^ help: try: `Color::Blue`
 
 error: wildcard matches only a single variant and will also match any future added variants
   --> $DIR/match_wildcard_for_single_variants.rs:84:9
    |
 LL |         _ => (),
-   |         ^ help: try this: `C::Blue`
+   |         ^ help: try: `C::Blue`
 
 error: wildcard matches only a single variant and will also match any future added variants
   --> $DIR/match_wildcard_for_single_variants.rs:91:9
    |
 LL |         _ => (),
-   |         ^ help: try this: `Color::Blue`
+   |         ^ help: try: `Color::Blue`
 
 error: wildcard matches only a single variant and will also match any future added variants
   --> $DIR/match_wildcard_for_single_variants.rs:126:13
    |
 LL |             _ => (),
-   |             ^ help: try this: `Enum::__Private`
+   |             ^ help: try: `Enum::__Private`
 
 error: wildcard matches only a single variant and will also match any future added variants
   --> $DIR/match_wildcard_for_single_variants.rs:153:13
    |
 LL |             _ => 2,
-   |             ^ help: try this: `Foo::B`
+   |             ^ help: try: `Foo::B`
 
 error: aborting due to 10 previous errors
 
diff --git a/tests/ui/methods_fixable.stderr b/tests/ui/methods_fixable.stderr
index 187714c75fb..6f45d100d28 100644
--- a/tests/ui/methods_fixable.stderr
+++ b/tests/ui/methods_fixable.stderr
@@ -2,7 +2,7 @@ error: called `filter(..).next()` on an `Iterator`. This is more succinctly expr
   --> $DIR/methods_fixable.rs:11:13
    |
 LL |     let _ = v.iter().filter(|&x| *x < 0).next();
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `v.iter().find(|&x| *x < 0)`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `v.iter().find(|&x| *x < 0)`
    |
    = note: `-D clippy::filter-next` implied by `-D warnings`
 
diff --git a/tests/ui/missing_spin_loop.stderr b/tests/ui/missing_spin_loop.stderr
index 485da00dc64..5795c2c2190 100644
--- a/tests/ui/missing_spin_loop.stderr
+++ b/tests/ui/missing_spin_loop.stderr
@@ -2,7 +2,7 @@ error: busy-waiting loop should at least have a spin loop hint
   --> $DIR/missing_spin_loop.rs:11:37
    |
 LL |     while b.load(Ordering::Acquire) {}
-   |                                     ^^ help: try this: `{ std::hint::spin_loop() }`
+   |                                     ^^ help: try: `{ std::hint::spin_loop() }`
    |
    = note: `-D clippy::missing-spin-loop` implied by `-D warnings`
 
@@ -10,31 +10,31 @@ error: busy-waiting loop should at least have a spin loop hint
   --> $DIR/missing_spin_loop.rs:13:37
    |
 LL |     while !b.load(Ordering::SeqCst) {}
-   |                                     ^^ help: try this: `{ std::hint::spin_loop() }`
+   |                                     ^^ help: try: `{ std::hint::spin_loop() }`
 
 error: busy-waiting loop should at least have a spin loop hint
   --> $DIR/missing_spin_loop.rs:15:46
    |
 LL |     while b.load(Ordering::Acquire) == false {}
-   |                                              ^^ help: try this: `{ std::hint::spin_loop() }`
+   |                                              ^^ help: try: `{ std::hint::spin_loop() }`
 
 error: busy-waiting loop should at least have a spin loop hint
   --> $DIR/missing_spin_loop.rs:17:49
    |
 LL |     while { true == b.load(Ordering::Acquire) } {}
-   |                                                 ^^ help: try this: `{ std::hint::spin_loop() }`
+   |                                                 ^^ help: try: `{ std::hint::spin_loop() }`
 
 error: busy-waiting loop should at least have a spin loop hint
   --> $DIR/missing_spin_loop.rs:19:93
    |
 LL |     while b.compare_exchange(true, false, Ordering::Acquire, Ordering::Relaxed) != Ok(true) {}
-   |                                                                                             ^^ help: try this: `{ std::hint::spin_loop() }`
+   |                                                                                             ^^ help: try: `{ std::hint::spin_loop() }`
 
 error: busy-waiting loop should at least have a spin loop hint
   --> $DIR/missing_spin_loop.rs:21:94
    |
 LL |     while Ok(false) != b.compare_exchange(false, true, Ordering::Acquire, Ordering::Relaxed) {}
-   |                                                                                              ^^ help: try this: `{ std::hint::spin_loop() }`
+   |                                                                                              ^^ help: try: `{ std::hint::spin_loop() }`
 
 error: aborting due to 6 previous errors
 
diff --git a/tests/ui/missing_spin_loop_no_std.stderr b/tests/ui/missing_spin_loop_no_std.stderr
index 2b3b6873c3c..3322a7aae5f 100644
--- a/tests/ui/missing_spin_loop_no_std.stderr
+++ b/tests/ui/missing_spin_loop_no_std.stderr
@@ -2,7 +2,7 @@ error: busy-waiting loop should at least have a spin loop hint
   --> $DIR/missing_spin_loop_no_std.rs:13:37
    |
 LL |     while b.load(Ordering::Acquire) {}
-   |                                     ^^ help: try this: `{ core::hint::spin_loop() }`
+   |                                     ^^ help: try: `{ core::hint::spin_loop() }`
    |
    = note: `-D clippy::missing-spin-loop` implied by `-D warnings`
 
diff --git a/tests/ui/needless_borrow_pat.stderr b/tests/ui/needless_borrow_pat.stderr
index db3b52b8850..2d9b8f15902 100644
--- a/tests/ui/needless_borrow_pat.stderr
+++ b/tests/ui/needless_borrow_pat.stderr
@@ -2,7 +2,7 @@ error: this pattern creates a reference to a reference
   --> $DIR/needless_borrow_pat.rs:59:14
    |
 LL |         Some(ref x) => x,
-   |              ^^^^^ help: try this: `x`
+   |              ^^^^^ help: try: `x`
    |
    = note: `-D clippy::needless-borrow` implied by `-D warnings`
 
@@ -12,7 +12,7 @@ error: this pattern creates a reference to a reference
 LL |         Some(ref x) => *x,
    |              ^^^^^
    |
-help: try this
+help: try
    |
 LL |         Some(x) => x,
    |              ~     ~
@@ -23,7 +23,7 @@ error: this pattern creates a reference to a reference
 LL |         Some(ref x) => {
    |              ^^^^^
    |
-help: try this
+help: try
    |
 LL ~         Some(x) => {
 LL |             f1(x);
@@ -34,13 +34,13 @@ error: this pattern creates a reference to a reference
   --> $DIR/needless_borrow_pat.rs:81:14
    |
 LL |         Some(ref x) => m1!(x),
-   |              ^^^^^ help: try this: `x`
+   |              ^^^^^ help: try: `x`
 
 error: this pattern creates a reference to a reference
   --> $DIR/needless_borrow_pat.rs:86:15
    |
 LL |     let _ = |&ref x: &&String| {
-   |               ^^^^^ help: try this: `x`
+   |               ^^^^^ help: try: `x`
 
 error: this pattern creates a reference to a reference
   --> $DIR/needless_borrow_pat.rs:91:10
@@ -48,7 +48,7 @@ error: this pattern creates a reference to a reference
 LL |     let (ref y,) = (&x,);
    |          ^^^^^
    |
-help: try this
+help: try
    |
 LL ~     let (y,) = (&x,);
 LL ~     let _: &String = y;
@@ -58,7 +58,7 @@ error: this pattern creates a reference to a reference
   --> $DIR/needless_borrow_pat.rs:101:14
    |
 LL |         Some(ref x) => x.0,
-   |              ^^^^^ help: try this: `x`
+   |              ^^^^^ help: try: `x`
 
 error: this pattern creates a reference to a reference
   --> $DIR/needless_borrow_pat.rs:111:14
@@ -66,7 +66,7 @@ error: this pattern creates a reference to a reference
 LL |         E::A(ref x) | E::B(ref x) => *x,
    |              ^^^^^         ^^^^^
    |
-help: try this
+help: try
    |
 LL |         E::A(x) | E::B(x) => x,
    |              ~         ~     ~
@@ -75,7 +75,7 @@ error: this pattern creates a reference to a reference
   --> $DIR/needless_borrow_pat.rs:117:21
    |
 LL |         if let Some(ref x) = Some(&String::new());
-   |                     ^^^^^ help: try this: `x`
+   |                     ^^^^^ help: try: `x`
 
 error: this pattern creates a reference to a reference
   --> $DIR/needless_borrow_pat.rs:125:12
@@ -83,7 +83,7 @@ error: this pattern creates a reference to a reference
 LL | fn f2<'a>(&ref x: &&'a String) -> &'a String {
    |            ^^^^^
    |
-help: try this
+help: try
    |
 LL ~ fn f2<'a>(&x: &&'a String) -> &'a String {
 LL |     let _: &String = x;
@@ -94,7 +94,7 @@ error: this pattern creates a reference to a reference
   --> $DIR/needless_borrow_pat.rs:132:11
    |
 LL |     fn f(&ref x: &&String) {
-   |           ^^^^^ help: try this: `x`
+   |           ^^^^^ help: try: `x`
 
 error: this pattern creates a reference to a reference
   --> $DIR/needless_borrow_pat.rs:140:11
@@ -102,7 +102,7 @@ error: this pattern creates a reference to a reference
 LL |     fn f(&ref x: &&String) {
    |           ^^^^^
    |
-help: try this
+help: try
    |
 LL ~     fn f(&x: &&String) {
 LL ~         let _: &String = x;
diff --git a/tests/ui/needless_option_as_deref.stderr b/tests/ui/needless_option_as_deref.stderr
index 20d28a968c9..4c0d502a203 100644
--- a/tests/ui/needless_option_as_deref.stderr
+++ b/tests/ui/needless_option_as_deref.stderr
@@ -2,7 +2,7 @@ error: derefed type is same as origin
   --> $DIR/needless_option_as_deref.rs:9:29
    |
 LL |     let _: Option<&usize> = Some(&1).as_deref();
-   |                             ^^^^^^^^^^^^^^^^^^^ help: try this: `Some(&1)`
+   |                             ^^^^^^^^^^^^^^^^^^^ help: try: `Some(&1)`
    |
    = note: `-D clippy::needless-option-as-deref` implied by `-D warnings`
 
@@ -10,13 +10,13 @@ error: derefed type is same as origin
   --> $DIR/needless_option_as_deref.rs:10:33
    |
 LL |     let _: Option<&mut usize> = Some(&mut 1).as_deref_mut();
-   |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `Some(&mut 1)`
+   |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Some(&mut 1)`
 
 error: derefed type is same as origin
   --> $DIR/needless_option_as_deref.rs:14:13
    |
 LL |     let _ = x.as_deref_mut();
-   |             ^^^^^^^^^^^^^^^^ help: try this: `x`
+   |             ^^^^^^^^^^^^^^^^ help: try: `x`
 
 error: aborting due to 3 previous errors
 
diff --git a/tests/ui/needless_splitn.stderr b/tests/ui/needless_splitn.stderr
index f607d8e1ab5..0005f758104 100644
--- a/tests/ui/needless_splitn.stderr
+++ b/tests/ui/needless_splitn.stderr
@@ -2,7 +2,7 @@ error: unnecessary use of `splitn`
   --> $DIR/needless_splitn.rs:14:13
    |
 LL |     let _ = str.splitn(2, '=').next();
-   |             ^^^^^^^^^^^^^^^^^^ help: try this: `str.split('=')`
+   |             ^^^^^^^^^^^^^^^^^^ help: try: `str.split('=')`
    |
    = note: `-D clippy::needless-splitn` implied by `-D warnings`
 
@@ -10,73 +10,73 @@ error: unnecessary use of `splitn`
   --> $DIR/needless_splitn.rs:15:13
    |
 LL |     let _ = str.splitn(2, '=').nth(0);
-   |             ^^^^^^^^^^^^^^^^^^ help: try this: `str.split('=')`
+   |             ^^^^^^^^^^^^^^^^^^ help: try: `str.split('=')`
 
 error: unnecessary use of `splitn`
   --> $DIR/needless_splitn.rs:18:18
    |
 LL |     let (_, _) = str.splitn(3, '=').next_tuple().unwrap();
-   |                  ^^^^^^^^^^^^^^^^^^ help: try this: `str.split('=')`
+   |                  ^^^^^^^^^^^^^^^^^^ help: try: `str.split('=')`
 
 error: unnecessary use of `rsplitn`
   --> $DIR/needless_splitn.rs:21:13
    |
 LL |     let _ = str.rsplitn(2, '=').next();
-   |             ^^^^^^^^^^^^^^^^^^^ help: try this: `str.rsplit('=')`
+   |             ^^^^^^^^^^^^^^^^^^^ help: try: `str.rsplit('=')`
 
 error: unnecessary use of `rsplitn`
   --> $DIR/needless_splitn.rs:22:13
    |
 LL |     let _ = str.rsplitn(2, '=').nth(0);
-   |             ^^^^^^^^^^^^^^^^^^^ help: try this: `str.rsplit('=')`
+   |             ^^^^^^^^^^^^^^^^^^^ help: try: `str.rsplit('=')`
 
 error: unnecessary use of `rsplitn`
   --> $DIR/needless_splitn.rs:25:18
    |
 LL |     let (_, _) = str.rsplitn(3, '=').next_tuple().unwrap();
-   |                  ^^^^^^^^^^^^^^^^^^^ help: try this: `str.rsplit('=')`
+   |                  ^^^^^^^^^^^^^^^^^^^ help: try: `str.rsplit('=')`
 
 error: unnecessary use of `splitn`
   --> $DIR/needless_splitn.rs:27:13
    |
 LL |     let _ = str.splitn(5, '=').next();
-   |             ^^^^^^^^^^^^^^^^^^ help: try this: `str.split('=')`
+   |             ^^^^^^^^^^^^^^^^^^ help: try: `str.split('=')`
 
 error: unnecessary use of `splitn`
   --> $DIR/needless_splitn.rs:28:13
    |
 LL |     let _ = str.splitn(5, '=').nth(3);
-   |             ^^^^^^^^^^^^^^^^^^ help: try this: `str.split('=')`
+   |             ^^^^^^^^^^^^^^^^^^ help: try: `str.split('=')`
 
 error: unnecessary use of `splitn`
   --> $DIR/needless_splitn.rs:34:13
    |
 LL |     let _ = s.splitn(2, '=').next()?;
-   |             ^^^^^^^^^^^^^^^^ help: try this: `s.split('=')`
+   |             ^^^^^^^^^^^^^^^^ help: try: `s.split('=')`
 
 error: unnecessary use of `splitn`
   --> $DIR/needless_splitn.rs:35:13
    |
 LL |     let _ = s.splitn(2, '=').nth(0)?;
-   |             ^^^^^^^^^^^^^^^^ help: try this: `s.split('=')`
+   |             ^^^^^^^^^^^^^^^^ help: try: `s.split('=')`
 
 error: unnecessary use of `rsplitn`
   --> $DIR/needless_splitn.rs:36:13
    |
 LL |     let _ = s.rsplitn(2, '=').next()?;
-   |             ^^^^^^^^^^^^^^^^^ help: try this: `s.rsplit('=')`
+   |             ^^^^^^^^^^^^^^^^^ help: try: `s.rsplit('=')`
 
 error: unnecessary use of `rsplitn`
   --> $DIR/needless_splitn.rs:37:13
    |
 LL |     let _ = s.rsplitn(2, '=').nth(0)?;
-   |             ^^^^^^^^^^^^^^^^^ help: try this: `s.rsplit('=')`
+   |             ^^^^^^^^^^^^^^^^^ help: try: `s.rsplit('=')`
 
 error: unnecessary use of `splitn`
   --> $DIR/needless_splitn.rs:45:13
    |
 LL |     let _ = "key=value".splitn(2, '=').nth(0).unwrap();
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `"key=value".split('=')`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `"key=value".split('=')`
 
 error: aborting due to 13 previous errors
 
diff --git a/tests/ui/numbered_fields.stderr b/tests/ui/numbered_fields.stderr
index 60c0d789806..26f7ad9048b 100644
--- a/tests/ui/numbered_fields.stderr
+++ b/tests/ui/numbered_fields.stderr
@@ -7,7 +7,7 @@ LL | |         0: 1u32,
 LL | |         1: 42,
 LL | |         2: 23u8,
 LL | |     };
-   | |_____^ help: try this instead: `TupleStruct(1u32, 42, 23u8)`
+   | |_____^ help: try: `TupleStruct(1u32, 42, 23u8)`
    |
    = note: `-D clippy::init-numbered-fields` implied by `-D warnings`
 
@@ -20,7 +20,7 @@ LL | |         0: 1u32,
 LL | |         2: 2u8,
 LL | |         1: 3u32,
 LL | |     };
-   | |_____^ help: try this instead: `TupleStruct(1u32, 3u32, 2u8)`
+   | |_____^ help: try: `TupleStruct(1u32, 3u32, 2u8)`
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/option_map_unit_fn_fixable.stderr b/tests/ui/option_map_unit_fn_fixable.stderr
index 0305387b9f8..5be5f10b017 100644
--- a/tests/ui/option_map_unit_fn_fixable.stderr
+++ b/tests/ui/option_map_unit_fn_fixable.stderr
@@ -4,7 +4,7 @@ error: called `map(f)` on an `Option` value where `f` is a function that returns
 LL |     x.field.map(do_nothing);
    |     ^^^^^^^^^^^^^^^^^^^^^^^-
    |     |
-   |     help: try this: `if let Some(x_field) = x.field { do_nothing(x_field) }`
+   |     help: try: `if let Some(x_field) = x.field { do_nothing(x_field) }`
    |
    = note: `-D clippy::option-map-unit-fn` implied by `-D warnings`
 
@@ -14,7 +14,7 @@ error: called `map(f)` on an `Option` value where `f` is a function that returns
 LL |     x.field.map(do_nothing);
    |     ^^^^^^^^^^^^^^^^^^^^^^^-
    |     |
-   |     help: try this: `if let Some(x_field) = x.field { do_nothing(x_field) }`
+   |     help: try: `if let Some(x_field) = x.field { do_nothing(x_field) }`
 
 error: called `map(f)` on an `Option` value where `f` is a function that returns the unit type `()`
   --> $DIR/option_map_unit_fn_fixable.rs:42:5
@@ -22,7 +22,7 @@ error: called `map(f)` on an `Option` value where `f` is a function that returns
 LL |     x.field.map(diverge);
    |     ^^^^^^^^^^^^^^^^^^^^-
    |     |
-   |     help: try this: `if let Some(x_field) = x.field { diverge(x_field) }`
+   |     help: try: `if let Some(x_field) = x.field { diverge(x_field) }`
 
 error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
   --> $DIR/option_map_unit_fn_fixable.rs:48:5
@@ -30,7 +30,7 @@ error: called `map(f)` on an `Option` value where `f` is a closure that returns
 LL |     x.field.map(|value| x.do_option_nothing(value + captured));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
    |     |
-   |     help: try this: `if let Some(value) = x.field { x.do_option_nothing(value + captured) }`
+   |     help: try: `if let Some(value) = x.field { x.do_option_nothing(value + captured) }`
 
 error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
   --> $DIR/option_map_unit_fn_fixable.rs:50:5
@@ -38,7 +38,7 @@ error: called `map(f)` on an `Option` value where `f` is a closure that returns
 LL |     x.field.map(|value| { x.do_option_plus_one(value + captured); });
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
    |     |
-   |     help: try this: `if let Some(value) = x.field { x.do_option_plus_one(value + captured); }`
+   |     help: try: `if let Some(value) = x.field { x.do_option_plus_one(value + captured); }`
 
 error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
   --> $DIR/option_map_unit_fn_fixable.rs:53:5
@@ -46,7 +46,7 @@ error: called `map(f)` on an `Option` value where `f` is a closure that returns
 LL |     x.field.map(|value| do_nothing(value + captured));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
    |     |
-   |     help: try this: `if let Some(value) = x.field { do_nothing(value + captured) }`
+   |     help: try: `if let Some(value) = x.field { do_nothing(value + captured) }`
 
 error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
   --> $DIR/option_map_unit_fn_fixable.rs:55:5
@@ -54,7 +54,7 @@ error: called `map(f)` on an `Option` value where `f` is a closure that returns
 LL |     x.field.map(|value| { do_nothing(value + captured) });
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
    |     |
-   |     help: try this: `if let Some(value) = x.field { do_nothing(value + captured) }`
+   |     help: try: `if let Some(value) = x.field { do_nothing(value + captured) }`
 
 error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
   --> $DIR/option_map_unit_fn_fixable.rs:57:5
@@ -62,7 +62,7 @@ error: called `map(f)` on an `Option` value where `f` is a closure that returns
 LL |     x.field.map(|value| { do_nothing(value + captured); });
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
    |     |
-   |     help: try this: `if let Some(value) = x.field { do_nothing(value + captured); }`
+   |     help: try: `if let Some(value) = x.field { do_nothing(value + captured); }`
 
 error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
   --> $DIR/option_map_unit_fn_fixable.rs:59:5
@@ -70,7 +70,7 @@ error: called `map(f)` on an `Option` value where `f` is a closure that returns
 LL |     x.field.map(|value| { { do_nothing(value + captured); } });
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
    |     |
-   |     help: try this: `if let Some(value) = x.field { do_nothing(value + captured); }`
+   |     help: try: `if let Some(value) = x.field { do_nothing(value + captured); }`
 
 error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
   --> $DIR/option_map_unit_fn_fixable.rs:62:5
@@ -78,7 +78,7 @@ error: called `map(f)` on an `Option` value where `f` is a closure that returns
 LL |     x.field.map(|value| diverge(value + captured));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
    |     |
-   |     help: try this: `if let Some(value) = x.field { diverge(value + captured) }`
+   |     help: try: `if let Some(value) = x.field { diverge(value + captured) }`
 
 error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
   --> $DIR/option_map_unit_fn_fixable.rs:64:5
@@ -86,7 +86,7 @@ error: called `map(f)` on an `Option` value where `f` is a closure that returns
 LL |     x.field.map(|value| { diverge(value + captured) });
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
    |     |
-   |     help: try this: `if let Some(value) = x.field { diverge(value + captured) }`
+   |     help: try: `if let Some(value) = x.field { diverge(value + captured) }`
 
 error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
   --> $DIR/option_map_unit_fn_fixable.rs:66:5
@@ -94,7 +94,7 @@ error: called `map(f)` on an `Option` value where `f` is a closure that returns
 LL |     x.field.map(|value| { diverge(value + captured); });
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
    |     |
-   |     help: try this: `if let Some(value) = x.field { diverge(value + captured); }`
+   |     help: try: `if let Some(value) = x.field { diverge(value + captured); }`
 
 error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
   --> $DIR/option_map_unit_fn_fixable.rs:68:5
@@ -102,7 +102,7 @@ error: called `map(f)` on an `Option` value where `f` is a closure that returns
 LL |     x.field.map(|value| { { diverge(value + captured); } });
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
    |     |
-   |     help: try this: `if let Some(value) = x.field { diverge(value + captured); }`
+   |     help: try: `if let Some(value) = x.field { diverge(value + captured); }`
 
 error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
   --> $DIR/option_map_unit_fn_fixable.rs:73:5
@@ -110,7 +110,7 @@ error: called `map(f)` on an `Option` value where `f` is a closure that returns
 LL |     x.field.map(|value| { let y = plus_one(value + captured); });
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
    |     |
-   |     help: try this: `if let Some(value) = x.field { let y = plus_one(value + captured); }`
+   |     help: try: `if let Some(value) = x.field { let y = plus_one(value + captured); }`
 
 error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
   --> $DIR/option_map_unit_fn_fixable.rs:75:5
@@ -118,7 +118,7 @@ error: called `map(f)` on an `Option` value where `f` is a closure that returns
 LL |     x.field.map(|value| { plus_one(value + captured); });
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
    |     |
-   |     help: try this: `if let Some(value) = x.field { plus_one(value + captured); }`
+   |     help: try: `if let Some(value) = x.field { plus_one(value + captured); }`
 
 error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
   --> $DIR/option_map_unit_fn_fixable.rs:77:5
@@ -126,7 +126,7 @@ error: called `map(f)` on an `Option` value where `f` is a closure that returns
 LL |     x.field.map(|value| { { plus_one(value + captured); } });
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
    |     |
-   |     help: try this: `if let Some(value) = x.field { plus_one(value + captured); }`
+   |     help: try: `if let Some(value) = x.field { plus_one(value + captured); }`
 
 error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
   --> $DIR/option_map_unit_fn_fixable.rs:80:5
@@ -134,7 +134,7 @@ error: called `map(f)` on an `Option` value where `f` is a closure that returns
 LL |     x.field.map(|ref value| { do_nothing(value + captured) });
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
    |     |
-   |     help: try this: `if let Some(ref value) = x.field { do_nothing(value + captured) }`
+   |     help: try: `if let Some(ref value) = x.field { do_nothing(value + captured) }`
 
 error: called `map(f)` on an `Option` value where `f` is a function that returns the unit type `()`
   --> $DIR/option_map_unit_fn_fixable.rs:82:5
@@ -142,7 +142,7 @@ error: called `map(f)` on an `Option` value where `f` is a function that returns
 LL |     option().map(do_nothing);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^-
    |     |
-   |     help: try this: `if let Some(a) = option() { do_nothing(a) }`
+   |     help: try: `if let Some(a) = option() { do_nothing(a) }`
 
 error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
   --> $DIR/option_map_unit_fn_fixable.rs:84:5
@@ -150,7 +150,7 @@ error: called `map(f)` on an `Option` value where `f` is a closure that returns
 LL |     option().map(|value| println!("{:?}", value));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
    |     |
-   |     help: try this: `if let Some(value) = option() { println!("{:?}", value) }`
+   |     help: try: `if let Some(value) = option() { println!("{:?}", value) }`
 
 error: aborting due to 19 previous errors
 
diff --git a/tests/ui/or_fun_call.stderr b/tests/ui/or_fun_call.stderr
index 0b5c686bec0..3965ae52aed 100644
--- a/tests/ui/or_fun_call.stderr
+++ b/tests/ui/or_fun_call.stderr
@@ -2,7 +2,7 @@ error: use of `unwrap_or` followed by a function call
   --> $DIR/or_fun_call.rs:54:22
    |
 LL |     with_constructor.unwrap_or(make());
-   |                      ^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(make)`
+   |                      ^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(make)`
    |
    = note: `-D clippy::or-fun-call` implied by `-D warnings`
 
@@ -10,163 +10,163 @@ error: use of `unwrap_or` followed by a call to `new`
   --> $DIR/or_fun_call.rs:57:14
    |
 LL |     with_new.unwrap_or(Vec::new());
-   |              ^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_default()`
+   |              ^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: use of `unwrap_or` followed by a function call
   --> $DIR/or_fun_call.rs:60:21
    |
 LL |     with_const_args.unwrap_or(Vec::with_capacity(12));
-   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|| Vec::with_capacity(12))`
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| Vec::with_capacity(12))`
 
 error: use of `unwrap_or` followed by a function call
   --> $DIR/or_fun_call.rs:63:14
    |
 LL |     with_err.unwrap_or(make());
-   |              ^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|_| make())`
+   |              ^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|_| make())`
 
 error: use of `unwrap_or` followed by a function call
   --> $DIR/or_fun_call.rs:66:19
    |
 LL |     with_err_args.unwrap_or(Vec::with_capacity(12));
-   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|_| Vec::with_capacity(12))`
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|_| Vec::with_capacity(12))`
 
 error: use of `unwrap_or` followed by a call to `default`
   --> $DIR/or_fun_call.rs:69:24
    |
 LL |     with_default_trait.unwrap_or(Default::default());
-   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_default()`
+   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: use of `unwrap_or` followed by a call to `default`
   --> $DIR/or_fun_call.rs:72:23
    |
 LL |     with_default_type.unwrap_or(u64::default());
-   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_default()`
+   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: use of `unwrap_or` followed by a function call
   --> $DIR/or_fun_call.rs:75:18
    |
 LL |     self_default.unwrap_or(<FakeDefault>::default());
-   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(<FakeDefault>::default)`
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(<FakeDefault>::default)`
 
 error: use of `unwrap_or` followed by a call to `default`
   --> $DIR/or_fun_call.rs:78:18
    |
 LL |     real_default.unwrap_or(<FakeDefault as Default>::default());
-   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_default()`
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: use of `unwrap_or` followed by a call to `new`
   --> $DIR/or_fun_call.rs:81:14
    |
 LL |     with_vec.unwrap_or(vec![]);
-   |              ^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_default()`
+   |              ^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: use of `unwrap_or` followed by a function call
   --> $DIR/or_fun_call.rs:84:21
    |
 LL |     without_default.unwrap_or(Foo::new());
-   |                     ^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(Foo::new)`
+   |                     ^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(Foo::new)`
 
 error: use of `or_insert` followed by a call to `new`
   --> $DIR/or_fun_call.rs:87:19
    |
 LL |     map.entry(42).or_insert(String::new());
-   |                   ^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `or_default()`
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `or_default()`
 
 error: use of `or_insert` followed by a call to `new`
   --> $DIR/or_fun_call.rs:90:23
    |
 LL |     map_vec.entry(42).or_insert(vec![]);
-   |                       ^^^^^^^^^^^^^^^^^ help: try this: `or_default()`
+   |                       ^^^^^^^^^^^^^^^^^ help: try: `or_default()`
 
 error: use of `or_insert` followed by a call to `new`
   --> $DIR/or_fun_call.rs:93:21
    |
 LL |     btree.entry(42).or_insert(String::new());
-   |                     ^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `or_default()`
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `or_default()`
 
 error: use of `or_insert` followed by a call to `new`
   --> $DIR/or_fun_call.rs:96:25
    |
 LL |     btree_vec.entry(42).or_insert(vec![]);
-   |                         ^^^^^^^^^^^^^^^^^ help: try this: `or_default()`
+   |                         ^^^^^^^^^^^^^^^^^ help: try: `or_default()`
 
 error: use of `unwrap_or` followed by a call to `new`
   --> $DIR/or_fun_call.rs:99:21
    |
 LL |     let _ = stringy.unwrap_or(String::new());
-   |                     ^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_default()`
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: use of `unwrap_or` followed by a function call
   --> $DIR/or_fun_call.rs:107:21
    |
 LL |     let _ = Some(1).unwrap_or(map[&1]);
-   |                     ^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|| map[&1])`
+   |                     ^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| map[&1])`
 
 error: use of `unwrap_or` followed by a function call
   --> $DIR/or_fun_call.rs:109:21
    |
 LL |     let _ = Some(1).unwrap_or(map[&1]);
-   |                     ^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|| map[&1])`
+   |                     ^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| map[&1])`
 
 error: use of `or` followed by a function call
   --> $DIR/or_fun_call.rs:133:35
    |
 LL |     let _ = Some("a".to_string()).or(Some("b".to_string()));
-   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `or_else(|| Some("b".to_string()))`
+   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `or_else(|| Some("b".to_string()))`
 
 error: use of `unwrap_or` followed by a function call
   --> $DIR/or_fun_call.rs:172:14
    |
 LL |         None.unwrap_or(ptr_to_ref(s));
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|| ptr_to_ref(s))`
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| ptr_to_ref(s))`
 
 error: use of `unwrap_or` followed by a function call
   --> $DIR/or_fun_call.rs:178:14
    |
 LL |         None.unwrap_or(unsafe { ptr_to_ref(s) });
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|| unsafe { ptr_to_ref(s) })`
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| unsafe { ptr_to_ref(s) })`
 
 error: use of `unwrap_or` followed by a function call
   --> $DIR/or_fun_call.rs:180:14
    |
 LL |         None.unwrap_or( unsafe { ptr_to_ref(s) }    );
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|| unsafe { ptr_to_ref(s) })`
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| unsafe { ptr_to_ref(s) })`
 
 error: use of `unwrap_or` followed by a call to `new`
   --> $DIR/or_fun_call.rs:194:14
    |
 LL |             .unwrap_or(String::new());
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_default()`
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: use of `unwrap_or` followed by a call to `new`
   --> $DIR/or_fun_call.rs:207:14
    |
 LL |             .unwrap_or(String::new());
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_default()`
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: use of `unwrap_or` followed by a call to `new`
   --> $DIR/or_fun_call.rs:219:14
    |
 LL |             .unwrap_or(String::new());
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_default()`
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: use of `unwrap_or` followed by a call to `new`
   --> $DIR/or_fun_call.rs:230:10
    |
 LL |         .unwrap_or(String::new());
-   |          ^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_default()`
+   |          ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: use of `map_or` followed by a function call
   --> $DIR/or_fun_call.rs:255:25
    |
 LL |         let _ = Some(4).map_or(g(), |v| v);
-   |                         ^^^^^^^^^^^^^^^^^^ help: try this: `map_or_else(g, |v| v)`
+   |                         ^^^^^^^^^^^^^^^^^^ help: try: `map_or_else(g, |v| v)`
 
 error: use of `map_or` followed by a function call
   --> $DIR/or_fun_call.rs:256:25
    |
 LL |         let _ = Some(4).map_or(g(), f);
-   |                         ^^^^^^^^^^^^^^ help: try this: `map_or_else(g, f)`
+   |                         ^^^^^^^^^^^^^^ help: try: `map_or_else(g, f)`
 
 error: aborting due to 28 previous errors
 
diff --git a/tests/ui/or_then_unwrap.stderr b/tests/ui/or_then_unwrap.stderr
index da88154c59f..2a1a52407dc 100644
--- a/tests/ui/or_then_unwrap.stderr
+++ b/tests/ui/or_then_unwrap.stderr
@@ -2,7 +2,7 @@ error: found `.or(Some(…)).unwrap()`
   --> $DIR/or_then_unwrap.rs:24:20
    |
 LL |     let _ = option.or(Some("fallback")).unwrap(); // should trigger lint
-   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or("fallback")`
+   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or("fallback")`
    |
    = note: `-D clippy::or-then-unwrap` implied by `-D warnings`
 
@@ -10,13 +10,13 @@ error: found `.or(Ok(…)).unwrap()`
   --> $DIR/or_then_unwrap.rs:27:20
    |
 LL |     let _ = result.or::<&str>(Ok("fallback")).unwrap(); // should trigger lint
-   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or("fallback")`
+   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or("fallback")`
 
 error: found `.or(Some(…)).unwrap()`
   --> $DIR/or_then_unwrap.rs:31:31
    |
 LL |     let _ = option.map(|v| v).or(Some("fallback")).unwrap().to_string().chars(); // should trigger lint
-   |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or("fallback")`
+   |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or("fallback")`
 
 error: aborting due to 3 previous errors
 
diff --git a/tests/ui/print_literal.stderr b/tests/ui/print_literal.stderr
index 6404dacdafa..71c8d188f16 100644
--- a/tests/ui/print_literal.stderr
+++ b/tests/ui/print_literal.stderr
@@ -5,7 +5,7 @@ LL |     print!("Hello {}", "world");
    |                        ^^^^^^^
    |
    = note: `-D clippy::print-literal` implied by `-D warnings`
-help: try this
+help: try
    |
 LL -     print!("Hello {}", "world");
 LL +     print!("Hello world");
@@ -17,7 +17,7 @@ error: literal with an empty format string
 LL |     println!("Hello {} {}", world, "world");
    |                                    ^^^^^^^
    |
-help: try this
+help: try
    |
 LL -     println!("Hello {} {}", world, "world");
 LL +     println!("Hello {} world", world);
@@ -29,7 +29,7 @@ error: literal with an empty format string
 LL |     println!("Hello {}", "world");
    |                          ^^^^^^^
    |
-help: try this
+help: try
    |
 LL -     println!("Hello {}", "world");
 LL +     println!("Hello world");
@@ -41,7 +41,7 @@ error: literal with an empty format string
 LL |     println!("{} {:.4}", "a literal", 5);
    |                          ^^^^^^^^^^^
    |
-help: try this
+help: try
    |
 LL -     println!("{} {:.4}", "a literal", 5);
 LL +     println!("a literal {:.4}", 5);
@@ -53,7 +53,7 @@ error: literal with an empty format string
 LL |     println!("{0} {1}", "hello", "world");
    |                         ^^^^^^^
    |
-help: try this
+help: try
    |
 LL -     println!("{0} {1}", "hello", "world");
 LL +     println!("hello {1}", "world");
@@ -65,7 +65,7 @@ error: literal with an empty format string
 LL |     println!("{0} {1}", "hello", "world");
    |                                  ^^^^^^^
    |
-help: try this
+help: try
    |
 LL -     println!("{0} {1}", "hello", "world");
 LL +     println!("{0} world", "hello");
@@ -77,7 +77,7 @@ error: literal with an empty format string
 LL |     println!("{1} {0}", "hello", "world");
    |                                  ^^^^^^^
    |
-help: try this
+help: try
    |
 LL -     println!("{1} {0}", "hello", "world");
 LL +     println!("world {0}", "hello");
@@ -89,7 +89,7 @@ error: literal with an empty format string
 LL |     println!("{1} {0}", "hello", "world");
    |                         ^^^^^^^
    |
-help: try this
+help: try
    |
 LL -     println!("{1} {0}", "hello", "world");
 LL +     println!("{1} hello", "world");
@@ -101,7 +101,7 @@ error: literal with an empty format string
 LL |     println!("{foo} {bar}", foo = "hello", bar = "world");
    |                                   ^^^^^^^
    |
-help: try this
+help: try
    |
 LL -     println!("{foo} {bar}", foo = "hello", bar = "world");
 LL +     println!("hello {bar}", bar = "world");
@@ -113,7 +113,7 @@ error: literal with an empty format string
 LL |     println!("{foo} {bar}", foo = "hello", bar = "world");
    |                                                  ^^^^^^^
    |
-help: try this
+help: try
    |
 LL -     println!("{foo} {bar}", foo = "hello", bar = "world");
 LL +     println!("{foo} world", foo = "hello");
@@ -125,7 +125,7 @@ error: literal with an empty format string
 LL |     println!("{bar} {foo}", foo = "hello", bar = "world");
    |                                                  ^^^^^^^
    |
-help: try this
+help: try
    |
 LL -     println!("{bar} {foo}", foo = "hello", bar = "world");
 LL +     println!("world {foo}", foo = "hello");
@@ -137,7 +137,7 @@ error: literal with an empty format string
 LL |     println!("{bar} {foo}", foo = "hello", bar = "world");
    |                                   ^^^^^^^
    |
-help: try this
+help: try
    |
 LL -     println!("{bar} {foo}", foo = "hello", bar = "world");
 LL +     println!("{bar} hello", bar = "world");
diff --git a/tests/ui/redundant_pattern_matching_drop_order.stderr b/tests/ui/redundant_pattern_matching_drop_order.stderr
index e9ea3f2e688..28f33f0c95d 100644
--- a/tests/ui/redundant_pattern_matching_drop_order.stderr
+++ b/tests/ui/redundant_pattern_matching_drop_order.stderr
@@ -2,7 +2,7 @@ error: redundant pattern matching, consider using `is_ok()`
   --> $DIR/redundant_pattern_matching_drop_order.rs:17:12
    |
 LL |     if let Ok(_) = m.lock() {}
-   |     -------^^^^^----------- help: try this: `if m.lock().is_ok()`
+   |     -------^^^^^----------- help: try: `if m.lock().is_ok()`
    |
    = note: this will change drop order of the result, as well as all temporaries
    = note: add `#[allow(clippy::redundant_pattern_matching)]` if this is important
@@ -12,7 +12,7 @@ error: redundant pattern matching, consider using `is_err()`
   --> $DIR/redundant_pattern_matching_drop_order.rs:18:12
    |
 LL |     if let Err(_) = Err::<(), _>(m.lock().unwrap().0) {}
-   |     -------^^^^^^------------------------------------ help: try this: `if Err::<(), _>(m.lock().unwrap().0).is_err()`
+   |     -------^^^^^^------------------------------------ help: try: `if Err::<(), _>(m.lock().unwrap().0).is_err()`
    |
    = note: this will change drop order of the result, as well as all temporaries
    = note: add `#[allow(clippy::redundant_pattern_matching)]` if this is important
@@ -21,7 +21,7 @@ error: redundant pattern matching, consider using `is_ok()`
   --> $DIR/redundant_pattern_matching_drop_order.rs:21:16
    |
 LL |         if let Ok(_) = Ok::<_, std::sync::MutexGuard<()>>(()) {}
-   |         -------^^^^^----------------------------------------- help: try this: `if Ok::<_, std::sync::MutexGuard<()>>(()).is_ok()`
+   |         -------^^^^^----------------------------------------- help: try: `if Ok::<_, std::sync::MutexGuard<()>>(()).is_ok()`
    |
    = note: this will change drop order of the result, as well as all temporaries
    = note: add `#[allow(clippy::redundant_pattern_matching)]` if this is important
@@ -30,7 +30,7 @@ error: redundant pattern matching, consider using `is_ok()`
   --> $DIR/redundant_pattern_matching_drop_order.rs:23:12
    |
 LL |     if let Ok(_) = Ok::<_, std::sync::MutexGuard<()>>(()) {
-   |     -------^^^^^----------------------------------------- help: try this: `if Ok::<_, std::sync::MutexGuard<()>>(()).is_ok()`
+   |     -------^^^^^----------------------------------------- help: try: `if Ok::<_, std::sync::MutexGuard<()>>(()).is_ok()`
    |
    = note: this will change drop order of the result, as well as all temporaries
    = note: add `#[allow(clippy::redundant_pattern_matching)]` if this is important
@@ -39,31 +39,31 @@ error: redundant pattern matching, consider using `is_ok()`
   --> $DIR/redundant_pattern_matching_drop_order.rs:26:12
    |
 LL |     if let Ok(_) = Ok::<_, std::sync::MutexGuard<()>>(()) {}
-   |     -------^^^^^----------------------------------------- help: try this: `if Ok::<_, std::sync::MutexGuard<()>>(()).is_ok()`
+   |     -------^^^^^----------------------------------------- help: try: `if Ok::<_, std::sync::MutexGuard<()>>(()).is_ok()`
 
 error: redundant pattern matching, consider using `is_err()`
   --> $DIR/redundant_pattern_matching_drop_order.rs:27:12
    |
 LL |     if let Err(_) = Err::<std::sync::MutexGuard<()>, _>(()) {}
-   |     -------^^^^^^------------------------------------------ help: try this: `if Err::<std::sync::MutexGuard<()>, _>(()).is_err()`
+   |     -------^^^^^^------------------------------------------ help: try: `if Err::<std::sync::MutexGuard<()>, _>(()).is_err()`
 
 error: redundant pattern matching, consider using `is_ok()`
   --> $DIR/redundant_pattern_matching_drop_order.rs:29:12
    |
 LL |     if let Ok(_) = Ok::<_, ()>(String::new()) {}
-   |     -------^^^^^----------------------------- help: try this: `if Ok::<_, ()>(String::new()).is_ok()`
+   |     -------^^^^^----------------------------- help: try: `if Ok::<_, ()>(String::new()).is_ok()`
 
 error: redundant pattern matching, consider using `is_err()`
   --> $DIR/redundant_pattern_matching_drop_order.rs:30:12
    |
 LL |     if let Err(_) = Err::<(), _>((String::new(), ())) {}
-   |     -------^^^^^^------------------------------------ help: try this: `if Err::<(), _>((String::new(), ())).is_err()`
+   |     -------^^^^^^------------------------------------ help: try: `if Err::<(), _>((String::new(), ())).is_err()`
 
 error: redundant pattern matching, consider using `is_some()`
   --> $DIR/redundant_pattern_matching_drop_order.rs:33:12
    |
 LL |     if let Some(_) = Some(m.lock()) {}
-   |     -------^^^^^^^----------------- help: try this: `if Some(m.lock()).is_some()`
+   |     -------^^^^^^^----------------- help: try: `if Some(m.lock()).is_some()`
    |
    = note: this will change drop order of the result, as well as all temporaries
    = note: add `#[allow(clippy::redundant_pattern_matching)]` if this is important
@@ -72,7 +72,7 @@ error: redundant pattern matching, consider using `is_some()`
   --> $DIR/redundant_pattern_matching_drop_order.rs:34:12
    |
 LL |     if let Some(_) = Some(m.lock().unwrap().0) {}
-   |     -------^^^^^^^---------------------------- help: try this: `if Some(m.lock().unwrap().0).is_some()`
+   |     -------^^^^^^^---------------------------- help: try: `if Some(m.lock().unwrap().0).is_some()`
    |
    = note: this will change drop order of the result, as well as all temporaries
    = note: add `#[allow(clippy::redundant_pattern_matching)]` if this is important
@@ -81,7 +81,7 @@ error: redundant pattern matching, consider using `is_none()`
   --> $DIR/redundant_pattern_matching_drop_order.rs:37:16
    |
 LL |         if let None = None::<std::sync::MutexGuard<()>> {}
-   |         -------^^^^------------------------------------ help: try this: `if None::<std::sync::MutexGuard<()>>.is_none()`
+   |         -------^^^^------------------------------------ help: try: `if None::<std::sync::MutexGuard<()>>.is_none()`
    |
    = note: this will change drop order of the result, as well as all temporaries
    = note: add `#[allow(clippy::redundant_pattern_matching)]` if this is important
@@ -90,7 +90,7 @@ error: redundant pattern matching, consider using `is_none()`
   --> $DIR/redundant_pattern_matching_drop_order.rs:39:12
    |
 LL |     if let None = None::<std::sync::MutexGuard<()>> {
-   |     -------^^^^------------------------------------ help: try this: `if None::<std::sync::MutexGuard<()>>.is_none()`
+   |     -------^^^^------------------------------------ help: try: `if None::<std::sync::MutexGuard<()>>.is_none()`
    |
    = note: this will change drop order of the result, as well as all temporaries
    = note: add `#[allow(clippy::redundant_pattern_matching)]` if this is important
@@ -99,25 +99,25 @@ error: redundant pattern matching, consider using `is_none()`
   --> $DIR/redundant_pattern_matching_drop_order.rs:43:12
    |
 LL |     if let None = None::<std::sync::MutexGuard<()>> {}
-   |     -------^^^^------------------------------------ help: try this: `if None::<std::sync::MutexGuard<()>>.is_none()`
+   |     -------^^^^------------------------------------ help: try: `if None::<std::sync::MutexGuard<()>>.is_none()`
 
 error: redundant pattern matching, consider using `is_some()`
   --> $DIR/redundant_pattern_matching_drop_order.rs:45:12
    |
 LL |     if let Some(_) = Some(String::new()) {}
-   |     -------^^^^^^^---------------------- help: try this: `if Some(String::new()).is_some()`
+   |     -------^^^^^^^---------------------- help: try: `if Some(String::new()).is_some()`
 
 error: redundant pattern matching, consider using `is_some()`
   --> $DIR/redundant_pattern_matching_drop_order.rs:46:12
    |
 LL |     if let Some(_) = Some((String::new(), ())) {}
-   |     -------^^^^^^^---------------------------- help: try this: `if Some((String::new(), ())).is_some()`
+   |     -------^^^^^^^---------------------------- help: try: `if Some((String::new(), ())).is_some()`
 
 error: redundant pattern matching, consider using `is_ready()`
   --> $DIR/redundant_pattern_matching_drop_order.rs:49:12
    |
 LL |     if let Ready(_) = Ready(m.lock()) {}
-   |     -------^^^^^^^^------------------ help: try this: `if Ready(m.lock()).is_ready()`
+   |     -------^^^^^^^^------------------ help: try: `if Ready(m.lock()).is_ready()`
    |
    = note: this will change drop order of the result, as well as all temporaries
    = note: add `#[allow(clippy::redundant_pattern_matching)]` if this is important
@@ -126,7 +126,7 @@ error: redundant pattern matching, consider using `is_ready()`
   --> $DIR/redundant_pattern_matching_drop_order.rs:50:12
    |
 LL |     if let Ready(_) = Ready(m.lock().unwrap().0) {}
-   |     -------^^^^^^^^----------------------------- help: try this: `if Ready(m.lock().unwrap().0).is_ready()`
+   |     -------^^^^^^^^----------------------------- help: try: `if Ready(m.lock().unwrap().0).is_ready()`
    |
    = note: this will change drop order of the result, as well as all temporaries
    = note: add `#[allow(clippy::redundant_pattern_matching)]` if this is important
@@ -135,7 +135,7 @@ error: redundant pattern matching, consider using `is_pending()`
   --> $DIR/redundant_pattern_matching_drop_order.rs:53:16
    |
 LL |         if let Pending = Pending::<std::sync::MutexGuard<()>> {}
-   |         -------^^^^^^^--------------------------------------- help: try this: `if Pending::<std::sync::MutexGuard<()>>.is_pending()`
+   |         -------^^^^^^^--------------------------------------- help: try: `if Pending::<std::sync::MutexGuard<()>>.is_pending()`
    |
    = note: this will change drop order of the result, as well as all temporaries
    = note: add `#[allow(clippy::redundant_pattern_matching)]` if this is important
@@ -144,7 +144,7 @@ error: redundant pattern matching, consider using `is_pending()`
   --> $DIR/redundant_pattern_matching_drop_order.rs:55:12
    |
 LL |     if let Pending = Pending::<std::sync::MutexGuard<()>> {
-   |     -------^^^^^^^--------------------------------------- help: try this: `if Pending::<std::sync::MutexGuard<()>>.is_pending()`
+   |     -------^^^^^^^--------------------------------------- help: try: `if Pending::<std::sync::MutexGuard<()>>.is_pending()`
    |
    = note: this will change drop order of the result, as well as all temporaries
    = note: add `#[allow(clippy::redundant_pattern_matching)]` if this is important
@@ -153,19 +153,19 @@ error: redundant pattern matching, consider using `is_pending()`
   --> $DIR/redundant_pattern_matching_drop_order.rs:59:12
    |
 LL |     if let Pending = Pending::<std::sync::MutexGuard<()>> {}
-   |     -------^^^^^^^--------------------------------------- help: try this: `if Pending::<std::sync::MutexGuard<()>>.is_pending()`
+   |     -------^^^^^^^--------------------------------------- help: try: `if Pending::<std::sync::MutexGuard<()>>.is_pending()`
 
 error: redundant pattern matching, consider using `is_ready()`
   --> $DIR/redundant_pattern_matching_drop_order.rs:61:12
    |
 LL |     if let Ready(_) = Ready(String::new()) {}
-   |     -------^^^^^^^^----------------------- help: try this: `if Ready(String::new()).is_ready()`
+   |     -------^^^^^^^^----------------------- help: try: `if Ready(String::new()).is_ready()`
 
 error: redundant pattern matching, consider using `is_ready()`
   --> $DIR/redundant_pattern_matching_drop_order.rs:62:12
    |
 LL |     if let Ready(_) = Ready((String::new(), ())) {}
-   |     -------^^^^^^^^----------------------------- help: try this: `if Ready((String::new(), ())).is_ready()`
+   |     -------^^^^^^^^----------------------------- help: try: `if Ready((String::new(), ())).is_ready()`
 
 error: aborting due to 22 previous errors
 
diff --git a/tests/ui/redundant_pattern_matching_ipaddr.stderr b/tests/ui/redundant_pattern_matching_ipaddr.stderr
index 6d1fb296463..f34dc709833 100644
--- a/tests/ui/redundant_pattern_matching_ipaddr.stderr
+++ b/tests/ui/redundant_pattern_matching_ipaddr.stderr
@@ -2,7 +2,7 @@ error: redundant pattern matching, consider using `is_ipv4()`
   --> $DIR/redundant_pattern_matching_ipaddr.rs:18:12
    |
 LL |     if let V4(_) = &ipaddr {}
-   |     -------^^^^^---------- help: try this: `if ipaddr.is_ipv4()`
+   |     -------^^^^^---------- help: try: `if ipaddr.is_ipv4()`
    |
    = note: `-D clippy::redundant-pattern-matching` implied by `-D warnings`
 
@@ -10,25 +10,25 @@ error: redundant pattern matching, consider using `is_ipv4()`
   --> $DIR/redundant_pattern_matching_ipaddr.rs:20:12
    |
 LL |     if let V4(_) = V4(Ipv4Addr::LOCALHOST) {}
-   |     -------^^^^^-------------------------- help: try this: `if V4(Ipv4Addr::LOCALHOST).is_ipv4()`
+   |     -------^^^^^-------------------------- help: try: `if V4(Ipv4Addr::LOCALHOST).is_ipv4()`
 
 error: redundant pattern matching, consider using `is_ipv6()`
   --> $DIR/redundant_pattern_matching_ipaddr.rs:22:12
    |
 LL |     if let V6(_) = V6(Ipv6Addr::LOCALHOST) {}
-   |     -------^^^^^-------------------------- help: try this: `if V6(Ipv6Addr::LOCALHOST).is_ipv6()`
+   |     -------^^^^^-------------------------- help: try: `if V6(Ipv6Addr::LOCALHOST).is_ipv6()`
 
 error: redundant pattern matching, consider using `is_ipv4()`
   --> $DIR/redundant_pattern_matching_ipaddr.rs:24:15
    |
 LL |     while let V4(_) = V4(Ipv4Addr::LOCALHOST) {}
-   |     ----------^^^^^-------------------------- help: try this: `while V4(Ipv4Addr::LOCALHOST).is_ipv4()`
+   |     ----------^^^^^-------------------------- help: try: `while V4(Ipv4Addr::LOCALHOST).is_ipv4()`
 
 error: redundant pattern matching, consider using `is_ipv6()`
   --> $DIR/redundant_pattern_matching_ipaddr.rs:26:15
    |
 LL |     while let V6(_) = V6(Ipv6Addr::LOCALHOST) {}
-   |     ----------^^^^^-------------------------- help: try this: `while V6(Ipv6Addr::LOCALHOST).is_ipv6()`
+   |     ----------^^^^^-------------------------- help: try: `while V6(Ipv6Addr::LOCALHOST).is_ipv6()`
 
 error: redundant pattern matching, consider using `is_ipv4()`
   --> $DIR/redundant_pattern_matching_ipaddr.rs:36:5
@@ -37,7 +37,7 @@ LL | /     match V4(Ipv4Addr::LOCALHOST) {
 LL | |         V4(_) => true,
 LL | |         V6(_) => false,
 LL | |     };
-   | |_____^ help: try this: `V4(Ipv4Addr::LOCALHOST).is_ipv4()`
+   | |_____^ help: try: `V4(Ipv4Addr::LOCALHOST).is_ipv4()`
 
 error: redundant pattern matching, consider using `is_ipv6()`
   --> $DIR/redundant_pattern_matching_ipaddr.rs:41:5
@@ -46,7 +46,7 @@ LL | /     match V4(Ipv4Addr::LOCALHOST) {
 LL | |         V4(_) => false,
 LL | |         V6(_) => true,
 LL | |     };
-   | |_____^ help: try this: `V4(Ipv4Addr::LOCALHOST).is_ipv6()`
+   | |_____^ help: try: `V4(Ipv4Addr::LOCALHOST).is_ipv6()`
 
 error: redundant pattern matching, consider using `is_ipv6()`
   --> $DIR/redundant_pattern_matching_ipaddr.rs:46:5
@@ -55,7 +55,7 @@ LL | /     match V6(Ipv6Addr::LOCALHOST) {
 LL | |         V4(_) => false,
 LL | |         V6(_) => true,
 LL | |     };
-   | |_____^ help: try this: `V6(Ipv6Addr::LOCALHOST).is_ipv6()`
+   | |_____^ help: try: `V6(Ipv6Addr::LOCALHOST).is_ipv6()`
 
 error: redundant pattern matching, consider using `is_ipv4()`
   --> $DIR/redundant_pattern_matching_ipaddr.rs:51:5
@@ -64,49 +64,49 @@ LL | /     match V6(Ipv6Addr::LOCALHOST) {
 LL | |         V4(_) => true,
 LL | |         V6(_) => false,
 LL | |     };
-   | |_____^ help: try this: `V6(Ipv6Addr::LOCALHOST).is_ipv4()`
+   | |_____^ help: try: `V6(Ipv6Addr::LOCALHOST).is_ipv4()`
 
 error: redundant pattern matching, consider using `is_ipv4()`
   --> $DIR/redundant_pattern_matching_ipaddr.rs:56:20
    |
 LL |     let _ = if let V4(_) = V4(Ipv4Addr::LOCALHOST) {
-   |             -------^^^^^-------------------------- help: try this: `if V4(Ipv4Addr::LOCALHOST).is_ipv4()`
+   |             -------^^^^^-------------------------- help: try: `if V4(Ipv4Addr::LOCALHOST).is_ipv4()`
 
 error: redundant pattern matching, consider using `is_ipv4()`
   --> $DIR/redundant_pattern_matching_ipaddr.rs:64:20
    |
 LL |     let _ = if let V4(_) = gen_ipaddr() {
-   |             -------^^^^^--------------- help: try this: `if gen_ipaddr().is_ipv4()`
+   |             -------^^^^^--------------- help: try: `if gen_ipaddr().is_ipv4()`
 
 error: redundant pattern matching, consider using `is_ipv6()`
   --> $DIR/redundant_pattern_matching_ipaddr.rs:66:19
    |
 LL |     } else if let V6(_) = gen_ipaddr() {
-   |            -------^^^^^--------------- help: try this: `if gen_ipaddr().is_ipv6()`
+   |            -------^^^^^--------------- help: try: `if gen_ipaddr().is_ipv6()`
 
 error: redundant pattern matching, consider using `is_ipv4()`
   --> $DIR/redundant_pattern_matching_ipaddr.rs:78:12
    |
 LL |     if let V4(_) = V4(Ipv4Addr::LOCALHOST) {}
-   |     -------^^^^^-------------------------- help: try this: `if V4(Ipv4Addr::LOCALHOST).is_ipv4()`
+   |     -------^^^^^-------------------------- help: try: `if V4(Ipv4Addr::LOCALHOST).is_ipv4()`
 
 error: redundant pattern matching, consider using `is_ipv6()`
   --> $DIR/redundant_pattern_matching_ipaddr.rs:80:12
    |
 LL |     if let V6(_) = V6(Ipv6Addr::LOCALHOST) {}
-   |     -------^^^^^-------------------------- help: try this: `if V6(Ipv6Addr::LOCALHOST).is_ipv6()`
+   |     -------^^^^^-------------------------- help: try: `if V6(Ipv6Addr::LOCALHOST).is_ipv6()`
 
 error: redundant pattern matching, consider using `is_ipv4()`
   --> $DIR/redundant_pattern_matching_ipaddr.rs:82:15
    |
 LL |     while let V4(_) = V4(Ipv4Addr::LOCALHOST) {}
-   |     ----------^^^^^-------------------------- help: try this: `while V4(Ipv4Addr::LOCALHOST).is_ipv4()`
+   |     ----------^^^^^-------------------------- help: try: `while V4(Ipv4Addr::LOCALHOST).is_ipv4()`
 
 error: redundant pattern matching, consider using `is_ipv6()`
   --> $DIR/redundant_pattern_matching_ipaddr.rs:84:15
    |
 LL |     while let V6(_) = V6(Ipv6Addr::LOCALHOST) {}
-   |     ----------^^^^^-------------------------- help: try this: `while V6(Ipv6Addr::LOCALHOST).is_ipv6()`
+   |     ----------^^^^^-------------------------- help: try: `while V6(Ipv6Addr::LOCALHOST).is_ipv6()`
 
 error: redundant pattern matching, consider using `is_ipv4()`
   --> $DIR/redundant_pattern_matching_ipaddr.rs:86:5
@@ -115,7 +115,7 @@ LL | /     match V4(Ipv4Addr::LOCALHOST) {
 LL | |         V4(_) => true,
 LL | |         V6(_) => false,
 LL | |     };
-   | |_____^ help: try this: `V4(Ipv4Addr::LOCALHOST).is_ipv4()`
+   | |_____^ help: try: `V4(Ipv4Addr::LOCALHOST).is_ipv4()`
 
 error: redundant pattern matching, consider using `is_ipv6()`
   --> $DIR/redundant_pattern_matching_ipaddr.rs:91:5
@@ -124,7 +124,7 @@ LL | /     match V6(Ipv6Addr::LOCALHOST) {
 LL | |         V4(_) => false,
 LL | |         V6(_) => true,
 LL | |     };
-   | |_____^ help: try this: `V6(Ipv6Addr::LOCALHOST).is_ipv6()`
+   | |_____^ help: try: `V6(Ipv6Addr::LOCALHOST).is_ipv6()`
 
 error: aborting due to 18 previous errors
 
diff --git a/tests/ui/redundant_pattern_matching_option.stderr b/tests/ui/redundant_pattern_matching_option.stderr
index 717b603c496..097ca827a42 100644
--- a/tests/ui/redundant_pattern_matching_option.stderr
+++ b/tests/ui/redundant_pattern_matching_option.stderr
@@ -2,7 +2,7 @@ error: redundant pattern matching, consider using `is_none()`
   --> $DIR/redundant_pattern_matching_option.rs:15:12
    |
 LL |     if let None = None::<()> {}
-   |     -------^^^^------------- help: try this: `if None::<()>.is_none()`
+   |     -------^^^^------------- help: try: `if None::<()>.is_none()`
    |
    = note: `-D clippy::redundant-pattern-matching` implied by `-D warnings`
 
@@ -10,37 +10,37 @@ error: redundant pattern matching, consider using `is_some()`
   --> $DIR/redundant_pattern_matching_option.rs:17:12
    |
 LL |     if let Some(_) = Some(42) {}
-   |     -------^^^^^^^----------- help: try this: `if Some(42).is_some()`
+   |     -------^^^^^^^----------- help: try: `if Some(42).is_some()`
 
 error: redundant pattern matching, consider using `is_some()`
   --> $DIR/redundant_pattern_matching_option.rs:19:12
    |
 LL |     if let Some(_) = Some(42) {
-   |     -------^^^^^^^----------- help: try this: `if Some(42).is_some()`
+   |     -------^^^^^^^----------- help: try: `if Some(42).is_some()`
 
 error: redundant pattern matching, consider using `is_some()`
   --> $DIR/redundant_pattern_matching_option.rs:25:15
    |
 LL |     while let Some(_) = Some(42) {}
-   |     ----------^^^^^^^----------- help: try this: `while Some(42).is_some()`
+   |     ----------^^^^^^^----------- help: try: `while Some(42).is_some()`
 
 error: redundant pattern matching, consider using `is_none()`
   --> $DIR/redundant_pattern_matching_option.rs:27:15
    |
 LL |     while let None = Some(42) {}
-   |     ----------^^^^----------- help: try this: `while Some(42).is_none()`
+   |     ----------^^^^----------- help: try: `while Some(42).is_none()`
 
 error: redundant pattern matching, consider using `is_none()`
   --> $DIR/redundant_pattern_matching_option.rs:29:15
    |
 LL |     while let None = None::<()> {}
-   |     ----------^^^^------------- help: try this: `while None::<()>.is_none()`
+   |     ----------^^^^------------- help: try: `while None::<()>.is_none()`
 
 error: redundant pattern matching, consider using `is_some()`
   --> $DIR/redundant_pattern_matching_option.rs:32:15
    |
 LL |     while let Some(_) = v.pop() {
-   |     ----------^^^^^^^---------- help: try this: `while v.pop().is_some()`
+   |     ----------^^^^^^^---------- help: try: `while v.pop().is_some()`
 
 error: redundant pattern matching, consider using `is_some()`
   --> $DIR/redundant_pattern_matching_option.rs:40:5
@@ -49,7 +49,7 @@ LL | /     match Some(42) {
 LL | |         Some(_) => true,
 LL | |         None => false,
 LL | |     };
-   | |_____^ help: try this: `Some(42).is_some()`
+   | |_____^ help: try: `Some(42).is_some()`
 
 error: redundant pattern matching, consider using `is_none()`
   --> $DIR/redundant_pattern_matching_option.rs:45:5
@@ -58,7 +58,7 @@ LL | /     match None::<()> {
 LL | |         Some(_) => false,
 LL | |         None => true,
 LL | |     };
-   | |_____^ help: try this: `None::<()>.is_none()`
+   | |_____^ help: try: `None::<()>.is_none()`
 
 error: redundant pattern matching, consider using `is_none()`
   --> $DIR/redundant_pattern_matching_option.rs:50:13
@@ -68,55 +68,55 @@ LL |       let _ = match None::<()> {
 LL | |         Some(_) => false,
 LL | |         None => true,
 LL | |     };
-   | |_____^ help: try this: `None::<()>.is_none()`
+   | |_____^ help: try: `None::<()>.is_none()`
 
 error: redundant pattern matching, consider using `is_some()`
   --> $DIR/redundant_pattern_matching_option.rs:56:20
    |
 LL |     let _ = if let Some(_) = opt { true } else { false };
-   |             -------^^^^^^^------ help: try this: `if opt.is_some()`
+   |             -------^^^^^^^------ help: try: `if opt.is_some()`
 
 error: redundant pattern matching, consider using `is_some()`
   --> $DIR/redundant_pattern_matching_option.rs:62:20
    |
 LL |     let _ = if let Some(_) = gen_opt() {
-   |             -------^^^^^^^------------ help: try this: `if gen_opt().is_some()`
+   |             -------^^^^^^^------------ help: try: `if gen_opt().is_some()`
 
 error: redundant pattern matching, consider using `is_none()`
   --> $DIR/redundant_pattern_matching_option.rs:64:19
    |
 LL |     } else if let None = gen_opt() {
-   |            -------^^^^------------ help: try this: `if gen_opt().is_none()`
+   |            -------^^^^------------ help: try: `if gen_opt().is_none()`
 
 error: redundant pattern matching, consider using `is_some()`
   --> $DIR/redundant_pattern_matching_option.rs:70:12
    |
 LL |     if let Some(..) = gen_opt() {}
-   |     -------^^^^^^^^------------ help: try this: `if gen_opt().is_some()`
+   |     -------^^^^^^^^------------ help: try: `if gen_opt().is_some()`
 
 error: redundant pattern matching, consider using `is_some()`
   --> $DIR/redundant_pattern_matching_option.rs:85:12
    |
 LL |     if let Some(_) = Some(42) {}
-   |     -------^^^^^^^----------- help: try this: `if Some(42).is_some()`
+   |     -------^^^^^^^----------- help: try: `if Some(42).is_some()`
 
 error: redundant pattern matching, consider using `is_none()`
   --> $DIR/redundant_pattern_matching_option.rs:87:12
    |
 LL |     if let None = None::<()> {}
-   |     -------^^^^------------- help: try this: `if None::<()>.is_none()`
+   |     -------^^^^------------- help: try: `if None::<()>.is_none()`
 
 error: redundant pattern matching, consider using `is_some()`
   --> $DIR/redundant_pattern_matching_option.rs:89:15
    |
 LL |     while let Some(_) = Some(42) {}
-   |     ----------^^^^^^^----------- help: try this: `while Some(42).is_some()`
+   |     ----------^^^^^^^----------- help: try: `while Some(42).is_some()`
 
 error: redundant pattern matching, consider using `is_none()`
   --> $DIR/redundant_pattern_matching_option.rs:91:15
    |
 LL |     while let None = None::<()> {}
-   |     ----------^^^^------------- help: try this: `while None::<()>.is_none()`
+   |     ----------^^^^------------- help: try: `while None::<()>.is_none()`
 
 error: redundant pattern matching, consider using `is_some()`
   --> $DIR/redundant_pattern_matching_option.rs:93:5
@@ -125,7 +125,7 @@ LL | /     match Some(42) {
 LL | |         Some(_) => true,
 LL | |         None => false,
 LL | |     };
-   | |_____^ help: try this: `Some(42).is_some()`
+   | |_____^ help: try: `Some(42).is_some()`
 
 error: redundant pattern matching, consider using `is_none()`
   --> $DIR/redundant_pattern_matching_option.rs:98:5
@@ -134,19 +134,19 @@ LL | /     match None::<()> {
 LL | |         Some(_) => false,
 LL | |         None => true,
 LL | |     };
-   | |_____^ help: try this: `None::<()>.is_none()`
+   | |_____^ help: try: `None::<()>.is_none()`
 
 error: redundant pattern matching, consider using `is_none()`
   --> $DIR/redundant_pattern_matching_option.rs:106:12
    |
 LL |     if let None = *(&None::<()>) {}
-   |     -------^^^^----------------- help: try this: `if (&None::<()>).is_none()`
+   |     -------^^^^----------------- help: try: `if (&None::<()>).is_none()`
 
 error: redundant pattern matching, consider using `is_none()`
   --> $DIR/redundant_pattern_matching_option.rs:107:12
    |
 LL |     if let None = *&None::<()> {}
-   |     -------^^^^--------------- help: try this: `if (&None::<()>).is_none()`
+   |     -------^^^^--------------- help: try: `if (&None::<()>).is_none()`
 
 error: redundant pattern matching, consider using `is_some()`
   --> $DIR/redundant_pattern_matching_option.rs:113:5
@@ -155,7 +155,7 @@ LL | /     match x {
 LL | |         Some(_) => true,
 LL | |         _ => false,
 LL | |     };
-   | |_____^ help: try this: `x.is_some()`
+   | |_____^ help: try: `x.is_some()`
 
 error: redundant pattern matching, consider using `is_none()`
   --> $DIR/redundant_pattern_matching_option.rs:118:5
@@ -164,7 +164,7 @@ LL | /     match x {
 LL | |         None => true,
 LL | |         _ => false,
 LL | |     };
-   | |_____^ help: try this: `x.is_none()`
+   | |_____^ help: try: `x.is_none()`
 
 error: redundant pattern matching, consider using `is_none()`
   --> $DIR/redundant_pattern_matching_option.rs:123:5
@@ -173,7 +173,7 @@ LL | /     match x {
 LL | |         Some(_) => false,
 LL | |         _ => true,
 LL | |     };
-   | |_____^ help: try this: `x.is_none()`
+   | |_____^ help: try: `x.is_none()`
 
 error: redundant pattern matching, consider using `is_some()`
   --> $DIR/redundant_pattern_matching_option.rs:128:5
@@ -182,19 +182,19 @@ LL | /     match x {
 LL | |         None => false,
 LL | |         _ => true,
 LL | |     };
-   | |_____^ help: try this: `x.is_some()`
+   | |_____^ help: try: `x.is_some()`
 
 error: redundant pattern matching, consider using `is_some()`
   --> $DIR/redundant_pattern_matching_option.rs:143:13
    |
 LL |     let _ = matches!(x, Some(_));
-   |             ^^^^^^^^^^^^^^^^^^^^ help: try this: `x.is_some()`
+   |             ^^^^^^^^^^^^^^^^^^^^ help: try: `x.is_some()`
 
 error: redundant pattern matching, consider using `is_none()`
   --> $DIR/redundant_pattern_matching_option.rs:145:13
    |
 LL |     let _ = matches!(x, None);
-   |             ^^^^^^^^^^^^^^^^^ help: try this: `x.is_none()`
+   |             ^^^^^^^^^^^^^^^^^ help: try: `x.is_none()`
 
 error: aborting due to 28 previous errors
 
diff --git a/tests/ui/redundant_pattern_matching_poll.stderr b/tests/ui/redundant_pattern_matching_poll.stderr
index b89fde35fcf..28d3606c4fb 100644
--- a/tests/ui/redundant_pattern_matching_poll.stderr
+++ b/tests/ui/redundant_pattern_matching_poll.stderr
@@ -2,7 +2,7 @@ error: redundant pattern matching, consider using `is_pending()`
   --> $DIR/redundant_pattern_matching_poll.rs:17:12
    |
 LL |     if let Pending = Pending::<()> {}
-   |     -------^^^^^^^---------------- help: try this: `if Pending::<()>.is_pending()`
+   |     -------^^^^^^^---------------- help: try: `if Pending::<()>.is_pending()`
    |
    = note: `-D clippy::redundant-pattern-matching` implied by `-D warnings`
 
@@ -10,31 +10,31 @@ error: redundant pattern matching, consider using `is_ready()`
   --> $DIR/redundant_pattern_matching_poll.rs:19:12
    |
 LL |     if let Ready(_) = Ready(42) {}
-   |     -------^^^^^^^^------------ help: try this: `if Ready(42).is_ready()`
+   |     -------^^^^^^^^------------ help: try: `if Ready(42).is_ready()`
 
 error: redundant pattern matching, consider using `is_ready()`
   --> $DIR/redundant_pattern_matching_poll.rs:21:12
    |
 LL |     if let Ready(_) = Ready(42) {
-   |     -------^^^^^^^^------------ help: try this: `if Ready(42).is_ready()`
+   |     -------^^^^^^^^------------ help: try: `if Ready(42).is_ready()`
 
 error: redundant pattern matching, consider using `is_ready()`
   --> $DIR/redundant_pattern_matching_poll.rs:27:15
    |
 LL |     while let Ready(_) = Ready(42) {}
-   |     ----------^^^^^^^^------------ help: try this: `while Ready(42).is_ready()`
+   |     ----------^^^^^^^^------------ help: try: `while Ready(42).is_ready()`
 
 error: redundant pattern matching, consider using `is_pending()`
   --> $DIR/redundant_pattern_matching_poll.rs:29:15
    |
 LL |     while let Pending = Ready(42) {}
-   |     ----------^^^^^^^------------ help: try this: `while Ready(42).is_pending()`
+   |     ----------^^^^^^^------------ help: try: `while Ready(42).is_pending()`
 
 error: redundant pattern matching, consider using `is_pending()`
   --> $DIR/redundant_pattern_matching_poll.rs:31:15
    |
 LL |     while let Pending = Pending::<()> {}
-   |     ----------^^^^^^^---------------- help: try this: `while Pending::<()>.is_pending()`
+   |     ----------^^^^^^^---------------- help: try: `while Pending::<()>.is_pending()`
 
 error: redundant pattern matching, consider using `is_ready()`
   --> $DIR/redundant_pattern_matching_poll.rs:37:5
@@ -43,7 +43,7 @@ LL | /     match Ready(42) {
 LL | |         Ready(_) => true,
 LL | |         Pending => false,
 LL | |     };
-   | |_____^ help: try this: `Ready(42).is_ready()`
+   | |_____^ help: try: `Ready(42).is_ready()`
 
 error: redundant pattern matching, consider using `is_pending()`
   --> $DIR/redundant_pattern_matching_poll.rs:42:5
@@ -52,7 +52,7 @@ LL | /     match Pending::<()> {
 LL | |         Ready(_) => false,
 LL | |         Pending => true,
 LL | |     };
-   | |_____^ help: try this: `Pending::<()>.is_pending()`
+   | |_____^ help: try: `Pending::<()>.is_pending()`
 
 error: redundant pattern matching, consider using `is_pending()`
   --> $DIR/redundant_pattern_matching_poll.rs:47:13
@@ -62,49 +62,49 @@ LL |       let _ = match Pending::<()> {
 LL | |         Ready(_) => false,
 LL | |         Pending => true,
 LL | |     };
-   | |_____^ help: try this: `Pending::<()>.is_pending()`
+   | |_____^ help: try: `Pending::<()>.is_pending()`
 
 error: redundant pattern matching, consider using `is_ready()`
   --> $DIR/redundant_pattern_matching_poll.rs:53:20
    |
 LL |     let _ = if let Ready(_) = poll { true } else { false };
-   |             -------^^^^^^^^------- help: try this: `if poll.is_ready()`
+   |             -------^^^^^^^^------- help: try: `if poll.is_ready()`
 
 error: redundant pattern matching, consider using `is_ready()`
   --> $DIR/redundant_pattern_matching_poll.rs:57:20
    |
 LL |     let _ = if let Ready(_) = gen_poll() {
-   |             -------^^^^^^^^------------- help: try this: `if gen_poll().is_ready()`
+   |             -------^^^^^^^^------------- help: try: `if gen_poll().is_ready()`
 
 error: redundant pattern matching, consider using `is_pending()`
   --> $DIR/redundant_pattern_matching_poll.rs:59:19
    |
 LL |     } else if let Pending = gen_poll() {
-   |            -------^^^^^^^------------- help: try this: `if gen_poll().is_pending()`
+   |            -------^^^^^^^------------- help: try: `if gen_poll().is_pending()`
 
 error: redundant pattern matching, consider using `is_ready()`
   --> $DIR/redundant_pattern_matching_poll.rs:75:12
    |
 LL |     if let Ready(_) = Ready(42) {}
-   |     -------^^^^^^^^------------ help: try this: `if Ready(42).is_ready()`
+   |     -------^^^^^^^^------------ help: try: `if Ready(42).is_ready()`
 
 error: redundant pattern matching, consider using `is_pending()`
   --> $DIR/redundant_pattern_matching_poll.rs:77:12
    |
 LL |     if let Pending = Pending::<()> {}
-   |     -------^^^^^^^---------------- help: try this: `if Pending::<()>.is_pending()`
+   |     -------^^^^^^^---------------- help: try: `if Pending::<()>.is_pending()`
 
 error: redundant pattern matching, consider using `is_ready()`
   --> $DIR/redundant_pattern_matching_poll.rs:79:15
    |
 LL |     while let Ready(_) = Ready(42) {}
-   |     ----------^^^^^^^^------------ help: try this: `while Ready(42).is_ready()`
+   |     ----------^^^^^^^^------------ help: try: `while Ready(42).is_ready()`
 
 error: redundant pattern matching, consider using `is_pending()`
   --> $DIR/redundant_pattern_matching_poll.rs:81:15
    |
 LL |     while let Pending = Pending::<()> {}
-   |     ----------^^^^^^^---------------- help: try this: `while Pending::<()>.is_pending()`
+   |     ----------^^^^^^^---------------- help: try: `while Pending::<()>.is_pending()`
 
 error: redundant pattern matching, consider using `is_ready()`
   --> $DIR/redundant_pattern_matching_poll.rs:83:5
@@ -113,7 +113,7 @@ LL | /     match Ready(42) {
 LL | |         Ready(_) => true,
 LL | |         Pending => false,
 LL | |     };
-   | |_____^ help: try this: `Ready(42).is_ready()`
+   | |_____^ help: try: `Ready(42).is_ready()`
 
 error: redundant pattern matching, consider using `is_pending()`
   --> $DIR/redundant_pattern_matching_poll.rs:88:5
@@ -122,7 +122,7 @@ LL | /     match Pending::<()> {
 LL | |         Ready(_) => false,
 LL | |         Pending => true,
 LL | |     };
-   | |_____^ help: try this: `Pending::<()>.is_pending()`
+   | |_____^ help: try: `Pending::<()>.is_pending()`
 
 error: aborting due to 18 previous errors
 
diff --git a/tests/ui/redundant_pattern_matching_result.stderr b/tests/ui/redundant_pattern_matching_result.stderr
index f6ce666bb4f..2b1ce9f5465 100644
--- a/tests/ui/redundant_pattern_matching_result.stderr
+++ b/tests/ui/redundant_pattern_matching_result.stderr
@@ -2,7 +2,7 @@ error: redundant pattern matching, consider using `is_ok()`
   --> $DIR/redundant_pattern_matching_result.rs:16:12
    |
 LL |     if let Ok(_) = &result {}
-   |     -------^^^^^---------- help: try this: `if result.is_ok()`
+   |     -------^^^^^---------- help: try: `if result.is_ok()`
    |
    = note: `-D clippy::redundant-pattern-matching` implied by `-D warnings`
 
@@ -10,25 +10,25 @@ error: redundant pattern matching, consider using `is_ok()`
   --> $DIR/redundant_pattern_matching_result.rs:18:12
    |
 LL |     if let Ok(_) = Ok::<i32, i32>(42) {}
-   |     -------^^^^^--------------------- help: try this: `if Ok::<i32, i32>(42).is_ok()`
+   |     -------^^^^^--------------------- help: try: `if Ok::<i32, i32>(42).is_ok()`
 
 error: redundant pattern matching, consider using `is_err()`
   --> $DIR/redundant_pattern_matching_result.rs:20:12
    |
 LL |     if let Err(_) = Err::<i32, i32>(42) {}
-   |     -------^^^^^^---------------------- help: try this: `if Err::<i32, i32>(42).is_err()`
+   |     -------^^^^^^---------------------- help: try: `if Err::<i32, i32>(42).is_err()`
 
 error: redundant pattern matching, consider using `is_ok()`
   --> $DIR/redundant_pattern_matching_result.rs:22:15
    |
 LL |     while let Ok(_) = Ok::<i32, i32>(10) {}
-   |     ----------^^^^^--------------------- help: try this: `while Ok::<i32, i32>(10).is_ok()`
+   |     ----------^^^^^--------------------- help: try: `while Ok::<i32, i32>(10).is_ok()`
 
 error: redundant pattern matching, consider using `is_err()`
   --> $DIR/redundant_pattern_matching_result.rs:24:15
    |
 LL |     while let Err(_) = Ok::<i32, i32>(10) {}
-   |     ----------^^^^^^--------------------- help: try this: `while Ok::<i32, i32>(10).is_err()`
+   |     ----------^^^^^^--------------------- help: try: `while Ok::<i32, i32>(10).is_err()`
 
 error: redundant pattern matching, consider using `is_ok()`
   --> $DIR/redundant_pattern_matching_result.rs:34:5
@@ -37,7 +37,7 @@ LL | /     match Ok::<i32, i32>(42) {
 LL | |         Ok(_) => true,
 LL | |         Err(_) => false,
 LL | |     };
-   | |_____^ help: try this: `Ok::<i32, i32>(42).is_ok()`
+   | |_____^ help: try: `Ok::<i32, i32>(42).is_ok()`
 
 error: redundant pattern matching, consider using `is_err()`
   --> $DIR/redundant_pattern_matching_result.rs:39:5
@@ -46,7 +46,7 @@ LL | /     match Ok::<i32, i32>(42) {
 LL | |         Ok(_) => false,
 LL | |         Err(_) => true,
 LL | |     };
-   | |_____^ help: try this: `Ok::<i32, i32>(42).is_err()`
+   | |_____^ help: try: `Ok::<i32, i32>(42).is_err()`
 
 error: redundant pattern matching, consider using `is_err()`
   --> $DIR/redundant_pattern_matching_result.rs:44:5
@@ -55,7 +55,7 @@ LL | /     match Err::<i32, i32>(42) {
 LL | |         Ok(_) => false,
 LL | |         Err(_) => true,
 LL | |     };
-   | |_____^ help: try this: `Err::<i32, i32>(42).is_err()`
+   | |_____^ help: try: `Err::<i32, i32>(42).is_err()`
 
 error: redundant pattern matching, consider using `is_ok()`
   --> $DIR/redundant_pattern_matching_result.rs:49:5
@@ -64,73 +64,73 @@ LL | /     match Err::<i32, i32>(42) {
 LL | |         Ok(_) => true,
 LL | |         Err(_) => false,
 LL | |     };
-   | |_____^ help: try this: `Err::<i32, i32>(42).is_ok()`
+   | |_____^ help: try: `Err::<i32, i32>(42).is_ok()`
 
 error: redundant pattern matching, consider using `is_ok()`
   --> $DIR/redundant_pattern_matching_result.rs:54:20
    |
 LL |     let _ = if let Ok(_) = Ok::<usize, ()>(4) { true } else { false };
-   |             -------^^^^^--------------------- help: try this: `if Ok::<usize, ()>(4).is_ok()`
+   |             -------^^^^^--------------------- help: try: `if Ok::<usize, ()>(4).is_ok()`
 
 error: redundant pattern matching, consider using `is_ok()`
   --> $DIR/redundant_pattern_matching_result.rs:62:20
    |
 LL |     let _ = if let Ok(_) = gen_res() {
-   |             -------^^^^^------------ help: try this: `if gen_res().is_ok()`
+   |             -------^^^^^------------ help: try: `if gen_res().is_ok()`
 
 error: redundant pattern matching, consider using `is_err()`
   --> $DIR/redundant_pattern_matching_result.rs:64:19
    |
 LL |     } else if let Err(_) = gen_res() {
-   |            -------^^^^^^------------ help: try this: `if gen_res().is_err()`
+   |            -------^^^^^^------------ help: try: `if gen_res().is_err()`
 
 error: redundant pattern matching, consider using `is_some()`
   --> $DIR/redundant_pattern_matching_result.rs:87:19
    |
 LL |         while let Some(_) = r#try!(result_opt()) {}
-   |         ----------^^^^^^^----------------------- help: try this: `while r#try!(result_opt()).is_some()`
+   |         ----------^^^^^^^----------------------- help: try: `while r#try!(result_opt()).is_some()`
 
 error: redundant pattern matching, consider using `is_some()`
   --> $DIR/redundant_pattern_matching_result.rs:88:16
    |
 LL |         if let Some(_) = r#try!(result_opt()) {}
-   |         -------^^^^^^^----------------------- help: try this: `if r#try!(result_opt()).is_some()`
+   |         -------^^^^^^^----------------------- help: try: `if r#try!(result_opt()).is_some()`
 
 error: redundant pattern matching, consider using `is_some()`
   --> $DIR/redundant_pattern_matching_result.rs:94:12
    |
 LL |     if let Some(_) = m!() {}
-   |     -------^^^^^^^------- help: try this: `if m!().is_some()`
+   |     -------^^^^^^^------- help: try: `if m!().is_some()`
 
 error: redundant pattern matching, consider using `is_some()`
   --> $DIR/redundant_pattern_matching_result.rs:95:15
    |
 LL |     while let Some(_) = m!() {}
-   |     ----------^^^^^^^------- help: try this: `while m!().is_some()`
+   |     ----------^^^^^^^------- help: try: `while m!().is_some()`
 
 error: redundant pattern matching, consider using `is_ok()`
   --> $DIR/redundant_pattern_matching_result.rs:113:12
    |
 LL |     if let Ok(_) = Ok::<i32, i32>(42) {}
-   |     -------^^^^^--------------------- help: try this: `if Ok::<i32, i32>(42).is_ok()`
+   |     -------^^^^^--------------------- help: try: `if Ok::<i32, i32>(42).is_ok()`
 
 error: redundant pattern matching, consider using `is_err()`
   --> $DIR/redundant_pattern_matching_result.rs:115:12
    |
 LL |     if let Err(_) = Err::<i32, i32>(42) {}
-   |     -------^^^^^^---------------------- help: try this: `if Err::<i32, i32>(42).is_err()`
+   |     -------^^^^^^---------------------- help: try: `if Err::<i32, i32>(42).is_err()`
 
 error: redundant pattern matching, consider using `is_ok()`
   --> $DIR/redundant_pattern_matching_result.rs:117:15
    |
 LL |     while let Ok(_) = Ok::<i32, i32>(10) {}
-   |     ----------^^^^^--------------------- help: try this: `while Ok::<i32, i32>(10).is_ok()`
+   |     ----------^^^^^--------------------- help: try: `while Ok::<i32, i32>(10).is_ok()`
 
 error: redundant pattern matching, consider using `is_err()`
   --> $DIR/redundant_pattern_matching_result.rs:119:15
    |
 LL |     while let Err(_) = Ok::<i32, i32>(10) {}
-   |     ----------^^^^^^--------------------- help: try this: `while Ok::<i32, i32>(10).is_err()`
+   |     ----------^^^^^^--------------------- help: try: `while Ok::<i32, i32>(10).is_err()`
 
 error: redundant pattern matching, consider using `is_ok()`
   --> $DIR/redundant_pattern_matching_result.rs:121:5
@@ -139,7 +139,7 @@ LL | /     match Ok::<i32, i32>(42) {
 LL | |         Ok(_) => true,
 LL | |         Err(_) => false,
 LL | |     };
-   | |_____^ help: try this: `Ok::<i32, i32>(42).is_ok()`
+   | |_____^ help: try: `Ok::<i32, i32>(42).is_ok()`
 
 error: redundant pattern matching, consider using `is_err()`
   --> $DIR/redundant_pattern_matching_result.rs:126:5
@@ -148,7 +148,7 @@ LL | /     match Err::<i32, i32>(42) {
 LL | |         Ok(_) => false,
 LL | |         Err(_) => true,
 LL | |     };
-   | |_____^ help: try this: `Err::<i32, i32>(42).is_err()`
+   | |_____^ help: try: `Err::<i32, i32>(42).is_err()`
 
 error: redundant pattern matching, consider using `is_ok()`
   --> $DIR/redundant_pattern_matching_result.rs:136:5
@@ -157,7 +157,7 @@ LL | /     match x {
 LL | |         Ok(_) => true,
 LL | |         _ => false,
 LL | |     };
-   | |_____^ help: try this: `x.is_ok()`
+   | |_____^ help: try: `x.is_ok()`
 
 error: redundant pattern matching, consider using `is_err()`
   --> $DIR/redundant_pattern_matching_result.rs:141:5
@@ -166,7 +166,7 @@ LL | /     match x {
 LL | |         Ok(_) => false,
 LL | |         _ => true,
 LL | |     };
-   | |_____^ help: try this: `x.is_err()`
+   | |_____^ help: try: `x.is_err()`
 
 error: redundant pattern matching, consider using `is_err()`
   --> $DIR/redundant_pattern_matching_result.rs:146:5
@@ -175,7 +175,7 @@ LL | /     match x {
 LL | |         Err(_) => true,
 LL | |         _ => false,
 LL | |     };
-   | |_____^ help: try this: `x.is_err()`
+   | |_____^ help: try: `x.is_err()`
 
 error: redundant pattern matching, consider using `is_ok()`
   --> $DIR/redundant_pattern_matching_result.rs:151:5
@@ -184,19 +184,19 @@ LL | /     match x {
 LL | |         Err(_) => false,
 LL | |         _ => true,
 LL | |     };
-   | |_____^ help: try this: `x.is_ok()`
+   | |_____^ help: try: `x.is_ok()`
 
 error: redundant pattern matching, consider using `is_ok()`
   --> $DIR/redundant_pattern_matching_result.rs:172:13
    |
 LL |     let _ = matches!(x, Ok(_));
-   |             ^^^^^^^^^^^^^^^^^^ help: try this: `x.is_ok()`
+   |             ^^^^^^^^^^^^^^^^^^ help: try: `x.is_ok()`
 
 error: redundant pattern matching, consider using `is_err()`
   --> $DIR/redundant_pattern_matching_result.rs:174:13
    |
 LL |     let _ = matches!(x, Err(_));
-   |             ^^^^^^^^^^^^^^^^^^^ help: try this: `x.is_err()`
+   |             ^^^^^^^^^^^^^^^^^^^ help: try: `x.is_err()`
 
 error: aborting due to 28 previous errors
 
diff --git a/tests/ui/ref_binding_to_reference.stderr b/tests/ui/ref_binding_to_reference.stderr
index eb36cd516a2..016feb103df 100644
--- a/tests/ui/ref_binding_to_reference.stderr
+++ b/tests/ui/ref_binding_to_reference.stderr
@@ -5,7 +5,7 @@ LL |         Some(ref x) => x,
    |              ^^^^^
    |
    = note: `-D clippy::ref-binding-to-reference` implied by `-D warnings`
-help: try this
+help: try
    |
 LL |         Some(x) => &x,
    |              ~     ~~
@@ -16,7 +16,7 @@ error: this pattern creates a reference to a reference
 LL |         Some(ref x) => {
    |              ^^^^^
    |
-help: try this
+help: try
    |
 LL ~         Some(x) => {
 LL |             f1(x);
@@ -30,7 +30,7 @@ error: this pattern creates a reference to a reference
 LL |         Some(ref x) => m2!(x),
    |              ^^^^^
    |
-help: try this
+help: try
    |
 LL |         Some(x) => m2!(&x),
    |              ~         ~~
@@ -41,7 +41,7 @@ error: this pattern creates a reference to a reference
 LL |     let _ = |&ref x: &&String| {
    |               ^^^^^
    |
-help: try this
+help: try
    |
 LL ~     let _ = |&x: &&String| {
 LL ~         let _: &&String = &x;
@@ -53,7 +53,7 @@ error: this pattern creates a reference to a reference
 LL | fn f2<'a>(&ref x: &&'a String) -> &'a String {
    |            ^^^^^
    |
-help: try this
+help: try
    |
 LL ~ fn f2<'a>(&x: &&'a String) -> &'a String {
 LL ~     let _: &&String = &x;
@@ -66,7 +66,7 @@ error: this pattern creates a reference to a reference
 LL |     fn f(&ref x: &&String) {
    |           ^^^^^
    |
-help: try this
+help: try
    |
 LL ~     fn f(&x: &&String) {
 LL ~         let _: &&String = &x;
@@ -78,7 +78,7 @@ error: this pattern creates a reference to a reference
 LL |     fn f(&ref x: &&String) {
    |           ^^^^^
    |
-help: try this
+help: try
    |
 LL ~     fn f(&x: &&String) {
 LL ~         let _: &&String = &x;
diff --git a/tests/ui/result_map_unit_fn_fixable.stderr b/tests/ui/result_map_unit_fn_fixable.stderr
index 782febd5264..ad941fa8bcc 100644
--- a/tests/ui/result_map_unit_fn_fixable.stderr
+++ b/tests/ui/result_map_unit_fn_fixable.stderr
@@ -4,7 +4,7 @@ error: called `map(f)` on an `Result` value where `f` is a function that returns
 LL |     x.field.map(do_nothing);
    |     ^^^^^^^^^^^^^^^^^^^^^^^-
    |     |
-   |     help: try this: `if let Ok(x_field) = x.field { do_nothing(x_field) }`
+   |     help: try: `if let Ok(x_field) = x.field { do_nothing(x_field) }`
    |
    = note: `-D clippy::result-map-unit-fn` implied by `-D warnings`
 
@@ -14,7 +14,7 @@ error: called `map(f)` on an `Result` value where `f` is a function that returns
 LL |     x.field.map(do_nothing);
    |     ^^^^^^^^^^^^^^^^^^^^^^^-
    |     |
-   |     help: try this: `if let Ok(x_field) = x.field { do_nothing(x_field) }`
+   |     help: try: `if let Ok(x_field) = x.field { do_nothing(x_field) }`
 
 error: called `map(f)` on an `Result` value where `f` is a function that returns the unit type `()`
   --> $DIR/result_map_unit_fn_fixable.rs:39:5
@@ -22,7 +22,7 @@ error: called `map(f)` on an `Result` value where `f` is a function that returns
 LL |     x.field.map(diverge);
    |     ^^^^^^^^^^^^^^^^^^^^-
    |     |
-   |     help: try this: `if let Ok(x_field) = x.field { diverge(x_field) }`
+   |     help: try: `if let Ok(x_field) = x.field { diverge(x_field) }`
 
 error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type `()`
   --> $DIR/result_map_unit_fn_fixable.rs:45:5
@@ -30,7 +30,7 @@ error: called `map(f)` on an `Result` value where `f` is a closure that returns
 LL |     x.field.map(|value| x.do_result_nothing(value + captured));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
    |     |
-   |     help: try this: `if let Ok(value) = x.field { x.do_result_nothing(value + captured) }`
+   |     help: try: `if let Ok(value) = x.field { x.do_result_nothing(value + captured) }`
 
 error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type `()`
   --> $DIR/result_map_unit_fn_fixable.rs:47:5
@@ -38,7 +38,7 @@ error: called `map(f)` on an `Result` value where `f` is a closure that returns
 LL |     x.field.map(|value| { x.do_result_plus_one(value + captured); });
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
    |     |
-   |     help: try this: `if let Ok(value) = x.field { x.do_result_plus_one(value + captured); }`
+   |     help: try: `if let Ok(value) = x.field { x.do_result_plus_one(value + captured); }`
 
 error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type `()`
   --> $DIR/result_map_unit_fn_fixable.rs:50:5
@@ -46,7 +46,7 @@ error: called `map(f)` on an `Result` value where `f` is a closure that returns
 LL |     x.field.map(|value| do_nothing(value + captured));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
    |     |
-   |     help: try this: `if let Ok(value) = x.field { do_nothing(value + captured) }`
+   |     help: try: `if let Ok(value) = x.field { do_nothing(value + captured) }`
 
 error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type `()`
   --> $DIR/result_map_unit_fn_fixable.rs:52:5
@@ -54,7 +54,7 @@ error: called `map(f)` on an `Result` value where `f` is a closure that returns
 LL |     x.field.map(|value| { do_nothing(value + captured) });
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
    |     |
-   |     help: try this: `if let Ok(value) = x.field { do_nothing(value + captured) }`
+   |     help: try: `if let Ok(value) = x.field { do_nothing(value + captured) }`
 
 error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type `()`
   --> $DIR/result_map_unit_fn_fixable.rs:54:5
@@ -62,7 +62,7 @@ error: called `map(f)` on an `Result` value where `f` is a closure that returns
 LL |     x.field.map(|value| { do_nothing(value + captured); });
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
    |     |
-   |     help: try this: `if let Ok(value) = x.field { do_nothing(value + captured); }`
+   |     help: try: `if let Ok(value) = x.field { do_nothing(value + captured); }`
 
 error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type `()`
   --> $DIR/result_map_unit_fn_fixable.rs:56:5
@@ -70,7 +70,7 @@ error: called `map(f)` on an `Result` value where `f` is a closure that returns
 LL |     x.field.map(|value| { { do_nothing(value + captured); } });
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
    |     |
-   |     help: try this: `if let Ok(value) = x.field { do_nothing(value + captured); }`
+   |     help: try: `if let Ok(value) = x.field { do_nothing(value + captured); }`
 
 error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type `()`
   --> $DIR/result_map_unit_fn_fixable.rs:59:5
@@ -78,7 +78,7 @@ error: called `map(f)` on an `Result` value where `f` is a closure that returns
 LL |     x.field.map(|value| diverge(value + captured));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
    |     |
-   |     help: try this: `if let Ok(value) = x.field { diverge(value + captured) }`
+   |     help: try: `if let Ok(value) = x.field { diverge(value + captured) }`
 
 error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type `()`
   --> $DIR/result_map_unit_fn_fixable.rs:61:5
@@ -86,7 +86,7 @@ error: called `map(f)` on an `Result` value where `f` is a closure that returns
 LL |     x.field.map(|value| { diverge(value + captured) });
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
    |     |
-   |     help: try this: `if let Ok(value) = x.field { diverge(value + captured) }`
+   |     help: try: `if let Ok(value) = x.field { diverge(value + captured) }`
 
 error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type `()`
   --> $DIR/result_map_unit_fn_fixable.rs:63:5
@@ -94,7 +94,7 @@ error: called `map(f)` on an `Result` value where `f` is a closure that returns
 LL |     x.field.map(|value| { diverge(value + captured); });
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
    |     |
-   |     help: try this: `if let Ok(value) = x.field { diverge(value + captured); }`
+   |     help: try: `if let Ok(value) = x.field { diverge(value + captured); }`
 
 error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type `()`
   --> $DIR/result_map_unit_fn_fixable.rs:65:5
@@ -102,7 +102,7 @@ error: called `map(f)` on an `Result` value where `f` is a closure that returns
 LL |     x.field.map(|value| { { diverge(value + captured); } });
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
    |     |
-   |     help: try this: `if let Ok(value) = x.field { diverge(value + captured); }`
+   |     help: try: `if let Ok(value) = x.field { diverge(value + captured); }`
 
 error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type `()`
   --> $DIR/result_map_unit_fn_fixable.rs:70:5
@@ -110,7 +110,7 @@ error: called `map(f)` on an `Result` value where `f` is a closure that returns
 LL |     x.field.map(|value| { let y = plus_one(value + captured); });
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
    |     |
-   |     help: try this: `if let Ok(value) = x.field { let y = plus_one(value + captured); }`
+   |     help: try: `if let Ok(value) = x.field { let y = plus_one(value + captured); }`
 
 error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type `()`
   --> $DIR/result_map_unit_fn_fixable.rs:72:5
@@ -118,7 +118,7 @@ error: called `map(f)` on an `Result` value where `f` is a closure that returns
 LL |     x.field.map(|value| { plus_one(value + captured); });
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
    |     |
-   |     help: try this: `if let Ok(value) = x.field { plus_one(value + captured); }`
+   |     help: try: `if let Ok(value) = x.field { plus_one(value + captured); }`
 
 error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type `()`
   --> $DIR/result_map_unit_fn_fixable.rs:74:5
@@ -126,7 +126,7 @@ error: called `map(f)` on an `Result` value where `f` is a closure that returns
 LL |     x.field.map(|value| { { plus_one(value + captured); } });
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
    |     |
-   |     help: try this: `if let Ok(value) = x.field { plus_one(value + captured); }`
+   |     help: try: `if let Ok(value) = x.field { plus_one(value + captured); }`
 
 error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type `()`
   --> $DIR/result_map_unit_fn_fixable.rs:77:5
@@ -134,7 +134,7 @@ error: called `map(f)` on an `Result` value where `f` is a closure that returns
 LL |     x.field.map(|ref value| { do_nothing(value + captured) });
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
    |     |
-   |     help: try this: `if let Ok(ref value) = x.field { do_nothing(value + captured) }`
+   |     help: try: `if let Ok(ref value) = x.field { do_nothing(value + captured) }`
 
 error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type `()`
   --> $DIR/result_map_unit_fn_fixable.rs:79:5
@@ -142,7 +142,7 @@ error: called `map(f)` on an `Result` value where `f` is a closure that returns
 LL |     x.field.map(|value| println!("{:?}", value));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
    |     |
-   |     help: try this: `if let Ok(value) = x.field { println!("{:?}", value) }`
+   |     help: try: `if let Ok(value) = x.field { println!("{:?}", value) }`
 
 error: aborting due to 18 previous errors
 
diff --git a/tests/ui/result_map_unit_fn_unfixable.stderr b/tests/ui/result_map_unit_fn_unfixable.stderr
index d0e534f6356..75ec1ba8024 100644
--- a/tests/ui/result_map_unit_fn_unfixable.stderr
+++ b/tests/ui/result_map_unit_fn_unfixable.stderr
@@ -4,7 +4,7 @@ error: called `map(f)` on an `Result` value where `f` is a closure that returns
 LL |     x.field.map(|value| { do_nothing(value); do_nothing(value) });
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
    |     |
-   |     help: try this: `if let Ok(value) = x.field { ... }`
+   |     help: try: `if let Ok(value) = x.field { ... }`
    |
    = note: `-D clippy::result-map-unit-fn` implied by `-D warnings`
 
@@ -14,7 +14,7 @@ error: called `map(f)` on an `Result` value where `f` is a closure that returns
 LL |     x.field.map(|value| if value > 0 { do_nothing(value); do_nothing(value) });
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
    |     |
-   |     help: try this: `if let Ok(value) = x.field { ... }`
+   |     help: try: `if let Ok(value) = x.field { ... }`
 
 error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type `()`
   --> $DIR/result_map_unit_fn_unfixable.rs:29:5
@@ -23,7 +23,7 @@ LL | //     x.field.map(|value| {
 LL | ||         do_nothing(value);
 LL | ||         do_nothing(value)
 LL | ||     });
-   | ||______^- help: try this: `if let Ok(value) = x.field { ... }`
+   | ||______^- help: try: `if let Ok(value) = x.field { ... }`
    |  |______|
    | 
 
@@ -33,7 +33,7 @@ error: called `map(f)` on an `Result` value where `f` is a closure that returns
 LL |     x.field.map(|value| { do_nothing(value); do_nothing(value); });
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
    |     |
-   |     help: try this: `if let Ok(value) = x.field { ... }`
+   |     help: try: `if let Ok(value) = x.field { ... }`
 
 error: called `map(f)` on an `Result` value where `f` is a function that returns the unit type `()`
   --> $DIR/result_map_unit_fn_unfixable.rs:37:5
@@ -41,7 +41,7 @@ error: called `map(f)` on an `Result` value where `f` is a function that returns
 LL |     "12".parse::<i32>().map(diverge);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
    |     |
-   |     help: try this: `if let Ok(a) = "12".parse::<i32>() { diverge(a) }`
+   |     help: try: `if let Ok(a) = "12".parse::<i32>() { diverge(a) }`
 
 error: called `map(f)` on an `Result` value where `f` is a function that returns the unit type `()`
   --> $DIR/result_map_unit_fn_unfixable.rs:43:5
@@ -49,7 +49,7 @@ error: called `map(f)` on an `Result` value where `f` is a function that returns
 LL |     y.map(do_nothing);
    |     ^^^^^^^^^^^^^^^^^-
    |     |
-   |     help: try this: `if let Ok(_y) = y { do_nothing(_y) }`
+   |     help: try: `if let Ok(_y) = y { do_nothing(_y) }`
 
 error: aborting due to 6 previous errors
 
diff --git a/tests/ui/single_match.stderr b/tests/ui/single_match.stderr
index ef901513240..76f7e789589 100644
--- a/tests/ui/single_match.stderr
+++ b/tests/ui/single_match.stderr
@@ -10,7 +10,7 @@ LL | |     };
    | |_____^
    |
    = note: `-D clippy::single-match` implied by `-D warnings`
-help: try this
+help: try
    |
 LL ~     if let Some(y) = x {
 LL +         println!("{:?}", y);
@@ -27,7 +27,7 @@ LL | |         // is expanded before we can do anything.
 LL | |         Some(y) => println!("{:?}", y),
 LL | |         _ => (),
 LL | |     }
-   | |_____^ help: try this: `if let Some(y) = x { println!("{:?}", y) }`
+   | |_____^ help: try: `if let Some(y) = x { println!("{:?}", y) }`
 
 error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
   --> $DIR/single_match.rs:31:5
@@ -36,7 +36,7 @@ LL | /     match z {
 LL | |         (2..=3, 7..=9) => dummy(),
 LL | |         _ => {},
 LL | |     };
-   | |_____^ help: try this: `if let (2..=3, 7..=9) = z { dummy() }`
+   | |_____^ help: try: `if let (2..=3, 7..=9) = z { dummy() }`
 
 error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
   --> $DIR/single_match.rs:60:5
@@ -45,7 +45,7 @@ LL | /     match x {
 LL | |         Some(y) => dummy(),
 LL | |         None => (),
 LL | |     };
-   | |_____^ help: try this: `if let Some(y) = x { dummy() }`
+   | |_____^ help: try: `if let Some(y) = x { dummy() }`
 
 error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
   --> $DIR/single_match.rs:65:5
@@ -54,7 +54,7 @@ LL | /     match y {
 LL | |         Ok(y) => dummy(),
 LL | |         Err(..) => (),
 LL | |     };
-   | |_____^ help: try this: `if let Ok(y) = y { dummy() }`
+   | |_____^ help: try: `if let Ok(y) = y { dummy() }`
 
 error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
   --> $DIR/single_match.rs:72:5
@@ -63,7 +63,7 @@ LL | /     match c {
 LL | |         Cow::Borrowed(..) => dummy(),
 LL | |         Cow::Owned(..) => (),
 LL | |     };
-   | |_____^ help: try this: `if let Cow::Borrowed(..) = c { dummy() }`
+   | |_____^ help: try: `if let Cow::Borrowed(..) = c { dummy() }`
 
 error: you seem to be trying to use `match` for an equality check. Consider using `if`
   --> $DIR/single_match.rs:93:5
@@ -72,7 +72,7 @@ LL | /     match x {
 LL | |         "test" => println!(),
 LL | |         _ => (),
 LL | |     }
-   | |_____^ help: try this: `if x == "test" { println!() }`
+   | |_____^ help: try: `if x == "test" { println!() }`
 
 error: you seem to be trying to use `match` for an equality check. Consider using `if`
   --> $DIR/single_match.rs:106:5
@@ -81,7 +81,7 @@ LL | /     match x {
 LL | |         Foo::A => println!(),
 LL | |         _ => (),
 LL | |     }
-   | |_____^ help: try this: `if x == Foo::A { println!() }`
+   | |_____^ help: try: `if x == Foo::A { println!() }`
 
 error: you seem to be trying to use `match` for an equality check. Consider using `if`
   --> $DIR/single_match.rs:112:5
@@ -90,7 +90,7 @@ LL | /     match x {
 LL | |         FOO_C => println!(),
 LL | |         _ => (),
 LL | |     }
-   | |_____^ help: try this: `if x == FOO_C { println!() }`
+   | |_____^ help: try: `if x == FOO_C { println!() }`
 
 error: you seem to be trying to use `match` for an equality check. Consider using `if`
   --> $DIR/single_match.rs:117:5
@@ -99,7 +99,7 @@ LL | /     match &&x {
 LL | |         Foo::A => println!(),
 LL | |         _ => (),
 LL | |     }
-   | |_____^ help: try this: `if x == Foo::A { println!() }`
+   | |_____^ help: try: `if x == Foo::A { println!() }`
 
 error: you seem to be trying to use `match` for an equality check. Consider using `if`
   --> $DIR/single_match.rs:123:5
@@ -108,7 +108,7 @@ LL | /     match &x {
 LL | |         Foo::A => println!(),
 LL | |         _ => (),
 LL | |     }
-   | |_____^ help: try this: `if x == &Foo::A { println!() }`
+   | |_____^ help: try: `if x == &Foo::A { println!() }`
 
 error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
   --> $DIR/single_match.rs:140:5
@@ -117,7 +117,7 @@ LL | /     match x {
 LL | |         Bar::A => println!(),
 LL | |         _ => (),
 LL | |     }
-   | |_____^ help: try this: `if let Bar::A = x { println!() }`
+   | |_____^ help: try: `if let Bar::A = x { println!() }`
 
 error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
   --> $DIR/single_match.rs:148:5
@@ -126,7 +126,7 @@ LL | /     match x {
 LL | |         None => println!(),
 LL | |         _ => (),
 LL | |     };
-   | |_____^ help: try this: `if let None = x { println!() }`
+   | |_____^ help: try: `if let None = x { println!() }`
 
 error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
   --> $DIR/single_match.rs:170:5
@@ -135,7 +135,7 @@ LL | /     match x {
 LL | |         (Some(_), _) => {},
 LL | |         (None, _) => {},
 LL | |     }
-   | |_____^ help: try this: `if let (Some(_), _) = x {}`
+   | |_____^ help: try: `if let (Some(_), _) = x {}`
 
 error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
   --> $DIR/single_match.rs:176:5
@@ -144,7 +144,7 @@ LL | /     match x {
 LL | |         (Some(E::V), _) => todo!(),
 LL | |         (_, _) => {},
 LL | |     }
-   | |_____^ help: try this: `if let (Some(E::V), _) = x { todo!() }`
+   | |_____^ help: try: `if let (Some(E::V), _) = x { todo!() }`
 
 error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
   --> $DIR/single_match.rs:182:5
@@ -153,7 +153,7 @@ LL | /     match (Some(42), Some(E::V), Some(42)) {
 LL | |         (.., Some(E::V), _) => {},
 LL | |         (..) => {},
 LL | |     }
-   | |_____^ help: try this: `if let (.., Some(E::V), _) = (Some(42), Some(E::V), Some(42)) {}`
+   | |_____^ help: try: `if let (.., Some(E::V), _) = (Some(42), Some(E::V), Some(42)) {}`
 
 error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
   --> $DIR/single_match.rs:254:5
@@ -167,7 +167,7 @@ LL | |         _ => {},
 LL | |     }
    | |_____^
    |
-help: try this
+help: try
    |
 LL ~     if let Some(v) = bar { unsafe {
 LL +         let r = &v as *const i32;
@@ -187,7 +187,7 @@ LL | |         _ => {},
 LL | |     }
    | |_____^
    |
-help: try this
+help: try
    |
 LL ~     if let Some(v) = bar {
 LL +         unsafe {
diff --git a/tests/ui/single_match_else.stderr b/tests/ui/single_match_else.stderr
index 228236f3bb8..5e7d4062efe 100644
--- a/tests/ui/single_match_else.stderr
+++ b/tests/ui/single_match_else.stderr
@@ -12,7 +12,7 @@ LL | |     };
    | |_____^
    |
    = note: `-D clippy::single-match-else` implied by `-D warnings`
-help: try this
+help: try
    |
 LL ~     let _ = if let ExprNode::ExprAddrOf = ExprNode::Butterflies { Some(&NODE) } else {
 LL +         let x = 5;
@@ -32,7 +32,7 @@ LL | |         },
 LL | |     }
    | |_____^
    |
-help: try this
+help: try
    |
 LL ~     if let Some(a) = Some(1) { println!("${:?}", a) } else {
 LL +         println!("else block");
@@ -52,7 +52,7 @@ LL | |         },
 LL | |     }
    | |_____^
    |
-help: try this
+help: try
    |
 LL ~     if let Some(a) = Some(1) { println!("${:?}", a) } else {
 LL +         println!("else block");
@@ -72,7 +72,7 @@ LL | |         }
 LL | |     }
    | |_____^
    |
-help: try this
+help: try
    |
 LL ~     if let Ok(a) = Result::<i32, Infallible>::Ok(1) { println!("${:?}", a) } else {
 LL +         println!("else block");
@@ -92,7 +92,7 @@ LL | |         }
 LL | |     }
    | |_____^
    |
-help: try this
+help: try
    |
 LL ~     if let Cow::Owned(a) = Cow::from("moo") { println!("${:?}", a) } else {
 LL +         println!("else block");
@@ -112,7 +112,7 @@ LL | |         },
 LL | |     }
    | |_____^
    |
-help: try this
+help: try
    |
 LL ~     if let Some(v) = bar { unsafe {
 LL +         let r = &v as *const i32;
@@ -135,7 +135,7 @@ LL | |         },
 LL | |     }
    | |_____^
    |
-help: try this
+help: try
    |
 LL ~     if let Some(v) = bar {
 LL +         println!("Some");
@@ -159,7 +159,7 @@ LL | |         },
 LL | |     }
    | |_____^
    |
-help: try this
+help: try
    |
 LL ~     if let Some(v) = bar { unsafe {
 LL +         let r = &v as *const i32;
@@ -183,7 +183,7 @@ LL | |         },
 LL | |     }
    | |_____^
    |
-help: try this
+help: try
    |
 LL ~     if let Some(v) = bar {
 LL +         unsafe {
diff --git a/tests/ui/string_extend.stderr b/tests/ui/string_extend.stderr
index b35c77fd961..34b43290147 100644
--- a/tests/ui/string_extend.stderr
+++ b/tests/ui/string_extend.stderr
@@ -2,7 +2,7 @@ error: calling `.extend(_.chars())`
   --> $DIR/string_extend.rs:18:5
    |
 LL |     s.extend(abc.chars());
-   |     ^^^^^^^^^^^^^^^^^^^^^ help: try this: `s.push_str(abc)`
+   |     ^^^^^^^^^^^^^^^^^^^^^ help: try: `s.push_str(abc)`
    |
    = note: `-D clippy::string-extend-chars` implied by `-D warnings`
 
@@ -10,19 +10,19 @@ error: calling `.extend(_.chars())`
   --> $DIR/string_extend.rs:21:5
    |
 LL |     s.extend("abc".chars());
-   |     ^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `s.push_str("abc")`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^ help: try: `s.push_str("abc")`
 
 error: calling `.extend(_.chars())`
   --> $DIR/string_extend.rs:24:5
    |
 LL |     s.extend(def.chars());
-   |     ^^^^^^^^^^^^^^^^^^^^^ help: try this: `s.push_str(&def)`
+   |     ^^^^^^^^^^^^^^^^^^^^^ help: try: `s.push_str(&def)`
 
 error: calling `.extend(_.chars())`
   --> $DIR/string_extend.rs:34:5
    |
 LL |     s.extend(abc[0..2].chars());
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `s.push_str(&abc[0..2])`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `s.push_str(&abc[0..2])`
 
 error: aborting due to 4 previous errors
 
diff --git a/tests/ui/strlen_on_c_strings.stderr b/tests/ui/strlen_on_c_strings.stderr
index 296268a5f1d..fcd17f68940 100644
--- a/tests/ui/strlen_on_c_strings.stderr
+++ b/tests/ui/strlen_on_c_strings.stderr
@@ -2,7 +2,7 @@ error: using `libc::strlen` on a `CString` or `CStr` value
   --> $DIR/strlen_on_c_strings.rs:15:13
    |
 LL |     let _ = unsafe { libc::strlen(cstring.as_ptr()) };
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `cstring.as_bytes().len()`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `cstring.as_bytes().len()`
    |
    = note: `-D clippy::strlen-on-c-strings` implied by `-D warnings`
 
@@ -10,37 +10,37 @@ error: using `libc::strlen` on a `CString` or `CStr` value
   --> $DIR/strlen_on_c_strings.rs:19:13
    |
 LL |     let _ = unsafe { libc::strlen(cstr.as_ptr()) };
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `cstr.to_bytes().len()`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `cstr.to_bytes().len()`
 
 error: using `libc::strlen` on a `CString` or `CStr` value
   --> $DIR/strlen_on_c_strings.rs:21:13
    |
 LL |     let _ = unsafe { strlen(cstr.as_ptr()) };
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `cstr.to_bytes().len()`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `cstr.to_bytes().len()`
 
 error: using `libc::strlen` on a `CString` or `CStr` value
   --> $DIR/strlen_on_c_strings.rs:24:22
    |
 LL |     let _ = unsafe { strlen((*pcstr).as_ptr()) };
-   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `(*pcstr).to_bytes().len()`
+   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `(*pcstr).to_bytes().len()`
 
 error: using `libc::strlen` on a `CString` or `CStr` value
   --> $DIR/strlen_on_c_strings.rs:29:22
    |
 LL |     let _ = unsafe { strlen(unsafe_identity(cstr).as_ptr()) };
-   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unsafe_identity(cstr).to_bytes().len()`
+   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unsafe_identity(cstr).to_bytes().len()`
 
 error: using `libc::strlen` on a `CString` or `CStr` value
   --> $DIR/strlen_on_c_strings.rs:30:13
    |
 LL |     let _ = unsafe { strlen(unsafe { unsafe_identity(cstr) }.as_ptr()) };
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unsafe { unsafe_identity(cstr) }.to_bytes().len()`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unsafe { unsafe_identity(cstr) }.to_bytes().len()`
 
 error: using `libc::strlen` on a `CString` or `CStr` value
   --> $DIR/strlen_on_c_strings.rs:33:22
    |
 LL |     let _ = unsafe { strlen(f(cstr).as_ptr()) };
-   |                      ^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `f(cstr).to_bytes().len()`
+   |                      ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `f(cstr).to_bytes().len()`
 
 error: aborting due to 7 previous errors
 
diff --git a/tests/ui/to_digit_is_some.stderr b/tests/ui/to_digit_is_some.stderr
index 10a1b393a39..c4718825dc2 100644
--- a/tests/ui/to_digit_is_some.stderr
+++ b/tests/ui/to_digit_is_some.stderr
@@ -2,7 +2,7 @@ error: use of `.to_digit(..).is_some()`
   --> $DIR/to_digit_is_some.rs:9:13
    |
 LL |     let _ = d.to_digit(8).is_some();
-   |             ^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `d.is_digit(8)`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^ help: try: `d.is_digit(8)`
    |
    = note: `-D clippy::to-digit-is-some` implied by `-D warnings`
 
@@ -10,7 +10,7 @@ error: use of `.to_digit(..).is_some()`
   --> $DIR/to_digit_is_some.rs:10:13
    |
 LL |     let _ = char::to_digit(c, 8).is_some();
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `char::is_digit(c, 8)`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `char::is_digit(c, 8)`
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/try_err.stderr b/tests/ui/try_err.stderr
index 4ad0e2e56a4..79f7b70224a 100644
--- a/tests/ui/try_err.stderr
+++ b/tests/ui/try_err.stderr
@@ -2,7 +2,7 @@ error: returning an `Err(_)` with the `?` operator
   --> $DIR/try_err.rs:19:9
    |
 LL |         Err(err)?;
-   |         ^^^^^^^^^ help: try this: `return Err(err)`
+   |         ^^^^^^^^^ help: try: `return Err(err)`
    |
 note: the lint level is defined here
   --> $DIR/try_err.rs:4:9
@@ -14,25 +14,25 @@ error: returning an `Err(_)` with the `?` operator
   --> $DIR/try_err.rs:29:9
    |
 LL |         Err(err)?;
-   |         ^^^^^^^^^ help: try this: `return Err(err.into())`
+   |         ^^^^^^^^^ help: try: `return Err(err.into())`
 
 error: returning an `Err(_)` with the `?` operator
   --> $DIR/try_err.rs:49:17
    |
 LL |                 Err(err)?;
-   |                 ^^^^^^^^^ help: try this: `return Err(err)`
+   |                 ^^^^^^^^^ help: try: `return Err(err)`
 
 error: returning an `Err(_)` with the `?` operator
   --> $DIR/try_err.rs:68:17
    |
 LL |                 Err(err)?;
-   |                 ^^^^^^^^^ help: try this: `return Err(err.into())`
+   |                 ^^^^^^^^^ help: try: `return Err(err.into())`
 
 error: returning an `Err(_)` with the `?` operator
   --> $DIR/try_err.rs:88:23
    |
 LL |             Err(_) => Err(1)?,
-   |                       ^^^^^^^ help: try this: `return Err(1)`
+   |                       ^^^^^^^ help: try: `return Err(1)`
    |
    = note: this error originates in the macro `__inline_mac_fn_calling_macro` (in Nightly builds, run with -Z macro-backtrace for more info)
 
@@ -40,7 +40,7 @@ error: returning an `Err(_)` with the `?` operator
   --> $DIR/try_err.rs:95:23
    |
 LL |             Err(_) => Err(inline!(1))?,
-   |                       ^^^^^^^^^^^^^^^^ help: try this: `return Err(inline!(1))`
+   |                       ^^^^^^^^^^^^^^^^ help: try: `return Err(inline!(1))`
    |
    = note: this error originates in the macro `__inline_mac_fn_calling_macro` (in Nightly builds, run with -Z macro-backtrace for more info)
 
@@ -48,31 +48,31 @@ error: returning an `Err(_)` with the `?` operator
   --> $DIR/try_err.rs:122:9
    |
 LL |         Err(inline!(inline!(String::from("aasdfasdfasdfa"))))?;
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `return Err(inline!(inline!(String::from("aasdfasdfasdfa"))))`
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `return Err(inline!(inline!(String::from("aasdfasdfasdfa"))))`
 
 error: returning an `Err(_)` with the `?` operator
   --> $DIR/try_err.rs:129:9
    |
 LL |         Err(io::ErrorKind::WriteZero)?
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `return Poll::Ready(Err(io::ErrorKind::WriteZero.into()))`
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `return Poll::Ready(Err(io::ErrorKind::WriteZero.into()))`
 
 error: returning an `Err(_)` with the `?` operator
   --> $DIR/try_err.rs:131:9
    |
 LL |         Err(io::Error::new(io::ErrorKind::InvalidInput, "error"))?
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `return Poll::Ready(Err(io::Error::new(io::ErrorKind::InvalidInput, "error")))`
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `return Poll::Ready(Err(io::Error::new(io::ErrorKind::InvalidInput, "error")))`
 
 error: returning an `Err(_)` with the `?` operator
   --> $DIR/try_err.rs:139:9
    |
 LL |         Err(io::ErrorKind::NotFound)?
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `return Poll::Ready(Some(Err(io::ErrorKind::NotFound.into())))`
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `return Poll::Ready(Some(Err(io::ErrorKind::NotFound.into())))`
 
 error: returning an `Err(_)` with the `?` operator
   --> $DIR/try_err.rs:148:16
    |
 LL |         return Err(42)?;
-   |                ^^^^^^^^ help: try this: `Err(42)`
+   |                ^^^^^^^^ help: try: `Err(42)`
 
 error: aborting due to 11 previous errors
 
diff --git a/tests/ui/unnecessary_clone.stderr b/tests/ui/unnecessary_clone.stderr
index 5686ab6b453..23639f6d41a 100644
--- a/tests/ui/unnecessary_clone.stderr
+++ b/tests/ui/unnecessary_clone.stderr
@@ -2,7 +2,7 @@ error: using `.clone()` on a ref-counted pointer
   --> $DIR/unnecessary_clone.rs:23:5
    |
 LL |     rc.clone();
-   |     ^^^^^^^^^^ help: try this: `Rc::<bool>::clone(&rc)`
+   |     ^^^^^^^^^^ help: try: `Rc::<bool>::clone(&rc)`
    |
    = note: `-D clippy::clone-on-ref-ptr` implied by `-D warnings`
 
@@ -10,25 +10,25 @@ error: using `.clone()` on a ref-counted pointer
   --> $DIR/unnecessary_clone.rs:26:5
    |
 LL |     arc.clone();
-   |     ^^^^^^^^^^^ help: try this: `Arc::<bool>::clone(&arc)`
+   |     ^^^^^^^^^^^ help: try: `Arc::<bool>::clone(&arc)`
 
 error: using `.clone()` on a ref-counted pointer
   --> $DIR/unnecessary_clone.rs:29:5
    |
 LL |     rcweak.clone();
-   |     ^^^^^^^^^^^^^^ help: try this: `Weak::<bool>::clone(&rcweak)`
+   |     ^^^^^^^^^^^^^^ help: try: `Weak::<bool>::clone(&rcweak)`
 
 error: using `.clone()` on a ref-counted pointer
   --> $DIR/unnecessary_clone.rs:32:5
    |
 LL |     arc_weak.clone();
-   |     ^^^^^^^^^^^^^^^^ help: try this: `Weak::<bool>::clone(&arc_weak)`
+   |     ^^^^^^^^^^^^^^^^ help: try: `Weak::<bool>::clone(&arc_weak)`
 
 error: using `.clone()` on a ref-counted pointer
   --> $DIR/unnecessary_clone.rs:36:33
    |
 LL |     let _: Arc<dyn SomeTrait> = x.clone();
-   |                                 ^^^^^^^^^ help: try this: `Arc::<SomeImpl>::clone(&x)`
+   |                                 ^^^^^^^^^ help: try: `Arc::<SomeImpl>::clone(&x)`
 
 error: using `clone` on type `T` which implements the `Copy` trait
   --> $DIR/unnecessary_clone.rs:40:5
@@ -54,7 +54,7 @@ error: using `.clone()` on a ref-counted pointer
   --> $DIR/unnecessary_clone.rs:95:14
    |
 LL |         Some(try_opt!(Some(rc)).clone())
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `Rc::<u8>::clone(&try_opt!(Some(rc)))`
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Rc::<u8>::clone(&try_opt!(Some(rc)))`
 
 error: aborting due to 9 previous errors
 
diff --git a/tests/ui/unwrap_or.stderr b/tests/ui/unwrap_or.stderr
index cf720eaaf05..e384bbbb015 100644
--- a/tests/ui/unwrap_or.stderr
+++ b/tests/ui/unwrap_or.stderr
@@ -2,7 +2,7 @@ error: use of `unwrap_or` followed by a function call
   --> $DIR/unwrap_or.rs:5:47
    |
 LL |     let s = Some(String::from("test string")).unwrap_or("Fail".to_string()).len();
-   |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|| "Fail".to_string())`
+   |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| "Fail".to_string())`
    |
    = note: `-D clippy::or-fun-call` implied by `-D warnings`
 
@@ -10,7 +10,7 @@ error: use of `unwrap_or` followed by a function call
   --> $DIR/unwrap_or.rs:9:47
    |
 LL |     let s = Some(String::from("test string")).unwrap_or("Fail".to_string()).len();
-   |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|| "Fail".to_string())`
+   |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| "Fail".to_string())`
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/useless_asref.stderr b/tests/ui/useless_asref.stderr
index 67ce8b64e0e..1f51831b2e9 100644
--- a/tests/ui/useless_asref.stderr
+++ b/tests/ui/useless_asref.stderr
@@ -2,7 +2,7 @@ error: this call to `as_ref` does nothing
   --> $DIR/useless_asref.rs:43:18
    |
 LL |         foo_rstr(rstr.as_ref());
-   |                  ^^^^^^^^^^^^^ help: try this: `rstr`
+   |                  ^^^^^^^^^^^^^ help: try: `rstr`
    |
 note: the lint level is defined here
   --> $DIR/useless_asref.rs:2:9
@@ -14,61 +14,61 @@ error: this call to `as_ref` does nothing
   --> $DIR/useless_asref.rs:45:20
    |
 LL |         foo_rslice(rslice.as_ref());
-   |                    ^^^^^^^^^^^^^^^ help: try this: `rslice`
+   |                    ^^^^^^^^^^^^^^^ help: try: `rslice`
 
 error: this call to `as_mut` does nothing
   --> $DIR/useless_asref.rs:49:21
    |
 LL |         foo_mrslice(mrslice.as_mut());
-   |                     ^^^^^^^^^^^^^^^^ help: try this: `mrslice`
+   |                     ^^^^^^^^^^^^^^^^ help: try: `mrslice`
 
 error: this call to `as_ref` does nothing
   --> $DIR/useless_asref.rs:51:20
    |
 LL |         foo_rslice(mrslice.as_ref());
-   |                    ^^^^^^^^^^^^^^^^ help: try this: `mrslice`
+   |                    ^^^^^^^^^^^^^^^^ help: try: `mrslice`
 
 error: this call to `as_ref` does nothing
   --> $DIR/useless_asref.rs:58:20
    |
 LL |         foo_rslice(rrrrrslice.as_ref());
-   |                    ^^^^^^^^^^^^^^^^^^^ help: try this: `rrrrrslice`
+   |                    ^^^^^^^^^^^^^^^^^^^ help: try: `rrrrrslice`
 
 error: this call to `as_ref` does nothing
   --> $DIR/useless_asref.rs:60:18
    |
 LL |         foo_rstr(rrrrrstr.as_ref());
-   |                  ^^^^^^^^^^^^^^^^^ help: try this: `rrrrrstr`
+   |                  ^^^^^^^^^^^^^^^^^ help: try: `rrrrrstr`
 
 error: this call to `as_mut` does nothing
   --> $DIR/useless_asref.rs:65:21
    |
 LL |         foo_mrslice(mrrrrrslice.as_mut());
-   |                     ^^^^^^^^^^^^^^^^^^^^ help: try this: `mrrrrrslice`
+   |                     ^^^^^^^^^^^^^^^^^^^^ help: try: `mrrrrrslice`
 
 error: this call to `as_ref` does nothing
   --> $DIR/useless_asref.rs:67:20
    |
 LL |         foo_rslice(mrrrrrslice.as_ref());
-   |                    ^^^^^^^^^^^^^^^^^^^^ help: try this: `mrrrrrslice`
+   |                    ^^^^^^^^^^^^^^^^^^^^ help: try: `mrrrrrslice`
 
 error: this call to `as_ref` does nothing
   --> $DIR/useless_asref.rs:71:16
    |
 LL |     foo_rrrrmr((&&&&MoreRef).as_ref());
-   |                ^^^^^^^^^^^^^^^^^^^^^^ help: try this: `(&&&&MoreRef)`
+   |                ^^^^^^^^^^^^^^^^^^^^^^ help: try: `(&&&&MoreRef)`
 
 error: this call to `as_mut` does nothing
   --> $DIR/useless_asref.rs:121:13
    |
 LL |     foo_mrt(mrt.as_mut());
-   |             ^^^^^^^^^^^^ help: try this: `mrt`
+   |             ^^^^^^^^^^^^ help: try: `mrt`
 
 error: this call to `as_ref` does nothing
   --> $DIR/useless_asref.rs:123:12
    |
 LL |     foo_rt(mrt.as_ref());
-   |            ^^^^^^^^^^^^ help: try this: `mrt`
+   |            ^^^^^^^^^^^^ help: try: `mrt`
 
 error: aborting due to 11 previous errors
 
diff --git a/tests/ui/wildcard_enum_match_arm.stderr b/tests/ui/wildcard_enum_match_arm.stderr
index 30d29aa4e77..5b88ae4ab66 100644
--- a/tests/ui/wildcard_enum_match_arm.stderr
+++ b/tests/ui/wildcard_enum_match_arm.stderr
@@ -2,7 +2,7 @@ error: wildcard match will also match any future added variants
   --> $DIR/wildcard_enum_match_arm.rs:40:9
    |
 LL |         _ => eprintln!("Not red"),
-   |         ^ help: try this: `Color::Green | Color::Blue | Color::Rgb(..) | Color::Cyan`
+   |         ^ help: try: `Color::Green | Color::Blue | Color::Rgb(..) | Color::Cyan`
    |
 note: the lint level is defined here
   --> $DIR/wildcard_enum_match_arm.rs:3:9
@@ -14,31 +14,31 @@ error: wildcard match will also match any future added variants
   --> $DIR/wildcard_enum_match_arm.rs:44:9
    |
 LL |         _not_red => eprintln!("Not red"),
-   |         ^^^^^^^^ help: try this: `_not_red @ Color::Green | _not_red @ Color::Blue | _not_red @ Color::Rgb(..) | _not_red @ Color::Cyan`
+   |         ^^^^^^^^ help: try: `_not_red @ Color::Green | _not_red @ Color::Blue | _not_red @ Color::Rgb(..) | _not_red @ Color::Cyan`
 
 error: wildcard match will also match any future added variants
   --> $DIR/wildcard_enum_match_arm.rs:48:9
    |
 LL |         not_red => format!("{:?}", not_red),
-   |         ^^^^^^^ help: try this: `not_red @ Color::Green | not_red @ Color::Blue | not_red @ Color::Rgb(..) | not_red @ Color::Cyan`
+   |         ^^^^^^^ help: try: `not_red @ Color::Green | not_red @ Color::Blue | not_red @ Color::Rgb(..) | not_red @ Color::Cyan`
 
 error: wildcard match will also match any future added variants
   --> $DIR/wildcard_enum_match_arm.rs:64:9
    |
 LL |         _ => "No red",
-   |         ^ help: try this: `Color::Red | Color::Green | Color::Blue | Color::Rgb(..) | Color::Cyan`
+   |         ^ help: try: `Color::Red | Color::Green | Color::Blue | Color::Rgb(..) | Color::Cyan`
 
 error: wildcard matches known variants and will also match future added variants
   --> $DIR/wildcard_enum_match_arm.rs:81:9
    |
 LL |         _ => {},
-   |         ^ help: try this: `ErrorKind::PermissionDenied | _`
+   |         ^ help: try: `ErrorKind::PermissionDenied | _`
 
 error: wildcard match will also match any future added variants
   --> $DIR/wildcard_enum_match_arm.rs:99:13
    |
 LL |             _ => (),
-   |             ^ help: try this: `Enum::B | Enum::__Private`
+   |             ^ help: try: `Enum::B | Enum::__Private`
 
 error: aborting due to 6 previous errors
 
diff --git a/tests/ui/write_literal.stderr b/tests/ui/write_literal.stderr
index 1e306ae28a2..8b72c8bd282 100644
--- a/tests/ui/write_literal.stderr
+++ b/tests/ui/write_literal.stderr
@@ -5,7 +5,7 @@ LL |     write!(v, "Hello {}", "world");
    |                           ^^^^^^^
    |
    = note: `-D clippy::write-literal` implied by `-D warnings`
-help: try this
+help: try
    |
 LL -     write!(v, "Hello {}", "world");
 LL +     write!(v, "Hello world");
@@ -17,7 +17,7 @@ error: literal with an empty format string
 LL |     writeln!(v, "Hello {} {}", world, "world");
    |                                       ^^^^^^^
    |
-help: try this
+help: try
    |
 LL -     writeln!(v, "Hello {} {}", world, "world");
 LL +     writeln!(v, "Hello {} world", world);
@@ -29,7 +29,7 @@ error: literal with an empty format string
 LL |     writeln!(v, "Hello {}", "world");
    |                             ^^^^^^^
    |
-help: try this
+help: try
    |
 LL -     writeln!(v, "Hello {}", "world");
 LL +     writeln!(v, "Hello world");
@@ -41,7 +41,7 @@ error: literal with an empty format string
 LL |     writeln!(v, "{} {:.4}", "a literal", 5);
    |                             ^^^^^^^^^^^
    |
-help: try this
+help: try
    |
 LL -     writeln!(v, "{} {:.4}", "a literal", 5);
 LL +     writeln!(v, "a literal {:.4}", 5);
@@ -53,7 +53,7 @@ error: literal with an empty format string
 LL |     writeln!(v, "{0} {1}", "hello", "world");
    |                            ^^^^^^^
    |
-help: try this
+help: try
    |
 LL -     writeln!(v, "{0} {1}", "hello", "world");
 LL +     writeln!(v, "hello {1}", "world");
@@ -65,7 +65,7 @@ error: literal with an empty format string
 LL |     writeln!(v, "{0} {1}", "hello", "world");
    |                                     ^^^^^^^
    |
-help: try this
+help: try
    |
 LL -     writeln!(v, "{0} {1}", "hello", "world");
 LL +     writeln!(v, "{0} world", "hello");
@@ -77,7 +77,7 @@ error: literal with an empty format string
 LL |     writeln!(v, "{1} {0}", "hello", "world");
    |                                     ^^^^^^^
    |
-help: try this
+help: try
    |
 LL -     writeln!(v, "{1} {0}", "hello", "world");
 LL +     writeln!(v, "world {0}", "hello");
@@ -89,7 +89,7 @@ error: literal with an empty format string
 LL |     writeln!(v, "{1} {0}", "hello", "world");
    |                            ^^^^^^^
    |
-help: try this
+help: try
    |
 LL -     writeln!(v, "{1} {0}", "hello", "world");
 LL +     writeln!(v, "{1} hello", "world");
@@ -101,7 +101,7 @@ error: literal with an empty format string
 LL |     writeln!(v, "{foo} {bar}", foo = "hello", bar = "world");
    |                                      ^^^^^^^
    |
-help: try this
+help: try
    |
 LL -     writeln!(v, "{foo} {bar}", foo = "hello", bar = "world");
 LL +     writeln!(v, "hello {bar}", bar = "world");
@@ -113,7 +113,7 @@ error: literal with an empty format string
 LL |     writeln!(v, "{foo} {bar}", foo = "hello", bar = "world");
    |                                                     ^^^^^^^
    |
-help: try this
+help: try
    |
 LL -     writeln!(v, "{foo} {bar}", foo = "hello", bar = "world");
 LL +     writeln!(v, "{foo} world", foo = "hello");
@@ -125,7 +125,7 @@ error: literal with an empty format string
 LL |     writeln!(v, "{bar} {foo}", foo = "hello", bar = "world");
    |                                                     ^^^^^^^
    |
-help: try this
+help: try
    |
 LL -     writeln!(v, "{bar} {foo}", foo = "hello", bar = "world");
 LL +     writeln!(v, "world {foo}", foo = "hello");
@@ -137,7 +137,7 @@ error: literal with an empty format string
 LL |     writeln!(v, "{bar} {foo}", foo = "hello", bar = "world");
    |                                      ^^^^^^^
    |
-help: try this
+help: try
    |
 LL -     writeln!(v, "{bar} {foo}", foo = "hello", bar = "world");
 LL +     writeln!(v, "{bar} hello", bar = "world");
diff --git a/tests/ui/write_literal_2.stderr b/tests/ui/write_literal_2.stderr
index 18591250aad..c30ec385b35 100644
--- a/tests/ui/write_literal_2.stderr
+++ b/tests/ui/write_literal_2.stderr
@@ -13,7 +13,7 @@ LL |     writeln!(v, "{}", "{hello}");
    |                       ^^^^^^^^^
    |
    = note: `-D clippy::write-literal` implied by `-D warnings`
-help: try this
+help: try
    |
 LL -     writeln!(v, "{}", "{hello}");
 LL +     writeln!(v, "{{hello}}");
@@ -25,7 +25,7 @@ error: literal with an empty format string
 LL |     writeln!(v, r"{}", r"{hello}");
    |                        ^^^^^^^^^^
    |
-help: try this
+help: try
    |
 LL -     writeln!(v, r"{}", r"{hello}");
 LL +     writeln!(v, r"{{hello}}");
@@ -37,7 +37,7 @@ error: literal with an empty format string
 LL |     writeln!(v, "{}", '/'');
    |                       ^^^^
    |
-help: try this
+help: try
    |
 LL -     writeln!(v, "{}", '/'');
 LL +     writeln!(v, "'");
@@ -49,7 +49,7 @@ error: literal with an empty format string
 LL |     writeln!(v, "{}", '"');
    |                       ^^^
    |
-help: try this
+help: try
    |
 LL -     writeln!(v, "{}", '"');
 LL +     writeln!(v, "/"");
@@ -67,7 +67,7 @@ error: literal with an empty format string
 LL |     writeln!(v, r"{}", '/'');
    |                        ^^^^
    |
-help: try this
+help: try
    |
 LL -     writeln!(v, r"{}", '/'');
 LL +     writeln!(v, r"'");
@@ -80,7 +80,7 @@ LL | /         "hello /
 LL | |         world!"
    | |_______________^
    |
-help: try this
+help: try
    |
 LL ~         "some hello /
 LL ~         world!"
@@ -92,7 +92,7 @@ error: literal with an empty format string
 LL |         "1", "2", "3",
    |         ^^^
    |
-help: try this
+help: try
    |
 LL ~         "some 1/
 LL ~         {} // {}", "2", "3",
@@ -104,7 +104,7 @@ error: literal with an empty format string
 LL |         "1", "2", "3",
    |              ^^^
    |
-help: try this
+help: try
    |
 LL ~         2 // {}",
 LL ~         "1", "3",
@@ -116,7 +116,7 @@ error: literal with an empty format string
 LL |         "1", "2", "3",
    |                   ^^^
    |
-help: try this
+help: try
    |
 LL ~         {} // 3",
 LL ~         "1", "2",
@@ -128,7 +128,7 @@ error: literal with an empty format string
 LL |     writeln!(v, "{}", "//");
    |                       ^^^^
    |
-help: try this
+help: try
    |
 LL -     writeln!(v, "{}", "//");
 LL +     writeln!(v, "//");
@@ -140,7 +140,7 @@ error: literal with an empty format string
 LL |     writeln!(v, r"{}", "//");
    |                        ^^^^
    |
-help: try this
+help: try
    |
 LL -     writeln!(v, r"{}", "//");
 LL +     writeln!(v, r"/");
@@ -152,7 +152,7 @@ error: literal with an empty format string
 LL |     writeln!(v, r#"{}"#, "//");
    |                          ^^^^
    |
-help: try this
+help: try
    |
 LL -     writeln!(v, r#"{}"#, "//");
 LL +     writeln!(v, r#"/"#);
@@ -164,7 +164,7 @@ error: literal with an empty format string
 LL |     writeln!(v, "{}", r"/");
    |                       ^^^^
    |
-help: try this
+help: try
    |
 LL -     writeln!(v, "{}", r"/");
 LL +     writeln!(v, "//");
@@ -176,7 +176,7 @@ error: literal with an empty format string
 LL |     writeln!(v, "{}", "/r");
    |                       ^^^^
    |
-help: try this
+help: try
    |
 LL -     writeln!(v, "{}", "/r");
 LL +     writeln!(v, "/r");
-- 
cgit 1.4.1-3-g733a5


From 354172a18efcf104db76fd7dba884b329e9bac7d Mon Sep 17 00:00:00 2001
From: Catherine <114838443+Centri3@users.noreply.github.com>
Date: Fri, 23 Jun 2023 05:43:53 -0500
Subject: New lint `manual_try_fold`

---
 CHANGELOG.md                                |  1 +
 clippy_lints/src/declared_lints.rs          |  1 +
 clippy_lints/src/methods/manual_try_fold.rs | 55 +++++++++++++++++++
 clippy_lints/src/methods/mod.rs             | 33 +++++++++++-
 clippy_utils/src/msrvs.rs                   |  1 +
 tests/ui/manual_try_fold.rs                 | 84 +++++++++++++++++++++++++++++
 tests/ui/manual_try_fold.stderr             | 22 ++++++++
 7 files changed, 195 insertions(+), 2 deletions(-)
 create mode 100644 clippy_lints/src/methods/manual_try_fold.rs
 create mode 100644 tests/ui/manual_try_fold.rs
 create mode 100644 tests/ui/manual_try_fold.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index ff39c6a0a6c..14d822083d8 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4959,6 +4959,7 @@ Released 2018-09-13
 [`manual_string_new`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_string_new
 [`manual_strip`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_strip
 [`manual_swap`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_swap
+[`manual_try_fold`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_try_fold
 [`manual_unwrap_or`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_unwrap_or
 [`manual_while_let_some`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_while_let_some
 [`many_single_char_names`]: https://rust-lang.github.io/rust-clippy/master/index.html#many_single_char_names
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 52bc2010207..9d9ee6ba307 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -364,6 +364,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::methods::MANUAL_SATURATING_ARITHMETIC_INFO,
     crate::methods::MANUAL_SPLIT_ONCE_INFO,
     crate::methods::MANUAL_STR_REPEAT_INFO,
+    crate::methods::MANUAL_TRY_FOLD_INFO,
     crate::methods::MAP_CLONE_INFO,
     crate::methods::MAP_COLLECT_RESULT_UNIT_INFO,
     crate::methods::MAP_ERR_IGNORE_INFO,
diff --git a/clippy_lints/src/methods/manual_try_fold.rs b/clippy_lints/src/methods/manual_try_fold.rs
new file mode 100644
index 00000000000..9f92524d356
--- /dev/null
+++ b/clippy_lints/src/methods/manual_try_fold.rs
@@ -0,0 +1,55 @@
+use clippy_utils::{
+    diagnostics::span_lint_and_sugg,
+    is_from_proc_macro,
+    msrvs::{Msrv, ITERATOR_TRY_FOLD},
+    source::snippet_opt,
+    ty::implements_trait,
+};
+use rustc_errors::Applicability;
+use rustc_hir::{
+    def::{DefKind, Res},
+    Expr, ExprKind,
+};
+use rustc_lint::{LateContext, LintContext};
+use rustc_middle::lint::in_external_macro;
+use rustc_span::Span;
+
+use super::MANUAL_TRY_FOLD;
+
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &Expr<'tcx>,
+    init: &Expr<'_>,
+    acc: &Expr<'_>,
+    fold_span: Span,
+    msrv: &Msrv,
+) {
+    if !in_external_macro(cx.sess(), fold_span)
+        && msrv.meets(ITERATOR_TRY_FOLD)
+        && let init_ty = cx.typeck_results().expr_ty(init)
+        && let Some(try_trait) = cx.tcx.lang_items().try_trait()
+        && implements_trait(cx, init_ty, try_trait, &[])
+        && let ExprKind::Call(path, [first, rest @ ..]) = init.kind
+        && let ExprKind::Path(qpath) = path.kind
+        && let Res::Def(DefKind::Ctor(_, _), _) = cx.qpath_res(&qpath, path.hir_id)
+        && let ExprKind::Closure(closure) = acc.kind
+        && let Some(args_snip) = closure.fn_arg_span.and_then(|fn_arg_span| snippet_opt(cx, fn_arg_span))
+        && !is_from_proc_macro(cx, expr)
+    {
+        let init_snip = rest
+            .is_empty()
+            .then_some(first.span)
+            .and_then(|span| snippet_opt(cx, span))
+            .unwrap_or("...".to_owned());
+
+        span_lint_and_sugg(
+            cx,
+            MANUAL_TRY_FOLD,
+            fold_span,
+            "you seem to be using `Iterator::fold` on a type that implements `Try`",
+            "use `try_fold` instead",
+            format!("try_fold({init_snip}, {args_snip}, ...)", ),
+            Applicability::HasPlaceholders,
+        );
+    }
+}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index b1d3b61aea3..a8d03bb95e6 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -50,6 +50,7 @@ mod manual_next_back;
 mod manual_ok_or;
 mod manual_saturating_arithmetic;
 mod manual_str_repeat;
+mod manual_try_fold;
 mod map_clone;
 mod map_collect_result_unit;
 mod map_err_ignore;
@@ -3286,6 +3287,30 @@ declare_clippy_lint! {
     "calling `.drain(..).collect()` to move all elements into a new collection"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of `Iterator::fold` with a type that implements `Try`.
+    ///
+    /// ### Why is this bad?
+    /// This is better represented with `try_fold`, but this has one major difference: It will
+    /// short-circuit on failure. *This is almost always what you want*. This can also open the door
+    /// for additional optimizations as well, as rustc can guarantee the function is never
+    /// called on `None`, `Err`, etc., alleviating otherwise necessary checks.
+    ///
+    /// ### Example
+    /// ```rust
+    /// vec![1, 2, 3].iter().fold(Some(0i32), |sum, i| sum?.checked_add(*i));
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// vec![1, 2, 3].iter().try_fold(0i32, |sum, i| sum.checked_add(*i));
+    /// ```
+    #[clippy::version = "1.72.0"]
+    pub MANUAL_TRY_FOLD,
+    perf,
+    "checks for usage of `Iterator::fold` with a type that implements `Try`"
+}
+
 pub struct Methods {
     avoid_breaking_exported_api: bool,
     msrv: Msrv,
@@ -3416,7 +3441,8 @@ impl_lint_pass!(Methods => [
     CLEAR_WITH_DRAIN,
     MANUAL_NEXT_BACK,
     UNNECESSARY_LITERAL_UNWRAP,
-    DRAIN_COLLECT
+    DRAIN_COLLECT,
+    MANUAL_TRY_FOLD,
 ]);
 
 /// Extracts a method call name, args, and `Span` of the method name.
@@ -3709,7 +3735,10 @@ impl Methods {
                     Some(("cloned", recv2, [], _, _)) => iter_overeager_cloned::check(cx, expr, recv, recv2, false, true),
                     _ => {},
                 },
-                ("fold", [init, acc]) => unnecessary_fold::check(cx, expr, init, acc, span),
+                ("fold", [init, acc]) => {
+                    manual_try_fold::check(cx, expr, init, acc, call_span, &self.msrv);
+                    unnecessary_fold::check(cx, expr, init, acc, span);
+                },
                 ("for_each", [_]) => {
                     if let Some(("inspect", _, [_], span2, _)) = method_call(recv) {
                         inspect_for_each::check(cx, expr, span2);
diff --git a/clippy_utils/src/msrvs.rs b/clippy_utils/src/msrvs.rs
index 1f70f11bd67..3637476c408 100644
--- a/clippy_utils/src/msrvs.rs
+++ b/clippy_utils/src/msrvs.rs
@@ -44,6 +44,7 @@ msrv_aliases! {
     1,34,0 { TRY_FROM }
     1,30,0 { ITERATOR_FIND_MAP, TOOL_ATTRIBUTES }
     1,28,0 { FROM_BOOL }
+    1,27,0 { ITERATOR_TRY_FOLD }
     1,26,0 { RANGE_INCLUSIVE, STRING_RETAIN }
     1,24,0 { IS_ASCII_DIGIT }
     1,18,0 { HASH_MAP_RETAIN, HASH_SET_RETAIN }
diff --git a/tests/ui/manual_try_fold.rs b/tests/ui/manual_try_fold.rs
new file mode 100644
index 00000000000..f43519dd44f
--- /dev/null
+++ b/tests/ui/manual_try_fold.rs
@@ -0,0 +1,84 @@
+//@aux-build:proc_macros.rs
+#![allow(clippy::unnecessary_fold, unused)]
+#![warn(clippy::manual_try_fold)]
+#![feature(try_trait_v2)]
+
+use std::ops::ControlFlow;
+use std::ops::FromResidual;
+use std::ops::Try;
+
+#[macro_use]
+extern crate proc_macros;
+
+// Test custom `Try` with more than 1 argument
+struct NotOption(i32, i32);
+
+impl<R> FromResidual<R> for NotOption {
+    fn from_residual(_: R) -> Self {
+        todo!()
+    }
+}
+
+impl Try for NotOption {
+    type Output = ();
+    type Residual = ();
+
+    fn from_output(_: Self::Output) -> Self {
+        todo!()
+    }
+
+    fn branch(self) -> ControlFlow<Self::Residual, Self::Output> {
+        todo!()
+    }
+}
+
+// Test custom `Try` with only 1 argument
+#[derive(Default)]
+struct NotOptionButWorse(i32);
+
+impl<R> FromResidual<R> for NotOptionButWorse {
+    fn from_residual(_: R) -> Self {
+        todo!()
+    }
+}
+
+impl Try for NotOptionButWorse {
+    type Output = ();
+    type Residual = ();
+
+    fn from_output(_: Self::Output) -> Self {
+        todo!()
+    }
+
+    fn branch(self) -> ControlFlow<Self::Residual, Self::Output> {
+        todo!()
+    }
+}
+
+fn main() {
+    [1, 2, 3]
+        .iter()
+        .fold(Some(0i32), |sum, i| sum?.checked_add(*i))
+        .unwrap();
+    [1, 2, 3]
+        .iter()
+        .fold(NotOption(0i32, 0i32), |sum, i| NotOption(0i32, 0i32));
+    [1, 2, 3]
+        .iter()
+        .fold(NotOptionButWorse(0i32), |sum, i| NotOptionButWorse(0i32));
+    // Do not lint
+    [1, 2, 3].iter().try_fold(0i32, |sum, i| sum.checked_add(*i)).unwrap();
+    [1, 2, 3].iter().fold(0i32, |sum, i| sum + i);
+    [1, 2, 3]
+        .iter()
+        .fold(NotOptionButWorse::default(), |sum, i| NotOptionButWorse::default());
+    external! {
+        [1, 2, 3].iter().fold(Some(0i32), |sum, i| sum?.checked_add(*i)).unwrap();
+        [1, 2, 3].iter().try_fold(0i32, |sum, i| sum.checked_add(*i)).unwrap();
+    }
+    with_span! {
+        span
+        [1, 2, 3].iter().fold(Some(0i32), |sum, i| sum?.checked_add(*i)).unwrap();
+        [1, 2, 3].iter().try_fold(0i32, |sum, i| sum.checked_add(*i)).unwrap();
+    }
+}
diff --git a/tests/ui/manual_try_fold.stderr b/tests/ui/manual_try_fold.stderr
new file mode 100644
index 00000000000..1a17435b459
--- /dev/null
+++ b/tests/ui/manual_try_fold.stderr
@@ -0,0 +1,22 @@
+error: you seem to be using `Iterator::fold` on a type that implements `Try`
+  --> $DIR/manual_try_fold.rs:61:10
+   |
+LL |         .fold(Some(0i32), |sum, i| sum?.checked_add(*i))
+   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `try_fold` instead: `try_fold(0i32, |sum, i|, ...)`
+   |
+   = note: `-D clippy::manual-try-fold` implied by `-D warnings`
+
+error: you seem to be using `Iterator::fold` on a type that implements `Try`
+  --> $DIR/manual_try_fold.rs:65:10
+   |
+LL |         .fold(NotOption(0i32, 0i32), |sum, i| NotOption(0i32, 0i32));
+   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `try_fold` instead: `try_fold(..., |sum, i|, ...)`
+
+error: you seem to be using `Iterator::fold` on a type that implements `Try`
+  --> $DIR/manual_try_fold.rs:68:10
+   |
+LL |         .fold(NotOptionButWorse(0i32), |sum, i| NotOptionButWorse(0i32));
+   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `try_fold` instead: `try_fold(0i32, |sum, i|, ...)`
+
+error: aborting due to 3 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 04b08576911cf06bc444fb0615f50c29ec82e675 Mon Sep 17 00:00:00 2001
From: Catherine <114838443+Centri3@users.noreply.github.com>
Date: Sun, 25 Jun 2023 09:01:06 -0500
Subject: Typo

---
 clippy_lints/src/methods/manual_try_fold.rs | 4 ++--
 tests/ui/manual_try_fold.stderr             | 8 ++++----
 2 files changed, 6 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/manual_try_fold.rs b/clippy_lints/src/methods/manual_try_fold.rs
index 9f92524d356..a1d83cf1419 100644
--- a/clippy_lints/src/methods/manual_try_fold.rs
+++ b/clippy_lints/src/methods/manual_try_fold.rs
@@ -33,8 +33,8 @@ pub(super) fn check<'tcx>(
         && let ExprKind::Path(qpath) = path.kind
         && let Res::Def(DefKind::Ctor(_, _), _) = cx.qpath_res(&qpath, path.hir_id)
         && let ExprKind::Closure(closure) = acc.kind
-        && let Some(args_snip) = closure.fn_arg_span.and_then(|fn_arg_span| snippet_opt(cx, fn_arg_span))
         && !is_from_proc_macro(cx, expr)
+        && let Some(args_snip) = closure.fn_arg_span.and_then(|fn_arg_span| snippet_opt(cx, fn_arg_span))
     {
         let init_snip = rest
             .is_empty()
@@ -48,7 +48,7 @@ pub(super) fn check<'tcx>(
             fold_span,
             "you seem to be using `Iterator::fold` on a type that implements `Try`",
             "use `try_fold` instead",
-            format!("try_fold({init_snip}, {args_snip}, ...)", ),
+            format!("try_fold({init_snip}, {args_snip} ...)", ),
             Applicability::HasPlaceholders,
         );
     }
diff --git a/tests/ui/manual_try_fold.stderr b/tests/ui/manual_try_fold.stderr
index 0c8a08e6c7d..2c0b0c67fd1 100644
--- a/tests/ui/manual_try_fold.stderr
+++ b/tests/ui/manual_try_fold.stderr
@@ -2,7 +2,7 @@ error: you seem to be using `Iterator::fold` on a type that implements `Try`
   --> $DIR/manual_try_fold.rs:61:10
    |
 LL |         .fold(Some(0i32), |sum, i| sum?.checked_add(*i))
-   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `try_fold` instead: `try_fold(0i32, |sum, i|, ...)`
+   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `try_fold` instead: `try_fold(0i32, |sum, i| ...)`
    |
    = note: `-D clippy::manual-try-fold` implied by `-D warnings`
 
@@ -10,19 +10,19 @@ error: you seem to be using `Iterator::fold` on a type that implements `Try`
   --> $DIR/manual_try_fold.rs:65:10
    |
 LL |         .fold(NotOption(0i32, 0i32), |sum, i| NotOption(0i32, 0i32));
-   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `try_fold` instead: `try_fold(..., |sum, i|, ...)`
+   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `try_fold` instead: `try_fold(..., |sum, i| ...)`
 
 error: you seem to be using `Iterator::fold` on a type that implements `Try`
   --> $DIR/manual_try_fold.rs:68:10
    |
 LL |         .fold(NotOptionButWorse(0i32), |sum, i| NotOptionButWorse(0i32));
-   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `try_fold` instead: `try_fold(0i32, |sum, i|, ...)`
+   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `try_fold` instead: `try_fold(0i32, |sum, i| ...)`
 
 error: you seem to be using `Iterator::fold` on a type that implements `Try`
   --> $DIR/manual_try_fold.rs:98:10
    |
 LL |         .fold(Some(0i32), |sum, i| sum?.checked_add(*i))
-   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `try_fold` instead: `try_fold(0i32, |sum, i|, ...)`
+   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `try_fold` instead: `try_fold(0i32, |sum, i| ...)`
 
 error: aborting due to 4 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From fbb3f759e2c6d90456f42a72eaaa741201d8e463 Mon Sep 17 00:00:00 2001
From: Catherine <114838443+Centri3@users.noreply.github.com>
Date: Mon, 26 Jun 2023 14:32:01 -0500
Subject: update docs

---
 clippy_lints/src/methods/mod.rs | 13 +++++++++----
 tests/ui/manual_try_fold.rs     |  2 +-
 2 files changed, 10 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index a8d03bb95e6..2cd7ca02755 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3292,10 +3292,15 @@ declare_clippy_lint! {
     /// Checks for usage of `Iterator::fold` with a type that implements `Try`.
     ///
     /// ### Why is this bad?
-    /// This is better represented with `try_fold`, but this has one major difference: It will
-    /// short-circuit on failure. *This is almost always what you want*. This can also open the door
-    /// for additional optimizations as well, as rustc can guarantee the function is never
-    /// called on `None`, `Err`, etc., alleviating otherwise necessary checks.
+    /// This should use `try_fold` instead, which short-circuits on failure, thus opening the door
+    /// for additional optimizations not possible with `fold` as rustc can guarantee the function is
+    /// never called on `None`, `Err`, etc., alleviating otherwise necessary checks. It's also
+    /// slightly more idiomatic.
+    ///
+    /// ### Known issues
+    /// This lint doesn't take into account whether a function does something on the failure case,
+    /// i.e., whether short-circuiting will affect behavior. Refactoring to `try_fold` is not
+    /// desirable in those cases.
     ///
     /// ### Example
     /// ```rust
diff --git a/tests/ui/manual_try_fold.rs b/tests/ui/manual_try_fold.rs
index e00371eb228..4521e9fa1a5 100644
--- a/tests/ui/manual_try_fold.rs
+++ b/tests/ui/manual_try_fold.rs
@@ -1,4 +1,4 @@
-//@aux-build:proc_macros.rs
+//@aux-build:proc_macros.rs:proc-macro
 #![allow(clippy::unnecessary_fold, unused)]
 #![warn(clippy::manual_try_fold)]
 #![feature(try_trait_v2)]
-- 
cgit 1.4.1-3-g733a5


From cb5d7e344a4f42eefb5b7d3df42f8899a684e73b Mon Sep 17 00:00:00 2001
From: Catherine <114838443+Centri3@users.noreply.github.com>
Date: Thu, 29 Jun 2023 02:26:45 -0500
Subject: address comments

---
 book/src/lint_configuration.md              | 1 +
 clippy_lints/src/methods/manual_try_fold.rs | 2 +-
 clippy_lints/src/methods/mod.rs             | 8 ++++----
 clippy_lints/src/utils/conf.rs              | 2 +-
 tests/ui/manual_try_fold.stderr             | 8 ++++----
 5 files changed, 11 insertions(+), 10 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/book/src/lint_configuration.md b/book/src/lint_configuration.md
index ae0b5140316..60d7ce6e615 100644
--- a/book/src/lint_configuration.md
+++ b/book/src/lint_configuration.md
@@ -150,6 +150,7 @@ The minimum rust version that the project supports
 * [`manual_retain`](https://rust-lang.github.io/rust-clippy/master/index.html#manual_retain)
 * [`type_repetition_in_bounds`](https://rust-lang.github.io/rust-clippy/master/index.html#type_repetition_in_bounds)
 * [`tuple_array_conversions`](https://rust-lang.github.io/rust-clippy/master/index.html#tuple_array_conversions)
+* [`manual_try_fold`](https://rust-lang.github.io/rust-clippy/master/index.html#manual_try_fold)
 
 
 ## `cognitive-complexity-threshold`
diff --git a/clippy_lints/src/methods/manual_try_fold.rs b/clippy_lints/src/methods/manual_try_fold.rs
index a1d83cf1419..576a58499b1 100644
--- a/clippy_lints/src/methods/manual_try_fold.rs
+++ b/clippy_lints/src/methods/manual_try_fold.rs
@@ -46,7 +46,7 @@ pub(super) fn check<'tcx>(
             cx,
             MANUAL_TRY_FOLD,
             fold_span,
-            "you seem to be using `Iterator::fold` on a type that implements `Try`",
+            "usage of `Iterator::fold` on a type that implements `Try`",
             "use `try_fold` instead",
             format!("try_fold({init_snip}, {args_snip} ...)", ),
             Applicability::HasPlaceholders,
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 2cd7ca02755..24dbe8c1d75 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3292,10 +3292,10 @@ declare_clippy_lint! {
     /// Checks for usage of `Iterator::fold` with a type that implements `Try`.
     ///
     /// ### Why is this bad?
-    /// This should use `try_fold` instead, which short-circuits on failure, thus opening the door
-    /// for additional optimizations not possible with `fold` as rustc can guarantee the function is
-    /// never called on `None`, `Err`, etc., alleviating otherwise necessary checks. It's also
-    /// slightly more idiomatic.
+    /// The code should use `try_fold` instead, which short-circuits on failure, thus opening the
+    /// door for additional optimizations not possible with `fold` as rustc can guarantee the
+    /// function is never called on `None`, `Err`, etc., alleviating otherwise necessary checks. It's
+    /// also slightly more idiomatic.
     ///
     /// ### Known issues
     /// This lint doesn't take into account whether a function does something on the failure case,
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 89063964622..f1d05c7529b 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -294,7 +294,7 @@ define_Conf! {
     ///
     /// Suppress lints whenever the suggested change would cause breakage for other crates.
     (avoid_breaking_exported_api: bool = true),
-    /// Lint: MANUAL_SPLIT_ONCE, MANUAL_STR_REPEAT, CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, OPTION_MAP_UNWRAP_OR, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR, IF_THEN_SOME_ELSE_NONE, APPROX_CONSTANT, DEPRECATED_CFG_ATTR, INDEX_REFUTABLE_SLICE, MAP_CLONE, BORROW_AS_PTR, MANUAL_BITS, ERR_EXPECT, CAST_ABS_TO_UNSIGNED, UNINLINED_FORMAT_ARGS, MANUAL_CLAMP, MANUAL_LET_ELSE, UNCHECKED_DURATION_SUBTRACTION, COLLAPSIBLE_STR_REPLACE, SEEK_FROM_CURRENT, SEEK_REWIND, UNNECESSARY_LAZY_EVALUATIONS, TRANSMUTE_PTR_TO_REF, ALMOST_COMPLETE_RANGE, NEEDLESS_BORROW, DERIVABLE_IMPLS, MANUAL_IS_ASCII_CHECK, MANUAL_REM_EUCLID, MANUAL_RETAIN, TYPE_REPETITION_IN_BOUNDS, TUPLE_ARRAY_CONVERSIONS.
+    /// Lint: MANUAL_SPLIT_ONCE, MANUAL_STR_REPEAT, CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, OPTION_MAP_UNWRAP_OR, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR, IF_THEN_SOME_ELSE_NONE, APPROX_CONSTANT, DEPRECATED_CFG_ATTR, INDEX_REFUTABLE_SLICE, MAP_CLONE, BORROW_AS_PTR, MANUAL_BITS, ERR_EXPECT, CAST_ABS_TO_UNSIGNED, UNINLINED_FORMAT_ARGS, MANUAL_CLAMP, MANUAL_LET_ELSE, UNCHECKED_DURATION_SUBTRACTION, COLLAPSIBLE_STR_REPLACE, SEEK_FROM_CURRENT, SEEK_REWIND, UNNECESSARY_LAZY_EVALUATIONS, TRANSMUTE_PTR_TO_REF, ALMOST_COMPLETE_RANGE, NEEDLESS_BORROW, DERIVABLE_IMPLS, MANUAL_IS_ASCII_CHECK, MANUAL_REM_EUCLID, MANUAL_RETAIN, TYPE_REPETITION_IN_BOUNDS, TUPLE_ARRAY_CONVERSIONS, MANUAL_TRY_FOLD.
     ///
     /// The minimum rust version that the project supports
     (msrv: Option<String> = None),
diff --git a/tests/ui/manual_try_fold.stderr b/tests/ui/manual_try_fold.stderr
index 2c0b0c67fd1..a0cf5b3b5fc 100644
--- a/tests/ui/manual_try_fold.stderr
+++ b/tests/ui/manual_try_fold.stderr
@@ -1,4 +1,4 @@
-error: you seem to be using `Iterator::fold` on a type that implements `Try`
+error: usage of `Iterator::fold` on a type that implements `Try`
   --> $DIR/manual_try_fold.rs:61:10
    |
 LL |         .fold(Some(0i32), |sum, i| sum?.checked_add(*i))
@@ -6,19 +6,19 @@ LL |         .fold(Some(0i32), |sum, i| sum?.checked_add(*i))
    |
    = note: `-D clippy::manual-try-fold` implied by `-D warnings`
 
-error: you seem to be using `Iterator::fold` on a type that implements `Try`
+error: usage of `Iterator::fold` on a type that implements `Try`
   --> $DIR/manual_try_fold.rs:65:10
    |
 LL |         .fold(NotOption(0i32, 0i32), |sum, i| NotOption(0i32, 0i32));
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `try_fold` instead: `try_fold(..., |sum, i| ...)`
 
-error: you seem to be using `Iterator::fold` on a type that implements `Try`
+error: usage of `Iterator::fold` on a type that implements `Try`
   --> $DIR/manual_try_fold.rs:68:10
    |
 LL |         .fold(NotOptionButWorse(0i32), |sum, i| NotOptionButWorse(0i32));
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `try_fold` instead: `try_fold(0i32, |sum, i| ...)`
 
-error: you seem to be using `Iterator::fold` on a type that implements `Try`
+error: usage of `Iterator::fold` on a type that implements `Try`
   --> $DIR/manual_try_fold.rs:98:10
    |
 LL |         .fold(Some(0i32), |sum, i| sum?.checked_add(*i))
-- 
cgit 1.4.1-3-g733a5


From 885a18207fb66fc736496a4c9cb8c010881c1ab5 Mon Sep 17 00:00:00 2001
From: Catherine <114838443+Centri3@users.noreply.github.com>
Date: Sat, 1 Jul 2023 19:33:08 -0500
Subject: Fix typos

---
 book/src/lint_configuration.md            | 2 +-
 clippy_lints/src/methods/map_unwrap_or.rs | 3 ++-
 clippy_lints/src/min_ident_chars.rs       | 2 +-
 clippy_lints/src/needless_else.rs         | 2 +-
 clippy_lints/src/utils/conf.rs            | 2 +-
 clippy_utils/src/attrs.rs                 | 4 ++--
 clippy_utils/src/check_proc_macro.rs      | 2 +-
 clippy_utils/src/comparisons.rs           | 4 ++--
 clippy_utils/src/consts.rs                | 2 +-
 clippy_utils/src/eager_or_lazy.rs         | 2 +-
 clippy_utils/src/higher.rs                | 8 ++++----
 clippy_utils/src/lib.rs                   | 5 +++--
 clippy_utils/src/sugg.rs                  | 2 +-
 tests/ui/needless_else.stderr             | 2 +-
 14 files changed, 22 insertions(+), 20 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/book/src/lint_configuration.md b/book/src/lint_configuration.md
index ae0b5140316..1ade6e3f481 100644
--- a/book/src/lint_configuration.md
+++ b/book/src/lint_configuration.md
@@ -174,7 +174,7 @@ The maximum amount of nesting a block can reside in
 
 ## `disallowed-names`
 The list of disallowed names to lint about. NB: `bar` is not here since it has legitimate uses. The value
-`".."` can be used as part of the list to indicate, that the configured values should be appended to the
+`".."` can be used as part of the list to indicate that the configured values should be appended to the
 default configuration of Clippy. By default, any configuration will replace the default value.
 
 **Default Value:** `["foo", "baz", "quux"]` (`Vec<String>`)
diff --git a/clippy_lints/src/methods/map_unwrap_or.rs b/clippy_lints/src/methods/map_unwrap_or.rs
index 3122f72ee91..72156bbd1b0 100644
--- a/clippy_lints/src/methods/map_unwrap_or.rs
+++ b/clippy_lints/src/methods/map_unwrap_or.rs
@@ -11,7 +11,8 @@ use rustc_span::symbol::sym;
 use super::MAP_UNWRAP_OR;
 
 /// lint use of `map().unwrap_or_else()` for `Option`s and `Result`s
-/// Return true if lint triggered
+///
+/// Returns true if the lint was emitted
 pub(super) fn check<'tcx>(
     cx: &LateContext<'tcx>,
     expr: &'tcx hir::Expr<'_>,
diff --git a/clippy_lints/src/min_ident_chars.rs b/clippy_lints/src/min_ident_chars.rs
index d49bb0ca6e2..23593e0d4d9 100644
--- a/clippy_lints/src/min_ident_chars.rs
+++ b/clippy_lints/src/min_ident_chars.rs
@@ -25,7 +25,7 @@ declare_clippy_lint! {
     /// ### Example
     /// ```rust,ignore
     /// for m in movies {
-    ///	    let title = m.t;
+    ///     let title = m.t;
     /// }
     /// ```
     /// Use instead:
diff --git a/clippy_lints/src/needless_else.rs b/clippy_lints/src/needless_else.rs
index 4ff1bf7ffc0..23d4a7b9586 100644
--- a/clippy_lints/src/needless_else.rs
+++ b/clippy_lints/src/needless_else.rs
@@ -51,7 +51,7 @@ impl EarlyLintPass for NeedlessElse {
                 cx,
                 NEEDLESS_ELSE,
                 span,
-                "this else branch is empty",
+                "this `else` branch is empty",
                 "you can remove it",
                 String::new(),
                 Applicability::MachineApplicable,
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 89063964622..59e99758829 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -319,7 +319,7 @@ define_Conf! {
     /// Lint: DISALLOWED_NAMES.
     ///
     /// The list of disallowed names to lint about. NB: `bar` is not here since it has legitimate uses. The value
-    /// `".."` can be used as part of the list to indicate, that the configured values should be appended to the
+    /// `".."` can be used as part of the list to indicate that the configured values should be appended to the
     /// default configuration of Clippy. By default, any configuration will replace the default value.
     (disallowed_names: Vec<String> = super::DEFAULT_DISALLOWED_NAMES.iter().map(ToString::to_string).collect()),
     /// Lint: SEMICOLON_INSIDE_BLOCK.
diff --git a/clippy_utils/src/attrs.rs b/clippy_utils/src/attrs.rs
index 49cb9718ef6..e4cc86f6800 100644
--- a/clippy_utils/src/attrs.rs
+++ b/clippy_utils/src/attrs.rs
@@ -143,13 +143,13 @@ pub fn get_unique_attr<'a>(
     unique_attr
 }
 
-/// Return true if the attributes contain any of `proc_macro`,
+/// Returns true if the attributes contain any of `proc_macro`,
 /// `proc_macro_derive` or `proc_macro_attribute`, false otherwise
 pub fn is_proc_macro(attrs: &[ast::Attribute]) -> bool {
     attrs.iter().any(rustc_ast::Attribute::is_proc_macro_attr)
 }
 
-/// Return true if the attributes contain `#[doc(hidden)]`
+/// Returns true if the attributes contain `#[doc(hidden)]`
 pub fn is_doc_hidden(attrs: &[ast::Attribute]) -> bool {
     attrs
         .iter()
diff --git a/clippy_utils/src/check_proc_macro.rs b/clippy_utils/src/check_proc_macro.rs
index c6d0b654f57..62792d60652 100644
--- a/clippy_utils/src/check_proc_macro.rs
+++ b/clippy_utils/src/check_proc_macro.rs
@@ -339,7 +339,7 @@ fn ty_search_pat(ty: &Ty<'_>) -> (Pat, Pat) {
         TyKind::Tup(..) => (Pat::Str("("), Pat::Str(")")),
         TyKind::OpaqueDef(..) => (Pat::Str("impl"), Pat::Str("")),
         TyKind::Path(qpath) => qpath_search_pat(&qpath),
-        // NOTE: This is missing `TraitObject`. It always return true then.
+        // NOTE: This is missing `TraitObject`. It will always return true then.
         _ => (Pat::Str(""), Pat::Str("")),
     }
 }
diff --git a/clippy_utils/src/comparisons.rs b/clippy_utils/src/comparisons.rs
index 7a18d5e818f..5e6bf227844 100644
--- a/clippy_utils/src/comparisons.rs
+++ b/clippy_utils/src/comparisons.rs
@@ -1,11 +1,11 @@
-//! Utility functions about comparison operators.
+//! Utility functions for comparison operators.
 
 #![deny(clippy::missing_docs_in_private_items)]
 
 use rustc_hir::{BinOpKind, Expr};
 
 #[derive(PartialEq, Eq, Debug, Copy, Clone)]
-/// Represent a normalized comparison operator.
+/// Represents a normalized comparison operator.
 pub enum Rel {
     /// `<`
     Lt,
diff --git a/clippy_utils/src/consts.rs b/clippy_utils/src/consts.rs
index 068820801df..87d85d742ce 100644
--- a/clippy_utils/src/consts.rs
+++ b/clippy_utils/src/consts.rs
@@ -267,7 +267,7 @@ pub fn constant_with_source<'tcx>(
     res.map(|x| (x, ctxt.source))
 }
 
-/// Attempts to evaluate an expression only if it's value is not dependent on other items.
+/// Attempts to evaluate an expression only if its value is not dependent on other items.
 pub fn constant_simple<'tcx>(
     lcx: &LateContext<'tcx>,
     typeck_results: &ty::TypeckResults<'tcx>,
diff --git a/clippy_utils/src/eager_or_lazy.rs b/clippy_utils/src/eager_or_lazy.rs
index 4a845ca63b4..eda739bceb5 100644
--- a/clippy_utils/src/eager_or_lazy.rs
+++ b/clippy_utils/src/eager_or_lazy.rs
@@ -1,7 +1,7 @@
 //! Utilities for evaluating whether eagerly evaluated expressions can be made lazy and vice versa.
 //!
 //! Things to consider:
-//!  - has the expression side-effects?
+//!  - does the expression have side-effects?
 //!  - is the expression computationally expensive?
 //!
 //! See lints:
diff --git a/clippy_utils/src/higher.rs b/clippy_utils/src/higher.rs
index a61e4c38088..357ac40b455 100644
--- a/clippy_utils/src/higher.rs
+++ b/clippy_utils/src/higher.rs
@@ -13,7 +13,7 @@ use rustc_lint::LateContext;
 use rustc_span::{sym, symbol, Span};
 
 /// The essential nodes of a desugared for loop as well as the entire span:
-/// `for pat in arg { body }` becomes `(pat, arg, body)`. Return `(pat, arg, body, span)`.
+/// `for pat in arg { body }` becomes `(pat, arg, body)`. Returns `(pat, arg, body, span)`.
 pub struct ForLoop<'tcx> {
     /// `for` loop item
     pub pat: &'tcx hir::Pat<'tcx>,
@@ -264,7 +264,7 @@ impl<'a> Range<'a> {
     }
 }
 
-/// Represent the pre-expansion arguments of a `vec!` invocation.
+/// Represents the pre-expansion arguments of a `vec!` invocation.
 pub enum VecArgs<'a> {
     /// `vec![elem; len]`
     Repeat(&'a hir::Expr<'a>, &'a hir::Expr<'a>),
@@ -398,7 +398,7 @@ impl<'hir> WhileLet<'hir> {
     }
 }
 
-/// Converts a hir binary operator to the corresponding `ast` type.
+/// Converts a `hir` binary operator to the corresponding `ast` type.
 #[must_use]
 pub fn binop(op: hir::BinOpKind) -> ast::BinOpKind {
     match op {
@@ -436,7 +436,7 @@ pub enum VecInitKind {
     WithExprCapacity(HirId),
 }
 
-/// Checks if given expression is an initialization of `Vec` and returns its kind.
+/// Checks if the given expression is an initialization of `Vec` and returns its kind.
 pub fn get_vec_init_kind<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> Option<VecInitKind> {
     if let ExprKind::Call(func, args) = expr.kind {
         match func.kind {
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 727b59f1f43..272228cebd0 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -823,7 +823,7 @@ fn is_default_equivalent_ctor(cx: &LateContext<'_>, def_id: DefId, path: &QPath<
     false
 }
 
-/// Return true if the expr is equal to `Default::default` when evaluated.
+/// Returns true if the expr is equal to `Default::default` when evaluated.
 pub fn is_default_equivalent_call(cx: &LateContext<'_>, repl_func: &Expr<'_>) -> bool {
     if_chain! {
         if let hir::ExprKind::Path(ref repl_func_qpath) = repl_func.kind;
@@ -2527,7 +2527,8 @@ pub fn span_contains_comment(sm: &SourceMap, span: Span) -> bool {
     });
 }
 
-/// Return all the comments a given span contains
+/// Returns all the comments a given span contains
+///
 /// Comments are returned wrapped with their relevant delimiters
 pub fn span_extract_comment(sm: &SourceMap, span: Span) -> String {
     let snippet = sm.span_to_snippet(span).unwrap_or_default();
diff --git a/clippy_utils/src/sugg.rs b/clippy_utils/src/sugg.rs
index cf781e18cd6..de3aad64757 100644
--- a/clippy_utils/src/sugg.rs
+++ b/clippy_utils/src/sugg.rs
@@ -395,7 +395,7 @@ fn binop_to_string(op: AssocOp, lhs: &str, rhs: &str) -> String {
     }
 }
 
-/// Return `true` if `sugg` is enclosed in parenthesis.
+/// Returns `true` if `sugg` is enclosed in parenthesis.
 pub fn has_enclosing_paren(sugg: impl AsRef<str>) -> bool {
     let mut chars = sugg.as_ref().chars();
     if chars.next() == Some('(') {
diff --git a/tests/ui/needless_else.stderr b/tests/ui/needless_else.stderr
index ea693085164..49cd78501ea 100644
--- a/tests/ui/needless_else.stderr
+++ b/tests/ui/needless_else.stderr
@@ -1,4 +1,4 @@
-error: this else branch is empty
+error: this `else` branch is empty
   --> $DIR/needless_else.rs:24:7
    |
 LL |       } else {
-- 
cgit 1.4.1-3-g733a5


From e29a5acf6f177e35ad00d7120fc3422ac94c3ac9 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Sun, 2 Jul 2023 14:17:34 +0000
Subject: let_and_return: lint 'static lifetimes, don't lint borrows in
 closures

---
 clippy_lints/src/returns.rs    |  6 ++---
 tests/ui/let_and_return.rs     | 61 ++++++++++++++++++++++--------------------
 tests/ui/let_and_return.stderr | 22 ++++++++++++---
 3 files changed, 53 insertions(+), 36 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
index 958351ad81b..ad0167a3d32 100644
--- a/clippy_lints/src/returns.rs
+++ b/clippy_lints/src/returns.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::{span_lint_and_then, span_lint_hir_and_then};
 use clippy_utils::source::{snippet_opt, snippet_with_context};
-use clippy_utils::visitors::{for_each_expr, Descend};
+use clippy_utils::visitors::{for_each_expr_with_closures, Descend};
 use clippy_utils::{fn_def_id, path_to_local_id, span_find_starting_semi};
 use core::ops::ControlFlow;
 use if_chain::if_chain;
@@ -328,7 +328,7 @@ fn emit_return_lint(cx: &LateContext<'_>, ret_span: Span, semi_spans: Vec<Span>,
 }
 
 fn last_statement_borrows<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
-    for_each_expr(expr, |e| {
+    for_each_expr_with_closures(cx, expr, |e| {
         if let Some(def_id) = fn_def_id(cx, e)
             && cx
                 .tcx
@@ -337,7 +337,7 @@ fn last_statement_borrows<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>)
                 .skip_binder()
                 .output()
                 .walk()
-                .any(|arg| matches!(arg.unpack(), GenericArgKind::Lifetime(_)))
+                .any(|arg| matches!(arg.unpack(), GenericArgKind::Lifetime(re) if !re.is_static()))
         {
             ControlFlow::Break(())
         } else {
diff --git a/tests/ui/let_and_return.rs b/tests/ui/let_and_return.rs
index bb162adc9ad..7e4d783a026 100644
--- a/tests/ui/let_and_return.rs
+++ b/tests/ui/let_and_return.rs
@@ -1,6 +1,8 @@
 #![allow(unused)]
 #![warn(clippy::let_and_return)]
 
+use std::cell::RefCell;
+
 fn test() -> i32 {
     let _y = 0; // no warning
     let x = 5;
@@ -65,45 +67,46 @@ macro_rules! tuple_encode {
     );
 }
 
+fn issue_3792() -> String {
+    use std::io::{self, BufRead, Stdin};
+
+    let stdin = io::stdin();
+    // `Stdin::lock` returns `StdinLock<'static>` so `line` doesn't borrow from `stdin`
+    // https://github.com/rust-lang/rust/pull/93965
+    let line = stdin.lock().lines().next().unwrap().unwrap();
+    line
+}
+
 tuple_encode!(T0, T1, T2, T3, T4, T5, T6, T7);
 
 mod no_lint_if_stmt_borrows {
-    mod issue_3792 {
-        use std::io::{self, BufRead, Stdin};
+    use std::cell::RefCell;
+    use std::rc::{Rc, Weak};
+    struct Bar;
 
-        fn read_line() -> String {
-            let stdin = io::stdin();
-            let line = stdin.lock().lines().next().unwrap().unwrap();
-            line
+    impl Bar {
+        fn new() -> Self {
+            Bar {}
         }
-    }
-
-    mod issue_3324 {
-        use std::cell::RefCell;
-        use std::rc::{Rc, Weak};
-
-        fn test(value: Weak<RefCell<Bar>>) -> u32 {
-            let value = value.upgrade().unwrap();
-            let ret = value.borrow().baz();
-            ret
+        fn baz(&self) -> u32 {
+            0
         }
+    }
 
-        struct Bar;
+    fn issue_3324(value: Weak<RefCell<Bar>>) -> u32 {
+        let value = value.upgrade().unwrap();
+        let ret = value.borrow().baz();
+        ret
+    }
 
-        impl Bar {
-            fn new() -> Self {
-                Bar {}
-            }
-            fn baz(&self) -> u32 {
-                0
-            }
+    fn borrows_in_closure(value: Weak<RefCell<Bar>>) -> u32 {
+        fn f(mut x: impl FnMut() -> u32) -> impl FnMut() -> u32 {
+            x
         }
 
-        fn main() {
-            let a = Rc::new(RefCell::new(Bar::new()));
-            let b = Rc::downgrade(&a);
-            test(b);
-        }
+        let value = value.upgrade().unwrap();
+        let ret = f(|| value.borrow().baz())();
+        ret
     }
 
     mod free_function {
diff --git a/tests/ui/let_and_return.stderr b/tests/ui/let_and_return.stderr
index 17fd694bf7a..4ca0a05c858 100644
--- a/tests/ui/let_and_return.stderr
+++ b/tests/ui/let_and_return.stderr
@@ -1,5 +1,5 @@
 error: returning the result of a `let` binding from a block
-  --> $DIR/let_and_return.rs:7:5
+  --> $DIR/let_and_return.rs:9:5
    |
 LL |     let x = 5;
    |     ---------- unnecessary `let` binding
@@ -14,7 +14,7 @@ LL ~     5
    |
 
 error: returning the result of a `let` binding from a block
-  --> $DIR/let_and_return.rs:13:9
+  --> $DIR/let_and_return.rs:15:9
    |
 LL |         let x = 5;
    |         ---------- unnecessary `let` binding
@@ -28,7 +28,21 @@ LL ~         5
    |
 
 error: returning the result of a `let` binding from a block
-  --> $DIR/let_and_return.rs:164:13
+  --> $DIR/let_and_return.rs:77:5
+   |
+LL |     let line = stdin.lock().lines().next().unwrap().unwrap();
+   |     --------------------------------------------------------- unnecessary `let` binding
+LL |     line
+   |     ^^^^
+   |
+help: return the expression directly
+   |
+LL ~     
+LL ~     stdin.lock().lines().next().unwrap().unwrap()
+   |
+
+error: returning the result of a `let` binding from a block
+  --> $DIR/let_and_return.rs:167:13
    |
 LL |             let clone = Arc::clone(&self.foo);
    |             ---------------------------------- unnecessary `let` binding
@@ -41,5 +55,5 @@ LL ~
 LL ~             Arc::clone(&self.foo) as _
    |
 
-error: aborting due to 3 previous errors
+error: aborting due to 4 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 555ceb83fefc937e03bade598b608b76700234cb Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Sun, 2 Jul 2023 21:42:39 +0200
Subject: [`missing_fields_in_debug`]: make sure `self` is an adt

---
 clippy_lints/src/missing_fields_in_debug.rs | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/missing_fields_in_debug.rs b/clippy_lints/src/missing_fields_in_debug.rs
index 1138d1163a4..497514fbcd6 100644
--- a/clippy_lints/src/missing_fields_in_debug.rs
+++ b/clippy_lints/src/missing_fields_in_debug.rs
@@ -207,11 +207,10 @@ impl<'tcx> LateLintPass<'tcx> for MissingFieldsInDebug {
         if let ItemKind::Impl(Impl { of_trait: Some(trait_ref), self_ty, items, .. }) = item.kind
             && let Res::Def(DefKind::Trait, trait_def_id) = trait_ref.path.res
             && let TyKind::Path(QPath::Resolved(_, self_path)) = &self_ty.kind
-            // don't trigger if self is a generic parameter, e.g. `impl<T> Debug for T`
-            // this can only happen in core itself, where the trait is defined,
-            // but it caused ICEs in the past:
-            // https://github.com/rust-lang/rust-clippy/issues/10887
-            && !matches!(self_path.res, Res::Def(DefKind::TyParam, _))
+            // make sure that the self type is either a struct, an enum or a union
+            // this prevents ICEs such as when self is a type parameter or a primitive type
+            // (see #10887, #11063)
+            && let Res::Def(DefKind::Struct | DefKind::Enum | DefKind::Union, self_path_did) = self_path.res
             && cx.match_def_path(trait_def_id, &[sym::core, sym::fmt, sym::Debug])
             // don't trigger if this impl was derived
             && !cx.tcx.has_attr(item.owner_id, sym::automatically_derived)
@@ -222,7 +221,7 @@ impl<'tcx> LateLintPass<'tcx> for MissingFieldsInDebug {
             && let body = cx.tcx.hir().body(*body_id)
             && let ExprKind::Block(block, _) = body.value.kind
             // inspect `self`
-            && let self_ty = cx.tcx.type_of(self_path.res.def_id()).skip_binder().peel_refs()
+            && let self_ty = cx.tcx.type_of(self_path_did).skip_binder().peel_refs()
             && let Some(self_adt) = self_ty.ty_adt_def()
             && let Some(self_def_id) = self_adt.did().as_local()
             && let Some(Node::Item(self_item)) = cx.tcx.hir().find_by_def_id(self_def_id)
-- 
cgit 1.4.1-3-g733a5


From 6990eaa9720e45b3b09eb00d9476b89839935c10 Mon Sep 17 00:00:00 2001
From: est31 <MTest31@outlook.com>
Date: Sun, 2 Jul 2023 04:03:20 +0200
Subject: Don't suppress manual_let_else if question_mark is allowed

If question_mark is allowed, there is no overlap any more,
so we can just not suppress it.
---
 clippy_lints/src/manual_let_else.rs           | 20 ++++++++++----------
 tests/ui/manual_let_else_question_mark.fixed  |  7 +++++++
 tests/ui/manual_let_else_question_mark.rs     |  7 +++++++
 tests/ui/manual_let_else_question_mark.stderr |  8 +++++++-
 4 files changed, 31 insertions(+), 11 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_let_else.rs b/clippy_lints/src/manual_let_else.rs
index 363018f1381..18739e9d8e2 100644
--- a/clippy_lints/src/manual_let_else.rs
+++ b/clippy_lints/src/manual_let_else.rs
@@ -1,12 +1,10 @@
-use crate::question_mark::{pat_and_expr_can_be_question_mark, QuestionMark};
+use crate::question_mark::{pat_and_expr_can_be_question_mark, QuestionMark, QUESTION_MARK};
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::higher::IfLetOrMatch;
-use clippy_utils::msrvs;
-use clippy_utils::peel_blocks;
 use clippy_utils::source::snippet_with_context;
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::visitors::{Descend, Visitable};
-use if_chain::if_chain;
+use clippy_utils::{is_lint_allowed, msrvs, peel_blocks};
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_expr, Visitor};
@@ -65,12 +63,14 @@ impl<'tcx> QuestionMark {
             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 let Some(ident_map) = expr_simple_identity_map(local.pat, let_pat, if_then);
-                    if let Some(if_else) = if_else;
-                    if expr_diverges(cx, if_else);
-                    if pat_and_expr_can_be_question_mark(cx, let_pat, if_else).is_none();
-                    then {
+                IfLetOrMatch::IfLet(if_let_expr, let_pat, if_then, if_else) => {
+                    if
+                        let Some(ident_map) = expr_simple_identity_map(local.pat, let_pat, if_then) &&
+                        let Some(if_else) = if_else &&
+                        expr_diverges(cx, if_else) &&
+                        let qm_allowed = is_lint_allowed(cx, QUESTION_MARK, stmt.hir_id) &&
+                        (qm_allowed || pat_and_expr_can_be_question_mark(cx, let_pat, if_else).is_none())
+                    {
                         emit_manual_let_else(cx, stmt.span, if_let_expr, &ident_map, let_pat, if_else);
                     }
                 },
diff --git a/tests/ui/manual_let_else_question_mark.fixed b/tests/ui/manual_let_else_question_mark.fixed
index 617f127b9a8..02308bc7c4c 100644
--- a/tests/ui/manual_let_else_question_mark.fixed
+++ b/tests/ui/manual_let_else_question_mark.fixed
@@ -52,5 +52,12 @@ fn foo() -> Option<()> {
         let Some(v) = g() else { return None };
     }
 
+    // This is a copy of the case above where we'd fire the question_mark lint, but here we have allowed
+    // it. Make sure that manual_let_else is fired as the fallback.
+    #[allow(clippy::question_mark)]
+    {
+        let Some(v) = g() else { return None };
+    }
+
     Some(())
 }
diff --git a/tests/ui/manual_let_else_question_mark.rs b/tests/ui/manual_let_else_question_mark.rs
index 3cf1eca8673..9c7ad386dc9 100644
--- a/tests/ui/manual_let_else_question_mark.rs
+++ b/tests/ui/manual_let_else_question_mark.rs
@@ -57,5 +57,12 @@ fn foo() -> Option<()> {
         };
     }
 
+    // This is a copy of the case above where we'd fire the question_mark lint, but here we have allowed
+    // it. Make sure that manual_let_else is fired as the fallback.
+    #[allow(clippy::question_mark)]
+    {
+        let v = if let Some(v_some) = g() { v_some } else { return None };
+    }
+
     Some(())
 }
diff --git a/tests/ui/manual_let_else_question_mark.stderr b/tests/ui/manual_let_else_question_mark.stderr
index 31052acf75c..d7d2e127ea3 100644
--- a/tests/ui/manual_let_else_question_mark.stderr
+++ b/tests/ui/manual_let_else_question_mark.stderr
@@ -45,5 +45,11 @@ LL | |             _ => return None,
 LL | |         };
    | |__________^ help: consider writing: `let Some(v) = g() else { return None };`
 
-error: aborting due to 5 previous errors
+error: this could be rewritten as `let...else`
+  --> $DIR/manual_let_else_question_mark.rs:64:9
+   |
+LL |         let v = if let Some(v_some) = g() { v_some } else { return None };
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let Some(v) = g() else { return None };`
+
+error: aborting due to 6 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From d80581c7d2db05a899e3363c8fc937012311de69 Mon Sep 17 00:00:00 2001
From: est31 <MTest31@outlook.com>
Date: Mon, 3 Jul 2023 09:42:43 +0200
Subject: Move pat_and_expr_can_be_question_mark into clippy_utils

---
 clippy_lints/src/manual_let_else.rs |  4 +--
 clippy_lints/src/question_mark.rs   | 50 +++----------------------------------
 clippy_utils/src/lib.rs             | 45 +++++++++++++++++++++++++++++++++
 3 files changed, 50 insertions(+), 49 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_let_else.rs b/clippy_lints/src/manual_let_else.rs
index 18739e9d8e2..ade85e23bd3 100644
--- a/clippy_lints/src/manual_let_else.rs
+++ b/clippy_lints/src/manual_let_else.rs
@@ -1,10 +1,10 @@
-use crate::question_mark::{pat_and_expr_can_be_question_mark, QuestionMark, QUESTION_MARK};
+use crate::question_mark::{QuestionMark, QUESTION_MARK};
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::higher::IfLetOrMatch;
 use clippy_utils::source::snippet_with_context;
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::visitors::{Descend, Visitable};
-use clippy_utils::{is_lint_allowed, msrvs, peel_blocks};
+use clippy_utils::{is_lint_allowed, msrvs, pat_and_expr_can_be_question_mark, peel_blocks};
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_expr, Visitor};
diff --git a/clippy_lints/src/question_mark.rs b/clippy_lints/src/question_mark.rs
index d473b6fd5c4..9840d464b75 100644
--- a/clippy_lints/src/question_mark.rs
+++ b/clippy_lints/src/question_mark.rs
@@ -4,8 +4,8 @@ use clippy_utils::msrvs::Msrv;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::{
-    eq_expr_value, get_parent_node, in_constant, is_else_clause, is_refutable, is_res_lang_ctor, path_to_local,
-    path_to_local_id, peel_blocks, peel_blocks_with_stmt,
+    eq_expr_value, get_parent_node, in_constant, is_else_clause, is_res_lang_ctor, pat_and_expr_can_be_question_mark,
+    path_to_local, path_to_local_id, peel_blocks, peel_blocks_with_stmt,
 };
 use clippy_utils::{higher, is_path_lang_item};
 use if_chain::if_chain;
@@ -13,7 +13,7 @@ use rustc_errors::Applicability;
 use rustc_hir::def::Res;
 use rustc_hir::LangItem::{self, OptionNone, OptionSome, ResultErr, ResultOk};
 use rustc_hir::{
-    BindingAnnotation, Block, ByRef, Expr, ExprKind, Local, Node, Pat, PatKind, PathSegment, QPath, Stmt, StmtKind,
+    BindingAnnotation, Block, ByRef, Expr, ExprKind, Local, Node, PatKind, PathSegment, QPath, Stmt, StmtKind,
 };
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::Ty;
@@ -95,50 +95,6 @@ enum IfBlockType<'hir> {
     ),
 }
 
-/// Returns whether the given let pattern and else body can be turned into a question mark
-///
-/// For this example:
-/// ```ignore
-/// let FooBar { a, b } = if let Some(a) = ex { a } else { return None };
-/// ```
-/// We get as parameters:
-/// ```ignore
-/// pat: Some(a)
-/// else_body: return None
-/// ```
-
-/// And for this example:
-/// ```ignore
-/// let Some(FooBar { a, b }) = ex else { return None };
-/// ```
-/// We get as parameters:
-/// ```ignore
-/// pat: Some(FooBar { a, b })
-/// else_body: return None
-/// ```
-
-/// We output `Some(a)` in the first instance, and `Some(FooBar { a, b })` in the second, because
-/// the question mark operator is applicable here. Callers have to check whether we are in a
-/// constant or not.
-pub(crate) fn pat_and_expr_can_be_question_mark<'a, 'hir>(
-    cx: &LateContext<'_>,
-    pat: &'a Pat<'hir>,
-    else_body: &Expr<'_>,
-) -> Option<&'a Pat<'hir>> {
-    if let PatKind::TupleStruct(pat_path, [inner_pat], _) = pat.kind &&
-        is_res_lang_ctor(cx, cx.qpath_res(&pat_path, pat.hir_id), OptionSome) &&
-        !is_refutable(cx, inner_pat) &&
-        let else_body = peel_blocks(else_body) &&
-        let ExprKind::Ret(Some(ret_val)) = else_body.kind &&
-        let ExprKind::Path(ret_path) = ret_val.kind &&
-        is_res_lang_ctor(cx, cx.qpath_res(&ret_path, ret_val.hir_id), OptionNone)
-    {
-        Some(inner_pat)
-    } else {
-        None
-    }
-}
-
 fn check_let_some_else_return_none(cx: &LateContext<'_>, stmt: &Stmt<'_>) {
     if let StmtKind::Local(Local { pat, init: Some(init_expr), els: Some(els), .. }) = stmt.kind &&
         let Block { stmts: &[], expr: Some(els), .. } = els &&
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 727b59f1f43..02ab1b31e72 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -87,6 +87,7 @@ use rustc_hir::def::{DefKind, Res};
 use rustc_hir::def_id::{CrateNum, DefId, LocalDefId, LOCAL_CRATE};
 use rustc_hir::hir_id::{HirIdMap, HirIdSet};
 use rustc_hir::intravisit::{walk_expr, FnKind, Visitor};
+use rustc_hir::LangItem::OptionSome;
 use rustc_hir::LangItem::{OptionNone, ResultErr, ResultOk};
 use rustc_hir::{
     self as hir, def, Arm, ArrayLen, BindingAnnotation, Block, BlockCheckMode, Body, Closure, Destination, Expr,
@@ -2542,6 +2543,50 @@ pub fn span_find_starting_semi(sm: &SourceMap, span: Span) -> Span {
     sm.span_take_while(span, |&ch| ch == ' ' || ch == ';')
 }
 
+/// Returns whether the given let pattern and else body can be turned into a question mark
+///
+/// For this example:
+/// ```ignore
+/// let FooBar { a, b } = if let Some(a) = ex { a } else { return None };
+/// ```
+/// We get as parameters:
+/// ```ignore
+/// pat: Some(a)
+/// else_body: return None
+/// ```
+
+/// And for this example:
+/// ```ignore
+/// let Some(FooBar { a, b }) = ex else { return None };
+/// ```
+/// We get as parameters:
+/// ```ignore
+/// pat: Some(FooBar { a, b })
+/// else_body: return None
+/// ```
+
+/// We output `Some(a)` in the first instance, and `Some(FooBar { a, b })` in the second, because
+/// the question mark operator is applicable here. Callers have to check whether we are in a
+/// constant or not.
+pub fn pat_and_expr_can_be_question_mark<'a, 'hir>(
+    cx: &LateContext<'_>,
+    pat: &'a Pat<'hir>,
+    else_body: &Expr<'_>,
+) -> Option<&'a Pat<'hir>> {
+    if let PatKind::TupleStruct(pat_path, [inner_pat], _) = pat.kind &&
+        is_res_lang_ctor(cx, cx.qpath_res(&pat_path, pat.hir_id), OptionSome) &&
+        !is_refutable(cx, inner_pat) &&
+        let else_body = peel_blocks(else_body) &&
+        let ExprKind::Ret(Some(ret_val)) = else_body.kind &&
+        let ExprKind::Path(ret_path) = ret_val.kind &&
+        is_res_lang_ctor(cx, cx.qpath_res(&ret_path, ret_val.hir_id), OptionNone)
+    {
+        Some(inner_pat)
+    } else {
+        None
+    }
+}
+
 macro_rules! op_utils {
     ($($name:ident $assign:ident)*) => {
         /// Binary operation traits like `LangItem::Add`
-- 
cgit 1.4.1-3-g733a5


From 75c339cd0ad7c38f8d258a369570400eae933973 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Mon, 3 Jul 2023 11:34:02 +0200
Subject: [`arc_with_non_send_sync`]: look for nested type parameters

---
 clippy_lints/src/arc_with_non_send_sync.rs | 6 +++++-
 tests/ui/arc_with_non_send_sync.rs         | 3 +++
 tests/ui/arc_with_non_send_sync.stderr     | 2 +-
 3 files changed, 9 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/arc_with_non_send_sync.rs b/clippy_lints/src/arc_with_non_send_sync.rs
index a1e44668e1a..62313df9f90 100644
--- a/clippy_lints/src/arc_with_non_send_sync.rs
+++ b/clippy_lints/src/arc_with_non_send_sync.rs
@@ -7,6 +7,7 @@ use rustc_hir::{Expr, ExprKind};
 use rustc_lint::LateContext;
 use rustc_lint::LateLintPass;
 use rustc_middle::ty;
+use rustc_middle::ty::GenericArgKind;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::symbol::sym;
 
@@ -47,7 +48,10 @@ impl LateLintPass<'_> for ArcWithNonSendSync {
             if let ExprKind::Path(func_path) = func.kind;
             if last_path_segment(&func_path).ident.name == sym::new;
             if let arg_ty = cx.typeck_results().expr_ty(arg);
-            if !matches!(arg_ty.kind(), ty::Param(_));
+            // make sure that the type is not and does not contain any type parameters
+            if arg_ty.walk().all(|arg| {
+                !matches!(arg.unpack(), GenericArgKind::Type(ty) if matches!(ty.kind(), ty::Param(_)))
+            });
             if !cx.tcx
                 .lang_items()
                 .sync_trait()
diff --git a/tests/ui/arc_with_non_send_sync.rs b/tests/ui/arc_with_non_send_sync.rs
index ac786f68c12..9d5849277c2 100644
--- a/tests/ui/arc_with_non_send_sync.rs
+++ b/tests/ui/arc_with_non_send_sync.rs
@@ -7,6 +7,9 @@ fn foo<T>(x: T) {
     // Should not lint - purposefully ignoring generic args.
     let a = Arc::new(x);
 }
+fn issue11076<T>() {
+    let a: Arc<Vec<T>> = Arc::new(Vec::new());
+}
 
 fn main() {
     // This is safe, as `i32` implements `Send` and `Sync`.
diff --git a/tests/ui/arc_with_non_send_sync.stderr b/tests/ui/arc_with_non_send_sync.stderr
index fc2fc5f93b1..520c21b565b 100644
--- a/tests/ui/arc_with_non_send_sync.stderr
+++ b/tests/ui/arc_with_non_send_sync.stderr
@@ -1,5 +1,5 @@
 error: usage of `Arc<T>` where `T` is not `Send` or `Sync`
-  --> $DIR/arc_with_non_send_sync.rs:16:13
+  --> $DIR/arc_with_non_send_sync.rs:19:13
    |
 LL |     let b = Arc::new(RefCell::new(42));
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From 9a581077d41dcc9a751a30cdfeca17464d5a7be2 Mon Sep 17 00:00:00 2001
From: Catherine <114838443+Centri3@users.noreply.github.com>
Date: Mon, 3 Jul 2023 06:35:04 -0500
Subject: Fix FP [`needless_raw_string_hashes`]

---
 clippy_lints/src/raw_strings.rs           | 2 +-
 tests/ui/needless_raw_string_hashes.fixed | 4 ++++
 tests/ui/needless_raw_string_hashes.rs    | 4 ++++
 3 files changed, 9 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/raw_strings.rs b/clippy_lints/src/raw_strings.rs
index f45bb1ef3e1..0e964ec4724 100644
--- a/clippy_lints/src/raw_strings.rs
+++ b/clippy_lints/src/raw_strings.rs
@@ -95,7 +95,7 @@ impl EarlyLintPass for RawStrings {
                 // `once` so a raw string ending in hashes is still checked
                 let num = str.as_bytes().iter().chain(once(&0)).try_fold(0u8, |acc, &b| {
                     match b {
-                        b'"' => (following_quote, req) = (true, 1),
+                        b'"' if !following_quote => (following_quote, req) = (true, 1),
                         // I'm a bit surprised the compiler didn't optimize this out, there's no
                         // branch but it still ends up doing an unnecessary comparison, it's:
                         // - cmp r9b,1h
diff --git a/tests/ui/needless_raw_string_hashes.fixed b/tests/ui/needless_raw_string_hashes.fixed
index e4d7d8fb017..a9a6282628e 100644
--- a/tests/ui/needless_raw_string_hashes.fixed
+++ b/tests/ui/needless_raw_string_hashes.fixed
@@ -16,4 +16,8 @@ fn main() {
     cr#"Hello "world"!"#;
     cr####" "### "## "# "####;
     cr###" "aa" "# "## "###;
+    // Issue #11068, do not lint
+    r##"a"#"a"##;
+    br##"a"#"a"##;
+    cr##"a"#"a"##;
 }
diff --git a/tests/ui/needless_raw_string_hashes.rs b/tests/ui/needless_raw_string_hashes.rs
index e2d85c52e78..baa97d86470 100644
--- a/tests/ui/needless_raw_string_hashes.rs
+++ b/tests/ui/needless_raw_string_hashes.rs
@@ -16,4 +16,8 @@ fn main() {
     cr##"Hello "world"!"##;
     cr######" "### "## "# "######;
     cr######" "aa" "# "## "######;
+    // Issue #11068, do not lint
+    r##"a"#"a"##;
+    br##"a"#"a"##;
+    cr##"a"#"a"##;
 }
-- 
cgit 1.4.1-3-g733a5


From 1f77f8cc3cca968d47d15c9e621d48f0193f8ab1 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Mon, 3 Jul 2023 13:40:33 +0200
Subject: [`useless_vec`]: use the source span

---
 clippy_lints/src/vec.rs |  2 +-
 tests/ui/vec.fixed      | 11 +++++++++++
 tests/ui/vec.rs         | 11 +++++++++++
 tests/ui/vec.stderr     | 12 +++++++++---
 4 files changed, 32 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/vec.rs b/clippy_lints/src/vec.rs
index 2a594e750b9..ca0daa9ecee 100644
--- a/clippy_lints/src/vec.rs
+++ b/clippy_lints/src/vec.rs
@@ -181,7 +181,7 @@ impl UselessVec {
                     if args.len() as u64 * size_of(cx, last) > self.too_large_for_stack {
                         return;
                     }
-                    let span = args[0].span.to(last.span);
+                    let span = args[0].span.source_callsite().to(last.span.source_callsite());
                     let args = snippet_with_applicability(cx, span, "..", &mut applicability);
 
                     match suggest_slice {
diff --git a/tests/ui/vec.fixed b/tests/ui/vec.fixed
index fcdc917c1b1..14ab8bd8897 100644
--- a/tests/ui/vec.fixed
+++ b/tests/ui/vec.fixed
@@ -115,6 +115,17 @@ fn main() {
     let _x = vec![1; 201];
 }
 
+fn issue11075() {
+    macro_rules! repro {
+        ($e:expr) => {
+            stringify!($e)
+        };
+    }
+    for _string in [repro!(true), repro!(null)] {
+        unimplemented!();
+    }
+}
+
 #[clippy::msrv = "1.53"]
 fn above() {
     for a in [1, 2, 3] {
diff --git a/tests/ui/vec.rs b/tests/ui/vec.rs
index 0404d8cdb84..e57cb4374e3 100644
--- a/tests/ui/vec.rs
+++ b/tests/ui/vec.rs
@@ -115,6 +115,17 @@ fn main() {
     let _x = vec![1; 201];
 }
 
+fn issue11075() {
+    macro_rules! repro {
+        ($e:expr) => {
+            stringify!($e)
+        };
+    }
+    for _string in vec![repro!(true), repro!(null)] {
+        unimplemented!();
+    }
+}
+
 #[clippy::msrv = "1.53"]
 fn above() {
     for a in vec![1, 2, 3] {
diff --git a/tests/ui/vec.stderr b/tests/ui/vec.stderr
index 33d565b2d52..1b82d5cbea8 100644
--- a/tests/ui/vec.stderr
+++ b/tests/ui/vec.stderr
@@ -85,16 +85,22 @@ LL |     for _ in vec![1, 2, 3] {}
    |              ^^^^^^^^^^^^^ help: you can use an array directly: `[1, 2, 3]`
 
 error: useless use of `vec!`
-  --> $DIR/vec.rs:120:14
+  --> $DIR/vec.rs:124:20
+   |
+LL |     for _string in vec![repro!(true), repro!(null)] {
+   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: you can use an array directly: `[repro!(true), repro!(null)]`
+
+error: useless use of `vec!`
+  --> $DIR/vec.rs:131:14
    |
 LL |     for a in vec![1, 2, 3] {
    |              ^^^^^^^^^^^^^ help: you can use an array directly: `[1, 2, 3]`
 
 error: useless use of `vec!`
-  --> $DIR/vec.rs:124:14
+  --> $DIR/vec.rs:135:14
    |
 LL |     for a in vec![String::new(), String::new()] {
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: you can use an array directly: `[String::new(), String::new()]`
 
-error: aborting due to 16 previous errors
+error: aborting due to 17 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From b4549c50b599929ec47ff4e9d880c27654342bb9 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Mon, 3 Jul 2023 18:13:01 +0200
Subject: [`useless_vec`]: add more tests for macro combinations

---
 clippy_lints/src/vec.rs |  4 ++++
 tests/ui/vec.fixed      | 29 +++++++++++++++++++++++++++++
 tests/ui/vec.rs         | 29 +++++++++++++++++++++++++++++
 tests/ui/vec.stderr     | 18 +++++++++++++++---
 4 files changed, 77 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/vec.rs b/clippy_lints/src/vec.rs
index ca0daa9ecee..6a96114ae76 100644
--- a/clippy_lints/src/vec.rs
+++ b/clippy_lints/src/vec.rs
@@ -154,6 +154,10 @@ impl UselessVec {
         span: Span,
         suggest_slice: SuggestedType,
     ) {
+        if span.from_expansion() {
+            return;
+        }
+
         let mut applicability = Applicability::MachineApplicable;
 
         let snippet = match *vec_args {
diff --git a/tests/ui/vec.fixed b/tests/ui/vec.fixed
index 14ab8bd8897..7a7d0026f79 100644
--- a/tests/ui/vec.fixed
+++ b/tests/ui/vec.fixed
@@ -124,6 +124,35 @@ fn issue11075() {
     for _string in [repro!(true), repro!(null)] {
         unimplemented!();
     }
+
+    macro_rules! in_macro {
+        ($e:expr, $vec:expr, $vec2:expr) => {{
+            vec![1; 2].fill(3);
+            vec![1, 2].fill(3);
+            for _ in vec![1, 2] {}
+            for _ in vec![1; 2] {}
+            for _ in vec![$e, $e] {}
+            for _ in vec![$e; 2] {}
+            for _ in $vec {}
+            for _ in $vec2 {}
+        }};
+    }
+
+    in_macro!(1, [1, 2], [1; 2]);
+
+    macro_rules! from_macro {
+        () => {
+            vec![1, 2, 3]
+        };
+    }
+    macro_rules! from_macro_repeat {
+        () => {
+            vec![1; 3]
+        };
+    }
+
+    for _ in from_macro!() {}
+    for _ in from_macro_repeat!() {}
 }
 
 #[clippy::msrv = "1.53"]
diff --git a/tests/ui/vec.rs b/tests/ui/vec.rs
index e57cb4374e3..cbe7685b453 100644
--- a/tests/ui/vec.rs
+++ b/tests/ui/vec.rs
@@ -124,6 +124,35 @@ fn issue11075() {
     for _string in vec![repro!(true), repro!(null)] {
         unimplemented!();
     }
+
+    macro_rules! in_macro {
+        ($e:expr, $vec:expr, $vec2:expr) => {{
+            vec![1; 2].fill(3);
+            vec![1, 2].fill(3);
+            for _ in vec![1, 2] {}
+            for _ in vec![1; 2] {}
+            for _ in vec![$e, $e] {}
+            for _ in vec![$e; 2] {}
+            for _ in $vec {}
+            for _ in $vec2 {}
+        }};
+    }
+
+    in_macro!(1, vec![1, 2], vec![1; 2]);
+
+    macro_rules! from_macro {
+        () => {
+            vec![1, 2, 3]
+        };
+    }
+    macro_rules! from_macro_repeat {
+        () => {
+            vec![1; 3]
+        };
+    }
+
+    for _ in from_macro!() {}
+    for _ in from_macro_repeat!() {}
 }
 
 #[clippy::msrv = "1.53"]
diff --git a/tests/ui/vec.stderr b/tests/ui/vec.stderr
index 1b82d5cbea8..8f6d2a1df80 100644
--- a/tests/ui/vec.stderr
+++ b/tests/ui/vec.stderr
@@ -91,16 +91,28 @@ LL |     for _string in vec![repro!(true), repro!(null)] {
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: you can use an array directly: `[repro!(true), repro!(null)]`
 
 error: useless use of `vec!`
-  --> $DIR/vec.rs:131:14
+  --> $DIR/vec.rs:141:18
+   |
+LL |     in_macro!(1, vec![1, 2], vec![1; 2]);
+   |                  ^^^^^^^^^^ help: you can use an array directly: `[1, 2]`
+
+error: useless use of `vec!`
+  --> $DIR/vec.rs:141:30
+   |
+LL |     in_macro!(1, vec![1, 2], vec![1; 2]);
+   |                              ^^^^^^^^^^ help: you can use an array directly: `[1; 2]`
+
+error: useless use of `vec!`
+  --> $DIR/vec.rs:160:14
    |
 LL |     for a in vec![1, 2, 3] {
    |              ^^^^^^^^^^^^^ help: you can use an array directly: `[1, 2, 3]`
 
 error: useless use of `vec!`
-  --> $DIR/vec.rs:135:14
+  --> $DIR/vec.rs:164:14
    |
 LL |     for a in vec![String::new(), String::new()] {
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: you can use an array directly: `[String::new(), String::new()]`
 
-error: aborting due to 17 previous errors
+error: aborting due to 19 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From b41fc6784fc723ea52da0e0668fc5205b740f81a Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Tue, 6 Jun 2023 19:27:12 +0200
Subject: Add needless_pass_by_ref lint

---
 CHANGELOG.md                                 |   1 +
 clippy_lints/src/declared_lints.rs           |   1 +
 clippy_lints/src/lib.rs                      |   2 +
 clippy_lints/src/needless_pass_by_ref_mut.rs | 238 +++++++++++++++++++++++++++
 clippy_lints/src/needless_pass_by_value.rs   |   2 +-
 5 files changed, 243 insertions(+), 1 deletion(-)
 create mode 100644 clippy_lints/src/needless_pass_by_ref_mut.rs

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index f9310b4ab31..762efed5c12 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5047,6 +5047,7 @@ Released 2018-09-13
 [`needless_option_as_deref`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_option_as_deref
 [`needless_option_take`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_option_take
 [`needless_parens_on_range_literals`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_parens_on_range_literals
+[`needless_pass_by_ref_mut`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_pass_by_ref_mut
 [`needless_pass_by_value`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_pass_by_value
 [`needless_pub_self`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_pub_self
 [`needless_question_mark`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_question_mark
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index e1dbe500396..4f945ebc610 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -470,6 +470,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::needless_if::NEEDLESS_IF_INFO,
     crate::needless_late_init::NEEDLESS_LATE_INIT_INFO,
     crate::needless_parens_on_range_literals::NEEDLESS_PARENS_ON_RANGE_LITERALS_INFO,
+    crate::needless_pass_by_ref_mut::NEEDLESS_PASS_BY_REF_MUT_INFO,
     crate::needless_pass_by_value::NEEDLESS_PASS_BY_VALUE_INFO,
     crate::needless_question_mark::NEEDLESS_QUESTION_MARK_INFO,
     crate::needless_update::NEEDLESS_UPDATE_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index c43e0b753dc..e1e4a83b031 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -229,6 +229,7 @@ mod needless_for_each;
 mod needless_if;
 mod needless_late_init;
 mod needless_parens_on_range_literals;
+mod needless_pass_by_ref_mut;
 mod needless_pass_by_value;
 mod needless_question_mark;
 mod needless_update;
@@ -1057,6 +1058,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     let stack_size_threshold = conf.stack_size_threshold;
     store.register_late_pass(move |_| Box::new(large_stack_frames::LargeStackFrames::new(stack_size_threshold)));
     store.register_late_pass(|_| Box::new(single_range_in_vec_init::SingleRangeInVecInit));
+    store.register_late_pass(|_| Box::new(needless_pass_by_ref_mut::NeedlessPassByRefMut));
     store.register_late_pass(|_| Box::new(incorrect_impls::IncorrectImpls));
     store.register_late_pass(move |_| {
         Box::new(single_call_fn::SingleCallFn {
diff --git a/clippy_lints/src/needless_pass_by_ref_mut.rs b/clippy_lints/src/needless_pass_by_ref_mut.rs
new file mode 100644
index 00000000000..c5dc87cdfa8
--- /dev/null
+++ b/clippy_lints/src/needless_pass_by_ref_mut.rs
@@ -0,0 +1,238 @@
+use super::needless_pass_by_value::requires_exact_signature;
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet;
+use clippy_utils::{is_from_proc_macro, is_self};
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir::intravisit::FnKind;
+use rustc_hir::{Body, FnDecl, HirId, Impl, ItemKind, Mutability, Node, PatKind};
+use rustc_hir::{HirIdMap, HirIdSet};
+use rustc_hir_typeck::expr_use_visitor as euv;
+use rustc_infer::infer::TyCtxtInferExt;
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::mir::FakeReadCause;
+use rustc_middle::ty::{self, Ty};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::def_id::LocalDefId;
+use rustc_span::symbol::kw;
+use rustc_span::Span;
+use rustc_target::spec::abi::Abi;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Check if a `&mut` function argument is actually used mutably.
+    ///
+    /// ### Why is this bad?
+    /// Less `mut` means less fights with the borrow checker. It can also lead to more
+    /// opportunities for parallelization.
+    ///
+    /// ### Example
+    /// ```rust
+    /// fn foo(y: &mut i32) -> i32 {
+    ///     12 + *y
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// fn foo(y: &i32) -> i32 {
+    ///     12 + *y
+    /// }
+    /// ```
+    #[clippy::version = "1.72.0"]
+    pub NEEDLESS_PASS_BY_REF_MUT,
+    suspicious,
+    "using a `&mut` argument when it's not mutated"
+}
+declare_lint_pass!(NeedlessPassByRefMut => [NEEDLESS_PASS_BY_REF_MUT]);
+
+fn should_skip<'tcx>(
+    cx: &LateContext<'tcx>,
+    input: rustc_hir::Ty<'tcx>,
+    ty: Ty<'_>,
+    arg: &rustc_hir::Param<'_>,
+) -> bool {
+    // We check if this a `&mut`. `ref_mutability` returns `None` if it's not a reference.
+    if !matches!(ty.ref_mutability(), Some(Mutability::Mut)) {
+        return true;
+    }
+
+    if is_self(arg) {
+        return true;
+    }
+
+    if let PatKind::Binding(.., name, _) = arg.pat.kind {
+        // If it's a potentially unused variable, we don't check it.
+        if name.name == kw::Underscore || name.as_str().starts_with('_') {
+            return true;
+        }
+    }
+
+    // All spans generated from a proc-macro invocation are the same...
+    is_from_proc_macro(cx, &input)
+}
+
+impl<'tcx> LateLintPass<'tcx> for NeedlessPassByRefMut {
+    fn check_fn(
+        &mut self,
+        cx: &LateContext<'tcx>,
+        kind: FnKind<'tcx>,
+        decl: &'tcx FnDecl<'_>,
+        body: &'tcx Body<'_>,
+        span: Span,
+        fn_def_id: LocalDefId,
+    ) {
+        if span.from_expansion() {
+            return;
+        }
+
+        let hir_id = cx.tcx.hir().local_def_id_to_hir_id(fn_def_id);
+
+        match kind {
+            FnKind::ItemFn(.., header) => {
+                let attrs = cx.tcx.hir().attrs(hir_id);
+                if header.abi != Abi::Rust || requires_exact_signature(attrs) {
+                    return;
+                }
+            },
+            FnKind::Method(..) => (),
+            FnKind::Closure => return,
+        }
+
+        // Exclude non-inherent impls
+        if let Some(Node::Item(item)) = cx.tcx.hir().find_parent(hir_id) {
+            if matches!(
+                item.kind,
+                ItemKind::Impl(Impl { of_trait: Some(_), .. }) | ItemKind::Trait(..)
+            ) {
+                return;
+            }
+        }
+
+        let fn_sig = cx.tcx.fn_sig(fn_def_id).subst_identity();
+        let fn_sig = cx.tcx.liberate_late_bound_regions(fn_def_id.to_def_id(), fn_sig);
+
+        // If there are no `&mut` argument, no need to go any further.
+        if !decl
+            .inputs
+            .iter()
+            .zip(fn_sig.inputs())
+            .zip(body.params)
+            .any(|((&input, &ty), arg)| !should_skip(cx, input, ty, arg))
+        {
+            return;
+        }
+
+        // Collect variables mutably used and spans which will need dereferencings from the
+        // function body.
+        let MutablyUsedVariablesCtxt { mutably_used_vars, .. } = {
+            let mut ctx = MutablyUsedVariablesCtxt::default();
+            let infcx = cx.tcx.infer_ctxt().build();
+            euv::ExprUseVisitor::new(&mut ctx, &infcx, fn_def_id, cx.param_env, cx.typeck_results()).consume_body(body);
+            ctx
+        };
+
+        for ((&input, &ty), arg) in decl.inputs.iter().zip(fn_sig.inputs()).zip(body.params) {
+            if should_skip(cx, input, ty, arg) {
+                continue;
+            }
+
+            // Only take `&mut` arguments.
+            if_chain! {
+                if let PatKind::Binding(_, canonical_id, ..) = arg.pat.kind;
+                if !mutably_used_vars.contains(&canonical_id);
+                if let rustc_hir::TyKind::Ref(_, inner_ty) = input.kind;
+                then {
+                    // If the argument is never used mutably, we emit the error.
+                    span_lint_and_sugg(
+                        cx,
+                        NEEDLESS_PASS_BY_REF_MUT,
+                        input.span,
+                        "this argument is a mutable reference, but not used mutably",
+                        "consider changing to",
+                        format!("&{}", snippet(cx, cx.tcx.hir().span(inner_ty.ty.hir_id), "_")),
+                        Applicability::Unspecified,
+                    );
+                }
+            }
+        }
+    }
+}
+
+#[derive(Default)]
+struct MutablyUsedVariablesCtxt {
+    mutably_used_vars: HirIdSet,
+    prev_bind: Option<HirId>,
+    aliases: HirIdMap<HirId>,
+}
+
+impl MutablyUsedVariablesCtxt {
+    fn add_mutably_used_var(&mut self, mut used_id: HirId) {
+        while let Some(id) = self.aliases.get(&used_id) {
+            self.mutably_used_vars.insert(used_id);
+            used_id = *id;
+        }
+        self.mutably_used_vars.insert(used_id);
+    }
+}
+
+impl<'tcx> euv::Delegate<'tcx> for MutablyUsedVariablesCtxt {
+    fn consume(&mut self, cmt: &euv::PlaceWithHirId<'tcx>, _id: HirId) {
+        if let euv::Place {
+            base: euv::PlaceBase::Local(vid),
+            base_ty,
+            ..
+        } = &cmt.place
+        {
+            if let Some(bind_id) = self.prev_bind.take() {
+                self.aliases.insert(bind_id, *vid);
+            } else if matches!(base_ty.ref_mutability(), Some(Mutability::Mut)) {
+                self.add_mutably_used_var(*vid);
+            }
+        }
+    }
+
+    fn borrow(&mut self, cmt: &euv::PlaceWithHirId<'tcx>, _id: HirId, borrow: ty::BorrowKind) {
+        self.prev_bind = None;
+        if let euv::Place {
+            base: euv::PlaceBase::Local(vid),
+            base_ty,
+            ..
+        } = &cmt.place
+        {
+            // If this is a mutable borrow, it was obviously used mutably so we add it. However
+            // for `UniqueImmBorrow`, it's interesting because if you do: `array[0] = value` inside
+            // a closure, it'll return this variant whereas if you have just an index access, it'll
+            // return `ImmBorrow`. So if there is "Unique" and it's a mutable reference, we add it
+            // to the mutably used variables set.
+            if borrow == ty::BorrowKind::MutBorrow
+                || (borrow == ty::BorrowKind::UniqueImmBorrow && base_ty.ref_mutability() == Some(Mutability::Mut))
+            {
+                self.add_mutably_used_var(*vid);
+            }
+        }
+    }
+
+    fn mutate(&mut self, cmt: &euv::PlaceWithHirId<'tcx>, _id: HirId) {
+        self.prev_bind = None;
+        if let euv::Place {
+            projections,
+            base: euv::PlaceBase::Local(vid),
+            ..
+        } = &cmt.place
+        {
+            if !projections.is_empty() {
+                self.add_mutably_used_var(*vid);
+            }
+        }
+    }
+
+    fn copy(&mut self, _cmt: &euv::PlaceWithHirId<'tcx>, _id: HirId) {
+        self.prev_bind = None;
+    }
+
+    fn fake_read(&mut self, _: &rustc_hir_typeck::expr_use_visitor::PlaceWithHirId<'tcx>, _: FakeReadCause, _: HirId) {}
+
+    fn bind(&mut self, _cmt: &euv::PlaceWithHirId<'tcx>, id: HirId) {
+        self.prev_bind = Some(id);
+    }
+}
diff --git a/clippy_lints/src/needless_pass_by_value.rs b/clippy_lints/src/needless_pass_by_value.rs
index ece10474715..5d299f9355d 100644
--- a/clippy_lints/src/needless_pass_by_value.rs
+++ b/clippy_lints/src/needless_pass_by_value.rs
@@ -289,7 +289,7 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByValue {
 }
 
 /// Functions marked with these attributes must have the exact signature.
-fn requires_exact_signature(attrs: &[Attribute]) -> bool {
+pub(crate) fn requires_exact_signature(attrs: &[Attribute]) -> bool {
     attrs.iter().any(|attr| {
         [sym::proc_macro, sym::proc_macro_attribute, sym::proc_macro_derive]
             .iter()
-- 
cgit 1.4.1-3-g733a5


From dd3e00f102aa9773c10a645db37c3a10967f31cb Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Thu, 15 Jun 2023 20:53:08 +0200
Subject: Fix warnings of `needless_pass_by_ref_mut` in clippy

---
 clippy_lints/src/literal_representation.rs | 4 ++--
 clippy_lints/src/non_expressive_names.rs   | 8 ++++----
 2 files changed, 6 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/literal_representation.rs b/clippy_lints/src/literal_representation.rs
index dadcd9c5135..09ca0317337 100644
--- a/clippy_lints/src/literal_representation.rs
+++ b/clippy_lints/src/literal_representation.rs
@@ -264,7 +264,7 @@ impl LiteralDigitGrouping {
                     return;
                 }
 
-                if Self::is_literal_uuid_formatted(&mut num_lit) {
+                if Self::is_literal_uuid_formatted(&num_lit) {
                     return;
                 }
 
@@ -376,7 +376,7 @@ impl LiteralDigitGrouping {
     ///
     /// Returns `true` if the radix is hexadecimal, and the groups match the
     /// UUID format of 8-4-4-4-12.
-    fn is_literal_uuid_formatted(num_lit: &mut NumericLiteral<'_>) -> bool {
+    fn is_literal_uuid_formatted(num_lit: &NumericLiteral<'_>) -> bool {
         if num_lit.radix != Radix::Hexadecimal {
             return false;
         }
diff --git a/clippy_lints/src/non_expressive_names.rs b/clippy_lints/src/non_expressive_names.rs
index 9f6917c146f..d562047cbf1 100644
--- a/clippy_lints/src/non_expressive_names.rs
+++ b/clippy_lints/src/non_expressive_names.rs
@@ -91,7 +91,7 @@ struct ExistingName {
 struct SimilarNamesLocalVisitor<'a, 'tcx> {
     names: Vec<ExistingName>,
     cx: &'a EarlyContext<'tcx>,
-    lint: &'a NonExpressiveNames,
+    lint: NonExpressiveNames,
 
     /// A stack of scopes containing the single-character bindings in each scope.
     single_char_names: Vec<Vec<Ident>>,
@@ -365,7 +365,7 @@ impl EarlyLintPass for NonExpressiveNames {
             ..
         }) = item.kind
         {
-            do_check(self, cx, &item.attrs, &sig.decl, blk);
+            do_check(*self, cx, &item.attrs, &sig.decl, blk);
         }
     }
 
@@ -380,12 +380,12 @@ impl EarlyLintPass for NonExpressiveNames {
             ..
         }) = item.kind
         {
-            do_check(self, cx, &item.attrs, &sig.decl, blk);
+            do_check(*self, cx, &item.attrs, &sig.decl, blk);
         }
     }
 }
 
-fn do_check(lint: &mut NonExpressiveNames, cx: &EarlyContext<'_>, attrs: &[Attribute], decl: &FnDecl, blk: &Block) {
+fn do_check(lint: NonExpressiveNames, cx: &EarlyContext<'_>, attrs: &[Attribute], decl: &FnDecl, blk: &Block) {
     if !attrs.iter().any(|attr| attr.has_name(sym::test)) {
         let mut visitor = SimilarNamesLocalVisitor {
             names: Vec::new(),
-- 
cgit 1.4.1-3-g733a5


From 33adfcd327880f45fce08660c1bd70f83ce09f84 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Mon, 3 Jul 2023 22:48:40 +0200
Subject: Add warning for `NEEDLESS_PASS_BY_REF_MUT` lint about the fact that
 it changes API

---
 clippy_lints/src/needless_pass_by_ref_mut.rs | 3 +++
 1 file changed, 3 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/needless_pass_by_ref_mut.rs b/clippy_lints/src/needless_pass_by_ref_mut.rs
index c5dc87cdfa8..d535963a1dc 100644
--- a/clippy_lints/src/needless_pass_by_ref_mut.rs
+++ b/clippy_lints/src/needless_pass_by_ref_mut.rs
@@ -22,6 +22,9 @@ declare_clippy_lint! {
     /// ### What it does
     /// Check if a `&mut` function argument is actually used mutably.
     ///
+    /// Be careful if the function is publically reexported as it would break compatibility with
+    /// users of this function.
+    ///
     /// ### Why is this bad?
     /// Less `mut` means less fights with the borrow checker. It can also lead to more
     /// opportunities for parallelization.
-- 
cgit 1.4.1-3-g733a5


From 8fad54e8f942e545458c7f339f0444513c5fcb1e Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Sat, 17 Jun 2023 01:41:11 +0200
Subject: new lint: `read_line_without_trim`

---
 CHANGELOG.md                                       |  1 +
 clippy_lints/src/declared_lints.rs                 |  1 +
 clippy_lints/src/methods/mod.rs                    | 34 ++++++++++
 clippy_lints/src/methods/read_line_without_trim.rs | 74 ++++++++++++++++++++++
 tests/ui/read_line_without_trim.fixed              | 19 ++++++
 tests/ui/read_line_without_trim.rs                 | 19 ++++++
 tests/ui/read_line_without_trim.stderr             | 31 +++++++++
 7 files changed, 179 insertions(+)
 create mode 100644 clippy_lints/src/methods/read_line_without_trim.rs
 create mode 100644 tests/ui/read_line_without_trim.fixed
 create mode 100644 tests/ui/read_line_without_trim.rs
 create mode 100644 tests/ui/read_line_without_trim.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index f9310b4ab31..e2004c2931d 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5134,6 +5134,7 @@ Released 2018-09-13
 [`rc_buffer`]: https://rust-lang.github.io/rust-clippy/master/index.html#rc_buffer
 [`rc_clone_in_vec_init`]: https://rust-lang.github.io/rust-clippy/master/index.html#rc_clone_in_vec_init
 [`rc_mutex`]: https://rust-lang.github.io/rust-clippy/master/index.html#rc_mutex
+[`read_line_without_trim`]: https://rust-lang.github.io/rust-clippy/master/index.html#read_line_without_trim
 [`read_zero_byte_vec`]: https://rust-lang.github.io/rust-clippy/master/index.html#read_zero_byte_vec
 [`recursive_format_impl`]: https://rust-lang.github.io/rust-clippy/master/index.html#recursive_format_impl
 [`redundant_allocation`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_allocation
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index e1dbe500396..ca97db04079 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -389,6 +389,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::methods::OR_THEN_UNWRAP_INFO,
     crate::methods::PATH_BUF_PUSH_OVERWRITE_INFO,
     crate::methods::RANGE_ZIP_WITH_LEN_INFO,
+    crate::methods::READ_LINE_WITHOUT_TRIM_INFO,
     crate::methods::REPEAT_ONCE_INFO,
     crate::methods::RESULT_MAP_OR_INTO_OPTION_INFO,
     crate::methods::SEARCH_IS_SOME_INFO,
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index ab97cf0e53d..c99f7c1fdd9 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -72,6 +72,7 @@ mod or_fun_call;
 mod or_then_unwrap;
 mod path_buf_push_overwrite;
 mod range_zip_with_len;
+mod read_line_without_trim;
 mod repeat_once;
 mod search_is_some;
 mod seek_from_current;
@@ -3348,6 +3349,35 @@ declare_clippy_lint! {
     "checks for usage of `Iterator::fold` with a type that implements `Try`"
 }
 
+declare_clippy_lint! {
+    /// Looks for calls to [`Stdin::read_line`] to read a line from the standard input
+    /// into a string, then later attempting to parse this string into a type without first trimming it, which will
+    /// always fail because the string has a trailing newline in it.
+    ///
+    /// ### Why is this bad?
+    /// The `.parse()` call will always fail.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// let mut input = String::new();
+    /// std::io::stdin().read_line(&mut input).expect("Failed to read a line");
+    /// let num: i32 = input.parse().expect("Not a number!");
+    /// assert_eq!(num, 42); // we never even get here!
+    /// ```
+    /// Use instead:
+    /// ```rust,ignore
+    /// let mut input = String::new();
+    /// std::io::stdin().read_line(&mut input).expect("Failed to read a line");
+    /// let num: i32 = input.trim_end().parse().expect("Not a number!");
+    /// //                  ^^^^^^^^^^^ remove the trailing newline
+    /// assert_eq!(num, 42);
+    /// ```
+    #[clippy::version = "1.72.0"]
+    pub READ_LINE_WITHOUT_TRIM,
+    correctness,
+    "calling `Stdin::read_line`, then trying to parse it without first trimming"
+}
+
 pub struct Methods {
     avoid_breaking_exported_api: bool,
     msrv: Msrv,
@@ -3468,6 +3498,7 @@ impl_lint_pass!(Methods => [
     REPEAT_ONCE,
     STABLE_SORT_PRIMITIVE,
     UNIT_HASH,
+    READ_LINE_WITHOUT_TRIM,
     UNNECESSARY_SORT_BY,
     VEC_RESIZE_TO_ZERO,
     VERBOSE_FILE_READS,
@@ -3879,6 +3910,9 @@ impl Methods {
                 ("read_to_string", [_]) => {
                     verbose_file_reads::check(cx, expr, recv, verbose_file_reads::READ_TO_STRING_MSG);
                 },
+                ("read_line", [arg]) => {
+                    read_line_without_trim::check(cx, expr, recv, arg);
+                }
                 ("repeat", [arg]) => {
                     repeat_once::check(cx, expr, recv, arg);
                 },
diff --git a/clippy_lints/src/methods/read_line_without_trim.rs b/clippy_lints/src/methods/read_line_without_trim.rs
new file mode 100644
index 00000000000..49e4f1acaa6
--- /dev/null
+++ b/clippy_lints/src/methods/read_line_without_trim.rs
@@ -0,0 +1,74 @@
+use std::ops::ControlFlow;
+
+use clippy_utils::{
+    diagnostics::span_lint_and_then, get_parent_expr, match_def_path, source::snippet, ty::is_type_diagnostic_item,
+    visitors::for_each_local_use_after_expr,
+};
+use rustc_errors::Applicability;
+use rustc_hir::Expr;
+use rustc_hir::QPath;
+use rustc_hir::{def::Res, ExprKind};
+use rustc_lint::LateContext;
+use rustc_middle::ty::{self, Ty};
+use rustc_span::sym;
+
+use super::READ_LINE_WITHOUT_TRIM;
+
+/// Will a `.parse::<ty>()` call fail if the input has a trailing newline?
+fn parse_fails_on_trailing_newline(ty: Ty<'_>) -> bool {
+    // only allow a very limited set of types for now, for which we 100% know parsing will fail
+    matches!(ty.kind(), ty::Float(_) | ty::Bool | ty::Int(_) | ty::Uint(_))
+}
+
+pub fn check(cx: &LateContext<'_>, call: &Expr<'_>, recv: &Expr<'_>, arg: &Expr<'_>) {
+    if let Some(recv_adt) = cx.typeck_results().expr_ty(recv).ty_adt_def()
+        && match_def_path(cx, recv_adt.did(), &["std", "io", "stdio", "Stdin"])
+        && let ExprKind::Path(QPath::Resolved(_, path)) = arg.peel_borrows().kind
+        && let Res::Local(local_id) = path.res
+    {
+        // We've checked that `call` is a call to `Stdin::read_line()` with the right receiver,
+        // now let's check if the first use of the string passed to `::read_line()` is
+        // parsed into a type that will always fail if it has a trailing newline.
+        for_each_local_use_after_expr(cx, local_id, call.hir_id, |expr| {
+            if let Some(parent) = get_parent_expr(cx, expr)
+                && let ExprKind::MethodCall(segment, .., span) = parent.kind
+                && segment.ident.name == sym!(parse)
+                && let parse_result_ty = cx.typeck_results().expr_ty(parent)
+                && is_type_diagnostic_item(cx, parse_result_ty, sym::Result)
+                && let ty::Adt(_, substs) = parse_result_ty.kind()
+                && let Some(ok_ty) = substs[0].as_type()
+                && parse_fails_on_trailing_newline(ok_ty)
+            {
+                let local_snippet = snippet(cx, expr.span, "<expr>");
+                span_lint_and_then(
+                    cx,
+                    READ_LINE_WITHOUT_TRIM,
+                    span,
+                    "calling `.parse()` without trimming the trailing newline character",
+                    |diag| {
+                        diag.span_note(call.span, "call to `.read_line()` here, \
+                            which leaves a trailing newline character in the buffer, \
+                            which in turn will cause `.parse()` to fail");
+
+                        diag.span_suggestion(
+                            expr.span,
+                            "try",
+                            format!("{local_snippet}.trim_end()"),
+                            Applicability::MachineApplicable,
+                        );
+                    }
+                );
+            }
+
+            // only consider the first use to prevent this scenario:
+            // ```
+            // let mut s = String::new();
+            // std::io::stdin().read_line(&mut s);
+            // s.pop();
+            // let _x: i32 = s.parse().unwrap();
+            // ```
+            // this is actually fine, because the pop call removes the trailing newline.
+            ControlFlow::<(), ()>::Break(())
+        });
+    }
+}
diff --git a/tests/ui/read_line_without_trim.fixed b/tests/ui/read_line_without_trim.fixed
new file mode 100644
index 00000000000..5995c8f523e
--- /dev/null
+++ b/tests/ui/read_line_without_trim.fixed
@@ -0,0 +1,19 @@
+//@run-rustfix
+
+#![allow(unused)]
+#![warn(clippy::read_line_without_trim)]
+
+fn main() {
+    let mut input = String::new();
+    std::io::stdin().read_line(&mut input).unwrap();
+    input.pop();
+    let _x: i32 = input.parse().unwrap(); // don't trigger here, newline character is popped
+
+    let mut input = String::new();
+    std::io::stdin().read_line(&mut input).unwrap();
+    let _x: i32 = input.trim_end().parse().unwrap();
+
+    let mut input = String::new();
+    std::io::stdin().read_line(&mut input).unwrap();
+    let _x = input.trim_end().parse::<i32>().unwrap();
+}
diff --git a/tests/ui/read_line_without_trim.rs b/tests/ui/read_line_without_trim.rs
new file mode 100644
index 00000000000..84527b624b6
--- /dev/null
+++ b/tests/ui/read_line_without_trim.rs
@@ -0,0 +1,19 @@
+//@run-rustfix
+
+#![allow(unused)]
+#![warn(clippy::read_line_without_trim)]
+
+fn main() {
+    let mut input = String::new();
+    std::io::stdin().read_line(&mut input).unwrap();
+    input.pop();
+    let _x: i32 = input.parse().unwrap(); // don't trigger here, newline character is popped
+
+    let mut input = String::new();
+    std::io::stdin().read_line(&mut input).unwrap();
+    let _x: i32 = input.parse().unwrap();
+
+    let mut input = String::new();
+    std::io::stdin().read_line(&mut input).unwrap();
+    let _x = input.parse::<i32>().unwrap();
+}
diff --git a/tests/ui/read_line_without_trim.stderr b/tests/ui/read_line_without_trim.stderr
new file mode 100644
index 00000000000..f0f7a61e9ff
--- /dev/null
+++ b/tests/ui/read_line_without_trim.stderr
@@ -0,0 +1,31 @@
+error: calling `.parse()` without trimming the trailing newline character
+  --> $DIR/read_line_without_trim.rs:14:25
+   |
+LL |     let _x: i32 = input.parse().unwrap();
+   |                   ----- ^^^^^^^
+   |                   |
+   |                   help: try: `input.trim_end()`
+   |
+note: call to `.read_line()` here, which leaves a trailing newline character in the buffer, which in turn will cause `.parse()` to fail
+  --> $DIR/read_line_without_trim.rs:13:5
+   |
+LL |     std::io::stdin().read_line(&mut input).unwrap();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   = note: `-D clippy::read-line-without-trim` implied by `-D warnings`
+
+error: calling `.parse()` without trimming the trailing newline character
+  --> $DIR/read_line_without_trim.rs:18:20
+   |
+LL |     let _x = input.parse::<i32>().unwrap();
+   |              ----- ^^^^^^^^^^^^^^
+   |              |
+   |              help: try: `input.trim_end()`
+   |
+note: call to `.read_line()` here, which leaves a trailing newline character in the buffer, which in turn will cause `.parse()` to fail
+  --> $DIR/read_line_without_trim.rs:17:5
+   |
+LL |     std::io::stdin().read_line(&mut input).unwrap();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From f048f73251309075c558f078538682c2e52b01a3 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Tue, 4 Jul 2023 20:35:23 +0200
Subject: Add warning about semver compatibility if it's a public function

---
 clippy_lints/src/lib.rs                         |  6 ++-
 clippy_lints/src/needless_pass_by_ref_mut.rs    | 61 +++++++++++++++++++------
 tests/ui/should_impl_trait/method_list_2.stderr |  1 +
 3 files changed, 53 insertions(+), 15 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index e1e4a83b031..040ed1a8619 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1058,7 +1058,11 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     let stack_size_threshold = conf.stack_size_threshold;
     store.register_late_pass(move |_| Box::new(large_stack_frames::LargeStackFrames::new(stack_size_threshold)));
     store.register_late_pass(|_| Box::new(single_range_in_vec_init::SingleRangeInVecInit));
-    store.register_late_pass(|_| Box::new(needless_pass_by_ref_mut::NeedlessPassByRefMut));
+    store.register_late_pass(move |_| {
+        Box::new(needless_pass_by_ref_mut::NeedlessPassByRefMut::new(
+            avoid_breaking_exported_api,
+        ))
+    });
     store.register_late_pass(|_| Box::new(incorrect_impls::IncorrectImpls));
     store.register_late_pass(move |_| {
         Box::new(single_call_fn::SingleCallFn {
diff --git a/clippy_lints/src/needless_pass_by_ref_mut.rs b/clippy_lints/src/needless_pass_by_ref_mut.rs
index d535963a1dc..96cb09c071a 100644
--- a/clippy_lints/src/needless_pass_by_ref_mut.rs
+++ b/clippy_lints/src/needless_pass_by_ref_mut.rs
@@ -1,5 +1,5 @@
 use super::needless_pass_by_value::requires_exact_signature;
-use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet;
 use clippy_utils::{is_from_proc_macro, is_self};
 use if_chain::if_chain;
@@ -12,7 +12,7 @@ use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::mir::FakeReadCause;
 use rustc_middle::ty::{self, Ty};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::def_id::LocalDefId;
 use rustc_span::symbol::kw;
 use rustc_span::Span;
@@ -46,7 +46,21 @@ declare_clippy_lint! {
     suspicious,
     "using a `&mut` argument when it's not mutated"
 }
-declare_lint_pass!(NeedlessPassByRefMut => [NEEDLESS_PASS_BY_REF_MUT]);
+
+#[derive(Copy, Clone)]
+pub struct NeedlessPassByRefMut {
+    avoid_breaking_exported_api: bool,
+}
+
+impl NeedlessPassByRefMut {
+    pub fn new(avoid_breaking_exported_api: bool) -> Self {
+        Self {
+            avoid_breaking_exported_api,
+        }
+    }
+}
+
+impl_lint_pass!(NeedlessPassByRefMut => [NEEDLESS_PASS_BY_REF_MUT]);
 
 fn should_skip<'tcx>(
     cx: &LateContext<'tcx>,
@@ -134,26 +148,45 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByRefMut {
             ctx
         };
 
-        for ((&input, &ty), arg) in decl.inputs.iter().zip(fn_sig.inputs()).zip(body.params) {
-            if should_skip(cx, input, ty, arg) {
-                continue;
-            }
-
+        let mut it = decl
+            .inputs
+            .iter()
+            .zip(fn_sig.inputs())
+            .zip(body.params)
+            .filter(|((&input, &ty), arg)| !should_skip(cx, input, ty, arg))
+            .peekable();
+        if it.peek().is_none() {
+            return;
+        }
+        let show_semver_warning = self.avoid_breaking_exported_api && cx.effective_visibilities.is_exported(fn_def_id);
+        for ((&input, &_), arg) in it {
             // Only take `&mut` arguments.
             if_chain! {
                 if let PatKind::Binding(_, canonical_id, ..) = arg.pat.kind;
                 if !mutably_used_vars.contains(&canonical_id);
                 if let rustc_hir::TyKind::Ref(_, inner_ty) = input.kind;
                 then {
-                    // If the argument is never used mutably, we emit the error.
-                    span_lint_and_sugg(
+                    // If the argument is never used mutably, we emit the warning.
+                    let sp = input.span;
+                    span_lint_and_then(
                         cx,
                         NEEDLESS_PASS_BY_REF_MUT,
-                        input.span,
+                        sp,
                         "this argument is a mutable reference, but not used mutably",
-                        "consider changing to",
-                        format!("&{}", snippet(cx, cx.tcx.hir().span(inner_ty.ty.hir_id), "_")),
-                        Applicability::Unspecified,
+                        |diag| {
+                            diag.span_suggestion(
+                                sp,
+                                "consider changing to".to_string(),
+                                format!(
+                                    "&{}",
+                                    snippet(cx, cx.tcx.hir().span(inner_ty.ty.hir_id), "_"),
+                                ),
+                                Applicability::Unspecified,
+                            );
+                            if show_semver_warning {
+                                diag.warn("changing this function will impact semver compatibility");
+                            }
+                        },
                     );
                 }
             }
diff --git a/tests/ui/should_impl_trait/method_list_2.stderr b/tests/ui/should_impl_trait/method_list_2.stderr
index e47cb209b83..2ae9fa34d14 100644
--- a/tests/ui/should_impl_trait/method_list_2.stderr
+++ b/tests/ui/should_impl_trait/method_list_2.stderr
@@ -45,6 +45,7 @@ error: this argument is a mutable reference, but not used mutably
 LL |     pub fn hash(&self, state: &mut T) {
    |                               ^^^^^^ help: consider changing to: `&T`
    |
+   = warning: changing this function will impact semver compatibility
    = note: `-D clippy::needless-pass-by-ref-mut` implied by `-D warnings`
 
 error: method `index` can be confused for the standard trait method `std::ops::Index::index`
-- 
cgit 1.4.1-3-g733a5


From 6868c0a74bb1edeff8c078bb8b09994075e826cb Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Wed, 5 Jul 2023 12:30:39 +0200
Subject: [`unnecessary_literal_unwrap`]: don't lint if binding initializer is
 expn

---
 clippy_lints/src/methods/unnecessary_literal_unwrap.rs |  5 +++++
 tests/ui/unnecessary_literal_unwrap.fixed              | 10 ++++++++++
 tests/ui/unnecessary_literal_unwrap.rs                 | 10 ++++++++++
 3 files changed, 25 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/unnecessary_literal_unwrap.rs b/clippy_lints/src/methods/unnecessary_literal_unwrap.rs
index 7877f6a386c..ce93d7c3eb3 100644
--- a/clippy_lints/src/methods/unnecessary_literal_unwrap.rs
+++ b/clippy_lints/src/methods/unnecessary_literal_unwrap.rs
@@ -29,6 +29,11 @@ pub(super) fn check(
     args: &[hir::Expr<'_>],
 ) {
     let init = clippy_utils::expr_or_init(cx, recv);
+    if init.span.from_expansion() {
+        // don't lint if the receiver or binding initializer comes from a macro
+        // (e.g. `let x = option_env!(..); x.unwrap()`)
+        return;
+    }
 
     let (constructor, call_args, ty) = if let hir::ExprKind::Call(call, call_args) = init.kind {
         let Some(qpath) = call.qpath_opt() else { return };
diff --git a/tests/ui/unnecessary_literal_unwrap.fixed b/tests/ui/unnecessary_literal_unwrap.fixed
index 630a1bea3c8..092bf78feab 100644
--- a/tests/ui/unnecessary_literal_unwrap.fixed
+++ b/tests/ui/unnecessary_literal_unwrap.fixed
@@ -68,6 +68,16 @@ fn unwrap_methods_result() {
     1;
 }
 
+fn unwrap_from_binding() {
+    macro_rules! from_macro {
+        () => {
+            Some("")
+        };
+    }
+    let val = from_macro!();
+    let _ = val.unwrap_or("");
+}
+
 fn main() {
     unwrap_option_some();
     unwrap_option_none();
diff --git a/tests/ui/unnecessary_literal_unwrap.rs b/tests/ui/unnecessary_literal_unwrap.rs
index 14f92cb370f..b9df893d1d2 100644
--- a/tests/ui/unnecessary_literal_unwrap.rs
+++ b/tests/ui/unnecessary_literal_unwrap.rs
@@ -68,6 +68,16 @@ fn unwrap_methods_result() {
     Ok::<_, ()>(1).unwrap_or_else(|_| 2);
 }
 
+fn unwrap_from_binding() {
+    macro_rules! from_macro {
+        () => {
+            Some("")
+        };
+    }
+    let val = from_macro!();
+    let _ = val.unwrap_or("");
+}
+
 fn main() {
     unwrap_option_some();
     unwrap_option_none();
-- 
cgit 1.4.1-3-g733a5


From f9453511701192ac391a42b37c1794621ece0f77 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Wed, 5 Jul 2023 18:04:10 +0000
Subject: Fix regex lints for regex 1.9.0

---
 clippy_lints/src/lib.rs   |  2 +-
 clippy_lints/src/regex.rs | 66 +++++++++++++++++++++++++++++++++--------------
 clippy_utils/src/paths.rs | 12 ++++-----
 3 files changed, 53 insertions(+), 27 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index c43e0b753dc..00d46025caa 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -722,7 +722,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(drop_forget_ref::DropForgetRef));
     store.register_late_pass(|_| Box::new(empty_enum::EmptyEnum));
     store.register_late_pass(|_| Box::new(invalid_upcast_comparisons::InvalidUpcastComparisons));
-    store.register_late_pass(|_| Box::new(regex::Regex));
+    store.register_late_pass(|_| Box::<regex::Regex>::default());
     let ignore_interior_mutability = conf.ignore_interior_mutability.clone();
     store.register_late_pass(move |_| Box::new(copies::CopyAndPaste::new(ignore_interior_mutability.clone())));
     store.register_late_pass(|_| Box::new(copy_iterator::CopyIterator));
diff --git a/clippy_lints/src/regex.rs b/clippy_lints/src/regex.rs
index 674f8bf4c0f..b795e4b15ba 100644
--- a/clippy_lints/src/regex.rs
+++ b/clippy_lints/src/regex.rs
@@ -3,12 +3,12 @@ use std::fmt::Display;
 use clippy_utils::consts::{constant, Constant};
 use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
 use clippy_utils::source::snippet_opt;
-use clippy_utils::{match_def_path, paths};
-use if_chain::if_chain;
+use clippy_utils::{def_path_def_ids, path_def_id, paths};
 use rustc_ast::ast::{LitKind, StrStyle};
+use rustc_hir::def_id::DefIdMap;
 use rustc_hir::{BorrowKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::{BytePos, Span};
 
 declare_clippy_lint! {
@@ -55,26 +55,52 @@ declare_clippy_lint! {
     "trivial regular expressions"
 }
 
-declare_lint_pass!(Regex => [INVALID_REGEX, TRIVIAL_REGEX]);
+#[derive(Copy, Clone)]
+enum RegexKind {
+    Unicode,
+    UnicodeSet,
+    Bytes,
+    BytesSet,
+}
+
+#[derive(Default)]
+pub struct Regex {
+    definitions: DefIdMap<RegexKind>,
+}
+
+impl_lint_pass!(Regex => [INVALID_REGEX, TRIVIAL_REGEX]);
 
 impl<'tcx> LateLintPass<'tcx> for Regex {
+    fn check_crate(&mut self, cx: &LateContext<'tcx>) {
+        // We don't use `match_def_path` here because that relies on matching the exact path, which changed
+        // between regex 1.8 and 1.9
+        //
+        // `def_path_def_ids` will resolve through re-exports but is relatively heavy, so we only perform
+        // the operation once and store the results
+        let mut resolve = |path, kind| {
+            for id in def_path_def_ids(cx, path) {
+                self.definitions.insert(id, kind);
+            }
+        };
+
+        resolve(&paths::REGEX_NEW, RegexKind::Unicode);
+        resolve(&paths::REGEX_BUILDER_NEW, RegexKind::Unicode);
+        resolve(&paths::REGEX_SET_NEW, RegexKind::UnicodeSet);
+        resolve(&paths::REGEX_BYTES_NEW, RegexKind::Bytes);
+        resolve(&paths::REGEX_BYTES_BUILDER_NEW, RegexKind::Bytes);
+        resolve(&paths::REGEX_BYTES_SET_NEW, RegexKind::BytesSet);
+    }
+
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if_chain! {
-            if let ExprKind::Call(fun, [arg]) = expr.kind;
-            if let ExprKind::Path(ref qpath) = fun.kind;
-            if let Some(def_id) = cx.qpath_res(qpath, fun.hir_id).opt_def_id();
-            then {
-                if match_def_path(cx, def_id, &paths::REGEX_NEW) ||
-                   match_def_path(cx, def_id, &paths::REGEX_BUILDER_NEW) {
-                    check_regex(cx, arg, true);
-                } else if match_def_path(cx, def_id, &paths::REGEX_BYTES_NEW) ||
-                   match_def_path(cx, def_id, &paths::REGEX_BYTES_BUILDER_NEW) {
-                    check_regex(cx, arg, false);
-                } else if match_def_path(cx, def_id, &paths::REGEX_SET_NEW) {
-                    check_set(cx, arg, true);
-                } else if match_def_path(cx, def_id, &paths::REGEX_BYTES_SET_NEW) {
-                    check_set(cx, arg, false);
-                }
+        if let ExprKind::Call(fun, [arg]) = expr.kind
+            && let Some(def_id) = path_def_id(cx, fun)
+            && let Some(regex_kind) = self.definitions.get(&def_id)
+        {
+            match regex_kind {
+                RegexKind::Unicode => check_regex(cx, arg, true),
+                RegexKind::UnicodeSet => check_set(cx, arg, true),
+                RegexKind::Bytes => check_regex(cx, arg, false),
+                RegexKind::BytesSet => check_set(cx, arg, false),
             }
         }
     }
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index 0e6f01287b5..f3677e6f614 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -94,12 +94,12 @@ pub const PUSH_STR: [&str; 4] = ["alloc", "string", "String", "push_str"];
 pub const RANGE_ARGUMENT_TRAIT: [&str; 3] = ["core", "ops", "RangeBounds"];
 pub const REFCELL_REF: [&str; 3] = ["core", "cell", "Ref"];
 pub const REFCELL_REFMUT: [&str; 3] = ["core", "cell", "RefMut"];
-pub const REGEX_BUILDER_NEW: [&str; 5] = ["regex", "re_builder", "unicode", "RegexBuilder", "new"];
-pub const REGEX_BYTES_BUILDER_NEW: [&str; 5] = ["regex", "re_builder", "bytes", "RegexBuilder", "new"];
-pub const REGEX_BYTES_NEW: [&str; 4] = ["regex", "re_bytes", "Regex", "new"];
-pub const REGEX_BYTES_SET_NEW: [&str; 5] = ["regex", "re_set", "bytes", "RegexSet", "new"];
-pub const REGEX_NEW: [&str; 4] = ["regex", "re_unicode", "Regex", "new"];
-pub const REGEX_SET_NEW: [&str; 5] = ["regex", "re_set", "unicode", "RegexSet", "new"];
+pub const REGEX_BUILDER_NEW: [&str; 3] = ["regex", "RegexBuilder", "new"];
+pub const REGEX_BYTES_BUILDER_NEW: [&str; 4] = ["regex", "bytes", "RegexBuilder", "new"];
+pub const REGEX_BYTES_NEW: [&str; 4] = ["regex", "bytes", "Regex", "new"];
+pub const REGEX_BYTES_SET_NEW: [&str; 4] = ["regex", "bytes", "RegexSet", "new"];
+pub const REGEX_NEW: [&str; 3] = ["regex", "Regex", "new"];
+pub const REGEX_SET_NEW: [&str; 3] = ["regex", "RegexSet", "new"];
 pub const SERDE_DESERIALIZE: [&str; 3] = ["serde", "de", "Deserialize"];
 pub const SERDE_DE_VISITOR: [&str; 3] = ["serde", "de", "Visitor"];
 pub const SLICE_FROM_RAW_PARTS: [&str; 4] = ["core", "slice", "raw", "from_raw_parts"];
-- 
cgit 1.4.1-3-g733a5


From f12edfdb53b13008dcff9eba2a3fd9a19370d2ee Mon Sep 17 00:00:00 2001
From: Catherine <114838443+Centri3@users.noreply.github.com>
Date: Fri, 30 Jun 2023 11:31:08 -0500
Subject: `manual_float_methods`

---
 CHANGELOG.md                             |   2 +
 clippy_lints/src/declared_lints.rs       |   2 +
 clippy_lints/src/lib.rs                  |   2 +
 clippy_lints/src/manual_float_methods.rs | 106 +++++++++++++++++++++++++++++++
 clippy_utils/src/consts.rs               |  11 ++++
 tests/ui/manual_float_methods.fixed      |  37 +++++++++++
 tests/ui/manual_float_methods.rs         |  37 +++++++++++
 tests/ui/manual_float_methods.stderr     |  42 ++++++++++++
 8 files changed, 239 insertions(+)
 create mode 100644 clippy_lints/src/manual_float_methods.rs
 create mode 100644 tests/ui/manual_float_methods.fixed
 create mode 100644 tests/ui/manual_float_methods.rs
 create mode 100644 tests/ui/manual_float_methods.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index e2004c2931d..59719080e44 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4941,6 +4941,8 @@ Released 2018-09-13
 [`manual_flatten`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_flatten
 [`manual_instant_elapsed`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_instant_elapsed
 [`manual_is_ascii_check`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_is_ascii_check
+[`manual_is_finite`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_is_finite
+[`manual_is_infinite`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_is_infinite
 [`manual_let_else`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_let_else
 [`manual_main_separator_str`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_main_separator_str
 [`manual_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_map
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index ca97db04079..f8b8b94dd29 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -273,6 +273,8 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::manual_async_fn::MANUAL_ASYNC_FN_INFO,
     crate::manual_bits::MANUAL_BITS_INFO,
     crate::manual_clamp::MANUAL_CLAMP_INFO,
+    crate::manual_float_methods::MANUAL_IS_FINITE_INFO,
+    crate::manual_float_methods::MANUAL_IS_INFINITE_INFO,
     crate::manual_is_ascii_check::MANUAL_IS_ASCII_CHECK_INFO,
     crate::manual_let_else::MANUAL_LET_ELSE_INFO,
     crate::manual_main_separator_str::MANUAL_MAIN_SEPARATOR_STR_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 00d46025caa..9abcbe01176 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -184,6 +184,7 @@ mod manual_assert;
 mod manual_async_fn;
 mod manual_bits;
 mod manual_clamp;
+mod manual_float_methods;
 mod manual_is_ascii_check;
 mod manual_let_else;
 mod manual_main_separator_str;
@@ -1073,6 +1074,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(manual_range_patterns::ManualRangePatterns));
     store.register_early_pass(|| Box::new(visibility::Visibility));
     store.register_late_pass(move |_| Box::new(tuple_array_conversions::TupleArrayConversions { msrv: msrv() }));
+    store.register_late_pass(|_| Box::new(manual_float_methods::ManualFloatMethods));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/manual_float_methods.rs b/clippy_lints/src/manual_float_methods.rs
new file mode 100644
index 00000000000..abf1eb788dd
--- /dev/null
+++ b/clippy_lints/src/manual_float_methods.rs
@@ -0,0 +1,106 @@
+use clippy_utils::{
+    consts::constant, diagnostics::span_lint_and_sugg, is_from_proc_macro, path_to_local, source::snippet_opt,
+};
+use rustc_errors::Applicability;
+use rustc_hir::{BinOpKind, Expr, ExprKind};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_middle::lint::in_external_macro;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `x == <float>::INFINITY || x == <float>::NEG_INFINITY`.
+    ///
+    /// ### Why is this bad?
+    /// This should use the dedicated method instead, `is_infinite`.
+    ///
+    /// ### Example
+    /// ```rust
+    /// # let x = 1.0f32;
+    /// if x == f32::INFINITY || x == f32::NEG_INFINITY {}
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// # let x = 1.0f32;
+    /// if x.is_infinite() {}
+    /// ```
+    #[clippy::version = "1.72.0"]
+    pub MANUAL_IS_INFINITE,
+    style,
+    "use dedicated method to check if a float is infinite"
+}
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `x != <float>::INFINITY && x != <float>::NEG_INFINITY`.
+    ///
+    /// ### Why is this bad?
+    /// This should use the dedicated method instead, `is_finite`.
+    ///
+    /// ### Example
+    /// ```rust
+    /// # let x = 1.0f32;
+    /// if x != f32::INFINITY && x != f32::NEG_INFINITY {}
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// # let x = 1.0f32;
+    /// if x.is_finite() {}
+    /// ```
+    #[clippy::version = "1.72.0"]
+    pub MANUAL_IS_FINITE,
+    style,
+    "use dedicated method to check if a float is finite"
+}
+declare_lint_pass!(ManualFloatMethods => [MANUAL_IS_INFINITE, MANUAL_IS_FINITE]);
+
+impl<'tcx> LateLintPass<'tcx> for ManualFloatMethods {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
+        if !in_external_macro(cx.sess(), expr.span)
+            && let ExprKind::Binary(kind, lhs, rhs) = expr.kind
+            && let ExprKind::Binary(lhs_kind, lhs_lhs, lhs_rhs) = lhs.kind
+            && let ExprKind::Binary(rhs_kind, rhs_lhs, rhs_rhs) = rhs.kind
+            && let (operands, consts) = [lhs_lhs, lhs_rhs, rhs_lhs, rhs_rhs]
+                .into_iter()
+                .partition::<Vec<&Expr<'_>>, _>(|i| path_to_local(i).is_some())
+            && let [first, second] = &*operands
+            && let Some([const_1, const_2]) = consts
+                .into_iter()
+                .map(|i| constant(cx, cx.typeck_results(), i).and_then(|c| c.to_bits()))
+                .collect::<Option<Vec<_>>>()
+                .as_deref()
+            && path_to_local(first).is_some_and(|f| path_to_local(second).is_some_and(|s| f == s))
+            && (is_infinity(*const_1) && is_neg_infinity(*const_2)
+                || is_neg_infinity(*const_1) && is_infinity(*const_2))
+            && let Some(local_snippet) = snippet_opt(cx, first.span)
+            && !is_from_proc_macro(cx, expr)
+        {
+            let (msg, lint, sugg_fn) = match (kind.node, lhs_kind.node, rhs_kind.node) {
+                (BinOpKind::Or, BinOpKind::Eq, BinOpKind::Eq) => {
+                    ("manually checking if a float is infinite", MANUAL_IS_INFINITE, "is_infinite")
+                },
+                (BinOpKind::And, BinOpKind::Ne, BinOpKind::Ne) => {
+                    ("manually checking if a float is finite", MANUAL_IS_FINITE, "is_finite")
+                },
+                _ => return,
+            };
+
+            span_lint_and_sugg(
+                cx,
+                lint,
+                expr.span,
+                msg,
+                "try",
+                format!("{local_snippet}.{sugg_fn}()"),
+                Applicability::MachineApplicable,
+            );
+        }
+    }
+}
+
+fn is_infinity(bits: u128) -> bool {
+    bits == 0x7f80_0000 || bits == 0x7ff0_0000_0000_0000
+}
+
+fn is_neg_infinity(bits: u128) -> bool {
+    bits == 0xff80_0000 || bits == 0xfff0_0000_0000_0000
+}
diff --git a/clippy_utils/src/consts.rs b/clippy_utils/src/consts.rs
index 87d85d742ce..b9f8eefeb8e 100644
--- a/clippy_utils/src/consts.rs
+++ b/clippy_utils/src/consts.rs
@@ -190,6 +190,17 @@ impl<'tcx> Constant<'tcx> {
         }
     }
 
+    /// Returns the bit representation if `self` is a bool, integer, or float.
+    pub fn to_bits(&self) -> Option<u128> {
+        match self {
+            Constant::Int(int) => Some(*int),
+            Constant::F32(float) => Some(u128::from(float.to_bits())),
+            Constant::F64(float) => Some(u128::from(float.to_bits())),
+            Constant::Bool(bool) => Some(u128::from(*bool)),
+            _ => None,
+        }
+    }
+
     /// Returns the integer value or `None` if `self` or `val_type` is not integer type.
     pub fn int_value(&self, cx: &LateContext<'_>, val_type: Ty<'_>) -> Option<FullInt> {
         if let Constant::Int(const_int) = *self {
diff --git a/tests/ui/manual_float_methods.fixed b/tests/ui/manual_float_methods.fixed
new file mode 100644
index 00000000000..87a23b5a75b
--- /dev/null
+++ b/tests/ui/manual_float_methods.fixed
@@ -0,0 +1,37 @@
+//@run-rustfix
+//@aux-build:proc_macros.rs:proc-macro
+#![allow(clippy::needless_if, unused)]
+#![warn(clippy::manual_is_infinite, clippy::manual_is_finite)]
+
+#[macro_use]
+extern crate proc_macros;
+
+const INFINITE: f32 = f32::INFINITY;
+const NEG_INFINITE: f32 = f32::NEG_INFINITY;
+
+fn main() {
+    let x = 1.0f32;
+    if x.is_infinite() {}
+    if x.is_finite() {}
+    if x.is_infinite() {}
+    if x.is_finite() {}
+    let x = 1.0f64;
+    if x.is_infinite() {}
+    if x.is_finite() {}
+    // Don't lint
+    if x.is_infinite() {}
+    if x.is_finite() {}
+    // If they're doing it this way, they probably know what they're doing
+    if x.abs() < f64::INFINITY {}
+    external! {
+        let x = 1.0;
+        if x == f32::INFINITY || x == f32::NEG_INFINITY {}
+        if x != f32::INFINITY && x != f32::NEG_INFINITY {}
+    }
+    with_span! {
+        span
+        let x = 1.0;
+        if x == f32::INFINITY || x == f32::NEG_INFINITY {}
+        if x != f32::INFINITY && x != f32::NEG_INFINITY {}
+    }
+}
diff --git a/tests/ui/manual_float_methods.rs b/tests/ui/manual_float_methods.rs
new file mode 100644
index 00000000000..9255bf93418
--- /dev/null
+++ b/tests/ui/manual_float_methods.rs
@@ -0,0 +1,37 @@
+//@run-rustfix
+//@aux-build:proc_macros.rs:proc-macro
+#![allow(clippy::needless_if, unused)]
+#![warn(clippy::manual_is_infinite, clippy::manual_is_finite)]
+
+#[macro_use]
+extern crate proc_macros;
+
+const INFINITE: f32 = f32::INFINITY;
+const NEG_INFINITE: f32 = f32::NEG_INFINITY;
+
+fn main() {
+    let x = 1.0f32;
+    if x == f32::INFINITY || x == f32::NEG_INFINITY {}
+    if x != f32::INFINITY && x != f32::NEG_INFINITY {}
+    if x == INFINITE || x == NEG_INFINITE {}
+    if x != INFINITE && x != NEG_INFINITE {}
+    let x = 1.0f64;
+    if x == f64::INFINITY || x == f64::NEG_INFINITY {}
+    if x != f64::INFINITY && x != f64::NEG_INFINITY {}
+    // Don't lint
+    if x.is_infinite() {}
+    if x.is_finite() {}
+    // If they're doing it this way, they probably know what they're doing
+    if x.abs() < f64::INFINITY {}
+    external! {
+        let x = 1.0;
+        if x == f32::INFINITY || x == f32::NEG_INFINITY {}
+        if x != f32::INFINITY && x != f32::NEG_INFINITY {}
+    }
+    with_span! {
+        span
+        let x = 1.0;
+        if x == f32::INFINITY || x == f32::NEG_INFINITY {}
+        if x != f32::INFINITY && x != f32::NEG_INFINITY {}
+    }
+}
diff --git a/tests/ui/manual_float_methods.stderr b/tests/ui/manual_float_methods.stderr
new file mode 100644
index 00000000000..00227593a9e
--- /dev/null
+++ b/tests/ui/manual_float_methods.stderr
@@ -0,0 +1,42 @@
+error: manually checking if a float is infinite
+  --> $DIR/manual_float_methods.rs:14:8
+   |
+LL |     if x == f32::INFINITY || x == f32::NEG_INFINITY {}
+   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `x.is_infinite()`
+   |
+   = note: `-D clippy::manual-is-infinite` implied by `-D warnings`
+
+error: manually checking if a float is finite
+  --> $DIR/manual_float_methods.rs:15:8
+   |
+LL |     if x != f32::INFINITY && x != f32::NEG_INFINITY {}
+   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `x.is_finite()`
+   |
+   = note: `-D clippy::manual-is-finite` implied by `-D warnings`
+
+error: manually checking if a float is infinite
+  --> $DIR/manual_float_methods.rs:16:8
+   |
+LL |     if x == INFINITE || x == NEG_INFINITE {}
+   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `x.is_infinite()`
+
+error: manually checking if a float is finite
+  --> $DIR/manual_float_methods.rs:17:8
+   |
+LL |     if x != INFINITE && x != NEG_INFINITE {}
+   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `x.is_finite()`
+
+error: manually checking if a float is infinite
+  --> $DIR/manual_float_methods.rs:19:8
+   |
+LL |     if x == f64::INFINITY || x == f64::NEG_INFINITY {}
+   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `x.is_infinite()`
+
+error: manually checking if a float is finite
+  --> $DIR/manual_float_methods.rs:20:8
+   |
+LL |     if x != f64::INFINITY && x != f64::NEG_INFINITY {}
+   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `x.is_finite()`
+
+error: aborting due to 6 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 5949f762bfa15e62657771e556c160abe4caee8b Mon Sep 17 00:00:00 2001
From: Catherine <114838443+Centri3@users.noreply.github.com>
Date: Sun, 2 Jul 2023 11:43:05 -0500
Subject: Make suggestion give multiple alternatives

---
 clippy_lints/src/manual_float_methods.rs | 82 ++++++++++++++++++++++++++------
 tests/ui/manual_float_methods.fixed      | 37 --------------
 tests/ui/manual_float_methods.rs         |  1 -
 tests/ui/manual_float_methods.stderr     | 62 +++++++++++++++++++-----
 4 files changed, 117 insertions(+), 65 deletions(-)
 delete mode 100644 tests/ui/manual_float_methods.fixed

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_float_methods.rs b/clippy_lints/src/manual_float_methods.rs
index abf1eb788dd..0f488627b4e 100644
--- a/clippy_lints/src/manual_float_methods.rs
+++ b/clippy_lints/src/manual_float_methods.rs
@@ -1,9 +1,9 @@
 use clippy_utils::{
-    consts::constant, diagnostics::span_lint_and_sugg, is_from_proc_macro, path_to_local, source::snippet_opt,
+    consts::constant, diagnostics::span_lint_and_then, is_from_proc_macro, path_to_local, source::snippet_opt,
 };
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind};
-use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_lint::{LateContext, LateLintPass, Lint, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
@@ -53,12 +53,37 @@ declare_clippy_lint! {
 }
 declare_lint_pass!(ManualFloatMethods => [MANUAL_IS_INFINITE, MANUAL_IS_FINITE]);
 
+#[derive(Clone, Copy)]
+enum Variant {
+    ManualIsInfinite,
+    ManualIsFinite,
+}
+
+impl Variant {
+    pub fn lint(self) -> &'static Lint {
+        match self {
+            Self::ManualIsInfinite => MANUAL_IS_INFINITE,
+            Self::ManualIsFinite => MANUAL_IS_FINITE,
+        }
+    }
+
+    pub fn msg(self) -> &'static str {
+        match self {
+            Self::ManualIsInfinite => "manually checking if a float is infinite",
+            Self::ManualIsFinite => "manually checking if a float is finite",
+        }
+    }
+}
+
 impl<'tcx> LateLintPass<'tcx> for ManualFloatMethods {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
         if !in_external_macro(cx.sess(), expr.span)
+            && (!cx.param_env.is_const() || cx.tcx.features().active(sym!(const_float_classify)))
             && let ExprKind::Binary(kind, lhs, rhs) = expr.kind
             && let ExprKind::Binary(lhs_kind, lhs_lhs, lhs_rhs) = lhs.kind
             && let ExprKind::Binary(rhs_kind, rhs_lhs, rhs_rhs) = rhs.kind
+            // Checking all possible scenarios using a function would be a hopeless task, as we have
+            // 16 possible alignments of constants/operands. For now, let's use `partition`.
             && let (operands, consts) = [lhs_lhs, lhs_rhs, rhs_lhs, rhs_rhs]
                 .into_iter()
                 .partition::<Vec<&Expr<'_>>, _>(|i| path_to_local(i).is_some())
@@ -74,24 +99,51 @@ impl<'tcx> LateLintPass<'tcx> for ManualFloatMethods {
             && let Some(local_snippet) = snippet_opt(cx, first.span)
             && !is_from_proc_macro(cx, expr)
         {
-            let (msg, lint, sugg_fn) = match (kind.node, lhs_kind.node, rhs_kind.node) {
-                (BinOpKind::Or, BinOpKind::Eq, BinOpKind::Eq) => {
-                    ("manually checking if a float is infinite", MANUAL_IS_INFINITE, "is_infinite")
-                },
-                (BinOpKind::And, BinOpKind::Ne, BinOpKind::Ne) => {
-                    ("manually checking if a float is finite", MANUAL_IS_FINITE, "is_finite")
-                },
+            let variant = match (kind.node, lhs_kind.node, rhs_kind.node) {
+                (BinOpKind::Or, BinOpKind::Eq, BinOpKind::Eq) => Variant::ManualIsInfinite,
+                (BinOpKind::And, BinOpKind::Ne, BinOpKind::Ne) => Variant::ManualIsFinite,
                 _ => return,
             };
 
-            span_lint_and_sugg(
+            span_lint_and_then(
                 cx,
-                lint,
+                variant.lint(),
                 expr.span,
-                msg,
-                "try",
-                format!("{local_snippet}.{sugg_fn}()"),
-                Applicability::MachineApplicable,
+                variant.msg(),
+                |diag| {
+                    match variant {
+                        Variant::ManualIsInfinite => {
+                            diag.span_suggestion(
+                                expr.span,
+                                "use the dedicated method instead",
+                                format!("{local_snippet}.is_infinite()"),
+                                Applicability::MachineApplicable,
+                            );
+                        },
+                        Variant::ManualIsFinite => {
+                            // TODO: There's probably some better way to do this, i.e., create
+                            // multiple suggestions with notes between each of them
+                            diag.span_suggestion_verbose(
+                                expr.span,
+                                "use the dedicated method instead",
+                                format!("{local_snippet}.is_finite()"),
+                                Applicability::MaybeIncorrect,
+                            );
+                            diag.span_suggestion_verbose(
+                                expr.span,
+                                "this will alter how it handles NaN; if that is a problem, use instead",
+                                format!("{local_snippet}.is_finite() || {local_snippet}.is_nan()"),
+                                Applicability::MaybeIncorrect,
+                            );
+                            diag.span_suggestion_verbose(
+                                expr.span,
+                                "or, for conciseness",
+                                format!("!{local_snippet}.is_infinite()"),
+                                Applicability::MaybeIncorrect,
+                            );
+                        }
+                    }
+                }
             );
         }
     }
diff --git a/tests/ui/manual_float_methods.fixed b/tests/ui/manual_float_methods.fixed
deleted file mode 100644
index 87a23b5a75b..00000000000
--- a/tests/ui/manual_float_methods.fixed
+++ /dev/null
@@ -1,37 +0,0 @@
-//@run-rustfix
-//@aux-build:proc_macros.rs:proc-macro
-#![allow(clippy::needless_if, unused)]
-#![warn(clippy::manual_is_infinite, clippy::manual_is_finite)]
-
-#[macro_use]
-extern crate proc_macros;
-
-const INFINITE: f32 = f32::INFINITY;
-const NEG_INFINITE: f32 = f32::NEG_INFINITY;
-
-fn main() {
-    let x = 1.0f32;
-    if x.is_infinite() {}
-    if x.is_finite() {}
-    if x.is_infinite() {}
-    if x.is_finite() {}
-    let x = 1.0f64;
-    if x.is_infinite() {}
-    if x.is_finite() {}
-    // Don't lint
-    if x.is_infinite() {}
-    if x.is_finite() {}
-    // If they're doing it this way, they probably know what they're doing
-    if x.abs() < f64::INFINITY {}
-    external! {
-        let x = 1.0;
-        if x == f32::INFINITY || x == f32::NEG_INFINITY {}
-        if x != f32::INFINITY && x != f32::NEG_INFINITY {}
-    }
-    with_span! {
-        span
-        let x = 1.0;
-        if x == f32::INFINITY || x == f32::NEG_INFINITY {}
-        if x != f32::INFINITY && x != f32::NEG_INFINITY {}
-    }
-}
diff --git a/tests/ui/manual_float_methods.rs b/tests/ui/manual_float_methods.rs
index 9255bf93418..b772202c003 100644
--- a/tests/ui/manual_float_methods.rs
+++ b/tests/ui/manual_float_methods.rs
@@ -1,4 +1,3 @@
-//@run-rustfix
 //@aux-build:proc_macros.rs:proc-macro
 #![allow(clippy::needless_if, unused)]
 #![warn(clippy::manual_is_infinite, clippy::manual_is_finite)]
diff --git a/tests/ui/manual_float_methods.stderr b/tests/ui/manual_float_methods.stderr
index 00227593a9e..7f4a4d2e95b 100644
--- a/tests/ui/manual_float_methods.stderr
+++ b/tests/ui/manual_float_methods.stderr
@@ -1,42 +1,80 @@
 error: manually checking if a float is infinite
-  --> $DIR/manual_float_methods.rs:14:8
+  --> $DIR/manual_float_methods.rs:13:8
    |
 LL |     if x == f32::INFINITY || x == f32::NEG_INFINITY {}
-   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `x.is_infinite()`
+   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the dedicated method instead: `x.is_infinite()`
    |
    = note: `-D clippy::manual-is-infinite` implied by `-D warnings`
 
 error: manually checking if a float is finite
-  --> $DIR/manual_float_methods.rs:15:8
+  --> $DIR/manual_float_methods.rs:14:8
    |
 LL |     if x != f32::INFINITY && x != f32::NEG_INFINITY {}
-   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `x.is_finite()`
+   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::manual-is-finite` implied by `-D warnings`
+help: use the dedicated method instead
+   |
+LL |     if x.is_finite() {}
+   |        ~~~~~~~~~~~~~
+help: this will alter how it handles NaN; if that is a problem, use instead
+   |
+LL |     if x.is_finite() || x.is_nan() {}
+   |        ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+help: or, for conciseness
+   |
+LL |     if !x.is_infinite() {}
+   |        ~~~~~~~~~~~~~~~~
 
 error: manually checking if a float is infinite
-  --> $DIR/manual_float_methods.rs:16:8
+  --> $DIR/manual_float_methods.rs:15:8
    |
 LL |     if x == INFINITE || x == NEG_INFINITE {}
-   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `x.is_infinite()`
+   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the dedicated method instead: `x.is_infinite()`
 
 error: manually checking if a float is finite
-  --> $DIR/manual_float_methods.rs:17:8
+  --> $DIR/manual_float_methods.rs:16:8
    |
 LL |     if x != INFINITE && x != NEG_INFINITE {}
-   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `x.is_finite()`
+   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use the dedicated method instead
+   |
+LL |     if x.is_finite() {}
+   |        ~~~~~~~~~~~~~
+help: this will alter how it handles NaN; if that is a problem, use instead
+   |
+LL |     if x.is_finite() || x.is_nan() {}
+   |        ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+help: or, for conciseness
+   |
+LL |     if !x.is_infinite() {}
+   |        ~~~~~~~~~~~~~~~~
 
 error: manually checking if a float is infinite
-  --> $DIR/manual_float_methods.rs:19:8
+  --> $DIR/manual_float_methods.rs:18:8
    |
 LL |     if x == f64::INFINITY || x == f64::NEG_INFINITY {}
-   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `x.is_infinite()`
+   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the dedicated method instead: `x.is_infinite()`
 
 error: manually checking if a float is finite
-  --> $DIR/manual_float_methods.rs:20:8
+  --> $DIR/manual_float_methods.rs:19:8
    |
 LL |     if x != f64::INFINITY && x != f64::NEG_INFINITY {}
-   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `x.is_finite()`
+   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use the dedicated method instead
+   |
+LL |     if x.is_finite() {}
+   |        ~~~~~~~~~~~~~
+help: this will alter how it handles NaN; if that is a problem, use instead
+   |
+LL |     if x.is_finite() || x.is_nan() {}
+   |        ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+help: or, for conciseness
+   |
+LL |     if !x.is_infinite() {}
+   |        ~~~~~~~~~~~~~~~~
 
 error: aborting due to 6 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 4939a716e80214edd19dab6b678fce3e769388f5 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Tue, 4 Jul 2023 16:58:02 +0000
Subject: arc_with_non_send_sync: reword and move to suspicious

---
 clippy_lints/src/arc_with_non_send_sync.rs | 71 ++++++++++++++++--------------
 tests/ui/arc_with_non_send_sync.rs         | 12 +++--
 tests/ui/arc_with_non_send_sync.stderr     | 33 +++++++++++---
 3 files changed, 73 insertions(+), 43 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/arc_with_non_send_sync.rs b/clippy_lints/src/arc_with_non_send_sync.rs
index 62313df9f90..98ee8a9a880 100644
--- a/clippy_lints/src/arc_with_non_send_sync.rs
+++ b/clippy_lints/src/arc_with_non_send_sync.rs
@@ -1,12 +1,11 @@
-use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::last_path_segment;
 use clippy_utils::ty::{implements_trait, is_type_diagnostic_item};
-use if_chain::if_chain;
-
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::LateContext;
 use rustc_lint::LateLintPass;
 use rustc_middle::ty;
+use rustc_middle::ty::print::with_forced_trimmed_paths;
 use rustc_middle::ty::GenericArgKind;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::symbol::sym;
@@ -16,8 +15,8 @@ declare_clippy_lint! {
     /// This lint warns when you use `Arc` with a type that does not implement `Send` or `Sync`.
     ///
     /// ### Why is this bad?
-    /// Wrapping a type in Arc doesn't add thread safety to the underlying data, so data races
-    /// could occur when touching the underlying data.
+    /// `Arc<T>` is only `Send`/`Sync` when `T` is [both `Send` and `Sync`](https://doc.rust-lang.org/std/sync/struct.Arc.html#impl-Send-for-Arc%3CT%3E),
+    /// either `T` should be made `Send + Sync` or an `Rc` should be used instead of an `Arc`
     ///
     /// ### Example
     /// ```rust
@@ -25,16 +24,17 @@ declare_clippy_lint! {
     /// # use std::sync::Arc;
     ///
     /// fn main() {
-    ///     // This is safe, as `i32` implements `Send` and `Sync`.
+    ///     // This is fine, as `i32` implements `Send` and `Sync`.
     ///     let a = Arc::new(42);
     ///
-    ///     // This is not safe, as `RefCell` does not implement `Sync`.
+    ///     // `RefCell` is `!Sync`, so either the `Arc` should be replaced with an `Rc`
+    ///     // or the `RefCell` replaced with something like a `RwLock`
     ///     let b = Arc::new(RefCell::new(42));
     /// }
     /// ```
     #[clippy::version = "1.72.0"]
     pub ARC_WITH_NON_SEND_SYNC,
-    correctness,
+    suspicious,
     "using `Arc` with a type that does not implement `Send` or `Sync`"
 }
 declare_lint_pass!(ArcWithNonSendSync => [ARC_WITH_NON_SEND_SYNC]);
@@ -42,35 +42,38 @@ declare_lint_pass!(ArcWithNonSendSync => [ARC_WITH_NON_SEND_SYNC]);
 impl LateLintPass<'_> for ArcWithNonSendSync {
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
         let ty = cx.typeck_results().expr_ty(expr);
-        if_chain! {
-            if is_type_diagnostic_item(cx, ty, sym::Arc);
-            if let ExprKind::Call(func, [arg]) = expr.kind;
-            if let ExprKind::Path(func_path) = func.kind;
-            if last_path_segment(&func_path).ident.name == sym::new;
-            if let arg_ty = cx.typeck_results().expr_ty(arg);
+        if is_type_diagnostic_item(cx, ty, sym::Arc)
+            && let ExprKind::Call(func, [arg]) = expr.kind
+            && let ExprKind::Path(func_path) = func.kind
+            && last_path_segment(&func_path).ident.name == sym::new
+            && let arg_ty = cx.typeck_results().expr_ty(arg)
             // make sure that the type is not and does not contain any type parameters
-            if arg_ty.walk().all(|arg| {
+            && arg_ty.walk().all(|arg| {
                 !matches!(arg.unpack(), GenericArgKind::Type(ty) if matches!(ty.kind(), ty::Param(_)))
-            });
-            if !cx.tcx
-                .lang_items()
-                .sync_trait()
-                .map_or(false, |id| implements_trait(cx, arg_ty, id, &[])) ||
-                !cx.tcx
-                .get_diagnostic_item(sym::Send)
-                .map_or(false, |id| implements_trait(cx, arg_ty, id, &[]));
+            })
+            && let Some(send) = cx.tcx.get_diagnostic_item(sym::Send)
+            && let Some(sync) = cx.tcx.lang_items().sync_trait()
+            && let [is_send, is_sync] = [send, sync].map(|id| implements_trait(cx, arg_ty, id, &[]))
+            && !(is_send && is_sync)
+        {
+            span_lint_and_then(
+                cx,
+                ARC_WITH_NON_SEND_SYNC,
+                expr.span,
+                "usage of an `Arc` that is not `Send` or `Sync`",
+                |diag| with_forced_trimmed_paths!({
+                    if !is_send {
+                        diag.note(format!("the trait `Send` is not implemented for `{arg_ty}`"));
+                    }
+                    if !is_sync {
+                        diag.note(format!("the trait `Sync` is not implemented for `{arg_ty}`"));
+                    }
+
+                    diag.note(format!("required for `{ty}` to implement `Send` and `Sync`"));
 
-            then {
-                span_lint_and_help(
-                    cx,
-                    ARC_WITH_NON_SEND_SYNC,
-                    expr.span,
-                    "usage of `Arc<T>` where `T` is not `Send` or `Sync`",
-                    None,
-                    "consider using `Rc<T>` instead or wrapping `T` in a std::sync type like \
-                    `Mutex<T>`",
-                );
-            }
+                    diag.help("consider using an `Rc` instead or wrapping the inner type with a `Mutex`");
+                }
+            ));
         }
     }
 }
diff --git a/tests/ui/arc_with_non_send_sync.rs b/tests/ui/arc_with_non_send_sync.rs
index 9d5849277c2..b6fcca0a791 100644
--- a/tests/ui/arc_with_non_send_sync.rs
+++ b/tests/ui/arc_with_non_send_sync.rs
@@ -12,9 +12,13 @@ fn issue11076<T>() {
 }
 
 fn main() {
-    // This is safe, as `i32` implements `Send` and `Sync`.
-    let a = Arc::new(42);
+    let _ = Arc::new(42);
 
-    // This is not safe, as `RefCell` does not implement `Sync`.
-    let b = Arc::new(RefCell::new(42));
+    // !Sync
+    let _ = Arc::new(RefCell::new(42));
+    let mutex = Mutex::new(1);
+    // !Send
+    let _ = Arc::new(mutex.lock().unwrap());
+    // !Send + !Sync
+    let _ = Arc::new(&42 as *const i32);
 }
diff --git a/tests/ui/arc_with_non_send_sync.stderr b/tests/ui/arc_with_non_send_sync.stderr
index 520c21b565b..7633b38dfb5 100644
--- a/tests/ui/arc_with_non_send_sync.stderr
+++ b/tests/ui/arc_with_non_send_sync.stderr
@@ -1,11 +1,34 @@
-error: usage of `Arc<T>` where `T` is not `Send` or `Sync`
-  --> $DIR/arc_with_non_send_sync.rs:19:13
+error: usage of an `Arc` that is not `Send` or `Sync`
+  --> $DIR/arc_with_non_send_sync.rs:18:13
    |
-LL |     let b = Arc::new(RefCell::new(42));
+LL |     let _ = Arc::new(RefCell::new(42));
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: consider using `Rc<T>` instead or wrapping `T` in a std::sync type like `Mutex<T>`
+   = note: the trait `Sync` is not implemented for `RefCell<i32>`
+   = note: required for `Arc<RefCell<i32>>` to implement `Send` and `Sync`
+   = help: consider using an `Rc` instead or wrapping the inner type with a `Mutex`
    = note: `-D clippy::arc-with-non-send-sync` implied by `-D warnings`
 
-error: aborting due to previous error
+error: usage of an `Arc` that is not `Send` or `Sync`
+  --> $DIR/arc_with_non_send_sync.rs:21:13
+   |
+LL |     let _ = Arc::new(mutex.lock().unwrap());
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: the trait `Send` is not implemented for `MutexGuard<'_, i32>`
+   = note: required for `Arc<MutexGuard<'_, i32>>` to implement `Send` and `Sync`
+   = help: consider using an `Rc` instead or wrapping the inner type with a `Mutex`
+
+error: usage of an `Arc` that is not `Send` or `Sync`
+  --> $DIR/arc_with_non_send_sync.rs:23:13
+   |
+LL |     let _ = Arc::new(&42 as *const i32);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: the trait `Send` is not implemented for `*const i32`
+   = note: the trait `Sync` is not implemented for `*const i32`
+   = note: required for `Arc<*const i32>` to implement `Send` and `Sync`
+   = help: consider using an `Rc` instead or wrapping the inner type with a `Mutex`
+
+error: aborting due to 3 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 5cc0c048264779509800a7b029e79454c48987a8 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Mon, 3 Jul 2023 20:24:14 +0200
Subject: [`manual_range_patterns`]: lint negative values

---
 clippy_lints/src/manual_range_patterns.rs | 19 +++++++++++--------
 tests/ui/manual_range_patterns.fixed      |  4 ++++
 tests/ui/manual_range_patterns.rs         |  4 ++++
 tests/ui/manual_range_patterns.stderr     | 16 ++++++++++++++--
 4 files changed, 33 insertions(+), 10 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_range_patterns.rs b/clippy_lints/src/manual_range_patterns.rs
index 65ff555209a..eb9576992a3 100644
--- a/clippy_lints/src/manual_range_patterns.rs
+++ b/clippy_lints/src/manual_range_patterns.rs
@@ -6,6 +6,7 @@ use rustc_hir::Expr;
 use rustc_hir::ExprKind;
 use rustc_hir::PatKind;
 use rustc_hir::RangeEnd;
+use rustc_hir::UnOp;
 use rustc_lint::LintContext;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::lint::in_external_macro;
@@ -36,11 +37,13 @@ declare_clippy_lint! {
 }
 declare_lint_pass!(ManualRangePatterns => [MANUAL_RANGE_PATTERNS]);
 
-fn expr_as_u128(expr: &Expr<'_>) -> Option<u128> {
-    if let ExprKind::Lit(lit) = expr.kind
+fn expr_as_i128(expr: &Expr<'_>) -> Option<i128> {
+    if let ExprKind::Unary(UnOp::Neg, expr) = expr.kind {
+        expr_as_i128(expr).map(|num| -num)
+    } else if let ExprKind::Lit(lit) = expr.kind
         && let LitKind::Int(num, _) = lit.node
     {
-        Some(num)
+        Some(num as i128)
     } else {
         None
     }
@@ -56,22 +59,22 @@ impl LateLintPass<'_> for ManualRangePatterns {
         if let PatKind::Or(pats) = pat.kind
             && pats.len() >= 3
         {
-            let mut min = u128::MAX;
-            let mut max = 0;
+            let mut min = i128::MAX;
+            let mut max = i128::MIN;
             let mut numbers_found = FxHashSet::default();
             let mut ranges_found = Vec::new();
 
             for pat in pats {
                 if let PatKind::Lit(lit) = pat.kind
-                    && let Some(num) = expr_as_u128(lit)
+                    && let Some(num) = expr_as_i128(lit)
                 {
                     numbers_found.insert(num);
 
                     min = min.min(num);
                     max = max.max(num);
                 } else if let PatKind::Range(Some(left), Some(right), end) = pat.kind
-                    && let Some(left) = expr_as_u128(left)
-                    && let Some(right) = expr_as_u128(right)
+                    && let Some(left) = expr_as_i128(left)
+                    && let Some(right) = expr_as_i128(right)
                     && right >= left
                 {
                     min = min.min(left);
diff --git a/tests/ui/manual_range_patterns.fixed b/tests/ui/manual_range_patterns.fixed
index 9eee8f37187..6bfcf263aa5 100644
--- a/tests/ui/manual_range_patterns.fixed
+++ b/tests/ui/manual_range_patterns.fixed
@@ -25,6 +25,10 @@ fn main() {
         1..=10 => true,
         _ => false,
     };
+    let _ = matches!(f, -5..=3);
+    let _ = matches!(f, -1 | -5 | 3 | -2 | -4 | -3 | 0 | 1); // 2 is missing
+    let _ = matches!(f, -1000001..=1000001);
+    let _ = matches!(f, -1_000_000..=1_000_000 | -1_000_001 | 1_000_002);
 
     macro_rules! mac {
         ($e:expr) => {
diff --git a/tests/ui/manual_range_patterns.rs b/tests/ui/manual_range_patterns.rs
index 10743a7d04c..4a429bb2aed 100644
--- a/tests/ui/manual_range_patterns.rs
+++ b/tests/ui/manual_range_patterns.rs
@@ -25,6 +25,10 @@ fn main() {
         1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 => true,
         _ => false,
     };
+    let _ = matches!(f, -1 | -5 | 3 | -2 | -4 | -3 | 0 | 1 | 2);
+    let _ = matches!(f, -1 | -5 | 3 | -2 | -4 | -3 | 0 | 1); // 2 is missing
+    let _ = matches!(f, -1_000_000..=1_000_000 | -1_000_001 | 1_000_001);
+    let _ = matches!(f, -1_000_000..=1_000_000 | -1_000_001 | 1_000_002);
 
     macro_rules! mac {
         ($e:expr) => {
diff --git a/tests/ui/manual_range_patterns.stderr b/tests/ui/manual_range_patterns.stderr
index bc9e3350164..b1b55d483e7 100644
--- a/tests/ui/manual_range_patterns.stderr
+++ b/tests/ui/manual_range_patterns.stderr
@@ -37,7 +37,19 @@ LL |         1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 => true,
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `1..=10`
 
 error: this OR pattern can be rewritten using a range
-  --> $DIR/manual_range_patterns.rs:31:26
+  --> $DIR/manual_range_patterns.rs:28:25
+   |
+LL |     let _ = matches!(f, -1 | -5 | 3 | -2 | -4 | -3 | 0 | 1 | 2);
+   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `-5..=3`
+
+error: this OR pattern can be rewritten using a range
+  --> $DIR/manual_range_patterns.rs:30:25
+   |
+LL |     let _ = matches!(f, -1_000_000..=1_000_000 | -1_000_001 | 1_000_001);
+   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `-1000001..=1000001`
+
+error: this OR pattern can be rewritten using a range
+  --> $DIR/manual_range_patterns.rs:35:26
    |
 LL |             matches!($e, 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10)
    |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `1..=10`
@@ -47,5 +59,5 @@ LL |     mac!(f);
    |
    = note: this error originates in the macro `mac` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to 7 previous errors
+error: aborting due to 9 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From c927912c5bc7aa511ca70e5c3786fa0ac8442774 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Thu, 6 Jul 2023 17:05:26 +0200
Subject: [`manual_range_patterns`]: document what range we don't lint

---
 clippy_lints/src/manual_range_patterns.rs | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_range_patterns.rs b/clippy_lints/src/manual_range_patterns.rs
index eb9576992a3..64d4c8e4566 100644
--- a/clippy_lints/src/manual_range_patterns.rs
+++ b/clippy_lints/src/manual_range_patterns.rs
@@ -20,6 +20,10 @@ declare_clippy_lint! {
     /// ### Why is this bad?
     /// Using an explicit range is more concise and easier to read.
     ///
+    /// ### Known issues
+    /// This lint intentionally does not handle numbers greater than `i128::MAX` for `u128` literals
+    /// in order to support negative numbers.
+    ///
     /// ### Example
     /// ```rust
     /// let x = 6;
@@ -43,7 +47,8 @@ fn expr_as_i128(expr: &Expr<'_>) -> Option<i128> {
     } else if let ExprKind::Lit(lit) = expr.kind
         && let LitKind::Int(num, _) = lit.node
     {
-        Some(num as i128)
+        // Intentionally not handling numbers greater than i128::MAX (for u128 literals) for now.
+        num.try_into().ok()
     } else {
         None
     }
-- 
cgit 1.4.1-3-g733a5


From 5df1f6681dca1a2028a4e6b60d3ab789c00b4cf8 Mon Sep 17 00:00:00 2001
From: Nilstrieb <48135649+Nilstrieb@users.noreply.github.com>
Date: Fri, 7 Jul 2023 20:28:51 +0200
Subject: Pass correct substs to `implements_trait` in `incorrect_impls`

`Copy<T>` does in fact not exist. The substs on the trait_ref contain
the `Self` type of the impl as the first parameter, so passing that
to `implements_trait`, which then nicely prepends the `Self` type
for us does not end will.
---
 clippy_lints/src/incorrect_impls.rs | 10 +++-------
 1 file changed, 3 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/incorrect_impls.rs b/clippy_lints/src/incorrect_impls.rs
index 13cc0b23ba3..ed21df4ff88 100644
--- a/clippy_lints/src/incorrect_impls.rs
+++ b/clippy_lints/src/incorrect_impls.rs
@@ -1,7 +1,6 @@
 use clippy_utils::{diagnostics::span_lint_and_sugg, get_parent_node, last_path_segment, ty::implements_trait};
 use rustc_errors::Applicability;
-use rustc_hir::{ExprKind, ImplItem, ImplItemKind, ItemKind, Node, UnOp};
-use rustc_hir_analysis::hir_ty_to_ty;
+use rustc_hir::{ExprKind, ImplItem, ImplItemKind, Node, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::EarlyBinder;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -55,9 +54,6 @@ impl LateLintPass<'_> for IncorrectImpls {
         let Some(Node::Item(item)) = node else {
             return;
         };
-        let ItemKind::Impl(imp) = item.kind else {
-            return;
-        };
         let Some(trait_impl) = cx.tcx.impl_trait_ref(item.owner_id).map(EarlyBinder::skip_binder) else {
             return;
         };
@@ -80,9 +76,9 @@ impl LateLintPass<'_> for IncorrectImpls {
             && let Some(copy_def_id) = cx.tcx.get_diagnostic_item(sym::Copy)
             && implements_trait(
                     cx,
-                    hir_ty_to_ty(cx.tcx, imp.self_ty),
+                    trait_impl.self_ty(),
                     copy_def_id,
-                    trait_impl.substs,
+                    &[],
                 )
         {
             if impl_item.ident.name == sym::clone {
-- 
cgit 1.4.1-3-g733a5


From 2a1fd22f81fd1222a5ceaa554e41095dec34f785 Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Mon, 15 May 2023 16:50:28 -0500
Subject: implement `manual_partial_ord_impl`

first try at this
---
 CHANGELOG.md                                |   1 +
 clippy_lints/src/declared_lints.rs          |   1 +
 clippy_lints/src/lib.rs                     |   1 +
 clippy_lints/src/manual_partial_ord_impl.rs | 132 ++++++++++++++++++++++++++++
 tests/ui/manual_partial_ord_impl.rs         |  57 ++++++++++++
 tests/ui/manual_partial_ord_impl.stderr     |  28 ++++++
 6 files changed, 220 insertions(+)
 create mode 100644 clippy_lints/src/manual_partial_ord_impl.rs
 create mode 100644 tests/ui/manual_partial_ord_impl.rs
 create mode 100644 tests/ui/manual_partial_ord_impl.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index da070adb808..840a46aa83a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4921,6 +4921,7 @@ Released 2018-09-13
 [`manual_next_back`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_next_back
 [`manual_non_exhaustive`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_non_exhaustive
 [`manual_ok_or`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_ok_or
+[`manual_partial_ord_impl`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_partial_ord_impl
 [`manual_range_contains`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_range_contains
 [`manual_range_patterns`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_range_patterns
 [`manual_rem_euclid`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_rem_euclid
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index ca97db04079..7764dd7391f 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -277,6 +277,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::manual_let_else::MANUAL_LET_ELSE_INFO,
     crate::manual_main_separator_str::MANUAL_MAIN_SEPARATOR_STR_INFO,
     crate::manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE_INFO,
+    crate::manual_partial_ord_impl::MANUAL_PARTIAL_ORD_IMPL_INFO,
     crate::manual_range_patterns::MANUAL_RANGE_PATTERNS_INFO,
     crate::manual_rem_euclid::MANUAL_REM_EUCLID_INFO,
     crate::manual_retain::MANUAL_RETAIN_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 00d46025caa..36a0cf860d7 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -188,6 +188,7 @@ mod manual_is_ascii_check;
 mod manual_let_else;
 mod manual_main_separator_str;
 mod manual_non_exhaustive;
+mod manual_partial_ord_impl;
 mod manual_range_patterns;
 mod manual_rem_euclid;
 mod manual_retain;
diff --git a/clippy_lints/src/manual_partial_ord_impl.rs b/clippy_lints/src/manual_partial_ord_impl.rs
new file mode 100644
index 00000000000..4c43b5e52e8
--- /dev/null
+++ b/clippy_lints/src/manual_partial_ord_impl.rs
@@ -0,0 +1,132 @@
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::{
+    def_path_def_ids, diagnostics::span_lint_and_sugg, get_trait_def_id, match_def_path, path_res, ty::implements_trait,
+};
+use rustc_errors::Applicability;
+use rustc_hir::def::Res;
+use rustc_hir::*;
+use rustc_hir_analysis::hir_ty_to_ty;
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::def_id::DefId;
+use std::cell::OnceCell;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for manual implementations of both `PartialOrd` and `Ord` when only `Ord` is
+    /// necessary.
+    ///
+    /// ### Why is this bad?
+    /// If both `PartialOrd` and `Ord` are implemented, `PartialOrd` will wrap the returned value of
+    /// `Ord::cmp` in `Some`. Not doing this may silently introduce an error.
+    ///
+    /// ### Example
+    /// ```rust
+    /// #[derive(Eq, PartialEq)]
+    /// struct A(u32);
+    ///
+    /// impl Ord for A {
+    ///     fn cmp(&self, other: &Self) -> Ordering {
+    ///         todo!();
+    ///     }
+    /// }
+    /// 
+    /// impl PartialOrd for A {
+    ///     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+    ///         todo!();
+    ///     }
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// #[derive(Eq, PartialEq)]
+    /// struct A(u32);
+    ///
+    /// impl Ord for A {
+    ///     fn cmp(&self, other: &Self) -> Ordering {
+    ///         todo!();
+    ///     }
+    /// }
+    /// 
+    /// impl PartialOrd for A {
+    ///     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+    ///         Some(self.cmp(other))
+    ///     }
+    /// }
+    /// ```
+    #[clippy::version = "1.71.0"]
+    pub MANUAL_PARTIAL_ORD_IMPL,
+    nursery,
+    "default lint description"
+}
+impl_lint_pass!(ManualPartialOrdImpl => [MANUAL_PARTIAL_ORD_IMPL]);
+
+#[derive(Clone)]
+pub struct ManualPartialOrdImpl {
+    pub ord_def_id: OnceCell<DefId>,
+}
+
+impl LateLintPass<'_> for ManualPartialOrdImpl {
+    fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
+        if_chain! {
+            if let ItemKind::Impl(imp) = &item.kind;
+            if let Some(impl_trait_ref) = cx.tcx.impl_trait_ref(item.owner_id);
+            if cx.tcx.is_diagnostic_item(sym!(PartialOrd), impl_trait_ref.skip_binder().def_id);
+            then {
+                lint_impl_body(self, cx, imp, item);
+            }
+        }
+    }
+}
+
+fn lint_impl_body(conf: &mut ManualPartialOrdImpl, cx: &LateContext<'_>, imp: &Impl<'_>, item: &Item<'_>) {
+    for imp_item in imp.items {
+        if_chain! {
+            if imp_item.ident.name == sym!(partial_cmp);
+            if let ImplItemKind::Fn(_, id) = cx.tcx.hir().impl_item(imp_item.id).kind;
+            then {
+                let body = cx.tcx.hir().body(id);
+                let ord_def_id = conf.ord_def_id.get_or_init(|| get_trait_def_id(cx, &["core", "cmp", "Ord"]).unwrap());
+                if let ExprKind::Block(block, ..)
+                    = body.value.kind && implements_trait(cx, hir_ty_to_ty(cx.tcx, imp.self_ty), *ord_def_id, &[])
+                {
+                    if_chain! {
+                        if block.stmts.is_empty();
+                        if let Some(expr) = block.expr;
+                        if let ExprKind::Call(Expr { kind: ExprKind::Path(path), ..}, [cmp_expr]) = expr.kind;
+                        if let QPath::Resolved(_, some_path) = path;
+                        if let Some(some_seg_one) = some_path.segments.get(0);
+                        if some_seg_one.ident.name == sym!(Some);
+                        if let ExprKind::MethodCall(cmp_path, _, [other_expr], ..) = cmp_expr.kind;
+                        if cmp_path.ident.name == sym!(cmp);
+                        if let Res::Local(..) = path_res(cx, other_expr);
+                        then {}
+                        else {
+                            span_lint_and_then(
+                                cx,
+                                MANUAL_PARTIAL_ORD_IMPL,
+                                item.span,
+                                "manual implementation of `PartialOrd` when `Ord` is already implemented",
+                                |diag| {
+                                    if let Some(param) = body.params.get(1)
+                                        && let PatKind::Binding(_, _, param_ident, ..) = param.pat.kind
+                                    {
+                                        diag.span_suggestion(
+                                            block.span,
+                                            "change this to",
+                                            format!("{{ Some(self.cmp({})) }}",
+                                            param_ident.name),
+                                            Applicability::MaybeIncorrect
+                                        );
+                                    } else {
+                                        diag.help("return the value of `self.cmp` wrapped in `Some` instead");
+                                    };
+                                }
+                            );
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/tests/ui/manual_partial_ord_impl.rs b/tests/ui/manual_partial_ord_impl.rs
new file mode 100644
index 00000000000..9e2c7e2ec51
--- /dev/null
+++ b/tests/ui/manual_partial_ord_impl.rs
@@ -0,0 +1,57 @@
+#![allow(unused)]
+#![warn(clippy::manual_partial_ord_impl)]
+#![no_main]
+
+use std::cmp::Ordering;
+
+// lint
+
+#[derive(Eq, PartialEq)]
+struct A(u32);
+
+impl Ord for A {
+    fn cmp(&self, other: &Self) -> Ordering {
+        todo!();
+    }
+}
+
+impl PartialOrd for A {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        todo!();
+    }
+}
+
+// do not lint
+
+#[derive(Eq, PartialEq)]
+struct B(u32);
+
+impl Ord for B {
+    fn cmp(&self, other: &Self) -> Ordering {
+        todo!();
+    }
+}
+
+impl PartialOrd for B {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+// lint, but we cannot give a suggestion since &Self is not named
+
+#[derive(Eq, PartialEq)]
+struct C(u32);
+
+impl Ord for C {
+    fn cmp(&self, other: &Self) -> Ordering {
+        todo!();
+    }
+}
+
+impl PartialOrd for C {
+    fn partial_cmp(&self, _: &Self) -> Option<Ordering> {
+        todo!();
+    }
+}
+
diff --git a/tests/ui/manual_partial_ord_impl.stderr b/tests/ui/manual_partial_ord_impl.stderr
new file mode 100644
index 00000000000..100ddb46e82
--- /dev/null
+++ b/tests/ui/manual_partial_ord_impl.stderr
@@ -0,0 +1,28 @@
+error: manual implementation of `PartialOrd` when `Ord` is already implemented
+  --> $DIR/manual_partial_ord_impl.rs:18:1
+   |
+LL | /  impl PartialOrd for A {
+LL | |      fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+   | | _____________________________________________________________-
+LL | ||         todo!();
+LL | ||     }
+   | ||_____- help: change this to: `{ Some(self.cmp(other)) }`
+LL | |  }
+   | |__^
+   |
+   = note: `-D clippy::manual-partial-ord-impl` implied by `-D warnings`
+
+error: manual implementation of `PartialOrd` when `Ord` is already implemented
+  --> $DIR/manual_partial_ord_impl.rs:52:1
+   |
+LL | / impl PartialOrd for C {
+LL | |     fn partial_cmp(&self, _: &Self) -> Option<Ordering> {
+LL | |         todo!();
+LL | |     }
+LL | | }
+   | |_^
+   |
+   = help: return the value of `self.cmp` wrapped in `Some` instead
+
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 004e89d4cfde749e9cb33d5ac26bdbe3001a1f3d Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Mon, 15 May 2023 18:41:41 -0500
Subject: rename to `manual_partial_ord_and_ord_impl`

cargo dev fmt

cargo test passes

cargo test passes

refactor a lil

Update bool_comparison.stderr

heavily refactor + bump `clippy::version`

refactor

refactor

check bounds to increase accuracy, and add todos
---
 CHANGELOG.md                                |   2 +-
 clippy_lints/src/declared_lints.rs          |   2 +-
 clippy_lints/src/lib.rs                     |   2 +-
 clippy_lints/src/manual_partial_ord_impl.rs | 132 -------------------------
 clippy_lints/src/needless_impls.rs          | 145 ++++++++++++++++++++++++++++
 tests/ui/bool_comparison.fixed              |   1 +
 tests/ui/bool_comparison.rs                 |   1 +
 tests/ui/bool_comparison.stderr             |  44 ++++-----
 tests/ui/derive_ord_xor_partial_ord.rs      |   1 +
 tests/ui/derive_ord_xor_partial_ord.stderr  |  16 +--
 tests/ui/manual_partial_ord_impl.rs         |  57 -----------
 tests/ui/manual_partial_ord_impl.stderr     |  28 ------
 tests/ui/needless_partial_ord_impl.fixed    |  85 ++++++++++++++++
 tests/ui/needless_partial_ord_impl.rs       |  89 +++++++++++++++++
 tests/ui/needless_partial_ord_impl.stderr   |  28 ++++++
 15 files changed, 383 insertions(+), 250 deletions(-)
 delete mode 100644 clippy_lints/src/manual_partial_ord_impl.rs
 create mode 100644 clippy_lints/src/needless_impls.rs
 delete mode 100644 tests/ui/manual_partial_ord_impl.rs
 delete mode 100644 tests/ui/manual_partial_ord_impl.stderr
 create mode 100644 tests/ui/needless_partial_ord_impl.fixed
 create mode 100644 tests/ui/needless_partial_ord_impl.rs
 create mode 100644 tests/ui/needless_partial_ord_impl.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 840a46aa83a..fea11bba63f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4921,7 +4921,6 @@ Released 2018-09-13
 [`manual_next_back`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_next_back
 [`manual_non_exhaustive`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_non_exhaustive
 [`manual_ok_or`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_ok_or
-[`manual_partial_ord_impl`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_partial_ord_impl
 [`manual_range_contains`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_range_contains
 [`manual_range_patterns`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_range_patterns
 [`manual_rem_euclid`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_rem_euclid
@@ -5021,6 +5020,7 @@ Released 2018-09-13
 [`needless_option_as_deref`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_option_as_deref
 [`needless_option_take`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_option_take
 [`needless_parens_on_range_literals`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_parens_on_range_literals
+[`needless_partial_ord_impl`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_partial_ord_impl
 [`needless_pass_by_value`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_pass_by_value
 [`needless_pub_self`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_pub_self
 [`needless_question_mark`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_question_mark
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 7764dd7391f..a2231b8fb1d 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -277,7 +277,6 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::manual_let_else::MANUAL_LET_ELSE_INFO,
     crate::manual_main_separator_str::MANUAL_MAIN_SEPARATOR_STR_INFO,
     crate::manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE_INFO,
-    crate::manual_partial_ord_impl::MANUAL_PARTIAL_ORD_IMPL_INFO,
     crate::manual_range_patterns::MANUAL_RANGE_PATTERNS_INFO,
     crate::manual_rem_euclid::MANUAL_REM_EUCLID_INFO,
     crate::manual_retain::MANUAL_RETAIN_INFO,
@@ -470,6 +469,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::needless_else::NEEDLESS_ELSE_INFO,
     crate::needless_for_each::NEEDLESS_FOR_EACH_INFO,
     crate::needless_if::NEEDLESS_IF_INFO,
+    crate::needless_impls::NEEDLESS_PARTIAL_ORD_IMPL_INFO,
     crate::needless_late_init::NEEDLESS_LATE_INIT_INFO,
     crate::needless_parens_on_range_literals::NEEDLESS_PARENS_ON_RANGE_LITERALS_INFO,
     crate::needless_pass_by_value::NEEDLESS_PASS_BY_VALUE_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 36a0cf860d7..1ec5b2e8b0a 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -188,7 +188,6 @@ mod manual_is_ascii_check;
 mod manual_let_else;
 mod manual_main_separator_str;
 mod manual_non_exhaustive;
-mod manual_partial_ord_impl;
 mod manual_range_patterns;
 mod manual_rem_euclid;
 mod manual_retain;
@@ -228,6 +227,7 @@ mod needless_continue;
 mod needless_else;
 mod needless_for_each;
 mod needless_if;
+mod needless_impls;
 mod needless_late_init;
 mod needless_parens_on_range_literals;
 mod needless_pass_by_value;
diff --git a/clippy_lints/src/manual_partial_ord_impl.rs b/clippy_lints/src/manual_partial_ord_impl.rs
deleted file mode 100644
index 4c43b5e52e8..00000000000
--- a/clippy_lints/src/manual_partial_ord_impl.rs
+++ /dev/null
@@ -1,132 +0,0 @@
-use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::{
-    def_path_def_ids, diagnostics::span_lint_and_sugg, get_trait_def_id, match_def_path, path_res, ty::implements_trait,
-};
-use rustc_errors::Applicability;
-use rustc_hir::def::Res;
-use rustc_hir::*;
-use rustc_hir_analysis::hir_ty_to_ty;
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::def_id::DefId;
-use std::cell::OnceCell;
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for manual implementations of both `PartialOrd` and `Ord` when only `Ord` is
-    /// necessary.
-    ///
-    /// ### Why is this bad?
-    /// If both `PartialOrd` and `Ord` are implemented, `PartialOrd` will wrap the returned value of
-    /// `Ord::cmp` in `Some`. Not doing this may silently introduce an error.
-    ///
-    /// ### Example
-    /// ```rust
-    /// #[derive(Eq, PartialEq)]
-    /// struct A(u32);
-    ///
-    /// impl Ord for A {
-    ///     fn cmp(&self, other: &Self) -> Ordering {
-    ///         todo!();
-    ///     }
-    /// }
-    /// 
-    /// impl PartialOrd for A {
-    ///     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-    ///         todo!();
-    ///     }
-    /// }
-    /// ```
-    /// Use instead:
-    /// ```rust
-    /// #[derive(Eq, PartialEq)]
-    /// struct A(u32);
-    ///
-    /// impl Ord for A {
-    ///     fn cmp(&self, other: &Self) -> Ordering {
-    ///         todo!();
-    ///     }
-    /// }
-    /// 
-    /// impl PartialOrd for A {
-    ///     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-    ///         Some(self.cmp(other))
-    ///     }
-    /// }
-    /// ```
-    #[clippy::version = "1.71.0"]
-    pub MANUAL_PARTIAL_ORD_IMPL,
-    nursery,
-    "default lint description"
-}
-impl_lint_pass!(ManualPartialOrdImpl => [MANUAL_PARTIAL_ORD_IMPL]);
-
-#[derive(Clone)]
-pub struct ManualPartialOrdImpl {
-    pub ord_def_id: OnceCell<DefId>,
-}
-
-impl LateLintPass<'_> for ManualPartialOrdImpl {
-    fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
-        if_chain! {
-            if let ItemKind::Impl(imp) = &item.kind;
-            if let Some(impl_trait_ref) = cx.tcx.impl_trait_ref(item.owner_id);
-            if cx.tcx.is_diagnostic_item(sym!(PartialOrd), impl_trait_ref.skip_binder().def_id);
-            then {
-                lint_impl_body(self, cx, imp, item);
-            }
-        }
-    }
-}
-
-fn lint_impl_body(conf: &mut ManualPartialOrdImpl, cx: &LateContext<'_>, imp: &Impl<'_>, item: &Item<'_>) {
-    for imp_item in imp.items {
-        if_chain! {
-            if imp_item.ident.name == sym!(partial_cmp);
-            if let ImplItemKind::Fn(_, id) = cx.tcx.hir().impl_item(imp_item.id).kind;
-            then {
-                let body = cx.tcx.hir().body(id);
-                let ord_def_id = conf.ord_def_id.get_or_init(|| get_trait_def_id(cx, &["core", "cmp", "Ord"]).unwrap());
-                if let ExprKind::Block(block, ..)
-                    = body.value.kind && implements_trait(cx, hir_ty_to_ty(cx.tcx, imp.self_ty), *ord_def_id, &[])
-                {
-                    if_chain! {
-                        if block.stmts.is_empty();
-                        if let Some(expr) = block.expr;
-                        if let ExprKind::Call(Expr { kind: ExprKind::Path(path), ..}, [cmp_expr]) = expr.kind;
-                        if let QPath::Resolved(_, some_path) = path;
-                        if let Some(some_seg_one) = some_path.segments.get(0);
-                        if some_seg_one.ident.name == sym!(Some);
-                        if let ExprKind::MethodCall(cmp_path, _, [other_expr], ..) = cmp_expr.kind;
-                        if cmp_path.ident.name == sym!(cmp);
-                        if let Res::Local(..) = path_res(cx, other_expr);
-                        then {}
-                        else {
-                            span_lint_and_then(
-                                cx,
-                                MANUAL_PARTIAL_ORD_IMPL,
-                                item.span,
-                                "manual implementation of `PartialOrd` when `Ord` is already implemented",
-                                |diag| {
-                                    if let Some(param) = body.params.get(1)
-                                        && let PatKind::Binding(_, _, param_ident, ..) = param.pat.kind
-                                    {
-                                        diag.span_suggestion(
-                                            block.span,
-                                            "change this to",
-                                            format!("{{ Some(self.cmp({})) }}",
-                                            param_ident.name),
-                                            Applicability::MaybeIncorrect
-                                        );
-                                    } else {
-                                        diag.help("return the value of `self.cmp` wrapped in `Some` instead");
-                                    };
-                                }
-                            );
-                        }
-                    }
-                }
-            }
-        }
-    }
-}
diff --git a/clippy_lints/src/needless_impls.rs b/clippy_lints/src/needless_impls.rs
new file mode 100644
index 00000000000..4f8741bf370
--- /dev/null
+++ b/clippy_lints/src/needless_impls.rs
@@ -0,0 +1,145 @@
+use clippy_utils::{
+    diagnostics::span_lint_and_then, get_parent_node, is_res_lang_ctor, path_res, ty::implements_trait,
+};
+use rustc_errors::Applicability;
+use rustc_hir::{def::Res, Expr, ExprKind, ImplItem, ImplItemKind, ItemKind, LangItem, Node, PatKind};
+use rustc_hir_analysis::hir_ty_to_ty;
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::EarlyBinder;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::sym;
+use std::borrow::Cow;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for manual implementations of both `PartialOrd` and `Ord` when only `Ord` is
+    /// necessary.
+    ///
+    /// ### Why is this bad?
+    /// If both `PartialOrd` and `Ord` are implemented, they must agree. This is commonly done by
+    /// wrapping the result of `cmp` in `Some` for `partial_cmp`. Not doing this may silently
+    /// introduce an error upon refactoring.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// #[derive(Eq, PartialEq)]
+    /// struct A(u32);
+    ///
+    /// impl Ord for A {
+    ///     fn cmp(&self, other: &Self) -> Ordering {
+    ///         todo!();
+    ///     }
+    /// }
+    ///
+    /// impl PartialOrd for A {
+    ///     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+    ///         todo!();
+    ///     }
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust,ignore
+    /// #[derive(Eq, PartialEq)]
+    /// struct A(u32);
+    ///
+    /// impl Ord for A {
+    ///     fn cmp(&self, other: &Self) -> Ordering {
+    ///         todo!();
+    ///     }
+    /// }
+    ///
+    /// impl PartialOrd for A {
+    ///     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+    ///         Some(self.cmp(other))
+    ///     }
+    /// }
+    /// ```
+    #[clippy::version = "1.72.0"]
+    pub NEEDLESS_PARTIAL_ORD_IMPL,
+    correctness,
+    "manual implementation of `PartialOrd` when `Ord` is already implemented"
+}
+declare_lint_pass!(NeedlessImpls => [NEEDLESS_PARTIAL_ORD_IMPL]);
+
+impl LateLintPass<'_> for NeedlessImpls {
+    fn check_impl_item(&mut self, cx: &LateContext<'_>, impl_item: &ImplItem<'_>) {
+        let node = get_parent_node(cx.tcx, impl_item.hir_id());
+        let Some(Node::Item(item)) = node else {
+            return;
+        };
+        let ItemKind::Impl(imp) = item.kind else {
+            return;
+        };
+        let Some(trait_impl) = cx.tcx.impl_trait_ref(item.owner_id).map(EarlyBinder::skip_binder) else {
+            return;
+        };
+        let trait_impl_def_id = trait_impl.def_id;
+        if cx.tcx.is_automatically_derived(item.owner_id.to_def_id()) {
+            return;
+        }
+        let ImplItemKind::Fn(_, impl_item_id) = cx.tcx.hir().impl_item(impl_item.impl_item_id()).kind else {
+            return;
+        };
+        let body = cx.tcx.hir().body(impl_item_id);
+        let ExprKind::Block(block, ..) = body.value.kind else {
+            return;
+        };
+
+        if cx.tcx.is_diagnostic_item(sym::PartialOrd, trait_impl_def_id)
+            && impl_item.ident.name == sym::partial_cmp
+            && let Some(ord_def_id) = cx
+                .tcx
+                .diagnostic_items(trait_impl.def_id.krate)
+                .name_to_id
+                .get(&sym::Ord)
+            && implements_trait(
+                    cx,
+                    hir_ty_to_ty(cx.tcx, imp.self_ty),
+                    *ord_def_id,
+                    trait_impl.substs,
+                )
+        {
+            if block.stmts.is_empty()
+                && let Some(expr) = block.expr
+                && let ExprKind::Call(
+                        Expr {
+                            kind: ExprKind::Path(some_path),
+                            hir_id: some_hir_id,
+                            ..
+                        },
+                        [cmp_expr],
+                    ) = expr.kind
+                && is_res_lang_ctor(cx, cx.qpath_res(some_path, *some_hir_id), LangItem::OptionSome)
+                && let ExprKind::MethodCall(cmp_path, _, [other_expr], ..) = cmp_expr.kind
+                && cmp_path.ident.name == sym::cmp
+                && let Res::Local(..) = path_res(cx, other_expr)
+            {} else {
+                span_lint_and_then(
+                    cx,
+                    NEEDLESS_PARTIAL_ORD_IMPL,
+                    item.span,
+                    "manual implementation of `PartialOrd` when `Ord` is already implemented",
+                    |diag| {
+                        let (help, app) = if let Some(other) = body.params.get(0)
+                            && let PatKind::Binding(_, _, other_ident, ..) = other.pat.kind
+                        {
+                            (
+                                Cow::Owned(format!("{{ Some(self.cmp({})) }}", other_ident.name)),
+                                Applicability::Unspecified,
+                            )
+                        } else {
+                            (Cow::Borrowed("{ Some(self.cmp(...)) }"), Applicability::HasPlaceholders)
+                        };
+
+                        diag.span_suggestion(
+                            block.span,
+                            "change this to",
+                            help,
+                            app,
+                        );
+                    }
+                );
+            }
+        }
+    }
+}
diff --git a/tests/ui/bool_comparison.fixed b/tests/ui/bool_comparison.fixed
index d6774c03598..33221c7777e 100644
--- a/tests/ui/bool_comparison.fixed
+++ b/tests/ui/bool_comparison.fixed
@@ -2,6 +2,7 @@
 
 #![allow(clippy::needless_if)]
 #![warn(clippy::bool_comparison)]
+#![allow(clippy::needless_partial_ord_impl)]
 
 fn main() {
     let x = true;
diff --git a/tests/ui/bool_comparison.rs b/tests/ui/bool_comparison.rs
index c0483fd7374..5f909bd2a53 100644
--- a/tests/ui/bool_comparison.rs
+++ b/tests/ui/bool_comparison.rs
@@ -2,6 +2,7 @@
 
 #![allow(clippy::needless_if)]
 #![warn(clippy::bool_comparison)]
+#![allow(clippy::needless_partial_ord_impl)]
 
 fn main() {
     let x = true;
diff --git a/tests/ui/bool_comparison.stderr b/tests/ui/bool_comparison.stderr
index f4dded365fb..19bdf301358 100644
--- a/tests/ui/bool_comparison.stderr
+++ b/tests/ui/bool_comparison.stderr
@@ -1,5 +1,5 @@
 error: equality checks against true are unnecessary
-  --> $DIR/bool_comparison.rs:8:8
+  --> $DIR/bool_comparison.rs:9:8
    |
 LL |     if x == true {
    |        ^^^^^^^^^ help: try simplifying it as shown: `x`
@@ -7,127 +7,127 @@ LL |     if x == true {
    = note: `-D clippy::bool-comparison` implied by `-D warnings`
 
 error: equality checks against false can be replaced by a negation
-  --> $DIR/bool_comparison.rs:13:8
+  --> $DIR/bool_comparison.rs:14:8
    |
 LL |     if x == false {
    |        ^^^^^^^^^^ help: try simplifying it as shown: `!x`
 
 error: equality checks against true are unnecessary
-  --> $DIR/bool_comparison.rs:18:8
+  --> $DIR/bool_comparison.rs:19:8
    |
 LL |     if true == x {
    |        ^^^^^^^^^ help: try simplifying it as shown: `x`
 
 error: equality checks against false can be replaced by a negation
-  --> $DIR/bool_comparison.rs:23:8
+  --> $DIR/bool_comparison.rs:24:8
    |
 LL |     if false == x {
    |        ^^^^^^^^^^ help: try simplifying it as shown: `!x`
 
 error: inequality checks against true can be replaced by a negation
-  --> $DIR/bool_comparison.rs:28:8
+  --> $DIR/bool_comparison.rs:29:8
    |
 LL |     if x != true {
    |        ^^^^^^^^^ help: try simplifying it as shown: `!x`
 
 error: inequality checks against false are unnecessary
-  --> $DIR/bool_comparison.rs:33:8
+  --> $DIR/bool_comparison.rs:34:8
    |
 LL |     if x != false {
    |        ^^^^^^^^^^ help: try simplifying it as shown: `x`
 
 error: inequality checks against true can be replaced by a negation
-  --> $DIR/bool_comparison.rs:38:8
+  --> $DIR/bool_comparison.rs:39:8
    |
 LL |     if true != x {
    |        ^^^^^^^^^ help: try simplifying it as shown: `!x`
 
 error: inequality checks against false are unnecessary
-  --> $DIR/bool_comparison.rs:43:8
+  --> $DIR/bool_comparison.rs:44:8
    |
 LL |     if false != x {
    |        ^^^^^^^^^^ help: try simplifying it as shown: `x`
 
 error: less than comparison against true can be replaced by a negation
-  --> $DIR/bool_comparison.rs:48:8
+  --> $DIR/bool_comparison.rs:49:8
    |
 LL |     if x < true {
    |        ^^^^^^^^ help: try simplifying it as shown: `!x`
 
 error: greater than checks against false are unnecessary
-  --> $DIR/bool_comparison.rs:53:8
+  --> $DIR/bool_comparison.rs:54:8
    |
 LL |     if false < x {
    |        ^^^^^^^^^ help: try simplifying it as shown: `x`
 
 error: greater than checks against false are unnecessary
-  --> $DIR/bool_comparison.rs:58:8
+  --> $DIR/bool_comparison.rs:59:8
    |
 LL |     if x > false {
    |        ^^^^^^^^^ help: try simplifying it as shown: `x`
 
 error: less than comparison against true can be replaced by a negation
-  --> $DIR/bool_comparison.rs:63:8
+  --> $DIR/bool_comparison.rs:64:8
    |
 LL |     if true > x {
    |        ^^^^^^^^ help: try simplifying it as shown: `!x`
 
 error: order comparisons between booleans can be simplified
-  --> $DIR/bool_comparison.rs:69:8
+  --> $DIR/bool_comparison.rs:70:8
    |
 LL |     if x < y {
    |        ^^^^^ help: try simplifying it as shown: `!x & y`
 
 error: order comparisons between booleans can be simplified
-  --> $DIR/bool_comparison.rs:74:8
+  --> $DIR/bool_comparison.rs:75:8
    |
 LL |     if x > y {
    |        ^^^^^ help: try simplifying it as shown: `x & !y`
 
 error: this comparison might be written more concisely
-  --> $DIR/bool_comparison.rs:122:8
+  --> $DIR/bool_comparison.rs:123:8
    |
 LL |     if a == !b {};
    |        ^^^^^^^ help: try simplifying it as shown: `a != b`
 
 error: this comparison might be written more concisely
-  --> $DIR/bool_comparison.rs:123:8
+  --> $DIR/bool_comparison.rs:124:8
    |
 LL |     if !a == b {};
    |        ^^^^^^^ help: try simplifying it as shown: `a != b`
 
 error: this comparison might be written more concisely
-  --> $DIR/bool_comparison.rs:127:8
+  --> $DIR/bool_comparison.rs:128:8
    |
 LL |     if b == !a {};
    |        ^^^^^^^ help: try simplifying it as shown: `b != a`
 
 error: this comparison might be written more concisely
-  --> $DIR/bool_comparison.rs:128:8
+  --> $DIR/bool_comparison.rs:129:8
    |
 LL |     if !b == a {};
    |        ^^^^^^^ help: try simplifying it as shown: `b != a`
 
 error: equality checks against false can be replaced by a negation
-  --> $DIR/bool_comparison.rs:152:8
+  --> $DIR/bool_comparison.rs:153:8
    |
 LL |     if false == m!(func) {}
    |        ^^^^^^^^^^^^^^^^^ help: try simplifying it as shown: `!m!(func)`
 
 error: equality checks against false can be replaced by a negation
-  --> $DIR/bool_comparison.rs:153:8
+  --> $DIR/bool_comparison.rs:154:8
    |
 LL |     if m!(func) == false {}
    |        ^^^^^^^^^^^^^^^^^ help: try simplifying it as shown: `!m!(func)`
 
 error: equality checks against true are unnecessary
-  --> $DIR/bool_comparison.rs:154:8
+  --> $DIR/bool_comparison.rs:155:8
    |
 LL |     if true == m!(func) {}
    |        ^^^^^^^^^^^^^^^^ help: try simplifying it as shown: `m!(func)`
 
 error: equality checks against true are unnecessary
-  --> $DIR/bool_comparison.rs:155:8
+  --> $DIR/bool_comparison.rs:156:8
    |
 LL |     if m!(func) == true {}
    |        ^^^^^^^^^^^^^^^^ help: try simplifying it as shown: `m!(func)`
diff --git a/tests/ui/derive_ord_xor_partial_ord.rs b/tests/ui/derive_ord_xor_partial_ord.rs
index 6f12d36d777..5d1a693321e 100644
--- a/tests/ui/derive_ord_xor_partial_ord.rs
+++ b/tests/ui/derive_ord_xor_partial_ord.rs
@@ -1,5 +1,6 @@
 #![warn(clippy::derive_ord_xor_partial_ord)]
 #![allow(clippy::unnecessary_wraps)]
+#![allow(clippy::needless_partial_ord_impl)]
 
 use std::cmp::Ordering;
 
diff --git a/tests/ui/derive_ord_xor_partial_ord.stderr b/tests/ui/derive_ord_xor_partial_ord.stderr
index 58efbb8541f..bd148834814 100644
--- a/tests/ui/derive_ord_xor_partial_ord.stderr
+++ b/tests/ui/derive_ord_xor_partial_ord.stderr
@@ -1,11 +1,11 @@
 error: you are deriving `Ord` but have implemented `PartialOrd` explicitly
-  --> $DIR/derive_ord_xor_partial_ord.rs:21:10
+  --> $DIR/derive_ord_xor_partial_ord.rs:22:10
    |
 LL | #[derive(Ord, PartialEq, Eq)]
    |          ^^^
    |
 note: `PartialOrd` implemented here
-  --> $DIR/derive_ord_xor_partial_ord.rs:24:1
+  --> $DIR/derive_ord_xor_partial_ord.rs:25:1
    |
 LL | impl PartialOrd for DeriveOrd {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -13,20 +13,20 @@ LL | impl PartialOrd for DeriveOrd {
    = note: this error originates in the derive macro `Ord` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: you are deriving `Ord` but have implemented `PartialOrd` explicitly
-  --> $DIR/derive_ord_xor_partial_ord.rs:30:10
+  --> $DIR/derive_ord_xor_partial_ord.rs:31:10
    |
 LL | #[derive(Ord, PartialEq, Eq)]
    |          ^^^
    |
 note: `PartialOrd` implemented here
-  --> $DIR/derive_ord_xor_partial_ord.rs:33:1
+  --> $DIR/derive_ord_xor_partial_ord.rs:34:1
    |
 LL | impl PartialOrd<DeriveOrdWithExplicitTypeVariable> for DeriveOrdWithExplicitTypeVariable {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    = note: this error originates in the derive macro `Ord` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: you are implementing `Ord` explicitly but have derived `PartialOrd`
-  --> $DIR/derive_ord_xor_partial_ord.rs:42:1
+  --> $DIR/derive_ord_xor_partial_ord.rs:43:1
    |
 LL | / impl std::cmp::Ord for DerivePartialOrd {
 LL | |     fn cmp(&self, other: &Self) -> Ordering {
@@ -36,14 +36,14 @@ LL | | }
    | |_^
    |
 note: `PartialOrd` implemented here
-  --> $DIR/derive_ord_xor_partial_ord.rs:39:10
+  --> $DIR/derive_ord_xor_partial_ord.rs:40:10
    |
 LL | #[derive(PartialOrd, PartialEq, Eq)]
    |          ^^^^^^^^^^
    = note: this error originates in the derive macro `PartialOrd` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: you are implementing `Ord` explicitly but have derived `PartialOrd`
-  --> $DIR/derive_ord_xor_partial_ord.rs:62:5
+  --> $DIR/derive_ord_xor_partial_ord.rs:63:5
    |
 LL | /     impl Ord for DerivePartialOrdInUseOrd {
 LL | |         fn cmp(&self, other: &Self) -> Ordering {
@@ -53,7 +53,7 @@ LL | |     }
    | |_____^
    |
 note: `PartialOrd` implemented here
-  --> $DIR/derive_ord_xor_partial_ord.rs:59:14
+  --> $DIR/derive_ord_xor_partial_ord.rs:60:14
    |
 LL |     #[derive(PartialOrd, PartialEq, Eq)]
    |              ^^^^^^^^^^
diff --git a/tests/ui/manual_partial_ord_impl.rs b/tests/ui/manual_partial_ord_impl.rs
deleted file mode 100644
index 9e2c7e2ec51..00000000000
--- a/tests/ui/manual_partial_ord_impl.rs
+++ /dev/null
@@ -1,57 +0,0 @@
-#![allow(unused)]
-#![warn(clippy::manual_partial_ord_impl)]
-#![no_main]
-
-use std::cmp::Ordering;
-
-// lint
-
-#[derive(Eq, PartialEq)]
-struct A(u32);
-
-impl Ord for A {
-    fn cmp(&self, other: &Self) -> Ordering {
-        todo!();
-    }
-}
-
-impl PartialOrd for A {
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        todo!();
-    }
-}
-
-// do not lint
-
-#[derive(Eq, PartialEq)]
-struct B(u32);
-
-impl Ord for B {
-    fn cmp(&self, other: &Self) -> Ordering {
-        todo!();
-    }
-}
-
-impl PartialOrd for B {
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        Some(self.cmp(other))
-    }
-}
-
-// lint, but we cannot give a suggestion since &Self is not named
-
-#[derive(Eq, PartialEq)]
-struct C(u32);
-
-impl Ord for C {
-    fn cmp(&self, other: &Self) -> Ordering {
-        todo!();
-    }
-}
-
-impl PartialOrd for C {
-    fn partial_cmp(&self, _: &Self) -> Option<Ordering> {
-        todo!();
-    }
-}
-
diff --git a/tests/ui/manual_partial_ord_impl.stderr b/tests/ui/manual_partial_ord_impl.stderr
deleted file mode 100644
index 100ddb46e82..00000000000
--- a/tests/ui/manual_partial_ord_impl.stderr
+++ /dev/null
@@ -1,28 +0,0 @@
-error: manual implementation of `PartialOrd` when `Ord` is already implemented
-  --> $DIR/manual_partial_ord_impl.rs:18:1
-   |
-LL | /  impl PartialOrd for A {
-LL | |      fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-   | | _____________________________________________________________-
-LL | ||         todo!();
-LL | ||     }
-   | ||_____- help: change this to: `{ Some(self.cmp(other)) }`
-LL | |  }
-   | |__^
-   |
-   = note: `-D clippy::manual-partial-ord-impl` implied by `-D warnings`
-
-error: manual implementation of `PartialOrd` when `Ord` is already implemented
-  --> $DIR/manual_partial_ord_impl.rs:52:1
-   |
-LL | / impl PartialOrd for C {
-LL | |     fn partial_cmp(&self, _: &Self) -> Option<Ordering> {
-LL | |         todo!();
-LL | |     }
-LL | | }
-   | |_^
-   |
-   = help: return the value of `self.cmp` wrapped in `Some` instead
-
-error: aborting due to 2 previous errors
-
diff --git a/tests/ui/needless_partial_ord_impl.fixed b/tests/ui/needless_partial_ord_impl.fixed
new file mode 100644
index 00000000000..7b47773ad76
--- /dev/null
+++ b/tests/ui/needless_partial_ord_impl.fixed
@@ -0,0 +1,85 @@
+//@run-rustfix
+#![allow(unused)]
+#![no_main]
+
+use std::cmp::Ordering;
+
+// lint
+
+#[derive(Eq, PartialEq)]
+struct A(u32);
+
+impl Ord for A {
+    fn cmp(&self, other: &Self) -> Ordering {
+        todo!();
+    }
+}
+
+impl PartialOrd for A {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> { Some(self.cmp(self)) }
+}
+
+// do not lint
+
+#[derive(Eq, PartialEq)]
+struct B(u32);
+
+impl Ord for B {
+    fn cmp(&self, other: &Self) -> Ordering {
+        todo!();
+    }
+}
+
+impl PartialOrd for B {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+// lint, but we can't give a suggestion since &Self is not named
+
+#[derive(Eq, PartialEq)]
+struct C(u32);
+
+impl Ord for C {
+    fn cmp(&self, other: &Self) -> Ordering {
+        todo!();
+    }
+}
+
+impl PartialOrd for C {
+    fn partial_cmp(&self, _: &Self) -> Option<Ordering> { Some(self.cmp(self)) }
+}
+
+// do not lint derived
+
+#[derive(Eq, Ord, PartialEq, PartialOrd)]
+struct D(u32);
+
+// do not lint if ord is not manually implemented
+
+#[derive(Eq, PartialEq)]
+struct E(u32);
+
+impl PartialOrd for E {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        todo!();
+    }
+}
+
+// do not lint since ord has more restrictive bounds
+
+#[derive(Eq, PartialEq)]
+struct Uwu<A>(A);
+
+impl<A: std::fmt::Debug + Ord + PartialOrd> Ord for Uwu<A> {
+    fn cmp(&self, other: &Self) -> Ordering {
+        todo!();
+    }
+}
+
+impl<A: Ord + PartialOrd> PartialOrd for Uwu<A> {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        todo!();
+    }
+}
diff --git a/tests/ui/needless_partial_ord_impl.rs b/tests/ui/needless_partial_ord_impl.rs
new file mode 100644
index 00000000000..8f5c1337369
--- /dev/null
+++ b/tests/ui/needless_partial_ord_impl.rs
@@ -0,0 +1,89 @@
+//@run-rustfix
+#![allow(unused)]
+#![no_main]
+
+use std::cmp::Ordering;
+
+// lint
+
+#[derive(Eq, PartialEq)]
+struct A(u32);
+
+impl Ord for A {
+    fn cmp(&self, other: &Self) -> Ordering {
+        todo!();
+    }
+}
+
+impl PartialOrd for A {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        todo!();
+    }
+}
+
+// do not lint
+
+#[derive(Eq, PartialEq)]
+struct B(u32);
+
+impl Ord for B {
+    fn cmp(&self, other: &Self) -> Ordering {
+        todo!();
+    }
+}
+
+impl PartialOrd for B {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+// lint, but we can't give a suggestion since &Self is not named
+
+#[derive(Eq, PartialEq)]
+struct C(u32);
+
+impl Ord for C {
+    fn cmp(&self, other: &Self) -> Ordering {
+        todo!();
+    }
+}
+
+impl PartialOrd for C {
+    fn partial_cmp(&self, _: &Self) -> Option<Ordering> {
+        todo!();
+    }
+}
+
+// do not lint derived
+
+#[derive(Eq, Ord, PartialEq, PartialOrd)]
+struct D(u32);
+
+// do not lint if ord is not manually implemented
+
+#[derive(Eq, PartialEq)]
+struct E(u32);
+
+impl PartialOrd for E {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        todo!();
+    }
+}
+
+// do not lint since ord has more restrictive bounds
+
+#[derive(Eq, PartialEq)]
+struct Uwu<A>(A);
+
+impl<A: std::fmt::Debug + Ord + PartialOrd> Ord for Uwu<A> {
+    fn cmp(&self, other: &Self) -> Ordering {
+        todo!();
+    }
+}
+
+impl<A: Ord + PartialOrd> PartialOrd for Uwu<A> {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        todo!();
+    }
+}
diff --git a/tests/ui/needless_partial_ord_impl.stderr b/tests/ui/needless_partial_ord_impl.stderr
new file mode 100644
index 00000000000..b8978462cc0
--- /dev/null
+++ b/tests/ui/needless_partial_ord_impl.stderr
@@ -0,0 +1,28 @@
+error: manual implementation of `PartialOrd` when `Ord` is already implemented
+  --> $DIR/needless_partial_ord_impl.rs:18:1
+   |
+LL | /  impl PartialOrd for A {
+LL | |      fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+   | | _____________________________________________________________-
+LL | ||         todo!();
+LL | ||     }
+   | ||_____- help: change this to: `{ Some(self.cmp(self)) }`
+LL | |  }
+   | |__^
+   |
+   = note: `#[deny(clippy::needless_partial_ord_impl)]` on by default
+
+error: manual implementation of `PartialOrd` when `Ord` is already implemented
+  --> $DIR/needless_partial_ord_impl.rs:52:1
+   |
+LL | /  impl PartialOrd for C {
+LL | |      fn partial_cmp(&self, _: &Self) -> Option<Ordering> {
+   | | _________________________________________________________-
+LL | ||         todo!();
+LL | ||     }
+   | ||_____- help: change this to: `{ Some(self.cmp(self)) }`
+LL | |  }
+   | |__^
+
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 844afbfebad063d335e30f01e7eab287535f6470 Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Thu, 15 Jun 2023 07:11:25 -0500
Subject: use `other` instead of `self`

---
 CHANGELOG.md                                       |   2 +-
 clippy_lints/src/declared_lints.rs                 |   2 +-
 clippy_lints/src/incorrect_impls.rs                | 130 +++++++++++++++++-
 clippy_lints/src/lib.rs                            |   1 -
 clippy_lints/src/needless_impls.rs                 | 145 ---------------------
 tests/ui/bool_comparison.fixed                     |   2 +-
 tests/ui/bool_comparison.rs                        |   2 +-
 tests/ui/derive.rs                                 |   6 +-
 tests/ui/derive.stderr                             |  20 +--
 tests/ui/derive_ord_xor_partial_ord.rs             |   2 +-
 tests/ui/incorrect_partial_ord_impl_on_ord_type.rs | 117 +++++++++++++++++
 .../incorrect_partial_ord_impl_on_ord_type.stderr  |  28 ++++
 tests/ui/needless_partial_ord_impl.fixed           |  85 ------------
 tests/ui/needless_partial_ord_impl.rs              |  89 -------------
 tests/ui/needless_partial_ord_impl.stderr          |  28 ----
 15 files changed, 289 insertions(+), 370 deletions(-)
 delete mode 100644 clippy_lints/src/needless_impls.rs
 create mode 100644 tests/ui/incorrect_partial_ord_impl_on_ord_type.rs
 create mode 100644 tests/ui/incorrect_partial_ord_impl_on_ord_type.stderr
 delete mode 100644 tests/ui/needless_partial_ord_impl.fixed
 delete mode 100644 tests/ui/needless_partial_ord_impl.rs
 delete mode 100644 tests/ui/needless_partial_ord_impl.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index fea11bba63f..57322887b86 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4834,6 +4834,7 @@ Released 2018-09-13
 [`inconsistent_digit_grouping`]: https://rust-lang.github.io/rust-clippy/master/index.html#inconsistent_digit_grouping
 [`inconsistent_struct_constructor`]: https://rust-lang.github.io/rust-clippy/master/index.html#inconsistent_struct_constructor
 [`incorrect_clone_impl_on_copy_type`]: https://rust-lang.github.io/rust-clippy/master/index.html#incorrect_clone_impl_on_copy_type
+[`incorrect_partial_ord_impl_on_ord_type`]: https://rust-lang.github.io/rust-clippy/master/index.html#incorrect_partial_ord_impl_on_ord_type
 [`index_refutable_slice`]: https://rust-lang.github.io/rust-clippy/master/index.html#index_refutable_slice
 [`indexing_slicing`]: https://rust-lang.github.io/rust-clippy/master/index.html#indexing_slicing
 [`ineffective_bit_mask`]: https://rust-lang.github.io/rust-clippy/master/index.html#ineffective_bit_mask
@@ -5020,7 +5021,6 @@ Released 2018-09-13
 [`needless_option_as_deref`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_option_as_deref
 [`needless_option_take`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_option_take
 [`needless_parens_on_range_literals`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_parens_on_range_literals
-[`needless_partial_ord_impl`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_partial_ord_impl
 [`needless_pass_by_value`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_pass_by_value
 [`needless_pub_self`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_pub_self
 [`needless_question_mark`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_question_mark
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index a2231b8fb1d..caff1c4b3be 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -207,6 +207,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::implicit_saturating_sub::IMPLICIT_SATURATING_SUB_INFO,
     crate::inconsistent_struct_constructor::INCONSISTENT_STRUCT_CONSTRUCTOR_INFO,
     crate::incorrect_impls::INCORRECT_CLONE_IMPL_ON_COPY_TYPE_INFO,
+    crate::incorrect_impls::INCORRECT_PARTIAL_ORD_IMPL_ON_ORD_TYPE_INFO,
     crate::index_refutable_slice::INDEX_REFUTABLE_SLICE_INFO,
     crate::indexing_slicing::INDEXING_SLICING_INFO,
     crate::indexing_slicing::OUT_OF_BOUNDS_INDEXING_INFO,
@@ -469,7 +470,6 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::needless_else::NEEDLESS_ELSE_INFO,
     crate::needless_for_each::NEEDLESS_FOR_EACH_INFO,
     crate::needless_if::NEEDLESS_IF_INFO,
-    crate::needless_impls::NEEDLESS_PARTIAL_ORD_IMPL_INFO,
     crate::needless_late_init::NEEDLESS_LATE_INIT_INFO,
     crate::needless_parens_on_range_literals::NEEDLESS_PARENS_ON_RANGE_LITERALS_INFO,
     crate::needless_pass_by_value::NEEDLESS_PASS_BY_VALUE_INFO,
diff --git a/clippy_lints/src/incorrect_impls.rs b/clippy_lints/src/incorrect_impls.rs
index ed21df4ff88..f7894f9c17b 100644
--- a/clippy_lints/src/incorrect_impls.rs
+++ b/clippy_lints/src/incorrect_impls.rs
@@ -1,10 +1,16 @@
-use clippy_utils::{diagnostics::span_lint_and_sugg, get_parent_node, last_path_segment, ty::implements_trait};
+use clippy_utils::{
+    diagnostics::{span_lint_and_sugg, span_lint_and_then},
+    get_parent_node, is_res_lang_ctor, last_path_segment, path_res,
+    ty::implements_trait,
+};
 use rustc_errors::Applicability;
+use rustc_hir::{def::Res, Expr, ExprKind, ImplItem, ImplItemKind, ItemKind, LangItem, Node, PatKind, UnOp};
 use rustc_hir::{ExprKind, ImplItem, ImplItemKind, Node, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::EarlyBinder;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::{sym, symbol};
+use std::borrow::Cow;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -45,10 +51,59 @@ declare_clippy_lint! {
     correctness,
     "manual implementation of `Clone` on a `Copy` type"
 }
-declare_lint_pass!(IncorrectImpls => [INCORRECT_CLONE_IMPL_ON_COPY_TYPE]);
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for manual implementations of both `PartialOrd` and `Ord` when only `Ord` is
+    /// necessary.
+    ///
+    /// ### Why is this bad?
+    /// If both `PartialOrd` and `Ord` are implemented, they must agree. This is commonly done by
+    /// wrapping the result of `cmp` in `Some` for `partial_cmp`. Not doing this may silently
+    /// introduce an error upon refactoring.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// #[derive(Eq, PartialEq)]
+    /// struct A(u32);
+    ///
+    /// impl Ord for A {
+    ///     fn cmp(&self, other: &Self) -> Ordering {
+    ///         todo!();
+    ///     }
+    /// }
+    ///
+    /// impl PartialOrd for A {
+    ///     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+    ///         todo!();
+    ///     }
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust,ignore
+    /// #[derive(Eq, PartialEq)]
+    /// struct A(u32);
+    ///
+    /// impl Ord for A {
+    ///     fn cmp(&self, other: &Self) -> Ordering {
+    ///         todo!();
+    ///     }
+    /// }
+    ///
+    /// impl PartialOrd for A {
+    ///     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+    ///         Some(self.cmp(other))
+    ///     }
+    /// }
+    /// ```
+    #[clippy::version = "1.72.0"]
+    pub INCORRECT_PARTIAL_ORD_IMPL_ON_ORD_TYPE,
+    correctness,
+    "manual implementation of `PartialOrd` when `Ord` is already implemented"
+}
+declare_lint_pass!(IncorrectImpls => [INCORRECT_CLONE_IMPL_ON_COPY_TYPE, INCORRECT_PARTIAL_ORD_IMPL_ON_ORD_TYPE]);
 
 impl LateLintPass<'_> for IncorrectImpls {
-    #[expect(clippy::needless_return)]
+    #[expect(clippy::too_many_lines)]
     fn check_impl_item(&mut self, cx: &LateContext<'_>, impl_item: &ImplItem<'_>) {
         let node = get_parent_node(cx.tcx, impl_item.hir_id());
         let Some(Node::Item(item)) = node else {
@@ -68,10 +123,7 @@ impl LateLintPass<'_> for IncorrectImpls {
         let ExprKind::Block(block, ..) = body.value.kind else {
             return;
         };
-        // Above is duplicated from the `duplicate_manual_partial_ord_impl` branch.
-        // Remove it while solving conflicts once that PR is merged.
 
-        // Actual implementation; remove this comment once aforementioned PR is merged
         if cx.tcx.is_diagnostic_item(sym::Clone, trait_impl_def_id)
             && let Some(copy_def_id) = cx.tcx.get_diagnostic_item(sym::Copy)
             && implements_trait(
@@ -116,5 +168,71 @@ impl LateLintPass<'_> for IncorrectImpls {
                 return;
             }
         }
+
+        if cx.tcx.is_diagnostic_item(sym::PartialOrd, trait_impl_def_id)
+            && impl_item.ident.name == sym::partial_cmp
+            && let Some(ord_def_id) = cx
+                .tcx
+                .diagnostic_items(trait_impl.def_id.krate)
+                .name_to_id
+                .get(&sym::Ord)
+            && implements_trait(
+                    cx,
+                    hir_ty_to_ty(cx.tcx, imp.self_ty),
+                    *ord_def_id,
+                    trait_impl.substs,
+                )
+        {
+            if block.stmts.is_empty()
+                && let Some(expr) = block.expr
+                && let ExprKind::Call(
+                        Expr {
+                            kind: ExprKind::Path(some_path),
+                            hir_id: some_hir_id,
+                            ..
+                        },
+                        [cmp_expr],
+                    ) = expr.kind
+                && is_res_lang_ctor(cx, cx.qpath_res(some_path, *some_hir_id), LangItem::OptionSome)
+                && let ExprKind::MethodCall(cmp_path, _, [other_expr], ..) = cmp_expr.kind
+                && cmp_path.ident.name == sym::cmp
+                && let Res::Local(..) = path_res(cx, other_expr)
+            {} else {
+                // If lhs and rhs are not the same type, bail. This makes creating a valid
+                // suggestion tons more complex.
+                if let Some(lhs) = trait_impl.substs.get(0)
+                    && let Some(rhs) = trait_impl.substs.get(1)
+                    && lhs != rhs
+                {
+                    return;
+                }
+
+                span_lint_and_then(
+                    cx,
+                    INCORRECT_PARTIAL_ORD_IMPL_ON_ORD_TYPE,
+                    item.span,
+                    "incorrect implementation of `partial_cmp` on an `Ord` type",
+                    |diag| {
+                        let (help, app) = if let Some(other) = body.params.get(1)
+                            && let PatKind::Binding(_, _, other_ident, ..) = other.pat.kind
+                        {
+                            (
+                                Cow::Owned(format!("{{ Some(self.cmp({})) }}", other_ident.name)),
+                                Applicability::Unspecified,
+                            )
+                        } else {
+                            (Cow::Borrowed("{ Some(self.cmp(...)) }"), Applicability::HasPlaceholders)
+                        };
+
+                        diag.span_suggestion(
+                            block.span,
+                            "change this to",
+                            help,
+                            app,
+                        );
+                    }
+                );
+            }
+        }
     }
 }
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 1ec5b2e8b0a..00d46025caa 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -227,7 +227,6 @@ mod needless_continue;
 mod needless_else;
 mod needless_for_each;
 mod needless_if;
-mod needless_impls;
 mod needless_late_init;
 mod needless_parens_on_range_literals;
 mod needless_pass_by_value;
diff --git a/clippy_lints/src/needless_impls.rs b/clippy_lints/src/needless_impls.rs
deleted file mode 100644
index 4f8741bf370..00000000000
--- a/clippy_lints/src/needless_impls.rs
+++ /dev/null
@@ -1,145 +0,0 @@
-use clippy_utils::{
-    diagnostics::span_lint_and_then, get_parent_node, is_res_lang_ctor, path_res, ty::implements_trait,
-};
-use rustc_errors::Applicability;
-use rustc_hir::{def::Res, Expr, ExprKind, ImplItem, ImplItemKind, ItemKind, LangItem, Node, PatKind};
-use rustc_hir_analysis::hir_ty_to_ty;
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty::EarlyBinder;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::sym;
-use std::borrow::Cow;
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for manual implementations of both `PartialOrd` and `Ord` when only `Ord` is
-    /// necessary.
-    ///
-    /// ### Why is this bad?
-    /// If both `PartialOrd` and `Ord` are implemented, they must agree. This is commonly done by
-    /// wrapping the result of `cmp` in `Some` for `partial_cmp`. Not doing this may silently
-    /// introduce an error upon refactoring.
-    ///
-    /// ### Example
-    /// ```rust,ignore
-    /// #[derive(Eq, PartialEq)]
-    /// struct A(u32);
-    ///
-    /// impl Ord for A {
-    ///     fn cmp(&self, other: &Self) -> Ordering {
-    ///         todo!();
-    ///     }
-    /// }
-    ///
-    /// impl PartialOrd for A {
-    ///     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-    ///         todo!();
-    ///     }
-    /// }
-    /// ```
-    /// Use instead:
-    /// ```rust,ignore
-    /// #[derive(Eq, PartialEq)]
-    /// struct A(u32);
-    ///
-    /// impl Ord for A {
-    ///     fn cmp(&self, other: &Self) -> Ordering {
-    ///         todo!();
-    ///     }
-    /// }
-    ///
-    /// impl PartialOrd for A {
-    ///     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-    ///         Some(self.cmp(other))
-    ///     }
-    /// }
-    /// ```
-    #[clippy::version = "1.72.0"]
-    pub NEEDLESS_PARTIAL_ORD_IMPL,
-    correctness,
-    "manual implementation of `PartialOrd` when `Ord` is already implemented"
-}
-declare_lint_pass!(NeedlessImpls => [NEEDLESS_PARTIAL_ORD_IMPL]);
-
-impl LateLintPass<'_> for NeedlessImpls {
-    fn check_impl_item(&mut self, cx: &LateContext<'_>, impl_item: &ImplItem<'_>) {
-        let node = get_parent_node(cx.tcx, impl_item.hir_id());
-        let Some(Node::Item(item)) = node else {
-            return;
-        };
-        let ItemKind::Impl(imp) = item.kind else {
-            return;
-        };
-        let Some(trait_impl) = cx.tcx.impl_trait_ref(item.owner_id).map(EarlyBinder::skip_binder) else {
-            return;
-        };
-        let trait_impl_def_id = trait_impl.def_id;
-        if cx.tcx.is_automatically_derived(item.owner_id.to_def_id()) {
-            return;
-        }
-        let ImplItemKind::Fn(_, impl_item_id) = cx.tcx.hir().impl_item(impl_item.impl_item_id()).kind else {
-            return;
-        };
-        let body = cx.tcx.hir().body(impl_item_id);
-        let ExprKind::Block(block, ..) = body.value.kind else {
-            return;
-        };
-
-        if cx.tcx.is_diagnostic_item(sym::PartialOrd, trait_impl_def_id)
-            && impl_item.ident.name == sym::partial_cmp
-            && let Some(ord_def_id) = cx
-                .tcx
-                .diagnostic_items(trait_impl.def_id.krate)
-                .name_to_id
-                .get(&sym::Ord)
-            && implements_trait(
-                    cx,
-                    hir_ty_to_ty(cx.tcx, imp.self_ty),
-                    *ord_def_id,
-                    trait_impl.substs,
-                )
-        {
-            if block.stmts.is_empty()
-                && let Some(expr) = block.expr
-                && let ExprKind::Call(
-                        Expr {
-                            kind: ExprKind::Path(some_path),
-                            hir_id: some_hir_id,
-                            ..
-                        },
-                        [cmp_expr],
-                    ) = expr.kind
-                && is_res_lang_ctor(cx, cx.qpath_res(some_path, *some_hir_id), LangItem::OptionSome)
-                && let ExprKind::MethodCall(cmp_path, _, [other_expr], ..) = cmp_expr.kind
-                && cmp_path.ident.name == sym::cmp
-                && let Res::Local(..) = path_res(cx, other_expr)
-            {} else {
-                span_lint_and_then(
-                    cx,
-                    NEEDLESS_PARTIAL_ORD_IMPL,
-                    item.span,
-                    "manual implementation of `PartialOrd` when `Ord` is already implemented",
-                    |diag| {
-                        let (help, app) = if let Some(other) = body.params.get(0)
-                            && let PatKind::Binding(_, _, other_ident, ..) = other.pat.kind
-                        {
-                            (
-                                Cow::Owned(format!("{{ Some(self.cmp({})) }}", other_ident.name)),
-                                Applicability::Unspecified,
-                            )
-                        } else {
-                            (Cow::Borrowed("{ Some(self.cmp(...)) }"), Applicability::HasPlaceholders)
-                        };
-
-                        diag.span_suggestion(
-                            block.span,
-                            "change this to",
-                            help,
-                            app,
-                        );
-                    }
-                );
-            }
-        }
-    }
-}
diff --git a/tests/ui/bool_comparison.fixed b/tests/ui/bool_comparison.fixed
index 33221c7777e..8689f89d2c3 100644
--- a/tests/ui/bool_comparison.fixed
+++ b/tests/ui/bool_comparison.fixed
@@ -2,7 +2,7 @@
 
 #![allow(clippy::needless_if)]
 #![warn(clippy::bool_comparison)]
-#![allow(clippy::needless_partial_ord_impl)]
+#![allow(clippy::incorrect_partial_ord_impl_on_ord_type)]
 
 fn main() {
     let x = true;
diff --git a/tests/ui/bool_comparison.rs b/tests/ui/bool_comparison.rs
index 5f909bd2a53..a1c94aff94b 100644
--- a/tests/ui/bool_comparison.rs
+++ b/tests/ui/bool_comparison.rs
@@ -2,7 +2,7 @@
 
 #![allow(clippy::needless_if)]
 #![warn(clippy::bool_comparison)]
-#![allow(clippy::needless_partial_ord_impl)]
+#![allow(clippy::incorrect_partial_ord_impl_on_ord_type)]
 
 fn main() {
     let x = true;
diff --git a/tests/ui/derive.rs b/tests/ui/derive.rs
index 44e18bff83f..ff4dcbfa2f2 100644
--- a/tests/ui/derive.rs
+++ b/tests/ui/derive.rs
@@ -1,4 +1,8 @@
-#![allow(clippy::incorrect_clone_impl_on_copy_type, dead_code)]
+#![allow(
+    clippy::incorrect_clone_impl_on_copy_type,
+    clippy::incorrect_partial_ord_impl_on_ord_type,
+    dead_code
+)]
 #![warn(clippy::expl_impl_clone_on_copy)]
 
 #[derive(Copy)]
diff --git a/tests/ui/derive.stderr b/tests/ui/derive.stderr
index d37f7fa7331..f7948e044b7 100644
--- a/tests/ui/derive.stderr
+++ b/tests/ui/derive.stderr
@@ -1,5 +1,5 @@
 error: you are implementing `Clone` explicitly on a `Copy` type
-  --> $DIR/derive.rs:7:1
+  --> $DIR/derive.rs:11:1
    |
 LL | / impl Clone for Qux {
 LL | |     fn clone(&self) -> Self {
@@ -9,7 +9,7 @@ LL | | }
    | |_^
    |
 note: consider deriving `Clone` or removing `Copy`
-  --> $DIR/derive.rs:7:1
+  --> $DIR/derive.rs:11:1
    |
 LL | / impl Clone for Qux {
 LL | |     fn clone(&self) -> Self {
@@ -20,7 +20,7 @@ LL | | }
    = note: `-D clippy::expl-impl-clone-on-copy` implied by `-D warnings`
 
 error: you are implementing `Clone` explicitly on a `Copy` type
-  --> $DIR/derive.rs:31:1
+  --> $DIR/derive.rs:35:1
    |
 LL | / impl<'a> Clone for Lt<'a> {
 LL | |     fn clone(&self) -> Self {
@@ -30,7 +30,7 @@ LL | | }
    | |_^
    |
 note: consider deriving `Clone` or removing `Copy`
-  --> $DIR/derive.rs:31:1
+  --> $DIR/derive.rs:35:1
    |
 LL | / impl<'a> Clone for Lt<'a> {
 LL | |     fn clone(&self) -> Self {
@@ -40,7 +40,7 @@ LL | | }
    | |_^
 
 error: you are implementing `Clone` explicitly on a `Copy` type
-  --> $DIR/derive.rs:42:1
+  --> $DIR/derive.rs:46:1
    |
 LL | / impl Clone for BigArray {
 LL | |     fn clone(&self) -> Self {
@@ -50,7 +50,7 @@ LL | | }
    | |_^
    |
 note: consider deriving `Clone` or removing `Copy`
-  --> $DIR/derive.rs:42:1
+  --> $DIR/derive.rs:46:1
    |
 LL | / impl Clone for BigArray {
 LL | |     fn clone(&self) -> Self {
@@ -60,7 +60,7 @@ LL | | }
    | |_^
 
 error: you are implementing `Clone` explicitly on a `Copy` type
-  --> $DIR/derive.rs:53:1
+  --> $DIR/derive.rs:57:1
    |
 LL | / impl Clone for FnPtr {
 LL | |     fn clone(&self) -> Self {
@@ -70,7 +70,7 @@ LL | | }
    | |_^
    |
 note: consider deriving `Clone` or removing `Copy`
-  --> $DIR/derive.rs:53:1
+  --> $DIR/derive.rs:57:1
    |
 LL | / impl Clone for FnPtr {
 LL | |     fn clone(&self) -> Self {
@@ -80,7 +80,7 @@ LL | | }
    | |_^
 
 error: you are implementing `Clone` explicitly on a `Copy` type
-  --> $DIR/derive.rs:73:1
+  --> $DIR/derive.rs:77:1
    |
 LL | / impl<T: Clone> Clone for Generic2<T> {
 LL | |     fn clone(&self) -> Self {
@@ -90,7 +90,7 @@ LL | | }
    | |_^
    |
 note: consider deriving `Clone` or removing `Copy`
-  --> $DIR/derive.rs:73:1
+  --> $DIR/derive.rs:77:1
    |
 LL | / impl<T: Clone> Clone for Generic2<T> {
 LL | |     fn clone(&self) -> Self {
diff --git a/tests/ui/derive_ord_xor_partial_ord.rs b/tests/ui/derive_ord_xor_partial_ord.rs
index 5d1a693321e..1fb3d51c46d 100644
--- a/tests/ui/derive_ord_xor_partial_ord.rs
+++ b/tests/ui/derive_ord_xor_partial_ord.rs
@@ -1,6 +1,6 @@
 #![warn(clippy::derive_ord_xor_partial_ord)]
 #![allow(clippy::unnecessary_wraps)]
-#![allow(clippy::needless_partial_ord_impl)]
+#![allow(clippy::incorrect_partial_ord_impl_on_ord_type)]
 
 use std::cmp::Ordering;
 
diff --git a/tests/ui/incorrect_partial_ord_impl_on_ord_type.rs b/tests/ui/incorrect_partial_ord_impl_on_ord_type.rs
new file mode 100644
index 00000000000..25fe909a8d3
--- /dev/null
+++ b/tests/ui/incorrect_partial_ord_impl_on_ord_type.rs
@@ -0,0 +1,117 @@
+#![allow(unused)]
+#![no_main]
+
+use std::cmp::Ordering;
+
+// lint
+
+#[derive(Eq, PartialEq)]
+struct A(u32);
+
+impl Ord for A {
+    fn cmp(&self, other: &Self) -> Ordering {
+        todo!();
+    }
+}
+
+impl PartialOrd for A {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        todo!();
+    }
+}
+
+// do not lint
+
+#[derive(Eq, PartialEq)]
+struct B(u32);
+
+impl Ord for B {
+    fn cmp(&self, other: &Self) -> Ordering {
+        todo!();
+    }
+}
+
+impl PartialOrd for B {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+// lint, but we can't give a suggestion since &Self is not named
+
+#[derive(Eq, PartialEq)]
+struct C(u32);
+
+impl Ord for C {
+    fn cmp(&self, other: &Self) -> Ordering {
+        todo!();
+    }
+}
+
+impl PartialOrd for C {
+    fn partial_cmp(&self, _: &Self) -> Option<Ordering> {
+        todo!(); // don't run rustfix, or else this will cause it to fail to compile
+    }
+}
+
+// do not lint derived
+
+#[derive(Eq, Ord, PartialEq, PartialOrd)]
+struct D(u32);
+
+// do not lint if ord is not manually implemented
+
+#[derive(Eq, PartialEq)]
+struct E(u32);
+
+impl PartialOrd for E {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        todo!();
+    }
+}
+
+// do not lint since ord has more restrictive bounds
+
+#[derive(Eq, PartialEq)]
+struct Uwu<A>(A);
+
+impl<A: std::fmt::Debug + Ord + PartialOrd> Ord for Uwu<A> {
+    fn cmp(&self, other: &Self) -> Ordering {
+        todo!();
+    }
+}
+
+impl<A: Ord + PartialOrd> PartialOrd for Uwu<A> {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        todo!();
+    }
+}
+
+// do not lint since `Rhs` is not `Self`
+
+#[derive(Eq, PartialEq)]
+struct F(u32);
+
+impl Ord for F {
+    fn cmp(&self, other: &Self) -> Ordering {
+        todo!();
+    }
+}
+
+impl PartialOrd for F {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl PartialEq<u32> for F {
+    fn eq(&self, other: &u32) -> bool {
+        todo!();
+    }
+}
+
+impl PartialOrd<u32> for F {
+    fn partial_cmp(&self, other: &u32) -> Option<Ordering> {
+        todo!();
+    }
+}
diff --git a/tests/ui/incorrect_partial_ord_impl_on_ord_type.stderr b/tests/ui/incorrect_partial_ord_impl_on_ord_type.stderr
new file mode 100644
index 00000000000..86b3d37241a
--- /dev/null
+++ b/tests/ui/incorrect_partial_ord_impl_on_ord_type.stderr
@@ -0,0 +1,28 @@
+error: incorrect implementation of `partial_cmp` on an `Ord` type
+  --> $DIR/incorrect_partial_ord_impl_on_ord_type.rs:17:1
+   |
+LL | /  impl PartialOrd for A {
+LL | |      fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+   | | _____________________________________________________________-
+LL | ||         todo!();
+LL | ||     }
+   | ||_____- help: change this to: `{ Some(self.cmp(other)) }`
+LL | |  }
+   | |__^
+   |
+   = note: `#[deny(clippy::incorrect_partial_ord_impl_on_ord_type)]` on by default
+
+error: incorrect implementation of `partial_cmp` on an `Ord` type
+  --> $DIR/incorrect_partial_ord_impl_on_ord_type.rs:51:1
+   |
+LL | /  impl PartialOrd for C {
+LL | |      fn partial_cmp(&self, _: &Self) -> Option<Ordering> {
+   | | _________________________________________________________-
+LL | ||         todo!(); // don't run rustfix, or else this will cause it to fail to compile
+LL | ||     }
+   | ||_____- help: change this to: `{ Some(self.cmp(...)) }`
+LL | |  }
+   | |__^
+
+error: aborting due to 2 previous errors
+
diff --git a/tests/ui/needless_partial_ord_impl.fixed b/tests/ui/needless_partial_ord_impl.fixed
deleted file mode 100644
index 7b47773ad76..00000000000
--- a/tests/ui/needless_partial_ord_impl.fixed
+++ /dev/null
@@ -1,85 +0,0 @@
-//@run-rustfix
-#![allow(unused)]
-#![no_main]
-
-use std::cmp::Ordering;
-
-// lint
-
-#[derive(Eq, PartialEq)]
-struct A(u32);
-
-impl Ord for A {
-    fn cmp(&self, other: &Self) -> Ordering {
-        todo!();
-    }
-}
-
-impl PartialOrd for A {
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> { Some(self.cmp(self)) }
-}
-
-// do not lint
-
-#[derive(Eq, PartialEq)]
-struct B(u32);
-
-impl Ord for B {
-    fn cmp(&self, other: &Self) -> Ordering {
-        todo!();
-    }
-}
-
-impl PartialOrd for B {
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        Some(self.cmp(other))
-    }
-}
-
-// lint, but we can't give a suggestion since &Self is not named
-
-#[derive(Eq, PartialEq)]
-struct C(u32);
-
-impl Ord for C {
-    fn cmp(&self, other: &Self) -> Ordering {
-        todo!();
-    }
-}
-
-impl PartialOrd for C {
-    fn partial_cmp(&self, _: &Self) -> Option<Ordering> { Some(self.cmp(self)) }
-}
-
-// do not lint derived
-
-#[derive(Eq, Ord, PartialEq, PartialOrd)]
-struct D(u32);
-
-// do not lint if ord is not manually implemented
-
-#[derive(Eq, PartialEq)]
-struct E(u32);
-
-impl PartialOrd for E {
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        todo!();
-    }
-}
-
-// do not lint since ord has more restrictive bounds
-
-#[derive(Eq, PartialEq)]
-struct Uwu<A>(A);
-
-impl<A: std::fmt::Debug + Ord + PartialOrd> Ord for Uwu<A> {
-    fn cmp(&self, other: &Self) -> Ordering {
-        todo!();
-    }
-}
-
-impl<A: Ord + PartialOrd> PartialOrd for Uwu<A> {
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        todo!();
-    }
-}
diff --git a/tests/ui/needless_partial_ord_impl.rs b/tests/ui/needless_partial_ord_impl.rs
deleted file mode 100644
index 8f5c1337369..00000000000
--- a/tests/ui/needless_partial_ord_impl.rs
+++ /dev/null
@@ -1,89 +0,0 @@
-//@run-rustfix
-#![allow(unused)]
-#![no_main]
-
-use std::cmp::Ordering;
-
-// lint
-
-#[derive(Eq, PartialEq)]
-struct A(u32);
-
-impl Ord for A {
-    fn cmp(&self, other: &Self) -> Ordering {
-        todo!();
-    }
-}
-
-impl PartialOrd for A {
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        todo!();
-    }
-}
-
-// do not lint
-
-#[derive(Eq, PartialEq)]
-struct B(u32);
-
-impl Ord for B {
-    fn cmp(&self, other: &Self) -> Ordering {
-        todo!();
-    }
-}
-
-impl PartialOrd for B {
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        Some(self.cmp(other))
-    }
-}
-
-// lint, but we can't give a suggestion since &Self is not named
-
-#[derive(Eq, PartialEq)]
-struct C(u32);
-
-impl Ord for C {
-    fn cmp(&self, other: &Self) -> Ordering {
-        todo!();
-    }
-}
-
-impl PartialOrd for C {
-    fn partial_cmp(&self, _: &Self) -> Option<Ordering> {
-        todo!();
-    }
-}
-
-// do not lint derived
-
-#[derive(Eq, Ord, PartialEq, PartialOrd)]
-struct D(u32);
-
-// do not lint if ord is not manually implemented
-
-#[derive(Eq, PartialEq)]
-struct E(u32);
-
-impl PartialOrd for E {
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        todo!();
-    }
-}
-
-// do not lint since ord has more restrictive bounds
-
-#[derive(Eq, PartialEq)]
-struct Uwu<A>(A);
-
-impl<A: std::fmt::Debug + Ord + PartialOrd> Ord for Uwu<A> {
-    fn cmp(&self, other: &Self) -> Ordering {
-        todo!();
-    }
-}
-
-impl<A: Ord + PartialOrd> PartialOrd for Uwu<A> {
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        todo!();
-    }
-}
diff --git a/tests/ui/needless_partial_ord_impl.stderr b/tests/ui/needless_partial_ord_impl.stderr
deleted file mode 100644
index b8978462cc0..00000000000
--- a/tests/ui/needless_partial_ord_impl.stderr
+++ /dev/null
@@ -1,28 +0,0 @@
-error: manual implementation of `PartialOrd` when `Ord` is already implemented
-  --> $DIR/needless_partial_ord_impl.rs:18:1
-   |
-LL | /  impl PartialOrd for A {
-LL | |      fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-   | | _____________________________________________________________-
-LL | ||         todo!();
-LL | ||     }
-   | ||_____- help: change this to: `{ Some(self.cmp(self)) }`
-LL | |  }
-   | |__^
-   |
-   = note: `#[deny(clippy::needless_partial_ord_impl)]` on by default
-
-error: manual implementation of `PartialOrd` when `Ord` is already implemented
-  --> $DIR/needless_partial_ord_impl.rs:52:1
-   |
-LL | /  impl PartialOrd for C {
-LL | |      fn partial_cmp(&self, _: &Self) -> Option<Ordering> {
-   | | _________________________________________________________-
-LL | ||         todo!();
-LL | ||     }
-   | ||_____- help: change this to: `{ Some(self.cmp(self)) }`
-LL | |  }
-   | |__^
-
-error: aborting due to 2 previous errors
-
-- 
cgit 1.4.1-3-g733a5


From a5dfb68491505d8ad2aceb8cb14e1bd7272dcc2a Mon Sep 17 00:00:00 2001
From: Catherine <114838443+Centri3@users.noreply.github.com>
Date: Fri, 30 Jun 2023 15:16:56 -0500
Subject: refactor

---
 clippy_lints/src/incorrect_impls.rs                |  76 +++++++-------
 tests/ui/incorrect_clone_impl_on_copy_type.stderr  |   4 +-
 .../incorrect_partial_ord_impl_on_ord_type.fixed   | 114 +++++++++++++++++++++
 tests/ui/incorrect_partial_ord_impl_on_ord_type.rs |   5 +-
 .../incorrect_partial_ord_impl_on_ord_type.stderr  |  23 +++--
 5 files changed, 173 insertions(+), 49 deletions(-)
 create mode 100644 tests/ui/incorrect_partial_ord_impl_on_ord_type.fixed

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/incorrect_impls.rs b/clippy_lints/src/incorrect_impls.rs
index f7894f9c17b..25e1cb36b74 100644
--- a/clippy_lints/src/incorrect_impls.rs
+++ b/clippy_lints/src/incorrect_impls.rs
@@ -4,13 +4,12 @@ use clippy_utils::{
     ty::implements_trait,
 };
 use rustc_errors::Applicability;
-use rustc_hir::{def::Res, Expr, ExprKind, ImplItem, ImplItemKind, ItemKind, LangItem, Node, PatKind, UnOp};
-use rustc_hir::{ExprKind, ImplItem, ImplItemKind, Node, UnOp};
+use rustc_hir::{def::Res, Expr, ExprKind, ImplItem, ImplItemKind, ItemKind, LangItem, Node, UnOp};
+use rustc_hir_analysis::hir_ty_to_ty;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::EarlyBinder;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::{sym, symbol};
-use std::borrow::Cow;
+use rustc_span::{sym, symbol::kw};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -61,31 +60,39 @@ declare_clippy_lint! {
     /// wrapping the result of `cmp` in `Some` for `partial_cmp`. Not doing this may silently
     /// introduce an error upon refactoring.
     ///
+    /// ### Limitations
+    /// Will not lint if `Self` and `Rhs` do not have the same type.
+    ///
     /// ### Example
-    /// ```rust,ignore
+    /// ```rust
+    /// # use std::cmp::Ordering;
     /// #[derive(Eq, PartialEq)]
     /// struct A(u32);
     ///
     /// impl Ord for A {
     ///     fn cmp(&self, other: &Self) -> Ordering {
-    ///         todo!();
+    ///         // ...
+    /// #       todo!();
     ///     }
     /// }
     ///
     /// impl PartialOrd for A {
     ///     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-    ///         todo!();
+    ///         // ...
+    /// #       todo!();
     ///     }
     /// }
     /// ```
     /// Use instead:
-    /// ```rust,ignore
+    /// ```rust
+    /// # use std::cmp::Ordering;
     /// #[derive(Eq, PartialEq)]
     /// struct A(u32);
     ///
     /// impl Ord for A {
     ///     fn cmp(&self, other: &Self) -> Ordering {
-    ///         todo!();
+    ///         // ...
+    /// #       todo!();
     ///     }
     /// }
     ///
@@ -105,17 +112,18 @@ declare_lint_pass!(IncorrectImpls => [INCORRECT_CLONE_IMPL_ON_COPY_TYPE, INCORRE
 impl LateLintPass<'_> for IncorrectImpls {
     #[expect(clippy::too_many_lines)]
     fn check_impl_item(&mut self, cx: &LateContext<'_>, impl_item: &ImplItem<'_>) {
-        let node = get_parent_node(cx.tcx, impl_item.hir_id());
-        let Some(Node::Item(item)) = node else {
+        let Some(Node::Item(item)) = get_parent_node(cx.tcx, impl_item.hir_id()) else {
             return;
         };
         let Some(trait_impl) = cx.tcx.impl_trait_ref(item.owner_id).map(EarlyBinder::skip_binder) else {
             return;
         };
-        let trait_impl_def_id = trait_impl.def_id;
         if cx.tcx.is_automatically_derived(item.owner_id.to_def_id()) {
             return;
         }
+        let ItemKind::Impl(imp) = item.kind else {
+            return;
+        };
         let ImplItemKind::Fn(_, impl_item_id) = cx.tcx.hir().impl_item(impl_item.impl_item_id()).kind else {
             return;
         };
@@ -124,7 +132,7 @@ impl LateLintPass<'_> for IncorrectImpls {
             return;
         };
 
-        if cx.tcx.is_diagnostic_item(sym::Clone, trait_impl_def_id)
+        if cx.tcx.is_diagnostic_item(sym::Clone, trait_impl.def_id)
             && let Some(copy_def_id) = cx.tcx.get_diagnostic_item(sym::Copy)
             && implements_trait(
                     cx,
@@ -136,9 +144,9 @@ impl LateLintPass<'_> for IncorrectImpls {
             if impl_item.ident.name == sym::clone {
                 if block.stmts.is_empty()
                     && let Some(expr) = block.expr
-                    && let ExprKind::Unary(UnOp::Deref, inner) = expr.kind
-                    && let ExprKind::Path(qpath) = inner.kind
-                    && last_path_segment(&qpath).ident.name == symbol::kw::SelfLower
+                    && let ExprKind::Unary(UnOp::Deref, deref) = expr.kind
+                    && let ExprKind::Path(qpath) = deref.kind
+                    && last_path_segment(&qpath).ident.name == kw::SelfLower
                 {} else {
                     span_lint_and_sugg(
                         cx,
@@ -160,7 +168,7 @@ impl LateLintPass<'_> for IncorrectImpls {
                     INCORRECT_CLONE_IMPL_ON_COPY_TYPE,
                     impl_item.span,
                     "incorrect implementation of `clone_from` on a `Copy` type",
-                    "remove this",
+                    "remove it",
                     String::new(),
                     Applicability::MaybeIncorrect,
                 );
@@ -169,7 +177,7 @@ impl LateLintPass<'_> for IncorrectImpls {
             }
         }
 
-        if cx.tcx.is_diagnostic_item(sym::PartialOrd, trait_impl_def_id)
+        if cx.tcx.is_diagnostic_item(sym::PartialOrd, trait_impl.def_id)
             && impl_item.ident.name == sym::partial_cmp
             && let Some(ord_def_id) = cx
                 .tcx
@@ -198,12 +206,9 @@ impl LateLintPass<'_> for IncorrectImpls {
                 && cmp_path.ident.name == sym::cmp
                 && let Res::Local(..) = path_res(cx, other_expr)
             {} else {
-                // If lhs and rhs are not the same type, bail. This makes creating a valid
+                // If `Self` and `Rhs` are not the same type, bail. This makes creating a valid
                 // suggestion tons more complex.
-                if let Some(lhs) = trait_impl.substs.get(0)
-                    && let Some(rhs) = trait_impl.substs.get(1)
-                    && lhs != rhs
-                {
+                if let [lhs, rhs, ..] = trait_impl.substs.as_slice() && lhs != rhs {
                     return;
                 }
 
@@ -213,22 +218,23 @@ impl LateLintPass<'_> for IncorrectImpls {
                     item.span,
                     "incorrect implementation of `partial_cmp` on an `Ord` type",
                     |diag| {
-                        let (help, app) = if let Some(other) = body.params.get(1)
-                            && let PatKind::Binding(_, _, other_ident, ..) = other.pat.kind
-                        {
-                            (
-                                Cow::Owned(format!("{{ Some(self.cmp({})) }}", other_ident.name)),
-                                Applicability::Unspecified,
-                            )
+                        let [_, other] = body.params else {
+                            return;
+                        };
+
+                        let suggs = if let Some(other_ident) = other.pat.simple_ident() {
+                            vec![(block.span, format!("{{ Some(self.cmp({})) }}", other_ident.name))]
                         } else {
-                            (Cow::Borrowed("{ Some(self.cmp(...)) }"), Applicability::HasPlaceholders)
+                            vec![
+                                (block.span, "{ Some(self.cmp(other)) }".to_owned()),
+                                (other.pat.span, "other".to_owned()),
+                            ]
                         };
 
-                        diag.span_suggestion(
-                            block.span,
+                        diag.multipart_suggestion(
                             "change this to",
-                            help,
-                            app,
+                            suggs,
+                            Applicability::Unspecified,
                         );
                     }
                 );
diff --git a/tests/ui/incorrect_clone_impl_on_copy_type.stderr b/tests/ui/incorrect_clone_impl_on_copy_type.stderr
index 0021841aa86..7bcba8ba45a 100644
--- a/tests/ui/incorrect_clone_impl_on_copy_type.stderr
+++ b/tests/ui/incorrect_clone_impl_on_copy_type.stderr
@@ -16,7 +16,7 @@ LL | /     fn clone_from(&mut self, source: &Self) {
 LL | |         source.clone();
 LL | |         *self = source.clone();
 LL | |     }
-   | |_____^ help: remove this
+   | |_____^ help: remove it
 
 error: incorrect implementation of `clone` on a `Copy` type
   --> $DIR/incorrect_clone_impl_on_copy_type.rs:81:29
@@ -34,7 +34,7 @@ LL | /     fn clone_from(&mut self, source: &Self) {
 LL | |         source.clone();
 LL | |         *self = source.clone();
 LL | |     }
-   | |_____^ help: remove this
+   | |_____^ help: remove it
 
 error: aborting due to 4 previous errors
 
diff --git a/tests/ui/incorrect_partial_ord_impl_on_ord_type.fixed b/tests/ui/incorrect_partial_ord_impl_on_ord_type.fixed
new file mode 100644
index 00000000000..dd4fdd98822
--- /dev/null
+++ b/tests/ui/incorrect_partial_ord_impl_on_ord_type.fixed
@@ -0,0 +1,114 @@
+//@run-rustfix
+#![allow(unused)]
+#![no_main]
+
+use std::cmp::Ordering;
+
+// lint
+
+#[derive(Eq, PartialEq)]
+struct A(u32);
+
+impl Ord for A {
+    fn cmp(&self, other: &Self) -> Ordering {
+        todo!();
+    }
+}
+
+impl PartialOrd for A {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> { Some(self.cmp(other)) }
+}
+
+// do not lint
+
+#[derive(Eq, PartialEq)]
+struct B(u32);
+
+impl Ord for B {
+    fn cmp(&self, other: &Self) -> Ordering {
+        todo!();
+    }
+}
+
+impl PartialOrd for B {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+// lint, and give `_` a name
+
+#[derive(Eq, PartialEq)]
+struct C(u32);
+
+impl Ord for C {
+    fn cmp(&self, other: &Self) -> Ordering {
+        todo!();
+    }
+}
+
+impl PartialOrd for C {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> { Some(self.cmp(other)) }
+}
+
+// do not lint derived
+
+#[derive(Eq, Ord, PartialEq, PartialOrd)]
+struct D(u32);
+
+// do not lint if ord is not manually implemented
+
+#[derive(Eq, PartialEq)]
+struct E(u32);
+
+impl PartialOrd for E {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        todo!();
+    }
+}
+
+// do not lint since ord has more restrictive bounds
+
+#[derive(Eq, PartialEq)]
+struct Uwu<A>(A);
+
+impl<A: std::fmt::Debug + Ord + PartialOrd> Ord for Uwu<A> {
+    fn cmp(&self, other: &Self) -> Ordering {
+        todo!();
+    }
+}
+
+impl<A: Ord + PartialOrd> PartialOrd for Uwu<A> {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        todo!();
+    }
+}
+
+// do not lint since `Rhs` is not `Self`
+
+#[derive(Eq, PartialEq)]
+struct F(u32);
+
+impl Ord for F {
+    fn cmp(&self, other: &Self) -> Ordering {
+        todo!();
+    }
+}
+
+impl PartialOrd for F {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl PartialEq<u32> for F {
+    fn eq(&self, other: &u32) -> bool {
+        todo!();
+    }
+}
+
+impl PartialOrd<u32> for F {
+    fn partial_cmp(&self, other: &u32) -> Option<Ordering> {
+        todo!();
+    }
+}
diff --git a/tests/ui/incorrect_partial_ord_impl_on_ord_type.rs b/tests/ui/incorrect_partial_ord_impl_on_ord_type.rs
index 25fe909a8d3..522e82299c0 100644
--- a/tests/ui/incorrect_partial_ord_impl_on_ord_type.rs
+++ b/tests/ui/incorrect_partial_ord_impl_on_ord_type.rs
@@ -1,3 +1,4 @@
+//@run-rustfix
 #![allow(unused)]
 #![no_main]
 
@@ -37,7 +38,7 @@ impl PartialOrd for B {
     }
 }
 
-// lint, but we can't give a suggestion since &Self is not named
+// lint, and give `_` a name
 
 #[derive(Eq, PartialEq)]
 struct C(u32);
@@ -50,7 +51,7 @@ impl Ord for C {
 
 impl PartialOrd for C {
     fn partial_cmp(&self, _: &Self) -> Option<Ordering> {
-        todo!(); // don't run rustfix, or else this will cause it to fail to compile
+        todo!();
     }
 }
 
diff --git a/tests/ui/incorrect_partial_ord_impl_on_ord_type.stderr b/tests/ui/incorrect_partial_ord_impl_on_ord_type.stderr
index 86b3d37241a..0e477798c40 100644
--- a/tests/ui/incorrect_partial_ord_impl_on_ord_type.stderr
+++ b/tests/ui/incorrect_partial_ord_impl_on_ord_type.stderr
@@ -1,5 +1,5 @@
 error: incorrect implementation of `partial_cmp` on an `Ord` type
-  --> $DIR/incorrect_partial_ord_impl_on_ord_type.rs:17:1
+  --> $DIR/incorrect_partial_ord_impl_on_ord_type.rs:18:1
    |
 LL | /  impl PartialOrd for A {
 LL | |      fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
@@ -13,16 +13,19 @@ LL | |  }
    = note: `#[deny(clippy::incorrect_partial_ord_impl_on_ord_type)]` on by default
 
 error: incorrect implementation of `partial_cmp` on an `Ord` type
-  --> $DIR/incorrect_partial_ord_impl_on_ord_type.rs:51:1
+  --> $DIR/incorrect_partial_ord_impl_on_ord_type.rs:52:1
    |
-LL | /  impl PartialOrd for C {
-LL | |      fn partial_cmp(&self, _: &Self) -> Option<Ordering> {
-   | | _________________________________________________________-
-LL | ||         todo!(); // don't run rustfix, or else this will cause it to fail to compile
-LL | ||     }
-   | ||_____- help: change this to: `{ Some(self.cmp(...)) }`
-LL | |  }
-   | |__^
+LL | / impl PartialOrd for C {
+LL | |     fn partial_cmp(&self, _: &Self) -> Option<Ordering> {
+LL | |         todo!();
+LL | |     }
+LL | | }
+   | |_^
+   |
+help: change this to
+   |
+LL |     fn partial_cmp(&self, other: &Self) -> Option<Ordering> { Some(self.cmp(other)) }
+   |                           ~~~~~                             ~~~~~~~~~~~~~~~~~~~~~~~~~
 
 error: aborting due to 2 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 41438c2b90f0324494c6ca22d205bf0acec4c03c Mon Sep 17 00:00:00 2001
From: Catherine <114838443+Centri3@users.noreply.github.com>
Date: Tue, 4 Jul 2023 12:49:15 -0500
Subject: Refactor, remove `Constant::to_bits`

---
 README.md                                |  2 +-
 book/src/README.md                       |  2 +-
 clippy_lints/src/manual_float_methods.rs | 59 ++++++++++++++++++++------------
 clippy_utils/src/consts.rs               | 11 ------
 tests/ui/manual_float_methods.rs         | 21 +++++++++++-
 tests/ui/manual_float_methods.stderr     | 12 +++----
 6 files changed, 66 insertions(+), 41 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/README.md b/README.md
index d712d3e6750..5d490645d89 100644
--- a/README.md
+++ b/README.md
@@ -5,7 +5,7 @@
 
 A collection of lints to catch common mistakes and improve your [Rust](https://github.com/rust-lang/rust) code.
 
-[There are over 600 lints included in this crate!](https://rust-lang.github.io/rust-clippy/master/index.html)
+[There are over 650 lints included in this crate!](https://rust-lang.github.io/rust-clippy/master/index.html)
 
 Lints are divided into categories, each with a default [lint level](https://doc.rust-lang.org/rustc/lints/levels.html).
 You can choose how much Clippy is supposed to ~~annoy~~ help you by changing the lint level by category.
diff --git a/book/src/README.md b/book/src/README.md
index 3b627096268..486ea3df704 100644
--- a/book/src/README.md
+++ b/book/src/README.md
@@ -6,7 +6,7 @@
 A collection of lints to catch common mistakes and improve your
 [Rust](https://github.com/rust-lang/rust) code.
 
-[There are over 600 lints included in this crate!](https://rust-lang.github.io/rust-clippy/master/index.html)
+[There are over 650 lints included in this crate!](https://rust-lang.github.io/rust-clippy/master/index.html)
 
 Lints are divided into categories, each with a default [lint
 level](https://doc.rust-lang.org/rustc/lints/levels.html). You can choose how
diff --git a/clippy_lints/src/manual_float_methods.rs b/clippy_lints/src/manual_float_methods.rs
index 0f488627b4e..09b39634333 100644
--- a/clippy_lints/src/manual_float_methods.rs
+++ b/clippy_lints/src/manual_float_methods.rs
@@ -1,5 +1,8 @@
 use clippy_utils::{
-    consts::constant, diagnostics::span_lint_and_then, is_from_proc_macro, path_to_local, source::snippet_opt,
+    consts::{constant, Constant},
+    diagnostics::span_lint_and_then,
+    is_from_proc_macro, path_to_local,
+    source::snippet_opt,
 };
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind};
@@ -9,10 +12,11 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for `x == <float>::INFINITY || x == <float>::NEG_INFINITY`.
+    /// Checks for manual `is_infinite` reimplementations
+    /// (i.e., `x == <float>::INFINITY || x == <float>::NEG_INFINITY`).
     ///
     /// ### Why is this bad?
-    /// This should use the dedicated method instead, `is_infinite`.
+    /// The method `is_infinite` is shorter and more readable.
     ///
     /// ### Example
     /// ```rust
@@ -31,20 +35,23 @@ declare_clippy_lint! {
 }
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for `x != <float>::INFINITY && x != <float>::NEG_INFINITY`.
+    /// Checks for manual `is_finite` reimplementations
+    /// (i.e., `x != <float>::INFINITY && x != <float>::NEG_INFINITY`).
     ///
     /// ### Why is this bad?
-    /// This should use the dedicated method instead, `is_finite`.
+    /// The method `is_finite` is shorter and more readable.
     ///
     /// ### Example
     /// ```rust
     /// # let x = 1.0f32;
     /// if x != f32::INFINITY && x != f32::NEG_INFINITY {}
+    /// if x.abs() < f32::INFINITY {}
     /// ```
     /// Use instead:
     /// ```rust
     /// # let x = 1.0f32;
     /// if x.is_finite() {}
+    /// if x.is_finite() {}
     /// ```
     #[clippy::version = "1.72.0"]
     pub MANUAL_IS_FINITE,
@@ -84,20 +91,22 @@ impl<'tcx> LateLintPass<'tcx> for ManualFloatMethods {
             && let ExprKind::Binary(rhs_kind, rhs_lhs, rhs_rhs) = rhs.kind
             // Checking all possible scenarios using a function would be a hopeless task, as we have
             // 16 possible alignments of constants/operands. For now, let's use `partition`.
-            && let (operands, consts) = [lhs_lhs, lhs_rhs, rhs_lhs, rhs_rhs]
+            && let (operands, constants) = [lhs_lhs, lhs_rhs, rhs_lhs, rhs_rhs]
                 .into_iter()
                 .partition::<Vec<&Expr<'_>>, _>(|i| path_to_local(i).is_some())
             && let [first, second] = &*operands
-            && let Some([const_1, const_2]) = consts
+            && let Some([const_1, const_2]) = constants
                 .into_iter()
-                .map(|i| constant(cx, cx.typeck_results(), i).and_then(|c| c.to_bits()))
+                .map(|i| constant(cx, cx.typeck_results(), i))
                 .collect::<Option<Vec<_>>>()
                 .as_deref()
             && path_to_local(first).is_some_and(|f| path_to_local(second).is_some_and(|s| f == s))
-            && (is_infinity(*const_1) && is_neg_infinity(*const_2)
-                || is_neg_infinity(*const_1) && is_infinity(*const_2))
-            && let Some(local_snippet) = snippet_opt(cx, first.span)
+            // The actual infinity check, we also allow `NEG_INFINITY` before` INFINITY` just in
+            // case somebody does that for some reason
+            && (is_infinity(const_1) && is_neg_infinity(const_2)
+                || is_neg_infinity(const_1) && is_infinity(const_2))
             && !is_from_proc_macro(cx, expr)
+            && let Some(local_snippet) = snippet_opt(cx, first.span)
         {
             let variant = match (kind.node, lhs_kind.node, rhs_kind.node) {
                 (BinOpKind::Or, BinOpKind::Eq, BinOpKind::Eq) => Variant::ManualIsInfinite,
@@ -128,31 +137,39 @@ impl<'tcx> LateLintPass<'tcx> for ManualFloatMethods {
                                 "use the dedicated method instead",
                                 format!("{local_snippet}.is_finite()"),
                                 Applicability::MaybeIncorrect,
-                            );
-                            diag.span_suggestion_verbose(
+                            )
+                            .span_suggestion_verbose(
                                 expr.span,
                                 "this will alter how it handles NaN; if that is a problem, use instead",
                                 format!("{local_snippet}.is_finite() || {local_snippet}.is_nan()"),
                                 Applicability::MaybeIncorrect,
-                            );
-                            diag.span_suggestion_verbose(
+                            )
+                            .span_suggestion_verbose(
                                 expr.span,
                                 "or, for conciseness",
                                 format!("!{local_snippet}.is_infinite()"),
                                 Applicability::MaybeIncorrect,
                             );
-                        }
+                        },
                     }
-                }
+                },
             );
         }
     }
 }
 
-fn is_infinity(bits: u128) -> bool {
-    bits == 0x7f80_0000 || bits == 0x7ff0_0000_0000_0000
+fn is_infinity(constant: &Constant<'_>) -> bool {
+    match constant {
+        Constant::F32(float) => *float == f32::INFINITY,
+        Constant::F64(float) => *float == f64::INFINITY,
+        _ => false,
+    }
 }
 
-fn is_neg_infinity(bits: u128) -> bool {
-    bits == 0xff80_0000 || bits == 0xfff0_0000_0000_0000
+fn is_neg_infinity(constant: &Constant<'_>) -> bool {
+    match constant {
+        Constant::F32(float) => *float == f32::NEG_INFINITY,
+        Constant::F64(float) => *float == f64::NEG_INFINITY,
+        _ => false,
+    }
 }
diff --git a/clippy_utils/src/consts.rs b/clippy_utils/src/consts.rs
index b9f8eefeb8e..87d85d742ce 100644
--- a/clippy_utils/src/consts.rs
+++ b/clippy_utils/src/consts.rs
@@ -190,17 +190,6 @@ impl<'tcx> Constant<'tcx> {
         }
     }
 
-    /// Returns the bit representation if `self` is a bool, integer, or float.
-    pub fn to_bits(&self) -> Option<u128> {
-        match self {
-            Constant::Int(int) => Some(*int),
-            Constant::F32(float) => Some(u128::from(float.to_bits())),
-            Constant::F64(float) => Some(u128::from(float.to_bits())),
-            Constant::Bool(bool) => Some(u128::from(*bool)),
-            _ => None,
-        }
-    }
-
     /// Returns the integer value or `None` if `self` or `val_type` is not integer type.
     pub fn int_value(&self, cx: &LateContext<'_>, val_type: Ty<'_>) -> Option<FullInt> {
         if let Constant::Int(const_int) = *self {
diff --git a/tests/ui/manual_float_methods.rs b/tests/ui/manual_float_methods.rs
index b772202c003..af9076cfb71 100644
--- a/tests/ui/manual_float_methods.rs
+++ b/tests/ui/manual_float_methods.rs
@@ -1,6 +1,7 @@
 //@aux-build:proc_macros.rs:proc-macro
 #![allow(clippy::needless_if, unused)]
 #![warn(clippy::manual_is_infinite, clippy::manual_is_finite)]
+#![feature(inline_const)]
 
 #[macro_use]
 extern crate proc_macros;
@@ -8,6 +9,14 @@ extern crate proc_macros;
 const INFINITE: f32 = f32::INFINITY;
 const NEG_INFINITE: f32 = f32::NEG_INFINITY;
 
+fn fn_test() -> f64 {
+    f64::NEG_INFINITY
+}
+
+fn fn_test_not_inf() -> f64 {
+    112.0
+}
+
 fn main() {
     let x = 1.0f32;
     if x == f32::INFINITY || x == f32::NEG_INFINITY {}
@@ -20,8 +29,18 @@ fn main() {
     // Don't lint
     if x.is_infinite() {}
     if x.is_finite() {}
-    // If they're doing it this way, they probably know what they're doing
     if x.abs() < f64::INFINITY {}
+    if f64::INFINITY > x.abs() {}
+    if f64::abs(x) < f64::INFINITY {}
+    if f64::INFINITY > f64::abs(x) {}
+    // Is not evaluated by `clippy_utils::constant`
+    if x != f64::INFINITY && x != fn_test() {}
+    // Not -inf
+    if x != f64::INFINITY && x != fn_test_not_inf() {}
+    const X: f64 = 1.0f64;
+    // Will be linted if `const_float_classify` is enabled
+    if const { X == f64::INFINITY || X == f64::NEG_INFINITY } {}
+    if const { X != f64::INFINITY && X != f64::NEG_INFINITY } {}
     external! {
         let x = 1.0;
         if x == f32::INFINITY || x == f32::NEG_INFINITY {}
diff --git a/tests/ui/manual_float_methods.stderr b/tests/ui/manual_float_methods.stderr
index 7f4a4d2e95b..a56118b316a 100644
--- a/tests/ui/manual_float_methods.stderr
+++ b/tests/ui/manual_float_methods.stderr
@@ -1,5 +1,5 @@
 error: manually checking if a float is infinite
-  --> $DIR/manual_float_methods.rs:13:8
+  --> $DIR/manual_float_methods.rs:22:8
    |
 LL |     if x == f32::INFINITY || x == f32::NEG_INFINITY {}
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the dedicated method instead: `x.is_infinite()`
@@ -7,7 +7,7 @@ LL |     if x == f32::INFINITY || x == f32::NEG_INFINITY {}
    = note: `-D clippy::manual-is-infinite` implied by `-D warnings`
 
 error: manually checking if a float is finite
-  --> $DIR/manual_float_methods.rs:14:8
+  --> $DIR/manual_float_methods.rs:23:8
    |
 LL |     if x != f32::INFINITY && x != f32::NEG_INFINITY {}
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -27,13 +27,13 @@ LL |     if !x.is_infinite() {}
    |        ~~~~~~~~~~~~~~~~
 
 error: manually checking if a float is infinite
-  --> $DIR/manual_float_methods.rs:15:8
+  --> $DIR/manual_float_methods.rs:24:8
    |
 LL |     if x == INFINITE || x == NEG_INFINITE {}
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the dedicated method instead: `x.is_infinite()`
 
 error: manually checking if a float is finite
-  --> $DIR/manual_float_methods.rs:16:8
+  --> $DIR/manual_float_methods.rs:25:8
    |
 LL |     if x != INFINITE && x != NEG_INFINITE {}
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -52,13 +52,13 @@ LL |     if !x.is_infinite() {}
    |        ~~~~~~~~~~~~~~~~
 
 error: manually checking if a float is infinite
-  --> $DIR/manual_float_methods.rs:18:8
+  --> $DIR/manual_float_methods.rs:27:8
    |
 LL |     if x == f64::INFINITY || x == f64::NEG_INFINITY {}
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the dedicated method instead: `x.is_infinite()`
 
 error: manually checking if a float is finite
-  --> $DIR/manual_float_methods.rs:19:8
+  --> $DIR/manual_float_methods.rs:28:8
    |
 LL |     if x != f64::INFINITY && x != f64::NEG_INFINITY {}
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From 2be695bf290299563c5589b3954bd9d044cfa6b9 Mon Sep 17 00:00:00 2001
From: Caio <c410.f3r@gmail.com>
Date: Sat, 8 Jul 2023 17:43:34 -0300
Subject: [significant_drop_tightening] Fix #11128

---
 clippy_lints/src/significant_drop_tightening.rs | 11 ++++++-----
 clippy_utils/src/paths.rs                       |  1 +
 tests/ui/significant_drop_tightening.fixed      | 23 +++++++++++++++++++++++
 tests/ui/significant_drop_tightening.rs         | 23 +++++++++++++++++++++++
 tests/ui/significant_drop_tightening.stderr     |  6 +++---
 5 files changed, 56 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/significant_drop_tightening.rs b/clippy_lints/src/significant_drop_tightening.rs
index fffa8a380c2..3febf747967 100644
--- a/clippy_lints/src/significant_drop_tightening.rs
+++ b/clippy_lints/src/significant_drop_tightening.rs
@@ -1,12 +1,13 @@
 use clippy_utils::{
     diagnostics::span_lint_and_then,
-    expr_or_init, get_attr, path_to_local,
+    expr_or_init, get_attr, match_def_path, path_to_local, paths,
     source::{indent_of, snippet},
 };
 use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexMap};
 use rustc_errors::Applicability;
 use rustc_hir::{
     self as hir,
+    def::{DefKind, Res},
     intravisit::{walk_expr, Visitor},
 };
 use rustc_lint::{LateContext, LateLintPass, LintContext};
@@ -333,7 +334,7 @@ impl<'ap, 'lc, 'others, 'stmt, 'tcx> Visitor<'tcx> for StmtsChecker<'ap, 'lc, 'o
                         }
                     },
                     hir::StmtKind::Semi(expr) => {
-                        if has_drop(expr, &apa.first_bind_ident) {
+                        if has_drop(expr, &apa.first_bind_ident, self.cx) {
                             apa.has_expensive_expr_after_last_attr = false;
                             apa.last_stmt_span = DUMMY_SP;
                             return;
@@ -430,11 +431,11 @@ fn dummy_stmt_expr<'any>(expr: &'any hir::Expr<'any>) -> hir::Stmt<'any> {
     }
 }
 
-fn has_drop(expr: &hir::Expr<'_>, first_bind_ident: &Ident) -> bool {
+fn has_drop(expr: &hir::Expr<'_>, first_bind_ident: &Ident, lcx: &LateContext<'_>) -> bool {
     if let hir::ExprKind::Call(fun, args) = expr.kind
         && let hir::ExprKind::Path(hir::QPath::Resolved(_, fun_path)) = &fun.kind
-        && let [fun_ident, ..] = fun_path.segments
-        && fun_ident.ident.name == rustc_span::sym::drop
+        && let Res::Def(DefKind::Fn, did) = fun_path.res
+        && match_def_path(lcx, did, &paths::DROP)
         && let [first_arg, ..] = args
         && let hir::ExprKind::Path(hir::QPath::Resolved(_, arg_path)) = &first_arg.kind
         && let [first_arg_ps, .. ] = arg_path.segments
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index 0e6f01287b5..e8510987225 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -57,6 +57,7 @@ pub const LATE_CONTEXT: [&str; 2] = ["rustc_lint", "LateContext"];
 pub const LATE_LINT_PASS: [&str; 3] = ["rustc_lint", "passes", "LateLintPass"];
 #[cfg(feature = "internal")]
 pub const LINT: [&str; 2] = ["rustc_lint_defs", "Lint"];
+pub const DROP: [&str; 3] = ["core", "mem", "drop"];
 pub const MEM_SWAP: [&str; 3] = ["core", "mem", "swap"];
 #[cfg(feature = "internal")]
 pub const MSRV: [&str; 3] = ["clippy_utils", "msrvs", "Msrv"];
diff --git a/tests/ui/significant_drop_tightening.fixed b/tests/ui/significant_drop_tightening.fixed
index 7b848ead784..eb8524167c4 100644
--- a/tests/ui/significant_drop_tightening.fixed
+++ b/tests/ui/significant_drop_tightening.fixed
@@ -28,6 +28,29 @@ pub fn issue_10413() {
     }
 }
 
+pub fn issue_11128() {
+    use std::mem::drop as unlock;
+
+    struct Foo {
+        droppable: Option<Vec<i32>>,
+        mutex: Mutex<Vec<i32>>,
+    }
+
+    impl Drop for Foo {
+        fn drop(&mut self) {
+            if let Some(droppable) = self.droppable.take() {
+                let lock = self.mutex.lock().unwrap();
+                let idx_opt = lock.iter().copied().find(|el| Some(el) == droppable.first());
+                if let Some(idx) = idx_opt {
+                    let local_droppable = vec![lock.first().copied().unwrap_or_default()];
+                    unlock(lock);
+                    drop(local_droppable);
+                }
+            }
+        }
+    }
+}
+
 pub fn path_return_can_be_ignored() -> i32 {
     let mutex = Mutex::new(1);
     let lock = mutex.lock().unwrap();
diff --git a/tests/ui/significant_drop_tightening.rs b/tests/ui/significant_drop_tightening.rs
index 36f77cf1bdb..f7fa65ea922 100644
--- a/tests/ui/significant_drop_tightening.rs
+++ b/tests/ui/significant_drop_tightening.rs
@@ -27,6 +27,29 @@ pub fn issue_10413() {
     }
 }
 
+pub fn issue_11128() {
+    use std::mem::drop as unlock;
+
+    struct Foo {
+        droppable: Option<Vec<i32>>,
+        mutex: Mutex<Vec<i32>>,
+    }
+
+    impl Drop for Foo {
+        fn drop(&mut self) {
+            if let Some(droppable) = self.droppable.take() {
+                let lock = self.mutex.lock().unwrap();
+                let idx_opt = lock.iter().copied().find(|el| Some(el) == droppable.first());
+                if let Some(idx) = idx_opt {
+                    let local_droppable = vec![lock.first().copied().unwrap_or_default()];
+                    unlock(lock);
+                    drop(local_droppable);
+                }
+            }
+        }
+    }
+}
+
 pub fn path_return_can_be_ignored() -> i32 {
     let mutex = Mutex::new(1);
     let lock = mutex.lock().unwrap();
diff --git a/tests/ui/significant_drop_tightening.stderr b/tests/ui/significant_drop_tightening.stderr
index 3bdac0b0a6b..ca4fede17c9 100644
--- a/tests/ui/significant_drop_tightening.stderr
+++ b/tests/ui/significant_drop_tightening.stderr
@@ -23,7 +23,7 @@ LL +     drop(lock);
    |
 
 error: temporary with significant `Drop` can be early dropped
-  --> $DIR/significant_drop_tightening.rs:56:13
+  --> $DIR/significant_drop_tightening.rs:79:13
    |
 LL | /     {
 LL | |         let mutex = Mutex::new(1i32);
@@ -43,7 +43,7 @@ LL +         drop(lock);
    |
 
 error: temporary with significant `Drop` can be early dropped
-  --> $DIR/significant_drop_tightening.rs:77:13
+  --> $DIR/significant_drop_tightening.rs:100:13
    |
 LL | /     {
 LL | |         let mutex = Mutex::new(1i32);
@@ -67,7 +67,7 @@ LL +
    |
 
 error: temporary with significant `Drop` can be early dropped
-  --> $DIR/significant_drop_tightening.rs:83:17
+  --> $DIR/significant_drop_tightening.rs:106:17
    |
 LL | /     {
 LL | |         let mutex = Mutex::new(vec![1i32]);
-- 
cgit 1.4.1-3-g733a5


From 6384221910ce09cca044511d52c489f6193bca7d Mon Sep 17 00:00:00 2001
From: Caio <c410.f3r@gmail.com>
Date: Sat, 8 Jul 2023 18:08:48 -0300
Subject: Dogfood

---
 clippy_lints/src/significant_drop_tightening.rs | 5 +++--
 clippy_utils/src/paths.rs                       | 1 -
 2 files changed, 3 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/significant_drop_tightening.rs b/clippy_lints/src/significant_drop_tightening.rs
index 3febf747967..cc2dbae4bc4 100644
--- a/clippy_lints/src/significant_drop_tightening.rs
+++ b/clippy_lints/src/significant_drop_tightening.rs
@@ -1,6 +1,6 @@
 use clippy_utils::{
     diagnostics::span_lint_and_then,
-    expr_or_init, get_attr, match_def_path, path_to_local, paths,
+    expr_or_init, get_attr, path_to_local,
     source::{indent_of, snippet},
 };
 use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexMap};
@@ -13,6 +13,7 @@ use rustc_hir::{
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::ty::{subst::GenericArgKind, Ty, TypeAndMut};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::sym;
 use rustc_span::{symbol::Ident, Span, DUMMY_SP};
 use std::borrow::Cow;
 
@@ -435,7 +436,7 @@ fn has_drop(expr: &hir::Expr<'_>, first_bind_ident: &Ident, lcx: &LateContext<'_
     if let hir::ExprKind::Call(fun, args) = expr.kind
         && let hir::ExprKind::Path(hir::QPath::Resolved(_, fun_path)) = &fun.kind
         && let Res::Def(DefKind::Fn, did) = fun_path.res
-        && match_def_path(lcx, did, &paths::DROP)
+        && lcx.tcx.is_diagnostic_item(sym::mem_drop, did)
         && let [first_arg, ..] = args
         && let hir::ExprKind::Path(hir::QPath::Resolved(_, arg_path)) = &first_arg.kind
         && let [first_arg_ps, .. ] = arg_path.segments
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index e8510987225..0e6f01287b5 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -57,7 +57,6 @@ pub const LATE_CONTEXT: [&str; 2] = ["rustc_lint", "LateContext"];
 pub const LATE_LINT_PASS: [&str; 3] = ["rustc_lint", "passes", "LateLintPass"];
 #[cfg(feature = "internal")]
 pub const LINT: [&str; 2] = ["rustc_lint_defs", "Lint"];
-pub const DROP: [&str; 3] = ["core", "mem", "drop"];
 pub const MEM_SWAP: [&str; 3] = ["core", "mem", "swap"];
 #[cfg(feature = "internal")]
 pub const MSRV: [&str; 3] = ["clippy_utils", "msrvs", "Msrv"];
-- 
cgit 1.4.1-3-g733a5


From 3bf2138289151bb400b53a9817d6e6ab2cf12f13 Mon Sep 17 00:00:00 2001
From: Samuel Moelius <sam@moeli.us>
Date: Sat, 8 Jul 2023 19:12:10 -0400
Subject: Fix #10535

---
 clippy_lints/src/dereference.rs |  4 ++--
 clippy_utils/src/mir/mod.rs     | 23 ++++++++++++++---------
 2 files changed, 16 insertions(+), 11 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index 73556c1053e..12f2f37e3c2 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -1296,8 +1296,8 @@ fn referent_used_exactly_once<'tcx>(
     possible_borrowers: &mut Vec<(LocalDefId, PossibleBorrowerMap<'tcx, 'tcx>)>,
     reference: &Expr<'tcx>,
 ) -> bool {
-    let mir = enclosing_mir(cx.tcx, reference.hir_id);
-    if let Some(local) = expr_local(cx.tcx, reference)
+    if let Some(mir) = enclosing_mir(cx.tcx, reference.hir_id)
+        && let Some(local) = expr_local(cx.tcx, reference)
         && let [location] = *local_assignments(mir, local).as_slice()
         && let Some(statement) = mir.basic_blocks[location.block].statements.get(location.statement_index)
         && let StatementKind::Assign(box (_, Rvalue::Ref(_, _, place))) = statement.kind
diff --git a/clippy_utils/src/mir/mod.rs b/clippy_utils/src/mir/mod.rs
index 26c0015e87e..131f3c0aa39 100644
--- a/clippy_utils/src/mir/mod.rs
+++ b/clippy_utils/src/mir/mod.rs
@@ -101,21 +101,26 @@ pub fn used_exactly_once(mir: &rustc_middle::mir::Body<'_>, local: rustc_middle:
 
 /// Returns the `mir::Body` containing the node associated with `hir_id`.
 #[allow(clippy::module_name_repetitions)]
-pub fn enclosing_mir(tcx: TyCtxt<'_>, hir_id: HirId) -> &Body<'_> {
+pub fn enclosing_mir(tcx: TyCtxt<'_>, hir_id: HirId) -> Option<&Body<'_>> {
     let body_owner_local_def_id = tcx.hir().enclosing_body_owner(hir_id);
-    tcx.optimized_mir(body_owner_local_def_id.to_def_id())
+    if tcx.hir().body_owner_kind(body_owner_local_def_id).is_fn_or_closure() {
+        Some(tcx.optimized_mir(body_owner_local_def_id.to_def_id()))
+    } else {
+        None
+    }
 }
 
 /// Tries to determine the `Local` corresponding to `expr`, if any.
 /// This function is expensive and should be used sparingly.
 pub fn expr_local(tcx: TyCtxt<'_>, expr: &Expr<'_>) -> Option<Local> {
-    let mir = enclosing_mir(tcx, expr.hir_id);
-    mir.local_decls.iter_enumerated().find_map(|(local, local_decl)| {
-        if local_decl.source_info.span == expr.span {
-            Some(local)
-        } else {
-            None
-        }
+    enclosing_mir(tcx, expr.hir_id).and_then(|mir| {
+        mir.local_decls.iter_enumerated().find_map(|(local, local_decl)| {
+            if local_decl.source_info.span == expr.span {
+                Some(local)
+            } else {
+                None
+            }
+        })
     })
 }
 
-- 
cgit 1.4.1-3-g733a5


From d1575d1f544691ec3c5b24834b99df0a7df0534a Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Sun, 9 Jul 2023 21:59:23 +0200
Subject: changelog: Fix typo in `needless_pass_by_ref_mut` lint description

---
 clippy_lints/src/needless_pass_by_ref_mut.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/needless_pass_by_ref_mut.rs b/clippy_lints/src/needless_pass_by_ref_mut.rs
index 96cb09c071a..46c9b6c4141 100644
--- a/clippy_lints/src/needless_pass_by_ref_mut.rs
+++ b/clippy_lints/src/needless_pass_by_ref_mut.rs
@@ -22,7 +22,7 @@ declare_clippy_lint! {
     /// ### What it does
     /// Check if a `&mut` function argument is actually used mutably.
     ///
-    /// Be careful if the function is publically reexported as it would break compatibility with
+    /// Be careful if the function is publicly reexported as it would break compatibility with
     /// users of this function.
     ///
     /// ### Why is this bad?
-- 
cgit 1.4.1-3-g733a5


From 23ac72316d7cf0c7979bf94544b2cc8f3ea3f89f Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Fri, 23 Jun 2023 23:23:36 +0200
Subject: adjust applicability and suggest making binding mutable

---
 clippy_lints/src/methods/filter_next.rs | 51 ++++++++++++++++++++++++++-------
 tests/ui/methods_unfixable.rs           | 10 +++++++
 tests/ui/methods_unfixable.stderr       | 15 ++++++++++
 3 files changed, 66 insertions(+), 10 deletions(-)
 create mode 100644 tests/ui/methods_unfixable.rs
 create mode 100644 tests/ui/methods_unfixable.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/filter_next.rs b/clippy_lints/src/methods/filter_next.rs
index ad71b494619..ce7f9997b5a 100644
--- a/clippy_lints/src/methods/filter_next.rs
+++ b/clippy_lints/src/methods/filter_next.rs
@@ -1,6 +1,7 @@
-use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg};
+use clippy_utils::diagnostics::{span_lint, span_lint_and_then};
 use clippy_utils::source::snippet;
 use clippy_utils::ty::implements_trait;
+use rustc_ast::{BindingAnnotation, Mutability};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
@@ -8,6 +9,21 @@ use rustc_span::sym;
 
 use super::FILTER_NEXT;
 
+fn path_to_local(expr: &hir::Expr<'_>) -> Option<hir::HirId> {
+    match expr.kind {
+        hir::ExprKind::Field(f, _) => path_to_local(f),
+        hir::ExprKind::Index(recv, _) => path_to_local(recv),
+        hir::ExprKind::Path(hir::QPath::Resolved(
+            _,
+            hir::Path {
+                res: rustc_hir::def::Res::Local(local),
+                ..
+            },
+        )) => Some(*local),
+        _ => None,
+    }
+}
+
 /// lint use of `filter().next()` for `Iterators`
 pub(super) fn check<'tcx>(
     cx: &LateContext<'tcx>,
@@ -26,15 +42,30 @@ pub(super) fn check<'tcx>(
         if filter_snippet.lines().count() <= 1 {
             let iter_snippet = snippet(cx, recv.span, "..");
             // add note if not multi-line
-            span_lint_and_sugg(
-                cx,
-                FILTER_NEXT,
-                expr.span,
-                msg,
-                "try",
-                format!("{iter_snippet}.find({filter_snippet})"),
-                Applicability::MachineApplicable,
-            );
+            span_lint_and_then(cx, FILTER_NEXT, expr.span, msg, |diag| {
+                let (applicability, pat) = if let Some(id) = path_to_local(recv)
+                    && let Some(hir::Node::Pat(pat)) = cx.tcx.hir().find(id)
+                    && let hir::PatKind::Binding(BindingAnnotation(_, Mutability::Not), _, ident, _) = pat.kind
+                {
+                    (Applicability::Unspecified, Some((pat.span, ident)))
+                } else {
+                    (Applicability::MachineApplicable, None)
+                };
+
+                diag.span_suggestion(
+                    expr.span,
+                    "try",
+                    format!("{iter_snippet}.find({filter_snippet})"),
+                    applicability,
+                );
+
+                if let Some((pat_span, ident)) = pat {
+                    diag.span_help(
+                        pat_span,
+                        format!("you will also need to make `{ident}` mutable, because `find` takes `&mut self`"),
+                    );
+                }
+            });
         } else {
             span_lint(cx, FILTER_NEXT, expr.span, msg);
         }
diff --git a/tests/ui/methods_unfixable.rs b/tests/ui/methods_unfixable.rs
new file mode 100644
index 00000000000..3d88ce4b6bb
--- /dev/null
+++ b/tests/ui/methods_unfixable.rs
@@ -0,0 +1,10 @@
+#![warn(clippy::filter_next)]
+
+fn main() {
+    issue10029();
+}
+
+pub fn issue10029() {
+    let iter = (0..10);
+    let _ = iter.filter(|_| true).next();
+}
diff --git a/tests/ui/methods_unfixable.stderr b/tests/ui/methods_unfixable.stderr
new file mode 100644
index 00000000000..6e101fe16b0
--- /dev/null
+++ b/tests/ui/methods_unfixable.stderr
@@ -0,0 +1,15 @@
+error: called `filter(..).next()` on an `Iterator`. This is more succinctly expressed by calling `.find(..)` instead
+  --> $DIR/methods_unfixable.rs:9:13
+   |
+LL |     let _ = iter.filter(|_| true).next();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `iter.find(|_| true)`
+   |
+help: you will also need to make `iter` mutable, because `find` takes `&mut self`
+  --> $DIR/methods_unfixable.rs:8:9
+   |
+LL |     let iter = (0..10);
+   |         ^^^^
+   = note: `-D clippy::filter-next` implied by `-D warnings`
+
+error: aborting due to previous error
+
-- 
cgit 1.4.1-3-g733a5


From cd1c8532e99c4c594c6704be6d4274131bb71004 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Tue, 4 Jul 2023 00:29:14 +0200
Subject: [`unnecessary_literal_unwrap`]: lint `unwrap_unchecked`

---
 clippy_lints/src/methods/mod.rs                    |  3 +
 .../src/methods/unnecessary_literal_unwrap.rs      | 16 +++++
 tests/ui/unnecessary_literal_unwrap.fixed          | 10 +++
 tests/ui/unnecessary_literal_unwrap.rs             | 10 +++
 tests/ui/unnecessary_literal_unwrap.stderr         | 74 +++++++++++++++++++++-
 5 files changed, 112 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index c99f7c1fdd9..6e936e92cbd 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -4000,6 +4000,9 @@ impl Methods {
                     unnecessary_literal_unwrap::check(cx, expr, recv, name, args);
                     unwrap_used::check(cx, expr, recv, false, self.allow_unwrap_in_tests);
                 },
+                ("unwrap_unchecked", []) => {
+                    unnecessary_literal_unwrap::check(cx, expr, recv, name, args);
+                }
                 ("unwrap_err", []) => {
                     unnecessary_literal_unwrap::check(cx, expr, recv, name, args);
                     unwrap_used::check(cx, expr, recv, true, self.allow_unwrap_in_tests);
diff --git a/clippy_lints/src/methods/unnecessary_literal_unwrap.rs b/clippy_lints/src/methods/unnecessary_literal_unwrap.rs
index ce93d7c3eb3..13895b67ed0 100644
--- a/clippy_lints/src/methods/unnecessary_literal_unwrap.rs
+++ b/clippy_lints/src/methods/unnecessary_literal_unwrap.rs
@@ -67,6 +67,22 @@ pub(super) fn check(
                 (expr.span.with_hi(args[0].span.lo()), "panic!(".to_string()),
                 (expr.span.with_lo(args[0].span.hi()), ")".to_string()),
             ]),
+            ("Some" | "Ok", "unwrap_unchecked", _) => {
+                let mut suggs = vec![
+                    (recv.span.with_hi(call_args[0].span.lo()), String::new()),
+                    (expr.span.with_lo(call_args[0].span.hi()), String::new()),
+                ];
+                // try to also remove the unsafe block if present
+                if let hir::Node::Block(block) = cx.tcx.hir().get_parent(expr.hir_id)
+                    && let hir::BlockCheckMode::UnsafeBlock(hir::UnsafeSource::UserProvided) = block.rules
+                {
+                    suggs.extend([
+                        (block.span.shrink_to_lo().to(expr.span.shrink_to_lo()), String::new()),
+                        (expr.span.shrink_to_hi().to(block.span.shrink_to_hi()), String::new())
+                    ]);
+                }
+                Some(suggs)
+            },
             (_, _, Some(_)) => None,
             ("Ok", "unwrap_err", None) | ("Err", "unwrap", None) => Some(vec![
                 (
diff --git a/tests/ui/unnecessary_literal_unwrap.fixed b/tests/ui/unnecessary_literal_unwrap.fixed
index 092bf78feab..0e7ba6bcbbb 100644
--- a/tests/ui/unnecessary_literal_unwrap.fixed
+++ b/tests/ui/unnecessary_literal_unwrap.fixed
@@ -78,6 +78,15 @@ fn unwrap_from_binding() {
     let _ = val.unwrap_or("");
 }
 
+fn unwrap_unchecked() {
+    let _ = 1;
+    let _ = unsafe { 1 + *(&1 as *const i32) }; // needs to keep the unsafe block
+    let _ = 1 + 1;
+    let _ = 1;
+    let _ = unsafe { 1 + *(&1 as *const i32) };
+    let _ = 1 + 1;
+}
+
 fn main() {
     unwrap_option_some();
     unwrap_option_none();
@@ -85,4 +94,5 @@ fn main() {
     unwrap_result_err();
     unwrap_methods_option();
     unwrap_methods_result();
+    unwrap_unchecked();
 }
diff --git a/tests/ui/unnecessary_literal_unwrap.rs b/tests/ui/unnecessary_literal_unwrap.rs
index b9df893d1d2..fda7fd36ff9 100644
--- a/tests/ui/unnecessary_literal_unwrap.rs
+++ b/tests/ui/unnecessary_literal_unwrap.rs
@@ -78,6 +78,15 @@ fn unwrap_from_binding() {
     let _ = val.unwrap_or("");
 }
 
+fn unwrap_unchecked() {
+    let _ = unsafe { Some(1).unwrap_unchecked() };
+    let _ = unsafe { Some(1).unwrap_unchecked() + *(&1 as *const i32) }; // needs to keep the unsafe block
+    let _ = unsafe { Some(1).unwrap_unchecked() } + 1;
+    let _ = unsafe { Ok::<_, ()>(1).unwrap_unchecked() };
+    let _ = unsafe { Ok::<_, ()>(1).unwrap_unchecked() + *(&1 as *const i32) };
+    let _ = unsafe { Ok::<_, ()>(1).unwrap_unchecked() } + 1;
+}
+
 fn main() {
     unwrap_option_some();
     unwrap_option_none();
@@ -85,4 +94,5 @@ fn main() {
     unwrap_result_err();
     unwrap_methods_option();
     unwrap_methods_result();
+    unwrap_unchecked();
 }
diff --git a/tests/ui/unnecessary_literal_unwrap.stderr b/tests/ui/unnecessary_literal_unwrap.stderr
index 0c71ee05323..e5b93c3d9af 100644
--- a/tests/ui/unnecessary_literal_unwrap.stderr
+++ b/tests/ui/unnecessary_literal_unwrap.stderr
@@ -409,5 +409,77 @@ LL -     Ok::<_, ()>(1).unwrap_or_else(|_| 2);
 LL +     1;
    |
 
-error: aborting due to 36 previous errors
+error: used `unwrap_unchecked()` on `Some` value
+  --> $DIR/unnecessary_literal_unwrap.rs:82:22
+   |
+LL |     let _ = unsafe { Some(1).unwrap_unchecked() };
+   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the `Some` and `unwrap_unchecked()`
+   |
+LL -     let _ = unsafe { Some(1).unwrap_unchecked() };
+LL +     let _ = 1;
+   |
+
+error: used `unwrap_unchecked()` on `Some` value
+  --> $DIR/unnecessary_literal_unwrap.rs:83:22
+   |
+LL |     let _ = unsafe { Some(1).unwrap_unchecked() + *(&1 as *const i32) }; // needs to keep the unsafe block
+   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the `Some` and `unwrap_unchecked()`
+   |
+LL -     let _ = unsafe { Some(1).unwrap_unchecked() + *(&1 as *const i32) }; // needs to keep the unsafe block
+LL +     let _ = unsafe { 1 + *(&1 as *const i32) }; // needs to keep the unsafe block
+   |
+
+error: used `unwrap_unchecked()` on `Some` value
+  --> $DIR/unnecessary_literal_unwrap.rs:84:22
+   |
+LL |     let _ = unsafe { Some(1).unwrap_unchecked() } + 1;
+   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the `Some` and `unwrap_unchecked()`
+   |
+LL -     let _ = unsafe { Some(1).unwrap_unchecked() } + 1;
+LL +     let _ = 1 + 1;
+   |
+
+error: used `unwrap_unchecked()` on `Ok` value
+  --> $DIR/unnecessary_literal_unwrap.rs:85:22
+   |
+LL |     let _ = unsafe { Ok::<_, ()>(1).unwrap_unchecked() };
+   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the `Ok` and `unwrap_unchecked()`
+   |
+LL -     let _ = unsafe { Ok::<_, ()>(1).unwrap_unchecked() };
+LL +     let _ = 1;
+   |
+
+error: used `unwrap_unchecked()` on `Ok` value
+  --> $DIR/unnecessary_literal_unwrap.rs:86:22
+   |
+LL |     let _ = unsafe { Ok::<_, ()>(1).unwrap_unchecked() + *(&1 as *const i32) };
+   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the `Ok` and `unwrap_unchecked()`
+   |
+LL -     let _ = unsafe { Ok::<_, ()>(1).unwrap_unchecked() + *(&1 as *const i32) };
+LL +     let _ = unsafe { 1 + *(&1 as *const i32) };
+   |
+
+error: used `unwrap_unchecked()` on `Ok` value
+  --> $DIR/unnecessary_literal_unwrap.rs:87:22
+   |
+LL |     let _ = unsafe { Ok::<_, ()>(1).unwrap_unchecked() } + 1;
+   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the `Ok` and `unwrap_unchecked()`
+   |
+LL -     let _ = unsafe { Ok::<_, ()>(1).unwrap_unchecked() } + 1;
+LL +     let _ = 1 + 1;
+   |
+
+error: aborting due to 42 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 0b5dac09757237a407a1cdfbff16eeb4606f6390 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Tue, 4 Jul 2023 00:49:18 +0200
Subject: [`unnecessary_literal_unwrap`]: also handle unwrap_err_unchecked

---
 clippy_lints/src/methods/mod.rs                        |  5 +----
 clippy_lints/src/methods/unnecessary_literal_unwrap.rs |  2 +-
 tests/ui/unnecessary_literal_unwrap.fixed              |  1 +
 tests/ui/unnecessary_literal_unwrap.rs                 |  1 +
 tests/ui/unnecessary_literal_unwrap.stderr             | 14 +++++++++++++-
 5 files changed, 17 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 6e936e92cbd..d6057ce45f6 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -4000,9 +4000,6 @@ impl Methods {
                     unnecessary_literal_unwrap::check(cx, expr, recv, name, args);
                     unwrap_used::check(cx, expr, recv, false, self.allow_unwrap_in_tests);
                 },
-                ("unwrap_unchecked", []) => {
-                    unnecessary_literal_unwrap::check(cx, expr, recv, name, args);
-                }
                 ("unwrap_err", []) => {
                     unnecessary_literal_unwrap::check(cx, expr, recv, name, args);
                     unwrap_used::check(cx, expr, recv, true, self.allow_unwrap_in_tests);
@@ -4022,7 +4019,7 @@ impl Methods {
                     }
                     unnecessary_literal_unwrap::check(cx, expr, recv, name, args);
                 },
-                ("unwrap_or_default", []) => {
+                ("unwrap_or_default" | "unwrap_unchecked" | "unwrap_err_unchecked", []) => {
                     unnecessary_literal_unwrap::check(cx, expr, recv, name, args);
                 }
                 ("unwrap_or_else", [u_arg]) => {
diff --git a/clippy_lints/src/methods/unnecessary_literal_unwrap.rs b/clippy_lints/src/methods/unnecessary_literal_unwrap.rs
index 13895b67ed0..54de300e6bc 100644
--- a/clippy_lints/src/methods/unnecessary_literal_unwrap.rs
+++ b/clippy_lints/src/methods/unnecessary_literal_unwrap.rs
@@ -67,7 +67,7 @@ pub(super) fn check(
                 (expr.span.with_hi(args[0].span.lo()), "panic!(".to_string()),
                 (expr.span.with_lo(args[0].span.hi()), ")".to_string()),
             ]),
-            ("Some" | "Ok", "unwrap_unchecked", _) => {
+            ("Some" | "Ok", "unwrap_unchecked", _) | ("Err", "unwrap_err_unchecked", _) => {
                 let mut suggs = vec![
                     (recv.span.with_hi(call_args[0].span.lo()), String::new()),
                     (expr.span.with_lo(call_args[0].span.hi()), String::new()),
diff --git a/tests/ui/unnecessary_literal_unwrap.fixed b/tests/ui/unnecessary_literal_unwrap.fixed
index 0e7ba6bcbbb..276cd800b89 100644
--- a/tests/ui/unnecessary_literal_unwrap.fixed
+++ b/tests/ui/unnecessary_literal_unwrap.fixed
@@ -85,6 +85,7 @@ fn unwrap_unchecked() {
     let _ = 1;
     let _ = unsafe { 1 + *(&1 as *const i32) };
     let _ = 1 + 1;
+    let _ = 123;
 }
 
 fn main() {
diff --git a/tests/ui/unnecessary_literal_unwrap.rs b/tests/ui/unnecessary_literal_unwrap.rs
index fda7fd36ff9..3065778d779 100644
--- a/tests/ui/unnecessary_literal_unwrap.rs
+++ b/tests/ui/unnecessary_literal_unwrap.rs
@@ -85,6 +85,7 @@ fn unwrap_unchecked() {
     let _ = unsafe { Ok::<_, ()>(1).unwrap_unchecked() };
     let _ = unsafe { Ok::<_, ()>(1).unwrap_unchecked() + *(&1 as *const i32) };
     let _ = unsafe { Ok::<_, ()>(1).unwrap_unchecked() } + 1;
+    let _ = unsafe { Err::<(), i32>(123).unwrap_err_unchecked() };
 }
 
 fn main() {
diff --git a/tests/ui/unnecessary_literal_unwrap.stderr b/tests/ui/unnecessary_literal_unwrap.stderr
index e5b93c3d9af..5823313b736 100644
--- a/tests/ui/unnecessary_literal_unwrap.stderr
+++ b/tests/ui/unnecessary_literal_unwrap.stderr
@@ -481,5 +481,17 @@ LL -     let _ = unsafe { Ok::<_, ()>(1).unwrap_unchecked() } + 1;
 LL +     let _ = 1 + 1;
    |
 
-error: aborting due to 42 previous errors
+error: used `unwrap_err_unchecked()` on `Err` value
+  --> $DIR/unnecessary_literal_unwrap.rs:88:22
+   |
+LL |     let _ = unsafe { Err::<(), i32>(123).unwrap_err_unchecked() };
+   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the `Err` and `unwrap_err_unchecked()`
+   |
+LL -     let _ = unsafe { Err::<(), i32>(123).unwrap_err_unchecked() };
+LL +     let _ = 123;
+   |
+
+error: aborting due to 43 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 31397b489a0601ac53717bef2e3f2b3a945779b1 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Tue, 11 Jul 2023 19:23:01 +0200
Subject: Update version attribute for 1.71 lints

---
 clippy_lints/src/items_after_test_module.rs | 2 +-
 clippy_lints/src/loops/mod.rs               | 2 +-
 clippy_lints/src/needless_bool.rs           | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/items_after_test_module.rs b/clippy_lints/src/items_after_test_module.rs
index 40378ee8205..f684847c0c2 100644
--- a/clippy_lints/src/items_after_test_module.rs
+++ b/clippy_lints/src/items_after_test_module.rs
@@ -32,7 +32,7 @@ declare_clippy_lint! {
     ///     // [...]
     /// }
     /// ```
-    #[clippy::version = "1.70.0"]
+    #[clippy::version = "1.71.0"]
     pub ITEMS_AFTER_TEST_MODULE,
     style,
     "An item was found after the testing module `tests`"
diff --git a/clippy_lints/src/loops/mod.rs b/clippy_lints/src/loops/mod.rs
index 529189b52ac..ffd29ab7630 100644
--- a/clippy_lints/src/loops/mod.rs
+++ b/clippy_lints/src/loops/mod.rs
@@ -601,7 +601,7 @@ declare_clippy_lint! {
     ///     // use `number`
     /// }
     /// ```
-    #[clippy::version = "1.70.0"]
+    #[clippy::version = "1.71.0"]
     pub MANUAL_WHILE_LET_SOME,
     style,
     "checking for emptiness of a `Vec` in the loop condition and popping an element in the body"
diff --git a/clippy_lints/src/needless_bool.rs b/clippy_lints/src/needless_bool.rs
index 62af42a3961..34b74e180cb 100644
--- a/clippy_lints/src/needless_bool.rs
+++ b/clippy_lints/src/needless_bool.rs
@@ -106,7 +106,7 @@ declare_clippy_lint! {
     /// # let mut skip: bool;
     /// skip = !must_keep(x, y);
     /// ```
-    #[clippy::version = "1.69.0"]
+    #[clippy::version = "1.71.0"]
     pub NEEDLESS_BOOL_ASSIGN,
     complexity,
     "setting the same boolean variable in both branches of an if-statement"
-- 
cgit 1.4.1-3-g733a5


From c49c177e062a8a5602207d309d2f6e8041fc1b1d Mon Sep 17 00:00:00 2001
From: Panagiotis Foliadis <pfoliadis@hotmail.com>
Date: Fri, 7 Jul 2023 21:39:31 +0300
Subject: [`panic_in_result_fn`] remove `todo!`, `unimplemented!`,
 `unreachable!`

This commit fixes #11025 by removing checks for `todo!`,
`unimplemented!` and `unreachable!`.

Signed-off-by: Panagiotis Foliadis <pfoliadis@hotmail.com>
---
 clippy_lints/src/panic_in_result_fn.rs        | 10 ++--
 tests/ui/panic_in_result_fn.stderr            | 74 ++-------------------------
 tests/ui/panic_in_result_fn_assertions.stderr | 12 ++---
 3 files changed, 16 insertions(+), 80 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/panic_in_result_fn.rs b/clippy_lints/src/panic_in_result_fn.rs
index 849cd03dd7b..a049427d85d 100644
--- a/clippy_lints/src/panic_in_result_fn.rs
+++ b/clippy_lints/src/panic_in_result_fn.rs
@@ -13,7 +13,7 @@ use rustc_span::{sym, Span};
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of `panic!`, `unimplemented!`, `todo!`, `unreachable!` or assertions in a function of type result.
+    /// Checks for usage of `panic!` or assertions in a function of type result.
     ///
     /// ### Why is this bad?
     /// For some codebases, it is desirable for functions of type result to return an error instead of crashing. Hence panicking macros should be avoided.
@@ -37,7 +37,7 @@ declare_clippy_lint! {
     #[clippy::version = "1.48.0"]
     pub PANIC_IN_RESULT_FN,
     restriction,
-    "functions of type `Result<..>` that contain `panic!()`, `todo!()`, `unreachable()`, `unimplemented()` or assertion"
+    "functions of type `Result<..>` that contain `panic!()` or assertion"
 }
 
 declare_lint_pass!(PanicInResultFn  => [PANIC_IN_RESULT_FN]);
@@ -70,7 +70,7 @@ fn lint_impl_body<'tcx>(cx: &LateContext<'tcx>, impl_span: Span, body: &'tcx hir
         };
         if matches!(
             cx.tcx.item_name(macro_call.def_id).as_str(),
-            "unimplemented" | "unreachable" | "panic" | "todo" | "assert" | "assert_eq" | "assert_ne"
+            "panic" | "assert" | "assert_eq" | "assert_ne"
         ) {
             panics.push(macro_call.span);
             ControlFlow::Continue(Descend::No)
@@ -83,10 +83,10 @@ fn lint_impl_body<'tcx>(cx: &LateContext<'tcx>, impl_span: Span, body: &'tcx hir
             cx,
             PANIC_IN_RESULT_FN,
             impl_span,
-            "used `unimplemented!()`, `unreachable!()`, `todo!()`, `panic!()` or assertion in a function that returns `Result`",
+            "used `panic!()` or assertion in a function that returns `Result`",
             move |diag| {
                 diag.help(
-                    "`unimplemented!()`, `unreachable!()`, `todo!()`, `panic!()` or assertions should not be used in a function that returns `Result` as `Result` is expected to return an error instead of crashing",
+                    "`panic!()` or assertions should not be used in a function that returns `Result` as `Result` is expected to return an error instead of crashing",
                 );
                 diag.span_note(panics, "return Err() instead of panicking");
             },
diff --git a/tests/ui/panic_in_result_fn.stderr b/tests/ui/panic_in_result_fn.stderr
index 97787bc84e2..b758fc23812 100644
--- a/tests/ui/panic_in_result_fn.stderr
+++ b/tests/ui/panic_in_result_fn.stderr
@@ -1,4 +1,4 @@
-error: used `unimplemented!()`, `unreachable!()`, `todo!()`, `panic!()` or assertion in a function that returns `Result`
+error: used `panic!()` or assertion in a function that returns `Result`
   --> $DIR/panic_in_result_fn.rs:6:5
    |
 LL | /     fn result_with_panic() -> Result<bool, String> // should emit lint
@@ -7,7 +7,7 @@ LL | |         panic!("error");
 LL | |     }
    | |_____^
    |
-   = help: `unimplemented!()`, `unreachable!()`, `todo!()`, `panic!()` or assertions should not be used in a function that returns `Result` as `Result` is expected to return an error instead of crashing
+   = help: `panic!()` or assertions should not be used in a function that returns `Result` as `Result` is expected to return an error instead of crashing
 note: return Err() instead of panicking
   --> $DIR/panic_in_result_fn.rs:8:9
    |
@@ -15,55 +15,7 @@ LL |         panic!("error");
    |         ^^^^^^^^^^^^^^^
    = note: `-D clippy::panic-in-result-fn` implied by `-D warnings`
 
-error: used `unimplemented!()`, `unreachable!()`, `todo!()`, `panic!()` or assertion in a function that returns `Result`
-  --> $DIR/panic_in_result_fn.rs:11:5
-   |
-LL | /     fn result_with_unimplemented() -> Result<bool, String> // should emit lint
-LL | |     {
-LL | |         unimplemented!();
-LL | |     }
-   | |_____^
-   |
-   = help: `unimplemented!()`, `unreachable!()`, `todo!()`, `panic!()` or assertions should not be used in a function that returns `Result` as `Result` is expected to return an error instead of crashing
-note: return Err() instead of panicking
-  --> $DIR/panic_in_result_fn.rs:13:9
-   |
-LL |         unimplemented!();
-   |         ^^^^^^^^^^^^^^^^
-
-error: used `unimplemented!()`, `unreachable!()`, `todo!()`, `panic!()` or assertion in a function that returns `Result`
-  --> $DIR/panic_in_result_fn.rs:16:5
-   |
-LL | /     fn result_with_unreachable() -> Result<bool, String> // should emit lint
-LL | |     {
-LL | |         unreachable!();
-LL | |     }
-   | |_____^
-   |
-   = help: `unimplemented!()`, `unreachable!()`, `todo!()`, `panic!()` or assertions should not be used in a function that returns `Result` as `Result` is expected to return an error instead of crashing
-note: return Err() instead of panicking
-  --> $DIR/panic_in_result_fn.rs:18:9
-   |
-LL |         unreachable!();
-   |         ^^^^^^^^^^^^^^
-
-error: used `unimplemented!()`, `unreachable!()`, `todo!()`, `panic!()` or assertion in a function that returns `Result`
-  --> $DIR/panic_in_result_fn.rs:21:5
-   |
-LL | /     fn result_with_todo() -> Result<bool, String> // should emit lint
-LL | |     {
-LL | |         todo!("Finish this");
-LL | |     }
-   | |_____^
-   |
-   = help: `unimplemented!()`, `unreachable!()`, `todo!()`, `panic!()` or assertions should not be used in a function that returns `Result` as `Result` is expected to return an error instead of crashing
-note: return Err() instead of panicking
-  --> $DIR/panic_in_result_fn.rs:23:9
-   |
-LL |         todo!("Finish this");
-   |         ^^^^^^^^^^^^^^^^^^^^
-
-error: used `unimplemented!()`, `unreachable!()`, `todo!()`, `panic!()` or assertion in a function that returns `Result`
+error: used `panic!()` or assertion in a function that returns `Result`
   --> $DIR/panic_in_result_fn.rs:52:1
    |
 LL | / fn function_result_with_panic() -> Result<bool, String> // should emit lint
@@ -72,28 +24,12 @@ LL | |     panic!("error");
 LL | | }
    | |_^
    |
-   = help: `unimplemented!()`, `unreachable!()`, `todo!()`, `panic!()` or assertions should not be used in a function that returns `Result` as `Result` is expected to return an error instead of crashing
+   = help: `panic!()` or assertions should not be used in a function that returns `Result` as `Result` is expected to return an error instead of crashing
 note: return Err() instead of panicking
   --> $DIR/panic_in_result_fn.rs:54:5
    |
 LL |     panic!("error");
    |     ^^^^^^^^^^^^^^^
 
-error: used `unimplemented!()`, `unreachable!()`, `todo!()`, `panic!()` or assertion in a function that returns `Result`
-  --> $DIR/panic_in_result_fn.rs:67:1
-   |
-LL | / fn main() -> Result<(), String> {
-LL | |     todo!("finish main method");
-LL | |     Ok(())
-LL | | }
-   | |_^
-   |
-   = help: `unimplemented!()`, `unreachable!()`, `todo!()`, `panic!()` or assertions should not be used in a function that returns `Result` as `Result` is expected to return an error instead of crashing
-note: return Err() instead of panicking
-  --> $DIR/panic_in_result_fn.rs:68:5
-   |
-LL |     todo!("finish main method");
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: aborting due to 6 previous errors
+error: aborting due to 2 previous errors
 
diff --git a/tests/ui/panic_in_result_fn_assertions.stderr b/tests/ui/panic_in_result_fn_assertions.stderr
index eb0aacbb6a4..0dd213a7eed 100644
--- a/tests/ui/panic_in_result_fn_assertions.stderr
+++ b/tests/ui/panic_in_result_fn_assertions.stderr
@@ -1,4 +1,4 @@
-error: used `unimplemented!()`, `unreachable!()`, `todo!()`, `panic!()` or assertion in a function that returns `Result`
+error: used `panic!()` or assertion in a function that returns `Result`
   --> $DIR/panic_in_result_fn_assertions.rs:7:5
    |
 LL | /     fn result_with_assert_with_message(x: i32) -> Result<bool, String> // should emit lint
@@ -8,7 +8,7 @@ LL | |         Ok(true)
 LL | |     }
    | |_____^
    |
-   = help: `unimplemented!()`, `unreachable!()`, `todo!()`, `panic!()` or assertions should not be used in a function that returns `Result` as `Result` is expected to return an error instead of crashing
+   = help: `panic!()` or assertions should not be used in a function that returns `Result` as `Result` is expected to return an error instead of crashing
 note: return Err() instead of panicking
   --> $DIR/panic_in_result_fn_assertions.rs:9:9
    |
@@ -16,7 +16,7 @@ LL |         assert!(x == 5, "wrong argument");
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    = note: `-D clippy::panic-in-result-fn` implied by `-D warnings`
 
-error: used `unimplemented!()`, `unreachable!()`, `todo!()`, `panic!()` or assertion in a function that returns `Result`
+error: used `panic!()` or assertion in a function that returns `Result`
   --> $DIR/panic_in_result_fn_assertions.rs:13:5
    |
 LL | /     fn result_with_assert_eq(x: i32) -> Result<bool, String> // should emit lint
@@ -26,14 +26,14 @@ LL | |         Ok(true)
 LL | |     }
    | |_____^
    |
-   = help: `unimplemented!()`, `unreachable!()`, `todo!()`, `panic!()` or assertions should not be used in a function that returns `Result` as `Result` is expected to return an error instead of crashing
+   = help: `panic!()` or assertions should not be used in a function that returns `Result` as `Result` is expected to return an error instead of crashing
 note: return Err() instead of panicking
   --> $DIR/panic_in_result_fn_assertions.rs:15:9
    |
 LL |         assert_eq!(x, 5);
    |         ^^^^^^^^^^^^^^^^
 
-error: used `unimplemented!()`, `unreachable!()`, `todo!()`, `panic!()` or assertion in a function that returns `Result`
+error: used `panic!()` or assertion in a function that returns `Result`
   --> $DIR/panic_in_result_fn_assertions.rs:19:5
    |
 LL | /     fn result_with_assert_ne(x: i32) -> Result<bool, String> // should emit lint
@@ -43,7 +43,7 @@ LL | |         Ok(true)
 LL | |     }
    | |_____^
    |
-   = help: `unimplemented!()`, `unreachable!()`, `todo!()`, `panic!()` or assertions should not be used in a function that returns `Result` as `Result` is expected to return an error instead of crashing
+   = help: `panic!()` or assertions should not be used in a function that returns `Result` as `Result` is expected to return an error instead of crashing
 note: return Err() instead of panicking
   --> $DIR/panic_in_result_fn_assertions.rs:21:9
    |
-- 
cgit 1.4.1-3-g733a5


From c5fc61ca9485d8ccf1e0865ed675edfacddd5d57 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Thu, 13 Jul 2023 00:24:10 +0200
Subject: [`arithmetic_side_effect`]: allow different rhs type

---
 clippy_lints/src/operators/arithmetic_side_effects.rs | 4 ++--
 tests/ui/arithmetic_side_effects.rs                   | 5 +++++
 2 files changed, 7 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/operators/arithmetic_side_effects.rs b/clippy_lints/src/operators/arithmetic_side_effects.rs
index 5c240276b76..47873f3b071 100644
--- a/clippy_lints/src/operators/arithmetic_side_effects.rs
+++ b/clippy_lints/src/operators/arithmetic_side_effects.rs
@@ -19,8 +19,8 @@ use rustc_span::{
 const HARD_CODED_ALLOWED_BINARY: &[[&str; 2]] = &[
     ["f32", "f32"],
     ["f64", "f64"],
-    ["std::num::Saturating", "std::num::Saturating"],
-    ["std::num::Wrapping", "std::num::Wrapping"],
+    ["std::num::Saturating", "*"],
+    ["std::num::Wrapping", "*"],
     ["std::string::String", "str"],
 ];
 const HARD_CODED_ALLOWED_UNARY: &[&str] = &["f32", "f64", "std::num::Saturating", "std::num::Wrapping"];
diff --git a/tests/ui/arithmetic_side_effects.rs b/tests/ui/arithmetic_side_effects.rs
index 4f38e50c81d..ed75acee8a2 100644
--- a/tests/ui/arithmetic_side_effects.rs
+++ b/tests/ui/arithmetic_side_effects.rs
@@ -481,4 +481,9 @@ pub fn issue_10792() {
     let _ = 10 / TWO.c;
 }
 
+pub fn issue_11145() {
+    let mut x: Wrapping<u32> = Wrapping(0_u32);
+    x += 1;
+}
+
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 4102a309d782522a2a6f378ec748cb3a3a4fed8d Mon Sep 17 00:00:00 2001
From: Mingwei Samuel <mingwei.samuel@gmail.com>
Date: Wed, 12 Jul 2023 15:01:37 -0700
Subject: [`tuple_array_conversions`]: move from `complexity` to `nursery`

Due to outstanding issues:
* https://github.com/rust-lang/rust-clippy/issues/11082
* https://github.com/rust-lang/rust-clippy/issues/11085
* https://github.com/rust-lang/rust-clippy/issues/11100 (https://github.com/rust-lang/rust-clippy/pull/11105)
* https://github.com/rust-lang/rust-clippy/issues/11124
* https://github.com/rust-lang/rust-clippy/issues/11144
---
 clippy_lints/src/tuple_array_conversions.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/tuple_array_conversions.rs b/clippy_lints/src/tuple_array_conversions.rs
index bd983306508..258617467e9 100644
--- a/clippy_lints/src/tuple_array_conversions.rs
+++ b/clippy_lints/src/tuple_array_conversions.rs
@@ -16,8 +16,8 @@ declare_clippy_lint! {
     /// Checks for tuple<=>array conversions that are not done with `.into()`.
     ///
     /// ### Why is this bad?
-    /// It's unnecessary complexity. `.into()` works for tuples<=>arrays at or below 12 elements and
-    /// conveys the intent a lot better, while also leaving less room for hard to spot bugs!
+    /// It may be unnecessary complexity. `.into()` works for converting tuples
+    /// <=> arrays of up to 12 elements and may convey intent more clearly.
     ///
     /// ### Example
     /// ```rust,ignore
@@ -31,7 +31,7 @@ declare_clippy_lint! {
     /// ```
     #[clippy::version = "1.72.0"]
     pub TUPLE_ARRAY_CONVERSIONS,
-    complexity,
+    pedantic,
     "checks for tuple<=>array conversions that are not done with `.into()`"
 }
 impl_lint_pass!(TupleArrayConversions => [TUPLE_ARRAY_CONVERSIONS]);
-- 
cgit 1.4.1-3-g733a5


From 050b714c9d638d57408d7ff7d14afd5d206525f2 Mon Sep 17 00:00:00 2001
From: Samuel Moelius <sam@moeli.us>
Date: Wed, 12 Jul 2023 20:15:54 -0400
Subject: Add "Known problems" section to `needless_borrow` documentation

---
 clippy_lints/src/dereference.rs | 5 +++++
 1 file changed, 5 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index 3af552e5016..cdf64b96036 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -77,6 +77,11 @@ declare_clippy_lint! {
     /// Suggests that the receiver of the expression borrows
     /// the expression.
     ///
+    /// ### Known problems
+    /// The lint cannot tell when the implementation of a trait
+    /// for `&T` and `T` do different things. Removing a borrow
+    /// in such a case can change the semantics of the code.
+    ///
     /// ### Example
     /// ```rust
     /// fn fun(_a: &i32) {}
-- 
cgit 1.4.1-3-g733a5


From 885ce610fe2b257d2263e28954ab11a92e0372cf Mon Sep 17 00:00:00 2001
From: Catherine <114838443+Centri3@users.noreply.github.com>
Date: Wed, 12 Jul 2023 03:19:22 -0500
Subject: New lint [`four_forward_slashes`]

Make it trim the contents
---
 CHANGELOG.md                             |  1 +
 clippy_lints/src/declared_lints.rs       |  1 +
 clippy_lints/src/four_forward_slashes.rs | 82 ++++++++++++++++++++++++++++++++
 clippy_lints/src/lib.rs                  |  2 +
 tests/ui/four_forward_slashes.fixed      | 44 +++++++++++++++++
 tests/ui/four_forward_slashes.rs         | 44 +++++++++++++++++
 tests/ui/four_forward_slashes.stderr     | 75 +++++++++++++++++++++++++++++
 7 files changed, 249 insertions(+)
 create mode 100644 clippy_lints/src/four_forward_slashes.rs
 create mode 100644 tests/ui/four_forward_slashes.fixed
 create mode 100644 tests/ui/four_forward_slashes.rs
 create mode 100644 tests/ui/four_forward_slashes.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index b3b6e3b865f..ec62d399aa4 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4867,6 +4867,7 @@ Released 2018-09-13
 [`forget_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#forget_ref
 [`format_in_format_args`]: https://rust-lang.github.io/rust-clippy/master/index.html#format_in_format_args
 [`format_push_string`]: https://rust-lang.github.io/rust-clippy/master/index.html#format_push_string
+[`four_forward_slashes`]: https://rust-lang.github.io/rust-clippy/master/index.html#four_forward_slashes
 [`from_iter_instead_of_collect`]: https://rust-lang.github.io/rust-clippy/master/index.html#from_iter_instead_of_collect
 [`from_over_into`]: https://rust-lang.github.io/rust-clippy/master/index.html#from_over_into
 [`from_raw_with_void_ptr`]: https://rust-lang.github.io/rust-clippy/master/index.html#from_raw_with_void_ptr
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 3723de7299b..d8b14a9f967 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -184,6 +184,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::formatting::SUSPICIOUS_ASSIGNMENT_FORMATTING_INFO,
     crate::formatting::SUSPICIOUS_ELSE_FORMATTING_INFO,
     crate::formatting::SUSPICIOUS_UNARY_OP_FORMATTING_INFO,
+    crate::four_forward_slashes::FOUR_FORWARD_SLASHES_INFO,
     crate::from_over_into::FROM_OVER_INTO_INFO,
     crate::from_raw_with_void_ptr::FROM_RAW_WITH_VOID_PTR_INFO,
     crate::from_str_radix_10::FROM_STR_RADIX_10_INFO,
diff --git a/clippy_lints/src/four_forward_slashes.rs b/clippy_lints/src/four_forward_slashes.rs
new file mode 100644
index 00000000000..7efa8c1b31f
--- /dev/null
+++ b/clippy_lints/src/four_forward_slashes.rs
@@ -0,0 +1,82 @@
+use clippy_utils::{diagnostics::span_lint_and_sugg, source::snippet_opt};
+use rustc_errors::Applicability;
+use rustc_hir::Item;
+use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::{Span, SyntaxContext};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for outer doc comments written with 4 forward slashes (`////`).
+    ///
+    /// ### Why is this bad?
+    /// This is (probably) a typo, and results in it not being a doc comment; just a regular
+    /// comment.
+    ///
+    /// ### Example
+    /// ```rust
+    /// //// My amazing data structure
+    /// pub struct Foo {
+    ///     // ...
+    /// }
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust
+    /// /// My amazing data structure
+    /// pub struct Foo {
+    ///     // ...
+    /// }
+    /// ```
+    #[clippy::version = "1.72.0"]
+    pub FOUR_FORWARD_SLASHES,
+    suspicious,
+    "comments with 4 forward slashes (`////`) likely intended to be doc comments (`///`)"
+}
+declare_lint_pass!(FourForwardSlashes => [FOUR_FORWARD_SLASHES]);
+
+impl<'tcx> LateLintPass<'tcx> for FourForwardSlashes {
+    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
+        if item.span.from_expansion() {
+            return;
+        }
+        let src = cx.sess().source_map();
+        let item_and_attrs_span = cx
+            .tcx
+            .hir()
+            .attrs(item.hir_id())
+            .iter()
+            .fold(item.span.shrink_to_lo(), |span, attr| span.to(attr.span));
+        let (Some(file), _, _, end_line, _) = src.span_to_location_info(item_and_attrs_span) else {
+            return;
+        };
+        for line in (0..end_line.saturating_sub(1)).rev() {
+            let Some(contents) = file.get_line(line) else {
+                continue;
+            };
+            let contents = contents.trim();
+            if contents.is_empty() {
+                break;
+            }
+            if contents.starts_with("////") {
+                let bounds = file.line_bounds(line);
+                let span = Span::new(bounds.start, bounds.end, SyntaxContext::root(), None);
+
+                if snippet_opt(cx, span).is_some_and(|s| s.trim().starts_with("////")) {
+                    span_lint_and_sugg(
+                        cx,
+                        FOUR_FORWARD_SLASHES,
+                        span,
+                        "comment with 4 forward slashes (`////`). This looks like a doc comment, but it isn't",
+                        "make this a doc comment by removing one `/`",
+                        // It's a little unfortunate but the span includes the `\n` yet the contents
+                        // do not, so we must add it back. If some codebase uses `\r\n` instead they
+                        // will need normalization but it should be fine
+                        contents.replacen("////", "///", 1) + "\n",
+                        Applicability::MachineApplicable,
+                    );
+                }
+            }
+        }
+    }
+}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index cebe2e44c0f..607c718b562 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -137,6 +137,7 @@ mod format_args;
 mod format_impl;
 mod format_push_string;
 mod formatting;
+mod four_forward_slashes;
 mod from_over_into;
 mod from_raw_with_void_ptr;
 mod from_str_radix_10;
@@ -1081,6 +1082,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_early_pass(|| Box::new(visibility::Visibility));
     store.register_late_pass(move |_| Box::new(tuple_array_conversions::TupleArrayConversions { msrv: msrv() }));
     store.register_late_pass(|_| Box::new(manual_float_methods::ManualFloatMethods));
+    store.register_late_pass(|_| Box::new(four_forward_slashes::FourForwardSlashes));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/tests/ui/four_forward_slashes.fixed b/tests/ui/four_forward_slashes.fixed
new file mode 100644
index 00000000000..4f9b1f4b7c8
--- /dev/null
+++ b/tests/ui/four_forward_slashes.fixed
@@ -0,0 +1,44 @@
+//// first line borked doc comment. doesn't combust!
+//@run-rustfix
+//@aux-build:proc_macros.rs:proc-macro
+#![feature(custom_inner_attributes)]
+#![allow(unused)]
+#![warn(clippy::four_forward_slashes)]
+#![no_main]
+#![rustfmt::skip]
+
+#[macro_use]
+extern crate proc_macros;
+
+/// whoops
+fn a() {}
+
+/// whoops
+#[allow(dead_code)]
+fn b() {}
+
+/// whoops
+/// two borked comments!
+#[track_caller]
+fn c() {}
+
+fn d() {}
+
+#[test]
+/// between attributes
+#[allow(dead_code)]
+fn g() {}
+
+/// not very start of contents
+fn h() {}
+
+external! {
+    //// don't lint me bozo
+    fn e() {}
+}
+
+with_span! {
+    span
+    //// don't lint me bozo
+    fn f() {}
+}
diff --git a/tests/ui/four_forward_slashes.rs b/tests/ui/four_forward_slashes.rs
new file mode 100644
index 00000000000..02f2084c17c
--- /dev/null
+++ b/tests/ui/four_forward_slashes.rs
@@ -0,0 +1,44 @@
+//// first line borked doc comment. doesn't combust!
+//@run-rustfix
+//@aux-build:proc_macros.rs:proc-macro
+#![feature(custom_inner_attributes)]
+#![allow(unused)]
+#![warn(clippy::four_forward_slashes)]
+#![no_main]
+#![rustfmt::skip]
+
+#[macro_use]
+extern crate proc_macros;
+
+//// whoops
+fn a() {}
+
+//// whoops
+#[allow(dead_code)]
+fn b() {}
+
+//// whoops
+//// two borked comments!
+#[track_caller]
+fn c() {}
+
+fn d() {}
+
+#[test]
+//// between attributes
+#[allow(dead_code)]
+fn g() {}
+
+    //// not very start of contents
+fn h() {}
+
+external! {
+    //// don't lint me bozo
+    fn e() {}
+}
+
+with_span! {
+    span
+    //// don't lint me bozo
+    fn f() {}
+}
diff --git a/tests/ui/four_forward_slashes.stderr b/tests/ui/four_forward_slashes.stderr
new file mode 100644
index 00000000000..1640b241bf3
--- /dev/null
+++ b/tests/ui/four_forward_slashes.stderr
@@ -0,0 +1,75 @@
+error: comment with 4 forward slashes (`////`). This looks like a doc comment, but it isn't
+  --> $DIR/four_forward_slashes.rs:13:1
+   |
+LL | / //// whoops
+LL | | fn a() {}
+   | |_
+   |
+   = note: `-D clippy::four-forward-slashes` implied by `-D warnings`
+help: make this a doc comment by removing one `/`
+   |
+LL + /// whoops
+   |
+
+error: comment with 4 forward slashes (`////`). This looks like a doc comment, but it isn't
+  --> $DIR/four_forward_slashes.rs:16:1
+   |
+LL | / //// whoops
+LL | | #[allow(dead_code)]
+   | |_
+   |
+help: make this a doc comment by removing one `/`
+   |
+LL + /// whoops
+   |
+
+error: comment with 4 forward slashes (`////`). This looks like a doc comment, but it isn't
+  --> $DIR/four_forward_slashes.rs:21:1
+   |
+LL | / //// two borked comments!
+LL | | #[track_caller]
+   | |_
+   |
+help: make this a doc comment by removing one `/`
+   |
+LL + /// two borked comments!
+   |
+
+error: comment with 4 forward slashes (`////`). This looks like a doc comment, but it isn't
+  --> $DIR/four_forward_slashes.rs:20:1
+   |
+LL | / //// whoops
+LL | | //// two borked comments!
+   | |_
+   |
+help: make this a doc comment by removing one `/`
+   |
+LL + /// whoops
+   |
+
+error: comment with 4 forward slashes (`////`). This looks like a doc comment, but it isn't
+  --> $DIR/four_forward_slashes.rs:28:1
+   |
+LL | / //// between attributes
+LL | | #[allow(dead_code)]
+   | |_
+   |
+help: make this a doc comment by removing one `/`
+   |
+LL + /// between attributes
+   |
+
+error: comment with 4 forward slashes (`////`). This looks like a doc comment, but it isn't
+  --> $DIR/four_forward_slashes.rs:32:1
+   |
+LL | /     //// not very start of contents
+LL | | fn h() {}
+   | |_
+   |
+help: make this a doc comment by removing one `/`
+   |
+LL + /// not very start of contents
+   |
+
+error: aborting due to 6 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 2e43d0c91717ed68cbfafc34d89dc95bca771c63 Mon Sep 17 00:00:00 2001
From: Catherine <114838443+Centri3@users.noreply.github.com>
Date: Wed, 12 Jul 2023 19:39:19 -0500
Subject: Improve suggestion and add more tests

---
 clippy_lints/src/four_forward_slashes.rs        | 65 ++++++++++++++++---------
 tests/ui/four_forward_slashes.fixed             |  6 ++-
 tests/ui/four_forward_slashes.rs                |  6 ++-
 tests/ui/four_forward_slashes.stderr            | 41 +++++++---------
 tests/ui/four_forward_slashes_first_line.fixed  |  7 +++
 tests/ui/four_forward_slashes_first_line.rs     |  7 +++
 tests/ui/four_forward_slashes_first_line.stderr | 15 ++++++
 7 files changed, 97 insertions(+), 50 deletions(-)
 create mode 100644 tests/ui/four_forward_slashes_first_line.fixed
 create mode 100644 tests/ui/four_forward_slashes_first_line.rs
 create mode 100644 tests/ui/four_forward_slashes_first_line.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/four_forward_slashes.rs b/clippy_lints/src/four_forward_slashes.rs
index 7efa8c1b31f..419c7734344 100644
--- a/clippy_lints/src/four_forward_slashes.rs
+++ b/clippy_lints/src/four_forward_slashes.rs
@@ -1,9 +1,9 @@
-use clippy_utils::{diagnostics::span_lint_and_sugg, source::snippet_opt};
+use clippy_utils::diagnostics::span_lint_and_then;
 use rustc_errors::Applicability;
 use rustc_hir::Item;
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::{Span, SyntaxContext};
+use rustc_span::Span;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -40,43 +40,60 @@ impl<'tcx> LateLintPass<'tcx> for FourForwardSlashes {
         if item.span.from_expansion() {
             return;
         }
-        let src = cx.sess().source_map();
-        let item_and_attrs_span = cx
+        let sm = cx.sess().source_map();
+        let mut span = cx
             .tcx
             .hir()
             .attrs(item.hir_id())
             .iter()
             .fold(item.span.shrink_to_lo(), |span, attr| span.to(attr.span));
-        let (Some(file), _, _, end_line, _) = src.span_to_location_info(item_and_attrs_span) else {
+        let (Some(file), _, _, end_line, _) = sm.span_to_location_info(span) else {
             return;
         };
+        let mut bad_comments = vec![];
         for line in (0..end_line.saturating_sub(1)).rev() {
-            let Some(contents) = file.get_line(line) else {
-                continue;
+            let Some(contents) = file.get_line(line).map(|c| c.trim().to_owned()) else {
+                return;
             };
-            let contents = contents.trim();
-            if contents.is_empty() {
+            // Keep searching until we find the next item
+            if !contents.is_empty() && !contents.starts_with("//") && !contents.starts_with("#[") {
                 break;
             }
-            if contents.starts_with("////") {
+
+            if contents.starts_with("////") && !matches!(contents.chars().nth(4), Some('/' | '!')) {
                 let bounds = file.line_bounds(line);
-                let span = Span::new(bounds.start, bounds.end, SyntaxContext::root(), None);
+                let line_span = Span::with_root_ctxt(bounds.start, bounds.end);
+                span = line_span.to(span);
+                bad_comments.push((line_span, contents));
+            }
+        }
 
-                if snippet_opt(cx, span).is_some_and(|s| s.trim().starts_with("////")) {
-                    span_lint_and_sugg(
-                        cx,
-                        FOUR_FORWARD_SLASHES,
-                        span,
-                        "comment with 4 forward slashes (`////`). This looks like a doc comment, but it isn't",
-                        "make this a doc comment by removing one `/`",
-                        // It's a little unfortunate but the span includes the `\n` yet the contents
-                        // do not, so we must add it back. If some codebase uses `\r\n` instead they
-                        // will need normalization but it should be fine
-                        contents.replacen("////", "///", 1) + "\n",
+        if !bad_comments.is_empty() {
+            span_lint_and_then(
+                cx,
+                FOUR_FORWARD_SLASHES,
+                span,
+                "this item has comments with 4 forward slashes (`////`). These look like doc comments, but they aren't",
+                |diag| {
+                    let msg = if bad_comments.len() == 1 {
+                        "make this a doc comment by removing one `/`"
+                    } else {
+                        "turn these into doc comments by removing one `/`"
+                    };
+
+                    diag.multipart_suggestion(
+                        msg,
+                        bad_comments
+                            .into_iter()
+                            // It's a little unfortunate but the span includes the `\n` yet the contents
+                            // do not, so we must add it back. If some codebase uses `\r\n` instead they
+                            // will need normalization but it should be fine
+                            .map(|(span, c)| (span, c.replacen("////", "///", 1) + "\n"))
+                            .collect(),
                         Applicability::MachineApplicable,
                     );
-                }
-            }
+                },
+            );
         }
     }
 }
diff --git a/tests/ui/four_forward_slashes.fixed b/tests/ui/four_forward_slashes.fixed
index 4f9b1f4b7c8..54b2c414b62 100644
--- a/tests/ui/four_forward_slashes.fixed
+++ b/tests/ui/four_forward_slashes.fixed
@@ -1,4 +1,3 @@
-//// first line borked doc comment. doesn't combust!
 //@run-rustfix
 //@aux-build:proc_macros.rs:proc-macro
 #![feature(custom_inner_attributes)]
@@ -32,6 +31,11 @@ fn g() {}
 /// not very start of contents
 fn h() {}
 
+fn i() {
+    //// don't lint me bozo
+    todo!()
+}
+
 external! {
     //// don't lint me bozo
     fn e() {}
diff --git a/tests/ui/four_forward_slashes.rs b/tests/ui/four_forward_slashes.rs
index 02f2084c17c..facdc8cb17d 100644
--- a/tests/ui/four_forward_slashes.rs
+++ b/tests/ui/four_forward_slashes.rs
@@ -1,4 +1,3 @@
-//// first line borked doc comment. doesn't combust!
 //@run-rustfix
 //@aux-build:proc_macros.rs:proc-macro
 #![feature(custom_inner_attributes)]
@@ -32,6 +31,11 @@ fn g() {}
     //// not very start of contents
 fn h() {}
 
+fn i() {
+    //// don't lint me bozo
+    todo!()
+}
+
 external! {
     //// don't lint me bozo
     fn e() {}
diff --git a/tests/ui/four_forward_slashes.stderr b/tests/ui/four_forward_slashes.stderr
index 1640b241bf3..89162e6b010 100644
--- a/tests/ui/four_forward_slashes.stderr
+++ b/tests/ui/four_forward_slashes.stderr
@@ -1,5 +1,5 @@
-error: comment with 4 forward slashes (`////`). This looks like a doc comment, but it isn't
-  --> $DIR/four_forward_slashes.rs:13:1
+error: this item has comments with 4 forward slashes (`////`). These look like doc comments, but they aren't
+  --> $DIR/four_forward_slashes.rs:12:1
    |
 LL | / //// whoops
 LL | | fn a() {}
@@ -11,11 +11,12 @@ help: make this a doc comment by removing one `/`
 LL + /// whoops
    |
 
-error: comment with 4 forward slashes (`////`). This looks like a doc comment, but it isn't
-  --> $DIR/four_forward_slashes.rs:16:1
+error: this item has comments with 4 forward slashes (`////`). These look like doc comments, but they aren't
+  --> $DIR/four_forward_slashes.rs:15:1
    |
 LL | / //// whoops
 LL | | #[allow(dead_code)]
+LL | | fn b() {}
    | |_
    |
 help: make this a doc comment by removing one `/`
@@ -23,35 +24,27 @@ help: make this a doc comment by removing one `/`
 LL + /// whoops
    |
 
-error: comment with 4 forward slashes (`////`). This looks like a doc comment, but it isn't
-  --> $DIR/four_forward_slashes.rs:21:1
-   |
-LL | / //// two borked comments!
-LL | | #[track_caller]
-   | |_
-   |
-help: make this a doc comment by removing one `/`
-   |
-LL + /// two borked comments!
-   |
-
-error: comment with 4 forward slashes (`////`). This looks like a doc comment, but it isn't
-  --> $DIR/four_forward_slashes.rs:20:1
+error: this item has comments with 4 forward slashes (`////`). These look like doc comments, but they aren't
+  --> $DIR/four_forward_slashes.rs:19:1
    |
 LL | / //// whoops
 LL | | //// two borked comments!
+LL | | #[track_caller]
+LL | | fn c() {}
    | |_
    |
-help: make this a doc comment by removing one `/`
+help: turn these into doc comments by removing one `/`
    |
 LL + /// whoops
+LL ~ /// two borked comments!
    |
 
-error: comment with 4 forward slashes (`////`). This looks like a doc comment, but it isn't
-  --> $DIR/four_forward_slashes.rs:28:1
+error: this item has comments with 4 forward slashes (`////`). These look like doc comments, but they aren't
+  --> $DIR/four_forward_slashes.rs:27:1
    |
 LL | / //// between attributes
 LL | | #[allow(dead_code)]
+LL | | fn g() {}
    | |_
    |
 help: make this a doc comment by removing one `/`
@@ -59,8 +52,8 @@ help: make this a doc comment by removing one `/`
 LL + /// between attributes
    |
 
-error: comment with 4 forward slashes (`////`). This looks like a doc comment, but it isn't
-  --> $DIR/four_forward_slashes.rs:32:1
+error: this item has comments with 4 forward slashes (`////`). These look like doc comments, but they aren't
+  --> $DIR/four_forward_slashes.rs:31:1
    |
 LL | /     //// not very start of contents
 LL | | fn h() {}
@@ -71,5 +64,5 @@ help: make this a doc comment by removing one `/`
 LL + /// not very start of contents
    |
 
-error: aborting due to 6 previous errors
+error: aborting due to 5 previous errors
 
diff --git a/tests/ui/four_forward_slashes_first_line.fixed b/tests/ui/four_forward_slashes_first_line.fixed
new file mode 100644
index 00000000000..ce272b4c6cd
--- /dev/null
+++ b/tests/ui/four_forward_slashes_first_line.fixed
@@ -0,0 +1,7 @@
+/// borked doc comment on the first line. doesn't combust!
+fn a() {}
+
+//@run-rustfix
+// This test's entire purpose is to make sure we don't panic if the comment with four slashes
+// extends to the first line of the file. This is likely pretty rare in production, but an ICE is an
+// ICE.
diff --git a/tests/ui/four_forward_slashes_first_line.rs b/tests/ui/four_forward_slashes_first_line.rs
new file mode 100644
index 00000000000..d8f82d4410b
--- /dev/null
+++ b/tests/ui/four_forward_slashes_first_line.rs
@@ -0,0 +1,7 @@
+//// borked doc comment on the first line. doesn't combust!
+fn a() {}
+
+//@run-rustfix
+// This test's entire purpose is to make sure we don't panic if the comment with four slashes
+// extends to the first line of the file. This is likely pretty rare in production, but an ICE is an
+// ICE.
diff --git a/tests/ui/four_forward_slashes_first_line.stderr b/tests/ui/four_forward_slashes_first_line.stderr
new file mode 100644
index 00000000000..7944da14feb
--- /dev/null
+++ b/tests/ui/four_forward_slashes_first_line.stderr
@@ -0,0 +1,15 @@
+error: this item has comments with 4 forward slashes (`////`). These look like doc comments, but they aren't
+  --> $DIR/four_forward_slashes_first_line.rs:1:1
+   |
+LL | / //// borked doc comment on the first line. doesn't combust!
+LL | | fn a() {}
+   | |_
+   |
+   = note: `-D clippy::four-forward-slashes` implied by `-D warnings`
+help: make this a doc comment by removing one `/`
+   |
+LL + /// borked doc comment on the first line. doesn't combust!
+   |
+
+error: aborting due to previous error
+
-- 
cgit 1.4.1-3-g733a5


From 2811effe3478a3ce7d1bdde936c6ca8fb08de326 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Mon, 3 Jul 2023 17:42:48 +0000
Subject: Add `imports_granularity = "Module"` to rustfmt.toml

---
 clippy_lints/src/allow_attributes.rs               |  3 +-
 clippy_lints/src/arc_with_non_send_sync.rs         |  3 +-
 clippy_lints/src/attrs.rs                          |  6 +--
 clippy_lints/src/blocks_in_if_conditions.rs        |  3 +-
 clippy_lints/src/bool_to_int_with_if.rs            |  4 +-
 clippy_lints/src/borrow_deref_ref.rs               |  3 +-
 clippy_lints/src/box_default.rs                    | 14 +++--
 clippy_lints/src/casts/as_ptr_cast_mut.rs          |  6 +--
 .../src/casts/cast_slice_different_sizes.rs        |  6 ++-
 .../src/casts/cast_slice_from_raw_parts.rs         |  3 +-
 clippy_lints/src/casts/ptr_cast_constness.rs       |  4 +-
 clippy_lints/src/copies.rs                         |  3 +-
 clippy_lints/src/crate_in_macro_def.rs             |  3 +-
 .../src/default_constructed_unit_structs.rs        |  6 ++-
 clippy_lints/src/default_instead_of_iter_empty.rs  |  3 +-
 clippy_lints/src/default_numeric_fallback.rs       | 12 ++---
 clippy_lints/src/dereference.rs                    | 13 ++---
 clippy_lints/src/derivable_impls.rs                |  5 +-
 clippy_lints/src/derive.rs                         |  3 +-
 clippy_lints/src/disallowed_names.rs               |  3 +-
 clippy_lints/src/doc.rs                            |  3 +-
 clippy_lints/src/drop_forget_ref.rs                |  3 +-
 clippy_lints/src/empty_drop.rs                     |  3 +-
 clippy_lints/src/empty_structs_with_brackets.rs    |  3 +-
 clippy_lints/src/endian_bytes.rs                   |  6 ++-
 clippy_lints/src/entry.rs                          | 18 +++----
 clippy_lints/src/escape.rs                         |  3 +-
 clippy_lints/src/excessive_nesting.rs              | 11 ++--
 clippy_lints/src/extra_unused_type_parameters.rs   |  9 ++--
 clippy_lints/src/floating_point_arithmetic.rs      | 10 ++--
 clippy_lints/src/format_args.rs                    |  6 +--
 clippy_lints/src/format_impl.rs                    |  4 +-
 clippy_lints/src/from_over_into.rs                 |  3 +-
 clippy_lints/src/from_raw_with_void_ptr.rs         |  3 +-
 clippy_lints/src/functions/impl_trait_in_params.rs |  6 ++-
 clippy_lints/src/functions/misnamed_getters.rs     |  3 +-
 clippy_lints/src/functions/must_use.rs             |  9 ++--
 clippy_lints/src/if_let_mutex.rs                   |  3 +-
 clippy_lints/src/implicit_return.rs                | 10 ++--
 clippy_lints/src/incorrect_impls.rs                | 14 ++---
 clippy_lints/src/index_refutable_slice.rs          |  3 +-
 clippy_lints/src/inherent_impl.rs                  |  3 +-
 clippy_lints/src/instant_subtraction.rs            |  3 +-
 clippy_lints/src/items_after_test_module.rs        |  3 +-
 clippy_lints/src/iter_not_returning_iterator.rs    |  7 ++-
 clippy_lints/src/large_enum_variant.rs             |  6 +--
 clippy_lints/src/large_futures.rs                  |  3 +-
 clippy_lints/src/large_include_file.rs             |  3 +-
 clippy_lints/src/large_stack_frames.rs             |  6 +--
 clippy_lints/src/len_zero.rs                       | 19 +++----
 clippy_lints/src/let_if_seq.rs                     |  3 +-
 clippy_lints/src/let_underscore.rs                 |  3 +-
 clippy_lints/src/lib.rs                            |  7 ++-
 clippy_lints/src/lines_filter_map_ok.rs            |  7 ++-
 clippy_lints/src/loops/manual_find.rs              | 14 ++---
 clippy_lints/src/loops/manual_flatten.rs           |  3 +-
 clippy_lints/src/loops/manual_while_let_some.rs    |  9 ++--
 clippy_lints/src/loops/mut_range_bound.rs          |  3 +-
 clippy_lints/src/loops/never_loop.rs               |  4 +-
 .../src/loops/while_immutable_condition.rs         |  3 +-
 clippy_lints/src/loops/while_let_on_iterator.rs    | 12 ++---
 clippy_lints/src/macro_use.rs                      |  3 +-
 clippy_lints/src/manual_clamp.rs                   | 14 +++--
 clippy_lints/src/manual_float_methods.rs           | 10 ++--
 clippy_lints/src/manual_is_ascii_check.rs          |  8 ++-
 clippy_lints/src/manual_range_patterns.rs          |  9 +---
 clippy_lints/src/manual_strip.rs                   |  3 +-
 clippy_lints/src/match_result_ok.rs                |  3 +-
 clippy_lints/src/matches/manual_utils.rs           |  9 ++--
 clippy_lints/src/matches/match_like_matches.rs     |  4 +-
 clippy_lints/src/matches/match_same_arms.rs        |  3 +-
 .../src/matches/redundant_pattern_match.rs         |  3 +-
 clippy_lints/src/methods/bind_instead_of_map.rs    |  3 +-
 .../case_sensitive_file_extension_comparisons.rs   |  6 +--
 clippy_lints/src/methods/chars_cmp.rs              |  3 +-
 clippy_lints/src/methods/chars_cmp_with_unwrap.rs  |  3 +-
 clippy_lints/src/methods/clone_on_copy.rs          |  4 +-
 .../src/methods/collapsible_str_replace.rs         |  3 +-
 clippy_lints/src/methods/drain_collect.rs          |  9 +---
 clippy_lints/src/methods/err_expect.rs             |  3 +-
 clippy_lints/src/methods/filter_map.rs             |  4 +-
 clippy_lints/src/methods/filter_map_identity.rs    |  3 +-
 clippy_lints/src/methods/flat_map_identity.rs      |  3 +-
 clippy_lints/src/methods/flat_map_option.rs        |  3 +-
 clippy_lints/src/methods/inspect_for_each.rs       |  3 +-
 clippy_lints/src/methods/is_digit_ascii_radix.rs   |  6 +--
 clippy_lints/src/methods/iter_kv_map.rs            |  3 +-
 clippy_lints/src/methods/iter_skip_next.rs         |  3 +-
 .../src/methods/manual_saturating_arithmetic.rs    |  6 +--
 clippy_lints/src/methods/manual_try_fold.rs        | 18 +++----
 clippy_lints/src/methods/map_flatten.rs            |  3 +-
 clippy_lints/src/methods/map_identity.rs           |  3 +-
 clippy_lints/src/methods/mut_mutex_lock.rs         |  3 +-
 clippy_lints/src/methods/needless_collect.rs       |  5 +-
 clippy_lints/src/methods/obfuscated_if_else.rs     |  3 +-
 clippy_lints/src/methods/option_map_or_none.rs     |  3 +-
 clippy_lints/src/methods/option_map_unwrap_or.rs   |  9 +---
 clippy_lints/src/methods/or_then_unwrap.rs         |  6 ++-
 clippy_lints/src/methods/range_zip_with_len.rs     |  3 +-
 clippy_lints/src/methods/read_line_without_trim.rs | 14 ++---
 clippy_lints/src/methods/seek_from_current.rs      |  8 +--
 .../src/methods/suspicious_command_arg_space.rs    |  3 +-
 clippy_lints/src/methods/suspicious_to_owned.rs    |  3 +-
 clippy_lints/src/methods/type_id_on_box.rs         |  6 +--
 clippy_lints/src/methods/uninit_assumed_init.rs    |  3 +-
 clippy_lints/src/methods/unnecessary_filter_map.rs |  3 +-
 clippy_lints/src/methods/unnecessary_fold.rs       |  3 +-
 .../src/methods/unnecessary_iter_cloned.rs         |  3 +-
 clippy_lints/src/methods/unnecessary_join.rs       |  3 +-
 .../src/methods/unnecessary_literal_unwrap.rs      |  3 +-
 clippy_lints/src/methods/unnecessary_sort_by.rs    |  3 +-
 clippy_lints/src/methods/unnecessary_to_owned.rs   |  6 ++-
 clippy_lints/src/methods/unwrap_or_else_default.rs |  8 +--
 clippy_lints/src/min_ident_chars.rs                | 11 ++--
 clippy_lints/src/missing_enforced_import_rename.rs |  7 ++-
 clippy_lints/src/missing_fields_in_debug.rs        | 20 +++-----
 clippy_lints/src/multiple_unsafe_ops_per_block.rs  | 12 ++---
 clippy_lints/src/needless_bool.rs                  |  4 +-
 clippy_lints/src/needless_else.rs                  |  4 +-
 clippy_lints/src/needless_for_each.rs              |  9 ++--
 clippy_lints/src/needless_if.rs                    |  5 +-
 .../src/needless_parens_on_range_literals.rs       |  8 ++-
 clippy_lints/src/needless_pass_by_ref_mut.rs       |  3 +-
 clippy_lints/src/needless_pass_by_value.rs         |  4 +-
 clippy_lints/src/no_effect.rs                      |  3 +-
 clippy_lints/src/non_send_fields_in_send_ty.rs     |  3 +-
 clippy_lints/src/nonstandard_macro_braces.rs       |  6 +--
 .../src/operators/arithmetic_side_effects.rs       | 18 +++----
 clippy_lints/src/operators/assign_op_pattern.rs    |  3 +-
 clippy_lints/src/operators/eq_op.rs                |  3 +-
 .../src/operators/misrefactored_assign_op.rs       |  3 +-
 clippy_lints/src/operators/op_ref.rs               |  4 +-
 clippy_lints/src/option_if_let_else.rs             |  5 +-
 clippy_lints/src/partialeq_to_none.rs              |  7 ++-
 clippy_lints/src/pass_by_ref_or_value.rs           |  3 +-
 clippy_lints/src/ptr.rs                            |  3 +-
 clippy_lints/src/question_mark.rs                  | 11 ++--
 clippy_lints/src/ranges.rs                         |  3 +-
 clippy_lints/src/raw_strings.rs                    | 12 ++---
 clippy_lints/src/rc_clone_in_vec_init.rs           |  3 +-
 clippy_lints/src/read_zero_byte_vec.rs             | 10 ++--
 clippy_lints/src/redundant_async_block.rs          | 13 +++--
 clippy_lints/src/redundant_closure_call.rs         |  3 +-
 clippy_lints/src/returns.rs                        |  3 +-
 clippy_lints/src/significant_drop_tightening.rs    | 23 ++++-----
 clippy_lints/src/single_call_fn.rs                 |  4 +-
 clippy_lints/src/single_component_path_imports.rs  |  7 ++-
 clippy_lints/src/single_range_in_vec_init.rs       | 10 ++--
 clippy_lints/src/size_of_in_element_count.rs       |  3 +-
 clippy_lints/src/size_of_ref.rs                    |  4 +-
 clippy_lints/src/std_instead_of_core.rs            |  6 ++-
 clippy_lints/src/strings.rs                        |  6 ++-
 clippy_lints/src/suspicious_doc_comments.rs        |  3 +-
 clippy_lints/src/suspicious_xor_used_as_pow.rs     |  3 +-
 clippy_lints/src/swap.rs                           |  4 +-
 clippy_lints/src/tests_outside_test_module.rs      |  9 ++--
 .../src/transmute/transmute_int_to_non_zero.rs     |  6 +--
 .../src/transmute/transmute_undefined_repr.rs      |  3 +-
 .../transmutes_expressible_as_ptr_casts.rs         |  3 +-
 clippy_lints/src/transmute/utils.rs                |  3 +-
 clippy_lints/src/tuple_array_conversions.rs        | 12 ++---
 clippy_lints/src/types/borrowed_box.rs             |  5 +-
 clippy_lints/src/types/box_collection.rs           |  3 +-
 clippy_lints/src/types/linked_list.rs              |  3 +-
 clippy_lints/src/types/option_option.rs            |  3 +-
 clippy_lints/src/types/rc_buffer.rs                |  3 +-
 clippy_lints/src/types/rc_mutex.rs                 |  3 +-
 clippy_lints/src/types/redundant_allocation.rs     |  3 +-
 clippy_lints/src/types/vec_box.rs                  |  3 +-
 clippy_lints/src/unnecessary_box_returns.rs        |  6 ++-
 .../src/unnecessary_owned_empty_strings.rs         |  3 +-
 .../src/unnecessary_struct_initialization.rs       |  5 +-
 clippy_lints/src/unnecessary_wraps.rs              |  3 +-
 clippy_lints/src/unnested_or_patterns.rs           |  3 +-
 clippy_lints/src/unused_unit.rs                    |  3 +-
 clippy_lints/src/unwrap.rs                         |  4 +-
 clippy_lints/src/use_self.rs                       | 11 ++--
 clippy_lints/src/useless_conversion.rs             |  3 +-
 .../src/utils/internal_lints/invalid_paths.rs      |  3 +-
 .../utils/internal_lints/lint_without_lint_pass.rs |  3 +-
 .../src/utils/internal_lints/metadata_collector.rs | 19 +++----
 .../src/utils/internal_lints/msrv_attr_impl.rs     |  3 +-
 clippy_lints/src/visibility.rs                     |  6 ++-
 clippy_lints/src/wildcard_imports.rs               |  6 +--
 clippy_utils/src/attrs.rs                          |  3 +-
 clippy_utils/src/check_proc_macro.rs               | 18 +++----
 clippy_utils/src/consts.rs                         |  6 +--
 clippy_utils/src/eager_or_lazy.rs                  |  6 +--
 clippy_utils/src/hir_utils.rs                      |  3 +-
 clippy_utils/src/lib.rs                            | 13 ++---
 clippy_utils/src/mir/possible_borrower.rs          | 12 +++--
 clippy_utils/src/qualify_min_const_fn.rs           |  4 +-
 clippy_utils/src/source.rs                         |  3 +-
 clippy_utils/src/ty.rs                             | 10 ++--
 clippy_utils/src/usage.rs                          |  6 +--
 lintcheck/src/config.rs                            |  3 +-
 lintcheck/src/main.rs                              |  4 +-
 lintcheck/src/recursive.rs                         |  3 +-
 rustfmt.toml                                       |  1 +
 .../excessive_nesting/auxiliary/proc_macros.rs     | 11 ++--
 tests/ui-toml/unwrap_used/unwrap_used.rs           |  4 +-
 tests/ui-toml/unwrap_used/unwrap_used.stderr       | 56 ++++++++++----------
 tests/ui/as_conversions.rs                         |  3 +-
 tests/ui/as_conversions.stderr                     |  6 +--
 tests/ui/auxiliary/macro_use_helper.rs             |  3 +-
 tests/ui/auxiliary/proc_macro_attr.rs              |  4 +-
 tests/ui/auxiliary/proc_macros.rs                  | 11 ++--
 tests/ui/default_trait_access.fixed                |  3 +-
 tests/ui/default_trait_access.rs                   |  3 +-
 tests/ui/default_trait_access.stderr               | 16 +++---
 tests/ui/get_first.fixed                           |  4 +-
 tests/ui/get_first.rs                              |  4 +-
 tests/ui/get_first.stderr                          |  6 +--
 tests/ui/get_unwrap.fixed                          |  4 +-
 tests/ui/get_unwrap.rs                             |  4 +-
 tests/ui/get_unwrap.stderr                         | 60 +++++++++++-----------
 tests/ui/issue-7447.rs                             |  5 +-
 tests/ui/issue-7447.stderr                         |  4 +-
 tests/ui/iter_cloned_collect.fixed                 |  3 +-
 tests/ui/iter_cloned_collect.rs                    |  3 +-
 tests/ui/iter_cloned_collect.stderr                | 10 ++--
 tests/ui/let_underscore_lock.rs                    |  3 +-
 tests/ui/let_underscore_lock.stderr                |  8 +--
 tests/ui/let_underscore_untyped.rs                 |  3 +-
 tests/ui/let_underscore_untyped.stderr             | 20 ++++----
 tests/ui/manual_retain.fixed                       |  7 +--
 tests/ui/manual_retain.rs                          |  7 +--
 tests/ui/manual_retain.stderr                      | 38 +++++++-------
 tests/ui/manual_try_fold.rs                        |  4 +-
 tests/ui/manual_try_fold.stderr                    |  8 +--
 tests/ui/match_as_ref.fixed                        |  4 +-
 tests/ui/match_as_ref.rs                           |  4 +-
 tests/ui/match_as_ref.stderr                       |  2 +-
 tests/ui/methods.rs                                |  5 +-
 tests/ui/methods.stderr                            |  4 +-
 tests/ui/min_ident_chars.rs                        |  3 +-
 tests/ui/min_ident_chars.stderr                    | 58 ++++++++++-----------
 tests/ui/min_max.rs                                |  4 +-
 tests/ui/min_max.stderr                            | 26 +++++-----
 tests/ui/missing_doc.rs                            |  4 +-
 tests/ui/mut_key.rs                                |  3 +-
 tests/ui/mut_key.stderr                            | 36 ++++++-------
 tests/ui/needless_if.fixed                         |  3 +-
 tests/ui/needless_if.rs                            |  3 +-
 tests/ui/needless_if.stderr                        | 14 ++---
 tests/ui/or_fun_call.fixed                         |  3 +-
 tests/ui/or_fun_call.rs                            |  3 +-
 tests/ui/or_fun_call.stderr                        | 56 ++++++++++----------
 tests/ui/redundant_allocation.rs                   |  9 ++--
 tests/ui/redundant_allocation.stderr               | 40 +++++++--------
 tests/ui/redundant_allocation_fixable.fixed        | 12 ++---
 tests/ui/redundant_allocation_fixable.rs           | 12 ++---
 tests/ui/redundant_allocation_fixable.stderr       | 24 ++++-----
 tests/ui/redundant_pattern_matching_ipaddr.fixed   |  6 +--
 tests/ui/redundant_pattern_matching_ipaddr.rs      |  6 +--
 tests/ui/redundant_pattern_matching_ipaddr.stderr  | 36 ++++++-------
 tests/ui/significant_drop_in_scrutinee.rs          |  3 +-
 tests/ui/significant_drop_in_scrutinee.stderr      | 52 +++++++++----------
 tests/ui/single_component_path_imports.fixed       |  4 ++
 tests/ui/single_component_path_imports.rs          |  4 ++
 tests/ui/single_component_path_imports.stderr      |  4 +-
 .../single_component_path_imports_nested_first.rs  |  2 +
 ...ngle_component_path_imports_nested_first.stderr |  4 +-
 .../ui/single_component_path_imports_self_after.rs |  1 +
 .../single_component_path_imports_self_before.rs   |  1 +
 tests/ui/unnecessary_to_owned.fixed                |  3 +-
 tests/ui/unnecessary_to_owned.rs                   |  3 +-
 tests/ui/unsafe_removed_from_name.rs               |  8 +++
 tests/ui/unsafe_removed_from_name.stderr           | 16 +++++-
 tests/ui/unused_peekable.rs                        |  3 +-
 tests/ui/unused_peekable.stderr                    | 16 +++---
 tests/ui/wildcard_imports.fixed                    |  1 +
 tests/ui/wildcard_imports.rs                       |  1 +
 tests/ui/wildcard_imports.stderr                   | 24 ++++-----
 tests/ui/wildcard_imports_2021.edition2018.fixed   |  1 +
 tests/ui/wildcard_imports_2021.edition2018.stderr  | 24 ++++-----
 tests/ui/wildcard_imports_2021.edition2021.fixed   |  1 +
 tests/ui/wildcard_imports_2021.edition2021.stderr  | 24 ++++-----
 tests/ui/wildcard_imports_2021.rs                  |  1 +
 279 files changed, 990 insertions(+), 1055 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/allow_attributes.rs b/clippy_lints/src/allow_attributes.rs
index eb21184713e..e1ef514edfd 100644
--- a/clippy_lints/src/allow_attributes.rs
+++ b/clippy_lints/src/allow_attributes.rs
@@ -1,5 +1,6 @@
 use ast::{AttrStyle, Attribute};
-use clippy_utils::{diagnostics::span_lint_and_sugg, is_from_proc_macro};
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::is_from_proc_macro;
 use rustc_ast as ast;
 use rustc_errors::Applicability;
 use rustc_lint::{LateContext, LateLintPass, LintContext};
diff --git a/clippy_lints/src/arc_with_non_send_sync.rs b/clippy_lints/src/arc_with_non_send_sync.rs
index 98ee8a9a880..7adcd9ad055 100644
--- a/clippy_lints/src/arc_with_non_send_sync.rs
+++ b/clippy_lints/src/arc_with_non_send_sync.rs
@@ -2,8 +2,7 @@ use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::last_path_segment;
 use clippy_utils::ty::{implements_trait, is_type_diagnostic_item};
 use rustc_hir::{Expr, ExprKind};
-use rustc_lint::LateContext;
-use rustc_lint::LateLintPass;
+use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
 use rustc_middle::ty::print::with_forced_trimmed_paths;
 use rustc_middle::ty::GenericArgKind;
diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs
index 2ba78f99569..2a5be275615 100644
--- a/clippy_lints/src/attrs.rs
+++ b/clippy_lints/src/attrs.rs
@@ -1,12 +1,10 @@
 //! checks for attributes
 
+use clippy_utils::diagnostics::{span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then};
+use clippy_utils::is_from_proc_macro;
 use clippy_utils::macros::{is_panic, macro_backtrace};
 use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::{first_line_of_span, is_present_in_source, snippet_opt, without_block_comments};
-use clippy_utils::{
-    diagnostics::{span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then},
-    is_from_proc_macro,
-};
 use if_chain::if_chain;
 use rustc_ast::{AttrKind, AttrStyle, Attribute, LitKind, MetaItemKind, MetaItemLit, NestedMetaItem};
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/blocks_in_if_conditions.rs b/clippy_lints/src/blocks_in_if_conditions.rs
index 569bf27c3e7..1593d7b0fb3 100644
--- a/clippy_lints/src/blocks_in_if_conditions.rs
+++ b/clippy_lints/src/blocks_in_if_conditions.rs
@@ -1,9 +1,8 @@
 use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg};
-use clippy_utils::get_parent_expr;
-use clippy_utils::higher;
 use clippy_utils::source::snippet_block_with_applicability;
 use clippy_utils::ty::implements_trait;
 use clippy_utils::visitors::{for_each_expr, Descend};
+use clippy_utils::{get_parent_expr, higher};
 use core::ops::ControlFlow;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/bool_to_int_with_if.rs b/clippy_lints/src/bool_to_int_with_if.rs
index bdb3a011602..1828dd65152 100644
--- a/clippy_lints/src/bool_to_int_with_if.rs
+++ b/clippy_lints/src/bool_to_int_with_if.rs
@@ -4,7 +4,9 @@ use rustc_hir::{Block, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
-use clippy_utils::{diagnostics::span_lint_and_then, in_constant, is_else_clause, is_integer_literal, sugg::Sugg};
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::sugg::Sugg;
+use clippy_utils::{in_constant, is_else_clause, is_integer_literal};
 use rustc_errors::Applicability;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/borrow_deref_ref.rs b/clippy_lints/src/borrow_deref_ref.rs
index 814108ed8a7..b3dbbb08f8e 100644
--- a/clippy_lints/src/borrow_deref_ref.rs
+++ b/clippy_lints/src/borrow_deref_ref.rs
@@ -1,9 +1,8 @@
 use crate::reference::DEREF_ADDROF;
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::is_from_proc_macro;
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::implements_trait;
-use clippy_utils::{get_parent_expr, is_lint_allowed};
+use clippy_utils::{get_parent_expr, is_from_proc_macro, is_lint_allowed};
 use rustc_errors::Applicability;
 use rustc_hir::{ExprKind, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/box_default.rs b/clippy_lints/src/box_default.rs
index e42c3fe2432..fa9c525fc08 100644
--- a/clippy_lints/src/box_default.rs
+++ b/clippy_lints/src/box_default.rs
@@ -1,12 +1,10 @@
-use clippy_utils::{
-    diagnostics::span_lint_and_sugg, get_parent_node, is_default_equivalent, macros::macro_backtrace, match_path,
-    path_def_id, paths, ty::expr_sig,
-};
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::macros::macro_backtrace;
+use clippy_utils::ty::expr_sig;
+use clippy_utils::{get_parent_node, is_default_equivalent, match_path, path_def_id, paths};
 use rustc_errors::Applicability;
-use rustc_hir::{
-    intravisit::{walk_ty, Visitor},
-    Block, Expr, ExprKind, Local, Node, QPath, TyKind,
-};
+use rustc_hir::intravisit::{walk_ty, Visitor};
+use rustc_hir::{Block, Expr, ExprKind, Local, Node, QPath, TyKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::print::with_forced_trimmed_paths;
diff --git a/clippy_lints/src/casts/as_ptr_cast_mut.rs b/clippy_lints/src/casts/as_ptr_cast_mut.rs
index 1633ffd589c..e3d1f7df294 100644
--- a/clippy_lints/src/casts/as_ptr_cast_mut.rs
+++ b/clippy_lints/src/casts/as_ptr_cast_mut.rs
@@ -3,10 +3,8 @@ use clippy_utils::source::snippet_opt;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::LateContext;
-use rustc_middle::{
-    mir::Mutability,
-    ty::{self, Ty, TypeAndMut},
-};
+use rustc_middle::mir::Mutability;
+use rustc_middle::ty::{self, Ty, TypeAndMut};
 
 use super::AS_PTR_CAST_MUT;
 
diff --git a/clippy_lints/src/casts/cast_slice_different_sizes.rs b/clippy_lints/src/casts/cast_slice_different_sizes.rs
index 27cc5a1c3f0..4d9cc4cacc3 100644
--- a/clippy_lints/src/casts/cast_slice_different_sizes.rs
+++ b/clippy_lints/src/casts/cast_slice_different_sizes.rs
@@ -1,10 +1,12 @@
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::msrvs::{self, Msrv};
-use clippy_utils::{diagnostics::span_lint_and_then, source};
+use clippy_utils::source;
 use if_chain::if_chain;
 use rustc_ast::Mutability;
 use rustc_hir::{Expr, ExprKind, Node};
 use rustc_lint::LateContext;
-use rustc_middle::ty::{self, layout::LayoutOf, Ty, TypeAndMut};
+use rustc_middle::ty::layout::LayoutOf;
+use rustc_middle::ty::{self, Ty, TypeAndMut};
 
 use super::CAST_SLICE_DIFFERENT_SIZES;
 
diff --git a/clippy_lints/src/casts/cast_slice_from_raw_parts.rs b/clippy_lints/src/casts/cast_slice_from_raw_parts.rs
index 1233c632a79..5e0123842b0 100644
--- a/clippy_lints/src/casts/cast_slice_from_raw_parts.rs
+++ b/clippy_lints/src/casts/cast_slice_from_raw_parts.rs
@@ -4,7 +4,8 @@ use clippy_utils::source::snippet_with_context;
 use clippy_utils::{match_def_path, paths};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
-use rustc_hir::{def_id::DefId, Expr, ExprKind};
+use rustc_hir::def_id::DefId;
+use rustc_hir::{Expr, ExprKind};
 use rustc_lint::LateContext;
 use rustc_middle::ty::{self, Ty};
 
diff --git a/clippy_lints/src/casts/ptr_cast_constness.rs b/clippy_lints/src/casts/ptr_cast_constness.rs
index f0c1df01430..ce1ab10910c 100644
--- a/clippy_lints/src/casts/ptr_cast_constness.rs
+++ b/clippy_lints/src/casts/ptr_cast_constness.rs
@@ -1,6 +1,6 @@
-use clippy_utils::msrvs::POINTER_CAST_CONSTNESS;
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::msrvs::{Msrv, POINTER_CAST_CONSTNESS};
 use clippy_utils::sugg::Sugg;
-use clippy_utils::{diagnostics::span_lint_and_sugg, msrvs::Msrv};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, Mutability};
diff --git a/clippy_lints/src/copies.rs b/clippy_lints/src/copies.rs
index 1c321f46e2d..e3a09636e24 100644
--- a/clippy_lints/src/copies.rs
+++ b/clippy_lints/src/copies.rs
@@ -10,8 +10,7 @@ use core::iter;
 use core::ops::ControlFlow;
 use rustc_errors::Applicability;
 use rustc_hir::def_id::DefIdSet;
-use rustc_hir::intravisit;
-use rustc_hir::{BinOpKind, Block, Expr, ExprKind, HirId, HirIdSet, Stmt, StmtKind};
+use rustc_hir::{intravisit, BinOpKind, Block, Expr, ExprKind, HirId, HirIdSet, Stmt, StmtKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::query::Key;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
diff --git a/clippy_lints/src/crate_in_macro_def.rs b/clippy_lints/src/crate_in_macro_def.rs
index 7436e9ce811..726674d88f1 100644
--- a/clippy_lints/src/crate_in_macro_def.rs
+++ b/clippy_lints/src/crate_in_macro_def.rs
@@ -5,7 +5,8 @@ use rustc_ast::tokenstream::{TokenStream, TokenTree};
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::{symbol::sym, Span};
+use rustc_span::symbol::sym;
+use rustc_span::Span;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/default_constructed_unit_structs.rs b/clippy_lints/src/default_constructed_unit_structs.rs
index ca9514ccc7d..a294c693787 100644
--- a/clippy_lints/src/default_constructed_unit_structs.rs
+++ b/clippy_lints/src/default_constructed_unit_structs.rs
@@ -1,5 +1,7 @@
-use clippy_utils::{diagnostics::span_lint_and_sugg, is_ty_alias, match_def_path, paths};
-use hir::{def::Res, ExprKind};
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::{is_ty_alias, match_def_path, paths};
+use hir::def::Res;
+use hir::ExprKind;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/default_instead_of_iter_empty.rs b/clippy_lints/src/default_instead_of_iter_empty.rs
index f296b80d283..572990aaba1 100644
--- a/clippy_lints/src/default_instead_of_iter_empty.rs
+++ b/clippy_lints/src/default_instead_of_iter_empty.rs
@@ -1,7 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::last_path_segment;
 use clippy_utils::source::snippet_with_context;
-use clippy_utils::{match_def_path, paths};
+use clippy_utils::{last_path_segment, match_def_path, paths};
 use rustc_errors::Applicability;
 use rustc_hir::{def, Expr, ExprKind, GenericArg, QPath, TyKind};
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/default_numeric_fallback.rs b/clippy_lints/src/default_numeric_fallback.rs
index e53a9877b20..0708b1cabdb 100644
--- a/clippy_lints/src/default_numeric_fallback.rs
+++ b/clippy_lints/src/default_numeric_fallback.rs
@@ -4,15 +4,11 @@ use clippy_utils::{get_parent_node, numeric_literal};
 use if_chain::if_chain;
 use rustc_ast::ast::{LitFloatType, LitIntType, LitKind};
 use rustc_errors::Applicability;
-use rustc_hir::{
-    intravisit::{walk_expr, walk_stmt, Visitor},
-    Body, Expr, ExprKind, HirId, ItemKind, Lit, Node, Stmt, StmtKind,
-};
+use rustc_hir::intravisit::{walk_expr, walk_stmt, Visitor};
+use rustc_hir::{Body, Expr, ExprKind, HirId, ItemKind, Lit, Node, Stmt, StmtKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
-use rustc_middle::{
-    lint::in_external_macro,
-    ty::{self, FloatTy, IntTy, PolyFnSig, Ty},
-};
+use rustc_middle::lint::in_external_macro;
+use rustc_middle::ty::{self, FloatTy, IntTy, PolyFnSig, Ty};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use std::iter;
 
diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index cdf64b96036..1b3bd268bf5 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -12,12 +12,11 @@ use rustc_ast::util::parser::{PREC_POSTFIX, PREC_PREFIX};
 use rustc_data_structures::fx::FxIndexMap;
 use rustc_data_structures::graph::iterate::{CycleDetector, TriColorDepthFirstSearch};
 use rustc_errors::Applicability;
+use rustc_hir::def_id::{DefId, LocalDefId};
 use rustc_hir::intravisit::{walk_ty, Visitor};
 use rustc_hir::{
-    self as hir,
-    def_id::{DefId, LocalDefId},
-    BindingAnnotation, Body, BodyId, BorrowKind, Closure, Expr, ExprKind, FnRetTy, GenericArg, HirId, ImplItem,
-    ImplItemKind, Item, ItemKind, Local, MatchSource, Mutability, Node, Pat, PatKind, Path, QPath, TraitItem,
+    self as hir, BindingAnnotation, Body, BodyId, BorrowKind, Closure, Expr, ExprKind, FnRetTy, GenericArg, HirId,
+    ImplItem, ImplItemKind, Item, ItemKind, Local, MatchSource, Mutability, Node, Pat, PatKind, Path, QPath, TraitItem,
     TraitItemKind, TyKind, UnOp,
 };
 use rustc_index::bit_set::BitSet;
@@ -30,9 +29,11 @@ use rustc_middle::ty::{
     ProjectionPredicate, Ty, TyCtxt, TypeVisitableExt, TypeckResults,
 };
 use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::{symbol::sym, Span, Symbol};
+use rustc_span::symbol::sym;
+use rustc_span::{Span, Symbol};
 use rustc_trait_selection::infer::InferCtxtExt as _;
-use rustc_trait_selection::traits::{query::evaluate_obligation::InferCtxtExt as _, Obligation, ObligationCause};
+use rustc_trait_selection::traits::query::evaluate_obligation::InferCtxtExt as _;
+use rustc_trait_selection::traits::{Obligation, ObligationCause};
 use std::collections::VecDeque;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/derivable_impls.rs b/clippy_lints/src/derivable_impls.rs
index ec0ca50cfec..0ff3ddd67de 100644
--- a/clippy_lints/src/derivable_impls.rs
+++ b/clippy_lints/src/derivable_impls.rs
@@ -3,10 +3,9 @@ use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::indent_of;
 use clippy_utils::{is_default_equivalent, peel_blocks};
 use rustc_errors::Applicability;
+use rustc_hir::def::{CtorKind, CtorOf, DefKind, Res};
 use rustc_hir::{
-    self as hir,
-    def::{CtorKind, CtorOf, DefKind, Res},
-    Body, Expr, ExprKind, GenericArg, Impl, ImplItemKind, Item, ItemKind, Node, PathSegment, QPath, TyKind,
+    self as hir, Body, Expr, ExprKind, GenericArg, Impl, ImplItemKind, Item, ItemKind, Node, PathSegment, QPath, TyKind,
 };
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::adjustment::{Adjust, PointerCast};
diff --git a/clippy_lints/src/derive.rs b/clippy_lints/src/derive.rs
index a005a360e9c..aea8cf2f9ab 100644
--- a/clippy_lints/src/derive.rs
+++ b/clippy_lints/src/derive.rs
@@ -1,7 +1,6 @@
 use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_note, span_lint_and_sugg, span_lint_and_then};
-use clippy_utils::paths;
 use clippy_utils::ty::{implements_trait, implements_trait_with_env, is_copy};
-use clippy_utils::{is_lint_allowed, match_def_path};
+use clippy_utils::{is_lint_allowed, match_def_path, paths};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::def_id::DefId;
diff --git a/clippy_lints/src/disallowed_names.rs b/clippy_lints/src/disallowed_names.rs
index 6e6615f08ee..04c2d44137a 100644
--- a/clippy_lints/src/disallowed_names.rs
+++ b/clippy_lints/src/disallowed_names.rs
@@ -1,4 +1,5 @@
-use clippy_utils::{diagnostics::span_lint, is_test_module_or_function};
+use clippy_utils::diagnostics::span_lint;
+use clippy_utils::is_test_module_or_function;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_hir::{Item, Pat, PatKind};
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/doc.rs b/clippy_lints/src/doc.rs
index 87d88f70752..2f474bf38e6 100644
--- a/clippy_lints/src/doc.rs
+++ b/clippy_lints/src/doc.rs
@@ -31,9 +31,8 @@ use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::edition::Edition;
 use rustc_span::source_map::{BytePos, FilePathMapping, SourceMap, Span};
 use rustc_span::{sym, FileName, Pos};
-use std::io;
 use std::ops::Range;
-use std::thread;
+use std::{io, thread};
 use url::Url;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/drop_forget_ref.rs b/clippy_lints/src/drop_forget_ref.rs
index 976ce47e869..14122abbf2c 100644
--- a/clippy_lints/src/drop_forget_ref.rs
+++ b/clippy_lints/src/drop_forget_ref.rs
@@ -1,7 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_note;
-use clippy_utils::get_parent_node;
-use clippy_utils::is_must_use_func_call;
 use clippy_utils::ty::{is_copy, is_must_use_ty, is_type_lang_item};
+use clippy_utils::{get_parent_node, is_must_use_func_call};
 use rustc_hir::{Arm, Expr, ExprKind, LangItem, Node};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
diff --git a/clippy_lints/src/empty_drop.rs b/clippy_lints/src/empty_drop.rs
index ec063c0f777..209fb66fa40 100644
--- a/clippy_lints/src/empty_drop.rs
+++ b/clippy_lints/src/empty_drop.rs
@@ -1,4 +1,5 @@
-use clippy_utils::{diagnostics::span_lint_and_sugg, peel_blocks};
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::peel_blocks;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Body, ExprKind, Impl, ImplItemKind, Item, ItemKind, Node};
diff --git a/clippy_lints/src/empty_structs_with_brackets.rs b/clippy_lints/src/empty_structs_with_brackets.rs
index c3a020433de..282157181ab 100644
--- a/clippy_lints/src/empty_structs_with_brackets.rs
+++ b/clippy_lints/src/empty_structs_with_brackets.rs
@@ -1,4 +1,5 @@
-use clippy_utils::{diagnostics::span_lint_and_then, source::snippet_opt};
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::source::snippet_opt;
 use rustc_ast::ast::{Item, ItemKind, VariantData};
 use rustc_errors::Applicability;
 use rustc_lexer::TokenKind;
diff --git a/clippy_lints/src/endian_bytes.rs b/clippy_lints/src/endian_bytes.rs
index f470987833e..dda14b4df53 100644
--- a/clippy_lints/src/endian_bytes.rs
+++ b/clippy_lints/src/endian_bytes.rs
@@ -1,8 +1,10 @@
 use crate::Lint;
-use clippy_utils::{diagnostics::span_lint_and_then, is_lint_allowed};
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::is_lint_allowed;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
-use rustc_middle::{lint::in_external_macro, ty::Ty};
+use rustc_middle::lint::in_external_macro;
+use rustc_middle::ty::Ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::Symbol;
 use std::borrow::Cow;
diff --git a/clippy_lints/src/entry.rs b/clippy_lints/src/entry.rs
index 86e94a62a78..49aae6b3745 100644
--- a/clippy_lints/src/entry.rs
+++ b/clippy_lints/src/entry.rs
@@ -1,18 +1,14 @@
-use clippy_utils::higher;
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::{reindent_multiline, snippet_indent, snippet_with_applicability, snippet_with_context};
 use clippy_utils::{
-    can_move_expr_to_closure_no_visit,
-    diagnostics::span_lint_and_sugg,
-    is_expr_final_block_expr, is_expr_used_or_unified, match_def_path, paths, peel_hir_expr_while,
-    source::{reindent_multiline, snippet_indent, snippet_with_applicability, snippet_with_context},
-    SpanlessEq,
+    can_move_expr_to_closure_no_visit, higher, is_expr_final_block_expr, is_expr_used_or_unified, match_def_path,
+    paths, peel_hir_expr_while, SpanlessEq,
 };
 use core::fmt::{self, Write};
 use rustc_errors::Applicability;
-use rustc_hir::{
-    hir_id::HirIdSet,
-    intravisit::{walk_expr, Visitor},
-    Block, Expr, ExprKind, Guard, HirId, Let, Pat, Stmt, StmtKind, UnOp,
-};
+use rustc_hir::hir_id::HirIdSet;
+use rustc_hir::intravisit::{walk_expr, Visitor};
+use rustc_hir::{Block, Expr, ExprKind, Guard, HirId, Let, Pat, Stmt, StmtKind, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::{Span, SyntaxContext, DUMMY_SP};
diff --git a/clippy_lints/src/escape.rs b/clippy_lints/src/escape.rs
index a51a8ee09f6..dbe3453e7bf 100644
--- a/clippy_lints/src/escape.rs
+++ b/clippy_lints/src/escape.rs
@@ -1,6 +1,5 @@
 use clippy_utils::diagnostics::span_lint_hir;
-use rustc_hir::intravisit;
-use rustc_hir::{self, AssocItemKind, Body, FnDecl, HirId, HirIdSet, Impl, ItemKind, Node, Pat, PatKind};
+use rustc_hir::{self, intravisit, AssocItemKind, Body, FnDecl, HirId, HirIdSet, Impl, ItemKind, Node, Pat, PatKind};
 use rustc_hir_typeck::expr_use_visitor::{Delegate, ExprUseVisitor, PlaceBase, PlaceWithHirId};
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/excessive_nesting.rs b/clippy_lints/src/excessive_nesting.rs
index d04d833e630..8911f1872c2 100644
--- a/clippy_lints/src/excessive_nesting.rs
+++ b/clippy_lints/src/excessive_nesting.rs
@@ -1,9 +1,8 @@
-use clippy_utils::{diagnostics::span_lint_and_help, source::snippet};
-use rustc_ast::{
-    node_id::NodeSet,
-    visit::{walk_block, walk_item, Visitor},
-    Block, Crate, Inline, Item, ItemKind, ModKind, NodeId,
-};
+use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::source::snippet;
+use rustc_ast::node_id::NodeSet;
+use rustc_ast::visit::{walk_block, walk_item, Visitor};
+use rustc_ast::{Block, Crate, Inline, Item, ItemKind, ModKind, NodeId};
 use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
diff --git a/clippy_lints/src/extra_unused_type_parameters.rs b/clippy_lints/src/extra_unused_type_parameters.rs
index 126bed6789c..c18006a71c2 100644
--- a/clippy_lints/src/extra_unused_type_parameters.rs
+++ b/clippy_lints/src/extra_unused_type_parameters.rs
@@ -1,6 +1,5 @@
 use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_then};
-use clippy_utils::is_from_proc_macro;
-use clippy_utils::trait_ref_of_method;
+use clippy_utils::{is_from_proc_macro, trait_ref_of_method};
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_impl_item, walk_item, walk_param_bound, walk_ty, Visitor};
@@ -12,10 +11,8 @@ use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::hir::nested_filter;
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::{
-    def_id::{DefId, LocalDefId},
-    Span,
-};
+use rustc_span::def_id::{DefId, LocalDefId};
+use rustc_span::Span;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/floating_point_arithmetic.rs b/clippy_lints/src/floating_point_arithmetic.rs
index 5e0fcd74339..29e5315f88b 100644
--- a/clippy_lints/src/floating_point_arithmetic.rs
+++ b/clippy_lints/src/floating_point_arithmetic.rs
@@ -1,10 +1,8 @@
-use clippy_utils::consts::{
-    constant, constant_simple, Constant,
-    Constant::{Int, F32, F64},
-};
+use clippy_utils::consts::Constant::{Int, F32, F64};
+use clippy_utils::consts::{constant, constant_simple, Constant};
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::{
-    diagnostics::span_lint_and_sugg, eq_expr_value, get_parent_expr, higher, in_constant, is_no_std_crate,
-    numeric_literal, peel_blocks, sugg,
+    eq_expr_value, get_parent_expr, higher, in_constant, is_no_std_crate, numeric_literal, peel_blocks, sugg,
 };
 use if_chain::if_chain;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/format_args.rs b/clippy_lints/src/format_args.rs
index 08e45ed7d0e..d27f5c24366 100644
--- a/clippy_lints/src/format_args.rs
+++ b/clippy_lints/src/format_args.rs
@@ -14,10 +14,8 @@ use rustc_ast::{
     FormatArgPosition, FormatArgPositionKind, FormatArgsPiece, FormatArgumentKind, FormatCount, FormatOptions,
     FormatPlaceholder, FormatTrait,
 };
-use rustc_errors::{
-    Applicability,
-    SuggestionStyle::{CompletelyHidden, ShowCode},
-};
+use rustc_errors::Applicability;
+use rustc_errors::SuggestionStyle::{CompletelyHidden, ShowCode};
 use rustc_hir::{Expr, ExprKind, LangItem};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::ty::adjustment::{Adjust, Adjustment};
diff --git a/clippy_lints/src/format_impl.rs b/clippy_lints/src/format_impl.rs
index 3ddee1842a3..66b74d3b5ab 100644
--- a/clippy_lints/src/format_impl.rs
+++ b/clippy_lints/src/format_impl.rs
@@ -7,8 +7,8 @@ use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, Impl, ImplItem, ImplItemKind, QPath};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::Span;
-use rustc_span::{sym, symbol::kw, Symbol};
+use rustc_span::symbol::kw;
+use rustc_span::{sym, Span, Symbol};
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/from_over_into.rs b/clippy_lints/src/from_over_into.rs
index 92d67ef359d..9584bec40ee 100644
--- a/clippy_lints/src/from_over_into.rs
+++ b/clippy_lints/src/from_over_into.rs
@@ -10,7 +10,8 @@ use rustc_hir::{
     TyKind,
 };
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::{hir::nested_filter::OnlyBodies, ty};
+use rustc_middle::hir::nested_filter::OnlyBodies;
+use rustc_middle::ty;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::symbol::{kw, sym};
 use rustc_span::{Span, Symbol};
diff --git a/clippy_lints/src/from_raw_with_void_ptr.rs b/clippy_lints/src/from_raw_with_void_ptr.rs
index 096508dc4f1..5e859d97c62 100644
--- a/clippy_lints/src/from_raw_with_void_ptr.rs
+++ b/clippy_lints/src/from_raw_with_void_ptr.rs
@@ -4,8 +4,7 @@ use clippy_utils::{match_def_path, path_def_id, paths};
 use rustc_hir::def_id::DefId;
 use rustc_hir::{Expr, ExprKind, QPath};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty::RawPtr;
-use rustc_middle::ty::TypeAndMut;
+use rustc_middle::ty::{RawPtr, TypeAndMut};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::sym;
 
diff --git a/clippy_lints/src/functions/impl_trait_in_params.rs b/clippy_lints/src/functions/impl_trait_in_params.rs
index d3d0d91c1be..597fca88885 100644
--- a/clippy_lints/src/functions/impl_trait_in_params.rs
+++ b/clippy_lints/src/functions/impl_trait_in_params.rs
@@ -1,6 +1,8 @@
-use clippy_utils::{diagnostics::span_lint_and_then, is_in_test_function};
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::is_in_test_function;
 
-use rustc_hir::{intravisit::FnKind, Body, HirId};
+use rustc_hir::intravisit::FnKind;
+use rustc_hir::{Body, HirId};
 use rustc_lint::LateContext;
 use rustc_span::Span;
 
diff --git a/clippy_lints/src/functions/misnamed_getters.rs b/clippy_lints/src/functions/misnamed_getters.rs
index b244b913314..169b70f0463 100644
--- a/clippy_lints/src/functions/misnamed_getters.rs
+++ b/clippy_lints/src/functions/misnamed_getters.rs
@@ -1,7 +1,8 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet;
 use rustc_errors::Applicability;
-use rustc_hir::{intravisit::FnKind, Body, ExprKind, FnDecl, ImplicitSelfKind, Unsafety};
+use rustc_hir::intravisit::FnKind;
+use rustc_hir::{Body, ExprKind, FnDecl, ImplicitSelfKind, Unsafety};
 use rustc_lint::LateContext;
 use rustc_middle::ty;
 use rustc_span::Span;
diff --git a/clippy_lints/src/functions/must_use.rs b/clippy_lints/src/functions/must_use.rs
index d0ad2628264..c211ca67937 100644
--- a/clippy_lints/src/functions/must_use.rs
+++ b/clippy_lints/src/functions/must_use.rs
@@ -1,14 +1,13 @@
 use hir::FnSig;
 use rustc_ast::ast::Attribute;
 use rustc_errors::Applicability;
+use rustc_hir::def::Res;
 use rustc_hir::def_id::DefIdSet;
-use rustc_hir::{self as hir, def::Res, QPath};
+use rustc_hir::{self as hir, QPath};
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::{LateContext, LintContext};
-use rustc_middle::{
-    lint::in_external_macro,
-    ty::{self, Ty},
-};
+use rustc_middle::lint::in_external_macro;
+use rustc_middle::ty::{self, Ty};
 use rustc_span::{sym, Span, Symbol};
 
 use clippy_utils::attrs::is_proc_macro;
diff --git a/clippy_lints/src/if_let_mutex.rs b/clippy_lints/src/if_let_mutex.rs
index 9ea8c494cfc..e614a8f694f 100644
--- a/clippy_lints/src/if_let_mutex.rs
+++ b/clippy_lints/src/if_let_mutex.rs
@@ -1,7 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::higher;
 use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::SpanlessEq;
+use clippy_utils::{higher, SpanlessEq};
 use if_chain::if_chain;
 use rustc_errors::Diagnostic;
 use rustc_hir::intravisit::{self as visit, Visitor};
diff --git a/clippy_lints/src/implicit_return.rs b/clippy_lints/src/implicit_return.rs
index 372b6ead3fe..a6b035d5106 100644
--- a/clippy_lints/src/implicit_return.rs
+++ b/clippy_lints/src/implicit_return.rs
@@ -1,9 +1,7 @@
-use clippy_utils::{
-    diagnostics::span_lint_hir_and_then,
-    get_async_fn_body, is_async_fn,
-    source::{snippet_with_applicability, snippet_with_context, walk_span_to_context},
-    visitors::for_each_expr,
-};
+use clippy_utils::diagnostics::span_lint_hir_and_then;
+use clippy_utils::source::{snippet_with_applicability, snippet_with_context, walk_span_to_context};
+use clippy_utils::visitors::for_each_expr;
+use clippy_utils::{get_async_fn_body, is_async_fn};
 use core::ops::ControlFlow;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::FnKind;
diff --git a/clippy_lints/src/incorrect_impls.rs b/clippy_lints/src/incorrect_impls.rs
index 25e1cb36b74..166908ef4e4 100644
--- a/clippy_lints/src/incorrect_impls.rs
+++ b/clippy_lints/src/incorrect_impls.rs
@@ -1,15 +1,15 @@
-use clippy_utils::{
-    diagnostics::{span_lint_and_sugg, span_lint_and_then},
-    get_parent_node, is_res_lang_ctor, last_path_segment, path_res,
-    ty::implements_trait,
-};
+use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
+use clippy_utils::ty::implements_trait;
+use clippy_utils::{get_parent_node, is_res_lang_ctor, last_path_segment, path_res};
 use rustc_errors::Applicability;
-use rustc_hir::{def::Res, Expr, ExprKind, ImplItem, ImplItemKind, ItemKind, LangItem, Node, UnOp};
+use rustc_hir::def::Res;
+use rustc_hir::{Expr, ExprKind, ImplItem, ImplItemKind, ItemKind, LangItem, Node, UnOp};
 use rustc_hir_analysis::hir_ty_to_ty;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::EarlyBinder;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::{sym, symbol::kw};
+use rustc_span::sym;
+use rustc_span::symbol::kw;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/index_refutable_slice.rs b/clippy_lints/src/index_refutable_slice.rs
index 7a269e98ff1..01a7c497cbe 100644
--- a/clippy_lints/src/index_refutable_slice.rs
+++ b/clippy_lints/src/index_refutable_slice.rs
@@ -13,7 +13,8 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::nested_filter;
 use rustc_middle::ty;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::{symbol::Ident, Span};
+use rustc_span::symbol::Ident;
+use rustc_span::Span;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/inherent_impl.rs b/clippy_lints/src/inherent_impl.rs
index 7c41699f307..77e541d5b16 100644
--- a/clippy_lints/src/inherent_impl.rs
+++ b/clippy_lints/src/inherent_impl.rs
@@ -3,7 +3,8 @@
 use clippy_utils::diagnostics::span_lint_and_note;
 use clippy_utils::is_lint_allowed;
 use rustc_data_structures::fx::FxHashMap;
-use rustc_hir::{def_id::LocalDefId, Item, ItemKind, Node};
+use rustc_hir::def_id::LocalDefId;
+use rustc_hir::{Item, ItemKind, Node};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::Span;
diff --git a/clippy_lints/src/instant_subtraction.rs b/clippy_lints/src/instant_subtraction.rs
index 34e9991582c..8df7dfb8b9e 100644
--- a/clippy_lints/src/instant_subtraction.rs
+++ b/clippy_lints/src/instant_subtraction.rs
@@ -7,7 +7,8 @@ use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::{source_map::Spanned, sym};
+use rustc_span::source_map::Spanned;
+use rustc_span::sym;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/items_after_test_module.rs b/clippy_lints/src/items_after_test_module.rs
index f684847c0c2..55a43e91562 100644
--- a/clippy_lints/src/items_after_test_module.rs
+++ b/clippy_lints/src/items_after_test_module.rs
@@ -1,4 +1,5 @@
-use clippy_utils::{diagnostics::span_lint_and_help, is_from_proc_macro, is_in_cfg_test};
+use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::{is_from_proc_macro, is_in_cfg_test};
 use rustc_hir::{HirId, ItemId, ItemKind, Mod};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
diff --git a/clippy_lints/src/iter_not_returning_iterator.rs b/clippy_lints/src/iter_not_returning_iterator.rs
index c924d7361ce..c16717deee0 100644
--- a/clippy_lints/src/iter_not_returning_iterator.rs
+++ b/clippy_lints/src/iter_not_returning_iterator.rs
@@ -1,5 +1,8 @@
-use clippy_utils::{diagnostics::span_lint, get_parent_node, ty::implements_trait};
-use rustc_hir::{def_id::LocalDefId, FnSig, ImplItem, ImplItemKind, Item, ItemKind, Node, TraitItem, TraitItemKind};
+use clippy_utils::diagnostics::span_lint;
+use clippy_utils::get_parent_node;
+use clippy_utils::ty::implements_trait;
+use rustc_hir::def_id::LocalDefId;
+use rustc_hir::{FnSig, ImplItem, ImplItemKind, Item, ItemKind, Node, TraitItem, TraitItemKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::symbol::sym;
diff --git a/clippy_lints/src/large_enum_variant.rs b/clippy_lints/src/large_enum_variant.rs
index 1c99bd2f3d0..9caaec4e5cc 100644
--- a/clippy_lints/src/large_enum_variant.rs
+++ b/clippy_lints/src/large_enum_variant.rs
@@ -1,10 +1,8 @@
 //! lint when there is a large size difference between variants on an enum
 
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::{
-    diagnostics::span_lint_and_then,
-    ty::{approx_ty_size, is_copy, AdtVariantInfo},
-};
+use clippy_utils::ty::{approx_ty_size, is_copy, AdtVariantInfo};
 use rustc_errors::Applicability;
 use rustc_hir::{Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/large_futures.rs b/clippy_lints/src/large_futures.rs
index 087c4a65250..d67d5899350 100644
--- a/clippy_lints/src/large_futures.rs
+++ b/clippy_lints/src/large_futures.rs
@@ -1,5 +1,6 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet;
-use clippy_utils::{diagnostics::span_lint_and_sugg, ty::implements_trait};
+use clippy_utils::ty::implements_trait;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, LangItem, MatchSource, QPath};
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/large_include_file.rs b/clippy_lints/src/large_include_file.rs
index 424c0d9e798..566901de347 100644
--- a/clippy_lints/src/large_include_file.rs
+++ b/clippy_lints/src/large_include_file.rs
@@ -2,8 +2,7 @@ use clippy_utils::diagnostics::span_lint_and_note;
 use clippy_utils::is_lint_allowed;
 use clippy_utils::macros::root_macro_call_first_node;
 use rustc_ast::LitKind;
-use rustc_hir::Expr;
-use rustc_hir::ExprKind;
+use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::sym;
diff --git a/clippy_lints/src/large_stack_frames.rs b/clippy_lints/src/large_stack_frames.rs
index 9c0cc978a39..7aa1446d53d 100644
--- a/clippy_lints/src/large_stack_frames.rs
+++ b/clippy_lints/src/large_stack_frames.rs
@@ -4,11 +4,9 @@ use clippy_utils::diagnostics::span_lint_and_note;
 use clippy_utils::fn_has_unsatisfiable_preds;
 use rustc_hir::def_id::LocalDefId;
 use rustc_hir::intravisit::FnKind;
-use rustc_hir::Body;
-use rustc_hir::FnDecl;
+use rustc_hir::{Body, FnDecl};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::declare_tool_lint;
-use rustc_session::impl_lint_pass;
+use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::Span;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/len_zero.rs b/clippy_lints/src/len_zero.rs
index 17bd89efaee..e64d46bd6e3 100644
--- a/clippy_lints/src/len_zero.rs
+++ b/clippy_lints/src/len_zero.rs
@@ -1,22 +1,23 @@
 use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::snippet_with_context;
-use clippy_utils::{get_item_name, get_parent_as_impl, is_lint_allowed, peel_ref_operators, sugg::Sugg};
+use clippy_utils::sugg::Sugg;
+use clippy_utils::{get_item_name, get_parent_as_impl, is_lint_allowed, peel_ref_operators};
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
-use rustc_hir::def_id::DefIdSet;
+use rustc_hir::def::Res;
+use rustc_hir::def_id::{DefId, DefIdSet};
+use rustc_hir::lang_items::LangItem;
 use rustc_hir::{
-    def::Res, def_id::DefId, lang_items::LangItem, AssocItemKind, BinOpKind, Expr, ExprKind, FnRetTy, GenericArg,
-    GenericBound, ImplItem, ImplItemKind, ImplicitSelfKind, Item, ItemKind, Mutability, Node, PathSegment, PrimTy,
-    QPath, TraitItemRef, TyKind, TypeBindingKind,
+    AssocItemKind, BinOpKind, Expr, ExprKind, FnRetTy, GenericArg, GenericBound, ImplItem, ImplItemKind,
+    ImplicitSelfKind, Item, ItemKind, Mutability, Node, PathSegment, PrimTy, QPath, TraitItemRef, TyKind,
+    TypeBindingKind,
 };
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{self, AssocKind, FnSig, Ty};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::{
-    source_map::{Span, Spanned, Symbol},
-    symbol::sym,
-};
+use rustc_span::source_map::{Span, Spanned, Symbol};
+use rustc_span::symbol::sym;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/let_if_seq.rs b/clippy_lints/src/let_if_seq.rs
index db41bc67da1..2f6f36c3960 100644
--- a/clippy_lints/src/let_if_seq.rs
+++ b/clippy_lints/src/let_if_seq.rs
@@ -1,6 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::path_to_local_id;
 use clippy_utils::source::snippet;
-use clippy_utils::{path_to_local_id, visitors::is_local_used};
+use clippy_utils::visitors::is_local_used;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
diff --git a/clippy_lints/src/let_underscore.rs b/clippy_lints/src/let_underscore.rs
index e6614180920..b505a4e0af9 100644
--- a/clippy_lints/src/let_underscore.rs
+++ b/clippy_lints/src/let_underscore.rs
@@ -1,7 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_help;
-use clippy_utils::is_from_proc_macro;
 use clippy_utils::ty::{implements_trait, is_must_use_ty, match_type};
-use clippy_utils::{is_must_use_func_call, paths};
+use clippy_utils::{is_from_proc_macro, is_must_use_func_call, paths};
 use rustc_hir::{Local, PatKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::lint::in_external_macro;
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index cebe2e44c0f..a60da13d053 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -348,11 +348,10 @@ mod zero_div_zero;
 mod zero_sized_map_values;
 // end lints modules, do not remove this comment, it’s used in `update_lints`
 
+use crate::utils::conf::metadata::get_configuration_metadata;
+use crate::utils::conf::TryConf;
 pub use crate::utils::conf::{lookup_conf_file, Conf};
-use crate::utils::{
-    conf::{metadata::get_configuration_metadata, TryConf},
-    FindAll,
-};
+use crate::utils::FindAll;
 
 /// Register all pre expansion lints
 ///
diff --git a/clippy_lints/src/lines_filter_map_ok.rs b/clippy_lints/src/lines_filter_map_ok.rs
index 09b2032e20f..49425ff0a8e 100644
--- a/clippy_lints/src/lines_filter_map_ok.rs
+++ b/clippy_lints/src/lines_filter_map_ok.rs
@@ -1,7 +1,6 @@
-use clippy_utils::{
-    diagnostics::span_lint_and_then, is_diag_item_method, is_trait_method, match_def_path, path_to_local_id, paths,
-    ty::match_type,
-};
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::ty::match_type;
+use clippy_utils::{is_diag_item_method, is_trait_method, match_def_path, path_to_local_id, paths};
 use rustc_errors::Applicability;
 use rustc_hir::{Body, Closure, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/loops/manual_find.rs b/clippy_lints/src/loops/manual_find.rs
index 4bb9936e9cd..0aaa66e6bce 100644
--- a/clippy_lints/src/loops/manual_find.rs
+++ b/clippy_lints/src/loops/manual_find.rs
@@ -1,14 +1,14 @@
 use super::utils::make_iterator_snippet;
 use super::MANUAL_FIND;
-use clippy_utils::{
-    diagnostics::span_lint_and_then, higher, is_res_lang_ctor, path_res, peel_blocks_with_stmt,
-    source::snippet_with_applicability, ty::implements_trait,
-};
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::ty::implements_trait;
+use clippy_utils::{higher, is_res_lang_ctor, path_res, peel_blocks_with_stmt};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
-use rustc_hir::{
-    def::Res, lang_items::LangItem, BindingAnnotation, Block, Expr, ExprKind, HirId, Node, Pat, PatKind, Stmt, StmtKind,
-};
+use rustc_hir::def::Res;
+use rustc_hir::lang_items::LangItem;
+use rustc_hir::{BindingAnnotation, Block, Expr, ExprKind, HirId, Node, Pat, PatKind, Stmt, StmtKind};
 use rustc_lint::LateContext;
 use rustc_span::source_map::Span;
 
diff --git a/clippy_lints/src/loops/manual_flatten.rs b/clippy_lints/src/loops/manual_flatten.rs
index 1e02a30e35f..559a2c03f14 100644
--- a/clippy_lints/src/loops/manual_flatten.rs
+++ b/clippy_lints/src/loops/manual_flatten.rs
@@ -1,9 +1,8 @@
 use super::utils::make_iterator_snippet;
 use super::MANUAL_FLATTEN;
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::higher;
 use clippy_utils::visitors::is_local_used;
-use clippy_utils::{path_to_local_id, peel_blocks_with_stmt};
+use clippy_utils::{higher, path_to_local_id, peel_blocks_with_stmt};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::def::{DefKind, Res};
diff --git a/clippy_lints/src/loops/manual_while_let_some.rs b/clippy_lints/src/loops/manual_while_let_some.rs
index cb9c84be4c7..ca584a454d0 100644
--- a/clippy_lints/src/loops/manual_while_let_some.rs
+++ b/clippy_lints/src/loops/manual_while_let_some.rs
@@ -1,9 +1,6 @@
-use clippy_utils::{
-    diagnostics::{multispan_sugg_with_applicability, span_lint_and_then},
-    match_def_path, paths,
-    source::snippet,
-    SpanlessEq,
-};
+use clippy_utils::diagnostics::{multispan_sugg_with_applicability, span_lint_and_then};
+use clippy_utils::source::snippet;
+use clippy_utils::{match_def_path, paths, SpanlessEq};
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, Pat, Stmt, StmtKind, UnOp};
 use rustc_lint::LateContext;
diff --git a/clippy_lints/src/loops/mut_range_bound.rs b/clippy_lints/src/loops/mut_range_bound.rs
index 4dae93f6028..b83d148b5f2 100644
--- a/clippy_lints/src/loops/mut_range_bound.rs
+++ b/clippy_lints/src/loops/mut_range_bound.rs
@@ -7,7 +7,8 @@ use rustc_hir::{BindingAnnotation, Expr, ExprKind, HirId, Node, PatKind};
 use rustc_hir_typeck::expr_use_visitor::{Delegate, ExprUseVisitor, PlaceBase, PlaceWithHirId};
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::LateContext;
-use rustc_middle::{mir::FakeReadCause, ty};
+use rustc_middle::mir::FakeReadCause;
+use rustc_middle::ty;
 use rustc_span::source_map::Span;
 
 pub(super) fn check(cx: &LateContext<'_>, arg: &Expr<'_>, body: &Expr<'_>) {
diff --git a/clippy_lints/src/loops/never_loop.rs b/clippy_lints/src/loops/never_loop.rs
index ee338c6beb0..7da9121fbb3 100644
--- a/clippy_lints/src/loops/never_loop.rs
+++ b/clippy_lints/src/loops/never_loop.rs
@@ -1,9 +1,9 @@
 use super::utils::make_iterator_snippet;
 use super::NEVER_LOOP;
-use clippy_utils::consts::constant;
+use clippy_utils::consts::{constant, Constant};
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::higher::ForLoop;
 use clippy_utils::source::snippet;
-use clippy_utils::{consts::Constant, diagnostics::span_lint_and_then};
 use rustc_errors::Applicability;
 use rustc_hir::{Block, Destination, Expr, ExprKind, HirId, InlineAsmOperand, Pat, Stmt, StmtKind};
 use rustc_lint::LateContext;
diff --git a/clippy_lints/src/loops/while_immutable_condition.rs b/clippy_lints/src/loops/while_immutable_condition.rs
index d1a1f773f87..7f24f3c5dc2 100644
--- a/clippy_lints/src/loops/while_immutable_condition.rs
+++ b/clippy_lints/src/loops/while_immutable_condition.rs
@@ -6,8 +6,7 @@ use if_chain::if_chain;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::def_id::DefIdMap;
 use rustc_hir::intravisit::{walk_expr, Visitor};
-use rustc_hir::HirIdSet;
-use rustc_hir::{Expr, ExprKind, QPath};
+use rustc_hir::{Expr, ExprKind, HirIdSet, QPath};
 use rustc_lint::LateContext;
 
 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, cond: &'tcx Expr<'_>, expr: &'tcx Expr<'_>) {
diff --git a/clippy_lints/src/loops/while_let_on_iterator.rs b/clippy_lints/src/loops/while_let_on_iterator.rs
index 55989f8a446..ed6af90ef04 100644
--- a/clippy_lints/src/loops/while_let_on_iterator.rs
+++ b/clippy_lints/src/loops/while_let_on_iterator.rs
@@ -1,18 +1,18 @@
 use super::WHILE_LET_ON_ITERATOR;
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::higher;
 use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::{
-    get_enclosing_loop_or_multi_call_closure, is_refutable, is_res_lang_ctor, is_trait_method, visitors::is_res_used,
-};
+use clippy_utils::visitors::is_res_used;
+use clippy_utils::{get_enclosing_loop_or_multi_call_closure, higher, is_refutable, is_res_lang_ctor, is_trait_method};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
+use rustc_hir::def::Res;
 use rustc_hir::intravisit::{walk_expr, Visitor};
-use rustc_hir::{def::Res, Closure, Expr, ExprKind, HirId, LangItem, Local, Mutability, PatKind, UnOp};
+use rustc_hir::{Closure, Expr, ExprKind, HirId, LangItem, Local, Mutability, PatKind, UnOp};
 use rustc_lint::LateContext;
 use rustc_middle::hir::nested_filter::OnlyBodies;
 use rustc_middle::ty::adjustment::Adjust;
-use rustc_span::{symbol::sym, Symbol};
+use rustc_span::symbol::sym;
+use rustc_span::Symbol;
 
 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
     let (scrutinee_expr, iter_expr_struct, iter_expr, some_pat, loop_expr) = if_chain! {
diff --git a/clippy_lints/src/macro_use.rs b/clippy_lints/src/macro_use.rs
index cb3bda96133..70c5182472a 100644
--- a/clippy_lints/src/macro_use.rs
+++ b/clippy_lints/src/macro_use.rs
@@ -8,7 +8,8 @@ use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::{edition::Edition, sym, Span};
+use rustc_span::edition::Edition;
+use rustc_span::{sym, Span};
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/manual_clamp.rs b/clippy_lints/src/manual_clamp.rs
index 440362b96b4..e75666e61f5 100644
--- a/clippy_lints/src/manual_clamp.rs
+++ b/clippy_lints/src/manual_clamp.rs
@@ -4,21 +4,19 @@ use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::implements_trait;
 use clippy_utils::visitors::is_const_evaluatable;
-use clippy_utils::MaybePath;
 use clippy_utils::{
     eq_expr_value, in_constant, is_diag_trait_item, is_trait_method, path_res, path_to_local_id, peel_blocks,
-    peel_blocks_with_stmt,
+    peel_blocks_with_stmt, MaybePath,
 };
 use itertools::Itertools;
-use rustc_errors::Applicability;
-use rustc_errors::Diagnostic;
-use rustc_hir::{
-    def::Res, Arm, BinOpKind, Block, Expr, ExprKind, Guard, HirId, PatKind, PathSegment, PrimTy, QPath, StmtKind,
-};
+use rustc_errors::{Applicability, Diagnostic};
+use rustc_hir::def::Res;
+use rustc_hir::{Arm, BinOpKind, Block, Expr, ExprKind, Guard, HirId, PatKind, PathSegment, PrimTy, QPath, StmtKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::Ty;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::{symbol::sym, Span};
+use rustc_span::symbol::sym;
+use rustc_span::Span;
 use std::ops::Deref;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/manual_float_methods.rs b/clippy_lints/src/manual_float_methods.rs
index 09b39634333..085c73a5f9f 100644
--- a/clippy_lints/src/manual_float_methods.rs
+++ b/clippy_lints/src/manual_float_methods.rs
@@ -1,9 +1,7 @@
-use clippy_utils::{
-    consts::{constant, Constant},
-    diagnostics::span_lint_and_then,
-    is_from_proc_macro, path_to_local,
-    source::snippet_opt,
-};
+use clippy_utils::consts::{constant, Constant};
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::source::snippet_opt;
+use clippy_utils::{is_from_proc_macro, path_to_local};
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass, Lint, LintContext};
diff --git a/clippy_lints/src/manual_is_ascii_check.rs b/clippy_lints/src/manual_is_ascii_check.rs
index 31264261f5d..f264424470d 100644
--- a/clippy_lints/src/manual_is_ascii_check.rs
+++ b/clippy_lints/src/manual_is_ascii_check.rs
@@ -1,12 +1,16 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::macros::root_macro_call;
 use clippy_utils::msrvs::{self, Msrv};
-use clippy_utils::{diagnostics::span_lint_and_sugg, higher, in_constant, macros::root_macro_call, sugg::Sugg};
+use clippy_utils::sugg::Sugg;
+use clippy_utils::{higher, in_constant};
 use rustc_ast::ast::RangeLimits;
 use rustc_ast::LitKind::{Byte, Char};
 use rustc_errors::Applicability;
 use rustc_hir::{BorrowKind, Expr, ExprKind, PatKind, RangeEnd};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::{def_id::DefId, sym, Span};
+use rustc_span::def_id::DefId;
+use rustc_span::{sym, Span};
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/manual_range_patterns.rs b/clippy_lints/src/manual_range_patterns.rs
index 64d4c8e4566..39d8b20d38d 100644
--- a/clippy_lints/src/manual_range_patterns.rs
+++ b/clippy_lints/src/manual_range_patterns.rs
@@ -2,13 +2,8 @@ use clippy_utils::diagnostics::span_lint_and_sugg;
 use rustc_ast::LitKind;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Applicability;
-use rustc_hir::Expr;
-use rustc_hir::ExprKind;
-use rustc_hir::PatKind;
-use rustc_hir::RangeEnd;
-use rustc_hir::UnOp;
-use rustc_lint::LintContext;
-use rustc_lint::{LateContext, LateLintPass};
+use rustc_hir::{Expr, ExprKind, PatKind, RangeEnd, UnOp};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
diff --git a/clippy_lints/src/manual_strip.rs b/clippy_lints/src/manual_strip.rs
index 93d977a5c96..2b9def1a688 100644
--- a/clippy_lints/src/manual_strip.rs
+++ b/clippy_lints/src/manual_strip.rs
@@ -8,8 +8,7 @@ use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
 use rustc_hir::def::Res;
 use rustc_hir::intravisit::{walk_expr, Visitor};
-use rustc_hir::BinOpKind;
-use rustc_hir::{BorrowKind, Expr, ExprKind};
+use rustc_hir::{BinOpKind, BorrowKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
diff --git a/clippy_lints/src/match_result_ok.rs b/clippy_lints/src/match_result_ok.rs
index 6ec9784038c..841c020f2d3 100644
--- a/clippy_lints/src/match_result_ok.rs
+++ b/clippy_lints/src/match_result_ok.rs
@@ -1,8 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::higher;
-use clippy_utils::is_res_lang_ctor;
 use clippy_utils::source::snippet_with_context;
 use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::{higher, is_res_lang_ctor};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, LangItem, PatKind};
diff --git a/clippy_lints/src/matches/manual_utils.rs b/clippy_lints/src/matches/manual_utils.rs
index 5b7644a5383..6b611f567ae 100644
--- a/clippy_lints/src/matches/manual_utils.rs
+++ b/clippy_lints/src/matches/manual_utils.rs
@@ -1,14 +1,17 @@
-use crate::{map_unit_fn::OPTION_MAP_UNIT_FN, matches::MATCH_AS_REF};
+use crate::map_unit_fn::OPTION_MAP_UNIT_FN;
+use crate::matches::MATCH_AS_REF;
 use clippy_utils::source::{snippet_with_applicability, snippet_with_context};
+use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::{is_copy, is_type_diagnostic_item, peel_mid_ty_refs_is_mutable, type_is_unsafe_function};
 use clippy_utils::{
     can_move_expr_to_closure, is_else_clause, is_lint_allowed, is_res_lang_ctor, path_res, path_to_local_id,
-    peel_blocks, peel_hir_expr_refs, peel_hir_expr_while, sugg::Sugg, CaptureKind,
+    peel_blocks, peel_hir_expr_refs, peel_hir_expr_while, CaptureKind,
 };
 use rustc_ast::util::parser::PREC_POSTFIX;
 use rustc_errors::Applicability;
+use rustc_hir::def::Res;
 use rustc_hir::LangItem::{OptionNone, OptionSome};
-use rustc_hir::{def::Res, BindingAnnotation, Expr, ExprKind, HirId, Mutability, Pat, PatKind, Path, QPath};
+use rustc_hir::{BindingAnnotation, Expr, ExprKind, HirId, Mutability, Pat, PatKind, Path, QPath};
 use rustc_lint::LateContext;
 use rustc_span::{sym, SyntaxContext};
 
diff --git a/clippy_lints/src/matches/match_like_matches.rs b/clippy_lints/src/matches/match_like_matches.rs
index 69f6c59beb3..e2ddf11abe2 100644
--- a/clippy_lints/src/matches/match_like_matches.rs
+++ b/clippy_lints/src/matches/match_like_matches.rs
@@ -1,9 +1,7 @@
 use super::REDUNDANT_PATTERN_MATCHING;
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::is_lint_allowed;
-use clippy_utils::is_wild;
 use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::span_contains_comment;
+use clippy_utils::{is_lint_allowed, is_wild, span_contains_comment};
 use rustc_ast::{Attribute, LitKind};
 use rustc_errors::Applicability;
 use rustc_hir::{Arm, BorrowKind, Expr, ExprKind, Guard, Pat, PatKind, QPath};
diff --git a/clippy_lints/src/matches/match_same_arms.rs b/clippy_lints/src/matches/match_same_arms.rs
index 3d2fbea63f5..0553b41328e 100644
--- a/clippy_lints/src/matches/match_same_arms.rs
+++ b/clippy_lints/src/matches/match_same_arms.rs
@@ -2,8 +2,7 @@ use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet;
 use clippy_utils::{is_lint_allowed, path_to_local, search_same, SpanlessEq, SpanlessHash};
 use core::cmp::Ordering;
-use core::iter;
-use core::slice;
+use core::{iter, slice};
 use rustc_arena::DroplessArena;
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/matches/redundant_pattern_match.rs b/clippy_lints/src/matches/redundant_pattern_match.rs
index 43d2ab9f60e..bddd57c9810 100644
--- a/clippy_lints/src/matches/redundant_pattern_match.rs
+++ b/clippy_lints/src/matches/redundant_pattern_match.rs
@@ -12,7 +12,8 @@ use rustc_hir::def::{DefKind, Res};
 use rustc_hir::LangItem::{self, OptionNone, OptionSome, PollPending, PollReady, ResultErr, ResultOk};
 use rustc_hir::{Arm, Expr, ExprKind, Node, Pat, PatKind, QPath, UnOp};
 use rustc_lint::LateContext;
-use rustc_middle::ty::{self, subst::GenericArgKind, Ty};
+use rustc_middle::ty::subst::GenericArgKind;
+use rustc_middle::ty::{self, Ty};
 use rustc_span::{sym, Symbol};
 
 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
diff --git a/clippy_lints/src/methods/bind_instead_of_map.rs b/clippy_lints/src/methods/bind_instead_of_map.rs
index 883a5505827..3a8cc41748e 100644
--- a/clippy_lints/src/methods/bind_instead_of_map.rs
+++ b/clippy_lints/src/methods/bind_instead_of_map.rs
@@ -1,7 +1,8 @@
 use super::{contains_return, BIND_INSTEAD_OF_MAP};
 use clippy_utils::diagnostics::{multispan_sugg_with_applicability, span_lint_and_sugg, span_lint_and_then};
+use clippy_utils::peel_blocks;
 use clippy_utils::source::{snippet, snippet_with_context};
-use clippy_utils::{peel_blocks, visitors::find_all_ret_expressions};
+use clippy_utils::visitors::find_all_ret_expressions;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
diff --git a/clippy_lints/src/methods/case_sensitive_file_extension_comparisons.rs b/clippy_lints/src/methods/case_sensitive_file_extension_comparisons.rs
index 7711aa78b23..41b5cc12d6d 100644
--- a/clippy_lints/src/methods/case_sensitive_file_extension_comparisons.rs
+++ b/clippy_lints/src/methods/case_sensitive_file_extension_comparisons.rs
@@ -1,13 +1,13 @@
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::source::snippet_opt;
-use clippy_utils::source::{indent_of, reindent_multiline};
+use clippy_utils::source::{indent_of, reindent_multiline, snippet_opt};
 use clippy_utils::ty::is_type_lang_item;
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, LangItem};
 use rustc_lint::LateContext;
-use rustc_span::{source_map::Spanned, Span};
+use rustc_span::source_map::Spanned;
+use rustc_span::Span;
 
 use super::CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS;
 
diff --git a/clippy_lints/src/methods/chars_cmp.rs b/clippy_lints/src/methods/chars_cmp.rs
index 079df2226d1..0e41f3c2107 100644
--- a/clippy_lints/src/methods/chars_cmp.rs
+++ b/clippy_lints/src/methods/chars_cmp.rs
@@ -4,8 +4,7 @@ use clippy_utils::{method_chain_args, path_def_id};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
-use rustc_lint::LateContext;
-use rustc_lint::Lint;
+use rustc_lint::{LateContext, Lint};
 use rustc_middle::ty;
 
 /// Wrapper fn for `CHARS_NEXT_CMP` and `CHARS_LAST_CMP` lints.
diff --git a/clippy_lints/src/methods/chars_cmp_with_unwrap.rs b/clippy_lints/src/methods/chars_cmp_with_unwrap.rs
index 8984b2cf8fd..c9d50a5b03d 100644
--- a/clippy_lints/src/methods/chars_cmp_with_unwrap.rs
+++ b/clippy_lints/src/methods/chars_cmp_with_unwrap.rs
@@ -5,8 +5,7 @@ use if_chain::if_chain;
 use rustc_ast::ast;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
-use rustc_lint::LateContext;
-use rustc_lint::Lint;
+use rustc_lint::{LateContext, Lint};
 
 /// Wrapper fn for `CHARS_NEXT_CMP` and `CHARS_LAST_CMP` lints with `unwrap()`.
 pub(super) fn check(
diff --git a/clippy_lints/src/methods/clone_on_copy.rs b/clippy_lints/src/methods/clone_on_copy.rs
index 65fd50dff58..7eb325ee7b5 100644
--- a/clippy_lints/src/methods/clone_on_copy.rs
+++ b/clippy_lints/src/methods/clone_on_copy.rs
@@ -5,7 +5,9 @@ use clippy_utils::ty::is_copy;
 use rustc_errors::Applicability;
 use rustc_hir::{BindingAnnotation, ByRef, Expr, ExprKind, MatchSource, Node, PatKind, QPath};
 use rustc_lint::LateContext;
-use rustc_middle::ty::{self, adjustment::Adjust, print::with_forced_trimmed_paths};
+use rustc_middle::ty::adjustment::Adjust;
+use rustc_middle::ty::print::with_forced_trimmed_paths;
+use rustc_middle::ty::{self};
 use rustc_span::symbol::{sym, Symbol};
 
 use super::CLONE_ON_COPY;
diff --git a/clippy_lints/src/methods/collapsible_str_replace.rs b/clippy_lints/src/methods/collapsible_str_replace.rs
index 5e01ed90ff0..5409ede6008 100644
--- a/clippy_lints/src/methods/collapsible_str_replace.rs
+++ b/clippy_lints/src/methods/collapsible_str_replace.rs
@@ -8,8 +8,7 @@ use rustc_hir as hir;
 use rustc_lint::LateContext;
 use std::collections::VecDeque;
 
-use super::method_call;
-use super::COLLAPSIBLE_STR_REPLACE;
+use super::{method_call, COLLAPSIBLE_STR_REPLACE};
 
 pub(super) fn check<'tcx>(
     cx: &LateContext<'tcx>,
diff --git a/clippy_lints/src/methods/drain_collect.rs b/clippy_lints/src/methods/drain_collect.rs
index d0c79dc11b0..6a82d8f756a 100644
--- a/clippy_lints/src/methods/drain_collect.rs
+++ b/clippy_lints/src/methods/drain_collect.rs
@@ -4,17 +4,12 @@ use clippy_utils::is_range_full;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::is_type_lang_item;
 use rustc_errors::Applicability;
-use rustc_hir::Expr;
-use rustc_hir::ExprKind;
-use rustc_hir::LangItem;
-use rustc_hir::Path;
-use rustc_hir::QPath;
+use rustc_hir::{Expr, ExprKind, LangItem, Path, QPath};
 use rustc_lint::LateContext;
 use rustc_middle::query::Key;
 use rustc_middle::ty;
 use rustc_middle::ty::Ty;
-use rustc_span::sym;
-use rustc_span::Symbol;
+use rustc_span::{sym, Symbol};
 
 /// Checks if both types match the given diagnostic item, e.g.:
 ///
diff --git a/clippy_lints/src/methods/err_expect.rs b/clippy_lints/src/methods/err_expect.rs
index ae03da0d3f9..98f470dff8a 100644
--- a/clippy_lints/src/methods/err_expect.rs
+++ b/clippy_lints/src/methods/err_expect.rs
@@ -1,8 +1,7 @@
 use super::ERR_EXPECT;
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::msrvs::{self, Msrv};
-use clippy_utils::ty::has_debug_impl;
-use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::ty::{has_debug_impl, is_type_diagnostic_item};
 use rustc_errors::Applicability;
 use rustc_lint::LateContext;
 use rustc_middle::ty;
diff --git a/clippy_lints/src/methods/filter_map.rs b/clippy_lints/src/methods/filter_map.rs
index fc80f2eeae0..597a423b537 100644
--- a/clippy_lints/src/methods/filter_map.rs
+++ b/clippy_lints/src/methods/filter_map.rs
@@ -13,9 +13,7 @@ use rustc_span::source_map::Span;
 use rustc_span::symbol::{sym, Symbol};
 use std::borrow::Cow;
 
-use super::MANUAL_FILTER_MAP;
-use super::MANUAL_FIND_MAP;
-use super::OPTION_FILTER_MAP;
+use super::{MANUAL_FILTER_MAP, MANUAL_FIND_MAP, OPTION_FILTER_MAP};
 
 fn is_method(cx: &LateContext<'_>, expr: &hir::Expr<'_>, method_name: Symbol) -> bool {
     match &expr.kind {
diff --git a/clippy_lints/src/methods/filter_map_identity.rs b/clippy_lints/src/methods/filter_map_identity.rs
index d1b5e945dfd..3337b250c0e 100644
--- a/clippy_lints/src/methods/filter_map_identity.rs
+++ b/clippy_lints/src/methods/filter_map_identity.rs
@@ -3,7 +3,8 @@ use clippy_utils::{is_expr_identity_function, is_trait_method};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
-use rustc_span::{source_map::Span, sym};
+use rustc_span::source_map::Span;
+use rustc_span::sym;
 
 use super::FILTER_MAP_IDENTITY;
 
diff --git a/clippy_lints/src/methods/flat_map_identity.rs b/clippy_lints/src/methods/flat_map_identity.rs
index 6f911d79d0b..84a21de0ac8 100644
--- a/clippy_lints/src/methods/flat_map_identity.rs
+++ b/clippy_lints/src/methods/flat_map_identity.rs
@@ -3,7 +3,8 @@ use clippy_utils::{is_expr_identity_function, is_trait_method};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
-use rustc_span::{source_map::Span, sym};
+use rustc_span::source_map::Span;
+use rustc_span::sym;
 
 use super::FLAT_MAP_IDENTITY;
 
diff --git a/clippy_lints/src/methods/flat_map_option.rs b/clippy_lints/src/methods/flat_map_option.rs
index 615bde94133..367a8ae82bd 100644
--- a/clippy_lints/src/methods/flat_map_option.rs
+++ b/clippy_lints/src/methods/flat_map_option.rs
@@ -4,7 +4,8 @@ use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
 use rustc_middle::ty;
-use rustc_span::{source_map::Span, sym};
+use rustc_span::source_map::Span;
+use rustc_span::sym;
 
 use super::FLAT_MAP_OPTION;
 use clippy_utils::ty::is_type_diagnostic_item;
diff --git a/clippy_lints/src/methods/inspect_for_each.rs b/clippy_lints/src/methods/inspect_for_each.rs
index 7fd3ef1a622..23cc192c38e 100644
--- a/clippy_lints/src/methods/inspect_for_each.rs
+++ b/clippy_lints/src/methods/inspect_for_each.rs
@@ -2,7 +2,8 @@ use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::is_trait_method;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
-use rustc_span::{source_map::Span, sym};
+use rustc_span::source_map::Span;
+use rustc_span::sym;
 
 use super::INSPECT_FOR_EACH;
 
diff --git a/clippy_lints/src/methods/is_digit_ascii_radix.rs b/clippy_lints/src/methods/is_digit_ascii_radix.rs
index 301aff5ae6a..120f3d5f42c 100644
--- a/clippy_lints/src/methods/is_digit_ascii_radix.rs
+++ b/clippy_lints/src/methods/is_digit_ascii_radix.rs
@@ -1,10 +1,10 @@
 //! Lint for `c.is_digit(10)`
 
 use super::IS_DIGIT_ASCII_RADIX;
+use clippy_utils::consts::{constant_full_int, FullInt};
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::msrvs::{self, Msrv};
-use clippy_utils::{
-    consts::constant_full_int, consts::FullInt, diagnostics::span_lint_and_sugg, source::snippet_with_applicability,
-};
+use clippy_utils::source::snippet_with_applicability;
 use rustc_errors::Applicability;
 use rustc_hir::Expr;
 use rustc_lint::LateContext;
diff --git a/clippy_lints/src/methods/iter_kv_map.rs b/clippy_lints/src/methods/iter_kv_map.rs
index c87f5daab6f..674d3451748 100644
--- a/clippy_lints/src/methods/iter_kv_map.rs
+++ b/clippy_lints/src/methods/iter_kv_map.rs
@@ -9,8 +9,7 @@ use clippy_utils::visitors::is_local_used;
 use rustc_hir::{BindingAnnotation, Body, BorrowKind, ByRef, Expr, ExprKind, Mutability, Pat, PatKind};
 use rustc_lint::{LateContext, LintContext};
 use rustc_middle::ty;
-use rustc_span::sym;
-use rustc_span::Span;
+use rustc_span::{sym, Span};
 
 /// lint use of:
 /// - `hashmap.iter().map(|(_, v)| v)`
diff --git a/clippy_lints/src/methods/iter_skip_next.rs b/clippy_lints/src/methods/iter_skip_next.rs
index 279175e20c3..39af52141bb 100644
--- a/clippy_lints/src/methods/iter_skip_next.rs
+++ b/clippy_lints/src/methods/iter_skip_next.rs
@@ -1,7 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::is_trait_method;
-use clippy_utils::path_to_local;
 use clippy_utils::source::snippet;
+use clippy_utils::{is_trait_method, path_to_local};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_hir::{BindingAnnotation, Node, PatKind};
diff --git a/clippy_lints/src/methods/manual_saturating_arithmetic.rs b/clippy_lints/src/methods/manual_saturating_arithmetic.rs
index a7284c64497..7e62e7ad909 100644
--- a/clippy_lints/src/methods/manual_saturating_arithmetic.rs
+++ b/clippy_lints/src/methods/manual_saturating_arithmetic.rs
@@ -24,10 +24,8 @@ pub fn check(
     let Some(mm) = is_min_or_max(cx, unwrap_arg) else { return };
 
     if ty.is_signed() {
-        use self::{
-            MinMax::{Max, Min},
-            Sign::{Neg, Pos},
-        };
+        use self::MinMax::{Max, Min};
+        use self::Sign::{Neg, Pos};
 
         let Some(sign) = lit_sign(arith_rhs) else {
             return;
diff --git a/clippy_lints/src/methods/manual_try_fold.rs b/clippy_lints/src/methods/manual_try_fold.rs
index 576a58499b1..dabed0affcf 100644
--- a/clippy_lints/src/methods/manual_try_fold.rs
+++ b/clippy_lints/src/methods/manual_try_fold.rs
@@ -1,15 +1,11 @@
-use clippy_utils::{
-    diagnostics::span_lint_and_sugg,
-    is_from_proc_macro,
-    msrvs::{Msrv, ITERATOR_TRY_FOLD},
-    source::snippet_opt,
-    ty::implements_trait,
-};
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::is_from_proc_macro;
+use clippy_utils::msrvs::{Msrv, ITERATOR_TRY_FOLD};
+use clippy_utils::source::snippet_opt;
+use clippy_utils::ty::implements_trait;
 use rustc_errors::Applicability;
-use rustc_hir::{
-    def::{DefKind, Res},
-    Expr, ExprKind,
-};
+use rustc_hir::def::{DefKind, Res};
+use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_span::Span;
diff --git a/clippy_lints/src/methods/map_flatten.rs b/clippy_lints/src/methods/map_flatten.rs
index 361ffcb5ef3..349caa6ea6c 100644
--- a/clippy_lints/src/methods/map_flatten.rs
+++ b/clippy_lints/src/methods/map_flatten.rs
@@ -6,7 +6,8 @@ use rustc_errors::Applicability;
 use rustc_hir::Expr;
 use rustc_lint::LateContext;
 use rustc_middle::ty;
-use rustc_span::{symbol::sym, Span};
+use rustc_span::symbol::sym;
+use rustc_span::Span;
 
 use super::MAP_FLATTEN;
 
diff --git a/clippy_lints/src/methods/map_identity.rs b/clippy_lints/src/methods/map_identity.rs
index 0f25ef82ed4..7be1ce483f6 100644
--- a/clippy_lints/src/methods/map_identity.rs
+++ b/clippy_lints/src/methods/map_identity.rs
@@ -4,7 +4,8 @@ use clippy_utils::{is_expr_identity_function, is_trait_method};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
-use rustc_span::{source_map::Span, sym};
+use rustc_span::source_map::Span;
+use rustc_span::sym;
 
 use super::MAP_IDENTITY;
 
diff --git a/clippy_lints/src/methods/mut_mutex_lock.rs b/clippy_lints/src/methods/mut_mutex_lock.rs
index d0aa39d0627..161a7aa7fd4 100644
--- a/clippy_lints/src/methods/mut_mutex_lock.rs
+++ b/clippy_lints/src/methods/mut_mutex_lock.rs
@@ -1,5 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::{expr_custom_deref_adjustment, ty::is_type_diagnostic_item};
+use clippy_utils::expr_custom_deref_adjustment;
+use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, Mutability};
diff --git a/clippy_lints/src/methods/needless_collect.rs b/clippy_lints/src/methods/needless_collect.rs
index ac209d01406..60fd64ec97f 100644
--- a/clippy_lints/src/methods/needless_collect.rs
+++ b/clippy_lints/src/methods/needless_collect.rs
@@ -4,10 +4,9 @@ use clippy_utils::source::{snippet, snippet_with_applicability};
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::{is_type_diagnostic_item, make_normalized_projection, make_projection};
 use clippy_utils::{
-    can_move_expr_to_closure, get_enclosing_block, get_parent_node, is_trait_method, path_to_local, path_to_local_id,
-    CaptureKind,
+    can_move_expr_to_closure, fn_def_id, get_enclosing_block, get_parent_node, higher, is_trait_method, path_to_local,
+    path_to_local_id, CaptureKind,
 };
-use clippy_utils::{fn_def_id, higher};
 use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::{Applicability, MultiSpan};
 use rustc_hir::intravisit::{walk_block, walk_expr, Visitor};
diff --git a/clippy_lints/src/methods/obfuscated_if_else.rs b/clippy_lints/src/methods/obfuscated_if_else.rs
index eada530d670..697eab32a33 100644
--- a/clippy_lints/src/methods/obfuscated_if_else.rs
+++ b/clippy_lints/src/methods/obfuscated_if_else.rs
@@ -1,5 +1,6 @@
 use super::OBFUSCATED_IF_ELSE;
-use clippy_utils::{diagnostics::span_lint_and_sugg, source::snippet_with_applicability};
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet_with_applicability;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
diff --git a/clippy_lints/src/methods/option_map_or_none.rs b/clippy_lints/src/methods/option_map_or_none.rs
index 41ceef19e3a..cb6a2306857 100644
--- a/clippy_lints/src/methods/option_map_or_none.rs
+++ b/clippy_lints/src/methods/option_map_or_none.rs
@@ -8,8 +8,7 @@ use rustc_hir::LangItem::{OptionNone, OptionSome};
 use rustc_lint::LateContext;
 use rustc_span::symbol::sym;
 
-use super::OPTION_MAP_OR_NONE;
-use super::RESULT_MAP_OR_INTO_OPTION;
+use super::{OPTION_MAP_OR_NONE, RESULT_MAP_OR_INTO_OPTION};
 
 // The expression inside a closure may or may not have surrounding braces
 // which causes problems when generating a suggestion.
diff --git a/clippy_lints/src/methods/option_map_unwrap_or.rs b/clippy_lints/src/methods/option_map_unwrap_or.rs
index f4f158c0439..fcbe005fb28 100644
--- a/clippy_lints/src/methods/option_map_unwrap_or.rs
+++ b/clippy_lints/src/methods/option_map_unwrap_or.rs
@@ -1,17 +1,12 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::ty::is_copy;
-use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::ty::{is_copy, is_type_diagnostic_item};
 use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Applicability;
 use rustc_hir::def::Res;
 use rustc_hir::intravisit::{walk_path, Visitor};
-use rustc_hir::ExprKind;
-use rustc_hir::Node;
-use rustc_hir::PatKind;
-use rustc_hir::QPath;
-use rustc_hir::{self, HirId, Path};
+use rustc_hir::{self, ExprKind, HirId, Node, PatKind, Path, QPath};
 use rustc_lint::LateContext;
 use rustc_middle::hir::nested_filter;
 use rustc_span::source_map::Span;
diff --git a/clippy_lints/src/methods/or_then_unwrap.rs b/clippy_lints/src/methods/or_then_unwrap.rs
index d65082173b3..7b0bdcf99e7 100644
--- a/clippy_lints/src/methods/or_then_unwrap.rs
+++ b/clippy_lints/src/methods/or_then_unwrap.rs
@@ -1,8 +1,10 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{diagnostics::span_lint_and_sugg, is_res_lang_ctor, path_res};
+use clippy_utils::{is_res_lang_ctor, path_res};
 use rustc_errors::Applicability;
-use rustc_hir::{lang_items::LangItem, Expr, ExprKind};
+use rustc_hir::lang_items::LangItem;
+use rustc_hir::{Expr, ExprKind};
 use rustc_lint::LateContext;
 use rustc_span::{sym, Span};
 
diff --git a/clippy_lints/src/methods/range_zip_with_len.rs b/clippy_lints/src/methods/range_zip_with_len.rs
index 867a3b40237..f253d8de91f 100644
--- a/clippy_lints/src/methods/range_zip_with_len.rs
+++ b/clippy_lints/src/methods/range_zip_with_len.rs
@@ -1,7 +1,6 @@
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::source::snippet;
-use clippy_utils::{higher, SpanlessEq};
-use clippy_utils::{is_integer_const, is_trait_method};
+use clippy_utils::{higher, is_integer_const, is_trait_method, SpanlessEq};
 use if_chain::if_chain;
 use rustc_hir::{Expr, ExprKind, QPath};
 use rustc_lint::LateContext;
diff --git a/clippy_lints/src/methods/read_line_without_trim.rs b/clippy_lints/src/methods/read_line_without_trim.rs
index 49e4f1acaa6..8add0656101 100644
--- a/clippy_lints/src/methods/read_line_without_trim.rs
+++ b/clippy_lints/src/methods/read_line_without_trim.rs
@@ -1,13 +1,13 @@
 use std::ops::ControlFlow;
 
-use clippy_utils::{
-    diagnostics::span_lint_and_then, get_parent_expr, match_def_path, source::snippet, ty::is_type_diagnostic_item,
-    visitors::for_each_local_use_after_expr,
-};
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::source::snippet;
+use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::visitors::for_each_local_use_after_expr;
+use clippy_utils::{get_parent_expr, match_def_path};
 use rustc_errors::Applicability;
-use rustc_hir::Expr;
-use rustc_hir::QPath;
-use rustc_hir::{def::Res, ExprKind};
+use rustc_hir::def::Res;
+use rustc_hir::{Expr, ExprKind, QPath};
 use rustc_lint::LateContext;
 use rustc_middle::ty::{self, Ty};
 use rustc_span::sym;
diff --git a/clippy_lints/src/methods/seek_from_current.rs b/clippy_lints/src/methods/seek_from_current.rs
index c028e954381..f3d6a15ede0 100644
--- a/clippy_lints/src/methods/seek_from_current.rs
+++ b/clippy_lints/src/methods/seek_from_current.rs
@@ -3,10 +3,10 @@ use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::LateContext;
 
-use clippy_utils::{
-    diagnostics::span_lint_and_sugg, get_trait_def_id, match_def_path, paths, source::snippet_with_applicability,
-    ty::implements_trait,
-};
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::ty::implements_trait;
+use clippy_utils::{get_trait_def_id, match_def_path, paths};
 
 use super::SEEK_FROM_CURRENT;
 
diff --git a/clippy_lints/src/methods/suspicious_command_arg_space.rs b/clippy_lints/src/methods/suspicious_command_arg_space.rs
index 73632c5a357..bc8f0176764 100644
--- a/clippy_lints/src/methods/suspicious_command_arg_space.rs
+++ b/clippy_lints/src/methods/suspicious_command_arg_space.rs
@@ -1,11 +1,10 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::paths;
 use clippy_utils::ty::match_type;
-use rustc_ast as ast;
 use rustc_errors::{Applicability, Diagnostic};
-use rustc_hir as hir;
 use rustc_lint::LateContext;
 use rustc_span::Span;
+use {rustc_ast as ast, rustc_hir as hir};
 
 use super::SUSPICIOUS_COMMAND_ARG_SPACE;
 
diff --git a/clippy_lints/src/methods/suspicious_to_owned.rs b/clippy_lints/src/methods/suspicious_to_owned.rs
index e818f1892e5..9eb8d6e6e78 100644
--- a/clippy_lints/src/methods/suspicious_to_owned.rs
+++ b/clippy_lints/src/methods/suspicious_to_owned.rs
@@ -5,7 +5,8 @@ use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
-use rustc_middle::ty::{self, print::with_forced_trimmed_paths};
+use rustc_middle::ty::print::with_forced_trimmed_paths;
+use rustc_middle::ty::{self};
 use rustc_span::sym;
 
 use super::SUSPICIOUS_TO_OWNED;
diff --git a/clippy_lints/src/methods/type_id_on_box.rs b/clippy_lints/src/methods/type_id_on_box.rs
index 88adba504aa..35137c97101 100644
--- a/clippy_lints/src/methods/type_id_on_box.rs
+++ b/clippy_lints/src/methods/type_id_on_box.rs
@@ -4,10 +4,8 @@ use clippy_utils::source::snippet;
 use rustc_errors::Applicability;
 use rustc_hir::Expr;
 use rustc_lint::LateContext;
-use rustc_middle::ty::adjustment::Adjust;
-use rustc_middle::ty::adjustment::Adjustment;
-use rustc_middle::ty::Ty;
-use rustc_middle::ty::{self, ExistentialPredicate};
+use rustc_middle::ty::adjustment::{Adjust, Adjustment};
+use rustc_middle::ty::{self, ExistentialPredicate, Ty};
 use rustc_span::{sym, Span};
 
 fn is_dyn_any(cx: &LateContext<'_>, ty: Ty<'_>) -> bool {
diff --git a/clippy_lints/src/methods/uninit_assumed_init.rs b/clippy_lints/src/methods/uninit_assumed_init.rs
index a1c6294737c..bc9c518dbcf 100644
--- a/clippy_lints/src/methods/uninit_assumed_init.rs
+++ b/clippy_lints/src/methods/uninit_assumed_init.rs
@@ -1,5 +1,6 @@
 use clippy_utils::diagnostics::span_lint;
-use clippy_utils::{is_path_diagnostic_item, ty::is_uninit_value_valid_for_ty};
+use clippy_utils::is_path_diagnostic_item;
+use clippy_utils::ty::is_uninit_value_valid_for_ty;
 use if_chain::if_chain;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
diff --git a/clippy_lints/src/methods/unnecessary_filter_map.rs b/clippy_lints/src/methods/unnecessary_filter_map.rs
index 1cef6226ad4..cc64a2e7948 100644
--- a/clippy_lints/src/methods/unnecessary_filter_map.rs
+++ b/clippy_lints/src/methods/unnecessary_filter_map.rs
@@ -11,8 +11,7 @@ use rustc_lint::LateContext;
 use rustc_middle::ty;
 use rustc_span::sym;
 
-use super::UNNECESSARY_FILTER_MAP;
-use super::UNNECESSARY_FIND_MAP;
+use super::{UNNECESSARY_FILTER_MAP, UNNECESSARY_FIND_MAP};
 
 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'tcx>, arg: &'tcx hir::Expr<'tcx>, name: &str) {
     if !is_trait_method(cx, expr, sym::Iterator) {
diff --git a/clippy_lints/src/methods/unnecessary_fold.rs b/clippy_lints/src/methods/unnecessary_fold.rs
index 8ec15a1c1b7..6e23754bf46 100644
--- a/clippy_lints/src/methods/unnecessary_fold.rs
+++ b/clippy_lints/src/methods/unnecessary_fold.rs
@@ -8,7 +8,8 @@ use rustc_hir as hir;
 use rustc_hir::PatKind;
 use rustc_lint::LateContext;
 use rustc_middle::ty;
-use rustc_span::{source_map::Span, sym};
+use rustc_span::source_map::Span;
+use rustc_span::sym;
 
 use super::UNNECESSARY_FOLD;
 
diff --git a/clippy_lints/src/methods/unnecessary_iter_cloned.rs b/clippy_lints/src/methods/unnecessary_iter_cloned.rs
index 52a4ff7d1ae..0c72c13a3ca 100644
--- a/clippy_lints/src/methods/unnecessary_iter_cloned.rs
+++ b/clippy_lints/src/methods/unnecessary_iter_cloned.rs
@@ -5,7 +5,8 @@ use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::{get_iterator_item_ty, implements_trait};
 use clippy_utils::{fn_def_id, get_parent_expr};
 use rustc_errors::Applicability;
-use rustc_hir::{def_id::DefId, Expr, ExprKind};
+use rustc_hir::def_id::DefId;
+use rustc_hir::{Expr, ExprKind};
 use rustc_lint::LateContext;
 use rustc_span::{sym, Symbol};
 
diff --git a/clippy_lints/src/methods/unnecessary_join.rs b/clippy_lints/src/methods/unnecessary_join.rs
index 087e1e4343b..d0c62fb56dc 100644
--- a/clippy_lints/src/methods/unnecessary_join.rs
+++ b/clippy_lints/src/methods/unnecessary_join.rs
@@ -1,4 +1,5 @@
-use clippy_utils::{diagnostics::span_lint_and_sugg, ty::is_type_lang_item};
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::ty::is_type_lang_item;
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, LangItem};
diff --git a/clippy_lints/src/methods/unnecessary_literal_unwrap.rs b/clippy_lints/src/methods/unnecessary_literal_unwrap.rs
index 54de300e6bc..111bcaaecec 100644
--- a/clippy_lints/src/methods/unnecessary_literal_unwrap.rs
+++ b/clippy_lints/src/methods/unnecessary_literal_unwrap.rs
@@ -1,4 +1,5 @@
-use clippy_utils::{diagnostics::span_lint_and_then, is_res_lang_ctor, last_path_segment, path_res, MaybePath};
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::{is_res_lang_ctor, last_path_segment, path_res, MaybePath};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
diff --git a/clippy_lints/src/methods/unnecessary_sort_by.rs b/clippy_lints/src/methods/unnecessary_sort_by.rs
index 67618f7038a..54b76bd04fe 100644
--- a/clippy_lints/src/methods/unnecessary_sort_by.rs
+++ b/clippy_lints/src/methods/unnecessary_sort_by.rs
@@ -6,7 +6,8 @@ use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Closure, Expr, ExprKind, Mutability, Param, Pat, PatKind, Path, PathSegment, QPath};
 use rustc_lint::LateContext;
-use rustc_middle::ty::{self, subst::GenericArgKind};
+use rustc_middle::ty::subst::GenericArgKind;
+use rustc_middle::ty::{self};
 use rustc_span::sym;
 use rustc_span::symbol::Ident;
 use std::iter;
diff --git a/clippy_lints/src/methods/unnecessary_to_owned.rs b/clippy_lints/src/methods/unnecessary_to_owned.rs
index 16ef24bd4e3..dcfec52fd71 100644
--- a/clippy_lints/src/methods/unnecessary_to_owned.rs
+++ b/clippy_lints/src/methods/unnecessary_to_owned.rs
@@ -7,7 +7,8 @@ use clippy_utils::ty::{get_iterator_item_ty, implements_trait, is_copy, peel_mid
 use clippy_utils::visitors::find_all_ret_expressions;
 use clippy_utils::{fn_def_id, get_parent_expr, is_diag_item_method, is_diag_trait_item, return_ty};
 use rustc_errors::Applicability;
-use rustc_hir::{def_id::DefId, BorrowKind, Expr, ExprKind, ItemKind, Node};
+use rustc_hir::def_id::DefId;
+use rustc_hir::{BorrowKind, Expr, ExprKind, ItemKind, Node};
 use rustc_hir_typeck::{FnCtxt, Inherited};
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::LateContext;
@@ -16,7 +17,8 @@ use rustc_middle::ty::adjustment::{Adjust, Adjustment, OverloadedDeref};
 use rustc_middle::ty::subst::{GenericArg, GenericArgKind, SubstsRef};
 use rustc_middle::ty::{self, ClauseKind, EarlyBinder, ParamTy, ProjectionPredicate, TraitPredicate, Ty};
 use rustc_span::{sym, Symbol};
-use rustc_trait_selection::traits::{query::evaluate_obligation::InferCtxtExt as _, Obligation, ObligationCause};
+use rustc_trait_selection::traits::query::evaluate_obligation::InferCtxtExt as _;
+use rustc_trait_selection::traits::{Obligation, ObligationCause};
 
 use super::UNNECESSARY_TO_OWNED;
 
diff --git a/clippy_lints/src/methods/unwrap_or_else_default.rs b/clippy_lints/src/methods/unwrap_or_else_default.rs
index 045f739e64d..474a33b67e1 100644
--- a/clippy_lints/src/methods/unwrap_or_else_default.rs
+++ b/clippy_lints/src/methods/unwrap_or_else_default.rs
@@ -1,10 +1,10 @@
 //! Lint for `some_result_or_option.unwrap_or_else(Default::default)`
 
 use super::UNWRAP_OR_ELSE_DEFAULT;
-use clippy_utils::{
-    diagnostics::span_lint_and_sugg, is_default_equivalent_call, source::snippet_with_applicability,
-    ty::is_type_diagnostic_item,
-};
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::is_default_equivalent_call;
+use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
diff --git a/clippy_lints/src/min_ident_chars.rs b/clippy_lints/src/min_ident_chars.rs
index 23593e0d4d9..2a60f2faca0 100644
--- a/clippy_lints/src/min_ident_chars.rs
+++ b/clippy_lints/src/min_ident_chars.rs
@@ -1,10 +1,9 @@
-use clippy_utils::{diagnostics::span_lint, is_from_proc_macro};
+use clippy_utils::diagnostics::span_lint;
+use clippy_utils::is_from_proc_macro;
 use rustc_data_structures::fx::FxHashSet;
-use rustc_hir::{
-    def::{DefKind, Res},
-    intravisit::{walk_item, Visitor},
-    GenericParamKind, HirId, Item, ItemKind, ItemLocalId, Node, Pat, PatKind,
-};
+use rustc_hir::def::{DefKind, Res};
+use rustc_hir::intravisit::{walk_item, Visitor};
+use rustc_hir::{GenericParamKind, HirId, Item, ItemKind, ItemLocalId, Node, Pat, PatKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
diff --git a/clippy_lints/src/missing_enforced_import_rename.rs b/clippy_lints/src/missing_enforced_import_rename.rs
index 773174679db..96d83e114a4 100644
--- a/clippy_lints/src/missing_enforced_import_rename.rs
+++ b/clippy_lints/src/missing_enforced_import_rename.rs
@@ -1,8 +1,11 @@
-use clippy_utils::{diagnostics::span_lint_and_sugg, source::snippet_opt};
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet_opt;
 
 use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::Applicability;
-use rustc_hir::{def::Res, def_id::DefId, Item, ItemKind, UseKind};
+use rustc_hir::def::Res;
+use rustc_hir::def_id::DefId;
+use rustc_hir::{Item, ItemKind, UseKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::Symbol;
diff --git a/clippy_lints/src/missing_fields_in_debug.rs b/clippy_lints/src/missing_fields_in_debug.rs
index 497514fbcd6..2f63b9b9f0b 100644
--- a/clippy_lints/src/missing_fields_in_debug.rs
+++ b/clippy_lints/src/missing_fields_in_debug.rs
@@ -1,23 +1,17 @@
 use std::ops::ControlFlow;
 
-use clippy_utils::{
-    diagnostics::span_lint_and_then,
-    is_path_lang_item, paths,
-    ty::match_type,
-    visitors::{for_each_expr, Visitable},
-};
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::ty::match_type;
+use clippy_utils::visitors::{for_each_expr, Visitable};
+use clippy_utils::{is_path_lang_item, paths};
 use rustc_ast::LitKind;
 use rustc_data_structures::fx::FxHashSet;
-use rustc_hir::Block;
+use rustc_hir::def::{DefKind, Res};
 use rustc_hir::{
-    def::{DefKind, Res},
-    Expr, ImplItemKind, LangItem, Node,
+    Block, Expr, ExprKind, Impl, ImplItem, ImplItemKind, Item, ItemKind, LangItem, Node, QPath, TyKind, VariantData,
 };
-use rustc_hir::{ExprKind, Impl, ItemKind, QPath, TyKind};
-use rustc_hir::{ImplItem, Item, VariantData};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty::Ty;
-use rustc_middle::ty::TypeckResults;
+use rustc_middle::ty::{Ty, TypeckResults};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::{sym, Span, Symbol};
 
diff --git a/clippy_lints/src/multiple_unsafe_ops_per_block.rs b/clippy_lints/src/multiple_unsafe_ops_per_block.rs
index e6fd65f001a..fe35126aab2 100644
--- a/clippy_lints/src/multiple_unsafe_ops_per_block.rs
+++ b/clippy_lints/src/multiple_unsafe_ops_per_block.rs
@@ -1,12 +1,8 @@
-use clippy_utils::{
-    diagnostics::span_lint_and_then,
-    visitors::{for_each_expr_with_closures, Descend, Visitable},
-};
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::visitors::{for_each_expr_with_closures, Descend, Visitable};
 use core::ops::ControlFlow::Continue;
-use hir::{
-    def::{DefKind, Res},
-    BlockCheckMode, ExprKind, QPath, UnOp, Unsafety,
-};
+use hir::def::{DefKind, Res};
+use hir::{BlockCheckMode, ExprKind, QPath, UnOp, Unsafety};
 use rustc_ast::Mutability;
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/needless_bool.rs b/clippy_lints/src/needless_bool.rs
index 34b74e180cb..46457400abc 100644
--- a/clippy_lints/src/needless_bool.rs
+++ b/clippy_lints/src/needless_bool.rs
@@ -6,9 +6,9 @@ use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg};
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::sugg::Sugg;
 use clippy_utils::{
-    get_parent_node, is_else_clause, is_expn_of, peel_blocks, peel_blocks_with_stmt, span_extract_comment,
+    get_parent_node, higher, is_else_clause, is_expn_of, peel_blocks, peel_blocks_with_stmt, span_extract_comment,
+    SpanlessEq,
 };
-use clippy_utils::{higher, SpanlessEq};
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Block, Expr, ExprKind, HirId, Node, UnOp};
diff --git a/clippy_lints/src/needless_else.rs b/clippy_lints/src/needless_else.rs
index 23d4a7b9586..03bab86c6d7 100644
--- a/clippy_lints/src/needless_else.rs
+++ b/clippy_lints/src/needless_else.rs
@@ -1,5 +1,5 @@
-use clippy_utils::source::snippet_opt;
-use clippy_utils::{diagnostics::span_lint_and_sugg, source::trim_span};
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::{snippet_opt, trim_span};
 use rustc_ast::ast::{Expr, ExprKind};
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
diff --git a/clippy_lints/src/needless_for_each.rs b/clippy_lints/src/needless_for_each.rs
index c3b633fd6a0..463e188fc8e 100644
--- a/clippy_lints/src/needless_for_each.rs
+++ b/clippy_lints/src/needless_for_each.rs
@@ -1,11 +1,10 @@
 use rustc_errors::Applicability;
-use rustc_hir::{
-    intravisit::{walk_expr, Visitor},
-    Closure, Expr, ExprKind, Stmt, StmtKind,
-};
+use rustc_hir::intravisit::{walk_expr, Visitor};
+use rustc_hir::{Closure, Expr, ExprKind, Stmt, StmtKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::{source_map::Span, sym, Symbol};
+use rustc_span::source_map::Span;
+use rustc_span::{sym, Symbol};
 
 use if_chain::if_chain;
 
diff --git a/clippy_lints/src/needless_if.rs b/clippy_lints/src/needless_if.rs
index ad5c3e1dc82..1ed7ea6b325 100644
--- a/clippy_lints/src/needless_if.rs
+++ b/clippy_lints/src/needless_if.rs
@@ -1,4 +1,7 @@
-use clippy_utils::{diagnostics::span_lint_and_sugg, higher::If, is_from_proc_macro, source::snippet_opt};
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::higher::If;
+use clippy_utils::is_from_proc_macro;
+use clippy_utils::source::snippet_opt;
 use rustc_errors::Applicability;
 use rustc_hir::{ExprKind, Stmt, StmtKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
diff --git a/clippy_lints/src/needless_parens_on_range_literals.rs b/clippy_lints/src/needless_parens_on_range_literals.rs
index da1b9d99931..d17a383e882 100644
--- a/clippy_lints/src/needless_parens_on_range_literals.rs
+++ b/clippy_lints/src/needless_parens_on_range_literals.rs
@@ -1,8 +1,6 @@
-use clippy_utils::{
-    diagnostics::span_lint_and_then,
-    higher,
-    source::{snippet, snippet_with_applicability},
-};
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::higher;
+use clippy_utils::source::{snippet, snippet_with_applicability};
 
 use rustc_ast::ast;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/needless_pass_by_ref_mut.rs b/clippy_lints/src/needless_pass_by_ref_mut.rs
index 46c9b6c4141..cdb7ee48305 100644
--- a/clippy_lints/src/needless_pass_by_ref_mut.rs
+++ b/clippy_lints/src/needless_pass_by_ref_mut.rs
@@ -5,8 +5,7 @@ use clippy_utils::{is_from_proc_macro, is_self};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::FnKind;
-use rustc_hir::{Body, FnDecl, HirId, Impl, ItemKind, Mutability, Node, PatKind};
-use rustc_hir::{HirIdMap, HirIdSet};
+use rustc_hir::{Body, FnDecl, HirId, HirIdMap, HirIdSet, Impl, ItemKind, Mutability, Node, PatKind};
 use rustc_hir_typeck::expr_use_visitor as euv;
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/needless_pass_by_value.rs b/clippy_lints/src/needless_pass_by_value.rs
index 5d299f9355d..f35f120c852 100644
--- a/clippy_lints/src/needless_pass_by_value.rs
+++ b/clippy_lints/src/needless_pass_by_value.rs
@@ -10,9 +10,9 @@ use rustc_ast::ast::Attribute;
 use rustc_errors::{Applicability, Diagnostic};
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::{
-    BindingAnnotation, Body, FnDecl, GenericArg, HirId, Impl, ItemKind, Mutability, Node, PatKind, QPath, TyKind,
+    BindingAnnotation, Body, FnDecl, GenericArg, HirId, HirIdSet, Impl, ItemKind, LangItem, Mutability, Node, PatKind,
+    QPath, TyKind,
 };
-use rustc_hir::{HirIdSet, LangItem};
 use rustc_hir_typeck::expr_use_visitor as euv;
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/no_effect.rs b/clippy_lints/src/no_effect.rs
index a4c7da7e48d..e6d3e72d1e6 100644
--- a/clippy_lints/src/no_effect.rs
+++ b/clippy_lints/src/no_effect.rs
@@ -1,8 +1,7 @@
 use clippy_utils::diagnostics::{span_lint_hir, span_lint_hir_and_then};
-use clippy_utils::peel_blocks;
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::has_drop;
-use clippy_utils::{get_parent_node, is_lint_allowed};
+use clippy_utils::{get_parent_node, is_lint_allowed, peel_blocks};
 use rustc_errors::Applicability;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::{
diff --git a/clippy_lints/src/non_send_fields_in_send_ty.rs b/clippy_lints/src/non_send_fields_in_send_ty.rs
index 7eaa7db78a4..24875855de3 100644
--- a/clippy_lints/src/non_send_fields_in_send_ty.rs
+++ b/clippy_lints/src/non_send_fields_in_send_ty.rs
@@ -7,7 +7,8 @@ use rustc_hir::def_id::DefId;
 use rustc_hir::{FieldDef, Item, ItemKind, Node};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::lint::in_external_macro;
-use rustc_middle::ty::{self, subst::GenericArgKind, Ty};
+use rustc_middle::ty::subst::GenericArgKind;
+use rustc_middle::ty::{self, Ty};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::sym;
 
diff --git a/clippy_lints/src/nonstandard_macro_braces.rs b/clippy_lints/src/nonstandard_macro_braces.rs
index 2d79a5c9008..bd194b93584 100644
--- a/clippy_lints/src/nonstandard_macro_braces.rs
+++ b/clippy_lints/src/nonstandard_macro_braces.rs
@@ -1,7 +1,5 @@
-use std::{
-    fmt,
-    hash::{Hash, Hasher},
-};
+use std::fmt;
+use std::hash::{Hash, Hasher};
 
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_opt;
diff --git a/clippy_lints/src/operators/arithmetic_side_effects.rs b/clippy_lints/src/operators/arithmetic_side_effects.rs
index 5c240276b76..41e8377e15e 100644
--- a/clippy_lints/src/operators/arithmetic_side_effects.rs
+++ b/clippy_lints/src/operators/arithmetic_side_effects.rs
@@ -1,20 +1,14 @@
 use super::ARITHMETIC_SIDE_EFFECTS;
-use clippy_utils::is_from_proc_macro;
-use clippy_utils::{
-    consts::{constant, constant_simple, Constant},
-    diagnostics::span_lint,
-    is_lint_allowed, peel_hir_expr_refs, peel_hir_expr_unary,
-};
-use rustc_ast as ast;
+use clippy_utils::consts::{constant, constant_simple, Constant};
+use clippy_utils::diagnostics::span_lint;
+use clippy_utils::{is_from_proc_macro, is_lint_allowed, peel_hir_expr_refs, peel_hir_expr_unary};
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
-use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::Ty;
 use rustc_session::impl_lint_pass;
-use rustc_span::{
-    source_map::{Span, Spanned},
-    Symbol,
-};
+use rustc_span::source_map::{Span, Spanned};
+use rustc_span::Symbol;
+use {rustc_ast as ast, rustc_hir as hir};
 
 const HARD_CODED_ALLOWED_BINARY: &[[&str; 2]] = &[
     ["f32", "f32"],
diff --git a/clippy_lints/src/operators/assign_op_pattern.rs b/clippy_lints/src/operators/assign_op_pattern.rs
index 9bbf385fb59..c4572a09db6 100644
--- a/clippy_lints/src/operators/assign_op_pattern.rs
+++ b/clippy_lints/src/operators/assign_op_pattern.rs
@@ -1,9 +1,8 @@
-use clippy_utils::binop_traits;
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::implements_trait;
 use clippy_utils::visitors::for_each_expr;
-use clippy_utils::{eq_expr_value, trait_ref_of_method};
+use clippy_utils::{binop_traits, eq_expr_value, trait_ref_of_method};
 use core::ops::ControlFlow;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/operators/eq_op.rs b/clippy_lints/src/operators/eq_op.rs
index 78965b7d6f7..88d56631841 100644
--- a/clippy_lints/src/operators/eq_op.rs
+++ b/clippy_lints/src/operators/eq_op.rs
@@ -1,6 +1,7 @@
+use clippy_utils::ast_utils::is_useless_with_eq_exprs;
 use clippy_utils::diagnostics::{span_lint, span_lint_and_then};
 use clippy_utils::macros::{find_assert_eq_args, first_node_macro_backtrace};
-use clippy_utils::{ast_utils::is_useless_with_eq_exprs, eq_expr_value, is_in_test_function};
+use clippy_utils::{eq_expr_value, is_in_test_function};
 use rustc_hir::{BinOpKind, Expr};
 use rustc_lint::LateContext;
 
diff --git a/clippy_lints/src/operators/misrefactored_assign_op.rs b/clippy_lints/src/operators/misrefactored_assign_op.rs
index 015f6c14e76..5eabb349ec1 100644
--- a/clippy_lints/src/operators/misrefactored_assign_op.rs
+++ b/clippy_lints/src/operators/misrefactored_assign_op.rs
@@ -1,7 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::eq_expr_value;
 use clippy_utils::source::snippet_opt;
-use clippy_utils::sugg;
+use clippy_utils::{eq_expr_value, sugg};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
diff --git a/clippy_lints/src/operators/op_ref.rs b/clippy_lints/src/operators/op_ref.rs
index d7917e86a86..932dd470f9e 100644
--- a/clippy_lints/src/operators/op_ref.rs
+++ b/clippy_lints/src/operators/op_ref.rs
@@ -4,7 +4,9 @@ use clippy_utils::source::snippet;
 use clippy_utils::ty::{implements_trait, is_copy};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
-use rustc_hir::{def::Res, def_id::DefId, BinOpKind, BorrowKind, Expr, ExprKind, GenericArg, ItemKind, QPath, TyKind};
+use rustc_hir::def::Res;
+use rustc_hir::def_id::DefId;
+use rustc_hir::{BinOpKind, BorrowKind, Expr, ExprKind, GenericArg, ItemKind, QPath, TyKind};
 use rustc_lint::LateContext;
 use rustc_middle::ty::{self, Ty};
 
diff --git a/clippy_lints/src/option_if_let_else.rs b/clippy_lints/src/option_if_let_else.rs
index abdccc47f54..40da002f4ff 100644
--- a/clippy_lints/src/option_if_let_else.rs
+++ b/clippy_lints/src/option_if_let_else.rs
@@ -6,10 +6,9 @@ use clippy_utils::{
 };
 use if_chain::if_chain;
 use rustc_errors::Applicability;
+use rustc_hir::def::Res;
 use rustc_hir::LangItem::{OptionNone, OptionSome, ResultErr, ResultOk};
-use rustc_hir::{
-    def::Res, Arm, BindingAnnotation, Expr, ExprKind, MatchSource, Mutability, Pat, PatKind, Path, QPath, UnOp,
-};
+use rustc_hir::{Arm, BindingAnnotation, Expr, ExprKind, MatchSource, Mutability, Pat, PatKind, Path, QPath, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::SyntaxContext;
diff --git a/clippy_lints/src/partialeq_to_none.rs b/clippy_lints/src/partialeq_to_none.rs
index 456ded3fc02..d9f5d1642d7 100644
--- a/clippy_lints/src/partialeq_to_none.rs
+++ b/clippy_lints/src/partialeq_to_none.rs
@@ -1,7 +1,6 @@
-use clippy_utils::{
-    diagnostics::span_lint_and_sugg, is_res_lang_ctor, path_res, peel_hir_expr_refs, peel_ref_operators, sugg,
-    ty::is_type_diagnostic_item,
-};
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::{is_res_lang_ctor, path_res, peel_hir_expr_refs, peel_ref_operators, sugg};
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind, LangItem};
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/pass_by_ref_or_value.rs b/clippy_lints/src/pass_by_ref_or_value.rs
index 0d78c3048ba..a8e16f2cb33 100644
--- a/clippy_lints/src/pass_by_ref_or_value.rs
+++ b/clippy_lints/src/pass_by_ref_or_value.rs
@@ -1,5 +1,4 @@
-use std::cmp;
-use std::iter;
+use std::{cmp, iter};
 
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet;
diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs
index 866a04466c9..71c65e925e3 100644
--- a/clippy_lints/src/ptr.rs
+++ b/clippy_lints/src/ptr.rs
@@ -28,8 +28,7 @@ use rustc_span::sym;
 use rustc_span::symbol::Symbol;
 use rustc_trait_selection::infer::InferCtxtExt as _;
 use rustc_trait_selection::traits::query::evaluate_obligation::InferCtxtExt as _;
-use std::fmt;
-use std::iter;
+use std::{fmt, iter};
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/question_mark.rs b/clippy_lints/src/question_mark.rs
index 9840d464b75..f5502cffb66 100644
--- a/clippy_lints/src/question_mark.rs
+++ b/clippy_lints/src/question_mark.rs
@@ -4,10 +4,9 @@ use clippy_utils::msrvs::Msrv;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::{
-    eq_expr_value, get_parent_node, in_constant, is_else_clause, is_res_lang_ctor, pat_and_expr_can_be_question_mark,
-    path_to_local, path_to_local_id, peel_blocks, peel_blocks_with_stmt,
+    eq_expr_value, get_parent_node, higher, in_constant, is_else_clause, is_path_lang_item, is_res_lang_ctor,
+    pat_and_expr_can_be_question_mark, path_to_local, path_to_local_id, peel_blocks, peel_blocks_with_stmt,
 };
-use clippy_utils::{higher, is_path_lang_item};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::def::Res;
@@ -17,9 +16,9 @@ use rustc_hir::{
 };
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::Ty;
-use rustc_session::declare_tool_lint;
-use rustc_session::impl_lint_pass;
-use rustc_span::{sym, symbol::Symbol};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::sym;
+use rustc_span::symbol::Symbol;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/ranges.rs b/clippy_lints/src/ranges.rs
index d2018aba9e3..3287675a82d 100644
--- a/clippy_lints/src/ranges.rs
+++ b/clippy_lints/src/ranges.rs
@@ -1,10 +1,9 @@
 use clippy_utils::consts::{constant, Constant};
 use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg, span_lint_and_then};
-use clippy_utils::higher;
 use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::{snippet, snippet_opt, snippet_with_applicability};
 use clippy_utils::sugg::Sugg;
-use clippy_utils::{get_parent_expr, in_constant, is_integer_const, path_to_local};
+use clippy_utils::{get_parent_expr, higher, in_constant, is_integer_const, path_to_local};
 use if_chain::if_chain;
 use rustc_ast::ast::RangeLimits;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/raw_strings.rs b/clippy_lints/src/raw_strings.rs
index 0e964ec4724..ccabb577cb7 100644
--- a/clippy_lints/src/raw_strings.rs
+++ b/clippy_lints/src/raw_strings.rs
@@ -1,10 +1,10 @@
-use std::{iter::once, ops::ControlFlow};
+use std::iter::once;
+use std::ops::ControlFlow;
 
-use clippy_utils::{diagnostics::span_lint_and_sugg, source::snippet};
-use rustc_ast::{
-    ast::{Expr, ExprKind},
-    token::LitKind,
-};
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet;
+use rustc_ast::ast::{Expr, ExprKind};
+use rustc_ast::token::LitKind;
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
diff --git a/clippy_lints/src/rc_clone_in_vec_init.rs b/clippy_lints/src/rc_clone_in_vec_init.rs
index e82aa3a7b98..a2e7ae6d79a 100644
--- a/clippy_lints/src/rc_clone_in_vec_init.rs
+++ b/clippy_lints/src/rc_clone_in_vec_init.rs
@@ -1,10 +1,9 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::higher::VecArgs;
-use clippy_utils::last_path_segment;
 use clippy_utils::macros::root_macro_call_first_node;
-use clippy_utils::paths;
 use clippy_utils::source::{indent_of, snippet};
 use clippy_utils::ty::match_type;
+use clippy_utils::{last_path_segment, paths};
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, QPath, TyKind};
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/read_zero_byte_vec.rs b/clippy_lints/src/read_zero_byte_vec.rs
index fa107858863..2bf90815caa 100644
--- a/clippy_lints/src/read_zero_byte_vec.rs
+++ b/clippy_lints/src/read_zero_byte_vec.rs
@@ -1,9 +1,7 @@
-use clippy_utils::{
-    diagnostics::{span_lint, span_lint_and_sugg},
-    higher::{get_vec_init_kind, VecInitKind},
-    source::snippet,
-    visitors::for_each_expr,
-};
+use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg};
+use clippy_utils::higher::{get_vec_init_kind, VecInitKind};
+use clippy_utils::source::snippet;
+use clippy_utils::visitors::for_each_expr;
 use core::ops::ControlFlow;
 use hir::{Expr, ExprKind, Local, PatKind, PathSegment, QPath, StmtKind};
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/redundant_async_block.rs b/clippy_lints/src/redundant_async_block.rs
index 05e52e6b38b..534b2762ba7 100644
--- a/clippy_lints/src/redundant_async_block.rs
+++ b/clippy_lints/src/redundant_async_block.rs
@@ -1,15 +1,14 @@
 use std::ops::ControlFlow;
 
-use clippy_utils::{
-    diagnostics::span_lint_and_sugg,
-    peel_blocks,
-    source::{snippet, walk_span_to_context},
-    visitors::for_each_expr,
-};
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::peel_blocks;
+use clippy_utils::source::{snippet, walk_span_to_context};
+use clippy_utils::visitors::for_each_expr;
 use rustc_errors::Applicability;
 use rustc_hir::{AsyncGeneratorKind, Closure, Expr, ExprKind, GeneratorKind, MatchSource};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::{lint::in_external_macro, ty::UpvarCapture};
+use rustc_middle::lint::in_external_macro;
+use rustc_middle::ty::UpvarCapture;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/redundant_closure_call.rs b/clippy_lints/src/redundant_closure_call.rs
index b6ce4ebc28f..4e3efe97b8c 100644
--- a/clippy_lints/src/redundant_closure_call.rs
+++ b/clippy_lints/src/redundant_closure_call.rs
@@ -6,8 +6,7 @@ use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_hir::intravisit as hir_visit;
-use rustc_hir::intravisit::Visitor as HirVisitor;
-use rustc_hir::intravisit::Visitor;
+use rustc_hir::intravisit::{Visitor as HirVisitor, Visitor};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::nested_filter;
 use rustc_middle::lint::in_external_macro;
diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
index ad0167a3d32..0212deda146 100644
--- a/clippy_lints/src/returns.rs
+++ b/clippy_lints/src/returns.rs
@@ -9,7 +9,8 @@ use rustc_hir::intravisit::FnKind;
 use rustc_hir::{Block, Body, Expr, ExprKind, FnDecl, LangItem, MatchSource, PatKind, QPath, StmtKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_middle::ty::{self, subst::GenericArgKind, Ty};
+use rustc_middle::ty::subst::GenericArgKind;
+use rustc_middle::ty::{self, Ty};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::def_id::LocalDefId;
 use rustc_span::source_map::Span;
diff --git a/clippy_lints/src/significant_drop_tightening.rs b/clippy_lints/src/significant_drop_tightening.rs
index cc2dbae4bc4..bf1059a8b29 100644
--- a/clippy_lints/src/significant_drop_tightening.rs
+++ b/clippy_lints/src/significant_drop_tightening.rs
@@ -1,20 +1,17 @@
-use clippy_utils::{
-    diagnostics::span_lint_and_then,
-    expr_or_init, get_attr, path_to_local,
-    source::{indent_of, snippet},
-};
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::source::{indent_of, snippet};
+use clippy_utils::{expr_or_init, get_attr, path_to_local};
 use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexMap};
 use rustc_errors::Applicability;
-use rustc_hir::{
-    self as hir,
-    def::{DefKind, Res},
-    intravisit::{walk_expr, Visitor},
-};
+use rustc_hir::def::{DefKind, Res};
+use rustc_hir::intravisit::{walk_expr, Visitor};
+use rustc_hir::{self as hir};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
-use rustc_middle::ty::{subst::GenericArgKind, Ty, TypeAndMut};
+use rustc_middle::ty::subst::GenericArgKind;
+use rustc_middle::ty::{Ty, TypeAndMut};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::sym;
-use rustc_span::{symbol::Ident, Span, DUMMY_SP};
+use rustc_span::symbol::Ident;
+use rustc_span::{sym, Span, DUMMY_SP};
 use std::borrow::Cow;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/single_call_fn.rs b/clippy_lints/src/single_call_fn.rs
index 42753d2e951..7bbe98e0a7f 100644
--- a/clippy_lints/src/single_call_fn.rs
+++ b/clippy_lints/src/single_call_fn.rs
@@ -2,8 +2,8 @@ use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::{is_from_proc_macro, is_in_test_function};
 use rustc_data_structures::fx::FxHashMap;
 use rustc_hir::def_id::LocalDefId;
-use rustc_hir::intravisit::{walk_expr, Visitor};
-use rustc_hir::{intravisit::FnKind, Body, Expr, ExprKind, FnDecl};
+use rustc_hir::intravisit::{walk_expr, FnKind, Visitor};
+use rustc_hir::{Body, Expr, ExprKind, FnDecl};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::hir::nested_filter::OnlyBodies;
 use rustc_middle::lint::in_external_macro;
diff --git a/clippy_lints/src/single_component_path_imports.rs b/clippy_lints/src/single_component_path_imports.rs
index 5743dd21c28..9c21d70c82c 100644
--- a/clippy_lints/src/single_component_path_imports.rs
+++ b/clippy_lints/src/single_component_path_imports.rs
@@ -1,11 +1,14 @@
 use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg};
 use rustc_ast::node_id::{NodeId, NodeMap};
+use rustc_ast::ptr::P;
 use rustc_ast::visit::{walk_expr, Visitor};
-use rustc_ast::{ptr::P, Crate, Expr, ExprKind, Item, ItemKind, MacroDef, ModKind, Ty, TyKind, UseTreeKind};
+use rustc_ast::{Crate, Expr, ExprKind, Item, ItemKind, MacroDef, ModKind, Ty, TyKind, UseTreeKind};
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::{edition::Edition, symbol::kw, Span, Symbol};
+use rustc_span::edition::Edition;
+use rustc_span::symbol::kw;
+use rustc_span::{Span, Symbol};
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/single_range_in_vec_init.rs b/clippy_lints/src/single_range_in_vec_init.rs
index dfe8be7a6a6..321c8988988 100644
--- a/clippy_lints/src/single_range_in_vec_init.rs
+++ b/clippy_lints/src/single_range_in_vec_init.rs
@@ -1,7 +1,9 @@
-use clippy_utils::{
-    diagnostics::span_lint_and_then, get_trait_def_id, higher::VecArgs, macros::root_macro_call_first_node,
-    source::snippet_opt, ty::implements_trait,
-};
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::get_trait_def_id;
+use clippy_utils::higher::VecArgs;
+use clippy_utils::macros::root_macro_call_first_node;
+use clippy_utils::source::snippet_opt;
+use clippy_utils::ty::implements_trait;
 use rustc_ast::{LitIntType, LitKind, UintTy};
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, LangItem, QPath};
diff --git a/clippy_lints/src/size_of_in_element_count.rs b/clippy_lints/src/size_of_in_element_count.rs
index ac4e29e9dfd..a91dd21269c 100644
--- a/clippy_lints/src/size_of_in_element_count.rs
+++ b/clippy_lints/src/size_of_in_element_count.rs
@@ -4,8 +4,7 @@
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::{match_def_path, paths};
 use if_chain::if_chain;
-use rustc_hir::BinOpKind;
-use rustc_hir::{Expr, ExprKind};
+use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{self, Ty, TypeAndMut};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
diff --git a/clippy_lints/src/size_of_ref.rs b/clippy_lints/src/size_of_ref.rs
index 8abec06c641..89ac8cd8ca9 100644
--- a/clippy_lints/src/size_of_ref.rs
+++ b/clippy_lints/src/size_of_ref.rs
@@ -1,4 +1,6 @@
-use clippy_utils::{diagnostics::span_lint_and_help, path_def_id, ty::peel_mid_ty_refs};
+use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::path_def_id;
+use clippy_utils::ty::peel_mid_ty_refs;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
diff --git a/clippy_lints/src/std_instead_of_core.rs b/clippy_lints/src/std_instead_of_core.rs
index a13bc7a5188..f239165276f 100644
--- a/clippy_lints/src/std_instead_of_core.rs
+++ b/clippy_lints/src/std_instead_of_core.rs
@@ -1,9 +1,11 @@
 use clippy_utils::diagnostics::span_lint_and_help;
+use rustc_hir::def::Res;
 use rustc_hir::def_id::DefId;
-use rustc_hir::{def::Res, HirId, Path, PathSegment};
+use rustc_hir::{HirId, Path, PathSegment};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::{sym, symbol::kw, Span};
+use rustc_span::symbol::kw;
+use rustc_span::{sym, Span};
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/strings.rs b/clippy_lints/src/strings.rs
index 8658009eba4..58724852b3c 100644
--- a/clippy_lints/src/strings.rs
+++ b/clippy_lints/src/strings.rs
@@ -1,8 +1,10 @@
 use clippy_utils::diagnostics::{span_lint, span_lint_and_help, span_lint_and_sugg};
 use clippy_utils::source::{snippet, snippet_with_applicability};
 use clippy_utils::ty::is_type_lang_item;
-use clippy_utils::{get_expr_use_or_unification_node, peel_blocks, SpanlessEq};
-use clippy_utils::{get_parent_expr, is_lint_allowed, is_path_diagnostic_item, method_calls};
+use clippy_utils::{
+    get_expr_use_or_unification_node, get_parent_expr, is_lint_allowed, is_path_diagnostic_item, method_calls,
+    peel_blocks, SpanlessEq,
+};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::def_id::DefId;
diff --git a/clippy_lints/src/suspicious_doc_comments.rs b/clippy_lints/src/suspicious_doc_comments.rs
index e5746ca99ca..8be4ec3dc64 100644
--- a/clippy_lints/src/suspicious_doc_comments.rs
+++ b/clippy_lints/src/suspicious_doc_comments.rs
@@ -1,6 +1,7 @@
 use clippy_utils::diagnostics::{multispan_sugg_with_applicability, span_lint_and_then};
 use if_chain::if_chain;
-use rustc_ast::{token::CommentKind, AttrKind, AttrStyle, Attribute, Item};
+use rustc_ast::token::CommentKind;
+use rustc_ast::{AttrKind, AttrStyle, Attribute, Item};
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
diff --git a/clippy_lints/src/suspicious_xor_used_as_pow.rs b/clippy_lints/src/suspicious_xor_used_as_pow.rs
index 9c0dc8096d0..6fa49afe0ec 100644
--- a/clippy_lints/src/suspicious_xor_used_as_pow.rs
+++ b/clippy_lints/src/suspicious_xor_used_as_pow.rs
@@ -1,4 +1,5 @@
-use clippy_utils::{numeric_literal::NumericLiteral, source::snippet_with_context};
+use clippy_utils::numeric_literal::NumericLiteral;
+use clippy_utils::source::snippet_with_context;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
diff --git a/clippy_lints/src/swap.rs b/clippy_lints/src/swap.rs
index f7eef03d1d4..98158ed0aee 100644
--- a/clippy_lints/src/swap.rs
+++ b/clippy_lints/src/swap.rs
@@ -11,8 +11,8 @@ use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Spanned;
-use rustc_span::SyntaxContext;
-use rustc_span::{sym, symbol::Ident, Span};
+use rustc_span::symbol::Ident;
+use rustc_span::{sym, Span, SyntaxContext};
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/tests_outside_test_module.rs b/clippy_lints/src/tests_outside_test_module.rs
index 0a0a77082e0..b356666d852 100644
--- a/clippy_lints/src/tests_outside_test_module.rs
+++ b/clippy_lints/src/tests_outside_test_module.rs
@@ -1,8 +1,11 @@
-use clippy_utils::{diagnostics::span_lint_and_note, is_in_cfg_test, is_in_test_function};
-use rustc_hir::{intravisit::FnKind, Body, FnDecl};
+use clippy_utils::diagnostics::span_lint_and_note;
+use clippy_utils::{is_in_cfg_test, is_in_test_function};
+use rustc_hir::intravisit::FnKind;
+use rustc_hir::{Body, FnDecl};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::{def_id::LocalDefId, Span};
+use rustc_span::def_id::LocalDefId;
+use rustc_span::Span;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/transmute/transmute_int_to_non_zero.rs b/clippy_lints/src/transmute/transmute_int_to_non_zero.rs
index 5503653253c..c0d0d2b93dc 100644
--- a/clippy_lints/src/transmute/transmute_int_to_non_zero.rs
+++ b/clippy_lints/src/transmute/transmute_int_to_non_zero.rs
@@ -4,10 +4,8 @@ use clippy_utils::sugg;
 use rustc_errors::Applicability;
 use rustc_hir::Expr;
 use rustc_lint::LateContext;
-use rustc_middle::{
-    query::Key,
-    ty::{self, Ty},
-};
+use rustc_middle::query::Key;
+use rustc_middle::ty::{self, Ty};
 use rustc_span::symbol::sym;
 
 /// Checks for `transmute_int_to_non_zero` lint.
diff --git a/clippy_lints/src/transmute/transmute_undefined_repr.rs b/clippy_lints/src/transmute/transmute_undefined_repr.rs
index 5e24213d07f..13b7eeb43a6 100644
--- a/clippy_lints/src/transmute/transmute_undefined_repr.rs
+++ b/clippy_lints/src/transmute/transmute_undefined_repr.rs
@@ -3,8 +3,7 @@ use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::ty::is_c_void;
 use rustc_hir::Expr;
 use rustc_lint::LateContext;
-use rustc_middle::ty::SubstsRef;
-use rustc_middle::ty::{self, IntTy, Ty, TypeAndMut, UintTy};
+use rustc_middle::ty::{self, IntTy, SubstsRef, Ty, TypeAndMut, UintTy};
 
 #[expect(clippy::too_many_lines)]
 pub(super) fn check<'tcx>(
diff --git a/clippy_lints/src/transmute/transmutes_expressible_as_ptr_casts.rs b/clippy_lints/src/transmute/transmutes_expressible_as_ptr_casts.rs
index 85cd74f23ef..513a913f56a 100644
--- a/clippy_lints/src/transmute/transmutes_expressible_as_ptr_casts.rs
+++ b/clippy_lints/src/transmute/transmutes_expressible_as_ptr_casts.rs
@@ -6,7 +6,8 @@ use rustc_ast::ExprPrecedence;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, Node};
 use rustc_lint::LateContext;
-use rustc_middle::ty::{cast::CastKind, Ty};
+use rustc_middle::ty::cast::CastKind;
+use rustc_middle::ty::Ty;
 
 /// Checks for `transmutes_expressible_as_ptr_casts` lint.
 /// Returns `true` if it's triggered, otherwise returns `false`.
diff --git a/clippy_lints/src/transmute/utils.rs b/clippy_lints/src/transmute/utils.rs
index 62efd13b8d9..1cf6cf8548a 100644
--- a/clippy_lints/src/transmute/utils.rs
+++ b/clippy_lints/src/transmute/utils.rs
@@ -2,7 +2,8 @@ use rustc_hir as hir;
 use rustc_hir::Expr;
 use rustc_hir_typeck::{cast, FnCtxt, Inherited};
 use rustc_lint::LateContext;
-use rustc_middle::ty::{cast::CastKind, Ty};
+use rustc_middle::ty::cast::CastKind;
+use rustc_middle::ty::Ty;
 use rustc_span::DUMMY_SP;
 
 // check if the component types of the transmuted collection and the result have different ABI,
diff --git a/clippy_lints/src/tuple_array_conversions.rs b/clippy_lints/src/tuple_array_conversions.rs
index 258617467e9..2e00ed042a8 100644
--- a/clippy_lints/src/tuple_array_conversions.rs
+++ b/clippy_lints/src/tuple_array_conversions.rs
@@ -1,13 +1,11 @@
-use clippy_utils::{
-    diagnostics::span_lint_and_help,
-    is_from_proc_macro,
-    msrvs::{self, Msrv},
-    path_to_local,
-};
+use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::msrvs::{self, Msrv};
+use clippy_utils::{is_from_proc_macro, path_to_local};
 use rustc_ast::LitKind;
 use rustc_hir::{Expr, ExprKind, HirId, Node, Pat};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
-use rustc_middle::{lint::in_external_macro, ty};
+use rustc_middle::lint::in_external_macro;
+use rustc_middle::ty;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use std::iter::once;
 
diff --git a/clippy_lints/src/types/borrowed_box.rs b/clippy_lints/src/types/borrowed_box.rs
index acdf5471069..306ca5724da 100644
--- a/clippy_lints/src/types/borrowed_box.rs
+++ b/clippy_lints/src/types/borrowed_box.rs
@@ -2,8 +2,9 @@ use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
-use rustc_hir::{self as hir, GenericArg, GenericBounds, GenericParamKind};
-use rustc_hir::{HirId, Lifetime, MutTy, Mutability, Node, QPath, TyKind};
+use rustc_hir::{
+    self as hir, GenericArg, GenericBounds, GenericParamKind, HirId, Lifetime, MutTy, Mutability, Node, QPath, TyKind,
+};
 use rustc_lint::LateContext;
 use rustc_span::sym;
 
diff --git a/clippy_lints/src/types/box_collection.rs b/clippy_lints/src/types/box_collection.rs
index 43665a922d4..4a5a94f2630 100644
--- a/clippy_lints/src/types/box_collection.rs
+++ b/clippy_lints/src/types/box_collection.rs
@@ -1,6 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::{path_def_id, qpath_generic_tys};
-use rustc_hir::{self as hir, def_id::DefId, QPath};
+use rustc_hir::def_id::DefId;
+use rustc_hir::{self as hir, QPath};
 use rustc_lint::LateContext;
 use rustc_span::{sym, Symbol};
 
diff --git a/clippy_lints/src/types/linked_list.rs b/clippy_lints/src/types/linked_list.rs
index 5fb708741e5..fba804bbe08 100644
--- a/clippy_lints/src/types/linked_list.rs
+++ b/clippy_lints/src/types/linked_list.rs
@@ -1,5 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_help;
-use rustc_hir::{self as hir, def_id::DefId};
+use rustc_hir::def_id::DefId;
+use rustc_hir::{self as hir};
 use rustc_lint::LateContext;
 use rustc_span::symbol::sym;
 
diff --git a/clippy_lints/src/types/option_option.rs b/clippy_lints/src/types/option_option.rs
index 8767e3c30a6..60622903af1 100644
--- a/clippy_lints/src/types/option_option.rs
+++ b/clippy_lints/src/types/option_option.rs
@@ -1,7 +1,8 @@
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::{path_def_id, qpath_generic_tys};
 use if_chain::if_chain;
-use rustc_hir::{self as hir, def_id::DefId, QPath};
+use rustc_hir::def_id::DefId;
+use rustc_hir::{self as hir, QPath};
 use rustc_lint::LateContext;
 use rustc_span::symbol::sym;
 
diff --git a/clippy_lints/src/types/rc_buffer.rs b/clippy_lints/src/types/rc_buffer.rs
index 855137b14d8..8239630ac2d 100644
--- a/clippy_lints/src/types/rc_buffer.rs
+++ b/clippy_lints/src/types/rc_buffer.rs
@@ -2,7 +2,8 @@ use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::{path_def_id, qpath_generic_tys};
 use rustc_errors::Applicability;
-use rustc_hir::{self as hir, def_id::DefId, QPath, TyKind};
+use rustc_hir::def_id::DefId;
+use rustc_hir::{self as hir, QPath, TyKind};
 use rustc_lint::LateContext;
 use rustc_span::symbol::sym;
 
diff --git a/clippy_lints/src/types/rc_mutex.rs b/clippy_lints/src/types/rc_mutex.rs
index a75972cf3dd..a616c3e4ea8 100644
--- a/clippy_lints/src/types/rc_mutex.rs
+++ b/clippy_lints/src/types/rc_mutex.rs
@@ -1,7 +1,8 @@
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::{path_def_id, qpath_generic_tys};
 use if_chain::if_chain;
-use rustc_hir::{self as hir, def_id::DefId, QPath};
+use rustc_hir::def_id::DefId;
+use rustc_hir::{self as hir, QPath};
 use rustc_lint::LateContext;
 use rustc_span::symbol::sym;
 
diff --git a/clippy_lints/src/types/redundant_allocation.rs b/clippy_lints/src/types/redundant_allocation.rs
index f7adc9d3555..d369c6df919 100644
--- a/clippy_lints/src/types/redundant_allocation.rs
+++ b/clippy_lints/src/types/redundant_allocation.rs
@@ -2,7 +2,8 @@ use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::{snippet, snippet_with_applicability};
 use clippy_utils::{path_def_id, qpath_generic_tys};
 use rustc_errors::Applicability;
-use rustc_hir::{self as hir, def_id::DefId, QPath, TyKind};
+use rustc_hir::def_id::DefId;
+use rustc_hir::{self as hir, QPath, TyKind};
 use rustc_hir_analysis::hir_ty_to_ty;
 use rustc_lint::LateContext;
 use rustc_middle::ty::TypeVisitableExt;
diff --git a/clippy_lints/src/types/vec_box.rs b/clippy_lints/src/types/vec_box.rs
index d3062f3d2e3..decc183ad96 100644
--- a/clippy_lints/src/types/vec_box.rs
+++ b/clippy_lints/src/types/vec_box.rs
@@ -3,7 +3,8 @@ use clippy_utils::last_path_segment;
 use clippy_utils::source::snippet;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
-use rustc_hir::{self as hir, def_id::DefId, GenericArg, QPath, TyKind};
+use rustc_hir::def_id::DefId;
+use rustc_hir::{self as hir, GenericArg, QPath, TyKind};
 use rustc_hir_analysis::hir_ty_to_ty;
 use rustc_lint::LateContext;
 use rustc_middle::ty::layout::LayoutOf;
diff --git a/clippy_lints/src/unnecessary_box_returns.rs b/clippy_lints/src/unnecessary_box_returns.rs
index e7449639f3a..58ccd47f837 100644
--- a/clippy_lints/src/unnecessary_box_returns.rs
+++ b/clippy_lints/src/unnecessary_box_returns.rs
@@ -1,6 +1,8 @@
-use clippy_utils::{diagnostics::span_lint_and_then, ty::approx_ty_size};
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::ty::approx_ty_size;
 use rustc_errors::Applicability;
-use rustc_hir::{def_id::LocalDefId, FnDecl, FnRetTy, ImplItemKind, Item, ItemKind, Node, TraitItem, TraitItemKind};
+use rustc_hir::def_id::LocalDefId;
+use rustc_hir::{FnDecl, FnRetTy, ImplItemKind, Item, ItemKind, Node, TraitItem, TraitItemKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::Symbol;
diff --git a/clippy_lints/src/unnecessary_owned_empty_strings.rs b/clippy_lints/src/unnecessary_owned_empty_strings.rs
index 6e802794f5a..57a4a429e12 100644
--- a/clippy_lints/src/unnecessary_owned_empty_strings.rs
+++ b/clippy_lints/src/unnecessary_owned_empty_strings.rs
@@ -1,4 +1,5 @@
-use clippy_utils::{diagnostics::span_lint_and_sugg, ty::is_type_lang_item};
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::ty::is_type_lang_item;
 use clippy_utils::{match_def_path, paths};
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
diff --git a/clippy_lints/src/unnecessary_struct_initialization.rs b/clippy_lints/src/unnecessary_struct_initialization.rs
index 084b031982d..f4111186c64 100644
--- a/clippy_lints/src/unnecessary_struct_initialization.rs
+++ b/clippy_lints/src/unnecessary_struct_initialization.rs
@@ -1,4 +1,7 @@
-use clippy_utils::{diagnostics::span_lint_and_sugg, get_parent_expr, path_to_local, source::snippet, ty::is_copy};
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet;
+use clippy_utils::ty::is_copy;
+use clippy_utils::{get_parent_expr, path_to_local};
 use rustc_hir::{BindingAnnotation, Expr, ExprKind, Node, PatKind, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
diff --git a/clippy_lints/src/unnecessary_wraps.rs b/clippy_lints/src/unnecessary_wraps.rs
index 5073eb02bd8..f34f8d0e353 100644
--- a/clippy_lints/src/unnecessary_wraps.rs
+++ b/clippy_lints/src/unnecessary_wraps.rs
@@ -1,6 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet;
-use clippy_utils::{contains_return, is_res_lang_ctor, path_res, return_ty, visitors::find_all_ret_expressions};
+use clippy_utils::visitors::find_all_ret_expressions;
+use clippy_utils::{contains_return, is_res_lang_ctor, path_res, return_ty};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::FnKind;
diff --git a/clippy_lints/src/unnested_or_patterns.rs b/clippy_lints/src/unnested_or_patterns.rs
index a57bf7ee822..c1cc7471d53 100644
--- a/clippy_lints/src/unnested_or_patterns.rs
+++ b/clippy_lints/src/unnested_or_patterns.rs
@@ -6,7 +6,8 @@ use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::over;
 use rustc_ast::mut_visit::*;
 use rustc_ast::ptr::P;
-use rustc_ast::{self as ast, Mutability, Pat, PatKind, PatKind::*, DUMMY_NODE_ID};
+use rustc_ast::PatKind::*;
+use rustc_ast::{self as ast, Mutability, Pat, PatKind, DUMMY_NODE_ID};
 use rustc_ast_pretty::pprust;
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass};
diff --git a/clippy_lints/src/unused_unit.rs b/clippy_lints/src/unused_unit.rs
index cad8da18c2f..95e74718d80 100644
--- a/clippy_lints/src/unused_unit.rs
+++ b/clippy_lints/src/unused_unit.rs
@@ -1,7 +1,8 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::{position_before_rarrow, snippet_opt};
 use if_chain::if_chain;
-use rustc_ast::{ast, visit::FnKind, ClosureBinder};
+use rustc_ast::visit::FnKind;
+use rustc_ast::{ast, ClosureBinder};
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
diff --git a/clippy_lints/src/unwrap.rs b/clippy_lints/src/unwrap.rs
index 377d3fb6f4e..c99b0290c0c 100644
--- a/clippy_lints/src/unwrap.rs
+++ b/clippy_lints/src/unwrap.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::span_lint_hir_and_then;
-use clippy_utils::higher;
 use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{path_to_local, usage::is_potentially_mutated};
+use clippy_utils::usage::is_potentially_mutated;
+use clippy_utils::{higher, path_to_local};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_expr, walk_fn, FnKind, Visitor};
diff --git a/clippy_lints/src/use_self.rs b/clippy_lints/src/use_self.rs
index 5a02987453c..fcf77e8eab9 100644
--- a/clippy_lints/src/use_self.rs
+++ b/clippy_lints/src/use_self.rs
@@ -5,13 +5,12 @@ use clippy_utils::ty::same_type_and_consts;
 use if_chain::if_chain;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Applicability;
+use rustc_hir::def::{CtorOf, DefKind, Res};
+use rustc_hir::def_id::LocalDefId;
+use rustc_hir::intravisit::{walk_inf, walk_ty, Visitor};
 use rustc_hir::{
-    self as hir,
-    def::{CtorOf, DefKind, Res},
-    def_id::LocalDefId,
-    intravisit::{walk_inf, walk_ty, Visitor},
-    Expr, ExprKind, FnRetTy, FnSig, GenericArg, GenericArgsParentheses, GenericParam, GenericParamKind, HirId, Impl,
-    ImplItemKind, Item, ItemKind, Pat, PatKind, Path, QPath, Ty, TyKind,
+    self as hir, Expr, ExprKind, FnRetTy, FnSig, GenericArg, GenericArgsParentheses, GenericParam, GenericParamKind,
+    HirId, Impl, ImplItemKind, Item, ItemKind, Pat, PatKind, Path, QPath, Ty, TyKind,
 };
 use rustc_hir_analysis::hir_ty_to_ty;
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/useless_conversion.rs b/clippy_lints/src/useless_conversion.rs
index b6c11cfb355..c9c092c508f 100644
--- a/clippy_lints/src/useless_conversion.rs
+++ b/clippy_lints/src/useless_conversion.rs
@@ -1,9 +1,8 @@
 use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg, span_lint_and_then};
-use clippy_utils::is_ty_alias;
 use clippy_utils::source::{snippet, snippet_with_applicability, snippet_with_context};
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::{is_copy, is_type_diagnostic_item, same_type_and_consts};
-use clippy_utils::{get_parent_expr, is_trait_method, match_def_path, path_to_local, paths};
+use clippy_utils::{get_parent_expr, is_trait_method, is_ty_alias, match_def_path, path_to_local, paths};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::def_id::DefId;
diff --git a/clippy_lints/src/utils/internal_lints/invalid_paths.rs b/clippy_lints/src/utils/internal_lints/invalid_paths.rs
index 9afe02c1e47..94b56304bca 100644
--- a/clippy_lints/src/utils/internal_lints/invalid_paths.rs
+++ b/clippy_lints/src/utils/internal_lints/invalid_paths.rs
@@ -7,7 +7,8 @@ use rustc_hir::def::DefKind;
 use rustc_hir::Item;
 use rustc_hir_analysis::hir_ty_to_ty;
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty::{self, fast_reject::SimplifiedType, FloatTy};
+use rustc_middle::ty::fast_reject::SimplifiedType;
+use rustc_middle::ty::{self, FloatTy};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::symbol::Symbol;
 
diff --git a/clippy_lints/src/utils/internal_lints/lint_without_lint_pass.rs b/clippy_lints/src/utils/internal_lints/lint_without_lint_pass.rs
index f718207654f..87380f14f9a 100644
--- a/clippy_lints/src/utils/internal_lints/lint_without_lint_pass.rs
+++ b/clippy_lints/src/utils/internal_lints/lint_without_lint_pass.rs
@@ -3,10 +3,8 @@ use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
 use clippy_utils::macros::root_macro_call_first_node;
 use clippy_utils::{is_lint_allowed, match_def_path, paths};
 use if_chain::if_chain;
-use rustc_ast as ast;
 use rustc_ast::ast::LitKind;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
-use rustc_hir as hir;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::hir_id::CRATE_HIR_ID;
 use rustc_hir::intravisit::Visitor;
@@ -18,6 +16,7 @@ use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::Spanned;
 use rustc_span::symbol::Symbol;
 use rustc_span::{sym, Span};
+use {rustc_ast as ast, rustc_hir as hir};
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index 107a62806a8..f49c3fadb07 100644
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -8,11 +8,8 @@
 //! a simple mistake)
 
 use crate::renamed_lints::RENAMED_LINTS;
-use crate::utils::{
-    collect_configs,
-    internal_lints::lint_without_lint_pass::{extract_clippy_version_value, is_lint_ref_type},
-    ClippyConfiguration,
-};
+use crate::utils::internal_lints::lint_without_lint_pass::{extract_clippy_version_value, is_lint_ref_type};
+use crate::utils::{collect_configs, ClippyConfiguration};
 
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::ty::{match_type, walk_ptrs_ty_depth};
@@ -21,22 +18,22 @@ use if_chain::if_chain;
 use itertools::Itertools;
 use rustc_ast as ast;
 use rustc_data_structures::fx::FxHashMap;
-use rustc_hir::{
-    self as hir, def::DefKind, intravisit, intravisit::Visitor, Closure, ExprKind, Item, ItemKind, Mutability, QPath,
-};
+use rustc_hir::def::DefKind;
+use rustc_hir::intravisit::Visitor;
+use rustc_hir::{self as hir, intravisit, Closure, ExprKind, Item, ItemKind, Mutability, QPath};
 use rustc_lint::{CheckLintNameResult, LateContext, LateLintPass, LintContext, LintId};
 use rustc_middle::hir::nested_filter;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::symbol::Ident;
 use rustc_span::{sym, Loc, Span, Symbol};
-use serde::{ser::SerializeStruct, Serialize, Serializer};
+use serde::ser::SerializeStruct;
+use serde::{Serialize, Serializer};
 use std::collections::{BTreeSet, BinaryHeap};
 use std::fmt;
 use std::fmt::Write as _;
 use std::fs::{self, OpenOptions};
 use std::io::prelude::*;
-use std::path::Path;
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 use std::process::Command;
 
 /// This is the json output file of the lint collector.
diff --git a/clippy_lints/src/utils/internal_lints/msrv_attr_impl.rs b/clippy_lints/src/utils/internal_lints/msrv_attr_impl.rs
index 09f0f0d0adb..14855e9c331 100644
--- a/clippy_lints/src/utils/internal_lints/msrv_attr_impl.rs
+++ b/clippy_lints/src/utils/internal_lints/msrv_attr_impl.rs
@@ -7,7 +7,8 @@ use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_hir_analysis::hir_ty_to_ty;
 use rustc_lint::{LateContext, LateLintPass, LintContext};
-use rustc_middle::ty::{self, subst::GenericArgKind};
+use rustc_middle::ty::subst::GenericArgKind;
+use rustc_middle::ty::{self};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/visibility.rs b/clippy_lints/src/visibility.rs
index 43248bccc13..49637652001 100644
--- a/clippy_lints/src/visibility.rs
+++ b/clippy_lints/src/visibility.rs
@@ -1,10 +1,12 @@
-use clippy_utils::{diagnostics::span_lint_and_sugg, source::snippet_opt};
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet_opt;
 use rustc_ast::ast::{Item, VisibilityKind};
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::{symbol::kw, Span};
+use rustc_span::symbol::kw;
+use rustc_span::Span;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/wildcard_imports.rs b/clippy_lints/src/wildcard_imports.rs
index 2a3d86988bb..d09d02a7dfd 100644
--- a/clippy_lints/src/wildcard_imports.rs
+++ b/clippy_lints/src/wildcard_imports.rs
@@ -3,10 +3,8 @@ use clippy_utils::is_test_module_or_function;
 use clippy_utils::source::{snippet, snippet_with_applicability};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
-use rustc_hir::{
-    def::{DefKind, Res},
-    Item, ItemKind, PathSegment, UseKind,
-};
+use rustc_hir::def::{DefKind, Res};
+use rustc_hir::{Item, ItemKind, PathSegment, UseKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::ty;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
diff --git a/clippy_utils/src/attrs.rs b/clippy_utils/src/attrs.rs
index e4cc86f6800..51771f78d4f 100644
--- a/clippy_utils/src/attrs.rs
+++ b/clippy_utils/src/attrs.rs
@@ -1,5 +1,4 @@
-use rustc_ast::ast;
-use rustc_ast::attr;
+use rustc_ast::{ast, attr};
 use rustc_errors::Applicability;
 use rustc_session::Session;
 use rustc_span::sym;
diff --git a/clippy_utils/src/check_proc_macro.rs b/clippy_utils/src/check_proc_macro.rs
index 62792d60652..89f8a65c5ae 100644
--- a/clippy_utils/src/check_proc_macro.rs
+++ b/clippy_utils/src/check_proc_macro.rs
@@ -12,20 +12,20 @@
 //! code was written, and check if the span contains that text. Note this will only work correctly
 //! if the span is not from a `macro_rules` based macro.
 
-use rustc_ast::{
-    ast::{AttrKind, Attribute, IntTy, LitIntType, LitKind, StrStyle, UintTy},
-    token::CommentKind,
-    AttrStyle,
-};
+use rustc_ast::ast::{AttrKind, Attribute, IntTy, LitIntType, LitKind, StrStyle, UintTy};
+use rustc_ast::token::CommentKind;
+use rustc_ast::AttrStyle;
+use rustc_hir::intravisit::FnKind;
 use rustc_hir::{
-    intravisit::FnKind, Block, BlockCheckMode, Body, Closure, Destination, Expr, ExprKind, FieldDef, FnHeader, HirId,
-    Impl, ImplItem, ImplItemKind, IsAuto, Item, ItemKind, LoopSource, MatchSource, MutTy, Node, QPath, TraitItem,
-    TraitItemKind, Ty, TyKind, UnOp, UnsafeSource, Unsafety, Variant, VariantData, YieldSource,
+    Block, BlockCheckMode, Body, Closure, Destination, Expr, ExprKind, FieldDef, FnHeader, HirId, Impl, ImplItem,
+    ImplItemKind, IsAuto, Item, ItemKind, LoopSource, MatchSource, MutTy, Node, QPath, TraitItem, TraitItemKind, Ty,
+    TyKind, UnOp, UnsafeSource, Unsafety, Variant, VariantData, YieldSource,
 };
 use rustc_lint::{LateContext, LintContext};
 use rustc_middle::ty::TyCtxt;
 use rustc_session::Session;
-use rustc_span::{symbol::Ident, Span, Symbol};
+use rustc_span::symbol::Ident;
+use rustc_span::{Span, Symbol};
 use rustc_target::spec::abi::Abi;
 
 /// The search pattern to look for. Used by `span_matches_pat`
diff --git a/clippy_utils/src/consts.rs b/clippy_utils/src/consts.rs
index 87d85d742ce..c61dc530e13 100644
--- a/clippy_utils/src/consts.rs
+++ b/clippy_utils/src/consts.rs
@@ -9,11 +9,9 @@ use rustc_hir::def::{DefKind, Res};
 use rustc_hir::{BinOp, BinOpKind, Block, ConstBlock, Expr, ExprKind, HirId, Item, ItemKind, Node, QPath, UnOp};
 use rustc_lexer::tokenize;
 use rustc_lint::LateContext;
-use rustc_middle::mir;
 use rustc_middle::mir::interpret::Scalar;
-use rustc_middle::ty::{self, EarlyBinder, FloatTy, ScalarInt, Ty, TyCtxt};
-use rustc_middle::ty::{List, SubstsRef};
-use rustc_middle::{bug, span_bug};
+use rustc_middle::ty::{self, EarlyBinder, FloatTy, List, ScalarInt, SubstsRef, Ty, TyCtxt};
+use rustc_middle::{bug, mir, span_bug};
 use rustc_span::symbol::{Ident, Symbol};
 use rustc_span::SyntaxContext;
 use std::cmp::Ordering::{self, Equal};
diff --git a/clippy_utils/src/eager_or_lazy.rs b/clippy_utils/src/eager_or_lazy.rs
index eda739bceb5..29b73ab4cd5 100644
--- a/clippy_utils/src/eager_or_lazy.rs
+++ b/clippy_utils/src/eager_or_lazy.rs
@@ -12,14 +12,14 @@
 use crate::ty::{all_predicates_of, is_copy};
 use crate::visitors::is_const_evaluatable;
 use rustc_hir::def::{DefKind, Res};
+use rustc_hir::def_id::DefId;
 use rustc_hir::intravisit::{walk_expr, Visitor};
-use rustc_hir::{def_id::DefId, Block, Expr, ExprKind, QPath, UnOp};
+use rustc_hir::{Block, Expr, ExprKind, QPath, UnOp};
 use rustc_lint::LateContext;
 use rustc_middle::ty;
 use rustc_middle::ty::adjustment::Adjust;
 use rustc_span::{sym, Symbol};
-use std::cmp;
-use std::ops;
+use std::{cmp, ops};
 
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
 enum EagernessSuggestion {
diff --git a/clippy_utils/src/hir_utils.rs b/clippy_utils/src/hir_utils.rs
index 3e1d7356414..fb359ee3bbe 100644
--- a/clippy_utils/src/hir_utils.rs
+++ b/clippy_utils/src/hir_utils.rs
@@ -5,10 +5,9 @@ use crate::tokenize_with_text;
 use rustc_ast::ast::InlineAsmTemplatePiece;
 use rustc_data_structures::fx::FxHasher;
 use rustc_hir::def::Res;
-use rustc_hir::HirIdMap;
 use rustc_hir::{
     ArrayLen, BinOpKind, BindingAnnotation, Block, BodyId, Closure, Expr, ExprField, ExprKind, FnRetTy, GenericArg,
-    GenericArgs, Guard, HirId, InlineAsmOperand, Let, Lifetime, LifetimeName, Pat, PatField, PatKind, Path,
+    GenericArgs, Guard, HirId, HirIdMap, InlineAsmOperand, Let, Lifetime, LifetimeName, Pat, PatField, PatKind, Path,
     PathSegment, PrimTy, QPath, Stmt, StmtKind, Ty, TyKind, TypeBinding,
 };
 use rustc_lexer::{tokenize, TokenKind};
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 1ac106d5d59..5b433ed95bc 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -74,8 +74,7 @@ pub use self::hir_utils::{
 use core::ops::ControlFlow;
 use std::collections::hash_map::Entry;
 use std::hash::BuildHasherDefault;
-use std::sync::OnceLock;
-use std::sync::{Mutex, MutexGuard};
+use std::sync::{Mutex, MutexGuard, OnceLock};
 
 use if_chain::if_chain;
 use itertools::Itertools;
@@ -87,8 +86,7 @@ use rustc_hir::def::{DefKind, Res};
 use rustc_hir::def_id::{CrateNum, DefId, LocalDefId, LOCAL_CRATE};
 use rustc_hir::hir_id::{HirIdMap, HirIdSet};
 use rustc_hir::intravisit::{walk_expr, FnKind, Visitor};
-use rustc_hir::LangItem::OptionSome;
-use rustc_hir::LangItem::{OptionNone, ResultErr, ResultOk};
+use rustc_hir::LangItem::{OptionNone, OptionSome, ResultErr, ResultOk};
 use rustc_hir::{
     self as hir, def, Arm, ArrayLen, BindingAnnotation, Block, BlockCheckMode, Body, Closure, Destination, Expr,
     ExprKind, FnDecl, HirId, Impl, ImplItem, ImplItemKind, ImplItemRef, IsAsync, Item, ItemKind, LangItem, Local,
@@ -106,15 +104,14 @@ use rustc_middle::ty::fast_reject::SimplifiedType::{
     ArraySimplifiedType, BoolSimplifiedType, CharSimplifiedType, FloatSimplifiedType, IntSimplifiedType,
     PtrSimplifiedType, SliceSimplifiedType, StrSimplifiedType, UintSimplifiedType,
 };
+use rustc_middle::ty::layout::IntegerExt;
 use rustc_middle::ty::{
-    layout::IntegerExt, BorrowKind, ClosureKind, Ty, TyCtxt, TypeAndMut, TypeVisitableExt, UpvarCapture,
+    BorrowKind, ClosureKind, FloatTy, IntTy, Ty, TyCtxt, TypeAndMut, TypeVisitableExt, UintTy, UpvarCapture,
 };
-use rustc_middle::ty::{FloatTy, IntTy, UintTy};
 use rustc_span::hygiene::{ExpnKind, MacroKind};
 use rustc_span::source_map::SourceMap;
-use rustc_span::sym;
 use rustc_span::symbol::{kw, Ident, Symbol};
-use rustc_span::Span;
+use rustc_span::{sym, Span};
 use rustc_target::abi::Integer;
 
 use crate::consts::{constant, miri_to_const, Constant};
diff --git a/clippy_utils/src/mir/possible_borrower.rs b/clippy_utils/src/mir/possible_borrower.rs
index 920ce8e655b..703985b9d4b 100644
--- a/clippy_utils/src/mir/possible_borrower.rs
+++ b/clippy_utils/src/mir/possible_borrower.rs
@@ -1,11 +1,15 @@
-use super::{possible_origin::PossibleOriginVisitor, transitive_relation::TransitiveRelation};
+use super::possible_origin::PossibleOriginVisitor;
+use super::transitive_relation::TransitiveRelation;
 use crate::ty::is_copy;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_index::bit_set::{BitSet, HybridBitSet};
 use rustc_lint::LateContext;
-use rustc_middle::mir::{self, visit::Visitor as _, Mutability};
-use rustc_middle::ty::{self, visit::TypeVisitor, TyCtxt};
-use rustc_mir_dataflow::{impls::MaybeStorageLive, Analysis, ResultsCursor};
+use rustc_middle::mir::visit::Visitor as _;
+use rustc_middle::mir::{self, Mutability};
+use rustc_middle::ty::visit::TypeVisitor;
+use rustc_middle::ty::{self, TyCtxt};
+use rustc_mir_dataflow::impls::MaybeStorageLive;
+use rustc_mir_dataflow::{Analysis, ResultsCursor};
 use std::borrow::Cow;
 use std::ops::ControlFlow;
 
diff --git a/clippy_utils/src/qualify_min_const_fn.rs b/clippy_utils/src/qualify_min_const_fn.rs
index c9938caefb0..a216d8c4f91 100644
--- a/clippy_utils/src/qualify_min_const_fn.rs
+++ b/clippy_utils/src/qualify_min_const_fn.rs
@@ -15,9 +15,9 @@ use rustc_middle::mir::{
     Terminator, TerminatorKind,
 };
 use rustc_middle::traits::{ImplSource, ObligationCause};
+use rustc_middle::ty::adjustment::PointerCast;
 use rustc_middle::ty::subst::GenericArgKind;
-use rustc_middle::ty::{self, adjustment::PointerCast, Ty, TyCtxt};
-use rustc_middle::ty::{BoundConstness, TraitRef};
+use rustc_middle::ty::{self, BoundConstness, TraitRef, Ty, TyCtxt};
 use rustc_semver::RustcVersion;
 use rustc_span::symbol::sym;
 use rustc_span::Span;
diff --git a/clippy_utils/src/source.rs b/clippy_utils/src/source.rs
index 582337b47e8..dc4ee725681 100644
--- a/clippy_utils/src/source.rs
+++ b/clippy_utils/src/source.rs
@@ -8,8 +8,7 @@ use rustc_hir::{BlockCheckMode, Expr, ExprKind, UnsafeSource};
 use rustc_lint::{LateContext, LintContext};
 use rustc_session::Session;
 use rustc_span::source_map::{original_sp, SourceMap};
-use rustc_span::{hygiene, SourceFile};
-use rustc_span::{BytePos, Pos, Span, SpanData, SyntaxContext, DUMMY_SP};
+use rustc_span::{hygiene, BytePos, Pos, SourceFile, Span, SpanData, SyntaxContext, DUMMY_SP};
 use std::borrow::Cow;
 use std::ops::Range;
 
diff --git a/clippy_utils/src/ty.rs b/clippy_utils/src/ty.rs
index 9c39d22c61b..d73972b1c44 100644
--- a/clippy_utils/src/ty.rs
+++ b/clippy_utils/src/ty.rs
@@ -9,18 +9,16 @@ use rustc_hir as hir;
 use rustc_hir::def::{CtorKind, CtorOf, DefKind, Res};
 use rustc_hir::def_id::DefId;
 use rustc_hir::{Expr, FnDecl, LangItem, TyKind, Unsafety};
-use rustc_infer::infer::{
-    type_variable::{TypeVariableOrigin, TypeVariableOriginKind},
-    TyCtxtInferExt,
-};
+use rustc_infer::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKind};
+use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::LateContext;
 use rustc_middle::mir::interpret::{ConstValue, Scalar};
+use rustc_middle::ty::layout::ValidityRequirement;
 use rustc_middle::ty::{
-    self, layout::ValidityRequirement, AdtDef, AliasTy, AssocKind, Binder, BoundRegion, FnSig, IntTy, List, ParamEnv,
+    self, AdtDef, AliasTy, AssocKind, Binder, BoundRegion, FnSig, GenericArg, GenericArgKind, IntTy, List, ParamEnv,
     Region, RegionKind, SubstsRef, Ty, TyCtxt, TypeSuperVisitable, TypeVisitable, TypeVisitableExt, TypeVisitor,
     UintTy, VariantDef, VariantDiscr,
 };
-use rustc_middle::ty::{GenericArg, GenericArgKind};
 use rustc_span::symbol::Ident;
 use rustc_span::{sym, Span, Symbol, DUMMY_SP};
 use rustc_target::abi::{Size, VariantIdx};
diff --git a/clippy_utils/src/usage.rs b/clippy_utils/src/usage.rs
index 9855085216f..efb23825abb 100644
--- a/clippy_utils/src/usage.rs
+++ b/clippy_utils/src/usage.rs
@@ -1,16 +1,14 @@
-use crate as utils;
 use crate::visitors::{for_each_expr, for_each_expr_with_closures, Descend};
 use core::ops::ControlFlow;
-use rustc_hir as hir;
 use rustc_hir::intravisit::{self, Visitor};
-use rustc_hir::HirIdSet;
-use rustc_hir::{Expr, ExprKind, HirId, Node};
+use rustc_hir::{Expr, ExprKind, HirId, HirIdSet, Node};
 use rustc_hir_typeck::expr_use_visitor::{Delegate, ExprUseVisitor, PlaceBase, PlaceWithHirId};
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::LateContext;
 use rustc_middle::hir::nested_filter;
 use rustc_middle::mir::FakeReadCause;
 use rustc_middle::ty;
+use {crate as utils, rustc_hir as hir};
 
 /// Returns a set of mutated local variable IDs, or `None` if mutations could not be determined.
 pub fn mutated_variables<'tcx>(expr: &'tcx Expr<'_>, cx: &LateContext<'tcx>) -> Option<HirIdSet> {
diff --git a/lintcheck/src/config.rs b/lintcheck/src/config.rs
index 3f01e9bb0a7..e678d40795e 100644
--- a/lintcheck/src/config.rs
+++ b/lintcheck/src/config.rs
@@ -1,5 +1,6 @@
 use clap::Parser;
-use std::{num::NonZeroUsize, path::PathBuf};
+use std::num::NonZeroUsize;
+use std::path::PathBuf;
 
 #[derive(Clone, Debug, Parser)]
 pub(crate) struct LintcheckConfig {
diff --git a/lintcheck/src/main.rs b/lintcheck/src/main.rs
index de56a6f8275..3a022b343a4 100644
--- a/lintcheck/src/main.rs
+++ b/lintcheck/src/main.rs
@@ -15,16 +15,14 @@ use crate::config::LintcheckConfig;
 use crate::recursive::LintcheckServer;
 
 use std::collections::{HashMap, HashSet};
-use std::env;
 use std::env::consts::EXE_SUFFIX;
 use std::fmt::{self, Write as _};
-use std::fs;
 use std::io::{self, ErrorKind};
 use std::path::{Path, PathBuf};
 use std::process::Command;
 use std::sync::atomic::{AtomicUsize, Ordering};
-use std::thread;
 use std::time::Duration;
+use std::{env, fs, thread};
 
 use cargo_metadata::diagnostic::{Diagnostic, DiagnosticLevel};
 use cargo_metadata::Message;
diff --git a/lintcheck/src/recursive.rs b/lintcheck/src/recursive.rs
index 49072e65192..994fa3c3b23 100644
--- a/lintcheck/src/recursive.rs
+++ b/lintcheck/src/recursive.rs
@@ -3,8 +3,7 @@
 //! [`LintcheckServer`] to ask if it should be skipped, and if not sends the stderr of running
 //! clippy on the crate to the server
 
-use crate::ClippyWarning;
-use crate::RecursiveOptions;
+use crate::{ClippyWarning, RecursiveOptions};
 
 use std::collections::HashSet;
 use std::io::{BufRead, BufReader, Read, Write};
diff --git a/rustfmt.toml b/rustfmt.toml
index 18b2a33469d..4248f42f654 100644
--- a/rustfmt.toml
+++ b/rustfmt.toml
@@ -4,5 +4,6 @@ match_block_trailing_comma = true
 wrap_comments = true
 edition = "2021"
 error_on_line_overflow = true
+imports_granularity = "Module"
 version = "Two"
 ignore = ["tests/ui/crashes/ice-10912.rs"]
diff --git a/tests/ui-toml/excessive_nesting/auxiliary/proc_macros.rs b/tests/ui-toml/excessive_nesting/auxiliary/proc_macros.rs
index ebadd4e440a..60fbaaea3d3 100644
--- a/tests/ui-toml/excessive_nesting/auxiliary/proc_macros.rs
+++ b/tests/ui-toml/excessive_nesting/auxiliary/proc_macros.rs
@@ -7,13 +7,10 @@
 extern crate proc_macro;
 
 use core::mem;
-use proc_macro::{
-    token_stream::IntoIter,
-    Delimiter::{self, Brace, Parenthesis},
-    Group, Ident, Literal, Punct,
-    Spacing::{self, Alone, Joint},
-    Span, TokenStream, TokenTree as TT,
-};
+use proc_macro::token_stream::IntoIter;
+use proc_macro::Delimiter::{self, Brace, Parenthesis};
+use proc_macro::Spacing::{self, Alone, Joint};
+use proc_macro::{Group, Ident, Literal, Punct, Span, TokenStream, TokenTree as TT};
 
 type Result<T> = core::result::Result<T, TokenStream>;
 
diff --git a/tests/ui-toml/unwrap_used/unwrap_used.rs b/tests/ui-toml/unwrap_used/unwrap_used.rs
index dde1c6d7c37..e300ba18c33 100644
--- a/tests/ui-toml/unwrap_used/unwrap_used.rs
+++ b/tests/ui-toml/unwrap_used/unwrap_used.rs
@@ -9,9 +9,7 @@
 #![warn(clippy::unwrap_used)]
 #![warn(clippy::get_unwrap)]
 
-use std::collections::BTreeMap;
-use std::collections::HashMap;
-use std::collections::VecDeque;
+use std::collections::{BTreeMap, HashMap, VecDeque};
 
 struct GetFalsePositive {
     arr: [u32; 3],
diff --git a/tests/ui-toml/unwrap_used/unwrap_used.stderr b/tests/ui-toml/unwrap_used/unwrap_used.stderr
index aed29a51c1d..4c9bdfa9dba 100644
--- a/tests/ui-toml/unwrap_used/unwrap_used.stderr
+++ b/tests/ui-toml/unwrap_used/unwrap_used.stderr
@@ -1,5 +1,5 @@
 error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more concise
-  --> $DIR/unwrap_used.rs:40:17
+  --> $DIR/unwrap_used.rs:38:17
    |
 LL |         let _ = boxed_slice.get(1).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&boxed_slice[1]`
@@ -7,7 +7,7 @@ LL |         let _ = boxed_slice.get(1).unwrap();
    = note: `-D clippy::get-unwrap` implied by `-D warnings`
 
 error: used `unwrap()` on an `Option` value
-  --> $DIR/unwrap_used.rs:40:17
+  --> $DIR/unwrap_used.rs:38:17
    |
 LL |         let _ = boxed_slice.get(1).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -16,13 +16,13 @@ LL |         let _ = boxed_slice.get(1).unwrap();
    = note: `-D clippy::unwrap-used` implied by `-D warnings`
 
 error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more concise
-  --> $DIR/unwrap_used.rs:41:17
+  --> $DIR/unwrap_used.rs:39:17
    |
 LL |         let _ = some_slice.get(0).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&some_slice[0]`
 
 error: used `unwrap()` on an `Option` value
-  --> $DIR/unwrap_used.rs:41:17
+  --> $DIR/unwrap_used.rs:39:17
    |
 LL |         let _ = some_slice.get(0).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -30,13 +30,13 @@ LL |         let _ = some_slice.get(0).unwrap();
    = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
 
 error: called `.get().unwrap()` on a Vec. Using `[]` is more clear and more concise
-  --> $DIR/unwrap_used.rs:42:17
+  --> $DIR/unwrap_used.rs:40:17
    |
 LL |         let _ = some_vec.get(0).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&some_vec[0]`
 
 error: used `unwrap()` on an `Option` value
-  --> $DIR/unwrap_used.rs:42:17
+  --> $DIR/unwrap_used.rs:40:17
    |
 LL |         let _ = some_vec.get(0).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -44,13 +44,13 @@ LL |         let _ = some_vec.get(0).unwrap();
    = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
 
 error: called `.get().unwrap()` on a VecDeque. Using `[]` is more clear and more concise
-  --> $DIR/unwrap_used.rs:43:17
+  --> $DIR/unwrap_used.rs:41:17
    |
 LL |         let _ = some_vecdeque.get(0).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&some_vecdeque[0]`
 
 error: used `unwrap()` on an `Option` value
-  --> $DIR/unwrap_used.rs:43:17
+  --> $DIR/unwrap_used.rs:41:17
    |
 LL |         let _ = some_vecdeque.get(0).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -58,13 +58,13 @@ LL |         let _ = some_vecdeque.get(0).unwrap();
    = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
 
 error: called `.get().unwrap()` on a HashMap. Using `[]` is more clear and more concise
-  --> $DIR/unwrap_used.rs:44:17
+  --> $DIR/unwrap_used.rs:42:17
    |
 LL |         let _ = some_hashmap.get(&1).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&some_hashmap[&1]`
 
 error: used `unwrap()` on an `Option` value
-  --> $DIR/unwrap_used.rs:44:17
+  --> $DIR/unwrap_used.rs:42:17
    |
 LL |         let _ = some_hashmap.get(&1).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -72,13 +72,13 @@ LL |         let _ = some_hashmap.get(&1).unwrap();
    = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
 
 error: called `.get().unwrap()` on a BTreeMap. Using `[]` is more clear and more concise
-  --> $DIR/unwrap_used.rs:45:17
+  --> $DIR/unwrap_used.rs:43:17
    |
 LL |         let _ = some_btreemap.get(&1).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&some_btreemap[&1]`
 
 error: used `unwrap()` on an `Option` value
-  --> $DIR/unwrap_used.rs:45:17
+  --> $DIR/unwrap_used.rs:43:17
    |
 LL |         let _ = some_btreemap.get(&1).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -86,13 +86,13 @@ LL |         let _ = some_btreemap.get(&1).unwrap();
    = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
 
 error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more concise
-  --> $DIR/unwrap_used.rs:49:21
+  --> $DIR/unwrap_used.rs:47:21
    |
 LL |         let _: u8 = *boxed_slice.get(1).unwrap();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `boxed_slice[1]`
 
 error: used `unwrap()` on an `Option` value
-  --> $DIR/unwrap_used.rs:49:22
+  --> $DIR/unwrap_used.rs:47:22
    |
 LL |         let _: u8 = *boxed_slice.get(1).unwrap();
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -100,13 +100,13 @@ LL |         let _: u8 = *boxed_slice.get(1).unwrap();
    = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
 
 error: called `.get_mut().unwrap()` on a slice. Using `[]` is more clear and more concise
-  --> $DIR/unwrap_used.rs:54:9
+  --> $DIR/unwrap_used.rs:52:9
    |
 LL |         *boxed_slice.get_mut(0).unwrap() = 1;
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `boxed_slice[0]`
 
 error: used `unwrap()` on an `Option` value
-  --> $DIR/unwrap_used.rs:54:10
+  --> $DIR/unwrap_used.rs:52:10
    |
 LL |         *boxed_slice.get_mut(0).unwrap() = 1;
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -114,13 +114,13 @@ LL |         *boxed_slice.get_mut(0).unwrap() = 1;
    = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
 
 error: called `.get_mut().unwrap()` on a slice. Using `[]` is more clear and more concise
-  --> $DIR/unwrap_used.rs:55:9
+  --> $DIR/unwrap_used.rs:53:9
    |
 LL |         *some_slice.get_mut(0).unwrap() = 1;
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `some_slice[0]`
 
 error: used `unwrap()` on an `Option` value
-  --> $DIR/unwrap_used.rs:55:10
+  --> $DIR/unwrap_used.rs:53:10
    |
 LL |         *some_slice.get_mut(0).unwrap() = 1;
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -128,13 +128,13 @@ LL |         *some_slice.get_mut(0).unwrap() = 1;
    = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
 
 error: called `.get_mut().unwrap()` on a Vec. Using `[]` is more clear and more concise
-  --> $DIR/unwrap_used.rs:56:9
+  --> $DIR/unwrap_used.rs:54:9
    |
 LL |         *some_vec.get_mut(0).unwrap() = 1;
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `some_vec[0]`
 
 error: used `unwrap()` on an `Option` value
-  --> $DIR/unwrap_used.rs:56:10
+  --> $DIR/unwrap_used.rs:54:10
    |
 LL |         *some_vec.get_mut(0).unwrap() = 1;
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -142,13 +142,13 @@ LL |         *some_vec.get_mut(0).unwrap() = 1;
    = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
 
 error: called `.get_mut().unwrap()` on a VecDeque. Using `[]` is more clear and more concise
-  --> $DIR/unwrap_used.rs:57:9
+  --> $DIR/unwrap_used.rs:55:9
    |
 LL |         *some_vecdeque.get_mut(0).unwrap() = 1;
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `some_vecdeque[0]`
 
 error: used `unwrap()` on an `Option` value
-  --> $DIR/unwrap_used.rs:57:10
+  --> $DIR/unwrap_used.rs:55:10
    |
 LL |         *some_vecdeque.get_mut(0).unwrap() = 1;
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -156,13 +156,13 @@ LL |         *some_vecdeque.get_mut(0).unwrap() = 1;
    = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
 
 error: called `.get().unwrap()` on a Vec. Using `[]` is more clear and more concise
-  --> $DIR/unwrap_used.rs:69:17
+  --> $DIR/unwrap_used.rs:67:17
    |
 LL |         let _ = some_vec.get(0..1).unwrap().to_vec();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `some_vec[0..1]`
 
 error: used `unwrap()` on an `Option` value
-  --> $DIR/unwrap_used.rs:69:17
+  --> $DIR/unwrap_used.rs:67:17
    |
 LL |         let _ = some_vec.get(0..1).unwrap().to_vec();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -170,13 +170,13 @@ LL |         let _ = some_vec.get(0..1).unwrap().to_vec();
    = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
 
 error: called `.get_mut().unwrap()` on a Vec. Using `[]` is more clear and more concise
-  --> $DIR/unwrap_used.rs:70:17
+  --> $DIR/unwrap_used.rs:68:17
    |
 LL |         let _ = some_vec.get_mut(0..1).unwrap().to_vec();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `some_vec[0..1]`
 
 error: used `unwrap()` on an `Option` value
-  --> $DIR/unwrap_used.rs:70:17
+  --> $DIR/unwrap_used.rs:68:17
    |
 LL |         let _ = some_vec.get_mut(0..1).unwrap().to_vec();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -184,13 +184,13 @@ LL |         let _ = some_vec.get_mut(0..1).unwrap().to_vec();
    = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
 
 error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more concise
-  --> $DIR/unwrap_used.rs:77:13
+  --> $DIR/unwrap_used.rs:75:13
    |
 LL |     let _ = boxed_slice.get(1).unwrap();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&boxed_slice[1]`
 
 error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more concise
-  --> $DIR/unwrap_used.rs:95:17
+  --> $DIR/unwrap_used.rs:93:17
    |
 LL |         let _ = Box::new([0]).get(1).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&Box::new([0])[1]`
diff --git a/tests/ui/as_conversions.rs b/tests/ui/as_conversions.rs
index 427842a51d9..69f1c541c4e 100644
--- a/tests/ui/as_conversions.rs
+++ b/tests/ui/as_conversions.rs
@@ -4,8 +4,7 @@
 #![allow(clippy::borrow_as_ptr, unused)]
 
 extern crate proc_macros;
-use proc_macros::external;
-use proc_macros::with_span;
+use proc_macros::{external, with_span};
 
 fn main() {
     let i = 0u32 as u64;
diff --git a/tests/ui/as_conversions.stderr b/tests/ui/as_conversions.stderr
index ca41d1378aa..54037a64997 100644
--- a/tests/ui/as_conversions.stderr
+++ b/tests/ui/as_conversions.stderr
@@ -1,5 +1,5 @@
 error: using a potentially dangerous silent `as` conversion
-  --> $DIR/as_conversions.rs:11:13
+  --> $DIR/as_conversions.rs:10:13
    |
 LL |     let i = 0u32 as u64;
    |             ^^^^^^^^^^^
@@ -8,7 +8,7 @@ LL |     let i = 0u32 as u64;
    = note: `-D clippy::as-conversions` implied by `-D warnings`
 
 error: using a potentially dangerous silent `as` conversion
-  --> $DIR/as_conversions.rs:13:13
+  --> $DIR/as_conversions.rs:12:13
    |
 LL |     let j = &i as *const u64 as *mut u64;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -16,7 +16,7 @@ LL |     let j = &i as *const u64 as *mut u64;
    = help: consider using a safe wrapper for this conversion
 
 error: using a potentially dangerous silent `as` conversion
-  --> $DIR/as_conversions.rs:13:13
+  --> $DIR/as_conversions.rs:12:13
    |
 LL |     let j = &i as *const u64 as *mut u64;
    |             ^^^^^^^^^^^^^^^^
diff --git a/tests/ui/auxiliary/macro_use_helper.rs b/tests/ui/auxiliary/macro_use_helper.rs
index cab216b51ac..f20df6f0f09 100644
--- a/tests/ui/auxiliary/macro_use_helper.rs
+++ b/tests/ui/auxiliary/macro_use_helper.rs
@@ -15,8 +15,7 @@ pub mod inner {
 
     // RE-EXPORT
     // this will stick in `inner` module
-    pub use macro_rules::mut_mut;
-    pub use macro_rules::try_err;
+    pub use macro_rules::{mut_mut, try_err};
 
     pub mod nested {
         pub use macro_rules::string_add;
diff --git a/tests/ui/auxiliary/proc_macro_attr.rs b/tests/ui/auxiliary/proc_macro_attr.rs
index fdfe5fc4181..c5879557516 100644
--- a/tests/ui/auxiliary/proc_macro_attr.rs
+++ b/tests/ui/auxiliary/proc_macro_attr.rs
@@ -8,11 +8,11 @@ extern crate syn;
 
 use proc_macro::TokenStream;
 use quote::{quote, quote_spanned};
-use syn::parse_macro_input;
 use syn::spanned::Spanned;
 use syn::token::Star;
 use syn::{
-    parse_quote, FnArg, ImplItem, ItemImpl, ItemTrait, Lifetime, Pat, PatIdent, PatType, Signature, TraitItem, Type,
+    parse_macro_input, parse_quote, FnArg, ImplItem, ItemImpl, ItemTrait, Lifetime, Pat, PatIdent, PatType, Signature,
+    TraitItem, Type,
 };
 
 #[proc_macro_attribute]
diff --git a/tests/ui/auxiliary/proc_macros.rs b/tests/ui/auxiliary/proc_macros.rs
index 4d008c8cb59..43df654389b 100644
--- a/tests/ui/auxiliary/proc_macros.rs
+++ b/tests/ui/auxiliary/proc_macros.rs
@@ -5,13 +5,10 @@
 extern crate proc_macro;
 
 use core::mem;
-use proc_macro::{
-    token_stream::IntoIter,
-    Delimiter::{self, Brace, Parenthesis},
-    Group, Ident, Literal, Punct,
-    Spacing::{self, Alone, Joint},
-    Span, TokenStream, TokenTree as TT,
-};
+use proc_macro::token_stream::IntoIter;
+use proc_macro::Delimiter::{self, Brace, Parenthesis};
+use proc_macro::Spacing::{self, Alone, Joint};
+use proc_macro::{Group, Ident, Literal, Punct, Span, TokenStream, TokenTree as TT};
 
 type Result<T> = core::result::Result<T, TokenStream>;
 
diff --git a/tests/ui/default_trait_access.fixed b/tests/ui/default_trait_access.fixed
index 14eb6d572cf..6e541473cb3 100644
--- a/tests/ui/default_trait_access.fixed
+++ b/tests/ui/default_trait_access.fixed
@@ -7,9 +7,8 @@
 extern crate proc_macros;
 
 use proc_macros::with_span;
-use std::default;
 use std::default::Default as D2;
-use std::string;
+use std::{default, string};
 
 fn main() {
     let s1: String = String::default();
diff --git a/tests/ui/default_trait_access.rs b/tests/ui/default_trait_access.rs
index aa2ced0a7f0..2ffeb32fbdc 100644
--- a/tests/ui/default_trait_access.rs
+++ b/tests/ui/default_trait_access.rs
@@ -7,9 +7,8 @@
 extern crate proc_macros;
 
 use proc_macros::with_span;
-use std::default;
 use std::default::Default as D2;
-use std::string;
+use std::{default, string};
 
 fn main() {
     let s1: String = Default::default();
diff --git a/tests/ui/default_trait_access.stderr b/tests/ui/default_trait_access.stderr
index e4f73c08d19..103fccf6a1d 100644
--- a/tests/ui/default_trait_access.stderr
+++ b/tests/ui/default_trait_access.stderr
@@ -1,5 +1,5 @@
 error: calling `String::default()` is more clear than this expression
-  --> $DIR/default_trait_access.rs:15:22
+  --> $DIR/default_trait_access.rs:14:22
    |
 LL |     let s1: String = Default::default();
    |                      ^^^^^^^^^^^^^^^^^^ help: try: `String::default()`
@@ -11,43 +11,43 @@ LL | #![deny(clippy::default_trait_access)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: calling `String::default()` is more clear than this expression
-  --> $DIR/default_trait_access.rs:19:22
+  --> $DIR/default_trait_access.rs:18:22
    |
 LL |     let s3: String = D2::default();
    |                      ^^^^^^^^^^^^^ help: try: `String::default()`
 
 error: calling `String::default()` is more clear than this expression
-  --> $DIR/default_trait_access.rs:21:22
+  --> $DIR/default_trait_access.rs:20:22
    |
 LL |     let s4: String = std::default::Default::default();
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `String::default()`
 
 error: calling `String::default()` is more clear than this expression
-  --> $DIR/default_trait_access.rs:25:22
+  --> $DIR/default_trait_access.rs:24:22
    |
 LL |     let s6: String = default::Default::default();
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `String::default()`
 
 error: calling `GenericDerivedDefault::default()` is more clear than this expression
-  --> $DIR/default_trait_access.rs:35:46
+  --> $DIR/default_trait_access.rs:34:46
    |
 LL |     let s11: GenericDerivedDefault<String> = Default::default();
    |                                              ^^^^^^^^^^^^^^^^^^ help: try: `GenericDerivedDefault::default()`
 
 error: calling `TupleDerivedDefault::default()` is more clear than this expression
-  --> $DIR/default_trait_access.rs:41:36
+  --> $DIR/default_trait_access.rs:40:36
    |
 LL |     let s14: TupleDerivedDefault = Default::default();
    |                                    ^^^^^^^^^^^^^^^^^^ help: try: `TupleDerivedDefault::default()`
 
 error: calling `ArrayDerivedDefault::default()` is more clear than this expression
-  --> $DIR/default_trait_access.rs:43:36
+  --> $DIR/default_trait_access.rs:42:36
    |
 LL |     let s15: ArrayDerivedDefault = Default::default();
    |                                    ^^^^^^^^^^^^^^^^^^ help: try: `ArrayDerivedDefault::default()`
 
 error: calling `TupleStructDerivedDefault::default()` is more clear than this expression
-  --> $DIR/default_trait_access.rs:47:42
+  --> $DIR/default_trait_access.rs:46:42
    |
 LL |     let s17: TupleStructDerivedDefault = Default::default();
    |                                          ^^^^^^^^^^^^^^^^^^ help: try: `TupleStructDerivedDefault::default()`
diff --git a/tests/ui/get_first.fixed b/tests/ui/get_first.fixed
index a29c0918a6d..bc2f86566bc 100644
--- a/tests/ui/get_first.fixed
+++ b/tests/ui/get_first.fixed
@@ -1,9 +1,7 @@
 //@run-rustfix
 #![warn(clippy::get_first)]
 #![allow(clippy::useless_vec)]
-use std::collections::BTreeMap;
-use std::collections::HashMap;
-use std::collections::VecDeque;
+use std::collections::{BTreeMap, HashMap, VecDeque};
 
 struct Bar {
     arr: [u32; 3],
diff --git a/tests/ui/get_first.rs b/tests/ui/get_first.rs
index 2062f3ec23a..bc0e233fdee 100644
--- a/tests/ui/get_first.rs
+++ b/tests/ui/get_first.rs
@@ -1,9 +1,7 @@
 //@run-rustfix
 #![warn(clippy::get_first)]
 #![allow(clippy::useless_vec)]
-use std::collections::BTreeMap;
-use std::collections::HashMap;
-use std::collections::VecDeque;
+use std::collections::{BTreeMap, HashMap, VecDeque};
 
 struct Bar {
     arr: [u32; 3],
diff --git a/tests/ui/get_first.stderr b/tests/ui/get_first.stderr
index 4e267ba9a3b..0899a5905f3 100644
--- a/tests/ui/get_first.stderr
+++ b/tests/ui/get_first.stderr
@@ -1,5 +1,5 @@
 error: accessing first element with `x.get(0)`
-  --> $DIR/get_first.rs:20:13
+  --> $DIR/get_first.rs:18:13
    |
 LL |     let _ = x.get(0); // Use x.first()
    |             ^^^^^^^^ help: try: `x.first()`
@@ -7,13 +7,13 @@ LL |     let _ = x.get(0); // Use x.first()
    = note: `-D clippy::get-first` implied by `-D warnings`
 
 error: accessing first element with `y.get(0)`
-  --> $DIR/get_first.rs:25:13
+  --> $DIR/get_first.rs:23:13
    |
 LL |     let _ = y.get(0); // Use y.first()
    |             ^^^^^^^^ help: try: `y.first()`
 
 error: accessing first element with `z.get(0)`
-  --> $DIR/get_first.rs:30:13
+  --> $DIR/get_first.rs:28:13
    |
 LL |     let _ = z.get(0); // Use z.first()
    |             ^^^^^^^^ help: try: `z.first()`
diff --git a/tests/ui/get_unwrap.fixed b/tests/ui/get_unwrap.fixed
index 56ee37f02d2..fda334407a9 100644
--- a/tests/ui/get_unwrap.fixed
+++ b/tests/ui/get_unwrap.fixed
@@ -9,9 +9,7 @@
 #![warn(clippy::unwrap_used)]
 #![deny(clippy::get_unwrap)]
 
-use std::collections::BTreeMap;
-use std::collections::HashMap;
-use std::collections::VecDeque;
+use std::collections::{BTreeMap, HashMap, VecDeque};
 
 struct GetFalsePositive {
     arr: [u32; 3],
diff --git a/tests/ui/get_unwrap.rs b/tests/ui/get_unwrap.rs
index af3a619adc5..eaf6b005a36 100644
--- a/tests/ui/get_unwrap.rs
+++ b/tests/ui/get_unwrap.rs
@@ -9,9 +9,7 @@
 #![warn(clippy::unwrap_used)]
 #![deny(clippy::get_unwrap)]
 
-use std::collections::BTreeMap;
-use std::collections::HashMap;
-use std::collections::VecDeque;
+use std::collections::{BTreeMap, HashMap, VecDeque};
 
 struct GetFalsePositive {
     arr: [u32; 3],
diff --git a/tests/ui/get_unwrap.stderr b/tests/ui/get_unwrap.stderr
index e705bebac57..c567ed319b5 100644
--- a/tests/ui/get_unwrap.stderr
+++ b/tests/ui/get_unwrap.stderr
@@ -1,5 +1,5 @@
 error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more concise
-  --> $DIR/get_unwrap.rs:40:17
+  --> $DIR/get_unwrap.rs:38:17
    |
 LL |         let _ = boxed_slice.get(1).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&boxed_slice[1]`
@@ -11,7 +11,7 @@ LL | #![deny(clippy::get_unwrap)]
    |         ^^^^^^^^^^^^^^^^^^
 
 error: used `unwrap()` on an `Option` value
-  --> $DIR/get_unwrap.rs:40:17
+  --> $DIR/get_unwrap.rs:38:17
    |
 LL |         let _ = boxed_slice.get(1).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -20,13 +20,13 @@ LL |         let _ = boxed_slice.get(1).unwrap();
    = note: `-D clippy::unwrap-used` implied by `-D warnings`
 
 error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more concise
-  --> $DIR/get_unwrap.rs:41:17
+  --> $DIR/get_unwrap.rs:39:17
    |
 LL |         let _ = some_slice.get(0).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&some_slice[0]`
 
 error: used `unwrap()` on an `Option` value
-  --> $DIR/get_unwrap.rs:41:17
+  --> $DIR/get_unwrap.rs:39:17
    |
 LL |         let _ = some_slice.get(0).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -34,13 +34,13 @@ LL |         let _ = some_slice.get(0).unwrap();
    = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
 
 error: called `.get().unwrap()` on a Vec. Using `[]` is more clear and more concise
-  --> $DIR/get_unwrap.rs:42:17
+  --> $DIR/get_unwrap.rs:40:17
    |
 LL |         let _ = some_vec.get(0).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&some_vec[0]`
 
 error: used `unwrap()` on an `Option` value
-  --> $DIR/get_unwrap.rs:42:17
+  --> $DIR/get_unwrap.rs:40:17
    |
 LL |         let _ = some_vec.get(0).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -48,13 +48,13 @@ LL |         let _ = some_vec.get(0).unwrap();
    = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
 
 error: called `.get().unwrap()` on a VecDeque. Using `[]` is more clear and more concise
-  --> $DIR/get_unwrap.rs:43:17
+  --> $DIR/get_unwrap.rs:41:17
    |
 LL |         let _ = some_vecdeque.get(0).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&some_vecdeque[0]`
 
 error: used `unwrap()` on an `Option` value
-  --> $DIR/get_unwrap.rs:43:17
+  --> $DIR/get_unwrap.rs:41:17
    |
 LL |         let _ = some_vecdeque.get(0).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -62,13 +62,13 @@ LL |         let _ = some_vecdeque.get(0).unwrap();
    = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
 
 error: called `.get().unwrap()` on a HashMap. Using `[]` is more clear and more concise
-  --> $DIR/get_unwrap.rs:44:17
+  --> $DIR/get_unwrap.rs:42:17
    |
 LL |         let _ = some_hashmap.get(&1).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&some_hashmap[&1]`
 
 error: used `unwrap()` on an `Option` value
-  --> $DIR/get_unwrap.rs:44:17
+  --> $DIR/get_unwrap.rs:42:17
    |
 LL |         let _ = some_hashmap.get(&1).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -76,13 +76,13 @@ LL |         let _ = some_hashmap.get(&1).unwrap();
    = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
 
 error: called `.get().unwrap()` on a BTreeMap. Using `[]` is more clear and more concise
-  --> $DIR/get_unwrap.rs:45:17
+  --> $DIR/get_unwrap.rs:43:17
    |
 LL |         let _ = some_btreemap.get(&1).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&some_btreemap[&1]`
 
 error: used `unwrap()` on an `Option` value
-  --> $DIR/get_unwrap.rs:45:17
+  --> $DIR/get_unwrap.rs:43:17
    |
 LL |         let _ = some_btreemap.get(&1).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -90,13 +90,13 @@ LL |         let _ = some_btreemap.get(&1).unwrap();
    = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
 
 error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more concise
-  --> $DIR/get_unwrap.rs:49:21
+  --> $DIR/get_unwrap.rs:47:21
    |
 LL |         let _: u8 = *boxed_slice.get(1).unwrap();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `boxed_slice[1]`
 
 error: used `unwrap()` on an `Option` value
-  --> $DIR/get_unwrap.rs:49:22
+  --> $DIR/get_unwrap.rs:47:22
    |
 LL |         let _: u8 = *boxed_slice.get(1).unwrap();
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -104,13 +104,13 @@ LL |         let _: u8 = *boxed_slice.get(1).unwrap();
    = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
 
 error: called `.get_mut().unwrap()` on a slice. Using `[]` is more clear and more concise
-  --> $DIR/get_unwrap.rs:54:9
+  --> $DIR/get_unwrap.rs:52:9
    |
 LL |         *boxed_slice.get_mut(0).unwrap() = 1;
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `boxed_slice[0]`
 
 error: used `unwrap()` on an `Option` value
-  --> $DIR/get_unwrap.rs:54:10
+  --> $DIR/get_unwrap.rs:52:10
    |
 LL |         *boxed_slice.get_mut(0).unwrap() = 1;
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -118,13 +118,13 @@ LL |         *boxed_slice.get_mut(0).unwrap() = 1;
    = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
 
 error: called `.get_mut().unwrap()` on a slice. Using `[]` is more clear and more concise
-  --> $DIR/get_unwrap.rs:55:9
+  --> $DIR/get_unwrap.rs:53:9
    |
 LL |         *some_slice.get_mut(0).unwrap() = 1;
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `some_slice[0]`
 
 error: used `unwrap()` on an `Option` value
-  --> $DIR/get_unwrap.rs:55:10
+  --> $DIR/get_unwrap.rs:53:10
    |
 LL |         *some_slice.get_mut(0).unwrap() = 1;
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -132,13 +132,13 @@ LL |         *some_slice.get_mut(0).unwrap() = 1;
    = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
 
 error: called `.get_mut().unwrap()` on a Vec. Using `[]` is more clear and more concise
-  --> $DIR/get_unwrap.rs:56:9
+  --> $DIR/get_unwrap.rs:54:9
    |
 LL |         *some_vec.get_mut(0).unwrap() = 1;
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `some_vec[0]`
 
 error: used `unwrap()` on an `Option` value
-  --> $DIR/get_unwrap.rs:56:10
+  --> $DIR/get_unwrap.rs:54:10
    |
 LL |         *some_vec.get_mut(0).unwrap() = 1;
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -146,13 +146,13 @@ LL |         *some_vec.get_mut(0).unwrap() = 1;
    = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
 
 error: called `.get_mut().unwrap()` on a VecDeque. Using `[]` is more clear and more concise
-  --> $DIR/get_unwrap.rs:57:9
+  --> $DIR/get_unwrap.rs:55:9
    |
 LL |         *some_vecdeque.get_mut(0).unwrap() = 1;
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `some_vecdeque[0]`
 
 error: used `unwrap()` on an `Option` value
-  --> $DIR/get_unwrap.rs:57:10
+  --> $DIR/get_unwrap.rs:55:10
    |
 LL |         *some_vecdeque.get_mut(0).unwrap() = 1;
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -160,13 +160,13 @@ LL |         *some_vecdeque.get_mut(0).unwrap() = 1;
    = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
 
 error: called `.get().unwrap()` on a Vec. Using `[]` is more clear and more concise
-  --> $DIR/get_unwrap.rs:69:17
+  --> $DIR/get_unwrap.rs:67:17
    |
 LL |         let _ = some_vec.get(0..1).unwrap().to_vec();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `some_vec[0..1]`
 
 error: used `unwrap()` on an `Option` value
-  --> $DIR/get_unwrap.rs:69:17
+  --> $DIR/get_unwrap.rs:67:17
    |
 LL |         let _ = some_vec.get(0..1).unwrap().to_vec();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -174,13 +174,13 @@ LL |         let _ = some_vec.get(0..1).unwrap().to_vec();
    = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
 
 error: called `.get_mut().unwrap()` on a Vec. Using `[]` is more clear and more concise
-  --> $DIR/get_unwrap.rs:70:17
+  --> $DIR/get_unwrap.rs:68:17
    |
 LL |         let _ = some_vec.get_mut(0..1).unwrap().to_vec();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `some_vec[0..1]`
 
 error: used `unwrap()` on an `Option` value
-  --> $DIR/get_unwrap.rs:70:17
+  --> $DIR/get_unwrap.rs:68:17
    |
 LL |         let _ = some_vec.get_mut(0..1).unwrap().to_vec();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -188,25 +188,25 @@ LL |         let _ = some_vec.get_mut(0..1).unwrap().to_vec();
    = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
 
 error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more concise
-  --> $DIR/get_unwrap.rs:80:24
+  --> $DIR/get_unwrap.rs:78:24
    |
 LL |         let _x: &i32 = f.get(1 + 2).unwrap();
    |                        ^^^^^^^^^^^^^^^^^^^^^ help: try: `&f[1 + 2]`
 
 error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more concise
-  --> $DIR/get_unwrap.rs:83:18
+  --> $DIR/get_unwrap.rs:81:18
    |
 LL |         let _x = f.get(1 + 2).unwrap().to_string();
    |                  ^^^^^^^^^^^^^^^^^^^^^ help: try: `f[1 + 2]`
 
 error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more concise
-  --> $DIR/get_unwrap.rs:86:18
+  --> $DIR/get_unwrap.rs:84:18
    |
 LL |         let _x = f.get(1 + 2).unwrap().abs();
    |                  ^^^^^^^^^^^^^^^^^^^^^ help: try: `f[1 + 2]`
 
 error: called `.get_mut().unwrap()` on a slice. Using `[]` is more clear and more concise
-  --> $DIR/get_unwrap.rs:103:33
+  --> $DIR/get_unwrap.rs:101:33
    |
 LL |                         let b = rest.get_mut(linidx(j, k) - linidx(i, k) - 1).unwrap();
    |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&mut rest[linidx(j, k) - linidx(i, k) - 1]`
diff --git a/tests/ui/issue-7447.rs b/tests/ui/issue-7447.rs
index fdb77f32257..de4362c4df7 100644
--- a/tests/ui/issue-7447.rs
+++ b/tests/ui/issue-7447.rs
@@ -1,4 +1,7 @@
-use std::{borrow::Cow, collections::BTreeMap, marker::PhantomData, sync::Arc};
+use std::borrow::Cow;
+use std::collections::BTreeMap;
+use std::marker::PhantomData;
+use std::sync::Arc;
 
 fn byte_view<'a>(s: &'a ByteView<'_>) -> BTreeMap<&'a str, ByteView<'a>> {
     panic!()
diff --git a/tests/ui/issue-7447.stderr b/tests/ui/issue-7447.stderr
index 8d8c29f1385..7a113740c6a 100644
--- a/tests/ui/issue-7447.stderr
+++ b/tests/ui/issue-7447.stderr
@@ -1,5 +1,5 @@
 error: sub-expression diverges
-  --> $DIR/issue-7447.rs:23:15
+  --> $DIR/issue-7447.rs:26:15
    |
 LL |     byte_view(panic!());
    |               ^^^^^^^^
@@ -8,7 +8,7 @@ LL |     byte_view(panic!());
    = note: this error originates in the macro `$crate::panic::panic_2021` which comes from the expansion of the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: sub-expression diverges
-  --> $DIR/issue-7447.rs:24:19
+  --> $DIR/issue-7447.rs:27:19
    |
 LL |     group_entries(panic!());
    |                   ^^^^^^^^
diff --git a/tests/ui/iter_cloned_collect.fixed b/tests/ui/iter_cloned_collect.fixed
index 2baea06f84b..636f572a343 100644
--- a/tests/ui/iter_cloned_collect.fixed
+++ b/tests/ui/iter_cloned_collect.fixed
@@ -3,8 +3,7 @@
 #![allow(unused)]
 #![allow(clippy::useless_vec)]
 
-use std::collections::HashSet;
-use std::collections::VecDeque;
+use std::collections::{HashSet, VecDeque};
 
 fn main() {
     let v = [1, 2, 3, 4, 5];
diff --git a/tests/ui/iter_cloned_collect.rs b/tests/ui/iter_cloned_collect.rs
index 9eac94eb8d9..518cb75affe 100644
--- a/tests/ui/iter_cloned_collect.rs
+++ b/tests/ui/iter_cloned_collect.rs
@@ -3,8 +3,7 @@
 #![allow(unused)]
 #![allow(clippy::useless_vec)]
 
-use std::collections::HashSet;
-use std::collections::VecDeque;
+use std::collections::{HashSet, VecDeque};
 
 fn main() {
     let v = [1, 2, 3, 4, 5];
diff --git a/tests/ui/iter_cloned_collect.stderr b/tests/ui/iter_cloned_collect.stderr
index b38cf547dc5..b2cc497bf43 100644
--- a/tests/ui/iter_cloned_collect.stderr
+++ b/tests/ui/iter_cloned_collect.stderr
@@ -1,5 +1,5 @@
 error: called `iter().cloned().collect()` on a slice to create a `Vec`. Calling `to_vec()` is both faster and more readable
-  --> $DIR/iter_cloned_collect.rs:11:27
+  --> $DIR/iter_cloned_collect.rs:10:27
    |
 LL |     let v2: Vec<isize> = v.iter().cloned().collect();
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `.to_vec()`
@@ -7,13 +7,13 @@ LL |     let v2: Vec<isize> = v.iter().cloned().collect();
    = note: `-D clippy::iter-cloned-collect` implied by `-D warnings`
 
 error: called `iter().cloned().collect()` on a slice to create a `Vec`. Calling `to_vec()` is both faster and more readable
-  --> $DIR/iter_cloned_collect.rs:16:38
+  --> $DIR/iter_cloned_collect.rs:15:38
    |
 LL |     let _: Vec<isize> = vec![1, 2, 3].iter().cloned().collect();
    |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `.to_vec()`
 
 error: called `iter().cloned().collect()` on a slice to create a `Vec`. Calling `to_vec()` is both faster and more readable
-  --> $DIR/iter_cloned_collect.rs:21:24
+  --> $DIR/iter_cloned_collect.rs:20:24
    |
 LL |               .to_bytes()
    |  ________________________^
@@ -23,13 +23,13 @@ LL | |             .collect();
    | |______________________^ help: try: `.to_vec()`
 
 error: called `iter().cloned().collect()` on a slice to create a `Vec`. Calling `to_vec()` is both faster and more readable
-  --> $DIR/iter_cloned_collect.rs:29:24
+  --> $DIR/iter_cloned_collect.rs:28:24
    |
 LL |     let _: Vec<_> = arr.iter().cloned().collect();
    |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `.to_vec()`
 
 error: called `iter().copied().collect()` on a slice to create a `Vec`. Calling `to_vec()` is both faster and more readable
-  --> $DIR/iter_cloned_collect.rs:32:26
+  --> $DIR/iter_cloned_collect.rs:31:26
    |
 LL |     let _: Vec<isize> = v.iter().copied().collect();
    |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `.to_vec()`
diff --git a/tests/ui/let_underscore_lock.rs b/tests/ui/let_underscore_lock.rs
index 4dff4d766bc..87f12e2789f 100644
--- a/tests/ui/let_underscore_lock.rs
+++ b/tests/ui/let_underscore_lock.rs
@@ -3,7 +3,8 @@
 extern crate parking_lot;
 
 fn main() {
-    use parking_lot::{lock_api::RawMutex, Mutex, RwLock};
+    use parking_lot::lock_api::RawMutex;
+    use parking_lot::{Mutex, RwLock};
 
     let p_m: Mutex<()> = Mutex::const_new(RawMutex::INIT, ());
     let _ = p_m.lock();
diff --git a/tests/ui/let_underscore_lock.stderr b/tests/ui/let_underscore_lock.stderr
index f137d411209..5027e6b3cbc 100644
--- a/tests/ui/let_underscore_lock.stderr
+++ b/tests/ui/let_underscore_lock.stderr
@@ -1,5 +1,5 @@
 error: non-binding `let` on a synchronization lock
-  --> $DIR/let_underscore_lock.rs:9:5
+  --> $DIR/let_underscore_lock.rs:10:5
    |
 LL |     let _ = p_m.lock();
    |     ^^^^^^^^^^^^^^^^^^^
@@ -8,7 +8,7 @@ LL |     let _ = p_m.lock();
    = note: `-D clippy::let-underscore-lock` implied by `-D warnings`
 
 error: non-binding `let` on a synchronization lock
-  --> $DIR/let_underscore_lock.rs:12:5
+  --> $DIR/let_underscore_lock.rs:13:5
    |
 LL |     let _ = p_m1.lock();
    |     ^^^^^^^^^^^^^^^^^^^^
@@ -16,7 +16,7 @@ LL |     let _ = p_m1.lock();
    = help: consider using an underscore-prefixed named binding or dropping explicitly with `std::mem::drop`
 
 error: non-binding `let` on a synchronization lock
-  --> $DIR/let_underscore_lock.rs:15:5
+  --> $DIR/let_underscore_lock.rs:16:5
    |
 LL |     let _ = p_rw.read();
    |     ^^^^^^^^^^^^^^^^^^^^
@@ -24,7 +24,7 @@ LL |     let _ = p_rw.read();
    = help: consider using an underscore-prefixed named binding or dropping explicitly with `std::mem::drop`
 
 error: non-binding `let` on a synchronization lock
-  --> $DIR/let_underscore_lock.rs:16:5
+  --> $DIR/let_underscore_lock.rs:17:5
    |
 LL |     let _ = p_rw.write();
    |     ^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/let_underscore_untyped.rs b/tests/ui/let_underscore_untyped.rs
index 431d83778e3..18630c27f41 100644
--- a/tests/ui/let_underscore_untyped.rs
+++ b/tests/ui/let_underscore_untyped.rs
@@ -7,8 +7,9 @@ extern crate proc_macros;
 use proc_macros::with_span;
 
 use clippy_utils::is_from_proc_macro;
+use std::boxed::Box;
+use std::fmt::Display;
 use std::future::Future;
-use std::{boxed::Box, fmt::Display};
 
 fn a() -> u32 {
     1
diff --git a/tests/ui/let_underscore_untyped.stderr b/tests/ui/let_underscore_untyped.stderr
index bbf2508af10..e0c39b6eeaf 100644
--- a/tests/ui/let_underscore_untyped.stderr
+++ b/tests/ui/let_underscore_untyped.stderr
@@ -1,60 +1,60 @@
 error: non-binding `let` without a type annotation
-  --> $DIR/let_underscore_untyped.rs:50:5
+  --> $DIR/let_underscore_untyped.rs:51:5
    |
 LL |     let _ = a();
    |     ^^^^^^^^^^^^
    |
 help: consider adding a type annotation
-  --> $DIR/let_underscore_untyped.rs:50:10
+  --> $DIR/let_underscore_untyped.rs:51:10
    |
 LL |     let _ = a();
    |          ^
    = note: `-D clippy::let-underscore-untyped` implied by `-D warnings`
 
 error: non-binding `let` without a type annotation
-  --> $DIR/let_underscore_untyped.rs:51:5
+  --> $DIR/let_underscore_untyped.rs:52:5
    |
 LL |     let _ = b(1);
    |     ^^^^^^^^^^^^^
    |
 help: consider adding a type annotation
-  --> $DIR/let_underscore_untyped.rs:51:10
+  --> $DIR/let_underscore_untyped.rs:52:10
    |
 LL |     let _ = b(1);
    |          ^
 
 error: non-binding `let` without a type annotation
-  --> $DIR/let_underscore_untyped.rs:53:5
+  --> $DIR/let_underscore_untyped.rs:54:5
    |
 LL |     let _ = d(&1);
    |     ^^^^^^^^^^^^^^
    |
 help: consider adding a type annotation
-  --> $DIR/let_underscore_untyped.rs:53:10
+  --> $DIR/let_underscore_untyped.rs:54:10
    |
 LL |     let _ = d(&1);
    |          ^
 
 error: non-binding `let` without a type annotation
-  --> $DIR/let_underscore_untyped.rs:54:5
+  --> $DIR/let_underscore_untyped.rs:55:5
    |
 LL |     let _ = e();
    |     ^^^^^^^^^^^^
    |
 help: consider adding a type annotation
-  --> $DIR/let_underscore_untyped.rs:54:10
+  --> $DIR/let_underscore_untyped.rs:55:10
    |
 LL |     let _ = e();
    |          ^
 
 error: non-binding `let` without a type annotation
-  --> $DIR/let_underscore_untyped.rs:55:5
+  --> $DIR/let_underscore_untyped.rs:56:5
    |
 LL |     let _ = f();
    |     ^^^^^^^^^^^^
    |
 help: consider adding a type annotation
-  --> $DIR/let_underscore_untyped.rs:55:10
+  --> $DIR/let_underscore_untyped.rs:56:10
    |
 LL |     let _ = f();
    |          ^
diff --git a/tests/ui/manual_retain.fixed b/tests/ui/manual_retain.fixed
index 09fb0d75852..c95d40fecba 100644
--- a/tests/ui/manual_retain.fixed
+++ b/tests/ui/manual_retain.fixed
@@ -1,12 +1,7 @@
 //@run-rustfix
 #![warn(clippy::manual_retain)]
 #![allow(unused, clippy::redundant_clone)]
-use std::collections::BTreeMap;
-use std::collections::BTreeSet;
-use std::collections::BinaryHeap;
-use std::collections::HashMap;
-use std::collections::HashSet;
-use std::collections::VecDeque;
+use std::collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, VecDeque};
 
 fn main() {
     binary_heap_retain();
diff --git a/tests/ui/manual_retain.rs b/tests/ui/manual_retain.rs
index 7fee4c95cea..9a3434f489d 100644
--- a/tests/ui/manual_retain.rs
+++ b/tests/ui/manual_retain.rs
@@ -1,12 +1,7 @@
 //@run-rustfix
 #![warn(clippy::manual_retain)]
 #![allow(unused, clippy::redundant_clone)]
-use std::collections::BTreeMap;
-use std::collections::BTreeSet;
-use std::collections::BinaryHeap;
-use std::collections::HashMap;
-use std::collections::HashSet;
-use std::collections::VecDeque;
+use std::collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, VecDeque};
 
 fn main() {
     binary_heap_retain();
diff --git a/tests/ui/manual_retain.stderr b/tests/ui/manual_retain.stderr
index 89316ce1d99..0936a23841c 100644
--- a/tests/ui/manual_retain.stderr
+++ b/tests/ui/manual_retain.stderr
@@ -1,5 +1,5 @@
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/manual_retain.rs:51:5
+  --> $DIR/manual_retain.rs:46:5
    |
 LL |     btree_map = btree_map.into_iter().filter(|(k, _)| k % 2 == 0).collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `btree_map.retain(|k, _| k % 2 == 0)`
@@ -7,13 +7,13 @@ LL |     btree_map = btree_map.into_iter().filter(|(k, _)| k % 2 == 0).collect()
    = note: `-D clippy::manual-retain` implied by `-D warnings`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/manual_retain.rs:52:5
+  --> $DIR/manual_retain.rs:47:5
    |
 LL |     btree_map = btree_map.into_iter().filter(|(_, v)| v % 2 == 0).collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `btree_map.retain(|_, &mut v| v % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/manual_retain.rs:53:5
+  --> $DIR/manual_retain.rs:48:5
    |
 LL | /     btree_map = btree_map
 LL | |         .into_iter()
@@ -22,37 +22,37 @@ LL | |         .collect();
    | |__________________^ help: consider calling `.retain()` instead: `btree_map.retain(|k, &mut v| (k % 2 == 0) && (v % 2 == 0))`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/manual_retain.rs:75:5
+  --> $DIR/manual_retain.rs:70:5
    |
 LL |     btree_set = btree_set.iter().filter(|&x| x % 2 == 0).copied().collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `btree_set.retain(|x| x % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/manual_retain.rs:76:5
+  --> $DIR/manual_retain.rs:71:5
    |
 LL |     btree_set = btree_set.iter().filter(|&x| x % 2 == 0).cloned().collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `btree_set.retain(|x| x % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/manual_retain.rs:77:5
+  --> $DIR/manual_retain.rs:72:5
    |
 LL |     btree_set = btree_set.into_iter().filter(|x| x % 2 == 0).collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `btree_set.retain(|x| x % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/manual_retain.rs:107:5
+  --> $DIR/manual_retain.rs:102:5
    |
 LL |     hash_map = hash_map.into_iter().filter(|(k, _)| k % 2 == 0).collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `hash_map.retain(|k, _| k % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/manual_retain.rs:108:5
+  --> $DIR/manual_retain.rs:103:5
    |
 LL |     hash_map = hash_map.into_iter().filter(|(_, v)| v % 2 == 0).collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `hash_map.retain(|_, &mut v| v % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/manual_retain.rs:109:5
+  --> $DIR/manual_retain.rs:104:5
    |
 LL | /     hash_map = hash_map
 LL | |         .into_iter()
@@ -61,61 +61,61 @@ LL | |         .collect();
    | |__________________^ help: consider calling `.retain()` instead: `hash_map.retain(|k, &mut v| (k % 2 == 0) && (v % 2 == 0))`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/manual_retain.rs:130:5
+  --> $DIR/manual_retain.rs:125:5
    |
 LL |     hash_set = hash_set.into_iter().filter(|x| x % 2 == 0).collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `hash_set.retain(|x| x % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/manual_retain.rs:131:5
+  --> $DIR/manual_retain.rs:126:5
    |
 LL |     hash_set = hash_set.iter().filter(|&x| x % 2 == 0).copied().collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `hash_set.retain(|x| x % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/manual_retain.rs:132:5
+  --> $DIR/manual_retain.rs:127:5
    |
 LL |     hash_set = hash_set.iter().filter(|&x| x % 2 == 0).cloned().collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `hash_set.retain(|x| x % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/manual_retain.rs:161:5
+  --> $DIR/manual_retain.rs:156:5
    |
 LL |     s = s.chars().filter(|&c| c != 'o').to_owned().collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `s.retain(|c| c != 'o')`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/manual_retain.rs:173:5
+  --> $DIR/manual_retain.rs:168:5
    |
 LL |     vec = vec.iter().filter(|&x| x % 2 == 0).copied().collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `vec.retain(|x| x % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/manual_retain.rs:174:5
+  --> $DIR/manual_retain.rs:169:5
    |
 LL |     vec = vec.iter().filter(|&x| x % 2 == 0).cloned().collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `vec.retain(|x| x % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/manual_retain.rs:175:5
+  --> $DIR/manual_retain.rs:170:5
    |
 LL |     vec = vec.into_iter().filter(|x| x % 2 == 0).collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `vec.retain(|x| x % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/manual_retain.rs:197:5
+  --> $DIR/manual_retain.rs:192:5
    |
 LL |     vec_deque = vec_deque.iter().filter(|&x| x % 2 == 0).copied().collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `vec_deque.retain(|x| x % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/manual_retain.rs:198:5
+  --> $DIR/manual_retain.rs:193:5
    |
 LL |     vec_deque = vec_deque.iter().filter(|&x| x % 2 == 0).cloned().collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `vec_deque.retain(|x| x % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/manual_retain.rs:199:5
+  --> $DIR/manual_retain.rs:194:5
    |
 LL |     vec_deque = vec_deque.into_iter().filter(|x| x % 2 == 0).collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `vec_deque.retain(|x| x % 2 == 0)`
diff --git a/tests/ui/manual_try_fold.rs b/tests/ui/manual_try_fold.rs
index 4521e9fa1a5..05c658579a5 100644
--- a/tests/ui/manual_try_fold.rs
+++ b/tests/ui/manual_try_fold.rs
@@ -3,9 +3,7 @@
 #![warn(clippy::manual_try_fold)]
 #![feature(try_trait_v2)]
 
-use std::ops::ControlFlow;
-use std::ops::FromResidual;
-use std::ops::Try;
+use std::ops::{ControlFlow, FromResidual, Try};
 
 #[macro_use]
 extern crate proc_macros;
diff --git a/tests/ui/manual_try_fold.stderr b/tests/ui/manual_try_fold.stderr
index a0cf5b3b5fc..f1bb97c6d0f 100644
--- a/tests/ui/manual_try_fold.stderr
+++ b/tests/ui/manual_try_fold.stderr
@@ -1,5 +1,5 @@
 error: usage of `Iterator::fold` on a type that implements `Try`
-  --> $DIR/manual_try_fold.rs:61:10
+  --> $DIR/manual_try_fold.rs:59:10
    |
 LL |         .fold(Some(0i32), |sum, i| sum?.checked_add(*i))
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `try_fold` instead: `try_fold(0i32, |sum, i| ...)`
@@ -7,19 +7,19 @@ LL |         .fold(Some(0i32), |sum, i| sum?.checked_add(*i))
    = note: `-D clippy::manual-try-fold` implied by `-D warnings`
 
 error: usage of `Iterator::fold` on a type that implements `Try`
-  --> $DIR/manual_try_fold.rs:65:10
+  --> $DIR/manual_try_fold.rs:63:10
    |
 LL |         .fold(NotOption(0i32, 0i32), |sum, i| NotOption(0i32, 0i32));
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `try_fold` instead: `try_fold(..., |sum, i| ...)`
 
 error: usage of `Iterator::fold` on a type that implements `Try`
-  --> $DIR/manual_try_fold.rs:68:10
+  --> $DIR/manual_try_fold.rs:66:10
    |
 LL |         .fold(NotOptionButWorse(0i32), |sum, i| NotOptionButWorse(0i32));
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `try_fold` instead: `try_fold(0i32, |sum, i| ...)`
 
 error: usage of `Iterator::fold` on a type that implements `Try`
-  --> $DIR/manual_try_fold.rs:98:10
+  --> $DIR/manual_try_fold.rs:96:10
    |
 LL |         .fold(Some(0i32), |sum, i| sum?.checked_add(*i))
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `try_fold` instead: `try_fold(0i32, |sum, i| ...)`
diff --git a/tests/ui/match_as_ref.fixed b/tests/ui/match_as_ref.fixed
index 8fa3f532587..61d414bdf4b 100644
--- a/tests/ui/match_as_ref.fixed
+++ b/tests/ui/match_as_ref.fixed
@@ -12,7 +12,9 @@ fn match_as_ref() {
 }
 
 mod issue4437 {
-    use std::{error::Error, fmt, num::ParseIntError};
+    use std::error::Error;
+    use std::fmt;
+    use std::num::ParseIntError;
 
     #[derive(Debug)]
     struct E {
diff --git a/tests/ui/match_as_ref.rs b/tests/ui/match_as_ref.rs
index 02a17791426..cd39514c59a 100644
--- a/tests/ui/match_as_ref.rs
+++ b/tests/ui/match_as_ref.rs
@@ -18,7 +18,9 @@ fn match_as_ref() {
 }
 
 mod issue4437 {
-    use std::{error::Error, fmt, num::ParseIntError};
+    use std::error::Error;
+    use std::fmt;
+    use std::num::ParseIntError;
 
     #[derive(Debug)]
     struct E {
diff --git a/tests/ui/match_as_ref.stderr b/tests/ui/match_as_ref.stderr
index 252abf74bca..2e6955eb805 100644
--- a/tests/ui/match_as_ref.stderr
+++ b/tests/ui/match_as_ref.stderr
@@ -21,7 +21,7 @@ LL | |     };
    | |_____^ help: try: `mut_owned.as_mut()`
 
 error: use `as_ref()` instead
-  --> $DIR/match_as_ref.rs:30:13
+  --> $DIR/match_as_ref.rs:32:13
    |
 LL | /             match self.source {
 LL | |                 Some(ref s) => Some(s),
diff --git a/tests/ui/methods.rs b/tests/ui/methods.rs
index 589eab5cdfc..cb1f695c651 100644
--- a/tests/ui/methods.rs
+++ b/tests/ui/methods.rs
@@ -25,10 +25,7 @@
 #[macro_use]
 extern crate option_helpers;
 
-use std::collections::BTreeMap;
-use std::collections::HashMap;
-use std::collections::HashSet;
-use std::collections::VecDeque;
+use std::collections::{BTreeMap, HashMap, HashSet, VecDeque};
 use std::ops::Mul;
 use std::rc::{self, Rc};
 use std::sync::{self, Arc};
diff --git a/tests/ui/methods.stderr b/tests/ui/methods.stderr
index 73ec48643e0..6be38b24fbd 100644
--- a/tests/ui/methods.stderr
+++ b/tests/ui/methods.stderr
@@ -1,5 +1,5 @@
 error: methods called `new` usually return `Self`
-  --> $DIR/methods.rs:106:5
+  --> $DIR/methods.rs:103:5
    |
 LL | /     fn new() -> i32 {
 LL | |         0
@@ -9,7 +9,7 @@ LL | |     }
    = note: `-D clippy::new-ret-no-self` implied by `-D warnings`
 
 error: called `filter(..).next()` on an `Iterator`. This is more succinctly expressed by calling `.find(..)` instead
-  --> $DIR/methods.rs:127:13
+  --> $DIR/methods.rs:124:13
    |
 LL |       let _ = v.iter().filter(|&x| {
    |  _____________^
diff --git a/tests/ui/min_ident_chars.rs b/tests/ui/min_ident_chars.rs
index b5b9e66aa7a..0fab224a29d 100644
--- a/tests/ui/min_ident_chars.rs
+++ b/tests/ui/min_ident_chars.rs
@@ -3,8 +3,7 @@
 #![warn(clippy::min_ident_chars)]
 
 extern crate proc_macros;
-use proc_macros::external;
-use proc_macros::with_span;
+use proc_macros::{external, with_span};
 
 struct A {
     a: u32,
diff --git a/tests/ui/min_ident_chars.stderr b/tests/ui/min_ident_chars.stderr
index 66a63f65756..4dff6588bb1 100644
--- a/tests/ui/min_ident_chars.stderr
+++ b/tests/ui/min_ident_chars.stderr
@@ -1,5 +1,5 @@
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:9:8
+  --> $DIR/min_ident_chars.rs:8:8
    |
 LL | struct A {
    |        ^
@@ -7,169 +7,169 @@ LL | struct A {
    = note: `-D clippy::min-ident-chars` implied by `-D warnings`
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:10:5
+  --> $DIR/min_ident_chars.rs:9:5
    |
 LL |     a: u32,
    |     ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:12:5
+  --> $DIR/min_ident_chars.rs:11:5
    |
 LL |     A: u32,
    |     ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:13:5
+  --> $DIR/min_ident_chars.rs:12:5
    |
 LL |     I: u32,
    |     ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:16:8
+  --> $DIR/min_ident_chars.rs:15:8
    |
 LL | struct B(u32);
    |        ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:18:8
+  --> $DIR/min_ident_chars.rs:17:8
    |
 LL | struct O {
    |        ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:19:5
+  --> $DIR/min_ident_chars.rs:18:5
    |
 LL |     o: u32,
    |     ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:24:6
+  --> $DIR/min_ident_chars.rs:23:6
    |
 LL | enum C {
    |      ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:25:5
+  --> $DIR/min_ident_chars.rs:24:5
    |
 LL |     D,
    |     ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:26:5
+  --> $DIR/min_ident_chars.rs:25:5
    |
 LL |     E,
    |     ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:27:5
+  --> $DIR/min_ident_chars.rs:26:5
    |
 LL |     F,
    |     ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:51:9
+  --> $DIR/min_ident_chars.rs:50:9
    |
 LL |     let h = 1;
    |         ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:52:9
+  --> $DIR/min_ident_chars.rs:51:9
    |
 LL |     let e = 2;
    |         ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:53:9
+  --> $DIR/min_ident_chars.rs:52:9
    |
 LL |     let l = 3;
    |         ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:54:9
+  --> $DIR/min_ident_chars.rs:53:9
    |
 LL |     let l = 4;
    |         ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:55:9
+  --> $DIR/min_ident_chars.rs:54:9
    |
 LL |     let o = 6;
    |         ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:59:10
+  --> $DIR/min_ident_chars.rs:58:10
    |
 LL |     let (h, o, w) = (1, 2, 3);
    |          ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:59:13
+  --> $DIR/min_ident_chars.rs:58:13
    |
 LL |     let (h, o, w) = (1, 2, 3);
    |             ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:60:10
+  --> $DIR/min_ident_chars.rs:59:10
    |
 LL |     for (a, (r, e)) in (0..1000).enumerate().enumerate() {}
    |          ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:60:14
+  --> $DIR/min_ident_chars.rs:59:14
    |
 LL |     for (a, (r, e)) in (0..1000).enumerate().enumerate() {}
    |              ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:60:17
+  --> $DIR/min_ident_chars.rs:59:17
    |
 LL |     for (a, (r, e)) in (0..1000).enumerate().enumerate() {}
    |                 ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:62:16
+  --> $DIR/min_ident_chars.rs:61:16
    |
 LL |     while let (d, o, _i, n, g) = (true, true, false, false, true) {}
    |                ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:62:19
+  --> $DIR/min_ident_chars.rs:61:19
    |
 LL |     while let (d, o, _i, n, g) = (true, true, false, false, true) {}
    |                   ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:62:29
+  --> $DIR/min_ident_chars.rs:61:29
    |
 LL |     while let (d, o, _i, n, g) = (true, true, false, false, true) {}
    |                             ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:66:9
+  --> $DIR/min_ident_chars.rs:65:9
    |
 LL |     let o = 1;
    |         ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:67:9
+  --> $DIR/min_ident_chars.rs:66:9
    |
 LL |     let o = O { o };
    |         ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:81:4
+  --> $DIR/min_ident_chars.rs:80:4
    |
 LL | fn b() {}
    |    ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:82:21
+  --> $DIR/min_ident_chars.rs:81:21
    |
 LL | fn wrong_pythagoras(a: f32, b: f32) -> f32 {
    |                     ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:82:29
+  --> $DIR/min_ident_chars.rs:81:29
    |
 LL | fn wrong_pythagoras(a: f32, b: f32) -> f32 {
    |                             ^
diff --git a/tests/ui/min_max.rs b/tests/ui/min_max.rs
index 24e52afd691..1215a02286c 100644
--- a/tests/ui/min_max.rs
+++ b/tests/ui/min_max.rs
@@ -1,9 +1,7 @@
 #![warn(clippy::all)]
 #![allow(clippy::manual_clamp)]
 
-use std::cmp::max as my_max;
-use std::cmp::min as my_min;
-use std::cmp::{max, min};
+use std::cmp::{max as my_max, max, min as my_min, min};
 
 const LARGE: usize = 3;
 
diff --git a/tests/ui/min_max.stderr b/tests/ui/min_max.stderr
index 069d9068657..402b094f4f7 100644
--- a/tests/ui/min_max.stderr
+++ b/tests/ui/min_max.stderr
@@ -1,5 +1,5 @@
 error: this `min`/`max` combination leads to constant result
-  --> $DIR/min_max.rs:24:5
+  --> $DIR/min_max.rs:22:5
    |
 LL |     min(1, max(3, x));
    |     ^^^^^^^^^^^^^^^^^
@@ -7,73 +7,73 @@ LL |     min(1, max(3, x));
    = note: `-D clippy::min-max` implied by `-D warnings`
 
 error: this `min`/`max` combination leads to constant result
-  --> $DIR/min_max.rs:25:5
+  --> $DIR/min_max.rs:23:5
    |
 LL |     min(max(3, x), 1);
    |     ^^^^^^^^^^^^^^^^^
 
 error: this `min`/`max` combination leads to constant result
-  --> $DIR/min_max.rs:26:5
+  --> $DIR/min_max.rs:24:5
    |
 LL |     max(min(x, 1), 3);
    |     ^^^^^^^^^^^^^^^^^
 
 error: this `min`/`max` combination leads to constant result
-  --> $DIR/min_max.rs:27:5
+  --> $DIR/min_max.rs:25:5
    |
 LL |     max(3, min(x, 1));
    |     ^^^^^^^^^^^^^^^^^
 
 error: this `min`/`max` combination leads to constant result
-  --> $DIR/min_max.rs:29:5
+  --> $DIR/min_max.rs:27:5
    |
 LL |     my_max(3, my_min(x, 1));
    |     ^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this `min`/`max` combination leads to constant result
-  --> $DIR/min_max.rs:39:5
+  --> $DIR/min_max.rs:37:5
    |
 LL |     min("Apple", max("Zoo", s));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this `min`/`max` combination leads to constant result
-  --> $DIR/min_max.rs:40:5
+  --> $DIR/min_max.rs:38:5
    |
 LL |     max(min(s, "Apple"), "Zoo");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this `min`/`max` combination leads to constant result
-  --> $DIR/min_max.rs:45:5
+  --> $DIR/min_max.rs:43:5
    |
 LL |     x.min(1).max(3);
    |     ^^^^^^^^^^^^^^^
 
 error: this `min`/`max` combination leads to constant result
-  --> $DIR/min_max.rs:46:5
+  --> $DIR/min_max.rs:44:5
    |
 LL |     x.max(3).min(1);
    |     ^^^^^^^^^^^^^^^
 
 error: this `min`/`max` combination leads to constant result
-  --> $DIR/min_max.rs:47:5
+  --> $DIR/min_max.rs:45:5
    |
 LL |     f.max(3f32).min(1f32);
    |     ^^^^^^^^^^^^^^^^^^^^^
 
 error: this `min`/`max` combination leads to constant result
-  --> $DIR/min_max.rs:53:5
+  --> $DIR/min_max.rs:51:5
    |
 LL |     max(x.min(1), 3);
    |     ^^^^^^^^^^^^^^^^
 
 error: this `min`/`max` combination leads to constant result
-  --> $DIR/min_max.rs:56:5
+  --> $DIR/min_max.rs:54:5
    |
 LL |     s.max("Zoo").min("Apple");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this `min`/`max` combination leads to constant result
-  --> $DIR/min_max.rs:57:5
+  --> $DIR/min_max.rs:55:5
    |
 LL |     s.min("Apple").max("Zoo");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/missing_doc.rs b/tests/ui/missing_doc.rs
index cff1706a842..83ebf09c8a3 100644
--- a/tests/ui/missing_doc.rs
+++ b/tests/ui/missing_doc.rs
@@ -96,10 +96,8 @@ mod internal_impl {
 }
 /// dox
 pub mod public_interface {
-    pub use crate::internal_impl::documented as foo;
     pub use crate::internal_impl::globbed::*;
-    pub use crate::internal_impl::undocumented1 as bar;
-    pub use crate::internal_impl::{documented, undocumented2};
+    pub use crate::internal_impl::{documented as foo, documented, undocumented1 as bar, undocumented2};
 }
 
 fn main() {}
diff --git a/tests/ui/mut_key.rs b/tests/ui/mut_key.rs
index 1c0ba664580..15d68c08984 100644
--- a/tests/ui/mut_key.rs
+++ b/tests/ui/mut_key.rs
@@ -2,7 +2,8 @@ use std::cell::Cell;
 use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
 use std::hash::{Hash, Hasher};
 use std::rc::Rc;
-use std::sync::atomic::{AtomicUsize, Ordering::Relaxed};
+use std::sync::atomic::AtomicUsize;
+use std::sync::atomic::Ordering::Relaxed;
 use std::sync::Arc;
 
 struct Key(AtomicUsize);
diff --git a/tests/ui/mut_key.stderr b/tests/ui/mut_key.stderr
index fe1eeb31d07..02a0da86a4b 100644
--- a/tests/ui/mut_key.stderr
+++ b/tests/ui/mut_key.stderr
@@ -1,5 +1,5 @@
 error: mutable key type
-  --> $DIR/mut_key.rs:30:32
+  --> $DIR/mut_key.rs:31:32
    |
 LL | fn should_not_take_this_arg(m: &mut HashMap<Key, usize>, _n: usize) -> HashSet<Key> {
    |                                ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -7,13 +7,13 @@ LL | fn should_not_take_this_arg(m: &mut HashMap<Key, usize>, _n: usize) -> Hash
    = note: `-D clippy::mutable-key-type` implied by `-D warnings`
 
 error: mutable key type
-  --> $DIR/mut_key.rs:30:72
+  --> $DIR/mut_key.rs:31:72
    |
 LL | fn should_not_take_this_arg(m: &mut HashMap<Key, usize>, _n: usize) -> HashSet<Key> {
    |                                                                        ^^^^^^^^^^^^
 
 error: this argument is a mutable reference, but not used mutably
-  --> $DIR/mut_key.rs:30:32
+  --> $DIR/mut_key.rs:31:32
    |
 LL | fn should_not_take_this_arg(m: &mut HashMap<Key, usize>, _n: usize) -> HashSet<Key> {
    |                                ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider changing to: `&HashMap<Key, usize>`
@@ -21,91 +21,91 @@ LL | fn should_not_take_this_arg(m: &mut HashMap<Key, usize>, _n: usize) -> Hash
    = note: `-D clippy::needless-pass-by-ref-mut` implied by `-D warnings`
 
 error: mutable key type
-  --> $DIR/mut_key.rs:31:5
+  --> $DIR/mut_key.rs:32:5
    |
 LL |     let _other: HashMap<Key, bool> = HashMap::new();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: mutable key type
-  --> $DIR/mut_key.rs:58:22
+  --> $DIR/mut_key.rs:59:22
    |
 LL | fn tuples_bad<U>(_m: &mut HashMap<(Key, U), bool>) {}
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: mutable key type
-  --> $DIR/mut_key.rs:70:5
+  --> $DIR/mut_key.rs:71:5
    |
 LL |     let _map = HashMap::<Cell<usize>, usize>::new();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: mutable key type
-  --> $DIR/mut_key.rs:71:5
+  --> $DIR/mut_key.rs:72:5
    |
 LL |     let _map = HashMap::<&mut Cell<usize>, usize>::new();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: mutable key type
-  --> $DIR/mut_key.rs:72:5
+  --> $DIR/mut_key.rs:73:5
    |
 LL |     let _map = HashMap::<&mut usize, usize>::new();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: mutable key type
-  --> $DIR/mut_key.rs:74:5
+  --> $DIR/mut_key.rs:75:5
    |
 LL |     let _map = HashMap::<Vec<Cell<usize>>, usize>::new();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: mutable key type
-  --> $DIR/mut_key.rs:75:5
+  --> $DIR/mut_key.rs:76:5
    |
 LL |     let _map = HashMap::<BTreeMap<Cell<usize>, ()>, usize>::new();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: mutable key type
-  --> $DIR/mut_key.rs:76:5
+  --> $DIR/mut_key.rs:77:5
    |
 LL |     let _map = HashMap::<BTreeMap<(), Cell<usize>>, usize>::new();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: mutable key type
-  --> $DIR/mut_key.rs:77:5
+  --> $DIR/mut_key.rs:78:5
    |
 LL |     let _map = HashMap::<BTreeSet<Cell<usize>>, usize>::new();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: mutable key type
-  --> $DIR/mut_key.rs:78:5
+  --> $DIR/mut_key.rs:79:5
    |
 LL |     let _map = HashMap::<Option<Cell<usize>>, usize>::new();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: mutable key type
-  --> $DIR/mut_key.rs:79:5
+  --> $DIR/mut_key.rs:80:5
    |
 LL |     let _map = HashMap::<Option<Vec<Cell<usize>>>, usize>::new();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: mutable key type
-  --> $DIR/mut_key.rs:80:5
+  --> $DIR/mut_key.rs:81:5
    |
 LL |     let _map = HashMap::<Result<&mut usize, ()>, usize>::new();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: mutable key type
-  --> $DIR/mut_key.rs:82:5
+  --> $DIR/mut_key.rs:83:5
    |
 LL |     let _map = HashMap::<Box<Cell<usize>>, usize>::new();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: mutable key type
-  --> $DIR/mut_key.rs:83:5
+  --> $DIR/mut_key.rs:84:5
    |
 LL |     let _map = HashMap::<Rc<Cell<usize>>, usize>::new();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: mutable key type
-  --> $DIR/mut_key.rs:84:5
+  --> $DIR/mut_key.rs:85:5
    |
 LL |     let _map = HashMap::<Arc<Cell<usize>>, usize>::new();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/needless_if.fixed b/tests/ui/needless_if.fixed
index 5e6e140c2db..6001c9e9301 100644
--- a/tests/ui/needless_if.fixed
+++ b/tests/ui/needless_if.fixed
@@ -16,8 +16,7 @@
 #![warn(clippy::needless_if)]
 
 extern crate proc_macros;
-use proc_macros::external;
-use proc_macros::with_span;
+use proc_macros::{external, with_span};
 
 fn maybe_side_effect() -> bool {
     true
diff --git a/tests/ui/needless_if.rs b/tests/ui/needless_if.rs
index eb28ce73be8..c6be4766dd8 100644
--- a/tests/ui/needless_if.rs
+++ b/tests/ui/needless_if.rs
@@ -16,8 +16,7 @@
 #![warn(clippy::needless_if)]
 
 extern crate proc_macros;
-use proc_macros::external;
-use proc_macros::with_span;
+use proc_macros::{external, with_span};
 
 fn maybe_side_effect() -> bool {
     true
diff --git a/tests/ui/needless_if.stderr b/tests/ui/needless_if.stderr
index 5cb42c36921..14de400953b 100644
--- a/tests/ui/needless_if.stderr
+++ b/tests/ui/needless_if.stderr
@@ -1,5 +1,5 @@
 error: this `if` branch is empty
-  --> $DIR/needless_if.rs:28:5
+  --> $DIR/needless_if.rs:27:5
    |
 LL |     if (true) {}
    |     ^^^^^^^^^^^^ help: you can remove it
@@ -7,13 +7,13 @@ LL |     if (true) {}
    = note: `-D clippy::needless-if` implied by `-D warnings`
 
 error: this `if` branch is empty
-  --> $DIR/needless_if.rs:30:5
+  --> $DIR/needless_if.rs:29:5
    |
 LL |     if maybe_side_effect() {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^ help: you can remove it: `maybe_side_effect();`
 
 error: this `if` branch is empty
-  --> $DIR/needless_if.rs:35:5
+  --> $DIR/needless_if.rs:34:5
    |
 LL | /     if {
 LL | |         return;
@@ -28,7 +28,7 @@ LL +     });
    |
 
 error: this `if` branch is empty
-  --> $DIR/needless_if.rs:47:5
+  --> $DIR/needless_if.rs:46:5
    |
 LL | /     if {
 LL | |         if let true = true && true { true } else { false }
@@ -44,19 +44,19 @@ LL +     } && true);
    |
 
 error: this `if` branch is empty
-  --> $DIR/needless_if.rs:85:5
+  --> $DIR/needless_if.rs:84:5
    |
 LL |     if { maybe_side_effect() } {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: you can remove it: `({ maybe_side_effect() });`
 
 error: this `if` branch is empty
-  --> $DIR/needless_if.rs:87:5
+  --> $DIR/needless_if.rs:86:5
    |
 LL |     if { maybe_side_effect() } && true {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: you can remove it: `({ maybe_side_effect() } && true);`
 
 error: this `if` branch is empty
-  --> $DIR/needless_if.rs:91:5
+  --> $DIR/needless_if.rs:90:5
    |
 LL |     if true {}
    |     ^^^^^^^^^^ help: you can remove it: `true;`
diff --git a/tests/ui/or_fun_call.fixed b/tests/ui/or_fun_call.fixed
index 703debb7a26..6deff0f3240 100644
--- a/tests/ui/or_fun_call.fixed
+++ b/tests/ui/or_fun_call.fixed
@@ -9,8 +9,7 @@
     clippy::useless_vec
 )]
 
-use std::collections::BTreeMap;
-use std::collections::HashMap;
+use std::collections::{BTreeMap, HashMap};
 use std::time::Duration;
 
 /// Checks implementation of the `OR_FUN_CALL` lint.
diff --git a/tests/ui/or_fun_call.rs b/tests/ui/or_fun_call.rs
index bb86fe0d45f..b05b33e6ee2 100644
--- a/tests/ui/or_fun_call.rs
+++ b/tests/ui/or_fun_call.rs
@@ -9,8 +9,7 @@
     clippy::useless_vec
 )]
 
-use std::collections::BTreeMap;
-use std::collections::HashMap;
+use std::collections::{BTreeMap, HashMap};
 use std::time::Duration;
 
 /// Checks implementation of the `OR_FUN_CALL` lint.
diff --git a/tests/ui/or_fun_call.stderr b/tests/ui/or_fun_call.stderr
index 3965ae52aed..7342b0c2914 100644
--- a/tests/ui/or_fun_call.stderr
+++ b/tests/ui/or_fun_call.stderr
@@ -1,5 +1,5 @@
 error: use of `unwrap_or` followed by a function call
-  --> $DIR/or_fun_call.rs:54:22
+  --> $DIR/or_fun_call.rs:53:22
    |
 LL |     with_constructor.unwrap_or(make());
    |                      ^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(make)`
@@ -7,163 +7,163 @@ LL |     with_constructor.unwrap_or(make());
    = note: `-D clippy::or-fun-call` implied by `-D warnings`
 
 error: use of `unwrap_or` followed by a call to `new`
-  --> $DIR/or_fun_call.rs:57:14
+  --> $DIR/or_fun_call.rs:56:14
    |
 LL |     with_new.unwrap_or(Vec::new());
    |              ^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: use of `unwrap_or` followed by a function call
-  --> $DIR/or_fun_call.rs:60:21
+  --> $DIR/or_fun_call.rs:59:21
    |
 LL |     with_const_args.unwrap_or(Vec::with_capacity(12));
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| Vec::with_capacity(12))`
 
 error: use of `unwrap_or` followed by a function call
-  --> $DIR/or_fun_call.rs:63:14
+  --> $DIR/or_fun_call.rs:62:14
    |
 LL |     with_err.unwrap_or(make());
    |              ^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|_| make())`
 
 error: use of `unwrap_or` followed by a function call
-  --> $DIR/or_fun_call.rs:66:19
+  --> $DIR/or_fun_call.rs:65:19
    |
 LL |     with_err_args.unwrap_or(Vec::with_capacity(12));
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|_| Vec::with_capacity(12))`
 
 error: use of `unwrap_or` followed by a call to `default`
-  --> $DIR/or_fun_call.rs:69:24
+  --> $DIR/or_fun_call.rs:68:24
    |
 LL |     with_default_trait.unwrap_or(Default::default());
    |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: use of `unwrap_or` followed by a call to `default`
-  --> $DIR/or_fun_call.rs:72:23
+  --> $DIR/or_fun_call.rs:71:23
    |
 LL |     with_default_type.unwrap_or(u64::default());
    |                       ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: use of `unwrap_or` followed by a function call
-  --> $DIR/or_fun_call.rs:75:18
+  --> $DIR/or_fun_call.rs:74:18
    |
 LL |     self_default.unwrap_or(<FakeDefault>::default());
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(<FakeDefault>::default)`
 
 error: use of `unwrap_or` followed by a call to `default`
-  --> $DIR/or_fun_call.rs:78:18
+  --> $DIR/or_fun_call.rs:77:18
    |
 LL |     real_default.unwrap_or(<FakeDefault as Default>::default());
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: use of `unwrap_or` followed by a call to `new`
-  --> $DIR/or_fun_call.rs:81:14
+  --> $DIR/or_fun_call.rs:80:14
    |
 LL |     with_vec.unwrap_or(vec![]);
    |              ^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: use of `unwrap_or` followed by a function call
-  --> $DIR/or_fun_call.rs:84:21
+  --> $DIR/or_fun_call.rs:83:21
    |
 LL |     without_default.unwrap_or(Foo::new());
    |                     ^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(Foo::new)`
 
 error: use of `or_insert` followed by a call to `new`
-  --> $DIR/or_fun_call.rs:87:19
+  --> $DIR/or_fun_call.rs:86:19
    |
 LL |     map.entry(42).or_insert(String::new());
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `or_default()`
 
 error: use of `or_insert` followed by a call to `new`
-  --> $DIR/or_fun_call.rs:90:23
+  --> $DIR/or_fun_call.rs:89:23
    |
 LL |     map_vec.entry(42).or_insert(vec![]);
    |                       ^^^^^^^^^^^^^^^^^ help: try: `or_default()`
 
 error: use of `or_insert` followed by a call to `new`
-  --> $DIR/or_fun_call.rs:93:21
+  --> $DIR/or_fun_call.rs:92:21
    |
 LL |     btree.entry(42).or_insert(String::new());
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `or_default()`
 
 error: use of `or_insert` followed by a call to `new`
-  --> $DIR/or_fun_call.rs:96:25
+  --> $DIR/or_fun_call.rs:95:25
    |
 LL |     btree_vec.entry(42).or_insert(vec![]);
    |                         ^^^^^^^^^^^^^^^^^ help: try: `or_default()`
 
 error: use of `unwrap_or` followed by a call to `new`
-  --> $DIR/or_fun_call.rs:99:21
+  --> $DIR/or_fun_call.rs:98:21
    |
 LL |     let _ = stringy.unwrap_or(String::new());
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: use of `unwrap_or` followed by a function call
-  --> $DIR/or_fun_call.rs:107:21
+  --> $DIR/or_fun_call.rs:106:21
    |
 LL |     let _ = Some(1).unwrap_or(map[&1]);
    |                     ^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| map[&1])`
 
 error: use of `unwrap_or` followed by a function call
-  --> $DIR/or_fun_call.rs:109:21
+  --> $DIR/or_fun_call.rs:108:21
    |
 LL |     let _ = Some(1).unwrap_or(map[&1]);
    |                     ^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| map[&1])`
 
 error: use of `or` followed by a function call
-  --> $DIR/or_fun_call.rs:133:35
+  --> $DIR/or_fun_call.rs:132:35
    |
 LL |     let _ = Some("a".to_string()).or(Some("b".to_string()));
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `or_else(|| Some("b".to_string()))`
 
 error: use of `unwrap_or` followed by a function call
-  --> $DIR/or_fun_call.rs:172:14
+  --> $DIR/or_fun_call.rs:171:14
    |
 LL |         None.unwrap_or(ptr_to_ref(s));
    |              ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| ptr_to_ref(s))`
 
 error: use of `unwrap_or` followed by a function call
-  --> $DIR/or_fun_call.rs:178:14
+  --> $DIR/or_fun_call.rs:177:14
    |
 LL |         None.unwrap_or(unsafe { ptr_to_ref(s) });
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| unsafe { ptr_to_ref(s) })`
 
 error: use of `unwrap_or` followed by a function call
-  --> $DIR/or_fun_call.rs:180:14
+  --> $DIR/or_fun_call.rs:179:14
    |
 LL |         None.unwrap_or( unsafe { ptr_to_ref(s) }    );
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| unsafe { ptr_to_ref(s) })`
 
 error: use of `unwrap_or` followed by a call to `new`
-  --> $DIR/or_fun_call.rs:194:14
+  --> $DIR/or_fun_call.rs:193:14
    |
 LL |             .unwrap_or(String::new());
    |              ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: use of `unwrap_or` followed by a call to `new`
-  --> $DIR/or_fun_call.rs:207:14
+  --> $DIR/or_fun_call.rs:206:14
    |
 LL |             .unwrap_or(String::new());
    |              ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: use of `unwrap_or` followed by a call to `new`
-  --> $DIR/or_fun_call.rs:219:14
+  --> $DIR/or_fun_call.rs:218:14
    |
 LL |             .unwrap_or(String::new());
    |              ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: use of `unwrap_or` followed by a call to `new`
-  --> $DIR/or_fun_call.rs:230:10
+  --> $DIR/or_fun_call.rs:229:10
    |
 LL |         .unwrap_or(String::new());
    |          ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: use of `map_or` followed by a function call
-  --> $DIR/or_fun_call.rs:255:25
+  --> $DIR/or_fun_call.rs:254:25
    |
 LL |         let _ = Some(4).map_or(g(), |v| v);
    |                         ^^^^^^^^^^^^^^^^^^ help: try: `map_or_else(g, |v| v)`
 
 error: use of `map_or` followed by a function call
-  --> $DIR/or_fun_call.rs:256:25
+  --> $DIR/or_fun_call.rs:255:25
    |
 LL |         let _ = Some(4).map_or(g(), f);
    |                         ^^^^^^^^^^^^^^ help: try: `map_or_else(g, f)`
diff --git a/tests/ui/redundant_allocation.rs b/tests/ui/redundant_allocation.rs
index 574d34aed2d..9eb58a3e53f 100644
--- a/tests/ui/redundant_allocation.rs
+++ b/tests/ui/redundant_allocation.rs
@@ -8,8 +8,7 @@ pub struct SubT<T> {
 }
 
 mod outer_box {
-    use crate::MyStruct;
-    use crate::SubT;
+    use crate::{MyStruct, SubT};
     use std::boxed::Box;
     use std::rc::Rc;
     use std::sync::Arc;
@@ -28,8 +27,7 @@ mod outer_box {
 }
 
 mod outer_rc {
-    use crate::MyStruct;
-    use crate::SubT;
+    use crate::{MyStruct, SubT};
     use std::boxed::Box;
     use std::rc::Rc;
     use std::sync::Arc;
@@ -48,8 +46,7 @@ mod outer_rc {
 }
 
 mod outer_arc {
-    use crate::MyStruct;
-    use crate::SubT;
+    use crate::{MyStruct, SubT};
     use std::boxed::Box;
     use std::rc::Rc;
     use std::sync::Arc;
diff --git a/tests/ui/redundant_allocation.stderr b/tests/ui/redundant_allocation.stderr
index e0826fefa6c..a9a1eed702b 100644
--- a/tests/ui/redundant_allocation.stderr
+++ b/tests/ui/redundant_allocation.stderr
@@ -1,5 +1,5 @@
 error: usage of `Box<Rc<T>>`
-  --> $DIR/redundant_allocation.rs:17:30
+  --> $DIR/redundant_allocation.rs:16:30
    |
 LL |     pub fn box_test6<T>(foo: Box<Rc<T>>) {}
    |                              ^^^^^^^^^^
@@ -9,7 +9,7 @@ LL |     pub fn box_test6<T>(foo: Box<Rc<T>>) {}
    = note: `-D clippy::redundant-allocation` implied by `-D warnings`
 
 error: usage of `Box<Arc<T>>`
-  --> $DIR/redundant_allocation.rs:19:30
+  --> $DIR/redundant_allocation.rs:18:30
    |
 LL |     pub fn box_test7<T>(foo: Box<Arc<T>>) {}
    |                              ^^^^^^^^^^^
@@ -18,7 +18,7 @@ LL |     pub fn box_test7<T>(foo: Box<Arc<T>>) {}
    = help: consider using just `Box<T>` or `Arc<T>`
 
 error: usage of `Box<Rc<SubT<usize>>>`
-  --> $DIR/redundant_allocation.rs:21:27
+  --> $DIR/redundant_allocation.rs:20:27
    |
 LL |     pub fn box_test8() -> Box<Rc<SubT<usize>>> {
    |                           ^^^^^^^^^^^^^^^^^^^^
@@ -27,7 +27,7 @@ LL |     pub fn box_test8() -> Box<Rc<SubT<usize>>> {
    = help: consider using just `Box<SubT<usize>>` or `Rc<SubT<usize>>`
 
 error: usage of `Box<Arc<T>>`
-  --> $DIR/redundant_allocation.rs:25:30
+  --> $DIR/redundant_allocation.rs:24:30
    |
 LL |     pub fn box_test9<T>(foo: Box<Arc<T>>) -> Box<Arc<SubT<T>>> {
    |                              ^^^^^^^^^^^
@@ -36,7 +36,7 @@ LL |     pub fn box_test9<T>(foo: Box<Arc<T>>) -> Box<Arc<SubT<T>>> {
    = help: consider using just `Box<T>` or `Arc<T>`
 
 error: usage of `Box<Arc<SubT<T>>>`
-  --> $DIR/redundant_allocation.rs:25:46
+  --> $DIR/redundant_allocation.rs:24:46
    |
 LL |     pub fn box_test9<T>(foo: Box<Arc<T>>) -> Box<Arc<SubT<T>>> {
    |                                              ^^^^^^^^^^^^^^^^^
@@ -45,7 +45,7 @@ LL |     pub fn box_test9<T>(foo: Box<Arc<T>>) -> Box<Arc<SubT<T>>> {
    = help: consider using just `Box<SubT<T>>` or `Arc<SubT<T>>`
 
 error: usage of `Rc<Box<bool>>`
-  --> $DIR/redundant_allocation.rs:37:24
+  --> $DIR/redundant_allocation.rs:35:24
    |
 LL |     pub fn rc_test5(a: Rc<Box<bool>>) {}
    |                        ^^^^^^^^^^^^^
@@ -54,7 +54,7 @@ LL |     pub fn rc_test5(a: Rc<Box<bool>>) {}
    = help: consider using just `Rc<bool>` or `Box<bool>`
 
 error: usage of `Rc<Arc<bool>>`
-  --> $DIR/redundant_allocation.rs:39:24
+  --> $DIR/redundant_allocation.rs:37:24
    |
 LL |     pub fn rc_test7(a: Rc<Arc<bool>>) {}
    |                        ^^^^^^^^^^^^^
@@ -63,7 +63,7 @@ LL |     pub fn rc_test7(a: Rc<Arc<bool>>) {}
    = help: consider using just `Rc<bool>` or `Arc<bool>`
 
 error: usage of `Rc<Box<SubT<usize>>>`
-  --> $DIR/redundant_allocation.rs:41:26
+  --> $DIR/redundant_allocation.rs:39:26
    |
 LL |     pub fn rc_test8() -> Rc<Box<SubT<usize>>> {
    |                          ^^^^^^^^^^^^^^^^^^^^
@@ -72,7 +72,7 @@ LL |     pub fn rc_test8() -> Rc<Box<SubT<usize>>> {
    = help: consider using just `Rc<SubT<usize>>` or `Box<SubT<usize>>`
 
 error: usage of `Rc<Arc<T>>`
-  --> $DIR/redundant_allocation.rs:45:29
+  --> $DIR/redundant_allocation.rs:43:29
    |
 LL |     pub fn rc_test9<T>(foo: Rc<Arc<T>>) -> Rc<Arc<SubT<T>>> {
    |                             ^^^^^^^^^^
@@ -81,7 +81,7 @@ LL |     pub fn rc_test9<T>(foo: Rc<Arc<T>>) -> Rc<Arc<SubT<T>>> {
    = help: consider using just `Rc<T>` or `Arc<T>`
 
 error: usage of `Rc<Arc<SubT<T>>>`
-  --> $DIR/redundant_allocation.rs:45:44
+  --> $DIR/redundant_allocation.rs:43:44
    |
 LL |     pub fn rc_test9<T>(foo: Rc<Arc<T>>) -> Rc<Arc<SubT<T>>> {
    |                                            ^^^^^^^^^^^^^^^^
@@ -90,7 +90,7 @@ LL |     pub fn rc_test9<T>(foo: Rc<Arc<T>>) -> Rc<Arc<SubT<T>>> {
    = help: consider using just `Rc<SubT<T>>` or `Arc<SubT<T>>`
 
 error: usage of `Arc<Box<bool>>`
-  --> $DIR/redundant_allocation.rs:57:25
+  --> $DIR/redundant_allocation.rs:54:25
    |
 LL |     pub fn arc_test5(a: Arc<Box<bool>>) {}
    |                         ^^^^^^^^^^^^^^
@@ -99,7 +99,7 @@ LL |     pub fn arc_test5(a: Arc<Box<bool>>) {}
    = help: consider using just `Arc<bool>` or `Box<bool>`
 
 error: usage of `Arc<Rc<bool>>`
-  --> $DIR/redundant_allocation.rs:59:25
+  --> $DIR/redundant_allocation.rs:56:25
    |
 LL |     pub fn arc_test6(a: Arc<Rc<bool>>) {}
    |                         ^^^^^^^^^^^^^
@@ -108,7 +108,7 @@ LL |     pub fn arc_test6(a: Arc<Rc<bool>>) {}
    = help: consider using just `Arc<bool>` or `Rc<bool>`
 
 error: usage of `Arc<Box<SubT<usize>>>`
-  --> $DIR/redundant_allocation.rs:61:27
+  --> $DIR/redundant_allocation.rs:58:27
    |
 LL |     pub fn arc_test8() -> Arc<Box<SubT<usize>>> {
    |                           ^^^^^^^^^^^^^^^^^^^^^
@@ -117,7 +117,7 @@ LL |     pub fn arc_test8() -> Arc<Box<SubT<usize>>> {
    = help: consider using just `Arc<SubT<usize>>` or `Box<SubT<usize>>`
 
 error: usage of `Arc<Rc<T>>`
-  --> $DIR/redundant_allocation.rs:65:30
+  --> $DIR/redundant_allocation.rs:62:30
    |
 LL |     pub fn arc_test9<T>(foo: Arc<Rc<T>>) -> Arc<Rc<SubT<T>>> {
    |                              ^^^^^^^^^^
@@ -126,7 +126,7 @@ LL |     pub fn arc_test9<T>(foo: Arc<Rc<T>>) -> Arc<Rc<SubT<T>>> {
    = help: consider using just `Arc<T>` or `Rc<T>`
 
 error: usage of `Arc<Rc<SubT<T>>>`
-  --> $DIR/redundant_allocation.rs:65:45
+  --> $DIR/redundant_allocation.rs:62:45
    |
 LL |     pub fn arc_test9<T>(foo: Arc<Rc<T>>) -> Arc<Rc<SubT<T>>> {
    |                                             ^^^^^^^^^^^^^^^^
@@ -135,7 +135,7 @@ LL |     pub fn arc_test9<T>(foo: Arc<Rc<T>>) -> Arc<Rc<SubT<T>>> {
    = help: consider using just `Arc<SubT<T>>` or `Rc<SubT<T>>`
 
 error: usage of `Rc<Box<Box<dyn T>>>`
-  --> $DIR/redundant_allocation.rs:87:27
+  --> $DIR/redundant_allocation.rs:84:27
    |
 LL |     pub fn test_rc_box(_: Rc<Box<Box<dyn T>>>) {}
    |                           ^^^^^^^^^^^^^^^^^^^
@@ -144,7 +144,7 @@ LL |     pub fn test_rc_box(_: Rc<Box<Box<dyn T>>>) {}
    = help: consider using just `Rc<Box<dyn T>>` or `Box<Box<dyn T>>`
 
 error: usage of `Rc<Box<Box<str>>>`
-  --> $DIR/redundant_allocation.rs:119:31
+  --> $DIR/redundant_allocation.rs:116:31
    |
 LL |     pub fn test_rc_box_str(_: Rc<Box<Box<str>>>) {}
    |                               ^^^^^^^^^^^^^^^^^
@@ -153,7 +153,7 @@ LL |     pub fn test_rc_box_str(_: Rc<Box<Box<str>>>) {}
    = help: consider using just `Rc<Box<str>>` or `Box<Box<str>>`
 
 error: usage of `Rc<Box<Box<[usize]>>>`
-  --> $DIR/redundant_allocation.rs:120:33
+  --> $DIR/redundant_allocation.rs:117:33
    |
 LL |     pub fn test_rc_box_slice(_: Rc<Box<Box<[usize]>>>) {}
    |                                 ^^^^^^^^^^^^^^^^^^^^^
@@ -162,7 +162,7 @@ LL |     pub fn test_rc_box_slice(_: Rc<Box<Box<[usize]>>>) {}
    = help: consider using just `Rc<Box<[usize]>>` or `Box<Box<[usize]>>`
 
 error: usage of `Rc<Box<Box<Path>>>`
-  --> $DIR/redundant_allocation.rs:121:32
+  --> $DIR/redundant_allocation.rs:118:32
    |
 LL |     pub fn test_rc_box_path(_: Rc<Box<Box<Path>>>) {}
    |                                ^^^^^^^^^^^^^^^^^^
@@ -171,7 +171,7 @@ LL |     pub fn test_rc_box_path(_: Rc<Box<Box<Path>>>) {}
    = help: consider using just `Rc<Box<Path>>` or `Box<Box<Path>>`
 
 error: usage of `Rc<Box<Box<DynSized>>>`
-  --> $DIR/redundant_allocation.rs:122:34
+  --> $DIR/redundant_allocation.rs:119:34
    |
 LL |     pub fn test_rc_box_custom(_: Rc<Box<Box<DynSized>>>) {}
    |                                  ^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/redundant_allocation_fixable.fixed b/tests/ui/redundant_allocation_fixable.fixed
index edb7715f42c..b97863daf22 100644
--- a/tests/ui/redundant_allocation_fixable.fixed
+++ b/tests/ui/redundant_allocation_fixable.fixed
@@ -16,9 +16,7 @@ pub enum MyEnum {
 }
 
 mod outer_box {
-    use crate::MyEnum;
-    use crate::MyStruct;
-    use crate::SubT;
+    use crate::{MyEnum, MyStruct, SubT};
     use std::boxed::Box;
     use std::rc::Rc;
     use std::sync::Arc;
@@ -35,9 +33,7 @@ mod outer_box {
 }
 
 mod outer_rc {
-    use crate::MyEnum;
-    use crate::MyStruct;
-    use crate::SubT;
+    use crate::{MyEnum, MyStruct, SubT};
     use std::boxed::Box;
     use std::rc::Rc;
     use std::sync::Arc;
@@ -54,9 +50,7 @@ mod outer_rc {
 }
 
 mod outer_arc {
-    use crate::MyEnum;
-    use crate::MyStruct;
-    use crate::SubT;
+    use crate::{MyEnum, MyStruct, SubT};
     use std::boxed::Box;
     use std::rc::Rc;
     use std::sync::Arc;
diff --git a/tests/ui/redundant_allocation_fixable.rs b/tests/ui/redundant_allocation_fixable.rs
index c59422dd966..bffb6f8c000 100644
--- a/tests/ui/redundant_allocation_fixable.rs
+++ b/tests/ui/redundant_allocation_fixable.rs
@@ -16,9 +16,7 @@ pub enum MyEnum {
 }
 
 mod outer_box {
-    use crate::MyEnum;
-    use crate::MyStruct;
-    use crate::SubT;
+    use crate::{MyEnum, MyStruct, SubT};
     use std::boxed::Box;
     use std::rc::Rc;
     use std::sync::Arc;
@@ -35,9 +33,7 @@ mod outer_box {
 }
 
 mod outer_rc {
-    use crate::MyEnum;
-    use crate::MyStruct;
-    use crate::SubT;
+    use crate::{MyEnum, MyStruct, SubT};
     use std::boxed::Box;
     use std::rc::Rc;
     use std::sync::Arc;
@@ -54,9 +50,7 @@ mod outer_rc {
 }
 
 mod outer_arc {
-    use crate::MyEnum;
-    use crate::MyStruct;
-    use crate::SubT;
+    use crate::{MyEnum, MyStruct, SubT};
     use std::boxed::Box;
     use std::rc::Rc;
     use std::sync::Arc;
diff --git a/tests/ui/redundant_allocation_fixable.stderr b/tests/ui/redundant_allocation_fixable.stderr
index 8dd4a6a2687..524ca5bf467 100644
--- a/tests/ui/redundant_allocation_fixable.stderr
+++ b/tests/ui/redundant_allocation_fixable.stderr
@@ -1,5 +1,5 @@
 error: usage of `Box<&T>`
-  --> $DIR/redundant_allocation_fixable.rs:26:30
+  --> $DIR/redundant_allocation_fixable.rs:24:30
    |
 LL |     pub fn box_test1<T>(foo: Box<&T>) {}
    |                              ^^^^^^^ help: try: `&T`
@@ -8,7 +8,7 @@ LL |     pub fn box_test1<T>(foo: Box<&T>) {}
    = note: `-D clippy::redundant-allocation` implied by `-D warnings`
 
 error: usage of `Box<&MyStruct>`
-  --> $DIR/redundant_allocation_fixable.rs:28:27
+  --> $DIR/redundant_allocation_fixable.rs:26:27
    |
 LL |     pub fn box_test2(foo: Box<&MyStruct>) {}
    |                           ^^^^^^^^^^^^^^ help: try: `&MyStruct`
@@ -16,7 +16,7 @@ LL |     pub fn box_test2(foo: Box<&MyStruct>) {}
    = note: `&MyStruct` is already a pointer, `Box<&MyStruct>` allocates a pointer on the heap
 
 error: usage of `Box<&MyEnum>`
-  --> $DIR/redundant_allocation_fixable.rs:30:27
+  --> $DIR/redundant_allocation_fixable.rs:28:27
    |
 LL |     pub fn box_test3(foo: Box<&MyEnum>) {}
    |                           ^^^^^^^^^^^^ help: try: `&MyEnum`
@@ -24,7 +24,7 @@ LL |     pub fn box_test3(foo: Box<&MyEnum>) {}
    = note: `&MyEnum` is already a pointer, `Box<&MyEnum>` allocates a pointer on the heap
 
 error: usage of `Box<Box<T>>`
-  --> $DIR/redundant_allocation_fixable.rs:34:30
+  --> $DIR/redundant_allocation_fixable.rs:32:30
    |
 LL |     pub fn box_test5<T>(foo: Box<Box<T>>) {}
    |                              ^^^^^^^^^^^ help: try: `Box<T>`
@@ -32,7 +32,7 @@ LL |     pub fn box_test5<T>(foo: Box<Box<T>>) {}
    = note: `Box<T>` is already on the heap, `Box<Box<T>>` makes an extra allocation
 
 error: usage of `Rc<&T>`
-  --> $DIR/redundant_allocation_fixable.rs:45:29
+  --> $DIR/redundant_allocation_fixable.rs:41:29
    |
 LL |     pub fn rc_test1<T>(foo: Rc<&T>) {}
    |                             ^^^^^^ help: try: `&T`
@@ -40,7 +40,7 @@ LL |     pub fn rc_test1<T>(foo: Rc<&T>) {}
    = note: `&T` is already a pointer, `Rc<&T>` allocates a pointer on the heap
 
 error: usage of `Rc<&MyStruct>`
-  --> $DIR/redundant_allocation_fixable.rs:47:26
+  --> $DIR/redundant_allocation_fixable.rs:43:26
    |
 LL |     pub fn rc_test2(foo: Rc<&MyStruct>) {}
    |                          ^^^^^^^^^^^^^ help: try: `&MyStruct`
@@ -48,7 +48,7 @@ LL |     pub fn rc_test2(foo: Rc<&MyStruct>) {}
    = note: `&MyStruct` is already a pointer, `Rc<&MyStruct>` allocates a pointer on the heap
 
 error: usage of `Rc<&MyEnum>`
-  --> $DIR/redundant_allocation_fixable.rs:49:26
+  --> $DIR/redundant_allocation_fixable.rs:45:26
    |
 LL |     pub fn rc_test3(foo: Rc<&MyEnum>) {}
    |                          ^^^^^^^^^^^ help: try: `&MyEnum`
@@ -56,7 +56,7 @@ LL |     pub fn rc_test3(foo: Rc<&MyEnum>) {}
    = note: `&MyEnum` is already a pointer, `Rc<&MyEnum>` allocates a pointer on the heap
 
 error: usage of `Rc<Rc<bool>>`
-  --> $DIR/redundant_allocation_fixable.rs:53:24
+  --> $DIR/redundant_allocation_fixable.rs:49:24
    |
 LL |     pub fn rc_test6(a: Rc<Rc<bool>>) {}
    |                        ^^^^^^^^^^^^ help: try: `Rc<bool>`
@@ -64,7 +64,7 @@ LL |     pub fn rc_test6(a: Rc<Rc<bool>>) {}
    = note: `Rc<bool>` is already on the heap, `Rc<Rc<bool>>` makes an extra allocation
 
 error: usage of `Arc<&T>`
-  --> $DIR/redundant_allocation_fixable.rs:64:30
+  --> $DIR/redundant_allocation_fixable.rs:58:30
    |
 LL |     pub fn arc_test1<T>(foo: Arc<&T>) {}
    |                              ^^^^^^^ help: try: `&T`
@@ -72,7 +72,7 @@ LL |     pub fn arc_test1<T>(foo: Arc<&T>) {}
    = note: `&T` is already a pointer, `Arc<&T>` allocates a pointer on the heap
 
 error: usage of `Arc<&MyStruct>`
-  --> $DIR/redundant_allocation_fixable.rs:66:27
+  --> $DIR/redundant_allocation_fixable.rs:60:27
    |
 LL |     pub fn arc_test2(foo: Arc<&MyStruct>) {}
    |                           ^^^^^^^^^^^^^^ help: try: `&MyStruct`
@@ -80,7 +80,7 @@ LL |     pub fn arc_test2(foo: Arc<&MyStruct>) {}
    = note: `&MyStruct` is already a pointer, `Arc<&MyStruct>` allocates a pointer on the heap
 
 error: usage of `Arc<&MyEnum>`
-  --> $DIR/redundant_allocation_fixable.rs:68:27
+  --> $DIR/redundant_allocation_fixable.rs:62:27
    |
 LL |     pub fn arc_test3(foo: Arc<&MyEnum>) {}
    |                           ^^^^^^^^^^^^ help: try: `&MyEnum`
@@ -88,7 +88,7 @@ LL |     pub fn arc_test3(foo: Arc<&MyEnum>) {}
    = note: `&MyEnum` is already a pointer, `Arc<&MyEnum>` allocates a pointer on the heap
 
 error: usage of `Arc<Arc<bool>>`
-  --> $DIR/redundant_allocation_fixable.rs:72:25
+  --> $DIR/redundant_allocation_fixable.rs:66:25
    |
 LL |     pub fn arc_test7(a: Arc<Arc<bool>>) {}
    |                         ^^^^^^^^^^^^^^ help: try: `Arc<bool>`
diff --git a/tests/ui/redundant_pattern_matching_ipaddr.fixed b/tests/ui/redundant_pattern_matching_ipaddr.fixed
index 75ed143446c..02f197aa26a 100644
--- a/tests/ui/redundant_pattern_matching_ipaddr.fixed
+++ b/tests/ui/redundant_pattern_matching_ipaddr.fixed
@@ -8,10 +8,8 @@
     clippy::uninlined_format_args
 )]
 
-use std::net::{
-    IpAddr::{self, V4, V6},
-    Ipv4Addr, Ipv6Addr,
-};
+use std::net::IpAddr::{self, V4, V6};
+use std::net::{Ipv4Addr, Ipv6Addr};
 
 fn main() {
     let ipaddr: IpAddr = V4(Ipv4Addr::LOCALHOST);
diff --git a/tests/ui/redundant_pattern_matching_ipaddr.rs b/tests/ui/redundant_pattern_matching_ipaddr.rs
index 9ac77409f79..5c1e1810f55 100644
--- a/tests/ui/redundant_pattern_matching_ipaddr.rs
+++ b/tests/ui/redundant_pattern_matching_ipaddr.rs
@@ -8,10 +8,8 @@
     clippy::uninlined_format_args
 )]
 
-use std::net::{
-    IpAddr::{self, V4, V6},
-    Ipv4Addr, Ipv6Addr,
-};
+use std::net::IpAddr::{self, V4, V6};
+use std::net::{Ipv4Addr, Ipv6Addr};
 
 fn main() {
     let ipaddr: IpAddr = V4(Ipv4Addr::LOCALHOST);
diff --git a/tests/ui/redundant_pattern_matching_ipaddr.stderr b/tests/ui/redundant_pattern_matching_ipaddr.stderr
index f34dc709833..bec8d30884d 100644
--- a/tests/ui/redundant_pattern_matching_ipaddr.stderr
+++ b/tests/ui/redundant_pattern_matching_ipaddr.stderr
@@ -1,5 +1,5 @@
 error: redundant pattern matching, consider using `is_ipv4()`
-  --> $DIR/redundant_pattern_matching_ipaddr.rs:18:12
+  --> $DIR/redundant_pattern_matching_ipaddr.rs:16:12
    |
 LL |     if let V4(_) = &ipaddr {}
    |     -------^^^^^---------- help: try: `if ipaddr.is_ipv4()`
@@ -7,31 +7,31 @@ LL |     if let V4(_) = &ipaddr {}
    = note: `-D clippy::redundant-pattern-matching` implied by `-D warnings`
 
 error: redundant pattern matching, consider using `is_ipv4()`
-  --> $DIR/redundant_pattern_matching_ipaddr.rs:20:12
+  --> $DIR/redundant_pattern_matching_ipaddr.rs:18:12
    |
 LL |     if let V4(_) = V4(Ipv4Addr::LOCALHOST) {}
    |     -------^^^^^-------------------------- help: try: `if V4(Ipv4Addr::LOCALHOST).is_ipv4()`
 
 error: redundant pattern matching, consider using `is_ipv6()`
-  --> $DIR/redundant_pattern_matching_ipaddr.rs:22:12
+  --> $DIR/redundant_pattern_matching_ipaddr.rs:20:12
    |
 LL |     if let V6(_) = V6(Ipv6Addr::LOCALHOST) {}
    |     -------^^^^^-------------------------- help: try: `if V6(Ipv6Addr::LOCALHOST).is_ipv6()`
 
 error: redundant pattern matching, consider using `is_ipv4()`
-  --> $DIR/redundant_pattern_matching_ipaddr.rs:24:15
+  --> $DIR/redundant_pattern_matching_ipaddr.rs:22:15
    |
 LL |     while let V4(_) = V4(Ipv4Addr::LOCALHOST) {}
    |     ----------^^^^^-------------------------- help: try: `while V4(Ipv4Addr::LOCALHOST).is_ipv4()`
 
 error: redundant pattern matching, consider using `is_ipv6()`
-  --> $DIR/redundant_pattern_matching_ipaddr.rs:26:15
+  --> $DIR/redundant_pattern_matching_ipaddr.rs:24:15
    |
 LL |     while let V6(_) = V6(Ipv6Addr::LOCALHOST) {}
    |     ----------^^^^^-------------------------- help: try: `while V6(Ipv6Addr::LOCALHOST).is_ipv6()`
 
 error: redundant pattern matching, consider using `is_ipv4()`
-  --> $DIR/redundant_pattern_matching_ipaddr.rs:36:5
+  --> $DIR/redundant_pattern_matching_ipaddr.rs:34:5
    |
 LL | /     match V4(Ipv4Addr::LOCALHOST) {
 LL | |         V4(_) => true,
@@ -40,7 +40,7 @@ LL | |     };
    | |_____^ help: try: `V4(Ipv4Addr::LOCALHOST).is_ipv4()`
 
 error: redundant pattern matching, consider using `is_ipv6()`
-  --> $DIR/redundant_pattern_matching_ipaddr.rs:41:5
+  --> $DIR/redundant_pattern_matching_ipaddr.rs:39:5
    |
 LL | /     match V4(Ipv4Addr::LOCALHOST) {
 LL | |         V4(_) => false,
@@ -49,7 +49,7 @@ LL | |     };
    | |_____^ help: try: `V4(Ipv4Addr::LOCALHOST).is_ipv6()`
 
 error: redundant pattern matching, consider using `is_ipv6()`
-  --> $DIR/redundant_pattern_matching_ipaddr.rs:46:5
+  --> $DIR/redundant_pattern_matching_ipaddr.rs:44:5
    |
 LL | /     match V6(Ipv6Addr::LOCALHOST) {
 LL | |         V4(_) => false,
@@ -58,7 +58,7 @@ LL | |     };
    | |_____^ help: try: `V6(Ipv6Addr::LOCALHOST).is_ipv6()`
 
 error: redundant pattern matching, consider using `is_ipv4()`
-  --> $DIR/redundant_pattern_matching_ipaddr.rs:51:5
+  --> $DIR/redundant_pattern_matching_ipaddr.rs:49:5
    |
 LL | /     match V6(Ipv6Addr::LOCALHOST) {
 LL | |         V4(_) => true,
@@ -67,49 +67,49 @@ LL | |     };
    | |_____^ help: try: `V6(Ipv6Addr::LOCALHOST).is_ipv4()`
 
 error: redundant pattern matching, consider using `is_ipv4()`
-  --> $DIR/redundant_pattern_matching_ipaddr.rs:56:20
+  --> $DIR/redundant_pattern_matching_ipaddr.rs:54:20
    |
 LL |     let _ = if let V4(_) = V4(Ipv4Addr::LOCALHOST) {
    |             -------^^^^^-------------------------- help: try: `if V4(Ipv4Addr::LOCALHOST).is_ipv4()`
 
 error: redundant pattern matching, consider using `is_ipv4()`
-  --> $DIR/redundant_pattern_matching_ipaddr.rs:64:20
+  --> $DIR/redundant_pattern_matching_ipaddr.rs:62:20
    |
 LL |     let _ = if let V4(_) = gen_ipaddr() {
    |             -------^^^^^--------------- help: try: `if gen_ipaddr().is_ipv4()`
 
 error: redundant pattern matching, consider using `is_ipv6()`
-  --> $DIR/redundant_pattern_matching_ipaddr.rs:66:19
+  --> $DIR/redundant_pattern_matching_ipaddr.rs:64:19
    |
 LL |     } else if let V6(_) = gen_ipaddr() {
    |            -------^^^^^--------------- help: try: `if gen_ipaddr().is_ipv6()`
 
 error: redundant pattern matching, consider using `is_ipv4()`
-  --> $DIR/redundant_pattern_matching_ipaddr.rs:78:12
+  --> $DIR/redundant_pattern_matching_ipaddr.rs:76:12
    |
 LL |     if let V4(_) = V4(Ipv4Addr::LOCALHOST) {}
    |     -------^^^^^-------------------------- help: try: `if V4(Ipv4Addr::LOCALHOST).is_ipv4()`
 
 error: redundant pattern matching, consider using `is_ipv6()`
-  --> $DIR/redundant_pattern_matching_ipaddr.rs:80:12
+  --> $DIR/redundant_pattern_matching_ipaddr.rs:78:12
    |
 LL |     if let V6(_) = V6(Ipv6Addr::LOCALHOST) {}
    |     -------^^^^^-------------------------- help: try: `if V6(Ipv6Addr::LOCALHOST).is_ipv6()`
 
 error: redundant pattern matching, consider using `is_ipv4()`
-  --> $DIR/redundant_pattern_matching_ipaddr.rs:82:15
+  --> $DIR/redundant_pattern_matching_ipaddr.rs:80:15
    |
 LL |     while let V4(_) = V4(Ipv4Addr::LOCALHOST) {}
    |     ----------^^^^^-------------------------- help: try: `while V4(Ipv4Addr::LOCALHOST).is_ipv4()`
 
 error: redundant pattern matching, consider using `is_ipv6()`
-  --> $DIR/redundant_pattern_matching_ipaddr.rs:84:15
+  --> $DIR/redundant_pattern_matching_ipaddr.rs:82:15
    |
 LL |     while let V6(_) = V6(Ipv6Addr::LOCALHOST) {}
    |     ----------^^^^^-------------------------- help: try: `while V6(Ipv6Addr::LOCALHOST).is_ipv6()`
 
 error: redundant pattern matching, consider using `is_ipv4()`
-  --> $DIR/redundant_pattern_matching_ipaddr.rs:86:5
+  --> $DIR/redundant_pattern_matching_ipaddr.rs:84:5
    |
 LL | /     match V4(Ipv4Addr::LOCALHOST) {
 LL | |         V4(_) => true,
@@ -118,7 +118,7 @@ LL | |     };
    | |_____^ help: try: `V4(Ipv4Addr::LOCALHOST).is_ipv4()`
 
 error: redundant pattern matching, consider using `is_ipv6()`
-  --> $DIR/redundant_pattern_matching_ipaddr.rs:91:5
+  --> $DIR/redundant_pattern_matching_ipaddr.rs:89:5
    |
 LL | /     match V6(Ipv6Addr::LOCALHOST) {
 LL | |         V4(_) => false,
diff --git a/tests/ui/significant_drop_in_scrutinee.rs b/tests/ui/significant_drop_in_scrutinee.rs
index 8c48b21f188..17df9f88fff 100644
--- a/tests/ui/significant_drop_in_scrutinee.rs
+++ b/tests/ui/significant_drop_in_scrutinee.rs
@@ -7,8 +7,7 @@
 use std::num::ParseIntError;
 use std::ops::Deref;
 use std::sync::atomic::{AtomicU64, Ordering};
-use std::sync::RwLock;
-use std::sync::{Mutex, MutexGuard};
+use std::sync::{Mutex, MutexGuard, RwLock};
 
 struct State {}
 
diff --git a/tests/ui/significant_drop_in_scrutinee.stderr b/tests/ui/significant_drop_in_scrutinee.stderr
index 75063a8c987..b56ace200a8 100644
--- a/tests/ui/significant_drop_in_scrutinee.stderr
+++ b/tests/ui/significant_drop_in_scrutinee.stderr
@@ -1,5 +1,5 @@
 error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
-  --> $DIR/significant_drop_in_scrutinee.rs:56:11
+  --> $DIR/significant_drop_in_scrutinee.rs:55:11
    |
 LL |     match mutex.lock().unwrap().foo() {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -19,7 +19,7 @@ LL ~     match value {
    |
 
 error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
-  --> $DIR/significant_drop_in_scrutinee.rs:142:11
+  --> $DIR/significant_drop_in_scrutinee.rs:141:11
    |
 LL |     match s.lock_m().get_the_value() {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -38,7 +38,7 @@ LL ~     match value {
    |
 
 error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
-  --> $DIR/significant_drop_in_scrutinee.rs:163:11
+  --> $DIR/significant_drop_in_scrutinee.rs:162:11
    |
 LL |     match s.lock_m_m().get_the_value() {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -57,7 +57,7 @@ LL ~     match value {
    |
 
 error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
-  --> $DIR/significant_drop_in_scrutinee.rs:211:11
+  --> $DIR/significant_drop_in_scrutinee.rs:210:11
    |
 LL |     match counter.temp_increment().len() {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -73,7 +73,7 @@ LL ~     match value {
    |
 
 error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
-  --> $DIR/significant_drop_in_scrutinee.rs:234:16
+  --> $DIR/significant_drop_in_scrutinee.rs:233:16
    |
 LL |         match (mutex1.lock().unwrap().s.len(), true) {
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -92,7 +92,7 @@ LL ~         match (value, true) {
    |
 
 error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
-  --> $DIR/significant_drop_in_scrutinee.rs:243:22
+  --> $DIR/significant_drop_in_scrutinee.rs:242:22
    |
 LL |         match (true, mutex1.lock().unwrap().s.len(), true) {
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -111,7 +111,7 @@ LL ~         match (true, value, true) {
    |
 
 error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
-  --> $DIR/significant_drop_in_scrutinee.rs:253:16
+  --> $DIR/significant_drop_in_scrutinee.rs:252:16
    |
 LL |         match (mutex1.lock().unwrap().s.len(), true, mutex2.lock().unwrap().s.len()) {
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -132,7 +132,7 @@ LL ~         match (value, true, mutex2.lock().unwrap().s.len()) {
    |
 
 error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
-  --> $DIR/significant_drop_in_scrutinee.rs:253:54
+  --> $DIR/significant_drop_in_scrutinee.rs:252:54
    |
 LL |         match (mutex1.lock().unwrap().s.len(), true, mutex2.lock().unwrap().s.len()) {
    |                                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -153,7 +153,7 @@ LL ~         match (mutex1.lock().unwrap().s.len(), true, value) {
    |
 
 error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
-  --> $DIR/significant_drop_in_scrutinee.rs:264:15
+  --> $DIR/significant_drop_in_scrutinee.rs:263:15
    |
 LL |         match mutex3.lock().unwrap().s.as_str() {
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -169,7 +169,7 @@ LL |         };
    = note: this might lead to deadlocks or other unexpected behavior
 
 error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
-  --> $DIR/significant_drop_in_scrutinee.rs:274:22
+  --> $DIR/significant_drop_in_scrutinee.rs:273:22
    |
 LL |         match (true, mutex3.lock().unwrap().s.as_str()) {
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -185,7 +185,7 @@ LL |         };
    = note: this might lead to deadlocks or other unexpected behavior
 
 error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
-  --> $DIR/significant_drop_in_scrutinee.rs:293:11
+  --> $DIR/significant_drop_in_scrutinee.rs:292:11
    |
 LL |     match mutex.lock().unwrap().s.len() > 1 {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -204,7 +204,7 @@ LL ~     match value {
    |
 
 error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
-  --> $DIR/significant_drop_in_scrutinee.rs:300:11
+  --> $DIR/significant_drop_in_scrutinee.rs:299:11
    |
 LL |     match 1 < mutex.lock().unwrap().s.len() {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -223,7 +223,7 @@ LL ~     match value {
    |
 
 error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
-  --> $DIR/significant_drop_in_scrutinee.rs:318:11
+  --> $DIR/significant_drop_in_scrutinee.rs:317:11
    |
 LL |     match mutex1.lock().unwrap().s.len() < mutex2.lock().unwrap().s.len() {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -244,7 +244,7 @@ LL ~     match value {
    |
 
 error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
-  --> $DIR/significant_drop_in_scrutinee.rs:329:11
+  --> $DIR/significant_drop_in_scrutinee.rs:328:11
    |
 LL |     match mutex1.lock().unwrap().s.len() >= mutex2.lock().unwrap().s.len() {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -265,7 +265,7 @@ LL ~     match value {
    |
 
 error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
-  --> $DIR/significant_drop_in_scrutinee.rs:364:11
+  --> $DIR/significant_drop_in_scrutinee.rs:363:11
    |
 LL |     match get_mutex_guard().s.len() > 1 {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -284,7 +284,7 @@ LL ~     match value {
    |
 
 error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
-  --> $DIR/significant_drop_in_scrutinee.rs:381:11
+  --> $DIR/significant_drop_in_scrutinee.rs:380:11
    |
 LL |       match match i {
    |  ___________^
@@ -316,7 +316,7 @@ LL ~     match value
    |
 
 error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
-  --> $DIR/significant_drop_in_scrutinee.rs:407:11
+  --> $DIR/significant_drop_in_scrutinee.rs:406:11
    |
 LL |       match if i > 1 {
    |  ___________^
@@ -349,7 +349,7 @@ LL ~     match value
    |
 
 error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
-  --> $DIR/significant_drop_in_scrutinee.rs:461:11
+  --> $DIR/significant_drop_in_scrutinee.rs:460:11
    |
 LL |     match s.lock().deref().deref() {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -367,7 +367,7 @@ LL ~     match value {
    |
 
 error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
-  --> $DIR/significant_drop_in_scrutinee.rs:489:11
+  --> $DIR/significant_drop_in_scrutinee.rs:488:11
    |
 LL |     match s.lock().deref().deref() {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -380,7 +380,7 @@ LL |     };
    = note: this might lead to deadlocks or other unexpected behavior
 
 error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
-  --> $DIR/significant_drop_in_scrutinee.rs:508:11
+  --> $DIR/significant_drop_in_scrutinee.rs:507:11
    |
 LL |     match mutex.lock().unwrap().i = i {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -399,7 +399,7 @@ LL ~     match () {
    |
 
 error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
-  --> $DIR/significant_drop_in_scrutinee.rs:514:11
+  --> $DIR/significant_drop_in_scrutinee.rs:513:11
    |
 LL |     match i = mutex.lock().unwrap().i {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -418,7 +418,7 @@ LL ~     match () {
    |
 
 error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
-  --> $DIR/significant_drop_in_scrutinee.rs:520:11
+  --> $DIR/significant_drop_in_scrutinee.rs:519:11
    |
 LL |     match mutex.lock().unwrap().i += 1 {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -437,7 +437,7 @@ LL ~     match () {
    |
 
 error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
-  --> $DIR/significant_drop_in_scrutinee.rs:526:11
+  --> $DIR/significant_drop_in_scrutinee.rs:525:11
    |
 LL |     match i += mutex.lock().unwrap().i {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -456,7 +456,7 @@ LL ~     match () {
    |
 
 error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
-  --> $DIR/significant_drop_in_scrutinee.rs:589:11
+  --> $DIR/significant_drop_in_scrutinee.rs:588:11
    |
 LL |     match rwlock.read().unwrap().to_number() {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -467,7 +467,7 @@ LL |     };
    = note: this might lead to deadlocks or other unexpected behavior
 
 error: temporary with significant `Drop` in `for` loop condition will live until the end of the `for` expression
-  --> $DIR/significant_drop_in_scrutinee.rs:599:14
+  --> $DIR/significant_drop_in_scrutinee.rs:598:14
    |
 LL |     for s in rwlock.read().unwrap().iter() {
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -478,7 +478,7 @@ LL |     }
    = note: this might lead to deadlocks or other unexpected behavior
 
 error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
-  --> $DIR/significant_drop_in_scrutinee.rs:614:11
+  --> $DIR/significant_drop_in_scrutinee.rs:613:11
    |
 LL |     match mutex.lock().unwrap().foo() {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/single_component_path_imports.fixed b/tests/ui/single_component_path_imports.fixed
index d4d2cbbe57a..b6b6b0288c5 100644
--- a/tests/ui/single_component_path_imports.fixed
+++ b/tests/ui/single_component_path_imports.fixed
@@ -4,8 +4,12 @@
 
 use core;
 
+
+
 use serde as edres;
+
 pub use serde;
+
 use std;
 
 macro_rules! m {
diff --git a/tests/ui/single_component_path_imports.rs b/tests/ui/single_component_path_imports.rs
index 80d72115f43..a8c4d899085 100644
--- a/tests/ui/single_component_path_imports.rs
+++ b/tests/ui/single_component_path_imports.rs
@@ -3,9 +3,13 @@
 #![allow(unused_imports)]
 
 use core;
+
 use regex;
+
 use serde as edres;
+
 pub use serde;
+
 use std;
 
 macro_rules! m {
diff --git a/tests/ui/single_component_path_imports.stderr b/tests/ui/single_component_path_imports.stderr
index d69a86470a5..853a2fe0e7b 100644
--- a/tests/ui/single_component_path_imports.stderr
+++ b/tests/ui/single_component_path_imports.stderr
@@ -1,5 +1,5 @@
 error: this import is redundant
-  --> $DIR/single_component_path_imports.rs:6:1
+  --> $DIR/single_component_path_imports.rs:7:1
    |
 LL | use regex;
    | ^^^^^^^^^^ help: remove it entirely
@@ -7,7 +7,7 @@ LL | use regex;
    = note: `-D clippy::single-component-path-imports` implied by `-D warnings`
 
 error: this import is redundant
-  --> $DIR/single_component_path_imports.rs:29:5
+  --> $DIR/single_component_path_imports.rs:33:5
    |
 LL |     use regex;
    |     ^^^^^^^^^^ help: remove it entirely
diff --git a/tests/ui/single_component_path_imports_nested_first.rs b/tests/ui/single_component_path_imports_nested_first.rs
index c75beb74786..d6243c19f55 100644
--- a/tests/ui/single_component_path_imports_nested_first.rs
+++ b/tests/ui/single_component_path_imports_nested_first.rs
@@ -2,7 +2,9 @@
 #![allow(unused_imports)]
 
 use regex;
+
 use serde as edres;
+
 pub use serde;
 
 fn main() {
diff --git a/tests/ui/single_component_path_imports_nested_first.stderr b/tests/ui/single_component_path_imports_nested_first.stderr
index 330f285202d..ff148355e12 100644
--- a/tests/ui/single_component_path_imports_nested_first.stderr
+++ b/tests/ui/single_component_path_imports_nested_first.stderr
@@ -7,7 +7,7 @@ LL | use regex;
    = note: `-D clippy::single-component-path-imports` implied by `-D warnings`
 
 error: this import is redundant
-  --> $DIR/single_component_path_imports_nested_first.rs:13:10
+  --> $DIR/single_component_path_imports_nested_first.rs:15:10
    |
 LL |     use {regex, serde};
    |          ^^^^^
@@ -15,7 +15,7 @@ LL |     use {regex, serde};
    = help: remove this import
 
 error: this import is redundant
-  --> $DIR/single_component_path_imports_nested_first.rs:13:17
+  --> $DIR/single_component_path_imports_nested_first.rs:15:17
    |
 LL |     use {regex, serde};
    |                 ^^^^^
diff --git a/tests/ui/single_component_path_imports_self_after.rs b/tests/ui/single_component_path_imports_self_after.rs
index 48e8e530261..5723d480a2e 100644
--- a/tests/ui/single_component_path_imports_self_after.rs
+++ b/tests/ui/single_component_path_imports_self_after.rs
@@ -2,6 +2,7 @@
 #![allow(unused_imports)]
 
 use self::regex::{Regex as xeger, RegexSet as tesxeger};
+#[rustfmt::skip]
 pub use self::{
     regex::{Regex, RegexSet},
     some_mod::SomeType,
diff --git a/tests/ui/single_component_path_imports_self_before.rs b/tests/ui/single_component_path_imports_self_before.rs
index 4fb0cf40b6e..8a4fbf0dc5b 100644
--- a/tests/ui/single_component_path_imports_self_before.rs
+++ b/tests/ui/single_component_path_imports_self_before.rs
@@ -4,6 +4,7 @@
 use regex;
 
 use self::regex::{Regex as xeger, RegexSet as tesxeger};
+#[rustfmt::skip]
 pub use self::{
     regex::{Regex, RegexSet},
     some_mod::SomeType,
diff --git a/tests/ui/unnecessary_to_owned.fixed b/tests/ui/unnecessary_to_owned.fixed
index 592a53f3a81..cb7562351e8 100644
--- a/tests/ui/unnecessary_to_owned.fixed
+++ b/tests/ui/unnecessary_to_owned.fixed
@@ -477,7 +477,8 @@ mod issue_10021 {
 
 mod issue_10033 {
     #![allow(dead_code)]
-    use std::{fmt::Display, ops::Deref};
+    use std::fmt::Display;
+    use std::ops::Deref;
 
     fn _main() {
         let f = Foo;
diff --git a/tests/ui/unnecessary_to_owned.rs b/tests/ui/unnecessary_to_owned.rs
index f2e48b1c4a6..f82ddb2d25d 100644
--- a/tests/ui/unnecessary_to_owned.rs
+++ b/tests/ui/unnecessary_to_owned.rs
@@ -477,7 +477,8 @@ mod issue_10021 {
 
 mod issue_10033 {
     #![allow(dead_code)]
-    use std::{fmt::Display, ops::Deref};
+    use std::fmt::Display;
+    use std::ops::Deref;
 
     fn _main() {
         let f = Foo;
diff --git a/tests/ui/unsafe_removed_from_name.rs b/tests/ui/unsafe_removed_from_name.rs
index d29888ac62f..04f6ef29a9a 100644
--- a/tests/ui/unsafe_removed_from_name.rs
+++ b/tests/ui/unsafe_removed_from_name.rs
@@ -8,9 +8,13 @@ use std::cell::UnsafeCell as TotallySafeCellAgain;
 
 // Shouldn't error
 use std::cell::RefCell as ProbablyNotUnsafe;
+
 use std::cell::RefCell as RefCellThatCantBeUnsafe;
+
 use std::cell::UnsafeCell as SuperDangerousUnsafeCell;
+
 use std::cell::UnsafeCell as Dangerunsafe;
+
 use std::cell::UnsafeCell as Bombsawayunsafe;
 
 mod mod_with_some_unsafe_things {
@@ -20,8 +24,12 @@ mod mod_with_some_unsafe_things {
 
 use mod_with_some_unsafe_things::Unsafe as LieAboutModSafety;
 
+// merged imports
+use mod_with_some_unsafe_things::{Unsafe as A, Unsafe as B};
+
 // Shouldn't error
 use mod_with_some_unsafe_things::Safe as IPromiseItsSafeThisTime;
+
 use mod_with_some_unsafe_things::Unsafe as SuperUnsafeModThing;
 
 #[allow(clippy::unsafe_removed_from_name)]
diff --git a/tests/ui/unsafe_removed_from_name.stderr b/tests/ui/unsafe_removed_from_name.stderr
index 4f871cbe41b..090d917bd38 100644
--- a/tests/ui/unsafe_removed_from_name.stderr
+++ b/tests/ui/unsafe_removed_from_name.stderr
@@ -13,10 +13,22 @@ LL | use std::cell::UnsafeCell as TotallySafeCellAgain;
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: removed `unsafe` from the name of `Unsafe` in use as `LieAboutModSafety`
-  --> $DIR/unsafe_removed_from_name.rs:21:1
+  --> $DIR/unsafe_removed_from_name.rs:25:1
    |
 LL | use mod_with_some_unsafe_things::Unsafe as LieAboutModSafety;
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 3 previous errors
+error: removed `unsafe` from the name of `Unsafe` in use as `A`
+  --> $DIR/unsafe_removed_from_name.rs:28:1
+   |
+LL | use mod_with_some_unsafe_things::{Unsafe as A, Unsafe as B};
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: removed `unsafe` from the name of `Unsafe` in use as `B`
+  --> $DIR/unsafe_removed_from_name.rs:28:1
+   |
+LL | use mod_with_some_unsafe_things::{Unsafe as A, Unsafe as B};
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 5 previous errors
 
diff --git a/tests/ui/unused_peekable.rs b/tests/ui/unused_peekable.rs
index 7374dfdf92e..b227f8660f5 100644
--- a/tests/ui/unused_peekable.rs
+++ b/tests/ui/unused_peekable.rs
@@ -1,8 +1,7 @@
 #![warn(clippy::unused_peekable)]
 #![allow(clippy::no_effect)]
 
-use std::iter::Empty;
-use std::iter::Peekable;
+use std::iter::{Empty, Peekable};
 
 fn main() {
     invalid();
diff --git a/tests/ui/unused_peekable.stderr b/tests/ui/unused_peekable.stderr
index 54788f2fa2f..d969232fdf3 100644
--- a/tests/ui/unused_peekable.stderr
+++ b/tests/ui/unused_peekable.stderr
@@ -1,5 +1,5 @@
 error: `peek` never called on `Peekable` iterator
-  --> $DIR/unused_peekable.rs:14:9
+  --> $DIR/unused_peekable.rs:13:9
    |
 LL |     let peekable = std::iter::empty::<u32>().peekable();
    |         ^^^^^^^^
@@ -8,7 +8,7 @@ LL |     let peekable = std::iter::empty::<u32>().peekable();
    = note: `-D clippy::unused-peekable` implied by `-D warnings`
 
 error: `peek` never called on `Peekable` iterator
-  --> $DIR/unused_peekable.rs:18:9
+  --> $DIR/unused_peekable.rs:17:9
    |
 LL |     let new_local = old_local;
    |         ^^^^^^^^^
@@ -16,7 +16,7 @@ LL |     let new_local = old_local;
    = help: consider removing the call to `peekable`
 
 error: `peek` never called on `Peekable` iterator
-  --> $DIR/unused_peekable.rs:22:9
+  --> $DIR/unused_peekable.rs:21:9
    |
 LL |     let by_mut_ref = &mut by_mut_ref_test;
    |         ^^^^^^^^^^
@@ -24,7 +24,7 @@ LL |     let by_mut_ref = &mut by_mut_ref_test;
    = help: consider removing the call to `peekable`
 
 error: `peek` never called on `Peekable` iterator
-  --> $DIR/unused_peekable.rs:29:9
+  --> $DIR/unused_peekable.rs:28:9
    |
 LL |     let peekable_from_fn = returns_peekable();
    |         ^^^^^^^^^^^^^^^^
@@ -32,7 +32,7 @@ LL |     let peekable_from_fn = returns_peekable();
    = help: consider removing the call to `peekable`
 
 error: `peek` never called on `Peekable` iterator
-  --> $DIR/unused_peekable.rs:32:13
+  --> $DIR/unused_peekable.rs:31:13
    |
 LL |     let mut peekable_using_iterator_method = std::iter::empty::<u32>().peekable();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -40,7 +40,7 @@ LL |     let mut peekable_using_iterator_method = std::iter::empty::<u32>().peek
    = help: consider removing the call to `peekable`
 
 error: `peek` never called on `Peekable` iterator
-  --> $DIR/unused_peekable.rs:37:9
+  --> $DIR/unused_peekable.rs:36:9
    |
 LL |     let passed_along_ref = std::iter::empty::<u32>().peekable();
    |         ^^^^^^^^^^^^^^^^
@@ -48,7 +48,7 @@ LL |     let passed_along_ref = std::iter::empty::<u32>().peekable();
    = help: consider removing the call to `peekable`
 
 error: `peek` never called on `Peekable` iterator
-  --> $DIR/unused_peekable.rs:42:9
+  --> $DIR/unused_peekable.rs:41:9
    |
 LL |     let _by_ref = by_ref_test.by_ref();
    |         ^^^^^^^
@@ -56,7 +56,7 @@ LL |     let _by_ref = by_ref_test.by_ref();
    = help: consider removing the call to `peekable`
 
 error: `peek` never called on `Peekable` iterator
-  --> $DIR/unused_peekable.rs:44:13
+  --> $DIR/unused_peekable.rs:43:13
    |
 LL |     let mut peekable_in_for_loop = std::iter::empty::<u32>().peekable();
    |             ^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/wildcard_imports.fixed b/tests/ui/wildcard_imports.fixed
index 2961b062ec3..67173f40654 100644
--- a/tests/ui/wildcard_imports.fixed
+++ b/tests/ui/wildcard_imports.fixed
@@ -112,6 +112,7 @@ mod in_fn_test {
     }
 
     fn test_inner_nested() {
+        #[rustfmt::skip]
         use self::{inner::inner_foo, inner2::inner_bar};
 
         inner_foo();
diff --git a/tests/ui/wildcard_imports.rs b/tests/ui/wildcard_imports.rs
index 28508a2538b..8223b693018 100644
--- a/tests/ui/wildcard_imports.rs
+++ b/tests/ui/wildcard_imports.rs
@@ -112,6 +112,7 @@ mod in_fn_test {
     }
 
     fn test_inner_nested() {
+        #[rustfmt::skip]
         use self::{inner::*, inner2::*};
 
         inner_foo();
diff --git a/tests/ui/wildcard_imports.stderr b/tests/ui/wildcard_imports.stderr
index c96b3041a00..f7baf234c2f 100644
--- a/tests/ui/wildcard_imports.stderr
+++ b/tests/ui/wildcard_imports.stderr
@@ -55,37 +55,37 @@ LL |         use wildcard_imports_helper::*;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `wildcard_imports_helper::{ExternA, extern_foo}`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:115:20
+  --> $DIR/wildcard_imports.rs:116:20
    |
 LL |         use self::{inner::*, inner2::*};
    |                    ^^^^^^^^ help: try: `inner::inner_foo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:115:30
+  --> $DIR/wildcard_imports.rs:116:30
    |
 LL |         use self::{inner::*, inner2::*};
    |                              ^^^^^^^^^ help: try: `inner2::inner_bar`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:122:13
+  --> $DIR/wildcard_imports.rs:123:13
    |
 LL |         use wildcard_imports_helper::*;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `wildcard_imports_helper::{ExternExportedEnum, ExternExportedStruct, extern_exported}`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:151:9
+  --> $DIR/wildcard_imports.rs:152:9
    |
 LL |     use crate::in_fn_test::*;
    |         ^^^^^^^^^^^^^^^^^^^^ help: try: `crate::in_fn_test::{ExportedEnum, ExportedStruct, exported}`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:160:9
+  --> $DIR/wildcard_imports.rs:161:9
    |
 LL |     use crate:: in_fn_test::  * ;
    |         ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `crate:: in_fn_test::exported`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:161:9
+  --> $DIR/wildcard_imports.rs:162:9
    |
 LL |       use crate:: fn_mod::
    |  _________^
@@ -93,37 +93,37 @@ LL | |         *;
    | |_________^ help: try: `crate:: fn_mod::foo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:172:13
+  --> $DIR/wildcard_imports.rs:173:13
    |
 LL |         use super::*;
    |             ^^^^^^^^ help: try: `super::foofoo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:207:17
+  --> $DIR/wildcard_imports.rs:208:17
    |
 LL |             use super::*;
    |                 ^^^^^^^^ help: try: `super::insidefoo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:215:13
+  --> $DIR/wildcard_imports.rs:216:13
    |
 LL |         use crate::super_imports::*;
    |             ^^^^^^^^^^^^^^^^^^^^^^^ help: try: `crate::super_imports::foofoo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:224:17
+  --> $DIR/wildcard_imports.rs:225:17
    |
 LL |             use super::super::*;
    |                 ^^^^^^^^^^^^^^^ help: try: `super::super::foofoo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:233:13
+  --> $DIR/wildcard_imports.rs:234:13
    |
 LL |         use super::super::super_imports::*;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `super::super::super_imports::foofoo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:241:13
+  --> $DIR/wildcard_imports.rs:242:13
    |
 LL |         use super::*;
    |             ^^^^^^^^ help: try: `super::foofoo`
diff --git a/tests/ui/wildcard_imports_2021.edition2018.fixed b/tests/ui/wildcard_imports_2021.edition2018.fixed
index 3aea013fb3a..8a63375676e 100644
--- a/tests/ui/wildcard_imports_2021.edition2018.fixed
+++ b/tests/ui/wildcard_imports_2021.edition2018.fixed
@@ -106,6 +106,7 @@ mod in_fn_test {
     }
 
     fn test_inner_nested() {
+        #[rustfmt::skip]
         use self::{inner::inner_foo, inner2::inner_bar};
 
         inner_foo();
diff --git a/tests/ui/wildcard_imports_2021.edition2018.stderr b/tests/ui/wildcard_imports_2021.edition2018.stderr
index acca9f651b4..af9ae6e786c 100644
--- a/tests/ui/wildcard_imports_2021.edition2018.stderr
+++ b/tests/ui/wildcard_imports_2021.edition2018.stderr
@@ -55,37 +55,37 @@ LL |         use wildcard_imports_helper::*;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `wildcard_imports_helper::{ExternA, extern_foo}`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports_2021.rs:109:20
+  --> $DIR/wildcard_imports_2021.rs:110:20
    |
 LL |         use self::{inner::*, inner2::*};
    |                    ^^^^^^^^ help: try: `inner::inner_foo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports_2021.rs:109:30
+  --> $DIR/wildcard_imports_2021.rs:110:30
    |
 LL |         use self::{inner::*, inner2::*};
    |                              ^^^^^^^^^ help: try: `inner2::inner_bar`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports_2021.rs:116:13
+  --> $DIR/wildcard_imports_2021.rs:117:13
    |
 LL |         use wildcard_imports_helper::*;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `wildcard_imports_helper::{ExternExportedEnum, ExternExportedStruct, extern_exported}`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports_2021.rs:145:9
+  --> $DIR/wildcard_imports_2021.rs:146:9
    |
 LL |     use crate::in_fn_test::*;
    |         ^^^^^^^^^^^^^^^^^^^^ help: try: `crate::in_fn_test::{ExportedEnum, ExportedStruct, exported}`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports_2021.rs:154:9
+  --> $DIR/wildcard_imports_2021.rs:155:9
    |
 LL |     use crate:: in_fn_test::  * ;
    |         ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `crate:: in_fn_test::exported`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports_2021.rs:155:9
+  --> $DIR/wildcard_imports_2021.rs:156:9
    |
 LL |       use crate:: fn_mod::
    |  _________^
@@ -93,37 +93,37 @@ LL | |         *;
    | |_________^ help: try: `crate:: fn_mod::foo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports_2021.rs:166:13
+  --> $DIR/wildcard_imports_2021.rs:167:13
    |
 LL |         use super::*;
    |             ^^^^^^^^ help: try: `super::foofoo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports_2021.rs:201:17
+  --> $DIR/wildcard_imports_2021.rs:202:17
    |
 LL |             use super::*;
    |                 ^^^^^^^^ help: try: `super::insidefoo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports_2021.rs:209:13
+  --> $DIR/wildcard_imports_2021.rs:210:13
    |
 LL |         use crate::super_imports::*;
    |             ^^^^^^^^^^^^^^^^^^^^^^^ help: try: `crate::super_imports::foofoo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports_2021.rs:218:17
+  --> $DIR/wildcard_imports_2021.rs:219:17
    |
 LL |             use super::super::*;
    |                 ^^^^^^^^^^^^^^^ help: try: `super::super::foofoo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports_2021.rs:227:13
+  --> $DIR/wildcard_imports_2021.rs:228:13
    |
 LL |         use super::super::super_imports::*;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `super::super::super_imports::foofoo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports_2021.rs:235:13
+  --> $DIR/wildcard_imports_2021.rs:236:13
    |
 LL |         use super::*;
    |             ^^^^^^^^ help: try: `super::foofoo`
diff --git a/tests/ui/wildcard_imports_2021.edition2021.fixed b/tests/ui/wildcard_imports_2021.edition2021.fixed
index 3aea013fb3a..8a63375676e 100644
--- a/tests/ui/wildcard_imports_2021.edition2021.fixed
+++ b/tests/ui/wildcard_imports_2021.edition2021.fixed
@@ -106,6 +106,7 @@ mod in_fn_test {
     }
 
     fn test_inner_nested() {
+        #[rustfmt::skip]
         use self::{inner::inner_foo, inner2::inner_bar};
 
         inner_foo();
diff --git a/tests/ui/wildcard_imports_2021.edition2021.stderr b/tests/ui/wildcard_imports_2021.edition2021.stderr
index acca9f651b4..af9ae6e786c 100644
--- a/tests/ui/wildcard_imports_2021.edition2021.stderr
+++ b/tests/ui/wildcard_imports_2021.edition2021.stderr
@@ -55,37 +55,37 @@ LL |         use wildcard_imports_helper::*;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `wildcard_imports_helper::{ExternA, extern_foo}`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports_2021.rs:109:20
+  --> $DIR/wildcard_imports_2021.rs:110:20
    |
 LL |         use self::{inner::*, inner2::*};
    |                    ^^^^^^^^ help: try: `inner::inner_foo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports_2021.rs:109:30
+  --> $DIR/wildcard_imports_2021.rs:110:30
    |
 LL |         use self::{inner::*, inner2::*};
    |                              ^^^^^^^^^ help: try: `inner2::inner_bar`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports_2021.rs:116:13
+  --> $DIR/wildcard_imports_2021.rs:117:13
    |
 LL |         use wildcard_imports_helper::*;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `wildcard_imports_helper::{ExternExportedEnum, ExternExportedStruct, extern_exported}`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports_2021.rs:145:9
+  --> $DIR/wildcard_imports_2021.rs:146:9
    |
 LL |     use crate::in_fn_test::*;
    |         ^^^^^^^^^^^^^^^^^^^^ help: try: `crate::in_fn_test::{ExportedEnum, ExportedStruct, exported}`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports_2021.rs:154:9
+  --> $DIR/wildcard_imports_2021.rs:155:9
    |
 LL |     use crate:: in_fn_test::  * ;
    |         ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `crate:: in_fn_test::exported`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports_2021.rs:155:9
+  --> $DIR/wildcard_imports_2021.rs:156:9
    |
 LL |       use crate:: fn_mod::
    |  _________^
@@ -93,37 +93,37 @@ LL | |         *;
    | |_________^ help: try: `crate:: fn_mod::foo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports_2021.rs:166:13
+  --> $DIR/wildcard_imports_2021.rs:167:13
    |
 LL |         use super::*;
    |             ^^^^^^^^ help: try: `super::foofoo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports_2021.rs:201:17
+  --> $DIR/wildcard_imports_2021.rs:202:17
    |
 LL |             use super::*;
    |                 ^^^^^^^^ help: try: `super::insidefoo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports_2021.rs:209:13
+  --> $DIR/wildcard_imports_2021.rs:210:13
    |
 LL |         use crate::super_imports::*;
    |             ^^^^^^^^^^^^^^^^^^^^^^^ help: try: `crate::super_imports::foofoo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports_2021.rs:218:17
+  --> $DIR/wildcard_imports_2021.rs:219:17
    |
 LL |             use super::super::*;
    |                 ^^^^^^^^^^^^^^^ help: try: `super::super::foofoo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports_2021.rs:227:13
+  --> $DIR/wildcard_imports_2021.rs:228:13
    |
 LL |         use super::super::super_imports::*;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `super::super::super_imports::foofoo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports_2021.rs:235:13
+  --> $DIR/wildcard_imports_2021.rs:236:13
    |
 LL |         use super::*;
    |             ^^^^^^^^ help: try: `super::foofoo`
diff --git a/tests/ui/wildcard_imports_2021.rs b/tests/ui/wildcard_imports_2021.rs
index 40c2d07527d..52cd2c82854 100644
--- a/tests/ui/wildcard_imports_2021.rs
+++ b/tests/ui/wildcard_imports_2021.rs
@@ -106,6 +106,7 @@ mod in_fn_test {
     }
 
     fn test_inner_nested() {
+        #[rustfmt::skip]
         use self::{inner::*, inner2::*};
 
         inner_foo();
-- 
cgit 1.4.1-3-g733a5


From ea36a9df753432df2dad471384543377e8f78129 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Thu, 13 Jul 2023 13:29:41 +0000
Subject: Set `unnecessary_cast` suggestion to `MaybeIncorrect` for pointer
 casts

Removing casts may cause type inference to stop working which requires
manual intervention
---
 clippy_lints/src/casts/unnecessary_cast.rs |  2 +-
 tests/ui/unnecessary_cast_unfixable.rs     | 22 ++++++++++++++++++++++
 tests/ui/unnecessary_cast_unfixable.stderr | 16 ++++++++++++++++
 3 files changed, 39 insertions(+), 1 deletion(-)
 create mode 100644 tests/ui/unnecessary_cast_unfixable.rs
 create mode 100644 tests/ui/unnecessary_cast_unfixable.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/unnecessary_cast.rs b/clippy_lints/src/casts/unnecessary_cast.rs
index 71cf2aea0f8..ae56f38d9ad 100644
--- a/clippy_lints/src/casts/unnecessary_cast.rs
+++ b/clippy_lints/src/casts/unnecessary_cast.rs
@@ -56,7 +56,7 @@ pub(super) fn check<'tcx>(
                 &format!("casting raw pointers to the same type and constness is unnecessary (`{cast_from}` -> `{cast_to}`)"),
                 "try",
                 cast_str.clone(),
-                Applicability::MachineApplicable,
+                Applicability::MaybeIncorrect,
             );
         }
     }
diff --git a/tests/ui/unnecessary_cast_unfixable.rs b/tests/ui/unnecessary_cast_unfixable.rs
new file mode 100644
index 00000000000..0e027f6042e
--- /dev/null
+++ b/tests/ui/unnecessary_cast_unfixable.rs
@@ -0,0 +1,22 @@
+#![warn(clippy::unnecessary_cast)]
+
+fn main() {
+    let _ = std::ptr::null() as *const u8;
+}
+
+mod issue11113 {
+    #[repr(C)]
+    struct Vtbl {
+        query: unsafe extern "system" fn(),
+    }
+
+    struct TearOff {
+        object: *mut std::ffi::c_void,
+    }
+
+    impl TearOff {
+        unsafe fn query(&self) {
+            ((*(*(self.object as *mut *mut _) as *mut Vtbl)).query)()
+        }
+    }
+}
diff --git a/tests/ui/unnecessary_cast_unfixable.stderr b/tests/ui/unnecessary_cast_unfixable.stderr
new file mode 100644
index 00000000000..eecf245686a
--- /dev/null
+++ b/tests/ui/unnecessary_cast_unfixable.stderr
@@ -0,0 +1,16 @@
+error: casting raw pointers to the same type and constness is unnecessary (`*const u8` -> `*const u8`)
+  --> $DIR/unnecessary_cast_unfixable.rs:4:13
+   |
+LL |     let _ = std::ptr::null() as *const u8;
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::null()`
+   |
+   = note: `-D clippy::unnecessary-cast` implied by `-D warnings`
+
+error: casting raw pointers to the same type and constness is unnecessary (`*mut issue11113::Vtbl` -> `*mut issue11113::Vtbl`)
+  --> $DIR/unnecessary_cast_unfixable.rs:19:16
+   |
+LL |             ((*(*(self.object as *mut *mut _) as *mut Vtbl)).query)()
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `*(self.object as *mut *mut _)`
+
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From c2aaa622eb1b8ce390dc5766199ed7c63d4900d7 Mon Sep 17 00:00:00 2001
From: syvb <smitty@timescale.com>
Date: Wed, 5 Jul 2023 22:13:37 -0400
Subject: Fix ICE on None.unwrap_or_default()

---
 .../src/methods/unnecessary_literal_unwrap.rs      |  12 ++
 tests/ui/unnecessary_literal_unwrap.fixed          |   2 +
 tests/ui/unnecessary_literal_unwrap.rs             |   2 +
 tests/ui/unnecessary_literal_unwrap.stderr         |  88 +++++-----
 tests/ui/unnecessary_literal_unwrap_unfixable.rs   |   2 +
 .../ui/unnecessary_literal_unwrap_unfixable.stderr | 182 +++++++++++----------
 6 files changed, 165 insertions(+), 123 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/unnecessary_literal_unwrap.rs b/clippy_lints/src/methods/unnecessary_literal_unwrap.rs
index 111bcaaecec..6d9a0451073 100644
--- a/clippy_lints/src/methods/unnecessary_literal_unwrap.rs
+++ b/clippy_lints/src/methods/unnecessary_literal_unwrap.rs
@@ -3,6 +3,8 @@ use clippy_utils::{is_res_lang_ctor, last_path_segment, path_res, MaybePath};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
+use rustc_middle::ty;
+use rustc_middle::ty::print::with_forced_trimmed_paths;
 
 use super::UNNECESSARY_LITERAL_UNWRAP;
 
@@ -84,6 +86,16 @@ pub(super) fn check(
                 }
                 Some(suggs)
             },
+            ("None", "unwrap_or_default", _) => {
+                let ty = cx.typeck_results().expr_ty(expr);
+                let default_ty_string = if let ty::Adt(def, ..) = ty.kind() {
+                    with_forced_trimmed_paths!(format!("{}", cx.tcx.def_path_str(def.did())))
+                } else {
+                    "Default".to_string()
+                };
+                Some(vec![(expr.span, format!("{default_ty_string}::default()"))])
+            },
+            _ if call_args.is_empty() => None,
             (_, _, Some(_)) => None,
             ("Ok", "unwrap_err", None) | ("Err", "unwrap", None) => Some(vec![
                 (
diff --git a/tests/ui/unnecessary_literal_unwrap.fixed b/tests/ui/unnecessary_literal_unwrap.fixed
index 276cd800b89..5eaa117b8e8 100644
--- a/tests/ui/unnecessary_literal_unwrap.fixed
+++ b/tests/ui/unnecessary_literal_unwrap.fixed
@@ -19,9 +19,11 @@ fn unwrap_option_some() {
 fn unwrap_option_none() {
     let _val = panic!();
     let _val = panic!("this always happens");
+    let _val: String = String::default();
 
     panic!();
     panic!("this always happens");
+    String::default();
 }
 
 fn unwrap_result_ok() {
diff --git a/tests/ui/unnecessary_literal_unwrap.rs b/tests/ui/unnecessary_literal_unwrap.rs
index 3065778d779..6408851b42a 100644
--- a/tests/ui/unnecessary_literal_unwrap.rs
+++ b/tests/ui/unnecessary_literal_unwrap.rs
@@ -19,9 +19,11 @@ fn unwrap_option_some() {
 fn unwrap_option_none() {
     let _val = None::<()>.unwrap();
     let _val = None::<()>.expect("this always happens");
+    let _val: String = None.unwrap_or_default();
 
     None::<()>.unwrap();
     None::<()>.expect("this always happens");
+    None::<String>.unwrap_or_default();
 }
 
 fn unwrap_result_ok() {
diff --git a/tests/ui/unnecessary_literal_unwrap.stderr b/tests/ui/unnecessary_literal_unwrap.stderr
index 5823313b736..acaf37b13a5 100644
--- a/tests/ui/unnecessary_literal_unwrap.stderr
+++ b/tests/ui/unnecessary_literal_unwrap.stderr
@@ -64,14 +64,20 @@ help: remove the `None` and `expect()`
 LL |     let _val = panic!("this always happens");
    |                ~~~~~~~                     ~
 
+error: used `unwrap_or_default()` on `None` value
+  --> $DIR/unnecessary_literal_unwrap.rs:22:24
+   |
+LL |     let _val: String = None.unwrap_or_default();
+   |                        ^^^^^^^^^^^^^^^^^^^^^^^^ help: remove the `None` and `unwrap_or_default()`: `String::default()`
+
 error: used `unwrap()` on `None` value
-  --> $DIR/unnecessary_literal_unwrap.rs:23:5
+  --> $DIR/unnecessary_literal_unwrap.rs:24:5
    |
 LL |     None::<()>.unwrap();
    |     ^^^^^^^^^^^^^^^^^^^ help: remove the `None` and `unwrap()`: `panic!()`
 
 error: used `expect()` on `None` value
-  --> $DIR/unnecessary_literal_unwrap.rs:24:5
+  --> $DIR/unnecessary_literal_unwrap.rs:25:5
    |
 LL |     None::<()>.expect("this always happens");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -81,8 +87,14 @@ help: remove the `None` and `expect()`
 LL |     panic!("this always happens");
    |     ~~~~~~~                     ~
 
+error: used `unwrap_or_default()` on `None` value
+  --> $DIR/unnecessary_literal_unwrap.rs:26:5
+   |
+LL |     None::<String>.unwrap_or_default();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove the `None` and `unwrap_or_default()`: `String::default()`
+
 error: used `unwrap()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap.rs:28:16
+  --> $DIR/unnecessary_literal_unwrap.rs:30:16
    |
 LL |     let _val = Ok::<_, ()>(1).unwrap();
    |                ^^^^^^^^^^^^^^^^^^^^^^^
@@ -94,7 +106,7 @@ LL +     let _val = 1;
    |
 
 error: used `expect()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap.rs:29:16
+  --> $DIR/unnecessary_literal_unwrap.rs:31:16
    |
 LL |     let _val = Ok::<_, ()>(1).expect("this never happens");
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -106,7 +118,7 @@ LL +     let _val = 1;
    |
 
 error: used `unwrap_err()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap.rs:30:16
+  --> $DIR/unnecessary_literal_unwrap.rs:32:16
    |
 LL |     let _val = Ok::<_, ()>(1).unwrap_err();
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -117,7 +129,7 @@ LL |     let _val = panic!("{:?}", 1);
    |                ~~~~~~~~~~~~~~  ~
 
 error: used `expect_err()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap.rs:31:16
+  --> $DIR/unnecessary_literal_unwrap.rs:33:16
    |
 LL |     let _val = Ok::<_, ()>(1).expect_err("this always happens");
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -128,7 +140,7 @@ LL |     let _val = panic!("{1}: {:?}", 1, "this always happens");
    |                ~~~~~~~~~~~~~~~~~~~  ~
 
 error: used `unwrap()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap.rs:33:5
+  --> $DIR/unnecessary_literal_unwrap.rs:35:5
    |
 LL |     Ok::<_, ()>(1).unwrap();
    |     ^^^^^^^^^^^^^^^^^^^^^^^
@@ -140,7 +152,7 @@ LL +     1;
    |
 
 error: used `expect()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap.rs:34:5
+  --> $DIR/unnecessary_literal_unwrap.rs:36:5
    |
 LL |     Ok::<_, ()>(1).expect("this never happens");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -152,7 +164,7 @@ LL +     1;
    |
 
 error: used `unwrap_err()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap.rs:35:5
+  --> $DIR/unnecessary_literal_unwrap.rs:37:5
    |
 LL |     Ok::<_, ()>(1).unwrap_err();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -163,7 +175,7 @@ LL |     panic!("{:?}", 1);
    |     ~~~~~~~~~~~~~~  ~
 
 error: used `expect_err()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap.rs:36:5
+  --> $DIR/unnecessary_literal_unwrap.rs:38:5
    |
 LL |     Ok::<_, ()>(1).expect_err("this always happens");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -174,7 +186,7 @@ LL |     panic!("{1}: {:?}", 1, "this always happens");
    |     ~~~~~~~~~~~~~~~~~~~  ~
 
 error: used `unwrap_err()` on `Err` value
-  --> $DIR/unnecessary_literal_unwrap.rs:40:16
+  --> $DIR/unnecessary_literal_unwrap.rs:42:16
    |
 LL |     let _val = Err::<(), _>(1).unwrap_err();
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -186,7 +198,7 @@ LL +     let _val = 1;
    |
 
 error: used `expect_err()` on `Err` value
-  --> $DIR/unnecessary_literal_unwrap.rs:41:16
+  --> $DIR/unnecessary_literal_unwrap.rs:43:16
    |
 LL |     let _val = Err::<(), _>(1).expect_err("this never happens");
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -198,7 +210,7 @@ LL +     let _val = 1;
    |
 
 error: used `unwrap()` on `Err` value
-  --> $DIR/unnecessary_literal_unwrap.rs:42:16
+  --> $DIR/unnecessary_literal_unwrap.rs:44:16
    |
 LL |     let _val = Err::<(), _>(1).unwrap();
    |                ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -209,7 +221,7 @@ LL |     let _val = panic!("{:?}", 1);
    |                ~~~~~~~~~~~~~~  ~
 
 error: used `expect()` on `Err` value
-  --> $DIR/unnecessary_literal_unwrap.rs:43:16
+  --> $DIR/unnecessary_literal_unwrap.rs:45:16
    |
 LL |     let _val = Err::<(), _>(1).expect("this always happens");
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -220,7 +232,7 @@ LL |     let _val = panic!("{1}: {:?}", 1, "this always happens");
    |                ~~~~~~~~~~~~~~~~~~~  ~
 
 error: used `unwrap_err()` on `Err` value
-  --> $DIR/unnecessary_literal_unwrap.rs:45:5
+  --> $DIR/unnecessary_literal_unwrap.rs:47:5
    |
 LL |     Err::<(), _>(1).unwrap_err();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -232,7 +244,7 @@ LL +     1;
    |
 
 error: used `expect_err()` on `Err` value
-  --> $DIR/unnecessary_literal_unwrap.rs:46:5
+  --> $DIR/unnecessary_literal_unwrap.rs:48:5
    |
 LL |     Err::<(), _>(1).expect_err("this never happens");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -244,7 +256,7 @@ LL +     1;
    |
 
 error: used `unwrap()` on `Err` value
-  --> $DIR/unnecessary_literal_unwrap.rs:47:5
+  --> $DIR/unnecessary_literal_unwrap.rs:49:5
    |
 LL |     Err::<(), _>(1).unwrap();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -255,7 +267,7 @@ LL |     panic!("{:?}", 1);
    |     ~~~~~~~~~~~~~~  ~
 
 error: used `expect()` on `Err` value
-  --> $DIR/unnecessary_literal_unwrap.rs:48:5
+  --> $DIR/unnecessary_literal_unwrap.rs:50:5
    |
 LL |     Err::<(), _>(1).expect("this always happens");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -266,7 +278,7 @@ LL |     panic!("{1}: {:?}", 1, "this always happens");
    |     ~~~~~~~~~~~~~~~~~~~  ~
 
 error: used `unwrap_or()` on `Some` value
-  --> $DIR/unnecessary_literal_unwrap.rs:52:16
+  --> $DIR/unnecessary_literal_unwrap.rs:54:16
    |
 LL |     let _val = Some(1).unwrap_or(2);
    |                ^^^^^^^^^^^^^^^^^^^^
@@ -278,7 +290,7 @@ LL +     let _val = 1;
    |
 
 error: used `unwrap_or_default()` on `Some` value
-  --> $DIR/unnecessary_literal_unwrap.rs:53:16
+  --> $DIR/unnecessary_literal_unwrap.rs:55:16
    |
 LL |     let _val = Some(1).unwrap_or_default();
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -290,7 +302,7 @@ LL +     let _val = 1;
    |
 
 error: used `unwrap_or_else()` on `Some` value
-  --> $DIR/unnecessary_literal_unwrap.rs:54:16
+  --> $DIR/unnecessary_literal_unwrap.rs:56:16
    |
 LL |     let _val = Some(1).unwrap_or_else(|| 2);
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -302,7 +314,7 @@ LL +     let _val = 1;
    |
 
 error: used `unwrap_or()` on `Some` value
-  --> $DIR/unnecessary_literal_unwrap.rs:56:5
+  --> $DIR/unnecessary_literal_unwrap.rs:58:5
    |
 LL |     Some(1).unwrap_or(2);
    |     ^^^^^^^^^^^^^^^^^^^^
@@ -314,7 +326,7 @@ LL +     1;
    |
 
 error: used `unwrap_or_default()` on `Some` value
-  --> $DIR/unnecessary_literal_unwrap.rs:57:5
+  --> $DIR/unnecessary_literal_unwrap.rs:59:5
    |
 LL |     Some(1).unwrap_or_default();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -326,7 +338,7 @@ LL +     1;
    |
 
 error: used `unwrap_or_else()` on `Some` value
-  --> $DIR/unnecessary_literal_unwrap.rs:58:5
+  --> $DIR/unnecessary_literal_unwrap.rs:60:5
    |
 LL |     Some(1).unwrap_or_else(|| 2);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -338,7 +350,7 @@ LL +     1;
    |
 
 error: used `unwrap_or()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap.rs:62:16
+  --> $DIR/unnecessary_literal_unwrap.rs:64:16
    |
 LL |     let _val = Ok::<_, ()>(1).unwrap_or(2);
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -350,7 +362,7 @@ LL +     let _val = 1;
    |
 
 error: used `unwrap_or_default()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap.rs:63:16
+  --> $DIR/unnecessary_literal_unwrap.rs:65:16
    |
 LL |     let _val = Ok::<_, ()>(1).unwrap_or_default();
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -362,7 +374,7 @@ LL +     let _val = 1;
    |
 
 error: used `unwrap_or_else()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap.rs:64:16
+  --> $DIR/unnecessary_literal_unwrap.rs:66:16
    |
 LL |     let _val = Ok::<_, ()>(1).unwrap_or_else(|_| 2);
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -374,7 +386,7 @@ LL +     let _val = 1;
    |
 
 error: used `unwrap_or()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap.rs:66:5
+  --> $DIR/unnecessary_literal_unwrap.rs:68:5
    |
 LL |     Ok::<_, ()>(1).unwrap_or(2);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -386,7 +398,7 @@ LL +     1;
    |
 
 error: used `unwrap_or_default()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap.rs:67:5
+  --> $DIR/unnecessary_literal_unwrap.rs:69:5
    |
 LL |     Ok::<_, ()>(1).unwrap_or_default();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -398,7 +410,7 @@ LL +     1;
    |
 
 error: used `unwrap_or_else()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap.rs:68:5
+  --> $DIR/unnecessary_literal_unwrap.rs:70:5
    |
 LL |     Ok::<_, ()>(1).unwrap_or_else(|_| 2);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -410,7 +422,7 @@ LL +     1;
    |
 
 error: used `unwrap_unchecked()` on `Some` value
-  --> $DIR/unnecessary_literal_unwrap.rs:82:22
+  --> $DIR/unnecessary_literal_unwrap.rs:84:22
    |
 LL |     let _ = unsafe { Some(1).unwrap_unchecked() };
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -422,7 +434,7 @@ LL +     let _ = 1;
    |
 
 error: used `unwrap_unchecked()` on `Some` value
-  --> $DIR/unnecessary_literal_unwrap.rs:83:22
+  --> $DIR/unnecessary_literal_unwrap.rs:85:22
    |
 LL |     let _ = unsafe { Some(1).unwrap_unchecked() + *(&1 as *const i32) }; // needs to keep the unsafe block
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -434,7 +446,7 @@ LL +     let _ = unsafe { 1 + *(&1 as *const i32) }; // needs to keep the unsafe
    |
 
 error: used `unwrap_unchecked()` on `Some` value
-  --> $DIR/unnecessary_literal_unwrap.rs:84:22
+  --> $DIR/unnecessary_literal_unwrap.rs:86:22
    |
 LL |     let _ = unsafe { Some(1).unwrap_unchecked() } + 1;
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -446,7 +458,7 @@ LL +     let _ = 1 + 1;
    |
 
 error: used `unwrap_unchecked()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap.rs:85:22
+  --> $DIR/unnecessary_literal_unwrap.rs:87:22
    |
 LL |     let _ = unsafe { Ok::<_, ()>(1).unwrap_unchecked() };
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -458,7 +470,7 @@ LL +     let _ = 1;
    |
 
 error: used `unwrap_unchecked()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap.rs:86:22
+  --> $DIR/unnecessary_literal_unwrap.rs:88:22
    |
 LL |     let _ = unsafe { Ok::<_, ()>(1).unwrap_unchecked() + *(&1 as *const i32) };
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -470,7 +482,7 @@ LL +     let _ = unsafe { 1 + *(&1 as *const i32) };
    |
 
 error: used `unwrap_unchecked()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap.rs:87:22
+  --> $DIR/unnecessary_literal_unwrap.rs:89:22
    |
 LL |     let _ = unsafe { Ok::<_, ()>(1).unwrap_unchecked() } + 1;
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -482,7 +494,7 @@ LL +     let _ = 1 + 1;
    |
 
 error: used `unwrap_err_unchecked()` on `Err` value
-  --> $DIR/unnecessary_literal_unwrap.rs:88:22
+  --> $DIR/unnecessary_literal_unwrap.rs:90:22
    |
 LL |     let _ = unsafe { Err::<(), i32>(123).unwrap_err_unchecked() };
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -493,5 +505,5 @@ LL -     let _ = unsafe { Err::<(), i32>(123).unwrap_err_unchecked() };
 LL +     let _ = 123;
    |
 
-error: aborting due to 43 previous errors
+error: aborting due to 45 previous errors
 
diff --git a/tests/ui/unnecessary_literal_unwrap_unfixable.rs b/tests/ui/unnecessary_literal_unwrap_unfixable.rs
index 711fdce3962..41300aceb41 100644
--- a/tests/ui/unnecessary_literal_unwrap_unfixable.rs
+++ b/tests/ui/unnecessary_literal_unwrap_unfixable.rs
@@ -21,6 +21,8 @@ fn unwrap_option_none() {
     let val = None::<()>;
     let _val2 = val.unwrap();
     let _val2 = val.expect("this always happens");
+    let _val3: u8 = None.unwrap_or_default();
+    None::<()>.unwrap_or_default();
 }
 
 fn unwrap_result_ok() {
diff --git a/tests/ui/unnecessary_literal_unwrap_unfixable.stderr b/tests/ui/unnecessary_literal_unwrap_unfixable.stderr
index feb9325b77a..2d1270d4717 100644
--- a/tests/ui/unnecessary_literal_unwrap_unfixable.stderr
+++ b/tests/ui/unnecessary_literal_unwrap_unfixable.stderr
@@ -95,509 +95,521 @@ help: remove the `None` and `expect()`
 LL |     let val = None::<()>;
    |               ^^^^^^^^^^
 
+error: used `unwrap_or_default()` on `None` value
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:24:21
+   |
+LL |     let _val3: u8 = None.unwrap_or_default();
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^ help: remove the `None` and `unwrap_or_default()`: `Default::default()`
+
+error: used `unwrap_or_default()` on `None` value
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:25:5
+   |
+LL |     None::<()>.unwrap_or_default();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove the `None` and `unwrap_or_default()`: `Default::default()`
+
 error: used `unwrap()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:28:17
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:30:17
    |
 LL |     let _val2 = val.unwrap();
    |                 ^^^^^^^^^^^^
    |
 help: remove the `Ok` and `unwrap()`
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:27:15
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:29:15
    |
 LL |     let val = Ok::<_, ()>(1);
    |               ^^^^^^^^^^^^^^
 
 error: used `expect()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:29:17
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:31:17
    |
 LL |     let _val2 = val.expect("this never happens");
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Ok` and `expect()`
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:27:15
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:29:15
    |
 LL |     let val = Ok::<_, ()>(1);
    |               ^^^^^^^^^^^^^^
 
 error: used `unwrap_err()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:30:17
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:32:17
    |
 LL |     let _val2 = val.unwrap_err();
    |                 ^^^^^^^^^^^^^^^^
    |
 help: remove the `Ok` and `unwrap_err()`
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:27:15
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:29:15
    |
 LL |     let val = Ok::<_, ()>(1);
    |               ^^^^^^^^^^^^^^
 
 error: used `expect_err()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:31:17
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:33:17
    |
 LL |     let _val2 = val.expect_err("this always happens");
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Ok` and `expect_err()`
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:27:15
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:29:15
    |
 LL |     let val = Ok::<_, ()>(1);
    |               ^^^^^^^^^^^^^^
 
 error: used `unwrap()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:35:16
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:37:16
    |
 LL |     let _val = Ok::<usize, ()>([1, 2, 3].iter().sum()).unwrap();
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Ok` and `unwrap()`
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:35:16
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:37:16
    |
 LL |     let _val = Ok::<usize, ()>([1, 2, 3].iter().sum()).unwrap();
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: used `expect()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:36:16
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:38:16
    |
 LL |     let _val = Ok::<usize, ()>([1, 2, 3].iter().sum()).expect("this never happens");
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Ok` and `expect()`
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:36:16
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:38:16
    |
 LL |     let _val = Ok::<usize, ()>([1, 2, 3].iter().sum()).expect("this never happens");
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: used `unwrap_err()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:37:16
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:39:16
    |
 LL |     let _val = Ok::<usize, ()>([1, 2, 3].iter().sum()).unwrap_err();
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Ok` and `unwrap_err()`
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:37:16
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:39:16
    |
 LL |     let _val = Ok::<usize, ()>([1, 2, 3].iter().sum()).unwrap_err();
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: used `expect_err()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:38:16
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:40:16
    |
 LL |     let _val = Ok::<usize, ()>([1, 2, 3].iter().sum()).expect_err("this always happens");
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Ok` and `expect_err()`
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:38:16
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:40:16
    |
 LL |     let _val = Ok::<usize, ()>([1, 2, 3].iter().sum()).expect_err("this always happens");
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: used `unwrap()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:41:17
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:43:17
    |
 LL |     let _val2 = val.unwrap();
    |                 ^^^^^^^^^^^^
    |
 help: remove the `Ok` and `unwrap()`
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:40:15
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:42:15
    |
 LL |     let val = Ok::<usize, ()>([1, 2, 3].iter().sum());
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: used `expect()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:42:17
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:44:17
    |
 LL |     let _val2 = val.expect("this never happens");
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Ok` and `expect()`
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:40:15
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:42:15
    |
 LL |     let val = Ok::<usize, ()>([1, 2, 3].iter().sum());
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: used `unwrap_err()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:43:17
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:45:17
    |
 LL |     let _val2 = val.unwrap_err();
    |                 ^^^^^^^^^^^^^^^^
    |
 help: remove the `Ok` and `unwrap_err()`
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:40:15
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:42:15
    |
 LL |     let val = Ok::<usize, ()>([1, 2, 3].iter().sum());
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: used `expect_err()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:44:17
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:46:17
    |
 LL |     let _val2 = val.expect_err("this always happens");
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Ok` and `expect_err()`
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:40:15
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:42:15
    |
 LL |     let val = Ok::<usize, ()>([1, 2, 3].iter().sum());
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: used `unwrap_err()` on `Err` value
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:49:17
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:51:17
    |
 LL |     let _val2 = val.unwrap_err();
    |                 ^^^^^^^^^^^^^^^^
    |
 help: remove the `Err` and `unwrap_err()`
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:48:15
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:50:15
    |
 LL |     let val = Err::<(), _>(1);
    |               ^^^^^^^^^^^^^^^
 
 error: used `expect_err()` on `Err` value
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:50:17
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:52:17
    |
 LL |     let _val2 = val.expect_err("this never happens");
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Err` and `expect_err()`
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:48:15
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:50:15
    |
 LL |     let val = Err::<(), _>(1);
    |               ^^^^^^^^^^^^^^^
 
 error: used `unwrap()` on `Err` value
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:51:17
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:53:17
    |
 LL |     let _val2 = val.unwrap();
    |                 ^^^^^^^^^^^^
    |
 help: remove the `Err` and `unwrap()`
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:48:15
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:50:15
    |
 LL |     let val = Err::<(), _>(1);
    |               ^^^^^^^^^^^^^^^
 
 error: used `expect()` on `Err` value
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:52:17
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:54:17
    |
 LL |     let _val2 = val.expect("this always happens");
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Err` and `expect()`
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:48:15
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:50:15
    |
 LL |     let val = Err::<(), _>(1);
    |               ^^^^^^^^^^^^^^^
 
 error: used `unwrap_err()` on `Err` value
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:56:16
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:58:16
    |
 LL |     let _val = Err::<(), usize>([1, 2, 3].iter().sum()).unwrap_err();
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Err` and `unwrap_err()`
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:56:16
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:58:16
    |
 LL |     let _val = Err::<(), usize>([1, 2, 3].iter().sum()).unwrap_err();
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: used `expect_err()` on `Err` value
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:57:16
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:59:16
    |
 LL |     let _val = Err::<(), usize>([1, 2, 3].iter().sum()).expect_err("this never happens");
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Err` and `expect_err()`
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:57:16
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:59:16
    |
 LL |     let _val = Err::<(), usize>([1, 2, 3].iter().sum()).expect_err("this never happens");
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: used `unwrap()` on `Err` value
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:58:16
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:60:16
    |
 LL |     let _val = Err::<(), usize>([1, 2, 3].iter().sum()).unwrap();
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Err` and `unwrap()`
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:58:16
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:60:16
    |
 LL |     let _val = Err::<(), usize>([1, 2, 3].iter().sum()).unwrap();
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: used `expect()` on `Err` value
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:59:16
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:61:16
    |
 LL |     let _val = Err::<(), usize>([1, 2, 3].iter().sum()).expect("this always happens");
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Err` and `expect()`
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:59:16
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:61:16
    |
 LL |     let _val = Err::<(), usize>([1, 2, 3].iter().sum()).expect("this always happens");
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: used `unwrap_err()` on `Err` value
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:62:17
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:64:17
    |
 LL |     let _val2 = val.unwrap_err();
    |                 ^^^^^^^^^^^^^^^^
    |
 help: remove the `Err` and `unwrap_err()`
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:61:15
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:63:15
    |
 LL |     let val = Err::<(), usize>([1, 2, 3].iter().sum());
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: used `expect_err()` on `Err` value
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:63:17
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:65:17
    |
 LL |     let _val2 = val.expect_err("this never happens");
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Err` and `expect_err()`
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:61:15
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:63:15
    |
 LL |     let val = Err::<(), usize>([1, 2, 3].iter().sum());
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: used `unwrap()` on `Err` value
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:64:17
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:66:17
    |
 LL |     let _val2 = val.unwrap();
    |                 ^^^^^^^^^^^^
    |
 help: remove the `Err` and `unwrap()`
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:61:15
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:63:15
    |
 LL |     let val = Err::<(), usize>([1, 2, 3].iter().sum());
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: used `expect()` on `Err` value
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:65:17
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:67:17
    |
 LL |     let _val2 = val.expect("this always happens");
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Err` and `expect()`
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:61:15
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:63:15
    |
 LL |     let val = Err::<(), usize>([1, 2, 3].iter().sum());
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: used `unwrap_or()` on `Some` value
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:70:17
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:72:17
    |
 LL |     let _val2 = val.unwrap_or(2);
    |                 ^^^^^^^^^^^^^^^^
    |
 help: remove the `Some` and `unwrap_or()`
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:69:15
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:71:15
    |
 LL |     let val = Some(1);
    |               ^^^^^^^
 
 error: used `unwrap_or_default()` on `Some` value
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:71:17
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:73:17
    |
 LL |     let _val2 = val.unwrap_or_default();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Some` and `unwrap_or_default()`
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:69:15
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:71:15
    |
 LL |     let val = Some(1);
    |               ^^^^^^^
 
 error: used `unwrap_or_else()` on `Some` value
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:72:17
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:74:17
    |
 LL |     let _val2 = val.unwrap_or_else(|| 2);
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Some` and `unwrap_or_else()`
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:69:15
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:71:15
    |
 LL |     let val = Some(1);
    |               ^^^^^^^
 
 error: used `unwrap_or()` on `Some` value
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:76:16
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:78:16
    |
 LL |     let _val = Some::<usize>([1, 2, 3].iter().sum()).unwrap_or(2);
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Some` and `unwrap_or()`
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:76:16
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:78:16
    |
 LL |     let _val = Some::<usize>([1, 2, 3].iter().sum()).unwrap_or(2);
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: used `unwrap_or_default()` on `Some` value
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:77:16
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:79:16
    |
 LL |     let _val = Some::<usize>([1, 2, 3].iter().sum()).unwrap_or_default();
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Some` and `unwrap_or_default()`
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:77:16
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:79:16
    |
 LL |     let _val = Some::<usize>([1, 2, 3].iter().sum()).unwrap_or_default();
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: used `unwrap_or_else()` on `Some` value
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:78:16
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:80:16
    |
 LL |     let _val = Some::<usize>([1, 2, 3].iter().sum()).unwrap_or_else(|| 2);
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Some` and `unwrap_or_else()`
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:78:16
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:80:16
    |
 LL |     let _val = Some::<usize>([1, 2, 3].iter().sum()).unwrap_or_else(|| 2);
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: used `unwrap_or()` on `Some` value
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:81:17
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:83:17
    |
 LL |     let _val2 = val.unwrap_or(2);
    |                 ^^^^^^^^^^^^^^^^
    |
 help: remove the `Some` and `unwrap_or()`
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:80:15
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:82:15
    |
 LL |     let val = Some::<usize>([1, 2, 3].iter().sum());
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: used `unwrap_or_default()` on `Some` value
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:82:17
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:84:17
    |
 LL |     let _val2 = val.unwrap_or_default();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Some` and `unwrap_or_default()`
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:80:15
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:82:15
    |
 LL |     let val = Some::<usize>([1, 2, 3].iter().sum());
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: used `unwrap_or_else()` on `Some` value
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:83:17
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:85:17
    |
 LL |     let _val2 = val.unwrap_or_else(|| 2);
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Some` and `unwrap_or_else()`
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:80:15
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:82:15
    |
 LL |     let val = Some::<usize>([1, 2, 3].iter().sum());
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: used `unwrap_or()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:88:17
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:90:17
    |
 LL |     let _val2 = val.unwrap_or(2);
    |                 ^^^^^^^^^^^^^^^^
    |
 help: remove the `Ok` and `unwrap_or()`
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:87:15
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:89:15
    |
 LL |     let val = Ok::<_, ()>(1);
    |               ^^^^^^^^^^^^^^
 
 error: used `unwrap_or_default()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:89:17
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:91:17
    |
 LL |     let _val2 = val.unwrap_or_default();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Ok` and `unwrap_or_default()`
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:87:15
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:89:15
    |
 LL |     let val = Ok::<_, ()>(1);
    |               ^^^^^^^^^^^^^^
 
 error: used `unwrap_or_else()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:90:17
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:92:17
    |
 LL |     let _val2 = val.unwrap_or_else(|_| 2);
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Ok` and `unwrap_or_else()`
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:87:15
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:89:15
    |
 LL |     let val = Ok::<_, ()>(1);
    |               ^^^^^^^^^^^^^^
 
 error: used `unwrap_or()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:94:16
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:96:16
    |
 LL |     let _val = Ok::<usize, ()>([1, 2, 3].iter().sum()).unwrap_or(2);
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Ok` and `unwrap_or()`
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:94:16
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:96:16
    |
 LL |     let _val = Ok::<usize, ()>([1, 2, 3].iter().sum()).unwrap_or(2);
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: used `unwrap_or_default()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:95:16
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:97:16
    |
 LL |     let _val = Ok::<usize, ()>([1, 2, 3].iter().sum()).unwrap_or_default();
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Ok` and `unwrap_or_default()`
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:95:16
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:97:16
    |
 LL |     let _val = Ok::<usize, ()>([1, 2, 3].iter().sum()).unwrap_or_default();
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: used `unwrap_or_else()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:96:16
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:98:16
    |
 LL |     let _val = Ok::<usize, ()>([1, 2, 3].iter().sum()).unwrap_or_else(|_| 2);
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Ok` and `unwrap_or_else()`
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:96:16
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:98:16
    |
 LL |     let _val = Ok::<usize, ()>([1, 2, 3].iter().sum()).unwrap_or_else(|_| 2);
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: used `unwrap_or()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:99:17
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:101:17
    |
 LL |     let _val2 = val.unwrap_or(2);
    |                 ^^^^^^^^^^^^^^^^
    |
 help: remove the `Ok` and `unwrap_or()`
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:98:15
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:100:15
    |
 LL |     let val = Ok::<usize, ()>([1, 2, 3].iter().sum());
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: used `unwrap_or_default()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:100:17
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:102:17
    |
 LL |     let _val2 = val.unwrap_or_default();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Ok` and `unwrap_or_default()`
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:98:15
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:100:15
    |
 LL |     let val = Ok::<usize, ()>([1, 2, 3].iter().sum());
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: used `unwrap_or_else()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:101:17
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:103:17
    |
 LL |     let _val2 = val.unwrap_or_else(|_| 2);
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Ok` and `unwrap_or_else()`
-  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:98:15
+  --> $DIR/unnecessary_literal_unwrap_unfixable.rs:100:15
    |
 LL |     let val = Ok::<usize, ()>([1, 2, 3].iter().sum());
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 50 previous errors
+error: aborting due to 52 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 8d258c15080f23b13b5268ac757c8f71adbe38b6 Mon Sep 17 00:00:00 2001
From: syvb <smitty@timescale.com>
Date: Wed, 5 Jul 2023 23:24:20 -0400
Subject: Add handling for None.unwrap_or(_else)

---
 .../src/methods/unnecessary_literal_unwrap.rs      |  19 +++
 tests/ui/unnecessary_literal_unwrap.fixed          |   9 ++
 tests/ui/unnecessary_literal_unwrap.rs             |   9 ++
 tests/ui/unnecessary_literal_unwrap.stderr         | 180 ++++++++++++++++-----
 4 files changed, 175 insertions(+), 42 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/unnecessary_literal_unwrap.rs b/clippy_lints/src/methods/unnecessary_literal_unwrap.rs
index 6d9a0451073..937aac8d25e 100644
--- a/clippy_lints/src/methods/unnecessary_literal_unwrap.rs
+++ b/clippy_lints/src/methods/unnecessary_literal_unwrap.rs
@@ -24,6 +24,7 @@ fn get_ty_from_args<'a>(args: Option<&'a [hir::GenericArg<'a>]>, index: usize) -
     }
 }
 
+#[expect(clippy::too_many_lines)]
 pub(super) fn check(
     cx: &LateContext<'_>,
     expr: &hir::Expr<'_>,
@@ -95,6 +96,24 @@ pub(super) fn check(
                 };
                 Some(vec![(expr.span, format!("{default_ty_string}::default()"))])
             },
+            ("None", "unwrap_or", _) => Some(vec![
+                (expr.span.with_hi(args[0].span.lo()), String::new()),
+                (expr.span.with_lo(args[0].span.hi()), String::new()),
+            ]),
+            ("None", "unwrap_or_else", _) => match args[0].kind {
+                hir::ExprKind::Closure(hir::Closure {
+                    fn_decl:
+                        hir::FnDecl {
+                            output: hir::FnRetTy::DefaultReturn(span) | hir::FnRetTy::Return(hir::Ty { span, .. }),
+                            ..
+                        },
+                    ..
+                }) => Some(vec![
+                    (expr.span.with_hi(span.hi()), String::new()),
+                    (expr.span.with_lo(args[0].span.hi()), String::new()),
+                ]),
+                _ => None,
+            },
             _ if call_args.is_empty() => None,
             (_, _, Some(_)) => None,
             ("Ok", "unwrap_err", None) | ("Err", "unwrap", None) => Some(vec![
diff --git a/tests/ui/unnecessary_literal_unwrap.fixed b/tests/ui/unnecessary_literal_unwrap.fixed
index 5eaa117b8e8..72d52c62355 100644
--- a/tests/ui/unnecessary_literal_unwrap.fixed
+++ b/tests/ui/unnecessary_literal_unwrap.fixed
@@ -16,14 +16,23 @@ fn unwrap_option_some() {
     1;
 }
 
+#[rustfmt::skip] // force rustfmt not to remove braces in `|| { 234 }`
 fn unwrap_option_none() {
     let _val = panic!();
     let _val = panic!("this always happens");
     let _val: String = String::default();
+    let _val: u16 = 234;
+    let _val: u16 = 234;
+    let _val: u16 = { 234 };
+    let _val: u16 =  { 234 };
 
     panic!();
     panic!("this always happens");
     String::default();
+    234;
+    234;
+    { 234 };
+     { 234 };
 }
 
 fn unwrap_result_ok() {
diff --git a/tests/ui/unnecessary_literal_unwrap.rs b/tests/ui/unnecessary_literal_unwrap.rs
index 6408851b42a..7d713ea205f 100644
--- a/tests/ui/unnecessary_literal_unwrap.rs
+++ b/tests/ui/unnecessary_literal_unwrap.rs
@@ -16,14 +16,23 @@ fn unwrap_option_some() {
     Some(1).expect("this never happens");
 }
 
+#[rustfmt::skip] // force rustfmt not to remove braces in `|| { 234 }`
 fn unwrap_option_none() {
     let _val = None::<()>.unwrap();
     let _val = None::<()>.expect("this always happens");
     let _val: String = None.unwrap_or_default();
+    let _val: u16 = None.unwrap_or(234);
+    let _val: u16 = None.unwrap_or_else(|| 234);
+    let _val: u16 = None.unwrap_or_else(|| { 234 });
+    let _val: u16 = None.unwrap_or_else(|| -> u16 { 234 });
 
     None::<()>.unwrap();
     None::<()>.expect("this always happens");
     None::<String>.unwrap_or_default();
+    None::<u16>.unwrap_or(234);
+    None::<u16>.unwrap_or_else(|| 234);
+    None::<u16>.unwrap_or_else(|| { 234 });
+    None::<u16>.unwrap_or_else(|| -> u16 { 234 });
 }
 
 fn unwrap_result_ok() {
diff --git a/tests/ui/unnecessary_literal_unwrap.stderr b/tests/ui/unnecessary_literal_unwrap.stderr
index acaf37b13a5..7f603d6ef58 100644
--- a/tests/ui/unnecessary_literal_unwrap.stderr
+++ b/tests/ui/unnecessary_literal_unwrap.stderr
@@ -48,13 +48,13 @@ LL +     1;
    |
 
 error: used `unwrap()` on `None` value
-  --> $DIR/unnecessary_literal_unwrap.rs:20:16
+  --> $DIR/unnecessary_literal_unwrap.rs:21:16
    |
 LL |     let _val = None::<()>.unwrap();
    |                ^^^^^^^^^^^^^^^^^^^ help: remove the `None` and `unwrap()`: `panic!()`
 
 error: used `expect()` on `None` value
-  --> $DIR/unnecessary_literal_unwrap.rs:21:16
+  --> $DIR/unnecessary_literal_unwrap.rs:22:16
    |
 LL |     let _val = None::<()>.expect("this always happens");
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -65,19 +65,67 @@ LL |     let _val = panic!("this always happens");
    |                ~~~~~~~                     ~
 
 error: used `unwrap_or_default()` on `None` value
-  --> $DIR/unnecessary_literal_unwrap.rs:22:24
+  --> $DIR/unnecessary_literal_unwrap.rs:23:24
    |
 LL |     let _val: String = None.unwrap_or_default();
    |                        ^^^^^^^^^^^^^^^^^^^^^^^^ help: remove the `None` and `unwrap_or_default()`: `String::default()`
 
+error: used `unwrap_or()` on `None` value
+  --> $DIR/unnecessary_literal_unwrap.rs:24:21
+   |
+LL |     let _val: u16 = None.unwrap_or(234);
+   |                     ^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the `None` and `unwrap_or()`
+   |
+LL -     let _val: u16 = None.unwrap_or(234);
+LL +     let _val: u16 = 234;
+   |
+
+error: used `unwrap_or_else()` on `None` value
+  --> $DIR/unnecessary_literal_unwrap.rs:25:21
+   |
+LL |     let _val: u16 = None.unwrap_or_else(|| 234);
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the `None` and `unwrap_or_else()`
+   |
+LL -     let _val: u16 = None.unwrap_or_else(|| 234);
+LL +     let _val: u16 = 234;
+   |
+
+error: used `unwrap_or_else()` on `None` value
+  --> $DIR/unnecessary_literal_unwrap.rs:26:21
+   |
+LL |     let _val: u16 = None.unwrap_or_else(|| { 234 });
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the `None` and `unwrap_or_else()`
+   |
+LL -     let _val: u16 = None.unwrap_or_else(|| { 234 });
+LL +     let _val: u16 = { 234 };
+   |
+
+error: used `unwrap_or_else()` on `None` value
+  --> $DIR/unnecessary_literal_unwrap.rs:27:21
+   |
+LL |     let _val: u16 = None.unwrap_or_else(|| -> u16 { 234 });
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the `None` and `unwrap_or_else()`
+   |
+LL -     let _val: u16 = None.unwrap_or_else(|| -> u16 { 234 });
+LL +     let _val: u16 =  { 234 };
+   |
+
 error: used `unwrap()` on `None` value
-  --> $DIR/unnecessary_literal_unwrap.rs:24:5
+  --> $DIR/unnecessary_literal_unwrap.rs:29:5
    |
 LL |     None::<()>.unwrap();
    |     ^^^^^^^^^^^^^^^^^^^ help: remove the `None` and `unwrap()`: `panic!()`
 
 error: used `expect()` on `None` value
-  --> $DIR/unnecessary_literal_unwrap.rs:25:5
+  --> $DIR/unnecessary_literal_unwrap.rs:30:5
    |
 LL |     None::<()>.expect("this always happens");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -88,13 +136,61 @@ LL |     panic!("this always happens");
    |     ~~~~~~~                     ~
 
 error: used `unwrap_or_default()` on `None` value
-  --> $DIR/unnecessary_literal_unwrap.rs:26:5
+  --> $DIR/unnecessary_literal_unwrap.rs:31:5
    |
 LL |     None::<String>.unwrap_or_default();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove the `None` and `unwrap_or_default()`: `String::default()`
 
+error: used `unwrap_or()` on `None` value
+  --> $DIR/unnecessary_literal_unwrap.rs:32:5
+   |
+LL |     None::<u16>.unwrap_or(234);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the `None` and `unwrap_or()`
+   |
+LL -     None::<u16>.unwrap_or(234);
+LL +     234;
+   |
+
+error: used `unwrap_or_else()` on `None` value
+  --> $DIR/unnecessary_literal_unwrap.rs:33:5
+   |
+LL |     None::<u16>.unwrap_or_else(|| 234);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the `None` and `unwrap_or_else()`
+   |
+LL -     None::<u16>.unwrap_or_else(|| 234);
+LL +     234;
+   |
+
+error: used `unwrap_or_else()` on `None` value
+  --> $DIR/unnecessary_literal_unwrap.rs:34:5
+   |
+LL |     None::<u16>.unwrap_or_else(|| { 234 });
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the `None` and `unwrap_or_else()`
+   |
+LL -     None::<u16>.unwrap_or_else(|| { 234 });
+LL +     { 234 };
+   |
+
+error: used `unwrap_or_else()` on `None` value
+  --> $DIR/unnecessary_literal_unwrap.rs:35:5
+   |
+LL |     None::<u16>.unwrap_or_else(|| -> u16 { 234 });
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the `None` and `unwrap_or_else()`
+   |
+LL -     None::<u16>.unwrap_or_else(|| -> u16 { 234 });
+LL +      { 234 };
+   |
+
 error: used `unwrap()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap.rs:30:16
+  --> $DIR/unnecessary_literal_unwrap.rs:39:16
    |
 LL |     let _val = Ok::<_, ()>(1).unwrap();
    |                ^^^^^^^^^^^^^^^^^^^^^^^
@@ -106,7 +202,7 @@ LL +     let _val = 1;
    |
 
 error: used `expect()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap.rs:31:16
+  --> $DIR/unnecessary_literal_unwrap.rs:40:16
    |
 LL |     let _val = Ok::<_, ()>(1).expect("this never happens");
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -118,7 +214,7 @@ LL +     let _val = 1;
    |
 
 error: used `unwrap_err()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap.rs:32:16
+  --> $DIR/unnecessary_literal_unwrap.rs:41:16
    |
 LL |     let _val = Ok::<_, ()>(1).unwrap_err();
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -129,7 +225,7 @@ LL |     let _val = panic!("{:?}", 1);
    |                ~~~~~~~~~~~~~~  ~
 
 error: used `expect_err()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap.rs:33:16
+  --> $DIR/unnecessary_literal_unwrap.rs:42:16
    |
 LL |     let _val = Ok::<_, ()>(1).expect_err("this always happens");
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -140,7 +236,7 @@ LL |     let _val = panic!("{1}: {:?}", 1, "this always happens");
    |                ~~~~~~~~~~~~~~~~~~~  ~
 
 error: used `unwrap()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap.rs:35:5
+  --> $DIR/unnecessary_literal_unwrap.rs:44:5
    |
 LL |     Ok::<_, ()>(1).unwrap();
    |     ^^^^^^^^^^^^^^^^^^^^^^^
@@ -152,7 +248,7 @@ LL +     1;
    |
 
 error: used `expect()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap.rs:36:5
+  --> $DIR/unnecessary_literal_unwrap.rs:45:5
    |
 LL |     Ok::<_, ()>(1).expect("this never happens");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -164,7 +260,7 @@ LL +     1;
    |
 
 error: used `unwrap_err()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap.rs:37:5
+  --> $DIR/unnecessary_literal_unwrap.rs:46:5
    |
 LL |     Ok::<_, ()>(1).unwrap_err();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -175,7 +271,7 @@ LL |     panic!("{:?}", 1);
    |     ~~~~~~~~~~~~~~  ~
 
 error: used `expect_err()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap.rs:38:5
+  --> $DIR/unnecessary_literal_unwrap.rs:47:5
    |
 LL |     Ok::<_, ()>(1).expect_err("this always happens");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -186,7 +282,7 @@ LL |     panic!("{1}: {:?}", 1, "this always happens");
    |     ~~~~~~~~~~~~~~~~~~~  ~
 
 error: used `unwrap_err()` on `Err` value
-  --> $DIR/unnecessary_literal_unwrap.rs:42:16
+  --> $DIR/unnecessary_literal_unwrap.rs:51:16
    |
 LL |     let _val = Err::<(), _>(1).unwrap_err();
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -198,7 +294,7 @@ LL +     let _val = 1;
    |
 
 error: used `expect_err()` on `Err` value
-  --> $DIR/unnecessary_literal_unwrap.rs:43:16
+  --> $DIR/unnecessary_literal_unwrap.rs:52:16
    |
 LL |     let _val = Err::<(), _>(1).expect_err("this never happens");
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -210,7 +306,7 @@ LL +     let _val = 1;
    |
 
 error: used `unwrap()` on `Err` value
-  --> $DIR/unnecessary_literal_unwrap.rs:44:16
+  --> $DIR/unnecessary_literal_unwrap.rs:53:16
    |
 LL |     let _val = Err::<(), _>(1).unwrap();
    |                ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -221,7 +317,7 @@ LL |     let _val = panic!("{:?}", 1);
    |                ~~~~~~~~~~~~~~  ~
 
 error: used `expect()` on `Err` value
-  --> $DIR/unnecessary_literal_unwrap.rs:45:16
+  --> $DIR/unnecessary_literal_unwrap.rs:54:16
    |
 LL |     let _val = Err::<(), _>(1).expect("this always happens");
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -232,7 +328,7 @@ LL |     let _val = panic!("{1}: {:?}", 1, "this always happens");
    |                ~~~~~~~~~~~~~~~~~~~  ~
 
 error: used `unwrap_err()` on `Err` value
-  --> $DIR/unnecessary_literal_unwrap.rs:47:5
+  --> $DIR/unnecessary_literal_unwrap.rs:56:5
    |
 LL |     Err::<(), _>(1).unwrap_err();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -244,7 +340,7 @@ LL +     1;
    |
 
 error: used `expect_err()` on `Err` value
-  --> $DIR/unnecessary_literal_unwrap.rs:48:5
+  --> $DIR/unnecessary_literal_unwrap.rs:57:5
    |
 LL |     Err::<(), _>(1).expect_err("this never happens");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -256,7 +352,7 @@ LL +     1;
    |
 
 error: used `unwrap()` on `Err` value
-  --> $DIR/unnecessary_literal_unwrap.rs:49:5
+  --> $DIR/unnecessary_literal_unwrap.rs:58:5
    |
 LL |     Err::<(), _>(1).unwrap();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -267,7 +363,7 @@ LL |     panic!("{:?}", 1);
    |     ~~~~~~~~~~~~~~  ~
 
 error: used `expect()` on `Err` value
-  --> $DIR/unnecessary_literal_unwrap.rs:50:5
+  --> $DIR/unnecessary_literal_unwrap.rs:59:5
    |
 LL |     Err::<(), _>(1).expect("this always happens");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -278,7 +374,7 @@ LL |     panic!("{1}: {:?}", 1, "this always happens");
    |     ~~~~~~~~~~~~~~~~~~~  ~
 
 error: used `unwrap_or()` on `Some` value
-  --> $DIR/unnecessary_literal_unwrap.rs:54:16
+  --> $DIR/unnecessary_literal_unwrap.rs:63:16
    |
 LL |     let _val = Some(1).unwrap_or(2);
    |                ^^^^^^^^^^^^^^^^^^^^
@@ -290,7 +386,7 @@ LL +     let _val = 1;
    |
 
 error: used `unwrap_or_default()` on `Some` value
-  --> $DIR/unnecessary_literal_unwrap.rs:55:16
+  --> $DIR/unnecessary_literal_unwrap.rs:64:16
    |
 LL |     let _val = Some(1).unwrap_or_default();
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -302,7 +398,7 @@ LL +     let _val = 1;
    |
 
 error: used `unwrap_or_else()` on `Some` value
-  --> $DIR/unnecessary_literal_unwrap.rs:56:16
+  --> $DIR/unnecessary_literal_unwrap.rs:65:16
    |
 LL |     let _val = Some(1).unwrap_or_else(|| 2);
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -314,7 +410,7 @@ LL +     let _val = 1;
    |
 
 error: used `unwrap_or()` on `Some` value
-  --> $DIR/unnecessary_literal_unwrap.rs:58:5
+  --> $DIR/unnecessary_literal_unwrap.rs:67:5
    |
 LL |     Some(1).unwrap_or(2);
    |     ^^^^^^^^^^^^^^^^^^^^
@@ -326,7 +422,7 @@ LL +     1;
    |
 
 error: used `unwrap_or_default()` on `Some` value
-  --> $DIR/unnecessary_literal_unwrap.rs:59:5
+  --> $DIR/unnecessary_literal_unwrap.rs:68:5
    |
 LL |     Some(1).unwrap_or_default();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -338,7 +434,7 @@ LL +     1;
    |
 
 error: used `unwrap_or_else()` on `Some` value
-  --> $DIR/unnecessary_literal_unwrap.rs:60:5
+  --> $DIR/unnecessary_literal_unwrap.rs:69:5
    |
 LL |     Some(1).unwrap_or_else(|| 2);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -350,7 +446,7 @@ LL +     1;
    |
 
 error: used `unwrap_or()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap.rs:64:16
+  --> $DIR/unnecessary_literal_unwrap.rs:73:16
    |
 LL |     let _val = Ok::<_, ()>(1).unwrap_or(2);
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -362,7 +458,7 @@ LL +     let _val = 1;
    |
 
 error: used `unwrap_or_default()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap.rs:65:16
+  --> $DIR/unnecessary_literal_unwrap.rs:74:16
    |
 LL |     let _val = Ok::<_, ()>(1).unwrap_or_default();
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -374,7 +470,7 @@ LL +     let _val = 1;
    |
 
 error: used `unwrap_or_else()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap.rs:66:16
+  --> $DIR/unnecessary_literal_unwrap.rs:75:16
    |
 LL |     let _val = Ok::<_, ()>(1).unwrap_or_else(|_| 2);
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -386,7 +482,7 @@ LL +     let _val = 1;
    |
 
 error: used `unwrap_or()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap.rs:68:5
+  --> $DIR/unnecessary_literal_unwrap.rs:77:5
    |
 LL |     Ok::<_, ()>(1).unwrap_or(2);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -398,7 +494,7 @@ LL +     1;
    |
 
 error: used `unwrap_or_default()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap.rs:69:5
+  --> $DIR/unnecessary_literal_unwrap.rs:78:5
    |
 LL |     Ok::<_, ()>(1).unwrap_or_default();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -410,7 +506,7 @@ LL +     1;
    |
 
 error: used `unwrap_or_else()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap.rs:70:5
+  --> $DIR/unnecessary_literal_unwrap.rs:79:5
    |
 LL |     Ok::<_, ()>(1).unwrap_or_else(|_| 2);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -422,7 +518,7 @@ LL +     1;
    |
 
 error: used `unwrap_unchecked()` on `Some` value
-  --> $DIR/unnecessary_literal_unwrap.rs:84:22
+  --> $DIR/unnecessary_literal_unwrap.rs:93:22
    |
 LL |     let _ = unsafe { Some(1).unwrap_unchecked() };
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -434,7 +530,7 @@ LL +     let _ = 1;
    |
 
 error: used `unwrap_unchecked()` on `Some` value
-  --> $DIR/unnecessary_literal_unwrap.rs:85:22
+  --> $DIR/unnecessary_literal_unwrap.rs:94:22
    |
 LL |     let _ = unsafe { Some(1).unwrap_unchecked() + *(&1 as *const i32) }; // needs to keep the unsafe block
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -446,7 +542,7 @@ LL +     let _ = unsafe { 1 + *(&1 as *const i32) }; // needs to keep the unsafe
    |
 
 error: used `unwrap_unchecked()` on `Some` value
-  --> $DIR/unnecessary_literal_unwrap.rs:86:22
+  --> $DIR/unnecessary_literal_unwrap.rs:95:22
    |
 LL |     let _ = unsafe { Some(1).unwrap_unchecked() } + 1;
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -458,7 +554,7 @@ LL +     let _ = 1 + 1;
    |
 
 error: used `unwrap_unchecked()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap.rs:87:22
+  --> $DIR/unnecessary_literal_unwrap.rs:96:22
    |
 LL |     let _ = unsafe { Ok::<_, ()>(1).unwrap_unchecked() };
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -470,7 +566,7 @@ LL +     let _ = 1;
    |
 
 error: used `unwrap_unchecked()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap.rs:88:22
+  --> $DIR/unnecessary_literal_unwrap.rs:97:22
    |
 LL |     let _ = unsafe { Ok::<_, ()>(1).unwrap_unchecked() + *(&1 as *const i32) };
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -482,7 +578,7 @@ LL +     let _ = unsafe { 1 + *(&1 as *const i32) };
    |
 
 error: used `unwrap_unchecked()` on `Ok` value
-  --> $DIR/unnecessary_literal_unwrap.rs:89:22
+  --> $DIR/unnecessary_literal_unwrap.rs:98:22
    |
 LL |     let _ = unsafe { Ok::<_, ()>(1).unwrap_unchecked() } + 1;
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -494,7 +590,7 @@ LL +     let _ = 1 + 1;
    |
 
 error: used `unwrap_err_unchecked()` on `Err` value
-  --> $DIR/unnecessary_literal_unwrap.rs:90:22
+  --> $DIR/unnecessary_literal_unwrap.rs:99:22
    |
 LL |     let _ = unsafe { Err::<(), i32>(123).unwrap_err_unchecked() };
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -505,5 +601,5 @@ LL -     let _ = unsafe { Err::<(), i32>(123).unwrap_err_unchecked() };
 LL +     let _ = 123;
    |
 
-error: aborting due to 45 previous errors
+error: aborting due to 53 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 1f82f6ddf30568af39b2f8bed6c723822b39aabe Mon Sep 17 00:00:00 2001
From: Caio <c410.f3r@gmail.com>
Date: Fri, 14 Jul 2023 13:51:34 -0300
Subject: [significant_drop_tightening] Fix #11160

---
 clippy_lints/src/significant_drop_tightening.rs | 11 +++++++----
 tests/ui/significant_drop_tightening.fixed      |  7 +++++++
 tests/ui/significant_drop_tightening.rs         |  7 +++++++
 tests/ui/significant_drop_tightening.stderr     |  6 +++---
 4 files changed, 24 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/significant_drop_tightening.rs b/clippy_lints/src/significant_drop_tightening.rs
index bf1059a8b29..8f8614ab305 100644
--- a/clippy_lints/src/significant_drop_tightening.rs
+++ b/clippy_lints/src/significant_drop_tightening.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::{indent_of, snippet};
-use clippy_utils::{expr_or_init, get_attr, path_to_local};
+use clippy_utils::{expr_or_init, get_attr, path_to_local, peel_hir_expr_unary};
 use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexMap};
 use rustc_errors::Applicability;
 use rustc_hir::def::{DefKind, Res};
@@ -236,7 +236,7 @@ impl<'ap, 'lc, 'others, 'stmt, 'tcx> StmtsChecker<'ap, 'lc, 'others, 'stmt, 'tcx
 
     fn manage_has_expensive_expr_after_last_attr(&mut self) {
         let has_expensive_stmt = match self.ap.curr_stmt.kind {
-            hir::StmtKind::Expr(expr) if !is_expensive_expr(expr) => false,
+            hir::StmtKind::Expr(expr) if is_inexpensive_expr(expr) => false,
             hir::StmtKind::Local(local) if let Some(expr) = local.init
                 && let hir::ExprKind::Path(_) = expr.kind => false,
             _ => true
@@ -445,6 +445,9 @@ fn has_drop(expr: &hir::Expr<'_>, first_bind_ident: &Ident, lcx: &LateContext<'_
     }
 }
 
-fn is_expensive_expr(expr: &hir::Expr<'_>) -> bool {
-    !matches!(expr.kind, hir::ExprKind::Path(_))
+fn is_inexpensive_expr(expr: &hir::Expr<'_>) -> bool {
+    let actual = peel_hir_expr_unary(expr).0;
+    let is_path = matches!(actual.kind, hir::ExprKind::Path(_));
+    let is_lit = matches!(actual.kind, hir::ExprKind::Lit(_));
+    is_path || is_lit
 }
diff --git a/tests/ui/significant_drop_tightening.fixed b/tests/ui/significant_drop_tightening.fixed
index eb8524167c4..aa6690b77e1 100644
--- a/tests/ui/significant_drop_tightening.fixed
+++ b/tests/ui/significant_drop_tightening.fixed
@@ -51,6 +51,13 @@ pub fn issue_11128() {
     }
 }
 
+pub fn issue_11160() -> bool {
+    let mutex = Mutex::new(1i32);
+    let lock = mutex.lock().unwrap();
+    let _ = lock.abs();
+    true
+}
+
 pub fn path_return_can_be_ignored() -> i32 {
     let mutex = Mutex::new(1);
     let lock = mutex.lock().unwrap();
diff --git a/tests/ui/significant_drop_tightening.rs b/tests/ui/significant_drop_tightening.rs
index f7fa65ea922..a0bf657df55 100644
--- a/tests/ui/significant_drop_tightening.rs
+++ b/tests/ui/significant_drop_tightening.rs
@@ -50,6 +50,13 @@ pub fn issue_11128() {
     }
 }
 
+pub fn issue_11160() -> bool {
+    let mutex = Mutex::new(1i32);
+    let lock = mutex.lock().unwrap();
+    let _ = lock.abs();
+    true
+}
+
 pub fn path_return_can_be_ignored() -> i32 {
     let mutex = Mutex::new(1);
     let lock = mutex.lock().unwrap();
diff --git a/tests/ui/significant_drop_tightening.stderr b/tests/ui/significant_drop_tightening.stderr
index ca4fede17c9..45ca73af3a8 100644
--- a/tests/ui/significant_drop_tightening.stderr
+++ b/tests/ui/significant_drop_tightening.stderr
@@ -23,7 +23,7 @@ LL +     drop(lock);
    |
 
 error: temporary with significant `Drop` can be early dropped
-  --> $DIR/significant_drop_tightening.rs:79:13
+  --> $DIR/significant_drop_tightening.rs:86:13
    |
 LL | /     {
 LL | |         let mutex = Mutex::new(1i32);
@@ -43,7 +43,7 @@ LL +         drop(lock);
    |
 
 error: temporary with significant `Drop` can be early dropped
-  --> $DIR/significant_drop_tightening.rs:100:13
+  --> $DIR/significant_drop_tightening.rs:107:13
    |
 LL | /     {
 LL | |         let mutex = Mutex::new(1i32);
@@ -67,7 +67,7 @@ LL +
    |
 
 error: temporary with significant `Drop` can be early dropped
-  --> $DIR/significant_drop_tightening.rs:106:17
+  --> $DIR/significant_drop_tightening.rs:113:17
    |
 LL | /     {
 LL | |         let mutex = Mutex::new(vec![1i32]);
-- 
cgit 1.4.1-3-g733a5


From eaccc6d38f356fb27bb69aa706f3862b2dc71276 Mon Sep 17 00:00:00 2001
From: Sylvestre Ledru <sylvestre@debian.org>
Date: Mon, 3 Jul 2023 14:42:50 +0200
Subject: [`semicolon_if_nothing_returned`]: enable the autofix

---
 clippy_lints/src/semicolon_if_nothing_returned.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/semicolon_if_nothing_returned.rs b/clippy_lints/src/semicolon_if_nothing_returned.rs
index 355f907e257..c9547cd95dc 100644
--- a/clippy_lints/src/semicolon_if_nothing_returned.rs
+++ b/clippy_lints/src/semicolon_if_nothing_returned.rs
@@ -43,7 +43,7 @@ impl<'tcx> LateLintPass<'tcx> for SemicolonIfNothingReturned {
             if let Some(expr) = block.expr;
             let t_expr = cx.typeck_results().expr_ty(expr);
             if t_expr.is_unit();
-            let mut app = Applicability::MaybeIncorrect;
+            let mut app = Applicability::MachineApplicable;
             if let snippet = snippet_with_context(cx, expr.span, block.span.ctxt(), "}", &mut app).0;
             if !snippet.ends_with('}') && !snippet.ends_with(';');
             if cx.sess().source_map().is_multiline(block.span);
-- 
cgit 1.4.1-3-g733a5


From c3881569afd049d391d6943bff9ee7317fe98211 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Fri, 7 Jul 2023 00:45:37 +0200
Subject: new lint: `format_collect`

---
 CHANGELOG.md                               |  1 +
 clippy_lints/src/declared_lints.rs         |  1 +
 clippy_lints/src/methods/format_collect.rs | 33 ++++++++++++++++++++++
 clippy_lints/src/methods/mod.rs            | 35 +++++++++++++++++++++++-
 src/main.rs                                |  3 +-
 tests/ui/format_collect.rs                 | 26 ++++++++++++++++++
 tests/ui/format_collect.stderr             | 44 ++++++++++++++++++++++++++++++
 7 files changed, 140 insertions(+), 3 deletions(-)
 create mode 100644 clippy_lints/src/methods/format_collect.rs
 create mode 100644 tests/ui/format_collect.rs
 create mode 100644 tests/ui/format_collect.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index b3b6e3b865f..ea8450ed5c2 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4865,6 +4865,7 @@ Released 2018-09-13
 [`forget_copy`]: https://rust-lang.github.io/rust-clippy/master/index.html#forget_copy
 [`forget_non_drop`]: https://rust-lang.github.io/rust-clippy/master/index.html#forget_non_drop
 [`forget_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#forget_ref
+[`format_collect`]: https://rust-lang.github.io/rust-clippy/master/index.html#format_collect
 [`format_in_format_args`]: https://rust-lang.github.io/rust-clippy/master/index.html#format_in_format_args
 [`format_push_string`]: https://rust-lang.github.io/rust-clippy/master/index.html#format_push_string
 [`from_iter_instead_of_collect`]: https://rust-lang.github.io/rust-clippy/master/index.html#from_iter_instead_of_collect
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 498d657b31f..7472158a81c 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -338,6 +338,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::methods::FILTER_NEXT_INFO,
     crate::methods::FLAT_MAP_IDENTITY_INFO,
     crate::methods::FLAT_MAP_OPTION_INFO,
+    crate::methods::FORMAT_COLLECT_INFO,
     crate::methods::FROM_ITER_INSTEAD_OF_COLLECT_INFO,
     crate::methods::GET_FIRST_INFO,
     crate::methods::GET_LAST_WITH_LEN_INFO,
diff --git a/clippy_lints/src/methods/format_collect.rs b/clippy_lints/src/methods/format_collect.rs
new file mode 100644
index 00000000000..74eb80782d6
--- /dev/null
+++ b/clippy_lints/src/methods/format_collect.rs
@@ -0,0 +1,33 @@
+use super::FORMAT_COLLECT;
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::macros::is_format_macro;
+use clippy_utils::macros::root_macro_call_first_node;
+use clippy_utils::ty::is_type_lang_item;
+use rustc_hir::Expr;
+use rustc_hir::ExprKind;
+use rustc_hir::LangItem;
+use rustc_lint::LateContext;
+use rustc_span::Span;
+
+fn tail_expr<'tcx>(expr: &'tcx Expr<'tcx>) -> Option<&'tcx Expr<'tcx>> {
+    match expr.kind {
+        ExprKind::Block(block, _) if !expr.span.from_expansion() => block.expr,
+        _ => Some(expr),
+    }
+}
+
+pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, map_arg: &Expr<'_>, map_span: Span) {
+    if is_type_lang_item(cx, cx.typeck_results().expr_ty(expr), LangItem::String)
+        && let ExprKind::Closure(closure) = map_arg.kind
+        && let body = cx.tcx.hir().body(closure.body)
+        && let Some(value) = tail_expr(body.value)
+        && let Some(mac) = root_macro_call_first_node(cx, value)
+        && is_format_macro(cx, mac.def_id)
+    {
+        span_lint_and_then(cx, FORMAT_COLLECT, expr.span, "use of `format!` to build up a string from an iterator", |diag| {
+            diag.span_help(map_span, "call `fold` instead")
+                .span_help(value.span.source_callsite(), "... and use the `write!` macro here")
+                .note("this can be written more efficiently by appending to a `String` directly");
+        });
+    }
+}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 2747ab5615c..f55a7727fad 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -26,6 +26,7 @@ mod filter_map_next;
 mod filter_next;
 mod flat_map_identity;
 mod flat_map_option;
+mod format_collect;
 mod from_iter_instead_of_collect;
 mod get_first;
 mod get_last_with_len;
@@ -3378,6 +3379,36 @@ declare_clippy_lint! {
     "calling `Stdin::read_line`, then trying to parse it without first trimming"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of `.map(|_| format!(..)).collect::<String>()`.
+    ///
+    /// ### Why is this bad?
+    /// This allocates a new string for every element in the iterator.
+    /// This can be done more efficiently by creating the `String` once and appending to it using `Iterator::fold`.
+    ///
+    /// ### Example
+    /// ```rust
+    /// fn hex_encode(bytes: &[u8]) -> String {
+    ///     bytes.iter().map(|b| format!("{b:02X}")).collect()
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// use std::fmt::Write;
+    /// fn hex_encode(bytes: &[u8]) -> String {
+    ///     bytes.iter().fold(String::new(), |mut output, b| {
+    ///         let _ = write!(output, "{b:02X}");
+    ///         output
+    ///     })
+    /// }
+    /// ```
+    #[clippy::version = "1.72.0"]
+    pub FORMAT_COLLECT,
+    perf,
+    "`format!`ing every element in a collection, then collecting the strings into a new `String`"
+}
+
 pub struct Methods {
     avoid_breaking_exported_api: bool,
     msrv: Msrv,
@@ -3512,6 +3543,7 @@ impl_lint_pass!(Methods => [
     UNNECESSARY_LITERAL_UNWRAP,
     DRAIN_COLLECT,
     MANUAL_TRY_FOLD,
+    FORMAT_COLLECT,
 ]);
 
 /// Extracts a method call name, args, and `Span` of the method name.
@@ -3733,8 +3765,9 @@ impl Methods {
                         Some((name @ ("cloned" | "copied"), recv2, [], _, _)) => {
                             iter_cloned_collect::check(cx, name, expr, recv2);
                         },
-                        Some(("map", m_recv, [m_arg], _, _)) => {
+                        Some(("map", m_recv, [m_arg], m_ident_span, _)) => {
                             map_collect_result_unit::check(cx, expr, m_recv, m_arg);
+                            format_collect::check(cx, expr, m_arg, m_ident_span);
                         },
                         Some(("take", take_self_arg, [take_arg], _, _)) => {
                             if self.msrv.meets(msrvs::STR_REPEAT) {
diff --git a/src/main.rs b/src/main.rs
index cdc85cb33ca..26b655076cf 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -132,8 +132,7 @@ impl ClippyCmd {
         let clippy_args: String = self
             .clippy_args
             .iter()
-            .map(|arg| format!("{arg}__CLIPPY_HACKERY__"))
-            .collect();
+            .fold(String::new(), |s, arg| s + arg + "__CLIPPY_HACKERY__");
 
         // Currently, `CLIPPY_TERMINAL_WIDTH` is used only to format "unknown field" error messages.
         let terminal_width = termize::dimensions().map_or(0, |(w, _)| w);
diff --git a/tests/ui/format_collect.rs b/tests/ui/format_collect.rs
new file mode 100644
index 00000000000..ecadb43ecb4
--- /dev/null
+++ b/tests/ui/format_collect.rs
@@ -0,0 +1,26 @@
+#![allow(unused, dead_code)]
+#![warn(clippy::format_collect)]
+
+fn hex_encode(bytes: &[u8]) -> String {
+    bytes.iter().map(|b| format!("{b:02X}")).collect()
+}
+
+macro_rules! fmt {
+    ($x:ident) => {
+        format!("{x:02X}", x = $x)
+    };
+}
+
+fn from_macro(bytes: &[u8]) -> String {
+    bytes.iter().map(|x| fmt!(x)).collect()
+}
+
+fn with_block() -> String {
+    (1..10)
+        .map(|s| {
+            let y = 1;
+            format!("{s} {y}")
+        })
+        .collect()
+}
+fn main() {}
diff --git a/tests/ui/format_collect.stderr b/tests/ui/format_collect.stderr
new file mode 100644
index 00000000000..cd71a853762
--- /dev/null
+++ b/tests/ui/format_collect.stderr
@@ -0,0 +1,44 @@
+error: use of `format!` to build up a string from an iterator
+  --> $DIR/format_collect.rs:5:5
+   |
+LL |     bytes.iter().map(|b| format!("{b:02X}")).collect()
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: call `fold` instead
+  --> $DIR/format_collect.rs:5:18
+   |
+LL |     bytes.iter().map(|b| format!("{b:02X}")).collect()
+   |                  ^^^
+help: ... and use the `write!` macro here
+  --> $DIR/format_collect.rs:5:26
+   |
+LL |     bytes.iter().map(|b| format!("{b:02X}")).collect()
+   |                          ^^^^^^^^^^^^^^^^^^
+   = note: this can be written more efficiently by appending to a `String` directly
+   = note: `-D clippy::format-collect` implied by `-D warnings`
+
+error: use of `format!` to build up a string from an iterator
+  --> $DIR/format_collect.rs:19:5
+   |
+LL | /     (1..10)
+LL | |         .map(|s| {
+LL | |             let y = 1;
+LL | |             format!("{s} {y}")
+LL | |         })
+LL | |         .collect()
+   | |__________________^
+   |
+help: call `fold` instead
+  --> $DIR/format_collect.rs:20:10
+   |
+LL |         .map(|s| {
+   |          ^^^
+help: ... and use the `write!` macro here
+  --> $DIR/format_collect.rs:22:13
+   |
+LL |             format!("{s} {y}")
+   |             ^^^^^^^^^^^^^^^^^^
+   = note: this can be written more efficiently by appending to a `String` directly
+
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From c83d58f5076f3a79ea79514395a02babd15687b1 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Fri, 7 Jul 2023 18:20:36 +0200
Subject: document that `write!`ing into a string never fails

---
 clippy_lints/src/methods/format_collect.rs | 16 ++++++++--------
 clippy_lints/src/methods/mod.rs            |  7 ++++++-
 tests/ui/format_collect.rs                 |  5 +++++
 tests/ui/format_collect.stderr             | 26 ++++++++++++++++++++++----
 4 files changed, 41 insertions(+), 13 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/format_collect.rs b/clippy_lints/src/methods/format_collect.rs
index 74eb80782d6..1f8863f8521 100644
--- a/clippy_lints/src/methods/format_collect.rs
+++ b/clippy_lints/src/methods/format_collect.rs
@@ -1,17 +1,17 @@
 use super::FORMAT_COLLECT;
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::macros::is_format_macro;
-use clippy_utils::macros::root_macro_call_first_node;
+use clippy_utils::macros::{is_format_macro, root_macro_call_first_node};
 use clippy_utils::ty::is_type_lang_item;
-use rustc_hir::Expr;
-use rustc_hir::ExprKind;
-use rustc_hir::LangItem;
+use rustc_hir::{Expr, ExprKind, LangItem};
 use rustc_lint::LateContext;
 use rustc_span::Span;
 
-fn tail_expr<'tcx>(expr: &'tcx Expr<'tcx>) -> Option<&'tcx Expr<'tcx>> {
+/// Same as `peel_blocks` but only actually considers blocks that are not from an expansion.
+/// This is needed because always calling `peel_blocks` would otherwise remove parts of the
+/// `format!` macro, which would cause `root_macro_call_first_node` to return `None`.
+fn peel_non_expn_blocks<'tcx>(expr: &'tcx Expr<'tcx>) -> Option<&'tcx Expr<'tcx>> {
     match expr.kind {
-        ExprKind::Block(block, _) if !expr.span.from_expansion() => block.expr,
+        ExprKind::Block(block, _) if !expr.span.from_expansion() => peel_non_expn_blocks(block.expr?),
         _ => Some(expr),
     }
 }
@@ -20,7 +20,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, map_arg: &Expr<'_>, m
     if is_type_lang_item(cx, cx.typeck_results().expr_ty(expr), LangItem::String)
         && let ExprKind::Closure(closure) = map_arg.kind
         && let body = cx.tcx.hir().body(closure.body)
-        && let Some(value) = tail_expr(body.value)
+        && let Some(value) = peel_non_expn_blocks(body.value)
         && let Some(mac) = root_macro_call_first_node(cx, value)
         && is_format_macro(cx, mac.def_id)
     {
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index f55a7727fad..81f59f68ec6 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3385,7 +3385,12 @@ declare_clippy_lint! {
     ///
     /// ### Why is this bad?
     /// This allocates a new string for every element in the iterator.
-    /// This can be done more efficiently by creating the `String` once and appending to it using `Iterator::fold`.
+    /// This can be done more efficiently by creating the `String` once and appending to it in `Iterator::fold`,
+    /// using either the `write!` macro which supports exactly the same syntax as the `format!` macro,
+    /// or concatenating with `+` in case the iterator yields `&str`/`String`.
+    ///
+    /// Note also that `write!`-ing into a `String` can never fail, despite the return type of `write!` being `std::fmt::Result`,
+    /// so it can be safely ignored or unwrapped.
     ///
     /// ### Example
     /// ```rust
diff --git a/tests/ui/format_collect.rs b/tests/ui/format_collect.rs
index ecadb43ecb4..c7f2b7b6950 100644
--- a/tests/ui/format_collect.rs
+++ b/tests/ui/format_collect.rs
@@ -5,6 +5,11 @@ fn hex_encode(bytes: &[u8]) -> String {
     bytes.iter().map(|b| format!("{b:02X}")).collect()
 }
 
+#[rustfmt::skip]
+fn hex_encode_deep(bytes: &[u8]) -> String {
+    bytes.iter().map(|b| {{{{{ format!("{b:02X}") }}}}}).collect()
+}
+
 macro_rules! fmt {
     ($x:ident) => {
         format!("{x:02X}", x = $x)
diff --git a/tests/ui/format_collect.stderr b/tests/ui/format_collect.stderr
index cd71a853762..d918f1ed466 100644
--- a/tests/ui/format_collect.stderr
+++ b/tests/ui/format_collect.stderr
@@ -18,7 +18,25 @@ LL |     bytes.iter().map(|b| format!("{b:02X}")).collect()
    = note: `-D clippy::format-collect` implied by `-D warnings`
 
 error: use of `format!` to build up a string from an iterator
-  --> $DIR/format_collect.rs:19:5
+  --> $DIR/format_collect.rs:10:5
+   |
+LL |     bytes.iter().map(|b| {{{{{ format!("{b:02X}") }}}}}).collect()
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: call `fold` instead
+  --> $DIR/format_collect.rs:10:18
+   |
+LL |     bytes.iter().map(|b| {{{{{ format!("{b:02X}") }}}}}).collect()
+   |                  ^^^
+help: ... and use the `write!` macro here
+  --> $DIR/format_collect.rs:10:32
+   |
+LL |     bytes.iter().map(|b| {{{{{ format!("{b:02X}") }}}}}).collect()
+   |                                ^^^^^^^^^^^^^^^^^^
+   = note: this can be written more efficiently by appending to a `String` directly
+
+error: use of `format!` to build up a string from an iterator
+  --> $DIR/format_collect.rs:24:5
    |
 LL | /     (1..10)
 LL | |         .map(|s| {
@@ -29,16 +47,16 @@ LL | |         .collect()
    | |__________________^
    |
 help: call `fold` instead
-  --> $DIR/format_collect.rs:20:10
+  --> $DIR/format_collect.rs:25:10
    |
 LL |         .map(|s| {
    |          ^^^
 help: ... and use the `write!` macro here
-  --> $DIR/format_collect.rs:22:13
+  --> $DIR/format_collect.rs:27:13
    |
 LL |             format!("{s} {y}")
    |             ^^^^^^^^^^^^^^^^^^
    = note: this can be written more efficiently by appending to a `String` directly
 
-error: aborting due to 2 previous errors
+error: aborting due to 3 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 74a77047da404a0b69db4b58957127e415c4d20d Mon Sep 17 00:00:00 2001
From: Catherine <114838443+Centri3@users.noreply.github.com>
Date: Mon, 17 Jul 2023 05:33:41 -0500
Subject: Rewrite [`tuple_array_conversions`]

---
 clippy_lints/src/tuple_array_conversions.rs | 314 +++++++++++++---------------
 tests/ui/tuple_array_conversions.rs         |  30 +++
 tests/ui/tuple_array_conversions.stderr     |  36 ++--
 3 files changed, 195 insertions(+), 185 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/tuple_array_conversions.rs b/clippy_lints/src/tuple_array_conversions.rs
index 2e00ed042a8..791cbe2fead 100644
--- a/clippy_lints/src/tuple_array_conversions.rs
+++ b/clippy_lints/src/tuple_array_conversions.rs
@@ -1,21 +1,29 @@
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::msrvs::{self, Msrv};
+use clippy_utils::visitors::for_each_local_use_after_expr;
 use clippy_utils::{is_from_proc_macro, path_to_local};
+use itertools::Itertools;
 use rustc_ast::LitKind;
-use rustc_hir::{Expr, ExprKind, HirId, Node, Pat};
+use rustc_hir::{Expr, ExprKind, Node, PatKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_middle::ty;
+use rustc_middle::ty::{self, Ty};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use std::iter::once;
+use std::ops::ControlFlow;
 
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for tuple<=>array conversions that are not done with `.into()`.
     ///
     /// ### Why is this bad?
-    /// It may be unnecessary complexity. `.into()` works for converting tuples
-    /// <=> arrays of up to 12 elements and may convey intent more clearly.
+    /// It may be unnecessary complexity. `.into()` works for converting tuples<=> arrays of up to
+    /// 12 elements and conveys the intent more clearly, while also leaving less room for hard to
+    /// spot bugs!
+    ///
+    /// ### Known issues
+    /// The suggested code may hide potential asymmetry in some cases. See
+    /// [#11085](https://github.com/rust-lang/rust-clippy/issues/11085) for more info.
     ///
     /// ### Example
     /// ```rust,ignore
@@ -41,130 +49,152 @@ pub struct TupleArrayConversions {
 
 impl LateLintPass<'_> for TupleArrayConversions {
     fn check_expr<'tcx>(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
-        if !in_external_macro(cx.sess(), expr.span) && self.msrv.meets(msrvs::TUPLE_ARRAY_CONVERSIONS) {
-            match expr.kind {
-                ExprKind::Array(elements) if (1..=12).contains(&elements.len()) => check_array(cx, expr, elements),
-                ExprKind::Tup(elements) if (1..=12).contains(&elements.len()) => check_tuple(cx, expr, elements),
-                _ => {},
-            }
+        if in_external_macro(cx.sess(), expr.span) || !self.msrv.meets(msrvs::TUPLE_ARRAY_CONVERSIONS) {
+            return;
+        }
+
+        match expr.kind {
+            ExprKind::Array(elements) if (1..=12).contains(&elements.len()) => check_array(cx, expr, elements),
+            ExprKind::Tup(elements) if (1..=12).contains(&elements.len()) => check_tuple(cx, expr, elements),
+            _ => {},
         }
     }
 
     extract_msrv_attr!(LateContext);
 }
 
-#[expect(
-    clippy::blocks_in_if_conditions,
-    reason = "not a FP, but this is much easier to understand"
-)]
 fn check_array<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, elements: &'tcx [Expr<'tcx>]) {
-    if should_lint(
-        cx,
-        elements,
-        // This is cursed.
-        Some,
-        |(first_id, local)| {
-            if let Node::Pat(pat) = local
-                && let parent = parent_pat(cx, pat)
-                && parent.hir_id == first_id
-            {
-                return matches!(
-                    cx.typeck_results().pat_ty(parent).peel_refs().kind(),
-                    ty::Tuple(len) if len.len() == elements.len()
-                );
-            }
-
-            false
-        },
-    ) || should_lint(
-        cx,
-        elements,
-        |(i, expr)| {
-            if let ExprKind::Field(path, field) = expr.kind && field.as_str() == i.to_string() {
-                return Some((i, path));
-            };
-
-            None
-        },
-        |(first_id, local)| {
-            if let Node::Pat(pat) = local
-                && let parent = parent_pat(cx, pat)
-                && parent.hir_id == first_id
-            {
-                return matches!(
-                    cx.typeck_results().pat_ty(parent).peel_refs().kind(),
-                    ty::Tuple(len) if len.len() == elements.len()
-                );
-            }
+    let (ty::Array(ty, _) | ty::Slice(ty)) = cx.typeck_results().expr_ty(expr).kind() else {
+        unreachable!("`expr` must be an array or slice due to `ExprKind::Array`");
+    };
+
+    if let [first, ..] = elements
+        && let Some(locals) = (match first.kind {
+            ExprKind::Field(_, _) => elements
+                .iter()
+                .enumerate()
+                .map(|(i, f)| -> Option<&'tcx Expr<'tcx>> {
+                    let ExprKind::Field(lhs, ident) = f.kind else {
+                        return None;
+                    };
+                    (ident.name.as_str() == i.to_string()).then_some(lhs)
+                })
+                .collect::<Option<Vec<_>>>(),
+            ExprKind::Path(_) => Some(elements.iter().collect()),
+            _ => None,
+        })
+        && all_bindings_are_for_conv(cx, &[*ty], expr, elements, &locals, ToType::Array)
+        && !is_from_proc_macro(cx, expr)
+    {
+        span_lint_and_help(
+            cx,
+            TUPLE_ARRAY_CONVERSIONS,
+            expr.span,
+            "it looks like you're trying to convert a tuple to an array",
+            None,
+            "use `.into()` instead, or `<[T; N]>::from` if type annotations are needed",
+        );
+    }
+}
 
-            false
-        },
-    ) {
-        emit_lint(cx, expr, ToType::Array);
+fn check_tuple<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, elements: &'tcx [Expr<'tcx>]) {
+    if let ty::Tuple(tys) = cx.typeck_results().expr_ty(expr).kind()
+        && let [first, ..] = elements
+        // Fix #11100
+        && tys.iter().all_equal()
+        && let Some(locals) = (match first.kind {
+            ExprKind::Index(_, _) => elements
+                .iter()
+                .enumerate()
+                .map(|(i, i_expr)| -> Option<&'tcx Expr<'tcx>> {
+                    if let ExprKind::Index(lhs, index) = i_expr.kind
+                        && let ExprKind::Lit(lit) = index.kind
+                        && let LitKind::Int(val, _) = lit.node
+                    {
+                        return (val == i as u128).then_some(lhs);
+                    };
+
+                    None
+                })
+                .collect::<Option<Vec<_>>>(),
+            ExprKind::Path(_) => Some(elements.iter().collect()),
+            _ => None,
+        })
+        && all_bindings_are_for_conv(cx, tys, expr, elements, &locals, ToType::Tuple)
+        && !is_from_proc_macro(cx, expr)
+    {
+        span_lint_and_help(
+            cx,
+            TUPLE_ARRAY_CONVERSIONS,
+            expr.span,
+            "it looks like you're trying to convert an array to a tuple",
+            None,
+            "use `.into()` instead, or `<(T0, T1, ..., Tn)>::from` if type annotations are needed",
+        );
     }
 }
 
-#[expect(
-    clippy::blocks_in_if_conditions,
-    reason = "not a FP, but this is much easier to understand"
-)]
+/// Checks that every binding in `elements` comes from the same parent `Pat` with the kind if there
+/// is a parent `Pat`. Returns false in any of the following cases:
+/// * `kind` does not match `pat.kind`
+/// * one or more elements in `elements` is not a binding
+/// * one or more bindings does not have the same parent `Pat`
+/// * one or more bindings are used after `expr`
+/// * the bindings do not all have the same type
 #[expect(clippy::cast_possible_truncation)]
-fn check_tuple<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, elements: &'tcx [Expr<'tcx>]) {
-    if should_lint(cx, elements, Some, |(first_id, local)| {
-        if let Node::Pat(pat) = local
-                && let parent = parent_pat(cx, pat)
-                && parent.hir_id == first_id
-            {
-                return matches!(
-                    cx.typeck_results().pat_ty(parent).peel_refs().kind(),
-                    ty::Array(_, len) if len.eval_target_usize(cx.tcx, cx.param_env) as usize == elements.len()
-                );
+fn all_bindings_are_for_conv<'tcx>(
+    cx: &LateContext<'tcx>,
+    final_tys: &[Ty<'tcx>],
+    expr: &Expr<'_>,
+    elements: &[Expr<'_>],
+    locals: &[&Expr<'_>],
+    kind: ToType,
+) -> bool {
+    let Some(locals) = locals.iter().map(|e| path_to_local(e)).collect::<Option<Vec<_>>>() else {
+        return false;
+    };
+    let Some(local_parents) = locals
+        .iter()
+        .map(|&l| cx.tcx.hir().find_parent(l))
+        .collect::<Option<Vec<_>>>()
+    else {
+        return false;
+    };
+
+    local_parents
+        .iter()
+        .map(|node| match node {
+            Node::Pat(pat) => kind.eq(&pat.kind).then_some(pat.hir_id),
+            Node::Local(l) => Some(l.hir_id),
+            _ => None,
+        })
+        .all_equal()
+        // Fix #11124, very convenient utils function! ❤️
+        && locals
+            .iter()
+            .all(|&l| for_each_local_use_after_expr(cx, l, expr.hir_id, |_| ControlFlow::Break::<()>(())).is_continue())
+        && local_parents.first().is_some_and(|node| {
+            let Some(ty) = match node {
+                Node::Pat(pat) => Some(pat.hir_id),
+                Node::Local(l) => Some(l.hir_id),
+                _ => None,
             }
-
-        false
-    }) || should_lint(
-        cx,
-        elements,
-        |(i, expr)| {
-            if let ExprKind::Index(path, index) = expr.kind
-                && let ExprKind::Lit(lit) = index.kind
-                && let LitKind::Int(val, _) = lit.node
-                && val as usize == i
-            {
-                return Some((i, path));
+            .map(|hir_id| cx.typeck_results().node_type(hir_id)) else {
+                return false;
             };
-
-            None
-        },
-        |(first_id, local)| {
-            if let Node::Pat(pat) = local
-                && let parent = parent_pat(cx, pat)
-                && parent.hir_id == first_id
-            {
-                return matches!(
-                    cx.typeck_results().pat_ty(parent).peel_refs().kind(),
-                    ty::Array(_, len) if len.eval_target_usize(cx.tcx, cx.param_env) as usize == elements.len()
-                );
+            match (kind, ty.kind()) {
+                // Ensure the final type and the original type have the same length, and that there
+                // is no implicit `&mut`<=>`&` anywhere (#11100). Bit ugly, I know, but it works.
+                (ToType::Array, ty::Tuple(tys)) => {
+                    tys.len() == elements.len() && tys.iter().chain(final_tys.iter().copied()).all_equal()
+                },
+                (ToType::Tuple, ty::Array(ty, len)) => {
+                    len.eval_target_usize(cx.tcx, cx.param_env) as usize == elements.len()
+                        && final_tys.iter().chain(once(ty)).all_equal()
+                },
+                _ => false,
             }
-
-            false
-        },
-    ) {
-        emit_lint(cx, expr, ToType::Tuple);
-    }
-}
-
-/// Walks up the `Pat` until it's reached the final containing `Pat`.
-fn parent_pat<'tcx>(cx: &LateContext<'tcx>, start: &'tcx Pat<'tcx>) -> &'tcx Pat<'tcx> {
-    let mut end = start;
-    for (_, node) in cx.tcx.hir().parent_iter(start.hir_id) {
-        if let Node::Pat(pat) = node {
-            end = pat;
-        } else {
-            break;
-        }
-    }
-    end
+        })
 }
 
 #[derive(Clone, Copy)]
@@ -173,61 +203,11 @@ enum ToType {
     Tuple,
 }
 
-impl ToType {
-    fn msg(self) -> &'static str {
-        match self {
-            ToType::Array => "it looks like you're trying to convert a tuple to an array",
-            ToType::Tuple => "it looks like you're trying to convert an array to a tuple",
-        }
-    }
-
-    fn help(self) -> &'static str {
+impl PartialEq<PatKind<'_>> for ToType {
+    fn eq(&self, other: &PatKind<'_>) -> bool {
         match self {
-            ToType::Array => "use `.into()` instead, or `<[T; N]>::from` if type annotations are needed",
-            ToType::Tuple => "use `.into()` instead, or `<(T0, T1, ..., Tn)>::from` if type annotations are needed",
+            ToType::Array => matches!(other, PatKind::Tuple(_, _)),
+            ToType::Tuple => matches!(other, PatKind::Slice(_, _, _)),
         }
     }
 }
-
-fn emit_lint<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, to_type: ToType) -> bool {
-    if !is_from_proc_macro(cx, expr) {
-        span_lint_and_help(
-            cx,
-            TUPLE_ARRAY_CONVERSIONS,
-            expr.span,
-            to_type.msg(),
-            None,
-            to_type.help(),
-        );
-
-        return true;
-    }
-
-    false
-}
-
-fn should_lint<'tcx>(
-    cx: &LateContext<'tcx>,
-    elements: &'tcx [Expr<'tcx>],
-    map: impl FnMut((usize, &'tcx Expr<'tcx>)) -> Option<(usize, &Expr<'_>)>,
-    predicate: impl FnMut((HirId, &Node<'tcx>)) -> bool,
-) -> bool {
-    if let Some(elements) = elements
-            .iter()
-            .enumerate()
-            .map(map)
-            .collect::<Option<Vec<_>>>()
-        && let Some(locals) = elements
-            .iter()
-            .map(|(_, element)| path_to_local(element).and_then(|local| cx.tcx.hir().find(local)))
-            .collect::<Option<Vec<_>>>()
-        && let [first, rest @ ..] = &*locals
-        && let Node::Pat(first_pat) = first
-        && let parent = parent_pat(cx, first_pat).hir_id
-        && rest.iter().chain(once(first)).map(|i| (parent, i)).all(predicate)
-    {
-        return true;
-    }
-
-    false
-}
diff --git a/tests/ui/tuple_array_conversions.rs b/tests/ui/tuple_array_conversions.rs
index f96a7c97f1a..569415acbce 100644
--- a/tests/ui/tuple_array_conversions.rs
+++ b/tests/ui/tuple_array_conversions.rs
@@ -52,6 +52,36 @@ fn main() {
         let v1: Vec<[u32; 2]> = t1.iter().map(|&(a, b)| [a, b]).collect();
         let t2: Vec<(u32, u32)> = v1.iter().map(|&[a, b]| (a, b)).collect();
     }
+    // FP #11082; needs discussion
+    let (a, b) = (1.0f64, 2.0f64);
+    let _: &[f64] = &[a, b];
+    // FP #11085; impossible to fix
+    let [src, dest]: [_; 2] = [1, 2];
+    (src, dest);
+    // FP #11100
+    fn issue_11100_array_to_tuple(this: [&mut i32; 2]) -> (&i32, &mut i32) {
+        let [input, output] = this;
+        (input, output)
+    }
+
+    fn issue_11100_tuple_to_array<'a>(this: (&'a mut i32, &'a mut i32)) -> [&'a i32; 2] {
+        let (input, output) = this;
+        [input, output]
+    }
+    // FP #11124
+    // tuple=>array
+    let (a, b) = (1, 2);
+    [a, b];
+    let x = a;
+    // array=>tuple
+    let [a, b] = [1, 2];
+    (a, b);
+    let x = a;
+    // FP #11144
+    let (a, (b, c)) = (1, (2, 3));
+    [a, c];
+    let [[a, b], [c, d]] = [[1, 2], [3, 4]];
+    (a, c);
 }
 
 #[clippy::msrv = "1.70.0"]
diff --git a/tests/ui/tuple_array_conversions.stderr b/tests/ui/tuple_array_conversions.stderr
index be653e8efb7..50bdcf29d1f 100644
--- a/tests/ui/tuple_array_conversions.stderr
+++ b/tests/ui/tuple_array_conversions.stderr
@@ -15,14 +15,6 @@ LL |     let x = [x.0, x.1];
    |
    = help: use `.into()` instead, or `<[T; N]>::from` if type annotations are needed
 
-error: it looks like you're trying to convert an array to a tuple
-  --> $DIR/tuple_array_conversions.rs:13:13
-   |
-LL |     let x = (x[0], x[1]);
-   |             ^^^^^^^^^^^^
-   |
-   = help: use `.into()` instead, or `<(T0, T1, ..., Tn)>::from` if type annotations are needed
-
 error: it looks like you're trying to convert a tuple to an array
   --> $DIR/tuple_array_conversions.rs:16:53
    |
@@ -55,8 +47,24 @@ LL |     t1.iter().for_each(|&(a, b)| _ = [a, b]);
    |
    = help: use `.into()` instead, or `<[T; N]>::from` if type annotations are needed
 
+error: it looks like you're trying to convert a tuple to an array
+  --> $DIR/tuple_array_conversions.rs:57:22
+   |
+LL |     let _: &[f64] = &[a, b];
+   |                      ^^^^^^
+   |
+   = help: use `.into()` instead, or `<[T; N]>::from` if type annotations are needed
+
 error: it looks like you're trying to convert an array to a tuple
-  --> $DIR/tuple_array_conversions.rs:69:13
+  --> $DIR/tuple_array_conversions.rs:60:5
+   |
+LL |     (src, dest);
+   |     ^^^^^^^^^^^
+   |
+   = help: use `.into()` instead, or `<(T0, T1, ..., Tn)>::from` if type annotations are needed
+
+error: it looks like you're trying to convert an array to a tuple
+  --> $DIR/tuple_array_conversions.rs:99:13
    |
 LL |     let x = (x[0], x[1]);
    |             ^^^^^^^^^^^^
@@ -64,20 +72,12 @@ LL |     let x = (x[0], x[1]);
    = help: use `.into()` instead, or `<(T0, T1, ..., Tn)>::from` if type annotations are needed
 
 error: it looks like you're trying to convert a tuple to an array
-  --> $DIR/tuple_array_conversions.rs:70:13
+  --> $DIR/tuple_array_conversions.rs:100:13
    |
 LL |     let x = [x.0, x.1];
    |             ^^^^^^^^^^
    |
    = help: use `.into()` instead, or `<[T; N]>::from` if type annotations are needed
 
-error: it looks like you're trying to convert an array to a tuple
-  --> $DIR/tuple_array_conversions.rs:72:13
-   |
-LL |     let x = (x[0], x[1]);
-   |             ^^^^^^^^^^^^
-   |
-   = help: use `.into()` instead, or `<(T0, T1, ..., Tn)>::from` if type annotations are needed
-
 error: aborting due to 10 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 36f84a6176ec2e3df036b0e0938b5395af0bfed1 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Mon, 17 Jul 2023 12:09:20 +0000
Subject: Move tuple_array_conversions to nursery

---
 clippy_lints/src/tuple_array_conversions.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/tuple_array_conversions.rs b/clippy_lints/src/tuple_array_conversions.rs
index 2e00ed042a8..81270101538 100644
--- a/clippy_lints/src/tuple_array_conversions.rs
+++ b/clippy_lints/src/tuple_array_conversions.rs
@@ -29,7 +29,7 @@ declare_clippy_lint! {
     /// ```
     #[clippy::version = "1.72.0"]
     pub TUPLE_ARRAY_CONVERSIONS,
-    pedantic,
+    nursery,
     "checks for tuple<=>array conversions that are not done with `.into()`"
 }
 impl_lint_pass!(TupleArrayConversions => [TUPLE_ARRAY_CONVERSIONS]);
-- 
cgit 1.4.1-3-g733a5


From d24f0d056fba88d0b7738f4bb8f3866c052c2b24 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Mon, 17 Jul 2023 13:40:55 +0000
Subject: Don't lint `needless_return` in fns across a macro boundary

---
 clippy_lints/src/returns.rs |  4 ++++
 tests/ui/let_and_return.rs  | 10 ++++++++++
 2 files changed, 14 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
index 0212deda146..fe797219073 100644
--- a/clippy_lints/src/returns.rs
+++ b/clippy_lints/src/returns.rs
@@ -174,6 +174,10 @@ impl<'tcx> LateLintPass<'tcx> for Return {
         sp: Span,
         _: LocalDefId,
     ) {
+        if sp.from_expansion() {
+            return;
+        }
+
         match kind {
             FnKind::Closure => {
                 // when returning without value in closure, replace this `return`
diff --git a/tests/ui/let_and_return.rs b/tests/ui/let_and_return.rs
index 7e4d783a026..64665cc906f 100644
--- a/tests/ui/let_and_return.rs
+++ b/tests/ui/let_and_return.rs
@@ -169,4 +169,14 @@ mod issue_5729 {
     }
 }
 
+// https://github.com/rust-lang/rust-clippy/issues/11167
+macro_rules! fn_in_macro {
+    ($b:block) => {
+        fn f() -> usize $b
+    }
+}
+fn_in_macro!({
+    return 1;
+});
+
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From c26801ee927fc00723df60e548af881e9285ddae Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Mon, 17 Jul 2023 19:25:28 +0200
Subject: [`redundant_pattern_matching`]: don't lint if if guards are present

---
 .../src/matches/redundant_pattern_match.rs         |  7 ++-
 tests/ui/redundant_pattern_matching_option.fixed   |  4 ++
 tests/ui/redundant_pattern_matching_option.rs      |  4 ++
 tests/ui/redundant_pattern_matching_option.stderr  | 56 +++++++++++-----------
 4 files changed, 41 insertions(+), 30 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/redundant_pattern_match.rs b/clippy_lints/src/matches/redundant_pattern_match.rs
index 92e8f7dbd43..a7c799f2de5 100644
--- a/clippy_lints/src/matches/redundant_pattern_match.rs
+++ b/clippy_lints/src/matches/redundant_pattern_match.rs
@@ -199,8 +199,11 @@ fn find_sugg_for_if_let<'tcx>(
 }
 
 pub(super) fn check_match<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, op: &Expr<'_>, arms: &[Arm<'_>]) {
-    if arms.len() == 2 {
-        let node_pair = (&arms[0].pat.kind, &arms[1].pat.kind);
+    if let [arm1, arm2] = arms
+        && arm1.guard.is_none()
+        && arm2.guard.is_none()
+    {
+        let node_pair = (&arm1.pat.kind, &arm2.pat.kind);
 
         if let Some(good_method) = found_good_method(cx, arms, node_pair) {
             let span = is_expn_of(expr.span, "matches").unwrap_or(expr.span.to(op.span));
diff --git a/tests/ui/redundant_pattern_matching_option.fixed b/tests/ui/redundant_pattern_matching_option.fixed
index a63ba5809e4..d50c204875f 100644
--- a/tests/ui/redundant_pattern_matching_option.fixed
+++ b/tests/ui/redundant_pattern_matching_option.fixed
@@ -11,6 +11,10 @@
     clippy::if_same_then_else
 )]
 
+fn issue_11174<T>(boolean: bool, maybe_some: Option<T>) -> bool {
+    matches!(maybe_some, None if !boolean)
+}
+
 fn main() {
     if None::<()>.is_none() {}
 
diff --git a/tests/ui/redundant_pattern_matching_option.rs b/tests/ui/redundant_pattern_matching_option.rs
index 631f9091672..ce365a87aa7 100644
--- a/tests/ui/redundant_pattern_matching_option.rs
+++ b/tests/ui/redundant_pattern_matching_option.rs
@@ -11,6 +11,10 @@
     clippy::if_same_then_else
 )]
 
+fn issue_11174<T>(boolean: bool, maybe_some: Option<T>) -> bool {
+    matches!(maybe_some, None if !boolean)
+}
+
 fn main() {
     if let None = None::<()> {}
 
diff --git a/tests/ui/redundant_pattern_matching_option.stderr b/tests/ui/redundant_pattern_matching_option.stderr
index 097ca827a42..2d5e1a74e5e 100644
--- a/tests/ui/redundant_pattern_matching_option.stderr
+++ b/tests/ui/redundant_pattern_matching_option.stderr
@@ -1,5 +1,5 @@
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:15:12
+  --> $DIR/redundant_pattern_matching_option.rs:19:12
    |
 LL |     if let None = None::<()> {}
    |     -------^^^^------------- help: try: `if None::<()>.is_none()`
@@ -7,43 +7,43 @@ LL |     if let None = 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:17:12
+  --> $DIR/redundant_pattern_matching_option.rs:21:12
    |
 LL |     if let Some(_) = Some(42) {}
    |     -------^^^^^^^----------- help: try: `if Some(42).is_some()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/redundant_pattern_matching_option.rs:19:12
+  --> $DIR/redundant_pattern_matching_option.rs:23:12
    |
 LL |     if let Some(_) = Some(42) {
    |     -------^^^^^^^----------- help: try: `if Some(42).is_some()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/redundant_pattern_matching_option.rs:25:15
+  --> $DIR/redundant_pattern_matching_option.rs:29:15
    |
 LL |     while let Some(_) = Some(42) {}
    |     ----------^^^^^^^----------- help: try: `while Some(42).is_some()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:27:15
+  --> $DIR/redundant_pattern_matching_option.rs:31:15
    |
 LL |     while let None = Some(42) {}
    |     ----------^^^^----------- help: try: `while Some(42).is_none()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:29:15
+  --> $DIR/redundant_pattern_matching_option.rs:33:15
    |
 LL |     while let None = None::<()> {}
    |     ----------^^^^------------- help: try: `while None::<()>.is_none()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/redundant_pattern_matching_option.rs:32:15
+  --> $DIR/redundant_pattern_matching_option.rs:36:15
    |
 LL |     while let Some(_) = v.pop() {
    |     ----------^^^^^^^---------- help: try: `while v.pop().is_some()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/redundant_pattern_matching_option.rs:40:5
+  --> $DIR/redundant_pattern_matching_option.rs:44:5
    |
 LL | /     match Some(42) {
 LL | |         Some(_) => true,
@@ -52,7 +52,7 @@ LL | |     };
    | |_____^ help: try: `Some(42).is_some()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:45:5
+  --> $DIR/redundant_pattern_matching_option.rs:49:5
    |
 LL | /     match None::<()> {
 LL | |         Some(_) => false,
@@ -61,7 +61,7 @@ LL | |     };
    | |_____^ help: try: `None::<()>.is_none()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:50:13
+  --> $DIR/redundant_pattern_matching_option.rs:54:13
    |
 LL |       let _ = match None::<()> {
    |  _____________^
@@ -71,55 +71,55 @@ LL | |     };
    | |_____^ help: try: `None::<()>.is_none()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/redundant_pattern_matching_option.rs:56:20
+  --> $DIR/redundant_pattern_matching_option.rs:60:20
    |
 LL |     let _ = if let Some(_) = opt { true } else { false };
    |             -------^^^^^^^------ help: try: `if opt.is_some()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/redundant_pattern_matching_option.rs:62:20
+  --> $DIR/redundant_pattern_matching_option.rs:66:20
    |
 LL |     let _ = if let Some(_) = gen_opt() {
    |             -------^^^^^^^------------ help: try: `if gen_opt().is_some()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:64:19
+  --> $DIR/redundant_pattern_matching_option.rs:68:19
    |
 LL |     } else if let None = gen_opt() {
    |            -------^^^^------------ help: try: `if gen_opt().is_none()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/redundant_pattern_matching_option.rs:70:12
+  --> $DIR/redundant_pattern_matching_option.rs:74:12
    |
 LL |     if let Some(..) = gen_opt() {}
    |     -------^^^^^^^^------------ help: try: `if gen_opt().is_some()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/redundant_pattern_matching_option.rs:85:12
+  --> $DIR/redundant_pattern_matching_option.rs:89:12
    |
 LL |     if let Some(_) = Some(42) {}
    |     -------^^^^^^^----------- help: try: `if Some(42).is_some()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:87:12
+  --> $DIR/redundant_pattern_matching_option.rs:91:12
    |
 LL |     if let None = None::<()> {}
    |     -------^^^^------------- help: try: `if None::<()>.is_none()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/redundant_pattern_matching_option.rs:89:15
+  --> $DIR/redundant_pattern_matching_option.rs:93:15
    |
 LL |     while let Some(_) = Some(42) {}
    |     ----------^^^^^^^----------- help: try: `while Some(42).is_some()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:91:15
+  --> $DIR/redundant_pattern_matching_option.rs:95:15
    |
 LL |     while let None = None::<()> {}
    |     ----------^^^^------------- help: try: `while None::<()>.is_none()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/redundant_pattern_matching_option.rs:93:5
+  --> $DIR/redundant_pattern_matching_option.rs:97:5
    |
 LL | /     match Some(42) {
 LL | |         Some(_) => true,
@@ -128,7 +128,7 @@ LL | |     };
    | |_____^ help: try: `Some(42).is_some()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:98:5
+  --> $DIR/redundant_pattern_matching_option.rs:102:5
    |
 LL | /     match None::<()> {
 LL | |         Some(_) => false,
@@ -137,19 +137,19 @@ LL | |     };
    | |_____^ help: try: `None::<()>.is_none()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:106:12
+  --> $DIR/redundant_pattern_matching_option.rs:110:12
    |
 LL |     if let None = *(&None::<()>) {}
    |     -------^^^^----------------- help: try: `if (&None::<()>).is_none()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:107:12
+  --> $DIR/redundant_pattern_matching_option.rs:111:12
    |
 LL |     if let None = *&None::<()> {}
    |     -------^^^^--------------- help: try: `if (&None::<()>).is_none()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/redundant_pattern_matching_option.rs:113:5
+  --> $DIR/redundant_pattern_matching_option.rs:117:5
    |
 LL | /     match x {
 LL | |         Some(_) => true,
@@ -158,7 +158,7 @@ LL | |     };
    | |_____^ help: try: `x.is_some()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:118:5
+  --> $DIR/redundant_pattern_matching_option.rs:122:5
    |
 LL | /     match x {
 LL | |         None => true,
@@ -167,7 +167,7 @@ LL | |     };
    | |_____^ help: try: `x.is_none()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:123:5
+  --> $DIR/redundant_pattern_matching_option.rs:127:5
    |
 LL | /     match x {
 LL | |         Some(_) => false,
@@ -176,7 +176,7 @@ LL | |     };
    | |_____^ help: try: `x.is_none()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/redundant_pattern_matching_option.rs:128:5
+  --> $DIR/redundant_pattern_matching_option.rs:132:5
    |
 LL | /     match x {
 LL | |         None => false,
@@ -185,13 +185,13 @@ LL | |     };
    | |_____^ help: try: `x.is_some()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/redundant_pattern_matching_option.rs:143:13
+  --> $DIR/redundant_pattern_matching_option.rs:147:13
    |
 LL |     let _ = matches!(x, Some(_));
    |             ^^^^^^^^^^^^^^^^^^^^ help: try: `x.is_some()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:145:13
+  --> $DIR/redundant_pattern_matching_option.rs:149:13
    |
 LL |     let _ = matches!(x, None);
    |             ^^^^^^^^^^^^^^^^^ help: try: `x.is_none()`
-- 
cgit 1.4.1-3-g733a5


From e7fd44f213df3d8a8d7efcacc8e694a58046b824 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Mon, 17 Jul 2023 21:18:11 +0200
Subject: add guard to suggestion instead of not linting

---
 .../src/matches/redundant_pattern_match.rs         | 77 +++++++++++++++-------
 tests/ui/redundant_pattern_matching_option.fixed   | 12 +++-
 tests/ui/redundant_pattern_matching_option.rs      | 10 +++
 tests/ui/redundant_pattern_matching_option.stderr  | 74 ++++++++++++---------
 4 files changed, 118 insertions(+), 55 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/redundant_pattern_match.rs b/clippy_lints/src/matches/redundant_pattern_match.rs
index a7c799f2de5..3994533322d 100644
--- a/clippy_lints/src/matches/redundant_pattern_match.rs
+++ b/clippy_lints/src/matches/redundant_pattern_match.rs
@@ -3,18 +3,20 @@ use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::{snippet, walk_span_to_context};
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::{is_type_diagnostic_item, needs_ordered_drop};
-use clippy_utils::visitors::any_temporaries_need_ordered_drop;
+use clippy_utils::visitors::{any_temporaries_need_ordered_drop, for_each_expr};
 use clippy_utils::{higher, is_expn_of, is_trait_method};
 use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::LangItem::{self, OptionNone, OptionSome, PollPending, PollReady, ResultErr, ResultOk};
-use rustc_hir::{Arm, Expr, ExprKind, Node, Pat, PatKind, QPath, UnOp};
+use rustc_hir::{Arm, Expr, ExprKind, Guard, Node, Pat, PatKind, QPath, UnOp};
 use rustc_lint::LateContext;
 use rustc_middle::ty::subst::GenericArgKind;
 use rustc_middle::ty::{self, Ty};
 use rustc_span::{sym, Symbol};
+use std::fmt::Write;
+use std::ops::ControlFlow;
 
 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
     if let Some(higher::WhileLet { let_pat, let_expr, .. }) = higher::WhileLet::hir(expr) {
@@ -199,36 +201,61 @@ fn find_sugg_for_if_let<'tcx>(
 }
 
 pub(super) fn check_match<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, op: &Expr<'_>, arms: &[Arm<'_>]) {
-    if let [arm1, arm2] = arms
-        && arm1.guard.is_none()
-        && arm2.guard.is_none()
-    {
-        let node_pair = (&arm1.pat.kind, &arm2.pat.kind);
+    if arms.len() == 2 {
+        let node_pair = (&arms[0].pat.kind, &arms[1].pat.kind);
 
-        if let Some(good_method) = found_good_method(cx, arms, node_pair) {
+        if let Some((good_method, maybe_guard)) = found_good_method(cx, arms, node_pair) {
             let span = is_expn_of(expr.span, "matches").unwrap_or(expr.span.to(op.span));
             let result_expr = match &op.kind {
                 ExprKind::AddrOf(_, _, borrowed) => borrowed,
                 _ => op,
             };
+            let mut sugg = format!("{}.{good_method}", snippet(cx, result_expr.span, "_"));
+
+            if let Some(guard) = maybe_guard {
+                let Guard::If(guard) = *guard else { return }; // `...is_none() && let ...` is a syntax error
+
+                // wow, the HIR for match guards in `PAT if let PAT = expr && expr => ...` is annoying!
+                // `guard` here is `Guard::If` with the let expression somewhere deep in the tree of exprs,
+                // counter to the intuition that it should be `Guard::IfLet`, so we need another check
+                // to see that there aren't any let chains anywhere in the guard, as that would break
+                // if we suggest `t.is_none() && (let X = y && z)` for:
+                // `match t { None if let X = y && z => true, _ => false }`
+                let has_nested_let_chain = for_each_expr(guard, |expr| {
+                    if matches!(expr.kind, ExprKind::Let(..)) {
+                        ControlFlow::Break(())
+                    } else {
+                        ControlFlow::Continue(())
+                    }
+                })
+                .is_some();
+
+                if has_nested_let_chain {
+                    return;
+                }
+
+                let guard = Sugg::hir(cx, guard, "..");
+                let _ = write!(sugg, " && {}", guard.maybe_par());
+            }
+
             span_lint_and_sugg(
                 cx,
                 REDUNDANT_PATTERN_MATCHING,
                 span,
                 &format!("redundant pattern matching, consider using `{good_method}`"),
                 "try",
-                format!("{}.{good_method}", snippet(cx, result_expr.span, "_")),
+                sugg,
                 Applicability::MachineApplicable,
             );
         }
     }
 }
 
-fn found_good_method<'a>(
+fn found_good_method<'tcx>(
     cx: &LateContext<'_>,
-    arms: &[Arm<'_>],
+    arms: &'tcx [Arm<'tcx>],
     node: (&PatKind<'_>, &PatKind<'_>),
-) -> Option<&'a str> {
+) -> Option<(&'static str, Option<&'tcx Guard<'tcx>>)> {
     match node {
         (
             PatKind::TupleStruct(ref path_left, patterns_left, _),
@@ -314,7 +341,11 @@ fn get_ident(path: &QPath<'_>) -> Option<rustc_span::symbol::Ident> {
     }
 }
 
-fn get_good_method<'a>(cx: &LateContext<'_>, arms: &[Arm<'_>], path_left: &QPath<'_>) -> Option<&'a str> {
+fn get_good_method<'tcx>(
+    cx: &LateContext<'_>,
+    arms: &'tcx [Arm<'tcx>],
+    path_left: &QPath<'_>,
+) -> Option<(&'static str, Option<&'tcx Guard<'tcx>>)> {
     if let Some(name) = get_ident(path_left) {
         return match name.as_str() {
             "Ok" => {
@@ -380,16 +411,16 @@ fn is_pat_variant(cx: &LateContext<'_>, pat: &Pat<'_>, path: &QPath<'_>, expecte
 }
 
 #[expect(clippy::too_many_arguments)]
-fn find_good_method_for_match<'a>(
+fn find_good_method_for_match<'a, 'tcx>(
     cx: &LateContext<'_>,
-    arms: &[Arm<'_>],
+    arms: &'tcx [Arm<'tcx>],
     path_left: &QPath<'_>,
     path_right: &QPath<'_>,
     expected_item_left: Item,
     expected_item_right: Item,
     should_be_left: &'a str,
     should_be_right: &'a str,
-) -> Option<&'a str> {
+) -> Option<(&'a str, Option<&'tcx Guard<'tcx>>)> {
     let first_pat = arms[0].pat;
     let second_pat = arms[1].pat;
 
@@ -407,22 +438,22 @@ fn find_good_method_for_match<'a>(
 
     match body_node_pair {
         (ExprKind::Lit(lit_left), ExprKind::Lit(lit_right)) => match (&lit_left.node, &lit_right.node) {
-            (LitKind::Bool(true), LitKind::Bool(false)) => Some(should_be_left),
-            (LitKind::Bool(false), LitKind::Bool(true)) => Some(should_be_right),
+            (LitKind::Bool(true), LitKind::Bool(false)) => Some((should_be_left, arms[0].guard.as_ref())),
+            (LitKind::Bool(false), LitKind::Bool(true)) => Some((should_be_right, arms[1].guard.as_ref())),
             _ => None,
         },
         _ => None,
     }
 }
 
-fn find_good_method_for_matches_macro<'a>(
+fn find_good_method_for_matches_macro<'a, 'tcx>(
     cx: &LateContext<'_>,
-    arms: &[Arm<'_>],
+    arms: &'tcx [Arm<'tcx>],
     path_left: &QPath<'_>,
     expected_item_left: Item,
     should_be_left: &'a str,
     should_be_right: &'a str,
-) -> Option<&'a str> {
+) -> Option<(&'a str, Option<&'tcx Guard<'tcx>>)> {
     let first_pat = arms[0].pat;
 
     let body_node_pair = if is_pat_variant(cx, first_pat, path_left, expected_item_left) {
@@ -433,8 +464,8 @@ fn find_good_method_for_matches_macro<'a>(
 
     match body_node_pair {
         (ExprKind::Lit(lit_left), ExprKind::Lit(lit_right)) => match (&lit_left.node, &lit_right.node) {
-            (LitKind::Bool(true), LitKind::Bool(false)) => Some(should_be_left),
-            (LitKind::Bool(false), LitKind::Bool(true)) => Some(should_be_right),
+            (LitKind::Bool(true), LitKind::Bool(false)) => Some((should_be_left, arms[0].guard.as_ref())),
+            (LitKind::Bool(false), LitKind::Bool(true)) => Some((should_be_right, arms[1].guard.as_ref())),
             _ => None,
         },
         _ => None,
diff --git a/tests/ui/redundant_pattern_matching_option.fixed b/tests/ui/redundant_pattern_matching_option.fixed
index d50c204875f..d9fcd98c56e 100644
--- a/tests/ui/redundant_pattern_matching_option.fixed
+++ b/tests/ui/redundant_pattern_matching_option.fixed
@@ -10,9 +10,19 @@
     clippy::equatable_if_let,
     clippy::if_same_then_else
 )]
+#![feature(let_chains, if_let_guard)]
 
 fn issue_11174<T>(boolean: bool, maybe_some: Option<T>) -> bool {
-    matches!(maybe_some, None if !boolean)
+    maybe_some.is_none() && (!boolean)
+}
+
+fn issue_11174_edge_cases<T>(boolean: bool, boolean2: bool, maybe_some: Option<T>) {
+    let _ = maybe_some.is_none() && (boolean || boolean2); // guard needs parentheses
+    let _ = match maybe_some { // can't use `matches!` here
+                               // because `expr` metavars in macros don't allow let exprs
+        None if let Some(x) = Some(0) && x > 5 => true,
+        _ => false
+    };
 }
 
 fn main() {
diff --git a/tests/ui/redundant_pattern_matching_option.rs b/tests/ui/redundant_pattern_matching_option.rs
index ce365a87aa7..cbd9494f15a 100644
--- a/tests/ui/redundant_pattern_matching_option.rs
+++ b/tests/ui/redundant_pattern_matching_option.rs
@@ -10,11 +10,21 @@
     clippy::equatable_if_let,
     clippy::if_same_then_else
 )]
+#![feature(let_chains, if_let_guard)]
 
 fn issue_11174<T>(boolean: bool, maybe_some: Option<T>) -> bool {
     matches!(maybe_some, None if !boolean)
 }
 
+fn issue_11174_edge_cases<T>(boolean: bool, boolean2: bool, maybe_some: Option<T>) {
+    let _ = matches!(maybe_some, None if boolean || boolean2); // guard needs parentheses
+    let _ = match maybe_some { // can't use `matches!` here
+                               // because `expr` metavars in macros don't allow let exprs
+        None if let Some(x) = Some(0) && x > 5 => true,
+        _ => false
+    };
+}
+
 fn main() {
     if let None = None::<()> {}
 
diff --git a/tests/ui/redundant_pattern_matching_option.stderr b/tests/ui/redundant_pattern_matching_option.stderr
index 2d5e1a74e5e..b0e43924dbc 100644
--- a/tests/ui/redundant_pattern_matching_option.stderr
+++ b/tests/ui/redundant_pattern_matching_option.stderr
@@ -1,49 +1,61 @@
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:19:12
+  --> $DIR/redundant_pattern_matching_option.rs:16:5
    |
-LL |     if let None = None::<()> {}
-   |     -------^^^^------------- help: try: `if None::<()>.is_none()`
+LL |     matches!(maybe_some, None if !boolean)
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `maybe_some.is_none() && (!boolean)`
    |
    = note: `-D clippy::redundant-pattern-matching` implied by `-D warnings`
 
+error: redundant pattern matching, consider using `is_none()`
+  --> $DIR/redundant_pattern_matching_option.rs:20:13
+   |
+LL |     let _ = matches!(maybe_some, None if boolean || boolean2); // guard needs parentheses
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `maybe_some.is_none() && (boolean || boolean2)`
+
+error: redundant pattern matching, consider using `is_none()`
+  --> $DIR/redundant_pattern_matching_option.rs:29:12
+   |
+LL |     if let None = None::<()> {}
+   |     -------^^^^------------- help: try: `if None::<()>.is_none()`
+
 error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/redundant_pattern_matching_option.rs:21:12
+  --> $DIR/redundant_pattern_matching_option.rs:31:12
    |
 LL |     if let Some(_) = Some(42) {}
    |     -------^^^^^^^----------- help: try: `if Some(42).is_some()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/redundant_pattern_matching_option.rs:23:12
+  --> $DIR/redundant_pattern_matching_option.rs:33:12
    |
 LL |     if let Some(_) = Some(42) {
    |     -------^^^^^^^----------- help: try: `if Some(42).is_some()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/redundant_pattern_matching_option.rs:29:15
+  --> $DIR/redundant_pattern_matching_option.rs:39:15
    |
 LL |     while let Some(_) = Some(42) {}
    |     ----------^^^^^^^----------- help: try: `while Some(42).is_some()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:31:15
+  --> $DIR/redundant_pattern_matching_option.rs:41:15
    |
 LL |     while let None = Some(42) {}
    |     ----------^^^^----------- help: try: `while Some(42).is_none()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:33:15
+  --> $DIR/redundant_pattern_matching_option.rs:43:15
    |
 LL |     while let None = None::<()> {}
    |     ----------^^^^------------- help: try: `while None::<()>.is_none()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/redundant_pattern_matching_option.rs:36:15
+  --> $DIR/redundant_pattern_matching_option.rs:46:15
    |
 LL |     while let Some(_) = v.pop() {
    |     ----------^^^^^^^---------- help: try: `while v.pop().is_some()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/redundant_pattern_matching_option.rs:44:5
+  --> $DIR/redundant_pattern_matching_option.rs:54:5
    |
 LL | /     match Some(42) {
 LL | |         Some(_) => true,
@@ -52,7 +64,7 @@ LL | |     };
    | |_____^ help: try: `Some(42).is_some()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:49:5
+  --> $DIR/redundant_pattern_matching_option.rs:59:5
    |
 LL | /     match None::<()> {
 LL | |         Some(_) => false,
@@ -61,7 +73,7 @@ LL | |     };
    | |_____^ help: try: `None::<()>.is_none()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:54:13
+  --> $DIR/redundant_pattern_matching_option.rs:64:13
    |
 LL |       let _ = match None::<()> {
    |  _____________^
@@ -71,55 +83,55 @@ LL | |     };
    | |_____^ help: try: `None::<()>.is_none()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/redundant_pattern_matching_option.rs:60:20
+  --> $DIR/redundant_pattern_matching_option.rs:70:20
    |
 LL |     let _ = if let Some(_) = opt { true } else { false };
    |             -------^^^^^^^------ help: try: `if opt.is_some()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/redundant_pattern_matching_option.rs:66:20
+  --> $DIR/redundant_pattern_matching_option.rs:76:20
    |
 LL |     let _ = if let Some(_) = gen_opt() {
    |             -------^^^^^^^------------ help: try: `if gen_opt().is_some()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:68:19
+  --> $DIR/redundant_pattern_matching_option.rs:78:19
    |
 LL |     } else if let None = gen_opt() {
    |            -------^^^^------------ help: try: `if gen_opt().is_none()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/redundant_pattern_matching_option.rs:74:12
+  --> $DIR/redundant_pattern_matching_option.rs:84:12
    |
 LL |     if let Some(..) = gen_opt() {}
    |     -------^^^^^^^^------------ help: try: `if gen_opt().is_some()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/redundant_pattern_matching_option.rs:89:12
+  --> $DIR/redundant_pattern_matching_option.rs:99:12
    |
 LL |     if let Some(_) = Some(42) {}
    |     -------^^^^^^^----------- help: try: `if Some(42).is_some()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:91:12
+  --> $DIR/redundant_pattern_matching_option.rs:101:12
    |
 LL |     if let None = None::<()> {}
    |     -------^^^^------------- help: try: `if None::<()>.is_none()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/redundant_pattern_matching_option.rs:93:15
+  --> $DIR/redundant_pattern_matching_option.rs:103:15
    |
 LL |     while let Some(_) = Some(42) {}
    |     ----------^^^^^^^----------- help: try: `while Some(42).is_some()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:95:15
+  --> $DIR/redundant_pattern_matching_option.rs:105:15
    |
 LL |     while let None = None::<()> {}
    |     ----------^^^^------------- help: try: `while None::<()>.is_none()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/redundant_pattern_matching_option.rs:97:5
+  --> $DIR/redundant_pattern_matching_option.rs:107:5
    |
 LL | /     match Some(42) {
 LL | |         Some(_) => true,
@@ -128,7 +140,7 @@ LL | |     };
    | |_____^ help: try: `Some(42).is_some()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:102:5
+  --> $DIR/redundant_pattern_matching_option.rs:112:5
    |
 LL | /     match None::<()> {
 LL | |         Some(_) => false,
@@ -137,19 +149,19 @@ LL | |     };
    | |_____^ help: try: `None::<()>.is_none()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:110:12
+  --> $DIR/redundant_pattern_matching_option.rs:120:12
    |
 LL |     if let None = *(&None::<()>) {}
    |     -------^^^^----------------- help: try: `if (&None::<()>).is_none()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:111:12
+  --> $DIR/redundant_pattern_matching_option.rs:121:12
    |
 LL |     if let None = *&None::<()> {}
    |     -------^^^^--------------- help: try: `if (&None::<()>).is_none()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/redundant_pattern_matching_option.rs:117:5
+  --> $DIR/redundant_pattern_matching_option.rs:127:5
    |
 LL | /     match x {
 LL | |         Some(_) => true,
@@ -158,7 +170,7 @@ LL | |     };
    | |_____^ help: try: `x.is_some()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:122:5
+  --> $DIR/redundant_pattern_matching_option.rs:132:5
    |
 LL | /     match x {
 LL | |         None => true,
@@ -167,7 +179,7 @@ LL | |     };
    | |_____^ help: try: `x.is_none()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:127:5
+  --> $DIR/redundant_pattern_matching_option.rs:137:5
    |
 LL | /     match x {
 LL | |         Some(_) => false,
@@ -176,7 +188,7 @@ LL | |     };
    | |_____^ help: try: `x.is_none()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/redundant_pattern_matching_option.rs:132:5
+  --> $DIR/redundant_pattern_matching_option.rs:142:5
    |
 LL | /     match x {
 LL | |         None => false,
@@ -185,16 +197,16 @@ LL | |     };
    | |_____^ help: try: `x.is_some()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/redundant_pattern_matching_option.rs:147:13
+  --> $DIR/redundant_pattern_matching_option.rs:157:13
    |
 LL |     let _ = matches!(x, Some(_));
    |             ^^^^^^^^^^^^^^^^^^^^ help: try: `x.is_some()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:149:13
+  --> $DIR/redundant_pattern_matching_option.rs:159:13
    |
 LL |     let _ = matches!(x, None);
    |             ^^^^^^^^^^^^^^^^^ help: try: `x.is_none()`
 
-error: aborting due to 28 previous errors
+error: aborting due to 30 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From c13cb54e25140afe2845eee3130b2b369d130d48 Mon Sep 17 00:00:00 2001
From: Catherine <114838443+Centri3@users.noreply.github.com>
Date: Mon, 26 Jun 2023 00:44:17 -0500
Subject: New lint `needless_return_with_try`

---
 CHANGELOG.md                             |  1 +
 clippy_lints/src/declared_lints.rs       |  1 +
 clippy_lints/src/returns.rs              | 74 ++++++++++++++++++++++++++++++--
 tests/ui/needless_return_with_try.fixed  | 40 +++++++++++++++++
 tests/ui/needless_return_with_try.rs     | 40 +++++++++++++++++
 tests/ui/needless_return_with_try.stderr | 10 +++++
 tests/ui/try_err.fixed                   |  6 ++-
 tests/ui/try_err.rs                      |  6 ++-
 tests/ui/try_err.stderr                  | 22 +++++-----
 9 files changed, 184 insertions(+), 16 deletions(-)
 create mode 100644 tests/ui/needless_return_with_try.fixed
 create mode 100644 tests/ui/needless_return_with_try.rs
 create mode 100644 tests/ui/needless_return_with_try.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index ea8450ed5c2..47b64d27ad7 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5093,6 +5093,7 @@ Released 2018-09-13
 [`needless_raw_string_hashes`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_raw_string_hashes
 [`needless_raw_strings`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_raw_strings
 [`needless_return`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_return
+[`needless_return_with_try`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_return_with_try
 [`needless_splitn`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_splitn
 [`needless_update`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_update
 [`neg_cmp_op_on_partial_ord`]: https://rust-lang.github.io/rust-clippy/master/index.html#neg_cmp_op_on_partial_ord
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 7472158a81c..7676e787ee7 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -569,6 +569,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::return_self_not_must_use::RETURN_SELF_NOT_MUST_USE_INFO,
     crate::returns::LET_AND_RETURN_INFO,
     crate::returns::NEEDLESS_RETURN_INFO,
+    crate::returns::NEEDLESS_RETURN_WITH_TRY_INFO,
     crate::same_name_method::SAME_NAME_METHOD_INFO,
     crate::self_named_constructors::SELF_NAMED_CONSTRUCTORS_INFO,
     crate::semicolon_block::SEMICOLON_INSIDE_BLOCK_INFO,
diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
index fe797219073..58868e97e23 100644
--- a/clippy_lints/src/returns.rs
+++ b/clippy_lints/src/returns.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::{span_lint_and_then, span_lint_hir_and_then};
+use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then, span_lint_hir_and_then};
 use clippy_utils::source::{snippet_opt, snippet_with_context};
 use clippy_utils::visitors::{for_each_expr_with_closures, Descend};
 use clippy_utils::{fn_def_id, path_to_local_id, span_find_starting_semi};
@@ -6,7 +6,9 @@ use core::ops::ControlFlow;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::FnKind;
-use rustc_hir::{Block, Body, Expr, ExprKind, FnDecl, LangItem, MatchSource, PatKind, QPath, StmtKind};
+use rustc_hir::{
+    Block, Body, Expr, ExprKind, FnDecl, ItemKind, LangItem, MatchSource, OwnerNode, PatKind, QPath, Stmt, StmtKind,
+};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::subst::GenericArgKind;
@@ -77,6 +79,46 @@ declare_clippy_lint! {
     "using a return statement like `return expr;` where an expression would suffice"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for return statements on `Err` paired with the `?` operator.
+    ///
+    /// ### Why is this bad?
+    /// The `return` is unnecessary.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// fn foo(x: usize) -> Result<(), Box<dyn Error>> {
+    ///     if x == 0 {
+    ///         return Err(...)?;
+    ///     }
+    ///     Ok(())
+    /// }
+    /// ```
+    /// simplify to
+    /// ```rust,ignore
+    /// fn foo(x: usize) -> Result<(), Box<dyn Error>> {
+    ///     if x == 0 {
+    ///         Err(...)?;
+    ///     }
+    ///     Ok(())
+    /// }
+    /// ```
+    /// if paired with `try_err`, use instead:
+    /// ```rust,ignore
+    /// fn foo(x: usize) -> Result<(), Box<dyn Error>> {
+    ///     if x == 0 {
+    ///         return Err(...);
+    ///     }
+    ///     Ok(())
+    /// }
+    /// ```
+    #[clippy::version = "1.72.0"]
+    pub NEEDLESS_RETURN_WITH_TRY,
+    style,
+    "using a return statement like `return Err(expr)?;` where removing it would suffice"
+}
+
 #[derive(PartialEq, Eq)]
 enum RetReplacement<'tcx> {
     Empty,
@@ -116,9 +158,35 @@ impl<'tcx> ToString for RetReplacement<'tcx> {
     }
 }
 
-declare_lint_pass!(Return => [LET_AND_RETURN, NEEDLESS_RETURN]);
+declare_lint_pass!(Return => [LET_AND_RETURN, NEEDLESS_RETURN, NEEDLESS_RETURN_WITH_TRY]);
 
 impl<'tcx> LateLintPass<'tcx> for Return {
+    fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) {
+        if !in_external_macro(cx.sess(), stmt.span)
+            && let StmtKind::Semi(expr) = stmt.kind
+            && let ExprKind::Ret(Some(ret)) = expr.kind
+            && let ExprKind::Match(.., MatchSource::TryDesugar) = ret.kind
+            // Ensure this is not the final stmt, otherwise removing it would cause a compile error
+            && let OwnerNode::Item(item) = cx.tcx.hir().owner(cx.tcx.hir().get_parent_item(expr.hir_id))
+            && let ItemKind::Fn(_, _, body) = item.kind
+            && let block = cx.tcx.hir().body(body).value
+            && let ExprKind::Block(block, _) = block.kind
+            && let [.., final_stmt] = block.stmts
+            && final_stmt.hir_id != stmt.hir_id
+            && !is_from_proc_macro(cx, expr)
+        {
+            span_lint_and_sugg(
+                cx,
+                NEEDLESS_RETURN_WITH_TRY,
+                expr.span.until(ret.span),
+                "unneeded `return` statement with `?` operator",
+                "remove it",
+                String::new(),
+                Applicability::MachineApplicable,
+            );
+        }
+    }
+
     fn check_block(&mut self, cx: &LateContext<'tcx>, block: &'tcx Block<'_>) {
         // we need both a let-binding stmt and an expr
         if_chain! {
diff --git a/tests/ui/needless_return_with_try.fixed b/tests/ui/needless_return_with_try.fixed
new file mode 100644
index 00000000000..96d3e6df2d1
--- /dev/null
+++ b/tests/ui/needless_return_with_try.fixed
@@ -0,0 +1,40 @@
+//@run-rustfix
+//@aux-build:proc_macros.rs
+#![allow(
+    clippy::needless_return,
+    clippy::no_effect,
+    clippy::unit_arg,
+    clippy::useless_conversion,
+    unused
+)]
+
+#[macro_use]
+extern crate proc_macros;
+
+fn a() -> u32 {
+    return 0;
+}
+
+fn b() -> Result<u32, u32> {
+    return Err(0);
+}
+
+// Do not lint
+fn c() -> Option<()> {
+    return None?;
+}
+
+fn main() -> Result<(), ()> {
+    Err(())?;
+    return Ok::<(), ()>(());
+    Err(())?;
+    Ok::<(), ()>(());
+    return Err(().into());
+    external! {
+        return Err(())?;
+    }
+    with_span! {
+        return Err(())?;
+    }
+    Err(())
+}
diff --git a/tests/ui/needless_return_with_try.rs b/tests/ui/needless_return_with_try.rs
new file mode 100644
index 00000000000..039afba0602
--- /dev/null
+++ b/tests/ui/needless_return_with_try.rs
@@ -0,0 +1,40 @@
+//@run-rustfix
+//@aux-build:proc_macros.rs
+#![allow(
+    clippy::needless_return,
+    clippy::no_effect,
+    clippy::unit_arg,
+    clippy::useless_conversion,
+    unused
+)]
+
+#[macro_use]
+extern crate proc_macros;
+
+fn a() -> u32 {
+    return 0;
+}
+
+fn b() -> Result<u32, u32> {
+    return Err(0);
+}
+
+// Do not lint
+fn c() -> Option<()> {
+    return None?;
+}
+
+fn main() -> Result<(), ()> {
+    return Err(())?;
+    return Ok::<(), ()>(());
+    Err(())?;
+    Ok::<(), ()>(());
+    return Err(().into());
+    external! {
+        return Err(())?;
+    }
+    with_span! {
+        return Err(())?;
+    }
+    Err(())
+}
diff --git a/tests/ui/needless_return_with_try.stderr b/tests/ui/needless_return_with_try.stderr
new file mode 100644
index 00000000000..72f2bba9200
--- /dev/null
+++ b/tests/ui/needless_return_with_try.stderr
@@ -0,0 +1,10 @@
+error: unneeded `return` statement with `?` operator
+  --> $DIR/needless_return_with_try.rs:28:5
+   |
+LL |     return Err(())?;
+   |     ^^^^^^^ help: remove it
+   |
+   = note: `-D clippy::needless-return-with-try` implied by `-D warnings`
+
+error: aborting due to previous error
+
diff --git a/tests/ui/try_err.fixed b/tests/ui/try_err.fixed
index 1816740870a..e7e2379fa4c 100644
--- a/tests/ui/try_err.fixed
+++ b/tests/ui/try_err.fixed
@@ -2,7 +2,11 @@
 //@aux-build:proc_macros.rs:proc-macro
 
 #![deny(clippy::try_err)]
-#![allow(clippy::unnecessary_wraps, clippy::needless_question_mark)]
+#![allow(
+    clippy::unnecessary_wraps,
+    clippy::needless_question_mark,
+    clippy::needless_return_with_try
+)]
 
 extern crate proc_macros;
 use proc_macros::{external, inline_macros};
diff --git a/tests/ui/try_err.rs b/tests/ui/try_err.rs
index 0e47c4d023e..ece21887ed3 100644
--- a/tests/ui/try_err.rs
+++ b/tests/ui/try_err.rs
@@ -2,7 +2,11 @@
 //@aux-build:proc_macros.rs:proc-macro
 
 #![deny(clippy::try_err)]
-#![allow(clippy::unnecessary_wraps, clippy::needless_question_mark)]
+#![allow(
+    clippy::unnecessary_wraps,
+    clippy::needless_question_mark,
+    clippy::needless_return_with_try
+)]
 
 extern crate proc_macros;
 use proc_macros::{external, inline_macros};
diff --git a/tests/ui/try_err.stderr b/tests/ui/try_err.stderr
index 79f7b70224a..9968b383ebb 100644
--- a/tests/ui/try_err.stderr
+++ b/tests/ui/try_err.stderr
@@ -1,5 +1,5 @@
 error: returning an `Err(_)` with the `?` operator
-  --> $DIR/try_err.rs:19:9
+  --> $DIR/try_err.rs:23:9
    |
 LL |         Err(err)?;
    |         ^^^^^^^^^ help: try: `return Err(err)`
@@ -11,25 +11,25 @@ LL | #![deny(clippy::try_err)]
    |         ^^^^^^^^^^^^^^^
 
 error: returning an `Err(_)` with the `?` operator
-  --> $DIR/try_err.rs:29:9
+  --> $DIR/try_err.rs:33:9
    |
 LL |         Err(err)?;
    |         ^^^^^^^^^ help: try: `return Err(err.into())`
 
 error: returning an `Err(_)` with the `?` operator
-  --> $DIR/try_err.rs:49:17
+  --> $DIR/try_err.rs:53:17
    |
 LL |                 Err(err)?;
    |                 ^^^^^^^^^ help: try: `return Err(err)`
 
 error: returning an `Err(_)` with the `?` operator
-  --> $DIR/try_err.rs:68:17
+  --> $DIR/try_err.rs:72:17
    |
 LL |                 Err(err)?;
    |                 ^^^^^^^^^ help: try: `return Err(err.into())`
 
 error: returning an `Err(_)` with the `?` operator
-  --> $DIR/try_err.rs:88:23
+  --> $DIR/try_err.rs:92:23
    |
 LL |             Err(_) => Err(1)?,
    |                       ^^^^^^^ help: try: `return Err(1)`
@@ -37,7 +37,7 @@ LL |             Err(_) => Err(1)?,
    = note: this error originates in the macro `__inline_mac_fn_calling_macro` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: returning an `Err(_)` with the `?` operator
-  --> $DIR/try_err.rs:95:23
+  --> $DIR/try_err.rs:99:23
    |
 LL |             Err(_) => Err(inline!(1))?,
    |                       ^^^^^^^^^^^^^^^^ help: try: `return Err(inline!(1))`
@@ -45,31 +45,31 @@ LL |             Err(_) => Err(inline!(1))?,
    = note: this error originates in the macro `__inline_mac_fn_calling_macro` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: returning an `Err(_)` with the `?` operator
-  --> $DIR/try_err.rs:122:9
+  --> $DIR/try_err.rs:126:9
    |
 LL |         Err(inline!(inline!(String::from("aasdfasdfasdfa"))))?;
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `return Err(inline!(inline!(String::from("aasdfasdfasdfa"))))`
 
 error: returning an `Err(_)` with the `?` operator
-  --> $DIR/try_err.rs:129:9
+  --> $DIR/try_err.rs:133:9
    |
 LL |         Err(io::ErrorKind::WriteZero)?
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `return Poll::Ready(Err(io::ErrorKind::WriteZero.into()))`
 
 error: returning an `Err(_)` with the `?` operator
-  --> $DIR/try_err.rs:131:9
+  --> $DIR/try_err.rs:135:9
    |
 LL |         Err(io::Error::new(io::ErrorKind::InvalidInput, "error"))?
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `return Poll::Ready(Err(io::Error::new(io::ErrorKind::InvalidInput, "error")))`
 
 error: returning an `Err(_)` with the `?` operator
-  --> $DIR/try_err.rs:139:9
+  --> $DIR/try_err.rs:143:9
    |
 LL |         Err(io::ErrorKind::NotFound)?
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `return Poll::Ready(Some(Err(io::ErrorKind::NotFound.into())))`
 
 error: returning an `Err(_)` with the `?` operator
-  --> $DIR/try_err.rs:148:16
+  --> $DIR/try_err.rs:152:16
    |
 LL |         return Err(42)?;
    |                ^^^^^^^^ help: try: `Err(42)`
-- 
cgit 1.4.1-3-g733a5


From 0d59d1d617531c1fe73cc94a4eaac7db5f23aa72 Mon Sep 17 00:00:00 2001
From: Catherine <114838443+Centri3@users.noreply.github.com>
Date: Wed, 12 Jul 2023 21:48:22 -0500
Subject: Rename to `needless_return_with_question_mark`

---
 CHANGELOG.md                                       |  2 +-
 clippy_lints/src/declared_lints.rs                 |  2 +-
 clippy_lints/src/returns.rs                        | 10 +++---
 tests/ui/needless_return_with_question_mark.fixed  | 40 ++++++++++++++++++++++
 tests/ui/needless_return_with_question_mark.rs     | 40 ++++++++++++++++++++++
 tests/ui/needless_return_with_question_mark.stderr | 10 ++++++
 tests/ui/needless_return_with_try.fixed            | 40 ----------------------
 tests/ui/needless_return_with_try.rs               | 40 ----------------------
 tests/ui/needless_return_with_try.stderr           | 10 ------
 tests/ui/try_err.fixed                             |  2 +-
 tests/ui/try_err.rs                                |  2 +-
 11 files changed, 99 insertions(+), 99 deletions(-)
 create mode 100644 tests/ui/needless_return_with_question_mark.fixed
 create mode 100644 tests/ui/needless_return_with_question_mark.rs
 create mode 100644 tests/ui/needless_return_with_question_mark.stderr
 delete mode 100644 tests/ui/needless_return_with_try.fixed
 delete mode 100644 tests/ui/needless_return_with_try.rs
 delete mode 100644 tests/ui/needless_return_with_try.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 47b64d27ad7..a0a4a541cef 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5093,7 +5093,7 @@ Released 2018-09-13
 [`needless_raw_string_hashes`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_raw_string_hashes
 [`needless_raw_strings`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_raw_strings
 [`needless_return`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_return
-[`needless_return_with_try`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_return_with_try
+[`needless_return_with_question_mark`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_return_with_question_mark
 [`needless_splitn`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_splitn
 [`needless_update`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_update
 [`neg_cmp_op_on_partial_ord`]: https://rust-lang.github.io/rust-clippy/master/index.html#neg_cmp_op_on_partial_ord
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 7676e787ee7..a75efd9bbb6 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -569,7 +569,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::return_self_not_must_use::RETURN_SELF_NOT_MUST_USE_INFO,
     crate::returns::LET_AND_RETURN_INFO,
     crate::returns::NEEDLESS_RETURN_INFO,
-    crate::returns::NEEDLESS_RETURN_WITH_TRY_INFO,
+    crate::returns::NEEDLESS_RETURN_WITH_QUESTION_MARK_INFO,
     crate::same_name_method::SAME_NAME_METHOD_INFO,
     crate::self_named_constructors::SELF_NAMED_CONSTRUCTORS_INFO,
     crate::semicolon_block::SEMICOLON_INSIDE_BLOCK_INFO,
diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
index 58868e97e23..e944da6bc81 100644
--- a/clippy_lints/src/returns.rs
+++ b/clippy_lints/src/returns.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then, span_lint_hir_and_then};
 use clippy_utils::source::{snippet_opt, snippet_with_context};
 use clippy_utils::visitors::{for_each_expr_with_closures, Descend};
-use clippy_utils::{fn_def_id, path_to_local_id, span_find_starting_semi};
+use clippy_utils::{fn_def_id, is_from_proc_macro, path_to_local_id, span_find_starting_semi};
 use core::ops::ControlFlow;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
@@ -113,8 +113,8 @@ declare_clippy_lint! {
     ///     Ok(())
     /// }
     /// ```
-    #[clippy::version = "1.72.0"]
-    pub NEEDLESS_RETURN_WITH_TRY,
+    #[clippy::version = "1.73.0"]
+    pub NEEDLESS_RETURN_WITH_QUESTION_MARK,
     style,
     "using a return statement like `return Err(expr)?;` where removing it would suffice"
 }
@@ -158,7 +158,7 @@ impl<'tcx> ToString for RetReplacement<'tcx> {
     }
 }
 
-declare_lint_pass!(Return => [LET_AND_RETURN, NEEDLESS_RETURN, NEEDLESS_RETURN_WITH_TRY]);
+declare_lint_pass!(Return => [LET_AND_RETURN, NEEDLESS_RETURN, NEEDLESS_RETURN_WITH_QUESTION_MARK]);
 
 impl<'tcx> LateLintPass<'tcx> for Return {
     fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) {
@@ -177,7 +177,7 @@ impl<'tcx> LateLintPass<'tcx> for Return {
         {
             span_lint_and_sugg(
                 cx,
-                NEEDLESS_RETURN_WITH_TRY,
+                NEEDLESS_RETURN_WITH_QUESTION_MARK,
                 expr.span.until(ret.span),
                 "unneeded `return` statement with `?` operator",
                 "remove it",
diff --git a/tests/ui/needless_return_with_question_mark.fixed b/tests/ui/needless_return_with_question_mark.fixed
new file mode 100644
index 00000000000..d6e47d07b0f
--- /dev/null
+++ b/tests/ui/needless_return_with_question_mark.fixed
@@ -0,0 +1,40 @@
+//@run-rustfix
+//@aux-build:proc_macros.rs:proc-macro
+#![allow(
+    clippy::needless_return,
+    clippy::no_effect,
+    clippy::unit_arg,
+    clippy::useless_conversion,
+    unused
+)]
+
+#[macro_use]
+extern crate proc_macros;
+
+fn a() -> u32 {
+    return 0;
+}
+
+fn b() -> Result<u32, u32> {
+    return Err(0);
+}
+
+// Do not lint
+fn c() -> Option<()> {
+    return None?;
+}
+
+fn main() -> Result<(), ()> {
+    Err(())?;
+    return Ok::<(), ()>(());
+    Err(())?;
+    Ok::<(), ()>(());
+    return Err(().into());
+    external! {
+        return Err(())?;
+    }
+    with_span! {
+        return Err(())?;
+    }
+    Err(())
+}
diff --git a/tests/ui/needless_return_with_question_mark.rs b/tests/ui/needless_return_with_question_mark.rs
new file mode 100644
index 00000000000..4fc04d363a9
--- /dev/null
+++ b/tests/ui/needless_return_with_question_mark.rs
@@ -0,0 +1,40 @@
+//@run-rustfix
+//@aux-build:proc_macros.rs:proc-macro
+#![allow(
+    clippy::needless_return,
+    clippy::no_effect,
+    clippy::unit_arg,
+    clippy::useless_conversion,
+    unused
+)]
+
+#[macro_use]
+extern crate proc_macros;
+
+fn a() -> u32 {
+    return 0;
+}
+
+fn b() -> Result<u32, u32> {
+    return Err(0);
+}
+
+// Do not lint
+fn c() -> Option<()> {
+    return None?;
+}
+
+fn main() -> Result<(), ()> {
+    return Err(())?;
+    return Ok::<(), ()>(());
+    Err(())?;
+    Ok::<(), ()>(());
+    return Err(().into());
+    external! {
+        return Err(())?;
+    }
+    with_span! {
+        return Err(())?;
+    }
+    Err(())
+}
diff --git a/tests/ui/needless_return_with_question_mark.stderr b/tests/ui/needless_return_with_question_mark.stderr
new file mode 100644
index 00000000000..e1d91638d2c
--- /dev/null
+++ b/tests/ui/needless_return_with_question_mark.stderr
@@ -0,0 +1,10 @@
+error: unneeded `return` statement with `?` operator
+  --> $DIR/needless_return_with_question_mark.rs:28:5
+   |
+LL |     return Err(())?;
+   |     ^^^^^^^ help: remove it
+   |
+   = note: `-D clippy::needless-return-with-question-mark` implied by `-D warnings`
+
+error: aborting due to previous error
+
diff --git a/tests/ui/needless_return_with_try.fixed b/tests/ui/needless_return_with_try.fixed
deleted file mode 100644
index 96d3e6df2d1..00000000000
--- a/tests/ui/needless_return_with_try.fixed
+++ /dev/null
@@ -1,40 +0,0 @@
-//@run-rustfix
-//@aux-build:proc_macros.rs
-#![allow(
-    clippy::needless_return,
-    clippy::no_effect,
-    clippy::unit_arg,
-    clippy::useless_conversion,
-    unused
-)]
-
-#[macro_use]
-extern crate proc_macros;
-
-fn a() -> u32 {
-    return 0;
-}
-
-fn b() -> Result<u32, u32> {
-    return Err(0);
-}
-
-// Do not lint
-fn c() -> Option<()> {
-    return None?;
-}
-
-fn main() -> Result<(), ()> {
-    Err(())?;
-    return Ok::<(), ()>(());
-    Err(())?;
-    Ok::<(), ()>(());
-    return Err(().into());
-    external! {
-        return Err(())?;
-    }
-    with_span! {
-        return Err(())?;
-    }
-    Err(())
-}
diff --git a/tests/ui/needless_return_with_try.rs b/tests/ui/needless_return_with_try.rs
deleted file mode 100644
index 039afba0602..00000000000
--- a/tests/ui/needless_return_with_try.rs
+++ /dev/null
@@ -1,40 +0,0 @@
-//@run-rustfix
-//@aux-build:proc_macros.rs
-#![allow(
-    clippy::needless_return,
-    clippy::no_effect,
-    clippy::unit_arg,
-    clippy::useless_conversion,
-    unused
-)]
-
-#[macro_use]
-extern crate proc_macros;
-
-fn a() -> u32 {
-    return 0;
-}
-
-fn b() -> Result<u32, u32> {
-    return Err(0);
-}
-
-// Do not lint
-fn c() -> Option<()> {
-    return None?;
-}
-
-fn main() -> Result<(), ()> {
-    return Err(())?;
-    return Ok::<(), ()>(());
-    Err(())?;
-    Ok::<(), ()>(());
-    return Err(().into());
-    external! {
-        return Err(())?;
-    }
-    with_span! {
-        return Err(())?;
-    }
-    Err(())
-}
diff --git a/tests/ui/needless_return_with_try.stderr b/tests/ui/needless_return_with_try.stderr
deleted file mode 100644
index 72f2bba9200..00000000000
--- a/tests/ui/needless_return_with_try.stderr
+++ /dev/null
@@ -1,10 +0,0 @@
-error: unneeded `return` statement with `?` operator
-  --> $DIR/needless_return_with_try.rs:28:5
-   |
-LL |     return Err(())?;
-   |     ^^^^^^^ help: remove it
-   |
-   = note: `-D clippy::needless-return-with-try` implied by `-D warnings`
-
-error: aborting due to previous error
-
diff --git a/tests/ui/try_err.fixed b/tests/ui/try_err.fixed
index e7e2379fa4c..930489fab76 100644
--- a/tests/ui/try_err.fixed
+++ b/tests/ui/try_err.fixed
@@ -5,7 +5,7 @@
 #![allow(
     clippy::unnecessary_wraps,
     clippy::needless_question_mark,
-    clippy::needless_return_with_try
+    clippy::needless_return_with_question_mark
 )]
 
 extern crate proc_macros;
diff --git a/tests/ui/try_err.rs b/tests/ui/try_err.rs
index ece21887ed3..f5baf3d8f74 100644
--- a/tests/ui/try_err.rs
+++ b/tests/ui/try_err.rs
@@ -5,7 +5,7 @@
 #![allow(
     clippy::unnecessary_wraps,
     clippy::needless_question_mark,
-    clippy::needless_return_with_try
+    clippy::needless_return_with_question_mark
 )]
 
 extern crate proc_macros;
-- 
cgit 1.4.1-3-g733a5


From 75e1329aac850a15f29a86ac685b3cb4794b8b4f Mon Sep 17 00:00:00 2001
From: Catherine <114838443+Centri3@users.noreply.github.com>
Date: Tue, 4 Jul 2023 13:36:56 -0500
Subject: New lint [`error_impl_error`]

---
 CHANGELOG.md                         |  1 +
 clippy_lints/src/declared_lints.rs   |  1 +
 clippy_lints/src/error_impl_error.rs | 76 ++++++++++++++++++++++++++++++++++++
 clippy_lints/src/lib.rs              |  2 +
 tests/ui/error_impl_error.rs         | 71 +++++++++++++++++++++++++++++++++
 tests/ui/error_impl_error.stderr     | 45 +++++++++++++++++++++
 6 files changed, 196 insertions(+)
 create mode 100644 clippy_lints/src/error_impl_error.rs
 create mode 100644 tests/ui/error_impl_error.rs
 create mode 100644 tests/ui/error_impl_error.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index db18bc296f7..0445e59480c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4819,6 +4819,7 @@ Released 2018-09-13
 [`equatable_if_let`]: https://rust-lang.github.io/rust-clippy/master/index.html#equatable_if_let
 [`erasing_op`]: https://rust-lang.github.io/rust-clippy/master/index.html#erasing_op
 [`err_expect`]: https://rust-lang.github.io/rust-clippy/master/index.html#err_expect
+[`error_impl_error`]: https://rust-lang.github.io/rust-clippy/master/index.html#error_impl_error
 [`eval_order_dependence`]: https://rust-lang.github.io/rust-clippy/master/index.html#eval_order_dependence
 [`excessive_nesting`]: https://rust-lang.github.io/rust-clippy/master/index.html#excessive_nesting
 [`excessive_precision`]: https://rust-lang.github.io/rust-clippy/master/index.html#excessive_precision
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 51035a9d66b..cd507d8a9e9 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -155,6 +155,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::enum_variants::MODULE_INCEPTION_INFO,
     crate::enum_variants::MODULE_NAME_REPETITIONS_INFO,
     crate::equatable_if_let::EQUATABLE_IF_LET_INFO,
+    crate::error_impl_error::ERROR_IMPL_ERROR_INFO,
     crate::escape::BOXED_LOCAL_INFO,
     crate::eta_reduction::REDUNDANT_CLOSURE_INFO,
     crate::eta_reduction::REDUNDANT_CLOSURE_FOR_METHOD_CALLS_INFO,
diff --git a/clippy_lints/src/error_impl_error.rs b/clippy_lints/src/error_impl_error.rs
new file mode 100644
index 00000000000..7f361d9ba02
--- /dev/null
+++ b/clippy_lints/src/error_impl_error.rs
@@ -0,0 +1,76 @@
+use clippy_utils::{
+    diagnostics::{span_lint, span_lint_hir_and_then},
+    path_res,
+    ty::implements_trait,
+};
+use rustc_hir::{def_id::DefId, Item, ItemKind, Node};
+use rustc_hir_analysis::hir_ty_to_ty;
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::sym;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for types named `Error` that implement `Error`.
+    ///
+    /// ### Why is this bad?
+    /// It can become confusing when a codebase has 20 types all named `Error`, requiring either
+    /// aliasing them in the `use` statement them or qualifying them like `my_module::Error`. This
+    /// severely hinders readability.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// #[derive(Debug)]
+    /// pub enum Error { ... }
+    ///
+    /// impl std::fmt::Display for Error { ... }
+    ///
+    /// impl std::error::Error for Error { ... }
+    /// ```
+    #[clippy::version = "1.72.0"]
+    pub ERROR_IMPL_ERROR,
+    restriction,
+    "types named `Error` that implement `Error`"
+}
+declare_lint_pass!(ErrorImplError => [ERROR_IMPL_ERROR]);
+
+impl<'tcx> LateLintPass<'tcx> for ErrorImplError {
+    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
+        let Some(error_def_id) = cx.tcx.get_diagnostic_item(sym::Error) else {
+            return;
+        };
+
+        match item.kind {
+            ItemKind::TyAlias(ty, _) if implements_trait(cx, hir_ty_to_ty(cx.tcx, ty), error_def_id, &[])
+                && item.ident.name == sym::Error =>
+            {
+                span_lint(
+                    cx,
+                    ERROR_IMPL_ERROR,
+                    item.ident.span,
+                    "type alias named `Error` that implements `Error`",
+                );
+            },
+            ItemKind::Impl(imp) if let Some(trait_def_id) = imp.of_trait.and_then(|t| t.trait_def_id())
+                && error_def_id == trait_def_id
+                && let Some(def_id) = path_res(cx, imp.self_ty).opt_def_id().and_then(DefId::as_local)
+                && let hir_id = cx.tcx.hir().local_def_id_to_hir_id(def_id)
+                && let Node::Item(ty_item) = cx.tcx.hir().get(hir_id)
+                && ty_item.ident.name == sym::Error =>
+            {
+                span_lint_hir_and_then(
+                    cx,
+                    ERROR_IMPL_ERROR,
+                    hir_id,
+                    ty_item.ident.span,
+                    "type named `Error` that implements `Error`",
+                    |diag| {
+                        diag.span_note(item.span, "`Error` was implemented here");
+                    }
+                );
+            }
+            _ => {},
+        }
+        {}
+    }
+}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 4ea25e4be9d..1609eb396b4 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -120,6 +120,7 @@ mod entry;
 mod enum_clike;
 mod enum_variants;
 mod equatable_if_let;
+mod error_impl_error;
 mod escape;
 mod eta_reduction;
 mod excessive_bools;
@@ -1080,6 +1081,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(move |_| Box::new(tuple_array_conversions::TupleArrayConversions { msrv: msrv() }));
     store.register_late_pass(|_| Box::new(manual_float_methods::ManualFloatMethods));
     store.register_late_pass(|_| Box::new(four_forward_slashes::FourForwardSlashes));
+    store.register_late_pass(|_| Box::new(error_impl_error::ErrorImplError));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/tests/ui/error_impl_error.rs b/tests/ui/error_impl_error.rs
new file mode 100644
index 00000000000..d85f9522081
--- /dev/null
+++ b/tests/ui/error_impl_error.rs
@@ -0,0 +1,71 @@
+#![allow(unused)]
+#![warn(clippy::error_impl_error)]
+#![no_main]
+
+mod a {
+    #[derive(Debug)]
+    struct Error;
+
+    impl std::fmt::Display for Error {
+        fn fmt(&self, _: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            todo!()
+        }
+    }
+
+    impl std::error::Error for Error {}
+}
+
+mod b {
+    #[derive(Debug)]
+    enum Error {}
+
+    impl std::fmt::Display for Error {
+        fn fmt(&self, _: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            todo!()
+        }
+    }
+
+    impl std::error::Error for Error {}
+}
+
+mod c {
+    union Error {
+        a: u32,
+        b: u32,
+    }
+
+    impl std::fmt::Debug for Error {
+        fn fmt(&self, _: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            todo!()
+        }
+    }
+
+    impl std::fmt::Display for Error {
+        fn fmt(&self, _: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            todo!()
+        }
+    }
+
+    impl std::error::Error for Error {}
+}
+
+mod d {
+    type Error = std::fmt::Error;
+}
+
+mod e {
+    #[derive(Debug)]
+    struct MyError;
+
+    impl std::fmt::Display for MyError {
+        fn fmt(&self, _: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            todo!()
+        }
+    }
+
+    impl std::error::Error for MyError {}
+}
+
+mod f {
+    type MyError = std::fmt::Error;
+}
diff --git a/tests/ui/error_impl_error.stderr b/tests/ui/error_impl_error.stderr
new file mode 100644
index 00000000000..64af0594e0a
--- /dev/null
+++ b/tests/ui/error_impl_error.stderr
@@ -0,0 +1,45 @@
+error: type named `Error` that implements `Error`
+  --> $DIR/error_impl_error.rs:7:12
+   |
+LL |     struct Error;
+   |            ^^^^^
+   |
+note: `Error` was implemented here
+  --> $DIR/error_impl_error.rs:15:5
+   |
+LL |     impl std::error::Error for Error {}
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   = note: `-D clippy::error-impl-error` implied by `-D warnings`
+
+error: type named `Error` that implements `Error`
+  --> $DIR/error_impl_error.rs:20:10
+   |
+LL |     enum Error {}
+   |          ^^^^^
+   |
+note: `Error` was implemented here
+  --> $DIR/error_impl_error.rs:28:5
+   |
+LL |     impl std::error::Error for Error {}
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: type named `Error` that implements `Error`
+  --> $DIR/error_impl_error.rs:32:11
+   |
+LL |     union Error {
+   |           ^^^^^
+   |
+note: `Error` was implemented here
+  --> $DIR/error_impl_error.rs:49:5
+   |
+LL |     impl std::error::Error for Error {}
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: type alias named `Error` that implements `Error`
+  --> $DIR/error_impl_error.rs:53:10
+   |
+LL |     type Error = std::fmt::Error;
+   |          ^^^^^
+
+error: aborting due to 4 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From f4b3bb19c18cbce910875d6fc97de70005b8dcdb Mon Sep 17 00:00:00 2001
From: Catherine <114838443+Centri3@users.noreply.github.com>
Date: Thu, 6 Jul 2023 21:58:11 -0500
Subject: Add `allow_private_error` config option

---
 CHANGELOG.md                                       |  1 +
 book/src/lint_configuration.md                     | 10 +++
 clippy_lints/src/error_impl_error.rs               | 31 +++++----
 clippy_lints/src/utils/conf.rs                     |  4 ++
 .../error_impl_error/allow_private/clippy.toml     |  1 +
 .../error_impl_error/disallow_private/clippy.toml  |  1 +
 .../error_impl_error.allow_private.stderr          | 33 ++++++++++
 .../error_impl_error.disallow_private.stderr       | 45 +++++++++++++
 tests/ui-toml/error_impl_error/error_impl_error.rs | 74 ++++++++++++++++++++++
 .../toml_unknown_key/conf_unknown_key.stderr       |  2 +
 tests/ui/error_impl_error.rs                       | 71 ---------------------
 tests/ui/error_impl_error.stderr                   | 45 -------------
 12 files changed, 190 insertions(+), 128 deletions(-)
 create mode 100644 tests/ui-toml/error_impl_error/allow_private/clippy.toml
 create mode 100644 tests/ui-toml/error_impl_error/disallow_private/clippy.toml
 create mode 100644 tests/ui-toml/error_impl_error/error_impl_error.allow_private.stderr
 create mode 100644 tests/ui-toml/error_impl_error/error_impl_error.disallow_private.stderr
 create mode 100644 tests/ui-toml/error_impl_error/error_impl_error.rs
 delete mode 100644 tests/ui/error_impl_error.rs
 delete mode 100644 tests/ui/error_impl_error.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 0445e59480c..0676752b766 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5465,4 +5465,5 @@ Released 2018-09-13
 [`accept-comment-above-statement`]: https://doc.rust-lang.org/clippy/lint_configuration.html#accept-comment-above-statement
 [`accept-comment-above-attributes`]: https://doc.rust-lang.org/clippy/lint_configuration.html#accept-comment-above-attributes
 [`allow-one-hash-in-raw-strings`]: https://doc.rust-lang.org/clippy/lint_configuration.html#allow-one-hash-in-raw-strings
+[`allow-private-error`]: https://doc.rust-lang.org/clippy/lint_configuration.html#allow-private-error
 <!-- end autogenerated links to configuration documentation -->
diff --git a/book/src/lint_configuration.md b/book/src/lint_configuration.md
index f8073dac330..1035f3e7fb6 100644
--- a/book/src/lint_configuration.md
+++ b/book/src/lint_configuration.md
@@ -730,3 +730,13 @@ Whether to allow `r#""#` when `r""` can be used
 * [`unnecessary_raw_string_hashes`](https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_raw_string_hashes)
 
 
+## `allow-private-error`
+Whether to allow private types named `Error` that implement `Error`
+
+**Default Value:** `true` (`bool`)
+
+---
+**Affected lints:**
+* [`error_impl_error`](https://rust-lang.github.io/rust-clippy/master/index.html#error_impl_error)
+
+
diff --git a/clippy_lints/src/error_impl_error.rs b/clippy_lints/src/error_impl_error.rs
index 7f361d9ba02..585a0ad04c7 100644
--- a/clippy_lints/src/error_impl_error.rs
+++ b/clippy_lints/src/error_impl_error.rs
@@ -1,12 +1,11 @@
-use clippy_utils::{
-    diagnostics::{span_lint, span_lint_hir_and_then},
-    path_res,
-    ty::implements_trait,
-};
-use rustc_hir::{def_id::DefId, Item, ItemKind, Node};
+use clippy_utils::diagnostics::{span_lint, span_lint_hir_and_then};
+use clippy_utils::path_res;
+use clippy_utils::ty::implements_trait;
+use rustc_hir::def_id::DefId;
+use rustc_hir::{Item, ItemKind, Node};
 use rustc_hir_analysis::hir_ty_to_ty;
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::sym;
 
 declare_clippy_lint! {
@@ -15,8 +14,9 @@ declare_clippy_lint! {
     ///
     /// ### Why is this bad?
     /// It can become confusing when a codebase has 20 types all named `Error`, requiring either
-    /// aliasing them in the `use` statement them or qualifying them like `my_module::Error`. This
-    /// severely hinders readability.
+    /// aliasing them in the `use` statement or qualifying them like `my_module::Error`. This
+    /// hinders comprehension, as it requires you to memorize every variation of importing `Error`
+    /// used across a codebase.
     ///
     /// ### Example
     /// ```rust,ignore
@@ -32,14 +32,22 @@ declare_clippy_lint! {
     restriction,
     "types named `Error` that implement `Error`"
 }
-declare_lint_pass!(ErrorImplError => [ERROR_IMPL_ERROR]);
+impl_lint_pass!(ErrorImplError => [ERROR_IMPL_ERROR]);
+
+#[derive(Clone, Copy)]
+pub struct ErrorImplError {
+    pub allow_private_error: bool,
+}
 
 impl<'tcx> LateLintPass<'tcx> for ErrorImplError {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
+        let Self { allow_private_error } = *self;
         let Some(error_def_id) = cx.tcx.get_diagnostic_item(sym::Error) else {
             return;
         };
-
+        if allow_private_error && !cx.effective_visibilities.is_exported(item.owner_id.def_id) {
+            return;
+        }
         match item.kind {
             ItemKind::TyAlias(ty, _) if implements_trait(cx, hir_ty_to_ty(cx.tcx, ty), error_def_id, &[])
                 && item.ident.name == sym::Error =>
@@ -71,6 +79,5 @@ impl<'tcx> LateLintPass<'tcx> for ErrorImplError {
             }
             _ => {},
         }
-        {}
     }
 }
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 76654bfe536..22aef713db6 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -551,6 +551,10 @@ define_Conf! {
     ///
     /// Whether to allow `r#""#` when `r""` can be used
     (allow_one_hash_in_raw_strings: bool = false),
+    /// Lint: ERROR_IMPL_ERROR.
+    ///
+    /// Whether to allow private types named `Error` that implement `Error`
+    (allow_private_error: bool = true),
 }
 
 /// Search for the configuration file.
diff --git a/tests/ui-toml/error_impl_error/allow_private/clippy.toml b/tests/ui-toml/error_impl_error/allow_private/clippy.toml
new file mode 100644
index 00000000000..04202148031
--- /dev/null
+++ b/tests/ui-toml/error_impl_error/allow_private/clippy.toml
@@ -0,0 +1 @@
+allow-private-error = true
diff --git a/tests/ui-toml/error_impl_error/disallow_private/clippy.toml b/tests/ui-toml/error_impl_error/disallow_private/clippy.toml
new file mode 100644
index 00000000000..d42da3160a9
--- /dev/null
+++ b/tests/ui-toml/error_impl_error/disallow_private/clippy.toml
@@ -0,0 +1 @@
+allow-private-error = false
diff --git a/tests/ui-toml/error_impl_error/error_impl_error.allow_private.stderr b/tests/ui-toml/error_impl_error/error_impl_error.allow_private.stderr
new file mode 100644
index 00000000000..520c3e0a3e6
--- /dev/null
+++ b/tests/ui-toml/error_impl_error/error_impl_error.allow_private.stderr
@@ -0,0 +1,33 @@
+error: type named `Error` that implements `Error`
+  --> $DIR/error_impl_error.rs:10:16
+   |
+LL |     pub struct Error;
+   |                ^^^^^
+   |
+note: `Error` was implemented here
+  --> $DIR/error_impl_error.rs:18:5
+   |
+LL |     impl std::error::Error for Error {}
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   = note: `-D clippy::error-impl-error` implied by `-D warnings`
+
+error: type named `Error` that implements `Error`
+  --> $DIR/error_impl_error.rs:35:15
+   |
+LL |     pub union Error {
+   |               ^^^^^
+   |
+note: `Error` was implemented here
+  --> $DIR/error_impl_error.rs:52:5
+   |
+LL |     impl std::error::Error for Error {}
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: type alias named `Error` that implements `Error`
+  --> $DIR/error_impl_error.rs:56:14
+   |
+LL |     pub type Error = std::fmt::Error;
+   |              ^^^^^
+
+error: aborting due to 3 previous errors
+
diff --git a/tests/ui-toml/error_impl_error/error_impl_error.disallow_private.stderr b/tests/ui-toml/error_impl_error/error_impl_error.disallow_private.stderr
new file mode 100644
index 00000000000..d29c5ef374f
--- /dev/null
+++ b/tests/ui-toml/error_impl_error/error_impl_error.disallow_private.stderr
@@ -0,0 +1,45 @@
+error: type named `Error` that implements `Error`
+  --> $DIR/error_impl_error.rs:10:16
+   |
+LL |     pub struct Error;
+   |                ^^^^^
+   |
+note: `Error` was implemented here
+  --> $DIR/error_impl_error.rs:18:5
+   |
+LL |     impl std::error::Error for Error {}
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   = note: `-D clippy::error-impl-error` implied by `-D warnings`
+
+error: type named `Error` that implements `Error`
+  --> $DIR/error_impl_error.rs:23:10
+   |
+LL |     enum Error {}
+   |          ^^^^^
+   |
+note: `Error` was implemented here
+  --> $DIR/error_impl_error.rs:31:5
+   |
+LL |     impl std::error::Error for Error {}
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: type named `Error` that implements `Error`
+  --> $DIR/error_impl_error.rs:35:15
+   |
+LL |     pub union Error {
+   |               ^^^^^
+   |
+note: `Error` was implemented here
+  --> $DIR/error_impl_error.rs:52:5
+   |
+LL |     impl std::error::Error for Error {}
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: type alias named `Error` that implements `Error`
+  --> $DIR/error_impl_error.rs:56:14
+   |
+LL |     pub type Error = std::fmt::Error;
+   |              ^^^^^
+
+error: aborting due to 4 previous errors
+
diff --git a/tests/ui-toml/error_impl_error/error_impl_error.rs b/tests/ui-toml/error_impl_error/error_impl_error.rs
new file mode 100644
index 00000000000..3f14b777ee8
--- /dev/null
+++ b/tests/ui-toml/error_impl_error/error_impl_error.rs
@@ -0,0 +1,74 @@
+//@revisions: allow_private disallow_private
+//@[allow_private] rustc-env:CLIPPY_CONF_DIR=tests/ui-toml/error_impl_error/allow_private
+//@[disallow_private] rustc-env:CLIPPY_CONF_DIR=tests/ui-toml/error_impl_error/disallow_private
+#![allow(unused)]
+#![warn(clippy::error_impl_error)]
+#![no_main]
+
+pub mod a {
+    #[derive(Debug)]
+    pub struct Error;
+
+    impl std::fmt::Display for Error {
+        fn fmt(&self, _: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            todo!()
+        }
+    }
+
+    impl std::error::Error for Error {}
+}
+
+mod b {
+    #[derive(Debug)]
+    enum Error {}
+
+    impl std::fmt::Display for Error {
+        fn fmt(&self, _: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            todo!()
+        }
+    }
+
+    impl std::error::Error for Error {}
+}
+
+pub mod c {
+    pub union Error {
+        a: u32,
+        b: u32,
+    }
+
+    impl std::fmt::Debug for Error {
+        fn fmt(&self, _: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            todo!()
+        }
+    }
+
+    impl std::fmt::Display for Error {
+        fn fmt(&self, _: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            todo!()
+        }
+    }
+
+    impl std::error::Error for Error {}
+}
+
+pub mod d {
+    pub type Error = std::fmt::Error;
+}
+
+mod e {
+    #[derive(Debug)]
+    struct MyError;
+
+    impl std::fmt::Display for MyError {
+        fn fmt(&self, _: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            todo!()
+        }
+    }
+
+    impl std::error::Error for MyError {}
+}
+
+mod f {
+    type MyError = std::fmt::Error;
+}
diff --git a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
index 6ba26e97730..227424f948c 100644
--- a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
+++ b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
@@ -6,6 +6,7 @@ error: error reading Clippy's configuration file: unknown field `foobar`, expect
            allow-mixed-uninlined-format-args
            allow-one-hash-in-raw-strings
            allow-print-in-tests
+           allow-private-error
            allow-private-module-inception
            allow-unwrap-in-tests
            allowed-idents-below-min-chars
@@ -75,6 +76,7 @@ error: error reading Clippy's configuration file: unknown field `barfoo`, expect
            allow-mixed-uninlined-format-args
            allow-one-hash-in-raw-strings
            allow-print-in-tests
+           allow-private-error
            allow-private-module-inception
            allow-unwrap-in-tests
            allowed-idents-below-min-chars
diff --git a/tests/ui/error_impl_error.rs b/tests/ui/error_impl_error.rs
deleted file mode 100644
index d85f9522081..00000000000
--- a/tests/ui/error_impl_error.rs
+++ /dev/null
@@ -1,71 +0,0 @@
-#![allow(unused)]
-#![warn(clippy::error_impl_error)]
-#![no_main]
-
-mod a {
-    #[derive(Debug)]
-    struct Error;
-
-    impl std::fmt::Display for Error {
-        fn fmt(&self, _: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-            todo!()
-        }
-    }
-
-    impl std::error::Error for Error {}
-}
-
-mod b {
-    #[derive(Debug)]
-    enum Error {}
-
-    impl std::fmt::Display for Error {
-        fn fmt(&self, _: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-            todo!()
-        }
-    }
-
-    impl std::error::Error for Error {}
-}
-
-mod c {
-    union Error {
-        a: u32,
-        b: u32,
-    }
-
-    impl std::fmt::Debug for Error {
-        fn fmt(&self, _: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-            todo!()
-        }
-    }
-
-    impl std::fmt::Display for Error {
-        fn fmt(&self, _: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-            todo!()
-        }
-    }
-
-    impl std::error::Error for Error {}
-}
-
-mod d {
-    type Error = std::fmt::Error;
-}
-
-mod e {
-    #[derive(Debug)]
-    struct MyError;
-
-    impl std::fmt::Display for MyError {
-        fn fmt(&self, _: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-            todo!()
-        }
-    }
-
-    impl std::error::Error for MyError {}
-}
-
-mod f {
-    type MyError = std::fmt::Error;
-}
diff --git a/tests/ui/error_impl_error.stderr b/tests/ui/error_impl_error.stderr
deleted file mode 100644
index 64af0594e0a..00000000000
--- a/tests/ui/error_impl_error.stderr
+++ /dev/null
@@ -1,45 +0,0 @@
-error: type named `Error` that implements `Error`
-  --> $DIR/error_impl_error.rs:7:12
-   |
-LL |     struct Error;
-   |            ^^^^^
-   |
-note: `Error` was implemented here
-  --> $DIR/error_impl_error.rs:15:5
-   |
-LL |     impl std::error::Error for Error {}
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   = note: `-D clippy::error-impl-error` implied by `-D warnings`
-
-error: type named `Error` that implements `Error`
-  --> $DIR/error_impl_error.rs:20:10
-   |
-LL |     enum Error {}
-   |          ^^^^^
-   |
-note: `Error` was implemented here
-  --> $DIR/error_impl_error.rs:28:5
-   |
-LL |     impl std::error::Error for Error {}
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: type named `Error` that implements `Error`
-  --> $DIR/error_impl_error.rs:32:11
-   |
-LL |     union Error {
-   |           ^^^^^
-   |
-note: `Error` was implemented here
-  --> $DIR/error_impl_error.rs:49:5
-   |
-LL |     impl std::error::Error for Error {}
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: type alias named `Error` that implements `Error`
-  --> $DIR/error_impl_error.rs:53:10
-   |
-LL |     type Error = std::fmt::Error;
-   |          ^^^^^
-
-error: aborting due to 4 previous errors
-
-- 
cgit 1.4.1-3-g733a5


From 8b0540bb46467cb4af35eed437994753957a43c6 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Tue, 18 Jul 2023 21:45:28 +0200
Subject: Fix async functions handling for `needless_pass_by_ref_mut` lint

---
 clippy_lints/src/needless_pass_by_ref_mut.rs | 89 +++++++++++++++++++++-------
 1 file changed, 67 insertions(+), 22 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/needless_pass_by_ref_mut.rs b/clippy_lints/src/needless_pass_by_ref_mut.rs
index cdb7ee48305..c399b43e251 100644
--- a/clippy_lints/src/needless_pass_by_ref_mut.rs
+++ b/clippy_lints/src/needless_pass_by_ref_mut.rs
@@ -3,14 +3,16 @@ use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet;
 use clippy_utils::{is_from_proc_macro, is_self};
 use if_chain::if_chain;
+use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::{Body, FnDecl, HirId, HirIdMap, HirIdSet, Impl, ItemKind, Mutability, Node, PatKind};
 use rustc_hir_typeck::expr_use_visitor as euv;
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::hir::map::associated_body;
 use rustc_middle::mir::FakeReadCause;
-use rustc_middle::ty::{self, Ty};
+use rustc_middle::ty::{self, Ty, UpvarId, UpvarPath};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::def_id::LocalDefId;
 use rustc_span::symbol::kw;
@@ -102,17 +104,17 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByRefMut {
         }
 
         let hir_id = cx.tcx.hir().local_def_id_to_hir_id(fn_def_id);
-
-        match kind {
+        let is_async = match kind {
             FnKind::ItemFn(.., header) => {
                 let attrs = cx.tcx.hir().attrs(hir_id);
                 if header.abi != Abi::Rust || requires_exact_signature(attrs) {
                     return;
                 }
+                header.is_async()
             },
-            FnKind::Method(..) => (),
+            FnKind::Method(.., sig) => sig.header.is_async(),
             FnKind::Closure => return,
-        }
+        };
 
         // Exclude non-inherent impls
         if let Some(Node::Item(item)) = cx.tcx.hir().find_parent(hir_id) {
@@ -128,13 +130,14 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByRefMut {
         let fn_sig = cx.tcx.liberate_late_bound_regions(fn_def_id.to_def_id(), fn_sig);
 
         // If there are no `&mut` argument, no need to go any further.
-        if !decl
+        let mut it = decl
             .inputs
             .iter()
             .zip(fn_sig.inputs())
             .zip(body.params)
-            .any(|((&input, &ty), arg)| !should_skip(cx, input, ty, arg))
-        {
+            .filter(|((&input, &ty), arg)| !should_skip(cx, input, ty, arg))
+            .peekable();
+        if it.peek().is_none() {
             return;
         }
 
@@ -144,19 +147,25 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByRefMut {
             let mut ctx = MutablyUsedVariablesCtxt::default();
             let infcx = cx.tcx.infer_ctxt().build();
             euv::ExprUseVisitor::new(&mut ctx, &infcx, fn_def_id, cx.param_env, cx.typeck_results()).consume_body(body);
+            if is_async {
+                let closures = ctx.async_closures.clone();
+                let hir = cx.tcx.hir();
+                for closure in closures {
+                    ctx.prev_bind = None;
+                    ctx.prev_move_to_closure.clear();
+                    if let Some(body) = hir
+                        .find_by_def_id(closure)
+                        .and_then(associated_body)
+                        .map(|(_, body_id)| hir.body(body_id))
+                    {
+                        euv::ExprUseVisitor::new(&mut ctx, &infcx, closure, cx.param_env, cx.typeck_results())
+                            .consume_body(body);
+                    }
+                }
+            }
             ctx
         };
 
-        let mut it = decl
-            .inputs
-            .iter()
-            .zip(fn_sig.inputs())
-            .zip(body.params)
-            .filter(|((&input, &ty), arg)| !should_skip(cx, input, ty, arg))
-            .peekable();
-        if it.peek().is_none() {
-            return;
-        }
         let show_semver_warning = self.avoid_breaking_exported_api && cx.effective_visibilities.is_exported(fn_def_id);
         for ((&input, &_), arg) in it {
             // Only take `&mut` arguments.
@@ -197,7 +206,9 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByRefMut {
 struct MutablyUsedVariablesCtxt {
     mutably_used_vars: HirIdSet,
     prev_bind: Option<HirId>,
+    prev_move_to_closure: HirIdSet,
     aliases: HirIdMap<HirId>,
+    async_closures: FxHashSet<LocalDefId>,
 }
 
 impl MutablyUsedVariablesCtxt {
@@ -213,16 +224,27 @@ impl MutablyUsedVariablesCtxt {
 impl<'tcx> euv::Delegate<'tcx> for MutablyUsedVariablesCtxt {
     fn consume(&mut self, cmt: &euv::PlaceWithHirId<'tcx>, _id: HirId) {
         if let euv::Place {
-            base: euv::PlaceBase::Local(vid),
+            base:
+                euv::PlaceBase::Local(vid)
+                | euv::PlaceBase::Upvar(UpvarId {
+                    var_path: UpvarPath { hir_id: vid },
+                    ..
+                }),
             base_ty,
             ..
         } = &cmt.place
         {
             if let Some(bind_id) = self.prev_bind.take() {
-                self.aliases.insert(bind_id, *vid);
-            } else if matches!(base_ty.ref_mutability(), Some(Mutability::Mut)) {
+                if bind_id != *vid {
+                    self.aliases.insert(bind_id, *vid);
+                }
+            } else if !self.prev_move_to_closure.contains(vid)
+                && matches!(base_ty.ref_mutability(), Some(Mutability::Mut))
+            {
                 self.add_mutably_used_var(*vid);
             }
+            self.prev_bind = None;
+            self.prev_move_to_closure.remove(vid);
         }
     }
 
@@ -265,7 +287,30 @@ impl<'tcx> euv::Delegate<'tcx> for MutablyUsedVariablesCtxt {
         self.prev_bind = None;
     }
 
-    fn fake_read(&mut self, _: &rustc_hir_typeck::expr_use_visitor::PlaceWithHirId<'tcx>, _: FakeReadCause, _: HirId) {}
+    fn fake_read(
+        &mut self,
+        cmt: &rustc_hir_typeck::expr_use_visitor::PlaceWithHirId<'tcx>,
+        cause: FakeReadCause,
+        _id: HirId,
+    ) {
+        if let euv::Place {
+            base:
+                euv::PlaceBase::Upvar(UpvarId {
+                    var_path: UpvarPath { hir_id: vid },
+                    ..
+                }),
+            ..
+        } = &cmt.place
+        {
+            if let FakeReadCause::ForLet(Some(inner)) = cause {
+                // Seems like we are inside an async function. We need to store the closure `DefId`
+                // to go through it afterwards.
+                self.async_closures.insert(inner);
+                self.aliases.insert(cmt.hir_id, *vid);
+                self.prev_move_to_closure.insert(*vid);
+            }
+        }
+    }
 
     fn bind(&mut self, _cmt: &euv::PlaceWithHirId<'tcx>, id: HirId) {
         self.prev_bind = Some(id);
-- 
cgit 1.4.1-3-g733a5


From 9d08502496f8a61bdc1f8d20ba075b6d0a5a8b87 Mon Sep 17 00:00:00 2001
From: Catherine <114838443+Centri3@users.noreply.github.com>
Date: Fri, 30 Jun 2023 14:39:17 -0500
Subject: New lint [`string_lit_chars_any`]

---
 CHANGELOG.md                                     |  1 +
 clippy_lints/src/declared_lints.rs               |  1 +
 clippy_lints/src/methods/mod.rs                  | 39 +++++++++++++++-
 clippy_lints/src/methods/string_lit_chars_any.rs | 58 ++++++++++++++++++++++++
 tests/ui/string_lit_chars_any.fixed              | 50 ++++++++++++++++++++
 tests/ui/string_lit_chars_any.rs                 | 50 ++++++++++++++++++++
 tests/ui/string_lit_chars_any.stderr             | 58 ++++++++++++++++++++++++
 7 files changed, 256 insertions(+), 1 deletion(-)
 create mode 100644 clippy_lints/src/methods/string_lit_chars_any.rs
 create mode 100644 tests/ui/string_lit_chars_any.fixed
 create mode 100644 tests/ui/string_lit_chars_any.rs
 create mode 100644 tests/ui/string_lit_chars_any.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index db18bc296f7..ece1111213c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5256,6 +5256,7 @@ Released 2018-09-13
 [`string_extend_chars`]: https://rust-lang.github.io/rust-clippy/master/index.html#string_extend_chars
 [`string_from_utf8_as_bytes`]: https://rust-lang.github.io/rust-clippy/master/index.html#string_from_utf8_as_bytes
 [`string_lit_as_bytes`]: https://rust-lang.github.io/rust-clippy/master/index.html#string_lit_as_bytes
+[`string_lit_chars_any`]: https://rust-lang.github.io/rust-clippy/master/index.html#string_lit_chars_any
 [`string_slice`]: https://rust-lang.github.io/rust-clippy/master/index.html#string_slice
 [`string_to_string`]: https://rust-lang.github.io/rust-clippy/master/index.html#string_to_string
 [`strlen_on_c_strings`]: https://rust-lang.github.io/rust-clippy/master/index.html#strlen_on_c_strings
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 51035a9d66b..168dc9bf4e1 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -405,6 +405,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::methods::SKIP_WHILE_NEXT_INFO,
     crate::methods::STABLE_SORT_PRIMITIVE_INFO,
     crate::methods::STRING_EXTEND_CHARS_INFO,
+    crate::methods::STRING_LIT_CHARS_ANY_INFO,
     crate::methods::SUSPICIOUS_COMMAND_ARG_SPACE_INFO,
     crate::methods::SUSPICIOUS_MAP_INFO,
     crate::methods::SUSPICIOUS_SPLITN_INFO,
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 81f59f68ec6..6efeff92091 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -86,6 +86,7 @@ mod skip_while_next;
 mod stable_sort_primitive;
 mod str_splitn;
 mod string_extend_chars;
+mod string_lit_chars_any;
 mod suspicious_command_arg_space;
 mod suspicious_map;
 mod suspicious_splitn;
@@ -115,7 +116,7 @@ use clippy_utils::consts::{constant, Constant};
 use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
 use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::ty::{contains_ty_adt_constructor_opaque, implements_trait, is_copy, is_type_diagnostic_item};
-use clippy_utils::{contains_return, is_bool, is_trait_method, iter_input_pats, return_ty};
+use clippy_utils::{contains_return, is_bool, is_trait_method, iter_input_pats, peel_blocks, return_ty};
 use if_chain::if_chain;
 use rustc_hir as hir;
 use rustc_hir::{Expr, ExprKind, Node, Stmt, StmtKind, TraitItem, TraitItemKind};
@@ -3379,6 +3380,34 @@ declare_clippy_lint! {
     "calling `Stdin::read_line`, then trying to parse it without first trimming"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `<string_lit>.chars().any(|i| i == c)`.
+    ///
+    /// ### Why is this bad?
+    /// It's significantly slower than using a pattern instead, like
+    /// `matches!(c, '\\' | '.' | '+')`.
+    ///
+    /// Despite this being faster, this is not `perf` as this is pretty common, and is a rather nice
+    /// way to check if a `char` is any in a set. In any case, this `restriction` lint is available
+    /// for situations where that additional performance is absolutely necessary.
+    ///
+    /// ### Example
+    /// ```rust
+    /// # let c = 'c';
+    /// "\\.+*?()|[]{}^$#&-~".chars().any(|x| x == c);
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// # let c = 'c';
+    /// matches!(c, '\\' | '.' | '+' | '*' | '(' | ')' | '|' | '[' | ']' | '{' | '}' | '^' | '$' | '#' | '&' | '-' | '~');
+    /// ```
+    #[clippy::version = "1.72.0"]
+    pub STRING_LIT_CHARS_ANY,
+    restriction,
+    "checks for `<string_lit>.chars().any(|i| i == c)`"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for usage of `.map(|_| format!(..)).collect::<String>()`.
@@ -3549,6 +3578,7 @@ impl_lint_pass!(Methods => [
     DRAIN_COLLECT,
     MANUAL_TRY_FOLD,
     FORMAT_COLLECT,
+    STRING_LIT_CHARS_ANY,
 ]);
 
 /// Extracts a method call name, args, and `Span` of the method name.
@@ -3923,6 +3953,13 @@ impl Methods {
                         }
                     }
                 },
+                ("any", [arg]) if let ExprKind::Closure(arg) = arg.kind
+                    && let body = cx.tcx.hir().body(arg.body)
+                    && let [param] = body.params
+                    && let Some(("chars", recv, _, _, _)) = method_call(recv) =>
+                {
+                    string_lit_chars_any::check(cx, expr, recv, param, peel_blocks(body.value), &self.msrv);
+                }
                 ("nth", [n_arg]) => match method_call(recv) {
                     Some(("bytes", recv2, [], _, _)) => bytes_nth::check(cx, expr, recv2, n_arg),
                     Some(("cloned", recv2, [], _, _)) => iter_overeager_cloned::check(cx, expr, recv, recv2, false, false),
diff --git a/clippy_lints/src/methods/string_lit_chars_any.rs b/clippy_lints/src/methods/string_lit_chars_any.rs
new file mode 100644
index 00000000000..70da6ad58bd
--- /dev/null
+++ b/clippy_lints/src/methods/string_lit_chars_any.rs
@@ -0,0 +1,58 @@
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::msrvs::{Msrv, MATCHES_MACRO};
+use clippy_utils::source::snippet_opt;
+use clippy_utils::{is_from_proc_macro, is_trait_method, path_to_local};
+use itertools::Itertools;
+use rustc_ast::LitKind;
+use rustc_errors::Applicability;
+use rustc_hir::{BinOpKind, Expr, ExprKind, Param, PatKind};
+use rustc_lint::LateContext;
+use rustc_span::sym;
+
+use super::STRING_LIT_CHARS_ANY;
+
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx Expr<'tcx>,
+    recv: &Expr<'_>,
+    param: &'tcx Param<'tcx>,
+    body: &Expr<'_>,
+    msrv: &Msrv,
+) {
+    if msrv.meets(MATCHES_MACRO)
+        && is_trait_method(cx, expr, sym::Iterator)
+        && let PatKind::Binding(_, arg, _, _) = param.pat.kind
+        && let ExprKind::Lit(lit_kind) = recv.kind
+        && let LitKind::Str(val, _) = lit_kind.node
+        && let ExprKind::Binary(kind, lhs, rhs) = body.kind
+        && let BinOpKind::Eq = kind.node
+        && let Some(lhs_path) = path_to_local(lhs)
+        && let Some(rhs_path) = path_to_local(rhs)
+        && let scrutinee = match (lhs_path == arg, rhs_path == arg) {
+            (true, false) => rhs,
+            (false, true) => lhs,
+            _ => return,
+        }
+        && !is_from_proc_macro(cx, expr)
+        && let Some(scrutinee_snip) = snippet_opt(cx, scrutinee.span)
+    {
+        // Normalize the char using `map` so `join` doesn't use `Display`, if we don't then
+        // something like `r"\"` will become `'\'`, which is of course invalid
+        let pat_snip = val.as_str().chars().map(|c| format!("{c:?}")).join(" | ");
+
+        span_lint_and_then(
+            cx,
+            STRING_LIT_CHARS_ANY,
+            expr.span,
+            "usage of `.chars().any(...)` to check if a char matches any from a string literal",
+            |diag| {
+                diag.span_suggestion_verbose(
+                    expr.span,
+                    "use `matches!(...)` instead",
+                    format!("matches!({scrutinee_snip}, {pat_snip})"),
+                    Applicability::MachineApplicable,
+                );
+            }
+        );
+    }
+}
diff --git a/tests/ui/string_lit_chars_any.fixed b/tests/ui/string_lit_chars_any.fixed
new file mode 100644
index 00000000000..d7ab9c3397a
--- /dev/null
+++ b/tests/ui/string_lit_chars_any.fixed
@@ -0,0 +1,50 @@
+//@run-rustfix
+//@aux-build:proc_macros.rs:proc-macro
+#![allow(clippy::eq_op, clippy::needless_raw_string_hashes, clippy::no_effect, unused)]
+#![warn(clippy::string_lit_chars_any)]
+
+#[macro_use]
+extern crate proc_macros;
+
+struct NotStringLit;
+
+impl NotStringLit {
+    fn chars(&self) -> impl Iterator<Item = char> {
+        "c".chars()
+    }
+}
+
+fn main() {
+    let c = 'c';
+    matches!(c, '\\' | '.' | '+' | '*' | '?' | '(' | ')' | '|' | '[' | ']' | '{' | '}' | '^' | '$' | '#' | '&' | '-' | '~');
+    matches!(c, '\\' | '.' | '+' | '*' | '?' | '(' | ')' | '|' | '[' | ']' | '{' | '}' | '^' | '$' | '#' | '&' | '-' | '~');
+    matches!(c, '\\' | '.' | '+' | '*' | '?' | '(' | ')' | '|' | '[' | ']' | '{' | '}' | '^' | '$' | '#' | '&' | '-' | '~');
+    matches!(c, '\\' | '.' | '+' | '*' | '?' | '(' | ')' | '|' | '[' | ']' | '{' | '}' | '^' | '$' | '#' | '&' | '-' | '~');
+    #[rustfmt::skip]
+    matches!(c, '\\' | '.' | '+' | '*' | '?' | '(' | ')' | '|' | '[' | ']' | '{' | '}' | '^' | '$' | '#' | '&' | '-' | '~');
+    // Do not lint
+    NotStringLit.chars().any(|x| x == c);
+    "\\.+*?()|[]{}^$#&-~".chars().any(|x| {
+        let c = 'c';
+        x == c
+    });
+    "\\.+*?()|[]{}^$#&-~".chars().any(|x| {
+        1;
+        x == c
+    });
+    "\\.+*?()|[]{}^$#&-~".chars().any(|x| x == x);
+    "\\.+*?()|[]{}^$#&-~".chars().any(|_x| c == c);
+    matches!(
+        c,
+        '\\' | '.' | '+' | '*' | '(' | ')' | '|' | '[' | ']' | '{' | '}' | '^' | '$' | '#' | '&' | '-' | '~'
+    );
+    external! {
+        let c = 'c';
+        "\\.+*?()|[]{}^$#&-~".chars().any(|x| x == c);
+    }
+    with_span! {
+        span
+        let c = 'c';
+        "\\.+*?()|[]{}^$#&-~".chars().any(|x| x == c);
+    }
+}
diff --git a/tests/ui/string_lit_chars_any.rs b/tests/ui/string_lit_chars_any.rs
new file mode 100644
index 00000000000..9408d7bb239
--- /dev/null
+++ b/tests/ui/string_lit_chars_any.rs
@@ -0,0 +1,50 @@
+//@run-rustfix
+//@aux-build:proc_macros.rs:proc-macro
+#![allow(clippy::eq_op, clippy::needless_raw_string_hashes, clippy::no_effect, unused)]
+#![warn(clippy::string_lit_chars_any)]
+
+#[macro_use]
+extern crate proc_macros;
+
+struct NotStringLit;
+
+impl NotStringLit {
+    fn chars(&self) -> impl Iterator<Item = char> {
+        "c".chars()
+    }
+}
+
+fn main() {
+    let c = 'c';
+    "\\.+*?()|[]{}^$#&-~".chars().any(|x| x == c);
+    r#"\.+*?()|[]{}^$#&-~"#.chars().any(|x| x == c);
+    "\\.+*?()|[]{}^$#&-~".chars().any(|x| c == x);
+    r#"\.+*?()|[]{}^$#&-~"#.chars().any(|x| c == x);
+    #[rustfmt::skip]
+    "\\.+*?()|[]{}^$#&-~".chars().any(|x| { x == c });
+    // Do not lint
+    NotStringLit.chars().any(|x| x == c);
+    "\\.+*?()|[]{}^$#&-~".chars().any(|x| {
+        let c = 'c';
+        x == c
+    });
+    "\\.+*?()|[]{}^$#&-~".chars().any(|x| {
+        1;
+        x == c
+    });
+    "\\.+*?()|[]{}^$#&-~".chars().any(|x| x == x);
+    "\\.+*?()|[]{}^$#&-~".chars().any(|_x| c == c);
+    matches!(
+        c,
+        '\\' | '.' | '+' | '*' | '(' | ')' | '|' | '[' | ']' | '{' | '}' | '^' | '$' | '#' | '&' | '-' | '~'
+    );
+    external! {
+        let c = 'c';
+        "\\.+*?()|[]{}^$#&-~".chars().any(|x| x == c);
+    }
+    with_span! {
+        span
+        let c = 'c';
+        "\\.+*?()|[]{}^$#&-~".chars().any(|x| x == c);
+    }
+}
diff --git a/tests/ui/string_lit_chars_any.stderr b/tests/ui/string_lit_chars_any.stderr
new file mode 100644
index 00000000000..ff951b73ded
--- /dev/null
+++ b/tests/ui/string_lit_chars_any.stderr
@@ -0,0 +1,58 @@
+error: usage of `.chars().any(...)` to check if a char matches any from a string literal
+  --> $DIR/string_lit_chars_any.rs:19:5
+   |
+LL |     "//.+*?()|[]{}^$#&-~".chars().any(|x| x == c);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::string-lit-chars-any` implied by `-D warnings`
+help: use `matches!(...)` instead
+   |
+LL |     matches!(c, '//' | '.' | '+' | '*' | '?' | '(' | ')' | '|' | '[' | ']' | '{' | '}' | '^' | '$' | '#' | '&' | '-' | '~');
+   |     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+error: usage of `.chars().any(...)` to check if a char matches any from a string literal
+  --> $DIR/string_lit_chars_any.rs:20:5
+   |
+LL |     r#"/.+*?()|[]{}^$#&-~"#.chars().any(|x| x == c);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `matches!(...)` instead
+   |
+LL |     matches!(c, '//' | '.' | '+' | '*' | '?' | '(' | ')' | '|' | '[' | ']' | '{' | '}' | '^' | '$' | '#' | '&' | '-' | '~');
+   |     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+error: usage of `.chars().any(...)` to check if a char matches any from a string literal
+  --> $DIR/string_lit_chars_any.rs:21:5
+   |
+LL |     "//.+*?()|[]{}^$#&-~".chars().any(|x| c == x);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `matches!(...)` instead
+   |
+LL |     matches!(c, '//' | '.' | '+' | '*' | '?' | '(' | ')' | '|' | '[' | ']' | '{' | '}' | '^' | '$' | '#' | '&' | '-' | '~');
+   |     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+error: usage of `.chars().any(...)` to check if a char matches any from a string literal
+  --> $DIR/string_lit_chars_any.rs:22:5
+   |
+LL |     r#"/.+*?()|[]{}^$#&-~"#.chars().any(|x| c == x);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `matches!(...)` instead
+   |
+LL |     matches!(c, '//' | '.' | '+' | '*' | '?' | '(' | ')' | '|' | '[' | ']' | '{' | '}' | '^' | '$' | '#' | '&' | '-' | '~');
+   |     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+error: usage of `.chars().any(...)` to check if a char matches any from a string literal
+  --> $DIR/string_lit_chars_any.rs:24:5
+   |
+LL |     "//.+*?()|[]{}^$#&-~".chars().any(|x| { x == c });
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `matches!(...)` instead
+   |
+LL |     matches!(c, '//' | '.' | '+' | '*' | '?' | '(' | ')' | '|' | '[' | ']' | '{' | '}' | '^' | '$' | '#' | '&' | '-' | '~');
+   |     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+error: aborting due to 5 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 19b0e84187fd0c7ada499adc256d671e2d6ad78c Mon Sep 17 00:00:00 2001
From: Catherine <114838443+Centri3@users.noreply.github.com>
Date: Tue, 18 Jul 2023 10:25:58 -0500
Subject: Remove the configuration option

Also no longer lints non-exported types now
---
 CHANGELOG.md                                       |  1 -
 book/src/lint_configuration.md                     | 10 ---
 clippy_lints/src/error_impl_error.rs               | 44 ++++++-----
 clippy_lints/src/utils/conf.rs                     |  4 -
 .../error_impl_error/allow_private/clippy.toml     |  1 -
 .../error_impl_error/disallow_private/clippy.toml  |  1 -
 .../error_impl_error.allow_private.stderr          | 33 --------
 .../error_impl_error.disallow_private.stderr       | 45 -----------
 tests/ui-toml/error_impl_error/error_impl_error.rs | 74 ------------------
 .../toml_unknown_key/conf_unknown_key.stderr       |  2 -
 tests/ui/error_impl_error.rs                       | 90 ++++++++++++++++++++++
 tests/ui/error_impl_error.stderr                   | 45 +++++++++++
 12 files changed, 159 insertions(+), 191 deletions(-)
 delete mode 100644 tests/ui-toml/error_impl_error/allow_private/clippy.toml
 delete mode 100644 tests/ui-toml/error_impl_error/disallow_private/clippy.toml
 delete mode 100644 tests/ui-toml/error_impl_error/error_impl_error.allow_private.stderr
 delete mode 100644 tests/ui-toml/error_impl_error/error_impl_error.disallow_private.stderr
 delete mode 100644 tests/ui-toml/error_impl_error/error_impl_error.rs
 create mode 100644 tests/ui/error_impl_error.rs
 create mode 100644 tests/ui/error_impl_error.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 0676752b766..0445e59480c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5465,5 +5465,4 @@ Released 2018-09-13
 [`accept-comment-above-statement`]: https://doc.rust-lang.org/clippy/lint_configuration.html#accept-comment-above-statement
 [`accept-comment-above-attributes`]: https://doc.rust-lang.org/clippy/lint_configuration.html#accept-comment-above-attributes
 [`allow-one-hash-in-raw-strings`]: https://doc.rust-lang.org/clippy/lint_configuration.html#allow-one-hash-in-raw-strings
-[`allow-private-error`]: https://doc.rust-lang.org/clippy/lint_configuration.html#allow-private-error
 <!-- end autogenerated links to configuration documentation -->
diff --git a/book/src/lint_configuration.md b/book/src/lint_configuration.md
index 1035f3e7fb6..f8073dac330 100644
--- a/book/src/lint_configuration.md
+++ b/book/src/lint_configuration.md
@@ -730,13 +730,3 @@ Whether to allow `r#""#` when `r""` can be used
 * [`unnecessary_raw_string_hashes`](https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_raw_string_hashes)
 
 
-## `allow-private-error`
-Whether to allow private types named `Error` that implement `Error`
-
-**Default Value:** `true` (`bool`)
-
----
-**Affected lints:**
-* [`error_impl_error`](https://rust-lang.github.io/rust-clippy/master/index.html#error_impl_error)
-
-
diff --git a/clippy_lints/src/error_impl_error.rs b/clippy_lints/src/error_impl_error.rs
index 585a0ad04c7..379af9b2234 100644
--- a/clippy_lints/src/error_impl_error.rs
+++ b/clippy_lints/src/error_impl_error.rs
@@ -1,11 +1,12 @@
 use clippy_utils::diagnostics::{span_lint, span_lint_hir_and_then};
 use clippy_utils::path_res;
 use clippy_utils::ty::implements_trait;
-use rustc_hir::def_id::DefId;
-use rustc_hir::{Item, ItemKind, Node};
+use rustc_hir::def_id::{DefId, LocalDefId};
+use rustc_hir::{Item, ItemKind};
 use rustc_hir_analysis::hir_ty_to_ty;
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_middle::ty::Visibility;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::sym;
 
 declare_clippy_lint! {
@@ -30,48 +31,42 @@ declare_clippy_lint! {
     #[clippy::version = "1.72.0"]
     pub ERROR_IMPL_ERROR,
     restriction,
-    "types named `Error` that implement `Error`"
-}
-impl_lint_pass!(ErrorImplError => [ERROR_IMPL_ERROR]);
-
-#[derive(Clone, Copy)]
-pub struct ErrorImplError {
-    pub allow_private_error: bool,
+    "exported types named `Error` that implement `Error`"
 }
+declare_lint_pass!(ErrorImplError => [ERROR_IMPL_ERROR]);
 
 impl<'tcx> LateLintPass<'tcx> for ErrorImplError {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
-        let Self { allow_private_error } = *self;
         let Some(error_def_id) = cx.tcx.get_diagnostic_item(sym::Error) else {
             return;
         };
-        if allow_private_error && !cx.effective_visibilities.is_exported(item.owner_id.def_id) {
-            return;
-        }
+
         match item.kind {
             ItemKind::TyAlias(ty, _) if implements_trait(cx, hir_ty_to_ty(cx.tcx, ty), error_def_id, &[])
-                && item.ident.name == sym::Error =>
+                && item.ident.name == sym::Error
+                && is_visible_outside_module(cx, item.owner_id.def_id) =>
             {
                 span_lint(
                     cx,
                     ERROR_IMPL_ERROR,
                     item.ident.span,
-                    "type alias named `Error` that implements `Error`",
+                    "exported type alias named `Error` that implements `Error`",
                 );
             },
             ItemKind::Impl(imp) if let Some(trait_def_id) = imp.of_trait.and_then(|t| t.trait_def_id())
                 && error_def_id == trait_def_id
                 && let Some(def_id) = path_res(cx, imp.self_ty).opt_def_id().and_then(DefId::as_local)
                 && let hir_id = cx.tcx.hir().local_def_id_to_hir_id(def_id)
-                && let Node::Item(ty_item) = cx.tcx.hir().get(hir_id)
-                && ty_item.ident.name == sym::Error =>
+                && let Some(ident) = cx.tcx.opt_item_ident(def_id.to_def_id())
+                && ident.name == sym::Error
+                && is_visible_outside_module(cx, def_id) =>
             {
                 span_lint_hir_and_then(
                     cx,
                     ERROR_IMPL_ERROR,
                     hir_id,
-                    ty_item.ident.span,
-                    "type named `Error` that implements `Error`",
+                    ident.span,
+                    "exported type named `Error` that implements `Error`",
                     |diag| {
                         diag.span_note(item.span, "`Error` was implemented here");
                     }
@@ -81,3 +76,12 @@ impl<'tcx> LateLintPass<'tcx> for ErrorImplError {
         }
     }
 }
+
+/// Do not lint private `Error`s, i.e., ones without any `pub` (minus `pub(self)` of course) and
+/// which aren't reexported
+fn is_visible_outside_module(cx: &LateContext<'_>, def_id: LocalDefId) -> bool {
+    !matches!(
+        cx.tcx.visibility(def_id),
+        Visibility::Restricted(mod_def_id) if cx.tcx.parent_module_from_def_id(def_id).to_def_id() == mod_def_id
+    )
+}
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 22aef713db6..76654bfe536 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -551,10 +551,6 @@ define_Conf! {
     ///
     /// Whether to allow `r#""#` when `r""` can be used
     (allow_one_hash_in_raw_strings: bool = false),
-    /// Lint: ERROR_IMPL_ERROR.
-    ///
-    /// Whether to allow private types named `Error` that implement `Error`
-    (allow_private_error: bool = true),
 }
 
 /// Search for the configuration file.
diff --git a/tests/ui-toml/error_impl_error/allow_private/clippy.toml b/tests/ui-toml/error_impl_error/allow_private/clippy.toml
deleted file mode 100644
index 04202148031..00000000000
--- a/tests/ui-toml/error_impl_error/allow_private/clippy.toml
+++ /dev/null
@@ -1 +0,0 @@
-allow-private-error = true
diff --git a/tests/ui-toml/error_impl_error/disallow_private/clippy.toml b/tests/ui-toml/error_impl_error/disallow_private/clippy.toml
deleted file mode 100644
index d42da3160a9..00000000000
--- a/tests/ui-toml/error_impl_error/disallow_private/clippy.toml
+++ /dev/null
@@ -1 +0,0 @@
-allow-private-error = false
diff --git a/tests/ui-toml/error_impl_error/error_impl_error.allow_private.stderr b/tests/ui-toml/error_impl_error/error_impl_error.allow_private.stderr
deleted file mode 100644
index 520c3e0a3e6..00000000000
--- a/tests/ui-toml/error_impl_error/error_impl_error.allow_private.stderr
+++ /dev/null
@@ -1,33 +0,0 @@
-error: type named `Error` that implements `Error`
-  --> $DIR/error_impl_error.rs:10:16
-   |
-LL |     pub struct Error;
-   |                ^^^^^
-   |
-note: `Error` was implemented here
-  --> $DIR/error_impl_error.rs:18:5
-   |
-LL |     impl std::error::Error for Error {}
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   = note: `-D clippy::error-impl-error` implied by `-D warnings`
-
-error: type named `Error` that implements `Error`
-  --> $DIR/error_impl_error.rs:35:15
-   |
-LL |     pub union Error {
-   |               ^^^^^
-   |
-note: `Error` was implemented here
-  --> $DIR/error_impl_error.rs:52:5
-   |
-LL |     impl std::error::Error for Error {}
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: type alias named `Error` that implements `Error`
-  --> $DIR/error_impl_error.rs:56:14
-   |
-LL |     pub type Error = std::fmt::Error;
-   |              ^^^^^
-
-error: aborting due to 3 previous errors
-
diff --git a/tests/ui-toml/error_impl_error/error_impl_error.disallow_private.stderr b/tests/ui-toml/error_impl_error/error_impl_error.disallow_private.stderr
deleted file mode 100644
index d29c5ef374f..00000000000
--- a/tests/ui-toml/error_impl_error/error_impl_error.disallow_private.stderr
+++ /dev/null
@@ -1,45 +0,0 @@
-error: type named `Error` that implements `Error`
-  --> $DIR/error_impl_error.rs:10:16
-   |
-LL |     pub struct Error;
-   |                ^^^^^
-   |
-note: `Error` was implemented here
-  --> $DIR/error_impl_error.rs:18:5
-   |
-LL |     impl std::error::Error for Error {}
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   = note: `-D clippy::error-impl-error` implied by `-D warnings`
-
-error: type named `Error` that implements `Error`
-  --> $DIR/error_impl_error.rs:23:10
-   |
-LL |     enum Error {}
-   |          ^^^^^
-   |
-note: `Error` was implemented here
-  --> $DIR/error_impl_error.rs:31:5
-   |
-LL |     impl std::error::Error for Error {}
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: type named `Error` that implements `Error`
-  --> $DIR/error_impl_error.rs:35:15
-   |
-LL |     pub union Error {
-   |               ^^^^^
-   |
-note: `Error` was implemented here
-  --> $DIR/error_impl_error.rs:52:5
-   |
-LL |     impl std::error::Error for Error {}
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: type alias named `Error` that implements `Error`
-  --> $DIR/error_impl_error.rs:56:14
-   |
-LL |     pub type Error = std::fmt::Error;
-   |              ^^^^^
-
-error: aborting due to 4 previous errors
-
diff --git a/tests/ui-toml/error_impl_error/error_impl_error.rs b/tests/ui-toml/error_impl_error/error_impl_error.rs
deleted file mode 100644
index 3f14b777ee8..00000000000
--- a/tests/ui-toml/error_impl_error/error_impl_error.rs
+++ /dev/null
@@ -1,74 +0,0 @@
-//@revisions: allow_private disallow_private
-//@[allow_private] rustc-env:CLIPPY_CONF_DIR=tests/ui-toml/error_impl_error/allow_private
-//@[disallow_private] rustc-env:CLIPPY_CONF_DIR=tests/ui-toml/error_impl_error/disallow_private
-#![allow(unused)]
-#![warn(clippy::error_impl_error)]
-#![no_main]
-
-pub mod a {
-    #[derive(Debug)]
-    pub struct Error;
-
-    impl std::fmt::Display for Error {
-        fn fmt(&self, _: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-            todo!()
-        }
-    }
-
-    impl std::error::Error for Error {}
-}
-
-mod b {
-    #[derive(Debug)]
-    enum Error {}
-
-    impl std::fmt::Display for Error {
-        fn fmt(&self, _: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-            todo!()
-        }
-    }
-
-    impl std::error::Error for Error {}
-}
-
-pub mod c {
-    pub union Error {
-        a: u32,
-        b: u32,
-    }
-
-    impl std::fmt::Debug for Error {
-        fn fmt(&self, _: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-            todo!()
-        }
-    }
-
-    impl std::fmt::Display for Error {
-        fn fmt(&self, _: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-            todo!()
-        }
-    }
-
-    impl std::error::Error for Error {}
-}
-
-pub mod d {
-    pub type Error = std::fmt::Error;
-}
-
-mod e {
-    #[derive(Debug)]
-    struct MyError;
-
-    impl std::fmt::Display for MyError {
-        fn fmt(&self, _: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-            todo!()
-        }
-    }
-
-    impl std::error::Error for MyError {}
-}
-
-mod f {
-    type MyError = std::fmt::Error;
-}
diff --git a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
index 227424f948c..6ba26e97730 100644
--- a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
+++ b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
@@ -6,7 +6,6 @@ error: error reading Clippy's configuration file: unknown field `foobar`, expect
            allow-mixed-uninlined-format-args
            allow-one-hash-in-raw-strings
            allow-print-in-tests
-           allow-private-error
            allow-private-module-inception
            allow-unwrap-in-tests
            allowed-idents-below-min-chars
@@ -76,7 +75,6 @@ error: error reading Clippy's configuration file: unknown field `barfoo`, expect
            allow-mixed-uninlined-format-args
            allow-one-hash-in-raw-strings
            allow-print-in-tests
-           allow-private-error
            allow-private-module-inception
            allow-unwrap-in-tests
            allowed-idents-below-min-chars
diff --git a/tests/ui/error_impl_error.rs b/tests/ui/error_impl_error.rs
new file mode 100644
index 00000000000..40ce4181bf3
--- /dev/null
+++ b/tests/ui/error_impl_error.rs
@@ -0,0 +1,90 @@
+#![allow(unused)]
+#![warn(clippy::error_impl_error)]
+#![no_main]
+
+pub mod a {
+    #[derive(Debug)]
+    pub struct Error;
+
+    impl std::fmt::Display for Error {
+        fn fmt(&self, _: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            todo!()
+        }
+    }
+
+    impl std::error::Error for Error {}
+}
+
+mod b {
+    #[derive(Debug)]
+    pub(super) enum Error {}
+
+    impl std::fmt::Display for Error {
+        fn fmt(&self, _: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            todo!()
+        }
+    }
+
+    impl std::error::Error for Error {}
+}
+
+pub mod c {
+    pub union Error {
+        a: u32,
+        b: u32,
+    }
+
+    impl std::fmt::Debug for Error {
+        fn fmt(&self, _: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            todo!()
+        }
+    }
+
+    impl std::fmt::Display for Error {
+        fn fmt(&self, _: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            todo!()
+        }
+    }
+
+    impl std::error::Error for Error {}
+}
+
+pub mod d {
+    pub type Error = std::fmt::Error;
+}
+
+mod e {
+    #[derive(Debug)]
+    pub(super) struct MyError;
+
+    impl std::fmt::Display for MyError {
+        fn fmt(&self, _: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            todo!()
+        }
+    }
+
+    impl std::error::Error for MyError {}
+}
+
+pub mod f {
+    pub type MyError = std::fmt::Error;
+}
+
+// Do not lint module-private types
+
+mod g {
+    #[derive(Debug)]
+    enum Error {}
+
+    impl std::fmt::Display for Error {
+        fn fmt(&self, _: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            todo!()
+        }
+    }
+
+    impl std::error::Error for Error {}
+}
+
+mod h {
+    type Error = std::fmt::Error;
+}
diff --git a/tests/ui/error_impl_error.stderr b/tests/ui/error_impl_error.stderr
new file mode 100644
index 00000000000..f3e04b64167
--- /dev/null
+++ b/tests/ui/error_impl_error.stderr
@@ -0,0 +1,45 @@
+error: exported type named `Error` that implements `Error`
+  --> $DIR/error_impl_error.rs:7:16
+   |
+LL |     pub struct Error;
+   |                ^^^^^
+   |
+note: `Error` was implemented here
+  --> $DIR/error_impl_error.rs:15:5
+   |
+LL |     impl std::error::Error for Error {}
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   = note: `-D clippy::error-impl-error` implied by `-D warnings`
+
+error: exported type named `Error` that implements `Error`
+  --> $DIR/error_impl_error.rs:20:21
+   |
+LL |     pub(super) enum Error {}
+   |                     ^^^^^
+   |
+note: `Error` was implemented here
+  --> $DIR/error_impl_error.rs:28:5
+   |
+LL |     impl std::error::Error for Error {}
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: exported type named `Error` that implements `Error`
+  --> $DIR/error_impl_error.rs:32:15
+   |
+LL |     pub union Error {
+   |               ^^^^^
+   |
+note: `Error` was implemented here
+  --> $DIR/error_impl_error.rs:49:5
+   |
+LL |     impl std::error::Error for Error {}
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: exported type alias named `Error` that implements `Error`
+  --> $DIR/error_impl_error.rs:53:14
+   |
+LL |     pub type Error = std::fmt::Error;
+   |              ^^^^^
+
+error: aborting due to 4 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 4c79d8ace5bf19d6f839b52138af014da570284f Mon Sep 17 00:00:00 2001
From: Catherine <114838443+Centri3@users.noreply.github.com>
Date: Thu, 29 Jun 2023 04:55:07 -0500
Subject: new lint `iter_skip_zero`

---
 CHANGELOG.md                               |  1 +
 clippy_lints/src/casts/unnecessary_cast.rs |  2 +-
 clippy_lints/src/declared_lints.rs         |  1 +
 clippy_lints/src/methods/iter_skip_zero.rs | 34 +++++++++++++++++++++++
 clippy_lints/src/methods/mod.rs            | 34 ++++++++++++++++++++++-
 tests/ui/iter_skip_zero.fixed              | 25 +++++++++++++++++
 tests/ui/iter_skip_zero.rs                 | 25 +++++++++++++++++
 tests/ui/iter_skip_zero.stderr             | 43 ++++++++++++++++++++++++++++++
 8 files changed, 163 insertions(+), 2 deletions(-)
 create mode 100644 clippy_lints/src/methods/iter_skip_zero.rs
 create mode 100644 tests/ui/iter_skip_zero.fixed
 create mode 100644 tests/ui/iter_skip_zero.rs
 create mode 100644 tests/ui/iter_skip_zero.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index ece1111213c..acc9d8ffbf7 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4939,6 +4939,7 @@ Released 2018-09-13
 [`iter_on_single_items`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_on_single_items
 [`iter_overeager_cloned`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_overeager_cloned
 [`iter_skip_next`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_skip_next
+[`iter_skip_zero`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_skip_zero
 [`iter_with_drain`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_with_drain
 [`iterator_step_by_zero`]: https://rust-lang.github.io/rust-clippy/master/index.html#iterator_step_by_zero
 [`just_underscores_and_digits`]: https://rust-lang.github.io/rust-clippy/master/index.html#just_underscores_and_digits
diff --git a/clippy_lints/src/casts/unnecessary_cast.rs b/clippy_lints/src/casts/unnecessary_cast.rs
index ae56f38d9ad..4b45b0c9eac 100644
--- a/clippy_lints/src/casts/unnecessary_cast.rs
+++ b/clippy_lints/src/casts/unnecessary_cast.rs
@@ -257,7 +257,7 @@ fn is_cast_from_ty_alias<'tcx>(cx: &LateContext<'tcx>, expr: impl Visitable<'tcx
                 // Will this work for more complex types? Probably not!
                 if !snippet
                     .split("->")
-                    .skip(0)
+                    .skip(1)
                     .map(|s| {
                         s.trim() == cast_from.to_string()
                             || s.split("where").any(|ty| ty.trim() == cast_from.to_string())
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 168dc9bf4e1..47995fea9f9 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -360,6 +360,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::methods::ITER_ON_SINGLE_ITEMS_INFO,
     crate::methods::ITER_OVEREAGER_CLONED_INFO,
     crate::methods::ITER_SKIP_NEXT_INFO,
+    crate::methods::ITER_SKIP_ZERO_INFO,
     crate::methods::ITER_WITH_DRAIN_INFO,
     crate::methods::MANUAL_FILTER_MAP_INFO,
     crate::methods::MANUAL_FIND_MAP_INFO,
diff --git a/clippy_lints/src/methods/iter_skip_zero.rs b/clippy_lints/src/methods/iter_skip_zero.rs
new file mode 100644
index 00000000000..6b696b42a69
--- /dev/null
+++ b/clippy_lints/src/methods/iter_skip_zero.rs
@@ -0,0 +1,34 @@
+use clippy_utils::consts::{constant, Constant};
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::{is_from_proc_macro, is_trait_method};
+use rustc_errors::Applicability;
+use rustc_hir::Expr;
+use rustc_lint::LateContext;
+use rustc_span::sym;
+
+use super::ITER_SKIP_ZERO;
+
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, arg_expr: &Expr<'_>) {
+    if !expr.span.from_expansion()
+        && is_trait_method(cx, expr, sym::Iterator)
+        && let Some(arg) = constant(cx, cx.typeck_results(), arg_expr).and_then(|constant| {
+            if let Constant::Int(arg) = constant {
+                Some(arg)
+            } else {
+                None
+            }
+        })
+        && arg == 0
+        && !is_from_proc_macro(cx, expr)
+    {
+        span_lint_and_then(cx, ITER_SKIP_ZERO, arg_expr.span, "usage of `.skip(0)`", |diag| {
+            diag.span_suggestion(
+                arg_expr.span,
+                "if you meant to skip the first element, use",
+                "1",
+                Applicability::MaybeIncorrect,
+            )
+            .note("this call to `skip` does nothing and is useless; remove it");
+        });
+    }
+}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 6efeff92091..be71072acd6 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -45,6 +45,7 @@ mod iter_nth_zero;
 mod iter_on_single_or_empty_collections;
 mod iter_overeager_cloned;
 mod iter_skip_next;
+mod iter_skip_zero;
 mod iter_with_drain;
 mod iterator_step_by_zero;
 mod manual_next_back;
@@ -3443,6 +3444,27 @@ declare_clippy_lint! {
     "`format!`ing every element in a collection, then collecting the strings into a new `String`"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of `.skip(0)` on iterators.
+    ///
+    /// ### Why is this bad?
+    /// This was likely intended to be `.skip(1)` to skip the first element, as `.skip(0)` does
+    /// nothing. If not, the call should be removed.
+    ///
+    /// ### Example
+    /// ```rust
+    /// let v = vec![1, 2, 3];
+    /// let x = v.iter().skip(0).collect::<Vec<_>>();
+    /// let y = v.iter().collect::<Vec<_>>();
+    /// assert_eq!(x, y);
+    /// ```
+    #[clippy::version = "1.72.0"]
+    pub ITER_SKIP_ZERO,
+    correctness,
+    "disallows `.skip(0)`"
+}
+
 pub struct Methods {
     avoid_breaking_exported_api: bool,
     msrv: Msrv,
@@ -3579,6 +3601,7 @@ impl_lint_pass!(Methods => [
     MANUAL_TRY_FOLD,
     FORMAT_COLLECT,
     STRING_LIT_CHARS_ANY,
+    ITER_SKIP_ZERO,
 ]);
 
 /// Extracts a method call name, args, and `Span` of the method name.
@@ -3901,7 +3924,16 @@ impl Methods {
                         unnecessary_join::check(cx, expr, recv, join_arg, span);
                     }
                 },
-                ("last", []) | ("skip", [_]) => {
+                ("skip", [arg]) => {
+                    iter_skip_zero::check(cx, expr, arg);
+
+                    if let Some((name2, recv2, args2, _span2, _)) = method_call(recv) {
+                        if let ("cloned", []) = (name2, args2) {
+                            iter_overeager_cloned::check(cx, expr, recv, recv2, false, false);
+                        }
+                    }
+                }
+                ("last", []) => {
                     if let Some((name2, recv2, args2, _span2, _)) = method_call(recv) {
                         if let ("cloned", []) = (name2, args2) {
                             iter_overeager_cloned::check(cx, expr, recv, recv2, false, false);
diff --git a/tests/ui/iter_skip_zero.fixed b/tests/ui/iter_skip_zero.fixed
new file mode 100644
index 00000000000..1eb0984fe07
--- /dev/null
+++ b/tests/ui/iter_skip_zero.fixed
@@ -0,0 +1,25 @@
+//@run-rustfix
+//@aux-build:proc_macros.rs:proc-macro
+#![allow(clippy::useless_vec, unused)]
+#![warn(clippy::iter_skip_zero)]
+
+#[macro_use]
+extern crate proc_macros;
+
+use std::iter::once;
+
+fn main() {
+    let _ = [1, 2, 3].iter().skip(1);
+    let _ = vec![1, 2, 3].iter().skip(1);
+    let _ = once([1, 2, 3]).skip(1);
+    let _ = vec![1, 2, 3].iter().chain([1, 2, 3].iter().skip(1)).skip(1);
+    // Don't lint
+    let _ = [1, 2, 3].iter().skip(1);
+    let _ = vec![1, 2, 3].iter().skip(1);
+    external! {
+        let _ = [1, 2, 3].iter().skip(0);
+    }
+    with_span! {
+        let _ = [1, 2, 3].iter().skip(0);
+    }
+}
diff --git a/tests/ui/iter_skip_zero.rs b/tests/ui/iter_skip_zero.rs
new file mode 100644
index 00000000000..8c103ab1d5b
--- /dev/null
+++ b/tests/ui/iter_skip_zero.rs
@@ -0,0 +1,25 @@
+//@run-rustfix
+//@aux-build:proc_macros.rs:proc-macro
+#![allow(clippy::useless_vec, unused)]
+#![warn(clippy::iter_skip_zero)]
+
+#[macro_use]
+extern crate proc_macros;
+
+use std::iter::once;
+
+fn main() {
+    let _ = [1, 2, 3].iter().skip(0);
+    let _ = vec![1, 2, 3].iter().skip(0);
+    let _ = once([1, 2, 3]).skip(0);
+    let _ = vec![1, 2, 3].iter().chain([1, 2, 3].iter().skip(0)).skip(0);
+    // Don't lint
+    let _ = [1, 2, 3].iter().skip(1);
+    let _ = vec![1, 2, 3].iter().skip(1);
+    external! {
+        let _ = [1, 2, 3].iter().skip(0);
+    }
+    with_span! {
+        let _ = [1, 2, 3].iter().skip(0);
+    }
+}
diff --git a/tests/ui/iter_skip_zero.stderr b/tests/ui/iter_skip_zero.stderr
new file mode 100644
index 00000000000..80fecd59e6d
--- /dev/null
+++ b/tests/ui/iter_skip_zero.stderr
@@ -0,0 +1,43 @@
+error: usage of `.skip(0)`
+  --> $DIR/iter_skip_zero.rs:12:35
+   |
+LL |     let _ = [1, 2, 3].iter().skip(0);
+   |                                   ^ help: if you meant to skip the first element, use: `1`
+   |
+   = note: this call to `skip` does nothing and is useless; remove it
+   = note: `-D clippy::iter-skip-zero` implied by `-D warnings`
+
+error: usage of `.skip(0)`
+  --> $DIR/iter_skip_zero.rs:13:39
+   |
+LL |     let _ = vec![1, 2, 3].iter().skip(0);
+   |                                       ^ help: if you meant to skip the first element, use: `1`
+   |
+   = note: this call to `skip` does nothing and is useless; remove it
+
+error: usage of `.skip(0)`
+  --> $DIR/iter_skip_zero.rs:14:34
+   |
+LL |     let _ = once([1, 2, 3]).skip(0);
+   |                                  ^ help: if you meant to skip the first element, use: `1`
+   |
+   = note: this call to `skip` does nothing and is useless; remove it
+
+error: usage of `.skip(0)`
+  --> $DIR/iter_skip_zero.rs:15:71
+   |
+LL |     let _ = vec![1, 2, 3].iter().chain([1, 2, 3].iter().skip(0)).skip(0);
+   |                                                                       ^ help: if you meant to skip the first element, use: `1`
+   |
+   = note: this call to `skip` does nothing and is useless; remove it
+
+error: usage of `.skip(0)`
+  --> $DIR/iter_skip_zero.rs:15:62
+   |
+LL |     let _ = vec![1, 2, 3].iter().chain([1, 2, 3].iter().skip(0)).skip(0);
+   |                                                              ^ help: if you meant to skip the first element, use: `1`
+   |
+   = note: this call to `skip` does nothing and is useless; remove it
+
+error: aborting due to 5 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From dcfc6a20dba6333852c5b55741b47c6f9d2c8db4 Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Fri, 16 Jun 2023 22:01:15 -0500
Subject: check for fully qualified paths in `unnecessary_cast`

---
 clippy_lints/src/casts/unnecessary_cast.rs | 11 +++-
 tests/ui/unnecessary_cast.fixed            | 17 ++++++
 tests/ui/unnecessary_cast.rs               | 17 ++++++
 tests/ui/unnecessary_cast.stderr           | 88 +++++++++++++++++-------------
 4 files changed, 93 insertions(+), 40 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/unnecessary_cast.rs b/clippy_lints/src/casts/unnecessary_cast.rs
index 4b45b0c9eac..9130f5df02f 100644
--- a/clippy_lints/src/casts/unnecessary_cast.rs
+++ b/clippy_lints/src/casts/unnecessary_cast.rs
@@ -254,13 +254,20 @@ fn is_cast_from_ty_alias<'tcx>(cx: &LateContext<'tcx>, expr: impl Visitable<'tcx
                 // function's declaration snippet is exactly equal to the `Ty`. That way, we can
                 // see whether it's a type alias.
                 //
-                // Will this work for more complex types? Probably not!
+                // FIXME: This won't work if the type is given an alias through `use`, should we
+                // consider this a type alias as well?
                 if !snippet
                     .split("->")
                     .skip(1)
                     .map(|s| {
                         s.trim() == cast_from.to_string()
-                            || s.split("where").any(|ty| ty.trim() == cast_from.to_string())
+                            || s.trim().contains(&format!("::{cast_from}"))
+                            || s.split("where").any(|ty| {
+                                ty.trim() == cast_from.to_string()
+                                    || ty.trim() == cast_from.to_string()
+                                    // Fully qualified path, or something silly like `::u32`
+                                    || s.trim().contains(&format!("::{cast_from}"))
+                            })
                     })
                     .any(|a| a)
                 {
diff --git a/tests/ui/unnecessary_cast.fixed b/tests/ui/unnecessary_cast.fixed
index 8efd44baf59..2bf02f13414 100644
--- a/tests/ui/unnecessary_cast.fixed
+++ b/tests/ui/unnecessary_cast.fixed
@@ -38,6 +38,16 @@ mod fake_libc {
     }
 }
 
+fn aaa() -> ::std::primitive::u32 {
+    0
+}
+
+use std::primitive::u32 as UnsignedThirtyTwoBitInteger;
+
+fn bbb() -> UnsignedThirtyTwoBitInteger {
+    0
+}
+
 #[rustfmt::skip]
 fn main() {
     // Test cast_unnecessary
@@ -105,6 +115,13 @@ fn main() {
     extern_fake_libc::getpid_SAFE_TRUTH() as i32;
     let pid = unsafe { fake_libc::getpid() };
     pid as i32;
+    aaa();
+    let x = aaa();
+    aaa();
+    // Will not lint currently.
+    bbb() as u32;
+    let x = bbb();
+    bbb() as u32;
 
     let i8_ptr: *const i8 = &1;
     let u8_ptr: *const u8 = &1;
diff --git a/tests/ui/unnecessary_cast.rs b/tests/ui/unnecessary_cast.rs
index c7723ef51f9..25b6b0f9b07 100644
--- a/tests/ui/unnecessary_cast.rs
+++ b/tests/ui/unnecessary_cast.rs
@@ -38,6 +38,16 @@ mod fake_libc {
     }
 }
 
+fn aaa() -> ::std::primitive::u32 {
+    0
+}
+
+use std::primitive::u32 as UnsignedThirtyTwoBitInteger;
+
+fn bbb() -> UnsignedThirtyTwoBitInteger {
+    0
+}
+
 #[rustfmt::skip]
 fn main() {
     // Test cast_unnecessary
@@ -105,6 +115,13 @@ fn main() {
     extern_fake_libc::getpid_SAFE_TRUTH() as i32;
     let pid = unsafe { fake_libc::getpid() };
     pid as i32;
+    aaa() as u32;
+    let x = aaa();
+    aaa() as u32;
+    // Will not lint currently.
+    bbb() as u32;
+    let x = bbb();
+    bbb() as u32;
 
     let i8_ptr: *const i8 = &1;
     let u8_ptr: *const u8 = &1;
diff --git a/tests/ui/unnecessary_cast.stderr b/tests/ui/unnecessary_cast.stderr
index f0443556fb4..19411a01b67 100644
--- a/tests/ui/unnecessary_cast.stderr
+++ b/tests/ui/unnecessary_cast.stderr
@@ -7,226 +7,238 @@ LL |     ptr as *const T
    = note: `-D clippy::unnecessary-cast` implied by `-D warnings`
 
 error: casting integer literal to `i32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:44:5
+  --> $DIR/unnecessary_cast.rs:54:5
    |
 LL |     1i32 as i32;
    |     ^^^^^^^^^^^ help: try: `1_i32`
 
 error: casting float literal to `f32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:45:5
+  --> $DIR/unnecessary_cast.rs:55:5
    |
 LL |     1f32 as f32;
    |     ^^^^^^^^^^^ help: try: `1_f32`
 
 error: casting to the same type is unnecessary (`bool` -> `bool`)
-  --> $DIR/unnecessary_cast.rs:46:5
+  --> $DIR/unnecessary_cast.rs:56:5
    |
 LL |     false as bool;
    |     ^^^^^^^^^^^^^ help: try: `false`
 
 error: casting integer literal to `i32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:49:5
+  --> $DIR/unnecessary_cast.rs:59:5
    |
 LL |     -1_i32 as i32;
    |     ^^^^^^^^^^^^^ help: try: `-1_i32`
 
 error: casting integer literal to `i32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:50:5
+  --> $DIR/unnecessary_cast.rs:60:5
    |
 LL |     - 1_i32 as i32;
    |     ^^^^^^^^^^^^^^ help: try: `- 1_i32`
 
 error: casting float literal to `f32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:51:5
+  --> $DIR/unnecessary_cast.rs:61:5
    |
 LL |     -1f32 as f32;
    |     ^^^^^^^^^^^^ help: try: `-1_f32`
 
 error: casting integer literal to `i32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:52:5
+  --> $DIR/unnecessary_cast.rs:62:5
    |
 LL |     1_i32 as i32;
    |     ^^^^^^^^^^^^ help: try: `1_i32`
 
 error: casting float literal to `f32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:53:5
+  --> $DIR/unnecessary_cast.rs:63:5
    |
 LL |     1_f32 as f32;
    |     ^^^^^^^^^^^^ help: try: `1_f32`
 
 error: casting raw pointers to the same type and constness is unnecessary (`*const u8` -> `*const u8`)
-  --> $DIR/unnecessary_cast.rs:55:22
+  --> $DIR/unnecessary_cast.rs:65:22
    |
 LL |     let _: *mut u8 = [1u8, 2].as_ptr() as *const u8 as *mut u8;
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `[1u8, 2].as_ptr()`
 
 error: casting raw pointers to the same type and constness is unnecessary (`*const u8` -> `*const u8`)
-  --> $DIR/unnecessary_cast.rs:57:5
+  --> $DIR/unnecessary_cast.rs:67:5
    |
 LL |     [1u8, 2].as_ptr() as *const u8;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `[1u8, 2].as_ptr()`
 
 error: casting raw pointers to the same type and constness is unnecessary (`*mut u8` -> `*mut u8`)
-  --> $DIR/unnecessary_cast.rs:59:5
+  --> $DIR/unnecessary_cast.rs:69:5
    |
 LL |     [1u8, 2].as_mut_ptr() as *mut u8;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `[1u8, 2].as_mut_ptr()`
 
 error: casting raw pointers to the same type and constness is unnecessary (`*const u32` -> `*const u32`)
-  --> $DIR/unnecessary_cast.rs:70:5
+  --> $DIR/unnecessary_cast.rs:80:5
    |
 LL |     owo::<u32>([1u32].as_ptr()) as *const u32;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `owo::<u32>([1u32].as_ptr())`
 
 error: casting raw pointers to the same type and constness is unnecessary (`*const u8` -> `*const u8`)
-  --> $DIR/unnecessary_cast.rs:71:5
+  --> $DIR/unnecessary_cast.rs:81:5
    |
 LL |     uwu::<u32, u8>([1u32].as_ptr()) as *const u8;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `uwu::<u32, u8>([1u32].as_ptr())`
 
 error: casting raw pointers to the same type and constness is unnecessary (`*const u32` -> `*const u32`)
-  --> $DIR/unnecessary_cast.rs:73:5
+  --> $DIR/unnecessary_cast.rs:83:5
    |
 LL |     uwu::<u32, u32>([1u32].as_ptr()) as *const u32;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `uwu::<u32, u32>([1u32].as_ptr())`
 
+error: casting to the same type is unnecessary (`u32` -> `u32`)
+  --> $DIR/unnecessary_cast.rs:118:5
+   |
+LL |     aaa() as u32;
+   |     ^^^^^^^^^^^^ help: try: `aaa()`
+
+error: casting to the same type is unnecessary (`u32` -> `u32`)
+  --> $DIR/unnecessary_cast.rs:120:5
+   |
+LL |     aaa() as u32;
+   |     ^^^^^^^^^^^^ help: try: `aaa()`
+
 error: casting integer literal to `f32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:139:9
+  --> $DIR/unnecessary_cast.rs:156:9
    |
 LL |         100 as f32;
    |         ^^^^^^^^^^ help: try: `100_f32`
 
 error: casting integer literal to `f64` is unnecessary
-  --> $DIR/unnecessary_cast.rs:140:9
+  --> $DIR/unnecessary_cast.rs:157:9
    |
 LL |         100 as f64;
    |         ^^^^^^^^^^ help: try: `100_f64`
 
 error: casting integer literal to `f64` is unnecessary
-  --> $DIR/unnecessary_cast.rs:141:9
+  --> $DIR/unnecessary_cast.rs:158:9
    |
 LL |         100_i32 as f64;
    |         ^^^^^^^^^^^^^^ help: try: `100_f64`
 
 error: casting integer literal to `f32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:142:17
+  --> $DIR/unnecessary_cast.rs:159:17
    |
 LL |         let _ = -100 as f32;
    |                 ^^^^^^^^^^^ help: try: `-100_f32`
 
 error: casting integer literal to `f64` is unnecessary
-  --> $DIR/unnecessary_cast.rs:143:17
+  --> $DIR/unnecessary_cast.rs:160:17
    |
 LL |         let _ = -100 as f64;
    |                 ^^^^^^^^^^^ help: try: `-100_f64`
 
 error: casting integer literal to `f64` is unnecessary
-  --> $DIR/unnecessary_cast.rs:144:17
+  --> $DIR/unnecessary_cast.rs:161:17
    |
 LL |         let _ = -100_i32 as f64;
    |                 ^^^^^^^^^^^^^^^ help: try: `-100_f64`
 
 error: casting float literal to `f32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:145:9
+  --> $DIR/unnecessary_cast.rs:162:9
    |
 LL |         100. as f32;
    |         ^^^^^^^^^^^ help: try: `100_f32`
 
 error: casting float literal to `f64` is unnecessary
-  --> $DIR/unnecessary_cast.rs:146:9
+  --> $DIR/unnecessary_cast.rs:163:9
    |
 LL |         100. as f64;
    |         ^^^^^^^^^^^ help: try: `100_f64`
 
 error: casting integer literal to `u32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:158:9
+  --> $DIR/unnecessary_cast.rs:175:9
    |
 LL |         1 as u32;
    |         ^^^^^^^^ help: try: `1_u32`
 
 error: casting integer literal to `i32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:159:9
+  --> $DIR/unnecessary_cast.rs:176:9
    |
 LL |         0x10 as i32;
    |         ^^^^^^^^^^^ help: try: `0x10_i32`
 
 error: casting integer literal to `usize` is unnecessary
-  --> $DIR/unnecessary_cast.rs:160:9
+  --> $DIR/unnecessary_cast.rs:177:9
    |
 LL |         0b10 as usize;
    |         ^^^^^^^^^^^^^ help: try: `0b10_usize`
 
 error: casting integer literal to `u16` is unnecessary
-  --> $DIR/unnecessary_cast.rs:161:9
+  --> $DIR/unnecessary_cast.rs:178:9
    |
 LL |         0o73 as u16;
    |         ^^^^^^^^^^^ help: try: `0o73_u16`
 
 error: casting integer literal to `u32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:162:9
+  --> $DIR/unnecessary_cast.rs:179:9
    |
 LL |         1_000_000_000 as u32;
    |         ^^^^^^^^^^^^^^^^^^^^ help: try: `1_000_000_000_u32`
 
 error: casting float literal to `f64` is unnecessary
-  --> $DIR/unnecessary_cast.rs:164:9
+  --> $DIR/unnecessary_cast.rs:181:9
    |
 LL |         1.0 as f64;
    |         ^^^^^^^^^^ help: try: `1.0_f64`
 
 error: casting float literal to `f32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:165:9
+  --> $DIR/unnecessary_cast.rs:182:9
    |
 LL |         0.5 as f32;
    |         ^^^^^^^^^^ help: try: `0.5_f32`
 
 error: casting integer literal to `i32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:169:17
+  --> $DIR/unnecessary_cast.rs:186:17
    |
 LL |         let _ = -1 as i32;
    |                 ^^^^^^^^^ help: try: `-1_i32`
 
 error: casting float literal to `f32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:170:17
+  --> $DIR/unnecessary_cast.rs:187:17
    |
 LL |         let _ = -1.0 as f32;
    |                 ^^^^^^^^^^^ help: try: `-1.0_f32`
 
 error: casting to the same type is unnecessary (`i32` -> `i32`)
-  --> $DIR/unnecessary_cast.rs:176:18
+  --> $DIR/unnecessary_cast.rs:193:18
    |
 LL |         let _ = &(x as i32);
    |                  ^^^^^^^^^^ help: try: `{ x }`
 
 error: casting integer literal to `i32` is unnecessary
-  --> $DIR/unnecessary_cast.rs:182:22
+  --> $DIR/unnecessary_cast.rs:199:22
    |
 LL |         let _: i32 = -(1) as i32;
    |                      ^^^^^^^^^^^ help: try: `-1_i32`
 
 error: casting integer literal to `i64` is unnecessary
-  --> $DIR/unnecessary_cast.rs:184:22
+  --> $DIR/unnecessary_cast.rs:201:22
    |
 LL |         let _: i64 = -(1) as i64;
    |                      ^^^^^^^^^^^ help: try: `-1_i64`
 
 error: casting float literal to `f64` is unnecessary
-  --> $DIR/unnecessary_cast.rs:191:22
+  --> $DIR/unnecessary_cast.rs:208:22
    |
 LL |         let _: f64 = (-8.0 as f64).exp();
    |                      ^^^^^^^^^^^^^ help: try: `(-8.0_f64)`
 
 error: casting float literal to `f64` is unnecessary
-  --> $DIR/unnecessary_cast.rs:193:23
+  --> $DIR/unnecessary_cast.rs:210:23
    |
 LL |         let _: f64 = -(8.0 as f64).exp(); // should suggest `-8.0_f64.exp()` here not to change code behavior
    |                       ^^^^^^^^^^^^ help: try: `8.0_f64`
 
 error: casting to the same type is unnecessary (`f32` -> `f32`)
-  --> $DIR/unnecessary_cast.rs:201:20
+  --> $DIR/unnecessary_cast.rs:218:20
    |
 LL |         let _num = foo() as f32;
    |                    ^^^^^^^^^^^^ help: try: `foo()`
 
-error: aborting due to 38 previous errors
+error: aborting due to 40 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From f583fd18e4d1ecb7a0c2c838a5ac0a10188f24db Mon Sep 17 00:00:00 2001
From: Samuel Moelius <sam@moeli.us>
Date: Sun, 9 Jul 2023 18:59:25 -0400
Subject: Fix `unwrap_or_else_default` false positive

---
 clippy_lints/src/methods/unwrap_or_else_default.rs |   6 +-
 clippy_utils/src/ty.rs                             |   3 +
 clippy_utils/src/ty/type_certainty/certainty.rs    | 122 ++++++++
 clippy_utils/src/ty/type_certainty/mod.rs          | 315 +++++++++++++++++++++
 tests/ui/unwrap_or_else_default.fixed              |  37 +++
 tests/ui/unwrap_or_else_default.rs                 |  37 +++
 tests/ui/unwrap_or_else_default.stderr             |  50 +++-
 7 files changed, 568 insertions(+), 2 deletions(-)
 create mode 100644 clippy_utils/src/ty/type_certainty/certainty.rs
 create mode 100644 clippy_utils/src/ty/type_certainty/mod.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/unwrap_or_else_default.rs b/clippy_lints/src/methods/unwrap_or_else_default.rs
index 474a33b67e1..cfb1f7bbba8 100644
--- a/clippy_lints/src/methods/unwrap_or_else_default.rs
+++ b/clippy_lints/src/methods/unwrap_or_else_default.rs
@@ -4,7 +4,7 @@ use super::UNWRAP_OR_ELSE_DEFAULT;
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::is_default_equivalent_call;
 use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::ty::{expr_type_is_certain, is_type_diagnostic_item};
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
@@ -17,6 +17,10 @@ pub(super) fn check<'tcx>(
     recv: &'tcx hir::Expr<'_>,
     u_arg: &'tcx hir::Expr<'_>,
 ) {
+    if !expr_type_is_certain(cx, recv) {
+        return;
+    }
+
     // something.unwrap_or_else(Default::default)
     // ^^^^^^^^^- recv          ^^^^^^^^^^^^^^^^- u_arg
     // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^- expr
diff --git a/clippy_utils/src/ty.rs b/clippy_utils/src/ty.rs
index 15a08370b6a..53152ab7e13 100644
--- a/clippy_utils/src/ty.rs
+++ b/clippy_utils/src/ty.rs
@@ -28,6 +28,9 @@ use std::iter;
 
 use crate::{match_def_path, path_res, paths};
 
+mod type_certainty;
+pub use type_certainty::expr_type_is_certain;
+
 /// Checks if the given type implements copy.
 pub fn is_copy<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
     ty.is_copy_modulo_regions(cx.tcx, cx.param_env)
diff --git a/clippy_utils/src/ty/type_certainty/certainty.rs b/clippy_utils/src/ty/type_certainty/certainty.rs
new file mode 100644
index 00000000000..0e69ffa2212
--- /dev/null
+++ b/clippy_utils/src/ty/type_certainty/certainty.rs
@@ -0,0 +1,122 @@
+use rustc_hir::def_id::DefId;
+use std::fmt::Debug;
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Certainty {
+    /// Determining the type requires contextual information.
+    Uncertain,
+
+    /// The type can be determined purely from subexpressions. If the argument is `Some(..)`, the
+    /// specific `DefId` is known. Such arguments are needed to handle path segments whose `res` is
+    /// `Res::Err`.
+    Certain(Option<DefId>),
+
+    /// The heuristic believes that more than one `DefId` applies to a type---this is a bug.
+    Contradiction,
+}
+
+pub trait Meet {
+    fn meet(self, other: Self) -> Self;
+}
+
+pub trait TryJoin: Sized {
+    fn try_join(self, other: Self) -> Option<Self>;
+}
+
+impl Meet for Option<DefId> {
+    fn meet(self, other: Self) -> Self {
+        match (self, other) {
+            (None, _) | (_, None) => None,
+            (Some(lhs), Some(rhs)) => (lhs == rhs).then_some(lhs),
+        }
+    }
+}
+
+impl TryJoin for Option<DefId> {
+    fn try_join(self, other: Self) -> Option<Self> {
+        match (self, other) {
+            (Some(lhs), Some(rhs)) => (lhs == rhs).then_some(Some(lhs)),
+            (Some(def_id), _) | (_, Some(def_id)) => Some(Some(def_id)),
+            (None, None) => Some(None),
+        }
+    }
+}
+
+impl Meet for Certainty {
+    fn meet(self, other: Self) -> Self {
+        match (self, other) {
+            (Certainty::Uncertain, _) | (_, Certainty::Uncertain) => Certainty::Uncertain,
+            (Certainty::Certain(lhs), Certainty::Certain(rhs)) => Certainty::Certain(lhs.meet(rhs)),
+            (Certainty::Certain(inner), _) | (_, Certainty::Certain(inner)) => Certainty::Certain(inner),
+            (Certainty::Contradiction, Certainty::Contradiction) => Certainty::Contradiction,
+        }
+    }
+}
+
+impl Certainty {
+    /// Join two `Certainty`s preserving their `DefId`s (if any). Generally speaking, this method
+    /// should be used only when `self` and `other` refer directly to types. Otherwise,
+    /// `join_clearing_def_ids` should be used.
+    pub fn join(self, other: Self) -> Self {
+        match (self, other) {
+            (Certainty::Contradiction, _) | (_, Certainty::Contradiction) => Certainty::Contradiction,
+
+            (Certainty::Certain(lhs), Certainty::Certain(rhs)) => {
+                if let Some(inner) = lhs.try_join(rhs) {
+                    Certainty::Certain(inner)
+                } else {
+                    debug_assert!(false, "Contradiction with {lhs:?} and {rhs:?}");
+                    Certainty::Contradiction
+                }
+            },
+
+            (Certainty::Certain(inner), _) | (_, Certainty::Certain(inner)) => Certainty::Certain(inner),
+
+            (Certainty::Uncertain, Certainty::Uncertain) => Certainty::Uncertain,
+        }
+    }
+
+    /// Join two `Certainty`s after clearing their `DefId`s. This method should be used when `self`
+    /// or `other` do not necessarily refer to types, e.g., when they are aggregations of other
+    /// `Certainty`s.
+    pub fn join_clearing_def_ids(self, other: Self) -> Self {
+        self.clear_def_id().join(other.clear_def_id())
+    }
+
+    pub fn clear_def_id(self) -> Certainty {
+        if matches!(self, Certainty::Certain(_)) {
+            Certainty::Certain(None)
+        } else {
+            self
+        }
+    }
+
+    pub fn with_def_id(self, def_id: DefId) -> Certainty {
+        if matches!(self, Certainty::Certain(_)) {
+            Certainty::Certain(Some(def_id))
+        } else {
+            self
+        }
+    }
+
+    pub fn to_def_id(self) -> Option<DefId> {
+        match self {
+            Certainty::Certain(inner) => inner,
+            _ => None,
+        }
+    }
+
+    pub fn is_certain(self) -> bool {
+        matches!(self, Self::Certain(_))
+    }
+}
+
+/// Think: `iter.all(/* is certain */)`
+pub fn meet(iter: impl Iterator<Item = Certainty>) -> Certainty {
+    iter.fold(Certainty::Certain(None), Certainty::meet)
+}
+
+/// Think: `iter.any(/* is certain */)`
+pub fn join(iter: impl Iterator<Item = Certainty>) -> Certainty {
+    iter.fold(Certainty::Uncertain, Certainty::join)
+}
diff --git a/clippy_utils/src/ty/type_certainty/mod.rs b/clippy_utils/src/ty/type_certainty/mod.rs
new file mode 100644
index 00000000000..67c4a293a86
--- /dev/null
+++ b/clippy_utils/src/ty/type_certainty/mod.rs
@@ -0,0 +1,315 @@
+//! A heuristic to tell whether an expression's type can be determined purely from its
+//! subexpressions, and the arguments and locals they use. Put another way, `expr_type_is_certain`
+//! tries to tell whether an expression's type can be determined without appeal to the surrounding
+//! context.
+//!
+//! This is, in some sense, a counterpart to `let_unit_value`'s `expr_needs_inferred_result`.
+//! Intuitively, that function determines whether an expression's type is needed for type inference,
+//! whereas `expr_type_is_certain` determines whether type inference is needed for an expression's
+//! type.
+//!
+//! As a heuristic, `expr_type_is_certain` may produce false negatives, but a false positive should
+//! be considered a bug.
+
+use crate::def_path_res;
+use rustc_hir::def::Res;
+use rustc_hir::def_id::DefId;
+use rustc_hir::intravisit::{walk_qpath, walk_ty, Visitor};
+use rustc_hir::{self as hir, Expr, ExprKind, GenericArgs, HirId, Node, PathSegment, QPath, TyKind};
+use rustc_lint::LateContext;
+use rustc_middle::ty::{self, AdtDef, GenericArgKind, Ty};
+use rustc_span::{Span, Symbol};
+
+mod certainty;
+use certainty::{join, meet, Certainty, Meet};
+
+pub fn expr_type_is_certain(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+    expr_type_certainty(cx, expr).is_certain()
+}
+
+fn expr_type_certainty(cx: &LateContext<'_>, expr: &Expr<'_>) -> Certainty {
+    let certainty = match &expr.kind {
+        ExprKind::Unary(_, expr)
+        | ExprKind::Field(expr, _)
+        | ExprKind::Index(expr, _)
+        | ExprKind::AddrOf(_, _, expr) => expr_type_certainty(cx, expr),
+
+        ExprKind::Array(exprs) => join(exprs.iter().map(|expr| expr_type_certainty(cx, expr))),
+
+        ExprKind::Call(callee, args) => {
+            let lhs = expr_type_certainty(cx, callee);
+            let rhs = if type_is_inferrable_from_arguments(cx, expr) {
+                meet(args.iter().map(|arg| expr_type_certainty(cx, arg)))
+            } else {
+                Certainty::Uncertain
+            };
+            lhs.join_clearing_def_ids(rhs)
+        },
+
+        ExprKind::MethodCall(method, receiver, args, _) => {
+            let mut receiver_type_certainty = expr_type_certainty(cx, receiver);
+            // Even if `receiver_type_certainty` is `Certain(Some(..))`, the `Self` type in the method
+            // identified by `type_dependent_def_id(..)` can differ. This can happen as a result of a `deref`,
+            // for example. So update the `DefId` in `receiver_type_certainty` (if any).
+            if let Some(method_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id)
+                && let Some(self_ty_def_id) = adt_def_id(self_ty(cx, method_def_id))
+            {
+                receiver_type_certainty = receiver_type_certainty.with_def_id(self_ty_def_id);
+            };
+            let lhs = path_segment_certainty(cx, receiver_type_certainty, method, false);
+            let rhs = if type_is_inferrable_from_arguments(cx, expr) {
+                meet(
+                    std::iter::once(receiver_type_certainty).chain(args.iter().map(|arg| expr_type_certainty(cx, arg))),
+                )
+            } else {
+                Certainty::Uncertain
+            };
+            lhs.join(rhs)
+        },
+
+        ExprKind::Tup(exprs) => meet(exprs.iter().map(|expr| expr_type_certainty(cx, expr))),
+
+        ExprKind::Binary(_, lhs, rhs) => expr_type_certainty(cx, lhs).meet(expr_type_certainty(cx, rhs)),
+
+        ExprKind::Lit(_) => Certainty::Certain(None),
+
+        ExprKind::Cast(_, ty) => type_certainty(cx, ty),
+
+        ExprKind::If(_, if_expr, Some(else_expr)) => {
+            expr_type_certainty(cx, if_expr).join(expr_type_certainty(cx, else_expr))
+        },
+
+        ExprKind::Path(qpath) => qpath_certainty(cx, qpath, false),
+
+        ExprKind::Struct(qpath, _, _) => qpath_certainty(cx, qpath, true),
+
+        _ => Certainty::Uncertain,
+    };
+
+    let expr_ty = cx.typeck_results().expr_ty(expr);
+    if let Some(def_id) = adt_def_id(expr_ty) {
+        certainty.with_def_id(def_id)
+    } else {
+        certainty
+    }
+}
+
+struct CertaintyVisitor<'cx, 'tcx> {
+    cx: &'cx LateContext<'tcx>,
+    certainty: Certainty,
+}
+
+impl<'cx, 'tcx> CertaintyVisitor<'cx, 'tcx> {
+    fn new(cx: &'cx LateContext<'tcx>) -> Self {
+        Self {
+            cx,
+            certainty: Certainty::Certain(None),
+        }
+    }
+}
+
+impl<'cx, 'tcx> Visitor<'cx> for CertaintyVisitor<'cx, 'tcx> {
+    fn visit_qpath(&mut self, qpath: &'cx QPath<'_>, hir_id: HirId, _: Span) {
+        self.certainty = self.certainty.meet(qpath_certainty(self.cx, qpath, true));
+        if self.certainty != Certainty::Uncertain {
+            walk_qpath(self, qpath, hir_id);
+        }
+    }
+
+    fn visit_ty(&mut self, ty: &'cx hir::Ty<'_>) {
+        if matches!(ty.kind, TyKind::Infer) {
+            self.certainty = Certainty::Uncertain;
+        }
+        if self.certainty != Certainty::Uncertain {
+            walk_ty(self, ty);
+        }
+    }
+}
+
+fn type_certainty(cx: &LateContext<'_>, ty: &hir::Ty<'_>) -> Certainty {
+    // Handle `TyKind::Path` specially so that its `DefId` can be preserved.
+    //
+    // Note that `CertaintyVisitor::new` initializes the visitor's internal certainty to
+    // `Certainty::Certain(None)`. Furthermore, if a `TyKind::Path` is encountered while traversing
+    // `ty`, the result of the call to `qpath_certainty` is combined with the visitor's internal
+    // certainty using `Certainty::meet`. Thus, if the `TyKind::Path` were not treated specially here,
+    // the resulting certainty would be `Certainty::Certain(None)`.
+    if let TyKind::Path(qpath) = &ty.kind {
+        return qpath_certainty(cx, qpath, true);
+    }
+
+    let mut visitor = CertaintyVisitor::new(cx);
+    visitor.visit_ty(ty);
+    visitor.certainty
+}
+
+fn generic_args_certainty(cx: &LateContext<'_>, args: &GenericArgs<'_>) -> Certainty {
+    let mut visitor = CertaintyVisitor::new(cx);
+    visitor.visit_generic_args(args);
+    visitor.certainty
+}
+
+/// Tries to tell whether a `QPath` resolves to something certain, e.g., whether all of its path
+/// segments generic arguments are are instantiated.
+///
+/// `qpath` could refer to either a type or a value. The heuristic never needs the `DefId` of a
+/// value. So `DefId`s are retained only when `resolves_to_type` is true.
+fn qpath_certainty(cx: &LateContext<'_>, qpath: &QPath<'_>, resolves_to_type: bool) -> Certainty {
+    let certainty = match qpath {
+        QPath::Resolved(ty, path) => {
+            let len = path.segments.len();
+            path.segments.iter().enumerate().fold(
+                ty.map_or(Certainty::Uncertain, |ty| type_certainty(cx, ty)),
+                |parent_certainty, (i, path_segment)| {
+                    path_segment_certainty(cx, parent_certainty, path_segment, i != len - 1 || resolves_to_type)
+                },
+            )
+        },
+
+        QPath::TypeRelative(ty, path_segment) => {
+            path_segment_certainty(cx, type_certainty(cx, ty), path_segment, resolves_to_type)
+        },
+
+        QPath::LangItem(lang_item, _, _) => {
+            cx.tcx
+                .lang_items()
+                .get(*lang_item)
+                .map_or(Certainty::Uncertain, |def_id| {
+                    let generics = cx.tcx.generics_of(def_id);
+                    if generics.parent_count == 0 && generics.params.is_empty() {
+                        Certainty::Certain(if resolves_to_type { Some(def_id) } else { None })
+                    } else {
+                        Certainty::Uncertain
+                    }
+                })
+        },
+    };
+    debug_assert!(resolves_to_type || certainty.to_def_id().is_none());
+    certainty
+}
+
+fn path_segment_certainty(
+    cx: &LateContext<'_>,
+    parent_certainty: Certainty,
+    path_segment: &PathSegment<'_>,
+    resolves_to_type: bool,
+) -> Certainty {
+    let certainty = match update_res(cx, parent_certainty, path_segment).unwrap_or(path_segment.res) {
+        // A definition's type is certain if it refers to something without generics (e.g., a crate or module, or
+        // an unparameterized type), or the generics are instantiated with arguments that are certain.
+        //
+        // If the parent is uncertain, then the current path segment must account for the parent's generic arguments.
+        // Consider the following examples, where the current path segment is `None`:
+        // - `Option::None`             // uncertain; parent (i.e., `Option`) is uncertain
+        // - `Option::<Vec<u64>>::None` // certain; parent (i.e., `Option::<..>`) is certain
+        // - `Option::None::<Vec<u64>>` // certain; parent (i.e., `Option`) is uncertain
+        Res::Def(_, def_id) => {
+            // Checking `res_generics_def_id(..)` before calling `generics_of` avoids an ICE.
+            if cx.tcx.res_generics_def_id(path_segment.res).is_some() {
+                let generics = cx.tcx.generics_of(def_id);
+                let lhs = if (parent_certainty.is_certain() || generics.parent_count == 0) && generics.params.is_empty()
+                {
+                    Certainty::Certain(None)
+                } else {
+                    Certainty::Uncertain
+                };
+                let rhs = path_segment
+                    .args
+                    .map_or(Certainty::Uncertain, |args| generic_args_certainty(cx, args));
+                // See the comment preceding `qpath_certainty`. `def_id` could refer to a type or a value.
+                let certainty = lhs.join_clearing_def_ids(rhs);
+                if resolves_to_type {
+                    certainty.with_def_id(def_id)
+                } else {
+                    certainty
+                }
+            } else {
+                Certainty::Certain(None)
+            }
+        },
+
+        Res::PrimTy(_) | Res::SelfTyParam { .. } | Res::SelfTyAlias { .. } | Res::SelfCtor(_) => {
+            Certainty::Certain(None)
+        },
+
+        // `get_parent` because `hir_id` refers to a `Pat`, and we're interested in the node containing the `Pat`.
+        Res::Local(hir_id) => match cx.tcx.hir().get_parent(hir_id) {
+            // An argument's type is always certain.
+            Node::Param(..) => Certainty::Certain(None),
+            // A local's type is certain if its type annotation is certain or it has an initializer whose
+            // type is certain.
+            Node::Local(local) => {
+                let lhs = local.ty.map_or(Certainty::Uncertain, |ty| type_certainty(cx, ty));
+                let rhs = local
+                    .init
+                    .map_or(Certainty::Uncertain, |init| expr_type_certainty(cx, init));
+                let certainty = lhs.join(rhs);
+                if resolves_to_type {
+                    certainty
+                } else {
+                    certainty.clear_def_id()
+                }
+            },
+            _ => Certainty::Uncertain,
+        },
+
+        _ => Certainty::Uncertain,
+    };
+    debug_assert!(resolves_to_type || certainty.to_def_id().is_none());
+    certainty
+}
+
+/// For at least some `QPath::TypeRelative`, the path segment's `res` can be `Res::Err`.
+/// `update_res` tries to fix the resolution when `parent_certainty` is `Certain(Some(..))`.
+fn update_res(cx: &LateContext<'_>, parent_certainty: Certainty, path_segment: &PathSegment<'_>) -> Option<Res> {
+    if path_segment.res == Res::Err && let Some(def_id) = parent_certainty.to_def_id() {
+        let mut def_path = cx.get_def_path(def_id);
+        def_path.push(path_segment.ident.name);
+        let reses = def_path_res(cx, &def_path.iter().map(Symbol::as_str).collect::<Vec<_>>());
+        if let [res] = reses.as_slice() { Some(*res) } else { None }
+    } else {
+        None
+    }
+}
+
+#[allow(clippy::cast_possible_truncation)]
+fn type_is_inferrable_from_arguments(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+    let Some(callee_def_id) = (match expr.kind {
+        ExprKind::Call(callee, _) => {
+            let callee_ty = cx.typeck_results().expr_ty(callee);
+            if let ty::FnDef(callee_def_id, _) = callee_ty.kind() {
+                Some(*callee_def_id)
+            } else {
+                None
+            }
+        },
+        ExprKind::MethodCall(_, _, _, _) => cx.typeck_results().type_dependent_def_id(expr.hir_id),
+        _ => None,
+    }) else {
+        return false;
+    };
+
+    let generics = cx.tcx.generics_of(callee_def_id);
+    let fn_sig = cx.tcx.fn_sig(callee_def_id).skip_binder();
+
+    // Check that all type parameters appear in the functions input types.
+    (0..(generics.parent_count + generics.params.len()) as u32).all(|index| {
+        fn_sig
+            .inputs()
+            .iter()
+            .any(|input_ty| contains_param(*input_ty.skip_binder(), index))
+    })
+}
+
+fn self_ty<'tcx>(cx: &LateContext<'tcx>, method_def_id: DefId) -> Ty<'tcx> {
+    cx.tcx.fn_sig(method_def_id).skip_binder().inputs().skip_binder()[0]
+}
+
+fn adt_def_id(ty: Ty<'_>) -> Option<DefId> {
+    ty.peel_refs().ty_adt_def().map(AdtDef::did)
+}
+
+fn contains_param(ty: Ty<'_>, index: u32) -> bool {
+    ty.walk()
+        .any(|arg| matches!(arg.unpack(), GenericArgKind::Type(ty) if ty.is_param(index)))
+}
diff --git a/tests/ui/unwrap_or_else_default.fixed b/tests/ui/unwrap_or_else_default.fixed
index 08b89a18bbb..e6b6ab359df 100644
--- a/tests/ui/unwrap_or_else_default.fixed
+++ b/tests/ui/unwrap_or_else_default.fixed
@@ -74,4 +74,41 @@ fn unwrap_or_else_default() {
     empty_string.unwrap_or_default();
 }
 
+fn type_certainty(option: Option<Vec<u64>>) {
+    option.unwrap_or_default().push(1);
+
+    let option: std::option::Option<std::vec::Vec<u64>> = None;
+    option.unwrap_or_default().push(1);
+
+    let option: Option<Vec<u64>> = None;
+    option.unwrap_or_default().push(1);
+
+    let option = std::option::Option::<std::vec::Vec<u64>>::None;
+    option.unwrap_or_default().push(1);
+
+    let option = Option::<Vec<u64>>::None;
+    option.unwrap_or_default().push(1);
+
+    let option = std::option::Option::None::<std::vec::Vec<u64>>;
+    option.unwrap_or_default().push(1);
+
+    let option = Option::None::<Vec<u64>>;
+    option.unwrap_or_default().push(1);
+
+    let option = None::<Vec<u64>>;
+    option.unwrap_or_default().push(1);
+
+    // should not be changed: type annotation with infer, unconcretized initializer
+    let option: Option<Vec<_>> = None;
+    option.unwrap_or_else(Vec::new).push(1);
+
+    // should not be changed: no type annotation, unconcretized initializer
+    let option = Option::None;
+    option.unwrap_or_else(Vec::new).push(1);
+
+    // should not be changed: no type annotation, unconcretized initializer
+    let option = None;
+    option.unwrap_or_else(Vec::new).push(1);
+}
+
 fn main() {}
diff --git a/tests/ui/unwrap_or_else_default.rs b/tests/ui/unwrap_or_else_default.rs
index ad2a744908f..38fa2e4595d 100644
--- a/tests/ui/unwrap_or_else_default.rs
+++ b/tests/ui/unwrap_or_else_default.rs
@@ -74,4 +74,41 @@ fn unwrap_or_else_default() {
     empty_string.unwrap_or_else(|| "".to_string());
 }
 
+fn type_certainty(option: Option<Vec<u64>>) {
+    option.unwrap_or_else(Vec::new).push(1);
+
+    let option: std::option::Option<std::vec::Vec<u64>> = None;
+    option.unwrap_or_else(Vec::new).push(1);
+
+    let option: Option<Vec<u64>> = None;
+    option.unwrap_or_else(Vec::new).push(1);
+
+    let option = std::option::Option::<std::vec::Vec<u64>>::None;
+    option.unwrap_or_else(Vec::new).push(1);
+
+    let option = Option::<Vec<u64>>::None;
+    option.unwrap_or_else(Vec::new).push(1);
+
+    let option = std::option::Option::None::<std::vec::Vec<u64>>;
+    option.unwrap_or_else(Vec::new).push(1);
+
+    let option = Option::None::<Vec<u64>>;
+    option.unwrap_or_else(Vec::new).push(1);
+
+    let option = None::<Vec<u64>>;
+    option.unwrap_or_else(Vec::new).push(1);
+
+    // should not be changed: type annotation with infer, unconcretized initializer
+    let option: Option<Vec<_>> = None;
+    option.unwrap_or_else(Vec::new).push(1);
+
+    // should not be changed: no type annotation, unconcretized initializer
+    let option = Option::None;
+    option.unwrap_or_else(Vec::new).push(1);
+
+    // should not be changed: no type annotation, unconcretized initializer
+    let option = None;
+    option.unwrap_or_else(Vec::new).push(1);
+}
+
 fn main() {}
diff --git a/tests/ui/unwrap_or_else_default.stderr b/tests/ui/unwrap_or_else_default.stderr
index d2b9212223f..a6815e8f916 100644
--- a/tests/ui/unwrap_or_else_default.stderr
+++ b/tests/ui/unwrap_or_else_default.stderr
@@ -36,5 +36,53 @@ error: use of `.unwrap_or_else(..)` to construct default value
 LL |     empty_string.unwrap_or_else(|| "".to_string());
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `empty_string.unwrap_or_default()`
 
-error: aborting due to 6 previous errors
+error: use of `.unwrap_or_else(..)` to construct default value
+  --> $DIR/unwrap_or_else_default.rs:78:5
+   |
+LL |     option.unwrap_or_else(Vec::new).push(1);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `option.unwrap_or_default()`
+
+error: use of `.unwrap_or_else(..)` to construct default value
+  --> $DIR/unwrap_or_else_default.rs:81:5
+   |
+LL |     option.unwrap_or_else(Vec::new).push(1);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `option.unwrap_or_default()`
+
+error: use of `.unwrap_or_else(..)` to construct default value
+  --> $DIR/unwrap_or_else_default.rs:84:5
+   |
+LL |     option.unwrap_or_else(Vec::new).push(1);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `option.unwrap_or_default()`
+
+error: use of `.unwrap_or_else(..)` to construct default value
+  --> $DIR/unwrap_or_else_default.rs:87:5
+   |
+LL |     option.unwrap_or_else(Vec::new).push(1);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `option.unwrap_or_default()`
+
+error: use of `.unwrap_or_else(..)` to construct default value
+  --> $DIR/unwrap_or_else_default.rs:90:5
+   |
+LL |     option.unwrap_or_else(Vec::new).push(1);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `option.unwrap_or_default()`
+
+error: use of `.unwrap_or_else(..)` to construct default value
+  --> $DIR/unwrap_or_else_default.rs:93:5
+   |
+LL |     option.unwrap_or_else(Vec::new).push(1);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `option.unwrap_or_default()`
+
+error: use of `.unwrap_or_else(..)` to construct default value
+  --> $DIR/unwrap_or_else_default.rs:96:5
+   |
+LL |     option.unwrap_or_else(Vec::new).push(1);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `option.unwrap_or_default()`
+
+error: use of `.unwrap_or_else(..)` to construct default value
+  --> $DIR/unwrap_or_else_default.rs:99:5
+   |
+LL |     option.unwrap_or_else(Vec::new).push(1);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `option.unwrap_or_default()`
+
+error: aborting due to 14 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From d4f735c3f5386c6b27ca6e5b1d8d0171593dd90d Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Wed, 19 Jul 2023 17:22:06 +0000
Subject: redundant_type_annotations: only pass certain def kinds to type_of

---
 clippy_lints/src/redundant_type_annotations.rs | 11 ++++++----
 tests/ui/redundant_type_annotations.rs         | 20 +++++++++++++++---
 tests/ui/redundant_type_annotations.stderr     | 28 +++++++++++++-------------
 3 files changed, 38 insertions(+), 21 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/redundant_type_annotations.rs b/clippy_lints/src/redundant_type_annotations.rs
index 8e9234bba3c..3e963d79892 100644
--- a/clippy_lints/src/redundant_type_annotations.rs
+++ b/clippy_lints/src/redundant_type_annotations.rs
@@ -1,6 +1,8 @@
 use clippy_utils::diagnostics::span_lint;
+use clippy_utils::is_lint_allowed;
 use rustc_ast::LitKind;
 use rustc_hir as hir;
+use rustc_hir::def::DefKind;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::Ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -45,8 +47,8 @@ fn is_same_type<'tcx>(cx: &LateContext<'tcx>, ty_resolved_path: hir::def::Res, f
         return primty.name() == func_return_type_sym;
     }
 
-    // type annotation is any other non generic type
-    if let hir::def::Res::Def(_, defid) = ty_resolved_path
+    // type annotation is a non generic type
+    if let hir::def::Res::Def(DefKind::Struct | DefKind::Union | DefKind::Enum, defid) = ty_resolved_path
         && let Some(annotation_ty) = cx.tcx.type_of(defid).no_bound_vars()
     {
         return annotation_ty == func_return_type;
@@ -130,8 +132,9 @@ fn extract_primty(ty_kind: &hir::TyKind<'_>) -> Option<hir::PrimTy> {
 
 impl LateLintPass<'_> for RedundantTypeAnnotations {
     fn check_local<'tcx>(&mut self, cx: &LateContext<'tcx>, local: &'tcx rustc_hir::Local<'tcx>) {
-        // type annotation part
-        if !local.span.from_expansion()
+        if !is_lint_allowed(cx, REDUNDANT_TYPE_ANNOTATIONS, local.hir_id)
+            // type annotation part
+            && !local.span.from_expansion()
             && let Some(ty) = &local.ty
 
             // initialization part
diff --git a/tests/ui/redundant_type_annotations.rs b/tests/ui/redundant_type_annotations.rs
index cc507b8d658..09dbd3c9b39 100644
--- a/tests/ui/redundant_type_annotations.rs
+++ b/tests/ui/redundant_type_annotations.rs
@@ -6,8 +6,8 @@ struct Cake<T> {
     _data: T,
 }
 
-fn make_something<T: Default>() -> T {
-    T::default()
+fn make_something<T>() -> T {
+    unimplemented!()
 }
 
 fn make_cake<T: Default>() -> Cake<T> {
@@ -117,7 +117,15 @@ fn test_non_locals() {
     let _closure_arg = |x: u32| x;
 }
 
-fn test_complex_types() {
+trait Trait {
+    type AssocTy;
+}
+
+impl Trait for () {
+    type AssocTy = String;
+}
+
+fn test_complex_types<T>() {
     // Shouldn't be lint, since the literal will be i32 otherwise
     let _u8: u8 = 128;
 
@@ -135,6 +143,10 @@ fn test_complex_types() {
 
     // Shouldn't be lint
     let _array: [u32; 2] = [8, 9];
+
+    let ty_param: T = make_something();
+
+    let assoc_ty: <() as Trait>::AssocTy = String::new();
 }
 
 fn test_functions() {
@@ -173,4 +185,6 @@ fn test_simple_types() {
     let _var: bool = false;
 }
 
+fn issue11190() {}
+
 fn main() {}
diff --git a/tests/ui/redundant_type_annotations.stderr b/tests/ui/redundant_type_annotations.stderr
index e8b2fe5c384..988ebe63722 100644
--- a/tests/ui/redundant_type_annotations.stderr
+++ b/tests/ui/redundant_type_annotations.stderr
@@ -19,85 +19,85 @@ LL |         let v: &Slice = self.return_a_ref_to_struct();
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: redundant type annotation
-  --> $DIR/redundant_type_annotations.rs:143:5
+  --> $DIR/redundant_type_annotations.rs:155:5
    |
 LL |     let _return: String = return_a_string();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: redundant type annotation
-  --> $DIR/redundant_type_annotations.rs:145:5
+  --> $DIR/redundant_type_annotations.rs:157:5
    |
 LL |     let _return: Pie = return_a_struct();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: redundant type annotation
-  --> $DIR/redundant_type_annotations.rs:147:5
+  --> $DIR/redundant_type_annotations.rs:159:5
    |
 LL |     let _return: Pizza = return_an_enum();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: redundant type annotation
-  --> $DIR/redundant_type_annotations.rs:149:5
+  --> $DIR/redundant_type_annotations.rs:161:5
    |
 LL |     let _return: u32 = return_an_int();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: redundant type annotation
-  --> $DIR/redundant_type_annotations.rs:151:5
+  --> $DIR/redundant_type_annotations.rs:163:5
    |
 LL |     let _return: String = String::new();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: redundant type annotation
-  --> $DIR/redundant_type_annotations.rs:153:5
+  --> $DIR/redundant_type_annotations.rs:165:5
    |
 LL |     let new_pie: Pie = Pie::new();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: redundant type annotation
-  --> $DIR/redundant_type_annotations.rs:155:5
+  --> $DIR/redundant_type_annotations.rs:167:5
    |
 LL |     let _return: u32 = new_pie.return_an_int();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: redundant type annotation
-  --> $DIR/redundant_type_annotations.rs:157:5
+  --> $DIR/redundant_type_annotations.rs:169:5
    |
 LL |     let _return: u32 = Pie::associated_return_an_int();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: redundant type annotation
-  --> $DIR/redundant_type_annotations.rs:159:5
+  --> $DIR/redundant_type_annotations.rs:171:5
    |
 LL |     let _return: String = Pie::associated_return_a_string();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: redundant type annotation
-  --> $DIR/redundant_type_annotations.rs:165:5
+  --> $DIR/redundant_type_annotations.rs:177:5
    |
 LL |     let _var: u32 = u32::MAX;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: redundant type annotation
-  --> $DIR/redundant_type_annotations.rs:167:5
+  --> $DIR/redundant_type_annotations.rs:179:5
    |
 LL |     let _var: u32 = 5_u32;
    |     ^^^^^^^^^^^^^^^^^^^^^^
 
 error: redundant type annotation
-  --> $DIR/redundant_type_annotations.rs:169:5
+  --> $DIR/redundant_type_annotations.rs:181:5
    |
 LL |     let _var: &str = "test";
    |     ^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: redundant type annotation
-  --> $DIR/redundant_type_annotations.rs:171:5
+  --> $DIR/redundant_type_annotations.rs:183:5
    |
 LL |     let _var: &[u8] = b"test";
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: redundant type annotation
-  --> $DIR/redundant_type_annotations.rs:173:5
+  --> $DIR/redundant_type_annotations.rs:185:5
    |
 LL |     let _var: bool = false;
    |     ^^^^^^^^^^^^^^^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From 84c411272d4ae8f0269747ce2d1fd7f4a3c2e158 Mon Sep 17 00:00:00 2001
From: Samuel Moelius <sam@moeli.us>
Date: Wed, 19 Jul 2023 20:05:16 -0400
Subject: Merge `unwrap_or_else_default.rs` into `or_fun_call.rs`

---
 clippy_lints/src/methods/mod.rs                    | 33 +++++---
 clippy_lints/src/methods/or_fun_call.rs            | 93 ++++++++++++++++------
 clippy_lints/src/methods/unwrap_or_else_default.rs | 70 ----------------
 tests/ui/or_fun_call.fixed                         | 63 ++++++++++++++-
 tests/ui/or_fun_call.rs                            | 55 +++++++++++++
 tests/ui/or_fun_call.stderr                        | 90 +++++++++++++--------
 tests/ui/unwrap_or_else_default.fixed              | 19 ++++-
 tests/ui/unwrap_or_else_default.rs                 | 19 ++++-
 tests/ui/unwrap_or_else_default.stderr             | 92 +++++++++++----------
 9 files changed, 343 insertions(+), 191 deletions(-)
 delete mode 100644 clippy_lints/src/methods/unwrap_or_else_default.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index be71072acd6..ac3055f04ee 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -103,7 +103,6 @@ mod unnecessary_lazy_eval;
 mod unnecessary_literal_unwrap;
 mod unnecessary_sort_by;
 mod unnecessary_to_owned;
-mod unwrap_or_else_default;
 mod unwrap_used;
 mod useless_asref;
 mod utils;
@@ -476,29 +475,40 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of `_.unwrap_or_else(Default::default)` on `Option` and
-    /// `Result` values.
+    /// Checks for usages of the following functions with an argument that constructs a default value
+    /// (e.g., `Default::default` or `String::new`):
+    /// - `unwrap_or`
+    /// - `unwrap_or_else`
+    /// - `or_insert`
+    /// - `or_insert_with`
     ///
     /// ### Why is this bad?
-    /// Readability, these can be written as `_.unwrap_or_default`, which is
-    /// simpler and more concise.
+    /// Readability. Using `unwrap_or_default` in place of `unwrap_or`/`unwrap_or_else`, or `or_default`
+    /// in place of `or_insert`/`or_insert_with`, is simpler and more concise.
+    ///
+    /// ### Known problems
+    /// In some cases, the argument of `unwrap_or`, etc. is needed for type inference. The lint uses a
+    /// heuristic to try to identify such cases. However, the heuristic can produce false negatives.
     ///
     /// ### Examples
     /// ```rust
     /// # let x = Some(1);
-    /// x.unwrap_or_else(Default::default);
-    /// x.unwrap_or_else(u32::default);
+    /// # let mut map = std::collections::HashMap::<u64, String>::new();
+    /// x.unwrap_or(Default::default());
+    /// map.entry(42).or_insert_with(String::new);
     /// ```
     ///
     /// Use instead:
     /// ```rust
     /// # let x = Some(1);
+    /// # let mut map = std::collections::HashMap::<u64, String>::new();
     /// x.unwrap_or_default();
+    /// map.entry(42).or_default();
     /// ```
     #[clippy::version = "1.56.0"]
     pub UNWRAP_OR_ELSE_DEFAULT,
     style,
-    "using `.unwrap_or_else(Default::default)`, which is more succinctly expressed as `.unwrap_or_default()`"
+    "using `.unwrap_or`, etc. with an argument that constructs a default value"
 }
 
 declare_clippy_lint! {
@@ -3756,8 +3766,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             then {
                 let first_arg_span = first_arg_ty.span;
                 let first_arg_ty = hir_ty_to_ty(cx.tcx, first_arg_ty);
-                let self_ty = TraitRef::identity(cx.tcx, item.owner_id.to_def_id())
-                    .self_ty();
+                let self_ty = TraitRef::identity(cx.tcx, item.owner_id.to_def_id()).self_ty();
                 wrong_self_convention::check(
                     cx,
                     item.ident.name.as_str(),
@@ -3774,8 +3783,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             if item.ident.name == sym::new;
             if let TraitItemKind::Fn(_, _) = item.kind;
             let ret_ty = return_ty(cx, item.owner_id);
-            let self_ty = TraitRef::identity(cx.tcx, item.owner_id.to_def_id())
-                .self_ty();
+            let self_ty = TraitRef::identity(cx.tcx, item.owner_id.to_def_id()).self_ty();
             if !ret_ty.contains(self_ty);
 
             then {
@@ -4134,7 +4142,6 @@ impl Methods {
                         Some(("map", recv, [map_arg], _, _))
                             if map_unwrap_or::check(cx, expr, recv, map_arg, u_arg, &self.msrv) => {},
                         _ => {
-                            unwrap_or_else_default::check(cx, expr, recv, u_arg);
                             unnecessary_lazy_eval::check(cx, expr, recv, u_arg, "unwrap_or");
                         },
                     }
diff --git a/clippy_lints/src/methods/or_fun_call.rs b/clippy_lints/src/methods/or_fun_call.rs
index 9165c1248f0..1a5a65dbece 100644
--- a/clippy_lints/src/methods/or_fun_call.rs
+++ b/clippy_lints/src/methods/or_fun_call.rs
@@ -1,16 +1,17 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::eager_or_lazy::switch_to_lazy_eval;
 use clippy_utils::source::snippet_with_context;
-use clippy_utils::ty::{implements_trait, is_type_diagnostic_item};
-use clippy_utils::{contains_return, is_trait_item, last_path_segment};
+use clippy_utils::ty::{expr_type_is_certain, implements_trait, is_type_diagnostic_item};
+use clippy_utils::{contains_return, is_default_equivalent, is_default_equivalent_call, last_path_segment};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
-use rustc_hir as hir;
 use rustc_lint::LateContext;
+use rustc_middle::ty;
 use rustc_span::source_map::Span;
-use rustc_span::symbol::{kw, sym, Symbol};
+use rustc_span::symbol::{self, sym, Symbol};
+use {rustc_ast as ast, rustc_hir as hir};
 
-use super::OR_FUN_CALL;
+use super::{OR_FUN_CALL, UNWRAP_OR_ELSE_DEFAULT};
 
 /// Checks for the `OR_FUN_CALL` lint.
 #[allow(clippy::too_many_lines)]
@@ -24,44 +25,64 @@ pub(super) fn check<'tcx>(
 ) {
     /// Checks for `unwrap_or(T::new())`, `unwrap_or(T::default())`,
     /// `or_insert(T::new())` or `or_insert(T::default())`.
+    /// Similarly checks for `unwrap_or_else(T::new)`, `unwrap_or_else(T::default)`,
+    /// `or_insert_with(T::new)` or `or_insert_with(T::default)`.
     #[allow(clippy::too_many_arguments)]
     fn check_unwrap_or_default(
         cx: &LateContext<'_>,
         name: &str,
+        receiver: &hir::Expr<'_>,
         fun: &hir::Expr<'_>,
-        arg: &hir::Expr<'_>,
-        or_has_args: bool,
+        call_expr: Option<&hir::Expr<'_>>,
         span: Span,
         method_span: Span,
     ) -> bool {
-        let is_default_default = || is_trait_item(cx, fun, sym::Default);
+        if !expr_type_is_certain(cx, receiver) {
+            return false;
+        }
+
+        let is_new = |fun: &hir::Expr<'_>| {
+            if let hir::ExprKind::Path(ref qpath) = fun.kind {
+                let path = last_path_segment(qpath).ident.name;
+                matches!(path, sym::new)
+            } else {
+                false
+            }
+        };
 
-        let implements_default = |arg, default_trait_id| {
-            let arg_ty = cx.typeck_results().expr_ty(arg);
-            implements_trait(cx, arg_ty, default_trait_id, &[])
+        let output_type_implements_default = |fun| {
+            let fun_ty = cx.typeck_results().expr_ty(fun);
+            if let ty::FnDef(def_id, substs) = fun_ty.kind() {
+                let output_ty = cx.tcx.fn_sig(def_id).subst(cx.tcx, substs).skip_binder().output();
+                cx.tcx
+                    .get_diagnostic_item(sym::Default)
+                    .map_or(false, |default_trait_id| {
+                        implements_trait(cx, output_ty, default_trait_id, substs)
+                    })
+            } else {
+                false
+            }
         };
 
         if_chain! {
-            if !or_has_args;
-            if let Some(sugg) = match name {
-                "unwrap_or" => Some("unwrap_or_default"),
-                "or_insert" => Some("or_default"),
+            if let Some(sugg) = match (name, call_expr.is_some()) {
+                ("unwrap_or", true) | ("unwrap_or_else", false) => Some("unwrap_or_default"),
+                ("or_insert", true) | ("or_insert_with", false) => Some("or_default"),
                 _ => None,
             };
-            if let hir::ExprKind::Path(ref qpath) = fun.kind;
-            if let Some(default_trait_id) = cx.tcx.get_diagnostic_item(sym::Default);
-            let path = last_path_segment(qpath).ident.name;
             // needs to target Default::default in particular or be *::new and have a Default impl
             // available
-            if (matches!(path, kw::Default) && is_default_default())
-                || (matches!(path, sym::new) && implements_default(arg, default_trait_id));
-
+            if (is_new(fun) && output_type_implements_default(fun))
+                || match call_expr {
+                    Some(call_expr) => is_default_equivalent(cx, call_expr),
+                    None => is_default_equivalent_call(cx, fun) || closure_body_returns_empty_to_string(cx, fun),
+                };
             then {
                 span_lint_and_sugg(
                     cx,
-                    OR_FUN_CALL,
+                    UNWRAP_OR_ELSE_DEFAULT,
                     method_span.with_hi(span.hi()),
-                    &format!("use of `{name}` followed by a call to `{path}`"),
+                    &format!("use of `{name}` to construct default value"),
                     "try",
                     format!("{sugg}()"),
                     Applicability::MachineApplicable,
@@ -168,11 +189,16 @@ pub(super) fn check<'tcx>(
         match inner_arg.kind {
             hir::ExprKind::Call(fun, or_args) => {
                 let or_has_args = !or_args.is_empty();
-                if !check_unwrap_or_default(cx, name, fun, arg, or_has_args, expr.span, method_span) {
+                if or_has_args
+                    || !check_unwrap_or_default(cx, name, receiver, fun, Some(inner_arg), expr.span, method_span)
+                {
                     let fun_span = if or_has_args { None } else { Some(fun.span) };
                     check_general_case(cx, name, method_span, receiver, arg, None, expr.span, fun_span);
                 }
             },
+            hir::ExprKind::Path(..) | hir::ExprKind::Closure(..) => {
+                check_unwrap_or_default(cx, name, receiver, inner_arg, None, expr.span, method_span);
+            },
             hir::ExprKind::Index(..) | hir::ExprKind::MethodCall(..) => {
                 check_general_case(cx, name, method_span, receiver, arg, None, expr.span, None);
             },
@@ -189,3 +215,22 @@ pub(super) fn check<'tcx>(
         }
     }
 }
+
+fn closure_body_returns_empty_to_string(cx: &LateContext<'_>, e: &hir::Expr<'_>) -> bool {
+    if let hir::ExprKind::Closure(&hir::Closure { body, .. }) = e.kind {
+        let body = cx.tcx.hir().body(body);
+
+        if body.params.is_empty()
+            && let hir::Expr{ kind, .. } = &body.value
+            && let hir::ExprKind::MethodCall(hir::PathSegment {ident, ..}, self_arg, _, _) = kind
+            && ident == &symbol::Ident::from_str("to_string")
+            && let hir::Expr{ kind, .. } = self_arg
+            && let hir::ExprKind::Lit(lit) = kind
+            && let ast::LitKind::Str(symbol::kw::Empty, _) = lit.node
+        {
+            return true;
+        }
+    }
+
+    false
+}
diff --git a/clippy_lints/src/methods/unwrap_or_else_default.rs b/clippy_lints/src/methods/unwrap_or_else_default.rs
deleted file mode 100644
index cfb1f7bbba8..00000000000
--- a/clippy_lints/src/methods/unwrap_or_else_default.rs
+++ /dev/null
@@ -1,70 +0,0 @@
-//! Lint for `some_result_or_option.unwrap_or_else(Default::default)`
-
-use super::UNWRAP_OR_ELSE_DEFAULT;
-use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::is_default_equivalent_call;
-use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::ty::{expr_type_is_certain, is_type_diagnostic_item};
-use rustc_ast::ast::LitKind;
-use rustc_errors::Applicability;
-use rustc_hir as hir;
-use rustc_lint::LateContext;
-use rustc_span::{sym, symbol};
-
-pub(super) fn check<'tcx>(
-    cx: &LateContext<'tcx>,
-    expr: &'tcx hir::Expr<'_>,
-    recv: &'tcx hir::Expr<'_>,
-    u_arg: &'tcx hir::Expr<'_>,
-) {
-    if !expr_type_is_certain(cx, recv) {
-        return;
-    }
-
-    // something.unwrap_or_else(Default::default)
-    // ^^^^^^^^^- recv          ^^^^^^^^^^^^^^^^- u_arg
-    // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^- expr
-    let recv_ty = cx.typeck_results().expr_ty(recv);
-    let is_option = is_type_diagnostic_item(cx, recv_ty, sym::Option);
-    let is_result = is_type_diagnostic_item(cx, recv_ty, sym::Result);
-
-    if_chain! {
-        if is_option || is_result;
-        if closure_body_returns_empty_to_string(cx, u_arg) || is_default_equivalent_call(cx, u_arg);
-        then {
-            let mut applicability = Applicability::MachineApplicable;
-
-            span_lint_and_sugg(
-                cx,
-                UNWRAP_OR_ELSE_DEFAULT,
-                expr.span,
-                "use of `.unwrap_or_else(..)` to construct default value",
-                "try",
-                format!(
-                    "{}.unwrap_or_default()",
-                    snippet_with_applicability(cx, recv.span, "..", &mut applicability)
-                ),
-                applicability,
-            );
-        }
-    }
-}
-
-fn closure_body_returns_empty_to_string(cx: &LateContext<'_>, e: &hir::Expr<'_>) -> bool {
-    if let hir::ExprKind::Closure(&hir::Closure { body, .. }) = e.kind {
-        let body = cx.tcx.hir().body(body);
-
-        if body.params.is_empty()
-            && let hir::Expr{ kind, .. } = &body.value
-            && let hir::ExprKind::MethodCall(hir::PathSegment {ident, ..}, self_arg, _, _) = kind
-            && ident == &symbol::Ident::from_str("to_string")
-            && let hir::Expr{ kind, .. } = self_arg
-            && let hir::ExprKind::Lit(lit) = kind
-            && let LitKind::Str(symbol::kw::Empty, _) = lit.node
-        {
-            return true;
-        }
-    }
-
-    false
-}
diff --git a/tests/ui/or_fun_call.fixed b/tests/ui/or_fun_call.fixed
index 6deff0f3240..581f3ad45c7 100644
--- a/tests/ui/or_fun_call.fixed
+++ b/tests/ui/or_fun_call.fixed
@@ -190,7 +190,7 @@ mod issue8239 {
                 acc.push_str(&f);
                 acc
             })
-            .unwrap_or_default();
+            .unwrap_or(String::new());
     }
 
     fn more_to_max_suggestion_highest_lines_1() {
@@ -203,7 +203,7 @@ mod issue8239 {
                 acc.push_str(&f);
                 acc
             })
-            .unwrap_or_default();
+            .unwrap_or(String::new());
     }
 
     fn equal_to_max_suggestion_highest_lines() {
@@ -215,7 +215,7 @@ mod issue8239 {
                 acc.push_str(&f);
                 acc
             })
-            .unwrap_or_default();
+            .unwrap_or(String::new());
     }
 
     fn less_than_max_suggestion_highest_lines() {
@@ -226,7 +226,7 @@ mod issue8239 {
             acc.push_str(&f);
             acc
         })
-        .unwrap_or_default();
+        .unwrap_or(String::new());
     }
 }
 
@@ -257,4 +257,59 @@ mod issue8993 {
     }
 }
 
+mod lazy {
+    use super::*;
+
+    fn foo() {
+        struct Foo;
+
+        impl Foo {
+            fn new() -> Foo {
+                Foo
+            }
+        }
+
+        struct FakeDefault;
+        impl FakeDefault {
+            fn default() -> Self {
+                FakeDefault
+            }
+        }
+
+        impl Default for FakeDefault {
+            fn default() -> Self {
+                FakeDefault
+            }
+        }
+
+        let with_new = Some(vec![1]);
+        with_new.unwrap_or_default();
+
+        let with_default_trait = Some(1);
+        with_default_trait.unwrap_or_default();
+
+        let with_default_type = Some(1);
+        with_default_type.unwrap_or_default();
+
+        let real_default = None::<FakeDefault>;
+        real_default.unwrap_or_default();
+
+        let mut map = HashMap::<u64, String>::new();
+        map.entry(42).or_default();
+
+        let mut btree = BTreeMap::<u64, String>::new();
+        btree.entry(42).or_default();
+
+        let stringy = Some(String::new());
+        let _ = stringy.unwrap_or_default();
+
+        // negative tests
+        let self_default = None::<FakeDefault>;
+        self_default.unwrap_or_else(<FakeDefault>::default);
+
+        let without_default = Some(Foo);
+        without_default.unwrap_or_else(Foo::new);
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/or_fun_call.rs b/tests/ui/or_fun_call.rs
index b05b33e6ee2..1f3987eb891 100644
--- a/tests/ui/or_fun_call.rs
+++ b/tests/ui/or_fun_call.rs
@@ -257,4 +257,59 @@ mod issue8993 {
     }
 }
 
+mod lazy {
+    use super::*;
+
+    fn foo() {
+        struct Foo;
+
+        impl Foo {
+            fn new() -> Foo {
+                Foo
+            }
+        }
+
+        struct FakeDefault;
+        impl FakeDefault {
+            fn default() -> Self {
+                FakeDefault
+            }
+        }
+
+        impl Default for FakeDefault {
+            fn default() -> Self {
+                FakeDefault
+            }
+        }
+
+        let with_new = Some(vec![1]);
+        with_new.unwrap_or_else(Vec::new);
+
+        let with_default_trait = Some(1);
+        with_default_trait.unwrap_or_else(Default::default);
+
+        let with_default_type = Some(1);
+        with_default_type.unwrap_or_else(u64::default);
+
+        let real_default = None::<FakeDefault>;
+        real_default.unwrap_or_else(<FakeDefault as Default>::default);
+
+        let mut map = HashMap::<u64, String>::new();
+        map.entry(42).or_insert_with(String::new);
+
+        let mut btree = BTreeMap::<u64, String>::new();
+        btree.entry(42).or_insert_with(String::new);
+
+        let stringy = Some(String::new());
+        let _ = stringy.unwrap_or_else(String::new);
+
+        // negative tests
+        let self_default = None::<FakeDefault>;
+        self_default.unwrap_or_else(<FakeDefault>::default);
+
+        let without_default = Some(Foo);
+        without_default.unwrap_or_else(Foo::new);
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/or_fun_call.stderr b/tests/ui/or_fun_call.stderr
index 7342b0c2914..13d392461de 100644
--- a/tests/ui/or_fun_call.stderr
+++ b/tests/ui/or_fun_call.stderr
@@ -6,11 +6,13 @@ LL |     with_constructor.unwrap_or(make());
    |
    = note: `-D clippy::or-fun-call` implied by `-D warnings`
 
-error: use of `unwrap_or` followed by a call to `new`
+error: use of `unwrap_or` to construct default value
   --> $DIR/or_fun_call.rs:56:14
    |
 LL |     with_new.unwrap_or(Vec::new());
    |              ^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
+   |
+   = note: `-D clippy::unwrap-or-else-default` implied by `-D warnings`
 
 error: use of `unwrap_or` followed by a function call
   --> $DIR/or_fun_call.rs:59:21
@@ -30,13 +32,13 @@ error: use of `unwrap_or` followed by a function call
 LL |     with_err_args.unwrap_or(Vec::with_capacity(12));
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|_| Vec::with_capacity(12))`
 
-error: use of `unwrap_or` followed by a call to `default`
+error: use of `unwrap_or` to construct default value
   --> $DIR/or_fun_call.rs:68:24
    |
 LL |     with_default_trait.unwrap_or(Default::default());
    |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
-error: use of `unwrap_or` followed by a call to `default`
+error: use of `unwrap_or` to construct default value
   --> $DIR/or_fun_call.rs:71:23
    |
 LL |     with_default_type.unwrap_or(u64::default());
@@ -48,13 +50,13 @@ error: use of `unwrap_or` followed by a function call
 LL |     self_default.unwrap_or(<FakeDefault>::default());
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(<FakeDefault>::default)`
 
-error: use of `unwrap_or` followed by a call to `default`
+error: use of `unwrap_or` to construct default value
   --> $DIR/or_fun_call.rs:77:18
    |
 LL |     real_default.unwrap_or(<FakeDefault as Default>::default());
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
-error: use of `unwrap_or` followed by a call to `new`
+error: use of `unwrap_or` to construct default value
   --> $DIR/or_fun_call.rs:80:14
    |
 LL |     with_vec.unwrap_or(vec![]);
@@ -66,31 +68,31 @@ error: use of `unwrap_or` followed by a function call
 LL |     without_default.unwrap_or(Foo::new());
    |                     ^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(Foo::new)`
 
-error: use of `or_insert` followed by a call to `new`
+error: use of `or_insert` to construct default value
   --> $DIR/or_fun_call.rs:86:19
    |
 LL |     map.entry(42).or_insert(String::new());
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `or_default()`
 
-error: use of `or_insert` followed by a call to `new`
+error: use of `or_insert` to construct default value
   --> $DIR/or_fun_call.rs:89:23
    |
 LL |     map_vec.entry(42).or_insert(vec![]);
    |                       ^^^^^^^^^^^^^^^^^ help: try: `or_default()`
 
-error: use of `or_insert` followed by a call to `new`
+error: use of `or_insert` to construct default value
   --> $DIR/or_fun_call.rs:92:21
    |
 LL |     btree.entry(42).or_insert(String::new());
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `or_default()`
 
-error: use of `or_insert` followed by a call to `new`
+error: use of `or_insert` to construct default value
   --> $DIR/or_fun_call.rs:95:25
    |
 LL |     btree_vec.entry(42).or_insert(vec![]);
    |                         ^^^^^^^^^^^^^^^^^ help: try: `or_default()`
 
-error: use of `unwrap_or` followed by a call to `new`
+error: use of `unwrap_or` to construct default value
   --> $DIR/or_fun_call.rs:98:21
    |
 LL |     let _ = stringy.unwrap_or(String::new());
@@ -132,30 +134,6 @@ error: use of `unwrap_or` followed by a function call
 LL |         None.unwrap_or( unsafe { ptr_to_ref(s) }    );
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| unsafe { ptr_to_ref(s) })`
 
-error: use of `unwrap_or` followed by a call to `new`
-  --> $DIR/or_fun_call.rs:193:14
-   |
-LL |             .unwrap_or(String::new());
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
-
-error: use of `unwrap_or` followed by a call to `new`
-  --> $DIR/or_fun_call.rs:206:14
-   |
-LL |             .unwrap_or(String::new());
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
-
-error: use of `unwrap_or` followed by a call to `new`
-  --> $DIR/or_fun_call.rs:218:14
-   |
-LL |             .unwrap_or(String::new());
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
-
-error: use of `unwrap_or` followed by a call to `new`
-  --> $DIR/or_fun_call.rs:229:10
-   |
-LL |         .unwrap_or(String::new());
-   |          ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
-
 error: use of `map_or` followed by a function call
   --> $DIR/or_fun_call.rs:254:25
    |
@@ -168,5 +146,47 @@ error: use of `map_or` followed by a function call
 LL |         let _ = Some(4).map_or(g(), f);
    |                         ^^^^^^^^^^^^^^ help: try: `map_or_else(g, f)`
 
-error: aborting due to 28 previous errors
+error: use of `unwrap_or_else` to construct default value
+  --> $DIR/or_fun_call.rs:286:18
+   |
+LL |         with_new.unwrap_or_else(Vec::new);
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
+
+error: use of `unwrap_or_else` to construct default value
+  --> $DIR/or_fun_call.rs:289:28
+   |
+LL |         with_default_trait.unwrap_or_else(Default::default);
+   |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
+
+error: use of `unwrap_or_else` to construct default value
+  --> $DIR/or_fun_call.rs:292:27
+   |
+LL |         with_default_type.unwrap_or_else(u64::default);
+   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
+
+error: use of `unwrap_or_else` to construct default value
+  --> $DIR/or_fun_call.rs:295:22
+   |
+LL |         real_default.unwrap_or_else(<FakeDefault as Default>::default);
+   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
+
+error: use of `or_insert_with` to construct default value
+  --> $DIR/or_fun_call.rs:298:23
+   |
+LL |         map.entry(42).or_insert_with(String::new);
+   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `or_default()`
+
+error: use of `or_insert_with` to construct default value
+  --> $DIR/or_fun_call.rs:301:25
+   |
+LL |         btree.entry(42).or_insert_with(String::new);
+   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `or_default()`
+
+error: use of `unwrap_or_else` to construct default value
+  --> $DIR/or_fun_call.rs:304:25
+   |
+LL |         let _ = stringy.unwrap_or_else(String::new);
+   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
+
+error: aborting due to 31 previous errors
 
diff --git a/tests/ui/unwrap_or_else_default.fixed b/tests/ui/unwrap_or_else_default.fixed
index e6b6ab359df..8c038c3647d 100644
--- a/tests/ui/unwrap_or_else_default.fixed
+++ b/tests/ui/unwrap_or_else_default.fixed
@@ -4,7 +4,7 @@
 #![allow(dead_code)]
 #![allow(clippy::unnecessary_wraps, clippy::unnecessary_literal_unwrap)]
 
-/// Checks implementation of the `UNWRAP_OR_ELSE_DEFAULT` lint.
+/// Checks implementation of the `UNWRAP_OR_DEFAULT` lint.
 fn unwrap_or_else_default() {
     struct Foo;
 
@@ -111,4 +111,21 @@ fn type_certainty(option: Option<Vec<u64>>) {
     option.unwrap_or_else(Vec::new).push(1);
 }
 
+fn method_call_with_deref() {
+    use std::cell::RefCell;
+    use std::collections::HashMap;
+
+    let cell = RefCell::new(HashMap::<u64, HashMap<u64, String>>::new());
+
+    let mut outer_map = cell.borrow_mut();
+
+    #[allow(unused_assignments)]
+    let mut option = None;
+    option = Some(0);
+
+    let inner_map = outer_map.get_mut(&option.unwrap()).unwrap();
+
+    let _ = inner_map.entry(0).or_default();
+}
+
 fn main() {}
diff --git a/tests/ui/unwrap_or_else_default.rs b/tests/ui/unwrap_or_else_default.rs
index 38fa2e4595d..47aadb68548 100644
--- a/tests/ui/unwrap_or_else_default.rs
+++ b/tests/ui/unwrap_or_else_default.rs
@@ -4,7 +4,7 @@
 #![allow(dead_code)]
 #![allow(clippy::unnecessary_wraps, clippy::unnecessary_literal_unwrap)]
 
-/// Checks implementation of the `UNWRAP_OR_ELSE_DEFAULT` lint.
+/// Checks implementation of the `UNWRAP_OR_DEFAULT` lint.
 fn unwrap_or_else_default() {
     struct Foo;
 
@@ -111,4 +111,21 @@ fn type_certainty(option: Option<Vec<u64>>) {
     option.unwrap_or_else(Vec::new).push(1);
 }
 
+fn method_call_with_deref() {
+    use std::cell::RefCell;
+    use std::collections::HashMap;
+
+    let cell = RefCell::new(HashMap::<u64, HashMap<u64, String>>::new());
+
+    let mut outer_map = cell.borrow_mut();
+
+    #[allow(unused_assignments)]
+    let mut option = None;
+    option = Some(0);
+
+    let inner_map = outer_map.get_mut(&option.unwrap()).unwrap();
+
+    let _ = inner_map.entry(0).or_insert_with(Default::default);
+}
+
 fn main() {}
diff --git a/tests/ui/unwrap_or_else_default.stderr b/tests/ui/unwrap_or_else_default.stderr
index a6815e8f916..5486d82e8fa 100644
--- a/tests/ui/unwrap_or_else_default.stderr
+++ b/tests/ui/unwrap_or_else_default.stderr
@@ -1,88 +1,94 @@
-error: use of `.unwrap_or_else(..)` to construct default value
-  --> $DIR/unwrap_or_else_default.rs:48:5
+error: use of `unwrap_or_else` to construct default value
+  --> $DIR/unwrap_or_else_default.rs:48:14
    |
 LL |     with_new.unwrap_or_else(Vec::new);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `with_new.unwrap_or_default()`
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
    |
    = note: `-D clippy::unwrap-or-else-default` implied by `-D warnings`
 
-error: use of `.unwrap_or_else(..)` to construct default value
-  --> $DIR/unwrap_or_else_default.rs:62:5
+error: use of `unwrap_or_else` to construct default value
+  --> $DIR/unwrap_or_else_default.rs:62:23
    |
 LL |     with_real_default.unwrap_or_else(<HasDefaultAndDuplicate as Default>::default);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `with_real_default.unwrap_or_default()`
+   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
-error: use of `.unwrap_or_else(..)` to construct default value
-  --> $DIR/unwrap_or_else_default.rs:65:5
+error: use of `unwrap_or_else` to construct default value
+  --> $DIR/unwrap_or_else_default.rs:65:24
    |
 LL |     with_default_trait.unwrap_or_else(Default::default);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `with_default_trait.unwrap_or_default()`
+   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
-error: use of `.unwrap_or_else(..)` to construct default value
-  --> $DIR/unwrap_or_else_default.rs:68:5
+error: use of `unwrap_or_else` to construct default value
+  --> $DIR/unwrap_or_else_default.rs:68:23
    |
 LL |     with_default_type.unwrap_or_else(u64::default);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `with_default_type.unwrap_or_default()`
+   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
-error: use of `.unwrap_or_else(..)` to construct default value
-  --> $DIR/unwrap_or_else_default.rs:71:5
+error: use of `unwrap_or_else` to construct default value
+  --> $DIR/unwrap_or_else_default.rs:71:23
    |
 LL |     with_default_type.unwrap_or_else(Vec::new);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `with_default_type.unwrap_or_default()`
+   |                       ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
-error: use of `.unwrap_or_else(..)` to construct default value
-  --> $DIR/unwrap_or_else_default.rs:74:5
+error: use of `unwrap_or_else` to construct default value
+  --> $DIR/unwrap_or_else_default.rs:74:18
    |
 LL |     empty_string.unwrap_or_else(|| "".to_string());
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `empty_string.unwrap_or_default()`
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
-error: use of `.unwrap_or_else(..)` to construct default value
-  --> $DIR/unwrap_or_else_default.rs:78:5
+error: use of `unwrap_or_else` to construct default value
+  --> $DIR/unwrap_or_else_default.rs:78:12
    |
 LL |     option.unwrap_or_else(Vec::new).push(1);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `option.unwrap_or_default()`
+   |            ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
-error: use of `.unwrap_or_else(..)` to construct default value
-  --> $DIR/unwrap_or_else_default.rs:81:5
+error: use of `unwrap_or_else` to construct default value
+  --> $DIR/unwrap_or_else_default.rs:81:12
    |
 LL |     option.unwrap_or_else(Vec::new).push(1);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `option.unwrap_or_default()`
+   |            ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
-error: use of `.unwrap_or_else(..)` to construct default value
-  --> $DIR/unwrap_or_else_default.rs:84:5
+error: use of `unwrap_or_else` to construct default value
+  --> $DIR/unwrap_or_else_default.rs:84:12
    |
 LL |     option.unwrap_or_else(Vec::new).push(1);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `option.unwrap_or_default()`
+   |            ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
-error: use of `.unwrap_or_else(..)` to construct default value
-  --> $DIR/unwrap_or_else_default.rs:87:5
+error: use of `unwrap_or_else` to construct default value
+  --> $DIR/unwrap_or_else_default.rs:87:12
    |
 LL |     option.unwrap_or_else(Vec::new).push(1);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `option.unwrap_or_default()`
+   |            ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
-error: use of `.unwrap_or_else(..)` to construct default value
-  --> $DIR/unwrap_or_else_default.rs:90:5
+error: use of `unwrap_or_else` to construct default value
+  --> $DIR/unwrap_or_else_default.rs:90:12
    |
 LL |     option.unwrap_or_else(Vec::new).push(1);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `option.unwrap_or_default()`
+   |            ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
-error: use of `.unwrap_or_else(..)` to construct default value
-  --> $DIR/unwrap_or_else_default.rs:93:5
+error: use of `unwrap_or_else` to construct default value
+  --> $DIR/unwrap_or_else_default.rs:93:12
    |
 LL |     option.unwrap_or_else(Vec::new).push(1);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `option.unwrap_or_default()`
+   |            ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
-error: use of `.unwrap_or_else(..)` to construct default value
-  --> $DIR/unwrap_or_else_default.rs:96:5
+error: use of `unwrap_or_else` to construct default value
+  --> $DIR/unwrap_or_else_default.rs:96:12
    |
 LL |     option.unwrap_or_else(Vec::new).push(1);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `option.unwrap_or_default()`
+   |            ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
-error: use of `.unwrap_or_else(..)` to construct default value
-  --> $DIR/unwrap_or_else_default.rs:99:5
+error: use of `unwrap_or_else` to construct default value
+  --> $DIR/unwrap_or_else_default.rs:99:12
    |
 LL |     option.unwrap_or_else(Vec::new).push(1);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `option.unwrap_or_default()`
+   |            ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
-error: aborting due to 14 previous errors
+error: use of `or_insert_with` to construct default value
+  --> $DIR/unwrap_or_else_default.rs:128:32
+   |
+LL |     let _ = inner_map.entry(0).or_insert_with(Default::default);
+   |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `or_default()`
+
+error: aborting due to 15 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From e27977b84776b641ec48482f18c1dac7420a5830 Mon Sep 17 00:00:00 2001
From: Samuel Moelius <sam@moeli.us>
Date: Wed, 19 Jul 2023 20:05:16 -0400
Subject: Rename `unwrap_or_else_default` to `unwrap_or_default`

---
 CHANGELOG.md                            |   1 +
 clippy_lints/src/declared_lints.rs      |   2 +-
 clippy_lints/src/methods/mod.rs         |   4 +-
 clippy_lints/src/methods/or_fun_call.rs |   4 +-
 clippy_lints/src/renamed_lints.rs       |   1 +
 tests/ui/or_fun_call.stderr             |   2 +-
 tests/ui/rename.fixed                   |   2 +
 tests/ui/rename.rs                      |   2 +
 tests/ui/rename.stderr                  | 114 +++++++++++++++++---------------
 tests/ui/unwrap_or_else_default.fixed   |   2 +-
 tests/ui/unwrap_or_else_default.rs      |   2 +-
 tests/ui/unwrap_or_else_default.stderr  |   2 +-
 12 files changed, 75 insertions(+), 63 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index acc9d8ffbf7..c50d28273bf 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5366,6 +5366,7 @@ Released 2018-09-13
 [`unused_unit`]: https://rust-lang.github.io/rust-clippy/master/index.html#unused_unit
 [`unusual_byte_groupings`]: https://rust-lang.github.io/rust-clippy/master/index.html#unusual_byte_groupings
 [`unwrap_in_result`]: https://rust-lang.github.io/rust-clippy/master/index.html#unwrap_in_result
+[`unwrap_or_default`]: https://rust-lang.github.io/rust-clippy/master/index.html#unwrap_or_default
 [`unwrap_or_else_default`]: https://rust-lang.github.io/rust-clippy/master/index.html#unwrap_or_else_default
 [`unwrap_used`]: https://rust-lang.github.io/rust-clippy/master/index.html#unwrap_used
 [`upper_case_acronyms`]: https://rust-lang.github.io/rust-clippy/master/index.html#upper_case_acronyms
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 47995fea9f9..cb5fed5f109 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -422,7 +422,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::methods::UNNECESSARY_LITERAL_UNWRAP_INFO,
     crate::methods::UNNECESSARY_SORT_BY_INFO,
     crate::methods::UNNECESSARY_TO_OWNED_INFO,
-    crate::methods::UNWRAP_OR_ELSE_DEFAULT_INFO,
+    crate::methods::UNWRAP_OR_DEFAULT_INFO,
     crate::methods::UNWRAP_USED_INFO,
     crate::methods::USELESS_ASREF_INFO,
     crate::methods::VEC_RESIZE_TO_ZERO_INFO,
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index ac3055f04ee..1058289679b 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -506,7 +506,7 @@ declare_clippy_lint! {
     /// map.entry(42).or_default();
     /// ```
     #[clippy::version = "1.56.0"]
-    pub UNWRAP_OR_ELSE_DEFAULT,
+    pub UNWRAP_OR_DEFAULT,
     style,
     "using `.unwrap_or`, etc. with an argument that constructs a default value"
 }
@@ -3505,7 +3505,7 @@ impl_lint_pass!(Methods => [
     SHOULD_IMPLEMENT_TRAIT,
     WRONG_SELF_CONVENTION,
     OK_EXPECT,
-    UNWRAP_OR_ELSE_DEFAULT,
+    UNWRAP_OR_DEFAULT,
     MAP_UNWRAP_OR,
     RESULT_MAP_OR_INTO_OPTION,
     OPTION_MAP_OR_NONE,
diff --git a/clippy_lints/src/methods/or_fun_call.rs b/clippy_lints/src/methods/or_fun_call.rs
index 1a5a65dbece..d1899658b84 100644
--- a/clippy_lints/src/methods/or_fun_call.rs
+++ b/clippy_lints/src/methods/or_fun_call.rs
@@ -11,7 +11,7 @@ use rustc_span::source_map::Span;
 use rustc_span::symbol::{self, sym, Symbol};
 use {rustc_ast as ast, rustc_hir as hir};
 
-use super::{OR_FUN_CALL, UNWRAP_OR_ELSE_DEFAULT};
+use super::{OR_FUN_CALL, UNWRAP_OR_DEFAULT};
 
 /// Checks for the `OR_FUN_CALL` lint.
 #[allow(clippy::too_many_lines)]
@@ -80,7 +80,7 @@ pub(super) fn check<'tcx>(
             then {
                 span_lint_and_sugg(
                     cx,
-                    UNWRAP_OR_ELSE_DEFAULT,
+                    UNWRAP_OR_DEFAULT,
                     method_span.with_hi(span.hi()),
                     &format!("use of `{name}` to construct default value"),
                     "try",
diff --git a/clippy_lints/src/renamed_lints.rs b/clippy_lints/src/renamed_lints.rs
index d24215c2292..13086f996ee 100644
--- a/clippy_lints/src/renamed_lints.rs
+++ b/clippy_lints/src/renamed_lints.rs
@@ -30,6 +30,7 @@ pub static RENAMED_LINTS: &[(&str, &str)] = &[
     ("clippy::single_char_push_str", "clippy::single_char_add_str"),
     ("clippy::stutter", "clippy::module_name_repetitions"),
     ("clippy::to_string_in_display", "clippy::recursive_format_impl"),
+    ("clippy::unwrap_or_else_default", "clippy::unwrap_or_default"),
     ("clippy::zero_width_space", "clippy::invisible_characters"),
     ("clippy::cast_ref_to_mut", "cast_ref_to_mut"),
     ("clippy::clone_double_ref", "suspicious_double_ref_op"),
diff --git a/tests/ui/or_fun_call.stderr b/tests/ui/or_fun_call.stderr
index 13d392461de..519f0916562 100644
--- a/tests/ui/or_fun_call.stderr
+++ b/tests/ui/or_fun_call.stderr
@@ -12,7 +12,7 @@ error: use of `unwrap_or` to construct default value
 LL |     with_new.unwrap_or(Vec::new());
    |              ^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
    |
-   = note: `-D clippy::unwrap-or-else-default` implied by `-D warnings`
+   = note: `-D clippy::unwrap-or-default` implied by `-D warnings`
 
 error: use of `unwrap_or` followed by a function call
   --> $DIR/or_fun_call.rs:59:21
diff --git a/tests/ui/rename.fixed b/tests/ui/rename.fixed
index cab02bb93c9..6936d526aeb 100644
--- a/tests/ui/rename.fixed
+++ b/tests/ui/rename.fixed
@@ -27,6 +27,7 @@
 #![allow(clippy::single_char_add_str)]
 #![allow(clippy::module_name_repetitions)]
 #![allow(clippy::recursive_format_impl)]
+#![allow(clippy::unwrap_or_default)]
 #![allow(clippy::invisible_characters)]
 #![allow(cast_ref_to_mut)]
 #![allow(suspicious_double_ref_op)]
@@ -78,6 +79,7 @@
 #![warn(clippy::single_char_add_str)]
 #![warn(clippy::module_name_repetitions)]
 #![warn(clippy::recursive_format_impl)]
+#![warn(clippy::unwrap_or_default)]
 #![warn(clippy::invisible_characters)]
 #![warn(cast_ref_to_mut)]
 #![warn(suspicious_double_ref_op)]
diff --git a/tests/ui/rename.rs b/tests/ui/rename.rs
index e5e31452149..626e5202025 100644
--- a/tests/ui/rename.rs
+++ b/tests/ui/rename.rs
@@ -27,6 +27,7 @@
 #![allow(clippy::single_char_add_str)]
 #![allow(clippy::module_name_repetitions)]
 #![allow(clippy::recursive_format_impl)]
+#![allow(clippy::unwrap_or_default)]
 #![allow(clippy::invisible_characters)]
 #![allow(cast_ref_to_mut)]
 #![allow(suspicious_double_ref_op)]
@@ -78,6 +79,7 @@
 #![warn(clippy::single_char_push_str)]
 #![warn(clippy::stutter)]
 #![warn(clippy::to_string_in_display)]
+#![warn(clippy::unwrap_or_else_default)]
 #![warn(clippy::zero_width_space)]
 #![warn(clippy::cast_ref_to_mut)]
 #![warn(clippy::clone_double_ref)]
diff --git a/tests/ui/rename.stderr b/tests/ui/rename.stderr
index 783608a0841..a0e0a66892e 100644
--- a/tests/ui/rename.stderr
+++ b/tests/ui/rename.stderr
@@ -1,5 +1,5 @@
 error: lint `clippy::almost_complete_letter_range` has been renamed to `clippy::almost_complete_range`
-  --> $DIR/rename.rs:53:9
+  --> $DIR/rename.rs:54:9
    |
 LL | #![warn(clippy::almost_complete_letter_range)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::almost_complete_range`
@@ -7,316 +7,322 @@ LL | #![warn(clippy::almost_complete_letter_range)]
    = note: `-D renamed-and-removed-lints` implied by `-D warnings`
 
 error: lint `clippy::blacklisted_name` has been renamed to `clippy::disallowed_names`
-  --> $DIR/rename.rs:54:9
+  --> $DIR/rename.rs:55:9
    |
 LL | #![warn(clippy::blacklisted_name)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::disallowed_names`
 
 error: lint `clippy::block_in_if_condition_expr` has been renamed to `clippy::blocks_in_if_conditions`
-  --> $DIR/rename.rs:55:9
+  --> $DIR/rename.rs:56:9
    |
 LL | #![warn(clippy::block_in_if_condition_expr)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::blocks_in_if_conditions`
 
 error: lint `clippy::block_in_if_condition_stmt` has been renamed to `clippy::blocks_in_if_conditions`
-  --> $DIR/rename.rs:56:9
+  --> $DIR/rename.rs:57:9
    |
 LL | #![warn(clippy::block_in_if_condition_stmt)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::blocks_in_if_conditions`
 
 error: lint `clippy::box_vec` has been renamed to `clippy::box_collection`
-  --> $DIR/rename.rs:57:9
+  --> $DIR/rename.rs:58:9
    |
 LL | #![warn(clippy::box_vec)]
    |         ^^^^^^^^^^^^^^^ help: use the new name: `clippy::box_collection`
 
 error: lint `clippy::const_static_lifetime` has been renamed to `clippy::redundant_static_lifetimes`
-  --> $DIR/rename.rs:58:9
+  --> $DIR/rename.rs:59:9
    |
 LL | #![warn(clippy::const_static_lifetime)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::redundant_static_lifetimes`
 
 error: lint `clippy::cyclomatic_complexity` has been renamed to `clippy::cognitive_complexity`
-  --> $DIR/rename.rs:59:9
+  --> $DIR/rename.rs:60:9
    |
 LL | #![warn(clippy::cyclomatic_complexity)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::cognitive_complexity`
 
 error: lint `clippy::derive_hash_xor_eq` has been renamed to `clippy::derived_hash_with_manual_eq`
-  --> $DIR/rename.rs:60:9
+  --> $DIR/rename.rs:61:9
    |
 LL | #![warn(clippy::derive_hash_xor_eq)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::derived_hash_with_manual_eq`
 
 error: lint `clippy::disallowed_method` has been renamed to `clippy::disallowed_methods`
-  --> $DIR/rename.rs:61:9
+  --> $DIR/rename.rs:62:9
    |
 LL | #![warn(clippy::disallowed_method)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::disallowed_methods`
 
 error: lint `clippy::disallowed_type` has been renamed to `clippy::disallowed_types`
-  --> $DIR/rename.rs:62:9
+  --> $DIR/rename.rs:63:9
    |
 LL | #![warn(clippy::disallowed_type)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::disallowed_types`
 
 error: lint `clippy::eval_order_dependence` has been renamed to `clippy::mixed_read_write_in_expression`
-  --> $DIR/rename.rs:63:9
+  --> $DIR/rename.rs:64:9
    |
 LL | #![warn(clippy::eval_order_dependence)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::mixed_read_write_in_expression`
 
 error: lint `clippy::identity_conversion` has been renamed to `clippy::useless_conversion`
-  --> $DIR/rename.rs:64:9
+  --> $DIR/rename.rs:65:9
    |
 LL | #![warn(clippy::identity_conversion)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::useless_conversion`
 
 error: lint `clippy::if_let_some_result` has been renamed to `clippy::match_result_ok`
-  --> $DIR/rename.rs:65:9
+  --> $DIR/rename.rs:66:9
    |
 LL | #![warn(clippy::if_let_some_result)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::match_result_ok`
 
 error: lint `clippy::integer_arithmetic` has been renamed to `clippy::arithmetic_side_effects`
-  --> $DIR/rename.rs:66:9
+  --> $DIR/rename.rs:67:9
    |
 LL | #![warn(clippy::integer_arithmetic)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::arithmetic_side_effects`
 
 error: lint `clippy::logic_bug` has been renamed to `clippy::overly_complex_bool_expr`
-  --> $DIR/rename.rs:67:9
+  --> $DIR/rename.rs:68:9
    |
 LL | #![warn(clippy::logic_bug)]
    |         ^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::overly_complex_bool_expr`
 
 error: lint `clippy::new_without_default_derive` has been renamed to `clippy::new_without_default`
-  --> $DIR/rename.rs:68:9
+  --> $DIR/rename.rs:69:9
    |
 LL | #![warn(clippy::new_without_default_derive)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::new_without_default`
 
 error: lint `clippy::option_and_then_some` has been renamed to `clippy::bind_instead_of_map`
-  --> $DIR/rename.rs:69:9
+  --> $DIR/rename.rs:70:9
    |
 LL | #![warn(clippy::option_and_then_some)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::bind_instead_of_map`
 
 error: lint `clippy::option_expect_used` has been renamed to `clippy::expect_used`
-  --> $DIR/rename.rs:70:9
+  --> $DIR/rename.rs:71:9
    |
 LL | #![warn(clippy::option_expect_used)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::expect_used`
 
 error: lint `clippy::option_map_unwrap_or` has been renamed to `clippy::map_unwrap_or`
-  --> $DIR/rename.rs:71:9
+  --> $DIR/rename.rs:72:9
    |
 LL | #![warn(clippy::option_map_unwrap_or)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::map_unwrap_or`
 
 error: lint `clippy::option_map_unwrap_or_else` has been renamed to `clippy::map_unwrap_or`
-  --> $DIR/rename.rs:72:9
+  --> $DIR/rename.rs:73:9
    |
 LL | #![warn(clippy::option_map_unwrap_or_else)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::map_unwrap_or`
 
 error: lint `clippy::option_unwrap_used` has been renamed to `clippy::unwrap_used`
-  --> $DIR/rename.rs:73:9
+  --> $DIR/rename.rs:74:9
    |
 LL | #![warn(clippy::option_unwrap_used)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::unwrap_used`
 
 error: lint `clippy::ref_in_deref` has been renamed to `clippy::needless_borrow`
-  --> $DIR/rename.rs:74:9
+  --> $DIR/rename.rs:75:9
    |
 LL | #![warn(clippy::ref_in_deref)]
    |         ^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::needless_borrow`
 
 error: lint `clippy::result_expect_used` has been renamed to `clippy::expect_used`
-  --> $DIR/rename.rs:75:9
+  --> $DIR/rename.rs:76:9
    |
 LL | #![warn(clippy::result_expect_used)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::expect_used`
 
 error: lint `clippy::result_map_unwrap_or_else` has been renamed to `clippy::map_unwrap_or`
-  --> $DIR/rename.rs:76:9
+  --> $DIR/rename.rs:77:9
    |
 LL | #![warn(clippy::result_map_unwrap_or_else)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::map_unwrap_or`
 
 error: lint `clippy::result_unwrap_used` has been renamed to `clippy::unwrap_used`
-  --> $DIR/rename.rs:77:9
+  --> $DIR/rename.rs:78:9
    |
 LL | #![warn(clippy::result_unwrap_used)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::unwrap_used`
 
 error: lint `clippy::single_char_push_str` has been renamed to `clippy::single_char_add_str`
-  --> $DIR/rename.rs:78:9
+  --> $DIR/rename.rs:79:9
    |
 LL | #![warn(clippy::single_char_push_str)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::single_char_add_str`
 
 error: lint `clippy::stutter` has been renamed to `clippy::module_name_repetitions`
-  --> $DIR/rename.rs:79:9
+  --> $DIR/rename.rs:80:9
    |
 LL | #![warn(clippy::stutter)]
    |         ^^^^^^^^^^^^^^^ help: use the new name: `clippy::module_name_repetitions`
 
 error: lint `clippy::to_string_in_display` has been renamed to `clippy::recursive_format_impl`
-  --> $DIR/rename.rs:80:9
+  --> $DIR/rename.rs:81:9
    |
 LL | #![warn(clippy::to_string_in_display)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::recursive_format_impl`
 
+error: lint `clippy::unwrap_or_else_default` has been renamed to `clippy::unwrap_or_default`
+  --> $DIR/rename.rs:82:9
+   |
+LL | #![warn(clippy::unwrap_or_else_default)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::unwrap_or_default`
+
 error: lint `clippy::zero_width_space` has been renamed to `clippy::invisible_characters`
-  --> $DIR/rename.rs:81:9
+  --> $DIR/rename.rs:83:9
    |
 LL | #![warn(clippy::zero_width_space)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::invisible_characters`
 
 error: lint `clippy::cast_ref_to_mut` has been renamed to `cast_ref_to_mut`
-  --> $DIR/rename.rs:82:9
+  --> $DIR/rename.rs:84:9
    |
 LL | #![warn(clippy::cast_ref_to_mut)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `cast_ref_to_mut`
 
 error: lint `clippy::clone_double_ref` has been renamed to `suspicious_double_ref_op`
-  --> $DIR/rename.rs:83:9
+  --> $DIR/rename.rs:85:9
    |
 LL | #![warn(clippy::clone_double_ref)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `suspicious_double_ref_op`
 
 error: lint `clippy::cmp_nan` has been renamed to `invalid_nan_comparisons`
-  --> $DIR/rename.rs:84:9
+  --> $DIR/rename.rs:86:9
    |
 LL | #![warn(clippy::cmp_nan)]
    |         ^^^^^^^^^^^^^^^ help: use the new name: `invalid_nan_comparisons`
 
 error: lint `clippy::drop_bounds` has been renamed to `drop_bounds`
-  --> $DIR/rename.rs:85:9
+  --> $DIR/rename.rs:87:9
    |
 LL | #![warn(clippy::drop_bounds)]
    |         ^^^^^^^^^^^^^^^^^^^ help: use the new name: `drop_bounds`
 
 error: lint `clippy::drop_copy` has been renamed to `dropping_copy_types`
-  --> $DIR/rename.rs:86:9
+  --> $DIR/rename.rs:88:9
    |
 LL | #![warn(clippy::drop_copy)]
    |         ^^^^^^^^^^^^^^^^^ help: use the new name: `dropping_copy_types`
 
 error: lint `clippy::drop_ref` has been renamed to `dropping_references`
-  --> $DIR/rename.rs:87:9
+  --> $DIR/rename.rs:89:9
    |
 LL | #![warn(clippy::drop_ref)]
    |         ^^^^^^^^^^^^^^^^ help: use the new name: `dropping_references`
 
 error: lint `clippy::for_loop_over_option` has been renamed to `for_loops_over_fallibles`
-  --> $DIR/rename.rs:88:9
+  --> $DIR/rename.rs:90:9
    |
 LL | #![warn(clippy::for_loop_over_option)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `for_loops_over_fallibles`
 
 error: lint `clippy::for_loop_over_result` has been renamed to `for_loops_over_fallibles`
-  --> $DIR/rename.rs:89:9
+  --> $DIR/rename.rs:91:9
    |
 LL | #![warn(clippy::for_loop_over_result)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `for_loops_over_fallibles`
 
 error: lint `clippy::for_loops_over_fallibles` has been renamed to `for_loops_over_fallibles`
-  --> $DIR/rename.rs:90:9
+  --> $DIR/rename.rs:92:9
    |
 LL | #![warn(clippy::for_loops_over_fallibles)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `for_loops_over_fallibles`
 
 error: lint `clippy::forget_copy` has been renamed to `forgetting_copy_types`
-  --> $DIR/rename.rs:91:9
+  --> $DIR/rename.rs:93:9
    |
 LL | #![warn(clippy::forget_copy)]
    |         ^^^^^^^^^^^^^^^^^^^ help: use the new name: `forgetting_copy_types`
 
 error: lint `clippy::forget_ref` has been renamed to `forgetting_references`
-  --> $DIR/rename.rs:92:9
+  --> $DIR/rename.rs:94:9
    |
 LL | #![warn(clippy::forget_ref)]
    |         ^^^^^^^^^^^^^^^^^^ help: use the new name: `forgetting_references`
 
 error: lint `clippy::fn_null_check` has been renamed to `incorrect_fn_null_checks`
-  --> $DIR/rename.rs:93:9
+  --> $DIR/rename.rs:95:9
    |
 LL | #![warn(clippy::fn_null_check)]
    |         ^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `incorrect_fn_null_checks`
 
 error: lint `clippy::into_iter_on_array` has been renamed to `array_into_iter`
-  --> $DIR/rename.rs:94:9
+  --> $DIR/rename.rs:96:9
    |
 LL | #![warn(clippy::into_iter_on_array)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `array_into_iter`
 
 error: lint `clippy::invalid_atomic_ordering` has been renamed to `invalid_atomic_ordering`
-  --> $DIR/rename.rs:95:9
+  --> $DIR/rename.rs:97:9
    |
 LL | #![warn(clippy::invalid_atomic_ordering)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `invalid_atomic_ordering`
 
 error: lint `clippy::invalid_ref` has been renamed to `invalid_value`
-  --> $DIR/rename.rs:96:9
+  --> $DIR/rename.rs:98:9
    |
 LL | #![warn(clippy::invalid_ref)]
    |         ^^^^^^^^^^^^^^^^^^^ help: use the new name: `invalid_value`
 
 error: lint `clippy::invalid_utf8_in_unchecked` has been renamed to `invalid_from_utf8_unchecked`
-  --> $DIR/rename.rs:97:9
+  --> $DIR/rename.rs:99:9
    |
 LL | #![warn(clippy::invalid_utf8_in_unchecked)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `invalid_from_utf8_unchecked`
 
 error: lint `clippy::let_underscore_drop` has been renamed to `let_underscore_drop`
-  --> $DIR/rename.rs:98:9
+  --> $DIR/rename.rs:100:9
    |
 LL | #![warn(clippy::let_underscore_drop)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `let_underscore_drop`
 
 error: lint `clippy::mem_discriminant_non_enum` has been renamed to `enum_intrinsics_non_enums`
-  --> $DIR/rename.rs:99:9
+  --> $DIR/rename.rs:101:9
    |
 LL | #![warn(clippy::mem_discriminant_non_enum)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `enum_intrinsics_non_enums`
 
 error: lint `clippy::panic_params` has been renamed to `non_fmt_panics`
-  --> $DIR/rename.rs:100:9
+  --> $DIR/rename.rs:102:9
    |
 LL | #![warn(clippy::panic_params)]
    |         ^^^^^^^^^^^^^^^^^^^^ help: use the new name: `non_fmt_panics`
 
 error: lint `clippy::positional_named_format_parameters` has been renamed to `named_arguments_used_positionally`
-  --> $DIR/rename.rs:101:9
+  --> $DIR/rename.rs:103:9
    |
 LL | #![warn(clippy::positional_named_format_parameters)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `named_arguments_used_positionally`
 
 error: lint `clippy::temporary_cstring_as_ptr` has been renamed to `temporary_cstring_as_ptr`
-  --> $DIR/rename.rs:102:9
+  --> $DIR/rename.rs:104:9
    |
 LL | #![warn(clippy::temporary_cstring_as_ptr)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `temporary_cstring_as_ptr`
 
 error: lint `clippy::undropped_manually_drops` has been renamed to `undropped_manually_drops`
-  --> $DIR/rename.rs:103:9
+  --> $DIR/rename.rs:105:9
    |
 LL | #![warn(clippy::undropped_manually_drops)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `undropped_manually_drops`
 
 error: lint `clippy::unknown_clippy_lints` has been renamed to `unknown_lints`
-  --> $DIR/rename.rs:104:9
+  --> $DIR/rename.rs:106:9
    |
 LL | #![warn(clippy::unknown_clippy_lints)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `unknown_lints`
 
 error: lint `clippy::unused_label` has been renamed to `unused_labels`
-  --> $DIR/rename.rs:105:9
+  --> $DIR/rename.rs:107:9
    |
 LL | #![warn(clippy::unused_label)]
    |         ^^^^^^^^^^^^^^^^^^^^ help: use the new name: `unused_labels`
 
-error: aborting due to 53 previous errors
+error: aborting due to 54 previous errors
 
diff --git a/tests/ui/unwrap_or_else_default.fixed b/tests/ui/unwrap_or_else_default.fixed
index 8c038c3647d..89a6b1395e5 100644
--- a/tests/ui/unwrap_or_else_default.fixed
+++ b/tests/ui/unwrap_or_else_default.fixed
@@ -1,6 +1,6 @@
 //@run-rustfix
 
-#![warn(clippy::unwrap_or_else_default)]
+#![warn(clippy::unwrap_or_default)]
 #![allow(dead_code)]
 #![allow(clippy::unnecessary_wraps, clippy::unnecessary_literal_unwrap)]
 
diff --git a/tests/ui/unwrap_or_else_default.rs b/tests/ui/unwrap_or_else_default.rs
index 47aadb68548..e5ebf35adda 100644
--- a/tests/ui/unwrap_or_else_default.rs
+++ b/tests/ui/unwrap_or_else_default.rs
@@ -1,6 +1,6 @@
 //@run-rustfix
 
-#![warn(clippy::unwrap_or_else_default)]
+#![warn(clippy::unwrap_or_default)]
 #![allow(dead_code)]
 #![allow(clippy::unnecessary_wraps, clippy::unnecessary_literal_unwrap)]
 
diff --git a/tests/ui/unwrap_or_else_default.stderr b/tests/ui/unwrap_or_else_default.stderr
index 5486d82e8fa..91e48375f18 100644
--- a/tests/ui/unwrap_or_else_default.stderr
+++ b/tests/ui/unwrap_or_else_default.stderr
@@ -4,7 +4,7 @@ error: use of `unwrap_or_else` to construct default value
 LL |     with_new.unwrap_or_else(Vec::new);
    |              ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
    |
-   = note: `-D clippy::unwrap-or-else-default` implied by `-D warnings`
+   = note: `-D clippy::unwrap-or-default` implied by `-D warnings`
 
 error: use of `unwrap_or_else` to construct default value
   --> $DIR/unwrap_or_else_default.rs:62:23
-- 
cgit 1.4.1-3-g733a5


From 15b68c24b8bccbad6b3c9ec2e60a9540573365ce Mon Sep 17 00:00:00 2001
From: Catherine <114838443+Centri3@users.noreply.github.com>
Date: Thu, 29 Jun 2023 04:30:51 -0500
Subject: Extract the logic for if a snippet equals a type

---
 clippy_lints/src/casts/mod.rs              |  8 ++++++++
 clippy_lints/src/casts/unnecessary_cast.rs | 25 ++++++++++---------------
 2 files changed, 18 insertions(+), 15 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index 0ac6ef6496a..d34de305f5d 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -181,6 +181,14 @@ declare_clippy_lint! {
     /// ### Why is this bad?
     /// It's just unnecessary.
     ///
+    /// ### Known problems
+    /// When the expression on the left is a function call, the lint considers the return type to be
+    /// a type alias if it's aliased through a `use` statement
+    /// (like `use std::io::Result as IoResult`). It will not lint such cases.
+    ///
+    /// This check is also rather primitive. It will only work on primitive types without any
+    /// intermediate references, raw pointers and trait objects may or may not work.
+    ///
     /// ### Example
     /// ```rust
     /// let _ = 2i32 as i32;
diff --git a/clippy_lints/src/casts/unnecessary_cast.rs b/clippy_lints/src/casts/unnecessary_cast.rs
index 9130f5df02f..86057bb74ee 100644
--- a/clippy_lints/src/casts/unnecessary_cast.rs
+++ b/clippy_lints/src/casts/unnecessary_cast.rs
@@ -85,11 +85,6 @@ pub(super) fn check<'tcx>(
         }
     }
 
-    // skip cast of fn call that returns type alias
-    if let ExprKind::Cast(inner, ..) = expr.kind && is_cast_from_ty_alias(cx, inner, cast_from) {
-        return false;
-    }
-
     // skip cast to non-primitive type
     if_chain! {
         if let ExprKind::Cast(_, cast_to) = expr.kind;
@@ -101,6 +96,11 @@ pub(super) fn check<'tcx>(
         }
     }
 
+    // skip cast of fn call that returns type alias
+    if let ExprKind::Cast(inner, ..) = expr.kind && is_cast_from_ty_alias(cx, inner, cast_from) {
+        return false;
+    }
+
     if let Some(lit) = get_numeric_literal(cast_expr) {
         let literal_str = &cast_str;
 
@@ -259,16 +259,7 @@ fn is_cast_from_ty_alias<'tcx>(cx: &LateContext<'tcx>, expr: impl Visitable<'tcx
                 if !snippet
                     .split("->")
                     .skip(1)
-                    .map(|s| {
-                        s.trim() == cast_from.to_string()
-                            || s.trim().contains(&format!("::{cast_from}"))
-                            || s.split("where").any(|ty| {
-                                ty.trim() == cast_from.to_string()
-                                    || ty.trim() == cast_from.to_string()
-                                    // Fully qualified path, or something silly like `::u32`
-                                    || s.trim().contains(&format!("::{cast_from}"))
-                            })
-                    })
+                    .map(|s| snippet_eq_ty(s, cast_from) || s.split("where").any(|ty| snippet_eq_ty(ty, cast_from)))
                     .any(|a| a)
                 {
                     return ControlFlow::Break(());
@@ -295,3 +286,7 @@ fn is_cast_from_ty_alias<'tcx>(cx: &LateContext<'tcx>, expr: impl Visitable<'tcx
     })
     .is_some()
 }
+
+fn snippet_eq_ty(snippet: &str, ty: Ty<'_>) -> bool {
+    snippet.trim() == ty.to_string() || snippet.trim().contains(&format!("::{ty}"))
+}
-- 
cgit 1.4.1-3-g733a5


From f0a16bb8a3ae4ef0ac24cac0f87eb5ca07005d3c Mon Sep 17 00:00:00 2001
From: Caio <c410.f3r@gmail.com>
Date: Thu, 20 Jul 2023 09:04:08 -0300
Subject: [significant_drop_tightening] Fix #11189

---
 clippy_lints/src/significant_drop_tightening.rs | 30 +++++++++++++++++--------
 tests/ui/significant_drop_tightening.fixed      | 20 +++++++++++++++++
 tests/ui/significant_drop_tightening.rs         | 20 +++++++++++++++++
 tests/ui/significant_drop_tightening.stderr     |  6 ++---
 4 files changed, 64 insertions(+), 12 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/significant_drop_tightening.rs b/clippy_lints/src/significant_drop_tightening.rs
index 8f8614ab305..5db061d1cef 100644
--- a/clippy_lints/src/significant_drop_tightening.rs
+++ b/clippy_lints/src/significant_drop_tightening.rs
@@ -331,13 +331,13 @@ impl<'ap, 'lc, 'others, 'stmt, 'tcx> Visitor<'tcx> for StmtsChecker<'ap, 'lc, 'o
                             apa.last_method_span = span;
                         }
                     },
-                    hir::StmtKind::Semi(expr) => {
-                        if has_drop(expr, &apa.first_bind_ident, self.cx) {
+                    hir::StmtKind::Semi(semi_expr) => {
+                        if has_drop(semi_expr, &apa.first_bind_ident, self.cx) {
                             apa.has_expensive_expr_after_last_attr = false;
                             apa.last_stmt_span = DUMMY_SP;
                             return;
                         }
-                        if let hir::ExprKind::MethodCall(_, _, _, span) = expr.kind {
+                        if let hir::ExprKind::MethodCall(_, _, _, span) = semi_expr.kind {
                             apa.last_method_span = span;
                         }
                     },
@@ -435,14 +435,26 @@ fn has_drop(expr: &hir::Expr<'_>, first_bind_ident: &Ident, lcx: &LateContext<'_
         && let Res::Def(DefKind::Fn, did) = fun_path.res
         && lcx.tcx.is_diagnostic_item(sym::mem_drop, did)
         && let [first_arg, ..] = args
-        && let hir::ExprKind::Path(hir::QPath::Resolved(_, arg_path)) = &first_arg.kind
-        && let [first_arg_ps, .. ] = arg_path.segments
     {
-        &first_arg_ps.ident == first_bind_ident
-    }
-    else {
-        false
+        let has_ident = |local_expr: &hir::Expr<'_>| {
+            if let hir::ExprKind::Path(hir::QPath::Resolved(_, arg_path)) = &local_expr.kind
+                && let [first_arg_ps, .. ] = arg_path.segments
+                && &first_arg_ps.ident == first_bind_ident
+            {
+                true
+            }
+            else {
+                false
+            }
+        };
+        if has_ident(first_arg) {
+            return true;
+        }
+        if let hir::ExprKind::Tup(value) = &first_arg.kind && value.iter().any(has_ident) {
+            return true;
+        }
     }
+    false
 }
 
 fn is_inexpensive_expr(expr: &hir::Expr<'_>) -> bool {
diff --git a/tests/ui/significant_drop_tightening.fixed b/tests/ui/significant_drop_tightening.fixed
index aa6690b77e1..8065e9e5fbc 100644
--- a/tests/ui/significant_drop_tightening.fixed
+++ b/tests/ui/significant_drop_tightening.fixed
@@ -58,6 +58,26 @@ pub fn issue_11160() -> bool {
     true
 }
 
+pub fn issue_11189() {
+    struct Number {
+        pub value: u32,
+    }
+
+    fn do_something() -> Result<(), ()> {
+        let number = Mutex::new(Number { value: 1 });
+        let number2 = Mutex::new(Number { value: 2 });
+        let number3 = Mutex::new(Number { value: 3 });
+        let mut lock = number.lock().unwrap();
+        let mut lock2 = number2.lock().unwrap();
+        let mut lock3 = number3.lock().unwrap();
+        lock.value += 1;
+        lock2.value += 1;
+        lock3.value += 1;
+        drop((lock, lock2, lock3));
+        Ok(())
+    }
+}
+
 pub fn path_return_can_be_ignored() -> i32 {
     let mutex = Mutex::new(1);
     let lock = mutex.lock().unwrap();
diff --git a/tests/ui/significant_drop_tightening.rs b/tests/ui/significant_drop_tightening.rs
index a0bf657df55..1620b76843a 100644
--- a/tests/ui/significant_drop_tightening.rs
+++ b/tests/ui/significant_drop_tightening.rs
@@ -57,6 +57,26 @@ pub fn issue_11160() -> bool {
     true
 }
 
+pub fn issue_11189() {
+    struct Number {
+        pub value: u32,
+    }
+
+    fn do_something() -> Result<(), ()> {
+        let number = Mutex::new(Number { value: 1 });
+        let number2 = Mutex::new(Number { value: 2 });
+        let number3 = Mutex::new(Number { value: 3 });
+        let mut lock = number.lock().unwrap();
+        let mut lock2 = number2.lock().unwrap();
+        let mut lock3 = number3.lock().unwrap();
+        lock.value += 1;
+        lock2.value += 1;
+        lock3.value += 1;
+        drop((lock, lock2, lock3));
+        Ok(())
+    }
+}
+
 pub fn path_return_can_be_ignored() -> i32 {
     let mutex = Mutex::new(1);
     let lock = mutex.lock().unwrap();
diff --git a/tests/ui/significant_drop_tightening.stderr b/tests/ui/significant_drop_tightening.stderr
index 45ca73af3a8..b5cad88ad3f 100644
--- a/tests/ui/significant_drop_tightening.stderr
+++ b/tests/ui/significant_drop_tightening.stderr
@@ -23,7 +23,7 @@ LL +     drop(lock);
    |
 
 error: temporary with significant `Drop` can be early dropped
-  --> $DIR/significant_drop_tightening.rs:86:13
+  --> $DIR/significant_drop_tightening.rs:106:13
    |
 LL | /     {
 LL | |         let mutex = Mutex::new(1i32);
@@ -43,7 +43,7 @@ LL +         drop(lock);
    |
 
 error: temporary with significant `Drop` can be early dropped
-  --> $DIR/significant_drop_tightening.rs:107:13
+  --> $DIR/significant_drop_tightening.rs:127:13
    |
 LL | /     {
 LL | |         let mutex = Mutex::new(1i32);
@@ -67,7 +67,7 @@ LL +
    |
 
 error: temporary with significant `Drop` can be early dropped
-  --> $DIR/significant_drop_tightening.rs:113:17
+  --> $DIR/significant_drop_tightening.rs:133:17
    |
 LL | /     {
 LL | |         let mutex = Mutex::new(vec![1i32]);
-- 
cgit 1.4.1-3-g733a5


From 541d0c8ab7e84689d2b54419e4b9c2748d83220b Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Thu, 20 Jul 2023 21:39:32 +0200
Subject: [`slow_vector_initialization`]: lint `Vec::new()`

---
 clippy_lints/src/slow_vector_initialization.rs | 96 +++++++++++++++++++-------
 tests/ui/read_zero_byte_vec.rs                 |  6 +-
 tests/ui/read_zero_byte_vec.stderr             | 20 +++---
 tests/ui/slow_vector_initialization.rs         | 16 +++++
 tests/ui/slow_vector_initialization.stderr     | 64 +++++++++++------
 5 files changed, 145 insertions(+), 57 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/slow_vector_initialization.rs b/clippy_lints/src/slow_vector_initialization.rs
index 858135c8d46..b496185cc72 100644
--- a/clippy_lints/src/slow_vector_initialization.rs
+++ b/clippy_lints/src/slow_vector_initialization.rs
@@ -2,7 +2,8 @@ use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::{
-    get_enclosing_block, is_integer_literal, is_path_diagnostic_item, path_to_local, path_to_local_id, SpanlessEq,
+    get_enclosing_block, is_expr_path_def_path, is_integer_literal, is_path_diagnostic_item, path_to_local,
+    path_to_local_id, paths, SpanlessEq,
 };
 use if_chain::if_chain;
 use rustc_errors::Applicability;
@@ -60,7 +61,11 @@ struct VecAllocation<'tcx> {
 
     /// Reference to the expression used as argument on `with_capacity` call. This is used
     /// to only match slow zero-filling idioms of the same length than vector initialization.
-    len_expr: &'tcx Expr<'tcx>,
+    ///
+    /// Initially set to `None` if initialized with `Vec::new()`, but will always be `Some(_)` by
+    /// the time the visitor has looked through the enclosing block and found a slow
+    /// initialization, so it is safe to unwrap later at lint time.
+    size_expr: Option<&'tcx Expr<'tcx>>,
 }
 
 /// Type of slow initialization
@@ -77,18 +82,14 @@ impl<'tcx> LateLintPass<'tcx> for SlowVectorInit {
         // Matches initialization on reassignments. For example: `vec = Vec::with_capacity(100)`
         if_chain! {
             if let ExprKind::Assign(left, right, _) = expr.kind;
-
-            // Extract variable
             if let Some(local_id) = path_to_local(left);
-
-            // Extract len argument
-            if let Some(len_arg) = Self::is_vec_with_capacity(cx, right);
+            if let Some(size_expr) = Self::as_vec_initializer(cx, right);
 
             then {
                 let vi = VecAllocation {
                     local_id,
                     allocation_expr: right,
-                    len_expr: len_arg,
+                    size_expr,
                 };
 
                 Self::search_initialization(cx, vi, expr.hir_id);
@@ -98,17 +99,18 @@ impl<'tcx> LateLintPass<'tcx> for SlowVectorInit {
 
     fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) {
         // Matches statements which initializes vectors. For example: `let mut vec = Vec::with_capacity(10)`
+        // or `Vec::new()`
         if_chain! {
             if let StmtKind::Local(local) = stmt.kind;
             if let PatKind::Binding(BindingAnnotation::MUT, local_id, _, None) = local.pat.kind;
             if let Some(init) = local.init;
-            if let Some(len_arg) = Self::is_vec_with_capacity(cx, init);
+            if let Some(size_expr) = Self::as_vec_initializer(cx, init);
 
             then {
                 let vi = VecAllocation {
                     local_id,
                     allocation_expr: init,
-                    len_expr: len_arg,
+                    size_expr,
                 };
 
                 Self::search_initialization(cx, vi, stmt.hir_id);
@@ -118,6 +120,25 @@ impl<'tcx> LateLintPass<'tcx> for SlowVectorInit {
 }
 
 impl SlowVectorInit {
+    /// Given an expression, returns:
+    /// - `Some(Some(size))` if it is a function call to `Vec::with_capacity(size)`
+    /// - `Some(None)` if it is a call to `Vec::new()`
+    /// - `None` if it is neither
+    #[allow(
+        clippy::option_option,
+        reason = "outer option is immediately removed at call site and the inner option is kept around, \
+            so extracting into a dedicated enum seems unnecessarily complicated"
+    )]
+    fn as_vec_initializer<'tcx>(cx: &LateContext<'_>, expr: &'tcx Expr<'tcx>) -> Option<Option<&'tcx Expr<'tcx>>> {
+        if let Some(len_expr) = Self::is_vec_with_capacity(cx, expr) {
+            Some(Some(len_expr))
+        } else if Self::is_vec_new(cx, expr) {
+            Some(None)
+        } else {
+            None
+        }
+    }
+
     /// Checks if the given expression is `Vec::with_capacity(..)`. It will return the expression
     /// of the first argument of `with_capacity` call if it matches or `None` if it does not.
     fn is_vec_with_capacity<'tcx>(cx: &LateContext<'_>, expr: &Expr<'tcx>) -> Option<&'tcx Expr<'tcx>> {
@@ -134,6 +155,14 @@ impl SlowVectorInit {
         }
     }
 
+    /// Checks if the given expression is `Vec::new()`
+    fn is_vec_new(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+        matches!(
+            expr.kind,
+            ExprKind::Call(func, _) if is_expr_path_def_path(cx, func, &paths::VEC_NEW)
+        )
+    }
+
     /// Search initialization for the given vector
     fn search_initialization<'tcx>(cx: &LateContext<'tcx>, vec_alloc: VecAllocation<'tcx>, parent_node: HirId) {
         let enclosing_body = get_enclosing_block(cx, parent_node);
@@ -169,12 +198,18 @@ impl SlowVectorInit {
     }
 
     fn emit_lint(cx: &LateContext<'_>, slow_fill: &Expr<'_>, vec_alloc: &VecAllocation<'_>, msg: &str) {
-        let len_expr = Sugg::hir(cx, vec_alloc.len_expr, "len");
+        let len_expr = Sugg::hir(
+            cx,
+            vec_alloc
+                .size_expr
+                .expect("length expression must be set by this point"),
+            "len",
+        );
 
         span_lint_and_then(cx, SLOW_VECTOR_INITIALIZATION, slow_fill.span, msg, |diag| {
             diag.span_suggestion(
                 vec_alloc.allocation_expr.span,
-                "consider replace allocation with",
+                "consider replacing this with",
                 format!("vec![0; {len_expr}]"),
                 Applicability::Unspecified,
             );
@@ -214,36 +249,45 @@ impl<'a, 'tcx> VectorInitializationVisitor<'a, 'tcx> {
     }
 
     /// Checks if the given expression is resizing a vector with 0
-    fn search_slow_resize_filling(&mut self, expr: &'tcx Expr<'_>) {
+    fn search_slow_resize_filling(&mut self, expr: &'tcx Expr<'tcx>) {
         if self.initialization_found
             && let ExprKind::MethodCall(path, self_arg, [len_arg, fill_arg], _) = expr.kind
             && path_to_local_id(self_arg, self.vec_alloc.local_id)
             && path.ident.name == sym!(resize)
             // Check that is filled with 0
-            && is_integer_literal(fill_arg, 0) {
-                // Check that len expression is equals to `with_capacity` expression
-                if SpanlessEq::new(self.cx).eq_expr(len_arg, self.vec_alloc.len_expr) {
-                    self.slow_expression = Some(InitializationType::Resize(expr));
-                } else if let ExprKind::MethodCall(path, ..) = len_arg.kind && path.ident.as_str() == "capacity" {
-                    self.slow_expression = Some(InitializationType::Resize(expr));
-                }
+            && is_integer_literal(fill_arg, 0)
+        {
+            let is_matching_resize = if let Some(size_expr) = self.vec_alloc.size_expr {
+                // If we have a size expression, check that it is equal to what's passed to `resize`
+                SpanlessEq::new(self.cx).eq_expr(len_arg, size_expr)
+                    || matches!(len_arg.kind, ExprKind::MethodCall(path, ..) if path.ident.as_str() == "capacity")
+            } else {
+                self.vec_alloc.size_expr = Some(len_arg);
+                true
+            };
+
+            if is_matching_resize {
+                self.slow_expression = Some(InitializationType::Resize(expr));
             }
+        }
     }
 
     /// Returns `true` if give expression is `repeat(0).take(...)`
-    fn is_repeat_take(&self, expr: &Expr<'_>) -> bool {
+    fn is_repeat_take(&mut self, expr: &'tcx Expr<'tcx>) -> bool {
         if_chain! {
             if let ExprKind::MethodCall(take_path, recv, [len_arg, ..], _) = expr.kind;
             if take_path.ident.name == sym!(take);
             // Check that take is applied to `repeat(0)`
             if self.is_repeat_zero(recv);
             then {
-                // Check that len expression is equals to `with_capacity` expression
-                if SpanlessEq::new(self.cx).eq_expr(len_arg, self.vec_alloc.len_expr) {
-                    return true;
-                } else if let ExprKind::MethodCall(path, ..) = len_arg.kind && path.ident.as_str() == "capacity" {
-                    return true;
+                if let Some(size_expr) = self.vec_alloc.size_expr {
+                    // Check that len expression is equals to `with_capacity` expression
+                    return SpanlessEq::new(self.cx).eq_expr(len_arg, size_expr)
+                        || matches!(len_arg.kind, ExprKind::MethodCall(path, ..) if path.ident.as_str() == "capacity")
                 }
+
+                self.vec_alloc.size_expr = Some(len_arg);
+                return true;
             }
         }
 
diff --git a/tests/ui/read_zero_byte_vec.rs b/tests/ui/read_zero_byte_vec.rs
index c6025ef1f4d..ff2ad8644b4 100644
--- a/tests/ui/read_zero_byte_vec.rs
+++ b/tests/ui/read_zero_byte_vec.rs
@@ -1,5 +1,9 @@
 #![warn(clippy::read_zero_byte_vec)]
-#![allow(clippy::unused_io_amount, clippy::needless_pass_by_ref_mut)]
+#![allow(
+    clippy::unused_io_amount,
+    clippy::needless_pass_by_ref_mut,
+    clippy::slow_vector_initialization
+)]
 use std::fs::File;
 use std::io;
 use std::io::prelude::*;
diff --git a/tests/ui/read_zero_byte_vec.stderr b/tests/ui/read_zero_byte_vec.stderr
index 08ba9753d7c..4c7f605f4c2 100644
--- a/tests/ui/read_zero_byte_vec.stderr
+++ b/tests/ui/read_zero_byte_vec.stderr
@@ -1,5 +1,5 @@
 error: reading zero byte data to `Vec`
-  --> $DIR/read_zero_byte_vec.rs:17:5
+  --> $DIR/read_zero_byte_vec.rs:21:5
    |
 LL |     f.read_exact(&mut data).unwrap();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `data.resize(20, 0); f.read_exact(&mut data).unwrap();`
@@ -7,55 +7,55 @@ LL |     f.read_exact(&mut data).unwrap();
    = note: `-D clippy::read-zero-byte-vec` implied by `-D warnings`
 
 error: reading zero byte data to `Vec`
-  --> $DIR/read_zero_byte_vec.rs:21:5
+  --> $DIR/read_zero_byte_vec.rs:25:5
    |
 LL |     f.read_exact(&mut data2)?;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `data2.resize(cap, 0); f.read_exact(&mut data2)?;`
 
 error: reading zero byte data to `Vec`
-  --> $DIR/read_zero_byte_vec.rs:25:5
+  --> $DIR/read_zero_byte_vec.rs:29:5
    |
 LL |     f.read_exact(&mut data3)?;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: reading zero byte data to `Vec`
-  --> $DIR/read_zero_byte_vec.rs:29:5
+  --> $DIR/read_zero_byte_vec.rs:33:5
    |
 LL |     let _ = f.read(&mut data4)?;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: reading zero byte data to `Vec`
-  --> $DIR/read_zero_byte_vec.rs:34:9
+  --> $DIR/read_zero_byte_vec.rs:38:9
    |
 LL |         f.read(&mut data5)
    |         ^^^^^^^^^^^^^^^^^^
 
 error: reading zero byte data to `Vec`
-  --> $DIR/read_zero_byte_vec.rs:40:9
+  --> $DIR/read_zero_byte_vec.rs:44:9
    |
 LL |         f.read(&mut data6)
    |         ^^^^^^^^^^^^^^^^^^
 
 error: reading zero byte data to `Vec`
-  --> $DIR/read_zero_byte_vec.rs:70:5
+  --> $DIR/read_zero_byte_vec.rs:74:5
    |
 LL |     r.read(&mut data).await.unwrap();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: reading zero byte data to `Vec`
-  --> $DIR/read_zero_byte_vec.rs:74:5
+  --> $DIR/read_zero_byte_vec.rs:78:5
    |
 LL |     r.read_exact(&mut data2).await.unwrap();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: reading zero byte data to `Vec`
-  --> $DIR/read_zero_byte_vec.rs:80:5
+  --> $DIR/read_zero_byte_vec.rs:84:5
    |
 LL |     r.read(&mut data).await.unwrap();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: reading zero byte data to `Vec`
-  --> $DIR/read_zero_byte_vec.rs:84:5
+  --> $DIR/read_zero_byte_vec.rs:88:5
    |
 LL |     r.read_exact(&mut data2).await.unwrap();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/slow_vector_initialization.rs b/tests/ui/slow_vector_initialization.rs
index 16be9f6d203..cfb856861b8 100644
--- a/tests/ui/slow_vector_initialization.rs
+++ b/tests/ui/slow_vector_initialization.rs
@@ -4,6 +4,7 @@ fn main() {
     resize_vector();
     extend_vector();
     mixed_extend_resize_vector();
+    from_empty_vec();
 }
 
 fn extend_vector() {
@@ -59,6 +60,21 @@ fn resize_vector() {
     vec1.resize(10, 0);
 }
 
+fn from_empty_vec() {
+    // Resize with constant expression
+    let len = 300;
+    let mut vec1 = Vec::new();
+    vec1.resize(len, 0);
+
+    // Resize with len expression
+    let mut vec3 = Vec::new();
+    vec3.resize(len - 10, 0);
+
+    // Reinitialization should be warned
+    vec1 = Vec::new();
+    vec1.resize(10, 0);
+}
+
 fn do_stuff(vec: &mut [u8]) {}
 
 fn extend_vector_with_manipulations_between() {
diff --git a/tests/ui/slow_vector_initialization.stderr b/tests/ui/slow_vector_initialization.stderr
index 22376680a8e..532ce4ac191 100644
--- a/tests/ui/slow_vector_initialization.stderr
+++ b/tests/ui/slow_vector_initialization.stderr
@@ -1,84 +1,108 @@
 error: slow zero-filling initialization
-  --> $DIR/slow_vector_initialization.rs:13:5
+  --> $DIR/slow_vector_initialization.rs:14:5
    |
 LL |     let mut vec1 = Vec::with_capacity(len);
-   |                    ----------------------- help: consider replace allocation with: `vec![0; len]`
+   |                    ----------------------- help: consider replacing this with: `vec![0; len]`
 LL |     vec1.extend(repeat(0).take(len));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::slow-vector-initialization` implied by `-D warnings`
 
 error: slow zero-filling initialization
-  --> $DIR/slow_vector_initialization.rs:17:5
+  --> $DIR/slow_vector_initialization.rs:18:5
    |
 LL |     let mut vec2 = Vec::with_capacity(len - 10);
-   |                    ---------------------------- help: consider replace allocation with: `vec![0; len - 10]`
+   |                    ---------------------------- help: consider replacing this with: `vec![0; len - 10]`
 LL |     vec2.extend(repeat(0).take(len - 10));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: slow zero-filling initialization
-  --> $DIR/slow_vector_initialization.rs:24:5
+  --> $DIR/slow_vector_initialization.rs:25:5
    |
 LL |     let mut vec4 = Vec::with_capacity(len);
-   |                    ----------------------- help: consider replace allocation with: `vec![0; len]`
+   |                    ----------------------- help: consider replacing this with: `vec![0; len]`
 LL |     vec4.extend(repeat(0).take(vec4.capacity()));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: slow zero-filling initialization
-  --> $DIR/slow_vector_initialization.rs:34:5
+  --> $DIR/slow_vector_initialization.rs:35:5
    |
 LL |     let mut resized_vec = Vec::with_capacity(30);
-   |                           ---------------------- help: consider replace allocation with: `vec![0; 30]`
+   |                           ---------------------- help: consider replacing this with: `vec![0; 30]`
 LL |     resized_vec.resize(30, 0);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: slow zero-filling initialization
-  --> $DIR/slow_vector_initialization.rs:37:5
+  --> $DIR/slow_vector_initialization.rs:38:5
    |
 LL |     let mut extend_vec = Vec::with_capacity(30);
-   |                          ---------------------- help: consider replace allocation with: `vec![0; 30]`
+   |                          ---------------------- help: consider replacing this with: `vec![0; 30]`
 LL |     extend_vec.extend(repeat(0).take(30));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: slow zero-filling initialization
-  --> $DIR/slow_vector_initialization.rs:44:5
+  --> $DIR/slow_vector_initialization.rs:45:5
    |
 LL |     let mut vec1 = Vec::with_capacity(len);
-   |                    ----------------------- help: consider replace allocation with: `vec![0; len]`
+   |                    ----------------------- help: consider replacing this with: `vec![0; len]`
 LL |     vec1.resize(len, 0);
    |     ^^^^^^^^^^^^^^^^^^^
 
 error: slow zero-filling initialization
-  --> $DIR/slow_vector_initialization.rs:52:5
+  --> $DIR/slow_vector_initialization.rs:53:5
    |
 LL |     let mut vec3 = Vec::with_capacity(len - 10);
-   |                    ---------------------------- help: consider replace allocation with: `vec![0; len - 10]`
+   |                    ---------------------------- help: consider replacing this with: `vec![0; len - 10]`
 LL |     vec3.resize(len - 10, 0);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: slow zero-filling initialization
-  --> $DIR/slow_vector_initialization.rs:55:5
+  --> $DIR/slow_vector_initialization.rs:56:5
    |
 LL |     let mut vec4 = Vec::with_capacity(len);
-   |                    ----------------------- help: consider replace allocation with: `vec![0; len]`
+   |                    ----------------------- help: consider replacing this with: `vec![0; len]`
 LL |     vec4.resize(vec4.capacity(), 0);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: slow zero-filling initialization
-  --> $DIR/slow_vector_initialization.rs:59:5
+  --> $DIR/slow_vector_initialization.rs:60:5
    |
 LL |     vec1 = Vec::with_capacity(10);
-   |            ---------------------- help: consider replace allocation with: `vec![0; 10]`
+   |            ---------------------- help: consider replacing this with: `vec![0; 10]`
+LL |     vec1.resize(10, 0);
+   |     ^^^^^^^^^^^^^^^^^^
+
+error: slow zero-filling initialization
+  --> $DIR/slow_vector_initialization.rs:67:5
+   |
+LL |     let mut vec1 = Vec::new();
+   |                    ---------- help: consider replacing this with: `vec![0; len]`
+LL |     vec1.resize(len, 0);
+   |     ^^^^^^^^^^^^^^^^^^^
+
+error: slow zero-filling initialization
+  --> $DIR/slow_vector_initialization.rs:71:5
+   |
+LL |     let mut vec3 = Vec::new();
+   |                    ---------- help: consider replacing this with: `vec![0; len - 10]`
+LL |     vec3.resize(len - 10, 0);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: slow zero-filling initialization
+  --> $DIR/slow_vector_initialization.rs:75:5
+   |
+LL |     vec1 = Vec::new();
+   |            ---------- help: consider replacing this with: `vec![0; 10]`
 LL |     vec1.resize(10, 0);
    |     ^^^^^^^^^^^^^^^^^^
 
 error: this argument is a mutable reference, but not used mutably
-  --> $DIR/slow_vector_initialization.rs:62:18
+  --> $DIR/slow_vector_initialization.rs:78:18
    |
 LL | fn do_stuff(vec: &mut [u8]) {}
    |                  ^^^^^^^^^ help: consider changing to: `&[u8]`
    |
    = note: `-D clippy::needless-pass-by-ref-mut` implied by `-D warnings`
 
-error: aborting due to 10 previous errors
+error: aborting due to 13 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From a4c367d0e9a11e6eeb10088a1c8adccc77bcbc89 Mon Sep 17 00:00:00 2001
From: Catherine <catherine.3.flores@gmail.com>
Date: Wed, 19 Jul 2023 02:59:06 -0500
Subject: Allow `Self::cmp(self, other)` as a correct impl

---
 clippy_lints/src/incorrect_impls.rs                | 72 +++++++++++++++++++---
 clippy_utils/src/paths.rs                          |  1 +
 .../incorrect_partial_ord_impl_on_ord_type.fixed   | 33 +++++++++-
 tests/ui/incorrect_partial_ord_impl_on_ord_type.rs | 33 +++++++++-
 .../incorrect_partial_ord_impl_on_ord_type.stderr  |  4 +-
 ...rect_partial_ord_impl_on_ord_type_fully_qual.rs | 51 +++++++++++++++
 ..._partial_ord_impl_on_ord_type_fully_qual.stderr | 31 ++++++++++
 7 files changed, 211 insertions(+), 14 deletions(-)
 create mode 100644 tests/ui/incorrect_partial_ord_impl_on_ord_type_fully_qual.rs
 create mode 100644 tests/ui/incorrect_partial_ord_impl_on_ord_type_fully_qual.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/incorrect_impls.rs b/clippy_lints/src/incorrect_impls.rs
index 166908ef4e4..e8a2042e92a 100644
--- a/clippy_lints/src/incorrect_impls.rs
+++ b/clippy_lints/src/incorrect_impls.rs
@@ -1,8 +1,9 @@
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
+use clippy_utils::paths::ORD_CMP;
 use clippy_utils::ty::implements_trait;
-use clippy_utils::{get_parent_node, is_res_lang_ctor, last_path_segment, path_res};
+use clippy_utils::{get_parent_node, is_res_lang_ctor, last_path_segment, match_def_path, path_res, std_or_core};
 use rustc_errors::Applicability;
-use rustc_hir::def::Res;
+use rustc_hir::def_id::LocalDefId;
 use rustc_hir::{Expr, ExprKind, ImplItem, ImplItemKind, ItemKind, LangItem, Node, UnOp};
 use rustc_hir_analysis::hir_ty_to_ty;
 use rustc_lint::{LateContext, LateLintPass};
@@ -60,6 +61,10 @@ declare_clippy_lint! {
     /// wrapping the result of `cmp` in `Some` for `partial_cmp`. Not doing this may silently
     /// introduce an error upon refactoring.
     ///
+    /// ### Known issues
+    /// Code that calls the `.into()` method instead will be flagged as incorrect, despite `.into()`
+    /// wrapping it in `Some`.
+    ///
     /// ### Limitations
     /// Will not lint if `Self` and `Rhs` do not have the same type.
     ///
@@ -191,6 +196,11 @@ impl LateLintPass<'_> for IncorrectImpls {
                     trait_impl.substs,
                 )
         {
+            // If the `cmp` call likely needs to be fully qualified in the suggestion
+            // (like `std::cmp::Ord::cmp`). It's unfortunate we must put this here but we can't
+            // access `cmp_expr` in the suggestion without major changes, as we lint in `else`.
+            let mut needs_fully_qualified = false;
+
             if block.stmts.is_empty()
                 && let Some(expr) = block.expr
                 && let ExprKind::Call(
@@ -202,9 +212,8 @@ impl LateLintPass<'_> for IncorrectImpls {
                         [cmp_expr],
                     ) = expr.kind
                 && is_res_lang_ctor(cx, cx.qpath_res(some_path, *some_hir_id), LangItem::OptionSome)
-                && let ExprKind::MethodCall(cmp_path, _, [other_expr], ..) = cmp_expr.kind
-                && cmp_path.ident.name == sym::cmp
-                && let Res::Local(..) = path_res(cx, other_expr)
+                // Fix #11178, allow `Self::cmp(self, ..)` too
+                && self_cmp_call(cx, cmp_expr, impl_item.owner_id.def_id, &mut needs_fully_qualified)
             {} else {
                 // If `Self` and `Rhs` are not the same type, bail. This makes creating a valid
                 // suggestion tons more complex.
@@ -221,14 +230,29 @@ impl LateLintPass<'_> for IncorrectImpls {
                         let [_, other] = body.params else {
                             return;
                         };
+                        let Some(std_or_core) = std_or_core(cx) else {
+                            return;
+                        };
 
-                        let suggs = if let Some(other_ident) = other.pat.simple_ident() {
-                            vec![(block.span, format!("{{ Some(self.cmp({})) }}", other_ident.name))]
-                        } else {
-                            vec![
+                        let suggs = match (other.pat.simple_ident(), needs_fully_qualified) {
+                            (Some(other_ident), true) => vec![(
+                                block.span,
+                                format!("{{ Some({std_or_core}::cmp::Ord::cmp(self, {})) }}", other_ident.name),
+                            )],
+                            (Some(other_ident), false) => {
+                                vec![(block.span, format!("{{ Some(self.cmp({})) }}", other_ident.name))]
+                            },
+                            (None, true) => vec![
+                                (
+                                    block.span,
+                                    format!("{{ Some({std_or_core}::cmp::Ord::cmp(self, other)) }}"),
+                                ),
+                                (other.pat.span, "other".to_owned()),
+                            ],
+                            (None, false) => vec![
                                 (block.span, "{ Some(self.cmp(other)) }".to_owned()),
                                 (other.pat.span, "other".to_owned()),
-                            ]
+                            ],
                         };
 
                         diag.multipart_suggestion(
@@ -242,3 +266,31 @@ impl LateLintPass<'_> for IncorrectImpls {
         }
     }
 }
+
+/// Returns whether this is any of `self.cmp(..)`, `Self::cmp(self, ..)` or `Ord::cmp(self, ..)`.
+fn self_cmp_call<'tcx>(
+    cx: &LateContext<'tcx>,
+    cmp_expr: &'tcx Expr<'tcx>,
+    def_id: LocalDefId,
+    needs_fully_qualified: &mut bool,
+) -> bool {
+    match cmp_expr.kind {
+        ExprKind::Call(path, [_self, _other]) => path_res(cx, path)
+            .opt_def_id()
+            .is_some_and(|def_id| match_def_path(cx, def_id, &ORD_CMP)),
+        ExprKind::MethodCall(_, _, [_other], ..) => {
+            // We can set this to true here no matter what as if it's a `MethodCall` and goes to the
+            // `else` branch, it must be a method named `cmp` that isn't `Ord::cmp`
+            *needs_fully_qualified = true;
+
+            // It's a bit annoying but `typeck_results` only gives us the CURRENT body, which we
+            // have none, not of any `LocalDefId` we want, so we must call the query itself to avoid
+            // an immediate ICE
+            cx.tcx
+                .typeck(def_id)
+                .type_dependent_def_id(cmp_expr.hir_id)
+                .is_some_and(|def_id| match_def_path(cx, def_id, &ORD_CMP))
+        },
+        _ => false,
+    }
+}
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index f3677e6f614..8fc13f23ef9 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -161,3 +161,4 @@ pub const OPTION_UNWRAP: [&str; 4] = ["core", "option", "Option", "unwrap"];
 pub const OPTION_EXPECT: [&str; 4] = ["core", "option", "Option", "expect"];
 pub const FORMATTER: [&str; 3] = ["core", "fmt", "Formatter"];
 pub const DEBUG_STRUCT: [&str; 4] = ["core", "fmt", "builders", "DebugStruct"];
+pub const ORD_CMP: [&str; 4] = ["core", "cmp", "Ord", "cmp"];
diff --git a/tests/ui/incorrect_partial_ord_impl_on_ord_type.fixed b/tests/ui/incorrect_partial_ord_impl_on_ord_type.fixed
index dd4fdd98822..2f51bf27480 100644
--- a/tests/ui/incorrect_partial_ord_impl_on_ord_type.fixed
+++ b/tests/ui/incorrect_partial_ord_impl_on_ord_type.fixed
@@ -1,5 +1,4 @@
 //@run-rustfix
-#![allow(unused)]
 #![no_main]
 
 use std::cmp::Ordering;
@@ -112,3 +111,35 @@ impl PartialOrd<u32> for F {
         todo!();
     }
 }
+
+// #11178, do not lint
+
+#[derive(Eq, PartialEq)]
+struct G(u32);
+
+impl Ord for G {
+    fn cmp(&self, other: &Self) -> Ordering {
+        todo!();
+    }
+}
+
+impl PartialOrd for G {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(Self::cmp(self, other))
+    }
+}
+
+#[derive(Eq, PartialEq)]
+struct H(u32);
+
+impl Ord for H {
+    fn cmp(&self, other: &Self) -> Ordering {
+        todo!();
+    }
+}
+
+impl PartialOrd for H {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(Ord::cmp(self, other))
+    }
+}
diff --git a/tests/ui/incorrect_partial_ord_impl_on_ord_type.rs b/tests/ui/incorrect_partial_ord_impl_on_ord_type.rs
index 522e82299c0..47127bdaec2 100644
--- a/tests/ui/incorrect_partial_ord_impl_on_ord_type.rs
+++ b/tests/ui/incorrect_partial_ord_impl_on_ord_type.rs
@@ -1,5 +1,4 @@
 //@run-rustfix
-#![allow(unused)]
 #![no_main]
 
 use std::cmp::Ordering;
@@ -116,3 +115,35 @@ impl PartialOrd<u32> for F {
         todo!();
     }
 }
+
+// #11178, do not lint
+
+#[derive(Eq, PartialEq)]
+struct G(u32);
+
+impl Ord for G {
+    fn cmp(&self, other: &Self) -> Ordering {
+        todo!();
+    }
+}
+
+impl PartialOrd for G {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(Self::cmp(self, other))
+    }
+}
+
+#[derive(Eq, PartialEq)]
+struct H(u32);
+
+impl Ord for H {
+    fn cmp(&self, other: &Self) -> Ordering {
+        todo!();
+    }
+}
+
+impl PartialOrd for H {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(Ord::cmp(self, other))
+    }
+}
diff --git a/tests/ui/incorrect_partial_ord_impl_on_ord_type.stderr b/tests/ui/incorrect_partial_ord_impl_on_ord_type.stderr
index 0e477798c40..66048fc9000 100644
--- a/tests/ui/incorrect_partial_ord_impl_on_ord_type.stderr
+++ b/tests/ui/incorrect_partial_ord_impl_on_ord_type.stderr
@@ -1,5 +1,5 @@
 error: incorrect implementation of `partial_cmp` on an `Ord` type
-  --> $DIR/incorrect_partial_ord_impl_on_ord_type.rs:18:1
+  --> $DIR/incorrect_partial_ord_impl_on_ord_type.rs:17:1
    |
 LL | /  impl PartialOrd for A {
 LL | |      fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
@@ -13,7 +13,7 @@ LL | |  }
    = note: `#[deny(clippy::incorrect_partial_ord_impl_on_ord_type)]` on by default
 
 error: incorrect implementation of `partial_cmp` on an `Ord` type
-  --> $DIR/incorrect_partial_ord_impl_on_ord_type.rs:52:1
+  --> $DIR/incorrect_partial_ord_impl_on_ord_type.rs:51:1
    |
 LL | / impl PartialOrd for C {
 LL | |     fn partial_cmp(&self, _: &Self) -> Option<Ordering> {
diff --git a/tests/ui/incorrect_partial_ord_impl_on_ord_type_fully_qual.rs b/tests/ui/incorrect_partial_ord_impl_on_ord_type_fully_qual.rs
new file mode 100644
index 00000000000..3a3b84f93c4
--- /dev/null
+++ b/tests/ui/incorrect_partial_ord_impl_on_ord_type_fully_qual.rs
@@ -0,0 +1,51 @@
+// This test's filename is... a bit verbose. But it ensures we suggest the correct code when `Ord`
+// is not in scope.
+#![no_main]
+#![no_implicit_prelude]
+
+extern crate std;
+
+use std::cmp::{self, Eq, Ordering, PartialEq, PartialOrd};
+use std::option::Option::{self, Some};
+use std::todo;
+
+// lint
+
+#[derive(Eq, PartialEq)]
+struct A(u32);
+
+impl cmp::Ord for A {
+    fn cmp(&self, other: &Self) -> Ordering {
+        todo!();
+    }
+}
+
+impl PartialOrd for A {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        // NOTE: This suggestion is wrong, as `Ord` is not in scope. But this should be fine as it isn't
+        // automatically applied
+        todo!();
+    }
+}
+
+#[derive(Eq, PartialEq)]
+struct B(u32);
+
+impl B {
+    fn cmp(&self, other: &Self) -> Ordering {
+        todo!();
+    }
+}
+
+impl cmp::Ord for B {
+    fn cmp(&self, other: &Self) -> Ordering {
+        todo!();
+    }
+}
+
+impl PartialOrd for B {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        // This calls `B.cmp`, not `Ord::cmp`!
+        Some(self.cmp(other))
+    }
+}
diff --git a/tests/ui/incorrect_partial_ord_impl_on_ord_type_fully_qual.stderr b/tests/ui/incorrect_partial_ord_impl_on_ord_type_fully_qual.stderr
new file mode 100644
index 00000000000..f4374c28128
--- /dev/null
+++ b/tests/ui/incorrect_partial_ord_impl_on_ord_type_fully_qual.stderr
@@ -0,0 +1,31 @@
+error: incorrect implementation of `partial_cmp` on an `Ord` type
+  --> $DIR/incorrect_partial_ord_impl_on_ord_type_fully_qual.rs:23:1
+   |
+LL | /  impl PartialOrd for A {
+LL | |      fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+   | | _____________________________________________________________-
+LL | ||         // NOTE: This suggestion is wrong, as `Ord` is not in scope. But this should be fine as it isn't
+LL | ||         // automatically applied
+LL | ||         todo!();
+LL | ||     }
+   | ||_____- help: change this to: `{ Some(self.cmp(other)) }`
+LL | |  }
+   | |__^
+   |
+   = note: `#[deny(clippy::incorrect_partial_ord_impl_on_ord_type)]` on by default
+
+error: incorrect implementation of `partial_cmp` on an `Ord` type
+  --> $DIR/incorrect_partial_ord_impl_on_ord_type_fully_qual.rs:46:1
+   |
+LL | /  impl PartialOrd for B {
+LL | |      fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+   | | _____________________________________________________________-
+LL | ||         // This calls `B.cmp`, not `Ord::cmp`!
+LL | ||         Some(self.cmp(other))
+LL | ||     }
+   | ||_____- help: change this to: `{ Some(std::cmp::Ord::cmp(self, other)) }`
+LL | |  }
+   | |__^
+
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 37b83660bc2501f6e90cb48689304aed73229967 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Fri, 21 Jul 2023 00:50:01 +0200
Subject: [`unused_async`]: don't lint if paths reference async fn without call

---
 clippy_lints/src/lib.rs          |   2 +-
 clippy_lints/src/unused_async.rs | 103 +++++++++++++++++++++++++++++++--------
 tests/ui/unused_async.rs         |  17 +++++++
 tests/ui/unused_async.stderr     |  34 ++++++++-----
 4 files changed, 123 insertions(+), 33 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 1609eb396b4..e6f6212508e 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -911,7 +911,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(move |_| Box::new(if_then_some_else_none::IfThenSomeElseNone::new(msrv())));
     store.register_late_pass(|_| Box::new(bool_assert_comparison::BoolAssertComparison));
     store.register_early_pass(move || Box::new(module_style::ModStyle));
-    store.register_late_pass(|_| Box::new(unused_async::UnusedAsync));
+    store.register_late_pass(|_| Box::<unused_async::UnusedAsync>::default());
     let disallowed_types = conf.disallowed_types.clone();
     store.register_late_pass(move |_| Box::new(disallowed_types::DisallowedTypes::new(disallowed_types.clone())));
     let import_renames = conf.enforced_import_renames.clone();
diff --git a/clippy_lints/src/unused_async.rs b/clippy_lints/src/unused_async.rs
index 5e42cf7e4f3..5c8c6e58914 100644
--- a/clippy_lints/src/unused_async.rs
+++ b/clippy_lints/src/unused_async.rs
@@ -1,11 +1,13 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::is_def_id_trait_method;
+use rustc_data_structures::fx::FxHashMap;
+use rustc_hir::def::DefKind;
 use rustc_hir::intravisit::{walk_body, walk_expr, walk_fn, FnKind, Visitor};
-use rustc_hir::{Body, Expr, ExprKind, FnDecl, YieldSource};
+use rustc_hir::{Body, Expr, ExprKind, FnDecl, Node, YieldSource};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::nested_filter;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::def_id::LocalDefId;
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::def_id::{LocalDefId, LocalDefIdSet};
 use rustc_span::Span;
 
 declare_clippy_lint! {
@@ -38,7 +40,23 @@ declare_clippy_lint! {
     "finds async functions with no await statements"
 }
 
-declare_lint_pass!(UnusedAsync => [UNUSED_ASYNC]);
+#[derive(Default)]
+pub struct UnusedAsync {
+    /// Keeps track of async functions used as values (i.e. path expressions to async functions that
+    /// are not immediately called)
+    async_fns_as_value: LocalDefIdSet,
+    /// Functions with unused `async`, linted post-crate after we've found all uses of local async
+    /// functions
+    unused_async_fns: FxHashMap<LocalDefId, UnusedAsyncFn>,
+}
+
+#[derive(Copy, Clone)]
+struct UnusedAsyncFn {
+    fn_span: Span,
+    await_in_async_block: Option<Span>,
+}
+
+impl_lint_pass!(UnusedAsync => [UNUSED_ASYNC]);
 
 struct AsyncFnVisitor<'a, 'tcx> {
     cx: &'a LateContext<'tcx>,
@@ -101,24 +119,71 @@ impl<'tcx> LateLintPass<'tcx> for UnusedAsync {
             };
             walk_fn(&mut visitor, fn_kind, fn_decl, body.id(), def_id);
             if !visitor.found_await {
-                span_lint_and_then(
-                    cx,
-                    UNUSED_ASYNC,
-                    span,
-                    "unused `async` for function with no await statements",
-                    |diag| {
-                        diag.help("consider removing the `async` from this function");
-
-                        if let Some(span) = visitor.await_in_async_block {
-                            diag.span_note(
-                                span,
-                                "`await` used in an async block, which does not require \
-                                the enclosing function to be `async`",
-                            );
-                        }
+                // Don't lint just yet, but store the necessary information for later.
+                // The actual linting happens in `check_crate_post`, once we've found all
+                // uses of local async functions that do require asyncness to pass typeck
+                self.unused_async_fns.insert(
+                    def_id,
+                    UnusedAsyncFn {
+                        await_in_async_block: visitor.await_in_async_block,
+                        fn_span: span,
                     },
                 );
             }
         }
     }
+
+    fn check_path(&mut self, cx: &LateContext<'tcx>, path: &rustc_hir::Path<'tcx>, hir_id: rustc_hir::HirId) {
+        fn is_node_func_call(node: Node<'_>, expected_receiver: Span) -> bool {
+            matches!(
+                node,
+                Node::Expr(Expr {
+                    kind: ExprKind::Call(Expr { span, .. }, _) | ExprKind::MethodCall(_, Expr { span, .. }, ..),
+                    ..
+                }) if *span == expected_receiver
+            )
+        }
+
+        // Find paths to local async functions that aren't immediately called.
+        // E.g. `async fn f() {}; let x = f;`
+        // Depending on how `x` is used, f's asyncness might be required despite not having any `await`
+        // statements, so don't lint at all if there are any such paths.
+        if let Some(def_id) = path.res.opt_def_id()
+            && let Some(local_def_id) = def_id.as_local()
+            && let Some(DefKind::Fn) = cx.tcx.opt_def_kind(def_id)
+            && cx.tcx.asyncness(def_id).is_async()
+            && !is_node_func_call(cx.tcx.hir().get_parent(hir_id), path.span)
+        {
+            self.async_fns_as_value.insert(local_def_id);
+        }
+    }
+
+    // After collecting all unused `async` and problematic paths to such functions,
+    // lint those unused ones that didn't have any path expressions to them.
+    fn check_crate_post(&mut self, cx: &LateContext<'tcx>) {
+        let iter = self
+            .unused_async_fns
+            .iter()
+            .filter_map(|(did, item)| (!self.async_fns_as_value.contains(did)).then_some(item));
+
+        for fun in iter {
+            span_lint_and_then(
+                cx,
+                UNUSED_ASYNC,
+                fun.fn_span,
+                "unused `async` for function with no await statements",
+                |diag| {
+                    diag.help("consider removing the `async` from this function");
+
+                    if let Some(span) = fun.await_in_async_block {
+                        diag.span_note(
+                            span,
+                            "`await` used in an async block, which does not require \
+                            the enclosing function to be `async`",
+                        );
+                    }
+                },
+            );
+        }
+    }
 }
diff --git a/tests/ui/unused_async.rs b/tests/ui/unused_async.rs
index 69e46ab4736..1d188025e41 100644
--- a/tests/ui/unused_async.rs
+++ b/tests/ui/unused_async.rs
@@ -37,6 +37,23 @@ mod issue10459 {
     }
 }
 
+mod issue9695 {
+    use std::future::Future;
+
+    async fn f() {}
+    async fn f2() {}
+    async fn f3() {}
+
+    fn needs_async_fn<F: Future<Output = ()>>(_: fn() -> F) {}
+
+    fn test() {
+        let x = f;
+        needs_async_fn(x); // async needed in f
+        needs_async_fn(f2); // async needed in f2
+        f3(); // async not needed in f3
+    }
+}
+
 async fn foo() -> i32 {
     4
 }
diff --git a/tests/ui/unused_async.stderr b/tests/ui/unused_async.stderr
index ffae8366b88..035dffa7f13 100644
--- a/tests/ui/unused_async.stderr
+++ b/tests/ui/unused_async.stderr
@@ -1,3 +1,22 @@
+error: unused `async` for function with no await statements
+  --> $DIR/unused_async.rs:45:5
+   |
+LL |     async fn f3() {}
+   |     ^^^^^^^^^^^^^^^^
+   |
+   = help: consider removing the `async` from this function
+   = note: `-D clippy::unused-async` implied by `-D warnings`
+
+error: unused `async` for function with no await statements
+  --> $DIR/unused_async.rs:57:1
+   |
+LL | / async fn foo() -> i32 {
+LL | |     4
+LL | | }
+   | |_^
+   |
+   = help: consider removing the `async` from this function
+
 error: unused `async` for function with no await statements
   --> $DIR/unused_async.rs:13:5
    |
@@ -14,20 +33,9 @@ note: `await` used in an async block, which does not require the enclosing funct
    |
 LL |             ready(()).await;
    |                       ^^^^^
-   = note: `-D clippy::unused-async` implied by `-D warnings`
-
-error: unused `async` for function with no await statements
-  --> $DIR/unused_async.rs:40:1
-   |
-LL | / async fn foo() -> i32 {
-LL | |     4
-LL | | }
-   | |_^
-   |
-   = help: consider removing the `async` from this function
 
 error: unused `async` for function with no await statements
-  --> $DIR/unused_async.rs:51:5
+  --> $DIR/unused_async.rs:68:5
    |
 LL | /     async fn unused(&self) -> i32 {
 LL | |         1
@@ -36,5 +44,5 @@ LL | |     }
    |
    = help: consider removing the `async` from this function
 
-error: aborting due to 3 previous errors
+error: aborting due to 4 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From f3f7f63c16ba173acefe43859516d0af9afc34f6 Mon Sep 17 00:00:00 2001
From: Catherine Flores <catherine.3.flores@gmail.com>
Date: Fri, 21 Jul 2023 06:45:30 -0500
Subject: [`inherent_to_string`]: Don't lint `unsafe` or `extern` fns

---
 clippy_lints/src/inherent_to_string.rs | 35 +++++++++++++++++-----------------
 tests/ui/inherent_to_string.rs         | 26 +++++++++++++++++++++++--
 tests/ui/inherent_to_string.stderr     | 10 +++-------
 3 files changed, 44 insertions(+), 27 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/inherent_to_string.rs b/clippy_lints/src/inherent_to_string.rs
index d43e5cc9b2c..bc4ec33b733 100644
--- a/clippy_lints/src/inherent_to_string.rs
+++ b/clippy_lints/src/inherent_to_string.rs
@@ -1,11 +1,11 @@
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::ty::{implements_trait, is_type_lang_item};
 use clippy_utils::{return_ty, trait_ref_of_method};
-use if_chain::if_chain;
-use rustc_hir::{GenericParamKind, ImplItem, ImplItemKind, LangItem};
+use rustc_hir::{GenericParamKind, ImplItem, ImplItemKind, LangItem, Unsafety};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::sym;
+use rustc_target::spec::abi::Abi;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -95,24 +95,23 @@ impl<'tcx> LateLintPass<'tcx> for InherentToString {
             return;
         }
 
-        if_chain! {
-            // Check if item is a method, called to_string and has a parameter 'self'
-            if let ImplItemKind::Fn(ref signature, _) = impl_item.kind;
-            if impl_item.ident.name == sym::to_string;
-            let decl = &signature.decl;
-            if decl.implicit_self.has_implicit_self();
-            if decl.inputs.len() == 1;
-            if impl_item.generics.params.iter().all(|p| matches!(p.kind, GenericParamKind::Lifetime { .. }));
-
+        // Check if item is a method called `to_string` and has a parameter 'self'
+        if let ImplItemKind::Fn(ref signature, _) = impl_item.kind
+            // #11201
+            && let header = signature.header
+            && header.unsafety == Unsafety::Normal
+            && header.abi == Abi::Rust
+            && impl_item.ident.name == sym::to_string
+            && let decl = signature.decl
+            && decl.implicit_self.has_implicit_self()
+            && decl.inputs.len() == 1
+            && impl_item.generics.params.iter().all(|p| matches!(p.kind, GenericParamKind::Lifetime { .. }))
             // Check if return type is String
-            if is_type_lang_item(cx, return_ty(cx, impl_item.owner_id), LangItem::String);
-
+            && is_type_lang_item(cx, return_ty(cx, impl_item.owner_id), LangItem::String)
             // Filters instances of to_string which are required by a trait
-            if trait_ref_of_method(cx, impl_item.owner_id.def_id).is_none();
-
-            then {
-                show_lint(cx, impl_item);
-            }
+            && trait_ref_of_method(cx, impl_item.owner_id.def_id).is_none()
+        {
+            show_lint(cx, impl_item);
         }
     }
 }
diff --git a/tests/ui/inherent_to_string.rs b/tests/ui/inherent_to_string.rs
index aeb0a0c1e2e..adb0389a043 100644
--- a/tests/ui/inherent_to_string.rs
+++ b/tests/ui/inherent_to_string.rs
@@ -1,5 +1,4 @@
-#![warn(clippy::inherent_to_string)]
-#![deny(clippy::inherent_to_string_shadow_display)]
+#![allow(improper_ctypes_definitions)]
 
 use std::fmt;
 
@@ -14,6 +13,9 @@ struct D;
 struct E;
 struct F;
 struct G;
+struct H;
+struct I;
+struct J;
 
 impl A {
     // Should be detected; emit warning
@@ -80,6 +82,26 @@ impl G {
     }
 }
 
+// Issue #11201
+
+impl H {
+    unsafe fn to_string(&self) -> String {
+        "G.to_string()".to_string()
+    }
+}
+
+impl I {
+    extern "C" fn to_string(&self) -> String {
+        "G.to_string()".to_string()
+    }
+}
+
+impl J {
+    unsafe extern "C" fn to_string(&self) -> String {
+        "G.to_string()".to_string()
+    }
+}
+
 fn main() {
     let a = A;
     a.to_string();
diff --git a/tests/ui/inherent_to_string.stderr b/tests/ui/inherent_to_string.stderr
index 443fecae1aa..579b3c8c56f 100644
--- a/tests/ui/inherent_to_string.stderr
+++ b/tests/ui/inherent_to_string.stderr
@@ -1,5 +1,5 @@
 error: implementation of inherent method `to_string(&self) -> String` for type `A`
-  --> $DIR/inherent_to_string.rs:20:5
+  --> $DIR/inherent_to_string.rs:22:5
    |
 LL | /     fn to_string(&self) -> String {
 LL | |         "A.to_string()".to_string()
@@ -10,7 +10,7 @@ LL | |     }
    = note: `-D clippy::inherent-to-string` implied by `-D warnings`
 
 error: type `C` implements inherent method `to_string(&self) -> String` which shadows the implementation of `Display`
-  --> $DIR/inherent_to_string.rs:44:5
+  --> $DIR/inherent_to_string.rs:46:5
    |
 LL | /     fn to_string(&self) -> String {
 LL | |         "C.to_string()".to_string()
@@ -18,11 +18,7 @@ LL | |     }
    | |_____^
    |
    = help: remove the inherent method from type `C`
-note: the lint level is defined here
-  --> $DIR/inherent_to_string.rs:2:9
-   |
-LL | #![deny(clippy::inherent_to_string_shadow_display)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   = note: `#[deny(clippy::inherent_to_string_shadow_display)]` on by default
 
 error: aborting due to 2 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 9cf1509b25889fad9743777602d472ffc8bd3ec2 Mon Sep 17 00:00:00 2001
From: Catherine <114838443+Centri3@users.noreply.github.com>
Date: Wed, 21 Jun 2023 21:15:20 -0500
Subject: New lint `absolute_paths`

---
 CHANGELOG.md                                       |   3 +
 book/src/lint_configuration.md                     |  21 +++++
 clippy_dev/src/lib.rs                              |   2 +-
 clippy_lints/src/absolute_paths.rs                 | 100 +++++++++++++++++++++
 clippy_lints/src/declared_lints.rs                 |   1 +
 clippy_lints/src/lib.rs                            |   9 ++
 clippy_lints/src/lifetimes.rs                      |   3 +-
 clippy_lints/src/redundant_static_lifetimes.rs     |   3 +-
 clippy_lints/src/utils/conf.rs                     |  10 +++
 clippy_utils/src/mir/possible_origin.rs            |   2 +-
 clippy_utils/src/usage.rs                          |   3 +-
 .../absolute_paths.allow_crates.stderr             |  28 ++++++
 .../absolute_paths.disallow_crates.stderr          |  70 +++++++++++++++
 tests/ui-toml/absolute_paths/absolute_paths.rs     |  97 ++++++++++++++++++++
 .../absolute_paths/allow_crates/clippy.toml        |   2 +
 tests/ui-toml/absolute_paths/auxiliary/helper.rs   |  11 +++
 .../absolute_paths/disallow_crates/clippy.toml     |   1 +
 .../toml_unknown_key/conf_unknown_key.stderr       |   4 +
 18 files changed, 365 insertions(+), 5 deletions(-)
 create mode 100644 clippy_lints/src/absolute_paths.rs
 create mode 100644 tests/ui-toml/absolute_paths/absolute_paths.allow_crates.stderr
 create mode 100644 tests/ui-toml/absolute_paths/absolute_paths.disallow_crates.stderr
 create mode 100644 tests/ui-toml/absolute_paths/absolute_paths.rs
 create mode 100644 tests/ui-toml/absolute_paths/allow_crates/clippy.toml
 create mode 100644 tests/ui-toml/absolute_paths/auxiliary/helper.rs
 create mode 100644 tests/ui-toml/absolute_paths/disallow_crates/clippy.toml

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 437f08dd777..fe879712130 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4680,6 +4680,7 @@ Released 2018-09-13
 
 <!-- lint disable no-unused-definitions -->
 <!-- begin autogenerated links to lint list -->
+[`absolute_paths`]: https://rust-lang.github.io/rust-clippy/master/index.html#absolute_paths
 [`absurd_extreme_comparisons`]: https://rust-lang.github.io/rust-clippy/master/index.html#absurd_extreme_comparisons
 [`alloc_instead_of_core`]: https://rust-lang.github.io/rust-clippy/master/index.html#alloc_instead_of_core
 [`allow_attributes`]: https://rust-lang.github.io/rust-clippy/master/index.html#allow_attributes
@@ -5467,4 +5468,6 @@ Released 2018-09-13
 [`accept-comment-above-statement`]: https://doc.rust-lang.org/clippy/lint_configuration.html#accept-comment-above-statement
 [`accept-comment-above-attributes`]: https://doc.rust-lang.org/clippy/lint_configuration.html#accept-comment-above-attributes
 [`allow-one-hash-in-raw-strings`]: https://doc.rust-lang.org/clippy/lint_configuration.html#allow-one-hash-in-raw-strings
+[`absolute-paths-max-segments`]: https://doc.rust-lang.org/clippy/lint_configuration.html#absolute-paths-max-segments
+[`absolute-paths-allowed-crates`]: https://doc.rust-lang.org/clippy/lint_configuration.html#absolute-paths-allowed-crates
 <!-- end autogenerated links to configuration documentation -->
diff --git a/book/src/lint_configuration.md b/book/src/lint_configuration.md
index f8073dac330..caaad6d1173 100644
--- a/book/src/lint_configuration.md
+++ b/book/src/lint_configuration.md
@@ -730,3 +730,24 @@ Whether to allow `r#""#` when `r""` can be used
 * [`unnecessary_raw_string_hashes`](https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_raw_string_hashes)
 
 
+## `absolute-paths-max-segments`
+The maximum number of segments a path can have before being linted, anything above this will
+be linted.
+
+**Default Value:** `2` (`u64`)
+
+---
+**Affected lints:**
+* [`absolute_paths`](https://rust-lang.github.io/rust-clippy/master/index.html#absolute_paths)
+
+
+## `absolute-paths-allowed-crates`
+Which crates to allow absolute paths from
+
+**Default Value:** `{}` (`rustc_data_structures::fx::FxHashSet<String>`)
+
+---
+**Affected lints:**
+* [`absolute_paths`](https://rust-lang.github.io/rust-clippy/master/index.html#absolute_paths)
+
+
diff --git a/clippy_dev/src/lib.rs b/clippy_dev/src/lib.rs
index 4624451cff4..c4ae4f0e2bd 100644
--- a/clippy_dev/src/lib.rs
+++ b/clippy_dev/src/lib.rs
@@ -51,7 +51,7 @@ pub fn clippy_project_root() -> PathBuf {
     for path in current_dir.ancestors() {
         let result = std::fs::read_to_string(path.join("Cargo.toml"));
         if let Err(err) = &result {
-            if err.kind() == std::io::ErrorKind::NotFound {
+            if err.kind() == io::ErrorKind::NotFound {
                 continue;
             }
         }
diff --git a/clippy_lints/src/absolute_paths.rs b/clippy_lints/src/absolute_paths.rs
new file mode 100644
index 00000000000..04417c4c460
--- /dev/null
+++ b/clippy_lints/src/absolute_paths.rs
@@ -0,0 +1,100 @@
+use clippy_utils::diagnostics::span_lint;
+use clippy_utils::source::snippet_opt;
+use rustc_data_structures::fx::FxHashSet;
+use rustc_hir::def::{DefKind, Res};
+use rustc_hir::def_id::{DefId, CRATE_DEF_INDEX};
+use rustc_hir::{HirId, ItemKind, Node, Path};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::symbol::kw;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of items through absolute paths, like `std::env::current_dir`.
+    ///
+    /// ### Why is this bad?
+    /// Many codebases have their own style when it comes to importing, but one that is seldom used
+    /// is using absolute paths *everywhere*. This is generally considered unidiomatic, and you
+    /// should add a `use` statement.
+    ///
+    /// The default maximum segments (2) is pretty strict, you may want to increase this in
+    /// `clippy.toml`.
+    ///
+    /// Note: One exception to this is code from macro expansion - this does not lint such cases, as
+    /// using absolute paths is the proper way of referencing items in one.
+    ///
+    /// ### Example
+    /// ```rust
+    /// let x = std::f64::consts::PI;
+    /// ```
+    /// Use any of the below instead, or anything else:
+    /// ```rust
+    /// use std::f64;
+    /// use std::f64::consts;
+    /// use std::f64::consts::PI;
+    /// let x = f64::consts::PI;
+    /// let x = consts::PI;
+    /// let x = PI;
+    /// use std::f64::consts as f64_consts;
+    /// let x = f64_consts::PI;
+    /// ```
+    #[clippy::version = "1.73.0"]
+    pub ABSOLUTE_PATHS,
+    restriction,
+    "checks for usage of an item without a `use` statement"
+}
+impl_lint_pass!(AbsolutePaths => [ABSOLUTE_PATHS]);
+
+pub struct AbsolutePaths {
+    pub absolute_paths_max_segments: u64,
+    pub absolute_paths_allowed_crates: FxHashSet<String>,
+}
+
+impl LateLintPass<'_> for AbsolutePaths {
+    // We should only lint `QPath::Resolved`s, but since `Path` is only used in `Resolved` and `UsePath`
+    // we don't need to use a visitor or anything as we can just check if the `Node` for `hir_id` isn't
+    // a `Use`
+    #[expect(clippy::cast_possible_truncation)]
+    fn check_path(&mut self, cx: &LateContext<'_>, path: &Path<'_>, hir_id: HirId) {
+        let Self {
+            absolute_paths_max_segments,
+            absolute_paths_allowed_crates,
+        } = self;
+
+        if !path.span.from_expansion()
+            && let Some(node) = cx.tcx.hir().find(hir_id)
+            && !matches!(node, Node::Item(item) if matches!(item.kind, ItemKind::Use(_, _)))
+            && let [first, rest @ ..] = path.segments
+            // Handle `::std`
+            && let (segment, len) = if first.ident.name == kw::PathRoot {
+                // Indexing is fine as `PathRoot` must be followed by another segment. `len() - 1`
+                // is fine here for the same reason
+                (&rest[0], path.segments.len() - 1)
+            } else {
+                (first, path.segments.len())
+            }
+            && len > *absolute_paths_max_segments as usize
+            && let Some(segment_snippet) = snippet_opt(cx, segment.ident.span)
+            && segment_snippet == segment.ident.as_str()
+        {
+            let is_abs_external =
+                matches!(segment.res, Res::Def(DefKind::Mod, DefId { index, .. }) if index == CRATE_DEF_INDEX);
+            let is_abs_crate = segment.ident.name == kw::Crate;
+
+            if is_abs_external && absolute_paths_allowed_crates.contains(segment.ident.name.as_str())
+                || is_abs_crate && absolute_paths_allowed_crates.contains("crate")
+            {
+                return;
+            }
+
+            if is_abs_external || is_abs_crate {
+                span_lint(
+                    cx,
+                    ABSOLUTE_PATHS,
+                    path.span,
+                    "consider bringing this path into scope with the `use` keyword",
+                );
+            }
+        }
+    }
+}
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index a0d181be3b1..830714ce7b0 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -37,6 +37,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::utils::internal_lints::produce_ice::PRODUCE_ICE_INFO,
     #[cfg(feature = "internal")]
     crate::utils::internal_lints::unnecessary_def_path::UNNECESSARY_DEF_PATH_INFO,
+    crate::absolute_paths::ABSOLUTE_PATHS_INFO,
     crate::allow_attributes::ALLOW_ATTRIBUTES_INFO,
     crate::almost_complete_range::ALMOST_COMPLETE_RANGE_INFO,
     crate::approx_const::APPROX_CONSTANT_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 1609eb396b4..0fa5c2f1828 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -65,6 +65,7 @@ mod declared_lints;
 mod renamed_lints;
 
 // begin lints modules, do not remove this comment, it’s used in `update_lints`
+mod absolute_paths;
 mod allow_attributes;
 mod almost_complete_range;
 mod approx_const;
@@ -1082,6 +1083,14 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(manual_float_methods::ManualFloatMethods));
     store.register_late_pass(|_| Box::new(four_forward_slashes::FourForwardSlashes));
     store.register_late_pass(|_| Box::new(error_impl_error::ErrorImplError));
+    let absolute_paths_max_segments = conf.absolute_paths_max_segments;
+    let absolute_paths_allowed_crates = conf.absolute_paths_allowed_crates.clone();
+    store.register_late_pass(move |_| {
+        Box::new(absolute_paths::AbsolutePaths {
+            absolute_paths_max_segments,
+            absolute_paths_allowed_crates: absolute_paths_allowed_crates.clone(),
+        })
+    });
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/lifetimes.rs b/clippy_lints/src/lifetimes.rs
index 852f6736585..0004a150d51 100644
--- a/clippy_lints/src/lifetimes.rs
+++ b/clippy_lints/src/lifetimes.rs
@@ -15,6 +15,7 @@ use rustc_hir::{
     PredicateOrigin, TraitFn, TraitItem, TraitItemKind, Ty, TyKind, WherePredicate,
 };
 use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_middle::hir::map::Map;
 use rustc_middle::hir::nested_filter as middle_nested_filter;
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -620,7 +621,7 @@ impl<'cx, 'tcx, F> Visitor<'tcx> for LifetimeChecker<'cx, 'tcx, F>
 where
     F: NestedFilter<'tcx>,
 {
-    type Map = rustc_middle::hir::map::Map<'tcx>;
+    type Map = Map<'tcx>;
     type NestedFilter = F;
 
     // for lifetimes as parameters of generics
diff --git a/clippy_lints/src/redundant_static_lifetimes.rs b/clippy_lints/src/redundant_static_lifetimes.rs
index 038dfe8e480..ed42a422b4b 100644
--- a/clippy_lints/src/redundant_static_lifetimes.rs
+++ b/clippy_lints/src/redundant_static_lifetimes.rs
@@ -5,6 +5,7 @@ use rustc_ast::ast::{ConstItem, Item, ItemKind, StaticItem, Ty, TyKind};
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::symbol::kw;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -64,7 +65,7 @@ impl RedundantStaticLifetimes {
                 if let Some(lifetime) = *optional_lifetime {
                     match borrow_type.ty.kind {
                         TyKind::Path(..) | TyKind::Slice(..) | TyKind::Array(..) | TyKind::Tup(..) => {
-                            if lifetime.ident.name == rustc_span::symbol::kw::StaticLifetime {
+                            if lifetime.ident.name == kw::StaticLifetime {
                                 let snip = snippet(cx, borrow_type.ty.span, "<type>");
                                 let sugg = format!("&{}{snip}", borrow_type.mutbl.prefix_str());
                                 span_lint_and_then(
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 76654bfe536..58ae0656db7 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -551,6 +551,16 @@ define_Conf! {
     ///
     /// Whether to allow `r#""#` when `r""` can be used
     (allow_one_hash_in_raw_strings: bool = false),
+    /// Lint: ABSOLUTE_PATHS.
+    ///
+    /// The maximum number of segments a path can have before being linted, anything above this will
+    /// be linted.
+    (absolute_paths_max_segments: u64 = 2),
+    /// Lint: ABSOLUTE_PATHS.
+    ///
+    /// Which crates to allow absolute paths from
+    (absolute_paths_allowed_crates: rustc_data_structures::fx::FxHashSet<String> =
+        rustc_data_structures::fx::FxHashSet::default()),
 }
 
 /// Search for the configuration file.
diff --git a/clippy_utils/src/mir/possible_origin.rs b/clippy_utils/src/mir/possible_origin.rs
index 8e7513d740a..da04266863f 100644
--- a/clippy_utils/src/mir/possible_origin.rs
+++ b/clippy_utils/src/mir/possible_origin.rs
@@ -44,7 +44,7 @@ impl<'a, 'tcx> mir::visit::Visitor<'tcx> for PossibleOriginVisitor<'a, 'tcx> {
         let lhs = place.local;
         match rvalue {
             // Only consider `&mut`, which can modify origin place
-            mir::Rvalue::Ref(_, rustc_middle::mir::BorrowKind::Mut { .. }, borrowed) |
+            mir::Rvalue::Ref(_, mir::BorrowKind::Mut { .. }, borrowed) |
             // _2: &mut _;
             // _3 = move _2
             mir::Rvalue::Use(mir::Operand::Move(borrowed))  |
diff --git a/clippy_utils/src/usage.rs b/clippy_utils/src/usage.rs
index 20993398d1b..8a7ea1e6cad 100644
--- a/clippy_utils/src/usage.rs
+++ b/clippy_utils/src/usage.rs
@@ -1,5 +1,6 @@
 use crate::visitors::{for_each_expr, for_each_expr_with_closures, Descend};
 use core::ops::ControlFlow;
+use hir::def::Res;
 use rustc_hir::intravisit::{self, Visitor};
 use rustc_hir::{Expr, ExprKind, HirId, HirIdSet, Node};
 use rustc_hir_typeck::expr_use_visitor::{Delegate, ExprUseVisitor, PlaceBase, PlaceWithHirId};
@@ -127,7 +128,7 @@ impl<'a, 'tcx> intravisit::Visitor<'tcx> for BindingUsageFinder<'a, 'tcx> {
     }
 
     fn visit_path(&mut self, path: &hir::Path<'tcx>, _: hir::HirId) {
-        if let hir::def::Res::Local(id) = path.res {
+        if let Res::Local(id) = path.res {
             if self.binding_ids.contains(&id) {
                 self.usage_found = true;
             }
diff --git a/tests/ui-toml/absolute_paths/absolute_paths.allow_crates.stderr b/tests/ui-toml/absolute_paths/absolute_paths.allow_crates.stderr
new file mode 100644
index 00000000000..a8900da4e6e
--- /dev/null
+++ b/tests/ui-toml/absolute_paths/absolute_paths.allow_crates.stderr
@@ -0,0 +1,28 @@
+error: consider bringing this path into scope with the `use` keyword
+  --> $DIR/absolute_paths.rs:40:5
+   |
+LL |     std::f32::MAX;
+   |     ^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::absolute-paths` implied by `-D warnings`
+
+error: consider bringing this path into scope with the `use` keyword
+  --> $DIR/absolute_paths.rs:41:5
+   |
+LL |     core::f32::MAX;
+   |     ^^^^^^^^^^^^^^
+
+error: consider bringing this path into scope with the `use` keyword
+  --> $DIR/absolute_paths.rs:42:5
+   |
+LL |     ::core::f32::MAX;
+   |     ^^^^^^^^^^^^^^^^
+
+error: consider bringing this path into scope with the `use` keyword
+  --> $DIR/absolute_paths.rs:58:5
+   |
+LL |     ::std::f32::MAX;
+   |     ^^^^^^^^^^^^^^^
+
+error: aborting due to 4 previous errors
+
diff --git a/tests/ui-toml/absolute_paths/absolute_paths.disallow_crates.stderr b/tests/ui-toml/absolute_paths/absolute_paths.disallow_crates.stderr
new file mode 100644
index 00000000000..41b70644be8
--- /dev/null
+++ b/tests/ui-toml/absolute_paths/absolute_paths.disallow_crates.stderr
@@ -0,0 +1,70 @@
+error: consider bringing this path into scope with the `use` keyword
+  --> $DIR/absolute_paths.rs:40:5
+   |
+LL |     std::f32::MAX;
+   |     ^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::absolute-paths` implied by `-D warnings`
+
+error: consider bringing this path into scope with the `use` keyword
+  --> $DIR/absolute_paths.rs:41:5
+   |
+LL |     core::f32::MAX;
+   |     ^^^^^^^^^^^^^^
+
+error: consider bringing this path into scope with the `use` keyword
+  --> $DIR/absolute_paths.rs:42:5
+   |
+LL |     ::core::f32::MAX;
+   |     ^^^^^^^^^^^^^^^^
+
+error: consider bringing this path into scope with the `use` keyword
+  --> $DIR/absolute_paths.rs:43:5
+   |
+LL |     crate::a::b::c::C;
+   |     ^^^^^^^^^^^^^^^^^
+
+error: consider bringing this path into scope with the `use` keyword
+  --> $DIR/absolute_paths.rs:44:5
+   |
+LL |     crate::a::b::c::d::e::f::F;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: consider bringing this path into scope with the `use` keyword
+  --> $DIR/absolute_paths.rs:45:5
+   |
+LL |     crate::a::A;
+   |     ^^^^^^^^^^^
+
+error: consider bringing this path into scope with the `use` keyword
+  --> $DIR/absolute_paths.rs:46:5
+   |
+LL |     crate::a::b::B;
+   |     ^^^^^^^^^^^^^^
+
+error: consider bringing this path into scope with the `use` keyword
+  --> $DIR/absolute_paths.rs:47:5
+   |
+LL |     crate::a::b::c::C::ZERO;
+   |     ^^^^^^^^^^^^^^^^^
+
+error: consider bringing this path into scope with the `use` keyword
+  --> $DIR/absolute_paths.rs:48:5
+   |
+LL |     helper::b::c::d::e::f();
+   |     ^^^^^^^^^^^^^^^^^^^^^
+
+error: consider bringing this path into scope with the `use` keyword
+  --> $DIR/absolute_paths.rs:49:5
+   |
+LL |     ::helper::b::c::d::e::f();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^
+
+error: consider bringing this path into scope with the `use` keyword
+  --> $DIR/absolute_paths.rs:58:5
+   |
+LL |     ::std::f32::MAX;
+   |     ^^^^^^^^^^^^^^^
+
+error: aborting due to 11 previous errors
+
diff --git a/tests/ui-toml/absolute_paths/absolute_paths.rs b/tests/ui-toml/absolute_paths/absolute_paths.rs
new file mode 100644
index 00000000000..d4c250a8ff2
--- /dev/null
+++ b/tests/ui-toml/absolute_paths/absolute_paths.rs
@@ -0,0 +1,97 @@
+//@aux-build:../../ui/auxiliary/proc_macros.rs:proc-macro
+//@aux-build:helper.rs
+//@revisions: allow_crates disallow_crates
+//@[allow_crates] rustc-env:CLIPPY_CONF_DIR=tests/ui-toml/absolute_paths/allow_crates
+//@[disallow_crates] rustc-env:CLIPPY_CONF_DIR=tests/ui-toml/absolute_paths/disallow_crates
+#![allow(clippy::no_effect, unused)]
+#![warn(clippy::absolute_paths)]
+#![feature(decl_macro)]
+
+extern crate helper;
+#[macro_use]
+extern crate proc_macros;
+
+pub mod a {
+    pub mod b {
+        pub mod c {
+            pub struct C;
+
+            impl C {
+                pub const ZERO: u32 = 0;
+            }
+
+            pub mod d {
+                pub mod e {
+                    pub mod f {
+                        pub struct F;
+                    }
+                }
+            }
+        }
+
+        pub struct B;
+    }
+
+    pub struct A;
+}
+
+fn main() {
+    f32::max(1.0, 2.0);
+    std::f32::MAX;
+    core::f32::MAX;
+    ::core::f32::MAX;
+    crate::a::b::c::C;
+    crate::a::b::c::d::e::f::F;
+    crate::a::A;
+    crate::a::b::B;
+    crate::a::b::c::C::ZERO;
+    helper::b::c::d::e::f();
+    ::helper::b::c::d::e::f();
+    fn b() -> a::b::B {
+        todo!()
+    }
+    std::println!("a");
+    let x = 1;
+    std::ptr::addr_of!(x);
+    // Test we handle max segments with `PathRoot` properly; this has 4 segments but we should say it
+    // has 3
+    ::std::f32::MAX;
+    // Do not lint due to the above
+    ::helper::a();
+    // Do not lint
+    helper::a();
+    use crate::a::b::c::C;
+    use a::b;
+    use std::f32::MAX;
+    a::b::c::d::e::f::F;
+    b::c::C;
+    fn a() -> a::A {
+        todo!()
+    }
+    use a::b::c;
+
+    fn c() -> c::C {
+        todo!()
+    }
+    fn d() -> Result<(), ()> {
+        todo!()
+    }
+    external! {
+        crate::a::b::c::C::ZERO;
+    }
+    // For some reason, `path.span.from_expansion()` takes care of this for us
+    with_span! {
+        span
+        crate::a::b::c::C::ZERO;
+    }
+    macro_rules! local_crate {
+        () => {
+            crate::a::b::c::C::ZERO;
+        };
+    }
+    macro local_crate_2_0() {
+        crate::a::b::c::C::ZERO;
+    }
+    local_crate!();
+    local_crate_2_0!();
+}
diff --git a/tests/ui-toml/absolute_paths/allow_crates/clippy.toml b/tests/ui-toml/absolute_paths/allow_crates/clippy.toml
new file mode 100644
index 00000000000..59a621e9d1d
--- /dev/null
+++ b/tests/ui-toml/absolute_paths/allow_crates/clippy.toml
@@ -0,0 +1,2 @@
+absolute-paths-max-segments = 2
+absolute-paths-allowed-crates = ["crate", "helper"]
diff --git a/tests/ui-toml/absolute_paths/auxiliary/helper.rs b/tests/ui-toml/absolute_paths/auxiliary/helper.rs
new file mode 100644
index 00000000000..8e2678f5fe6
--- /dev/null
+++ b/tests/ui-toml/absolute_paths/auxiliary/helper.rs
@@ -0,0 +1,11 @@
+pub fn a() {}
+
+pub mod b {
+    pub mod c {
+        pub mod d {
+            pub mod e {
+                pub fn f() {}
+            }
+        }
+    }
+}
diff --git a/tests/ui-toml/absolute_paths/disallow_crates/clippy.toml b/tests/ui-toml/absolute_paths/disallow_crates/clippy.toml
new file mode 100644
index 00000000000..d44d648c641
--- /dev/null
+++ b/tests/ui-toml/absolute_paths/disallow_crates/clippy.toml
@@ -0,0 +1 @@
+absolute-paths-max-segments = 2
diff --git a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
index 6ba26e97730..cdabe6460cd 100644
--- a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
+++ b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
@@ -1,4 +1,6 @@
 error: error reading Clippy's configuration file: unknown field `foobar`, expected one of
+           absolute-paths-allowed-crates
+           absolute-paths-max-segments
            accept-comment-above-attributes
            accept-comment-above-statement
            allow-dbg-in-tests
@@ -68,6 +70,8 @@ LL | foobar = 42
    | ^^^^^^
 
 error: error reading Clippy's configuration file: unknown field `barfoo`, expected one of
+           absolute-paths-allowed-crates
+           absolute-paths-max-segments
            accept-comment-above-attributes
            accept-comment-above-statement
            allow-dbg-in-tests
-- 
cgit 1.4.1-3-g733a5


From 008ba2b8bb711b8ee725a808f3d9ee65c2a1dce3 Mon Sep 17 00:00:00 2001
From: Max Niederman <max@maxniederman.com>
Date: Sat, 3 Jun 2023 19:58:27 -0700
Subject: new lint: redundant_local

fix dogfood lints in `redundant_local`

keep `redundant_local` from running in proc macros

rewrite `redundant_local` as late pass

make redundant_local's `find_binding` more readable

pluralize `redundant_locals` name

add test for `redundant_locals` in macros

test `redundant_locals` in proc macros

use more destructuring in `redundant_locals`

fix: format redundant_locals.rs

ignore needless_pass_by_mut_ref in redundant_locals test
---
 CHANGELOG.md                         |   1 +
 clippy_lints/src/declared_lints.rs   |   1 +
 clippy_lints/src/lib.rs              |   2 +
 clippy_lints/src/redundant_locals.rs | 103 ++++++++++++++++++++++++++
 tests/ui/option_if_let_else.fixed    |   3 +-
 tests/ui/option_if_let_else.rs       |   3 +-
 tests/ui/option_if_let_else.stderr   |  46 ++++++------
 tests/ui/redundant_locals.rs         | 111 ++++++++++++++++++++++++++++
 tests/ui/redundant_locals.stderr     | 136 +++++++++++++++++++++++++++++++++++
 tests/ui/shadow.rs                   |   2 +-
 tests/ui/swap.fixed                  |   3 +-
 tests/ui/swap.rs                     |   3 +-
 tests/ui/swap.stderr                 |  34 ++++-----
 13 files changed, 403 insertions(+), 45 deletions(-)
 create mode 100644 clippy_lints/src/redundant_locals.rs
 create mode 100644 tests/ui/redundant_locals.rs
 create mode 100644 tests/ui/redundant_locals.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index fe879712130..2b53f1df7c0 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5190,6 +5190,7 @@ Released 2018-09-13
 [`redundant_else`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_else
 [`redundant_feature_names`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_feature_names
 [`redundant_field_names`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_field_names
+[`redundant_locals`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_locals
 [`redundant_pattern`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_pattern
 [`redundant_pattern_matching`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_pattern_matching
 [`redundant_pub_crate`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_pub_crate
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 830714ce7b0..e92d9fa7f63 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -561,6 +561,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::redundant_closure_call::REDUNDANT_CLOSURE_CALL_INFO,
     crate::redundant_else::REDUNDANT_ELSE_INFO,
     crate::redundant_field_names::REDUNDANT_FIELD_NAMES_INFO,
+    crate::redundant_locals::REDUNDANT_LOCALS_INFO,
     crate::redundant_pub_crate::REDUNDANT_PUB_CRATE_INFO,
     crate::redundant_slicing::DEREF_BY_SLICING_INFO,
     crate::redundant_slicing::REDUNDANT_SLICING_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 0fa5c2f1828..ca2f5191cdf 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -275,6 +275,7 @@ mod redundant_clone;
 mod redundant_closure_call;
 mod redundant_else;
 mod redundant_field_names;
+mod redundant_locals;
 mod redundant_pub_crate;
 mod redundant_slicing;
 mod redundant_static_lifetimes;
@@ -1091,6 +1092,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
             absolute_paths_allowed_crates: absolute_paths_allowed_crates.clone(),
         })
     });
+    store.register_late_pass(|_| Box::new(redundant_locals::RedundantLocals));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/redundant_locals.rs b/clippy_lints/src/redundant_locals.rs
new file mode 100644
index 00000000000..140ae837a17
--- /dev/null
+++ b/clippy_lints/src/redundant_locals.rs
@@ -0,0 +1,103 @@
+use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::is_from_proc_macro;
+use clippy_utils::ty::needs_ordered_drop;
+use rustc_hir::def::Res;
+use rustc_hir::{BindingAnnotation, ByRef, Expr, ExprKind, HirId, Local, Node, Pat, PatKind, QPath};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_middle::lint::in_external_macro;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::symbol::Ident;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for redundant redefinitions of local bindings.
+    ///
+    /// ### Why is this bad?
+    /// Redundant redefinitions of local bindings do not change behavior and are likely to be unintended.
+    ///
+    /// Note that although these bindings do not affect your code's meaning, they _may_ affect `rustc`'s stack allocation.
+    ///
+    /// ### Example
+    /// ```rust
+    /// let a = 0;
+    /// let a = a;
+    ///
+    /// fn foo(b: i32) {
+    ///    let b = b;
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// let a = 0;
+    /// // no redefinition with the same name
+    ///
+    /// fn foo(b: i32) {
+    ///   // no redefinition with the same name
+    /// }
+    /// ```
+    #[clippy::version = "1.72.0"]
+    pub REDUNDANT_LOCALS,
+    correctness,
+    "redundant redefinition of a local binding"
+}
+declare_lint_pass!(RedundantLocals => [REDUNDANT_LOCALS]);
+
+impl<'tcx> LateLintPass<'tcx> for RedundantLocals {
+    fn check_local(&mut self, cx: &LateContext<'tcx>, local: &'tcx Local<'tcx>) {
+        if_chain! {
+            // the pattern is a single by-value binding
+            if let PatKind::Binding(BindingAnnotation(ByRef::No, mutability), _, ident, None) = local.pat.kind;
+            // the binding is not type-ascribed
+            if local.ty.is_none();
+            // the expression is a resolved path
+            if let Some(expr) = local.init;
+            if let ExprKind::Path(qpath @ QPath::Resolved(None, path)) = expr.kind;
+            // the path is a single segment equal to the local's name
+            if let [last_segment] = path.segments;
+            if last_segment.ident == ident;
+            // resolve the path to its defining binding pattern
+            if let Res::Local(binding_id) = cx.qpath_res(&qpath, expr.hir_id);
+            if let Node::Pat(binding_pat) = cx.tcx.hir().get(binding_id);
+            // the previous binding has the same mutability
+            if find_binding(binding_pat, ident).unwrap().1 == mutability;
+            // the local does not affect the code's drop behavior
+            if !affects_drop_behavior(cx, binding_id, local.hir_id, expr);
+            // the local is user-controlled
+            if !in_external_macro(cx.sess(), local.span);
+            if !is_from_proc_macro(cx, expr);
+            then {
+                span_lint_and_help(
+                    cx,
+                    REDUNDANT_LOCALS,
+                    vec![binding_pat.span, local.span],
+                    "redundant redefinition of a binding",
+                    None,
+                    &format!("remove the redefinition of `{ident}`"),
+                );
+            }
+        }
+    }
+}
+
+/// Find the annotation of a binding introduced by a pattern, or `None` if it's not introduced.
+fn find_binding(pat: &Pat<'_>, name: Ident) -> Option<BindingAnnotation> {
+    let mut ret = None;
+
+    pat.each_binding_or_first(&mut |annotation, _, _, ident| {
+        if ident == name {
+            ret = Some(annotation);
+        }
+    });
+
+    ret
+}
+
+/// Check if a rebinding of a local affects the code's drop behavior.
+fn affects_drop_behavior<'tcx>(cx: &LateContext<'tcx>, bind: HirId, rebind: HirId, rebind_expr: &Expr<'tcx>) -> bool {
+    let hir = cx.tcx.hir();
+
+    // the rebinding is in a different scope than the original binding
+    // and the type of the binding cares about drop order
+    hir.get_enclosing_scope(bind) != hir.get_enclosing_scope(rebind)
+        && needs_ordered_drop(cx, cx.typeck_results().expr_ty(rebind_expr))
+}
diff --git a/tests/ui/option_if_let_else.fixed b/tests/ui/option_if_let_else.fixed
index 8e59e4375d2..6fee3cce619 100644
--- a/tests/ui/option_if_let_else.fixed
+++ b/tests/ui/option_if_let_else.fixed
@@ -5,7 +5,8 @@
     clippy::redundant_closure,
     clippy::ref_option_ref,
     clippy::equatable_if_let,
-    clippy::let_unit_value
+    clippy::let_unit_value,
+    clippy::redundant_locals
 )]
 
 fn bad1(string: Option<&str>) -> (bool, &str) {
diff --git a/tests/ui/option_if_let_else.rs b/tests/ui/option_if_let_else.rs
index e72edf2a8e3..4b3cf948a1b 100644
--- a/tests/ui/option_if_let_else.rs
+++ b/tests/ui/option_if_let_else.rs
@@ -5,7 +5,8 @@
     clippy::redundant_closure,
     clippy::ref_option_ref,
     clippy::equatable_if_let,
-    clippy::let_unit_value
+    clippy::let_unit_value,
+    clippy::redundant_locals
 )]
 
 fn bad1(string: Option<&str>) -> (bool, &str) {
diff --git a/tests/ui/option_if_let_else.stderr b/tests/ui/option_if_let_else.stderr
index aa2da217400..350f0f07e13 100644
--- a/tests/ui/option_if_let_else.stderr
+++ b/tests/ui/option_if_let_else.stderr
@@ -1,5 +1,5 @@
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:12:5
+  --> $DIR/option_if_let_else.rs:13:5
    |
 LL | /     if let Some(x) = string {
 LL | |         (true, x)
@@ -11,19 +11,19 @@ LL | |     }
    = note: `-D clippy::option-if-let-else` implied by `-D warnings`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:30:13
+  --> $DIR/option_if_let_else.rs:31:13
    |
 LL |     let _ = if let Some(s) = *string { s.len() } else { 0 };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `string.map_or(0, |s| s.len())`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:31:13
+  --> $DIR/option_if_let_else.rs:32:13
    |
 LL |     let _ = if let Some(s) = &num { s } else { &0 };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `num.as_ref().map_or(&0, |s| s)`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:32:13
+  --> $DIR/option_if_let_else.rs:33:13
    |
 LL |       let _ = if let Some(s) = &mut num {
    |  _____________^
@@ -43,13 +43,13 @@ LL ~     });
    |
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:38:13
+  --> $DIR/option_if_let_else.rs:39:13
    |
 LL |     let _ = if let Some(ref s) = num { s } else { &0 };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `num.as_ref().map_or(&0, |s| s)`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:39:13
+  --> $DIR/option_if_let_else.rs:40:13
    |
 LL |       let _ = if let Some(mut s) = num {
    |  _____________^
@@ -69,7 +69,7 @@ LL ~     });
    |
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:45:13
+  --> $DIR/option_if_let_else.rs:46:13
    |
 LL |       let _ = if let Some(ref mut s) = num {
    |  _____________^
@@ -89,7 +89,7 @@ LL ~     });
    |
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:54:5
+  --> $DIR/option_if_let_else.rs:55:5
    |
 LL | /     if let Some(x) = arg {
 LL | |         let y = x * x;
@@ -108,7 +108,7 @@ LL +     })
    |
 
 error: use Option::map_or_else instead of an if let/else
-  --> $DIR/option_if_let_else.rs:67:13
+  --> $DIR/option_if_let_else.rs:68:13
    |
 LL |       let _ = if let Some(x) = arg {
    |  _____________^
@@ -120,7 +120,7 @@ LL | |     };
    | |_____^ help: try: `arg.map_or_else(|| side_effect(), |x| x)`
 
 error: use Option::map_or_else instead of an if let/else
-  --> $DIR/option_if_let_else.rs:76:13
+  --> $DIR/option_if_let_else.rs:77:13
    |
 LL |       let _ = if let Some(x) = arg {
    |  _____________^
@@ -143,7 +143,7 @@ LL ~     }, |x| x * x * x * x);
    |
 
 error: use Option::map_or_else instead of an if let/else
-  --> $DIR/option_if_let_else.rs:109:13
+  --> $DIR/option_if_let_else.rs:110:13
    |
 LL | /             if let Some(idx) = s.find('.') {
 LL | |                 vec![s[..idx].to_string(), s[idx..].to_string()]
@@ -153,7 +153,7 @@ LL | |             }
    | |_____________^ help: try: `s.find('.').map_or_else(|| vec![s.to_string()], |idx| vec![s[..idx].to_string(), s[idx..].to_string()])`
 
 error: use Option::map_or_else instead of an if let/else
-  --> $DIR/option_if_let_else.rs:120:5
+  --> $DIR/option_if_let_else.rs:121:5
    |
 LL | /     if let Ok(binding) = variable {
 LL | |         println!("Ok {binding}");
@@ -172,13 +172,13 @@ LL +     })
    |
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:142:13
+  --> $DIR/option_if_let_else.rs:143:13
    |
 LL |     let _ = if let Some(x) = optional { x + 2 } else { 5 };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `optional.map_or(5, |x| x + 2)`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:152:13
+  --> $DIR/option_if_let_else.rs:153:13
    |
 LL |       let _ = if let Some(x) = Some(0) {
    |  _____________^
@@ -200,13 +200,13 @@ LL ~         });
    |
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:180:13
+  --> $DIR/option_if_let_else.rs:181:13
    |
 LL |     let _ = if let Some(x) = Some(0) { s.len() + x } else { s.len() };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Some(0).map_or(s.len(), |x| s.len() + x)`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:184:13
+  --> $DIR/option_if_let_else.rs:185:13
    |
 LL |       let _ = if let Some(x) = Some(0) {
    |  _____________^
@@ -226,7 +226,7 @@ LL ~     });
    |
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:223:13
+  --> $DIR/option_if_let_else.rs:224:13
    |
 LL |       let _ = match s {
    |  _____________^
@@ -236,7 +236,7 @@ LL | |     };
    | |_____^ help: try: `s.map_or(1, |string| string.len())`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:227:13
+  --> $DIR/option_if_let_else.rs:228:13
    |
 LL |       let _ = match Some(10) {
    |  _____________^
@@ -246,7 +246,7 @@ LL | |     };
    | |_____^ help: try: `Some(10).map_or(5, |a| a + 1)`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:233:13
+  --> $DIR/option_if_let_else.rs:234:13
    |
 LL |       let _ = match res {
    |  _____________^
@@ -256,7 +256,7 @@ LL | |     };
    | |_____^ help: try: `res.map_or(1, |a| a + 1)`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:237:13
+  --> $DIR/option_if_let_else.rs:238:13
    |
 LL |       let _ = match res {
    |  _____________^
@@ -266,13 +266,13 @@ LL | |     };
    | |_____^ help: try: `res.map_or(1, |a| a + 1)`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:241:13
+  --> $DIR/option_if_let_else.rs:242:13
    |
 LL |     let _ = if let Ok(a) = res { a + 1 } else { 5 };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `res.map_or(5, |a| a + 1)`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:258:9
+  --> $DIR/option_if_let_else.rs:259:9
    |
 LL | /         match initial {
 LL | |             Some(value) => do_something(value),
@@ -281,7 +281,7 @@ LL | |         }
    | |_________^ help: try: `initial.as_ref().map_or({}, |value| do_something(value))`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:265:9
+  --> $DIR/option_if_let_else.rs:266:9
    |
 LL | /         match initial {
 LL | |             Some(value) => do_something2(value),
diff --git a/tests/ui/redundant_locals.rs b/tests/ui/redundant_locals.rs
new file mode 100644
index 00000000000..e74c78a50b6
--- /dev/null
+++ b/tests/ui/redundant_locals.rs
@@ -0,0 +1,111 @@
+//@aux-build:proc_macros.rs:proc-macro
+#![allow(unused, clippy::no_effect, clippy::needless_pass_by_ref_mut)]
+#![warn(clippy::redundant_locals)]
+
+extern crate proc_macros;
+use proc_macros::{external, with_span};
+
+fn main() {}
+
+fn immutable() {
+    let x = 1;
+    let x = x;
+}
+
+fn mutable() {
+    let mut x = 1;
+    let mut x = x;
+}
+
+fn upgraded_mutability() {
+    let x = 1;
+    let mut x = x;
+}
+
+fn downgraded_mutability() {
+    let mut x = 1;
+    let x = x;
+}
+
+fn coercion(par: &mut i32) {
+    let par: &i32 = par;
+
+    let x: &mut i32 = &mut 1;
+    let x: &i32 = x;
+}
+
+fn parameter(x: i32) {
+    let x = x;
+}
+
+fn many() {
+    let x = 1;
+    let x = x;
+    let x = x;
+    let x = x;
+    let x = x;
+}
+
+fn interleaved() {
+    let a = 1;
+    let b = 2;
+    let a = a;
+    let b = b;
+}
+
+fn block() {
+    {
+        let x = 1;
+        let x = x;
+    }
+}
+
+fn closure() {
+    || {
+        let x = 1;
+        let x = x;
+    };
+    |x: i32| {
+        let x = x;
+    };
+}
+
+fn consequential_drop_order() {
+    use std::sync::Mutex;
+
+    let mutex = Mutex::new(1);
+    let guard = mutex.lock().unwrap();
+
+    {
+        let guard = guard;
+    }
+}
+
+fn inconsequential_drop_order() {
+    let x = 1;
+
+    {
+        let x = x;
+    }
+}
+
+fn macros() {
+    macro_rules! rebind {
+        ($x:ident) => {
+            let $x = 1;
+            let $x = $x;
+        };
+    }
+
+    rebind!(x);
+
+    external! {
+        let x = 1;
+        let x = x;
+    }
+    with_span! {
+        span
+        let x = 1;
+        let x = x;
+    }
+}
diff --git a/tests/ui/redundant_locals.stderr b/tests/ui/redundant_locals.stderr
new file mode 100644
index 00000000000..df07dd2f453
--- /dev/null
+++ b/tests/ui/redundant_locals.stderr
@@ -0,0 +1,136 @@
+error: redundant redefinition of a binding
+  --> $DIR/redundant_locals.rs:11:9
+   |
+LL |     let x = 1;
+   |         ^
+LL |     let x = x;
+   |     ^^^^^^^^^^
+   |
+   = help: remove the redefinition of `x`
+   = note: `-D clippy::redundant-locals` implied by `-D warnings`
+
+error: redundant redefinition of a binding
+  --> $DIR/redundant_locals.rs:16:9
+   |
+LL |     let mut x = 1;
+   |         ^^^^^
+LL |     let mut x = x;
+   |     ^^^^^^^^^^^^^^
+   |
+   = help: remove the redefinition of `x`
+
+error: redundant redefinition of a binding
+  --> $DIR/redundant_locals.rs:37:14
+   |
+LL | fn parameter(x: i32) {
+   |              ^
+LL |     let x = x;
+   |     ^^^^^^^^^^
+   |
+   = help: remove the redefinition of `x`
+
+error: redundant redefinition of a binding
+  --> $DIR/redundant_locals.rs:42:9
+   |
+LL |     let x = 1;
+   |         ^
+LL |     let x = x;
+   |     ^^^^^^^^^^
+   |
+   = help: remove the redefinition of `x`
+
+error: redundant redefinition of a binding
+  --> $DIR/redundant_locals.rs:43:9
+   |
+LL |     let x = x;
+   |         ^
+LL |     let x = x;
+   |     ^^^^^^^^^^
+   |
+   = help: remove the redefinition of `x`
+
+error: redundant redefinition of a binding
+  --> $DIR/redundant_locals.rs:44:9
+   |
+LL |     let x = x;
+   |         ^
+LL |     let x = x;
+   |     ^^^^^^^^^^
+   |
+   = help: remove the redefinition of `x`
+
+error: redundant redefinition of a binding
+  --> $DIR/redundant_locals.rs:45:9
+   |
+LL |     let x = x;
+   |         ^
+LL |     let x = x;
+   |     ^^^^^^^^^^
+   |
+   = help: remove the redefinition of `x`
+
+error: redundant redefinition of a binding
+  --> $DIR/redundant_locals.rs:50:9
+   |
+LL |     let a = 1;
+   |         ^
+LL |     let b = 2;
+LL |     let a = a;
+   |     ^^^^^^^^^^
+   |
+   = help: remove the redefinition of `a`
+
+error: redundant redefinition of a binding
+  --> $DIR/redundant_locals.rs:51:9
+   |
+LL |     let b = 2;
+   |         ^
+LL |     let a = a;
+LL |     let b = b;
+   |     ^^^^^^^^^^
+   |
+   = help: remove the redefinition of `b`
+
+error: redundant redefinition of a binding
+  --> $DIR/redundant_locals.rs:58:13
+   |
+LL |         let x = 1;
+   |             ^
+LL |         let x = x;
+   |         ^^^^^^^^^^
+   |
+   = help: remove the redefinition of `x`
+
+error: redundant redefinition of a binding
+  --> $DIR/redundant_locals.rs:65:13
+   |
+LL |         let x = 1;
+   |             ^
+LL |         let x = x;
+   |         ^^^^^^^^^^
+   |
+   = help: remove the redefinition of `x`
+
+error: redundant redefinition of a binding
+  --> $DIR/redundant_locals.rs:68:6
+   |
+LL |     |x: i32| {
+   |      ^
+LL |         let x = x;
+   |         ^^^^^^^^^^
+   |
+   = help: remove the redefinition of `x`
+
+error: redundant redefinition of a binding
+  --> $DIR/redundant_locals.rs:85:9
+   |
+LL |     let x = 1;
+   |         ^
+...
+LL |         let x = x;
+   |         ^^^^^^^^^^
+   |
+   = help: remove the redefinition of `x`
+
+error: aborting due to 13 previous errors
+
diff --git a/tests/ui/shadow.rs b/tests/ui/shadow.rs
index 9be8c5e59d0..4d22b7d2ad0 100644
--- a/tests/ui/shadow.rs
+++ b/tests/ui/shadow.rs
@@ -1,7 +1,7 @@
 //@aux-build:proc_macro_derive.rs:proc-macro
 
 #![warn(clippy::shadow_same, clippy::shadow_reuse, clippy::shadow_unrelated)]
-#![allow(clippy::let_unit_value, clippy::needless_if)]
+#![allow(clippy::let_unit_value, clippy::needless_if, clippy::redundant_locals)]
 
 extern crate proc_macro_derive;
 
diff --git a/tests/ui/swap.fixed b/tests/ui/swap.fixed
index 22f904e3fd9..7b74a83b6df 100644
--- a/tests/ui/swap.fixed
+++ b/tests/ui/swap.fixed
@@ -11,7 +11,8 @@
     unused_assignments,
     unused_variables,
     clippy::let_and_return,
-    clippy::useless_vec
+    clippy::useless_vec,
+    clippy::redundant_locals
 )]
 
 struct Foo(u32);
diff --git a/tests/ui/swap.rs b/tests/ui/swap.rs
index ada64f89e6d..93855cd7b5c 100644
--- a/tests/ui/swap.rs
+++ b/tests/ui/swap.rs
@@ -11,7 +11,8 @@
     unused_assignments,
     unused_variables,
     clippy::let_and_return,
-    clippy::useless_vec
+    clippy::useless_vec,
+    clippy::redundant_locals
 )]
 
 struct Foo(u32);
diff --git a/tests/ui/swap.stderr b/tests/ui/swap.stderr
index a3b9c2b744c..1097b29bba0 100644
--- a/tests/ui/swap.stderr
+++ b/tests/ui/swap.stderr
@@ -1,5 +1,5 @@
 error: this looks like you are swapping `bar.a` and `bar.b` manually
-  --> $DIR/swap.rs:28:5
+  --> $DIR/swap.rs:29:5
    |
 LL | /     let temp = bar.a;
 LL | |     bar.a = bar.b;
@@ -10,7 +10,7 @@ LL | |     bar.b = temp;
    = note: `-D clippy::manual-swap` implied by `-D warnings`
 
 error: this looks like you are swapping elements of `foo` manually
-  --> $DIR/swap.rs:40:5
+  --> $DIR/swap.rs:41:5
    |
 LL | /     let temp = foo[0];
 LL | |     foo[0] = foo[1];
@@ -18,7 +18,7 @@ LL | |     foo[1] = temp;
    | |__________________^ help: try: `foo.swap(0, 1);`
 
 error: this looks like you are swapping elements of `foo` manually
-  --> $DIR/swap.rs:49:5
+  --> $DIR/swap.rs:50:5
    |
 LL | /     let temp = foo[0];
 LL | |     foo[0] = foo[1];
@@ -26,7 +26,7 @@ LL | |     foo[1] = temp;
    | |__________________^ help: try: `foo.swap(0, 1);`
 
 error: this looks like you are swapping elements of `foo` manually
-  --> $DIR/swap.rs:68:5
+  --> $DIR/swap.rs:69:5
    |
 LL | /     let temp = foo[0];
 LL | |     foo[0] = foo[1];
@@ -34,7 +34,7 @@ LL | |     foo[1] = temp;
    | |__________________^ help: try: `foo.swap(0, 1);`
 
 error: this looks like you are swapping `a` and `b` manually
-  --> $DIR/swap.rs:79:5
+  --> $DIR/swap.rs:80:5
    |
 LL | /     a ^= b;
 LL | |     b ^= a;
@@ -42,7 +42,7 @@ LL | |     a ^= b;
    | |___________^ help: try: `std::mem::swap(&mut a, &mut b);`
 
 error: this looks like you are swapping `bar.a` and `bar.b` manually
-  --> $DIR/swap.rs:87:5
+  --> $DIR/swap.rs:88:5
    |
 LL | /     bar.a ^= bar.b;
 LL | |     bar.b ^= bar.a;
@@ -50,7 +50,7 @@ LL | |     bar.a ^= bar.b;
    | |___________________^ help: try: `std::mem::swap(&mut bar.a, &mut bar.b);`
 
 error: this looks like you are swapping elements of `foo` manually
-  --> $DIR/swap.rs:95:5
+  --> $DIR/swap.rs:96:5
    |
 LL | /     foo[0] ^= foo[1];
 LL | |     foo[1] ^= foo[0];
@@ -58,7 +58,7 @@ LL | |     foo[0] ^= foo[1];
    | |_____________________^ help: try: `foo.swap(0, 1);`
 
 error: this looks like you are swapping `foo[0][1]` and `bar[1][0]` manually
-  --> $DIR/swap.rs:124:5
+  --> $DIR/swap.rs:125:5
    |
 LL | /     let temp = foo[0][1];
 LL | |     foo[0][1] = bar[1][0];
@@ -68,7 +68,7 @@ LL | |     bar[1][0] = temp;
    = note: or maybe you should use `std::mem::replace`?
 
 error: this looks like you are swapping `a` and `b` manually
-  --> $DIR/swap.rs:138:7
+  --> $DIR/swap.rs:139:7
    |
 LL |       ; let t = a;
    |  _______^
@@ -79,7 +79,7 @@ LL | |     b = t;
    = note: or maybe you should use `std::mem::replace`?
 
 error: this looks like you are swapping `c.0` and `a` manually
-  --> $DIR/swap.rs:147:7
+  --> $DIR/swap.rs:148:7
    |
 LL |       ; let t = c.0;
    |  _______^
@@ -90,7 +90,7 @@ LL | |     a = t;
    = note: or maybe you should use `std::mem::replace`?
 
 error: this looks like you are swapping `b` and `a` manually
-  --> $DIR/swap.rs:173:5
+  --> $DIR/swap.rs:174:5
    |
 LL | /     let t = b;
 LL | |     b = a;
@@ -100,7 +100,7 @@ LL | |     a = t;
    = note: or maybe you should use `std::mem::replace`?
 
 error: this looks like you are trying to swap `a` and `b`
-  --> $DIR/swap.rs:135:5
+  --> $DIR/swap.rs:136:5
    |
 LL | /     a = b;
 LL | |     b = a;
@@ -110,7 +110,7 @@ LL | |     b = a;
    = note: `-D clippy::almost-swapped` implied by `-D warnings`
 
 error: this looks like you are trying to swap `c.0` and `a`
-  --> $DIR/swap.rs:144:5
+  --> $DIR/swap.rs:145:5
    |
 LL | /     c.0 = a;
 LL | |     a = c.0;
@@ -119,7 +119,7 @@ LL | |     a = c.0;
    = note: or maybe you should use `std::mem::replace`?
 
 error: this looks like you are trying to swap `a` and `b`
-  --> $DIR/swap.rs:151:5
+  --> $DIR/swap.rs:152:5
    |
 LL | /     let a = b;
 LL | |     let b = a;
@@ -128,7 +128,7 @@ LL | |     let b = a;
    = note: or maybe you should use `std::mem::replace`?
 
 error: this looks like you are trying to swap `d` and `c`
-  --> $DIR/swap.rs:156:5
+  --> $DIR/swap.rs:157:5
    |
 LL | /     d = c;
 LL | |     c = d;
@@ -137,7 +137,7 @@ LL | |     c = d;
    = note: or maybe you should use `std::mem::replace`?
 
 error: this looks like you are trying to swap `a` and `b`
-  --> $DIR/swap.rs:160:5
+  --> $DIR/swap.rs:161:5
    |
 LL | /     let a = b;
 LL | |     b = a;
@@ -146,7 +146,7 @@ LL | |     b = a;
    = note: or maybe you should use `std::mem::replace`?
 
 error: this looks like you are swapping `s.0.x` and `s.0.y` manually
-  --> $DIR/swap.rs:208:5
+  --> $DIR/swap.rs:209:5
    |
 LL | /     let t = s.0.x;
 LL | |     s.0.x = s.0.y;
-- 
cgit 1.4.1-3-g733a5


From da93ee86e5708cd991d7e21012ff2a2a980b0b2d Mon Sep 17 00:00:00 2001
From: Catherine <114838443+Centri3@users.noreply.github.com>
Date: Mon, 26 Jun 2023 00:20:31 -0500
Subject: Make `comparison_to_empty` work on `if let`/`let` chains

refactor it
---
 clippy_lints/src/len_zero.rs        | 30 ++++++++++--
 clippy_utils/src/higher.rs          | 92 +++++++++++++++++++++++++++++++++++++
 tests/ui/comparison_to_empty.fixed  | 12 ++++-
 tests/ui/comparison_to_empty.rs     | 12 ++++-
 tests/ui/comparison_to_empty.stderr | 40 ++++++++++++++--
 5 files changed, 176 insertions(+), 10 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/len_zero.rs b/clippy_lints/src/len_zero.rs
index e64d46bd6e3..a707921ce7e 100644
--- a/clippy_lints/src/len_zero.rs
+++ b/clippy_lints/src/len_zero.rs
@@ -7,11 +7,10 @@ use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::def::Res;
 use rustc_hir::def_id::{DefId, DefIdSet};
-use rustc_hir::lang_items::LangItem;
 use rustc_hir::{
     AssocItemKind, BinOpKind, Expr, ExprKind, FnRetTy, GenericArg, GenericBound, ImplItem, ImplItemKind,
-    ImplicitSelfKind, Item, ItemKind, Mutability, Node, PathSegment, PrimTy, QPath, TraitItemRef, TyKind,
-    TypeBindingKind,
+    ImplicitSelfKind, Item, ItemKind, LangItem, Mutability, Node, PatKind, PathSegment, PrimTy, QPath, TraitItemRef,
+    TyKind, TypeBindingKind,
 };
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{self, AssocKind, FnSig, Ty};
@@ -168,6 +167,31 @@ impl<'tcx> LateLintPass<'tcx> for LenZero {
             return;
         }
 
+        if let ExprKind::Let(lt) = expr.kind
+            && has_is_empty(cx, lt.init)
+            && match lt.pat.kind {
+                PatKind::Slice([], _, []) => true,
+                PatKind::Lit(lit) if is_empty_string(lit) => true,
+                _ => false,
+            }
+        {
+            let mut applicability = Applicability::MachineApplicable;
+
+            let lit1 = peel_ref_operators(cx, lt.init);
+            let lit_str =
+                Sugg::hir_with_context(cx, lit1, lt.span.ctxt(), "_", &mut applicability).maybe_par();
+
+            span_lint_and_sugg(
+                cx,
+                COMPARISON_TO_EMPTY,
+                lt.span,
+                "comparison to empty slice using `if let`",
+                "using `is_empty` is clearer and more explicit",
+                format!("{lit_str}.is_empty()"),
+                applicability,
+            );
+        }
+
         if let ExprKind::Binary(Spanned { node: cmp, .. }, left, right) = expr.kind {
             // expr.span might contains parenthesis, see issue #10529
             let actual_span = left.span.with_hi(right.span.hi());
diff --git a/clippy_utils/src/higher.rs b/clippy_utils/src/higher.rs
index 802adbd4d2d..312e6ea40c5 100644
--- a/clippy_utils/src/higher.rs
+++ b/clippy_utils/src/higher.rs
@@ -5,6 +5,7 @@
 use crate::consts::{constant_simple, Constant};
 use crate::ty::is_type_diagnostic_item;
 use crate::{is_expn_of, match_def_path, paths};
+use hir::BinOpKind;
 use if_chain::if_chain;
 use rustc_ast::ast;
 use rustc_hir as hir;
@@ -137,6 +138,97 @@ impl<'hir> IfLet<'hir> {
     }
 }
 
+/// A `let` chain, like `if true && let Some(true) = x {}`
+#[derive(Debug)]
+pub struct LetChain<'hir> {
+    pub conds: Vec<IfOrIfLetInChain<'hir>>,
+    pub if_then: &'hir Expr<'hir>,
+    pub if_else: Option<&'hir Expr<'hir>>,
+}
+
+impl<'hir> LetChain<'hir> {
+    pub fn hir(expr: &Expr<'hir>) -> Option<Self> {
+        if let ExprKind::If(cond, if_then, if_else) = expr.kind {
+            let mut conds = vec![];
+            let mut cursor = cond;
+            while let ExprKind::Binary(binop, lhs, rhs) = cursor.kind
+                && let BinOpKind::And = binop.node
+            {
+                cursor = lhs;
+                conds.push(IfOrIfLetInChain::hir(rhs)?);
+            }
+
+            // The final lhs cannot be `&&`
+            conds.push(IfOrIfLetInChain::hir(cursor)?);
+
+            return Some(Self {
+                conds,
+                if_then,
+                if_else,
+            });
+        }
+
+        None
+    }
+}
+
+/// An `if let` or `if` expression in a let chain.
+#[derive(Debug)]
+pub enum IfOrIfLetInChain<'hir> {
+    If(IfInChain<'hir>),
+    IfLet(IfLetInChain<'hir>),
+}
+
+impl<'hir> IfOrIfLetInChain<'hir> {
+    pub fn hir(expr: &Expr<'hir>) -> Option<Self> {
+        match expr.kind {
+            ExprKind::DropTemps(cond) => Some(IfInChain { cond }.into()),
+            ExprKind::Let(hir::Let {
+                pat: let_pat,
+                init: let_expr,
+                span: let_span,
+                ..
+            }) => Some(
+                IfLetInChain {
+                    let_pat,
+                    let_expr,
+                    let_span: *let_span,
+                }
+                .into(),
+            ),
+            _ => None,
+        }
+    }
+}
+
+impl<'hir> From<IfInChain<'hir>> for IfOrIfLetInChain<'hir> {
+    fn from(value: IfInChain<'hir>) -> Self {
+        Self::If(value)
+    }
+}
+
+impl<'hir> From<IfLetInChain<'hir>> for IfOrIfLetInChain<'hir> {
+    fn from(value: IfLetInChain<'hir>) -> Self {
+        Self::IfLet(value)
+    }
+}
+
+/// An `if` expression in a let chain.
+#[derive(Debug)]
+pub struct IfInChain<'hir> {
+    pub cond: &'hir Expr<'hir>,
+}
+
+/// An `if let` expression in a let chain.
+#[derive(Debug)]
+pub struct IfLetInChain<'hir> {
+    pub let_span: Span,
+    /// `if let` pattern
+    pub let_pat: &'hir Pat<'hir>,
+    /// `if let` scrutinee
+    pub let_expr: &'hir Expr<'hir>,
+}
+
 /// An `if let` or `match` expression. Useful for lints that trigger on one or the other.
 #[derive(Debug)]
 pub enum IfLetOrMatch<'hir> {
diff --git a/tests/ui/comparison_to_empty.fixed b/tests/ui/comparison_to_empty.fixed
index c92dd509ebb..af219eed0b8 100644
--- a/tests/ui/comparison_to_empty.fixed
+++ b/tests/ui/comparison_to_empty.fixed
@@ -1,7 +1,8 @@
 //@run-rustfix
 
 #![warn(clippy::comparison_to_empty)]
-#![allow(clippy::useless_vec)]
+#![allow(clippy::borrow_deref_ref, clippy::needless_if, clippy::useless_vec)]
+#![feature(let_chains)]
 
 fn main() {
     // Disallow comparisons to empty
@@ -12,6 +13,11 @@ fn main() {
     let v = vec![0];
     let _ = v.is_empty();
     let _ = !v.is_empty();
+    if (*v).is_empty() {}
+    let s = [0].as_slice();
+    if s.is_empty() {}
+    if s.is_empty() {}
+    if s.is_empty() && s.is_empty() {}
 
     // Allow comparisons to non-empty
     let s = String::new();
@@ -21,4 +27,8 @@ fn main() {
     let v = vec![0];
     let _ = v == [0];
     let _ = v != [0];
+    if let [0] = &*v {}
+    let s = [0].as_slice();
+    if let [0] = s {}
+    if let [0] = &*s && s == [0] {}
 }
diff --git a/tests/ui/comparison_to_empty.rs b/tests/ui/comparison_to_empty.rs
index b3489714380..21e65184d50 100644
--- a/tests/ui/comparison_to_empty.rs
+++ b/tests/ui/comparison_to_empty.rs
@@ -1,7 +1,8 @@
 //@run-rustfix
 
 #![warn(clippy::comparison_to_empty)]
-#![allow(clippy::useless_vec)]
+#![allow(clippy::borrow_deref_ref, clippy::needless_if, clippy::useless_vec)]
+#![feature(let_chains)]
 
 fn main() {
     // Disallow comparisons to empty
@@ -12,6 +13,11 @@ fn main() {
     let v = vec![0];
     let _ = v == [];
     let _ = v != [];
+    if let [] = &*v {}
+    let s = [0].as_slice();
+    if let [] = s {}
+    if let [] = &*s {}
+    if let [] = &*s && s == [] {}
 
     // Allow comparisons to non-empty
     let s = String::new();
@@ -21,4 +27,8 @@ fn main() {
     let v = vec![0];
     let _ = v == [0];
     let _ = v != [0];
+    if let [0] = &*v {}
+    let s = [0].as_slice();
+    if let [0] = s {}
+    if let [0] = &*s && s == [0] {}
 }
diff --git a/tests/ui/comparison_to_empty.stderr b/tests/ui/comparison_to_empty.stderr
index cc09b17eb89..f29782ed80d 100644
--- a/tests/ui/comparison_to_empty.stderr
+++ b/tests/ui/comparison_to_empty.stderr
@@ -1,5 +1,5 @@
 error: comparison to empty slice
-  --> $DIR/comparison_to_empty.rs:9:13
+  --> $DIR/comparison_to_empty.rs:10:13
    |
 LL |     let _ = s == "";
    |             ^^^^^^^ help: using `is_empty` is clearer and more explicit: `s.is_empty()`
@@ -7,22 +7,52 @@ LL |     let _ = s == "";
    = note: `-D clippy::comparison-to-empty` implied by `-D warnings`
 
 error: comparison to empty slice
-  --> $DIR/comparison_to_empty.rs:10:13
+  --> $DIR/comparison_to_empty.rs:11:13
    |
 LL |     let _ = s != "";
    |             ^^^^^^^ help: using `!is_empty` is clearer and more explicit: `!s.is_empty()`
 
 error: comparison to empty slice
-  --> $DIR/comparison_to_empty.rs:13:13
+  --> $DIR/comparison_to_empty.rs:14:13
    |
 LL |     let _ = v == [];
    |             ^^^^^^^ help: using `is_empty` is clearer and more explicit: `v.is_empty()`
 
 error: comparison to empty slice
-  --> $DIR/comparison_to_empty.rs:14:13
+  --> $DIR/comparison_to_empty.rs:15:13
    |
 LL |     let _ = v != [];
    |             ^^^^^^^ help: using `!is_empty` is clearer and more explicit: `!v.is_empty()`
 
-error: aborting due to 4 previous errors
+error: comparison to empty slice using `if let`
+  --> $DIR/comparison_to_empty.rs:16:8
+   |
+LL |     if let [] = &*v {}
+   |        ^^^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `(*v).is_empty()`
+
+error: comparison to empty slice using `if let`
+  --> $DIR/comparison_to_empty.rs:18:8
+   |
+LL |     if let [] = s {}
+   |        ^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `s.is_empty()`
+
+error: comparison to empty slice using `if let`
+  --> $DIR/comparison_to_empty.rs:19:8
+   |
+LL |     if let [] = &*s {}
+   |        ^^^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `s.is_empty()`
+
+error: comparison to empty slice using `if let`
+  --> $DIR/comparison_to_empty.rs:20:8
+   |
+LL |     if let [] = &*s && s == [] {}
+   |        ^^^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `s.is_empty()`
+
+error: comparison to empty slice
+  --> $DIR/comparison_to_empty.rs:20:24
+   |
+LL |     if let [] = &*s && s == [] {}
+   |                        ^^^^^^^ help: using `is_empty` is clearer and more explicit: `s.is_empty()`
+
+error: aborting due to 9 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From ae5d391d21fb227da007da44286e43ce61f10f38 Mon Sep 17 00:00:00 2001
From: Catherine Flores <catherine.3.flores@gmail.com>
Date: Sat, 22 Jul 2023 05:57:39 -0500
Subject: Remove `LetChain`

---
 clippy_lints/src/len_zero.rs |  2 +-
 clippy_utils/src/higher.rs   | 92 --------------------------------------------
 2 files changed, 1 insertion(+), 93 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/len_zero.rs b/clippy_lints/src/len_zero.rs
index a707921ce7e..d4236926a6c 100644
--- a/clippy_lints/src/len_zero.rs
+++ b/clippy_lints/src/len_zero.rs
@@ -170,7 +170,7 @@ impl<'tcx> LateLintPass<'tcx> for LenZero {
         if let ExprKind::Let(lt) = expr.kind
             && has_is_empty(cx, lt.init)
             && match lt.pat.kind {
-                PatKind::Slice([], _, []) => true,
+                PatKind::Slice([], None, []) => true,
                 PatKind::Lit(lit) if is_empty_string(lit) => true,
                 _ => false,
             }
diff --git a/clippy_utils/src/higher.rs b/clippy_utils/src/higher.rs
index 312e6ea40c5..802adbd4d2d 100644
--- a/clippy_utils/src/higher.rs
+++ b/clippy_utils/src/higher.rs
@@ -5,7 +5,6 @@
 use crate::consts::{constant_simple, Constant};
 use crate::ty::is_type_diagnostic_item;
 use crate::{is_expn_of, match_def_path, paths};
-use hir::BinOpKind;
 use if_chain::if_chain;
 use rustc_ast::ast;
 use rustc_hir as hir;
@@ -138,97 +137,6 @@ impl<'hir> IfLet<'hir> {
     }
 }
 
-/// A `let` chain, like `if true && let Some(true) = x {}`
-#[derive(Debug)]
-pub struct LetChain<'hir> {
-    pub conds: Vec<IfOrIfLetInChain<'hir>>,
-    pub if_then: &'hir Expr<'hir>,
-    pub if_else: Option<&'hir Expr<'hir>>,
-}
-
-impl<'hir> LetChain<'hir> {
-    pub fn hir(expr: &Expr<'hir>) -> Option<Self> {
-        if let ExprKind::If(cond, if_then, if_else) = expr.kind {
-            let mut conds = vec![];
-            let mut cursor = cond;
-            while let ExprKind::Binary(binop, lhs, rhs) = cursor.kind
-                && let BinOpKind::And = binop.node
-            {
-                cursor = lhs;
-                conds.push(IfOrIfLetInChain::hir(rhs)?);
-            }
-
-            // The final lhs cannot be `&&`
-            conds.push(IfOrIfLetInChain::hir(cursor)?);
-
-            return Some(Self {
-                conds,
-                if_then,
-                if_else,
-            });
-        }
-
-        None
-    }
-}
-
-/// An `if let` or `if` expression in a let chain.
-#[derive(Debug)]
-pub enum IfOrIfLetInChain<'hir> {
-    If(IfInChain<'hir>),
-    IfLet(IfLetInChain<'hir>),
-}
-
-impl<'hir> IfOrIfLetInChain<'hir> {
-    pub fn hir(expr: &Expr<'hir>) -> Option<Self> {
-        match expr.kind {
-            ExprKind::DropTemps(cond) => Some(IfInChain { cond }.into()),
-            ExprKind::Let(hir::Let {
-                pat: let_pat,
-                init: let_expr,
-                span: let_span,
-                ..
-            }) => Some(
-                IfLetInChain {
-                    let_pat,
-                    let_expr,
-                    let_span: *let_span,
-                }
-                .into(),
-            ),
-            _ => None,
-        }
-    }
-}
-
-impl<'hir> From<IfInChain<'hir>> for IfOrIfLetInChain<'hir> {
-    fn from(value: IfInChain<'hir>) -> Self {
-        Self::If(value)
-    }
-}
-
-impl<'hir> From<IfLetInChain<'hir>> for IfOrIfLetInChain<'hir> {
-    fn from(value: IfLetInChain<'hir>) -> Self {
-        Self::IfLet(value)
-    }
-}
-
-/// An `if` expression in a let chain.
-#[derive(Debug)]
-pub struct IfInChain<'hir> {
-    pub cond: &'hir Expr<'hir>,
-}
-
-/// An `if let` expression in a let chain.
-#[derive(Debug)]
-pub struct IfLetInChain<'hir> {
-    pub let_span: Span,
-    /// `if let` pattern
-    pub let_pat: &'hir Pat<'hir>,
-    /// `if let` scrutinee
-    pub let_expr: &'hir Expr<'hir>,
-}
-
 /// An `if let` or `match` expression. Useful for lints that trigger on one or the other.
 #[derive(Debug)]
 pub enum IfLetOrMatch<'hir> {
-- 
cgit 1.4.1-3-g733a5


From 51b57723d18aec1b9dd26bbb1482d1f29f6d18cf Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Wed, 14 Jun 2023 13:51:31 -0500
Subject: new lint `redundant_guards`

---
 CHANGELOG.md                                  |   1 +
 clippy_lints/src/declared_lints.rs            |   1 +
 clippy_lints/src/loops/utils.rs               |   4 +-
 clippy_lints/src/matches/mod.rs               |  33 +++++
 clippy_lints/src/matches/redundant_guards.rs  | 190 ++++++++++++++++++++++++++
 tests/ui/match_expr_like_matches_macro.fixed  |   3 +-
 tests/ui/match_expr_like_matches_macro.rs     |   3 +-
 tests/ui/match_expr_like_matches_macro.stderr |  28 ++--
 tests/ui/redundant_guards.fixed               | 133 ++++++++++++++++++
 tests/ui/redundant_guards.rs                  | 133 ++++++++++++++++++
 tests/ui/redundant_guards.stderr              |  98 +++++++++++++
 tests/ui/shadow.rs                            |   7 +-
 tests/ui/shadow.stderr                        |  92 ++++++-------
 tests/ui/single_match.fixed                   |   1 +
 tests/ui/single_match.rs                      |   1 +
 tests/ui/single_match.stderr                  |  36 ++---
 16 files changed, 681 insertions(+), 83 deletions(-)
 create mode 100644 clippy_lints/src/matches/redundant_guards.rs
 create mode 100644 tests/ui/redundant_guards.fixed
 create mode 100644 tests/ui/redundant_guards.rs
 create mode 100644 tests/ui/redundant_guards.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 2b53f1df7c0..9118c0e634f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5190,6 +5190,7 @@ Released 2018-09-13
 [`redundant_else`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_else
 [`redundant_feature_names`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_feature_names
 [`redundant_field_names`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_field_names
+[`redundant_guards`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_guards
 [`redundant_locals`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_locals
 [`redundant_pattern`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_pattern
 [`redundant_pattern_matching`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_pattern_matching
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index e92d9fa7f63..189ca5b052e 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -308,6 +308,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::matches::MATCH_WILDCARD_FOR_SINGLE_VARIANTS_INFO,
     crate::matches::MATCH_WILD_ERR_ARM_INFO,
     crate::matches::NEEDLESS_MATCH_INFO,
+    crate::matches::REDUNDANT_GUARDS_INFO,
     crate::matches::REDUNDANT_PATTERN_MATCHING_INFO,
     crate::matches::REST_PAT_IN_FULLY_BOUND_STRUCTS_INFO,
     crate::matches::SIGNIFICANT_DROP_IN_SCRUTINEE_INFO,
diff --git a/clippy_lints/src/loops/utils.rs b/clippy_lints/src/loops/utils.rs
index 28ee24309cc..6edca2d55f6 100644
--- a/clippy_lints/src/loops/utils.rs
+++ b/clippy_lints/src/loops/utils.rs
@@ -76,7 +76,7 @@ impl<'a, 'tcx> Visitor<'tcx> for IncrementVisitor<'a, 'tcx> {
                     ExprKind::Assign(lhs, _, _) if lhs.hir_id == expr.hir_id => {
                         *state = IncrementVisitorVarState::DontWarn;
                     },
-                    ExprKind::AddrOf(BorrowKind::Ref, mutability, _) if mutability == Mutability::Mut => {
+                    ExprKind::AddrOf(BorrowKind::Ref, Mutability::Mut, _) => {
                         *state = IncrementVisitorVarState::DontWarn;
                     },
                     _ => (),
@@ -226,7 +226,7 @@ impl<'a, 'tcx> Visitor<'tcx> for InitializeVisitor<'a, 'tcx> {
                             InitializeVisitorState::DontWarn
                         }
                     },
-                    ExprKind::AddrOf(BorrowKind::Ref, mutability, _) if mutability == Mutability::Mut => {
+                    ExprKind::AddrOf(BorrowKind::Ref, Mutability::Mut, _) => {
                         self.state = InitializeVisitorState::DontWarn;
                     },
                     _ => (),
diff --git a/clippy_lints/src/matches/mod.rs b/clippy_lints/src/matches/mod.rs
index d1061171e4d..6d16d188754 100644
--- a/clippy_lints/src/matches/mod.rs
+++ b/clippy_lints/src/matches/mod.rs
@@ -16,6 +16,7 @@ mod match_wild_enum;
 mod match_wild_err_arm;
 mod needless_match;
 mod overlapping_arms;
+mod redundant_guards;
 mod redundant_pattern_match;
 mod rest_pat_in_fully_bound_struct;
 mod significant_drop_in_scrutinee;
@@ -936,6 +937,36 @@ declare_clippy_lint! {
     "reimplementation of `filter`"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for unnecessary guards in match expressions.
+    ///
+    /// ### Why is this bad?
+    /// It's more complex and much less readable. Making it part of the pattern can improve
+    /// exhaustiveness checking as well.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// match x {
+    ///     Some(x) if matches!(x, Some(1)) => ..,
+    ///     Some(x) if x == Some(2) => ..,
+    ///     _ => todo!(),
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust,ignore
+    /// match x {
+    ///     Some(Some(1)) => ..,
+    ///     Some(Some(2)) => ..,
+    ///     _ => todo!(),
+    /// }
+    /// ```
+    #[clippy::version = "1.72.0"]
+    pub REDUNDANT_GUARDS,
+    complexity,
+    "checks for unnecessary guards in match expressions"
+}
+
 #[derive(Default)]
 pub struct Matches {
     msrv: Msrv,
@@ -978,6 +1009,7 @@ impl_lint_pass!(Matches => [
     TRY_ERR,
     MANUAL_MAP,
     MANUAL_FILTER,
+    REDUNDANT_GUARDS,
 ]);
 
 impl<'tcx> LateLintPass<'tcx> for Matches {
@@ -1025,6 +1057,7 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
                     needless_match::check_match(cx, ex, arms, expr);
                     match_on_vec_items::check(cx, ex);
                     match_str_case_mismatch::check(cx, ex, arms);
+                    redundant_guards::check(cx, arms);
 
                     if !in_constant(cx, expr.hir_id) {
                         manual_unwrap_or::check(cx, expr, ex, arms);
diff --git a/clippy_lints/src/matches/redundant_guards.rs b/clippy_lints/src/matches/redundant_guards.rs
new file mode 100644
index 00000000000..6383326aa38
--- /dev/null
+++ b/clippy_lints/src/matches/redundant_guards.rs
@@ -0,0 +1,190 @@
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::path_to_local;
+use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::visitors::{for_each_expr, is_local_used};
+use rustc_errors::Applicability;
+use rustc_hir::def::{DefKind, Res};
+use rustc_hir::{Arm, BinOpKind, Expr, ExprKind, Guard, MatchSource, Node, Pat, PatKind};
+use rustc_lint::LateContext;
+use rustc_span::Span;
+use std::ops::ControlFlow;
+
+use super::REDUNDANT_GUARDS;
+
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'tcx>]) {
+    for outer_arm in arms {
+        let Some(guard) = outer_arm.guard else {
+            continue;
+        };
+
+        // `Some(x) if matches!(x, y)`
+        if let Guard::If(if_expr) = guard
+            && let ExprKind::Match(
+                scrutinee,
+                [
+                    arm,
+                    Arm {
+                        pat: Pat {
+                            kind: PatKind::Wild,
+                            ..
+                        },
+                        ..
+                    },
+                ],
+                MatchSource::Normal,
+            ) = if_expr.kind
+        {
+            emit_redundant_guards(
+                cx,
+                outer_arm,
+                if_expr.span,
+                scrutinee,
+                arm.pat.span,
+                arm.guard,
+            );
+        }
+        // `Some(x) if let Some(2) = x`
+        else if let Guard::IfLet(let_expr) = guard {
+            emit_redundant_guards(
+                cx,
+                outer_arm,
+                let_expr.span,
+                let_expr.init,
+                let_expr.pat.span,
+                None,
+            );
+        }
+        // `Some(x) if x == Some(2)`
+        else if let Guard::If(if_expr) = guard
+            && let ExprKind::Binary(bin_op, local, pat) = if_expr.kind
+            && matches!(bin_op.node, BinOpKind::Eq)
+            && expr_can_be_pat(cx, pat)
+            // Ensure they have the same type. If they don't, we'd need deref coercion which isn't
+            // possible (currently) in a pattern. In some cases, you can use something like
+            // `as_deref` or similar but in general, we shouldn't lint this as it'd create an
+            // extraordinary amount of FPs.
+            //
+            // This isn't necessary in the other two checks, as they must be a pattern already.
+            && cx.typeck_results().expr_ty(local) == cx.typeck_results().expr_ty(pat)
+        {
+            emit_redundant_guards(
+                cx,
+                outer_arm,
+                if_expr.span,
+                local,
+                pat.span,
+                None,
+            );
+        }
+    }
+}
+
+fn get_pat_binding<'tcx>(cx: &LateContext<'tcx>, guard_expr: &Expr<'_>, outer_arm: &Arm<'tcx>) -> Option<(Span, bool)> {
+    if let Some(local) = path_to_local(guard_expr) && !is_local_used(cx, outer_arm.body, local) {
+        let mut span = None;
+        let mut multiple_bindings = false;
+        // `each_binding` gives the `HirId` of the `Pat` itself, not the binding
+        outer_arm.pat.walk(|pat| {
+            if let PatKind::Binding(_, hir_id, _, _) = pat.kind
+                && hir_id == local
+                && span.replace(pat.span).is_some()
+            {
+                multiple_bindings = true;
+                return false;
+            }
+
+            true
+        });
+
+        // Ignore bindings from or patterns, like `First(x) | Second(x, _) | Third(x, _, _)`
+        if !multiple_bindings {
+            return span.map(|span| {
+                (
+                    span,
+                    !matches!(cx.tcx.hir().get_parent(local), Node::PatField(_)),
+                )
+            });
+        }
+    }
+
+    None
+}
+
+fn emit_redundant_guards<'tcx>(
+    cx: &LateContext<'tcx>,
+    outer_arm: &Arm<'tcx>,
+    guard_span: Span,
+    local: &Expr<'_>,
+    pat_span: Span,
+    inner_guard: Option<Guard<'_>>,
+) {
+    let mut app = Applicability::MaybeIncorrect;
+    let Some((pat_binding, can_use_shorthand)) = get_pat_binding(cx, local, outer_arm) else {
+        return;
+    };
+
+    span_lint_and_then(
+        cx,
+        REDUNDANT_GUARDS,
+        guard_span.source_callsite(),
+        "redundant guard",
+        |diag| {
+            let binding_replacement = snippet_with_applicability(cx, pat_span, "<binding_repl>", &mut app);
+            diag.multipart_suggestion_verbose(
+                "try",
+                vec![
+                    if can_use_shorthand {
+                        (pat_binding, binding_replacement.into_owned())
+                    } else {
+                        (pat_binding.shrink_to_hi(), format!(": {binding_replacement}"))
+                    },
+                    (
+                        guard_span.source_callsite().with_lo(outer_arm.pat.span.hi()),
+                        inner_guard.map_or_else(String::new, |guard| {
+                            let (prefix, span) = match guard {
+                                Guard::If(e) => ("if", e.span),
+                                Guard::IfLet(l) => ("if let", l.span),
+                            };
+
+                            format!(
+                                " {prefix} {}",
+                                snippet_with_applicability(cx, span, "<guard>", &mut app),
+                            )
+                        }),
+                    ),
+                ],
+                app,
+            );
+        },
+    );
+}
+
+/// Checks if the given `Expr` can also be represented as a `Pat`.
+fn expr_can_be_pat(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+    for_each_expr(expr, |expr| {
+        if match expr.kind {
+            ExprKind::ConstBlock(..) => cx.tcx.features().inline_const_pat,
+            ExprKind::Call(c, ..) if let ExprKind::Path(qpath) = c.kind => {
+                // Allow ctors
+                matches!(cx.qpath_res(&qpath, c.hir_id), Res::Def(DefKind::Ctor(..), ..))
+            },
+            ExprKind::Path(qpath) => {
+                matches!(
+                    cx.qpath_res(&qpath, expr.hir_id),
+                    Res::Def(DefKind::Struct | DefKind::Enum | DefKind::Ctor(..), ..),
+                )
+            },
+            ExprKind::AddrOf(..)
+            | ExprKind::Array(..)
+            | ExprKind::Tup(..)
+            | ExprKind::Struct(..)
+            | ExprKind::Lit(..) => true,
+            _ => false,
+        } {
+            return ControlFlow::Continue(());
+        }
+
+        ControlFlow::Break(())
+    })
+    .is_none()
+}
diff --git a/tests/ui/match_expr_like_matches_macro.fixed b/tests/ui/match_expr_like_matches_macro.fixed
index 60f59066173..f19149cf9de 100644
--- a/tests/ui/match_expr_like_matches_macro.fixed
+++ b/tests/ui/match_expr_like_matches_macro.fixed
@@ -5,7 +5,8 @@
     unreachable_patterns,
     dead_code,
     clippy::equatable_if_let,
-    clippy::needless_borrowed_reference
+    clippy::needless_borrowed_reference,
+    clippy::redundant_guards
 )]
 
 fn main() {
diff --git a/tests/ui/match_expr_like_matches_macro.rs b/tests/ui/match_expr_like_matches_macro.rs
index afdf1069f5e..8f4e58981ea 100644
--- a/tests/ui/match_expr_like_matches_macro.rs
+++ b/tests/ui/match_expr_like_matches_macro.rs
@@ -5,7 +5,8 @@
     unreachable_patterns,
     dead_code,
     clippy::equatable_if_let,
-    clippy::needless_borrowed_reference
+    clippy::needless_borrowed_reference,
+    clippy::redundant_guards
 )]
 
 fn main() {
diff --git a/tests/ui/match_expr_like_matches_macro.stderr b/tests/ui/match_expr_like_matches_macro.stderr
index c8c1e5da05f..b57b26284ff 100644
--- a/tests/ui/match_expr_like_matches_macro.stderr
+++ b/tests/ui/match_expr_like_matches_macro.stderr
@@ -1,5 +1,5 @@
 error: match expression looks like `matches!` macro
-  --> $DIR/match_expr_like_matches_macro.rs:15:14
+  --> $DIR/match_expr_like_matches_macro.rs:16:14
    |
 LL |       let _y = match x {
    |  ______________^
@@ -11,7 +11,7 @@ LL | |     };
    = note: `-D clippy::match-like-matches-macro` implied by `-D warnings`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/match_expr_like_matches_macro.rs:21:14
+  --> $DIR/match_expr_like_matches_macro.rs:22:14
    |
 LL |       let _w = match x {
    |  ______________^
@@ -23,7 +23,7 @@ LL | |     };
    = note: `-D clippy::redundant-pattern-matching` implied by `-D warnings`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/match_expr_like_matches_macro.rs:27:14
+  --> $DIR/match_expr_like_matches_macro.rs:28:14
    |
 LL |       let _z = match x {
    |  ______________^
@@ -33,7 +33,7 @@ LL | |     };
    | |_____^ help: try: `x.is_none()`
 
 error: match expression looks like `matches!` macro
-  --> $DIR/match_expr_like_matches_macro.rs:33:15
+  --> $DIR/match_expr_like_matches_macro.rs:34:15
    |
 LL |       let _zz = match x {
    |  _______________^
@@ -43,13 +43,13 @@ LL | |     };
    | |_____^ help: try: `!matches!(x, Some(r) if r == 0)`
 
 error: if let .. else expression looks like `matches!` macro
-  --> $DIR/match_expr_like_matches_macro.rs:39:16
+  --> $DIR/match_expr_like_matches_macro.rs:40:16
    |
 LL |     let _zzz = if let Some(5) = x { true } else { false };
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `matches!(x, Some(5))`
 
 error: match expression looks like `matches!` macro
-  --> $DIR/match_expr_like_matches_macro.rs:63:20
+  --> $DIR/match_expr_like_matches_macro.rs:64:20
    |
 LL |           let _ans = match x {
    |  ____________________^
@@ -60,7 +60,7 @@ LL | |         };
    | |_________^ help: try: `matches!(x, E::A(_) | E::B(_))`
 
 error: match expression looks like `matches!` macro
-  --> $DIR/match_expr_like_matches_macro.rs:73:20
+  --> $DIR/match_expr_like_matches_macro.rs:74:20
    |
 LL |           let _ans = match x {
    |  ____________________^
@@ -73,7 +73,7 @@ LL | |         };
    | |_________^ help: try: `matches!(x, E::A(_) | E::B(_))`
 
 error: match expression looks like `matches!` macro
-  --> $DIR/match_expr_like_matches_macro.rs:83:20
+  --> $DIR/match_expr_like_matches_macro.rs:84:20
    |
 LL |           let _ans = match x {
    |  ____________________^
@@ -84,7 +84,7 @@ LL | |         };
    | |_________^ help: try: `!matches!(x, E::B(_) | E::C)`
 
 error: match expression looks like `matches!` macro
-  --> $DIR/match_expr_like_matches_macro.rs:143:18
+  --> $DIR/match_expr_like_matches_macro.rs:144:18
    |
 LL |           let _z = match &z {
    |  __________________^
@@ -94,7 +94,7 @@ LL | |         };
    | |_________^ help: try: `matches!(z, Some(3))`
 
 error: match expression looks like `matches!` macro
-  --> $DIR/match_expr_like_matches_macro.rs:152:18
+  --> $DIR/match_expr_like_matches_macro.rs:153:18
    |
 LL |           let _z = match &z {
    |  __________________^
@@ -104,7 +104,7 @@ LL | |         };
    | |_________^ help: try: `matches!(&z, Some(3))`
 
 error: match expression looks like `matches!` macro
-  --> $DIR/match_expr_like_matches_macro.rs:169:21
+  --> $DIR/match_expr_like_matches_macro.rs:170:21
    |
 LL |               let _ = match &z {
    |  _____________________^
@@ -114,7 +114,7 @@ LL | |             };
    | |_____________^ help: try: `matches!(&z, AnEnum::X)`
 
 error: match expression looks like `matches!` macro
-  --> $DIR/match_expr_like_matches_macro.rs:183:20
+  --> $DIR/match_expr_like_matches_macro.rs:184:20
    |
 LL |           let _res = match &val {
    |  ____________________^
@@ -124,7 +124,7 @@ LL | |         };
    | |_________^ help: try: `matches!(&val, &Some(ref _a))`
 
 error: match expression looks like `matches!` macro
-  --> $DIR/match_expr_like_matches_macro.rs:195:20
+  --> $DIR/match_expr_like_matches_macro.rs:196:20
    |
 LL |           let _res = match &val {
    |  ____________________^
@@ -134,7 +134,7 @@ LL | |         };
    | |_________^ help: try: `matches!(&val, &Some(ref _a))`
 
 error: match expression looks like `matches!` macro
-  --> $DIR/match_expr_like_matches_macro.rs:253:14
+  --> $DIR/match_expr_like_matches_macro.rs:254:14
    |
 LL |       let _y = match Some(5) {
    |  ______________^
diff --git a/tests/ui/redundant_guards.fixed b/tests/ui/redundant_guards.fixed
new file mode 100644
index 00000000000..77ac7666864
--- /dev/null
+++ b/tests/ui/redundant_guards.fixed
@@ -0,0 +1,133 @@
+//@run-rustfix
+//@aux-build:proc_macros.rs:proc-macro
+#![feature(if_let_guard)]
+#![allow(clippy::no_effect, unused)]
+#![warn(clippy::redundant_guards)]
+
+#[macro_use]
+extern crate proc_macros;
+
+struct A(u32);
+
+struct B {
+    e: Option<A>,
+}
+
+struct C(u32, u32);
+
+fn main() {
+    let c = C(1, 2);
+    match c {
+        C(x, 1) => ..,
+        _ => todo!(),
+    };
+
+    let x = Some(Some(1));
+    match x {
+        Some(Some(1)) if true => ..,
+        Some(Some(1)) => {
+            println!("a");
+            ..
+        },
+        Some(Some(1)) => ..,
+        Some(Some(2)) => ..,
+        // Don't lint, since x is used in the body
+        Some(x) if let Some(1) = x => {
+            x;
+            ..
+        }
+        _ => todo!(),
+    };
+    let y = 1;
+    match x {
+        // Don't inline these, since y is not from the pat
+        Some(x) if matches!(y, 1 if true) => ..,
+        Some(x) if let 1 = y => ..,
+        Some(x) if y == 2 => ..,
+        _ => todo!(),
+    };
+    let a = A(1);
+    match a {
+        _ if a.0 == 1 => {},
+        _ => todo!(),
+    }
+    let b = B { e: Some(A(0)) };
+    match b {
+        B { e: Some(A(2)) } => ..,
+        _ => todo!(),
+    };
+    // Do not lint, since we cannot represent this as a pattern (at least, without a conversion)
+    let v = Some(vec![1u8, 2, 3]);
+    match v {
+        Some(x) if x == [1] => {},
+        _ => {},
+    }
+
+    external! {
+        let x = Some(Some(1));
+        match x {
+            Some(x) if let Some(1) = x => ..,
+            _ => todo!(),
+        };
+    }
+    with_span! {
+        span
+        let x = Some(Some(1));
+        match x {
+            Some(x) if let Some(1) = x => ..,
+            _ => todo!(),
+        };
+    }
+}
+
+enum E {
+    A(&'static str),
+    B(&'static str),
+    C(&'static str),
+}
+
+fn i() {
+    match E::A("") {
+        // Do not lint
+        E::A(x) | E::B(x) | E::C(x) if x == "from an or pattern" => {},
+        E::A("not from an or pattern") => {},
+        _ => {},
+    };
+}
+
+fn h(v: Option<u32>) {
+    match v {
+        Some(0) => ..,
+        _ => ..,
+    };
+}
+
+// Do not lint
+
+fn f(s: Option<std::ffi::OsString>) {
+    match s {
+        Some(x) if x == "a" => {},
+        _ => {},
+    }
+}
+
+struct S {
+    a: usize,
+}
+
+impl PartialEq for S {
+    fn eq(&self, _: &Self) -> bool {
+        true
+    }
+}
+
+impl Eq for S {}
+
+static CONST_S: S = S { a: 1 };
+
+fn g(opt_s: Option<S>) {
+    match opt_s {
+        Some(x) if x == CONST_S => {},
+        _ => {},
+    }
+}
diff --git a/tests/ui/redundant_guards.rs b/tests/ui/redundant_guards.rs
new file mode 100644
index 00000000000..b072e4ea14d
--- /dev/null
+++ b/tests/ui/redundant_guards.rs
@@ -0,0 +1,133 @@
+//@run-rustfix
+//@aux-build:proc_macros.rs:proc-macro
+#![feature(if_let_guard)]
+#![allow(clippy::no_effect, unused)]
+#![warn(clippy::redundant_guards)]
+
+#[macro_use]
+extern crate proc_macros;
+
+struct A(u32);
+
+struct B {
+    e: Option<A>,
+}
+
+struct C(u32, u32);
+
+fn main() {
+    let c = C(1, 2);
+    match c {
+        C(x, y) if let 1 = y => ..,
+        _ => todo!(),
+    };
+
+    let x = Some(Some(1));
+    match x {
+        Some(x) if matches!(x, Some(1) if true) => ..,
+        Some(x) if matches!(x, Some(1)) => {
+            println!("a");
+            ..
+        },
+        Some(x) if let Some(1) = x => ..,
+        Some(x) if x == Some(2) => ..,
+        // Don't lint, since x is used in the body
+        Some(x) if let Some(1) = x => {
+            x;
+            ..
+        }
+        _ => todo!(),
+    };
+    let y = 1;
+    match x {
+        // Don't inline these, since y is not from the pat
+        Some(x) if matches!(y, 1 if true) => ..,
+        Some(x) if let 1 = y => ..,
+        Some(x) if y == 2 => ..,
+        _ => todo!(),
+    };
+    let a = A(1);
+    match a {
+        _ if a.0 == 1 => {},
+        _ => todo!(),
+    }
+    let b = B { e: Some(A(0)) };
+    match b {
+        B { e } if matches!(e, Some(A(2))) => ..,
+        _ => todo!(),
+    };
+    // Do not lint, since we cannot represent this as a pattern (at least, without a conversion)
+    let v = Some(vec![1u8, 2, 3]);
+    match v {
+        Some(x) if x == [1] => {},
+        _ => {},
+    }
+
+    external! {
+        let x = Some(Some(1));
+        match x {
+            Some(x) if let Some(1) = x => ..,
+            _ => todo!(),
+        };
+    }
+    with_span! {
+        span
+        let x = Some(Some(1));
+        match x {
+            Some(x) if let Some(1) = x => ..,
+            _ => todo!(),
+        };
+    }
+}
+
+enum E {
+    A(&'static str),
+    B(&'static str),
+    C(&'static str),
+}
+
+fn i() {
+    match E::A("") {
+        // Do not lint
+        E::A(x) | E::B(x) | E::C(x) if x == "from an or pattern" => {},
+        E::A(y) if y == "not from an or pattern" => {},
+        _ => {},
+    };
+}
+
+fn h(v: Option<u32>) {
+    match v {
+        x if matches!(x, Some(0)) => ..,
+        _ => ..,
+    };
+}
+
+// Do not lint
+
+fn f(s: Option<std::ffi::OsString>) {
+    match s {
+        Some(x) if x == "a" => {},
+        _ => {},
+    }
+}
+
+struct S {
+    a: usize,
+}
+
+impl PartialEq for S {
+    fn eq(&self, _: &Self) -> bool {
+        true
+    }
+}
+
+impl Eq for S {}
+
+static CONST_S: S = S { a: 1 };
+
+fn g(opt_s: Option<S>) {
+    match opt_s {
+        Some(x) if x == CONST_S => {},
+        _ => {},
+    }
+}
diff --git a/tests/ui/redundant_guards.stderr b/tests/ui/redundant_guards.stderr
new file mode 100644
index 00000000000..c2a92071d1d
--- /dev/null
+++ b/tests/ui/redundant_guards.stderr
@@ -0,0 +1,98 @@
+error: redundant guard
+  --> $DIR/redundant_guards.rs:21:20
+   |
+LL |         C(x, y) if let 1 = y => ..,
+   |                    ^^^^^^^^^
+   |
+   = note: `-D clippy::redundant-guards` implied by `-D warnings`
+help: try
+   |
+LL -         C(x, y) if let 1 = y => ..,
+LL +         C(x, 1) => ..,
+   |
+
+error: redundant guard
+  --> $DIR/redundant_guards.rs:27:20
+   |
+LL |         Some(x) if matches!(x, Some(1) if true) => ..,
+   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: try
+   |
+LL |         Some(Some(1)) if true => ..,
+   |              ~~~~~~~  ~~~~~~~
+
+error: redundant guard
+  --> $DIR/redundant_guards.rs:28:20
+   |
+LL |         Some(x) if matches!(x, Some(1)) => {
+   |                    ^^^^^^^^^^^^^^^^^^^^
+   |
+help: try
+   |
+LL -         Some(x) if matches!(x, Some(1)) => {
+LL +         Some(Some(1)) => {
+   |
+
+error: redundant guard
+  --> $DIR/redundant_guards.rs:32:20
+   |
+LL |         Some(x) if let Some(1) = x => ..,
+   |                    ^^^^^^^^^^^^^^^
+   |
+help: try
+   |
+LL -         Some(x) if let Some(1) = x => ..,
+LL +         Some(Some(1)) => ..,
+   |
+
+error: redundant guard
+  --> $DIR/redundant_guards.rs:33:20
+   |
+LL |         Some(x) if x == Some(2) => ..,
+   |                    ^^^^^^^^^^^^
+   |
+help: try
+   |
+LL -         Some(x) if x == Some(2) => ..,
+LL +         Some(Some(2)) => ..,
+   |
+
+error: redundant guard
+  --> $DIR/redundant_guards.rs:56:20
+   |
+LL |         B { e } if matches!(e, Some(A(2))) => ..,
+   |                    ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: try
+   |
+LL -         B { e } if matches!(e, Some(A(2))) => ..,
+LL +         B { e: Some(A(2)) } => ..,
+   |
+
+error: redundant guard
+  --> $DIR/redundant_guards.rs:93:20
+   |
+LL |         E::A(y) if y == "not from an or pattern" => {},
+   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: try
+   |
+LL -         E::A(y) if y == "not from an or pattern" => {},
+LL +         E::A("not from an or pattern") => {},
+   |
+
+error: redundant guard
+  --> $DIR/redundant_guards.rs:100:14
+   |
+LL |         x if matches!(x, Some(0)) => ..,
+   |              ^^^^^^^^^^^^^^^^^^^^
+   |
+help: try
+   |
+LL -         x if matches!(x, Some(0)) => ..,
+LL +         Some(0) => ..,
+   |
+
+error: aborting due to 8 previous errors
+
diff --git a/tests/ui/shadow.rs b/tests/ui/shadow.rs
index 4d22b7d2ad0..1b40a43d019 100644
--- a/tests/ui/shadow.rs
+++ b/tests/ui/shadow.rs
@@ -1,7 +1,12 @@
 //@aux-build:proc_macro_derive.rs:proc-macro
 
 #![warn(clippy::shadow_same, clippy::shadow_reuse, clippy::shadow_unrelated)]
-#![allow(clippy::let_unit_value, clippy::needless_if, clippy::redundant_locals)]
+#![allow(
+    clippy::let_unit_value,
+    clippy::needless_if,
+    clippy::redundant_guards,
+    clippy::redundant_locals
+)]
 
 extern crate proc_macro_derive;
 
diff --git a/tests/ui/shadow.stderr b/tests/ui/shadow.stderr
index 8321f6df224..88b02f53be1 100644
--- a/tests/ui/shadow.stderr
+++ b/tests/ui/shadow.stderr
@@ -1,278 +1,278 @@
 error: `x` is shadowed by itself in `x`
-  --> $DIR/shadow.rs:19:9
+  --> $DIR/shadow.rs:24:9
    |
 LL |     let x = x;
    |         ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:18:9
+  --> $DIR/shadow.rs:23:9
    |
 LL |     let x = 1;
    |         ^
    = note: `-D clippy::shadow-same` implied by `-D warnings`
 
 error: `mut x` is shadowed by itself in `&x`
-  --> $DIR/shadow.rs:20:13
+  --> $DIR/shadow.rs:25:13
    |
 LL |     let mut x = &x;
    |             ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:19:9
+  --> $DIR/shadow.rs:24:9
    |
 LL |     let x = x;
    |         ^
 
 error: `x` is shadowed by itself in `&mut x`
-  --> $DIR/shadow.rs:21:9
+  --> $DIR/shadow.rs:26:9
    |
 LL |     let x = &mut x;
    |         ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:20:9
+  --> $DIR/shadow.rs:25:9
    |
 LL |     let mut x = &x;
    |         ^^^^^
 
 error: `x` is shadowed by itself in `*x`
-  --> $DIR/shadow.rs:22:9
+  --> $DIR/shadow.rs:27:9
    |
 LL |     let x = *x;
    |         ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:21:9
+  --> $DIR/shadow.rs:26:9
    |
 LL |     let x = &mut x;
    |         ^
 
 error: `x` is shadowed
-  --> $DIR/shadow.rs:27:9
+  --> $DIR/shadow.rs:32:9
    |
 LL |     let x = x.0;
    |         ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:26:9
+  --> $DIR/shadow.rs:31:9
    |
 LL |     let x = ([[0]], ());
    |         ^
    = note: `-D clippy::shadow-reuse` implied by `-D warnings`
 
 error: `x` is shadowed
-  --> $DIR/shadow.rs:28:9
+  --> $DIR/shadow.rs:33:9
    |
 LL |     let x = x[0];
    |         ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:27:9
+  --> $DIR/shadow.rs:32:9
    |
 LL |     let x = x.0;
    |         ^
 
 error: `x` is shadowed
-  --> $DIR/shadow.rs:29:10
+  --> $DIR/shadow.rs:34:10
    |
 LL |     let [x] = x;
    |          ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:28:9
+  --> $DIR/shadow.rs:33:9
    |
 LL |     let x = x[0];
    |         ^
 
 error: `x` is shadowed
-  --> $DIR/shadow.rs:30:9
+  --> $DIR/shadow.rs:35:9
    |
 LL |     let x = Some(x);
    |         ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:29:10
+  --> $DIR/shadow.rs:34:10
    |
 LL |     let [x] = x;
    |          ^
 
 error: `x` is shadowed
-  --> $DIR/shadow.rs:31:9
+  --> $DIR/shadow.rs:36:9
    |
 LL |     let x = foo(x);
    |         ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:30:9
+  --> $DIR/shadow.rs:35:9
    |
 LL |     let x = Some(x);
    |         ^
 
 error: `x` is shadowed
-  --> $DIR/shadow.rs:32:9
+  --> $DIR/shadow.rs:37:9
    |
 LL |     let x = || x;
    |         ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:31:9
+  --> $DIR/shadow.rs:36:9
    |
 LL |     let x = foo(x);
    |         ^
 
 error: `x` is shadowed
-  --> $DIR/shadow.rs:33:9
+  --> $DIR/shadow.rs:38:9
    |
 LL |     let x = Some(1).map(|_| x)?;
    |         ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:32:9
+  --> $DIR/shadow.rs:37:9
    |
 LL |     let x = || x;
    |         ^
 
 error: `y` is shadowed
-  --> $DIR/shadow.rs:35:9
+  --> $DIR/shadow.rs:40:9
    |
 LL |     let y = match y {
    |         ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:34:9
+  --> $DIR/shadow.rs:39:9
    |
 LL |     let y = 1;
    |         ^
 
 error: `x` shadows a previous, unrelated binding
-  --> $DIR/shadow.rs:50:9
+  --> $DIR/shadow.rs:55:9
    |
 LL |     let x = 2;
    |         ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:49:9
+  --> $DIR/shadow.rs:54:9
    |
 LL |     let x = 1;
    |         ^
    = note: `-D clippy::shadow-unrelated` implied by `-D warnings`
 
 error: `x` shadows a previous, unrelated binding
-  --> $DIR/shadow.rs:55:13
+  --> $DIR/shadow.rs:60:13
    |
 LL |         let x = 1;
    |             ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:54:10
+  --> $DIR/shadow.rs:59:10
    |
 LL |     fn f(x: u32) {
    |          ^
 
 error: `x` shadows a previous, unrelated binding
-  --> $DIR/shadow.rs:60:14
+  --> $DIR/shadow.rs:65:14
    |
 LL |         Some(x) => {
    |              ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:57:9
+  --> $DIR/shadow.rs:62:9
    |
 LL |     let x = 1;
    |         ^
 
 error: `x` shadows a previous, unrelated binding
-  --> $DIR/shadow.rs:61:17
+  --> $DIR/shadow.rs:66:17
    |
 LL |             let x = 1;
    |                 ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:60:14
+  --> $DIR/shadow.rs:65:14
    |
 LL |         Some(x) => {
    |              ^
 
 error: `x` shadows a previous, unrelated binding
-  --> $DIR/shadow.rs:65:17
+  --> $DIR/shadow.rs:70:17
    |
 LL |     if let Some(x) = Some(1) {}
    |                 ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:57:9
+  --> $DIR/shadow.rs:62:9
    |
 LL |     let x = 1;
    |         ^
 
 error: `x` shadows a previous, unrelated binding
-  --> $DIR/shadow.rs:66:20
+  --> $DIR/shadow.rs:71:20
    |
 LL |     while let Some(x) = Some(1) {}
    |                    ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:57:9
+  --> $DIR/shadow.rs:62:9
    |
 LL |     let x = 1;
    |         ^
 
 error: `x` shadows a previous, unrelated binding
-  --> $DIR/shadow.rs:67:15
+  --> $DIR/shadow.rs:72:15
    |
 LL |     let _ = |[x]: [u32; 1]| {
    |               ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:57:9
+  --> $DIR/shadow.rs:62:9
    |
 LL |     let x = 1;
    |         ^
 
 error: `x` shadows a previous, unrelated binding
-  --> $DIR/shadow.rs:68:13
+  --> $DIR/shadow.rs:73:13
    |
 LL |         let x = 1;
    |             ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:67:15
+  --> $DIR/shadow.rs:72:15
    |
 LL |     let _ = |[x]: [u32; 1]| {
    |               ^
 
 error: `y` is shadowed
-  --> $DIR/shadow.rs:71:17
+  --> $DIR/shadow.rs:76:17
    |
 LL |     if let Some(y) = y {}
    |                 ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:70:9
+  --> $DIR/shadow.rs:75:9
    |
 LL |     let y = Some(1);
    |         ^
 
 error: `_b` shadows a previous, unrelated binding
-  --> $DIR/shadow.rs:107:9
+  --> $DIR/shadow.rs:112:9
    |
 LL |     let _b = _a;
    |         ^^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:106:28
+  --> $DIR/shadow.rs:111:28
    |
 LL | pub async fn foo2(_a: i32, _b: i64) {
    |                            ^^
 
 error: `x` shadows a previous, unrelated binding
-  --> $DIR/shadow.rs:113:21
+  --> $DIR/shadow.rs:118:21
    |
 LL |         if let Some(x) = Some(1) { x } else { 1 }
    |                     ^
    |
 note: previous binding is here
-  --> $DIR/shadow.rs:112:13
+  --> $DIR/shadow.rs:117:13
    |
 LL |         let x = 1;
    |             ^
diff --git a/tests/ui/single_match.fixed b/tests/ui/single_match.fixed
index e7b1fd6a85f..163ba94aff8 100644
--- a/tests/ui/single_match.fixed
+++ b/tests/ui/single_match.fixed
@@ -4,6 +4,7 @@
     unused,
     clippy::uninlined_format_args,
     clippy::needless_if,
+    clippy::redundant_guards,
     clippy::redundant_pattern_matching
 )]
 fn dummy() {}
diff --git a/tests/ui/single_match.rs b/tests/ui/single_match.rs
index 1515a7053e5..0dcdb125ffd 100644
--- a/tests/ui/single_match.rs
+++ b/tests/ui/single_match.rs
@@ -4,6 +4,7 @@
     unused,
     clippy::uninlined_format_args,
     clippy::needless_if,
+    clippy::redundant_guards,
     clippy::redundant_pattern_matching
 )]
 fn dummy() {}
diff --git a/tests/ui/single_match.stderr b/tests/ui/single_match.stderr
index 76f7e789589..d3536159949 100644
--- a/tests/ui/single_match.stderr
+++ b/tests/ui/single_match.stderr
@@ -1,5 +1,5 @@
 error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
-  --> $DIR/single_match.rs:14:5
+  --> $DIR/single_match.rs:15:5
    |
 LL | /     match x {
 LL | |         Some(y) => {
@@ -18,7 +18,7 @@ LL ~     };
    |
 
 error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
-  --> $DIR/single_match.rs:22:5
+  --> $DIR/single_match.rs:23:5
    |
 LL | /     match x {
 LL | |         // Note the missing block braces.
@@ -30,7 +30,7 @@ LL | |     }
    | |_____^ help: try: `if let Some(y) = x { println!("{:?}", y) }`
 
 error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
-  --> $DIR/single_match.rs:31:5
+  --> $DIR/single_match.rs:32:5
    |
 LL | /     match z {
 LL | |         (2..=3, 7..=9) => dummy(),
@@ -39,7 +39,7 @@ LL | |     };
    | |_____^ help: try: `if let (2..=3, 7..=9) = z { dummy() }`
 
 error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
-  --> $DIR/single_match.rs:60:5
+  --> $DIR/single_match.rs:61:5
    |
 LL | /     match x {
 LL | |         Some(y) => dummy(),
@@ -48,7 +48,7 @@ LL | |     };
    | |_____^ help: try: `if let Some(y) = x { dummy() }`
 
 error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
-  --> $DIR/single_match.rs:65:5
+  --> $DIR/single_match.rs:66:5
    |
 LL | /     match y {
 LL | |         Ok(y) => dummy(),
@@ -57,7 +57,7 @@ LL | |     };
    | |_____^ help: try: `if let Ok(y) = y { dummy() }`
 
 error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
-  --> $DIR/single_match.rs:72:5
+  --> $DIR/single_match.rs:73:5
    |
 LL | /     match c {
 LL | |         Cow::Borrowed(..) => dummy(),
@@ -66,7 +66,7 @@ LL | |     };
    | |_____^ help: try: `if let Cow::Borrowed(..) = c { dummy() }`
 
 error: you seem to be trying to use `match` for an equality check. Consider using `if`
-  --> $DIR/single_match.rs:93:5
+  --> $DIR/single_match.rs:94:5
    |
 LL | /     match x {
 LL | |         "test" => println!(),
@@ -75,7 +75,7 @@ LL | |     }
    | |_____^ help: try: `if x == "test" { println!() }`
 
 error: you seem to be trying to use `match` for an equality check. Consider using `if`
-  --> $DIR/single_match.rs:106:5
+  --> $DIR/single_match.rs:107:5
    |
 LL | /     match x {
 LL | |         Foo::A => println!(),
@@ -84,7 +84,7 @@ LL | |     }
    | |_____^ help: try: `if x == Foo::A { println!() }`
 
 error: you seem to be trying to use `match` for an equality check. Consider using `if`
-  --> $DIR/single_match.rs:112:5
+  --> $DIR/single_match.rs:113:5
    |
 LL | /     match x {
 LL | |         FOO_C => println!(),
@@ -93,7 +93,7 @@ LL | |     }
    | |_____^ help: try: `if x == FOO_C { println!() }`
 
 error: you seem to be trying to use `match` for an equality check. Consider using `if`
-  --> $DIR/single_match.rs:117:5
+  --> $DIR/single_match.rs:118:5
    |
 LL | /     match &&x {
 LL | |         Foo::A => println!(),
@@ -102,7 +102,7 @@ LL | |     }
    | |_____^ help: try: `if x == Foo::A { println!() }`
 
 error: you seem to be trying to use `match` for an equality check. Consider using `if`
-  --> $DIR/single_match.rs:123:5
+  --> $DIR/single_match.rs:124:5
    |
 LL | /     match &x {
 LL | |         Foo::A => println!(),
@@ -111,7 +111,7 @@ LL | |     }
    | |_____^ help: try: `if x == &Foo::A { println!() }`
 
 error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
-  --> $DIR/single_match.rs:140:5
+  --> $DIR/single_match.rs:141:5
    |
 LL | /     match x {
 LL | |         Bar::A => println!(),
@@ -120,7 +120,7 @@ LL | |     }
    | |_____^ help: try: `if let Bar::A = x { println!() }`
 
 error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
-  --> $DIR/single_match.rs:148:5
+  --> $DIR/single_match.rs:149:5
    |
 LL | /     match x {
 LL | |         None => println!(),
@@ -129,7 +129,7 @@ LL | |     };
    | |_____^ help: try: `if let None = x { println!() }`
 
 error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
-  --> $DIR/single_match.rs:170:5
+  --> $DIR/single_match.rs:171:5
    |
 LL | /     match x {
 LL | |         (Some(_), _) => {},
@@ -138,7 +138,7 @@ LL | |     }
    | |_____^ help: try: `if let (Some(_), _) = x {}`
 
 error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
-  --> $DIR/single_match.rs:176:5
+  --> $DIR/single_match.rs:177:5
    |
 LL | /     match x {
 LL | |         (Some(E::V), _) => todo!(),
@@ -147,7 +147,7 @@ LL | |     }
    | |_____^ help: try: `if let (Some(E::V), _) = x { todo!() }`
 
 error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
-  --> $DIR/single_match.rs:182:5
+  --> $DIR/single_match.rs:183:5
    |
 LL | /     match (Some(42), Some(E::V), Some(42)) {
 LL | |         (.., Some(E::V), _) => {},
@@ -156,7 +156,7 @@ LL | |     }
    | |_____^ help: try: `if let (.., Some(E::V), _) = (Some(42), Some(E::V), Some(42)) {}`
 
 error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
-  --> $DIR/single_match.rs:254:5
+  --> $DIR/single_match.rs:255:5
    |
 LL | /     match bar {
 LL | |         Some(v) => unsafe {
@@ -176,7 +176,7 @@ LL +     } }
    |
 
 error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
-  --> $DIR/single_match.rs:262:5
+  --> $DIR/single_match.rs:263:5
    |
 LL | /     match bar {
 LL | |         #[rustfmt::skip]
-- 
cgit 1.4.1-3-g733a5


From 482d5fafc9ffc7edf9236ea186883ee0346e7938 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Sat, 22 Jul 2023 14:33:36 +0200
Subject: replace HashMap with Vec, use span_lint_hir_and_then

---
 clippy_lints/src/unused_async.rs | 21 ++++++++++-----------
 tests/ui/unused_async.stderr     | 36 ++++++++++++++++++------------------
 2 files changed, 28 insertions(+), 29 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unused_async.rs b/clippy_lints/src/unused_async.rs
index 5c8c6e58914..bc7c3897a6e 100644
--- a/clippy_lints/src/unused_async.rs
+++ b/clippy_lints/src/unused_async.rs
@@ -1,6 +1,5 @@
-use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::diagnostics::span_lint_hir_and_then;
 use clippy_utils::is_def_id_trait_method;
-use rustc_data_structures::fx::FxHashMap;
 use rustc_hir::def::DefKind;
 use rustc_hir::intravisit::{walk_body, walk_expr, walk_fn, FnKind, Visitor};
 use rustc_hir::{Body, Expr, ExprKind, FnDecl, Node, YieldSource};
@@ -47,11 +46,12 @@ pub struct UnusedAsync {
     async_fns_as_value: LocalDefIdSet,
     /// Functions with unused `async`, linted post-crate after we've found all uses of local async
     /// functions
-    unused_async_fns: FxHashMap<LocalDefId, UnusedAsyncFn>,
+    unused_async_fns: Vec<UnusedAsyncFn>,
 }
 
 #[derive(Copy, Clone)]
 struct UnusedAsyncFn {
+    def_id: LocalDefId,
     fn_span: Span,
     await_in_async_block: Option<Span>,
 }
@@ -122,13 +122,11 @@ impl<'tcx> LateLintPass<'tcx> for UnusedAsync {
                 // Don't lint just yet, but store the necessary information for later.
                 // The actual linting happens in `check_crate_post`, once we've found all
                 // uses of local async functions that do require asyncness to pass typeck
-                self.unused_async_fns.insert(
+                self.unused_async_fns.push(UnusedAsyncFn {
+                    await_in_async_block: visitor.await_in_async_block,
+                    fn_span: span,
                     def_id,
-                    UnusedAsyncFn {
-                        await_in_async_block: visitor.await_in_async_block,
-                        fn_span: span,
-                    },
-                );
+                });
             }
         }
     }
@@ -164,12 +162,13 @@ impl<'tcx> LateLintPass<'tcx> for UnusedAsync {
         let iter = self
             .unused_async_fns
             .iter()
-            .filter_map(|(did, item)| (!self.async_fns_as_value.contains(did)).then_some(item));
+            .filter(|UnusedAsyncFn { def_id, .. }| (!self.async_fns_as_value.contains(def_id)));
 
         for fun in iter {
-            span_lint_and_then(
+            span_lint_hir_and_then(
                 cx,
                 UNUSED_ASYNC,
+                cx.tcx.local_def_id_to_hir_id(fun.def_id),
                 fun.fn_span,
                 "unused `async` for function with no await statements",
                 |diag| {
diff --git a/tests/ui/unused_async.stderr b/tests/ui/unused_async.stderr
index 035dffa7f13..8d9b72c4886 100644
--- a/tests/ui/unused_async.stderr
+++ b/tests/ui/unused_async.stderr
@@ -1,3 +1,21 @@
+error: unused `async` for function with no await statements
+  --> $DIR/unused_async.rs:13:5
+   |
+LL | /     async fn async_block_await() {
+LL | |         async {
+LL | |             ready(()).await;
+LL | |         };
+LL | |     }
+   | |_____^
+   |
+   = help: consider removing the `async` from this function
+note: `await` used in an async block, which does not require the enclosing function to be `async`
+  --> $DIR/unused_async.rs:15:23
+   |
+LL |             ready(()).await;
+   |                       ^^^^^
+   = note: `-D clippy::unused-async` implied by `-D warnings`
+
 error: unused `async` for function with no await statements
   --> $DIR/unused_async.rs:45:5
    |
@@ -5,7 +23,6 @@ LL |     async fn f3() {}
    |     ^^^^^^^^^^^^^^^^
    |
    = help: consider removing the `async` from this function
-   = note: `-D clippy::unused-async` implied by `-D warnings`
 
 error: unused `async` for function with no await statements
   --> $DIR/unused_async.rs:57:1
@@ -17,23 +34,6 @@ LL | | }
    |
    = help: consider removing the `async` from this function
 
-error: unused `async` for function with no await statements
-  --> $DIR/unused_async.rs:13:5
-   |
-LL | /     async fn async_block_await() {
-LL | |         async {
-LL | |             ready(()).await;
-LL | |         };
-LL | |     }
-   | |_____^
-   |
-   = help: consider removing the `async` from this function
-note: `await` used in an async block, which does not require the enclosing function to be `async`
-  --> $DIR/unused_async.rs:15:23
-   |
-LL |             ready(()).await;
-   |                       ^^^^^
-
 error: unused `async` for function with no await statements
   --> $DIR/unused_async.rs:68:5
    |
-- 
cgit 1.4.1-3-g733a5


From 99202a0b56e2ac801dfc8d6fe1a5ae539e6dbc15 Mon Sep 17 00:00:00 2001
From: Samuel Moelius <sam@moeli.us>
Date: Sat, 22 Jul 2023 11:51:44 -0400
Subject: Start addressing review comments

---
 clippy_lints/src/methods/or_fun_call.rs | 53 ++++++++++++++++-----------------
 1 file changed, 26 insertions(+), 27 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/or_fun_call.rs b/clippy_lints/src/methods/or_fun_call.rs
index d1899658b84..9fe863ecc0d 100644
--- a/clippy_lints/src/methods/or_fun_call.rs
+++ b/clippy_lints/src/methods/or_fun_call.rs
@@ -64,34 +64,33 @@ pub(super) fn check<'tcx>(
             }
         };
 
-        if_chain! {
-            if let Some(sugg) = match (name, call_expr.is_some()) {
-                ("unwrap_or", true) | ("unwrap_or_else", false) => Some("unwrap_or_default"),
-                ("or_insert", true) | ("or_insert_with", false) => Some("or_default"),
-                _ => None,
-            };
-            // needs to target Default::default in particular or be *::new and have a Default impl
-            // available
-            if (is_new(fun) && output_type_implements_default(fun))
-                || match call_expr {
-                    Some(call_expr) => is_default_equivalent(cx, call_expr),
-                    None => is_default_equivalent_call(cx, fun) || closure_body_returns_empty_to_string(cx, fun),
-                };
-            then {
-                span_lint_and_sugg(
-                    cx,
-                    UNWRAP_OR_DEFAULT,
-                    method_span.with_hi(span.hi()),
-                    &format!("use of `{name}` to construct default value"),
-                    "try",
-                    format!("{sugg}()"),
-                    Applicability::MachineApplicable,
-                );
+        let sugg = match (name, call_expr.is_some()) {
+            ("unwrap_or", true) | ("unwrap_or_else", false) => "unwrap_or_default",
+            ("or_insert", true) | ("or_insert_with", false) => "or_default",
+            _ => return false,
+        };
 
-                true
-            } else {
-                false
+        // needs to target Default::default in particular or be *::new and have a Default impl
+        // available
+        if (is_new(fun) && output_type_implements_default(fun))
+            || match call_expr {
+                Some(call_expr) => is_default_equivalent(cx, call_expr),
+                None => is_default_equivalent_call(cx, fun) || closure_body_returns_empty_to_string(cx, fun),
             }
+        {
+            span_lint_and_sugg(
+                cx,
+                UNWRAP_OR_DEFAULT,
+                method_span.with_hi(span.hi()),
+                &format!("use of `{name}` to construct default value"),
+                "try",
+                format!("{sugg}()"),
+                Applicability::MachineApplicable,
+            );
+
+            true
+        } else {
+            false
         }
     }
 
@@ -223,7 +222,7 @@ fn closure_body_returns_empty_to_string(cx: &LateContext<'_>, e: &hir::Expr<'_>)
         if body.params.is_empty()
             && let hir::Expr{ kind, .. } = &body.value
             && let hir::ExprKind::MethodCall(hir::PathSegment {ident, ..}, self_arg, _, _) = kind
-            && ident == &symbol::Ident::from_str("to_string")
+            && ident.name == sym::to_string
             && let hir::Expr{ kind, .. } = self_arg
             && let hir::ExprKind::Lit(lit) = kind
             && let ast::LitKind::Str(symbol::kw::Empty, _) = lit.node
-- 
cgit 1.4.1-3-g733a5


From 55dd8a97175e75a47e83f2255ba99ddf2eb07ab8 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Tue, 4 Jul 2023 21:49:05 -0400
Subject: Refactor `dereference.rs` Extract getting an expression's use context
 and the context's defined type as util functions.

---
 clippy_lints/src/dereference.rs | 1020 +++++++++++++++------------------------
 clippy_utils/src/lib.rs         |  270 ++++++++++-
 2 files changed, 661 insertions(+), 629 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index b2f78ddf989..63db22a2e86 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -3,21 +3,23 @@ use clippy_utils::mir::{enclosing_mir, expr_local, local_assignments, used_exact
 use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::{snippet_with_applicability, snippet_with_context};
 use clippy_utils::sugg::has_enclosing_paren;
-use clippy_utils::ty::{adt_and_variant_of_res, expr_sig, is_copy, peel_mid_ty_refs, ty_sig};
+use clippy_utils::ty::{is_copy, peel_mid_ty_refs};
 use clippy_utils::{
-    fn_def_id, get_parent_expr, get_parent_expr_for_hir, is_lint_allowed, path_to_local, walk_to_expr_usage,
+    expr_use_ctxt, get_parent_expr, get_parent_node, is_lint_allowed, path_to_local, DefinedTy, ExprUseNode,
 };
 
+use hir::def::DefKind;
+use hir::MatchSource;
 use rustc_ast::util::parser::{PREC_POSTFIX, PREC_PREFIX};
 use rustc_data_structures::fx::FxIndexMap;
 use rustc_data_structures::graph::iterate::{CycleDetector, TriColorDepthFirstSearch};
 use rustc_errors::Applicability;
+use rustc_hir::def::Res;
 use rustc_hir::def_id::{DefId, LocalDefId};
 use rustc_hir::intravisit::{walk_ty, Visitor};
 use rustc_hir::{
-    self as hir, BindingAnnotation, Body, BodyId, BorrowKind, Closure, Expr, ExprKind, FnRetTy, GenericArg, HirId,
-    ImplItem, ImplItemKind, Item, ItemKind, Local, MatchSource, Mutability, Node, Pat, PatKind, Path, QPath, TraitItem,
-    TraitItemKind, TyKind, UnOp,
+    self as hir, BindingAnnotation, Body, BodyId, BorrowKind, Expr, ExprKind, HirId, Mutability, Node, Pat, PatKind,
+    Path, QPath, TyKind, UnOp,
 };
 use rustc_index::bit_set::BitSet;
 use rustc_infer::infer::TyCtxtInferExt;
@@ -25,8 +27,8 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::mir::{Rvalue, StatementKind};
 use rustc_middle::ty::adjustment::{Adjust, Adjustment, AutoBorrow, AutoBorrowMutability};
 use rustc_middle::ty::{
-    self, Binder, BoundVariableKind, ClauseKind, EarlyBinder, FnSig, GenericArgKind, List, ParamEnv, ParamTy,
-    ProjectionPredicate, Ty, TyCtxt, TypeVisitableExt, TypeckResults,
+    self, ClauseKind, EarlyBinder, FnSig, GenericArg, GenericArgKind, List, ParamEnv, ParamTy, ProjectionPredicate, Ty,
+    TyCtxt, TypeVisitableExt, TypeckResults,
 };
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::symbol::sym;
@@ -163,7 +165,7 @@ impl_lint_pass!(Dereferencing<'_> => [
 
 #[derive(Default)]
 pub struct Dereferencing<'tcx> {
-    state: Option<(State, StateData)>,
+    state: Option<(State, StateData<'tcx>)>,
 
     // While parsing a `deref` method call in ufcs form, the path to the function is itself an
     // expression. This is to store the id of that expression so it can be skipped when
@@ -203,29 +205,28 @@ impl<'tcx> Dereferencing<'tcx> {
 }
 
 #[derive(Debug)]
-struct StateData {
+struct StateData<'tcx> {
     /// Span of the top level expression
     span: Span,
     hir_id: HirId,
-    position: Position,
+    adjusted_ty: Ty<'tcx>,
 }
 
-#[derive(Debug)]
 struct DerefedBorrow {
     count: usize,
     msg: &'static str,
-    snip_expr: Option<HirId>,
+    stability: TyCoercionStability,
+    for_field_access: Option<Symbol>,
 }
 
-#[derive(Debug)]
 enum State {
     // Any number of deref method calls.
     DerefMethod {
         // The number of calls in a sequence which changed the referenced type
         ty_changed_count: usize,
-        is_final_ufcs: bool,
+        is_ufcs: bool,
         /// The required mutability
-        target_mut: Mutability,
+        mutbl: Mutability,
     },
     DerefedBorrow(DerefedBorrow),
     ExplicitDeref {
@@ -244,7 +245,7 @@ enum State {
 
 // A reference operation considered by this lint pass
 enum RefOp {
-    Method(Mutability),
+    Method { mutbl: Mutability, is_ufcs: bool },
     Deref,
     AddrOf(Mutability),
 }
@@ -294,48 +295,115 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing<'tcx> {
         match (self.state.take(), kind) {
             (None, kind) => {
                 let expr_ty = typeck.expr_ty(expr);
-                let (position, adjustments) = walk_parents(cx, &mut self.possible_borrowers, expr, &self.msrv);
-                match kind {
-                    RefOp::Deref => {
+                let use_cx = expr_use_ctxt(cx, expr);
+                let adjusted_ty = match &use_cx {
+                    Some(use_cx) => match use_cx.adjustments {
+                        [.., a] => a.target,
+                        _ => expr_ty,
+                    },
+                    _ => typeck.expr_ty_adjusted(expr),
+                };
+
+                match (use_cx, kind) {
+                    (Some(use_cx), RefOp::Deref) => {
                         let sub_ty = typeck.expr_ty(sub_expr);
-                        if let Position::FieldAccess {
-                            name,
-                            of_union: false,
-                        } = position
-                            && !ty_contains_field(sub_ty, name)
+                        if let ExprUseNode::FieldAccess(name) = use_cx.node
+                            && adjusted_ty.ty_adt_def().map_or(true, |adt| !adt.is_union())
+                            && !ty_contains_field(sub_ty, name.name)
                         {
                             self.state = Some((
-                                State::ExplicitDerefField { name },
-                                StateData { span: expr.span, hir_id: expr.hir_id, position },
+                                State::ExplicitDerefField { name: name.name },
+                                StateData {
+                                    span: expr.span,
+                                    hir_id: expr.hir_id,
+                                    adjusted_ty,
+                                },
                             ));
-                        } else if position.is_deref_stable() && sub_ty.is_ref() {
+                        } else if sub_ty.is_ref()
+                            // Linting method receivers would require verifying that name lookup
+                            // would resolve the same way. This is complicated by trait methods.
+                            && !use_cx.node.is_recv()
+                            && let Some(ty) = use_cx.node.defined_ty(cx)
+                            && TyCoercionStability::for_defined_ty(cx, ty, use_cx.node.is_return()).is_deref_stable()
+                        {
                             self.state = Some((
                                 State::ExplicitDeref { mutability: None },
-                                StateData { span: expr.span, hir_id: expr.hir_id, position },
+                                StateData {
+                                    span: expr.span,
+                                    hir_id: expr.hir_id,
+                                    adjusted_ty,
+                                },
                             ));
                         }
                     },
-                    RefOp::Method(target_mut)
+                    (_, RefOp::Method { mutbl, is_ufcs })
                         if !is_lint_allowed(cx, EXPLICIT_DEREF_METHODS, expr.hir_id)
-                            && position.lint_explicit_deref() =>
+                            // Allow explicit deref in method chains. e.g. `foo.deref().bar()`
+                            && (is_ufcs || !in_postfix_position(cx, expr)) =>
                     {
                         let ty_changed_count = usize::from(!deref_method_same_type(expr_ty, typeck.expr_ty(sub_expr)));
                         self.state = Some((
                             State::DerefMethod {
                                 ty_changed_count,
-                                is_final_ufcs: matches!(expr.kind, ExprKind::Call(..)),
-                                target_mut,
+                                is_ufcs,
+                                mutbl,
                             },
                             StateData {
                                 span: expr.span,
                                 hir_id: expr.hir_id,
-                                position,
+                                adjusted_ty,
                             },
                         ));
                     },
-                    RefOp::AddrOf(mutability) => {
+                    (Some(use_cx), RefOp::AddrOf(mutability)) => {
+                        let defined_ty = use_cx.node.defined_ty(cx);
+
+                        // Check needless_borrow for generic arguments.
+                        if !use_cx.is_ty_unified
+                            && let Some(DefinedTy::Mir(ty)) = defined_ty
+                            && let ty::Param(ty) = *ty.value.skip_binder().kind()
+                            && let Some((hir_id, fn_id, i)) = match use_cx.node {
+                                ExprUseNode::MethodArg(_, _, 0) => None,
+                                ExprUseNode::MethodArg(hir_id, None, i) => {
+                                    typeck.type_dependent_def_id(hir_id).map(|id| (hir_id, id, i))
+                                },
+                                ExprUseNode::FnArg(&Expr { kind: ExprKind::Path(ref p), hir_id, .. }, i)
+                                if !path_has_args(p) => match typeck.qpath_res(p, hir_id) {
+                                    Res::Def(DefKind::Fn | DefKind::Ctor(..) | DefKind::AssocFn, id) => {
+                                        Some((hir_id, id, i))
+                                    },
+                                    _ => None,
+                                },
+                                _ => None,
+                            } && let count = needless_borrow_generic_arg_count(
+                                cx,
+                                &mut self.possible_borrowers,
+                                fn_id,
+                                typeck.node_substs(hir_id),
+                                i,
+                                ty,
+                                expr,
+                                &self.msrv,
+                            ) && count != 0
+                        {
+                            self.state = Some((
+                                State::DerefedBorrow(DerefedBorrow {
+                                    count: count - 1,
+                                    msg: "the borrowed expression implements the required traits",
+                                    stability: TyCoercionStability::None,
+                                    for_field_access: None,
+                                }),
+                                StateData {
+                                    span: expr.span,
+                                    hir_id: expr.hir_id,
+                                    adjusted_ty: use_cx.adjustments.last().map_or(expr_ty, |a| a.target),
+                                },
+                            ));
+                            return;
+                        }
+
                         // Find the number of times the borrow is auto-derefed.
-                        let mut iter = adjustments.iter();
+                        let mut iter = use_cx.adjustments.iter();
                         let mut deref_count = 0usize;
                         let next_adjust = loop {
                             match iter.next() {
@@ -352,6 +420,58 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing<'tcx> {
                             };
                         };
 
+                        let stability = defined_ty.map_or(TyCoercionStability::None, |ty| {
+                            TyCoercionStability::for_defined_ty(cx, ty, use_cx.node.is_return())
+                        });
+                        let can_auto_borrow = match use_cx.node {
+                            ExprUseNode::Callee => true,
+                            ExprUseNode::FieldAccess(_) => adjusted_ty.ty_adt_def().map_or(true, |adt| !adt.is_union()),
+                            ExprUseNode::MethodArg(hir_id, _, 0) if !use_cx.moved_before_use => {
+                                // Check for calls to trait methods where the trait is implemented
+                                // on a reference.
+                                // Two cases need to be handled:
+                                // * `self` methods on `&T` will never have auto-borrow
+                                // * `&self` methods on `&T` can have auto-borrow, but `&self` methods on `T` will take
+                                //   priority.
+                                if let Some(fn_id) = typeck.type_dependent_def_id(hir_id)
+                                    && let Some(trait_id) = cx.tcx.trait_of_item(fn_id)
+                                    && let arg_ty
+                                        = cx.tcx.erase_regions(use_cx.adjustments.last().map_or(expr_ty, |a| a.target))
+                                    && let ty::Ref(_, sub_ty, _) = *arg_ty.kind()
+                                    && let subs = cx
+                                        .typeck_results()
+                                        .node_substs_opt(hir_id).map(|subs| &subs[1..]).unwrap_or_default()
+                                    && let impl_ty = if cx.tcx.fn_sig(fn_id)
+                                        .subst_identity()
+                                        .skip_binder()
+                                        .inputs()[0].is_ref()
+                                    {
+                                        // Trait methods taking `&self`
+                                        sub_ty
+                                    } else {
+                                        // Trait methods taking `self`
+                                        arg_ty
+                                    } && impl_ty.is_ref()
+                                    && cx.tcx.infer_ctxt().build()
+                                        .type_implements_trait(
+                                            trait_id,
+                                            [impl_ty.into()].into_iter().chain(subs.iter().copied()),
+                                            cx.param_env,
+                                        )
+                                        .must_apply_modulo_regions()
+                                {
+                                    false
+                                } else {
+                                    true
+                                }
+                            },
+                            _ => false,
+                        };
+
+                        let deref_msg =
+                            "this expression creates a reference which is immediately dereferenced by the compiler";
+                        let borrow_msg = "this expression borrows a value the compiler would automatically borrow";
+
                         // Determine the required number of references before any can be removed. In all cases the
                         // reference made by the current expression will be removed. After that there are four cases to
                         // handle.
@@ -374,26 +494,18 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing<'tcx> {
                         //        };
                         //    }
                         //    ```
-                        let deref_msg =
-                            "this expression creates a reference which is immediately dereferenced by the compiler";
-                        let borrow_msg = "this expression borrows a value the compiler would automatically borrow";
-                        let impl_msg = "the borrowed expression implements the required traits";
-
-                        let (required_refs, msg, snip_expr) = if position.can_auto_borrow() {
-                            (1, if deref_count == 1 { borrow_msg } else { deref_msg }, None)
-                        } else if let Position::ImplArg(hir_id) = position {
-                            (0, impl_msg, Some(hir_id))
-                        } else if let Some(&Adjust::Borrow(AutoBorrow::Ref(_, mutability))) =
-                            next_adjust.map(|a| &a.kind)
+                        let (required_refs, msg) = if can_auto_borrow {
+                            (1, if deref_count == 1 { borrow_msg } else { deref_msg })
+                        } else if let Some(&Adjustment {
+                                kind: Adjust::Borrow(AutoBorrow::Ref(_, mutability)),
+                                ..
+                            }) = next_adjust
+                            && matches!(mutability, AutoBorrowMutability::Mut { .. })
+                            && !stability.is_reborrow_stable()
                         {
-                            if matches!(mutability, AutoBorrowMutability::Mut { .. }) && !position.is_reborrow_stable()
-                            {
-                                (3, deref_msg, None)
-                            } else {
-                                (2, deref_msg, None)
-                            }
+                            (3, deref_msg)
                         } else {
-                            (2, deref_msg, None)
+                            (2, deref_msg)
                         };
 
                         if deref_count >= required_refs {
@@ -403,15 +515,19 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing<'tcx> {
                                     // can't be removed without breaking the code. See earlier comment.
                                     count: deref_count - required_refs,
                                     msg,
-                                    snip_expr,
+                                    stability,
+                                    for_field_access: match use_cx.node {
+                                        ExprUseNode::FieldAccess(name) => Some(name.name),
+                                        _ => None,
+                                    },
                                 }),
                                 StateData {
                                     span: expr.span,
                                     hir_id: expr.hir_id,
-                                    position,
+                                    adjusted_ty: use_cx.adjustments.last().map_or(expr_ty, |a| a.target),
                                 },
                             ));
-                        } else if position.is_deref_stable()
+                        } else if stability.is_deref_stable()
                             // Auto-deref doesn't combine with other adjustments
                             && next_adjust.map_or(true, |a| matches!(a.kind, Adjust::Deref(_) | Adjust::Borrow(_)))
                             && iter.all(|a| matches!(a.kind, Adjust::Deref(_) | Adjust::Borrow(_)))
@@ -421,24 +537,24 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing<'tcx> {
                                 StateData {
                                     span: expr.span,
                                     hir_id: expr.hir_id,
-                                    position,
+                                    adjusted_ty: use_cx.adjustments.last().map_or(expr_ty, |a| a.target),
                                 },
                             ));
                         }
                     },
-                    RefOp::Method(..) => (),
+                    (None, _) | (_, RefOp::Method { .. }) => (),
                 }
             },
             (
                 Some((
                     State::DerefMethod {
-                        target_mut,
+                        mutbl,
                         ty_changed_count,
                         ..
                     },
                     data,
                 )),
-                RefOp::Method(_),
+                RefOp::Method { is_ufcs, .. },
             ) => {
                 self.state = Some((
                     State::DerefMethod {
@@ -447,8 +563,8 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing<'tcx> {
                         } else {
                             ty_changed_count + 1
                         },
-                        is_final_ufcs: matches!(expr.kind, ExprKind::Call(..)),
-                        target_mut,
+                        is_ufcs,
+                        mutbl,
                     },
                     data,
                 ));
@@ -463,33 +579,44 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing<'tcx> {
                 ));
             },
             (Some((State::DerefedBorrow(state), data)), RefOp::AddrOf(mutability)) => {
-                let position = data.position;
+                let adjusted_ty = data.adjusted_ty;
+                let stability = state.stability;
                 report(cx, expr, State::DerefedBorrow(state), data);
-                if position.is_deref_stable() {
+                if stability.is_deref_stable() {
                     self.state = Some((
                         State::Borrow { mutability },
                         StateData {
                             span: expr.span,
                             hir_id: expr.hir_id,
-                            position,
+                            adjusted_ty,
                         },
                     ));
                 }
             },
             (Some((State::DerefedBorrow(state), data)), RefOp::Deref) => {
-                let position = data.position;
+                let adjusted_ty = data.adjusted_ty;
+                let stability = state.stability;
+                let for_field_access = state.for_field_access;
                 report(cx, expr, State::DerefedBorrow(state), data);
-                if let Position::FieldAccess{name, ..} = position
+                if let Some(name) = for_field_access
                     && !ty_contains_field(typeck.expr_ty(sub_expr), name)
                 {
                     self.state = Some((
                         State::ExplicitDerefField { name },
-                        StateData { span: expr.span, hir_id: expr.hir_id, position },
+                        StateData {
+                            span: expr.span,
+                            hir_id: expr.hir_id,
+                            adjusted_ty,
+                        },
                     ));
-                } else if position.is_deref_stable() {
+                } else if stability.is_deref_stable() {
                     self.state = Some((
                         State::ExplicitDeref { mutability: None },
-                        StateData { span: expr.span, hir_id: expr.hir_id, position },
+                        StateData {
+                            span: expr.span,
+                            hir_id: expr.hir_id,
+                            adjusted_ty,
+                        },
                     ));
                 }
             },
@@ -611,8 +738,8 @@ fn try_parse_ref_op<'tcx>(
     typeck: &'tcx TypeckResults<'_>,
     expr: &'tcx Expr<'_>,
 ) -> Option<(RefOp, &'tcx Expr<'tcx>)> {
-    let (def_id, arg) = match expr.kind {
-        ExprKind::MethodCall(_, arg, [], _) => (typeck.type_dependent_def_id(expr.hir_id)?, arg),
+    let (is_ufcs, def_id, arg) = match expr.kind {
+        ExprKind::MethodCall(_, arg, [], _) => (false, typeck.type_dependent_def_id(expr.hir_id)?, arg),
         ExprKind::Call(
             Expr {
                 kind: ExprKind::Path(path),
@@ -620,7 +747,7 @@ fn try_parse_ref_op<'tcx>(
                 ..
             },
             [arg],
-        ) => (typeck.qpath_res(path, *hir_id).opt_def_id()?, arg),
+        ) => (true, typeck.qpath_res(path, *hir_id).opt_def_id()?, arg),
         ExprKind::Unary(UnOp::Deref, sub_expr) if !typeck.expr_ty(sub_expr).is_unsafe_ptr() => {
             return Some((RefOp::Deref, sub_expr));
         },
@@ -628,9 +755,21 @@ fn try_parse_ref_op<'tcx>(
         _ => return None,
     };
     if tcx.is_diagnostic_item(sym::deref_method, def_id) {
-        Some((RefOp::Method(Mutability::Not), arg))
+        Some((
+            RefOp::Method {
+                mutbl: Mutability::Not,
+                is_ufcs,
+            },
+            arg,
+        ))
     } else if tcx.trait_of_item(def_id)? == tcx.lang_items().deref_mut_trait()? {
-        Some((RefOp::Method(Mutability::Mut), arg))
+        Some((
+            RefOp::Method {
+                mutbl: Mutability::Mut,
+                is_ufcs,
+            },
+            arg,
+        ))
     } else {
         None
     }
@@ -649,420 +788,164 @@ fn deref_method_same_type<'tcx>(result_ty: Ty<'tcx>, arg_ty: Ty<'tcx>) -> bool {
     }
 }
 
-/// The position of an expression relative to it's parent.
-#[derive(Clone, Copy, Debug)]
-enum Position {
-    MethodReceiver,
-    /// The method is defined on a reference type. e.g. `impl Foo for &T`
-    MethodReceiverRefImpl,
-    Callee,
-    ImplArg(HirId),
-    FieldAccess {
-        name: Symbol,
-        of_union: bool,
-    }, // union fields cannot be auto borrowed
-    Postfix,
-    Deref,
-    /// Any other location which will trigger auto-deref to a specific time.
-    /// Contains the precedence of the parent expression and whether the target type is sized.
-    DerefStable(i8, bool),
-    /// Any other location which will trigger auto-reborrowing.
-    /// Contains the precedence of the parent expression.
-    ReborrowStable(i8),
-    /// Contains the precedence of the parent expression.
-    Other(i8),
-}
-impl Position {
-    fn is_deref_stable(self) -> bool {
-        matches!(self, Self::DerefStable(..))
+fn path_has_args(p: &QPath<'_>) -> bool {
+    match *p {
+        QPath::Resolved(_, Path { segments: [.., s], .. }) | QPath::TypeRelative(_, s) => s.args.is_some(),
+        _ => false,
     }
+}
 
-    fn is_reborrow_stable(self) -> bool {
-        matches!(self, Self::DerefStable(..) | Self::ReborrowStable(_))
+fn in_postfix_position<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'tcx>) -> bool {
+    if let Some(parent) = get_parent_expr(cx, e)
+        && parent.span.ctxt() == e.span.ctxt()
+    {
+        match parent.kind {
+            ExprKind::Call(child, _) | ExprKind::MethodCall(_, child, _, _) | ExprKind::Index(child, _)
+                if child.hir_id == e.hir_id => true,
+            ExprKind::Field(_, _) | ExprKind::Match(_, _, MatchSource::TryDesugar | MatchSource::AwaitDesugar) => true,
+            _ => false,
+        }
+    } else {
+        false
     }
+}
 
-    fn can_auto_borrow(self) -> bool {
-        matches!(
-            self,
-            Self::MethodReceiver | Self::FieldAccess { of_union: false, .. } | Self::Callee
-        )
+#[derive(Clone, Copy)]
+enum TyCoercionStability {
+    Deref,
+    Reborrow,
+    None,
+}
+impl TyCoercionStability {
+    fn is_deref_stable(self) -> bool {
+        matches!(self, Self::Deref)
     }
 
-    fn lint_explicit_deref(self) -> bool {
-        matches!(self, Self::Other(_) | Self::DerefStable(..) | Self::ReborrowStable(_))
+    fn is_reborrow_stable(self) -> bool {
+        matches!(self, Self::Deref | Self::Reborrow)
     }
 
-    fn precedence(self) -> i8 {
-        match self {
-            Self::MethodReceiver
-            | Self::MethodReceiverRefImpl
-            | Self::Callee
-            | Self::FieldAccess { .. }
-            | Self::Postfix => PREC_POSTFIX,
-            Self::ImplArg(_) | Self::Deref => PREC_PREFIX,
-            Self::DerefStable(p, _) | Self::ReborrowStable(p) | Self::Other(p) => p,
+    fn for_defined_ty<'tcx>(cx: &LateContext<'tcx>, ty: DefinedTy<'tcx>, for_return: bool) -> Self {
+        match ty {
+            DefinedTy::Hir(ty) => Self::for_hir_ty(ty),
+            DefinedTy::Mir(ty) => Self::for_mir_ty(
+                cx.tcx,
+                ty.param_env,
+                cx.tcx.erase_late_bound_regions(ty.value),
+                for_return,
+            ),
         }
     }
-}
-
-/// Walks up the parent expressions attempting to determine both how stable the auto-deref result
-/// is, and which adjustments will be applied to it. Note this will not consider auto-borrow
-/// locations as those follow different rules.
-#[expect(clippy::too_many_lines)]
-fn walk_parents<'tcx>(
-    cx: &LateContext<'tcx>,
-    possible_borrowers: &mut Vec<(LocalDefId, PossibleBorrowerMap<'tcx, 'tcx>)>,
-    e: &'tcx Expr<'_>,
-    msrv: &Msrv,
-) -> (Position, &'tcx [Adjustment<'tcx>]) {
-    let mut adjustments = [].as_slice();
-    let mut precedence = 0i8;
-    let ctxt = e.span.ctxt();
-    let position = walk_to_expr_usage(cx, e, &mut |parent, child_id| {
-        // LocalTableInContext returns the wrong lifetime, so go use `expr_adjustments` instead.
-        if adjustments.is_empty() && let Node::Expr(e) = cx.tcx.hir().get(child_id) {
-            adjustments = cx.typeck_results().expr_adjustments(e);
-        }
-        match parent {
-            Node::Local(Local { ty: Some(ty), span, .. }) if span.ctxt() == ctxt => {
-                Some(binding_ty_auto_deref_stability(cx, ty, precedence, List::empty()))
-            },
-            Node::Item(&Item {
-                kind: ItemKind::Static(..) | ItemKind::Const(..),
-                owner_id,
-                span,
-                ..
-            })
-            | Node::TraitItem(&TraitItem {
-                kind: TraitItemKind::Const(..),
-                owner_id,
-                span,
-                ..
-            })
-            | Node::ImplItem(&ImplItem {
-                kind: ImplItemKind::Const(..),
-                owner_id,
-                span,
-                ..
-            }) if span.ctxt() == ctxt => {
-                let ty = cx.tcx.type_of(owner_id.def_id).subst_identity();
-                Some(ty_auto_deref_stability(cx.tcx, cx.param_env, ty, precedence).position_for_result(cx))
-            },
 
-            Node::Item(&Item {
-                kind: ItemKind::Fn(..),
-                owner_id,
-                span,
-                ..
-            })
-            | Node::TraitItem(&TraitItem {
-                kind: TraitItemKind::Fn(..),
-                owner_id,
-                span,
-                ..
-            })
-            | Node::ImplItem(&ImplItem {
-                kind: ImplItemKind::Fn(..),
-                owner_id,
-                span,
-                ..
-            }) if span.ctxt() == ctxt => {
-                let output = cx
-                    .tcx
-                    .erase_late_bound_regions(cx.tcx.fn_sig(owner_id).subst_identity().output());
-                Some(ty_auto_deref_stability(cx.tcx, cx.param_env, output, precedence).position_for_result(cx))
-            },
-
-            Node::ExprField(field) if field.span.ctxt() == ctxt => match get_parent_expr_for_hir(cx, field.hir_id) {
-                Some(Expr {
-                    hir_id,
-                    kind: ExprKind::Struct(path, ..),
-                    ..
-                }) => adt_and_variant_of_res(cx, cx.qpath_res(path, *hir_id))
-                    .and_then(|(adt, variant)| {
-                        variant
-                            .fields
-                            .iter()
-                            .find(|f| f.name == field.ident.name)
-                            .map(|f| (adt, f))
-                    })
-                    .map(|(adt, field_def)| {
-                        ty_auto_deref_stability(
-                            cx.tcx,
-                            // Use the param_env of the target type.
-                            cx.tcx.param_env(adt.did()),
-                            cx.tcx.type_of(field_def.did).subst_identity(),
-                            precedence,
-                        )
-                        .position_for_arg()
-                    }),
-                _ => None,
-            },
+    // Checks the stability of type coercions when assigned to a binding with the given explicit type.
+    //
+    // e.g.
+    // let x = Box::new(Box::new(0u32));
+    // let y1: &Box<_> = x.deref();
+    // let y2: &Box<_> = &x;
+    //
+    // Here `y1` and `y2` would resolve to different types, so the type `&Box<_>` is not stable when
+    // switching to auto-dereferencing.
+    fn for_hir_ty<'tcx>(ty: &'tcx hir::Ty<'tcx>) -> Self {
+        let TyKind::Ref(_, ty) = &ty.kind else {
+            return Self::None;
+        };
+        let mut ty = ty;
 
-            Node::Expr(parent) if parent.span.ctxt() == ctxt => match parent.kind {
-                ExprKind::Ret(_) => {
-                    let owner_id = cx.tcx.hir().body_owner_def_id(cx.enclosing_body.unwrap());
-                    Some(
-                        if let Node::Expr(
-                            closure_expr @ Expr {
-                                kind: ExprKind::Closure(closure),
-                                ..
-                            },
-                        ) = cx.tcx.hir().get_by_def_id(owner_id)
-                        {
-                            closure_result_position(cx, closure, cx.typeck_results().expr_ty(closure_expr), precedence)
-                        } else {
-                            let output = cx
-                                .tcx
-                                .erase_late_bound_regions(cx.tcx.fn_sig(owner_id).subst_identity().output());
-                            ty_auto_deref_stability(cx.tcx, cx.param_env, output, precedence).position_for_result(cx)
-                        },
-                    )
-                },
-                ExprKind::Closure(closure) => Some(closure_result_position(
-                    cx,
-                    closure,
-                    cx.typeck_results().expr_ty(parent),
-                    precedence,
-                )),
-                ExprKind::Call(func, _) if func.hir_id == child_id => {
-                    (child_id == e.hir_id).then_some(Position::Callee)
+        loop {
+            break match ty.ty.kind {
+                TyKind::Ref(_, ref ref_ty) => {
+                    ty = ref_ty;
+                    continue;
                 },
-                ExprKind::Call(func, args) => args
-                    .iter()
-                    .position(|arg| arg.hir_id == child_id)
-                    .zip(expr_sig(cx, func))
-                    .and_then(|(i, sig)| {
-                        sig.input_with_hir(i).map(|(hir_ty, ty)| {
-                            match hir_ty {
-                                // Type inference for closures can depend on how they're called. Only go by the explicit
-                                // types here.
-                                Some(hir_ty) => {
-                                    binding_ty_auto_deref_stability(cx, hir_ty, precedence, ty.bound_vars())
-                                },
-                                None => {
-                                    // `e.hir_id == child_id` for https://github.com/rust-lang/rust-clippy/issues/9739
-                                    // `!call_is_qualified(func)` for https://github.com/rust-lang/rust-clippy/issues/9782
-                                    if e.hir_id == child_id
-                                        && !call_is_qualified(func)
-                                        && let ty::Param(param_ty) = ty.skip_binder().kind()
-                                    {
-                                        needless_borrow_impl_arg_position(
-                                            cx,
-                                            possible_borrowers,
-                                            parent,
-                                            i,
-                                            *param_ty,
-                                            e,
-                                            precedence,
-                                            msrv,
-                                        )
-                                    } else {
-                                        ty_auto_deref_stability(
-                                            cx.tcx,
-                                            // Use the param_env of the target function.
-                                            sig.predicates_id().map_or(ParamEnv::empty(), |id| cx.tcx.param_env(id)),
-                                            cx.tcx.erase_late_bound_regions(ty),
-                                            precedence
-                                        ).position_for_arg()
-                                    }
-                                },
-                            }
+                TyKind::Path(
+                    QPath::TypeRelative(_, path)
+                    | QPath::Resolved(
+                        _,
+                        Path {
+                            segments: [.., path], ..
+                        },
+                    ),
+                ) => {
+                    if let Some(args) = path.args
+                        && args.args.iter().any(|arg| match arg {
+                            hir::GenericArg::Infer(_) => true,
+                            hir::GenericArg::Type(ty) => ty_contains_infer(ty),
+                            _ => false,
                         })
-                    }),
-                ExprKind::MethodCall(method, receiver, args, _) => {
-                    let fn_id = cx.typeck_results().type_dependent_def_id(parent.hir_id).unwrap();
-                    if receiver.hir_id == child_id {
-                        // Check for calls to trait methods where the trait is implemented on a reference.
-                        // Two cases need to be handled:
-                        // * `self` methods on `&T` will never have auto-borrow
-                        // * `&self` methods on `&T` can have auto-borrow, but `&self` methods on `T` will take
-                        //   priority.
-                        if e.hir_id != child_id {
-                            return Some(Position::ReborrowStable(precedence))
-                        } else if let Some(trait_id) = cx.tcx.trait_of_item(fn_id)
-                            && let arg_ty = cx.tcx.erase_regions(cx.typeck_results().expr_ty_adjusted(e))
-                            && let ty::Ref(_, sub_ty, _) = *arg_ty.kind()
-                            && let subs = cx
-                                .typeck_results()
-                                .node_substs_opt(parent.hir_id).map(|subs| &subs[1..]).unwrap_or_default()
-                            && let impl_ty = if cx.tcx.fn_sig(fn_id)
-                                .subst_identity()
-                                .skip_binder()
-                                .inputs()[0].is_ref()
-                            {
-                                // Trait methods taking `&self`
-                                sub_ty
-                            } else {
-                                // Trait methods taking `self`
-                                arg_ty
-                            } && impl_ty.is_ref()
-                            && let infcx = cx.tcx.infer_ctxt().build()
-                            && infcx
-                                .type_implements_trait(
-                                    trait_id,
-                                    [impl_ty.into()].into_iter().chain(subs.iter().copied()),
-                                    cx.param_env,
-                                )
-                                .must_apply_modulo_regions()
-                        {
-                            return Some(Position::MethodReceiverRefImpl)
-                        }
-                        return Some(Position::MethodReceiver);
+                    {
+                        Self::Reborrow
+                    } else {
+                        Self::Deref
                     }
-                    args.iter().position(|arg| arg.hir_id == child_id).map(|i| {
-                        let ty = cx.tcx.fn_sig(fn_id).subst_identity().input(i + 1);
-                        // `e.hir_id == child_id` for https://github.com/rust-lang/rust-clippy/issues/9739
-                        // `method.args.is_none()` for https://github.com/rust-lang/rust-clippy/issues/9782
-                        if e.hir_id == child_id
-                            && method.args.is_none()
-                            && let ty::Param(param_ty) = ty.skip_binder().kind()
-                        {
-                            needless_borrow_impl_arg_position(
-                                cx,
-                                possible_borrowers,
-                                parent,
-                                i + 1,
-                                *param_ty,
-                                e,
-                                precedence,
-                                msrv,
-                            )
-                        } else {
-                            ty_auto_deref_stability(
-                                cx.tcx,
-                                // Use the param_env of the target function.
-                                cx.tcx.param_env(fn_id),
-                                cx.tcx.erase_late_bound_regions(ty),
-                                precedence,
-                            )
-                            .position_for_arg()
-                        }
-                    })
-                },
-                ExprKind::Field(child, name) if child.hir_id == e.hir_id => Some(Position::FieldAccess {
-                    name: name.name,
-                    of_union: is_union(cx.typeck_results(), child),
-                }),
-                ExprKind::Unary(UnOp::Deref, child) if child.hir_id == e.hir_id => Some(Position::Deref),
-                ExprKind::Match(child, _, MatchSource::TryDesugar | MatchSource::AwaitDesugar)
-                | ExprKind::Index(child, _)
-                    if child.hir_id == e.hir_id =>
-                {
-                    Some(Position::Postfix)
                 },
-                _ if child_id == e.hir_id => {
-                    precedence = parent.precedence().order();
-                    None
-                },
-                _ => None,
-            },
-            _ => None,
+                TyKind::Slice(_)
+                | TyKind::Array(..)
+                | TyKind::Ptr(_)
+                | TyKind::BareFn(_)
+                | TyKind::Never
+                | TyKind::Tup(_)
+                | TyKind::Path(_) => Self::Deref,
+                TyKind::OpaqueDef(..)
+                | TyKind::Infer
+                | TyKind::Typeof(..)
+                | TyKind::TraitObject(..)
+                | TyKind::Err(_) => Self::Reborrow,
+            };
         }
-    })
-    .unwrap_or(Position::Other(precedence));
-    (position, adjustments)
-}
-
-fn is_union<'tcx>(typeck: &'tcx TypeckResults<'_>, path_expr: &'tcx Expr<'_>) -> bool {
-    typeck
-        .expr_ty_adjusted(path_expr)
-        .ty_adt_def()
-        .map_or(false, rustc_middle::ty::AdtDef::is_union)
-}
-
-fn closure_result_position<'tcx>(
-    cx: &LateContext<'tcx>,
-    closure: &'tcx Closure<'_>,
-    ty: Ty<'tcx>,
-    precedence: i8,
-) -> Position {
-    match closure.fn_decl.output {
-        FnRetTy::Return(hir_ty) => {
-            if let Some(sig) = ty_sig(cx, ty)
-                && let Some(output) = sig.output()
-            {
-                binding_ty_auto_deref_stability(cx, hir_ty, precedence, output.bound_vars())
-            } else {
-                Position::Other(precedence)
-            }
-        },
-        FnRetTy::DefaultReturn(_) => Position::Other(precedence),
     }
-}
 
-// Checks the stability of auto-deref when assigned to a binding with the given explicit type.
-//
-// e.g.
-// let x = Box::new(Box::new(0u32));
-// let y1: &Box<_> = x.deref();
-// let y2: &Box<_> = &x;
-//
-// Here `y1` and `y2` would resolve to different types, so the type `&Box<_>` is not stable when
-// switching to auto-dereferencing.
-fn binding_ty_auto_deref_stability<'tcx>(
-    cx: &LateContext<'tcx>,
-    ty: &'tcx hir::Ty<'_>,
-    precedence: i8,
-    binder_args: &'tcx List<BoundVariableKind>,
-) -> Position {
-    let TyKind::Ref(_, ty) = &ty.kind else {
-        return Position::Other(precedence);
-    };
-    let mut ty = ty;
+    fn for_mir_ty<'tcx>(tcx: TyCtxt<'tcx>, param_env: ParamEnv<'tcx>, ty: Ty<'tcx>, for_return: bool) -> Self {
+        let ty::Ref(_, mut ty, _) = *ty.kind() else {
+            return Self::None;
+        };
 
-    loop {
-        break match ty.ty.kind {
-            TyKind::Ref(_, ref ref_ty) => {
-                ty = ref_ty;
-                continue;
-            },
-            TyKind::Path(
-                QPath::TypeRelative(_, path)
-                | QPath::Resolved(
-                    _,
-                    Path {
-                        segments: [.., path], ..
-                    },
-                ),
-            ) => {
-                if let Some(args) = path.args
-                    && args.args.iter().any(|arg| match arg {
-                        GenericArg::Infer(_) => true,
-                        GenericArg::Type(ty) => ty_contains_infer(ty),
-                        _ => false,
-                    })
+        ty = tcx.try_normalize_erasing_regions(param_env, ty).unwrap_or(ty);
+        loop {
+            break match *ty.kind() {
+                ty::Ref(_, ref_ty, _) => {
+                    ty = ref_ty;
+                    continue;
+                },
+                ty::Param(_) if for_return => Self::Deref,
+                ty::Alias(ty::Weak | ty::Inherent, _) => unreachable!("should have been normalized away above"),
+                ty::Alias(ty::Projection, _) if !for_return && ty.has_non_region_param() => Self::Reborrow,
+                ty::Infer(_)
+                | ty::Error(_)
+                | ty::Bound(..)
+                | ty::Alias(ty::Opaque, ..)
+                | ty::Placeholder(_)
+                | ty::Dynamic(..)
+                | ty::Param(_) => Self::Reborrow,
+                ty::Adt(_, substs)
+                    if ty.has_placeholders()
+                        || ty.has_opaque_types()
+                        || (!for_return && substs.has_non_region_param()) =>
                 {
-                    Position::ReborrowStable(precedence)
-                } else {
-                    Position::DerefStable(
-                        precedence,
-                        cx.tcx
-                            .erase_late_bound_regions(Binder::bind_with_vars(
-                                cx.typeck_results().node_type(ty.ty.hir_id),
-                                binder_args,
-                            ))
-                            .is_sized(cx.tcx, cx.param_env.without_caller_bounds()),
-                    )
-                }
-            },
-            TyKind::Slice(_) => Position::DerefStable(precedence, false),
-            TyKind::Array(..) | TyKind::Ptr(_) | TyKind::BareFn(_) => Position::DerefStable(precedence, true),
-            TyKind::Never
-            | TyKind::Tup(_)
-            | TyKind::Path(_) => Position::DerefStable(
-                precedence,
-                cx.tcx
-                    .erase_late_bound_regions(Binder::bind_with_vars(
-                        cx.typeck_results().node_type(ty.ty.hir_id),
-                        binder_args,
-                    ))
-                    .is_sized(cx.tcx, cx.param_env.without_caller_bounds()),
-            ),
-            TyKind::OpaqueDef(..) | TyKind::Infer | TyKind::Typeof(..) | TyKind::TraitObject(..) | TyKind::Err(_) => {
-                Position::ReborrowStable(precedence)
-            },
-        };
+                    Self::Reborrow
+                },
+                ty::Bool
+                | ty::Char
+                | ty::Int(_)
+                | ty::Uint(_)
+                | ty::Array(..)
+                | ty::Float(_)
+                | ty::RawPtr(..)
+                | ty::FnPtr(_)
+                | ty::Str
+                | ty::Slice(..)
+                | ty::Adt(..)
+                | ty::Foreign(_)
+                | ty::FnDef(..)
+                | ty::Generator(..)
+                | ty::GeneratorWitness(..)
+                | ty::GeneratorWitnessMIR(..)
+                | ty::Closure(..)
+                | ty::Never
+                | ty::Tuple(_)
+                | ty::Alias(ty::Projection, _) => Self::Deref,
+            };
+        }
     }
 }
 
@@ -1084,10 +967,10 @@ fn ty_contains_infer(ty: &hir::Ty<'_>) -> bool {
             }
         }
 
-        fn visit_generic_arg(&mut self, arg: &GenericArg<'_>) {
-            if self.0 || matches!(arg, GenericArg::Infer(_)) {
+        fn visit_generic_arg(&mut self, arg: &hir::GenericArg<'_>) {
+            if self.0 || matches!(arg, hir::GenericArg::Infer(_)) {
                 self.0 = true;
-            } else if let GenericArg::Type(ty) = arg {
+            } else if let hir::GenericArg::Type(ty) = arg {
                 self.visit_ty(ty);
             }
         }
@@ -1097,51 +980,29 @@ fn ty_contains_infer(ty: &hir::Ty<'_>) -> bool {
     v.0
 }
 
-fn call_is_qualified(expr: &Expr<'_>) -> bool {
-    if let ExprKind::Path(path) = &expr.kind {
-        match path {
-            QPath::Resolved(_, path) => path.segments.last().map_or(false, |segment| segment.args.is_some()),
-            QPath::TypeRelative(_, segment) => segment.args.is_some(),
-            QPath::LangItem(..) => false,
-        }
-    } else {
-        false
-    }
-}
-
-// Checks whether:
-// * child is an expression of the form `&e` in an argument position requiring an `impl Trait`
-// * `e`'s type implements `Trait` and is copyable
-// If the conditions are met, returns `Some(Position::ImplArg(..))`; otherwise, returns `None`.
-//   The "is copyable" condition is to avoid the case where removing the `&` means `e` would have to
-// be moved, but it cannot be.
-#[expect(clippy::too_many_arguments, clippy::too_many_lines)]
-fn needless_borrow_impl_arg_position<'tcx>(
+/// Checks for the number of borrow expressions which can be removed from the given expression
+/// where the expression is used as an argument to a function expecting a generic type.
+///
+/// The following constraints will be checked:
+/// * The borrowed expression meets all the generic type's constraints.
+/// * The generic type appears only once in the functions signature.
+/// * The borrowed value will not be moved if it is used later in the function.
+#[expect(clippy::too_many_arguments)]
+fn needless_borrow_generic_arg_count<'tcx>(
     cx: &LateContext<'tcx>,
     possible_borrowers: &mut Vec<(LocalDefId, PossibleBorrowerMap<'tcx, 'tcx>)>,
-    parent: &Expr<'tcx>,
+    fn_id: DefId,
+    callee_substs: &'tcx List<GenericArg<'tcx>>,
     arg_index: usize,
     param_ty: ParamTy,
     mut expr: &Expr<'tcx>,
-    precedence: i8,
     msrv: &Msrv,
-) -> Position {
+) -> usize {
     let destruct_trait_def_id = cx.tcx.lang_items().destruct_trait();
     let sized_trait_def_id = cx.tcx.lang_items().sized_trait();
 
-    let Some(callee_def_id) = fn_def_id(cx, parent) else {
-        return Position::Other(precedence);
-    };
-    let fn_sig = cx.tcx.fn_sig(callee_def_id).subst_identity().skip_binder();
-    let substs_with_expr_ty = cx
-        .typeck_results()
-        .node_substs(if let ExprKind::Call(callee, _) = parent.kind {
-            callee.hir_id
-        } else {
-            parent.hir_id
-        });
-
-    let predicates = cx.tcx.param_env(callee_def_id).caller_bounds();
+    let fn_sig = cx.tcx.fn_sig(fn_id).subst_identity().skip_binder();
+    let predicates = cx.tcx.param_env(fn_id).caller_bounds();
     let projection_predicates = predicates
         .iter()
         .filter_map(|predicate| {
@@ -1176,7 +1037,7 @@ fn needless_borrow_impl_arg_position<'tcx>(
                 || cx.tcx.is_diagnostic_item(sym::Any, trait_def_id)
         })
     {
-        return Position::Other(precedence);
+        return 0;
     }
 
     // See:
@@ -1184,14 +1045,14 @@ fn needless_borrow_impl_arg_position<'tcx>(
     // - https://github.com/rust-lang/rust-clippy/pull/9674#issuecomment-1292225232
     if projection_predicates
         .iter()
-        .any(|projection_predicate| is_mixed_projection_predicate(cx, callee_def_id, projection_predicate))
+        .any(|projection_predicate| is_mixed_projection_predicate(cx, fn_id, projection_predicate))
     {
-        return Position::Other(precedence);
+        return 0;
     }
 
     // `substs_with_referent_ty` can be constructed outside of `check_referent` because the same
     // elements are modified each time `check_referent` is called.
-    let mut substs_with_referent_ty = substs_with_expr_ty.to_vec();
+    let mut substs_with_referent_ty = callee_substs.to_vec();
 
     let mut check_reference_and_referent = |reference, referent| {
         let referent_ty = cx.typeck_results().expr_ty(referent);
@@ -1238,20 +1099,15 @@ fn needless_borrow_impl_arg_position<'tcx>(
         })
     };
 
-    let mut needless_borrow = false;
+    let mut count = 0;
     while let ExprKind::AddrOf(_, _, referent) = expr.kind {
         if !check_reference_and_referent(expr, referent) {
             break;
         }
         expr = referent;
-        needless_borrow = true;
-    }
-
-    if needless_borrow {
-        Position::ImplArg(expr.hir_id)
-    } else {
-        Position::Other(precedence)
+        count += 1;
     }
+    count
 }
 
 fn has_ref_mut_self_method(cx: &LateContext<'_>, trait_def_id: DefId) -> bool {
@@ -1387,95 +1243,6 @@ fn replace_types<'tcx>(
     true
 }
 
-struct TyPosition<'tcx> {
-    position: Position,
-    ty: Option<Ty<'tcx>>,
-}
-impl From<Position> for TyPosition<'_> {
-    fn from(position: Position) -> Self {
-        Self { position, ty: None }
-    }
-}
-impl<'tcx> TyPosition<'tcx> {
-    fn new_deref_stable_for_result(precedence: i8, ty: Ty<'tcx>) -> Self {
-        Self {
-            position: Position::ReborrowStable(precedence),
-            ty: Some(ty),
-        }
-    }
-    fn position_for_result(self, cx: &LateContext<'tcx>) -> Position {
-        match (self.position, self.ty) {
-            (Position::ReborrowStable(precedence), Some(ty)) => {
-                Position::DerefStable(precedence, ty.is_sized(cx.tcx, cx.param_env))
-            },
-            (position, _) => position,
-        }
-    }
-    fn position_for_arg(self) -> Position {
-        self.position
-    }
-}
-
-// Checks whether a type is stable when switching to auto dereferencing,
-fn ty_auto_deref_stability<'tcx>(
-    tcx: TyCtxt<'tcx>,
-    param_env: ParamEnv<'tcx>,
-    ty: Ty<'tcx>,
-    precedence: i8,
-) -> TyPosition<'tcx> {
-    let ty::Ref(_, mut ty, _) = *ty.kind() else {
-        return Position::Other(precedence).into();
-    };
-
-    ty = tcx.try_normalize_erasing_regions(param_env, ty).unwrap_or(ty);
-
-    loop {
-        break match *ty.kind() {
-            ty::Ref(_, ref_ty, _) => {
-                ty = ref_ty;
-                continue;
-            },
-            ty::Param(_) => TyPosition::new_deref_stable_for_result(precedence, ty),
-            ty::Alias(ty::Weak, _) => unreachable!("should have been normalized away above"),
-            ty::Alias(ty::Inherent, _) => unreachable!("inherent projection should have been normalized away above"),
-            ty::Alias(ty::Projection, _) if ty.has_non_region_param() => {
-                TyPosition::new_deref_stable_for_result(precedence, ty)
-            },
-            ty::Infer(_)
-            | ty::Error(_)
-            | ty::Bound(..)
-            | ty::Alias(ty::Opaque, ..)
-            | ty::Placeholder(_)
-            | ty::Dynamic(..) => Position::ReborrowStable(precedence).into(),
-            ty::Adt(..) if ty.has_placeholders() || ty.has_opaque_types() => {
-                Position::ReborrowStable(precedence).into()
-            },
-            ty::Adt(_, substs) if substs.has_non_region_param() => {
-                TyPosition::new_deref_stable_for_result(precedence, ty)
-            },
-            ty::Bool
-            | ty::Char
-            | ty::Int(_)
-            | ty::Uint(_)
-            | ty::Array(..)
-            | ty::Float(_)
-            | ty::RawPtr(..)
-            | ty::FnPtr(_) => Position::DerefStable(precedence, true).into(),
-            ty::Str | ty::Slice(..) => Position::DerefStable(precedence, false).into(),
-            ty::Adt(..)
-            | ty::Foreign(_)
-            | ty::FnDef(..)
-            | ty::Generator(..)
-            | ty::GeneratorWitness(..)
-            | ty::GeneratorWitnessMIR(..)
-            | ty::Closure(..)
-            | ty::Never
-            | ty::Tuple(_)
-            | ty::Alias(ty::Projection, _) => Position::DerefStable(precedence, ty.is_sized(tcx, param_env)).into(),
-        };
-    }
-}
-
 fn ty_contains_field(ty: Ty<'_>, name: Symbol) -> bool {
     if let ty::Adt(adt, _) = *ty.kind() {
         adt.is_struct() && adt.all_fields().any(|f| f.name == name)
@@ -1485,12 +1252,12 @@ fn ty_contains_field(ty: Ty<'_>, name: Symbol) -> bool {
 }
 
 #[expect(clippy::needless_pass_by_value, clippy::too_many_lines)]
-fn report<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, state: State, data: StateData) {
+fn report<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, state: State, data: StateData<'tcx>) {
     match state {
         State::DerefMethod {
             ty_changed_count,
-            is_final_ufcs,
-            target_mut,
+            is_ufcs,
+            mutbl,
         } => {
             let mut app = Applicability::MachineApplicable;
             let (expr_str, _expr_is_macro_call) = snippet_with_context(cx, expr.span, data.span.ctxt(), "..", &mut app);
@@ -1505,12 +1272,12 @@ fn report<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, state: State, data
             };
             let addr_of_str = if ty_changed_count < ref_count {
                 // Check if a reborrow from &mut T -> &T is required.
-                if target_mut == Mutability::Not && matches!(ty.kind(), ty::Ref(_, _, Mutability::Mut)) {
+                if mutbl == Mutability::Not && matches!(ty.kind(), ty::Ref(_, _, Mutability::Mut)) {
                     "&*"
                 } else {
                     ""
                 }
-            } else if target_mut == Mutability::Mut {
+            } else if mutbl == Mutability::Mut {
                 "&mut "
             } else {
                 "&"
@@ -1527,7 +1294,7 @@ fn report<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, state: State, data
             */
 
             // Fix #10850, do not lint if it's `Foo::deref` instead of `foo.deref()`.
-            if is_final_ufcs {
+            if is_ufcs {
                 return;
             }
 
@@ -1535,7 +1302,7 @@ fn report<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, state: State, data
                 cx,
                 EXPLICIT_DEREF_METHODS,
                 data.span,
-                match target_mut {
+                match mutbl {
                     Mutability::Not => "explicit `deref` method call",
                     Mutability::Mut => "explicit `deref_mut` method call",
                 },
@@ -1546,13 +1313,19 @@ fn report<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, state: State, data
         },
         State::DerefedBorrow(state) => {
             let mut app = Applicability::MachineApplicable;
-            let snip_expr = state.snip_expr.map_or(expr, |hir_id| cx.tcx.hir().expect_expr(hir_id));
-            let (snip, snip_is_macro) = snippet_with_context(cx, snip_expr.span, data.span.ctxt(), "..", &mut app);
+            let (snip, snip_is_macro) = snippet_with_context(cx, expr.span, data.span.ctxt(), "..", &mut app);
             span_lint_hir_and_then(cx, NEEDLESS_BORROW, data.hir_id, data.span, state.msg, |diag| {
-                let calls_field = matches!(expr.kind, ExprKind::Field(..)) && matches!(data.position, Position::Callee);
+                let (precedence, calls_field) = match get_parent_node(cx.tcx, data.hir_id) {
+                    Some(Node::Expr(e)) => match e.kind {
+                        ExprKind::Call(callee, _) if callee.hir_id != data.hir_id => (0, false),
+                        ExprKind::Call(..) => (PREC_POSTFIX, matches!(expr.kind, ExprKind::Field(..))),
+                        _ => (e.precedence().order(), false),
+                    },
+                    _ => (0, false),
+                };
                 let sugg = if !snip_is_macro
+                    && (calls_field || expr.precedence().order() < precedence)
                     && !has_enclosing_paren(&snip)
-                    && (expr.precedence().order() < data.position.precedence() || calls_field)
                 {
                     format!("({snip})")
                 } else {
@@ -1569,7 +1342,8 @@ fn report<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, state: State, data
                     | ExprKind::If(..)
                     | ExprKind::Loop(..)
                     | ExprKind::Match(..)
-            ) && matches!(data.position, Position::DerefStable(_, true))
+            ) && let ty::Ref(_, ty, _) = data.adjusted_ty.kind()
+                && ty.is_sized(cx.tcx, cx.param_env)
             {
                 // Rustc bug: auto deref doesn't work on block expression when targeting sized types.
                 return;
@@ -1582,9 +1356,9 @@ fn report<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, state: State, data
                     Mutability::Not => "&",
                     Mutability::Mut => "&mut ",
                 };
-                (prefix, 0)
+                (prefix, PREC_PREFIX)
             } else {
-                ("", data.position.precedence())
+                ("", 0)
             };
             span_lint_hir_and_then(
                 cx,
@@ -1613,7 +1387,7 @@ fn report<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, state: State, data
                     | ExprKind::If(..)
                     | ExprKind::Loop(..)
                     | ExprKind::Match(..)
-            ) && matches!(data.position, Position::DerefStable(_, true))
+            ) && data.adjusted_ty.is_sized(cx.tcx, cx.param_env)
             {
                 // Rustc bug: auto deref doesn't work on block expression when targeting sized types.
                 return;
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index cf33076d356..8429192437c 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -89,15 +89,14 @@ use rustc_hir::intravisit::{walk_expr, FnKind, Visitor};
 use rustc_hir::LangItem::{OptionNone, OptionSome, ResultErr, ResultOk};
 use rustc_hir::{
     self as hir, def, Arm, ArrayLen, BindingAnnotation, Block, BlockCheckMode, Body, Closure, Destination, Expr,
-    ExprKind, FnDecl, HirId, Impl, ImplItem, ImplItemKind, ImplItemRef, IsAsync, Item, ItemKind, LangItem, Local,
-    MatchSource, Mutability, Node, OwnerId, Param, Pat, PatKind, Path, PathSegment, PrimTy, QPath, Stmt, StmtKind,
-    TraitItem, TraitItemRef, TraitRef, TyKind, UnOp,
+    ExprField, ExprKind, FnDecl, FnRetTy, GenericArgs, HirId, Impl, ImplItem, ImplItemKind, ImplItemRef, IsAsync, Item,
+    ItemKind, LangItem, Local, MatchSource, Mutability, Node, OwnerId, Param, Pat, PatKind, Path, PathSegment, PrimTy,
+    QPath, Stmt, StmtKind, TraitItem, TraitItemKind, TraitItemRef, TraitRef, TyKind, UnOp,
 };
 use rustc_lexer::{tokenize, TokenKind};
 use rustc_lint::{LateContext, Level, Lint, LintContext};
 use rustc_middle::hir::place::PlaceBase;
 use rustc_middle::mir::ConstantKind;
-use rustc_middle::ty as rustc_ty;
 use rustc_middle::ty::adjustment::{Adjust, Adjustment, AutoBorrow};
 use rustc_middle::ty::binding::BindingMode;
 use rustc_middle::ty::fast_reject::SimplifiedType::{
@@ -106,7 +105,8 @@ use rustc_middle::ty::fast_reject::SimplifiedType::{
 };
 use rustc_middle::ty::layout::IntegerExt;
 use rustc_middle::ty::{
-    BorrowKind, ClosureKind, FloatTy, IntTy, Ty, TyCtxt, TypeAndMut, TypeVisitableExt, UintTy, UpvarCapture,
+    self as rustc_ty, Binder, BorrowKind, ClosureKind, FloatTy, IntTy, ParamEnv, ParamEnvAnd, Ty, TyCtxt, TypeAndMut,
+    TypeVisitableExt, UintTy, UpvarCapture,
 };
 use rustc_span::hygiene::{ExpnKind, MacroKind};
 use rustc_span::source_map::SourceMap;
@@ -116,7 +116,10 @@ use rustc_target::abi::Integer;
 
 use crate::consts::{constant, miri_to_const, Constant};
 use crate::higher::Range;
-use crate::ty::{can_partially_move_ty, expr_sig, is_copy, is_recursively_primitive_type, ty_is_fn_once_param};
+use crate::ty::{
+    adt_and_variant_of_res, can_partially_move_ty, expr_sig, is_copy, is_recursively_primitive_type,
+    ty_is_fn_once_param,
+};
 use crate::visitors::for_each_expr;
 
 use rustc_middle::hir::nested_filter;
@@ -2502,6 +2505,261 @@ pub fn walk_to_expr_usage<'tcx, T>(
     None
 }
 
+/// A type definition as it would be viewed from within a function.
+#[derive(Clone, Copy)]
+pub enum DefinedTy<'tcx> {
+    // Used for locals and closures defined within the function.
+    Hir(&'tcx hir::Ty<'tcx>),
+    /// Used for function signatures, and constant and static values. This includes the `ParamEnv`
+    /// from the definition site.
+    Mir(ParamEnvAnd<'tcx, Binder<'tcx, Ty<'tcx>>>),
+}
+
+/// The context an expressions value is used in.
+pub struct ExprUseCtxt<'tcx> {
+    /// The parent node which consumes the value.
+    pub node: ExprUseNode<'tcx>,
+    /// Any adjustments applied to the type.
+    pub adjustments: &'tcx [Adjustment<'tcx>],
+    /// Whether or not the type must unify with another code path.
+    pub is_ty_unified: bool,
+    /// Whether or not the value will be moved before it's used.
+    pub moved_before_use: bool,
+}
+
+/// The node which consumes a value.
+pub enum ExprUseNode<'tcx> {
+    /// Assignment to, or initializer for, a local
+    Local(&'tcx Local<'tcx>),
+    /// Initializer for a const or static item.
+    ConstStatic(OwnerId),
+    /// Implicit or explicit return from a function.
+    Return(OwnerId),
+    /// Initialization of a struct field.
+    Field(&'tcx ExprField<'tcx>),
+    /// An argument to a function.
+    FnArg(&'tcx Expr<'tcx>, usize),
+    /// An argument to a method.
+    MethodArg(HirId, Option<&'tcx GenericArgs<'tcx>>, usize),
+    /// The callee of a function call.
+    Callee,
+    /// Access of a field.
+    FieldAccess(Ident),
+}
+impl<'tcx> ExprUseNode<'tcx> {
+    /// Checks if the value is returned from the function.
+    pub fn is_return(&self) -> bool {
+        matches!(self, Self::Return(_))
+    }
+
+    /// Checks if the value is used as a method call receiver.
+    pub fn is_recv(&self) -> bool {
+        matches!(self, Self::MethodArg(_, _, 0))
+    }
+
+    /// Gets the needed type as it's defined without any type inference.
+    pub fn defined_ty(&self, cx: &LateContext<'tcx>) -> Option<DefinedTy<'tcx>> {
+        match *self {
+            Self::Local(Local { ty: Some(ty), .. }) => Some(DefinedTy::Hir(ty)),
+            Self::ConstStatic(id) => Some(DefinedTy::Mir(
+                cx.param_env.and(Binder::dummy(cx.tcx.type_of(id).subst_identity())),
+            )),
+            Self::Return(id) => {
+                let hir_id = cx.tcx.hir().local_def_id_to_hir_id(id.def_id);
+                if let Some(Node::Expr(Expr {
+                    kind: ExprKind::Closure(c),
+                    ..
+                })) = cx.tcx.hir().find(hir_id)
+                {
+                    match c.fn_decl.output {
+                        FnRetTy::DefaultReturn(_) => None,
+                        FnRetTy::Return(ty) => Some(DefinedTy::Hir(ty)),
+                    }
+                } else {
+                    Some(DefinedTy::Mir(
+                        cx.param_env.and(cx.tcx.fn_sig(id).subst_identity().output()),
+                    ))
+                }
+            },
+            Self::Field(field) => match get_parent_expr_for_hir(cx, field.hir_id) {
+                Some(Expr {
+                    hir_id,
+                    kind: ExprKind::Struct(path, ..),
+                    ..
+                }) => adt_and_variant_of_res(cx, cx.qpath_res(path, *hir_id))
+                    .and_then(|(adt, variant)| {
+                        variant
+                            .fields
+                            .iter()
+                            .find(|f| f.name == field.ident.name)
+                            .map(|f| (adt, f))
+                    })
+                    .map(|(adt, field_def)| {
+                        DefinedTy::Mir(
+                            cx.tcx
+                                .param_env(adt.did())
+                                .and(Binder::dummy(cx.tcx.type_of(field_def.did).subst_identity())),
+                        )
+                    }),
+                _ => None,
+            },
+            Self::FnArg(callee, i) => {
+                let sig = expr_sig(cx, callee)?;
+                let (hir_ty, ty) = sig.input_with_hir(i)?;
+                Some(match hir_ty {
+                    Some(hir_ty) => DefinedTy::Hir(hir_ty),
+                    None => DefinedTy::Mir(
+                        sig.predicates_id()
+                            .map_or(ParamEnv::empty(), |id| cx.tcx.param_env(id))
+                            .and(ty),
+                    ),
+                })
+            },
+            Self::MethodArg(id, _, i) => {
+                let id = cx.typeck_results().type_dependent_def_id(id)?;
+                let sig = cx.tcx.fn_sig(id).skip_binder();
+                Some(DefinedTy::Mir(cx.tcx.param_env(id).and(sig.input(i))))
+            },
+            Self::Local(_) | Self::FieldAccess(..) | Self::Callee => None,
+        }
+    }
+}
+
+/// Gets the context an expression's value is used in.
+#[expect(clippy::too_many_lines)]
+pub fn expr_use_ctxt<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'tcx>) -> Option<ExprUseCtxt<'tcx>> {
+    let mut adjustments = [].as_slice();
+    let mut is_ty_unified = false;
+    let mut moved_before_use = false;
+    let ctxt = e.span.ctxt();
+    walk_to_expr_usage(cx, e, &mut |parent, child_id| {
+        // LocalTableInContext returns the wrong lifetime, so go use `expr_adjustments` instead.
+        if adjustments.is_empty() && let Node::Expr(e) = cx.tcx.hir().get(child_id) {
+            adjustments = cx.typeck_results().expr_adjustments(e);
+        }
+        match parent {
+            Node::Local(l) if l.span.ctxt() == ctxt => Some(ExprUseCtxt {
+                node: ExprUseNode::Local(l),
+                adjustments,
+                is_ty_unified,
+                moved_before_use,
+            }),
+            Node::Item(&Item {
+                kind: ItemKind::Static(..) | ItemKind::Const(..),
+                owner_id,
+                span,
+                ..
+            })
+            | Node::TraitItem(&TraitItem {
+                kind: TraitItemKind::Const(..),
+                owner_id,
+                span,
+                ..
+            })
+            | Node::ImplItem(&ImplItem {
+                kind: ImplItemKind::Const(..),
+                owner_id,
+                span,
+                ..
+            }) if span.ctxt() == ctxt => Some(ExprUseCtxt {
+                node: ExprUseNode::ConstStatic(owner_id),
+                adjustments,
+                is_ty_unified,
+                moved_before_use,
+            }),
+
+            Node::Item(&Item {
+                kind: ItemKind::Fn(..),
+                owner_id,
+                span,
+                ..
+            })
+            | Node::TraitItem(&TraitItem {
+                kind: TraitItemKind::Fn(..),
+                owner_id,
+                span,
+                ..
+            })
+            | Node::ImplItem(&ImplItem {
+                kind: ImplItemKind::Fn(..),
+                owner_id,
+                span,
+                ..
+            }) if span.ctxt() == ctxt => Some(ExprUseCtxt {
+                node: ExprUseNode::Return(owner_id),
+                adjustments,
+                is_ty_unified,
+                moved_before_use,
+            }),
+
+            Node::ExprField(field) if field.span.ctxt() == ctxt => Some(ExprUseCtxt {
+                node: ExprUseNode::Field(field),
+                adjustments,
+                is_ty_unified,
+                moved_before_use,
+            }),
+
+            Node::Expr(parent) if parent.span.ctxt() == ctxt => match parent.kind {
+                ExprKind::Ret(_) => Some(ExprUseCtxt {
+                    node: ExprUseNode::Return(OwnerId {
+                        def_id: cx.tcx.hir().body_owner_def_id(cx.enclosing_body.unwrap()),
+                    }),
+                    adjustments,
+                    is_ty_unified,
+                    moved_before_use,
+                }),
+                ExprKind::Closure(closure) => Some(ExprUseCtxt {
+                    node: ExprUseNode::Return(OwnerId { def_id: closure.def_id }),
+                    adjustments,
+                    is_ty_unified,
+                    moved_before_use,
+                }),
+                ExprKind::Call(func, args) => Some(ExprUseCtxt {
+                    node: match args.iter().position(|arg| arg.hir_id == child_id) {
+                        Some(i) => ExprUseNode::FnArg(func, i),
+                        None => ExprUseNode::Callee,
+                    },
+                    adjustments,
+                    is_ty_unified,
+                    moved_before_use,
+                }),
+                ExprKind::MethodCall(name, _, args, _) => Some(ExprUseCtxt {
+                    node: ExprUseNode::MethodArg(
+                        parent.hir_id,
+                        name.args,
+                        args.iter().position(|arg| arg.hir_id == child_id).map_or(0, |i| i + 1),
+                    ),
+                    adjustments,
+                    is_ty_unified,
+                    moved_before_use,
+                }),
+                ExprKind::Field(child, name) if child.hir_id == e.hir_id => Some(ExprUseCtxt {
+                    node: ExprUseNode::FieldAccess(name),
+                    adjustments,
+                    is_ty_unified,
+                    moved_before_use,
+                }),
+                ExprKind::If(e, _, _) | ExprKind::Match(e, _, _) if e.hir_id != child_id => {
+                    is_ty_unified = true;
+                    moved_before_use = true;
+                    None
+                },
+                ExprKind::Block(_, Some(_)) | ExprKind::Break(..) => {
+                    is_ty_unified = true;
+                    moved_before_use = true;
+                    None
+                },
+                ExprKind::Block(..) => {
+                    moved_before_use = true;
+                    None
+                },
+                _ => None,
+            },
+            _ => None,
+        }
+    })
+}
+
 /// Tokenizes the input while keeping the text associated with each token.
 pub fn tokenize_with_text(s: &str) -> impl Iterator<Item = (TokenKind, &str)> {
     let mut pos = 0;
-- 
cgit 1.4.1-3-g733a5


From 30d06a810c8b8967d9d0ea2cb64d5adf8b357914 Mon Sep 17 00:00:00 2001
From: Milo Moisson <milomoisson@gmail.com>
Date: Sun, 23 Jul 2023 17:05:54 +0200
Subject: ptr_arg should ignore extern functions

---
 clippy_lints/src/ptr.rs | 11 +++++++++++
 tests/ui/ptr_arg.rs     | 13 +++++++++++++
 2 files changed, 24 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs
index 82a55166aea..4534b2ab28a 100644
--- a/clippy_lints/src/ptr.rs
+++ b/clippy_lints/src/ptr.rs
@@ -26,6 +26,7 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
 use rustc_span::sym;
 use rustc_span::symbol::Symbol;
+use rustc_target::spec::abi::Abi;
 use rustc_trait_selection::infer::InferCtxtExt as _;
 use rustc_trait_selection::traits::query::evaluate_obligation::InferCtxtExt as _;
 use std::{fmt, iter};
@@ -162,6 +163,11 @@ impl<'tcx> LateLintPass<'tcx> for Ptr {
                 return;
             }
 
+            if !matches!(sig.header.abi, Abi::Rust) {
+                // Ignore `extern` functions with non-Rust calling conventions
+                return;
+            }
+
             check_mut_from_ref(cx, sig, None);
             for arg in check_fn_args(
                 cx,
@@ -217,6 +223,11 @@ impl<'tcx> LateLintPass<'tcx> for Ptr {
             _ => return,
         };
 
+        if !matches!(sig.header.abi, Abi::Rust) {
+            // Ignore `extern` functions with non-Rust calling conventions
+            return;
+        }
+
         check_mut_from_ref(cx, sig, Some(body));
         let decl = sig.decl;
         let sig = cx.tcx.fn_sig(item_id).subst_identity().skip_binder();
diff --git a/tests/ui/ptr_arg.rs b/tests/ui/ptr_arg.rs
index 13e993d247b..08075c382a2 100644
--- a/tests/ui/ptr_arg.rs
+++ b/tests/ui/ptr_arg.rs
@@ -267,3 +267,16 @@ mod issue_9218 {
         todo!()
     }
 }
+
+mod issue_11181 {
+    extern "C" fn allowed(_v: &Vec<u32>) {}
+
+    struct S;
+    impl S {
+        extern "C" fn allowed(_v: &Vec<u32>) {}
+    }
+
+    trait T {
+        extern "C" fn allowed(_v: &Vec<u32>) {}
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 7b8598d6c0c28c4e60387f18fae8d5b021ce5907 Mon Sep 17 00:00:00 2001
From: Milo Moisson <milomoisson@gmail.com>
Date: Mon, 24 Jul 2023 01:23:35 +0200
Subject: ptr lint: check_mut_from_ref is checked independently of the
 function's ABI

---
 clippy_lints/src/ptr.rs | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs
index 4534b2ab28a..d32e58c1af9 100644
--- a/clippy_lints/src/ptr.rs
+++ b/clippy_lints/src/ptr.rs
@@ -163,12 +163,13 @@ impl<'tcx> LateLintPass<'tcx> for Ptr {
                 return;
             }
 
+            check_mut_from_ref(cx, sig, None);
+
             if !matches!(sig.header.abi, Abi::Rust) {
                 // Ignore `extern` functions with non-Rust calling conventions
                 return;
             }
 
-            check_mut_from_ref(cx, sig, None);
             for arg in check_fn_args(
                 cx,
                 cx.tcx.fn_sig(item.owner_id).subst_identity().skip_binder().inputs(),
@@ -223,12 +224,13 @@ impl<'tcx> LateLintPass<'tcx> for Ptr {
             _ => return,
         };
 
+        check_mut_from_ref(cx, sig, Some(body));
+
         if !matches!(sig.header.abi, Abi::Rust) {
             // Ignore `extern` functions with non-Rust calling conventions
             return;
         }
 
-        check_mut_from_ref(cx, sig, Some(body));
         let decl = sig.decl;
         let sig = cx.tcx.fn_sig(item_id).subst_identity().skip_binder();
         let lint_args: Vec<_> = check_fn_args(cx, sig.inputs(), decl.inputs, &decl.output, body.params)
-- 
cgit 1.4.1-3-g733a5


From 82982133a9c5ee663b26013ac8ebd3cfb0e0913f Mon Sep 17 00:00:00 2001
From: Milo Moisson <milomoisson@gmail.com>
Date: Mon, 24 Jul 2023 14:54:55 +0200
Subject: changelog: [`min_ident_chars`]: don't lint const generics

---
 clippy_lints/src/min_ident_chars.rs | 8 ++++++++
 tests/ui/min_ident_chars.rs         | 4 ++++
 2 files changed, 12 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/min_ident_chars.rs b/clippy_lints/src/min_ident_chars.rs
index 2a60f2faca0..c79a1a7b9d4 100644
--- a/clippy_lints/src/min_ident_chars.rs
+++ b/clippy_lints/src/min_ident_chars.rs
@@ -129,6 +129,14 @@ impl Visitor<'_> for IdentVisitor<'_, '_> {
                 return;
             }
 
+            // `struct Array<T, const N: usize>([T; N])`
+            //                        ^
+            if let Node::GenericParam(generic_param) = node
+                && let GenericParamKind::Const { .. } = generic_param.kind
+            {
+                return;
+            }
+
             if is_from_proc_macro(cx, &ident) {
                 return;
             }
diff --git a/tests/ui/min_ident_chars.rs b/tests/ui/min_ident_chars.rs
index 0fab224a29d..03784442e2c 100644
--- a/tests/ui/min_ident_chars.rs
+++ b/tests/ui/min_ident_chars.rs
@@ -81,3 +81,7 @@ fn b() {}
 fn wrong_pythagoras(a: f32, b: f32) -> f32 {
     a * a + a * b
 }
+
+mod issue_11163 {
+    struct Array<T, const N: usize>([T; N]);
+}
-- 
cgit 1.4.1-3-g733a5


From 5c26e82d80b4c6f2f1eb54b98edd832f00cbd0a6 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Sun, 23 Jul 2023 17:19:52 +0000
Subject: Remove Gha status emitter in compile-test

---
 clippy_lints/src/utils/mod.rs |  2 +-
 tests/compile-test.rs         | 36 ++++++++++++++++++++----------------
 2 files changed, 21 insertions(+), 17 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index fb08256931f..4fef8c0717d 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -18,7 +18,7 @@ const BOOK_CONFIGS_PATH: &str = "https://doc.rust-lang.org/clippy/lint_configura
 // ==================================================================
 // Configuration
 // ==================================================================
-#[derive(Debug, Clone, Default)] //~ ERROR no such field
+#[derive(Debug, Clone, Default)]
 pub struct ClippyConfiguration {
     pub name: String,
     #[allow(dead_code)]
diff --git a/tests/compile-test.rs b/tests/compile-test.rs
index d70c4ea34cb..596b04fe8a5 100644
--- a/tests/compile-test.rs
+++ b/tests/compile-test.rs
@@ -5,7 +5,7 @@
 #![warn(rust_2018_idioms, unused_lifetimes)]
 #![allow(unused_extern_crates)]
 
-use compiletest::{status_emitter, CommandBuilder};
+use compiletest::{status_emitter, CommandBuilder, OutputConflictHandling};
 use ui_test as compiletest;
 use ui_test::Mode as TestMode;
 
@@ -116,9 +116,9 @@ fn base_config(test_dir: &str) -> compiletest::Config {
         stderr_filters: vec![],
         stdout_filters: vec![],
         output_conflict_handling: if var_os("BLESS").is_some() || env::args().any(|arg| arg == "--bless") {
-            compiletest::OutputConflictHandling::Bless
+            OutputConflictHandling::Bless
         } else {
-            compiletest::OutputConflictHandling::Error("cargo test -- -- --bless".into())
+            OutputConflictHandling::Error("cargo uibless".into())
         },
         target: None,
         out_dir: PathBuf::from(std::env::var_os("CARGO_TARGET_DIR").unwrap_or("target".into())).join("ui_test"),
@@ -187,9 +187,6 @@ fn run_ui() {
                 .to_string()
         }),
     );
-    eprintln!("   Compiler: {}", config.program.display());
-
-    let name = config.root_dir.display().to_string();
 
     let test_filter = test_filter();
 
@@ -197,7 +194,7 @@ fn run_ui() {
         config,
         move |path| compiletest::default_file_filter(path) && test_filter(path),
         compiletest::default_per_file_config,
-        (status_emitter::Text, status_emitter::Gha::<true> { name }),
+        status_emitter::Text,
     )
     .unwrap();
     check_rustfix_coverage();
@@ -208,8 +205,19 @@ fn run_internal_tests() {
     if !RUN_INTERNAL_TESTS {
         return;
     }
-    let config = base_config("ui-internal");
-    compiletest::run_tests(config).unwrap();
+    let mut config = base_config("ui-internal");
+    if let OutputConflictHandling::Error(err) = &mut config.output_conflict_handling {
+        *err = "cargo uitest --features internal -- -- --bless".into();
+    }
+    let test_filter = test_filter();
+
+    compiletest::run_tests_generic(
+        config,
+        move |path| compiletest::default_file_filter(path) && test_filter(path),
+        compiletest::default_per_file_config,
+        status_emitter::Text,
+    )
+    .unwrap();
 }
 
 fn run_ui_toml() {
@@ -228,13 +236,11 @@ fn run_ui_toml() {
         "$$DIR",
     );
 
-    let name = config.root_dir.display().to_string();
-
     let test_filter = test_filter();
 
     ui_test::run_tests_generic(
         config,
-        |path| test_filter(path) && path.extension() == Some("rs".as_ref()),
+        |path| compiletest::default_file_filter(path) && test_filter(path),
         |config, path| {
             let mut config = config.clone();
             config
@@ -243,7 +249,7 @@ fn run_ui_toml() {
                 .push(("CLIPPY_CONF_DIR".into(), Some(path.parent().unwrap().into())));
             Some(config)
         },
-        (status_emitter::Text, status_emitter::Gha::<true> { name }),
+        status_emitter::Text,
     )
     .unwrap();
 }
@@ -284,8 +290,6 @@ fn run_ui_cargo() {
         "$$DIR",
     );
 
-    let name = config.root_dir.display().to_string();
-
     let test_filter = test_filter();
 
     ui_test::run_tests_generic(
@@ -296,7 +300,7 @@ fn run_ui_cargo() {
             config.out_dir = PathBuf::from("target/ui_test_cargo/").join(path.parent().unwrap());
             Some(config)
         },
-        (status_emitter::Text, status_emitter::Gha::<true> { name }),
+        status_emitter::Text,
     )
     .unwrap();
 }
-- 
cgit 1.4.1-3-g733a5


From ef482d17f2f990ac1a9de49c03e771bb0dc1cf3e Mon Sep 17 00:00:00 2001
From: Catherine Flores <catherine.3.flores@gmail.com>
Date: Fri, 21 Jul 2023 09:14:13 -0500
Subject: Do not lint if used as a `fn`-like argument

---
 clippy_lints/src/needless_pass_by_ref_mut.rs    | 113 ++++++++++++++++++------
 tests/ui/infinite_loop.stderr                   |  16 ++--
 tests/ui/let_underscore_future.stderr           |  16 ++--
 tests/ui/mut_key.stderr                         |  16 ++--
 tests/ui/mut_reference.stderr                   |  24 ++---
 tests/ui/needless_pass_by_ref_mut.rs            |  56 +++++++++---
 tests/ui/needless_pass_by_ref_mut.stderr        |  26 +++---
 tests/ui/should_impl_trait/method_list_2.stderr |  18 ++--
 8 files changed, 186 insertions(+), 99 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/needless_pass_by_ref_mut.rs b/clippy_lints/src/needless_pass_by_ref_mut.rs
index c399b43e251..3299dca09c3 100644
--- a/clippy_lints/src/needless_pass_by_ref_mut.rs
+++ b/clippy_lints/src/needless_pass_by_ref_mut.rs
@@ -1,16 +1,16 @@
 use super::needless_pass_by_value::requires_exact_signature;
-use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::diagnostics::span_lint_hir_and_then;
 use clippy_utils::source::snippet;
-use clippy_utils::{is_from_proc_macro, is_self};
-use if_chain::if_chain;
-use rustc_data_structures::fx::FxHashSet;
+use clippy_utils::{get_parent_node, is_from_proc_macro, is_self};
+use rustc_data_structures::fx::{FxHashSet, FxIndexMap};
 use rustc_errors::Applicability;
-use rustc_hir::intravisit::FnKind;
-use rustc_hir::{Body, FnDecl, HirId, HirIdMap, HirIdSet, Impl, ItemKind, Mutability, Node, PatKind};
+use rustc_hir::intravisit::{walk_qpath, FnKind, Visitor};
+use rustc_hir::{Body, ExprKind, FnDecl, HirId, HirIdMap, HirIdSet, Impl, ItemKind, Mutability, Node, PatKind, QPath};
 use rustc_hir_typeck::expr_use_visitor as euv;
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::map::associated_body;
+use rustc_middle::hir::nested_filter::OnlyBodies;
 use rustc_middle::mir::FakeReadCause;
 use rustc_middle::ty::{self, Ty, UpvarId, UpvarPath};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
@@ -48,20 +48,24 @@ declare_clippy_lint! {
     "using a `&mut` argument when it's not mutated"
 }
 
-#[derive(Copy, Clone)]
-pub struct NeedlessPassByRefMut {
+#[derive(Clone)]
+pub struct NeedlessPassByRefMut<'tcx> {
     avoid_breaking_exported_api: bool,
+    used_fn_def_ids: FxHashSet<LocalDefId>,
+    fn_def_ids_to_maybe_unused_mut: FxIndexMap<LocalDefId, Vec<rustc_hir::Ty<'tcx>>>,
 }
 
-impl NeedlessPassByRefMut {
+impl NeedlessPassByRefMut<'_> {
     pub fn new(avoid_breaking_exported_api: bool) -> Self {
         Self {
             avoid_breaking_exported_api,
+            used_fn_def_ids: FxHashSet::default(),
+            fn_def_ids_to_maybe_unused_mut: FxIndexMap::default(),
         }
     }
 }
 
-impl_lint_pass!(NeedlessPassByRefMut => [NEEDLESS_PASS_BY_REF_MUT]);
+impl_lint_pass!(NeedlessPassByRefMut<'_> => [NEEDLESS_PASS_BY_REF_MUT]);
 
 fn should_skip<'tcx>(
     cx: &LateContext<'tcx>,
@@ -89,12 +93,12 @@ fn should_skip<'tcx>(
     is_from_proc_macro(cx, &input)
 }
 
-impl<'tcx> LateLintPass<'tcx> for NeedlessPassByRefMut {
+impl<'tcx> LateLintPass<'tcx> for NeedlessPassByRefMut<'tcx> {
     fn check_fn(
         &mut self,
         cx: &LateContext<'tcx>,
         kind: FnKind<'tcx>,
-        decl: &'tcx FnDecl<'_>,
+        decl: &'tcx FnDecl<'tcx>,
         body: &'tcx Body<'_>,
         span: Span,
         fn_def_id: LocalDefId,
@@ -140,7 +144,6 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByRefMut {
         if it.peek().is_none() {
             return;
         }
-
         // Collect variables mutably used and spans which will need dereferencings from the
         // function body.
         let MutablyUsedVariablesCtxt { mutably_used_vars, .. } = {
@@ -165,30 +168,45 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByRefMut {
             }
             ctx
         };
-
-        let show_semver_warning = self.avoid_breaking_exported_api && cx.effective_visibilities.is_exported(fn_def_id);
         for ((&input, &_), arg) in it {
             // Only take `&mut` arguments.
-            if_chain! {
-                if let PatKind::Binding(_, canonical_id, ..) = arg.pat.kind;
-                if !mutably_used_vars.contains(&canonical_id);
-                if let rustc_hir::TyKind::Ref(_, inner_ty) = input.kind;
-                then {
-                    // If the argument is never used mutably, we emit the warning.
-                    let sp = input.span;
-                    span_lint_and_then(
+            if let PatKind::Binding(_, canonical_id, ..) = arg.pat.kind
+                && !mutably_used_vars.contains(&canonical_id)
+            {
+                self.fn_def_ids_to_maybe_unused_mut.entry(fn_def_id).or_default().push(input);
+            }
+        }
+    }
+
+    fn check_crate_post(&mut self, cx: &LateContext<'tcx>) {
+        cx.tcx.hir().visit_all_item_likes_in_crate(&mut FnNeedsMutVisitor {
+            cx,
+            used_fn_def_ids: &mut self.used_fn_def_ids,
+        });
+
+        for (fn_def_id, unused) in self
+            .fn_def_ids_to_maybe_unused_mut
+            .iter()
+            .filter(|(def_id, _)| !self.used_fn_def_ids.contains(def_id))
+        {
+            let show_semver_warning =
+                self.avoid_breaking_exported_api && cx.effective_visibilities.is_exported(*fn_def_id);
+
+            for input in unused {
+                // If the argument is never used mutably, we emit the warning.
+                let sp = input.span;
+                if let rustc_hir::TyKind::Ref(_, inner_ty) = input.kind {
+                    span_lint_hir_and_then(
                         cx,
                         NEEDLESS_PASS_BY_REF_MUT,
+                        cx.tcx.hir().local_def_id_to_hir_id(*fn_def_id),
                         sp,
                         "this argument is a mutable reference, but not used mutably",
                         |diag| {
                             diag.span_suggestion(
                                 sp,
                                 "consider changing to".to_string(),
-                                format!(
-                                    "&{}",
-                                    snippet(cx, cx.tcx.hir().span(inner_ty.ty.hir_id), "_"),
-                                ),
+                                format!("&{}", snippet(cx, cx.tcx.hir().span(inner_ty.ty.hir_id), "_"),),
                                 Applicability::Unspecified,
                             );
                             if show_semver_warning {
@@ -316,3 +334,44 @@ impl<'tcx> euv::Delegate<'tcx> for MutablyUsedVariablesCtxt {
         self.prev_bind = Some(id);
     }
 }
+
+/// A final pass to check for paths referencing this function that require the argument to be
+/// `&mut`, basically if the function is ever used as a `fn`-like argument.
+struct FnNeedsMutVisitor<'a, 'tcx> {
+    cx: &'a LateContext<'tcx>,
+    used_fn_def_ids: &'a mut FxHashSet<LocalDefId>,
+}
+
+impl<'tcx> Visitor<'tcx> for FnNeedsMutVisitor<'_, 'tcx> {
+    type NestedFilter = OnlyBodies;
+
+    fn nested_visit_map(&mut self) -> Self::Map {
+        self.cx.tcx.hir()
+    }
+
+    fn visit_qpath(&mut self, qpath: &'tcx QPath<'tcx>, hir_id: HirId, _: Span) {
+        walk_qpath(self, qpath, hir_id);
+
+        let Self { cx, used_fn_def_ids } = self;
+
+        // #11182; do not lint if mutability is required elsewhere
+        if let Node::Expr(expr) = cx.tcx.hir().get(hir_id)
+            && let Some(parent) = get_parent_node(cx.tcx, expr.hir_id)
+            && let ty::FnDef(def_id, _) = cx.tcx.typeck(cx.tcx.hir().enclosing_body_owner(hir_id)).expr_ty(expr).kind()
+            && let Some(def_id) = def_id.as_local()
+        {
+            if let Node::Expr(e) = parent
+                && let ExprKind::Call(call, _) = e.kind
+                && call.hir_id == expr.hir_id
+            {
+                return;
+            }
+
+            // We don't need to check each argument individually as you cannot coerce a function
+            // taking `&mut` -> `&`, for some reason, so if we've gotten this far we know it's
+            // passed as a `fn`-like argument (or is unified) and should ignore every "unused"
+            // argument entirely
+            used_fn_def_ids.insert(def_id);
+        }
+    }
+}
diff --git a/tests/ui/infinite_loop.stderr b/tests/ui/infinite_loop.stderr
index 701b3cd1904..04559f9ada4 100644
--- a/tests/ui/infinite_loop.stderr
+++ b/tests/ui/infinite_loop.stderr
@@ -1,11 +1,3 @@
-error: this argument is a mutable reference, but not used mutably
-  --> $DIR/infinite_loop.rs:7:17
-   |
-LL | fn fn_mutref(i: &mut i32) {
-   |                 ^^^^^^^^ help: consider changing to: `&i32`
-   |
-   = note: `-D clippy::needless-pass-by-ref-mut` implied by `-D warnings`
-
 error: variables in the condition are not mutated in the loop body
   --> $DIR/infinite_loop.rs:20:11
    |
@@ -99,5 +91,13 @@ LL |     while y < 10 {
    = note: this loop contains `return`s or `break`s
    = help: rewrite it as `if cond { loop { } }`
 
+error: this argument is a mutable reference, but not used mutably
+  --> $DIR/infinite_loop.rs:7:17
+   |
+LL | fn fn_mutref(i: &mut i32) {
+   |                 ^^^^^^^^ help: consider changing to: `&i32`
+   |
+   = note: `-D clippy::needless-pass-by-ref-mut` implied by `-D warnings`
+
 error: aborting due to 12 previous errors
 
diff --git a/tests/ui/let_underscore_future.stderr b/tests/ui/let_underscore_future.stderr
index 9e69fb04133..ff1e2b8c901 100644
--- a/tests/ui/let_underscore_future.stderr
+++ b/tests/ui/let_underscore_future.stderr
@@ -1,11 +1,3 @@
-error: this argument is a mutable reference, but not used mutably
-  --> $DIR/let_underscore_future.rs:11:35
-   |
-LL | fn do_something_to_future(future: &mut impl Future<Output = ()>) {}
-   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider changing to: `&impl Future<Output = ()>`
-   |
-   = note: `-D clippy::needless-pass-by-ref-mut` implied by `-D warnings`
-
 error: non-binding `let` on a future
   --> $DIR/let_underscore_future.rs:14:5
    |
@@ -31,5 +23,13 @@ LL |     let _ = future;
    |
    = help: consider awaiting the future or dropping explicitly with `std::mem::drop`
 
+error: this argument is a mutable reference, but not used mutably
+  --> $DIR/let_underscore_future.rs:11:35
+   |
+LL | fn do_something_to_future(future: &mut impl Future<Output = ()>) {}
+   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider changing to: `&impl Future<Output = ()>`
+   |
+   = note: `-D clippy::needless-pass-by-ref-mut` implied by `-D warnings`
+
 error: aborting due to 4 previous errors
 
diff --git a/tests/ui/mut_key.stderr b/tests/ui/mut_key.stderr
index 02a0da86a4b..3f756f5f0e5 100644
--- a/tests/ui/mut_key.stderr
+++ b/tests/ui/mut_key.stderr
@@ -12,14 +12,6 @@ error: mutable key type
 LL | fn should_not_take_this_arg(m: &mut HashMap<Key, usize>, _n: usize) -> HashSet<Key> {
    |                                                                        ^^^^^^^^^^^^
 
-error: this argument is a mutable reference, but not used mutably
-  --> $DIR/mut_key.rs:31:32
-   |
-LL | fn should_not_take_this_arg(m: &mut HashMap<Key, usize>, _n: usize) -> HashSet<Key> {
-   |                                ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider changing to: `&HashMap<Key, usize>`
-   |
-   = note: `-D clippy::needless-pass-by-ref-mut` implied by `-D warnings`
-
 error: mutable key type
   --> $DIR/mut_key.rs:32:5
    |
@@ -110,5 +102,13 @@ error: mutable key type
 LL |     let _map = HashMap::<Arc<Cell<usize>>, usize>::new();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
+error: this argument is a mutable reference, but not used mutably
+  --> $DIR/mut_key.rs:31:32
+   |
+LL | fn should_not_take_this_arg(m: &mut HashMap<Key, usize>, _n: usize) -> HashSet<Key> {
+   |                                ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider changing to: `&HashMap<Key, usize>`
+   |
+   = note: `-D clippy::needless-pass-by-ref-mut` implied by `-D warnings`
+
 error: aborting due to 18 previous errors
 
diff --git a/tests/ui/mut_reference.stderr b/tests/ui/mut_reference.stderr
index 23c812475c2..1fdfbf9227e 100644
--- a/tests/ui/mut_reference.stderr
+++ b/tests/ui/mut_reference.stderr
@@ -1,17 +1,3 @@
-error: this argument is a mutable reference, but not used mutably
-  --> $DIR/mut_reference.rs:4:33
-   |
-LL | fn takes_a_mutable_reference(a: &mut i32) {}
-   |                                 ^^^^^^^^ help: consider changing to: `&i32`
-   |
-   = note: `-D clippy::needless-pass-by-ref-mut` implied by `-D warnings`
-
-error: this argument is a mutable reference, but not used mutably
-  --> $DIR/mut_reference.rs:11:44
-   |
-LL |     fn takes_a_mutable_reference(&self, a: &mut i32) {}
-   |                                            ^^^^^^^^ help: consider changing to: `&i32`
-
 error: the function `takes_an_immutable_reference` doesn't need a mutable reference
   --> $DIR/mut_reference.rs:17:34
    |
@@ -32,5 +18,13 @@ error: the method `takes_an_immutable_reference` doesn't need a mutable referenc
 LL |     my_struct.takes_an_immutable_reference(&mut 42);
    |                                            ^^^^^^^
 
-error: aborting due to 5 previous errors
+error: this argument is a mutable reference, but not used mutably
+  --> $DIR/mut_reference.rs:11:44
+   |
+LL |     fn takes_a_mutable_reference(&self, a: &mut i32) {}
+   |                                            ^^^^^^^^ help: consider changing to: `&i32`
+   |
+   = note: `-D clippy::needless-pass-by-ref-mut` implied by `-D warnings`
+
+error: aborting due to 4 previous errors
 
diff --git a/tests/ui/needless_pass_by_ref_mut.rs b/tests/ui/needless_pass_by_ref_mut.rs
index 27e1fc075bb..49f88978bff 100644
--- a/tests/ui/needless_pass_by_ref_mut.rs
+++ b/tests/ui/needless_pass_by_ref_mut.rs
@@ -1,4 +1,5 @@
-#![allow(unused)]
+#![allow(clippy::if_same_then_else, clippy::no_effect)]
+#![feature(lint_reasons)]
 
 use std::ptr::NonNull;
 
@@ -155,15 +156,48 @@ async fn a8(x: i32, a: &mut i32, y: i32, z: &mut i32) {
     println!("{:?}", z);
 }
 
+// Should not warn (passed as closure which takes `&mut`).
+fn passed_as_closure(s: &mut u32) {}
+
+// Should not warn.
+fn passed_as_local(s: &mut u32) {}
+
+// Should not warn.
+fn ty_unify_1(s: &mut u32) {}
+
+// Should not warn.
+fn ty_unify_2(s: &mut u32) {}
+
+// Should not warn.
+fn passed_as_field(s: &mut u32) {}
+
+fn closure_takes_mut(s: fn(&mut u32)) {}
+
+struct A {
+    s: fn(&mut u32),
+}
+
+// Should warn.
+fn used_as_path(s: &mut u32) {}
+
+// Make sure lint attributes work fine
+#[expect(clippy::needless_pass_by_ref_mut)]
+fn lint_attr(s: &mut u32) {}
+
 fn main() {
-    // let mut u = 0;
-    // let mut v = vec![0];
-    // foo(&mut v, &0, &mut u);
-    // foo2(&mut v);
-    // foo3(&mut v);
-    // foo4(&mut v);
-    // foo5(&mut v);
-    // alias_check(&mut v);
-    // alias_check2(&mut v);
-    // println!("{u}");
+    let mut u = 0;
+    let mut v = vec![0];
+    foo(&mut v, &0, &mut u);
+    foo2(&mut v);
+    foo3(&mut v);
+    foo4(&mut v);
+    foo5(&mut v);
+    alias_check(&mut v);
+    alias_check2(&mut v);
+    println!("{u}");
+    closure_takes_mut(passed_as_closure);
+    A { s: passed_as_field };
+    used_as_path;
+    let _: fn(&mut u32) = passed_as_local;
+    let _ = if v[0] == 0 { ty_unify_1 } else { ty_unify_2 };
 }
diff --git a/tests/ui/needless_pass_by_ref_mut.stderr b/tests/ui/needless_pass_by_ref_mut.stderr
index caf47bbce86..4ab5b5675ca 100644
--- a/tests/ui/needless_pass_by_ref_mut.stderr
+++ b/tests/ui/needless_pass_by_ref_mut.stderr
@@ -1,5 +1,5 @@
 error: this argument is a mutable reference, but not used mutably
-  --> $DIR/needless_pass_by_ref_mut.rs:6:11
+  --> $DIR/needless_pass_by_ref_mut.rs:7:11
    |
 LL | fn foo(s: &mut Vec<u32>, b: &u32, x: &mut u32) {
    |           ^^^^^^^^^^^^^ help: consider changing to: `&Vec<u32>`
@@ -7,73 +7,73 @@ LL | fn foo(s: &mut Vec<u32>, b: &u32, x: &mut u32) {
    = note: `-D clippy::needless-pass-by-ref-mut` implied by `-D warnings`
 
 error: this argument is a mutable reference, but not used mutably
-  --> $DIR/needless_pass_by_ref_mut.rs:31:12
+  --> $DIR/needless_pass_by_ref_mut.rs:32:12
    |
 LL | fn foo6(s: &mut Vec<u32>) {
    |            ^^^^^^^^^^^^^ help: consider changing to: `&Vec<u32>`
 
 error: this argument is a mutable reference, but not used mutably
-  --> $DIR/needless_pass_by_ref_mut.rs:44:29
+  --> $DIR/needless_pass_by_ref_mut.rs:45:29
    |
 LL |     fn mushroom(&self, vec: &mut Vec<i32>) -> usize {
    |                             ^^^^^^^^^^^^^ help: consider changing to: `&Vec<i32>`
 
 error: this argument is a mutable reference, but not used mutably
-  --> $DIR/needless_pass_by_ref_mut.rs:49:31
+  --> $DIR/needless_pass_by_ref_mut.rs:50:31
    |
 LL |     fn badger(&mut self, vec: &mut Vec<i32>) -> usize {
    |                               ^^^^^^^^^^^^^ help: consider changing to: `&Vec<i32>`
 
 error: this argument is a mutable reference, but not used mutably
-  --> $DIR/needless_pass_by_ref_mut.rs:126:16
+  --> $DIR/needless_pass_by_ref_mut.rs:127:16
    |
 LL | async fn a1(x: &mut i32) {
    |                ^^^^^^^^ help: consider changing to: `&i32`
 
 error: this argument is a mutable reference, but not used mutably
-  --> $DIR/needless_pass_by_ref_mut.rs:130:16
+  --> $DIR/needless_pass_by_ref_mut.rs:131:16
    |
 LL | async fn a2(x: &mut i32, y: String) {
    |                ^^^^^^^^ help: consider changing to: `&i32`
 
 error: this argument is a mutable reference, but not used mutably
-  --> $DIR/needless_pass_by_ref_mut.rs:134:16
+  --> $DIR/needless_pass_by_ref_mut.rs:135:16
    |
 LL | async fn a3(x: &mut i32, y: String, z: String) {
    |                ^^^^^^^^ help: consider changing to: `&i32`
 
 error: this argument is a mutable reference, but not used mutably
-  --> $DIR/needless_pass_by_ref_mut.rs:138:16
+  --> $DIR/needless_pass_by_ref_mut.rs:139:16
    |
 LL | async fn a4(x: &mut i32, y: i32) {
    |                ^^^^^^^^ help: consider changing to: `&i32`
 
 error: this argument is a mutable reference, but not used mutably
-  --> $DIR/needless_pass_by_ref_mut.rs:142:24
+  --> $DIR/needless_pass_by_ref_mut.rs:143:24
    |
 LL | async fn a5(x: i32, y: &mut i32) {
    |                        ^^^^^^^^ help: consider changing to: `&i32`
 
 error: this argument is a mutable reference, but not used mutably
-  --> $DIR/needless_pass_by_ref_mut.rs:146:24
+  --> $DIR/needless_pass_by_ref_mut.rs:147:24
    |
 LL | async fn a6(x: i32, y: &mut i32) {
    |                        ^^^^^^^^ help: consider changing to: `&i32`
 
 error: this argument is a mutable reference, but not used mutably
-  --> $DIR/needless_pass_by_ref_mut.rs:150:32
+  --> $DIR/needless_pass_by_ref_mut.rs:151:32
    |
 LL | async fn a7(x: i32, y: i32, z: &mut i32) {
    |                                ^^^^^^^^ help: consider changing to: `&i32`
 
 error: this argument is a mutable reference, but not used mutably
-  --> $DIR/needless_pass_by_ref_mut.rs:154:24
+  --> $DIR/needless_pass_by_ref_mut.rs:155:24
    |
 LL | async fn a8(x: i32, a: &mut i32, y: i32, z: &mut i32) {
    |                        ^^^^^^^^ help: consider changing to: `&i32`
 
 error: this argument is a mutable reference, but not used mutably
-  --> $DIR/needless_pass_by_ref_mut.rs:154:45
+  --> $DIR/needless_pass_by_ref_mut.rs:155:45
    |
 LL | async fn a8(x: i32, a: &mut i32, y: i32, z: &mut i32) {
    |                                             ^^^^^^^^ help: consider changing to: `&i32`
diff --git a/tests/ui/should_impl_trait/method_list_2.stderr b/tests/ui/should_impl_trait/method_list_2.stderr
index 2ae9fa34d14..a3bb05bf176 100644
--- a/tests/ui/should_impl_trait/method_list_2.stderr
+++ b/tests/ui/should_impl_trait/method_list_2.stderr
@@ -39,15 +39,6 @@ LL | |     }
    |
    = help: consider implementing the trait `std::hash::Hash` or choosing a less ambiguous method name
 
-error: this argument is a mutable reference, but not used mutably
-  --> $DIR/method_list_2.rs:38:31
-   |
-LL |     pub fn hash(&self, state: &mut T) {
-   |                               ^^^^^^ help: consider changing to: `&T`
-   |
-   = warning: changing this function will impact semver compatibility
-   = note: `-D clippy::needless-pass-by-ref-mut` implied by `-D warnings`
-
 error: method `index` can be confused for the standard trait method `std::ops::Index::index`
   --> $DIR/method_list_2.rs:42:5
    |
@@ -158,5 +149,14 @@ LL | |     }
    |
    = help: consider implementing the trait `std::ops::Sub` or choosing a less ambiguous method name
 
+error: this argument is a mutable reference, but not used mutably
+  --> $DIR/method_list_2.rs:38:31
+   |
+LL |     pub fn hash(&self, state: &mut T) {
+   |                               ^^^^^^ help: consider changing to: `&T`
+   |
+   = warning: changing this function will impact semver compatibility
+   = note: `-D clippy::needless-pass-by-ref-mut` implied by `-D warnings`
+
 error: aborting due to 16 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 15de3dd2afcedef99ef6a1dd485734d94b00bb99 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Tue, 25 Jul 2023 18:08:16 +0200
Subject: Add a note if the function is behind a cfg

---
 clippy_lints/src/needless_pass_by_ref_mut.rs | 21 ++++++++++++++++++---
 tests/ui/needless_pass_by_ref_mut.rs         | 10 ++++++++++
 tests/ui/needless_pass_by_ref_mut.stderr     | 18 +++++++++++++++++-
 3 files changed, 45 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/needless_pass_by_ref_mut.rs b/clippy_lints/src/needless_pass_by_ref_mut.rs
index 3299dca09c3..b4be910c8ad 100644
--- a/clippy_lints/src/needless_pass_by_ref_mut.rs
+++ b/clippy_lints/src/needless_pass_by_ref_mut.rs
@@ -12,11 +12,11 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::map::associated_body;
 use rustc_middle::hir::nested_filter::OnlyBodies;
 use rustc_middle::mir::FakeReadCause;
-use rustc_middle::ty::{self, Ty, UpvarId, UpvarPath};
+use rustc_middle::ty::{self, Ty, TyCtxt, UpvarId, UpvarPath};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::def_id::LocalDefId;
+use rustc_span::def_id::{LocalDefId, CRATE_DEF_ID};
 use rustc_span::symbol::kw;
-use rustc_span::Span;
+use rustc_span::{sym, Span};
 use rustc_target::spec::abi::Abi;
 
 declare_clippy_lint! {
@@ -93,6 +93,16 @@ fn should_skip<'tcx>(
     is_from_proc_macro(cx, &input)
 }
 
+fn inherits_cfg(tcx: TyCtxt<'_>, def_id: LocalDefId) -> bool {
+    if def_id == CRATE_DEF_ID {
+        false
+    } else if tcx.has_attr(def_id, sym::cfg) {
+        true
+    } else {
+        inherits_cfg(tcx, tcx.parent_module_from_def_id(def_id))
+    }
+}
+
 impl<'tcx> LateLintPass<'tcx> for NeedlessPassByRefMut<'tcx> {
     fn check_fn(
         &mut self,
@@ -192,10 +202,12 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByRefMut<'tcx> {
             let show_semver_warning =
                 self.avoid_breaking_exported_api && cx.effective_visibilities.is_exported(*fn_def_id);
 
+            let mut is_cfged = None;
             for input in unused {
                 // If the argument is never used mutably, we emit the warning.
                 let sp = input.span;
                 if let rustc_hir::TyKind::Ref(_, inner_ty) = input.kind {
+                    let is_cfged = is_cfged.get_or_insert_with(|| inherits_cfg(cx.tcx, *fn_def_id));
                     span_lint_hir_and_then(
                         cx,
                         NEEDLESS_PASS_BY_REF_MUT,
@@ -212,6 +224,9 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByRefMut<'tcx> {
                             if show_semver_warning {
                                 diag.warn("changing this function will impact semver compatibility");
                             }
+                            if *is_cfged {
+                                diag.note("this is cfg-gated and may require further changes");
+                            }
                         },
                     );
                 }
diff --git a/tests/ui/needless_pass_by_ref_mut.rs b/tests/ui/needless_pass_by_ref_mut.rs
index 49f88978bff..b3933bb9b4a 100644
--- a/tests/ui/needless_pass_by_ref_mut.rs
+++ b/tests/ui/needless_pass_by_ref_mut.rs
@@ -184,6 +184,16 @@ fn used_as_path(s: &mut u32) {}
 #[expect(clippy::needless_pass_by_ref_mut)]
 fn lint_attr(s: &mut u32) {}
 
+#[cfg(not(feature = "a"))]
+// Should warn with note.
+fn cfg_warn(s: &mut u32) {}
+
+#[cfg(not(feature = "a"))]
+mod foo {
+    // Should warn with note.
+    fn cfg_warn(s: &mut u32) {}
+}
+
 fn main() {
     let mut u = 0;
     let mut v = vec![0];
diff --git a/tests/ui/needless_pass_by_ref_mut.stderr b/tests/ui/needless_pass_by_ref_mut.stderr
index 4ab5b5675ca..977dd5154b0 100644
--- a/tests/ui/needless_pass_by_ref_mut.stderr
+++ b/tests/ui/needless_pass_by_ref_mut.stderr
@@ -78,5 +78,21 @@ error: this argument is a mutable reference, but not used mutably
 LL | async fn a8(x: i32, a: &mut i32, y: i32, z: &mut i32) {
    |                                             ^^^^^^^^ help: consider changing to: `&i32`
 
-error: aborting due to 13 previous errors
+error: this argument is a mutable reference, but not used mutably
+  --> $DIR/needless_pass_by_ref_mut.rs:189:16
+   |
+LL | fn cfg_warn(s: &mut u32) {}
+   |                ^^^^^^^^ help: consider changing to: `&u32`
+   |
+   = note: this is cfg-gated and may require further changes
+
+error: this argument is a mutable reference, but not used mutably
+  --> $DIR/needless_pass_by_ref_mut.rs:194:20
+   |
+LL |     fn cfg_warn(s: &mut u32) {}
+   |                    ^^^^^^^^ help: consider changing to: `&u32`
+   |
+   = note: this is cfg-gated and may require further changes
+
+error: aborting due to 15 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 1fe27629005f15d51bfa770ab4ba330b47e7d9ed Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Tue, 25 Jul 2023 18:21:00 +0200
Subject: use a dedicated enum for vec initializer

---
 clippy_lints/src/slow_vector_initialization.rs | 63 ++++++++++++--------------
 1 file changed, 30 insertions(+), 33 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/slow_vector_initialization.rs b/clippy_lints/src/slow_vector_initialization.rs
index b496185cc72..01da63d2b00 100644
--- a/clippy_lints/src/slow_vector_initialization.rs
+++ b/clippy_lints/src/slow_vector_initialization.rs
@@ -61,11 +61,24 @@ struct VecAllocation<'tcx> {
 
     /// Reference to the expression used as argument on `with_capacity` call. This is used
     /// to only match slow zero-filling idioms of the same length than vector initialization.
-    ///
-    /// Initially set to `None` if initialized with `Vec::new()`, but will always be `Some(_)` by
-    /// the time the visitor has looked through the enclosing block and found a slow
-    /// initialization, so it is safe to unwrap later at lint time.
-    size_expr: Option<&'tcx Expr<'tcx>>,
+    size_expr: InitializedSize<'tcx>,
+}
+
+/// Initializer for the creation of the vector.
+///
+/// When `Vec::with_capacity(size)` is found, the `size` expression will be in
+/// `InitializedSize::Initialized`.
+///
+/// Otherwise, for `Vec::new()` calls, there is no allocation initializer yet, so
+/// `InitializedSize::Uninitialized` is used.
+/// Later, when a call to `.resize(size, 0)` or similar is found, it's set
+/// to `InitializedSize::Initialized(size)`.
+///
+/// Since it will be set to `InitializedSize::Initialized(size)` when a slow initialization is
+/// found, it is always safe to "unwrap" it at lint time.
+enum InitializedSize<'tcx> {
+    Initialized(&'tcx Expr<'tcx>),
+    Uninitialized,
 }
 
 /// Type of slow initialization
@@ -120,20 +133,11 @@ impl<'tcx> LateLintPass<'tcx> for SlowVectorInit {
 }
 
 impl SlowVectorInit {
-    /// Given an expression, returns:
-    /// - `Some(Some(size))` if it is a function call to `Vec::with_capacity(size)`
-    /// - `Some(None)` if it is a call to `Vec::new()`
-    /// - `None` if it is neither
-    #[allow(
-        clippy::option_option,
-        reason = "outer option is immediately removed at call site and the inner option is kept around, \
-            so extracting into a dedicated enum seems unnecessarily complicated"
-    )]
-    fn as_vec_initializer<'tcx>(cx: &LateContext<'_>, expr: &'tcx Expr<'tcx>) -> Option<Option<&'tcx Expr<'tcx>>> {
+    fn as_vec_initializer<'tcx>(cx: &LateContext<'_>, expr: &'tcx Expr<'tcx>) -> Option<InitializedSize<'tcx>> {
         if let Some(len_expr) = Self::is_vec_with_capacity(cx, expr) {
-            Some(Some(len_expr))
-        } else if Self::is_vec_new(cx, expr) {
-            Some(None)
+            Some(InitializedSize::Initialized(len_expr))
+        } else if matches!(expr.kind, ExprKind::Call(func, _) if is_expr_path_def_path(cx, func, &paths::VEC_NEW)) {
+            Some(InitializedSize::Uninitialized)
         } else {
             None
         }
@@ -155,14 +159,6 @@ impl SlowVectorInit {
         }
     }
 
-    /// Checks if the given expression is `Vec::new()`
-    fn is_vec_new(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-        matches!(
-            expr.kind,
-            ExprKind::Call(func, _) if is_expr_path_def_path(cx, func, &paths::VEC_NEW)
-        )
-    }
-
     /// Search initialization for the given vector
     fn search_initialization<'tcx>(cx: &LateContext<'tcx>, vec_alloc: VecAllocation<'tcx>, parent_node: HirId) {
         let enclosing_body = get_enclosing_block(cx, parent_node);
@@ -200,9 +196,10 @@ impl SlowVectorInit {
     fn emit_lint(cx: &LateContext<'_>, slow_fill: &Expr<'_>, vec_alloc: &VecAllocation<'_>, msg: &str) {
         let len_expr = Sugg::hir(
             cx,
-            vec_alloc
-                .size_expr
-                .expect("length expression must be set by this point"),
+            match vec_alloc.size_expr {
+                InitializedSize::Initialized(expr) => expr,
+                InitializedSize::Uninitialized => unreachable!("size expression must be set by this point"),
+            },
             "len",
         );
 
@@ -257,12 +254,12 @@ impl<'a, 'tcx> VectorInitializationVisitor<'a, 'tcx> {
             // Check that is filled with 0
             && is_integer_literal(fill_arg, 0)
         {
-            let is_matching_resize = if let Some(size_expr) = self.vec_alloc.size_expr {
+            let is_matching_resize = if let InitializedSize::Initialized(size_expr) = self.vec_alloc.size_expr {
                 // If we have a size expression, check that it is equal to what's passed to `resize`
                 SpanlessEq::new(self.cx).eq_expr(len_arg, size_expr)
                     || matches!(len_arg.kind, ExprKind::MethodCall(path, ..) if path.ident.as_str() == "capacity")
             } else {
-                self.vec_alloc.size_expr = Some(len_arg);
+                self.vec_alloc.size_expr = InitializedSize::Initialized(len_arg);
                 true
             };
 
@@ -280,13 +277,13 @@ impl<'a, 'tcx> VectorInitializationVisitor<'a, 'tcx> {
             // Check that take is applied to `repeat(0)`
             if self.is_repeat_zero(recv);
             then {
-                if let Some(size_expr) = self.vec_alloc.size_expr {
+                if let InitializedSize::Initialized(size_expr) = self.vec_alloc.size_expr {
                     // Check that len expression is equals to `with_capacity` expression
                     return SpanlessEq::new(self.cx).eq_expr(len_arg, size_expr)
                         || matches!(len_arg.kind, ExprKind::MethodCall(path, ..) if path.ident.as_str() == "capacity")
                 }
 
-                self.vec_alloc.size_expr = Some(len_arg);
+                self.vec_alloc.size_expr = InitializedSize::Initialized(len_arg);
                 return true;
             }
         }
-- 
cgit 1.4.1-3-g733a5


From 1c9772c7737e5937f71be1d1a27699bf226d89f1 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Tue, 25 Jul 2023 18:43:51 +0200
Subject: Move `inherits_cfg` function into clippy_utils

---
 clippy_lints/src/needless_pass_by_ref_mut.rs | 18 ++++--------------
 clippy_utils/src/lib.rs                      | 11 +++++++++++
 2 files changed, 15 insertions(+), 14 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/needless_pass_by_ref_mut.rs b/clippy_lints/src/needless_pass_by_ref_mut.rs
index b4be910c8ad..0e2a101a977 100644
--- a/clippy_lints/src/needless_pass_by_ref_mut.rs
+++ b/clippy_lints/src/needless_pass_by_ref_mut.rs
@@ -1,7 +1,7 @@
 use super::needless_pass_by_value::requires_exact_signature;
 use clippy_utils::diagnostics::span_lint_hir_and_then;
 use clippy_utils::source::snippet;
-use clippy_utils::{get_parent_node, is_from_proc_macro, is_self};
+use clippy_utils::{get_parent_node, inherits_cfg, is_from_proc_macro, is_self};
 use rustc_data_structures::fx::{FxHashSet, FxIndexMap};
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_qpath, FnKind, Visitor};
@@ -12,11 +12,11 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::map::associated_body;
 use rustc_middle::hir::nested_filter::OnlyBodies;
 use rustc_middle::mir::FakeReadCause;
-use rustc_middle::ty::{self, Ty, TyCtxt, UpvarId, UpvarPath};
+use rustc_middle::ty::{self, Ty, UpvarId, UpvarPath};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::def_id::{LocalDefId, CRATE_DEF_ID};
+use rustc_span::def_id::LocalDefId;
 use rustc_span::symbol::kw;
-use rustc_span::{sym, Span};
+use rustc_span::Span;
 use rustc_target::spec::abi::Abi;
 
 declare_clippy_lint! {
@@ -93,16 +93,6 @@ fn should_skip<'tcx>(
     is_from_proc_macro(cx, &input)
 }
 
-fn inherits_cfg(tcx: TyCtxt<'_>, def_id: LocalDefId) -> bool {
-    if def_id == CRATE_DEF_ID {
-        false
-    } else if tcx.has_attr(def_id, sym::cfg) {
-        true
-    } else {
-        inherits_cfg(tcx, tcx.parent_module_from_def_id(def_id))
-    }
-}
-
 impl<'tcx> LateLintPass<'tcx> for NeedlessPassByRefMut<'tcx> {
     fn check_fn(
         &mut self,
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 8429192437c..beff0e6e1ab 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -2451,6 +2451,17 @@ pub fn is_in_cfg_test(tcx: TyCtxt<'_>, id: hir::HirId) -> bool {
         .any(is_cfg_test)
 }
 
+/// Checks if the item of any of its parents has `#[cfg(...)]` attribute applied.
+pub fn inherits_cfg(tcx: TyCtxt<'_>, def_id: LocalDefId) -> bool {
+    let hir = tcx.hir();
+
+    tcx.has_attr(def_id, sym::cfg)
+        || hir
+            .parent_iter(hir.local_def_id_to_hir_id(def_id))
+            .flat_map(|(parent_id, _)| hir.attrs(parent_id))
+            .any(|attr| attr.has_name(sym::cfg))
+}
+
 /// Checks whether item either has `test` attribute applied, or
 /// is a module with `test` in its name.
 ///
-- 
cgit 1.4.1-3-g733a5


From c0484b74f79d2e648083a6c52a697aae66202707 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Tue, 25 Jul 2023 18:56:57 +0200
Subject: simplify looking for `Vec::with_capacity` exprs

---
 clippy_lints/src/slow_vector_initialization.rs | 28 +++++++++-----------------
 clippy_utils/src/paths.rs                      |  1 +
 2 files changed, 10 insertions(+), 19 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/slow_vector_initialization.rs b/clippy_lints/src/slow_vector_initialization.rs
index 01da63d2b00..54a33eb2986 100644
--- a/clippy_lints/src/slow_vector_initialization.rs
+++ b/clippy_lints/src/slow_vector_initialization.rs
@@ -1,6 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::sugg::Sugg;
-use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::{
     get_enclosing_block, is_expr_path_def_path, is_integer_literal, is_path_diagnostic_item, path_to_local,
     path_to_local_id, paths, SpanlessEq,
@@ -8,7 +7,7 @@ use clippy_utils::{
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_block, walk_expr, walk_stmt, Visitor};
-use rustc_hir::{BindingAnnotation, Block, Expr, ExprKind, HirId, PatKind, QPath, Stmt, StmtKind};
+use rustc_hir::{BindingAnnotation, Block, Expr, ExprKind, HirId, PatKind, Stmt, StmtKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::symbol::sym;
@@ -133,8 +132,15 @@ impl<'tcx> LateLintPass<'tcx> for SlowVectorInit {
 }
 
 impl SlowVectorInit {
+    /// Looks for `Vec::with_capacity(size)` or `Vec::new()` calls and returns the initialized size,
+    /// if any. More specifically, it returns:
+    /// - `Some(InitializedSize::Initialized(size))` for `Vec::with_capacity(size)`
+    /// - `Some(InitializedSize::Uninitialized)` for `Vec::new()`
+    /// - `None` for other, unrelated kinds of expressions
     fn as_vec_initializer<'tcx>(cx: &LateContext<'_>, expr: &'tcx Expr<'tcx>) -> Option<InitializedSize<'tcx>> {
-        if let Some(len_expr) = Self::is_vec_with_capacity(cx, expr) {
+        if let ExprKind::Call(func, [len_expr]) = expr.kind
+            && is_expr_path_def_path(cx, func, &paths::VEC_WITH_CAPACITY)
+        {
             Some(InitializedSize::Initialized(len_expr))
         } else if matches!(expr.kind, ExprKind::Call(func, _) if is_expr_path_def_path(cx, func, &paths::VEC_NEW)) {
             Some(InitializedSize::Uninitialized)
@@ -143,22 +149,6 @@ impl SlowVectorInit {
         }
     }
 
-    /// Checks if the given expression is `Vec::with_capacity(..)`. It will return the expression
-    /// of the first argument of `with_capacity` call if it matches or `None` if it does not.
-    fn is_vec_with_capacity<'tcx>(cx: &LateContext<'_>, expr: &Expr<'tcx>) -> Option<&'tcx Expr<'tcx>> {
-        if_chain! {
-            if let ExprKind::Call(func, [arg]) = expr.kind;
-            if let ExprKind::Path(QPath::TypeRelative(ty, name)) = func.kind;
-            if name.ident.as_str() == "with_capacity";
-            if is_type_diagnostic_item(cx, cx.typeck_results().node_type(ty.hir_id), sym::Vec);
-            then {
-                Some(arg)
-            } else {
-                None
-            }
-        }
-    }
-
     /// Search initialization for the given vector
     fn search_initialization<'tcx>(cx: &LateContext<'tcx>, vec_alloc: VecAllocation<'tcx>, parent_node: HirId) {
         let enclosing_body = get_enclosing_block(cx, parent_node);
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index f3677e6f614..ad3e1ce8108 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -149,6 +149,7 @@ pub const VEC_AS_SLICE: [&str; 4] = ["alloc", "vec", "Vec", "as_slice"];
 pub const VEC_DEQUE_ITER: [&str; 5] = ["alloc", "collections", "vec_deque", "VecDeque", "iter"];
 pub const VEC_FROM_ELEM: [&str; 3] = ["alloc", "vec", "from_elem"];
 pub const VEC_NEW: [&str; 4] = ["alloc", "vec", "Vec", "new"];
+pub const VEC_WITH_CAPACITY: [&str; 4] = ["alloc", "vec", "Vec", "with_capacity"];
 pub const VEC_RESIZE: [&str; 4] = ["alloc", "vec", "Vec", "resize"];
 pub const WEAK_ARC: [&str; 3] = ["alloc", "sync", "Weak"];
 pub const WEAK_RC: [&str; 3] = ["alloc", "rc", "Weak"];
-- 
cgit 1.4.1-3-g733a5


From 978b1daf99d8326718684381704902fdaaf71b18 Mon Sep 17 00:00:00 2001
From: Catherine <114838443+Centri3@users.noreply.github.com>
Date: Thu, 6 Jul 2023 15:56:52 -0500
Subject: New lint [`filter_map_bool_then`]

---
 CHANGELOG.md                                     |  1 +
 clippy_lints/src/declared_lints.rs               |  1 +
 clippy_lints/src/methods/filter_map_bool_then.rs | 39 ++++++++++++++++++++++++
 clippy_lints/src/methods/mod.rs                  | 34 +++++++++++++++++++++
 clippy_utils/src/paths.rs                        |  2 ++
 tests/ui/filter_map_bool_then.fixed              | 33 ++++++++++++++++++++
 tests/ui/filter_map_bool_then.rs                 | 33 ++++++++++++++++++++
 tests/ui/filter_map_bool_then.stderr             | 28 +++++++++++++++++
 8 files changed, 171 insertions(+)
 create mode 100644 clippy_lints/src/methods/filter_map_bool_then.rs
 create mode 100644 tests/ui/filter_map_bool_then.fixed
 create mode 100644 tests/ui/filter_map_bool_then.rs
 create mode 100644 tests/ui/filter_map_bool_then.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 02d12d60e73..251f32d2e6e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4844,6 +4844,7 @@ Released 2018-09-13
 [`field_reassign_with_default`]: https://rust-lang.github.io/rust-clippy/master/index.html#field_reassign_with_default
 [`filetype_is_file`]: https://rust-lang.github.io/rust-clippy/master/index.html#filetype_is_file
 [`filter_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#filter_map
+[`filter_map_bool_then`]: https://rust-lang.github.io/rust-clippy/master/index.html#filter_map_bool_then
 [`filter_map_identity`]: https://rust-lang.github.io/rust-clippy/master/index.html#filter_map_identity
 [`filter_map_next`]: https://rust-lang.github.io/rust-clippy/master/index.html#filter_map_next
 [`filter_next`]: https://rust-lang.github.io/rust-clippy/master/index.html#filter_next
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 9b99a255423..e084471433d 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -337,6 +337,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::methods::EXPECT_USED_INFO,
     crate::methods::EXTEND_WITH_DRAIN_INFO,
     crate::methods::FILETYPE_IS_FILE_INFO,
+    crate::methods::FILTER_MAP_BOOL_THEN_INFO,
     crate::methods::FILTER_MAP_IDENTITY_INFO,
     crate::methods::FILTER_MAP_NEXT_INFO,
     crate::methods::FILTER_NEXT_INFO,
diff --git a/clippy_lints/src/methods/filter_map_bool_then.rs b/clippy_lints/src/methods/filter_map_bool_then.rs
new file mode 100644
index 00000000000..e5d8be21f3d
--- /dev/null
+++ b/clippy_lints/src/methods/filter_map_bool_then.rs
@@ -0,0 +1,39 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::paths::BOOL_THEN;
+use clippy_utils::source::snippet_opt;
+use clippy_utils::{is_from_proc_macro, match_def_path, peel_blocks};
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind};
+use rustc_lint::{LateContext, LintContext};
+use rustc_middle::lint::in_external_macro;
+use rustc_span::Span;
+
+use super::FILTER_MAP_BOOL_THEN;
+
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, arg: &Expr<'_>, call_span: Span) {
+    if !in_external_macro(cx.sess(), expr.span)
+        && let ExprKind::Closure(closure) = arg.kind
+        && let body = peel_blocks(cx.tcx.hir().body(closure.body).value)
+        && let ExprKind::MethodCall(_, recv, [then_arg], _) = body.kind
+        && let ExprKind::Closure(then_closure) = then_arg.kind
+        && let then_body = peel_blocks(cx.tcx.hir().body(then_closure.body).value)
+        && let Some(def_id) = cx.typeck_results().type_dependent_def_id(body.hir_id)
+        && match_def_path(cx, def_id, &BOOL_THEN)
+        && !is_from_proc_macro(cx, expr)
+        && let Some(decl_snippet) = closure.fn_arg_span.and_then(|s| snippet_opt(cx, s))
+        // NOTE: This will include the `()` (parenthesis) around it. Maybe there's some utils method
+        // to remove them? `unused_parens` will already take care of this but it may be nice.
+        && let Some(filter) = snippet_opt(cx, recv.span)
+        && let Some(map) = snippet_opt(cx, then_body.span)
+    {
+        span_lint_and_sugg(
+            cx,
+            FILTER_MAP_BOOL_THEN,
+            call_span,
+            "usage of `bool::then` in `filter_map`",
+            "use `filter` then `map` instead",
+            format!("filter({decl_snippet} {filter}).map({decl_snippet} {map})"),
+            Applicability::MachineApplicable,
+        );
+    }
+}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 1058289679b..e774450018e 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -21,6 +21,7 @@ mod expect_used;
 mod extend_with_drain;
 mod filetype_is_file;
 mod filter_map;
+mod filter_map_bool_then;
 mod filter_map_identity;
 mod filter_map_next;
 mod filter_next;
@@ -3475,6 +3476,37 @@ declare_clippy_lint! {
     "disallows `.skip(0)`"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of `bool::then` in `Iterator::filter_map`.
+    ///
+    /// ### Why is this bad?
+    /// This can be written with `filter` then `map` instead, which would reduce nesting and
+    /// separates the filtering from the transformation phase. This comes with no cost to
+    /// performance and is just cleaner.
+    ///
+    /// ### Limitations
+    /// Does not lint `bool::then_some`, as it eagerly evaluates its arguments rather than lazily.
+    /// This can create differing behavior, so better safe than sorry.
+    ///
+    /// ### Example
+    /// ```rust
+    /// # fn really_expensive_fn(i: i32) -> i32 { i }
+    /// # let v = vec![];
+    /// _ = v.into_iter().filter_map(|i| (i % 2 == 0).then(|| really_expensive_fn(i)));
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// # fn really_expensive_fn(i: i32) -> i32 { i }
+    /// # let v = vec![];
+    /// _ = v.into_iter().filter(|i| i % 2 == 0).map(|i| really_expensive_fn(i));
+    /// ```
+    #[clippy::version = "1.72.0"]
+    pub FILTER_MAP_BOOL_THEN,
+    style,
+    "checks for usage of `bool::then` in `Iterator::filter_map`"
+}
+
 pub struct Methods {
     avoid_breaking_exported_api: bool,
     msrv: Msrv,
@@ -3612,6 +3644,7 @@ impl_lint_pass!(Methods => [
     FORMAT_COLLECT,
     STRING_LIT_CHARS_ANY,
     ITER_SKIP_ZERO,
+    FILTER_MAP_BOOL_THEN,
 ]);
 
 /// Extracts a method call name, args, and `Span` of the method name.
@@ -3889,6 +3922,7 @@ impl Methods {
                 },
                 ("filter_map", [arg]) => {
                     unnecessary_filter_map::check(cx, expr, arg, name);
+                    filter_map_bool_then::check(cx, expr, arg, call_span);
                     filter_map_identity::check(cx, expr, arg, span);
                 },
                 ("find_map", [arg]) => {
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index 8d96d3cfe50..914ea85ac28 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -163,3 +163,5 @@ pub const OPTION_EXPECT: [&str; 4] = ["core", "option", "Option", "expect"];
 pub const FORMATTER: [&str; 3] = ["core", "fmt", "Formatter"];
 pub const DEBUG_STRUCT: [&str; 4] = ["core", "fmt", "builders", "DebugStruct"];
 pub const ORD_CMP: [&str; 4] = ["core", "cmp", "Ord", "cmp"];
+#[expect(clippy::invalid_paths)] // not sure why it thinks this, it works so
+pub const BOOL_THEN: [&str; 4] = ["core", "bool", "<impl bool>", "then"];
diff --git a/tests/ui/filter_map_bool_then.fixed b/tests/ui/filter_map_bool_then.fixed
new file mode 100644
index 00000000000..0db0b0a8a28
--- /dev/null
+++ b/tests/ui/filter_map_bool_then.fixed
@@ -0,0 +1,33 @@
+//@run-rustfix
+//@aux-build:proc_macros.rs:proc-macro
+#![allow(clippy::clone_on_copy, clippy::unnecessary_lazy_evaluations, unused)]
+#![warn(clippy::filter_map_bool_then)]
+
+#[macro_use]
+extern crate proc_macros;
+
+fn main() {
+    let v = vec![1, 2, 3, 4, 5, 6];
+    v.clone().into_iter().filter(|i| (i % 2 == 0)).map(|i| i + 1);
+    v.clone()
+        .into_iter()
+        .filter(|i| (i % 2 == 0)).map(|i| i + 1);
+    v.clone()
+        .into_iter()
+        .filter(|&i| i != 1000)
+        .filter(|i| (i % 2 == 0)).map(|i| i + 1);
+    v.iter()
+        .copied()
+        .filter(|&i| i != 1000)
+        .filter(|i| (i.clone() % 2 == 0)).map(|i| i + 1);
+    // Do not lint
+    external! {
+        let v = vec![1, 2, 3, 4, 5, 6];
+        v.clone().into_iter().filter_map(|i| (i % 2 == 0).then(|| i + 1));
+    }
+    with_span! {
+        span
+        let v = vec![1, 2, 3, 4, 5, 6];
+        v.clone().into_iter().filter_map(|i| (i % 2 == 0).then(|| i + 1));
+    }
+}
diff --git a/tests/ui/filter_map_bool_then.rs b/tests/ui/filter_map_bool_then.rs
new file mode 100644
index 00000000000..764f9c4a85e
--- /dev/null
+++ b/tests/ui/filter_map_bool_then.rs
@@ -0,0 +1,33 @@
+//@run-rustfix
+//@aux-build:proc_macros.rs:proc-macro
+#![allow(clippy::clone_on_copy, clippy::unnecessary_lazy_evaluations, unused)]
+#![warn(clippy::filter_map_bool_then)]
+
+#[macro_use]
+extern crate proc_macros;
+
+fn main() {
+    let v = vec![1, 2, 3, 4, 5, 6];
+    v.clone().into_iter().filter_map(|i| (i % 2 == 0).then(|| i + 1));
+    v.clone()
+        .into_iter()
+        .filter_map(|i| -> Option<_> { (i % 2 == 0).then(|| i + 1) });
+    v.clone()
+        .into_iter()
+        .filter(|&i| i != 1000)
+        .filter_map(|i| (i % 2 == 0).then(|| i + 1));
+    v.iter()
+        .copied()
+        .filter(|&i| i != 1000)
+        .filter_map(|i| (i.clone() % 2 == 0).then(|| i + 1));
+    // Do not lint
+    external! {
+        let v = vec![1, 2, 3, 4, 5, 6];
+        v.clone().into_iter().filter_map(|i| (i % 2 == 0).then(|| i + 1));
+    }
+    with_span! {
+        span
+        let v = vec![1, 2, 3, 4, 5, 6];
+        v.clone().into_iter().filter_map(|i| (i % 2 == 0).then(|| i + 1));
+    }
+}
diff --git a/tests/ui/filter_map_bool_then.stderr b/tests/ui/filter_map_bool_then.stderr
new file mode 100644
index 00000000000..79bc7ba02f7
--- /dev/null
+++ b/tests/ui/filter_map_bool_then.stderr
@@ -0,0 +1,28 @@
+error: usage of `bool::then` in `filter_map`
+  --> $DIR/filter_map_bool_then.rs:11:27
+   |
+LL |     v.clone().into_iter().filter_map(|i| (i % 2 == 0).then(|| i + 1));
+   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `filter` then `map` instead: `filter(|i| (i % 2 == 0)).map(|i| i + 1)`
+   |
+   = note: `-D clippy::filter-map-bool-then` implied by `-D warnings`
+
+error: usage of `bool::then` in `filter_map`
+  --> $DIR/filter_map_bool_then.rs:14:10
+   |
+LL |         .filter_map(|i| -> Option<_> { (i % 2 == 0).then(|| i + 1) });
+   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `filter` then `map` instead: `filter(|i| (i % 2 == 0)).map(|i| i + 1)`
+
+error: usage of `bool::then` in `filter_map`
+  --> $DIR/filter_map_bool_then.rs:18:10
+   |
+LL |         .filter_map(|i| (i % 2 == 0).then(|| i + 1));
+   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `filter` then `map` instead: `filter(|i| (i % 2 == 0)).map(|i| i + 1)`
+
+error: usage of `bool::then` in `filter_map`
+  --> $DIR/filter_map_bool_then.rs:22:10
+   |
+LL |         .filter_map(|i| (i.clone() % 2 == 0).then(|| i + 1));
+   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `filter` then `map` instead: `filter(|i| (i.clone() % 2 == 0)).map(|i| i + 1)`
+
+error: aborting due to 4 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 3235d9d612909bc64550eea3a0d387e1187e93dd Mon Sep 17 00:00:00 2001
From: Catherine <114838443+Centri3@users.noreply.github.com>
Date: Sun, 16 Jul 2023 05:30:01 -0500
Subject: Only lint `Copy` types

---
 clippy_lints/src/methods/filter_map_bool_then.rs | 24 ++++++++++++++--------
 tests/ui/filter_map_bool_then.fixed              | 21 ++++++++++++++-----
 tests/ui/filter_map_bool_then.rs                 | 13 +++++++++++-
 tests/ui/filter_map_bool_then.stderr             | 26 +++++++++++++++---------
 4 files changed, 59 insertions(+), 25 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/filter_map_bool_then.rs b/clippy_lints/src/methods/filter_map_bool_then.rs
index e5d8be21f3d..4aee22a4afc 100644
--- a/clippy_lints/src/methods/filter_map_bool_then.rs
+++ b/clippy_lints/src/methods/filter_map_bool_then.rs
@@ -1,28 +1,34 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::paths::BOOL_THEN;
 use clippy_utils::source::snippet_opt;
-use clippy_utils::{is_from_proc_macro, match_def_path, peel_blocks};
+use clippy_utils::ty::is_copy;
+use clippy_utils::{is_from_proc_macro, is_trait_method, match_def_path, peel_blocks};
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_span::Span;
+use rustc_span::{sym, Span};
 
 use super::FILTER_MAP_BOOL_THEN;
 
 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, arg: &Expr<'_>, call_span: Span) {
     if !in_external_macro(cx.sess(), expr.span)
+        && is_trait_method(cx, expr, sym::Iterator)
         && let ExprKind::Closure(closure) = arg.kind
-        && let body = peel_blocks(cx.tcx.hir().body(closure.body).value)
-        && let ExprKind::MethodCall(_, recv, [then_arg], _) = body.kind
+        && let body = cx.tcx.hir().body(closure.body)
+        && let value = peel_blocks(body.value)
+        // Indexing should be fine as `filter_map` always has 1 input, we unfortunately need both
+        // `inputs` and `params` here as we need both the type and the span
+        && let param_ty = closure.fn_decl.inputs[0]
+        && let param = body.params[0]
+        && is_copy(cx, cx.typeck_results().node_type(param_ty.hir_id).peel_refs())
+        && let ExprKind::MethodCall(_, recv, [then_arg], _) = value.kind
         && let ExprKind::Closure(then_closure) = then_arg.kind
         && let then_body = peel_blocks(cx.tcx.hir().body(then_closure.body).value)
-        && let Some(def_id) = cx.typeck_results().type_dependent_def_id(body.hir_id)
+        && let Some(def_id) = cx.typeck_results().type_dependent_def_id(value.hir_id)
         && match_def_path(cx, def_id, &BOOL_THEN)
         && !is_from_proc_macro(cx, expr)
-        && let Some(decl_snippet) = closure.fn_arg_span.and_then(|s| snippet_opt(cx, s))
-        // NOTE: This will include the `()` (parenthesis) around it. Maybe there's some utils method
-        // to remove them? `unused_parens` will already take care of this but it may be nice.
+        && let Some(param_snippet) = snippet_opt(cx, param.span)
         && let Some(filter) = snippet_opt(cx, recv.span)
         && let Some(map) = snippet_opt(cx, then_body.span)
     {
@@ -32,7 +38,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, arg: &
             call_span,
             "usage of `bool::then` in `filter_map`",
             "use `filter` then `map` instead",
-            format!("filter({decl_snippet} {filter}).map({decl_snippet} {map})"),
+            format!("filter(|&{param_snippet}| {filter}).map(|{param_snippet}| {map})"),
             Applicability::MachineApplicable,
         );
     }
diff --git a/tests/ui/filter_map_bool_then.fixed b/tests/ui/filter_map_bool_then.fixed
index 0db0b0a8a28..3e72fee4b07 100644
--- a/tests/ui/filter_map_bool_then.fixed
+++ b/tests/ui/filter_map_bool_then.fixed
@@ -1,26 +1,37 @@
 //@run-rustfix
 //@aux-build:proc_macros.rs:proc-macro
-#![allow(clippy::clone_on_copy, clippy::unnecessary_lazy_evaluations, unused)]
+#![allow(
+    clippy::clone_on_copy,
+    clippy::map_identity,
+    clippy::unnecessary_lazy_evaluations,
+    unused
+)]
 #![warn(clippy::filter_map_bool_then)]
 
 #[macro_use]
 extern crate proc_macros;
 
+#[derive(Clone, PartialEq)]
+struct NonCopy;
+
 fn main() {
     let v = vec![1, 2, 3, 4, 5, 6];
-    v.clone().into_iter().filter(|i| (i % 2 == 0)).map(|i| i + 1);
+    v.clone().iter().filter(|&i| (i % 2 == 0)).map(|i| i + 1);
+    v.clone().into_iter().filter(|&i| (i % 2 == 0)).map(|i| i + 1);
     v.clone()
         .into_iter()
-        .filter(|i| (i % 2 == 0)).map(|i| i + 1);
+        .filter(|&i| (i % 2 == 0)).map(|i| i + 1);
     v.clone()
         .into_iter()
         .filter(|&i| i != 1000)
-        .filter(|i| (i % 2 == 0)).map(|i| i + 1);
+        .filter(|&i| (i % 2 == 0)).map(|i| i + 1);
     v.iter()
         .copied()
         .filter(|&i| i != 1000)
-        .filter(|i| (i.clone() % 2 == 0)).map(|i| i + 1);
+        .filter(|&i| (i.clone() % 2 == 0)).map(|i| i + 1);
     // Do not lint
+    let v = vec![NonCopy, NonCopy];
+    v.clone().iter().filter_map(|i| (i == &NonCopy).then(|| i));
     external! {
         let v = vec![1, 2, 3, 4, 5, 6];
         v.clone().into_iter().filter_map(|i| (i % 2 == 0).then(|| i + 1));
diff --git a/tests/ui/filter_map_bool_then.rs b/tests/ui/filter_map_bool_then.rs
index 764f9c4a85e..38a04e57de4 100644
--- a/tests/ui/filter_map_bool_then.rs
+++ b/tests/ui/filter_map_bool_then.rs
@@ -1,13 +1,22 @@
 //@run-rustfix
 //@aux-build:proc_macros.rs:proc-macro
-#![allow(clippy::clone_on_copy, clippy::unnecessary_lazy_evaluations, unused)]
+#![allow(
+    clippy::clone_on_copy,
+    clippy::map_identity,
+    clippy::unnecessary_lazy_evaluations,
+    unused
+)]
 #![warn(clippy::filter_map_bool_then)]
 
 #[macro_use]
 extern crate proc_macros;
 
+#[derive(Clone, PartialEq)]
+struct NonCopy;
+
 fn main() {
     let v = vec![1, 2, 3, 4, 5, 6];
+    v.clone().iter().filter_map(|i| (i % 2 == 0).then(|| i + 1));
     v.clone().into_iter().filter_map(|i| (i % 2 == 0).then(|| i + 1));
     v.clone()
         .into_iter()
@@ -21,6 +30,8 @@ fn main() {
         .filter(|&i| i != 1000)
         .filter_map(|i| (i.clone() % 2 == 0).then(|| i + 1));
     // Do not lint
+    let v = vec![NonCopy, NonCopy];
+    v.clone().iter().filter_map(|i| (i == &NonCopy).then(|| i));
     external! {
         let v = vec![1, 2, 3, 4, 5, 6];
         v.clone().into_iter().filter_map(|i| (i % 2 == 0).then(|| i + 1));
diff --git a/tests/ui/filter_map_bool_then.stderr b/tests/ui/filter_map_bool_then.stderr
index 79bc7ba02f7..b411cd83dfd 100644
--- a/tests/ui/filter_map_bool_then.stderr
+++ b/tests/ui/filter_map_bool_then.stderr
@@ -1,28 +1,34 @@
 error: usage of `bool::then` in `filter_map`
-  --> $DIR/filter_map_bool_then.rs:11:27
+  --> $DIR/filter_map_bool_then.rs:19:22
    |
-LL |     v.clone().into_iter().filter_map(|i| (i % 2 == 0).then(|| i + 1));
-   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `filter` then `map` instead: `filter(|i| (i % 2 == 0)).map(|i| i + 1)`
+LL |     v.clone().iter().filter_map(|i| (i % 2 == 0).then(|| i + 1));
+   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `filter` then `map` instead: `filter(|&i| (i % 2 == 0)).map(|i| i + 1)`
    |
    = note: `-D clippy::filter-map-bool-then` implied by `-D warnings`
 
 error: usage of `bool::then` in `filter_map`
-  --> $DIR/filter_map_bool_then.rs:14:10
+  --> $DIR/filter_map_bool_then.rs:20:27
+   |
+LL |     v.clone().into_iter().filter_map(|i| (i % 2 == 0).then(|| i + 1));
+   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `filter` then `map` instead: `filter(|&i| (i % 2 == 0)).map(|i| i + 1)`
+
+error: usage of `bool::then` in `filter_map`
+  --> $DIR/filter_map_bool_then.rs:23:10
    |
 LL |         .filter_map(|i| -> Option<_> { (i % 2 == 0).then(|| i + 1) });
-   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `filter` then `map` instead: `filter(|i| (i % 2 == 0)).map(|i| i + 1)`
+   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `filter` then `map` instead: `filter(|&i| (i % 2 == 0)).map(|i| i + 1)`
 
 error: usage of `bool::then` in `filter_map`
-  --> $DIR/filter_map_bool_then.rs:18:10
+  --> $DIR/filter_map_bool_then.rs:27:10
    |
 LL |         .filter_map(|i| (i % 2 == 0).then(|| i + 1));
-   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `filter` then `map` instead: `filter(|i| (i % 2 == 0)).map(|i| i + 1)`
+   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `filter` then `map` instead: `filter(|&i| (i % 2 == 0)).map(|i| i + 1)`
 
 error: usage of `bool::then` in `filter_map`
-  --> $DIR/filter_map_bool_then.rs:22:10
+  --> $DIR/filter_map_bool_then.rs:31:10
    |
 LL |         .filter_map(|i| (i.clone() % 2 == 0).then(|| i + 1));
-   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `filter` then `map` instead: `filter(|i| (i.clone() % 2 == 0)).map(|i| i + 1)`
+   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `filter` then `map` instead: `filter(|&i| (i.clone() % 2 == 0)).map(|i| i + 1)`
 
-error: aborting due to 4 previous errors
+error: aborting due to 5 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 90947e95ad8c26156739566c7ad1e52013b63a93 Mon Sep 17 00:00:00 2001
From: Catherine Flores <catherine.3.flores@gmail.com>
Date: Tue, 25 Jul 2023 17:56:43 -0500
Subject: [`arc_with_non_send_sync`]: Check if it's macro-generated

---
 clippy_lints/src/arc_with_non_send_sync.rs | 12 +++++++-----
 tests/ui/arc_with_non_send_sync.rs         | 30 +++++++++++++++++++++++++++---
 tests/ui/arc_with_non_send_sync.stderr     |  6 +++---
 3 files changed, 37 insertions(+), 11 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/arc_with_non_send_sync.rs b/clippy_lints/src/arc_with_non_send_sync.rs
index 7adcd9ad055..35a04b5e44a 100644
--- a/clippy_lints/src/arc_with_non_send_sync.rs
+++ b/clippy_lints/src/arc_with_non_send_sync.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::last_path_segment;
 use clippy_utils::ty::{implements_trait, is_type_diagnostic_item};
+use clippy_utils::{is_from_proc_macro, last_path_segment};
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
@@ -38,10 +38,11 @@ declare_clippy_lint! {
 }
 declare_lint_pass!(ArcWithNonSendSync => [ARC_WITH_NON_SEND_SYNC]);
 
-impl LateLintPass<'_> for ArcWithNonSendSync {
-    fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
-        let ty = cx.typeck_results().expr_ty(expr);
-        if is_type_diagnostic_item(cx, ty, sym::Arc)
+impl<'tcx> LateLintPass<'tcx> for ArcWithNonSendSync {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
+        if !expr.span.from_expansion()
+            && let ty = cx.typeck_results().expr_ty(expr)
+            && is_type_diagnostic_item(cx, ty, sym::Arc)
             && let ExprKind::Call(func, [arg]) = expr.kind
             && let ExprKind::Path(func_path) = func.kind
             && last_path_segment(&func_path).ident.name == sym::new
@@ -54,6 +55,7 @@ impl LateLintPass<'_> for ArcWithNonSendSync {
             && let Some(sync) = cx.tcx.lang_items().sync_trait()
             && let [is_send, is_sync] = [send, sync].map(|id| implements_trait(cx, arg_ty, id, &[]))
             && !(is_send && is_sync)
+            && !is_from_proc_macro(cx, expr)
         {
             span_lint_and_then(
                 cx,
diff --git a/tests/ui/arc_with_non_send_sync.rs b/tests/ui/arc_with_non_send_sync.rs
index b6fcca0a791..2940c273255 100644
--- a/tests/ui/arc_with_non_send_sync.rs
+++ b/tests/ui/arc_with_non_send_sync.rs
@@ -1,6 +1,12 @@
+//@aux-build:proc_macros.rs:proc-macro
 #![warn(clippy::arc_with_non_send_sync)]
 #![allow(unused_variables)]
+
+#[macro_use]
+extern crate proc_macros;
+
 use std::cell::RefCell;
+use std::ptr::{null, null_mut};
 use std::sync::{Arc, Mutex};
 
 fn foo<T>(x: T) {
@@ -11,14 +17,32 @@ fn issue11076<T>() {
     let a: Arc<Vec<T>> = Arc::new(Vec::new());
 }
 
+fn issue11232() {
+    external! {
+        let a: Arc<*const u8> = Arc::new(null());
+        let a: Arc<*mut u8> = Arc::new(null_mut());
+    }
+    with_span! {
+        span
+        let a: Arc<*const u8> = Arc::new(null());
+        let a: Arc<*mut u8> = Arc::new(null_mut());
+    }
+}
+
 fn main() {
     let _ = Arc::new(42);
 
-    // !Sync
     let _ = Arc::new(RefCell::new(42));
+    //~^ ERROR: usage of an `Arc` that is not `Send` or `Sync`
+    //~| NOTE: the trait `Sync` is not implemented for `RefCell<i32>`
+
     let mutex = Mutex::new(1);
-    // !Send
     let _ = Arc::new(mutex.lock().unwrap());
-    // !Send + !Sync
+    //~^ ERROR: usage of an `Arc` that is not `Send` or `Sync`
+    //~| NOTE: the trait `Send` is not implemented for `MutexGuard<'_, i32>`
+
     let _ = Arc::new(&42 as *const i32);
+    //~^ ERROR: usage of an `Arc` that is not `Send` or `Sync`
+    //~| NOTE: the trait `Send` is not implemented for `*const i32`
+    //~| NOTE: the trait `Sync` is not implemented for `*const i32`
 }
diff --git a/tests/ui/arc_with_non_send_sync.stderr b/tests/ui/arc_with_non_send_sync.stderr
index 7633b38dfb5..de3f2fb9e16 100644
--- a/tests/ui/arc_with_non_send_sync.stderr
+++ b/tests/ui/arc_with_non_send_sync.stderr
@@ -1,5 +1,5 @@
 error: usage of an `Arc` that is not `Send` or `Sync`
-  --> $DIR/arc_with_non_send_sync.rs:18:13
+  --> $DIR/arc_with_non_send_sync.rs:35:13
    |
 LL |     let _ = Arc::new(RefCell::new(42));
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -10,7 +10,7 @@ LL |     let _ = Arc::new(RefCell::new(42));
    = note: `-D clippy::arc-with-non-send-sync` implied by `-D warnings`
 
 error: usage of an `Arc` that is not `Send` or `Sync`
-  --> $DIR/arc_with_non_send_sync.rs:21:13
+  --> $DIR/arc_with_non_send_sync.rs:40:13
    |
 LL |     let _ = Arc::new(mutex.lock().unwrap());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -20,7 +20,7 @@ LL |     let _ = Arc::new(mutex.lock().unwrap());
    = help: consider using an `Rc` instead or wrapping the inner type with a `Mutex`
 
 error: usage of an `Arc` that is not `Send` or `Sync`
-  --> $DIR/arc_with_non_send_sync.rs:23:13
+  --> $DIR/arc_with_non_send_sync.rs:44:13
    |
 LL |     let _ = Arc::new(&42 as *const i32);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From 4e1db44404bbd11f3644c0402e5b1f5358c1b532 Mon Sep 17 00:00:00 2001
From: blyxyas <blyxyas@gmail.com>
Date: Sun, 7 May 2023 00:08:46 +0200
Subject: Now `option_env_unwrap` warns even if a variable isn't set at compile
 time.

---
 clippy_lints/src/option_env_unwrap.rs | 36 ++++++++++++++++++-----------------
 tests/ui/option_env_unwrap.rs         |  1 +
 tests/ui/option_env_unwrap.stderr     | 18 +++++++++++++-----
 3 files changed, 33 insertions(+), 22 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/option_env_unwrap.rs b/clippy_lints/src/option_env_unwrap.rs
index 377bddeaa5f..0885bb40cb8 100644
--- a/clippy_lints/src/option_env_unwrap.rs
+++ b/clippy_lints/src/option_env_unwrap.rs
@@ -1,10 +1,9 @@
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::is_direct_expn_of;
-use if_chain::if_chain;
 use rustc_ast::ast::{Expr, ExprKind, MethodCall};
 use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::sym;
+use rustc_span::{sym, Span};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -36,21 +35,24 @@ declare_lint_pass!(OptionEnvUnwrap => [OPTION_ENV_UNWRAP]);
 
 impl EarlyLintPass for OptionEnvUnwrap {
     fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
-        if_chain! {
-            if let ExprKind::MethodCall(box MethodCall { seg, receiver, .. }) = &expr.kind;
-            if matches!(seg.ident.name, sym::expect | sym::unwrap);
-            if let ExprKind::Call(caller, _) = &receiver.kind;
-            if is_direct_expn_of(caller.span, "option_env").is_some();
-            then {
-                span_lint_and_help(
-                    cx,
-                    OPTION_ENV_UNWRAP,
-                    expr.span,
-                    "this will panic at run-time if the environment variable doesn't exist at compile-time",
-                    None,
-                    "consider using the `env!` macro instead"
-                );
-            }
+        fn lint(cx: &EarlyContext<'_>, span: Span) {
+            span_lint_and_help(
+                cx,
+                OPTION_ENV_UNWRAP,
+                span,
+                "this will panic at run-time if the environment variable doesn't exist at compile-time",
+                None,
+                "consider using the `env!` macro instead",
+            );
         }
+
+        if let ExprKind::MethodCall(box MethodCall { seg, receiver, .. }) = &expr.kind &&
+		matches!(seg.ident.name, sym::expect | sym::unwrap) {
+			if let ExprKind::Call(caller, _) = &receiver.kind && is_direct_expn_of(caller.span, "option_env").is_some() {
+				lint(cx, expr.span);
+			} else if let ExprKind::Path(_, caller) = &receiver.kind && is_direct_expn_of(caller.span, "option_env").is_some() {
+				lint(cx, expr.span);
+			}
+		}
     }
 }
diff --git a/tests/ui/option_env_unwrap.rs b/tests/ui/option_env_unwrap.rs
index ee1fe3f1fc0..f8d382340f2 100644
--- a/tests/ui/option_env_unwrap.rs
+++ b/tests/ui/option_env_unwrap.rs
@@ -9,6 +9,7 @@ use proc_macros::{external, inline_macros};
 fn main() {
     let _ = option_env!("PATH").unwrap();
     let _ = option_env!("PATH").expect("environment variable PATH isn't set");
+    let _ = option_env!("__Y__do_not_use").unwrap(); // This test only works if you don't have a __Y__do_not_use env variable in your environment.
     let _ = inline!(option_env!($"PATH").unwrap());
     let _ = inline!(option_env!($"PATH").expect($"environment variable PATH isn't set"));
     let _ = external!(option_env!($"PATH").unwrap());
diff --git a/tests/ui/option_env_unwrap.stderr b/tests/ui/option_env_unwrap.stderr
index 7bba62686ee..7698b4b0216 100644
--- a/tests/ui/option_env_unwrap.stderr
+++ b/tests/ui/option_env_unwrap.stderr
@@ -16,7 +16,15 @@ LL |     let _ = option_env!("PATH").expect("environment variable PATH isn't set
    = help: consider using the `env!` macro instead
 
 error: this will panic at run-time if the environment variable doesn't exist at compile-time
-  --> $DIR/option_env_unwrap.rs:12:21
+  --> $DIR/option_env_unwrap.rs:12:13
+   |
+LL |     let _ = option_env!("Y").unwrap(); // This test only works if you don't have a __Y__do_not_use env variable in your environment.
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using the `env!` macro instead
+
+error: this will panic at run-time if the environment variable doesn't exist at compile-time
+  --> $DIR/option_env_unwrap.rs:13:21
    |
 LL |     let _ = inline!(option_env!($"PATH").unwrap());
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -25,7 +33,7 @@ LL |     let _ = inline!(option_env!($"PATH").unwrap());
    = note: this error originates in the macro `__inline_mac_fn_main` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: this will panic at run-time if the environment variable doesn't exist at compile-time
-  --> $DIR/option_env_unwrap.rs:13:21
+  --> $DIR/option_env_unwrap.rs:14:21
    |
 LL |     let _ = inline!(option_env!($"PATH").expect($"environment variable PATH isn't set"));
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -34,7 +42,7 @@ LL |     let _ = inline!(option_env!($"PATH").expect($"environment variable PATH
    = note: this error originates in the macro `__inline_mac_fn_main` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: this will panic at run-time if the environment variable doesn't exist at compile-time
-  --> $DIR/option_env_unwrap.rs:14:13
+  --> $DIR/option_env_unwrap.rs:15:13
    |
 LL |     let _ = external!(option_env!($"PATH").unwrap());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -43,7 +51,7 @@ LL |     let _ = external!(option_env!($"PATH").unwrap());
    = note: this error originates in the macro `external` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: this will panic at run-time if the environment variable doesn't exist at compile-time
-  --> $DIR/option_env_unwrap.rs:15:13
+  --> $DIR/option_env_unwrap.rs:16:13
    |
 LL |     let _ = external!(option_env!($"PATH").expect($"environment variable PATH isn't set"));
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -51,5 +59,5 @@ LL |     let _ = external!(option_env!($"PATH").expect($"environment variable PA
    = help: consider using the `env!` macro instead
    = note: this error originates in the macro `external` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to 6 previous errors
+error: aborting due to 7 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 3bfccacca97cb7d4d7751fc90b89b3381b8b8b35 Mon Sep 17 00:00:00 2001
From: blyxyas <blyxyas@gmail.com>
Date: Wed, 26 Jul 2023 23:16:24 +0200
Subject: Add comments + Very minor Refactor

---
 clippy_lints/src/option_env_unwrap.rs | 7 +++++--
 tests/ui/option_env_unwrap.stderr     | 4 ++--
 2 files changed, 7 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/option_env_unwrap.rs b/clippy_lints/src/option_env_unwrap.rs
index 0885bb40cb8..9c7f7e1cd7f 100644
--- a/clippy_lints/src/option_env_unwrap.rs
+++ b/clippy_lints/src/option_env_unwrap.rs
@@ -48,9 +48,12 @@ impl EarlyLintPass for OptionEnvUnwrap {
 
         if let ExprKind::MethodCall(box MethodCall { seg, receiver, .. }) = &expr.kind &&
 		matches!(seg.ident.name, sym::expect | sym::unwrap) {
-			if let ExprKind::Call(caller, _) = &receiver.kind && is_direct_expn_of(caller.span, "option_env").is_some() {
+			if let ExprKind::Call(caller, _) = &receiver.kind &&
+            // If it exists, it will be ::core::option::Option::Some("<env var>").unwrap() (A method call in the HIR)
+            is_direct_expn_of(caller.span, "option_env").is_some() {
 				lint(cx, expr.span);
-			} else if let ExprKind::Path(_, caller) = &receiver.kind && is_direct_expn_of(caller.span, "option_env").is_some() {
+			} else if let ExprKind::Path(_, caller) = &receiver.kind && // If it doesn't exist, it will be ::core::option::Option::None::<&'static str>.unwrap() (A path in the HIR)
+            is_direct_expn_of(caller.span, "option_env").is_some() {
 				lint(cx, expr.span);
 			}
 		}
diff --git a/tests/ui/option_env_unwrap.stderr b/tests/ui/option_env_unwrap.stderr
index 7698b4b0216..cfa9dd58a30 100644
--- a/tests/ui/option_env_unwrap.stderr
+++ b/tests/ui/option_env_unwrap.stderr
@@ -18,8 +18,8 @@ LL |     let _ = option_env!("PATH").expect("environment variable PATH isn't set
 error: this will panic at run-time if the environment variable doesn't exist at compile-time
   --> $DIR/option_env_unwrap.rs:12:13
    |
-LL |     let _ = option_env!("Y").unwrap(); // This test only works if you don't have a __Y__do_not_use env variable in your environment.
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |     let _ = option_env!("__Y__do_not_use").unwrap(); // This test only works if you don't have a __Y__do_not_use env variable in your env...
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: consider using the `env!` macro instead
 
-- 
cgit 1.4.1-3-g733a5


From 136339f2d307cb819b61573c37e4bb5d155a6d9c Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Sat, 22 Jul 2023 02:17:51 +0200
Subject: new lint: [`readonly_write_lock`]

---
 CHANGELOG.md                                    |  1 +
 clippy_lints/src/declared_lints.rs              |  1 +
 clippy_lints/src/methods/mod.rs                 | 36 +++++++++++++++++
 clippy_lints/src/methods/readonly_write_lock.rs | 51 +++++++++++++++++++++++++
 tests/ui/readonly_write_lock.rs                 | 42 ++++++++++++++++++++
 tests/ui/readonly_write_lock.stderr             | 16 ++++++++
 6 files changed, 147 insertions(+)
 create mode 100644 clippy_lints/src/methods/readonly_write_lock.rs
 create mode 100644 tests/ui/readonly_write_lock.rs
 create mode 100644 tests/ui/readonly_write_lock.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 251f32d2e6e..2655d93599e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5181,6 +5181,7 @@ Released 2018-09-13
 [`rc_mutex`]: https://rust-lang.github.io/rust-clippy/master/index.html#rc_mutex
 [`read_line_without_trim`]: https://rust-lang.github.io/rust-clippy/master/index.html#read_line_without_trim
 [`read_zero_byte_vec`]: https://rust-lang.github.io/rust-clippy/master/index.html#read_zero_byte_vec
+[`readonly_write_lock`]: https://rust-lang.github.io/rust-clippy/master/index.html#readonly_write_lock
 [`recursive_format_impl`]: https://rust-lang.github.io/rust-clippy/master/index.html#recursive_format_impl
 [`redundant_allocation`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_allocation
 [`redundant_async_block`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_async_block
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index e084471433d..d4e0d286334 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -398,6 +398,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::methods::OR_THEN_UNWRAP_INFO,
     crate::methods::PATH_BUF_PUSH_OVERWRITE_INFO,
     crate::methods::RANGE_ZIP_WITH_LEN_INFO,
+    crate::methods::READONLY_WRITE_LOCK_INFO,
     crate::methods::READ_LINE_WITHOUT_TRIM_INFO,
     crate::methods::REPEAT_ONCE_INFO,
     crate::methods::RESULT_MAP_OR_INTO_OPTION_INFO,
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index e774450018e..0e02c6d8e1b 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -76,6 +76,7 @@ mod or_then_unwrap;
 mod path_buf_push_overwrite;
 mod range_zip_with_len;
 mod read_line_without_trim;
+mod readonly_write_lock;
 mod repeat_once;
 mod search_is_some;
 mod seek_from_current;
@@ -3507,6 +3508,37 @@ declare_clippy_lint! {
     "checks for usage of `bool::then` in `Iterator::filter_map`"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Looks for calls to `RwLock::write` where the lock is only used for reading.
+    ///
+    /// ### Why is this bad?
+    /// The write portion of `RwLock` is exclusive, meaning that no other thread
+    /// can access the lock while this writer is active.
+    ///
+    /// ### Example
+    /// ```rust
+    /// use std::sync::RwLock;
+    /// fn assert_is_zero(lock: &RwLock<i32>) {
+    ///     let num = lock.write().unwrap();
+    ///     assert_eq!(*num, 0);
+    /// }
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust
+    /// use std::sync::RwLock;
+    /// fn assert_is_zero(lock: &RwLock<i32>) {
+    ///     let num = lock.read().unwrap();
+    ///     assert_eq!(*num, 0);
+    /// }
+    /// ```
+    #[clippy::version = "1.73.0"]
+    pub READONLY_WRITE_LOCK,
+    nursery,
+    "acquiring a writer lock when a reader lock would work"
+}
+
 pub struct Methods {
     avoid_breaking_exported_api: bool,
     msrv: Msrv,
@@ -3645,6 +3677,7 @@ impl_lint_pass!(Methods => [
     STRING_LIT_CHARS_ANY,
     ITER_SKIP_ZERO,
     FILTER_MAP_BOOL_THEN,
+    READONLY_WRITE_LOCK
 ]);
 
 /// Extracts a method call name, args, and `Span` of the method name.
@@ -4188,6 +4221,9 @@ impl Methods {
                         range_zip_with_len::check(cx, expr, iter_recv, arg);
                     }
                 },
+                ("write", []) => {
+                    readonly_write_lock::check(cx, expr, recv);
+                }
                 _ => {},
             }
         }
diff --git a/clippy_lints/src/methods/readonly_write_lock.rs b/clippy_lints/src/methods/readonly_write_lock.rs
new file mode 100644
index 00000000000..404ded2b013
--- /dev/null
+++ b/clippy_lints/src/methods/readonly_write_lock.rs
@@ -0,0 +1,51 @@
+use super::READONLY_WRITE_LOCK;
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::mir::{enclosing_mir, visit_local_usage};
+use clippy_utils::source::snippet;
+use clippy_utils::ty::is_type_diagnostic_item;
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind, Node};
+use rustc_lint::LateContext;
+use rustc_middle::mir::{Location, START_BLOCK};
+use rustc_span::sym;
+
+fn is_unwrap_call(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+    if let ExprKind::MethodCall(path, receiver, ..) = expr.kind
+        && path.ident.name == sym::unwrap
+    {
+        is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(receiver).peel_refs(), sym::Result)
+    } else {
+        false
+    }
+}
+
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, receiver: &Expr<'_>) {
+    if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(receiver).peel_refs(), sym::RwLock)
+        && let Node::Expr(unwrap_call_expr) = cx.tcx.hir().get_parent(expr.hir_id)
+        && is_unwrap_call(cx, unwrap_call_expr)
+        && let parent = cx.tcx.hir().get_parent(unwrap_call_expr.hir_id)
+        && let Node::Local(local) = parent
+        && let Some(mir) = enclosing_mir(cx.tcx, expr.hir_id)
+        && let Some((local, _)) = mir.local_decls.iter_enumerated().find(|(_, decl)| {
+            local.span.contains(decl.source_info.span)
+        })
+        && let Some(usage) = visit_local_usage(&[local], mir, Location {
+            block: START_BLOCK,
+            statement_index: 0,
+        })
+    {
+        let writer_never_mutated = usage[0].local_consume_or_mutate_locs.is_empty();
+
+        if writer_never_mutated {
+            span_lint_and_sugg(
+                cx,
+                READONLY_WRITE_LOCK,
+                expr.span,
+                "this write lock is used only for reading",
+                "consider using a read lock instead",
+                format!("{}.read()", snippet(cx, receiver.span, "<receiver>")),
+                Applicability::MaybeIncorrect // write lock might be intentional for enforcing exclusiveness
+            );
+        }
+    }
+}
diff --git a/tests/ui/readonly_write_lock.rs b/tests/ui/readonly_write_lock.rs
new file mode 100644
index 00000000000..656b45787e8
--- /dev/null
+++ b/tests/ui/readonly_write_lock.rs
@@ -0,0 +1,42 @@
+#![warn(clippy::readonly_write_lock)]
+
+use std::sync::RwLock;
+
+fn mutate_i32(x: &mut i32) {
+    *x += 1;
+}
+
+fn accept_i32(_: i32) {}
+
+fn main() {
+    let lock = RwLock::new(42);
+    let lock2 = RwLock::new(1234);
+
+    {
+        let writer = lock.write().unwrap();
+        dbg!(&writer);
+    }
+
+    {
+        let writer = lock.write().unwrap();
+        accept_i32(*writer);
+    }
+
+    {
+        let mut writer = lock.write().unwrap();
+        mutate_i32(&mut writer);
+        dbg!(&writer);
+    }
+
+    {
+        let mut writer = lock.write().unwrap();
+        *writer += 1;
+    }
+
+    {
+        let mut writer1 = lock.write().unwrap();
+        let mut writer2 = lock2.write().unwrap();
+        *writer2 += 1;
+        *writer1 = *writer2;
+    }
+}
diff --git a/tests/ui/readonly_write_lock.stderr b/tests/ui/readonly_write_lock.stderr
new file mode 100644
index 00000000000..e3d8fce7b2c
--- /dev/null
+++ b/tests/ui/readonly_write_lock.stderr
@@ -0,0 +1,16 @@
+error: this write lock is used only for reading
+  --> $DIR/readonly_write_lock.rs:16:22
+   |
+LL |         let writer = lock.write().unwrap();
+   |                      ^^^^^^^^^^^^ help: consider using a read lock instead: `lock.read()`
+   |
+   = note: `-D clippy::readonly-write-lock` implied by `-D warnings`
+
+error: this write lock is used only for reading
+  --> $DIR/readonly_write_lock.rs:21:22
+   |
+LL |         let writer = lock.write().unwrap();
+   |                      ^^^^^^^^^^^^ help: consider using a read lock instead: `lock.read()`
+
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 205a3741c1659b5157a5dfdaec2476c8a151ada2 Mon Sep 17 00:00:00 2001
From: Timo <30553356+y21@users.noreply.github.com>
Date: Thu, 27 Jul 2023 20:37:15 +0200
Subject: make lint description more consistent (writer/reader -> write/read)

Co-authored-by: Takayuki Nakata <f.seasons017@gmail.com>
---
 clippy_lints/src/methods/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 0e02c6d8e1b..bca2039860d 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3536,7 +3536,7 @@ declare_clippy_lint! {
     #[clippy::version = "1.73.0"]
     pub READONLY_WRITE_LOCK,
     nursery,
-    "acquiring a writer lock when a reader lock would work"
+    "acquiring a write lock when a read lock would work"
 }
 
 pub struct Methods {
-- 
cgit 1.4.1-3-g733a5


From 5e88003ddac563a8ffc912d6e69332d479a92cc3 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Fri, 28 Jul 2023 12:52:06 +0200
Subject: pattern match on local usage slice to avoid ICE

---
 clippy_lints/src/methods/readonly_write_lock.rs | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/readonly_write_lock.rs b/clippy_lints/src/methods/readonly_write_lock.rs
index 404ded2b013..e3ec921da0c 100644
--- a/clippy_lints/src/methods/readonly_write_lock.rs
+++ b/clippy_lints/src/methods/readonly_write_lock.rs
@@ -29,12 +29,13 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, receiver
         && let Some((local, _)) = mir.local_decls.iter_enumerated().find(|(_, decl)| {
             local.span.contains(decl.source_info.span)
         })
-        && let Some(usage) = visit_local_usage(&[local], mir, Location {
+        && let Some(usages) = visit_local_usage(&[local], mir, Location {
             block: START_BLOCK,
             statement_index: 0,
         })
+        && let [usage] = usages.as_slice()
     {
-        let writer_never_mutated = usage[0].local_consume_or_mutate_locs.is_empty();
+        let writer_never_mutated = usage.local_consume_or_mutate_locs.is_empty();
 
         if writer_never_mutated {
             span_lint_and_sugg(
-- 
cgit 1.4.1-3-g733a5


From 71cc39e1f2f4cd7e8cd6fa09c65ecab06ce9cc80 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sun, 30 Jul 2023 00:00:19 -0400
Subject: Add debug assertions to `implements_trait` Improve debug assertions
 for `make_projection`

---
 clippy_lints/src/derive.rs                   |   4 +-
 clippy_lints/src/incorrect_impls.rs          |   8 +-
 clippy_lints/src/loops/explicit_iter_loop.rs |   2 +-
 clippy_lints/src/methods/or_fun_call.rs      |   2 +-
 clippy_lints/src/needless_pass_by_value.rs   |  10 +-
 clippy_utils/src/ty.rs                       | 184 +++++++++++++++------------
 6 files changed, 117 insertions(+), 93 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/derive.rs b/clippy_lints/src/derive.rs
index c343f248d06..ad7b3b27383 100644
--- a/clippy_lints/src/derive.rs
+++ b/clippy_lints/src/derive.rs
@@ -471,12 +471,12 @@ fn check_partial_eq_without_eq<'tcx>(cx: &LateContext<'tcx>, span: Span, trait_r
         if let Some(def_id) = trait_ref.trait_def_id();
         if cx.tcx.is_diagnostic_item(sym::PartialEq, def_id);
         let param_env = param_env_for_derived_eq(cx.tcx, adt.did(), eq_trait_def_id);
-        if !implements_trait_with_env(cx.tcx, param_env, ty, eq_trait_def_id, []);
+        if !implements_trait_with_env(cx.tcx, param_env, ty, eq_trait_def_id, &[]);
         // If all of our fields implement `Eq`, we can implement `Eq` too
         if adt
             .all_fields()
             .map(|f| f.ty(cx.tcx, args))
-            .all(|ty| implements_trait_with_env(cx.tcx, param_env, ty, eq_trait_def_id, []));
+            .all(|ty| implements_trait_with_env(cx.tcx, param_env, ty, eq_trait_def_id, &[]));
         then {
             span_lint_and_sugg(
                 cx,
diff --git a/clippy_lints/src/incorrect_impls.rs b/clippy_lints/src/incorrect_impls.rs
index bce010bb168..f4edb17ae80 100644
--- a/clippy_lints/src/incorrect_impls.rs
+++ b/clippy_lints/src/incorrect_impls.rs
@@ -189,12 +189,8 @@ impl LateLintPass<'_> for IncorrectImpls {
                 .diagnostic_items(trait_impl.def_id.krate)
                 .name_to_id
                 .get(&sym::Ord)
-            && implements_trait(
-                    cx,
-                    hir_ty_to_ty(cx.tcx, imp.self_ty),
-                    *ord_def_id,
-                    trait_impl.args,
-                )
+            && trait_impl.self_ty() == trait_impl.args.type_at(1)
+            && implements_trait(cx, hir_ty_to_ty(cx.tcx, imp.self_ty), *ord_def_id, &[])
         {
             // If the `cmp` call likely needs to be fully qualified in the suggestion
             // (like `std::cmp::Ord::cmp`). It's unfortunate we must put this here but we can't
diff --git a/clippy_lints/src/loops/explicit_iter_loop.rs b/clippy_lints/src/loops/explicit_iter_loop.rs
index a84a0a6eeb8..7b8c88235a9 100644
--- a/clippy_lints/src/loops/explicit_iter_loop.rs
+++ b/clippy_lints/src/loops/explicit_iter_loop.rs
@@ -109,7 +109,7 @@ fn is_ref_iterable<'tcx>(
         && let sig = cx.tcx.liberate_late_bound_regions(fn_id, cx.tcx.fn_sig(fn_id).skip_binder())
         && let &[req_self_ty, req_res_ty] = &**sig.inputs_and_output
         && let param_env = cx.tcx.param_env(fn_id)
-        && implements_trait_with_env(cx.tcx, param_env, req_self_ty, trait_id, [])
+        && implements_trait_with_env(cx.tcx, param_env, req_self_ty, trait_id, &[])
         && let Some(into_iter_ty) =
             make_normalized_projection_with_regions(cx.tcx, param_env, trait_id, sym!(IntoIter), [req_self_ty])
         && let req_res_ty = normalize_with_regions(cx.tcx, param_env, req_res_ty)
diff --git a/clippy_lints/src/methods/or_fun_call.rs b/clippy_lints/src/methods/or_fun_call.rs
index 23039f2f3f1..8b2f57160af 100644
--- a/clippy_lints/src/methods/or_fun_call.rs
+++ b/clippy_lints/src/methods/or_fun_call.rs
@@ -57,7 +57,7 @@ pub(super) fn check<'tcx>(
                 cx.tcx
                     .get_diagnostic_item(sym::Default)
                     .map_or(false, |default_trait_id| {
-                        implements_trait(cx, output_ty, default_trait_id, args)
+                        implements_trait(cx, output_ty, default_trait_id, &[])
                     })
             } else {
                 false
diff --git a/clippy_lints/src/needless_pass_by_value.rs b/clippy_lints/src/needless_pass_by_value.rs
index 5e26601537f..5ee26966fa7 100644
--- a/clippy_lints/src/needless_pass_by_value.rs
+++ b/clippy_lints/src/needless_pass_by_value.rs
@@ -2,7 +2,7 @@ use clippy_utils::diagnostics::{multispan_sugg, span_lint_and_then};
 use clippy_utils::ptr::get_spans;
 use clippy_utils::source::{snippet, snippet_opt};
 use clippy_utils::ty::{
-    implements_trait, implements_trait_with_env, is_copy, is_type_diagnostic_item, is_type_lang_item,
+    implements_trait, implements_trait_with_env_from_iter, is_copy, is_type_diagnostic_item, is_type_lang_item,
 };
 use clippy_utils::{get_trait_def_id, is_self, paths};
 use if_chain::if_chain;
@@ -182,7 +182,13 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByValue {
                 if !ty.is_mutable_ptr();
                 if !is_copy(cx, ty);
                 if ty.is_sized(cx.tcx, cx.param_env);
-                if !allowed_traits.iter().any(|&t| implements_trait_with_env(cx.tcx, cx.param_env, ty, t, [None]));
+                if !allowed_traits.iter().any(|&t| implements_trait_with_env_from_iter(
+                    cx.tcx,
+                    cx.param_env,
+                    ty,
+                    t,
+                    [Option::<ty::GenericArg<'tcx>>::None],
+                ));
                 if !implements_borrow_trait;
                 if !all_borrowable_trait;
 
diff --git a/clippy_utils/src/ty.rs b/clippy_utils/src/ty.rs
index 44ec8813f19..dbb6b986952 100644
--- a/clippy_utils/src/ty.rs
+++ b/clippy_utils/src/ty.rs
@@ -3,6 +3,7 @@
 #![allow(clippy::module_name_repetitions)]
 
 use core::ops::ControlFlow;
+use itertools::Itertools;
 use rustc_ast::ast::Mutability;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_hir as hir;
@@ -13,17 +14,19 @@ use rustc_infer::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKi
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::LateContext;
 use rustc_middle::mir::interpret::{ConstValue, Scalar};
+use rustc_middle::traits::EvaluationResult;
 use rustc_middle::ty::layout::ValidityRequirement;
 use rustc_middle::ty::{
-    self, AdtDef, AliasTy, AssocKind, Binder, BoundRegion, FnSig, GenericArg, GenericArgKind, GenericArgsRef, IntTy,
-    List, ParamEnv, Region, RegionKind, Ty, TyCtxt, TypeSuperVisitable, TypeVisitable, TypeVisitableExt, TypeVisitor,
-    UintTy, VariantDef, VariantDiscr,
+    self, AdtDef, AliasTy, AssocKind, Binder, BoundRegion, FnSig, GenericArg, GenericArgKind, GenericArgsRef,
+    GenericParamDefKind, IntTy, List, ParamEnv, Region, RegionKind, ToPredicate, TraitRef, Ty, TyCtxt,
+    TypeSuperVisitable, TypeVisitable, TypeVisitableExt, TypeVisitor, UintTy, VariantDef, VariantDiscr,
 };
 use rustc_span::symbol::Ident;
 use rustc_span::{sym, Span, Symbol, DUMMY_SP};
 use rustc_target::abi::{Size, VariantIdx};
-use rustc_trait_selection::infer::InferCtxtExt;
+use rustc_trait_selection::traits::query::evaluate_obligation::InferCtxtExt as _;
 use rustc_trait_selection::traits::query::normalize::QueryNormalizeExt;
+use rustc_trait_selection::traits::{Obligation, ObligationCause};
 use std::iter;
 
 use crate::{match_def_path, path_res, paths};
@@ -207,15 +210,9 @@ pub fn implements_trait<'tcx>(
     cx: &LateContext<'tcx>,
     ty: Ty<'tcx>,
     trait_id: DefId,
-    ty_params: &[GenericArg<'tcx>],
+    args: &[GenericArg<'tcx>],
 ) -> bool {
-    implements_trait_with_env(
-        cx.tcx,
-        cx.param_env,
-        ty,
-        trait_id,
-        ty_params.iter().map(|&arg| Some(arg)),
-    )
+    implements_trait_with_env_from_iter(cx.tcx, cx.param_env, ty, trait_id, args.iter().map(|&x| Some(x)))
 }
 
 /// Same as `implements_trait` but allows using a `ParamEnv` different from the lint context.
@@ -224,7 +221,18 @@ pub fn implements_trait_with_env<'tcx>(
     param_env: ParamEnv<'tcx>,
     ty: Ty<'tcx>,
     trait_id: DefId,
-    ty_params: impl IntoIterator<Item = Option<GenericArg<'tcx>>>,
+    args: &[GenericArg<'tcx>],
+) -> bool {
+    implements_trait_with_env_from_iter(tcx, param_env, ty, trait_id, args.iter().map(|&x| Some(x)))
+}
+
+/// Same as `implements_trait_from_env` but takes the arguments as an iterator.
+pub fn implements_trait_with_env_from_iter<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    param_env: ParamEnv<'tcx>,
+    ty: Ty<'tcx>,
+    trait_id: DefId,
+    args: impl IntoIterator<Item = impl Into<Option<GenericArg<'tcx>>>>,
 ) -> bool {
     // Clippy shouldn't have infer types
     assert!(!ty.has_infer());
@@ -233,19 +241,37 @@ pub fn implements_trait_with_env<'tcx>(
     if ty.has_escaping_bound_vars() {
         return false;
     }
+
     let infcx = tcx.infer_ctxt().build();
-    let orig = TypeVariableOrigin {
-        kind: TypeVariableOriginKind::MiscVariable,
-        span: DUMMY_SP,
-    };
-    let ty_params = tcx.mk_args_from_iter(
-        ty_params
+    let trait_ref = TraitRef::new(
+        tcx,
+        trait_id,
+        Some(GenericArg::from(ty))
             .into_iter()
-            .map(|arg| arg.unwrap_or_else(|| infcx.next_ty_var(orig).into())),
+            .chain(args.into_iter().map(|arg| {
+                arg.into().unwrap_or_else(|| {
+                    let orig = TypeVariableOrigin {
+                        kind: TypeVariableOriginKind::MiscVariable,
+                        span: DUMMY_SP,
+                    };
+                    infcx.next_ty_var(orig).into()
+                })
+            })),
     );
+
+    debug_assert_eq!(tcx.def_kind(trait_id), DefKind::Trait);
+    #[cfg(debug_assertions)]
+    assert_generic_args_match(tcx, trait_id, trait_ref.args);
+
+    let obligation = Obligation {
+        cause: ObligationCause::dummy(),
+        param_env,
+        recursion_depth: 0,
+        predicate: ty::Binder::dummy(trait_ref).without_const().to_predicate(tcx),
+    };
     infcx
-        .type_implements_trait(trait_id, [ty.into()].into_iter().chain(ty_params), param_env)
-        .must_apply_modulo_regions()
+        .evaluate_obligation(&obligation)
+        .is_ok_and(EvaluationResult::must_apply_modulo_regions)
 }
 
 /// Checks whether this type implements `Drop`.
@@ -1014,12 +1040,60 @@ pub fn approx_ty_size<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> u64 {
     }
 }
 
+/// Asserts that the given arguments match the generic parameters of the given item.
+#[allow(dead_code)]
+fn assert_generic_args_match<'tcx>(tcx: TyCtxt<'tcx>, did: DefId, args: &[GenericArg<'tcx>]) {
+    let g = tcx.generics_of(did);
+    let parent = g.parent.map(|did| tcx.generics_of(did));
+    let count = g.parent_count + g.params.len();
+    let params = parent
+        .map_or([].as_slice(), |p| p.params.as_slice())
+        .iter()
+        .chain(&g.params)
+        .map(|x| &x.kind);
+
+    assert!(
+        count == args.len(),
+        "wrong number of arguments for `{did:?}`: expected `{count}`, found {}\n\
+            note: the expected arguments are: `[{}]`\n\
+            the given arguments are: `{args:#?}`",
+        args.len(),
+        params.clone().map(GenericParamDefKind::descr).format(", "),
+    );
+
+    if let Some((idx, (param, arg))) =
+        params
+            .clone()
+            .zip(args.iter().map(|&x| x.unpack()))
+            .enumerate()
+            .find(|(_, (param, arg))| match (param, arg) {
+                (GenericParamDefKind::Lifetime, GenericArgKind::Lifetime(_))
+                | (GenericParamDefKind::Type { .. }, GenericArgKind::Type(_))
+                | (GenericParamDefKind::Const { .. }, GenericArgKind::Const(_)) => false,
+                (
+                    GenericParamDefKind::Lifetime
+                    | GenericParamDefKind::Type { .. }
+                    | GenericParamDefKind::Const { .. },
+                    _,
+                ) => true,
+            })
+    {
+        panic!(
+            "incorrect argument for `{did:?}` at index `{idx}`: expected a {}, found `{arg:?}`\n\
+                note: the expected arguments are `[{}]`\n\
+                the given arguments are `{args:#?}`",
+            param.descr(),
+            params.clone().map(GenericParamDefKind::descr).format(", "),
+        );
+    }
+}
+
 /// Makes the projection type for the named associated type in the given impl or trait impl.
 ///
 /// This function is for associated types which are "known" to exist, and as such, will only return
 /// `None` when debug assertions are disabled in order to prevent ICE's. With debug assertions
 /// enabled this will check that the named associated type exists, the correct number of
-/// substitutions are given, and that the correct kinds of substitutions are given (lifetime,
+/// arguments are given, and that the correct kinds of arguments are given (lifetime,
 /// constant or type). This will not check if type normalization would succeed.
 pub fn make_projection<'tcx>(
     tcx: TyCtxt<'tcx>,
@@ -1043,49 +1117,7 @@ pub fn make_projection<'tcx>(
             return None;
         };
         #[cfg(debug_assertions)]
-        {
-            let generics = tcx.generics_of(assoc_item.def_id);
-            let generic_count = generics.parent_count + generics.params.len();
-            let params = generics
-                .parent
-                .map_or([].as_slice(), |id| &*tcx.generics_of(id).params)
-                .iter()
-                .chain(&generics.params)
-                .map(|x| &x.kind);
-
-            debug_assert!(
-                generic_count == args.len(),
-                "wrong number of args for `{:?}`: found `{}` expected `{generic_count}`.\n\
-                    note: the expected parameters are: {:#?}\n\
-                    the given arguments are: `{args:#?}`",
-                assoc_item.def_id,
-                args.len(),
-                params.map(ty::GenericParamDefKind::descr).collect::<Vec<_>>(),
-            );
-
-            if let Some((idx, (param, arg))) = params
-                .clone()
-                .zip(args.iter().map(GenericArg::unpack))
-                .enumerate()
-                .find(|(_, (param, arg))| {
-                    !matches!(
-                        (param, arg),
-                        (ty::GenericParamDefKind::Lifetime, GenericArgKind::Lifetime(_))
-                            | (ty::GenericParamDefKind::Type { .. }, GenericArgKind::Type(_))
-                            | (ty::GenericParamDefKind::Const { .. }, GenericArgKind::Const(_))
-                    )
-                })
-            {
-                debug_assert!(
-                    false,
-                    "mismatched subst type at index {idx}: expected a {}, found `{arg:?}`\n\
-                        note: the expected parameters are {:#?}\n\
-                        the given arguments are {args:#?}",
-                    param.descr(),
-                    params.map(ty::GenericParamDefKind::descr).collect::<Vec<_>>()
-                );
-            }
-        }
+        assert_generic_args_match(tcx, assoc_item.def_id, args);
 
         Some(tcx.mk_alias_ty(assoc_item.def_id, args))
     }
@@ -1100,7 +1132,7 @@ pub fn make_projection<'tcx>(
 /// Normalizes the named associated type in the given impl or trait impl.
 ///
 /// This function is for associated types which are "known" to be valid with the given
-/// substitutions, and as such, will only return `None` when debug assertions are disabled in order
+/// arguments, and as such, will only return `None` when debug assertions are disabled in order
 /// to prevent ICE's. With debug assertions enabled this will check that type normalization
 /// succeeds as well as everything checked by `make_projection`.
 pub fn make_normalized_projection<'tcx>(
@@ -1112,17 +1144,12 @@ pub fn make_normalized_projection<'tcx>(
 ) -> Option<Ty<'tcx>> {
     fn helper<'tcx>(tcx: TyCtxt<'tcx>, param_env: ParamEnv<'tcx>, ty: AliasTy<'tcx>) -> Option<Ty<'tcx>> {
         #[cfg(debug_assertions)]
-        if let Some((i, subst)) = ty
-            .args
-            .iter()
-            .enumerate()
-            .find(|(_, subst)| subst.has_late_bound_regions())
-        {
+        if let Some((i, arg)) = ty.args.iter().enumerate().find(|(_, arg)| arg.has_late_bound_regions()) {
             debug_assert!(
                 false,
                 "args contain late-bound region at index `{i}` which can't be normalized.\n\
                     use `TyCtxt::erase_late_bound_regions`\n\
-                    note: subst is `{subst:#?}`",
+                    note: arg is `{arg:#?}`",
             );
             return None;
         }
@@ -1190,17 +1217,12 @@ pub fn make_normalized_projection_with_regions<'tcx>(
 ) -> Option<Ty<'tcx>> {
     fn helper<'tcx>(tcx: TyCtxt<'tcx>, param_env: ParamEnv<'tcx>, ty: AliasTy<'tcx>) -> Option<Ty<'tcx>> {
         #[cfg(debug_assertions)]
-        if let Some((i, subst)) = ty
-            .args
-            .iter()
-            .enumerate()
-            .find(|(_, subst)| subst.has_late_bound_regions())
-        {
+        if let Some((i, arg)) = ty.args.iter().enumerate().find(|(_, arg)| arg.has_late_bound_regions()) {
             debug_assert!(
                 false,
                 "args contain late-bound region at index `{i}` which can't be normalized.\n\
                     use `TyCtxt::erase_late_bound_regions`\n\
-                    note: subst is `{subst:#?}`",
+                    note: arg is `{arg:#?}`",
             );
             return None;
         }
-- 
cgit 1.4.1-3-g733a5


From 4d80a2ed2e1cd6df90f89d8f39bdfba06c8632fe Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sun, 30 Jul 2023 01:11:08 -0400
Subject: Rework `redundant_closure` * Better track when a early-bound region
 appears when a late-bound region is required * Don't lint when the closure
 gives explicit types.

---
 clippy_lints/src/eta_reduction.rs   | 342 ++++++++++++++++++++++--------------
 clippy_lints/src/incorrect_impls.rs |   1 -
 clippy_utils/src/ty.rs              |   5 +
 clippy_utils/src/usage.rs           |  46 ++---
 clippy_utils/src/visitors.rs        |  10 ++
 tests/ui/eta.fixed                  |  55 ++++++
 tests/ui/eta.rs                     |  55 ++++++
 tests/ui/eta.stderr                 |   8 +-
 8 files changed, 368 insertions(+), 154 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/eta_reduction.rs b/clippy_lints/src/eta_reduction.rs
index 22e10accd35..255859da495 100644
--- a/clippy_lints/src/eta_reduction.rs
+++ b/clippy_lints/src/eta_reduction.rs
@@ -1,19 +1,22 @@
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::higher::VecArgs;
 use clippy_utils::source::snippet_opt;
-use clippy_utils::ty::{implements_trait, is_type_diagnostic_item};
-use clippy_utils::usage::local_used_after_expr;
+use clippy_utils::ty::type_diagnostic_name;
+use clippy_utils::usage::{local_used_after_expr, local_used_in};
 use clippy_utils::{higher, is_adjusted, path_to_local, path_to_local_id};
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::def_id::DefId;
-use rustc_hir::{Closure, Expr, ExprKind, Param, PatKind, Unsafety};
+use rustc_hir::{BindingAnnotation, Expr, ExprKind, FnRetTy, Param, PatKind, TyKind, Unsafety};
+use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty::adjustment::{Adjust, Adjustment, AutoBorrow};
-use rustc_middle::ty::binding::BindingMode;
-use rustc_middle::ty::{self, EarlyBinder, GenericArgsRef, Ty, TypeVisitableExt};
+use rustc_middle::ty::{
+    self, Binder, BoundConstness, ClosureArgs, ClosureKind, EarlyBinder, FnSig, GenericArg, GenericArgKind,
+    GenericArgsRef, ImplPolarity, List, Region, RegionKind, Ty, TypeVisitableExt, TypeckResults,
+};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::symbol::sym;
+use rustc_target::spec::abi::Abi;
+use rustc_trait_selection::traits::error_reporting::InferCtxtExt as _;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -72,14 +75,18 @@ declare_clippy_lint! {
 declare_lint_pass!(EtaReduction => [REDUNDANT_CLOSURE, REDUNDANT_CLOSURE_FOR_METHOD_CALLS]);
 
 impl<'tcx> LateLintPass<'tcx> for EtaReduction {
+    #[allow(clippy::too_many_lines)]
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if expr.span.from_expansion() {
+        let body = if let ExprKind::Closure(c) = expr.kind
+            && c.fn_decl.inputs.iter().all(|ty| matches!(ty.kind, TyKind::Infer))
+            && matches!(c.fn_decl.output, FnRetTy::DefaultReturn(_))
+            && !expr.span.from_expansion()
+        {
+            cx.tcx.hir().body(c.body)
+        } else {
             return;
-        }
-        let body = match expr.kind {
-            ExprKind::Closure(&Closure { body, .. }) => cx.tcx.hir().body(body),
-            _ => return,
         };
+
         if body.value.span.from_expansion() {
             if body.params.is_empty() {
                 if let Some(VecArgs::Vec(&[])) = higher::VecArgs::hir(cx, body.value) {
@@ -99,140 +106,217 @@ impl<'tcx> LateLintPass<'tcx> for EtaReduction {
             return;
         }
 
-        let closure_ty = cx.typeck_results().expr_ty(expr);
+        let typeck = cx.typeck_results();
+        let closure = if let ty::Closure(_, closure_subs) = typeck.expr_ty(expr).kind() {
+            closure_subs.as_closure()
+        } else {
+            return;
+        };
 
-        if_chain!(
-            if !is_adjusted(cx, body.value);
-            if let ExprKind::Call(callee, args) = body.value.kind;
-            if let ExprKind::Path(_) = callee.kind;
-            if check_inputs(cx, body.params, None, args);
-            let callee_ty = cx.typeck_results().expr_ty_adjusted(callee);
-            let call_ty = cx.typeck_results().type_dependent_def_id(body.value.hir_id)
-                .map_or(callee_ty, |id| cx.tcx.type_of(id).instantiate_identity());
-            if check_sig(cx, closure_ty, call_ty);
-            let args = cx.typeck_results().node_args(callee.hir_id);
-            // This fixes some false positives that I don't entirely understand
-            if args.is_empty() || !cx.typeck_results().expr_ty(expr).has_late_bound_regions();
-            // A type param function ref like `T::f` is not 'static, however
-            // it is if cast like `T::f as fn()`. This seems like a rustc bug.
-            if !args.types().any(|t| matches!(t.kind(), ty::Param(_)));
-            let callee_ty_unadjusted = cx.typeck_results().expr_ty(callee).peel_refs();
-            if !is_type_diagnostic_item(cx, callee_ty_unadjusted, sym::Arc);
-            if !is_type_diagnostic_item(cx, callee_ty_unadjusted, sym::Rc);
-            if let ty::Closure(_, args) = *closure_ty.kind();
-            // Don't lint if this is an inclusive range expression.
-            // They desugar to a call to `RangeInclusiveNew` which would have odd suggestions. (#10684)
-            if !matches!(higher::Range::hir(body.value), Some(higher::Range {
-                start: Some(_),
-                end: Some(_),
-                limits: rustc_ast::RangeLimits::Closed
-            }));
-            then {
-                span_lint_and_then(cx, REDUNDANT_CLOSURE, expr.span, "redundant closure", |diag| {
-                    if let Some(mut snippet) = snippet_opt(cx, callee.span) {
-                        if let Some(fn_mut_id) = cx.tcx.lang_items().fn_mut_trait()
-                            && let args = cx.tcx.erase_late_bound_regions(args.as_closure().sig()).inputs()
-                            && implements_trait(
-                                   cx,
-                                   callee_ty.peel_refs(),
-                                   fn_mut_id,
-                                   &args.iter().copied().map(Into::into).collect::<Vec<_>>(),
-                               )
-                            && path_to_local(callee).map_or(false, |l| local_used_after_expr(cx, l, expr))
-                        {
-                                // Mutable closure is used after current expr; we cannot consume it.
-                                snippet = format!("&mut {snippet}");
-                        }
+        if is_adjusted(cx, body.value) {
+            return;
+        }
 
-                        diag.span_suggestion(
-                            expr.span,
-                            "replace the closure with the function itself",
-                            snippet,
-                            Applicability::MachineApplicable,
-                        );
-                    }
-                });
-            }
-        );
+        match body.value.kind {
+            ExprKind::Call(callee, args)
+                if matches!(callee.kind, ExprKind::Path(..)) =>
+            {
+                if matches!(higher::Range::hir(body.value), Some(higher::Range {
+                    start: Some(_),
+                    end: Some(_),
+                    limits: rustc_ast::RangeLimits::Closed
+                })) {
+                    return;
+                }
+
+                let callee_ty = typeck.expr_ty(callee).peel_refs();
+                if matches!(
+                    type_diagnostic_name(cx, callee_ty),
+                    Some(sym::Arc | sym::Rc)
+                ) || !check_inputs(typeck, body.params, None, args) {
+                    return;
+                }
+                let callee_ty_adjusted = typeck.expr_adjustments(callee).last().map_or(
+                    callee_ty,
+                    |a| a.target.peel_refs(),
+                );
 
-        if_chain!(
-            if !is_adjusted(cx, body.value);
-            if let ExprKind::MethodCall(path, receiver, args, _) = body.value.kind;
-            if check_inputs(cx, body.params, Some(receiver), args);
-            let method_def_id = cx.typeck_results().type_dependent_def_id(body.value.hir_id).unwrap();
-            let args = cx.typeck_results().node_args(body.value.hir_id);
-            let call_ty = cx.tcx.type_of(method_def_id).instantiate(cx.tcx, args);
-            if check_sig(cx, closure_ty, call_ty);
-            then {
-                span_lint_and_then(cx, REDUNDANT_CLOSURE_FOR_METHOD_CALLS, expr.span, "redundant closure", |diag| {
-                    let name = get_ufcs_type_name(cx, method_def_id, args);
-                    diag.span_suggestion(
+                let sig = match callee_ty_adjusted.kind() {
+                    ty::FnDef(def, _) => cx.tcx.fn_sig(def).skip_binder().skip_binder(),
+                    ty::FnPtr(sig) => sig.skip_binder(),
+                    ty::Closure(_, subs) => cx
+                        .tcx
+                        .signature_unclosure(subs.as_closure().sig(), Unsafety::Normal)
+                        .skip_binder(),
+                    _ => {
+                        if typeck.type_dependent_def_id(body.value.hir_id).is_some()
+                            && let subs = typeck.node_args(body.value.hir_id)
+                            && let output = typeck.expr_ty(body.value)
+                            && let ty::Tuple(tys) = *subs.type_at(1).kind()
+                        {
+                            cx.tcx.mk_fn_sig(tys, output, false, Unsafety::Normal, Abi::Rust)
+                        } else {
+                            return;
+                        }
+                    },
+                };
+                if check_sig(cx, closure, sig)
+                    && let generic_args = typeck.node_args(callee.hir_id)
+                    // Given some trait fn `fn f() -> ()` and some type `T: Trait`, `T::f` is not
+                    // `'static` unless `T: 'static`. The cast `T::f as fn()` will, however, result
+                    // in a type which is `'static`.
+                    // For now ignore all callee types which reference a type parameter.
+                    && !generic_args.types().any(|t| matches!(t.kind(), ty::Param(_)))
+                {
+                    span_lint_and_then(
+                        cx,
+                        REDUNDANT_CLOSURE,
                         expr.span,
-                        "replace the closure with the method itself",
-                        format!("{name}::{}", path.ident.name),
-                        Applicability::MachineApplicable,
+                        "redundant closure",
+                        |diag| {
+                            if let Some(mut snippet) = snippet_opt(cx, callee.span) {
+                                if let Ok((ClosureKind::FnMut, _))
+                                    = cx.tcx.infer_ctxt().build().type_implements_fn_trait(
+                                        cx.param_env,
+                                        Binder::bind_with_vars(callee_ty_adjusted, List::empty()),
+                                        BoundConstness::NotConst,
+                                        ImplPolarity::Positive,
+                                    ) && path_to_local(callee)
+                                        .map_or(
+                                            false,
+                                            |l| local_used_in(cx, l, args) || local_used_after_expr(cx, l, expr),
+                                        )
+                                {
+                                    // Mutable closure is used after current expr; we cannot consume it.
+                                    snippet = format!("&mut {snippet}");
+                                }
+                                diag.span_suggestion(
+                                    expr.span,
+                                    "replace the closure with the function itself",
+                                    snippet,
+                                    Applicability::MachineApplicable,
+                                );
+                            }
+                        }
                     );
-                })
-            }
-        );
+                }
+            },
+            ExprKind::MethodCall(path, self_, args, _) if check_inputs(typeck, body.params, Some(self_), args) => {
+                if let Some(method_def_id) = typeck.type_dependent_def_id(body.value.hir_id)
+                    && check_sig(cx, closure, cx.tcx.fn_sig(method_def_id).skip_binder().skip_binder())
+                {
+                    span_lint_and_then(
+                        cx,
+                        REDUNDANT_CLOSURE_FOR_METHOD_CALLS,
+                        expr.span,
+                        "redundant closure",
+                        |diag| {
+                            let args = typeck.node_args(body.value.hir_id);
+                            let name = get_ufcs_type_name(cx, method_def_id, args);
+                            diag.span_suggestion(
+                                expr.span,
+                                "replace the closure with the method itself",
+                                format!("{}::{}", name, path.ident.name),
+                                Applicability::MachineApplicable,
+                            );
+                        },
+                    );
+                }
+            },
+            _ => (),
+        }
     }
 }
 
 fn check_inputs(
-    cx: &LateContext<'_>,
+    typeck: &TypeckResults<'_>,
     params: &[Param<'_>],
-    receiver: Option<&Expr<'_>>,
-    call_args: &[Expr<'_>],
+    self_arg: Option<&Expr<'_>>,
+    args: &[Expr<'_>],
 ) -> bool {
-    if receiver.map_or(params.len() != call_args.len(), |_| params.len() != call_args.len() + 1) {
-        return false;
+    params.len() == self_arg.map_or(0, |_| 1) + args.len()
+        && params.iter().zip(self_arg.into_iter().chain(args)).all(|(p, arg)| {
+            matches!(
+                p.pat.kind,PatKind::Binding(BindingAnnotation::NONE, id, _, None)
+                if path_to_local_id(arg, id)
+            )
+            // Only allow adjustments which change regions (i.e. re-borrowing).
+            && typeck
+                .expr_adjustments(arg)
+                .last()
+                .map_or(true, |a| a.target == typeck.expr_ty(arg))
+        })
+}
+
+fn check_sig<'tcx>(cx: &LateContext<'tcx>, closure: ClosureArgs<'tcx>, call_sig: FnSig<'_>) -> bool {
+    call_sig.unsafety == Unsafety::Normal
+        && !has_late_bound_to_non_late_bound_regions(
+            cx.tcx
+                .signature_unclosure(closure.sig(), Unsafety::Normal)
+                .skip_binder(),
+            call_sig,
+        )
+}
+
+/// This walks through both signatures and checks for any time a late-bound region is expected by an
+/// `impl Fn` type, but the target signature does not have a late-bound region in the same position.
+///
+/// This is needed because rustc is unable to late bind early-bound regions in a function signature.
+fn has_late_bound_to_non_late_bound_regions(from_sig: FnSig<'_>, to_sig: FnSig<'_>) -> bool {
+    fn check_region(from_region: Region<'_>, to_region: Region<'_>) -> bool {
+        matches!(from_region.kind(), RegionKind::ReLateBound(..))
+            && !matches!(to_region.kind(), RegionKind::ReLateBound(..))
     }
-    let binding_modes = cx.typeck_results().pat_binding_modes();
-    let check_inputs = |param: &Param<'_>, arg| {
-        match param.pat.kind {
-            PatKind::Binding(_, id, ..) if path_to_local_id(arg, id) => {},
-            _ => return false,
-        }
-        // checks that parameters are not bound as `ref` or `ref mut`
-        if let Some(BindingMode::BindByReference(_)) = binding_modes.get(param.pat.hir_id) {
-            return false;
-        }
 
-        match *cx.typeck_results().expr_adjustments(arg) {
-            [] => true,
-            [
-                Adjustment {
-                    kind: Adjust::Deref(None),
-                    ..
+    fn check_subs(from_subs: &[GenericArg<'_>], to_subs: &[GenericArg<'_>]) -> bool {
+        if from_subs.len() != to_subs.len() {
+            return true;
+        }
+        for (from_arg, to_arg) in to_subs.iter().zip(from_subs) {
+            match (from_arg.unpack(), to_arg.unpack()) {
+                (GenericArgKind::Lifetime(from_region), GenericArgKind::Lifetime(to_region)) => {
+                    if check_region(from_region, to_region) {
+                        return true;
+                    }
                 },
-                Adjustment {
-                    kind: Adjust::Borrow(AutoBorrow::Ref(_, mu2)),
-                    ..
+                (GenericArgKind::Type(from_ty), GenericArgKind::Type(to_ty)) => {
+                    if check_ty(from_ty, to_ty) {
+                        return true;
+                    }
                 },
-            ] => {
-                // re-borrow with the same mutability is allowed
-                let ty = cx.typeck_results().expr_ty(arg);
-                matches!(*ty.kind(), ty::Ref(.., mu1) if mu1 == mu2.into())
-            },
-            _ => false,
+                (GenericArgKind::Const(_), GenericArgKind::Const(_)) => (),
+                _ => return true,
+            }
         }
-    };
-    std::iter::zip(params, receiver.into_iter().chain(call_args.iter())).all(|(param, arg)| check_inputs(param, arg))
-}
-
-fn check_sig<'tcx>(cx: &LateContext<'tcx>, closure_ty: Ty<'tcx>, call_ty: Ty<'tcx>) -> bool {
-    let call_sig = call_ty.fn_sig(cx.tcx);
-    if call_sig.unsafety() == Unsafety::Unsafe {
-        return false;
+        false
     }
-    if !closure_ty.has_late_bound_regions() {
-        return true;
+
+    fn check_ty(from_ty: Ty<'_>, to_ty: Ty<'_>) -> bool {
+        match (from_ty.kind(), to_ty.kind()) {
+            (&ty::Adt(_, from_subs), &ty::Adt(_, to_subs)) => check_subs(from_subs, to_subs),
+            (&ty::Array(from_ty, _), &ty::Array(to_ty, _)) | (&ty::Slice(from_ty), &ty::Slice(to_ty)) => {
+                check_ty(from_ty, to_ty)
+            },
+            (&ty::Ref(from_region, from_ty, _), &ty::Ref(to_region, to_ty, _)) => {
+                check_region(from_region, to_region) || check_ty(from_ty, to_ty)
+            },
+            (&ty::Tuple(from_tys), &ty::Tuple(to_tys)) => {
+                from_tys.len() != to_tys.len()
+                    || from_tys
+                        .iter()
+                        .zip(to_tys)
+                        .any(|(from_ty, to_ty)| check_ty(from_ty, to_ty))
+            },
+            _ => from_ty.has_late_bound_regions(),
+        }
     }
-    let ty::Closure(_, args) = closure_ty.kind() else {
-        return false;
-    };
-    let closure_sig = cx.tcx.signature_unclosure(args.as_closure().sig(), Unsafety::Normal);
-    cx.tcx.erase_late_bound_regions(closure_sig) == cx.tcx.erase_late_bound_regions(call_sig)
+
+    assert!(from_sig.inputs_and_output.len() == to_sig.inputs_and_output.len());
+    from_sig
+        .inputs_and_output
+        .iter()
+        .zip(to_sig.inputs_and_output)
+        .any(|(from_ty, to_ty)| check_ty(from_ty, to_ty))
 }
 
 fn get_ufcs_type_name<'tcx>(cx: &LateContext<'tcx>, method_def_id: DefId, args: GenericArgsRef<'tcx>) -> String {
@@ -241,7 +325,7 @@ fn get_ufcs_type_name<'tcx>(cx: &LateContext<'tcx>, method_def_id: DefId, args:
     match assoc_item.container {
         ty::TraitContainer => cx.tcx.def_path_str(def_id),
         ty::ImplContainer => {
-            let ty = cx.tcx.type_of(def_id).skip_binder();
+            let ty = cx.tcx.type_of(def_id).instantiate_identity();
             match ty.kind() {
                 ty::Adt(adt, _) => cx.tcx.def_path_str(adt.did()),
                 ty::Array(..)
diff --git a/clippy_lints/src/incorrect_impls.rs b/clippy_lints/src/incorrect_impls.rs
index f4edb17ae80..c19a46f4e97 100644
--- a/clippy_lints/src/incorrect_impls.rs
+++ b/clippy_lints/src/incorrect_impls.rs
@@ -189,7 +189,6 @@ impl LateLintPass<'_> for IncorrectImpls {
                 .diagnostic_items(trait_impl.def_id.krate)
                 .name_to_id
                 .get(&sym::Ord)
-            && trait_impl.self_ty() == trait_impl.args.type_at(1)
             && implements_trait(cx, hir_ty_to_ty(cx.tcx, imp.self_ty), *ord_def_id, &[])
         {
             // If the `cmp` call likely needs to be fully qualified in the suggestion
diff --git a/clippy_utils/src/ty.rs b/clippy_utils/src/ty.rs
index dbb6b986952..d0e15aa8bb3 100644
--- a/clippy_utils/src/ty.rs
+++ b/clippy_utils/src/ty.rs
@@ -419,6 +419,11 @@ pub fn is_type_lang_item(cx: &LateContext<'_>, ty: Ty<'_>, lang_item: hir::LangI
     }
 }
 
+/// Gets the diagnostic name of the type, if it has one
+pub fn type_diagnostic_name(cx: &LateContext<'_>, ty: Ty<'_>) -> Option<Symbol> {
+    ty.ty_adt_def().and_then(|adt| cx.tcx.get_diagnostic_name(adt.did()))
+}
+
 /// Return `true` if the passed `typ` is `isize` or `usize`.
 pub fn is_isize_or_usize(typ: Ty<'_>) -> bool {
     matches!(typ.kind(), ty::Int(IntTy::Isize) | ty::Uint(UintTy::Usize))
diff --git a/clippy_utils/src/usage.rs b/clippy_utils/src/usage.rs
index 8a7ea1e6cad..39ef76348d7 100644
--- a/clippy_utils/src/usage.rs
+++ b/clippy_utils/src/usage.rs
@@ -1,15 +1,15 @@
-use crate::visitors::{for_each_expr, for_each_expr_with_closures, Descend};
+use crate::visitors::{for_each_expr, for_each_expr_with_closures, Descend, Visitable};
+use crate::{self as utils, get_enclosing_loop_or_multi_call_closure};
 use core::ops::ControlFlow;
 use hir::def::Res;
 use rustc_hir::intravisit::{self, Visitor};
-use rustc_hir::{Expr, ExprKind, HirId, HirIdSet, Node};
+use rustc_hir::{self as hir, Expr, ExprKind, HirId, HirIdSet};
 use rustc_hir_typeck::expr_use_visitor::{Delegate, ExprUseVisitor, PlaceBase, PlaceWithHirId};
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::LateContext;
 use rustc_middle::hir::nested_filter;
 use rustc_middle::mir::FakeReadCause;
 use rustc_middle::ty;
-use {crate as utils, rustc_hir as hir};
 
 /// Returns a set of mutated local variable IDs, or `None` if mutations could not be determined.
 pub fn mutated_variables<'tcx>(expr: &'tcx Expr<'_>, cx: &LateContext<'tcx>) -> Option<HirIdSet> {
@@ -154,6 +154,17 @@ pub fn contains_return_break_continue_macro(expression: &Expr<'_>) -> bool {
     .is_some()
 }
 
+pub fn local_used_in<'tcx>(cx: &LateContext<'tcx>, local_id: HirId, v: impl Visitable<'tcx>) -> bool {
+    for_each_expr_with_closures(cx, v, |e| {
+        if utils::path_to_local_id(e, local_id) {
+            ControlFlow::Break(())
+        } else {
+            ControlFlow::Continue(())
+        }
+    })
+    .is_some()
+}
+
 pub fn local_used_after_expr(cx: &LateContext<'_>, local_id: HirId, after: &Expr<'_>) -> bool {
     let Some(block) = utils::get_enclosing_block(cx, local_id) else {
         return false;
@@ -166,32 +177,21 @@ pub fn local_used_after_expr(cx: &LateContext<'_>, local_id: HirId, after: &Expr
     // let closure = || local;
     // closure();
     // closure();
-    let in_loop_or_closure = cx
-        .tcx
-        .hir()
-        .parent_iter(after.hir_id)
-        .take_while(|&(id, _)| id != block.hir_id)
-        .any(|(_, node)| {
-            matches!(
-                node,
-                Node::Expr(Expr {
-                    kind: ExprKind::Loop(..) | ExprKind::Closure { .. },
-                    ..
-                })
-            )
-        });
-    if in_loop_or_closure {
-        return true;
-    }
+    let loop_start = get_enclosing_loop_or_multi_call_closure(cx, after).map(|e| e.hir_id);
 
     let mut past_expr = false;
     for_each_expr_with_closures(cx, block, |e| {
-        if e.hir_id == after.hir_id {
+        if past_expr {
+            if utils::path_to_local_id(e, local_id) {
+                ControlFlow::Break(())
+            } else {
+                ControlFlow::Continue(Descend::Yes)
+            }
+        } else if e.hir_id == after.hir_id {
             past_expr = true;
             ControlFlow::Continue(Descend::No)
-        } else if past_expr && utils::path_to_local_id(e, local_id) {
-            ControlFlow::Break(())
         } else {
+            past_expr = Some(e.hir_id) == loop_start;
             ControlFlow::Continue(Descend::Yes)
         }
     })
diff --git a/clippy_utils/src/visitors.rs b/clippy_utils/src/visitors.rs
index 8dafa723afa..09f447b27eb 100644
--- a/clippy_utils/src/visitors.rs
+++ b/clippy_utils/src/visitors.rs
@@ -52,6 +52,16 @@ pub trait Visitable<'tcx> {
     /// Calls the corresponding `visit_*` function on the visitor.
     fn visit<V: Visitor<'tcx>>(self, visitor: &mut V);
 }
+impl<'tcx, T> Visitable<'tcx> for &'tcx [T]
+where
+    &'tcx T: Visitable<'tcx>,
+{
+    fn visit<V: Visitor<'tcx>>(self, visitor: &mut V) {
+        for x in self {
+            x.visit(visitor);
+        }
+    }
+}
 macro_rules! visitable_ref {
     ($t:ident, $f:ident) => {
         impl<'tcx> Visitable<'tcx> for &'tcx $t<'tcx> {
diff --git a/tests/ui/eta.fixed b/tests/ui/eta.fixed
index db7bd99e0ae..ddabe7616d0 100644
--- a/tests/ui/eta.fixed
+++ b/tests/ui/eta.fixed
@@ -345,3 +345,58 @@ fn angle_brackets_and_args() {
     let dyn_opt: Option<&dyn TestTrait> = Some(&test_struct);
     dyn_opt.map(<dyn TestTrait>::method_on_dyn);
 }
+
+fn _late_bound_to_early_bound_regions() {
+    struct Foo<'a>(&'a u32);
+    impl<'a> Foo<'a> {
+        fn f(x: &'a u32) -> Self {
+            Foo(x)
+        }
+    }
+    fn f(f: impl for<'a> Fn(&'a u32) -> Foo<'a>) -> Foo<'static> {
+        f(&0)
+    }
+
+    let _ = f(|x| Foo::f(x));
+
+    struct Bar;
+    impl<'a> From<&'a u32> for Bar {
+        fn from(x: &'a u32) -> Bar {
+            Bar
+        }
+    }
+    fn f2(f: impl for<'a> Fn(&'a u32) -> Bar) -> Bar {
+        f(&0)
+    }
+
+    let _ = f2(|x| <Bar>::from(x));
+
+    struct Baz<'a>(&'a u32);
+    fn f3(f: impl Fn(&u32) -> Baz<'_>) -> Baz<'static> {
+        f(&0)
+    }
+
+    let _ = f3(|x| Baz(x));
+}
+
+fn _mixed_late_bound_and_early_bound_regions() {
+    fn f<T>(t: T, f: impl Fn(T, &u32) -> u32) -> u32 {
+        f(t, &0)
+    }
+    fn f2<'a, T: 'a>(_: &'a T, y: &u32) -> u32 {
+        *y
+    }
+    let _ = f(&0, f2);
+}
+
+fn _closure_with_types() {
+    fn f<T>(x: T) -> T {
+        x
+    }
+    fn f2<T: Default>(f: impl Fn(T) -> T) -> T {
+        f(T::default())
+    }
+
+    let _ = f2(|x: u32| f(x));
+    let _ = f2(|x| -> u32 { f(x) });
+}
diff --git a/tests/ui/eta.rs b/tests/ui/eta.rs
index 52fc17686fd..92ecff6eb1a 100644
--- a/tests/ui/eta.rs
+++ b/tests/ui/eta.rs
@@ -345,3 +345,58 @@ fn angle_brackets_and_args() {
     let dyn_opt: Option<&dyn TestTrait> = Some(&test_struct);
     dyn_opt.map(|d| d.method_on_dyn());
 }
+
+fn _late_bound_to_early_bound_regions() {
+    struct Foo<'a>(&'a u32);
+    impl<'a> Foo<'a> {
+        fn f(x: &'a u32) -> Self {
+            Foo(x)
+        }
+    }
+    fn f(f: impl for<'a> Fn(&'a u32) -> Foo<'a>) -> Foo<'static> {
+        f(&0)
+    }
+
+    let _ = f(|x| Foo::f(x));
+
+    struct Bar;
+    impl<'a> From<&'a u32> for Bar {
+        fn from(x: &'a u32) -> Bar {
+            Bar
+        }
+    }
+    fn f2(f: impl for<'a> Fn(&'a u32) -> Bar) -> Bar {
+        f(&0)
+    }
+
+    let _ = f2(|x| <Bar>::from(x));
+
+    struct Baz<'a>(&'a u32);
+    fn f3(f: impl Fn(&u32) -> Baz<'_>) -> Baz<'static> {
+        f(&0)
+    }
+
+    let _ = f3(|x| Baz(x));
+}
+
+fn _mixed_late_bound_and_early_bound_regions() {
+    fn f<T>(t: T, f: impl Fn(T, &u32) -> u32) -> u32 {
+        f(t, &0)
+    }
+    fn f2<'a, T: 'a>(_: &'a T, y: &u32) -> u32 {
+        *y
+    }
+    let _ = f(&0, |x, y| f2(x, y));
+}
+
+fn _closure_with_types() {
+    fn f<T>(x: T) -> T {
+        x
+    }
+    fn f2<T: Default>(f: impl Fn(T) -> T) -> T {
+        f(T::default())
+    }
+
+    let _ = f2(|x: u32| f(x));
+    let _ = f2(|x| -> u32 { f(x) });
+}
diff --git a/tests/ui/eta.stderr b/tests/ui/eta.stderr
index 0ac0b901df4..ff40a2074e5 100644
--- a/tests/ui/eta.stderr
+++ b/tests/ui/eta.stderr
@@ -158,5 +158,11 @@ error: redundant closure
 LL |     dyn_opt.map(|d| d.method_on_dyn());
    |                 ^^^^^^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `<dyn TestTrait>::method_on_dyn`
 
-error: aborting due to 26 previous errors
+error: redundant closure
+  --> $DIR/eta.rs:389:19
+   |
+LL |     let _ = f(&0, |x, y| f2(x, y));
+   |                   ^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `f2`
+
+error: aborting due to 27 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 7423c2760b0dbfd4379d2c3eac309d660b859f41 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Fri, 9 Jun 2023 18:59:24 -0400
Subject: Don't lint redundant closure for any function call inserted by the
 compiler.

---
 clippy_lints/src/eta_reduction.rs | 12 ++----------
 1 file changed, 2 insertions(+), 10 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/eta_reduction.rs b/clippy_lints/src/eta_reduction.rs
index 255859da495..8d6fb8438b6 100644
--- a/clippy_lints/src/eta_reduction.rs
+++ b/clippy_lints/src/eta_reduction.rs
@@ -6,7 +6,7 @@ use clippy_utils::usage::{local_used_after_expr, local_used_in};
 use clippy_utils::{higher, is_adjusted, path_to_local, path_to_local_id};
 use rustc_errors::Applicability;
 use rustc_hir::def_id::DefId;
-use rustc_hir::{BindingAnnotation, Expr, ExprKind, FnRetTy, Param, PatKind, TyKind, Unsafety};
+use rustc_hir::{BindingAnnotation, Expr, ExprKind, FnRetTy, Param, PatKind, QPath, TyKind, Unsafety};
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{
@@ -119,16 +119,8 @@ impl<'tcx> LateLintPass<'tcx> for EtaReduction {
 
         match body.value.kind {
             ExprKind::Call(callee, args)
-                if matches!(callee.kind, ExprKind::Path(..)) =>
+                if matches!(callee.kind, ExprKind::Path(QPath::Resolved(..) | QPath::TypeRelative(..))) =>
             {
-                if matches!(higher::Range::hir(body.value), Some(higher::Range {
-                    start: Some(_),
-                    end: Some(_),
-                    limits: rustc_ast::RangeLimits::Closed
-                })) {
-                    return;
-                }
-
                 let callee_ty = typeck.expr_ty(callee).peel_refs();
                 if matches!(
                     type_diagnostic_name(cx, callee_ty),
-- 
cgit 1.4.1-3-g733a5


From 8277e7d15482f0f7a2b2517243814b3a302d50ef Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sun, 30 Jul 2023 03:47:13 -0400
Subject: Don't pass extra generic arguments in `needless_borrow`

---
 clippy_lints/src/dereference.rs | 16 +++++++---------
 tests/ui/needless_borrow.fixed  | 13 +++++++++++++
 tests/ui/needless_borrow.rs     | 13 +++++++++++++
 3 files changed, 33 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index a5ec979ccd9..328a797d9e0 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -3,7 +3,7 @@ use clippy_utils::mir::{enclosing_mir, expr_local, local_assignments, used_exact
 use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::{snippet_with_applicability, snippet_with_context};
 use clippy_utils::sugg::has_enclosing_paren;
-use clippy_utils::ty::{is_copy, peel_mid_ty_refs};
+use clippy_utils::ty::{implements_trait, is_copy, peel_mid_ty_refs};
 use clippy_utils::{
     expr_use_ctxt, get_parent_expr, get_parent_node, is_lint_allowed, path_to_local, DefinedTy, ExprUseNode,
 };
@@ -33,7 +33,6 @@ use rustc_middle::ty::{
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::symbol::sym;
 use rustc_span::{Span, Symbol};
-use rustc_trait_selection::infer::InferCtxtExt as _;
 use rustc_trait_selection::traits::query::evaluate_obligation::InferCtxtExt as _;
 use rustc_trait_selection::traits::{Obligation, ObligationCause};
 use std::collections::VecDeque;
@@ -452,13 +451,12 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing<'tcx> {
                                         // Trait methods taking `self`
                                         arg_ty
                                     } && impl_ty.is_ref()
-                                    && cx.tcx.infer_ctxt().build()
-                                        .type_implements_trait(
-                                            trait_id,
-                                            [impl_ty.into()].into_iter().chain(args.iter().copied()),
-                                            cx.param_env,
-                                        )
-                                        .must_apply_modulo_regions()
+                                    && implements_trait(
+                                        cx,
+                                        impl_ty,
+                                        trait_id,
+                                        &args[..cx.tcx.generics_of(trait_id).params.len() - 1],
+                                    )
                                 {
                                     false
                                 } else {
diff --git a/tests/ui/needless_borrow.fixed b/tests/ui/needless_borrow.fixed
index 1dfbee150d7..e90669bb0df 100644
--- a/tests/ui/needless_borrow.fixed
+++ b/tests/ui/needless_borrow.fixed
@@ -504,3 +504,16 @@ mod issue_10535 {
     {
     }
 }
+
+mod issue_10253 {
+    struct S;
+    trait X {
+        fn f<T>(&self);
+    }
+    impl X for &S {
+        fn f<T>(&self) {}
+    }
+    fn f() {
+        (&S).f::<()>();
+    }
+}
diff --git a/tests/ui/needless_borrow.rs b/tests/ui/needless_borrow.rs
index 3c0d73f5f02..43b037c46b6 100644
--- a/tests/ui/needless_borrow.rs
+++ b/tests/ui/needless_borrow.rs
@@ -504,3 +504,16 @@ mod issue_10535 {
     {
     }
 }
+
+mod issue_10253 {
+    struct S;
+    trait X {
+        fn f<T>(&self);
+    }
+    impl X for &S {
+        fn f<T>(&self) {}
+    }
+    fn f() {
+        (&S).f::<()>();
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 008746cae4976baab645a6ca2d49f8392ded68ae Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Sun, 30 Jul 2023 13:41:58 +0200
Subject: [`unnecessary_find_map`]: look for then_some

---
 clippy_lints/src/methods/unnecessary_filter_map.rs | 10 ++++++++++
 tests/ui/unnecessary_find_map.rs                   |  4 ++++
 tests/ui/unnecessary_find_map.stderr               |  8 +++++++-
 3 files changed, 21 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/unnecessary_filter_map.rs b/clippy_lints/src/methods/unnecessary_filter_map.rs
index cc64a2e7948..fabf3fa0c0c 100644
--- a/clippy_lints/src/methods/unnecessary_filter_map.rs
+++ b/clippy_lints/src/methods/unnecessary_filter_map.rs
@@ -77,6 +77,16 @@ fn check_expression<'tcx>(cx: &LateContext<'tcx>, arg_id: hir::HirId, expr: &'tc
             }
             (true, true)
         },
+        hir::ExprKind::MethodCall(segment, recv, [arg], _) => {
+            if segment.ident.name == sym!(then_some)
+                && cx.typeck_results().expr_ty(recv).is_bool()
+                && path_to_local_id(arg, arg_id)
+            {
+                (false, true)
+            } else {
+                (true, true)
+            }
+        },
         hir::ExprKind::Block(block, _) => block
             .expr
             .as_ref()
diff --git a/tests/ui/unnecessary_find_map.rs b/tests/ui/unnecessary_find_map.rs
index a52390861b4..3be41b775aa 100644
--- a/tests/ui/unnecessary_find_map.rs
+++ b/tests/ui/unnecessary_find_map.rs
@@ -21,3 +21,7 @@ fn main() {
 fn find_map_none_changes_item_type() -> Option<bool> {
     "".chars().find_map(|_| None)
 }
+
+fn issue11260() {
+    let _x = std::iter::once(1).find_map(|n| (n > 1).then_some(n));
+}
diff --git a/tests/ui/unnecessary_find_map.stderr b/tests/ui/unnecessary_find_map.stderr
index fb33c122fe3..3d6ef4f44fd 100644
--- a/tests/ui/unnecessary_find_map.stderr
+++ b/tests/ui/unnecessary_find_map.stderr
@@ -34,5 +34,11 @@ error: this `.find_map` can be written more simply using `.map(..).next()`
 LL |     let _ = (0..4).find_map(|x| Some(x + 1));
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 4 previous errors
+error: this `.find_map` can be written more simply using `.find`
+  --> $DIR/unnecessary_find_map.rs:26:14
+   |
+LL |     let _x = std::iter::once(1).find_map(|n| (n > 1).then_some(n));
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 5 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 35d434d08e522bc613543a265a6191d0c185d0c7 Mon Sep 17 00:00:00 2001
From: Caio <c410.f3r@gmail.com>
Date: Sun, 30 Jul 2023 14:33:38 -0300
Subject: [arithmetic_side_effects] Fix #11262

---
 clippy_lints/src/operators/arithmetic_side_effects.rs | 8 +++++---
 tests/ui/arithmetic_side_effects.rs                   | 7 +++++++
 2 files changed, 12 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/operators/arithmetic_side_effects.rs b/clippy_lints/src/operators/arithmetic_side_effects.rs
index 35dd8fabe6e..f9108145cdb 100644
--- a/clippy_lints/src/operators/arithmetic_side_effects.rs
+++ b/clippy_lints/src/operators/arithmetic_side_effects.rs
@@ -1,7 +1,7 @@
 use super::ARITHMETIC_SIDE_EFFECTS;
 use clippy_utils::consts::{constant, constant_simple, Constant};
 use clippy_utils::diagnostics::span_lint;
-use clippy_utils::{is_from_proc_macro, is_lint_allowed, peel_hir_expr_refs, peel_hir_expr_unary};
+use clippy_utils::{expr_or_init, is_from_proc_macro, is_lint_allowed, peel_hir_expr_refs, peel_hir_expr_unary};
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::Ty;
@@ -138,8 +138,10 @@ impl ArithmeticSideEffects {
         ) {
             return;
         };
-        let (actual_lhs, lhs_ref_counter) = peel_hir_expr_refs(lhs);
-        let (actual_rhs, rhs_ref_counter) = peel_hir_expr_refs(rhs);
+        let (mut actual_lhs, lhs_ref_counter) = peel_hir_expr_refs(lhs);
+        let (mut actual_rhs, rhs_ref_counter) = peel_hir_expr_refs(rhs);
+        actual_lhs = expr_or_init(cx, actual_lhs);
+        actual_rhs = expr_or_init(cx, actual_rhs);
         let lhs_ty = cx.typeck_results().expr_ty(actual_lhs).peel_refs();
         let rhs_ty = cx.typeck_results().expr_ty(actual_rhs).peel_refs();
         if self.has_allowed_binary(lhs_ty, rhs_ty) {
diff --git a/tests/ui/arithmetic_side_effects.rs b/tests/ui/arithmetic_side_effects.rs
index ed75acee8a2..2ac2fa22086 100644
--- a/tests/ui/arithmetic_side_effects.rs
+++ b/tests/ui/arithmetic_side_effects.rs
@@ -486,4 +486,11 @@ pub fn issue_11145() {
     x += 1;
 }
 
+pub fn issue_11262() {
+    let one = 1;
+    let zero = 0;
+    let _ = 2 / one;
+    let _ = 2 / zero;
+}
+
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From dc1e8b0dd9f63beeb3a858051d183a80c46fac32 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Mon, 31 Jul 2023 21:09:52 +0200
Subject: [`unnecessary_mut_passed`]: don't lint in macro expansions

---
 clippy_lints/src/mut_reference.rs |  5 +++++
 tests/ui/mut_reference.rs         | 15 ++++++++++++++-
 tests/ui/mut_reference.stderr     |  8 ++++----
 3 files changed, 23 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/mut_reference.rs b/clippy_lints/src/mut_reference.rs
index 4b20aecad4a..e53e146ec5d 100644
--- a/clippy_lints/src/mut_reference.rs
+++ b/clippy_lints/src/mut_reference.rs
@@ -37,6 +37,11 @@ declare_lint_pass!(UnnecessaryMutPassed => [UNNECESSARY_MUT_PASSED]);
 
 impl<'tcx> LateLintPass<'tcx> for UnnecessaryMutPassed {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
+        if e.span.from_expansion() {
+            // Issue #11268
+            return;
+        }
+
         match e.kind {
             ExprKind::Call(fn_expr, arguments) => {
                 if let ExprKind::Path(ref path) = fn_expr.kind {
diff --git a/tests/ui/mut_reference.rs b/tests/ui/mut_reference.rs
index 73906121c40..00661c51a78 100644
--- a/tests/ui/mut_reference.rs
+++ b/tests/ui/mut_reference.rs
@@ -1,8 +1,21 @@
-#![allow(unused_variables)]
+#![allow(unused_variables, dead_code)]
 
 fn takes_an_immutable_reference(a: &i32) {}
 fn takes_a_mutable_reference(a: &mut i32) {}
 
+mod issue11268 {
+    macro_rules! x {
+        ($f:expr) => {
+            $f(&mut 1);
+        };
+    }
+
+    fn f() {
+        x!(super::takes_an_immutable_reference);
+        x!(super::takes_a_mutable_reference);
+    }
+}
+
 struct MyStruct;
 
 impl MyStruct {
diff --git a/tests/ui/mut_reference.stderr b/tests/ui/mut_reference.stderr
index 1fdfbf9227e..d8a71d26461 100644
--- a/tests/ui/mut_reference.stderr
+++ b/tests/ui/mut_reference.stderr
@@ -1,5 +1,5 @@
 error: the function `takes_an_immutable_reference` doesn't need a mutable reference
-  --> $DIR/mut_reference.rs:17:34
+  --> $DIR/mut_reference.rs:30:34
    |
 LL |     takes_an_immutable_reference(&mut 42);
    |                                  ^^^^^^^
@@ -7,19 +7,19 @@ LL |     takes_an_immutable_reference(&mut 42);
    = note: `-D clippy::unnecessary-mut-passed` implied by `-D warnings`
 
 error: the function `as_ptr` doesn't need a mutable reference
-  --> $DIR/mut_reference.rs:19:12
+  --> $DIR/mut_reference.rs:32:12
    |
 LL |     as_ptr(&mut 42);
    |            ^^^^^^^
 
 error: the method `takes_an_immutable_reference` doesn't need a mutable reference
-  --> $DIR/mut_reference.rs:23:44
+  --> $DIR/mut_reference.rs:36:44
    |
 LL |     my_struct.takes_an_immutable_reference(&mut 42);
    |                                            ^^^^^^^
 
 error: this argument is a mutable reference, but not used mutably
-  --> $DIR/mut_reference.rs:11:44
+  --> $DIR/mut_reference.rs:24:44
    |
 LL |     fn takes_a_mutable_reference(&self, a: &mut i32) {}
    |                                            ^^^^^^^^ help: consider changing to: `&i32`
-- 
cgit 1.4.1-3-g733a5


From f9a6dfa60d4f55ec9a98bc517dea4e4fb9c0f61a Mon Sep 17 00:00:00 2001
From: "Samuel \"Sam\" Tardieu" <sam@rfc1149.net>
Date: Thu, 27 Jul 2023 19:04:01 +0200
Subject: New lint `ignored_unit_patterns`

---
 CHANGELOG.md                              |  1 +
 clippy_dev/src/main.rs                    |  2 +-
 clippy_dev/src/setup/vscode.rs            |  2 +-
 clippy_lints/src/declared_lints.rs        |  1 +
 clippy_lints/src/ignored_unit_patterns.rs | 52 +++++++++++++++++++++++++++++++
 clippy_lints/src/lib.rs                   |  2 ++
 clippy_lints/src/option_if_let_else.rs    |  2 +-
 tests/ui/ignored_unit_patterns.fixed      | 17 ++++++++++
 tests/ui/ignored_unit_patterns.rs         | 17 ++++++++++
 tests/ui/ignored_unit_patterns.stderr     | 28 +++++++++++++++++
 10 files changed, 121 insertions(+), 3 deletions(-)
 create mode 100644 clippy_lints/src/ignored_unit_patterns.rs
 create mode 100644 tests/ui/ignored_unit_patterns.fixed
 create mode 100644 tests/ui/ignored_unit_patterns.rs
 create mode 100644 tests/ui/ignored_unit_patterns.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 251f32d2e6e..370772498e4 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4890,6 +4890,7 @@ Released 2018-09-13
 [`if_same_then_else`]: https://rust-lang.github.io/rust-clippy/master/index.html#if_same_then_else
 [`if_then_some_else_none`]: https://rust-lang.github.io/rust-clippy/master/index.html#if_then_some_else_none
 [`ifs_same_cond`]: https://rust-lang.github.io/rust-clippy/master/index.html#ifs_same_cond
+[`ignored_unit_patterns`]: https://rust-lang.github.io/rust-clippy/master/index.html#ignored_unit_patterns
 [`impl_trait_in_params`]: https://rust-lang.github.io/rust-clippy/master/index.html#impl_trait_in_params
 [`implicit_clone`]: https://rust-lang.github.io/rust-clippy/master/index.html#implicit_clone
 [`implicit_hasher`]: https://rust-lang.github.io/rust-clippy/master/index.html#implicit_hasher
diff --git a/clippy_dev/src/main.rs b/clippy_dev/src/main.rs
index 43eaccdf5a3..fca750fafc7 100644
--- a/clippy_dev/src/main.rs
+++ b/clippy_dev/src/main.rs
@@ -41,7 +41,7 @@ fn main() {
                 matches.get_one::<String>("type").map(String::as_str),
                 matches.get_flag("msrv"),
             ) {
-                Ok(_) => update_lints::update(update_lints::UpdateMode::Change),
+                Ok(()) => update_lints::update(update_lints::UpdateMode::Change),
                 Err(e) => eprintln!("Unable to create lint: {e}"),
             }
         },
diff --git a/clippy_dev/src/setup/vscode.rs b/clippy_dev/src/setup/vscode.rs
index dbcdc9b59e5..204f4af2cf1 100644
--- a/clippy_dev/src/setup/vscode.rs
+++ b/clippy_dev/src/setup/vscode.rs
@@ -47,7 +47,7 @@ fn check_install_precondition(force_override: bool) -> bool {
         }
     } else {
         match fs::create_dir(vs_dir_path) {
-            Ok(_) => {
+            Ok(()) => {
                 println!("info: created `{VSCODE_DIR}` directory for clippy");
             },
             Err(err) => {
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index e084471433d..413025dafcb 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -203,6 +203,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::if_let_mutex::IF_LET_MUTEX_INFO,
     crate::if_not_else::IF_NOT_ELSE_INFO,
     crate::if_then_some_else_none::IF_THEN_SOME_ELSE_NONE_INFO,
+    crate::ignored_unit_patterns::IGNORED_UNIT_PATTERNS_INFO,
     crate::implicit_hasher::IMPLICIT_HASHER_INFO,
     crate::implicit_return::IMPLICIT_RETURN_INFO,
     crate::implicit_saturating_add::IMPLICIT_SATURATING_ADD_INFO,
diff --git a/clippy_lints/src/ignored_unit_patterns.rs b/clippy_lints/src/ignored_unit_patterns.rs
new file mode 100644
index 00000000000..c635120b882
--- /dev/null
+++ b/clippy_lints/src/ignored_unit_patterns.rs
@@ -0,0 +1,52 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use hir::PatKind;
+use rustc_errors::Applicability;
+use rustc_hir as hir;
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of `_` in patterns of type `()`.
+    ///
+    /// ### Why is this bad?
+    /// Matching with `()` explicitly instead of `_` outlines
+    /// the fact that the pattern contains no data. Also it
+    /// would detect a type change that `_` would ignore.
+    ///
+    /// ### Example
+    /// ```rust
+    /// match std::fs::create_dir("tmp-work-dir") {
+    ///    Ok(_) => println!("Working directory created"),
+    ///    Err(s) => eprintln!("Could not create directory: {s}"),
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// match std::fs::create_dir("tmp-work-dir") {
+    ///    Ok(()) => println!("Working directory created"),
+    ///    Err(s) => eprintln!("Could not create directory: {s}"),
+    /// }
+    /// ```
+    #[clippy::version = "1.73.0"]
+    pub IGNORED_UNIT_PATTERNS,
+    pedantic,
+    "suggest replacing `_` by `()` in patterns where appropriate"
+}
+declare_lint_pass!(IgnoredUnitPatterns => [IGNORED_UNIT_PATTERNS]);
+
+impl<'tcx> LateLintPass<'tcx> for IgnoredUnitPatterns {
+    fn check_pat(&mut self, cx: &LateContext<'tcx>, pat: &'tcx hir::Pat<'tcx>) {
+        if matches!(pat.kind, PatKind::Wild) && cx.typeck_results().pat_ty(pat).is_unit() {
+            span_lint_and_sugg(
+                cx,
+                IGNORED_UNIT_PATTERNS,
+                pat.span,
+                "matching over `()` is more explicit",
+                "use `()` instead of `_`",
+                String::from("()"),
+                Applicability::MachineApplicable,
+            );
+        }
+    }
+}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 9d6096ccb2a..358004cf460 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -147,6 +147,7 @@ mod future_not_send;
 mod if_let_mutex;
 mod if_not_else;
 mod if_then_some_else_none;
+mod ignored_unit_patterns;
 mod implicit_hasher;
 mod implicit_return;
 mod implicit_saturating_add;
@@ -1093,6 +1094,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         })
     });
     store.register_late_pass(|_| Box::new(redundant_locals::RedundantLocals));
+    store.register_late_pass(|_| Box::new(ignored_unit_patterns::IgnoredUnitPatterns));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/option_if_let_else.rs b/clippy_lints/src/option_if_let_else.rs
index 40da002f4ff..a7a7f4fd8fa 100644
--- a/clippy_lints/src/option_if_let_else.rs
+++ b/clippy_lints/src/option_if_let_else.rs
@@ -155,7 +155,7 @@ fn try_get_option_occurrence<'tcx>(
                 });
                 if let ExprKind::Path(QPath::Resolved(None, Path { res: Res::Local(local_id), .. })) = e.kind {
                     match some_captures.get(local_id)
-                        .or_else(|| (method_sugg == "map_or_else").then_some(()).and_then(|_| none_captures.get(local_id)))
+                        .or_else(|| (method_sugg == "map_or_else").then_some(()).and_then(|()| none_captures.get(local_id)))
                     {
                         Some(CaptureKind::Value | CaptureKind::Ref(Mutability::Mut)) => return None,
                         Some(CaptureKind::Ref(Mutability::Not)) if as_mut => return None,
diff --git a/tests/ui/ignored_unit_patterns.fixed b/tests/ui/ignored_unit_patterns.fixed
new file mode 100644
index 00000000000..492219fe447
--- /dev/null
+++ b/tests/ui/ignored_unit_patterns.fixed
@@ -0,0 +1,17 @@
+//@run-rustfix
+
+#![warn(clippy::ignored_unit_patterns)]
+#![allow(clippy::redundant_pattern_matching, clippy::single_match)]
+
+fn foo() -> Result<(), ()> {
+    unimplemented!()
+}
+
+fn main() {
+    match foo() {
+        Ok(()) => {},
+        Err(()) => {},
+    }
+    if let Ok(()) = foo() {}
+    let _ = foo().map_err(|()| todo!());
+}
diff --git a/tests/ui/ignored_unit_patterns.rs b/tests/ui/ignored_unit_patterns.rs
new file mode 100644
index 00000000000..90af36f8e5e
--- /dev/null
+++ b/tests/ui/ignored_unit_patterns.rs
@@ -0,0 +1,17 @@
+//@run-rustfix
+
+#![warn(clippy::ignored_unit_patterns)]
+#![allow(clippy::redundant_pattern_matching, clippy::single_match)]
+
+fn foo() -> Result<(), ()> {
+    unimplemented!()
+}
+
+fn main() {
+    match foo() {
+        Ok(_) => {},
+        Err(_) => {},
+    }
+    if let Ok(_) = foo() {}
+    let _ = foo().map_err(|_| todo!());
+}
diff --git a/tests/ui/ignored_unit_patterns.stderr b/tests/ui/ignored_unit_patterns.stderr
new file mode 100644
index 00000000000..8feea3cc2a8
--- /dev/null
+++ b/tests/ui/ignored_unit_patterns.stderr
@@ -0,0 +1,28 @@
+error: matching over `()` is more explicit
+  --> $DIR/ignored_unit_patterns.rs:12:12
+   |
+LL |         Ok(_) => {},
+   |            ^ help: use `()` instead of `_`: `()`
+   |
+   = note: `-D clippy::ignored-unit-patterns` implied by `-D warnings`
+
+error: matching over `()` is more explicit
+  --> $DIR/ignored_unit_patterns.rs:13:13
+   |
+LL |         Err(_) => {},
+   |             ^ help: use `()` instead of `_`: `()`
+
+error: matching over `()` is more explicit
+  --> $DIR/ignored_unit_patterns.rs:15:15
+   |
+LL |     if let Ok(_) = foo() {}
+   |               ^ help: use `()` instead of `_`: `()`
+
+error: matching over `()` is more explicit
+  --> $DIR/ignored_unit_patterns.rs:16:28
+   |
+LL |     let _ = foo().map_err(|_| todo!());
+   |                            ^ help: use `()` instead of `_`: `()`
+
+error: aborting due to 4 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 72074a0f002dd67aa87f2bd913e8811972dcc415 Mon Sep 17 00:00:00 2001
From: Your Name <you@example.com>
Date: Wed, 2 Aug 2023 13:38:59 +0800
Subject: Alphabetically order arms in methods/mod.rs match

---
 clippy_lints/src/methods/mod.rs | 38 +++++++++++++++++++-------------------
 1 file changed, 19 insertions(+), 19 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index dd694ce7393..62d565bcc5c 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3881,6 +3881,13 @@ impl Methods {
                         unnecessary_lazy_eval::check(cx, expr, recv, arg, "and");
                     }
                 },
+                ("any", [arg]) if let ExprKind::Closure(arg) = arg.kind
+                    && let body = cx.tcx.hir().body(arg.body)
+                    && let [param] = body.params
+                    && let Some(("chars", recv, _, _, _)) = method_call(recv) =>
+                {
+                    string_lit_chars_any::check(cx, expr, recv, param, peel_blocks(body.value), &self.msrv);
+                }
                 ("arg", [arg]) => {
                     suspicious_command_arg_space::check(cx, recv, arg, span);
                 }
@@ -3999,15 +4006,6 @@ impl Methods {
                         unnecessary_join::check(cx, expr, recv, join_arg, span);
                     }
                 },
-                ("skip", [arg]) => {
-                    iter_skip_zero::check(cx, expr, arg);
-
-                    if let Some((name2, recv2, args2, _span2, _)) = method_call(recv) {
-                        if let ("cloned", []) = (name2, args2) {
-                            iter_overeager_cloned::check(cx, expr, recv, recv2, false, false);
-                        }
-                    }
-                }
                 ("last", []) => {
                     if let Some((name2, recv2, args2, _span2, _)) = method_call(recv) {
                         if let ("cloned", []) = (name2, args2) {
@@ -4060,13 +4058,6 @@ impl Methods {
                         }
                     }
                 },
-                ("any", [arg]) if let ExprKind::Closure(arg) = arg.kind
-                    && let body = cx.tcx.hir().body(arg.body)
-                    && let [param] = body.params
-                    && let Some(("chars", recv, _, _, _)) = method_call(recv) =>
-                {
-                    string_lit_chars_any::check(cx, expr, recv, param, peel_blocks(body.value), &self.msrv);
-                }
                 ("nth", [n_arg]) => match method_call(recv) {
                     Some(("bytes", recv2, [], _, _)) => bytes_nth::check(cx, expr, recv2, n_arg),
                     Some(("cloned", recv2, [], _, _)) => iter_overeager_cloned::check(cx, expr, recv, recv2, false, false),
@@ -4120,6 +4111,15 @@ impl Methods {
                         seek_to_start_instead_of_rewind::check(cx, expr, recv, arg, span);
                     }
                 },
+                ("skip", [arg]) => {
+                    iter_skip_zero::check(cx, expr, arg);
+
+                    if let Some((name2, recv2, args2, _span2, _)) = method_call(recv) {
+                        if let ("cloned", []) = (name2, args2) {
+                            iter_overeager_cloned::check(cx, expr, recv, recv2, false, false);
+                        }
+                    }
+                }
                 ("sort", []) => {
                     stable_sort_primitive::check(cx, expr, recv);
                 },
@@ -4214,6 +4214,9 @@ impl Methods {
                     }
                     unnecessary_literal_unwrap::check(cx, expr, recv, name, args);
                 },
+                ("write", []) => {
+                    readonly_write_lock::check(cx, expr, recv);
+                }
                 ("zip", [arg]) => {
                     if let ExprKind::MethodCall(name, iter_recv, [], _) = recv.kind
                         && name.ident.name == sym::iter
@@ -4221,9 +4224,6 @@ impl Methods {
                         range_zip_with_len::check(cx, expr, iter_recv, arg);
                     }
                 },
-                ("write", []) => {
-                    readonly_write_lock::check(cx, expr, recv);
-                }
                 _ => {},
             }
         }
-- 
cgit 1.4.1-3-g733a5


From 779e0f4021b591919c34126f623e3bc2383cb185 Mon Sep 17 00:00:00 2001
From: Catherine Flores <catherine.3.flores@gmail.com>
Date: Sat, 29 Jul 2023 00:06:08 -0500
Subject: Do not lint unwrapping on `!` or never-like enums

---
 clippy_lints/src/methods/expect_used.rs        | 44 -------------
 clippy_lints/src/methods/mod.rs                | 39 ++++++++++--
 clippy_lints/src/methods/unwrap_expect_used.rs | 87 ++++++++++++++++++++++++++
 clippy_lints/src/methods/unwrap_used.rs        | 53 ----------------
 tests/ui/unwrap_expect_used.rs                 | 11 ++++
 tests/ui/unwrap_expect_used.stderr             | 12 ++--
 6 files changed, 137 insertions(+), 109 deletions(-)
 delete mode 100644 clippy_lints/src/methods/expect_used.rs
 create mode 100644 clippy_lints/src/methods/unwrap_expect_used.rs
 delete mode 100644 clippy_lints/src/methods/unwrap_used.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/expect_used.rs b/clippy_lints/src/methods/expect_used.rs
deleted file mode 100644
index 614610335a1..00000000000
--- a/clippy_lints/src/methods/expect_used.rs
+++ /dev/null
@@ -1,44 +0,0 @@
-use clippy_utils::diagnostics::span_lint_and_help;
-use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{is_in_cfg_test, is_in_test_function};
-use rustc_hir as hir;
-use rustc_lint::LateContext;
-use rustc_span::sym;
-
-use super::EXPECT_USED;
-
-/// lint use of `expect()` or `expect_err` for `Result` and `expect()` for `Option`.
-pub(super) fn check(
-    cx: &LateContext<'_>,
-    expr: &hir::Expr<'_>,
-    recv: &hir::Expr<'_>,
-    is_err: bool,
-    allow_expect_in_tests: bool,
-) {
-    let obj_ty = cx.typeck_results().expr_ty(recv).peel_refs();
-
-    let mess = if is_type_diagnostic_item(cx, obj_ty, sym::Option) && !is_err {
-        Some((EXPECT_USED, "an `Option`", "None", ""))
-    } else if is_type_diagnostic_item(cx, obj_ty, sym::Result) {
-        Some((EXPECT_USED, "a `Result`", if is_err { "Ok" } else { "Err" }, "an "))
-    } else {
-        None
-    };
-
-    let method = if is_err { "expect_err" } else { "expect" };
-
-    if allow_expect_in_tests && (is_in_test_function(cx.tcx, expr.hir_id) || is_in_cfg_test(cx.tcx, expr.hir_id)) {
-        return;
-    }
-
-    if let Some((lint, kind, none_value, none_prefix)) = mess {
-        span_lint_and_help(
-            cx,
-            lint,
-            expr.span,
-            &format!("used `{method}()` on {kind} value"),
-            None,
-            &format!("if this value is {none_prefix}`{none_value}`, it will panic"),
-        );
-    }
-}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 62d565bcc5c..17483656cec 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -17,7 +17,6 @@ mod collapsible_str_replace;
 mod drain_collect;
 mod err_expect;
 mod expect_fun_call;
-mod expect_used;
 mod extend_with_drain;
 mod filetype_is_file;
 mod filter_map;
@@ -105,7 +104,7 @@ mod unnecessary_lazy_eval;
 mod unnecessary_literal_unwrap;
 mod unnecessary_sort_by;
 mod unnecessary_to_owned;
-mod unwrap_used;
+mod unwrap_expect_used;
 mod useless_asref;
 mod utils;
 mod vec_resize_to_zero;
@@ -3948,13 +3947,27 @@ impl Methods {
                     match method_call(recv) {
                         Some(("ok", recv, [], _, _)) => ok_expect::check(cx, expr, recv),
                         Some(("err", recv, [], err_span, _)) => err_expect::check(cx, expr, recv, span, err_span, &self.msrv),
-                        _ => expect_used::check(cx, expr, recv, false, self.allow_expect_in_tests),
+                        _ => unwrap_expect_used::check(
+                            cx,
+                            expr,
+                            recv,
+                            false,
+                            self.allow_expect_in_tests,
+                            unwrap_expect_used::Variant::Expect,
+                        ),
                     }
                     unnecessary_literal_unwrap::check(cx, expr, recv, name, args);
                 },
                 ("expect_err", [_]) => {
                     unnecessary_literal_unwrap::check(cx, expr, recv, name, args);
-                    expect_used::check(cx, expr, recv, true, self.allow_expect_in_tests);
+                    unwrap_expect_used::check(
+                        cx,
+                        expr,
+                        recv,
+                        true,
+                        self.allow_expect_in_tests,
+                        unwrap_expect_used::Variant::Expect,
+                    );
                 },
                 ("extend", [arg]) => {
                     string_extend_chars::check(cx, expr, recv, arg);
@@ -4180,11 +4193,25 @@ impl Methods {
                         _ => {},
                     }
                     unnecessary_literal_unwrap::check(cx, expr, recv, name, args);
-                    unwrap_used::check(cx, expr, recv, false, self.allow_unwrap_in_tests);
+                    unwrap_expect_used::check(
+                        cx,
+                        expr,
+                        recv,
+                        false,
+                        self.allow_unwrap_in_tests,
+                        unwrap_expect_used::Variant::Unwrap,
+                    );
                 },
                 ("unwrap_err", []) => {
                     unnecessary_literal_unwrap::check(cx, expr, recv, name, args);
-                    unwrap_used::check(cx, expr, recv, true, self.allow_unwrap_in_tests);
+                    unwrap_expect_used::check(
+                        cx,
+                        expr,
+                        recv,
+                        true,
+                        self.allow_unwrap_in_tests,
+                        unwrap_expect_used::Variant::Unwrap,
+                    );
                 },
                 ("unwrap_or", [u_arg]) => {
                     match method_call(recv) {
diff --git a/clippy_lints/src/methods/unwrap_expect_used.rs b/clippy_lints/src/methods/unwrap_expect_used.rs
new file mode 100644
index 00000000000..9b93eda688d
--- /dev/null
+++ b/clippy_lints/src/methods/unwrap_expect_used.rs
@@ -0,0 +1,87 @@
+use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::{is_in_cfg_test, is_in_test_function, is_lint_allowed};
+use rustc_hir::Expr;
+use rustc_lint::{LateContext, Lint};
+use rustc_middle::ty;
+use rustc_span::sym;
+
+use super::{EXPECT_USED, UNWRAP_USED};
+
+#[derive(Clone, Copy, Eq, PartialEq)]
+pub(super) enum Variant {
+    Unwrap,
+    Expect,
+}
+
+impl Variant {
+    fn method_name(self, is_err: bool) -> &'static str {
+        match (self, is_err) {
+            (Variant::Unwrap, true) => "unwrap_err",
+            (Variant::Unwrap, false) => "unwrap",
+            (Variant::Expect, true) => "expect_err",
+            (Variant::Expect, false) => "expect",
+        }
+    }
+
+    fn lint(self) -> &'static Lint {
+        match self {
+            Variant::Unwrap => UNWRAP_USED,
+            Variant::Expect => EXPECT_USED,
+        }
+    }
+}
+
+/// lint use of `unwrap()` or `unwrap_err` for `Result` and `unwrap()` for `Option`.
+pub(super) fn check(
+    cx: &LateContext<'_>,
+    expr: &Expr<'_>,
+    recv: &Expr<'_>,
+    is_err: bool,
+    allow_unwrap_in_tests: bool,
+    variant: Variant,
+) {
+    let ty = cx.typeck_results().expr_ty(recv).peel_refs();
+
+    let (kind, none_value, none_prefix) = if is_type_diagnostic_item(cx, ty, sym::Option) && !is_err {
+        ("an `Option`", "None", "")
+    } else if is_type_diagnostic_item(cx, ty, sym::Result)
+        && let ty::Adt(_, substs) = ty.kind()
+        && let Some(t_or_e_ty) = substs[usize::from(!is_err)].as_type()
+    {
+        // Issue #11245: Do not lint `!` or never-like enums
+        if t_or_e_ty.is_never()
+            || (t_or_e_ty.is_enum() && t_or_e_ty.ty_adt_def().is_some_and(|def| def.variants().is_empty()))
+        {
+            return;
+        }
+
+        ("a `Result`", if is_err { "Ok" } else { "Err" }, "an ")
+    } else {
+        return;
+    };
+
+    let method_suffix = if is_err { "_err" } else { "" };
+
+    if allow_unwrap_in_tests && (is_in_test_function(cx.tcx, expr.hir_id) || is_in_cfg_test(cx.tcx, expr.hir_id)) {
+        return;
+    }
+
+    let help = if variant == Variant::Unwrap && is_lint_allowed(cx, EXPECT_USED, expr.hir_id) {
+        format!(
+            "if you don't want to handle the `{none_value}` case gracefully, consider \
+                using `expect{method_suffix}()` to provide a better panic message"
+        )
+    } else {
+        format!("if this value is {none_prefix}`{none_value}`, it will panic")
+    };
+
+    span_lint_and_help(
+        cx,
+        variant.lint(),
+        expr.span,
+        &format!("used `{}()` on {kind} value", variant.method_name(is_err)),
+        None,
+        &help,
+    );
+}
diff --git a/clippy_lints/src/methods/unwrap_used.rs b/clippy_lints/src/methods/unwrap_used.rs
deleted file mode 100644
index 5e4c3daee64..00000000000
--- a/clippy_lints/src/methods/unwrap_used.rs
+++ /dev/null
@@ -1,53 +0,0 @@
-use clippy_utils::diagnostics::span_lint_and_help;
-use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{is_in_cfg_test, is_in_test_function, is_lint_allowed};
-use rustc_hir as hir;
-use rustc_lint::LateContext;
-use rustc_span::sym;
-
-use super::{EXPECT_USED, UNWRAP_USED};
-
-/// lint use of `unwrap()` or `unwrap_err` for `Result` and `unwrap()` for `Option`.
-pub(super) fn check(
-    cx: &LateContext<'_>,
-    expr: &hir::Expr<'_>,
-    recv: &hir::Expr<'_>,
-    is_err: bool,
-    allow_unwrap_in_tests: bool,
-) {
-    let obj_ty = cx.typeck_results().expr_ty(recv).peel_refs();
-
-    let mess = if is_type_diagnostic_item(cx, obj_ty, sym::Option) && !is_err {
-        Some((UNWRAP_USED, "an `Option`", "None", ""))
-    } else if is_type_diagnostic_item(cx, obj_ty, sym::Result) {
-        Some((UNWRAP_USED, "a `Result`", if is_err { "Ok" } else { "Err" }, "an "))
-    } else {
-        None
-    };
-
-    let method_suffix = if is_err { "_err" } else { "" };
-
-    if allow_unwrap_in_tests && (is_in_test_function(cx.tcx, expr.hir_id) || is_in_cfg_test(cx.tcx, expr.hir_id)) {
-        return;
-    }
-
-    if let Some((lint, kind, none_value, none_prefix)) = mess {
-        let help = if is_lint_allowed(cx, EXPECT_USED, expr.hir_id) {
-            format!(
-                "if you don't want to handle the `{none_value}` case gracefully, consider \
-                using `expect{method_suffix}()` to provide a better panic message"
-            )
-        } else {
-            format!("if this value is {none_prefix}`{none_value}`, it will panic")
-        };
-
-        span_lint_and_help(
-            cx,
-            lint,
-            expr.span,
-            &format!("used `unwrap{method_suffix}()` on {kind} value"),
-            None,
-            &help,
-        );
-    }
-}
diff --git a/tests/ui/unwrap_expect_used.rs b/tests/ui/unwrap_expect_used.rs
index 7f57efc53c9..26f92ccdefa 100644
--- a/tests/ui/unwrap_expect_used.rs
+++ b/tests/ui/unwrap_expect_used.rs
@@ -1,5 +1,8 @@
 #![warn(clippy::unwrap_used, clippy::expect_used)]
 #![allow(clippy::unnecessary_literal_unwrap)]
+#![feature(never_type)]
+
+use std::convert::Infallible;
 
 trait OptionExt {
     type Item;
@@ -28,6 +31,14 @@ fn main() {
     Some(3).unwrap_err();
     Some(3).expect_err("Hellow none!");
 
+    // Issue #11245: The `Err` variant can never be constructed so do not lint this.
+    let x: Result<(), !> = Ok(());
+    x.unwrap();
+    x.expect("is `!` (never)");
+    let x: Result<(), Infallible> = Ok(());
+    x.unwrap();
+    x.expect("is never-like (0 variants)");
+
     let a: Result<i32, i32> = Ok(3);
     a.unwrap();
     a.expect("Hello world!");
diff --git a/tests/ui/unwrap_expect_used.stderr b/tests/ui/unwrap_expect_used.stderr
index 1a551ab5ab8..8cbde8bf946 100644
--- a/tests/ui/unwrap_expect_used.stderr
+++ b/tests/ui/unwrap_expect_used.stderr
@@ -1,5 +1,5 @@
 error: used `unwrap()` on an `Option` value
-  --> $DIR/unwrap_expect_used.rs:24:5
+  --> $DIR/unwrap_expect_used.rs:27:5
    |
 LL |     Some(3).unwrap();
    |     ^^^^^^^^^^^^^^^^
@@ -8,7 +8,7 @@ LL |     Some(3).unwrap();
    = note: `-D clippy::unwrap-used` implied by `-D warnings`
 
 error: used `expect()` on an `Option` value
-  --> $DIR/unwrap_expect_used.rs:25:5
+  --> $DIR/unwrap_expect_used.rs:28:5
    |
 LL |     Some(3).expect("Hello world!");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -17,7 +17,7 @@ LL |     Some(3).expect("Hello world!");
    = note: `-D clippy::expect-used` implied by `-D warnings`
 
 error: used `unwrap()` on a `Result` value
-  --> $DIR/unwrap_expect_used.rs:32:5
+  --> $DIR/unwrap_expect_used.rs:43:5
    |
 LL |     a.unwrap();
    |     ^^^^^^^^^^
@@ -25,7 +25,7 @@ LL |     a.unwrap();
    = help: if this value is an `Err`, it will panic
 
 error: used `expect()` on a `Result` value
-  --> $DIR/unwrap_expect_used.rs:33:5
+  --> $DIR/unwrap_expect_used.rs:44:5
    |
 LL |     a.expect("Hello world!");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -33,7 +33,7 @@ LL |     a.expect("Hello world!");
    = help: if this value is an `Err`, it will panic
 
 error: used `unwrap_err()` on a `Result` value
-  --> $DIR/unwrap_expect_used.rs:34:5
+  --> $DIR/unwrap_expect_used.rs:45:5
    |
 LL |     a.unwrap_err();
    |     ^^^^^^^^^^^^^^
@@ -41,7 +41,7 @@ LL |     a.unwrap_err();
    = help: if this value is an `Ok`, it will panic
 
 error: used `expect_err()` on a `Result` value
-  --> $DIR/unwrap_expect_used.rs:35:5
+  --> $DIR/unwrap_expect_used.rs:46:5
    |
 LL |     a.expect_err("Hello error!");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From 71c54137eadc730d01fe15c17df8bf3ba5d3b04b Mon Sep 17 00:00:00 2001
From: Catherine Flores <catherine.3.flores@gmail.com>
Date: Wed, 2 Aug 2023 13:57:06 -0500
Subject: Extract never-like into `clippy_utils`

---
 clippy_lints/src/methods/unwrap_expect_used.rs | 34 ++++++++++------------
 clippy_utils/src/ty.rs                         |  5 ++++
 tests/ui-toml/expect_used/expect_used.stderr   |  4 +--
 tests/ui-toml/unwrap_used/unwrap_used.stderr   | 39 +++++++++++++++++---------
 tests/ui/expect.stderr                         |  6 ++--
 tests/ui/get_unwrap.stderr                     | 39 +++++++++++++++++---------
 tests/ui/unwrap.stderr                         |  9 ++++--
 tests/ui/unwrap_expect_used.stderr             | 12 ++++----
 8 files changed, 89 insertions(+), 59 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/unwrap_expect_used.rs b/clippy_lints/src/methods/unwrap_expect_used.rs
index 9b93eda688d..7bd16b473ce 100644
--- a/clippy_lints/src/methods/unwrap_expect_used.rs
+++ b/clippy_lints/src/methods/unwrap_expect_used.rs
@@ -1,5 +1,5 @@
-use clippy_utils::diagnostics::span_lint_and_help;
-use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::ty::{is_never_like, is_type_diagnostic_item};
 use clippy_utils::{is_in_cfg_test, is_in_test_function, is_lint_allowed};
 use rustc_hir::Expr;
 use rustc_lint::{LateContext, Lint};
@@ -32,7 +32,8 @@ impl Variant {
     }
 }
 
-/// lint use of `unwrap()` or `unwrap_err` for `Result` and `unwrap()` for `Option`.
+/// Lint usage of `unwrap` or `unwrap_err` for `Result` and `unwrap()` for `Option` (and their
+/// `expect` counterparts).
 pub(super) fn check(
     cx: &LateContext<'_>,
     expr: &Expr<'_>,
@@ -49,10 +50,7 @@ pub(super) fn check(
         && let ty::Adt(_, substs) = ty.kind()
         && let Some(t_or_e_ty) = substs[usize::from(!is_err)].as_type()
     {
-        // Issue #11245: Do not lint `!` or never-like enums
-        if t_or_e_ty.is_never()
-            || (t_or_e_ty.is_enum() && t_or_e_ty.ty_adt_def().is_some_and(|def| def.variants().is_empty()))
-        {
+        if is_never_like(t_or_e_ty) {
             return;
         }
 
@@ -67,21 +65,19 @@ pub(super) fn check(
         return;
     }
 
-    let help = if variant == Variant::Unwrap && is_lint_allowed(cx, EXPECT_USED, expr.hir_id) {
-        format!(
-            "if you don't want to handle the `{none_value}` case gracefully, consider \
-                using `expect{method_suffix}()` to provide a better panic message"
-        )
-    } else {
-        format!("if this value is {none_prefix}`{none_value}`, it will panic")
-    };
-
-    span_lint_and_help(
+    span_lint_and_then(
         cx,
         variant.lint(),
         expr.span,
         &format!("used `{}()` on {kind} value", variant.method_name(is_err)),
-        None,
-        &help,
+        |diag| {
+            diag.note(format!("if this value is {none_prefix}`{none_value}`, it will panic"));
+
+            if variant == Variant::Unwrap && is_lint_allowed(cx, EXPECT_USED, expr.hir_id) {
+                diag.help(format!(
+                    "consider using `expect{method_suffix}()` to provide a better panic message"
+                ));
+            }
+        },
     );
 }
diff --git a/clippy_utils/src/ty.rs b/clippy_utils/src/ty.rs
index d0e15aa8bb3..98e163abc58 100644
--- a/clippy_utils/src/ty.rs
+++ b/clippy_utils/src/ty.rs
@@ -1093,6 +1093,11 @@ fn assert_generic_args_match<'tcx>(tcx: TyCtxt<'tcx>, did: DefId, args: &[Generi
     }
 }
 
+/// Returns whether `ty` is never-like; i.e., `!` (never) or an enum with zero variants.
+pub fn is_never_like(ty: Ty<'_>) -> bool {
+    ty.is_never() || (ty.is_enum() && ty.ty_adt_def().is_some_and(|def| def.variants().is_empty()))
+}
+
 /// Makes the projection type for the named associated type in the given impl or trait impl.
 ///
 /// This function is for associated types which are "known" to exist, and as such, will only return
diff --git a/tests/ui-toml/expect_used/expect_used.stderr b/tests/ui-toml/expect_used/expect_used.stderr
index 9eef0e1bfaa..815d009350f 100644
--- a/tests/ui-toml/expect_used/expect_used.stderr
+++ b/tests/ui-toml/expect_used/expect_used.stderr
@@ -4,7 +4,7 @@ error: used `expect()` on an `Option` value
 LL |     let _ = opt.expect("");
    |             ^^^^^^^^^^^^^^
    |
-   = help: if this value is `None`, it will panic
+   = note: if this value is `None`, it will panic
    = note: `-D clippy::expect-used` implied by `-D warnings`
 
 error: used `expect()` on a `Result` value
@@ -13,7 +13,7 @@ error: used `expect()` on a `Result` value
 LL |     let _ = res.expect("");
    |             ^^^^^^^^^^^^^^
    |
-   = help: if this value is an `Err`, it will panic
+   = note: if this value is an `Err`, it will panic
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui-toml/unwrap_used/unwrap_used.stderr b/tests/ui-toml/unwrap_used/unwrap_used.stderr
index 4c9bdfa9dba..10219beaf97 100644
--- a/tests/ui-toml/unwrap_used/unwrap_used.stderr
+++ b/tests/ui-toml/unwrap_used/unwrap_used.stderr
@@ -12,7 +12,8 @@ error: used `unwrap()` on an `Option` value
 LL |         let _ = boxed_slice.get(1).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
+   = note: if this value is `None`, it will panic
+   = help: consider using `expect()` to provide a better panic message
    = note: `-D clippy::unwrap-used` implied by `-D warnings`
 
 error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more concise
@@ -27,7 +28,8 @@ error: used `unwrap()` on an `Option` value
 LL |         let _ = some_slice.get(0).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
+   = note: if this value is `None`, it will panic
+   = help: consider using `expect()` to provide a better panic message
 
 error: called `.get().unwrap()` on a Vec. Using `[]` is more clear and more concise
   --> $DIR/unwrap_used.rs:40:17
@@ -41,7 +43,8 @@ error: used `unwrap()` on an `Option` value
 LL |         let _ = some_vec.get(0).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
+   = note: if this value is `None`, it will panic
+   = help: consider using `expect()` to provide a better panic message
 
 error: called `.get().unwrap()` on a VecDeque. Using `[]` is more clear and more concise
   --> $DIR/unwrap_used.rs:41:17
@@ -55,7 +58,8 @@ error: used `unwrap()` on an `Option` value
 LL |         let _ = some_vecdeque.get(0).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
+   = note: if this value is `None`, it will panic
+   = help: consider using `expect()` to provide a better panic message
 
 error: called `.get().unwrap()` on a HashMap. Using `[]` is more clear and more concise
   --> $DIR/unwrap_used.rs:42:17
@@ -69,7 +73,8 @@ error: used `unwrap()` on an `Option` value
 LL |         let _ = some_hashmap.get(&1).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
+   = note: if this value is `None`, it will panic
+   = help: consider using `expect()` to provide a better panic message
 
 error: called `.get().unwrap()` on a BTreeMap. Using `[]` is more clear and more concise
   --> $DIR/unwrap_used.rs:43:17
@@ -83,7 +88,8 @@ error: used `unwrap()` on an `Option` value
 LL |         let _ = some_btreemap.get(&1).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
+   = note: if this value is `None`, it will panic
+   = help: consider using `expect()` to provide a better panic message
 
 error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more concise
   --> $DIR/unwrap_used.rs:47:21
@@ -97,7 +103,8 @@ error: used `unwrap()` on an `Option` value
 LL |         let _: u8 = *boxed_slice.get(1).unwrap();
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
+   = note: if this value is `None`, it will panic
+   = help: consider using `expect()` to provide a better panic message
 
 error: called `.get_mut().unwrap()` on a slice. Using `[]` is more clear and more concise
   --> $DIR/unwrap_used.rs:52:9
@@ -111,7 +118,8 @@ error: used `unwrap()` on an `Option` value
 LL |         *boxed_slice.get_mut(0).unwrap() = 1;
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
+   = note: if this value is `None`, it will panic
+   = help: consider using `expect()` to provide a better panic message
 
 error: called `.get_mut().unwrap()` on a slice. Using `[]` is more clear and more concise
   --> $DIR/unwrap_used.rs:53:9
@@ -125,7 +133,8 @@ error: used `unwrap()` on an `Option` value
 LL |         *some_slice.get_mut(0).unwrap() = 1;
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
+   = note: if this value is `None`, it will panic
+   = help: consider using `expect()` to provide a better panic message
 
 error: called `.get_mut().unwrap()` on a Vec. Using `[]` is more clear and more concise
   --> $DIR/unwrap_used.rs:54:9
@@ -139,7 +148,8 @@ error: used `unwrap()` on an `Option` value
 LL |         *some_vec.get_mut(0).unwrap() = 1;
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
+   = note: if this value is `None`, it will panic
+   = help: consider using `expect()` to provide a better panic message
 
 error: called `.get_mut().unwrap()` on a VecDeque. Using `[]` is more clear and more concise
   --> $DIR/unwrap_used.rs:55:9
@@ -153,7 +163,8 @@ error: used `unwrap()` on an `Option` value
 LL |         *some_vecdeque.get_mut(0).unwrap() = 1;
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
+   = note: if this value is `None`, it will panic
+   = help: consider using `expect()` to provide a better panic message
 
 error: called `.get().unwrap()` on a Vec. Using `[]` is more clear and more concise
   --> $DIR/unwrap_used.rs:67:17
@@ -167,7 +178,8 @@ error: used `unwrap()` on an `Option` value
 LL |         let _ = some_vec.get(0..1).unwrap().to_vec();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
+   = note: if this value is `None`, it will panic
+   = help: consider using `expect()` to provide a better panic message
 
 error: called `.get_mut().unwrap()` on a Vec. Using `[]` is more clear and more concise
   --> $DIR/unwrap_used.rs:68:17
@@ -181,7 +193,8 @@ error: used `unwrap()` on an `Option` value
 LL |         let _ = some_vec.get_mut(0..1).unwrap().to_vec();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
+   = note: if this value is `None`, it will panic
+   = help: consider using `expect()` to provide a better panic message
 
 error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more concise
   --> $DIR/unwrap_used.rs:75:13
diff --git a/tests/ui/expect.stderr b/tests/ui/expect.stderr
index be340340d47..f787fa973a3 100644
--- a/tests/ui/expect.stderr
+++ b/tests/ui/expect.stderr
@@ -4,7 +4,7 @@ error: used `expect()` on an `Option` value
 LL |     let _ = opt.expect("");
    |             ^^^^^^^^^^^^^^
    |
-   = help: if this value is `None`, it will panic
+   = note: if this value is `None`, it will panic
    = note: `-D clippy::expect-used` implied by `-D warnings`
 
 error: used `expect()` on a `Result` value
@@ -13,7 +13,7 @@ error: used `expect()` on a `Result` value
 LL |     let _ = res.expect("");
    |             ^^^^^^^^^^^^^^
    |
-   = help: if this value is an `Err`, it will panic
+   = note: if this value is an `Err`, it will panic
 
 error: used `expect_err()` on a `Result` value
   --> $DIR/expect.rs:12:13
@@ -21,7 +21,7 @@ error: used `expect_err()` on a `Result` value
 LL |     let _ = res.expect_err("");
    |             ^^^^^^^^^^^^^^^^^^
    |
-   = help: if this value is an `Ok`, it will panic
+   = note: if this value is an `Ok`, it will panic
 
 error: aborting due to 3 previous errors
 
diff --git a/tests/ui/get_unwrap.stderr b/tests/ui/get_unwrap.stderr
index c567ed319b5..19dc9071fe7 100644
--- a/tests/ui/get_unwrap.stderr
+++ b/tests/ui/get_unwrap.stderr
@@ -16,7 +16,8 @@ error: used `unwrap()` on an `Option` value
 LL |         let _ = boxed_slice.get(1).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
+   = note: if this value is `None`, it will panic
+   = help: consider using `expect()` to provide a better panic message
    = note: `-D clippy::unwrap-used` implied by `-D warnings`
 
 error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more concise
@@ -31,7 +32,8 @@ error: used `unwrap()` on an `Option` value
 LL |         let _ = some_slice.get(0).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
+   = note: if this value is `None`, it will panic
+   = help: consider using `expect()` to provide a better panic message
 
 error: called `.get().unwrap()` on a Vec. Using `[]` is more clear and more concise
   --> $DIR/get_unwrap.rs:40:17
@@ -45,7 +47,8 @@ error: used `unwrap()` on an `Option` value
 LL |         let _ = some_vec.get(0).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
+   = note: if this value is `None`, it will panic
+   = help: consider using `expect()` to provide a better panic message
 
 error: called `.get().unwrap()` on a VecDeque. Using `[]` is more clear and more concise
   --> $DIR/get_unwrap.rs:41:17
@@ -59,7 +62,8 @@ error: used `unwrap()` on an `Option` value
 LL |         let _ = some_vecdeque.get(0).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
+   = note: if this value is `None`, it will panic
+   = help: consider using `expect()` to provide a better panic message
 
 error: called `.get().unwrap()` on a HashMap. Using `[]` is more clear and more concise
   --> $DIR/get_unwrap.rs:42:17
@@ -73,7 +77,8 @@ error: used `unwrap()` on an `Option` value
 LL |         let _ = some_hashmap.get(&1).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
+   = note: if this value is `None`, it will panic
+   = help: consider using `expect()` to provide a better panic message
 
 error: called `.get().unwrap()` on a BTreeMap. Using `[]` is more clear and more concise
   --> $DIR/get_unwrap.rs:43:17
@@ -87,7 +92,8 @@ error: used `unwrap()` on an `Option` value
 LL |         let _ = some_btreemap.get(&1).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
+   = note: if this value is `None`, it will panic
+   = help: consider using `expect()` to provide a better panic message
 
 error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more concise
   --> $DIR/get_unwrap.rs:47:21
@@ -101,7 +107,8 @@ error: used `unwrap()` on an `Option` value
 LL |         let _: u8 = *boxed_slice.get(1).unwrap();
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
+   = note: if this value is `None`, it will panic
+   = help: consider using `expect()` to provide a better panic message
 
 error: called `.get_mut().unwrap()` on a slice. Using `[]` is more clear and more concise
   --> $DIR/get_unwrap.rs:52:9
@@ -115,7 +122,8 @@ error: used `unwrap()` on an `Option` value
 LL |         *boxed_slice.get_mut(0).unwrap() = 1;
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
+   = note: if this value is `None`, it will panic
+   = help: consider using `expect()` to provide a better panic message
 
 error: called `.get_mut().unwrap()` on a slice. Using `[]` is more clear and more concise
   --> $DIR/get_unwrap.rs:53:9
@@ -129,7 +137,8 @@ error: used `unwrap()` on an `Option` value
 LL |         *some_slice.get_mut(0).unwrap() = 1;
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
+   = note: if this value is `None`, it will panic
+   = help: consider using `expect()` to provide a better panic message
 
 error: called `.get_mut().unwrap()` on a Vec. Using `[]` is more clear and more concise
   --> $DIR/get_unwrap.rs:54:9
@@ -143,7 +152,8 @@ error: used `unwrap()` on an `Option` value
 LL |         *some_vec.get_mut(0).unwrap() = 1;
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
+   = note: if this value is `None`, it will panic
+   = help: consider using `expect()` to provide a better panic message
 
 error: called `.get_mut().unwrap()` on a VecDeque. Using `[]` is more clear and more concise
   --> $DIR/get_unwrap.rs:55:9
@@ -157,7 +167,8 @@ error: used `unwrap()` on an `Option` value
 LL |         *some_vecdeque.get_mut(0).unwrap() = 1;
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
+   = note: if this value is `None`, it will panic
+   = help: consider using `expect()` to provide a better panic message
 
 error: called `.get().unwrap()` on a Vec. Using `[]` is more clear and more concise
   --> $DIR/get_unwrap.rs:67:17
@@ -171,7 +182,8 @@ error: used `unwrap()` on an `Option` value
 LL |         let _ = some_vec.get(0..1).unwrap().to_vec();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
+   = note: if this value is `None`, it will panic
+   = help: consider using `expect()` to provide a better panic message
 
 error: called `.get_mut().unwrap()` on a Vec. Using `[]` is more clear and more concise
   --> $DIR/get_unwrap.rs:68:17
@@ -185,7 +197,8 @@ error: used `unwrap()` on an `Option` value
 LL |         let _ = some_vec.get_mut(0..1).unwrap().to_vec();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
+   = note: if this value is `None`, it will panic
+   = help: consider using `expect()` to provide a better panic message
 
 error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more concise
   --> $DIR/get_unwrap.rs:78:24
diff --git a/tests/ui/unwrap.stderr b/tests/ui/unwrap.stderr
index 3796d942ff9..41db819f6fb 100644
--- a/tests/ui/unwrap.stderr
+++ b/tests/ui/unwrap.stderr
@@ -4,7 +4,8 @@ error: used `unwrap()` on an `Option` value
 LL |     let _ = opt.unwrap();
    |             ^^^^^^^^^^^^
    |
-   = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
+   = note: if this value is `None`, it will panic
+   = help: consider using `expect()` to provide a better panic message
    = note: `-D clippy::unwrap-used` implied by `-D warnings`
 
 error: used `unwrap()` on a `Result` value
@@ -13,7 +14,8 @@ error: used `unwrap()` on a `Result` value
 LL |     let _ = res.unwrap();
    |             ^^^^^^^^^^^^
    |
-   = help: if you don't want to handle the `Err` case gracefully, consider using `expect()` to provide a better panic message
+   = note: if this value is an `Err`, it will panic
+   = help: consider using `expect()` to provide a better panic message
 
 error: used `unwrap_err()` on a `Result` value
   --> $DIR/unwrap.rs:12:13
@@ -21,7 +23,8 @@ error: used `unwrap_err()` on a `Result` value
 LL |     let _ = res.unwrap_err();
    |             ^^^^^^^^^^^^^^^^
    |
-   = help: if you don't want to handle the `Ok` case gracefully, consider using `expect_err()` to provide a better panic message
+   = note: if this value is an `Ok`, it will panic
+   = help: consider using `expect_err()` to provide a better panic message
 
 error: aborting due to 3 previous errors
 
diff --git a/tests/ui/unwrap_expect_used.stderr b/tests/ui/unwrap_expect_used.stderr
index 8cbde8bf946..f66e47612ad 100644
--- a/tests/ui/unwrap_expect_used.stderr
+++ b/tests/ui/unwrap_expect_used.stderr
@@ -4,7 +4,7 @@ error: used `unwrap()` on an `Option` value
 LL |     Some(3).unwrap();
    |     ^^^^^^^^^^^^^^^^
    |
-   = help: if this value is `None`, it will panic
+   = note: if this value is `None`, it will panic
    = note: `-D clippy::unwrap-used` implied by `-D warnings`
 
 error: used `expect()` on an `Option` value
@@ -13,7 +13,7 @@ error: used `expect()` on an `Option` value
 LL |     Some(3).expect("Hello world!");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: if this value is `None`, it will panic
+   = note: if this value is `None`, it will panic
    = note: `-D clippy::expect-used` implied by `-D warnings`
 
 error: used `unwrap()` on a `Result` value
@@ -22,7 +22,7 @@ error: used `unwrap()` on a `Result` value
 LL |     a.unwrap();
    |     ^^^^^^^^^^
    |
-   = help: if this value is an `Err`, it will panic
+   = note: if this value is an `Err`, it will panic
 
 error: used `expect()` on a `Result` value
   --> $DIR/unwrap_expect_used.rs:44:5
@@ -30,7 +30,7 @@ error: used `expect()` on a `Result` value
 LL |     a.expect("Hello world!");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: if this value is an `Err`, it will panic
+   = note: if this value is an `Err`, it will panic
 
 error: used `unwrap_err()` on a `Result` value
   --> $DIR/unwrap_expect_used.rs:45:5
@@ -38,7 +38,7 @@ error: used `unwrap_err()` on a `Result` value
 LL |     a.unwrap_err();
    |     ^^^^^^^^^^^^^^
    |
-   = help: if this value is an `Ok`, it will panic
+   = note: if this value is an `Ok`, it will panic
 
 error: used `expect_err()` on a `Result` value
   --> $DIR/unwrap_expect_used.rs:46:5
@@ -46,7 +46,7 @@ error: used `expect_err()` on a `Result` value
 LL |     a.expect_err("Hello error!");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: if this value is an `Ok`, it will panic
+   = note: if this value is an `Ok`, it will panic
 
 error: aborting due to 6 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 4d49065a6cf1bd3d469919a961f35eac9e8d1e2a Mon Sep 17 00:00:00 2001
From: Catherine Flores <catherine.3.flores@gmail.com>
Date: Wed, 2 Aug 2023 14:13:16 -0500
Subject: Suppress `question_mark` if `question_mark_used` is not allowed

---
 clippy_lints/src/question_mark.rs | 12 +++++++++---
 tests/ui/question_mark.fixed      | 17 +++++++++++++++++
 tests/ui/question_mark.rs         | 17 +++++++++++++++++
 tests/ui/question_mark.stderr     |  6 +++---
 4 files changed, 46 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/question_mark.rs b/clippy_lints/src/question_mark.rs
index f5502cffb66..734ca2914f5 100644
--- a/clippy_lints/src/question_mark.rs
+++ b/clippy_lints/src/question_mark.rs
@@ -1,11 +1,13 @@
 use crate::manual_let_else::{MatchLintBehaviour, MANUAL_LET_ELSE};
+use crate::question_mark_used::QUESTION_MARK_USED;
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::msrvs::Msrv;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::{
-    eq_expr_value, get_parent_node, higher, in_constant, is_else_clause, is_path_lang_item, is_res_lang_ctor,
-    pat_and_expr_can_be_question_mark, path_to_local, path_to_local_id, peel_blocks, peel_blocks_with_stmt,
+    eq_expr_value, get_parent_node, higher, in_constant, is_else_clause, is_lint_allowed, is_path_lang_item,
+    is_res_lang_ctor, pat_and_expr_can_be_question_mark, path_to_local, path_to_local_id, peel_blocks,
+    peel_blocks_with_stmt,
 };
 use if_chain::if_chain;
 use rustc_errors::Applicability;
@@ -299,13 +301,17 @@ fn is_try_block(cx: &LateContext<'_>, bl: &rustc_hir::Block<'_>) -> bool {
 
 impl<'tcx> LateLintPass<'tcx> for QuestionMark {
     fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) {
+        if !is_lint_allowed(cx, QUESTION_MARK_USED, stmt.hir_id) {
+            return;
+        }
+
         if !in_constant(cx, stmt.hir_id) {
             check_let_some_else_return_none(cx, stmt);
         }
         self.check_manual_let_else(cx, stmt);
     }
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if !in_constant(cx, expr.hir_id) {
+        if !in_constant(cx, expr.hir_id) && is_lint_allowed(cx, QUESTION_MARK_USED, expr.hir_id) {
             self.check_is_none_or_err_and_early_return(cx, expr);
             self.check_if_let_some_or_err_and_early_return(cx, expr);
         }
diff --git a/tests/ui/question_mark.fixed b/tests/ui/question_mark.fixed
index 2d8920ccc42..20b9e42a7aa 100644
--- a/tests/ui/question_mark.fixed
+++ b/tests/ui/question_mark.fixed
@@ -138,6 +138,23 @@ fn result_func(x: Result<i32, i32>) -> Result<i32, i32> {
     // no warning
     let _ = if let Err(e) = x { Err(e) } else { Ok(0) };
 
+    // issue #11283
+    // no warning
+    #[warn(clippy::question_mark_used)]
+    {
+        if let Err(err) = Ok(()) {
+            return Err(err);
+        }
+
+        if Err::<i32, _>(0).is_err() {
+            return Err(0);
+        } else {
+            return Ok(0);
+        }
+
+        unreachable!()
+    }
+
     Ok(y)
 }
 
diff --git a/tests/ui/question_mark.rs b/tests/ui/question_mark.rs
index 69451c17ee7..8bdafd46e8f 100644
--- a/tests/ui/question_mark.rs
+++ b/tests/ui/question_mark.rs
@@ -170,6 +170,23 @@ fn result_func(x: Result<i32, i32>) -> Result<i32, i32> {
     // no warning
     let _ = if let Err(e) = x { Err(e) } else { Ok(0) };
 
+    // issue #11283
+    // no warning
+    #[warn(clippy::question_mark_used)]
+    {
+        if let Err(err) = Ok(()) {
+            return Err(err);
+        }
+
+        if Err::<i32, _>(0).is_err() {
+            return Err(0);
+        } else {
+            return Ok(0);
+        }
+
+        unreachable!()
+    }
+
     Ok(y)
 }
 
diff --git a/tests/ui/question_mark.stderr b/tests/ui/question_mark.stderr
index 2cfd7586308..62489c8c8c4 100644
--- a/tests/ui/question_mark.stderr
+++ b/tests/ui/question_mark.stderr
@@ -115,7 +115,7 @@ LL | |     }
    | |_____^ help: replace it with: `x?;`
 
 error: this block may be rewritten with the `?` operator
-  --> $DIR/question_mark.rs:197:5
+  --> $DIR/question_mark.rs:214:5
    |
 LL | /     if let Err(err) = func_returning_result() {
 LL | |         return Err(err);
@@ -123,7 +123,7 @@ LL | |     }
    | |_____^ help: replace it with: `func_returning_result()?;`
 
 error: this block may be rewritten with the `?` operator
-  --> $DIR/question_mark.rs:204:5
+  --> $DIR/question_mark.rs:221:5
    |
 LL | /     if let Err(err) = func_returning_result() {
 LL | |         return Err(err);
@@ -131,7 +131,7 @@ LL | |     }
    | |_____^ help: replace it with: `func_returning_result()?;`
 
 error: this block may be rewritten with the `?` operator
-  --> $DIR/question_mark.rs:281:13
+  --> $DIR/question_mark.rs:298:13
    |
 LL | /             if a.is_none() {
 LL | |                 return None;
-- 
cgit 1.4.1-3-g733a5


From fef85c90837eca1655cacd3168fd7c3501899503 Mon Sep 17 00:00:00 2001
From: Catherine Flores <catherine.3.flores@gmail.com>
Date: Wed, 2 Aug 2023 15:00:41 -0500
Subject: Take snippet instead of pretty printing type

---
 clippy_lints/src/casts/ptr_as_ptr.rs | 64 ++++++++++++++++++++----------------
 tests/ui/ptr_as_ptr.fixed            | 16 ++++++++-
 tests/ui/ptr_as_ptr.rs               | 16 ++++++++-
 tests/ui/ptr_as_ptr.stderr           | 28 +++++++++-------
 4 files changed, 82 insertions(+), 42 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/ptr_as_ptr.rs b/clippy_lints/src/casts/ptr_as_ptr.rs
index 15ffb00da88..181dbcf6e9a 100644
--- a/clippy_lints/src/casts/ptr_as_ptr.rs
+++ b/clippy_lints/src/casts/ptr_as_ptr.rs
@@ -1,9 +1,7 @@
-use std::borrow::Cow;
-
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::msrvs::{self, Msrv};
+use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::sugg::Sugg;
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, Mutability, TyKind};
 use rustc_lint::LateContext;
@@ -16,33 +14,41 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, msrv: &Msrv) {
         return;
     }
 
-    if_chain! {
-        if let ExprKind::Cast(cast_expr, cast_to_hir_ty) = expr.kind;
-        let (cast_from, cast_to) = (cx.typeck_results().expr_ty(cast_expr), cx.typeck_results().expr_ty(expr));
-        if let ty::RawPtr(TypeAndMut { mutbl: from_mutbl, .. }) = cast_from.kind();
-        if let ty::RawPtr(TypeAndMut { ty: to_pointee_ty, mutbl: to_mutbl }) = cast_to.kind();
-        if matches!((from_mutbl, to_mutbl),
-            (Mutability::Not, Mutability::Not) | (Mutability::Mut, Mutability::Mut));
+    if let ExprKind::Cast(cast_expr, cast_to_hir_ty) = expr.kind
+        && let (cast_from, cast_to) = (cx.typeck_results().expr_ty(cast_expr), cx.typeck_results().expr_ty(expr))
+        && let ty::RawPtr(TypeAndMut { mutbl: from_mutbl, .. }) = cast_from.kind()
+        && let ty::RawPtr(TypeAndMut { ty: to_pointee_ty, mutbl: to_mutbl }) = cast_to.kind()
+        && matches!((from_mutbl, to_mutbl),
+            (Mutability::Not, Mutability::Not) | (Mutability::Mut, Mutability::Mut))
         // The `U` in `pointer::cast` have to be `Sized`
         // as explained here: https://github.com/rust-lang/rust/issues/60602.
-        if to_pointee_ty.is_sized(cx.tcx, cx.param_env);
-        then {
-            let mut applicability = Applicability::MachineApplicable;
-            let cast_expr_sugg = Sugg::hir_with_applicability(cx, cast_expr, "_", &mut applicability);
-            let turbofish = match &cast_to_hir_ty.kind {
-                    TyKind::Infer => Cow::Borrowed(""),
-                    TyKind::Ptr(mut_ty) if matches!(mut_ty.ty.kind, TyKind::Infer) => Cow::Borrowed(""),
-                    _ => Cow::Owned(format!("::<{to_pointee_ty}>")),
-                };
-            span_lint_and_sugg(
-                cx,
-                PTR_AS_PTR,
-                expr.span,
-                "`as` casting between raw pointers without changing its mutability",
-                "try `pointer::cast`, a safer alternative",
-                format!("{}.cast{turbofish}()", cast_expr_sugg.maybe_par()),
-                applicability,
-            );
-        }
+        && to_pointee_ty.is_sized(cx.tcx, cx.param_env)
+    {
+        let mut app = Applicability::MachineApplicable;
+        let cast_expr_sugg = Sugg::hir_with_applicability(cx, cast_expr, "_", &mut app);
+        let turbofish = match &cast_to_hir_ty.kind {
+            TyKind::Infer => String::new(),
+            TyKind::Ptr(mut_ty) => {
+                if matches!(mut_ty.ty.kind, TyKind::Infer) {
+                    String::new()
+                } else {
+                    format!(
+                        "::<{}>",
+                        snippet_with_applicability(cx, mut_ty.ty.span, "/* type */", &mut app)
+                    )
+                }
+            },
+            _ => return,
+        };
+
+        span_lint_and_sugg(
+            cx,
+            PTR_AS_PTR,
+            expr.span,
+            "`as` casting between raw pointers without changing its mutability",
+            "try `pointer::cast`, a safer alternative",
+            format!("{}.cast{turbofish}()", cast_expr_sugg.maybe_par()),
+            app,
+        );
     }
 }
diff --git a/tests/ui/ptr_as_ptr.fixed b/tests/ui/ptr_as_ptr.fixed
index 26a64c861cf..84babb97416 100644
--- a/tests/ui/ptr_as_ptr.fixed
+++ b/tests/ui/ptr_as_ptr.fixed
@@ -3,8 +3,22 @@
 
 #![warn(clippy::ptr_as_ptr)]
 
+#[macro_use]
 extern crate proc_macros;
-use proc_macros::{external, inline_macros};
+
+mod issue_11278_a {
+    #[derive(Debug)]
+    pub struct T<D: std::fmt::Debug + ?Sized> {
+        pub p: D,
+    }
+}
+
+mod issue_11278_b {
+    pub fn f(o: &mut super::issue_11278_a::T<dyn std::fmt::Debug>) -> super::issue_11278_a::T<String> {
+        // Retain `super`
+        *unsafe { Box::from_raw(Box::into_raw(Box::new(o)).cast::<super::issue_11278_a::T<String>>()) }
+    }
+}
 
 #[inline_macros]
 fn main() {
diff --git a/tests/ui/ptr_as_ptr.rs b/tests/ui/ptr_as_ptr.rs
index ea40d494733..34fd76428b2 100644
--- a/tests/ui/ptr_as_ptr.rs
+++ b/tests/ui/ptr_as_ptr.rs
@@ -3,8 +3,22 @@
 
 #![warn(clippy::ptr_as_ptr)]
 
+#[macro_use]
 extern crate proc_macros;
-use proc_macros::{external, inline_macros};
+
+mod issue_11278_a {
+    #[derive(Debug)]
+    pub struct T<D: std::fmt::Debug + ?Sized> {
+        pub p: D,
+    }
+}
+
+mod issue_11278_b {
+    pub fn f(o: &mut super::issue_11278_a::T<dyn std::fmt::Debug>) -> super::issue_11278_a::T<String> {
+        // Retain `super`
+        *unsafe { Box::from_raw(Box::into_raw(Box::new(o)) as *mut super::issue_11278_a::T<String>) }
+    }
+}
 
 #[inline_macros]
 fn main() {
diff --git a/tests/ui/ptr_as_ptr.stderr b/tests/ui/ptr_as_ptr.stderr
index 78d733994ac..e64f3351505 100644
--- a/tests/ui/ptr_as_ptr.stderr
+++ b/tests/ui/ptr_as_ptr.stderr
@@ -1,37 +1,43 @@
 error: `as` casting between raw pointers without changing its mutability
-  --> $DIR/ptr_as_ptr.rs:14:13
+  --> $DIR/ptr_as_ptr.rs:19:33
    |
-LL |     let _ = ptr as *const i32;
-   |             ^^^^^^^^^^^^^^^^^ help: try `pointer::cast`, a safer alternative: `ptr.cast::<i32>()`
+LL |         *unsafe { Box::from_raw(Box::into_raw(Box::new(o)) as *mut super::issue_11278_a::T<String>) }
+   |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try `pointer::cast`, a safer alternative: `Box::into_raw(Box::new(o)).cast::<super::issue_11278_a::T<String>>()`
    |
    = note: `-D clippy::ptr-as-ptr` implied by `-D warnings`
 
 error: `as` casting between raw pointers without changing its mutability
-  --> $DIR/ptr_as_ptr.rs:15:13
+  --> $DIR/ptr_as_ptr.rs:28:13
+   |
+LL |     let _ = ptr as *const i32;
+   |             ^^^^^^^^^^^^^^^^^ help: try `pointer::cast`, a safer alternative: `ptr.cast::<i32>()`
+
+error: `as` casting between raw pointers without changing its mutability
+  --> $DIR/ptr_as_ptr.rs:29:13
    |
 LL |     let _ = mut_ptr as *mut i32;
    |             ^^^^^^^^^^^^^^^^^^^ help: try `pointer::cast`, a safer alternative: `mut_ptr.cast::<i32>()`
 
 error: `as` casting between raw pointers without changing its mutability
-  --> $DIR/ptr_as_ptr.rs:20:17
+  --> $DIR/ptr_as_ptr.rs:34:17
    |
 LL |         let _ = *ptr_ptr as *const i32;
    |                 ^^^^^^^^^^^^^^^^^^^^^^ help: try `pointer::cast`, a safer alternative: `(*ptr_ptr).cast::<i32>()`
 
 error: `as` casting between raw pointers without changing its mutability
-  --> $DIR/ptr_as_ptr.rs:33:25
+  --> $DIR/ptr_as_ptr.rs:47:25
    |
 LL |     let _: *const i32 = ptr as *const _;
    |                         ^^^^^^^^^^^^^^^ help: try `pointer::cast`, a safer alternative: `ptr.cast()`
 
 error: `as` casting between raw pointers without changing its mutability
-  --> $DIR/ptr_as_ptr.rs:34:23
+  --> $DIR/ptr_as_ptr.rs:48:23
    |
 LL |     let _: *mut i32 = mut_ptr as _;
    |                       ^^^^^^^^^^^^ help: try `pointer::cast`, a safer alternative: `mut_ptr.cast()`
 
 error: `as` casting between raw pointers without changing its mutability
-  --> $DIR/ptr_as_ptr.rs:37:21
+  --> $DIR/ptr_as_ptr.rs:51:21
    |
 LL |     let _ = inline!($ptr as *const i32);
    |                     ^^^^^^^^^^^^^^^^^^ help: try `pointer::cast`, a safer alternative: `$ptr.cast::<i32>()`
@@ -39,16 +45,16 @@ LL |     let _ = inline!($ptr as *const i32);
    = note: this error originates in the macro `__inline_mac_fn_main` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: `as` casting between raw pointers without changing its mutability
-  --> $DIR/ptr_as_ptr.rs:58:13
+  --> $DIR/ptr_as_ptr.rs:72:13
    |
 LL |     let _ = ptr as *const i32;
    |             ^^^^^^^^^^^^^^^^^ help: try `pointer::cast`, a safer alternative: `ptr.cast::<i32>()`
 
 error: `as` casting between raw pointers without changing its mutability
-  --> $DIR/ptr_as_ptr.rs:59:13
+  --> $DIR/ptr_as_ptr.rs:73:13
    |
 LL |     let _ = mut_ptr as *mut i32;
    |             ^^^^^^^^^^^^^^^^^^^ help: try `pointer::cast`, a safer alternative: `mut_ptr.cast::<i32>()`
 
-error: aborting due to 8 previous errors
+error: aborting due to 9 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 3fb84415cdfa671bc16680a31667ce70399f4079 Mon Sep 17 00:00:00 2001
From: blyxyas <blyxyas@gmail.com>
Date: Sat, 29 Jul 2023 20:37:21 +0200
Subject: Fix `suspicious_xor_used_as_pow.rs` performance

---
 clippy_lints/src/suspicious_xor_used_as_pow.rs | 48 ++++++++++++++------------
 tests/ui/suspicious_xor_used_as_pow.stderr     | 10 +++---
 2 files changed, 31 insertions(+), 27 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/suspicious_xor_used_as_pow.rs b/clippy_lints/src/suspicious_xor_used_as_pow.rs
index 6fa49afe0ec..8e156b8829b 100644
--- a/clippy_lints/src/suspicious_xor_used_as_pow.rs
+++ b/clippy_lints/src/suspicious_xor_used_as_pow.rs
@@ -1,5 +1,7 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::numeric_literal::NumericLiteral;
-use clippy_utils::source::snippet_with_context;
+use clippy_utils::source::snippet;
+use rustc_ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
@@ -28,27 +30,29 @@ declare_lint_pass!(ConfusingXorAndPow => [SUSPICIOUS_XOR_USED_AS_POW]);
 
 impl LateLintPass<'_> for ConfusingXorAndPow {
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
-        if !in_external_macro(cx.sess(), expr.span) &&
-        	let ExprKind::Binary(op, left, right) = &expr.kind &&
-            op.node == BinOpKind::BitXor &&
-            left.span.ctxt() == right.span.ctxt() &&
-            let ExprKind::Lit(lit_left) = &left.kind &&
-            let ExprKind::Lit(lit_right) = &right.kind &&
-            let snip_left = snippet_with_context(cx, lit_left.span, lit_left.span.ctxt(), "..", &mut Applicability::MaybeIncorrect) &&
-            let snip_right = snippet_with_context(cx, lit_right.span, lit_right.span.ctxt(), "..", &mut Applicability::MaybeIncorrect) &&
-            let Some(left_val) = NumericLiteral::from_lit_kind(&snip_left.0, &lit_left.node) &&
-            let Some(right_val) = NumericLiteral::from_lit_kind(&snip_right.0, &lit_right.node) &&
-			left_val.is_decimal() &&
-			right_val.is_decimal() {
-					clippy_utils::diagnostics::span_lint_and_sugg(
-					        cx,
-					        SUSPICIOUS_XOR_USED_AS_POW,
-					        expr.span,
-					        "`^` is not the exponentiation operator",
-					        "did you mean to write",
-					        format!("{}.pow({})", left_val.format(), right_val.format()),
-					        Applicability::MaybeIncorrect,
-					    );
+        if !in_external_macro(cx.sess(), expr.span)
+            && let ExprKind::Binary(op, left, right) = &expr.kind
+            && op.node == BinOpKind::BitXor
+            && left.span.ctxt() == right.span.ctxt()
+            && let ExprKind::Lit(lit_left) = &left.kind
+            && let ExprKind::Lit(lit_right) = &right.kind
+            && matches!(lit_right.node, LitKind::Int(..) | LitKind::Float(..))
+            && matches!(lit_left.node, LitKind::Int(..) | LitKind::Float(..))
+            && NumericLiteral::from_lit_kind(&snippet(cx, lit_right.span, ".."), &lit_right.node).is_some_and(|x| x.is_decimal())
+            {
+                span_lint_and_sugg(
+                    cx,
+                    SUSPICIOUS_XOR_USED_AS_POW,
+                    expr.span,
+                    "`^` is not the exponentiation operator",
+                    "did you mean to write",
+                    format!(
+                        "{}.pow({})",
+                        lit_left.node,
+                        lit_right.node
+                    ),
+                    Applicability::MaybeIncorrect,
+                );
 		}
     }
 }
diff --git a/tests/ui/suspicious_xor_used_as_pow.stderr b/tests/ui/suspicious_xor_used_as_pow.stderr
index 8bb3c8fbeeb..d93a55ba906 100644
--- a/tests/ui/suspicious_xor_used_as_pow.stderr
+++ b/tests/ui/suspicious_xor_used_as_pow.stderr
@@ -10,31 +10,31 @@ error: `^` is not the exponentiation operator
   --> $DIR/suspicious_xor_used_as_pow.rs:20:13
    |
 LL |     let _ = 2i32 ^ 9i32;
-   |             ^^^^^^^^^^^ help: did you mean to write: `2_i32.pow(9_i32)`
+   |             ^^^^^^^^^^^ help: did you mean to write: `2i32.pow(9i32)`
 
 error: `^` is not the exponentiation operator
   --> $DIR/suspicious_xor_used_as_pow.rs:21:13
    |
 LL |     let _ = 2i32 ^ 2i32;
-   |             ^^^^^^^^^^^ help: did you mean to write: `2_i32.pow(2_i32)`
+   |             ^^^^^^^^^^^ help: did you mean to write: `2i32.pow(2i32)`
 
 error: `^` is not the exponentiation operator
   --> $DIR/suspicious_xor_used_as_pow.rs:22:13
    |
 LL |     let _ = 50i32 ^ 3i32;
-   |             ^^^^^^^^^^^^ help: did you mean to write: `50_i32.pow(3_i32)`
+   |             ^^^^^^^^^^^^ help: did you mean to write: `50i32.pow(3i32)`
 
 error: `^` is not the exponentiation operator
   --> $DIR/suspicious_xor_used_as_pow.rs:23:13
    |
 LL |     let _ = 5i32 ^ 8i32;
-   |             ^^^^^^^^^^^ help: did you mean to write: `5_i32.pow(8_i32)`
+   |             ^^^^^^^^^^^ help: did you mean to write: `5i32.pow(8i32)`
 
 error: `^` is not the exponentiation operator
   --> $DIR/suspicious_xor_used_as_pow.rs:24:13
    |
 LL |     let _ = 2i32 ^ 32i32;
-   |             ^^^^^^^^^^^^ help: did you mean to write: `2_i32.pow(32_i32)`
+   |             ^^^^^^^^^^^^ help: did you mean to write: `2i32.pow(32i32)`
 
 error: `^` is not the exponentiation operator
   --> $DIR/suspicious_xor_used_as_pow.rs:13:9
-- 
cgit 1.4.1-3-g733a5


From e5b0483c852ed801b18fd1a43afa471f13937a47 Mon Sep 17 00:00:00 2001
From: lengyijun <sjtu5140809011@gmail.com>
Date: Sat, 5 Aug 2023 12:39:31 +0800
Subject: Small code style adjustments

---
 clippy_lints/src/methods/mod.rs | 18 ++++++------------
 1 file changed, 6 insertions(+), 12 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 17483656cec..42756b27d01 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -4020,10 +4020,8 @@ impl Methods {
                     }
                 },
                 ("last", []) => {
-                    if let Some((name2, recv2, args2, _span2, _)) = method_call(recv) {
-                        if let ("cloned", []) = (name2, args2) {
-                            iter_overeager_cloned::check(cx, expr, recv, recv2, false, false);
-                        }
+                    if let Some(("cloned", recv2, [], _span2, _)) = method_call(recv) {
+                        iter_overeager_cloned::check(cx, expr, recv, recv2, false, false);
                     }
                 },
                 ("lock", []) => {
@@ -4127,10 +4125,8 @@ impl Methods {
                 ("skip", [arg]) => {
                     iter_skip_zero::check(cx, expr, arg);
 
-                    if let Some((name2, recv2, args2, _span2, _)) = method_call(recv) {
-                        if let ("cloned", []) = (name2, args2) {
-                            iter_overeager_cloned::check(cx, expr, recv, recv2, false, false);
-                        }
+                    if let Some(("cloned", recv2, [], _span2, _)) = method_call(recv) {
+                        iter_overeager_cloned::check(cx, expr, recv, recv2, false, false);
                     }
                 }
                 ("sort", []) => {
@@ -4155,10 +4151,8 @@ impl Methods {
                 },
                 ("step_by", [arg]) => iterator_step_by_zero::check(cx, expr, arg),
                 ("take", [_arg]) => {
-                    if let Some((name2, recv2, args2, _span2, _)) = method_call(recv) {
-                        if let ("cloned", []) = (name2, args2) {
-                            iter_overeager_cloned::check(cx, expr, recv, recv2, false, false);
-                        }
+                    if let Some(("cloned", recv2, [], _span2, _)) = method_call(recv) {
+                        iter_overeager_cloned::check(cx, expr, recv, recv2, false, false);
                     }
                 },
                 ("take", []) => needless_option_take::check(cx, expr, recv),
-- 
cgit 1.4.1-3-g733a5


From 046d3df35eccafd73f84c47bb3b45a3cec33bcf4 Mon Sep 17 00:00:00 2001
From: Morten Lohne <lohnemorten@gmail.com>
Date: Mon, 29 May 2023 21:40:28 +0200
Subject: New lints: `impossible_double_const_comparisons` and
 `ineffective_double_const_comparisons`

---
 CHANGELOG.md                                       |   2 +
 clippy_lints/src/declared_lints.rs                 |   2 +
 .../src/operators/double_const_comparison.rs       | 204 +++++++++++++++++++++
 clippy_lints/src/operators/mod.rs                  |  41 +++++
 tests/ui/double_const_comparisons.rs               |  52 ++++++
 tests/ui/double_const_comparisons.stderr           | 180 ++++++++++++++++++
 tests/ui/range_contains.fixed                      |   2 +
 tests/ui/range_contains.rs                         |   2 +
 tests/ui/range_contains.stderr                     |  42 ++---
 9 files changed, 506 insertions(+), 21 deletions(-)
 create mode 100644 clippy_lints/src/operators/double_const_comparison.rs
 create mode 100644 tests/ui/double_const_comparisons.rs
 create mode 100644 tests/ui/double_const_comparisons.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 3ef22555979..3f9ec3a4df9 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4897,6 +4897,7 @@ Released 2018-09-13
 [`implicit_return`]: https://rust-lang.github.io/rust-clippy/master/index.html#implicit_return
 [`implicit_saturating_add`]: https://rust-lang.github.io/rust-clippy/master/index.html#implicit_saturating_add
 [`implicit_saturating_sub`]: https://rust-lang.github.io/rust-clippy/master/index.html#implicit_saturating_sub
+[`impossible_double_const_comparisons`]: https://rust-lang.github.io/rust-clippy/master/index.html#impossible_double_const_comparisons
 [`imprecise_flops`]: https://rust-lang.github.io/rust-clippy/master/index.html#imprecise_flops
 [`inconsistent_digit_grouping`]: https://rust-lang.github.io/rust-clippy/master/index.html#inconsistent_digit_grouping
 [`inconsistent_struct_constructor`]: https://rust-lang.github.io/rust-clippy/master/index.html#inconsistent_struct_constructor
@@ -4905,6 +4906,7 @@ Released 2018-09-13
 [`index_refutable_slice`]: https://rust-lang.github.io/rust-clippy/master/index.html#index_refutable_slice
 [`indexing_slicing`]: https://rust-lang.github.io/rust-clippy/master/index.html#indexing_slicing
 [`ineffective_bit_mask`]: https://rust-lang.github.io/rust-clippy/master/index.html#ineffective_bit_mask
+[`ineffective_double_const_comparisons`]: https://rust-lang.github.io/rust-clippy/master/index.html#ineffective_double_const_comparisons
 [`inefficient_to_string`]: https://rust-lang.github.io/rust-clippy/master/index.html#inefficient_to_string
 [`infallible_destructuring_match`]: https://rust-lang.github.io/rust-clippy/master/index.html#infallible_destructuring_match
 [`infinite_iter`]: https://rust-lang.github.io/rust-clippy/master/index.html#infinite_iter
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index ea66c760a2f..897e6c7bd10 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -518,7 +518,9 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::operators::FLOAT_CMP_CONST_INFO,
     crate::operators::FLOAT_EQUALITY_WITHOUT_ABS_INFO,
     crate::operators::IDENTITY_OP_INFO,
+    crate::operators::IMPOSSIBLE_DOUBLE_CONST_COMPARISONS_INFO,
     crate::operators::INEFFECTIVE_BIT_MASK_INFO,
+    crate::operators::INEFFECTIVE_DOUBLE_CONST_COMPARISONS_INFO,
     crate::operators::INTEGER_DIVISION_INFO,
     crate::operators::MISREFACTORED_ASSIGN_OP_INFO,
     crate::operators::MODULO_ARITHMETIC_INFO,
diff --git a/clippy_lints/src/operators/double_const_comparison.rs b/clippy_lints/src/operators/double_const_comparison.rs
new file mode 100644
index 00000000000..d029a3d4ebe
--- /dev/null
+++ b/clippy_lints/src/operators/double_const_comparison.rs
@@ -0,0 +1,204 @@
+#![allow(clippy::match_same_arms)]
+
+use std::cmp::Ordering;
+
+use clippy_utils::consts;
+use clippy_utils::consts::{ConstEvalLateContext, Constant};
+use if_chain::if_chain;
+use rustc_hir::{BinOpKind, Expr, ExprKind};
+use rustc_lint::LateContext;
+use rustc_middle::ty::{layout::HasTyCtxt, Ty, TypeckResults};
+use rustc_span::source_map::{Span, Spanned};
+
+use clippy_utils::diagnostics::span_lint_and_note;
+use clippy_utils::source::snippet;
+use clippy_utils::SpanlessEq;
+
+use super::IMPOSSIBLE_DOUBLE_CONST_COMPARISONS;
+use super::INEFFECTIVE_DOUBLE_CONST_COMPARISONS;
+
+// Extract a comparison between a const and non-const
+// Flip yoda conditionals, turnings expressions like `42 < x` into `x > 42`
+fn comparison_to_const<'tcx>(
+    ctx: &mut ConstEvalLateContext<'_, 'tcx>,
+    typeck: &TypeckResults<'tcx>,
+    expr: &'tcx Expr<'tcx>,
+) -> Option<(CmpOp, &'tcx Expr<'tcx>, &'tcx Expr<'tcx>, Constant, Ty<'tcx>)> {
+    if_chain! {
+        if let ExprKind::Binary(operator, left, right) = expr.kind;
+        if let Ok(cmp_op) = CmpOp::try_from(operator.node);
+        then {
+            match (ctx.expr(left), ctx.expr(right)) {
+                (Some(_), Some(_)) => None,
+                (_, Some(con)) => Some((cmp_op, left, right, con, typeck.expr_ty(right))),
+                (Some(con), _) => Some((cmp_op.reverse(), right, left, con, typeck.expr_ty(left))),
+                _ => None,
+            }
+        } else {
+            None
+        }
+    }
+}
+
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    and_op: Spanned<BinOpKind>,
+    left_cond: &'tcx Expr<'tcx>,
+    right_cond: &'tcx Expr<'tcx>,
+    span: Span,
+) {
+    if_chain! {
+        // Ensure that the binary operator is &&
+        if and_op.node == BinOpKind::And;
+
+        let typeck_results = cx.typeck_results();
+        let mut const_context = consts::ConstEvalLateContext::new(cx, typeck_results);
+
+        // Check that both operands to '&&' compare a non-literal to a literal
+        if let Some((left_cmp_op, left_expr, left_const_expr, left_const, left_type)) =
+            comparison_to_const(&mut const_context, typeck_results, left_cond);
+        if let Some((right_cmp_op, right_expr, right_const_expr, right_const, right_type)) =
+            comparison_to_const(&mut const_context, typeck_results, right_cond);
+
+        if left_type == right_type;
+
+        // Check that the same expression is compared in both comparisons
+        if SpanlessEq::new(cx).eq_expr(left_expr, right_expr);
+
+        if !left_expr.can_have_side_effects();
+
+        // Compare the two constant expressions
+        if let Some(ordering) = Constant::partial_cmp(cx.tcx(), left_type, &left_const, &right_const);
+
+        // Rule out the `x >= 42 && x <= 42` corner case immediately
+        // Mostly to simplify the implementation, but it is also covered by `clippy::double_comparisons`
+        if !matches!(
+            (&left_cmp_op, &right_cmp_op, ordering),
+            (CmpOp::Le | CmpOp::Ge, CmpOp::Le | CmpOp::Ge, Ordering::Equal)
+        );
+
+        then {
+            if left_cmp_op.direction() == right_cmp_op.direction() {
+                let lhs_str = snippet(cx, left_cond.span, "");
+                let rhs_str = snippet(cx, right_cond.span, "");
+                // We already know that either side of `&&` has no effect,
+                // but emit a different error message depending on which side it is
+                if left_side_is_useless(left_cmp_op, ordering) {
+                    span_lint_and_note(
+                        cx,
+                        INEFFECTIVE_DOUBLE_CONST_COMPARISONS,
+                        span,
+                        "left-hand side of `&&` operator has no effect",
+                        Some(left_cond.span.until(right_cond.span)),
+                        &format!("`if `{rhs_str}` evaluates to true, {lhs_str}` will always evaluate to true as well"),
+                    );
+                } else {
+                    span_lint_and_note(
+                        cx,
+                        INEFFECTIVE_DOUBLE_CONST_COMPARISONS,
+                        span,
+                        "right-hand side of `&&` operator has no effect",
+                        Some(and_op.span.to(right_cond.span)),
+                        &format!("`if `{lhs_str}` evaluates to true, {rhs_str}` will always evaluate to true as well"),
+                    );
+                }
+                // We could autofix this error but choose not to,
+                // because code triggering this lint probably not behaving correctly in the first place
+            }
+            else if !comparison_is_possible(left_cmp_op.direction(), ordering) {
+                let expr_str = snippet(cx, left_expr.span, "");
+                let lhs_str = snippet(cx, left_const_expr.span, "");
+                let rhs_str = snippet(cx, right_const_expr.span, "");
+                let note = match ordering {
+                    Ordering::Less => format!("since `{lhs_str}` < `{rhs_str}`, the expression evaluates to false for any value of `{expr_str}`"),
+                    Ordering::Equal => format!("`{expr_str}` cannot simultaneously be greater than and less than `{lhs_str}`"),
+                    Ordering::Greater => format!("since `{lhs_str}` > `{rhs_str}`, the expression evaluates to false for any value of `{expr_str}`"),
+                };
+                span_lint_and_note(
+                    cx,
+                    IMPOSSIBLE_DOUBLE_CONST_COMPARISONS,
+                    span,
+                    "boolean expression will never evaluate to 'true'",
+                    None,
+                    &note,
+                );
+            };
+        }
+    }
+}
+
+fn left_side_is_useless(left_cmp_op: CmpOp, ordering: Ordering) -> bool {
+    // Special-case for equal constants with an inclusive comparison
+    if ordering == Ordering::Equal {
+        match left_cmp_op {
+            CmpOp::Lt | CmpOp::Gt => false,
+            CmpOp::Le | CmpOp::Ge => true,
+        }
+    } else {
+        match (left_cmp_op.direction(), ordering) {
+            (CmpOpDirection::Lesser, Ordering::Less) => false,
+            (CmpOpDirection::Lesser, Ordering::Equal) => false,
+            (CmpOpDirection::Lesser, Ordering::Greater) => true,
+            (CmpOpDirection::Greater, Ordering::Less) => true,
+            (CmpOpDirection::Greater, Ordering::Equal) => false,
+            (CmpOpDirection::Greater, Ordering::Greater) => false,
+        }
+    }
+}
+
+fn comparison_is_possible(left_cmp_direction: CmpOpDirection, ordering: Ordering) -> bool {
+    match (left_cmp_direction, ordering) {
+        (CmpOpDirection::Lesser, Ordering::Less | Ordering::Equal) => false,
+        (CmpOpDirection::Lesser, Ordering::Greater) => true,
+        (CmpOpDirection::Greater, Ordering::Greater | Ordering::Equal) => false,
+        (CmpOpDirection::Greater, Ordering::Less) => true,
+    }
+}
+
+#[derive(PartialEq, Eq, Clone, Copy)]
+enum CmpOpDirection {
+    Lesser,
+    Greater,
+}
+
+#[derive(Clone, Copy)]
+enum CmpOp {
+    Lt,
+    Le,
+    Ge,
+    Gt,
+}
+
+impl CmpOp {
+    fn reverse(self) -> Self {
+        match self {
+            CmpOp::Lt => CmpOp::Gt,
+            CmpOp::Le => CmpOp::Ge,
+            CmpOp::Ge => CmpOp::Le,
+            CmpOp::Gt => CmpOp::Lt,
+        }
+    }
+
+    fn direction(self) -> CmpOpDirection {
+        match self {
+            CmpOp::Lt => CmpOpDirection::Lesser,
+            CmpOp::Le => CmpOpDirection::Lesser,
+            CmpOp::Ge => CmpOpDirection::Greater,
+            CmpOp::Gt => CmpOpDirection::Greater,
+        }
+    }
+}
+
+impl TryFrom<BinOpKind> for CmpOp {
+    type Error = ();
+
+    fn try_from(bin_op: BinOpKind) -> Result<Self, Self::Error> {
+        match bin_op {
+            BinOpKind::Lt => Ok(CmpOp::Lt),
+            BinOpKind::Le => Ok(CmpOp::Le),
+            BinOpKind::Ge => Ok(CmpOp::Ge),
+            BinOpKind::Gt => Ok(CmpOp::Gt),
+            _ => Err(()),
+        }
+    }
+}
diff --git a/clippy_lints/src/operators/mod.rs b/clippy_lints/src/operators/mod.rs
index 2cf15adda01..41efcef86c8 100644
--- a/clippy_lints/src/operators/mod.rs
+++ b/clippy_lints/src/operators/mod.rs
@@ -3,6 +3,7 @@ mod assign_op_pattern;
 mod bit_mask;
 mod cmp_owned;
 mod double_comparison;
+mod double_const_comparison;
 mod duration_subsec;
 mod eq_op;
 mod erasing_op;
@@ -298,6 +299,43 @@ declare_clippy_lint! {
     "unnecessary double comparisons that can be simplified"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for double comparisons that can never succeed
+    ///
+    /// ### Why is this bad?
+    /// The whole expression can be replaced by `false`,
+    /// which is probably not the programmer's intention
+    ///
+    /// ### Example
+    /// ```rust
+    /// status_code <= 400 && status_code > 500;
+    /// ```
+    #[clippy::version = "1.71.0"]
+    pub IMPOSSIBLE_DOUBLE_CONST_COMPARISONS,
+    correctness,
+    "default lint description"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for ineffective double comparisons against constants
+    ///
+    /// ### Why is this bad?
+    /// Only one of the comparisons has any effect on the result
+    /// The programmer probably intended to flip one of the comparison operators,
+    /// or compare a different value entirely
+    ///
+    /// ### Example
+    /// ```rust
+    /// status_code <= 400 && status_code < 500;
+    /// ```
+    #[clippy::version = "1.71.0"]
+    pub INEFFECTIVE_DOUBLE_CONST_COMPARISONS,
+    correctness,
+    "default lint description"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for calculation of subsecond microseconds or milliseconds
@@ -742,6 +780,8 @@ impl_lint_pass!(Operators => [
     INEFFECTIVE_BIT_MASK,
     VERBOSE_BIT_MASK,
     DOUBLE_COMPARISONS,
+    IMPOSSIBLE_DOUBLE_CONST_COMPARISONS,
+    INEFFECTIVE_DOUBLE_CONST_COMPARISONS,
     DURATION_SUBSEC,
     EQ_OP,
     OP_REF,
@@ -786,6 +826,7 @@ impl<'tcx> LateLintPass<'tcx> for Operators {
                 bit_mask::check(cx, e, op.node, lhs, rhs);
                 verbose_bit_mask::check(cx, e, op.node, lhs, rhs, self.verbose_bit_mask_threshold);
                 double_comparison::check(cx, op.node, lhs, rhs, e.span);
+                double_const_comparison::check(cx, op, lhs, rhs, e.span);
                 duration_subsec::check(cx, e, op.node, lhs, rhs);
                 float_equality_without_abs::check(cx, e, op.node, lhs, rhs);
                 integer_division::check(cx, e, op.node, lhs, rhs);
diff --git a/tests/ui/double_const_comparisons.rs b/tests/ui/double_const_comparisons.rs
new file mode 100644
index 00000000000..0f57fbba1eb
--- /dev/null
+++ b/tests/ui/double_const_comparisons.rs
@@ -0,0 +1,52 @@
+#![allow(unused)]
+#![warn(clippy::impossible_double_const_comparisons)]
+#![warn(clippy::ineffective_double_const_comparisons)]
+#![allow(clippy::no_effect)]
+#![allow(clippy::short_circuit_statement)]
+#![allow(clippy::manual_range_contains)]
+
+const STATUS_BAD_REQUEST: u16 = 400;
+const STATUS_SERVER_ERROR: u16 = 500;
+
+fn main() {
+    let status_code = 500; // Value doesn't matter for the lint
+
+    status_code >= 400 && status_code < 500; // Correct
+    status_code <= 400 && status_code > 500;
+    status_code > 500 && status_code < 400;
+    status_code < 500 && status_code > 500;
+
+    // More complex expressions
+    status_code < { 400 } && status_code > { 500 };
+    status_code < STATUS_BAD_REQUEST && status_code > STATUS_SERVER_ERROR;
+    status_code <= u16::MIN + 1 && status_code > STATUS_SERVER_ERROR;
+    status_code < STATUS_SERVER_ERROR && status_code > STATUS_SERVER_ERROR;
+
+    // Yoda conditions
+    500 <= status_code && 600 > status_code; // Correct
+    500 <= status_code && status_code <= 600; // Correct
+    500 >= status_code && 600 < status_code; // Incorrect
+    500 >= status_code && status_code > 600; // Incorrect
+
+    // Expressions where one of the sides has no effect
+    status_code < 200 && status_code <= 299;
+    status_code > 200 && status_code >= 299;
+
+    status_code >= 500 && status_code > 500; // Useless left
+    status_code > 500 && status_code >= 500; // Useless right
+    status_code <= 500 && status_code < 500; // Useless left
+    status_code < 500 && status_code <= 500; // Useless right
+
+    // Other types
+    let name = "Steve";
+    name < "Jennifer" && name > "Shannon";
+
+    let numbers = [1, 2];
+    numbers < [3, 4] && numbers > [5, 6];
+
+    let letter = 'a';
+    letter < 'b' && letter > 'c';
+
+    let area = 42.0;
+    area < std::f32::consts::E && area > std::f32::consts::PI;
+}
diff --git a/tests/ui/double_const_comparisons.stderr b/tests/ui/double_const_comparisons.stderr
new file mode 100644
index 00000000000..76cfc82c0a4
--- /dev/null
+++ b/tests/ui/double_const_comparisons.stderr
@@ -0,0 +1,180 @@
+error: boolean expression will never evaluate to 'true'
+  --> $DIR/double_const_comparisons.rs:15:5
+   |
+LL |     status_code <= 400 && status_code > 500;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: since `400` < `500`, the expression evaluates to false for any value of `status_code`
+   = note: `-D clippy::impossible-double-const-comparisons` implied by `-D warnings`
+
+error: boolean expression will never evaluate to 'true'
+  --> $DIR/double_const_comparisons.rs:16:5
+   |
+LL |     status_code > 500 && status_code < 400;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: since `500` > `400`, the expression evaluates to false for any value of `status_code`
+
+error: boolean expression will never evaluate to 'true'
+  --> $DIR/double_const_comparisons.rs:17:5
+   |
+LL |     status_code < 500 && status_code > 500;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `status_code` cannot simultaneously be greater than and less than `500`
+
+error: boolean expression will never evaluate to 'true'
+  --> $DIR/double_const_comparisons.rs:20:5
+   |
+LL |     status_code < { 400 } && status_code > { 500 };
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: since `{ 400 }` < `{ 500 }`, the expression evaluates to false for any value of `status_code`
+
+error: boolean expression will never evaluate to 'true'
+  --> $DIR/double_const_comparisons.rs:21:5
+   |
+LL |     status_code < STATUS_BAD_REQUEST && status_code > STATUS_SERVER_ERROR;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: since `STATUS_BAD_REQUEST` < `STATUS_SERVER_ERROR`, the expression evaluates to false for any value of `status_code`
+
+error: boolean expression will never evaluate to 'true'
+  --> $DIR/double_const_comparisons.rs:22:5
+   |
+LL |     status_code <= u16::MIN + 1 && status_code > STATUS_SERVER_ERROR;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: since `u16::MIN + 1` < `STATUS_SERVER_ERROR`, the expression evaluates to false for any value of `status_code`
+
+error: boolean expression will never evaluate to 'true'
+  --> $DIR/double_const_comparisons.rs:23:5
+   |
+LL |     status_code < STATUS_SERVER_ERROR && status_code > STATUS_SERVER_ERROR;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `status_code` cannot simultaneously be greater than and less than `STATUS_SERVER_ERROR`
+
+error: boolean expression will never evaluate to 'true'
+  --> $DIR/double_const_comparisons.rs:28:5
+   |
+LL |     500 >= status_code && 600 < status_code; // Incorrect
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: since `500` < `600`, the expression evaluates to false for any value of `status_code`
+
+error: boolean expression will never evaluate to 'true'
+  --> $DIR/double_const_comparisons.rs:29:5
+   |
+LL |     500 >= status_code && status_code > 600; // Incorrect
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: since `500` < `600`, the expression evaluates to false for any value of `status_code`
+
+error: right-hand side of `&&` operator has no effect
+  --> $DIR/double_const_comparisons.rs:32:5
+   |
+LL |     status_code < 200 && status_code <= 299;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: `if `status_code < 200` evaluates to true, status_code <= 299` will always evaluate to true as well
+  --> $DIR/double_const_comparisons.rs:32:23
+   |
+LL |     status_code < 200 && status_code <= 299;
+   |                       ^^^^^^^^^^^^^^^^^^^^^
+   = note: `-D clippy::ineffective-double-const-comparisons` implied by `-D warnings`
+
+error: left-hand side of `&&` operator has no effect
+  --> $DIR/double_const_comparisons.rs:33:5
+   |
+LL |     status_code > 200 && status_code >= 299;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: `if `status_code >= 299` evaluates to true, status_code > 200` will always evaluate to true as well
+  --> $DIR/double_const_comparisons.rs:33:5
+   |
+LL |     status_code > 200 && status_code >= 299;
+   |     ^^^^^^^^^^^^^^^^^^^^^
+
+error: left-hand side of `&&` operator has no effect
+  --> $DIR/double_const_comparisons.rs:35:5
+   |
+LL |     status_code >= 500 && status_code > 500; // Useless left
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: `if `status_code > 500` evaluates to true, status_code >= 500` will always evaluate to true as well
+  --> $DIR/double_const_comparisons.rs:35:5
+   |
+LL |     status_code >= 500 && status_code > 500; // Useless left
+   |     ^^^^^^^^^^^^^^^^^^^^^^
+
+error: right-hand side of `&&` operator has no effect
+  --> $DIR/double_const_comparisons.rs:36:5
+   |
+LL |     status_code > 500 && status_code >= 500; // Useless right
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: `if `status_code > 500` evaluates to true, status_code >= 500` will always evaluate to true as well
+  --> $DIR/double_const_comparisons.rs:36:23
+   |
+LL |     status_code > 500 && status_code >= 500; // Useless right
+   |                       ^^^^^^^^^^^^^^^^^^^^^
+
+error: left-hand side of `&&` operator has no effect
+  --> $DIR/double_const_comparisons.rs:37:5
+   |
+LL |     status_code <= 500 && status_code < 500; // Useless left
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: `if `status_code < 500` evaluates to true, status_code <= 500` will always evaluate to true as well
+  --> $DIR/double_const_comparisons.rs:37:5
+   |
+LL |     status_code <= 500 && status_code < 500; // Useless left
+   |     ^^^^^^^^^^^^^^^^^^^^^^
+
+error: right-hand side of `&&` operator has no effect
+  --> $DIR/double_const_comparisons.rs:38:5
+   |
+LL |     status_code < 500 && status_code <= 500; // Useless right
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: `if `status_code < 500` evaluates to true, status_code <= 500` will always evaluate to true as well
+  --> $DIR/double_const_comparisons.rs:38:23
+   |
+LL |     status_code < 500 && status_code <= 500; // Useless right
+   |                       ^^^^^^^^^^^^^^^^^^^^^
+
+error: boolean expression will never evaluate to 'true'
+  --> $DIR/double_const_comparisons.rs:42:5
+   |
+LL |     name < "Jennifer" && name > "Shannon";
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: since `"Jennifer"` < `"Shannon"`, the expression evaluates to false for any value of `name`
+
+error: boolean expression will never evaluate to 'true'
+  --> $DIR/double_const_comparisons.rs:45:5
+   |
+LL |     numbers < [3, 4] && numbers > [5, 6];
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: since `[3, 4]` < `[5, 6]`, the expression evaluates to false for any value of `numbers`
+
+error: boolean expression will never evaluate to 'true'
+  --> $DIR/double_const_comparisons.rs:48:5
+   |
+LL |     letter < 'b' && letter > 'c';
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: since `'b'` < `'c'`, the expression evaluates to false for any value of `letter`
+
+error: boolean expression will never evaluate to 'true'
+  --> $DIR/double_const_comparisons.rs:51:5
+   |
+LL |     area < std::f32::consts::E && area > std::f32::consts::PI;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: since `std::f32::consts::E` < `std::f32::consts::PI`, the expression evaluates to false for any value of `area`
+
+error: aborting due to 19 previous errors
+
diff --git a/tests/ui/range_contains.fixed b/tests/ui/range_contains.fixed
index 0a92ee7c8dd..429d8608291 100644
--- a/tests/ui/range_contains.fixed
+++ b/tests/ui/range_contains.fixed
@@ -5,6 +5,8 @@
 #![allow(clippy::no_effect)]
 #![allow(clippy::short_circuit_statement)]
 #![allow(clippy::unnecessary_operation)]
+#![allow(clippy::impossible_double_const_comparisons)]
+#![allow(clippy::ineffective_double_const_comparisons)]
 
 fn main() {
     let x = 9_i32;
diff --git a/tests/ui/range_contains.rs b/tests/ui/range_contains.rs
index 7a83be60957..e47e2948147 100644
--- a/tests/ui/range_contains.rs
+++ b/tests/ui/range_contains.rs
@@ -5,6 +5,8 @@
 #![allow(clippy::no_effect)]
 #![allow(clippy::short_circuit_statement)]
 #![allow(clippy::unnecessary_operation)]
+#![allow(clippy::impossible_double_const_comparisons)]
+#![allow(clippy::ineffective_double_const_comparisons)]
 
 fn main() {
     let x = 9_i32;
diff --git a/tests/ui/range_contains.stderr b/tests/ui/range_contains.stderr
index ea34023a466..1265db695bf 100644
--- a/tests/ui/range_contains.stderr
+++ b/tests/ui/range_contains.stderr
@@ -1,5 +1,5 @@
 error: manual `Range::contains` implementation
-  --> $DIR/range_contains.rs:13:5
+  --> $DIR/range_contains.rs:15:5
    |
 LL |     x >= 8 && x < 12;
    |     ^^^^^^^^^^^^^^^^ help: use: `(8..12).contains(&x)`
@@ -7,121 +7,121 @@ LL |     x >= 8 && x < 12;
    = note: `-D clippy::manual-range-contains` implied by `-D warnings`
 
 error: manual `Range::contains` implementation
-  --> $DIR/range_contains.rs:14:5
+  --> $DIR/range_contains.rs:16:5
    |
 LL |     x < 42 && x >= 21;
    |     ^^^^^^^^^^^^^^^^^ help: use: `(21..42).contains(&x)`
 
 error: manual `Range::contains` implementation
-  --> $DIR/range_contains.rs:15:5
+  --> $DIR/range_contains.rs:17:5
    |
 LL |     100 > x && 1 <= x;
    |     ^^^^^^^^^^^^^^^^^ help: use: `(1..100).contains(&x)`
 
 error: manual `RangeInclusive::contains` implementation
-  --> $DIR/range_contains.rs:18:5
+  --> $DIR/range_contains.rs:20:5
    |
 LL |     x >= 9 && x <= 99;
    |     ^^^^^^^^^^^^^^^^^ help: use: `(9..=99).contains(&x)`
 
 error: manual `RangeInclusive::contains` implementation
-  --> $DIR/range_contains.rs:19:5
+  --> $DIR/range_contains.rs:21:5
    |
 LL |     x <= 33 && x >= 1;
    |     ^^^^^^^^^^^^^^^^^ help: use: `(1..=33).contains(&x)`
 
 error: manual `RangeInclusive::contains` implementation
-  --> $DIR/range_contains.rs:20:5
+  --> $DIR/range_contains.rs:22:5
    |
 LL |     999 >= x && 1 <= x;
    |     ^^^^^^^^^^^^^^^^^^ help: use: `(1..=999).contains(&x)`
 
 error: manual `!Range::contains` implementation
-  --> $DIR/range_contains.rs:23:5
+  --> $DIR/range_contains.rs:25:5
    |
 LL |     x < 8 || x >= 12;
    |     ^^^^^^^^^^^^^^^^ help: use: `!(8..12).contains(&x)`
 
 error: manual `!Range::contains` implementation
-  --> $DIR/range_contains.rs:24:5
+  --> $DIR/range_contains.rs:26:5
    |
 LL |     x >= 42 || x < 21;
    |     ^^^^^^^^^^^^^^^^^ help: use: `!(21..42).contains(&x)`
 
 error: manual `!Range::contains` implementation
-  --> $DIR/range_contains.rs:25:5
+  --> $DIR/range_contains.rs:27:5
    |
 LL |     100 <= x || 1 > x;
    |     ^^^^^^^^^^^^^^^^^ help: use: `!(1..100).contains(&x)`
 
 error: manual `!RangeInclusive::contains` implementation
-  --> $DIR/range_contains.rs:28:5
+  --> $DIR/range_contains.rs:30:5
    |
 LL |     x < 9 || x > 99;
    |     ^^^^^^^^^^^^^^^ help: use: `!(9..=99).contains(&x)`
 
 error: manual `!RangeInclusive::contains` implementation
-  --> $DIR/range_contains.rs:29:5
+  --> $DIR/range_contains.rs:31:5
    |
 LL |     x > 33 || x < 1;
    |     ^^^^^^^^^^^^^^^ help: use: `!(1..=33).contains(&x)`
 
 error: manual `!RangeInclusive::contains` implementation
-  --> $DIR/range_contains.rs:30:5
+  --> $DIR/range_contains.rs:32:5
    |
 LL |     999 < x || 1 > x;
    |     ^^^^^^^^^^^^^^^^ help: use: `!(1..=999).contains(&x)`
 
 error: manual `Range::contains` implementation
-  --> $DIR/range_contains.rs:45:5
+  --> $DIR/range_contains.rs:47:5
    |
 LL |     y >= 0. && y < 1.;
    |     ^^^^^^^^^^^^^^^^^ help: use: `(0. ..1.).contains(&y)`
 
 error: manual `!RangeInclusive::contains` implementation
-  --> $DIR/range_contains.rs:46:5
+  --> $DIR/range_contains.rs:48:5
    |
 LL |     y < 0. || y > 1.;
    |     ^^^^^^^^^^^^^^^^ help: use: `!(0. ..=1.).contains(&y)`
 
 error: manual `RangeInclusive::contains` implementation
-  --> $DIR/range_contains.rs:49:5
+  --> $DIR/range_contains.rs:51:5
    |
 LL |     x >= -10 && x <= 10;
    |     ^^^^^^^^^^^^^^^^^^^ help: use: `(-10..=10).contains(&x)`
 
 error: manual `RangeInclusive::contains` implementation
-  --> $DIR/range_contains.rs:51:5
+  --> $DIR/range_contains.rs:53:5
    |
 LL |     y >= -3. && y <= 3.;
    |     ^^^^^^^^^^^^^^^^^^^ help: use: `(-3. ..=3.).contains(&y)`
 
 error: manual `RangeInclusive::contains` implementation
-  --> $DIR/range_contains.rs:56:30
+  --> $DIR/range_contains.rs:58:30
    |
 LL |     (x >= 0) && (x <= 10) && (z >= 0) && (z <= 10);
    |                              ^^^^^^^^^^^^^^^^^^^^^ help: use: `(0..=10).contains(&z)`
 
 error: manual `RangeInclusive::contains` implementation
-  --> $DIR/range_contains.rs:56:5
+  --> $DIR/range_contains.rs:58:5
    |
 LL |     (x >= 0) && (x <= 10) && (z >= 0) && (z <= 10);
    |     ^^^^^^^^^^^^^^^^^^^^^ help: use: `(0..=10).contains(&x)`
 
 error: manual `!Range::contains` implementation
-  --> $DIR/range_contains.rs:57:29
+  --> $DIR/range_contains.rs:59:29
    |
 LL |     (x < 0) || (x >= 10) || (z < 0) || (z >= 10);
    |                             ^^^^^^^^^^^^^^^^^^^^ help: use: `!(0..10).contains(&z)`
 
 error: manual `!Range::contains` implementation
-  --> $DIR/range_contains.rs:57:5
+  --> $DIR/range_contains.rs:59:5
    |
 LL |     (x < 0) || (x >= 10) || (z < 0) || (z >= 10);
    |     ^^^^^^^^^^^^^^^^^^^^ help: use: `!(0..10).contains(&x)`
 
 error: manual `Range::contains` implementation
-  --> $DIR/range_contains.rs:76:5
+  --> $DIR/range_contains.rs:78:5
    |
 LL |     x >= 8 && x < 35;
    |     ^^^^^^^^^^^^^^^^ help: use: `(8..35).contains(&x)`
-- 
cgit 1.4.1-3-g733a5


From e16a2ac0c65c233ab52f61cdb38ad76ea53b11f4 Mon Sep 17 00:00:00 2001
From: Morten Lohne <lohnemorten@gmail.com>
Date: Mon, 29 May 2023 23:49:54 +0200
Subject: Add descriptions for 'impossible_double_const_comparisons' and
 'ineffective_double_const_comparisons'

---
 clippy_lints/src/operators/mod.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/operators/mod.rs b/clippy_lints/src/operators/mod.rs
index 41efcef86c8..25e1fce1980 100644
--- a/clippy_lints/src/operators/mod.rs
+++ b/clippy_lints/src/operators/mod.rs
@@ -314,7 +314,7 @@ declare_clippy_lint! {
     #[clippy::version = "1.71.0"]
     pub IMPOSSIBLE_DOUBLE_CONST_COMPARISONS,
     correctness,
-    "default lint description"
+    "double comparisons that will never evaluate to `true`"
 }
 
 declare_clippy_lint! {
@@ -333,7 +333,7 @@ declare_clippy_lint! {
     #[clippy::version = "1.71.0"]
     pub INEFFECTIVE_DOUBLE_CONST_COMPARISONS,
     correctness,
-    "default lint description"
+    "double comparisons where one of them can be removed"
 }
 
 declare_clippy_lint! {
-- 
cgit 1.4.1-3-g733a5


From 08e1333fa6467290b9951fc28f0616db3b13c51d Mon Sep 17 00:00:00 2001
From: Morten Lohne <lohnemorten@gmail.com>
Date: Thu, 1 Jun 2023 23:50:33 +0200
Subject: Add missing variable decl to doc comment

---
 clippy_lints/src/operators/mod.rs | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/operators/mod.rs b/clippy_lints/src/operators/mod.rs
index 25e1fce1980..ef76812d9dd 100644
--- a/clippy_lints/src/operators/mod.rs
+++ b/clippy_lints/src/operators/mod.rs
@@ -309,7 +309,8 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust
-    /// status_code <= 400 && status_code > 500;
+    /// # let status_code = 200;
+    /// if status_code <= 400 && status_code > 500 {}
     /// ```
     #[clippy::version = "1.71.0"]
     pub IMPOSSIBLE_DOUBLE_CONST_COMPARISONS,
@@ -328,7 +329,8 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust
-    /// status_code <= 400 && status_code < 500;
+    /// # let status_code = 200;
+    /// if status_code <= 400 && status_code < 500 {}
     /// ```
     #[clippy::version = "1.71.0"]
     pub INEFFECTIVE_DOUBLE_CONST_COMPARISONS,
-- 
cgit 1.4.1-3-g733a5


From b5ef66f442229ada09a83454b47a9671c2d098c9 Mon Sep 17 00:00:00 2001
From: Morten Lohne <lohnemorten@gmail.com>
Date: Sat, 10 Jun 2023 14:29:24 +0200
Subject: Optimize by doing a cheap check for double binary expression first

---
 clippy_lints/src/operators/double_const_comparison.rs | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/operators/double_const_comparison.rs b/clippy_lints/src/operators/double_const_comparison.rs
index d029a3d4ebe..80db455d2e6 100644
--- a/clippy_lints/src/operators/double_const_comparison.rs
+++ b/clippy_lints/src/operators/double_const_comparison.rs
@@ -51,14 +51,19 @@ pub(super) fn check<'tcx>(
         // Ensure that the binary operator is &&
         if and_op.node == BinOpKind::And;
 
-        let typeck_results = cx.typeck_results();
-        let mut const_context = consts::ConstEvalLateContext::new(cx, typeck_results);
+        // Check that both operands to '&&' are themselves a binary operation
+        // The `comparison_to_const` step also checks this, so this step is just an optimization
+        if let ExprKind::Binary(_, _, _) = left_cond.kind;
+        if let ExprKind::Binary(_, _, _) = right_cond.kind;
+
+        let typeck = cx.typeck_results();
+        let mut const_context = consts::ConstEvalLateContext::new(cx, typeck);
 
         // Check that both operands to '&&' compare a non-literal to a literal
         if let Some((left_cmp_op, left_expr, left_const_expr, left_const, left_type)) =
-            comparison_to_const(&mut const_context, typeck_results, left_cond);
+            comparison_to_const(&mut const_context, typeck, left_cond);
         if let Some((right_cmp_op, right_expr, right_const_expr, right_const, right_type)) =
-            comparison_to_const(&mut const_context, typeck_results, right_cond);
+            comparison_to_const(&mut const_context, typeck, right_cond);
 
         if left_type == right_type;
 
-- 
cgit 1.4.1-3-g733a5


From 1d61fc1b0a02bb8f4a597279f03e897de0e521d1 Mon Sep 17 00:00:00 2001
From: Morten Lohne <lohnemorten@gmail.com>
Date: Sat, 10 Jun 2023 15:58:46 +0200
Subject: Rename 'impossible_double_const_comparisons' ->
 'impossible_comparisons' and 'ineffective_double_const_comparisons' ->
 'redundant_comparisons', after discussion on Zulip

---
 CHANGELOG.md                                       |   4 +-
 clippy_lints/src/declared_lints.rs                 |   4 +-
 clippy_lints/src/operators/const_comparisons.rs    | 209 +++++++++++++++++++
 .../src/operators/double_const_comparison.rs       | 209 -------------------
 clippy_lints/src/operators/mod.rs                  |  12 +-
 tests/ui/const_comparisons.rs                      |  93 +++++++++
 tests/ui/const_comparisons.stderr                  | 228 +++++++++++++++++++++
 tests/ui/double_const_comparisons.rs               |  93 ---------
 tests/ui/double_const_comparisons.stderr           | 228 ---------------------
 tests/ui/range_contains.fixed                      |   4 +-
 tests/ui/range_contains.rs                         |   4 +-
 11 files changed, 544 insertions(+), 544 deletions(-)
 create mode 100644 clippy_lints/src/operators/const_comparisons.rs
 delete mode 100644 clippy_lints/src/operators/double_const_comparison.rs
 create mode 100644 tests/ui/const_comparisons.rs
 create mode 100644 tests/ui/const_comparisons.stderr
 delete mode 100644 tests/ui/double_const_comparisons.rs
 delete mode 100644 tests/ui/double_const_comparisons.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 3f9ec3a4df9..71671273c57 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4897,7 +4897,7 @@ Released 2018-09-13
 [`implicit_return`]: https://rust-lang.github.io/rust-clippy/master/index.html#implicit_return
 [`implicit_saturating_add`]: https://rust-lang.github.io/rust-clippy/master/index.html#implicit_saturating_add
 [`implicit_saturating_sub`]: https://rust-lang.github.io/rust-clippy/master/index.html#implicit_saturating_sub
-[`impossible_double_const_comparisons`]: https://rust-lang.github.io/rust-clippy/master/index.html#impossible_double_const_comparisons
+[`impossible_comparisons`]: https://rust-lang.github.io/rust-clippy/master/index.html#impossible_comparisons
 [`imprecise_flops`]: https://rust-lang.github.io/rust-clippy/master/index.html#imprecise_flops
 [`inconsistent_digit_grouping`]: https://rust-lang.github.io/rust-clippy/master/index.html#inconsistent_digit_grouping
 [`inconsistent_struct_constructor`]: https://rust-lang.github.io/rust-clippy/master/index.html#inconsistent_struct_constructor
@@ -4906,7 +4906,6 @@ Released 2018-09-13
 [`index_refutable_slice`]: https://rust-lang.github.io/rust-clippy/master/index.html#index_refutable_slice
 [`indexing_slicing`]: https://rust-lang.github.io/rust-clippy/master/index.html#indexing_slicing
 [`ineffective_bit_mask`]: https://rust-lang.github.io/rust-clippy/master/index.html#ineffective_bit_mask
-[`ineffective_double_const_comparisons`]: https://rust-lang.github.io/rust-clippy/master/index.html#ineffective_double_const_comparisons
 [`inefficient_to_string`]: https://rust-lang.github.io/rust-clippy/master/index.html#inefficient_to_string
 [`infallible_destructuring_match`]: https://rust-lang.github.io/rust-clippy/master/index.html#infallible_destructuring_match
 [`infinite_iter`]: https://rust-lang.github.io/rust-clippy/master/index.html#infinite_iter
@@ -5193,6 +5192,7 @@ Released 2018-09-13
 [`redundant_closure`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_closure
 [`redundant_closure_call`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_closure_call
 [`redundant_closure_for_method_calls`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_closure_for_method_calls
+[`redundant_comparisons`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_comparisons
 [`redundant_else`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_else
 [`redundant_feature_names`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_feature_names
 [`redundant_field_names`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_field_names
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 897e6c7bd10..db114abfc86 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -518,9 +518,8 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::operators::FLOAT_CMP_CONST_INFO,
     crate::operators::FLOAT_EQUALITY_WITHOUT_ABS_INFO,
     crate::operators::IDENTITY_OP_INFO,
-    crate::operators::IMPOSSIBLE_DOUBLE_CONST_COMPARISONS_INFO,
+    crate::operators::IMPOSSIBLE_COMPARISONS_INFO,
     crate::operators::INEFFECTIVE_BIT_MASK_INFO,
-    crate::operators::INEFFECTIVE_DOUBLE_CONST_COMPARISONS_INFO,
     crate::operators::INTEGER_DIVISION_INFO,
     crate::operators::MISREFACTORED_ASSIGN_OP_INFO,
     crate::operators::MODULO_ARITHMETIC_INFO,
@@ -528,6 +527,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::operators::NEEDLESS_BITWISE_BOOL_INFO,
     crate::operators::OP_REF_INFO,
     crate::operators::PTR_EQ_INFO,
+    crate::operators::REDUNDANT_COMPARISONS_INFO,
     crate::operators::SELF_ASSIGNMENT_INFO,
     crate::operators::VERBOSE_BIT_MASK_INFO,
     crate::option_env_unwrap::OPTION_ENV_UNWRAP_INFO,
diff --git a/clippy_lints/src/operators/const_comparisons.rs b/clippy_lints/src/operators/const_comparisons.rs
new file mode 100644
index 00000000000..357981c10ad
--- /dev/null
+++ b/clippy_lints/src/operators/const_comparisons.rs
@@ -0,0 +1,209 @@
+#![allow(clippy::match_same_arms)]
+
+use std::cmp::Ordering;
+
+use clippy_utils::consts;
+use clippy_utils::consts::{ConstEvalLateContext, Constant};
+use if_chain::if_chain;
+use rustc_hir::{BinOpKind, Expr, ExprKind};
+use rustc_lint::LateContext;
+use rustc_middle::ty::{layout::HasTyCtxt, Ty, TypeckResults};
+use rustc_span::source_map::{Span, Spanned};
+
+use clippy_utils::diagnostics::span_lint_and_note;
+use clippy_utils::source::snippet;
+use clippy_utils::SpanlessEq;
+
+use super::IMPOSSIBLE_COMPARISONS;
+use super::REDUNDANT_COMPARISONS;
+
+// Extract a comparison between a const and non-const
+// Flip yoda conditionals, turnings expressions like `42 < x` into `x > 42`
+fn comparison_to_const<'tcx>(
+    ctx: &mut ConstEvalLateContext<'_, 'tcx>,
+    typeck: &TypeckResults<'tcx>,
+    expr: &'tcx Expr<'tcx>,
+) -> Option<(CmpOp, &'tcx Expr<'tcx>, &'tcx Expr<'tcx>, Constant, Ty<'tcx>)> {
+    if_chain! {
+        if let ExprKind::Binary(operator, left, right) = expr.kind;
+        if let Ok(cmp_op) = CmpOp::try_from(operator.node);
+        then {
+            match (ctx.expr(left), ctx.expr(right)) {
+                (Some(_), Some(_)) => None,
+                (_, Some(con)) => Some((cmp_op, left, right, con, typeck.expr_ty(right))),
+                (Some(con), _) => Some((cmp_op.reverse(), right, left, con, typeck.expr_ty(left))),
+                _ => None,
+            }
+        } else {
+            None
+        }
+    }
+}
+
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    and_op: Spanned<BinOpKind>,
+    left_cond: &'tcx Expr<'tcx>,
+    right_cond: &'tcx Expr<'tcx>,
+    span: Span,
+) {
+    if_chain! {
+        // Ensure that the binary operator is &&
+        if and_op.node == BinOpKind::And;
+
+        // Check that both operands to '&&' are themselves a binary operation
+        // The `comparison_to_const` step also checks this, so this step is just an optimization
+        if let ExprKind::Binary(_, _, _) = left_cond.kind;
+        if let ExprKind::Binary(_, _, _) = right_cond.kind;
+
+        let typeck = cx.typeck_results();
+        let mut const_context = consts::ConstEvalLateContext::new(cx, typeck);
+
+        // Check that both operands to '&&' compare a non-literal to a literal
+        if let Some((left_cmp_op, left_expr, left_const_expr, left_const, left_type)) =
+            comparison_to_const(&mut const_context, typeck, left_cond);
+        if let Some((right_cmp_op, right_expr, right_const_expr, right_const, right_type)) =
+            comparison_to_const(&mut const_context, typeck, right_cond);
+
+        if left_type == right_type;
+
+        // Check that the same expression is compared in both comparisons
+        if SpanlessEq::new(cx).eq_expr(left_expr, right_expr);
+
+        if !left_expr.can_have_side_effects();
+
+        // Compare the two constant expressions
+        if let Some(ordering) = Constant::partial_cmp(cx.tcx(), left_type, &left_const, &right_const);
+
+        // Rule out the `x >= 42 && x <= 42` corner case immediately
+        // Mostly to simplify the implementation, but it is also covered by `clippy::double_comparisons`
+        if !matches!(
+            (&left_cmp_op, &right_cmp_op, ordering),
+            (CmpOp::Le | CmpOp::Ge, CmpOp::Le | CmpOp::Ge, Ordering::Equal)
+        );
+
+        then {
+            if left_cmp_op.direction() == right_cmp_op.direction() {
+                let lhs_str = snippet(cx, left_cond.span, "");
+                let rhs_str = snippet(cx, right_cond.span, "");
+                // We already know that either side of `&&` has no effect,
+                // but emit a different error message depending on which side it is
+                if left_side_is_useless(left_cmp_op, ordering) {
+                    span_lint_and_note(
+                        cx,
+                        REDUNDANT_COMPARISONS,
+                        span,
+                        "left-hand side of `&&` operator has no effect",
+                        Some(left_cond.span.until(right_cond.span)),
+                        &format!("`if `{rhs_str}` evaluates to true, {lhs_str}` will always evaluate to true as well"),
+                    );
+                } else {
+                    span_lint_and_note(
+                        cx,
+                        REDUNDANT_COMPARISONS,
+                        span,
+                        "right-hand side of `&&` operator has no effect",
+                        Some(and_op.span.to(right_cond.span)),
+                        &format!("`if `{lhs_str}` evaluates to true, {rhs_str}` will always evaluate to true as well"),
+                    );
+                }
+                // We could autofix this error but choose not to,
+                // because code triggering this lint probably not behaving correctly in the first place
+            }
+            else if !comparison_is_possible(left_cmp_op.direction(), ordering) {
+                let expr_str = snippet(cx, left_expr.span, "");
+                let lhs_str = snippet(cx, left_const_expr.span, "");
+                let rhs_str = snippet(cx, right_const_expr.span, "");
+                let note = match ordering {
+                    Ordering::Less => format!("since `{lhs_str}` < `{rhs_str}`, the expression evaluates to false for any value of `{expr_str}`"),
+                    Ordering::Equal => format!("`{expr_str}` cannot simultaneously be greater than and less than `{lhs_str}`"),
+                    Ordering::Greater => format!("since `{lhs_str}` > `{rhs_str}`, the expression evaluates to false for any value of `{expr_str}`"),
+                };
+                span_lint_and_note(
+                    cx,
+                    IMPOSSIBLE_COMPARISONS,
+                    span,
+                    "boolean expression will never evaluate to 'true'",
+                    None,
+                    &note,
+                );
+            };
+        }
+    }
+}
+
+fn left_side_is_useless(left_cmp_op: CmpOp, ordering: Ordering) -> bool {
+    // Special-case for equal constants with an inclusive comparison
+    if ordering == Ordering::Equal {
+        match left_cmp_op {
+            CmpOp::Lt | CmpOp::Gt => false,
+            CmpOp::Le | CmpOp::Ge => true,
+        }
+    } else {
+        match (left_cmp_op.direction(), ordering) {
+            (CmpOpDirection::Lesser, Ordering::Less) => false,
+            (CmpOpDirection::Lesser, Ordering::Equal) => false,
+            (CmpOpDirection::Lesser, Ordering::Greater) => true,
+            (CmpOpDirection::Greater, Ordering::Less) => true,
+            (CmpOpDirection::Greater, Ordering::Equal) => false,
+            (CmpOpDirection::Greater, Ordering::Greater) => false,
+        }
+    }
+}
+
+fn comparison_is_possible(left_cmp_direction: CmpOpDirection, ordering: Ordering) -> bool {
+    match (left_cmp_direction, ordering) {
+        (CmpOpDirection::Lesser, Ordering::Less | Ordering::Equal) => false,
+        (CmpOpDirection::Lesser, Ordering::Greater) => true,
+        (CmpOpDirection::Greater, Ordering::Greater | Ordering::Equal) => false,
+        (CmpOpDirection::Greater, Ordering::Less) => true,
+    }
+}
+
+#[derive(PartialEq, Eq, Clone, Copy)]
+enum CmpOpDirection {
+    Lesser,
+    Greater,
+}
+
+#[derive(Clone, Copy)]
+enum CmpOp {
+    Lt,
+    Le,
+    Ge,
+    Gt,
+}
+
+impl CmpOp {
+    fn reverse(self) -> Self {
+        match self {
+            CmpOp::Lt => CmpOp::Gt,
+            CmpOp::Le => CmpOp::Ge,
+            CmpOp::Ge => CmpOp::Le,
+            CmpOp::Gt => CmpOp::Lt,
+        }
+    }
+
+    fn direction(self) -> CmpOpDirection {
+        match self {
+            CmpOp::Lt => CmpOpDirection::Lesser,
+            CmpOp::Le => CmpOpDirection::Lesser,
+            CmpOp::Ge => CmpOpDirection::Greater,
+            CmpOp::Gt => CmpOpDirection::Greater,
+        }
+    }
+}
+
+impl TryFrom<BinOpKind> for CmpOp {
+    type Error = ();
+
+    fn try_from(bin_op: BinOpKind) -> Result<Self, Self::Error> {
+        match bin_op {
+            BinOpKind::Lt => Ok(CmpOp::Lt),
+            BinOpKind::Le => Ok(CmpOp::Le),
+            BinOpKind::Ge => Ok(CmpOp::Ge),
+            BinOpKind::Gt => Ok(CmpOp::Gt),
+            _ => Err(()),
+        }
+    }
+}
diff --git a/clippy_lints/src/operators/double_const_comparison.rs b/clippy_lints/src/operators/double_const_comparison.rs
deleted file mode 100644
index 80db455d2e6..00000000000
--- a/clippy_lints/src/operators/double_const_comparison.rs
+++ /dev/null
@@ -1,209 +0,0 @@
-#![allow(clippy::match_same_arms)]
-
-use std::cmp::Ordering;
-
-use clippy_utils::consts;
-use clippy_utils::consts::{ConstEvalLateContext, Constant};
-use if_chain::if_chain;
-use rustc_hir::{BinOpKind, Expr, ExprKind};
-use rustc_lint::LateContext;
-use rustc_middle::ty::{layout::HasTyCtxt, Ty, TypeckResults};
-use rustc_span::source_map::{Span, Spanned};
-
-use clippy_utils::diagnostics::span_lint_and_note;
-use clippy_utils::source::snippet;
-use clippy_utils::SpanlessEq;
-
-use super::IMPOSSIBLE_DOUBLE_CONST_COMPARISONS;
-use super::INEFFECTIVE_DOUBLE_CONST_COMPARISONS;
-
-// Extract a comparison between a const and non-const
-// Flip yoda conditionals, turnings expressions like `42 < x` into `x > 42`
-fn comparison_to_const<'tcx>(
-    ctx: &mut ConstEvalLateContext<'_, 'tcx>,
-    typeck: &TypeckResults<'tcx>,
-    expr: &'tcx Expr<'tcx>,
-) -> Option<(CmpOp, &'tcx Expr<'tcx>, &'tcx Expr<'tcx>, Constant, Ty<'tcx>)> {
-    if_chain! {
-        if let ExprKind::Binary(operator, left, right) = expr.kind;
-        if let Ok(cmp_op) = CmpOp::try_from(operator.node);
-        then {
-            match (ctx.expr(left), ctx.expr(right)) {
-                (Some(_), Some(_)) => None,
-                (_, Some(con)) => Some((cmp_op, left, right, con, typeck.expr_ty(right))),
-                (Some(con), _) => Some((cmp_op.reverse(), right, left, con, typeck.expr_ty(left))),
-                _ => None,
-            }
-        } else {
-            None
-        }
-    }
-}
-
-pub(super) fn check<'tcx>(
-    cx: &LateContext<'tcx>,
-    and_op: Spanned<BinOpKind>,
-    left_cond: &'tcx Expr<'tcx>,
-    right_cond: &'tcx Expr<'tcx>,
-    span: Span,
-) {
-    if_chain! {
-        // Ensure that the binary operator is &&
-        if and_op.node == BinOpKind::And;
-
-        // Check that both operands to '&&' are themselves a binary operation
-        // The `comparison_to_const` step also checks this, so this step is just an optimization
-        if let ExprKind::Binary(_, _, _) = left_cond.kind;
-        if let ExprKind::Binary(_, _, _) = right_cond.kind;
-
-        let typeck = cx.typeck_results();
-        let mut const_context = consts::ConstEvalLateContext::new(cx, typeck);
-
-        // Check that both operands to '&&' compare a non-literal to a literal
-        if let Some((left_cmp_op, left_expr, left_const_expr, left_const, left_type)) =
-            comparison_to_const(&mut const_context, typeck, left_cond);
-        if let Some((right_cmp_op, right_expr, right_const_expr, right_const, right_type)) =
-            comparison_to_const(&mut const_context, typeck, right_cond);
-
-        if left_type == right_type;
-
-        // Check that the same expression is compared in both comparisons
-        if SpanlessEq::new(cx).eq_expr(left_expr, right_expr);
-
-        if !left_expr.can_have_side_effects();
-
-        // Compare the two constant expressions
-        if let Some(ordering) = Constant::partial_cmp(cx.tcx(), left_type, &left_const, &right_const);
-
-        // Rule out the `x >= 42 && x <= 42` corner case immediately
-        // Mostly to simplify the implementation, but it is also covered by `clippy::double_comparisons`
-        if !matches!(
-            (&left_cmp_op, &right_cmp_op, ordering),
-            (CmpOp::Le | CmpOp::Ge, CmpOp::Le | CmpOp::Ge, Ordering::Equal)
-        );
-
-        then {
-            if left_cmp_op.direction() == right_cmp_op.direction() {
-                let lhs_str = snippet(cx, left_cond.span, "");
-                let rhs_str = snippet(cx, right_cond.span, "");
-                // We already know that either side of `&&` has no effect,
-                // but emit a different error message depending on which side it is
-                if left_side_is_useless(left_cmp_op, ordering) {
-                    span_lint_and_note(
-                        cx,
-                        INEFFECTIVE_DOUBLE_CONST_COMPARISONS,
-                        span,
-                        "left-hand side of `&&` operator has no effect",
-                        Some(left_cond.span.until(right_cond.span)),
-                        &format!("`if `{rhs_str}` evaluates to true, {lhs_str}` will always evaluate to true as well"),
-                    );
-                } else {
-                    span_lint_and_note(
-                        cx,
-                        INEFFECTIVE_DOUBLE_CONST_COMPARISONS,
-                        span,
-                        "right-hand side of `&&` operator has no effect",
-                        Some(and_op.span.to(right_cond.span)),
-                        &format!("`if `{lhs_str}` evaluates to true, {rhs_str}` will always evaluate to true as well"),
-                    );
-                }
-                // We could autofix this error but choose not to,
-                // because code triggering this lint probably not behaving correctly in the first place
-            }
-            else if !comparison_is_possible(left_cmp_op.direction(), ordering) {
-                let expr_str = snippet(cx, left_expr.span, "");
-                let lhs_str = snippet(cx, left_const_expr.span, "");
-                let rhs_str = snippet(cx, right_const_expr.span, "");
-                let note = match ordering {
-                    Ordering::Less => format!("since `{lhs_str}` < `{rhs_str}`, the expression evaluates to false for any value of `{expr_str}`"),
-                    Ordering::Equal => format!("`{expr_str}` cannot simultaneously be greater than and less than `{lhs_str}`"),
-                    Ordering::Greater => format!("since `{lhs_str}` > `{rhs_str}`, the expression evaluates to false for any value of `{expr_str}`"),
-                };
-                span_lint_and_note(
-                    cx,
-                    IMPOSSIBLE_DOUBLE_CONST_COMPARISONS,
-                    span,
-                    "boolean expression will never evaluate to 'true'",
-                    None,
-                    &note,
-                );
-            };
-        }
-    }
-}
-
-fn left_side_is_useless(left_cmp_op: CmpOp, ordering: Ordering) -> bool {
-    // Special-case for equal constants with an inclusive comparison
-    if ordering == Ordering::Equal {
-        match left_cmp_op {
-            CmpOp::Lt | CmpOp::Gt => false,
-            CmpOp::Le | CmpOp::Ge => true,
-        }
-    } else {
-        match (left_cmp_op.direction(), ordering) {
-            (CmpOpDirection::Lesser, Ordering::Less) => false,
-            (CmpOpDirection::Lesser, Ordering::Equal) => false,
-            (CmpOpDirection::Lesser, Ordering::Greater) => true,
-            (CmpOpDirection::Greater, Ordering::Less) => true,
-            (CmpOpDirection::Greater, Ordering::Equal) => false,
-            (CmpOpDirection::Greater, Ordering::Greater) => false,
-        }
-    }
-}
-
-fn comparison_is_possible(left_cmp_direction: CmpOpDirection, ordering: Ordering) -> bool {
-    match (left_cmp_direction, ordering) {
-        (CmpOpDirection::Lesser, Ordering::Less | Ordering::Equal) => false,
-        (CmpOpDirection::Lesser, Ordering::Greater) => true,
-        (CmpOpDirection::Greater, Ordering::Greater | Ordering::Equal) => false,
-        (CmpOpDirection::Greater, Ordering::Less) => true,
-    }
-}
-
-#[derive(PartialEq, Eq, Clone, Copy)]
-enum CmpOpDirection {
-    Lesser,
-    Greater,
-}
-
-#[derive(Clone, Copy)]
-enum CmpOp {
-    Lt,
-    Le,
-    Ge,
-    Gt,
-}
-
-impl CmpOp {
-    fn reverse(self) -> Self {
-        match self {
-            CmpOp::Lt => CmpOp::Gt,
-            CmpOp::Le => CmpOp::Ge,
-            CmpOp::Ge => CmpOp::Le,
-            CmpOp::Gt => CmpOp::Lt,
-        }
-    }
-
-    fn direction(self) -> CmpOpDirection {
-        match self {
-            CmpOp::Lt => CmpOpDirection::Lesser,
-            CmpOp::Le => CmpOpDirection::Lesser,
-            CmpOp::Ge => CmpOpDirection::Greater,
-            CmpOp::Gt => CmpOpDirection::Greater,
-        }
-    }
-}
-
-impl TryFrom<BinOpKind> for CmpOp {
-    type Error = ();
-
-    fn try_from(bin_op: BinOpKind) -> Result<Self, Self::Error> {
-        match bin_op {
-            BinOpKind::Lt => Ok(CmpOp::Lt),
-            BinOpKind::Le => Ok(CmpOp::Le),
-            BinOpKind::Ge => Ok(CmpOp::Ge),
-            BinOpKind::Gt => Ok(CmpOp::Gt),
-            _ => Err(()),
-        }
-    }
-}
diff --git a/clippy_lints/src/operators/mod.rs b/clippy_lints/src/operators/mod.rs
index ef76812d9dd..fa8e4c00a97 100644
--- a/clippy_lints/src/operators/mod.rs
+++ b/clippy_lints/src/operators/mod.rs
@@ -2,8 +2,8 @@ mod absurd_extreme_comparisons;
 mod assign_op_pattern;
 mod bit_mask;
 mod cmp_owned;
+mod const_comparisons;
 mod double_comparison;
-mod double_const_comparison;
 mod duration_subsec;
 mod eq_op;
 mod erasing_op;
@@ -313,7 +313,7 @@ declare_clippy_lint! {
     /// if status_code <= 400 && status_code > 500 {}
     /// ```
     #[clippy::version = "1.71.0"]
-    pub IMPOSSIBLE_DOUBLE_CONST_COMPARISONS,
+    pub IMPOSSIBLE_COMPARISONS,
     correctness,
     "double comparisons that will never evaluate to `true`"
 }
@@ -333,7 +333,7 @@ declare_clippy_lint! {
     /// if status_code <= 400 && status_code < 500 {}
     /// ```
     #[clippy::version = "1.71.0"]
-    pub INEFFECTIVE_DOUBLE_CONST_COMPARISONS,
+    pub REDUNDANT_COMPARISONS,
     correctness,
     "double comparisons where one of them can be removed"
 }
@@ -782,8 +782,8 @@ impl_lint_pass!(Operators => [
     INEFFECTIVE_BIT_MASK,
     VERBOSE_BIT_MASK,
     DOUBLE_COMPARISONS,
-    IMPOSSIBLE_DOUBLE_CONST_COMPARISONS,
-    INEFFECTIVE_DOUBLE_CONST_COMPARISONS,
+    IMPOSSIBLE_COMPARISONS,
+    REDUNDANT_COMPARISONS,
     DURATION_SUBSEC,
     EQ_OP,
     OP_REF,
@@ -828,7 +828,7 @@ impl<'tcx> LateLintPass<'tcx> for Operators {
                 bit_mask::check(cx, e, op.node, lhs, rhs);
                 verbose_bit_mask::check(cx, e, op.node, lhs, rhs, self.verbose_bit_mask_threshold);
                 double_comparison::check(cx, op.node, lhs, rhs, e.span);
-                double_const_comparison::check(cx, op, lhs, rhs, e.span);
+                const_comparisons::check(cx, op, lhs, rhs, e.span);
                 duration_subsec::check(cx, e, op.node, lhs, rhs);
                 float_equality_without_abs::check(cx, e, op.node, lhs, rhs);
                 integer_division::check(cx, e, op.node, lhs, rhs);
diff --git a/tests/ui/const_comparisons.rs b/tests/ui/const_comparisons.rs
new file mode 100644
index 00000000000..8e265c9141c
--- /dev/null
+++ b/tests/ui/const_comparisons.rs
@@ -0,0 +1,93 @@
+#![allow(unused)]
+#![warn(clippy::impossible_comparisons)]
+#![warn(clippy::redundant_comparisons)]
+#![allow(clippy::no_effect)]
+#![allow(clippy::short_circuit_statement)]
+#![allow(clippy::manual_range_contains)]
+
+const STATUS_BAD_REQUEST: u16 = 400;
+const STATUS_SERVER_ERROR: u16 = 500;
+
+struct Status {
+    code: u16,
+}
+
+impl PartialEq<u16> for Status {
+    fn eq(&self, other: &u16) -> bool {
+        self.code == *other
+    }
+}
+
+impl PartialOrd<u16> for Status {
+    fn partial_cmp(&self, other: &u16) -> Option<std::cmp::Ordering> {
+        self.code.partial_cmp(other)
+    }
+}
+
+impl PartialEq<Status> for u16 {
+    fn eq(&self, other: &Status) -> bool {
+        *self == other.code
+    }
+}
+
+impl PartialOrd<Status> for u16 {
+    fn partial_cmp(&self, other: &Status) -> Option<std::cmp::Ordering> {
+        self.partial_cmp(&other.code)
+    }
+}
+
+fn main() {
+    let status_code = 500; // Value doesn't matter for the lint
+    let status = Status { code: status_code };
+
+    status_code >= 400 && status_code < 500; // Correct
+    status_code <= 400 && status_code > 500;
+    status_code > 500 && status_code < 400;
+    status_code < 500 && status_code > 500;
+
+    // More complex expressions
+    status_code < { 400 } && status_code > { 500 };
+    status_code < STATUS_BAD_REQUEST && status_code > STATUS_SERVER_ERROR;
+    status_code <= u16::MIN + 1 && status_code > STATUS_SERVER_ERROR;
+    status_code < STATUS_SERVER_ERROR && status_code > STATUS_SERVER_ERROR;
+
+    // Comparing two different types, via the `impl PartialOrd<u16> for Status`
+    status < { 400 } && status > { 500 };
+    status < STATUS_BAD_REQUEST && status > STATUS_SERVER_ERROR;
+    status <= u16::MIN + 1 && status > STATUS_SERVER_ERROR;
+    status < STATUS_SERVER_ERROR && status > STATUS_SERVER_ERROR;
+
+    // Yoda conditions
+    500 <= status_code && 600 > status_code; // Correct
+    500 <= status_code && status_code <= 600; // Correct
+    500 >= status_code && 600 < status_code; // Incorrect
+    500 >= status_code && status_code > 600; // Incorrect
+
+    // Yoda conditions, comparing two different types
+    500 <= status && 600 > status; // Correct
+    500 <= status && status <= 600; // Correct
+    500 >= status && 600 < status; // Incorrect
+    500 >= status && status > 600; // Incorrect
+
+    // Expressions where one of the sides has no effect
+    status_code < 200 && status_code <= 299;
+    status_code > 200 && status_code >= 299;
+
+    status_code >= 500 && status_code > 500; // Useless left
+    status_code > 500 && status_code >= 500; // Useless right
+    status_code <= 500 && status_code < 500; // Useless left
+    status_code < 500 && status_code <= 500; // Useless right
+
+    // Other types
+    let name = "Steve";
+    name < "Jennifer" && name > "Shannon";
+
+    let numbers = [1, 2];
+    numbers < [3, 4] && numbers > [5, 6];
+
+    let letter = 'a';
+    letter < 'b' && letter > 'c';
+
+    let area = 42.0;
+    area < std::f32::consts::E && area > std::f32::consts::PI;
+}
diff --git a/tests/ui/const_comparisons.stderr b/tests/ui/const_comparisons.stderr
new file mode 100644
index 00000000000..90e6db64762
--- /dev/null
+++ b/tests/ui/const_comparisons.stderr
@@ -0,0 +1,228 @@
+error: boolean expression will never evaluate to 'true'
+  --> $DIR/const_comparisons.rs:44:5
+   |
+LL |     status_code <= 400 && status_code > 500;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: since `400` < `500`, the expression evaluates to false for any value of `status_code`
+   = note: `-D clippy::impossible-comparisons` implied by `-D warnings`
+
+error: boolean expression will never evaluate to 'true'
+  --> $DIR/const_comparisons.rs:45:5
+   |
+LL |     status_code > 500 && status_code < 400;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: since `500` > `400`, the expression evaluates to false for any value of `status_code`
+
+error: boolean expression will never evaluate to 'true'
+  --> $DIR/const_comparisons.rs:46:5
+   |
+LL |     status_code < 500 && status_code > 500;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `status_code` cannot simultaneously be greater than and less than `500`
+
+error: boolean expression will never evaluate to 'true'
+  --> $DIR/const_comparisons.rs:49:5
+   |
+LL |     status_code < { 400 } && status_code > { 500 };
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: since `{ 400 }` < `{ 500 }`, the expression evaluates to false for any value of `status_code`
+
+error: boolean expression will never evaluate to 'true'
+  --> $DIR/const_comparisons.rs:50:5
+   |
+LL |     status_code < STATUS_BAD_REQUEST && status_code > STATUS_SERVER_ERROR;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: since `STATUS_BAD_REQUEST` < `STATUS_SERVER_ERROR`, the expression evaluates to false for any value of `status_code`
+
+error: boolean expression will never evaluate to 'true'
+  --> $DIR/const_comparisons.rs:51:5
+   |
+LL |     status_code <= u16::MIN + 1 && status_code > STATUS_SERVER_ERROR;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: since `u16::MIN + 1` < `STATUS_SERVER_ERROR`, the expression evaluates to false for any value of `status_code`
+
+error: boolean expression will never evaluate to 'true'
+  --> $DIR/const_comparisons.rs:52:5
+   |
+LL |     status_code < STATUS_SERVER_ERROR && status_code > STATUS_SERVER_ERROR;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `status_code` cannot simultaneously be greater than and less than `STATUS_SERVER_ERROR`
+
+error: boolean expression will never evaluate to 'true'
+  --> $DIR/const_comparisons.rs:55:5
+   |
+LL |     status < { 400 } && status > { 500 };
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: since `{ 400 }` < `{ 500 }`, the expression evaluates to false for any value of `status`
+
+error: boolean expression will never evaluate to 'true'
+  --> $DIR/const_comparisons.rs:56:5
+   |
+LL |     status < STATUS_BAD_REQUEST && status > STATUS_SERVER_ERROR;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: since `STATUS_BAD_REQUEST` < `STATUS_SERVER_ERROR`, the expression evaluates to false for any value of `status`
+
+error: boolean expression will never evaluate to 'true'
+  --> $DIR/const_comparisons.rs:57:5
+   |
+LL |     status <= u16::MIN + 1 && status > STATUS_SERVER_ERROR;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: since `u16::MIN + 1` < `STATUS_SERVER_ERROR`, the expression evaluates to false for any value of `status`
+
+error: boolean expression will never evaluate to 'true'
+  --> $DIR/const_comparisons.rs:58:5
+   |
+LL |     status < STATUS_SERVER_ERROR && status > STATUS_SERVER_ERROR;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `status` cannot simultaneously be greater than and less than `STATUS_SERVER_ERROR`
+
+error: boolean expression will never evaluate to 'true'
+  --> $DIR/const_comparisons.rs:63:5
+   |
+LL |     500 >= status_code && 600 < status_code; // Incorrect
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: since `500` < `600`, the expression evaluates to false for any value of `status_code`
+
+error: boolean expression will never evaluate to 'true'
+  --> $DIR/const_comparisons.rs:64:5
+   |
+LL |     500 >= status_code && status_code > 600; // Incorrect
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: since `500` < `600`, the expression evaluates to false for any value of `status_code`
+
+error: boolean expression will never evaluate to 'true'
+  --> $DIR/const_comparisons.rs:69:5
+   |
+LL |     500 >= status && 600 < status; // Incorrect
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: since `500` < `600`, the expression evaluates to false for any value of `status`
+
+error: boolean expression will never evaluate to 'true'
+  --> $DIR/const_comparisons.rs:70:5
+   |
+LL |     500 >= status && status > 600; // Incorrect
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: since `500` < `600`, the expression evaluates to false for any value of `status`
+
+error: right-hand side of `&&` operator has no effect
+  --> $DIR/const_comparisons.rs:73:5
+   |
+LL |     status_code < 200 && status_code <= 299;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: `if `status_code < 200` evaluates to true, status_code <= 299` will always evaluate to true as well
+  --> $DIR/const_comparisons.rs:73:23
+   |
+LL |     status_code < 200 && status_code <= 299;
+   |                       ^^^^^^^^^^^^^^^^^^^^^
+   = note: `-D clippy::redundant-comparisons` implied by `-D warnings`
+
+error: left-hand side of `&&` operator has no effect
+  --> $DIR/const_comparisons.rs:74:5
+   |
+LL |     status_code > 200 && status_code >= 299;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: `if `status_code >= 299` evaluates to true, status_code > 200` will always evaluate to true as well
+  --> $DIR/const_comparisons.rs:74:5
+   |
+LL |     status_code > 200 && status_code >= 299;
+   |     ^^^^^^^^^^^^^^^^^^^^^
+
+error: left-hand side of `&&` operator has no effect
+  --> $DIR/const_comparisons.rs:76:5
+   |
+LL |     status_code >= 500 && status_code > 500; // Useless left
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: `if `status_code > 500` evaluates to true, status_code >= 500` will always evaluate to true as well
+  --> $DIR/const_comparisons.rs:76:5
+   |
+LL |     status_code >= 500 && status_code > 500; // Useless left
+   |     ^^^^^^^^^^^^^^^^^^^^^^
+
+error: right-hand side of `&&` operator has no effect
+  --> $DIR/const_comparisons.rs:77:5
+   |
+LL |     status_code > 500 && status_code >= 500; // Useless right
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: `if `status_code > 500` evaluates to true, status_code >= 500` will always evaluate to true as well
+  --> $DIR/const_comparisons.rs:77:23
+   |
+LL |     status_code > 500 && status_code >= 500; // Useless right
+   |                       ^^^^^^^^^^^^^^^^^^^^^
+
+error: left-hand side of `&&` operator has no effect
+  --> $DIR/const_comparisons.rs:78:5
+   |
+LL |     status_code <= 500 && status_code < 500; // Useless left
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: `if `status_code < 500` evaluates to true, status_code <= 500` will always evaluate to true as well
+  --> $DIR/const_comparisons.rs:78:5
+   |
+LL |     status_code <= 500 && status_code < 500; // Useless left
+   |     ^^^^^^^^^^^^^^^^^^^^^^
+
+error: right-hand side of `&&` operator has no effect
+  --> $DIR/const_comparisons.rs:79:5
+   |
+LL |     status_code < 500 && status_code <= 500; // Useless right
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: `if `status_code < 500` evaluates to true, status_code <= 500` will always evaluate to true as well
+  --> $DIR/const_comparisons.rs:79:23
+   |
+LL |     status_code < 500 && status_code <= 500; // Useless right
+   |                       ^^^^^^^^^^^^^^^^^^^^^
+
+error: boolean expression will never evaluate to 'true'
+  --> $DIR/const_comparisons.rs:83:5
+   |
+LL |     name < "Jennifer" && name > "Shannon";
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: since `"Jennifer"` < `"Shannon"`, the expression evaluates to false for any value of `name`
+
+error: boolean expression will never evaluate to 'true'
+  --> $DIR/const_comparisons.rs:86:5
+   |
+LL |     numbers < [3, 4] && numbers > [5, 6];
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: since `[3, 4]` < `[5, 6]`, the expression evaluates to false for any value of `numbers`
+
+error: boolean expression will never evaluate to 'true'
+  --> $DIR/const_comparisons.rs:89:5
+   |
+LL |     letter < 'b' && letter > 'c';
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: since `'b'` < `'c'`, the expression evaluates to false for any value of `letter`
+
+error: boolean expression will never evaluate to 'true'
+  --> $DIR/const_comparisons.rs:92:5
+   |
+LL |     area < std::f32::consts::E && area > std::f32::consts::PI;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: since `std::f32::consts::E` < `std::f32::consts::PI`, the expression evaluates to false for any value of `area`
+
+error: aborting due to 25 previous errors
+
diff --git a/tests/ui/double_const_comparisons.rs b/tests/ui/double_const_comparisons.rs
deleted file mode 100644
index de01d8e0c36..00000000000
--- a/tests/ui/double_const_comparisons.rs
+++ /dev/null
@@ -1,93 +0,0 @@
-#![allow(unused)]
-#![warn(clippy::impossible_double_const_comparisons)]
-#![warn(clippy::ineffective_double_const_comparisons)]
-#![allow(clippy::no_effect)]
-#![allow(clippy::short_circuit_statement)]
-#![allow(clippy::manual_range_contains)]
-
-const STATUS_BAD_REQUEST: u16 = 400;
-const STATUS_SERVER_ERROR: u16 = 500;
-
-struct Status {
-    code: u16,
-}
-
-impl PartialEq<u16> for Status {
-    fn eq(&self, other: &u16) -> bool {
-        self.code == *other
-    }
-}
-
-impl PartialOrd<u16> for Status {
-    fn partial_cmp(&self, other: &u16) -> Option<std::cmp::Ordering> {
-        self.code.partial_cmp(other)
-    }
-}
-
-impl PartialEq<Status> for u16 {
-    fn eq(&self, other: &Status) -> bool {
-        *self == other.code
-    }
-}
-
-impl PartialOrd<Status> for u16 {
-    fn partial_cmp(&self, other: &Status) -> Option<std::cmp::Ordering> {
-        self.partial_cmp(&other.code)
-    }
-}
-
-fn main() {
-    let status_code = 500; // Value doesn't matter for the lint
-    let status = Status { code: status_code };
-
-    status_code >= 400 && status_code < 500; // Correct
-    status_code <= 400 && status_code > 500;
-    status_code > 500 && status_code < 400;
-    status_code < 500 && status_code > 500;
-
-    // More complex expressions
-    status_code < { 400 } && status_code > { 500 };
-    status_code < STATUS_BAD_REQUEST && status_code > STATUS_SERVER_ERROR;
-    status_code <= u16::MIN + 1 && status_code > STATUS_SERVER_ERROR;
-    status_code < STATUS_SERVER_ERROR && status_code > STATUS_SERVER_ERROR;
-
-    // Comparing two different types, via the `impl PartialOrd<u16> for Status`
-    status < { 400 } && status > { 500 };
-    status < STATUS_BAD_REQUEST && status > STATUS_SERVER_ERROR;
-    status <= u16::MIN + 1 && status > STATUS_SERVER_ERROR;
-    status < STATUS_SERVER_ERROR && status > STATUS_SERVER_ERROR;
-
-    // Yoda conditions
-    500 <= status_code && 600 > status_code; // Correct
-    500 <= status_code && status_code <= 600; // Correct
-    500 >= status_code && 600 < status_code; // Incorrect
-    500 >= status_code && status_code > 600; // Incorrect
-
-    // Yoda conditions, comparing two different types
-    500 <= status && 600 > status; // Correct
-    500 <= status && status <= 600; // Correct
-    500 >= status && 600 < status; // Incorrect
-    500 >= status && status > 600; // Incorrect
-
-    // Expressions where one of the sides has no effect
-    status_code < 200 && status_code <= 299;
-    status_code > 200 && status_code >= 299;
-
-    status_code >= 500 && status_code > 500; // Useless left
-    status_code > 500 && status_code >= 500; // Useless right
-    status_code <= 500 && status_code < 500; // Useless left
-    status_code < 500 && status_code <= 500; // Useless right
-
-    // Other types
-    let name = "Steve";
-    name < "Jennifer" && name > "Shannon";
-
-    let numbers = [1, 2];
-    numbers < [3, 4] && numbers > [5, 6];
-
-    let letter = 'a';
-    letter < 'b' && letter > 'c';
-
-    let area = 42.0;
-    area < std::f32::consts::E && area > std::f32::consts::PI;
-}
diff --git a/tests/ui/double_const_comparisons.stderr b/tests/ui/double_const_comparisons.stderr
deleted file mode 100644
index 3d8ef3c6d64..00000000000
--- a/tests/ui/double_const_comparisons.stderr
+++ /dev/null
@@ -1,228 +0,0 @@
-error: boolean expression will never evaluate to 'true'
-  --> $DIR/double_const_comparisons.rs:44:5
-   |
-LL |     status_code <= 400 && status_code > 500;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: since `400` < `500`, the expression evaluates to false for any value of `status_code`
-   = note: `-D clippy::impossible-double-const-comparisons` implied by `-D warnings`
-
-error: boolean expression will never evaluate to 'true'
-  --> $DIR/double_const_comparisons.rs:45:5
-   |
-LL |     status_code > 500 && status_code < 400;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: since `500` > `400`, the expression evaluates to false for any value of `status_code`
-
-error: boolean expression will never evaluate to 'true'
-  --> $DIR/double_const_comparisons.rs:46:5
-   |
-LL |     status_code < 500 && status_code > 500;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: `status_code` cannot simultaneously be greater than and less than `500`
-
-error: boolean expression will never evaluate to 'true'
-  --> $DIR/double_const_comparisons.rs:49:5
-   |
-LL |     status_code < { 400 } && status_code > { 500 };
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: since `{ 400 }` < `{ 500 }`, the expression evaluates to false for any value of `status_code`
-
-error: boolean expression will never evaluate to 'true'
-  --> $DIR/double_const_comparisons.rs:50:5
-   |
-LL |     status_code < STATUS_BAD_REQUEST && status_code > STATUS_SERVER_ERROR;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: since `STATUS_BAD_REQUEST` < `STATUS_SERVER_ERROR`, the expression evaluates to false for any value of `status_code`
-
-error: boolean expression will never evaluate to 'true'
-  --> $DIR/double_const_comparisons.rs:51:5
-   |
-LL |     status_code <= u16::MIN + 1 && status_code > STATUS_SERVER_ERROR;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: since `u16::MIN + 1` < `STATUS_SERVER_ERROR`, the expression evaluates to false for any value of `status_code`
-
-error: boolean expression will never evaluate to 'true'
-  --> $DIR/double_const_comparisons.rs:52:5
-   |
-LL |     status_code < STATUS_SERVER_ERROR && status_code > STATUS_SERVER_ERROR;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: `status_code` cannot simultaneously be greater than and less than `STATUS_SERVER_ERROR`
-
-error: boolean expression will never evaluate to 'true'
-  --> $DIR/double_const_comparisons.rs:55:5
-   |
-LL |     status < { 400 } && status > { 500 };
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: since `{ 400 }` < `{ 500 }`, the expression evaluates to false for any value of `status`
-
-error: boolean expression will never evaluate to 'true'
-  --> $DIR/double_const_comparisons.rs:56:5
-   |
-LL |     status < STATUS_BAD_REQUEST && status > STATUS_SERVER_ERROR;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: since `STATUS_BAD_REQUEST` < `STATUS_SERVER_ERROR`, the expression evaluates to false for any value of `status`
-
-error: boolean expression will never evaluate to 'true'
-  --> $DIR/double_const_comparisons.rs:57:5
-   |
-LL |     status <= u16::MIN + 1 && status > STATUS_SERVER_ERROR;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: since `u16::MIN + 1` < `STATUS_SERVER_ERROR`, the expression evaluates to false for any value of `status`
-
-error: boolean expression will never evaluate to 'true'
-  --> $DIR/double_const_comparisons.rs:58:5
-   |
-LL |     status < STATUS_SERVER_ERROR && status > STATUS_SERVER_ERROR;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: `status` cannot simultaneously be greater than and less than `STATUS_SERVER_ERROR`
-
-error: boolean expression will never evaluate to 'true'
-  --> $DIR/double_const_comparisons.rs:63:5
-   |
-LL |     500 >= status_code && 600 < status_code; // Incorrect
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: since `500` < `600`, the expression evaluates to false for any value of `status_code`
-
-error: boolean expression will never evaluate to 'true'
-  --> $DIR/double_const_comparisons.rs:64:5
-   |
-LL |     500 >= status_code && status_code > 600; // Incorrect
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: since `500` < `600`, the expression evaluates to false for any value of `status_code`
-
-error: boolean expression will never evaluate to 'true'
-  --> $DIR/double_const_comparisons.rs:69:5
-   |
-LL |     500 >= status && 600 < status; // Incorrect
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: since `500` < `600`, the expression evaluates to false for any value of `status`
-
-error: boolean expression will never evaluate to 'true'
-  --> $DIR/double_const_comparisons.rs:70:5
-   |
-LL |     500 >= status && status > 600; // Incorrect
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: since `500` < `600`, the expression evaluates to false for any value of `status`
-
-error: right-hand side of `&&` operator has no effect
-  --> $DIR/double_const_comparisons.rs:73:5
-   |
-LL |     status_code < 200 && status_code <= 299;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-note: `if `status_code < 200` evaluates to true, status_code <= 299` will always evaluate to true as well
-  --> $DIR/double_const_comparisons.rs:73:23
-   |
-LL |     status_code < 200 && status_code <= 299;
-   |                       ^^^^^^^^^^^^^^^^^^^^^
-   = note: `-D clippy::ineffective-double-const-comparisons` implied by `-D warnings`
-
-error: left-hand side of `&&` operator has no effect
-  --> $DIR/double_const_comparisons.rs:74:5
-   |
-LL |     status_code > 200 && status_code >= 299;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-note: `if `status_code >= 299` evaluates to true, status_code > 200` will always evaluate to true as well
-  --> $DIR/double_const_comparisons.rs:74:5
-   |
-LL |     status_code > 200 && status_code >= 299;
-   |     ^^^^^^^^^^^^^^^^^^^^^
-
-error: left-hand side of `&&` operator has no effect
-  --> $DIR/double_const_comparisons.rs:76:5
-   |
-LL |     status_code >= 500 && status_code > 500; // Useless left
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-note: `if `status_code > 500` evaluates to true, status_code >= 500` will always evaluate to true as well
-  --> $DIR/double_const_comparisons.rs:76:5
-   |
-LL |     status_code >= 500 && status_code > 500; // Useless left
-   |     ^^^^^^^^^^^^^^^^^^^^^^
-
-error: right-hand side of `&&` operator has no effect
-  --> $DIR/double_const_comparisons.rs:77:5
-   |
-LL |     status_code > 500 && status_code >= 500; // Useless right
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-note: `if `status_code > 500` evaluates to true, status_code >= 500` will always evaluate to true as well
-  --> $DIR/double_const_comparisons.rs:77:23
-   |
-LL |     status_code > 500 && status_code >= 500; // Useless right
-   |                       ^^^^^^^^^^^^^^^^^^^^^
-
-error: left-hand side of `&&` operator has no effect
-  --> $DIR/double_const_comparisons.rs:78:5
-   |
-LL |     status_code <= 500 && status_code < 500; // Useless left
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-note: `if `status_code < 500` evaluates to true, status_code <= 500` will always evaluate to true as well
-  --> $DIR/double_const_comparisons.rs:78:5
-   |
-LL |     status_code <= 500 && status_code < 500; // Useless left
-   |     ^^^^^^^^^^^^^^^^^^^^^^
-
-error: right-hand side of `&&` operator has no effect
-  --> $DIR/double_const_comparisons.rs:79:5
-   |
-LL |     status_code < 500 && status_code <= 500; // Useless right
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-note: `if `status_code < 500` evaluates to true, status_code <= 500` will always evaluate to true as well
-  --> $DIR/double_const_comparisons.rs:79:23
-   |
-LL |     status_code < 500 && status_code <= 500; // Useless right
-   |                       ^^^^^^^^^^^^^^^^^^^^^
-
-error: boolean expression will never evaluate to 'true'
-  --> $DIR/double_const_comparisons.rs:83:5
-   |
-LL |     name < "Jennifer" && name > "Shannon";
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: since `"Jennifer"` < `"Shannon"`, the expression evaluates to false for any value of `name`
-
-error: boolean expression will never evaluate to 'true'
-  --> $DIR/double_const_comparisons.rs:86:5
-   |
-LL |     numbers < [3, 4] && numbers > [5, 6];
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: since `[3, 4]` < `[5, 6]`, the expression evaluates to false for any value of `numbers`
-
-error: boolean expression will never evaluate to 'true'
-  --> $DIR/double_const_comparisons.rs:89:5
-   |
-LL |     letter < 'b' && letter > 'c';
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: since `'b'` < `'c'`, the expression evaluates to false for any value of `letter`
-
-error: boolean expression will never evaluate to 'true'
-  --> $DIR/double_const_comparisons.rs:92:5
-   |
-LL |     area < std::f32::consts::E && area > std::f32::consts::PI;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: since `std::f32::consts::E` < `std::f32::consts::PI`, the expression evaluates to false for any value of `area`
-
-error: aborting due to 25 previous errors
-
diff --git a/tests/ui/range_contains.fixed b/tests/ui/range_contains.fixed
index 429d8608291..47c5248118e 100644
--- a/tests/ui/range_contains.fixed
+++ b/tests/ui/range_contains.fixed
@@ -5,8 +5,8 @@
 #![allow(clippy::no_effect)]
 #![allow(clippy::short_circuit_statement)]
 #![allow(clippy::unnecessary_operation)]
-#![allow(clippy::impossible_double_const_comparisons)]
-#![allow(clippy::ineffective_double_const_comparisons)]
+#![allow(clippy::impossible_comparisons)]
+#![allow(clippy::redundant_comparisons)]
 
 fn main() {
     let x = 9_i32;
diff --git a/tests/ui/range_contains.rs b/tests/ui/range_contains.rs
index e47e2948147..a35315a649d 100644
--- a/tests/ui/range_contains.rs
+++ b/tests/ui/range_contains.rs
@@ -5,8 +5,8 @@
 #![allow(clippy::no_effect)]
 #![allow(clippy::short_circuit_statement)]
 #![allow(clippy::unnecessary_operation)]
-#![allow(clippy::impossible_double_const_comparisons)]
-#![allow(clippy::ineffective_double_const_comparisons)]
+#![allow(clippy::impossible_comparisons)]
+#![allow(clippy::redundant_comparisons)]
 
 fn main() {
     let x = 9_i32;
-- 
cgit 1.4.1-3-g733a5


From 964644692324c41fae286208417086c45b5c878e Mon Sep 17 00:00:00 2001
From: Morten Lohne <lohnemorten@gmail.com>
Date: Sun, 6 Aug 2023 13:29:50 +0200
Subject: Add lifetime parameter to 'Constant', after rebasing on upstream

---
 clippy_lints/src/operators/const_comparisons.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/operators/const_comparisons.rs b/clippy_lints/src/operators/const_comparisons.rs
index 357981c10ad..16ac964e93a 100644
--- a/clippy_lints/src/operators/const_comparisons.rs
+++ b/clippy_lints/src/operators/const_comparisons.rs
@@ -7,15 +7,15 @@ use clippy_utils::consts::{ConstEvalLateContext, Constant};
 use if_chain::if_chain;
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::LateContext;
-use rustc_middle::ty::{layout::HasTyCtxt, Ty, TypeckResults};
+use rustc_middle::ty::layout::HasTyCtxt;
+use rustc_middle::ty::{Ty, TypeckResults};
 use rustc_span::source_map::{Span, Spanned};
 
 use clippy_utils::diagnostics::span_lint_and_note;
 use clippy_utils::source::snippet;
 use clippy_utils::SpanlessEq;
 
-use super::IMPOSSIBLE_COMPARISONS;
-use super::REDUNDANT_COMPARISONS;
+use super::{IMPOSSIBLE_COMPARISONS, REDUNDANT_COMPARISONS};
 
 // Extract a comparison between a const and non-const
 // Flip yoda conditionals, turnings expressions like `42 < x` into `x > 42`
@@ -23,7 +23,7 @@ fn comparison_to_const<'tcx>(
     ctx: &mut ConstEvalLateContext<'_, 'tcx>,
     typeck: &TypeckResults<'tcx>,
     expr: &'tcx Expr<'tcx>,
-) -> Option<(CmpOp, &'tcx Expr<'tcx>, &'tcx Expr<'tcx>, Constant, Ty<'tcx>)> {
+) -> Option<(CmpOp, &'tcx Expr<'tcx>, &'tcx Expr<'tcx>, Constant<'tcx>, Ty<'tcx>)> {
     if_chain! {
         if let ExprKind::Binary(operator, left, right) = expr.kind;
         if let Ok(cmp_op) = CmpOp::try_from(operator.node);
-- 
cgit 1.4.1-3-g733a5


From 0e064d5d0480bf471c26a4566a9e3a09751a6262 Mon Sep 17 00:00:00 2001
From: Morten Lohne <lohnemorten@gmail.com>
Date: Sun, 6 Aug 2023 13:48:28 +0200
Subject: Replace ConstEvalLateContext::new() with two calls to constant() to
 simplify the code, after PR suggestion

---
 clippy_lints/src/operators/const_comparisons.rs | 12 +++++-------
 1 file changed, 5 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/operators/const_comparisons.rs b/clippy_lints/src/operators/const_comparisons.rs
index 16ac964e93a..77043b0a3eb 100644
--- a/clippy_lints/src/operators/const_comparisons.rs
+++ b/clippy_lints/src/operators/const_comparisons.rs
@@ -2,8 +2,7 @@
 
 use std::cmp::Ordering;
 
-use clippy_utils::consts;
-use clippy_utils::consts::{ConstEvalLateContext, Constant};
+use clippy_utils::consts::{constant, Constant};
 use if_chain::if_chain;
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::LateContext;
@@ -20,7 +19,7 @@ use super::{IMPOSSIBLE_COMPARISONS, REDUNDANT_COMPARISONS};
 // Extract a comparison between a const and non-const
 // Flip yoda conditionals, turnings expressions like `42 < x` into `x > 42`
 fn comparison_to_const<'tcx>(
-    ctx: &mut ConstEvalLateContext<'_, 'tcx>,
+    cx: &LateContext<'tcx>,
     typeck: &TypeckResults<'tcx>,
     expr: &'tcx Expr<'tcx>,
 ) -> Option<(CmpOp, &'tcx Expr<'tcx>, &'tcx Expr<'tcx>, Constant<'tcx>, Ty<'tcx>)> {
@@ -28,7 +27,7 @@ fn comparison_to_const<'tcx>(
         if let ExprKind::Binary(operator, left, right) = expr.kind;
         if let Ok(cmp_op) = CmpOp::try_from(operator.node);
         then {
-            match (ctx.expr(left), ctx.expr(right)) {
+            match (constant(cx, typeck, left), constant(cx, typeck, right)) {
                 (Some(_), Some(_)) => None,
                 (_, Some(con)) => Some((cmp_op, left, right, con, typeck.expr_ty(right))),
                 (Some(con), _) => Some((cmp_op.reverse(), right, left, con, typeck.expr_ty(left))),
@@ -57,13 +56,12 @@ pub(super) fn check<'tcx>(
         if let ExprKind::Binary(_, _, _) = right_cond.kind;
 
         let typeck = cx.typeck_results();
-        let mut const_context = consts::ConstEvalLateContext::new(cx, typeck);
 
         // Check that both operands to '&&' compare a non-literal to a literal
         if let Some((left_cmp_op, left_expr, left_const_expr, left_const, left_type)) =
-            comparison_to_const(&mut const_context, typeck, left_cond);
+            comparison_to_const(cx, typeck, left_cond);
         if let Some((right_cmp_op, right_expr, right_const_expr, right_const, right_type)) =
-            comparison_to_const(&mut const_context, typeck, right_cond);
+            comparison_to_const(cx, typeck, right_cond);
 
         if left_type == right_type;
 
-- 
cgit 1.4.1-3-g733a5


From 3157b96a5bc352336889399c68d0248eb67073c0 Mon Sep 17 00:00:00 2001
From: Morten Lohne <lohnemorten@gmail.com>
Date: Sun, 6 Aug 2023 13:49:17 +0200
Subject: Provide fallback code snippets, if the snippet is not available

---
 clippy_lints/src/operators/const_comparisons.rs | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/operators/const_comparisons.rs b/clippy_lints/src/operators/const_comparisons.rs
index 77043b0a3eb..abe8df19543 100644
--- a/clippy_lints/src/operators/const_comparisons.rs
+++ b/clippy_lints/src/operators/const_comparisons.rs
@@ -82,8 +82,8 @@ pub(super) fn check<'tcx>(
 
         then {
             if left_cmp_op.direction() == right_cmp_op.direction() {
-                let lhs_str = snippet(cx, left_cond.span, "");
-                let rhs_str = snippet(cx, right_cond.span, "");
+                let lhs_str = snippet(cx, left_cond.span, "<lhs>");
+                let rhs_str = snippet(cx, right_cond.span, "<rhs>");
                 // We already know that either side of `&&` has no effect,
                 // but emit a different error message depending on which side it is
                 if left_side_is_useless(left_cmp_op, ordering) {
@@ -109,9 +109,9 @@ pub(super) fn check<'tcx>(
                 // because code triggering this lint probably not behaving correctly in the first place
             }
             else if !comparison_is_possible(left_cmp_op.direction(), ordering) {
-                let expr_str = snippet(cx, left_expr.span, "");
-                let lhs_str = snippet(cx, left_const_expr.span, "");
-                let rhs_str = snippet(cx, right_const_expr.span, "");
+                let expr_str = snippet(cx, left_expr.span, "..");
+                let lhs_str = snippet(cx, left_const_expr.span, "<lhs>");
+                let rhs_str = snippet(cx, right_const_expr.span, "<rhs>");
                 let note = match ordering {
                     Ordering::Less => format!("since `{lhs_str}` < `{rhs_str}`, the expression evaluates to false for any value of `{expr_str}`"),
                     Ordering::Equal => format!("`{expr_str}` cannot simultaneously be greater than and less than `{lhs_str}`"),
-- 
cgit 1.4.1-3-g733a5


From d62804624441c2f7bf3de45cd2c9b5c411b2d6a6 Mon Sep 17 00:00:00 2001
From: Manish Goregaokar <manishsmail@gmail.com>
Date: Sun, 6 Aug 2023 17:19:43 +0000
Subject: Update clippy_lints/src/operators/mod.rs

Co-authored-by: Catherine Flores <catherine.3.flores@gmail.com>
---
 clippy_lints/src/operators/mod.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/operators/mod.rs b/clippy_lints/src/operators/mod.rs
index fa8e4c00a97..4635e1164cd 100644
--- a/clippy_lints/src/operators/mod.rs
+++ b/clippy_lints/src/operators/mod.rs
@@ -320,12 +320,12 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for ineffective double comparisons against constants
+    /// Checks for ineffective double comparisons against constants.
     ///
     /// ### Why is this bad?
-    /// Only one of the comparisons has any effect on the result
-    /// The programmer probably intended to flip one of the comparison operators,
-    /// or compare a different value entirely
+    /// Only one of the comparisons has any effect on the result, the programmer
+    /// probably intended to flip one of the comparison operators, or compare a
+    /// different value entirely.
     ///
     /// ### Example
     /// ```rust
-- 
cgit 1.4.1-3-g733a5


From f959ccc09b28b9aaa49b8282691b45564c9f1326 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Tue, 8 Aug 2023 17:19:53 +0200
Subject: [`redundant_guards`]: don't lint on floats

---
 clippy_lints/src/matches/redundant_guards.rs |  5 +++--
 tests/ui/redundant_guards.fixed              |  7 +++++++
 tests/ui/redundant_guards.rs                 |  7 +++++++
 tests/ui/redundant_guards.stderr             | 16 ++++++++--------
 4 files changed, 25 insertions(+), 10 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/redundant_guards.rs b/clippy_lints/src/matches/redundant_guards.rs
index 6383326aa38..0e7059caadb 100644
--- a/clippy_lints/src/matches/redundant_guards.rs
+++ b/clippy_lints/src/matches/redundant_guards.rs
@@ -2,6 +2,7 @@ use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::path_to_local;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::visitors::{for_each_expr, is_local_used};
+use rustc_ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::{Arm, BinOpKind, Expr, ExprKind, Guard, MatchSource, Node, Pat, PatKind};
@@ -177,8 +178,8 @@ fn expr_can_be_pat(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
             ExprKind::AddrOf(..)
             | ExprKind::Array(..)
             | ExprKind::Tup(..)
-            | ExprKind::Struct(..)
-            | ExprKind::Lit(..) => true,
+            | ExprKind::Struct(..) => true,
+            ExprKind::Lit(lit) if !matches!(lit.node, LitKind::Float(..)) => true,
             _ => false,
         } {
             return ControlFlow::Continue(());
diff --git a/tests/ui/redundant_guards.fixed b/tests/ui/redundant_guards.fixed
index 77ac7666864..2adedf3d029 100644
--- a/tests/ui/redundant_guards.fixed
+++ b/tests/ui/redundant_guards.fixed
@@ -15,6 +15,13 @@ struct B {
 
 struct C(u32, u32);
 
+fn issue11304() {
+    match 0.1 {
+        x if x == 0.0 => todo!(),
+        _ => todo!(),
+    }
+}
+
 fn main() {
     let c = C(1, 2);
     match c {
diff --git a/tests/ui/redundant_guards.rs b/tests/ui/redundant_guards.rs
index b072e4ea14d..cf285995214 100644
--- a/tests/ui/redundant_guards.rs
+++ b/tests/ui/redundant_guards.rs
@@ -15,6 +15,13 @@ struct B {
 
 struct C(u32, u32);
 
+fn issue11304() {
+    match 0.1 {
+        x if x == 0.0 => todo!(),
+        _ => todo!(),
+    }
+}
+
 fn main() {
     let c = C(1, 2);
     match c {
diff --git a/tests/ui/redundant_guards.stderr b/tests/ui/redundant_guards.stderr
index c2a92071d1d..f1b3fd08381 100644
--- a/tests/ui/redundant_guards.stderr
+++ b/tests/ui/redundant_guards.stderr
@@ -1,5 +1,5 @@
 error: redundant guard
-  --> $DIR/redundant_guards.rs:21:20
+  --> $DIR/redundant_guards.rs:28:20
    |
 LL |         C(x, y) if let 1 = y => ..,
    |                    ^^^^^^^^^
@@ -12,7 +12,7 @@ LL +         C(x, 1) => ..,
    |
 
 error: redundant guard
-  --> $DIR/redundant_guards.rs:27:20
+  --> $DIR/redundant_guards.rs:34:20
    |
 LL |         Some(x) if matches!(x, Some(1) if true) => ..,
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -23,7 +23,7 @@ LL |         Some(Some(1)) if true => ..,
    |              ~~~~~~~  ~~~~~~~
 
 error: redundant guard
-  --> $DIR/redundant_guards.rs:28:20
+  --> $DIR/redundant_guards.rs:35:20
    |
 LL |         Some(x) if matches!(x, Some(1)) => {
    |                    ^^^^^^^^^^^^^^^^^^^^
@@ -35,7 +35,7 @@ LL +         Some(Some(1)) => {
    |
 
 error: redundant guard
-  --> $DIR/redundant_guards.rs:32:20
+  --> $DIR/redundant_guards.rs:39:20
    |
 LL |         Some(x) if let Some(1) = x => ..,
    |                    ^^^^^^^^^^^^^^^
@@ -47,7 +47,7 @@ LL +         Some(Some(1)) => ..,
    |
 
 error: redundant guard
-  --> $DIR/redundant_guards.rs:33:20
+  --> $DIR/redundant_guards.rs:40:20
    |
 LL |         Some(x) if x == Some(2) => ..,
    |                    ^^^^^^^^^^^^
@@ -59,7 +59,7 @@ LL +         Some(Some(2)) => ..,
    |
 
 error: redundant guard
-  --> $DIR/redundant_guards.rs:56:20
+  --> $DIR/redundant_guards.rs:63:20
    |
 LL |         B { e } if matches!(e, Some(A(2))) => ..,
    |                    ^^^^^^^^^^^^^^^^^^^^^^^
@@ -71,7 +71,7 @@ LL +         B { e: Some(A(2)) } => ..,
    |
 
 error: redundant guard
-  --> $DIR/redundant_guards.rs:93:20
+  --> $DIR/redundant_guards.rs:100:20
    |
 LL |         E::A(y) if y == "not from an or pattern" => {},
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -83,7 +83,7 @@ LL +         E::A("not from an or pattern") => {},
    |
 
 error: redundant guard
-  --> $DIR/redundant_guards.rs:100:14
+  --> $DIR/redundant_guards.rs:107:14
    |
 LL |         x if matches!(x, Some(0)) => ..,
    |              ^^^^^^^^^^^^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From b6156502afc765bac1ef48242009fe03c53232cc Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Tue, 8 Aug 2023 17:52:17 +0200
Subject: document the new behavior and add test for float in struct

---
 clippy_lints/src/matches/redundant_guards.rs |  5 +++++
 tests/ui/redundant_guards.fixed              |  6 ++++++
 tests/ui/redundant_guards.rs                 |  6 ++++++
 tests/ui/redundant_guards.stderr             | 16 ++++++++--------
 4 files changed, 25 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/redundant_guards.rs b/clippy_lints/src/matches/redundant_guards.rs
index 0e7059caadb..29af4812351 100644
--- a/clippy_lints/src/matches/redundant_guards.rs
+++ b/clippy_lints/src/matches/redundant_guards.rs
@@ -161,6 +161,11 @@ fn emit_redundant_guards<'tcx>(
 }
 
 /// Checks if the given `Expr` can also be represented as a `Pat`.
+///
+/// All literals generally also work as patterns, however float literals are special.
+/// They are currently (as of 2023/08/08) still allowed in patterns, but that will become
+/// an error in the future, and rustc already actively warns against this (see rust#41620),
+/// so we don't consider those as usable within patterns for linting purposes.
 fn expr_can_be_pat(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
     for_each_expr(expr, |expr| {
         if match expr.kind {
diff --git a/tests/ui/redundant_guards.fixed b/tests/ui/redundant_guards.fixed
index 2adedf3d029..49d7336ee37 100644
--- a/tests/ui/redundant_guards.fixed
+++ b/tests/ui/redundant_guards.fixed
@@ -15,11 +15,17 @@ struct B {
 
 struct C(u32, u32);
 
+#[derive(PartialEq)]
+struct FloatWrapper(f32);
 fn issue11304() {
     match 0.1 {
         x if x == 0.0 => todo!(),
         _ => todo!(),
     }
+    match FloatWrapper(0.1) {
+        x if x == FloatWrapper(0.0) => todo!(),
+        _ => todo!(),
+    }
 }
 
 fn main() {
diff --git a/tests/ui/redundant_guards.rs b/tests/ui/redundant_guards.rs
index cf285995214..87761010de2 100644
--- a/tests/ui/redundant_guards.rs
+++ b/tests/ui/redundant_guards.rs
@@ -15,11 +15,17 @@ struct B {
 
 struct C(u32, u32);
 
+#[derive(PartialEq)]
+struct FloatWrapper(f32);
 fn issue11304() {
     match 0.1 {
         x if x == 0.0 => todo!(),
         _ => todo!(),
     }
+    match FloatWrapper(0.1) {
+        x if x == FloatWrapper(0.0) => todo!(),
+        _ => todo!(),
+    }
 }
 
 fn main() {
diff --git a/tests/ui/redundant_guards.stderr b/tests/ui/redundant_guards.stderr
index f1b3fd08381..5bdf43d23c5 100644
--- a/tests/ui/redundant_guards.stderr
+++ b/tests/ui/redundant_guards.stderr
@@ -1,5 +1,5 @@
 error: redundant guard
-  --> $DIR/redundant_guards.rs:28:20
+  --> $DIR/redundant_guards.rs:34:20
    |
 LL |         C(x, y) if let 1 = y => ..,
    |                    ^^^^^^^^^
@@ -12,7 +12,7 @@ LL +         C(x, 1) => ..,
    |
 
 error: redundant guard
-  --> $DIR/redundant_guards.rs:34:20
+  --> $DIR/redundant_guards.rs:40:20
    |
 LL |         Some(x) if matches!(x, Some(1) if true) => ..,
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -23,7 +23,7 @@ LL |         Some(Some(1)) if true => ..,
    |              ~~~~~~~  ~~~~~~~
 
 error: redundant guard
-  --> $DIR/redundant_guards.rs:35:20
+  --> $DIR/redundant_guards.rs:41:20
    |
 LL |         Some(x) if matches!(x, Some(1)) => {
    |                    ^^^^^^^^^^^^^^^^^^^^
@@ -35,7 +35,7 @@ LL +         Some(Some(1)) => {
    |
 
 error: redundant guard
-  --> $DIR/redundant_guards.rs:39:20
+  --> $DIR/redundant_guards.rs:45:20
    |
 LL |         Some(x) if let Some(1) = x => ..,
    |                    ^^^^^^^^^^^^^^^
@@ -47,7 +47,7 @@ LL +         Some(Some(1)) => ..,
    |
 
 error: redundant guard
-  --> $DIR/redundant_guards.rs:40:20
+  --> $DIR/redundant_guards.rs:46:20
    |
 LL |         Some(x) if x == Some(2) => ..,
    |                    ^^^^^^^^^^^^
@@ -59,7 +59,7 @@ LL +         Some(Some(2)) => ..,
    |
 
 error: redundant guard
-  --> $DIR/redundant_guards.rs:63:20
+  --> $DIR/redundant_guards.rs:69:20
    |
 LL |         B { e } if matches!(e, Some(A(2))) => ..,
    |                    ^^^^^^^^^^^^^^^^^^^^^^^
@@ -71,7 +71,7 @@ LL +         B { e: Some(A(2)) } => ..,
    |
 
 error: redundant guard
-  --> $DIR/redundant_guards.rs:100:20
+  --> $DIR/redundant_guards.rs:106:20
    |
 LL |         E::A(y) if y == "not from an or pattern" => {},
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -83,7 +83,7 @@ LL +         E::A("not from an or pattern") => {},
    |
 
 error: redundant guard
-  --> $DIR/redundant_guards.rs:107:14
+  --> $DIR/redundant_guards.rs:113:14
    |
 LL |         x if matches!(x, Some(0)) => ..,
    |              ^^^^^^^^^^^^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From 830bac554898fa6e3969876134324df4b41670c1 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Wed, 9 Aug 2023 14:00:06 +0200
Subject: clarify why `Vec::new()` + resize is worse than `vec![0; N]`

---
 clippy_lints/src/slow_vector_initialization.rs | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/slow_vector_initialization.rs b/clippy_lints/src/slow_vector_initialization.rs
index 54a33eb2986..2117bcae22c 100644
--- a/clippy_lints/src/slow_vector_initialization.rs
+++ b/clippy_lints/src/slow_vector_initialization.rs
@@ -20,6 +20,20 @@ declare_clippy_lint! {
     /// These structures are non-idiomatic and less efficient than simply using
     /// `vec![0; len]`.
     ///
+    /// More specifically, for `vec![0; len]`, the compiler can use a more specialized type of allocation
+    /// that also zero-initializes the allocated memory in the same call
+    /// (see: [alloc_zeroed](https://doc.rust-lang.org/stable/std/alloc/trait.GlobalAlloc.html#method.alloc_zeroed)).
+    ///
+    /// Writing `Vec::new()` followed by `vec.resize(len, 0)` is suboptimal because,
+    /// while it does do the same number of allocations,
+    /// it involves two operations for allocating and initializing.
+    /// The `resize` call first allocates memory (since `Vec::new()` did not), and only *then* zero-initializes it.
+    ///
+    /// Writing `Vec::with_capacity(size)` followed by `vec.resize(len, 0)` is similar.
+    /// The allocation shifts from `resize` to `with_capacity`,
+    /// but the zero-initialization still happens separately,
+    /// when it could be done in one call with `vec![0; len]` (`alloc_zeroed`).
+    ///
     /// ### Example
     /// ```rust
     /// # use core::iter::repeat;
@@ -32,6 +46,9 @@ declare_clippy_lint! {
     ///
     /// let mut vec2 = Vec::with_capacity(len);
     /// vec2.extend(repeat(0).take(len));
+    ///
+    /// let mut vec3 = Vec::new();
+    /// vec3.resize(len, 0);
     /// ```
     ///
     /// Use instead:
@@ -39,6 +56,7 @@ declare_clippy_lint! {
     /// # let len = 4;
     /// let mut vec1 = vec![0; len];
     /// let mut vec2 = vec![0; len];
+    /// let mut vec3 = vec![0; len];
     /// ```
     #[clippy::version = "1.32.0"]
     pub SLOW_VECTOR_INITIALIZATION,
-- 
cgit 1.4.1-3-g733a5


From d2acfb37b3344de3405457e02c4703cfc74bcb95 Mon Sep 17 00:00:00 2001
From: Timo <30553356+y21@users.noreply.github.com>
Date: Wed, 9 Aug 2023 14:44:42 +0200
Subject: Reword paragraph

Co-authored-by: Dirkjan Ochtman <dirkjan@ochtman.nl>
---
 clippy_lints/src/slow_vector_initialization.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/slow_vector_initialization.rs b/clippy_lints/src/slow_vector_initialization.rs
index 2117bcae22c..1001441b03d 100644
--- a/clippy_lints/src/slow_vector_initialization.rs
+++ b/clippy_lints/src/slow_vector_initialization.rs
@@ -20,7 +20,7 @@ declare_clippy_lint! {
     /// These structures are non-idiomatic and less efficient than simply using
     /// `vec![0; len]`.
     ///
-    /// More specifically, for `vec![0; len]`, the compiler can use a more specialized type of allocation
+    /// Specifically, for `vec![0; len]`, the compiler can use a specialized type of allocation
     /// that also zero-initializes the allocated memory in the same call
     /// (see: [alloc_zeroed](https://doc.rust-lang.org/stable/std/alloc/trait.GlobalAlloc.html#method.alloc_zeroed)).
     ///
-- 
cgit 1.4.1-3-g733a5


From dd25cc349be3dae9b7c7f1ad0465ab14fab773e3 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Wed, 9 Aug 2023 14:48:31 +0200
Subject: Remove unnecessary paragraph, move examples

---
 clippy_lints/src/slow_vector_initialization.rs | 16 ++++------------
 1 file changed, 4 insertions(+), 12 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/slow_vector_initialization.rs b/clippy_lints/src/slow_vector_initialization.rs
index 1001441b03d..c9ab622ad25 100644
--- a/clippy_lints/src/slow_vector_initialization.rs
+++ b/clippy_lints/src/slow_vector_initialization.rs
@@ -29,26 +29,18 @@ declare_clippy_lint! {
     /// it involves two operations for allocating and initializing.
     /// The `resize` call first allocates memory (since `Vec::new()` did not), and only *then* zero-initializes it.
     ///
-    /// Writing `Vec::with_capacity(size)` followed by `vec.resize(len, 0)` is similar.
-    /// The allocation shifts from `resize` to `with_capacity`,
-    /// but the zero-initialization still happens separately,
-    /// when it could be done in one call with `vec![0; len]` (`alloc_zeroed`).
-    ///
     /// ### Example
     /// ```rust
     /// # use core::iter::repeat;
     /// # let len = 4;
-    /// let mut vec1 = Vec::with_capacity(len);
+    /// let mut vec1 = Vec::new();
     /// vec1.resize(len, 0);
     ///
-    /// let mut vec1 = Vec::with_capacity(len);
-    /// vec1.resize(vec1.capacity(), 0);
-    ///
     /// let mut vec2 = Vec::with_capacity(len);
-    /// vec2.extend(repeat(0).take(len));
+    /// vec2.resize(len, 0);
     ///
-    /// let mut vec3 = Vec::new();
-    /// vec3.resize(len, 0);
+    /// let mut vec3 = Vec::with_capacity(len);
+    /// vec3.extend(repeat(0).take(len));
     /// ```
     ///
     /// Use instead:
-- 
cgit 1.4.1-3-g733a5


From 42186af21e7a0a0d410c40540b534c6c9f02b557 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Thu, 10 Aug 2023 16:06:17 +0200
Subject: Correctly handle async blocks for NEEDLESS_PASS_BY_REF_MUT

---
 clippy_lints/src/needless_pass_by_ref_mut.rs | 105 +++++++++++++++++++++------
 1 file changed, 82 insertions(+), 23 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/needless_pass_by_ref_mut.rs b/clippy_lints/src/needless_pass_by_ref_mut.rs
index c634de960d1..6eb17d675e9 100644
--- a/clippy_lints/src/needless_pass_by_ref_mut.rs
+++ b/clippy_lints/src/needless_pass_by_ref_mut.rs
@@ -5,14 +5,16 @@ use clippy_utils::{get_parent_node, inherits_cfg, is_from_proc_macro, is_self};
 use rustc_data_structures::fx::{FxHashSet, FxIndexMap};
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_qpath, FnKind, Visitor};
-use rustc_hir::{Body, ExprKind, FnDecl, HirId, HirIdMap, HirIdSet, Impl, ItemKind, Mutability, Node, PatKind, QPath};
+use rustc_hir::{
+    Body, Closure, Expr, ExprKind, FnDecl, HirId, HirIdMap, HirIdSet, Impl, ItemKind, Mutability, Node, PatKind, QPath,
+};
 use rustc_hir_typeck::expr_use_visitor as euv;
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::map::associated_body;
 use rustc_middle::hir::nested_filter::OnlyBodies;
 use rustc_middle::mir::FakeReadCause;
-use rustc_middle::ty::{self, Ty, UpvarId, UpvarPath};
+use rustc_middle::ty::{self, Ty, TyCtxt, UpvarId, UpvarPath};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::def_id::LocalDefId;
 use rustc_span::symbol::kw;
@@ -147,22 +149,36 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByRefMut<'tcx> {
         // Collect variables mutably used and spans which will need dereferencings from the
         // function body.
         let MutablyUsedVariablesCtxt { mutably_used_vars, .. } = {
-            let mut ctx = MutablyUsedVariablesCtxt::default();
+            let mut ctx = MutablyUsedVariablesCtxt {
+                mutably_used_vars: HirIdSet::default(),
+                prev_bind: None,
+                prev_move_to_closure: HirIdSet::default(),
+                aliases: HirIdMap::default(),
+                async_closures: FxHashSet::default(),
+                tcx: cx.tcx,
+            };
             let infcx = cx.tcx.infer_ctxt().build();
             euv::ExprUseVisitor::new(&mut ctx, &infcx, fn_def_id, cx.param_env, cx.typeck_results()).consume_body(body);
             if is_async {
-                let closures = ctx.async_closures.clone();
-                let hir = cx.tcx.hir();
-                for closure in closures {
-                    ctx.prev_bind = None;
-                    ctx.prev_move_to_closure.clear();
-                    if let Some(body) = hir
-                        .find_by_def_id(closure)
-                        .and_then(associated_body)
-                        .map(|(_, body_id)| hir.body(body_id))
-                    {
-                        euv::ExprUseVisitor::new(&mut ctx, &infcx, closure, cx.param_env, cx.typeck_results())
-                            .consume_body(body);
+                let mut checked_closures = FxHashSet::default();
+                while !ctx.async_closures.is_empty() {
+                    let closures = ctx.async_closures.clone();
+                    ctx.async_closures.clear();
+                    let hir = cx.tcx.hir();
+                    for closure in closures {
+                        if !checked_closures.insert(closure) {
+                            continue;
+                        }
+                        ctx.prev_bind = None;
+                        ctx.prev_move_to_closure.clear();
+                        if let Some(body) = hir
+                            .find_by_def_id(closure)
+                            .and_then(associated_body)
+                            .map(|(_, body_id)| hir.body(body_id))
+                        {
+                            euv::ExprUseVisitor::new(&mut ctx, &infcx, closure, cx.param_env, cx.typeck_results())
+                                .consume_body(body);
+                        }
                     }
                 }
             }
@@ -225,16 +241,16 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByRefMut<'tcx> {
     }
 }
 
-#[derive(Default)]
-struct MutablyUsedVariablesCtxt {
+struct MutablyUsedVariablesCtxt<'tcx> {
     mutably_used_vars: HirIdSet,
     prev_bind: Option<HirId>,
     prev_move_to_closure: HirIdSet,
     aliases: HirIdMap<HirId>,
     async_closures: FxHashSet<LocalDefId>,
+    tcx: TyCtxt<'tcx>,
 }
 
-impl MutablyUsedVariablesCtxt {
+impl<'tcx> MutablyUsedVariablesCtxt<'tcx> {
     fn add_mutably_used_var(&mut self, mut used_id: HirId) {
         while let Some(id) = self.aliases.get(&used_id) {
             self.mutably_used_vars.insert(used_id);
@@ -242,9 +258,27 @@ impl MutablyUsedVariablesCtxt {
         }
         self.mutably_used_vars.insert(used_id);
     }
+
+    fn would_be_alias_cycle(&self, alias: HirId, mut target: HirId) -> bool {
+        while let Some(id) = self.aliases.get(&target) {
+            if *id == alias {
+                return true;
+            }
+            target = *id;
+        }
+        false
+    }
+
+    fn add_alias(&mut self, alias: HirId, target: HirId) {
+        // This is to prevent alias loop.
+        if alias == target || self.would_be_alias_cycle(alias, target) {
+            return;
+        }
+        self.aliases.insert(alias, target);
+    }
 }
 
-impl<'tcx> euv::Delegate<'tcx> for MutablyUsedVariablesCtxt {
+impl<'tcx> euv::Delegate<'tcx> for MutablyUsedVariablesCtxt<'tcx> {
     fn consume(&mut self, cmt: &euv::PlaceWithHirId<'tcx>, _id: HirId) {
         if let euv::Place {
             base:
@@ -259,7 +293,7 @@ impl<'tcx> euv::Delegate<'tcx> for MutablyUsedVariablesCtxt {
         {
             if let Some(bind_id) = self.prev_bind.take() {
                 if bind_id != *vid {
-                    self.aliases.insert(bind_id, *vid);
+                    self.add_alias(bind_id, *vid);
                 }
             } else if !self.prev_move_to_closure.contains(vid)
                 && matches!(base_ty.ref_mutability(), Some(Mutability::Mut))
@@ -271,7 +305,7 @@ impl<'tcx> euv::Delegate<'tcx> for MutablyUsedVariablesCtxt {
         }
     }
 
-    fn borrow(&mut self, cmt: &euv::PlaceWithHirId<'tcx>, _id: HirId, borrow: ty::BorrowKind) {
+    fn borrow(&mut self, cmt: &euv::PlaceWithHirId<'tcx>, id: HirId, borrow: ty::BorrowKind) {
         self.prev_bind = None;
         if let euv::Place {
             base: euv::PlaceBase::Local(vid),
@@ -289,6 +323,25 @@ impl<'tcx> euv::Delegate<'tcx> for MutablyUsedVariablesCtxt {
             {
                 self.add_mutably_used_var(*vid);
             }
+        } else if borrow == ty::ImmBorrow {
+            // If there is an `async block`, it'll contain a call to a closure which we need to
+            // go into to ensure all "mutate" checks are found.
+            if let Node::Expr(Expr {
+                kind:
+                    ExprKind::Call(
+                        _,
+                        [
+                            Expr {
+                                kind: ExprKind::Closure(Closure { def_id, .. }),
+                                ..
+                            },
+                        ],
+                    ),
+                ..
+            }) = self.tcx.hir().get(id)
+            {
+                self.async_closures.insert(*def_id);
+            }
         }
     }
 
@@ -296,7 +349,12 @@ impl<'tcx> euv::Delegate<'tcx> for MutablyUsedVariablesCtxt {
         self.prev_bind = None;
         if let euv::Place {
             projections,
-            base: euv::PlaceBase::Local(vid),
+            base:
+                euv::PlaceBase::Local(vid)
+                | euv::PlaceBase::Upvar(UpvarId {
+                    var_path: UpvarPath { hir_id: vid },
+                    ..
+                }),
             ..
         } = &cmt.place
         {
@@ -329,8 +387,9 @@ impl<'tcx> euv::Delegate<'tcx> for MutablyUsedVariablesCtxt {
                 // Seems like we are inside an async function. We need to store the closure `DefId`
                 // to go through it afterwards.
                 self.async_closures.insert(inner);
-                self.aliases.insert(cmt.hir_id, *vid);
+                self.add_alias(cmt.hir_id, *vid);
                 self.prev_move_to_closure.insert(*vid);
+                self.prev_bind = None;
             }
         }
     }
-- 
cgit 1.4.1-3-g733a5


From beb57f074eb83643dde6ad960edadd3dbe4e6109 Mon Sep 17 00:00:00 2001
From: Catherine Flores <catherine.3.flores@gmail.com>
Date: Thu, 10 Aug 2023 16:21:35 -0500
Subject: Don't ICE with late bound regions

---
 clippy_lints/src/methods/filter_map_bool_then.rs | 14 +++++++++++---
 tests/ui/filter_map_bool_then.fixed              | 12 +++++++++++-
 tests/ui/filter_map_bool_then.rs                 | 12 +++++++++++-
 tests/ui/filter_map_bool_then.stderr             | 18 ++++++++++++------
 4 files changed, 45 insertions(+), 11 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/filter_map_bool_then.rs b/clippy_lints/src/methods/filter_map_bool_then.rs
index 4aee22a4afc..fafc9709770 100644
--- a/clippy_lints/src/methods/filter_map_bool_then.rs
+++ b/clippy_lints/src/methods/filter_map_bool_then.rs
@@ -1,3 +1,4 @@
+use super::FILTER_MAP_BOOL_THEN;
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::paths::BOOL_THEN;
 use clippy_utils::source::snippet_opt;
@@ -7,10 +8,9 @@ use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LintContext};
 use rustc_middle::lint::in_external_macro;
+use rustc_middle::ty::Binder;
 use rustc_span::{sym, Span};
 
-use super::FILTER_MAP_BOOL_THEN;
-
 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, arg: &Expr<'_>, call_span: Span) {
     if !in_external_macro(cx.sess(), expr.span)
         && is_trait_method(cx, expr, sym::Iterator)
@@ -21,7 +21,15 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, arg: &
         // `inputs` and `params` here as we need both the type and the span
         && let param_ty = closure.fn_decl.inputs[0]
         && let param = body.params[0]
-        && is_copy(cx, cx.typeck_results().node_type(param_ty.hir_id).peel_refs())
+        // Issue #11309
+        && let param_ty = cx.tcx.liberate_late_bound_regions(
+            closure.def_id.to_def_id(),
+            Binder::bind_with_vars(
+                cx.typeck_results().node_type(param_ty.hir_id),
+                cx.tcx.late_bound_vars(cx.tcx.hir().local_def_id_to_hir_id(closure.def_id)),
+            ),
+        )
+        && is_copy(cx, param_ty)
         && let ExprKind::MethodCall(_, recv, [then_arg], _) = value.kind
         && let ExprKind::Closure(then_closure) = then_arg.kind
         && let then_body = peel_blocks(cx.tcx.hir().body(then_closure.body).value)
diff --git a/tests/ui/filter_map_bool_then.fixed b/tests/ui/filter_map_bool_then.fixed
index 3e72fee4b07..b85e3659a4c 100644
--- a/tests/ui/filter_map_bool_then.fixed
+++ b/tests/ui/filter_map_bool_then.fixed
@@ -4,6 +4,7 @@
     clippy::clone_on_copy,
     clippy::map_identity,
     clippy::unnecessary_lazy_evaluations,
+    clippy::unnecessary_filter_map,
     unused
 )]
 #![warn(clippy::filter_map_bool_then)]
@@ -29,9 +30,14 @@ fn main() {
         .copied()
         .filter(|&i| i != 1000)
         .filter(|&i| (i.clone() % 2 == 0)).map(|i| i + 1);
+    // Despite this is non-copy, `is_copy` still returns true (at least now) because it's `&NonCopy`,
+    // and any `&` is `Copy`. So since we can dereference it in `filter` (since it's then `&&NonCopy`),
+    // we can lint this and still get the same input type.
+    let v = vec![NonCopy, NonCopy];
+    v.clone().iter().filter(|&i| (i == &NonCopy)).map(|i| i);
     // Do not lint
     let v = vec![NonCopy, NonCopy];
-    v.clone().iter().filter_map(|i| (i == &NonCopy).then(|| i));
+    v.clone().into_iter().filter_map(|i| (i == NonCopy).then(|| i));
     external! {
         let v = vec![1, 2, 3, 4, 5, 6];
         v.clone().into_iter().filter_map(|i| (i % 2 == 0).then(|| i + 1));
@@ -42,3 +48,7 @@ fn main() {
         v.clone().into_iter().filter_map(|i| (i % 2 == 0).then(|| i + 1));
     }
 }
+
+fn issue11309<'a>(iter: impl Iterator<Item = (&'a str, &'a str)>) -> Vec<&'a str> {
+    iter.filter_map(|(_, s): (&str, _)| Some(s)).collect()
+}
diff --git a/tests/ui/filter_map_bool_then.rs b/tests/ui/filter_map_bool_then.rs
index 38a04e57de4..c009b4e6ebe 100644
--- a/tests/ui/filter_map_bool_then.rs
+++ b/tests/ui/filter_map_bool_then.rs
@@ -4,6 +4,7 @@
     clippy::clone_on_copy,
     clippy::map_identity,
     clippy::unnecessary_lazy_evaluations,
+    clippy::unnecessary_filter_map,
     unused
 )]
 #![warn(clippy::filter_map_bool_then)]
@@ -29,9 +30,14 @@ fn main() {
         .copied()
         .filter(|&i| i != 1000)
         .filter_map(|i| (i.clone() % 2 == 0).then(|| i + 1));
-    // Do not lint
+    // Despite this is non-copy, `is_copy` still returns true (at least now) because it's `&NonCopy`,
+    // and any `&` is `Copy`. So since we can dereference it in `filter` (since it's then `&&NonCopy`),
+    // we can lint this and still get the same input type.
     let v = vec![NonCopy, NonCopy];
     v.clone().iter().filter_map(|i| (i == &NonCopy).then(|| i));
+    // Do not lint
+    let v = vec![NonCopy, NonCopy];
+    v.clone().into_iter().filter_map(|i| (i == NonCopy).then(|| i));
     external! {
         let v = vec![1, 2, 3, 4, 5, 6];
         v.clone().into_iter().filter_map(|i| (i % 2 == 0).then(|| i + 1));
@@ -42,3 +48,7 @@ fn main() {
         v.clone().into_iter().filter_map(|i| (i % 2 == 0).then(|| i + 1));
     }
 }
+
+fn issue11309<'a>(iter: impl Iterator<Item = (&'a str, &'a str)>) -> Vec<&'a str> {
+    iter.filter_map(|(_, s): (&str, _)| Some(s)).collect()
+}
diff --git a/tests/ui/filter_map_bool_then.stderr b/tests/ui/filter_map_bool_then.stderr
index b411cd83dfd..b47f8eac7f0 100644
--- a/tests/ui/filter_map_bool_then.stderr
+++ b/tests/ui/filter_map_bool_then.stderr
@@ -1,5 +1,5 @@
 error: usage of `bool::then` in `filter_map`
-  --> $DIR/filter_map_bool_then.rs:19:22
+  --> $DIR/filter_map_bool_then.rs:20:22
    |
 LL |     v.clone().iter().filter_map(|i| (i % 2 == 0).then(|| i + 1));
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `filter` then `map` instead: `filter(|&i| (i % 2 == 0)).map(|i| i + 1)`
@@ -7,28 +7,34 @@ LL |     v.clone().iter().filter_map(|i| (i % 2 == 0).then(|| i + 1));
    = note: `-D clippy::filter-map-bool-then` implied by `-D warnings`
 
 error: usage of `bool::then` in `filter_map`
-  --> $DIR/filter_map_bool_then.rs:20:27
+  --> $DIR/filter_map_bool_then.rs:21:27
    |
 LL |     v.clone().into_iter().filter_map(|i| (i % 2 == 0).then(|| i + 1));
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `filter` then `map` instead: `filter(|&i| (i % 2 == 0)).map(|i| i + 1)`
 
 error: usage of `bool::then` in `filter_map`
-  --> $DIR/filter_map_bool_then.rs:23:10
+  --> $DIR/filter_map_bool_then.rs:24:10
    |
 LL |         .filter_map(|i| -> Option<_> { (i % 2 == 0).then(|| i + 1) });
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `filter` then `map` instead: `filter(|&i| (i % 2 == 0)).map(|i| i + 1)`
 
 error: usage of `bool::then` in `filter_map`
-  --> $DIR/filter_map_bool_then.rs:27:10
+  --> $DIR/filter_map_bool_then.rs:28:10
    |
 LL |         .filter_map(|i| (i % 2 == 0).then(|| i + 1));
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `filter` then `map` instead: `filter(|&i| (i % 2 == 0)).map(|i| i + 1)`
 
 error: usage of `bool::then` in `filter_map`
-  --> $DIR/filter_map_bool_then.rs:31:10
+  --> $DIR/filter_map_bool_then.rs:32:10
    |
 LL |         .filter_map(|i| (i.clone() % 2 == 0).then(|| i + 1));
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `filter` then `map` instead: `filter(|&i| (i.clone() % 2 == 0)).map(|i| i + 1)`
 
-error: aborting due to 5 previous errors
+error: usage of `bool::then` in `filter_map`
+  --> $DIR/filter_map_bool_then.rs:37:22
+   |
+LL |     v.clone().iter().filter_map(|i| (i == &NonCopy).then(|| i));
+   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `filter` then `map` instead: `filter(|&i| (i == &NonCopy)).map(|i| i)`
+
+error: aborting due to 6 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From a5f62bdfcdf826c1b03603e9a5bc3a052db853c2 Mon Sep 17 00:00:00 2001
From: Max Niederman <max@maxniederman.com>
Date: Thu, 10 Aug 2023 19:42:59 -0700
Subject: redundant_locals: fix FPs on mutated shadows

When a mutable binding is shadowed by
a mutable binding of the same name in a different scope,
mutations in that scope have different meaning.
This commit fixes spurious `redundant_locals` emissions
on such locals.
---
 clippy_lints/src/redundant_locals.rs | 11 +++++++++++
 tests/ui/redundant_locals.rs         |  9 +++++++++
 tests/ui/redundant_locals.stderr     | 22 +++++++++++-----------
 3 files changed, 31 insertions(+), 11 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/redundant_locals.rs b/clippy_lints/src/redundant_locals.rs
index 140ae837a17..0fc297d9111 100644
--- a/clippy_lints/src/redundant_locals.rs
+++ b/clippy_lints/src/redundant_locals.rs
@@ -1,6 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::is_from_proc_macro;
 use clippy_utils::ty::needs_ordered_drop;
+use rustc_ast::Mutability;
 use rustc_hir::def::Res;
 use rustc_hir::{BindingAnnotation, ByRef, Expr, ExprKind, HirId, Local, Node, Pat, PatKind, QPath};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
@@ -60,6 +61,8 @@ impl<'tcx> LateLintPass<'tcx> for RedundantLocals {
             if let Node::Pat(binding_pat) = cx.tcx.hir().get(binding_id);
             // the previous binding has the same mutability
             if find_binding(binding_pat, ident).unwrap().1 == mutability;
+            // the local does not change the effect of assignments to the binding. see #11290
+            if !affects_assignments(cx, mutability, binding_id, local.hir_id);
             // the local does not affect the code's drop behavior
             if !affects_drop_behavior(cx, binding_id, local.hir_id, expr);
             // the local is user-controlled
@@ -92,6 +95,14 @@ fn find_binding(pat: &Pat<'_>, name: Ident) -> Option<BindingAnnotation> {
     ret
 }
 
+/// Check if a rebinding of a local changes the effect of assignments to the binding.
+fn affects_assignments(cx: &LateContext<'_>, mutability: Mutability, bind: HirId, rebind: HirId) -> bool {
+    let hir = cx.tcx.hir();
+
+    // the binding is mutable and the rebinding is in a different scope than the original binding
+    mutability == Mutability::Mut && hir.get_enclosing_scope(bind) != hir.get_enclosing_scope(rebind)
+}
+
 /// Check if a rebinding of a local affects the code's drop behavior.
 fn affects_drop_behavior<'tcx>(cx: &LateContext<'tcx>, bind: HirId, rebind: HirId, rebind_expr: &Expr<'tcx>) -> bool {
     let hir = cx.tcx.hir();
diff --git a/tests/ui/redundant_locals.rs b/tests/ui/redundant_locals.rs
index e74c78a50b6..80af38f47b8 100644
--- a/tests/ui/redundant_locals.rs
+++ b/tests/ui/redundant_locals.rs
@@ -27,6 +27,15 @@ fn downgraded_mutability() {
     let x = x;
 }
 
+// see #11290
+fn shadow_mutation() {
+    let mut x = 1;
+    {
+        let mut x = x;
+        x = 2;
+    }
+}
+
 fn coercion(par: &mut i32) {
     let par: &i32 = par;
 
diff --git a/tests/ui/redundant_locals.stderr b/tests/ui/redundant_locals.stderr
index df07dd2f453..587de057524 100644
--- a/tests/ui/redundant_locals.stderr
+++ b/tests/ui/redundant_locals.stderr
@@ -20,7 +20,7 @@ LL |     let mut x = x;
    = help: remove the redefinition of `x`
 
 error: redundant redefinition of a binding
-  --> $DIR/redundant_locals.rs:37:14
+  --> $DIR/redundant_locals.rs:46:14
    |
 LL | fn parameter(x: i32) {
    |              ^
@@ -30,7 +30,7 @@ LL |     let x = x;
    = help: remove the redefinition of `x`
 
 error: redundant redefinition of a binding
-  --> $DIR/redundant_locals.rs:42:9
+  --> $DIR/redundant_locals.rs:51:9
    |
 LL |     let x = 1;
    |         ^
@@ -40,7 +40,7 @@ LL |     let x = x;
    = help: remove the redefinition of `x`
 
 error: redundant redefinition of a binding
-  --> $DIR/redundant_locals.rs:43:9
+  --> $DIR/redundant_locals.rs:52:9
    |
 LL |     let x = x;
    |         ^
@@ -50,7 +50,7 @@ LL |     let x = x;
    = help: remove the redefinition of `x`
 
 error: redundant redefinition of a binding
-  --> $DIR/redundant_locals.rs:44:9
+  --> $DIR/redundant_locals.rs:53:9
    |
 LL |     let x = x;
    |         ^
@@ -60,7 +60,7 @@ LL |     let x = x;
    = help: remove the redefinition of `x`
 
 error: redundant redefinition of a binding
-  --> $DIR/redundant_locals.rs:45:9
+  --> $DIR/redundant_locals.rs:54:9
    |
 LL |     let x = x;
    |         ^
@@ -70,7 +70,7 @@ LL |     let x = x;
    = help: remove the redefinition of `x`
 
 error: redundant redefinition of a binding
-  --> $DIR/redundant_locals.rs:50:9
+  --> $DIR/redundant_locals.rs:59:9
    |
 LL |     let a = 1;
    |         ^
@@ -81,7 +81,7 @@ LL |     let a = a;
    = help: remove the redefinition of `a`
 
 error: redundant redefinition of a binding
-  --> $DIR/redundant_locals.rs:51:9
+  --> $DIR/redundant_locals.rs:60:9
    |
 LL |     let b = 2;
    |         ^
@@ -92,7 +92,7 @@ LL |     let b = b;
    = help: remove the redefinition of `b`
 
 error: redundant redefinition of a binding
-  --> $DIR/redundant_locals.rs:58:13
+  --> $DIR/redundant_locals.rs:67:13
    |
 LL |         let x = 1;
    |             ^
@@ -102,7 +102,7 @@ LL |         let x = x;
    = help: remove the redefinition of `x`
 
 error: redundant redefinition of a binding
-  --> $DIR/redundant_locals.rs:65:13
+  --> $DIR/redundant_locals.rs:74:13
    |
 LL |         let x = 1;
    |             ^
@@ -112,7 +112,7 @@ LL |         let x = x;
    = help: remove the redefinition of `x`
 
 error: redundant redefinition of a binding
-  --> $DIR/redundant_locals.rs:68:6
+  --> $DIR/redundant_locals.rs:77:6
    |
 LL |     |x: i32| {
    |      ^
@@ -122,7 +122,7 @@ LL |         let x = x;
    = help: remove the redefinition of `x`
 
 error: redundant redefinition of a binding
-  --> $DIR/redundant_locals.rs:85:9
+  --> $DIR/redundant_locals.rs:94:9
    |
 LL |     let x = 1;
    |         ^
-- 
cgit 1.4.1-3-g733a5


From 0fc051ddbaaa4daf567c46240c6effabcde176f5 Mon Sep 17 00:00:00 2001
From: Philipp Krones <hello@philkrones.com>
Date: Fri, 11 Aug 2023 10:51:18 +0200
Subject: Fix redundant_locals for Async desugaring

---
 clippy_lints/src/redundant_locals.rs | 2 ++
 1 file changed, 2 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/redundant_locals.rs b/clippy_lints/src/redundant_locals.rs
index 140ae837a17..1271cf38538 100644
--- a/clippy_lints/src/redundant_locals.rs
+++ b/clippy_lints/src/redundant_locals.rs
@@ -7,6 +7,7 @@ use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::symbol::Ident;
+use rustc_span::DesugaringKind;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -45,6 +46,7 @@ declare_lint_pass!(RedundantLocals => [REDUNDANT_LOCALS]);
 impl<'tcx> LateLintPass<'tcx> for RedundantLocals {
     fn check_local(&mut self, cx: &LateContext<'tcx>, local: &'tcx Local<'tcx>) {
         if_chain! {
+            if !local.span.is_desugaring(DesugaringKind::Async);
             // the pattern is a single by-value binding
             if let PatKind::Binding(BindingAnnotation(ByRef::No, mutability), _, ident, None) = local.pat.kind;
             // the binding is not type-ascribed
-- 
cgit 1.4.1-3-g733a5


From 621e76d2528e0872926305686041f6a935028db8 Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Mon, 31 Jul 2023 21:57:31 +0200
Subject: [new_without_default]: include `where` clauses in suggestion

Fix #11267
---
 clippy_lints/src/new_without_default.rs | 19 ++++++++++++++++---
 tests/ui/new_without_default.rs         | 18 ++++++++++++++++++
 tests/ui/new_without_default.stderr     | 22 +++++++++++++++++++++-
 3 files changed, 55 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/new_without_default.rs b/clippy_lints/src/new_without_default.rs
index cf7cd671dca..6900502e8e1 100644
--- a/clippy_lints/src/new_without_default.rs
+++ b/clippy_lints/src/new_without_default.rs
@@ -130,6 +130,11 @@ impl<'tcx> LateLintPass<'tcx> for NewWithoutDefault {
                                 }
 
                                 let generics_sugg = snippet(cx, generics.span, "");
+                                let where_clause_sugg = if generics.has_where_clause_predicates {
+                                    format!("\n{}\n", snippet(cx, generics.where_clause_span, ""))
+                                } else {
+                                    String::new()
+                                };
                                 let self_ty_fmt = self_ty.to_string();
                                 let self_type_snip = snippet(cx, impl_self_ty.span, &self_ty_fmt);
                                 span_lint_hir_and_then(
@@ -145,7 +150,11 @@ impl<'tcx> LateLintPass<'tcx> for NewWithoutDefault {
                                             cx,
                                             item.span,
                                             "try adding this",
-                                            &create_new_without_default_suggest_msg(&self_type_snip, &generics_sugg),
+                                            &create_new_without_default_suggest_msg(
+                                                &self_type_snip,
+                                                &generics_sugg,
+                                                &where_clause_sugg
+                                            ),
                                             Applicability::MaybeIncorrect,
                                         );
                                     },
@@ -159,10 +168,14 @@ impl<'tcx> LateLintPass<'tcx> for NewWithoutDefault {
     }
 }
 
-fn create_new_without_default_suggest_msg(self_type_snip: &str, generics_sugg: &str) -> String {
+fn create_new_without_default_suggest_msg(
+    self_type_snip: &str,
+    generics_sugg: &str,
+    where_clause_sugg: &str,
+) -> String {
     #[rustfmt::skip]
     format!(
-"impl{generics_sugg} Default for {self_type_snip} {{
+"impl{generics_sugg} Default for {self_type_snip}{where_clause_sugg} {{
     fn default() -> Self {{
         Self::new()
     }}
diff --git a/tests/ui/new_without_default.rs b/tests/ui/new_without_default.rs
index 7dbfa002d3f..bbd7a51d6b9 100644
--- a/tests/ui/new_without_default.rs
+++ b/tests/ui/new_without_default.rs
@@ -230,3 +230,21 @@ impl IgnoreLifetimeNew {
         Self
     }
 }
+
+// From issue #11267
+
+pub struct MyStruct<K, V>
+where
+    K: std::hash::Hash + Eq + PartialEq,
+{
+    _kv: Option<(K, V)>,
+}
+
+impl<K, V> MyStruct<K, V>
+where
+    K: std::hash::Hash + Eq + PartialEq,
+{
+    pub fn new() -> Self {
+        Self { _kv: None }
+    }
+}
diff --git a/tests/ui/new_without_default.stderr b/tests/ui/new_without_default.stderr
index 7641035d2a6..61973abcde8 100644
--- a/tests/ui/new_without_default.stderr
+++ b/tests/ui/new_without_default.stderr
@@ -120,5 +120,25 @@ LL +
 LL ~     impl<T> Foo<T> {
    |
 
-error: aborting due to 7 previous errors
+error: you should consider adding a `Default` implementation for `MyStruct<K, V>`
+  --> $DIR/new_without_default.rs:247:5
+   |
+LL | /     pub fn new() -> Self {
+LL | |         Self { _kv: None }
+LL | |     }
+   | |_____^
+   |
+help: try adding this
+   |
+LL + impl<K, V> Default for MyStruct<K, V>
+LL + where
+LL +     K: std::hash::Hash + Eq + PartialEq,
+LL +  {
+LL +     fn default() -> Self {
+LL +         Self::new()
+LL +     }
+LL + }
+   |
+
+error: aborting due to 8 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From f9b22e7b84df2bfef723fbb456349d1d5948d611 Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Tue, 1 Aug 2023 20:28:10 +0200
Subject: [new_without_default]: make the suggestion machine-applicable

Now that generics and lifetimes are output as expected, the lint
should be applicable.
---
 clippy_lints/src/new_without_default.rs |  2 +-
 tests/ui/new_without_default.fixed      | 28 +++++++++++++++++++++++++++-
 2 files changed, 28 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/new_without_default.rs b/clippy_lints/src/new_without_default.rs
index 6900502e8e1..f7f9dccfbce 100644
--- a/clippy_lints/src/new_without_default.rs
+++ b/clippy_lints/src/new_without_default.rs
@@ -155,7 +155,7 @@ impl<'tcx> LateLintPass<'tcx> for NewWithoutDefault {
                                                 &generics_sugg,
                                                 &where_clause_sugg
                                             ),
-                                            Applicability::MaybeIncorrect,
+                                            Applicability::MachineApplicable,
                                         );
                                     },
                                 );
diff --git a/tests/ui/new_without_default.fixed b/tests/ui/new_without_default.fixed
index 0c4283ad0c1..56359a4cbc3 100644
--- a/tests/ui/new_without_default.fixed
+++ b/tests/ui/new_without_default.fixed
@@ -102,7 +102,6 @@ impl<'c> LtKo<'c> {
     pub fn new() -> LtKo<'c> {
         unimplemented!()
     }
-    // FIXME: that suggestion is missing lifetimes
 }
 
 struct Private;
@@ -273,3 +272,30 @@ impl IgnoreLifetimeNew {
         Self
     }
 }
+
+// From issue #11267
+
+pub struct MyStruct<K, V>
+where
+    K: std::hash::Hash + Eq + PartialEq,
+{
+    _kv: Option<(K, V)>,
+}
+
+impl<K, V> Default for MyStruct<K, V>
+where
+    K: std::hash::Hash + Eq + PartialEq,
+ {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl<K, V> MyStruct<K, V>
+where
+    K: std::hash::Hash + Eq + PartialEq,
+{
+    pub fn new() -> Self {
+        Self { _kv: None }
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From d5dbee4aa0696374dcb99f7e13fa46721f759a8b Mon Sep 17 00:00:00 2001
From: unvalley <kirohi.code@gmail.com>
Date: Sat, 12 Aug 2023 18:20:44 +0900
Subject: feat: update manual_retain to lint binary_heap_retain

refactor: rename variable

chore: reorder

test: update naming for msrv
---
 clippy_lints/src/manual_retain.rs |  6 ++--
 clippy_utils/src/msrvs.rs         |  2 +-
 clippy_utils/src/paths.rs         |  1 +
 tests/ui/manual_retain.fixed      | 39 +++++++++++++++-------
 tests/ui/manual_retain.rs         | 39 +++++++++++++++-------
 tests/ui/manual_retain.stderr     | 68 ++++++++++++++++++++++++++-------------
 6 files changed, 106 insertions(+), 49 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_retain.rs b/clippy_lints/src/manual_retain.rs
index 5259066eb71..1a69a48c582 100644
--- a/clippy_lints/src/manual_retain.rs
+++ b/clippy_lints/src/manual_retain.rs
@@ -12,13 +12,15 @@ use rustc_semver::RustcVersion;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::symbol::sym;
 
-const ACCEPTABLE_METHODS: [&[&str]; 4] = [
+const ACCEPTABLE_METHODS: [&[&str]; 5] = [
+    &paths::BINARYHEAP_ITER,
     &paths::HASHSET_ITER,
     &paths::BTREESET_ITER,
     &paths::SLICE_INTO,
     &paths::VEC_DEQUE_ITER,
 ];
-const ACCEPTABLE_TYPES: [(rustc_span::Symbol, Option<RustcVersion>); 6] = [
+const ACCEPTABLE_TYPES: [(rustc_span::Symbol, Option<RustcVersion>); 7] = [
+    (sym::BinaryHeap, Some(msrvs::BINARY_HEAP_RETAIN)),
     (sym::BTreeSet, Some(msrvs::BTREE_SET_RETAIN)),
     (sym::BTreeMap, Some(msrvs::BTREE_MAP_RETAIN)),
     (sym::HashSet, Some(msrvs::HASH_SET_RETAIN)),
diff --git a/clippy_utils/src/msrvs.rs b/clippy_utils/src/msrvs.rs
index 3637476c408..0faff05eb23 100644
--- a/clippy_utils/src/msrvs.rs
+++ b/clippy_utils/src/msrvs.rs
@@ -20,7 +20,7 @@ macro_rules! msrv_aliases {
 // names may refer to stabilized feature flags or library items
 msrv_aliases! {
     1,71,0 { TUPLE_ARRAY_CONVERSIONS }
-    1,70,0 { OPTION_IS_SOME_AND }
+    1,70,0 { OPTION_IS_SOME_AND, BINARY_HEAP_RETAIN }
     1,68,0 { PATH_MAIN_SEPARATOR_STR }
     1,65,0 { LET_ELSE, POINTER_CAST_CONSTNESS }
     1,62,0 { BOOL_THEN_SOME, DEFAULT_ENUM_ATTRIBUTE }
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index 914ea85ac28..e72d063cfd9 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -15,6 +15,7 @@ pub const APPLICABILITY_VALUES: [[&str; 3]; 4] = [
 ];
 #[cfg(feature = "internal")]
 pub const DIAGNOSTIC_BUILDER: [&str; 3] = ["rustc_errors", "diagnostic_builder", "DiagnosticBuilder"];
+pub const BINARYHEAP_ITER: [&str; 5] = ["alloc", "collections", "binary_heap", "BinaryHeap", "iter"];
 pub const BTREEMAP_CONTAINS_KEY: [&str; 6] = ["alloc", "collections", "btree", "map", "BTreeMap", "contains_key"];
 pub const BTREEMAP_INSERT: [&str; 6] = ["alloc", "collections", "btree", "map", "BTreeMap", "insert"];
 pub const BTREESET_ITER: [&str; 6] = ["alloc", "collections", "btree", "set", "BTreeSet", "iter"];
diff --git a/tests/ui/manual_retain.fixed b/tests/ui/manual_retain.fixed
index 3afa2da6ab1..c856a4dc67a 100644
--- a/tests/ui/manual_retain.fixed
+++ b/tests/ui/manual_retain.fixed
@@ -17,22 +17,31 @@ fn main() {
 }
 
 fn binary_heap_retain() {
-    // NOTE: Do not lint now, because binary_heap_retain is nightly API.
-    // And we need to add a test case for msrv if we update this implementation.
-    // https://github.com/rust-lang/rust/issues/71503
-    let mut heap = BinaryHeap::from([1, 2, 3]);
-    heap = heap.into_iter().filter(|x| x % 2 == 0).collect();
-    heap = heap.iter().filter(|&x| x % 2 == 0).copied().collect();
-    heap = heap.iter().filter(|&x| x % 2 == 0).cloned().collect();
+    let mut binary_heap = BinaryHeap::from([1, 2, 3]);
+    // Do lint.
+    binary_heap.retain(|x| x % 2 == 0);
+    binary_heap.retain(|x| x % 2 == 0);
+    binary_heap.retain(|x| x % 2 == 0);
 
     // Do not lint, because type conversion is performed
-    heap = heap.into_iter().filter(|x| x % 2 == 0).collect::<BinaryHeap<i8>>();
-    heap = heap.iter().filter(|&x| x % 2 == 0).copied().collect::<BinaryHeap<i8>>();
-    heap = heap.iter().filter(|&x| x % 2 == 0).cloned().collect::<BinaryHeap<i8>>();
+    binary_heap = binary_heap
+        .into_iter()
+        .filter(|x| x % 2 == 0)
+        .collect::<BinaryHeap<i8>>();
+    binary_heap = binary_heap
+        .iter()
+        .filter(|&x| x % 2 == 0)
+        .copied()
+        .collect::<BinaryHeap<i8>>();
+    binary_heap = binary_heap
+        .iter()
+        .filter(|&x| x % 2 == 0)
+        .cloned()
+        .collect::<BinaryHeap<i8>>();
 
     // Do not lint, because this expression is not assign.
-    let mut bar: BinaryHeap<i8> = heap.iter().filter(|&x| x % 2 == 0).copied().collect();
-    let mut foobar: BinaryHeap<i8> = heap.into_iter().filter(|x| x % 2 == 0).collect();
+    let mut bar: BinaryHeap<i8> = binary_heap.iter().filter(|&x| x % 2 == 0).copied().collect();
+    let mut foobar: BinaryHeap<i8> = binary_heap.into_iter().filter(|x| x % 2 == 0).collect();
 
     // Do not lint, because it is an assignment to a different variable.
     bar = foobar.iter().filter(|&x| x % 2 == 0).copied().collect();
@@ -209,6 +218,12 @@ fn vec_deque_retain() {
     bar = foobar.into_iter().filter(|x| x % 2 == 0).collect();
 }
 
+#[clippy::msrv = "1.70"]
+fn _msrv_170() {
+    let mut binary_heap = BinaryHeap::from([1, 2, 3]);
+    binary_heap.retain(|x| x % 2 == 0);
+}
+
 #[clippy::msrv = "1.52"]
 fn _msrv_153() {
     let mut btree_map: BTreeMap<i8, i8> = (0..8).map(|x| (x, x * 10)).collect();
diff --git a/tests/ui/manual_retain.rs b/tests/ui/manual_retain.rs
index 43460da5eb0..7f92eede94e 100644
--- a/tests/ui/manual_retain.rs
+++ b/tests/ui/manual_retain.rs
@@ -17,22 +17,31 @@ fn main() {
 }
 
 fn binary_heap_retain() {
-    // NOTE: Do not lint now, because binary_heap_retain is nightly API.
-    // And we need to add a test case for msrv if we update this implementation.
-    // https://github.com/rust-lang/rust/issues/71503
-    let mut heap = BinaryHeap::from([1, 2, 3]);
-    heap = heap.into_iter().filter(|x| x % 2 == 0).collect();
-    heap = heap.iter().filter(|&x| x % 2 == 0).copied().collect();
-    heap = heap.iter().filter(|&x| x % 2 == 0).cloned().collect();
+    let mut binary_heap = BinaryHeap::from([1, 2, 3]);
+    // Do lint.
+    binary_heap = binary_heap.into_iter().filter(|x| x % 2 == 0).collect();
+    binary_heap = binary_heap.iter().filter(|&x| x % 2 == 0).copied().collect();
+    binary_heap = binary_heap.iter().filter(|&x| x % 2 == 0).cloned().collect();
 
     // Do not lint, because type conversion is performed
-    heap = heap.into_iter().filter(|x| x % 2 == 0).collect::<BinaryHeap<i8>>();
-    heap = heap.iter().filter(|&x| x % 2 == 0).copied().collect::<BinaryHeap<i8>>();
-    heap = heap.iter().filter(|&x| x % 2 == 0).cloned().collect::<BinaryHeap<i8>>();
+    binary_heap = binary_heap
+        .into_iter()
+        .filter(|x| x % 2 == 0)
+        .collect::<BinaryHeap<i8>>();
+    binary_heap = binary_heap
+        .iter()
+        .filter(|&x| x % 2 == 0)
+        .copied()
+        .collect::<BinaryHeap<i8>>();
+    binary_heap = binary_heap
+        .iter()
+        .filter(|&x| x % 2 == 0)
+        .cloned()
+        .collect::<BinaryHeap<i8>>();
 
     // Do not lint, because this expression is not assign.
-    let mut bar: BinaryHeap<i8> = heap.iter().filter(|&x| x % 2 == 0).copied().collect();
-    let mut foobar: BinaryHeap<i8> = heap.into_iter().filter(|x| x % 2 == 0).collect();
+    let mut bar: BinaryHeap<i8> = binary_heap.iter().filter(|&x| x % 2 == 0).copied().collect();
+    let mut foobar: BinaryHeap<i8> = binary_heap.into_iter().filter(|x| x % 2 == 0).collect();
 
     // Do not lint, because it is an assignment to a different variable.
     bar = foobar.iter().filter(|&x| x % 2 == 0).copied().collect();
@@ -215,6 +224,12 @@ fn vec_deque_retain() {
     bar = foobar.into_iter().filter(|x| x % 2 == 0).collect();
 }
 
+#[clippy::msrv = "1.70"]
+fn _msrv_170() {
+    let mut binary_heap = BinaryHeap::from([1, 2, 3]);
+    binary_heap = binary_heap.into_iter().filter(|x| x % 2 == 0).collect();
+}
+
 #[clippy::msrv = "1.52"]
 fn _msrv_153() {
     let mut btree_map: BTreeMap<i8, i8> = (0..8).map(|x| (x, x * 10)).collect();
diff --git a/tests/ui/manual_retain.stderr b/tests/ui/manual_retain.stderr
index 8b5f9f3a30e..6b8ec4d68b2 100644
--- a/tests/ui/manual_retain.stderr
+++ b/tests/ui/manual_retain.stderr
@@ -1,19 +1,37 @@
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/manual_retain.rs:45:5
+  --> $DIR/manual_retain.rs:22:5
    |
-LL |     btree_map = btree_map.into_iter().filter(|(k, _)| k % 2 == 0).collect();
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `btree_map.retain(|k, _| k % 2 == 0)`
+LL |     binary_heap = binary_heap.into_iter().filter(|x| x % 2 == 0).collect();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `binary_heap.retain(|x| x % 2 == 0)`
    |
    = note: `-D clippy::manual-retain` implied by `-D warnings`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/manual_retain.rs:46:5
+  --> $DIR/manual_retain.rs:23:5
+   |
+LL |     binary_heap = binary_heap.iter().filter(|&x| x % 2 == 0).copied().collect();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `binary_heap.retain(|x| x % 2 == 0)`
+
+error: this expression can be written more simply using `.retain()`
+  --> $DIR/manual_retain.rs:24:5
+   |
+LL |     binary_heap = binary_heap.iter().filter(|&x| x % 2 == 0).cloned().collect();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `binary_heap.retain(|x| x % 2 == 0)`
+
+error: this expression can be written more simply using `.retain()`
+  --> $DIR/manual_retain.rs:54:5
+   |
+LL |     btree_map = btree_map.into_iter().filter(|(k, _)| k % 2 == 0).collect();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `btree_map.retain(|k, _| k % 2 == 0)`
+
+error: this expression can be written more simply using `.retain()`
+  --> $DIR/manual_retain.rs:55:5
    |
 LL |     btree_map = btree_map.into_iter().filter(|(_, v)| v % 2 == 0).collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `btree_map.retain(|_, &mut v| v % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/manual_retain.rs:47:5
+  --> $DIR/manual_retain.rs:56:5
    |
 LL | /     btree_map = btree_map
 LL | |         .into_iter()
@@ -22,37 +40,37 @@ LL | |         .collect();
    | |__________________^ help: consider calling `.retain()` instead: `btree_map.retain(|k, &mut v| (k % 2 == 0) && (v % 2 == 0))`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/manual_retain.rs:69:5
+  --> $DIR/manual_retain.rs:78:5
    |
 LL |     btree_set = btree_set.iter().filter(|&x| x % 2 == 0).copied().collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `btree_set.retain(|x| x % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/manual_retain.rs:70:5
+  --> $DIR/manual_retain.rs:79:5
    |
 LL |     btree_set = btree_set.iter().filter(|&x| x % 2 == 0).cloned().collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `btree_set.retain(|x| x % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/manual_retain.rs:71:5
+  --> $DIR/manual_retain.rs:80:5
    |
 LL |     btree_set = btree_set.into_iter().filter(|x| x % 2 == 0).collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `btree_set.retain(|x| x % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/manual_retain.rs:101:5
+  --> $DIR/manual_retain.rs:110:5
    |
 LL |     hash_map = hash_map.into_iter().filter(|(k, _)| k % 2 == 0).collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `hash_map.retain(|k, _| k % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/manual_retain.rs:102:5
+  --> $DIR/manual_retain.rs:111:5
    |
 LL |     hash_map = hash_map.into_iter().filter(|(_, v)| v % 2 == 0).collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `hash_map.retain(|_, &mut v| v % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/manual_retain.rs:103:5
+  --> $DIR/manual_retain.rs:112:5
    |
 LL | /     hash_map = hash_map
 LL | |         .into_iter()
@@ -61,64 +79,70 @@ LL | |         .collect();
    | |__________________^ help: consider calling `.retain()` instead: `hash_map.retain(|k, &mut v| (k % 2 == 0) && (v % 2 == 0))`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/manual_retain.rs:124:5
+  --> $DIR/manual_retain.rs:133:5
    |
 LL |     hash_set = hash_set.into_iter().filter(|x| x % 2 == 0).collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `hash_set.retain(|x| x % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/manual_retain.rs:125:5
+  --> $DIR/manual_retain.rs:134:5
    |
 LL |     hash_set = hash_set.iter().filter(|&x| x % 2 == 0).copied().collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `hash_set.retain(|x| x % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/manual_retain.rs:126:5
+  --> $DIR/manual_retain.rs:135:5
    |
 LL |     hash_set = hash_set.iter().filter(|&x| x % 2 == 0).cloned().collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `hash_set.retain(|x| x % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/manual_retain.rs:155:5
+  --> $DIR/manual_retain.rs:164:5
    |
 LL |     s = s.chars().filter(|&c| c != 'o').to_owned().collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `s.retain(|c| c != 'o')`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/manual_retain.rs:167:5
+  --> $DIR/manual_retain.rs:176:5
    |
 LL |     vec = vec.iter().filter(|&x| x % 2 == 0).copied().collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `vec.retain(|x| x % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/manual_retain.rs:168:5
+  --> $DIR/manual_retain.rs:177:5
    |
 LL |     vec = vec.iter().filter(|&x| x % 2 == 0).cloned().collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `vec.retain(|x| x % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/manual_retain.rs:169:5
+  --> $DIR/manual_retain.rs:178:5
    |
 LL |     vec = vec.into_iter().filter(|x| x % 2 == 0).collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `vec.retain(|x| x % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/manual_retain.rs:191:5
+  --> $DIR/manual_retain.rs:200:5
    |
 LL |     vec_deque = vec_deque.iter().filter(|&x| x % 2 == 0).copied().collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `vec_deque.retain(|x| x % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/manual_retain.rs:192:5
+  --> $DIR/manual_retain.rs:201:5
    |
 LL |     vec_deque = vec_deque.iter().filter(|&x| x % 2 == 0).cloned().collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `vec_deque.retain(|x| x % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/manual_retain.rs:193:5
+  --> $DIR/manual_retain.rs:202:5
    |
 LL |     vec_deque = vec_deque.into_iter().filter(|x| x % 2 == 0).collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `vec_deque.retain(|x| x % 2 == 0)`
 
-error: aborting due to 19 previous errors
+error: this expression can be written more simply using `.retain()`
+  --> $DIR/manual_retain.rs:230:5
+   |
+LL |     binary_heap = binary_heap.into_iter().filter(|x| x % 2 == 0).collect();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `binary_heap.retain(|x| x % 2 == 0)`
+
+error: aborting due to 23 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From fc061890d6b1a2715d30e99e36ae4305f473c43c Mon Sep 17 00:00:00 2001
From: lengyijun <sjtu5140809011@gmail.com>
Date: Thu, 3 Aug 2023 11:37:23 +0800
Subject: [`iter_overeager_cloned`]: detect .cloned().filter() and
 .cloned().find()

Key idea:
```
// before
iter.cloned().filter(|x| unimplemented!() )
// after
iter.filter(|&x| unimplemented!() ).cloned()

// before
iter.cloned().filter( foo )
// after
iter.filter(|&x| foo(x) ).cloned()
```
---
 clippy_lints/src/methods/iter_overeager_cloned.rs | 53 ++++++++++++++----
 clippy_lints/src/methods/mod.rs                   | 24 ++++++---
 tests/ui/iter_overeager_cloned.fixed              | 40 ++++++++++++--
 tests/ui/iter_overeager_cloned.rs                 | 38 +++++++++++--
 tests/ui/iter_overeager_cloned.stderr             | 66 ++++++++++++++++++++++-
 5 files changed, 193 insertions(+), 28 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/iter_overeager_cloned.rs b/clippy_lints/src/methods/iter_overeager_cloned.rs
index 9f7ec19aa59..4b1ca0d9b9c 100644
--- a/clippy_lints/src/methods/iter_overeager_cloned.rs
+++ b/clippy_lints/src/methods/iter_overeager_cloned.rs
@@ -2,7 +2,7 @@ use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::{implements_trait, is_copy};
 use rustc_errors::Applicability;
-use rustc_hir::Expr;
+use rustc_hir::{Expr, ExprKind};
 use rustc_lint::LateContext;
 use rustc_middle::ty;
 use rustc_span::sym;
@@ -10,12 +10,28 @@ use rustc_span::sym;
 use super::ITER_OVEREAGER_CLONED;
 use crate::redundant_clone::REDUNDANT_CLONE;
 
+#[derive(Clone, Copy)]
+pub(super) enum Op<'a> {
+    // rm `.cloned()`
+    // e.g. `count`
+    RmCloned,
+
+    // later `.cloned()`
+    // and add `&` to the parameter of closure parameter
+    // e.g. `find` `filter`
+    FixClosure(&'a str, &'a Expr<'a>),
+
+    // later `.cloned()`
+    // e.g. `skip` `take`
+    LaterCloned,
+}
+
 pub(super) fn check<'tcx>(
     cx: &LateContext<'tcx>,
     expr: &'tcx Expr<'_>,
     cloned_call: &'tcx Expr<'_>,
     cloned_recv: &'tcx Expr<'_>,
-    is_count: bool,
+    op: Op<'tcx>,
     needs_into_iter: bool,
 ) {
     let typeck = cx.typeck_results();
@@ -35,10 +51,9 @@ pub(super) fn check<'tcx>(
             return;
         }
 
-        let (lint, msg, trailing_clone) = if is_count {
-            (REDUNDANT_CLONE, "unneeded cloning of iterator items", "")
-        } else {
-            (ITER_OVEREAGER_CLONED, "unnecessarily eager cloning of iterator items", ".cloned()")
+        let (lint, msg, trailing_clone) = match op {
+            Op::RmCloned => (REDUNDANT_CLONE, "unneeded cloning of iterator items", ""),
+            Op::LaterCloned | Op::FixClosure(_, _) => (ITER_OVEREAGER_CLONED, "unnecessarily eager cloning of iterator items", ".cloned()"),
         };
 
         span_lint_and_then(
@@ -47,11 +62,27 @@ pub(super) fn check<'tcx>(
             expr.span,
             msg,
             |diag| {
-                let method_span = expr.span.with_lo(cloned_call.span.hi());
-                if let Some(mut snip) = snippet_opt(cx, method_span) {
-                    snip.push_str(trailing_clone);
-                    let replace_span = expr.span.with_lo(cloned_recv.span.hi());
-                    diag.span_suggestion(replace_span, "try", snip, Applicability::MachineApplicable);
+                match op {
+                    Op::RmCloned | Op::LaterCloned => {
+                        let method_span = expr.span.with_lo(cloned_call.span.hi());
+                        if let Some(mut snip) = snippet_opt(cx, method_span) {
+                            snip.push_str(trailing_clone);
+                            let replace_span = expr.span.with_lo(cloned_recv.span.hi());
+                            diag.span_suggestion(replace_span, "try", snip, Applicability::MachineApplicable);
+                        }
+                    }
+                    Op::FixClosure(name, predicate_expr) => {
+                        if let Some(predicate) = snippet_opt(cx, predicate_expr.span) {
+                            let new_closure = if let ExprKind::Closure(_) = predicate_expr.kind {
+                                predicate.replacen('|', "|&", 1)
+                            } else {
+                                format!("|&x| {predicate}(x)")
+                            };
+                            let snip = format!(".{name}({new_closure}).cloned()" );
+                            let replace_span = expr.span.with_lo(cloned_recv.span.hi());
+                            diag.span_suggestion(replace_span, "try", snip, Applicability::MachineApplicable);
+                        }
+                    }
                 }
             }
         );
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 42756b27d01..729eda37af6 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3919,7 +3919,7 @@ impl Methods {
                     }
                 },
                 ("count", []) if is_trait_method(cx, expr, sym::Iterator) => match method_call(recv) {
-                    Some(("cloned", recv2, [], _, _)) => iter_overeager_cloned::check(cx, expr, recv, recv2, true, false),
+                    Some(("cloned", recv2, [], _, _)) => iter_overeager_cloned::check(cx, expr, recv, recv2, iter_overeager_cloned::Op::RmCloned , false),
                     Some((name2 @ ("into_iter" | "iter" | "iter_mut"), recv2, [], _, _)) => {
                         iter_count::check(cx, expr, recv2, name2);
                     },
@@ -3973,6 +3973,13 @@ impl Methods {
                     string_extend_chars::check(cx, expr, recv, arg);
                     extend_with_drain::check(cx, expr, recv, arg);
                 },
+                (name @ ( "filter" | "find" ) , [arg]) => {
+                    if let Some(("cloned", recv2, [], _span2, _)) = method_call(recv) {
+                        // if `arg` has side-effect, the semantic will change
+                        iter_overeager_cloned::check(cx, expr, recv, recv2,
+                                iter_overeager_cloned::Op::FixClosure(name, arg), false);
+                    }
+                }
                 ("filter_map", [arg]) => {
                     unnecessary_filter_map::check(cx, expr, arg, name);
                     filter_map_bool_then::check(cx, expr, arg, call_span);
@@ -3987,7 +3994,7 @@ impl Methods {
                 },
                 ("flatten", []) => match method_call(recv) {
                     Some(("map", recv, [map_arg], map_span, _)) => map_flatten::check(cx, expr, recv, map_arg, map_span),
-                    Some(("cloned", recv2, [], _, _)) => iter_overeager_cloned::check(cx, expr, recv, recv2, false, true),
+                    Some(("cloned", recv2, [], _, _)) => iter_overeager_cloned::check(cx, expr, recv, recv2, iter_overeager_cloned::Op::LaterCloned , true),
                     _ => {},
                 },
                 ("fold", [init, acc]) => {
@@ -4021,7 +4028,8 @@ impl Methods {
                 },
                 ("last", []) => {
                     if let Some(("cloned", recv2, [], _span2, _)) = method_call(recv) {
-                        iter_overeager_cloned::check(cx, expr, recv, recv2, false, false);
+                        iter_overeager_cloned::check(cx, expr, recv, recv2,
+                                iter_overeager_cloned::Op::LaterCloned , false);
                     }
                 },
                 ("lock", []) => {
@@ -4058,7 +4066,7 @@ impl Methods {
                 ("next", []) => {
                     if let Some((name2, recv2, args2, _, _)) = method_call(recv) {
                         match (name2, args2) {
-                            ("cloned", []) => iter_overeager_cloned::check(cx, expr, recv, recv2, false, false),
+                            ("cloned", []) => iter_overeager_cloned::check(cx, expr, recv, recv2, iter_overeager_cloned::Op::LaterCloned, false),
                             ("filter", [arg]) => filter_next::check(cx, expr, recv2, arg),
                             ("filter_map", [arg]) => filter_map_next::check(cx, expr, recv2, arg, &self.msrv),
                             ("iter", []) => iter_next_slice::check(cx, expr, recv2),
@@ -4071,7 +4079,7 @@ impl Methods {
                 },
                 ("nth", [n_arg]) => match method_call(recv) {
                     Some(("bytes", recv2, [], _, _)) => bytes_nth::check(cx, expr, recv2, n_arg),
-                    Some(("cloned", recv2, [], _, _)) => iter_overeager_cloned::check(cx, expr, recv, recv2, false, false),
+                    Some(("cloned", recv2, [], _, _)) => iter_overeager_cloned::check(cx, expr, recv, recv2, iter_overeager_cloned::Op::LaterCloned , false),
                     Some(("iter", recv2, [], _, _)) => iter_nth::check(cx, expr, recv2, recv, n_arg, false),
                     Some(("iter_mut", recv2, [], _, _)) => iter_nth::check(cx, expr, recv2, recv, n_arg, true),
                     _ => iter_nth_zero::check(cx, expr, recv, n_arg),
@@ -4126,7 +4134,8 @@ impl Methods {
                     iter_skip_zero::check(cx, expr, arg);
 
                     if let Some(("cloned", recv2, [], _span2, _)) = method_call(recv) {
-                        iter_overeager_cloned::check(cx, expr, recv, recv2, false, false);
+                        iter_overeager_cloned::check(cx, expr, recv, recv2,
+                                iter_overeager_cloned::Op::LaterCloned , false);
                     }
                 }
                 ("sort", []) => {
@@ -4152,7 +4161,8 @@ impl Methods {
                 ("step_by", [arg]) => iterator_step_by_zero::check(cx, expr, arg),
                 ("take", [_arg]) => {
                     if let Some(("cloned", recv2, [], _span2, _)) = method_call(recv) {
-                        iter_overeager_cloned::check(cx, expr, recv, recv2, false, false);
+                        iter_overeager_cloned::check(cx, expr, recv, recv2,
+                                iter_overeager_cloned::Op::LaterCloned, false);
                     }
                 },
                 ("take", []) => needless_option_take::check(cx, expr, recv),
diff --git a/tests/ui/iter_overeager_cloned.fixed b/tests/ui/iter_overeager_cloned.fixed
index ba26fe33d89..9605b449b40 100644
--- a/tests/ui/iter_overeager_cloned.fixed
+++ b/tests/ui/iter_overeager_cloned.fixed
@@ -20,8 +20,41 @@ fn main() {
         .iter()
         .flatten().cloned();
 
-    // Not implemented yet
-    let _ = vec.iter().cloned().filter(|x| x.starts_with('2'));
+    let _ = vec.iter().filter(|&x| x.starts_with('2')).cloned();
+
+    let _ = vec.iter().find(|&x| x == "2").cloned();
+
+    {
+        let f = |x: &String| x.starts_with('2');
+        let _ = vec.iter().filter(|&x| f(x)).cloned();
+        let _ = vec.iter().find(|&x| f(x)).cloned();
+    }
+
+    {
+        let vec: Vec<(String, String)> = vec![];
+        let f = move |x: &(String, String)| x.0.starts_with('2');
+        let _ = vec.iter().filter(|&x| f(x)).cloned();
+        let _ = vec.iter().find(|&x| f(x)).cloned();
+    }
+
+    fn test_move<'a>(
+        iter: impl Iterator<Item = &'a (&'a u32, String)> + 'a,
+        target: String,
+    ) -> impl Iterator<Item = (&'a u32, String)> + 'a {
+        iter.filter(move |&(&a, b)| a == 1 && b == &target).cloned()
+    }
+
+    {
+        #[derive(Clone)]
+        struct S<'a> {
+            a: &'a u32,
+            b: String,
+        }
+
+        fn bar<'a>(iter: impl Iterator<Item = &'a S<'a>> + 'a, target: String) -> impl Iterator<Item = S<'a>> + 'a {
+            iter.filter(move |&S { a, b }| **a == 1 && b == &target).cloned()
+        }
+    }
 
     // Not implemented yet
     let _ = vec.iter().cloned().map(|x| x.len());
@@ -29,9 +62,6 @@ fn main() {
     // This would fail if changed.
     let _ = vec.iter().cloned().map(|x| x + "2");
 
-    // Not implemented yet
-    let _ = vec.iter().cloned().find(|x| x == "2");
-
     // Not implemented yet
     let _ = vec.iter().cloned().for_each(|x| assert!(!x.is_empty()));
 
diff --git a/tests/ui/iter_overeager_cloned.rs b/tests/ui/iter_overeager_cloned.rs
index 2d3c4ea7c20..8d75f039d44 100644
--- a/tests/ui/iter_overeager_cloned.rs
+++ b/tests/ui/iter_overeager_cloned.rs
@@ -21,18 +21,48 @@ fn main() {
         .cloned()
         .flatten();
 
-    // Not implemented yet
     let _ = vec.iter().cloned().filter(|x| x.starts_with('2'));
 
+    let _ = vec.iter().cloned().find(|x| x == "2");
+
+    {
+        let f = |x: &String| x.starts_with('2');
+        let _ = vec.iter().cloned().filter(f);
+        let _ = vec.iter().cloned().find(f);
+    }
+
+    {
+        let vec: Vec<(String, String)> = vec![];
+        let f = move |x: &(String, String)| x.0.starts_with('2');
+        let _ = vec.iter().cloned().filter(f);
+        let _ = vec.iter().cloned().find(f);
+    }
+
+    fn test_move<'a>(
+        iter: impl Iterator<Item = &'a (&'a u32, String)> + 'a,
+        target: String,
+    ) -> impl Iterator<Item = (&'a u32, String)> + 'a {
+        iter.cloned().filter(move |(&a, b)| a == 1 && b == &target)
+    }
+
+    {
+        #[derive(Clone)]
+        struct S<'a> {
+            a: &'a u32,
+            b: String,
+        }
+
+        fn bar<'a>(iter: impl Iterator<Item = &'a S<'a>> + 'a, target: String) -> impl Iterator<Item = S<'a>> + 'a {
+            iter.cloned().filter(move |S { a, b }| **a == 1 && b == &target)
+        }
+    }
+
     // Not implemented yet
     let _ = vec.iter().cloned().map(|x| x.len());
 
     // This would fail if changed.
     let _ = vec.iter().cloned().map(|x| x + "2");
 
-    // Not implemented yet
-    let _ = vec.iter().cloned().find(|x| x == "2");
-
     // Not implemented yet
     let _ = vec.iter().cloned().for_each(|x| assert!(!x.is_empty()));
 
diff --git a/tests/ui/iter_overeager_cloned.stderr b/tests/ui/iter_overeager_cloned.stderr
index 2be2b7e07a4..bdbb04d7f08 100644
--- a/tests/ui/iter_overeager_cloned.stderr
+++ b/tests/ui/iter_overeager_cloned.stderr
@@ -66,5 +66,69 @@ LL ~         .iter()
 LL ~         .flatten().cloned();
    |
 
-error: aborting due to 7 previous errors
+error: unnecessarily eager cloning of iterator items
+  --> $DIR/iter_overeager_cloned.rs:24:13
+   |
+LL |     let _ = vec.iter().cloned().filter(|x| x.starts_with('2'));
+   |             ^^^^^^^^^^----------------------------------------
+   |                       |
+   |                       help: try: `.filter(|&x| x.starts_with('2')).cloned()`
+
+error: unnecessarily eager cloning of iterator items
+  --> $DIR/iter_overeager_cloned.rs:26:13
+   |
+LL |     let _ = vec.iter().cloned().find(|x| x == "2");
+   |             ^^^^^^^^^^----------------------------
+   |                       |
+   |                       help: try: `.find(|&x| x == "2").cloned()`
+
+error: unnecessarily eager cloning of iterator items
+  --> $DIR/iter_overeager_cloned.rs:30:17
+   |
+LL |         let _ = vec.iter().cloned().filter(f);
+   |                 ^^^^^^^^^^-------------------
+   |                           |
+   |                           help: try: `.filter(|&x| f(x)).cloned()`
+
+error: unnecessarily eager cloning of iterator items
+  --> $DIR/iter_overeager_cloned.rs:31:17
+   |
+LL |         let _ = vec.iter().cloned().find(f);
+   |                 ^^^^^^^^^^-----------------
+   |                           |
+   |                           help: try: `.find(|&x| f(x)).cloned()`
+
+error: unnecessarily eager cloning of iterator items
+  --> $DIR/iter_overeager_cloned.rs:37:17
+   |
+LL |         let _ = vec.iter().cloned().filter(f);
+   |                 ^^^^^^^^^^-------------------
+   |                           |
+   |                           help: try: `.filter(|&x| f(x)).cloned()`
+
+error: unnecessarily eager cloning of iterator items
+  --> $DIR/iter_overeager_cloned.rs:38:17
+   |
+LL |         let _ = vec.iter().cloned().find(f);
+   |                 ^^^^^^^^^^-----------------
+   |                           |
+   |                           help: try: `.find(|&x| f(x)).cloned()`
+
+error: unnecessarily eager cloning of iterator items
+  --> $DIR/iter_overeager_cloned.rs:45:9
+   |
+LL |         iter.cloned().filter(move |(&a, b)| a == 1 && b == &target)
+   |         ^^^^-------------------------------------------------------
+   |             |
+   |             help: try: `.filter(move |&(&a, b)| a == 1 && b == &target).cloned()`
+
+error: unnecessarily eager cloning of iterator items
+  --> $DIR/iter_overeager_cloned.rs:56:13
+   |
+LL |             iter.cloned().filter(move |S { a, b }| **a == 1 && b == &target)
+   |             ^^^^------------------------------------------------------------
+   |                 |
+   |                 help: try: `.filter(move |&S { a, b }| **a == 1 && b == &target).cloned()`
+
+error: aborting due to 15 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 34348f72f40b070a1a5fe5eac829e41cbd5f98e1 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Mon, 3 Jul 2023 01:12:08 +0200
Subject: [`useless_conversion`]: make sure path points to fn-like item

---
 clippy_lints/src/useless_conversion.rs | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/useless_conversion.rs b/clippy_lints/src/useless_conversion.rs
index 92b694d3076..3be4fb7cc32 100644
--- a/clippy_lints/src/useless_conversion.rs
+++ b/clippy_lints/src/useless_conversion.rs
@@ -150,9 +150,14 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
                 {
                     if let Some(parent) = get_parent_expr(cx, e) {
                         let parent_fn = match parent.kind {
-                            ExprKind::Call(recv, args) if let ExprKind::Path(ref qpath) = recv.kind => {
-                                cx.qpath_res(qpath, recv.hir_id).opt_def_id()
-                                    .map(|did| (did, args, MethodOrFunction::Function))
+                            ExprKind::Call(recv, args)
+                                if let ExprKind::Path(ref qpath) = recv.kind
+                                    && let Some(did) = cx.qpath_res(qpath, recv.hir_id).opt_def_id()
+                                    // make sure that the path indeed points to a fn-like item, so that
+                                    // `fn_sig` does not ICE. (see #11065)
+                                    && cx.tcx.opt_def_kind(did).is_some_and(|k| k.is_fn_like()) =>
+                            {
+                                    Some((did, args, MethodOrFunction::Function))
                             }
                             ExprKind::MethodCall(.., args, _) => {
                                 cx.typeck_results().type_dependent_def_id(parent.hir_id)
-- 
cgit 1.4.1-3-g733a5


From 2820d980cb3495768babdaeeabd8aa44c3f1aaa8 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Mon, 3 Jul 2023 01:19:09 +0200
Subject: [`useless_conversion`]: fix FP in macro and add test

---
 clippy_lints/src/useless_conversion.rs | 15 ++++++++++++++-
 tests/ui/crashes/ice-11065.rs          | 19 +++++++++++++++++++
 2 files changed, 33 insertions(+), 1 deletion(-)
 create mode 100644 tests/ui/crashes/ice-11065.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/useless_conversion.rs b/clippy_lints/src/useless_conversion.rs
index 3be4fb7cc32..ec8af2b8362 100644
--- a/clippy_lints/src/useless_conversion.rs
+++ b/clippy_lints/src/useless_conversion.rs
@@ -5,6 +5,7 @@ use clippy_utils::ty::{is_copy, is_type_diagnostic_item, same_type_and_consts};
 use clippy_utils::{get_parent_expr, is_trait_method, is_ty_alias, match_def_path, path_to_local, paths};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
+use rustc_hir::def::DefKind;
 use rustc_hir::def_id::DefId;
 use rustc_hir::{BindingAnnotation, Expr, ExprKind, HirId, MatchSource, Node, PatKind};
 use rustc_lint::{LateContext, LateLintPass};
@@ -101,6 +102,17 @@ fn into_iter_deep_call<'hir>(cx: &LateContext<'_>, mut expr: &'hir Expr<'hir>) -
     (expr, depth)
 }
 
+/// Checks if the given `expr` is an argument of a macro invocation.
+/// This is a slow-ish operation, so consider calling this late
+/// to avoid slowing down the lint in the happy path when not emitting a warning
+fn is_macro_argument(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+    if let Some(parent) = get_parent_expr(cx, expr) {
+        parent.span.from_expansion() || is_macro_argument(cx, parent)
+    } else {
+        false
+    }
+}
+
 #[expect(clippy::too_many_lines)]
 impl<'tcx> LateLintPass<'tcx> for UselessConversion {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
@@ -155,7 +167,7 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
                                     && let Some(did) = cx.qpath_res(qpath, recv.hir_id).opt_def_id()
                                     // make sure that the path indeed points to a fn-like item, so that
                                     // `fn_sig` does not ICE. (see #11065)
-                                    && cx.tcx.opt_def_kind(did).is_some_and(|k| k.is_fn_like()) =>
+                                    && cx.tcx.opt_def_kind(did).is_some_and(DefKind::is_fn_like) =>
                             {
                                     Some((did, args, MethodOrFunction::Function))
                             }
@@ -173,6 +185,7 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
                             && let Some(&into_iter_param) = sig.inputs().get(kind.param_pos(arg_pos))
                             && let ty::Param(param) = into_iter_param.kind()
                             && let Some(span) = into_iter_bound(cx, parent_fn_did, into_iter_did, param.index)
+                            && !is_macro_argument(cx, e)
                         {
                             // Get the "innermost" `.into_iter()` call, e.g. given this expression:
                             // `foo.into_iter().into_iter()`
diff --git a/tests/ui/crashes/ice-11065.rs b/tests/ui/crashes/ice-11065.rs
new file mode 100644
index 00000000000..f5cf6b1cd77
--- /dev/null
+++ b/tests/ui/crashes/ice-11065.rs
@@ -0,0 +1,19 @@
+#![warn(clippy::useless_conversion)]
+
+use std::iter::FromIterator;
+use std::option::IntoIter as OptionIter;
+
+fn eq<T: Eq>(a: T, b: T) -> bool {
+    a == b
+}
+
+macro_rules! tests {
+    ($($expr:expr, $ty:ty, ($($test:expr),*);)+) => (pub fn main() {$({
+        const C: $ty = $expr;
+        assert!(eq(C($($test),*), $expr($($test),*)));
+    })+})
+}
+
+tests! {
+    FromIterator::from_iter, fn(OptionIter<i32>) -> Vec<i32>, (Some(5).into_iter());
+}
-- 
cgit 1.4.1-3-g733a5


From f47165c703c1f2819bb0f0aef1be1136457b2f9a Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Sun, 9 Jul 2023 22:32:58 +0200
Subject: find expansions more efficiently

---
 clippy_lints/src/useless_conversion.rs | 18 ++++++------------
 tests/ui/useless_conversion.fixed      | 14 ++++++++++++++
 tests/ui/useless_conversion.rs         | 14 ++++++++++++++
 tests/ui/useless_conversion.stderr     | 20 ++++++++++----------
 4 files changed, 44 insertions(+), 22 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/useless_conversion.rs b/clippy_lints/src/useless_conversion.rs
index ec8af2b8362..64dfe51b059 100644
--- a/clippy_lints/src/useless_conversion.rs
+++ b/clippy_lints/src/useless_conversion.rs
@@ -40,6 +40,7 @@ declare_clippy_lint! {
 #[derive(Default)]
 pub struct UselessConversion {
     try_desugar_arm: Vec<HirId>,
+    expn_depth: u32,
 }
 
 impl_lint_pass!(UselessConversion => [USELESS_CONVERSION]);
@@ -102,21 +103,11 @@ fn into_iter_deep_call<'hir>(cx: &LateContext<'_>, mut expr: &'hir Expr<'hir>) -
     (expr, depth)
 }
 
-/// Checks if the given `expr` is an argument of a macro invocation.
-/// This is a slow-ish operation, so consider calling this late
-/// to avoid slowing down the lint in the happy path when not emitting a warning
-fn is_macro_argument(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-    if let Some(parent) = get_parent_expr(cx, expr) {
-        parent.span.from_expansion() || is_macro_argument(cx, parent)
-    } else {
-        false
-    }
-}
-
 #[expect(clippy::too_many_lines)]
 impl<'tcx> LateLintPass<'tcx> for UselessConversion {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
         if e.span.from_expansion() {
+            self.expn_depth += 1;
             return;
         }
 
@@ -185,7 +176,7 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
                             && let Some(&into_iter_param) = sig.inputs().get(kind.param_pos(arg_pos))
                             && let ty::Param(param) = into_iter_param.kind()
                             && let Some(span) = into_iter_bound(cx, parent_fn_did, into_iter_did, param.index)
-                            && !is_macro_argument(cx, e)
+                            && self.expn_depth == 0
                         {
                             // Get the "innermost" `.into_iter()` call, e.g. given this expression:
                             // `foo.into_iter().into_iter()`
@@ -321,5 +312,8 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
         if Some(&e.hir_id) == self.try_desugar_arm.last() {
             self.try_desugar_arm.pop();
         }
+        if e.span.from_expansion() {
+            self.expn_depth -= 1;
+        }
     }
 }
diff --git a/tests/ui/useless_conversion.fixed b/tests/ui/useless_conversion.fixed
index d5a57ec61f7..52591959905 100644
--- a/tests/ui/useless_conversion.fixed
+++ b/tests/ui/useless_conversion.fixed
@@ -153,6 +153,20 @@ fn main() {
     let _ = vec![s4, s4, s4].into_iter();
 }
 
+#[allow(dead_code)]
+fn issue11065_fp() {
+    use std::option::IntoIter;
+    fn takes_into_iter(_: impl IntoIterator<Item = i32>) {}
+
+    macro_rules! x {
+        ($e:expr) => {
+            takes_into_iter($e);
+            let _: IntoIter<i32> = $e; // removing `.into_iter()` leads to a type error here
+        };
+    }
+    x!(Some(5).into_iter());
+}
+
 #[allow(dead_code)]
 fn explicit_into_iter_fn_arg() {
     fn a<T>(_: T) {}
diff --git a/tests/ui/useless_conversion.rs b/tests/ui/useless_conversion.rs
index 6730e6909c5..befb2f9a5c3 100644
--- a/tests/ui/useless_conversion.rs
+++ b/tests/ui/useless_conversion.rs
@@ -153,6 +153,20 @@ fn main() {
     let _ = vec![s4, s4, s4].into_iter().into_iter();
 }
 
+#[allow(dead_code)]
+fn issue11065_fp() {
+    use std::option::IntoIter;
+    fn takes_into_iter(_: impl IntoIterator<Item = i32>) {}
+
+    macro_rules! x {
+        ($e:expr) => {
+            takes_into_iter($e);
+            let _: IntoIter<i32> = $e; // removing `.into_iter()` leads to a type error here
+        };
+    }
+    x!(Some(5).into_iter());
+}
+
 #[allow(dead_code)]
 fn explicit_into_iter_fn_arg() {
     fn a<T>(_: T) {}
diff --git a/tests/ui/useless_conversion.stderr b/tests/ui/useless_conversion.stderr
index bf701b1e81e..28e7bb61098 100644
--- a/tests/ui/useless_conversion.stderr
+++ b/tests/ui/useless_conversion.stderr
@@ -119,61 +119,61 @@ LL |     let _ = vec![s4, s4, s4].into_iter().into_iter();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `vec![s4, s4, s4].into_iter()`
 
 error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
-  --> $DIR/useless_conversion.rs:169:7
+  --> $DIR/useless_conversion.rs:183:7
    |
 LL |     b(vec![1, 2].into_iter());
    |       ^^^^^^^^^^^^^^^^^^^^^^ help: consider removing the `.into_iter()`: `vec![1, 2]`
    |
 note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
-  --> $DIR/useless_conversion.rs:159:13
+  --> $DIR/useless_conversion.rs:173:13
    |
 LL |     fn b<T: IntoIterator<Item = i32>>(_: T) {}
    |             ^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
-  --> $DIR/useless_conversion.rs:170:7
+  --> $DIR/useless_conversion.rs:184:7
    |
 LL |     c(vec![1, 2].into_iter());
    |       ^^^^^^^^^^^^^^^^^^^^^^ help: consider removing the `.into_iter()`: `vec![1, 2]`
    |
 note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
-  --> $DIR/useless_conversion.rs:160:18
+  --> $DIR/useless_conversion.rs:174:18
    |
 LL |     fn c(_: impl IntoIterator<Item = i32>) {}
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
-  --> $DIR/useless_conversion.rs:171:7
+  --> $DIR/useless_conversion.rs:185:7
    |
 LL |     d(vec![1, 2].into_iter());
    |       ^^^^^^^^^^^^^^^^^^^^^^ help: consider removing the `.into_iter()`: `vec![1, 2]`
    |
 note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
-  --> $DIR/useless_conversion.rs:163:12
+  --> $DIR/useless_conversion.rs:177:12
    |
 LL |         T: IntoIterator<Item = i32>,
    |            ^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
-  --> $DIR/useless_conversion.rs:174:7
+  --> $DIR/useless_conversion.rs:188:7
    |
 LL |     b(vec![1, 2].into_iter().into_iter());
    |       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing the `.into_iter()`s: `vec![1, 2]`
    |
 note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
-  --> $DIR/useless_conversion.rs:159:13
+  --> $DIR/useless_conversion.rs:173:13
    |
 LL |     fn b<T: IntoIterator<Item = i32>>(_: T) {}
    |             ^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
-  --> $DIR/useless_conversion.rs:175:7
+  --> $DIR/useless_conversion.rs:189:7
    |
 LL |     b(vec![1, 2].into_iter().into_iter().into_iter());
    |       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing the `.into_iter()`s: `vec![1, 2]`
    |
 note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
-  --> $DIR/useless_conversion.rs:159:13
+  --> $DIR/useless_conversion.rs:173:13
    |
 LL |     fn b<T: IntoIterator<Item = i32>>(_: T) {}
    |             ^^^^^^^^^^^^^^^^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From aa8995e589c7f4a433ae6fe27b319ff9898b523a Mon Sep 17 00:00:00 2001
From: J-ZhengLi <lizheng135@huawei.com>
Date: Tue, 15 Aug 2023 09:41:15 +0800
Subject: allow calling `to_owned` with borrowed value for [`implicit_clone`]

---
 clippy_lints/src/methods/implicit_clone.rs | 1 +
 tests/ui/implicit_clone.fixed              | 2 +-
 tests/ui/implicit_clone.stderr             | 8 +-------
 3 files changed, 3 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/implicit_clone.rs b/clippy_lints/src/methods/implicit_clone.rs
index 043425300d8..e91ce64d8c8 100644
--- a/clippy_lints/src/methods/implicit_clone.rs
+++ b/clippy_lints/src/methods/implicit_clone.rs
@@ -17,6 +17,7 @@ pub fn check(cx: &LateContext<'_>, method_name: &str, expr: &hir::Expr<'_>, recv
         let return_type = cx.typeck_results().expr_ty(expr);
         let input_type = cx.typeck_results().expr_ty(recv);
         let (input_type, ref_count) = peel_mid_ty_refs(input_type);
+        if !(ref_count > 0 && is_diag_trait_item(cx, method_def_id, sym::ToOwned));
         if let Some(ty_name) = input_type.ty_adt_def().map(|adt_def| cx.tcx.item_name(adt_def.did()));
         if return_type == input_type;
         if let Some(clone_trait) = cx.tcx.lang_items().clone_trait();
diff --git a/tests/ui/implicit_clone.fixed b/tests/ui/implicit_clone.fixed
index 04644b111bf..98556b4dd30 100644
--- a/tests/ui/implicit_clone.fixed
+++ b/tests/ui/implicit_clone.fixed
@@ -67,7 +67,7 @@ fn main() {
 
     let vec_ref = &vec;
     let _ = return_owned_from_slice(vec_ref);
-    let _ = vec_ref.clone();
+    let _ = vec_ref.to_owned();
     let _ = vec_ref.clone();
 
     // we expect no lint for this
diff --git a/tests/ui/implicit_clone.stderr b/tests/ui/implicit_clone.stderr
index 0f412424190..59f000c06e2 100644
--- a/tests/ui/implicit_clone.stderr
+++ b/tests/ui/implicit_clone.stderr
@@ -12,12 +12,6 @@ error: implicitly cloning a `Vec` by calling `to_vec` on its dereferenced type
 LL |     let _ = vec.to_vec();
    |             ^^^^^^^^^^^^ help: consider using: `vec.clone()`
 
-error: implicitly cloning a `Vec` by calling `to_owned` on its dereferenced type
-  --> $DIR/implicit_clone.rs:70:13
-   |
-LL |     let _ = vec_ref.to_owned();
-   |             ^^^^^^^^^^^^^^^^^^ help: consider using: `vec_ref.clone()`
-
 error: implicitly cloning a `Vec` by calling `to_vec` on its dereferenced type
   --> $DIR/implicit_clone.rs:71:13
    |
@@ -72,5 +66,5 @@ error: implicitly cloning a `PathBuf` by calling `to_path_buf` on its dereferenc
 LL |     let _ = pathbuf_ref.to_path_buf();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(**pathbuf_ref).clone()`
 
-error: aborting due to 12 previous errors
+error: aborting due to 11 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 5875bd2b5f2b593d708459111bff42ba4535cebc Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Thu, 17 Aug 2023 17:45:17 +0200
Subject: Use `HirId` from `PlaceWithHirId` rather than using the one provided
 to the function

---
 clippy_lints/src/needless_pass_by_ref_mut.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/needless_pass_by_ref_mut.rs b/clippy_lints/src/needless_pass_by_ref_mut.rs
index 6eb17d675e9..7b00eabf97b 100644
--- a/clippy_lints/src/needless_pass_by_ref_mut.rs
+++ b/clippy_lints/src/needless_pass_by_ref_mut.rs
@@ -305,7 +305,7 @@ impl<'tcx> euv::Delegate<'tcx> for MutablyUsedVariablesCtxt<'tcx> {
         }
     }
 
-    fn borrow(&mut self, cmt: &euv::PlaceWithHirId<'tcx>, id: HirId, borrow: ty::BorrowKind) {
+    fn borrow(&mut self, cmt: &euv::PlaceWithHirId<'tcx>, _id: HirId, borrow: ty::BorrowKind) {
         self.prev_bind = None;
         if let euv::Place {
             base: euv::PlaceBase::Local(vid),
@@ -338,7 +338,7 @@ impl<'tcx> euv::Delegate<'tcx> for MutablyUsedVariablesCtxt<'tcx> {
                         ],
                     ),
                 ..
-            }) = self.tcx.hir().get(id)
+            }) = self.tcx.hir().get(cmt.hir_id)
             {
                 self.async_closures.insert(*def_id);
             }
-- 
cgit 1.4.1-3-g733a5


From 41570c1ee71b36a5a5ea887a3aee07121d1aa0b6 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Fri, 18 Aug 2023 17:07:43 +0200
Subject: Update version attribute for 1.72 lints

---
 clippy_lints/src/casts/mod.rs                  | 2 +-
 clippy_lints/src/endian_bytes.rs               | 6 +++---
 clippy_lints/src/excessive_nesting.rs          | 2 +-
 clippy_lints/src/large_stack_frames.rs         | 2 +-
 clippy_lints/src/methods/mod.rs                | 4 ++--
 clippy_lints/src/needless_else.rs              | 2 +-
 clippy_lints/src/redundant_type_annotations.rs | 2 +-
 7 files changed, 10 insertions(+), 10 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index d34de305f5d..88ffbb55486 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -418,7 +418,7 @@ declare_clippy_lint! {
     /// let mut_ptr = ptr.cast_mut();
     /// let ptr = mut_ptr.cast_const();
     /// ```
-    #[clippy::version = "1.71.0"]
+    #[clippy::version = "1.72.0"]
     pub PTR_CAST_CONSTNESS,
     pedantic,
     "casting using `as` from and to raw pointers to change constness when specialized methods apply"
diff --git a/clippy_lints/src/endian_bytes.rs b/clippy_lints/src/endian_bytes.rs
index dda14b4df53..affd0822120 100644
--- a/clippy_lints/src/endian_bytes.rs
+++ b/clippy_lints/src/endian_bytes.rs
@@ -21,7 +21,7 @@ declare_clippy_lint! {
     /// let _x = 2i32.to_ne_bytes();
     /// let _y = 2i64.to_ne_bytes();
     /// ```
-    #[clippy::version = "1.71.0"]
+    #[clippy::version = "1.72.0"]
     pub HOST_ENDIAN_BYTES,
     restriction,
     "disallows usage of the `to_ne_bytes` method"
@@ -40,7 +40,7 @@ declare_clippy_lint! {
     /// let _x = 2i32.to_le_bytes();
     /// let _y = 2i64.to_le_bytes();
     /// ```
-    #[clippy::version = "1.71.0"]
+    #[clippy::version = "1.72.0"]
     pub LITTLE_ENDIAN_BYTES,
     restriction,
     "disallows usage of the `to_le_bytes` method"
@@ -59,7 +59,7 @@ declare_clippy_lint! {
     /// let _x = 2i32.to_be_bytes();
     /// let _y = 2i64.to_be_bytes();
     /// ```
-    #[clippy::version = "1.71.0"]
+    #[clippy::version = "1.72.0"]
     pub BIG_ENDIAN_BYTES,
     restriction,
     "disallows usage of the `to_be_bytes` method"
diff --git a/clippy_lints/src/excessive_nesting.rs b/clippy_lints/src/excessive_nesting.rs
index 8911f1872c2..83480fc5eeb 100644
--- a/clippy_lints/src/excessive_nesting.rs
+++ b/clippy_lints/src/excessive_nesting.rs
@@ -56,7 +56,7 @@ declare_clippy_lint! {
     /// // lib.rs
     /// pub mod a;
     /// ```
-    #[clippy::version = "1.70.0"]
+    #[clippy::version = "1.72.0"]
     pub EXCESSIVE_NESTING,
     complexity,
     "checks for blocks nested beyond a certain threshold"
diff --git a/clippy_lints/src/large_stack_frames.rs b/clippy_lints/src/large_stack_frames.rs
index 7aa1446d53d..1d28d7dd0e7 100644
--- a/clippy_lints/src/large_stack_frames.rs
+++ b/clippy_lints/src/large_stack_frames.rs
@@ -72,7 +72,7 @@ declare_clippy_lint! {
     /// //  ...
     /// }
     /// ```
-    #[clippy::version = "1.71.0"]
+    #[clippy::version = "1.72.0"]
     pub LARGE_STACK_FRAMES,
     nursery,
     "checks for functions that allocate a lot of stack space"
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 729eda37af6..3a8af0248d8 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -301,7 +301,7 @@ declare_clippy_lint! {
     /// let val2 = 1;
     /// let val3 = 1;
     /// ```
-    #[clippy::version = "1.69.0"]
+    #[clippy::version = "1.72.0"]
     pub UNNECESSARY_LITERAL_UNWRAP,
     complexity,
     "using `unwrap()` related calls on `Result` and `Option` constructors"
@@ -3328,7 +3328,7 @@ declare_clippy_lint! {
     ///     mem::take(v)
     /// }
     /// ```
-    #[clippy::version = "1.71.0"]
+    #[clippy::version = "1.72.0"]
     pub DRAIN_COLLECT,
     perf,
     "calling `.drain(..).collect()` to move all elements into a new collection"
diff --git a/clippy_lints/src/needless_else.rs b/clippy_lints/src/needless_else.rs
index 03bab86c6d7..0c1fe881fc1 100644
--- a/clippy_lints/src/needless_else.rs
+++ b/clippy_lints/src/needless_else.rs
@@ -27,7 +27,7 @@ declare_clippy_lint! {
     ///     println!("Check successful!");
     /// }
     /// ```
-    #[clippy::version = "1.71.0"]
+    #[clippy::version = "1.72.0"]
     pub NEEDLESS_ELSE,
     style,
     "empty else branch"
diff --git a/clippy_lints/src/redundant_type_annotations.rs b/clippy_lints/src/redundant_type_annotations.rs
index 3e963d79892..1d4fdb43a0b 100644
--- a/clippy_lints/src/redundant_type_annotations.rs
+++ b/clippy_lints/src/redundant_type_annotations.rs
@@ -31,7 +31,7 @@ declare_clippy_lint! {
     /// ```rust
     /// let foo = String::new();
     /// ```
-    #[clippy::version = "1.70.0"]
+    #[clippy::version = "1.72.0"]
     pub REDUNDANT_TYPE_ANNOTATIONS,
     restriction,
     "warns about needless / redundant type annotations."
-- 
cgit 1.4.1-3-g733a5


From e52bd6f8505bd3e3ce120104e4c6ee4f17dc1d10 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Fri, 21 Jul 2023 11:23:31 +0200
Subject: new lint: `should_panic_without_expect`

---
 CHANGELOG.md                                |  1 +
 clippy_lints/src/attrs.rs                   | 74 ++++++++++++++++++++++++++++-
 clippy_lints/src/declared_lints.rs          |  1 +
 clippy_utils/src/paths.rs                   |  2 +
 tests/ui/should_panic_without_expect.rs     | 21 ++++++++
 tests/ui/should_panic_without_expect.stderr | 14 ++++++
 6 files changed, 112 insertions(+), 1 deletion(-)
 create mode 100644 tests/ui/should_panic_without_expect.rs
 create mode 100644 tests/ui/should_panic_without_expect.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 786df2ae9ab..fe64283462d 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5329,6 +5329,7 @@ Released 2018-09-13
 [`short_circuit_statement`]: https://rust-lang.github.io/rust-clippy/master/index.html#short_circuit_statement
 [`should_assert_eq`]: https://rust-lang.github.io/rust-clippy/master/index.html#should_assert_eq
 [`should_implement_trait`]: https://rust-lang.github.io/rust-clippy/master/index.html#should_implement_trait
+[`should_panic_without_expect`]: https://rust-lang.github.io/rust-clippy/master/index.html#should_panic_without_expect
 [`significant_drop_in_scrutinee`]: https://rust-lang.github.io/rust-clippy/master/index.html#significant_drop_in_scrutinee
 [`significant_drop_tightening`]: https://rust-lang.github.io/rust-clippy/master/index.html#significant_drop_tightening
 [`similar_names`]: https://rust-lang.github.io/rust-clippy/master/index.html#similar_names
diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs
index 2a5be275615..a88f2b51c82 100644
--- a/clippy_lints/src/attrs.rs
+++ b/clippy_lints/src/attrs.rs
@@ -6,7 +6,11 @@ use clippy_utils::macros::{is_panic, macro_backtrace};
 use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::{first_line_of_span, is_present_in_source, snippet_opt, without_block_comments};
 use if_chain::if_chain;
-use rustc_ast::{AttrKind, AttrStyle, Attribute, LitKind, MetaItemKind, MetaItemLit, NestedMetaItem};
+use rustc_ast::token::{Token, TokenKind};
+use rustc_ast::tokenstream::TokenTree;
+use rustc_ast::{
+    AttrArgs, AttrArgsEq, AttrKind, AttrStyle, Attribute, LitKind, MetaItemKind, MetaItemLit, NestedMetaItem,
+};
 use rustc_errors::Applicability;
 use rustc_hir::{
     Block, Expr, ExprKind, ImplItem, ImplItemKind, Item, ItemKind, StmtKind, TraitFn, TraitItem, TraitItemKind,
@@ -339,6 +343,41 @@ declare_clippy_lint! {
     "ensures that all `allow` and `expect` attributes have a reason"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `#[should_panic]` attributes without specifying the expected panic message.
+    ///
+    /// ### Why is this bad?
+    /// The expected panic message should be specified to ensure that the test is actually
+    /// panicking with the expected message, and not another unrelated panic.
+    ///
+    /// ### Example
+    /// ```rust
+    /// fn random() -> i32 { 0 }
+    ///
+    /// #[should_panic]
+    /// #[test]
+    /// fn my_test() {
+    ///     let _ = 1 / random();
+    /// }
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust
+    /// fn random() -> i32 { 0 }
+    ///
+    /// #[should_panic = "attempt to divide by zero"]
+    /// #[test]
+    /// fn my_test() {
+    ///     let _ = 1 / random();
+    /// }
+    /// ```
+    #[clippy::version = "1.73.0"]
+    pub SHOULD_PANIC_WITHOUT_EXPECT,
+    pedantic,
+    "ensures that all `should_panic` attributes specify its expected panic message"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for `any` and `all` combinators in `cfg` with only one condition.
@@ -395,6 +434,7 @@ declare_lint_pass!(Attributes => [
     DEPRECATED_SEMVER,
     USELESS_ATTRIBUTE,
     BLANKET_CLIPPY_RESTRICTION_LINTS,
+    SHOULD_PANIC_WITHOUT_EXPECT,
 ]);
 
 impl<'tcx> LateLintPass<'tcx> for Attributes {
@@ -442,6 +482,9 @@ impl<'tcx> LateLintPass<'tcx> for Attributes {
                 }
             }
         }
+        if attr.has_name(sym::should_panic) {
+            check_should_panic_reason(cx, attr);
+        }
     }
 
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
@@ -550,6 +593,35 @@ fn extract_clippy_lint(lint: &NestedMetaItem) -> Option<Symbol> {
     None
 }
 
+fn check_should_panic_reason(cx: &LateContext<'_>, attr: &Attribute) {
+    if let AttrKind::Normal(normal_attr) = &attr.kind {
+        if let AttrArgs::Eq(_, AttrArgsEq::Hir(_)) = &normal_attr.item.args {
+            // `#[should_panic = ".."]` found, good
+            return;
+        }
+
+        if let AttrArgs::Delimited(args) = &normal_attr.item.args
+            && let mut tt_iter = args.tokens.trees()
+            && let Some(TokenTree::Token(Token { kind: TokenKind::Ident(sym::expected, _), .. }, _)) = tt_iter.next()
+            && let Some(TokenTree::Token(Token { kind: TokenKind::Eq, .. }, _)) = tt_iter.next()
+            && let Some(TokenTree::Token(Token { kind: TokenKind::Literal(_), .. }, _)) = tt_iter.next()
+        {
+            // `#[should_panic(expected = "..")]` found, good
+            return;
+        }
+
+        span_lint_and_sugg(
+            cx,
+            SHOULD_PANIC_WITHOUT_EXPECT,
+            attr.span,
+            "#[should_panic] attribute without a reason",
+            "consider specifying the expected panic",
+            r#"#[should_panic(expected = /* panic message */)]"#.into(),
+            Applicability::HasPlaceholders,
+        );
+    }
+}
+
 fn check_clippy_lint_names(cx: &LateContext<'_>, name: Symbol, items: &[NestedMetaItem]) {
     for lint in items {
         if let Some(lint_name) = extract_clippy_lint(lint) {
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index db114abfc86..bab77f91269 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -58,6 +58,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::attrs::MAYBE_MISUSED_CFG_INFO,
     crate::attrs::MISMATCHED_TARGET_OS_INFO,
     crate::attrs::NON_MINIMAL_CFG_INFO,
+    crate::attrs::SHOULD_PANIC_WITHOUT_EXPECT_INFO,
     crate::attrs::USELESS_ATTRIBUTE_INFO,
     crate::await_holding_invalid::AWAIT_HOLDING_INVALID_TYPE_INFO,
     crate::await_holding_invalid::AWAIT_HOLDING_LOCK_INFO,
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index e72d063cfd9..6d5754eee78 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -166,3 +166,5 @@ pub const DEBUG_STRUCT: [&str; 4] = ["core", "fmt", "builders", "DebugStruct"];
 pub const ORD_CMP: [&str; 4] = ["core", "cmp", "Ord", "cmp"];
 #[expect(clippy::invalid_paths)] // not sure why it thinks this, it works so
 pub const BOOL_THEN: [&str; 4] = ["core", "bool", "<impl bool>", "then"];
+#[allow(clippy::invalid_paths, reason = "internal lints do not always know about ::test")]
+pub const TEST_DESC_AND_FN: [&str; 3] = ["test", "types", "TestDescAndFn"];
diff --git a/tests/ui/should_panic_without_expect.rs b/tests/ui/should_panic_without_expect.rs
new file mode 100644
index 00000000000..b554fdaf224
--- /dev/null
+++ b/tests/ui/should_panic_without_expect.rs
@@ -0,0 +1,21 @@
+//@no-rustfix
+#![deny(clippy::should_panic_without_expect)]
+
+#[test]
+#[should_panic]
+fn no_message() {}
+
+#[test]
+#[should_panic]
+#[cfg(not(test))]
+fn no_message_cfg_false() {}
+
+#[test]
+#[should_panic = "message"]
+fn metastr() {}
+
+#[test]
+#[should_panic(expected = "message")]
+fn metalist() {}
+
+fn main() {}
diff --git a/tests/ui/should_panic_without_expect.stderr b/tests/ui/should_panic_without_expect.stderr
new file mode 100644
index 00000000000..dfcef52a9f5
--- /dev/null
+++ b/tests/ui/should_panic_without_expect.stderr
@@ -0,0 +1,14 @@
+error: #[should_panic] attribute without a reason
+  --> $DIR/should_panic_without_expect.rs:5:1
+   |
+LL | #[should_panic]
+   | ^^^^^^^^^^^^^^^ help: consider specifying the expected panic: `#[should_panic(expected = /* panic message */)]`
+   |
+note: the lint level is defined here
+  --> $DIR/should_panic_without_expect.rs:2:9
+   |
+LL | #![deny(clippy::should_panic_without_expect)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to previous error
+
-- 
cgit 1.4.1-3-g733a5


From e440065a0f930b527925b61c3a6dd5f4207dd7b6 Mon Sep 17 00:00:00 2001
From: lengyijun <sjtu5140809011@gmail.com>
Date: Sat, 5 Aug 2023 10:20:16 +0800
Subject: [`iter_overeager_cloned`]: detect .cloned().map() and
 .cloned().for_each()

key idea:
for `f` in `.map(f)` and `.for_each(f)`:
1. `f` must be a closure with one parameter
2. don't lint if mutable paramter in clsure `f`: `|mut x| ...`
3. don't lint if parameter is moved
---
 clippy_lints/src/methods/iter_overeager_cloned.rs | 77 ++++++++++++++++++++++-
 clippy_lints/src/methods/mod.rs                   | 14 +++--
 tests/ui/iter_overeager_cloned.fixed              |  6 +-
 tests/ui/iter_overeager_cloned.rs                 |  2 -
 tests/ui/iter_overeager_cloned.stderr             | 18 +++++-
 5 files changed, 102 insertions(+), 15 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/iter_overeager_cloned.rs b/clippy_lints/src/methods/iter_overeager_cloned.rs
index 4b1ca0d9b9c..ee405a3e30c 100644
--- a/clippy_lints/src/methods/iter_overeager_cloned.rs
+++ b/clippy_lints/src/methods/iter_overeager_cloned.rs
@@ -1,14 +1,18 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::{implements_trait, is_copy};
+use rustc_ast::BindingAnnotation;
 use rustc_errors::Applicability;
-use rustc_hir::{Expr, ExprKind};
+use rustc_hir::{Body, Expr, ExprKind, HirId, HirIdSet, PatKind};
+use rustc_hir_typeck::expr_use_visitor::{Delegate, ExprUseVisitor, PlaceBase, PlaceWithHirId};
 use rustc_lint::LateContext;
-use rustc_middle::ty;
+use rustc_middle::mir::{FakeReadCause, Mutability};
+use rustc_middle::ty::{self, BorrowKind};
 use rustc_span::sym;
 
 use super::ITER_OVEREAGER_CLONED;
 use crate::redundant_clone::REDUNDANT_CLONE;
+use crate::rustc_trait_selection::infer::TyCtxtInferExt;
 
 #[derive(Clone, Copy)]
 pub(super) enum Op<'a> {
@@ -16,6 +20,10 @@ pub(super) enum Op<'a> {
     // e.g. `count`
     RmCloned,
 
+    // rm `.cloned()`
+    // e.g. `map` `for_each`
+    NeedlessMove(&'a str, &'a Expr<'a>),
+
     // later `.cloned()`
     // and add `&` to the parameter of closure parameter
     // e.g. `find` `filter`
@@ -51,8 +59,46 @@ pub(super) fn check<'tcx>(
             return;
         }
 
+        if let Op::NeedlessMove(_, expr) = op {
+            let rustc_hir::ExprKind::Closure(closure) = expr.kind else { return } ;
+            let body @ Body { params: [p], .. } = cx.tcx.hir().body(closure.body) else { return };
+            let mut delegate = MoveDelegate {used_move : HirIdSet::default()};
+            let infcx = cx.tcx.infer_ctxt().build();
+
+            ExprUseVisitor::new(
+                &mut delegate,
+                &infcx,
+                closure.body.hir_id.owner.def_id,
+                cx.param_env,
+                cx.typeck_results(),
+            )
+            .consume_body(body);
+
+            let mut to_be_discarded = false;
+
+            p.pat.walk(|it| {
+                if delegate.used_move.contains(&it.hir_id){
+                    to_be_discarded = true;
+                    return false;
+                }
+
+                match it.kind {
+                    PatKind::Binding(BindingAnnotation(_, Mutability::Mut), _, _, _)
+                    | PatKind::Ref(_, Mutability::Mut) => {
+                        to_be_discarded = true;
+                        false
+                    }
+                    _ => { true }
+                }
+            });
+
+            if to_be_discarded {
+                return;
+            }
+        }
+
         let (lint, msg, trailing_clone) = match op {
-            Op::RmCloned => (REDUNDANT_CLONE, "unneeded cloning of iterator items", ""),
+            Op::RmCloned | Op::NeedlessMove(_, _) => (REDUNDANT_CLONE, "unneeded cloning of iterator items", ""),
             Op::LaterCloned | Op::FixClosure(_, _) => (ITER_OVEREAGER_CLONED, "unnecessarily eager cloning of iterator items", ".cloned()"),
         };
 
@@ -83,8 +129,33 @@ pub(super) fn check<'tcx>(
                             diag.span_suggestion(replace_span, "try", snip, Applicability::MachineApplicable);
                         }
                     }
+                    Op::NeedlessMove(_, _) => {
+                        let method_span = expr.span.with_lo(cloned_call.span.hi());
+                        if let Some(snip) = snippet_opt(cx, method_span) {
+                            let replace_span = expr.span.with_lo(cloned_recv.span.hi());
+                            diag.span_suggestion(replace_span, "try", snip, Applicability::MaybeIncorrect);
+                        }
+                    }
                 }
             }
         );
     }
 }
+
+struct MoveDelegate {
+    used_move: HirIdSet,
+}
+
+impl<'tcx> Delegate<'tcx> for MoveDelegate {
+    fn consume(&mut self, place_with_id: &PlaceWithHirId<'tcx>, _: HirId) {
+        if let PlaceBase::Local(l) = place_with_id.place.base {
+            self.used_move.insert(l);
+        }
+    }
+
+    fn borrow(&mut self, _: &PlaceWithHirId<'tcx>, _: HirId, _: BorrowKind) {}
+
+    fn mutate(&mut self, _: &PlaceWithHirId<'tcx>, _: HirId) {}
+
+    fn fake_read(&mut self, _: &PlaceWithHirId<'tcx>, _: FakeReadCause, _: HirId) {}
+}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 3a8af0248d8..5075137caa0 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -4001,9 +4001,11 @@ impl Methods {
                     manual_try_fold::check(cx, expr, init, acc, call_span, &self.msrv);
                     unnecessary_fold::check(cx, expr, init, acc, span);
                 },
-                ("for_each", [_]) => {
-                    if let Some(("inspect", _, [_], span2, _)) = method_call(recv) {
-                        inspect_for_each::check(cx, expr, span2);
+                ("for_each", [arg]) => {
+                    match method_call(recv) {
+                        Some(("inspect", _, [_], span2, _)) => inspect_for_each::check(cx, expr, span2),
+                        Some(("cloned", recv2, [], _, _)) => iter_overeager_cloned::check(cx, expr, recv, recv2, iter_overeager_cloned::Op::NeedlessMove(name, arg), false),
+                        _ => {}
                     }
                 },
                 ("get", [arg]) => {
@@ -4038,8 +4040,10 @@ impl Methods {
                 (name @ ("map" | "map_err"), [m_arg]) => {
                     if name == "map" {
                         map_clone::check(cx, expr, recv, m_arg, &self.msrv);
-                        if let Some((map_name @ ("iter" | "into_iter"), recv2, _, _, _)) = method_call(recv) {
-                            iter_kv_map::check(cx, map_name, expr, recv2, m_arg);
+                        match method_call(recv) {
+                            Some((map_name @ ("iter" | "into_iter"), recv2, _, _, _)) => iter_kv_map::check(cx, map_name, expr, recv2, m_arg),
+                            Some(("cloned", recv2, [], _, _)) => iter_overeager_cloned::check(cx, expr, recv, recv2, iter_overeager_cloned::Op::NeedlessMove(name, m_arg), false),
+                            _ => {}
                         }
                     } else {
                         map_err_ignore::check(cx, expr, m_arg);
diff --git a/tests/ui/iter_overeager_cloned.fixed b/tests/ui/iter_overeager_cloned.fixed
index 9605b449b40..9dd046fec1f 100644
--- a/tests/ui/iter_overeager_cloned.fixed
+++ b/tests/ui/iter_overeager_cloned.fixed
@@ -56,14 +56,12 @@ fn main() {
         }
     }
 
-    // Not implemented yet
-    let _ = vec.iter().cloned().map(|x| x.len());
+    let _ = vec.iter().map(|x| x.len());
 
     // This would fail if changed.
     let _ = vec.iter().cloned().map(|x| x + "2");
 
-    // Not implemented yet
-    let _ = vec.iter().cloned().for_each(|x| assert!(!x.is_empty()));
+    let _ = vec.iter().for_each(|x| assert!(!x.is_empty()));
 
     // Not implemented yet
     let _ = vec.iter().cloned().all(|x| x.len() == 1);
diff --git a/tests/ui/iter_overeager_cloned.rs b/tests/ui/iter_overeager_cloned.rs
index 8d75f039d44..3cab3669554 100644
--- a/tests/ui/iter_overeager_cloned.rs
+++ b/tests/ui/iter_overeager_cloned.rs
@@ -57,13 +57,11 @@ fn main() {
         }
     }
 
-    // Not implemented yet
     let _ = vec.iter().cloned().map(|x| x.len());
 
     // This would fail if changed.
     let _ = vec.iter().cloned().map(|x| x + "2");
 
-    // Not implemented yet
     let _ = vec.iter().cloned().for_each(|x| assert!(!x.is_empty()));
 
     // Not implemented yet
diff --git a/tests/ui/iter_overeager_cloned.stderr b/tests/ui/iter_overeager_cloned.stderr
index bdbb04d7f08..4417a40a63b 100644
--- a/tests/ui/iter_overeager_cloned.stderr
+++ b/tests/ui/iter_overeager_cloned.stderr
@@ -130,5 +130,21 @@ LL |             iter.cloned().filter(move |S { a, b }| **a == 1 && b == &target
    |                 |
    |                 help: try: `.filter(move |&S { a, b }| **a == 1 && b == &target).cloned()`
 
-error: aborting due to 15 previous errors
+error: unneeded cloning of iterator items
+  --> $DIR/iter_overeager_cloned.rs:60:13
+   |
+LL |     let _ = vec.iter().cloned().map(|x| x.len());
+   |             ^^^^^^^^^^--------------------------
+   |                       |
+   |                       help: try: `.map(|x| x.len())`
+
+error: unneeded cloning of iterator items
+  --> $DIR/iter_overeager_cloned.rs:65:13
+   |
+LL |     let _ = vec.iter().cloned().for_each(|x| assert!(!x.is_empty()));
+   |             ^^^^^^^^^^----------------------------------------------
+   |                       |
+   |                       help: try: `.for_each(|x| assert!(!x.is_empty()))`
+
+error: aborting due to 17 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 8f2d47ea72fdc754697b381441fb49953bf37b58 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Sat, 19 Aug 2023 18:06:46 +0000
Subject: Check that the suggested method exists in unwrap_or_default

---
 clippy_lints/src/methods/or_fun_call.rs | 19 +++++++++++++++++--
 tests/ui/unwrap_or_else_default.fixed   | 30 ++++++++++++++++++++++++++++++
 tests/ui/unwrap_or_else_default.rs      | 30 ++++++++++++++++++++++++++++++
 3 files changed, 77 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/or_fun_call.rs b/clippy_lints/src/methods/or_fun_call.rs
index 8b2f57160af..942f3bd79a6 100644
--- a/clippy_lints/src/methods/or_fun_call.rs
+++ b/clippy_lints/src/methods/or_fun_call.rs
@@ -65,11 +65,26 @@ pub(super) fn check<'tcx>(
         };
 
         let sugg = match (name, call_expr.is_some()) {
-            ("unwrap_or", true) | ("unwrap_or_else", false) => "unwrap_or_default",
-            ("or_insert", true) | ("or_insert_with", false) => "or_default",
+            ("unwrap_or", true) | ("unwrap_or_else", false) => sym!(unwrap_or_default),
+            ("or_insert", true) | ("or_insert_with", false) => sym!(or_default),
             _ => return false,
         };
 
+        let receiver_ty = cx.typeck_results().expr_ty_adjusted(receiver).peel_refs();
+        let has_suggested_method = receiver_ty.ty_adt_def().is_some_and(|adt_def| {
+            cx.tcx
+                .inherent_impls(adt_def.did())
+                .iter()
+                .flat_map(|impl_id| cx.tcx.associated_items(impl_id).filter_by_name_unhygienic(sugg))
+                .any(|assoc| {
+                    assoc.fn_has_self_parameter
+                        && cx.tcx.fn_sig(assoc.def_id).skip_binder().inputs().skip_binder().len() == 1
+                })
+        });
+        if !has_suggested_method {
+            return false;
+        }
+
         // needs to target Default::default in particular or be *::new and have a Default impl
         // available
         if (is_new(fun) && output_type_implements_default(fun))
diff --git a/tests/ui/unwrap_or_else_default.fixed b/tests/ui/unwrap_or_else_default.fixed
index 73d99907958..8d5d34175c5 100644
--- a/tests/ui/unwrap_or_else_default.fixed
+++ b/tests/ui/unwrap_or_else_default.fixed
@@ -130,4 +130,34 @@ fn method_call_with_deref() {
     let _ = inner_map.entry(0).or_default();
 }
 
+fn missing_suggested_method() {
+    #[derive(Copy, Clone)]
+    struct S<T>(T);
+
+    impl<T> S<T> {
+        fn or_insert_with(&mut self, default: impl FnOnce() -> T) -> &mut T {
+            &mut self.0
+        }
+
+        fn or_insert(&mut self, default: T) -> &mut T {
+            &mut self.0
+        }
+
+        fn unwrap_or_else(self, default: impl FnOnce() -> T) -> T {
+            self.0
+        }
+
+        fn unwrap_or(self, default: T) -> T {
+            self.0
+        }
+    }
+
+    // Don't lint when or_default/unwrap_or_default do not exist on the type
+    let mut s = S(1);
+    s.or_insert_with(Default::default);
+    s.or_insert(Default::default());
+    s.unwrap_or_else(Default::default);
+    s.unwrap_or(Default::default());
+}
+
 fn main() {}
diff --git a/tests/ui/unwrap_or_else_default.rs b/tests/ui/unwrap_or_else_default.rs
index afacedf17c6..adbcb4b4465 100644
--- a/tests/ui/unwrap_or_else_default.rs
+++ b/tests/ui/unwrap_or_else_default.rs
@@ -130,4 +130,34 @@ fn method_call_with_deref() {
     let _ = inner_map.entry(0).or_insert_with(Default::default);
 }
 
+fn missing_suggested_method() {
+    #[derive(Copy, Clone)]
+    struct S<T>(T);
+
+    impl<T> S<T> {
+        fn or_insert_with(&mut self, default: impl FnOnce() -> T) -> &mut T {
+            &mut self.0
+        }
+
+        fn or_insert(&mut self, default: T) -> &mut T {
+            &mut self.0
+        }
+
+        fn unwrap_or_else(self, default: impl FnOnce() -> T) -> T {
+            self.0
+        }
+
+        fn unwrap_or(self, default: T) -> T {
+            self.0
+        }
+    }
+
+    // Don't lint when or_default/unwrap_or_default do not exist on the type
+    let mut s = S(1);
+    s.or_insert_with(Default::default);
+    s.or_insert(Default::default());
+    s.unwrap_or_else(Default::default);
+    s.unwrap_or(Default::default());
+}
+
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 7fbf808a5056f63da5d2ae86ebeb32fb21f45b50 Mon Sep 17 00:00:00 2001
From: Red Rapious <red.rapious@gmail.com>
Date: Mon, 21 Aug 2023 18:50:53 +0200
Subject: Added new lint: `reserve_after_initialization`

---
 CHANGELOG.md                                     |   1 +
 clippy_lints/src/declared_lints.rs               |   1 +
 clippy_lints/src/lib.rs                          |   2 +
 clippy_lints/src/reserve_after_initialization.rs | 242 +++++++++++++++++++++++
 tests/ui/reserve_after_initialization.fixed      |   5 +
 tests/ui/reserve_after_initialization.rs         |   6 +
 tests/ui/reserve_after_initialization.stderr     |  11 ++
 7 files changed, 268 insertions(+)
 create mode 100644 clippy_lints/src/reserve_after_initialization.rs
 create mode 100644 tests/ui/reserve_after_initialization.fixed
 create mode 100644 tests/ui/reserve_after_initialization.rs
 create mode 100644 tests/ui/reserve_after_initialization.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index fe64283462d..4e33cb7b457 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5299,6 +5299,7 @@ Released 2018-09-13
 [`regex_macro`]: https://rust-lang.github.io/rust-clippy/master/index.html#regex_macro
 [`repeat_once`]: https://rust-lang.github.io/rust-clippy/master/index.html#repeat_once
 [`replace_consts`]: https://rust-lang.github.io/rust-clippy/master/index.html#replace_consts
+[`reserve_after_initialization`]: https://rust-lang.github.io/rust-clippy/master/index.html#reserve_after_initialization
 [`rest_pat_in_fully_bound_structs`]: https://rust-lang.github.io/rust-clippy/master/index.html#rest_pat_in_fully_bound_structs
 [`result_expect_used`]: https://rust-lang.github.io/rust-clippy/master/index.html#result_expect_used
 [`result_large_err`]: https://rust-lang.github.io/rust-clippy/master/index.html#result_large_err
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index bab77f91269..1be9720fbbf 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -579,6 +579,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::reference::DEREF_ADDROF_INFO,
     crate::regex::INVALID_REGEX_INFO,
     crate::regex::TRIVIAL_REGEX_INFO,
+    crate::reserve_after_initialization::RESERVE_AFTER_INITIALIZATION_INFO,
     crate::return_self_not_must_use::RETURN_SELF_NOT_MUST_USE_INFO,
     crate::returns::LET_AND_RETURN_INFO,
     crate::returns::NEEDLESS_RETURN_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 358004cf460..791fb96453d 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -285,6 +285,7 @@ mod ref_option_ref;
 mod ref_patterns;
 mod reference;
 mod regex;
+mod reserve_after_initialization;
 mod return_self_not_must_use;
 mod returns;
 mod same_name_method;
@@ -1095,6 +1096,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     });
     store.register_late_pass(|_| Box::new(redundant_locals::RedundantLocals));
     store.register_late_pass(|_| Box::new(ignored_unit_patterns::IgnoredUnitPatterns));
+    store.register_late_pass(|_| Box::new(reserve_after_initialization::ReserveAfterInitialization::default()));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/reserve_after_initialization.rs b/clippy_lints/src/reserve_after_initialization.rs
new file mode 100644
index 00000000000..073f810048c
--- /dev/null
+++ b/clippy_lints/src/reserve_after_initialization.rs
@@ -0,0 +1,242 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::higher::{get_vec_init_kind, VecInitKind};
+use clippy_utils::source::snippet;
+use clippy_utils::visitors::for_each_local_use_after_expr;
+use clippy_utils::{get_parent_expr, path_to_local_id};
+use core::ops::ControlFlow;
+use rustc_ast::LitKind;
+use rustc_errors::Applicability;
+use rustc_hir::def::Res;
+use rustc_hir::{
+    BindingAnnotation, Block, Expr, ExprKind, HirId, Local, Mutability, PatKind, QPath, Stmt, StmtKind, UnOp,
+};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_middle::lint::in_external_macro;
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::{Span, Symbol};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Informs the user about a more concise way to create a vector with a known capacity.
+    ///
+    /// ### Why is this bad?
+    /// The `Vec::with_capacity` constructor is easier to understand.
+    ///
+    /// ### Example
+    /// ```rust
+    /// {
+    ///     let mut v = vec![];
+    ///     v.reserve(space_hint);
+    ///     v
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// Vec::with_capacity(space_hint)
+    /// ```
+    #[clippy::version = "1.73.0"]
+    pub RESERVE_AFTER_INITIALIZATION,
+    complexity,
+    "`reserve` called immediatly after `Vec` creation"
+}
+impl_lint_pass!(ReserveAfterInitialization => [RESERVE_AFTER_INITIALIZATION]);
+
+/*impl<'tcx> LateLintPass<'tcx> for ReserveAfterInitialization {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx rustc_hir::Expr<'_>) {
+        if let ExprKind::Assign(left, right, _) = expr.kind
+        && let ExprKind::Path(QPath::Resolved(None, path)) = left.kind
+        && let [name] = &path.segments
+        && let Res::Local(id) = path.res
+        && let Some(init) = get_vec_init_kind(cx, right)
+        && !matches!(init, VecInitKind::WithExprCapacity(_)) {
+            span_lint_and_help(
+                cx,
+                RESERVE_AFTER_INITIALIZATION,
+                expr.span,
+                "`reserve` called just after the initialisation of the vector",
+                None,
+                "use `Vec::with_capacity(space_hint)` instead"
+            );
+        }
+    }
+
+    /*fn check_block(&mut self, cx: &LateContext<'_>, block: &'_ rustc_hir::Block<'_>) {
+        span_lint_and_help(
+            cx,
+            RESERVE_AFTER_INITIALIZATION,
+            block.span,
+            "`reserve` called just after the initialisation of the vector",
+            None,
+            "use `Vec::with_capacity(space_hint)` instead"
+        );
+    }*/
+}*/
+
+#[derive(Default)]
+pub struct ReserveAfterInitialization {
+    searcher: Option<VecReserveSearcher>,
+}
+
+struct VecReserveSearcher {
+    local_id: HirId,
+    lhs_is_let: bool,
+    let_ty_span: Option<Span>,
+    name: Symbol,
+    err_span: Span,
+    last_reserve_expr: HirId,
+    space_hint: usize,
+}
+impl VecReserveSearcher {
+    fn display_err(&self, cx: &LateContext<'_>) {
+        if self.space_hint == 0 {
+            return;
+        }
+
+        let mut needs_mut = false;
+        let _res = for_each_local_use_after_expr(cx, self.local_id, self.last_reserve_expr, |e| {
+            let Some(parent) = get_parent_expr(cx, e) else {
+                return ControlFlow::Continue(());
+            };
+            let adjusted_ty = cx.typeck_results().expr_ty_adjusted(e);
+            let adjusted_mut = adjusted_ty.ref_mutability().unwrap_or(Mutability::Not);
+            needs_mut |= adjusted_mut == Mutability::Mut;
+            match parent.kind {
+                ExprKind::AddrOf(_, Mutability::Mut, _) => {
+                    needs_mut = true;
+                    return ControlFlow::Break(true);
+                },
+                ExprKind::Unary(UnOp::Deref, _) | ExprKind::Index(..) if !needs_mut => {
+                    let mut last_place = parent;
+                    while let Some(parent) = get_parent_expr(cx, last_place) {
+                        if matches!(parent.kind, ExprKind::Unary(UnOp::Deref, _) | ExprKind::Field(..))
+                            || matches!(parent.kind, ExprKind::Index(e, _, _) if e.hir_id == last_place.hir_id)
+                        {
+                            last_place = parent;
+                        } else {
+                            break;
+                        }
+                    }
+                    needs_mut |= cx.typeck_results().expr_ty_adjusted(last_place).ref_mutability()
+                        == Some(Mutability::Mut)
+                        || get_parent_expr(cx, last_place)
+                            .map_or(false, |e| matches!(e.kind, ExprKind::AddrOf(_, Mutability::Mut, _)));
+                },
+                ExprKind::MethodCall(_, recv, ..)
+                    if recv.hir_id == e.hir_id
+                        && adjusted_mut == Mutability::Mut
+                        && !adjusted_ty.peel_refs().is_slice() =>
+                {
+                    // No need to set `needs_mut` to true. The receiver will be either explicitly borrowed, or it will
+                    // be implicitly borrowed via an adjustment. Both of these cases are already handled by this point.
+                    return ControlFlow::Break(true);
+                },
+                ExprKind::Assign(lhs, ..) if e.hir_id == lhs.hir_id => {
+                    needs_mut = true;
+                    return ControlFlow::Break(false);
+                },
+                _ => (),
+            }
+            ControlFlow::Continue(())
+        });
+
+        let mut s = if self.lhs_is_let {
+            String::from("let ")
+        } else {
+            String::new()
+        };
+        if needs_mut {
+            s.push_str("mut ");
+        }
+        s.push_str(self.name.as_str());
+        if let Some(span) = self.let_ty_span {
+            s.push_str(": ");
+            s.push_str(&snippet(cx, span, "_"));
+        }
+        s.push_str(format!(" = Vec::with_capacity({});", self.space_hint).as_str());
+
+        span_lint_and_sugg(
+            cx,
+            RESERVE_AFTER_INITIALIZATION,
+            self.err_span,
+            "calls to `reverse` immediately after creation",
+            "consider using `Vec::with_capacity(space_hint)`",
+            s,
+            Applicability::HasPlaceholders,
+        );
+    }
+}
+
+impl<'tcx> LateLintPass<'tcx> for ReserveAfterInitialization {
+    fn check_block(&mut self, _: &LateContext<'tcx>, _: &'tcx Block<'tcx>) {
+        self.searcher = None;
+    }
+
+    fn check_local(&mut self, cx: &LateContext<'tcx>, local: &'tcx Local<'tcx>) {
+        if let Some(init_expr) = local.init
+            && let PatKind::Binding(BindingAnnotation::MUT, id, name, None) = local.pat.kind
+            && !in_external_macro(cx.sess(), local.span)
+            && let Some(init) = get_vec_init_kind(cx, init_expr)
+            && !matches!(init, VecInitKind::WithExprCapacity(_))
+        {
+            self.searcher = Some(VecReserveSearcher {
+                local_id: id,
+                lhs_is_let: true,
+                name: name.name,
+                let_ty_span: local.ty.map(|ty| ty.span),
+                err_span: local.span,
+                last_reserve_expr: init_expr.hir_id,
+                space_hint: 0
+            });
+        }
+    }
+
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        if self.searcher.is_none()
+            && let ExprKind::Assign(left, right, _) = expr.kind
+            && let ExprKind::Path(QPath::Resolved(None, path)) = left.kind
+            && let [name] = &path.segments
+            && let Res::Local(id) = path.res
+            && !in_external_macro(cx.sess(), expr.span)
+            && let Some(init) = get_vec_init_kind(cx, right)
+            && !matches!(init, VecInitKind::WithExprCapacity(_))
+        {
+            self.searcher = Some(VecReserveSearcher {
+                local_id: id,
+                lhs_is_let: false,
+                let_ty_span: None,
+                name: name.ident.name,
+                err_span: expr.span,
+                last_reserve_expr: expr.hir_id,
+                space_hint: 0
+            });
+        }
+    }
+
+    fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) {
+        if let Some(searcher) = self.searcher.take() {
+            if let StmtKind::Expr(expr) | StmtKind::Semi(expr) = stmt.kind
+                && let ExprKind::MethodCall(name, self_arg, other_args, _) = expr.kind
+                && other_args.len() == 1
+                && let ExprKind::Lit(lit) = other_args[0].kind
+                && let LitKind::Int(space_hint, _) = lit.node
+                && path_to_local_id(self_arg, searcher.local_id)
+                && name.ident.as_str() == "reserve"
+            {
+                self.searcher = Some(VecReserveSearcher {
+                    err_span: searcher.err_span.to(stmt.span),
+                    last_reserve_expr: expr.hir_id,
+                    space_hint: space_hint as usize,
+                    .. searcher
+                });
+            } else {
+                searcher.display_err(cx);
+            }
+        }
+    }
+
+    fn check_block_post(&mut self, cx: &LateContext<'tcx>, _: &'tcx Block<'tcx>) {
+        if let Some(searcher) = self.searcher.take() {
+            searcher.display_err(cx);
+        }
+    }
+}
diff --git a/tests/ui/reserve_after_initialization.fixed b/tests/ui/reserve_after_initialization.fixed
new file mode 100644
index 00000000000..fe1f7ff174e
--- /dev/null
+++ b/tests/ui/reserve_after_initialization.fixed
@@ -0,0 +1,5 @@
+#![warn(clippy::reserve_after_initialization)]
+
+fn main() {
+    let v: Vec<usize> = Vec::with_capacity(10);
+}
diff --git a/tests/ui/reserve_after_initialization.rs b/tests/ui/reserve_after_initialization.rs
new file mode 100644
index 00000000000..469b951b1c4
--- /dev/null
+++ b/tests/ui/reserve_after_initialization.rs
@@ -0,0 +1,6 @@
+#![warn(clippy::reserve_after_initialization)]
+
+fn main() {
+    let mut v: Vec<usize> = vec![];
+    v.reserve(10);
+}
diff --git a/tests/ui/reserve_after_initialization.stderr b/tests/ui/reserve_after_initialization.stderr
new file mode 100644
index 00000000000..da8c7d693f0
--- /dev/null
+++ b/tests/ui/reserve_after_initialization.stderr
@@ -0,0 +1,11 @@
+error: calls to `reverse` immediately after creation
+  --> $DIR/reserve_after_initialization.rs:4:5
+   |
+LL | /     let mut v: Vec<usize> = vec![];
+LL | |     v.reserve(10);
+   | |__________________^ help: consider using `Vec::with_capacity(space_hint)`: `let v: Vec<usize> = Vec::with_capacity(10);`
+   |
+   = note: `-D clippy::reserve-after-initialization` implied by `-D warnings`
+
+error: aborting due to previous error
+
-- 
cgit 1.4.1-3-g733a5


From e33a17e33c0201f8fe00a17e875fe8f8b7210ce5 Mon Sep 17 00:00:00 2001
From: Red Rapious <red.rapious@gmail.com>
Date: Mon, 21 Aug 2023 19:05:59 +0200
Subject: Changed Box

---
 clippy_lints/src/lib.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 791fb96453d..f50019f3cf7 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1096,7 +1096,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     });
     store.register_late_pass(|_| Box::new(redundant_locals::RedundantLocals));
     store.register_late_pass(|_| Box::new(ignored_unit_patterns::IgnoredUnitPatterns));
-    store.register_late_pass(|_| Box::new(reserve_after_initialization::ReserveAfterInitialization::default()));
+    store.register_late_pass(|_| Box::<reserve_after_initialization::ReserveAfterInitialization>::default());
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
-- 
cgit 1.4.1-3-g733a5


From 073149a7ef483b8feddacc865e935d6019272e14 Mon Sep 17 00:00:00 2001
From: Red Rapious <red.rapious@gmail.com>
Date: Mon, 21 Aug 2023 19:21:02 +0200
Subject: Changed documentation example and removed comments

---
 clippy_lints/src/reserve_after_initialization.rs | 40 ++----------------------
 1 file changed, 3 insertions(+), 37 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/reserve_after_initialization.rs b/clippy_lints/src/reserve_after_initialization.rs
index 073f810048c..6a2bbd0af85 100644
--- a/clippy_lints/src/reserve_after_initialization.rs
+++ b/clippy_lints/src/reserve_after_initialization.rs
@@ -24,15 +24,12 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust
-    /// {
-    ///     let mut v = vec![];
-    ///     v.reserve(space_hint);
-    ///     v
-    /// }
+    /// let mut v: Vec<usize> = vec![];
+    /// v.reserve(10);
     /// ```
     /// Use instead:
     /// ```rust
-    /// Vec::with_capacity(space_hint)
+    /// let mut v: Vec<usize> = Vec::with_capacity(10);
     /// ```
     #[clippy::version = "1.73.0"]
     pub RESERVE_AFTER_INITIALIZATION,
@@ -41,37 +38,6 @@ declare_clippy_lint! {
 }
 impl_lint_pass!(ReserveAfterInitialization => [RESERVE_AFTER_INITIALIZATION]);
 
-/*impl<'tcx> LateLintPass<'tcx> for ReserveAfterInitialization {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx rustc_hir::Expr<'_>) {
-        if let ExprKind::Assign(left, right, _) = expr.kind
-        && let ExprKind::Path(QPath::Resolved(None, path)) = left.kind
-        && let [name] = &path.segments
-        && let Res::Local(id) = path.res
-        && let Some(init) = get_vec_init_kind(cx, right)
-        && !matches!(init, VecInitKind::WithExprCapacity(_)) {
-            span_lint_and_help(
-                cx,
-                RESERVE_AFTER_INITIALIZATION,
-                expr.span,
-                "`reserve` called just after the initialisation of the vector",
-                None,
-                "use `Vec::with_capacity(space_hint)` instead"
-            );
-        }
-    }
-
-    /*fn check_block(&mut self, cx: &LateContext<'_>, block: &'_ rustc_hir::Block<'_>) {
-        span_lint_and_help(
-            cx,
-            RESERVE_AFTER_INITIALIZATION,
-            block.span,
-            "`reserve` called just after the initialisation of the vector",
-            None,
-            "use `Vec::with_capacity(space_hint)` instead"
-        );
-    }*/
-}*/
-
 #[derive(Default)]
 pub struct ReserveAfterInitialization {
     searcher: Option<VecReserveSearcher>,
-- 
cgit 1.4.1-3-g733a5


From a1bf23f0a394788aec496e5440d8520d2807caec Mon Sep 17 00:00:00 2001
From: Red Rapious <red.rapious@gmail.com>
Date: Mon, 21 Aug 2023 22:22:48 +0200
Subject: Added more use cases

---
 clippy_lints/src/reserve_after_initialization.rs | 43 +++++++++++++++++-------
 1 file changed, 30 insertions(+), 13 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/reserve_after_initialization.rs b/clippy_lints/src/reserve_after_initialization.rs
index 6a2bbd0af85..f9454bd7540 100644
--- a/clippy_lints/src/reserve_after_initialization.rs
+++ b/clippy_lints/src/reserve_after_initialization.rs
@@ -50,11 +50,11 @@ struct VecReserveSearcher {
     name: Symbol,
     err_span: Span,
     last_reserve_expr: HirId,
-    space_hint: usize,
+    space_hint: Option<usize>,
 }
 impl VecReserveSearcher {
     fn display_err(&self, cx: &LateContext<'_>) {
-        if self.space_hint == 0 {
+        if self.space_hint == Some(0) {
             return;
         }
 
@@ -118,7 +118,16 @@ impl VecReserveSearcher {
             s.push_str(": ");
             s.push_str(&snippet(cx, span, "_"));
         }
-        s.push_str(format!(" = Vec::with_capacity({});", self.space_hint).as_str());
+        s.push_str(
+            format!(
+                " = Vec::with_capacity({});",
+                match self.space_hint {
+                    None => "..".to_string(),
+                    Some(hint) => hint.to_string(),
+                }
+            )
+            .as_str(),
+        );
 
         span_lint_and_sugg(
             cx,
@@ -151,7 +160,7 @@ impl<'tcx> LateLintPass<'tcx> for ReserveAfterInitialization {
                 let_ty_span: local.ty.map(|ty| ty.span),
                 err_span: local.span,
                 last_reserve_expr: init_expr.hir_id,
-                space_hint: 0
+                space_hint: Some(0)
             });
         }
     }
@@ -173,7 +182,7 @@ impl<'tcx> LateLintPass<'tcx> for ReserveAfterInitialization {
                 name: name.ident.name,
                 err_span: expr.span,
                 last_reserve_expr: expr.hir_id,
-                space_hint: 0
+                space_hint: Some(0)
             });
         }
     }
@@ -183,17 +192,25 @@ impl<'tcx> LateLintPass<'tcx> for ReserveAfterInitialization {
             if let StmtKind::Expr(expr) | StmtKind::Semi(expr) = stmt.kind
                 && let ExprKind::MethodCall(name, self_arg, other_args, _) = expr.kind
                 && other_args.len() == 1
-                && let ExprKind::Lit(lit) = other_args[0].kind
-                && let LitKind::Int(space_hint, _) = lit.node
                 && path_to_local_id(self_arg, searcher.local_id)
                 && name.ident.as_str() == "reserve"
             {
-                self.searcher = Some(VecReserveSearcher {
-                    err_span: searcher.err_span.to(stmt.span),
-                    last_reserve_expr: expr.hir_id,
-                    space_hint: space_hint as usize,
-                    .. searcher
-                });
+                if let ExprKind::Lit(lit) = other_args[0].kind
+                && let LitKind::Int(space_hint, _) = lit.node {
+                    self.searcher = Some(VecReserveSearcher {
+                        err_span: searcher.err_span.to(stmt.span),
+                        last_reserve_expr: expr.hir_id,
+                        space_hint: Some(space_hint as usize), // the expression is an int, so we'll display the good amount as a hint
+                        .. searcher
+                    });
+                } else {
+                    self.searcher = Some(VecReserveSearcher {
+                        err_span: searcher.err_span.to(stmt.span),
+                        last_reserve_expr: expr.hir_id,
+                        space_hint: None, // the expression isn't an int, so we'll display ".." as hint
+                        .. searcher
+                    });
+                }
             } else {
                 searcher.display_err(cx);
             }
-- 
cgit 1.4.1-3-g733a5


From b0bd6219c8f62ea97bbc6d5580f9b847758fb195 Mon Sep 17 00:00:00 2001
From: Red Rapious <red.rapious@gmail.com>
Date: Mon, 21 Aug 2023 23:36:15 +0200
Subject: Simplified code and added tests

---
 clippy_lints/src/reserve_after_initialization.rs | 138 +++++------------------
 tests/ui/reserve_after_initialization.fixed      |  14 ++-
 tests/ui/reserve_after_initialization.rs         |  17 ++-
 tests/ui/reserve_after_initialization.stderr     |  17 ++-
 4 files changed, 66 insertions(+), 120 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/reserve_after_initialization.rs b/clippy_lints/src/reserve_after_initialization.rs
index f9454bd7540..d530d5758b1 100644
--- a/clippy_lints/src/reserve_after_initialization.rs
+++ b/clippy_lints/src/reserve_after_initialization.rs
@@ -1,19 +1,15 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::higher::{get_vec_init_kind, VecInitKind};
+use clippy_utils::path_to_local_id;
 use clippy_utils::source::snippet;
-use clippy_utils::visitors::for_each_local_use_after_expr;
-use clippy_utils::{get_parent_expr, path_to_local_id};
-use core::ops::ControlFlow;
-use rustc_ast::LitKind;
+//use rustc_ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::def::Res;
-use rustc_hir::{
-    BindingAnnotation, Block, Expr, ExprKind, HirId, Local, Mutability, PatKind, QPath, Stmt, StmtKind, UnOp,
-};
+use rustc_hir::{BindingAnnotation, Block, Expr, ExprKind, HirId, Local, PatKind, QPath, Stmt, StmtKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::{Span, Symbol};
+use rustc_span::Span;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -45,89 +41,17 @@ pub struct ReserveAfterInitialization {
 
 struct VecReserveSearcher {
     local_id: HirId,
-    lhs_is_let: bool,
-    let_ty_span: Option<Span>,
-    name: Symbol,
     err_span: Span,
-    last_reserve_expr: HirId,
-    space_hint: Option<usize>,
+    init_part: String,
+    space_hint: String,
 }
 impl VecReserveSearcher {
     fn display_err(&self, cx: &LateContext<'_>) {
-        if self.space_hint == Some(0) {
+        if self.space_hint.is_empty() {
             return;
         }
 
-        let mut needs_mut = false;
-        let _res = for_each_local_use_after_expr(cx, self.local_id, self.last_reserve_expr, |e| {
-            let Some(parent) = get_parent_expr(cx, e) else {
-                return ControlFlow::Continue(());
-            };
-            let adjusted_ty = cx.typeck_results().expr_ty_adjusted(e);
-            let adjusted_mut = adjusted_ty.ref_mutability().unwrap_or(Mutability::Not);
-            needs_mut |= adjusted_mut == Mutability::Mut;
-            match parent.kind {
-                ExprKind::AddrOf(_, Mutability::Mut, _) => {
-                    needs_mut = true;
-                    return ControlFlow::Break(true);
-                },
-                ExprKind::Unary(UnOp::Deref, _) | ExprKind::Index(..) if !needs_mut => {
-                    let mut last_place = parent;
-                    while let Some(parent) = get_parent_expr(cx, last_place) {
-                        if matches!(parent.kind, ExprKind::Unary(UnOp::Deref, _) | ExprKind::Field(..))
-                            || matches!(parent.kind, ExprKind::Index(e, _, _) if e.hir_id == last_place.hir_id)
-                        {
-                            last_place = parent;
-                        } else {
-                            break;
-                        }
-                    }
-                    needs_mut |= cx.typeck_results().expr_ty_adjusted(last_place).ref_mutability()
-                        == Some(Mutability::Mut)
-                        || get_parent_expr(cx, last_place)
-                            .map_or(false, |e| matches!(e.kind, ExprKind::AddrOf(_, Mutability::Mut, _)));
-                },
-                ExprKind::MethodCall(_, recv, ..)
-                    if recv.hir_id == e.hir_id
-                        && adjusted_mut == Mutability::Mut
-                        && !adjusted_ty.peel_refs().is_slice() =>
-                {
-                    // No need to set `needs_mut` to true. The receiver will be either explicitly borrowed, or it will
-                    // be implicitly borrowed via an adjustment. Both of these cases are already handled by this point.
-                    return ControlFlow::Break(true);
-                },
-                ExprKind::Assign(lhs, ..) if e.hir_id == lhs.hir_id => {
-                    needs_mut = true;
-                    return ControlFlow::Break(false);
-                },
-                _ => (),
-            }
-            ControlFlow::Continue(())
-        });
-
-        let mut s = if self.lhs_is_let {
-            String::from("let ")
-        } else {
-            String::new()
-        };
-        if needs_mut {
-            s.push_str("mut ");
-        }
-        s.push_str(self.name.as_str());
-        if let Some(span) = self.let_ty_span {
-            s.push_str(": ");
-            s.push_str(&snippet(cx, span, "_"));
-        }
-        s.push_str(
-            format!(
-                " = Vec::with_capacity({});",
-                match self.space_hint {
-                    None => "..".to_string(),
-                    Some(hint) => hint.to_string(),
-                }
-            )
-            .as_str(),
-        );
+        let s = format!("{} = Vec::with_capacity({});", self.init_part, self.space_hint);
 
         span_lint_and_sugg(
             cx,
@@ -148,19 +72,22 @@ impl<'tcx> LateLintPass<'tcx> for ReserveAfterInitialization {
 
     fn check_local(&mut self, cx: &LateContext<'tcx>, local: &'tcx Local<'tcx>) {
         if let Some(init_expr) = local.init
-            && let PatKind::Binding(BindingAnnotation::MUT, id, name, None) = local.pat.kind
+            && let PatKind::Binding(BindingAnnotation::MUT, id, _name, None) = local.pat.kind
             && !in_external_macro(cx.sess(), local.span)
             && let Some(init) = get_vec_init_kind(cx, init_expr)
             && !matches!(init, VecInitKind::WithExprCapacity(_))
+            && !matches!(init, VecInitKind::WithConstCapacity(_))
         {
             self.searcher = Some(VecReserveSearcher {
                 local_id: id,
-                lhs_is_let: true,
-                name: name.name,
-                let_ty_span: local.ty.map(|ty| ty.span),
                 err_span: local.span,
-                last_reserve_expr: init_expr.hir_id,
-                space_hint: Some(0)
+                init_part: format!("let {}: {}", 
+                snippet(cx, local.pat.span, ""),
+                match local.ty {
+                    Some(type_inference) => snippet(cx, type_inference.span, "").to_string(),
+                    None => String::new()
+                }),
+                space_hint: String::new()
             });
         }
     }
@@ -169,20 +96,18 @@ impl<'tcx> LateLintPass<'tcx> for ReserveAfterInitialization {
         if self.searcher.is_none()
             && let ExprKind::Assign(left, right, _) = expr.kind
             && let ExprKind::Path(QPath::Resolved(None, path)) = left.kind
-            && let [name] = &path.segments
+            && let [_name] = &path.segments
             && let Res::Local(id) = path.res
             && !in_external_macro(cx.sess(), expr.span)
             && let Some(init) = get_vec_init_kind(cx, right)
             && !matches!(init, VecInitKind::WithExprCapacity(_))
+            && !matches!(init, VecInitKind::WithConstCapacity(_))
         {
             self.searcher = Some(VecReserveSearcher {
                 local_id: id,
-                lhs_is_let: false,
-                let_ty_span: None,
-                name: name.ident.name,
                 err_span: expr.span,
-                last_reserve_expr: expr.hir_id,
-                space_hint: Some(0)
+                init_part: snippet(cx, left.span, "").to_string(),
+                space_hint: String::new()
             });
         }
     }
@@ -195,22 +120,11 @@ impl<'tcx> LateLintPass<'tcx> for ReserveAfterInitialization {
                 && path_to_local_id(self_arg, searcher.local_id)
                 && name.ident.as_str() == "reserve"
             {
-                if let ExprKind::Lit(lit) = other_args[0].kind
-                && let LitKind::Int(space_hint, _) = lit.node {
-                    self.searcher = Some(VecReserveSearcher {
-                        err_span: searcher.err_span.to(stmt.span),
-                        last_reserve_expr: expr.hir_id,
-                        space_hint: Some(space_hint as usize), // the expression is an int, so we'll display the good amount as a hint
-                        .. searcher
-                    });
-                } else {
-                    self.searcher = Some(VecReserveSearcher {
-                        err_span: searcher.err_span.to(stmt.span),
-                        last_reserve_expr: expr.hir_id,
-                        space_hint: None, // the expression isn't an int, so we'll display ".." as hint
-                        .. searcher
-                    });
-                }
+                self.searcher = Some(VecReserveSearcher {
+                    err_span: searcher.err_span.to(stmt.span),
+                    space_hint: snippet(cx, other_args[0].span, "").to_string(),
+                    .. searcher
+                });
             } else {
                 searcher.display_err(cx);
             }
diff --git a/tests/ui/reserve_after_initialization.fixed b/tests/ui/reserve_after_initialization.fixed
index fe1f7ff174e..e7dd8f6b14f 100644
--- a/tests/ui/reserve_after_initialization.fixed
+++ b/tests/ui/reserve_after_initialization.fixed
@@ -1,5 +1,17 @@
 #![warn(clippy::reserve_after_initialization)]
 
 fn main() {
-    let v: Vec<usize> = Vec::with_capacity(10);
+    // Should lint
+    let mut v1: Vec<usize> = Vec::with_capacity(10);
+
+    // Should lint
+    let capacity = 10;
+    let mut v2: Vec<usize> = Vec::with_capacity(capacity);
+
+    // Shouldn't lint
+    let mut v3 = vec![1];
+    v3.reserve(10);
+
+    // Shouldn't lint
+    let mut v4: Vec<usize> = Vec::with_capacity(10);
 }
diff --git a/tests/ui/reserve_after_initialization.rs b/tests/ui/reserve_after_initialization.rs
index 469b951b1c4..07f9377dbfe 100644
--- a/tests/ui/reserve_after_initialization.rs
+++ b/tests/ui/reserve_after_initialization.rs
@@ -1,6 +1,19 @@
 #![warn(clippy::reserve_after_initialization)]
 
 fn main() {
-    let mut v: Vec<usize> = vec![];
-    v.reserve(10);
+    // Should lint
+    let mut v1: Vec<usize> = vec![];
+    v1.reserve(10);
+
+    // Should lint
+    let capacity = 10;
+    let mut v2: Vec<usize> = vec![];
+    v2.reserve(capacity);
+
+    // Shouldn't lint
+    let mut v3 = vec![1];
+    v3.reserve(10);
+
+    // Shouldn't lint
+    let mut v4: Vec<usize> = Vec::with_capacity(10);
 }
diff --git a/tests/ui/reserve_after_initialization.stderr b/tests/ui/reserve_after_initialization.stderr
index da8c7d693f0..ab2753cdd60 100644
--- a/tests/ui/reserve_after_initialization.stderr
+++ b/tests/ui/reserve_after_initialization.stderr
@@ -1,11 +1,18 @@
 error: calls to `reverse` immediately after creation
-  --> $DIR/reserve_after_initialization.rs:4:5
+  --> $DIR/reserve_after_initialization.rs:5:5
    |
-LL | /     let mut v: Vec<usize> = vec![];
-LL | |     v.reserve(10);
-   | |__________________^ help: consider using `Vec::with_capacity(space_hint)`: `let v: Vec<usize> = Vec::with_capacity(10);`
+LL | /     let mut v1: Vec<usize> = vec![];
+LL | |     v1.reserve(10);
+   | |___________________^ help: consider using `Vec::with_capacity(space_hint)`: `let mut v1: Vec<usize> = Vec::with_capacity(10);`
    |
    = note: `-D clippy::reserve-after-initialization` implied by `-D warnings`
 
-error: aborting due to previous error
+error: calls to `reverse` immediately after creation
+  --> $DIR/reserve_after_initialization.rs:10:5
+   |
+LL | /     let mut v2: Vec<usize> = vec![];
+LL | |     v2.reserve(capacity);
+   | |_________________________^ help: consider using `Vec::with_capacity(space_hint)`: `let mut v2: Vec<usize> = Vec::with_capacity(capacity);`
+
+error: aborting due to 2 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 77215672e9c29ad32eadcd65509738e21b714e86 Mon Sep 17 00:00:00 2001
From: J-ZhengLi <lizheng135@huawei.com>
Date: Tue, 22 Aug 2023 10:27:16 +0800
Subject: fix [`undocumented_unsafe_blocks`] not able to detect comment for
 global vars

---
 clippy_lints/src/undocumented_unsafe_blocks.rs     | 113 ++++++++++-----------
 .../undocumented_unsafe_blocks.rs                  |  14 +++
 2 files changed, 65 insertions(+), 62 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/undocumented_unsafe_blocks.rs b/clippy_lints/src/undocumented_unsafe_blocks.rs
index f2ef602012f..4ee817c0676 100644
--- a/clippy_lints/src/undocumented_unsafe_blocks.rs
+++ b/clippy_lints/src/undocumented_unsafe_blocks.rs
@@ -341,44 +341,21 @@ fn block_parents_have_safety_comment(
     id: hir::HirId,
 ) -> bool {
     if let Some(node) = get_parent_node(cx.tcx, id) {
-        return match node {
-            Node::Expr(expr) => {
-                if let Some(
-                    Node::Local(hir::Local { span, .. })
-                    | Node::Item(hir::Item {
-                        kind: hir::ItemKind::Const(..) | ItemKind::Static(..),
-                        span,
-                        ..
-                    }),
-                ) = get_parent_node(cx.tcx, expr.hir_id)
-                {
-                    let hir_id = match get_parent_node(cx.tcx, expr.hir_id) {
-                        Some(Node::Local(hir::Local { hir_id, .. })) => *hir_id,
-                        Some(Node::Item(hir::Item { owner_id, .. })) => {
-                            cx.tcx.hir().local_def_id_to_hir_id(owner_id.def_id)
-                        },
-                        _ => unreachable!(),
-                    };
-
-                    // if unsafe block is part of a let/const/static statement,
-                    // and accept_comment_above_statement is set to true
-                    // we accept the safety comment in the line the precedes this statement.
-                    accept_comment_above_statement
-                        && span_with_attrs_in_body_has_safety_comment(
-                            cx,
-                            *span,
-                            hir_id,
-                            accept_comment_above_attributes,
-                        )
-                } else {
-                    !is_branchy(expr)
-                        && span_with_attrs_in_body_has_safety_comment(
-                            cx,
-                            expr.span,
-                            expr.hir_id,
-                            accept_comment_above_attributes,
-                        )
-                }
+        let (span, hir_id) = match node {
+            Node::Expr(expr) => match get_parent_node(cx.tcx, expr.hir_id) {
+                Some(Node::Local(hir::Local { span, hir_id, .. })) => (*span, *hir_id),
+                Some(Node::Item(hir::Item {
+                    kind: hir::ItemKind::Const(..) | ItemKind::Static(..),
+                    span,
+                    owner_id,
+                    ..
+                })) => (*span, cx.tcx.hir().local_def_id_to_hir_id(owner_id.def_id)),
+                _ => {
+                    if is_branchy(expr) {
+                        return false;
+                    }
+                    (expr.span, expr.hir_id)
+                },
             },
             Node::Stmt(hir::Stmt {
                 kind:
@@ -387,28 +364,27 @@ fn block_parents_have_safety_comment(
                     | hir::StmtKind::Semi(hir::Expr { span, hir_id, .. }),
                 ..
             })
-            | Node::Local(hir::Local { span, hir_id, .. }) => {
-                span_with_attrs_in_body_has_safety_comment(cx, *span, *hir_id, accept_comment_above_attributes)
-            },
+            | Node::Local(hir::Local { span, hir_id, .. }) => (*span, *hir_id),
             Node::Item(hir::Item {
                 kind: hir::ItemKind::Const(..) | ItemKind::Static(..),
                 span,
                 owner_id,
                 ..
-            }) => span_with_attrs_in_body_has_safety_comment(
-                cx,
-                *span,
-                cx.tcx.hir().local_def_id_to_hir_id(owner_id.def_id),
-                accept_comment_above_attributes,
-            ),
-            _ => false,
+            }) => (*span, cx.tcx.hir().local_def_id_to_hir_id(owner_id.def_id)),
+            _ => return false,
         };
+        // if unsafe block is part of a let/const/static statement,
+        // and accept_comment_above_statement is set to true
+        // we accept the safety comment in the line the precedes this statement.
+        accept_comment_above_statement
+            && span_with_attrs_has_safety_comment(cx, span, hir_id, accept_comment_above_attributes)
+    } else {
+        false
     }
-    false
 }
 
 /// Extends `span` to also include its attributes, then checks if that span has a safety comment.
-fn span_with_attrs_in_body_has_safety_comment(
+fn span_with_attrs_has_safety_comment(
     cx: &LateContext<'_>,
     span: Span,
     hir_id: HirId,
@@ -420,7 +396,7 @@ fn span_with_attrs_in_body_has_safety_comment(
         span
     };
 
-    span_in_body_has_safety_comment(cx, span)
+    span_has_safety_comment(cx, span)
 }
 
 /// Checks if an expression is "branchy", e.g. loop, match/if/etc.
@@ -444,7 +420,7 @@ fn block_has_safety_comment(cx: &LateContext<'_>, span: Span) -> bool {
     matches!(
         span_from_macro_expansion_has_safety_comment(cx, span),
         HasSafetyComment::Yes(_)
-    ) || span_in_body_has_safety_comment(cx, span)
+    ) || span_has_safety_comment(cx, span)
 }
 
 fn include_attrs_in_span(cx: &LateContext<'_>, hir_id: HirId, span: Span) -> Span {
@@ -639,29 +615,42 @@ fn get_body_search_span(cx: &LateContext<'_>) -> Option<Span> {
     let body = cx.enclosing_body?;
     let map = cx.tcx.hir();
     let mut span = map.body(body).value.span;
+    let mut maybe_global_var = false;
     for (_, node) in map.parent_iter(body.hir_id) {
         match node {
-            Node::Expr(e) => span = e.span,
+            Node::Expr(e) => {
+                span = e.span;
+                // Note: setting this to `false` is to making sure a "in-function defined"
+                // const/static variable not mistakenly processed as global variable,
+                // since global var doesn't have an `Expr` parent as its parent???
+                maybe_global_var = false;
+            }
             Node::Block(_)
             | Node::Arm(_)
             | Node::Stmt(_)
-            | Node::Local(_)
-            | Node::Item(hir::Item {
-                kind: hir::ItemKind::Const(..) | ItemKind::Static(..),
-                ..
-            }) => (),
+            | Node::Local(_) => (),
+            Node::Item(hir::Item { kind, span: item_span, .. }) => {
+                if matches!(kind, hir::ItemKind::Const(..) | ItemKind::Static(..)) {
+                    maybe_global_var = true;
+                } else if maybe_global_var && let hir::ItemKind::Mod(_) = kind {
+                    span = *item_span;
+                } else {
+                    break;
+                }
+            }
+            Node::Crate(mod_) if maybe_global_var => {
+                span = mod_.spans.inner_span;
+            }
             _ => break,
         }
     }
     Some(span)
 }
 
-fn span_in_body_has_safety_comment(cx: &LateContext<'_>, span: Span) -> bool {
+fn span_has_safety_comment(cx: &LateContext<'_>, span: Span) -> bool {
     let source_map = cx.sess().source_map();
     let ctxt = span.ctxt();
-    if ctxt == SyntaxContext::root()
-        && let Some(search_span) = get_body_search_span(cx)
-    {
+    if ctxt.is_root() && let Some(search_span) = get_body_search_span(cx) {
         if let Ok(unsafe_line) = source_map.lookup_line(span.lo())
             && let Some(body_span) = walk_span_to_context(search_span, SyntaxContext::root())
             && let Ok(body_line) = source_map.lookup_line(body_span.lo())
diff --git a/tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs b/tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs
index c0976f0d600..a28cf9efbbc 100644
--- a/tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs
+++ b/tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs
@@ -564,4 +564,18 @@ fn issue_8679<T: Copy>() {
     unsafe {}
 }
 
+mod issue_11246 {
+    // Safety: foo
+    const _: () = unsafe {};
+
+    // Safety: A safety comment
+    const FOO: () = unsafe {};
+
+    // Safety: bar
+    static BAR: u8 = unsafe { 0 };
+}
+
+// Safety: Another safety comment
+const FOO: () = unsafe {};
+
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 82f2e52469f6130ce801e4296607c3f0e6843bf4 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Mon, 21 Aug 2023 22:28:17 -0400
Subject: Fix span when linting `explicit_auto_deref` immediately after
 `needless_borrow`

---
 clippy_lints/src/dereference.rs     |  8 +++++---
 tests/ui/explicit_auto_deref.fixed  |  8 +++++++-
 tests/ui/explicit_auto_deref.rs     |  6 ++++++
 tests/ui/explicit_auto_deref.stderr | 12 +++++++++---
 4 files changed, 27 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index bc011a6c354..fcedcfadd65 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -609,12 +609,14 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing<'tcx> {
                             adjusted_ty,
                         },
                     ));
-                } else if stability.is_deref_stable() {
+                } else if stability.is_deref_stable()
+                    && let Some(parent) = get_parent_expr(cx, expr)
+                {
                     self.state = Some((
                         State::ExplicitDeref { mutability: None },
                         StateData {
-                            span: expr.span,
-                            hir_id: expr.hir_id,
+                            span: parent.span,
+                            hir_id: parent.hir_id,
                             adjusted_ty,
                         },
                     ));
diff --git a/tests/ui/explicit_auto_deref.fixed b/tests/ui/explicit_auto_deref.fixed
index 86bee11eb87..d046a926935 100644
--- a/tests/ui/explicit_auto_deref.fixed
+++ b/tests/ui/explicit_auto_deref.fixed
@@ -205,7 +205,7 @@ fn main() {
         }
     }
 
-    f_str(&&ref_str); // `needless_borrow` will suggest removing both references
+    f_str(&ref_str); // `needless_borrow` will suggest removing both references
     f_str(&ref_str); // `needless_borrow` will suggest removing only one reference
 
     let x = &&40;
@@ -293,4 +293,10 @@ fn main() {
     fn return_dyn_assoc<'a>(x: &'a &'a u32) -> &'a <&'a u32 as WithAssoc>::Assoc {
         *x
     }
+
+    // Issue #11366
+    let _: &mut u32 = match &mut Some(&mut 0u32) {
+        Some(x) => x,
+        None => panic!(),
+    };
 }
diff --git a/tests/ui/explicit_auto_deref.rs b/tests/ui/explicit_auto_deref.rs
index 7a505bdf558..3dd08e487f8 100644
--- a/tests/ui/explicit_auto_deref.rs
+++ b/tests/ui/explicit_auto_deref.rs
@@ -293,4 +293,10 @@ fn main() {
     fn return_dyn_assoc<'a>(x: &'a &'a u32) -> &'a <&'a u32 as WithAssoc>::Assoc {
         *x
     }
+
+    // Issue #11366
+    let _: &mut u32 = match &mut Some(&mut 0u32) {
+        Some(x) => &mut *x,
+        None => panic!(),
+    };
 }
diff --git a/tests/ui/explicit_auto_deref.stderr b/tests/ui/explicit_auto_deref.stderr
index 34ce188530c..e98f1c40b27 100644
--- a/tests/ui/explicit_auto_deref.stderr
+++ b/tests/ui/explicit_auto_deref.stderr
@@ -193,10 +193,10 @@ LL |     let _ = f_str(**ref_ref_str);
    |                   ^^^^^^^^^^^^^ help: try: `ref_ref_str`
 
 error: deref which would be done by auto-deref
-  --> $DIR/explicit_auto_deref.rs:208:13
+  --> $DIR/explicit_auto_deref.rs:208:12
    |
 LL |     f_str(&&*ref_str); // `needless_borrow` will suggest removing both references
-   |             ^^^^^^^^ help: try: `ref_str`
+   |            ^^^^^^^^^ help: try: `ref_str`
 
 error: deref which would be done by auto-deref
   --> $DIR/explicit_auto_deref.rs:209:12
@@ -234,5 +234,11 @@ error: deref which would be done by auto-deref
 LL |         *x
    |         ^^ help: try: `x`
 
-error: aborting due to 39 previous errors
+error: deref which would be done by auto-deref
+  --> $DIR/explicit_auto_deref.rs:299:20
+   |
+LL |         Some(x) => &mut *x,
+   |                    ^^^^^^^ help: try: `x`
+
+error: aborting due to 40 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From e35eb91a337431b5894aa6755d0d8317b9aa2cca Mon Sep 17 00:00:00 2001
From: Igor Aleksanov <popzxc@yandex.ru>
Date: Tue, 22 Aug 2023 13:15:05 +0400
Subject: Fix tuple_array_conversions lint on nightly

---
 clippy_lints/src/tuple_array_conversions.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/tuple_array_conversions.rs b/clippy_lints/src/tuple_array_conversions.rs
index 78ad52d8a87..c12519d723c 100644
--- a/clippy_lints/src/tuple_array_conversions.rs
+++ b/clippy_lints/src/tuple_array_conversions.rs
@@ -189,8 +189,8 @@ fn all_bindings_are_for_conv<'tcx>(
                     tys.len() == elements.len() && tys.iter().chain(final_tys.iter().copied()).all_equal()
                 },
                 (ToType::Tuple, ty::Array(ty, len)) => {
-                    len.eval_target_usize(cx.tcx, cx.param_env) as usize == elements.len()
-                        && final_tys.iter().chain(once(ty)).all_equal()
+                    let Some(len) = len.try_eval_target_usize(cx.tcx, cx.param_env) else { return false };
+                    len as usize == elements.len() && final_tys.iter().chain(once(ty)).all_equal()
                 },
                 _ => false,
             }
-- 
cgit 1.4.1-3-g733a5


From df8bb47f1711d0db0dd6e9e8446b15b394721126 Mon Sep 17 00:00:00 2001
From: Red Rapious <red.rapious@gmail.com>
Date: Tue, 22 Aug 2023 18:46:16 +0200
Subject: Improved snippets and added tests

---
 clippy_lints/src/reserve_after_initialization.rs | 36 ++++++++--------
 tests/ui/reserve_after_initialization.fixed      | 51 ++++++++++++++++++++---
 tests/ui/reserve_after_initialization.rs         | 52 +++++++++++++++++++++---
 tests/ui/reserve_after_initialization.stderr     | 21 ++++++----
 4 files changed, 122 insertions(+), 38 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/reserve_after_initialization.rs b/clippy_lints/src/reserve_after_initialization.rs
index d530d5758b1..17ca9c8aab8 100644
--- a/clippy_lints/src/reserve_after_initialization.rs
+++ b/clippy_lints/src/reserve_after_initialization.rs
@@ -2,7 +2,6 @@ use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::higher::{get_vec_init_kind, VecInitKind};
 use clippy_utils::path_to_local_id;
 use clippy_utils::source::snippet;
-//use rustc_ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::def::Res;
 use rustc_hir::{BindingAnnotation, Block, Expr, ExprKind, HirId, Local, PatKind, QPath, Stmt, StmtKind};
@@ -16,7 +15,7 @@ declare_clippy_lint! {
     /// Informs the user about a more concise way to create a vector with a known capacity.
     ///
     /// ### Why is this bad?
-    /// The `Vec::with_capacity` constructor is easier to understand.
+    /// The `Vec::with_capacity` constructor is less complex.
     ///
     /// ### Example
     /// ```rust
@@ -51,14 +50,14 @@ impl VecReserveSearcher {
             return;
         }
 
-        let s = format!("{} = Vec::with_capacity({});", self.init_part, self.space_hint);
+        let s = format!("{}Vec::with_capacity({});", self.init_part, self.space_hint);
 
         span_lint_and_sugg(
             cx,
             RESERVE_AFTER_INITIALIZATION,
             self.err_span,
-            "calls to `reverse` immediately after creation",
-            "consider using `Vec::with_capacity(space_hint)`",
+            "call to `reserve` immediately after creation",
+            "consider using `Vec::with_capacity(/* Space hint */)`",
             s,
             Applicability::HasPlaceholders,
         );
@@ -72,7 +71,7 @@ impl<'tcx> LateLintPass<'tcx> for ReserveAfterInitialization {
 
     fn check_local(&mut self, cx: &LateContext<'tcx>, local: &'tcx Local<'tcx>) {
         if let Some(init_expr) = local.init
-            && let PatKind::Binding(BindingAnnotation::MUT, id, _name, None) = local.pat.kind
+            && let PatKind::Binding(BindingAnnotation::MUT, id, _, None) = local.pat.kind
             && !in_external_macro(cx.sess(), local.span)
             && let Some(init) = get_vec_init_kind(cx, init_expr)
             && !matches!(init, VecInitKind::WithExprCapacity(_))
@@ -81,12 +80,9 @@ impl<'tcx> LateLintPass<'tcx> for ReserveAfterInitialization {
             self.searcher = Some(VecReserveSearcher {
                 local_id: id,
                 err_span: local.span,
-                init_part: format!("let {}: {}", 
-                snippet(cx, local.pat.span, ""),
-                match local.ty {
-                    Some(type_inference) => snippet(cx, type_inference.span, "").to_string(),
-                    None => String::new()
-                }),
+                init_part: snippet(cx, local.span.shrink_to_lo()
+                    .to(init_expr.span.source_callsite().shrink_to_lo()), "..")
+                    .into_owned(),
                 space_hint: String::new()
             });
         }
@@ -96,17 +92,20 @@ impl<'tcx> LateLintPass<'tcx> for ReserveAfterInitialization {
         if self.searcher.is_none()
             && let ExprKind::Assign(left, right, _) = expr.kind
             && let ExprKind::Path(QPath::Resolved(None, path)) = left.kind
-            && let [_name] = &path.segments
+            && let [_] = &path.segments
             && let Res::Local(id) = path.res
             && !in_external_macro(cx.sess(), expr.span)
             && let Some(init) = get_vec_init_kind(cx, right)
-            && !matches!(init, VecInitKind::WithExprCapacity(_))
-            && !matches!(init, VecInitKind::WithConstCapacity(_))
+            && !matches!(init, VecInitKind::WithExprCapacity(_)
+               | VecInitKind::WithConstCapacity(_)
+            )
         {
             self.searcher = Some(VecReserveSearcher {
                 local_id: id,
                 err_span: expr.span,
-                init_part: snippet(cx, left.span, "").to_string(),
+                init_part: snippet(cx, left.span.shrink_to_lo()
+                    .to(right.span.source_callsite().shrink_to_lo()), "..")
+                    .into_owned(), // see `assign_expression` test
                 space_hint: String::new()
             });
         }
@@ -115,14 +114,13 @@ impl<'tcx> LateLintPass<'tcx> for ReserveAfterInitialization {
     fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) {
         if let Some(searcher) = self.searcher.take() {
             if let StmtKind::Expr(expr) | StmtKind::Semi(expr) = stmt.kind
-                && let ExprKind::MethodCall(name, self_arg, other_args, _) = expr.kind
-                && other_args.len() == 1
+                && let ExprKind::MethodCall(name, self_arg, [space_hint], _) = expr.kind
                 && path_to_local_id(self_arg, searcher.local_id)
                 && name.ident.as_str() == "reserve"
             {
                 self.searcher = Some(VecReserveSearcher {
                     err_span: searcher.err_span.to(stmt.span),
-                    space_hint: snippet(cx, other_args[0].span, "").to_string(),
+                    space_hint: snippet(cx, space_hint.span, "..").to_string(),
                     .. searcher
                 });
             } else {
diff --git a/tests/ui/reserve_after_initialization.fixed b/tests/ui/reserve_after_initialization.fixed
index e7dd8f6b14f..5ef848ed8cf 100644
--- a/tests/ui/reserve_after_initialization.fixed
+++ b/tests/ui/reserve_after_initialization.fixed
@@ -1,17 +1,56 @@
 #![warn(clippy::reserve_after_initialization)]
+#![no_main]
 
-fn main() {
-    // Should lint
+// Should lint
+fn standard() {
     let mut v1: Vec<usize> = Vec::with_capacity(10);
+}
 
-    // Should lint
+// Should lint
+fn capacity_as_expr() {
     let capacity = 10;
     let mut v2: Vec<usize> = Vec::with_capacity(capacity);
+}
 
-    // Shouldn't lint
+// Shouldn't lint
+fn vec_init_with_argument() {
     let mut v3 = vec![1];
     v3.reserve(10);
+}
+
+// Shouldn't lint
+fn called_with_capacity() {
+    let _v4: Vec<usize> = Vec::with_capacity(10);
+}
 
-    // Shouldn't lint
-    let mut v4: Vec<usize> = Vec::with_capacity(10);
+// Should lint
+fn assign_expression() {
+    let mut v5: Vec<usize> = Vec::new();
+    v5 = Vec::with_capacity(10);
 }
+
+/*fn in_macros() {
+    external! {
+        // Should lint
+        let mut v1: Vec<usize> = vec![];
+        v1.reserve(10);
+
+        // Should lint
+        let capacity = 10;
+        let mut v2: Vec<usize> = vec![];
+        v2.reserve(capacity);
+    }
+
+    with_span! {
+        span
+
+        // Should lint
+        let mut v1: Vec<usize> = vec![];
+        v1.reserve(10);
+
+        // Should lint
+        let capacity = 10;
+        let mut v2: Vec<usize> = vec![];
+        v2.reserve(capacity);
+    }
+}*/
diff --git a/tests/ui/reserve_after_initialization.rs b/tests/ui/reserve_after_initialization.rs
index 07f9377dbfe..eba7bc8dab3 100644
--- a/tests/ui/reserve_after_initialization.rs
+++ b/tests/ui/reserve_after_initialization.rs
@@ -1,19 +1,59 @@
 #![warn(clippy::reserve_after_initialization)]
+#![no_main]
 
-fn main() {
-    // Should lint
+// Should lint
+fn standard() {
     let mut v1: Vec<usize> = vec![];
     v1.reserve(10);
+}
 
-    // Should lint
+// Should lint
+fn capacity_as_expr() {
     let capacity = 10;
     let mut v2: Vec<usize> = vec![];
     v2.reserve(capacity);
+}
 
-    // Shouldn't lint
+// Shouldn't lint
+fn vec_init_with_argument() {
     let mut v3 = vec![1];
     v3.reserve(10);
+}
+
+// Shouldn't lint
+fn called_with_capacity() {
+    let _v4: Vec<usize> = Vec::with_capacity(10);
+}
 
-    // Shouldn't lint
-    let mut v4: Vec<usize> = Vec::with_capacity(10);
+// Should lint
+fn assign_expression() {
+    let mut v5: Vec<usize> = Vec::new();
+    v5 = Vec::new();
+    v5.reserve(10);
 }
+
+/*fn in_macros() {
+    external! {
+        // Should lint
+        let mut v1: Vec<usize> = vec![];
+        v1.reserve(10);
+
+        // Should lint
+        let capacity = 10;
+        let mut v2: Vec<usize> = vec![];
+        v2.reserve(capacity);
+    }
+
+    with_span! {
+        span
+
+        // Should lint
+        let mut v1: Vec<usize> = vec![];
+        v1.reserve(10);
+
+        // Should lint
+        let capacity = 10;
+        let mut v2: Vec<usize> = vec![];
+        v2.reserve(capacity);
+    }
+}*/
diff --git a/tests/ui/reserve_after_initialization.stderr b/tests/ui/reserve_after_initialization.stderr
index ab2753cdd60..e50a8a065ba 100644
--- a/tests/ui/reserve_after_initialization.stderr
+++ b/tests/ui/reserve_after_initialization.stderr
@@ -1,18 +1,25 @@
-error: calls to `reverse` immediately after creation
-  --> $DIR/reserve_after_initialization.rs:5:5
+error: call to `reserve` immediately after creation
+  --> $DIR/reserve_after_initialization.rs:6:5
    |
 LL | /     let mut v1: Vec<usize> = vec![];
 LL | |     v1.reserve(10);
-   | |___________________^ help: consider using `Vec::with_capacity(space_hint)`: `let mut v1: Vec<usize> = Vec::with_capacity(10);`
+   | |___________________^ help: consider using `Vec::with_capacity(/* Space hint */)`: `let mut v1: Vec<usize> = Vec::with_capacity(10);`
    |
    = note: `-D clippy::reserve-after-initialization` implied by `-D warnings`
 
-error: calls to `reverse` immediately after creation
-  --> $DIR/reserve_after_initialization.rs:10:5
+error: call to `reserve` immediately after creation
+  --> $DIR/reserve_after_initialization.rs:13:5
    |
 LL | /     let mut v2: Vec<usize> = vec![];
 LL | |     v2.reserve(capacity);
-   | |_________________________^ help: consider using `Vec::with_capacity(space_hint)`: `let mut v2: Vec<usize> = Vec::with_capacity(capacity);`
+   | |_________________________^ help: consider using `Vec::with_capacity(/* Space hint */)`: `let mut v2: Vec<usize> = Vec::with_capacity(capacity);`
 
-error: aborting due to 2 previous errors
+error: call to `reserve` immediately after creation
+  --> $DIR/reserve_after_initialization.rs:31:5
+   |
+LL | /     v5 = Vec::new();
+LL | |     v5.reserve(10);
+   | |___________________^ help: consider using `Vec::with_capacity(/* Space hint */)`: `v5 = Vec::with_capacity(10);`
+
+error: aborting due to 3 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 7977d209b27c14769c8e50b5f189cd27a716be3e Mon Sep 17 00:00:00 2001
From: Red Rapious <red.rapious@gmail.com>
Date: Tue, 22 Aug 2023 19:36:58 +0200
Subject: Do not lint inside macros

---
 clippy_lints/src/reserve_after_initialization.rs |  8 ++++---
 tests/ui/reserve_after_initialization.fixed      | 28 +++++++++---------------
 tests/ui/reserve_after_initialization.rs         | 28 +++++++++---------------
 tests/ui/reserve_after_initialization.stderr     |  6 ++---
 4 files changed, 28 insertions(+), 42 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/reserve_after_initialization.rs b/clippy_lints/src/reserve_after_initialization.rs
index 17ca9c8aab8..15f8c5da106 100644
--- a/clippy_lints/src/reserve_after_initialization.rs
+++ b/clippy_lints/src/reserve_after_initialization.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::higher::{get_vec_init_kind, VecInitKind};
-use clippy_utils::path_to_local_id;
 use clippy_utils::source::snippet;
+use clippy_utils::{is_from_proc_macro, path_to_local_id};
 use rustc_errors::Applicability;
 use rustc_hir::def::Res;
 use rustc_hir::{BindingAnnotation, Block, Expr, ExprKind, HirId, Local, PatKind, QPath, Stmt, StmtKind};
@@ -74,8 +74,9 @@ impl<'tcx> LateLintPass<'tcx> for ReserveAfterInitialization {
             && let PatKind::Binding(BindingAnnotation::MUT, id, _, None) = local.pat.kind
             && !in_external_macro(cx.sess(), local.span)
             && let Some(init) = get_vec_init_kind(cx, init_expr)
-            && !matches!(init, VecInitKind::WithExprCapacity(_))
-            && !matches!(init, VecInitKind::WithConstCapacity(_))
+            && !matches!(init, VecInitKind::WithExprCapacity(_)
+               | VecInitKind::WithConstCapacity(_)
+            )
         {
             self.searcher = Some(VecReserveSearcher {
                 local_id: id,
@@ -116,6 +117,7 @@ impl<'tcx> LateLintPass<'tcx> for ReserveAfterInitialization {
             if let StmtKind::Expr(expr) | StmtKind::Semi(expr) = stmt.kind
                 && let ExprKind::MethodCall(name, self_arg, [space_hint], _) = expr.kind
                 && path_to_local_id(self_arg, searcher.local_id)
+                && !is_from_proc_macro(cx, expr)
                 && name.ident.as_str() == "reserve"
             {
                 self.searcher = Some(VecReserveSearcher {
diff --git a/tests/ui/reserve_after_initialization.fixed b/tests/ui/reserve_after_initialization.fixed
index 5ef848ed8cf..0675277849a 100644
--- a/tests/ui/reserve_after_initialization.fixed
+++ b/tests/ui/reserve_after_initialization.fixed
@@ -1,6 +1,10 @@
+//@aux-build:proc_macros.rs
 #![warn(clippy::reserve_after_initialization)]
 #![no_main]
 
+extern crate proc_macros;
+use proc_macros::{external, with_span};
+
 // Should lint
 fn standard() {
     let mut v1: Vec<usize> = Vec::with_capacity(10);
@@ -29,28 +33,16 @@ fn assign_expression() {
     v5 = Vec::with_capacity(10);
 }
 
-/*fn in_macros() {
+fn in_macros() {
     external! {
-        // Should lint
-        let mut v1: Vec<usize> = vec![];
-        v1.reserve(10);
-
-        // Should lint
-        let capacity = 10;
-        let mut v2: Vec<usize> = vec![];
-        v2.reserve(capacity);
+        let mut v: Vec<usize> = vec![];
+        v.reserve(10);
     }
 
     with_span! {
         span
 
-        // Should lint
-        let mut v1: Vec<usize> = vec![];
-        v1.reserve(10);
-
-        // Should lint
-        let capacity = 10;
-        let mut v2: Vec<usize> = vec![];
-        v2.reserve(capacity);
+        let mut v: Vec<usize> = vec![];
+        v.reserve(10);
     }
-}*/
+}
diff --git a/tests/ui/reserve_after_initialization.rs b/tests/ui/reserve_after_initialization.rs
index eba7bc8dab3..b57a8e162c5 100644
--- a/tests/ui/reserve_after_initialization.rs
+++ b/tests/ui/reserve_after_initialization.rs
@@ -1,6 +1,10 @@
+//@aux-build:proc_macros.rs
 #![warn(clippy::reserve_after_initialization)]
 #![no_main]
 
+extern crate proc_macros;
+use proc_macros::{external, with_span};
+
 // Should lint
 fn standard() {
     let mut v1: Vec<usize> = vec![];
@@ -32,28 +36,16 @@ fn assign_expression() {
     v5.reserve(10);
 }
 
-/*fn in_macros() {
+fn in_macros() {
     external! {
-        // Should lint
-        let mut v1: Vec<usize> = vec![];
-        v1.reserve(10);
-
-        // Should lint
-        let capacity = 10;
-        let mut v2: Vec<usize> = vec![];
-        v2.reserve(capacity);
+        let mut v: Vec<usize> = vec![];
+        v.reserve(10);
     }
 
     with_span! {
         span
 
-        // Should lint
-        let mut v1: Vec<usize> = vec![];
-        v1.reserve(10);
-
-        // Should lint
-        let capacity = 10;
-        let mut v2: Vec<usize> = vec![];
-        v2.reserve(capacity);
+        let mut v: Vec<usize> = vec![];
+        v.reserve(10);
     }
-}*/
+}
diff --git a/tests/ui/reserve_after_initialization.stderr b/tests/ui/reserve_after_initialization.stderr
index e50a8a065ba..4a6164d8ebc 100644
--- a/tests/ui/reserve_after_initialization.stderr
+++ b/tests/ui/reserve_after_initialization.stderr
@@ -1,5 +1,5 @@
 error: call to `reserve` immediately after creation
-  --> $DIR/reserve_after_initialization.rs:6:5
+  --> $DIR/reserve_after_initialization.rs:10:5
    |
 LL | /     let mut v1: Vec<usize> = vec![];
 LL | |     v1.reserve(10);
@@ -8,14 +8,14 @@ LL | |     v1.reserve(10);
    = note: `-D clippy::reserve-after-initialization` implied by `-D warnings`
 
 error: call to `reserve` immediately after creation
-  --> $DIR/reserve_after_initialization.rs:13:5
+  --> $DIR/reserve_after_initialization.rs:17:5
    |
 LL | /     let mut v2: Vec<usize> = vec![];
 LL | |     v2.reserve(capacity);
    | |_________________________^ help: consider using `Vec::with_capacity(/* Space hint */)`: `let mut v2: Vec<usize> = Vec::with_capacity(capacity);`
 
 error: call to `reserve` immediately after creation
-  --> $DIR/reserve_after_initialization.rs:31:5
+  --> $DIR/reserve_after_initialization.rs:35:5
    |
 LL | /     v5 = Vec::new();
 LL | |     v5.reserve(10);
-- 
cgit 1.4.1-3-g733a5


From e9a222beb5153024c0c0f2491274272ab00c7d7a Mon Sep 17 00:00:00 2001
From: Red Rapious <red.rapious@gmail.com>
Date: Tue, 22 Aug 2023 23:41:06 +0200
Subject: Minor changes

---
 clippy_lints/src/reserve_after_initialization.rs | 11 +++--------
 1 file changed, 3 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/reserve_after_initialization.rs b/clippy_lints/src/reserve_after_initialization.rs
index 15f8c5da106..7ba10c97595 100644
--- a/clippy_lints/src/reserve_after_initialization.rs
+++ b/clippy_lints/src/reserve_after_initialization.rs
@@ -74,9 +74,7 @@ impl<'tcx> LateLintPass<'tcx> for ReserveAfterInitialization {
             && let PatKind::Binding(BindingAnnotation::MUT, id, _, None) = local.pat.kind
             && !in_external_macro(cx.sess(), local.span)
             && let Some(init) = get_vec_init_kind(cx, init_expr)
-            && !matches!(init, VecInitKind::WithExprCapacity(_)
-               | VecInitKind::WithConstCapacity(_)
-            )
+            && !matches!(init, VecInitKind::WithExprCapacity(_) | VecInitKind::WithConstCapacity(_))
         {
             self.searcher = Some(VecReserveSearcher {
                 local_id: id,
@@ -93,13 +91,10 @@ impl<'tcx> LateLintPass<'tcx> for ReserveAfterInitialization {
         if self.searcher.is_none()
             && let ExprKind::Assign(left, right, _) = expr.kind
             && let ExprKind::Path(QPath::Resolved(None, path)) = left.kind
-            && let [_] = &path.segments
             && let Res::Local(id) = path.res
             && !in_external_macro(cx.sess(), expr.span)
             && let Some(init) = get_vec_init_kind(cx, right)
-            && !matches!(init, VecInitKind::WithExprCapacity(_)
-               | VecInitKind::WithConstCapacity(_)
-            )
+            && !matches!(init, VecInitKind::WithExprCapacity(_) | VecInitKind::WithConstCapacity(_))
         {
             self.searcher = Some(VecReserveSearcher {
                 local_id: id,
@@ -122,7 +117,7 @@ impl<'tcx> LateLintPass<'tcx> for ReserveAfterInitialization {
             {
                 self.searcher = Some(VecReserveSearcher {
                     err_span: searcher.err_span.to(stmt.span),
-                    space_hint: snippet(cx, space_hint.span, "..").to_string(),
+                    space_hint: snippet(cx, space_hint.span, "..").into_owned(),
                     .. searcher
                 });
             } else {
-- 
cgit 1.4.1-3-g733a5


From f3c58773026bf042142be2bf8ed1e8b8797a4f68 Mon Sep 17 00:00:00 2001
From: Red Rapious <red.rapious@gmail.com>
Date: Wed, 23 Aug 2023 13:46:12 +0200
Subject: Put `is_from_proc_macro` last

---
 clippy_lints/src/reserve_after_initialization.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/reserve_after_initialization.rs b/clippy_lints/src/reserve_after_initialization.rs
index 7ba10c97595..0c8c904e374 100644
--- a/clippy_lints/src/reserve_after_initialization.rs
+++ b/clippy_lints/src/reserve_after_initialization.rs
@@ -112,8 +112,8 @@ impl<'tcx> LateLintPass<'tcx> for ReserveAfterInitialization {
             if let StmtKind::Expr(expr) | StmtKind::Semi(expr) = stmt.kind
                 && let ExprKind::MethodCall(name, self_arg, [space_hint], _) = expr.kind
                 && path_to_local_id(self_arg, searcher.local_id)
-                && !is_from_proc_macro(cx, expr)
                 && name.ident.as_str() == "reserve"
+                && !is_from_proc_macro(cx, expr)
             {
                 self.searcher = Some(VecReserveSearcher {
                     err_span: searcher.err_span.to(stmt.span),
-- 
cgit 1.4.1-3-g733a5


From 42bd6d7af3b12366b6d063c2f5220323aee62efc Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Sun, 20 Aug 2023 01:20:29 +0200
Subject: new lint: `implied_bounds_in_impl`

---
 CHANGELOG.md                               |  1 +
 clippy_lints/src/declared_lints.rs         |  1 +
 clippy_lints/src/implied_bounds_in_impl.rs | 96 ++++++++++++++++++++++++++++++
 clippy_lints/src/lib.rs                    |  2 +
 tests/ui/implied_bounds_in_impl.rs         | 45 ++++++++++++++
 tests/ui/implied_bounds_in_impl.stderr     | 16 +++++
 6 files changed, 161 insertions(+)
 create mode 100644 clippy_lints/src/implied_bounds_in_impl.rs
 create mode 100644 tests/ui/implied_bounds_in_impl.rs
 create mode 100644 tests/ui/implied_bounds_in_impl.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 4e33cb7b457..1ae44c502db 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4985,6 +4985,7 @@ Released 2018-09-13
 [`implicit_return`]: https://rust-lang.github.io/rust-clippy/master/index.html#implicit_return
 [`implicit_saturating_add`]: https://rust-lang.github.io/rust-clippy/master/index.html#implicit_saturating_add
 [`implicit_saturating_sub`]: https://rust-lang.github.io/rust-clippy/master/index.html#implicit_saturating_sub
+[`implied_bounds_in_impl`]: https://rust-lang.github.io/rust-clippy/master/index.html#implied_bounds_in_impl
 [`impossible_comparisons`]: https://rust-lang.github.io/rust-clippy/master/index.html#impossible_comparisons
 [`imprecise_flops`]: https://rust-lang.github.io/rust-clippy/master/index.html#imprecise_flops
 [`inconsistent_digit_grouping`]: https://rust-lang.github.io/rust-clippy/master/index.html#inconsistent_digit_grouping
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 1be9720fbbf..ea8d804b423 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -209,6 +209,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::implicit_return::IMPLICIT_RETURN_INFO,
     crate::implicit_saturating_add::IMPLICIT_SATURATING_ADD_INFO,
     crate::implicit_saturating_sub::IMPLICIT_SATURATING_SUB_INFO,
+    crate::implied_bounds_in_impl::IMPLIED_BOUNDS_IN_IMPL_INFO,
     crate::inconsistent_struct_constructor::INCONSISTENT_STRUCT_CONSTRUCTOR_INFO,
     crate::incorrect_impls::INCORRECT_CLONE_IMPL_ON_COPY_TYPE_INFO,
     crate::incorrect_impls::INCORRECT_PARTIAL_ORD_IMPL_ON_ORD_TYPE_INFO,
diff --git a/clippy_lints/src/implied_bounds_in_impl.rs b/clippy_lints/src/implied_bounds_in_impl.rs
new file mode 100644
index 00000000000..c83153e5350
--- /dev/null
+++ b/clippy_lints/src/implied_bounds_in_impl.rs
@@ -0,0 +1,96 @@
+use clippy_utils::diagnostics::span_lint;
+use rustc_hir::def_id::LocalDefId;
+use rustc_hir::intravisit::FnKind;
+use rustc_hir::{Body, FnDecl, FnRetTy, GenericArgs, GenericBound, ItemKind, TraitBoundModifier, TyKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::ClauseKind;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::Span;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Looks for bounds in `impl Trait` in return position that are implied by other bounds.
+    /// This is usually the case when a supertrait is explicitly specified, when it is already implied
+    /// by a subtrait (e.g. `DerefMut: Deref`, so specifying `Deref` is unnecessary when `DerefMut` is specified).
+    ///
+    /// ### Why is this bad?
+    /// Unnecessary complexity.
+    ///
+    /// ### Known problems
+    /// This lint currently does not work with generic traits (i.e. will not lint even if redundant).
+    ///
+    /// ### Example
+    /// ```rust
+    /// fn f() -> impl Deref<Target = i32> + DerefMut<Target = i32> {
+    /// //             ^^^^^^^^^^^^^^^^^^^ unnecessary bound, already implied by the `DerefMut` trait bound
+    ///     Box::new(123)
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// fn f() -> impl DerefMut<Target = i32> {
+    ///     Box::new(123)
+    /// }
+    /// ```
+    #[clippy::version = "1.73.0"]
+    pub IMPLIED_BOUNDS_IN_IMPL,
+    complexity,
+    "specifying bounds that are implied by other bounds in `impl Trait` type"
+}
+declare_lint_pass!(ImpliedBoundsInImpl => [IMPLIED_BOUNDS_IN_IMPL]);
+
+impl LateLintPass<'_> for ImpliedBoundsInImpl {
+    fn check_fn(
+        &mut self,
+        cx: &LateContext<'_>,
+        _: FnKind<'_>,
+        decl: &FnDecl<'_>,
+        _: &Body<'_>,
+        _: Span,
+        _: LocalDefId,
+    ) {
+        if let FnRetTy::Return(ty) = decl.output {
+            if let TyKind::OpaqueDef(item_id, ..) = ty.kind
+                && let item = cx.tcx.hir().item(item_id)
+                && let ItemKind::OpaqueTy(opaque_ty) = item.kind
+            {
+                // Get all `DefId`s of (implied) trait predicates in all the bounds.
+                // For `impl Deref + DerefMut` this will contain [`Deref`].
+                // The implied `Deref` comes from `DerefMut` because `trait DerefMut: Deref {}`.
+
+                // N.B. Generic args on trait bounds are currently ignored and (G)ATs are fine to disregard,
+                // because they must be the same for all of its supertraits. Example:
+                // `impl Deref<Target = i32> + DerefMut<Target = u32>` is not allowed.
+                // `DerefMut::Target` needs to match `Deref::Target`
+                let implied_bounds = opaque_ty.bounds.iter().flat_map(|bound| {
+                    if let GenericBound::Trait(poly_trait, TraitBoundModifier::None) = bound
+                        && let [.., path]  = poly_trait.trait_ref.path.segments
+                        && poly_trait.bound_generic_params.is_empty()
+                        && path.args.map_or(true, GenericArgs::is_empty)
+                        && let Some(trait_def_id) = path.res.opt_def_id()
+                    {
+                        cx.tcx.implied_predicates_of(trait_def_id).predicates
+                    } else {
+                        &[]
+                    }
+                }).collect::<Vec<_>>();
+
+                // Lint all bounds in the `impl Trait` type that are also in the `implied_bounds` vec.
+                for bound in opaque_ty.bounds {
+                    if let GenericBound::Trait(poly_trait, TraitBoundModifier::None) = bound
+                        && let Some(def_id) = poly_trait.trait_ref.path.res.opt_def_id()
+                        && implied_bounds.iter().any(|(clause, _)| {
+                            if let ClauseKind::Trait(tr) = clause.kind().skip_binder() {
+                                tr.def_id() == def_id
+                            } else {
+                                false
+                            }
+                        })
+                    {
+                        span_lint(cx, IMPLIED_BOUNDS_IN_IMPL, poly_trait.span, "this bound is implied by another bound and can be removed");
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index f50019f3cf7..d4fcddc66c5 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -152,6 +152,7 @@ mod implicit_hasher;
 mod implicit_return;
 mod implicit_saturating_add;
 mod implicit_saturating_sub;
+mod implied_bounds_in_impl;
 mod inconsistent_struct_constructor;
 mod incorrect_impls;
 mod index_refutable_slice;
@@ -1097,6 +1098,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(redundant_locals::RedundantLocals));
     store.register_late_pass(|_| Box::new(ignored_unit_patterns::IgnoredUnitPatterns));
     store.register_late_pass(|_| Box::<reserve_after_initialization::ReserveAfterInitialization>::default());
+    store.register_late_pass(|_| Box::new(implied_bounds_in_impl::ImpliedBoundsInImpl));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/tests/ui/implied_bounds_in_impl.rs b/tests/ui/implied_bounds_in_impl.rs
new file mode 100644
index 00000000000..516f21fc795
--- /dev/null
+++ b/tests/ui/implied_bounds_in_impl.rs
@@ -0,0 +1,45 @@
+#![warn(clippy::implied_bounds_in_impl)]
+#![allow(dead_code)]
+
+use std::ops::{Deref, DerefMut};
+
+trait Trait1<T> {}
+// T is intentionally at a different position in Trait2 than in Trait1,
+// since that also needs to be taken into account when making this lint work with generics
+trait Trait2<U, T>: Trait1<T> {}
+impl Trait1<i32> for () {}
+impl Trait1<String> for () {}
+impl Trait2<u32, i32> for () {}
+impl Trait2<u32, String> for () {}
+
+// Deref implied by DerefMut
+fn deref_derefmut<T>(x: T) -> impl Deref<Target = T> + DerefMut<Target = T> {
+    Box::new(x)
+}
+
+// Note: no test for different associated types needed since that isn't allowed in the first place.
+// E.g. `-> impl Deref<Target = T> + DerefMut<Target = U>` is a compile error.
+
+// DefIds of the traits match, but the generics do not, so it's *not* redundant.
+// `Trait2: Trait` holds, but not `Trait2<_, String>: Trait1<i32>`.
+// (Generic traits are currently not linted anyway but once/if ever implemented this should not
+// warn.)
+fn different_generics() -> impl Trait1<i32> + Trait2<u32, String> {
+    /* () */
+}
+
+trait NonGenericTrait1 {}
+trait NonGenericTrait2: NonGenericTrait1 {}
+impl NonGenericTrait1 for i32 {}
+impl NonGenericTrait2 for i32 {}
+
+// Only one bound. Nothing to lint.
+fn normal1() -> impl NonGenericTrait1 {
+    1
+}
+
+fn normal2() -> impl NonGenericTrait1 + NonGenericTrait2 {
+    1
+}
+
+fn main() {}
diff --git a/tests/ui/implied_bounds_in_impl.stderr b/tests/ui/implied_bounds_in_impl.stderr
new file mode 100644
index 00000000000..2709f727acc
--- /dev/null
+++ b/tests/ui/implied_bounds_in_impl.stderr
@@ -0,0 +1,16 @@
+error: this bound is implied by another bound and can be removed
+  --> $DIR/implied_bounds_in_impl.rs:16:36
+   |
+LL | fn deref_derefmut<T>(x: T) -> impl Deref<Target = T> + DerefMut<Target = T> {
+   |                                    ^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::implied-bounds-in-impl` implied by `-D warnings`
+
+error: this bound is implied by another bound and can be removed
+  --> $DIR/implied_bounds_in_impl.rs:41:22
+   |
+LL | fn normal2() -> impl NonGenericTrait1 + NonGenericTrait2 {
+   |                      ^^^^^^^^^^^^^^^^
+
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 2ebff58969988d1b45b19d0dd50a8058aa26eb37 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Sun, 20 Aug 2023 05:25:35 +0200
Subject: make generics work

fix compile error in doc example
---
 clippy_lints/src/implied_bounds_in_impl.rs | 99 +++++++++++++++++++++++++-----
 tests/ui/implied_bounds_in_impl.rs         | 56 +++++++++--------
 tests/ui/implied_bounds_in_impl.stderr     | 40 ++++++++++--
 3 files changed, 146 insertions(+), 49 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/implied_bounds_in_impl.rs b/clippy_lints/src/implied_bounds_in_impl.rs
index c83153e5350..3f9f5daa6a4 100644
--- a/clippy_lints/src/implied_bounds_in_impl.rs
+++ b/clippy_lints/src/implied_bounds_in_impl.rs
@@ -1,9 +1,10 @@
 use clippy_utils::diagnostics::span_lint;
 use rustc_hir::def_id::LocalDefId;
 use rustc_hir::intravisit::FnKind;
-use rustc_hir::{Body, FnDecl, FnRetTy, GenericArgs, GenericBound, ItemKind, TraitBoundModifier, TyKind};
+use rustc_hir::{Body, FnDecl, FnRetTy, GenericArg, GenericBound, ItemKind, TraitBoundModifier, TyKind};
+use rustc_hir_analysis::hir_ty_to_ty;
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty::ClauseKind;
+use rustc_middle::ty::{self, ClauseKind, TyCtxt};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::Span;
 
@@ -17,10 +18,11 @@ declare_clippy_lint! {
     /// Unnecessary complexity.
     ///
     /// ### Known problems
-    /// This lint currently does not work with generic traits (i.e. will not lint even if redundant).
+    /// This lint does not transitively look for implied bounds past the first supertrait.
     ///
     /// ### Example
     /// ```rust
+    /// # use std::ops::{Deref,DerefMut};
     /// fn f() -> impl Deref<Target = i32> + DerefMut<Target = i32> {
     /// //             ^^^^^^^^^^^^^^^^^^^ unnecessary bound, already implied by the `DerefMut` trait bound
     ///     Box::new(123)
@@ -28,6 +30,7 @@ declare_clippy_lint! {
     /// ```
     /// Use instead:
     /// ```rust
+    /// # use std::ops::{Deref,DerefMut};
     /// fn f() -> impl DerefMut<Target = i32> {
     ///     Box::new(123)
     /// }
@@ -39,6 +42,53 @@ declare_clippy_lint! {
 }
 declare_lint_pass!(ImpliedBoundsInImpl => [IMPLIED_BOUNDS_IN_IMPL]);
 
+/// This function tries to, for all type parameters in a supertype predicate `GenericTrait<U>`,
+/// check if the substituted type in the implied-by bound matches with what's subtituted in the
+/// implied type.
+///
+/// Consider this example function.
+/// ```rust,ignore
+/// trait GenericTrait<T> {}
+/// trait GenericSubTrait<T, U, V>: GenericTrait<U> {}
+///                                              ^ trait_predicate_args: [Self#0, U#2]
+/// impl GenericTrait<i32> for () {}
+/// impl GenericSubTrait<(), i32, ()> for () {}
+/// impl GenericSubTrait<(), [u8; 8], ()> for () {}
+///
+/// fn f() -> impl GenericTrait<i32> + GenericSubTrait<(), [u8; 8], ()> {
+///                             ^^^ implied_args       ^^^^^^^^^^^^^^^ implied_by_args
+///                                                                    (we are interested in `[u8; 8]` specifically, as that
+///                                                                     is what `U` in `GenericTrait<U>` is substituted with)
+///     ()
+/// }
+/// ```
+/// Here i32 != [u8; 8], so this will return false.
+fn is_same_generics(
+    tcx: TyCtxt<'_>,
+    trait_predicate_args: &[ty::GenericArg<'_>],
+    implied_by_args: &[GenericArg<'_>],
+    implied_args: &[GenericArg<'_>],
+) -> bool {
+    trait_predicate_args
+        .iter()
+        .enumerate()
+        .skip(1) // skip `Self` implicit arg
+        .all(|(arg_index, arg)| {
+            if let Some(ty) = arg.as_type()
+                && let &ty::Param(ty::ParamTy{ index, .. }) = ty.kind()
+                // Since `trait_predicate_args` and type params in traits start with `Self=0`
+                // and generic argument lists `GenericTrait<i32>` don't have `Self`,
+                // we need to subtract 1 from the index.
+                && let GenericArg::Type(ty_a) = implied_by_args[index as usize - 1]
+                && let GenericArg::Type(ty_b) = implied_args[arg_index - 1]
+            {
+                hir_ty_to_ty(tcx, ty_a) == hir_ty_to_ty(tcx, ty_b)
+            } else {
+                false
+            }
+        })
+}
+
 impl LateLintPass<'_> for ImpliedBoundsInImpl {
     fn check_fn(
         &mut self,
@@ -54,37 +104,52 @@ impl LateLintPass<'_> for ImpliedBoundsInImpl {
                 && let item = cx.tcx.hir().item(item_id)
                 && let ItemKind::OpaqueTy(opaque_ty) = item.kind
             {
-                // Get all `DefId`s of (implied) trait predicates in all the bounds.
+                // Very often there is only a single bound, e.g. `impl Deref<..>`, in which case
+                // we can avoid doing a bunch of stuff unnecessarily.
+                if opaque_ty.bounds.is_empty() {
+                    return;
+                }
+
+                // Get all the (implied) trait predicates in the bounds.
                 // For `impl Deref + DerefMut` this will contain [`Deref`].
                 // The implied `Deref` comes from `DerefMut` because `trait DerefMut: Deref {}`.
 
-                // N.B. Generic args on trait bounds are currently ignored and (G)ATs are fine to disregard,
-                // because they must be the same for all of its supertraits. Example:
+                // N.B. (G)ATs are fine to disregard, because they must be the same for all of its supertraits.
+                // Example:
                 // `impl Deref<Target = i32> + DerefMut<Target = u32>` is not allowed.
                 // `DerefMut::Target` needs to match `Deref::Target`
-                let implied_bounds = opaque_ty.bounds.iter().flat_map(|bound| {
+                let implied_bounds: Vec<_> = opaque_ty.bounds.iter().filter_map(|bound| {
                     if let GenericBound::Trait(poly_trait, TraitBoundModifier::None) = bound
                         && let [.., path]  = poly_trait.trait_ref.path.segments
                         && poly_trait.bound_generic_params.is_empty()
-                        && path.args.map_or(true, GenericArgs::is_empty)
                         && let Some(trait_def_id) = path.res.opt_def_id()
+                        && let predicates = cx.tcx.super_predicates_of(trait_def_id).predicates
+                        && !predicates.is_empty() // If the trait has no supertrait, there is nothing to add.
                     {
-                        cx.tcx.implied_predicates_of(trait_def_id).predicates
+                        Some((path.args.map_or([].as_slice(), |a| a.args), predicates))
                     } else {
-                        &[]
+                        None
                     }
-                }).collect::<Vec<_>>();
+                }).collect();
 
                 // Lint all bounds in the `impl Trait` type that are also in the `implied_bounds` vec.
+                // This involves some extra logic when generic arguments are present, since
+                // simply comparing trait `DefId`s won't be enough. We also need to compare the generics.
                 for bound in opaque_ty.bounds {
                     if let GenericBound::Trait(poly_trait, TraitBoundModifier::None) = bound
+                        && let [.., path] = poly_trait.trait_ref.path.segments
+                        && let implied_args = path.args.map_or([].as_slice(), |a| a.args)
                         && let Some(def_id) = poly_trait.trait_ref.path.res.opt_def_id()
-                        && implied_bounds.iter().any(|(clause, _)| {
-                            if let ClauseKind::Trait(tr) = clause.kind().skip_binder() {
-                                tr.def_id() == def_id
-                            } else {
-                                false
-                            }
+                        && implied_bounds.iter().any(|(implied_by_args, preds)| {
+                            preds.iter().any(|(clause, _)| {
+                                if let ClauseKind::Trait(tr) = clause.kind().skip_binder()
+                                    && tr.def_id() == def_id
+                                {
+                                    is_same_generics(cx.tcx, tr.trait_ref.args, implied_by_args, implied_args)
+                                } else {
+                                    false
+                                }
+                            })
                         })
                     {
                         span_lint(cx, IMPLIED_BOUNDS_IN_IMPL, poly_trait.span, "this bound is implied by another bound and can be removed");
diff --git a/tests/ui/implied_bounds_in_impl.rs b/tests/ui/implied_bounds_in_impl.rs
index 516f21fc795..0bc4b193d53 100644
--- a/tests/ui/implied_bounds_in_impl.rs
+++ b/tests/ui/implied_bounds_in_impl.rs
@@ -3,43 +3,45 @@
 
 use std::ops::{Deref, DerefMut};
 
-trait Trait1<T> {}
-// T is intentionally at a different position in Trait2 than in Trait1,
-// since that also needs to be taken into account when making this lint work with generics
-trait Trait2<U, T>: Trait1<T> {}
-impl Trait1<i32> for () {}
-impl Trait1<String> for () {}
-impl Trait2<u32, i32> for () {}
-impl Trait2<u32, String> for () {}
+// Only one bound, nothing to lint.
+fn normal_deref<T>(x: T) -> impl Deref<Target = T> {
+    Box::new(x)
+}
 
 // Deref implied by DerefMut
 fn deref_derefmut<T>(x: T) -> impl Deref<Target = T> + DerefMut<Target = T> {
     Box::new(x)
 }
 
-// Note: no test for different associated types needed since that isn't allowed in the first place.
-// E.g. `-> impl Deref<Target = T> + DerefMut<Target = U>` is a compile error.
-
-// DefIds of the traits match, but the generics do not, so it's *not* redundant.
-// `Trait2: Trait` holds, but not `Trait2<_, String>: Trait1<i32>`.
-// (Generic traits are currently not linted anyway but once/if ever implemented this should not
-// warn.)
-fn different_generics() -> impl Trait1<i32> + Trait2<u32, String> {
-    /* () */
+trait GenericTrait<T> {}
+trait GenericTrait2<V> {}
+// U is intentionally at a different "index" in GenericSubtrait than `T` is in GenericTrait
+trait GenericSubtrait<T, U, V>: GenericTrait<U> + GenericTrait2<V> {}
+
+impl GenericTrait<i32> for () {}
+impl GenericTrait<i64> for () {}
+impl<V> GenericTrait2<V> for () {}
+impl<V> GenericSubtrait<(), i32, V> for () {}
+impl<V> GenericSubtrait<(), i64, V> for () {}
+
+fn generics_implied<T>() -> impl GenericTrait<T> + GenericSubtrait<(), T, ()>
+where
+    (): GenericSubtrait<(), T, ()>,
+{
 }
 
-trait NonGenericTrait1 {}
-trait NonGenericTrait2: NonGenericTrait1 {}
-impl NonGenericTrait1 for i32 {}
-impl NonGenericTrait2 for i32 {}
+fn generics_implied_multi<V>() -> impl GenericTrait<i32> + GenericTrait2<V> + GenericSubtrait<(), i32, V> {}
 
-// Only one bound. Nothing to lint.
-fn normal1() -> impl NonGenericTrait1 {
-    1
+fn generics_implied_multi2<T, V>() -> impl GenericTrait<T> + GenericTrait2<V> + GenericSubtrait<(), T, V>
+where
+    (): GenericSubtrait<(), T, V> + GenericTrait<T>,
+{
 }
 
-fn normal2() -> impl NonGenericTrait1 + NonGenericTrait2 {
-    1
-}
+// i32 != i64, GenericSubtrait<_, i64, _> does not imply GenericTrait<i32>, don't lint
+fn generics_different() -> impl GenericTrait<i32> + GenericSubtrait<(), i64, ()> {}
+
+// i32 == i32, GenericSubtrait<_, i32, _> does imply GenericTrait<i32>, lint
+fn generics_same() -> impl GenericTrait<i32> + GenericSubtrait<(), i32, ()> {}
 
 fn main() {}
diff --git a/tests/ui/implied_bounds_in_impl.stderr b/tests/ui/implied_bounds_in_impl.stderr
index 2709f727acc..92d412e784f 100644
--- a/tests/ui/implied_bounds_in_impl.stderr
+++ b/tests/ui/implied_bounds_in_impl.stderr
@@ -1,5 +1,5 @@
 error: this bound is implied by another bound and can be removed
-  --> $DIR/implied_bounds_in_impl.rs:16:36
+  --> $DIR/implied_bounds_in_impl.rs:12:36
    |
 LL | fn deref_derefmut<T>(x: T) -> impl Deref<Target = T> + DerefMut<Target = T> {
    |                                    ^^^^^^^^^^^^^^^^^
@@ -7,10 +7,40 @@ LL | fn deref_derefmut<T>(x: T) -> impl Deref<Target = T> + DerefMut<Target = T>
    = note: `-D clippy::implied-bounds-in-impl` implied by `-D warnings`
 
 error: this bound is implied by another bound and can be removed
-  --> $DIR/implied_bounds_in_impl.rs:41:22
+  --> $DIR/implied_bounds_in_impl.rs:27:34
    |
-LL | fn normal2() -> impl NonGenericTrait1 + NonGenericTrait2 {
-   |                      ^^^^^^^^^^^^^^^^
+LL | fn generics_implied<T>() -> impl GenericTrait<T> + GenericSubtrait<(), T, ()>
+   |                                  ^^^^^^^^^^^^^^^
 
-error: aborting due to 2 previous errors
+error: this bound is implied by another bound and can be removed
+  --> $DIR/implied_bounds_in_impl.rs:33:40
+   |
+LL | fn generics_implied_multi<V>() -> impl GenericTrait<i32> + GenericTrait2<V> + GenericSubtrait<(), i32, V> {}
+   |                                        ^^^^^^^^^^^^^^^^^
+
+error: this bound is implied by another bound and can be removed
+  --> $DIR/implied_bounds_in_impl.rs:33:60
+   |
+LL | fn generics_implied_multi<V>() -> impl GenericTrait<i32> + GenericTrait2<V> + GenericSubtrait<(), i32, V> {}
+   |                                                            ^^^^^^^^^^^^^^^^
+
+error: this bound is implied by another bound and can be removed
+  --> $DIR/implied_bounds_in_impl.rs:35:44
+   |
+LL | fn generics_implied_multi2<T, V>() -> impl GenericTrait<T> + GenericTrait2<V> + GenericSubtrait<(), T, V>
+   |                                            ^^^^^^^^^^^^^^^
+
+error: this bound is implied by another bound and can be removed
+  --> $DIR/implied_bounds_in_impl.rs:35:62
+   |
+LL | fn generics_implied_multi2<T, V>() -> impl GenericTrait<T> + GenericTrait2<V> + GenericSubtrait<(), T, V>
+   |                                                              ^^^^^^^^^^^^^^^^
+
+error: this bound is implied by another bound and can be removed
+  --> $DIR/implied_bounds_in_impl.rs:45:28
+   |
+LL | fn generics_same() -> impl GenericTrait<i32> + GenericSubtrait<(), i32, ()> {}
+   |                            ^^^^^^^^^^^^^^^^^
+
+error: aborting due to 7 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 09506f49c13630765f636cf8a1ac58f95658dd68 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Wed, 23 Aug 2023 15:48:26 +0200
Subject: rename lint, docs, improve diagnostics

---
 CHANGELOG.md                                |   2 +-
 clippy_lints/src/declared_lints.rs          |   2 +-
 clippy_lints/src/implied_bounds_in_impl.rs  | 161 ------------------------
 clippy_lints/src/implied_bounds_in_impls.rs | 185 ++++++++++++++++++++++++++++
 clippy_lints/src/lib.rs                     |   4 +-
 tests/ui/implied_bounds_in_impl.rs          |  47 -------
 tests/ui/implied_bounds_in_impl.stderr      |  46 -------
 tests/ui/implied_bounds_in_impls.fixed      |  70 +++++++++++
 tests/ui/implied_bounds_in_impls.rs         |  70 +++++++++++
 tests/ui/implied_bounds_in_impls.stderr     |  99 +++++++++++++++
 10 files changed, 428 insertions(+), 258 deletions(-)
 delete mode 100644 clippy_lints/src/implied_bounds_in_impl.rs
 create mode 100644 clippy_lints/src/implied_bounds_in_impls.rs
 delete mode 100644 tests/ui/implied_bounds_in_impl.rs
 delete mode 100644 tests/ui/implied_bounds_in_impl.stderr
 create mode 100644 tests/ui/implied_bounds_in_impls.fixed
 create mode 100644 tests/ui/implied_bounds_in_impls.rs
 create mode 100644 tests/ui/implied_bounds_in_impls.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 1ae44c502db..583bc6754fb 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4985,7 +4985,7 @@ Released 2018-09-13
 [`implicit_return`]: https://rust-lang.github.io/rust-clippy/master/index.html#implicit_return
 [`implicit_saturating_add`]: https://rust-lang.github.io/rust-clippy/master/index.html#implicit_saturating_add
 [`implicit_saturating_sub`]: https://rust-lang.github.io/rust-clippy/master/index.html#implicit_saturating_sub
-[`implied_bounds_in_impl`]: https://rust-lang.github.io/rust-clippy/master/index.html#implied_bounds_in_impl
+[`implied_bounds_in_impls`]: https://rust-lang.github.io/rust-clippy/master/index.html#implied_bounds_in_impls
 [`impossible_comparisons`]: https://rust-lang.github.io/rust-clippy/master/index.html#impossible_comparisons
 [`imprecise_flops`]: https://rust-lang.github.io/rust-clippy/master/index.html#imprecise_flops
 [`inconsistent_digit_grouping`]: https://rust-lang.github.io/rust-clippy/master/index.html#inconsistent_digit_grouping
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index ea8d804b423..f73f1ed18f8 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -209,7 +209,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::implicit_return::IMPLICIT_RETURN_INFO,
     crate::implicit_saturating_add::IMPLICIT_SATURATING_ADD_INFO,
     crate::implicit_saturating_sub::IMPLICIT_SATURATING_SUB_INFO,
-    crate::implied_bounds_in_impl::IMPLIED_BOUNDS_IN_IMPL_INFO,
+    crate::implied_bounds_in_impls::IMPLIED_BOUNDS_IN_IMPLS_INFO,
     crate::inconsistent_struct_constructor::INCONSISTENT_STRUCT_CONSTRUCTOR_INFO,
     crate::incorrect_impls::INCORRECT_CLONE_IMPL_ON_COPY_TYPE_INFO,
     crate::incorrect_impls::INCORRECT_PARTIAL_ORD_IMPL_ON_ORD_TYPE_INFO,
diff --git a/clippy_lints/src/implied_bounds_in_impl.rs b/clippy_lints/src/implied_bounds_in_impl.rs
deleted file mode 100644
index 3f9f5daa6a4..00000000000
--- a/clippy_lints/src/implied_bounds_in_impl.rs
+++ /dev/null
@@ -1,161 +0,0 @@
-use clippy_utils::diagnostics::span_lint;
-use rustc_hir::def_id::LocalDefId;
-use rustc_hir::intravisit::FnKind;
-use rustc_hir::{Body, FnDecl, FnRetTy, GenericArg, GenericBound, ItemKind, TraitBoundModifier, TyKind};
-use rustc_hir_analysis::hir_ty_to_ty;
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty::{self, ClauseKind, TyCtxt};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::Span;
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Looks for bounds in `impl Trait` in return position that are implied by other bounds.
-    /// This is usually the case when a supertrait is explicitly specified, when it is already implied
-    /// by a subtrait (e.g. `DerefMut: Deref`, so specifying `Deref` is unnecessary when `DerefMut` is specified).
-    ///
-    /// ### Why is this bad?
-    /// Unnecessary complexity.
-    ///
-    /// ### Known problems
-    /// This lint does not transitively look for implied bounds past the first supertrait.
-    ///
-    /// ### Example
-    /// ```rust
-    /// # use std::ops::{Deref,DerefMut};
-    /// fn f() -> impl Deref<Target = i32> + DerefMut<Target = i32> {
-    /// //             ^^^^^^^^^^^^^^^^^^^ unnecessary bound, already implied by the `DerefMut` trait bound
-    ///     Box::new(123)
-    /// }
-    /// ```
-    /// Use instead:
-    /// ```rust
-    /// # use std::ops::{Deref,DerefMut};
-    /// fn f() -> impl DerefMut<Target = i32> {
-    ///     Box::new(123)
-    /// }
-    /// ```
-    #[clippy::version = "1.73.0"]
-    pub IMPLIED_BOUNDS_IN_IMPL,
-    complexity,
-    "specifying bounds that are implied by other bounds in `impl Trait` type"
-}
-declare_lint_pass!(ImpliedBoundsInImpl => [IMPLIED_BOUNDS_IN_IMPL]);
-
-/// This function tries to, for all type parameters in a supertype predicate `GenericTrait<U>`,
-/// check if the substituted type in the implied-by bound matches with what's subtituted in the
-/// implied type.
-///
-/// Consider this example function.
-/// ```rust,ignore
-/// trait GenericTrait<T> {}
-/// trait GenericSubTrait<T, U, V>: GenericTrait<U> {}
-///                                              ^ trait_predicate_args: [Self#0, U#2]
-/// impl GenericTrait<i32> for () {}
-/// impl GenericSubTrait<(), i32, ()> for () {}
-/// impl GenericSubTrait<(), [u8; 8], ()> for () {}
-///
-/// fn f() -> impl GenericTrait<i32> + GenericSubTrait<(), [u8; 8], ()> {
-///                             ^^^ implied_args       ^^^^^^^^^^^^^^^ implied_by_args
-///                                                                    (we are interested in `[u8; 8]` specifically, as that
-///                                                                     is what `U` in `GenericTrait<U>` is substituted with)
-///     ()
-/// }
-/// ```
-/// Here i32 != [u8; 8], so this will return false.
-fn is_same_generics(
-    tcx: TyCtxt<'_>,
-    trait_predicate_args: &[ty::GenericArg<'_>],
-    implied_by_args: &[GenericArg<'_>],
-    implied_args: &[GenericArg<'_>],
-) -> bool {
-    trait_predicate_args
-        .iter()
-        .enumerate()
-        .skip(1) // skip `Self` implicit arg
-        .all(|(arg_index, arg)| {
-            if let Some(ty) = arg.as_type()
-                && let &ty::Param(ty::ParamTy{ index, .. }) = ty.kind()
-                // Since `trait_predicate_args` and type params in traits start with `Self=0`
-                // and generic argument lists `GenericTrait<i32>` don't have `Self`,
-                // we need to subtract 1 from the index.
-                && let GenericArg::Type(ty_a) = implied_by_args[index as usize - 1]
-                && let GenericArg::Type(ty_b) = implied_args[arg_index - 1]
-            {
-                hir_ty_to_ty(tcx, ty_a) == hir_ty_to_ty(tcx, ty_b)
-            } else {
-                false
-            }
-        })
-}
-
-impl LateLintPass<'_> for ImpliedBoundsInImpl {
-    fn check_fn(
-        &mut self,
-        cx: &LateContext<'_>,
-        _: FnKind<'_>,
-        decl: &FnDecl<'_>,
-        _: &Body<'_>,
-        _: Span,
-        _: LocalDefId,
-    ) {
-        if let FnRetTy::Return(ty) = decl.output {
-            if let TyKind::OpaqueDef(item_id, ..) = ty.kind
-                && let item = cx.tcx.hir().item(item_id)
-                && let ItemKind::OpaqueTy(opaque_ty) = item.kind
-            {
-                // Very often there is only a single bound, e.g. `impl Deref<..>`, in which case
-                // we can avoid doing a bunch of stuff unnecessarily.
-                if opaque_ty.bounds.is_empty() {
-                    return;
-                }
-
-                // Get all the (implied) trait predicates in the bounds.
-                // For `impl Deref + DerefMut` this will contain [`Deref`].
-                // The implied `Deref` comes from `DerefMut` because `trait DerefMut: Deref {}`.
-
-                // N.B. (G)ATs are fine to disregard, because they must be the same for all of its supertraits.
-                // Example:
-                // `impl Deref<Target = i32> + DerefMut<Target = u32>` is not allowed.
-                // `DerefMut::Target` needs to match `Deref::Target`
-                let implied_bounds: Vec<_> = opaque_ty.bounds.iter().filter_map(|bound| {
-                    if let GenericBound::Trait(poly_trait, TraitBoundModifier::None) = bound
-                        && let [.., path]  = poly_trait.trait_ref.path.segments
-                        && poly_trait.bound_generic_params.is_empty()
-                        && let Some(trait_def_id) = path.res.opt_def_id()
-                        && let predicates = cx.tcx.super_predicates_of(trait_def_id).predicates
-                        && !predicates.is_empty() // If the trait has no supertrait, there is nothing to add.
-                    {
-                        Some((path.args.map_or([].as_slice(), |a| a.args), predicates))
-                    } else {
-                        None
-                    }
-                }).collect();
-
-                // Lint all bounds in the `impl Trait` type that are also in the `implied_bounds` vec.
-                // This involves some extra logic when generic arguments are present, since
-                // simply comparing trait `DefId`s won't be enough. We also need to compare the generics.
-                for bound in opaque_ty.bounds {
-                    if let GenericBound::Trait(poly_trait, TraitBoundModifier::None) = bound
-                        && let [.., path] = poly_trait.trait_ref.path.segments
-                        && let implied_args = path.args.map_or([].as_slice(), |a| a.args)
-                        && let Some(def_id) = poly_trait.trait_ref.path.res.opt_def_id()
-                        && implied_bounds.iter().any(|(implied_by_args, preds)| {
-                            preds.iter().any(|(clause, _)| {
-                                if let ClauseKind::Trait(tr) = clause.kind().skip_binder()
-                                    && tr.def_id() == def_id
-                                {
-                                    is_same_generics(cx.tcx, tr.trait_ref.args, implied_by_args, implied_args)
-                                } else {
-                                    false
-                                }
-                            })
-                        })
-                    {
-                        span_lint(cx, IMPLIED_BOUNDS_IN_IMPL, poly_trait.span, "this bound is implied by another bound and can be removed");
-                    }
-                }
-            }
-        }
-    }
-}
diff --git a/clippy_lints/src/implied_bounds_in_impls.rs b/clippy_lints/src/implied_bounds_in_impls.rs
new file mode 100644
index 00000000000..7ba467a3e06
--- /dev/null
+++ b/clippy_lints/src/implied_bounds_in_impls.rs
@@ -0,0 +1,185 @@
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::source::snippet;
+use rustc_hir::def_id::LocalDefId;
+use rustc_hir::intravisit::FnKind;
+use rustc_hir::{Body, FnDecl, FnRetTy, GenericArg, GenericBound, ItemKind, TraitBoundModifier, TyKind};
+use rustc_hir_analysis::hir_ty_to_ty;
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_errors::{Applicability, SuggestionStyle};
+use rustc_middle::ty::{self, ClauseKind, TyCtxt};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::Span;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Looks for bounds in `impl Trait` in return position that are implied by other bounds.
+    /// This can happen when a trait is specified that another trait already has as a supertrait
+    /// (e.g. `fn() -> impl Deref + DerefMut<Target = i32>` has an unnecessary `Deref` bound,
+    /// because `Deref` is a supertrait of `DerefMut`)
+    ///
+    /// ### Why is this bad?
+    /// Specifying more bounds than necessary adds needless complexity for the reader.
+    ///
+    /// ### Limitations
+    /// This lint does not check for implied bounds transitively. Meaning that
+    /// it does't check for implied bounds from supertraits of supertraits
+    /// (e.g. `trait A {} trait B: A {} trait C: B {}`, then having an `fn() -> impl A + C`)
+    ///
+    /// ### Example
+    /// ```rust
+    /// # use std::ops::{Deref,DerefMut};
+    /// fn f() -> impl Deref<Target = i32> + DerefMut<Target = i32> {
+    /// //             ^^^^^^^^^^^^^^^^^^^ unnecessary bound, already implied by the `DerefMut` trait bound
+    ///     Box::new(123)
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// # use std::ops::{Deref,DerefMut};
+    /// fn f() -> impl DerefMut<Target = i32> {
+    ///     Box::new(123)
+    /// }
+    /// ```
+    #[clippy::version = "1.73.0"]
+    pub IMPLIED_BOUNDS_IN_IMPLS,
+    complexity,
+    "specifying bounds that are implied by other bounds in `impl Trait` type"
+}
+declare_lint_pass!(ImpliedBoundsInImpls => [IMPLIED_BOUNDS_IN_IMPLS]);
+
+/// This function tries to, for all type parameters in a supertype predicate `GenericTrait<U>`,
+/// check if the substituted type in the implied-by bound matches with what's subtituted in the
+/// implied type.
+///
+/// Consider this example.
+/// ```rust,ignore
+/// trait GenericTrait<T> {}
+/// trait GenericSubTrait<T, U, V>: GenericTrait<U> {}
+///                                              ^ trait_predicate_args: [Self#0, U#2]
+/// impl GenericTrait<i32> for () {}
+/// impl GenericSubTrait<(), i32, ()> for () {}
+/// impl GenericSubTrait<(), [u8; 8], ()> for () {}
+///
+/// fn f() -> impl GenericTrait<i32> + GenericSubTrait<(), [u8; 8], ()> {
+///                             ^^^ implied_args       ^^^^^^^^^^^^^^^ implied_by_args
+///                                                                    (we are interested in `[u8; 8]` specifically, as that
+///                                                                     is what `U` in `GenericTrait<U>` is substituted with)
+///     ()
+/// }
+/// ```
+/// Here i32 != [u8; 8], so this will return false.
+fn is_same_generics(
+    tcx: TyCtxt<'_>,
+    trait_predicate_args: &[ty::GenericArg<'_>],
+    implied_by_args: &[GenericArg<'_>],
+    implied_args: &[GenericArg<'_>],
+) -> bool {
+    trait_predicate_args
+        .iter()
+        .enumerate()
+        .skip(1) // skip `Self` implicit arg
+        .all(|(arg_index, arg)| {
+            if let Some(ty) = arg.as_type()
+                && let &ty::Param(ty::ParamTy{ index, .. }) = ty.kind()
+                // Since `trait_predicate_args` and type params in traits start with `Self=0`
+                // and generic argument lists `GenericTrait<i32>` don't have `Self`,
+                // we need to subtract 1 from the index.
+                && let GenericArg::Type(ty_a) = implied_by_args[index as usize - 1]
+                && let GenericArg::Type(ty_b) = implied_args[arg_index - 1]
+            {
+                hir_ty_to_ty(tcx, ty_a) == hir_ty_to_ty(tcx, ty_b)
+            } else {
+                false
+            }
+        })
+}
+
+impl LateLintPass<'_> for ImpliedBoundsInImpls {
+    fn check_fn(
+        &mut self,
+        cx: &LateContext<'_>,
+        _: FnKind<'_>,
+        decl: &FnDecl<'_>,
+        _: &Body<'_>,
+        _: Span,
+        _: LocalDefId,
+    ) {
+        if let FnRetTy::Return(ty) = decl.output 
+            &&let TyKind::OpaqueDef(item_id, ..) = ty.kind
+            && let item = cx.tcx.hir().item(item_id)
+            && let ItemKind::OpaqueTy(opaque_ty) = item.kind
+            // Very often there is only a single bound, e.g. `impl Deref<..>`, in which case
+            // we can avoid doing a bunch of stuff unnecessarily.
+            && opaque_ty.bounds.len() > 1
+        {
+            // Get all the (implied) trait predicates in the bounds.
+            // For `impl Deref + DerefMut` this will contain [`Deref`].
+            // The implied `Deref` comes from `DerefMut` because `trait DerefMut: Deref {}`.
+            // N.B. (G)ATs are fine to disregard, because they must be the same for all of its supertraits.
+            // Example:
+            // `impl Deref<Target = i32> + DerefMut<Target = u32>` is not allowed.
+            // `DerefMut::Target` needs to match `Deref::Target`.
+            let implied_bounds: Vec<_> = opaque_ty.bounds.iter().filter_map(|bound| {
+                if let GenericBound::Trait(poly_trait, TraitBoundModifier::None) = bound
+                    && let [.., path]  = poly_trait.trait_ref.path.segments
+                    && poly_trait.bound_generic_params.is_empty()
+                    && let Some(trait_def_id) = path.res.opt_def_id()
+                    && let predicates = cx.tcx.super_predicates_of(trait_def_id).predicates
+                    && !predicates.is_empty() // If the trait has no supertrait, there is nothing to add.
+                {
+                    Some((bound.span(), path.args.map_or([].as_slice(), |a| a.args), predicates))
+                } else {
+                    None
+                }
+            }).collect();
+
+            // Lint all bounds in the `impl Trait` type that are also in the `implied_bounds` vec.
+            // This involves some extra logic when generic arguments are present, since
+            // simply comparing trait `DefId`s won't be enough. We also need to compare the generics.
+            for (index, bound) in opaque_ty.bounds.iter().enumerate() {
+                if let GenericBound::Trait(poly_trait, TraitBoundModifier::None) = bound
+                    && let [.., path] = poly_trait.trait_ref.path.segments
+                    && let implied_args = path.args.map_or([].as_slice(), |a| a.args)
+                    && let Some(def_id) = poly_trait.trait_ref.path.res.opt_def_id()
+                    && let Some(implied_by_span) = implied_bounds.iter().find_map(|&(span, implied_by_args, preds)| {
+                        preds.iter().find_map(|(clause, _)| {
+                            if let ClauseKind::Trait(tr) = clause.kind().skip_binder()
+                                && tr.def_id() == def_id
+                                && is_same_generics(cx.tcx, tr.trait_ref.args, implied_by_args, implied_args)
+                            {
+                                Some(span)
+                            } else {
+                                None
+                            }
+                        })
+                    })
+                {
+                    let implied_by = snippet(cx, implied_by_span, "..");
+                    span_lint_and_then(
+                        cx, IMPLIED_BOUNDS_IN_IMPLS,
+                        poly_trait.span,
+                        &format!("this bound is already specified as the supertrait of `{}`", implied_by),
+                        |diag| {
+                            // If we suggest removing a bound, we may also need extend the span
+                            // to include the `+` token, so we don't end up with something like `impl + B`
+
+                            let implied_span_extended = if let Some(next_bound) = opaque_ty.bounds.get(index + 1) {
+                                poly_trait.span.to(next_bound.span().shrink_to_lo())
+                            } else {
+                                poly_trait.span
+                            };
+
+                            diag.span_suggestion_with_style(
+                                implied_span_extended,
+                                "try removing this bound",
+                                "",
+                                Applicability::MachineApplicable,
+                                SuggestionStyle::ShowAlways
+                            );
+                        }
+                    );
+                }
+            }
+        }
+    }
+}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index d4fcddc66c5..ab71bfbdc58 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -152,7 +152,7 @@ mod implicit_hasher;
 mod implicit_return;
 mod implicit_saturating_add;
 mod implicit_saturating_sub;
-mod implied_bounds_in_impl;
+mod implied_bounds_in_impls;
 mod inconsistent_struct_constructor;
 mod incorrect_impls;
 mod index_refutable_slice;
@@ -1098,7 +1098,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(redundant_locals::RedundantLocals));
     store.register_late_pass(|_| Box::new(ignored_unit_patterns::IgnoredUnitPatterns));
     store.register_late_pass(|_| Box::<reserve_after_initialization::ReserveAfterInitialization>::default());
-    store.register_late_pass(|_| Box::new(implied_bounds_in_impl::ImpliedBoundsInImpl));
+    store.register_late_pass(|_| Box::new(implied_bounds_in_impls::ImpliedBoundsInImpls));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/tests/ui/implied_bounds_in_impl.rs b/tests/ui/implied_bounds_in_impl.rs
deleted file mode 100644
index 0bc4b193d53..00000000000
--- a/tests/ui/implied_bounds_in_impl.rs
+++ /dev/null
@@ -1,47 +0,0 @@
-#![warn(clippy::implied_bounds_in_impl)]
-#![allow(dead_code)]
-
-use std::ops::{Deref, DerefMut};
-
-// Only one bound, nothing to lint.
-fn normal_deref<T>(x: T) -> impl Deref<Target = T> {
-    Box::new(x)
-}
-
-// Deref implied by DerefMut
-fn deref_derefmut<T>(x: T) -> impl Deref<Target = T> + DerefMut<Target = T> {
-    Box::new(x)
-}
-
-trait GenericTrait<T> {}
-trait GenericTrait2<V> {}
-// U is intentionally at a different "index" in GenericSubtrait than `T` is in GenericTrait
-trait GenericSubtrait<T, U, V>: GenericTrait<U> + GenericTrait2<V> {}
-
-impl GenericTrait<i32> for () {}
-impl GenericTrait<i64> for () {}
-impl<V> GenericTrait2<V> for () {}
-impl<V> GenericSubtrait<(), i32, V> for () {}
-impl<V> GenericSubtrait<(), i64, V> for () {}
-
-fn generics_implied<T>() -> impl GenericTrait<T> + GenericSubtrait<(), T, ()>
-where
-    (): GenericSubtrait<(), T, ()>,
-{
-}
-
-fn generics_implied_multi<V>() -> impl GenericTrait<i32> + GenericTrait2<V> + GenericSubtrait<(), i32, V> {}
-
-fn generics_implied_multi2<T, V>() -> impl GenericTrait<T> + GenericTrait2<V> + GenericSubtrait<(), T, V>
-where
-    (): GenericSubtrait<(), T, V> + GenericTrait<T>,
-{
-}
-
-// i32 != i64, GenericSubtrait<_, i64, _> does not imply GenericTrait<i32>, don't lint
-fn generics_different() -> impl GenericTrait<i32> + GenericSubtrait<(), i64, ()> {}
-
-// i32 == i32, GenericSubtrait<_, i32, _> does imply GenericTrait<i32>, lint
-fn generics_same() -> impl GenericTrait<i32> + GenericSubtrait<(), i32, ()> {}
-
-fn main() {}
diff --git a/tests/ui/implied_bounds_in_impl.stderr b/tests/ui/implied_bounds_in_impl.stderr
deleted file mode 100644
index 92d412e784f..00000000000
--- a/tests/ui/implied_bounds_in_impl.stderr
+++ /dev/null
@@ -1,46 +0,0 @@
-error: this bound is implied by another bound and can be removed
-  --> $DIR/implied_bounds_in_impl.rs:12:36
-   |
-LL | fn deref_derefmut<T>(x: T) -> impl Deref<Target = T> + DerefMut<Target = T> {
-   |                                    ^^^^^^^^^^^^^^^^^
-   |
-   = note: `-D clippy::implied-bounds-in-impl` implied by `-D warnings`
-
-error: this bound is implied by another bound and can be removed
-  --> $DIR/implied_bounds_in_impl.rs:27:34
-   |
-LL | fn generics_implied<T>() -> impl GenericTrait<T> + GenericSubtrait<(), T, ()>
-   |                                  ^^^^^^^^^^^^^^^
-
-error: this bound is implied by another bound and can be removed
-  --> $DIR/implied_bounds_in_impl.rs:33:40
-   |
-LL | fn generics_implied_multi<V>() -> impl GenericTrait<i32> + GenericTrait2<V> + GenericSubtrait<(), i32, V> {}
-   |                                        ^^^^^^^^^^^^^^^^^
-
-error: this bound is implied by another bound and can be removed
-  --> $DIR/implied_bounds_in_impl.rs:33:60
-   |
-LL | fn generics_implied_multi<V>() -> impl GenericTrait<i32> + GenericTrait2<V> + GenericSubtrait<(), i32, V> {}
-   |                                                            ^^^^^^^^^^^^^^^^
-
-error: this bound is implied by another bound and can be removed
-  --> $DIR/implied_bounds_in_impl.rs:35:44
-   |
-LL | fn generics_implied_multi2<T, V>() -> impl GenericTrait<T> + GenericTrait2<V> + GenericSubtrait<(), T, V>
-   |                                            ^^^^^^^^^^^^^^^
-
-error: this bound is implied by another bound and can be removed
-  --> $DIR/implied_bounds_in_impl.rs:35:62
-   |
-LL | fn generics_implied_multi2<T, V>() -> impl GenericTrait<T> + GenericTrait2<V> + GenericSubtrait<(), T, V>
-   |                                                              ^^^^^^^^^^^^^^^^
-
-error: this bound is implied by another bound and can be removed
-  --> $DIR/implied_bounds_in_impl.rs:45:28
-   |
-LL | fn generics_same() -> impl GenericTrait<i32> + GenericSubtrait<(), i32, ()> {}
-   |                            ^^^^^^^^^^^^^^^^^
-
-error: aborting due to 7 previous errors
-
diff --git a/tests/ui/implied_bounds_in_impls.fixed b/tests/ui/implied_bounds_in_impls.fixed
new file mode 100644
index 00000000000..72239afae4a
--- /dev/null
+++ b/tests/ui/implied_bounds_in_impls.fixed
@@ -0,0 +1,70 @@
+#![warn(clippy::implied_bounds_in_impls)]
+#![allow(dead_code)]
+#![feature(return_position_impl_trait_in_trait)]
+
+use std::ops::{Deref, DerefMut};
+
+// Only one bound, nothing to lint.
+fn normal_deref<T>(x: T) -> impl Deref<Target = T> {
+    Box::new(x)
+}
+
+// Deref implied by DerefMut
+fn deref_derefmut<T>(x: T) -> impl DerefMut<Target = T> {
+    Box::new(x)
+}
+
+trait GenericTrait<T> {}
+trait GenericTrait2<V> {}
+// U is intentionally at a different "index" in GenericSubtrait than `T` is in GenericTrait,
+// so this can be a good test to make sure that the calculations are right (no off-by-one errors,
+// ...)
+trait GenericSubtrait<T, U, V>: GenericTrait<U> + GenericTrait2<V> {}
+
+impl GenericTrait<i32> for () {}
+impl GenericTrait<i64> for () {}
+impl<V> GenericTrait2<V> for () {}
+impl<V> GenericSubtrait<(), i32, V> for () {}
+impl<V> GenericSubtrait<(), i64, V> for () {}
+
+fn generics_implied<U, W>() -> impl GenericSubtrait<U, W, U>
+where
+    (): GenericSubtrait<U, W, U>,
+{
+}
+
+fn generics_implied_multi<V>() -> impl GenericSubtrait<(), i32, V> {}
+
+fn generics_implied_multi2<T, V>() -> impl GenericSubtrait<(), T, V>
+where
+    (): GenericSubtrait<(), T, V> + GenericTrait<T>,
+{
+}
+
+// i32 != i64, GenericSubtrait<_, i64, _> does not imply GenericTrait<i32>, don't lint
+fn generics_different() -> impl GenericTrait<i32> + GenericSubtrait<(), i64, ()> {}
+
+// i32 == i32, GenericSubtrait<_, i32, _> does imply GenericTrait<i32>, lint
+fn generics_same() -> impl GenericSubtrait<(), i32, ()> {}
+
+trait SomeTrait {
+    // Check that it works in trait declarations.
+    fn f() -> impl DerefMut<Target = u8> {
+        Box::new(0)
+    }
+}
+struct SomeStruct;
+impl SomeStruct {
+    // Check that it works in inherent impl blocks.
+    fn f() -> impl DerefMut<Target = u8> {
+        Box::new(123)
+    }
+}
+impl SomeTrait for SomeStruct {
+    // Check that it works in trait impls.
+    fn f() -> impl DerefMut<Target = u8> {
+        Box::new(42)
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/implied_bounds_in_impls.rs b/tests/ui/implied_bounds_in_impls.rs
new file mode 100644
index 00000000000..d59241d9ad1
--- /dev/null
+++ b/tests/ui/implied_bounds_in_impls.rs
@@ -0,0 +1,70 @@
+#![warn(clippy::implied_bounds_in_impls)]
+#![allow(dead_code)]
+#![feature(return_position_impl_trait_in_trait)]
+
+use std::ops::{Deref, DerefMut};
+
+// Only one bound, nothing to lint.
+fn normal_deref<T>(x: T) -> impl Deref<Target = T> {
+    Box::new(x)
+}
+
+// Deref implied by DerefMut
+fn deref_derefmut<T>(x: T) -> impl Deref<Target = T> + DerefMut<Target = T> {
+    Box::new(x)
+}
+
+trait GenericTrait<T> {}
+trait GenericTrait2<V> {}
+// U is intentionally at a different "index" in GenericSubtrait than `T` is in GenericTrait,
+// so this can be a good test to make sure that the calculations are right (no off-by-one errors,
+// ...)
+trait GenericSubtrait<T, U, V>: GenericTrait<U> + GenericTrait2<V> {}
+
+impl GenericTrait<i32> for () {}
+impl GenericTrait<i64> for () {}
+impl<V> GenericTrait2<V> for () {}
+impl<V> GenericSubtrait<(), i32, V> for () {}
+impl<V> GenericSubtrait<(), i64, V> for () {}
+
+fn generics_implied<U, W>() -> impl GenericTrait<W> + GenericSubtrait<U, W, U>
+where
+    (): GenericSubtrait<U, W, U>,
+{
+}
+
+fn generics_implied_multi<V>() -> impl GenericTrait<i32> + GenericTrait2<V> + GenericSubtrait<(), i32, V> {}
+
+fn generics_implied_multi2<T, V>() -> impl GenericTrait<T> + GenericTrait2<V> + GenericSubtrait<(), T, V>
+where
+    (): GenericSubtrait<(), T, V> + GenericTrait<T>,
+{
+}
+
+// i32 != i64, GenericSubtrait<_, i64, _> does not imply GenericTrait<i32>, don't lint
+fn generics_different() -> impl GenericTrait<i32> + GenericSubtrait<(), i64, ()> {}
+
+// i32 == i32, GenericSubtrait<_, i32, _> does imply GenericTrait<i32>, lint
+fn generics_same() -> impl GenericTrait<i32> + GenericSubtrait<(), i32, ()> {}
+
+trait SomeTrait {
+    // Check that it works in trait declarations.
+    fn f() -> impl Deref + DerefMut<Target = u8> {
+        Box::new(0)
+    }
+}
+struct SomeStruct;
+impl SomeStruct {
+    // Check that it works in inherent impl blocks.
+    fn f() -> impl DerefMut<Target = u8> {
+        Box::new(123)
+    }
+}
+impl SomeTrait for SomeStruct {
+    // Check that it works in trait impls.
+    fn f() -> impl DerefMut<Target = u8> {
+        Box::new(42)
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/implied_bounds_in_impls.stderr b/tests/ui/implied_bounds_in_impls.stderr
new file mode 100644
index 00000000000..86ce64a47fd
--- /dev/null
+++ b/tests/ui/implied_bounds_in_impls.stderr
@@ -0,0 +1,99 @@
+error: this bound is already specified as the supertrait of `DerefMut<Target = T>`
+  --> $DIR/implied_bounds_in_impls.rs:13:36
+   |
+LL | fn deref_derefmut<T>(x: T) -> impl Deref<Target = T> + DerefMut<Target = T> {
+   |                                    ^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::implied-bounds-in-impls` implied by `-D warnings`
+help: try removing this bound
+   |
+LL - fn deref_derefmut<T>(x: T) -> impl Deref<Target = T> + DerefMut<Target = T> {
+LL + fn deref_derefmut<T>(x: T) -> impl DerefMut<Target = T> {
+   |
+
+error: this bound is already specified as the supertrait of `GenericSubtrait<U, W, U>`
+  --> $DIR/implied_bounds_in_impls.rs:30:37
+   |
+LL | fn generics_implied<U, W>() -> impl GenericTrait<W> + GenericSubtrait<U, W, U>
+   |                                     ^^^^^^^^^^^^^^^
+   |
+help: try removing this bound
+   |
+LL - fn generics_implied<U, W>() -> impl GenericTrait<W> + GenericSubtrait<U, W, U>
+LL + fn generics_implied<U, W>() -> impl GenericSubtrait<U, W, U>
+   |
+
+error: this bound is already specified as the supertrait of `GenericSubtrait<(), i32, V>`
+  --> $DIR/implied_bounds_in_impls.rs:36:40
+   |
+LL | fn generics_implied_multi<V>() -> impl GenericTrait<i32> + GenericTrait2<V> + GenericSubtrait<(), i32, V> {}
+   |                                        ^^^^^^^^^^^^^^^^^
+   |
+help: try removing this bound
+   |
+LL - fn generics_implied_multi<V>() -> impl GenericTrait<i32> + GenericTrait2<V> + GenericSubtrait<(), i32, V> {}
+LL + fn generics_implied_multi<V>() -> impl GenericTrait2<V> + GenericSubtrait<(), i32, V> {}
+   |
+
+error: this bound is already specified as the supertrait of `GenericSubtrait<(), i32, V>`
+  --> $DIR/implied_bounds_in_impls.rs:36:60
+   |
+LL | fn generics_implied_multi<V>() -> impl GenericTrait<i32> + GenericTrait2<V> + GenericSubtrait<(), i32, V> {}
+   |                                                            ^^^^^^^^^^^^^^^^
+   |
+help: try removing this bound
+   |
+LL - fn generics_implied_multi<V>() -> impl GenericTrait<i32> + GenericTrait2<V> + GenericSubtrait<(), i32, V> {}
+LL + fn generics_implied_multi<V>() -> impl GenericTrait<i32> + GenericSubtrait<(), i32, V> {}
+   |
+
+error: this bound is already specified as the supertrait of `GenericSubtrait<(), T, V>`
+  --> $DIR/implied_bounds_in_impls.rs:38:44
+   |
+LL | fn generics_implied_multi2<T, V>() -> impl GenericTrait<T> + GenericTrait2<V> + GenericSubtrait<(), T, V>
+   |                                            ^^^^^^^^^^^^^^^
+   |
+help: try removing this bound
+   |
+LL - fn generics_implied_multi2<T, V>() -> impl GenericTrait<T> + GenericTrait2<V> + GenericSubtrait<(), T, V>
+LL + fn generics_implied_multi2<T, V>() -> impl GenericTrait2<V> + GenericSubtrait<(), T, V>
+   |
+
+error: this bound is already specified as the supertrait of `GenericSubtrait<(), T, V>`
+  --> $DIR/implied_bounds_in_impls.rs:38:62
+   |
+LL | fn generics_implied_multi2<T, V>() -> impl GenericTrait<T> + GenericTrait2<V> + GenericSubtrait<(), T, V>
+   |                                                              ^^^^^^^^^^^^^^^^
+   |
+help: try removing this bound
+   |
+LL - fn generics_implied_multi2<T, V>() -> impl GenericTrait<T> + GenericTrait2<V> + GenericSubtrait<(), T, V>
+LL + fn generics_implied_multi2<T, V>() -> impl GenericTrait<T> + GenericSubtrait<(), T, V>
+   |
+
+error: this bound is already specified as the supertrait of `GenericSubtrait<(), i32, ()>`
+  --> $DIR/implied_bounds_in_impls.rs:48:28
+   |
+LL | fn generics_same() -> impl GenericTrait<i32> + GenericSubtrait<(), i32, ()> {}
+   |                            ^^^^^^^^^^^^^^^^^
+   |
+help: try removing this bound
+   |
+LL - fn generics_same() -> impl GenericTrait<i32> + GenericSubtrait<(), i32, ()> {}
+LL + fn generics_same() -> impl GenericSubtrait<(), i32, ()> {}
+   |
+
+error: this bound is already specified as the supertrait of `DerefMut<Target = u8>`
+  --> $DIR/implied_bounds_in_impls.rs:52:20
+   |
+LL |     fn f() -> impl Deref + DerefMut<Target = u8> {
+   |                    ^^^^^
+   |
+help: try removing this bound
+   |
+LL -     fn f() -> impl Deref + DerefMut<Target = u8> {
+LL +     fn f() -> impl DerefMut<Target = u8> {
+   |
+
+error: aborting due to 8 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 12275713d5e1540ddde6a6854b106c537270e9de Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Wed, 23 Aug 2023 16:48:12 +0200
Subject: support inherent impls and trait impls

---
 clippy_lints/src/implied_bounds_in_impls.rs | 173 +++++++++++++++-------------
 tests/ui/implied_bounds_in_impls.fixed      |   4 +-
 tests/ui/implied_bounds_in_impls.rs         |   8 +-
 tests/ui/implied_bounds_in_impls.stderr     |  26 ++++-
 4 files changed, 124 insertions(+), 87 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/implied_bounds_in_impls.rs b/clippy_lints/src/implied_bounds_in_impls.rs
index 7ba467a3e06..c6d1acad3a0 100644
--- a/clippy_lints/src/implied_bounds_in_impls.rs
+++ b/clippy_lints/src/implied_bounds_in_impls.rs
@@ -1,11 +1,14 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet;
+use rustc_errors::{Applicability, SuggestionStyle};
 use rustc_hir::def_id::LocalDefId;
 use rustc_hir::intravisit::FnKind;
-use rustc_hir::{Body, FnDecl, FnRetTy, GenericArg, GenericBound, ItemKind, TraitBoundModifier, TyKind};
+use rustc_hir::{
+    Body, FnDecl, FnRetTy, GenericArg, GenericBound, ImplItem, ImplItemKind, ItemKind, TraitBoundModifier, TraitItem,
+    TraitItemKind, TyKind,
+};
 use rustc_hir_analysis::hir_ty_to_ty;
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_errors::{Applicability, SuggestionStyle};
 use rustc_middle::ty::{self, ClauseKind, TyCtxt};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::Span;
@@ -94,6 +97,86 @@ fn is_same_generics(
         })
 }
 
+fn check(cx: &LateContext<'_>, decl: &FnDecl<'_>) {
+    if let FnRetTy::Return(ty) = decl.output
+        &&let TyKind::OpaqueDef(item_id, ..) = ty.kind
+        && let item = cx.tcx.hir().item(item_id)
+        && let ItemKind::OpaqueTy(opaque_ty) = item.kind
+        // Very often there is only a single bound, e.g. `impl Deref<..>`, in which case
+        // we can avoid doing a bunch of stuff unnecessarily.
+        && opaque_ty.bounds.len() > 1
+    {
+        // Get all the (implied) trait predicates in the bounds.
+        // For `impl Deref + DerefMut` this will contain [`Deref`].
+        // The implied `Deref` comes from `DerefMut` because `trait DerefMut: Deref {}`.
+        // N.B. (G)ATs are fine to disregard, because they must be the same for all of its supertraits.
+        // Example:
+        // `impl Deref<Target = i32> + DerefMut<Target = u32>` is not allowed.
+        // `DerefMut::Target` needs to match `Deref::Target`.
+        let implied_bounds: Vec<_> = opaque_ty.bounds.iter().filter_map(|bound| {
+            if let GenericBound::Trait(poly_trait, TraitBoundModifier::None) = bound
+                && let [.., path]  = poly_trait.trait_ref.path.segments
+                && poly_trait.bound_generic_params.is_empty()
+                && let Some(trait_def_id) = path.res.opt_def_id()
+                && let predicates = cx.tcx.super_predicates_of(trait_def_id).predicates
+                && !predicates.is_empty() // If the trait has no supertrait, there is nothing to add.
+            {
+                Some((bound.span(), path.args.map_or([].as_slice(), |a| a.args), predicates))
+            } else {
+                None
+            }
+        }).collect();
+
+        // Lint all bounds in the `impl Trait` type that are also in the `implied_bounds` vec.
+        // This involves some extra logic when generic arguments are present, since
+        // simply comparing trait `DefId`s won't be enough. We also need to compare the generics.
+        for (index, bound) in opaque_ty.bounds.iter().enumerate() {
+            if let GenericBound::Trait(poly_trait, TraitBoundModifier::None) = bound
+                && let [.., path] = poly_trait.trait_ref.path.segments
+                && let implied_args = path.args.map_or([].as_slice(), |a| a.args)
+                && let Some(def_id) = poly_trait.trait_ref.path.res.opt_def_id()
+                && let Some(implied_by_span) = implied_bounds.iter().find_map(|&(span, implied_by_args, preds)| {
+                    preds.iter().find_map(|(clause, _)| {
+                        if let ClauseKind::Trait(tr) = clause.kind().skip_binder()
+                            && tr.def_id() == def_id
+                            && is_same_generics(cx.tcx, tr.trait_ref.args, implied_by_args, implied_args)
+                        {
+                            Some(span)
+                        } else {
+                            None
+                        }
+                    })
+                })
+            {
+                let implied_by = snippet(cx, implied_by_span, "..");
+                span_lint_and_then(
+                    cx, IMPLIED_BOUNDS_IN_IMPLS,
+                    poly_trait.span,
+                    &format!("this bound is already specified as the supertrait of `{implied_by}`"),
+                    |diag| {
+                        // If we suggest removing a bound, we may also need extend the span
+                        // to include the `+` token, so we don't end up with something like `impl + B`
+
+                        let implied_span_extended = if let Some(next_bound) = opaque_ty.bounds.get(index + 1) {
+                            poly_trait.span.to(next_bound.span().shrink_to_lo())
+                        } else {
+                            poly_trait.span
+                        };
+
+                        diag.span_suggestion_with_style(
+                            implied_span_extended,
+                            "try removing this bound",
+                            "",
+                            Applicability::MachineApplicable,
+                            SuggestionStyle::ShowAlways
+                        );
+                    }
+                );
+            }
+        }
+    }
+}
+
 impl LateLintPass<'_> for ImpliedBoundsInImpls {
     fn check_fn(
         &mut self,
@@ -104,82 +187,16 @@ impl LateLintPass<'_> for ImpliedBoundsInImpls {
         _: Span,
         _: LocalDefId,
     ) {
-        if let FnRetTy::Return(ty) = decl.output 
-            &&let TyKind::OpaqueDef(item_id, ..) = ty.kind
-            && let item = cx.tcx.hir().item(item_id)
-            && let ItemKind::OpaqueTy(opaque_ty) = item.kind
-            // Very often there is only a single bound, e.g. `impl Deref<..>`, in which case
-            // we can avoid doing a bunch of stuff unnecessarily.
-            && opaque_ty.bounds.len() > 1
-        {
-            // Get all the (implied) trait predicates in the bounds.
-            // For `impl Deref + DerefMut` this will contain [`Deref`].
-            // The implied `Deref` comes from `DerefMut` because `trait DerefMut: Deref {}`.
-            // N.B. (G)ATs are fine to disregard, because they must be the same for all of its supertraits.
-            // Example:
-            // `impl Deref<Target = i32> + DerefMut<Target = u32>` is not allowed.
-            // `DerefMut::Target` needs to match `Deref::Target`.
-            let implied_bounds: Vec<_> = opaque_ty.bounds.iter().filter_map(|bound| {
-                if let GenericBound::Trait(poly_trait, TraitBoundModifier::None) = bound
-                    && let [.., path]  = poly_trait.trait_ref.path.segments
-                    && poly_trait.bound_generic_params.is_empty()
-                    && let Some(trait_def_id) = path.res.opt_def_id()
-                    && let predicates = cx.tcx.super_predicates_of(trait_def_id).predicates
-                    && !predicates.is_empty() // If the trait has no supertrait, there is nothing to add.
-                {
-                    Some((bound.span(), path.args.map_or([].as_slice(), |a| a.args), predicates))
-                } else {
-                    None
-                }
-            }).collect();
-
-            // Lint all bounds in the `impl Trait` type that are also in the `implied_bounds` vec.
-            // This involves some extra logic when generic arguments are present, since
-            // simply comparing trait `DefId`s won't be enough. We also need to compare the generics.
-            for (index, bound) in opaque_ty.bounds.iter().enumerate() {
-                if let GenericBound::Trait(poly_trait, TraitBoundModifier::None) = bound
-                    && let [.., path] = poly_trait.trait_ref.path.segments
-                    && let implied_args = path.args.map_or([].as_slice(), |a| a.args)
-                    && let Some(def_id) = poly_trait.trait_ref.path.res.opt_def_id()
-                    && let Some(implied_by_span) = implied_bounds.iter().find_map(|&(span, implied_by_args, preds)| {
-                        preds.iter().find_map(|(clause, _)| {
-                            if let ClauseKind::Trait(tr) = clause.kind().skip_binder()
-                                && tr.def_id() == def_id
-                                && is_same_generics(cx.tcx, tr.trait_ref.args, implied_by_args, implied_args)
-                            {
-                                Some(span)
-                            } else {
-                                None
-                            }
-                        })
-                    })
-                {
-                    let implied_by = snippet(cx, implied_by_span, "..");
-                    span_lint_and_then(
-                        cx, IMPLIED_BOUNDS_IN_IMPLS,
-                        poly_trait.span,
-                        &format!("this bound is already specified as the supertrait of `{}`", implied_by),
-                        |diag| {
-                            // If we suggest removing a bound, we may also need extend the span
-                            // to include the `+` token, so we don't end up with something like `impl + B`
-
-                            let implied_span_extended = if let Some(next_bound) = opaque_ty.bounds.get(index + 1) {
-                                poly_trait.span.to(next_bound.span().shrink_to_lo())
-                            } else {
-                                poly_trait.span
-                            };
-
-                            diag.span_suggestion_with_style(
-                                implied_span_extended,
-                                "try removing this bound",
-                                "",
-                                Applicability::MachineApplicable,
-                                SuggestionStyle::ShowAlways
-                            );
-                        }
-                    );
-                }
-            }
+        check(cx, decl);
+    }
+    fn check_trait_item(&mut self, cx: &LateContext<'_>, item: &TraitItem<'_>) {
+        if let TraitItemKind::Fn(sig, ..) = &item.kind {
+            check(cx, sig.decl);
+        }
+    }
+    fn check_impl_item(&mut self, cx: &LateContext<'_>, item: &ImplItem<'_>) {
+        if let ImplItemKind::Fn(sig, ..) = &item.kind {
+            check(cx, sig.decl);
         }
     }
 }
diff --git a/tests/ui/implied_bounds_in_impls.fixed b/tests/ui/implied_bounds_in_impls.fixed
index 72239afae4a..952c2b70619 100644
--- a/tests/ui/implied_bounds_in_impls.fixed
+++ b/tests/ui/implied_bounds_in_impls.fixed
@@ -49,9 +49,7 @@ fn generics_same() -> impl GenericSubtrait<(), i32, ()> {}
 
 trait SomeTrait {
     // Check that it works in trait declarations.
-    fn f() -> impl DerefMut<Target = u8> {
-        Box::new(0)
-    }
+    fn f() -> impl DerefMut<Target = u8>;
 }
 struct SomeStruct;
 impl SomeStruct {
diff --git a/tests/ui/implied_bounds_in_impls.rs b/tests/ui/implied_bounds_in_impls.rs
index d59241d9ad1..475f2621bbf 100644
--- a/tests/ui/implied_bounds_in_impls.rs
+++ b/tests/ui/implied_bounds_in_impls.rs
@@ -49,20 +49,18 @@ fn generics_same() -> impl GenericTrait<i32> + GenericSubtrait<(), i32, ()> {}
 
 trait SomeTrait {
     // Check that it works in trait declarations.
-    fn f() -> impl Deref + DerefMut<Target = u8> {
-        Box::new(0)
-    }
+    fn f() -> impl Deref + DerefMut<Target = u8>;
 }
 struct SomeStruct;
 impl SomeStruct {
     // Check that it works in inherent impl blocks.
-    fn f() -> impl DerefMut<Target = u8> {
+    fn f() -> impl Deref + DerefMut<Target = u8> {
         Box::new(123)
     }
 }
 impl SomeTrait for SomeStruct {
     // Check that it works in trait impls.
-    fn f() -> impl DerefMut<Target = u8> {
+    fn f() -> impl Deref + DerefMut<Target = u8> {
         Box::new(42)
     }
 }
diff --git a/tests/ui/implied_bounds_in_impls.stderr b/tests/ui/implied_bounds_in_impls.stderr
index 86ce64a47fd..8dffc674444 100644
--- a/tests/ui/implied_bounds_in_impls.stderr
+++ b/tests/ui/implied_bounds_in_impls.stderr
@@ -86,6 +86,30 @@ LL + fn generics_same() -> impl GenericSubtrait<(), i32, ()> {}
 error: this bound is already specified as the supertrait of `DerefMut<Target = u8>`
   --> $DIR/implied_bounds_in_impls.rs:52:20
    |
+LL |     fn f() -> impl Deref + DerefMut<Target = u8>;
+   |                    ^^^^^
+   |
+help: try removing this bound
+   |
+LL -     fn f() -> impl Deref + DerefMut<Target = u8>;
+LL +     fn f() -> impl DerefMut<Target = u8>;
+   |
+
+error: this bound is already specified as the supertrait of `DerefMut<Target = u8>`
+  --> $DIR/implied_bounds_in_impls.rs:57:20
+   |
+LL |     fn f() -> impl Deref + DerefMut<Target = u8> {
+   |                    ^^^^^
+   |
+help: try removing this bound
+   |
+LL -     fn f() -> impl Deref + DerefMut<Target = u8> {
+LL +     fn f() -> impl DerefMut<Target = u8> {
+   |
+
+error: this bound is already specified as the supertrait of `DerefMut<Target = u8>`
+  --> $DIR/implied_bounds_in_impls.rs:63:20
+   |
 LL |     fn f() -> impl Deref + DerefMut<Target = u8> {
    |                    ^^^^^
    |
@@ -95,5 +119,5 @@ LL -     fn f() -> impl Deref + DerefMut<Target = u8> {
 LL +     fn f() -> impl DerefMut<Target = u8> {
    |
 
-error: aborting due to 8 previous errors
+error: aborting due to 10 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 42c6492ebcedfff6f7452245b15ef7e0bf3abefa Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Wed, 23 Aug 2023 21:02:01 +0200
Subject: [`unnecessary_unwrap`]: lint on `.as_ref().unwrap()`

---
 clippy_lints/src/unwrap.rs                         | 96 ++++++++++++++++++++--
 clippy_utils/src/usage.rs                          | 13 ++-
 tests/ui/checked_unwrap/simple_conditionals.rs     | 40 +++++++++
 tests/ui/checked_unwrap/simple_conditionals.stderr | 70 +++++++++++++++-
 4 files changed, 210 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unwrap.rs b/clippy_lints/src/unwrap.rs
index c99b0290c0c..fc97ab8fbe1 100644
--- a/clippy_lints/src/unwrap.rs
+++ b/clippy_lints/src/unwrap.rs
@@ -1,15 +1,18 @@
 use clippy_utils::diagnostics::span_lint_hir_and_then;
 use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::usage::is_potentially_mutated;
+use clippy_utils::usage::is_potentially_local_place;
 use clippy_utils::{higher, path_to_local};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_expr, walk_fn, FnKind, Visitor};
-use rustc_hir::{BinOpKind, Body, Expr, ExprKind, FnDecl, HirId, PathSegment, UnOp};
+use rustc_hir::{BinOpKind, Body, Expr, ExprKind, FnDecl, HirId, Node, PathSegment, UnOp};
+use rustc_hir_typeck::expr_use_visitor::{Delegate, ExprUseVisitor, PlaceWithHirId};
+use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::nested_filter;
 use rustc_middle::lint::in_external_macro;
-use rustc_middle::ty::Ty;
+use rustc_middle::mir::FakeReadCause;
+use rustc_middle::ty::{self, Ty, TyCtxt};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::def_id::LocalDefId;
 use rustc_span::source_map::Span;
@@ -192,6 +195,43 @@ fn collect_unwrap_info<'tcx>(
     Vec::new()
 }
 
+/// A HIR visitor delegate that checks if a local variable of type `Option<_>` is mutated,
+/// unless `Option::as_mut` is called.
+struct MutationVisitor<'tcx> {
+    is_mutated: bool,
+    local_id: HirId,
+    tcx: TyCtxt<'tcx>,
+}
+
+fn is_option_as_mut_use(tcx: TyCtxt<'_>, expr_id: HirId) -> bool {
+    if let Node::Expr(mutating_expr) = tcx.hir().get_parent(expr_id)
+        && let ExprKind::MethodCall(path, ..) = mutating_expr.kind
+    {
+        path.ident.name.as_str() == "as_mut"
+    } else {
+        false
+    }
+}
+
+impl<'tcx> Delegate<'tcx> for MutationVisitor<'tcx> {
+    fn borrow(&mut self, cat: &PlaceWithHirId<'tcx>, diag_expr_id: HirId, bk: ty::BorrowKind) {
+        if let ty::BorrowKind::MutBorrow = bk
+            && is_potentially_local_place(self.local_id, &cat.place)
+            && !is_option_as_mut_use(self.tcx, diag_expr_id)
+        {
+            self.is_mutated = true;
+        }
+    }
+
+    fn mutate(&mut self, _: &PlaceWithHirId<'tcx>, _: HirId) {
+        self.is_mutated = true;
+    }
+
+    fn consume(&mut self, _: &PlaceWithHirId<'tcx>, _: HirId) {}
+
+    fn fake_read(&mut self, _: &PlaceWithHirId<'tcx>, _: FakeReadCause, _: HirId) {}
+}
+
 impl<'a, 'tcx> UnwrappableVariablesVisitor<'a, 'tcx> {
     fn visit_branch(
         &mut self,
@@ -202,9 +242,24 @@ impl<'a, 'tcx> UnwrappableVariablesVisitor<'a, 'tcx> {
     ) {
         let prev_len = self.unwrappables.len();
         for unwrap_info in collect_unwrap_info(self.cx, if_expr, cond, branch, else_branch, true) {
-            if is_potentially_mutated(unwrap_info.local_id, cond, self.cx)
-                || is_potentially_mutated(unwrap_info.local_id, branch, self.cx)
-            {
+            let mut delegate = MutationVisitor {
+                tcx: self.cx.tcx,
+                is_mutated: false,
+                local_id: unwrap_info.local_id,
+            };
+
+            let infcx = self.cx.tcx.infer_ctxt().build();
+            let mut vis = ExprUseVisitor::new(
+                &mut delegate,
+                &infcx,
+                cond.hir_id.owner.def_id,
+                self.cx.param_env,
+                self.cx.typeck_results(),
+            );
+            vis.walk_expr(cond);
+            vis.walk_expr(branch);
+
+            if delegate.is_mutated {
                 // if the variable is mutated, we don't know whether it can be unwrapped:
                 continue;
             }
@@ -215,6 +270,27 @@ impl<'a, 'tcx> UnwrappableVariablesVisitor<'a, 'tcx> {
     }
 }
 
+enum AsRefKind {
+    AsRef,
+    AsMut,
+}
+
+/// Checks if the expression is a method call to `as_{ref,mut}` and returns the receiver of it.
+/// If it isn't, the expression itself is returned.
+fn consume_option_as_ref<'tcx>(expr: &'tcx Expr<'tcx>) -> (&'tcx Expr<'tcx>, Option<AsRefKind>) {
+    if let ExprKind::MethodCall(path, recv, ..) = expr.kind {
+        if path.ident.name == sym::as_ref {
+            (recv, Some(AsRefKind::AsRef))
+        } else if path.ident.name.as_str() == "as_mut" {
+            (recv, Some(AsRefKind::AsMut))
+        } else {
+            (expr, None)
+        }
+    } else {
+        (expr, None)
+    }
+}
+
 impl<'a, 'tcx> Visitor<'tcx> for UnwrappableVariablesVisitor<'a, 'tcx> {
     type NestedFilter = nested_filter::OnlyBodies;
 
@@ -233,6 +309,7 @@ impl<'a, 'tcx> Visitor<'tcx> for UnwrappableVariablesVisitor<'a, 'tcx> {
             // find `unwrap[_err]()` calls:
             if_chain! {
                 if let ExprKind::MethodCall(method_name, self_arg, ..) = expr.kind;
+                let (self_arg, as_ref_kind) = consume_option_as_ref(self_arg);
                 if let Some(id) = path_to_local(self_arg);
                 if [sym::unwrap, sym::expect, sym!(unwrap_err)].contains(&method_name.ident.name);
                 let call_to_unwrap = [sym::unwrap, sym::expect].contains(&method_name.ident.name);
@@ -268,7 +345,12 @@ impl<'a, 'tcx> Visitor<'tcx> for UnwrappableVariablesVisitor<'a, 'tcx> {
                                         unwrappable.check.span.with_lo(unwrappable.if_expr.span.lo()),
                                         "try",
                                         format!(
-                                            "if let {suggested_pattern} = {unwrappable_variable_name}",
+                                            "if let {suggested_pattern} = {borrow_prefix}{unwrappable_variable_name}",
+                                            borrow_prefix = match as_ref_kind {
+                                                Some(AsRefKind::AsRef) => "&",
+                                                Some(AsRefKind::AsMut) => "&mut ",
+                                                None => "",
+                                            },
                                         ),
                                         // We don't track how the unwrapped value is used inside the
                                         // block or suggest deleting the unwrap, so we can't offer a
diff --git a/clippy_utils/src/usage.rs b/clippy_utils/src/usage.rs
index 39ef76348d7..ec131c7f6a3 100644
--- a/clippy_utils/src/usage.rs
+++ b/clippy_utils/src/usage.rs
@@ -4,7 +4,7 @@ use core::ops::ControlFlow;
 use hir::def::Res;
 use rustc_hir::intravisit::{self, Visitor};
 use rustc_hir::{self as hir, Expr, ExprKind, HirId, HirIdSet};
-use rustc_hir_typeck::expr_use_visitor::{Delegate, ExprUseVisitor, PlaceBase, PlaceWithHirId};
+use rustc_hir_typeck::expr_use_visitor::{Delegate, ExprUseVisitor, Place, PlaceBase, PlaceWithHirId};
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::LateContext;
 use rustc_middle::hir::nested_filter;
@@ -37,6 +37,17 @@ pub fn is_potentially_mutated<'tcx>(variable: HirId, expr: &'tcx Expr<'_>, cx: &
     mutated_variables(expr, cx).map_or(true, |mutated| mutated.contains(&variable))
 }
 
+pub fn is_potentially_local_place(local_id: HirId, place: &Place<'_>) -> bool {
+    match place.base {
+        PlaceBase::Local(id) => id == local_id,
+        PlaceBase::Upvar(_) => {
+            // Conservatively assume yes.
+            true
+        },
+        _ => false,
+    }
+}
+
 struct MutVarsDelegate {
     used_mutably: HirIdSet,
     skip: bool,
diff --git a/tests/ui/checked_unwrap/simple_conditionals.rs b/tests/ui/checked_unwrap/simple_conditionals.rs
index e82e7bcb06c..feeef9393be 100644
--- a/tests/ui/checked_unwrap/simple_conditionals.rs
+++ b/tests/ui/checked_unwrap/simple_conditionals.rs
@@ -128,6 +128,46 @@ fn main() {
     assert!(x.is_ok(), "{:?}", x.unwrap_err());
 }
 
+fn issue11371() {
+    let option = Some(());
+
+    if option.is_some() {
+        option.as_ref().unwrap();
+        //~^ ERROR: called `unwrap` on `option` after checking its variant with `is_some`
+    } else {
+        option.as_ref().unwrap();
+        //~^ ERROR: this call to `unwrap()` will always panic
+    }
+
+    let result = Ok::<(), ()>(());
+
+    if result.is_ok() {
+        result.as_ref().unwrap();
+        //~^ ERROR: called `unwrap` on `result` after checking its variant with `is_ok`
+    } else {
+        result.as_ref().unwrap();
+        //~^ ERROR: this call to `unwrap()` will always panic
+    }
+
+    let mut option = Some(());
+    if option.is_some() {
+        option.as_mut().unwrap();
+        //~^ ERROR: called `unwrap` on `option` after checking its variant with `is_some`
+    } else {
+        option.as_mut().unwrap();
+        //~^ ERROR: this call to `unwrap()` will always panic
+    }
+
+    let mut result = Ok::<(), ()>(());
+    if result.is_ok() {
+        result.as_mut().unwrap();
+        //~^ ERROR: called `unwrap` on `result` after checking its variant with `is_ok`
+    } else {
+        result.as_mut().unwrap();
+        //~^ ERROR: this call to `unwrap()` will always panic
+    }
+}
+
 fn check_expect() {
     let x = Some(());
     if x.is_some() {
diff --git a/tests/ui/checked_unwrap/simple_conditionals.stderr b/tests/ui/checked_unwrap/simple_conditionals.stderr
index ed603581ecd..a5afbba7317 100644
--- a/tests/ui/checked_unwrap/simple_conditionals.stderr
+++ b/tests/ui/checked_unwrap/simple_conditionals.stderr
@@ -168,5 +168,73 @@ LL |     if x.is_err() {
 LL |         x.unwrap_err();
    |         ^^^^^^^^^^^^^^
 
-error: aborting due to 17 previous errors
+error: called `unwrap` on `option` after checking its variant with `is_some`
+  --> $DIR/simple_conditionals.rs:135:9
+   |
+LL |     if option.is_some() {
+   |     ------------------- help: try: `if let Some(..) = &option`
+LL |         option.as_ref().unwrap();
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: this call to `unwrap()` will always panic
+  --> $DIR/simple_conditionals.rs:138:9
+   |
+LL |     if option.is_some() {
+   |        ---------------- because of this check
+...
+LL |         option.as_ref().unwrap();
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: called `unwrap` on `result` after checking its variant with `is_ok`
+  --> $DIR/simple_conditionals.rs:145:9
+   |
+LL |     if result.is_ok() {
+   |     ----------------- help: try: `if let Ok(..) = &result`
+LL |         result.as_ref().unwrap();
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: this call to `unwrap()` will always panic
+  --> $DIR/simple_conditionals.rs:148:9
+   |
+LL |     if result.is_ok() {
+   |        -------------- because of this check
+...
+LL |         result.as_ref().unwrap();
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: called `unwrap` on `option` after checking its variant with `is_some`
+  --> $DIR/simple_conditionals.rs:154:9
+   |
+LL |     if option.is_some() {
+   |     ------------------- help: try: `if let Some(..) = &mut option`
+LL |         option.as_mut().unwrap();
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: this call to `unwrap()` will always panic
+  --> $DIR/simple_conditionals.rs:157:9
+   |
+LL |     if option.is_some() {
+   |        ---------------- because of this check
+...
+LL |         option.as_mut().unwrap();
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: called `unwrap` on `result` after checking its variant with `is_ok`
+  --> $DIR/simple_conditionals.rs:163:9
+   |
+LL |     if result.is_ok() {
+   |     ----------------- help: try: `if let Ok(..) = &mut result`
+LL |         result.as_mut().unwrap();
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: this call to `unwrap()` will always panic
+  --> $DIR/simple_conditionals.rs:166:9
+   |
+LL |     if result.is_ok() {
+   |        -------------- because of this check
+...
+LL |         result.as_mut().unwrap();
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 25 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From fb6fad20c87d8562c60ef1ad28f6cf471b76d3c2 Mon Sep 17 00:00:00 2001
From: lengyijun <sjtu5140809011@gmail.com>
Date: Sun, 20 Aug 2023 09:14:52 +0800
Subject: [`iter_overeager_cloned`]: detect .cloned().all() and .cloned().any()

---
 clippy_lints/src/methods/iter_overeager_cloned.rs |  2 +-
 clippy_lints/src/methods/mod.rs                   | 22 ++++++++++++++++------
 tests/ui/iter_overeager_cloned.fixed              |  6 ++----
 tests/ui/iter_overeager_cloned.rs                 |  2 --
 tests/ui/iter_overeager_cloned.stderr             | 18 +++++++++++++++++-
 5 files changed, 36 insertions(+), 14 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/iter_overeager_cloned.rs b/clippy_lints/src/methods/iter_overeager_cloned.rs
index ee405a3e30c..a49dd98db87 100644
--- a/clippy_lints/src/methods/iter_overeager_cloned.rs
+++ b/clippy_lints/src/methods/iter_overeager_cloned.rs
@@ -21,7 +21,7 @@ pub(super) enum Op<'a> {
     RmCloned,
 
     // rm `.cloned()`
-    // e.g. `map` `for_each`
+    // e.g. `map` `for_each` `all` `any`
     NeedlessMove(&'a str, &'a Expr<'a>),
 
     // later `.cloned()`
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 5075137caa0..5fb0d9f0a57 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3873,6 +3873,12 @@ impl Methods {
                 ("add" | "offset" | "sub" | "wrapping_offset" | "wrapping_add" | "wrapping_sub", [_arg]) => {
                     zst_offset::check(cx, expr, recv);
                 },
+                ("all", [arg]) => {
+                    if let Some(("cloned", recv2, [], _, _)) = method_call(recv) {
+                        iter_overeager_cloned::check(cx, expr, recv, recv2,
+                                iter_overeager_cloned::Op::NeedlessMove(name, arg), false);
+                    }
+                }
                 ("and_then", [arg]) => {
                     let biom_option_linted = bind_instead_of_map::OptionAndThenSome::check(cx, expr, recv, arg);
                     let biom_result_linted = bind_instead_of_map::ResultAndThenOk::check(cx, expr, recv, arg);
@@ -3880,12 +3886,16 @@ impl Methods {
                         unnecessary_lazy_eval::check(cx, expr, recv, arg, "and");
                     }
                 },
-                ("any", [arg]) if let ExprKind::Closure(arg) = arg.kind
-                    && let body = cx.tcx.hir().body(arg.body)
-                    && let [param] = body.params
-                    && let Some(("chars", recv, _, _, _)) = method_call(recv) =>
-                {
-                    string_lit_chars_any::check(cx, expr, recv, param, peel_blocks(body.value), &self.msrv);
+                ("any", [arg]) => {
+                    match method_call(recv) {
+                        Some(("cloned", recv2, [], _, _)) => iter_overeager_cloned::check(cx, expr, recv, recv2, iter_overeager_cloned::Op::NeedlessMove(name, arg), false),
+                        Some(("chars", recv, _, _, _)) if let ExprKind::Closure(arg) = arg.kind
+                        && let body = cx.tcx.hir().body(arg.body)
+                        && let [param] = body.params => {
+                            string_lit_chars_any::check(cx, expr, recv, param, peel_blocks(body.value), &self.msrv);
+                        }
+                        _ => {}
+                    }
                 }
                 ("arg", [arg]) => {
                     suspicious_command_arg_space::check(cx, recv, arg, span);
diff --git a/tests/ui/iter_overeager_cloned.fixed b/tests/ui/iter_overeager_cloned.fixed
index 9dd046fec1f..7d8a584b022 100644
--- a/tests/ui/iter_overeager_cloned.fixed
+++ b/tests/ui/iter_overeager_cloned.fixed
@@ -63,11 +63,9 @@ fn main() {
 
     let _ = vec.iter().for_each(|x| assert!(!x.is_empty()));
 
-    // Not implemented yet
-    let _ = vec.iter().cloned().all(|x| x.len() == 1);
+    let _ = vec.iter().all(|x| x.len() == 1);
 
-    // Not implemented yet
-    let _ = vec.iter().cloned().any(|x| x.len() == 1);
+    let _ = vec.iter().any(|x| x.len() == 1);
 
     // Should probably stay as it is.
     let _ = [0, 1, 2, 3, 4].iter().cloned().take(10);
diff --git a/tests/ui/iter_overeager_cloned.rs b/tests/ui/iter_overeager_cloned.rs
index 3cab3669554..58c374ab8cd 100644
--- a/tests/ui/iter_overeager_cloned.rs
+++ b/tests/ui/iter_overeager_cloned.rs
@@ -64,10 +64,8 @@ fn main() {
 
     let _ = vec.iter().cloned().for_each(|x| assert!(!x.is_empty()));
 
-    // Not implemented yet
     let _ = vec.iter().cloned().all(|x| x.len() == 1);
 
-    // Not implemented yet
     let _ = vec.iter().cloned().any(|x| x.len() == 1);
 
     // Should probably stay as it is.
diff --git a/tests/ui/iter_overeager_cloned.stderr b/tests/ui/iter_overeager_cloned.stderr
index 4417a40a63b..1f4c9040f77 100644
--- a/tests/ui/iter_overeager_cloned.stderr
+++ b/tests/ui/iter_overeager_cloned.stderr
@@ -146,5 +146,21 @@ LL |     let _ = vec.iter().cloned().for_each(|x| assert!(!x.is_empty()));
    |                       |
    |                       help: try: `.for_each(|x| assert!(!x.is_empty()))`
 
-error: aborting due to 17 previous errors
+error: unneeded cloning of iterator items
+  --> $DIR/iter_overeager_cloned.rs:67:13
+   |
+LL |     let _ = vec.iter().cloned().all(|x| x.len() == 1);
+   |             ^^^^^^^^^^-------------------------------
+   |                       |
+   |                       help: try: `.all(|x| x.len() == 1)`
+
+error: unneeded cloning of iterator items
+  --> $DIR/iter_overeager_cloned.rs:69:13
+   |
+LL |     let _ = vec.iter().cloned().any(|x| x.len() == 1);
+   |             ^^^^^^^^^^-------------------------------
+   |                       |
+   |                       help: try: `.any(|x| x.len() == 1)`
+
+error: aborting due to 19 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 2faa43c8b455bd66a0d93f9af5beac4fb7698234 Mon Sep 17 00:00:00 2001
From: Caio <c410.f3r@gmail.com>
Date: Thu, 24 Aug 2023 13:22:27 -0300
Subject: [arithmetic_side_effects] Fix #11393

---
 .../src/operators/arithmetic_side_effects.rs       | 55 +++++++++++++++++++---
 tests/ui/arithmetic_side_effects.rs                | 30 +++++++++++-
 tests/ui/arithmetic_side_effects.stderr            | 14 +++++-
 3 files changed, 90 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/operators/arithmetic_side_effects.rs b/clippy_lints/src/operators/arithmetic_side_effects.rs
index f9108145cdb..377b56fadaa 100644
--- a/clippy_lints/src/operators/arithmetic_side_effects.rs
+++ b/clippy_lints/src/operators/arithmetic_side_effects.rs
@@ -1,22 +1,18 @@
 use super::ARITHMETIC_SIDE_EFFECTS;
 use clippy_utils::consts::{constant, constant_simple, Constant};
 use clippy_utils::diagnostics::span_lint;
+use clippy_utils::ty::{match_type, type_diagnostic_name};
 use clippy_utils::{expr_or_init, is_from_proc_macro, is_lint_allowed, peel_hir_expr_refs, peel_hir_expr_unary};
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::Ty;
 use rustc_session::impl_lint_pass;
 use rustc_span::source_map::{Span, Spanned};
+use rustc_span::symbol::sym;
 use rustc_span::Symbol;
 use {rustc_ast as ast, rustc_hir as hir};
 
-const HARD_CODED_ALLOWED_BINARY: &[[&str; 2]] = &[
-    ["f32", "f32"],
-    ["f64", "f64"],
-    ["std::num::Saturating", "*"],
-    ["std::num::Wrapping", "*"],
-    ["std::string::String", "str"],
-];
+const HARD_CODED_ALLOWED_BINARY: &[[&str; 2]] = &[["f32", "f32"], ["f64", "f64"], ["std::string::String", "str"]];
 const HARD_CODED_ALLOWED_UNARY: &[&str] = &["f32", "f64", "std::num::Saturating", "std::num::Wrapping"];
 const INTEGER_METHODS: &[&str] = &["saturating_div", "wrapping_div", "wrapping_rem", "wrapping_rem_euclid"];
 
@@ -86,6 +82,48 @@ impl ArithmeticSideEffects {
         self.allowed_unary.contains(ty_string_elem)
     }
 
+    /// Verifies built-in types that have specific allowed operations
+    fn has_specific_allowed_type_and_operation(
+        cx: &LateContext<'_>,
+        lhs_ty: Ty<'_>,
+        op: &Spanned<hir::BinOpKind>,
+        rhs_ty: Ty<'_>,
+    ) -> bool {
+        const SATURATING: &[&str] = &["core", "num", "saturating", "Saturating"];
+        const WRAPPING: &[&str] = &["core", "num", "wrapping", "Wrapping"];
+        let is_non_zero = |symbol: Option<Symbol>| {
+            matches!(
+                symbol,
+                Some(
+                    sym::NonZeroI128
+                        | sym::NonZeroI16
+                        | sym::NonZeroI32
+                        | sym::NonZeroI64
+                        | sym::NonZeroI8
+                        | sym::NonZeroU128
+                        | sym::NonZeroU16
+                        | sym::NonZeroU32
+                        | sym::NonZeroU64
+                        | sym::NonZeroU8
+                )
+            )
+        };
+        // If the RHS is NonZero*, then division or module by zero will never occur
+        if is_non_zero(type_diagnostic_name(cx, rhs_ty)) && let hir::BinOpKind::Div | hir::BinOpKind::Rem = op.node {
+            return true;
+        }
+        // For `Saturation` or `Wrapping` (RHS), all but division and module are allowed.
+        let is_div_or_rem = matches!(op.node, hir::BinOpKind::Div | hir::BinOpKind::Rem);
+        if (match_type(cx, rhs_ty, SATURATING) || match_type(cx, rhs_ty, WRAPPING)) && !is_div_or_rem {
+            return true;
+        }
+        // For `Saturation` or `Wrapping` (LHS), everything is allowed
+        if match_type(cx, lhs_ty, SATURATING) || match_type(cx, lhs_ty, WRAPPING) {
+            return true;
+        }
+        return false;
+    }
+
     // For example, 8i32 or &i64::MAX.
     fn is_integral(ty: Ty<'_>) -> bool {
         ty.peel_refs().is_integral()
@@ -147,6 +185,9 @@ impl ArithmeticSideEffects {
         if self.has_allowed_binary(lhs_ty, rhs_ty) {
             return;
         }
+        if Self::has_specific_allowed_type_and_operation(cx, lhs_ty, op, rhs_ty) {
+            return;
+        }
         let has_valid_op = if Self::is_integral(lhs_ty) && Self::is_integral(rhs_ty) {
             if let hir::BinOpKind::Shl | hir::BinOpKind::Shr = op.node {
                 // At least for integers, shifts are already handled by the CTFE
diff --git a/tests/ui/arithmetic_side_effects.rs b/tests/ui/arithmetic_side_effects.rs
index 8485b3eab71..def30f5903d 100644
--- a/tests/ui/arithmetic_side_effects.rs
+++ b/tests/ui/arithmetic_side_effects.rs
@@ -15,7 +15,7 @@
 
 extern crate proc_macro_derive;
 
-use core::num::{Saturating, Wrapping};
+use core::num::{NonZeroUsize, Saturating, Wrapping};
 
 const ONE: i32 = 1;
 const ZERO: i32 = 0;
@@ -493,4 +493,32 @@ pub fn issue_11262() {
     let _ = 2 / zero;
 }
 
+pub fn issue_11392() {
+    fn example_div(unsigned: usize, nonzero_unsigned: NonZeroUsize) -> usize {
+        unsigned / nonzero_unsigned
+    }
+
+    fn example_rem(unsigned: usize, nonzero_unsigned: NonZeroUsize) -> usize {
+        unsigned % nonzero_unsigned
+    }
+
+    let (unsigned, nonzero_unsigned) = (0, NonZeroUsize::new(1).unwrap());
+    example_div(unsigned, nonzero_unsigned);
+    example_rem(unsigned, nonzero_unsigned);
+}
+
+pub fn issue_11393() {
+    fn example_div(x: Wrapping<i32>, maybe_zero: Wrapping<i32>) -> Wrapping<i32> {
+        x / maybe_zero
+    }
+
+    fn example_rem(x: Wrapping<i32>, maybe_zero: Wrapping<i32>) -> Wrapping<i32> {
+        x % maybe_zero
+    }
+
+    let [x, maybe_zero] = [1, 0].map(Wrapping);
+    example_div(x, maybe_zero);
+    example_rem(x, maybe_zero);
+}
+
 fn main() {}
diff --git a/tests/ui/arithmetic_side_effects.stderr b/tests/ui/arithmetic_side_effects.stderr
index e9a626643ff..af6b5521cc4 100644
--- a/tests/ui/arithmetic_side_effects.stderr
+++ b/tests/ui/arithmetic_side_effects.stderr
@@ -702,5 +702,17 @@ error: arithmetic operation that can potentially result in unexpected side-effec
 LL |     10 / a
    |     ^^^^^^
 
-error: aborting due to 117 previous errors
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:498:9
+   |
+LL |         unsigned / nonzero_unsigned
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: arithmetic operation that can potentially result in unexpected side-effects
+  --> $DIR/arithmetic_side_effects.rs:502:9
+   |
+LL |         unsigned % nonzero_unsigned
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 119 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From d802ab28de8c7e8095fd00fe6cec48ed809ad3b3 Mon Sep 17 00:00:00 2001
From: Caio <c410.f3r@gmail.com>
Date: Thu, 24 Aug 2023 13:34:36 -0300
Subject: Dogfood

---
 clippy_lints/src/operators/arithmetic_side_effects.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/operators/arithmetic_side_effects.rs b/clippy_lints/src/operators/arithmetic_side_effects.rs
index 377b56fadaa..edd18b86b5d 100644
--- a/clippy_lints/src/operators/arithmetic_side_effects.rs
+++ b/clippy_lints/src/operators/arithmetic_side_effects.rs
@@ -121,7 +121,7 @@ impl ArithmeticSideEffects {
         if match_type(cx, lhs_ty, SATURATING) || match_type(cx, lhs_ty, WRAPPING) {
             return true;
         }
-        return false;
+        false
     }
 
     // For example, 8i32 or &i64::MAX.
-- 
cgit 1.4.1-3-g733a5


From 86b66443797bfa89dbc099722c20c9c2c5943217 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Thu, 24 Aug 2023 20:12:03 +0200
Subject: new lint: `iter_out_of_bounds`

---
 CHANGELOG.md                                   |  1 +
 clippy_lints/src/declared_lints.rs             |  1 +
 clippy_lints/src/methods/iter_out_of_bounds.rs | 91 ++++++++++++++++++++++++++
 clippy_lints/src/methods/mod.rs                | 32 ++++++++-
 clippy_utils/src/paths.rs                      |  2 +
 tests/ui/iter_out_of_bounds.rs                 | 44 +++++++++++++
 tests/ui/iter_out_of_bounds.stderr             | 71 ++++++++++++++++++++
 tests/ui/iter_skip_zero.fixed                  |  2 +-
 tests/ui/iter_skip_zero.rs                     |  2 +-
 9 files changed, 242 insertions(+), 4 deletions(-)
 create mode 100644 clippy_lints/src/methods/iter_out_of_bounds.rs
 create mode 100644 tests/ui/iter_out_of_bounds.rs
 create mode 100644 tests/ui/iter_out_of_bounds.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 4e33cb7b457..43633b36925 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5030,6 +5030,7 @@ Released 2018-09-13
 [`iter_nth_zero`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_nth_zero
 [`iter_on_empty_collections`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_on_empty_collections
 [`iter_on_single_items`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_on_single_items
+[`iter_out_of_bounds`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_out_of_bounds
 [`iter_overeager_cloned`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_overeager_cloned
 [`iter_skip_next`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_skip_next
 [`iter_skip_zero`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_skip_zero
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 1be9720fbbf..10cb8201306 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -364,6 +364,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::methods::ITER_NTH_ZERO_INFO,
     crate::methods::ITER_ON_EMPTY_COLLECTIONS_INFO,
     crate::methods::ITER_ON_SINGLE_ITEMS_INFO,
+    crate::methods::ITER_OUT_OF_BOUNDS_INFO,
     crate::methods::ITER_OVEREAGER_CLONED_INFO,
     crate::methods::ITER_SKIP_NEXT_INFO,
     crate::methods::ITER_SKIP_ZERO_INFO,
diff --git a/clippy_lints/src/methods/iter_out_of_bounds.rs b/clippy_lints/src/methods/iter_out_of_bounds.rs
new file mode 100644
index 00000000000..0a94700ae8e
--- /dev/null
+++ b/clippy_lints/src/methods/iter_out_of_bounds.rs
@@ -0,0 +1,91 @@
+use clippy_utils::diagnostics::span_lint_and_note;
+use clippy_utils::{is_trait_method, match_def_path, paths};
+use rustc_ast::LitKind;
+use rustc_hir::{Expr, ExprKind};
+use rustc_lint::LateContext;
+use rustc_middle::ty::{self};
+use rustc_span::sym;
+
+use super::ITER_OUT_OF_BOUNDS;
+
+/// Attempts to extract the length out of an iterator expression.
+fn get_iterator_length<'tcx>(cx: &LateContext<'tcx>, iter: &'tcx Expr<'tcx>) -> Option<u128> {
+    let iter_ty = cx.typeck_results().expr_ty(iter);
+
+    if let ty::Adt(adt, substs) = iter_ty.kind() {
+        let did = adt.did();
+
+        if match_def_path(cx, did, &paths::ARRAY_INTO_ITER) {
+            // For array::IntoIter<T, const N: usize>, the length is the second generic
+            // parameter.
+            substs
+                .const_at(1)
+                .try_eval_target_usize(cx.tcx, cx.param_env)
+                .map(u128::from)
+        } else if match_def_path(cx, did, &paths::SLICE_ITER)
+            && let ExprKind::MethodCall(_, recv, ..) = iter.kind
+            && let ExprKind::Array(array) = recv.peel_borrows().kind
+        {
+            // For slice::Iter<'_, T>, the receiver might be an array literal: [1,2,3].iter().skip(..)
+            array.len().try_into().ok()
+        } else if match_def_path(cx, did, &paths::ITER_EMPTY) {
+            Some(0)
+        } else if match_def_path(cx, did, &paths::ITER_ONCE) {
+            Some(1)
+        } else {
+            None
+        }
+    } else {
+        None
+    }
+}
+
+fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx Expr<'tcx>,
+    recv: &'tcx Expr<'tcx>,
+    arg: &'tcx Expr<'tcx>,
+    message: &'static str,
+    note: &'static str,
+) {
+    if is_trait_method(cx, expr, sym::Iterator)
+        && let Some(len) = get_iterator_length(cx, recv)
+        && let ExprKind::Lit(lit) = arg.kind
+        && let LitKind::Int(skip, _) = lit.node
+        && skip > len
+    {
+        span_lint_and_note(cx, ITER_OUT_OF_BOUNDS, expr.span, message, None, note);
+    }
+}
+
+pub(super) fn check_skip<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx Expr<'tcx>,
+    recv: &'tcx Expr<'tcx>,
+    arg: &'tcx Expr<'tcx>,
+) {
+    check(
+        cx,
+        expr,
+        recv,
+        arg,
+        "this `.skip()` call skips more items than the iterator will produce",
+        "this operation is useless and will create an empty iterator",
+    );
+}
+
+pub(super) fn check_take<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx Expr<'tcx>,
+    recv: &'tcx Expr<'tcx>,
+    arg: &'tcx Expr<'tcx>,
+) {
+    check(
+        cx,
+        expr,
+        recv,
+        arg,
+        "this `.take()` call takes more items than the iterator will produce",
+        "this operation is useless and the returned iterator will simply yield the same items",
+    );
+}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 5075137caa0..5dbbd7f9618 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -43,6 +43,7 @@ mod iter_next_slice;
 mod iter_nth;
 mod iter_nth_zero;
 mod iter_on_single_or_empty_collections;
+mod iter_out_of_bounds;
 mod iter_overeager_cloned;
 mod iter_skip_next;
 mod iter_skip_zero;
@@ -3538,6 +3539,30 @@ declare_clippy_lint! {
     "acquiring a write lock when a read lock would work"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Looks for iterator combinator calls such as `.take(x)` or `.skip(x)`
+    /// where `x` is greater than the amount of items that an iterator will produce.
+    ///
+    /// ### Why is this bad?
+    /// Taking or skipping more items than there are in an iterator either creates an iterator
+    /// with all items from the original iterator or an iterator with no items at all.
+    /// This is most likely not what the user intended to do.
+    ///
+    /// ### Example
+    /// ```rust
+    /// for _ in [1, 2, 3].iter().take(4) {}
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// for _ in [1, 2, 3].iter() {}
+    /// ```
+    #[clippy::version = "1.73.0"]
+    pub ITER_OUT_OF_BOUNDS,
+    suspicious,
+    "calls to `.take()` or `.skip()` that are out of bounds"
+}
+
 pub struct Methods {
     avoid_breaking_exported_api: bool,
     msrv: Msrv,
@@ -3676,7 +3701,8 @@ impl_lint_pass!(Methods => [
     STRING_LIT_CHARS_ANY,
     ITER_SKIP_ZERO,
     FILTER_MAP_BOOL_THEN,
-    READONLY_WRITE_LOCK
+    READONLY_WRITE_LOCK,
+    ITER_OUT_OF_BOUNDS,
 ]);
 
 /// Extracts a method call name, args, and `Span` of the method name.
@@ -4136,6 +4162,7 @@ impl Methods {
                 },
                 ("skip", [arg]) => {
                     iter_skip_zero::check(cx, expr, arg);
+                    iter_out_of_bounds::check_skip(cx, expr, recv, arg);
 
                     if let Some(("cloned", recv2, [], _span2, _)) = method_call(recv) {
                         iter_overeager_cloned::check(cx, expr, recv, recv2,
@@ -4163,7 +4190,8 @@ impl Methods {
                     }
                 },
                 ("step_by", [arg]) => iterator_step_by_zero::check(cx, expr, arg),
-                ("take", [_arg]) => {
+                ("take", [arg]) => {
+                    iter_out_of_bounds::check_take(cx, expr, recv, arg);
                     if let Some(("cloned", recv2, [], _span2, _)) = method_call(recv) {
                         iter_overeager_cloned::check(cx, expr, recv, recv2,
                                 iter_overeager_cloned::Op::LaterCloned, false);
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index e72d063cfd9..61022ea0651 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -49,6 +49,7 @@ pub const IDENT: [&str; 3] = ["rustc_span", "symbol", "Ident"];
 pub const IDENT_AS_STR: [&str; 4] = ["rustc_span", "symbol", "Ident", "as_str"];
 pub const INSERT_STR: [&str; 4] = ["alloc", "string", "String", "insert_str"];
 pub const ITER_EMPTY: [&str; 5] = ["core", "iter", "sources", "empty", "Empty"];
+pub const ITER_ONCE: [&str; 5] = ["core", "iter", "sources", "once", "Once"];
 pub const ITERTOOLS_NEXT_TUPLE: [&str; 3] = ["itertools", "Itertools", "next_tuple"];
 #[cfg(feature = "internal")]
 pub const KW_MODULE: [&str; 3] = ["rustc_span", "symbol", "kw"];
@@ -166,3 +167,4 @@ pub const DEBUG_STRUCT: [&str; 4] = ["core", "fmt", "builders", "DebugStruct"];
 pub const ORD_CMP: [&str; 4] = ["core", "cmp", "Ord", "cmp"];
 #[expect(clippy::invalid_paths)] // not sure why it thinks this, it works so
 pub const BOOL_THEN: [&str; 4] = ["core", "bool", "<impl bool>", "then"];
+pub const ARRAY_INTO_ITER: [&str; 4] = ["core", "array", "iter", "IntoIter"];
diff --git a/tests/ui/iter_out_of_bounds.rs b/tests/ui/iter_out_of_bounds.rs
new file mode 100644
index 00000000000..07908f929cd
--- /dev/null
+++ b/tests/ui/iter_out_of_bounds.rs
@@ -0,0 +1,44 @@
+#![deny(clippy::iter_out_of_bounds)]
+
+fn opaque_empty_iter() -> impl Iterator<Item = ()> {
+    std::iter::empty()
+}
+
+fn main() {
+    for _ in [1, 2, 3].iter().skip(4) {
+        //~^ ERROR: this `.skip()` call skips more items than the iterator will produce
+        unreachable!();
+    }
+    for (i, _) in [1, 2, 3].iter().take(4).enumerate() {
+        //~^ ERROR: this `.take()` call takes more items than the iterator will produce
+        assert!(i <= 2);
+    }
+
+    #[allow(clippy::needless_borrow)]
+    for _ in (&&&&&&[1, 2, 3]).iter().take(4) {}
+    //~^ ERROR: this `.take()` call takes more items than the iterator will produce
+
+    for _ in [1, 2, 3].iter().skip(4) {}
+    //~^ ERROR: this `.skip()` call skips more items than the iterator will produce
+
+    // Should not lint
+    for _ in opaque_empty_iter().skip(1) {}
+
+    // Should not lint
+    let empty: [i8; 0] = [];
+    for _ in empty.iter().skip(1) {}
+
+    let empty = std::iter::empty::<i8>;
+
+    for _ in empty().skip(1) {}
+    //~^ ERROR: this `.skip()` call skips more items than the iterator will produce
+
+    for _ in empty().take(1) {}
+    //~^ ERROR: this `.take()` call takes more items than the iterator will produce
+
+    for _ in std::iter::once(1).skip(2) {}
+    //~^ ERROR: this `.skip()` call skips more items than the iterator will produce
+
+    for _ in std::iter::once(1).take(2) {}
+    //~^ ERROR: this `.take()` call takes more items than the iterator will produce
+}
diff --git a/tests/ui/iter_out_of_bounds.stderr b/tests/ui/iter_out_of_bounds.stderr
new file mode 100644
index 00000000000..c819ca3771f
--- /dev/null
+++ b/tests/ui/iter_out_of_bounds.stderr
@@ -0,0 +1,71 @@
+error: this `.skip()` call skips more items than the iterator will produce
+  --> $DIR/iter_out_of_bounds.rs:8:14
+   |
+LL |     for _ in [1, 2, 3].iter().skip(4) {
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: this operation is useless and will create an empty iterator
+note: the lint level is defined here
+  --> $DIR/iter_out_of_bounds.rs:1:9
+   |
+LL | #![deny(clippy::iter_out_of_bounds)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: this `.take()` call takes more items than the iterator will produce
+  --> $DIR/iter_out_of_bounds.rs:12:19
+   |
+LL |     for (i, _) in [1, 2, 3].iter().take(4).enumerate() {
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: this operation is useless and the returned iterator will simply yield the same items
+
+error: this `.take()` call takes more items than the iterator will produce
+  --> $DIR/iter_out_of_bounds.rs:18:14
+   |
+LL |     for _ in (&&&&&&[1, 2, 3]).iter().take(4) {}
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: this operation is useless and the returned iterator will simply yield the same items
+
+error: this `.skip()` call skips more items than the iterator will produce
+  --> $DIR/iter_out_of_bounds.rs:21:14
+   |
+LL |     for _ in [1, 2, 3].iter().skip(4) {}
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: this operation is useless and will create an empty iterator
+
+error: this `.skip()` call skips more items than the iterator will produce
+  --> $DIR/iter_out_of_bounds.rs:33:14
+   |
+LL |     for _ in empty().skip(1) {}
+   |              ^^^^^^^^^^^^^^^
+   |
+   = note: this operation is useless and will create an empty iterator
+
+error: this `.take()` call takes more items than the iterator will produce
+  --> $DIR/iter_out_of_bounds.rs:36:14
+   |
+LL |     for _ in empty().take(1) {}
+   |              ^^^^^^^^^^^^^^^
+   |
+   = note: this operation is useless and the returned iterator will simply yield the same items
+
+error: this `.skip()` call skips more items than the iterator will produce
+  --> $DIR/iter_out_of_bounds.rs:39:14
+   |
+LL |     for _ in std::iter::once(1).skip(2) {}
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: this operation is useless and will create an empty iterator
+
+error: this `.take()` call takes more items than the iterator will produce
+  --> $DIR/iter_out_of_bounds.rs:42:14
+   |
+LL |     for _ in std::iter::once(1).take(2) {}
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: this operation is useless and the returned iterator will simply yield the same items
+
+error: aborting due to 8 previous errors
+
diff --git a/tests/ui/iter_skip_zero.fixed b/tests/ui/iter_skip_zero.fixed
index 62a83d5905b..447d07100e9 100644
--- a/tests/ui/iter_skip_zero.fixed
+++ b/tests/ui/iter_skip_zero.fixed
@@ -1,5 +1,5 @@
 //@aux-build:proc_macros.rs
-#![allow(clippy::useless_vec, unused)]
+#![allow(clippy::useless_vec, clippy::iter_out_of_bounds, unused)]
 #![warn(clippy::iter_skip_zero)]
 
 #[macro_use]
diff --git a/tests/ui/iter_skip_zero.rs b/tests/ui/iter_skip_zero.rs
index c96696dde65..ba63c398180 100644
--- a/tests/ui/iter_skip_zero.rs
+++ b/tests/ui/iter_skip_zero.rs
@@ -1,5 +1,5 @@
 //@aux-build:proc_macros.rs
-#![allow(clippy::useless_vec, unused)]
+#![allow(clippy::useless_vec, clippy::iter_out_of_bounds, unused)]
 #![warn(clippy::iter_skip_zero)]
 
 #[macro_use]
-- 
cgit 1.4.1-3-g733a5


From e1ec41b2179e89a657bae77c6a4ed15da65ad040 Mon Sep 17 00:00:00 2001
From: Philipp Krones <hello@philkrones.com>
Date: Thu, 24 Aug 2023 21:06:18 +0200
Subject: Fix dogfood issues

---
 clippy_lints/src/casts/cast_ptr_alignment.rs |  6 ++++--
 clippy_lints/src/ptr.rs                      | 25 +++++++++++++++++++------
 clippy_utils/src/paths.rs                    |  3 ---
 3 files changed, 23 insertions(+), 11 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/cast_ptr_alignment.rs b/clippy_lints/src/casts/cast_ptr_alignment.rs
index 5bf467efa0f..1de69122101 100644
--- a/clippy_lints/src/casts/cast_ptr_alignment.rs
+++ b/clippy_lints/src/casts/cast_ptr_alignment.rs
@@ -5,6 +5,7 @@ use rustc_hir::{Expr, ExprKind, GenericArg};
 use rustc_lint::LateContext;
 use rustc_middle::ty::layout::LayoutOf;
 use rustc_middle::ty::{self, Ty};
+use rustc_span::sym;
 
 use super::CAST_PTR_ALIGNMENT;
 
@@ -76,13 +77,14 @@ fn is_used_as_unaligned(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
         ExprKind::Call(func, [arg, ..]) if arg.hir_id == e.hir_id => {
             static PATHS: &[&[&str]] = &[
                 paths::PTR_READ_UNALIGNED.as_slice(),
-                paths::PTR_WRITE_UNALIGNED.as_slice(),
                 paths::PTR_UNALIGNED_VOLATILE_LOAD.as_slice(),
                 paths::PTR_UNALIGNED_VOLATILE_STORE.as_slice(),
             ];
+
             if let ExprKind::Path(path) = &func.kind
                 && let Some(def_id) = cx.qpath_res(path, func.hir_id).opt_def_id()
-                && match_any_def_paths(cx, def_id, PATHS).is_some()
+                && (match_any_def_paths(cx, def_id, PATHS).is_some()
+                    || cx.tcx.is_diagnostic_item(sym::ptr_write_unaligned, def_id))
             {
                 true
             } else {
diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs
index 8009b00b4b9..bf031ac8454 100644
--- a/clippy_lints/src/ptr.rs
+++ b/clippy_lints/src/ptr.rs
@@ -278,7 +278,7 @@ impl<'tcx> LateLintPass<'tcx> for Ptr {
 
 fn check_invalid_ptr_usage<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
     // (fn_path, arg_indices) - `arg_indices` are the `arg` positions where null would cause U.B.
-    const INVALID_NULL_PTR_USAGE_TABLE: [(&[&str], &[usize]); 16] = [
+    const INVALID_NULL_PTR_USAGE_TABLE: [(&[&str], &[usize]); 13] = [
         (&paths::SLICE_FROM_RAW_PARTS, &[0]),
         (&paths::SLICE_FROM_RAW_PARTS_MUT, &[0]),
         (&paths::PTR_COPY, &[0, 1]),
@@ -291,20 +291,33 @@ fn check_invalid_ptr_usage<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         (&paths::PTR_SLICE_FROM_RAW_PARTS_MUT, &[0]),
         (&paths::PTR_SWAP, &[0, 1]),
         (&paths::PTR_SWAP_NONOVERLAPPING, &[0, 1]),
-        (&paths::PTR_WRITE, &[0]),
-        (&paths::PTR_WRITE_UNALIGNED, &[0]),
-        (&paths::PTR_WRITE_VOLATILE, &[0]),
         (&paths::PTR_WRITE_BYTES, &[0]),
     ];
+    let invalid_null_ptr_usage_table_diag_items: [(Option<DefId>, &[usize]); 3] = [
+        (cx.tcx.get_diagnostic_item(sym::ptr_write), &[0]),
+        (cx.tcx.get_diagnostic_item(sym::ptr_write_unaligned), &[0]),
+        (cx.tcx.get_diagnostic_item(sym::ptr_write_volatile), &[0]),
+    ];
 
     if_chain! {
         if let ExprKind::Call(fun, args) = expr.kind;
         if let ExprKind::Path(ref qpath) = fun.kind;
         if let Some(fun_def_id) = cx.qpath_res(qpath, fun.hir_id).opt_def_id();
         let fun_def_path = cx.get_def_path(fun_def_id).into_iter().map(Symbol::to_ident_string).collect::<Vec<_>>();
-        if let Some(&(_, arg_indices)) = INVALID_NULL_PTR_USAGE_TABLE
+        if let Some(arg_indices) = INVALID_NULL_PTR_USAGE_TABLE
             .iter()
-            .find(|&&(fn_path, _)| fn_path == fun_def_path);
+            .find_map(|&(fn_path, indices)| if fn_path == fun_def_path { Some(indices) } else { None })
+            .or_else(|| {
+                invalid_null_ptr_usage_table_diag_items
+                    .iter()
+                    .find_map(|&(def_id, indices)| {
+                        if def_id == Some(fun_def_id) {
+                            Some(indices)
+                        } else {
+                            None
+                        }
+                    })
+            });
         then {
             for &arg_idx in arg_indices {
                 if let Some(arg) = args.get(arg_idx).filter(|arg| is_null_path(cx, arg)) {
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index e72d063cfd9..a567c5cbdc9 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -87,10 +87,7 @@ pub const PTR_REPLACE: [&str; 3] = ["core", "ptr", "replace"];
 pub const PTR_SWAP: [&str; 3] = ["core", "ptr", "swap"];
 pub const PTR_UNALIGNED_VOLATILE_LOAD: [&str; 3] = ["core", "intrinsics", "unaligned_volatile_load"];
 pub const PTR_UNALIGNED_VOLATILE_STORE: [&str; 3] = ["core", "intrinsics", "unaligned_volatile_store"];
-pub const PTR_WRITE: [&str; 3] = ["core", "ptr", "write"];
 pub const PTR_WRITE_BYTES: [&str; 3] = ["core", "intrinsics", "write_bytes"];
-pub const PTR_WRITE_UNALIGNED: [&str; 3] = ["core", "ptr", "write_unaligned"];
-pub const PTR_WRITE_VOLATILE: [&str; 3] = ["core", "ptr", "write_volatile"];
 pub const PUSH_STR: [&str; 4] = ["alloc", "string", "String", "push_str"];
 pub const RANGE_ARGUMENT_TRAIT: [&str; 3] = ["core", "ops", "RangeBounds"];
 pub const REFCELL_REF: [&str; 3] = ["core", "cell", "Ref"];
-- 
cgit 1.4.1-3-g733a5


From dba7763128356f684f31a0a1aff25ac3e9646818 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Thu, 24 Aug 2023 23:44:17 +0200
Subject: [`if_then_some_else_none`]: look into local initializers

---
 clippy_lints/src/if_then_some_else_none.rs | 18 ++----------------
 clippy_utils/src/lib.rs                    |  3 ++-
 tests/ui/if_then_some_else_none.rs         | 12 ++++++++++++
 3 files changed, 16 insertions(+), 17 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/if_then_some_else_none.rs b/clippy_lints/src/if_then_some_else_none.rs
index ab6ad3f3b3a..e2d19e24557 100644
--- a/clippy_lints/src/if_then_some_else_none.rs
+++ b/clippy_lints/src/if_then_some_else_none.rs
@@ -6,7 +6,7 @@ use clippy_utils::sugg::Sugg;
 use clippy_utils::{contains_return, higher, is_else_clause, is_res_lang_ctor, path_res, peel_blocks};
 use rustc_errors::Applicability;
 use rustc_hir::LangItem::{OptionNone, OptionSome};
-use rustc_hir::{Expr, ExprKind, Stmt, StmtKind};
+use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
@@ -83,7 +83,7 @@ impl<'tcx> LateLintPass<'tcx> for IfThenSomeElseNone {
             && then_expr.span.ctxt() == ctxt
             && is_res_lang_ctor(cx, path_res(cx, then_call), OptionSome)
             && is_res_lang_ctor(cx, path_res(cx, peel_blocks(els)), OptionNone)
-            && !stmts_contains_early_return(then_block.stmts)
+            && !contains_return(then_block.stmts)
         {
             let mut app = Applicability::Unspecified;
             let cond_snip = Sugg::hir_with_context(cx, cond, expr.span.ctxt(), "[condition]", &mut app).maybe_par().to_string();
@@ -116,17 +116,3 @@ impl<'tcx> LateLintPass<'tcx> for IfThenSomeElseNone {
 
     extract_msrv_attr!(LateContext);
 }
-
-fn stmts_contains_early_return(stmts: &[Stmt<'_>]) -> bool {
-    stmts.iter().any(|stmt| {
-        let Stmt {
-            kind: StmtKind::Semi(e),
-            ..
-        } = stmt
-        else {
-            return false;
-        };
-
-        contains_return(e)
-    })
-}
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 171b7faf219..5bfccaeb600 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -110,6 +110,7 @@ use rustc_span::source_map::SourceMap;
 use rustc_span::symbol::{kw, Ident, Symbol};
 use rustc_span::{sym, Span};
 use rustc_target::abi::Integer;
+use visitors::Visitable;
 
 use crate::consts::{constant, miri_to_const, Constant};
 use crate::higher::Range;
@@ -1286,7 +1287,7 @@ pub fn contains_name<'tcx>(name: Symbol, expr: &'tcx Expr<'_>, cx: &LateContext<
 }
 
 /// Returns `true` if `expr` contains a return expression
-pub fn contains_return(expr: &hir::Expr<'_>) -> bool {
+pub fn contains_return<'tcx>(expr: impl Visitable<'tcx>) -> bool {
     for_each_expr(expr, |e| {
         if matches!(e.kind, hir::ExprKind::Ret(..)) {
             ControlFlow::Break(())
diff --git a/tests/ui/if_then_some_else_none.rs b/tests/ui/if_then_some_else_none.rs
index 8fa0f34a6c4..77abd663e0a 100644
--- a/tests/ui/if_then_some_else_none.rs
+++ b/tests/ui/if_then_some_else_none.rs
@@ -117,3 +117,15 @@ fn f(b: bool, v: Option<()>) -> Option<()> {
         None
     }
 }
+
+fn issue11394(b: bool, v: Result<(), ()>) -> Result<(), ()> {
+    let x = if b {
+        #[allow(clippy::let_unit_value)]
+        let _ = v?;
+        Some(())
+    } else {
+        None
+    };
+
+    Ok(())
+}
-- 
cgit 1.4.1-3-g733a5


From 11072b51fa2b8fbcf68f8cf6a5f4140b19c16241 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Fri, 25 Aug 2023 01:13:35 +0200
Subject: lint vecs, version bump, more tests

---
 clippy_lints/src/methods/iter_out_of_bounds.rs | 65 ++++++++++++++++----------
 clippy_lints/src/methods/mod.rs                |  2 +-
 tests/ui/iter_out_of_bounds.rs                 | 22 +++++++--
 tests/ui/iter_out_of_bounds.stderr             | 58 +++++++++++++++++++----
 tests/ui/iter_skip_next.fixed                  |  1 +
 tests/ui/iter_skip_next.rs                     |  1 +
 tests/ui/iter_skip_next.stderr                 | 14 +++---
 tests/ui/iter_skip_next_unfixable.rs           |  2 +-
 8 files changed, 119 insertions(+), 46 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/iter_out_of_bounds.rs b/clippy_lints/src/methods/iter_out_of_bounds.rs
index 0a94700ae8e..79c6d63254b 100644
--- a/clippy_lints/src/methods/iter_out_of_bounds.rs
+++ b/clippy_lints/src/methods/iter_out_of_bounds.rs
@@ -1,5 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_note;
-use clippy_utils::{is_trait_method, match_def_path, paths};
+use clippy_utils::higher::VecArgs;
+use clippy_utils::{expr_or_init, is_trait_method, match_def_path, paths};
 use rustc_ast::LitKind;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::LateContext;
@@ -8,34 +9,49 @@ use rustc_span::sym;
 
 use super::ITER_OUT_OF_BOUNDS;
 
+fn expr_as_u128(cx: &LateContext<'_>, e: &Expr<'_>) -> Option<u128> {
+    if let ExprKind::Lit(lit) = expr_or_init(cx, e).kind
+        && let LitKind::Int(n, _) = lit.node
+    {
+        Some(n)
+    } else {
+        None
+    }
+}
+
 /// Attempts to extract the length out of an iterator expression.
 fn get_iterator_length<'tcx>(cx: &LateContext<'tcx>, iter: &'tcx Expr<'tcx>) -> Option<u128> {
-    let iter_ty = cx.typeck_results().expr_ty(iter);
-
-    if let ty::Adt(adt, substs) = iter_ty.kind() {
-        let did = adt.did();
+    let ty::Adt(adt, substs) = cx.typeck_results().expr_ty(iter).kind() else {
+        return None;
+    };
+    let did = adt.did();
 
-        if match_def_path(cx, did, &paths::ARRAY_INTO_ITER) {
-            // For array::IntoIter<T, const N: usize>, the length is the second generic
-            // parameter.
-            substs
-                .const_at(1)
-                .try_eval_target_usize(cx.tcx, cx.param_env)
-                .map(u128::from)
-        } else if match_def_path(cx, did, &paths::SLICE_ITER)
-            && let ExprKind::MethodCall(_, recv, ..) = iter.kind
-            && let ExprKind::Array(array) = recv.peel_borrows().kind
-        {
+    if match_def_path(cx, did, &paths::ARRAY_INTO_ITER) {
+        // For array::IntoIter<T, const N: usize>, the length is the second generic
+        // parameter.
+        substs
+            .const_at(1)
+            .try_eval_target_usize(cx.tcx, cx.param_env)
+            .map(u128::from)
+    } else if match_def_path(cx, did, &paths::SLICE_ITER)
+        && let ExprKind::MethodCall(_, recv, ..) = iter.kind
+    {
+        if let ty::Array(_, len) = cx.typeck_results().expr_ty(recv).peel_refs().kind() {
             // For slice::Iter<'_, T>, the receiver might be an array literal: [1,2,3].iter().skip(..)
-            array.len().try_into().ok()
-        } else if match_def_path(cx, did, &paths::ITER_EMPTY) {
-            Some(0)
-        } else if match_def_path(cx, did, &paths::ITER_ONCE) {
-            Some(1)
+            len.try_eval_target_usize(cx.tcx, cx.param_env).map(u128::from)
+        } else if let Some(args) = VecArgs::hir(cx, expr_or_init(cx, recv)) {
+            match args {
+                VecArgs::Vec(vec) => vec.len().try_into().ok(),
+                VecArgs::Repeat(_, len) => expr_as_u128(cx, len),
+            }
         } else {
             None
         }
-    } else {
+    } else if match_def_path(cx, did, &paths::ITER_EMPTY) {
+        Some(0)
+    } else if match_def_path(cx, did, &paths::ITER_ONCE) {
+        Some(1)
+    }  else {
         None
     }
 }
@@ -50,9 +66,8 @@ fn check<'tcx>(
 ) {
     if is_trait_method(cx, expr, sym::Iterator)
         && let Some(len) = get_iterator_length(cx, recv)
-        && let ExprKind::Lit(lit) = arg.kind
-        && let LitKind::Int(skip, _) = lit.node
-        && skip > len
+        && let Some(skipped) = expr_as_u128(cx, arg)
+        && skipped > len
     {
         span_lint_and_note(cx, ITER_OUT_OF_BOUNDS, expr.span, message, None, note);
     }
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 5dbbd7f9618..76beb9380a9 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3557,7 +3557,7 @@ declare_clippy_lint! {
     /// ```rust
     /// for _ in [1, 2, 3].iter() {}
     /// ```
-    #[clippy::version = "1.73.0"]
+    #[clippy::version = "1.74.0"]
     pub ITER_OUT_OF_BOUNDS,
     suspicious,
     "calls to `.take()` or `.skip()` that are out of bounds"
diff --git a/tests/ui/iter_out_of_bounds.rs b/tests/ui/iter_out_of_bounds.rs
index 07908f929cd..a2c17b452d6 100644
--- a/tests/ui/iter_out_of_bounds.rs
+++ b/tests/ui/iter_out_of_bounds.rs
@@ -1,4 +1,7 @@
+//@no-rustfix
+
 #![deny(clippy::iter_out_of_bounds)]
+#![allow(clippy::useless_vec)]
 
 fn opaque_empty_iter() -> impl Iterator<Item = ()> {
     std::iter::empty()
@@ -21,12 +24,25 @@ fn main() {
     for _ in [1, 2, 3].iter().skip(4) {}
     //~^ ERROR: this `.skip()` call skips more items than the iterator will produce
 
+    for _ in [1; 3].iter().skip(4) {}
+    //~^ ERROR: this `.skip()` call skips more items than the iterator will produce
+
     // Should not lint
     for _ in opaque_empty_iter().skip(1) {}
 
-    // Should not lint
-    let empty: [i8; 0] = [];
-    for _ in empty.iter().skip(1) {}
+    for _ in vec![1, 2, 3].iter().skip(4) {}
+    //~^ ERROR: this `.skip()` call skips more items than the iterator will produce
+
+    for _ in vec![1; 3].iter().skip(4) {}
+    //~^ ERROR: this `.skip()` call skips more items than the iterator will produce
+
+    let x = [1, 2, 3];
+    for _ in x.iter().skip(4) {}
+    //~^ ERROR: this `.skip()` call skips more items than the iterator will produce
+
+    let n = 4;
+    for _ in x.iter().skip(n) {}
+    //~^ ERROR: this `.skip()` call skips more items than the iterator will produce
 
     let empty = std::iter::empty::<i8>;
 
diff --git a/tests/ui/iter_out_of_bounds.stderr b/tests/ui/iter_out_of_bounds.stderr
index c819ca3771f..d4b7b4355d0 100644
--- a/tests/ui/iter_out_of_bounds.stderr
+++ b/tests/ui/iter_out_of_bounds.stderr
@@ -1,18 +1,18 @@
 error: this `.skip()` call skips more items than the iterator will produce
-  --> $DIR/iter_out_of_bounds.rs:8:14
+  --> $DIR/iter_out_of_bounds.rs:11:14
    |
 LL |     for _ in [1, 2, 3].iter().skip(4) {
    |              ^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: this operation is useless and will create an empty iterator
 note: the lint level is defined here
-  --> $DIR/iter_out_of_bounds.rs:1:9
+  --> $DIR/iter_out_of_bounds.rs:3:9
    |
 LL | #![deny(clippy::iter_out_of_bounds)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this `.take()` call takes more items than the iterator will produce
-  --> $DIR/iter_out_of_bounds.rs:12:19
+  --> $DIR/iter_out_of_bounds.rs:15:19
    |
 LL |     for (i, _) in [1, 2, 3].iter().take(4).enumerate() {
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -20,7 +20,7 @@ LL |     for (i, _) in [1, 2, 3].iter().take(4).enumerate() {
    = note: this operation is useless and the returned iterator will simply yield the same items
 
 error: this `.take()` call takes more items than the iterator will produce
-  --> $DIR/iter_out_of_bounds.rs:18:14
+  --> $DIR/iter_out_of_bounds.rs:21:14
    |
 LL |     for _ in (&&&&&&[1, 2, 3]).iter().take(4) {}
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -28,23 +28,63 @@ LL |     for _ in (&&&&&&[1, 2, 3]).iter().take(4) {}
    = note: this operation is useless and the returned iterator will simply yield the same items
 
 error: this `.skip()` call skips more items than the iterator will produce
-  --> $DIR/iter_out_of_bounds.rs:21:14
+  --> $DIR/iter_out_of_bounds.rs:24:14
    |
 LL |     for _ in [1, 2, 3].iter().skip(4) {}
    |              ^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: this operation is useless and will create an empty iterator
 
+error: this `.skip()` call skips more items than the iterator will produce
+  --> $DIR/iter_out_of_bounds.rs:27:14
+   |
+LL |     for _ in [1; 3].iter().skip(4) {}
+   |              ^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: this operation is useless and will create an empty iterator
+
 error: this `.skip()` call skips more items than the iterator will produce
   --> $DIR/iter_out_of_bounds.rs:33:14
    |
+LL |     for _ in vec![1, 2, 3].iter().skip(4) {}
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: this operation is useless and will create an empty iterator
+
+error: this `.skip()` call skips more items than the iterator will produce
+  --> $DIR/iter_out_of_bounds.rs:36:14
+   |
+LL |     for _ in vec![1; 3].iter().skip(4) {}
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: this operation is useless and will create an empty iterator
+
+error: this `.skip()` call skips more items than the iterator will produce
+  --> $DIR/iter_out_of_bounds.rs:40:14
+   |
+LL |     for _ in x.iter().skip(4) {}
+   |              ^^^^^^^^^^^^^^^^
+   |
+   = note: this operation is useless and will create an empty iterator
+
+error: this `.skip()` call skips more items than the iterator will produce
+  --> $DIR/iter_out_of_bounds.rs:44:14
+   |
+LL |     for _ in x.iter().skip(n) {}
+   |              ^^^^^^^^^^^^^^^^
+   |
+   = note: this operation is useless and will create an empty iterator
+
+error: this `.skip()` call skips more items than the iterator will produce
+  --> $DIR/iter_out_of_bounds.rs:49:14
+   |
 LL |     for _ in empty().skip(1) {}
    |              ^^^^^^^^^^^^^^^
    |
    = note: this operation is useless and will create an empty iterator
 
 error: this `.take()` call takes more items than the iterator will produce
-  --> $DIR/iter_out_of_bounds.rs:36:14
+  --> $DIR/iter_out_of_bounds.rs:52:14
    |
 LL |     for _ in empty().take(1) {}
    |              ^^^^^^^^^^^^^^^
@@ -52,7 +92,7 @@ LL |     for _ in empty().take(1) {}
    = note: this operation is useless and the returned iterator will simply yield the same items
 
 error: this `.skip()` call skips more items than the iterator will produce
-  --> $DIR/iter_out_of_bounds.rs:39:14
+  --> $DIR/iter_out_of_bounds.rs:55:14
    |
 LL |     for _ in std::iter::once(1).skip(2) {}
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -60,12 +100,12 @@ LL |     for _ in std::iter::once(1).skip(2) {}
    = note: this operation is useless and will create an empty iterator
 
 error: this `.take()` call takes more items than the iterator will produce
-  --> $DIR/iter_out_of_bounds.rs:42:14
+  --> $DIR/iter_out_of_bounds.rs:58:14
    |
 LL |     for _ in std::iter::once(1).take(2) {}
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: this operation is useless and the returned iterator will simply yield the same items
 
-error: aborting due to 8 previous errors
+error: aborting due to 13 previous errors
 
diff --git a/tests/ui/iter_skip_next.fixed b/tests/ui/iter_skip_next.fixed
index 310b24a9cde..3e41b363249 100644
--- a/tests/ui/iter_skip_next.fixed
+++ b/tests/ui/iter_skip_next.fixed
@@ -4,6 +4,7 @@
 #![allow(clippy::disallowed_names)]
 #![allow(clippy::iter_nth)]
 #![allow(clippy::useless_vec)]
+#![allow(clippy::iter_out_of_bounds)]
 #![allow(unused_mut, dead_code)]
 
 extern crate option_helpers;
diff --git a/tests/ui/iter_skip_next.rs b/tests/ui/iter_skip_next.rs
index 222d6a2a184..6d96441ca96 100644
--- a/tests/ui/iter_skip_next.rs
+++ b/tests/ui/iter_skip_next.rs
@@ -4,6 +4,7 @@
 #![allow(clippy::disallowed_names)]
 #![allow(clippy::iter_nth)]
 #![allow(clippy::useless_vec)]
+#![allow(clippy::iter_out_of_bounds)]
 #![allow(unused_mut, dead_code)]
 
 extern crate option_helpers;
diff --git a/tests/ui/iter_skip_next.stderr b/tests/ui/iter_skip_next.stderr
index ca6970b27f1..4ee26e088ce 100644
--- a/tests/ui/iter_skip_next.stderr
+++ b/tests/ui/iter_skip_next.stderr
@@ -1,5 +1,5 @@
 error: called `skip(..).next()` on an iterator
-  --> $DIR/iter_skip_next.rs:16:28
+  --> $DIR/iter_skip_next.rs:17:28
    |
 LL |     let _ = some_vec.iter().skip(42).next();
    |                            ^^^^^^^^^^^^^^^^ help: use `nth` instead: `.nth(42)`
@@ -7,37 +7,37 @@ LL |     let _ = some_vec.iter().skip(42).next();
    = note: `-D clippy::iter-skip-next` implied by `-D warnings`
 
 error: called `skip(..).next()` on an iterator
-  --> $DIR/iter_skip_next.rs:17:36
+  --> $DIR/iter_skip_next.rs:18:36
    |
 LL |     let _ = some_vec.iter().cycle().skip(42).next();
    |                                    ^^^^^^^^^^^^^^^^ help: use `nth` instead: `.nth(42)`
 
 error: called `skip(..).next()` on an iterator
-  --> $DIR/iter_skip_next.rs:18:20
+  --> $DIR/iter_skip_next.rs:19:20
    |
 LL |     let _ = (1..10).skip(10).next();
    |                    ^^^^^^^^^^^^^^^^ help: use `nth` instead: `.nth(10)`
 
 error: called `skip(..).next()` on an iterator
-  --> $DIR/iter_skip_next.rs:19:33
+  --> $DIR/iter_skip_next.rs:20:33
    |
 LL |     let _ = &some_vec[..].iter().skip(3).next();
    |                                 ^^^^^^^^^^^^^^^ help: use `nth` instead: `.nth(3)`
 
 error: called `skip(..).next()` on an iterator
-  --> $DIR/iter_skip_next.rs:27:26
+  --> $DIR/iter_skip_next.rs:28:26
    |
 LL |     let _: Vec<&str> = sp.skip(1).next().unwrap().split(' ').collect();
    |                          ^^^^^^^^^^^^^^^ help: use `nth` instead: `.nth(1)`
 
 error: called `skip(..).next()` on an iterator
-  --> $DIR/iter_skip_next.rs:29:29
+  --> $DIR/iter_skip_next.rs:30:29
    |
 LL |         let _: Vec<&str> = s.skip(1).next().unwrap().split(' ').collect();
    |                             ^^^^^^^^^^^^^^^ help: use `nth` instead: `.nth(1)`
 
 error: called `skip(..).next()` on an iterator
-  --> $DIR/iter_skip_next.rs:35:29
+  --> $DIR/iter_skip_next.rs:36:29
    |
 LL |         let _: Vec<&str> = s.skip(1).next().unwrap().split(' ').collect();
    |                             ^^^^^^^^^^^^^^^ help: use `nth` instead: `.nth(1)`
diff --git a/tests/ui/iter_skip_next_unfixable.rs b/tests/ui/iter_skip_next_unfixable.rs
index 9c224f4117d..6c98bdc8c88 100644
--- a/tests/ui/iter_skip_next_unfixable.rs
+++ b/tests/ui/iter_skip_next_unfixable.rs
@@ -1,5 +1,5 @@
 #![warn(clippy::iter_skip_next)]
-#![allow(dead_code)]
+#![allow(dead_code, clippy::iter_out_of_bounds)]
 //@no-rustfix
 /// Checks implementation of `ITER_SKIP_NEXT` lint
 fn main() {
-- 
cgit 1.4.1-3-g733a5


From 6eec4a3720de954edb18985e6bdcb4a734dbeb0c Mon Sep 17 00:00:00 2001
From: J-ZhengLi <lizheng135@huawei.com>
Date: Fri, 25 Aug 2023 15:01:31 +0800
Subject: remove unecessary code and narrow search span when const/static items
 are in a mod block

---
 clippy_lints/src/undocumented_unsafe_blocks.rs | 36 +++++++++++---------------
 1 file changed, 15 insertions(+), 21 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/undocumented_unsafe_blocks.rs b/clippy_lints/src/undocumented_unsafe_blocks.rs
index 4ee817c0676..7649ce7fafb 100644
--- a/clippy_lints/src/undocumented_unsafe_blocks.rs
+++ b/clippy_lints/src/undocumented_unsafe_blocks.rs
@@ -618,29 +618,23 @@ fn get_body_search_span(cx: &LateContext<'_>) -> Option<Span> {
     let mut maybe_global_var = false;
     for (_, node) in map.parent_iter(body.hir_id) {
         match node {
-            Node::Expr(e) => {
-                span = e.span;
-                // Note: setting this to `false` is to making sure a "in-function defined"
-                // const/static variable not mistakenly processed as global variable,
-                // since global var doesn't have an `Expr` parent as its parent???
-                maybe_global_var = false;
-            }
-            Node::Block(_)
-            | Node::Arm(_)
-            | Node::Stmt(_)
-            | Node::Local(_) => (),
-            Node::Item(hir::Item { kind, span: item_span, .. }) => {
-                if matches!(kind, hir::ItemKind::Const(..) | ItemKind::Static(..)) {
-                    maybe_global_var = true;
-                } else if maybe_global_var && let hir::ItemKind::Mod(_) = kind {
-                    span = *item_span;
-                } else {
-                    break;
-                }
-            }
+            Node::Expr(e) => span = e.span,
+            Node::Block(_) | Node::Arm(_) | Node::Stmt(_) | Node::Local(_) => (),
+            Node::Item(hir::Item {
+                kind: hir::ItemKind::Const(..) | ItemKind::Static(..),
+                ..
+            }) => maybe_global_var = true,
+            Node::Item(hir::Item {
+                kind: hir::ItemKind::Mod(_),
+                span: item_span,
+                ..
+            }) => {
+                span = *item_span;
+                break;
+            },
             Node::Crate(mod_) if maybe_global_var => {
                 span = mod_.spans.inner_span;
-            }
+            },
             _ => break,
         }
     }
-- 
cgit 1.4.1-3-g733a5


From 90fcc67d32afd73d28aaf965e152dbe478ea9024 Mon Sep 17 00:00:00 2001
From: mojave2 <chenchen145@huawei.com>
Date: Fri, 25 Aug 2023 19:15:44 +0800
Subject: fix "derivable_impls: attributes are ignored"

---
 clippy_lints/src/derivable_impls.rs |  3 +--
 tests/ui/derivable_impls.fixed      | 13 +++++++++++++
 tests/ui/derivable_impls.rs         | 13 +++++++++++++
 3 files changed, 27 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/derivable_impls.rs b/clippy_lints/src/derivable_impls.rs
index 9a85cc4ce2d..d2bfc4f8e27 100644
--- a/clippy_lints/src/derivable_impls.rs
+++ b/clippy_lints/src/derivable_impls.rs
@@ -217,8 +217,7 @@ impl<'tcx> LateLintPass<'tcx> for DerivableImpls {
             if let &Adt(adt_def, args) = cx.tcx.type_of(item.owner_id).instantiate_identity().kind();
             if let attrs = cx.tcx.hir().attrs(item.hir_id());
             if !attrs.iter().any(|attr| attr.doc_str().is_some());
-            if let child_attrs = cx.tcx.hir().attrs(impl_item_hir);
-            if !child_attrs.iter().any(|attr| attr.doc_str().is_some());
+            if cx.tcx.hir().attrs(impl_item_hir).is_empty();
 
             then {
                 if adt_def.is_struct() {
diff --git a/tests/ui/derivable_impls.fixed b/tests/ui/derivable_impls.fixed
index 6cc202414f5..68c5a5c5ca4 100644
--- a/tests/ui/derivable_impls.fixed
+++ b/tests/ui/derivable_impls.fixed
@@ -287,4 +287,17 @@ mod issue10158 {
     }
 }
 
+mod issue11368 {
+    pub struct A {
+        a: u32,
+    }
+
+    impl Default for A {
+        #[track_caller]
+        fn default() -> Self {
+            Self { a: 0 }
+        }
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/derivable_impls.rs b/tests/ui/derivable_impls.rs
index 0aa9acd752d..21d73ba8b77 100644
--- a/tests/ui/derivable_impls.rs
+++ b/tests/ui/derivable_impls.rs
@@ -323,4 +323,17 @@ mod issue10158 {
     }
 }
 
+mod issue11368 {
+    pub struct A {
+        a: u32,
+    }
+
+    impl Default for A {
+        #[track_caller]
+        fn default() -> Self {
+            Self { a: 0 }
+        }
+    }
+}
+
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From e43c23416832d61d906512c73c205823f1b6eea5 Mon Sep 17 00:00:00 2001
From: Meng Huang <agile.text8909@fastmail.com>
Date: Wed, 23 Aug 2023 19:58:59 +0800
Subject: allow float_cmp when lhs is a custom type

---
 clippy_lints/src/operators/float_cmp.rs |  2 +-
 tests/ui/float_cmp.rs                   | 13 +++++++++++++
 tests/ui/float_cmp.stderr               | 12 ++++++------
 3 files changed, 20 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/operators/float_cmp.rs b/clippy_lints/src/operators/float_cmp.rs
index f3e0c58a787..bce6bdcaf61 100644
--- a/clippy_lints/src/operators/float_cmp.rs
+++ b/clippy_lints/src/operators/float_cmp.rs
@@ -17,7 +17,7 @@ pub(crate) fn check<'tcx>(
     left: &'tcx Expr<'_>,
     right: &'tcx Expr<'_>,
 ) {
-    if (op == BinOpKind::Eq || op == BinOpKind::Ne) && (is_float(cx, left) || is_float(cx, right)) {
+    if (op == BinOpKind::Eq || op == BinOpKind::Ne) && is_float(cx, left) {
         let left_is_local = match constant_with_source(cx, cx.typeck_results(), left) {
             Some((c, s)) if !is_allowed(&c) => s.is_local(),
             Some(_) => return,
diff --git a/tests/ui/float_cmp.rs b/tests/ui/float_cmp.rs
index a547a67430f..5057c643732 100644
--- a/tests/ui/float_cmp.rs
+++ b/tests/ui/float_cmp.rs
@@ -41,6 +41,16 @@ impl PartialEq for X {
     }
 }
 
+impl PartialEq<f32> for X {
+    fn eq(&self, o: &f32) -> bool {
+        if self.val.is_nan() {
+            o.is_nan()
+        } else {
+            self.val == *o // no error, inside "eq" fn
+        }
+    }
+}
+
 fn main() {
     ZERO == 0f32; //no error, comparison with zero is ok
     1.0f32 != f32::INFINITY; // also comparison with infinity
@@ -48,6 +58,9 @@ fn main() {
     ZERO == 0.0; //no error, comparison with zero is ok
     ZERO + ZERO != 1.0; //no error, comparison with zero is ok
 
+    let x = X { val: 1.0 };
+    x == 1.0; // no error, custom type that implement PartialOrder for float is not checked
+
     ONE == 1f32;
     ONE == 1.0 + 0.0;
     ONE + ONE == ZERO + ONE + ONE;
diff --git a/tests/ui/float_cmp.stderr b/tests/ui/float_cmp.stderr
index 5836b5603d6..a84dc1226fb 100644
--- a/tests/ui/float_cmp.stderr
+++ b/tests/ui/float_cmp.stderr
@@ -1,5 +1,5 @@
 error: strict comparison of `f32` or `f64`
-  --> $DIR/float_cmp.rs:57:5
+  --> $DIR/float_cmp.rs:70:5
    |
 LL |     ONE as f64 != 2.0;
    |     ^^^^^^^^^^^^^^^^^ help: consider comparing them within some margin of error: `(ONE as f64 - 2.0).abs() > error_margin`
@@ -8,7 +8,7 @@ LL |     ONE as f64 != 2.0;
    = note: `-D clippy::float-cmp` implied by `-D warnings`
 
 error: strict comparison of `f32` or `f64`
-  --> $DIR/float_cmp.rs:64:5
+  --> $DIR/float_cmp.rs:77:5
    |
 LL |     x == 1.0;
    |     ^^^^^^^^ help: consider comparing them within some margin of error: `(x - 1.0).abs() < error_margin`
@@ -16,7 +16,7 @@ LL |     x == 1.0;
    = note: `f32::EPSILON` and `f64::EPSILON` are available for the `error_margin`
 
 error: strict comparison of `f32` or `f64`
-  --> $DIR/float_cmp.rs:69:5
+  --> $DIR/float_cmp.rs:82:5
    |
 LL |     twice(x) != twice(ONE as f64);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider comparing them within some margin of error: `(twice(x) - twice(ONE as f64)).abs() > error_margin`
@@ -24,7 +24,7 @@ LL |     twice(x) != twice(ONE as f64);
    = note: `f32::EPSILON` and `f64::EPSILON` are available for the `error_margin`
 
 error: strict comparison of `f32` or `f64`
-  --> $DIR/float_cmp.rs:91:5
+  --> $DIR/float_cmp.rs:104:5
    |
 LL |     NON_ZERO_ARRAY[i] == NON_ZERO_ARRAY[j];
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider comparing them within some margin of error: `(NON_ZERO_ARRAY[i] - NON_ZERO_ARRAY[j]).abs() < error_margin`
@@ -32,7 +32,7 @@ LL |     NON_ZERO_ARRAY[i] == NON_ZERO_ARRAY[j];
    = note: `f32::EPSILON` and `f64::EPSILON` are available for the `error_margin`
 
 error: strict comparison of `f32` or `f64` arrays
-  --> $DIR/float_cmp.rs:98:5
+  --> $DIR/float_cmp.rs:111:5
    |
 LL |     a1 == a2;
    |     ^^^^^^^^
@@ -40,7 +40,7 @@ LL |     a1 == a2;
    = note: `f32::EPSILON` and `f64::EPSILON` are available for the `error_margin`
 
 error: strict comparison of `f32` or `f64`
-  --> $DIR/float_cmp.rs:101:5
+  --> $DIR/float_cmp.rs:114:5
    |
 LL |     a1[0] == a2[0];
    |     ^^^^^^^^^^^^^^ help: consider comparing them within some margin of error: `(a1[0] - a2[0]).abs() < error_margin`
-- 
cgit 1.4.1-3-g733a5


From f80c55deb58424e19de1a43c7a4d7a9ab70030c9 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Sat, 26 Aug 2023 01:10:32 +0200
Subject: add a test for statics and doc comments

---
 clippy_lints/src/unwrap.rs                     | 17 +++++++++++++++--
 tests/ui/checked_unwrap/simple_conditionals.rs | 11 +++++++++++
 2 files changed, 26 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unwrap.rs b/clippy_lints/src/unwrap.rs
index fc97ab8fbe1..9a0d83d83f1 100644
--- a/clippy_lints/src/unwrap.rs
+++ b/clippy_lints/src/unwrap.rs
@@ -196,13 +196,25 @@ fn collect_unwrap_info<'tcx>(
 }
 
 /// A HIR visitor delegate that checks if a local variable of type `Option<_>` is mutated,
-/// unless `Option::as_mut` is called.
+/// *except* for if `Option::as_mut` is called.
+/// The reason for why we allow that one specifically is that `.as_mut()` cannot change
+/// the option to `None`, and that is important because this lint relies on the fact that
+/// `is_some` + `unwrap` is equivalent to `if let Some(..) = ..`, which it would not be if
+/// the option is changed to None between `is_some` and `unwrap`.
+/// (And also `.as_mut()` is a somewhat common method that is still worth linting on.)
 struct MutationVisitor<'tcx> {
     is_mutated: bool,
     local_id: HirId,
     tcx: TyCtxt<'tcx>,
 }
 
+/// Checks if the parent of the expression pointed at by the given `HirId` is a call to
+/// `Option::as_mut`.
+///
+/// Used by the mutation visitor to specifically allow `.as_mut()` calls.
+/// In particular, the `HirId` that the visitor receives is the id of the local expression
+/// (i.e. the `x` in `x.as_mut()`), and that is the reason for why we care about its parent
+/// expression: that will be where the actual method call is.
 fn is_option_as_mut_use(tcx: TyCtxt<'_>, expr_id: HirId) -> bool {
     if let Node::Expr(mutating_expr) = tcx.hir().get_parent(expr_id)
         && let ExprKind::MethodCall(path, ..) = mutating_expr.kind
@@ -260,7 +272,8 @@ impl<'a, 'tcx> UnwrappableVariablesVisitor<'a, 'tcx> {
             vis.walk_expr(branch);
 
             if delegate.is_mutated {
-                // if the variable is mutated, we don't know whether it can be unwrapped:
+                // if the variable is mutated, we don't know whether it can be unwrapped.
+                // it might have been changed to `None` in between `is_some` + `unwrap`.
                 continue;
             }
             self.unwrappables.push(unwrap_info);
diff --git a/tests/ui/checked_unwrap/simple_conditionals.rs b/tests/ui/checked_unwrap/simple_conditionals.rs
index feeef9393be..02f80cc52ac 100644
--- a/tests/ui/checked_unwrap/simple_conditionals.rs
+++ b/tests/ui/checked_unwrap/simple_conditionals.rs
@@ -166,6 +166,17 @@ fn issue11371() {
         result.as_mut().unwrap();
         //~^ ERROR: this call to `unwrap()` will always panic
     }
+
+    // This should not lint. Statics are, at the time of writing, not linted on anyway,
+    // but if at some point they are supported by this lint, it should correctly see that
+    // `X` is being mutated and not suggest `if let Some(..) = X {}`
+    static mut X: Option<i32> = Some(123);
+    unsafe {
+        if X.is_some() {
+            X = None;
+            X.unwrap();
+        }
+    }
 }
 
 fn check_expect() {
-- 
cgit 1.4.1-3-g733a5


From 7ff87163e0630a314af5a3cd091f8fe0616bcc96 Mon Sep 17 00:00:00 2001
From: Samuel Moelius <35515885+smoelius@users.noreply.github.com>
Date: Fri, 25 Aug 2023 19:50:51 -0400
Subject: Typo

---
 clippy_lints/src/doc.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/doc.rs b/clippy_lints/src/doc.rs
index e29ab634c97..093abdb3e40 100644
--- a/clippy_lints/src/doc.rs
+++ b/clippy_lints/src/doc.rs
@@ -508,7 +508,7 @@ struct DocHeaders {
 
 fn check_attrs(cx: &LateContext<'_>, valid_idents: &FxHashSet<String>, attrs: &[Attribute]) -> Option<DocHeaders> {
     /// We don't want the parser to choke on intra doc links. Since we don't
-    /// actually care about rendering them, just pretend that all broken links are
+    /// actually care about rendering them, just pretend that all broken links
     /// point to a fake address.
     #[expect(clippy::unnecessary_wraps)] // we're following a type signature
     fn fake_broken_link_callback<'a>(_: BrokenLink<'_>) -> Option<(CowStr<'a>, CowStr<'a>)> {
-- 
cgit 1.4.1-3-g733a5


From 1c77b0b2677f04f535137cdf582c98a281309a1b Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Sun, 27 Aug 2023 11:43:45 +0000
Subject: Move needless_raw_string_hashes to pedantic

---
 clippy_lints/src/raw_strings.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/raw_strings.rs b/clippy_lints/src/raw_strings.rs
index ccabb577cb7..edd4d961b0c 100644
--- a/clippy_lints/src/raw_strings.rs
+++ b/clippy_lints/src/raw_strings.rs
@@ -49,7 +49,7 @@ declare_clippy_lint! {
     /// ```
     #[clippy::version = "1.72.0"]
     pub NEEDLESS_RAW_STRING_HASHES,
-    style,
+    pedantic,
     "suggests reducing the number of hashes around a raw string literal"
 }
 impl_lint_pass!(RawStrings => [NEEDLESS_RAW_STRINGS, NEEDLESS_RAW_STRING_HASHES]);
-- 
cgit 1.4.1-3-g733a5


From be55a96d802e919ec91a3264bb5fa5b6d211da65 Mon Sep 17 00:00:00 2001
From: Ben Schofield <me@benjscho.dev>
Date: Sun, 27 Aug 2023 21:45:14 -0600
Subject: Add config flag for reborrows in explicit_iter_loop

This commit adds a config flag for enforcing explicit into iter lint
for reborrowed values. The config flag, enforce_iter_loop_reborrow, can be
added to clippy.toml files to enable the linting behaviour. By default
the lint is not enabled.
---
 clippy_lints/src/lib.rs                            |  3 +-
 clippy_lints/src/loops/explicit_iter_loop.rs       | 17 ++++--
 clippy_lints/src/loops/mod.rs                      | 10 +++-
 clippy_lints/src/utils/conf.rs                     | 20 +++++++
 .../toml_unknown_key/conf_unknown_key.stderr       |  2 +
 tests/ui/explicit_iter_loop.fixed                  |  7 ++-
 tests/ui/explicit_iter_loop.rs                     |  1 +
 tests/ui/explicit_iter_loop.stderr                 | 64 +++++++---------------
 8 files changed, 68 insertions(+), 56 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index ab71bfbdc58..f3559771a57 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -695,7 +695,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     });
     store.register_late_pass(|_| Box::<shadow::Shadow>::default());
     store.register_late_pass(|_| Box::new(unit_types::UnitTypes));
-    store.register_late_pass(move |_| Box::new(loops::Loops::new(msrv())));
+    let enforce_iter_loop_reborrow = conf.enforce_iter_loop_reborrow;
+    store.register_late_pass(move |_| Box::new(loops::Loops::new(msrv(), enforce_iter_loop_reborrow)));
     store.register_late_pass(|_| Box::<main_recursion::MainRecursion>::default());
     store.register_late_pass(|_| Box::new(lifetimes::Lifetimes));
     store.register_late_pass(|_| Box::new(entry::HashMapPass));
diff --git a/clippy_lints/src/loops/explicit_iter_loop.rs b/clippy_lints/src/loops/explicit_iter_loop.rs
index 7b8c88235a9..6ab256ef001 100644
--- a/clippy_lints/src/loops/explicit_iter_loop.rs
+++ b/clippy_lints/src/loops/explicit_iter_loop.rs
@@ -13,8 +13,14 @@ use rustc_middle::ty::adjustment::{Adjust, Adjustment, AutoBorrow, AutoBorrowMut
 use rustc_middle::ty::{self, EarlyBinder, Ty, TypeAndMut};
 use rustc_span::sym;
 
-pub(super) fn check(cx: &LateContext<'_>, self_arg: &Expr<'_>, call_expr: &Expr<'_>, msrv: &Msrv) {
-    let Some((adjust, ty)) = is_ref_iterable(cx, self_arg, call_expr) else {
+pub(super) fn check(
+    cx: &LateContext<'_>,
+    self_arg: &Expr<'_>,
+    call_expr: &Expr<'_>,
+    msrv: &Msrv,
+    enforce_iter_loop_reborrow: bool,
+) {
+    let Some((adjust, ty)) = is_ref_iterable(cx, self_arg, call_expr, enforce_iter_loop_reborrow) else {
         return;
     };
     if let ty::Array(_, count) = *ty.peel_refs().kind() {
@@ -102,6 +108,7 @@ fn is_ref_iterable<'tcx>(
     cx: &LateContext<'tcx>,
     self_arg: &Expr<'_>,
     call_expr: &Expr<'_>,
+    enforce_iter_loop_reborrow: bool,
 ) -> Option<(AdjustKind, Ty<'tcx>)> {
     let typeck = cx.typeck_results();
     if let Some(trait_id) = cx.tcx.get_diagnostic_item(sym::IntoIterator)
@@ -142,7 +149,8 @@ fn is_ref_iterable<'tcx>(
                 {
                     return Some((AdjustKind::None, self_ty));
                 }
-            } else if let ty::Ref(region, ty, Mutability::Mut) = *self_ty.kind()
+            } else if enforce_iter_loop_reborrow
+                && let ty::Ref(region, ty, Mutability::Mut) = *self_ty.kind()
                 && let Some(mutbl) = mutbl
             {
                 // Attempt to reborrow the mutable reference
@@ -186,7 +194,8 @@ fn is_ref_iterable<'tcx>(
                 },
                 ..
             ] => {
-                if target != self_ty
+                if enforce_iter_loop_reborrow
+                    && target != self_ty
                     && implements_trait(cx, target, trait_id, &[])
                     && let Some(ty) =
                         make_normalized_projection(cx.tcx, cx.param_env, trait_id, sym!(IntoIter), [target])
diff --git a/clippy_lints/src/loops/mod.rs b/clippy_lints/src/loops/mod.rs
index ffd29ab7630..1fb16adad7a 100644
--- a/clippy_lints/src/loops/mod.rs
+++ b/clippy_lints/src/loops/mod.rs
@@ -609,10 +609,14 @@ declare_clippy_lint! {
 
 pub struct Loops {
     msrv: Msrv,
+    enforce_iter_loop_reborrow: bool,
 }
 impl Loops {
-    pub fn new(msrv: Msrv) -> Self {
-        Self { msrv }
+    pub fn new(msrv: Msrv, enforce_iter_loop_reborrow: bool) -> Self {
+        Self {
+            msrv,
+            enforce_iter_loop_reborrow,
+        }
     }
 }
 impl_lint_pass!(Loops => [
@@ -719,7 +723,7 @@ impl Loops {
         if let ExprKind::MethodCall(method, self_arg, [], _) = arg.kind {
             match method.ident.as_str() {
                 "iter" | "iter_mut" => {
-                    explicit_iter_loop::check(cx, self_arg, arg, &self.msrv);
+                    explicit_iter_loop::check(cx, self_arg, arg, &self.msrv, self.enforce_iter_loop_reborrow);
                 },
                 "into_iter" => {
                     explicit_into_iter_loop::check(cx, self_arg, arg);
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 58ae0656db7..26889475522 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -561,6 +561,26 @@ define_Conf! {
     /// Which crates to allow absolute paths from
     (absolute_paths_allowed_crates: rustc_data_structures::fx::FxHashSet<String> =
         rustc_data_structures::fx::FxHashSet::default()),
+    /// Lint: EXPLICIT_ITER_LOOP
+    ///
+    /// Whether to recommend using implicit into iter for reborrowed values.
+    ///
+    /// #### Example
+    /// ```
+    /// let mut vec = vec![1, 2, 3];
+    /// let rmvec = &mut vec;
+    /// for _ in rmvec.iter() {}
+    /// for _ in rmvec.iter_mut() {}
+    /// ```
+    ///
+    /// Use instead:
+    /// ```
+    /// let mut vec = vec![1, 2, 3];
+    /// let rmvec = &mut vec;
+    /// for _ in &*rmvec {}
+    /// for _ in &mut *rmvec {}
+    /// ```
+    (enforce_iter_loop_reborrow: bool = false),
 }
 
 /// Search for the configuration file.
diff --git a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
index cdabe6460cd..b97bb144468 100644
--- a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
+++ b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
@@ -28,6 +28,7 @@ error: error reading Clippy's configuration file: unknown field `foobar`, expect
            disallowed-types
            doc-valid-idents
            enable-raw-pointer-heuristic-for-send
+           enforce-iter-loop-reborrow
            enforced-import-renames
            enum-variant-name-threshold
            enum-variant-size-threshold
@@ -99,6 +100,7 @@ error: error reading Clippy's configuration file: unknown field `barfoo`, expect
            disallowed-types
            doc-valid-idents
            enable-raw-pointer-heuristic-for-send
+           enforce-iter-loop-reborrow
            enforced-import-renames
            enum-variant-name-threshold
            enum-variant-size-threshold
diff --git a/tests/ui/explicit_iter_loop.fixed b/tests/ui/explicit_iter_loop.fixed
index 57292114e38..f08397defa5 100644
--- a/tests/ui/explicit_iter_loop.fixed
+++ b/tests/ui/explicit_iter_loop.fixed
@@ -4,6 +4,7 @@
     clippy::similar_names,
     clippy::needless_borrow,
     clippy::deref_addrof,
+    clippy::unnecessary_mut_passed,
     dead_code
 )]
 
@@ -20,15 +21,15 @@ fn main() {
     for _ in rvec {}
 
     let rmvec = &mut vec;
-    for _ in &*rmvec {}
-    for _ in &mut *rmvec {}
+    for _ in rmvec.iter() {}
+    for _ in rmvec.iter_mut() {}
 
     for _ in &vec {} // these are fine
     for _ in &mut vec {} // these are fine
 
     for _ in &[1, 2, 3] {}
 
-    for _ in &*(&mut [1, 2, 3]) {}
+    for _ in (&mut [1, 2, 3]).iter() {}
 
     for _ in &[0; 32] {}
     for _ in &[0; 33] {}
diff --git a/tests/ui/explicit_iter_loop.rs b/tests/ui/explicit_iter_loop.rs
index 66280c23843..2ee6825d445 100644
--- a/tests/ui/explicit_iter_loop.rs
+++ b/tests/ui/explicit_iter_loop.rs
@@ -4,6 +4,7 @@
     clippy::similar_names,
     clippy::needless_borrow,
     clippy::deref_addrof,
+    clippy::unnecessary_mut_passed,
     dead_code
 )]
 
diff --git a/tests/ui/explicit_iter_loop.stderr b/tests/ui/explicit_iter_loop.stderr
index c311096117f..725d9b63cf8 100644
--- a/tests/ui/explicit_iter_loop.stderr
+++ b/tests/ui/explicit_iter_loop.stderr
@@ -1,5 +1,5 @@
 error: it is more concise to loop over references to containers instead of using explicit iteration methods
-  --> $DIR/explicit_iter_loop.rs:16:14
+  --> $DIR/explicit_iter_loop.rs:17:14
    |
 LL |     for _ in vec.iter() {}
    |              ^^^^^^^^^^ help: to write this more concisely, try: `&vec`
@@ -11,132 +11,106 @@ LL | #![deny(clippy::explicit_iter_loop)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: it is more concise to loop over references to containers instead of using explicit iteration methods
-  --> $DIR/explicit_iter_loop.rs:17:14
+  --> $DIR/explicit_iter_loop.rs:18:14
    |
 LL |     for _ in vec.iter_mut() {}
    |              ^^^^^^^^^^^^^^ help: to write this more concisely, try: `&mut vec`
 
 error: it is more concise to loop over references to containers instead of using explicit iteration methods
-  --> $DIR/explicit_iter_loop.rs:20:14
+  --> $DIR/explicit_iter_loop.rs:21:14
    |
 LL |     for _ in rvec.iter() {}
    |              ^^^^^^^^^^^ help: to write this more concisely, try: `rvec`
 
 error: it is more concise to loop over references to containers instead of using explicit iteration methods
-  --> $DIR/explicit_iter_loop.rs:23:14
-   |
-LL |     for _ in rmvec.iter() {}
-   |              ^^^^^^^^^^^^ help: to write this more concisely, try: `&*rmvec`
-
-error: it is more concise to loop over references to containers instead of using explicit iteration methods
-  --> $DIR/explicit_iter_loop.rs:24:14
-   |
-LL |     for _ in rmvec.iter_mut() {}
-   |              ^^^^^^^^^^^^^^^^ help: to write this more concisely, try: `&mut *rmvec`
-
-error: it is more concise to loop over references to containers instead of using explicit iteration methods
-  --> $DIR/explicit_iter_loop.rs:29:14
+  --> $DIR/explicit_iter_loop.rs:30:14
    |
 LL |     for _ in [1, 2, 3].iter() {}
    |              ^^^^^^^^^^^^^^^^ help: to write this more concisely, try: `&[1, 2, 3]`
 
 error: it is more concise to loop over references to containers instead of using explicit iteration methods
-  --> $DIR/explicit_iter_loop.rs:31:14
-   |
-LL |     for _ in (&mut [1, 2, 3]).iter() {}
-   |              ^^^^^^^^^^^^^^^^^^^^^^^ help: to write this more concisely, try: `&*(&mut [1, 2, 3])`
-
-error: the method `iter` doesn't need a mutable reference
-  --> $DIR/explicit_iter_loop.rs:31:14
-   |
-LL |     for _ in (&mut [1, 2, 3]).iter() {}
-   |              ^^^^^^^^^^^^^^^^
-   |
-   = note: `-D clippy::unnecessary-mut-passed` implied by `-D warnings`
-
-error: it is more concise to loop over references to containers instead of using explicit iteration methods
-  --> $DIR/explicit_iter_loop.rs:33:14
+  --> $DIR/explicit_iter_loop.rs:34:14
    |
 LL |     for _ in [0; 32].iter() {}
    |              ^^^^^^^^^^^^^^ help: to write this more concisely, try: `&[0; 32]`
 
 error: it is more concise to loop over references to containers instead of using explicit iteration methods
-  --> $DIR/explicit_iter_loop.rs:34:14
+  --> $DIR/explicit_iter_loop.rs:35:14
    |
 LL |     for _ in [0; 33].iter() {}
    |              ^^^^^^^^^^^^^^ help: to write this more concisely, try: `&[0; 33]`
 
 error: it is more concise to loop over references to containers instead of using explicit iteration methods
-  --> $DIR/explicit_iter_loop.rs:37:14
+  --> $DIR/explicit_iter_loop.rs:38:14
    |
 LL |     for _ in ll.iter() {}
    |              ^^^^^^^^^ help: to write this more concisely, try: `&ll`
 
 error: it is more concise to loop over references to containers instead of using explicit iteration methods
-  --> $DIR/explicit_iter_loop.rs:39:14
+  --> $DIR/explicit_iter_loop.rs:40:14
    |
 LL |     for _ in rll.iter() {}
    |              ^^^^^^^^^^ help: to write this more concisely, try: `rll`
 
 error: it is more concise to loop over references to containers instead of using explicit iteration methods
-  --> $DIR/explicit_iter_loop.rs:42:14
+  --> $DIR/explicit_iter_loop.rs:43:14
    |
 LL |     for _ in vd.iter() {}
    |              ^^^^^^^^^ help: to write this more concisely, try: `&vd`
 
 error: it is more concise to loop over references to containers instead of using explicit iteration methods
-  --> $DIR/explicit_iter_loop.rs:44:14
+  --> $DIR/explicit_iter_loop.rs:45:14
    |
 LL |     for _ in rvd.iter() {}
    |              ^^^^^^^^^^ help: to write this more concisely, try: `rvd`
 
 error: it is more concise to loop over references to containers instead of using explicit iteration methods
-  --> $DIR/explicit_iter_loop.rs:47:14
+  --> $DIR/explicit_iter_loop.rs:48:14
    |
 LL |     for _ in bh.iter() {}
    |              ^^^^^^^^^ help: to write this more concisely, try: `&bh`
 
 error: it is more concise to loop over references to containers instead of using explicit iteration methods
-  --> $DIR/explicit_iter_loop.rs:50:14
+  --> $DIR/explicit_iter_loop.rs:51:14
    |
 LL |     for _ in hm.iter() {}
    |              ^^^^^^^^^ help: to write this more concisely, try: `&hm`
 
 error: it is more concise to loop over references to containers instead of using explicit iteration methods
-  --> $DIR/explicit_iter_loop.rs:53:14
+  --> $DIR/explicit_iter_loop.rs:54:14
    |
 LL |     for _ in bt.iter() {}
    |              ^^^^^^^^^ help: to write this more concisely, try: `&bt`
 
 error: it is more concise to loop over references to containers instead of using explicit iteration methods
-  --> $DIR/explicit_iter_loop.rs:56:14
+  --> $DIR/explicit_iter_loop.rs:57:14
    |
 LL |     for _ in hs.iter() {}
    |              ^^^^^^^^^ help: to write this more concisely, try: `&hs`
 
 error: it is more concise to loop over references to containers instead of using explicit iteration methods
-  --> $DIR/explicit_iter_loop.rs:59:14
+  --> $DIR/explicit_iter_loop.rs:60:14
    |
 LL |     for _ in bs.iter() {}
    |              ^^^^^^^^^ help: to write this more concisely, try: `&bs`
 
 error: it is more concise to loop over references to containers instead of using explicit iteration methods
-  --> $DIR/explicit_iter_loop.rs:148:14
+  --> $DIR/explicit_iter_loop.rs:149:14
    |
 LL |     for _ in x.iter() {}
    |              ^^^^^^^^ help: to write this more concisely, try: `&x`
 
 error: it is more concise to loop over references to containers instead of using explicit iteration methods
-  --> $DIR/explicit_iter_loop.rs:149:14
+  --> $DIR/explicit_iter_loop.rs:150:14
    |
 LL |     for _ in x.iter_mut() {}
    |              ^^^^^^^^^^^^ help: to write this more concisely, try: `&mut x`
 
 error: it is more concise to loop over references to containers instead of using explicit iteration methods
-  --> $DIR/explicit_iter_loop.rs:152:14
+  --> $DIR/explicit_iter_loop.rs:153:14
    |
 LL |     for _ in r.iter() {}
    |              ^^^^^^^^ help: to write this more concisely, try: `r`
 
-error: aborting due to 22 previous errors
+error: aborting due to 18 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 6eb7a46b8872af41e467d5ee96fd15c5741fec49 Mon Sep 17 00:00:00 2001
From: Tobias Decking <Tobias.Decking@gmail.com>
Date: Wed, 30 Aug 2023 13:36:37 +0200
Subject: Documentation Formatting

---
 clippy_lints/src/methods/mod.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 5fb0d9f0a57..df44b1a676b 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3054,12 +3054,12 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust
-    /// vec!(1, 2, 3, 4, 5).resize(0, 5)
+    /// vec![1, 2, 3, 4, 5].resize(0, 5)
     /// ```
     ///
     /// Use instead:
     /// ```rust
-    /// vec!(1, 2, 3, 4, 5).clear()
+    /// vec![1, 2, 3, 4, 5].clear()
     /// ```
     #[clippy::version = "1.46.0"]
     pub VEC_RESIZE_TO_ZERO,
-- 
cgit 1.4.1-3-g733a5


From 1f8b2047752caa70148795074b8c00142c729c5b Mon Sep 17 00:00:00 2001
From: Tobias Decking <Tobias.Decking@gmail.com>
Date: Wed, 30 Aug 2023 14:02:44 +0200
Subject: Second instance of `vec!` with parenthesis.

---
 clippy_lints/src/unit_return_expecting_ord.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unit_return_expecting_ord.rs b/clippy_lints/src/unit_return_expecting_ord.rs
index dd829ded0d0..de4b8738e35 100644
--- a/clippy_lints/src/unit_return_expecting_ord.rs
+++ b/clippy_lints/src/unit_return_expecting_ord.rs
@@ -26,7 +26,7 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust
-    /// let mut twins = vec!((1, 1), (2, 2));
+    /// let mut twins = vec![(1, 1), (2, 2)];
     /// twins.sort_by_key(|x| { x.1; });
     /// ```
     #[clippy::version = "1.47.0"]
-- 
cgit 1.4.1-3-g733a5


From 563abf965145afe2ad9468622ad310dcb9ad4e40 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Wed, 30 Aug 2023 22:08:05 +0200
Subject: [`implied_bounds_in_impls`]: move to nursery and fix ICEs

---
 clippy_lints/src/implied_bounds_in_impls.rs | 117 ++++++++++++++++++----------
 tests/ui/crashes/ice-11422.fixed            |  25 ++++++
 tests/ui/crashes/ice-11422.rs               |  25 ++++++
 tests/ui/crashes/ice-11422.stderr           |  15 ++++
 tests/ui/implied_bounds_in_impls.fixed      |  18 +++++
 tests/ui/implied_bounds_in_impls.rs         |  18 +++++
 tests/ui/implied_bounds_in_impls.stderr     |  26 ++++++-
 7 files changed, 203 insertions(+), 41 deletions(-)
 create mode 100644 tests/ui/crashes/ice-11422.fixed
 create mode 100644 tests/ui/crashes/ice-11422.rs
 create mode 100644 tests/ui/crashes/ice-11422.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/implied_bounds_in_impls.rs b/clippy_lints/src/implied_bounds_in_impls.rs
index c6d1acad3a0..64bdb8ba84e 100644
--- a/clippy_lints/src/implied_bounds_in_impls.rs
+++ b/clippy_lints/src/implied_bounds_in_impls.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet;
 use rustc_errors::{Applicability, SuggestionStyle};
-use rustc_hir::def_id::LocalDefId;
+use rustc_hir::def_id::{DefId, LocalDefId};
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::{
     Body, FnDecl, FnRetTy, GenericArg, GenericBound, ImplItem, ImplItemKind, ItemKind, TraitBoundModifier, TraitItem,
@@ -9,7 +9,7 @@ use rustc_hir::{
 };
 use rustc_hir_analysis::hir_ty_to_ty;
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty::{self, ClauseKind, TyCtxt};
+use rustc_middle::ty::{self, ClauseKind, Generics, Ty, TyCtxt};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::Span;
 
@@ -45,52 +45,80 @@ declare_clippy_lint! {
     /// ```
     #[clippy::version = "1.73.0"]
     pub IMPLIED_BOUNDS_IN_IMPLS,
-    complexity,
+    nursery,
     "specifying bounds that are implied by other bounds in `impl Trait` type"
 }
 declare_lint_pass!(ImpliedBoundsInImpls => [IMPLIED_BOUNDS_IN_IMPLS]);
 
-/// This function tries to, for all type parameters in a supertype predicate `GenericTrait<U>`,
-/// check if the substituted type in the implied-by bound matches with what's subtituted in the
-/// implied type.
+/// Tries to "resolve" a type.
+/// The index passed to this function must start with `Self=0`, i.e. it must be a valid
+/// type parameter index.
+/// If the index is out of bounds, it means that the generic parameter has a default type.
+fn try_resolve_type<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    args: &'tcx [GenericArg<'tcx>],
+    generics: &'tcx Generics,
+    index: usize,
+) -> Option<Ty<'tcx>> {
+    match args.get(index - 1) {
+        Some(GenericArg::Type(ty)) => Some(hir_ty_to_ty(tcx, ty)),
+        Some(_) => None,
+        None => Some(tcx.type_of(generics.params[index].def_id).skip_binder()),
+    }
+}
+
+/// This function tries to, for all generic type parameters in a supertrait predicate `trait ...<U>:
+/// GenericTrait<U>`, check if the substituted type in the implied-by bound matches with what's
+/// subtituted in the implied bound.
 ///
 /// Consider this example.
 /// ```rust,ignore
 /// trait GenericTrait<T> {}
 /// trait GenericSubTrait<T, U, V>: GenericTrait<U> {}
-///                                              ^ trait_predicate_args: [Self#0, U#2]
+///                                 ^^^^^^^^^^^^^^^ trait_predicate_args: [Self#0, U#2]
+///                                                 (the Self#0 is implicit: `<Self as GenericTrait<U>>`)
 /// impl GenericTrait<i32> for () {}
 /// impl GenericSubTrait<(), i32, ()> for () {}
-/// impl GenericSubTrait<(), [u8; 8], ()> for () {}
+/// impl GenericSubTrait<(), i64, ()> for () {}
 ///
-/// fn f() -> impl GenericTrait<i32> + GenericSubTrait<(), [u8; 8], ()> {
-///                             ^^^ implied_args       ^^^^^^^^^^^^^^^ implied_by_args
-///                                                                    (we are interested in `[u8; 8]` specifically, as that
-///                                                                     is what `U` in `GenericTrait<U>` is substituted with)
-///     ()
+/// fn f() -> impl GenericTrait<i32> + GenericSubTrait<(), i64, ()> {
+///                             ^^^ implied_args       ^^^^^^^^^^^ implied_by_args
+///                                                                (we are interested in `i64` specifically, as that
+///                                                                 is what `U` in `GenericTrait<U>` is substituted with)
 /// }
 /// ```
-/// Here i32 != [u8; 8], so this will return false.
-fn is_same_generics(
-    tcx: TyCtxt<'_>,
-    trait_predicate_args: &[ty::GenericArg<'_>],
-    implied_by_args: &[GenericArg<'_>],
-    implied_args: &[GenericArg<'_>],
+/// Here i32 != i64, so this will return false.
+fn is_same_generics<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    trait_predicate_args: &'tcx [ty::GenericArg<'tcx>],
+    implied_by_args: &'tcx [GenericArg<'tcx>],
+    implied_args: &'tcx [GenericArg<'tcx>],
+    implied_by_def_id: DefId,
+    implied_def_id: DefId,
 ) -> bool {
+    // Get the generics of the two traits to be able to get default generic parameter.
+    let implied_by_generics = tcx.generics_of(implied_by_def_id);
+    let implied_generics = tcx.generics_of(implied_def_id);
+
     trait_predicate_args
         .iter()
         .enumerate()
         .skip(1) // skip `Self` implicit arg
         .all(|(arg_index, arg)| {
-            if let Some(ty) = arg.as_type()
-                && let &ty::Param(ty::ParamTy{ index, .. }) = ty.kind()
-                // Since `trait_predicate_args` and type params in traits start with `Self=0`
-                // and generic argument lists `GenericTrait<i32>` don't have `Self`,
-                // we need to subtract 1 from the index.
-                && let GenericArg::Type(ty_a) = implied_by_args[index as usize - 1]
-                && let GenericArg::Type(ty_b) = implied_args[arg_index - 1]
-            {
-                hir_ty_to_ty(tcx, ty_a) == hir_ty_to_ty(tcx, ty_b)
+            if let Some(ty) = arg.as_type() {
+                if let &ty::Param(ty::ParamTy { index, .. }) = ty.kind()
+                    // `index == 0` means that it's referring to `Self`,
+                    // in which case we don't try to substitute it
+                    && index != 0
+                    && let Some(ty_a) = try_resolve_type(tcx, implied_by_args, implied_by_generics, index as usize)
+                    && let Some(ty_b) = try_resolve_type(tcx, implied_args, implied_generics, arg_index)
+                {
+                    ty_a == ty_b
+                } else if let Some(ty_b) = try_resolve_type(tcx, implied_args, implied_generics, arg_index) {
+                    ty == ty_b
+                } else {
+                    false
+                }
             } else {
                 false
             }
@@ -121,7 +149,7 @@ fn check(cx: &LateContext<'_>, decl: &FnDecl<'_>) {
                 && let predicates = cx.tcx.super_predicates_of(trait_def_id).predicates
                 && !predicates.is_empty() // If the trait has no supertrait, there is nothing to add.
             {
-                Some((bound.span(), path.args.map_or([].as_slice(), |a| a.args), predicates))
+                Some((bound.span(), path.args.map_or([].as_slice(), |a| a.args), predicates, trait_def_id))
             } else {
                 None
             }
@@ -135,18 +163,27 @@ fn check(cx: &LateContext<'_>, decl: &FnDecl<'_>) {
                 && let [.., path] = poly_trait.trait_ref.path.segments
                 && let implied_args = path.args.map_or([].as_slice(), |a| a.args)
                 && let Some(def_id) = poly_trait.trait_ref.path.res.opt_def_id()
-                && let Some(implied_by_span) = implied_bounds.iter().find_map(|&(span, implied_by_args, preds)| {
-                    preds.iter().find_map(|(clause, _)| {
-                        if let ClauseKind::Trait(tr) = clause.kind().skip_binder()
-                            && tr.def_id() == def_id
-                            && is_same_generics(cx.tcx, tr.trait_ref.args, implied_by_args, implied_args)
-                        {
-                            Some(span)
-                        } else {
-                            None
-                        }
+                && let Some(implied_by_span) = implied_bounds
+                    .iter()
+                    .find_map(|&(span, implied_by_args, preds, implied_by_def_id)| {
+                        preds.iter().find_map(|(clause, _)| {
+                            if let ClauseKind::Trait(tr) = clause.kind().skip_binder()
+                                && tr.def_id() == def_id
+                                && is_same_generics(
+                                    cx.tcx,
+                                    tr.trait_ref.args,
+                                    implied_by_args,
+                                    implied_args,
+                                    implied_by_def_id,
+                                    def_id,
+                                )
+                            {
+                                Some(span)
+                            } else {
+                                None
+                            }
+                        })
                     })
-                })
             {
                 let implied_by = snippet(cx, implied_by_span, "..");
                 span_lint_and_then(
diff --git a/tests/ui/crashes/ice-11422.fixed b/tests/ui/crashes/ice-11422.fixed
new file mode 100644
index 00000000000..ca5721cbb2b
--- /dev/null
+++ b/tests/ui/crashes/ice-11422.fixed
@@ -0,0 +1,25 @@
+#![warn(clippy::implied_bounds_in_impls)]
+
+use std::fmt::Debug;
+use std::ops::*;
+
+fn gen() -> impl PartialOrd + Debug {}
+
+struct Bar {}
+trait Foo<T = Self> {}
+trait FooNested<T = Option<Self>> {}
+impl Foo for Bar {}
+impl FooNested for Bar {}
+
+fn foo() -> impl Foo + FooNested {
+    Bar {}
+}
+
+fn test_impl_ops() -> impl Add + Sub + Mul + Div {
+    1
+}
+fn test_impl_assign_ops() -> impl AddAssign + SubAssign + MulAssign + DivAssign {
+    1
+}
+
+fn main() {}
diff --git a/tests/ui/crashes/ice-11422.rs b/tests/ui/crashes/ice-11422.rs
new file mode 100644
index 00000000000..355ec2480bb
--- /dev/null
+++ b/tests/ui/crashes/ice-11422.rs
@@ -0,0 +1,25 @@
+#![warn(clippy::implied_bounds_in_impls)]
+
+use std::fmt::Debug;
+use std::ops::*;
+
+fn gen() -> impl PartialOrd + PartialEq + Debug {}
+
+struct Bar {}
+trait Foo<T = Self> {}
+trait FooNested<T = Option<Self>> {}
+impl Foo for Bar {}
+impl FooNested for Bar {}
+
+fn foo() -> impl Foo + FooNested {
+    Bar {}
+}
+
+fn test_impl_ops() -> impl Add + Sub + Mul + Div {
+    1
+}
+fn test_impl_assign_ops() -> impl AddAssign + SubAssign + MulAssign + DivAssign {
+    1
+}
+
+fn main() {}
diff --git a/tests/ui/crashes/ice-11422.stderr b/tests/ui/crashes/ice-11422.stderr
new file mode 100644
index 00000000000..1930a517397
--- /dev/null
+++ b/tests/ui/crashes/ice-11422.stderr
@@ -0,0 +1,15 @@
+error: this bound is already specified as the supertrait of `PartialOrd`
+  --> $DIR/ice-11422.rs:6:31
+   |
+LL | fn gen() -> impl PartialOrd + PartialEq + Debug {}
+   |                               ^^^^^^^^^
+   |
+   = note: `-D clippy::implied-bounds-in-impls` implied by `-D warnings`
+help: try removing this bound
+   |
+LL - fn gen() -> impl PartialOrd + PartialEq + Debug {}
+LL + fn gen() -> impl PartialOrd + Debug {}
+   |
+
+error: aborting due to previous error
+
diff --git a/tests/ui/implied_bounds_in_impls.fixed b/tests/ui/implied_bounds_in_impls.fixed
index 952c2b70619..69fcc8921d6 100644
--- a/tests/ui/implied_bounds_in_impls.fixed
+++ b/tests/ui/implied_bounds_in_impls.fixed
@@ -65,4 +65,22 @@ impl SomeTrait for SomeStruct {
     }
 }
 
+mod issue11422 {
+    use core::fmt::Debug;
+    // Some additional tests that would cause ICEs:
+
+    // `PartialOrd` has a default generic parameter and does not need to be explicitly specified.
+    // This needs special handling.
+    fn default_generic_param1() -> impl PartialOrd + Debug {}
+    fn default_generic_param2() -> impl PartialOrd + Debug {}
+
+    // Referring to `Self` in the supertrait clause needs special handling.
+    trait Trait1<X: ?Sized> {}
+    trait Trait2: Trait1<Self> {}
+    impl Trait1<()> for () {}
+    impl Trait2 for () {}
+
+    fn f() -> impl Trait1<()> + Trait2 {}
+}
+
 fn main() {}
diff --git a/tests/ui/implied_bounds_in_impls.rs b/tests/ui/implied_bounds_in_impls.rs
index 475f2621bbf..5504feae613 100644
--- a/tests/ui/implied_bounds_in_impls.rs
+++ b/tests/ui/implied_bounds_in_impls.rs
@@ -65,4 +65,22 @@ impl SomeTrait for SomeStruct {
     }
 }
 
+mod issue11422 {
+    use core::fmt::Debug;
+    // Some additional tests that would cause ICEs:
+
+    // `PartialOrd` has a default generic parameter and does not need to be explicitly specified.
+    // This needs special handling.
+    fn default_generic_param1() -> impl PartialEq + PartialOrd + Debug {}
+    fn default_generic_param2() -> impl PartialOrd + PartialEq + Debug {}
+
+    // Referring to `Self` in the supertrait clause needs special handling.
+    trait Trait1<X: ?Sized> {}
+    trait Trait2: Trait1<Self> {}
+    impl Trait1<()> for () {}
+    impl Trait2 for () {}
+
+    fn f() -> impl Trait1<()> + Trait2 {}
+}
+
 fn main() {}
diff --git a/tests/ui/implied_bounds_in_impls.stderr b/tests/ui/implied_bounds_in_impls.stderr
index 8dffc674444..d6a4ae889fe 100644
--- a/tests/ui/implied_bounds_in_impls.stderr
+++ b/tests/ui/implied_bounds_in_impls.stderr
@@ -119,5 +119,29 @@ LL -     fn f() -> impl Deref + DerefMut<Target = u8> {
 LL +     fn f() -> impl DerefMut<Target = u8> {
    |
 
-error: aborting due to 10 previous errors
+error: this bound is already specified as the supertrait of `PartialOrd`
+  --> $DIR/implied_bounds_in_impls.rs:74:41
+   |
+LL |     fn default_generic_param1() -> impl PartialEq + PartialOrd + Debug {}
+   |                                         ^^^^^^^^^
+   |
+help: try removing this bound
+   |
+LL -     fn default_generic_param1() -> impl PartialEq + PartialOrd + Debug {}
+LL +     fn default_generic_param1() -> impl PartialOrd + Debug {}
+   |
+
+error: this bound is already specified as the supertrait of `PartialOrd`
+  --> $DIR/implied_bounds_in_impls.rs:75:54
+   |
+LL |     fn default_generic_param2() -> impl PartialOrd + PartialEq + Debug {}
+   |                                                      ^^^^^^^^^
+   |
+help: try removing this bound
+   |
+LL -     fn default_generic_param2() -> impl PartialOrd + PartialEq + Debug {}
+LL +     fn default_generic_param2() -> impl PartialOrd + Debug {}
+   |
+
+error: aborting due to 12 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 299fbceb96a36fdb55c1370ae1a5c9ce01fd65c6 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Thu, 31 Aug 2023 12:52:55 +0000
Subject: Check binary operators and attributes in disallowed_macros

---
 clippy_lints/src/disallowed_macros.rs              | 11 ++++++++++-
 .../ui-toml/disallowed_macros/auxiliary/macros.rs  | 15 +++++++++++++++
 tests/ui-toml/disallowed_macros/clippy.toml        |  2 ++
 .../ui-toml/disallowed_macros/disallowed_macros.rs |  5 ++++-
 .../disallowed_macros/disallowed_macros.stderr     | 22 ++++++++++++++++++----
 5 files changed, 49 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/disallowed_macros.rs b/clippy_lints/src/disallowed_macros.rs
index 1971cab64ef..7469f813ef8 100644
--- a/clippy_lints/src/disallowed_macros.rs
+++ b/clippy_lints/src/disallowed_macros.rs
@@ -1,8 +1,9 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::macros::macro_backtrace;
+use rustc_ast::Attribute;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_hir::def_id::DefIdMap;
-use rustc_hir::{Expr, ForeignItem, HirId, ImplItem, Item, Pat, Path, Stmt, TraitItem, Ty};
+use rustc_hir::{Expr, ExprKind, ForeignItem, HirId, ImplItem, Item, Pat, Path, Stmt, TraitItem, Ty};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::{ExpnId, Span};
@@ -111,6 +112,10 @@ impl LateLintPass<'_> for DisallowedMacros {
 
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
         self.check(cx, expr.span);
+        // `$t + $t` can have the context of $t, check also the span of the binary operator
+        if let ExprKind::Binary(op, ..) = expr.kind {
+            self.check(cx, op.span);
+        }
     }
 
     fn check_stmt(&mut self, cx: &LateContext<'_>, stmt: &Stmt<'_>) {
@@ -147,4 +152,8 @@ impl LateLintPass<'_> for DisallowedMacros {
     fn check_path(&mut self, cx: &LateContext<'_>, path: &Path<'_>, _: HirId) {
         self.check(cx, path.span);
     }
+
+    fn check_attribute(&mut self, cx: &LateContext<'_>, attr: &Attribute) {
+        self.check(cx, attr.span);
+    }
 }
diff --git a/tests/ui-toml/disallowed_macros/auxiliary/macros.rs b/tests/ui-toml/disallowed_macros/auxiliary/macros.rs
index fcaeace0e98..f4166b227fc 100644
--- a/tests/ui-toml/disallowed_macros/auxiliary/macros.rs
+++ b/tests/ui-toml/disallowed_macros/auxiliary/macros.rs
@@ -30,3 +30,18 @@ macro_rules! item {
         const ITEM: usize = 1;
     };
 }
+
+#[macro_export]
+macro_rules! binop {
+    ($t:tt) => {
+        $t + $t
+    };
+}
+
+#[macro_export]
+macro_rules! attr {
+    ($i:item) => {
+        #[repr(C)]
+        $i
+    };
+}
diff --git a/tests/ui-toml/disallowed_macros/clippy.toml b/tests/ui-toml/disallowed_macros/clippy.toml
index c8fe8be9a77..85f1b71eb66 100644
--- a/tests/ui-toml/disallowed_macros/clippy.toml
+++ b/tests/ui-toml/disallowed_macros/clippy.toml
@@ -8,4 +8,6 @@ disallowed-macros = [
     "macros::ty",
     "macros::pat",
     "macros::item",
+    "macros::binop",
+    "macros::attr",
 ]
diff --git a/tests/ui-toml/disallowed_macros/disallowed_macros.rs b/tests/ui-toml/disallowed_macros/disallowed_macros.rs
index ba919b48788..4a3d55e13c9 100644
--- a/tests/ui-toml/disallowed_macros/disallowed_macros.rs
+++ b/tests/ui-toml/disallowed_macros/disallowed_macros.rs
@@ -20,11 +20,14 @@ fn main() {
     let macros::pat!() = 1;
     let _: macros::ty!() = "";
     macros::item!();
+    let _ = macros::binop!(1);
 
     eprintln!("allowed");
 }
 
-struct S;
+macros::attr! {
+    struct S;
+}
 
 impl S {
     macros::item!();
diff --git a/tests/ui-toml/disallowed_macros/disallowed_macros.stderr b/tests/ui-toml/disallowed_macros/disallowed_macros.stderr
index aed9feb6f79..d768dd9cce7 100644
--- a/tests/ui-toml/disallowed_macros/disallowed_macros.stderr
+++ b/tests/ui-toml/disallowed_macros/disallowed_macros.stderr
@@ -62,23 +62,37 @@ error: use of a disallowed macro `macros::item`
 LL |     macros::item!();
    |     ^^^^^^^^^^^^^^^
 
+error: use of a disallowed macro `macros::binop`
+  --> $DIR/disallowed_macros.rs:23:13
+   |
+LL |     let _ = macros::binop!(1);
+   |             ^^^^^^^^^^^^^^^^^
+
 error: use of a disallowed macro `macros::item`
-  --> $DIR/disallowed_macros.rs:30:5
+  --> $DIR/disallowed_macros.rs:33:5
    |
 LL |     macros::item!();
    |     ^^^^^^^^^^^^^^^
 
 error: use of a disallowed macro `macros::item`
-  --> $DIR/disallowed_macros.rs:34:5
+  --> $DIR/disallowed_macros.rs:37:5
    |
 LL |     macros::item!();
    |     ^^^^^^^^^^^^^^^
 
 error: use of a disallowed macro `macros::item`
-  --> $DIR/disallowed_macros.rs:38:5
+  --> $DIR/disallowed_macros.rs:41:5
    |
 LL |     macros::item!();
    |     ^^^^^^^^^^^^^^^
 
-error: aborting due to 13 previous errors
+error: use of a disallowed macro `macros::attr`
+  --> $DIR/disallowed_macros.rs:28:1
+   |
+LL | / macros::attr! {
+LL | |     struct S;
+LL | | }
+   | |_^
+
+error: aborting due to 15 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From b54bac9f1420423503cb2408d57ab0fd44adc243 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Fri, 21 Apr 2023 23:58:55 +0200
Subject: new lint: `missing_assert_for_indexing`

---
 CHANGELOG.md                                       |   1 +
 clippy_lints/src/declared_lints.rs                 |   1 +
 clippy_lints/src/lib.rs                            |   2 +
 clippy_lints/src/missing_asserts_for_indexing.rs   | 393 +++++++++++++++++++++
 tests/ui/missing_asserts_for_indexing.fixed        | 123 +++++++
 tests/ui/missing_asserts_for_indexing.rs           | 123 +++++++
 tests/ui/missing_asserts_for_indexing.stderr       | 256 ++++++++++++++
 tests/ui/missing_asserts_for_indexing_unfixable.rs |  43 +++
 .../missing_asserts_for_indexing_unfixable.stderr  | 161 +++++++++
 9 files changed, 1103 insertions(+)
 create mode 100644 clippy_lints/src/missing_asserts_for_indexing.rs
 create mode 100644 tests/ui/missing_asserts_for_indexing.fixed
 create mode 100644 tests/ui/missing_asserts_for_indexing.rs
 create mode 100644 tests/ui/missing_asserts_for_indexing.stderr
 create mode 100644 tests/ui/missing_asserts_for_indexing_unfixable.rs
 create mode 100644 tests/ui/missing_asserts_for_indexing_unfixable.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 851a5aa8789..fd7232e280f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5132,6 +5132,7 @@ Released 2018-09-13
 [`misnamed_getters`]: https://rust-lang.github.io/rust-clippy/master/index.html#misnamed_getters
 [`misrefactored_assign_op`]: https://rust-lang.github.io/rust-clippy/master/index.html#misrefactored_assign_op
 [`missing_assert_message`]: https://rust-lang.github.io/rust-clippy/master/index.html#missing_assert_message
+[`missing_asserts_for_indexing`]: https://rust-lang.github.io/rust-clippy/master/index.html#missing_asserts_for_indexing
 [`missing_const_for_fn`]: https://rust-lang.github.io/rust-clippy/master/index.html#missing_const_for_fn
 [`missing_docs_in_private_items`]: https://rust-lang.github.io/rust-clippy/master/index.html#missing_docs_in_private_items
 [`missing_enforced_import_renames`]: https://rust-lang.github.io/rust-clippy/master/index.html#missing_enforced_import_renames
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 70dcda6a557..150d883985c 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -457,6 +457,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::misc_early::ZERO_PREFIXED_LITERAL_INFO,
     crate::mismatching_type_param_order::MISMATCHING_TYPE_PARAM_ORDER_INFO,
     crate::missing_assert_message::MISSING_ASSERT_MESSAGE_INFO,
+    crate::missing_asserts_for_indexing::MISSING_ASSERTS_FOR_INDEXING_INFO,
     crate::missing_const_for_fn::MISSING_CONST_FOR_FN_INFO,
     crate::missing_doc::MISSING_DOCS_IN_PRIVATE_ITEMS_INFO,
     crate::missing_enforced_import_rename::MISSING_ENFORCED_IMPORT_RENAMES_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index f3559771a57..4ff97e03a14 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -210,6 +210,7 @@ mod misc;
 mod misc_early;
 mod mismatching_type_param_order;
 mod missing_assert_message;
+mod missing_asserts_for_indexing;
 mod missing_const_for_fn;
 mod missing_doc;
 mod missing_enforced_import_rename;
@@ -1100,6 +1101,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(ignored_unit_patterns::IgnoredUnitPatterns));
     store.register_late_pass(|_| Box::<reserve_after_initialization::ReserveAfterInitialization>::default());
     store.register_late_pass(|_| Box::new(implied_bounds_in_impls::ImpliedBoundsInImpls));
+    store.register_late_pass(|_| Box::new(missing_asserts_for_indexing::MissingAssertsForIndexing));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/missing_asserts_for_indexing.rs b/clippy_lints/src/missing_asserts_for_indexing.rs
new file mode 100644
index 00000000000..03587a90707
--- /dev/null
+++ b/clippy_lints/src/missing_asserts_for_indexing.rs
@@ -0,0 +1,393 @@
+use std::mem;
+use std::ops::ControlFlow;
+
+use clippy_utils::eq_expr_value;
+use clippy_utils::source::snippet;
+use clippy_utils::{
+    comparisons::{normalize_comparison, Rel},
+    diagnostics::span_lint_and_then,
+    hash_expr, higher,
+    visitors::for_each_expr,
+};
+use rustc_ast::{LitKind, RangeLimits};
+use rustc_data_structures::unhash::UnhashMap;
+use rustc_errors::{Applicability, Diagnostic};
+use rustc_hir::{BinOp, Block, Expr, ExprKind, UnOp};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::source_map::Spanned;
+use rustc_span::{sym, Span};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for repeated slice indexing without asserting beforehand that the length
+    /// is greater than the largest index used to index into the slice.
+    ///
+    /// ### Why is this bad?
+    /// In the general case where the compiler does not have a lot of information
+    /// about the length of a slice, indexing it repeatedly will generate a bounds check
+    /// for every single index.
+    ///
+    /// Asserting that the length of the slice is at least as large as the largest value
+    /// to index beforehand gives the compiler enough information to elide the bounds checks,
+    /// effectively reducing the number of bounds checks from however many times
+    /// the slice was indexed to just one (the assert).
+    ///
+    /// ### Drawbacks
+    /// False positives. It is, in general, very difficult to predict how well
+    /// the optimizer will be able to elide bounds checks and it very much depends on
+    /// the surrounding code. For example, indexing into the slice yielded by the
+    /// [`slice::chunks_exact`](https://doc.rust-lang.org/stable/std/primitive.slice.html#method.chunks_exact)
+    /// iterator will likely have all of the bounds checks elided even without an assert
+    /// if the `chunk_size` is a constant.
+    ///
+    /// Asserts are not tracked across function calls. Asserting the length of a slice
+    /// in a different function likely gives the optimizer enough information
+    /// about the length of a slice, but this lint will not detect that.
+    ///
+    /// ### Example
+    /// ```rust
+    /// fn sum(v: &[u8]) -> u8 {
+    ///     // 4 bounds checks
+    ///     v[0] + v[1] + v[2] + v[3]
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// fn sum(v: &[u8]) -> u8 {
+    ///     assert!(v.len() > 4);
+    ///     // no bounds checks
+    ///     v[0] + v[1] + v[2] + v[3]
+    /// }
+    /// ```
+    #[clippy::version = "1.70.0"]
+    pub MISSING_ASSERTS_FOR_INDEXING,
+    restriction,
+    "indexing into a slice multiple times without an `assert`"
+}
+declare_lint_pass!(MissingAssertsForIndexing => [MISSING_ASSERTS_FOR_INDEXING]);
+
+fn report_lint<F>(cx: &LateContext<'_>, full_span: Span, msg: &str, indexes: &[Span], f: F)
+where
+    F: FnOnce(&mut Diagnostic),
+{
+    span_lint_and_then(cx, MISSING_ASSERTS_FOR_INDEXING, full_span, msg, |diag| {
+        f(diag);
+        for span in indexes {
+            diag.span_note(*span, "slice indexed here");
+        }
+        diag.note("asserting the length before indexing will elide bounds checks");
+    });
+}
+
+#[derive(Copy, Clone, Debug)]
+enum LengthComparison {
+    /// `v.len() < 5`
+    LengthLessThanInt,
+    /// `5 < v.len()`
+    IntLessThanLength,
+    /// `v.len() <= 5`
+    LengthLessThanOrEqualInt,
+    /// `5 <= v.len()`
+    IntLessThanOrEqualLength,
+}
+
+/// Extracts parts out of a length comparison expression.
+///
+/// E.g. for `v.len() > 5` this returns `Some((LengthComparison::IntLessThanLength, 5, `v.len()`))`
+fn len_comparison<'hir>(
+    bin_op: BinOp,
+    left: &'hir Expr<'hir>,
+    right: &'hir Expr<'hir>,
+) -> Option<(LengthComparison, usize, &'hir Expr<'hir>)> {
+    macro_rules! int_lit_pat {
+        ($id:ident) => {
+            ExprKind::Lit(Spanned {
+                node: LitKind::Int($id, _),
+                ..
+            })
+        };
+    }
+
+    // normalize comparison, `v.len() > 4` becomes `4 < v.len()`
+    // this simplifies the logic a bit
+    let (op, left, right) = normalize_comparison(bin_op.node, left, right)?;
+    match (op, &left.kind, &right.kind) {
+        (Rel::Lt, int_lit_pat!(left), _) => Some((LengthComparison::IntLessThanLength, *left as usize, right)),
+        (Rel::Lt, _, int_lit_pat!(right)) => Some((LengthComparison::LengthLessThanInt, *right as usize, left)),
+        (Rel::Le, int_lit_pat!(left), _) => Some((LengthComparison::IntLessThanOrEqualLength, *left as usize, right)),
+        (Rel::Le, _, int_lit_pat!(right)) => Some((LengthComparison::LengthLessThanOrEqualInt, *right as usize, left)),
+        _ => None,
+    }
+}
+
+/// Attempts to extract parts out of an `assert!`-like expression
+/// in the form `assert!(some_slice.len() > 5)`.
+///
+/// `assert!` has expanded to an if expression at the HIR, so this
+/// actually works not just with `assert!` specifically, but anything
+/// that has a never type expression in the `then` block (e.g. `panic!`).
+fn assert_len_expr<'hir>(
+    cx: &LateContext<'_>,
+    expr: &'hir Expr<'hir>,
+) -> Option<(LengthComparison, usize, &'hir Expr<'hir>)> {
+    if let Some(higher::If { cond, then, .. }) = higher::If::hir(expr)
+        && let ExprKind::Unary(UnOp::Not, condition) = &cond.kind
+        && let ExprKind::Binary(bin_op, left, right) = &condition.kind
+
+        && let Some((cmp, asserted_len, slice_len)) = len_comparison(*bin_op, left, right)
+        && let ExprKind::MethodCall(method, recv, ..) = &slice_len.kind
+        && cx.typeck_results().expr_ty_adjusted(recv).peel_refs().is_slice()
+        && method.ident.name == sym::len
+
+        // check if `then` block has a never type expression
+        && let ExprKind::Block(Block { expr: Some(then_expr), .. }, _) = then.kind
+        && cx.typeck_results().expr_ty(then_expr).is_never()
+    {
+        Some((cmp, asserted_len, recv))
+    } else {
+        None
+    }
+}
+
+#[derive(Debug)]
+enum IndexEntry<'hir> {
+    /// `assert!` without any indexing (so far)
+    StrayAssert {
+        asserted_len: usize,
+        comparison: LengthComparison,
+        assert_span: Span,
+        slice: &'hir Expr<'hir>,
+    },
+    /// `assert!` with indexing
+    ///
+    /// We also store the highest index to be able to check
+    /// if the `assert!` asserts the right length.
+    AssertWithIndex {
+        highest_index: usize,
+        asserted_len: usize,
+        assert_span: Span,
+        slice: &'hir Expr<'hir>,
+        indexes: Vec<Span>,
+        comparison: LengthComparison,
+    },
+    /// Indexing without an `assert!`
+    IndexWithoutAssert {
+        highest_index: usize,
+        indexes: Vec<Span>,
+        slice: &'hir Expr<'hir>,
+    },
+}
+
+impl<'hir> IndexEntry<'hir> {
+    pub fn slice(&self) -> &'hir Expr<'hir> {
+        match self {
+            IndexEntry::StrayAssert { slice, .. }
+            | IndexEntry::AssertWithIndex { slice, .. }
+            | IndexEntry::IndexWithoutAssert { slice, .. } => slice,
+        }
+    }
+
+    pub fn index_spans(&self) -> Option<&[Span]> {
+        match self {
+            IndexEntry::StrayAssert { .. } => None,
+            IndexEntry::AssertWithIndex { indexes, .. } | IndexEntry::IndexWithoutAssert { indexes, .. } => {
+                Some(indexes)
+            },
+        }
+    }
+}
+
+/// Extracts the upper index of a slice indexing expression.
+///
+/// E.g. for `5` this returns `Some(5)`, for `..5` this returns `Some(4)`,
+/// for `..=5` this returns `Some(5)`
+fn upper_index_expr(expr: &Expr<'_>) -> Option<usize> {
+    if let ExprKind::Lit(lit) = &expr.kind && let LitKind::Int(index, _) = lit.node {
+        Some(index as usize)
+    } else if let Some(higher::Range { end: Some(end), limits, .. }) = higher::Range::hir(expr)
+        && let ExprKind::Lit(lit) = &end.kind
+        && let LitKind::Int(index @ 1.., _) = lit.node
+    {
+        match limits {
+            RangeLimits::HalfOpen => Some(index as usize - 1),
+            RangeLimits::Closed => Some(index as usize),
+        }
+    } else {
+        None
+    }
+}
+
+/// Checks if the expression is an index into a slice and adds it to `indexes`
+fn check_index<'hir>(cx: &LateContext<'_>, expr: &'hir Expr<'hir>, map: &mut UnhashMap<u64, Vec<IndexEntry<'hir>>>) {
+    if let ExprKind::Index(slice, index_lit) = expr.kind
+        && cx.typeck_results().expr_ty_adjusted(slice).peel_refs().is_slice()
+        && let Some(index) = upper_index_expr(index_lit)
+    {
+        let hash = hash_expr(cx, slice);
+
+        let indexes = map.entry(hash).or_insert_with(Vec::new);
+        let entry = indexes.iter_mut().find(|entry| eq_expr_value(cx, entry.slice(), slice));
+
+        if let Some(entry) = entry {
+            match entry {
+                IndexEntry::StrayAssert { asserted_len, comparison, assert_span, slice } => {
+                    *entry = IndexEntry::AssertWithIndex {
+                        highest_index: index,
+                        asserted_len: *asserted_len,
+                        assert_span: *assert_span,
+                        slice,
+                        indexes: vec![expr.span],
+                        comparison: *comparison,
+                    };
+                },
+                IndexEntry::IndexWithoutAssert { highest_index, indexes, .. }
+                | IndexEntry::AssertWithIndex { highest_index, indexes, .. } => {
+                    indexes.push(expr.span);
+                    *highest_index = (*highest_index).max(index);
+                },
+            }
+        } else {
+            indexes.push(IndexEntry::IndexWithoutAssert {
+                highest_index: index,
+                indexes: vec![expr.span],
+                slice,
+            });
+        }
+    }
+}
+
+/// Checks if the expression is an `assert!` expression and adds it to `asserts`
+fn check_assert<'hir>(cx: &LateContext<'_>, expr: &'hir Expr<'hir>, map: &mut UnhashMap<u64, Vec<IndexEntry<'hir>>>) {
+    if let Some((comparison, asserted_len, slice)) = assert_len_expr(cx, expr) {
+        let hash = hash_expr(cx, slice);
+        let indexes = map.entry(hash).or_insert_with(Vec::new);
+
+        let entry = indexes.iter_mut().find(|entry| eq_expr_value(cx, entry.slice(), slice));
+
+        if let Some(entry) = entry {
+            if let IndexEntry::IndexWithoutAssert {
+                highest_index,
+                indexes,
+                slice,
+            } = entry
+            {
+                *entry = IndexEntry::AssertWithIndex {
+                    highest_index: *highest_index,
+                    indexes: mem::take(indexes),
+                    slice,
+                    assert_span: expr.span,
+                    comparison,
+                    asserted_len,
+                };
+            }
+        } else {
+            indexes.push(IndexEntry::StrayAssert {
+                asserted_len,
+                comparison,
+                assert_span: expr.span,
+                slice,
+            });
+        }
+    }
+}
+
+/// Inspects indexes and reports lints.
+///
+/// Called at the end of this lint after all indexing and `assert!` expressions have been collected.
+fn report_indexes(cx: &LateContext<'_>, map: &UnhashMap<u64, Vec<IndexEntry<'_>>>) {
+    for bucket in map.values() {
+        for entry in bucket {
+            let Some(full_span) = entry
+                .index_spans()
+                .and_then(|spans| spans.first().zip(spans.last()))
+                .map(|(low, &high)| low.to(high)) else {
+                    continue;
+                };
+
+            match entry {
+                IndexEntry::AssertWithIndex {
+                    highest_index,
+                    asserted_len,
+                    indexes,
+                    comparison,
+                    assert_span,
+                    slice,
+                } if indexes.len() > 1 => {
+                    // if we have found an `assert!`, let's also check that it's actually right
+                    // and if it convers the highest index and if not, suggest the correct length
+                    let sugg = match comparison {
+                        // `v.len() < 5` and `v.len() <= 5` does nothing in terms of bounds checks.
+                        // The user probably meant `v.len() > 5`
+                        LengthComparison::LengthLessThanInt | LengthComparison::LengthLessThanOrEqualInt => Some(
+                            format!("assert!({}.len() > {highest_index})", snippet(cx, slice.span, "..")),
+                        ),
+                        // `5 < v.len()` == `v.len() > 5`
+                        LengthComparison::IntLessThanLength if asserted_len < highest_index => Some(format!(
+                            "assert!({}.len() > {highest_index})",
+                            snippet(cx, slice.span, "..")
+                        )),
+                        // `5 <= v.len() == `v.len() >= 5`
+                        LengthComparison::IntLessThanOrEqualLength if asserted_len <= highest_index => Some(format!(
+                            "assert!({}.len() > {highest_index})",
+                            snippet(cx, slice.span, "..")
+                        )),
+                        _ => None,
+                    };
+
+                    if let Some(sugg) = sugg {
+                        report_lint(
+                            cx,
+                            full_span,
+                            "indexing into a slice multiple times with an `assert` that does not cover the highest index",
+                            indexes,
+                            |diag| {
+                                diag.span_suggestion(
+                                    *assert_span,
+                                    "provide the highest index that is indexed with",
+                                    sugg,
+                                    Applicability::MachineApplicable,
+                                );
+                            },
+                        );
+                    }
+                },
+                IndexEntry::IndexWithoutAssert {
+                    indexes,
+                    highest_index,
+                    slice,
+                } if indexes.len() > 1 => {
+                    // if there was no `assert!` but more than one index, suggest
+                    // adding an `assert!` that covers the highest index
+                    report_lint(
+                        cx,
+                        full_span,
+                        "indexing into a slice multiple times without an `assert`",
+                        indexes,
+                        |diag| {
+                            diag.help(format!(
+                                "consider asserting the length before indexing: `assert!({}.len() > {highest_index});`",
+                                snippet(cx, slice.span, "..")
+                            ));
+                        },
+                    );
+                },
+                _ => {},
+            }
+        }
+    }
+}
+
+impl LateLintPass<'_> for MissingAssertsForIndexing {
+    fn check_block(&mut self, cx: &LateContext<'_>, block: &Block<'_>) {
+        let mut map = UnhashMap::default();
+
+        for_each_expr(block, |expr| {
+            check_index(cx, expr, &mut map);
+            check_assert(cx, expr, &mut map);
+            ControlFlow::<!, ()>::Continue(())
+        });
+
+        report_indexes(cx, &map);
+    }
+}
diff --git a/tests/ui/missing_asserts_for_indexing.fixed b/tests/ui/missing_asserts_for_indexing.fixed
new file mode 100644
index 00000000000..0dee4d76db5
--- /dev/null
+++ b/tests/ui/missing_asserts_for_indexing.fixed
@@ -0,0 +1,123 @@
+//@run-rustfix
+
+#![allow(unused)]
+#![warn(clippy::missing_asserts_for_indexing)]
+
+// ok
+fn sum_with_assert(v: &[u8]) -> u8 {
+    assert!(v.len() > 4);
+    v[0] + v[1] + v[2] + v[3] + v[4]
+}
+
+// ok
+fn sum_with_assert_other_way(v: &[u8]) -> u8 {
+    assert!(5 <= v.len());
+    v[0] + v[1] + v[2] + v[3] + v[4]
+}
+
+// ok
+fn sum_with_assert_ge(v: &[u8]) -> u8 {
+    assert!(v.len() >= 5);
+    v[0] + v[1] + v[2] + v[3] + v[4]
+}
+
+// ok
+fn sum_with_assert_ge_other_way(v: &[u8]) -> u8 {
+    assert!(4 < v.len());
+    v[0] + v[1] + v[2] + v[3] + v[4]
+}
+
+fn sum_with_assert_lt(v: &[u8]) -> u8 {
+    assert!(v.len() > 4);
+    //~^ ERROR incorrect length
+    v[0] + v[1] + v[2] + v[3] + v[4]
+}
+
+fn sum_with_assert_le(v: &[u8]) -> u8 {
+    assert!(v.len() > 4);
+    //~^ ERROR incorrect length
+    v[0] + v[1] + v[2] + v[3] + v[4]
+}
+
+fn sum_with_incorrect_assert_len(v: &[u8]) -> u8 {
+    assert!(v.len() > 4);
+    //~^ ERROR incorrect length
+    v[0] + v[1] + v[2] + v[3] + v[4]
+}
+
+fn sum_with_incorrect_assert_len2(v: &[u8]) -> u8 {
+    assert!(v.len() > 4);
+    //~^ ERROR incorrect length
+    v[0] + v[1] + v[2] + v[3] + v[4]
+}
+
+// ok, don't lint for single array access
+fn single_access(v: &[u8]) -> u8 {
+    v[0]
+}
+
+// ok
+fn subslice_ok(v: &[u8]) {
+    assert!(v.len() > 3);
+    let _ = v[0];
+    let _ = v[1..4];
+}
+
+fn subslice_bad(v: &[u8]) {
+    assert!(v.len() > 3);
+    //~^ ERROR incorrect length
+    let _ = v[0];
+    let _ = v[1..4];
+}
+
+// ok
+fn subslice_inclusive_ok(v: &[u8]) {
+    assert!(v.len() > 4);
+    let _ = v[0];
+    let _ = v[1..=4];
+}
+
+fn subslice_inclusive_bad(v: &[u8]) {
+    assert!(v.len() > 4);
+    //~^ ERROR incorrect length
+    let _ = v[0];
+    let _ = v[1..=4];
+}
+
+fn index_different_slices_ok(v1: &[u8], v2: &[u8]) {
+    assert!(v1.len() > 12);
+    assert!(v2.len() > 15);
+    let _ = v1[0] + v1[12];
+    let _ = v2[5] + v2[15];
+}
+
+fn index_different_slices_wrong_len(v1: &[u8], v2: &[u8]) {
+    assert!(v1.len() > 12);
+    //~^ ERROR incorrect length
+    assert!(v2.len() > 15);
+    //~^ ERROR incorrect length
+    let _ = v1[0] + v1[12];
+    let _ = v2[5] + v2[15];
+}
+fn index_different_slices_one_wrong_len(v1: &[u8], v2: &[u8]) {
+    assert!(v1.len() > 12);
+    //~^ ERROR incorrect length
+    assert!(v2.len() > 15);
+    let _ = v1[0] + v1[12];
+    let _ = v2[5] + v2[15];
+}
+
+fn side_effect() -> &'static [u8] {
+    &[]
+}
+
+fn index_side_effect_expr() {
+    let _ = side_effect()[0] + side_effect()[1];
+}
+
+// ok, single access for different slices
+fn index_different_slice_in_same_expr(v1: &[u8], v2: &[u8]) {
+    let _ = v1[0] + v2[1];
+}
+
+fn main() {}
diff --git a/tests/ui/missing_asserts_for_indexing.rs b/tests/ui/missing_asserts_for_indexing.rs
new file mode 100644
index 00000000000..cddf82434a6
--- /dev/null
+++ b/tests/ui/missing_asserts_for_indexing.rs
@@ -0,0 +1,123 @@
+//@run-rustfix
+
+#![allow(unused)]
+#![warn(clippy::missing_asserts_for_indexing)]
+
+// ok
+fn sum_with_assert(v: &[u8]) -> u8 {
+    assert!(v.len() > 4);
+    v[0] + v[1] + v[2] + v[3] + v[4]
+}
+
+// ok
+fn sum_with_assert_other_way(v: &[u8]) -> u8 {
+    assert!(5 <= v.len());
+    v[0] + v[1] + v[2] + v[3] + v[4]
+}
+
+// ok
+fn sum_with_assert_ge(v: &[u8]) -> u8 {
+    assert!(v.len() >= 5);
+    v[0] + v[1] + v[2] + v[3] + v[4]
+}
+
+// ok
+fn sum_with_assert_ge_other_way(v: &[u8]) -> u8 {
+    assert!(4 < v.len());
+    v[0] + v[1] + v[2] + v[3] + v[4]
+}
+
+fn sum_with_assert_lt(v: &[u8]) -> u8 {
+    assert!(v.len() < 5);
+    //~^ ERROR incorrect length
+    v[0] + v[1] + v[2] + v[3] + v[4]
+}
+
+fn sum_with_assert_le(v: &[u8]) -> u8 {
+    assert!(v.len() <= 5);
+    //~^ ERROR incorrect length
+    v[0] + v[1] + v[2] + v[3] + v[4]
+}
+
+fn sum_with_incorrect_assert_len(v: &[u8]) -> u8 {
+    assert!(v.len() > 3);
+    //~^ ERROR incorrect length
+    v[0] + v[1] + v[2] + v[3] + v[4]
+}
+
+fn sum_with_incorrect_assert_len2(v: &[u8]) -> u8 {
+    assert!(v.len() >= 4);
+    //~^ ERROR incorrect length
+    v[0] + v[1] + v[2] + v[3] + v[4]
+}
+
+// ok, don't lint for single array access
+fn single_access(v: &[u8]) -> u8 {
+    v[0]
+}
+
+// ok
+fn subslice_ok(v: &[u8]) {
+    assert!(v.len() > 3);
+    let _ = v[0];
+    let _ = v[1..4];
+}
+
+fn subslice_bad(v: &[u8]) {
+    assert!(v.len() >= 3);
+    //~^ ERROR incorrect length
+    let _ = v[0];
+    let _ = v[1..4];
+}
+
+// ok
+fn subslice_inclusive_ok(v: &[u8]) {
+    assert!(v.len() > 4);
+    let _ = v[0];
+    let _ = v[1..=4];
+}
+
+fn subslice_inclusive_bad(v: &[u8]) {
+    assert!(v.len() >= 4);
+    //~^ ERROR incorrect length
+    let _ = v[0];
+    let _ = v[1..=4];
+}
+
+fn index_different_slices_ok(v1: &[u8], v2: &[u8]) {
+    assert!(v1.len() > 12);
+    assert!(v2.len() > 15);
+    let _ = v1[0] + v1[12];
+    let _ = v2[5] + v2[15];
+}
+
+fn index_different_slices_wrong_len(v1: &[u8], v2: &[u8]) {
+    assert!(v1.len() >= 12);
+    //~^ ERROR incorrect length
+    assert!(v2.len() >= 15);
+    //~^ ERROR incorrect length
+    let _ = v1[0] + v1[12];
+    let _ = v2[5] + v2[15];
+}
+fn index_different_slices_one_wrong_len(v1: &[u8], v2: &[u8]) {
+    assert!(v1.len() >= 12);
+    //~^ ERROR incorrect length
+    assert!(v2.len() > 15);
+    let _ = v1[0] + v1[12];
+    let _ = v2[5] + v2[15];
+}
+
+fn side_effect() -> &'static [u8] {
+    &[]
+}
+
+fn index_side_effect_expr() {
+    let _ = side_effect()[0] + side_effect()[1];
+}
+
+// ok, single access for different slices
+fn index_different_slice_in_same_expr(v1: &[u8], v2: &[u8]) {
+    let _ = v1[0] + v2[1];
+}
+
+fn main() {}
diff --git a/tests/ui/missing_asserts_for_indexing.stderr b/tests/ui/missing_asserts_for_indexing.stderr
new file mode 100644
index 00000000000..b3c0ec8cf74
--- /dev/null
+++ b/tests/ui/missing_asserts_for_indexing.stderr
@@ -0,0 +1,256 @@
+error: indexing into a slice multiple times with an `assert` that does not cover the highest index
+  --> $DIR/missing_asserts_for_indexing.rs:33:5
+   |
+LL |     assert!(v.len() < 5);
+   |     -------------------- help: provide the highest index that is indexed with: `assert!(v.len() > 4)`
+LL |     //~^ ERROR incorrect length
+LL |     v[0] + v[1] + v[2] + v[3] + v[4]
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: slice indexed here
+  --> $DIR/missing_asserts_for_indexing.rs:33:5
+   |
+LL |     v[0] + v[1] + v[2] + v[3] + v[4]
+   |     ^^^^
+note: slice indexed here
+  --> $DIR/missing_asserts_for_indexing.rs:33:12
+   |
+LL |     v[0] + v[1] + v[2] + v[3] + v[4]
+   |            ^^^^
+note: slice indexed here
+  --> $DIR/missing_asserts_for_indexing.rs:33:19
+   |
+LL |     v[0] + v[1] + v[2] + v[3] + v[4]
+   |                   ^^^^
+note: slice indexed here
+  --> $DIR/missing_asserts_for_indexing.rs:33:26
+   |
+LL |     v[0] + v[1] + v[2] + v[3] + v[4]
+   |                          ^^^^
+note: slice indexed here
+  --> $DIR/missing_asserts_for_indexing.rs:33:33
+   |
+LL |     v[0] + v[1] + v[2] + v[3] + v[4]
+   |                                 ^^^^
+   = note: asserting the length before indexing will elide bounds checks
+   = note: `-D clippy::missing-asserts-for-indexing` implied by `-D warnings`
+
+error: indexing into a slice multiple times with an `assert` that does not cover the highest index
+  --> $DIR/missing_asserts_for_indexing.rs:39:5
+   |
+LL |     assert!(v.len() <= 5);
+   |     --------------------- help: provide the highest index that is indexed with: `assert!(v.len() > 4)`
+LL |     //~^ ERROR incorrect length
+LL |     v[0] + v[1] + v[2] + v[3] + v[4]
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: slice indexed here
+  --> $DIR/missing_asserts_for_indexing.rs:39:5
+   |
+LL |     v[0] + v[1] + v[2] + v[3] + v[4]
+   |     ^^^^
+note: slice indexed here
+  --> $DIR/missing_asserts_for_indexing.rs:39:12
+   |
+LL |     v[0] + v[1] + v[2] + v[3] + v[4]
+   |            ^^^^
+note: slice indexed here
+  --> $DIR/missing_asserts_for_indexing.rs:39:19
+   |
+LL |     v[0] + v[1] + v[2] + v[3] + v[4]
+   |                   ^^^^
+note: slice indexed here
+  --> $DIR/missing_asserts_for_indexing.rs:39:26
+   |
+LL |     v[0] + v[1] + v[2] + v[3] + v[4]
+   |                          ^^^^
+note: slice indexed here
+  --> $DIR/missing_asserts_for_indexing.rs:39:33
+   |
+LL |     v[0] + v[1] + v[2] + v[3] + v[4]
+   |                                 ^^^^
+   = note: asserting the length before indexing will elide bounds checks
+
+error: indexing into a slice multiple times with an `assert` that does not cover the highest index
+  --> $DIR/missing_asserts_for_indexing.rs:45:5
+   |
+LL |     assert!(v.len() > 3);
+   |     -------------------- help: provide the highest index that is indexed with: `assert!(v.len() > 4)`
+LL |     //~^ ERROR incorrect length
+LL |     v[0] + v[1] + v[2] + v[3] + v[4]
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: slice indexed here
+  --> $DIR/missing_asserts_for_indexing.rs:45:5
+   |
+LL |     v[0] + v[1] + v[2] + v[3] + v[4]
+   |     ^^^^
+note: slice indexed here
+  --> $DIR/missing_asserts_for_indexing.rs:45:12
+   |
+LL |     v[0] + v[1] + v[2] + v[3] + v[4]
+   |            ^^^^
+note: slice indexed here
+  --> $DIR/missing_asserts_for_indexing.rs:45:19
+   |
+LL |     v[0] + v[1] + v[2] + v[3] + v[4]
+   |                   ^^^^
+note: slice indexed here
+  --> $DIR/missing_asserts_for_indexing.rs:45:26
+   |
+LL |     v[0] + v[1] + v[2] + v[3] + v[4]
+   |                          ^^^^
+note: slice indexed here
+  --> $DIR/missing_asserts_for_indexing.rs:45:33
+   |
+LL |     v[0] + v[1] + v[2] + v[3] + v[4]
+   |                                 ^^^^
+   = note: asserting the length before indexing will elide bounds checks
+
+error: indexing into a slice multiple times with an `assert` that does not cover the highest index
+  --> $DIR/missing_asserts_for_indexing.rs:51:5
+   |
+LL |     assert!(v.len() >= 4);
+   |     --------------------- help: provide the highest index that is indexed with: `assert!(v.len() > 4)`
+LL |     //~^ ERROR incorrect length
+LL |     v[0] + v[1] + v[2] + v[3] + v[4]
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: slice indexed here
+  --> $DIR/missing_asserts_for_indexing.rs:51:5
+   |
+LL |     v[0] + v[1] + v[2] + v[3] + v[4]
+   |     ^^^^
+note: slice indexed here
+  --> $DIR/missing_asserts_for_indexing.rs:51:12
+   |
+LL |     v[0] + v[1] + v[2] + v[3] + v[4]
+   |            ^^^^
+note: slice indexed here
+  --> $DIR/missing_asserts_for_indexing.rs:51:19
+   |
+LL |     v[0] + v[1] + v[2] + v[3] + v[4]
+   |                   ^^^^
+note: slice indexed here
+  --> $DIR/missing_asserts_for_indexing.rs:51:26
+   |
+LL |     v[0] + v[1] + v[2] + v[3] + v[4]
+   |                          ^^^^
+note: slice indexed here
+  --> $DIR/missing_asserts_for_indexing.rs:51:33
+   |
+LL |     v[0] + v[1] + v[2] + v[3] + v[4]
+   |                                 ^^^^
+   = note: asserting the length before indexing will elide bounds checks
+
+error: indexing into a slice multiple times with an `assert` that does not cover the highest index
+  --> $DIR/missing_asserts_for_indexing.rs:69:13
+   |
+LL |       assert!(v.len() >= 3);
+   |       --------------------- help: provide the highest index that is indexed with: `assert!(v.len() > 3)`
+LL |       //~^ ERROR incorrect length
+LL |       let _ = v[0];
+   |  _____________^
+LL | |     let _ = v[1..4];
+   | |___________________^
+   |
+note: slice indexed here
+  --> $DIR/missing_asserts_for_indexing.rs:69:13
+   |
+LL |     let _ = v[0];
+   |             ^^^^
+note: slice indexed here
+  --> $DIR/missing_asserts_for_indexing.rs:70:13
+   |
+LL |     let _ = v[1..4];
+   |             ^^^^^^^
+   = note: asserting the length before indexing will elide bounds checks
+
+error: indexing into a slice multiple times with an `assert` that does not cover the highest index
+  --> $DIR/missing_asserts_for_indexing.rs:83:13
+   |
+LL |       assert!(v.len() >= 4);
+   |       --------------------- help: provide the highest index that is indexed with: `assert!(v.len() > 4)`
+LL |       //~^ ERROR incorrect length
+LL |       let _ = v[0];
+   |  _____________^
+LL | |     let _ = v[1..=4];
+   | |____________________^
+   |
+note: slice indexed here
+  --> $DIR/missing_asserts_for_indexing.rs:83:13
+   |
+LL |     let _ = v[0];
+   |             ^^^^
+note: slice indexed here
+  --> $DIR/missing_asserts_for_indexing.rs:84:13
+   |
+LL |     let _ = v[1..=4];
+   |             ^^^^^^^^
+   = note: asserting the length before indexing will elide bounds checks
+
+error: indexing into a slice multiple times with an `assert` that does not cover the highest index
+  --> $DIR/missing_asserts_for_indexing.rs:99:13
+   |
+LL |     assert!(v1.len() >= 12);
+   |     ----------------------- help: provide the highest index that is indexed with: `assert!(v1.len() > 12)`
+...
+LL |     let _ = v1[0] + v1[12];
+   |             ^^^^^^^^^^^^^^
+   |
+note: slice indexed here
+  --> $DIR/missing_asserts_for_indexing.rs:99:13
+   |
+LL |     let _ = v1[0] + v1[12];
+   |             ^^^^^
+note: slice indexed here
+  --> $DIR/missing_asserts_for_indexing.rs:99:21
+   |
+LL |     let _ = v1[0] + v1[12];
+   |                     ^^^^^^
+   = note: asserting the length before indexing will elide bounds checks
+
+error: indexing into a slice multiple times with an `assert` that does not cover the highest index
+  --> $DIR/missing_asserts_for_indexing.rs:100:13
+   |
+LL |     assert!(v2.len() >= 15);
+   |     ----------------------- help: provide the highest index that is indexed with: `assert!(v2.len() > 15)`
+...
+LL |     let _ = v2[5] + v2[15];
+   |             ^^^^^^^^^^^^^^
+   |
+note: slice indexed here
+  --> $DIR/missing_asserts_for_indexing.rs:100:13
+   |
+LL |     let _ = v2[5] + v2[15];
+   |             ^^^^^
+note: slice indexed here
+  --> $DIR/missing_asserts_for_indexing.rs:100:21
+   |
+LL |     let _ = v2[5] + v2[15];
+   |                     ^^^^^^
+   = note: asserting the length before indexing will elide bounds checks
+
+error: indexing into a slice multiple times with an `assert` that does not cover the highest index
+  --> $DIR/missing_asserts_for_indexing.rs:106:13
+   |
+LL |     assert!(v1.len() >= 12);
+   |     ----------------------- help: provide the highest index that is indexed with: `assert!(v1.len() > 12)`
+...
+LL |     let _ = v1[0] + v1[12];
+   |             ^^^^^^^^^^^^^^
+   |
+note: slice indexed here
+  --> $DIR/missing_asserts_for_indexing.rs:106:13
+   |
+LL |     let _ = v1[0] + v1[12];
+   |             ^^^^^
+note: slice indexed here
+  --> $DIR/missing_asserts_for_indexing.rs:106:21
+   |
+LL |     let _ = v1[0] + v1[12];
+   |                     ^^^^^^
+   = note: asserting the length before indexing will elide bounds checks
+
+error: aborting due to 9 previous errors
+
diff --git a/tests/ui/missing_asserts_for_indexing_unfixable.rs b/tests/ui/missing_asserts_for_indexing_unfixable.rs
new file mode 100644
index 00000000000..d157771bf7f
--- /dev/null
+++ b/tests/ui/missing_asserts_for_indexing_unfixable.rs
@@ -0,0 +1,43 @@
+#![allow(unused)]
+#![warn(clippy::missing_asserts_for_indexing)]
+
+fn sum(v: &[u8]) -> u8 {
+    //~^ ERROR missing assertions on `v.len()`
+    v[0] + v[1] + v[2] + v[3] + v[4]
+}
+
+fn subslice(v: &[u8]) {
+    //~^ ERROR missing assertion on `v.len()`
+    let _ = v[0];
+    let _ = v[1..4];
+}
+
+fn variables(v: &[u8]) -> u8 {
+    //~^ ERROR missing assertions on `v.len()`
+    let a = v[0];
+    let b = v[1];
+    let c = v[2];
+    a + b + c
+}
+
+fn index_different_slices(v1: &[u8], v2: &[u8]) {
+    let _ = v1[0] + v1[12];
+    let _ = v2[5] + v2[15];
+}
+
+fn index_different_slices2(v1: &[u8], v2: &[u8]) {
+    assert!(v1.len() > 12);
+    let _ = v1[0] + v1[12];
+    let _ = v2[5] + v2[15];
+}
+
+struct Foo<'a> {
+    v: &'a [u8],
+}
+
+fn index_struct_field(f: &Foo<'_>) {
+    //~^ ERROR missing assertion on `f.v.len()`
+    let _ = f.v[0] + f.v[1];
+}
+
+fn main() {}
diff --git a/tests/ui/missing_asserts_for_indexing_unfixable.stderr b/tests/ui/missing_asserts_for_indexing_unfixable.stderr
new file mode 100644
index 00000000000..c18620f105d
--- /dev/null
+++ b/tests/ui/missing_asserts_for_indexing_unfixable.stderr
@@ -0,0 +1,161 @@
+error: indexing into a slice multiple times without an `assert`
+  --> $DIR/missing_asserts_for_indexing_unfixable.rs:6:5
+   |
+LL |     v[0] + v[1] + v[2] + v[3] + v[4]
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider asserting the length before indexing: `assert!(v.len() > 4);`
+note: slice indexed here
+  --> $DIR/missing_asserts_for_indexing_unfixable.rs:6:5
+   |
+LL |     v[0] + v[1] + v[2] + v[3] + v[4]
+   |     ^^^^
+note: slice indexed here
+  --> $DIR/missing_asserts_for_indexing_unfixable.rs:6:12
+   |
+LL |     v[0] + v[1] + v[2] + v[3] + v[4]
+   |            ^^^^
+note: slice indexed here
+  --> $DIR/missing_asserts_for_indexing_unfixable.rs:6:19
+   |
+LL |     v[0] + v[1] + v[2] + v[3] + v[4]
+   |                   ^^^^
+note: slice indexed here
+  --> $DIR/missing_asserts_for_indexing_unfixable.rs:6:26
+   |
+LL |     v[0] + v[1] + v[2] + v[3] + v[4]
+   |                          ^^^^
+note: slice indexed here
+  --> $DIR/missing_asserts_for_indexing_unfixable.rs:6:33
+   |
+LL |     v[0] + v[1] + v[2] + v[3] + v[4]
+   |                                 ^^^^
+   = note: asserting the length before indexing will elide bounds checks
+   = note: `-D clippy::missing-asserts-for-indexing` implied by `-D warnings`
+
+error: indexing into a slice multiple times without an `assert`
+  --> $DIR/missing_asserts_for_indexing_unfixable.rs:11:13
+   |
+LL |       let _ = v[0];
+   |  _____________^
+LL | |     let _ = v[1..4];
+   | |___________________^
+   |
+   = help: consider asserting the length before indexing: `assert!(v.len() > 3);`
+note: slice indexed here
+  --> $DIR/missing_asserts_for_indexing_unfixable.rs:11:13
+   |
+LL |     let _ = v[0];
+   |             ^^^^
+note: slice indexed here
+  --> $DIR/missing_asserts_for_indexing_unfixable.rs:12:13
+   |
+LL |     let _ = v[1..4];
+   |             ^^^^^^^
+   = note: asserting the length before indexing will elide bounds checks
+
+error: indexing into a slice multiple times without an `assert`
+  --> $DIR/missing_asserts_for_indexing_unfixable.rs:17:13
+   |
+LL |       let a = v[0];
+   |  _____________^
+LL | |     let b = v[1];
+LL | |     let c = v[2];
+   | |________________^
+   |
+   = help: consider asserting the length before indexing: `assert!(v.len() > 2);`
+note: slice indexed here
+  --> $DIR/missing_asserts_for_indexing_unfixable.rs:17:13
+   |
+LL |     let a = v[0];
+   |             ^^^^
+note: slice indexed here
+  --> $DIR/missing_asserts_for_indexing_unfixable.rs:18:13
+   |
+LL |     let b = v[1];
+   |             ^^^^
+note: slice indexed here
+  --> $DIR/missing_asserts_for_indexing_unfixable.rs:19:13
+   |
+LL |     let c = v[2];
+   |             ^^^^
+   = note: asserting the length before indexing will elide bounds checks
+
+error: indexing into a slice multiple times without an `assert`
+  --> $DIR/missing_asserts_for_indexing_unfixable.rs:24:13
+   |
+LL |     let _ = v1[0] + v1[12];
+   |             ^^^^^^^^^^^^^^
+   |
+   = help: consider asserting the length before indexing: `assert!(v1.len() > 12);`
+note: slice indexed here
+  --> $DIR/missing_asserts_for_indexing_unfixable.rs:24:13
+   |
+LL |     let _ = v1[0] + v1[12];
+   |             ^^^^^
+note: slice indexed here
+  --> $DIR/missing_asserts_for_indexing_unfixable.rs:24:21
+   |
+LL |     let _ = v1[0] + v1[12];
+   |                     ^^^^^^
+   = note: asserting the length before indexing will elide bounds checks
+
+error: indexing into a slice multiple times without an `assert`
+  --> $DIR/missing_asserts_for_indexing_unfixable.rs:25:13
+   |
+LL |     let _ = v2[5] + v2[15];
+   |             ^^^^^^^^^^^^^^
+   |
+   = help: consider asserting the length before indexing: `assert!(v2.len() > 15);`
+note: slice indexed here
+  --> $DIR/missing_asserts_for_indexing_unfixable.rs:25:13
+   |
+LL |     let _ = v2[5] + v2[15];
+   |             ^^^^^
+note: slice indexed here
+  --> $DIR/missing_asserts_for_indexing_unfixable.rs:25:21
+   |
+LL |     let _ = v2[5] + v2[15];
+   |                     ^^^^^^
+   = note: asserting the length before indexing will elide bounds checks
+
+error: indexing into a slice multiple times without an `assert`
+  --> $DIR/missing_asserts_for_indexing_unfixable.rs:31:13
+   |
+LL |     let _ = v2[5] + v2[15];
+   |             ^^^^^^^^^^^^^^
+   |
+   = help: consider asserting the length before indexing: `assert!(v2.len() > 15);`
+note: slice indexed here
+  --> $DIR/missing_asserts_for_indexing_unfixable.rs:31:13
+   |
+LL |     let _ = v2[5] + v2[15];
+   |             ^^^^^
+note: slice indexed here
+  --> $DIR/missing_asserts_for_indexing_unfixable.rs:31:21
+   |
+LL |     let _ = v2[5] + v2[15];
+   |                     ^^^^^^
+   = note: asserting the length before indexing will elide bounds checks
+
+error: indexing into a slice multiple times without an `assert`
+  --> $DIR/missing_asserts_for_indexing_unfixable.rs:40:13
+   |
+LL |     let _ = f.v[0] + f.v[1];
+   |             ^^^^^^^^^^^^^^^
+   |
+   = help: consider asserting the length before indexing: `assert!(f.v.len() > 1);`
+note: slice indexed here
+  --> $DIR/missing_asserts_for_indexing_unfixable.rs:40:13
+   |
+LL |     let _ = f.v[0] + f.v[1];
+   |             ^^^^^^
+note: slice indexed here
+  --> $DIR/missing_asserts_for_indexing_unfixable.rs:40:22
+   |
+LL |     let _ = f.v[0] + f.v[1];
+   |                      ^^^^^^
+   = note: asserting the length before indexing will elide bounds checks
+
+error: aborting due to 7 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 790922c5d6de7ed8e8f6f53a04e8afc005ac3bd4 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Thu, 31 Aug 2023 18:42:27 +0200
Subject: update ui tests and some minor cleanups

---
 clippy_lints/src/missing_asserts_for_indexing.rs   | 24 +++---
 tests/ui/missing_asserts_for_indexing.fixed        | 20 +++--
 tests/ui/missing_asserts_for_indexing.rs           | 20 +++--
 tests/ui/missing_asserts_for_indexing.stderr       | 90 +++++++++++-----------
 tests/ui/missing_asserts_for_indexing_unfixable.rs | 14 +++-
 .../missing_asserts_for_indexing_unfixable.stderr  | 22 +++---
 6 files changed, 94 insertions(+), 96 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/missing_asserts_for_indexing.rs b/clippy_lints/src/missing_asserts_for_indexing.rs
index 03587a90707..08fec2b8ec8 100644
--- a/clippy_lints/src/missing_asserts_for_indexing.rs
+++ b/clippy_lints/src/missing_asserts_for_indexing.rs
@@ -1,14 +1,11 @@
 use std::mem;
 use std::ops::ControlFlow;
 
-use clippy_utils::eq_expr_value;
+use clippy_utils::comparisons::{normalize_comparison, Rel};
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet;
-use clippy_utils::{
-    comparisons::{normalize_comparison, Rel},
-    diagnostics::span_lint_and_then,
-    hash_expr, higher,
-    visitors::for_each_expr,
-};
+use clippy_utils::visitors::for_each_expr;
+use clippy_utils::{eq_expr_value, hash_expr, higher};
 use rustc_ast::{LitKind, RangeLimits};
 use rustc_data_structures::unhash::UnhashMap;
 use rustc_errors::{Applicability, Diagnostic};
@@ -220,13 +217,13 @@ fn upper_index_expr(expr: &Expr<'_>) -> Option<usize> {
 
 /// Checks if the expression is an index into a slice and adds it to `indexes`
 fn check_index<'hir>(cx: &LateContext<'_>, expr: &'hir Expr<'hir>, map: &mut UnhashMap<u64, Vec<IndexEntry<'hir>>>) {
-    if let ExprKind::Index(slice, index_lit) = expr.kind
+    if let ExprKind::Index(slice, index_lit, _) = expr.kind
         && cx.typeck_results().expr_ty_adjusted(slice).peel_refs().is_slice()
         && let Some(index) = upper_index_expr(index_lit)
     {
         let hash = hash_expr(cx, slice);
 
-        let indexes = map.entry(hash).or_insert_with(Vec::new);
+        let indexes = map.entry(hash).or_default();
         let entry = indexes.iter_mut().find(|entry| eq_expr_value(cx, entry.slice(), slice));
 
         if let Some(entry) = entry {
@@ -261,7 +258,7 @@ fn check_index<'hir>(cx: &LateContext<'_>, expr: &'hir Expr<'hir>, map: &mut Unh
 fn check_assert<'hir>(cx: &LateContext<'_>, expr: &'hir Expr<'hir>, map: &mut UnhashMap<u64, Vec<IndexEntry<'hir>>>) {
     if let Some((comparison, asserted_len, slice)) = assert_len_expr(cx, expr) {
         let hash = hash_expr(cx, slice);
-        let indexes = map.entry(hash).or_insert_with(Vec::new);
+        let indexes = map.entry(hash).or_default();
 
         let entry = indexes.iter_mut().find(|entry| eq_expr_value(cx, entry.slice(), slice));
 
@@ -301,9 +298,10 @@ fn report_indexes(cx: &LateContext<'_>, map: &UnhashMap<u64, Vec<IndexEntry<'_>>
             let Some(full_span) = entry
                 .index_spans()
                 .and_then(|spans| spans.first().zip(spans.last()))
-                .map(|(low, &high)| low.to(high)) else {
-                    continue;
-                };
+                .map(|(low, &high)| low.to(high))
+            else {
+                continue;
+            };
 
             match entry {
                 IndexEntry::AssertWithIndex {
diff --git a/tests/ui/missing_asserts_for_indexing.fixed b/tests/ui/missing_asserts_for_indexing.fixed
index 0dee4d76db5..a96827259f5 100644
--- a/tests/ui/missing_asserts_for_indexing.fixed
+++ b/tests/ui/missing_asserts_for_indexing.fixed
@@ -1,5 +1,3 @@
-//@run-rustfix
-
 #![allow(unused)]
 #![warn(clippy::missing_asserts_for_indexing)]
 
@@ -29,26 +27,26 @@ fn sum_with_assert_ge_other_way(v: &[u8]) -> u8 {
 
 fn sum_with_assert_lt(v: &[u8]) -> u8 {
     assert!(v.len() > 4);
-    //~^ ERROR incorrect length
     v[0] + v[1] + v[2] + v[3] + v[4]
+    //~^ ERROR: indexing into a slice multiple times with an `assert` that does not cover the
 }
 
 fn sum_with_assert_le(v: &[u8]) -> u8 {
     assert!(v.len() > 4);
-    //~^ ERROR incorrect length
     v[0] + v[1] + v[2] + v[3] + v[4]
+    //~^ ERROR: indexing into a slice multiple times with an `assert` that does not cover the
 }
 
 fn sum_with_incorrect_assert_len(v: &[u8]) -> u8 {
     assert!(v.len() > 4);
-    //~^ ERROR incorrect length
     v[0] + v[1] + v[2] + v[3] + v[4]
+    //~^ ERROR: indexing into a slice multiple times with an `assert` that does not cover the
 }
 
 fn sum_with_incorrect_assert_len2(v: &[u8]) -> u8 {
     assert!(v.len() > 4);
-    //~^ ERROR incorrect length
     v[0] + v[1] + v[2] + v[3] + v[4]
+    //~^ ERROR: indexing into a slice multiple times with an `assert` that does not cover the
 }
 
 // ok, don't lint for single array access
@@ -65,8 +63,8 @@ fn subslice_ok(v: &[u8]) {
 
 fn subslice_bad(v: &[u8]) {
     assert!(v.len() > 3);
-    //~^ ERROR incorrect length
     let _ = v[0];
+    //~^ ERROR: indexing into a slice multiple times with an `assert` that does not cover the
     let _ = v[1..4];
 }
 
@@ -79,8 +77,8 @@ fn subslice_inclusive_ok(v: &[u8]) {
 
 fn subslice_inclusive_bad(v: &[u8]) {
     assert!(v.len() > 4);
-    //~^ ERROR incorrect length
     let _ = v[0];
+    //~^ ERROR: indexing into a slice multiple times with an `assert` that does not cover the
     let _ = v[1..=4];
 }
 
@@ -93,17 +91,17 @@ fn index_different_slices_ok(v1: &[u8], v2: &[u8]) {
 
 fn index_different_slices_wrong_len(v1: &[u8], v2: &[u8]) {
     assert!(v1.len() > 12);
-    //~^ ERROR incorrect length
     assert!(v2.len() > 15);
-    //~^ ERROR incorrect length
     let _ = v1[0] + v1[12];
+    //~^ ERROR: indexing into a slice multiple times with an `assert` that does not cover the
     let _ = v2[5] + v2[15];
+    //~^ ERROR: indexing into a slice multiple times with an `assert` that does not cover the
 }
 fn index_different_slices_one_wrong_len(v1: &[u8], v2: &[u8]) {
     assert!(v1.len() > 12);
-    //~^ ERROR incorrect length
     assert!(v2.len() > 15);
     let _ = v1[0] + v1[12];
+    //~^ ERROR: indexing into a slice multiple times with an `assert` that does not cover the
     let _ = v2[5] + v2[15];
 }
 
diff --git a/tests/ui/missing_asserts_for_indexing.rs b/tests/ui/missing_asserts_for_indexing.rs
index cddf82434a6..0b4b883acf8 100644
--- a/tests/ui/missing_asserts_for_indexing.rs
+++ b/tests/ui/missing_asserts_for_indexing.rs
@@ -1,5 +1,3 @@
-//@run-rustfix
-
 #![allow(unused)]
 #![warn(clippy::missing_asserts_for_indexing)]
 
@@ -29,26 +27,26 @@ fn sum_with_assert_ge_other_way(v: &[u8]) -> u8 {
 
 fn sum_with_assert_lt(v: &[u8]) -> u8 {
     assert!(v.len() < 5);
-    //~^ ERROR incorrect length
     v[0] + v[1] + v[2] + v[3] + v[4]
+    //~^ ERROR: indexing into a slice multiple times with an `assert` that does not cover the
 }
 
 fn sum_with_assert_le(v: &[u8]) -> u8 {
     assert!(v.len() <= 5);
-    //~^ ERROR incorrect length
     v[0] + v[1] + v[2] + v[3] + v[4]
+    //~^ ERROR: indexing into a slice multiple times with an `assert` that does not cover the
 }
 
 fn sum_with_incorrect_assert_len(v: &[u8]) -> u8 {
     assert!(v.len() > 3);
-    //~^ ERROR incorrect length
     v[0] + v[1] + v[2] + v[3] + v[4]
+    //~^ ERROR: indexing into a slice multiple times with an `assert` that does not cover the
 }
 
 fn sum_with_incorrect_assert_len2(v: &[u8]) -> u8 {
     assert!(v.len() >= 4);
-    //~^ ERROR incorrect length
     v[0] + v[1] + v[2] + v[3] + v[4]
+    //~^ ERROR: indexing into a slice multiple times with an `assert` that does not cover the
 }
 
 // ok, don't lint for single array access
@@ -65,8 +63,8 @@ fn subslice_ok(v: &[u8]) {
 
 fn subslice_bad(v: &[u8]) {
     assert!(v.len() >= 3);
-    //~^ ERROR incorrect length
     let _ = v[0];
+    //~^ ERROR: indexing into a slice multiple times with an `assert` that does not cover the
     let _ = v[1..4];
 }
 
@@ -79,8 +77,8 @@ fn subslice_inclusive_ok(v: &[u8]) {
 
 fn subslice_inclusive_bad(v: &[u8]) {
     assert!(v.len() >= 4);
-    //~^ ERROR incorrect length
     let _ = v[0];
+    //~^ ERROR: indexing into a slice multiple times with an `assert` that does not cover the
     let _ = v[1..=4];
 }
 
@@ -93,17 +91,17 @@ fn index_different_slices_ok(v1: &[u8], v2: &[u8]) {
 
 fn index_different_slices_wrong_len(v1: &[u8], v2: &[u8]) {
     assert!(v1.len() >= 12);
-    //~^ ERROR incorrect length
     assert!(v2.len() >= 15);
-    //~^ ERROR incorrect length
     let _ = v1[0] + v1[12];
+    //~^ ERROR: indexing into a slice multiple times with an `assert` that does not cover the
     let _ = v2[5] + v2[15];
+    //~^ ERROR: indexing into a slice multiple times with an `assert` that does not cover the
 }
 fn index_different_slices_one_wrong_len(v1: &[u8], v2: &[u8]) {
     assert!(v1.len() >= 12);
-    //~^ ERROR incorrect length
     assert!(v2.len() > 15);
     let _ = v1[0] + v1[12];
+    //~^ ERROR: indexing into a slice multiple times with an `assert` that does not cover the
     let _ = v2[5] + v2[15];
 }
 
diff --git a/tests/ui/missing_asserts_for_indexing.stderr b/tests/ui/missing_asserts_for_indexing.stderr
index b3c0ec8cf74..75eb4a35cd4 100644
--- a/tests/ui/missing_asserts_for_indexing.stderr
+++ b/tests/ui/missing_asserts_for_indexing.stderr
@@ -1,34 +1,33 @@
 error: indexing into a slice multiple times with an `assert` that does not cover the highest index
-  --> $DIR/missing_asserts_for_indexing.rs:33:5
+  --> $DIR/missing_asserts_for_indexing.rs:30:5
    |
 LL |     assert!(v.len() < 5);
    |     -------------------- help: provide the highest index that is indexed with: `assert!(v.len() > 4)`
-LL |     //~^ ERROR incorrect length
 LL |     v[0] + v[1] + v[2] + v[3] + v[4]
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: slice indexed here
-  --> $DIR/missing_asserts_for_indexing.rs:33:5
+  --> $DIR/missing_asserts_for_indexing.rs:30:5
    |
 LL |     v[0] + v[1] + v[2] + v[3] + v[4]
    |     ^^^^
 note: slice indexed here
-  --> $DIR/missing_asserts_for_indexing.rs:33:12
+  --> $DIR/missing_asserts_for_indexing.rs:30:12
    |
 LL |     v[0] + v[1] + v[2] + v[3] + v[4]
    |            ^^^^
 note: slice indexed here
-  --> $DIR/missing_asserts_for_indexing.rs:33:19
+  --> $DIR/missing_asserts_for_indexing.rs:30:19
    |
 LL |     v[0] + v[1] + v[2] + v[3] + v[4]
    |                   ^^^^
 note: slice indexed here
-  --> $DIR/missing_asserts_for_indexing.rs:33:26
+  --> $DIR/missing_asserts_for_indexing.rs:30:26
    |
 LL |     v[0] + v[1] + v[2] + v[3] + v[4]
    |                          ^^^^
 note: slice indexed here
-  --> $DIR/missing_asserts_for_indexing.rs:33:33
+  --> $DIR/missing_asserts_for_indexing.rs:30:33
    |
 LL |     v[0] + v[1] + v[2] + v[3] + v[4]
    |                                 ^^^^
@@ -36,182 +35,179 @@ LL |     v[0] + v[1] + v[2] + v[3] + v[4]
    = note: `-D clippy::missing-asserts-for-indexing` implied by `-D warnings`
 
 error: indexing into a slice multiple times with an `assert` that does not cover the highest index
-  --> $DIR/missing_asserts_for_indexing.rs:39:5
+  --> $DIR/missing_asserts_for_indexing.rs:36:5
    |
 LL |     assert!(v.len() <= 5);
    |     --------------------- help: provide the highest index that is indexed with: `assert!(v.len() > 4)`
-LL |     //~^ ERROR incorrect length
 LL |     v[0] + v[1] + v[2] + v[3] + v[4]
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: slice indexed here
-  --> $DIR/missing_asserts_for_indexing.rs:39:5
+  --> $DIR/missing_asserts_for_indexing.rs:36:5
    |
 LL |     v[0] + v[1] + v[2] + v[3] + v[4]
    |     ^^^^
 note: slice indexed here
-  --> $DIR/missing_asserts_for_indexing.rs:39:12
+  --> $DIR/missing_asserts_for_indexing.rs:36:12
    |
 LL |     v[0] + v[1] + v[2] + v[3] + v[4]
    |            ^^^^
 note: slice indexed here
-  --> $DIR/missing_asserts_for_indexing.rs:39:19
+  --> $DIR/missing_asserts_for_indexing.rs:36:19
    |
 LL |     v[0] + v[1] + v[2] + v[3] + v[4]
    |                   ^^^^
 note: slice indexed here
-  --> $DIR/missing_asserts_for_indexing.rs:39:26
+  --> $DIR/missing_asserts_for_indexing.rs:36:26
    |
 LL |     v[0] + v[1] + v[2] + v[3] + v[4]
    |                          ^^^^
 note: slice indexed here
-  --> $DIR/missing_asserts_for_indexing.rs:39:33
+  --> $DIR/missing_asserts_for_indexing.rs:36:33
    |
 LL |     v[0] + v[1] + v[2] + v[3] + v[4]
    |                                 ^^^^
    = note: asserting the length before indexing will elide bounds checks
 
 error: indexing into a slice multiple times with an `assert` that does not cover the highest index
-  --> $DIR/missing_asserts_for_indexing.rs:45:5
+  --> $DIR/missing_asserts_for_indexing.rs:42:5
    |
 LL |     assert!(v.len() > 3);
    |     -------------------- help: provide the highest index that is indexed with: `assert!(v.len() > 4)`
-LL |     //~^ ERROR incorrect length
 LL |     v[0] + v[1] + v[2] + v[3] + v[4]
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: slice indexed here
-  --> $DIR/missing_asserts_for_indexing.rs:45:5
+  --> $DIR/missing_asserts_for_indexing.rs:42:5
    |
 LL |     v[0] + v[1] + v[2] + v[3] + v[4]
    |     ^^^^
 note: slice indexed here
-  --> $DIR/missing_asserts_for_indexing.rs:45:12
+  --> $DIR/missing_asserts_for_indexing.rs:42:12
    |
 LL |     v[0] + v[1] + v[2] + v[3] + v[4]
    |            ^^^^
 note: slice indexed here
-  --> $DIR/missing_asserts_for_indexing.rs:45:19
+  --> $DIR/missing_asserts_for_indexing.rs:42:19
    |
 LL |     v[0] + v[1] + v[2] + v[3] + v[4]
    |                   ^^^^
 note: slice indexed here
-  --> $DIR/missing_asserts_for_indexing.rs:45:26
+  --> $DIR/missing_asserts_for_indexing.rs:42:26
    |
 LL |     v[0] + v[1] + v[2] + v[3] + v[4]
    |                          ^^^^
 note: slice indexed here
-  --> $DIR/missing_asserts_for_indexing.rs:45:33
+  --> $DIR/missing_asserts_for_indexing.rs:42:33
    |
 LL |     v[0] + v[1] + v[2] + v[3] + v[4]
    |                                 ^^^^
    = note: asserting the length before indexing will elide bounds checks
 
 error: indexing into a slice multiple times with an `assert` that does not cover the highest index
-  --> $DIR/missing_asserts_for_indexing.rs:51:5
+  --> $DIR/missing_asserts_for_indexing.rs:48:5
    |
 LL |     assert!(v.len() >= 4);
    |     --------------------- help: provide the highest index that is indexed with: `assert!(v.len() > 4)`
-LL |     //~^ ERROR incorrect length
 LL |     v[0] + v[1] + v[2] + v[3] + v[4]
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: slice indexed here
-  --> $DIR/missing_asserts_for_indexing.rs:51:5
+  --> $DIR/missing_asserts_for_indexing.rs:48:5
    |
 LL |     v[0] + v[1] + v[2] + v[3] + v[4]
    |     ^^^^
 note: slice indexed here
-  --> $DIR/missing_asserts_for_indexing.rs:51:12
+  --> $DIR/missing_asserts_for_indexing.rs:48:12
    |
 LL |     v[0] + v[1] + v[2] + v[3] + v[4]
    |            ^^^^
 note: slice indexed here
-  --> $DIR/missing_asserts_for_indexing.rs:51:19
+  --> $DIR/missing_asserts_for_indexing.rs:48:19
    |
 LL |     v[0] + v[1] + v[2] + v[3] + v[4]
    |                   ^^^^
 note: slice indexed here
-  --> $DIR/missing_asserts_for_indexing.rs:51:26
+  --> $DIR/missing_asserts_for_indexing.rs:48:26
    |
 LL |     v[0] + v[1] + v[2] + v[3] + v[4]
    |                          ^^^^
 note: slice indexed here
-  --> $DIR/missing_asserts_for_indexing.rs:51:33
+  --> $DIR/missing_asserts_for_indexing.rs:48:33
    |
 LL |     v[0] + v[1] + v[2] + v[3] + v[4]
    |                                 ^^^^
    = note: asserting the length before indexing will elide bounds checks
 
 error: indexing into a slice multiple times with an `assert` that does not cover the highest index
-  --> $DIR/missing_asserts_for_indexing.rs:69:13
+  --> $DIR/missing_asserts_for_indexing.rs:66:13
    |
 LL |       assert!(v.len() >= 3);
    |       --------------------- help: provide the highest index that is indexed with: `assert!(v.len() > 3)`
-LL |       //~^ ERROR incorrect length
 LL |       let _ = v[0];
    |  _____________^
+LL | |
 LL | |     let _ = v[1..4];
    | |___________________^
    |
 note: slice indexed here
-  --> $DIR/missing_asserts_for_indexing.rs:69:13
+  --> $DIR/missing_asserts_for_indexing.rs:66:13
    |
 LL |     let _ = v[0];
    |             ^^^^
 note: slice indexed here
-  --> $DIR/missing_asserts_for_indexing.rs:70:13
+  --> $DIR/missing_asserts_for_indexing.rs:68:13
    |
 LL |     let _ = v[1..4];
    |             ^^^^^^^
    = note: asserting the length before indexing will elide bounds checks
 
 error: indexing into a slice multiple times with an `assert` that does not cover the highest index
-  --> $DIR/missing_asserts_for_indexing.rs:83:13
+  --> $DIR/missing_asserts_for_indexing.rs:80:13
    |
 LL |       assert!(v.len() >= 4);
    |       --------------------- help: provide the highest index that is indexed with: `assert!(v.len() > 4)`
-LL |       //~^ ERROR incorrect length
 LL |       let _ = v[0];
    |  _____________^
+LL | |
 LL | |     let _ = v[1..=4];
    | |____________________^
    |
 note: slice indexed here
-  --> $DIR/missing_asserts_for_indexing.rs:83:13
+  --> $DIR/missing_asserts_for_indexing.rs:80:13
    |
 LL |     let _ = v[0];
    |             ^^^^
 note: slice indexed here
-  --> $DIR/missing_asserts_for_indexing.rs:84:13
+  --> $DIR/missing_asserts_for_indexing.rs:82:13
    |
 LL |     let _ = v[1..=4];
    |             ^^^^^^^^
    = note: asserting the length before indexing will elide bounds checks
 
 error: indexing into a slice multiple times with an `assert` that does not cover the highest index
-  --> $DIR/missing_asserts_for_indexing.rs:99:13
+  --> $DIR/missing_asserts_for_indexing.rs:95:13
    |
 LL |     assert!(v1.len() >= 12);
    |     ----------------------- help: provide the highest index that is indexed with: `assert!(v1.len() > 12)`
-...
+LL |     assert!(v2.len() >= 15);
 LL |     let _ = v1[0] + v1[12];
    |             ^^^^^^^^^^^^^^
    |
 note: slice indexed here
-  --> $DIR/missing_asserts_for_indexing.rs:99:13
+  --> $DIR/missing_asserts_for_indexing.rs:95:13
    |
 LL |     let _ = v1[0] + v1[12];
    |             ^^^^^
 note: slice indexed here
-  --> $DIR/missing_asserts_for_indexing.rs:99:21
+  --> $DIR/missing_asserts_for_indexing.rs:95:21
    |
 LL |     let _ = v1[0] + v1[12];
    |                     ^^^^^^
    = note: asserting the length before indexing will elide bounds checks
 
 error: indexing into a slice multiple times with an `assert` that does not cover the highest index
-  --> $DIR/missing_asserts_for_indexing.rs:100:13
+  --> $DIR/missing_asserts_for_indexing.rs:97:13
    |
 LL |     assert!(v2.len() >= 15);
    |     ----------------------- help: provide the highest index that is indexed with: `assert!(v2.len() > 15)`
@@ -220,33 +216,33 @@ LL |     let _ = v2[5] + v2[15];
    |             ^^^^^^^^^^^^^^
    |
 note: slice indexed here
-  --> $DIR/missing_asserts_for_indexing.rs:100:13
+  --> $DIR/missing_asserts_for_indexing.rs:97:13
    |
 LL |     let _ = v2[5] + v2[15];
    |             ^^^^^
 note: slice indexed here
-  --> $DIR/missing_asserts_for_indexing.rs:100:21
+  --> $DIR/missing_asserts_for_indexing.rs:97:21
    |
 LL |     let _ = v2[5] + v2[15];
    |                     ^^^^^^
    = note: asserting the length before indexing will elide bounds checks
 
 error: indexing into a slice multiple times with an `assert` that does not cover the highest index
-  --> $DIR/missing_asserts_for_indexing.rs:106:13
+  --> $DIR/missing_asserts_for_indexing.rs:103:13
    |
 LL |     assert!(v1.len() >= 12);
    |     ----------------------- help: provide the highest index that is indexed with: `assert!(v1.len() > 12)`
-...
+LL |     assert!(v2.len() > 15);
 LL |     let _ = v1[0] + v1[12];
    |             ^^^^^^^^^^^^^^
    |
 note: slice indexed here
-  --> $DIR/missing_asserts_for_indexing.rs:106:13
+  --> $DIR/missing_asserts_for_indexing.rs:103:13
    |
 LL |     let _ = v1[0] + v1[12];
    |             ^^^^^
 note: slice indexed here
-  --> $DIR/missing_asserts_for_indexing.rs:106:21
+  --> $DIR/missing_asserts_for_indexing.rs:103:21
    |
 LL |     let _ = v1[0] + v1[12];
    |                     ^^^^^^
diff --git a/tests/ui/missing_asserts_for_indexing_unfixable.rs b/tests/ui/missing_asserts_for_indexing_unfixable.rs
index d157771bf7f..4346ed892f2 100644
--- a/tests/ui/missing_asserts_for_indexing_unfixable.rs
+++ b/tests/ui/missing_asserts_for_indexing_unfixable.rs
@@ -2,19 +2,19 @@
 #![warn(clippy::missing_asserts_for_indexing)]
 
 fn sum(v: &[u8]) -> u8 {
-    //~^ ERROR missing assertions on `v.len()`
     v[0] + v[1] + v[2] + v[3] + v[4]
+    //~^ ERROR: indexing into a slice multiple times without an `assert`
 }
 
 fn subslice(v: &[u8]) {
-    //~^ ERROR missing assertion on `v.len()`
     let _ = v[0];
+    //~^ ERROR: indexing into a slice multiple times without an `assert`
     let _ = v[1..4];
 }
 
 fn variables(v: &[u8]) -> u8 {
-    //~^ ERROR missing assertions on `v.len()`
     let a = v[0];
+    //~^ ERROR: indexing into a slice multiple times without an `assert`
     let b = v[1];
     let c = v[2];
     a + b + c
@@ -33,11 +33,17 @@ fn index_different_slices2(v1: &[u8], v2: &[u8]) {
 
 struct Foo<'a> {
     v: &'a [u8],
+    v2: &'a [u8],
 }
 
 fn index_struct_field(f: &Foo<'_>) {
-    //~^ ERROR missing assertion on `f.v.len()`
     let _ = f.v[0] + f.v[1];
+    //~^ ERROR: indexing into a slice multiple times without an `assert`
+}
+
+fn index_struct_different_fields(f: &Foo<'_>) {
+    // ok, different fields
+    let _ = f.v[0] + f.v2[1];
 }
 
 fn main() {}
diff --git a/tests/ui/missing_asserts_for_indexing_unfixable.stderr b/tests/ui/missing_asserts_for_indexing_unfixable.stderr
index c18620f105d..a26524d9a11 100644
--- a/tests/ui/missing_asserts_for_indexing_unfixable.stderr
+++ b/tests/ui/missing_asserts_for_indexing_unfixable.stderr
@@ -1,32 +1,32 @@
 error: indexing into a slice multiple times without an `assert`
-  --> $DIR/missing_asserts_for_indexing_unfixable.rs:6:5
+  --> $DIR/missing_asserts_for_indexing_unfixable.rs:5:5
    |
 LL |     v[0] + v[1] + v[2] + v[3] + v[4]
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: consider asserting the length before indexing: `assert!(v.len() > 4);`
 note: slice indexed here
-  --> $DIR/missing_asserts_for_indexing_unfixable.rs:6:5
+  --> $DIR/missing_asserts_for_indexing_unfixable.rs:5:5
    |
 LL |     v[0] + v[1] + v[2] + v[3] + v[4]
    |     ^^^^
 note: slice indexed here
-  --> $DIR/missing_asserts_for_indexing_unfixable.rs:6:12
+  --> $DIR/missing_asserts_for_indexing_unfixable.rs:5:12
    |
 LL |     v[0] + v[1] + v[2] + v[3] + v[4]
    |            ^^^^
 note: slice indexed here
-  --> $DIR/missing_asserts_for_indexing_unfixable.rs:6:19
+  --> $DIR/missing_asserts_for_indexing_unfixable.rs:5:19
    |
 LL |     v[0] + v[1] + v[2] + v[3] + v[4]
    |                   ^^^^
 note: slice indexed here
-  --> $DIR/missing_asserts_for_indexing_unfixable.rs:6:26
+  --> $DIR/missing_asserts_for_indexing_unfixable.rs:5:26
    |
 LL |     v[0] + v[1] + v[2] + v[3] + v[4]
    |                          ^^^^
 note: slice indexed here
-  --> $DIR/missing_asserts_for_indexing_unfixable.rs:6:33
+  --> $DIR/missing_asserts_for_indexing_unfixable.rs:5:33
    |
 LL |     v[0] + v[1] + v[2] + v[3] + v[4]
    |                                 ^^^^
@@ -34,16 +34,17 @@ LL |     v[0] + v[1] + v[2] + v[3] + v[4]
    = note: `-D clippy::missing-asserts-for-indexing` implied by `-D warnings`
 
 error: indexing into a slice multiple times without an `assert`
-  --> $DIR/missing_asserts_for_indexing_unfixable.rs:11:13
+  --> $DIR/missing_asserts_for_indexing_unfixable.rs:10:13
    |
 LL |       let _ = v[0];
    |  _____________^
+LL | |
 LL | |     let _ = v[1..4];
    | |___________________^
    |
    = help: consider asserting the length before indexing: `assert!(v.len() > 3);`
 note: slice indexed here
-  --> $DIR/missing_asserts_for_indexing_unfixable.rs:11:13
+  --> $DIR/missing_asserts_for_indexing_unfixable.rs:10:13
    |
 LL |     let _ = v[0];
    |             ^^^^
@@ -55,17 +56,18 @@ LL |     let _ = v[1..4];
    = note: asserting the length before indexing will elide bounds checks
 
 error: indexing into a slice multiple times without an `assert`
-  --> $DIR/missing_asserts_for_indexing_unfixable.rs:17:13
+  --> $DIR/missing_asserts_for_indexing_unfixable.rs:16:13
    |
 LL |       let a = v[0];
    |  _____________^
+LL | |
 LL | |     let b = v[1];
 LL | |     let c = v[2];
    | |________________^
    |
    = help: consider asserting the length before indexing: `assert!(v.len() > 2);`
 note: slice indexed here
-  --> $DIR/missing_asserts_for_indexing_unfixable.rs:17:13
+  --> $DIR/missing_asserts_for_indexing_unfixable.rs:16:13
    |
 LL |     let a = v[0];
    |             ^^^^
-- 
cgit 1.4.1-3-g733a5


From f595f1e0ffde3dd371b734f10690e995dfaae518 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Sun, 27 Aug 2023 13:55:55 +0000
Subject: Use multipart suggestions for raw string lints

---
 clippy_lints/src/raw_strings.rs            |  80 ++++++++++++----
 tests/ui/needless_raw_string.fixed         |  13 ++-
 tests/ui/needless_raw_string.rs            |  13 ++-
 tests/ui/needless_raw_string.stderr        |  48 +++++++++-
 tests/ui/needless_raw_string_hashes.fixed  |  19 ++--
 tests/ui/needless_raw_string_hashes.rs     |  19 ++--
 tests/ui/needless_raw_string_hashes.stderr | 142 +++++++++++++++++++++++++++--
 tests/ui/write_literal_2.stderr            |   7 +-
 8 files changed, 289 insertions(+), 52 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/raw_strings.rs b/clippy_lints/src/raw_strings.rs
index ccabb577cb7..a4fe501f79c 100644
--- a/clippy_lints/src/raw_strings.rs
+++ b/clippy_lints/src/raw_strings.rs
@@ -1,7 +1,7 @@
 use std::iter::once;
 use std::ops::ControlFlow;
 
-use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet;
 use rustc_ast::ast::{Expr, ExprKind};
 use rustc_ast::token::LitKind;
@@ -9,6 +9,7 @@ use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::{BytePos, Pos, Span};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -76,14 +77,24 @@ impl EarlyLintPass for RawStrings {
             }
 
             if !str.contains(['\\', '"']) {
-                span_lint_and_sugg(
+                span_lint_and_then(
                     cx,
                     NEEDLESS_RAW_STRINGS,
                     expr.span,
                     "unnecessary raw string literal",
-                    "try",
-                    format!("{}\"{}\"", prefix.replace('r', ""), lit.symbol),
-                    Applicability::MachineApplicable,
+                    |diag| {
+                        let (start, end) = hash_spans(expr.span, prefix, 0, max);
+
+                        // BytePos: skip over the `b` in `br`, we checked the prefix appears in the source text
+                        let r_pos = expr.span.lo() + BytePos::from_usize(prefix.len() - 1);
+                        let start = start.with_lo(r_pos);
+
+                        diag.multipart_suggestion(
+                            "try",
+                            vec![(start, String::new()), (end, String::new())],
+                            Applicability::MachineApplicable,
+                        );
+                    },
                 );
 
                 return;
@@ -96,13 +107,6 @@ impl EarlyLintPass for RawStrings {
                 let num = str.as_bytes().iter().chain(once(&0)).try_fold(0u8, |acc, &b| {
                     match b {
                         b'"' if !following_quote => (following_quote, req) = (true, 1),
-                        // I'm a bit surprised the compiler didn't optimize this out, there's no
-                        // branch but it still ends up doing an unnecessary comparison, it's:
-                        // - cmp r9b,1h
-                        // - sbb cl,-1h
-                        // which will add 1 if it's true. With this change, it becomes:
-                        // - add cl,r9b
-                        // isn't that so much nicer?
                         b'#' => req += u8::from(following_quote),
                         _ => {
                             if following_quote {
@@ -126,18 +130,58 @@ impl EarlyLintPass for RawStrings {
             };
 
             if req < max {
-                let hashes = "#".repeat(req as usize);
-
-                span_lint_and_sugg(
+                span_lint_and_then(
                     cx,
                     NEEDLESS_RAW_STRING_HASHES,
                     expr.span,
                     "unnecessary hashes around raw string literal",
-                    "try",
-                    format!(r#"{prefix}{hashes}"{}"{hashes}"#, lit.symbol),
-                    Applicability::MachineApplicable,
+                    |diag| {
+                        let (start, end) = hash_spans(expr.span, prefix, req, max);
+
+                        let message = match max - req {
+                            _ if req == 0 => "remove all the hashes around the literal".to_string(),
+                            1 => "remove one hash from both sides of the literal".to_string(),
+                            n => format!("remove {n} hashes from both sides of the literal"),
+                        };
+
+                        diag.multipart_suggestion(
+                            message,
+                            vec![(start, String::new()), (end, String::new())],
+                            Applicability::MachineApplicable,
+                        );
+                    },
                 );
             }
         }
     }
 }
+
+/// Returns spans pointing at the unneeded hashes, e.g. for a `req` of `1` and `max` of `3`:
+///
+/// ```ignore
+/// r###".."###
+///   ^^    ^^
+/// ```
+fn hash_spans(literal_span: Span, prefix: &str, req: u8, max: u8) -> (Span, Span) {
+    let literal_span = literal_span.data();
+
+    // BytePos: we checked prefix appears literally in the source text
+    let hash_start = literal_span.lo + BytePos::from_usize(prefix.len());
+    let hash_end = literal_span.hi;
+
+    // BytePos: req/max are counts of the ASCII character #
+    let start = Span::new(
+        hash_start + BytePos(req.into()),
+        hash_start + BytePos(max.into()),
+        literal_span.ctxt,
+        None,
+    );
+    let end = Span::new(
+        hash_end - BytePos(req.into()),
+        hash_end - BytePos(max.into()),
+        literal_span.ctxt,
+        None,
+    );
+
+    (start, end)
+}
diff --git a/tests/ui/needless_raw_string.fixed b/tests/ui/needless_raw_string.fixed
index 4db375178b4..85549810513 100644
--- a/tests/ui/needless_raw_string.fixed
+++ b/tests/ui/needless_raw_string.fixed
@@ -9,8 +9,13 @@ fn main() {
     b"aaa";
     br#""aaa""#;
     br#"\s"#;
-    // currently disabled: https://github.com/rust-lang/rust/issues/113333
-    // cr#"aaa"#;
-    // cr#""aaa""#;
-    // cr#"\s"#;
+    c"aaa";
+    cr#""aaa""#;
+    cr#"\s"#;
+
+    "
+        a
+        multiline
+        string
+    ";
 }
diff --git a/tests/ui/needless_raw_string.rs b/tests/ui/needless_raw_string.rs
index 59c75fda41b..06d49730387 100644
--- a/tests/ui/needless_raw_string.rs
+++ b/tests/ui/needless_raw_string.rs
@@ -9,8 +9,13 @@ fn main() {
     br#"aaa"#;
     br#""aaa""#;
     br#"\s"#;
-    // currently disabled: https://github.com/rust-lang/rust/issues/113333
-    // cr#"aaa"#;
-    // cr#""aaa""#;
-    // cr#"\s"#;
+    cr#"aaa"#;
+    cr#""aaa""#;
+    cr#"\s"#;
+
+    r#"
+        a
+        multiline
+        string
+    "#;
 }
diff --git a/tests/ui/needless_raw_string.stderr b/tests/ui/needless_raw_string.stderr
index ddc36af2e72..9c417fe1699 100644
--- a/tests/ui/needless_raw_string.stderr
+++ b/tests/ui/needless_raw_string.stderr
@@ -2,15 +2,57 @@ error: unnecessary raw string literal
   --> $DIR/needless_raw_string.rs:6:5
    |
 LL |     r#"aaa"#;
-   |     ^^^^^^^^ help: try: `"aaa"`
+   |     ^^^^^^^^
    |
    = note: `-D clippy::needless-raw-strings` implied by `-D warnings`
+help: try
+   |
+LL -     r#"aaa"#;
+LL +     "aaa";
+   |
 
 error: unnecessary raw string literal
   --> $DIR/needless_raw_string.rs:9:5
    |
 LL |     br#"aaa"#;
-   |     ^^^^^^^^^ help: try: `b"aaa"`
+   |     ^^^^^^^^^
+   |
+help: try
+   |
+LL -     br#"aaa"#;
+LL +     b"aaa";
+   |
+
+error: unnecessary raw string literal
+  --> $DIR/needless_raw_string.rs:12:5
+   |
+LL |     cr#"aaa"#;
+   |     ^^^^^^^^^
+   |
+help: try
+   |
+LL -     cr#"aaa"#;
+LL +     c"aaa";
+   |
+
+error: unnecessary raw string literal
+  --> $DIR/needless_raw_string.rs:16:5
+   |
+LL | /     r#"
+LL | |         a
+LL | |         multiline
+LL | |         string
+LL | |     "#;
+   | |______^
+   |
+help: try
+   |
+LL ~     "
+LL |         a
+LL |         multiline
+LL |         string
+LL ~     ";
+   |
 
-error: aborting due to 2 previous errors
+error: aborting due to 4 previous errors
 
diff --git a/tests/ui/needless_raw_string_hashes.fixed b/tests/ui/needless_raw_string_hashes.fixed
index 84902157ab4..e980adeeff4 100644
--- a/tests/ui/needless_raw_string_hashes.fixed
+++ b/tests/ui/needless_raw_string_hashes.fixed
@@ -3,17 +3,22 @@
 #![feature(c_str_literals)]
 
 fn main() {
-    r#"aaa"#;
+    r"\aaa";
     r#"Hello "world"!"#;
     r####" "### "## "# "####;
     r###" "aa" "# "## "###;
-    br#"aaa"#;
+    br"\aaa";
     br#"Hello "world"!"#;
     br####" "### "## "# "####;
     br###" "aa" "# "## "###;
-    // currently disabled: https://github.com/rust-lang/rust/issues/113333
-    // cr#"aaa"#;
-    // cr##"Hello "world"!"##;
-    // cr######" "### "## "# "######;
-    // cr######" "aa" "# "## "######;
+    cr"\aaa";
+    cr#"Hello "world"!"#;
+    cr####" "### "## "# "####;
+    cr###" "aa" "# "## "###;
+
+    r"
+        \a
+        multiline
+        string
+    ";
 }
diff --git a/tests/ui/needless_raw_string_hashes.rs b/tests/ui/needless_raw_string_hashes.rs
index 62abae83859..6113c5f25ae 100644
--- a/tests/ui/needless_raw_string_hashes.rs
+++ b/tests/ui/needless_raw_string_hashes.rs
@@ -3,17 +3,22 @@
 #![feature(c_str_literals)]
 
 fn main() {
-    r#"aaa"#;
+    r#"\aaa"#;
     r##"Hello "world"!"##;
     r######" "### "## "# "######;
     r######" "aa" "# "## "######;
-    br#"aaa"#;
+    br#"\aaa"#;
     br##"Hello "world"!"##;
     br######" "### "## "# "######;
     br######" "aa" "# "## "######;
-    // currently disabled: https://github.com/rust-lang/rust/issues/113333
-    // cr#"aaa"#;
-    // cr##"Hello "world"!"##;
-    // cr######" "### "## "# "######;
-    // cr######" "aa" "# "## "######;
+    cr#"\aaa"#;
+    cr##"Hello "world"!"##;
+    cr######" "### "## "# "######;
+    cr######" "aa" "# "## "######;
+
+    r#"
+        \a
+        multiline
+        string
+    "#;
 }
diff --git a/tests/ui/needless_raw_string_hashes.stderr b/tests/ui/needless_raw_string_hashes.stderr
index 9649d59a71f..ab6a87c5e8d 100644
--- a/tests/ui/needless_raw_string_hashes.stderr
+++ b/tests/ui/needless_raw_string_hashes.stderr
@@ -1,40 +1,166 @@
+error: unnecessary hashes around raw string literal
+  --> $DIR/needless_raw_string_hashes.rs:6:5
+   |
+LL |     r#"\aaa"#;
+   |     ^^^^^^^^^
+   |
+   = note: `-D clippy::needless-raw-string-hashes` implied by `-D warnings`
+help: remove all the hashes around the literal
+   |
+LL -     r#"\aaa"#;
+LL +     r"\aaa";
+   |
+
 error: unnecessary hashes around raw string literal
   --> $DIR/needless_raw_string_hashes.rs:7:5
    |
 LL |     r##"Hello "world"!"##;
-   |     ^^^^^^^^^^^^^^^^^^^^^ help: try: `r#"Hello "world"!"#`
+   |     ^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove one hash from both sides of the literal
+   |
+LL -     r##"Hello "world"!"##;
+LL +     r#"Hello "world"!"#;
    |
-   = note: `-D clippy::needless-raw-string-hashes` implied by `-D warnings`
 
 error: unnecessary hashes around raw string literal
   --> $DIR/needless_raw_string_hashes.rs:8:5
    |
 LL |     r######" "### "## "# "######;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `r####" "### "## "# "####`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove 2 hashes from both sides of the literal
+   |
+LL -     r######" "### "## "# "######;
+LL +     r####" "### "## "# "####;
+   |
 
 error: unnecessary hashes around raw string literal
   --> $DIR/needless_raw_string_hashes.rs:9:5
    |
 LL |     r######" "aa" "# "## "######;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `r###" "aa" "# "## "###`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove 3 hashes from both sides of the literal
+   |
+LL -     r######" "aa" "# "## "######;
+LL +     r###" "aa" "# "## "###;
+   |
+
+error: unnecessary hashes around raw string literal
+  --> $DIR/needless_raw_string_hashes.rs:10:5
+   |
+LL |     br#"\aaa"#;
+   |     ^^^^^^^^^^
+   |
+help: remove all the hashes around the literal
+   |
+LL -     br#"\aaa"#;
+LL +     br"\aaa";
+   |
 
 error: unnecessary hashes around raw string literal
   --> $DIR/needless_raw_string_hashes.rs:11:5
    |
 LL |     br##"Hello "world"!"##;
-   |     ^^^^^^^^^^^^^^^^^^^^^^ help: try: `br#"Hello "world"!"#`
+   |     ^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove one hash from both sides of the literal
+   |
+LL -     br##"Hello "world"!"##;
+LL +     br#"Hello "world"!"#;
+   |
 
 error: unnecessary hashes around raw string literal
   --> $DIR/needless_raw_string_hashes.rs:12:5
    |
 LL |     br######" "### "## "# "######;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `br####" "### "## "# "####`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove 2 hashes from both sides of the literal
+   |
+LL -     br######" "### "## "# "######;
+LL +     br####" "### "## "# "####;
+   |
 
 error: unnecessary hashes around raw string literal
   --> $DIR/needless_raw_string_hashes.rs:13:5
    |
 LL |     br######" "aa" "# "## "######;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `br###" "aa" "# "## "###`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove 3 hashes from both sides of the literal
+   |
+LL -     br######" "aa" "# "## "######;
+LL +     br###" "aa" "# "## "###;
+   |
+
+error: unnecessary hashes around raw string literal
+  --> $DIR/needless_raw_string_hashes.rs:14:5
+   |
+LL |     cr#"\aaa"#;
+   |     ^^^^^^^^^^
+   |
+help: remove all the hashes around the literal
+   |
+LL -     cr#"\aaa"#;
+LL +     cr"\aaa";
+   |
+
+error: unnecessary hashes around raw string literal
+  --> $DIR/needless_raw_string_hashes.rs:15:5
+   |
+LL |     cr##"Hello "world"!"##;
+   |     ^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove one hash from both sides of the literal
+   |
+LL -     cr##"Hello "world"!"##;
+LL +     cr#"Hello "world"!"#;
+   |
+
+error: unnecessary hashes around raw string literal
+  --> $DIR/needless_raw_string_hashes.rs:16:5
+   |
+LL |     cr######" "### "## "# "######;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove 2 hashes from both sides of the literal
+   |
+LL -     cr######" "### "## "# "######;
+LL +     cr####" "### "## "# "####;
+   |
+
+error: unnecessary hashes around raw string literal
+  --> $DIR/needless_raw_string_hashes.rs:17:5
+   |
+LL |     cr######" "aa" "# "## "######;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove 3 hashes from both sides of the literal
+   |
+LL -     cr######" "aa" "# "## "######;
+LL +     cr###" "aa" "# "## "###;
+   |
+
+error: unnecessary hashes around raw string literal
+  --> $DIR/needless_raw_string_hashes.rs:19:5
+   |
+LL | /     r#"
+LL | |         \a
+LL | |         multiline
+LL | |         string
+LL | |     "#;
+   | |______^
+   |
+help: remove all the hashes around the literal
+   |
+LL ~     r"
+LL |         \a
+LL |         multiline
+LL |         string
+LL ~     ";
+   |
 
-error: aborting due to 6 previous errors
+error: aborting due to 13 previous errors
 
diff --git a/tests/ui/write_literal_2.stderr b/tests/ui/write_literal_2.stderr
index 84b302d8d3b..20b1f0e2a45 100644
--- a/tests/ui/write_literal_2.stderr
+++ b/tests/ui/write_literal_2.stderr
@@ -2,9 +2,14 @@ error: unnecessary raw string literal
   --> $DIR/write_literal_2.rs:13:24
    |
 LL |     writeln!(v, r"{}", r"{hello}");
-   |                        ^^^^^^^^^^ help: try: `"{hello}"`
+   |                        ^^^^^^^^^^
    |
    = note: `-D clippy::needless-raw-strings` implied by `-D warnings`
+help: try
+   |
+LL -     writeln!(v, r"{}", r"{hello}");
+LL +     writeln!(v, r"{}", "{hello}");
+   |
 
 error: literal with an empty format string
   --> $DIR/write_literal_2.rs:10:23
-- 
cgit 1.4.1-3-g733a5


From 68011893d82e5923e894673d018a5d803d6da20c Mon Sep 17 00:00:00 2001
From: Mario Carneiro <di.gama@gmail.com>
Date: Sat, 2 Sep 2023 01:43:12 -0400
Subject: Rewrite `never_loop` as a strict reachability pass

fixes #11004
---
 clippy_lints/src/loops/never_loop.rs | 234 ++++++++++++++++++-----------------
 tests/ui/never_loop.rs               |  40 +++++-
 tests/ui/never_loop.stderr           |  13 +-
 3 files changed, 163 insertions(+), 124 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/never_loop.rs b/clippy_lints/src/loops/never_loop.rs
index cc19ac55e5e..ee1bf67994e 100644
--- a/clippy_lints/src/loops/never_loop.rs
+++ b/clippy_lints/src/loops/never_loop.rs
@@ -1,6 +1,5 @@
 use super::utils::make_iterator_snippet;
 use super::NEVER_LOOP;
-use clippy_utils::consts::{constant, Constant};
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::higher::ForLoop;
 use clippy_utils::source::snippet;
@@ -18,7 +17,7 @@ pub(super) fn check<'tcx>(
     for_loop: Option<&ForLoop<'_>>,
 ) {
     match never_loop_block(cx, block, &mut Vec::new(), loop_id) {
-        NeverLoopResult::AlwaysBreak => {
+        NeverLoopResult::Diverging => {
             span_lint_and_then(cx, NEVER_LOOP, span, "this loop never actually loops", |diag| {
                 if let Some(ForLoop {
                     arg: iterator,
@@ -39,67 +38,76 @@ pub(super) fn check<'tcx>(
                 }
             });
         },
-        NeverLoopResult::MayContinueMainLoop | NeverLoopResult::Otherwise => (),
-        NeverLoopResult::IgnoreUntilEnd(_) => unreachable!(),
+        NeverLoopResult::MayContinueMainLoop | NeverLoopResult::Normal => (),
     }
 }
 
+/// The `never_loop` analysis keeps track of three things:
+///
+/// * Has any (reachable) code path hit a `continue` of the main loop?
+/// * Is the current code path diverging (that is, the next expression is not reachable)
+/// * For each block label `'a` inside the main loop, has any (reachable) code path encountered a
+///   `break 'a`?
+///
+/// The first two bits of information are in this enum, and the last part is in the
+/// `local_labels` variable, which contains a list of `(block_id, reachable)` pairs ordered by
+/// scope.
 #[derive(Copy, Clone)]
 enum NeverLoopResult {
-    // A break/return always get triggered but not necessarily for the main loop.
-    AlwaysBreak,
-    // A continue may occur for the main loop.
+    /// A continue may occur for the main loop.
     MayContinueMainLoop,
-    // Ignore everything until the end of the block with this id
-    IgnoreUntilEnd(HirId),
-    Otherwise,
+    /// We have not encountered any main loop continue,
+    /// but we are diverging (subsequent control flow is not reachable)
+    Diverging,
+    /// We have not encountered any main loop continue,
+    /// and subsequent control flow is (possibly) reachable
+    Normal,
 }
 
 #[must_use]
 fn absorb_break(arg: NeverLoopResult) -> NeverLoopResult {
     match arg {
-        NeverLoopResult::AlwaysBreak | NeverLoopResult::Otherwise => NeverLoopResult::Otherwise,
+        NeverLoopResult::Diverging | NeverLoopResult::Normal => NeverLoopResult::Normal,
         NeverLoopResult::MayContinueMainLoop => NeverLoopResult::MayContinueMainLoop,
-        NeverLoopResult::IgnoreUntilEnd(id) => NeverLoopResult::IgnoreUntilEnd(id),
     }
 }
 
 // Combine two results for parts that are called in order.
 #[must_use]
-fn combine_seq(first: NeverLoopResult, second: NeverLoopResult) -> NeverLoopResult {
+fn combine_seq(first: NeverLoopResult, second: impl FnOnce() -> NeverLoopResult) -> NeverLoopResult {
     match first {
-        NeverLoopResult::AlwaysBreak | NeverLoopResult::MayContinueMainLoop | NeverLoopResult::IgnoreUntilEnd(_) => {
-            first
-        },
-        NeverLoopResult::Otherwise => second,
+        NeverLoopResult::Diverging | NeverLoopResult::MayContinueMainLoop => first,
+        NeverLoopResult::Normal => second(),
+    }
+}
+
+// Combine an iterator of results for parts that are called in order.
+#[must_use]
+fn combine_seq_many(iter: impl IntoIterator<Item = NeverLoopResult>) -> NeverLoopResult {
+    for e in iter {
+        if let NeverLoopResult::Diverging | NeverLoopResult::MayContinueMainLoop = e {
+            return e;
+        }
     }
+    NeverLoopResult::Normal
 }
 
 // Combine two results where only one of the part may have been executed.
 #[must_use]
-fn combine_branches(b1: NeverLoopResult, b2: NeverLoopResult, ignore_ids: &[HirId]) -> NeverLoopResult {
+fn combine_branches(b1: NeverLoopResult, b2: NeverLoopResult) -> NeverLoopResult {
     match (b1, b2) {
-        (NeverLoopResult::IgnoreUntilEnd(a), NeverLoopResult::IgnoreUntilEnd(b)) => {
-            if ignore_ids.iter().find(|&e| e == &a || e == &b).unwrap() == &a {
-                NeverLoopResult::IgnoreUntilEnd(b)
-            } else {
-                NeverLoopResult::IgnoreUntilEnd(a)
-            }
-        },
-        (i @ NeverLoopResult::IgnoreUntilEnd(_), NeverLoopResult::AlwaysBreak)
-        | (NeverLoopResult::AlwaysBreak, i @ NeverLoopResult::IgnoreUntilEnd(_)) => i,
-        (NeverLoopResult::AlwaysBreak, NeverLoopResult::AlwaysBreak) => NeverLoopResult::AlwaysBreak,
         (NeverLoopResult::MayContinueMainLoop, _) | (_, NeverLoopResult::MayContinueMainLoop) => {
             NeverLoopResult::MayContinueMainLoop
         },
-        (NeverLoopResult::Otherwise, _) | (_, NeverLoopResult::Otherwise) => NeverLoopResult::Otherwise,
+        (NeverLoopResult::Normal, _) | (_, NeverLoopResult::Normal) => NeverLoopResult::Normal,
+        (NeverLoopResult::Diverging, NeverLoopResult::Diverging) => NeverLoopResult::Diverging,
     }
 }
 
 fn never_loop_block<'tcx>(
     cx: &LateContext<'tcx>,
     block: &Block<'tcx>,
-    ignore_ids: &mut Vec<HirId>,
+    local_labels: &mut Vec<(HirId, bool)>,
     main_loop_id: HirId,
 ) -> NeverLoopResult {
     let iter = block
@@ -107,15 +115,21 @@ fn never_loop_block<'tcx>(
         .iter()
         .filter_map(stmt_to_expr)
         .chain(block.expr.map(|expr| (expr, None)));
-
-    iter.map(|(e, els)| {
-        let e = never_loop_expr(cx, e, ignore_ids, main_loop_id);
+    combine_seq_many(iter.map(|(e, els)| {
+        let e = never_loop_expr(cx, e, local_labels, main_loop_id);
         // els is an else block in a let...else binding
         els.map_or(e, |els| {
-            combine_branches(e, never_loop_block(cx, els, ignore_ids, main_loop_id), ignore_ids)
+            combine_seq(e, || match never_loop_block(cx, els, local_labels, main_loop_id) {
+                // Returning MayContinueMainLoop here means that
+                // we will not evaluate the rest of the body
+                NeverLoopResult::MayContinueMainLoop => NeverLoopResult::MayContinueMainLoop,
+                // An else block always diverges, so the Normal case should not happen,
+                // but the analysis is approximate so it might return Normal anyway.
+                // Returning Normal here says that nothing more happens on the main path
+                NeverLoopResult::Diverging | NeverLoopResult::Normal => NeverLoopResult::Normal,
+            })
         })
-    })
-    .fold(NeverLoopResult::Otherwise, combine_seq)
+    }))
 }
 
 fn stmt_to_expr<'tcx>(stmt: &Stmt<'tcx>) -> Option<(&'tcx Expr<'tcx>, Option<&'tcx Block<'tcx>>)> {
@@ -131,7 +145,7 @@ fn stmt_to_expr<'tcx>(stmt: &Stmt<'tcx>) -> Option<(&'tcx Expr<'tcx>, Option<&'t
 fn never_loop_expr<'tcx>(
     cx: &LateContext<'tcx>,
     expr: &Expr<'tcx>,
-    ignore_ids: &mut Vec<HirId>,
+    local_labels: &mut Vec<(HirId, bool)>,
     main_loop_id: HirId,
 ) -> NeverLoopResult {
     match expr.kind {
@@ -141,66 +155,61 @@ fn never_loop_expr<'tcx>(
         | ExprKind::Field(e, _)
         | ExprKind::AddrOf(_, _, e)
         | ExprKind::Repeat(e, _)
-        | ExprKind::DropTemps(e) => never_loop_expr(cx, e, ignore_ids, main_loop_id),
-        ExprKind::Let(let_expr) => never_loop_expr(cx, let_expr.init, ignore_ids, main_loop_id),
-        ExprKind::Array(es) | ExprKind::Tup(es) => never_loop_expr_all(cx, &mut es.iter(), ignore_ids, main_loop_id),
+        | ExprKind::DropTemps(e) => never_loop_expr(cx, e, local_labels, main_loop_id),
+        ExprKind::Let(let_expr) => never_loop_expr(cx, let_expr.init, local_labels, main_loop_id),
+        ExprKind::Array(es) | ExprKind::Tup(es) => never_loop_expr_all(cx, es.iter(), local_labels, main_loop_id),
         ExprKind::MethodCall(_, receiver, es, _) => never_loop_expr_all(
             cx,
-            &mut std::iter::once(receiver).chain(es.iter()),
-            ignore_ids,
+            std::iter::once(receiver).chain(es.iter()),
+            local_labels,
             main_loop_id,
         ),
         ExprKind::Struct(_, fields, base) => {
-            let fields = never_loop_expr_all(cx, &mut fields.iter().map(|f| f.expr), ignore_ids, main_loop_id);
+            let fields = never_loop_expr_all(cx, fields.iter().map(|f| f.expr), local_labels, main_loop_id);
             if let Some(base) = base {
-                combine_seq(fields, never_loop_expr(cx, base, ignore_ids, main_loop_id))
+                combine_seq(fields, || never_loop_expr(cx, base, local_labels, main_loop_id))
             } else {
                 fields
             }
         },
-        ExprKind::Call(e, es) => never_loop_expr_all(cx, &mut once(e).chain(es.iter()), ignore_ids, main_loop_id),
+        ExprKind::Call(e, es) => never_loop_expr_all(cx, once(e).chain(es.iter()), local_labels, main_loop_id),
         ExprKind::Binary(_, e1, e2)
         | ExprKind::Assign(e1, e2, _)
         | ExprKind::AssignOp(_, e1, e2)
-        | ExprKind::Index(e1, e2, _) => {
-            never_loop_expr_all(cx, &mut [e1, e2].iter().copied(), ignore_ids, main_loop_id)
-        },
+        | ExprKind::Index(e1, e2, _) => never_loop_expr_all(cx, [e1, e2].iter().copied(), local_labels, main_loop_id),
         ExprKind::Loop(b, _, _, _) => {
-            // Break can come from the inner loop so remove them.
-            absorb_break(never_loop_block(cx, b, ignore_ids, main_loop_id))
+            // We don't attempt to track reachability after a loop,
+            // just assume there may have been a break somewhere
+            absorb_break(never_loop_block(cx, b, local_labels, main_loop_id))
         },
         ExprKind::If(e, e2, e3) => {
-            let e1 = never_loop_expr(cx, e, ignore_ids, main_loop_id);
-            let e2 = never_loop_expr(cx, e2, ignore_ids, main_loop_id);
-            // If we know the `if` condition evaluates to `true`, don't check everything past it; it
-            // should just return whatever's evaluated for `e1` and `e2` since `e3` is unreachable
-            if let Some(Constant::Bool(true)) = constant(cx, cx.typeck_results(), e) {
-                return combine_seq(e1, e2);
-            }
-            let e3 = e3.as_ref().map_or(NeverLoopResult::Otherwise, |e| {
-                never_loop_expr(cx, e, ignore_ids, main_loop_id)
-            });
-            combine_seq(e1, combine_branches(e2, e3, ignore_ids))
+            let e1 = never_loop_expr(cx, e, local_labels, main_loop_id);
+            combine_seq(e1, || {
+                let e2 = never_loop_expr(cx, e2, local_labels, main_loop_id);
+                let e3 = e3.as_ref().map_or(NeverLoopResult::Normal, |e| {
+                    never_loop_expr(cx, e, local_labels, main_loop_id)
+                });
+                combine_branches(e2, e3)
+            })
         },
         ExprKind::Match(e, arms, _) => {
-            let e = never_loop_expr(cx, e, ignore_ids, main_loop_id);
+            let e = never_loop_expr(cx, e, local_labels, main_loop_id);
             if arms.is_empty() {
                 e
             } else {
-                let arms = never_loop_expr_branch(cx, &mut arms.iter().map(|a| a.body), ignore_ids, main_loop_id);
-                combine_seq(e, arms)
+                combine_seq(e, || {
+                    never_loop_expr_branch(cx, &mut arms.iter().map(|a| a.body), local_labels, main_loop_id)
+                })
             }
         },
         ExprKind::Block(b, l) => {
             if l.is_some() {
-                ignore_ids.push(b.hir_id);
-            }
-            let ret = never_loop_block(cx, b, ignore_ids, main_loop_id);
-            if l.is_some() {
-                ignore_ids.pop();
+                local_labels.push((b.hir_id, false));
             }
+            let ret = never_loop_block(cx, b, local_labels, main_loop_id);
+            let jumped_to = l.is_some() && local_labels.pop().unwrap().1;
             match ret {
-                NeverLoopResult::IgnoreUntilEnd(a) if a == b.hir_id => NeverLoopResult::Otherwise,
+                NeverLoopResult::Diverging if jumped_to => NeverLoopResult::Normal,
                 _ => ret,
             }
         },
@@ -211,73 +220,70 @@ fn never_loop_expr<'tcx>(
             if id == main_loop_id {
                 NeverLoopResult::MayContinueMainLoop
             } else {
-                NeverLoopResult::AlwaysBreak
+                NeverLoopResult::Diverging
             }
         },
-        // checks if break targets a block instead of a loop
-        ExprKind::Break(Destination { target_id: Ok(t), .. }, e) if ignore_ids.contains(&t) => e
-            .map_or(NeverLoopResult::IgnoreUntilEnd(t), |e| {
-                never_loop_expr(cx, e, ignore_ids, main_loop_id)
-            }),
-        ExprKind::Break(_, e) | ExprKind::Ret(e) => e.as_ref().map_or(NeverLoopResult::AlwaysBreak, |e| {
-            combine_seq(
-                never_loop_expr(cx, e, ignore_ids, main_loop_id),
-                NeverLoopResult::AlwaysBreak,
-            )
-        }),
-        ExprKind::Become(e) => combine_seq(
-            never_loop_expr(cx, e, ignore_ids, main_loop_id),
-            NeverLoopResult::AlwaysBreak,
-        ),
-        ExprKind::InlineAsm(asm) => asm
-            .operands
-            .iter()
-            .map(|(o, _)| match o {
-                InlineAsmOperand::In { expr, .. } | InlineAsmOperand::InOut { expr, .. } => {
-                    never_loop_expr(cx, expr, ignore_ids, main_loop_id)
-                },
-                InlineAsmOperand::Out { expr, .. } => {
-                    never_loop_expr_all(cx, &mut expr.iter().copied(), ignore_ids, main_loop_id)
-                },
-                InlineAsmOperand::SplitInOut { in_expr, out_expr, .. } => never_loop_expr_all(
-                    cx,
-                    &mut once(*in_expr).chain(out_expr.iter().copied()),
-                    ignore_ids,
-                    main_loop_id,
-                ),
-                InlineAsmOperand::Const { .. }
-                | InlineAsmOperand::SymFn { .. }
-                | InlineAsmOperand::SymStatic { .. } => NeverLoopResult::Otherwise,
+        ExprKind::Break(_, e) | ExprKind::Ret(e) => {
+            let first = e.as_ref().map_or(NeverLoopResult::Normal, |e| {
+                never_loop_expr(cx, e, local_labels, main_loop_id)
+            });
+            combine_seq(first, || {
+                // checks if break targets a block instead of a loop
+                if let ExprKind::Break(Destination { target_id: Ok(t), .. }, _) = expr.kind {
+                    if let Some((_, reachable)) = local_labels.iter_mut().find(|(label, _)| *label == t) {
+                        *reachable = true;
+                    }
+                }
+                NeverLoopResult::Diverging
             })
-            .fold(NeverLoopResult::Otherwise, combine_seq),
+        },
+        ExprKind::Become(e) => combine_seq(never_loop_expr(cx, e, local_labels, main_loop_id), || {
+            NeverLoopResult::Diverging
+        }),
+        ExprKind::InlineAsm(asm) => combine_seq_many(asm.operands.iter().map(|(o, _)| match o {
+            InlineAsmOperand::In { expr, .. } | InlineAsmOperand::InOut { expr, .. } => {
+                never_loop_expr(cx, expr, local_labels, main_loop_id)
+            },
+            InlineAsmOperand::Out { expr, .. } => {
+                never_loop_expr_all(cx, expr.iter().copied(), local_labels, main_loop_id)
+            },
+            InlineAsmOperand::SplitInOut { in_expr, out_expr, .. } => never_loop_expr_all(
+                cx,
+                once(*in_expr).chain(out_expr.iter().copied()),
+                local_labels,
+                main_loop_id,
+            ),
+            InlineAsmOperand::Const { .. } | InlineAsmOperand::SymFn { .. } | InlineAsmOperand::SymStatic { .. } => {
+                NeverLoopResult::Normal
+            },
+        })),
         ExprKind::OffsetOf(_, _)
         | ExprKind::Yield(_, _)
         | ExprKind::Closure { .. }
         | ExprKind::Path(_)
         | ExprKind::ConstBlock(_)
         | ExprKind::Lit(_)
-        | ExprKind::Err(_) => NeverLoopResult::Otherwise,
+        | ExprKind::Err(_) => NeverLoopResult::Normal,
     }
 }
 
 fn never_loop_expr_all<'tcx, T: Iterator<Item = &'tcx Expr<'tcx>>>(
     cx: &LateContext<'tcx>,
-    es: &mut T,
-    ignore_ids: &mut Vec<HirId>,
+    es: T,
+    local_labels: &mut Vec<(HirId, bool)>,
     main_loop_id: HirId,
 ) -> NeverLoopResult {
-    es.map(|e| never_loop_expr(cx, e, ignore_ids, main_loop_id))
-        .fold(NeverLoopResult::Otherwise, combine_seq)
+    combine_seq_many(es.map(|e| never_loop_expr(cx, e, local_labels, main_loop_id)))
 }
 
 fn never_loop_expr_branch<'tcx, T: Iterator<Item = &'tcx Expr<'tcx>>>(
     cx: &LateContext<'tcx>,
     e: &mut T,
-    ignore_ids: &mut Vec<HirId>,
+    local_labels: &mut Vec<(HirId, bool)>,
     main_loop_id: HirId,
 ) -> NeverLoopResult {
-    e.fold(NeverLoopResult::AlwaysBreak, |a, b| {
-        combine_branches(a, never_loop_expr(cx, b, ignore_ids, main_loop_id), ignore_ids)
+    e.fold(NeverLoopResult::Diverging, |a, b| {
+        combine_branches(a, never_loop_expr(cx, b, local_labels, main_loop_id))
     })
 }
 
diff --git a/tests/ui/never_loop.rs b/tests/ui/never_loop.rs
index 001b94391ca..ed18d79902c 100644
--- a/tests/ui/never_loop.rs
+++ b/tests/ui/never_loop.rs
@@ -337,10 +337,8 @@ pub fn test26() {
 
 pub fn test27() {
     loop {
-        //~^ ERROR: this loop never actually loops
         'label: {
             let x = true;
-            // Lints because we cannot prove it's always `true`
             if x {
                 break 'label;
             }
@@ -349,6 +347,44 @@ pub fn test27() {
     }
 }
 
+// issue 11004
+pub fn test29() {
+    loop {
+        'label: {
+            if true {
+                break 'label;
+            }
+            return;
+        }
+    }
+}
+
+pub fn test30() {
+    'a: loop {
+        'b: {
+            for j in 0..2 {
+                if j == 1 {
+                    break 'b;
+                }
+            }
+            break 'a;
+        }
+    }
+}
+
+pub fn test31(b: bool) {
+    'a: loop {
+        'b: {
+            'c: loop {
+                //~^ ERROR: this loop never actually loops
+                if b { break 'c } else { break 'b }
+            }
+            continue 'a;
+        }
+        break 'a;
+    }
+}
+
 fn main() {
     test1();
     test2();
diff --git a/tests/ui/never_loop.stderr b/tests/ui/never_loop.stderr
index 6d6d2c8ac52..188cd08b017 100644
--- a/tests/ui/never_loop.stderr
+++ b/tests/ui/never_loop.stderr
@@ -153,16 +153,13 @@ LL |             if let Some(_) = (0..20).next() {
    |             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 error: this loop never actually loops
-  --> $DIR/never_loop.rs:339:5
+  --> $DIR/never_loop.rs:378:13
    |
-LL | /     loop {
+LL | /             'c: loop {
 LL | |
-LL | |         'label: {
-LL | |             let x = true;
-...  |
-LL | |         }
-LL | |     }
-   | |_____^
+LL | |                 if b { break 'c } else { break 'b }
+LL | |             }
+   | |_____________^
 
 error: aborting due to 14 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 79e31cb80ea78dbfe67597fcff2f2a5d4d172f8d Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sat, 2 Sep 2023 11:36:34 +0200
Subject: DefaultUnionRepresentation: explain why we only warn about unions
 with at least 2 non-ZST fields

---
 clippy_lints/src/default_union_representation.rs | 3 +++
 1 file changed, 3 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/default_union_representation.rs b/clippy_lints/src/default_union_representation.rs
index 03b5a2d6d08..bbce6e1dd8f 100644
--- a/clippy_lints/src/default_union_representation.rs
+++ b/clippy_lints/src/default_union_representation.rs
@@ -69,6 +69,9 @@ impl<'tcx> LateLintPass<'tcx> for DefaultUnionRepresentation {
 }
 
 /// Returns true if the given item is a union with at least two non-ZST fields.
+/// (ZST fields having an arbitrary offset is completely inconsequential, and
+/// if there is only one field left after ignoring ZST fields then the offset
+/// of that field does not matter either.)
 fn is_union_with_two_non_zst_fields(cx: &LateContext<'_>, item: &Item<'_>) -> bool {
     if let ItemKind::Union(data, _) = &item.kind {
         data.fields().iter().filter(|f| !is_zst(cx, f.ty)).count() >= 2
-- 
cgit 1.4.1-3-g733a5


From 39b316db61f350f5aafb186ab4b919587ead4777 Mon Sep 17 00:00:00 2001
From: Mario Carneiro <di.gama@gmail.com>
Date: Sat, 2 Sep 2023 07:32:38 -0400
Subject: an empty match diverges

---
 clippy_lints/src/loops/never_loop.rs | 21 ++++-----------------
 1 file changed, 4 insertions(+), 17 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/never_loop.rs b/clippy_lints/src/loops/never_loop.rs
index ee1bf67994e..13f0ddc0ebf 100644
--- a/clippy_lints/src/loops/never_loop.rs
+++ b/clippy_lints/src/loops/never_loop.rs
@@ -194,13 +194,11 @@ fn never_loop_expr<'tcx>(
         },
         ExprKind::Match(e, arms, _) => {
             let e = never_loop_expr(cx, e, local_labels, main_loop_id);
-            if arms.is_empty() {
-                e
-            } else {
-                combine_seq(e, || {
-                    never_loop_expr_branch(cx, &mut arms.iter().map(|a| a.body), local_labels, main_loop_id)
+            combine_seq(e, || {
+                arms.iter().fold(NeverLoopResult::Diverging, |a, b| {
+                    combine_branches(a, never_loop_expr(cx, b.body, local_labels, main_loop_id))
                 })
-            }
+            })
         },
         ExprKind::Block(b, l) => {
             if l.is_some() {
@@ -276,17 +274,6 @@ fn never_loop_expr_all<'tcx, T: Iterator<Item = &'tcx Expr<'tcx>>>(
     combine_seq_many(es.map(|e| never_loop_expr(cx, e, local_labels, main_loop_id)))
 }
 
-fn never_loop_expr_branch<'tcx, T: Iterator<Item = &'tcx Expr<'tcx>>>(
-    cx: &LateContext<'tcx>,
-    e: &mut T,
-    local_labels: &mut Vec<(HirId, bool)>,
-    main_loop_id: HirId,
-) -> NeverLoopResult {
-    e.fold(NeverLoopResult::Diverging, |a, b| {
-        combine_branches(a, never_loop_expr(cx, b, local_labels, main_loop_id))
-    })
-}
-
 fn for_to_if_let_sugg(cx: &LateContext<'_>, iterator: &Expr<'_>, pat: &Pat<'_>) -> String {
     let pat_snippet = snippet(cx, pat.span, "_");
     let iter_snippet = make_iterator_snippet(cx, iterator, &mut Applicability::Unspecified);
-- 
cgit 1.4.1-3-g733a5


From b3980d84976ae956a9a9f053b7fffe809b4a543e Mon Sep 17 00:00:00 2001
From: Mario Carneiro <di.gama@gmail.com>
Date: Sat, 2 Sep 2023 07:51:34 -0400
Subject: catch never loops through diverging functions

---
 clippy_lints/src/loops/never_loop.rs | 11 +++++++++--
 tests/ui/never_loop.rs               |  7 +++++++
 tests/ui/never_loop.stderr           | 11 ++++++++++-
 3 files changed, 26 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/never_loop.rs b/clippy_lints/src/loops/never_loop.rs
index 13f0ddc0ebf..5cdf0bd891f 100644
--- a/clippy_lints/src/loops/never_loop.rs
+++ b/clippy_lints/src/loops/never_loop.rs
@@ -148,7 +148,7 @@ fn never_loop_expr<'tcx>(
     local_labels: &mut Vec<(HirId, bool)>,
     main_loop_id: HirId,
 ) -> NeverLoopResult {
-    match expr.kind {
+    let result = match expr.kind {
         ExprKind::Unary(_, e)
         | ExprKind::Cast(e, _)
         | ExprKind::Type(e, _)
@@ -262,7 +262,14 @@ fn never_loop_expr<'tcx>(
         | ExprKind::ConstBlock(_)
         | ExprKind::Lit(_)
         | ExprKind::Err(_) => NeverLoopResult::Normal,
-    }
+    };
+    combine_seq(result, || {
+        if cx.typeck_results().expr_ty(expr).is_never() {
+            NeverLoopResult::Diverging
+        } else {
+            NeverLoopResult::Normal
+        }
+    })
 }
 
 fn never_loop_expr_all<'tcx, T: Iterator<Item = &'tcx Expr<'tcx>>>(
diff --git a/tests/ui/never_loop.rs b/tests/ui/never_loop.rs
index ed18d79902c..33208364f0e 100644
--- a/tests/ui/never_loop.rs
+++ b/tests/ui/never_loop.rs
@@ -385,6 +385,13 @@ pub fn test31(b: bool) {
     }
 }
 
+pub fn test32(b: bool) {
+    loop {
+        //~^ ERROR: this loop never actually loops
+        panic!("oh no");
+    }
+}
+
 fn main() {
     test1();
     test2();
diff --git a/tests/ui/never_loop.stderr b/tests/ui/never_loop.stderr
index 188cd08b017..37ccd63d27c 100644
--- a/tests/ui/never_loop.stderr
+++ b/tests/ui/never_loop.stderr
@@ -161,5 +161,14 @@ LL | |                 if b { break 'c } else { break 'b }
 LL | |             }
    | |_____________^
 
-error: aborting due to 14 previous errors
+error: this loop never actually loops
+  --> $DIR/never_loop.rs:389:5
+   |
+LL | /     loop {
+LL | |
+LL | |         panic!("oh no");
+LL | |     }
+   | |_____^
+
+error: aborting due to 15 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 78983d9e3f5a1de6355fc33ca56e8dbb94c6cf56 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Sat, 2 Sep 2023 15:46:15 +0200
Subject: [`slow_vector_initialization`]: use the source span of `vec![]` macro

---
 clippy_lints/src/slow_vector_initialization.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/slow_vector_initialization.rs b/clippy_lints/src/slow_vector_initialization.rs
index c9ab622ad25..0ef7e05de6e 100644
--- a/clippy_lints/src/slow_vector_initialization.rs
+++ b/clippy_lints/src/slow_vector_initialization.rs
@@ -205,7 +205,7 @@ impl SlowVectorInit {
 
         span_lint_and_then(cx, SLOW_VECTOR_INITIALIZATION, slow_fill.span, msg, |diag| {
             diag.span_suggestion(
-                vec_alloc.allocation_expr.span,
+                vec_alloc.allocation_expr.span.source_callsite(),
                 "consider replacing this with",
                 format!("vec![0; {len_expr}]"),
                 Applicability::Unspecified,
-- 
cgit 1.4.1-3-g733a5


From 51206323a100b2b2e2b94b0f65078eb9523e524d Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Sat, 2 Sep 2023 16:21:46 +0200
Subject: [`slow_vector_initialization`]: only warn on `vec![]` expn

---
 clippy_lints/src/slow_vector_initialization.rs | 10 ++++++++++
 tests/ui/slow_vector_initialization.rs         | 16 +++++++++++++++-
 tests/ui/slow_vector_initialization.stderr     | 12 ++++++++++--
 3 files changed, 35 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/slow_vector_initialization.rs b/clippy_lints/src/slow_vector_initialization.rs
index 0ef7e05de6e..9db18c2976c 100644
--- a/clippy_lints/src/slow_vector_initialization.rs
+++ b/clippy_lints/src/slow_vector_initialization.rs
@@ -1,4 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::macros::root_macro_call;
 use clippy_utils::sugg::Sugg;
 use clippy_utils::{
     get_enclosing_block, is_expr_path_def_path, is_integer_literal, is_path_diagnostic_item, path_to_local,
@@ -148,6 +149,15 @@ impl SlowVectorInit {
     /// - `Some(InitializedSize::Uninitialized)` for `Vec::new()`
     /// - `None` for other, unrelated kinds of expressions
     fn as_vec_initializer<'tcx>(cx: &LateContext<'_>, expr: &'tcx Expr<'tcx>) -> Option<InitializedSize<'tcx>> {
+        // Generally don't warn if the vec initializer comes from an expansion, except for the vec! macro.
+        // This lets us still warn on `vec![]`, while ignoring other kinds of macros that may output an
+        // empty vec
+        if expr.span.from_expansion()
+            && root_macro_call(expr.span).map(|m| m.def_id) != cx.tcx.get_diagnostic_item(sym::vec_macro)
+        {
+            return None;
+        }
+
         if let ExprKind::Call(func, [len_expr]) = expr.kind
             && is_expr_path_def_path(cx, func, &paths::VEC_WITH_CAPACITY)
         {
diff --git a/tests/ui/slow_vector_initialization.rs b/tests/ui/slow_vector_initialization.rs
index f8d85ed38cd..5c3086c9d69 100644
--- a/tests/ui/slow_vector_initialization.rs
+++ b/tests/ui/slow_vector_initialization.rs
@@ -1,5 +1,5 @@
-use std::iter::repeat;
 //@no-rustfix
+use std::iter::repeat;
 fn main() {
     resize_vector();
     extend_vector();
@@ -86,6 +86,20 @@ fn from_empty_vec() {
     vec1 = Vec::new();
     vec1.resize(10, 0);
     //~^ ERROR: slow zero-filling initialization
+
+    vec1 = vec![];
+    vec1.resize(10, 0);
+    //~^ ERROR: slow zero-filling initialization
+
+    macro_rules! x {
+        () => {
+            vec![]
+        };
+    }
+
+    // `vec![]` comes from another macro, don't warn
+    vec1 = x!();
+    vec1.resize(10, 0);
 }
 
 fn do_stuff(vec: &mut [u8]) {}
diff --git a/tests/ui/slow_vector_initialization.stderr b/tests/ui/slow_vector_initialization.stderr
index 4800e6e4418..73a9cb55eb9 100644
--- a/tests/ui/slow_vector_initialization.stderr
+++ b/tests/ui/slow_vector_initialization.stderr
@@ -96,13 +96,21 @@ LL |     vec1 = Vec::new();
 LL |     vec1.resize(10, 0);
    |     ^^^^^^^^^^^^^^^^^^
 
+error: slow zero-filling initialization
+  --> $DIR/slow_vector_initialization.rs:91:5
+   |
+LL |     vec1 = vec![];
+   |            ------ help: consider replacing this with: `vec![0; 10]`
+LL |     vec1.resize(10, 0);
+   |     ^^^^^^^^^^^^^^^^^^
+
 error: this argument is a mutable reference, but not used mutably
-  --> $DIR/slow_vector_initialization.rs:91:18
+  --> $DIR/slow_vector_initialization.rs:105:18
    |
 LL | fn do_stuff(vec: &mut [u8]) {}
    |                  ^^^^^^^^^ help: consider changing to: `&[u8]`
    |
    = note: `-D clippy::needless-pass-by-ref-mut` implied by `-D warnings`
 
-error: aborting due to 13 previous errors
+error: aborting due to 14 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 26c0f97579763363310bc32cf6d8ef4cd6f5588f Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Sat, 2 Sep 2023 21:55:44 +0200
Subject: [`len_without_is_empty`]: follow type alias

---
 clippy_lints/src/len_zero.rs         |  8 ++++++++
 tests/ui/len_without_is_empty.rs     | 23 +++++++++++++++++++++++
 tests/ui/len_without_is_empty.stderr |  8 +++++++-
 3 files changed, 38 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/len_zero.rs b/clippy_lints/src/len_zero.rs
index deba232bdd2..c06b35ca0da 100644
--- a/clippy_lints/src/len_zero.rs
+++ b/clippy_lints/src/len_zero.rs
@@ -424,6 +424,14 @@ fn check_for_is_empty(
     item_name: Symbol,
     item_kind: &str,
 ) {
+    // Implementor may be a type alias, in which case we need to get the `DefId` of the aliased type to
+    // find the correct inherent impls.
+    let impl_ty = if let Some(adt) = cx.tcx.type_of(impl_ty).skip_binder().ty_adt_def() {
+        adt.did()
+    } else {
+        return;
+    };
+
     let is_empty = Symbol::intern("is_empty");
     let is_empty = cx
         .tcx
diff --git a/tests/ui/len_without_is_empty.rs b/tests/ui/len_without_is_empty.rs
index ac6c3e06365..d623601110e 100644
--- a/tests/ui/len_without_is_empty.rs
+++ b/tests/ui/len_without_is_empty.rs
@@ -436,4 +436,27 @@ impl DifferingErrors {
     }
 }
 
+// Issue #11165
+pub struct Aliased1;
+pub type Alias1 = Aliased1;
+
+impl Alias1 {
+    pub fn len(&self) -> usize {
+        todo!()
+    }
+
+    pub fn is_empty(&self) -> bool {
+        todo!()
+    }
+}
+
+pub struct Aliased2;
+pub type Alias2 = Aliased2;
+impl Alias2 {
+    pub fn len(&self) -> usize {
+        //~^ ERROR: type `Alias2` has a public `len` method, but no `is_empty` method
+        todo!()
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/len_without_is_empty.stderr b/tests/ui/len_without_is_empty.stderr
index 1042ea2e1b3..50a8c8086b7 100644
--- a/tests/ui/len_without_is_empty.stderr
+++ b/tests/ui/len_without_is_empty.stderr
@@ -139,5 +139,11 @@ error: struct `AsyncResultLenWithoutIsEmpty` has a public `len` method, but no `
 LL |     pub async fn len(&self) -> Result<usize, ()> {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 15 previous errors
+error: type `Alias2` has a public `len` method, but no `is_empty` method
+  --> $DIR/len_without_is_empty.rs:456:5
+   |
+LL |     pub fn len(&self) -> usize {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 16 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 61a2f972b3ae063512cdcd3e10fd2f95319fec24 Mon Sep 17 00:00:00 2001
From: Mario Carneiro <di.gama@gmail.com>
Date: Sat, 2 Sep 2023 23:34:03 -0400
Subject: skip `todo` / `unimplemented` in  `never_loop`

---
 clippy_lints/src/loops/never_loop.rs      | 17 ++++++++++++--
 tests/ui/needless_collect_indirect.rs     |  6 -----
 tests/ui/needless_collect_indirect.stderr |  7 ++----
 tests/ui/never_loop.rs                    | 10 +++++++-
 tests/ui/vec.fixed                        |  7 +-----
 tests/ui/vec.rs                           |  7 +-----
 tests/ui/vec.stderr                       | 38 +++++++++++++++----------------
 7 files changed, 47 insertions(+), 45 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/never_loop.rs b/clippy_lints/src/loops/never_loop.rs
index 5cdf0bd891f..5845be870d4 100644
--- a/clippy_lints/src/loops/never_loop.rs
+++ b/clippy_lints/src/loops/never_loop.rs
@@ -2,6 +2,7 @@ use super::utils::make_iterator_snippet;
 use super::NEVER_LOOP;
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::higher::ForLoop;
+use clippy_utils::macros::root_macro_call_first_node;
 use clippy_utils::source::snippet;
 use rustc_errors::Applicability;
 use rustc_hir::{Block, Destination, Expr, ExprKind, HirId, InlineAsmOperand, Pat, Stmt, StmtKind};
@@ -263,13 +264,25 @@ fn never_loop_expr<'tcx>(
         | ExprKind::Lit(_)
         | ExprKind::Err(_) => NeverLoopResult::Normal,
     };
-    combine_seq(result, || {
+    let result = combine_seq(result, || {
         if cx.typeck_results().expr_ty(expr).is_never() {
             NeverLoopResult::Diverging
         } else {
             NeverLoopResult::Normal
         }
-    })
+    });
+    if  let NeverLoopResult::Diverging = result &&
+        let Some(macro_call) = root_macro_call_first_node(cx, expr) &&
+        let "todo" | "unimplemented" = cx.tcx.item_name(macro_call.def_id).as_str()
+    {
+        // We return MayContinueMainLoop here because we treat `todo!()` and
+        // `unimplemented!()` macros as potentially containing any code,
+        // including a continue of the main loop. This effectively silences the lint
+        // whenever a loop contains one of these macros anywhere.
+        NeverLoopResult::MayContinueMainLoop
+    } else {
+        result
+    }
 }
 
 fn never_loop_expr_all<'tcx, T: Iterator<Item = &'tcx Expr<'tcx>>>(
diff --git a/tests/ui/needless_collect_indirect.rs b/tests/ui/needless_collect_indirect.rs
index b4a536cb159..9d66c5f255f 100644
--- a/tests/ui/needless_collect_indirect.rs
+++ b/tests/ui/needless_collect_indirect.rs
@@ -260,7 +260,6 @@ mod issue_8553 {
         let w = v.iter().collect::<Vec<_>>();
         //~^ ERROR: avoid using `collect()` when not needed
         // Do lint
-        #[allow(clippy::never_loop)]
         for _ in 0..w.len() {
             todo!();
         }
@@ -271,7 +270,6 @@ mod issue_8553 {
         let v: Vec<usize> = vec.iter().map(|i| i * i).collect();
         let w = v.iter().collect::<Vec<_>>();
         // Do not lint, because w is used.
-        #[allow(clippy::never_loop)]
         for _ in 0..w.len() {
             todo!();
         }
@@ -285,7 +283,6 @@ mod issue_8553 {
         let mut w = v.iter().collect::<Vec<_>>();
         //~^ ERROR: avoid using `collect()` when not needed
         // Do lint
-        #[allow(clippy::never_loop)]
         while 1 == w.len() {
             todo!();
         }
@@ -296,7 +293,6 @@ mod issue_8553 {
         let mut v: Vec<usize> = vec.iter().map(|i| i * i).collect();
         let mut w = v.iter().collect::<Vec<_>>();
         // Do not lint, because w is used.
-        #[allow(clippy::never_loop)]
         while 1 == w.len() {
             todo!();
         }
@@ -310,7 +306,6 @@ mod issue_8553 {
         let mut w = v.iter().collect::<Vec<_>>();
         //~^ ERROR: avoid using `collect()` when not needed
         // Do lint
-        #[allow(clippy::never_loop)]
         while let Some(i) = Some(w.len()) {
             todo!();
         }
@@ -321,7 +316,6 @@ mod issue_8553 {
         let mut v: Vec<usize> = vec.iter().map(|i| i * i).collect();
         let mut w = v.iter().collect::<Vec<_>>();
         // Do not lint, because w is used.
-        #[allow(clippy::never_loop)]
         while let Some(i) = Some(w.len()) {
             todo!();
         }
diff --git a/tests/ui/needless_collect_indirect.stderr b/tests/ui/needless_collect_indirect.stderr
index 47048b74125..9337a741242 100644
--- a/tests/ui/needless_collect_indirect.stderr
+++ b/tests/ui/needless_collect_indirect.stderr
@@ -230,12 +230,11 @@ help: take the original Iterator's count instead of collecting it and finding th
 LL ~         
 LL |
 LL |         // Do lint
-LL |         #[allow(clippy::never_loop)]
 LL ~         for _ in 0..v.iter().count() {
    |
 
 error: avoid using `collect()` when not needed
-  --> $DIR/needless_collect_indirect.rs:285:30
+  --> $DIR/needless_collect_indirect.rs:283:30
    |
 LL |         let mut w = v.iter().collect::<Vec<_>>();
    |                              ^^^^^^^
@@ -248,12 +247,11 @@ help: take the original Iterator's count instead of collecting it and finding th
 LL ~         
 LL |
 LL |         // Do lint
-LL |         #[allow(clippy::never_loop)]
 LL ~         while 1 == v.iter().count() {
    |
 
 error: avoid using `collect()` when not needed
-  --> $DIR/needless_collect_indirect.rs:310:30
+  --> $DIR/needless_collect_indirect.rs:306:30
    |
 LL |         let mut w = v.iter().collect::<Vec<_>>();
    |                              ^^^^^^^
@@ -266,7 +264,6 @@ help: take the original Iterator's count instead of collecting it and finding th
 LL ~         
 LL |
 LL |         // Do lint
-LL |         #[allow(clippy::never_loop)]
 LL ~         while let Some(i) = Some(v.iter().count()) {
    |
 
diff --git a/tests/ui/never_loop.rs b/tests/ui/never_loop.rs
index 33208364f0e..cee52dfd85b 100644
--- a/tests/ui/never_loop.rs
+++ b/tests/ui/never_loop.rs
@@ -385,11 +385,19 @@ pub fn test31(b: bool) {
     }
 }
 
-pub fn test32(b: bool) {
+pub fn test32() {
     loop {
         //~^ ERROR: this loop never actually loops
         panic!("oh no");
     }
+    loop {
+        // no error
+        unimplemented!("not yet");
+    }
+    loop {
+        // no error
+        todo!("maybe later");
+    }
 }
 
 fn main() {
diff --git a/tests/ui/vec.fixed b/tests/ui/vec.fixed
index de1eb613ce0..3ff2acbe28f 100644
--- a/tests/ui/vec.fixed
+++ b/tests/ui/vec.fixed
@@ -1,10 +1,5 @@
 #![warn(clippy::useless_vec)]
-#![allow(
-    clippy::nonstandard_macro_braces,
-    clippy::never_loop,
-    clippy::uninlined_format_args,
-    unused
-)]
+#![allow(clippy::nonstandard_macro_braces, clippy::uninlined_format_args, unused)]
 
 use std::rc::Rc;
 
diff --git a/tests/ui/vec.rs b/tests/ui/vec.rs
index 1da10c28880..2ab025f424a 100644
--- a/tests/ui/vec.rs
+++ b/tests/ui/vec.rs
@@ -1,10 +1,5 @@
 #![warn(clippy::useless_vec)]
-#![allow(
-    clippy::nonstandard_macro_braces,
-    clippy::never_loop,
-    clippy::uninlined_format_args,
-    unused
-)]
+#![allow(clippy::nonstandard_macro_braces, clippy::uninlined_format_args, unused)]
 
 use std::rc::Rc;
 
diff --git a/tests/ui/vec.stderr b/tests/ui/vec.stderr
index a4c2b8984e0..5cd6d9fa8c7 100644
--- a/tests/ui/vec.stderr
+++ b/tests/ui/vec.stderr
@@ -1,5 +1,5 @@
 error: useless use of `vec!`
-  --> $DIR/vec.rs:35:14
+  --> $DIR/vec.rs:30:14
    |
 LL |     on_slice(&vec![]);
    |              ^^^^^^^ help: you can use a slice directly: `&[]`
@@ -7,109 +7,109 @@ LL |     on_slice(&vec![]);
    = note: `-D clippy::useless-vec` implied by `-D warnings`
 
 error: useless use of `vec!`
-  --> $DIR/vec.rs:37:18
+  --> $DIR/vec.rs:32:18
    |
 LL |     on_mut_slice(&mut vec![]);
    |                  ^^^^^^^^^^^ help: you can use a slice directly: `&mut []`
 
 error: useless use of `vec!`
-  --> $DIR/vec.rs:39:14
+  --> $DIR/vec.rs:34:14
    |
 LL |     on_slice(&vec![1, 2]);
    |              ^^^^^^^^^^^ help: you can use a slice directly: `&[1, 2]`
 
 error: useless use of `vec!`
-  --> $DIR/vec.rs:41:18
+  --> $DIR/vec.rs:36:18
    |
 LL |     on_mut_slice(&mut vec![1, 2]);
    |                  ^^^^^^^^^^^^^^^ help: you can use a slice directly: `&mut [1, 2]`
 
 error: useless use of `vec!`
-  --> $DIR/vec.rs:43:14
+  --> $DIR/vec.rs:38:14
    |
 LL |     on_slice(&vec![1, 2]);
    |              ^^^^^^^^^^^ help: you can use a slice directly: `&[1, 2]`
 
 error: useless use of `vec!`
-  --> $DIR/vec.rs:45:18
+  --> $DIR/vec.rs:40:18
    |
 LL |     on_mut_slice(&mut vec![1, 2]);
    |                  ^^^^^^^^^^^^^^^ help: you can use a slice directly: `&mut [1, 2]`
 
 error: useless use of `vec!`
-  --> $DIR/vec.rs:47:14
+  --> $DIR/vec.rs:42:14
    |
 LL |     on_slice(&vec!(1, 2));
    |              ^^^^^^^^^^^ help: you can use a slice directly: `&[1, 2]`
 
 error: useless use of `vec!`
-  --> $DIR/vec.rs:49:18
+  --> $DIR/vec.rs:44:18
    |
 LL |     on_mut_slice(&mut vec![1, 2]);
    |                  ^^^^^^^^^^^^^^^ help: you can use a slice directly: `&mut [1, 2]`
 
 error: useless use of `vec!`
-  --> $DIR/vec.rs:51:14
+  --> $DIR/vec.rs:46:14
    |
 LL |     on_slice(&vec![1; 2]);
    |              ^^^^^^^^^^^ help: you can use a slice directly: `&[1; 2]`
 
 error: useless use of `vec!`
-  --> $DIR/vec.rs:53:18
+  --> $DIR/vec.rs:48:18
    |
 LL |     on_mut_slice(&mut vec![1; 2]);
    |                  ^^^^^^^^^^^^^^^ help: you can use a slice directly: `&mut [1; 2]`
 
 error: useless use of `vec!`
-  --> $DIR/vec.rs:79:19
+  --> $DIR/vec.rs:74:19
    |
 LL |     let _x: i32 = vec![1, 2, 3].iter().sum();
    |                   ^^^^^^^^^^^^^ help: you can use an array directly: `[1, 2, 3]`
 
 error: useless use of `vec!`
-  --> $DIR/vec.rs:82:17
+  --> $DIR/vec.rs:77:17
    |
 LL |     let mut x = vec![1, 2, 3];
    |                 ^^^^^^^^^^^^^ help: you can use an array directly: `[1, 2, 3]`
 
 error: useless use of `vec!`
-  --> $DIR/vec.rs:88:22
+  --> $DIR/vec.rs:83:22
    |
 LL |     let _x: &[i32] = &vec![1, 2, 3];
    |                      ^^^^^^^^^^^^^^ help: you can use a slice directly: `&[1, 2, 3]`
 
 error: useless use of `vec!`
-  --> $DIR/vec.rs:90:14
+  --> $DIR/vec.rs:85:14
    |
 LL |     for _ in vec![1, 2, 3] {}
    |              ^^^^^^^^^^^^^ help: you can use an array directly: `[1, 2, 3]`
 
 error: useless use of `vec!`
-  --> $DIR/vec.rs:128:20
+  --> $DIR/vec.rs:123:20
    |
 LL |     for _string in vec![repro!(true), repro!(null)] {
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: you can use an array directly: `[repro!(true), repro!(null)]`
 
 error: useless use of `vec!`
-  --> $DIR/vec.rs:145:18
+  --> $DIR/vec.rs:140:18
    |
 LL |     in_macro!(1, vec![1, 2], vec![1; 2]);
    |                  ^^^^^^^^^^ help: you can use an array directly: `[1, 2]`
 
 error: useless use of `vec!`
-  --> $DIR/vec.rs:145:30
+  --> $DIR/vec.rs:140:30
    |
 LL |     in_macro!(1, vec![1, 2], vec![1; 2]);
    |                              ^^^^^^^^^^ help: you can use an array directly: `[1; 2]`
 
 error: useless use of `vec!`
-  --> $DIR/vec.rs:164:14
+  --> $DIR/vec.rs:159:14
    |
 LL |     for a in vec![1, 2, 3] {
    |              ^^^^^^^^^^^^^ help: you can use an array directly: `[1, 2, 3]`
 
 error: useless use of `vec!`
-  --> $DIR/vec.rs:168:14
+  --> $DIR/vec.rs:163:14
    |
 LL |     for a in vec![String::new(), String::new()] {
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: you can use an array directly: `[String::new(), String::new()]`
-- 
cgit 1.4.1-3-g733a5


From e0014afa2df2df55bf9246ba22dcc706fe98dc83 Mon Sep 17 00:00:00 2001
From: tom-anders <13141438+tom-anders@users.noreply.github.com>
Date: Sun, 3 Sep 2023 14:34:40 +0200
Subject: Add suggestions for std_instead_of_core

Fixes #11446
---
 clippy_lints/src/std_instead_of_core.rs | 26 +++++++-----
 tests/ui/std_instead_of_core.fixed      | 62 ++++++++++++++++++++++++++++
 tests/ui/std_instead_of_core.rs         |  1 -
 tests/ui/std_instead_of_core.stderr     | 71 ++++++++++-----------------------
 4 files changed, 101 insertions(+), 59 deletions(-)
 create mode 100644 tests/ui/std_instead_of_core.fixed

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/std_instead_of_core.rs b/clippy_lints/src/std_instead_of_core.rs
index f239165276f..5f54a10d1c4 100644
--- a/clippy_lints/src/std_instead_of_core.rs
+++ b/clippy_lints/src/std_instead_of_core.rs
@@ -1,4 +1,5 @@
-use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use rustc_errors::Applicability;
 use rustc_hir::def::Res;
 use rustc_hir::def_id::DefId;
 use rustc_hir::{HirId, Path, PathSegment};
@@ -99,17 +100,17 @@ impl<'tcx> LateLintPass<'tcx> for StdReexports {
             && let Some(first_segment) = get_first_segment(path)
             && is_stable(cx, def_id)
         {
-            let (lint, msg, help) = match first_segment.ident.name {
+            let (lint, used_mod, replace_with) = match first_segment.ident.name {
                 sym::std => match cx.tcx.crate_name(def_id.krate) {
                     sym::core => (
                         STD_INSTEAD_OF_CORE,
-                        "used import from `std` instead of `core`",
-                        "consider importing the item from `core`",
+                        "std",
+                        "core",
                     ),
                     sym::alloc => (
                         STD_INSTEAD_OF_ALLOC,
-                        "used import from `std` instead of `alloc`",
-                        "consider importing the item from `alloc`",
+                        "std",
+                        "alloc",
                     ),
                     _ => {
                         self.prev_span = path.span;
@@ -120,8 +121,8 @@ impl<'tcx> LateLintPass<'tcx> for StdReexports {
                     if cx.tcx.crate_name(def_id.krate) == sym::core {
                         (
                             ALLOC_INSTEAD_OF_CORE,
-                            "used import from `alloc` instead of `core`",
-                            "consider importing the item from `core`",
+                            "alloc",
+                            "core",
                         )
                     } else {
                         self.prev_span = path.span;
@@ -131,7 +132,14 @@ impl<'tcx> LateLintPass<'tcx> for StdReexports {
                 _ => return,
             };
             if path.span != self.prev_span {
-                span_lint_and_help(cx, lint, path.span, msg, None, help);
+                span_lint_and_sugg(
+                    cx,
+                    lint,
+                    first_segment.ident.span,
+                    &format!("used import from `{used_mod}` instead of `{replace_with}`"),
+                    &format!("consider importing the item from `{replace_with}`"),
+                    replace_with.to_string(),
+                    Applicability::MachineApplicable);
                 self.prev_span = path.span;
             }
         }
diff --git a/tests/ui/std_instead_of_core.fixed b/tests/ui/std_instead_of_core.fixed
new file mode 100644
index 00000000000..8027c053fb5
--- /dev/null
+++ b/tests/ui/std_instead_of_core.fixed
@@ -0,0 +1,62 @@
+#![warn(clippy::std_instead_of_core)]
+#![allow(unused_imports)]
+
+extern crate alloc;
+
+#[warn(clippy::std_instead_of_core)]
+fn std_instead_of_core() {
+    // Regular import
+    use core::hash::Hasher;
+    //~^ ERROR: used import from `std` instead of `core`
+    // Absolute path
+    use ::core::hash::Hash;
+    //~^ ERROR: used import from `std` instead of `core`
+    // Don't lint on `env` macro
+    use std::env;
+
+    // Multiple imports
+    use core::fmt::{Debug, Result};
+    //~^ ERROR: used import from `std` instead of `core`
+
+    // Function calls
+    let ptr = core::ptr::null::<u32>();
+    //~^ ERROR: used import from `std` instead of `core`
+    let ptr_mut = ::core::ptr::null_mut::<usize>();
+    //~^ ERROR: used import from `std` instead of `core`
+
+    // Types
+    let cell = core::cell::Cell::new(8u32);
+    //~^ ERROR: used import from `std` instead of `core`
+    let cell_absolute = ::core::cell::Cell::new(8u32);
+    //~^ ERROR: used import from `std` instead of `core`
+
+    let _ = std::env!("PATH");
+
+    // do not lint until `error_in_core` is stable
+    use std::error::Error;
+
+    // lint items re-exported from private modules, `core::iter::traits::iterator::Iterator`
+    use core::iter::Iterator;
+    //~^ ERROR: used import from `std` instead of `core`
+}
+
+#[warn(clippy::std_instead_of_alloc)]
+fn std_instead_of_alloc() {
+    // Only lint once.
+    use alloc::vec;
+    //~^ ERROR: used import from `std` instead of `alloc`
+    use alloc::vec::Vec;
+    //~^ ERROR: used import from `std` instead of `alloc`
+}
+
+#[warn(clippy::alloc_instead_of_core)]
+fn alloc_instead_of_core() {
+    use core::slice::from_ref;
+    //~^ ERROR: used import from `alloc` instead of `core`
+}
+
+fn main() {
+    std_instead_of_core();
+    std_instead_of_alloc();
+    alloc_instead_of_core();
+}
diff --git a/tests/ui/std_instead_of_core.rs b/tests/ui/std_instead_of_core.rs
index 2e44487d77e..63a096384d7 100644
--- a/tests/ui/std_instead_of_core.rs
+++ b/tests/ui/std_instead_of_core.rs
@@ -17,7 +17,6 @@ fn std_instead_of_core() {
     // Multiple imports
     use std::fmt::{Debug, Result};
     //~^ ERROR: used import from `std` instead of `core`
-    //~| ERROR: used import from `std` instead of `core`
 
     // Function calls
     let ptr = std::ptr::null::<u32>();
diff --git a/tests/ui/std_instead_of_core.stderr b/tests/ui/std_instead_of_core.stderr
index f2db81e5163..7f05b05ae28 100644
--- a/tests/ui/std_instead_of_core.stderr
+++ b/tests/ui/std_instead_of_core.stderr
@@ -2,100 +2,73 @@ error: used import from `std` instead of `core`
   --> $DIR/std_instead_of_core.rs:9:9
    |
 LL |     use std::hash::Hasher;
-   |         ^^^^^^^^^^^^^^^^^
+   |         ^^^ help: consider importing the item from `core`: `core`
    |
-   = help: consider importing the item from `core`
    = note: `-D clippy::std-instead-of-core` implied by `-D warnings`
 
 error: used import from `std` instead of `core`
-  --> $DIR/std_instead_of_core.rs:12:9
+  --> $DIR/std_instead_of_core.rs:12:11
    |
 LL |     use ::std::hash::Hash;
-   |         ^^^^^^^^^^^^^^^^^
-   |
-   = help: consider importing the item from `core`
+   |           ^^^ help: consider importing the item from `core`: `core`
 
 error: used import from `std` instead of `core`
-  --> $DIR/std_instead_of_core.rs:18:20
+  --> $DIR/std_instead_of_core.rs:18:9
    |
 LL |     use std::fmt::{Debug, Result};
-   |                    ^^^^^
-   |
-   = help: consider importing the item from `core`
-
-error: used import from `std` instead of `core`
-  --> $DIR/std_instead_of_core.rs:18:27
-   |
-LL |     use std::fmt::{Debug, Result};
-   |                           ^^^^^^
-   |
-   = help: consider importing the item from `core`
+   |         ^^^ help: consider importing the item from `core`: `core`
 
 error: used import from `std` instead of `core`
-  --> $DIR/std_instead_of_core.rs:23:15
+  --> $DIR/std_instead_of_core.rs:22:15
    |
 LL |     let ptr = std::ptr::null::<u32>();
-   |               ^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: consider importing the item from `core`
+   |               ^^^ help: consider importing the item from `core`: `core`
 
 error: used import from `std` instead of `core`
-  --> $DIR/std_instead_of_core.rs:25:19
+  --> $DIR/std_instead_of_core.rs:24:21
    |
 LL |     let ptr_mut = ::std::ptr::null_mut::<usize>();
-   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: consider importing the item from `core`
+   |                     ^^^ help: consider importing the item from `core`: `core`
 
 error: used import from `std` instead of `core`
-  --> $DIR/std_instead_of_core.rs:29:16
+  --> $DIR/std_instead_of_core.rs:28:16
    |
 LL |     let cell = std::cell::Cell::new(8u32);
-   |                ^^^^^^^^^^^^^^^
-   |
-   = help: consider importing the item from `core`
+   |                ^^^ help: consider importing the item from `core`: `core`
 
 error: used import from `std` instead of `core`
-  --> $DIR/std_instead_of_core.rs:31:25
+  --> $DIR/std_instead_of_core.rs:30:27
    |
 LL |     let cell_absolute = ::std::cell::Cell::new(8u32);
-   |                         ^^^^^^^^^^^^^^^^^
-   |
-   = help: consider importing the item from `core`
+   |                           ^^^ help: consider importing the item from `core`: `core`
 
 error: used import from `std` instead of `core`
-  --> $DIR/std_instead_of_core.rs:40:9
+  --> $DIR/std_instead_of_core.rs:39:9
    |
 LL |     use std::iter::Iterator;
-   |         ^^^^^^^^^^^^^^^^^^^
-   |
-   = help: consider importing the item from `core`
+   |         ^^^ help: consider importing the item from `core`: `core`
 
 error: used import from `std` instead of `alloc`
-  --> $DIR/std_instead_of_core.rs:47:9
+  --> $DIR/std_instead_of_core.rs:46:9
    |
 LL |     use std::vec;
-   |         ^^^^^^^^
+   |         ^^^ help: consider importing the item from `alloc`: `alloc`
    |
-   = help: consider importing the item from `alloc`
    = note: `-D clippy::std-instead-of-alloc` implied by `-D warnings`
 
 error: used import from `std` instead of `alloc`
-  --> $DIR/std_instead_of_core.rs:49:9
+  --> $DIR/std_instead_of_core.rs:48:9
    |
 LL |     use std::vec::Vec;
-   |         ^^^^^^^^^^^^^
-   |
-   = help: consider importing the item from `alloc`
+   |         ^^^ help: consider importing the item from `alloc`: `alloc`
 
 error: used import from `alloc` instead of `core`
-  --> $DIR/std_instead_of_core.rs:55:9
+  --> $DIR/std_instead_of_core.rs:54:9
    |
 LL |     use alloc::slice::from_ref;
-   |         ^^^^^^^^^^^^^^^^^^^^^^
+   |         ^^^^^ help: consider importing the item from `core`: `core`
    |
-   = help: consider importing the item from `core`
    = note: `-D clippy::alloc-instead-of-core` implied by `-D warnings`
 
-error: aborting due to 12 previous errors
+error: aborting due to 11 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 1317378b9e31306f45ece0be21104a798b4ba73c Mon Sep 17 00:00:00 2001
From: Mario Carneiro <di.gama@gmail.com>
Date: Sun, 3 Sep 2023 17:16:06 +0200
Subject: fix todo item check, remove unimplemented

---
 clippy_lints/src/loops/never_loop.rs |  4 ++--
 tests/ui/never_loop.rs               |  2 +-
 tests/ui/never_loop.stderr           | 11 ++++++++++-
 3 files changed, 13 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/never_loop.rs b/clippy_lints/src/loops/never_loop.rs
index 5845be870d4..7b27c4132de 100644
--- a/clippy_lints/src/loops/never_loop.rs
+++ b/clippy_lints/src/loops/never_loop.rs
@@ -7,7 +7,7 @@ use clippy_utils::source::snippet;
 use rustc_errors::Applicability;
 use rustc_hir::{Block, Destination, Expr, ExprKind, HirId, InlineAsmOperand, Pat, Stmt, StmtKind};
 use rustc_lint::LateContext;
-use rustc_span::Span;
+use rustc_span::{sym, Span};
 use std::iter::{once, Iterator};
 
 pub(super) fn check<'tcx>(
@@ -273,7 +273,7 @@ fn never_loop_expr<'tcx>(
     });
     if  let NeverLoopResult::Diverging = result &&
         let Some(macro_call) = root_macro_call_first_node(cx, expr) &&
-        let "todo" | "unimplemented" = cx.tcx.item_name(macro_call.def_id).as_str()
+        let Some(sym::todo_macro) = cx.tcx.get_diagnostic_name(macro_call.def_id)
     {
         // We return MayContinueMainLoop here because we treat `todo!()` and
         // `unimplemented!()` macros as potentially containing any code,
diff --git a/tests/ui/never_loop.rs b/tests/ui/never_loop.rs
index cee52dfd85b..c67a6d4494e 100644
--- a/tests/ui/never_loop.rs
+++ b/tests/ui/never_loop.rs
@@ -391,7 +391,7 @@ pub fn test32() {
         panic!("oh no");
     }
     loop {
-        // no error
+        //~^ ERROR: this loop never actually loops
         unimplemented!("not yet");
     }
     loop {
diff --git a/tests/ui/never_loop.stderr b/tests/ui/never_loop.stderr
index 37ccd63d27c..50cec32cabd 100644
--- a/tests/ui/never_loop.stderr
+++ b/tests/ui/never_loop.stderr
@@ -170,5 +170,14 @@ LL | |         panic!("oh no");
 LL | |     }
    | |_____^
 
-error: aborting due to 15 previous errors
+error: this loop never actually loops
+  --> $DIR/never_loop.rs:393:5
+   |
+LL | /     loop {
+LL | |
+LL | |         unimplemented!("not yet");
+LL | |     }
+   | |_____^
+
+error: aborting due to 16 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 726214596486f59064747469dd86f19cf00ba6a3 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Sun, 3 Sep 2023 22:21:03 +0200
Subject: [`implied_bounds_in_impl`]: fix suggestion for assoc types

---
 clippy_lints/src/implied_bounds_in_impls.rs | 79 ++++++++++++++++++++++++-----
 tests/ui/implied_bounds_in_impls.fixed      | 39 ++++++++++++++
 tests/ui/implied_bounds_in_impls.rs         | 39 ++++++++++++++
 tests/ui/implied_bounds_in_impls.stderr     | 50 +++++++++++++++++-
 4 files changed, 194 insertions(+), 13 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/implied_bounds_in_impls.rs b/clippy_lints/src/implied_bounds_in_impls.rs
index 64bdb8ba84e..165dc2548e1 100644
--- a/clippy_lints/src/implied_bounds_in_impls.rs
+++ b/clippy_lints/src/implied_bounds_in_impls.rs
@@ -149,7 +149,7 @@ fn check(cx: &LateContext<'_>, decl: &FnDecl<'_>) {
                 && let predicates = cx.tcx.super_predicates_of(trait_def_id).predicates
                 && !predicates.is_empty() // If the trait has no supertrait, there is nothing to add.
             {
-                Some((bound.span(), path.args.map_or([].as_slice(), |a| a.args), predicates, trait_def_id))
+                Some((bound.span(), path, predicates, trait_def_id))
             } else {
                 None
             }
@@ -162,10 +162,14 @@ fn check(cx: &LateContext<'_>, decl: &FnDecl<'_>) {
             if let GenericBound::Trait(poly_trait, TraitBoundModifier::None) = bound
                 && let [.., path] = poly_trait.trait_ref.path.segments
                 && let implied_args = path.args.map_or([].as_slice(), |a| a.args)
+                && let implied_bindings = path.args.map_or([].as_slice(), |a| a.bindings)
                 && let Some(def_id) = poly_trait.trait_ref.path.res.opt_def_id()
-                && let Some(implied_by_span) = implied_bounds
+                && let Some((implied_by_span, implied_by_args, implied_by_bindings)) = implied_bounds
                     .iter()
-                    .find_map(|&(span, implied_by_args, preds, implied_by_def_id)| {
+                    .find_map(|&(span, implied_by_path, preds, implied_by_def_id)| {
+                        let implied_by_args = implied_by_path.args.map_or([].as_slice(), |a| a.args);
+                        let implied_by_bindings = implied_by_path.args.map_or([].as_slice(), |a| a.bindings);
+
                         preds.iter().find_map(|(clause, _)| {
                             if let ClauseKind::Trait(tr) = clause.kind().skip_binder()
                                 && tr.def_id() == def_id
@@ -178,7 +182,7 @@ fn check(cx: &LateContext<'_>, decl: &FnDecl<'_>) {
                                     def_id,
                                 )
                             {
-                                Some(span)
+                                Some((span, implied_by_args, implied_by_bindings))
                             } else {
                                 None
                             }
@@ -192,21 +196,72 @@ fn check(cx: &LateContext<'_>, decl: &FnDecl<'_>) {
                     &format!("this bound is already specified as the supertrait of `{implied_by}`"),
                     |diag| {
                         // If we suggest removing a bound, we may also need extend the span
-                        // to include the `+` token, so we don't end up with something like `impl + B`
+                        // to include the `+` token that is ahead or behind,
+                        // so we don't end up with something like `impl + B` or `impl A + `
 
                         let implied_span_extended = if let Some(next_bound) = opaque_ty.bounds.get(index + 1) {
                             poly_trait.span.to(next_bound.span().shrink_to_lo())
+                        } else if index > 0
+                            && let Some(prev_bound) = opaque_ty.bounds.get(index - 1)
+                        {
+                            prev_bound.span().shrink_to_hi().to(poly_trait.span.shrink_to_hi())
                         } else {
                             poly_trait.span
                         };
 
-                        diag.span_suggestion_with_style(
-                            implied_span_extended,
-                            "try removing this bound",
-                            "",
-                            Applicability::MachineApplicable,
-                            SuggestionStyle::ShowAlways
-                        );
+                        let mut sugg = vec![
+                            (implied_span_extended, String::new()),
+                        ];
+
+                        // We also might need to include associated type binding that were specified in the implied bound,
+                        // but omitted in the implied-by bound:
+                        // `fn f() -> impl Deref<Target = u8> + DerefMut`
+                        // If we're going to suggest removing `Deref<..>`, we'll need to put `<Target = u8>` on `DerefMut`
+                        let omitted_assoc_tys: Vec<_> = implied_bindings
+                            .iter()
+                            .filter(|binding| {
+                                implied_by_bindings
+                                    .iter()
+                                    // TODO: is checking idents enough for stuff like `<Target: Sized> == <Target = u8>`
+                                    .find(|b| b.ident == binding.ident)
+                                    .is_none()
+                            })
+                            .collect();
+                        
+                        if !omitted_assoc_tys.is_empty() {
+                            // `<>` needs to be added if there aren't yet any generic arguments or bindings
+                            let needs_angle_brackets = implied_by_args.is_empty() && implied_by_bindings.is_empty();
+                            let insert_span = match (implied_by_args, implied_by_bindings) {
+                                ([.., arg], [.., binding]) => arg.span().max(binding.span).shrink_to_hi(),
+                                ([.., arg], []) => arg.span().shrink_to_hi(),
+                                ([], [.., binding]) => binding.span.shrink_to_hi(),
+                                ([], []) => implied_by_span.shrink_to_hi(),
+                            };
+
+                            let mut associated_tys_sugg = if needs_angle_brackets {
+                                "<".to_owned()
+                            } else {
+                                // If angle brackets aren't needed (i.e., there are already generic arguments or bindings),
+                                // we need to add a comma:
+                                // `impl A<B, C >`
+                                //             ^ if we insert `Assoc=i32` without a comma here, that'd be invalid syntax:
+                                // `impl A<B, C Assoc=i32>`
+                                ", ".to_owned()
+                            };
+
+                            for (index, binding) in omitted_assoc_tys.into_iter().enumerate() {
+                                if index > 0 {
+                                    associated_tys_sugg += ", ";
+                                }
+                                associated_tys_sugg += &snippet(cx, binding.span, "..");
+                            }
+                            if needs_angle_brackets {
+                                associated_tys_sugg += ">";
+                            }
+                            sugg.push((insert_span, associated_tys_sugg));
+                        }
+
+                        diag.multipart_suggestion_with_style("try removing this bound", sugg, Applicability::MachineApplicable, SuggestionStyle::ShowAlways);
                     }
                 );
             }
diff --git a/tests/ui/implied_bounds_in_impls.fixed b/tests/ui/implied_bounds_in_impls.fixed
index 69fcc8921d6..a50fa0ccf6e 100644
--- a/tests/ui/implied_bounds_in_impls.fixed
+++ b/tests/ui/implied_bounds_in_impls.fixed
@@ -83,4 +83,43 @@ mod issue11422 {
     fn f() -> impl Trait1<()> + Trait2 {}
 }
 
+mod issue11435 {
+    // Associated type needs to be included on DoubleEndedIterator in the suggestion
+    fn my_iter() -> impl DoubleEndedIterator<Item = u32> {
+        0..5
+    }
+
+    // Removing the `Clone` bound should include the `+` behind it in its remove suggestion
+    fn f() -> impl Copy {
+        1
+    }
+
+    trait Trait1<T> {
+        type U;
+    }
+    impl Trait1<i32> for () {
+        type U = i64;
+    }
+    trait Trait2<T>: Trait1<T> {}
+    impl Trait2<i32> for () {}
+
+    // When the other trait has generics, it shouldn't add another pair of `<>`
+    fn f2() -> impl Trait2<i32, U = i64> {}
+
+    trait Trait3<T, U, V> {
+        type X;
+        type Y;
+    }
+    trait Trait4<T>: Trait3<T, i16, i64> {}
+    impl Trait3<i8, i16, i64> for () {
+        type X = i32;
+        type Y = i128;
+    }
+    impl Trait4<i8> for () {}
+
+    // Associated type `X` is specified, but `Y` is not, so only that associated type should be moved
+    // over
+    fn f3() -> impl Trait4<i8, X = i32, Y = i128> {}
+}
+
 fn main() {}
diff --git a/tests/ui/implied_bounds_in_impls.rs b/tests/ui/implied_bounds_in_impls.rs
index 5504feae613..e74ed4425b8 100644
--- a/tests/ui/implied_bounds_in_impls.rs
+++ b/tests/ui/implied_bounds_in_impls.rs
@@ -83,4 +83,43 @@ mod issue11422 {
     fn f() -> impl Trait1<()> + Trait2 {}
 }
 
+mod issue11435 {
+    // Associated type needs to be included on DoubleEndedIterator in the suggestion
+    fn my_iter() -> impl Iterator<Item = u32> + DoubleEndedIterator {
+        0..5
+    }
+
+    // Removing the `Clone` bound should include the `+` behind it in its remove suggestion
+    fn f() -> impl Copy + Clone {
+        1
+    }
+
+    trait Trait1<T> {
+        type U;
+    }
+    impl Trait1<i32> for () {
+        type U = i64;
+    }
+    trait Trait2<T>: Trait1<T> {}
+    impl Trait2<i32> for () {}
+
+    // When the other trait has generics, it shouldn't add another pair of `<>`
+    fn f2() -> impl Trait1<i32, U = i64> + Trait2<i32> {}
+
+    trait Trait3<T, U, V> {
+        type X;
+        type Y;
+    }
+    trait Trait4<T>: Trait3<T, i16, i64> {}
+    impl Trait3<i8, i16, i64> for () {
+        type X = i32;
+        type Y = i128;
+    }
+    impl Trait4<i8> for () {}
+
+    // Associated type `X` is specified, but `Y` is not, so only that associated type should be moved
+    // over
+    fn f3() -> impl Trait3<i8, i16, i64, X = i32, Y = i128> + Trait4<i8, X = i32> {}
+}
+
 fn main() {}
diff --git a/tests/ui/implied_bounds_in_impls.stderr b/tests/ui/implied_bounds_in_impls.stderr
index d6a4ae889fe..9f381efba0a 100644
--- a/tests/ui/implied_bounds_in_impls.stderr
+++ b/tests/ui/implied_bounds_in_impls.stderr
@@ -143,5 +143,53 @@ LL -     fn default_generic_param2() -> impl PartialOrd + PartialEq + Debug {}
 LL +     fn default_generic_param2() -> impl PartialOrd + Debug {}
    |
 
-error: aborting due to 12 previous errors
+error: this bound is already specified as the supertrait of `DoubleEndedIterator`
+  --> $DIR/implied_bounds_in_impls.rs:88:26
+   |
+LL |     fn my_iter() -> impl Iterator<Item = u32> + DoubleEndedIterator {
+   |                          ^^^^^^^^^^^^^^^^^^^^
+   |
+help: try removing this bound
+   |
+LL -     fn my_iter() -> impl Iterator<Item = u32> + DoubleEndedIterator {
+LL +     fn my_iter() -> impl DoubleEndedIterator<Item = u32> {
+   |
+
+error: this bound is already specified as the supertrait of `Copy`
+  --> $DIR/implied_bounds_in_impls.rs:93:27
+   |
+LL |     fn f() -> impl Copy + Clone {
+   |                           ^^^^^
+   |
+help: try removing this bound
+   |
+LL -     fn f() -> impl Copy + Clone {
+LL +     fn f() -> impl Copy {
+   |
+
+error: this bound is already specified as the supertrait of `Trait2<i32>`
+  --> $DIR/implied_bounds_in_impls.rs:107:21
+   |
+LL |     fn f2() -> impl Trait1<i32, U = i64> + Trait2<i32> {}
+   |                     ^^^^^^^^^^^^^^^^^^^^
+   |
+help: try removing this bound
+   |
+LL -     fn f2() -> impl Trait1<i32, U = i64> + Trait2<i32> {}
+LL +     fn f2() -> impl Trait2<i32, U = i64> {}
+   |
+
+error: this bound is already specified as the supertrait of `Trait4<i8, X = i32>`
+  --> $DIR/implied_bounds_in_impls.rs:122:21
+   |
+LL |     fn f3() -> impl Trait3<i8, i16, i64, X = i32, Y = i128> + Trait4<i8, X = i32> {}
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: try removing this bound
+   |
+LL -     fn f3() -> impl Trait3<i8, i16, i64, X = i32, Y = i128> + Trait4<i8, X = i32> {}
+LL +     fn f3() -> impl Trait4<i8, X = i32, Y = i128> {}
+   |
+
+error: aborting due to 16 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 32e25118a69e0235f14dd971714bc653e8788d8c Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Sun, 3 Sep 2023 22:53:37 +0200
Subject: extract lint emitting into separate fn

---
 clippy_lints/src/implied_bounds_in_impls.rs | 170 ++++++++++++++++------------
 1 file changed, 96 insertions(+), 74 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/implied_bounds_in_impls.rs b/clippy_lints/src/implied_bounds_in_impls.rs
index 165dc2548e1..120ab5a034e 100644
--- a/clippy_lints/src/implied_bounds_in_impls.rs
+++ b/clippy_lints/src/implied_bounds_in_impls.rs
@@ -50,6 +50,93 @@ declare_clippy_lint! {
 }
 declare_lint_pass!(ImpliedBoundsInImpls => [IMPLIED_BOUNDS_IN_IMPLS]);
 
+#[allow(clippy::too_many_arguments)]
+fn emit_lint(
+    cx: &LateContext<'_>,
+    poly_trait: &rustc_hir::PolyTraitRef<'_>,
+    opaque_ty: &rustc_hir::OpaqueTy<'_>,
+    index: usize,
+    implied_bindings: &[rustc_hir::TypeBinding<'_>],
+    implied_by_bindings: &[rustc_hir::TypeBinding<'_>],
+    implied_by_args: &[GenericArg<'_>],
+    implied_by_span: Span,
+) {
+    let implied_by = snippet(cx, implied_by_span, "..");
+
+    span_lint_and_then(
+        cx,
+        IMPLIED_BOUNDS_IN_IMPLS,
+        poly_trait.span,
+        &format!("this bound is already specified as the supertrait of `{implied_by}`"),
+        |diag| {
+            // If we suggest removing a bound, we may also need extend the span
+            // to include the `+` token that is ahead or behind,
+            // so we don't end up with something like `impl + B` or `impl A + `
+
+            let implied_span_extended = if let Some(next_bound) = opaque_ty.bounds.get(index + 1) {
+                poly_trait.span.to(next_bound.span().shrink_to_lo())
+            } else if index > 0
+                && let Some(prev_bound) = opaque_ty.bounds.get(index - 1)
+            {
+                prev_bound.span().shrink_to_hi().to(poly_trait.span.shrink_to_hi())
+            } else {
+                poly_trait.span
+            };
+
+            let mut sugg = vec![(implied_span_extended, String::new())];
+
+            // We also might need to include associated type binding that were specified in the implied bound,
+            // but omitted in the implied-by bound:
+            // `fn f() -> impl Deref<Target = u8> + DerefMut`
+            // If we're going to suggest removing `Deref<..>`, we'll need to put `<Target = u8>` on `DerefMut`
+            let omitted_assoc_tys: Vec<_> = implied_bindings
+                .iter()
+                .filter(|binding| !implied_by_bindings.iter().any(|b| b.ident == binding.ident))
+                .collect();
+
+            if !omitted_assoc_tys.is_empty() {
+                // `<>` needs to be added if there aren't yet any generic arguments or bindings
+                let needs_angle_brackets = implied_by_args.is_empty() && implied_by_bindings.is_empty();
+                let insert_span = match (implied_by_args, implied_by_bindings) {
+                    ([.., arg], [.., binding]) => arg.span().max(binding.span).shrink_to_hi(),
+                    ([.., arg], []) => arg.span().shrink_to_hi(),
+                    ([], [.., binding]) => binding.span.shrink_to_hi(),
+                    ([], []) => implied_by_span.shrink_to_hi(),
+                };
+
+                let mut associated_tys_sugg = if needs_angle_brackets {
+                    "<".to_owned()
+                } else {
+                    // If angle brackets aren't needed (i.e., there are already generic arguments or bindings),
+                    // we need to add a comma:
+                    // `impl A<B, C >`
+                    //             ^ if we insert `Assoc=i32` without a comma here, that'd be invalid syntax:
+                    // `impl A<B, C Assoc=i32>`
+                    ", ".to_owned()
+                };
+
+                for (index, binding) in omitted_assoc_tys.into_iter().enumerate() {
+                    if index > 0 {
+                        associated_tys_sugg += ", ";
+                    }
+                    associated_tys_sugg += &snippet(cx, binding.span, "..");
+                }
+                if needs_angle_brackets {
+                    associated_tys_sugg += ">";
+                }
+                sugg.push((insert_span, associated_tys_sugg));
+            }
+
+            diag.multipart_suggestion_with_style(
+                "try removing this bound",
+                sugg,
+                Applicability::MachineApplicable,
+                SuggestionStyle::ShowAlways,
+            );
+        },
+    );
+}
+
 /// Tries to "resolve" a type.
 /// The index passed to this function must start with `Self=0`, i.e. it must be a valid
 /// type parameter index.
@@ -189,80 +276,15 @@ fn check(cx: &LateContext<'_>, decl: &FnDecl<'_>) {
                         })
                     })
             {
-                let implied_by = snippet(cx, implied_by_span, "..");
-                span_lint_and_then(
-                    cx, IMPLIED_BOUNDS_IN_IMPLS,
-                    poly_trait.span,
-                    &format!("this bound is already specified as the supertrait of `{implied_by}`"),
-                    |diag| {
-                        // If we suggest removing a bound, we may also need extend the span
-                        // to include the `+` token that is ahead or behind,
-                        // so we don't end up with something like `impl + B` or `impl A + `
-
-                        let implied_span_extended = if let Some(next_bound) = opaque_ty.bounds.get(index + 1) {
-                            poly_trait.span.to(next_bound.span().shrink_to_lo())
-                        } else if index > 0
-                            && let Some(prev_bound) = opaque_ty.bounds.get(index - 1)
-                        {
-                            prev_bound.span().shrink_to_hi().to(poly_trait.span.shrink_to_hi())
-                        } else {
-                            poly_trait.span
-                        };
-
-                        let mut sugg = vec![
-                            (implied_span_extended, String::new()),
-                        ];
-
-                        // We also might need to include associated type binding that were specified in the implied bound,
-                        // but omitted in the implied-by bound:
-                        // `fn f() -> impl Deref<Target = u8> + DerefMut`
-                        // If we're going to suggest removing `Deref<..>`, we'll need to put `<Target = u8>` on `DerefMut`
-                        let omitted_assoc_tys: Vec<_> = implied_bindings
-                            .iter()
-                            .filter(|binding| {
-                                implied_by_bindings
-                                    .iter()
-                                    // TODO: is checking idents enough for stuff like `<Target: Sized> == <Target = u8>`
-                                    .find(|b| b.ident == binding.ident)
-                                    .is_none()
-                            })
-                            .collect();
-                        
-                        if !omitted_assoc_tys.is_empty() {
-                            // `<>` needs to be added if there aren't yet any generic arguments or bindings
-                            let needs_angle_brackets = implied_by_args.is_empty() && implied_by_bindings.is_empty();
-                            let insert_span = match (implied_by_args, implied_by_bindings) {
-                                ([.., arg], [.., binding]) => arg.span().max(binding.span).shrink_to_hi(),
-                                ([.., arg], []) => arg.span().shrink_to_hi(),
-                                ([], [.., binding]) => binding.span.shrink_to_hi(),
-                                ([], []) => implied_by_span.shrink_to_hi(),
-                            };
-
-                            let mut associated_tys_sugg = if needs_angle_brackets {
-                                "<".to_owned()
-                            } else {
-                                // If angle brackets aren't needed (i.e., there are already generic arguments or bindings),
-                                // we need to add a comma:
-                                // `impl A<B, C >`
-                                //             ^ if we insert `Assoc=i32` without a comma here, that'd be invalid syntax:
-                                // `impl A<B, C Assoc=i32>`
-                                ", ".to_owned()
-                            };
-
-                            for (index, binding) in omitted_assoc_tys.into_iter().enumerate() {
-                                if index > 0 {
-                                    associated_tys_sugg += ", ";
-                                }
-                                associated_tys_sugg += &snippet(cx, binding.span, "..");
-                            }
-                            if needs_angle_brackets {
-                                associated_tys_sugg += ">";
-                            }
-                            sugg.push((insert_span, associated_tys_sugg));
-                        }
-
-                        diag.multipart_suggestion_with_style("try removing this bound", sugg, Applicability::MachineApplicable, SuggestionStyle::ShowAlways);
-                    }
+                emit_lint(
+                    cx,
+                    poly_trait,
+                    opaque_ty,
+                    index,
+                    implied_bindings,
+                    implied_by_bindings,
+                    implied_by_args,
+                    implied_by_span
                 );
             }
         }
-- 
cgit 1.4.1-3-g733a5


From 4e0a3465d1cf3f7fee92168deef9668508d5b400 Mon Sep 17 00:00:00 2001
From: Mario Carneiro <di.gama@gmail.com>
Date: Mon, 4 Sep 2023 06:35:51 +0200
Subject: fix vec.rs test, comment

---
 clippy_lints/src/loops/never_loop.rs |  7 +++----
 tests/ui/vec.fixed                   |  1 +
 tests/ui/vec.rs                      |  1 +
 tests/ui/vec.stderr                  | 10 +++++-----
 4 files changed, 10 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/never_loop.rs b/clippy_lints/src/loops/never_loop.rs
index 7b27c4132de..3d8a4cd948a 100644
--- a/clippy_lints/src/loops/never_loop.rs
+++ b/clippy_lints/src/loops/never_loop.rs
@@ -275,10 +275,9 @@ fn never_loop_expr<'tcx>(
         let Some(macro_call) = root_macro_call_first_node(cx, expr) &&
         let Some(sym::todo_macro) = cx.tcx.get_diagnostic_name(macro_call.def_id)
     {
-        // We return MayContinueMainLoop here because we treat `todo!()` and
-        // `unimplemented!()` macros as potentially containing any code,
-        // including a continue of the main loop. This effectively silences the lint
-        // whenever a loop contains one of these macros anywhere.
+        // We return MayContinueMainLoop here because we treat `todo!()`
+        // as potentially containing any code, including a continue of the main loop.
+        // This effectively silences the lint whenever a loop contains this macro anywhere.
         NeverLoopResult::MayContinueMainLoop
     } else {
         result
diff --git a/tests/ui/vec.fixed b/tests/ui/vec.fixed
index 3ff2acbe28f..bcbca971a78 100644
--- a/tests/ui/vec.fixed
+++ b/tests/ui/vec.fixed
@@ -120,6 +120,7 @@ fn issue11075() {
             stringify!($e)
         };
     }
+    #[allow(clippy::never_loop)]
     for _string in [repro!(true), repro!(null)] {
         unimplemented!();
     }
diff --git a/tests/ui/vec.rs b/tests/ui/vec.rs
index 2ab025f424a..087425585de 100644
--- a/tests/ui/vec.rs
+++ b/tests/ui/vec.rs
@@ -120,6 +120,7 @@ fn issue11075() {
             stringify!($e)
         };
     }
+    #[allow(clippy::never_loop)]
     for _string in vec![repro!(true), repro!(null)] {
         unimplemented!();
     }
diff --git a/tests/ui/vec.stderr b/tests/ui/vec.stderr
index 5cd6d9fa8c7..a133b4041d4 100644
--- a/tests/ui/vec.stderr
+++ b/tests/ui/vec.stderr
@@ -85,31 +85,31 @@ LL |     for _ in vec![1, 2, 3] {}
    |              ^^^^^^^^^^^^^ help: you can use an array directly: `[1, 2, 3]`
 
 error: useless use of `vec!`
-  --> $DIR/vec.rs:123:20
+  --> $DIR/vec.rs:124:20
    |
 LL |     for _string in vec![repro!(true), repro!(null)] {
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: you can use an array directly: `[repro!(true), repro!(null)]`
 
 error: useless use of `vec!`
-  --> $DIR/vec.rs:140:18
+  --> $DIR/vec.rs:141:18
    |
 LL |     in_macro!(1, vec![1, 2], vec![1; 2]);
    |                  ^^^^^^^^^^ help: you can use an array directly: `[1, 2]`
 
 error: useless use of `vec!`
-  --> $DIR/vec.rs:140:30
+  --> $DIR/vec.rs:141:30
    |
 LL |     in_macro!(1, vec![1, 2], vec![1; 2]);
    |                              ^^^^^^^^^^ help: you can use an array directly: `[1; 2]`
 
 error: useless use of `vec!`
-  --> $DIR/vec.rs:159:14
+  --> $DIR/vec.rs:160:14
    |
 LL |     for a in vec![1, 2, 3] {
    |              ^^^^^^^^^^^^^ help: you can use an array directly: `[1, 2, 3]`
 
 error: useless use of `vec!`
-  --> $DIR/vec.rs:163:14
+  --> $DIR/vec.rs:164:14
    |
 LL |     for a in vec![String::new(), String::new()] {
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: you can use an array directly: `[String::new(), String::new()]`
-- 
cgit 1.4.1-3-g733a5


From 438f934f1c330cc43693a2b9ca404f3c704c2ca1 Mon Sep 17 00:00:00 2001
From: J-ZhengLi <lizheng135@huawei.com>
Date: Mon, 4 Sep 2023 16:15:45 +0800
Subject: suggest passing function instead of calling it in
 [`option_if_let_else`]

---
 clippy_lints/src/option_if_let_else.rs | 19 +++++++++-
 tests/ui/option_if_let_else.fixed      | 17 ++++++++-
 tests/ui/option_if_let_else.rs         | 19 +++++++++-
 tests/ui/option_if_let_else.stderr     | 67 +++++++++++++++++++++-------------
 4 files changed, 93 insertions(+), 29 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/option_if_let_else.rs b/clippy_lints/src/option_if_let_else.rs
index a7a7f4fd8fa..156b95d644a 100644
--- a/clippy_lints/src/option_if_let_else.rs
+++ b/clippy_lints/src/option_if_let_else.rs
@@ -165,6 +165,13 @@ fn try_get_option_occurrence<'tcx>(
             }
 
             let mut app = Applicability::Unspecified;
+
+            let (none_body, is_argless_call) = if let Some(call_expr) = try_get_argless_call_expr(none_body) {
+                (call_expr, true)
+            } else {
+                (none_body, false)
+            };
+
             return Some(OptionOccurrence {
                 option: format_option_in_sugg(
                     Sugg::hir_with_context(cx, cond_expr, ctxt, "..", &mut app),
@@ -178,7 +185,7 @@ fn try_get_option_occurrence<'tcx>(
                 ),
                 none_expr: format!(
                     "{}{}",
-                    if method_sugg == "map_or" { "" } else if is_result { "|_| " } else { "|| "},
+                    if method_sugg == "map_or" || is_argless_call { "" } else if is_result { "|_| " } else { "|| "},
                     Sugg::hir_with_context(cx, none_body, ctxt, "..", &mut app),
                 ),
             });
@@ -188,6 +195,16 @@ fn try_get_option_occurrence<'tcx>(
     None
 }
 
+/// Gets the call expr iff it does not have any args and was not from macro expansion.
+fn try_get_argless_call_expr<'tcx>(expr: &Expr<'tcx>) -> Option<&'tcx Expr<'tcx>> {
+    if !expr.span.from_expansion() &&
+        let ExprKind::Call(call_expr, []) = expr.kind
+    {
+        return Some(call_expr);
+    }
+    None
+}
+
 fn try_get_inner_pat_and_is_result<'tcx>(cx: &LateContext<'tcx>, pat: &Pat<'tcx>) -> Option<(&'tcx Pat<'tcx>, bool)> {
     if let PatKind::TupleStruct(ref qpath, [inner_pat], ..) = pat.kind {
         let res = cx.qpath_res(qpath, pat.hir_id);
diff --git a/tests/ui/option_if_let_else.fixed b/tests/ui/option_if_let_else.fixed
index c3415a7df9e..f0113ca696e 100644
--- a/tests/ui/option_if_let_else.fixed
+++ b/tests/ui/option_if_let_else.fixed
@@ -1,7 +1,6 @@
 #![warn(clippy::option_if_let_else)]
 #![allow(
     unused_tuple_struct_fields,
-    clippy::redundant_closure,
     clippy::ref_option_ref,
     clippy::equatable_if_let,
     clippy::let_unit_value,
@@ -52,7 +51,7 @@ fn impure_else(arg: Option<i32>) {
         println!("return 1");
         1
     };
-    let _ = arg.map_or_else(|| side_effect(), |x| x);
+    let _ = arg.map_or_else(side_effect, |x| x);
 }
 
 fn test_map_or_else(arg: Option<u32>) {
@@ -224,3 +223,17 @@ mod issue10729 {
     fn do_something(_value: &str) {}
     fn do_something2(_value: &mut str) {}
 }
+
+fn issue11429() {
+    use std::collections::HashMap;
+
+    macro_rules! new_map {
+        () => {{ HashMap::new() }};
+    }
+
+    let opt: Option<HashMap<u8, u8>> = None;
+
+    let mut _hashmap = opt.as_ref().map_or_else(HashMap::new, |hm| hm.clone());
+
+    let mut _hm = opt.as_ref().map_or_else(|| new_map!(), |hm| hm.clone());
+}
diff --git a/tests/ui/option_if_let_else.rs b/tests/ui/option_if_let_else.rs
index 86537f62057..18b7af44392 100644
--- a/tests/ui/option_if_let_else.rs
+++ b/tests/ui/option_if_let_else.rs
@@ -1,7 +1,6 @@
 #![warn(clippy::option_if_let_else)]
 #![allow(
     unused_tuple_struct_fields,
-    clippy::redundant_closure,
     clippy::ref_option_ref,
     clippy::equatable_if_let,
     clippy::let_unit_value,
@@ -271,3 +270,21 @@ mod issue10729 {
     fn do_something(_value: &str) {}
     fn do_something2(_value: &mut str) {}
 }
+
+fn issue11429() {
+    use std::collections::HashMap;
+
+    macro_rules! new_map {
+        () => {{ HashMap::new() }};
+    }
+
+    let opt: Option<HashMap<u8, u8>> = None;
+
+    let mut _hashmap = if let Some(hm) = &opt {
+        hm.clone()
+    } else {
+        HashMap::new()
+    };
+
+    let mut _hm = if let Some(hm) = &opt { hm.clone() } else { new_map!() };
+}
diff --git a/tests/ui/option_if_let_else.stderr b/tests/ui/option_if_let_else.stderr
index aa2da217400..fe436a349c5 100644
--- a/tests/ui/option_if_let_else.stderr
+++ b/tests/ui/option_if_let_else.stderr
@@ -1,5 +1,5 @@
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:12:5
+  --> $DIR/option_if_let_else.rs:11:5
    |
 LL | /     if let Some(x) = string {
 LL | |         (true, x)
@@ -11,19 +11,19 @@ LL | |     }
    = note: `-D clippy::option-if-let-else` implied by `-D warnings`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:30:13
+  --> $DIR/option_if_let_else.rs:29:13
    |
 LL |     let _ = if let Some(s) = *string { s.len() } else { 0 };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `string.map_or(0, |s| s.len())`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:31:13
+  --> $DIR/option_if_let_else.rs:30:13
    |
 LL |     let _ = if let Some(s) = &num { s } else { &0 };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `num.as_ref().map_or(&0, |s| s)`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:32:13
+  --> $DIR/option_if_let_else.rs:31:13
    |
 LL |       let _ = if let Some(s) = &mut num {
    |  _____________^
@@ -43,13 +43,13 @@ LL ~     });
    |
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:38:13
+  --> $DIR/option_if_let_else.rs:37:13
    |
 LL |     let _ = if let Some(ref s) = num { s } else { &0 };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `num.as_ref().map_or(&0, |s| s)`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:39:13
+  --> $DIR/option_if_let_else.rs:38:13
    |
 LL |       let _ = if let Some(mut s) = num {
    |  _____________^
@@ -69,7 +69,7 @@ LL ~     });
    |
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:45:13
+  --> $DIR/option_if_let_else.rs:44:13
    |
 LL |       let _ = if let Some(ref mut s) = num {
    |  _____________^
@@ -89,7 +89,7 @@ LL ~     });
    |
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:54:5
+  --> $DIR/option_if_let_else.rs:53:5
    |
 LL | /     if let Some(x) = arg {
 LL | |         let y = x * x;
@@ -108,7 +108,7 @@ LL +     })
    |
 
 error: use Option::map_or_else instead of an if let/else
-  --> $DIR/option_if_let_else.rs:67:13
+  --> $DIR/option_if_let_else.rs:66:13
    |
 LL |       let _ = if let Some(x) = arg {
    |  _____________^
@@ -117,10 +117,10 @@ LL | |     } else {
 LL | |         // map_or_else must be suggested
 LL | |         side_effect()
 LL | |     };
-   | |_____^ help: try: `arg.map_or_else(|| side_effect(), |x| x)`
+   | |_____^ help: try: `arg.map_or_else(side_effect, |x| x)`
 
 error: use Option::map_or_else instead of an if let/else
-  --> $DIR/option_if_let_else.rs:76:13
+  --> $DIR/option_if_let_else.rs:75:13
    |
 LL |       let _ = if let Some(x) = arg {
    |  _____________^
@@ -143,7 +143,7 @@ LL ~     }, |x| x * x * x * x);
    |
 
 error: use Option::map_or_else instead of an if let/else
-  --> $DIR/option_if_let_else.rs:109:13
+  --> $DIR/option_if_let_else.rs:108:13
    |
 LL | /             if let Some(idx) = s.find('.') {
 LL | |                 vec![s[..idx].to_string(), s[idx..].to_string()]
@@ -153,7 +153,7 @@ LL | |             }
    | |_____________^ help: try: `s.find('.').map_or_else(|| vec![s.to_string()], |idx| vec![s[..idx].to_string(), s[idx..].to_string()])`
 
 error: use Option::map_or_else instead of an if let/else
-  --> $DIR/option_if_let_else.rs:120:5
+  --> $DIR/option_if_let_else.rs:119:5
    |
 LL | /     if let Ok(binding) = variable {
 LL | |         println!("Ok {binding}");
@@ -172,13 +172,13 @@ LL +     })
    |
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:142:13
+  --> $DIR/option_if_let_else.rs:141:13
    |
 LL |     let _ = if let Some(x) = optional { x + 2 } else { 5 };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `optional.map_or(5, |x| x + 2)`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:152:13
+  --> $DIR/option_if_let_else.rs:151:13
    |
 LL |       let _ = if let Some(x) = Some(0) {
    |  _____________^
@@ -200,13 +200,13 @@ LL ~         });
    |
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:180:13
+  --> $DIR/option_if_let_else.rs:179:13
    |
 LL |     let _ = if let Some(x) = Some(0) { s.len() + x } else { s.len() };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Some(0).map_or(s.len(), |x| s.len() + x)`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:184:13
+  --> $DIR/option_if_let_else.rs:183:13
    |
 LL |       let _ = if let Some(x) = Some(0) {
    |  _____________^
@@ -226,7 +226,7 @@ LL ~     });
    |
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:223:13
+  --> $DIR/option_if_let_else.rs:222:13
    |
 LL |       let _ = match s {
    |  _____________^
@@ -236,7 +236,7 @@ LL | |     };
    | |_____^ help: try: `s.map_or(1, |string| string.len())`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:227:13
+  --> $DIR/option_if_let_else.rs:226:13
    |
 LL |       let _ = match Some(10) {
    |  _____________^
@@ -246,7 +246,7 @@ LL | |     };
    | |_____^ help: try: `Some(10).map_or(5, |a| a + 1)`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:233:13
+  --> $DIR/option_if_let_else.rs:232:13
    |
 LL |       let _ = match res {
    |  _____________^
@@ -256,7 +256,7 @@ LL | |     };
    | |_____^ help: try: `res.map_or(1, |a| a + 1)`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:237:13
+  --> $DIR/option_if_let_else.rs:236:13
    |
 LL |       let _ = match res {
    |  _____________^
@@ -266,13 +266,13 @@ LL | |     };
    | |_____^ help: try: `res.map_or(1, |a| a + 1)`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:241:13
+  --> $DIR/option_if_let_else.rs:240:13
    |
 LL |     let _ = if let Ok(a) = res { a + 1 } else { 5 };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `res.map_or(5, |a| a + 1)`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:258:9
+  --> $DIR/option_if_let_else.rs:257:9
    |
 LL | /         match initial {
 LL | |             Some(value) => do_something(value),
@@ -281,7 +281,7 @@ LL | |         }
    | |_________^ help: try: `initial.as_ref().map_or({}, |value| do_something(value))`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:265:9
+  --> $DIR/option_if_let_else.rs:264:9
    |
 LL | /         match initial {
 LL | |             Some(value) => do_something2(value),
@@ -289,5 +289,22 @@ LL | |             None => {},
 LL | |         }
    | |_________^ help: try: `initial.as_mut().map_or({}, |value| do_something2(value))`
 
-error: aborting due to 23 previous errors
+error: use Option::map_or_else instead of an if let/else
+  --> $DIR/option_if_let_else.rs:283:24
+   |
+LL |       let mut _hashmap = if let Some(hm) = &opt {
+   |  ________________________^
+LL | |         hm.clone()
+LL | |     } else {
+LL | |         HashMap::new()
+LL | |     };
+   | |_____^ help: try: `opt.as_ref().map_or_else(HashMap::new, |hm| hm.clone())`
+
+error: use Option::map_or_else instead of an if let/else
+  --> $DIR/option_if_let_else.rs:289:19
+   |
+LL |     let mut _hm = if let Some(hm) = &opt { hm.clone() } else { new_map!() };
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `opt.as_ref().map_or_else(|| new_map!(), |hm| hm.clone())`
+
+error: aborting due to 25 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From e34e49f7ff8a4fee6667c3ec68a76e2a55e36ad8 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Sun, 6 Aug 2023 23:45:34 +0200
Subject: `useless_conversion`: don't lint if ty param has multiple bounds

---
 clippy_lints/src/useless_conversion.rs | 97 ++++++++++++++++++++++++++++------
 tests/ui/useless_conversion.fixed      | 18 +++++++
 tests/ui/useless_conversion.rs         | 18 +++++++
 tests/ui/useless_conversion.stderr     | 20 +++----
 4 files changed, 127 insertions(+), 26 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/useless_conversion.rs b/clippy_lints/src/useless_conversion.rs
index 5ac4f0aa46c..05acf034a95 100644
--- a/clippy_lints/src/useless_conversion.rs
+++ b/clippy_lints/src/useless_conversion.rs
@@ -1,15 +1,19 @@
+use std::ops::ControlFlow;
+
 use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::{snippet, snippet_with_applicability, snippet_with_context};
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::{is_copy, is_type_diagnostic_item, same_type_and_consts};
-use clippy_utils::{get_parent_expr, is_trait_method, is_ty_alias, match_def_path, path_to_local, paths};
+use clippy_utils::{
+    get_parent_expr, is_diag_trait_item, is_trait_method, is_ty_alias, match_def_path, path_to_local, paths,
+};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::def::DefKind;
 use rustc_hir::def_id::DefId;
 use rustc_hir::{BindingAnnotation, Expr, ExprKind, HirId, MatchSource, Node, PatKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty;
+use rustc_middle::ty::{self, Ty, TyCtxt, TypeSuperVisitable, TypeVisitable, TypeVisitor};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::{sym, Span};
 
@@ -61,22 +65,83 @@ impl MethodOrFunction {
     }
 }
 
-/// Returns the span of the `IntoIterator` trait bound in the function pointed to by `fn_did`
-fn into_iter_bound(cx: &LateContext<'_>, fn_did: DefId, into_iter_did: DefId, param_index: u32) -> Option<Span> {
-    cx.tcx
-        .predicates_of(fn_did)
-        .predicates
-        .iter()
-        .find_map(|&(ref pred, span)| {
-            if let ty::ClauseKind::Trait(tr) = pred.kind().skip_binder()
-                && tr.def_id() == into_iter_did
-                && tr.self_ty().is_param(param_index)
+/// Returns the span of the `IntoIterator` trait bound in the function pointed to by `fn_did`,
+/// iff the `IntoIterator` bound is the only bound on the type parameter.
+///
+/// This last part is important because it might be that the type the user is calling `.into_iter()`
+/// on might not satisfy those other bounds and would result in compile errors:
+/// ```ignore
+/// pub fn foo<I>(i: I)
+/// where I: IntoIterator<Item=i32> + ExactSizeIterator
+///                                   ^^^^^^^^^^^^^^^^^ this extra bound stops us from suggesting to remove `.into_iter()` ...
+/// {
+///     assert_eq!(i.len(), 3);
+/// }
+///
+/// pub fn bar() {
+///     foo([1, 2, 3].into_iter());
+///                  ^^^^^^^^^^^^ ... here, because `[i32; 3]` is not `ExactSizeIterator`
+/// }
+/// ```
+fn exclusive_into_iter_bound(
+    cx: &LateContext<'_>,
+    fn_did: DefId,
+    into_iter_did: DefId,
+    param_index: u32,
+) -> Option<Span> {
+    #[derive(Clone)]
+    struct ExplicitlyUsedTyParam<'a, 'tcx> {
+        cx: &'a LateContext<'tcx>,
+        param_index: u32,
+    }
+
+    impl<'a, 'tcx> TypeVisitor<TyCtxt<'tcx>> for ExplicitlyUsedTyParam<'a, 'tcx> {
+        type BreakTy = ();
+        fn visit_predicate(&mut self, p: ty::Predicate<'tcx>) -> ControlFlow<Self::BreakTy> {
+            // Ignore implicit `T: Sized` bound
+            if let ty::PredicateKind::Clause(ty::ClauseKind::Trait(tr)) = p.kind().skip_binder()
+                && let Some(sized_trait_did) = self.cx.tcx.lang_items().sized_trait()
+                && sized_trait_did == tr.def_id()
             {
-                Some(span)
+                return ControlFlow::Continue(());
+            }
+
+            // Ignore `<T as IntoIterator>::Item` projection, this use of the ty param specifically is fine
+            // because it's what we're already looking for
+            if let ty::PredicateKind::Clause(ty::ClauseKind::Projection(proj)) = p.kind().skip_binder()
+                && is_diag_trait_item(self.cx,proj.projection_ty.def_id, sym::IntoIterator)
+            {
+                return ControlFlow::Continue(());
+            }
+
+            p.super_visit_with(self)
+        }
+
+        fn visit_ty(&mut self, t: Ty<'tcx>) -> ControlFlow<Self::BreakTy> {
+            if t.is_param(self.param_index) {
+                ControlFlow::Break(())
             } else {
-                None
+                ControlFlow::Continue(())
             }
-        })
+        }
+    }
+
+    let mut into_iter_span = None;
+
+    for (pred, span) in cx.tcx.explicit_predicates_of(fn_did).predicates {
+        if let ty::ClauseKind::Trait(tr) = pred.kind().skip_binder()
+            && tr.def_id() == into_iter_did
+            && tr.self_ty().is_param(param_index)
+        {
+            into_iter_span = Some(*span);
+        } else if pred.visit_with(&mut ExplicitlyUsedTyParam { cx, param_index }).is_break() {
+            // Found another reference of the type parameter; conservatively assume
+            // that we can't remove the bound.
+            return None;
+        }
+    }
+
+    into_iter_span
 }
 
 /// Extracts the receiver of a `.into_iter()` method call.
@@ -175,7 +240,7 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
                             && let Some(arg_pos) = args.iter().position(|x| x.hir_id == e.hir_id)
                             && let Some(&into_iter_param) = sig.inputs().get(kind.param_pos(arg_pos))
                             && let ty::Param(param) = into_iter_param.kind()
-                            && let Some(span) = into_iter_bound(cx, parent_fn_did, into_iter_did, param.index)
+                            && let Some(span) = exclusive_into_iter_bound(cx, parent_fn_did, into_iter_did, param.index)
                             && self.expn_depth == 0
                         {
                             // Get the "innermost" `.into_iter()` call, e.g. given this expression:
diff --git a/tests/ui/useless_conversion.fixed b/tests/ui/useless_conversion.fixed
index 52591959905..13463e1782d 100644
--- a/tests/ui/useless_conversion.fixed
+++ b/tests/ui/useless_conversion.fixed
@@ -151,6 +151,8 @@ fn main() {
     let _ = s3;
     let s4: Foo<'a'> = Foo;
     let _ = vec![s4, s4, s4].into_iter();
+
+    issue11300::bar();
 }
 
 #[allow(dead_code)]
@@ -196,6 +198,22 @@ fn explicit_into_iter_fn_arg() {
     b(macro_generated!());
 }
 
+mod issue11300 {
+    pub fn foo<I>(i: I)
+    where
+        I: IntoIterator<Item = i32> + ExactSizeIterator,
+    {
+        assert_eq!(i.len(), 3);
+    }
+
+    pub fn bar() {
+        // This should not trigger the lint:
+        // `[i32, 3]` does not satisfy the `ExactSizeIterator` bound, so the into_iter call cannot be
+        // removed and is not useless.
+        foo([1, 2, 3].into_iter());
+    }
+}
+
 #[derive(Copy, Clone)]
 struct Foo<const C: char>;
 
diff --git a/tests/ui/useless_conversion.rs b/tests/ui/useless_conversion.rs
index befb2f9a5c3..06f3160b0f3 100644
--- a/tests/ui/useless_conversion.rs
+++ b/tests/ui/useless_conversion.rs
@@ -151,6 +151,8 @@ fn main() {
     let _ = Foo::<'a'>::from(s3);
     let s4: Foo<'a'> = Foo;
     let _ = vec![s4, s4, s4].into_iter().into_iter();
+
+    issue11300::bar();
 }
 
 #[allow(dead_code)]
@@ -196,6 +198,22 @@ fn explicit_into_iter_fn_arg() {
     b(macro_generated!());
 }
 
+mod issue11300 {
+    pub fn foo<I>(i: I)
+    where
+        I: IntoIterator<Item = i32> + ExactSizeIterator,
+    {
+        assert_eq!(i.len(), 3);
+    }
+
+    pub fn bar() {
+        // This should not trigger the lint:
+        // `[i32, 3]` does not satisfy the `ExactSizeIterator` bound, so the into_iter call cannot be
+        // removed and is not useless.
+        foo([1, 2, 3].into_iter());
+    }
+}
+
 #[derive(Copy, Clone)]
 struct Foo<const C: char>;
 
diff --git a/tests/ui/useless_conversion.stderr b/tests/ui/useless_conversion.stderr
index 28e7bb61098..e7466e2fbdb 100644
--- a/tests/ui/useless_conversion.stderr
+++ b/tests/ui/useless_conversion.stderr
@@ -119,61 +119,61 @@ LL |     let _ = vec![s4, s4, s4].into_iter().into_iter();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `vec![s4, s4, s4].into_iter()`
 
 error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
-  --> $DIR/useless_conversion.rs:183:7
+  --> $DIR/useless_conversion.rs:185:7
    |
 LL |     b(vec![1, 2].into_iter());
    |       ^^^^^^^^^^^^^^^^^^^^^^ help: consider removing the `.into_iter()`: `vec![1, 2]`
    |
 note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
-  --> $DIR/useless_conversion.rs:173:13
+  --> $DIR/useless_conversion.rs:175:13
    |
 LL |     fn b<T: IntoIterator<Item = i32>>(_: T) {}
    |             ^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
-  --> $DIR/useless_conversion.rs:184:7
+  --> $DIR/useless_conversion.rs:186:7
    |
 LL |     c(vec![1, 2].into_iter());
    |       ^^^^^^^^^^^^^^^^^^^^^^ help: consider removing the `.into_iter()`: `vec![1, 2]`
    |
 note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
-  --> $DIR/useless_conversion.rs:174:18
+  --> $DIR/useless_conversion.rs:176:18
    |
 LL |     fn c(_: impl IntoIterator<Item = i32>) {}
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
-  --> $DIR/useless_conversion.rs:185:7
+  --> $DIR/useless_conversion.rs:187:7
    |
 LL |     d(vec![1, 2].into_iter());
    |       ^^^^^^^^^^^^^^^^^^^^^^ help: consider removing the `.into_iter()`: `vec![1, 2]`
    |
 note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
-  --> $DIR/useless_conversion.rs:177:12
+  --> $DIR/useless_conversion.rs:179:12
    |
 LL |         T: IntoIterator<Item = i32>,
    |            ^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
-  --> $DIR/useless_conversion.rs:188:7
+  --> $DIR/useless_conversion.rs:190:7
    |
 LL |     b(vec![1, 2].into_iter().into_iter());
    |       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing the `.into_iter()`s: `vec![1, 2]`
    |
 note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
-  --> $DIR/useless_conversion.rs:173:13
+  --> $DIR/useless_conversion.rs:175:13
    |
 LL |     fn b<T: IntoIterator<Item = i32>>(_: T) {}
    |             ^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
-  --> $DIR/useless_conversion.rs:189:7
+  --> $DIR/useless_conversion.rs:191:7
    |
 LL |     b(vec![1, 2].into_iter().into_iter().into_iter());
    |       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing the `.into_iter()`s: `vec![1, 2]`
    |
 note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
-  --> $DIR/useless_conversion.rs:173:13
+  --> $DIR/useless_conversion.rs:175:13
    |
 LL |     fn b<T: IntoIterator<Item = i32>>(_: T) {}
    |             ^^^^^^^^^^^^^^^^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From cf10690ad4e1c4df0794fcf072f65515cf8bbadd Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Mon, 7 Aug 2023 04:04:51 +0200
Subject: check that the receiver type satisfies bounds

---
 clippy_lints/src/useless_conversion.rs | 121 ++++++++++++++++-----------------
 tests/ui/useless_conversion.fixed      |  32 +++++++++
 tests/ui/useless_conversion.rs         |  32 +++++++++
 tests/ui/useless_conversion.stderr     |  26 ++++++-
 4 files changed, 148 insertions(+), 63 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/useless_conversion.rs b/clippy_lints/src/useless_conversion.rs
index 05acf034a95..5afb1f76df8 100644
--- a/clippy_lints/src/useless_conversion.rs
+++ b/clippy_lints/src/useless_conversion.rs
@@ -1,21 +1,21 @@
-use std::ops::ControlFlow;
-
 use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::{snippet, snippet_with_applicability, snippet_with_context};
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::{is_copy, is_type_diagnostic_item, same_type_and_consts};
-use clippy_utils::{
-    get_parent_expr, is_diag_trait_item, is_trait_method, is_ty_alias, match_def_path, path_to_local, paths,
-};
+use clippy_utils::{get_parent_expr, is_trait_method, is_ty_alias, match_def_path, path_to_local, paths};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::def::DefKind;
 use rustc_hir::def_id::DefId;
 use rustc_hir::{BindingAnnotation, Expr, ExprKind, HirId, MatchSource, Node, PatKind};
+use rustc_infer::infer::TyCtxtInferExt;
+use rustc_infer::traits::Obligation;
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty::{self, Ty, TyCtxt, TypeSuperVisitable, TypeVisitable, TypeVisitor};
+use rustc_middle::traits::ObligationCause;
+use rustc_middle::ty::{self, EarlyBinder, GenericArg, GenericArgsRef, Ty};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::{sym, Span};
+use rustc_trait_selection::traits::query::evaluate_obligation::InferCtxtExt;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -66,10 +66,7 @@ impl MethodOrFunction {
 }
 
 /// Returns the span of the `IntoIterator` trait bound in the function pointed to by `fn_did`,
-/// iff the `IntoIterator` bound is the only bound on the type parameter.
-///
-/// This last part is important because it might be that the type the user is calling `.into_iter()`
-/// on might not satisfy those other bounds and would result in compile errors:
+/// iff all of the bounds also hold for the type of the `.into_iter()` receiver.
 /// ```ignore
 /// pub fn foo<I>(i: I)
 /// where I: IntoIterator<Item=i32> + ExactSizeIterator
@@ -83,61 +80,42 @@ impl MethodOrFunction {
 ///                  ^^^^^^^^^^^^ ... here, because `[i32; 3]` is not `ExactSizeIterator`
 /// }
 /// ```
-fn exclusive_into_iter_bound(
-    cx: &LateContext<'_>,
+fn into_iter_bound<'tcx>(
+    cx: &LateContext<'tcx>,
     fn_did: DefId,
     into_iter_did: DefId,
+    into_iter_receiver: Ty<'tcx>,
     param_index: u32,
+    node_args: GenericArgsRef<'tcx>,
 ) -> Option<Span> {
-    #[derive(Clone)]
-    struct ExplicitlyUsedTyParam<'a, 'tcx> {
-        cx: &'a LateContext<'tcx>,
-        param_index: u32,
-    }
-
-    impl<'a, 'tcx> TypeVisitor<TyCtxt<'tcx>> for ExplicitlyUsedTyParam<'a, 'tcx> {
-        type BreakTy = ();
-        fn visit_predicate(&mut self, p: ty::Predicate<'tcx>) -> ControlFlow<Self::BreakTy> {
-            // Ignore implicit `T: Sized` bound
-            if let ty::PredicateKind::Clause(ty::ClauseKind::Trait(tr)) = p.kind().skip_binder()
-                && let Some(sized_trait_did) = self.cx.tcx.lang_items().sized_trait()
-                && sized_trait_did == tr.def_id()
-            {
-                return ControlFlow::Continue(());
-            }
-
-            // Ignore `<T as IntoIterator>::Item` projection, this use of the ty param specifically is fine
-            // because it's what we're already looking for
-            if let ty::PredicateKind::Clause(ty::ClauseKind::Projection(proj)) = p.kind().skip_binder()
-                && is_diag_trait_item(self.cx,proj.projection_ty.def_id, sym::IntoIterator)
-            {
-                return ControlFlow::Continue(());
-            }
-
-            p.super_visit_with(self)
-        }
-
-        fn visit_ty(&mut self, t: Ty<'tcx>) -> ControlFlow<Self::BreakTy> {
-            if t.is_param(self.param_index) {
-                ControlFlow::Break(())
-            } else {
-                ControlFlow::Continue(())
-            }
-        }
-    }
-
+    let param_env = cx.tcx.param_env(fn_did);
     let mut into_iter_span = None;
 
     for (pred, span) in cx.tcx.explicit_predicates_of(fn_did).predicates {
-        if let ty::ClauseKind::Trait(tr) = pred.kind().skip_binder()
-            && tr.def_id() == into_iter_did
-            && tr.self_ty().is_param(param_index)
-        {
-            into_iter_span = Some(*span);
-        } else if pred.visit_with(&mut ExplicitlyUsedTyParam { cx, param_index }).is_break() {
-            // Found another reference of the type parameter; conservatively assume
-            // that we can't remove the bound.
-            return None;
+        if let ty::ClauseKind::Trait(tr) = pred.kind().skip_binder() {
+            if tr.def_id() == into_iter_did && tr.self_ty().is_param(param_index) {
+                into_iter_span = Some(*span);
+            } else {
+                // Substitute generics in the predicate and replace the IntoIterator type parameter with the
+                // `.into_iter()` receiver to see if the bound also holds for that type.
+                let args = cx.tcx.mk_args_from_iter(node_args.iter().enumerate().map(|(i, arg)| {
+                    if i == param_index as usize {
+                        GenericArg::from(into_iter_receiver)
+                    } else {
+                        arg
+                    }
+                }));
+                let predicate = EarlyBinder::bind(tr).instantiate(cx.tcx, args);
+                let obligation = Obligation::new(cx.tcx, ObligationCause::dummy(), param_env, predicate);
+                if !cx
+                    .tcx
+                    .infer_ctxt()
+                    .build()
+                    .predicate_must_hold_modulo_regions(&obligation)
+                {
+                    return None;
+                }
+            }
         }
     }
 
@@ -225,22 +203,41 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
                                     // `fn_sig` does not ICE. (see #11065)
                                     && cx.tcx.opt_def_kind(did).is_some_and(DefKind::is_fn_like) =>
                             {
-                                    Some((did, args, MethodOrFunction::Function))
+                                Some((
+                                    did,
+                                    args,
+                                    cx.typeck_results().node_args(recv.hir_id),
+                                    MethodOrFunction::Function
+                                ))
                             }
                             ExprKind::MethodCall(.., args, _) => {
                                 cx.typeck_results().type_dependent_def_id(parent.hir_id)
-                                    .map(|did| (did, args, MethodOrFunction::Method))
+                                    .map(|did| {
+                                        return (
+                                            did,
+                                            args,
+                                            cx.typeck_results().node_args(recv.hir_id),
+                                            MethodOrFunction::Method
+                                        );
+                                    })
                             }
                             _ => None,
                         };
 
-                        if let Some((parent_fn_did, args, kind)) = parent_fn
+                        if let Some((parent_fn_did, args, node_args, kind)) = parent_fn
                             && let Some(into_iter_did) = cx.tcx.get_diagnostic_item(sym::IntoIterator)
                             && let sig = cx.tcx.fn_sig(parent_fn_did).skip_binder().skip_binder()
                             && let Some(arg_pos) = args.iter().position(|x| x.hir_id == e.hir_id)
                             && let Some(&into_iter_param) = sig.inputs().get(kind.param_pos(arg_pos))
                             && let ty::Param(param) = into_iter_param.kind()
-                            && let Some(span) = exclusive_into_iter_bound(cx, parent_fn_did, into_iter_did, param.index)
+                            && let Some(span) = into_iter_bound(
+                                cx,
+                                parent_fn_did,
+                                into_iter_did,
+                                cx.typeck_results().expr_ty(into_iter_recv),
+                                param.index,
+                                node_args
+                            )
                             && self.expn_depth == 0
                         {
                             // Get the "innermost" `.into_iter()` call, e.g. given this expression:
diff --git a/tests/ui/useless_conversion.fixed b/tests/ui/useless_conversion.fixed
index 13463e1782d..f3504bc62b4 100644
--- a/tests/ui/useless_conversion.fixed
+++ b/tests/ui/useless_conversion.fixed
@@ -206,11 +206,43 @@ mod issue11300 {
         assert_eq!(i.len(), 3);
     }
 
+    trait Helper<T: ?Sized> {}
+    impl Helper<i32> for [i32; 3] {}
+    impl Helper<i32> for std::array::IntoIter<i32, 3> {}
+    impl Helper<()> for std::array::IntoIter<i32, 3> {}
+
+    fn foo2<X: ?Sized, I>(_: I)
+    where
+        I: IntoIterator<Item = i32> + Helper<X>,
+    {
+    }
+
+    trait Helper2<T> {}
+    impl Helper2<std::array::IntoIter<i32, 3>> for i32 {}
+    impl Helper2<[i32; 3]> for i32 {}
+    fn foo3<I>(_: I)
+    where
+        I: IntoIterator<Item = i32>,
+        i32: Helper2<I>,
+    {
+    }
+
     pub fn bar() {
         // This should not trigger the lint:
         // `[i32, 3]` does not satisfy the `ExactSizeIterator` bound, so the into_iter call cannot be
         // removed and is not useless.
         foo([1, 2, 3].into_iter());
+
+        // This should trigger the lint, receiver type [i32; 3] also implements `Helper`
+        foo2::<i32, _>([1, 2, 3]);
+
+        // This again should *not* lint, since X = () and I = std::array::IntoIter<i32, 3>,
+        // and `[i32; 3]: Helper<()>` is not true (only `std::array::IntoIter<i32, 3>: Helper<()>` is).
+        foo2::<(), _>([1, 2, 3].into_iter());
+
+        // This should lint. Removing the `.into_iter()` means that `I` gets substituted with `[i32; 3]`,
+        // and `i32: Helper2<[i32, 3]>` is true, so this call is indeed unncessary.
+        foo3([1, 2, 3]);
     }
 }
 
diff --git a/tests/ui/useless_conversion.rs b/tests/ui/useless_conversion.rs
index 06f3160b0f3..a4f4722927f 100644
--- a/tests/ui/useless_conversion.rs
+++ b/tests/ui/useless_conversion.rs
@@ -206,11 +206,43 @@ mod issue11300 {
         assert_eq!(i.len(), 3);
     }
 
+    trait Helper<T: ?Sized> {}
+    impl Helper<i32> for [i32; 3] {}
+    impl Helper<i32> for std::array::IntoIter<i32, 3> {}
+    impl Helper<()> for std::array::IntoIter<i32, 3> {}
+
+    fn foo2<X: ?Sized, I>(_: I)
+    where
+        I: IntoIterator<Item = i32> + Helper<X>,
+    {
+    }
+
+    trait Helper2<T> {}
+    impl Helper2<std::array::IntoIter<i32, 3>> for i32 {}
+    impl Helper2<[i32; 3]> for i32 {}
+    fn foo3<I>(_: I)
+    where
+        I: IntoIterator<Item = i32>,
+        i32: Helper2<I>,
+    {
+    }
+
     pub fn bar() {
         // This should not trigger the lint:
         // `[i32, 3]` does not satisfy the `ExactSizeIterator` bound, so the into_iter call cannot be
         // removed and is not useless.
         foo([1, 2, 3].into_iter());
+
+        // This should trigger the lint, receiver type [i32; 3] also implements `Helper`
+        foo2::<i32, _>([1, 2, 3].into_iter());
+
+        // This again should *not* lint, since X = () and I = std::array::IntoIter<i32, 3>,
+        // and `[i32; 3]: Helper<()>` is not true (only `std::array::IntoIter<i32, 3>: Helper<()>` is).
+        foo2::<(), _>([1, 2, 3].into_iter());
+
+        // This should lint. Removing the `.into_iter()` means that `I` gets substituted with `[i32; 3]`,
+        // and `i32: Helper2<[i32, 3]>` is true, so this call is indeed unncessary.
+        foo3([1, 2, 3].into_iter());
     }
 }
 
diff --git a/tests/ui/useless_conversion.stderr b/tests/ui/useless_conversion.stderr
index e7466e2fbdb..81a0898bdf6 100644
--- a/tests/ui/useless_conversion.stderr
+++ b/tests/ui/useless_conversion.stderr
@@ -178,5 +178,29 @@ note: this parameter accepts any `IntoIterator`, so you don't need to call `.int
 LL |     fn b<T: IntoIterator<Item = i32>>(_: T) {}
    |             ^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 24 previous errors
+error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
+  --> $DIR/useless_conversion.rs:237:24
+   |
+LL |         foo2::<i32, _>([1, 2, 3].into_iter());
+   |                        ^^^^^^^^^^^^^^^^^^^^^ help: consider removing the `.into_iter()`: `[1, 2, 3]`
+   |
+note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
+  --> $DIR/useless_conversion.rs:216:12
+   |
+LL |         I: IntoIterator<Item = i32> + Helper<X>,
+   |            ^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
+  --> $DIR/useless_conversion.rs:245:14
+   |
+LL |         foo3([1, 2, 3].into_iter());
+   |              ^^^^^^^^^^^^^^^^^^^^^ help: consider removing the `.into_iter()`: `[1, 2, 3]`
+   |
+note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
+  --> $DIR/useless_conversion.rs:225:12
+   |
+LL |         I: IntoIterator<Item = i32>,
+   |            ^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 26 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 2f5c445c0bea87315b5517fce83a2f5442a94bc4 Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Sat, 2 Sep 2023 23:06:16 +0200
Subject: Ignore wildcards in function arguments and local bindings

---
 clippy_lints/src/ignored_unit_patterns.rs | 13 ++++++++++++-
 tests/ui/ignored_unit_patterns.fixed      | 10 +++++++++-
 tests/ui/ignored_unit_patterns.rs         | 10 +++++++++-
 tests/ui/ignored_unit_patterns.stderr     |  8 +++++++-
 4 files changed, 37 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/ignored_unit_patterns.rs b/clippy_lints/src/ignored_unit_patterns.rs
index c635120b882..d8ead1c9d9f 100644
--- a/clippy_lints/src/ignored_unit_patterns.rs
+++ b/clippy_lints/src/ignored_unit_patterns.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use hir::PatKind;
+use hir::{Node, PatKind};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass};
@@ -37,6 +37,17 @@ declare_lint_pass!(IgnoredUnitPatterns => [IGNORED_UNIT_PATTERNS]);
 
 impl<'tcx> LateLintPass<'tcx> for IgnoredUnitPatterns {
     fn check_pat(&mut self, cx: &LateContext<'tcx>, pat: &'tcx hir::Pat<'tcx>) {
+        match cx.tcx.hir().get_parent(pat.hir_id) {
+            Node::Param(param) if matches!(cx.tcx.hir().get_parent(param.hir_id), Node::Item(_)) => {
+                // Ignore function parameters
+                return;
+            },
+            Node::Local(local) if local.ty.is_some() => {
+                // Ignore let bindings with explicit type
+                return;
+            },
+            _ => {},
+        }
         if matches!(pat.kind, PatKind::Wild) && cx.typeck_results().pat_ty(pat).is_unit() {
             span_lint_and_sugg(
                 cx,
diff --git a/tests/ui/ignored_unit_patterns.fixed b/tests/ui/ignored_unit_patterns.fixed
index cac1352d2ac..6c6f21fee16 100644
--- a/tests/ui/ignored_unit_patterns.fixed
+++ b/tests/ui/ignored_unit_patterns.fixed
@@ -1,5 +1,5 @@
 #![warn(clippy::ignored_unit_patterns)]
-#![allow(clippy::redundant_pattern_matching, clippy::single_match)]
+#![allow(clippy::let_unit_value, clippy::redundant_pattern_matching, clippy::single_match)]
 
 fn foo() -> Result<(), ()> {
     unimplemented!()
@@ -15,3 +15,11 @@ fn main() {
     let _ = foo().map_err(|()| todo!());
     //~^ ERROR: matching over `()` is more explicit
 }
+
+#[allow(unused)]
+pub fn moo(_: ()) {
+    let () = foo().unwrap();
+    //~^ ERROR: matching over `()` is more explicit
+    let _: () = foo().unwrap();
+    let _: () = ();
+}
diff --git a/tests/ui/ignored_unit_patterns.rs b/tests/ui/ignored_unit_patterns.rs
index 962271d9c1d..5e8c2e03ba2 100644
--- a/tests/ui/ignored_unit_patterns.rs
+++ b/tests/ui/ignored_unit_patterns.rs
@@ -1,5 +1,5 @@
 #![warn(clippy::ignored_unit_patterns)]
-#![allow(clippy::redundant_pattern_matching, clippy::single_match)]
+#![allow(clippy::let_unit_value, clippy::redundant_pattern_matching, clippy::single_match)]
 
 fn foo() -> Result<(), ()> {
     unimplemented!()
@@ -15,3 +15,11 @@ fn main() {
     let _ = foo().map_err(|_| todo!());
     //~^ ERROR: matching over `()` is more explicit
 }
+
+#[allow(unused)]
+pub fn moo(_: ()) {
+    let _ = foo().unwrap();
+    //~^ ERROR: matching over `()` is more explicit
+    let _: () = foo().unwrap();
+    let _: () = ();
+}
diff --git a/tests/ui/ignored_unit_patterns.stderr b/tests/ui/ignored_unit_patterns.stderr
index 91e14308d56..81aa067daef 100644
--- a/tests/ui/ignored_unit_patterns.stderr
+++ b/tests/ui/ignored_unit_patterns.stderr
@@ -24,5 +24,11 @@ error: matching over `()` is more explicit
 LL |     let _ = foo().map_err(|_| todo!());
    |                            ^ help: use `()` instead of `_`: `()`
 
-error: aborting due to 4 previous errors
+error: matching over `()` is more explicit
+  --> $DIR/ignored_unit_patterns.rs:21:9
+   |
+LL |     let _ = foo().unwrap();
+   |         ^ help: use `()` instead of `_`: `()`
+
+error: aborting due to 5 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From bbf67c3424cb76ce7ae92e012f1bf23c1161eea7 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Mon, 4 Sep 2023 14:08:47 +0000
Subject: Preserve literals and range kinds in `manual_range_patterns`

---
 clippy_lints/src/manual_range_patterns.rs | 129 +++++++++++++++++++-----------
 tests/ui/manual_range_patterns.fixed      |  17 +++-
 tests/ui/manual_range_patterns.rs         |  11 +++
 tests/ui/manual_range_patterns.stderr     |  66 ++++++++++++++-
 4 files changed, 171 insertions(+), 52 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_range_patterns.rs b/clippy_lints/src/manual_range_patterns.rs
index 39d8b20d38d..90557b55560 100644
--- a/clippy_lints/src/manual_range_patterns.rs
+++ b/clippy_lints/src/manual_range_patterns.rs
@@ -1,4 +1,5 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::source::snippet_opt;
 use rustc_ast::LitKind;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Applicability;
@@ -6,6 +7,7 @@ use rustc_hir::{Expr, ExprKind, PatKind, RangeEnd, UnOp};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::{Span, DUMMY_SP};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -49,6 +51,29 @@ fn expr_as_i128(expr: &Expr<'_>) -> Option<i128> {
     }
 }
 
+#[derive(Copy, Clone)]
+struct Num {
+    val: i128,
+    span: Span,
+}
+
+impl Num {
+    fn new(expr: &Expr<'_>) -> Option<Self> {
+        Some(Self {
+            val: expr_as_i128(expr)?,
+            span: expr.span,
+        })
+    }
+
+    fn dummy(val: i128) -> Self {
+        Self { val, span: DUMMY_SP }
+    }
+
+    fn min(self, other: Self) -> Self {
+        if self.val < other.val { self } else { other }
+    }
+}
+
 impl LateLintPass<'_> for ManualRangePatterns {
     fn check_pat(&mut self, cx: &LateContext<'_>, pat: &'_ rustc_hir::Pat<'_>) {
         if in_external_macro(cx.sess(), pat.span) {
@@ -56,71 +81,83 @@ impl LateLintPass<'_> for ManualRangePatterns {
         }
 
         // a pattern like 1 | 2 seems fine, lint if there are at least 3 alternatives
+        // or at least one range
         if let PatKind::Or(pats) = pat.kind
-            && pats.len() >= 3
+            && (pats.len() >= 3 || pats.iter().any(|p| matches!(p.kind, PatKind::Range(..))))
         {
-            let mut min = i128::MAX;
-            let mut max = i128::MIN;
+            let mut min = Num::dummy(i128::MAX);
+            let mut max = Num::dummy(i128::MIN);
+            let mut range_kind = RangeEnd::Included;
             let mut numbers_found = FxHashSet::default();
             let mut ranges_found = Vec::new();
 
             for pat in pats {
                 if let PatKind::Lit(lit) = pat.kind
-                    && let Some(num) = expr_as_i128(lit)
+                    && let Some(num) = Num::new(lit)
                 {
-                    numbers_found.insert(num);
+                    numbers_found.insert(num.val);
 
                     min = min.min(num);
-                    max = max.max(num);
+                    if num.val >= max.val {
+                        max = num;
+                        range_kind = RangeEnd::Included;
+                    }
                 } else if let PatKind::Range(Some(left), Some(right), end) = pat.kind
-                    && let Some(left) = expr_as_i128(left)
-                    && let Some(right) = expr_as_i128(right)
-                    && right >= left
+                    && let Some(left) = Num::new(left)
+                    && let Some(mut right) = Num::new(right)
                 {
+                    if let RangeEnd::Excluded = end {
+                        right.val -= 1;
+                    }
+
                     min = min.min(left);
-                    max = max.max(right);
-                    ranges_found.push(left..=match end {
-                        RangeEnd::Included => right,
-                        RangeEnd::Excluded => right - 1,
-                    });
+                    if right.val > max.val {
+                        max = right;
+                        range_kind = end;
+                    }
+                    ranges_found.push(left.val..=right.val);
                 } else {
                     return;
                 }
             }
 
-            let contains_whole_range = 'contains: {
-                let mut num = min;
-                while num <= max {
-                    if numbers_found.contains(&num) {
-                        num += 1;
-                    }
-                    // Given a list of (potentially overlapping) ranges like:
-                    // 1..=5, 3..=7, 6..=10
-                    // We want to find the range with the highest end that still contains the current number
-                    else if let Some(range) = ranges_found
-                        .iter()
-                        .filter(|range| range.contains(&num))
-                        .max_by_key(|range| range.end())
-                    {
-                        num = range.end() + 1;
-                    } else {
-                        break 'contains false;
-                    }
+            let mut num = min.val;
+            while num <= max.val {
+                if numbers_found.contains(&num) {
+                    num += 1;
+                }
+                // Given a list of (potentially overlapping) ranges like:
+                // 1..=5, 3..=7, 6..=10
+                // We want to find the range with the highest end that still contains the current number
+                else if let Some(range) = ranges_found
+                    .iter()
+                    .filter(|range| range.contains(&num))
+                    .max_by_key(|range| range.end())
+                {
+                    num = range.end() + 1;
+                } else {
+                    return;
                 }
-                break 'contains true;
-            };
-
-            if contains_whole_range {
-                span_lint_and_sugg(
-                    cx,
-                    MANUAL_RANGE_PATTERNS,
-                    pat.span,
-                    "this OR pattern can be rewritten using a range",
-                    "try",
-                    format!("{min}..={max}"),
-                    Applicability::MachineApplicable,
-                );
             }
+
+            span_lint_and_then(
+                cx,
+                MANUAL_RANGE_PATTERNS,
+                pat.span,
+                "this OR pattern can be rewritten using a range",
+                |diag| {
+                    if let Some(min) = snippet_opt(cx, min.span)
+                        && let Some(max) = snippet_opt(cx, max.span)
+                    {
+                        diag.span_suggestion(
+                            pat.span,
+                            "try",
+                            format!("{min}{range_kind}{max}"),
+                            Applicability::MachineApplicable,
+                        );
+                    }
+                },
+            );
         }
     }
 }
diff --git a/tests/ui/manual_range_patterns.fixed b/tests/ui/manual_range_patterns.fixed
index ea06e27d153..b348d7071f6 100644
--- a/tests/ui/manual_range_patterns.fixed
+++ b/tests/ui/manual_range_patterns.fixed
@@ -13,8 +13,8 @@ fn main() {
     let _ = matches!(f, 1 | 2147483647);
     let _ = matches!(f, 0 | 2147483647);
     let _ = matches!(f, -2147483647 | 2147483647);
-    let _ = matches!(f, 1 | (2..=4));
-    let _ = matches!(f, 1 | (2..4));
+    let _ = matches!(f, 1..=4);
+    let _ = matches!(f, 1..4);
     let _ = matches!(f, 1..=48324729);
     let _ = matches!(f, 0..=48324730);
     let _ = matches!(f, 0..=3);
@@ -25,9 +25,20 @@ fn main() {
     };
     let _ = matches!(f, -5..=3);
     let _ = matches!(f, -1 | -5 | 3 | -2 | -4 | -3 | 0 | 1); // 2 is missing
-    let _ = matches!(f, -1000001..=1000001);
+    let _ = matches!(f, -1_000_001..=1_000_001);
     let _ = matches!(f, -1_000_000..=1_000_000 | -1_000_001 | 1_000_002);
 
+    matches!(f, 0x00..=0x03);
+    matches!(f, 0x00..=0x07);
+    matches!(f, -0x09..=0x00);
+
+    matches!(f, 0..=5);
+    matches!(f, 0..5);
+
+    matches!(f, 0..10);
+    matches!(f, 0..=10);
+    matches!(f, 0..=10);
+
     macro_rules! mac {
         ($e:expr) => {
             matches!($e, 1..=10)
diff --git a/tests/ui/manual_range_patterns.rs b/tests/ui/manual_range_patterns.rs
index eb29987b89f..a0750f54b73 100644
--- a/tests/ui/manual_range_patterns.rs
+++ b/tests/ui/manual_range_patterns.rs
@@ -28,6 +28,17 @@ fn main() {
     let _ = matches!(f, -1_000_000..=1_000_000 | -1_000_001 | 1_000_001);
     let _ = matches!(f, -1_000_000..=1_000_000 | -1_000_001 | 1_000_002);
 
+    matches!(f, 0x00 | 0x01 | 0x02 | 0x03);
+    matches!(f, 0x00..=0x05 | 0x06 | 0x07);
+    matches!(f, -0x09 | -0x08 | -0x07..=0x00);
+
+    matches!(f, 0..5 | 5);
+    matches!(f, 0 | 1..5);
+
+    matches!(f, 0..=5 | 6..10);
+    matches!(f, 0..5 | 5..=10);
+    matches!(f, 5..=10 | 0..5);
+
     macro_rules! mac {
         ($e:expr) => {
             matches!($e, 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10)
diff --git a/tests/ui/manual_range_patterns.stderr b/tests/ui/manual_range_patterns.stderr
index 1cf58d7df6a..60ee75d1b8e 100644
--- a/tests/ui/manual_range_patterns.stderr
+++ b/tests/ui/manual_range_patterns.stderr
@@ -12,6 +12,18 @@ error: this OR pattern can be rewritten using a range
 LL |     let _ = matches!(f, 4 | 2 | 3 | 1 | 5 | 6 | 9 | 7 | 8 | 10);
    |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `1..=10`
 
+error: this OR pattern can be rewritten using a range
+  --> $DIR/manual_range_patterns.rs:16:25
+   |
+LL |     let _ = matches!(f, 1 | (2..=4));
+   |                         ^^^^^^^^^^^ help: try: `1..=4`
+
+error: this OR pattern can be rewritten using a range
+  --> $DIR/manual_range_patterns.rs:17:25
+   |
+LL |     let _ = matches!(f, 1 | (2..4));
+   |                         ^^^^^^^^^^ help: try: `1..4`
+
 error: this OR pattern can be rewritten using a range
   --> $DIR/manual_range_patterns.rs:18:25
    |
@@ -46,10 +58,58 @@ error: this OR pattern can be rewritten using a range
   --> $DIR/manual_range_patterns.rs:28:25
    |
 LL |     let _ = matches!(f, -1_000_000..=1_000_000 | -1_000_001 | 1_000_001);
-   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `-1000001..=1000001`
+   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `-1_000_001..=1_000_001`
+
+error: this OR pattern can be rewritten using a range
+  --> $DIR/manual_range_patterns.rs:31:17
+   |
+LL |     matches!(f, 0x00 | 0x01 | 0x02 | 0x03);
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `0x00..=0x03`
+
+error: this OR pattern can be rewritten using a range
+  --> $DIR/manual_range_patterns.rs:32:17
+   |
+LL |     matches!(f, 0x00..=0x05 | 0x06 | 0x07);
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `0x00..=0x07`
+
+error: this OR pattern can be rewritten using a range
+  --> $DIR/manual_range_patterns.rs:33:17
+   |
+LL |     matches!(f, -0x09 | -0x08 | -0x07..=0x00);
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `-0x09..=0x00`
+
+error: this OR pattern can be rewritten using a range
+  --> $DIR/manual_range_patterns.rs:35:17
+   |
+LL |     matches!(f, 0..5 | 5);
+   |                 ^^^^^^^^ help: try: `0..=5`
+
+error: this OR pattern can be rewritten using a range
+  --> $DIR/manual_range_patterns.rs:36:17
+   |
+LL |     matches!(f, 0 | 1..5);
+   |                 ^^^^^^^^ help: try: `0..5`
+
+error: this OR pattern can be rewritten using a range
+  --> $DIR/manual_range_patterns.rs:38:17
+   |
+LL |     matches!(f, 0..=5 | 6..10);
+   |                 ^^^^^^^^^^^^^ help: try: `0..10`
+
+error: this OR pattern can be rewritten using a range
+  --> $DIR/manual_range_patterns.rs:39:17
+   |
+LL |     matches!(f, 0..5 | 5..=10);
+   |                 ^^^^^^^^^^^^^ help: try: `0..=10`
+
+error: this OR pattern can be rewritten using a range
+  --> $DIR/manual_range_patterns.rs:40:17
+   |
+LL |     matches!(f, 5..=10 | 0..5);
+   |                 ^^^^^^^^^^^^^ help: try: `0..=10`
 
 error: this OR pattern can be rewritten using a range
-  --> $DIR/manual_range_patterns.rs:33:26
+  --> $DIR/manual_range_patterns.rs:44:26
    |
 LL |             matches!($e, 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10)
    |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `1..=10`
@@ -59,5 +119,5 @@ LL |     mac!(f);
    |
    = note: this error originates in the macro `mac` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to 9 previous errors
+error: aborting due to 19 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 18f36897ef0844dc5e5a0d995356247cbee72ff3 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Tue, 5 Sep 2023 19:08:34 +0200
Subject: use the correct node args for substitution

---
 clippy_lints/src/useless_conversion.rs | 52 ++++++++++++++++++++--------------
 tests/ui/useless_conversion.fixed      | 41 +++++++++++++++++++++++++++
 tests/ui/useless_conversion.rs         | 41 +++++++++++++++++++++++++++
 tests/ui/useless_conversion.stderr     | 26 ++++++++++++++++-
 4 files changed, 137 insertions(+), 23 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/useless_conversion.rs b/clippy_lints/src/useless_conversion.rs
index 5afb1f76df8..f32e7edad6c 100644
--- a/clippy_lints/src/useless_conversion.rs
+++ b/clippy_lints/src/useless_conversion.rs
@@ -12,7 +12,7 @@ use rustc_infer::infer::TyCtxtInferExt;
 use rustc_infer::traits::Obligation;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::traits::ObligationCause;
-use rustc_middle::ty::{self, EarlyBinder, GenericArg, GenericArgsRef, Ty};
+use rustc_middle::ty::{self, EarlyBinder, GenericArg, GenericArgsRef, Ty, TypeVisitableExt};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::{sym, Span};
 use rustc_trait_selection::traits::query::evaluate_obligation::InferCtxtExt;
@@ -93,27 +93,35 @@ fn into_iter_bound<'tcx>(
 
     for (pred, span) in cx.tcx.explicit_predicates_of(fn_did).predicates {
         if let ty::ClauseKind::Trait(tr) = pred.kind().skip_binder() {
-            if tr.def_id() == into_iter_did && tr.self_ty().is_param(param_index) {
-                into_iter_span = Some(*span);
-            } else {
-                // Substitute generics in the predicate and replace the IntoIterator type parameter with the
-                // `.into_iter()` receiver to see if the bound also holds for that type.
-                let args = cx.tcx.mk_args_from_iter(node_args.iter().enumerate().map(|(i, arg)| {
-                    if i == param_index as usize {
-                        GenericArg::from(into_iter_receiver)
-                    } else {
-                        arg
+            if tr.self_ty().is_param(param_index) {
+                if tr.def_id() == into_iter_did {
+                    into_iter_span = Some(*span);
+                } else {
+                    let tr = cx.tcx.erase_regions(tr);
+                    if tr.has_escaping_bound_vars() {
+                        return None;
+                    }
+
+                    // Substitute generics in the predicate and replace the IntoIterator type parameter with the
+                    // `.into_iter()` receiver to see if the bound also holds for that type.
+                    let args = cx.tcx.mk_args_from_iter(node_args.iter().enumerate().map(|(i, arg)| {
+                        if i == param_index as usize {
+                            GenericArg::from(into_iter_receiver)
+                        } else {
+                            arg
+                        }
+                    }));
+
+                    let predicate = EarlyBinder::bind(tr).instantiate(cx.tcx, args);
+                    let obligation = Obligation::new(cx.tcx, ObligationCause::dummy(), param_env, predicate);
+                    if !cx
+                        .tcx
+                        .infer_ctxt()
+                        .build()
+                        .predicate_must_hold_modulo_regions(&obligation)
+                    {
+                        return None;
                     }
-                }));
-                let predicate = EarlyBinder::bind(tr).instantiate(cx.tcx, args);
-                let obligation = Obligation::new(cx.tcx, ObligationCause::dummy(), param_env, predicate);
-                if !cx
-                    .tcx
-                    .infer_ctxt()
-                    .build()
-                    .predicate_must_hold_modulo_regions(&obligation)
-                {
-                    return None;
                 }
             }
         }
@@ -216,7 +224,7 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
                                         return (
                                             did,
                                             args,
-                                            cx.typeck_results().node_args(recv.hir_id),
+                                            cx.typeck_results().node_args(parent.hir_id),
                                             MethodOrFunction::Method
                                         );
                                     })
diff --git a/tests/ui/useless_conversion.fixed b/tests/ui/useless_conversion.fixed
index f3504bc62b4..ed8387b7eb2 100644
--- a/tests/ui/useless_conversion.fixed
+++ b/tests/ui/useless_conversion.fixed
@@ -244,6 +244,47 @@ mod issue11300 {
         // and `i32: Helper2<[i32, 3]>` is true, so this call is indeed unncessary.
         foo3([1, 2, 3]);
     }
+
+    fn ice() {
+        struct S1;
+        impl S1 {
+            pub fn foo<I: IntoIterator>(&self, _: I) {}
+        }
+
+        S1.foo([1, 2]);
+
+        // ICE that occured in itertools
+        trait Itertools {
+            fn interleave_shortest<J>(self, other: J)
+            where
+                J: IntoIterator,
+                Self: Sized;
+        }
+        impl<I: Iterator> Itertools for I {
+            fn interleave_shortest<J>(self, other: J)
+            where
+                J: IntoIterator,
+                Self: Sized,
+            {
+            }
+        }
+        let v0: Vec<i32> = vec![0, 2, 4];
+        let v1: Vec<i32> = vec![1, 3, 5, 7];
+        v0.into_iter().interleave_shortest(v1);
+
+        trait TraitWithLifetime<'a> {}
+        impl<'a> TraitWithLifetime<'a> for std::array::IntoIter<&'a i32, 2> {}
+
+        struct Helper;
+        impl<'a> Helper {
+            fn with_lt<I>(&self, _: I)
+            where
+                I: IntoIterator + TraitWithLifetime<'a>,
+            {
+            }
+        }
+        Helper.with_lt([&1, &2].into_iter());
+    }
 }
 
 #[derive(Copy, Clone)]
diff --git a/tests/ui/useless_conversion.rs b/tests/ui/useless_conversion.rs
index a4f4722927f..991a7762fc6 100644
--- a/tests/ui/useless_conversion.rs
+++ b/tests/ui/useless_conversion.rs
@@ -244,6 +244,47 @@ mod issue11300 {
         // and `i32: Helper2<[i32, 3]>` is true, so this call is indeed unncessary.
         foo3([1, 2, 3].into_iter());
     }
+
+    fn ice() {
+        struct S1;
+        impl S1 {
+            pub fn foo<I: IntoIterator>(&self, _: I) {}
+        }
+
+        S1.foo([1, 2].into_iter());
+
+        // ICE that occured in itertools
+        trait Itertools {
+            fn interleave_shortest<J>(self, other: J)
+            where
+                J: IntoIterator,
+                Self: Sized;
+        }
+        impl<I: Iterator> Itertools for I {
+            fn interleave_shortest<J>(self, other: J)
+            where
+                J: IntoIterator,
+                Self: Sized,
+            {
+            }
+        }
+        let v0: Vec<i32> = vec![0, 2, 4];
+        let v1: Vec<i32> = vec![1, 3, 5, 7];
+        v0.into_iter().interleave_shortest(v1.into_iter());
+
+        trait TraitWithLifetime<'a> {}
+        impl<'a> TraitWithLifetime<'a> for std::array::IntoIter<&'a i32, 2> {}
+
+        struct Helper;
+        impl<'a> Helper {
+            fn with_lt<I>(&self, _: I)
+            where
+                I: IntoIterator + TraitWithLifetime<'a>,
+            {
+            }
+        }
+        Helper.with_lt([&1, &2].into_iter());
+    }
 }
 
 #[derive(Copy, Clone)]
diff --git a/tests/ui/useless_conversion.stderr b/tests/ui/useless_conversion.stderr
index 81a0898bdf6..c1f8b6b4aa9 100644
--- a/tests/ui/useless_conversion.stderr
+++ b/tests/ui/useless_conversion.stderr
@@ -202,5 +202,29 @@ note: this parameter accepts any `IntoIterator`, so you don't need to call `.int
 LL |         I: IntoIterator<Item = i32>,
    |            ^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 26 previous errors
+error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
+  --> $DIR/useless_conversion.rs:254:16
+   |
+LL |         S1.foo([1, 2].into_iter());
+   |                ^^^^^^^^^^^^^^^^^^ help: consider removing the `.into_iter()`: `[1, 2]`
+   |
+note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
+  --> $DIR/useless_conversion.rs:251:27
+   |
+LL |             pub fn foo<I: IntoIterator>(&self, _: I) {}
+   |                           ^^^^^^^^^^^^
+
+error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
+  --> $DIR/useless_conversion.rs:273:44
+   |
+LL |         v0.into_iter().interleave_shortest(v1.into_iter());
+   |                                            ^^^^^^^^^^^^^^ help: consider removing the `.into_iter()`: `v1`
+   |
+note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
+  --> $DIR/useless_conversion.rs:260:20
+   |
+LL |                 J: IntoIterator,
+   |                    ^^^^^^^^^^^^
+
+error: aborting due to 28 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 30846b16a0feaf25e4a78d468d1b56920e775aae Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Tue, 5 Sep 2023 21:55:08 +0200
Subject: add comments in code to clarify and fix typo

---
 clippy_lints/src/implied_bounds_in_impls.rs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/implied_bounds_in_impls.rs b/clippy_lints/src/implied_bounds_in_impls.rs
index 120ab5a034e..ec9044bba5c 100644
--- a/clippy_lints/src/implied_bounds_in_impls.rs
+++ b/clippy_lints/src/implied_bounds_in_impls.rs
@@ -56,7 +56,9 @@ fn emit_lint(
     poly_trait: &rustc_hir::PolyTraitRef<'_>,
     opaque_ty: &rustc_hir::OpaqueTy<'_>,
     index: usize,
+    // The bindings that were implied
     implied_bindings: &[rustc_hir::TypeBinding<'_>],
+    // The original bindings that `implied_bindings` are implied from
     implied_by_bindings: &[rustc_hir::TypeBinding<'_>],
     implied_by_args: &[GenericArg<'_>],
     implied_by_span: Span,
@@ -69,7 +71,7 @@ fn emit_lint(
         poly_trait.span,
         &format!("this bound is already specified as the supertrait of `{implied_by}`"),
         |diag| {
-            // If we suggest removing a bound, we may also need extend the span
+            // If we suggest removing a bound, we may also need to extend the span
             // to include the `+` token that is ahead or behind,
             // so we don't end up with something like `impl + B` or `impl A + `
 
-- 
cgit 1.4.1-3-g733a5


From b99921a5e8e7d31332e1de9e5c2d78a044f6d8cb Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Fri, 8 Sep 2023 13:15:51 +0000
Subject: Rename incorrect_impls to non_canonical_impls, move them to warn by
 default

---
 CHANGELOG.md                                       |   2 +
 clippy_lints/src/declared_lints.rs                 |   4 +-
 clippy_lints/src/incorrect_impls.rs                | 291 ---------------------
 clippy_lints/src/lib.rs                            |   4 +-
 clippy_lints/src/non_canonical_impls.rs            | 288 ++++++++++++++++++++
 clippy_lints/src/renamed_lints.rs                  |   4 +-
 tests/ui/bool_comparison.fixed                     |   2 +-
 tests/ui/bool_comparison.rs                        |   2 +-
 tests/ui/clone_on_copy_impl.rs                     |   2 +-
 tests/ui/derive.rs                                 |   6 +-
 tests/ui/derive.stderr                             |  20 +-
 tests/ui/derive_ord_xor_partial_ord.rs             |   2 +-
 tests/ui/incorrect_clone_impl_on_copy_type.fixed   |  96 -------
 tests/ui/incorrect_clone_impl_on_copy_type.rs      | 106 --------
 tests/ui/incorrect_clone_impl_on_copy_type.stderr  |  40 ---
 .../incorrect_partial_ord_impl_on_ord_type.fixed   | 144 ----------
 tests/ui/incorrect_partial_ord_impl_on_ord_type.rs | 148 -----------
 .../incorrect_partial_ord_impl_on_ord_type.stderr  |  31 ---
 ...rect_partial_ord_impl_on_ord_type_fully_qual.rs |  54 ----
 ..._partial_ord_impl_on_ord_type_fully_qual.stderr |  34 ---
 tests/ui/non_canonical_clone_impl.fixed            |  96 +++++++
 tests/ui/non_canonical_clone_impl.rs               | 106 ++++++++
 tests/ui/non_canonical_clone_impl.stderr           |  41 +++
 tests/ui/non_canonical_partial_ord_impl.fixed      | 144 ++++++++++
 tests/ui/non_canonical_partial_ord_impl.rs         | 148 +++++++++++
 tests/ui/non_canonical_partial_ord_impl.stderr     |  32 +++
 .../non_canonical_partial_ord_impl_fully_qual.rs   |  51 ++++
 ...on_canonical_partial_ord_impl_fully_qual.stderr |  32 +++
 tests/ui/rename.fixed                              |   8 +-
 tests/ui/rename.rs                                 |   8 +-
 tests/ui/rename.stderr                             | 132 +++++-----
 tests/ui/unnecessary_struct_initialization.fixed   |   2 +-
 tests/ui/unnecessary_struct_initialization.rs      |   2 +-
 33 files changed, 1048 insertions(+), 1034 deletions(-)
 delete mode 100644 clippy_lints/src/incorrect_impls.rs
 create mode 100644 clippy_lints/src/non_canonical_impls.rs
 delete mode 100644 tests/ui/incorrect_clone_impl_on_copy_type.fixed
 delete mode 100644 tests/ui/incorrect_clone_impl_on_copy_type.rs
 delete mode 100644 tests/ui/incorrect_clone_impl_on_copy_type.stderr
 delete mode 100644 tests/ui/incorrect_partial_ord_impl_on_ord_type.fixed
 delete mode 100644 tests/ui/incorrect_partial_ord_impl_on_ord_type.rs
 delete mode 100644 tests/ui/incorrect_partial_ord_impl_on_ord_type.stderr
 delete mode 100644 tests/ui/incorrect_partial_ord_impl_on_ord_type_fully_qual.rs
 delete mode 100644 tests/ui/incorrect_partial_ord_impl_on_ord_type_fully_qual.stderr
 create mode 100644 tests/ui/non_canonical_clone_impl.fixed
 create mode 100644 tests/ui/non_canonical_clone_impl.rs
 create mode 100644 tests/ui/non_canonical_clone_impl.stderr
 create mode 100644 tests/ui/non_canonical_partial_ord_impl.fixed
 create mode 100644 tests/ui/non_canonical_partial_ord_impl.rs
 create mode 100644 tests/ui/non_canonical_partial_ord_impl.stderr
 create mode 100644 tests/ui/non_canonical_partial_ord_impl_fully_qual.rs
 create mode 100644 tests/ui/non_canonical_partial_ord_impl_fully_qual.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index fd7232e280f..a7ae4a0ee2c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5206,6 +5206,8 @@ Released 2018-09-13
 [`no_effect_underscore_binding`]: https://rust-lang.github.io/rust-clippy/master/index.html#no_effect_underscore_binding
 [`no_mangle_with_rust_abi`]: https://rust-lang.github.io/rust-clippy/master/index.html#no_mangle_with_rust_abi
 [`non_ascii_literal`]: https://rust-lang.github.io/rust-clippy/master/index.html#non_ascii_literal
+[`non_canonical_clone_impl`]: https://rust-lang.github.io/rust-clippy/master/index.html#non_canonical_clone_impl
+[`non_canonical_partial_ord_impl`]: https://rust-lang.github.io/rust-clippy/master/index.html#non_canonical_partial_ord_impl
 [`non_minimal_cfg`]: https://rust-lang.github.io/rust-clippy/master/index.html#non_minimal_cfg
 [`non_octal_unix_permissions`]: https://rust-lang.github.io/rust-clippy/master/index.html#non_octal_unix_permissions
 [`non_send_fields_in_send_ty`]: https://rust-lang.github.io/rust-clippy/master/index.html#non_send_fields_in_send_ty
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 150d883985c..a4d40df52e7 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -211,8 +211,6 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::implicit_saturating_sub::IMPLICIT_SATURATING_SUB_INFO,
     crate::implied_bounds_in_impls::IMPLIED_BOUNDS_IN_IMPLS_INFO,
     crate::inconsistent_struct_constructor::INCONSISTENT_STRUCT_CONSTRUCTOR_INFO,
-    crate::incorrect_impls::INCORRECT_CLONE_IMPL_ON_COPY_TYPE_INFO,
-    crate::incorrect_impls::INCORRECT_PARTIAL_ORD_IMPL_ON_ORD_TYPE_INFO,
     crate::index_refutable_slice::INDEX_REFUTABLE_SLICE_INFO,
     crate::indexing_slicing::INDEXING_SLICING_INFO,
     crate::indexing_slicing::OUT_OF_BOUNDS_INDEXING_INFO,
@@ -498,6 +496,8 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::no_effect::NO_EFFECT_UNDERSCORE_BINDING_INFO,
     crate::no_effect::UNNECESSARY_OPERATION_INFO,
     crate::no_mangle_with_rust_abi::NO_MANGLE_WITH_RUST_ABI_INFO,
+    crate::non_canonical_impls::NON_CANONICAL_CLONE_IMPL_INFO,
+    crate::non_canonical_impls::NON_CANONICAL_PARTIAL_ORD_IMPL_INFO,
     crate::non_copy_const::BORROW_INTERIOR_MUTABLE_CONST_INFO,
     crate::non_copy_const::DECLARE_INTERIOR_MUTABLE_CONST_INFO,
     crate::non_expressive_names::JUST_UNDERSCORES_AND_DIGITS_INFO,
diff --git a/clippy_lints/src/incorrect_impls.rs b/clippy_lints/src/incorrect_impls.rs
deleted file mode 100644
index c19a46f4e97..00000000000
--- a/clippy_lints/src/incorrect_impls.rs
+++ /dev/null
@@ -1,291 +0,0 @@
-use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
-use clippy_utils::paths::ORD_CMP;
-use clippy_utils::ty::implements_trait;
-use clippy_utils::{get_parent_node, is_res_lang_ctor, last_path_segment, match_def_path, path_res, std_or_core};
-use rustc_errors::Applicability;
-use rustc_hir::def_id::LocalDefId;
-use rustc_hir::{Expr, ExprKind, ImplItem, ImplItemKind, ItemKind, LangItem, Node, UnOp};
-use rustc_hir_analysis::hir_ty_to_ty;
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty::EarlyBinder;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::sym;
-use rustc_span::symbol::kw;
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for manual implementations of `Clone` when `Copy` is already implemented.
-    ///
-    /// ### Why is this bad?
-    /// If both `Clone` and `Copy` are implemented, they must agree. This is done by dereferencing
-    /// `self` in `Clone`'s implementation. Anything else is incorrect.
-    ///
-    /// ### Example
-    /// ```rust,ignore
-    /// #[derive(Eq, PartialEq)]
-    /// struct A(u32);
-    ///
-    /// impl Clone for A {
-    ///     fn clone(&self) -> Self {
-    ///         Self(self.0)
-    ///     }
-    /// }
-    ///
-    /// impl Copy for A {}
-    /// ```
-    /// Use instead:
-    /// ```rust,ignore
-    /// #[derive(Eq, PartialEq)]
-    /// struct A(u32);
-    ///
-    /// impl Clone for A {
-    ///     fn clone(&self) -> Self {
-    ///         *self
-    ///     }
-    /// }
-    ///
-    /// impl Copy for A {}
-    /// ```
-    #[clippy::version = "1.72.0"]
-    pub INCORRECT_CLONE_IMPL_ON_COPY_TYPE,
-    correctness,
-    "manual implementation of `Clone` on a `Copy` type"
-}
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for manual implementations of both `PartialOrd` and `Ord` when only `Ord` is
-    /// necessary.
-    ///
-    /// ### Why is this bad?
-    /// If both `PartialOrd` and `Ord` are implemented, they must agree. This is commonly done by
-    /// wrapping the result of `cmp` in `Some` for `partial_cmp`. Not doing this may silently
-    /// introduce an error upon refactoring.
-    ///
-    /// ### Known issues
-    /// Code that calls the `.into()` method instead will be flagged as incorrect, despite `.into()`
-    /// wrapping it in `Some`.
-    ///
-    /// ### Limitations
-    /// Will not lint if `Self` and `Rhs` do not have the same type.
-    ///
-    /// ### Example
-    /// ```rust
-    /// # use std::cmp::Ordering;
-    /// #[derive(Eq, PartialEq)]
-    /// struct A(u32);
-    ///
-    /// impl Ord for A {
-    ///     fn cmp(&self, other: &Self) -> Ordering {
-    ///         // ...
-    /// #       todo!();
-    ///     }
-    /// }
-    ///
-    /// impl PartialOrd for A {
-    ///     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-    ///         // ...
-    /// #       todo!();
-    ///     }
-    /// }
-    /// ```
-    /// Use instead:
-    /// ```rust
-    /// # use std::cmp::Ordering;
-    /// #[derive(Eq, PartialEq)]
-    /// struct A(u32);
-    ///
-    /// impl Ord for A {
-    ///     fn cmp(&self, other: &Self) -> Ordering {
-    ///         // ...
-    /// #       todo!();
-    ///     }
-    /// }
-    ///
-    /// impl PartialOrd for A {
-    ///     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-    ///         Some(self.cmp(other))
-    ///     }
-    /// }
-    /// ```
-    #[clippy::version = "1.72.0"]
-    pub INCORRECT_PARTIAL_ORD_IMPL_ON_ORD_TYPE,
-    correctness,
-    "manual implementation of `PartialOrd` when `Ord` is already implemented"
-}
-declare_lint_pass!(IncorrectImpls => [INCORRECT_CLONE_IMPL_ON_COPY_TYPE, INCORRECT_PARTIAL_ORD_IMPL_ON_ORD_TYPE]);
-
-impl LateLintPass<'_> for IncorrectImpls {
-    #[expect(clippy::too_many_lines)]
-    fn check_impl_item(&mut self, cx: &LateContext<'_>, impl_item: &ImplItem<'_>) {
-        let Some(Node::Item(item)) = get_parent_node(cx.tcx, impl_item.hir_id()) else {
-            return;
-        };
-        let Some(trait_impl) = cx.tcx.impl_trait_ref(item.owner_id).map(EarlyBinder::skip_binder) else {
-            return;
-        };
-        if cx.tcx.is_automatically_derived(item.owner_id.to_def_id()) {
-            return;
-        }
-        let ItemKind::Impl(imp) = item.kind else {
-            return;
-        };
-        let ImplItemKind::Fn(_, impl_item_id) = cx.tcx.hir().impl_item(impl_item.impl_item_id()).kind else {
-            return;
-        };
-        let body = cx.tcx.hir().body(impl_item_id);
-        let ExprKind::Block(block, ..) = body.value.kind else {
-            return;
-        };
-
-        if cx.tcx.is_diagnostic_item(sym::Clone, trait_impl.def_id)
-            && let Some(copy_def_id) = cx.tcx.get_diagnostic_item(sym::Copy)
-            && implements_trait(
-                    cx,
-                    trait_impl.self_ty(),
-                    copy_def_id,
-                    &[],
-                )
-        {
-            if impl_item.ident.name == sym::clone {
-                if block.stmts.is_empty()
-                    && let Some(expr) = block.expr
-                    && let ExprKind::Unary(UnOp::Deref, deref) = expr.kind
-                    && let ExprKind::Path(qpath) = deref.kind
-                    && last_path_segment(&qpath).ident.name == kw::SelfLower
-                {} else {
-                    span_lint_and_sugg(
-                        cx,
-                        INCORRECT_CLONE_IMPL_ON_COPY_TYPE,
-                        block.span,
-                        "incorrect implementation of `clone` on a `Copy` type",
-                        "change this to",
-                        "{ *self }".to_owned(),
-                        Applicability::MaybeIncorrect,
-                    );
-
-                    return;
-                }
-            }
-
-            if impl_item.ident.name == sym::clone_from {
-                span_lint_and_sugg(
-                    cx,
-                    INCORRECT_CLONE_IMPL_ON_COPY_TYPE,
-                    impl_item.span,
-                    "incorrect implementation of `clone_from` on a `Copy` type",
-                    "remove it",
-                    String::new(),
-                    Applicability::MaybeIncorrect,
-                );
-
-                return;
-            }
-        }
-
-        if cx.tcx.is_diagnostic_item(sym::PartialOrd, trait_impl.def_id)
-            && impl_item.ident.name == sym::partial_cmp
-            && let Some(ord_def_id) = cx
-                .tcx
-                .diagnostic_items(trait_impl.def_id.krate)
-                .name_to_id
-                .get(&sym::Ord)
-            && implements_trait(cx, hir_ty_to_ty(cx.tcx, imp.self_ty), *ord_def_id, &[])
-        {
-            // If the `cmp` call likely needs to be fully qualified in the suggestion
-            // (like `std::cmp::Ord::cmp`). It's unfortunate we must put this here but we can't
-            // access `cmp_expr` in the suggestion without major changes, as we lint in `else`.
-            let mut needs_fully_qualified = false;
-
-            if block.stmts.is_empty()
-                && let Some(expr) = block.expr
-                && let ExprKind::Call(
-                        Expr {
-                            kind: ExprKind::Path(some_path),
-                            hir_id: some_hir_id,
-                            ..
-                        },
-                        [cmp_expr],
-                    ) = expr.kind
-                && is_res_lang_ctor(cx, cx.qpath_res(some_path, *some_hir_id), LangItem::OptionSome)
-                // Fix #11178, allow `Self::cmp(self, ..)` too
-                && self_cmp_call(cx, cmp_expr, impl_item.owner_id.def_id, &mut needs_fully_qualified)
-            {} else {
-                // If `Self` and `Rhs` are not the same type, bail. This makes creating a valid
-                // suggestion tons more complex.
-                if let [lhs, rhs, ..] = trait_impl.args.as_slice() && lhs != rhs {
-                    return;
-                }
-
-                span_lint_and_then(
-                    cx,
-                    INCORRECT_PARTIAL_ORD_IMPL_ON_ORD_TYPE,
-                    item.span,
-                    "incorrect implementation of `partial_cmp` on an `Ord` type",
-                    |diag| {
-                        let [_, other] = body.params else {
-                            return;
-                        };
-                        let Some(std_or_core) = std_or_core(cx) else {
-                            return;
-                        };
-
-                        let suggs = match (other.pat.simple_ident(), needs_fully_qualified) {
-                            (Some(other_ident), true) => vec![(
-                                block.span,
-                                format!("{{ Some({std_or_core}::cmp::Ord::cmp(self, {})) }}", other_ident.name),
-                            )],
-                            (Some(other_ident), false) => {
-                                vec![(block.span, format!("{{ Some(self.cmp({})) }}", other_ident.name))]
-                            },
-                            (None, true) => vec![
-                                (
-                                    block.span,
-                                    format!("{{ Some({std_or_core}::cmp::Ord::cmp(self, other)) }}"),
-                                ),
-                                (other.pat.span, "other".to_owned()),
-                            ],
-                            (None, false) => vec![
-                                (block.span, "{ Some(self.cmp(other)) }".to_owned()),
-                                (other.pat.span, "other".to_owned()),
-                            ],
-                        };
-
-                        diag.multipart_suggestion(
-                            "change this to",
-                            suggs,
-                            Applicability::Unspecified,
-                        );
-                    }
-                );
-            }
-        }
-    }
-}
-
-/// Returns whether this is any of `self.cmp(..)`, `Self::cmp(self, ..)` or `Ord::cmp(self, ..)`.
-fn self_cmp_call<'tcx>(
-    cx: &LateContext<'tcx>,
-    cmp_expr: &'tcx Expr<'tcx>,
-    def_id: LocalDefId,
-    needs_fully_qualified: &mut bool,
-) -> bool {
-    match cmp_expr.kind {
-        ExprKind::Call(path, [_self, _other]) => path_res(cx, path)
-            .opt_def_id()
-            .is_some_and(|def_id| match_def_path(cx, def_id, &ORD_CMP)),
-        ExprKind::MethodCall(_, _, [_other], ..) => {
-            // We can set this to true here no matter what as if it's a `MethodCall` and goes to the
-            // `else` branch, it must be a method named `cmp` that isn't `Ord::cmp`
-            *needs_fully_qualified = true;
-
-            // It's a bit annoying but `typeck_results` only gives us the CURRENT body, which we
-            // have none, not of any `LocalDefId` we want, so we must call the query itself to avoid
-            // an immediate ICE
-            cx.tcx
-                .typeck(def_id)
-                .type_dependent_def_id(cmp_expr.hir_id)
-                .is_some_and(|def_id| match_def_path(cx, def_id, &ORD_CMP))
-        },
-        _ => false,
-    }
-}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 4ff97e03a14..440940a4478 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -154,7 +154,6 @@ mod implicit_saturating_add;
 mod implicit_saturating_sub;
 mod implied_bounds_in_impls;
 mod inconsistent_struct_constructor;
-mod incorrect_impls;
 mod index_refutable_slice;
 mod indexing_slicing;
 mod infinite_iter;
@@ -244,6 +243,7 @@ mod neg_multiply;
 mod new_without_default;
 mod no_effect;
 mod no_mangle_with_rust_abi;
+mod non_canonical_impls;
 mod non_copy_const;
 mod non_expressive_names;
 mod non_octal_unix_permissions;
@@ -1070,7 +1070,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
             avoid_breaking_exported_api,
         ))
     });
-    store.register_late_pass(|_| Box::new(incorrect_impls::IncorrectImpls));
+    store.register_late_pass(|_| Box::new(non_canonical_impls::NonCanonicalImpls));
     store.register_late_pass(move |_| {
         Box::new(single_call_fn::SingleCallFn {
             avoid_breaking_exported_api,
diff --git a/clippy_lints/src/non_canonical_impls.rs b/clippy_lints/src/non_canonical_impls.rs
new file mode 100644
index 00000000000..c390e6913ff
--- /dev/null
+++ b/clippy_lints/src/non_canonical_impls.rs
@@ -0,0 +1,288 @@
+use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
+use clippy_utils::paths::ORD_CMP;
+use clippy_utils::ty::implements_trait;
+use clippy_utils::{get_parent_node, is_res_lang_ctor, last_path_segment, match_def_path, path_res, std_or_core};
+use rustc_errors::Applicability;
+use rustc_hir::def_id::LocalDefId;
+use rustc_hir::{Expr, ExprKind, ImplItem, ImplItemKind, ItemKind, LangItem, Node, UnOp};
+use rustc_hir_analysis::hir_ty_to_ty;
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::EarlyBinder;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::sym;
+use rustc_span::symbol::kw;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for non-canonical implementations of `Clone` when `Copy` is already implemented.
+    ///
+    /// ### Why is this bad?
+    /// If both `Clone` and `Copy` are implemented, they must agree. This can done by dereferencing
+    /// `self` in `Clone`'s implementation, which will avoid any possibility of the implementations
+    /// becoming out of sync.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// #[derive(Eq, PartialEq)]
+    /// struct A(u32);
+    ///
+    /// impl Clone for A {
+    ///     fn clone(&self) -> Self {
+    ///         Self(self.0)
+    ///     }
+    /// }
+    ///
+    /// impl Copy for A {}
+    /// ```
+    /// Use instead:
+    /// ```rust,ignore
+    /// #[derive(Eq, PartialEq)]
+    /// struct A(u32);
+    ///
+    /// impl Clone for A {
+    ///     fn clone(&self) -> Self {
+    ///         *self
+    ///     }
+    /// }
+    ///
+    /// impl Copy for A {}
+    /// ```
+    #[clippy::version = "1.72.0"]
+    pub NON_CANONICAL_CLONE_IMPL,
+    suspicious,
+    "non-canonical implementation of `Clone` on a `Copy` type"
+}
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for non-canonical implementations of `PartialOrd` when `Ord` is already implemented.
+    ///
+    /// ### Why is this bad?
+    /// If both `PartialOrd` and `Ord` are implemented, they must agree. This is commonly done by
+    /// wrapping the result of `cmp` in `Some` for `partial_cmp`. Not doing this may silently
+    /// introduce an error upon refactoring.
+    ///
+    /// ### Known issues
+    /// Code that calls the `.into()` method instead will be flagged, despite `.into()` wrapping it
+    /// in `Some`.
+    ///
+    /// ### Example
+    /// ```rust
+    /// # use std::cmp::Ordering;
+    /// #[derive(Eq, PartialEq)]
+    /// struct A(u32);
+    ///
+    /// impl Ord for A {
+    ///     fn cmp(&self, other: &Self) -> Ordering {
+    ///         // ...
+    /// #       todo!();
+    ///     }
+    /// }
+    ///
+    /// impl PartialOrd for A {
+    ///     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+    ///         // ...
+    /// #       todo!();
+    ///     }
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// # use std::cmp::Ordering;
+    /// #[derive(Eq, PartialEq)]
+    /// struct A(u32);
+    ///
+    /// impl Ord for A {
+    ///     fn cmp(&self, other: &Self) -> Ordering {
+    ///         // ...
+    /// #       todo!();
+    ///     }
+    /// }
+    ///
+    /// impl PartialOrd for A {
+    ///     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+    ///         Some(self.cmp(other))
+    ///     }
+    /// }
+    /// ```
+    #[clippy::version = "1.72.0"]
+    pub NON_CANONICAL_PARTIAL_ORD_IMPL,
+    suspicious,
+    "non-canonical implementation of `PartialOrd` on an `Ord` type"
+}
+declare_lint_pass!(NonCanonicalImpls => [NON_CANONICAL_CLONE_IMPL, NON_CANONICAL_PARTIAL_ORD_IMPL]);
+
+impl LateLintPass<'_> for NonCanonicalImpls {
+    #[expect(clippy::too_many_lines)]
+    fn check_impl_item(&mut self, cx: &LateContext<'_>, impl_item: &ImplItem<'_>) {
+        let Some(Node::Item(item)) = get_parent_node(cx.tcx, impl_item.hir_id()) else {
+            return;
+        };
+        let Some(trait_impl) = cx.tcx.impl_trait_ref(item.owner_id).map(EarlyBinder::skip_binder) else {
+            return;
+        };
+        if cx.tcx.is_automatically_derived(item.owner_id.to_def_id()) {
+            return;
+        }
+        let ItemKind::Impl(imp) = item.kind else {
+            return;
+        };
+        let ImplItemKind::Fn(_, impl_item_id) = cx.tcx.hir().impl_item(impl_item.impl_item_id()).kind else {
+            return;
+        };
+        let body = cx.tcx.hir().body(impl_item_id);
+        let ExprKind::Block(block, ..) = body.value.kind else {
+            return;
+        };
+
+        if cx.tcx.is_diagnostic_item(sym::Clone, trait_impl.def_id)
+            && let Some(copy_def_id) = cx.tcx.get_diagnostic_item(sym::Copy)
+            && implements_trait(
+                    cx,
+                    trait_impl.self_ty(),
+                    copy_def_id,
+                    &[],
+                )
+        {
+            if impl_item.ident.name == sym::clone {
+                if block.stmts.is_empty()
+                    && let Some(expr) = block.expr
+                    && let ExprKind::Unary(UnOp::Deref, deref) = expr.kind
+                    && let ExprKind::Path(qpath) = deref.kind
+                    && last_path_segment(&qpath).ident.name == kw::SelfLower
+                {} else {
+                    span_lint_and_sugg(
+                        cx,
+                        NON_CANONICAL_CLONE_IMPL,
+                        block.span,
+                        "non-canonical implementation of `clone` on a `Copy` type",
+                        "change this to",
+                        "{ *self }".to_owned(),
+                        Applicability::MaybeIncorrect,
+                    );
+
+                    return;
+                }
+            }
+
+            if impl_item.ident.name == sym::clone_from {
+                span_lint_and_sugg(
+                    cx,
+                    NON_CANONICAL_CLONE_IMPL,
+                    impl_item.span,
+                    "unnecessary implementation of `clone_from` on a `Copy` type",
+                    "remove it",
+                    String::new(),
+                    Applicability::MaybeIncorrect,
+                );
+
+                return;
+            }
+        }
+
+        if cx.tcx.is_diagnostic_item(sym::PartialOrd, trait_impl.def_id)
+            && impl_item.ident.name == sym::partial_cmp
+            && let Some(ord_def_id) = cx
+                .tcx
+                .diagnostic_items(trait_impl.def_id.krate)
+                .name_to_id
+                .get(&sym::Ord)
+            && implements_trait(cx, hir_ty_to_ty(cx.tcx, imp.self_ty), *ord_def_id, &[])
+        {
+            // If the `cmp` call likely needs to be fully qualified in the suggestion
+            // (like `std::cmp::Ord::cmp`). It's unfortunate we must put this here but we can't
+            // access `cmp_expr` in the suggestion without major changes, as we lint in `else`.
+            let mut needs_fully_qualified = false;
+
+            if block.stmts.is_empty()
+                && let Some(expr) = block.expr
+                && let ExprKind::Call(
+                        Expr {
+                            kind: ExprKind::Path(some_path),
+                            hir_id: some_hir_id,
+                            ..
+                        },
+                        [cmp_expr],
+                    ) = expr.kind
+                && is_res_lang_ctor(cx, cx.qpath_res(some_path, *some_hir_id), LangItem::OptionSome)
+                // Fix #11178, allow `Self::cmp(self, ..)` too
+                && self_cmp_call(cx, cmp_expr, impl_item.owner_id.def_id, &mut needs_fully_qualified)
+            {} else {
+                // If `Self` and `Rhs` are not the same type, bail. This makes creating a valid
+                // suggestion tons more complex.
+                if let [lhs, rhs, ..] = trait_impl.args.as_slice() && lhs != rhs {
+                    return;
+                }
+
+                span_lint_and_then(
+                    cx,
+                    NON_CANONICAL_PARTIAL_ORD_IMPL,
+                    item.span,
+                    "non-canonical implementation of `partial_cmp` on an `Ord` type",
+                    |diag| {
+                        let [_, other] = body.params else {
+                            return;
+                        };
+                        let Some(std_or_core) = std_or_core(cx) else {
+                            return;
+                        };
+
+                        let suggs = match (other.pat.simple_ident(), needs_fully_qualified) {
+                            (Some(other_ident), true) => vec![(
+                                block.span,
+                                format!("{{ Some({std_or_core}::cmp::Ord::cmp(self, {})) }}", other_ident.name),
+                            )],
+                            (Some(other_ident), false) => {
+                                vec![(block.span, format!("{{ Some(self.cmp({})) }}", other_ident.name))]
+                            },
+                            (None, true) => vec![
+                                (
+                                    block.span,
+                                    format!("{{ Some({std_or_core}::cmp::Ord::cmp(self, other)) }}"),
+                                ),
+                                (other.pat.span, "other".to_owned()),
+                            ],
+                            (None, false) => vec![
+                                (block.span, "{ Some(self.cmp(other)) }".to_owned()),
+                                (other.pat.span, "other".to_owned()),
+                            ],
+                        };
+
+                        diag.multipart_suggestion(
+                            "change this to",
+                            suggs,
+                            Applicability::Unspecified,
+                        );
+                    }
+                );
+            }
+        }
+    }
+}
+
+/// Returns whether this is any of `self.cmp(..)`, `Self::cmp(self, ..)` or `Ord::cmp(self, ..)`.
+fn self_cmp_call<'tcx>(
+    cx: &LateContext<'tcx>,
+    cmp_expr: &'tcx Expr<'tcx>,
+    def_id: LocalDefId,
+    needs_fully_qualified: &mut bool,
+) -> bool {
+    match cmp_expr.kind {
+        ExprKind::Call(path, [_self, _other]) => path_res(cx, path)
+            .opt_def_id()
+            .is_some_and(|def_id| match_def_path(cx, def_id, &ORD_CMP)),
+        ExprKind::MethodCall(_, _, [_other], ..) => {
+            // We can set this to true here no matter what as if it's a `MethodCall` and goes to the
+            // `else` branch, it must be a method named `cmp` that isn't `Ord::cmp`
+            *needs_fully_qualified = true;
+
+            // It's a bit annoying but `typeck_results` only gives us the CURRENT body, which we
+            // have none, not of any `LocalDefId` we want, so we must call the query itself to avoid
+            // an immediate ICE
+            cx.tcx
+                .typeck(def_id)
+                .type_dependent_def_id(cmp_expr.hir_id)
+                .is_some_and(|def_id| match_def_path(cx, def_id, &ORD_CMP))
+        },
+        _ => false,
+    }
+}
diff --git a/clippy_lints/src/renamed_lints.rs b/clippy_lints/src/renamed_lints.rs
index fc1fabcc0ae..613f1ecc6fb 100644
--- a/clippy_lints/src/renamed_lints.rs
+++ b/clippy_lints/src/renamed_lints.rs
@@ -15,6 +15,8 @@ pub static RENAMED_LINTS: &[(&str, &str)] = &[
     ("clippy::eval_order_dependence", "clippy::mixed_read_write_in_expression"),
     ("clippy::identity_conversion", "clippy::useless_conversion"),
     ("clippy::if_let_some_result", "clippy::match_result_ok"),
+    ("clippy::incorrect_clone_impl_on_copy_type", "clippy::non_canonical_clone_impl"),
+    ("clippy::incorrect_partial_ord_impl_on_ord_type", "clippy::non_canonical_partial_ord_impl"),
     ("clippy::integer_arithmetic", "clippy::arithmetic_side_effects"),
     ("clippy::logic_bug", "clippy::overly_complex_bool_expr"),
     ("clippy::new_without_default_derive", "clippy::new_without_default"),
@@ -38,12 +40,12 @@ pub static RENAMED_LINTS: &[(&str, &str)] = &[
     ("clippy::drop_bounds", "drop_bounds"),
     ("clippy::drop_copy", "dropping_copy_types"),
     ("clippy::drop_ref", "dropping_references"),
+    ("clippy::fn_null_check", "useless_ptr_null_checks"),
     ("clippy::for_loop_over_option", "for_loops_over_fallibles"),
     ("clippy::for_loop_over_result", "for_loops_over_fallibles"),
     ("clippy::for_loops_over_fallibles", "for_loops_over_fallibles"),
     ("clippy::forget_copy", "forgetting_copy_types"),
     ("clippy::forget_ref", "forgetting_references"),
-    ("clippy::fn_null_check", "useless_ptr_null_checks"),
     ("clippy::into_iter_on_array", "array_into_iter"),
     ("clippy::invalid_atomic_ordering", "invalid_atomic_ordering"),
     ("clippy::invalid_ref", "invalid_value"),
diff --git a/tests/ui/bool_comparison.fixed b/tests/ui/bool_comparison.fixed
index db85247f47d..e3f2ca72d1c 100644
--- a/tests/ui/bool_comparison.fixed
+++ b/tests/ui/bool_comparison.fixed
@@ -1,6 +1,6 @@
 #![allow(clippy::needless_if)]
 #![warn(clippy::bool_comparison)]
-#![allow(clippy::incorrect_partial_ord_impl_on_ord_type)]
+#![allow(clippy::non_canonical_partial_ord_impl)]
 
 fn main() {
     let x = true;
diff --git a/tests/ui/bool_comparison.rs b/tests/ui/bool_comparison.rs
index 0915f88544b..d1bc20d6831 100644
--- a/tests/ui/bool_comparison.rs
+++ b/tests/ui/bool_comparison.rs
@@ -1,6 +1,6 @@
 #![allow(clippy::needless_if)]
 #![warn(clippy::bool_comparison)]
-#![allow(clippy::incorrect_partial_ord_impl_on_ord_type)]
+#![allow(clippy::non_canonical_partial_ord_impl)]
 
 fn main() {
     let x = true;
diff --git a/tests/ui/clone_on_copy_impl.rs b/tests/ui/clone_on_copy_impl.rs
index b7c186bef77..2d03544ad8b 100644
--- a/tests/ui/clone_on_copy_impl.rs
+++ b/tests/ui/clone_on_copy_impl.rs
@@ -1,4 +1,4 @@
-#![allow(clippy::incorrect_clone_impl_on_copy_type)]
+#![allow(clippy::non_canonical_clone_impl)]
 
 use std::fmt;
 use std::marker::PhantomData;
diff --git a/tests/ui/derive.rs b/tests/ui/derive.rs
index 07df50f4661..4ac21f2cb4b 100644
--- a/tests/ui/derive.rs
+++ b/tests/ui/derive.rs
@@ -1,8 +1,4 @@
-#![allow(
-    clippy::incorrect_clone_impl_on_copy_type,
-    clippy::incorrect_partial_ord_impl_on_ord_type,
-    dead_code
-)]
+#![allow(clippy::non_canonical_clone_impl, clippy::non_canonical_partial_ord_impl, dead_code)]
 #![warn(clippy::expl_impl_clone_on_copy)]
 
 #[derive(Copy)]
diff --git a/tests/ui/derive.stderr b/tests/ui/derive.stderr
index b1b45df17fa..d9093038b09 100644
--- a/tests/ui/derive.stderr
+++ b/tests/ui/derive.stderr
@@ -1,5 +1,5 @@
 error: you are implementing `Clone` explicitly on a `Copy` type
-  --> $DIR/derive.rs:11:1
+  --> $DIR/derive.rs:7:1
    |
 LL | / impl Clone for Qux {
 LL | |
@@ -10,7 +10,7 @@ LL | | }
    | |_^
    |
 note: consider deriving `Clone` or removing `Copy`
-  --> $DIR/derive.rs:11:1
+  --> $DIR/derive.rs:7:1
    |
 LL | / impl Clone for Qux {
 LL | |
@@ -23,7 +23,7 @@ LL | | }
    = help: to override `-D warnings` add `#[allow(clippy::expl_impl_clone_on_copy)]`
 
 error: you are implementing `Clone` explicitly on a `Copy` type
-  --> $DIR/derive.rs:36:1
+  --> $DIR/derive.rs:32:1
    |
 LL | / impl<'a> Clone for Lt<'a> {
 LL | |
@@ -34,7 +34,7 @@ LL | | }
    | |_^
    |
 note: consider deriving `Clone` or removing `Copy`
-  --> $DIR/derive.rs:36:1
+  --> $DIR/derive.rs:32:1
    |
 LL | / impl<'a> Clone for Lt<'a> {
 LL | |
@@ -45,7 +45,7 @@ LL | | }
    | |_^
 
 error: you are implementing `Clone` explicitly on a `Copy` type
-  --> $DIR/derive.rs:48:1
+  --> $DIR/derive.rs:44:1
    |
 LL | / impl Clone for BigArray {
 LL | |
@@ -56,7 +56,7 @@ LL | | }
    | |_^
    |
 note: consider deriving `Clone` or removing `Copy`
-  --> $DIR/derive.rs:48:1
+  --> $DIR/derive.rs:44:1
    |
 LL | / impl Clone for BigArray {
 LL | |
@@ -67,7 +67,7 @@ LL | | }
    | |_^
 
 error: you are implementing `Clone` explicitly on a `Copy` type
-  --> $DIR/derive.rs:60:1
+  --> $DIR/derive.rs:56:1
    |
 LL | / impl Clone for FnPtr {
 LL | |
@@ -78,7 +78,7 @@ LL | | }
    | |_^
    |
 note: consider deriving `Clone` or removing `Copy`
-  --> $DIR/derive.rs:60:1
+  --> $DIR/derive.rs:56:1
    |
 LL | / impl Clone for FnPtr {
 LL | |
@@ -89,7 +89,7 @@ LL | | }
    | |_^
 
 error: you are implementing `Clone` explicitly on a `Copy` type
-  --> $DIR/derive.rs:81:1
+  --> $DIR/derive.rs:77:1
    |
 LL | / impl<T: Clone> Clone for Generic2<T> {
 LL | |
@@ -100,7 +100,7 @@ LL | | }
    | |_^
    |
 note: consider deriving `Clone` or removing `Copy`
-  --> $DIR/derive.rs:81:1
+  --> $DIR/derive.rs:77:1
    |
 LL | / impl<T: Clone> Clone for Generic2<T> {
 LL | |
diff --git a/tests/ui/derive_ord_xor_partial_ord.rs b/tests/ui/derive_ord_xor_partial_ord.rs
index 2c19942d420..1c7e6d1c202 100644
--- a/tests/ui/derive_ord_xor_partial_ord.rs
+++ b/tests/ui/derive_ord_xor_partial_ord.rs
@@ -1,6 +1,6 @@
 #![warn(clippy::derive_ord_xor_partial_ord)]
 #![allow(clippy::unnecessary_wraps)]
-#![allow(clippy::incorrect_partial_ord_impl_on_ord_type)]
+#![allow(clippy::non_canonical_partial_ord_impl)]
 
 use std::cmp::Ordering;
 
diff --git a/tests/ui/incorrect_clone_impl_on_copy_type.fixed b/tests/ui/incorrect_clone_impl_on_copy_type.fixed
deleted file mode 100644
index 165702b3041..00000000000
--- a/tests/ui/incorrect_clone_impl_on_copy_type.fixed
+++ /dev/null
@@ -1,96 +0,0 @@
-#![allow(clippy::clone_on_copy, unused)]
-#![no_main]
-
-// lint
-
-struct A(u32);
-
-impl Clone for A {
-    fn clone(&self) -> Self { *self }
-
-    
-}
-
-impl Copy for A {}
-
-// do not lint
-
-struct B(u32);
-
-impl Clone for B {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-
-impl Copy for B {}
-
-// do not lint derived (clone's implementation is `*self` here anyway)
-
-#[derive(Clone, Copy)]
-struct C(u32);
-
-// do not lint derived (fr this time)
-
-struct D(u32);
-
-#[automatically_derived]
-impl Clone for D {
-    fn clone(&self) -> Self {
-        Self(self.0)
-    }
-
-    fn clone_from(&mut self, source: &Self) {
-        source.clone();
-        *self = source.clone();
-    }
-}
-
-impl Copy for D {}
-
-// do not lint if clone is not manually implemented
-
-struct E(u32);
-
-#[automatically_derived]
-impl Clone for E {
-    fn clone(&self) -> Self {
-        Self(self.0)
-    }
-
-    fn clone_from(&mut self, source: &Self) {
-        source.clone();
-        *self = source.clone();
-    }
-}
-
-impl Copy for E {}
-
-// lint since clone is not derived
-
-#[derive(Copy)]
-struct F(u32);
-
-impl Clone for F {
-    fn clone(&self) -> Self { *self }
-
-    
-}
-
-// do not lint since copy has more restrictive bounds
-
-#[derive(Eq, PartialEq)]
-struct Uwu<A: Copy>(A);
-
-impl<A: Copy> Clone for Uwu<A> {
-    fn clone(&self) -> Self {
-        Self(self.0)
-    }
-
-    fn clone_from(&mut self, source: &Self) {
-        source.clone();
-        *self = source.clone();
-    }
-}
-
-impl<A: std::fmt::Debug + Copy + Clone> Copy for Uwu<A> {}
diff --git a/tests/ui/incorrect_clone_impl_on_copy_type.rs b/tests/ui/incorrect_clone_impl_on_copy_type.rs
deleted file mode 100644
index 3b07dd5ce62..00000000000
--- a/tests/ui/incorrect_clone_impl_on_copy_type.rs
+++ /dev/null
@@ -1,106 +0,0 @@
-#![allow(clippy::clone_on_copy, unused)]
-#![no_main]
-
-// lint
-
-struct A(u32);
-
-impl Clone for A {
-    fn clone(&self) -> Self {
-        Self(self.0)
-    }
-
-    fn clone_from(&mut self, source: &Self) {
-        source.clone();
-        *self = source.clone();
-    }
-}
-
-impl Copy for A {}
-
-// do not lint
-
-struct B(u32);
-
-impl Clone for B {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-
-impl Copy for B {}
-
-// do not lint derived (clone's implementation is `*self` here anyway)
-
-#[derive(Clone, Copy)]
-struct C(u32);
-
-// do not lint derived (fr this time)
-
-struct D(u32);
-
-#[automatically_derived]
-impl Clone for D {
-    fn clone(&self) -> Self {
-        Self(self.0)
-    }
-
-    fn clone_from(&mut self, source: &Self) {
-        source.clone();
-        *self = source.clone();
-    }
-}
-
-impl Copy for D {}
-
-// do not lint if clone is not manually implemented
-
-struct E(u32);
-
-#[automatically_derived]
-impl Clone for E {
-    fn clone(&self) -> Self {
-        Self(self.0)
-    }
-
-    fn clone_from(&mut self, source: &Self) {
-        source.clone();
-        *self = source.clone();
-    }
-}
-
-impl Copy for E {}
-
-// lint since clone is not derived
-
-#[derive(Copy)]
-struct F(u32);
-
-impl Clone for F {
-    fn clone(&self) -> Self {
-        Self(self.0)
-    }
-
-    fn clone_from(&mut self, source: &Self) {
-        source.clone();
-        *self = source.clone();
-    }
-}
-
-// do not lint since copy has more restrictive bounds
-
-#[derive(Eq, PartialEq)]
-struct Uwu<A: Copy>(A);
-
-impl<A: Copy> Clone for Uwu<A> {
-    fn clone(&self) -> Self {
-        Self(self.0)
-    }
-
-    fn clone_from(&mut self, source: &Self) {
-        source.clone();
-        *self = source.clone();
-    }
-}
-
-impl<A: std::fmt::Debug + Copy + Clone> Copy for Uwu<A> {}
diff --git a/tests/ui/incorrect_clone_impl_on_copy_type.stderr b/tests/ui/incorrect_clone_impl_on_copy_type.stderr
deleted file mode 100644
index 566a1a4b14b..00000000000
--- a/tests/ui/incorrect_clone_impl_on_copy_type.stderr
+++ /dev/null
@@ -1,40 +0,0 @@
-error: incorrect implementation of `clone` on a `Copy` type
-  --> $DIR/incorrect_clone_impl_on_copy_type.rs:9:29
-   |
-LL |       fn clone(&self) -> Self {
-   |  _____________________________^
-LL | |         Self(self.0)
-LL | |     }
-   | |_____^ help: change this to: `{ *self }`
-   |
-   = note: `#[deny(clippy::incorrect_clone_impl_on_copy_type)]` on by default
-
-error: incorrect implementation of `clone_from` on a `Copy` type
-  --> $DIR/incorrect_clone_impl_on_copy_type.rs:13:5
-   |
-LL | /     fn clone_from(&mut self, source: &Self) {
-LL | |         source.clone();
-LL | |         *self = source.clone();
-LL | |     }
-   | |_____^ help: remove it
-
-error: incorrect implementation of `clone` on a `Copy` type
-  --> $DIR/incorrect_clone_impl_on_copy_type.rs:80:29
-   |
-LL |       fn clone(&self) -> Self {
-   |  _____________________________^
-LL | |         Self(self.0)
-LL | |     }
-   | |_____^ help: change this to: `{ *self }`
-
-error: incorrect implementation of `clone_from` on a `Copy` type
-  --> $DIR/incorrect_clone_impl_on_copy_type.rs:84:5
-   |
-LL | /     fn clone_from(&mut self, source: &Self) {
-LL | |         source.clone();
-LL | |         *self = source.clone();
-LL | |     }
-   | |_____^ help: remove it
-
-error: aborting due to 4 previous errors
-
diff --git a/tests/ui/incorrect_partial_ord_impl_on_ord_type.fixed b/tests/ui/incorrect_partial_ord_impl_on_ord_type.fixed
deleted file mode 100644
index db55cc094e3..00000000000
--- a/tests/ui/incorrect_partial_ord_impl_on_ord_type.fixed
+++ /dev/null
@@ -1,144 +0,0 @@
-#![no_main]
-
-use std::cmp::Ordering;
-
-// lint
-
-#[derive(Eq, PartialEq)]
-struct A(u32);
-
-impl Ord for A {
-    fn cmp(&self, other: &Self) -> Ordering {
-        todo!();
-    }
-}
-
-impl PartialOrd for A {
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> { Some(self.cmp(other)) }
-}
-
-// do not lint
-
-#[derive(Eq, PartialEq)]
-struct B(u32);
-
-impl Ord for B {
-    fn cmp(&self, other: &Self) -> Ordering {
-        todo!();
-    }
-}
-
-impl PartialOrd for B {
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        Some(self.cmp(other))
-    }
-}
-
-// lint, and give `_` a name
-
-#[derive(Eq, PartialEq)]
-struct C(u32);
-
-impl Ord for C {
-    fn cmp(&self, other: &Self) -> Ordering {
-        todo!();
-    }
-}
-
-impl PartialOrd for C {
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> { Some(self.cmp(other)) }
-}
-
-// do not lint derived
-
-#[derive(Eq, Ord, PartialEq, PartialOrd)]
-struct D(u32);
-
-// do not lint if ord is not manually implemented
-
-#[derive(Eq, PartialEq)]
-struct E(u32);
-
-impl PartialOrd for E {
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        todo!();
-    }
-}
-
-// do not lint since ord has more restrictive bounds
-
-#[derive(Eq, PartialEq)]
-struct Uwu<A>(A);
-
-impl<A: std::fmt::Debug + Ord + PartialOrd> Ord for Uwu<A> {
-    fn cmp(&self, other: &Self) -> Ordering {
-        todo!();
-    }
-}
-
-impl<A: Ord + PartialOrd> PartialOrd for Uwu<A> {
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        todo!();
-    }
-}
-
-// do not lint since `Rhs` is not `Self`
-
-#[derive(Eq, PartialEq)]
-struct F(u32);
-
-impl Ord for F {
-    fn cmp(&self, other: &Self) -> Ordering {
-        todo!();
-    }
-}
-
-impl PartialOrd for F {
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        Some(self.cmp(other))
-    }
-}
-
-impl PartialEq<u32> for F {
-    fn eq(&self, other: &u32) -> bool {
-        todo!();
-    }
-}
-
-impl PartialOrd<u32> for F {
-    fn partial_cmp(&self, other: &u32) -> Option<Ordering> {
-        todo!();
-    }
-}
-
-// #11178, do not lint
-
-#[derive(Eq, PartialEq)]
-struct G(u32);
-
-impl Ord for G {
-    fn cmp(&self, other: &Self) -> Ordering {
-        todo!();
-    }
-}
-
-impl PartialOrd for G {
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        Some(Self::cmp(self, other))
-    }
-}
-
-#[derive(Eq, PartialEq)]
-struct H(u32);
-
-impl Ord for H {
-    fn cmp(&self, other: &Self) -> Ordering {
-        todo!();
-    }
-}
-
-impl PartialOrd for H {
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        Some(Ord::cmp(self, other))
-    }
-}
diff --git a/tests/ui/incorrect_partial_ord_impl_on_ord_type.rs b/tests/ui/incorrect_partial_ord_impl_on_ord_type.rs
deleted file mode 100644
index 52f4b85b917..00000000000
--- a/tests/ui/incorrect_partial_ord_impl_on_ord_type.rs
+++ /dev/null
@@ -1,148 +0,0 @@
-#![no_main]
-
-use std::cmp::Ordering;
-
-// lint
-
-#[derive(Eq, PartialEq)]
-struct A(u32);
-
-impl Ord for A {
-    fn cmp(&self, other: &Self) -> Ordering {
-        todo!();
-    }
-}
-
-impl PartialOrd for A {
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        todo!();
-    }
-}
-
-// do not lint
-
-#[derive(Eq, PartialEq)]
-struct B(u32);
-
-impl Ord for B {
-    fn cmp(&self, other: &Self) -> Ordering {
-        todo!();
-    }
-}
-
-impl PartialOrd for B {
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        Some(self.cmp(other))
-    }
-}
-
-// lint, and give `_` a name
-
-#[derive(Eq, PartialEq)]
-struct C(u32);
-
-impl Ord for C {
-    fn cmp(&self, other: &Self) -> Ordering {
-        todo!();
-    }
-}
-
-impl PartialOrd for C {
-    fn partial_cmp(&self, _: &Self) -> Option<Ordering> {
-        todo!();
-    }
-}
-
-// do not lint derived
-
-#[derive(Eq, Ord, PartialEq, PartialOrd)]
-struct D(u32);
-
-// do not lint if ord is not manually implemented
-
-#[derive(Eq, PartialEq)]
-struct E(u32);
-
-impl PartialOrd for E {
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        todo!();
-    }
-}
-
-// do not lint since ord has more restrictive bounds
-
-#[derive(Eq, PartialEq)]
-struct Uwu<A>(A);
-
-impl<A: std::fmt::Debug + Ord + PartialOrd> Ord for Uwu<A> {
-    fn cmp(&self, other: &Self) -> Ordering {
-        todo!();
-    }
-}
-
-impl<A: Ord + PartialOrd> PartialOrd for Uwu<A> {
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        todo!();
-    }
-}
-
-// do not lint since `Rhs` is not `Self`
-
-#[derive(Eq, PartialEq)]
-struct F(u32);
-
-impl Ord for F {
-    fn cmp(&self, other: &Self) -> Ordering {
-        todo!();
-    }
-}
-
-impl PartialOrd for F {
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        Some(self.cmp(other))
-    }
-}
-
-impl PartialEq<u32> for F {
-    fn eq(&self, other: &u32) -> bool {
-        todo!();
-    }
-}
-
-impl PartialOrd<u32> for F {
-    fn partial_cmp(&self, other: &u32) -> Option<Ordering> {
-        todo!();
-    }
-}
-
-// #11178, do not lint
-
-#[derive(Eq, PartialEq)]
-struct G(u32);
-
-impl Ord for G {
-    fn cmp(&self, other: &Self) -> Ordering {
-        todo!();
-    }
-}
-
-impl PartialOrd for G {
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        Some(Self::cmp(self, other))
-    }
-}
-
-#[derive(Eq, PartialEq)]
-struct H(u32);
-
-impl Ord for H {
-    fn cmp(&self, other: &Self) -> Ordering {
-        todo!();
-    }
-}
-
-impl PartialOrd for H {
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        Some(Ord::cmp(self, other))
-    }
-}
diff --git a/tests/ui/incorrect_partial_ord_impl_on_ord_type.stderr b/tests/ui/incorrect_partial_ord_impl_on_ord_type.stderr
deleted file mode 100644
index 1f706984662..00000000000
--- a/tests/ui/incorrect_partial_ord_impl_on_ord_type.stderr
+++ /dev/null
@@ -1,31 +0,0 @@
-error: incorrect implementation of `partial_cmp` on an `Ord` type
-  --> $DIR/incorrect_partial_ord_impl_on_ord_type.rs:16:1
-   |
-LL | /  impl PartialOrd for A {
-LL | |      fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-   | | _____________________________________________________________-
-LL | ||         todo!();
-LL | ||     }
-   | ||_____- help: change this to: `{ Some(self.cmp(other)) }`
-LL | |  }
-   | |__^
-   |
-   = note: `#[deny(clippy::incorrect_partial_ord_impl_on_ord_type)]` on by default
-
-error: incorrect implementation of `partial_cmp` on an `Ord` type
-  --> $DIR/incorrect_partial_ord_impl_on_ord_type.rs:50:1
-   |
-LL | / impl PartialOrd for C {
-LL | |     fn partial_cmp(&self, _: &Self) -> Option<Ordering> {
-LL | |         todo!();
-LL | |     }
-LL | | }
-   | |_^
-   |
-help: change this to
-   |
-LL |     fn partial_cmp(&self, other: &Self) -> Option<Ordering> { Some(self.cmp(other)) }
-   |                           ~~~~~                             ~~~~~~~~~~~~~~~~~~~~~~~~~
-
-error: aborting due to 2 previous errors
-
diff --git a/tests/ui/incorrect_partial_ord_impl_on_ord_type_fully_qual.rs b/tests/ui/incorrect_partial_ord_impl_on_ord_type_fully_qual.rs
deleted file mode 100644
index 1173a95d065..00000000000
--- a/tests/ui/incorrect_partial_ord_impl_on_ord_type_fully_qual.rs
+++ /dev/null
@@ -1,54 +0,0 @@
-// This test's filename is... a bit verbose. But it ensures we suggest the correct code when `Ord`
-// is not in scope.
-#![no_main]
-#![no_implicit_prelude]
-//@no-rustfix
-extern crate std;
-
-use std::cmp::{self, Eq, Ordering, PartialEq, PartialOrd};
-use std::option::Option::{self, Some};
-use std::todo;
-
-// lint
-
-#[derive(Eq, PartialEq)]
-struct A(u32);
-
-impl cmp::Ord for A {
-    fn cmp(&self, other: &Self) -> Ordering {
-        todo!();
-    }
-}
-
-impl PartialOrd for A {
-    //~^ ERROR: incorrect implementation of `partial_cmp` on an `Ord` type
-    //~| NOTE: `#[deny(clippy::incorrect_partial_ord_impl_on_ord_type)]` on by default
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        // NOTE: This suggestion is wrong, as `Ord` is not in scope. But this should be fine as it isn't
-        // automatically applied
-        todo!();
-    }
-}
-
-#[derive(Eq, PartialEq)]
-struct B(u32);
-
-impl B {
-    fn cmp(&self, other: &Self) -> Ordering {
-        todo!();
-    }
-}
-
-impl cmp::Ord for B {
-    fn cmp(&self, other: &Self) -> Ordering {
-        todo!();
-    }
-}
-
-impl PartialOrd for B {
-    //~^ ERROR: incorrect implementation of `partial_cmp` on an `Ord` type
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        // This calls `B.cmp`, not `Ord::cmp`!
-        Some(self.cmp(other))
-    }
-}
diff --git a/tests/ui/incorrect_partial_ord_impl_on_ord_type_fully_qual.stderr b/tests/ui/incorrect_partial_ord_impl_on_ord_type_fully_qual.stderr
deleted file mode 100644
index 09d7a32e334..00000000000
--- a/tests/ui/incorrect_partial_ord_impl_on_ord_type_fully_qual.stderr
+++ /dev/null
@@ -1,34 +0,0 @@
-error: incorrect implementation of `partial_cmp` on an `Ord` type
-  --> $DIR/incorrect_partial_ord_impl_on_ord_type_fully_qual.rs:23:1
-   |
-LL | /  impl PartialOrd for A {
-LL | |
-LL | |
-LL | |      fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-   | | _____________________________________________________________-
-LL | ||         // NOTE: This suggestion is wrong, as `Ord` is not in scope. But this should be fine as it isn't
-LL | ||         // automatically applied
-LL | ||         todo!();
-LL | ||     }
-   | ||_____- help: change this to: `{ Some(self.cmp(other)) }`
-LL | |  }
-   | |__^
-   |
-   = note: `#[deny(clippy::incorrect_partial_ord_impl_on_ord_type)]` on by default
-
-error: incorrect implementation of `partial_cmp` on an `Ord` type
-  --> $DIR/incorrect_partial_ord_impl_on_ord_type_fully_qual.rs:48:1
-   |
-LL | /  impl PartialOrd for B {
-LL | |
-LL | |      fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-   | | _____________________________________________________________-
-LL | ||         // This calls `B.cmp`, not `Ord::cmp`!
-LL | ||         Some(self.cmp(other))
-LL | ||     }
-   | ||_____- help: change this to: `{ Some(std::cmp::Ord::cmp(self, other)) }`
-LL | |  }
-   | |__^
-
-error: aborting due to 2 previous errors
-
diff --git a/tests/ui/non_canonical_clone_impl.fixed b/tests/ui/non_canonical_clone_impl.fixed
new file mode 100644
index 00000000000..165702b3041
--- /dev/null
+++ b/tests/ui/non_canonical_clone_impl.fixed
@@ -0,0 +1,96 @@
+#![allow(clippy::clone_on_copy, unused)]
+#![no_main]
+
+// lint
+
+struct A(u32);
+
+impl Clone for A {
+    fn clone(&self) -> Self { *self }
+
+    
+}
+
+impl Copy for A {}
+
+// do not lint
+
+struct B(u32);
+
+impl Clone for B {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+
+impl Copy for B {}
+
+// do not lint derived (clone's implementation is `*self` here anyway)
+
+#[derive(Clone, Copy)]
+struct C(u32);
+
+// do not lint derived (fr this time)
+
+struct D(u32);
+
+#[automatically_derived]
+impl Clone for D {
+    fn clone(&self) -> Self {
+        Self(self.0)
+    }
+
+    fn clone_from(&mut self, source: &Self) {
+        source.clone();
+        *self = source.clone();
+    }
+}
+
+impl Copy for D {}
+
+// do not lint if clone is not manually implemented
+
+struct E(u32);
+
+#[automatically_derived]
+impl Clone for E {
+    fn clone(&self) -> Self {
+        Self(self.0)
+    }
+
+    fn clone_from(&mut self, source: &Self) {
+        source.clone();
+        *self = source.clone();
+    }
+}
+
+impl Copy for E {}
+
+// lint since clone is not derived
+
+#[derive(Copy)]
+struct F(u32);
+
+impl Clone for F {
+    fn clone(&self) -> Self { *self }
+
+    
+}
+
+// do not lint since copy has more restrictive bounds
+
+#[derive(Eq, PartialEq)]
+struct Uwu<A: Copy>(A);
+
+impl<A: Copy> Clone for Uwu<A> {
+    fn clone(&self) -> Self {
+        Self(self.0)
+    }
+
+    fn clone_from(&mut self, source: &Self) {
+        source.clone();
+        *self = source.clone();
+    }
+}
+
+impl<A: std::fmt::Debug + Copy + Clone> Copy for Uwu<A> {}
diff --git a/tests/ui/non_canonical_clone_impl.rs b/tests/ui/non_canonical_clone_impl.rs
new file mode 100644
index 00000000000..3b07dd5ce62
--- /dev/null
+++ b/tests/ui/non_canonical_clone_impl.rs
@@ -0,0 +1,106 @@
+#![allow(clippy::clone_on_copy, unused)]
+#![no_main]
+
+// lint
+
+struct A(u32);
+
+impl Clone for A {
+    fn clone(&self) -> Self {
+        Self(self.0)
+    }
+
+    fn clone_from(&mut self, source: &Self) {
+        source.clone();
+        *self = source.clone();
+    }
+}
+
+impl Copy for A {}
+
+// do not lint
+
+struct B(u32);
+
+impl Clone for B {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+
+impl Copy for B {}
+
+// do not lint derived (clone's implementation is `*self` here anyway)
+
+#[derive(Clone, Copy)]
+struct C(u32);
+
+// do not lint derived (fr this time)
+
+struct D(u32);
+
+#[automatically_derived]
+impl Clone for D {
+    fn clone(&self) -> Self {
+        Self(self.0)
+    }
+
+    fn clone_from(&mut self, source: &Self) {
+        source.clone();
+        *self = source.clone();
+    }
+}
+
+impl Copy for D {}
+
+// do not lint if clone is not manually implemented
+
+struct E(u32);
+
+#[automatically_derived]
+impl Clone for E {
+    fn clone(&self) -> Self {
+        Self(self.0)
+    }
+
+    fn clone_from(&mut self, source: &Self) {
+        source.clone();
+        *self = source.clone();
+    }
+}
+
+impl Copy for E {}
+
+// lint since clone is not derived
+
+#[derive(Copy)]
+struct F(u32);
+
+impl Clone for F {
+    fn clone(&self) -> Self {
+        Self(self.0)
+    }
+
+    fn clone_from(&mut self, source: &Self) {
+        source.clone();
+        *self = source.clone();
+    }
+}
+
+// do not lint since copy has more restrictive bounds
+
+#[derive(Eq, PartialEq)]
+struct Uwu<A: Copy>(A);
+
+impl<A: Copy> Clone for Uwu<A> {
+    fn clone(&self) -> Self {
+        Self(self.0)
+    }
+
+    fn clone_from(&mut self, source: &Self) {
+        source.clone();
+        *self = source.clone();
+    }
+}
+
+impl<A: std::fmt::Debug + Copy + Clone> Copy for Uwu<A> {}
diff --git a/tests/ui/non_canonical_clone_impl.stderr b/tests/ui/non_canonical_clone_impl.stderr
new file mode 100644
index 00000000000..44196751b05
--- /dev/null
+++ b/tests/ui/non_canonical_clone_impl.stderr
@@ -0,0 +1,41 @@
+error: non-canonical implementation of `clone` on a `Copy` type
+  --> $DIR/non_canonical_clone_impl.rs:9:29
+   |
+LL |       fn clone(&self) -> Self {
+   |  _____________________________^
+LL | |         Self(self.0)
+LL | |     }
+   | |_____^ help: change this to: `{ *self }`
+   |
+   = note: `-D clippy::non-canonical-clone-impl` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::non_canonical_clone_impl)]`
+
+error: unnecessary implementation of `clone_from` on a `Copy` type
+  --> $DIR/non_canonical_clone_impl.rs:13:5
+   |
+LL | /     fn clone_from(&mut self, source: &Self) {
+LL | |         source.clone();
+LL | |         *self = source.clone();
+LL | |     }
+   | |_____^ help: remove it
+
+error: non-canonical implementation of `clone` on a `Copy` type
+  --> $DIR/non_canonical_clone_impl.rs:80:29
+   |
+LL |       fn clone(&self) -> Self {
+   |  _____________________________^
+LL | |         Self(self.0)
+LL | |     }
+   | |_____^ help: change this to: `{ *self }`
+
+error: unnecessary implementation of `clone_from` on a `Copy` type
+  --> $DIR/non_canonical_clone_impl.rs:84:5
+   |
+LL | /     fn clone_from(&mut self, source: &Self) {
+LL | |         source.clone();
+LL | |         *self = source.clone();
+LL | |     }
+   | |_____^ help: remove it
+
+error: aborting due to 4 previous errors
+
diff --git a/tests/ui/non_canonical_partial_ord_impl.fixed b/tests/ui/non_canonical_partial_ord_impl.fixed
new file mode 100644
index 00000000000..db55cc094e3
--- /dev/null
+++ b/tests/ui/non_canonical_partial_ord_impl.fixed
@@ -0,0 +1,144 @@
+#![no_main]
+
+use std::cmp::Ordering;
+
+// lint
+
+#[derive(Eq, PartialEq)]
+struct A(u32);
+
+impl Ord for A {
+    fn cmp(&self, other: &Self) -> Ordering {
+        todo!();
+    }
+}
+
+impl PartialOrd for A {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> { Some(self.cmp(other)) }
+}
+
+// do not lint
+
+#[derive(Eq, PartialEq)]
+struct B(u32);
+
+impl Ord for B {
+    fn cmp(&self, other: &Self) -> Ordering {
+        todo!();
+    }
+}
+
+impl PartialOrd for B {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+// lint, and give `_` a name
+
+#[derive(Eq, PartialEq)]
+struct C(u32);
+
+impl Ord for C {
+    fn cmp(&self, other: &Self) -> Ordering {
+        todo!();
+    }
+}
+
+impl PartialOrd for C {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> { Some(self.cmp(other)) }
+}
+
+// do not lint derived
+
+#[derive(Eq, Ord, PartialEq, PartialOrd)]
+struct D(u32);
+
+// do not lint if ord is not manually implemented
+
+#[derive(Eq, PartialEq)]
+struct E(u32);
+
+impl PartialOrd for E {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        todo!();
+    }
+}
+
+// do not lint since ord has more restrictive bounds
+
+#[derive(Eq, PartialEq)]
+struct Uwu<A>(A);
+
+impl<A: std::fmt::Debug + Ord + PartialOrd> Ord for Uwu<A> {
+    fn cmp(&self, other: &Self) -> Ordering {
+        todo!();
+    }
+}
+
+impl<A: Ord + PartialOrd> PartialOrd for Uwu<A> {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        todo!();
+    }
+}
+
+// do not lint since `Rhs` is not `Self`
+
+#[derive(Eq, PartialEq)]
+struct F(u32);
+
+impl Ord for F {
+    fn cmp(&self, other: &Self) -> Ordering {
+        todo!();
+    }
+}
+
+impl PartialOrd for F {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl PartialEq<u32> for F {
+    fn eq(&self, other: &u32) -> bool {
+        todo!();
+    }
+}
+
+impl PartialOrd<u32> for F {
+    fn partial_cmp(&self, other: &u32) -> Option<Ordering> {
+        todo!();
+    }
+}
+
+// #11178, do not lint
+
+#[derive(Eq, PartialEq)]
+struct G(u32);
+
+impl Ord for G {
+    fn cmp(&self, other: &Self) -> Ordering {
+        todo!();
+    }
+}
+
+impl PartialOrd for G {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(Self::cmp(self, other))
+    }
+}
+
+#[derive(Eq, PartialEq)]
+struct H(u32);
+
+impl Ord for H {
+    fn cmp(&self, other: &Self) -> Ordering {
+        todo!();
+    }
+}
+
+impl PartialOrd for H {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(Ord::cmp(self, other))
+    }
+}
diff --git a/tests/ui/non_canonical_partial_ord_impl.rs b/tests/ui/non_canonical_partial_ord_impl.rs
new file mode 100644
index 00000000000..52f4b85b917
--- /dev/null
+++ b/tests/ui/non_canonical_partial_ord_impl.rs
@@ -0,0 +1,148 @@
+#![no_main]
+
+use std::cmp::Ordering;
+
+// lint
+
+#[derive(Eq, PartialEq)]
+struct A(u32);
+
+impl Ord for A {
+    fn cmp(&self, other: &Self) -> Ordering {
+        todo!();
+    }
+}
+
+impl PartialOrd for A {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        todo!();
+    }
+}
+
+// do not lint
+
+#[derive(Eq, PartialEq)]
+struct B(u32);
+
+impl Ord for B {
+    fn cmp(&self, other: &Self) -> Ordering {
+        todo!();
+    }
+}
+
+impl PartialOrd for B {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+// lint, and give `_` a name
+
+#[derive(Eq, PartialEq)]
+struct C(u32);
+
+impl Ord for C {
+    fn cmp(&self, other: &Self) -> Ordering {
+        todo!();
+    }
+}
+
+impl PartialOrd for C {
+    fn partial_cmp(&self, _: &Self) -> Option<Ordering> {
+        todo!();
+    }
+}
+
+// do not lint derived
+
+#[derive(Eq, Ord, PartialEq, PartialOrd)]
+struct D(u32);
+
+// do not lint if ord is not manually implemented
+
+#[derive(Eq, PartialEq)]
+struct E(u32);
+
+impl PartialOrd for E {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        todo!();
+    }
+}
+
+// do not lint since ord has more restrictive bounds
+
+#[derive(Eq, PartialEq)]
+struct Uwu<A>(A);
+
+impl<A: std::fmt::Debug + Ord + PartialOrd> Ord for Uwu<A> {
+    fn cmp(&self, other: &Self) -> Ordering {
+        todo!();
+    }
+}
+
+impl<A: Ord + PartialOrd> PartialOrd for Uwu<A> {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        todo!();
+    }
+}
+
+// do not lint since `Rhs` is not `Self`
+
+#[derive(Eq, PartialEq)]
+struct F(u32);
+
+impl Ord for F {
+    fn cmp(&self, other: &Self) -> Ordering {
+        todo!();
+    }
+}
+
+impl PartialOrd for F {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl PartialEq<u32> for F {
+    fn eq(&self, other: &u32) -> bool {
+        todo!();
+    }
+}
+
+impl PartialOrd<u32> for F {
+    fn partial_cmp(&self, other: &u32) -> Option<Ordering> {
+        todo!();
+    }
+}
+
+// #11178, do not lint
+
+#[derive(Eq, PartialEq)]
+struct G(u32);
+
+impl Ord for G {
+    fn cmp(&self, other: &Self) -> Ordering {
+        todo!();
+    }
+}
+
+impl PartialOrd for G {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(Self::cmp(self, other))
+    }
+}
+
+#[derive(Eq, PartialEq)]
+struct H(u32);
+
+impl Ord for H {
+    fn cmp(&self, other: &Self) -> Ordering {
+        todo!();
+    }
+}
+
+impl PartialOrd for H {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(Ord::cmp(self, other))
+    }
+}
diff --git a/tests/ui/non_canonical_partial_ord_impl.stderr b/tests/ui/non_canonical_partial_ord_impl.stderr
new file mode 100644
index 00000000000..05cc717b9ba
--- /dev/null
+++ b/tests/ui/non_canonical_partial_ord_impl.stderr
@@ -0,0 +1,32 @@
+error: non-canonical implementation of `partial_cmp` on an `Ord` type
+  --> $DIR/non_canonical_partial_ord_impl.rs:16:1
+   |
+LL | /  impl PartialOrd for A {
+LL | |      fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+   | | _____________________________________________________________-
+LL | ||         todo!();
+LL | ||     }
+   | ||_____- help: change this to: `{ Some(self.cmp(other)) }`
+LL | |  }
+   | |__^
+   |
+   = note: `-D clippy::non-canonical-partial-ord-impl` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::non_canonical_partial_ord_impl)]`
+
+error: non-canonical implementation of `partial_cmp` on an `Ord` type
+  --> $DIR/non_canonical_partial_ord_impl.rs:50:1
+   |
+LL | / impl PartialOrd for C {
+LL | |     fn partial_cmp(&self, _: &Self) -> Option<Ordering> {
+LL | |         todo!();
+LL | |     }
+LL | | }
+   | |_^
+   |
+help: change this to
+   |
+LL |     fn partial_cmp(&self, other: &Self) -> Option<Ordering> { Some(self.cmp(other)) }
+   |                           ~~~~~                             ~~~~~~~~~~~~~~~~~~~~~~~~~
+
+error: aborting due to 2 previous errors
+
diff --git a/tests/ui/non_canonical_partial_ord_impl_fully_qual.rs b/tests/ui/non_canonical_partial_ord_impl_fully_qual.rs
new file mode 100644
index 00000000000..2f8d5cf30c7
--- /dev/null
+++ b/tests/ui/non_canonical_partial_ord_impl_fully_qual.rs
@@ -0,0 +1,51 @@
+// This test's filename is... a bit verbose. But it ensures we suggest the correct code when `Ord`
+// is not in scope.
+#![no_main]
+#![no_implicit_prelude]
+//@no-rustfix
+extern crate std;
+
+use std::cmp::{self, Eq, Ordering, PartialEq, PartialOrd};
+use std::option::Option::{self, Some};
+use std::todo;
+
+// lint
+
+#[derive(Eq, PartialEq)]
+struct A(u32);
+
+impl cmp::Ord for A {
+    fn cmp(&self, other: &Self) -> Ordering {
+        todo!();
+    }
+}
+
+impl PartialOrd for A {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        // NOTE: This suggestion is wrong, as `Ord` is not in scope. But this should be fine as it isn't
+        // automatically applied
+        todo!();
+    }
+}
+
+#[derive(Eq, PartialEq)]
+struct B(u32);
+
+impl B {
+    fn cmp(&self, other: &Self) -> Ordering {
+        todo!();
+    }
+}
+
+impl cmp::Ord for B {
+    fn cmp(&self, other: &Self) -> Ordering {
+        todo!();
+    }
+}
+
+impl PartialOrd for B {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        // This calls `B.cmp`, not `Ord::cmp`!
+        Some(self.cmp(other))
+    }
+}
diff --git a/tests/ui/non_canonical_partial_ord_impl_fully_qual.stderr b/tests/ui/non_canonical_partial_ord_impl_fully_qual.stderr
new file mode 100644
index 00000000000..4978d7a8739
--- /dev/null
+++ b/tests/ui/non_canonical_partial_ord_impl_fully_qual.stderr
@@ -0,0 +1,32 @@
+error: non-canonical implementation of `partial_cmp` on an `Ord` type
+  --> $DIR/non_canonical_partial_ord_impl_fully_qual.rs:23:1
+   |
+LL | /  impl PartialOrd for A {
+LL | |      fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+   | | _____________________________________________________________-
+LL | ||         // NOTE: This suggestion is wrong, as `Ord` is not in scope. But this should be fine as it isn't
+LL | ||         // automatically applied
+LL | ||         todo!();
+LL | ||     }
+   | ||_____- help: change this to: `{ Some(self.cmp(other)) }`
+LL | |  }
+   | |__^
+   |
+   = note: `-D clippy::non-canonical-partial-ord-impl` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::non_canonical_partial_ord_impl)]`
+
+error: non-canonical implementation of `partial_cmp` on an `Ord` type
+  --> $DIR/non_canonical_partial_ord_impl_fully_qual.rs:46:1
+   |
+LL | /  impl PartialOrd for B {
+LL | |      fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+   | | _____________________________________________________________-
+LL | ||         // This calls `B.cmp`, not `Ord::cmp`!
+LL | ||         Some(self.cmp(other))
+LL | ||     }
+   | ||_____- help: change this to: `{ Some(std::cmp::Ord::cmp(self, other)) }`
+LL | |  }
+   | |__^
+
+error: aborting due to 2 previous errors
+
diff --git a/tests/ui/rename.fixed b/tests/ui/rename.fixed
index 0fd68eb92b1..4df9be2c21d 100644
--- a/tests/ui/rename.fixed
+++ b/tests/ui/rename.fixed
@@ -14,6 +14,8 @@
 #![allow(clippy::mixed_read_write_in_expression)]
 #![allow(clippy::useless_conversion)]
 #![allow(clippy::match_result_ok)]
+#![allow(clippy::non_canonical_clone_impl)]
+#![allow(clippy::non_canonical_partial_ord_impl)]
 #![allow(clippy::arithmetic_side_effects)]
 #![allow(clippy::overly_complex_bool_expr)]
 #![allow(clippy::new_without_default)]
@@ -33,10 +35,10 @@
 #![allow(drop_bounds)]
 #![allow(dropping_copy_types)]
 #![allow(dropping_references)]
+#![allow(useless_ptr_null_checks)]
 #![allow(for_loops_over_fallibles)]
 #![allow(forgetting_copy_types)]
 #![allow(forgetting_references)]
-#![allow(useless_ptr_null_checks)]
 #![allow(array_into_iter)]
 #![allow(invalid_atomic_ordering)]
 #![allow(invalid_value)]
@@ -62,6 +64,8 @@
 #![warn(clippy::mixed_read_write_in_expression)]
 #![warn(clippy::useless_conversion)]
 #![warn(clippy::match_result_ok)]
+#![warn(clippy::non_canonical_clone_impl)]
+#![warn(clippy::non_canonical_partial_ord_impl)]
 #![warn(clippy::arithmetic_side_effects)]
 #![warn(clippy::overly_complex_bool_expr)]
 #![warn(clippy::new_without_default)]
@@ -85,12 +89,12 @@
 #![warn(drop_bounds)]
 #![warn(dropping_copy_types)]
 #![warn(dropping_references)]
+#![warn(useless_ptr_null_checks)]
 #![warn(for_loops_over_fallibles)]
 #![warn(for_loops_over_fallibles)]
 #![warn(for_loops_over_fallibles)]
 #![warn(forgetting_copy_types)]
 #![warn(forgetting_references)]
-#![warn(useless_ptr_null_checks)]
 #![warn(array_into_iter)]
 #![warn(invalid_atomic_ordering)]
 #![warn(invalid_value)]
diff --git a/tests/ui/rename.rs b/tests/ui/rename.rs
index 927937fba83..940e60068e7 100644
--- a/tests/ui/rename.rs
+++ b/tests/ui/rename.rs
@@ -14,6 +14,8 @@
 #![allow(clippy::mixed_read_write_in_expression)]
 #![allow(clippy::useless_conversion)]
 #![allow(clippy::match_result_ok)]
+#![allow(clippy::non_canonical_clone_impl)]
+#![allow(clippy::non_canonical_partial_ord_impl)]
 #![allow(clippy::arithmetic_side_effects)]
 #![allow(clippy::overly_complex_bool_expr)]
 #![allow(clippy::new_without_default)]
@@ -33,10 +35,10 @@
 #![allow(drop_bounds)]
 #![allow(dropping_copy_types)]
 #![allow(dropping_references)]
+#![allow(useless_ptr_null_checks)]
 #![allow(for_loops_over_fallibles)]
 #![allow(forgetting_copy_types)]
 #![allow(forgetting_references)]
-#![allow(useless_ptr_null_checks)]
 #![allow(array_into_iter)]
 #![allow(invalid_atomic_ordering)]
 #![allow(invalid_value)]
@@ -62,6 +64,8 @@
 #![warn(clippy::eval_order_dependence)]
 #![warn(clippy::identity_conversion)]
 #![warn(clippy::if_let_some_result)]
+#![warn(clippy::incorrect_clone_impl_on_copy_type)]
+#![warn(clippy::incorrect_partial_ord_impl_on_ord_type)]
 #![warn(clippy::integer_arithmetic)]
 #![warn(clippy::logic_bug)]
 #![warn(clippy::new_without_default_derive)]
@@ -85,12 +89,12 @@
 #![warn(clippy::drop_bounds)]
 #![warn(clippy::drop_copy)]
 #![warn(clippy::drop_ref)]
+#![warn(clippy::fn_null_check)]
 #![warn(clippy::for_loop_over_option)]
 #![warn(clippy::for_loop_over_result)]
 #![warn(clippy::for_loops_over_fallibles)]
 #![warn(clippy::forget_copy)]
 #![warn(clippy::forget_ref)]
-#![warn(clippy::fn_null_check)]
 #![warn(clippy::into_iter_on_array)]
 #![warn(clippy::invalid_atomic_ordering)]
 #![warn(clippy::invalid_ref)]
diff --git a/tests/ui/rename.stderr b/tests/ui/rename.stderr
index d98fc7b30db..30824e154b8 100644
--- a/tests/ui/rename.stderr
+++ b/tests/ui/rename.stderr
@@ -1,5 +1,5 @@
 error: lint `clippy::almost_complete_letter_range` has been renamed to `clippy::almost_complete_range`
-  --> $DIR/rename.rs:52:9
+  --> $DIR/rename.rs:54:9
    |
 LL | #![warn(clippy::almost_complete_letter_range)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::almost_complete_range`
@@ -8,322 +8,334 @@ LL | #![warn(clippy::almost_complete_letter_range)]
    = help: to override `-D warnings` add `#[allow(renamed_and_removed_lints)]`
 
 error: lint `clippy::blacklisted_name` has been renamed to `clippy::disallowed_names`
-  --> $DIR/rename.rs:53:9
+  --> $DIR/rename.rs:55:9
    |
 LL | #![warn(clippy::blacklisted_name)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::disallowed_names`
 
 error: lint `clippy::block_in_if_condition_expr` has been renamed to `clippy::blocks_in_if_conditions`
-  --> $DIR/rename.rs:54:9
+  --> $DIR/rename.rs:56:9
    |
 LL | #![warn(clippy::block_in_if_condition_expr)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::blocks_in_if_conditions`
 
 error: lint `clippy::block_in_if_condition_stmt` has been renamed to `clippy::blocks_in_if_conditions`
-  --> $DIR/rename.rs:55:9
+  --> $DIR/rename.rs:57:9
    |
 LL | #![warn(clippy::block_in_if_condition_stmt)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::blocks_in_if_conditions`
 
 error: lint `clippy::box_vec` has been renamed to `clippy::box_collection`
-  --> $DIR/rename.rs:56:9
+  --> $DIR/rename.rs:58:9
    |
 LL | #![warn(clippy::box_vec)]
    |         ^^^^^^^^^^^^^^^ help: use the new name: `clippy::box_collection`
 
 error: lint `clippy::const_static_lifetime` has been renamed to `clippy::redundant_static_lifetimes`
-  --> $DIR/rename.rs:57:9
+  --> $DIR/rename.rs:59:9
    |
 LL | #![warn(clippy::const_static_lifetime)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::redundant_static_lifetimes`
 
 error: lint `clippy::cyclomatic_complexity` has been renamed to `clippy::cognitive_complexity`
-  --> $DIR/rename.rs:58:9
+  --> $DIR/rename.rs:60:9
    |
 LL | #![warn(clippy::cyclomatic_complexity)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::cognitive_complexity`
 
 error: lint `clippy::derive_hash_xor_eq` has been renamed to `clippy::derived_hash_with_manual_eq`
-  --> $DIR/rename.rs:59:9
+  --> $DIR/rename.rs:61:9
    |
 LL | #![warn(clippy::derive_hash_xor_eq)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::derived_hash_with_manual_eq`
 
 error: lint `clippy::disallowed_method` has been renamed to `clippy::disallowed_methods`
-  --> $DIR/rename.rs:60:9
+  --> $DIR/rename.rs:62:9
    |
 LL | #![warn(clippy::disallowed_method)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::disallowed_methods`
 
 error: lint `clippy::disallowed_type` has been renamed to `clippy::disallowed_types`
-  --> $DIR/rename.rs:61:9
+  --> $DIR/rename.rs:63:9
    |
 LL | #![warn(clippy::disallowed_type)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::disallowed_types`
 
 error: lint `clippy::eval_order_dependence` has been renamed to `clippy::mixed_read_write_in_expression`
-  --> $DIR/rename.rs:62:9
+  --> $DIR/rename.rs:64:9
    |
 LL | #![warn(clippy::eval_order_dependence)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::mixed_read_write_in_expression`
 
 error: lint `clippy::identity_conversion` has been renamed to `clippy::useless_conversion`
-  --> $DIR/rename.rs:63:9
+  --> $DIR/rename.rs:65:9
    |
 LL | #![warn(clippy::identity_conversion)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::useless_conversion`
 
 error: lint `clippy::if_let_some_result` has been renamed to `clippy::match_result_ok`
-  --> $DIR/rename.rs:64:9
+  --> $DIR/rename.rs:66:9
    |
 LL | #![warn(clippy::if_let_some_result)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::match_result_ok`
 
+error: lint `clippy::incorrect_clone_impl_on_copy_type` has been renamed to `clippy::non_canonical_clone_impl`
+  --> $DIR/rename.rs:67:9
+   |
+LL | #![warn(clippy::incorrect_clone_impl_on_copy_type)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::non_canonical_clone_impl`
+
+error: lint `clippy::incorrect_partial_ord_impl_on_ord_type` has been renamed to `clippy::non_canonical_partial_ord_impl`
+  --> $DIR/rename.rs:68:9
+   |
+LL | #![warn(clippy::incorrect_partial_ord_impl_on_ord_type)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::non_canonical_partial_ord_impl`
+
 error: lint `clippy::integer_arithmetic` has been renamed to `clippy::arithmetic_side_effects`
-  --> $DIR/rename.rs:65:9
+  --> $DIR/rename.rs:69:9
    |
 LL | #![warn(clippy::integer_arithmetic)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::arithmetic_side_effects`
 
 error: lint `clippy::logic_bug` has been renamed to `clippy::overly_complex_bool_expr`
-  --> $DIR/rename.rs:66:9
+  --> $DIR/rename.rs:70:9
    |
 LL | #![warn(clippy::logic_bug)]
    |         ^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::overly_complex_bool_expr`
 
 error: lint `clippy::new_without_default_derive` has been renamed to `clippy::new_without_default`
-  --> $DIR/rename.rs:67:9
+  --> $DIR/rename.rs:71:9
    |
 LL | #![warn(clippy::new_without_default_derive)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::new_without_default`
 
 error: lint `clippy::option_and_then_some` has been renamed to `clippy::bind_instead_of_map`
-  --> $DIR/rename.rs:68:9
+  --> $DIR/rename.rs:72:9
    |
 LL | #![warn(clippy::option_and_then_some)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::bind_instead_of_map`
 
 error: lint `clippy::option_expect_used` has been renamed to `clippy::expect_used`
-  --> $DIR/rename.rs:69:9
+  --> $DIR/rename.rs:73:9
    |
 LL | #![warn(clippy::option_expect_used)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::expect_used`
 
 error: lint `clippy::option_map_unwrap_or` has been renamed to `clippy::map_unwrap_or`
-  --> $DIR/rename.rs:70:9
+  --> $DIR/rename.rs:74:9
    |
 LL | #![warn(clippy::option_map_unwrap_or)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::map_unwrap_or`
 
 error: lint `clippy::option_map_unwrap_or_else` has been renamed to `clippy::map_unwrap_or`
-  --> $DIR/rename.rs:71:9
+  --> $DIR/rename.rs:75:9
    |
 LL | #![warn(clippy::option_map_unwrap_or_else)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::map_unwrap_or`
 
 error: lint `clippy::option_unwrap_used` has been renamed to `clippy::unwrap_used`
-  --> $DIR/rename.rs:72:9
+  --> $DIR/rename.rs:76:9
    |
 LL | #![warn(clippy::option_unwrap_used)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::unwrap_used`
 
 error: lint `clippy::ref_in_deref` has been renamed to `clippy::needless_borrow`
-  --> $DIR/rename.rs:73:9
+  --> $DIR/rename.rs:77:9
    |
 LL | #![warn(clippy::ref_in_deref)]
    |         ^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::needless_borrow`
 
 error: lint `clippy::result_expect_used` has been renamed to `clippy::expect_used`
-  --> $DIR/rename.rs:74:9
+  --> $DIR/rename.rs:78:9
    |
 LL | #![warn(clippy::result_expect_used)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::expect_used`
 
 error: lint `clippy::result_map_unwrap_or_else` has been renamed to `clippy::map_unwrap_or`
-  --> $DIR/rename.rs:75:9
+  --> $DIR/rename.rs:79:9
    |
 LL | #![warn(clippy::result_map_unwrap_or_else)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::map_unwrap_or`
 
 error: lint `clippy::result_unwrap_used` has been renamed to `clippy::unwrap_used`
-  --> $DIR/rename.rs:76:9
+  --> $DIR/rename.rs:80:9
    |
 LL | #![warn(clippy::result_unwrap_used)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::unwrap_used`
 
 error: lint `clippy::single_char_push_str` has been renamed to `clippy::single_char_add_str`
-  --> $DIR/rename.rs:77:9
+  --> $DIR/rename.rs:81:9
    |
 LL | #![warn(clippy::single_char_push_str)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::single_char_add_str`
 
 error: lint `clippy::stutter` has been renamed to `clippy::module_name_repetitions`
-  --> $DIR/rename.rs:78:9
+  --> $DIR/rename.rs:82:9
    |
 LL | #![warn(clippy::stutter)]
    |         ^^^^^^^^^^^^^^^ help: use the new name: `clippy::module_name_repetitions`
 
 error: lint `clippy::to_string_in_display` has been renamed to `clippy::recursive_format_impl`
-  --> $DIR/rename.rs:79:9
+  --> $DIR/rename.rs:83:9
    |
 LL | #![warn(clippy::to_string_in_display)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::recursive_format_impl`
 
 error: lint `clippy::unwrap_or_else_default` has been renamed to `clippy::unwrap_or_default`
-  --> $DIR/rename.rs:80:9
+  --> $DIR/rename.rs:84:9
    |
 LL | #![warn(clippy::unwrap_or_else_default)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::unwrap_or_default`
 
 error: lint `clippy::zero_width_space` has been renamed to `clippy::invisible_characters`
-  --> $DIR/rename.rs:81:9
+  --> $DIR/rename.rs:85:9
    |
 LL | #![warn(clippy::zero_width_space)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::invisible_characters`
 
 error: lint `clippy::cast_ref_to_mut` has been renamed to `invalid_reference_casting`
-  --> $DIR/rename.rs:82:9
+  --> $DIR/rename.rs:86:9
    |
 LL | #![warn(clippy::cast_ref_to_mut)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `invalid_reference_casting`
 
 error: lint `clippy::clone_double_ref` has been renamed to `suspicious_double_ref_op`
-  --> $DIR/rename.rs:83:9
+  --> $DIR/rename.rs:87:9
    |
 LL | #![warn(clippy::clone_double_ref)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `suspicious_double_ref_op`
 
 error: lint `clippy::cmp_nan` has been renamed to `invalid_nan_comparisons`
-  --> $DIR/rename.rs:84:9
+  --> $DIR/rename.rs:88:9
    |
 LL | #![warn(clippy::cmp_nan)]
    |         ^^^^^^^^^^^^^^^ help: use the new name: `invalid_nan_comparisons`
 
 error: lint `clippy::drop_bounds` has been renamed to `drop_bounds`
-  --> $DIR/rename.rs:85:9
+  --> $DIR/rename.rs:89:9
    |
 LL | #![warn(clippy::drop_bounds)]
    |         ^^^^^^^^^^^^^^^^^^^ help: use the new name: `drop_bounds`
 
 error: lint `clippy::drop_copy` has been renamed to `dropping_copy_types`
-  --> $DIR/rename.rs:86:9
+  --> $DIR/rename.rs:90:9
    |
 LL | #![warn(clippy::drop_copy)]
    |         ^^^^^^^^^^^^^^^^^ help: use the new name: `dropping_copy_types`
 
 error: lint `clippy::drop_ref` has been renamed to `dropping_references`
-  --> $DIR/rename.rs:87:9
+  --> $DIR/rename.rs:91:9
    |
 LL | #![warn(clippy::drop_ref)]
    |         ^^^^^^^^^^^^^^^^ help: use the new name: `dropping_references`
 
+error: lint `clippy::fn_null_check` has been renamed to `useless_ptr_null_checks`
+  --> $DIR/rename.rs:92:9
+   |
+LL | #![warn(clippy::fn_null_check)]
+   |         ^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `useless_ptr_null_checks`
+
 error: lint `clippy::for_loop_over_option` has been renamed to `for_loops_over_fallibles`
-  --> $DIR/rename.rs:88:9
+  --> $DIR/rename.rs:93:9
    |
 LL | #![warn(clippy::for_loop_over_option)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `for_loops_over_fallibles`
 
 error: lint `clippy::for_loop_over_result` has been renamed to `for_loops_over_fallibles`
-  --> $DIR/rename.rs:89:9
+  --> $DIR/rename.rs:94:9
    |
 LL | #![warn(clippy::for_loop_over_result)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `for_loops_over_fallibles`
 
 error: lint `clippy::for_loops_over_fallibles` has been renamed to `for_loops_over_fallibles`
-  --> $DIR/rename.rs:90:9
+  --> $DIR/rename.rs:95:9
    |
 LL | #![warn(clippy::for_loops_over_fallibles)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `for_loops_over_fallibles`
 
 error: lint `clippy::forget_copy` has been renamed to `forgetting_copy_types`
-  --> $DIR/rename.rs:91:9
+  --> $DIR/rename.rs:96:9
    |
 LL | #![warn(clippy::forget_copy)]
    |         ^^^^^^^^^^^^^^^^^^^ help: use the new name: `forgetting_copy_types`
 
 error: lint `clippy::forget_ref` has been renamed to `forgetting_references`
-  --> $DIR/rename.rs:92:9
+  --> $DIR/rename.rs:97:9
    |
 LL | #![warn(clippy::forget_ref)]
    |         ^^^^^^^^^^^^^^^^^^ help: use the new name: `forgetting_references`
 
-error: lint `clippy::fn_null_check` has been renamed to `useless_ptr_null_checks`
-  --> $DIR/rename.rs:93:9
-   |
-LL | #![warn(clippy::fn_null_check)]
-   |         ^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `useless_ptr_null_checks`
-
 error: lint `clippy::into_iter_on_array` has been renamed to `array_into_iter`
-  --> $DIR/rename.rs:94:9
+  --> $DIR/rename.rs:98:9
    |
 LL | #![warn(clippy::into_iter_on_array)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `array_into_iter`
 
 error: lint `clippy::invalid_atomic_ordering` has been renamed to `invalid_atomic_ordering`
-  --> $DIR/rename.rs:95:9
+  --> $DIR/rename.rs:99:9
    |
 LL | #![warn(clippy::invalid_atomic_ordering)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `invalid_atomic_ordering`
 
 error: lint `clippy::invalid_ref` has been renamed to `invalid_value`
-  --> $DIR/rename.rs:96:9
+  --> $DIR/rename.rs:100:9
    |
 LL | #![warn(clippy::invalid_ref)]
    |         ^^^^^^^^^^^^^^^^^^^ help: use the new name: `invalid_value`
 
 error: lint `clippy::invalid_utf8_in_unchecked` has been renamed to `invalid_from_utf8_unchecked`
-  --> $DIR/rename.rs:97:9
+  --> $DIR/rename.rs:101:9
    |
 LL | #![warn(clippy::invalid_utf8_in_unchecked)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `invalid_from_utf8_unchecked`
 
 error: lint `clippy::let_underscore_drop` has been renamed to `let_underscore_drop`
-  --> $DIR/rename.rs:98:9
+  --> $DIR/rename.rs:102:9
    |
 LL | #![warn(clippy::let_underscore_drop)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `let_underscore_drop`
 
 error: lint `clippy::mem_discriminant_non_enum` has been renamed to `enum_intrinsics_non_enums`
-  --> $DIR/rename.rs:99:9
+  --> $DIR/rename.rs:103:9
    |
 LL | #![warn(clippy::mem_discriminant_non_enum)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `enum_intrinsics_non_enums`
 
 error: lint `clippy::panic_params` has been renamed to `non_fmt_panics`
-  --> $DIR/rename.rs:100:9
+  --> $DIR/rename.rs:104:9
    |
 LL | #![warn(clippy::panic_params)]
    |         ^^^^^^^^^^^^^^^^^^^^ help: use the new name: `non_fmt_panics`
 
 error: lint `clippy::positional_named_format_parameters` has been renamed to `named_arguments_used_positionally`
-  --> $DIR/rename.rs:101:9
+  --> $DIR/rename.rs:105:9
    |
 LL | #![warn(clippy::positional_named_format_parameters)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `named_arguments_used_positionally`
 
 error: lint `clippy::temporary_cstring_as_ptr` has been renamed to `temporary_cstring_as_ptr`
-  --> $DIR/rename.rs:102:9
+  --> $DIR/rename.rs:106:9
    |
 LL | #![warn(clippy::temporary_cstring_as_ptr)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `temporary_cstring_as_ptr`
 
 error: lint `clippy::undropped_manually_drops` has been renamed to `undropped_manually_drops`
-  --> $DIR/rename.rs:103:9
+  --> $DIR/rename.rs:107:9
    |
 LL | #![warn(clippy::undropped_manually_drops)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `undropped_manually_drops`
 
 error: lint `clippy::unknown_clippy_lints` has been renamed to `unknown_lints`
-  --> $DIR/rename.rs:104:9
+  --> $DIR/rename.rs:108:9
    |
 LL | #![warn(clippy::unknown_clippy_lints)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `unknown_lints`
 
 error: lint `clippy::unused_label` has been renamed to `unused_labels`
-  --> $DIR/rename.rs:105:9
+  --> $DIR/rename.rs:109:9
    |
 LL | #![warn(clippy::unused_label)]
    |         ^^^^^^^^^^^^^^^^^^^^ help: use the new name: `unused_labels`
 
-error: aborting due to 54 previous errors
+error: aborting due to 56 previous errors
 
diff --git a/tests/ui/unnecessary_struct_initialization.fixed b/tests/ui/unnecessary_struct_initialization.fixed
index b5dedef5f4c..f3cf65da2d6 100644
--- a/tests/ui/unnecessary_struct_initialization.fixed
+++ b/tests/ui/unnecessary_struct_initialization.fixed
@@ -1,4 +1,4 @@
-#![allow(clippy::incorrect_clone_impl_on_copy_type, unused)]
+#![allow(clippy::non_canonical_clone_impl, unused)]
 #![warn(clippy::unnecessary_struct_initialization)]
 
 struct S {
diff --git a/tests/ui/unnecessary_struct_initialization.rs b/tests/ui/unnecessary_struct_initialization.rs
index 2222c3ddf37..bd5302f9d85 100644
--- a/tests/ui/unnecessary_struct_initialization.rs
+++ b/tests/ui/unnecessary_struct_initialization.rs
@@ -1,4 +1,4 @@
-#![allow(clippy::incorrect_clone_impl_on_copy_type, unused)]
+#![allow(clippy::non_canonical_clone_impl, unused)]
 #![warn(clippy::unnecessary_struct_initialization)]
 
 struct S {
-- 
cgit 1.4.1-3-g733a5


From c548d11041e074bf32e1938bd34625eb1acdfe1d Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Sun, 10 Sep 2023 18:15:18 +0200
Subject: Auto deref does not apply on union field

---
 clippy_lints/src/dereference.rs    |  7 +++++++
 tests/ui/explicit_auto_deref.fixed | 22 ++++++++++++++++++++++
 tests/ui/explicit_auto_deref.rs    | 22 ++++++++++++++++++++++
 3 files changed, 51 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index 1b23f01913f..8090f821d1f 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -1399,6 +1399,13 @@ fn report<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, state: State, data
                 return;
             }
 
+            if let ExprKind::Field(parent_expr, _) = expr.kind
+                && let ty::Adt(adt, _) = cx.typeck_results().expr_ty(parent_expr).kind()
+                && adt.is_union()
+            {
+                // Auto deref does not apply on union field
+                return;
+            }
             span_lint_hir_and_then(
                 cx,
                 EXPLICIT_AUTO_DEREF,
diff --git a/tests/ui/explicit_auto_deref.fixed b/tests/ui/explicit_auto_deref.fixed
index d046a926935..12158d0d12a 100644
--- a/tests/ui/explicit_auto_deref.fixed
+++ b/tests/ui/explicit_auto_deref.fixed
@@ -299,4 +299,26 @@ fn main() {
         Some(x) => x,
         None => panic!(),
     };
+
+    // Issue #11474
+    pub struct Variant {
+        pub anonymous: Variant0,
+    }
+
+    pub union Variant0 {
+        pub anonymous: std::mem::ManuallyDrop<Variant00>,
+    }
+
+    pub struct Variant00 {
+        pub anonymous: Variant000,
+    }
+
+    pub union Variant000 {
+        pub val: i32,
+    }
+
+    unsafe {
+        let mut p = core::mem::zeroed::<Variant>();
+        (*p.anonymous.anonymous).anonymous.val = 1;
+    }
 }
diff --git a/tests/ui/explicit_auto_deref.rs b/tests/ui/explicit_auto_deref.rs
index 3dd08e487f8..dec021c1834 100644
--- a/tests/ui/explicit_auto_deref.rs
+++ b/tests/ui/explicit_auto_deref.rs
@@ -299,4 +299,26 @@ fn main() {
         Some(x) => &mut *x,
         None => panic!(),
     };
+
+    // Issue #11474
+    pub struct Variant {
+        pub anonymous: Variant0,
+    }
+
+    pub union Variant0 {
+        pub anonymous: std::mem::ManuallyDrop<Variant00>,
+    }
+
+    pub struct Variant00 {
+        pub anonymous: Variant000,
+    }
+
+    pub union Variant000 {
+        pub val: i32,
+    }
+
+    unsafe {
+        let mut p = core::mem::zeroed::<Variant>();
+        (*p.anonymous.anonymous).anonymous.val = 1;
+    }
 }
-- 
cgit 1.4.1-3-g733a5


From f598bb75d47c45b69b3fe2952d53fcccf870e8b3 Mon Sep 17 00:00:00 2001
From: Michael Krasnitski <michael.krasnitski@gmail.com>
Date: Mon, 11 Sep 2023 21:43:27 -0400
Subject: Walk the left side of where bounds if the bounded type is not a
 generic parameter

---
 clippy_lints/src/extra_unused_type_parameters.rs |  7 ++++++-
 tests/ui/extra_unused_type_parameters.fixed      | 15 +++++++++++++++
 tests/ui/extra_unused_type_parameters.rs         | 15 +++++++++++++++
 3 files changed, 36 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/extra_unused_type_parameters.rs b/clippy_lints/src/extra_unused_type_parameters.rs
index c18006a71c2..0a885984abb 100644
--- a/clippy_lints/src/extra_unused_type_parameters.rs
+++ b/clippy_lints/src/extra_unused_type_parameters.rs
@@ -246,8 +246,13 @@ impl<'cx, 'tcx> Visitor<'tcx> for TypeWalker<'cx, 'tcx> {
                 {
                     self.ty_params.remove(&def_id);
                 }
+            } else {
+                // If the bounded type isn't a generic param, but is instead a concrete generic
+                // type, any params we find nested inside of it are being used as concrete types,
+                // and can therefore can be considered used. So, we're fine to walk the left-hand
+                // side of the where bound.
+                walk_ty(self, predicate.bounded_ty);
             }
-            // Only walk the right-hand side of where bounds
             for bound in predicate.bounds {
                 walk_param_bound(self, bound);
             }
diff --git a/tests/ui/extra_unused_type_parameters.fixed b/tests/ui/extra_unused_type_parameters.fixed
index a4943344a11..c9bebabdf17 100644
--- a/tests/ui/extra_unused_type_parameters.fixed
+++ b/tests/ui/extra_unused_type_parameters.fixed
@@ -113,4 +113,19 @@ with_span!(
     }
 );
 
+mod issue11302 {
+    use std::fmt::Debug;
+    use std::marker::PhantomData;
+
+    #[derive(Debug)]
+    struct Wrapper<T>(PhantomData<T>);
+
+    fn store<T: 'static>(v: &mut Vec<Box<dyn Debug>>)
+    where
+        Wrapper<T>: Debug,
+    {
+        v.push(Box::new(Wrapper(PhantomData)));
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/extra_unused_type_parameters.rs b/tests/ui/extra_unused_type_parameters.rs
index 6d85b1ce9d4..1bc0047adf0 100644
--- a/tests/ui/extra_unused_type_parameters.rs
+++ b/tests/ui/extra_unused_type_parameters.rs
@@ -113,4 +113,19 @@ with_span!(
     }
 );
 
+mod issue11302 {
+    use std::fmt::Debug;
+    use std::marker::PhantomData;
+
+    #[derive(Debug)]
+    struct Wrapper<T>(PhantomData<T>);
+
+    fn store<T: 'static>(v: &mut Vec<Box<dyn Debug>>)
+    where
+        Wrapper<T>: Debug,
+    {
+        v.push(Box::new(Wrapper(PhantomData)));
+    }
+}
+
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 22ba7925d6e7b08fe84ff315b95e2bffd058275f Mon Sep 17 00:00:00 2001
From: J-ZhengLi <lizheng135@huawei.com>
Date: Tue, 12 Sep 2023 17:18:39 +0800
Subject: Update clippy_lints/src/option_if_let_else.rs

Co-authored-by: Samuel Tardieu <sam@rfc1149.net>
---
 clippy_lints/src/option_if_let_else.rs | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/option_if_let_else.rs b/clippy_lints/src/option_if_let_else.rs
index 156b95d644a..f94dbb40be7 100644
--- a/clippy_lints/src/option_if_let_else.rs
+++ b/clippy_lints/src/option_if_let_else.rs
@@ -197,12 +197,10 @@ fn try_get_option_occurrence<'tcx>(
 
 /// Gets the call expr iff it does not have any args and was not from macro expansion.
 fn try_get_argless_call_expr<'tcx>(expr: &Expr<'tcx>) -> Option<&'tcx Expr<'tcx>> {
-    if !expr.span.from_expansion() &&
-        let ExprKind::Call(call_expr, []) = expr.kind
-    {
-        return Some(call_expr);
+    match expr.kind {
+        ExprKind::Call(call_expr, []) if !expr.span.from_expansion() => Some(call_expr),
+        _ => None,
     }
-    None
 }
 
 fn try_get_inner_pat_and_is_result<'tcx>(cx: &LateContext<'tcx>, pat: &Pat<'tcx>) -> Option<(&'tcx Pat<'tcx>, bool)> {
-- 
cgit 1.4.1-3-g733a5


From f136e1634a8d834d32deb89273717227eedaf153 Mon Sep 17 00:00:00 2001
From: jonboh <jon.bosque.hernando@gmail.com>
Date: Sat, 26 Aug 2023 16:26:09 +0200
Subject: new unnecessary_map_on_constructor lint

---
 CHANGELOG.md                                       |  1 +
 clippy_lints/src/declared_lints.rs                 |  1 +
 clippy_lints/src/lib.rs                            |  2 +
 clippy_lints/src/unnecessary_map_on_constructor.rs | 93 ++++++++++++++++++++++
 tests/ui/eta.fixed                                 |  3 +-
 tests/ui/eta.rs                                    |  3 +-
 tests/ui/eta.stderr                                | 54 ++++++-------
 tests/ui/manual_map_option.fixed                   |  1 +
 tests/ui/manual_map_option.rs                      |  1 +
 tests/ui/manual_map_option.stderr                  | 42 +++++-----
 tests/ui/option_filter_map.fixed                   |  2 +-
 tests/ui/option_filter_map.rs                      |  2 +-
 tests/ui/result_map_unit_fn_unfixable.rs           |  2 +-
 tests/ui/unnecessary_map_on_constructor.fixed      | 56 +++++++++++++
 tests/ui/unnecessary_map_on_constructor.rs         | 56 +++++++++++++
 tests/ui/unnecessary_map_on_constructor.stderr     | 53 ++++++++++++
 16 files changed, 319 insertions(+), 53 deletions(-)
 create mode 100644 clippy_lints/src/unnecessary_map_on_constructor.rs
 create mode 100644 tests/ui/unnecessary_map_on_constructor.fixed
 create mode 100644 tests/ui/unnecessary_map_on_constructor.rs
 create mode 100644 tests/ui/unnecessary_map_on_constructor.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index a7ae4a0ee2c..9aca13a6cf6 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5437,6 +5437,7 @@ Released 2018-09-13
 [`unnecessary_join`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_join
 [`unnecessary_lazy_evaluations`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_lazy_evaluations
 [`unnecessary_literal_unwrap`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_literal_unwrap
+[`unnecessary_map_on_constructor`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_map_on_constructor
 [`unnecessary_mut_passed`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_mut_passed
 [`unnecessary_operation`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_operation
 [`unnecessary_owned_empty_strings`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_owned_empty_strings
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index a4d40df52e7..ecf44e05920 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -671,6 +671,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::unnamed_address::FN_ADDRESS_COMPARISONS_INFO,
     crate::unnamed_address::VTABLE_ADDRESS_COMPARISONS_INFO,
     crate::unnecessary_box_returns::UNNECESSARY_BOX_RETURNS_INFO,
+    crate::unnecessary_map_on_constructor::UNNECESSARY_MAP_ON_CONSTRUCTOR_INFO,
     crate::unnecessary_owned_empty_strings::UNNECESSARY_OWNED_EMPTY_STRINGS_INFO,
     crate::unnecessary_self_imports::UNNECESSARY_SELF_IMPORTS_INFO,
     crate::unnecessary_struct_initialization::UNNECESSARY_STRUCT_INITIALIZATION_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 440940a4478..f5035dcfeeb 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -329,6 +329,7 @@ mod unit_return_expecting_ord;
 mod unit_types;
 mod unnamed_address;
 mod unnecessary_box_returns;
+mod unnecessary_map_on_constructor;
 mod unnecessary_owned_empty_strings;
 mod unnecessary_self_imports;
 mod unnecessary_struct_initialization;
@@ -1102,6 +1103,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::<reserve_after_initialization::ReserveAfterInitialization>::default());
     store.register_late_pass(|_| Box::new(implied_bounds_in_impls::ImpliedBoundsInImpls));
     store.register_late_pass(|_| Box::new(missing_asserts_for_indexing::MissingAssertsForIndexing));
+    store.register_late_pass(|_| Box::new(unnecessary_map_on_constructor::UnnecessaryMapOnConstructor));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/unnecessary_map_on_constructor.rs b/clippy_lints/src/unnecessary_map_on_constructor.rs
new file mode 100644
index 00000000000..5aa057580e9
--- /dev/null
+++ b/clippy_lints/src/unnecessary_map_on_constructor.rs
@@ -0,0 +1,93 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::ty::get_type_diagnostic_name;
+use rustc_errors::Applicability;
+use rustc_hir as hir;
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::sym;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Suggest removing the use of a may (or map_err) method when an Option or Result is being construted.
+    ///
+    /// ### Why is this bad?
+    /// It introduces unnecessary complexity. In this case the function can be used directly and
+    /// construct the Option or Result from the output.
+    ///
+    /// ### Example
+    /// ```rust
+    /// Some(4).map(i32::swap_bytes);
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// Some(i32::swap_bytes(4));
+    /// ```
+    #[clippy::version = "1.73.0"]
+    pub UNNECESSARY_MAP_ON_CONSTRUCTOR,
+    complexity,
+    "using `map`/`map_err` on `Option` or `Result` constructors"
+}
+declare_lint_pass!(UnnecessaryMapOnConstructor => [UNNECESSARY_MAP_ON_CONSTRUCTOR]);
+
+impl<'tcx> LateLintPass<'tcx> for UnnecessaryMapOnConstructor {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx rustc_hir::Expr<'tcx>) {
+        if expr.span.from_expansion() {
+            return;
+        }
+        if let hir::ExprKind::MethodCall(path, recv, args, ..) = expr.kind
+            && let Some(sym::Option | sym::Result) = get_type_diagnostic_name(cx, cx.typeck_results().expr_ty(recv)){
+            let (constructor_path, constructor_item) =
+                if let hir::ExprKind::Call(constructor, constructor_args) = recv.kind
+                    && let hir::ExprKind::Path(constructor_path) = constructor.kind
+                    && let Some(arg) = constructor_args.get(0)
+                {
+                    if constructor.span.from_expansion() || arg.span.from_expansion() {
+                        return;
+                    }
+                    (constructor_path, arg)
+                } else {
+                    return;
+                };
+            let constructor_symbol = match constructor_path {
+                hir::QPath::Resolved(_, path) => {
+                    if let Some(path_segment) = path.segments.last() {
+                        path_segment.ident.name
+                    } else {
+                        return;
+                    }
+                },
+                hir::QPath::TypeRelative(_, path) => path.ident.name,
+                hir::QPath::LangItem(_, _, _) => return,
+            };
+            match constructor_symbol {
+                sym::Some | sym::Ok if path.ident.name == rustc_span::sym::map => (),
+                sym::Err if path.ident.name == sym!(map_err) => (),
+                _ => return,
+            }
+
+            if let Some(map_arg) = args.get(0)
+                && let hir::ExprKind::Path(fun) = map_arg.kind
+            {
+                if map_arg.span.from_expansion() {
+                    return;
+                }
+                let mut applicability = Applicability::MachineApplicable;
+                let fun_snippet = snippet_with_applicability(cx, fun.span(), "_", &mut applicability);
+                let constructor_snippet =
+                    snippet_with_applicability(cx, constructor_path.span(), "_", &mut applicability);
+                let constructor_arg_snippet =
+                    snippet_with_applicability(cx, constructor_item.span, "_", &mut applicability);
+                span_lint_and_sugg(
+                    cx,
+                    UNNECESSARY_MAP_ON_CONSTRUCTOR,
+                    expr.span,
+                    &format!("unnecessary {} on constructor {constructor_snippet}(_)", path.ident.name),
+                    "try",
+                    format!("{constructor_snippet}({fun_snippet}({constructor_arg_snippet}))"),
+                    applicability,
+                );
+            }
+        }
+    }
+}
diff --git a/tests/ui/eta.fixed b/tests/ui/eta.fixed
index f1cac8c5fbc..32c7499bf73 100644
--- a/tests/ui/eta.fixed
+++ b/tests/ui/eta.fixed
@@ -7,7 +7,8 @@
     clippy::option_map_unit_fn,
     clippy::redundant_closure_call,
     clippy::uninlined_format_args,
-    clippy::useless_vec
+    clippy::useless_vec,
+    clippy::unnecessary_map_on_constructor
 )]
 
 use std::path::{Path, PathBuf};
diff --git a/tests/ui/eta.rs b/tests/ui/eta.rs
index c7a470b5be6..25b7431ba8c 100644
--- a/tests/ui/eta.rs
+++ b/tests/ui/eta.rs
@@ -7,7 +7,8 @@
     clippy::option_map_unit_fn,
     clippy::redundant_closure_call,
     clippy::uninlined_format_args,
-    clippy::useless_vec
+    clippy::useless_vec,
+    clippy::unnecessary_map_on_constructor
 )]
 
 use std::path::{Path, PathBuf};
diff --git a/tests/ui/eta.stderr b/tests/ui/eta.stderr
index 7c7f1797462..951e4ac749c 100644
--- a/tests/ui/eta.stderr
+++ b/tests/ui/eta.stderr
@@ -1,5 +1,5 @@
 error: redundant closure
-  --> $DIR/eta.rs:28:27
+  --> $DIR/eta.rs:29:27
    |
 LL |     let a = Some(1u8).map(|a| foo(a));
    |                           ^^^^^^^^^^ help: replace the closure with the function itself: `foo`
@@ -8,31 +8,31 @@ LL |     let a = Some(1u8).map(|a| foo(a));
    = help: to override `-D warnings` add `#[allow(clippy::redundant_closure)]`
 
 error: redundant closure
-  --> $DIR/eta.rs:32:40
+  --> $DIR/eta.rs:33:40
    |
 LL |     let _: Option<Vec<u8>> = true.then(|| vec![]); // special case vec!
    |                                        ^^^^^^^^^ help: replace the closure with `Vec::new`: `std::vec::Vec::new`
 
 error: redundant closure
-  --> $DIR/eta.rs:33:35
+  --> $DIR/eta.rs:34:35
    |
 LL |     let d = Some(1u8).map(|a| foo((|b| foo2(b))(a))); //is adjusted?
    |                                   ^^^^^^^^^^^^^ help: replace the closure with the function itself: `foo2`
 
 error: redundant closure
-  --> $DIR/eta.rs:34:26
+  --> $DIR/eta.rs:35:26
    |
 LL |     all(&[1, 2, 3], &&2, |x, y| below(x, y)); //is adjusted
    |                          ^^^^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `below`
 
 error: redundant closure
-  --> $DIR/eta.rs:41:27
+  --> $DIR/eta.rs:42:27
    |
 LL |     let e = Some(1u8).map(|a| generic(a));
    |                           ^^^^^^^^^^^^^^ help: replace the closure with the function itself: `generic`
 
 error: redundant closure
-  --> $DIR/eta.rs:93:51
+  --> $DIR/eta.rs:94:51
    |
 LL |     let e = Some(TestStruct { some_ref: &i }).map(|a| a.foo());
    |                                                   ^^^^^^^^^^^ help: replace the closure with the method itself: `TestStruct::foo`
@@ -41,127 +41,127 @@ LL |     let e = Some(TestStruct { some_ref: &i }).map(|a| a.foo());
    = help: to override `-D warnings` add `#[allow(clippy::redundant_closure_for_method_calls)]`
 
 error: redundant closure
-  --> $DIR/eta.rs:94:51
+  --> $DIR/eta.rs:95:51
    |
 LL |     let e = Some(TestStruct { some_ref: &i }).map(|a| a.trait_foo());
    |                                                   ^^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `TestTrait::trait_foo`
 
 error: redundant closure
-  --> $DIR/eta.rs:96:42
+  --> $DIR/eta.rs:97:42
    |
 LL |     let e = Some(&mut vec![1, 2, 3]).map(|v| v.clear());
    |                                          ^^^^^^^^^^^^^ help: replace the closure with the method itself: `std::vec::Vec::clear`
 
 error: redundant closure
-  --> $DIR/eta.rs:100:29
+  --> $DIR/eta.rs:101:29
    |
 LL |     let e = Some("str").map(|s| s.to_string());
    |                             ^^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `std::string::ToString::to_string`
 
 error: redundant closure
-  --> $DIR/eta.rs:101:27
+  --> $DIR/eta.rs:102:27
    |
 LL |     let e = Some('a').map(|s| s.to_uppercase());
    |                           ^^^^^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `char::to_uppercase`
 
 error: redundant closure
-  --> $DIR/eta.rs:103:65
+  --> $DIR/eta.rs:104:65
    |
 LL |     let e: std::vec::Vec<char> = vec!['a', 'b', 'c'].iter().map(|c| c.to_ascii_uppercase()).collect();
    |                                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `char::to_ascii_uppercase`
 
 error: redundant closure
-  --> $DIR/eta.rs:166:22
+  --> $DIR/eta.rs:167:22
    |
 LL |     requires_fn_once(|| x());
    |                      ^^^^^^ help: replace the closure with the function itself: `x`
 
 error: redundant closure
-  --> $DIR/eta.rs:173:27
+  --> $DIR/eta.rs:174:27
    |
 LL |     let a = Some(1u8).map(|a| foo_ptr(a));
    |                           ^^^^^^^^^^^^^^ help: replace the closure with the function itself: `foo_ptr`
 
 error: redundant closure
-  --> $DIR/eta.rs:178:27
+  --> $DIR/eta.rs:179:27
    |
 LL |     let a = Some(1u8).map(|a| closure(a));
    |                           ^^^^^^^^^^^^^^ help: replace the closure with the function itself: `closure`
 
 error: redundant closure
-  --> $DIR/eta.rs:210:28
+  --> $DIR/eta.rs:211:28
    |
 LL |     x.into_iter().for_each(|x| add_to_res(x));
    |                            ^^^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `&mut add_to_res`
 
 error: redundant closure
-  --> $DIR/eta.rs:211:28
+  --> $DIR/eta.rs:212:28
    |
 LL |     y.into_iter().for_each(|x| add_to_res(x));
    |                            ^^^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `&mut add_to_res`
 
 error: redundant closure
-  --> $DIR/eta.rs:212:28
+  --> $DIR/eta.rs:213:28
    |
 LL |     z.into_iter().for_each(|x| add_to_res(x));
    |                            ^^^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `add_to_res`
 
 error: redundant closure
-  --> $DIR/eta.rs:219:21
+  --> $DIR/eta.rs:220:21
    |
 LL |         Some(1).map(|n| closure(n));
    |                     ^^^^^^^^^^^^^^ help: replace the closure with the function itself: `&mut closure`
 
 error: redundant closure
-  --> $DIR/eta.rs:223:21
+  --> $DIR/eta.rs:224:21
    |
 LL |         Some(1).map(|n| in_loop(n));
    |                     ^^^^^^^^^^^^^^ help: replace the closure with the function itself: `in_loop`
 
 error: redundant closure
-  --> $DIR/eta.rs:316:18
+  --> $DIR/eta.rs:317:18
    |
 LL |     takes_fn_mut(|| f());
    |                  ^^^^^^ help: replace the closure with the function itself: `&mut f`
 
 error: redundant closure
-  --> $DIR/eta.rs:319:19
+  --> $DIR/eta.rs:320:19
    |
 LL |     takes_fn_once(|| f());
    |                   ^^^^^^ help: replace the closure with the function itself: `&mut f`
 
 error: redundant closure
-  --> $DIR/eta.rs:323:26
+  --> $DIR/eta.rs:324:26
    |
 LL |     move || takes_fn_mut(|| f_used_once())
    |                          ^^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `&mut f_used_once`
 
 error: redundant closure
-  --> $DIR/eta.rs:335:19
+  --> $DIR/eta.rs:336:19
    |
 LL |     array_opt.map(|a| a.as_slice());
    |                   ^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `<[u8; 3]>::as_slice`
 
 error: redundant closure
-  --> $DIR/eta.rs:338:19
+  --> $DIR/eta.rs:339:19
    |
 LL |     slice_opt.map(|s| s.len());
    |                   ^^^^^^^^^^^ help: replace the closure with the method itself: `<[u8]>::len`
 
 error: redundant closure
-  --> $DIR/eta.rs:341:17
+  --> $DIR/eta.rs:342:17
    |
 LL |     ptr_opt.map(|p| p.is_null());
    |                 ^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `<*const usize>::is_null`
 
 error: redundant closure
-  --> $DIR/eta.rs:345:17
+  --> $DIR/eta.rs:346:17
    |
 LL |     dyn_opt.map(|d| d.method_on_dyn());
    |                 ^^^^^^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `<dyn TestTrait>::method_on_dyn`
 
 error: redundant closure
-  --> $DIR/eta.rs:388:19
+  --> $DIR/eta.rs:389:19
    |
 LL |     let _ = f(&0, |x, y| f2(x, y));
    |                   ^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `f2`
diff --git a/tests/ui/manual_map_option.fixed b/tests/ui/manual_map_option.fixed
index f6a964da418..16cee3fd382 100644
--- a/tests/ui/manual_map_option.fixed
+++ b/tests/ui/manual_map_option.fixed
@@ -5,6 +5,7 @@
     clippy::unit_arg,
     clippy::match_ref_pats,
     clippy::redundant_pattern_matching,
+    clippy::unnecessary_map_on_constructor,
     for_loops_over_fallibles,
     dead_code
 )]
diff --git a/tests/ui/manual_map_option.rs b/tests/ui/manual_map_option.rs
index df9dc256d30..4655acf1406 100644
--- a/tests/ui/manual_map_option.rs
+++ b/tests/ui/manual_map_option.rs
@@ -5,6 +5,7 @@
     clippy::unit_arg,
     clippy::match_ref_pats,
     clippy::redundant_pattern_matching,
+    clippy::unnecessary_map_on_constructor,
     for_loops_over_fallibles,
     dead_code
 )]
diff --git a/tests/ui/manual_map_option.stderr b/tests/ui/manual_map_option.stderr
index ff6ed974d4a..3754a982cb9 100644
--- a/tests/ui/manual_map_option.stderr
+++ b/tests/ui/manual_map_option.stderr
@@ -1,5 +1,5 @@
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:13:5
+  --> $DIR/manual_map_option.rs:14:5
    |
 LL | /     match Some(0) {
 LL | |         Some(_) => Some(2),
@@ -11,7 +11,7 @@ LL | |     };
    = help: to override `-D warnings` add `#[allow(clippy::manual_map)]`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:18:5
+  --> $DIR/manual_map_option.rs:19:5
    |
 LL | /     match Some(0) {
 LL | |         Some(x) => Some(x + 1),
@@ -20,7 +20,7 @@ LL | |     };
    | |_____^ help: try: `Some(0).map(|x| x + 1)`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:23:5
+  --> $DIR/manual_map_option.rs:24:5
    |
 LL | /     match Some("") {
 LL | |         Some(x) => Some(x.is_empty()),
@@ -29,7 +29,7 @@ LL | |     };
    | |_____^ help: try: `Some("").map(|x| x.is_empty())`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:28:5
+  --> $DIR/manual_map_option.rs:29:5
    |
 LL | /     if let Some(x) = Some(0) {
 LL | |         Some(!x)
@@ -39,7 +39,7 @@ LL | |     };
    | |_____^ help: try: `Some(0).map(|x| !x)`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:35:5
+  --> $DIR/manual_map_option.rs:36:5
    |
 LL | /     match Some(0) {
 LL | |         Some(x) => { Some(std::convert::identity(x)) }
@@ -48,7 +48,7 @@ LL | |     };
    | |_____^ help: try: `Some(0).map(std::convert::identity)`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:40:5
+  --> $DIR/manual_map_option.rs:41:5
    |
 LL | /     match Some(&String::new()) {
 LL | |         Some(x) => Some(str::len(x)),
@@ -57,7 +57,7 @@ LL | |     };
    | |_____^ help: try: `Some(&String::new()).map(|x| str::len(x))`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:50:5
+  --> $DIR/manual_map_option.rs:51:5
    |
 LL | /     match &Some([0, 1]) {
 LL | |         Some(x) => Some(x[0]),
@@ -66,7 +66,7 @@ LL | |     };
    | |_____^ help: try: `Some([0, 1]).as_ref().map(|x| x[0])`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:55:5
+  --> $DIR/manual_map_option.rs:56:5
    |
 LL | /     match &Some(0) {
 LL | |         &Some(x) => Some(x * 2),
@@ -75,7 +75,7 @@ LL | |     };
    | |_____^ help: try: `Some(0).map(|x| x * 2)`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:60:5
+  --> $DIR/manual_map_option.rs:61:5
    |
 LL | /     match Some(String::new()) {
 LL | |         Some(ref x) => Some(x.is_empty()),
@@ -84,7 +84,7 @@ LL | |     };
    | |_____^ help: try: `Some(String::new()).as_ref().map(|x| x.is_empty())`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:65:5
+  --> $DIR/manual_map_option.rs:66:5
    |
 LL | /     match &&Some(String::new()) {
 LL | |         Some(x) => Some(x.len()),
@@ -93,7 +93,7 @@ LL | |     };
    | |_____^ help: try: `Some(String::new()).as_ref().map(|x| x.len())`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:70:5
+  --> $DIR/manual_map_option.rs:71:5
    |
 LL | /     match &&Some(0) {
 LL | |         &&Some(x) => Some(x + x),
@@ -102,7 +102,7 @@ LL | |     };
    | |_____^ help: try: `Some(0).map(|x| x + x)`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:83:9
+  --> $DIR/manual_map_option.rs:84:9
    |
 LL | /         match &mut Some(String::new()) {
 LL | |             Some(x) => Some(x.push_str("")),
@@ -111,7 +111,7 @@ LL | |         };
    | |_________^ help: try: `Some(String::new()).as_mut().map(|x| x.push_str(""))`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:89:5
+  --> $DIR/manual_map_option.rs:90:5
    |
 LL | /     match &mut Some(String::new()) {
 LL | |         Some(ref x) => Some(x.len()),
@@ -120,7 +120,7 @@ LL | |     };
    | |_____^ help: try: `Some(String::new()).as_ref().map(|x| x.len())`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:94:5
+  --> $DIR/manual_map_option.rs:95:5
    |
 LL | /     match &mut &Some(String::new()) {
 LL | |         Some(x) => Some(x.is_empty()),
@@ -129,7 +129,7 @@ LL | |     };
    | |_____^ help: try: `Some(String::new()).as_ref().map(|x| x.is_empty())`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:99:5
+  --> $DIR/manual_map_option.rs:100:5
    |
 LL | /     match Some((0, 1, 2)) {
 LL | |         Some((x, y, z)) => Some(x + y + z),
@@ -138,7 +138,7 @@ LL | |     };
    | |_____^ help: try: `Some((0, 1, 2)).map(|(x, y, z)| x + y + z)`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:104:5
+  --> $DIR/manual_map_option.rs:105:5
    |
 LL | /     match Some([1, 2, 3]) {
 LL | |         Some([first, ..]) => Some(first),
@@ -147,7 +147,7 @@ LL | |     };
    | |_____^ help: try: `Some([1, 2, 3]).map(|[first, ..]| first)`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:109:5
+  --> $DIR/manual_map_option.rs:110:5
    |
 LL | /     match &Some((String::new(), "test")) {
 LL | |         Some((x, y)) => Some((y, x)),
@@ -156,7 +156,7 @@ LL | |     };
    | |_____^ help: try: `Some((String::new(), "test")).as_ref().map(|(x, y)| (y, x))`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:167:5
+  --> $DIR/manual_map_option.rs:168:5
    |
 LL | /     match Some(0) {
 LL | |         Some(x) => Some(vec![x]),
@@ -165,7 +165,7 @@ LL | |     };
    | |_____^ help: try: `Some(0).map(|x| vec![x])`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:172:5
+  --> $DIR/manual_map_option.rs:173:5
    |
 LL | /     match option_env!("") {
 LL | |         Some(x) => Some(String::from(x)),
@@ -174,7 +174,7 @@ LL | |     };
    | |_____^ help: try: `option_env!("").map(String::from)`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:192:12
+  --> $DIR/manual_map_option.rs:193:12
    |
 LL |       } else if let Some(x) = Some(0) {
    |  ____________^
@@ -185,7 +185,7 @@ LL | |     };
    | |_____^ help: try: `{ Some(0).map(|x| x + 1) }`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option.rs:200:12
+  --> $DIR/manual_map_option.rs:201:12
    |
 LL |       } else if let Some(x) = Some(0) {
    |  ____________^
diff --git a/tests/ui/option_filter_map.fixed b/tests/ui/option_filter_map.fixed
index d4c04ff907b..ee004c0e194 100644
--- a/tests/ui/option_filter_map.fixed
+++ b/tests/ui/option_filter_map.fixed
@@ -1,5 +1,5 @@
 #![warn(clippy::option_filter_map)]
-#![allow(clippy::map_flatten)]
+#![allow(clippy::map_flatten, clippy::unnecessary_map_on_constructor)]
 
 fn main() {
     let _ = Some(Some(1)).flatten();
diff --git a/tests/ui/option_filter_map.rs b/tests/ui/option_filter_map.rs
index 99fb4723cab..eae2fa176a8 100644
--- a/tests/ui/option_filter_map.rs
+++ b/tests/ui/option_filter_map.rs
@@ -1,5 +1,5 @@
 #![warn(clippy::option_filter_map)]
-#![allow(clippy::map_flatten)]
+#![allow(clippy::map_flatten, clippy::unnecessary_map_on_constructor)]
 
 fn main() {
     let _ = Some(Some(1)).filter(Option::is_some).map(Option::unwrap);
diff --git a/tests/ui/result_map_unit_fn_unfixable.rs b/tests/ui/result_map_unit_fn_unfixable.rs
index a4dfc8f293d..62798b6d3d6 100644
--- a/tests/ui/result_map_unit_fn_unfixable.rs
+++ b/tests/ui/result_map_unit_fn_unfixable.rs
@@ -1,6 +1,6 @@
 #![warn(clippy::result_map_unit_fn)]
 #![feature(never_type)]
-#![allow(unused)]
+#![allow(unused, clippy::unnecessary_map_on_constructor)]
 //@no-rustfix
 struct HasResult {
     field: Result<usize, usize>,
diff --git a/tests/ui/unnecessary_map_on_constructor.fixed b/tests/ui/unnecessary_map_on_constructor.fixed
new file mode 100644
index 00000000000..d0ba7ed749e
--- /dev/null
+++ b/tests/ui/unnecessary_map_on_constructor.fixed
@@ -0,0 +1,56 @@
+#![allow(unused)]
+#![warn(clippy::unnecessary_map_on_constructor)]
+
+use std::ffi::OsStr;
+
+fn fun(t: i32) -> i32 {
+    t
+}
+
+fn notfun(e: SimpleError) -> SimpleError {
+    e
+}
+macro_rules! expands_to_fun {
+    () => {
+        fun
+    };
+}
+
+#[derive(Copy, Clone)]
+struct SimpleError {}
+
+type SimpleResult = std::result::Result<i32, SimpleError>;
+
+fn main() {
+    let x: i32 = 4;
+
+    let err = SimpleError {};
+    let a = Some(x);
+    let b: SimpleResult = Ok(x);
+    let c: SimpleResult = Err(err);
+
+    let a = Some(fun(x));
+    let b: SimpleResult = Ok(fun(x));
+    let c: SimpleResult = Err(notfun(err));
+
+    let a = Option::Some(fun(x));
+    let b: SimpleResult = SimpleResult::Ok(fun(x));
+    let c: SimpleResult = SimpleResult::Err(notfun(err));
+    let b: std::result::Result<i32, SimpleError> = Ok(fun(x));
+    let c: std::result::Result<i32, SimpleError> = Err(notfun(err));
+
+    let a = Some(fun(x));
+    let b: SimpleResult = Ok(fun(x));
+    let c: SimpleResult = Err(notfun(err));
+
+    // Should not trigger warning
+    a.map(fun);
+    b.map(fun);
+    c.map_err(notfun);
+
+    b.map_err(notfun); // Ok(_).map_err
+    c.map(fun); // Err(_).map()
+
+    option_env!("PATH").map(OsStr::new);
+    Some(x).map(expands_to_fun!());
+}
diff --git a/tests/ui/unnecessary_map_on_constructor.rs b/tests/ui/unnecessary_map_on_constructor.rs
new file mode 100644
index 00000000000..e89e7aad4c4
--- /dev/null
+++ b/tests/ui/unnecessary_map_on_constructor.rs
@@ -0,0 +1,56 @@
+#![allow(unused)]
+#![warn(clippy::unnecessary_map_on_constructor)]
+
+use std::ffi::OsStr;
+
+fn fun(t: i32) -> i32 {
+    t
+}
+
+fn notfun(e: SimpleError) -> SimpleError {
+    e
+}
+macro_rules! expands_to_fun {
+    () => {
+        fun
+    };
+}
+
+#[derive(Copy, Clone)]
+struct SimpleError {}
+
+type SimpleResult = std::result::Result<i32, SimpleError>;
+
+fn main() {
+    let x: i32 = 4;
+
+    let err = SimpleError {};
+    let a = Some(x);
+    let b: SimpleResult = Ok(x);
+    let c: SimpleResult = Err(err);
+
+    let a = Some(x).map(fun);
+    let b: SimpleResult = Ok(x).map(fun);
+    let c: SimpleResult = Err(err).map_err(notfun);
+
+    let a = Option::Some(x).map(fun);
+    let b: SimpleResult = SimpleResult::Ok(x).map(fun);
+    let c: SimpleResult = SimpleResult::Err(err).map_err(notfun);
+    let b: std::result::Result<i32, SimpleError> = Ok(x).map(fun);
+    let c: std::result::Result<i32, SimpleError> = Err(err).map_err(notfun);
+
+    let a = Some(fun(x));
+    let b: SimpleResult = Ok(fun(x));
+    let c: SimpleResult = Err(notfun(err));
+
+    // Should not trigger warning
+    a.map(fun);
+    b.map(fun);
+    c.map_err(notfun);
+
+    b.map_err(notfun); // Ok(_).map_err
+    c.map(fun); // Err(_).map()
+
+    option_env!("PATH").map(OsStr::new);
+    Some(x).map(expands_to_fun!());
+}
diff --git a/tests/ui/unnecessary_map_on_constructor.stderr b/tests/ui/unnecessary_map_on_constructor.stderr
new file mode 100644
index 00000000000..d522b68d872
--- /dev/null
+++ b/tests/ui/unnecessary_map_on_constructor.stderr
@@ -0,0 +1,53 @@
+error: unnecessary map on constructor Some(_)
+  --> $DIR/unnecessary_map_on_constructor.rs:32:13
+   |
+LL |     let a = Some(x).map(fun);
+   |             ^^^^^^^^^^^^^^^^ help: try: `Some(fun(x))`
+   |
+   = note: `-D clippy::unnecessary-map-on-constructor` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::unnecessary_map_on_constructor)]`
+
+error: unnecessary map on constructor Ok(_)
+  --> $DIR/unnecessary_map_on_constructor.rs:33:27
+   |
+LL |     let b: SimpleResult = Ok(x).map(fun);
+   |                           ^^^^^^^^^^^^^^ help: try: `Ok(fun(x))`
+
+error: unnecessary map_err on constructor Err(_)
+  --> $DIR/unnecessary_map_on_constructor.rs:34:27
+   |
+LL |     let c: SimpleResult = Err(err).map_err(notfun);
+   |                           ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Err(notfun(err))`
+
+error: unnecessary map on constructor Option::Some(_)
+  --> $DIR/unnecessary_map_on_constructor.rs:36:13
+   |
+LL |     let a = Option::Some(x).map(fun);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Option::Some(fun(x))`
+
+error: unnecessary map on constructor SimpleResult::Ok(_)
+  --> $DIR/unnecessary_map_on_constructor.rs:37:27
+   |
+LL |     let b: SimpleResult = SimpleResult::Ok(x).map(fun);
+   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `SimpleResult::Ok(fun(x))`
+
+error: unnecessary map_err on constructor SimpleResult::Err(_)
+  --> $DIR/unnecessary_map_on_constructor.rs:38:27
+   |
+LL |     let c: SimpleResult = SimpleResult::Err(err).map_err(notfun);
+   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `SimpleResult::Err(notfun(err))`
+
+error: unnecessary map on constructor Ok(_)
+  --> $DIR/unnecessary_map_on_constructor.rs:39:52
+   |
+LL |     let b: std::result::Result<i32, SimpleError> = Ok(x).map(fun);
+   |                                                    ^^^^^^^^^^^^^^ help: try: `Ok(fun(x))`
+
+error: unnecessary map_err on constructor Err(_)
+  --> $DIR/unnecessary_map_on_constructor.rs:40:52
+   |
+LL |     let c: std::result::Result<i32, SimpleError> = Err(err).map_err(notfun);
+   |                                                    ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Err(notfun(err))`
+
+error: aborting due to 8 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 7f870201d3c46f40e6be34424ded337fe702fecb Mon Sep 17 00:00:00 2001
From: mojave2 <chenchen145@huawei.com>
Date: Wed, 13 Sep 2023 11:13:51 +0800
Subject: add `byref` checking for the guard's local

---
 clippy_lints/src/matches/redundant_guards.rs | 77 ++++++++++++++++++++--------
 tests/ui/redundant_guards.fixed              | 41 +++++++++++++++
 tests/ui/redundant_guards.rs                 | 41 +++++++++++++++
 tests/ui/redundant_guards.stderr             | 38 +++++++++++++-
 4 files changed, 176 insertions(+), 21 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/redundant_guards.rs b/clippy_lints/src/matches/redundant_guards.rs
index 29af4812351..1f61e4df30d 100644
--- a/clippy_lints/src/matches/redundant_guards.rs
+++ b/clippy_lints/src/matches/redundant_guards.rs
@@ -34,24 +34,45 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'tcx>]) {
                 ],
                 MatchSource::Normal,
             ) = if_expr.kind
+            && let Some((binding_span, is_field, is_byref)) = get_pat_binding(cx, scrutinee, outer_arm)
         {
+            if is_field && is_byref { return; }
+            let pat_span = if let PatKind::Ref(pat, _) = arm.pat.kind {
+                if is_byref { pat.span } else { continue; }
+            } else {
+                if is_byref { continue; }
+                arm.pat.span
+            };
+
             emit_redundant_guards(
                 cx,
                 outer_arm,
                 if_expr.span,
-                scrutinee,
-                arm.pat.span,
+                pat_span,
+                binding_span,
+                is_field,
                 arm.guard,
             );
         }
         // `Some(x) if let Some(2) = x`
-        else if let Guard::IfLet(let_expr) = guard {
+        else if let Guard::IfLet(let_expr) = guard
+            && let Some((binding_span, is_field, is_byref)) = get_pat_binding(cx, let_expr.init, outer_arm)
+        {
+            if is_field && is_byref { return; }
+            let pat_span = if let PatKind::Ref(pat, _) = let_expr.pat.kind {
+                if is_byref && !is_field { pat.span } else { continue; }
+            } else {
+                if is_byref { continue; }
+                let_expr.pat.span
+            };
+
             emit_redundant_guards(
                 cx,
                 outer_arm,
                 let_expr.span,
-                let_expr.init,
-                let_expr.pat.span,
+                pat_span,
+                binding_span,
+                is_field,
                 None,
             );
         }
@@ -67,31 +88,48 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'tcx>]) {
             //
             // This isn't necessary in the other two checks, as they must be a pattern already.
             && cx.typeck_results().expr_ty(local) == cx.typeck_results().expr_ty(pat)
+            && let Some((binding_span, is_field, is_byref)) = get_pat_binding(cx, local, outer_arm)
         {
+            if is_field && is_byref { return; }
+            let pat_span = if let ExprKind::AddrOf(rustc_ast::BorrowKind::Ref, _, expr) = pat.kind {
+                if is_byref { expr.span } else { continue; }
+            } else {
+                if is_byref { continue; }
+                pat.span
+            };
+
             emit_redundant_guards(
                 cx,
                 outer_arm,
                 if_expr.span,
-                local,
-                pat.span,
+                pat_span,
+                binding_span,
+                is_field,
                 None,
             );
         }
     }
 }
 
-fn get_pat_binding<'tcx>(cx: &LateContext<'tcx>, guard_expr: &Expr<'_>, outer_arm: &Arm<'tcx>) -> Option<(Span, bool)> {
+fn get_pat_binding<'tcx>(
+    cx: &LateContext<'tcx>,
+    guard_expr: &Expr<'_>,
+    outer_arm: &Arm<'tcx>,
+) -> Option<(Span, bool, bool)> {
     if let Some(local) = path_to_local(guard_expr) && !is_local_used(cx, outer_arm.body, local) {
         let mut span = None;
         let mut multiple_bindings = false;
+        let mut is_byref = false;
         // `each_binding` gives the `HirId` of the `Pat` itself, not the binding
         outer_arm.pat.walk(|pat| {
-            if let PatKind::Binding(_, hir_id, _, _) = pat.kind
+            if let PatKind::Binding(bind_annot, hir_id, _, _) = pat.kind
                 && hir_id == local
-                && span.replace(pat.span).is_some()
             {
-                multiple_bindings = true;
-                return false;
+                is_byref = matches!(bind_annot.0, rustc_ast::ByRef::Yes);
+                if span.replace(pat.span).is_some() {
+                    multiple_bindings = true;
+                    return false;
+                }
             }
 
             true
@@ -102,7 +140,8 @@ fn get_pat_binding<'tcx>(cx: &LateContext<'tcx>, guard_expr: &Expr<'_>, outer_ar
             return span.map(|span| {
                 (
                     span,
-                    !matches!(cx.tcx.hir().get_parent(local), Node::PatField(_)),
+                    matches!(cx.tcx.hir().get_parent(local), Node::PatField(_)),
+                    is_byref,
                 )
             });
         }
@@ -115,14 +154,12 @@ fn emit_redundant_guards<'tcx>(
     cx: &LateContext<'tcx>,
     outer_arm: &Arm<'tcx>,
     guard_span: Span,
-    local: &Expr<'_>,
     pat_span: Span,
+    binding_span: Span,
+    field_binding: bool,
     inner_guard: Option<Guard<'_>>,
 ) {
     let mut app = Applicability::MaybeIncorrect;
-    let Some((pat_binding, can_use_shorthand)) = get_pat_binding(cx, local, outer_arm) else {
-        return;
-    };
 
     span_lint_and_then(
         cx,
@@ -134,10 +171,10 @@ fn emit_redundant_guards<'tcx>(
             diag.multipart_suggestion_verbose(
                 "try",
                 vec![
-                    if can_use_shorthand {
-                        (pat_binding, binding_replacement.into_owned())
+                    if field_binding {
+                        (binding_span.shrink_to_hi(), format!(": {binding_replacement}"))
                     } else {
-                        (pat_binding.shrink_to_hi(), format!(": {binding_replacement}"))
+                        (binding_span, binding_replacement.into_owned())
                     },
                     (
                         guard_span.source_callsite().with_lo(outer_arm.pat.span.hi()),
diff --git a/tests/ui/redundant_guards.fixed b/tests/ui/redundant_guards.fixed
index 9a1ec3a4d36..6793b9c0f6d 100644
--- a/tests/ui/redundant_guards.fixed
+++ b/tests/ui/redundant_guards.fixed
@@ -143,3 +143,44 @@ fn g(opt_s: Option<S>) {
         _ => {},
     }
 }
+
+mod issue11465 {
+    enum A {
+        Foo([u8; 3]),
+    }
+
+    struct B {
+        b: String,
+        c: i32,
+    }
+
+    fn issue11465() {
+        let c = Some(1);
+        match c {
+            Some(1) => {},
+            Some(2) => {},
+            Some(3) => {},
+            _ => {},
+        };
+
+        let enum_a = A::Foo([98, 97, 114]);
+        match enum_a {
+            A::Foo(ref arr) if arr == b"foo" => {},
+            A::Foo(ref arr) if let b"bar" = arr => {},
+            A::Foo(ref arr) if matches!(arr, b"baz") => {},
+            _ => {},
+        };
+
+        let struct_b = B {
+            b: "bar".to_string(),
+            c: 42,
+        };
+        match struct_b {
+            B { ref b, .. } if b == "bar" => {},
+            B { ref c, .. } if c == &1 => {},
+            B { ref c, .. } if let &1 = c => {},
+            B { ref c, .. } if matches!(c, &1) => {},
+            _ => {},
+        }
+    }
+}
diff --git a/tests/ui/redundant_guards.rs b/tests/ui/redundant_guards.rs
index e2e0ee816c5..e63cd29e8af 100644
--- a/tests/ui/redundant_guards.rs
+++ b/tests/ui/redundant_guards.rs
@@ -143,3 +143,44 @@ fn g(opt_s: Option<S>) {
         _ => {},
     }
 }
+
+mod issue11465 {
+    enum A {
+        Foo([u8; 3]),
+    }
+
+    struct B {
+        b: String,
+        c: i32,
+    }
+
+    fn issue11465() {
+        let c = Some(1);
+        match c {
+            Some(ref x) if x == &1 => {},
+            Some(ref x) if let &2 = x => {},
+            Some(ref x) if matches!(x, &3) => {},
+            _ => {},
+        };
+
+        let enum_a = A::Foo([98, 97, 114]);
+        match enum_a {
+            A::Foo(ref arr) if arr == b"foo" => {},
+            A::Foo(ref arr) if let b"bar" = arr => {},
+            A::Foo(ref arr) if matches!(arr, b"baz") => {},
+            _ => {},
+        };
+
+        let struct_b = B {
+            b: "bar".to_string(),
+            c: 42,
+        };
+        match struct_b {
+            B { ref b, .. } if b == "bar" => {},
+            B { ref c, .. } if c == &1 => {},
+            B { ref c, .. } if let &1 = c => {},
+            B { ref c, .. } if matches!(c, &1) => {},
+            _ => {},
+        }
+    }
+}
diff --git a/tests/ui/redundant_guards.stderr b/tests/ui/redundant_guards.stderr
index 50077234382..54b5f2464e6 100644
--- a/tests/ui/redundant_guards.stderr
+++ b/tests/ui/redundant_guards.stderr
@@ -94,5 +94,41 @@ LL -         x if matches!(x, Some(0)) => ..,
 LL +         Some(0) => ..,
    |
 
-error: aborting due to 8 previous errors
+error: redundant guard
+  --> $DIR/redundant_guards.rs:160:28
+   |
+LL |             Some(ref x) if x == &1 => {},
+   |                            ^^^^^^^
+   |
+help: try
+   |
+LL -             Some(ref x) if x == &1 => {},
+LL +             Some(1) => {},
+   |
+
+error: redundant guard
+  --> $DIR/redundant_guards.rs:161:28
+   |
+LL |             Some(ref x) if let &2 = x => {},
+   |                            ^^^^^^^^^^
+   |
+help: try
+   |
+LL -             Some(ref x) if let &2 = x => {},
+LL +             Some(2) => {},
+   |
+
+error: redundant guard
+  --> $DIR/redundant_guards.rs:162:28
+   |
+LL |             Some(ref x) if matches!(x, &3) => {},
+   |                            ^^^^^^^^^^^^^^^
+   |
+help: try
+   |
+LL -             Some(ref x) if matches!(x, &3) => {},
+LL +             Some(3) => {},
+   |
+
+error: aborting due to 11 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From e3267b1fe7bf90348f76b42fba6ebd09ef8ef714 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Wed, 13 Sep 2023 14:39:41 +0200
Subject: Fix mutaby used async function argument in closure for
 `needless_pass_by_ref_mut`

---
 clippy_lints/src/needless_pass_by_ref_mut.rs | 85 +++++++++++++++++++++-------
 tests/ui/needless_pass_by_ref_mut.rs         | 28 ++++++++-
 tests/ui/needless_pass_by_ref_mut.stderr     | 26 ++++++++-
 3 files changed, 118 insertions(+), 21 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/needless_pass_by_ref_mut.rs b/clippy_lints/src/needless_pass_by_ref_mut.rs
index 7b00eabf97b..bea44ed92ef 100644
--- a/clippy_lints/src/needless_pass_by_ref_mut.rs
+++ b/clippy_lints/src/needless_pass_by_ref_mut.rs
@@ -4,12 +4,13 @@ use clippy_utils::source::snippet;
 use clippy_utils::{get_parent_node, inherits_cfg, is_from_proc_macro, is_self};
 use rustc_data_structures::fx::{FxHashSet, FxIndexMap};
 use rustc_errors::Applicability;
-use rustc_hir::intravisit::{walk_qpath, FnKind, Visitor};
+use rustc_hir::intravisit::{walk_fn, walk_qpath, FnKind, Visitor};
 use rustc_hir::{
-    Body, Closure, Expr, ExprKind, FnDecl, HirId, HirIdMap, HirIdSet, Impl, ItemKind, Mutability, Node, PatKind, QPath,
+    Body, BodyId, Closure, Expr, ExprKind, FnDecl, HirId, HirIdMap, HirIdSet, Impl, ItemKind, Mutability, Node,
+    PatKind, QPath,
 };
 use rustc_hir_typeck::expr_use_visitor as euv;
-use rustc_infer::infer::TyCtxtInferExt;
+use rustc_infer::infer::{InferCtxt, TyCtxtInferExt};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::map::associated_body;
 use rustc_middle::hir::nested_filter::OnlyBodies;
@@ -95,6 +96,30 @@ fn should_skip<'tcx>(
     is_from_proc_macro(cx, &input)
 }
 
+fn check_closures<'tcx>(
+    ctx: &mut MutablyUsedVariablesCtxt<'tcx>,
+    cx: &LateContext<'tcx>,
+    infcx: &InferCtxt<'tcx>,
+    checked_closures: &mut FxHashSet<LocalDefId>,
+    closures: FxHashSet<LocalDefId>,
+) {
+    let hir = cx.tcx.hir();
+    for closure in closures {
+        if !checked_closures.insert(closure) {
+            continue;
+        }
+        ctx.prev_bind = None;
+        ctx.prev_move_to_closure.clear();
+        if let Some(body) = hir
+            .find_by_def_id(closure)
+            .and_then(associated_body)
+            .map(|(_, body_id)| hir.body(body_id))
+        {
+            euv::ExprUseVisitor::new(ctx, infcx, closure, cx.param_env, cx.typeck_results()).consume_body(body);
+        }
+    }
+}
+
 impl<'tcx> LateLintPass<'tcx> for NeedlessPassByRefMut<'tcx> {
     fn check_fn(
         &mut self,
@@ -161,25 +186,20 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByRefMut<'tcx> {
             euv::ExprUseVisitor::new(&mut ctx, &infcx, fn_def_id, cx.param_env, cx.typeck_results()).consume_body(body);
             if is_async {
                 let mut checked_closures = FxHashSet::default();
+
+                // We retrieve all the closures declared in the async function because they will
+                // not be found by `euv::Delegate`.
+                let mut closures_retriever = ClosuresRetriever {
+                    cx,
+                    closures: FxHashSet::default(),
+                };
+                walk_fn(&mut closures_retriever, kind, decl, body.id(), fn_def_id);
+                check_closures(&mut ctx, cx, &infcx, &mut checked_closures, closures_retriever.closures);
+
                 while !ctx.async_closures.is_empty() {
                     let closures = ctx.async_closures.clone();
                     ctx.async_closures.clear();
-                    let hir = cx.tcx.hir();
-                    for closure in closures {
-                        if !checked_closures.insert(closure) {
-                            continue;
-                        }
-                        ctx.prev_bind = None;
-                        ctx.prev_move_to_closure.clear();
-                        if let Some(body) = hir
-                            .find_by_def_id(closure)
-                            .and_then(associated_body)
-                            .map(|(_, body_id)| hir.body(body_id))
-                        {
-                            euv::ExprUseVisitor::new(&mut ctx, &infcx, closure, cx.param_env, cx.typeck_results())
-                                .consume_body(body);
-                        }
-                    }
+                    check_closures(&mut ctx, cx, &infcx, &mut checked_closures, closures);
                 }
             }
             ctx
@@ -439,3 +459,30 @@ impl<'tcx> Visitor<'tcx> for FnNeedsMutVisitor<'_, 'tcx> {
         }
     }
 }
+
+struct ClosuresRetriever<'a, 'tcx> {
+    cx: &'a LateContext<'tcx>,
+    closures: FxHashSet<LocalDefId>,
+}
+
+impl<'a, 'tcx> Visitor<'tcx> for ClosuresRetriever<'a, 'tcx> {
+    type NestedFilter = OnlyBodies;
+
+    fn nested_visit_map(&mut self) -> Self::Map {
+        self.cx.tcx.hir()
+    }
+
+    fn visit_fn(
+        &mut self,
+        kind: FnKind<'tcx>,
+        decl: &'tcx FnDecl<'tcx>,
+        body_id: BodyId,
+        _span: Span,
+        fn_def_id: LocalDefId,
+    ) {
+        if matches!(kind, FnKind::Closure) {
+            self.closures.insert(fn_def_id);
+        }
+        walk_fn(self, kind, decl, body_id, fn_def_id);
+    }
+}
diff --git a/tests/ui/needless_pass_by_ref_mut.rs b/tests/ui/needless_pass_by_ref_mut.rs
index e1e5e8fd220..da2a72caacb 100644
--- a/tests/ui/needless_pass_by_ref_mut.rs
+++ b/tests/ui/needless_pass_by_ref_mut.rs
@@ -1,4 +1,4 @@
-#![allow(clippy::if_same_then_else, clippy::no_effect)]
+#![allow(clippy::if_same_then_else, clippy::no_effect, clippy::redundant_closure_call)]
 #![feature(lint_reasons)]
 //@no-rustfix
 use std::ptr::NonNull;
@@ -231,6 +231,32 @@ async fn async_vec2(b: &mut Vec<bool>) {
     b.push(true);
 }
 
+// Should not warn.
+pub async fn closure(n: &mut usize) -> impl '_ + FnMut() {
+    || {
+        *n += 1;
+    }
+}
+
+// Should warn.
+pub fn closure2(n: &mut usize) -> impl '_ + FnMut() -> usize {
+    //~^ ERROR: this argument is a mutable reference, but not used mutably
+    || *n + 1
+}
+
+// Should not warn.
+pub async fn closure3(n: &mut usize) {
+    (|| *n += 1)();
+}
+
+// Should warn.
+pub async fn closure4(n: &mut usize) {
+    //~^ ERROR: this argument is a mutable reference, but not used mutably
+    (|| {
+        let _x = *n + 1;
+    })();
+}
+
 fn main() {
     let mut u = 0;
     let mut v = vec![0];
diff --git a/tests/ui/needless_pass_by_ref_mut.stderr b/tests/ui/needless_pass_by_ref_mut.stderr
index df3df045776..0fb9458d794 100644
--- a/tests/ui/needless_pass_by_ref_mut.stderr
+++ b/tests/ui/needless_pass_by_ref_mut.stderr
@@ -107,5 +107,29 @@ error: this argument is a mutable reference, but not used mutably
 LL | async fn inner_async3(x: &mut i32, y: &mut u32) {
    |                          ^^^^^^^^ help: consider changing to: `&i32`
 
-error: aborting due to 17 previous errors
+error: this argument is a mutable reference, but not used mutably
+  --> $DIR/needless_pass_by_ref_mut.rs:235:25
+   |
+LL | pub async fn closure(n: &mut usize) -> impl '_ + FnMut() {
+   |                         ^^^^^^^^^^ help: consider changing to: `&usize`
+   |
+   = warning: changing this function will impact semver compatibility
+
+error: this argument is a mutable reference, but not used mutably
+  --> $DIR/needless_pass_by_ref_mut.rs:242:20
+   |
+LL | pub fn closure2(n: &mut usize) -> impl '_ + FnMut() -> usize {
+   |                    ^^^^^^^^^^ help: consider changing to: `&usize`
+   |
+   = warning: changing this function will impact semver compatibility
+
+error: this argument is a mutable reference, but not used mutably
+  --> $DIR/needless_pass_by_ref_mut.rs:253:26
+   |
+LL | pub async fn closure4(n: &mut usize) {
+   |                          ^^^^^^^^^^ help: consider changing to: `&usize`
+   |
+   = warning: changing this function will impact semver compatibility
+
+error: aborting due to 20 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From fb4f6035da41ada636bef3a7eed1ec4dae72c606 Mon Sep 17 00:00:00 2001
From: J-ZhengLi <lizheng135@huawei.com>
Date: Thu, 14 Sep 2023 10:17:27 +0800
Subject: Apply suggestions from code review

Co-authored-by: Samuel Tardieu <sam@rfc1149.net>
Co-authored-by: Catherine Flores <catherine.3.flores@gmail.com>
---
 clippy_lints/src/option_if_let_else.rs | 15 +++------------
 1 file changed, 3 insertions(+), 12 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/option_if_let_else.rs b/clippy_lints/src/option_if_let_else.rs
index f94dbb40be7..cfe40a829ed 100644
--- a/clippy_lints/src/option_if_let_else.rs
+++ b/clippy_lints/src/option_if_let_else.rs
@@ -166,10 +166,9 @@ fn try_get_option_occurrence<'tcx>(
 
             let mut app = Applicability::Unspecified;
 
-            let (none_body, is_argless_call) = if let Some(call_expr) = try_get_argless_call_expr(none_body) {
-                (call_expr, true)
-            } else {
-                (none_body, false)
+            let (none_body, is_argless_call) = match none_body.kind {
+                ExprKind::Call(call_expr, []) if !none_body.span.from_expansion() => (call_expr, true),
+                _ => (none_body, false),
             };
 
             return Some(OptionOccurrence {
@@ -195,14 +194,6 @@ fn try_get_option_occurrence<'tcx>(
     None
 }
 
-/// Gets the call expr iff it does not have any args and was not from macro expansion.
-fn try_get_argless_call_expr<'tcx>(expr: &Expr<'tcx>) -> Option<&'tcx Expr<'tcx>> {
-    match expr.kind {
-        ExprKind::Call(call_expr, []) if !expr.span.from_expansion() => Some(call_expr),
-        _ => None,
-    }
-}
-
 fn try_get_inner_pat_and_is_result<'tcx>(cx: &LateContext<'tcx>, pat: &Pat<'tcx>) -> Option<(&'tcx Pat<'tcx>, bool)> {
     if let PatKind::TupleStruct(ref qpath, [inner_pat], ..) = pat.kind {
         let res = cx.qpath_res(qpath, pat.hir_id);
-- 
cgit 1.4.1-3-g733a5


From 8d3bbb09640479b43b48a3c3a81580a1d3fbbc04 Mon Sep 17 00:00:00 2001
From: mojave2 <chenchen145@huawei.com>
Date: Thu, 14 Sep 2023 14:57:05 +0800
Subject: handle the byref binding in the struct pattern

---
 clippy_lints/src/matches/redundant_guards.rs | 99 ++++++++++++++--------------
 tests/ui/redundant_guards.fixed              |  6 +-
 tests/ui/redundant_guards.stderr             | 38 ++++++++++-
 3 files changed, 90 insertions(+), 53 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/redundant_guards.rs b/clippy_lints/src/matches/redundant_guards.rs
index 1f61e4df30d..d51d7edc8e3 100644
--- a/clippy_lints/src/matches/redundant_guards.rs
+++ b/clippy_lints/src/matches/redundant_guards.rs
@@ -2,11 +2,12 @@ use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::path_to_local;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::visitors::{for_each_expr, is_local_used};
-use rustc_ast::LitKind;
+use rustc_ast::{BorrowKind, LitKind};
 use rustc_errors::Applicability;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::{Arm, BinOpKind, Expr, ExprKind, Guard, MatchSource, Node, Pat, PatKind};
 use rustc_lint::LateContext;
+use rustc_span::symbol::Ident;
 use rustc_span::Span;
 use std::ops::ControlFlow;
 
@@ -34,45 +35,37 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'tcx>]) {
                 ],
                 MatchSource::Normal,
             ) = if_expr.kind
-            && let Some((binding_span, is_field, is_byref)) = get_pat_binding(cx, scrutinee, outer_arm)
+            && let Some(binding) = get_pat_binding(cx, scrutinee, outer_arm)
         {
-            if is_field && is_byref { return; }
-            let pat_span = if let PatKind::Ref(pat, _) = arm.pat.kind {
-                if is_byref { pat.span } else { continue; }
-            } else {
-                if is_byref { continue; }
-                arm.pat.span
+            let pat_span = match (arm.pat.kind, binding.byref_ident) {
+                (PatKind::Ref(pat, _), Some(_)) => pat.span,
+                (PatKind::Ref(..), None) | (_, Some(_)) => continue,
+                _ => arm.pat.span,
             };
-
             emit_redundant_guards(
                 cx,
                 outer_arm,
                 if_expr.span,
                 pat_span,
-                binding_span,
-                is_field,
+                &binding,
                 arm.guard,
             );
         }
         // `Some(x) if let Some(2) = x`
         else if let Guard::IfLet(let_expr) = guard
-            && let Some((binding_span, is_field, is_byref)) = get_pat_binding(cx, let_expr.init, outer_arm)
+            && let Some(binding) = get_pat_binding(cx, let_expr.init, outer_arm)
         {
-            if is_field && is_byref { return; }
-            let pat_span = if let PatKind::Ref(pat, _) = let_expr.pat.kind {
-                if is_byref && !is_field { pat.span } else { continue; }
-            } else {
-                if is_byref { continue; }
-                let_expr.pat.span
+            let pat_span = match (let_expr.pat.kind, binding.byref_ident) {
+                (PatKind::Ref(pat, _), Some(_)) => pat.span,
+                (PatKind::Ref(..), None) | (_, Some(_)) => continue,
+                _ => let_expr.pat.span,
             };
-
             emit_redundant_guards(
                 cx,
                 outer_arm,
                 let_expr.span,
                 pat_span,
-                binding_span,
-                is_field,
+                &binding,
                 None,
             );
         }
@@ -88,61 +81,63 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'tcx>]) {
             //
             // This isn't necessary in the other two checks, as they must be a pattern already.
             && cx.typeck_results().expr_ty(local) == cx.typeck_results().expr_ty(pat)
-            && let Some((binding_span, is_field, is_byref)) = get_pat_binding(cx, local, outer_arm)
+            && let Some(binding) = get_pat_binding(cx, local, outer_arm)
         {
-            if is_field && is_byref { return; }
-            let pat_span = if let ExprKind::AddrOf(rustc_ast::BorrowKind::Ref, _, expr) = pat.kind {
-                if is_byref { expr.span } else { continue; }
-            } else {
-                if is_byref { continue; }
-                pat.span
+            let pat_span = match (pat.kind, binding.byref_ident) {
+                (ExprKind::AddrOf(BorrowKind::Ref, _, expr), Some(_)) => expr.span,
+                (ExprKind::AddrOf(..), None) | (_, Some(_)) => continue,
+                _ => pat.span,
             };
-
             emit_redundant_guards(
                 cx,
                 outer_arm,
                 if_expr.span,
                 pat_span,
-                binding_span,
-                is_field,
+                &binding,
                 None,
             );
         }
     }
 }
 
+struct PatBindingInfo {
+    span: Span,
+    byref_ident: Option<Ident>,
+    is_field: bool,
+}
+
 fn get_pat_binding<'tcx>(
     cx: &LateContext<'tcx>,
     guard_expr: &Expr<'_>,
     outer_arm: &Arm<'tcx>,
-) -> Option<(Span, bool, bool)> {
+) -> Option<PatBindingInfo> {
     if let Some(local) = path_to_local(guard_expr) && !is_local_used(cx, outer_arm.body, local) {
         let mut span = None;
+        let mut byref_ident = None;
         let mut multiple_bindings = false;
-        let mut is_byref = false;
         // `each_binding` gives the `HirId` of the `Pat` itself, not the binding
         outer_arm.pat.walk(|pat| {
-            if let PatKind::Binding(bind_annot, hir_id, _, _) = pat.kind
+            if let PatKind::Binding(bind_annot, hir_id, ident, _) = pat.kind
                 && hir_id == local
             {
-                is_byref = matches!(bind_annot.0, rustc_ast::ByRef::Yes);
+                if matches!(bind_annot.0, rustc_ast::ByRef::Yes) {
+                    let _ = byref_ident.insert(ident);
+                }
+                // the second call of `replce()` returns a `Some(span)`, meaning a multi-binding pattern
                 if span.replace(pat.span).is_some() {
                     multiple_bindings = true;
                     return false;
                 }
             }
-
             true
         });
 
         // Ignore bindings from or patterns, like `First(x) | Second(x, _) | Third(x, _, _)`
         if !multiple_bindings {
-            return span.map(|span| {
-                (
-                    span,
-                    matches!(cx.tcx.hir().get_parent(local), Node::PatField(_)),
-                    is_byref,
-                )
+            return span.map(|span| PatBindingInfo {
+                span,
+                byref_ident,
+                is_field: matches!(cx.tcx.hir().get_parent(local), Node::PatField(_)),
             });
         }
     }
@@ -155,8 +150,7 @@ fn emit_redundant_guards<'tcx>(
     outer_arm: &Arm<'tcx>,
     guard_span: Span,
     pat_span: Span,
-    binding_span: Span,
-    field_binding: bool,
+    pat_binding: &PatBindingInfo,
     inner_guard: Option<Guard<'_>>,
 ) {
     let mut app = Applicability::MaybeIncorrect;
@@ -168,14 +162,21 @@ fn emit_redundant_guards<'tcx>(
         "redundant guard",
         |diag| {
             let binding_replacement = snippet_with_applicability(cx, pat_span, "<binding_repl>", &mut app);
+            let suggestion_span = match *pat_binding {
+                PatBindingInfo {
+                    span,
+                    byref_ident: Some(ident),
+                    is_field: true,
+                } => (span, format!("{ident}: {binding_replacement}")),
+                PatBindingInfo {
+                    span, is_field: true, ..
+                } => (span.shrink_to_hi(), format!(": {binding_replacement}")),
+                PatBindingInfo { span, .. } => (span, binding_replacement.into_owned()),
+            };
             diag.multipart_suggestion_verbose(
                 "try",
                 vec![
-                    if field_binding {
-                        (binding_span.shrink_to_hi(), format!(": {binding_replacement}"))
-                    } else {
-                        (binding_span, binding_replacement.into_owned())
-                    },
+                    suggestion_span,
                     (
                         guard_span.source_callsite().with_lo(outer_arm.pat.span.hi()),
                         inner_guard.map_or_else(String::new, |guard| {
diff --git a/tests/ui/redundant_guards.fixed b/tests/ui/redundant_guards.fixed
index 6793b9c0f6d..20fcc1254a6 100644
--- a/tests/ui/redundant_guards.fixed
+++ b/tests/ui/redundant_guards.fixed
@@ -177,9 +177,9 @@ mod issue11465 {
         };
         match struct_b {
             B { ref b, .. } if b == "bar" => {},
-            B { ref c, .. } if c == &1 => {},
-            B { ref c, .. } if let &1 = c => {},
-            B { ref c, .. } if matches!(c, &1) => {},
+            B { c: 1, .. } => {},
+            B { c: 1, .. } => {},
+            B { c: 1, .. } => {},
             _ => {},
         }
     }
diff --git a/tests/ui/redundant_guards.stderr b/tests/ui/redundant_guards.stderr
index 54b5f2464e6..0a6146413d3 100644
--- a/tests/ui/redundant_guards.stderr
+++ b/tests/ui/redundant_guards.stderr
@@ -130,5 +130,41 @@ LL -             Some(ref x) if matches!(x, &3) => {},
 LL +             Some(3) => {},
    |
 
-error: aborting due to 11 previous errors
+error: redundant guard
+  --> $DIR/redundant_guards.rs:180:32
+   |
+LL |             B { ref c, .. } if c == &1 => {},
+   |                                ^^^^^^^
+   |
+help: try
+   |
+LL -             B { ref c, .. } if c == &1 => {},
+LL +             B { c: 1, .. } => {},
+   |
+
+error: redundant guard
+  --> $DIR/redundant_guards.rs:181:32
+   |
+LL |             B { ref c, .. } if let &1 = c => {},
+   |                                ^^^^^^^^^^
+   |
+help: try
+   |
+LL -             B { ref c, .. } if let &1 = c => {},
+LL +             B { c: 1, .. } => {},
+   |
+
+error: redundant guard
+  --> $DIR/redundant_guards.rs:182:32
+   |
+LL |             B { ref c, .. } if matches!(c, &1) => {},
+   |                                ^^^^^^^^^^^^^^^
+   |
+help: try
+   |
+LL -             B { ref c, .. } if matches!(c, &1) => {},
+LL +             B { c: 1, .. } => {},
+   |
+
+error: aborting due to 14 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From c29de92d85f22bdc8814e87e4d4ee9f46d3c679e Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Fri, 1 Sep 2023 17:05:30 +0000
Subject: Return a value from find_format_args instead of using a callback

---
 clippy_lints/src/explicit_write.rs              | 90 ++++++++++++-------------
 clippy_lints/src/format.rs                      | 14 ++--
 clippy_lints/src/format_args.rs                 | 20 +++---
 clippy_lints/src/format_impl.rs                 | 41 ++++++-----
 clippy_lints/src/lib.rs                         |  2 +-
 clippy_lints/src/methods/expect_fun_call.rs     | 13 ++--
 clippy_lints/src/utils/format_args_collector.rs | 28 ++++++--
 clippy_lints/src/write.rs                       | 10 +--
 clippy_utils/src/macros.rs                      | 37 +++++-----
 9 files changed, 126 insertions(+), 129 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/explicit_write.rs b/clippy_lints/src/explicit_write.rs
index 4b9ca8c917e..b612cc00bf9 100644
--- a/clippy_lints/src/explicit_write.rs
+++ b/clippy_lints/src/explicit_write.rs
@@ -57,54 +57,52 @@ impl<'tcx> LateLintPass<'tcx> for ExplicitWrite {
             } else {
                 None
             }
+            && let Some(format_args) = find_format_args(cx, write_arg, ExpnId::root())
         {
-            find_format_args(cx, write_arg, ExpnId::root(), |format_args| {
-                let calling_macro =
-                    // ordering is important here, since `writeln!` uses `write!` internally
-                    if is_expn_of(write_call.span, "writeln").is_some() {
-                        Some("writeln")
-                    } else if is_expn_of(write_call.span, "write").is_some() {
-                        Some("write")
-                    } else {
-                        None
-                    };
-                let prefix = if dest_name == "stderr" {
-                    "e"
-                } else {
-                    ""
-                };
+            // ordering is important here, since `writeln!` uses `write!` internally
+            let calling_macro = if is_expn_of(write_call.span, "writeln").is_some() {
+                Some("writeln")
+            } else if is_expn_of(write_call.span, "write").is_some() {
+                Some("write")
+            } else {
+                None
+            };
+            let prefix = if dest_name == "stderr" {
+                "e"
+            } else {
+                ""
+            };
 
-                // We need to remove the last trailing newline from the string because the
-                // underlying `fmt::write` function doesn't know whether `println!` or `print!` was
-                // used.
-                let (used, sugg_mac) = if let Some(macro_name) = calling_macro {
-                    (
-                        format!("{macro_name}!({dest_name}(), ...)"),
-                        macro_name.replace("write", "print"),
-                    )
-                } else {
-                    (
-                        format!("{dest_name}().write_fmt(...)"),
-                        "print".into(),
-                    )
-                };
-                let mut applicability = Applicability::MachineApplicable;
-                let inputs_snippet = snippet_with_applicability(
-                    cx,
-                    format_args_inputs_span(format_args),
-                    "..",
-                    &mut applicability,
-                );
-                span_lint_and_sugg(
-                    cx,
-                    EXPLICIT_WRITE,
-                    expr.span,
-                    &format!("use of `{used}.unwrap()`"),
-                    "try",
-                    format!("{prefix}{sugg_mac}!({inputs_snippet})"),
-                    applicability,
-                );
-            });
+            // We need to remove the last trailing newline from the string because the
+            // underlying `fmt::write` function doesn't know whether `println!` or `print!` was
+            // used.
+            let (used, sugg_mac) = if let Some(macro_name) = calling_macro {
+                (
+                    format!("{macro_name}!({dest_name}(), ...)"),
+                    macro_name.replace("write", "print"),
+                )
+            } else {
+                (
+                    format!("{dest_name}().write_fmt(...)"),
+                    "print".into(),
+                )
+            };
+            let mut applicability = Applicability::MachineApplicable;
+            let inputs_snippet = snippet_with_applicability(
+                cx,
+                format_args_inputs_span(&format_args),
+                "..",
+                &mut applicability,
+            );
+            span_lint_and_sugg(
+                cx,
+                EXPLICIT_WRITE,
+                expr.span,
+                &format!("use of `{used}.unwrap()`"),
+                "try",
+                format!("{prefix}{sugg_mac}!({inputs_snippet})"),
+                applicability,
+            );
         }
     }
 }
diff --git a/clippy_lints/src/format.rs b/clippy_lints/src/format.rs
index f4f8bdc2c44..b748d329367 100644
--- a/clippy_lints/src/format.rs
+++ b/clippy_lints/src/format.rs
@@ -43,14 +43,10 @@ declare_lint_pass!(UselessFormat => [USELESS_FORMAT]);
 
 impl<'tcx> LateLintPass<'tcx> for UselessFormat {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        let Some(macro_call) = root_macro_call_first_node(cx, expr) else {
-            return;
-        };
-        if !cx.tcx.is_diagnostic_item(sym::format_macro, macro_call.def_id) {
-            return;
-        }
-
-        find_format_args(cx, expr, macro_call.expn, |format_args| {
+        if let Some(macro_call) = root_macro_call_first_node(cx, expr)
+            && cx.tcx.is_diagnostic_item(sym::format_macro, macro_call.def_id)
+            && let Some(format_args) = find_format_args(cx, expr, macro_call.expn)
+        {
             let mut applicability = Applicability::MachineApplicable;
             let call_site = macro_call.span;
 
@@ -91,7 +87,7 @@ impl<'tcx> LateLintPass<'tcx> for UselessFormat {
                 },
                 _ => {},
             }
-        });
+        }
     }
 }
 
diff --git a/clippy_lints/src/format_args.rs b/clippy_lints/src/format_args.rs
index 01c714c414b..39abf5c2def 100644
--- a/clippy_lints/src/format_args.rs
+++ b/clippy_lints/src/format_args.rs
@@ -186,15 +186,10 @@ impl FormatArgs {
 
 impl<'tcx> LateLintPass<'tcx> for FormatArgs {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
-        let Some(macro_call) = root_macro_call_first_node(cx, expr) else {
-            return;
-        };
-        if !is_format_macro(cx, macro_call.def_id) {
-            return;
-        }
-        let name = cx.tcx.item_name(macro_call.def_id);
-
-        find_format_args(cx, expr, macro_call.expn, |format_args| {
+        if let Some(macro_call) = root_macro_call_first_node(cx, expr)
+            && is_format_macro(cx, macro_call.def_id)
+            && let Some(format_args) = find_format_args(cx, expr, macro_call.expn)
+        {
             for piece in &format_args.template {
                 if let FormatArgsPiece::Placeholder(placeholder) = piece
                     && let Ok(index) = placeholder.argument.index
@@ -206,12 +201,13 @@ impl<'tcx> LateLintPass<'tcx> for FormatArgs {
 
                     if placeholder.format_trait != FormatTrait::Display
                         || placeholder.format_options != FormatOptions::default()
-                        || is_aliased(format_args, index)
+                        || is_aliased(&format_args, index)
                     {
                         continue;
                     }
 
                     if let Ok(arg_hir_expr) = arg_expr {
+                        let name = cx.tcx.item_name(macro_call.def_id);
                         check_format_in_format_args(cx, macro_call.span, name, arg_hir_expr);
                         check_to_string_in_format_args(cx, name, arg_hir_expr);
                     }
@@ -219,9 +215,9 @@ impl<'tcx> LateLintPass<'tcx> for FormatArgs {
             }
 
             if self.msrv.meets(msrvs::FORMAT_ARGS_CAPTURE) {
-                check_uninlined_args(cx, format_args, macro_call.span, macro_call.def_id, self.ignore_mixed);
+                check_uninlined_args(cx, &format_args, macro_call.span, macro_call.def_id, self.ignore_mixed);
             }
-        });
+        }
     }
 
     extract_msrv_attr!(LateContext);
diff --git a/clippy_lints/src/format_impl.rs b/clippy_lints/src/format_impl.rs
index 76369bccf9e..1d2f7cb7130 100644
--- a/clippy_lints/src/format_impl.rs
+++ b/clippy_lints/src/format_impl.rs
@@ -170,30 +170,29 @@ fn check_self_in_format_args<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>,
     if let Some(outer_macro) = root_macro_call_first_node(cx, expr)
         && let macro_def_id = outer_macro.def_id
         && is_format_macro(cx, macro_def_id)
+        && let Some(format_args) = find_format_args(cx, expr, outer_macro.expn)
     {
-        find_format_args(cx, expr, outer_macro.expn, |format_args| {
-            for piece in &format_args.template {
-                if let FormatArgsPiece::Placeholder(placeholder) = piece
-                    && let trait_name = match placeholder.format_trait {
-                        FormatTrait::Display => sym::Display,
-                        FormatTrait::Debug => sym::Debug,
-                        FormatTrait::LowerExp => sym!(LowerExp),
-                        FormatTrait::UpperExp => sym!(UpperExp),
-                        FormatTrait::Octal => sym!(Octal),
-                        FormatTrait::Pointer => sym::Pointer,
-                        FormatTrait::Binary => sym!(Binary),
-                        FormatTrait::LowerHex => sym!(LowerHex),
-                        FormatTrait::UpperHex => sym!(UpperHex),
-                    }
-                    && trait_name == impl_trait.name
-                    && let Ok(index) = placeholder.argument.index
-                    && let Some(arg) = format_args.arguments.all_args().get(index)
-                    && let Ok(arg_expr) = find_format_arg_expr(expr, arg)
-                {
-                    check_format_arg_self(cx, expr.span, arg_expr, impl_trait);
+        for piece in &format_args.template {
+            if let FormatArgsPiece::Placeholder(placeholder) = piece
+                && let trait_name = match placeholder.format_trait {
+                    FormatTrait::Display => sym::Display,
+                    FormatTrait::Debug => sym::Debug,
+                    FormatTrait::LowerExp => sym!(LowerExp),
+                    FormatTrait::UpperExp => sym!(UpperExp),
+                    FormatTrait::Octal => sym!(Octal),
+                    FormatTrait::Pointer => sym::Pointer,
+                    FormatTrait::Binary => sym!(Binary),
+                    FormatTrait::LowerHex => sym!(LowerHex),
+                    FormatTrait::UpperHex => sym!(UpperHex),
                 }
+                && trait_name == impl_trait.name
+                && let Ok(index) = placeholder.argument.index
+                && let Some(arg) = format_args.arguments.all_args().get(index)
+                && let Ok(arg_expr) = find_format_arg_expr(expr, arg)
+            {
+                check_format_arg_self(cx, expr.span, arg_expr, impl_trait);
             }
-        });
+        }
     }
 }
 
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index f5035dcfeeb..3f6bdb2b62c 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -609,7 +609,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
                 .collect(),
         ))
     });
-    store.register_early_pass(|| Box::new(utils::format_args_collector::FormatArgsCollector));
+    store.register_early_pass(|| Box::<utils::format_args_collector::FormatArgsCollector>::default());
     store.register_late_pass(|_| Box::new(utils::dump_hir::DumpHir));
     store.register_late_pass(|_| Box::new(utils::author::Author));
     let await_holding_invalid_types = conf.await_holding_invalid_types.clone();
diff --git a/clippy_lints/src/methods/expect_fun_call.rs b/clippy_lints/src/methods/expect_fun_call.rs
index d3e90e4bba3..40e487bf650 100644
--- a/clippy_lints/src/methods/expect_fun_call.rs
+++ b/clippy_lints/src/methods/expect_fun_call.rs
@@ -131,13 +131,12 @@ pub(super) fn check<'tcx>(
 
     let mut applicability = Applicability::MachineApplicable;
 
-    //Special handling for `format!` as arg_root
+    // Special handling for `format!` as arg_root
     if let Some(macro_call) = root_macro_call_first_node(cx, arg_root) {
-        if !cx.tcx.is_diagnostic_item(sym::format_macro, macro_call.def_id) {
-            return;
-        }
-        find_format_args(cx, arg_root, macro_call.expn, |format_args| {
-            let span = format_args_inputs_span(format_args);
+        if cx.tcx.is_diagnostic_item(sym::format_macro, macro_call.def_id)
+            && let Some(format_args) = find_format_args(cx, arg_root, macro_call.expn)
+        {
+            let span = format_args_inputs_span(&format_args);
             let sugg = snippet_with_applicability(cx, span, "..", &mut applicability);
             span_lint_and_sugg(
                 cx,
@@ -148,7 +147,7 @@ pub(super) fn check<'tcx>(
                 format!("unwrap_or_else({closure_args} panic!({sugg}))"),
                 applicability,
             );
-        });
+        }
         return;
     }
 
diff --git a/clippy_lints/src/utils/format_args_collector.rs b/clippy_lints/src/utils/format_args_collector.rs
index 6d3493523e6..94a9a7c241b 100644
--- a/clippy_lints/src/utils/format_args_collector.rs
+++ b/clippy_lints/src/utils/format_args_collector.rs
@@ -1,12 +1,15 @@
-use clippy_utils::macros::collect_ast_format_args;
+use clippy_utils::macros::AST_FORMAT_ARGS;
 use clippy_utils::source::snippet_opt;
 use itertools::Itertools;
-use rustc_ast::{Expr, ExprKind, FormatArgs};
+use rustc_ast::{Crate, Expr, ExprKind, FormatArgs};
+use rustc_data_structures::fx::FxHashMap;
 use rustc_lexer::{tokenize, TokenKind};
 use rustc_lint::{EarlyContext, EarlyLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::hygiene;
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::{hygiene, Span};
 use std::iter::once;
+use std::mem;
+use std::rc::Rc;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -17,7 +20,12 @@ declare_clippy_lint! {
     "collects `format_args` AST nodes for use in later lints"
 }
 
-declare_lint_pass!(FormatArgsCollector => [FORMAT_ARGS_COLLECTOR]);
+#[derive(Default)]
+pub struct FormatArgsCollector {
+    format_args: FxHashMap<Span, Rc<FormatArgs>>,
+}
+
+impl_lint_pass!(FormatArgsCollector => [FORMAT_ARGS_COLLECTOR]);
 
 impl EarlyLintPass for FormatArgsCollector {
     fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
@@ -26,9 +34,17 @@ impl EarlyLintPass for FormatArgsCollector {
                 return;
             }
 
-            collect_ast_format_args(expr.span, args);
+            self.format_args
+                .insert(expr.span.with_parent(None), Rc::new((**args).clone()));
         }
     }
+
+    fn check_crate_post(&mut self, _: &EarlyContext<'_>, _: &Crate) {
+        AST_FORMAT_ARGS.with(|ast_format_args| {
+            let result = ast_format_args.set(mem::take(&mut self.format_args));
+            debug_assert!(result.is_ok());
+        });
+    }
 }
 
 /// Detects if the format string or an argument has its span set by a proc macro to something inside
diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs
index a9957b18a53..da083fb14aa 100644
--- a/clippy_lints/src/write.rs
+++ b/clippy_lints/src/write.rs
@@ -304,7 +304,7 @@ impl<'tcx> LateLintPass<'tcx> for Write {
             _ => return,
         }
 
-        find_format_args(cx, expr, macro_call.expn, |format_args| {
+        if let Some(format_args) = find_format_args(cx, expr, macro_call.expn) {
             // ignore `writeln!(w)` and `write!(v, some_macro!())`
             if format_args.span.from_expansion() {
                 return;
@@ -312,15 +312,15 @@ impl<'tcx> LateLintPass<'tcx> for Write {
 
             match diag_name {
                 sym::print_macro | sym::eprint_macro | sym::write_macro => {
-                    check_newline(cx, format_args, &macro_call, name);
+                    check_newline(cx, &format_args, &macro_call, name);
                 },
                 sym::println_macro | sym::eprintln_macro | sym::writeln_macro => {
-                    check_empty_string(cx, format_args, &macro_call, name);
+                    check_empty_string(cx, &format_args, &macro_call, name);
                 },
                 _ => {},
             }
 
-            check_literal(cx, format_args, name);
+            check_literal(cx, &format_args, name);
 
             if !self.in_debug_impl {
                 for piece in &format_args.template {
@@ -334,7 +334,7 @@ impl<'tcx> LateLintPass<'tcx> for Write {
                     }
                 }
             }
-        });
+        }
     }
 }
 
diff --git a/clippy_utils/src/macros.rs b/clippy_utils/src/macros.rs
index 98724fcbe96..82508bcdb85 100644
--- a/clippy_utils/src/macros.rs
+++ b/clippy_utils/src/macros.rs
@@ -10,8 +10,9 @@ use rustc_lint::LateContext;
 use rustc_span::def_id::DefId;
 use rustc_span::hygiene::{self, MacroKind, SyntaxContext};
 use rustc_span::{sym, BytePos, ExpnData, ExpnId, ExpnKind, Span, SpanData, Symbol};
-use std::cell::RefCell;
+use std::cell::OnceCell;
 use std::ops::ControlFlow;
+use std::rc::Rc;
 use std::sync::atomic::{AtomicBool, Ordering};
 
 const FORMAT_MACRO_DIAG_ITEMS: &[Symbol] = &[
@@ -374,30 +375,21 @@ thread_local! {
     /// A thread local is used because [`FormatArgs`] is `!Send` and `!Sync`, we are making an
     /// assumption that the early pass that populates the map and the later late passes will all be
     /// running on the same thread.
-    static AST_FORMAT_ARGS: RefCell<FxHashMap<Span, FormatArgs>> = {
+    #[doc(hidden)]
+    pub static AST_FORMAT_ARGS: OnceCell<FxHashMap<Span, Rc<FormatArgs>>> = {
         static CALLED: AtomicBool = AtomicBool::new(false);
         debug_assert!(
             !CALLED.swap(true, Ordering::SeqCst),
             "incorrect assumption: `AST_FORMAT_ARGS` should only be accessed by a single thread",
         );
 
-        RefCell::default()
+        OnceCell::new()
     };
 }
 
-/// Record [`rustc_ast::FormatArgs`] for use in late lint passes, this should only be called by
-/// `FormatArgsCollector`
-pub fn collect_ast_format_args(span: Span, format_args: &FormatArgs) {
-    AST_FORMAT_ARGS.with(|ast_format_args| {
-        ast_format_args
-            .borrow_mut()
-            .insert(span.with_parent(None), format_args.clone());
-    });
-}
-
-/// Calls `callback` with an AST [`FormatArgs`] node if a `format_args` expansion is found as a
-/// descendant of `expn_id`
-pub fn find_format_args(cx: &LateContext<'_>, start: &Expr<'_>, expn_id: ExpnId, callback: impl FnOnce(&FormatArgs)) {
+/// Returns an AST [`FormatArgs`] node if a `format_args` expansion is found as a descendant of
+/// `expn_id`
+pub fn find_format_args(cx: &LateContext<'_>, start: &Expr<'_>, expn_id: ExpnId) -> Option<Rc<FormatArgs>> {
     let format_args_expr = for_each_expr(start, |expr| {
         let ctxt = expr.span.ctxt();
         if ctxt.outer_expn().is_descendant_of(expn_id) {
@@ -412,13 +404,14 @@ pub fn find_format_args(cx: &LateContext<'_>, start: &Expr<'_>, expn_id: ExpnId,
         } else {
             ControlFlow::Continue(Descend::No)
         }
-    });
+    })?;
 
-    if let Some(expr) = format_args_expr {
-        AST_FORMAT_ARGS.with(|ast_format_args| {
-            ast_format_args.borrow().get(&expr.span.with_parent(None)).map(callback);
-        });
-    }
+    AST_FORMAT_ARGS.with(|ast_format_args| {
+        ast_format_args
+            .get()?
+            .get(&format_args_expr.span.with_parent(None))
+            .map(Rc::clone)
+    })
 }
 
 /// Attempt to find the [`rustc_hir::Expr`] that corresponds to the [`FormatArgument`]'s value, if
-- 
cgit 1.4.1-3-g733a5


From a2a31a0a2fd356f681c78498719dea8aa2523190 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Thu, 14 Sep 2023 21:20:50 +0000
Subject: Ignore closures for some type lints

---
 clippy_lints/src/types/mod.rs    | 11 ++++++-----
 tests/ui/redundant_allocation.rs |  5 +++++
 tests/ui/vec_box_sized.fixed     |  5 +++++
 tests/ui/vec_box_sized.rs        |  5 +++++
 4 files changed, 21 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types/mod.rs b/clippy_lints/src/types/mod.rs
index 79f9d45d597..71a4b3fba1b 100644
--- a/clippy_lints/src/types/mod.rs
+++ b/clippy_lints/src/types/mod.rs
@@ -315,7 +315,7 @@ impl<'tcx> LateLintPass<'tcx> for Types {
     fn check_fn(
         &mut self,
         cx: &LateContext<'_>,
-        _: FnKind<'_>,
+        fn_kind: FnKind<'_>,
         decl: &FnDecl<'_>,
         _: &Body<'_>,
         _: Span,
@@ -340,6 +340,7 @@ impl<'tcx> LateLintPass<'tcx> for Types {
             CheckTyContext {
                 is_in_trait_impl,
                 is_exported,
+                in_body: matches!(fn_kind, FnKind::Closure),
                 ..CheckTyContext::default()
             },
         );
@@ -427,7 +428,7 @@ impl<'tcx> LateLintPass<'tcx> for Types {
                 cx,
                 ty,
                 CheckTyContext {
-                    is_local: true,
+                    in_body: true,
                     ..CheckTyContext::default()
                 },
             );
@@ -481,7 +482,7 @@ impl Types {
         }
 
         match hir_ty.kind {
-            TyKind::Path(ref qpath) if !context.is_local => {
+            TyKind::Path(ref qpath) if !context.in_body => {
                 let hir_id = hir_ty.hir_id;
                 let res = cx.qpath_res(qpath, hir_id);
                 if let Some(def_id) = res.opt_def_id() {
@@ -581,8 +582,8 @@ impl Types {
 #[derive(Clone, Copy, Default)]
 struct CheckTyContext {
     is_in_trait_impl: bool,
-    /// `true` for types on local variables.
-    is_local: bool,
+    /// `true` for types on local variables and in closure signatures.
+    in_body: bool,
     /// `true` for types that are part of the public API.
     is_exported: bool,
     is_nested_call: bool,
diff --git a/tests/ui/redundant_allocation.rs b/tests/ui/redundant_allocation.rs
index b3257c04f82..e70f8e71fae 100644
--- a/tests/ui/redundant_allocation.rs
+++ b/tests/ui/redundant_allocation.rs
@@ -159,4 +159,9 @@ mod box_fat_ptr {
     //~| NOTE: `Box<Box<DynSized>>` is already on the heap, `Rc<Box<Box<DynSized>>>` makes
 }
 
+// https://github.com/rust-lang/rust-clippy/issues/11417
+fn type_in_closure() {
+    let _ = |_: &mut Box<Box<dyn ToString>>| {};
+}
+
 fn main() {}
diff --git a/tests/ui/vec_box_sized.fixed b/tests/ui/vec_box_sized.fixed
index 4a5ef83856a..4363d2224af 100644
--- a/tests/ui/vec_box_sized.fixed
+++ b/tests/ui/vec_box_sized.fixed
@@ -49,4 +49,9 @@ mod inner_mod {
     }
 }
 
+// https://github.com/rust-lang/rust-clippy/issues/11417
+fn in_closure() {
+    let _ = |_: Vec<Box<dyn ToString>>| {};
+}
+
 fn main() {}
diff --git a/tests/ui/vec_box_sized.rs b/tests/ui/vec_box_sized.rs
index ea020405a30..f4e27fe4bd5 100644
--- a/tests/ui/vec_box_sized.rs
+++ b/tests/ui/vec_box_sized.rs
@@ -49,4 +49,9 @@ mod inner_mod {
     }
 }
 
+// https://github.com/rust-lang/rust-clippy/issues/11417
+fn in_closure() {
+    let _ = |_: Vec<Box<dyn ToString>>| {};
+}
+
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 3c0fc15848395ed5ef714c8817df8bd4f1bc430f Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Thu, 14 Sep 2023 22:17:51 +0000
Subject: Truncate files when opening in metadata-collector

---
 .../src/utils/internal_lints/metadata_collector.rs | 37 ++++++----------------
 1 file changed, 10 insertions(+), 27 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index f49c3fadb07..c38a3e81b0f 100644
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -31,7 +31,7 @@ use serde::{Serialize, Serializer};
 use std::collections::{BTreeSet, BinaryHeap};
 use std::fmt;
 use std::fmt::Write as _;
-use std::fs::{self, OpenOptions};
+use std::fs::{self, File};
 use std::io::prelude::*;
 use std::path::{Path, PathBuf};
 use std::process::Command;
@@ -229,25 +229,10 @@ impl Drop for MetadataCollector {
         collect_renames(&mut lints);
 
         // Outputting json
-        if Path::new(JSON_OUTPUT_FILE).exists() {
-            fs::remove_file(JSON_OUTPUT_FILE).unwrap();
-        }
-        let mut file = OpenOptions::new()
-            .write(true)
-            .create(true)
-            .open(JSON_OUTPUT_FILE)
-            .unwrap();
-        writeln!(file, "{}", serde_json::to_string_pretty(&lints).unwrap()).unwrap();
+        fs::write(JSON_OUTPUT_FILE, serde_json::to_string_pretty(&lints).unwrap()).unwrap();
 
         // Outputting markdown
-        if Path::new(MARKDOWN_OUTPUT_FILE).exists() {
-            fs::remove_file(MARKDOWN_OUTPUT_FILE).unwrap();
-        }
-        let mut file = OpenOptions::new()
-            .write(true)
-            .create(true)
-            .open(MARKDOWN_OUTPUT_FILE)
-            .unwrap();
+        let mut file = File::create(MARKDOWN_OUTPUT_FILE).unwrap();
         writeln!(
             file,
             "<!--
@@ -261,17 +246,15 @@ Please use that command to update the file and do not edit it by hand.
         .unwrap();
 
         // Write configuration links to CHANGELOG.md
-        let mut changelog = std::fs::read_to_string(CHANGELOG_PATH).unwrap();
-        let mut changelog_file = OpenOptions::new().read(true).write(true).open(CHANGELOG_PATH).unwrap();
-
-        if let Some(position) = changelog.find("<!-- begin autogenerated links to configuration documentation -->") {
-            // I know this is kinda wasteful, we just don't have regex on `clippy_lints` so... this is the best
-            // we can do AFAIK.
-            changelog = changelog[..position].to_string();
-        }
+        let changelog = std::fs::read_to_string(CHANGELOG_PATH).unwrap();
+        let mut changelog_file = File::create(CHANGELOG_PATH).unwrap();
+        let position = changelog
+            .find("<!-- begin autogenerated links to configuration documentation -->")
+            .unwrap();
         writeln!(
             changelog_file,
-            "{changelog}<!-- begin autogenerated links to configuration documentation -->\n{}\n<!-- end autogenerated links to configuration documentation -->",
+            "{}<!-- begin autogenerated links to configuration documentation -->\n{}\n<!-- end autogenerated links to configuration documentation -->",
+            &changelog[..position],
             self.configs_to_markdown(ClippyConfiguration::to_markdown_link)
         )
         .unwrap();
-- 
cgit 1.4.1-3-g733a5


From 1d76eede99126dc6534a0d89dbf04121cd990042 Mon Sep 17 00:00:00 2001
From: J-ZhengLi <lizheng135@huawei.com>
Date: Fri, 15 Sep 2023 12:24:45 +0800
Subject: trigger [`transmute_null_to_fn`] on chain of casts

---
 clippy_lints/src/transmute/transmute_null_to_fn.rs | 30 ++++++++++++++--------
 tests/ui/transmute_null_to_fn.rs                   | 11 ++++++++
 tests/ui/transmute_null_to_fn.stderr               | 26 ++++++++++++++++++-
 3 files changed, 55 insertions(+), 12 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/transmute/transmute_null_to_fn.rs b/clippy_lints/src/transmute/transmute_null_to_fn.rs
index 4944381da24..b26365e34ab 100644
--- a/clippy_lints/src/transmute/transmute_null_to_fn.rs
+++ b/clippy_lints/src/transmute/transmute_null_to_fn.rs
@@ -28,35 +28,43 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, arg: &'t
         return false;
     }
 
-    match arg.kind {
+    let casts_peeled = peel_casts(arg);
+    match casts_peeled.kind {
         // Catching:
         // transmute over constants that resolve to `null`.
-        ExprKind::Path(ref _qpath) if matches!(constant(cx, cx.typeck_results(), arg), Some(Constant::RawPtr(0))) => {
+        ExprKind::Path(ref _qpath)
+            if matches!(
+                constant(cx, cx.typeck_results(), casts_peeled),
+                Some(Constant::RawPtr(0))
+            ) =>
+        {
             lint_expr(cx, expr);
             true
         },
-
-        // Catching:
-        // `std::mem::transmute(0 as *const i32)`
-        ExprKind::Cast(inner_expr, _cast_ty) if is_integer_literal(inner_expr, 0) => {
-            lint_expr(cx, expr);
-            true
-        },
-
         // Catching:
         // `std::mem::transmute(std::ptr::null::<i32>())`
         ExprKind::Call(func1, []) if is_path_diagnostic_item(cx, func1, sym::ptr_null) => {
             lint_expr(cx, expr);
             true
         },
-
         _ => {
             // FIXME:
             // Also catch transmutations of variables which are known nulls.
             // To do this, MIR const propagation seems to be the better tool.
             // Whenever MIR const prop routines are more developed, this will
             // become available. As of this writing (25/03/19) it is not yet.
+            if is_integer_literal(casts_peeled, 0) {
+                lint_expr(cx, expr);
+                return true;
+            }
             false
         },
     }
 }
+
+fn peel_casts<'tcx>(expr: &'tcx Expr<'tcx>) -> &'tcx Expr<'tcx> {
+    match &expr.kind {
+        ExprKind::Cast(inner_expr, _) => peel_casts(inner_expr),
+        _ => expr,
+    }
+}
diff --git a/tests/ui/transmute_null_to_fn.rs b/tests/ui/transmute_null_to_fn.rs
index 7d780c803ff..b07851e864f 100644
--- a/tests/ui/transmute_null_to_fn.rs
+++ b/tests/ui/transmute_null_to_fn.rs
@@ -25,6 +25,17 @@ fn transmute_const() {
     }
 }
 
+fn issue_11485() {
+    unsafe {
+        let _: fn() = std::mem::transmute(0 as *const u8 as *const ());
+        //~^ ERROR: transmuting a known null pointer into a function pointer
+        let _: fn() = std::mem::transmute(std::ptr::null::<()>() as *const u8);
+        //~^ ERROR: transmuting a known null pointer into a function pointer
+        let _: fn() = std::mem::transmute(ZPTR as *const u8);
+        //~^ ERROR: transmuting a known null pointer into a function pointer
+    }
+}
+
 fn main() {
     one_liners();
     transmute_const();
diff --git a/tests/ui/transmute_null_to_fn.stderr b/tests/ui/transmute_null_to_fn.stderr
index ab0ac0dd480..9073080cbf3 100644
--- a/tests/ui/transmute_null_to_fn.stderr
+++ b/tests/ui/transmute_null_to_fn.stderr
@@ -24,5 +24,29 @@ LL |         let _: fn() = std::mem::transmute(ZPTR);
    |
    = help: try wrapping your function pointer type in `Option<T>` instead, and using `None` as a null pointer value
 
-error: aborting due to 3 previous errors
+error: transmuting a known null pointer into a function pointer
+  --> $DIR/transmute_null_to_fn.rs:30:23
+   |
+LL |         let _: fn() = std::mem::transmute(0 as *const u8 as *const ());
+   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this transmute results in undefined behavior
+   |
+   = help: try wrapping your function pointer type in `Option<T>` instead, and using `None` as a null pointer value
+
+error: transmuting a known null pointer into a function pointer
+  --> $DIR/transmute_null_to_fn.rs:32:23
+   |
+LL |         let _: fn() = std::mem::transmute(std::ptr::null::<()>() as *const u8);
+   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this transmute results in undefined behavior
+   |
+   = help: try wrapping your function pointer type in `Option<T>` instead, and using `None` as a null pointer value
+
+error: transmuting a known null pointer into a function pointer
+  --> $DIR/transmute_null_to_fn.rs:34:23
+   |
+LL |         let _: fn() = std::mem::transmute(ZPTR as *const u8);
+   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this transmute results in undefined behavior
+   |
+   = help: try wrapping your function pointer type in `Option<T>` instead, and using `None` as a null pointer value
+
+error: aborting due to 6 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From c9b212d5ffa5dcfe36ed41658c71dcbcbf949dd8 Mon Sep 17 00:00:00 2001
From: mojave2 <chenchen145@huawei.com>
Date: Fri, 15 Sep 2023 14:23:58 +0800
Subject: fix filter_map_bool_then with a bool reference

---
 clippy_lints/src/methods/filter_map_bool_then.rs | 5 +++--
 tests/ui/filter_map_bool_then.fixed              | 5 +++++
 tests/ui/filter_map_bool_then.rs                 | 5 +++++
 tests/ui/filter_map_bool_then.stderr             | 8 +++++++-
 4 files changed, 20 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/filter_map_bool_then.rs b/clippy_lints/src/methods/filter_map_bool_then.rs
index fafc9709770..ac5bff6fee0 100644
--- a/clippy_lints/src/methods/filter_map_bool_then.rs
+++ b/clippy_lints/src/methods/filter_map_bool_then.rs
@@ -8,7 +8,7 @@ use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_middle::ty::Binder;
+use rustc_middle::ty::{self, Binder};
 use rustc_span::{sym, Span};
 
 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, arg: &Expr<'_>, call_span: Span) {
@@ -36,6 +36,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, arg: &
         && let Some(def_id) = cx.typeck_results().type_dependent_def_id(value.hir_id)
         && match_def_path(cx, def_id, &BOOL_THEN)
         && !is_from_proc_macro(cx, expr)
+        && let ref_bool = matches!(cx.typeck_results().expr_ty(recv).kind(), ty::Ref(..))
         && let Some(param_snippet) = snippet_opt(cx, param.span)
         && let Some(filter) = snippet_opt(cx, recv.span)
         && let Some(map) = snippet_opt(cx, then_body.span)
@@ -46,7 +47,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, arg: &
             call_span,
             "usage of `bool::then` in `filter_map`",
             "use `filter` then `map` instead",
-            format!("filter(|&{param_snippet}| {filter}).map(|{param_snippet}| {map})"),
+            format!("filter(|&{param_snippet}| {}{filter}).map(|{param_snippet}| {map})", if ref_bool { "*" } else { "" }),
             Applicability::MachineApplicable,
         );
     }
diff --git a/tests/ui/filter_map_bool_then.fixed b/tests/ui/filter_map_bool_then.fixed
index 6de870a9289..67b984ce025 100644
--- a/tests/ui/filter_map_bool_then.fixed
+++ b/tests/ui/filter_map_bool_then.fixed
@@ -55,3 +55,8 @@ fn main() {
 fn issue11309<'a>(iter: impl Iterator<Item = (&'a str, &'a str)>) -> Vec<&'a str> {
     iter.filter_map(|(_, s): (&str, _)| Some(s)).collect()
 }
+
+fn issue11503() {
+    let bools: &[bool] = &[true, false, false, true];
+    let _: Vec<usize> = bools.iter().enumerate().filter(|&(i, b)| *b).map(|(i, b)| i).collect();
+}
diff --git a/tests/ui/filter_map_bool_then.rs b/tests/ui/filter_map_bool_then.rs
index 4108177e3a0..b716fd70fa0 100644
--- a/tests/ui/filter_map_bool_then.rs
+++ b/tests/ui/filter_map_bool_then.rs
@@ -55,3 +55,8 @@ fn main() {
 fn issue11309<'a>(iter: impl Iterator<Item = (&'a str, &'a str)>) -> Vec<&'a str> {
     iter.filter_map(|(_, s): (&str, _)| Some(s)).collect()
 }
+
+fn issue11503() {
+    let bools: &[bool] = &[true, false, false, true];
+    let _: Vec<usize> = bools.iter().enumerate().filter_map(|(i, b)| b.then(|| i)).collect();
+}
diff --git a/tests/ui/filter_map_bool_then.stderr b/tests/ui/filter_map_bool_then.stderr
index 86ef6edf8ee..1fee93afb36 100644
--- a/tests/ui/filter_map_bool_then.stderr
+++ b/tests/ui/filter_map_bool_then.stderr
@@ -37,5 +37,11 @@ error: usage of `bool::then` in `filter_map`
 LL |     v.clone().iter().filter_map(|i| (i == &NonCopy).then(|| i));
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `filter` then `map` instead: `filter(|&i| (i == &NonCopy)).map(|i| i)`
 
-error: aborting due to 6 previous errors
+error: usage of `bool::then` in `filter_map`
+  --> $DIR/filter_map_bool_then.rs:61:50
+   |
+LL |     let _: Vec<usize> = bools.iter().enumerate().filter_map(|(i, b)| b.then(|| i)).collect();
+   |                                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `filter` then `map` instead: `filter(|&(i, b)| *b).map(|(i, b)| i)`
+
+error: aborting due to 7 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From c81888eab32e09318a9b95fdad22aea27f6933ea Mon Sep 17 00:00:00 2001
From: mojave2 <chenchen145@huawei.com>
Date: Fri, 15 Sep 2023 15:05:43 +0800
Subject: fix FP of let_unit_value on async fn args

---
 clippy_lints/src/unit_types/let_unit_value.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unit_types/let_unit_value.rs b/clippy_lints/src/unit_types/let_unit_value.rs
index 704d7abd7e5..e7915953d85 100644
--- a/clippy_lints/src/unit_types/let_unit_value.rs
+++ b/clippy_lints/src/unit_types/let_unit_value.rs
@@ -7,7 +7,7 @@ use rustc_errors::Applicability;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::{Expr, ExprKind, HirId, HirIdSet, Local, MatchSource, Node, PatKind, QPath, TyKind};
 use rustc_lint::{LateContext, LintContext};
-use rustc_middle::lint::in_external_macro;
+use rustc_middle::lint::{in_external_macro, is_from_async_await};
 use rustc_middle::ty;
 
 use super::LET_UNIT_VALUE;
@@ -16,6 +16,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, local: &'tcx Local<'_>) {
     if let Some(init) = local.init
         && !local.pat.span.from_expansion()
         && !in_external_macro(cx.sess(), local.span)
+        && !is_from_async_await(local.span)
         && cx.typeck_results().pat_ty(local.pat).is_unit()
     {
         if (local.ty.map_or(false, |ty| !matches!(ty.kind, TyKind::Infer))
-- 
cgit 1.4.1-3-g733a5


From 981e96008b58d34e9c52b0aa3b318974c75b9d1d Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Mon, 11 Sep 2023 22:46:15 +0200
Subject: new lint: `path_ends_with_ext`

---
 CHANGELOG.md                                       |  2 +
 book/src/lint_configuration.md                     | 10 ++++
 clippy_lints/src/declared_lints.rs                 |  1 +
 clippy_lints/src/lib.rs                            |  7 +++
 clippy_lints/src/methods/mod.rs                    | 47 +++++++++++++++++++
 clippy_lints/src/methods/path_ends_with_ext.rs     | 53 ++++++++++++++++++++++
 clippy_lints/src/utils/conf.rs                     |  5 ++
 .../toml_unknown_key/conf_unknown_key.stderr       |  2 +
 tests/ui/path_ends_with_ext.fixed                  | 36 +++++++++++++++
 tests/ui/path_ends_with_ext.rs                     | 36 +++++++++++++++
 tests/ui/path_ends_with_ext.stderr                 | 17 +++++++
 11 files changed, 216 insertions(+)
 create mode 100644 clippy_lints/src/methods/path_ends_with_ext.rs
 create mode 100644 tests/ui/path_ends_with_ext.fixed
 create mode 100644 tests/ui/path_ends_with_ext.rs
 create mode 100644 tests/ui/path_ends_with_ext.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9aca13a6cf6..5e01e8d07bd 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5245,6 +5245,7 @@ Released 2018-09-13
 [`partialeq_ne_impl`]: https://rust-lang.github.io/rust-clippy/master/index.html#partialeq_ne_impl
 [`partialeq_to_none`]: https://rust-lang.github.io/rust-clippy/master/index.html#partialeq_to_none
 [`path_buf_push_overwrite`]: https://rust-lang.github.io/rust-clippy/master/index.html#path_buf_push_overwrite
+[`path_ends_with_ext`]: https://rust-lang.github.io/rust-clippy/master/index.html#path_ends_with_ext
 [`pattern_type_mismatch`]: https://rust-lang.github.io/rust-clippy/master/index.html#pattern_type_mismatch
 [`permissions_set_readonly_false`]: https://rust-lang.github.io/rust-clippy/master/index.html#permissions_set_readonly_false
 [`positional_named_format_parameters`]: https://rust-lang.github.io/rust-clippy/master/index.html#positional_named_format_parameters
@@ -5575,5 +5576,6 @@ Released 2018-09-13
 [`allow-one-hash-in-raw-strings`]: https://doc.rust-lang.org/clippy/lint_configuration.html#allow-one-hash-in-raw-strings
 [`absolute-paths-max-segments`]: https://doc.rust-lang.org/clippy/lint_configuration.html#absolute-paths-max-segments
 [`absolute-paths-allowed-crates`]: https://doc.rust-lang.org/clippy/lint_configuration.html#absolute-paths-allowed-crates
+[`allowed-dotfiles`]: https://doc.rust-lang.org/clippy/lint_configuration.html#allowed-dotfiles
 [`enforce-iter-loop-reborrow`]: https://doc.rust-lang.org/clippy/lint_configuration.html#enforce-iter-loop-reborrow
 <!-- end autogenerated links to configuration documentation -->
diff --git a/book/src/lint_configuration.md b/book/src/lint_configuration.md
index 52c795e04fe..3aeb6206fca 100644
--- a/book/src/lint_configuration.md
+++ b/book/src/lint_configuration.md
@@ -751,6 +751,16 @@ Which crates to allow absolute paths from
 * [`absolute_paths`](https://rust-lang.github.io/rust-clippy/master/index.html#absolute_paths)
 
 
+## `allowed-dotfiles`
+Additional dotfiles (files or directories starting with a dot) to allow
+
+**Default Value:** `{}` (`rustc_data_structures::fx::FxHashSet<String>`)
+
+---
+**Affected lints:**
+* [`path_ends_with_ext`](https://rust-lang.github.io/rust-clippy/master/index.html#path_ends_with_ext)
+
+
 ## `enforce-iter-loop-reborrow`
 #### Example
 ```
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index ecf44e05920..4772f3d8037 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -399,6 +399,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::methods::OR_FUN_CALL_INFO,
     crate::methods::OR_THEN_UNWRAP_INFO,
     crate::methods::PATH_BUF_PUSH_OVERWRITE_INFO,
+    crate::methods::PATH_ENDS_WITH_EXT_INFO,
     crate::methods::RANGE_ZIP_WITH_LEN_INFO,
     crate::methods::READONLY_WRITE_LOCK_INFO,
     crate::methods::READ_LINE_WITHOUT_TRIM_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 3f6bdb2b62c..8f603d5d988 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -662,12 +662,19 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     let allow_unwrap_in_tests = conf.allow_unwrap_in_tests;
     let suppress_restriction_lint_in_const = conf.suppress_restriction_lint_in_const;
     store.register_late_pass(move |_| Box::new(approx_const::ApproxConstant::new(msrv())));
+    let allowed_dotfiles = conf
+        .allowed_dotfiles
+        .iter()
+        .cloned()
+        .chain(methods::DEFAULT_ALLOWED_DOTFILES.iter().copied().map(ToOwned::to_owned))
+        .collect::<FxHashSet<_>>();
     store.register_late_pass(move |_| {
         Box::new(methods::Methods::new(
             avoid_breaking_exported_api,
             msrv(),
             allow_expect_in_tests,
             allow_unwrap_in_tests,
+            allowed_dotfiles.clone(),
         ))
     });
     store.register_late_pass(move |_| Box::new(matches::Matches::new(msrv())));
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 81223fa8d95..f4682364806 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -74,6 +74,7 @@ mod option_map_unwrap_or;
 mod or_fun_call;
 mod or_then_unwrap;
 mod path_buf_push_overwrite;
+mod path_ends_with_ext;
 mod range_zip_with_len;
 mod read_line_without_trim;
 mod readonly_write_lock;
@@ -120,6 +121,8 @@ use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::ty::{contains_ty_adt_constructor_opaque, implements_trait, is_copy, is_type_diagnostic_item};
 use clippy_utils::{contains_return, is_bool, is_trait_method, iter_input_pats, peel_blocks, return_ty};
 use if_chain::if_chain;
+pub use path_ends_with_ext::DEFAULT_ALLOWED_DOTFILES;
+use rustc_data_structures::fx::FxHashSet;
 use rustc_hir as hir;
 use rustc_hir::{Expr, ExprKind, Node, Stmt, StmtKind, TraitItem, TraitItemKind};
 use rustc_hir_analysis::hir_ty_to_ty;
@@ -3563,11 +3566,51 @@ declare_clippy_lint! {
     "calls to `.take()` or `.skip()` that are out of bounds"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Looks for calls to `Path::ends_with` calls where the argument looks like a file extension.
+    ///
+    /// By default, Clippy has a short list of known filenames that start with a dot
+    /// but aren't necessarily file extensions (e.g. the `.git` folder), which are allowed by default.
+    /// The `allowed-dotfiles` configuration can be used to allow additional
+    /// file extensions that Clippy should not lint.
+    ///
+    /// ### Why is this bad?
+    /// This doesn't actually compare file extensions. Rather, `ends_with` compares the given argument
+    /// to the last **component** of the path and checks if it matches exactly.
+    ///
+    /// ### Known issues
+    /// File extensions are often at most three characters long, so this only lints in those cases
+    /// in an attempt to avoid false positives.
+    /// Any extension names longer than that are assumed to likely be real path components and are
+    /// therefore ignored.
+    ///
+    /// ### Example
+    /// ```rust
+    /// # use std::path::Path;
+    /// fn is_markdown(path: &Path) -> bool {
+    ///     path.ends_with(".md")
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// # use std::path::Path;
+    /// fn is_markdown(path: &Path) -> bool {
+    ///     path.extension().is_some_and(|ext| ext == "md")
+    /// }
+    /// ```
+    #[clippy::version = "1.74.0"]
+    pub PATH_ENDS_WITH_EXT,
+    suspicious,
+    "attempting to compare file extensions using `Path::ends_with`"
+}
+
 pub struct Methods {
     avoid_breaking_exported_api: bool,
     msrv: Msrv,
     allow_expect_in_tests: bool,
     allow_unwrap_in_tests: bool,
+    allowed_dotfiles: FxHashSet<String>,
 }
 
 impl Methods {
@@ -3577,12 +3620,14 @@ impl Methods {
         msrv: Msrv,
         allow_expect_in_tests: bool,
         allow_unwrap_in_tests: bool,
+        allowed_dotfiles: FxHashSet<String>,
     ) -> Self {
         Self {
             avoid_breaking_exported_api,
             msrv,
             allow_expect_in_tests,
             allow_unwrap_in_tests,
+            allowed_dotfiles,
         }
     }
 }
@@ -3703,6 +3748,7 @@ impl_lint_pass!(Methods => [
     FILTER_MAP_BOOL_THEN,
     READONLY_WRITE_LOCK,
     ITER_OUT_OF_BOUNDS,
+    PATH_ENDS_WITH_EXT,
 ]);
 
 /// Extracts a method call name, args, and `Span` of the method name.
@@ -3978,6 +4024,7 @@ impl Methods {
                     if let ExprKind::MethodCall(.., span) = expr.kind {
                         case_sensitive_file_extension_comparisons::check(cx, expr, span, recv, arg);
                     }
+                    path_ends_with_ext::check(cx, recv, arg, expr, &self.msrv, &self.allowed_dotfiles);
                 },
                 ("expect", [_]) => {
                     match method_call(recv) {
diff --git a/clippy_lints/src/methods/path_ends_with_ext.rs b/clippy_lints/src/methods/path_ends_with_ext.rs
new file mode 100644
index 00000000000..3347c8c1620
--- /dev/null
+++ b/clippy_lints/src/methods/path_ends_with_ext.rs
@@ -0,0 +1,53 @@
+use super::PATH_ENDS_WITH_EXT;
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::msrvs;
+use clippy_utils::msrvs::Msrv;
+use clippy_utils::source::snippet;
+use clippy_utils::ty::is_type_diagnostic_item;
+use rustc_ast::{LitKind, StrStyle};
+use rustc_data_structures::fx::FxHashSet;
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind};
+use rustc_lint::LateContext;
+use rustc_span::sym;
+use std::fmt::Write;
+
+pub const DEFAULT_ALLOWED_DOTFILES: &[&str] = &[
+    "git", "svn", "gem", "npm", "vim", "env", "rnd", "ssh", "vnc", "smb", "nvm", "bin",
+];
+
+pub(super) fn check(
+    cx: &LateContext<'_>,
+    recv: &Expr<'_>,
+    path: &Expr<'_>,
+    expr: &Expr<'_>,
+    msrv: &Msrv,
+    allowed_dotfiles: &FxHashSet<String>,
+) {
+    if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(recv).peel_refs(), sym::Path)
+        && !path.span.from_expansion()
+        && let ExprKind::Lit(lit) = path.kind
+        && let LitKind::Str(path, StrStyle::Cooked) = lit.node
+        && let Some(path) = path.as_str().strip_prefix('.')
+        && (1..=3).contains(&path.len())
+        && !allowed_dotfiles.contains(path)
+        && path.chars().all(char::is_alphanumeric)
+    {
+        let mut sugg = snippet(cx, recv.span, "..").into_owned();
+        if msrv.meets(msrvs::OPTION_IS_SOME_AND) {
+            let _ = write!(sugg, r#".extension().is_some_and(|ext| ext == "{path}")"#);
+        } else {
+            let _ = write!(sugg, r#".extension().map_or(false, |ext| ext == "{path}")"#);
+        };
+
+        span_lint_and_sugg(
+            cx,
+            PATH_ENDS_WITH_EXT,
+            expr.span,
+            "this looks like a failed attempt at checking for the file extension",
+            "try",
+            sugg,
+            Applicability::MaybeIncorrect
+        );
+    }
+}
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 26889475522..e1280ef38ef 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -561,6 +561,11 @@ define_Conf! {
     /// Which crates to allow absolute paths from
     (absolute_paths_allowed_crates: rustc_data_structures::fx::FxHashSet<String> =
         rustc_data_structures::fx::FxHashSet::default()),
+    /// Lint: PATH_ENDS_WITH_EXT.
+    ///
+    /// Additional dotfiles (files or directories starting with a dot) to allow
+    (allowed_dotfiles: rustc_data_structures::fx::FxHashSet<String> =
+        rustc_data_structures::fx::FxHashSet::default()),
     /// Lint: EXPLICIT_ITER_LOOP
     ///
     /// Whether to recommend using implicit into iter for reborrowed values.
diff --git a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
index b97bb144468..4bed5c149f5 100644
--- a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
+++ b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
@@ -10,6 +10,7 @@ error: error reading Clippy's configuration file: unknown field `foobar`, expect
            allow-print-in-tests
            allow-private-module-inception
            allow-unwrap-in-tests
+           allowed-dotfiles
            allowed-idents-below-min-chars
            allowed-scripts
            arithmetic-side-effects-allowed
@@ -82,6 +83,7 @@ error: error reading Clippy's configuration file: unknown field `barfoo`, expect
            allow-print-in-tests
            allow-private-module-inception
            allow-unwrap-in-tests
+           allowed-dotfiles
            allowed-idents-below-min-chars
            allowed-scripts
            arithmetic-side-effects-allowed
diff --git a/tests/ui/path_ends_with_ext.fixed b/tests/ui/path_ends_with_ext.fixed
new file mode 100644
index 00000000000..49767e242ce
--- /dev/null
+++ b/tests/ui/path_ends_with_ext.fixed
@@ -0,0 +1,36 @@
+#![warn(clippy::path_ends_with_ext)]
+use std::path::Path;
+
+macro_rules! arg {
+    () => {
+        ".md"
+    };
+}
+
+fn test(path: &Path) {
+    path.extension().is_some_and(|ext| ext == "md");
+    //~^ ERROR: this looks like a failed attempt at checking for the file extension
+
+    // some "extensions" are allowed by default
+    path.ends_with(".git");
+
+    // most legitimate "dotfiles" are longer than 3 chars, so we allow them as well
+    path.ends_with(".bashrc");
+
+    // argument from expn shouldn't trigger
+    path.ends_with(arg!());
+
+    path.ends_with("..");
+    path.ends_with("./a");
+    path.ends_with(".");
+    path.ends_with("");
+}
+
+// is_some_and was stabilized in 1.70, so suggest map_or(false, ..) if under that
+#[clippy::msrv = "1.69"]
+fn under_msv(path: &Path) -> bool {
+    path.extension().map_or(false, |ext| ext == "md")
+    //~^ ERROR: this looks like a failed attempt at checking for the file extension
+}
+
+fn main() {}
diff --git a/tests/ui/path_ends_with_ext.rs b/tests/ui/path_ends_with_ext.rs
new file mode 100644
index 00000000000..2dfd046218a
--- /dev/null
+++ b/tests/ui/path_ends_with_ext.rs
@@ -0,0 +1,36 @@
+#![warn(clippy::path_ends_with_ext)]
+use std::path::Path;
+
+macro_rules! arg {
+    () => {
+        ".md"
+    };
+}
+
+fn test(path: &Path) {
+    path.ends_with(".md");
+    //~^ ERROR: this looks like a failed attempt at checking for the file extension
+
+    // some "extensions" are allowed by default
+    path.ends_with(".git");
+
+    // most legitimate "dotfiles" are longer than 3 chars, so we allow them as well
+    path.ends_with(".bashrc");
+
+    // argument from expn shouldn't trigger
+    path.ends_with(arg!());
+
+    path.ends_with("..");
+    path.ends_with("./a");
+    path.ends_with(".");
+    path.ends_with("");
+}
+
+// is_some_and was stabilized in 1.70, so suggest map_or(false, ..) if under that
+#[clippy::msrv = "1.69"]
+fn under_msv(path: &Path) -> bool {
+    path.ends_with(".md")
+    //~^ ERROR: this looks like a failed attempt at checking for the file extension
+}
+
+fn main() {}
diff --git a/tests/ui/path_ends_with_ext.stderr b/tests/ui/path_ends_with_ext.stderr
new file mode 100644
index 00000000000..a73ab4d08e9
--- /dev/null
+++ b/tests/ui/path_ends_with_ext.stderr
@@ -0,0 +1,17 @@
+error: this looks like a failed attempt at checking for the file extension
+  --> $DIR/path_ends_with_ext.rs:11:5
+   |
+LL |     path.ends_with(".md");
+   |     ^^^^^^^^^^^^^^^^^^^^^ help: try: `path.extension().is_some_and(|ext| ext == "md")`
+   |
+   = note: `-D clippy::path-ends-with-ext` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::path_ends_with_ext)]`
+
+error: this looks like a failed attempt at checking for the file extension
+  --> $DIR/path_ends_with_ext.rs:32:5
+   |
+LL |     path.ends_with(".md")
+   |     ^^^^^^^^^^^^^^^^^^^^^ help: try: `path.extension().map_or(false, |ext| ext == "md")`
+
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From fed036a57c96d91ac632f0bd40a27ef78b5b96c6 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Fri, 15 Sep 2023 07:06:50 -0400
Subject: Fix cycle detection in `needless_borrow`

---
 clippy_lints/src/dereference.rs |  3 ---
 clippy_utils/src/mir/mod.rs     | 40 ++++++++++++++++++++++++++++++++++------
 2 files changed, 34 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index 8090f821d1f..d0a898adff4 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -12,7 +12,6 @@ use hir::def::DefKind;
 use hir::MatchSource;
 use rustc_ast::util::parser::{PREC_POSTFIX, PREC_PREFIX};
 use rustc_data_structures::fx::FxIndexMap;
-use rustc_data_structures::graph::iterate::{CycleDetector, TriColorDepthFirstSearch};
 use rustc_errors::Applicability;
 use rustc_hir::def::Res;
 use rustc_hir::def_id::{DefId, LocalDefId};
@@ -1172,8 +1171,6 @@ fn referent_used_exactly_once<'tcx>(
         && let Some(statement) = mir.basic_blocks[location.block].statements.get(location.statement_index)
         && let StatementKind::Assign(box (_, Rvalue::Ref(_, _, place))) = statement.kind
         && !place.is_indirect_first_projection()
-        // Ensure not in a loop (https://github.com/rust-lang/rust-clippy/issues/9710)
-        && TriColorDepthFirstSearch::new(&mir.basic_blocks).run_from(location.block, &mut CycleDetector).is_none()
     {
         let body_owner_local_def_id = cx.tcx.hir().enclosing_body_owner(reference.hir_id);
         if possible_borrowers
diff --git a/clippy_utils/src/mir/mod.rs b/clippy_utils/src/mir/mod.rs
index 131f3c0aa39..f04467dc19d 100644
--- a/clippy_utils/src/mir/mod.rs
+++ b/clippy_utils/src/mir/mod.rs
@@ -1,7 +1,8 @@
 use rustc_hir::{Expr, HirId};
+use rustc_index::bit_set::BitSet;
 use rustc_middle::mir::visit::{MutatingUseContext, NonMutatingUseContext, PlaceContext, Visitor};
 use rustc_middle::mir::{
-    traversal, Body, InlineAsmOperand, Local, Location, Place, StatementKind, TerminatorKind, START_BLOCK,
+    traversal, BasicBlock, Body, InlineAsmOperand, Local, Location, Place, StatementKind, TerminatorKind, START_BLOCK,
 };
 use rustc_middle::ty::TyCtxt;
 
@@ -79,8 +80,32 @@ impl<'a, 'tcx> Visitor<'tcx> for V<'a> {
     }
 }
 
+/// Checks if the block is part of a cycle
+pub fn block_in_cycle(body: &Body<'_>, block: BasicBlock) -> bool {
+    let mut seen = BitSet::new_empty(body.basic_blocks.len());
+    let mut to_visit = Vec::with_capacity(body.basic_blocks.len() / 2);
+
+    seen.insert(block);
+    let mut next = block;
+    loop {
+        for succ in body.basic_blocks[next].terminator().successors() {
+            if seen.insert(succ) {
+                to_visit.push(succ);
+            } else if succ == block {
+                return true;
+            }
+        }
+
+        if let Some(x) = to_visit.pop() {
+            next = x;
+        } else {
+            return false;
+        }
+    }
+}
+
 /// Convenience wrapper around `visit_local_usage`.
-pub fn used_exactly_once(mir: &rustc_middle::mir::Body<'_>, local: rustc_middle::mir::Local) -> Option<bool> {
+pub fn used_exactly_once(mir: &Body<'_>, local: rustc_middle::mir::Local) -> Option<bool> {
     visit_local_usage(
         &[local],
         mir,
@@ -91,11 +116,14 @@ pub fn used_exactly_once(mir: &rustc_middle::mir::Body<'_>, local: rustc_middle:
     )
     .map(|mut vec| {
         let LocalUsage { local_use_locs, .. } = vec.remove(0);
-        local_use_locs
+        let mut locations = local_use_locs
             .into_iter()
-            .filter(|location| !is_local_assignment(mir, local, *location))
-            .count()
-            == 1
+            .filter(|&location| !is_local_assignment(mir, local, location));
+        if let Some(location) = locations.next() {
+            locations.next().is_none() && !block_in_cycle(mir, location.block)
+        } else {
+            false
+        }
     })
 }
 
-- 
cgit 1.4.1-3-g733a5


From 860e800fa08734ff9d15a67115f8220e5fa2202e Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Sat, 16 Sep 2023 14:14:51 +0200
Subject: [`filter_map_bool_then`]: peel as many refs as needed

---
 clippy_lints/src/methods/filter_map_bool_then.rs | 15 +++++++++++----
 tests/ui/filter_map_bool_then.fixed              |  8 ++++++++
 tests/ui/filter_map_bool_then.rs                 |  8 ++++++++
 tests/ui/filter_map_bool_then.stderr             | 14 +++++++++++++-
 4 files changed, 40 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/filter_map_bool_then.rs b/clippy_lints/src/methods/filter_map_bool_then.rs
index ac5bff6fee0..dd4aa276663 100644
--- a/clippy_lints/src/methods/filter_map_bool_then.rs
+++ b/clippy_lints/src/methods/filter_map_bool_then.rs
@@ -2,13 +2,13 @@ use super::FILTER_MAP_BOOL_THEN;
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::paths::BOOL_THEN;
 use clippy_utils::source::snippet_opt;
-use clippy_utils::ty::is_copy;
+use clippy_utils::ty::{is_copy, peel_mid_ty_refs_is_mutable};
 use clippy_utils::{is_from_proc_macro, is_trait_method, match_def_path, peel_blocks};
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_middle::ty::{self, Binder};
+use rustc_middle::ty::Binder;
 use rustc_span::{sym, Span};
 
 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, arg: &Expr<'_>, call_span: Span) {
@@ -36,7 +36,11 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, arg: &
         && let Some(def_id) = cx.typeck_results().type_dependent_def_id(value.hir_id)
         && match_def_path(cx, def_id, &BOOL_THEN)
         && !is_from_proc_macro(cx, expr)
-        && let ref_bool = matches!(cx.typeck_results().expr_ty(recv).kind(), ty::Ref(..))
+        // Peel all refs (e.g. `&&&&mut &&&bool` -> `bool`) and get its count so we can suggest the exact
+        // amount of derefs to get to the bool in the filter.
+        // `peel_mid_ty_refs` alone doesn't handle mutable reference, so we use `_is_mutable`
+        // instead which counts them too and just ignore the resulting mutability
+        && let (_, needed_derefs, _) = peel_mid_ty_refs_is_mutable(cx.typeck_results().expr_ty(recv))
         && let Some(param_snippet) = snippet_opt(cx, param.span)
         && let Some(filter) = snippet_opt(cx, recv.span)
         && let Some(map) = snippet_opt(cx, then_body.span)
@@ -47,7 +51,10 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, arg: &
             call_span,
             "usage of `bool::then` in `filter_map`",
             "use `filter` then `map` instead",
-            format!("filter(|&{param_snippet}| {}{filter}).map(|{param_snippet}| {map})", if ref_bool { "*" } else { "" }),
+            format!(
+                "filter(|&{param_snippet}| {derefs}{filter}).map(|{param_snippet}| {map})",
+                derefs="*".repeat(needed_derefs)
+            ),
             Applicability::MachineApplicable,
         );
     }
diff --git a/tests/ui/filter_map_bool_then.fixed b/tests/ui/filter_map_bool_then.fixed
index 67b984ce025..d1c946585f5 100644
--- a/tests/ui/filter_map_bool_then.fixed
+++ b/tests/ui/filter_map_bool_then.fixed
@@ -59,4 +59,12 @@ fn issue11309<'a>(iter: impl Iterator<Item = (&'a str, &'a str)>) -> Vec<&'a str
 fn issue11503() {
     let bools: &[bool] = &[true, false, false, true];
     let _: Vec<usize> = bools.iter().enumerate().filter(|&(i, b)| *b).map(|(i, b)| i).collect();
+
+    // Need to insert multiple derefs if there is more than one layer of references
+    let bools: &[&&bool] = &[&&true, &&false, &&false, &&true];
+    let _: Vec<usize> = bools.iter().enumerate().filter(|&(i, b)| ***b).map(|(i, b)| i).collect();
+
+    // Should also suggest derefs when going through a mutable reference
+    let bools: &[&mut bool] = &[&mut true];
+    let _: Vec<usize> = bools.iter().enumerate().filter(|&(i, b)| **b).map(|(i, b)| i).collect();
 }
diff --git a/tests/ui/filter_map_bool_then.rs b/tests/ui/filter_map_bool_then.rs
index b716fd70fa0..2d0ed282013 100644
--- a/tests/ui/filter_map_bool_then.rs
+++ b/tests/ui/filter_map_bool_then.rs
@@ -59,4 +59,12 @@ fn issue11309<'a>(iter: impl Iterator<Item = (&'a str, &'a str)>) -> Vec<&'a str
 fn issue11503() {
     let bools: &[bool] = &[true, false, false, true];
     let _: Vec<usize> = bools.iter().enumerate().filter_map(|(i, b)| b.then(|| i)).collect();
+
+    // Need to insert multiple derefs if there is more than one layer of references
+    let bools: &[&&bool] = &[&&true, &&false, &&false, &&true];
+    let _: Vec<usize> = bools.iter().enumerate().filter_map(|(i, b)| b.then(|| i)).collect();
+
+    // Should also suggest derefs when going through a mutable reference
+    let bools: &[&mut bool] = &[&mut true];
+    let _: Vec<usize> = bools.iter().enumerate().filter_map(|(i, b)| b.then(|| i)).collect();
 }
diff --git a/tests/ui/filter_map_bool_then.stderr b/tests/ui/filter_map_bool_then.stderr
index 1fee93afb36..174786ff32e 100644
--- a/tests/ui/filter_map_bool_then.stderr
+++ b/tests/ui/filter_map_bool_then.stderr
@@ -43,5 +43,17 @@ error: usage of `bool::then` in `filter_map`
 LL |     let _: Vec<usize> = bools.iter().enumerate().filter_map(|(i, b)| b.then(|| i)).collect();
    |                                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `filter` then `map` instead: `filter(|&(i, b)| *b).map(|(i, b)| i)`
 
-error: aborting due to 7 previous errors
+error: usage of `bool::then` in `filter_map`
+  --> $DIR/filter_map_bool_then.rs:65:50
+   |
+LL |     let _: Vec<usize> = bools.iter().enumerate().filter_map(|(i, b)| b.then(|| i)).collect();
+   |                                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `filter` then `map` instead: `filter(|&(i, b)| ***b).map(|(i, b)| i)`
+
+error: usage of `bool::then` in `filter_map`
+  --> $DIR/filter_map_bool_then.rs:69:50
+   |
+LL |     let _: Vec<usize> = bools.iter().enumerate().filter_map(|(i, b)| b.then(|| i)).collect();
+   |                                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `filter` then `map` instead: `filter(|&(i, b)| **b).map(|(i, b)| i)`
+
+error: aborting due to 9 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 2ec6f3b1ed22c3fa0b20eda5cf335c54f81b4462 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Sat, 16 Sep 2023 15:13:44 +0200
Subject: also count derefs through custom `Deref` impls

---
 clippy_lints/src/methods/filter_map_bool_then.rs | 13 +++++++------
 tests/ui/filter_map_bool_then.fixed              | 11 +++++++++++
 tests/ui/filter_map_bool_then.rs                 | 11 +++++++++++
 tests/ui/filter_map_bool_then.stderr             |  8 +++++++-
 4 files changed, 36 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/filter_map_bool_then.rs b/clippy_lints/src/methods/filter_map_bool_then.rs
index dd4aa276663..33657254965 100644
--- a/clippy_lints/src/methods/filter_map_bool_then.rs
+++ b/clippy_lints/src/methods/filter_map_bool_then.rs
@@ -2,12 +2,13 @@ use super::FILTER_MAP_BOOL_THEN;
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::paths::BOOL_THEN;
 use clippy_utils::source::snippet_opt;
-use clippy_utils::ty::{is_copy, peel_mid_ty_refs_is_mutable};
+use clippy_utils::ty::is_copy;
 use clippy_utils::{is_from_proc_macro, is_trait_method, match_def_path, peel_blocks};
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LintContext};
 use rustc_middle::lint::in_external_macro;
+use rustc_middle::ty::adjustment::Adjust;
 use rustc_middle::ty::Binder;
 use rustc_span::{sym, Span};
 
@@ -36,11 +37,11 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, arg: &
         && let Some(def_id) = cx.typeck_results().type_dependent_def_id(value.hir_id)
         && match_def_path(cx, def_id, &BOOL_THEN)
         && !is_from_proc_macro(cx, expr)
-        // Peel all refs (e.g. `&&&&mut &&&bool` -> `bool`) and get its count so we can suggest the exact
-        // amount of derefs to get to the bool in the filter.
-        // `peel_mid_ty_refs` alone doesn't handle mutable reference, so we use `_is_mutable`
-        // instead which counts them too and just ignore the resulting mutability
-        && let (_, needed_derefs, _) = peel_mid_ty_refs_is_mutable(cx.typeck_results().expr_ty(recv))
+        // Count the number of derefs needed to get to the bool because we need those in the suggestion
+        && let needed_derefs = cx.typeck_results().expr_adjustments(recv)
+            .iter()
+            .filter(|adj| matches!(adj.kind, Adjust::Deref(_)))
+            .count()
         && let Some(param_snippet) = snippet_opt(cx, param.span)
         && let Some(filter) = snippet_opt(cx, recv.span)
         && let Some(map) = snippet_opt(cx, then_body.span)
diff --git a/tests/ui/filter_map_bool_then.fixed b/tests/ui/filter_map_bool_then.fixed
index d1c946585f5..6a1b81fdbcb 100644
--- a/tests/ui/filter_map_bool_then.fixed
+++ b/tests/ui/filter_map_bool_then.fixed
@@ -67,4 +67,15 @@ fn issue11503() {
     // Should also suggest derefs when going through a mutable reference
     let bools: &[&mut bool] = &[&mut true];
     let _: Vec<usize> = bools.iter().enumerate().filter(|&(i, b)| **b).map(|(i, b)| i).collect();
+
+    // Should also suggest derefs when going through a custom deref
+    struct DerefToBool;
+    impl std::ops::Deref for DerefToBool {
+        type Target = bool;
+        fn deref(&self) -> &Self::Target {
+            &true
+        }
+    }
+    let bools: &[&&DerefToBool] = &[&&DerefToBool];
+    let _: Vec<usize> = bools.iter().enumerate().filter(|&(i, b)| ****b).map(|(i, b)| i).collect();
 }
diff --git a/tests/ui/filter_map_bool_then.rs b/tests/ui/filter_map_bool_then.rs
index 2d0ed282013..a41e88f8805 100644
--- a/tests/ui/filter_map_bool_then.rs
+++ b/tests/ui/filter_map_bool_then.rs
@@ -67,4 +67,15 @@ fn issue11503() {
     // Should also suggest derefs when going through a mutable reference
     let bools: &[&mut bool] = &[&mut true];
     let _: Vec<usize> = bools.iter().enumerate().filter_map(|(i, b)| b.then(|| i)).collect();
+
+    // Should also suggest derefs when going through a custom deref
+    struct DerefToBool;
+    impl std::ops::Deref for DerefToBool {
+        type Target = bool;
+        fn deref(&self) -> &Self::Target {
+            &true
+        }
+    }
+    let bools: &[&&DerefToBool] = &[&&DerefToBool];
+    let _: Vec<usize> = bools.iter().enumerate().filter_map(|(i, b)| b.then(|| i)).collect();
 }
diff --git a/tests/ui/filter_map_bool_then.stderr b/tests/ui/filter_map_bool_then.stderr
index 174786ff32e..fab6987913a 100644
--- a/tests/ui/filter_map_bool_then.stderr
+++ b/tests/ui/filter_map_bool_then.stderr
@@ -55,5 +55,11 @@ error: usage of `bool::then` in `filter_map`
 LL |     let _: Vec<usize> = bools.iter().enumerate().filter_map(|(i, b)| b.then(|| i)).collect();
    |                                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `filter` then `map` instead: `filter(|&(i, b)| **b).map(|(i, b)| i)`
 
-error: aborting due to 9 previous errors
+error: usage of `bool::then` in `filter_map`
+  --> $DIR/filter_map_bool_then.rs:80:50
+   |
+LL |     let _: Vec<usize> = bools.iter().enumerate().filter_map(|(i, b)| b.then(|| i)).collect();
+   |                                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `filter` then `map` instead: `filter(|&(i, b)| ****b).map(|(i, b)| i)`
+
+error: aborting due to 10 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 67f0ba4af8be42d361adc8d047121fe6c820c0d4 Mon Sep 17 00:00:00 2001
From: Chen Chen <0109chenchen@gmail.com>
Date: Sat, 16 Sep 2023 22:12:40 +0800
Subject: Update clippy_lints/src/matches/redundant_guards.rs
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

fix typo

Co-authored-by: Alejandra González <blyxyas@gmail.com>
---
 clippy_lints/src/matches/redundant_guards.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/redundant_guards.rs b/clippy_lints/src/matches/redundant_guards.rs
index d51d7edc8e3..d470c05f351 100644
--- a/clippy_lints/src/matches/redundant_guards.rs
+++ b/clippy_lints/src/matches/redundant_guards.rs
@@ -123,7 +123,7 @@ fn get_pat_binding<'tcx>(
                 if matches!(bind_annot.0, rustc_ast::ByRef::Yes) {
                     let _ = byref_ident.insert(ident);
                 }
-                // the second call of `replce()` returns a `Some(span)`, meaning a multi-binding pattern
+                // the second call of `replace()` returns a `Some(span)`, meaning a multi-binding pattern
                 if span.replace(pat.span).is_some() {
                     multiple_bindings = true;
                     return false;
-- 
cgit 1.4.1-3-g733a5


From af2a8478ba3228ede92ff799b17ac2408fc6347f Mon Sep 17 00:00:00 2001
From: mojave2 <chenchen145@huawei.com>
Date: Sat, 16 Sep 2023 23:17:47 +0800
Subject: fix cast_lossless with macro call

---
 clippy_lints/src/casts/cast_lossless.rs |  9 ++++++++-
 tests/ui/cast_lossless_integer.fixed    | 11 +++++++++++
 tests/ui/cast_lossless_integer.rs       | 11 +++++++++++
 tests/ui/cast_lossless_integer.stderr   | 14 +++++++++++++-
 4 files changed, 43 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/cast_lossless.rs b/clippy_lints/src/casts/cast_lossless.rs
index cf07e050ccc..2f3ffea6693 100644
--- a/clippy_lints/src/casts/cast_lossless.rs
+++ b/clippy_lints/src/casts/cast_lossless.rs
@@ -25,7 +25,14 @@ pub(super) fn check(
     // The suggestion is to use a function call, so if the original expression
     // has parens on the outside, they are no longer needed.
     let mut applicability = Applicability::MachineApplicable;
-    let opt = snippet_opt(cx, cast_op.span);
+    let opt = snippet_opt(
+        cx,
+        if cast_op.span.from_expansion() {
+            cast_op.span.source_callsite()
+        } else {
+            cast_op.span
+        },
+    );
     let sugg = opt.as_ref().map_or_else(
         || {
             applicability = Applicability::HasPlaceholders;
diff --git a/tests/ui/cast_lossless_integer.fixed b/tests/ui/cast_lossless_integer.fixed
index 6547107f500..5e7e545e764 100644
--- a/tests/ui/cast_lossless_integer.fixed
+++ b/tests/ui/cast_lossless_integer.fixed
@@ -49,3 +49,14 @@ mod cast_lossless_in_impl {
 enum Test {
     A = u32::MAX as i64 + 1,
 }
+
+fn issue11458() {
+    macro_rules! sign_cast {
+        ($var: ident, $src: ty, $dest: ty) => {
+            <$dest>::from_ne_bytes(($var as $src).to_ne_bytes())
+        };
+    }
+    let x = 10_u128;
+    let _ = i32::from(sign_cast!(x, u8, i8));
+    let _ = i32::from(sign_cast!(x, u8, i8) + 1);
+}
diff --git a/tests/ui/cast_lossless_integer.rs b/tests/ui/cast_lossless_integer.rs
index 79af9a83ca2..0d69ddbd586 100644
--- a/tests/ui/cast_lossless_integer.rs
+++ b/tests/ui/cast_lossless_integer.rs
@@ -49,3 +49,14 @@ mod cast_lossless_in_impl {
 enum Test {
     A = u32::MAX as i64 + 1,
 }
+
+fn issue11458() {
+    macro_rules! sign_cast {
+        ($var: ident, $src: ty, $dest: ty) => {
+            <$dest>::from_ne_bytes(($var as $src).to_ne_bytes())
+        };
+    }
+    let x = 10_u128;
+    let _ = sign_cast!(x, u8, i8) as i32;
+    let _ = (sign_cast!(x, u8, i8) + 1) as i32;
+}
diff --git a/tests/ui/cast_lossless_integer.stderr b/tests/ui/cast_lossless_integer.stderr
index da75cb195eb..f9f111a7c20 100644
--- a/tests/ui/cast_lossless_integer.stderr
+++ b/tests/ui/cast_lossless_integer.stderr
@@ -115,5 +115,17 @@ error: casting `u8` to `u16` may become silently lossy if you later change the t
 LL |     let _ = (1u8 + 1u8) as u16;
    |             ^^^^^^^^^^^^^^^^^^ help: try: `u16::from(1u8 + 1u8)`
 
-error: aborting due to 19 previous errors
+error: casting `i8` to `i32` may become silently lossy if you later change the type
+  --> $DIR/cast_lossless_integer.rs:60:13
+   |
+LL |     let _ = sign_cast!(x, u8, i8) as i32;
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `i32::from(sign_cast!(x, u8, i8))`
+
+error: casting `i8` to `i32` may become silently lossy if you later change the type
+  --> $DIR/cast_lossless_integer.rs:61:13
+   |
+LL |     let _ = (sign_cast!(x, u8, i8) + 1) as i32;
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `i32::from(sign_cast!(x, u8, i8) + 1)`
+
+error: aborting due to 21 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 3cad6237166dc71e2b75a9e60d5058f2876e1959 Mon Sep 17 00:00:00 2001
From: Chen Chen <0109chenchen@gmail.com>
Date: Sun, 17 Sep 2023 02:42:12 +0800
Subject: 更新 cast_lossless.rs
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Timo <30553356+y21@users.noreply.github.com>
---
 clippy_lints/src/casts/cast_lossless.rs | 9 +--------
 1 file changed, 1 insertion(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/cast_lossless.rs b/clippy_lints/src/casts/cast_lossless.rs
index 2f3ffea6693..c586b572be9 100644
--- a/clippy_lints/src/casts/cast_lossless.rs
+++ b/clippy_lints/src/casts/cast_lossless.rs
@@ -25,14 +25,7 @@ pub(super) fn check(
     // The suggestion is to use a function call, so if the original expression
     // has parens on the outside, they are no longer needed.
     let mut applicability = Applicability::MachineApplicable;
-    let opt = snippet_opt(
-        cx,
-        if cast_op.span.from_expansion() {
-            cast_op.span.source_callsite()
-        } else {
-            cast_op.span
-        },
-    );
+    let opt = snippet_opt(cx, cast_op.span.source_callsite());
     let sugg = opt.as_ref().map_or_else(
         || {
             applicability = Applicability::HasPlaceholders;
-- 
cgit 1.4.1-3-g733a5


From 5b790ff9e0effa9f742ce8a7b896a35c767fb131 Mon Sep 17 00:00:00 2001
From: mojave2 <chenchen145@huawei.com>
Date: Sun, 17 Sep 2023 12:54:00 +0800
Subject: fix FP with needless_raw_string_hashes

---
 clippy_lints/src/attrs.rs                  |  2 +-
 clippy_lints/src/raw_strings.rs            |  5 +++--
 tests/ui/needless_raw_string_hashes.fixed  |  3 +++
 tests/ui/needless_raw_string_hashes.rs     |  3 +++
 tests/ui/needless_raw_string_hashes.stderr | 26 +++++++++++++++++++++++++-
 5 files changed, 35 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs
index a88f2b51c82..0546807bac4 100644
--- a/clippy_lints/src/attrs.rs
+++ b/clippy_lints/src/attrs.rs
@@ -616,7 +616,7 @@ fn check_should_panic_reason(cx: &LateContext<'_>, attr: &Attribute) {
             attr.span,
             "#[should_panic] attribute without a reason",
             "consider specifying the expected panic",
-            r#"#[should_panic(expected = /* panic message */)]"#.into(),
+            "#[should_panic(expected = /* panic message */)]".into(),
             Applicability::HasPlaceholders,
         );
     }
diff --git a/clippy_lints/src/raw_strings.rs b/clippy_lints/src/raw_strings.rs
index a4fe501f79c..3db9f7541e5 100644
--- a/clippy_lints/src/raw_strings.rs
+++ b/clippy_lints/src/raw_strings.rs
@@ -96,8 +96,9 @@ impl EarlyLintPass for RawStrings {
                         );
                     },
                 );
-
-                return;
+                if !matches!(cx.get_lint_level(NEEDLESS_RAW_STRINGS), rustc_lint::Allow) {
+                    return;
+                }
             }
 
             let req = {
diff --git a/tests/ui/needless_raw_string_hashes.fixed b/tests/ui/needless_raw_string_hashes.fixed
index e980adeeff4..c99c2f46532 100644
--- a/tests/ui/needless_raw_string_hashes.fixed
+++ b/tests/ui/needless_raw_string_hashes.fixed
@@ -21,4 +21,7 @@ fn main() {
         multiline
         string
     ";
+
+    r"rust";
+    r"hello world";
 }
diff --git a/tests/ui/needless_raw_string_hashes.rs b/tests/ui/needless_raw_string_hashes.rs
index 6113c5f25ae..dcc2af69f4e 100644
--- a/tests/ui/needless_raw_string_hashes.rs
+++ b/tests/ui/needless_raw_string_hashes.rs
@@ -21,4 +21,7 @@ fn main() {
         multiline
         string
     "#;
+
+    r###"rust"###;
+    r#"hello world"#;
 }
diff --git a/tests/ui/needless_raw_string_hashes.stderr b/tests/ui/needless_raw_string_hashes.stderr
index 5a8e3d04543..4399c6555c2 100644
--- a/tests/ui/needless_raw_string_hashes.stderr
+++ b/tests/ui/needless_raw_string_hashes.stderr
@@ -163,5 +163,29 @@ LL |         string
 LL ~     ";
    |
 
-error: aborting due to 13 previous errors
+error: unnecessary hashes around raw string literal
+  --> $DIR/needless_raw_string_hashes.rs:25:5
+   |
+LL |     r###"rust"###;
+   |     ^^^^^^^^^^^^^
+   |
+help: remove all the hashes around the literal
+   |
+LL -     r###"rust"###;
+LL +     r"rust";
+   |
+
+error: unnecessary hashes around raw string literal
+  --> $DIR/needless_raw_string_hashes.rs:26:5
+   |
+LL |     r#"hello world"#;
+   |     ^^^^^^^^^^^^^^^^
+   |
+help: remove all the hashes around the literal
+   |
+LL -     r#"hello world"#;
+LL +     r"hello world";
+   |
+
+error: aborting due to 15 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 3665a4102bce2cd6b09a7aea1b405cc640e076d8 Mon Sep 17 00:00:00 2001
From: mojave2 <chenchen145@huawei.com>
Date: Sun, 17 Sep 2023 19:44:25 +0800
Subject: fix ICE by `u64::try_from(<u128>)`

---
 clippy_lints/src/casts/cast_possible_truncation.rs | 2 +-
 tests/ui/cast.rs                                   | 4 ++++
 2 files changed, 5 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/cast_possible_truncation.rs b/clippy_lints/src/casts/cast_possible_truncation.rs
index 84b99ad5c24..f99a51e2b88 100644
--- a/clippy_lints/src/casts/cast_possible_truncation.rs
+++ b/clippy_lints/src/casts/cast_possible_truncation.rs
@@ -44,7 +44,7 @@ fn apply_reductions(cx: &LateContext<'_>, nbits: u64, expr: &Expr<'_>, signed: b
                 .unwrap_or(u64::max_value())
                 .min(apply_reductions(cx, nbits, left, signed)),
             BinOpKind::Shr => apply_reductions(cx, nbits, left, signed)
-                .saturating_sub(constant_int(cx, right).map_or(0, |s| u64::try_from(s).expect("shift too high"))),
+                .saturating_sub(constant_int(cx, right).map_or(0, |s| u64::try_from(s).unwrap_or_default())),
             _ => nbits,
         },
         ExprKind::MethodCall(method, left, [right], _) => {
diff --git a/tests/ui/cast.rs b/tests/ui/cast.rs
index d0a092093f3..1ca18170f8a 100644
--- a/tests/ui/cast.rs
+++ b/tests/ui/cast.rs
@@ -361,3 +361,7 @@ fn avoid_subtract_overflow(q: u32) {
     //~^ ERROR: casting `u32` to `u8` may truncate the value
     c as usize;
 }
+
+fn issue11426() {
+    (&42u8 >> 0xa9008fb6c9d81e42_0e25730562a601c8_u128) as usize;
+}
-- 
cgit 1.4.1-3-g733a5


From 558ae4c6a8a5a81c5b0cb3c7828e622201ba33ee Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Sun, 17 Sep 2023 15:34:32 +0200
Subject: [`redundant_guards`]: lint if the pattern is on the LHS

---
 clippy_lints/src/matches/redundant_guards.rs |  9 ++++-
 tests/ui/redundant_guards.fixed              |  9 +++++
 tests/ui/redundant_guards.rs                 |  9 +++++
 tests/ui/redundant_guards.stderr             | 56 +++++++++++++++++++++++-----
 4 files changed, 71 insertions(+), 12 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/redundant_guards.rs b/clippy_lints/src/matches/redundant_guards.rs
index d470c05f351..0efeeacc9d9 100644
--- a/clippy_lints/src/matches/redundant_guards.rs
+++ b/clippy_lints/src/matches/redundant_guards.rs
@@ -70,10 +70,10 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'tcx>]) {
             );
         }
         // `Some(x) if x == Some(2)`
+        // `Some(x) if Some(2) == x`
         else if let Guard::If(if_expr) = guard
             && let ExprKind::Binary(bin_op, local, pat) = if_expr.kind
             && matches!(bin_op.node, BinOpKind::Eq)
-            && expr_can_be_pat(cx, pat)
             // Ensure they have the same type. If they don't, we'd need deref coercion which isn't
             // possible (currently) in a pattern. In some cases, you can use something like
             // `as_deref` or similar but in general, we shouldn't lint this as it'd create an
@@ -81,7 +81,12 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'tcx>]) {
             //
             // This isn't necessary in the other two checks, as they must be a pattern already.
             && cx.typeck_results().expr_ty(local) == cx.typeck_results().expr_ty(pat)
-            && let Some(binding) = get_pat_binding(cx, local, outer_arm)
+            // Since we want to lint on both `x == Some(2)` and `Some(2) == x`, we might have to "swap"
+            // `local` and `pat`, depending on which side they are.
+            && let Some((binding, pat)) = get_pat_binding(cx, local, outer_arm)
+                .map(|binding| (binding, pat))
+                .or_else(|| get_pat_binding(cx, pat, outer_arm).map(|binding| (binding, local)))
+            && expr_can_be_pat(cx, pat)
         {
             let pat_span = match (pat.kind, binding.byref_ident) {
                 (ExprKind::AddrOf(BorrowKind::Ref, _, expr), Some(_)) => expr.span,
diff --git a/tests/ui/redundant_guards.fixed b/tests/ui/redundant_guards.fixed
index 20fcc1254a6..f23116a7e1c 100644
--- a/tests/ui/redundant_guards.fixed
+++ b/tests/ui/redundant_guards.fixed
@@ -43,6 +43,7 @@ fn main() {
         },
         Some(Some(1)) => ..,
         Some(Some(2)) => ..,
+        Some(Some(2)) => ..,
         // Don't lint, since x is used in the body
         Some(x) if let Some(1) = x => {
             x;
@@ -56,11 +57,13 @@ fn main() {
         Some(x) if matches!(y, 1 if true) => ..,
         Some(x) if let 1 = y => ..,
         Some(x) if y == 2 => ..,
+        Some(x) if 2 == y => ..,
         _ => todo!(),
     };
     let a = A(1);
     match a {
         _ if a.0 == 1 => {},
+        _ if 1 == a.0 => {},
         _ => todo!(),
     }
     let b = B { e: Some(A(0)) };
@@ -119,6 +122,7 @@ fn h(v: Option<u32>) {
 fn f(s: Option<std::ffi::OsString>) {
     match s {
         Some(x) if x == "a" => {},
+        Some(x) if "a" == x => {},
         _ => {},
     }
 }
@@ -140,6 +144,7 @@ static CONST_S: S = S { a: 1 };
 fn g(opt_s: Option<S>) {
     match opt_s {
         Some(x) if x == CONST_S => {},
+        Some(x) if CONST_S == x => {},
         _ => {},
     }
 }
@@ -157,6 +162,7 @@ mod issue11465 {
     fn issue11465() {
         let c = Some(1);
         match c {
+            Some(1) => {},
             Some(1) => {},
             Some(2) => {},
             Some(3) => {},
@@ -166,6 +172,7 @@ mod issue11465 {
         let enum_a = A::Foo([98, 97, 114]);
         match enum_a {
             A::Foo(ref arr) if arr == b"foo" => {},
+            A::Foo(ref arr) if b"foo" == arr => {},
             A::Foo(ref arr) if let b"bar" = arr => {},
             A::Foo(ref arr) if matches!(arr, b"baz") => {},
             _ => {},
@@ -177,6 +184,8 @@ mod issue11465 {
         };
         match struct_b {
             B { ref b, .. } if b == "bar" => {},
+            B { ref b, .. } if "bar" == b => {},
+            B { c: 1, .. } => {},
             B { c: 1, .. } => {},
             B { c: 1, .. } => {},
             B { c: 1, .. } => {},
diff --git a/tests/ui/redundant_guards.rs b/tests/ui/redundant_guards.rs
index e63cd29e8af..c0206b4cec7 100644
--- a/tests/ui/redundant_guards.rs
+++ b/tests/ui/redundant_guards.rs
@@ -43,6 +43,7 @@ fn main() {
         },
         Some(x) if let Some(1) = x => ..,
         Some(x) if x == Some(2) => ..,
+        Some(x) if Some(2) == x => ..,
         // Don't lint, since x is used in the body
         Some(x) if let Some(1) = x => {
             x;
@@ -56,11 +57,13 @@ fn main() {
         Some(x) if matches!(y, 1 if true) => ..,
         Some(x) if let 1 = y => ..,
         Some(x) if y == 2 => ..,
+        Some(x) if 2 == y => ..,
         _ => todo!(),
     };
     let a = A(1);
     match a {
         _ if a.0 == 1 => {},
+        _ if 1 == a.0 => {},
         _ => todo!(),
     }
     let b = B { e: Some(A(0)) };
@@ -119,6 +122,7 @@ fn h(v: Option<u32>) {
 fn f(s: Option<std::ffi::OsString>) {
     match s {
         Some(x) if x == "a" => {},
+        Some(x) if "a" == x => {},
         _ => {},
     }
 }
@@ -140,6 +144,7 @@ static CONST_S: S = S { a: 1 };
 fn g(opt_s: Option<S>) {
     match opt_s {
         Some(x) if x == CONST_S => {},
+        Some(x) if CONST_S == x => {},
         _ => {},
     }
 }
@@ -158,6 +163,7 @@ mod issue11465 {
         let c = Some(1);
         match c {
             Some(ref x) if x == &1 => {},
+            Some(ref x) if &1 == x => {},
             Some(ref x) if let &2 = x => {},
             Some(ref x) if matches!(x, &3) => {},
             _ => {},
@@ -166,6 +172,7 @@ mod issue11465 {
         let enum_a = A::Foo([98, 97, 114]);
         match enum_a {
             A::Foo(ref arr) if arr == b"foo" => {},
+            A::Foo(ref arr) if b"foo" == arr => {},
             A::Foo(ref arr) if let b"bar" = arr => {},
             A::Foo(ref arr) if matches!(arr, b"baz") => {},
             _ => {},
@@ -177,7 +184,9 @@ mod issue11465 {
         };
         match struct_b {
             B { ref b, .. } if b == "bar" => {},
+            B { ref b, .. } if "bar" == b => {},
             B { ref c, .. } if c == &1 => {},
+            B { ref c, .. } if &1 == c => {},
             B { ref c, .. } if let &1 = c => {},
             B { ref c, .. } if matches!(c, &1) => {},
             _ => {},
diff --git a/tests/ui/redundant_guards.stderr b/tests/ui/redundant_guards.stderr
index f208e556f2e..b8d7834e358 100644
--- a/tests/ui/redundant_guards.stderr
+++ b/tests/ui/redundant_guards.stderr
@@ -60,7 +60,19 @@ LL +         Some(Some(2)) => ..,
    |
 
 error: redundant guard
-  --> $DIR/redundant_guards.rs:68:20
+  --> $DIR/redundant_guards.rs:46:20
+   |
+LL |         Some(x) if Some(2) == x => ..,
+   |                    ^^^^^^^^^^^^
+   |
+help: try
+   |
+LL -         Some(x) if Some(2) == x => ..,
+LL +         Some(Some(2)) => ..,
+   |
+
+error: redundant guard
+  --> $DIR/redundant_guards.rs:71:20
    |
 LL |         B { e } if matches!(e, Some(A(2))) => ..,
    |                    ^^^^^^^^^^^^^^^^^^^^^^^
@@ -72,7 +84,7 @@ LL +         B { e: Some(A(2)) } => ..,
    |
 
 error: redundant guard
-  --> $DIR/redundant_guards.rs:105:20
+  --> $DIR/redundant_guards.rs:108:20
    |
 LL |         E::A(y) if y == "not from an or pattern" => {},
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -84,7 +96,7 @@ LL +         E::A("not from an or pattern") => {},
    |
 
 error: redundant guard
-  --> $DIR/redundant_guards.rs:112:14
+  --> $DIR/redundant_guards.rs:115:14
    |
 LL |         x if matches!(x, Some(0)) => ..,
    |              ^^^^^^^^^^^^^^^^^^^^
@@ -96,7 +108,7 @@ LL +         Some(0) => ..,
    |
 
 error: redundant guard
-  --> $DIR/redundant_guards.rs:160:28
+  --> $DIR/redundant_guards.rs:165:28
    |
 LL |             Some(ref x) if x == &1 => {},
    |                            ^^^^^^^
@@ -108,7 +120,19 @@ LL +             Some(1) => {},
    |
 
 error: redundant guard
-  --> $DIR/redundant_guards.rs:161:28
+  --> $DIR/redundant_guards.rs:166:28
+   |
+LL |             Some(ref x) if &1 == x => {},
+   |                            ^^^^^^^
+   |
+help: try
+   |
+LL -             Some(ref x) if &1 == x => {},
+LL +             Some(1) => {},
+   |
+
+error: redundant guard
+  --> $DIR/redundant_guards.rs:167:28
    |
 LL |             Some(ref x) if let &2 = x => {},
    |                            ^^^^^^^^^^
@@ -120,7 +144,7 @@ LL +             Some(2) => {},
    |
 
 error: redundant guard
-  --> $DIR/redundant_guards.rs:162:28
+  --> $DIR/redundant_guards.rs:168:28
    |
 LL |             Some(ref x) if matches!(x, &3) => {},
    |                            ^^^^^^^^^^^^^^^
@@ -132,7 +156,7 @@ LL +             Some(3) => {},
    |
 
 error: redundant guard
-  --> $DIR/redundant_guards.rs:180:32
+  --> $DIR/redundant_guards.rs:188:32
    |
 LL |             B { ref c, .. } if c == &1 => {},
    |                                ^^^^^^^
@@ -144,7 +168,19 @@ LL +             B { c: 1, .. } => {},
    |
 
 error: redundant guard
-  --> $DIR/redundant_guards.rs:181:32
+  --> $DIR/redundant_guards.rs:189:32
+   |
+LL |             B { ref c, .. } if &1 == c => {},
+   |                                ^^^^^^^
+   |
+help: try
+   |
+LL -             B { ref c, .. } if &1 == c => {},
+LL +             B { c: 1, .. } => {},
+   |
+
+error: redundant guard
+  --> $DIR/redundant_guards.rs:190:32
    |
 LL |             B { ref c, .. } if let &1 = c => {},
    |                                ^^^^^^^^^^
@@ -156,7 +192,7 @@ LL +             B { c: 1, .. } => {},
    |
 
 error: redundant guard
-  --> $DIR/redundant_guards.rs:182:32
+  --> $DIR/redundant_guards.rs:191:32
    |
 LL |             B { ref c, .. } if matches!(c, &1) => {},
    |                                ^^^^^^^^^^^^^^^
@@ -167,5 +203,5 @@ LL -             B { ref c, .. } if matches!(c, &1) => {},
 LL +             B { c: 1, .. } => {},
    |
 
-error: aborting due to 14 previous errors
+error: aborting due to 17 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 79247d95f7ec00019cc26db20a07d4f1c1f335aa Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Fri, 15 Sep 2023 07:07:34 -0400
Subject: Split part of  `needless_borrow` into
 `needless_borrows_for_generic_args`

---
 CHANGELOG.md                                       |   1 +
 clippy_lints/src/declared_lints.rs                 |   1 +
 clippy_lints/src/dereference.rs                    | 371 +------------------
 clippy_lints/src/lib.rs                            |   8 +-
 .../src/needless_borrows_for_generic_args.rs       | 410 +++++++++++++++++++++
 tests/ui/needless_borrow.fixed                     | 290 ---------------
 tests/ui/needless_borrow.rs                        | 290 ---------------
 tests/ui/needless_borrow.stderr                    |  90 +----
 tests/ui/needless_borrows_for_generic_args.fixed   | 287 +++++++++++++++
 tests/ui/needless_borrows_for_generic_args.rs      | 287 +++++++++++++++
 tests/ui/needless_borrows_for_generic_args.stderr  |  77 ++++
 tests/ui/regex.rs                                  |   3 +-
 tests/ui/regex.stderr                              |  48 +--
 tests/ui/unnecessary_to_owned.fixed                |   2 +-
 tests/ui/unnecessary_to_owned.rs                   |   2 +-
 15 files changed, 1106 insertions(+), 1061 deletions(-)
 create mode 100644 clippy_lints/src/needless_borrows_for_generic_args.rs
 create mode 100644 tests/ui/needless_borrows_for_generic_args.fixed
 create mode 100644 tests/ui/needless_borrows_for_generic_args.rs
 create mode 100644 tests/ui/needless_borrows_for_generic_args.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9aca13a6cf6..3717b15ac5c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5171,6 +5171,7 @@ Released 2018-09-13
 [`needless_bool_assign`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_bool_assign
 [`needless_borrow`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow
 [`needless_borrowed_reference`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrowed_reference
+[`needless_borrows_for_generic_args`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrows_for_generic_args
 [`needless_collect`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_collect
 [`needless_continue`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_continue
 [`needless_doctest_main`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_doctest_main
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index ecf44e05920..c4d5bee389e 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -479,6 +479,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::needless_bool::NEEDLESS_BOOL_INFO,
     crate::needless_bool::NEEDLESS_BOOL_ASSIGN_INFO,
     crate::needless_borrowed_ref::NEEDLESS_BORROWED_REFERENCE_INFO,
+    crate::needless_borrows_for_generic_args::NEEDLESS_BORROWS_FOR_GENERIC_ARGS_INFO,
     crate::needless_continue::NEEDLESS_CONTINUE_INFO,
     crate::needless_else::NEEDLESS_ELSE_INFO,
     crate::needless_for_each::NEEDLESS_FOR_EACH_INFO,
diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index d0a898adff4..aa80d60a4b1 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -1,40 +1,24 @@
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_hir_and_then};
-use clippy_utils::mir::{enclosing_mir, expr_local, local_assignments, used_exactly_once, PossibleBorrowerMap};
-use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::{snippet_with_applicability, snippet_with_context};
 use clippy_utils::sugg::has_enclosing_paren;
-use clippy_utils::ty::{implements_trait, is_copy, peel_mid_ty_refs};
+use clippy_utils::ty::{implements_trait, peel_mid_ty_refs};
 use clippy_utils::{
     expr_use_ctxt, get_parent_expr, get_parent_node, is_lint_allowed, path_to_local, DefinedTy, ExprUseNode,
 };
-
-use hir::def::DefKind;
-use hir::MatchSource;
 use rustc_ast::util::parser::{PREC_POSTFIX, PREC_PREFIX};
 use rustc_data_structures::fx::FxIndexMap;
 use rustc_errors::Applicability;
-use rustc_hir::def::Res;
-use rustc_hir::def_id::{DefId, LocalDefId};
 use rustc_hir::intravisit::{walk_ty, Visitor};
 use rustc_hir::{
-    self as hir, BindingAnnotation, Body, BodyId, BorrowKind, Expr, ExprKind, HirId, Mutability, Node, Pat, PatKind,
-    Path, QPath, TyKind, UnOp,
+    self as hir, BindingAnnotation, Body, BodyId, BorrowKind, Expr, ExprKind, HirId, MatchSource, Mutability, Node,
+    Pat, PatKind, Path, QPath, TyKind, UnOp,
 };
-use rustc_index::bit_set::BitSet;
-use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::mir::{Rvalue, StatementKind};
 use rustc_middle::ty::adjustment::{Adjust, Adjustment, AutoBorrow, AutoBorrowMutability};
-use rustc_middle::ty::{
-    self, ClauseKind, EarlyBinder, FnSig, GenericArg, GenericArgKind, List, ParamEnv, ParamTy, ProjectionPredicate, Ty,
-    TyCtxt, TypeVisitableExt, TypeckResults,
-};
+use rustc_middle::ty::{self, ParamEnv, Ty, TyCtxt, TypeVisitableExt, TypeckResults};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::symbol::sym;
 use rustc_span::{Span, Symbol};
-use rustc_trait_selection::traits::query::evaluate_obligation::InferCtxtExt as _;
-use rustc_trait_selection::traits::{Obligation, ObligationCause};
-use std::collections::VecDeque;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -182,24 +166,6 @@ pub struct Dereferencing<'tcx> {
     ///
     /// e.g. `m!(x) | Foo::Bar(ref x)`
     ref_locals: FxIndexMap<HirId, Option<RefPat>>,
-
-    /// Stack of (body owner, `PossibleBorrowerMap`) pairs. Used by
-    /// `needless_borrow_impl_arg_position` to determine when a borrowed expression can instead
-    /// be moved.
-    possible_borrowers: Vec<(LocalDefId, PossibleBorrowerMap<'tcx, 'tcx>)>,
-
-    // `IntoIterator` for arrays requires Rust 1.53.
-    msrv: Msrv,
-}
-
-impl<'tcx> Dereferencing<'tcx> {
-    #[must_use]
-    pub fn new(msrv: Msrv) -> Self {
-        Self {
-            msrv,
-            ..Dereferencing::default()
-        }
-    }
 }
 
 #[derive(Debug)]
@@ -354,52 +320,6 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing<'tcx> {
                         ));
                     },
                     (Some(use_cx), RefOp::AddrOf(mutability)) => {
-                        let defined_ty = use_cx.node.defined_ty(cx);
-
-                        // Check needless_borrow for generic arguments.
-                        if !use_cx.is_ty_unified
-                            && let Some(DefinedTy::Mir(ty)) = defined_ty
-                            && let ty::Param(ty) = *ty.value.skip_binder().kind()
-                            && let Some((hir_id, fn_id, i)) = match use_cx.node {
-                                ExprUseNode::MethodArg(_, _, 0) => None,
-                                ExprUseNode::MethodArg(hir_id, None, i) => {
-                                    typeck.type_dependent_def_id(hir_id).map(|id| (hir_id, id, i))
-                                },
-                                ExprUseNode::FnArg(&Expr { kind: ExprKind::Path(ref p), hir_id, .. }, i)
-                                if !path_has_args(p) => match typeck.qpath_res(p, hir_id) {
-                                    Res::Def(DefKind::Fn | DefKind::Ctor(..) | DefKind::AssocFn, id) => {
-                                        Some((hir_id, id, i))
-                                    },
-                                    _ => None,
-                                },
-                                _ => None,
-                            } && let count = needless_borrow_generic_arg_count(
-                                cx,
-                                &mut self.possible_borrowers,
-                                fn_id,
-                                typeck.node_args(hir_id),
-                                i,
-                                ty,
-                                expr,
-                                &self.msrv,
-                            ) && count != 0
-                        {
-                            self.state = Some((
-                                State::DerefedBorrow(DerefedBorrow {
-                                    count: count - 1,
-                                    msg: "the borrowed expression implements the required traits",
-                                    stability: TyCoercionStability::None,
-                                    for_field_access: None,
-                                }),
-                                StateData {
-                                    span: expr.span,
-                                    hir_id: expr.hir_id,
-                                    adjusted_ty: use_cx.adjustments.last().map_or(expr_ty, |a| a.target),
-                                },
-                            ));
-                            return;
-                        }
-
                         // Find the number of times the borrow is auto-derefed.
                         let mut iter = use_cx.adjustments.iter();
                         let mut deref_count = 0usize;
@@ -418,7 +338,7 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing<'tcx> {
                             };
                         };
 
-                        let stability = defined_ty.map_or(TyCoercionStability::None, |ty| {
+                        let stability = use_cx.node.defined_ty(cx).map_or(TyCoercionStability::None, |ty| {
                             TyCoercionStability::for_defined_ty(cx, ty, use_cx.node.is_return())
                         });
                         let can_auto_borrow = match use_cx.node {
@@ -699,12 +619,6 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing<'tcx> {
     }
 
     fn check_body_post(&mut self, cx: &LateContext<'tcx>, body: &'tcx Body<'_>) {
-        if self.possible_borrowers.last().map_or(false, |&(local_def_id, _)| {
-            local_def_id == cx.tcx.hir().body_owner_def_id(body.id())
-        }) {
-            self.possible_borrowers.pop();
-        }
-
         if Some(body.id()) == self.current_body {
             for pat in self.ref_locals.drain(..).filter_map(|(_, x)| x) {
                 let replacements = pat.replacements;
@@ -728,8 +642,6 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing<'tcx> {
             self.current_body = None;
         }
     }
-
-    extract_msrv_attr!(LateContext);
 }
 
 fn try_parse_ref_op<'tcx>(
@@ -787,13 +699,6 @@ fn deref_method_same_type<'tcx>(result_ty: Ty<'tcx>, arg_ty: Ty<'tcx>) -> bool {
     }
 }
 
-fn path_has_args(p: &QPath<'_>) -> bool {
-    match *p {
-        QPath::Resolved(_, Path { segments: [.., s], .. }) | QPath::TypeRelative(_, s) => s.args.is_some(),
-        _ => false,
-    }
-}
-
 fn in_postfix_position<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'tcx>) -> bool {
     if let Some(parent) = get_parent_expr(cx, e)
         && parent.span.ctxt() == e.span.ctxt()
@@ -980,272 +885,6 @@ fn ty_contains_infer(ty: &hir::Ty<'_>) -> bool {
     v.0
 }
 
-/// Checks for the number of borrow expressions which can be removed from the given expression
-/// where the expression is used as an argument to a function expecting a generic type.
-///
-/// The following constraints will be checked:
-/// * The borrowed expression meets all the generic type's constraints.
-/// * The generic type appears only once in the functions signature.
-/// * The borrowed value will not be moved if it is used later in the function.
-#[expect(clippy::too_many_arguments)]
-fn needless_borrow_generic_arg_count<'tcx>(
-    cx: &LateContext<'tcx>,
-    possible_borrowers: &mut Vec<(LocalDefId, PossibleBorrowerMap<'tcx, 'tcx>)>,
-    fn_id: DefId,
-    callee_args: &'tcx List<GenericArg<'tcx>>,
-    arg_index: usize,
-    param_ty: ParamTy,
-    mut expr: &Expr<'tcx>,
-    msrv: &Msrv,
-) -> usize {
-    let destruct_trait_def_id = cx.tcx.lang_items().destruct_trait();
-    let sized_trait_def_id = cx.tcx.lang_items().sized_trait();
-
-    let fn_sig = cx.tcx.fn_sig(fn_id).instantiate_identity().skip_binder();
-    let predicates = cx.tcx.param_env(fn_id).caller_bounds();
-    let projection_predicates = predicates
-        .iter()
-        .filter_map(|predicate| {
-            if let ClauseKind::Projection(projection_predicate) = predicate.kind().skip_binder() {
-                Some(projection_predicate)
-            } else {
-                None
-            }
-        })
-        .collect::<Vec<_>>();
-
-    let mut trait_with_ref_mut_self_method = false;
-
-    // If no traits were found, or only the `Destruct`, `Sized`, or `Any` traits were found, return.
-    if predicates
-        .iter()
-        .filter_map(|predicate| {
-            if let ClauseKind::Trait(trait_predicate) = predicate.kind().skip_binder()
-                && trait_predicate.trait_ref.self_ty() == param_ty.to_ty(cx.tcx)
-            {
-                Some(trait_predicate.trait_ref.def_id)
-            } else {
-                None
-            }
-        })
-        .inspect(|trait_def_id| {
-            trait_with_ref_mut_self_method |= has_ref_mut_self_method(cx, *trait_def_id);
-        })
-        .all(|trait_def_id| {
-            Some(trait_def_id) == destruct_trait_def_id
-                || Some(trait_def_id) == sized_trait_def_id
-                || cx.tcx.is_diagnostic_item(sym::Any, trait_def_id)
-        })
-    {
-        return 0;
-    }
-
-    // See:
-    // - https://github.com/rust-lang/rust-clippy/pull/9674#issuecomment-1289294201
-    // - https://github.com/rust-lang/rust-clippy/pull/9674#issuecomment-1292225232
-    if projection_predicates
-        .iter()
-        .any(|projection_predicate| is_mixed_projection_predicate(cx, fn_id, projection_predicate))
-    {
-        return 0;
-    }
-
-    // `args_with_referent_ty` can be constructed outside of `check_referent` because the same
-    // elements are modified each time `check_referent` is called.
-    let mut args_with_referent_ty = callee_args.to_vec();
-
-    let mut check_reference_and_referent = |reference, referent| {
-        let referent_ty = cx.typeck_results().expr_ty(referent);
-
-        if !is_copy(cx, referent_ty)
-            && (referent_ty.has_significant_drop(cx.tcx, cx.param_env)
-                || !referent_used_exactly_once(cx, possible_borrowers, reference))
-        {
-            return false;
-        }
-
-        // https://github.com/rust-lang/rust-clippy/pull/9136#pullrequestreview-1037379321
-        if trait_with_ref_mut_self_method && !matches!(referent_ty.kind(), ty::Ref(_, _, Mutability::Mut)) {
-            return false;
-        }
-
-        if !replace_types(
-            cx,
-            param_ty,
-            referent_ty,
-            fn_sig,
-            arg_index,
-            &projection_predicates,
-            &mut args_with_referent_ty,
-        ) {
-            return false;
-        }
-
-        predicates.iter().all(|predicate| {
-            if let ClauseKind::Trait(trait_predicate) = predicate.kind().skip_binder()
-                && cx.tcx.is_diagnostic_item(sym::IntoIterator, trait_predicate.trait_ref.def_id)
-                && let ty::Param(param_ty) = trait_predicate.self_ty().kind()
-                && let GenericArgKind::Type(ty) = args_with_referent_ty[param_ty.index as usize].unpack()
-                && ty.is_array()
-                && !msrv.meets(msrvs::ARRAY_INTO_ITERATOR)
-            {
-                return false;
-            }
-
-            let predicate = EarlyBinder::bind(predicate).instantiate(cx.tcx, &args_with_referent_ty);
-            let obligation = Obligation::new(cx.tcx, ObligationCause::dummy(), cx.param_env, predicate);
-            let infcx = cx.tcx.infer_ctxt().build();
-            infcx.predicate_must_hold_modulo_regions(&obligation)
-        })
-    };
-
-    let mut count = 0;
-    while let ExprKind::AddrOf(_, _, referent) = expr.kind {
-        if !check_reference_and_referent(expr, referent) {
-            break;
-        }
-        expr = referent;
-        count += 1;
-    }
-    count
-}
-
-fn has_ref_mut_self_method(cx: &LateContext<'_>, trait_def_id: DefId) -> bool {
-    cx.tcx
-        .associated_items(trait_def_id)
-        .in_definition_order()
-        .any(|assoc_item| {
-            if assoc_item.fn_has_self_parameter {
-                let self_ty = cx
-                    .tcx
-                    .fn_sig(assoc_item.def_id)
-                    .instantiate_identity()
-                    .skip_binder()
-                    .inputs()[0];
-                matches!(self_ty.kind(), ty::Ref(_, _, Mutability::Mut))
-            } else {
-                false
-            }
-        })
-}
-
-fn is_mixed_projection_predicate<'tcx>(
-    cx: &LateContext<'tcx>,
-    callee_def_id: DefId,
-    projection_predicate: &ProjectionPredicate<'tcx>,
-) -> bool {
-    let generics = cx.tcx.generics_of(callee_def_id);
-    // The predicate requires the projected type to equal a type parameter from the parent context.
-    if let Some(term_ty) = projection_predicate.term.ty()
-        && let ty::Param(term_param_ty) = term_ty.kind()
-        && (term_param_ty.index as usize) < generics.parent_count
-    {
-        // The inner-most self type is a type parameter from the current function.
-        let mut projection_ty = projection_predicate.projection_ty;
-        loop {
-            match projection_ty.self_ty().kind() {
-                ty::Alias(ty::Projection, inner_projection_ty) => {
-                    projection_ty = *inner_projection_ty;
-                }
-                ty::Param(param_ty) => {
-                    return (param_ty.index as usize) >= generics.parent_count;
-                }
-                _ => {
-                    return false;
-                }
-            }
-        }
-    } else {
-        false
-    }
-}
-
-fn referent_used_exactly_once<'tcx>(
-    cx: &LateContext<'tcx>,
-    possible_borrowers: &mut Vec<(LocalDefId, PossibleBorrowerMap<'tcx, 'tcx>)>,
-    reference: &Expr<'tcx>,
-) -> bool {
-    if let Some(mir) = enclosing_mir(cx.tcx, reference.hir_id)
-        && let Some(local) = expr_local(cx.tcx, reference)
-        && let [location] = *local_assignments(mir, local).as_slice()
-        && let Some(statement) = mir.basic_blocks[location.block].statements.get(location.statement_index)
-        && let StatementKind::Assign(box (_, Rvalue::Ref(_, _, place))) = statement.kind
-        && !place.is_indirect_first_projection()
-    {
-        let body_owner_local_def_id = cx.tcx.hir().enclosing_body_owner(reference.hir_id);
-        if possible_borrowers
-            .last()
-            .map_or(true, |&(local_def_id, _)| local_def_id != body_owner_local_def_id)
-        {
-            possible_borrowers.push((body_owner_local_def_id, PossibleBorrowerMap::new(cx, mir)));
-        }
-        let possible_borrower = &mut possible_borrowers.last_mut().unwrap().1;
-        // If `only_borrowers` were used here, the `copyable_iterator::warn` test would fail. The reason is
-        // that `PossibleBorrowerVisitor::visit_terminator` considers `place.local` a possible borrower of
-        // itself. See the comment in that method for an explanation as to why.
-        possible_borrower.bounded_borrowers(&[local], &[local, place.local], place.local, location)
-            && used_exactly_once(mir, place.local).unwrap_or(false)
-    } else {
-        false
-    }
-}
-
-// Iteratively replaces `param_ty` with `new_ty` in `args`, and similarly for each resulting
-// projected type that is a type parameter. Returns `false` if replacing the types would have an
-// effect on the function signature beyond substituting `new_ty` for `param_ty`.
-// See: https://github.com/rust-lang/rust-clippy/pull/9136#discussion_r927212757
-fn replace_types<'tcx>(
-    cx: &LateContext<'tcx>,
-    param_ty: ParamTy,
-    new_ty: Ty<'tcx>,
-    fn_sig: FnSig<'tcx>,
-    arg_index: usize,
-    projection_predicates: &[ProjectionPredicate<'tcx>],
-    args: &mut [ty::GenericArg<'tcx>],
-) -> bool {
-    let mut replaced = BitSet::new_empty(args.len());
-
-    let mut deque = VecDeque::with_capacity(args.len());
-    deque.push_back((param_ty, new_ty));
-
-    while let Some((param_ty, new_ty)) = deque.pop_front() {
-        // If `replaced.is_empty()`, then `param_ty` and `new_ty` are those initially passed in.
-        if !fn_sig
-            .inputs_and_output
-            .iter()
-            .enumerate()
-            .all(|(i, ty)| (replaced.is_empty() && i == arg_index) || !ty.contains(param_ty.to_ty(cx.tcx)))
-        {
-            return false;
-        }
-
-        args[param_ty.index as usize] = ty::GenericArg::from(new_ty);
-
-        // The `replaced.insert(...)` check provides some protection against infinite loops.
-        if replaced.insert(param_ty.index) {
-            for projection_predicate in projection_predicates {
-                if projection_predicate.projection_ty.self_ty() == param_ty.to_ty(cx.tcx)
-                    && let Some(term_ty) = projection_predicate.term.ty()
-                    && let ty::Param(term_param_ty) = term_ty.kind()
-                {
-                    let projection = cx.tcx.mk_ty_from_kind(ty::Alias(
-                        ty::Projection,
-                        projection_predicate.projection_ty.with_self_ty(cx.tcx, new_ty),
-                    ));
-
-                    if let Ok(projected_ty) = cx.tcx.try_normalize_erasing_regions(cx.param_env, projection)
-                        && args[term_param_ty.index as usize] != ty::GenericArg::from(projected_ty)
-                    {
-                        deque.push_back((*term_param_ty, projected_ty));
-                    }
-                }
-            }
-        }
-    }
-
-    true
-}
-
 fn ty_contains_field(ty: Ty<'_>, name: Symbol) -> bool {
     if let ty::Adt(adt, _) = *ty.kind() {
         adt.is_struct() && adt.all_fields().any(|f| f.name == name)
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 3f6bdb2b62c..614ddcda88f 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -228,6 +228,7 @@ mod mutex_atomic;
 mod needless_arbitrary_self_type;
 mod needless_bool;
 mod needless_borrowed_ref;
+mod needless_borrows_for_generic_args;
 mod needless_continue;
 mod needless_else;
 mod needless_for_each;
@@ -880,7 +881,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(move |_| Box::new(wildcard_imports::WildcardImports::new(warn_on_all_wildcard_imports)));
     store.register_late_pass(|_| Box::<redundant_pub_crate::RedundantPubCrate>::default());
     store.register_late_pass(|_| Box::new(unnamed_address::UnnamedAddress));
-    store.register_late_pass(move |_| Box::new(dereference::Dereferencing::new(msrv())));
+    store.register_late_pass(|_| Box::<dereference::Dereferencing<'_>>::default());
     store.register_late_pass(|_| Box::new(option_if_let_else::OptionIfLetElse));
     store.register_late_pass(|_| Box::new(future_not_send::FutureNotSend));
     let future_size_threshold = conf.future_size_threshold;
@@ -1104,6 +1105,11 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(implied_bounds_in_impls::ImpliedBoundsInImpls));
     store.register_late_pass(|_| Box::new(missing_asserts_for_indexing::MissingAssertsForIndexing));
     store.register_late_pass(|_| Box::new(unnecessary_map_on_constructor::UnnecessaryMapOnConstructor));
+    store.register_late_pass(move |_| {
+        Box::new(needless_borrows_for_generic_args::NeedlessBorrowsForGenericArgs::new(
+            msrv(),
+        ))
+    });
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/needless_borrows_for_generic_args.rs b/clippy_lints/src/needless_borrows_for_generic_args.rs
new file mode 100644
index 00000000000..d55c77a92b1
--- /dev/null
+++ b/clippy_lints/src/needless_borrows_for_generic_args.rs
@@ -0,0 +1,410 @@
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::mir::{enclosing_mir, expr_local, local_assignments, used_exactly_once, PossibleBorrowerMap};
+use clippy_utils::msrvs::{self, Msrv};
+use clippy_utils::source::snippet_with_context;
+use clippy_utils::ty::is_copy;
+use clippy_utils::{expr_use_ctxt, peel_n_hir_expr_refs, DefinedTy, ExprUseNode};
+use rustc_errors::Applicability;
+use rustc_hir::def::{DefKind, Res};
+use rustc_hir::def_id::{DefId, LocalDefId};
+use rustc_hir::{Body, Expr, ExprKind, Mutability, Path, QPath};
+use rustc_index::bit_set::BitSet;
+use rustc_infer::infer::TyCtxtInferExt;
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::mir::{Rvalue, StatementKind};
+use rustc_middle::ty::{
+    self, ClauseKind, EarlyBinder, FnSig, GenericArg, GenericArgKind, List, ParamTy, ProjectionPredicate, Ty,
+};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::symbol::sym;
+use rustc_trait_selection::traits::query::evaluate_obligation::InferCtxtExt as _;
+use rustc_trait_selection::traits::{Obligation, ObligationCause};
+use std::collections::VecDeque;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for borrow operations (`&`) that used as a generic argument to a
+    /// function when the borrowed value could be used.
+    ///
+    /// ### Why is this bad?
+    /// Suggests that the receiver of the expression borrows
+    /// the expression.
+    ///
+    /// ### Known problems
+    /// The lint cannot tell when the implementation of a trait
+    /// for `&T` and `T` do different things. Removing a borrow
+    /// in such a case can change the semantics of the code.
+    ///
+    /// ### Example
+    /// ```rust
+    /// fn f(_: impl AsRef<str>) {}
+    ///
+    /// let x = "foo";
+    /// f(&x);
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust
+    /// fn f(_: impl AsRef<str>) {}
+    ///
+    /// let x = "foo";
+    /// f(x);
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub NEEDLESS_BORROWS_FOR_GENERIC_ARGS,
+    style,
+    "taking a reference that is going to be automatically dereferenced"
+}
+
+pub struct NeedlessBorrowsForGenericArgs<'tcx> {
+    /// Stack of (body owner, `PossibleBorrowerMap`) pairs. Used by
+    /// `needless_borrow_impl_arg_position` to determine when a borrowed expression can instead
+    /// be moved.
+    possible_borrowers: Vec<(LocalDefId, PossibleBorrowerMap<'tcx, 'tcx>)>,
+
+    // `IntoIterator` for arrays requires Rust 1.53.
+    msrv: Msrv,
+}
+impl_lint_pass!(NeedlessBorrowsForGenericArgs<'_> => [NEEDLESS_BORROWS_FOR_GENERIC_ARGS]);
+
+impl NeedlessBorrowsForGenericArgs<'_> {
+    #[must_use]
+    pub fn new(msrv: Msrv) -> Self {
+        Self {
+            possible_borrowers: Vec::new(),
+            msrv,
+        }
+    }
+}
+
+impl<'tcx> LateLintPass<'tcx> for NeedlessBorrowsForGenericArgs<'tcx> {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        if matches!(expr.kind, ExprKind::AddrOf(..))
+            && !expr.span.from_expansion()
+            && let Some(use_cx) = expr_use_ctxt(cx, expr)
+            && !use_cx.is_ty_unified
+            && let Some(DefinedTy::Mir(ty)) = use_cx.node.defined_ty(cx)
+            && let ty::Param(ty) = *ty.value.skip_binder().kind()
+            && let Some((hir_id, fn_id, i)) = match use_cx.node {
+                ExprUseNode::MethodArg(_, _, 0) => None,
+                ExprUseNode::MethodArg(hir_id, None, i) => {
+                    cx.typeck_results().type_dependent_def_id(hir_id).map(|id| (hir_id, id, i))
+                },
+                ExprUseNode::FnArg(&Expr { kind: ExprKind::Path(ref p), hir_id, .. }, i)
+                if !path_has_args(p) => match cx.typeck_results().qpath_res(p, hir_id) {
+                    Res::Def(DefKind::Fn | DefKind::Ctor(..) | DefKind::AssocFn, id) => {
+                        Some((hir_id, id, i))
+                    },
+                    _ => None,
+                },
+                _ => None,
+            } && let count = needless_borrow_count(
+                cx,
+                &mut self.possible_borrowers,
+                fn_id,
+                cx.typeck_results().node_args(hir_id),
+                i,
+                ty,
+                expr,
+                &self.msrv,
+            ) && count != 0
+        {
+            span_lint_and_then(
+                cx,
+                NEEDLESS_BORROWS_FOR_GENERIC_ARGS,
+                expr.span,
+                "the borrowed expression implements the required traits",
+                |diag| {
+                    let mut app = Applicability::MachineApplicable;
+                    let snip_span = peel_n_hir_expr_refs(expr, count).0.span;
+                    let snip = snippet_with_context(cx, snip_span, expr.span.ctxt(), "..", &mut app).0;
+                    diag.span_suggestion(expr.span, "change this to", snip.into_owned(), app);
+                }
+            );
+        }
+    }
+
+    fn check_body_post(&mut self, cx: &LateContext<'tcx>, body: &'tcx Body<'_>) {
+        if self.possible_borrowers.last().map_or(false, |&(local_def_id, _)| {
+            local_def_id == cx.tcx.hir().body_owner_def_id(body.id())
+        }) {
+            self.possible_borrowers.pop();
+        }
+    }
+
+    extract_msrv_attr!(LateContext);
+}
+
+fn path_has_args(p: &QPath<'_>) -> bool {
+    match *p {
+        QPath::Resolved(_, Path { segments: [.., s], .. }) | QPath::TypeRelative(_, s) => s.args.is_some(),
+        _ => false,
+    }
+}
+
+/// Checks for the number of borrow expressions which can be removed from the given expression
+/// where the expression is used as an argument to a function expecting a generic type.
+///
+/// The following constraints will be checked:
+/// * The borrowed expression meets all the generic type's constraints.
+/// * The generic type appears only once in the functions signature.
+/// * The borrowed value will not be moved if it is used later in the function.
+#[expect(clippy::too_many_arguments)]
+fn needless_borrow_count<'tcx>(
+    cx: &LateContext<'tcx>,
+    possible_borrowers: &mut Vec<(LocalDefId, PossibleBorrowerMap<'tcx, 'tcx>)>,
+    fn_id: DefId,
+    callee_args: &'tcx List<GenericArg<'tcx>>,
+    arg_index: usize,
+    param_ty: ParamTy,
+    mut expr: &Expr<'tcx>,
+    msrv: &Msrv,
+) -> usize {
+    let destruct_trait_def_id = cx.tcx.lang_items().destruct_trait();
+    let sized_trait_def_id = cx.tcx.lang_items().sized_trait();
+
+    let fn_sig = cx.tcx.fn_sig(fn_id).instantiate_identity().skip_binder();
+    let predicates = cx.tcx.param_env(fn_id).caller_bounds();
+    let projection_predicates = predicates
+        .iter()
+        .filter_map(|predicate| {
+            if let ClauseKind::Projection(projection_predicate) = predicate.kind().skip_binder() {
+                Some(projection_predicate)
+            } else {
+                None
+            }
+        })
+        .collect::<Vec<_>>();
+
+    let mut trait_with_ref_mut_self_method = false;
+
+    // If no traits were found, or only the `Destruct`, `Sized`, or `Any` traits were found, return.
+    if predicates
+        .iter()
+        .filter_map(|predicate| {
+            if let ClauseKind::Trait(trait_predicate) = predicate.kind().skip_binder()
+                && trait_predicate.trait_ref.self_ty() == param_ty.to_ty(cx.tcx)
+            {
+                Some(trait_predicate.trait_ref.def_id)
+            } else {
+                None
+            }
+        })
+        .inspect(|trait_def_id| {
+            trait_with_ref_mut_self_method |= has_ref_mut_self_method(cx, *trait_def_id);
+        })
+        .all(|trait_def_id| {
+            Some(trait_def_id) == destruct_trait_def_id
+                || Some(trait_def_id) == sized_trait_def_id
+                || cx.tcx.is_diagnostic_item(sym::Any, trait_def_id)
+        })
+    {
+        return 0;
+    }
+
+    // See:
+    // - https://github.com/rust-lang/rust-clippy/pull/9674#issuecomment-1289294201
+    // - https://github.com/rust-lang/rust-clippy/pull/9674#issuecomment-1292225232
+    if projection_predicates
+        .iter()
+        .any(|projection_predicate| is_mixed_projection_predicate(cx, fn_id, projection_predicate))
+    {
+        return 0;
+    }
+
+    // `args_with_referent_ty` can be constructed outside of `check_referent` because the same
+    // elements are modified each time `check_referent` is called.
+    let mut args_with_referent_ty = callee_args.to_vec();
+
+    let mut check_reference_and_referent = |reference, referent| {
+        let referent_ty = cx.typeck_results().expr_ty(referent);
+
+        if !is_copy(cx, referent_ty)
+            && (referent_ty.has_significant_drop(cx.tcx, cx.param_env)
+                || !referent_used_exactly_once(cx, possible_borrowers, reference))
+        {
+            return false;
+        }
+
+        // https://github.com/rust-lang/rust-clippy/pull/9136#pullrequestreview-1037379321
+        if trait_with_ref_mut_self_method && !matches!(referent_ty.kind(), ty::Ref(_, _, Mutability::Mut)) {
+            return false;
+        }
+
+        if !replace_types(
+            cx,
+            param_ty,
+            referent_ty,
+            fn_sig,
+            arg_index,
+            &projection_predicates,
+            &mut args_with_referent_ty,
+        ) {
+            return false;
+        }
+
+        predicates.iter().all(|predicate| {
+            if let ClauseKind::Trait(trait_predicate) = predicate.kind().skip_binder()
+                && cx.tcx.is_diagnostic_item(sym::IntoIterator, trait_predicate.trait_ref.def_id)
+                && let ty::Param(param_ty) = trait_predicate.self_ty().kind()
+                && let GenericArgKind::Type(ty) = args_with_referent_ty[param_ty.index as usize].unpack()
+                && ty.is_array()
+                && !msrv.meets(msrvs::ARRAY_INTO_ITERATOR)
+            {
+                return false;
+            }
+
+            let predicate = EarlyBinder::bind(predicate).instantiate(cx.tcx, &args_with_referent_ty);
+            let obligation = Obligation::new(cx.tcx, ObligationCause::dummy(), cx.param_env, predicate);
+            let infcx = cx.tcx.infer_ctxt().build();
+            infcx.predicate_must_hold_modulo_regions(&obligation)
+        })
+    };
+
+    let mut count = 0;
+    while let ExprKind::AddrOf(_, _, referent) = expr.kind {
+        if !check_reference_and_referent(expr, referent) {
+            break;
+        }
+        expr = referent;
+        count += 1;
+    }
+    count
+}
+
+fn has_ref_mut_self_method(cx: &LateContext<'_>, trait_def_id: DefId) -> bool {
+    cx.tcx
+        .associated_items(trait_def_id)
+        .in_definition_order()
+        .any(|assoc_item| {
+            if assoc_item.fn_has_self_parameter {
+                let self_ty = cx
+                    .tcx
+                    .fn_sig(assoc_item.def_id)
+                    .instantiate_identity()
+                    .skip_binder()
+                    .inputs()[0];
+                matches!(self_ty.kind(), ty::Ref(_, _, Mutability::Mut))
+            } else {
+                false
+            }
+        })
+}
+
+fn is_mixed_projection_predicate<'tcx>(
+    cx: &LateContext<'tcx>,
+    callee_def_id: DefId,
+    projection_predicate: &ProjectionPredicate<'tcx>,
+) -> bool {
+    let generics = cx.tcx.generics_of(callee_def_id);
+    // The predicate requires the projected type to equal a type parameter from the parent context.
+    if let Some(term_ty) = projection_predicate.term.ty()
+        && let ty::Param(term_param_ty) = term_ty.kind()
+        && (term_param_ty.index as usize) < generics.parent_count
+    {
+        // The inner-most self type is a type parameter from the current function.
+        let mut projection_ty = projection_predicate.projection_ty;
+        loop {
+            match projection_ty.self_ty().kind() {
+                ty::Alias(ty::Projection, inner_projection_ty) => {
+                    projection_ty = *inner_projection_ty;
+                }
+                ty::Param(param_ty) => {
+                    return (param_ty.index as usize) >= generics.parent_count;
+                }
+                _ => {
+                    return false;
+                }
+            }
+        }
+    } else {
+        false
+    }
+}
+
+fn referent_used_exactly_once<'tcx>(
+    cx: &LateContext<'tcx>,
+    possible_borrowers: &mut Vec<(LocalDefId, PossibleBorrowerMap<'tcx, 'tcx>)>,
+    reference: &Expr<'tcx>,
+) -> bool {
+    if let Some(mir) = enclosing_mir(cx.tcx, reference.hir_id)
+        && let Some(local) = expr_local(cx.tcx, reference)
+        && let [location] = *local_assignments(mir, local).as_slice()
+        && let block_data = &mir.basic_blocks[location.block]
+        && let Some(statement) = block_data.statements.get(location.statement_index)
+        && let StatementKind::Assign(box (_, Rvalue::Ref(_, _, place))) = statement.kind
+        && !place.is_indirect_first_projection()
+    {
+        let body_owner_local_def_id = cx.tcx.hir().enclosing_body_owner(reference.hir_id);
+        if possible_borrowers
+            .last()
+            .map_or(true, |&(local_def_id, _)| local_def_id != body_owner_local_def_id)
+        {
+            possible_borrowers.push((body_owner_local_def_id, PossibleBorrowerMap::new(cx, mir)));
+        }
+        let possible_borrower = &mut possible_borrowers.last_mut().unwrap().1;
+        // If `only_borrowers` were used here, the `copyable_iterator::warn` test would fail. The reason is
+        // that `PossibleBorrowerVisitor::visit_terminator` considers `place.local` a possible borrower of
+        // itself. See the comment in that method for an explanation as to why.
+        possible_borrower.bounded_borrowers(&[local], &[local, place.local], place.local, location)
+            && used_exactly_once(mir, place.local).unwrap_or(false)
+    } else {
+        false
+    }
+}
+
+// Iteratively replaces `param_ty` with `new_ty` in `args`, and similarly for each resulting
+// projected type that is a type parameter. Returns `false` if replacing the types would have an
+// effect on the function signature beyond substituting `new_ty` for `param_ty`.
+// See: https://github.com/rust-lang/rust-clippy/pull/9136#discussion_r927212757
+fn replace_types<'tcx>(
+    cx: &LateContext<'tcx>,
+    param_ty: ParamTy,
+    new_ty: Ty<'tcx>,
+    fn_sig: FnSig<'tcx>,
+    arg_index: usize,
+    projection_predicates: &[ProjectionPredicate<'tcx>],
+    args: &mut [ty::GenericArg<'tcx>],
+) -> bool {
+    let mut replaced = BitSet::new_empty(args.len());
+
+    let mut deque = VecDeque::with_capacity(args.len());
+    deque.push_back((param_ty, new_ty));
+
+    while let Some((param_ty, new_ty)) = deque.pop_front() {
+        // If `replaced.is_empty()`, then `param_ty` and `new_ty` are those initially passed in.
+        if !fn_sig
+            .inputs_and_output
+            .iter()
+            .enumerate()
+            .all(|(i, ty)| (replaced.is_empty() && i == arg_index) || !ty.contains(param_ty.to_ty(cx.tcx)))
+        {
+            return false;
+        }
+
+        args[param_ty.index as usize] = ty::GenericArg::from(new_ty);
+
+        // The `replaced.insert(...)` check provides some protection against infinite loops.
+        if replaced.insert(param_ty.index) {
+            for projection_predicate in projection_predicates {
+                if projection_predicate.projection_ty.self_ty() == param_ty.to_ty(cx.tcx)
+                    && let Some(term_ty) = projection_predicate.term.ty()
+                    && let ty::Param(term_param_ty) = term_ty.kind()
+                {
+                    let projection = cx.tcx.mk_ty_from_kind(ty::Alias(
+                        ty::Projection,
+                        projection_predicate.projection_ty.with_self_ty(cx.tcx, new_ty),
+                    ));
+
+                    if let Ok(projected_ty) = cx.tcx.try_normalize_erasing_regions(cx.param_env, projection)
+                        && args[term_param_ty.index as usize] != ty::GenericArg::from(projected_ty)
+                    {
+                        deque.push_back((*term_param_ty, projected_ty));
+                    }
+                }
+            }
+        }
+    }
+
+    true
+}
diff --git a/tests/ui/needless_borrow.fixed b/tests/ui/needless_borrow.fixed
index 0a52b25229d..c2c5f765abf 100644
--- a/tests/ui/needless_borrow.fixed
+++ b/tests/ui/needless_borrow.fixed
@@ -131,21 +131,6 @@ fn main() {
             0
         }
     }
-
-    let _ = std::process::Command::new("ls").args(["-a", "-l"]).status().unwrap();
-    let _ = std::path::Path::new(".").join(".");
-    deref_target_is_x(X);
-    multiple_constraints([[""]]);
-    multiple_constraints_normalizes_to_same(X, X);
-    let _ = Some("").unwrap_or("");
-    let _ = std::fs::write("x", "".to_string());
-
-    only_sized(&""); // Don't lint. `Sized` is only bound
-    let _ = std::any::Any::type_id(&""); // Don't lint. `Any` is only bound
-    let _ = Box::new(&""); // Don't lint. Type parameter appears in return type
-    ref_as_ref_path(&""); // Don't lint. Argument type is not a type parameter
-    refs_only(&()); // Don't lint. `&T` implements trait, but `T` doesn't
-    multiple_constraints_normalizes_to_different(&[[""]], &[""]); // Don't lint. Projected type appears in arguments
 }
 
 #[allow(clippy::needless_borrowed_reference)]
@@ -201,103 +186,6 @@ mod issue9160 {
     }
 }
 
-#[derive(Clone, Copy)]
-struct X;
-
-impl std::ops::Deref for X {
-    type Target = X;
-    fn deref(&self) -> &Self::Target {
-        self
-    }
-}
-
-fn deref_target_is_x<T>(_: T)
-where
-    T: std::ops::Deref<Target = X>,
-{
-}
-
-fn multiple_constraints<T, U, V, X, Y>(_: T)
-where
-    T: IntoIterator<Item = U> + IntoIterator<Item = X>,
-    U: IntoIterator<Item = V>,
-    V: AsRef<str>,
-    X: IntoIterator<Item = Y>,
-    Y: AsRef<std::ffi::OsStr>,
-{
-}
-
-fn multiple_constraints_normalizes_to_same<T, U, V>(_: T, _: V)
-where
-    T: std::ops::Deref<Target = U>,
-    U: std::ops::Deref<Target = V>,
-{
-}
-
-fn only_sized<T>(_: T) {}
-
-fn ref_as_ref_path<T: 'static>(_: &'static T)
-where
-    &'static T: AsRef<std::path::Path>,
-{
-}
-
-trait RefsOnly {
-    type Referent;
-}
-
-impl<T> RefsOnly for &T {
-    type Referent = T;
-}
-
-fn refs_only<T, U>(_: T)
-where
-    T: RefsOnly<Referent = U>,
-{
-}
-
-fn multiple_constraints_normalizes_to_different<T, U, V>(_: T, _: U)
-where
-    T: IntoIterator<Item = U>,
-    U: IntoIterator<Item = V>,
-    V: AsRef<str>,
-{
-}
-
-// https://github.com/rust-lang/rust-clippy/pull/9136#pullrequestreview-1037379321
-mod copyable_iterator {
-    #[derive(Clone, Copy)]
-    struct Iter;
-    impl Iterator for Iter {
-        type Item = ();
-        fn next(&mut self) -> Option<Self::Item> {
-            None
-        }
-    }
-    fn takes_iter(_: impl Iterator) {}
-    fn dont_warn(mut x: Iter) {
-        takes_iter(&mut x);
-    }
-    #[allow(unused_mut)]
-    fn warn(mut x: &mut Iter) {
-        takes_iter(x)
-    }
-}
-
-#[clippy::msrv = "1.52.0"]
-mod under_msrv {
-    fn foo() {
-        let _ = std::process::Command::new("ls").args(&["-a", "-l"]).status().unwrap();
-    }
-}
-
-#[clippy::msrv = "1.53.0"]
-mod meets_msrv {
-    fn foo() {
-        let _ = std::process::Command::new("ls").args(["-a", "-l"]).status().unwrap();
-    }
-}
-
 fn issue9383() {
     // Should not lint because unions need explicit deref when accessing field
     use std::mem::ManuallyDrop;
@@ -326,184 +214,6 @@ fn issue9383() {
     }
 }
 
-fn closure_test() {
-    let env = "env".to_owned();
-    let arg = "arg".to_owned();
-    let f = |arg| {
-        let loc = "loc".to_owned();
-        let _ = std::fs::write("x", &env); // Don't lint. In environment
-        let _ = std::fs::write("x", arg);
-        let _ = std::fs::write("x", loc);
-    };
-    let _ = std::fs::write("x", &env); // Don't lint. Borrowed by `f`
-    f(arg);
-}
-
-mod significant_drop {
-    #[derive(Debug)]
-    struct X;
-
-    #[derive(Debug)]
-    struct Y;
-
-    impl Drop for Y {
-        fn drop(&mut self) {}
-    }
-
-    fn foo(x: X, y: Y) {
-        debug(x);
-        debug(&y); // Don't lint. Has significant drop
-    }
-
-    fn debug(_: impl std::fmt::Debug) {}
-}
-
-mod used_exactly_once {
-    fn foo(x: String) {
-        use_x(x);
-    }
-    fn use_x(_: impl AsRef<str>) {}
-}
-
-mod used_more_than_once {
-    fn foo(x: String) {
-        use_x(&x);
-        use_x_again(&x);
-    }
-    fn use_x(_: impl AsRef<str>) {}
-    fn use_x_again(_: impl AsRef<str>) {}
-}
-
-// https://github.com/rust-lang/rust-clippy/issues/9111#issuecomment-1277114280
-mod issue_9111 {
-    struct A;
-
-    impl Extend<u8> for A {
-        fn extend<T: IntoIterator<Item = u8>>(&mut self, _: T) {
-            unimplemented!()
-        }
-    }
-
-    impl<'a> Extend<&'a u8> for A {
-        fn extend<T: IntoIterator<Item = &'a u8>>(&mut self, _: T) {
-            unimplemented!()
-        }
-    }
-
-    fn main() {
-        let mut a = A;
-        a.extend(&[]); // vs a.extend([]);
-    }
-}
-
-mod issue_9710 {
-    fn main() {
-        let string = String::new();
-        for _i in 0..10 {
-            f(&string);
-        }
-    }
-
-    fn f<T: AsRef<str>>(_: T) {}
-}
-
-mod issue_9739 {
-    fn foo<D: std::fmt::Display>(_it: impl IntoIterator<Item = D>) {}
-
-    fn main() {
-        foo(if std::env::var_os("HI").is_some() {
-            &[0]
-        } else {
-            &[] as &[u32]
-        });
-    }
-}
-
-mod issue_9739_method_variant {
-    struct S;
-
-    impl S {
-        fn foo<D: std::fmt::Display>(&self, _it: impl IntoIterator<Item = D>) {}
-    }
-
-    fn main() {
-        S.foo(if std::env::var_os("HI").is_some() {
-            &[0]
-        } else {
-            &[] as &[u32]
-        });
-    }
-}
-
-mod issue_9782 {
-    fn foo<T: AsRef<[u8]>>(t: T) {
-        println!("{}", std::mem::size_of::<T>());
-        let _t: &[u8] = t.as_ref();
-    }
-
-    fn main() {
-        let a: [u8; 100] = [0u8; 100];
-
-        // 100
-        foo::<[u8; 100]>(a);
-        foo(a);
-
-        // 16
-        foo::<&[u8]>(&a);
-        foo(a.as_slice());
-
-        // 8
-        foo::<&[u8; 100]>(&a);
-        foo(a);
-    }
-}
-
-mod issue_9782_type_relative_variant {
-    struct S;
-
-    impl S {
-        fn foo<T: AsRef<[u8]>>(t: T) {
-            println!("{}", std::mem::size_of::<T>());
-            let _t: &[u8] = t.as_ref();
-        }
-    }
-
-    fn main() {
-        let a: [u8; 100] = [0u8; 100];
-
-        S::foo::<&[u8; 100]>(&a);
-    }
-}
-
-mod issue_9782_method_variant {
-    struct S;
-
-    impl S {
-        fn foo<T: AsRef<[u8]>>(&self, t: T) {
-            println!("{}", std::mem::size_of::<T>());
-            let _t: &[u8] = t.as_ref();
-        }
-    }
-
-    fn main() {
-        let a: [u8; 100] = [0u8; 100];
-
-        S.foo::<&[u8; 100]>(&a);
-    }
-}
-
-mod issue_10535 {
-    static SOME_STATIC: String = String::new();
-
-    static UNIT: () = compute(&SOME_STATIC);
-
-    pub const fn compute<T>(_: T)
-    where
-        T: Copy,
-    {
-    }
-}
-
 mod issue_10253 {
     struct S;
     trait X {
diff --git a/tests/ui/needless_borrow.rs b/tests/ui/needless_borrow.rs
index 34a95d18463..0cd6e41b8a4 100644
--- a/tests/ui/needless_borrow.rs
+++ b/tests/ui/needless_borrow.rs
@@ -131,21 +131,6 @@ fn main() {
             0
         }
     }
-
-    let _ = std::process::Command::new("ls").args(&["-a", "-l"]).status().unwrap();
-    let _ = std::path::Path::new(".").join(&&".");
-    deref_target_is_x(&X);
-    multiple_constraints(&[[""]]);
-    multiple_constraints_normalizes_to_same(&X, X);
-    let _ = Some("").unwrap_or(&"");
-    let _ = std::fs::write("x", &"".to_string());
-
-    only_sized(&""); // Don't lint. `Sized` is only bound
-    let _ = std::any::Any::type_id(&""); // Don't lint. `Any` is only bound
-    let _ = Box::new(&""); // Don't lint. Type parameter appears in return type
-    ref_as_ref_path(&""); // Don't lint. Argument type is not a type parameter
-    refs_only(&()); // Don't lint. `&T` implements trait, but `T` doesn't
-    multiple_constraints_normalizes_to_different(&[[""]], &[""]); // Don't lint. Projected type appears in arguments
 }
 
 #[allow(clippy::needless_borrowed_reference)]
@@ -201,103 +186,6 @@ mod issue9160 {
     }
 }
 
-#[derive(Clone, Copy)]
-struct X;
-
-impl std::ops::Deref for X {
-    type Target = X;
-    fn deref(&self) -> &Self::Target {
-        self
-    }
-}
-
-fn deref_target_is_x<T>(_: T)
-where
-    T: std::ops::Deref<Target = X>,
-{
-}
-
-fn multiple_constraints<T, U, V, X, Y>(_: T)
-where
-    T: IntoIterator<Item = U> + IntoIterator<Item = X>,
-    U: IntoIterator<Item = V>,
-    V: AsRef<str>,
-    X: IntoIterator<Item = Y>,
-    Y: AsRef<std::ffi::OsStr>,
-{
-}
-
-fn multiple_constraints_normalizes_to_same<T, U, V>(_: T, _: V)
-where
-    T: std::ops::Deref<Target = U>,
-    U: std::ops::Deref<Target = V>,
-{
-}
-
-fn only_sized<T>(_: T) {}
-
-fn ref_as_ref_path<T: 'static>(_: &'static T)
-where
-    &'static T: AsRef<std::path::Path>,
-{
-}
-
-trait RefsOnly {
-    type Referent;
-}
-
-impl<T> RefsOnly for &T {
-    type Referent = T;
-}
-
-fn refs_only<T, U>(_: T)
-where
-    T: RefsOnly<Referent = U>,
-{
-}
-
-fn multiple_constraints_normalizes_to_different<T, U, V>(_: T, _: U)
-where
-    T: IntoIterator<Item = U>,
-    U: IntoIterator<Item = V>,
-    V: AsRef<str>,
-{
-}
-
-// https://github.com/rust-lang/rust-clippy/pull/9136#pullrequestreview-1037379321
-mod copyable_iterator {
-    #[derive(Clone, Copy)]
-    struct Iter;
-    impl Iterator for Iter {
-        type Item = ();
-        fn next(&mut self) -> Option<Self::Item> {
-            None
-        }
-    }
-    fn takes_iter(_: impl Iterator) {}
-    fn dont_warn(mut x: Iter) {
-        takes_iter(&mut x);
-    }
-    #[allow(unused_mut)]
-    fn warn(mut x: &mut Iter) {
-        takes_iter(&mut x)
-    }
-}
-
-#[clippy::msrv = "1.52.0"]
-mod under_msrv {
-    fn foo() {
-        let _ = std::process::Command::new("ls").args(&["-a", "-l"]).status().unwrap();
-    }
-}
-
-#[clippy::msrv = "1.53.0"]
-mod meets_msrv {
-    fn foo() {
-        let _ = std::process::Command::new("ls").args(&["-a", "-l"]).status().unwrap();
-    }
-}
-
 fn issue9383() {
     // Should not lint because unions need explicit deref when accessing field
     use std::mem::ManuallyDrop;
@@ -326,184 +214,6 @@ fn issue9383() {
     }
 }
 
-fn closure_test() {
-    let env = "env".to_owned();
-    let arg = "arg".to_owned();
-    let f = |arg| {
-        let loc = "loc".to_owned();
-        let _ = std::fs::write("x", &env); // Don't lint. In environment
-        let _ = std::fs::write("x", &arg);
-        let _ = std::fs::write("x", &loc);
-    };
-    let _ = std::fs::write("x", &env); // Don't lint. Borrowed by `f`
-    f(arg);
-}
-
-mod significant_drop {
-    #[derive(Debug)]
-    struct X;
-
-    #[derive(Debug)]
-    struct Y;
-
-    impl Drop for Y {
-        fn drop(&mut self) {}
-    }
-
-    fn foo(x: X, y: Y) {
-        debug(&x);
-        debug(&y); // Don't lint. Has significant drop
-    }
-
-    fn debug(_: impl std::fmt::Debug) {}
-}
-
-mod used_exactly_once {
-    fn foo(x: String) {
-        use_x(&x);
-    }
-    fn use_x(_: impl AsRef<str>) {}
-}
-
-mod used_more_than_once {
-    fn foo(x: String) {
-        use_x(&x);
-        use_x_again(&x);
-    }
-    fn use_x(_: impl AsRef<str>) {}
-    fn use_x_again(_: impl AsRef<str>) {}
-}
-
-// https://github.com/rust-lang/rust-clippy/issues/9111#issuecomment-1277114280
-mod issue_9111 {
-    struct A;
-
-    impl Extend<u8> for A {
-        fn extend<T: IntoIterator<Item = u8>>(&mut self, _: T) {
-            unimplemented!()
-        }
-    }
-
-    impl<'a> Extend<&'a u8> for A {
-        fn extend<T: IntoIterator<Item = &'a u8>>(&mut self, _: T) {
-            unimplemented!()
-        }
-    }
-
-    fn main() {
-        let mut a = A;
-        a.extend(&[]); // vs a.extend([]);
-    }
-}
-
-mod issue_9710 {
-    fn main() {
-        let string = String::new();
-        for _i in 0..10 {
-            f(&string);
-        }
-    }
-
-    fn f<T: AsRef<str>>(_: T) {}
-}
-
-mod issue_9739 {
-    fn foo<D: std::fmt::Display>(_it: impl IntoIterator<Item = D>) {}
-
-    fn main() {
-        foo(if std::env::var_os("HI").is_some() {
-            &[0]
-        } else {
-            &[] as &[u32]
-        });
-    }
-}
-
-mod issue_9739_method_variant {
-    struct S;
-
-    impl S {
-        fn foo<D: std::fmt::Display>(&self, _it: impl IntoIterator<Item = D>) {}
-    }
-
-    fn main() {
-        S.foo(if std::env::var_os("HI").is_some() {
-            &[0]
-        } else {
-            &[] as &[u32]
-        });
-    }
-}
-
-mod issue_9782 {
-    fn foo<T: AsRef<[u8]>>(t: T) {
-        println!("{}", std::mem::size_of::<T>());
-        let _t: &[u8] = t.as_ref();
-    }
-
-    fn main() {
-        let a: [u8; 100] = [0u8; 100];
-
-        // 100
-        foo::<[u8; 100]>(a);
-        foo(a);
-
-        // 16
-        foo::<&[u8]>(&a);
-        foo(a.as_slice());
-
-        // 8
-        foo::<&[u8; 100]>(&a);
-        foo(&a);
-    }
-}
-
-mod issue_9782_type_relative_variant {
-    struct S;
-
-    impl S {
-        fn foo<T: AsRef<[u8]>>(t: T) {
-            println!("{}", std::mem::size_of::<T>());
-            let _t: &[u8] = t.as_ref();
-        }
-    }
-
-    fn main() {
-        let a: [u8; 100] = [0u8; 100];
-
-        S::foo::<&[u8; 100]>(&a);
-    }
-}
-
-mod issue_9782_method_variant {
-    struct S;
-
-    impl S {
-        fn foo<T: AsRef<[u8]>>(&self, t: T) {
-            println!("{}", std::mem::size_of::<T>());
-            let _t: &[u8] = t.as_ref();
-        }
-    }
-
-    fn main() {
-        let a: [u8; 100] = [0u8; 100];
-
-        S.foo::<&[u8; 100]>(&a);
-    }
-}
-
-mod issue_10535 {
-    static SOME_STATIC: String = String::new();
-
-    static UNIT: () = compute(&SOME_STATIC);
-
-    pub const fn compute<T>(_: T)
-    where
-        T: Copy,
-    {
-    }
-}
-
 mod issue_10253 {
     struct S;
     trait X {
diff --git a/tests/ui/needless_borrow.stderr b/tests/ui/needless_borrow.stderr
index 8e27014d53c..e91b78b0a15 100644
--- a/tests/ui/needless_borrow.stderr
+++ b/tests/ui/needless_borrow.stderr
@@ -121,101 +121,17 @@ error: this expression creates a reference which is immediately dereferenced by
 LL |     (&&5).foo();
    |     ^^^^^ help: change this to: `(&5)`
 
-error: the borrowed expression implements the required traits
-  --> $DIR/needless_borrow.rs:135:51
-   |
-LL |     let _ = std::process::Command::new("ls").args(&["-a", "-l"]).status().unwrap();
-   |                                                   ^^^^^^^^^^^^^ help: change this to: `["-a", "-l"]`
-
-error: the borrowed expression implements the required traits
-  --> $DIR/needless_borrow.rs:136:44
-   |
-LL |     let _ = std::path::Path::new(".").join(&&".");
-   |                                            ^^^^^ help: change this to: `"."`
-
-error: the borrowed expression implements the required traits
-  --> $DIR/needless_borrow.rs:137:23
-   |
-LL |     deref_target_is_x(&X);
-   |                       ^^ help: change this to: `X`
-
-error: the borrowed expression implements the required traits
-  --> $DIR/needless_borrow.rs:138:26
-   |
-LL |     multiple_constraints(&[[""]]);
-   |                          ^^^^^^^ help: change this to: `[[""]]`
-
-error: the borrowed expression implements the required traits
-  --> $DIR/needless_borrow.rs:139:45
-   |
-LL |     multiple_constraints_normalizes_to_same(&X, X);
-   |                                             ^^ help: change this to: `X`
-
-error: this expression creates a reference which is immediately dereferenced by the compiler
-  --> $DIR/needless_borrow.rs:140:32
-   |
-LL |     let _ = Some("").unwrap_or(&"");
-   |                                ^^^ help: change this to: `""`
-
-error: the borrowed expression implements the required traits
-  --> $DIR/needless_borrow.rs:141:33
-   |
-LL |     let _ = std::fs::write("x", &"".to_string());
-   |                                 ^^^^^^^^^^^^^^^ help: change this to: `"".to_string()`
-
 error: this expression borrows a value the compiler would automatically borrow
-  --> $DIR/needless_borrow.rs:190:13
+  --> $DIR/needless_borrow.rs:175:13
    |
 LL |             (&self.f)()
    |             ^^^^^^^^^ help: change this to: `(self.f)`
 
 error: this expression borrows a value the compiler would automatically borrow
-  --> $DIR/needless_borrow.rs:199:13
+  --> $DIR/needless_borrow.rs:184:13
    |
 LL |             (&mut self.f)()
    |             ^^^^^^^^^^^^^ help: change this to: `(self.f)`
 
-error: the borrowed expression implements the required traits
-  --> $DIR/needless_borrow.rs:283:20
-   |
-LL |         takes_iter(&mut x)
-   |                    ^^^^^^ help: change this to: `x`
-
-error: the borrowed expression implements the required traits
-  --> $DIR/needless_borrow.rs:297:55
-   |
-LL |         let _ = std::process::Command::new("ls").args(&["-a", "-l"]).status().unwrap();
-   |                                                       ^^^^^^^^^^^^^ help: change this to: `["-a", "-l"]`
-
-error: the borrowed expression implements the required traits
-  --> $DIR/needless_borrow.rs:335:37
-   |
-LL |         let _ = std::fs::write("x", &arg);
-   |                                     ^^^^ help: change this to: `arg`
-
-error: the borrowed expression implements the required traits
-  --> $DIR/needless_borrow.rs:336:37
-   |
-LL |         let _ = std::fs::write("x", &loc);
-   |                                     ^^^^ help: change this to: `loc`
-
-error: the borrowed expression implements the required traits
-  --> $DIR/needless_borrow.rs:354:15
-   |
-LL |         debug(&x);
-   |               ^^ help: change this to: `x`
-
-error: the borrowed expression implements the required traits
-  --> $DIR/needless_borrow.rs:363:15
-   |
-LL |         use_x(&x);
-   |               ^^ help: change this to: `x`
-
-error: the borrowed expression implements the required traits
-  --> $DIR/needless_borrow.rs:457:13
-   |
-LL |         foo(&a);
-   |             ^^ help: change this to: `a`
-
-error: aborting due to 36 previous errors
+error: aborting due to 22 previous errors
 
diff --git a/tests/ui/needless_borrows_for_generic_args.fixed b/tests/ui/needless_borrows_for_generic_args.fixed
new file mode 100644
index 00000000000..2a335516f51
--- /dev/null
+++ b/tests/ui/needless_borrows_for_generic_args.fixed
@@ -0,0 +1,287 @@
+#![warn(clippy::needless_borrows_for_generic_args)]
+#![allow(
+    clippy::unnecessary_to_owned,
+    clippy::unnecessary_literal_unwrap,
+    clippy::needless_borrow
+)]
+
+use core::ops::Deref;
+use std::any::Any;
+use std::ffi::OsStr;
+use std::fmt::{Debug, Display};
+use std::path::Path;
+use std::process::Command;
+
+fn main() {
+    let _ = Command::new("ls").args(["-a", "-l"]).status().unwrap();
+    let _ = Path::new(".").join(".");
+    let _ = Any::type_id(&""); // Don't lint. `Any` is only bound
+    let _ = Box::new(&""); // Don't lint. Type parameter appears in return type
+    let _ = Some("").unwrap_or(&"");
+    let _ = std::fs::write("x", "".to_string());
+
+    {
+        #[derive(Clone, Copy)]
+        struct X;
+
+        impl Deref for X {
+            type Target = X;
+            fn deref(&self) -> &Self::Target {
+                self
+            }
+        }
+
+        fn deref_target_is_x<T: Deref<Target = X>>(_: T) {}
+
+        deref_target_is_x(X);
+    }
+    {
+        fn multiple_constraints<T, U, V, X, Y>(_: T)
+        where
+            T: IntoIterator<Item = U> + IntoIterator<Item = X>,
+            U: IntoIterator<Item = V>,
+            V: AsRef<str>,
+            X: IntoIterator<Item = Y>,
+            Y: AsRef<OsStr>,
+        {
+        }
+
+        multiple_constraints([[""]]);
+    }
+    {
+        #[derive(Clone, Copy)]
+        struct X;
+
+        impl Deref for X {
+            type Target = X;
+            fn deref(&self) -> &Self::Target {
+                self
+            }
+        }
+
+        fn multiple_constraints_normalizes_to_same<T, U, V>(_: T, _: V)
+        where
+            T: Deref<Target = U>,
+            U: Deref<Target = V>,
+        {
+        }
+
+        multiple_constraints_normalizes_to_same(X, X);
+    }
+    {
+        fn only_sized<T>(_: T) {}
+        only_sized(&""); // Don't lint. `Sized` is only bound
+    }
+    {
+        fn ref_as_ref_path<T: 'static>(_: &'static T)
+        where
+            &'static T: AsRef<Path>,
+        {
+        }
+
+        ref_as_ref_path(&""); // Don't lint. Argument type is not a type parameter
+    }
+    {
+        trait RefsOnly {
+            type Referent;
+        }
+
+        impl<T> RefsOnly for &T {
+            type Referent = T;
+        }
+
+        fn refs_only<T, U>(_: T)
+        where
+            T: RefsOnly<Referent = U>,
+        {
+        }
+
+        refs_only(&()); // Don't lint. `&T` implements trait, but `T` doesn't
+    }
+    {
+        fn multiple_constraints_normalizes_to_different<T, U, V>(_: T, _: U)
+        where
+            T: IntoIterator<Item = U>,
+            U: IntoIterator<Item = V>,
+            V: AsRef<str>,
+        {
+        }
+        multiple_constraints_normalizes_to_different(&[[""]], &[""]); // Don't lint. Projected type appears in arguments
+    }
+    // https://github.com/rust-lang/rust-clippy/pull/9136#pullrequestreview-1037379321
+    {
+        #[derive(Clone, Copy)]
+        struct Iter;
+        impl Iterator for Iter {
+            type Item = ();
+            fn next(&mut self) -> Option<Self::Item> {
+                None
+            }
+        }
+        fn takes_iter(_: impl Iterator) {}
+        fn dont_warn(mut x: Iter) {
+            takes_iter(&mut x);
+        }
+        #[allow(unused_mut)]
+        fn warn(mut x: &mut Iter) {
+            takes_iter(x)
+        }
+    }
+    #[clippy::msrv = "1.52.0"]
+    {
+        let _ = Command::new("ls").args(&["-a", "-l"]).status().unwrap();
+    };
+    #[clippy::msrv = "1.53.0"]
+    {
+        let _ = Command::new("ls").args(["-a", "-l"]).status().unwrap();
+    };
+    {
+        let env = "env".to_owned();
+        let arg = "arg".to_owned();
+        let f = |arg| {
+            let loc = "loc".to_owned();
+            let _ = std::fs::write("x", &env); // Don't lint. In environment
+            let _ = std::fs::write("x", arg);
+            let _ = std::fs::write("x", loc);
+        };
+        let _ = std::fs::write("x", &env); // Don't lint. Borrowed by `f`
+        f(arg);
+    }
+    {
+        #[derive(Debug)]
+        struct X;
+
+        impl Drop for X {
+            fn drop(&mut self) {}
+        }
+
+        fn f(_: impl Debug) {}
+
+        let x = X;
+        f(&x); // Don't lint. Has significant drop
+    }
+    {
+        fn f(_: impl AsRef<str>) {}
+
+        let x = String::new();
+        f(x);
+    }
+    {
+        fn f(_: impl AsRef<str>) {}
+        fn f2(_: impl AsRef<str>) {}
+
+        let x = String::new();
+        f(&x);
+        f2(&x);
+    }
+    // https://github.com/rust-lang/rust-clippy/issues/9111#issuecomment-1277114280
+    // issue 9111
+    {
+        struct A;
+
+        impl Extend<u8> for A {
+            fn extend<T: IntoIterator<Item = u8>>(&mut self, _: T) {
+                unimplemented!()
+            }
+        }
+
+        impl<'a> Extend<&'a u8> for A {
+            fn extend<T: IntoIterator<Item = &'a u8>>(&mut self, _: T) {
+                unimplemented!()
+            }
+        }
+
+        let mut a = A;
+        a.extend(&[]); // vs a.extend([]);
+    }
+    // issue 9710
+    {
+        fn f(_: impl AsRef<str>) {}
+
+        let x = String::new();
+        for _ in 0..10 {
+            f(&x);
+        }
+    }
+    // issue 9739
+    {
+        fn foo<D: Display>(_it: impl IntoIterator<Item = D>) {}
+        foo(if std::env::var_os("HI").is_some() {
+            &[0]
+        } else {
+            &[] as &[u32]
+        });
+    }
+    {
+        struct S;
+
+        impl S {
+            fn foo<D: Display>(&self, _it: impl IntoIterator<Item = D>) {}
+        }
+
+        S.foo(if std::env::var_os("HI").is_some() {
+            &[0]
+        } else {
+            &[] as &[u32]
+        });
+    }
+    // issue 9782
+    {
+        fn foo<T: AsRef<[u8]>>(t: T) {
+            println!("{}", std::mem::size_of::<T>());
+            let _t: &[u8] = t.as_ref();
+        }
+
+        let a: [u8; 100] = [0u8; 100];
+
+        // 100
+        foo::<[u8; 100]>(a);
+        foo(a);
+
+        // 16
+        foo::<&[u8]>(&a);
+        foo(a.as_slice());
+
+        // 8
+        foo::<&[u8; 100]>(&a);
+        foo(a);
+    }
+    {
+        struct S;
+
+        impl S {
+            fn foo<T: AsRef<[u8]>>(t: T) {
+                println!("{}", std::mem::size_of::<T>());
+                let _t: &[u8] = t.as_ref();
+            }
+        }
+
+        let a: [u8; 100] = [0u8; 100];
+        S::foo::<&[u8; 100]>(&a);
+    }
+    {
+        struct S;
+
+        impl S {
+            fn foo<T: AsRef<[u8]>>(&self, t: T) {
+                println!("{}", std::mem::size_of::<T>());
+                let _t: &[u8] = t.as_ref();
+            }
+        }
+
+        let a: [u8; 100] = [0u8; 100];
+        S.foo::<&[u8; 100]>(&a);
+    }
+    // issue 10535
+    {
+        static SOME_STATIC: String = String::new();
+
+        static UNIT: () = compute(&SOME_STATIC);
+
+        pub const fn compute<T>(_: T)
+        where
+            T: Copy,
+        {
+        }
+    }
+}
diff --git a/tests/ui/needless_borrows_for_generic_args.rs b/tests/ui/needless_borrows_for_generic_args.rs
new file mode 100644
index 00000000000..f0567f486ac
--- /dev/null
+++ b/tests/ui/needless_borrows_for_generic_args.rs
@@ -0,0 +1,287 @@
+#![warn(clippy::needless_borrows_for_generic_args)]
+#![allow(
+    clippy::unnecessary_to_owned,
+    clippy::unnecessary_literal_unwrap,
+    clippy::needless_borrow
+)]
+
+use core::ops::Deref;
+use std::any::Any;
+use std::ffi::OsStr;
+use std::fmt::{Debug, Display};
+use std::path::Path;
+use std::process::Command;
+
+fn main() {
+    let _ = Command::new("ls").args(&["-a", "-l"]).status().unwrap();
+    let _ = Path::new(".").join(&&".");
+    let _ = Any::type_id(&""); // Don't lint. `Any` is only bound
+    let _ = Box::new(&""); // Don't lint. Type parameter appears in return type
+    let _ = Some("").unwrap_or(&"");
+    let _ = std::fs::write("x", &"".to_string());
+
+    {
+        #[derive(Clone, Copy)]
+        struct X;
+
+        impl Deref for X {
+            type Target = X;
+            fn deref(&self) -> &Self::Target {
+                self
+            }
+        }
+
+        fn deref_target_is_x<T: Deref<Target = X>>(_: T) {}
+
+        deref_target_is_x(&X);
+    }
+    {
+        fn multiple_constraints<T, U, V, X, Y>(_: T)
+        where
+            T: IntoIterator<Item = U> + IntoIterator<Item = X>,
+            U: IntoIterator<Item = V>,
+            V: AsRef<str>,
+            X: IntoIterator<Item = Y>,
+            Y: AsRef<OsStr>,
+        {
+        }
+
+        multiple_constraints(&[[""]]);
+    }
+    {
+        #[derive(Clone, Copy)]
+        struct X;
+
+        impl Deref for X {
+            type Target = X;
+            fn deref(&self) -> &Self::Target {
+                self
+            }
+        }
+
+        fn multiple_constraints_normalizes_to_same<T, U, V>(_: T, _: V)
+        where
+            T: Deref<Target = U>,
+            U: Deref<Target = V>,
+        {
+        }
+
+        multiple_constraints_normalizes_to_same(&X, X);
+    }
+    {
+        fn only_sized<T>(_: T) {}
+        only_sized(&""); // Don't lint. `Sized` is only bound
+    }
+    {
+        fn ref_as_ref_path<T: 'static>(_: &'static T)
+        where
+            &'static T: AsRef<Path>,
+        {
+        }
+
+        ref_as_ref_path(&""); // Don't lint. Argument type is not a type parameter
+    }
+    {
+        trait RefsOnly {
+            type Referent;
+        }
+
+        impl<T> RefsOnly for &T {
+            type Referent = T;
+        }
+
+        fn refs_only<T, U>(_: T)
+        where
+            T: RefsOnly<Referent = U>,
+        {
+        }
+
+        refs_only(&()); // Don't lint. `&T` implements trait, but `T` doesn't
+    }
+    {
+        fn multiple_constraints_normalizes_to_different<T, U, V>(_: T, _: U)
+        where
+            T: IntoIterator<Item = U>,
+            U: IntoIterator<Item = V>,
+            V: AsRef<str>,
+        {
+        }
+        multiple_constraints_normalizes_to_different(&[[""]], &[""]); // Don't lint. Projected type appears in arguments
+    }
+    // https://github.com/rust-lang/rust-clippy/pull/9136#pullrequestreview-1037379321
+    {
+        #[derive(Clone, Copy)]
+        struct Iter;
+        impl Iterator for Iter {
+            type Item = ();
+            fn next(&mut self) -> Option<Self::Item> {
+                None
+            }
+        }
+        fn takes_iter(_: impl Iterator) {}
+        fn dont_warn(mut x: Iter) {
+            takes_iter(&mut x);
+        }
+        #[allow(unused_mut)]
+        fn warn(mut x: &mut Iter) {
+            takes_iter(&mut x)
+        }
+    }
+    #[clippy::msrv = "1.52.0"]
+    {
+        let _ = Command::new("ls").args(&["-a", "-l"]).status().unwrap();
+    };
+    #[clippy::msrv = "1.53.0"]
+    {
+        let _ = Command::new("ls").args(&["-a", "-l"]).status().unwrap();
+    };
+    {
+        let env = "env".to_owned();
+        let arg = "arg".to_owned();
+        let f = |arg| {
+            let loc = "loc".to_owned();
+            let _ = std::fs::write("x", &env); // Don't lint. In environment
+            let _ = std::fs::write("x", &arg);
+            let _ = std::fs::write("x", &loc);
+        };
+        let _ = std::fs::write("x", &env); // Don't lint. Borrowed by `f`
+        f(arg);
+    }
+    {
+        #[derive(Debug)]
+        struct X;
+
+        impl Drop for X {
+            fn drop(&mut self) {}
+        }
+
+        fn f(_: impl Debug) {}
+
+        let x = X;
+        f(&x); // Don't lint. Has significant drop
+    }
+    {
+        fn f(_: impl AsRef<str>) {}
+
+        let x = String::new();
+        f(&x);
+    }
+    {
+        fn f(_: impl AsRef<str>) {}
+        fn f2(_: impl AsRef<str>) {}
+
+        let x = String::new();
+        f(&x);
+        f2(&x);
+    }
+    // https://github.com/rust-lang/rust-clippy/issues/9111#issuecomment-1277114280
+    // issue 9111
+    {
+        struct A;
+
+        impl Extend<u8> for A {
+            fn extend<T: IntoIterator<Item = u8>>(&mut self, _: T) {
+                unimplemented!()
+            }
+        }
+
+        impl<'a> Extend<&'a u8> for A {
+            fn extend<T: IntoIterator<Item = &'a u8>>(&mut self, _: T) {
+                unimplemented!()
+            }
+        }
+
+        let mut a = A;
+        a.extend(&[]); // vs a.extend([]);
+    }
+    // issue 9710
+    {
+        fn f(_: impl AsRef<str>) {}
+
+        let x = String::new();
+        for _ in 0..10 {
+            f(&x);
+        }
+    }
+    // issue 9739
+    {
+        fn foo<D: Display>(_it: impl IntoIterator<Item = D>) {}
+        foo(if std::env::var_os("HI").is_some() {
+            &[0]
+        } else {
+            &[] as &[u32]
+        });
+    }
+    {
+        struct S;
+
+        impl S {
+            fn foo<D: Display>(&self, _it: impl IntoIterator<Item = D>) {}
+        }
+
+        S.foo(if std::env::var_os("HI").is_some() {
+            &[0]
+        } else {
+            &[] as &[u32]
+        });
+    }
+    // issue 9782
+    {
+        fn foo<T: AsRef<[u8]>>(t: T) {
+            println!("{}", std::mem::size_of::<T>());
+            let _t: &[u8] = t.as_ref();
+        }
+
+        let a: [u8; 100] = [0u8; 100];
+
+        // 100
+        foo::<[u8; 100]>(a);
+        foo(a);
+
+        // 16
+        foo::<&[u8]>(&a);
+        foo(a.as_slice());
+
+        // 8
+        foo::<&[u8; 100]>(&a);
+        foo(&a);
+    }
+    {
+        struct S;
+
+        impl S {
+            fn foo<T: AsRef<[u8]>>(t: T) {
+                println!("{}", std::mem::size_of::<T>());
+                let _t: &[u8] = t.as_ref();
+            }
+        }
+
+        let a: [u8; 100] = [0u8; 100];
+        S::foo::<&[u8; 100]>(&a);
+    }
+    {
+        struct S;
+
+        impl S {
+            fn foo<T: AsRef<[u8]>>(&self, t: T) {
+                println!("{}", std::mem::size_of::<T>());
+                let _t: &[u8] = t.as_ref();
+            }
+        }
+
+        let a: [u8; 100] = [0u8; 100];
+        S.foo::<&[u8; 100]>(&a);
+    }
+    // issue 10535
+    {
+        static SOME_STATIC: String = String::new();
+
+        static UNIT: () = compute(&SOME_STATIC);
+
+        pub const fn compute<T>(_: T)
+        where
+            T: Copy,
+        {
+        }
+    }
+}
diff --git a/tests/ui/needless_borrows_for_generic_args.stderr b/tests/ui/needless_borrows_for_generic_args.stderr
new file mode 100644
index 00000000000..e2cde2c59a6
--- /dev/null
+++ b/tests/ui/needless_borrows_for_generic_args.stderr
@@ -0,0 +1,77 @@
+error: the borrowed expression implements the required traits
+  --> $DIR/needless_borrows_for_generic_args.rs:16:37
+   |
+LL |     let _ = Command::new("ls").args(&["-a", "-l"]).status().unwrap();
+   |                                     ^^^^^^^^^^^^^ help: change this to: `["-a", "-l"]`
+   |
+   = note: `-D clippy::needless-borrows-for-generic-args` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::needless_borrows_for_generic_args)]`
+
+error: the borrowed expression implements the required traits
+  --> $DIR/needless_borrows_for_generic_args.rs:17:33
+   |
+LL |     let _ = Path::new(".").join(&&".");
+   |                                 ^^^^^ help: change this to: `"."`
+
+error: the borrowed expression implements the required traits
+  --> $DIR/needless_borrows_for_generic_args.rs:21:33
+   |
+LL |     let _ = std::fs::write("x", &"".to_string());
+   |                                 ^^^^^^^^^^^^^^^ help: change this to: `"".to_string()`
+
+error: the borrowed expression implements the required traits
+  --> $DIR/needless_borrows_for_generic_args.rs:36:27
+   |
+LL |         deref_target_is_x(&X);
+   |                           ^^ help: change this to: `X`
+
+error: the borrowed expression implements the required traits
+  --> $DIR/needless_borrows_for_generic_args.rs:49:30
+   |
+LL |         multiple_constraints(&[[""]]);
+   |                              ^^^^^^^ help: change this to: `[[""]]`
+
+error: the borrowed expression implements the required traits
+  --> $DIR/needless_borrows_for_generic_args.rs:69:49
+   |
+LL |         multiple_constraints_normalizes_to_same(&X, X);
+   |                                                 ^^ help: change this to: `X`
+
+error: the borrowed expression implements the required traits
+  --> $DIR/needless_borrows_for_generic_args.rs:127:24
+   |
+LL |             takes_iter(&mut x)
+   |                        ^^^^^^ help: change this to: `x`
+
+error: the borrowed expression implements the required traits
+  --> $DIR/needless_borrows_for_generic_args.rs:136:41
+   |
+LL |         let _ = Command::new("ls").args(&["-a", "-l"]).status().unwrap();
+   |                                         ^^^^^^^^^^^^^ help: change this to: `["-a", "-l"]`
+
+error: the borrowed expression implements the required traits
+  --> $DIR/needless_borrows_for_generic_args.rs:144:41
+   |
+LL |             let _ = std::fs::write("x", &arg);
+   |                                         ^^^^ help: change this to: `arg`
+
+error: the borrowed expression implements the required traits
+  --> $DIR/needless_borrows_for_generic_args.rs:145:41
+   |
+LL |             let _ = std::fs::write("x", &loc);
+   |                                         ^^^^ help: change this to: `loc`
+
+error: the borrowed expression implements the required traits
+  --> $DIR/needless_borrows_for_generic_args.rs:167:11
+   |
+LL |         f(&x);
+   |           ^^ help: change this to: `x`
+
+error: the borrowed expression implements the required traits
+  --> $DIR/needless_borrows_for_generic_args.rs:247:13
+   |
+LL |         foo(&a);
+   |             ^^ help: change this to: `a`
+
+error: aborting due to 12 previous errors
+
diff --git a/tests/ui/regex.rs b/tests/ui/regex.rs
index 5259d9ce04b..094d9574ae9 100644
--- a/tests/ui/regex.rs
+++ b/tests/ui/regex.rs
@@ -2,7 +2,8 @@
     unused,
     clippy::needless_raw_strings,
     clippy::needless_raw_string_hashes,
-    clippy::needless_borrow
+    clippy::needless_borrow,
+    clippy::needless_borrows_for_generic_args
 )]
 #![warn(clippy::invalid_regex, clippy::trivial_regex)]
 
diff --git a/tests/ui/regex.stderr b/tests/ui/regex.stderr
index 91f90157e68..6d98d691d6f 100644
--- a/tests/ui/regex.stderr
+++ b/tests/ui/regex.stderr
@@ -1,5 +1,5 @@
 error: trivial regex
-  --> $DIR/regex.rs:18:45
+  --> $DIR/regex.rs:19:45
    |
 LL |     let pipe_in_wrong_position = Regex::new("|");
    |                                             ^^^
@@ -9,7 +9,7 @@ LL |     let pipe_in_wrong_position = Regex::new("|");
    = help: to override `-D warnings` add `#[allow(clippy::trivial_regex)]`
 
 error: trivial regex
-  --> $DIR/regex.rs:20:60
+  --> $DIR/regex.rs:21:60
    |
 LL |     let pipe_in_wrong_position_builder = RegexBuilder::new("|");
    |                                                            ^^^
@@ -17,7 +17,7 @@ LL |     let pipe_in_wrong_position_builder = RegexBuilder::new("|");
    = help: the regex is unlikely to be useful as it is
 
 error: regex syntax error: invalid character class range, the start must be <= the end
-  --> $DIR/regex.rs:22:42
+  --> $DIR/regex.rs:23:42
    |
 LL |     let wrong_char_ranice = Regex::new("[z-a]");
    |                                          ^^^
@@ -26,7 +26,7 @@ LL |     let wrong_char_ranice = Regex::new("[z-a]");
    = help: to override `-D warnings` add `#[allow(clippy::invalid_regex)]`
 
 error: regex syntax error: invalid character class range, the start must be <= the end
-  --> $DIR/regex.rs:25:37
+  --> $DIR/regex.rs:26:37
    |
 LL |     let some_unicode = Regex::new("[é-è]");
    |                                     ^^^
@@ -35,13 +35,13 @@ error: regex parse error:
            (
            ^
        error: unclosed group
-  --> $DIR/regex.rs:28:33
+  --> $DIR/regex.rs:29:33
    |
 LL |     let some_regex = Regex::new(OPENING_PAREN);
    |                                 ^^^^^^^^^^^^^
 
 error: trivial regex
-  --> $DIR/regex.rs:30:53
+  --> $DIR/regex.rs:31:53
    |
 LL |     let binary_pipe_in_wrong_position = BRegex::new("|");
    |                                                     ^^^
@@ -52,7 +52,7 @@ error: regex parse error:
            (
            ^
        error: unclosed group
-  --> $DIR/regex.rs:32:41
+  --> $DIR/regex.rs:33:41
    |
 LL |     let some_binary_regex = BRegex::new(OPENING_PAREN);
    |                                         ^^^^^^^^^^^^^
@@ -61,7 +61,7 @@ error: regex parse error:
            (
            ^
        error: unclosed group
-  --> $DIR/regex.rs:33:56
+  --> $DIR/regex.rs:34:56
    |
 LL |     let some_binary_regex_builder = BRegexBuilder::new(OPENING_PAREN);
    |                                                        ^^^^^^^^^^^^^
@@ -70,7 +70,7 @@ error: regex parse error:
            (
            ^
        error: unclosed group
-  --> $DIR/regex.rs:45:37
+  --> $DIR/regex.rs:46:37
    |
 LL |     let set_error = RegexSet::new(&[OPENING_PAREN, r"[a-z]+\.(com|org|net)"]);
    |                                     ^^^^^^^^^^^^^
@@ -79,7 +79,7 @@ error: regex parse error:
            (
            ^
        error: unclosed group
-  --> $DIR/regex.rs:46:39
+  --> $DIR/regex.rs:47:39
    |
 LL |     let bset_error = BRegexSet::new(&[OPENING_PAREN, r"[a-z]+\.(com|org|net)"]);
    |                                       ^^^^^^^^^^^^^
@@ -88,7 +88,7 @@ error: regex parse error:
            \b\c
              ^^
        error: unrecognized escape sequence
-  --> $DIR/regex.rs:53:42
+  --> $DIR/regex.rs:54:42
    |
 LL |     let escaped_string_span = Regex::new("\\b\\c");
    |                                          ^^^^^^^^
@@ -96,19 +96,19 @@ LL |     let escaped_string_span = Regex::new("\\b\\c");
    = help: consider using a raw string literal: `r".."`
 
 error: regex syntax error: duplicate flag
-  --> $DIR/regex.rs:55:34
+  --> $DIR/regex.rs:56:34
    |
 LL |     let aux_span = Regex::new("(?ixi)");
    |                                  ^ ^
 
 error: regex syntax error: pattern can match invalid UTF-8
-  --> $DIR/regex.rs:61:53
+  --> $DIR/regex.rs:62:53
    |
 LL |     let invalid_utf8_should_lint = Regex::new("(?-u).");
    |                                                     ^
 
 error: trivial regex
-  --> $DIR/regex.rs:66:33
+  --> $DIR/regex.rs:67:33
    |
 LL |     let trivial_eq = Regex::new("^foobar$");
    |                                 ^^^^^^^^^^
@@ -116,7 +116,7 @@ LL |     let trivial_eq = Regex::new("^foobar$");
    = help: consider using `==` on `str`s
 
 error: trivial regex
-  --> $DIR/regex.rs:69:48
+  --> $DIR/regex.rs:70:48
    |
 LL |     let trivial_eq_builder = RegexBuilder::new("^foobar$");
    |                                                ^^^^^^^^^^
@@ -124,7 +124,7 @@ LL |     let trivial_eq_builder = RegexBuilder::new("^foobar$");
    = help: consider using `==` on `str`s
 
 error: trivial regex
-  --> $DIR/regex.rs:72:42
+  --> $DIR/regex.rs:73:42
    |
 LL |     let trivial_starts_with = Regex::new("^foobar");
    |                                          ^^^^^^^^^
@@ -132,7 +132,7 @@ LL |     let trivial_starts_with = Regex::new("^foobar");
    = help: consider using `str::starts_with`
 
 error: trivial regex
-  --> $DIR/regex.rs:75:40
+  --> $DIR/regex.rs:76:40
    |
 LL |     let trivial_ends_with = Regex::new("foobar$");
    |                                        ^^^^^^^^^
@@ -140,7 +140,7 @@ LL |     let trivial_ends_with = Regex::new("foobar$");
    = help: consider using `str::ends_with`
 
 error: trivial regex
-  --> $DIR/regex.rs:78:39
+  --> $DIR/regex.rs:79:39
    |
 LL |     let trivial_contains = Regex::new("foobar");
    |                                       ^^^^^^^^
@@ -148,7 +148,7 @@ LL |     let trivial_contains = Regex::new("foobar");
    = help: consider using `str::contains`
 
 error: trivial regex
-  --> $DIR/regex.rs:81:39
+  --> $DIR/regex.rs:82:39
    |
 LL |     let trivial_contains = Regex::new(NOT_A_REAL_REGEX);
    |                                       ^^^^^^^^^^^^^^^^
@@ -156,7 +156,7 @@ LL |     let trivial_contains = Regex::new(NOT_A_REAL_REGEX);
    = help: consider using `str::contains`
 
 error: trivial regex
-  --> $DIR/regex.rs:84:40
+  --> $DIR/regex.rs:85:40
    |
 LL |     let trivial_backslash = Regex::new("a\\.b");
    |                                        ^^^^^^^
@@ -164,7 +164,7 @@ LL |     let trivial_backslash = Regex::new("a\\.b");
    = help: consider using `str::contains`
 
 error: trivial regex
-  --> $DIR/regex.rs:88:36
+  --> $DIR/regex.rs:89:36
    |
 LL |     let trivial_empty = Regex::new("");
    |                                    ^^
@@ -172,7 +172,7 @@ LL |     let trivial_empty = Regex::new("");
    = help: the regex is unlikely to be useful as it is
 
 error: trivial regex
-  --> $DIR/regex.rs:91:36
+  --> $DIR/regex.rs:92:36
    |
 LL |     let trivial_empty = Regex::new("^");
    |                                    ^^^
@@ -180,7 +180,7 @@ LL |     let trivial_empty = Regex::new("^");
    = help: the regex is unlikely to be useful as it is
 
 error: trivial regex
-  --> $DIR/regex.rs:94:36
+  --> $DIR/regex.rs:95:36
    |
 LL |     let trivial_empty = Regex::new("^$");
    |                                    ^^^^
@@ -188,7 +188,7 @@ LL |     let trivial_empty = Regex::new("^$");
    = help: consider using `str::is_empty`
 
 error: trivial regex
-  --> $DIR/regex.rs:97:44
+  --> $DIR/regex.rs:98:44
    |
 LL |     let binary_trivial_empty = BRegex::new("^$");
    |                                            ^^^^
diff --git a/tests/ui/unnecessary_to_owned.fixed b/tests/ui/unnecessary_to_owned.fixed
index 7b662ca92d2..67faabc53cb 100644
--- a/tests/ui/unnecessary_to_owned.fixed
+++ b/tests/ui/unnecessary_to_owned.fixed
@@ -1,4 +1,4 @@
-#![allow(clippy::needless_borrow, clippy::ptr_arg)]
+#![allow(clippy::needless_borrow, clippy::needless_borrows_for_generic_args, clippy::ptr_arg)]
 #![warn(clippy::unnecessary_to_owned, clippy::redundant_clone)]
 
 use std::borrow::Cow;
diff --git a/tests/ui/unnecessary_to_owned.rs b/tests/ui/unnecessary_to_owned.rs
index d79778a6a2e..99f9136427d 100644
--- a/tests/ui/unnecessary_to_owned.rs
+++ b/tests/ui/unnecessary_to_owned.rs
@@ -1,4 +1,4 @@
-#![allow(clippy::needless_borrow, clippy::ptr_arg)]
+#![allow(clippy::needless_borrow, clippy::needless_borrows_for_generic_args, clippy::ptr_arg)]
 #![warn(clippy::unnecessary_to_owned, clippy::redundant_clone)]
 
 use std::borrow::Cow;
-- 
cgit 1.4.1-3-g733a5


From 32d3387c80b59ad85756aa66237aa6d2a0eca884 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Sun, 17 Sep 2023 14:33:06 +0000
Subject: used_underscore_bindings: respect lint levels on the binding
 definition

---
 clippy_lints/src/misc.rs                | 104 ++++++++++++++------------------
 clippy_utils/src/lib.rs                 |  27 +++++++++
 tests/ui/used_underscore_binding.rs     |  28 ++++++++-
 tests/ui/used_underscore_binding.stderr |  47 +++++++++++++--
 4 files changed, 140 insertions(+), 66 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/misc.rs b/clippy_lints/src/misc.rs
index 303f0125690..f8e76a5833e 100644
--- a/clippy_lints/src/misc.rs
+++ b/clippy_lints/src/misc.rs
@@ -1,24 +1,23 @@
-use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg, span_lint_hir_and_then};
+use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg, span_lint_and_then, span_lint_hir_and_then};
 use clippy_utils::source::{snippet, snippet_opt, snippet_with_context};
+use clippy_utils::sugg::Sugg;
+use clippy_utils::{
+    any_parent_is_automatically_derived, fulfill_or_allowed, get_parent_expr, in_constant, is_integer_literal,
+    is_lint_allowed, is_no_std_crate, iter_input_pats, last_path_segment, SpanlessEq,
+};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
+use rustc_hir::def::Res;
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::{
-    self as hir, def, BinOpKind, BindingAnnotation, Body, ByRef, Expr, ExprKind, FnDecl, Mutability, PatKind, Stmt,
-    StmtKind, TyKind,
+    BinOpKind, BindingAnnotation, Body, ByRef, Expr, ExprKind, FnDecl, Mutability, PatKind, QPath, Stmt, StmtKind, Ty,
+    TyKind,
 };
-use rustc_lint::{LateContext, LateLintPass};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::def_id::LocalDefId;
-use rustc_span::hygiene::DesugaringKind;
-use rustc_span::source_map::{ExpnKind, Span};
-
-use clippy_utils::sugg::Sugg;
-use clippy_utils::{
-    get_parent_expr, in_constant, is_integer_literal, is_lint_allowed, is_no_std_crate, iter_input_pats,
-    last_path_segment, SpanlessEq,
-};
+use rustc_span::source_map::Span;
 
 use crate::ref_patterns::REF_PATTERNS;
 
@@ -257,46 +256,56 @@ impl<'tcx> LateLintPass<'tcx> for LintPass {
             self.check_cast(cx, expr.span, e, ty);
             return;
         }
-        if in_attributes_expansion(expr) || expr.span.is_desugaring(DesugaringKind::Await) {
-            // Don't lint things expanded by #[derive(...)], etc or `await` desugaring
+        if in_external_macro(cx.sess(), expr.span)
+            || expr.span.desugaring_kind().is_some()
+            || any_parent_is_automatically_derived(cx.tcx, expr.hir_id)
+        {
             return;
         }
-        let sym;
-        let binding = match expr.kind {
-            ExprKind::Path(ref qpath) if !matches!(qpath, hir::QPath::LangItem(..)) => {
-                let binding = last_path_segment(qpath).ident.as_str();
-                if binding.starts_with('_') &&
-                    !binding.starts_with("__") &&
-                    binding != "_result" && // FIXME: #944
-                    is_used(cx, expr) &&
-                    // don't lint if the declaration is in a macro
-                    non_macro_local(cx, cx.qpath_res(qpath, expr.hir_id))
+        let (definition_hir_id, ident) = match expr.kind {
+            ExprKind::Path(ref qpath) => {
+                if let QPath::Resolved(None, path) = qpath
+                    && let Res::Local(id) = path.res
+                    && is_used(cx, expr)
                 {
-                    Some(binding)
+                    (id, last_path_segment(qpath).ident)
                 } else {
-                    None
+                    return;
                 }
             },
-            ExprKind::Field(_, ident) => {
-                sym = ident.name;
-                let name = sym.as_str();
-                if name.starts_with('_') && !name.starts_with("__") {
-                    Some(name)
+            ExprKind::Field(recv, ident) => {
+                if let Some(adt_def) = cx.typeck_results().expr_ty_adjusted(recv).ty_adt_def()
+                    && let Some(field) = adt_def.all_fields().find(|field| field.name == ident.name)
+                    && let Some(local_did) = field.did.as_local()
+                    && let Some(hir_id) = cx.tcx.opt_local_def_id_to_hir_id(local_did)
+                    && !cx.tcx.type_of(field.did).skip_binder().is_phantom_data()
+                {
+                    (hir_id, ident)
                 } else {
-                    None
+                    return;
                 }
             },
-            _ => None,
+            _ => return,
         };
-        if let Some(binding) = binding {
-            span_lint(
+
+        let name = ident.name.as_str();
+        if name.starts_with('_')
+            && !name.starts_with("__")
+            && let definition_span = cx.tcx.hir().span(definition_hir_id)
+            && !definition_span.from_expansion()
+            && !fulfill_or_allowed(cx, USED_UNDERSCORE_BINDING, [expr.hir_id, definition_hir_id])
+        {
+            span_lint_and_then(
                 cx,
                 USED_UNDERSCORE_BINDING,
                 expr.span,
                 &format!(
-                    "used binding `{binding}` which is prefixed with an underscore. A leading \
+                    "used binding `{name}` which is prefixed with an underscore. A leading \
                      underscore signals that a binding will not be used"
                 ),
+                |diag| {
+                    diag.span_note(definition_span, format!("`{name}` is defined here"));
+                }
             );
         }
     }
@@ -312,29 +321,8 @@ fn is_used(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
     })
 }
 
-/// Tests whether an expression is in a macro expansion (e.g., something
-/// generated by `#[derive(...)]` or the like).
-fn in_attributes_expansion(expr: &Expr<'_>) -> bool {
-    use rustc_span::hygiene::MacroKind;
-    if expr.span.from_expansion() {
-        let data = expr.span.ctxt().outer_expn_data();
-        matches!(data.kind, ExpnKind::Macro(MacroKind::Attr | MacroKind::Derive, _))
-    } else {
-        false
-    }
-}
-
-/// Tests whether `res` is a variable defined outside a macro.
-fn non_macro_local(cx: &LateContext<'_>, res: def::Res) -> bool {
-    if let def::Res::Local(id) = res {
-        !cx.tcx.hir().span(id).from_expansion()
-    } else {
-        false
-    }
-}
-
 impl LintPass {
-    fn check_cast(&self, cx: &LateContext<'_>, span: Span, e: &Expr<'_>, ty: &hir::Ty<'_>) {
+    fn check_cast(&self, cx: &LateContext<'_>, span: Span, e: &Expr<'_>, ty: &Ty<'_>) {
         if_chain! {
             if let TyKind::Ptr(ref mut_ty) = ty.kind;
             if is_integer_literal(e, 0);
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 4ef3ec19647..eb5baa98f62 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -1785,6 +1785,33 @@ pub fn is_try<'tcx>(cx: &LateContext<'_>, expr: &'tcx Expr<'tcx>) -> Option<&'tc
     None
 }
 
+/// Returns `true` if the lint is `#[allow]`ed or `#[expect]`ed at any of the `ids`, fulfilling all
+/// of the expectations in `ids`
+///
+/// This should only be used when the lint would otherwise be emitted, for a way to check if a lint
+/// is allowed early to skip work see [`is_lint_allowed`]
+///
+/// To emit at a lint at a different context than the one current see
+/// [`span_lint_hir`](diagnostics::span_lint_hir) or
+/// [`span_lint_hir_and_then`](diagnostics::span_lint_hir_and_then)
+pub fn fulfill_or_allowed(cx: &LateContext<'_>, lint: &'static Lint, ids: impl IntoIterator<Item = HirId>) -> bool {
+    let mut suppress_lint = false;
+
+    for id in ids {
+        let (level, _) = cx.tcx.lint_level_at_node(lint, id);
+        if let Some(expectation) = level.get_expectation_id() {
+            cx.fulfill_expectation(expectation);
+        }
+
+        match level {
+            Level::Allow | Level::Expect(_) => suppress_lint = true,
+            Level::Warn | Level::ForceWarn(_) | Level::Deny | Level::Forbid => {},
+        }
+    }
+
+    suppress_lint
+}
+
 /// Returns `true` if the lint is allowed in the current context. This is useful for
 /// skipping long running code when it's unnecessary
 ///
diff --git a/tests/ui/used_underscore_binding.rs b/tests/ui/used_underscore_binding.rs
index c672eff1c27..a8f404b1400 100644
--- a/tests/ui/used_underscore_binding.rs
+++ b/tests/ui/used_underscore_binding.rs
@@ -1,6 +1,5 @@
 //@aux-build:proc_macro_derive.rs
-#![feature(rustc_private)]
-#![warn(clippy::all)]
+#![feature(rustc_private, lint_reasons)]
 #![warn(clippy::used_underscore_binding)]
 #![allow(clippy::disallowed_names, clippy::eq_op, clippy::uninlined_format_args)]
 
@@ -107,6 +106,31 @@ async fn await_desugaring() {
     .await
 }
 
+struct PhantomField<T> {
+    _marker: std::marker::PhantomData<T>,
+}
+
+impl<T> std::fmt::Debug for PhantomField<T> {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        f.debug_struct("PhantomField").field("_marker", &self._marker).finish()
+    }
+}
+
+struct AllowedField {
+    #[allow(clippy::used_underscore_binding)]
+    _allowed: usize,
+}
+
+struct ExpectedField {
+    #[expect(clippy::used_underscore_binding)]
+    _expected: usize,
+}
+
+fn lint_levels(allowed: AllowedField, expected: ExpectedField) {
+    let _ = allowed._allowed;
+    let _ = expected._expected;
+}
+
 fn main() {
     let foo = 0u32;
     // tests of unused_underscore lint
diff --git a/tests/ui/used_underscore_binding.stderr b/tests/ui/used_underscore_binding.stderr
index 289519b172e..78d8279810c 100644
--- a/tests/ui/used_underscore_binding.stderr
+++ b/tests/ui/used_underscore_binding.stderr
@@ -1,41 +1,76 @@
 error: used binding `_foo` which is prefixed with an underscore. A leading underscore signals that a binding will not be used
-  --> $DIR/used_underscore_binding.rs:24:5
+  --> $DIR/used_underscore_binding.rs:23:5
    |
 LL |     _foo + 1
    |     ^^^^
    |
+note: `_foo` is defined here
+  --> $DIR/used_underscore_binding.rs:22:22
+   |
+LL | fn prefix_underscore(_foo: u32) -> u32 {
+   |                      ^^^^
    = note: `-D clippy::used-underscore-binding` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::used_underscore_binding)]`
 
 error: used binding `_foo` which is prefixed with an underscore. A leading underscore signals that a binding will not be used
-  --> $DIR/used_underscore_binding.rs:29:20
+  --> $DIR/used_underscore_binding.rs:28:20
    |
 LL |     println!("{}", _foo);
    |                    ^^^^
+   |
+note: `_foo` is defined here
+  --> $DIR/used_underscore_binding.rs:27:24
+   |
+LL | fn in_macro_or_desugar(_foo: u32) {
+   |                        ^^^^
 
 error: used binding `_foo` which is prefixed with an underscore. A leading underscore signals that a binding will not be used
-  --> $DIR/used_underscore_binding.rs:30:16
+  --> $DIR/used_underscore_binding.rs:29:16
    |
 LL |     assert_eq!(_foo, _foo);
    |                ^^^^
+   |
+note: `_foo` is defined here
+  --> $DIR/used_underscore_binding.rs:27:24
+   |
+LL | fn in_macro_or_desugar(_foo: u32) {
+   |                        ^^^^
 
 error: used binding `_foo` which is prefixed with an underscore. A leading underscore signals that a binding will not be used
-  --> $DIR/used_underscore_binding.rs:30:22
+  --> $DIR/used_underscore_binding.rs:29:22
    |
 LL |     assert_eq!(_foo, _foo);
    |                      ^^^^
+   |
+note: `_foo` is defined here
+  --> $DIR/used_underscore_binding.rs:27:24
+   |
+LL | fn in_macro_or_desugar(_foo: u32) {
+   |                        ^^^^
 
 error: used binding `_underscore_field` which is prefixed with an underscore. A leading underscore signals that a binding will not be used
-  --> $DIR/used_underscore_binding.rs:43:5
+  --> $DIR/used_underscore_binding.rs:42:5
    |
 LL |     s._underscore_field += 1;
    |     ^^^^^^^^^^^^^^^^^^^
+   |
+note: `_underscore_field` is defined here
+  --> $DIR/used_underscore_binding.rs:36:5
+   |
+LL |     _underscore_field: u32,
+   |     ^^^^^^^^^^^^^^^^^^^^^^
 
 error: used binding `_i` which is prefixed with an underscore. A leading underscore signals that a binding will not be used
-  --> $DIR/used_underscore_binding.rs:104:16
+  --> $DIR/used_underscore_binding.rs:103:16
    |
 LL |         uses_i(_i);
    |                ^^
+   |
+note: `_i` is defined here
+  --> $DIR/used_underscore_binding.rs:102:13
+   |
+LL |         let _i = 5;
+   |             ^^
 
 error: aborting due to 6 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 1c9f3bef8bb80dc8706e4595a262fe8825ccf74a Mon Sep 17 00:00:00 2001
From: Dev381 <49997896+Dev380@users.noreply.github.com>
Date: Sun, 17 Sep 2023 17:50:45 -0400
Subject: Add redundant_as_str lint

This lint checks for `as_str` on a `String` immediately followed by `as_bytes` or `is_empty` as those methods are available on `String` too. This could possibly also be extended to `&[u8]` in the future.
---
 CHANGELOG.md                                 |  1 +
 clippy_lints/src/declared_lints.rs           |  1 +
 clippy_lints/src/methods/mod.rs              | 29 ++++++++++++++++++++++++
 clippy_lints/src/methods/redundant_as_str.rs | 34 ++++++++++++++++++++++++++++
 tests/ui/redundant_as_str.fixed              |  6 +++++
 tests/ui/redundant_as_str.rs                 |  6 +++++
 tests/ui/redundant_as_str.stderr             | 17 ++++++++++++++
 7 files changed, 94 insertions(+)
 create mode 100644 clippy_lints/src/methods/redundant_as_str.rs
 create mode 100644 tests/ui/redundant_as_str.fixed
 create mode 100644 tests/ui/redundant_as_str.rs
 create mode 100644 tests/ui/redundant_as_str.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index a2484203e9e..8c9ab1e2402 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5281,6 +5281,7 @@ Released 2018-09-13
 [`readonly_write_lock`]: https://rust-lang.github.io/rust-clippy/master/index.html#readonly_write_lock
 [`recursive_format_impl`]: https://rust-lang.github.io/rust-clippy/master/index.html#recursive_format_impl
 [`redundant_allocation`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_allocation
+[`redundant_as_str`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_as_str
 [`redundant_async_block`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_async_block
 [`redundant_at_rest_pattern`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_at_rest_pattern
 [`redundant_clone`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_clone
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index b1ffc347812..aa2ca0e1149 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -403,6 +403,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::methods::RANGE_ZIP_WITH_LEN_INFO,
     crate::methods::READONLY_WRITE_LOCK_INFO,
     crate::methods::READ_LINE_WITHOUT_TRIM_INFO,
+    crate::methods::REDUNDANT_AS_STR_INFO,
     crate::methods::REPEAT_ONCE_INFO,
     crate::methods::RESULT_MAP_OR_INTO_OPTION_INFO,
     crate::methods::SEARCH_IS_SOME_INFO,
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index f4682364806..0b0a90bac0c 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -78,6 +78,7 @@ mod path_ends_with_ext;
 mod range_zip_with_len;
 mod read_line_without_trim;
 mod readonly_write_lock;
+mod redundant_as_str;
 mod repeat_once;
 mod search_is_some;
 mod seek_from_current;
@@ -3605,6 +3606,32 @@ declare_clippy_lint! {
     "attempting to compare file extensions using `Path::ends_with`"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of `as_str()` on a `String`` chained with a method available on the `String` itself.
+    ///
+    /// ### Why is this bad?
+    /// The `as_str()` conversion is pointless and can be removed for simplicity and cleanliness.
+    ///
+    /// ### Example
+    /// ```rust
+    /// # #![allow(unused)]
+    /// let owned_string = "This is a string".to_owned();
+    /// owned_string.as_str().as_bytes()
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust
+    /// # #![allow(unused)]
+    /// let owned_string = "This is a string".to_owned();
+    /// owned_string.as_bytes()
+    /// ```
+    #[clippy::version = "1.74.0"]
+    pub REDUNDANT_AS_STR,
+    complexity,
+    "`as_str` used to call a method on `str` that is also available on `String`"
+}
+
 pub struct Methods {
     avoid_breaking_exported_api: bool,
     msrv: Msrv,
@@ -3749,6 +3776,7 @@ impl_lint_pass!(Methods => [
     READONLY_WRITE_LOCK,
     ITER_OUT_OF_BOUNDS,
     PATH_ENDS_WITH_EXT,
+    REDUNDANT_AS_STR,
 ]);
 
 /// Extracts a method call name, args, and `Span` of the method name.
@@ -3975,6 +4003,7 @@ impl Methods {
                 ("as_deref" | "as_deref_mut", []) => {
                     needless_option_as_deref::check(cx, expr, recv, name);
                 },
+                ("as_bytes" | "is_empty", []) => if let Some(("as_str", recv, [], as_str_span, _)) = method_call(recv) { redundant_as_str::check(cx, expr, recv, as_str_span, span); },
                 ("as_mut", []) => useless_asref::check(cx, expr, "as_mut", recv),
                 ("as_ref", []) => useless_asref::check(cx, expr, "as_ref", recv),
                 ("assume_init", []) => uninit_assumed_init::check(cx, expr, recv),
diff --git a/clippy_lints/src/methods/redundant_as_str.rs b/clippy_lints/src/methods/redundant_as_str.rs
new file mode 100644
index 00000000000..98cd6afc2b7
--- /dev/null
+++ b/clippy_lints/src/methods/redundant_as_str.rs
@@ -0,0 +1,34 @@
+use super::REDUNDANT_AS_STR;
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet_with_applicability;
+use rustc_errors::Applicability;
+use rustc_hir::Expr;
+use rustc_lint::LateContext;
+use rustc_middle::query::Key;
+use rustc_span::Span;
+
+pub(super) fn check(
+    cx: &LateContext<'_>,
+    _expr: &Expr<'_>,
+    recv: &Expr<'_>,
+    as_str_span: Span,
+    other_method_span: Span,
+) {
+    if cx
+        .tcx
+        .lang_items()
+        .string()
+        .is_some_and(|id| Some(id) == cx.typeck_results().expr_ty(recv).ty_adt_id())
+    {
+        let mut applicability = Applicability::MachineApplicable;
+        span_lint_and_sugg(
+            cx,
+            REDUNDANT_AS_STR,
+            as_str_span.to(other_method_span),
+            "this `as_str` is redundant and can be removed as the method immediately following exists on `String` too",
+            "try",
+            snippet_with_applicability(cx, other_method_span, "..", &mut applicability).into_owned(),
+            applicability,
+        );
+    }
+}
diff --git a/tests/ui/redundant_as_str.fixed b/tests/ui/redundant_as_str.fixed
new file mode 100644
index 00000000000..f339787e689
--- /dev/null
+++ b/tests/ui/redundant_as_str.fixed
@@ -0,0 +1,6 @@
+#![warn(clippy::redundant_as_str)]
+
+fn main() {
+    let _redundant = "Hello, world!".to_owned().as_bytes();
+    let _redundant = "Hello, world!".to_owned().is_empty();
+}
diff --git a/tests/ui/redundant_as_str.rs b/tests/ui/redundant_as_str.rs
new file mode 100644
index 00000000000..66074df83a8
--- /dev/null
+++ b/tests/ui/redundant_as_str.rs
@@ -0,0 +1,6 @@
+#![warn(clippy::redundant_as_str)]
+
+fn main() {
+    let _redundant = "Hello, world!".to_owned().as_str().as_bytes();
+    let _redundant = "Hello, world!".to_owned().as_str().is_empty();
+}
diff --git a/tests/ui/redundant_as_str.stderr b/tests/ui/redundant_as_str.stderr
new file mode 100644
index 00000000000..32b5232385d
--- /dev/null
+++ b/tests/ui/redundant_as_str.stderr
@@ -0,0 +1,17 @@
+error: this `as_str` is redundant and can be removed as the method immediately following exists on `String` too
+  --> $DIR/redundant_as_str.rs:4:49
+   |
+LL |     let _redundant = "Hello, world!".to_owned().as_str().as_bytes();
+   |                                                 ^^^^^^^^^^^^^^^^^ help: try: `as_bytes`
+   |
+   = note: `-D clippy::redundant-as-str` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::redundant_as_str)]`
+
+error: this `as_str` is redundant and can be removed as the method immediately following exists on `String` too
+  --> $DIR/redundant_as_str.rs:5:49
+   |
+LL |     let _redundant = "Hello, world!".to_owned().as_str().is_empty();
+   |                                                 ^^^^^^^^^^^^^^^^^ help: try: `is_empty`
+
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 01056c5aae63c546c3d988a0b46e502a3a2a7baf Mon Sep 17 00:00:00 2001
From: Dev381 <49997896+Dev380@users.noreply.github.com>
Date: Sun, 17 Sep 2023 18:10:21 -0400
Subject: Fix missing semicolon in redundant_as_str docstring example

---
 clippy_lints/src/methods/mod.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 0b0a90bac0c..bd07e6cbf2e 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3617,14 +3617,14 @@ declare_clippy_lint! {
     /// ```rust
     /// # #![allow(unused)]
     /// let owned_string = "This is a string".to_owned();
-    /// owned_string.as_str().as_bytes()
+    /// owned_string.as_str().as_bytes();
     /// ```
     ///
     /// Use instead:
     /// ```rust
     /// # #![allow(unused)]
     /// let owned_string = "This is a string".to_owned();
-    /// owned_string.as_bytes()
+    /// owned_string.as_bytes();
     /// ```
     #[clippy::version = "1.74.0"]
     pub REDUNDANT_AS_STR,
-- 
cgit 1.4.1-3-g733a5


From b06b915dc04a577cfe599d7e44137124ba12c877 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Mon, 18 Sep 2023 12:10:35 +0000
Subject: Move zero_ptr to the casts module

---
 clippy_lints/src/casts/mod.rs      | 26 ++++++++++++
 clippy_lints/src/casts/zero_ptr.rs | 39 ++++++++++++++++++
 clippy_lints/src/declared_lints.rs |  2 +-
 clippy_lints/src/lib.rs            |  2 +-
 clippy_lints/src/misc.rs           | 84 ++++----------------------------------
 5 files changed, 75 insertions(+), 78 deletions(-)
 create mode 100644 clippy_lints/src/casts/zero_ptr.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index 88ffbb55486..b00130ffd76 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -20,6 +20,7 @@ mod ptr_as_ptr;
 mod ptr_cast_constness;
 mod unnecessary_cast;
 mod utils;
+mod zero_ptr;
 
 use clippy_utils::is_hir_ty_cfg_dependant;
 use clippy_utils::msrvs::{self, Msrv};
@@ -665,6 +666,29 @@ declare_clippy_lint! {
     "casting a known floating-point NaN into an integer"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Catch casts from `0` to some pointer type
+    ///
+    /// ### Why is this bad?
+    /// This generally means `null` and is better expressed as
+    /// {`std`, `core`}`::ptr::`{`null`, `null_mut`}.
+    ///
+    /// ### Example
+    /// ```rust
+    /// let a = 0 as *const u32;
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust
+    /// let a = std::ptr::null::<u32>();
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub ZERO_PTR,
+    style,
+    "using `0 as *{const, mut} T`"
+}
+
 pub struct Casts {
     msrv: Msrv,
 }
@@ -699,6 +723,7 @@ impl_lint_pass!(Casts => [
     CAST_SLICE_FROM_RAW_PARTS,
     AS_PTR_CAST_MUT,
     CAST_NAN_TO_INT,
+    ZERO_PTR,
 ]);
 
 impl<'tcx> LateLintPass<'tcx> for Casts {
@@ -729,6 +754,7 @@ impl<'tcx> LateLintPass<'tcx> for Casts {
             fn_to_numeric_cast_any::check(cx, expr, cast_expr, cast_from, cast_to);
             fn_to_numeric_cast::check(cx, expr, cast_expr, cast_from, cast_to);
             fn_to_numeric_cast_with_truncation::check(cx, expr, cast_expr, cast_from, cast_to);
+            zero_ptr::check(cx, expr, cast_expr, cast_to_hir);
 
             if cast_to.is_numeric() && !in_external_macro(cx.sess(), expr.span) {
                 cast_possible_truncation::check(cx, expr, cast_expr, cast_from, cast_to, cast_to_hir.span);
diff --git a/clippy_lints/src/casts/zero_ptr.rs b/clippy_lints/src/casts/zero_ptr.rs
new file mode 100644
index 00000000000..5071af5ecb9
--- /dev/null
+++ b/clippy_lints/src/casts/zero_ptr.rs
@@ -0,0 +1,39 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet_opt;
+use clippy_utils::{in_constant, is_integer_literal, std_or_core};
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, Mutability, Ty, TyKind};
+use rustc_lint::LateContext;
+
+use super::ZERO_PTR;
+
+pub fn check(cx: &LateContext<'_>, expr: &Expr<'_>, from: &Expr<'_>, to: &Ty<'_>) {
+    if let TyKind::Ptr(ref mut_ty) = to.kind
+        && is_integer_literal(from, 0)
+        && !in_constant(cx, from.hir_id)
+        && let Some(std_or_core) = std_or_core(cx)
+    {
+        let (msg, sugg_fn) = match mut_ty.mutbl {
+            Mutability::Mut => ("`0 as *mut _` detected", "ptr::null_mut"),
+            Mutability::Not => ("`0 as *const _` detected", "ptr::null"),
+        };
+
+        let sugg = if let TyKind::Infer = mut_ty.ty.kind {
+            format!("{std_or_core}::{sugg_fn}()")
+        } else if let Some(mut_ty_snip) = snippet_opt(cx, mut_ty.ty.span) {
+            format!("{std_or_core}::{sugg_fn}::<{mut_ty_snip}>()")
+        } else {
+            return;
+        };
+
+        span_lint_and_sugg(
+            cx,
+            ZERO_PTR,
+            expr.span,
+            msg,
+            "try",
+            sugg,
+            Applicability::MachineApplicable,
+        );
+    }
+}
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index b1ffc347812..d45f4013816 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -97,6 +97,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::casts::PTR_AS_PTR_INFO,
     crate::casts::PTR_CAST_CONSTNESS_INFO,
     crate::casts::UNNECESSARY_CAST_INFO,
+    crate::casts::ZERO_PTR_INFO,
     crate::checked_conversions::CHECKED_CONVERSIONS_INFO,
     crate::cognitive_complexity::COGNITIVE_COMPLEXITY_INFO,
     crate::collapsible_if::COLLAPSIBLE_ELSE_IF_INFO,
@@ -442,7 +443,6 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::misc::SHORT_CIRCUIT_STATEMENT_INFO,
     crate::misc::TOPLEVEL_REF_ARG_INFO,
     crate::misc::USED_UNDERSCORE_BINDING_INFO,
-    crate::misc::ZERO_PTR_INFO,
     crate::misc_early::BUILTIN_TYPE_SHADOW_INFO,
     crate::misc_early::DOUBLE_NEG_INFO,
     crate::misc_early::DUPLICATE_UNDERSCORE_ARGUMENT_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index dcc6ee68e1b..fa009c8b2d6 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -637,7 +637,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(needless_bool::NeedlessBool));
     store.register_late_pass(|_| Box::new(needless_bool::BoolComparison));
     store.register_late_pass(|_| Box::new(needless_for_each::NeedlessForEach));
-    store.register_late_pass(|_| Box::<misc::LintPass>::default());
+    store.register_late_pass(|_| Box::new(misc::LintPass));
     store.register_late_pass(|_| Box::new(eta_reduction::EtaReduction));
     store.register_late_pass(|_| Box::new(mut_mut::MutMut));
     store.register_late_pass(|_| Box::new(mut_reference::UnnecessaryMutPassed));
diff --git a/clippy_lints/src/misc.rs b/clippy_lints/src/misc.rs
index f8e76a5833e..9c8b47fb303 100644
--- a/clippy_lints/src/misc.rs
+++ b/clippy_lints/src/misc.rs
@@ -1,21 +1,20 @@
-use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg, span_lint_and_then, span_lint_hir_and_then};
-use clippy_utils::source::{snippet, snippet_opt, snippet_with_context};
+use clippy_utils::diagnostics::{span_lint, span_lint_and_then, span_lint_hir_and_then};
+use clippy_utils::source::{snippet, snippet_with_context};
 use clippy_utils::sugg::Sugg;
 use clippy_utils::{
-    any_parent_is_automatically_derived, fulfill_or_allowed, get_parent_expr, in_constant, is_integer_literal,
-    is_lint_allowed, is_no_std_crate, iter_input_pats, last_path_segment, SpanlessEq,
+    any_parent_is_automatically_derived, fulfill_or_allowed, get_parent_expr, is_lint_allowed, iter_input_pats,
+    last_path_segment, SpanlessEq,
 };
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::def::Res;
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::{
-    BinOpKind, BindingAnnotation, Body, ByRef, Expr, ExprKind, FnDecl, Mutability, PatKind, QPath, Stmt, StmtKind, Ty,
-    TyKind,
+    BinOpKind, BindingAnnotation, Body, ByRef, Expr, ExprKind, FnDecl, Mutability, PatKind, QPath, Stmt, StmtKind,
 };
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::def_id::LocalDefId;
 use rustc_span::source_map::Span;
 
@@ -55,6 +54,7 @@ declare_clippy_lint! {
     style,
     "an entire binding declared as `ref`, in a function argument or a `let` statement"
 }
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for the use of bindings with a single leading
@@ -102,51 +102,13 @@ declare_clippy_lint! {
     "using a short circuit boolean condition as a statement"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Catch casts from `0` to some pointer type
-    ///
-    /// ### Why is this bad?
-    /// This generally means `null` and is better expressed as
-    /// {`std`, `core`}`::ptr::`{`null`, `null_mut`}.
-    ///
-    /// ### Example
-    /// ```rust
-    /// let a = 0 as *const u32;
-    /// ```
-    ///
-    /// Use instead:
-    /// ```rust
-    /// let a = std::ptr::null::<u32>();
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub ZERO_PTR,
-    style,
-    "using `0 as *{const, mut} T`"
-}
-
-pub struct LintPass {
-    std_or_core: &'static str,
-}
-impl Default for LintPass {
-    fn default() -> Self {
-        Self { std_or_core: "std" }
-    }
-}
-impl_lint_pass!(LintPass => [
+declare_lint_pass!(LintPass => [
     TOPLEVEL_REF_ARG,
     USED_UNDERSCORE_BINDING,
     SHORT_CIRCUIT_STATEMENT,
-    ZERO_PTR,
 ]);
 
 impl<'tcx> LateLintPass<'tcx> for LintPass {
-    fn check_crate(&mut self, cx: &LateContext<'_>) {
-        if is_no_std_crate(cx) {
-            self.std_or_core = "core";
-        }
-    }
-
     fn check_fn(
         &mut self,
         cx: &LateContext<'tcx>,
@@ -252,10 +214,6 @@ impl<'tcx> LateLintPass<'tcx> for LintPass {
     }
 
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if let ExprKind::Cast(e, ty) = expr.kind {
-            self.check_cast(cx, expr.span, e, ty);
-            return;
-        }
         if in_external_macro(cx.sess(), expr.span)
             || expr.span.desugaring_kind().is_some()
             || any_parent_is_automatically_derived(cx.tcx, expr.hir_id)
@@ -320,29 +278,3 @@ fn is_used(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
         _ => is_used(cx, parent),
     })
 }
-
-impl LintPass {
-    fn check_cast(&self, cx: &LateContext<'_>, span: Span, e: &Expr<'_>, ty: &Ty<'_>) {
-        if_chain! {
-            if let TyKind::Ptr(ref mut_ty) = ty.kind;
-            if is_integer_literal(e, 0);
-            if !in_constant(cx, e.hir_id);
-            then {
-                let (msg, sugg_fn) = match mut_ty.mutbl {
-                    Mutability::Mut => ("`0 as *mut _` detected", "ptr::null_mut"),
-                    Mutability::Not => ("`0 as *const _` detected", "ptr::null"),
-                };
-
-                let (sugg, appl) = if let TyKind::Infer = mut_ty.ty.kind {
-                    (format!("{}::{sugg_fn}()", self.std_or_core), Applicability::MachineApplicable)
-                } else if let Some(mut_ty_snip) = snippet_opt(cx, mut_ty.ty.span) {
-                    (format!("{}::{sugg_fn}::<{mut_ty_snip}>()", self.std_or_core), Applicability::MachineApplicable)
-                } else {
-                    // `MaybeIncorrect` as type inference may not work with the suggested code
-                    (format!("{}::{sugg_fn}()", self.std_or_core), Applicability::MaybeIncorrect)
-                };
-                span_lint_and_sugg(cx, ZERO_PTR, span, msg, "try", sugg, appl);
-            }
-        }
-    }
-}
-- 
cgit 1.4.1-3-g733a5


From b8b420cc79dc18423a9bf59ee3397a398e9aac2a Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Mon, 18 Sep 2023 15:47:24 +0200
Subject: Improve code readability by moving the retrieval of closures inside
 async functions right besides other closures handling.

Add doc comment explaining what `MutablyUsedVariablesCtxt::prev_move_to_closure` is about.
---
 clippy_lints/src/needless_pass_by_ref_mut.rs | 57 ++++++++++------------------
 1 file changed, 19 insertions(+), 38 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/needless_pass_by_ref_mut.rs b/clippy_lints/src/needless_pass_by_ref_mut.rs
index bea44ed92ef..36ca61c0b44 100644
--- a/clippy_lints/src/needless_pass_by_ref_mut.rs
+++ b/clippy_lints/src/needless_pass_by_ref_mut.rs
@@ -1,13 +1,13 @@
 use super::needless_pass_by_value::requires_exact_signature;
 use clippy_utils::diagnostics::span_lint_hir_and_then;
 use clippy_utils::source::snippet;
+use clippy_utils::visitors::for_each_expr_with_closures;
 use clippy_utils::{get_parent_node, inherits_cfg, is_from_proc_macro, is_self};
 use rustc_data_structures::fx::{FxHashSet, FxIndexMap};
 use rustc_errors::Applicability;
-use rustc_hir::intravisit::{walk_fn, walk_qpath, FnKind, Visitor};
+use rustc_hir::intravisit::{walk_qpath, FnKind, Visitor};
 use rustc_hir::{
-    Body, BodyId, Closure, Expr, ExprKind, FnDecl, HirId, HirIdMap, HirIdSet, Impl, ItemKind, Mutability, Node,
-    PatKind, QPath,
+    Body, Closure, Expr, ExprKind, FnDecl, HirId, HirIdMap, HirIdSet, Impl, ItemKind, Mutability, Node, PatKind, QPath,
 };
 use rustc_hir_typeck::expr_use_visitor as euv;
 use rustc_infer::infer::{InferCtxt, TyCtxtInferExt};
@@ -22,6 +22,8 @@ use rustc_span::symbol::kw;
 use rustc_span::Span;
 use rustc_target::spec::abi::Abi;
 
+use core::ops::ControlFlow;
+
 declare_clippy_lint! {
     /// ### What it does
     /// Check if a `&mut` function argument is actually used mutably.
@@ -189,17 +191,19 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByRefMut<'tcx> {
 
                 // We retrieve all the closures declared in the async function because they will
                 // not be found by `euv::Delegate`.
-                let mut closures_retriever = ClosuresRetriever {
-                    cx,
-                    closures: FxHashSet::default(),
-                };
-                walk_fn(&mut closures_retriever, kind, decl, body.id(), fn_def_id);
-                check_closures(&mut ctx, cx, &infcx, &mut checked_closures, closures_retriever.closures);
+                let mut closures: FxHashSet<LocalDefId> = FxHashSet::default();
+                for_each_expr_with_closures(cx, body, |expr| {
+                    if let ExprKind::Closure(closure) = expr.kind {
+                        closures.insert(closure.def_id);
+                    }
+                    ControlFlow::<()>::Continue(())
+                });
+                check_closures(&mut ctx, cx, &infcx, &mut checked_closures, closures);
 
                 while !ctx.async_closures.is_empty() {
-                    let closures = ctx.async_closures.clone();
+                    let async_closures = ctx.async_closures.clone();
                     ctx.async_closures.clear();
-                    check_closures(&mut ctx, cx, &infcx, &mut checked_closures, closures);
+                    check_closures(&mut ctx, cx, &infcx, &mut checked_closures, async_closures);
                 }
             }
             ctx
@@ -264,6 +268,10 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByRefMut<'tcx> {
 struct MutablyUsedVariablesCtxt<'tcx> {
     mutably_used_vars: HirIdSet,
     prev_bind: Option<HirId>,
+    /// In async functions, the inner AST is composed of multiple layers until we reach the code
+    /// defined by the user. Because of that, some variables are marked as mutably borrowed even
+    /// though they're not. This field lists the `HirId` that should not be considered as mutable
+    /// use of a variable.
     prev_move_to_closure: HirIdSet,
     aliases: HirIdMap<HirId>,
     async_closures: FxHashSet<LocalDefId>,
@@ -459,30 +467,3 @@ impl<'tcx> Visitor<'tcx> for FnNeedsMutVisitor<'_, 'tcx> {
         }
     }
 }
-
-struct ClosuresRetriever<'a, 'tcx> {
-    cx: &'a LateContext<'tcx>,
-    closures: FxHashSet<LocalDefId>,
-}
-
-impl<'a, 'tcx> Visitor<'tcx> for ClosuresRetriever<'a, 'tcx> {
-    type NestedFilter = OnlyBodies;
-
-    fn nested_visit_map(&mut self) -> Self::Map {
-        self.cx.tcx.hir()
-    }
-
-    fn visit_fn(
-        &mut self,
-        kind: FnKind<'tcx>,
-        decl: &'tcx FnDecl<'tcx>,
-        body_id: BodyId,
-        _span: Span,
-        fn_def_id: LocalDefId,
-    ) {
-        if matches!(kind, FnKind::Closure) {
-            self.closures.insert(fn_def_id);
-        }
-        walk_fn(self, kind, decl, body_id, fn_def_id);
-    }
-}
-- 
cgit 1.4.1-3-g733a5


From 1b3e5dd0fcae6056e8ab435b795eb4d73f69230d Mon Sep 17 00:00:00 2001
From: Trevor Gross <tmgross@umich.edu>
Date: Mon, 17 Jul 2023 00:30:24 -0400
Subject: Change default configuration of `undocumented_unsafe_blocks`

This patch sets the two configuration options for
`undocumented_unsafe_blocks` to `true` by default: these are
`accept-comment-above-statement` and `accept-comment-above-attributes`.
Having these values `false` by default prevents what many users would
consider clean code, e.g. placing the `// SAFETY:` comment above a
single-line functino call, rather than directly next to the argument.

changelog: [`undocumented_unsafe_blocks`]: set
`accept-comment-above-statement` and `accept-comment-above-attributes`
to `true` by default.
---
 book/src/lint_configuration.md                     |   4 +-
 clippy_lints/src/utils/conf.rs                     |   4 +-
 .../ui-toml/undocumented_unsafe_blocks/clippy.toml |   2 -
 .../undocumented_unsafe_blocks/default/clippy.toml |   2 +
 .../disabled/clippy.toml                           |   3 +
 .../undocumented_unsafe_blocks.default.stderr      | 316 ++++++++++++
 .../undocumented_unsafe_blocks.disabled.stderr     | 396 +++++++++++++++
 .../undocumented_unsafe_blocks.rs                  |  30 +-
 .../undocumented_unsafe_blocks.stderr              | 316 ------------
 tests/ui/undocumented_unsafe_blocks.rs             | 534 ---------------------
 tests/ui/undocumented_unsafe_blocks.stderr         | 348 --------------
 11 files changed, 738 insertions(+), 1217 deletions(-)
 delete mode 100644 tests/ui-toml/undocumented_unsafe_blocks/clippy.toml
 create mode 100644 tests/ui-toml/undocumented_unsafe_blocks/default/clippy.toml
 create mode 100644 tests/ui-toml/undocumented_unsafe_blocks/disabled/clippy.toml
 create mode 100644 tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.default.stderr
 create mode 100644 tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.disabled.stderr
 delete mode 100644 tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.stderr
 delete mode 100644 tests/ui/undocumented_unsafe_blocks.rs
 delete mode 100644 tests/ui/undocumented_unsafe_blocks.stderr

(limited to 'clippy_lints/src')

diff --git a/book/src/lint_configuration.md b/book/src/lint_configuration.md
index 3aeb6206fca..b980083f1f5 100644
--- a/book/src/lint_configuration.md
+++ b/book/src/lint_configuration.md
@@ -703,7 +703,7 @@ Minimum chars an ident can have, anything below or equal to this will be linted.
 ## `accept-comment-above-statement`
 Whether to accept a safety comment to be placed above the statement containing the `unsafe` block
 
-**Default Value:** `false` (`bool`)
+**Default Value:** `true` (`bool`)
 
 ---
 **Affected lints:**
@@ -713,7 +713,7 @@ Whether to accept a safety comment to be placed above the statement containing t
 ## `accept-comment-above-attributes`
 Whether to accept a safety comment to be placed above the attributes for the `unsafe` block
 
-**Default Value:** `false` (`bool`)
+**Default Value:** `true` (`bool`)
 
 ---
 **Affected lints:**
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index e1280ef38ef..75c3c7a958a 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -542,11 +542,11 @@ define_Conf! {
     /// Lint: UNDOCUMENTED_UNSAFE_BLOCKS.
     ///
     /// Whether to accept a safety comment to be placed above the statement containing the `unsafe` block
-    (accept_comment_above_statement: bool = false),
+    (accept_comment_above_statement: bool = true),
     /// Lint: UNDOCUMENTED_UNSAFE_BLOCKS.
     ///
     /// Whether to accept a safety comment to be placed above the attributes for the `unsafe` block
-    (accept_comment_above_attributes: bool = false),
+    (accept_comment_above_attributes: bool = true),
     /// Lint: UNNECESSARY_RAW_STRING_HASHES.
     ///
     /// Whether to allow `r#""#` when `r""` can be used
diff --git a/tests/ui-toml/undocumented_unsafe_blocks/clippy.toml b/tests/ui-toml/undocumented_unsafe_blocks/clippy.toml
deleted file mode 100644
index e6dbb3d3784..00000000000
--- a/tests/ui-toml/undocumented_unsafe_blocks/clippy.toml
+++ /dev/null
@@ -1,2 +0,0 @@
-accept-comment-above-statement = true
-accept-comment-above-attributes = true
diff --git a/tests/ui-toml/undocumented_unsafe_blocks/default/clippy.toml b/tests/ui-toml/undocumented_unsafe_blocks/default/clippy.toml
new file mode 100644
index 00000000000..3b205d536f2
--- /dev/null
+++ b/tests/ui-toml/undocumented_unsafe_blocks/default/clippy.toml
@@ -0,0 +1,2 @@
+# default configuration has `accept-comment-above-statement` and
+# `accept-comment-above-attributes` true
diff --git a/tests/ui-toml/undocumented_unsafe_blocks/disabled/clippy.toml b/tests/ui-toml/undocumented_unsafe_blocks/disabled/clippy.toml
new file mode 100644
index 00000000000..57ecb902d65
--- /dev/null
+++ b/tests/ui-toml/undocumented_unsafe_blocks/disabled/clippy.toml
@@ -0,0 +1,3 @@
+# test with these options disabled
+accept-comment-above-statement = false
+accept-comment-above-attributes = false
diff --git a/tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.default.stderr b/tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.default.stderr
new file mode 100644
index 00000000000..15edf2a7dae
--- /dev/null
+++ b/tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.default.stderr
@@ -0,0 +1,316 @@
+error: unsafe block missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:266:19
+   |
+LL |     /* Safety: */ unsafe {}
+   |                   ^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+   = note: `-D clippy::undocumented-unsafe-blocks` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::undocumented_unsafe_blocks)]`
+
+error: unsafe block missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:270:5
+   |
+LL |     unsafe {}
+   |     ^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: unsafe block missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:274:14
+   |
+LL |     let _ = [unsafe { 14 }, unsafe { 15 }, 42, unsafe { 16 }];
+   |              ^^^^^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: unsafe block missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:274:29
+   |
+LL |     let _ = [unsafe { 14 }, unsafe { 15 }, 42, unsafe { 16 }];
+   |                             ^^^^^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: unsafe block missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:274:48
+   |
+LL |     let _ = [unsafe { 14 }, unsafe { 15 }, 42, unsafe { 16 }];
+   |                                                ^^^^^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: unsafe block missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:278:18
+   |
+LL |     let _ = (42, unsafe {}, "test", unsafe {});
+   |                  ^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: unsafe block missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:278:37
+   |
+LL |     let _ = (42, unsafe {}, "test", unsafe {});
+   |                                     ^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: unsafe block missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:282:14
+   |
+LL |     let _ = *unsafe { &42 };
+   |              ^^^^^^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: unsafe block missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:287:19
+   |
+LL |     let _ = match unsafe {} {
+   |                   ^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: unsafe block missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:293:14
+   |
+LL |     let _ = &unsafe {};
+   |              ^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: unsafe block missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:297:14
+   |
+LL |     let _ = [unsafe {}; 5];
+   |              ^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: unsafe block missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:301:13
+   |
+LL |     let _ = unsafe {};
+   |             ^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: unsafe block missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:311:8
+   |
+LL |     t!(unsafe {});
+   |        ^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: unsafe block missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:317:13
+   |
+LL |             unsafe {}
+   |             ^^^^^^^^^
+...
+LL |     t!();
+   |     ---- in this macro invocation
+   |
+   = help: consider adding a safety comment on the preceding line
+   = note: this error originates in the macro `t` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: unsafe block missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:325:5
+   |
+LL |     unsafe {} // SAFETY:
+   |     ^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: unsafe block missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:329:5
+   |
+LL |     unsafe {
+   |     ^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: unsafe block missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:339:5
+   |
+LL |     unsafe {};
+   |     ^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: unsafe block missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:343:20
+   |
+LL |     println!("{}", unsafe { String::from_utf8_unchecked(vec![]) });
+   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: unsafe impl missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:350:5
+   |
+LL |     unsafe impl A for () {}
+   |     ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: unsafe impl missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:357:9
+   |
+LL |         unsafe impl B for (u32) {}
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: unsafe impl missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:378:13
+   |
+LL |             unsafe impl T for $t {}
+   |             ^^^^^^^^^^^^^^^^^^^^^^^
+...
+LL |     no_safety_comment!(());
+   |     ---------------------- in this macro invocation
+   |
+   = help: consider adding a safety comment on the preceding line
+   = note: this error originates in the macro `no_safety_comment` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: unsafe impl missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:403:13
+   |
+LL |             unsafe impl T for $t {}
+   |             ^^^^^^^^^^^^^^^^^^^^^^^
+...
+LL |     no_safety_comment!(());
+   |     ---------------------- in this macro invocation
+   |
+   = help: consider adding a safety comment on the preceding line
+   = note: this error originates in the macro `no_safety_comment` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: unsafe impl missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:411:5
+   |
+LL |     unsafe impl T for (i32) {}
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: unsafe impl missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:403:13
+   |
+LL |             unsafe impl T for $t {}
+   |             ^^^^^^^^^^^^^^^^^^^^^^^
+...
+LL |     no_safety_comment!(u32);
+   |     ----------------------- in this macro invocation
+   |
+   = help: consider adding a safety comment on the preceding line
+   = note: this error originates in the macro `no_safety_comment` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: unsafe impl missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:417:5
+   |
+LL |     unsafe impl T for (bool) {}
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: unsafe impl missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:463:5
+   |
+LL |     unsafe impl NoComment for () {}
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: unsafe impl missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:467:19
+   |
+LL |     /* SAFETY: */ unsafe impl InlineComment for () {}
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: unsafe impl missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:471:5
+   |
+LL |     unsafe impl TrailingComment for () {} // SAFETY:
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: constant item has unnecessary safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:475:5
+   |
+LL |     const BIG_NUMBER: i32 = 1000000;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider removing the safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:474:5
+   |
+LL |     // SAFETY:
+   |     ^^^^^^^^^^
+   = note: `-D clippy::unnecessary-safety-comment` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::unnecessary_safety_comment)]`
+
+error: unsafe impl missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:476:5
+   |
+LL |     unsafe impl Interference for () {}
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: unsafe impl missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:483:5
+   |
+LL |     unsafe impl ImplInFn for () {}
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: unsafe impl missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:492:1
+   |
+LL | unsafe impl CrateRoot for () {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: statement has unnecessary safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:505:5
+   |
+LL | /     let _ = {
+LL | |         if unsafe { true } {
+LL | |             todo!();
+LL | |         } else {
+...  |
+LL | |         }
+LL | |     };
+   | |______^
+   |
+help: consider removing the safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:504:5
+   |
+LL |     // SAFETY: this is more than one level away, so it should warn
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: unsafe block missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:506:12
+   |
+LL |         if unsafe { true } {
+   |            ^^^^^^^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: unsafe block missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:509:23
+   |
+LL |             let bar = unsafe {};
+   |                       ^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: aborting due to 35 previous errors
+
diff --git a/tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.disabled.stderr b/tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.disabled.stderr
new file mode 100644
index 00000000000..cc9530f79b6
--- /dev/null
+++ b/tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.disabled.stderr
@@ -0,0 +1,396 @@
+error: unsafe block missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:266:19
+   |
+LL |     /* Safety: */ unsafe {}
+   |                   ^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+   = note: `-D clippy::undocumented-unsafe-blocks` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::undocumented_unsafe_blocks)]`
+
+error: unsafe block missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:270:5
+   |
+LL |     unsafe {}
+   |     ^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: unsafe block missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:274:14
+   |
+LL |     let _ = [unsafe { 14 }, unsafe { 15 }, 42, unsafe { 16 }];
+   |              ^^^^^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: unsafe block missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:274:29
+   |
+LL |     let _ = [unsafe { 14 }, unsafe { 15 }, 42, unsafe { 16 }];
+   |                             ^^^^^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: unsafe block missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:274:48
+   |
+LL |     let _ = [unsafe { 14 }, unsafe { 15 }, 42, unsafe { 16 }];
+   |                                                ^^^^^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: unsafe block missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:278:18
+   |
+LL |     let _ = (42, unsafe {}, "test", unsafe {});
+   |                  ^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: unsafe block missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:278:37
+   |
+LL |     let _ = (42, unsafe {}, "test", unsafe {});
+   |                                     ^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: unsafe block missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:282:14
+   |
+LL |     let _ = *unsafe { &42 };
+   |              ^^^^^^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: unsafe block missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:287:19
+   |
+LL |     let _ = match unsafe {} {
+   |                   ^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: unsafe block missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:293:14
+   |
+LL |     let _ = &unsafe {};
+   |              ^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: unsafe block missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:297:14
+   |
+LL |     let _ = [unsafe {}; 5];
+   |              ^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: unsafe block missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:301:13
+   |
+LL |     let _ = unsafe {};
+   |             ^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: unsafe block missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:311:8
+   |
+LL |     t!(unsafe {});
+   |        ^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: unsafe block missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:317:13
+   |
+LL |             unsafe {}
+   |             ^^^^^^^^^
+...
+LL |     t!();
+   |     ---- in this macro invocation
+   |
+   = help: consider adding a safety comment on the preceding line
+   = note: this error originates in the macro `t` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: unsafe block missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:325:5
+   |
+LL |     unsafe {} // SAFETY:
+   |     ^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: unsafe block missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:329:5
+   |
+LL |     unsafe {
+   |     ^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: unsafe block missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:339:5
+   |
+LL |     unsafe {};
+   |     ^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: unsafe block missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:343:20
+   |
+LL |     println!("{}", unsafe { String::from_utf8_unchecked(vec![]) });
+   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: unsafe impl missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:350:5
+   |
+LL |     unsafe impl A for () {}
+   |     ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: unsafe impl missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:357:9
+   |
+LL |         unsafe impl B for (u32) {}
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: unsafe impl missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:378:13
+   |
+LL |             unsafe impl T for $t {}
+   |             ^^^^^^^^^^^^^^^^^^^^^^^
+...
+LL |     no_safety_comment!(());
+   |     ---------------------- in this macro invocation
+   |
+   = help: consider adding a safety comment on the preceding line
+   = note: this error originates in the macro `no_safety_comment` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: unsafe impl missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:403:13
+   |
+LL |             unsafe impl T for $t {}
+   |             ^^^^^^^^^^^^^^^^^^^^^^^
+...
+LL |     no_safety_comment!(());
+   |     ---------------------- in this macro invocation
+   |
+   = help: consider adding a safety comment on the preceding line
+   = note: this error originates in the macro `no_safety_comment` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: unsafe impl missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:411:5
+   |
+LL |     unsafe impl T for (i32) {}
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: unsafe impl missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:403:13
+   |
+LL |             unsafe impl T for $t {}
+   |             ^^^^^^^^^^^^^^^^^^^^^^^
+...
+LL |     no_safety_comment!(u32);
+   |     ----------------------- in this macro invocation
+   |
+   = help: consider adding a safety comment on the preceding line
+   = note: this error originates in the macro `no_safety_comment` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: unsafe impl missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:417:5
+   |
+LL |     unsafe impl T for (bool) {}
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: unsafe impl missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:463:5
+   |
+LL |     unsafe impl NoComment for () {}
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: unsafe impl missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:467:19
+   |
+LL |     /* SAFETY: */ unsafe impl InlineComment for () {}
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: unsafe impl missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:471:5
+   |
+LL |     unsafe impl TrailingComment for () {} // SAFETY:
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: constant item has unnecessary safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:475:5
+   |
+LL |     const BIG_NUMBER: i32 = 1000000;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider removing the safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:474:5
+   |
+LL |     // SAFETY:
+   |     ^^^^^^^^^^
+   = note: `-D clippy::unnecessary-safety-comment` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::unnecessary_safety_comment)]`
+
+error: unsafe impl missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:476:5
+   |
+LL |     unsafe impl Interference for () {}
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: unsafe impl missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:483:5
+   |
+LL |     unsafe impl ImplInFn for () {}
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: unsafe impl missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:492:1
+   |
+LL | unsafe impl CrateRoot for () {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: unsafe block missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:502:9
+   |
+LL |         unsafe {};
+   |         ^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: statement has unnecessary safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:505:5
+   |
+LL | /     let _ = {
+LL | |         if unsafe { true } {
+LL | |             todo!();
+LL | |         } else {
+...  |
+LL | |         }
+LL | |     };
+   | |______^
+   |
+help: consider removing the safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:504:5
+   |
+LL |     // SAFETY: this is more than one level away, so it should warn
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: unsafe block missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:506:12
+   |
+LL |         if unsafe { true } {
+   |            ^^^^^^^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: unsafe block missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:509:23
+   |
+LL |             let bar = unsafe {};
+   |                       ^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: unsafe block missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:527:9
+   |
+LL |         unsafe { a_function_with_a_very_long_name_to_break_the_line() };
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: unsafe block missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:531:9
+   |
+LL |         unsafe { a_const_function_with_a_very_long_name_to_break_the_line() };
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: unsafe block missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:535:9
+   |
+LL |         unsafe { a_const_function_with_a_very_long_name_to_break_the_line() };
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: unsafe block missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:541:5
+   |
+LL |     unsafe {}
+   |     ^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: unsafe block missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:545:5
+   |
+LL |     unsafe {
+   |     ^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: unsafe block missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:552:9
+   |
+LL |         unsafe { a_function_with_a_very_long_name_to_break_the_line() };
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: unsafe block missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:557:9
+   |
+LL |         unsafe { a_const_function_with_a_very_long_name_to_break_the_line() };
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: unsafe block missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:563:9
+   |
+LL |         unsafe { a_const_function_with_a_very_long_name_to_break_the_line() };
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: unsafe block missing a safety comment
+  --> $DIR/undocumented_unsafe_blocks.rs:568:5
+   |
+LL |     unsafe {}
+   |     ^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: aborting due to 45 previous errors
+
diff --git a/tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs b/tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs
index b28e1b7d180..a2781398760 100644
--- a/tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs
+++ b/tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs
@@ -1,4 +1,7 @@
 //@aux-build:../../ui/auxiliary/proc_macro_unsafe.rs
+//@revisions: default disabled
+//@[default] rustc-env:CLIPPY_CONF_DIR=tests/ui-toml/undocumented_unsafe_blocks/default
+//@[disabled] rustc-env:CLIPPY_CONF_DIR=tests/ui-toml/undocumented_unsafe_blocks/disabled
 
 #![warn(clippy::undocumented_unsafe_blocks, clippy::unnecessary_safety_comment)]
 #![allow(deref_nullptr, clippy::let_unit_value, clippy::missing_safety_doc)]
@@ -491,7 +494,7 @@ unsafe impl CrateRoot for () {}
 // SAFETY: ok
 unsafe impl CrateRoot for (i32) {}
 
-fn issue_9142() {
+fn nested_block_separation_issue_9142() {
     // SAFETY: ok
     let _ =
         // we need this comment to avoid rustfmt putting
@@ -518,49 +521,50 @@ pub const unsafe fn a_const_function_with_a_very_long_name_to_break_the_line() -
     2
 }
 
-fn issue_10832() {
-    // Safety: A safety comment
+fn separate_line_from_let_issue_10832() {
+    // SAFETY: fail ONLY if `accept-comment-above-statement = false`
     let _some_variable_with_a_very_long_name_to_break_the_line =
         unsafe { a_function_with_a_very_long_name_to_break_the_line() };
 
-    // Safety: Another safety comment
+    // SAFETY: fail ONLY if `accept-comment-above-statement = false`
     const _SOME_CONST_WITH_A_VERY_LONG_NAME_TO_BREAK_THE_LINE: u32 =
         unsafe { a_const_function_with_a_very_long_name_to_break_the_line() };
 
-    // Safety: Yet another safety comment
+    // SAFETY: fail ONLY if `accept-comment-above-statement = false`
     static _SOME_STATIC_WITH_A_VERY_LONG_NAME_TO_BREAK_THE_LINE: u32 =
         unsafe { a_const_function_with_a_very_long_name_to_break_the_line() };
 }
 
-fn issue_8679<T: Copy>() {
-    // SAFETY:
+fn above_expr_attribute_issue_8679<T: Copy>() {
+    // SAFETY: fail ONLY if `accept-comment-above-attribute = false`
     #[allow(unsafe_code)]
     unsafe {}
 
-    // SAFETY:
+    // SAFETY: fail ONLY if `accept-comment-above-attribute = false`
     #[expect(unsafe_code, reason = "totally safe")]
     unsafe {
         *std::ptr::null::<T>()
     };
 
-    // Safety: A safety comment
+    // SAFETY: fail ONLY if `accept-comment-above-attribute = false`
     #[allow(unsafe_code)]
     let _some_variable_with_a_very_long_name_to_break_the_line =
         unsafe { a_function_with_a_very_long_name_to_break_the_line() };
 
-    // Safety: Another safety comment
+    // SAFETY: fail ONLY if `accept-comment-above-attribute = false`
     #[allow(unsafe_code)]
     const _SOME_CONST_WITH_A_VERY_LONG_NAME_TO_BREAK_THE_LINE: u32 =
         unsafe { a_const_function_with_a_very_long_name_to_break_the_line() };
 
-    // Safety: Yet another safety comment
+    // SAFETY: fail ONLY if `accept-comment-above-attribute = false`
     #[allow(unsafe_code)]
-    static _SOME_STATIC_WITH_A_VERY_LONG_NAME_TO_BREAK_THE_LINE: u32 =
+    #[allow(non_upper_case_globals)]
+    static _some_static_with_a_very_long_name_to_break_the_line: u32 =
         unsafe { a_const_function_with_a_very_long_name_to_break_the_line() };
 
     // SAFETY:
     #[allow(unsafe_code)]
-    // This also works I guess
+    // This shouldn't work either
     unsafe {}
 }
 
diff --git a/tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.stderr b/tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.stderr
deleted file mode 100644
index 183c07fe786..00000000000
--- a/tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.stderr
+++ /dev/null
@@ -1,316 +0,0 @@
-error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:263:19
-   |
-LL |     /* Safety: */ unsafe {}
-   |                   ^^^^^^^^^
-   |
-   = help: consider adding a safety comment on the preceding line
-   = note: `-D clippy::undocumented-unsafe-blocks` implied by `-D warnings`
-   = help: to override `-D warnings` add `#[allow(clippy::undocumented_unsafe_blocks)]`
-
-error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:267:5
-   |
-LL |     unsafe {}
-   |     ^^^^^^^^^
-   |
-   = help: consider adding a safety comment on the preceding line
-
-error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:271:14
-   |
-LL |     let _ = [unsafe { 14 }, unsafe { 15 }, 42, unsafe { 16 }];
-   |              ^^^^^^^^^^^^^
-   |
-   = help: consider adding a safety comment on the preceding line
-
-error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:271:29
-   |
-LL |     let _ = [unsafe { 14 }, unsafe { 15 }, 42, unsafe { 16 }];
-   |                             ^^^^^^^^^^^^^
-   |
-   = help: consider adding a safety comment on the preceding line
-
-error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:271:48
-   |
-LL |     let _ = [unsafe { 14 }, unsafe { 15 }, 42, unsafe { 16 }];
-   |                                                ^^^^^^^^^^^^^
-   |
-   = help: consider adding a safety comment on the preceding line
-
-error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:275:18
-   |
-LL |     let _ = (42, unsafe {}, "test", unsafe {});
-   |                  ^^^^^^^^^
-   |
-   = help: consider adding a safety comment on the preceding line
-
-error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:275:37
-   |
-LL |     let _ = (42, unsafe {}, "test", unsafe {});
-   |                                     ^^^^^^^^^
-   |
-   = help: consider adding a safety comment on the preceding line
-
-error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:279:14
-   |
-LL |     let _ = *unsafe { &42 };
-   |              ^^^^^^^^^^^^^^
-   |
-   = help: consider adding a safety comment on the preceding line
-
-error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:284:19
-   |
-LL |     let _ = match unsafe {} {
-   |                   ^^^^^^^^^
-   |
-   = help: consider adding a safety comment on the preceding line
-
-error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:290:14
-   |
-LL |     let _ = &unsafe {};
-   |              ^^^^^^^^^
-   |
-   = help: consider adding a safety comment on the preceding line
-
-error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:294:14
-   |
-LL |     let _ = [unsafe {}; 5];
-   |              ^^^^^^^^^
-   |
-   = help: consider adding a safety comment on the preceding line
-
-error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:298:13
-   |
-LL |     let _ = unsafe {};
-   |             ^^^^^^^^^
-   |
-   = help: consider adding a safety comment on the preceding line
-
-error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:308:8
-   |
-LL |     t!(unsafe {});
-   |        ^^^^^^^^^
-   |
-   = help: consider adding a safety comment on the preceding line
-
-error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:314:13
-   |
-LL |             unsafe {}
-   |             ^^^^^^^^^
-...
-LL |     t!();
-   |     ---- in this macro invocation
-   |
-   = help: consider adding a safety comment on the preceding line
-   = note: this error originates in the macro `t` (in Nightly builds, run with -Z macro-backtrace for more info)
-
-error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:322:5
-   |
-LL |     unsafe {} // SAFETY:
-   |     ^^^^^^^^^
-   |
-   = help: consider adding a safety comment on the preceding line
-
-error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:326:5
-   |
-LL |     unsafe {
-   |     ^^^^^^^^
-   |
-   = help: consider adding a safety comment on the preceding line
-
-error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:336:5
-   |
-LL |     unsafe {};
-   |     ^^^^^^^^^
-   |
-   = help: consider adding a safety comment on the preceding line
-
-error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:340:20
-   |
-LL |     println!("{}", unsafe { String::from_utf8_unchecked(vec![]) });
-   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: consider adding a safety comment on the preceding line
-
-error: unsafe impl missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:347:5
-   |
-LL |     unsafe impl A for () {}
-   |     ^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: consider adding a safety comment on the preceding line
-
-error: unsafe impl missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:354:9
-   |
-LL |         unsafe impl B for (u32) {}
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: consider adding a safety comment on the preceding line
-
-error: unsafe impl missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:375:13
-   |
-LL |             unsafe impl T for $t {}
-   |             ^^^^^^^^^^^^^^^^^^^^^^^
-...
-LL |     no_safety_comment!(());
-   |     ---------------------- in this macro invocation
-   |
-   = help: consider adding a safety comment on the preceding line
-   = note: this error originates in the macro `no_safety_comment` (in Nightly builds, run with -Z macro-backtrace for more info)
-
-error: unsafe impl missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:400:13
-   |
-LL |             unsafe impl T for $t {}
-   |             ^^^^^^^^^^^^^^^^^^^^^^^
-...
-LL |     no_safety_comment!(());
-   |     ---------------------- in this macro invocation
-   |
-   = help: consider adding a safety comment on the preceding line
-   = note: this error originates in the macro `no_safety_comment` (in Nightly builds, run with -Z macro-backtrace for more info)
-
-error: unsafe impl missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:408:5
-   |
-LL |     unsafe impl T for (i32) {}
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: consider adding a safety comment on the preceding line
-
-error: unsafe impl missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:400:13
-   |
-LL |             unsafe impl T for $t {}
-   |             ^^^^^^^^^^^^^^^^^^^^^^^
-...
-LL |     no_safety_comment!(u32);
-   |     ----------------------- in this macro invocation
-   |
-   = help: consider adding a safety comment on the preceding line
-   = note: this error originates in the macro `no_safety_comment` (in Nightly builds, run with -Z macro-backtrace for more info)
-
-error: unsafe impl missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:414:5
-   |
-LL |     unsafe impl T for (bool) {}
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: consider adding a safety comment on the preceding line
-
-error: unsafe impl missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:460:5
-   |
-LL |     unsafe impl NoComment for () {}
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: consider adding a safety comment on the preceding line
-
-error: unsafe impl missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:464:19
-   |
-LL |     /* SAFETY: */ unsafe impl InlineComment for () {}
-   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: consider adding a safety comment on the preceding line
-
-error: unsafe impl missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:468:5
-   |
-LL |     unsafe impl TrailingComment for () {} // SAFETY:
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: consider adding a safety comment on the preceding line
-
-error: constant item has unnecessary safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:472:5
-   |
-LL |     const BIG_NUMBER: i32 = 1000000;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: consider removing the safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:471:5
-   |
-LL |     // SAFETY:
-   |     ^^^^^^^^^^
-   = note: `-D clippy::unnecessary-safety-comment` implied by `-D warnings`
-   = help: to override `-D warnings` add `#[allow(clippy::unnecessary_safety_comment)]`
-
-error: unsafe impl missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:473:5
-   |
-LL |     unsafe impl Interference for () {}
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: consider adding a safety comment on the preceding line
-
-error: unsafe impl missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:480:5
-   |
-LL |     unsafe impl ImplInFn for () {}
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: consider adding a safety comment on the preceding line
-
-error: unsafe impl missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:489:1
-   |
-LL | unsafe impl CrateRoot for () {}
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: consider adding a safety comment on the preceding line
-
-error: statement has unnecessary safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:502:5
-   |
-LL | /     let _ = {
-LL | |         if unsafe { true } {
-LL | |             todo!();
-LL | |         } else {
-...  |
-LL | |         }
-LL | |     };
-   | |______^
-   |
-help: consider removing the safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:501:5
-   |
-LL |     // SAFETY: this is more than one level away, so it should warn
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:503:12
-   |
-LL |         if unsafe { true } {
-   |            ^^^^^^^^^^^^^^^
-   |
-   = help: consider adding a safety comment on the preceding line
-
-error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:506:23
-   |
-LL |             let bar = unsafe {};
-   |                       ^^^^^^^^^
-   |
-   = help: consider adding a safety comment on the preceding line
-
-error: aborting due to 35 previous errors
-
diff --git a/tests/ui/undocumented_unsafe_blocks.rs b/tests/ui/undocumented_unsafe_blocks.rs
deleted file mode 100644
index f4e7f1943ae..00000000000
--- a/tests/ui/undocumented_unsafe_blocks.rs
+++ /dev/null
@@ -1,534 +0,0 @@
-//@aux-build:proc_macro_unsafe.rs
-
-#![warn(clippy::undocumented_unsafe_blocks, clippy::unnecessary_safety_comment)]
-#![allow(clippy::let_unit_value, clippy::missing_safety_doc)]
-
-extern crate proc_macro_unsafe;
-
-// Valid comments
-
-fn nested_local() {
-    let _ = {
-        let _ = {
-            // SAFETY:
-            let _ = unsafe {};
-        };
-    };
-}
-
-fn deep_nest() {
-    let _ = {
-        let _ = {
-            // SAFETY:
-            let _ = unsafe {};
-
-            // Safety:
-            unsafe {};
-
-            let _ = {
-                let _ = {
-                    let _ = {
-                        let _ = {
-                            let _ = {
-                                // Safety:
-                                let _ = unsafe {};
-
-                                // SAFETY:
-                                unsafe {};
-                            };
-                        };
-                    };
-
-                    // Safety:
-                    unsafe {};
-                };
-            };
-        };
-
-        // Safety:
-        unsafe {};
-    };
-
-    // SAFETY:
-    unsafe {};
-}
-
-fn local_tuple_expression() {
-    // Safety:
-    let _ = (42, unsafe {});
-}
-
-fn line_comment() {
-    // Safety:
-    unsafe {}
-}
-
-fn line_comment_newlines() {
-    // SAFETY:
-
-    unsafe {}
-}
-
-fn line_comment_empty() {
-    // Safety:
-    //
-    //
-    //
-    unsafe {}
-}
-
-fn line_comment_with_extras() {
-    // This is a description
-    // Safety:
-    unsafe {}
-}
-
-fn block_comment() {
-    /* Safety: */
-    unsafe {}
-}
-
-fn block_comment_newlines() {
-    /* SAFETY: */
-
-    unsafe {}
-}
-
-fn block_comment_with_extras() {
-    /* This is a description
-     * SAFETY:
-     */
-    unsafe {}
-}
-
-fn block_comment_terminator_same_line() {
-    /* This is a description
-     * Safety: */
-    unsafe {}
-}
-
-fn buried_safety() {
-    // Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor
-    // incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation
-    // ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in
-    // reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint
-    // occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est
-    // laborum. Safety:
-    // Tellus elementum sagittis vitae et leo duis ut diam quam. Sit amet nulla facilisi
-    // morbi tempus iaculis urna. Amet luctus venenatis lectus magna. At quis risus sed vulputate odio
-    // ut. Luctus venenatis lectus magna fringilla urna. Tortor id aliquet lectus proin nibh nisl
-    // condimentum id venenatis. Vulputate dignissim suspendisse in est ante in nibh mauris cursus.
-    unsafe {}
-}
-
-fn safety_with_prepended_text() {
-    // This is a test. safety:
-    unsafe {}
-}
-
-fn local_line_comment() {
-    // Safety:
-    let _ = unsafe {};
-}
-
-fn local_block_comment() {
-    /* SAFETY: */
-    let _ = unsafe {};
-}
-
-fn comment_array() {
-    // Safety:
-    let _ = [unsafe { 14 }, unsafe { 15 }, 42, unsafe { 16 }];
-}
-
-fn comment_tuple() {
-    // sAFETY:
-    let _ = (42, unsafe {}, "test", unsafe {});
-}
-
-fn comment_unary() {
-    // SAFETY:
-    let _ = *unsafe { &42 };
-}
-
-#[allow(clippy::match_single_binding)]
-fn comment_match() {
-    // SAFETY:
-    let _ = match unsafe {} {
-        _ => {},
-    };
-}
-
-fn comment_addr_of() {
-    // Safety:
-    let _ = &unsafe {};
-}
-
-fn comment_repeat() {
-    // Safety:
-    let _ = [unsafe {}; 5];
-}
-
-fn comment_macro_call() {
-    macro_rules! t {
-        ($b:expr) => {
-            $b
-        };
-    }
-
-    t!(
-        // SAFETY:
-        unsafe {}
-    );
-}
-
-fn comment_macro_def() {
-    macro_rules! t {
-        () => {
-            // Safety:
-            unsafe {}
-        };
-    }
-
-    t!();
-}
-
-fn non_ascii_comment() {
-    // ॐ᧻໒ SaFeTy: ௵∰
-    unsafe {};
-}
-
-fn local_commented_block() {
-    let _ =
-        // safety:
-        unsafe {};
-}
-
-fn local_nest() {
-    // safety:
-    let _ = [(42, unsafe {}, unsafe {}), (52, unsafe {}, unsafe {})];
-}
-
-fn in_fn_call(x: *const u32) {
-    fn f(x: u32) {}
-
-    // Safety: reason
-    f(unsafe { *x });
-}
-
-fn multi_in_fn_call(x: *const u32) {
-    fn f(x: u32, y: u32) {}
-
-    // Safety: reason
-    f(unsafe { *x }, unsafe { *x });
-}
-
-fn in_multiline_fn_call(x: *const u32) {
-    fn f(x: u32, y: u32) {}
-
-    f(
-        // Safety: reason
-        unsafe { *x },
-        0,
-    );
-}
-
-fn in_macro_call(x: *const u32) {
-    // Safety: reason
-    println!("{}", unsafe { *x });
-}
-
-fn in_multiline_macro_call(x: *const u32) {
-    println!(
-        "{}",
-        // Safety: reason
-        unsafe { *x },
-    );
-}
-
-fn from_proc_macro() {
-    proc_macro_unsafe::unsafe_block!(token);
-}
-
-fn in_closure(x: *const u32) {
-    // Safety: reason
-    let _ = || unsafe { *x };
-}
-
-// Invalid comments
-
-#[rustfmt::skip]
-fn inline_block_comment() {
-    /* Safety: */ unsafe {}
-}
-
-fn no_comment() {
-    unsafe {}
-}
-
-fn no_comment_array() {
-    let _ = [unsafe { 14 }, unsafe { 15 }, 42, unsafe { 16 }];
-}
-
-fn no_comment_tuple() {
-    let _ = (42, unsafe {}, "test", unsafe {});
-}
-
-fn no_comment_unary() {
-    let _ = *unsafe { &42 };
-}
-
-#[allow(clippy::match_single_binding)]
-fn no_comment_match() {
-    let _ = match unsafe {} {
-        _ => {},
-    };
-}
-
-fn no_comment_addr_of() {
-    let _ = &unsafe {};
-}
-
-fn no_comment_repeat() {
-    let _ = [unsafe {}; 5];
-}
-
-fn local_no_comment() {
-    let _ = unsafe {};
-}
-
-fn no_comment_macro_call() {
-    macro_rules! t {
-        ($b:expr) => {
-            $b
-        };
-    }
-
-    t!(unsafe {});
-}
-
-fn no_comment_macro_def() {
-    macro_rules! t {
-        () => {
-            unsafe {}
-        };
-    }
-
-    t!();
-}
-
-fn trailing_comment() {
-    unsafe {} // SAFETY:
-}
-
-fn internal_comment() {
-    unsafe {
-        // SAFETY:
-    }
-}
-
-fn interference() {
-    // SAFETY
-
-    let _ = 42;
-
-    unsafe {};
-}
-
-pub fn print_binary_tree() {
-    println!("{}", unsafe { String::from_utf8_unchecked(vec![]) });
-}
-
-mod unsafe_impl_smoke_test {
-    unsafe trait A {}
-
-    // error: no safety comment
-    unsafe impl A for () {}
-
-    // Safety: ok
-    unsafe impl A for (i32) {}
-
-    mod sub_mod {
-        // error:
-        unsafe impl B for (u32) {}
-        unsafe trait B {}
-    }
-
-    #[rustfmt::skip]
-    mod sub_mod2 {
-        //
-        // SAFETY: ok
-        //
-
-        unsafe impl B for (u32) {}
-        unsafe trait B {}
-    }
-}
-
-mod unsafe_impl_from_macro {
-    unsafe trait T {}
-
-    // error
-    macro_rules! no_safety_comment {
-        ($t:ty) => {
-            unsafe impl T for $t {}
-        };
-    }
-
-    // ok
-    no_safety_comment!(());
-
-    // ok
-    macro_rules! with_safety_comment {
-        ($t:ty) => {
-            // SAFETY:
-            unsafe impl T for $t {}
-        };
-    }
-
-    // ok
-    with_safety_comment!((i32));
-}
-
-mod unsafe_impl_macro_and_not_macro {
-    unsafe trait T {}
-
-    // error
-    macro_rules! no_safety_comment {
-        ($t:ty) => {
-            unsafe impl T for $t {}
-        };
-    }
-
-    // ok
-    no_safety_comment!(());
-
-    // error
-    unsafe impl T for (i32) {}
-
-    // ok
-    no_safety_comment!(u32);
-
-    // error
-    unsafe impl T for (bool) {}
-}
-
-#[rustfmt::skip]
-mod unsafe_impl_valid_comment {
-    unsafe trait SaFety {}
-    // SaFety:
-    unsafe impl SaFety for () {}
-
-    unsafe trait MultiLineComment {}
-    // The following impl is safe
-    // ...
-    // Safety: reason
-    unsafe impl MultiLineComment for () {}
-
-    unsafe trait NoAscii {}
-    // 安全 SAFETY: 以下のコードは安全です
-    unsafe impl NoAscii for () {}
-
-    unsafe trait InlineAndPrecedingComment {}
-    // SAFETY:
-    /* comment */ unsafe impl InlineAndPrecedingComment for () {}
-
-    unsafe trait BuriedSafety {}
-    // Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor
-    // incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation
-    // ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in
-    // reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint
-    // occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est
-    // laborum. Safety:
-    // Tellus elementum sagittis vitae et leo duis ut diam quam. Sit amet nulla facilisi
-    // morbi tempus iaculis urna. Amet luctus venenatis lectus magna. At quis risus sed vulputate odio
-    // ut. Luctus venenatis lectus magna fringilla urna. Tortor id aliquet lectus proin nibh nisl
-    // condimentum id venenatis. Vulputate dignissim suspendisse in est ante in nibh mauris cursus.
-    unsafe impl BuriedSafety for () {}
-
-    unsafe trait MultiLineBlockComment {}
-    /* This is a description
-     * Safety: */
-    unsafe impl MultiLineBlockComment for () {}
-}
-
-#[rustfmt::skip]
-mod unsafe_impl_invalid_comment {
-    unsafe trait NoComment {}
-
-    unsafe impl NoComment for () {}
-
-    unsafe trait InlineComment {}
-
-    /* SAFETY: */ unsafe impl InlineComment for () {}
-
-    unsafe trait TrailingComment {}
-
-    unsafe impl TrailingComment for () {} // SAFETY:
-
-    unsafe trait Interference {}
-    // SAFETY:
-    const BIG_NUMBER: i32 = 1000000;
-    unsafe impl Interference for () {}
-}
-
-unsafe trait ImplInFn {}
-
-fn impl_in_fn() {
-    // error
-    unsafe impl ImplInFn for () {}
-
-    // SAFETY: ok
-    unsafe impl ImplInFn for (i32) {}
-}
-
-unsafe trait CrateRoot {}
-
-// error
-unsafe impl CrateRoot for () {}
-
-// SAFETY: ok
-unsafe impl CrateRoot for (i32) {}
-
-fn issue_9142() {
-    // SAFETY: ok
-    let _ =
-        // we need this comment to avoid rustfmt putting
-        // it all on one line
-        unsafe {};
-
-    // SAFETY: this is more than one level away, so it should warn
-    let _ = {
-        if unsafe { true } {
-            todo!();
-        } else {
-            let bar = unsafe {};
-            todo!();
-            bar
-        }
-    };
-}
-
-pub unsafe fn a_function_with_a_very_long_name_to_break_the_line() -> u32 {
-    1
-}
-
-pub const unsafe fn a_const_function_with_a_very_long_name_to_break_the_line() -> u32 {
-    2
-}
-
-fn issue_10832() {
-    // Safety: A safety comment. But it will warn anyways
-    let _some_variable_with_a_very_long_name_to_break_the_line =
-        unsafe { a_function_with_a_very_long_name_to_break_the_line() };
-
-    // Safety: Another safety comment. But it will warn anyways
-    const _SOME_CONST_WITH_A_VERY_LONG_NAME_TO_BREAK_THE_LINE: u32 =
-        unsafe { a_const_function_with_a_very_long_name_to_break_the_line() };
-
-    // Safety: Yet another safety comment. But it will warn anyways
-    static _SOME_STATIC_WITH_A_VERY_LONG_NAME_TO_BREAK_THE_LINE: u32 =
-        unsafe { a_const_function_with_a_very_long_name_to_break_the_line() };
-}
-
-fn main() {}
diff --git a/tests/ui/undocumented_unsafe_blocks.stderr b/tests/ui/undocumented_unsafe_blocks.stderr
deleted file mode 100644
index 77f6aea2e0d..00000000000
--- a/tests/ui/undocumented_unsafe_blocks.stderr
+++ /dev/null
@@ -1,348 +0,0 @@
-error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:262:19
-   |
-LL |     /* Safety: */ unsafe {}
-   |                   ^^^^^^^^^
-   |
-   = help: consider adding a safety comment on the preceding line
-   = note: `-D clippy::undocumented-unsafe-blocks` implied by `-D warnings`
-   = help: to override `-D warnings` add `#[allow(clippy::undocumented_unsafe_blocks)]`
-
-error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:266:5
-   |
-LL |     unsafe {}
-   |     ^^^^^^^^^
-   |
-   = help: consider adding a safety comment on the preceding line
-
-error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:270:14
-   |
-LL |     let _ = [unsafe { 14 }, unsafe { 15 }, 42, unsafe { 16 }];
-   |              ^^^^^^^^^^^^^
-   |
-   = help: consider adding a safety comment on the preceding line
-
-error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:270:29
-   |
-LL |     let _ = [unsafe { 14 }, unsafe { 15 }, 42, unsafe { 16 }];
-   |                             ^^^^^^^^^^^^^
-   |
-   = help: consider adding a safety comment on the preceding line
-
-error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:270:48
-   |
-LL |     let _ = [unsafe { 14 }, unsafe { 15 }, 42, unsafe { 16 }];
-   |                                                ^^^^^^^^^^^^^
-   |
-   = help: consider adding a safety comment on the preceding line
-
-error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:274:18
-   |
-LL |     let _ = (42, unsafe {}, "test", unsafe {});
-   |                  ^^^^^^^^^
-   |
-   = help: consider adding a safety comment on the preceding line
-
-error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:274:37
-   |
-LL |     let _ = (42, unsafe {}, "test", unsafe {});
-   |                                     ^^^^^^^^^
-   |
-   = help: consider adding a safety comment on the preceding line
-
-error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:278:14
-   |
-LL |     let _ = *unsafe { &42 };
-   |              ^^^^^^^^^^^^^^
-   |
-   = help: consider adding a safety comment on the preceding line
-
-error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:283:19
-   |
-LL |     let _ = match unsafe {} {
-   |                   ^^^^^^^^^
-   |
-   = help: consider adding a safety comment on the preceding line
-
-error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:289:14
-   |
-LL |     let _ = &unsafe {};
-   |              ^^^^^^^^^
-   |
-   = help: consider adding a safety comment on the preceding line
-
-error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:293:14
-   |
-LL |     let _ = [unsafe {}; 5];
-   |              ^^^^^^^^^
-   |
-   = help: consider adding a safety comment on the preceding line
-
-error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:297:13
-   |
-LL |     let _ = unsafe {};
-   |             ^^^^^^^^^
-   |
-   = help: consider adding a safety comment on the preceding line
-
-error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:307:8
-   |
-LL |     t!(unsafe {});
-   |        ^^^^^^^^^
-   |
-   = help: consider adding a safety comment on the preceding line
-
-error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:313:13
-   |
-LL |             unsafe {}
-   |             ^^^^^^^^^
-...
-LL |     t!();
-   |     ---- in this macro invocation
-   |
-   = help: consider adding a safety comment on the preceding line
-   = note: this error originates in the macro `t` (in Nightly builds, run with -Z macro-backtrace for more info)
-
-error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:321:5
-   |
-LL |     unsafe {} // SAFETY:
-   |     ^^^^^^^^^
-   |
-   = help: consider adding a safety comment on the preceding line
-
-error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:325:5
-   |
-LL |     unsafe {
-   |     ^^^^^^^^
-   |
-   = help: consider adding a safety comment on the preceding line
-
-error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:335:5
-   |
-LL |     unsafe {};
-   |     ^^^^^^^^^
-   |
-   = help: consider adding a safety comment on the preceding line
-
-error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:339:20
-   |
-LL |     println!("{}", unsafe { String::from_utf8_unchecked(vec![]) });
-   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: consider adding a safety comment on the preceding line
-
-error: unsafe impl missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:346:5
-   |
-LL |     unsafe impl A for () {}
-   |     ^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: consider adding a safety comment on the preceding line
-
-error: unsafe impl missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:353:9
-   |
-LL |         unsafe impl B for (u32) {}
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: consider adding a safety comment on the preceding line
-
-error: unsafe impl missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:374:13
-   |
-LL |             unsafe impl T for $t {}
-   |             ^^^^^^^^^^^^^^^^^^^^^^^
-...
-LL |     no_safety_comment!(());
-   |     ---------------------- in this macro invocation
-   |
-   = help: consider adding a safety comment on the preceding line
-   = note: this error originates in the macro `no_safety_comment` (in Nightly builds, run with -Z macro-backtrace for more info)
-
-error: unsafe impl missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:399:13
-   |
-LL |             unsafe impl T for $t {}
-   |             ^^^^^^^^^^^^^^^^^^^^^^^
-...
-LL |     no_safety_comment!(());
-   |     ---------------------- in this macro invocation
-   |
-   = help: consider adding a safety comment on the preceding line
-   = note: this error originates in the macro `no_safety_comment` (in Nightly builds, run with -Z macro-backtrace for more info)
-
-error: unsafe impl missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:407:5
-   |
-LL |     unsafe impl T for (i32) {}
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: consider adding a safety comment on the preceding line
-
-error: unsafe impl missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:399:13
-   |
-LL |             unsafe impl T for $t {}
-   |             ^^^^^^^^^^^^^^^^^^^^^^^
-...
-LL |     no_safety_comment!(u32);
-   |     ----------------------- in this macro invocation
-   |
-   = help: consider adding a safety comment on the preceding line
-   = note: this error originates in the macro `no_safety_comment` (in Nightly builds, run with -Z macro-backtrace for more info)
-
-error: unsafe impl missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:413:5
-   |
-LL |     unsafe impl T for (bool) {}
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: consider adding a safety comment on the preceding line
-
-error: unsafe impl missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:459:5
-   |
-LL |     unsafe impl NoComment for () {}
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: consider adding a safety comment on the preceding line
-
-error: unsafe impl missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:463:19
-   |
-LL |     /* SAFETY: */ unsafe impl InlineComment for () {}
-   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: consider adding a safety comment on the preceding line
-
-error: unsafe impl missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:467:5
-   |
-LL |     unsafe impl TrailingComment for () {} // SAFETY:
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: consider adding a safety comment on the preceding line
-
-error: constant item has unnecessary safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:471:5
-   |
-LL |     const BIG_NUMBER: i32 = 1000000;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: consider removing the safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:470:5
-   |
-LL |     // SAFETY:
-   |     ^^^^^^^^^^
-   = note: `-D clippy::unnecessary-safety-comment` implied by `-D warnings`
-   = help: to override `-D warnings` add `#[allow(clippy::unnecessary_safety_comment)]`
-
-error: unsafe impl missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:472:5
-   |
-LL |     unsafe impl Interference for () {}
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: consider adding a safety comment on the preceding line
-
-error: unsafe impl missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:479:5
-   |
-LL |     unsafe impl ImplInFn for () {}
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: consider adding a safety comment on the preceding line
-
-error: unsafe impl missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:488:1
-   |
-LL | unsafe impl CrateRoot for () {}
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: consider adding a safety comment on the preceding line
-
-error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:498:9
-   |
-LL |         unsafe {};
-   |         ^^^^^^^^^
-   |
-   = help: consider adding a safety comment on the preceding line
-
-error: statement has unnecessary safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:501:5
-   |
-LL | /     let _ = {
-LL | |         if unsafe { true } {
-LL | |             todo!();
-LL | |         } else {
-...  |
-LL | |         }
-LL | |     };
-   | |______^
-   |
-help: consider removing the safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:500:5
-   |
-LL |     // SAFETY: this is more than one level away, so it should warn
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:502:12
-   |
-LL |         if unsafe { true } {
-   |            ^^^^^^^^^^^^^^^
-   |
-   = help: consider adding a safety comment on the preceding line
-
-error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:505:23
-   |
-LL |             let bar = unsafe {};
-   |                       ^^^^^^^^^
-   |
-   = help: consider adding a safety comment on the preceding line
-
-error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:523:9
-   |
-LL |         unsafe { a_function_with_a_very_long_name_to_break_the_line() };
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: consider adding a safety comment on the preceding line
-
-error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:527:9
-   |
-LL |         unsafe { a_const_function_with_a_very_long_name_to_break_the_line() };
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: consider adding a safety comment on the preceding line
-
-error: unsafe block missing a safety comment
-  --> $DIR/undocumented_unsafe_blocks.rs:531:9
-   |
-LL |         unsafe { a_const_function_with_a_very_long_name_to_break_the_line() };
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: consider adding a safety comment on the preceding line
-
-error: aborting due to 39 previous errors
-
-- 
cgit 1.4.1-3-g733a5


From 77c121e8172377ca5a978a2f107735847dea33ed Mon Sep 17 00:00:00 2001
From: Taiki Endo <te316e89@gmail.com>
Date: Wed, 20 Sep 2023 19:05:51 +0900
Subject: Warn missing_enforced_import_renames by default

---
 clippy_lints/src/missing_enforced_import_rename.rs | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/missing_enforced_import_rename.rs b/clippy_lints/src/missing_enforced_import_rename.rs
index 96d83e114a4..fc088710e42 100644
--- a/clippy_lints/src/missing_enforced_import_rename.rs
+++ b/clippy_lints/src/missing_enforced_import_rename.rs
@@ -17,6 +17,9 @@ declare_clippy_lint! {
     /// Checks for imports that do not rename the item as specified
     /// in the `enforce-import-renames` config option.
     ///
+    /// Note: Even though this lint is warn-by-default, it will only trigger if
+    /// import renames are defined in the clippy.toml file.
+    ///
     /// ### Why is this bad?
     /// Consistency is important, if a project has defined import
     /// renames they should be followed. More practically, some item names are too
@@ -38,7 +41,7 @@ declare_clippy_lint! {
     /// ```
     #[clippy::version = "1.55.0"]
     pub MISSING_ENFORCED_IMPORT_RENAMES,
-    restriction,
+    style,
     "enforce import renames"
 }
 
-- 
cgit 1.4.1-3-g733a5


From 01c25a8eb63f8da0453d1aedca782f477342ef2d Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Wed, 20 Sep 2023 13:41:20 +0000
Subject: Remove most usage of `hir_ty_to_ty`

---
 clippy_lints/src/default_union_representation.rs   | 22 ++++++++++++----------
 clippy_lints/src/error_impl_error.rs               |  8 ++++----
 clippy_lints/src/large_const_arrays.rs             |  5 ++---
 clippy_lints/src/loops/utils.rs                    |  3 +--
 clippy_lints/src/matches/needless_match.rs         | 17 ++++++++++-------
 clippy_lints/src/methods/mod.rs                    | 13 +++++++------
 clippy_lints/src/missing_const_for_fn.rs           | 12 +++++-------
 clippy_lints/src/no_effect.rs                      | 11 ++++-------
 clippy_lints/src/non_canonical_impls.rs            | 14 +++-----------
 clippy_lints/src/non_copy_const.rs                 | 15 +++++++--------
 clippy_lints/src/ptr.rs                            | 21 +++++++--------------
 .../src/utils/internal_lints/invalid_paths.rs      | 18 ++++++------------
 .../src/utils/internal_lints/msrv_attr_impl.rs     | 15 ++++++---------
 tests/ui/no_effect_return.rs                       |  1 +
 tests/ui/no_effect_return.stderr                   |  8 +++-----
 15 files changed, 78 insertions(+), 105 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/default_union_representation.rs b/clippy_lints/src/default_union_representation.rs
index bbce6e1dd8f..63ec8195020 100644
--- a/clippy_lints/src/default_union_representation.rs
+++ b/clippy_lints/src/default_union_representation.rs
@@ -1,8 +1,8 @@
 use clippy_utils::diagnostics::span_lint_and_help;
-use rustc_hir::{self as hir, HirId, Item, ItemKind};
-use rustc_hir_analysis::hir_ty_to_ty;
+use rustc_hir::{HirId, Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::layout::LayoutOf;
+use rustc_middle::ty::{self, FieldDef, GenericArg, List};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::sym;
 
@@ -52,7 +52,10 @@ declare_lint_pass!(DefaultUnionRepresentation => [DEFAULT_UNION_REPRESENTATION])
 
 impl<'tcx> LateLintPass<'tcx> for DefaultUnionRepresentation {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
-        if is_union_with_two_non_zst_fields(cx, item) && !has_c_repr_attr(cx, item.hir_id()) {
+        if !item.span.from_expansion()
+            && is_union_with_two_non_zst_fields(cx, item)
+            && !has_c_repr_attr(cx, item.hir_id())
+        {
             span_lint_and_help(
                 cx,
                 DEFAULT_UNION_REPRESENTATION,
@@ -73,18 +76,17 @@ impl<'tcx> LateLintPass<'tcx> for DefaultUnionRepresentation {
 /// if there is only one field left after ignoring ZST fields then the offset
 /// of that field does not matter either.)
 fn is_union_with_two_non_zst_fields(cx: &LateContext<'_>, item: &Item<'_>) -> bool {
-    if let ItemKind::Union(data, _) = &item.kind {
-        data.fields().iter().filter(|f| !is_zst(cx, f.ty)).count() >= 2
+    if let ItemKind::Union(..) = &item.kind
+        && let ty::Adt(adt_def, args) = cx.tcx.type_of(item.owner_id).instantiate_identity().kind()
+    {
+        adt_def.all_fields().filter(|f| !is_zst(cx, f, args)).count() >= 2
     } else {
         false
     }
 }
 
-fn is_zst(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>) -> bool {
-    if hir_ty.span.from_expansion() {
-        return false;
-    }
-    let ty = hir_ty_to_ty(cx.tcx, hir_ty);
+fn is_zst<'tcx>(cx: &LateContext<'tcx>, field: &FieldDef, args: &'tcx List<GenericArg<'tcx>>) -> bool {
+    let ty = field.ty(cx.tcx, args);
     if let Ok(layout) = cx.layout_of(ty) {
         layout.is_zst()
     } else {
diff --git a/clippy_lints/src/error_impl_error.rs b/clippy_lints/src/error_impl_error.rs
index 379af9b2234..f24577c7382 100644
--- a/clippy_lints/src/error_impl_error.rs
+++ b/clippy_lints/src/error_impl_error.rs
@@ -3,7 +3,6 @@ use clippy_utils::path_res;
 use clippy_utils::ty::implements_trait;
 use rustc_hir::def_id::{DefId, LocalDefId};
 use rustc_hir::{Item, ItemKind};
-use rustc_hir_analysis::hir_ty_to_ty;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::Visibility;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -42,9 +41,10 @@ impl<'tcx> LateLintPass<'tcx> for ErrorImplError {
         };
 
         match item.kind {
-            ItemKind::TyAlias(ty, _) if implements_trait(cx, hir_ty_to_ty(cx.tcx, ty), error_def_id, &[])
-                && item.ident.name == sym::Error
-                && is_visible_outside_module(cx, item.owner_id.def_id) =>
+            ItemKind::TyAlias(..) if item.ident.name == sym::Error
+                && is_visible_outside_module(cx, item.owner_id.def_id)
+                && let ty = cx.tcx.type_of(item.owner_id).instantiate_identity()
+                && implements_trait(cx, ty, error_def_id, &[]) =>
             {
                 span_lint(
                     cx,
diff --git a/clippy_lints/src/large_const_arrays.rs b/clippy_lints/src/large_const_arrays.rs
index 9b26c3573e1..a4f3d498345 100644
--- a/clippy_lints/src/large_const_arrays.rs
+++ b/clippy_lints/src/large_const_arrays.rs
@@ -2,7 +2,6 @@ use clippy_utils::diagnostics::span_lint_and_then;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Item, ItemKind};
-use rustc_hir_analysis::hir_ty_to_ty;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::layout::LayoutOf;
 use rustc_middle::ty::{self, ConstKind};
@@ -50,12 +49,12 @@ impl<'tcx> LateLintPass<'tcx> for LargeConstArrays {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
         if_chain! {
             if !item.span.from_expansion();
-            if let ItemKind::Const(hir_ty, generics, _) = &item.kind;
+            if let ItemKind::Const(_, generics, _) = &item.kind;
             // Since static items may not have generics, skip generic const items.
             // FIXME(generic_const_items): I don't think checking `generics.hwcp` suffices as it
             // doesn't account for empty where-clauses that only consist of keyword `where` IINM.
             if generics.params.is_empty() && !generics.has_where_clause_predicates;
-            let ty = hir_ty_to_ty(cx.tcx, hir_ty);
+            let ty = cx.tcx.type_of(item.owner_id).instantiate_identity();
             if let ty::Array(element_type, cst) = ty.kind();
             if let ConstKind::Value(ty::ValTree::Leaf(element_count)) = cst.kind();
             if let Ok(element_count) = element_count.try_to_target_usize(cx.tcx);
diff --git a/clippy_lints/src/loops/utils.rs b/clippy_lints/src/loops/utils.rs
index 6edca2d55f6..0a2bd89eb3c 100644
--- a/clippy_lints/src/loops/utils.rs
+++ b/clippy_lints/src/loops/utils.rs
@@ -5,7 +5,6 @@ use rustc_ast::ast::{LitIntType, LitKind};
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_expr, walk_local, walk_pat, walk_stmt, Visitor};
 use rustc_hir::{BinOpKind, BorrowKind, Expr, ExprKind, HirId, HirIdMap, Local, Mutability, Pat, PatKind, Stmt};
-use rustc_hir_analysis::hir_ty_to_ty;
 use rustc_lint::LateContext;
 use rustc_middle::hir::nested_filter;
 use rustc_middle::ty::{self, Ty};
@@ -150,7 +149,7 @@ impl<'a, 'tcx> Visitor<'tcx> for InitializeVisitor<'a, 'tcx> {
             if l.pat.hir_id == self.var_id;
             if let PatKind::Binding(.., ident, _) = l.pat.kind;
             then {
-                let ty = l.ty.map(|ty| hir_ty_to_ty(self.cx.tcx, ty));
+                let ty = l.ty.map(|_| self.cx.typeck_results().pat_ty(l.pat));
 
                 self.state = l.init.map_or(InitializeVisitorState::Declared(ident.name, ty), |init| {
                     InitializeVisitorState::Initialized {
diff --git a/clippy_lints/src/matches/needless_match.rs b/clippy_lints/src/matches/needless_match.rs
index c4f6852aedc..44dc29c36a6 100644
--- a/clippy_lints/src/matches/needless_match.rs
+++ b/clippy_lints/src/matches/needless_match.rs
@@ -8,8 +8,7 @@ use clippy_utils::{
 };
 use rustc_errors::Applicability;
 use rustc_hir::LangItem::OptionNone;
-use rustc_hir::{Arm, BindingAnnotation, ByRef, Expr, ExprKind, FnRetTy, Guard, Node, Pat, PatKind, Path, QPath};
-use rustc_hir_analysis::hir_ty_to_ty;
+use rustc_hir::{Arm, BindingAnnotation, ByRef, Expr, ExprKind, Guard, ItemKind, Node, Pat, PatKind, Path, QPath};
 use rustc_lint::LateContext;
 use rustc_span::sym;
 
@@ -141,11 +140,15 @@ fn expr_ty_matches_p_ty(cx: &LateContext<'_>, expr: &Expr<'_>, p_expr: &Expr<'_>
                 return same_type_and_consts(results.node_type(local.hir_id), results.expr_ty(expr));
             },
             // compare match_expr ty with RetTy in `fn foo() -> RetTy`
-            Node::Item(..) => {
-                if let Some(fn_decl) = p_node.fn_decl() {
-                    if let FnRetTy::Return(ret_ty) = fn_decl.output {
-                        return same_type_and_consts(hir_ty_to_ty(cx.tcx, ret_ty), cx.typeck_results().expr_ty(expr));
-                    }
+            Node::Item(item) => {
+                if let ItemKind::Fn(..) = item.kind {
+                    let output = cx
+                        .tcx
+                        .fn_sig(item.owner_id)
+                        .instantiate_identity()
+                        .output()
+                        .skip_binder();
+                    return same_type_and_consts(output, cx.typeck_results().expr_ty(expr));
                 }
             },
             // check the parent expr for this whole block `{ match match_expr {..} }`
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index bd07e6cbf2e..e7fcef9e9de 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -126,7 +126,6 @@ pub use path_ends_with_ext::DEFAULT_ALLOWED_DOTFILES;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_hir as hir;
 use rustc_hir::{Expr, ExprKind, Node, Stmt, StmtKind, TraitItem, TraitItemKind};
-use rustc_hir_analysis::hir_ty_to_ty;
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::{self, TraitRef, Ty};
@@ -3926,18 +3925,20 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
         if_chain! {
             if let TraitItemKind::Fn(ref sig, _) = item.kind;
             if sig.decl.implicit_self.has_implicit_self();
-            if let Some(first_arg_ty) = sig.decl.inputs.iter().next();
-
+            if let Some(first_arg_hir_ty) = sig.decl.inputs.first();
+            if let Some(&first_arg_ty) = cx.tcx.fn_sig(item.owner_id)
+                .instantiate_identity()
+                .inputs()
+                .skip_binder()
+                .first();
             then {
-                let first_arg_span = first_arg_ty.span;
-                let first_arg_ty = hir_ty_to_ty(cx.tcx, first_arg_ty);
                 let self_ty = TraitRef::identity(cx.tcx, item.owner_id.to_def_id()).self_ty();
                 wrong_self_convention::check(
                     cx,
                     item.ident.name.as_str(),
                     self_ty,
                     first_arg_ty,
-                    first_arg_span,
+                    first_arg_hir_ty.span,
                     false,
                     true,
                 );
diff --git a/clippy_lints/src/missing_const_for_fn.rs b/clippy_lints/src/missing_const_for_fn.rs
index 3b7eccad79d..f598a65d2e4 100644
--- a/clippy_lints/src/missing_const_for_fn.rs
+++ b/clippy_lints/src/missing_const_for_fn.rs
@@ -7,7 +7,6 @@ use rustc_hir as hir;
 use rustc_hir::def_id::CRATE_DEF_ID;
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::{Body, Constness, FnDecl, GenericParamKind};
-use rustc_hir_analysis::hir_ty_to_ty;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
@@ -124,7 +123,7 @@ impl<'tcx> LateLintPass<'tcx> for MissingConstForFn {
             FnKind::Method(_, sig, ..) => {
                 if trait_ref_of_method(cx, def_id).is_some()
                     || already_const(sig.header)
-                    || method_accepts_droppable(cx, sig.decl.inputs)
+                    || method_accepts_droppable(cx, def_id)
                 {
                     return;
                 }
@@ -165,12 +164,11 @@ impl<'tcx> LateLintPass<'tcx> for MissingConstForFn {
 
 /// Returns true if any of the method parameters is a type that implements `Drop`. The method
 /// can't be made const then, because `drop` can't be const-evaluated.
-fn method_accepts_droppable(cx: &LateContext<'_>, param_tys: &[hir::Ty<'_>]) -> bool {
+fn method_accepts_droppable(cx: &LateContext<'_>, def_id: LocalDefId) -> bool {
+    let sig = cx.tcx.fn_sig(def_id).instantiate_identity().skip_binder();
+
     // If any of the params are droppable, return true
-    param_tys.iter().any(|hir_ty| {
-        let ty_ty = hir_ty_to_ty(cx.tcx, hir_ty);
-        has_drop(cx, ty_ty)
-    })
+    sig.inputs().iter().any(|&ty| has_drop(cx, ty))
 }
 
 // We don't have to lint on something that's already `const`
diff --git a/clippy_lints/src/no_effect.rs b/clippy_lints/src/no_effect.rs
index 5f2a324b05f..aee184252fb 100644
--- a/clippy_lints/src/no_effect.rs
+++ b/clippy_lints/src/no_effect.rs
@@ -5,10 +5,8 @@ use clippy_utils::{get_parent_node, is_lint_allowed, peel_blocks};
 use rustc_errors::Applicability;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::{
-    is_range_literal, BinOpKind, BlockCheckMode, Expr, ExprKind, FnRetTy, ItemKind, Node, PatKind, Stmt, StmtKind,
-    UnsafeSource,
+    is_range_literal, BinOpKind, BlockCheckMode, Expr, ExprKind, ItemKind, Node, PatKind, Stmt, StmtKind, UnsafeSource,
 };
-use rustc_hir_analysis::hir_ty_to_ty;
 use rustc_infer::infer::TyCtxtInferExt as _;
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
@@ -99,14 +97,13 @@ fn check_no_effect(cx: &LateContext<'_>, stmt: &Stmt<'_>) -> bool {
                 |diag| {
                     for parent in cx.tcx.hir().parent_iter(stmt.hir_id) {
                         if let Node::Item(item) = parent.1
-                            && let ItemKind::Fn(sig, ..) = item.kind
-                            && let FnRetTy::Return(ret_ty) = sig.decl.output
+                            && let ItemKind::Fn(..) = item.kind
                             && let Some(Node::Block(block)) = get_parent_node(cx.tcx, stmt.hir_id)
                             && let [.., final_stmt] = block.stmts
                             && final_stmt.hir_id == stmt.hir_id
                         {
                             let expr_ty = cx.typeck_results().expr_ty(expr);
-                            let mut ret_ty = hir_ty_to_ty(cx.tcx, ret_ty);
+                            let mut ret_ty = cx.tcx.fn_sig(item.owner_id).instantiate_identity().output().skip_binder();
 
                             // Remove `impl Future<Output = T>` to get `T`
                             if cx.tcx.ty_is_opaque_future(ret_ty) &&
@@ -115,7 +112,7 @@ fn check_no_effect(cx: &LateContext<'_>, stmt: &Stmt<'_>) -> bool {
                                 ret_ty = true_ret_ty;
                             }
 
-                            if ret_ty == expr_ty {
+                            if !ret_ty.is_unit() && ret_ty == expr_ty {
                                 diag.span_suggestion(
                                     stmt.span.shrink_to_lo(),
                                     "did you mean to return it?",
diff --git a/clippy_lints/src/non_canonical_impls.rs b/clippy_lints/src/non_canonical_impls.rs
index c390e6913ff..20b4b4f03ed 100644
--- a/clippy_lints/src/non_canonical_impls.rs
+++ b/clippy_lints/src/non_canonical_impls.rs
@@ -4,8 +4,7 @@ use clippy_utils::ty::implements_trait;
 use clippy_utils::{get_parent_node, is_res_lang_ctor, last_path_segment, match_def_path, path_res, std_or_core};
 use rustc_errors::Applicability;
 use rustc_hir::def_id::LocalDefId;
-use rustc_hir::{Expr, ExprKind, ImplItem, ImplItemKind, ItemKind, LangItem, Node, UnOp};
-use rustc_hir_analysis::hir_ty_to_ty;
+use rustc_hir::{Expr, ExprKind, ImplItem, ImplItemKind, LangItem, Node, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::EarlyBinder;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -123,9 +122,6 @@ impl LateLintPass<'_> for NonCanonicalImpls {
         if cx.tcx.is_automatically_derived(item.owner_id.to_def_id()) {
             return;
         }
-        let ItemKind::Impl(imp) = item.kind else {
-            return;
-        };
         let ImplItemKind::Fn(_, impl_item_id) = cx.tcx.hir().impl_item(impl_item.impl_item_id()).kind else {
             return;
         };
@@ -181,12 +177,8 @@ impl LateLintPass<'_> for NonCanonicalImpls {
 
         if cx.tcx.is_diagnostic_item(sym::PartialOrd, trait_impl.def_id)
             && impl_item.ident.name == sym::partial_cmp
-            && let Some(ord_def_id) = cx
-                .tcx
-                .diagnostic_items(trait_impl.def_id.krate)
-                .name_to_id
-                .get(&sym::Ord)
-            && implements_trait(cx, hir_ty_to_ty(cx.tcx, imp.self_ty), *ord_def_id, &[])
+            && let Some(ord_def_id) = cx.tcx.get_diagnostic_item(sym::Ord)
+            && implements_trait(cx, trait_impl.self_ty(), ord_def_id, &[])
         {
             // If the `cmp` call likely needs to be fully qualified in the suggestion
             // (like `std::cmp::Ord::cmp`). It's unfortunate we must put this here but we can't
diff --git a/clippy_lints/src/non_copy_const.rs b/clippy_lints/src/non_copy_const.rs
index 243192385c2..e106a959165 100644
--- a/clippy_lints/src/non_copy_const.rs
+++ b/clippy_lints/src/non_copy_const.rs
@@ -13,7 +13,6 @@ use rustc_hir::def_id::DefId;
 use rustc_hir::{
     BodyId, Expr, ExprKind, HirId, Impl, ImplItem, ImplItemKind, Item, ItemKind, Node, TraitItem, TraitItemKind, UnOp,
 };
-use rustc_hir_analysis::hir_ty_to_ty;
 use rustc_lint::{LateContext, LateLintPass, Lint};
 use rustc_middle::mir::interpret::{ErrorHandled, EvalToValTreeResult, GlobalId};
 use rustc_middle::ty::adjustment::Adjust;
@@ -297,8 +296,8 @@ declare_lint_pass!(NonCopyConst => [DECLARE_INTERIOR_MUTABLE_CONST, BORROW_INTER
 
 impl<'tcx> LateLintPass<'tcx> for NonCopyConst {
     fn check_item(&mut self, cx: &LateContext<'tcx>, it: &'tcx Item<'_>) {
-        if let ItemKind::Const(hir_ty, _generics, body_id) = it.kind {
-            let ty = hir_ty_to_ty(cx.tcx, hir_ty);
+        if let ItemKind::Const(.., body_id) = it.kind {
+            let ty = cx.tcx.type_of(it.owner_id).instantiate_identity();
             if !ignored_macro(cx, it) && is_unfrozen(cx, ty) && is_value_unfrozen_poly(cx, body_id, ty) {
                 lint(cx, Source::Item { item: it.span });
             }
@@ -306,8 +305,8 @@ impl<'tcx> LateLintPass<'tcx> for NonCopyConst {
     }
 
     fn check_trait_item(&mut self, cx: &LateContext<'tcx>, trait_item: &'tcx TraitItem<'_>) {
-        if let TraitItemKind::Const(hir_ty, body_id_opt) = &trait_item.kind {
-            let ty = hir_ty_to_ty(cx.tcx, hir_ty);
+        if let TraitItemKind::Const(_, body_id_opt) = &trait_item.kind {
+            let ty = cx.tcx.type_of(trait_item.owner_id).instantiate_identity();
 
             // Normalize assoc types because ones originated from generic params
             // bounded other traits could have their bound.
@@ -333,7 +332,7 @@ impl<'tcx> LateLintPass<'tcx> for NonCopyConst {
     }
 
     fn check_impl_item(&mut self, cx: &LateContext<'tcx>, impl_item: &'tcx ImplItem<'_>) {
-        if let ImplItemKind::Const(hir_ty, body_id) = &impl_item.kind {
+        if let ImplItemKind::Const(_, body_id) = &impl_item.kind {
             let item_def_id = cx.tcx.hir().get_parent_item(impl_item.hir_id()).def_id;
             let item = cx.tcx.hir().expect_item(item_def_id);
 
@@ -366,7 +365,7 @@ impl<'tcx> LateLintPass<'tcx> for NonCopyConst {
                             // we should use here as a frozen variant is a potential to be frozen
                             // similar to unknown layouts.
                             // e.g. `layout_of(...).is_err() || has_frozen_variant(...);`
-                        let ty = hir_ty_to_ty(cx.tcx, hir_ty);
+                        let ty = cx.tcx.type_of(impl_item.owner_id).instantiate_identity();
                         let normalized = cx.tcx.normalize_erasing_regions(cx.param_env, ty);
                         if is_unfrozen(cx, normalized);
                         if is_value_unfrozen_poly(cx, *body_id, normalized);
@@ -381,7 +380,7 @@ impl<'tcx> LateLintPass<'tcx> for NonCopyConst {
                     }
                 },
                 ItemKind::Impl(Impl { of_trait: None, .. }) => {
-                    let ty = hir_ty_to_ty(cx.tcx, hir_ty);
+                    let ty = cx.tcx.type_of(impl_item.owner_id).instantiate_identity();
                     // Normalize assoc types originated from generic params.
                     let normalized = cx.tcx.normalize_erasing_regions(cx.param_env, ty);
 
diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs
index bf031ac8454..7dabdcd58ec 100644
--- a/clippy_lints/src/ptr.rs
+++ b/clippy_lints/src/ptr.rs
@@ -16,7 +16,6 @@ use rustc_hir::{
     ImplItemKind, ItemKind, Lifetime, Mutability, Node, Param, PatKind, QPath, TraitFn, TraitItem, TraitItemKind,
     TyKind, Unsafety,
 };
-use rustc_hir_analysis::hir_ty_to_ty;
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_infer::traits::{Obligation, ObligationCause};
 use rustc_lint::{LateContext, LateLintPass};
@@ -172,13 +171,8 @@ impl<'tcx> LateLintPass<'tcx> for Ptr {
 
             for arg in check_fn_args(
                 cx,
-                cx.tcx
-                    .fn_sig(item.owner_id)
-                    .instantiate_identity()
-                    .skip_binder()
-                    .inputs(),
+                cx.tcx.fn_sig(item.owner_id).instantiate_identity().skip_binder(),
                 sig.decl.inputs,
-                &sig.decl.output,
                 &[],
             )
             .filter(|arg| arg.mutability() == Mutability::Not)
@@ -237,7 +231,7 @@ impl<'tcx> LateLintPass<'tcx> for Ptr {
 
         let decl = sig.decl;
         let sig = cx.tcx.fn_sig(item_id).instantiate_identity().skip_binder();
-        let lint_args: Vec<_> = check_fn_args(cx, sig.inputs(), decl.inputs, &decl.output, body.params)
+        let lint_args: Vec<_> = check_fn_args(cx, sig, decl.inputs, body.params)
             .filter(|arg| !is_trait_item || arg.mutability() == Mutability::Not)
             .collect();
         let results = check_ptr_arg_usage(cx, body, &lint_args);
@@ -443,12 +437,13 @@ impl<'tcx> DerefTy<'tcx> {
 #[expect(clippy::too_many_lines)]
 fn check_fn_args<'cx, 'tcx: 'cx>(
     cx: &'cx LateContext<'tcx>,
-    tys: &'tcx [Ty<'tcx>],
+    fn_sig: ty::FnSig<'tcx>,
     hir_tys: &'tcx [hir::Ty<'tcx>],
-    ret_ty: &'tcx FnRetTy<'tcx>,
     params: &'tcx [Param<'tcx>],
 ) -> impl Iterator<Item = PtrArg<'tcx>> + 'cx {
-    tys.iter()
+    fn_sig
+        .inputs()
+        .iter()
         .zip(hir_tys.iter())
         .enumerate()
         .filter_map(move |(i, (ty, hir_ty))| {
@@ -494,9 +489,7 @@ fn check_fn_args<'cx, 'tcx: 'cx>(
                                 })
                             {
                                 if !lifetime.is_anonymous()
-                                    && let FnRetTy::Return(ret_ty) = ret_ty
-                                    && let ret_ty = hir_ty_to_ty(cx.tcx, ret_ty)
-                                    && ret_ty
+                                    && fn_sig.output()
                                         .walk()
                                         .filter_map(|arg| {
                                             arg.as_region().and_then(|lifetime| {
diff --git a/clippy_lints/src/utils/internal_lints/invalid_paths.rs b/clippy_lints/src/utils/internal_lints/invalid_paths.rs
index 4ed985f54d0..25077223885 100644
--- a/clippy_lints/src/utils/internal_lints/invalid_paths.rs
+++ b/clippy_lints/src/utils/internal_lints/invalid_paths.rs
@@ -5,10 +5,9 @@ use if_chain::if_chain;
 use rustc_hir as hir;
 use rustc_hir::def::DefKind;
 use rustc_hir::Item;
-use rustc_hir_analysis::hir_ty_to_ty;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::fast_reject::SimplifiedType;
-use rustc_middle::ty::{self, FloatTy};
+use rustc_middle::ty::FloatTy;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::symbol::Symbol;
 
@@ -34,25 +33,20 @@ impl<'tcx> LateLintPass<'tcx> for InvalidPaths {
         let mod_name = &cx.tcx.item_name(local_def_id.to_def_id());
         if_chain! {
             if mod_name.as_str() == "paths";
-            if let hir::ItemKind::Const(ty, _, body_id) = item.kind;
-            let ty = hir_ty_to_ty(cx.tcx, ty);
-            if let ty::Array(el_ty, _) = &ty.kind();
-            if let ty::Ref(_, el_ty, _) = &el_ty.kind();
-            if el_ty.is_str();
+            if let hir::ItemKind::Const(.., body_id) = item.kind;
             let body = cx.tcx.hir().body(body_id);
             let typeck_results = cx.tcx.typeck_body(body_id);
             if let Some(Constant::Vec(path)) = constant_simple(cx, typeck_results, body.value);
-            let path: Vec<&str> = path
+            if let Some(path) = path
                 .iter()
                 .map(|x| {
                     if let Constant::Str(s) = x {
-                        s.as_str()
+                        Some(s.as_str())
                     } else {
-                        // We checked the type of the constant above
-                        unreachable!()
+                        None
                     }
                 })
-                .collect();
+                .collect::<Option<Vec<&str>>>();
             if !check_path(cx, &path[..]);
             then {
                 span_lint(cx, INVALID_PATHS, item.span, "invalid path");
diff --git a/clippy_lints/src/utils/internal_lints/msrv_attr_impl.rs b/clippy_lints/src/utils/internal_lints/msrv_attr_impl.rs
index bf835f89cfc..86b77a77f17 100644
--- a/clippy_lints/src/utils/internal_lints/msrv_attr_impl.rs
+++ b/clippy_lints/src/utils/internal_lints/msrv_attr_impl.rs
@@ -5,9 +5,8 @@ use clippy_utils::{match_def_path, paths};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
-use rustc_hir_analysis::hir_ty_to_ty;
 use rustc_lint::{LateContext, LateLintPass, LintContext};
-use rustc_middle::ty::{self, GenericArgKind};
+use rustc_middle::ty::{self, EarlyBinder, GenericArgKind};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
@@ -25,16 +24,14 @@ impl LateLintPass<'_> for MsrvAttrImpl {
     fn check_item(&mut self, cx: &LateContext<'_>, item: &hir::Item<'_>) {
         if_chain! {
             if let hir::ItemKind::Impl(hir::Impl {
-                of_trait: Some(lint_pass_trait_ref),
-                self_ty,
+                of_trait: Some(_),
                 items,
                 ..
             }) = &item.kind;
-            if let Some(lint_pass_trait_def_id) = lint_pass_trait_ref.trait_def_id();
-            let is_late_pass = match_def_path(cx, lint_pass_trait_def_id, &paths::LATE_LINT_PASS);
-            if is_late_pass || match_def_path(cx, lint_pass_trait_def_id, &paths::EARLY_LINT_PASS);
-            let self_ty = hir_ty_to_ty(cx.tcx, self_ty);
-            if let ty::Adt(self_ty_def, _) = self_ty.kind();
+            if let Some(trait_ref) = cx.tcx.impl_trait_ref(item.owner_id).map(EarlyBinder::instantiate_identity);
+            let is_late_pass = match_def_path(cx, trait_ref.def_id, &paths::LATE_LINT_PASS);
+            if is_late_pass || match_def_path(cx, trait_ref.def_id, &paths::EARLY_LINT_PASS);
+            if let ty::Adt(self_ty_def, _) = trait_ref.self_ty().kind();
             if self_ty_def.is_struct();
             if self_ty_def.all_fields().any(|f| {
                 cx.tcx
diff --git a/tests/ui/no_effect_return.rs b/tests/ui/no_effect_return.rs
index f6585aa30a6..e46c0d73518 100644
--- a/tests/ui/no_effect_return.rs
+++ b/tests/ui/no_effect_return.rs
@@ -76,6 +76,7 @@ fn h() -> Vec<u16> {
 
 fn i() -> () {
     {
+        // does not suggest on function with explicit unit return type
         ();
         //~^ ERROR: statement with no effect
     }
diff --git a/tests/ui/no_effect_return.stderr b/tests/ui/no_effect_return.stderr
index b036e634204..aed079f09b9 100644
--- a/tests/ui/no_effect_return.stderr
+++ b/tests/ui/no_effect_return.stderr
@@ -54,15 +54,13 @@ LL |         ControlFlow::Break::<()>(());
    |         help: did you mean to return it?: `return`
 
 error: statement with no effect
-  --> $DIR/no_effect_return.rs:79:9
+  --> $DIR/no_effect_return.rs:80:9
    |
 LL |         ();
-   |         -^^
-   |         |
-   |         help: did you mean to return it?: `return`
+   |         ^^^
 
 error: statement with no effect
-  --> $DIR/no_effect_return.rs:88:9
+  --> $DIR/no_effect_return.rs:89:9
    |
 LL |         ();
    |         ^^^
-- 
cgit 1.4.1-3-g733a5


From 85801f55eff002a63db51125e9bc20aab1d4982e Mon Sep 17 00:00:00 2001
From: pc-linux <patryk.stachowski@op.pl>
Date: Fri, 22 Sep 2023 16:54:21 +0200
Subject: fixed fp caused by moving &mut reference inside of a closure

---
 clippy_lints/src/needless_pass_by_ref_mut.rs | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/needless_pass_by_ref_mut.rs b/clippy_lints/src/needless_pass_by_ref_mut.rs
index 36ca61c0b44..57652e5ff54 100644
--- a/clippy_lints/src/needless_pass_by_ref_mut.rs
+++ b/clippy_lints/src/needless_pass_by_ref_mut.rs
@@ -336,7 +336,12 @@ impl<'tcx> euv::Delegate<'tcx> for MutablyUsedVariablesCtxt<'tcx> {
     fn borrow(&mut self, cmt: &euv::PlaceWithHirId<'tcx>, _id: HirId, borrow: ty::BorrowKind) {
         self.prev_bind = None;
         if let euv::Place {
-            base: euv::PlaceBase::Local(vid),
+            base:
+                euv::PlaceBase::Local(vid)
+                | euv::PlaceBase::Upvar(UpvarId {
+                    var_path: UpvarPath { hir_id: vid },
+                    ..
+                }),
             base_ty,
             ..
         } = &cmt.place
-- 
cgit 1.4.1-3-g733a5


From f3a27d20f60a7b0f23b9256ef6f405c4da8106fd Mon Sep 17 00:00:00 2001
From: jonboh <jon.bosque.hernando@gmail.com>
Date: Fri, 22 Sep 2023 17:18:49 +0200
Subject: prevent ice when threshold is 0 and enum has no variants

---
 clippy_lints/src/enum_variants.rs | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/enum_variants.rs b/clippy_lints/src/enum_variants.rs
index d4df6f7aa2d..85334d09d4b 100644
--- a/clippy_lints/src/enum_variants.rs
+++ b/clippy_lints/src/enum_variants.rs
@@ -167,7 +167,10 @@ fn check_variant(cx: &LateContext<'_>, threshold: u64, def: &EnumDef<'_>, item_n
         return;
     }
 
-    let first = &def.variants[0].ident.name.as_str();
+    let first = match &def.variants.get(0) {
+        Some(variant) => variant.ident.name.as_str(),
+        None => return,
+    };
     let mut pre = camel_case_split(first);
     let mut post = pre.clone();
     post.reverse();
-- 
cgit 1.4.1-3-g733a5


From 7e46fb9a658ceb5120fdf0de8665e7cc19114d7f Mon Sep 17 00:00:00 2001
From: Mick van Gelderen <mickvangelderen@gmail.com>
Date: Fri, 22 Sep 2023 19:41:00 +0200
Subject: Fix large_futures example

The value used in the large_futures example was not large enough to
trigger the lint given the default threshold.

The example also contained more code than necessary.

This PR changes the value size from 1kB to 16kB and reduces the example
in size.
---
 clippy_lints/src/large_futures.rs | 18 ++++++------------
 1 file changed, 6 insertions(+), 12 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/large_futures.rs b/clippy_lints/src/large_futures.rs
index d67d5899350..19f1e08b57a 100644
--- a/clippy_lints/src/large_futures.rs
+++ b/clippy_lints/src/large_futures.rs
@@ -17,26 +17,20 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```rust
-    /// async fn wait(f: impl std::future::Future<Output = ()>) {}
+    /// async fn large_future(_x: [u8; 16 * 1024]) {}
     ///
-    /// async fn big_fut(arg: [u8; 1024]) {}
-    ///
-    /// pub async fn test() {
-    ///     let fut = big_fut([0u8; 1024]);
-    ///     wait(fut).await;
+    /// pub async fn trigger() {
+    ///     large_future([0u8; 16 * 1024]).await;
     /// }
     /// ```
     ///
     /// `Box::pin` the big future instead.
     ///
     /// ```rust
-    /// async fn wait(f: impl std::future::Future<Output = ()>) {}
-    ///
-    /// async fn big_fut(arg: [u8; 1024]) {}
+    /// async fn large_future(_x: [u8; 16 * 1024]) {}
     ///
-    /// pub async fn test() {
-    ///     let fut = Box::pin(big_fut([0u8; 1024]));
-    ///     wait(fut).await;
+    /// pub async fn trigger() {
+    ///     Box::pin(large_future([0u8; 16 * 1024])).await;
     /// }
     /// ```
     #[clippy::version = "1.70.0"]
-- 
cgit 1.4.1-3-g733a5


From 0433e458dadc927e645f6307c0253a4b241dfd5b Mon Sep 17 00:00:00 2001
From: Jon <jon.bosque.hernando@gmail.com>
Date: Sun, 24 Sep 2023 21:37:56 +0200
Subject: use first instead of get(0)

Co-authored-by: Timo <30553356+y21@users.noreply.github.com>
---
 clippy_lints/src/enum_variants.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/enum_variants.rs b/clippy_lints/src/enum_variants.rs
index 85334d09d4b..e332f681b6d 100644
--- a/clippy_lints/src/enum_variants.rs
+++ b/clippy_lints/src/enum_variants.rs
@@ -167,7 +167,7 @@ fn check_variant(cx: &LateContext<'_>, threshold: u64, def: &EnumDef<'_>, item_n
         return;
     }
 
-    let first = match &def.variants.get(0) {
+    let first = match def.variants.first() {
         Some(variant) => variant.ident.name.as_str(),
         None => return,
     };
-- 
cgit 1.4.1-3-g733a5


From 903add0c11a0205314bf49fff6851fea3478449c Mon Sep 17 00:00:00 2001
From: Philipp Krones <hello@philkrones.com>
Date: Mon, 25 Sep 2023 10:31:51 +0200
Subject: Fix dogfood fallout

---
 clippy_lints/src/doc.rs                   | 3 ++-
 clippy_lints/src/raw_strings.rs           | 2 +-
 clippy_utils/src/ty/type_certainty/mod.rs | 2 +-
 3 files changed, 4 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/doc.rs b/clippy_lints/src/doc.rs
index bf2add6aa64..e789e0da679 100644
--- a/clippy_lints/src/doc.rs
+++ b/clippy_lints/src/doc.rs
@@ -459,7 +459,7 @@ struct Fragments<'a> {
 
 impl Fragments<'_> {
     fn span(self, cx: &LateContext<'_>, range: Range<usize>) -> Option<Span> {
-        source_span_for_markdown_range(cx.tcx, &self.doc, &range, &self.fragments)
+        source_span_for_markdown_range(cx.tcx, self.doc, &range, self.fragments)
     }
 }
 
@@ -513,6 +513,7 @@ fn check_attrs(cx: &LateContext<'_>, valid_idents: &FxHashSet<String>, attrs: &[
 
 const RUST_CODE: &[&str] = &["rust", "no_run", "should_panic", "compile_fail"];
 
+#[allow(clippy::too_many_lines)] // Only a big match statement
 fn check_doc<'a, Events: Iterator<Item = (pulldown_cmark::Event<'a>, Range<usize>)>>(
     cx: &LateContext<'_>,
     valid_idents: &FxHashSet<String>,
diff --git a/clippy_lints/src/raw_strings.rs b/clippy_lints/src/raw_strings.rs
index ba80e37d37e..2895595e039 100644
--- a/clippy_lints/src/raw_strings.rs
+++ b/clippy_lints/src/raw_strings.rs
@@ -93,7 +93,7 @@ impl EarlyLintPass for RawStrings {
                             diag.span_suggestion(
                                 start,
                                 "use a string literal instead",
-                                format!("\"{}\"", str),
+                                format!("\"{str}\""),
                                 Applicability::MachineApplicable,
                             );
                         } else {
diff --git a/clippy_utils/src/ty/type_certainty/mod.rs b/clippy_utils/src/ty/type_certainty/mod.rs
index 713158c3a55..d05d9e7640f 100644
--- a/clippy_utils/src/ty/type_certainty/mod.rs
+++ b/clippy_utils/src/ty/type_certainty/mod.rs
@@ -207,7 +207,7 @@ fn path_segment_certainty(
             // Checking `res_generics_def_id(..)` before calling `generics_of` avoids an ICE.
             if cx.tcx.res_generics_def_id(path_segment.res).is_some() {
                 let generics = cx.tcx.generics_of(def_id);
-                let count = generics.params.len() - generics.host_effect_index.is_some() as usize;
+                let count = generics.params.len() - usize::from(generics.host_effect_index.is_some());
                 let lhs = if (parent_certainty.is_certain() || generics.parent_count == 0) && count == 0 {
                     Certainty::Certain(None)
                 } else {
-- 
cgit 1.4.1-3-g733a5


From 1972cc89c4e9db8f325137b58f7197aeef0a49d6 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Mon, 25 Sep 2023 11:55:20 +0000
Subject: Test that each config value exists in a test clippy.toml

---
 clippy_lints/Cargo.toml        |  3 +++
 clippy_lints/src/utils/conf.rs | 41 +++++++++++++++++++++++++++++++++++++++++
 2 files changed, 44 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/Cargo.toml b/clippy_lints/Cargo.toml
index dcd9a4adcbd..834753a2301 100644
--- a/clippy_lints/Cargo.toml
+++ b/clippy_lints/Cargo.toml
@@ -28,6 +28,9 @@ semver = "1.0"
 rustc-semver = "1.1"
 url = "2.2"
 
+[dev-dependencies]
+walkdir = "2.3"
+
 [features]
 deny-warnings = ["clippy_utils/deny-warnings"]
 # build clippy with internal lints enabled, off by default
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 75c3c7a958a..c502e50d21f 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -744,3 +744,44 @@ fn calculate_dimensions(fields: &[&str]) -> (usize, Vec<usize>) {
 
     (rows, column_widths)
 }
+
+#[cfg(test)]
+mod tests {
+    use rustc_data_structures::fx::{FxHashMap, FxHashSet};
+    use serde::de::IgnoredAny;
+    use std::fs;
+    use walkdir::WalkDir;
+
+    #[test]
+    fn configs_are_tested() {
+        let mut names: FxHashSet<String> = super::metadata::get_configuration_metadata()
+            .into_iter()
+            .map(|meta| meta.name.replace('_', "-"))
+            .collect();
+
+        let toml_files = WalkDir::new("../tests")
+            .into_iter()
+            .map(Result::unwrap)
+            .filter(|entry| entry.file_name() == "clippy.toml");
+
+        for entry in toml_files {
+            let file = fs::read_to_string(entry.path()).unwrap();
+            #[allow(clippy::zero_sized_map_values)]
+            if let Ok(map) = toml::from_str::<FxHashMap<String, IgnoredAny>>(&file) {
+                for name in map.keys() {
+                    names.remove(name.as_str());
+                }
+            }
+        }
+
+        assert!(
+            names.remove("allow-one-hash-in-raw-strings"),
+            "remove this when #11481 is fixed"
+        );
+
+        assert!(
+            names.is_empty(),
+            "Configuration variable lacks test: {names:?}\nAdd a test to `tests/ui-toml`"
+        );
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 84d6894f2665bc2d3876538f4f2eb7e88d3b92ee Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Mon, 25 Sep 2023 16:19:02 +0200
Subject: it's not Miri but MIR constants

---
 clippy_lints/src/enum_clike.rs               | 4 ++--
 clippy_lints/src/matches/overlapping_arms.rs | 6 +++---
 clippy_utils/src/consts.rs                   | 6 +++---
 clippy_utils/src/lib.rs                      | 6 +++---
 4 files changed, 11 insertions(+), 11 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/enum_clike.rs b/clippy_lints/src/enum_clike.rs
index 3f60e5a7c4d..646767868e2 100644
--- a/clippy_lints/src/enum_clike.rs
+++ b/clippy_lints/src/enum_clike.rs
@@ -1,7 +1,7 @@
 //! lint on C-like enums that are `repr(isize/usize)` and have values that
 //! don't fit into an `i32`
 
-use clippy_utils::consts::{miri_to_const, Constant};
+use clippy_utils::consts::{mir_to_const, Constant};
 use clippy_utils::diagnostics::span_lint;
 use rustc_hir::{Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
@@ -51,7 +51,7 @@ impl<'tcx> LateLintPass<'tcx> for UnportableVariant {
                         .const_eval_poly(def_id.to_def_id())
                         .ok()
                         .map(|val| rustc_middle::mir::Const::from_value(val, ty));
-                    if let Some(Constant::Int(val)) = constant.and_then(|c| miri_to_const(cx, c)) {
+                    if let Some(Constant::Int(val)) = constant.and_then(|c| mir_to_const(cx, c)) {
                         if let ty::Adt(adt, _) = ty.kind() {
                             if adt.is_enum() {
                                 ty = adt.repr().discr_type().to_ty(cx.tcx);
diff --git a/clippy_lints/src/matches/overlapping_arms.rs b/clippy_lints/src/matches/overlapping_arms.rs
index 7c0485914b8..8f0083f812c 100644
--- a/clippy_lints/src/matches/overlapping_arms.rs
+++ b/clippy_lints/src/matches/overlapping_arms.rs
@@ -1,4 +1,4 @@
-use clippy_utils::consts::{constant, constant_full_int, miri_to_const, FullInt};
+use clippy_utils::consts::{constant, constant_full_int, mir_to_const, FullInt};
 use clippy_utils::diagnostics::span_lint_and_note;
 use core::cmp::Ordering;
 use rustc_hir::{Arm, Expr, PatKind, RangeEnd};
@@ -37,14 +37,14 @@ fn all_ranges<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>], ty: Ty<'tcx>)
                         Some(lhs) => constant(cx, cx.typeck_results(), lhs)?,
                         None => {
                             let min_val_const = ty.numeric_min_val(cx.tcx)?;
-                            miri_to_const(cx, mir::Const::from_ty_const(min_val_const, cx.tcx))?
+                            mir_to_const(cx, mir::Const::from_ty_const(min_val_const, cx.tcx))?
                         },
                     };
                     let rhs_const = match rhs {
                         Some(rhs) => constant(cx, cx.typeck_results(), rhs)?,
                         None => {
                             let max_val_const = ty.numeric_max_val(cx.tcx)?;
-                            miri_to_const(cx, mir::Const::from_ty_const(max_val_const, cx.tcx))?
+                            mir_to_const(cx, mir::Const::from_ty_const(max_val_const, cx.tcx))?
                         },
                     };
                     let lhs_val = lhs_const.int_value(cx, ty)?;
diff --git a/clippy_utils/src/consts.rs b/clippy_utils/src/consts.rs
index d596eed4b7c..81584e8f1e4 100644
--- a/clippy_utils/src/consts.rs
+++ b/clippy_utils/src/consts.rs
@@ -403,7 +403,7 @@ impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
                     && adt_def.is_struct()
                     && let Some(desired_field) = field_of_struct(*adt_def, self.lcx, *constant, field)
                 {
-                    miri_to_const(self.lcx, desired_field)
+                    mir_to_const(self.lcx, desired_field)
                 }
                 else {
                     result
@@ -483,7 +483,7 @@ impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
                     .const_eval_resolve(self.param_env, mir::UnevaluatedConst::new(def_id, args), None)
                     .ok()
                     .map(|val| rustc_middle::mir::Const::from_value(val, ty))?;
-                let result = miri_to_const(self.lcx, result)?;
+                let result = mir_to_const(self.lcx, result)?;
                 self.source = ConstantSource::Constant;
                 Some(result)
             },
@@ -655,7 +655,7 @@ impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
     }
 }
 
-pub fn miri_to_const<'tcx>(lcx: &LateContext<'tcx>, result: mir::Const<'tcx>) -> Option<Constant<'tcx>> {
+pub fn mir_to_const<'tcx>(lcx: &LateContext<'tcx>, result: mir::Const<'tcx>) -> Option<Constant<'tcx>> {
     use rustc_middle::mir::ConstValue;
     match result {
         mir::Const::Val(ConstValue::Scalar(Scalar::Int(int)), _) => match result.ty().kind() {
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 0f7bc04ccba..3210581299c 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -113,7 +113,7 @@ use rustc_span::{sym, Span};
 use rustc_target::abi::Integer;
 use visitors::Visitable;
 
-use crate::consts::{constant, miri_to_const, Constant};
+use crate::consts::{constant, mir_to_const, Constant};
 use crate::higher::Range;
 use crate::ty::{
     adt_and_variant_of_res, can_partially_move_ty, expr_sig, is_copy, is_recursively_primitive_type,
@@ -1511,7 +1511,7 @@ pub fn is_range_full(cx: &LateContext<'_>, expr: &Expr<'_>, container_path: Opti
                 && let Some(min_val) = bnd_ty.numeric_min_val(cx.tcx)
                 && let const_val = cx.tcx.valtree_to_const_val((bnd_ty, min_val.to_valtree()))
                 && let min_const_kind = Const::from_value(const_val, bnd_ty)
-                && let Some(min_const) = miri_to_const(cx, min_const_kind)
+                && let Some(min_const) = mir_to_const(cx, min_const_kind)
                 && let Some(start_const) = constant(cx, cx.typeck_results(), start)
             {
                 start_const == min_const
@@ -1527,7 +1527,7 @@ pub fn is_range_full(cx: &LateContext<'_>, expr: &Expr<'_>, container_path: Opti
                         && let Some(max_val) = bnd_ty.numeric_max_val(cx.tcx)
                         && let const_val = cx.tcx.valtree_to_const_val((bnd_ty, max_val.to_valtree()))
                         && let max_const_kind = Const::from_value(const_val, bnd_ty)
-                        && let Some(max_const) = miri_to_const(cx, max_const_kind)
+                        && let Some(max_const) = mir_to_const(cx, max_const_kind)
                         && let Some(end_const) = constant(cx, cx.typeck_results(), end)
                     {
                         end_const == max_const
-- 
cgit 1.4.1-3-g733a5


From fab90003b860409113b60b11b5c3c58547c3f0ad Mon Sep 17 00:00:00 2001
From: koka <koka.code@gmail.com>
Date: Mon, 6 Feb 2023 21:09:39 +0900
Subject: Do not lint when imported item contains underscore

---
 clippy_lints/src/wildcard_imports.rs              |  1 +
 tests/ui/wildcard_imports.fixed                   | 28 +++++++++++++++++
 tests/ui/wildcard_imports.rs                      | 28 +++++++++++++++++
 tests/ui/wildcard_imports.stderr                  | 38 +++++++++++++----------
 tests/ui/wildcard_imports_2021.edition2018.fixed  | 28 +++++++++++++++++
 tests/ui/wildcard_imports_2021.edition2018.stderr | 38 +++++++++++++----------
 tests/ui/wildcard_imports_2021.edition2021.fixed  | 28 +++++++++++++++++
 tests/ui/wildcard_imports_2021.edition2021.stderr | 38 +++++++++++++----------
 tests/ui/wildcard_imports_2021.rs                 | 28 +++++++++++++++++
 9 files changed, 207 insertions(+), 48 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/wildcard_imports.rs b/clippy_lints/src/wildcard_imports.rs
index d09d02a7dfd..70b83149ce1 100644
--- a/clippy_lints/src/wildcard_imports.rs
+++ b/clippy_lints/src/wildcard_imports.rs
@@ -132,6 +132,7 @@ impl LateLintPass<'_> for WildcardImports {
             if self.warn_on_all || !self.check_exceptions(item, use_path.segments);
             let used_imports = cx.tcx.names_imported_by_glob_use(item.owner_id.def_id);
             if !used_imports.is_empty(); // Already handled by `unused_imports`
+            if !used_imports.contains(&kw::Underscore);
             then {
                 let mut applicability = Applicability::MachineApplicable;
                 let import_source_snippet = snippet_with_applicability(cx, use_path.span, "..", &mut applicability);
diff --git a/tests/ui/wildcard_imports.fixed b/tests/ui/wildcard_imports.fixed
index 2828f9d048e..6fdd728b9b7 100644
--- a/tests/ui/wildcard_imports.fixed
+++ b/tests/ui/wildcard_imports.fixed
@@ -69,6 +69,34 @@ mod struct_mod {
     }
 }
 
+// issue 9942
+mod underscore_mod {
+    // allow use of `deref` so that `clippy --fix` includes `Deref`.
+    #![allow(noop_method_call)]
+
+    mod exports_underscore {
+        pub use std::ops::Deref as _;
+        pub fn dummy() {}
+    }
+
+    mod exports_underscore_ish {
+        pub use std::ops::Deref as _Deref;
+        pub fn dummy() {}
+    }
+
+    fn does_not_lint() {
+        use self::exports_underscore::*;
+        let _ = (&0).deref();
+        dummy();
+    }
+
+    fn does_lint() {
+        use self::exports_underscore_ish::{_Deref, dummy};
+        let _ = (&0).deref();
+        dummy();
+    }
+}
+
 fn main() {
     foo();
     multi_foo();
diff --git a/tests/ui/wildcard_imports.rs b/tests/ui/wildcard_imports.rs
index cbe70e505d8..20e06d4b366 100644
--- a/tests/ui/wildcard_imports.rs
+++ b/tests/ui/wildcard_imports.rs
@@ -69,6 +69,34 @@ mod struct_mod {
     }
 }
 
+// issue 9942
+mod underscore_mod {
+    // allow use of `deref` so that `clippy --fix` includes `Deref`.
+    #![allow(noop_method_call)]
+
+    mod exports_underscore {
+        pub use std::ops::Deref as _;
+        pub fn dummy() {}
+    }
+
+    mod exports_underscore_ish {
+        pub use std::ops::Deref as _Deref;
+        pub fn dummy() {}
+    }
+
+    fn does_not_lint() {
+        use self::exports_underscore::*;
+        let _ = (&0).deref();
+        dummy();
+    }
+
+    fn does_lint() {
+        use self::exports_underscore_ish::*;
+        let _ = (&0).deref();
+        dummy();
+    }
+}
+
 fn main() {
     foo();
     multi_foo();
diff --git a/tests/ui/wildcard_imports.stderr b/tests/ui/wildcard_imports.stderr
index 3c750815baf..01a5414778c 100644
--- a/tests/ui/wildcard_imports.stderr
+++ b/tests/ui/wildcard_imports.stderr
@@ -38,55 +38,61 @@ LL | use wildcard_imports_helper::*;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `wildcard_imports_helper::{ExternA, extern_foo}`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:97:13
+  --> $DIR/wildcard_imports.rs:94:13
+   |
+LL |         use self::exports_underscore_ish::*;
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `self::exports_underscore_ish::{_Deref, dummy}`
+
+error: usage of wildcard import
+  --> $DIR/wildcard_imports.rs:125:13
    |
 LL |         use crate::fn_mod::*;
    |             ^^^^^^^^^^^^^^^^ help: try: `crate::fn_mod::foo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:103:75
+  --> $DIR/wildcard_imports.rs:131:75
    |
 LL |         use wildcard_imports_helper::inner::inner_for_self_import::{self, *};
    |                                                                           ^ help: try: `inner_extern_foo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:104:13
+  --> $DIR/wildcard_imports.rs:132:13
    |
 LL |         use wildcard_imports_helper::*;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `wildcard_imports_helper::{ExternA, extern_foo}`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:116:20
+  --> $DIR/wildcard_imports.rs:144:20
    |
 LL |         use self::{inner::*, inner2::*};
    |                    ^^^^^^^^ help: try: `inner::inner_foo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:116:30
+  --> $DIR/wildcard_imports.rs:144:30
    |
 LL |         use self::{inner::*, inner2::*};
    |                              ^^^^^^^^^ help: try: `inner2::inner_bar`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:123:13
+  --> $DIR/wildcard_imports.rs:151:13
    |
 LL |         use wildcard_imports_helper::*;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `wildcard_imports_helper::{ExternExportedEnum, ExternExportedStruct, extern_exported}`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:152:9
+  --> $DIR/wildcard_imports.rs:180:9
    |
 LL |     use crate::in_fn_test::*;
    |         ^^^^^^^^^^^^^^^^^^^^ help: try: `crate::in_fn_test::{ExportedEnum, ExportedStruct, exported}`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:161:9
+  --> $DIR/wildcard_imports.rs:189:9
    |
 LL |     use crate:: in_fn_test::  * ;
    |         ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `crate:: in_fn_test::exported`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:162:9
+  --> $DIR/wildcard_imports.rs:190:9
    |
 LL |       use crate:: fn_mod::
    |  _________^
@@ -94,40 +100,40 @@ LL | |         *;
    | |_________^ help: try: `crate:: fn_mod::foo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:173:13
+  --> $DIR/wildcard_imports.rs:201:13
    |
 LL |         use super::*;
    |             ^^^^^^^^ help: try: `super::foofoo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:208:17
+  --> $DIR/wildcard_imports.rs:236:17
    |
 LL |             use super::*;
    |                 ^^^^^^^^ help: try: `super::insidefoo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:216:13
+  --> $DIR/wildcard_imports.rs:244:13
    |
 LL |         use crate::super_imports::*;
    |             ^^^^^^^^^^^^^^^^^^^^^^^ help: try: `crate::super_imports::foofoo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:225:17
+  --> $DIR/wildcard_imports.rs:253:17
    |
 LL |             use super::super::*;
    |                 ^^^^^^^^^^^^^^^ help: try: `super::super::foofoo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:234:13
+  --> $DIR/wildcard_imports.rs:262:13
    |
 LL |         use super::super::super_imports::*;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `super::super::super_imports::foofoo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:242:13
+  --> $DIR/wildcard_imports.rs:270:13
    |
 LL |         use super::*;
    |             ^^^^^^^^ help: try: `super::foofoo`
 
-error: aborting due to 21 previous errors
+error: aborting due to 22 previous errors
 
diff --git a/tests/ui/wildcard_imports_2021.edition2018.fixed b/tests/ui/wildcard_imports_2021.edition2018.fixed
index b27281fa25c..6a9fe007d65 100644
--- a/tests/ui/wildcard_imports_2021.edition2018.fixed
+++ b/tests/ui/wildcard_imports_2021.edition2018.fixed
@@ -64,6 +64,34 @@ mod struct_mod {
     }
 }
 
+// issue 9942
+mod underscore_mod {
+    // allow use of `deref` so that `clippy --fix` includes `Deref`.
+    #![allow(noop_method_call)]
+
+    mod exports_underscore {
+        pub use std::ops::Deref as _;
+        pub fn dummy() {}
+    }
+
+    mod exports_underscore_ish {
+        pub use std::ops::Deref as _Deref;
+        pub fn dummy() {}
+    }
+
+    fn does_not_lint() {
+        use exports_underscore::*;
+        let _ = (&0).deref();
+        dummy();
+    }
+
+    fn does_lint() {
+        use exports_underscore_ish::{_Deref, dummy};
+        let _ = (&0).deref();
+        dummy();
+    }
+}
+
 fn main() {
     foo();
     multi_foo();
diff --git a/tests/ui/wildcard_imports_2021.edition2018.stderr b/tests/ui/wildcard_imports_2021.edition2018.stderr
index 709a665d65c..e39f240a4aa 100644
--- a/tests/ui/wildcard_imports_2021.edition2018.stderr
+++ b/tests/ui/wildcard_imports_2021.edition2018.stderr
@@ -38,55 +38,61 @@ LL | use wildcard_imports_helper::*;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `wildcard_imports_helper::{ExternA, extern_foo}`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports_2021.rs:91:13
+  --> $DIR/wildcard_imports_2021.rs:89:13
+   |
+LL |         use exports_underscore_ish::*;
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `exports_underscore_ish::{_Deref, dummy}`
+
+error: usage of wildcard import
+  --> $DIR/wildcard_imports_2021.rs:119:13
    |
 LL |         use crate::fn_mod::*;
    |             ^^^^^^^^^^^^^^^^ help: try: `crate::fn_mod::foo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports_2021.rs:97:75
+  --> $DIR/wildcard_imports_2021.rs:125:75
    |
 LL |         use wildcard_imports_helper::inner::inner_for_self_import::{self, *};
    |                                                                           ^ help: try: `inner_extern_foo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports_2021.rs:98:13
+  --> $DIR/wildcard_imports_2021.rs:126:13
    |
 LL |         use wildcard_imports_helper::*;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `wildcard_imports_helper::{ExternA, extern_foo}`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports_2021.rs:110:20
+  --> $DIR/wildcard_imports_2021.rs:138:20
    |
 LL |         use self::{inner::*, inner2::*};
    |                    ^^^^^^^^ help: try: `inner::inner_foo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports_2021.rs:110:30
+  --> $DIR/wildcard_imports_2021.rs:138:30
    |
 LL |         use self::{inner::*, inner2::*};
    |                              ^^^^^^^^^ help: try: `inner2::inner_bar`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports_2021.rs:117:13
+  --> $DIR/wildcard_imports_2021.rs:145:13
    |
 LL |         use wildcard_imports_helper::*;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `wildcard_imports_helper::{ExternExportedEnum, ExternExportedStruct, extern_exported}`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports_2021.rs:146:9
+  --> $DIR/wildcard_imports_2021.rs:174:9
    |
 LL |     use crate::in_fn_test::*;
    |         ^^^^^^^^^^^^^^^^^^^^ help: try: `crate::in_fn_test::{ExportedEnum, ExportedStruct, exported}`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports_2021.rs:155:9
+  --> $DIR/wildcard_imports_2021.rs:183:9
    |
 LL |     use crate:: in_fn_test::  * ;
    |         ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `crate:: in_fn_test::exported`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports_2021.rs:156:9
+  --> $DIR/wildcard_imports_2021.rs:184:9
    |
 LL |       use crate:: fn_mod::
    |  _________^
@@ -94,40 +100,40 @@ LL | |         *;
    | |_________^ help: try: `crate:: fn_mod::foo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports_2021.rs:167:13
+  --> $DIR/wildcard_imports_2021.rs:195:13
    |
 LL |         use super::*;
    |             ^^^^^^^^ help: try: `super::foofoo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports_2021.rs:202:17
+  --> $DIR/wildcard_imports_2021.rs:230:17
    |
 LL |             use super::*;
    |                 ^^^^^^^^ help: try: `super::insidefoo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports_2021.rs:210:13
+  --> $DIR/wildcard_imports_2021.rs:238:13
    |
 LL |         use crate::super_imports::*;
    |             ^^^^^^^^^^^^^^^^^^^^^^^ help: try: `crate::super_imports::foofoo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports_2021.rs:219:17
+  --> $DIR/wildcard_imports_2021.rs:247:17
    |
 LL |             use super::super::*;
    |                 ^^^^^^^^^^^^^^^ help: try: `super::super::foofoo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports_2021.rs:228:13
+  --> $DIR/wildcard_imports_2021.rs:256:13
    |
 LL |         use super::super::super_imports::*;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `super::super::super_imports::foofoo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports_2021.rs:236:13
+  --> $DIR/wildcard_imports_2021.rs:264:13
    |
 LL |         use super::*;
    |             ^^^^^^^^ help: try: `super::foofoo`
 
-error: aborting due to 21 previous errors
+error: aborting due to 22 previous errors
 
diff --git a/tests/ui/wildcard_imports_2021.edition2021.fixed b/tests/ui/wildcard_imports_2021.edition2021.fixed
index b27281fa25c..6a9fe007d65 100644
--- a/tests/ui/wildcard_imports_2021.edition2021.fixed
+++ b/tests/ui/wildcard_imports_2021.edition2021.fixed
@@ -64,6 +64,34 @@ mod struct_mod {
     }
 }
 
+// issue 9942
+mod underscore_mod {
+    // allow use of `deref` so that `clippy --fix` includes `Deref`.
+    #![allow(noop_method_call)]
+
+    mod exports_underscore {
+        pub use std::ops::Deref as _;
+        pub fn dummy() {}
+    }
+
+    mod exports_underscore_ish {
+        pub use std::ops::Deref as _Deref;
+        pub fn dummy() {}
+    }
+
+    fn does_not_lint() {
+        use exports_underscore::*;
+        let _ = (&0).deref();
+        dummy();
+    }
+
+    fn does_lint() {
+        use exports_underscore_ish::{_Deref, dummy};
+        let _ = (&0).deref();
+        dummy();
+    }
+}
+
 fn main() {
     foo();
     multi_foo();
diff --git a/tests/ui/wildcard_imports_2021.edition2021.stderr b/tests/ui/wildcard_imports_2021.edition2021.stderr
index 709a665d65c..e39f240a4aa 100644
--- a/tests/ui/wildcard_imports_2021.edition2021.stderr
+++ b/tests/ui/wildcard_imports_2021.edition2021.stderr
@@ -38,55 +38,61 @@ LL | use wildcard_imports_helper::*;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `wildcard_imports_helper::{ExternA, extern_foo}`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports_2021.rs:91:13
+  --> $DIR/wildcard_imports_2021.rs:89:13
+   |
+LL |         use exports_underscore_ish::*;
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `exports_underscore_ish::{_Deref, dummy}`
+
+error: usage of wildcard import
+  --> $DIR/wildcard_imports_2021.rs:119:13
    |
 LL |         use crate::fn_mod::*;
    |             ^^^^^^^^^^^^^^^^ help: try: `crate::fn_mod::foo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports_2021.rs:97:75
+  --> $DIR/wildcard_imports_2021.rs:125:75
    |
 LL |         use wildcard_imports_helper::inner::inner_for_self_import::{self, *};
    |                                                                           ^ help: try: `inner_extern_foo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports_2021.rs:98:13
+  --> $DIR/wildcard_imports_2021.rs:126:13
    |
 LL |         use wildcard_imports_helper::*;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `wildcard_imports_helper::{ExternA, extern_foo}`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports_2021.rs:110:20
+  --> $DIR/wildcard_imports_2021.rs:138:20
    |
 LL |         use self::{inner::*, inner2::*};
    |                    ^^^^^^^^ help: try: `inner::inner_foo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports_2021.rs:110:30
+  --> $DIR/wildcard_imports_2021.rs:138:30
    |
 LL |         use self::{inner::*, inner2::*};
    |                              ^^^^^^^^^ help: try: `inner2::inner_bar`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports_2021.rs:117:13
+  --> $DIR/wildcard_imports_2021.rs:145:13
    |
 LL |         use wildcard_imports_helper::*;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `wildcard_imports_helper::{ExternExportedEnum, ExternExportedStruct, extern_exported}`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports_2021.rs:146:9
+  --> $DIR/wildcard_imports_2021.rs:174:9
    |
 LL |     use crate::in_fn_test::*;
    |         ^^^^^^^^^^^^^^^^^^^^ help: try: `crate::in_fn_test::{ExportedEnum, ExportedStruct, exported}`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports_2021.rs:155:9
+  --> $DIR/wildcard_imports_2021.rs:183:9
    |
 LL |     use crate:: in_fn_test::  * ;
    |         ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `crate:: in_fn_test::exported`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports_2021.rs:156:9
+  --> $DIR/wildcard_imports_2021.rs:184:9
    |
 LL |       use crate:: fn_mod::
    |  _________^
@@ -94,40 +100,40 @@ LL | |         *;
    | |_________^ help: try: `crate:: fn_mod::foo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports_2021.rs:167:13
+  --> $DIR/wildcard_imports_2021.rs:195:13
    |
 LL |         use super::*;
    |             ^^^^^^^^ help: try: `super::foofoo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports_2021.rs:202:17
+  --> $DIR/wildcard_imports_2021.rs:230:17
    |
 LL |             use super::*;
    |                 ^^^^^^^^ help: try: `super::insidefoo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports_2021.rs:210:13
+  --> $DIR/wildcard_imports_2021.rs:238:13
    |
 LL |         use crate::super_imports::*;
    |             ^^^^^^^^^^^^^^^^^^^^^^^ help: try: `crate::super_imports::foofoo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports_2021.rs:219:17
+  --> $DIR/wildcard_imports_2021.rs:247:17
    |
 LL |             use super::super::*;
    |                 ^^^^^^^^^^^^^^^ help: try: `super::super::foofoo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports_2021.rs:228:13
+  --> $DIR/wildcard_imports_2021.rs:256:13
    |
 LL |         use super::super::super_imports::*;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `super::super::super_imports::foofoo`
 
 error: usage of wildcard import
-  --> $DIR/wildcard_imports_2021.rs:236:13
+  --> $DIR/wildcard_imports_2021.rs:264:13
    |
 LL |         use super::*;
    |             ^^^^^^^^ help: try: `super::foofoo`
 
-error: aborting due to 21 previous errors
+error: aborting due to 22 previous errors
 
diff --git a/tests/ui/wildcard_imports_2021.rs b/tests/ui/wildcard_imports_2021.rs
index 7dd2103eca7..18ebc0f5127 100644
--- a/tests/ui/wildcard_imports_2021.rs
+++ b/tests/ui/wildcard_imports_2021.rs
@@ -64,6 +64,34 @@ mod struct_mod {
     }
 }
 
+// issue 9942
+mod underscore_mod {
+    // allow use of `deref` so that `clippy --fix` includes `Deref`.
+    #![allow(noop_method_call)]
+
+    mod exports_underscore {
+        pub use std::ops::Deref as _;
+        pub fn dummy() {}
+    }
+
+    mod exports_underscore_ish {
+        pub use std::ops::Deref as _Deref;
+        pub fn dummy() {}
+    }
+
+    fn does_not_lint() {
+        use exports_underscore::*;
+        let _ = (&0).deref();
+        dummy();
+    }
+
+    fn does_lint() {
+        use exports_underscore_ish::*;
+        let _ = (&0).deref();
+        dummy();
+    }
+}
+
 fn main() {
     foo();
     multi_foo();
-- 
cgit 1.4.1-3-g733a5


From 6cdff107782be2c00ce37267bc5b2181dc1f12f7 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Tue, 26 Sep 2023 11:40:10 +0000
Subject: Describe the type of string in raw_strings lints

---
 clippy_lints/src/raw_strings.rs            | 30 +++++++++---------
 tests/ui/needless_raw_string.fixed         |  4 +++
 tests/ui/needless_raw_string.rs            |  4 +++
 tests/ui/needless_raw_string.stderr        | 46 +++++++++++++++++++++++++---
 tests/ui/needless_raw_string_hashes.stderr | 30 +++++++++---------
 tests/ui/write_literal_2.rs                | 10 +++---
 tests/ui/write_literal_2.stderr            | 49 +++++++++++-------------------
 7 files changed, 100 insertions(+), 73 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/raw_strings.rs b/clippy_lints/src/raw_strings.rs
index 2895595e039..4b46cbc4d89 100644
--- a/clippy_lints/src/raw_strings.rs
+++ b/clippy_lints/src/raw_strings.rs
@@ -75,6 +75,7 @@ impl EarlyLintPass for RawStrings {
             if !snippet(cx, expr.span, prefix).trim().starts_with(prefix) {
                 return;
             }
+            let descr = lit.kind.descr();
 
             if !str.contains(['\\', '"']) {
                 span_lint_and_then(
@@ -89,20 +90,17 @@ impl EarlyLintPass for RawStrings {
                         let r_pos = expr.span.lo() + BytePos::from_usize(prefix.len() - 1);
                         let start = start.with_lo(r_pos);
 
-                        if end.is_empty() {
-                            diag.span_suggestion(
-                                start,
-                                "use a string literal instead",
-                                format!("\"{str}\""),
-                                Applicability::MachineApplicable,
-                            );
-                        } else {
-                            diag.multipart_suggestion(
-                                "try",
-                                vec![(start, String::new()), (end, String::new())],
-                                Applicability::MachineApplicable,
-                            );
+                        let mut remove = vec![(start, String::new())];
+                        // avoid debug ICE from empty suggestions
+                        if !end.is_empty() {
+                            remove.push((end, String::new()));
                         }
+
+                        diag.multipart_suggestion_verbose(
+                            format!("use a plain {descr} literal instead"),
+                            remove,
+                            Applicability::MachineApplicable,
+                        );
                     },
                 );
                 if !matches!(cx.get_lint_level(NEEDLESS_RAW_STRINGS), rustc_lint::Allow) {
@@ -149,9 +147,9 @@ impl EarlyLintPass for RawStrings {
                         let (start, end) = hash_spans(expr.span, prefix, req, max);
 
                         let message = match max - req {
-                            _ if req == 0 => "remove all the hashes around the literal".to_string(),
-                            1 => "remove one hash from both sides of the literal".to_string(),
-                            n => format!("remove {n} hashes from both sides of the literal"),
+                            _ if req == 0 => format!("remove all the hashes around the {descr} literal"),
+                            1 => format!("remove one hash from both sides of the {descr} literal"),
+                            n => format!("remove {n} hashes from both sides of the {descr} literal"),
                         };
 
                         diag.multipart_suggestion(
diff --git a/tests/ui/needless_raw_string.fixed b/tests/ui/needless_raw_string.fixed
index 85549810513..4ea711fd67a 100644
--- a/tests/ui/needless_raw_string.fixed
+++ b/tests/ui/needless_raw_string.fixed
@@ -18,4 +18,8 @@ fn main() {
         multiline
         string
     ";
+
+    "no hashes";
+    b"no hashes";
+    c"no hashes";
 }
diff --git a/tests/ui/needless_raw_string.rs b/tests/ui/needless_raw_string.rs
index 06d49730387..b6239f9b1f0 100644
--- a/tests/ui/needless_raw_string.rs
+++ b/tests/ui/needless_raw_string.rs
@@ -18,4 +18,8 @@ fn main() {
         multiline
         string
     "#;
+
+    r"no hashes";
+    br"no hashes";
+    cr"no hashes";
 }
diff --git a/tests/ui/needless_raw_string.stderr b/tests/ui/needless_raw_string.stderr
index e6806b31b1d..276bc84c6c3 100644
--- a/tests/ui/needless_raw_string.stderr
+++ b/tests/ui/needless_raw_string.stderr
@@ -6,7 +6,7 @@ LL |     r#"aaa"#;
    |
    = note: `-D clippy::needless-raw-strings` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::needless_raw_strings)]`
-help: try
+help: use a plain string literal instead
    |
 LL -     r#"aaa"#;
 LL +     "aaa";
@@ -18,7 +18,7 @@ error: unnecessary raw string literal
 LL |     br#"aaa"#;
    |     ^^^^^^^^^
    |
-help: try
+help: use a plain byte string literal instead
    |
 LL -     br#"aaa"#;
 LL +     b"aaa";
@@ -30,7 +30,7 @@ error: unnecessary raw string literal
 LL |     cr#"aaa"#;
    |     ^^^^^^^^^
    |
-help: try
+help: use a plain C string literal instead
    |
 LL -     cr#"aaa"#;
 LL +     c"aaa";
@@ -46,7 +46,7 @@ LL | |         string
 LL | |     "#;
    | |______^
    |
-help: try
+help: use a plain string literal instead
    |
 LL ~     "
 LL |         a
@@ -55,5 +55,41 @@ LL |         string
 LL ~     ";
    |
 
-error: aborting due to 4 previous errors
+error: unnecessary raw string literal
+  --> $DIR/needless_raw_string.rs:22:5
+   |
+LL |     r"no hashes";
+   |     ^^^^^^^^^^^^
+   |
+help: use a plain string literal instead
+   |
+LL -     r"no hashes";
+LL +     "no hashes";
+   |
+
+error: unnecessary raw string literal
+  --> $DIR/needless_raw_string.rs:23:5
+   |
+LL |     br"no hashes";
+   |     ^^^^^^^^^^^^^
+   |
+help: use a plain byte string literal instead
+   |
+LL -     br"no hashes";
+LL +     b"no hashes";
+   |
+
+error: unnecessary raw string literal
+  --> $DIR/needless_raw_string.rs:24:5
+   |
+LL |     cr"no hashes";
+   |     ^^^^^^^^^^^^^
+   |
+help: use a plain C string literal instead
+   |
+LL -     cr"no hashes";
+LL +     c"no hashes";
+   |
+
+error: aborting due to 7 previous errors
 
diff --git a/tests/ui/needless_raw_string_hashes.stderr b/tests/ui/needless_raw_string_hashes.stderr
index 4399c6555c2..017160b1a42 100644
--- a/tests/ui/needless_raw_string_hashes.stderr
+++ b/tests/ui/needless_raw_string_hashes.stderr
@@ -6,7 +6,7 @@ LL |     r#"\aaa"#;
    |
    = note: `-D clippy::needless-raw-string-hashes` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::needless_raw_string_hashes)]`
-help: remove all the hashes around the literal
+help: remove all the hashes around the string literal
    |
 LL -     r#"\aaa"#;
 LL +     r"\aaa";
@@ -18,7 +18,7 @@ error: unnecessary hashes around raw string literal
 LL |     r##"Hello "world"!"##;
    |     ^^^^^^^^^^^^^^^^^^^^^
    |
-help: remove one hash from both sides of the literal
+help: remove one hash from both sides of the string literal
    |
 LL -     r##"Hello "world"!"##;
 LL +     r#"Hello "world"!"#;
@@ -30,7 +30,7 @@ error: unnecessary hashes around raw string literal
 LL |     r######" "### "## "# "######;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-help: remove 2 hashes from both sides of the literal
+help: remove 2 hashes from both sides of the string literal
    |
 LL -     r######" "### "## "# "######;
 LL +     r####" "### "## "# "####;
@@ -42,7 +42,7 @@ error: unnecessary hashes around raw string literal
 LL |     r######" "aa" "# "## "######;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-help: remove 3 hashes from both sides of the literal
+help: remove 3 hashes from both sides of the string literal
    |
 LL -     r######" "aa" "# "## "######;
 LL +     r###" "aa" "# "## "###;
@@ -54,7 +54,7 @@ error: unnecessary hashes around raw string literal
 LL |     br#"\aaa"#;
    |     ^^^^^^^^^^
    |
-help: remove all the hashes around the literal
+help: remove all the hashes around the byte string literal
    |
 LL -     br#"\aaa"#;
 LL +     br"\aaa";
@@ -66,7 +66,7 @@ error: unnecessary hashes around raw string literal
 LL |     br##"Hello "world"!"##;
    |     ^^^^^^^^^^^^^^^^^^^^^^
    |
-help: remove one hash from both sides of the literal
+help: remove one hash from both sides of the byte string literal
    |
 LL -     br##"Hello "world"!"##;
 LL +     br#"Hello "world"!"#;
@@ -78,7 +78,7 @@ error: unnecessary hashes around raw string literal
 LL |     br######" "### "## "# "######;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-help: remove 2 hashes from both sides of the literal
+help: remove 2 hashes from both sides of the byte string literal
    |
 LL -     br######" "### "## "# "######;
 LL +     br####" "### "## "# "####;
@@ -90,7 +90,7 @@ error: unnecessary hashes around raw string literal
 LL |     br######" "aa" "# "## "######;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-help: remove 3 hashes from both sides of the literal
+help: remove 3 hashes from both sides of the byte string literal
    |
 LL -     br######" "aa" "# "## "######;
 LL +     br###" "aa" "# "## "###;
@@ -102,7 +102,7 @@ error: unnecessary hashes around raw string literal
 LL |     cr#"\aaa"#;
    |     ^^^^^^^^^^
    |
-help: remove all the hashes around the literal
+help: remove all the hashes around the C string literal
    |
 LL -     cr#"\aaa"#;
 LL +     cr"\aaa";
@@ -114,7 +114,7 @@ error: unnecessary hashes around raw string literal
 LL |     cr##"Hello "world"!"##;
    |     ^^^^^^^^^^^^^^^^^^^^^^
    |
-help: remove one hash from both sides of the literal
+help: remove one hash from both sides of the C string literal
    |
 LL -     cr##"Hello "world"!"##;
 LL +     cr#"Hello "world"!"#;
@@ -126,7 +126,7 @@ error: unnecessary hashes around raw string literal
 LL |     cr######" "### "## "# "######;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-help: remove 2 hashes from both sides of the literal
+help: remove 2 hashes from both sides of the C string literal
    |
 LL -     cr######" "### "## "# "######;
 LL +     cr####" "### "## "# "####;
@@ -138,7 +138,7 @@ error: unnecessary hashes around raw string literal
 LL |     cr######" "aa" "# "## "######;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-help: remove 3 hashes from both sides of the literal
+help: remove 3 hashes from both sides of the C string literal
    |
 LL -     cr######" "aa" "# "## "######;
 LL +     cr###" "aa" "# "## "###;
@@ -154,7 +154,7 @@ LL | |         string
 LL | |     "#;
    | |______^
    |
-help: remove all the hashes around the literal
+help: remove all the hashes around the string literal
    |
 LL ~     r"
 LL |         \a
@@ -169,7 +169,7 @@ error: unnecessary hashes around raw string literal
 LL |     r###"rust"###;
    |     ^^^^^^^^^^^^^
    |
-help: remove all the hashes around the literal
+help: remove all the hashes around the string literal
    |
 LL -     r###"rust"###;
 LL +     r"rust";
@@ -181,7 +181,7 @@ error: unnecessary hashes around raw string literal
 LL |     r#"hello world"#;
    |     ^^^^^^^^^^^^^^^^
    |
-help: remove all the hashes around the literal
+help: remove all the hashes around the string literal
    |
 LL -     r#"hello world"#;
 LL +     r"hello world";
diff --git a/tests/ui/write_literal_2.rs b/tests/ui/write_literal_2.rs
index aa0c13c1340..197e01149e0 100644
--- a/tests/ui/write_literal_2.rs
+++ b/tests/ui/write_literal_2.rs
@@ -1,6 +1,6 @@
 //@no-rustfix: overlapping suggestions
 #![allow(unused_must_use)]
-#![warn(clippy::needless_raw_strings, clippy::write_literal)]
+#![warn(clippy::write_literal)]
 
 use std::io::Write;
 
@@ -11,9 +11,7 @@ fn main() {
     //~^ ERROR: literal with an empty format string
     //~| NOTE: `-D clippy::write-literal` implied by `-D warnings`
     writeln!(v, r"{}", r"{hello}");
-    //~^ ERROR: unnecessary raw string literal
-    //~| NOTE: `-D clippy::needless-raw-strings` implied by `-D warnings`
-    //~| ERROR: literal with an empty format string
+    //~^ ERROR: literal with an empty format string
     writeln!(v, "{}", '\'');
     //~^ ERROR: literal with an empty format string
     writeln!(v, "{}", '"');
@@ -26,8 +24,8 @@ fn main() {
         v,
         "some {}",
         "hello \
-        //~^ ERROR: literal with an empty format string
-        world!"
+        world!",
+        //~^^ ERROR: literal with an empty format string
     );
     writeln!(
         v,
diff --git a/tests/ui/write_literal_2.stderr b/tests/ui/write_literal_2.stderr
index 6d382a267ad..9a16d2f240d 100644
--- a/tests/ui/write_literal_2.stderr
+++ b/tests/ui/write_literal_2.stderr
@@ -1,14 +1,3 @@
-error: unnecessary raw string literal
-  --> $DIR/write_literal_2.rs:13:24
-   |
-LL |     writeln!(v, r"{}", r"{hello}");
-   |                        -^^^^^^^^^
-   |                        |
-   |                        help: use a string literal instead: `"{hello}"`
-   |
-   = note: `-D clippy::needless-raw-strings` implied by `-D warnings`
-   = help: to override `-D warnings` add `#[allow(clippy::needless_raw_strings)]`
-
 error: literal with an empty format string
   --> $DIR/write_literal_2.rs:10:23
    |
@@ -36,7 +25,7 @@ LL +     writeln!(v, r"{{hello}}");
    |
 
 error: literal with an empty format string
-  --> $DIR/write_literal_2.rs:17:23
+  --> $DIR/write_literal_2.rs:15:23
    |
 LL |     writeln!(v, "{}", '\'');
    |                       ^^^^
@@ -48,7 +37,7 @@ LL +     writeln!(v, "'");
    |
 
 error: literal with an empty format string
-  --> $DIR/write_literal_2.rs:19:23
+  --> $DIR/write_literal_2.rs:17:23
    |
 LL |     writeln!(v, "{}", '"');
    |                       ^^^
@@ -60,13 +49,13 @@ LL +     writeln!(v, "\"");
    |
 
 error: literal with an empty format string
-  --> $DIR/write_literal_2.rs:21:24
+  --> $DIR/write_literal_2.rs:19:24
    |
 LL |     writeln!(v, r"{}", '"');
    |                        ^^^
 
 error: literal with an empty format string
-  --> $DIR/write_literal_2.rs:23:24
+  --> $DIR/write_literal_2.rs:21:24
    |
 LL |     writeln!(v, r"{}", '\'');
    |                        ^^^^
@@ -78,22 +67,20 @@ LL +     writeln!(v, r"'");
    |
 
 error: literal with an empty format string
-  --> $DIR/write_literal_2.rs:28:9
+  --> $DIR/write_literal_2.rs:26:9
    |
 LL | /         "hello \
-LL | |
-LL | |         world!"
+LL | |         world!",
    | |_______________^
    |
 help: try
    |
 LL ~         "some hello \
-LL +
-LL ~         world!"
+LL ~         world!",
    |
 
 error: literal with an empty format string
-  --> $DIR/write_literal_2.rs:36:9
+  --> $DIR/write_literal_2.rs:34:9
    |
 LL |         "1",
    |         ^^^
@@ -105,7 +92,7 @@ LL ~         {} \\ {}",
    |
 
 error: literal with an empty format string
-  --> $DIR/write_literal_2.rs:37:9
+  --> $DIR/write_literal_2.rs:35:9
    |
 LL |         "2",
    |         ^^^
@@ -117,7 +104,7 @@ LL ~         "1",
    |
 
 error: literal with an empty format string
-  --> $DIR/write_literal_2.rs:38:9
+  --> $DIR/write_literal_2.rs:36:9
    |
 LL |         "3",
    |         ^^^
@@ -130,7 +117,7 @@ LL ~         "2",
    |
 
 error: literal with an empty format string
-  --> $DIR/write_literal_2.rs:41:23
+  --> $DIR/write_literal_2.rs:39:23
    |
 LL |     writeln!(v, "{}", "\\");
    |                       ^^^^
@@ -142,7 +129,7 @@ LL +     writeln!(v, "\\");
    |
 
 error: literal with an empty format string
-  --> $DIR/write_literal_2.rs:43:24
+  --> $DIR/write_literal_2.rs:41:24
    |
 LL |     writeln!(v, r"{}", "\\");
    |                        ^^^^
@@ -154,7 +141,7 @@ LL +     writeln!(v, r"\");
    |
 
 error: literal with an empty format string
-  --> $DIR/write_literal_2.rs:45:26
+  --> $DIR/write_literal_2.rs:43:26
    |
 LL |     writeln!(v, r#"{}"#, "\\");
    |                          ^^^^
@@ -166,7 +153,7 @@ LL +     writeln!(v, r#"\"#);
    |
 
 error: literal with an empty format string
-  --> $DIR/write_literal_2.rs:47:23
+  --> $DIR/write_literal_2.rs:45:23
    |
 LL |     writeln!(v, "{}", r"\");
    |                       ^^^^
@@ -178,7 +165,7 @@ LL +     writeln!(v, "\\");
    |
 
 error: literal with an empty format string
-  --> $DIR/write_literal_2.rs:49:23
+  --> $DIR/write_literal_2.rs:47:23
    |
 LL |     writeln!(v, "{}", "\r");
    |                       ^^^^
@@ -190,16 +177,16 @@ LL +     writeln!(v, "\r");
    |
 
 error: literal with an empty format string
-  --> $DIR/write_literal_2.rs:52:28
+  --> $DIR/write_literal_2.rs:50:28
    |
 LL |     writeln!(v, r#"{}{}"#, '#', '"');
    |                            ^^^
 
 error: literal with an empty format string
-  --> $DIR/write_literal_2.rs:52:33
+  --> $DIR/write_literal_2.rs:50:33
    |
 LL |     writeln!(v, r#"{}{}"#, '#', '"');
    |                                 ^^^
 
-error: aborting due to 18 previous errors
+error: aborting due to 17 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From ec2f62677f5e7e6a1ed7e02fd61100c78c896d86 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Sat, 23 Sep 2023 17:34:05 +0000
Subject: Add `manual_hash_one` lint

---
 CHANGELOG.md                        |   1 +
 book/src/lint_configuration.md      |   1 +
 clippy_lints/src/declared_lints.rs  |   1 +
 clippy_lints/src/lib.rs             |   2 +
 clippy_lints/src/manual_hash_one.rs | 133 ++++++++++++++++++++++++++++++++++++
 clippy_lints/src/utils/conf.rs      |   2 +-
 clippy_utils/src/msrvs.rs           |   2 +-
 clippy_utils/src/visitors.rs        |  44 ++++++++++++
 tests/ui/manual_hash_one.fixed      |  89 ++++++++++++++++++++++++
 tests/ui/manual_hash_one.rs         |  89 ++++++++++++++++++++++++
 tests/ui/manual_hash_one.stderr     |  56 +++++++++++++++
 11 files changed, 418 insertions(+), 2 deletions(-)
 create mode 100644 clippy_lints/src/manual_hash_one.rs
 create mode 100644 tests/ui/manual_hash_one.fixed
 create mode 100644 tests/ui/manual_hash_one.rs
 create mode 100644 tests/ui/manual_hash_one.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 8c9ab1e2402..db54bfbf0b3 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5072,6 +5072,7 @@ Released 2018-09-13
 [`manual_find`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_find
 [`manual_find_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_find_map
 [`manual_flatten`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_flatten
+[`manual_hash_one`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_hash_one
 [`manual_instant_elapsed`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_instant_elapsed
 [`manual_is_ascii_check`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_is_ascii_check
 [`manual_is_finite`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_is_finite
diff --git a/book/src/lint_configuration.md b/book/src/lint_configuration.md
index b980083f1f5..2c958ccbbc2 100644
--- a/book/src/lint_configuration.md
+++ b/book/src/lint_configuration.md
@@ -151,6 +151,7 @@ The minimum rust version that the project supports
 * [`type_repetition_in_bounds`](https://rust-lang.github.io/rust-clippy/master/index.html#type_repetition_in_bounds)
 * [`tuple_array_conversions`](https://rust-lang.github.io/rust-clippy/master/index.html#tuple_array_conversions)
 * [`manual_try_fold`](https://rust-lang.github.io/rust-clippy/master/index.html#manual_try_fold)
+* [`manual_hash_one`](https://rust-lang.github.io/rust-clippy/master/index.html#manual_hash_one)
 
 
 ## `cognitive-complexity-threshold`
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 4d1281ec1e7..b4b84b36044 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -280,6 +280,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::manual_clamp::MANUAL_CLAMP_INFO,
     crate::manual_float_methods::MANUAL_IS_FINITE_INFO,
     crate::manual_float_methods::MANUAL_IS_INFINITE_INFO,
+    crate::manual_hash_one::MANUAL_HASH_ONE_INFO,
     crate::manual_is_ascii_check::MANUAL_IS_ASCII_CHECK_INFO,
     crate::manual_let_else::MANUAL_LET_ELSE_INFO,
     crate::manual_main_separator_str::MANUAL_MAIN_SEPARATOR_STR_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 1271be2fd93..63a3fbcb897 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -190,6 +190,7 @@ mod manual_async_fn;
 mod manual_bits;
 mod manual_clamp;
 mod manual_float_methods;
+mod manual_hash_one;
 mod manual_is_ascii_check;
 mod manual_let_else;
 mod manual_main_separator_str;
@@ -1119,6 +1120,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
             msrv(),
         ))
     });
+    store.register_late_pass(move |_| Box::new(manual_hash_one::ManualHashOne::new(msrv())));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/manual_hash_one.rs b/clippy_lints/src/manual_hash_one.rs
new file mode 100644
index 00000000000..ea911335450
--- /dev/null
+++ b/clippy_lints/src/manual_hash_one.rs
@@ -0,0 +1,133 @@
+use clippy_utils::diagnostics::span_lint_hir_and_then;
+use clippy_utils::msrvs::{self, Msrv};
+use clippy_utils::source::snippet_opt;
+use clippy_utils::visitors::{is_local_used, local_used_once};
+use clippy_utils::{is_trait_method, path_to_local_id};
+use rustc_errors::Applicability;
+use rustc_hir::{BindingAnnotation, ExprKind, Local, Node, PatKind, StmtKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::sym;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for cases where [`BuildHasher::hash_one`] can be used.
+    ///
+    /// [`BuildHasher::hash_one`]: https://doc.rust-lang.org/std/hash/trait.BuildHasher.html#method.hash_one
+    ///
+    /// ### Why is this bad?
+    /// It is more concise to use the `hash_one` method.
+    ///
+    /// ### Example
+    /// ```rust
+    /// use std::hash::{BuildHasher, Hash, Hasher};
+    /// use std::collections::hash_map::RandomState;
+    ///
+    /// let s = RandomState::new();
+    /// let value = vec![1, 2, 3];
+    ///
+    /// let mut hasher = s.build_hasher();
+    /// value.hash(&mut hasher);
+    /// let hash = hasher.finish();
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// use std::hash::BuildHasher;
+    /// use std::collections::hash_map::RandomState;
+    ///
+    /// let s = RandomState::new();
+    /// let value = vec![1, 2, 3];
+    ///
+    /// let hash = s.hash_one(&value);
+    /// ```
+    #[clippy::version = "1.74.0"]
+    pub MANUAL_HASH_ONE,
+    complexity,
+    "manual implementations of `BuildHasher::hash_one`"
+}
+
+pub struct ManualHashOne {
+    msrv: Msrv,
+}
+
+impl ManualHashOne {
+    #[must_use]
+    pub fn new(msrv: Msrv) -> Self {
+        Self { msrv }
+    }
+}
+
+impl_lint_pass!(ManualHashOne => [MANUAL_HASH_ONE]);
+
+impl LateLintPass<'_> for ManualHashOne {
+    fn check_local(&mut self, cx: &LateContext<'_>, local: &Local<'_>) {
+        // `let mut hasher = seg.build_hasher();`
+        if let PatKind::Binding(BindingAnnotation::MUT, hasher, _, None) = local.pat.kind
+            && let Some(init) = local.init
+            && !init.span.from_expansion()
+            && let ExprKind::MethodCall(seg, build_hasher, [], _) = init.kind
+            && seg.ident.name == sym!(build_hasher)
+
+            && let Node::Stmt(local_stmt) = cx.tcx.hir().get_parent(local.hir_id)
+            && let Node::Block(block) = cx.tcx.hir().get_parent(local_stmt.hir_id)
+
+            && let mut stmts = block.stmts.iter()
+                .skip_while(|stmt| stmt.hir_id != local_stmt.hir_id)
+                .skip(1)
+                .filter(|&stmt| is_local_used(cx, stmt, hasher))
+
+            // `hashed_value.hash(&mut hasher);`
+            && let Some(hash_stmt) = stmts.next()
+            && let StmtKind::Semi(hash_expr) = hash_stmt.kind
+            && !hash_expr.span.from_expansion()
+            && let ExprKind::MethodCall(seg, hashed_value, [ref_to_hasher], _) = hash_expr.kind
+            && seg.ident.name == sym::hash
+            && is_trait_method(cx, hash_expr, sym::Hash)
+            && path_to_local_id(ref_to_hasher.peel_borrows(), hasher)
+
+            && let maybe_finish_stmt = stmts.next()
+            // There should be no more statements referencing `hasher`
+            && stmts.next().is_none()
+
+            // `hasher.finish()`, may be anywhere in a statement or the trailing expr of the block
+            && let Some(path_expr) = local_used_once(cx, (maybe_finish_stmt, block.expr), hasher)
+            && let Node::Expr(finish_expr) = cx.tcx.hir().get_parent(path_expr.hir_id)
+            && !finish_expr.span.from_expansion()
+            && let ExprKind::MethodCall(seg, _, [], _) = finish_expr.kind
+            && seg.ident.name == sym!(finish)
+
+            && self.msrv.meets(msrvs::BUILD_HASHER_HASH_ONE)
+        {
+            span_lint_hir_and_then(
+                cx,
+                MANUAL_HASH_ONE,
+                finish_expr.hir_id,
+                finish_expr.span,
+                "manual implementation of `BuildHasher::hash_one`",
+                |diag| {
+                    if let Some(build_hasher) = snippet_opt(cx, build_hasher.span)
+                        && let Some(hashed_value) = snippet_opt(cx, hashed_value.span)
+                    {
+                        diag.multipart_suggestion(
+                            "try",
+                            vec![
+                                (local_stmt.span, String::new()),
+                                (hash_stmt.span, String::new()),
+                                (
+                                    finish_expr.span,
+                                    // `needless_borrows_for_generic_args` will take care of
+                                    // removing the `&` when it isn't needed
+                                    format!("{build_hasher}.hash_one(&{hashed_value})")
+                                )
+                            ],
+                            Applicability::MachineApplicable,
+                        );
+
+                    }
+                },
+            );
+        }
+    }
+
+    extract_msrv_attr!(LateContext);
+}
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index c502e50d21f..23da1de7730 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -294,7 +294,7 @@ define_Conf! {
     ///
     /// Suppress lints whenever the suggested change would cause breakage for other crates.
     (avoid_breaking_exported_api: bool = true),
-    /// Lint: MANUAL_SPLIT_ONCE, MANUAL_STR_REPEAT, CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, OPTION_MAP_UNWRAP_OR, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR, IF_THEN_SOME_ELSE_NONE, APPROX_CONSTANT, DEPRECATED_CFG_ATTR, INDEX_REFUTABLE_SLICE, MAP_CLONE, BORROW_AS_PTR, MANUAL_BITS, ERR_EXPECT, CAST_ABS_TO_UNSIGNED, UNINLINED_FORMAT_ARGS, MANUAL_CLAMP, MANUAL_LET_ELSE, UNCHECKED_DURATION_SUBTRACTION, COLLAPSIBLE_STR_REPLACE, SEEK_FROM_CURRENT, SEEK_REWIND, UNNECESSARY_LAZY_EVALUATIONS, TRANSMUTE_PTR_TO_REF, ALMOST_COMPLETE_RANGE, NEEDLESS_BORROW, DERIVABLE_IMPLS, MANUAL_IS_ASCII_CHECK, MANUAL_REM_EUCLID, MANUAL_RETAIN, TYPE_REPETITION_IN_BOUNDS, TUPLE_ARRAY_CONVERSIONS, MANUAL_TRY_FOLD.
+    /// Lint: MANUAL_SPLIT_ONCE, MANUAL_STR_REPEAT, CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, OPTION_MAP_UNWRAP_OR, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR, IF_THEN_SOME_ELSE_NONE, APPROX_CONSTANT, DEPRECATED_CFG_ATTR, INDEX_REFUTABLE_SLICE, MAP_CLONE, BORROW_AS_PTR, MANUAL_BITS, ERR_EXPECT, CAST_ABS_TO_UNSIGNED, UNINLINED_FORMAT_ARGS, MANUAL_CLAMP, MANUAL_LET_ELSE, UNCHECKED_DURATION_SUBTRACTION, COLLAPSIBLE_STR_REPLACE, SEEK_FROM_CURRENT, SEEK_REWIND, UNNECESSARY_LAZY_EVALUATIONS, TRANSMUTE_PTR_TO_REF, ALMOST_COMPLETE_RANGE, NEEDLESS_BORROW, DERIVABLE_IMPLS, MANUAL_IS_ASCII_CHECK, MANUAL_REM_EUCLID, MANUAL_RETAIN, TYPE_REPETITION_IN_BOUNDS, TUPLE_ARRAY_CONVERSIONS, MANUAL_TRY_FOLD, MANUAL_HASH_ONE.
     ///
     /// The minimum rust version that the project supports
     (msrv: Option<String> = None),
diff --git a/clippy_utils/src/msrvs.rs b/clippy_utils/src/msrvs.rs
index 0faff05eb23..df839c2106f 100644
--- a/clippy_utils/src/msrvs.rs
+++ b/clippy_utils/src/msrvs.rs
@@ -19,7 +19,7 @@ macro_rules! msrv_aliases {
 
 // names may refer to stabilized feature flags or library items
 msrv_aliases! {
-    1,71,0 { TUPLE_ARRAY_CONVERSIONS }
+    1,71,0 { TUPLE_ARRAY_CONVERSIONS, BUILD_HASHER_HASH_ONE }
     1,70,0 { OPTION_IS_SOME_AND, BINARY_HEAP_RETAIN }
     1,68,0 { PATH_MAIN_SEPARATOR_STR }
     1,65,0 { LET_ELSE, POINTER_CAST_CONSTNESS }
diff --git a/clippy_utils/src/visitors.rs b/clippy_utils/src/visitors.rs
index 3b47a451345..d752fe7d97e 100644
--- a/clippy_utils/src/visitors.rs
+++ b/clippy_utils/src/visitors.rs
@@ -62,6 +62,27 @@ where
         }
     }
 }
+impl<'tcx, A, B> Visitable<'tcx> for (A, B)
+where
+    A: Visitable<'tcx>,
+    B: Visitable<'tcx>,
+{
+    fn visit<V: Visitor<'tcx>>(self, visitor: &mut V) {
+        let (a, b) = self;
+        a.visit(visitor);
+        b.visit(visitor);
+    }
+}
+impl<'tcx, T> Visitable<'tcx> for Option<T>
+where
+    T: Visitable<'tcx>,
+{
+    fn visit<V: Visitor<'tcx>>(self, visitor: &mut V) {
+        if let Some(x) = self {
+            x.visit(visitor);
+        }
+    }
+}
 macro_rules! visitable_ref {
     ($t:ident, $f:ident) => {
         impl<'tcx> Visitable<'tcx> for &'tcx $t<'tcx> {
@@ -748,3 +769,26 @@ pub fn contains_break_or_continue(expr: &Expr<'_>) -> bool {
     })
     .is_some()
 }
+
+/// If the local is only used once in `visitable` returns the path expression referencing the given
+/// local
+pub fn local_used_once<'tcx>(
+    cx: &LateContext<'tcx>,
+    visitable: impl Visitable<'tcx>,
+    id: HirId,
+) -> Option<&'tcx Expr<'tcx>> {
+    let mut expr = None;
+
+    let cf = for_each_expr_with_closures(cx, visitable, |e| {
+        if path_to_local_id(e, id) && expr.replace(e).is_some() {
+            ControlFlow::Break(())
+        } else {
+            ControlFlow::Continue(())
+        }
+    });
+    if cf.is_some() {
+        return None;
+    }
+
+    expr
+}
diff --git a/tests/ui/manual_hash_one.fixed b/tests/ui/manual_hash_one.fixed
new file mode 100644
index 00000000000..edfd9c4a47b
--- /dev/null
+++ b/tests/ui/manual_hash_one.fixed
@@ -0,0 +1,89 @@
+#![warn(clippy::manual_hash_one)]
+#![allow(clippy::needless_borrows_for_generic_args)]
+
+use std::hash::{BuildHasher, Hash, Hasher};
+
+fn returned(b: impl BuildHasher) -> u64 {
+    
+    
+    b.hash_one(&true)
+}
+
+fn unsized_receiver(b: impl BuildHasher, s: &str) {
+    
+    
+    let _ = b.hash_one(&s[4..10]);
+}
+
+fn owned_value(b: impl BuildHasher, v: Vec<u32>) -> Vec<u32> {
+    
+    
+    let _ = b.hash_one(&v);
+    v
+}
+
+fn reused_hasher(b: impl BuildHasher) {
+    let mut hasher = b.build_hasher();
+    true.hash(&mut hasher);
+    let _ = hasher.finish();
+    let _ = hasher.finish();
+}
+
+fn reused_hasher_in_return(b: impl BuildHasher) -> u64 {
+    let mut hasher = b.build_hasher();
+    true.hash(&mut hasher);
+    let _ = hasher.finish();
+    hasher.finish()
+}
+
+fn no_hash(b: impl BuildHasher) {
+    let mut hasher = b.build_hasher();
+    let _ = hasher.finish();
+}
+
+fn hash_twice(b: impl BuildHasher) {
+    let mut hasher = b.build_hasher();
+    true.hash(&mut hasher);
+    true.hash(&mut hasher);
+    let _ = hasher.finish();
+}
+
+fn other_hasher(b: impl BuildHasher) {
+    let mut other_hasher = b.build_hasher();
+
+    let mut hasher = b.build_hasher();
+    true.hash(&mut other_hasher);
+    let _ = hasher.finish();
+}
+
+fn finish_then_hash(b: impl BuildHasher) {
+    let mut hasher = b.build_hasher();
+    let _ = hasher.finish();
+    true.hash(&mut hasher);
+}
+
+fn in_macro(b: impl BuildHasher) {
+    macro_rules! m {
+        ($b:expr) => {{
+            let mut hasher = $b.build_hasher();
+            true.hash(&mut hasher);
+            let _ = hasher.finish();
+        }};
+    }
+
+    m!(b);
+}
+
+#[clippy::msrv = "1.70"]
+fn msrv_1_70(b: impl BuildHasher, v: impl Hash) {
+    let mut hasher = b.build_hasher();
+    v.hash(&mut hasher);
+    let _ = hasher.finish();
+}
+
+#[clippy::msrv = "1.71"]
+fn msrv_1_71(b: impl BuildHasher, v: impl Hash) {
+    
+    
+    let _ = b.hash_one(&v);
+}
diff --git a/tests/ui/manual_hash_one.rs b/tests/ui/manual_hash_one.rs
new file mode 100644
index 00000000000..ee61522853f
--- /dev/null
+++ b/tests/ui/manual_hash_one.rs
@@ -0,0 +1,89 @@
+#![warn(clippy::manual_hash_one)]
+#![allow(clippy::needless_borrows_for_generic_args)]
+
+use std::hash::{BuildHasher, Hash, Hasher};
+
+fn returned(b: impl BuildHasher) -> u64 {
+    let mut hasher = b.build_hasher();
+    true.hash(&mut hasher);
+    hasher.finish()
+}
+
+fn unsized_receiver(b: impl BuildHasher, s: &str) {
+    let mut hasher = b.build_hasher();
+    s[4..10].hash(&mut hasher);
+    let _ = hasher.finish();
+}
+
+fn owned_value(b: impl BuildHasher, v: Vec<u32>) -> Vec<u32> {
+    let mut hasher = b.build_hasher();
+    v.hash(&mut hasher);
+    let _ = hasher.finish();
+    v
+}
+
+fn reused_hasher(b: impl BuildHasher) {
+    let mut hasher = b.build_hasher();
+    true.hash(&mut hasher);
+    let _ = hasher.finish();
+    let _ = hasher.finish();
+}
+
+fn reused_hasher_in_return(b: impl BuildHasher) -> u64 {
+    let mut hasher = b.build_hasher();
+    true.hash(&mut hasher);
+    let _ = hasher.finish();
+    hasher.finish()
+}
+
+fn no_hash(b: impl BuildHasher) {
+    let mut hasher = b.build_hasher();
+    let _ = hasher.finish();
+}
+
+fn hash_twice(b: impl BuildHasher) {
+    let mut hasher = b.build_hasher();
+    true.hash(&mut hasher);
+    true.hash(&mut hasher);
+    let _ = hasher.finish();
+}
+
+fn other_hasher(b: impl BuildHasher) {
+    let mut other_hasher = b.build_hasher();
+
+    let mut hasher = b.build_hasher();
+    true.hash(&mut other_hasher);
+    let _ = hasher.finish();
+}
+
+fn finish_then_hash(b: impl BuildHasher) {
+    let mut hasher = b.build_hasher();
+    let _ = hasher.finish();
+    true.hash(&mut hasher);
+}
+
+fn in_macro(b: impl BuildHasher) {
+    macro_rules! m {
+        ($b:expr) => {{
+            let mut hasher = $b.build_hasher();
+            true.hash(&mut hasher);
+            let _ = hasher.finish();
+        }};
+    }
+
+    m!(b);
+}
+
+#[clippy::msrv = "1.70"]
+fn msrv_1_70(b: impl BuildHasher, v: impl Hash) {
+    let mut hasher = b.build_hasher();
+    v.hash(&mut hasher);
+    let _ = hasher.finish();
+}
+
+#[clippy::msrv = "1.71"]
+fn msrv_1_71(b: impl BuildHasher, v: impl Hash) {
+    let mut hasher = b.build_hasher();
+    v.hash(&mut hasher);
+    let _ = hasher.finish();
+}
diff --git a/tests/ui/manual_hash_one.stderr b/tests/ui/manual_hash_one.stderr
new file mode 100644
index 00000000000..3ce6f41e1f9
--- /dev/null
+++ b/tests/ui/manual_hash_one.stderr
@@ -0,0 +1,56 @@
+error: manual implementation of `BuildHasher::hash_one`
+  --> $DIR/manual_hash_one.rs:9:5
+   |
+LL |     hasher.finish()
+   |     ^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::manual-hash-one` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::manual_hash_one)]`
+help: try
+   |
+LL ~     
+LL ~     
+LL ~     b.hash_one(&true)
+   |
+
+error: manual implementation of `BuildHasher::hash_one`
+  --> $DIR/manual_hash_one.rs:15:13
+   |
+LL |     let _ = hasher.finish();
+   |             ^^^^^^^^^^^^^^^
+   |
+help: try
+   |
+LL ~     
+LL ~     
+LL ~     let _ = b.hash_one(&s[4..10]);
+   |
+
+error: manual implementation of `BuildHasher::hash_one`
+  --> $DIR/manual_hash_one.rs:21:13
+   |
+LL |     let _ = hasher.finish();
+   |             ^^^^^^^^^^^^^^^
+   |
+help: try
+   |
+LL ~     
+LL ~     
+LL ~     let _ = b.hash_one(&v);
+   |
+
+error: manual implementation of `BuildHasher::hash_one`
+  --> $DIR/manual_hash_one.rs:88:13
+   |
+LL |     let _ = hasher.finish();
+   |             ^^^^^^^^^^^^^^^
+   |
+help: try
+   |
+LL ~     
+LL ~     
+LL ~     let _ = b.hash_one(&v);
+   |
+
+error: aborting due to 4 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 62b8ef304adf92e2f5d3d8f172fa1e4661183692 Mon Sep 17 00:00:00 2001
From: unexge <unexge@gmail.com>
Date: Wed, 27 Sep 2023 22:06:01 +0100
Subject: Mention that `missing_assert_message` lint ignores test functions

---
 clippy_lints/src/missing_assert_message.rs | 4 ++++
 1 file changed, 4 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/missing_assert_message.rs b/clippy_lints/src/missing_assert_message.rs
index c17f00c4275..136947a2c8c 100644
--- a/clippy_lints/src/missing_assert_message.rs
+++ b/clippy_lints/src/missing_assert_message.rs
@@ -15,6 +15,10 @@ declare_clippy_lint! {
     /// A good custom message should be more about why the failure of the assertion is problematic
     /// and not what is failed because the assertion already conveys that.
     ///
+    /// Although the same reasoning applies to testing functions, this lint ignores them as they would be too noisy.
+    /// Also, in most cases understanding the test failure would be easier
+    /// compared to understanding a complex invariant distributed around the codebase.
+    ///
     /// ### Known problems
     /// This lint cannot check the quality of the custom panic messages.
     /// Hence, you can suppress this lint simply by adding placeholder messages
-- 
cgit 1.4.1-3-g733a5


From b413bf6c4ee671df153b930dc2ba5b159c652c1d Mon Sep 17 00:00:00 2001
From: koka <koka.code@gmail.com>
Date: Thu, 28 Sep 2023 17:12:00 +0900
Subject: Fix index of the remaining positional arguments

---
 clippy_lints/src/write.rs       | 94 +++++++++++++++++++++++++++++------------
 tests/ui/print_literal.fixed    |  4 --
 tests/ui/print_literal.rs       |  4 --
 tests/ui/print_literal.stderr   | 72 ++++++-------------------------
 tests/ui/write_literal.fixed    | 14 ++++--
 tests/ui/write_literal.rs       | 14 ++++--
 tests/ui/write_literal.stderr   | 74 ++++++++++++++++----------------
 tests/ui/write_literal_2.rs     |  6 +--
 tests/ui/write_literal_2.stderr | 53 +++++------------------
 9 files changed, 147 insertions(+), 188 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs
index da083fb14aa..21b675ff679 100644
--- a/clippy_lints/src/write.rs
+++ b/clippy_lints/src/write.rs
@@ -3,12 +3,15 @@ use clippy_utils::macros::{find_format_args, format_arg_removal_span, root_macro
 use clippy_utils::source::{expand_past_previous_comma, snippet_opt};
 use clippy_utils::{is_in_cfg_test, is_in_test_function};
 use rustc_ast::token::LitKind;
-use rustc_ast::{FormatArgPosition, FormatArgs, FormatArgsPiece, FormatOptions, FormatPlaceholder, FormatTrait};
+use rustc_ast::{
+    FormatArgPosition, FormatArgPositionKind, FormatArgs, FormatArgsPiece, FormatOptions, FormatPlaceholder,
+    FormatTrait,
+};
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, Impl, Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::{sym, BytePos};
+use rustc_span::{sym, BytePos, Span};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -450,6 +453,12 @@ fn check_empty_string(cx: &LateContext<'_>, format_args: &FormatArgs, macro_call
 fn check_literal(cx: &LateContext<'_>, format_args: &FormatArgs, name: &str) {
     let arg_index = |argument: &FormatArgPosition| argument.index.unwrap_or_else(|pos| pos);
 
+    let lint_name = if name.starts_with("write") {
+        WRITE_LITERAL
+    } else {
+        PRINT_LITERAL
+    };
+
     let mut counts = vec![0u32; format_args.arguments.all_args().len()];
     for piece in &format_args.template {
         if let FormatArgsPiece::Placeholder(placeholder) = piece {
@@ -457,6 +466,12 @@ fn check_literal(cx: &LateContext<'_>, format_args: &FormatArgs, name: &str) {
         }
     }
 
+    let mut suggestion: Vec<(Span, String)> = vec![];
+    // holds index of replaced positional arguments; used to decrement the index of the remaining
+    // positional arguments.
+    let mut replaced_position: Vec<usize> = vec![];
+    let mut sug_span: Option<Span> = None;
+
     for piece in &format_args.template {
         if let FormatArgsPiece::Placeholder(FormatPlaceholder {
             argument,
@@ -493,12 +508,6 @@ fn check_literal(cx: &LateContext<'_>, format_args: &FormatArgs, name: &str) {
                 _ => continue,
             };
 
-            let lint = if name.starts_with("write") {
-                WRITE_LITERAL
-            } else {
-                PRINT_LITERAL
-            };
-
             let Some(format_string_snippet) = snippet_opt(cx, format_args.span) else { continue };
             let format_string_is_raw = format_string_snippet.starts_with('r');
 
@@ -519,29 +528,58 @@ fn check_literal(cx: &LateContext<'_>, format_args: &FormatArgs, name: &str) {
                 },
             };
 
-            span_lint_and_then(
-                cx,
-                lint,
-                arg.expr.span,
-                "literal with an empty format string",
-                |diag| {
-                    if let Some(replacement) = replacement
-                        // `format!("{}", "a")`, `format!("{named}", named = "b")
-                        //              ~~~~~                      ~~~~~~~~~~~~~
-                        && let Some(removal_span) = format_arg_removal_span(format_args, index)
-                    {
-                        let replacement = replacement.replace('{', "{{").replace('}', "}}");
-                        diag.multipart_suggestion(
-                            "try",
-                            vec![(*placeholder_span, replacement), (removal_span, String::new())],
-                            Applicability::MachineApplicable,
-                        );
-                    }
-                },
-            );
+            sug_span = Some(sug_span.unwrap_or(arg.expr.span).to(arg.expr.span));
 
+            if let Some((_, index)) = positional_arg_piece_span(piece) {
+                replaced_position.push(index);
+            }
+
+            if let Some(replacement) = replacement
+                // `format!("{}", "a")`, `format!("{named}", named = "b")
+                //              ~~~~~                      ~~~~~~~~~~~~~
+                && let Some(removal_span) = format_arg_removal_span(format_args, index) {
+                let replacement = replacement.replace('{', "{{").replace('}', "}}");
+                suggestion.push((*placeholder_span, replacement));
+                suggestion.push((removal_span, String::new()));
+            }
         }
     }
+
+    // Decrement the index of the remaining by the number of replaced positional arguments
+    if !suggestion.is_empty() {
+        for piece in &format_args.template {
+            if let Some((span, index)) = positional_arg_piece_span(piece)
+                && suggestion.iter().all(|(s, _)| *s != span) {
+                let decrement = replaced_position.iter().filter(|i| **i < index).count();
+                suggestion.push((span, format!("{{{}}}", index.saturating_sub(decrement))));
+            }
+        }
+    }
+
+    if let Some(span) = sug_span {
+        span_lint_and_then(cx, lint_name, span, "literal with an empty format string", |diag| {
+            if !suggestion.is_empty() {
+                diag.multipart_suggestion("try", suggestion, Applicability::MachineApplicable);
+            }
+        });
+    }
+}
+
+/// Extract Span and its index from the given `piece`, iff it's positional argument.
+fn positional_arg_piece_span(piece: &FormatArgsPiece) -> Option<(Span, usize)> {
+    match piece {
+        FormatArgsPiece::Placeholder(FormatPlaceholder {
+            argument:
+                FormatArgPosition {
+                    index: Ok(index),
+                    kind: FormatArgPositionKind::Number,
+                    ..
+                },
+            span: Some(span),
+            ..
+        }) => Some((*span, *index)),
+        _ => None,
+    }
 }
 
 /// Removes the raw marker, `#`s and quotes from a str, and returns if the literal is raw
diff --git a/tests/ui/print_literal.fixed b/tests/ui/print_literal.fixed
index 88cd3a54b41..04a484258a4 100644
--- a/tests/ui/print_literal.fixed
+++ b/tests/ui/print_literal.fixed
@@ -39,18 +39,14 @@ fn main() {
     // throw a warning
     println!("hello world");
     //~^ ERROR: literal with an empty format string
-    //~| ERROR: literal with an empty format string
     println!("world hello");
     //~^ ERROR: literal with an empty format string
-    //~| ERROR: literal with an empty format string
 
     // named args shouldn't change anything either
     println!("hello world");
     //~^ ERROR: literal with an empty format string
-    //~| ERROR: literal with an empty format string
     println!("world hello");
     //~^ ERROR: literal with an empty format string
-    //~| ERROR: literal with an empty format string
 
     // The string literal from `file!()` has a callsite span that isn't marked as coming from an
     // expansion
diff --git a/tests/ui/print_literal.rs b/tests/ui/print_literal.rs
index bd7444c9606..38c036f56c5 100644
--- a/tests/ui/print_literal.rs
+++ b/tests/ui/print_literal.rs
@@ -39,18 +39,14 @@ fn main() {
     // throw a warning
     println!("{0} {1}", "hello", "world");
     //~^ ERROR: literal with an empty format string
-    //~| ERROR: literal with an empty format string
     println!("{1} {0}", "hello", "world");
     //~^ ERROR: literal with an empty format string
-    //~| ERROR: literal with an empty format string
 
     // named args shouldn't change anything either
     println!("{foo} {bar}", foo = "hello", bar = "world");
     //~^ ERROR: literal with an empty format string
-    //~| ERROR: literal with an empty format string
     println!("{bar} {foo}", foo = "hello", bar = "world");
     //~^ ERROR: literal with an empty format string
-    //~| ERROR: literal with an empty format string
 
     // The string literal from `file!()` has a callsite span that isn't marked as coming from an
     // expansion
diff --git a/tests/ui/print_literal.stderr b/tests/ui/print_literal.stderr
index 1d9751b92e9..b2f85be9d94 100644
--- a/tests/ui/print_literal.stderr
+++ b/tests/ui/print_literal.stderr
@@ -52,97 +52,49 @@ error: literal with an empty format string
   --> $DIR/print_literal.rs:40:25
    |
 LL |     println!("{0} {1}", "hello", "world");
-   |                         ^^^^^^^
+   |                         ^^^^^^^^^^^^^^^^
    |
 help: try
    |
 LL -     println!("{0} {1}", "hello", "world");
-LL +     println!("hello {1}", "world");
+LL +     println!("hello world");
    |
 
 error: literal with an empty format string
-  --> $DIR/print_literal.rs:40:34
-   |
-LL |     println!("{0} {1}", "hello", "world");
-   |                                  ^^^^^^^
-   |
-help: try
-   |
-LL -     println!("{0} {1}", "hello", "world");
-LL +     println!("{0} world", "hello");
-   |
-
-error: literal with an empty format string
-  --> $DIR/print_literal.rs:43:34
+  --> $DIR/print_literal.rs:42:25
    |
 LL |     println!("{1} {0}", "hello", "world");
-   |                                  ^^^^^^^
+   |                         ^^^^^^^^^^^^^^^^
    |
 help: try
    |
 LL -     println!("{1} {0}", "hello", "world");
-LL +     println!("world {0}", "hello");
-   |
-
-error: literal with an empty format string
-  --> $DIR/print_literal.rs:43:25
-   |
-LL |     println!("{1} {0}", "hello", "world");
-   |                         ^^^^^^^
-   |
-help: try
-   |
-LL -     println!("{1} {0}", "hello", "world");
-LL +     println!("{1} hello", "world");
-   |
-
-error: literal with an empty format string
-  --> $DIR/print_literal.rs:48:35
-   |
-LL |     println!("{foo} {bar}", foo = "hello", bar = "world");
-   |                                   ^^^^^^^
-   |
-help: try
-   |
-LL -     println!("{foo} {bar}", foo = "hello", bar = "world");
-LL +     println!("hello {bar}", bar = "world");
+LL +     println!("world hello");
    |
 
 error: literal with an empty format string
-  --> $DIR/print_literal.rs:48:50
+  --> $DIR/print_literal.rs:46:35
    |
 LL |     println!("{foo} {bar}", foo = "hello", bar = "world");
-   |                                                  ^^^^^^^
+   |                                   ^^^^^^^^^^^^^^^^^^^^^^
    |
 help: try
    |
 LL -     println!("{foo} {bar}", foo = "hello", bar = "world");
-LL +     println!("{foo} world", foo = "hello");
+LL +     println!("hello world");
    |
 
 error: literal with an empty format string
-  --> $DIR/print_literal.rs:51:50
-   |
-LL |     println!("{bar} {foo}", foo = "hello", bar = "world");
-   |                                                  ^^^^^^^
-   |
-help: try
-   |
-LL -     println!("{bar} {foo}", foo = "hello", bar = "world");
-LL +     println!("world {foo}", foo = "hello");
-   |
-
-error: literal with an empty format string
-  --> $DIR/print_literal.rs:51:35
+  --> $DIR/print_literal.rs:48:35
    |
 LL |     println!("{bar} {foo}", foo = "hello", bar = "world");
-   |                                   ^^^^^^^
+   |                                   ^^^^^^^^^^^^^^^^^^^^^^
    |
 help: try
    |
 LL -     println!("{bar} {foo}", foo = "hello", bar = "world");
-LL +     println!("{bar} hello", bar = "world");
+LL +     println!("world hello");
    |
 
-error: aborting due to 12 previous errors
+error: aborting due to 8 previous errors
 
diff --git a/tests/ui/write_literal.fixed b/tests/ui/write_literal.fixed
index ee577574d28..3d216b76cbf 100644
--- a/tests/ui/write_literal.fixed
+++ b/tests/ui/write_literal.fixed
@@ -43,16 +43,22 @@ fn main() {
     // throw a warning
     writeln!(v, "hello world");
     //~^ ERROR: literal with an empty format string
-    //~| ERROR: literal with an empty format string
     writeln!(v, "world hello");
     //~^ ERROR: literal with an empty format string
-    //~| ERROR: literal with an empty format string
 
     // named args shouldn't change anything either
     writeln!(v, "hello world");
     //~^ ERROR: literal with an empty format string
-    //~| ERROR: literal with an empty format string
     writeln!(v, "world hello");
     //~^ ERROR: literal with an empty format string
-    //~| ERROR: literal with an empty format string
+
+    // #10128
+    writeln!(v, "hello {0} world", 2);
+    //~^ ERROR: literal with an empty format string
+    writeln!(v, "world {0} hello", 2);
+    //~^ ERROR: literal with an empty format string
+    writeln!(v, "hello {0} {1}, {bar}", 2, 3, bar = 4);
+    //~^ ERROR: literal with an empty format string
+    writeln!(v, "hello {0} {1}, world {2}", 2, 3, 4);
+    //~^ ERROR: literal with an empty format string
 }
diff --git a/tests/ui/write_literal.rs b/tests/ui/write_literal.rs
index 588e8fd413a..79d6daa2e3b 100644
--- a/tests/ui/write_literal.rs
+++ b/tests/ui/write_literal.rs
@@ -43,16 +43,22 @@ fn main() {
     // throw a warning
     writeln!(v, "{0} {1}", "hello", "world");
     //~^ ERROR: literal with an empty format string
-    //~| ERROR: literal with an empty format string
     writeln!(v, "{1} {0}", "hello", "world");
     //~^ ERROR: literal with an empty format string
-    //~| ERROR: literal with an empty format string
 
     // named args shouldn't change anything either
     writeln!(v, "{foo} {bar}", foo = "hello", bar = "world");
     //~^ ERROR: literal with an empty format string
-    //~| ERROR: literal with an empty format string
     writeln!(v, "{bar} {foo}", foo = "hello", bar = "world");
     //~^ ERROR: literal with an empty format string
-    //~| ERROR: literal with an empty format string
+
+    // #10128
+    writeln!(v, "{0} {1} {2}", "hello", 2, "world");
+    //~^ ERROR: literal with an empty format string
+    writeln!(v, "{2} {1} {0}", "hello", 2, "world");
+    //~^ ERROR: literal with an empty format string
+    writeln!(v, "{0} {1} {2}, {bar}", "hello", 2, 3, bar = 4);
+    //~^ ERROR: literal with an empty format string
+    writeln!(v, "{0} {1} {2}, {3} {4}", "hello", 2, 3, "world", 4);
+    //~^ ERROR: literal with an empty format string
 }
diff --git a/tests/ui/write_literal.stderr b/tests/ui/write_literal.stderr
index 372a54cf769..ee0d536e954 100644
--- a/tests/ui/write_literal.stderr
+++ b/tests/ui/write_literal.stderr
@@ -52,96 +52,96 @@ error: literal with an empty format string
   --> $DIR/write_literal.rs:44:28
    |
 LL |     writeln!(v, "{0} {1}", "hello", "world");
-   |                            ^^^^^^^
+   |                            ^^^^^^^^^^^^^^^^
    |
 help: try
    |
 LL -     writeln!(v, "{0} {1}", "hello", "world");
-LL +     writeln!(v, "hello {1}", "world");
+LL +     writeln!(v, "hello world");
    |
 
 error: literal with an empty format string
-  --> $DIR/write_literal.rs:44:37
+  --> $DIR/write_literal.rs:46:28
    |
-LL |     writeln!(v, "{0} {1}", "hello", "world");
-   |                                     ^^^^^^^
+LL |     writeln!(v, "{1} {0}", "hello", "world");
+   |                            ^^^^^^^^^^^^^^^^
    |
 help: try
    |
-LL -     writeln!(v, "{0} {1}", "hello", "world");
-LL +     writeln!(v, "{0} world", "hello");
+LL -     writeln!(v, "{1} {0}", "hello", "world");
+LL +     writeln!(v, "world hello");
    |
 
 error: literal with an empty format string
-  --> $DIR/write_literal.rs:47:37
+  --> $DIR/write_literal.rs:50:38
    |
-LL |     writeln!(v, "{1} {0}", "hello", "world");
-   |                                     ^^^^^^^
+LL |     writeln!(v, "{foo} {bar}", foo = "hello", bar = "world");
+   |                                      ^^^^^^^^^^^^^^^^^^^^^^
    |
 help: try
    |
-LL -     writeln!(v, "{1} {0}", "hello", "world");
-LL +     writeln!(v, "world {0}", "hello");
+LL -     writeln!(v, "{foo} {bar}", foo = "hello", bar = "world");
+LL +     writeln!(v, "hello world");
    |
 
 error: literal with an empty format string
-  --> $DIR/write_literal.rs:47:28
+  --> $DIR/write_literal.rs:52:38
    |
-LL |     writeln!(v, "{1} {0}", "hello", "world");
-   |                            ^^^^^^^
+LL |     writeln!(v, "{bar} {foo}", foo = "hello", bar = "world");
+   |                                      ^^^^^^^^^^^^^^^^^^^^^^
    |
 help: try
    |
-LL -     writeln!(v, "{1} {0}", "hello", "world");
-LL +     writeln!(v, "{1} hello", "world");
+LL -     writeln!(v, "{bar} {foo}", foo = "hello", bar = "world");
+LL +     writeln!(v, "world hello");
    |
 
 error: literal with an empty format string
-  --> $DIR/write_literal.rs:52:38
+  --> $DIR/write_literal.rs:56:32
    |
-LL |     writeln!(v, "{foo} {bar}", foo = "hello", bar = "world");
-   |                                      ^^^^^^^
+LL |     writeln!(v, "{0} {1} {2}", "hello", 2, "world");
+   |                                ^^^^^^^^^^^^^^^^^^^
    |
 help: try
    |
-LL -     writeln!(v, "{foo} {bar}", foo = "hello", bar = "world");
-LL +     writeln!(v, "hello {bar}", bar = "world");
+LL -     writeln!(v, "{0} {1} {2}", "hello", 2, "world");
+LL +     writeln!(v, "hello {0} world", 2);
    |
 
 error: literal with an empty format string
-  --> $DIR/write_literal.rs:52:53
+  --> $DIR/write_literal.rs:58:32
    |
-LL |     writeln!(v, "{foo} {bar}", foo = "hello", bar = "world");
-   |                                                     ^^^^^^^
+LL |     writeln!(v, "{2} {1} {0}", "hello", 2, "world");
+   |                                ^^^^^^^^^^^^^^^^^^^
    |
 help: try
    |
-LL -     writeln!(v, "{foo} {bar}", foo = "hello", bar = "world");
-LL +     writeln!(v, "{foo} world", foo = "hello");
+LL -     writeln!(v, "{2} {1} {0}", "hello", 2, "world");
+LL +     writeln!(v, "world {0} hello", 2);
    |
 
 error: literal with an empty format string
-  --> $DIR/write_literal.rs:55:53
+  --> $DIR/write_literal.rs:60:39
    |
-LL |     writeln!(v, "{bar} {foo}", foo = "hello", bar = "world");
-   |                                                     ^^^^^^^
+LL |     writeln!(v, "{0} {1} {2}, {bar}", "hello", 2, 3, bar = 4);
+   |                                       ^^^^^^^
    |
 help: try
    |
-LL -     writeln!(v, "{bar} {foo}", foo = "hello", bar = "world");
-LL +     writeln!(v, "world {foo}", foo = "hello");
+LL -     writeln!(v, "{0} {1} {2}, {bar}", "hello", 2, 3, bar = 4);
+LL +     writeln!(v, "hello {0} {1}, {bar}", 2, 3, bar = 4);
    |
 
 error: literal with an empty format string
-  --> $DIR/write_literal.rs:55:38
+  --> $DIR/write_literal.rs:62:41
    |
-LL |     writeln!(v, "{bar} {foo}", foo = "hello", bar = "world");
-   |                                      ^^^^^^^
+LL |     writeln!(v, "{0} {1} {2}, {3} {4}", "hello", 2, 3, "world", 4);
+   |                                         ^^^^^^^^^^^^^^^^^^^^^^
    |
 help: try
    |
-LL -     writeln!(v, "{bar} {foo}", foo = "hello", bar = "world");
-LL +     writeln!(v, "{bar} hello", bar = "world");
+LL -     writeln!(v, "{0} {1} {2}, {3} {4}", "hello", 2, 3, "world", 4);
+LL +     writeln!(v, "hello {0} {1}, world {2}", 2, 3, 4);
    |
 
 error: aborting due to 12 previous errors
diff --git a/tests/ui/write_literal_2.rs b/tests/ui/write_literal_2.rs
index 197e01149e0..b2ed552d46b 100644
--- a/tests/ui/write_literal_2.rs
+++ b/tests/ui/write_literal_2.rs
@@ -31,10 +31,7 @@ fn main() {
         v,
         "some {}\
         {} \\ {}",
-        "1",
-        "2",
-        "3",
-        //~^ ERROR: literal with an empty format string
+        "1", "2", "3",
     );
     writeln!(v, "{}", "\\");
     //~^ ERROR: literal with an empty format string
@@ -49,7 +46,6 @@ fn main() {
     // hard mode
     writeln!(v, r#"{}{}"#, '#', '"');
     //~^ ERROR: literal with an empty format string
-    //~| ERROR: literal with an empty format string
     // should not lint
     writeln!(v, r"{}", "\r");
 }
diff --git a/tests/ui/write_literal_2.stderr b/tests/ui/write_literal_2.stderr
index 9a16d2f240d..81ef49de082 100644
--- a/tests/ui/write_literal_2.stderr
+++ b/tests/ui/write_literal_2.stderr
@@ -82,42 +82,17 @@ LL ~         world!",
 error: literal with an empty format string
   --> $DIR/write_literal_2.rs:34:9
    |
-LL |         "1",
-   |         ^^^
+LL |         "1", "2", "3",
+   |         ^^^^^^^^^^^^^
    |
 help: try
    |
 LL ~         "some 1\
-LL ~         {} \\ {}",
+LL ~         2 \\ 3",
    |
 
 error: literal with an empty format string
-  --> $DIR/write_literal_2.rs:35:9
-   |
-LL |         "2",
-   |         ^^^
-   |
-help: try
-   |
-LL ~         2 \\ {}",
-LL ~         "1",
-   |
-
-error: literal with an empty format string
-  --> $DIR/write_literal_2.rs:36:9
-   |
-LL |         "3",
-   |         ^^^
-   |
-help: try
-   |
-LL ~         {} \\ 3",
-LL |         "1",
-LL ~         "2",
-   |
-
-error: literal with an empty format string
-  --> $DIR/write_literal_2.rs:39:23
+  --> $DIR/write_literal_2.rs:36:23
    |
 LL |     writeln!(v, "{}", "\\");
    |                       ^^^^
@@ -129,7 +104,7 @@ LL +     writeln!(v, "\\");
    |
 
 error: literal with an empty format string
-  --> $DIR/write_literal_2.rs:41:24
+  --> $DIR/write_literal_2.rs:38:24
    |
 LL |     writeln!(v, r"{}", "\\");
    |                        ^^^^
@@ -141,7 +116,7 @@ LL +     writeln!(v, r"\");
    |
 
 error: literal with an empty format string
-  --> $DIR/write_literal_2.rs:43:26
+  --> $DIR/write_literal_2.rs:40:26
    |
 LL |     writeln!(v, r#"{}"#, "\\");
    |                          ^^^^
@@ -153,7 +128,7 @@ LL +     writeln!(v, r#"\"#);
    |
 
 error: literal with an empty format string
-  --> $DIR/write_literal_2.rs:45:23
+  --> $DIR/write_literal_2.rs:42:23
    |
 LL |     writeln!(v, "{}", r"\");
    |                       ^^^^
@@ -165,7 +140,7 @@ LL +     writeln!(v, "\\");
    |
 
 error: literal with an empty format string
-  --> $DIR/write_literal_2.rs:47:23
+  --> $DIR/write_literal_2.rs:44:23
    |
 LL |     writeln!(v, "{}", "\r");
    |                       ^^^^
@@ -177,16 +152,10 @@ LL +     writeln!(v, "\r");
    |
 
 error: literal with an empty format string
-  --> $DIR/write_literal_2.rs:50:28
-   |
-LL |     writeln!(v, r#"{}{}"#, '#', '"');
-   |                            ^^^
-
-error: literal with an empty format string
-  --> $DIR/write_literal_2.rs:50:33
+  --> $DIR/write_literal_2.rs:47:28
    |
 LL |     writeln!(v, r#"{}{}"#, '#', '"');
-   |                                 ^^^
+   |                            ^^^^^^^^
 
-error: aborting due to 17 previous errors
+error: aborting due to 14 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 330ebbb9f9ee3c4bab37e330726ccc3ac1c26e4a Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Mon, 18 Sep 2023 00:19:34 +0200
Subject: new lint: `iter_without_into_iter`

---
 CHANGELOG.md                               |   1 +
 clippy_lints/src/declared_lints.rs         |   1 +
 clippy_lints/src/iter_without_into_iter.rs | 135 ++++++++++++++++++++++++++
 clippy_lints/src/lib.rs                    |   2 +
 tests/ui/iter_without_into_iter.rs         | 120 +++++++++++++++++++++++
 tests/ui/iter_without_into_iter.stderr     | 150 +++++++++++++++++++++++++++++
 6 files changed, 409 insertions(+)
 create mode 100644 clippy_lints/src/iter_without_into_iter.rs
 create mode 100644 tests/ui/iter_without_into_iter.rs
 create mode 100644 tests/ui/iter_without_into_iter.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index db54bfbf0b3..40510d78800 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5036,6 +5036,7 @@ Released 2018-09-13
 [`iter_skip_next`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_skip_next
 [`iter_skip_zero`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_skip_zero
 [`iter_with_drain`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_with_drain
+[`iter_without_into_iter`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_without_into_iter
 [`iterator_step_by_zero`]: https://rust-lang.github.io/rust-clippy/master/index.html#iterator_step_by_zero
 [`just_underscores_and_digits`]: https://rust-lang.github.io/rust-clippy/master/index.html#just_underscores_and_digits
 [`large_const_arrays`]: https://rust-lang.github.io/rust-clippy/master/index.html#large_const_arrays
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index b4b84b36044..06809038927 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -229,6 +229,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::items_after_statements::ITEMS_AFTER_STATEMENTS_INFO,
     crate::items_after_test_module::ITEMS_AFTER_TEST_MODULE_INFO,
     crate::iter_not_returning_iterator::ITER_NOT_RETURNING_ITERATOR_INFO,
+    crate::iter_without_into_iter::ITER_WITHOUT_INTO_ITER_INFO,
     crate::large_const_arrays::LARGE_CONST_ARRAYS_INFO,
     crate::large_enum_variant::LARGE_ENUM_VARIANT_INFO,
     crate::large_futures::LARGE_FUTURES_INFO,
diff --git a/clippy_lints/src/iter_without_into_iter.rs b/clippy_lints/src/iter_without_into_iter.rs
new file mode 100644
index 00000000000..08a8e6dbf18
--- /dev/null
+++ b/clippy_lints/src/iter_without_into_iter.rs
@@ -0,0 +1,135 @@
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::get_parent_as_impl;
+use clippy_utils::source::snippet;
+use clippy_utils::ty::{implements_trait, make_normalized_projection};
+use rustc_errors::Applicability;
+use rustc_hir::{FnRetTy, ImplItemKind, ImplicitSelfKind, TyKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::sym;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Looks for `iter` and `iter_mut` methods without an associated `IntoIterator for (&|&mut) Type` implementation.
+    ///
+    /// ### Why is this bad?
+    /// It's not bad, but having them is idiomatic and allows the type to be used in for loops directly
+    /// (`for val in &iter {}`), without having to first call `iter()` or `iter_mut()`.
+    ///
+    /// ### Example
+    /// ```rust
+    /// struct MySlice<'a>(&'a [u8]);
+    /// impl<'a> MySlice<'a> {
+    ///     pub fn iter(&self) -> std::slice::Iter<'a, u8> {
+    ///         self.0.iter()
+    ///     }
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// struct MySlice<'a>(&'a [u8]);
+    /// impl<'a> MySlice<'a> {
+    ///     pub fn iter(&self) -> std::slice::Iter<'a, u8> {
+    ///         self.0.iter()
+    ///     }
+    /// }
+    /// impl<'a> IntoIterator for &MySlice<'a> {
+    ///     type Item = &'a u8;
+    ///     type IntoIter = std::slice::Iter<'a, u8>;
+    ///     fn into_iter(self) -> Self::IntoIter {
+    ///         self.iter()
+    ///     }
+    /// }
+    /// ```
+    #[clippy::version = "1.74.0"]
+    pub ITER_WITHOUT_INTO_ITER,
+    pedantic,
+    "implementing `iter(_mut)` without an associated `IntoIterator for (&|&mut) Type` impl"
+}
+declare_lint_pass!(IterWithoutIntoIter => [ITER_WITHOUT_INTO_ITER]);
+
+/// Checks if a given type is nameable in a trait (impl).
+/// RPIT is stable, but impl Trait in traits is not (yet), so when we have
+/// a function such as `fn iter(&self) -> impl IntoIterator`, we can't
+/// suggest `type IntoIter = impl IntoIterator`.
+fn is_nameable_in_impl_trait(ty: &rustc_hir::Ty<'_>) -> bool {
+    !matches!(ty.kind, TyKind::OpaqueDef(..))
+}
+
+impl LateLintPass<'_> for IterWithoutIntoIter {
+    fn check_impl_item(&mut self, cx: &LateContext<'_>, item: &rustc_hir::ImplItem<'_>) {
+        let item_did = item.owner_id.to_def_id();
+        let (borrow_prefix, expected_implicit_self) = match item.ident.name {
+            sym::iter => ("&", ImplicitSelfKind::ImmRef),
+            sym::iter_mut => ("&mut ", ImplicitSelfKind::MutRef),
+            _ => return,
+        };
+
+        if let ImplItemKind::Fn(sig, _) = item.kind
+            && let FnRetTy::Return(ret) = sig.decl.output
+            && is_nameable_in_impl_trait(ret)
+            && cx.tcx.generics_of(item_did).params.is_empty()
+            && sig.decl.implicit_self == expected_implicit_self
+            && sig.decl.inputs.len() == 1
+            && let Some(imp) = get_parent_as_impl(cx.tcx, item.hir_id())
+            && imp.of_trait.is_none()
+            && let sig = cx.tcx.liberate_late_bound_regions(
+                item_did,
+                cx.tcx.fn_sig(item_did).instantiate_identity()
+            )
+            && let ref_ty = sig.inputs()[0]
+            && let Some(into_iter_did) = cx.tcx.get_diagnostic_item(sym::IntoIterator)
+            && let Some(iterator_did) = cx.tcx.get_diagnostic_item(sym::Iterator)
+            && let ret_ty = sig.output()
+            // Order is important here, we need to check that the `fn iter` return type actually implements `IntoIterator`
+            // *before* normalizing `<_ as IntoIterator>::Item` (otherwise make_normalized_projection ICEs)
+            && implements_trait(cx, ret_ty, iterator_did, &[])
+            && let Some(iter_ty) = make_normalized_projection(
+                cx.tcx,
+                cx.param_env,
+                iterator_did,
+                sym!(Item),
+                [ret_ty],
+            )
+            // Only lint if the `IntoIterator` impl doesn't actually exist
+            && !implements_trait(cx, ref_ty, into_iter_did, &[])
+        {
+            let self_ty_snippet = format!("{borrow_prefix}{}", snippet(cx, imp.self_ty.span, ".."));
+
+            span_lint_and_then(
+                cx,
+                ITER_WITHOUT_INTO_ITER,
+                item.span,
+                &format!("`{}` method without an `IntoIterator` impl for `{self_ty_snippet}`", item.ident),
+                |diag| {
+                    // Get the lower span of the `impl` block, and insert the suggestion right before it:
+                    // impl X {
+                    // ^   fn iter(&self) -> impl IntoIterator { ... }
+                    // }
+                    let span_behind_impl = cx.tcx
+                        .def_span(cx.tcx.hir().parent_id(item.hir_id()).owner.def_id)
+                        .shrink_to_lo();
+
+                    let sugg = format!(
+"
+impl IntoIterator for {self_ty_snippet} {{
+    type IntoIter = {ret_ty};
+    type Iter = {iter_ty};
+    fn into_iter() -> Self::IntoIter {{
+        self.iter()
+    }}
+}}
+"
+                    );
+                    diag.span_suggestion_verbose(
+                        span_behind_impl,
+                        format!("consider implementing `IntoIterator` for `{self_ty_snippet}`"),
+                        sugg,
+                        // Suggestion is on a best effort basis, might need some adjustments by the user
+                        // such as adding some lifetimes in the associated types, or importing types.
+                        Applicability::Unspecified,
+                    );
+            });
+        }
+    }
+}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 63a3fbcb897..0f35ec27665 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -169,6 +169,7 @@ mod invalid_upcast_comparisons;
 mod items_after_statements;
 mod items_after_test_module;
 mod iter_not_returning_iterator;
+mod iter_without_into_iter;
 mod large_const_arrays;
 mod large_enum_variant;
 mod large_futures;
@@ -1121,6 +1122,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         ))
     });
     store.register_late_pass(move |_| Box::new(manual_hash_one::ManualHashOne::new(msrv())));
+    store.register_late_pass(|_| Box::new(iter_without_into_iter::IterWithoutIntoIter));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/tests/ui/iter_without_into_iter.rs b/tests/ui/iter_without_into_iter.rs
new file mode 100644
index 00000000000..cedb756c79d
--- /dev/null
+++ b/tests/ui/iter_without_into_iter.rs
@@ -0,0 +1,120 @@
+//@no-rustfix
+#![warn(clippy::iter_without_into_iter)]
+
+fn main() {
+    {
+        struct S;
+        impl S {
+            pub fn iter(&self) -> std::slice::Iter<'_, u8> {
+                //~^ ERROR: `iter` method without an `IntoIterator` impl
+                [].iter()
+            }
+            pub fn iter_mut(&mut self) -> std::slice::IterMut<'_, u8> {
+                //~^ ERROR: `iter_mut` method without an `IntoIterator` impl
+                [].iter_mut()
+            }
+        }
+    }
+    {
+        struct S;
+        impl S {
+            pub fn iter(&self) -> impl Iterator<Item = &u8> {
+                // RPITIT is not stable, so we can't generally suggest it here yet
+                [].iter()
+            }
+        }
+    }
+    {
+        struct S<'a>(&'a mut [u8]);
+        impl<'a> S<'a> {
+            pub fn iter(&self) -> std::slice::Iter<'_, u8> {
+                //~^ ERROR: `iter` method without an `IntoIterator` impl
+                self.0.iter()
+            }
+            pub fn iter_mut(&mut self) -> std::slice::IterMut<'_, u8> {
+                //~^ ERROR: `iter_mut` method without an `IntoIterator` impl
+                self.0.iter_mut()
+            }
+        }
+    }
+    {
+        // Incompatible signatures
+        struct S;
+        impl S {
+            pub fn iter(self) -> std::slice::Iter<'static, u8> {
+                todo!()
+            }
+        }
+        struct S2;
+        impl S2 {
+            pub async fn iter(&self) -> std::slice::Iter<'static, u8> {
+                todo!()
+            }
+        }
+        struct S3;
+        impl S3 {
+            pub fn iter(&self, _additional_param: ()) -> std::slice::Iter<'static, u8> {
+                todo!()
+            }
+        }
+        struct S4<T>(T);
+        impl<T> S4<T> {
+            pub fn iter<U>(&self) -> std::slice::Iter<'static, (T, U)> {
+                todo!()
+            }
+        }
+        struct S5<T>(T);
+        impl<T> S5<T> {
+            pub fn iter(&self) -> std::slice::Iter<'static, T> {
+                todo!()
+            }
+        }
+    }
+    {
+        struct S<T>(T);
+        impl<T> S<T> {
+            pub fn iter(&self) -> std::slice::Iter<'_, T> {
+                //~^ ERROR: `iter` method without an `IntoIterator` impl
+                todo!()
+            }
+            pub fn iter_mut(&mut self) -> std::slice::IterMut<'_, T> {
+                //~^ ERROR: `iter_mut` method without an `IntoIterator` impl
+                todo!()
+            }
+        }
+    }
+    {
+        struct S<T>(T);
+        impl<T> S<T> {
+            pub fn iter(&self) -> std::slice::Iter<'_, T> {
+                // Don't lint, there's an existing (wrong) IntoIterator impl
+                todo!()
+            }
+        }
+
+        impl<'a, T> IntoIterator for &'a S<T> {
+            type Item = &'a String;
+            type IntoIter = std::slice::Iter<'a, String>;
+            fn into_iter(self) -> Self::IntoIter {
+                todo!()
+            }
+        }
+    }
+    {
+        struct S<T>(T);
+        impl<T> S<T> {
+            pub fn iter_mut(&self) -> std::slice::IterMut<'_, T> {
+                // Don't lint, there's an existing (wrong) IntoIterator impl
+                todo!()
+            }
+        }
+
+        impl<'a, T> IntoIterator for &'a mut S<T> {
+            type Item = &'a mut String;
+            type IntoIter = std::slice::IterMut<'a, String>;
+            fn into_iter(self) -> Self::IntoIter {
+                todo!()
+            }
+        }
+    }
+}
diff --git a/tests/ui/iter_without_into_iter.stderr b/tests/ui/iter_without_into_iter.stderr
new file mode 100644
index 00000000000..9d0b99415a5
--- /dev/null
+++ b/tests/ui/iter_without_into_iter.stderr
@@ -0,0 +1,150 @@
+error: `iter` method without an `IntoIterator` impl for `&S`
+  --> $DIR/iter_without_into_iter.rs:8:13
+   |
+LL | /             pub fn iter(&self) -> std::slice::Iter<'_, u8> {
+LL | |
+LL | |                 [].iter()
+LL | |             }
+   | |_____________^
+   |
+   = note: `-D clippy::iter-without-into-iter` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::iter_without_into_iter)]`
+help: consider implementing `IntoIterator` for `&S`
+   |
+LL ~         
+LL + impl IntoIterator for &S {
+LL +     type IntoIter = std::slice::Iter<'_, u8>;
+LL +     type Iter = &u8;
+LL +     fn into_iter() -> Self::IntoIter {
+LL +         self.iter()
+LL +     }
+LL + }
+   |
+
+error: `iter_mut` method without an `IntoIterator` impl for `&mut S`
+  --> $DIR/iter_without_into_iter.rs:12:13
+   |
+LL | /             pub fn iter_mut(&mut self) -> std::slice::IterMut<'_, u8> {
+LL | |
+LL | |                 [].iter_mut()
+LL | |             }
+   | |_____________^
+   |
+help: consider implementing `IntoIterator` for `&mut S`
+   |
+LL ~         
+LL + impl IntoIterator for &mut S {
+LL +     type IntoIter = std::slice::IterMut<'_, u8>;
+LL +     type Iter = &mut u8;
+LL +     fn into_iter() -> Self::IntoIter {
+LL +         self.iter()
+LL +     }
+LL + }
+   |
+
+error: `iter` method without an `IntoIterator` impl for `&S<'a>`
+  --> $DIR/iter_without_into_iter.rs:30:13
+   |
+LL | /             pub fn iter(&self) -> std::slice::Iter<'_, u8> {
+LL | |
+LL | |                 self.0.iter()
+LL | |             }
+   | |_____________^
+   |
+help: consider implementing `IntoIterator` for `&S<'a>`
+   |
+LL ~         
+LL + impl IntoIterator for &S<'a> {
+LL +     type IntoIter = std::slice::Iter<'_, u8>;
+LL +     type Iter = &u8;
+LL +     fn into_iter() -> Self::IntoIter {
+LL +         self.iter()
+LL +     }
+LL + }
+   |
+
+error: `iter_mut` method without an `IntoIterator` impl for `&mut S<'a>`
+  --> $DIR/iter_without_into_iter.rs:34:13
+   |
+LL | /             pub fn iter_mut(&mut self) -> std::slice::IterMut<'_, u8> {
+LL | |
+LL | |                 self.0.iter_mut()
+LL | |             }
+   | |_____________^
+   |
+help: consider implementing `IntoIterator` for `&mut S<'a>`
+   |
+LL ~         
+LL + impl IntoIterator for &mut S<'a> {
+LL +     type IntoIter = std::slice::IterMut<'_, u8>;
+LL +     type Iter = &mut u8;
+LL +     fn into_iter() -> Self::IntoIter {
+LL +         self.iter()
+LL +     }
+LL + }
+   |
+
+error: `iter` method without an `IntoIterator` impl for `&S5<T>`
+  --> $DIR/iter_without_into_iter.rs:68:13
+   |
+LL | /             pub fn iter(&self) -> std::slice::Iter<'static, T> {
+LL | |                 todo!()
+LL | |             }
+   | |_____________^
+   |
+help: consider implementing `IntoIterator` for `&S5<T>`
+   |
+LL ~         
+LL + impl IntoIterator for &S5<T> {
+LL +     type IntoIter = std::slice::Iter<'static, T>;
+LL +     type Iter = &T;
+LL +     fn into_iter() -> Self::IntoIter {
+LL +         self.iter()
+LL +     }
+LL + }
+   |
+
+error: `iter` method without an `IntoIterator` impl for `&S<T>`
+  --> $DIR/iter_without_into_iter.rs:76:13
+   |
+LL | /             pub fn iter(&self) -> std::slice::Iter<'_, T> {
+LL | |
+LL | |                 todo!()
+LL | |             }
+   | |_____________^
+   |
+help: consider implementing `IntoIterator` for `&S<T>`
+   |
+LL ~         
+LL + impl IntoIterator for &S<T> {
+LL +     type IntoIter = std::slice::Iter<'_, T>;
+LL +     type Iter = &T;
+LL +     fn into_iter() -> Self::IntoIter {
+LL +         self.iter()
+LL +     }
+LL + }
+   |
+
+error: `iter_mut` method without an `IntoIterator` impl for `&mut S<T>`
+  --> $DIR/iter_without_into_iter.rs:80:13
+   |
+LL | /             pub fn iter_mut(&mut self) -> std::slice::IterMut<'_, T> {
+LL | |
+LL | |                 todo!()
+LL | |             }
+   | |_____________^
+   |
+help: consider implementing `IntoIterator` for `&mut S<T>`
+   |
+LL ~         
+LL + impl IntoIterator for &mut S<T> {
+LL +     type IntoIter = std::slice::IterMut<'_, T>;
+LL +     type Iter = &mut T;
+LL +     fn into_iter() -> Self::IntoIter {
+LL +         self.iter()
+LL +     }
+LL + }
+   |
+
+error: aborting due to 7 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From ad5653b296e8b3a001f15a3c02c5b17de8d13d57 Mon Sep 17 00:00:00 2001
From: DaniPopes <57450786+DaniPopes@users.noreply.github.com>
Date: Fri, 29 Sep 2023 03:08:34 +0200
Subject: Add missing lint description headers

---
 clippy_lints/src/allow_attributes.rs | 2 +-
 clippy_lints/src/methods/mod.rs      | 1 +
 2 files changed, 2 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/allow_attributes.rs b/clippy_lints/src/allow_attributes.rs
index e1ef514edfd..e3f4cf79d31 100644
--- a/clippy_lints/src/allow_attributes.rs
+++ b/clippy_lints/src/allow_attributes.rs
@@ -8,6 +8,7 @@ use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
 declare_clippy_lint! {
+    /// ### What it does
     /// Checks for usage of the `#[allow]` attribute and suggests replacing it with
     /// the `#[expect]` (See [RFC 2383](https://rust-lang.github.io/rfcs/2383-lint-reasons.html))
     ///
@@ -19,7 +20,6 @@ declare_clippy_lint! {
     /// (`#![allow]`) are usually used to enable or disable lints on a global scale.
     ///
     /// ### Why is this bad?
-    ///
     /// `#[expect]` attributes suppress the lint emission, but emit a warning, if
     /// the expectation is unfulfilled. This can be useful to be notified when the
     /// lint is no longer triggered.
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index e7fcef9e9de..7b743382fa1 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3368,6 +3368,7 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
+    /// ### What it does
     /// Looks for calls to [`Stdin::read_line`] to read a line from the standard input
     /// into a string, then later attempting to parse this string into a type without first trimming it, which will
     /// always fail because the string has a trailing newline in it.
-- 
cgit 1.4.1-3-g733a5


From f4a8b12ed503ce998cc44320f5cd902e837b785f Mon Sep 17 00:00:00 2001
From: koka <koka.code@gmail.com>
Date: Fri, 29 Sep 2023 23:17:49 +0900
Subject: Wrap with parenthesis if necessary

---
 clippy_lints/src/returns.rs    |  4 ++++
 tests/ui/let_and_return.fixed  | 21 ++++++++++++++++++++-
 tests/ui/let_and_return.rs     | 19 +++++++++++++++++++
 tests/ui/let_and_return.stderr | 26 ++++++++++++++++++++++++--
 4 files changed, 67 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
index d6b9a49d2fe..477207142b4 100644
--- a/clippy_lints/src/returns.rs
+++ b/clippy_lints/src/returns.rs
@@ -1,5 +1,6 @@
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then, span_lint_hir_and_then};
 use clippy_utils::source::{snippet_opt, snippet_with_context};
+use clippy_utils::sugg::has_enclosing_paren;
 use clippy_utils::visitors::{for_each_expr_with_closures, Descend};
 use clippy_utils::{fn_def_id, is_from_proc_macro, path_to_local_id, span_find_starting_semi};
 use core::ops::ControlFlow;
@@ -213,6 +214,9 @@ impl<'tcx> LateLintPass<'tcx> for Return {
 
                         if let Some(mut snippet) = snippet_opt(cx, initexpr.span) {
                             if !cx.typeck_results().expr_adjustments(retexpr).is_empty() {
+                                if !has_enclosing_paren(&snippet) {
+                                    snippet = format!("({snippet})");
+                                }
                                 snippet.push_str(" as _");
                             }
                             err.multipart_suggestion(
diff --git a/tests/ui/let_and_return.fixed b/tests/ui/let_and_return.fixed
index 88b8ae67375..b5584fcde8c 100644
--- a/tests/ui/let_and_return.fixed
+++ b/tests/ui/let_and_return.fixed
@@ -168,7 +168,26 @@ mod issue_5729 {
     impl<T: Foo + 'static> FooStorage for FooStorageImpl<T> {
         fn foo_cloned(&self) -> Arc<dyn Foo> {
             
-            Arc::clone(&self.foo) as _
+            (Arc::clone(&self.foo)) as _
+            //~^ ERROR: returning the result of a `let` binding from a block
+        }
+    }
+}
+
+mod issue_11335 {
+    pub enum E<T> {
+        A(T),
+        B(T),
+    }
+
+    impl<T> E<T> {
+        pub fn inner(&self) -> &T {
+            
+
+            (match self {
+                E::A(x) => x,
+                E::B(x) => x,
+            }) as _
             //~^ ERROR: returning the result of a `let` binding from a block
         }
     }
diff --git a/tests/ui/let_and_return.rs b/tests/ui/let_and_return.rs
index f366842c5d7..f13c7c4e203 100644
--- a/tests/ui/let_and_return.rs
+++ b/tests/ui/let_and_return.rs
@@ -174,6 +174,25 @@ mod issue_5729 {
     }
 }
 
+mod issue_11335 {
+    pub enum E<T> {
+        A(T),
+        B(T),
+    }
+
+    impl<T> E<T> {
+        pub fn inner(&self) -> &T {
+            let result = match self {
+                E::A(x) => x,
+                E::B(x) => x,
+            };
+
+            result
+            //~^ ERROR: returning the result of a `let` binding from a block
+        }
+    }
+}
+
 // https://github.com/rust-lang/rust-clippy/issues/11167
 macro_rules! fn_in_macro {
     ($b:block) => {
diff --git a/tests/ui/let_and_return.stderr b/tests/ui/let_and_return.stderr
index c09c2b32aad..fe60072d13f 100644
--- a/tests/ui/let_and_return.stderr
+++ b/tests/ui/let_and_return.stderr
@@ -53,8 +53,30 @@ LL |             clone
 help: return the expression directly
    |
 LL ~             
-LL ~             Arc::clone(&self.foo) as _
+LL ~             (Arc::clone(&self.foo)) as _
    |
 
-error: aborting due to 4 previous errors
+error: returning the result of a `let` binding from a block
+  --> $DIR/let_and_return.rs:190:13
+   |
+LL | /             let result = match self {
+LL | |                 E::A(x) => x,
+LL | |                 E::B(x) => x,
+LL | |             };
+   | |______________- unnecessary `let` binding
+LL |
+LL |               result
+   |               ^^^^^^
+   |
+help: return the expression directly
+   |
+LL ~             
+LL | 
+LL ~             (match self {
+LL +                 E::A(x) => x,
+LL +                 E::B(x) => x,
+LL +             }) as _
+   |
+
+error: aborting due to 5 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 2d2017942afc221da0295962ac0374bd31cc6d1c Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Thu, 28 Sep 2023 16:31:21 +0200
Subject: [`manual_let_else`]: only omit block if span is from same ctxt

---
 clippy_lints/src/manual_let_else.rs   |  4 ++--
 tests/ui/manual_let_else_match.fixed  |  4 ++++
 tests/ui/manual_let_else_match.rs     |  8 ++++++++
 tests/ui/manual_let_else_match.stderr | 12 +++++++++++-
 4 files changed, 25 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_let_else.rs b/clippy_lints/src/manual_let_else.rs
index c531137b785..2117308cd40 100644
--- a/clippy_lints/src/manual_let_else.rs
+++ b/clippy_lints/src/manual_let_else.rs
@@ -136,9 +136,9 @@ fn emit_manual_let_else(
             // for this to be machine applicable.
             let mut app = Applicability::HasPlaceholders;
             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);
+            let (sn_else, else_is_mac_call) = snippet_with_context(cx, else_body.span, span.ctxt(), "", &mut app);
 
-            let else_bl = if matches!(else_body.kind, ExprKind::Block(..)) {
+            let else_bl = if matches!(else_body.kind, ExprKind::Block(..)) && !else_is_mac_call {
                 sn_else.into_owned()
             } else {
                 format!("{{ {sn_else} }}")
diff --git a/tests/ui/manual_let_else_match.fixed b/tests/ui/manual_let_else_match.fixed
index 09b713f0410..588ba5edd8f 100644
--- a/tests/ui/manual_let_else_match.fixed
+++ b/tests/ui/manual_let_else_match.fixed
@@ -133,3 +133,7 @@ fn not_fire() {
         [data @ .., 0, 0, 0, 0] | [data @ .., 0, 0] | [data @ ..] => data,
     };
 }
+
+fn issue11579() {
+    let Some(msg) = Some("hi") else { unreachable!("can't happen") };
+}
diff --git a/tests/ui/manual_let_else_match.rs b/tests/ui/manual_let_else_match.rs
index e6af4738420..c37b5613ff7 100644
--- a/tests/ui/manual_let_else_match.rs
+++ b/tests/ui/manual_let_else_match.rs
@@ -170,3 +170,11 @@ fn not_fire() {
         [data @ .., 0, 0, 0, 0] | [data @ .., 0, 0] | [data @ ..] => data,
     };
 }
+
+fn issue11579() {
+    let msg = match Some("hi") {
+        //~^ ERROR: this could be rewritten as `let...else`
+        Some(m) => m,
+        _ => unreachable!("can't happen"),
+    };
+}
diff --git a/tests/ui/manual_let_else_match.stderr b/tests/ui/manual_let_else_match.stderr
index 8ca2c84072d..18bfe324ba7 100644
--- a/tests/ui/manual_let_else_match.stderr
+++ b/tests/ui/manual_let_else_match.stderr
@@ -92,5 +92,15 @@ LL | |         _ => return,
 LL | |     };
    | |______^ help: consider writing: `let ([data @ .., 0, 0, 0, 0] | [data @ .., 0, 0] | [data @ .., 0]) = data.as_slice() else { return };`
 
-error: aborting due to 9 previous errors
+error: this could be rewritten as `let...else`
+  --> $DIR/manual_let_else_match.rs:175:5
+   |
+LL | /     let msg = match Some("hi") {
+LL | |
+LL | |         Some(m) => m,
+LL | |         _ => unreachable!("can't happen"),
+LL | |     };
+   | |______^ help: consider writing: `let Some(msg) = Some("hi") else { unreachable!("can't happen") };`
+
+error: aborting due to 10 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 44b6aca96b48299adf0ab44307c40d7f3392d060 Mon Sep 17 00:00:00 2001
From: koka <koka.code@gmail.com>
Date: Sat, 30 Sep 2023 23:56:11 +0900
Subject: Avoid linting in external/proc macro

---
 clippy_lints/src/std_instead_of_core.rs | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/std_instead_of_core.rs b/clippy_lints/src/std_instead_of_core.rs
index 5f54a10d1c4..b7396535eed 100644
--- a/clippy_lints/src/std_instead_of_core.rs
+++ b/clippy_lints/src/std_instead_of_core.rs
@@ -1,9 +1,11 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::is_from_proc_macro;
 use rustc_errors::Applicability;
 use rustc_hir::def::Res;
 use rustc_hir::def_id::DefId;
 use rustc_hir::{HirId, Path, PathSegment};
-use rustc_lint::{LateContext, LateLintPass};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::symbol::kw;
 use rustc_span::{sym, Span};
@@ -99,6 +101,8 @@ impl<'tcx> LateLintPass<'tcx> for StdReexports {
         if let Res::Def(_, def_id) = path.res
             && let Some(first_segment) = get_first_segment(path)
             && is_stable(cx, def_id)
+            && !in_external_macro(cx.sess(), path.span)
+            && !is_from_proc_macro(cx, &first_segment.ident)
         {
             let (lint, used_mod, replace_with) = match first_segment.ident.name {
                 sym::std => match cx.tcx.crate_name(def_id.krate) {
-- 
cgit 1.4.1-3-g733a5


From 8eb586d1549236be3ba55b205c9dc19e9bfe7f3d Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Sat, 30 Sep 2023 03:00:34 +0200
Subject: new lint: `into_iter_without_iter`

---
 CHANGELOG.md                               |   1 +
 clippy_lints/src/declared_lints.rs         |   1 +
 clippy_lints/src/iter_without_into_iter.rs | 120 +++++++++++++++++++++++++++-
 tests/ui/into_iter_without_iter.rs         | 124 +++++++++++++++++++++++++++++
 tests/ui/into_iter_without_iter.stderr     | 114 ++++++++++++++++++++++++++
 5 files changed, 357 insertions(+), 3 deletions(-)
 create mode 100644 tests/ui/into_iter_without_iter.rs
 create mode 100644 tests/ui/into_iter_without_iter.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 40510d78800..25230e46e88 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5011,6 +5011,7 @@ Released 2018-09-13
 [`integer_division`]: https://rust-lang.github.io/rust-clippy/master/index.html#integer_division
 [`into_iter_on_array`]: https://rust-lang.github.io/rust-clippy/master/index.html#into_iter_on_array
 [`into_iter_on_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#into_iter_on_ref
+[`into_iter_without_iter`]: https://rust-lang.github.io/rust-clippy/master/index.html#into_iter_without_iter
 [`invalid_atomic_ordering`]: https://rust-lang.github.io/rust-clippy/master/index.html#invalid_atomic_ordering
 [`invalid_null_ptr_usage`]: https://rust-lang.github.io/rust-clippy/master/index.html#invalid_null_ptr_usage
 [`invalid_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#invalid_ref
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 06809038927..481c44031cf 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -229,6 +229,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::items_after_statements::ITEMS_AFTER_STATEMENTS_INFO,
     crate::items_after_test_module::ITEMS_AFTER_TEST_MODULE_INFO,
     crate::iter_not_returning_iterator::ITER_NOT_RETURNING_ITERATOR_INFO,
+    crate::iter_without_into_iter::INTO_ITER_WITHOUT_ITER_INFO,
     crate::iter_without_into_iter::ITER_WITHOUT_INTO_ITER_INFO,
     crate::large_const_arrays::LARGE_CONST_ARRAYS_INFO,
     crate::large_enum_variant::LARGE_ENUM_VARIANT_INFO,
diff --git a/clippy_lints/src/iter_without_into_iter.rs b/clippy_lints/src/iter_without_into_iter.rs
index 08a8e6dbf18..43e1b92c9b9 100644
--- a/clippy_lints/src/iter_without_into_iter.rs
+++ b/clippy_lints/src/iter_without_into_iter.rs
@@ -2,11 +2,13 @@ use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::get_parent_as_impl;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::{implements_trait, make_normalized_projection};
+use rustc_ast::Mutability;
 use rustc_errors::Applicability;
-use rustc_hir::{FnRetTy, ImplItemKind, ImplicitSelfKind, TyKind};
+use rustc_hir::{FnRetTy, ImplItemKind, ImplicitSelfKind, ItemKind, TyKind};
 use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::{self, Ty};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::sym;
+use rustc_span::{sym, Symbol};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -46,7 +48,51 @@ declare_clippy_lint! {
     pedantic,
     "implementing `iter(_mut)` without an associated `IntoIterator for (&|&mut) Type` impl"
 }
-declare_lint_pass!(IterWithoutIntoIter => [ITER_WITHOUT_INTO_ITER]);
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// This is the opposite of the `iter_without_into_iter` lint.
+    /// It looks for `IntoIterator for (&|&mut) Type` implementations without an inherent `iter` or `iter_mut` method.
+    ///
+    /// ### Why is this bad?
+    /// It's not bad, but having them is idiomatic and allows the type to be used in iterator chains
+    /// by just calling `.iter()`, instead of the more awkward `<&Type>::into_iter` or `(&val).iter()` syntax
+    /// in case of ambiguity with another `Intoiterator` impl.
+    ///
+    /// ### Example
+    /// ```rust
+    /// struct MySlice<'a>(&'a [u8]);
+    /// impl<'a> IntoIterator for &MySlice<'a> {
+    ///     type Item = &'a u8;
+    ///     type IntoIter = std::slice::Iter<'a, u8>;
+    ///     fn into_iter(self) -> Self::IntoIter {
+    ///         self.0.iter()
+    ///     }
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// struct MySlice<'a>(&'a [u8]);
+    /// impl<'a> MySlice<'a> {
+    ///     pub fn iter(&self) -> std::slice::Iter<'a, u8> {
+    ///         self.into_iter()
+    ///     }
+    /// }
+    /// impl<'a> IntoIterator for &MySlice<'a> {
+    ///     type Item = &'a u8;
+    ///     type IntoIter = std::slice::Iter<'a, u8>;
+    ///     fn into_iter(self) -> Self::IntoIter {
+    ///         self.0.iter()
+    ///     }
+    /// }
+    /// ```
+    #[clippy::version = "1.74.0"]
+    pub INTO_ITER_WITHOUT_ITER,
+    pedantic,
+    "implementing `IntoIterator for (&|&mut) Type` without an inherent `iter(_mut)` method"
+}
+
+declare_lint_pass!(IterWithoutIntoIter => [ITER_WITHOUT_INTO_ITER, INTO_ITER_WITHOUT_ITER]);
 
 /// Checks if a given type is nameable in a trait (impl).
 /// RPIT is stable, but impl Trait in traits is not (yet), so when we have
@@ -56,7 +102,75 @@ fn is_nameable_in_impl_trait(ty: &rustc_hir::Ty<'_>) -> bool {
     !matches!(ty.kind, TyKind::OpaqueDef(..))
 }
 
+fn type_has_inherent_method(cx: &LateContext<'_>, ty: Ty<'_>, method_name: Symbol) -> bool {
+    if let Some(ty_did) = ty.ty_adt_def().map(ty::AdtDef::did) {
+        cx.tcx.inherent_impls(ty_did).iter().any(|&did| {
+            cx.tcx
+                .associated_items(did)
+                .filter_by_name_unhygienic(method_name)
+                .next()
+                .is_some_and(|item| item.kind == ty::AssocKind::Fn)
+        })
+    } else {
+        false
+    }
+}
+
 impl LateLintPass<'_> for IterWithoutIntoIter {
+    fn check_item(&mut self, cx: &LateContext<'_>, item: &rustc_hir::Item<'_>) {
+        if let ItemKind::Impl(imp) = item.kind
+            && let TyKind::Ref(_, self_ty_without_ref) = &imp.self_ty.kind
+            && let Some(trait_ref) = imp.of_trait
+            && trait_ref.trait_def_id().is_some_and(|did| cx.tcx.is_diagnostic_item(sym::IntoIterator, did))
+            && let &ty::Ref(_, ty, mtbl) = cx.tcx.type_of(item.owner_id).instantiate_identity().kind()
+            && let expected_method_name = match mtbl {
+                Mutability::Mut => sym::iter_mut,
+                Mutability::Not => sym::iter,
+            }
+            && !type_has_inherent_method(cx, ty, expected_method_name)
+            && let Some(iter_assoc_span) = imp.items.iter().find_map(|item| {
+                if item.ident.name == sym!(IntoIter) {
+                    Some(cx.tcx.hir().impl_item(item.id).expect_type().span)
+                } else {
+                    None
+                }
+            })
+        {
+            span_lint_and_then(
+                cx,
+                INTO_ITER_WITHOUT_ITER,
+                item.span,
+                &format!("`IntoIterator` implemented for a reference type without an `{expected_method_name}` method"),
+                |diag| {
+                    // The suggestion forwards to the `IntoIterator` impl and uses a form of UFCS
+                    // to avoid name ambiguities, as there might be an inherent into_iter method
+                    // that we don't want to call.
+                    let sugg = format!(
+"
+impl {self_ty_without_ref} {{
+    fn {expected_method_name}({ref_self}self) -> {iter_ty} {{
+        <{ref_self}Self as IntoIterator>::into_iter(self)
+    }}
+}}
+",
+                        self_ty_without_ref = snippet(cx, self_ty_without_ref.ty.span, ".."),
+                        ref_self = mtbl.ref_prefix_str(),
+                        iter_ty = snippet(cx, iter_assoc_span, ".."),
+                    );
+
+                    diag.span_suggestion_verbose(
+                        item.span.shrink_to_lo(),
+                        format!("consider implementing `{expected_method_name}`"),
+                        sugg,
+                        // Just like iter_without_into_iter, this suggestion is on a best effort basis
+                        // and requires potentially adding lifetimes or moving them around.
+                        Applicability::Unspecified
+                    );
+                }
+            );
+        }
+    }
+
     fn check_impl_item(&mut self, cx: &LateContext<'_>, item: &rustc_hir::ImplItem<'_>) {
         let item_did = item.owner_id.to_def_id();
         let (borrow_prefix, expected_implicit_self) = match item.ident.name {
diff --git a/tests/ui/into_iter_without_iter.rs b/tests/ui/into_iter_without_iter.rs
new file mode 100644
index 00000000000..6be3bb8abdd
--- /dev/null
+++ b/tests/ui/into_iter_without_iter.rs
@@ -0,0 +1,124 @@
+//@no-rustfix
+#![warn(clippy::into_iter_without_iter)]
+
+use std::iter::IntoIterator;
+
+fn main() {
+    {
+        struct S;
+
+        impl<'a> IntoIterator for &'a S {
+            //~^ ERROR: `IntoIterator` implemented for a reference type without an `iter` method
+            type IntoIter = std::slice::Iter<'a, u8>;
+            type Item = &'a u8;
+            fn into_iter(self) -> Self::IntoIter {
+                todo!()
+            }
+        }
+        impl<'a> IntoIterator for &'a mut S {
+            //~^ ERROR: `IntoIterator` implemented for a reference type without an `iter_mut` method
+            type IntoIter = std::slice::IterMut<'a, u8>;
+            type Item = &'a mut u8;
+            fn into_iter(self) -> Self::IntoIter {
+                todo!()
+            }
+        }
+    }
+    {
+        struct S<T>(T);
+        impl<'a, T> IntoIterator for &'a S<T> {
+            //~^ ERROR: `IntoIterator` implemented for a reference type without an `iter` method
+            type IntoIter = std::slice::Iter<'a, T>;
+            type Item = &'a T;
+            fn into_iter(self) -> Self::IntoIter {
+                todo!()
+            }
+        }
+        impl<'a, T> IntoIterator for &'a mut S<T> {
+            //~^ ERROR: `IntoIterator` implemented for a reference type without an `iter_mut` method
+            type IntoIter = std::slice::IterMut<'a, T>;
+            type Item = &'a mut T;
+            fn into_iter(self) -> Self::IntoIter {
+                todo!()
+            }
+        }
+    }
+    {
+        // Both iter and iter_mut methods exist, don't lint
+        struct S<'a, T>(&'a T);
+
+        impl<'a, T> S<'a, T> {
+            fn iter(&self) -> std::slice::Iter<'a, T> {
+                todo!()
+            }
+            fn iter_mut(&mut self) -> std::slice::IterMut<'a, T> {
+                todo!()
+            }
+        }
+
+        impl<'a, T> IntoIterator for &S<'a, T> {
+            type IntoIter = std::slice::Iter<'a, T>;
+            type Item = &'a T;
+            fn into_iter(self) -> Self::IntoIter {
+                todo!()
+            }
+        }
+
+        impl<'a, T> IntoIterator for &mut S<'a, T> {
+            type IntoIter = std::slice::IterMut<'a, T>;
+            type Item = &'a mut T;
+            fn into_iter(self) -> Self::IntoIter {
+                todo!()
+            }
+        }
+    }
+    {
+        // Only `iter` exists, no `iter_mut`
+        struct S<'a, T>(&'a T);
+
+        impl<'a, T> S<'a, T> {
+            fn iter(&self) -> std::slice::Iter<'a, T> {
+                todo!()
+            }
+        }
+
+        impl<'a, T> IntoIterator for &S<'a, T> {
+            type IntoIter = std::slice::Iter<'a, T>;
+            type Item = &'a T;
+            fn into_iter(self) -> Self::IntoIter {
+                todo!()
+            }
+        }
+
+        impl<'a, T> IntoIterator for &mut S<'a, T> {
+            //~^ ERROR: `IntoIterator` implemented for a reference type without an `iter_mut` method
+            type IntoIter = std::slice::IterMut<'a, T>;
+            type Item = &'a mut T;
+            fn into_iter(self) -> Self::IntoIter {
+                todo!()
+            }
+        }
+    }
+    {
+        // `iter` exists, but `IntoIterator` is implemented for an alias. inherent_impls doesn't "normalize"
+        // aliases so that `inherent_impls(Alias)` where `type Alias = S` returns nothing, so this can lead
+        // to fun FPs. Make sure it doesn't happen here (we're using type_of, which should skip the alias).
+        struct S;
+
+        impl S {
+            fn iter(&self) -> std::slice::Iter<'static, u8> {
+                todo!()
+            }
+        }
+
+        type Alias = S;
+
+        impl IntoIterator for &Alias {
+            type IntoIter = std::slice::Iter<'static, u8>;
+            type Item = &'static u8;
+            fn into_iter(self) -> Self::IntoIter {
+                todo!()
+            }
+        }
+    }
+}
diff --git a/tests/ui/into_iter_without_iter.stderr b/tests/ui/into_iter_without_iter.stderr
new file mode 100644
index 00000000000..f543d1d8e86
--- /dev/null
+++ b/tests/ui/into_iter_without_iter.stderr
@@ -0,0 +1,114 @@
+error: `IntoIterator` implemented for a reference type without an `iter` method
+  --> $DIR/into_iter_without_iter.rs:10:9
+   |
+LL | /         impl<'a> IntoIterator for &'a S {
+LL | |
+LL | |             type IntoIter = std::slice::Iter<'a, u8>;
+LL | |             type Item = &'a u8;
+...  |
+LL | |             }
+LL | |         }
+   | |_________^
+   |
+   = note: `-D clippy::into-iter-without-iter` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::into_iter_without_iter)]`
+help: consider implementing `iter`
+   |
+LL ~         
+LL + impl S {
+LL +     fn iter(&self) -> std::slice::Iter<'a, u8> {
+LL +         <&Self as IntoIterator>::into_iter(self)
+LL +     }
+LL + }
+   |
+
+error: `IntoIterator` implemented for a reference type without an `iter_mut` method
+  --> $DIR/into_iter_without_iter.rs:18:9
+   |
+LL | /         impl<'a> IntoIterator for &'a mut S {
+LL | |
+LL | |             type IntoIter = std::slice::IterMut<'a, u8>;
+LL | |             type Item = &'a mut u8;
+...  |
+LL | |             }
+LL | |         }
+   | |_________^
+   |
+help: consider implementing `iter_mut`
+   |
+LL ~         
+LL + impl S {
+LL +     fn iter_mut(&mut self) -> std::slice::IterMut<'a, u8> {
+LL +         <&mut Self as IntoIterator>::into_iter(self)
+LL +     }
+LL + }
+   |
+
+error: `IntoIterator` implemented for a reference type without an `iter` method
+  --> $DIR/into_iter_without_iter.rs:29:9
+   |
+LL | /         impl<'a, T> IntoIterator for &'a S<T> {
+LL | |
+LL | |             type IntoIter = std::slice::Iter<'a, T>;
+LL | |             type Item = &'a T;
+...  |
+LL | |             }
+LL | |         }
+   | |_________^
+   |
+help: consider implementing `iter`
+   |
+LL ~         
+LL + impl S<T> {
+LL +     fn iter(&self) -> std::slice::Iter<'a, T> {
+LL +         <&Self as IntoIterator>::into_iter(self)
+LL +     }
+LL + }
+   |
+
+error: `IntoIterator` implemented for a reference type without an `iter_mut` method
+  --> $DIR/into_iter_without_iter.rs:37:9
+   |
+LL | /         impl<'a, T> IntoIterator for &'a mut S<T> {
+LL | |
+LL | |             type IntoIter = std::slice::IterMut<'a, T>;
+LL | |             type Item = &'a mut T;
+...  |
+LL | |             }
+LL | |         }
+   | |_________^
+   |
+help: consider implementing `iter_mut`
+   |
+LL ~         
+LL + impl S<T> {
+LL +     fn iter_mut(&mut self) -> std::slice::IterMut<'a, T> {
+LL +         <&mut Self as IntoIterator>::into_iter(self)
+LL +     }
+LL + }
+   |
+
+error: `IntoIterator` implemented for a reference type without an `iter_mut` method
+  --> $DIR/into_iter_without_iter.rs:93:9
+   |
+LL | /         impl<'a, T> IntoIterator for &mut S<'a, T> {
+LL | |
+LL | |             type IntoIter = std::slice::IterMut<'a, T>;
+LL | |             type Item = &'a mut T;
+...  |
+LL | |             }
+LL | |         }
+   | |_________^
+   |
+help: consider implementing `iter_mut`
+   |
+LL ~         
+LL + impl S<'a, T> {
+LL +     fn iter_mut(&mut self) -> std::slice::IterMut<'a, T> {
+LL +         <&mut Self as IntoIterator>::into_iter(self)
+LL +     }
+LL + }
+   |
+
+error: aborting due to 5 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From e683e3eeac5603296c328ff45c9e5bb911327756 Mon Sep 17 00:00:00 2001
From: Victor Song <vms2@rice.edu>
Date: Sat, 30 Sep 2023 22:57:54 -0500
Subject: Don't lint `manual_non_exhaustive` when enum explicitly marked as
 `non_exhaustive`

There are cases where users create a unit variant for the purposes
of tracking the number of variants for an nonexhaustive enum.
We should check if an enum is explicitly marked as nonexhaustive
before reporting `manual_non_exhaustive` in these cases. Fixes #11583
---
 clippy_lints/src/manual_non_exhaustive.rs  |  4 +++-
 tests/ui/manual_non_exhaustive_enum.rs     |  3 +--
 tests/ui/manual_non_exhaustive_enum.stderr | 20 +-------------------
 3 files changed, 5 insertions(+), 22 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_non_exhaustive.rs b/clippy_lints/src/manual_non_exhaustive.rs
index 0e22485db2c..9fe55d819da 100644
--- a/clippy_lints/src/manual_non_exhaustive.rs
+++ b/clippy_lints/src/manual_non_exhaustive.rs
@@ -3,6 +3,7 @@ use clippy_utils::is_doc_hidden;
 use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::snippet_opt;
 use rustc_ast::ast::{self, VisibilityKind};
+use rustc_ast::attr;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Applicability;
 use rustc_hir::def::{CtorKind, CtorOf, DefKind, Res};
@@ -158,7 +159,8 @@ impl<'tcx> LateLintPass<'tcx> for ManualNonExhaustiveEnum {
             let mut iter = def.variants.iter().filter_map(|v| {
                 (matches!(v.data, hir::VariantData::Unit(_, _))
                     && v.ident.as_str().starts_with('_')
-                    && is_doc_hidden(cx.tcx.hir().attrs(v.hir_id)))
+                    && is_doc_hidden(cx.tcx.hir().attrs(v.hir_id))
+                    && !attr::contains_name(cx.tcx.hir().attrs(item.hir_id()), sym::non_exhaustive))
                 .then_some((v.def_id, v.span))
             });
             if let Some((id, span)) = iter.next()
diff --git a/tests/ui/manual_non_exhaustive_enum.rs b/tests/ui/manual_non_exhaustive_enum.rs
index 0e439dabfd6..e32ba863176 100644
--- a/tests/ui/manual_non_exhaustive_enum.rs
+++ b/tests/ui/manual_non_exhaustive_enum.rs
@@ -10,10 +10,9 @@ enum E {
     _C,
 }
 
-// user forgot to remove the marker
+// if the user explicitly marks as nonexhaustive we shouldn't warn them
 #[non_exhaustive]
 enum Ep {
-    //~^ ERROR: this seems like a manual implementation of the non-exhaustive pattern
     A,
     B,
     #[doc(hidden)]
diff --git a/tests/ui/manual_non_exhaustive_enum.stderr b/tests/ui/manual_non_exhaustive_enum.stderr
index ce7e21c94bb..7361a4a2cbb 100644
--- a/tests/ui/manual_non_exhaustive_enum.stderr
+++ b/tests/ui/manual_non_exhaustive_enum.stderr
@@ -22,23 +22,5 @@ LL |     _C,
    = note: `-D clippy::manual-non-exhaustive` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::manual_non_exhaustive)]`
 
-error: this seems like a manual implementation of the non-exhaustive pattern
-  --> $DIR/manual_non_exhaustive_enum.rs:15:1
-   |
-LL | / enum Ep {
-LL | |
-LL | |     A,
-LL | |     B,
-LL | |     #[doc(hidden)]
-LL | |     _C,
-LL | | }
-   | |_^
-   |
-help: remove this variant
-  --> $DIR/manual_non_exhaustive_enum.rs:20:5
-   |
-LL |     _C,
-   |     ^^
-
-error: aborting due to 2 previous errors
+error: aborting due to previous error
 
-- 
cgit 1.4.1-3-g733a5


From 9dfd60cf4f33c9af8e37d4a4956f56626bac2b3c Mon Sep 17 00:00:00 2001
From: Victor Song <vms2@rice.edu>
Date: Sun, 1 Oct 2023 09:54:45 -0500
Subject: Remove extraneous `#[non_exhaustive]` check in lint

---
 clippy_lints/src/manual_non_exhaustive.rs | 18 ++++++++----------
 1 file changed, 8 insertions(+), 10 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_non_exhaustive.rs b/clippy_lints/src/manual_non_exhaustive.rs
index 9fe55d819da..c12727c4a28 100644
--- a/clippy_lints/src/manual_non_exhaustive.rs
+++ b/clippy_lints/src/manual_non_exhaustive.rs
@@ -200,16 +200,14 @@ impl<'tcx> LateLintPass<'tcx> for ManualNonExhaustiveEnum {
                 enum_span,
                 "this seems like a manual implementation of the non-exhaustive pattern",
                 |diag| {
-                    if !cx.tcx.adt_def(enum_id).is_variant_list_non_exhaustive()
-                        && let header_span = cx.sess().source_map().span_until_char(enum_span, '{')
-                        && let Some(snippet) = snippet_opt(cx, header_span)
-                    {
-                            diag.span_suggestion(
-                                header_span,
-                                "add the attribute",
-                                format!("#[non_exhaustive] {snippet}"),
-                                Applicability::Unspecified,
-                            );
+                    let header_span = cx.sess().source_map().span_until_char(enum_span, '{');
+                    if let Some(snippet) = snippet_opt(cx, header_span) {
+                        diag.span_suggestion(
+                            header_span,
+                            "add the attribute",
+                            format!("#[non_exhaustive] {snippet}"),
+                            Applicability::Unspecified,
+                        );
                     }
                     diag.span_help(variant_span, "remove this variant");
                 },
-- 
cgit 1.4.1-3-g733a5


From 6f1a78ffa85b1fc67517a0522530907d0025a5f5 Mon Sep 17 00:00:00 2001
From: koka <koka.code@gmail.com>
Date: Mon, 2 Oct 2023 00:38:01 +0900
Subject: Use Span#from_expansion instead of in_external_macro

---
 clippy_lints/src/implicit_hasher.rs | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/implicit_hasher.rs b/clippy_lints/src/implicit_hasher.rs
index 64a4a3fa741..2b2ea156cd4 100644
--- a/clippy_lints/src/implicit_hasher.rs
+++ b/clippy_lints/src/implicit_hasher.rs
@@ -6,9 +6,8 @@ use rustc_hir as hir;
 use rustc_hir::intravisit::{walk_body, walk_expr, walk_inf, walk_ty, Visitor};
 use rustc_hir::{Body, Expr, ExprKind, GenericArg, Item, ItemKind, QPath, TyKind};
 use rustc_hir_analysis::hir_ty_to_ty;
-use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::nested_filter;
-use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::{Ty, TypeckResults};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
@@ -162,7 +161,7 @@ impl<'tcx> LateLintPass<'tcx> for ImplicitHasher {
                     vis.visit_ty(ty);
 
                     for target in &vis.found {
-                        if in_external_macro(cx.sess(), generics.span) {
+                        if generics.span.from_expansion() {
                             continue;
                         }
                         let generics_suggestion_span = generics.span.substitute_dummy({
-- 
cgit 1.4.1-3-g733a5


From 258b9a856273a0e6bbf6becd1dd769cb20228815 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Mon, 31 Jul 2023 20:22:39 +0000
Subject: Don't escape unicode escape braces in print_literal

---
 clippy_lints/src/write.rs     | 50 ++++++++++++++++++++--
 tests/ui/print_literal.fixed  | 14 +++++++
 tests/ui/print_literal.rs     | 14 +++++++
 tests/ui/print_literal.stderr | 98 ++++++++++++++++++++++++++++++++++++++++++-
 4 files changed, 172 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs
index 21b675ff679..855aefa70cb 100644
--- a/clippy_lints/src/write.rs
+++ b/clippy_lints/src/write.rs
@@ -486,9 +486,9 @@ fn check_literal(cx: &LateContext<'_>, format_args: &FormatArgs, name: &str) {
             && let rustc_ast::ExprKind::Lit(lit) = &arg.expr.kind
             && !arg.expr.span.from_expansion()
             && let Some(value_string) = snippet_opt(cx, arg.expr.span)
-    {
+        {
             let (replacement, replace_raw) = match lit.kind {
-                LitKind::Str | LitKind::StrRaw(_)  => match extract_str_literal(&value_string) {
+                LitKind::Str | LitKind::StrRaw(_) => match extract_str_literal(&value_string) {
                     Some(extracted) => extracted,
                     None => return,
                 },
@@ -538,7 +538,7 @@ fn check_literal(cx: &LateContext<'_>, format_args: &FormatArgs, name: &str) {
                 // `format!("{}", "a")`, `format!("{named}", named = "b")
                 //              ~~~~~                      ~~~~~~~~~~~~~
                 && let Some(removal_span) = format_arg_removal_span(format_args, index) {
-                let replacement = replacement.replace('{', "{{").replace('}', "}}");
+                let replacement = escape_braces(&replacement, !format_string_is_raw && !replace_raw);
                 suggestion.push((*placeholder_span, replacement));
                 suggestion.push((removal_span, String::new()));
             }
@@ -631,3 +631,47 @@ fn conservative_unescape(literal: &str) -> Result<String, UnescapeErr> {
 
     if err { Err(UnescapeErr::Lint) } else { Ok(unescaped) }
 }
+
+/// Replaces `{` with `{{` and `}` with `}}`. If `preserve_unicode_escapes` is `true` the braces in
+/// `\u{xxxx}` are left unmodified
+#[expect(clippy::match_same_arms)]
+fn escape_braces(literal: &str, preserve_unicode_escapes: bool) -> String {
+    #[derive(Clone, Copy)]
+    enum State {
+        Normal,
+        Backslash,
+        UnicodeEscape,
+    }
+
+    let mut escaped = String::with_capacity(literal.len());
+    let mut state = State::Normal;
+
+    for ch in literal.chars() {
+        state = match (ch, state) {
+            // Escape braces outside of unicode escapes by doubling them up
+            ('{' | '}', State::Normal) => {
+                escaped.push(ch);
+                State::Normal
+            },
+            // If `preserve_unicode_escapes` isn't enabled stay in `State::Normal`, otherwise:
+            //
+            // \u{aaaa} \\ \x01
+            // ^        ^  ^
+            ('\\', State::Normal) if preserve_unicode_escapes => State::Backslash,
+            // \u{aaaa}
+            //  ^
+            ('u', State::Backslash) => State::UnicodeEscape,
+            // \xAA \\
+            //  ^    ^
+            (_, State::Backslash) => State::Normal,
+            // \u{aaaa}
+            //        ^
+            ('}', State::UnicodeEscape) => State::Normal,
+            _ => state,
+        };
+
+        escaped.push(ch);
+    }
+
+    escaped
+}
diff --git a/tests/ui/print_literal.fixed b/tests/ui/print_literal.fixed
index 04a484258a4..a7157c07f8a 100644
--- a/tests/ui/print_literal.fixed
+++ b/tests/ui/print_literal.fixed
@@ -51,4 +51,18 @@ fn main() {
     // The string literal from `file!()` has a callsite span that isn't marked as coming from an
     // expansion
     println!("file: {}", file!());
+
+    // Braces in unicode escapes should not be escaped
+    println!("{{}} \x00 \u{ab123} \\\u{ab123} {{:?}}");
+    println!("\\\u{1234}");
+    // This does not lint because it would have to suggest unescaping the character
+    println!(r"{}", "\u{ab123}");
+    // These are not unicode escapes
+    println!("\\u{{ab123}} \\u{{{{");
+    println!(r"\u{{ab123}} \u{{{{");
+    println!("\\{{ab123}} \\u{{{{");
+    println!("\\u{{ab123}}");
+    println!("\\\\u{{1234}}");
+
+    println!("mixed: {{hello}} {world}");
 }
diff --git a/tests/ui/print_literal.rs b/tests/ui/print_literal.rs
index 38c036f56c5..4b04b42744c 100644
--- a/tests/ui/print_literal.rs
+++ b/tests/ui/print_literal.rs
@@ -51,4 +51,18 @@ fn main() {
     // The string literal from `file!()` has a callsite span that isn't marked as coming from an
     // expansion
     println!("file: {}", file!());
+
+    // Braces in unicode escapes should not be escaped
+    println!("{}", "{} \x00 \u{ab123} \\\u{ab123} {:?}");
+    println!("{}", "\\\u{1234}");
+    // This does not lint because it would have to suggest unescaping the character
+    println!(r"{}", "\u{ab123}");
+    // These are not unicode escapes
+    println!("{}", r"\u{ab123} \u{{");
+    println!(r"{}", r"\u{ab123} \u{{");
+    println!("{}", r"\{ab123} \u{{");
+    println!("{}", "\\u{ab123}");
+    println!("{}", "\\\\u{1234}");
+
+    println!("mixed: {} {world}", "{hello}");
 }
diff --git a/tests/ui/print_literal.stderr b/tests/ui/print_literal.stderr
index b2f85be9d94..8c011d7bc0a 100644
--- a/tests/ui/print_literal.stderr
+++ b/tests/ui/print_literal.stderr
@@ -96,5 +96,101 @@ LL -     println!("{bar} {foo}", foo = "hello", bar = "world");
 LL +     println!("world hello");
    |
 
-error: aborting due to 8 previous errors
+error: literal with an empty format string
+  --> $DIR/print_literal.rs:56:20
+   |
+LL |     println!("{}", "{} \x00 \u{ab123} \\\u{ab123} {:?}");
+   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: try
+   |
+LL -     println!("{}", "{} \x00 \u{ab123} \\\u{ab123} {:?}");
+LL +     println!("{{}} \x00 \u{ab123} \\\u{ab123} {{:?}}");
+   |
+
+error: literal with an empty format string
+  --> $DIR/print_literal.rs:57:20
+   |
+LL |     println!("{}", "\\\u{1234}");
+   |                    ^^^^^^^^^^^^
+   |
+help: try
+   |
+LL -     println!("{}", "\\\u{1234}");
+LL +     println!("\\\u{1234}");
+   |
+
+error: literal with an empty format string
+  --> $DIR/print_literal.rs:61:20
+   |
+LL |     println!("{}", r"\u{ab123} \u{{");
+   |                    ^^^^^^^^^^^^^^^^^
+   |
+help: try
+   |
+LL -     println!("{}", r"\u{ab123} \u{{");
+LL +     println!("\\u{{ab123}} \\u{{{{");
+   |
+
+error: literal with an empty format string
+  --> $DIR/print_literal.rs:62:21
+   |
+LL |     println!(r"{}", r"\u{ab123} \u{{");
+   |                     ^^^^^^^^^^^^^^^^^
+   |
+help: try
+   |
+LL -     println!(r"{}", r"\u{ab123} \u{{");
+LL +     println!(r"\u{{ab123}} \u{{{{");
+   |
+
+error: literal with an empty format string
+  --> $DIR/print_literal.rs:63:20
+   |
+LL |     println!("{}", r"\{ab123} \u{{");
+   |                    ^^^^^^^^^^^^^^^^
+   |
+help: try
+   |
+LL -     println!("{}", r"\{ab123} \u{{");
+LL +     println!("\\{{ab123}} \\u{{{{");
+   |
+
+error: literal with an empty format string
+  --> $DIR/print_literal.rs:64:20
+   |
+LL |     println!("{}", "\\u{ab123}");
+   |                    ^^^^^^^^^^^^
+   |
+help: try
+   |
+LL -     println!("{}", "\\u{ab123}");
+LL +     println!("\\u{{ab123}}");
+   |
+
+error: literal with an empty format string
+  --> $DIR/print_literal.rs:65:20
+   |
+LL |     println!("{}", "\\\\u{1234}");
+   |                    ^^^^^^^^^^^^^
+   |
+help: try
+   |
+LL -     println!("{}", "\\\\u{1234}");
+LL +     println!("\\\\u{{1234}}");
+   |
+
+error: literal with an empty format string
+  --> $DIR/print_literal.rs:67:35
+   |
+LL |     println!("mixed: {} {world}", "{hello}");
+   |                                   ^^^^^^^^^
+   |
+help: try
+   |
+LL -     println!("mixed: {} {world}", "{hello}");
+LL +     println!("mixed: {{hello}} {world}");
+   |
+
+error: aborting due to 16 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 3f0da4dda29c1dd058ab2ee0f4ddf3ff0d8a8bac Mon Sep 17 00:00:00 2001
From: blyxyas <blyxyas@gmail.com>
Date: Mon, 2 Oct 2023 13:28:45 +0200
Subject: Move `needless_pass_by_ref_mut`: `suspicious` -> `nursery`

---
 clippy_lints/src/needless_pass_by_ref_mut.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/needless_pass_by_ref_mut.rs b/clippy_lints/src/needless_pass_by_ref_mut.rs
index 57652e5ff54..3ad9ae0301a 100644
--- a/clippy_lints/src/needless_pass_by_ref_mut.rs
+++ b/clippy_lints/src/needless_pass_by_ref_mut.rs
@@ -49,7 +49,7 @@ declare_clippy_lint! {
     /// ```
     #[clippy::version = "1.72.0"]
     pub NEEDLESS_PASS_BY_REF_MUT,
-    suspicious,
+    nursery,
     "using a `&mut` argument when it's not mutated"
 }
 
-- 
cgit 1.4.1-3-g733a5


From e465264d47fbe0a19c620e320c1b5dbeae446f1e Mon Sep 17 00:00:00 2001
From: koka <koka.code@gmail.com>
Date: Tue, 3 Oct 2023 20:36:35 +0900
Subject: Avoid invoking `ignored_unit_patterns` in macro definition

---
 clippy_lints/src/ignored_unit_patterns.rs |  4 ++++
 tests/ui/auxiliary/proc_macro_derive.rs   | 16 ++++++++++++++++
 tests/ui/ignored_unit_patterns.fixed      | 15 +++++++++++++++
 tests/ui/ignored_unit_patterns.rs         | 15 +++++++++++++++
 tests/ui/ignored_unit_patterns.stderr     | 24 ++++++++++++++++++------
 5 files changed, 68 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/ignored_unit_patterns.rs b/clippy_lints/src/ignored_unit_patterns.rs
index d8ead1c9d9f..ef2a66d4a20 100644
--- a/clippy_lints/src/ignored_unit_patterns.rs
+++ b/clippy_lints/src/ignored_unit_patterns.rs
@@ -37,6 +37,10 @@ declare_lint_pass!(IgnoredUnitPatterns => [IGNORED_UNIT_PATTERNS]);
 
 impl<'tcx> LateLintPass<'tcx> for IgnoredUnitPatterns {
     fn check_pat(&mut self, cx: &LateContext<'tcx>, pat: &'tcx hir::Pat<'tcx>) {
+        if pat.span.from_expansion() {
+            return;
+        }
+
         match cx.tcx.hir().get_parent(pat.hir_id) {
             Node::Param(param) if matches!(cx.tcx.hir().get_parent(param.hir_id), Node::Item(_)) => {
                 // Ignore function parameters
diff --git a/tests/ui/auxiliary/proc_macro_derive.rs b/tests/ui/auxiliary/proc_macro_derive.rs
index 556b886f386..79a95d775b1 100644
--- a/tests/ui/auxiliary/proc_macro_derive.rs
+++ b/tests/ui/auxiliary/proc_macro_derive.rs
@@ -153,3 +153,19 @@ pub fn shadow_derive(_: TokenStream) -> TokenStream {
         .into(),
     ])
 }
+
+#[proc_macro_derive(StructIgnoredUnitPattern)]
+pub fn derive_ignored_unit_pattern(_: TokenStream) -> TokenStream {
+    quote! {
+        struct A;
+        impl A {
+            fn a(&self) -> Result<(), ()> {
+                unimplemented!()
+            }
+
+            pub fn b(&self) {
+                let _ = self.a().unwrap();
+            }
+        }
+    }
+}
diff --git a/tests/ui/ignored_unit_patterns.fixed b/tests/ui/ignored_unit_patterns.fixed
index 6c6f21fee16..15eaf1f659a 100644
--- a/tests/ui/ignored_unit_patterns.fixed
+++ b/tests/ui/ignored_unit_patterns.fixed
@@ -1,3 +1,4 @@
+//@aux-build:proc_macro_derive.rs
 #![warn(clippy::ignored_unit_patterns)]
 #![allow(clippy::let_unit_value, clippy::redundant_pattern_matching, clippy::single_match)]
 
@@ -14,8 +15,22 @@ fn main() {
     //~^ ERROR: matching over `()` is more explicit
     let _ = foo().map_err(|()| todo!());
     //~^ ERROR: matching over `()` is more explicit
+
+    println!(
+        "{:?}",
+        match foo() {
+            Ok(()) => {},
+            //~^ ERROR: matching over `()` is more explicit
+            Err(()) => {},
+            //~^ ERROR: matching over `()` is more explicit
+        }
+    );
 }
 
+// ignored_unit_patterns in derive macro should be ok
+#[derive(proc_macro_derive::StructIgnoredUnitPattern)]
+pub struct B;
+
 #[allow(unused)]
 pub fn moo(_: ()) {
     let () = foo().unwrap();
diff --git a/tests/ui/ignored_unit_patterns.rs b/tests/ui/ignored_unit_patterns.rs
index 5e8c2e03ba2..9cac3a440ab 100644
--- a/tests/ui/ignored_unit_patterns.rs
+++ b/tests/ui/ignored_unit_patterns.rs
@@ -1,3 +1,4 @@
+//@aux-build:proc_macro_derive.rs
 #![warn(clippy::ignored_unit_patterns)]
 #![allow(clippy::let_unit_value, clippy::redundant_pattern_matching, clippy::single_match)]
 
@@ -14,8 +15,22 @@ fn main() {
     //~^ ERROR: matching over `()` is more explicit
     let _ = foo().map_err(|_| todo!());
     //~^ ERROR: matching over `()` is more explicit
+
+    println!(
+        "{:?}",
+        match foo() {
+            Ok(_) => {},
+            //~^ ERROR: matching over `()` is more explicit
+            Err(_) => {},
+            //~^ ERROR: matching over `()` is more explicit
+        }
+    );
 }
 
+// ignored_unit_patterns in derive macro should be ok
+#[derive(proc_macro_derive::StructIgnoredUnitPattern)]
+pub struct B;
+
 #[allow(unused)]
 pub fn moo(_: ()) {
     let _ = foo().unwrap();
diff --git a/tests/ui/ignored_unit_patterns.stderr b/tests/ui/ignored_unit_patterns.stderr
index df5e1d89e90..cac01a87dba 100644
--- a/tests/ui/ignored_unit_patterns.stderr
+++ b/tests/ui/ignored_unit_patterns.stderr
@@ -1,5 +1,5 @@
 error: matching over `()` is more explicit
-  --> $DIR/ignored_unit_patterns.rs:10:12
+  --> $DIR/ignored_unit_patterns.rs:11:12
    |
 LL |         Ok(_) => {},
    |            ^ help: use `()` instead of `_`: `()`
@@ -8,28 +8,40 @@ LL |         Ok(_) => {},
    = help: to override `-D warnings` add `#[allow(clippy::ignored_unit_patterns)]`
 
 error: matching over `()` is more explicit
-  --> $DIR/ignored_unit_patterns.rs:11:13
+  --> $DIR/ignored_unit_patterns.rs:12:13
    |
 LL |         Err(_) => {},
    |             ^ help: use `()` instead of `_`: `()`
 
 error: matching over `()` is more explicit
-  --> $DIR/ignored_unit_patterns.rs:13:15
+  --> $DIR/ignored_unit_patterns.rs:14:15
    |
 LL |     if let Ok(_) = foo() {}
    |               ^ help: use `()` instead of `_`: `()`
 
 error: matching over `()` is more explicit
-  --> $DIR/ignored_unit_patterns.rs:15:28
+  --> $DIR/ignored_unit_patterns.rs:16:28
    |
 LL |     let _ = foo().map_err(|_| todo!());
    |                            ^ help: use `()` instead of `_`: `()`
 
 error: matching over `()` is more explicit
-  --> $DIR/ignored_unit_patterns.rs:21:9
+  --> $DIR/ignored_unit_patterns.rs:22:16
+   |
+LL |             Ok(_) => {},
+   |                ^ help: use `()` instead of `_`: `()`
+
+error: matching over `()` is more explicit
+  --> $DIR/ignored_unit_patterns.rs:24:17
+   |
+LL |             Err(_) => {},
+   |                 ^ help: use `()` instead of `_`: `()`
+
+error: matching over `()` is more explicit
+  --> $DIR/ignored_unit_patterns.rs:36:9
    |
 LL |     let _ = foo().unwrap();
    |         ^ help: use `()` instead of `_`: `()`
 
-error: aborting due to 5 previous errors
+error: aborting due to 7 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 1a56f90ee5ff65020e9992dd6e434e9ec0e46435 Mon Sep 17 00:00:00 2001
From: koka <koka.code@gmail.com>
Date: Tue, 3 Oct 2023 21:22:54 +0900
Subject: Fix: avoid changing drop order

---
 clippy_lints/src/redundant_locals.rs | 10 ++++++++++
 tests/ui/redundant_locals.rs         | 17 +++++++++++++++++
 tests/ui/redundant_locals.stderr     | 13 ++++++++++++-
 3 files changed, 39 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/redundant_locals.rs b/clippy_lints/src/redundant_locals.rs
index a1ebba6a6a8..fd0506a658f 100644
--- a/clippy_lints/src/redundant_locals.rs
+++ b/clippy_lints/src/redundant_locals.rs
@@ -4,11 +4,13 @@ use clippy_utils::ty::needs_ordered_drop;
 use rustc_ast::Mutability;
 use rustc_hir::def::Res;
 use rustc_hir::{BindingAnnotation, ByRef, Expr, ExprKind, HirId, Local, Node, Pat, PatKind, QPath};
+use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::symbol::Ident;
 use rustc_span::DesugaringKind;
+use rustc_trait_selection::infer::InferCtxtExt as _;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -70,6 +72,14 @@ impl<'tcx> LateLintPass<'tcx> for RedundantLocals {
             // the local is user-controlled
             if !in_external_macro(cx.sess(), local.span);
             if !is_from_proc_macro(cx, expr);
+            // the local does not impl Drop trait. see #11599
+            let local_ty = cx.typeck_results().node_type(local.hir_id);
+            if let Some(drop_trait_id) = cx.tcx.lang_items().drop_trait();
+            if !cx.tcx.infer_ctxt().build().type_implements_trait(
+              drop_trait_id,
+              [local_ty],
+              cx.param_env
+            ).must_apply_modulo_regions();
             then {
                 span_lint_and_help(
                     cx,
diff --git a/tests/ui/redundant_locals.rs b/tests/ui/redundant_locals.rs
index c5d93e4365d..985bc739b26 100644
--- a/tests/ui/redundant_locals.rs
+++ b/tests/ui/redundant_locals.rs
@@ -118,3 +118,20 @@ fn macros() {
         let x = x;
     }
 }
+
+struct WithDrop(usize);
+impl Drop for WithDrop {
+    fn drop(&mut self) {}
+}
+
+struct WithoutDrop(usize);
+
+fn drop_trait() {
+    let a = WithDrop(1);
+    let b = WithDrop(2);
+    let a = a;
+
+    let c = WithoutDrop(1);
+    let d = WithoutDrop(2);
+    let c = c;
+}
diff --git a/tests/ui/redundant_locals.stderr b/tests/ui/redundant_locals.stderr
index 13b872e9576..9f8dc6e6162 100644
--- a/tests/ui/redundant_locals.stderr
+++ b/tests/ui/redundant_locals.stderr
@@ -133,5 +133,16 @@ LL |         let x = x;
    |
    = help: remove the redefinition of `x`
 
-error: aborting due to 13 previous errors
+error: redundant redefinition of a binding
+  --> $DIR/redundant_locals.rs:134:9
+   |
+LL |     let c = WithoutDrop(1);
+   |         ^
+LL |     let d = WithoutDrop(2);
+LL |     let c = c;
+   |     ^^^^^^^^^^
+   |
+   = help: remove the redefinition of `c`
+
+error: aborting due to 14 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From c7152679efd5cd7c433f77eae2109170e4cc34e8 Mon Sep 17 00:00:00 2001
From: koka <koka.code@gmail.com>
Date: Wed, 4 Oct 2023 00:13:53 +0900
Subject: Apply review suggestions from @y21

---
 clippy_lints/src/redundant_locals.rs | 24 ++----------------------
 tests/ui/redundant_locals.rs         | 26 +++++++++++++++++++++++---
 tests/ui/redundant_locals.stderr     | 10 +++++-----
 3 files changed, 30 insertions(+), 30 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/redundant_locals.rs b/clippy_lints/src/redundant_locals.rs
index fd0506a658f..a26bb98c5e2 100644
--- a/clippy_lints/src/redundant_locals.rs
+++ b/clippy_lints/src/redundant_locals.rs
@@ -3,14 +3,12 @@ use clippy_utils::is_from_proc_macro;
 use clippy_utils::ty::needs_ordered_drop;
 use rustc_ast::Mutability;
 use rustc_hir::def::Res;
-use rustc_hir::{BindingAnnotation, ByRef, Expr, ExprKind, HirId, Local, Node, Pat, PatKind, QPath};
-use rustc_infer::infer::TyCtxtInferExt;
+use rustc_hir::{BindingAnnotation, ByRef, ExprKind, HirId, Local, Node, Pat, PatKind, QPath};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::symbol::Ident;
 use rustc_span::DesugaringKind;
-use rustc_trait_selection::infer::InferCtxtExt as _;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -68,18 +66,10 @@ impl<'tcx> LateLintPass<'tcx> for RedundantLocals {
             // the local does not change the effect of assignments to the binding. see #11290
             if !affects_assignments(cx, mutability, binding_id, local.hir_id);
             // the local does not affect the code's drop behavior
-            if !affects_drop_behavior(cx, binding_id, local.hir_id, expr);
+            if !needs_ordered_drop(cx, cx.typeck_results().expr_ty(expr));
             // the local is user-controlled
             if !in_external_macro(cx.sess(), local.span);
             if !is_from_proc_macro(cx, expr);
-            // the local does not impl Drop trait. see #11599
-            let local_ty = cx.typeck_results().node_type(local.hir_id);
-            if let Some(drop_trait_id) = cx.tcx.lang_items().drop_trait();
-            if !cx.tcx.infer_ctxt().build().type_implements_trait(
-              drop_trait_id,
-              [local_ty],
-              cx.param_env
-            ).must_apply_modulo_regions();
             then {
                 span_lint_and_help(
                     cx,
@@ -114,13 +104,3 @@ fn affects_assignments(cx: &LateContext<'_>, mutability: Mutability, bind: HirId
     // the binding is mutable and the rebinding is in a different scope than the original binding
     mutability == Mutability::Mut && hir.get_enclosing_scope(bind) != hir.get_enclosing_scope(rebind)
 }
-
-/// Check if a rebinding of a local affects the code's drop behavior.
-fn affects_drop_behavior<'tcx>(cx: &LateContext<'tcx>, bind: HirId, rebind: HirId, rebind_expr: &Expr<'tcx>) -> bool {
-    let hir = cx.tcx.hir();
-
-    // the rebinding is in a different scope than the original binding
-    // and the type of the binding cares about drop order
-    hir.get_enclosing_scope(bind) != hir.get_enclosing_scope(rebind)
-        && needs_ordered_drop(cx, cx.typeck_results().expr_ty(rebind_expr))
-}
diff --git a/tests/ui/redundant_locals.rs b/tests/ui/redundant_locals.rs
index 985bc739b26..e81db300f15 100644
--- a/tests/ui/redundant_locals.rs
+++ b/tests/ui/redundant_locals.rs
@@ -124,14 +124,34 @@ impl Drop for WithDrop {
     fn drop(&mut self) {}
 }
 
+struct InnerDrop(WithDrop);
+
+struct ComposeDrop {
+    d: WithDrop,
+}
+
 struct WithoutDrop(usize);
 
 fn drop_trait() {
     let a = WithDrop(1);
     let b = WithDrop(2);
     let a = a;
+}
 
-    let c = WithoutDrop(1);
-    let d = WithoutDrop(2);
-    let c = c;
+fn without_drop() {
+    let a = WithoutDrop(1);
+    let b = WithoutDrop(2);
+    let a = a;
+}
+
+fn drop_inner() {
+    let a = InnerDrop(WithDrop(1));
+    let b = InnerDrop(WithDrop(2));
+    let a = a;
+}
+
+fn drop_compose() {
+    let a = ComposeDrop { d: WithDrop(1) };
+    let b = ComposeDrop { d: WithDrop(1) };
+    let a = a;
 }
diff --git a/tests/ui/redundant_locals.stderr b/tests/ui/redundant_locals.stderr
index 9f8dc6e6162..6e9da8fccbd 100644
--- a/tests/ui/redundant_locals.stderr
+++ b/tests/ui/redundant_locals.stderr
@@ -134,15 +134,15 @@ LL |         let x = x;
    = help: remove the redefinition of `x`
 
 error: redundant redefinition of a binding
-  --> $DIR/redundant_locals.rs:134:9
+  --> $DIR/redundant_locals.rs:142:9
    |
-LL |     let c = WithoutDrop(1);
+LL |     let a = WithoutDrop(1);
    |         ^
-LL |     let d = WithoutDrop(2);
-LL |     let c = c;
+LL |     let b = WithoutDrop(2);
+LL |     let a = a;
    |     ^^^^^^^^^^
    |
-   = help: remove the redefinition of `c`
+   = help: remove the redefinition of `a`
 
 error: aborting due to 14 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From eab0a75ff942598a57c93f78000a8a9dbb3af9b7 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Wed, 4 Oct 2023 01:04:00 +0200
Subject: Update version attribute for 1.73 lints

---
 clippy_lints/src/error_impl_error.rs         |  2 +-
 clippy_lints/src/four_forward_slashes.rs     |  2 +-
 clippy_lints/src/manual_float_methods.rs     |  4 ++--
 clippy_lints/src/matches/mod.rs              |  2 +-
 clippy_lints/src/methods/mod.rs              | 12 ++++++------
 clippy_lints/src/needless_pass_by_ref_mut.rs |  2 +-
 clippy_lints/src/non_canonical_impls.rs      |  2 +-
 clippy_lints/src/operators/mod.rs            |  4 ++--
 clippy_lints/src/redundant_locals.rs         |  2 +-
 9 files changed, 16 insertions(+), 16 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/error_impl_error.rs b/clippy_lints/src/error_impl_error.rs
index f24577c7382..6d429fbd035 100644
--- a/clippy_lints/src/error_impl_error.rs
+++ b/clippy_lints/src/error_impl_error.rs
@@ -27,7 +27,7 @@ declare_clippy_lint! {
     ///
     /// impl std::error::Error for Error { ... }
     /// ```
-    #[clippy::version = "1.72.0"]
+    #[clippy::version = "1.73.0"]
     pub ERROR_IMPL_ERROR,
     restriction,
     "exported types named `Error` that implement `Error`"
diff --git a/clippy_lints/src/four_forward_slashes.rs b/clippy_lints/src/four_forward_slashes.rs
index 419c7734344..0ec52f89e71 100644
--- a/clippy_lints/src/four_forward_slashes.rs
+++ b/clippy_lints/src/four_forward_slashes.rs
@@ -28,7 +28,7 @@ declare_clippy_lint! {
     ///     // ...
     /// }
     /// ```
-    #[clippy::version = "1.72.0"]
+    #[clippy::version = "1.73.0"]
     pub FOUR_FORWARD_SLASHES,
     suspicious,
     "comments with 4 forward slashes (`////`) likely intended to be doc comments (`///`)"
diff --git a/clippy_lints/src/manual_float_methods.rs b/clippy_lints/src/manual_float_methods.rs
index 88db7ae6aec..ed9189a1804 100644
--- a/clippy_lints/src/manual_float_methods.rs
+++ b/clippy_lints/src/manual_float_methods.rs
@@ -26,7 +26,7 @@ declare_clippy_lint! {
     /// # let x = 1.0f32;
     /// if x.is_infinite() {}
     /// ```
-    #[clippy::version = "1.72.0"]
+    #[clippy::version = "1.73.0"]
     pub MANUAL_IS_INFINITE,
     style,
     "use dedicated method to check if a float is infinite"
@@ -51,7 +51,7 @@ declare_clippy_lint! {
     /// if x.is_finite() {}
     /// if x.is_finite() {}
     /// ```
-    #[clippy::version = "1.72.0"]
+    #[clippy::version = "1.73.0"]
     pub MANUAL_IS_FINITE,
     style,
     "use dedicated method to check if a float is finite"
diff --git a/clippy_lints/src/matches/mod.rs b/clippy_lints/src/matches/mod.rs
index 930386a60aa..a23000e5fe1 100644
--- a/clippy_lints/src/matches/mod.rs
+++ b/clippy_lints/src/matches/mod.rs
@@ -961,7 +961,7 @@ declare_clippy_lint! {
     ///     _ => todo!(),
     /// }
     /// ```
-    #[clippy::version = "1.72.0"]
+    #[clippy::version = "1.73.0"]
     pub REDUNDANT_GUARDS,
     complexity,
     "checks for unnecessary guards in match expressions"
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 7b743382fa1..a935aea5075 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -2970,7 +2970,7 @@ declare_clippy_lint! {
     /// assert_eq!((*any_box).type_id(), TypeId::of::<i32>());
     /// //          ^ dereference first, to call `type_id` on `dyn Any`
     /// ```
-    #[clippy::version = "1.72.0"]
+    #[clippy::version = "1.73.0"]
     pub TYPE_ID_ON_BOX,
     suspicious,
     "calling `.type_id()` on `Box<dyn Any>`"
@@ -3391,7 +3391,7 @@ declare_clippy_lint! {
     /// //                  ^^^^^^^^^^^ remove the trailing newline
     /// assert_eq!(num, 42);
     /// ```
-    #[clippy::version = "1.72.0"]
+    #[clippy::version = "1.73.0"]
     pub READ_LINE_WITHOUT_TRIM,
     correctness,
     "calling `Stdin::read_line`, then trying to parse it without first trimming"
@@ -3419,7 +3419,7 @@ declare_clippy_lint! {
     /// # let c = 'c';
     /// matches!(c, '\\' | '.' | '+' | '*' | '(' | ')' | '|' | '[' | ']' | '{' | '}' | '^' | '$' | '#' | '&' | '-' | '~');
     /// ```
-    #[clippy::version = "1.72.0"]
+    #[clippy::version = "1.73.0"]
     pub STRING_LIT_CHARS_ANY,
     restriction,
     "checks for `<string_lit>.chars().any(|i| i == c)`"
@@ -3454,7 +3454,7 @@ declare_clippy_lint! {
     ///     })
     /// }
     /// ```
-    #[clippy::version = "1.72.0"]
+    #[clippy::version = "1.73.0"]
     pub FORMAT_COLLECT,
     perf,
     "`format!`ing every element in a collection, then collecting the strings into a new `String`"
@@ -3475,7 +3475,7 @@ declare_clippy_lint! {
     /// let y = v.iter().collect::<Vec<_>>();
     /// assert_eq!(x, y);
     /// ```
-    #[clippy::version = "1.72.0"]
+    #[clippy::version = "1.73.0"]
     pub ITER_SKIP_ZERO,
     correctness,
     "disallows `.skip(0)`"
@@ -3506,7 +3506,7 @@ declare_clippy_lint! {
     /// # let v = vec![];
     /// _ = v.into_iter().filter(|i| i % 2 == 0).map(|i| really_expensive_fn(i));
     /// ```
-    #[clippy::version = "1.72.0"]
+    #[clippy::version = "1.73.0"]
     pub FILTER_MAP_BOOL_THEN,
     style,
     "checks for usage of `bool::then` in `Iterator::filter_map`"
diff --git a/clippy_lints/src/needless_pass_by_ref_mut.rs b/clippy_lints/src/needless_pass_by_ref_mut.rs
index 3ad9ae0301a..212d6234bdb 100644
--- a/clippy_lints/src/needless_pass_by_ref_mut.rs
+++ b/clippy_lints/src/needless_pass_by_ref_mut.rs
@@ -47,7 +47,7 @@ declare_clippy_lint! {
     ///     12 + *y
     /// }
     /// ```
-    #[clippy::version = "1.72.0"]
+    #[clippy::version = "1.73.0"]
     pub NEEDLESS_PASS_BY_REF_MUT,
     nursery,
     "using a `&mut` argument when it's not mutated"
diff --git a/clippy_lints/src/non_canonical_impls.rs b/clippy_lints/src/non_canonical_impls.rs
index 20b4b4f03ed..f159c261d11 100644
--- a/clippy_lints/src/non_canonical_impls.rs
+++ b/clippy_lints/src/non_canonical_impls.rs
@@ -103,7 +103,7 @@ declare_clippy_lint! {
     ///     }
     /// }
     /// ```
-    #[clippy::version = "1.72.0"]
+    #[clippy::version = "1.73.0"]
     pub NON_CANONICAL_PARTIAL_ORD_IMPL,
     suspicious,
     "non-canonical implementation of `PartialOrd` on an `Ord` type"
diff --git a/clippy_lints/src/operators/mod.rs b/clippy_lints/src/operators/mod.rs
index 4635e1164cd..6b247cf5f6a 100644
--- a/clippy_lints/src/operators/mod.rs
+++ b/clippy_lints/src/operators/mod.rs
@@ -312,7 +312,7 @@ declare_clippy_lint! {
     /// # let status_code = 200;
     /// if status_code <= 400 && status_code > 500 {}
     /// ```
-    #[clippy::version = "1.71.0"]
+    #[clippy::version = "1.73.0"]
     pub IMPOSSIBLE_COMPARISONS,
     correctness,
     "double comparisons that will never evaluate to `true`"
@@ -332,7 +332,7 @@ declare_clippy_lint! {
     /// # let status_code = 200;
     /// if status_code <= 400 && status_code < 500 {}
     /// ```
-    #[clippy::version = "1.71.0"]
+    #[clippy::version = "1.73.0"]
     pub REDUNDANT_COMPARISONS,
     correctness,
     "double comparisons where one of them can be removed"
diff --git a/clippy_lints/src/redundant_locals.rs b/clippy_lints/src/redundant_locals.rs
index a26bb98c5e2..7864ff3e8ff 100644
--- a/clippy_lints/src/redundant_locals.rs
+++ b/clippy_lints/src/redundant_locals.rs
@@ -37,7 +37,7 @@ declare_clippy_lint! {
     ///   // no redefinition with the same name
     /// }
     /// ```
-    #[clippy::version = "1.72.0"]
+    #[clippy::version = "1.73.0"]
     pub REDUNDANT_LOCALS,
     correctness,
     "redundant redefinition of a local binding"
-- 
cgit 1.4.1-3-g733a5


From 31fd282732e15811e916d216d5badd0a56361dd3 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Wed, 4 Oct 2023 18:07:54 +0200
Subject: [`get_first`]: lint on non-primitive types

---
 clippy_lints/src/methods/get_first.rs |  2 --
 tests/ui/get_first.fixed              | 13 ++++++++++---
 tests/ui/get_first.rs                 | 13 ++++++++++---
 tests/ui/get_first.stderr             | 18 ++++++++++++------
 4 files changed, 32 insertions(+), 14 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/get_first.rs b/clippy_lints/src/methods/get_first.rs
index ee063adac64..e7b4564c651 100644
--- a/clippy_lints/src/methods/get_first.rs
+++ b/clippy_lints/src/methods/get_first.rs
@@ -1,5 +1,4 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::is_slice_of_primitives;
 use clippy_utils::source::snippet_with_applicability;
 use if_chain::if_chain;
 use rustc_ast::LitKind;
@@ -20,7 +19,6 @@ pub(super) fn check<'tcx>(
         if let Some(method_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
         if let Some(impl_id) = cx.tcx.impl_of_method(method_id);
         if cx.tcx.type_of(impl_id).instantiate_identity().is_slice();
-        if let Some(_) = is_slice_of_primitives(cx, recv);
         if let hir::ExprKind::Lit(Spanned { node: LitKind::Int(0, _), .. }) = arg.kind;
         then {
             let mut app = Applicability::MachineApplicable;
diff --git a/tests/ui/get_first.fixed b/tests/ui/get_first.fixed
index b1a597fc4dd..a7cdd2a93ba 100644
--- a/tests/ui/get_first.fixed
+++ b/tests/ui/get_first.fixed
@@ -14,17 +14,20 @@ impl Bar {
 
 fn main() {
     let x = vec![2, 3, 5];
-    let _ = x.first(); // Use x.first()
+    let _ = x.first();
+    //~^ ERROR: accessing first element with `x.get(0)`
     let _ = x.get(1);
     let _ = x[0];
 
     let y = [2, 3, 5];
-    let _ = y.first(); // Use y.first()
+    let _ = y.first();
+    //~^ ERROR: accessing first element with `y.get(0)`
     let _ = y.get(1);
     let _ = y[0];
 
     let z = &[2, 3, 5];
-    let _ = z.first(); // Use z.first()
+    let _ = z.first();
+    //~^ ERROR: accessing first element with `z.get(0)`
     let _ = z.get(1);
     let _ = z[0];
 
@@ -37,4 +40,8 @@ fn main() {
 
     let bar = Bar { arr: [0, 1, 2] };
     let _ = bar.get(0); // Do not lint, because Bar is struct.
+
+    let non_primitives = [vec![1, 2], vec![3, 4]];
+    let _ = non_primitives.first();
+    //~^ ERROR: accessing first element with `non_primitives.get(0)`
 }
diff --git a/tests/ui/get_first.rs b/tests/ui/get_first.rs
index e27ee4be8c0..cca743c4bf5 100644
--- a/tests/ui/get_first.rs
+++ b/tests/ui/get_first.rs
@@ -14,17 +14,20 @@ impl Bar {
 
 fn main() {
     let x = vec![2, 3, 5];
-    let _ = x.get(0); // Use x.first()
+    let _ = x.get(0);
+    //~^ ERROR: accessing first element with `x.get(0)`
     let _ = x.get(1);
     let _ = x[0];
 
     let y = [2, 3, 5];
-    let _ = y.get(0); // Use y.first()
+    let _ = y.get(0);
+    //~^ ERROR: accessing first element with `y.get(0)`
     let _ = y.get(1);
     let _ = y[0];
 
     let z = &[2, 3, 5];
-    let _ = z.get(0); // Use z.first()
+    let _ = z.get(0);
+    //~^ ERROR: accessing first element with `z.get(0)`
     let _ = z.get(1);
     let _ = z[0];
 
@@ -37,4 +40,8 @@ fn main() {
 
     let bar = Bar { arr: [0, 1, 2] };
     let _ = bar.get(0); // Do not lint, because Bar is struct.
+
+    let non_primitives = [vec![1, 2], vec![3, 4]];
+    let _ = non_primitives.get(0);
+    //~^ ERROR: accessing first element with `non_primitives.get(0)`
 }
diff --git a/tests/ui/get_first.stderr b/tests/ui/get_first.stderr
index 56b4c29a313..8ee66e33cc8 100644
--- a/tests/ui/get_first.stderr
+++ b/tests/ui/get_first.stderr
@@ -1,23 +1,29 @@
 error: accessing first element with `x.get(0)`
   --> $DIR/get_first.rs:17:13
    |
-LL |     let _ = x.get(0); // Use x.first()
+LL |     let _ = x.get(0);
    |             ^^^^^^^^ help: try: `x.first()`
    |
    = note: `-D clippy::get-first` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::get_first)]`
 
 error: accessing first element with `y.get(0)`
-  --> $DIR/get_first.rs:22:13
+  --> $DIR/get_first.rs:23:13
    |
-LL |     let _ = y.get(0); // Use y.first()
+LL |     let _ = y.get(0);
    |             ^^^^^^^^ help: try: `y.first()`
 
 error: accessing first element with `z.get(0)`
-  --> $DIR/get_first.rs:27:13
+  --> $DIR/get_first.rs:29:13
    |
-LL |     let _ = z.get(0); // Use z.first()
+LL |     let _ = z.get(0);
    |             ^^^^^^^^ help: try: `z.first()`
 
-error: aborting due to 3 previous errors
+error: accessing first element with `non_primitives.get(0)`
+  --> $DIR/get_first.rs:45:13
+   |
+LL |     let _ = non_primitives.get(0);
+   |             ^^^^^^^^^^^^^^^^^^^^^ help: try: `non_primitives.first()`
+
+error: aborting due to 4 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From e6f29f1900002d980dd06778a29e73637539d928 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Wed, 4 Oct 2023 18:08:30 +0200
Subject: dogfood

---
 clippy_lints/src/loops/same_item_push.rs           | 2 +-
 clippy_lints/src/manual_bits.rs                    | 4 ++--
 clippy_lints/src/methods/search_is_some.rs         | 2 +-
 clippy_lints/src/missing_doc.rs                    | 2 +-
 clippy_lints/src/needless_continue.rs              | 4 ++--
 clippy_lints/src/slow_vector_initialization.rs     | 2 +-
 clippy_lints/src/uninit_vec.rs                     | 2 +-
 clippy_lints/src/unnecessary_map_on_constructor.rs | 4 ++--
 clippy_utils/src/consts.rs                         | 2 +-
 clippy_utils/src/higher.rs                         | 2 +-
 10 files changed, 13 insertions(+), 13 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/same_item_push.rs b/clippy_lints/src/loops/same_item_push.rs
index f7b3b2358a0..5fffb27cda2 100644
--- a/clippy_lints/src/loops/same_item_push.rs
+++ b/clippy_lints/src/loops/same_item_push.rs
@@ -185,7 +185,7 @@ fn get_vec_push<'tcx>(
             if let StmtKind::Semi(semi_stmt) = &stmt.kind;
             if let ExprKind::MethodCall(path, self_expr, args, _) = &semi_stmt.kind;
             // Figure out the parameters for the method call
-            if let Some(pushed_item) = args.get(0);
+            if let Some(pushed_item) = args.first();
             // Check that the method being called is push() on a Vec
             if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(self_expr), sym::Vec);
             if path.ident.name.as_str() == "push";
diff --git a/clippy_lints/src/manual_bits.rs b/clippy_lints/src/manual_bits.rs
index 6c7c57ba1d6..552c57d5e02 100644
--- a/clippy_lints/src/manual_bits.rs
+++ b/clippy_lints/src/manual_bits.rs
@@ -103,9 +103,9 @@ fn get_size_of_ty<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<
         if let ExprKind::Path(ref count_func_qpath) = count_func.kind;
 
         if let QPath::Resolved(_, count_func_path) = count_func_qpath;
-        if let Some(segment_zero) = count_func_path.segments.get(0);
+        if let Some(segment_zero) = count_func_path.segments.first();
         if let Some(args) = segment_zero.args;
-        if let Some(GenericArg::Type(real_ty)) = args.args.get(0);
+        if let Some(GenericArg::Type(real_ty)) = args.args.first();
 
         if let Some(def_id) = cx.qpath_res(count_func_qpath, count_func.hir_id).opt_def_id();
         if cx.tcx.is_diagnostic_item(sym::mem_size_of, def_id);
diff --git a/clippy_lints/src/methods/search_is_some.rs b/clippy_lints/src/methods/search_is_some.rs
index afdb8ce94ac..04ddaaa2f46 100644
--- a/clippy_lints/src/methods/search_is_some.rs
+++ b/clippy_lints/src/methods/search_is_some.rs
@@ -39,7 +39,7 @@ pub(super) fn check<'tcx>(
                 if search_method == "find";
                 if let hir::ExprKind::Closure(&hir::Closure { body, .. }) = search_arg.kind;
                 let closure_body = cx.tcx.hir().body(body);
-                if let Some(closure_arg) = closure_body.params.get(0);
+                if let Some(closure_arg) = closure_body.params.first();
                 then {
                     if let hir::PatKind::Ref(..) = closure_arg.pat.kind {
                         Some(search_snippet.replacen('&', "", 1))
diff --git a/clippy_lints/src/missing_doc.rs b/clippy_lints/src/missing_doc.rs
index f2773cad400..0629dee4f72 100644
--- a/clippy_lints/src/missing_doc.rs
+++ b/clippy_lints/src/missing_doc.rs
@@ -67,7 +67,7 @@ impl MissingDoc {
         if_chain! {
             if let Some(meta) = meta;
             if let MetaItemKind::List(list) = meta.kind;
-            if let Some(meta) = list.get(0);
+            if let Some(meta) = list.first();
             if let Some(name) = meta.ident();
             then {
                 name.name == sym::include
diff --git a/clippy_lints/src/needless_continue.rs b/clippy_lints/src/needless_continue.rs
index 38a75034cd3..377cbef7b99 100644
--- a/clippy_lints/src/needless_continue.rs
+++ b/clippy_lints/src/needless_continue.rs
@@ -189,7 +189,7 @@ fn needless_continue_in_else(else_expr: &ast::Expr, label: Option<&ast::Label>)
 }
 
 fn is_first_block_stmt_continue(block: &ast::Block, label: Option<&ast::Label>) -> bool {
-    block.stmts.get(0).map_or(false, |stmt| match stmt.kind {
+    block.stmts.first().map_or(false, |stmt| match stmt.kind {
         ast::StmtKind::Semi(ref e) | ast::StmtKind::Expr(ref e) => {
             if let ast::ExprKind::Continue(ref l) = e.kind {
                 compare_labels(label, l.as_ref())
@@ -434,7 +434,7 @@ fn erode_from_back(s: &str) -> String {
 }
 
 fn span_of_first_expr_in_block(block: &ast::Block) -> Option<Span> {
-    block.stmts.get(0).map(|stmt| stmt.span)
+    block.stmts.first().map(|stmt| stmt.span)
 }
 
 #[cfg(test)]
diff --git a/clippy_lints/src/slow_vector_initialization.rs b/clippy_lints/src/slow_vector_initialization.rs
index 9db18c2976c..2278e41be37 100644
--- a/clippy_lints/src/slow_vector_initialization.rs
+++ b/clippy_lints/src/slow_vector_initialization.rs
@@ -335,7 +335,7 @@ impl<'a, 'tcx> Visitor<'tcx> for VectorInitializationVisitor<'a, 'tcx> {
 
     fn visit_block(&mut self, block: &'tcx Block<'_>) {
         if self.initialization_found {
-            if let Some(s) = block.stmts.get(0) {
+            if let Some(s) = block.stmts.first() {
                 self.visit_stmt(s);
             }
 
diff --git a/clippy_lints/src/uninit_vec.rs b/clippy_lints/src/uninit_vec.rs
index 6756df8e716..72569e10f05 100644
--- a/clippy_lints/src/uninit_vec.rs
+++ b/clippy_lints/src/uninit_vec.rs
@@ -201,7 +201,7 @@ fn extract_set_len_self<'tcx>(cx: &LateContext<'_>, expr: &'tcx Expr<'_>) -> Opt
     let expr = peel_hir_expr_while(expr, |e| {
         if let ExprKind::Block(block, _) = e.kind {
             // Extract the first statement/expression
-            match (block.stmts.get(0).map(|stmt| &stmt.kind), block.expr) {
+            match (block.stmts.first().map(|stmt| &stmt.kind), block.expr) {
                 (None, Some(expr)) => Some(expr),
                 (Some(StmtKind::Expr(expr) | StmtKind::Semi(expr)), _) => Some(expr),
                 _ => None,
diff --git a/clippy_lints/src/unnecessary_map_on_constructor.rs b/clippy_lints/src/unnecessary_map_on_constructor.rs
index 5aa057580e9..894de0d85c1 100644
--- a/clippy_lints/src/unnecessary_map_on_constructor.rs
+++ b/clippy_lints/src/unnecessary_map_on_constructor.rs
@@ -40,7 +40,7 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryMapOnConstructor {
             let (constructor_path, constructor_item) =
                 if let hir::ExprKind::Call(constructor, constructor_args) = recv.kind
                     && let hir::ExprKind::Path(constructor_path) = constructor.kind
-                    && let Some(arg) = constructor_args.get(0)
+                    && let Some(arg) = constructor_args.first()
                 {
                     if constructor.span.from_expansion() || arg.span.from_expansion() {
                         return;
@@ -66,7 +66,7 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryMapOnConstructor {
                 _ => return,
             }
 
-            if let Some(map_arg) = args.get(0)
+            if let Some(map_arg) = args.first()
                 && let hir::ExprKind::Path(fun) = map_arg.kind
             {
                 if map_arg.span.from_expansion() {
diff --git a/clippy_utils/src/consts.rs b/clippy_utils/src/consts.rs
index 0bae7056c4f..79c04c7c7f4 100644
--- a/clippy_utils/src/consts.rs
+++ b/clippy_utils/src/consts.rs
@@ -504,7 +504,7 @@ impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
             },
             (Some(Constant::Vec(vec)), _) => {
                 if !vec.is_empty() && vec.iter().all(|x| *x == vec[0]) {
-                    match vec.get(0) {
+                    match vec.first() {
                         Some(Constant::F32(x)) => Some(Constant::F32(*x)),
                         Some(Constant::F64(x)) => Some(Constant::F64(*x)),
                         _ => None,
diff --git a/clippy_utils/src/higher.rs b/clippy_utils/src/higher.rs
index 802adbd4d2d..7c1be625bd3 100644
--- a/clippy_utils/src/higher.rs
+++ b/clippy_utils/src/higher.rs
@@ -449,7 +449,7 @@ pub fn get_vec_init_kind<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -
                 } else if name.ident.name == symbol::kw::Default {
                     return Some(VecInitKind::Default);
                 } else if name.ident.name.as_str() == "with_capacity" {
-                    let arg = args.get(0)?;
+                    let arg = args.first()?;
                     return match constant_simple(cx, cx.typeck_results(), arg) {
                         Some(Constant::Int(num)) => Some(VecInitKind::WithConstCapacity(num)),
                         _ => Some(VecInitKind::WithExprCapacity(arg.hir_id)),
-- 
cgit 1.4.1-3-g733a5


From dcc400191e444c8a57869f5004fdcbab807f7f09 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Wed, 4 Oct 2023 20:24:16 +0000
Subject: Fix `items_after_test_module` for non root modules, add applicable
 suggestion

---
 clippy_lints/src/items_after_test_module.rs        | 108 +++++++++++++--------
 clippy_utils/src/lib.rs                            |  21 ++--
 .../items_after_test_module/after_proc_macros.rs   |  11 +++
 .../items_after_test_module/auxiliary/submodule.rs |   4 +
 tests/ui/items_after_test_module/block_module.rs   |  23 -----
 .../ui/items_after_test_module/block_module.stderr |   2 -
 tests/ui/items_after_test_module/in_submodule.rs   |   8 ++
 .../ui/items_after_test_module/in_submodule.stderr |  14 +++
 .../ui/items_after_test_module/multiple_modules.rs |  11 +++
 tests/ui/items_after_test_module/root_module.fixed |  22 +++++
 tests/ui/items_after_test_module/root_module.rs    |  22 +++++
 .../ui/items_after_test_module/root_module.stderr  |  20 ++++
 12 files changed, 192 insertions(+), 74 deletions(-)
 create mode 100644 tests/ui/items_after_test_module/after_proc_macros.rs
 create mode 100644 tests/ui/items_after_test_module/auxiliary/submodule.rs
 delete mode 100644 tests/ui/items_after_test_module/block_module.rs
 delete mode 100644 tests/ui/items_after_test_module/block_module.stderr
 create mode 100644 tests/ui/items_after_test_module/in_submodule.rs
 create mode 100644 tests/ui/items_after_test_module/in_submodule.stderr
 create mode 100644 tests/ui/items_after_test_module/multiple_modules.rs
 create mode 100644 tests/ui/items_after_test_module/root_module.fixed
 create mode 100644 tests/ui/items_after_test_module/root_module.rs
 create mode 100644 tests/ui/items_after_test_module/root_module.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/items_after_test_module.rs b/clippy_lints/src/items_after_test_module.rs
index 55a43e91562..41477242bcc 100644
--- a/clippy_lints/src/items_after_test_module.rs
+++ b/clippy_lints/src/items_after_test_module.rs
@@ -1,10 +1,12 @@
-use clippy_utils::diagnostics::span_lint_and_help;
-use clippy_utils::{is_from_proc_macro, is_in_cfg_test};
-use rustc_hir::{HirId, ItemId, ItemKind, Mod};
-use rustc_lint::{LateContext, LateLintPass, LintContext};
-use rustc_middle::lint::in_external_macro;
+use clippy_utils::diagnostics::span_lint_hir_and_then;
+use clippy_utils::source::snippet_opt;
+use clippy_utils::{fulfill_or_allowed, is_cfg_test, is_from_proc_macro};
+use rustc_errors::{Applicability, SuggestionStyle};
+use rustc_hir::{HirId, Item, ItemKind, Mod};
+use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::{sym, Span};
+use rustc_span::hygiene::AstPass;
+use rustc_span::{sym, ExpnKind};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -41,46 +43,72 @@ declare_clippy_lint! {
 
 declare_lint_pass!(ItemsAfterTestModule => [ITEMS_AFTER_TEST_MODULE]);
 
-impl LateLintPass<'_> for ItemsAfterTestModule {
-    fn check_mod(&mut self, cx: &LateContext<'_>, _: &Mod<'_>, _: HirId) {
-        let mut was_test_mod_visited = false;
-        let mut test_mod_span: Option<Span> = None;
+fn cfg_test_module<'tcx>(cx: &LateContext<'tcx>, item: &Item<'tcx>) -> bool {
+    if let ItemKind::Mod(test_mod) = item.kind
+        && item.span.hi() == test_mod.spans.inner_span.hi()
+        && is_cfg_test(cx.tcx, item.hir_id())
+        && !item.span.from_expansion()
+        && !is_from_proc_macro(cx, item)
+    {
+        true
+    } else {
+        false
+    }
+}
 
-        let hir = cx.tcx.hir();
-        let items = hir.items().collect::<Vec<ItemId>>();
+impl LateLintPass<'_> for ItemsAfterTestModule {
+    fn check_mod(&mut self, cx: &LateContext<'_>, module: &Mod<'_>, _: HirId) {
+        let mut items = module.item_ids.iter().map(|&id| cx.tcx.hir().item(id));
 
-        for (i, itid) in items.iter().enumerate() {
-            let item = hir.item(*itid);
+        let Some((mod_pos, test_mod)) = items.by_ref().enumerate().find(|(_, item)| cfg_test_module(cx, item)) else {
+            return;
+        };
 
-            if_chain! {
-            if was_test_mod_visited;
-            if i == (items.len() - 3 /* Weird magic number (HIR-translation behaviour) */);
-            if cx.sess().source_map().lookup_char_pos(item.span.lo()).file.name_hash
-            == cx.sess().source_map().lookup_char_pos(test_mod_span.unwrap().lo()).file.name_hash; // Will never fail
-            if !matches!(item.kind, ItemKind::Mod(_));
-            if !is_in_cfg_test(cx.tcx, itid.hir_id()); // The item isn't in the testing module itself
-            if !in_external_macro(cx.sess(), item.span);
-            if !is_from_proc_macro(cx, item);
+        let after: Vec<_> = items
+            .filter(|item| {
+                // Ignore the generated test main function
+                !(item.ident.name == sym::main
+                    && item.span.ctxt().outer_expn_data().kind == ExpnKind::AstPass(AstPass::TestHarness))
+            })
+            .collect();
 
-            then {
-                span_lint_and_help(cx, ITEMS_AFTER_TEST_MODULE, test_mod_span.unwrap().with_hi(item.span.hi()), "items were found after the testing module", None, "move the items to before the testing module was defined");
-            }};
+        if let Some(last) = after.last()
+            && after.iter().all(|&item| {
+                !matches!(item.kind, ItemKind::Mod(_))
+                    && !item.span.from_expansion()
+                    && !is_from_proc_macro(cx, item)
+            })
+            && !fulfill_or_allowed(cx, ITEMS_AFTER_TEST_MODULE, after.iter().map(|item| item.hir_id()))
+        {
+            let def_spans: Vec<_> = std::iter::once(test_mod.owner_id)
+                .chain(after.iter().map(|item| item.owner_id))
+                .map(|id| cx.tcx.def_span(id))
+                .collect();
 
-            if let ItemKind::Mod(module) = item.kind && item.span.hi() == module.spans.inner_span.hi() {
-			// Check that it works the same way, the only I way I've found for #10713
-				for attr in cx.tcx.get_attrs(item.owner_id.to_def_id(), sym::cfg) {
-					if_chain! {
-						if attr.has_name(sym::cfg);
-                        if let Some(mitems) = attr.meta_item_list();
-                        if let [mitem] = &*mitems;
-                        if mitem.has_name(sym::test);
-                        then {
-							was_test_mod_visited = true;
-                            test_mod_span = Some(item.span);
-                        }
+            span_lint_hir_and_then(
+                cx,
+                ITEMS_AFTER_TEST_MODULE,
+                test_mod.hir_id(),
+                def_spans,
+                "items after a test module",
+                |diag| {
+                    if let Some(prev) = mod_pos.checked_sub(1)
+                        && let prev = cx.tcx.hir().item(module.item_ids[prev])
+                        && let items_span = last.span.with_lo(test_mod.span.hi())
+                        && let Some(items) = snippet_opt(cx, items_span)
+                    {
+                        diag.multipart_suggestion_with_style(
+                            "move the items to before the test module was defined",
+                            vec![
+                                (prev.span.shrink_to_hi(), items),
+                                (items_span, String::new())
+                            ],
+                            Applicability::MachineApplicable,
+                            SuggestionStyle::HideCodeAlways,
+                        );
                     }
-                }
-			}
+                },
+            );
         }
     }
 }
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 350b231e903..6711d007388 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -80,7 +80,6 @@ use std::sync::{Mutex, MutexGuard, OnceLock};
 use if_chain::if_chain;
 use itertools::Itertools;
 use rustc_ast::ast::{self, LitKind, RangeLimits};
-use rustc_ast::Attribute;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_data_structures::unhash::UnhashMap;
 use rustc_hir::def::{DefKind, Res};
@@ -2452,11 +2451,12 @@ pub fn is_in_test_function(tcx: TyCtxt<'_>, id: hir::HirId) -> bool {
     })
 }
 
-/// Checks if the item containing the given `HirId` has `#[cfg(test)]` attribute applied
+/// Checks if `id` has a `#[cfg(test)]` attribute applied
 ///
-/// Note: Add `//@compile-flags: --test` to UI tests with a `#[cfg(test)]` function
-pub fn is_in_cfg_test(tcx: TyCtxt<'_>, id: hir::HirId) -> bool {
-    fn is_cfg_test(attr: &Attribute) -> bool {
+/// This only checks directly applied attributes, to see if a node is inside a `#[cfg(test)]` parent
+/// use [`is_in_cfg_test`]
+pub fn is_cfg_test(tcx: TyCtxt<'_>, id: hir::HirId) -> bool {
+    tcx.hir().attrs(id).iter().any(|attr| {
         if attr.has_name(sym::cfg)
             && let Some(items) = attr.meta_item_list()
             && let [item] = &*items
@@ -2466,11 +2466,14 @@ pub fn is_in_cfg_test(tcx: TyCtxt<'_>, id: hir::HirId) -> bool {
         } else {
             false
         }
-    }
+    })
+}
+
+/// Checks if any parent node of `HirId` has `#[cfg(test)]` attribute applied
+pub fn is_in_cfg_test(tcx: TyCtxt<'_>, id: hir::HirId) -> bool {
     tcx.hir()
-        .parent_iter(id)
-        .flat_map(|(parent_id, _)| tcx.hir().attrs(parent_id))
-        .any(is_cfg_test)
+        .parent_id_iter(id)
+        .any(|parent_id| is_cfg_test(tcx, parent_id))
 }
 
 /// Checks if the item of any of its parents has `#[cfg(...)]` attribute applied.
diff --git a/tests/ui/items_after_test_module/after_proc_macros.rs b/tests/ui/items_after_test_module/after_proc_macros.rs
new file mode 100644
index 00000000000..d9c0aef88c8
--- /dev/null
+++ b/tests/ui/items_after_test_module/after_proc_macros.rs
@@ -0,0 +1,11 @@
+//@aux-build:../auxiliary/proc_macros.rs
+extern crate proc_macros;
+
+proc_macros::with_span! {
+    span
+    #[cfg(test)]
+    mod tests {}
+}
+
+#[test]
+fn f() {}
diff --git a/tests/ui/items_after_test_module/auxiliary/submodule.rs b/tests/ui/items_after_test_module/auxiliary/submodule.rs
new file mode 100644
index 00000000000..69d61790121
--- /dev/null
+++ b/tests/ui/items_after_test_module/auxiliary/submodule.rs
@@ -0,0 +1,4 @@
+#[cfg(test)]
+mod tests {}
+
+fn in_submodule() {}
diff --git a/tests/ui/items_after_test_module/block_module.rs b/tests/ui/items_after_test_module/block_module.rs
deleted file mode 100644
index 5136b2557ec..00000000000
--- a/tests/ui/items_after_test_module/block_module.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-//@compile-flags: --test
-#![allow(unused)]
-#![warn(clippy::items_after_test_module)]
-
-fn main() {}
-
-fn should_not_lint() {}
-
-#[allow(dead_code)]
-#[allow(unused)] // Some attributes to check that span replacement is good enough
-#[allow(clippy::allow_attributes)]
-#[cfg(test)]
-mod tests {
-    #[test]
-    fn hi() {}
-}
-
-fn should_lint() {}
-
-const SHOULD_ALSO_LINT: usize = 1;
-macro_rules! should_not_lint {
-    () => {};
-}
diff --git a/tests/ui/items_after_test_module/block_module.stderr b/tests/ui/items_after_test_module/block_module.stderr
deleted file mode 100644
index 1b625747161..00000000000
--- a/tests/ui/items_after_test_module/block_module.stderr
+++ /dev/null
@@ -1,2 +0,0 @@
-error: Option 'test' given more than once
-
diff --git a/tests/ui/items_after_test_module/in_submodule.rs b/tests/ui/items_after_test_module/in_submodule.rs
new file mode 100644
index 00000000000..7132e71764e
--- /dev/null
+++ b/tests/ui/items_after_test_module/in_submodule.rs
@@ -0,0 +1,8 @@
+#[path = "auxiliary/submodule.rs"]
+mod submodule;
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn t() {}
+}
diff --git a/tests/ui/items_after_test_module/in_submodule.stderr b/tests/ui/items_after_test_module/in_submodule.stderr
new file mode 100644
index 00000000000..4e99876365c
--- /dev/null
+++ b/tests/ui/items_after_test_module/in_submodule.stderr
@@ -0,0 +1,14 @@
+error: items after a test module
+  --> $DIR/auxiliary/submodule.rs:2:1
+   |
+LL | mod tests {}
+   | ^^^^^^^^^
+LL |
+LL | fn in_submodule() {}
+   | ^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::items-after-test-module` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::items_after_test_module)]`
+
+error: aborting due to previous error
+
diff --git a/tests/ui/items_after_test_module/multiple_modules.rs b/tests/ui/items_after_test_module/multiple_modules.rs
new file mode 100644
index 00000000000..8ab9e8200f1
--- /dev/null
+++ b/tests/ui/items_after_test_module/multiple_modules.rs
@@ -0,0 +1,11 @@
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn f() {}
+}
+
+#[cfg(test)]
+mod more_tests {
+    #[test]
+    fn g() {}
+}
diff --git a/tests/ui/items_after_test_module/root_module.fixed b/tests/ui/items_after_test_module/root_module.fixed
new file mode 100644
index 00000000000..d444100a76b
--- /dev/null
+++ b/tests/ui/items_after_test_module/root_module.fixed
@@ -0,0 +1,22 @@
+#![allow(unused)]
+#![warn(clippy::items_after_test_module)]
+
+fn main() {}
+
+fn should_not_lint() {}
+
+fn should_lint() {}
+
+const SHOULD_ALSO_LINT: usize = 1;
+macro_rules! should_lint {
+    () => {};
+}
+
+#[allow(dead_code)]
+#[allow(unused)] // Some attributes to check that span replacement is good enough
+#[allow(clippy::allow_attributes)]
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn hi() {}
+}
diff --git a/tests/ui/items_after_test_module/root_module.rs b/tests/ui/items_after_test_module/root_module.rs
new file mode 100644
index 00000000000..57da01639cc
--- /dev/null
+++ b/tests/ui/items_after_test_module/root_module.rs
@@ -0,0 +1,22 @@
+#![allow(unused)]
+#![warn(clippy::items_after_test_module)]
+
+fn main() {}
+
+fn should_not_lint() {}
+
+#[allow(dead_code)]
+#[allow(unused)] // Some attributes to check that span replacement is good enough
+#[allow(clippy::allow_attributes)]
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn hi() {}
+}
+
+fn should_lint() {}
+
+const SHOULD_ALSO_LINT: usize = 1;
+macro_rules! should_lint {
+    () => {};
+}
diff --git a/tests/ui/items_after_test_module/root_module.stderr b/tests/ui/items_after_test_module/root_module.stderr
new file mode 100644
index 00000000000..67bc82ebff9
--- /dev/null
+++ b/tests/ui/items_after_test_module/root_module.stderr
@@ -0,0 +1,20 @@
+error: items after a test module
+  --> $DIR/root_module.rs:12:1
+   |
+LL | mod tests {
+   | ^^^^^^^^^
+...
+LL | fn should_lint() {}
+   | ^^^^^^^^^^^^^^^^
+LL |
+LL | const SHOULD_ALSO_LINT: usize = 1;
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL | macro_rules! should_lint {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::items-after-test-module` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::items_after_test_module)]`
+   = help: move the items to before the test module was defined
+
+error: aborting due to previous error
+
-- 
cgit 1.4.1-3-g733a5


From 48d2770e527dd21fd8ae71178d360abd005b6ddc Mon Sep 17 00:00:00 2001
From: koka <koka.code@gmail.com>
Date: Fri, 6 Oct 2023 22:18:11 +0900
Subject: Improve `redundant_locals` help message

---
 clippy_lints/src/redundant_locals.rs |   8 +-
 tests/ui/redundant_locals.stderr     | 140 ++++++++++++++++++++---------------
 2 files changed, 86 insertions(+), 62 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/redundant_locals.rs b/clippy_lints/src/redundant_locals.rs
index 7864ff3e8ff..197742b5dd4 100644
--- a/clippy_lints/src/redundant_locals.rs
+++ b/clippy_lints/src/redundant_locals.rs
@@ -74,10 +74,10 @@ impl<'tcx> LateLintPass<'tcx> for RedundantLocals {
                 span_lint_and_help(
                     cx,
                     REDUNDANT_LOCALS,
-                    vec![binding_pat.span, local.span],
-                    "redundant redefinition of a binding",
-                    None,
-                    &format!("remove the redefinition of `{ident}`"),
+                    local.span,
+                    &format!("redundant redefinition of a binding `{ident}`"),
+                    Some(binding_pat.span),
+                    &format!("`{ident}` is initially defined here"),
                 );
             }
         }
diff --git a/tests/ui/redundant_locals.stderr b/tests/ui/redundant_locals.stderr
index 6e9da8fccbd..d794a87fe7d 100644
--- a/tests/ui/redundant_locals.stderr
+++ b/tests/ui/redundant_locals.stderr
@@ -1,148 +1,172 @@
-error: redundant redefinition of a binding
-  --> $DIR/redundant_locals.rs:11:9
+error: redundant redefinition of a binding `x`
+  --> $DIR/redundant_locals.rs:12:5
    |
-LL |     let x = 1;
-   |         ^
 LL |     let x = x;
    |     ^^^^^^^^^^
    |
-   = help: remove the redefinition of `x`
+help: `x` is initially defined here
+  --> $DIR/redundant_locals.rs:11:9
+   |
+LL |     let x = 1;
+   |         ^
    = note: `-D clippy::redundant-locals` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::redundant_locals)]`
 
-error: redundant redefinition of a binding
-  --> $DIR/redundant_locals.rs:16:9
+error: redundant redefinition of a binding `x`
+  --> $DIR/redundant_locals.rs:17:5
    |
-LL |     let mut x = 1;
-   |         ^^^^^
 LL |     let mut x = x;
    |     ^^^^^^^^^^^^^^
    |
-   = help: remove the redefinition of `x`
+help: `x` is initially defined here
+  --> $DIR/redundant_locals.rs:16:9
+   |
+LL |     let mut x = 1;
+   |         ^^^^^
 
-error: redundant redefinition of a binding
+error: redundant redefinition of a binding `x`
+  --> $DIR/redundant_locals.rs:47:5
+   |
+LL |     let x = x;
+   |     ^^^^^^^^^^
+   |
+help: `x` is initially defined here
   --> $DIR/redundant_locals.rs:46:14
    |
 LL | fn parameter(x: i32) {
    |              ^
+
+error: redundant redefinition of a binding `x`
+  --> $DIR/redundant_locals.rs:52:5
+   |
 LL |     let x = x;
    |     ^^^^^^^^^^
    |
-   = help: remove the redefinition of `x`
-
-error: redundant redefinition of a binding
+help: `x` is initially defined here
   --> $DIR/redundant_locals.rs:51:9
    |
 LL |     let x = 1;
    |         ^
+
+error: redundant redefinition of a binding `x`
+  --> $DIR/redundant_locals.rs:53:5
+   |
 LL |     let x = x;
    |     ^^^^^^^^^^
    |
-   = help: remove the redefinition of `x`
-
-error: redundant redefinition of a binding
+help: `x` is initially defined here
   --> $DIR/redundant_locals.rs:52:9
    |
 LL |     let x = x;
    |         ^
+
+error: redundant redefinition of a binding `x`
+  --> $DIR/redundant_locals.rs:54:5
+   |
 LL |     let x = x;
    |     ^^^^^^^^^^
    |
-   = help: remove the redefinition of `x`
-
-error: redundant redefinition of a binding
+help: `x` is initially defined here
   --> $DIR/redundant_locals.rs:53:9
    |
 LL |     let x = x;
    |         ^
+
+error: redundant redefinition of a binding `x`
+  --> $DIR/redundant_locals.rs:55:5
+   |
 LL |     let x = x;
    |     ^^^^^^^^^^
    |
-   = help: remove the redefinition of `x`
-
-error: redundant redefinition of a binding
+help: `x` is initially defined here
   --> $DIR/redundant_locals.rs:54:9
    |
 LL |     let x = x;
    |         ^
-LL |     let x = x;
+
+error: redundant redefinition of a binding `a`
+  --> $DIR/redundant_locals.rs:61:5
+   |
+LL |     let a = a;
    |     ^^^^^^^^^^
    |
-   = help: remove the redefinition of `x`
-
-error: redundant redefinition of a binding
+help: `a` is initially defined here
   --> $DIR/redundant_locals.rs:59:9
    |
 LL |     let a = 1;
    |         ^
-LL |     let b = 2;
-LL |     let a = a;
+
+error: redundant redefinition of a binding `b`
+  --> $DIR/redundant_locals.rs:62:5
+   |
+LL |     let b = b;
    |     ^^^^^^^^^^
    |
-   = help: remove the redefinition of `a`
-
-error: redundant redefinition of a binding
+help: `b` is initially defined here
   --> $DIR/redundant_locals.rs:60:9
    |
 LL |     let b = 2;
    |         ^
-LL |     let a = a;
-LL |     let b = b;
-   |     ^^^^^^^^^^
-   |
-   = help: remove the redefinition of `b`
 
-error: redundant redefinition of a binding
+error: redundant redefinition of a binding `x`
+  --> $DIR/redundant_locals.rs:68:9
+   |
+LL |         let x = x;
+   |         ^^^^^^^^^^
+   |
+help: `x` is initially defined here
   --> $DIR/redundant_locals.rs:67:13
    |
 LL |         let x = 1;
    |             ^
+
+error: redundant redefinition of a binding `x`
+  --> $DIR/redundant_locals.rs:75:9
+   |
 LL |         let x = x;
    |         ^^^^^^^^^^
    |
-   = help: remove the redefinition of `x`
-
-error: redundant redefinition of a binding
+help: `x` is initially defined here
   --> $DIR/redundant_locals.rs:74:13
    |
 LL |         let x = 1;
    |             ^
+
+error: redundant redefinition of a binding `x`
+  --> $DIR/redundant_locals.rs:78:9
+   |
 LL |         let x = x;
    |         ^^^^^^^^^^
    |
-   = help: remove the redefinition of `x`
-
-error: redundant redefinition of a binding
+help: `x` is initially defined here
   --> $DIR/redundant_locals.rs:77:6
    |
 LL |     |x: i32| {
    |      ^
+
+error: redundant redefinition of a binding `x`
+  --> $DIR/redundant_locals.rs:97:9
+   |
 LL |         let x = x;
    |         ^^^^^^^^^^
    |
-   = help: remove the redefinition of `x`
-
-error: redundant redefinition of a binding
+help: `x` is initially defined here
   --> $DIR/redundant_locals.rs:94:9
    |
 LL |     let x = 1;
    |         ^
-...
-LL |         let x = x;
-   |         ^^^^^^^^^^
-   |
-   = help: remove the redefinition of `x`
 
-error: redundant redefinition of a binding
-  --> $DIR/redundant_locals.rs:142:9
+error: redundant redefinition of a binding `a`
+  --> $DIR/redundant_locals.rs:144:5
    |
-LL |     let a = WithoutDrop(1);
-   |         ^
-LL |     let b = WithoutDrop(2);
 LL |     let a = a;
    |     ^^^^^^^^^^
    |
-   = help: remove the redefinition of `a`
+help: `a` is initially defined here
+  --> $DIR/redundant_locals.rs:142:9
+   |
+LL |     let a = WithoutDrop(1);
+   |         ^
 
 error: aborting due to 14 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 68d2082d69d61af56d0b9d73035b274ea0e2e8de Mon Sep 17 00:00:00 2001
From: koka <koka.code@gmail.com>
Date: Fri, 6 Oct 2023 18:22:32 +0900
Subject: Fix ice

---
 clippy_lints/src/redundant_locals.rs | 2 +-
 tests/ui/redundant_locals.rs         | 8 ++++++++
 tests/ui/redundant_locals.stderr     | 4 ++--
 3 files changed, 11 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/redundant_locals.rs b/clippy_lints/src/redundant_locals.rs
index 197742b5dd4..a1a0e8f3520 100644
--- a/clippy_lints/src/redundant_locals.rs
+++ b/clippy_lints/src/redundant_locals.rs
@@ -62,7 +62,7 @@ impl<'tcx> LateLintPass<'tcx> for RedundantLocals {
             if let Res::Local(binding_id) = cx.qpath_res(&qpath, expr.hir_id);
             if let Node::Pat(binding_pat) = cx.tcx.hir().get(binding_id);
             // the previous binding has the same mutability
-            if find_binding(binding_pat, ident).unwrap().1 == mutability;
+            if find_binding(binding_pat, ident).is_some_and(|bind| bind.1 == mutability);
             // the local does not change the effect of assignments to the binding. see #11290
             if !affects_assignments(cx, mutability, binding_id, local.hir_id);
             // the local does not affect the code's drop behavior
diff --git a/tests/ui/redundant_locals.rs b/tests/ui/redundant_locals.rs
index e81db300f15..182d067a5e9 100644
--- a/tests/ui/redundant_locals.rs
+++ b/tests/ui/redundant_locals.rs
@@ -117,6 +117,14 @@ fn macros() {
         let x = 1;
         let x = x;
     }
+
+    let x = 10;
+    macro_rules! rebind_outer_macro {
+        ($x:ident) => {
+            let x = x;
+        };
+    }
+    rebind_outer_macro!(y);
 }
 
 struct WithDrop(usize);
diff --git a/tests/ui/redundant_locals.stderr b/tests/ui/redundant_locals.stderr
index d794a87fe7d..30ab4aa2ea9 100644
--- a/tests/ui/redundant_locals.stderr
+++ b/tests/ui/redundant_locals.stderr
@@ -157,13 +157,13 @@ LL |     let x = 1;
    |         ^
 
 error: redundant redefinition of a binding `a`
-  --> $DIR/redundant_locals.rs:144:5
+  --> $DIR/redundant_locals.rs:152:5
    |
 LL |     let a = a;
    |     ^^^^^^^^^^
    |
 help: `a` is initially defined here
-  --> $DIR/redundant_locals.rs:142:9
+  --> $DIR/redundant_locals.rs:150:9
    |
 LL |     let a = WithoutDrop(1);
    |         ^
-- 
cgit 1.4.1-3-g733a5


From bffba76b52dfe96f42fb153c02824237968a15c8 Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Sat, 7 Oct 2023 10:54:45 +0200
Subject: Fix two typos in lint description

---
 clippy_lints/src/iter_without_into_iter.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/iter_without_into_iter.rs b/clippy_lints/src/iter_without_into_iter.rs
index 43e1b92c9b9..abfc50369b5 100644
--- a/clippy_lints/src/iter_without_into_iter.rs
+++ b/clippy_lints/src/iter_without_into_iter.rs
@@ -56,8 +56,8 @@ declare_clippy_lint! {
     ///
     /// ### Why is this bad?
     /// It's not bad, but having them is idiomatic and allows the type to be used in iterator chains
-    /// by just calling `.iter()`, instead of the more awkward `<&Type>::into_iter` or `(&val).iter()` syntax
-    /// in case of ambiguity with another `Intoiterator` impl.
+    /// by just calling `.iter()`, instead of the more awkward `<&Type>::into_iter` or `(&val).into_iter()` syntax
+    /// in case of ambiguity with another `IntoIterator` impl.
     ///
     /// ### Example
     /// ```rust
-- 
cgit 1.4.1-3-g733a5


From 1c6fa2989d056de1183e5df1e1d778e925a6a6fe Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Sat, 7 Oct 2023 16:33:06 +0200
Subject: [`into_iter_without_iter`]: look for `iter` method in deref chains

---
 clippy_lints/src/iter_without_into_iter.rs | 25 +++++++++++++++++++---
 tests/ui/into_iter_without_iter.rs         | 34 ++++++++++++++++++++++++++++++
 2 files changed, 56 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/iter_without_into_iter.rs b/clippy_lints/src/iter_without_into_iter.rs
index 43e1b92c9b9..ee3d1735043 100644
--- a/clippy_lints/src/iter_without_into_iter.rs
+++ b/clippy_lints/src/iter_without_into_iter.rs
@@ -9,6 +9,7 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{self, Ty};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::{sym, Symbol};
+use std::iter;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -52,7 +53,8 @@ declare_clippy_lint! {
 declare_clippy_lint! {
     /// ### What it does
     /// This is the opposite of the `iter_without_into_iter` lint.
-    /// It looks for `IntoIterator for (&|&mut) Type` implementations without an inherent `iter` or `iter_mut` method.
+    /// It looks for `IntoIterator for (&|&mut) Type` implementations without an inherent `iter` or `iter_mut` method
+    /// on the type or on any of the types in its `Deref` chain.
     ///
     /// ### Why is this bad?
     /// It's not bad, but having them is idiomatic and allows the type to be used in iterator chains
@@ -102,7 +104,20 @@ fn is_nameable_in_impl_trait(ty: &rustc_hir::Ty<'_>) -> bool {
     !matches!(ty.kind, TyKind::OpaqueDef(..))
 }
 
-fn type_has_inherent_method(cx: &LateContext<'_>, ty: Ty<'_>, method_name: Symbol) -> bool {
+/// Returns the deref chain of a type, starting with the type itself.
+fn deref_chain<'cx, 'tcx>(cx: &'cx LateContext<'tcx>, ty: Ty<'tcx>) -> impl Iterator<Item = Ty<'tcx>> + 'cx {
+    iter::successors(Some(ty), |&ty| {
+        if let Some(deref_did) = cx.tcx.lang_items().deref_trait()
+            && implements_trait(cx, ty, deref_did, &[])
+        {
+            make_normalized_projection(cx.tcx, cx.param_env, deref_did, sym::Target, [ty])
+        } else {
+            None
+        }
+    })
+}
+
+fn adt_has_inherent_method(cx: &LateContext<'_>, ty: Ty<'_>, method_name: Symbol) -> bool {
     if let Some(ty_did) = ty.ty_adt_def().map(ty::AdtDef::did) {
         cx.tcx.inherent_impls(ty_did).iter().any(|&did| {
             cx.tcx
@@ -127,7 +142,11 @@ impl LateLintPass<'_> for IterWithoutIntoIter {
                 Mutability::Mut => sym::iter_mut,
                 Mutability::Not => sym::iter,
             }
-            && !type_has_inherent_method(cx, ty, expected_method_name)
+            && !deref_chain(cx, ty)
+                .any(|ty| {
+                    // We can't check inherent impls for slices, but we know that they have an `iter(_mut)` method
+                    ty.peel_refs().is_slice() || adt_has_inherent_method(cx, ty, expected_method_name)
+                })
             && let Some(iter_assoc_span) = imp.items.iter().find_map(|item| {
                 if item.ident.name == sym!(IntoIter) {
                     Some(cx.tcx.hir().impl_item(item.id).expect_type().span)
diff --git a/tests/ui/into_iter_without_iter.rs b/tests/ui/into_iter_without_iter.rs
index 6be3bb8abdd..e6ff821a8ad 100644
--- a/tests/ui/into_iter_without_iter.rs
+++ b/tests/ui/into_iter_without_iter.rs
@@ -122,3 +122,37 @@ fn main() {
         }
     }
 }
+
+fn issue11635() {
+    // A little more involved than the original repro in the issue, but this tests that it correctly
+    // works for more than one deref step
+
+    use std::ops::Deref;
+
+    pub struct Thing(Vec<u8>);
+    pub struct Thing2(Thing);
+
+    impl Deref for Thing {
+        type Target = [u8];
+
+        fn deref(&self) -> &Self::Target {
+            &self.0
+        }
+    }
+
+    impl Deref for Thing2 {
+        type Target = Thing;
+        fn deref(&self) -> &Self::Target {
+            &self.0
+        }
+    }
+
+    impl<'a> IntoIterator for &'a Thing2 {
+        type Item = &'a u8;
+        type IntoIter = <&'a [u8] as IntoIterator>::IntoIter;
+
+        fn into_iter(self) -> Self::IntoIter {
+            self.0.iter()
+        }
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 5ed338dff9ab543460e83c9fbe462373c0b99a82 Mon Sep 17 00:00:00 2001
From: blyxyas <blyxyas@gmail.com>
Date: Thu, 21 Sep 2023 22:37:32 +0200
Subject: `impl_trait_in_params` now supports impls and traits

---
 clippy_lints/src/functions/impl_trait_in_params.rs | 120 +++++++++++++++------
 clippy_lints/src/functions/mod.rs                  |  11 +-
 clippy_lints/src/lib.rs                            |   1 +
 .../ui-toml/impl_trait_in_params/true/clippy.toml  |   1 +
 .../true/impl_trait_in_params.rs                   |  10 ++
 tests/ui/impl_trait_in_params.rs                   |  29 ++++-
 tests/ui/impl_trait_in_params.stderr               |  30 +++++-
 7 files changed, 158 insertions(+), 44 deletions(-)
 create mode 100644 tests/ui-toml/impl_trait_in_params/true/clippy.toml
 create mode 100644 tests/ui-toml/impl_trait_in_params/true/impl_trait_in_params.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/functions/impl_trait_in_params.rs b/clippy_lints/src/functions/impl_trait_in_params.rs
index 597fca88885..4a776dd2613 100644
--- a/clippy_lints/src/functions/impl_trait_in_params.rs
+++ b/clippy_lints/src/functions/impl_trait_in_params.rs
@@ -1,50 +1,100 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::is_in_test_function;
 
+use rustc_hir as hir;
 use rustc_hir::intravisit::FnKind;
-use rustc_hir::{Body, HirId};
+use rustc_hir::{Body, GenericParam, Generics, HirId, ImplItem, ImplItemKind, TraitItem, TraitItemKind};
 use rustc_lint::LateContext;
+use rustc_span::symbol::Ident;
 use rustc_span::Span;
 
 use super::IMPL_TRAIT_IN_PARAMS;
 
+fn report(
+    cx: &LateContext<'_>,
+    param: &GenericParam<'_>,
+    ident: &Ident,
+    generics: &Generics<'_>,
+    first_param_span: Span,
+) {
+    // No generics with nested generics, and no generics like FnMut(x)
+    span_lint_and_then(
+        cx,
+        IMPL_TRAIT_IN_PARAMS,
+        param.span,
+        "`impl Trait` used as a function parameter",
+        |diag| {
+            if let Some(gen_span) = generics.span_for_param_suggestion() {
+                // If there's already a generic param with the same bound, do not lint **this** suggestion.
+                diag.span_suggestion_with_style(
+                    gen_span,
+                    "add a type parameter",
+                    format!(", {{ /* Generic name */ }}: {}", &param.name.ident().as_str()[5..]),
+                    rustc_errors::Applicability::HasPlaceholders,
+                    rustc_errors::SuggestionStyle::ShowAlways,
+                );
+            } else {
+                diag.span_suggestion_with_style(
+                    Span::new(
+                        first_param_span.lo() - rustc_span::BytePos(1),
+                        ident.span.hi(),
+                        ident.span.ctxt(),
+                        ident.span.parent(),
+                    ),
+                    "add a type parameter",
+                    format!("<{{ /* Generic name */ }}: {}>", &param.name.ident().as_str()[5..]),
+                    rustc_errors::Applicability::HasPlaceholders,
+                    rustc_errors::SuggestionStyle::ShowAlways,
+                );
+            }
+        },
+    );
+}
+
 pub(super) fn check_fn<'tcx>(cx: &LateContext<'_>, kind: &'tcx FnKind<'_>, body: &'tcx Body<'_>, hir_id: HirId) {
-    if cx.tcx.visibility(cx.tcx.hir().body_owner_def_id(body.id())).is_public() && !is_in_test_function(cx.tcx, hir_id)
-    {
-        if let FnKind::ItemFn(ident, generics, _) = kind {
+    if_chain! {
+        if let FnKind::ItemFn(ident, generics, _) = kind;
+        if cx.tcx.visibility(cx.tcx.hir().body_owner_def_id(body.id())).is_public();
+        if !is_in_test_function(cx.tcx, hir_id);
+        then {
             for param in generics.params {
                 if param.is_impl_trait() {
-                    // No generics with nested generics, and no generics like FnMut(x)
-                    span_lint_and_then(
-                        cx,
-                        IMPL_TRAIT_IN_PARAMS,
-                        param.span,
-                        "'`impl Trait` used as a function parameter'",
-                        |diag| {
-                            if let Some(gen_span) = generics.span_for_param_suggestion() {
-                                diag.span_suggestion_with_style(
-                                    gen_span,
-                                    "add a type parameter",
-                                    format!(", {{ /* Generic name */ }}: {}", &param.name.ident().as_str()[5..]),
-                                    rustc_errors::Applicability::HasPlaceholders,
-                                    rustc_errors::SuggestionStyle::ShowAlways,
-                                );
-                            } else {
-                                diag.span_suggestion_with_style(
-                                    Span::new(
-                                        body.params[0].span.lo() - rustc_span::BytePos(1),
-                                        ident.span.hi(),
-                                        ident.span.ctxt(),
-                                        ident.span.parent(),
-                                    ),
-                                    "add a type parameter",
-                                    format!("<{{ /* Generic name */ }}: {}>", &param.name.ident().as_str()[5..]),
-                                    rustc_errors::Applicability::HasPlaceholders,
-                                    rustc_errors::SuggestionStyle::ShowAlways,
-                                );
-                            }
-                        },
-                    );
+                    report(cx, param, ident, generics, body.params[0].span);
+                };
+            }
+        }
+    }
+}
+
+pub(super) fn check_impl_item(cx: &LateContext<'_>, impl_item: &ImplItem<'_>) {
+    if_chain! {
+        if let ImplItemKind::Fn(_, body_id) = impl_item.kind;
+        if let hir::Node::Item(item) = cx.tcx.hir().get_parent(impl_item.hir_id());
+        if let hir::ItemKind::Impl(impl_) = item.kind;
+        if let hir::Impl { of_trait, .. } = *impl_;
+        if of_trait.is_none();
+        let body = cx.tcx.hir().body(body_id);
+        if cx.tcx.visibility(cx.tcx.hir().body_owner_def_id(body.id())).is_public();
+        if !is_in_test_function(cx.tcx, impl_item.hir_id());
+        then {
+            for param in impl_item.generics.params {
+                if param.is_impl_trait() {
+                    report(cx, param, &impl_item.ident, impl_item.generics, body.params[0].span);
+                }
+            }
+        }
+    }
+}
+
+pub(super) fn check_trait_item(cx: &LateContext<'_>, trait_item: &TraitItem<'_>, avoid_breaking_exported_api: bool) {
+    if_chain! {
+        if !avoid_breaking_exported_api;
+        if let TraitItemKind::Fn(sig, _) = trait_item.kind;
+        if !is_in_test_function(cx.tcx, trait_item.hir_id());
+        then {
+            for param in trait_item.generics.params {
+                if param.is_impl_trait() {
+                    report(cx, param, &trait_item.ident, trait_item.generics, sig.decl.inputs[0].span);
                 }
             }
         }
diff --git a/clippy_lints/src/functions/mod.rs b/clippy_lints/src/functions/mod.rs
index ee10334c67f..55ebd44a60c 100644
--- a/clippy_lints/src/functions/mod.rs
+++ b/clippy_lints/src/functions/mod.rs
@@ -364,14 +364,21 @@ pub struct Functions {
     too_many_arguments_threshold: u64,
     too_many_lines_threshold: u64,
     large_error_threshold: u64,
+    avoid_breaking_exported_api: bool,
 }
 
 impl Functions {
-    pub fn new(too_many_arguments_threshold: u64, too_many_lines_threshold: u64, large_error_threshold: u64) -> Self {
+    pub fn new(
+        too_many_arguments_threshold: u64,
+        too_many_lines_threshold: u64,
+        large_error_threshold: u64,
+        avoid_breaking_exported_api: bool,
+    ) -> Self {
         Self {
             too_many_arguments_threshold,
             too_many_lines_threshold,
             large_error_threshold,
+            avoid_breaking_exported_api,
         }
     }
 }
@@ -415,6 +422,7 @@ impl<'tcx> LateLintPass<'tcx> for Functions {
     fn check_impl_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::ImplItem<'_>) {
         must_use::check_impl_item(cx, item);
         result::check_impl_item(cx, item, self.large_error_threshold);
+        impl_trait_in_params::check_impl_item(cx, item);
     }
 
     fn check_trait_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::TraitItem<'_>) {
@@ -422,5 +430,6 @@ impl<'tcx> LateLintPass<'tcx> for Functions {
         not_unsafe_ptr_arg_deref::check_trait_item(cx, item);
         must_use::check_trait_item(cx, item);
         result::check_trait_item(cx, item, self.large_error_threshold);
+        impl_trait_in_params::check_trait_item(cx, item, self.avoid_breaking_exported_api);
     }
 }
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index fa009c8b2d6..8a4c2fc2c43 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -758,6 +758,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
             too_many_arguments_threshold,
             too_many_lines_threshold,
             large_error_threshold,
+            avoid_breaking_exported_api,
         ))
     });
     let doc_valid_idents = conf.doc_valid_idents.iter().cloned().collect::<FxHashSet<_>>();
diff --git a/tests/ui-toml/impl_trait_in_params/true/clippy.toml b/tests/ui-toml/impl_trait_in_params/true/clippy.toml
new file mode 100644
index 00000000000..0e7ffd070a3
--- /dev/null
+++ b/tests/ui-toml/impl_trait_in_params/true/clippy.toml
@@ -0,0 +1 @@
+avoid-breaking-exported-api = true
\ No newline at end of file
diff --git a/tests/ui-toml/impl_trait_in_params/true/impl_trait_in_params.rs b/tests/ui-toml/impl_trait_in_params/true/impl_trait_in_params.rs
new file mode 100644
index 00000000000..d1176ab8963
--- /dev/null
+++ b/tests/ui-toml/impl_trait_in_params/true/impl_trait_in_params.rs
@@ -0,0 +1,10 @@
+//! As avoid-breaking-exported-api is `true`, nothing here should lint
+#![warn(clippy::impl_trait_in_params)]
+#![no_main]
+
+trait Trait {}
+
+trait T {
+    fn t(_: impl Trait);
+    fn tt<T: Trait>(_: T);
+}
diff --git a/tests/ui/impl_trait_in_params.rs b/tests/ui/impl_trait_in_params.rs
index b652e4a4abe..825bb76e3f7 100644
--- a/tests/ui/impl_trait_in_params.rs
+++ b/tests/ui/impl_trait_in_params.rs
@@ -1,20 +1,41 @@
 #![allow(unused)]
 #![warn(clippy::impl_trait_in_params)]
+
 //@no-rustfix
 pub trait Trait {}
 pub trait AnotherTrait<T> {}
 
 // Should warn
 pub fn a(_: impl Trait) {}
-//~^ ERROR: '`impl Trait` used as a function parameter'
-//~| NOTE: `-D clippy::impl-trait-in-params` implied by `-D warnings`
+//~^ ERROR: `impl Trait` used as a function parameter
 pub fn c<C: Trait>(_: C, _: impl Trait) {}
-//~^ ERROR: '`impl Trait` used as a function parameter'
-fn d(_: impl AnotherTrait<u32>) {}
+//~^ ERROR: `impl Trait` used as a function parameter
 
 // Shouldn't warn
 
 pub fn b<B: Trait>(_: B) {}
 fn e<T: AnotherTrait<u32>>(_: T) {}
+fn d(_: impl AnotherTrait<u32>) {}
+
+//------ IMPLS
+
+trait T {
+    // See test in ui-toml for a case where avoid-breaking-exported-api is set to true
+    fn t(_: impl Trait);
+    fn tt<T: Trait>(_: T) {}
+}
+
+struct S;
+impl S {
+    pub fn h(_: impl Trait) {} //~ ERROR: `impl Trait` used as a function parameter
+    fn i(_: impl Trait) {}
+    pub fn j<J: Trait>(_: J) {}
+    pub fn k<K: AnotherTrait<u32>>(_: K, _: impl AnotherTrait<u32>) {} //~ ERROR: `impl Trait` used as a function parameter
+}
+
+// Trying with traits
+impl T for S {
+    fn t(_: impl Trait) {}
+}
 
 fn main() {}
diff --git a/tests/ui/impl_trait_in_params.stderr b/tests/ui/impl_trait_in_params.stderr
index 36b4f27e9a4..9f6e545c3f2 100644
--- a/tests/ui/impl_trait_in_params.stderr
+++ b/tests/ui/impl_trait_in_params.stderr
@@ -1,5 +1,5 @@
-error: '`impl Trait` used as a function parameter'
-  --> $DIR/impl_trait_in_params.rs:8:13
+error: `impl Trait` used as a function parameter
+  --> $DIR/impl_trait_in_params.rs:9:13
    |
 LL | pub fn a(_: impl Trait) {}
    |             ^^^^^^^^^^
@@ -11,7 +11,7 @@ help: add a type parameter
 LL | pub fn a<{ /* Generic name */ }: Trait>(_: impl Trait) {}
    |         +++++++++++++++++++++++++++++++
 
-error: '`impl Trait` used as a function parameter'
+error: `impl Trait` used as a function parameter
   --> $DIR/impl_trait_in_params.rs:11:29
    |
 LL | pub fn c<C: Trait>(_: C, _: impl Trait) {}
@@ -22,5 +22,27 @@ help: add a type parameter
 LL | pub fn c<C: Trait, { /* Generic name */ }: Trait>(_: C, _: impl Trait) {}
    |                  +++++++++++++++++++++++++++++++
 
-error: aborting due to 2 previous errors
+error: `impl Trait` used as a function parameter
+  --> $DIR/impl_trait_in_params.rs:30:17
+   |
+LL |     pub fn h(_: impl Trait) {}
+   |                 ^^^^^^^^^^
+   |
+help: add a type parameter
+   |
+LL |     pub fn h<{ /* Generic name */ }: Trait>(_: impl Trait) {}
+   |             +++++++++++++++++++++++++++++++
+
+error: `impl Trait` used as a function parameter
+  --> $DIR/impl_trait_in_params.rs:33:45
+   |
+LL |     pub fn k<K: AnotherTrait<u32>>(_: K, _: impl AnotherTrait<u32>) {}
+   |                                             ^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: add a type parameter
+   |
+LL |     pub fn k<K: AnotherTrait<u32>, { /* Generic name */ }: AnotherTrait<u32>>(_: K, _: impl AnotherTrait<u32>) {}
+   |                                  +++++++++++++++++++++++++++++++++++++++++++
+
+error: aborting due to 4 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 775573768ed4bef5e0ebbfe7aa782a615eff2c51 Mon Sep 17 00:00:00 2001
From: blyxyas <blyxyas@gmail.com>
Date: Sat, 23 Sep 2023 20:36:06 +0200
Subject: Fix tests, only lint for public tests

---
 clippy_lints/src/functions/impl_trait_in_params.rs       | 10 +++++++---
 tests/ui-toml/impl_trait_in_params/clippy.toml           |  1 +
 .../ui-toml/impl_trait_in_params/impl_trait_in_params.rs | 16 ++++++++++++++++
 .../impl_trait_in_params/impl_trait_in_params.stderr     | 15 +++++++++++++++
 tests/ui-toml/impl_trait_in_params/true/clippy.toml      |  1 -
 .../impl_trait_in_params/true/impl_trait_in_params.rs    | 10 ----------
 tests/ui/impl_trait_in_params.rs                         | 12 +++++++++---
 tests/ui/impl_trait_in_params.stderr                     |  4 ++--
 8 files changed, 50 insertions(+), 19 deletions(-)
 create mode 100644 tests/ui-toml/impl_trait_in_params/clippy.toml
 create mode 100644 tests/ui-toml/impl_trait_in_params/impl_trait_in_params.rs
 create mode 100644 tests/ui-toml/impl_trait_in_params/impl_trait_in_params.stderr
 delete mode 100644 tests/ui-toml/impl_trait_in_params/true/clippy.toml
 delete mode 100644 tests/ui-toml/impl_trait_in_params/true/impl_trait_in_params.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/functions/impl_trait_in_params.rs b/clippy_lints/src/functions/impl_trait_in_params.rs
index 4a776dd2613..ee66c841ed2 100644
--- a/clippy_lints/src/functions/impl_trait_in_params.rs
+++ b/clippy_lints/src/functions/impl_trait_in_params.rs
@@ -6,7 +6,7 @@ use rustc_hir::intravisit::FnKind;
 use rustc_hir::{Body, GenericParam, Generics, HirId, ImplItem, ImplItemKind, TraitItem, TraitItemKind};
 use rustc_lint::LateContext;
 use rustc_span::symbol::Ident;
-use rustc_span::Span;
+use rustc_span::{BytePos, Span};
 
 use super::IMPL_TRAIT_IN_PARAMS;
 
@@ -89,12 +89,16 @@ pub(super) fn check_impl_item(cx: &LateContext<'_>, impl_item: &ImplItem<'_>) {
 pub(super) fn check_trait_item(cx: &LateContext<'_>, trait_item: &TraitItem<'_>, avoid_breaking_exported_api: bool) {
     if_chain! {
         if !avoid_breaking_exported_api;
-        if let TraitItemKind::Fn(sig, _) = trait_item.kind;
+        if let TraitItemKind::Fn(_, _) = trait_item.kind;
+        if let hir::Node::Item(item) = cx.tcx.hir().get_parent(trait_item.hir_id());
+        // ^^ (Will always be a trait)
+        if !item.vis_span.is_empty(); // Is public
         if !is_in_test_function(cx.tcx, trait_item.hir_id());
         then {
             for param in trait_item.generics.params {
                 if param.is_impl_trait() {
-                    report(cx, param, &trait_item.ident, trait_item.generics, sig.decl.inputs[0].span);
+                    let sp = trait_item.ident.span.with_hi(trait_item.ident.span.hi() + BytePos(1));
+                    report(cx, param, &trait_item.ident, trait_item.generics, sp.shrink_to_hi());
                 }
             }
         }
diff --git a/tests/ui-toml/impl_trait_in_params/clippy.toml b/tests/ui-toml/impl_trait_in_params/clippy.toml
new file mode 100644
index 00000000000..87e1f235741
--- /dev/null
+++ b/tests/ui-toml/impl_trait_in_params/clippy.toml
@@ -0,0 +1 @@
+avoid-breaking-exported-api = false
\ No newline at end of file
diff --git a/tests/ui-toml/impl_trait_in_params/impl_trait_in_params.rs b/tests/ui-toml/impl_trait_in_params/impl_trait_in_params.rs
new file mode 100644
index 00000000000..08fc7edf1c8
--- /dev/null
+++ b/tests/ui-toml/impl_trait_in_params/impl_trait_in_params.rs
@@ -0,0 +1,16 @@
+//! As avoid-breaking-exported-api is `false`, nothing here should lint
+#![warn(clippy::impl_trait_in_params)]
+#![no_main]
+//@no-rustfix
+
+pub trait Trait {}
+
+trait Private {
+    fn t(_: impl Trait);
+    fn tt<T: Trait>(_: T);
+}
+
+pub trait Public {
+    fn t(_: impl Trait); //~ ERROR: `impl Trait` used as a function parameter
+    fn tt<T: Trait>(_: T);
+}
diff --git a/tests/ui-toml/impl_trait_in_params/impl_trait_in_params.stderr b/tests/ui-toml/impl_trait_in_params/impl_trait_in_params.stderr
new file mode 100644
index 00000000000..80c4f5ed4b0
--- /dev/null
+++ b/tests/ui-toml/impl_trait_in_params/impl_trait_in_params.stderr
@@ -0,0 +1,15 @@
+error: `impl Trait` used as a function parameter
+  --> $DIR/impl_trait_in_params.rs:14:13
+   |
+LL |     fn t(_: impl Trait);
+   |             ^^^^^^^^^^
+   |
+   = note: `-D clippy::impl-trait-in-params` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::impl_trait_in_params)]`
+help: add a type parameter
+   |
+LL |     fn t<{ /* Generic name */ }: Trait>(_: impl Trait);
+   |         +++++++++++++++++++++++++++++++
+
+error: aborting due to previous error
+
diff --git a/tests/ui-toml/impl_trait_in_params/true/clippy.toml b/tests/ui-toml/impl_trait_in_params/true/clippy.toml
deleted file mode 100644
index 0e7ffd070a3..00000000000
--- a/tests/ui-toml/impl_trait_in_params/true/clippy.toml
+++ /dev/null
@@ -1 +0,0 @@
-avoid-breaking-exported-api = true
\ No newline at end of file
diff --git a/tests/ui-toml/impl_trait_in_params/true/impl_trait_in_params.rs b/tests/ui-toml/impl_trait_in_params/true/impl_trait_in_params.rs
deleted file mode 100644
index d1176ab8963..00000000000
--- a/tests/ui-toml/impl_trait_in_params/true/impl_trait_in_params.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-//! As avoid-breaking-exported-api is `true`, nothing here should lint
-#![warn(clippy::impl_trait_in_params)]
-#![no_main]
-
-trait Trait {}
-
-trait T {
-    fn t(_: impl Trait);
-    fn tt<T: Trait>(_: T);
-}
diff --git a/tests/ui/impl_trait_in_params.rs b/tests/ui/impl_trait_in_params.rs
index 825bb76e3f7..a6251a370d1 100644
--- a/tests/ui/impl_trait_in_params.rs
+++ b/tests/ui/impl_trait_in_params.rs
@@ -19,8 +19,14 @@ fn d(_: impl AnotherTrait<u32>) {}
 
 //------ IMPLS
 
-trait T {
-    // See test in ui-toml for a case where avoid-breaking-exported-api is set to true
+pub trait Public {
+    // See test in ui-toml for a case where avoid-breaking-exported-api is set to false
+    fn t(_: impl Trait);
+    fn tt<T: Trait>(_: T) {}
+}
+
+trait Private {
+    // This shouldn't lint
     fn t(_: impl Trait);
     fn tt<T: Trait>(_: T) {}
 }
@@ -34,7 +40,7 @@ impl S {
 }
 
 // Trying with traits
-impl T for S {
+impl Public for S {
     fn t(_: impl Trait) {}
 }
 
diff --git a/tests/ui/impl_trait_in_params.stderr b/tests/ui/impl_trait_in_params.stderr
index 9f6e545c3f2..0ae7a3672d1 100644
--- a/tests/ui/impl_trait_in_params.stderr
+++ b/tests/ui/impl_trait_in_params.stderr
@@ -23,7 +23,7 @@ LL | pub fn c<C: Trait, { /* Generic name */ }: Trait>(_: C, _: impl Trait) {}
    |                  +++++++++++++++++++++++++++++++
 
 error: `impl Trait` used as a function parameter
-  --> $DIR/impl_trait_in_params.rs:30:17
+  --> $DIR/impl_trait_in_params.rs:36:17
    |
 LL |     pub fn h(_: impl Trait) {}
    |                 ^^^^^^^^^^
@@ -34,7 +34,7 @@ LL |     pub fn h<{ /* Generic name */ }: Trait>(_: impl Trait) {}
    |             +++++++++++++++++++++++++++++++
 
 error: `impl Trait` used as a function parameter
-  --> $DIR/impl_trait_in_params.rs:33:45
+  --> $DIR/impl_trait_in_params.rs:39:45
    |
 LL |     pub fn k<K: AnotherTrait<u32>>(_: K, _: impl AnotherTrait<u32>) {}
    |                                             ^^^^^^^^^^^^^^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From bba155ea9dac4f320303696572f552e80042889c Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Mon, 9 Oct 2023 21:39:16 +0200
Subject: move changed logic to into its own util function

---
 clippy_lints/src/methods/filter_map_identity.rs |  4 +-
 clippy_lints/src/methods/flat_map_identity.rs   |  4 +-
 clippy_lints/src/methods/map_identity.rs        |  4 +-
 clippy_utils/src/lib.rs                         | 71 +++++++++++++++----------
 4 files changed, 49 insertions(+), 34 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/filter_map_identity.rs b/clippy_lints/src/methods/filter_map_identity.rs
index 3337b250c0e..20878f1e4df 100644
--- a/clippy_lints/src/methods/filter_map_identity.rs
+++ b/clippy_lints/src/methods/filter_map_identity.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::{is_expr_identity_function, is_trait_method};
+use clippy_utils::{is_expr_untyped_identity_function, is_trait_method};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
@@ -9,7 +9,7 @@ use rustc_span::sym;
 use super::FILTER_MAP_IDENTITY;
 
 pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, filter_map_arg: &hir::Expr<'_>, filter_map_span: Span) {
-    if is_trait_method(cx, expr, sym::Iterator) && is_expr_identity_function(cx, filter_map_arg) {
+    if is_trait_method(cx, expr, sym::Iterator) && is_expr_untyped_identity_function(cx, filter_map_arg) {
         span_lint_and_sugg(
             cx,
             FILTER_MAP_IDENTITY,
diff --git a/clippy_lints/src/methods/flat_map_identity.rs b/clippy_lints/src/methods/flat_map_identity.rs
index 84a21de0ac8..8849a4f4942 100644
--- a/clippy_lints/src/methods/flat_map_identity.rs
+++ b/clippy_lints/src/methods/flat_map_identity.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::{is_expr_identity_function, is_trait_method};
+use clippy_utils::{is_expr_untyped_identity_function, is_trait_method};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
@@ -15,7 +15,7 @@ pub(super) fn check<'tcx>(
     flat_map_arg: &'tcx hir::Expr<'_>,
     flat_map_span: Span,
 ) {
-    if is_trait_method(cx, expr, sym::Iterator) && is_expr_identity_function(cx, flat_map_arg) {
+    if is_trait_method(cx, expr, sym::Iterator) && is_expr_untyped_identity_function(cx, flat_map_arg) {
         span_lint_and_sugg(
             cx,
             FLAT_MAP_IDENTITY,
diff --git a/clippy_lints/src/methods/map_identity.rs b/clippy_lints/src/methods/map_identity.rs
index 7be1ce483f6..57581363cfa 100644
--- a/clippy_lints/src/methods/map_identity.rs
+++ b/clippy_lints/src/methods/map_identity.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{is_expr_identity_function, is_trait_method};
+use clippy_utils::{is_expr_untyped_identity_function, is_trait_method};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
@@ -23,7 +23,7 @@ pub(super) fn check(
         if is_trait_method(cx, expr, sym::Iterator)
             || is_type_diagnostic_item(cx, caller_ty, sym::Result)
             || is_type_diagnostic_item(cx, caller_ty, sym::Option);
-        if is_expr_identity_function(cx, map_arg);
+        if is_expr_untyped_identity_function(cx, map_arg);
         if let Some(sugg_span) = expr.span.trim_start(caller.span);
         then {
             span_lint_and_sugg(
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index e22bf11bb79..dc1b5a0a324 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -2027,36 +2027,31 @@ pub fn is_must_use_func_call(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
     did.map_or(false, |did| cx.tcx.has_attr(did, sym::must_use))
 }
 
-/// Checks if an expression represents the identity function
-/// Only examines closures and `std::convert::identity`
+/// Checks if a function's body represents the identity function. Looks for bodies of the form:
+/// * `|x| x`
+/// * `|x| return x`
+/// * `|x| { return x }`
+/// * `|x| { return x; }`
 ///
-/// Closure bindings with type annotations and `std::convert::identity` with generic args
-/// are not considered identity functions because they can guide type inference,
-/// and removing it may lead to compile errors.
-pub fn is_expr_identity_function(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-    /// Checks if a function's body represents the identity function. Looks for bodies of the form:
-    /// * `|x| x`
-    /// * `|x| return x`
-    /// * `|x| { return x }`
-    /// * `|x| { return x; }`
-    fn is_body_identity_function(cx: &LateContext<'_>, func: &Body<'_>) -> bool {
-        let id = if_chain! {
-            if let [param] = func.params;
-            if let PatKind::Binding(_, id, _, _) = param.pat.kind;
-            then {
-                id
-            } else {
-                return false;
-            }
-        };
+/// Consider calling [`is_expr_untyped_identity_function`] or [`is_expr_identity_function`] instead.
+fn is_body_identity_function(cx: &LateContext<'_>, func: &Body<'_>) -> bool {
+    let id = if_chain! {
+        if let [param] = func.params;
+        if let PatKind::Binding(_, id, _, _) = param.pat.kind;
+        then {
+            id
+        } else {
+            return false;
+        }
+    };
 
-        let mut expr = func.value;
-        loop {
-            match expr.kind {
-                #[rustfmt::skip]
+    let mut expr = func.value;
+    loop {
+        match expr.kind {
+            #[rustfmt::skip]
                 ExprKind::Block(&Block { stmts: [], expr: Some(e), .. }, _, )
                 | ExprKind::Ret(Some(e)) => expr = e,
-                #[rustfmt::skip]
+            #[rustfmt::skip]
                 ExprKind::Block(&Block { stmts: [stmt], expr: None, .. }, _) => {
                     if_chain! {
                         if let StmtKind::Semi(e) | StmtKind::Expr(e) = stmt.kind;
@@ -2068,11 +2063,16 @@ pub fn is_expr_identity_function(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool
                         }
                     }
                 },
-                _ => return path_to_local_id(expr, id) && cx.typeck_results().expr_adjustments(expr).is_empty(),
-            }
+            _ => return path_to_local_id(expr, id) && cx.typeck_results().expr_adjustments(expr).is_empty(),
         }
     }
+}
 
+/// This is the same as [`is_expr_identity_function`], but does not consider closures
+/// with type annotations for its bindings (or similar) as identity functions:
+/// * `|x: u8| x`
+/// * `std::convert::identity::<u8>`
+pub fn is_expr_untyped_identity_function(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
     match expr.kind {
         ExprKind::Closure(&Closure { body, fn_decl, .. })
             if fn_decl.inputs.iter().all(|ty| matches!(ty.kind, TyKind::Infer)) =>
@@ -2089,6 +2089,21 @@ pub fn is_expr_identity_function(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool
     }
 }
 
+/// Checks if an expression represents the identity function
+/// Only examines closures and `std::convert::identity`
+///
+/// NOTE: If you want to use this function to find out if a closure is unnecessary, you likely want
+/// to call [`is_expr_untyped_identity_function`] instead, which makes sure that the closure doesn't
+/// have type annotations. This is important because removing a closure with bindings can
+/// remove type information that helped type inference before, which can then lead to compile
+/// errors.
+pub fn is_expr_identity_function(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+    match expr.kind {
+        ExprKind::Closure(&Closure { body, .. }) => is_body_identity_function(cx, cx.tcx.hir().body(body)),
+        _ => path_def_id(cx, expr).map_or(false, |id| match_def_path(cx, id, &paths::CONVERT_IDENTITY)),
+    }
+}
+
 /// Gets the node where an expression is either used, or it's type is unified with another branch.
 /// Returns both the node and the `HirId` of the closest child node.
 pub fn get_expr_use_or_unification_node<'tcx>(tcx: TyCtxt<'tcx>, expr: &Expr<'_>) -> Option<(Node<'tcx>, HirId)> {
-- 
cgit 1.4.1-3-g733a5


From b5488f98503d77740fe59546921a4ed55eeb7e9e Mon Sep 17 00:00:00 2001
From: Alona Enraght-Moony <code@alona.page>
Date: Thu, 12 Oct 2023 17:49:58 +0000
Subject: [`manual_is_ascii_check`]: Also check for `is_ascii_hexdigt`

---
 clippy_lints/src/manual_is_ascii_check.rs | 24 +++++++++++++++++++++---
 tests/ui/manual_is_ascii_check.fixed      |  4 ++++
 tests/ui/manual_is_ascii_check.rs         |  4 ++++
 tests/ui/manual_is_ascii_check.stderr     | 22 +++++++++++++++++-----
 4 files changed, 46 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_is_ascii_check.rs b/clippy_lints/src/manual_is_ascii_check.rs
index f264424470d..9da20a28fba 100644
--- a/clippy_lints/src/manual_is_ascii_check.rs
+++ b/clippy_lints/src/manual_is_ascii_check.rs
@@ -15,12 +15,13 @@ use rustc_span::{sym, Span};
 declare_clippy_lint! {
     /// ### What it does
     /// Suggests to use dedicated built-in methods,
-    /// `is_ascii_(lowercase|uppercase|digit)` for checking on corresponding ascii range
+    /// `is_ascii_(lowercase|uppercase|digit|hexdigit)` for checking on corresponding
+    /// ascii range
     ///
     /// ### Why is this bad?
     /// Using the built-in functions is more readable and makes it
     /// clear that it's not a specific subset of characters, but all
-    /// ASCII (lowercase|uppercase|digit) characters.
+    /// ASCII (lowercase|uppercase|digit|hexdigit) characters.
     /// ### Example
     /// ```rust
     /// fn main() {
@@ -28,6 +29,7 @@ declare_clippy_lint! {
     ///     assert!(matches!(b'X', b'A'..=b'Z'));
     ///     assert!(matches!('2', '0'..='9'));
     ///     assert!(matches!('x', 'A'..='Z' | 'a'..='z'));
+    ///     assert!(matches!('C', '0'..='9' | 'a'..='f' | 'A'..='F'));
     ///
     ///     ('0'..='9').contains(&'0');
     ///     ('a'..='z').contains(&'a');
@@ -41,6 +43,7 @@ declare_clippy_lint! {
     ///     assert!(b'X'.is_ascii_uppercase());
     ///     assert!('2'.is_ascii_digit());
     ///     assert!('x'.is_ascii_alphabetic());
+    ///     assert!('C'.is_ascii_hexdigit());
     ///
     ///     '0'.is_ascii_digit();
     ///     'a'.is_ascii_lowercase();
@@ -75,6 +78,12 @@ enum CharRange {
     FullChar,
     /// '0..=9'
     Digit,
+    /// 'a..=f'
+    LowerHexLetter,
+    /// 'A..=F'
+    UpperHexLetter,
+    /// '0..=9' | 'a..=f' | 'A..=F'
+    HexDigit,
     Otherwise,
 }
 
@@ -116,7 +125,8 @@ fn check_is_ascii(cx: &LateContext<'_>, span: Span, recv: &Expr<'_>, range: &Cha
         CharRange::LowerChar => Some("is_ascii_lowercase"),
         CharRange::FullChar => Some("is_ascii_alphabetic"),
         CharRange::Digit => Some("is_ascii_digit"),
-        CharRange::Otherwise => None,
+        CharRange::HexDigit => Some("is_ascii_hexdigit"),
+        CharRange::Otherwise | CharRange::LowerHexLetter | CharRange::UpperHexLetter => None,
     } {
         let default_snip = "..";
         let mut app = Applicability::MachineApplicable;
@@ -141,6 +151,12 @@ fn check_pat(pat_kind: &PatKind<'_>) -> CharRange {
 
             if ranges.len() == 2 && ranges.contains(&CharRange::UpperChar) && ranges.contains(&CharRange::LowerChar) {
                 CharRange::FullChar
+            } else if ranges.len() == 3
+                && ranges.contains(&CharRange::Digit)
+                && ranges.contains(&CharRange::LowerHexLetter)
+                && ranges.contains(&CharRange::UpperHexLetter)
+            {
+                CharRange::HexDigit
             } else {
                 CharRange::Otherwise
             }
@@ -156,6 +172,8 @@ fn check_range(start: &Expr<'_>, end: &Expr<'_>) -> CharRange {
         match (&start_lit.node, &end_lit.node) {
             (Char('a'), Char('z')) | (Byte(b'a'), Byte(b'z')) => CharRange::LowerChar,
             (Char('A'), Char('Z')) | (Byte(b'A'), Byte(b'Z')) => CharRange::UpperChar,
+            (Char('a'), Char('f')) | (Byte(b'a'), Byte(b'f')) => CharRange::LowerHexLetter,
+            (Char('A'), Char('F')) | (Byte(b'A'), Byte(b'F')) => CharRange::UpperHexLetter,
             (Char('0'), Char('9')) | (Byte(b'0'), Byte(b'9')) => CharRange::Digit,
             _ => CharRange::Otherwise,
         }
diff --git a/tests/ui/manual_is_ascii_check.fixed b/tests/ui/manual_is_ascii_check.fixed
index 5be2dd280b8..9c4bd335ad8 100644
--- a/tests/ui/manual_is_ascii_check.fixed
+++ b/tests/ui/manual_is_ascii_check.fixed
@@ -33,6 +33,7 @@ fn msrv_1_23() {
     assert!(matches!(b'1', b'0'..=b'9'));
     assert!(matches!('X', 'A'..='Z'));
     assert!(matches!('x', 'A'..='Z' | 'a'..='z'));
+    assert!(matches!('x', '0'..='9' | 'a'..='f' | 'A'..='F'));
 }
 
 #[clippy::msrv = "1.24"]
@@ -40,14 +41,17 @@ fn msrv_1_24() {
     assert!(b'1'.is_ascii_digit());
     assert!('X'.is_ascii_uppercase());
     assert!('x'.is_ascii_alphabetic());
+    assert!('x'.is_ascii_hexdigit());
 }
 
 #[clippy::msrv = "1.46"]
 fn msrv_1_46() {
     const FOO: bool = matches!('x', '0'..='9');
+    const BAR: bool = matches!('x', '0'..='9' | 'a'..='f' | 'A'..='F');
 }
 
 #[clippy::msrv = "1.47"]
 fn msrv_1_47() {
     const FOO: bool = 'x'.is_ascii_digit();
+    const BAR: bool = 'x'.is_ascii_hexdigit();
 }
diff --git a/tests/ui/manual_is_ascii_check.rs b/tests/ui/manual_is_ascii_check.rs
index f9249e22a02..785943cd24d 100644
--- a/tests/ui/manual_is_ascii_check.rs
+++ b/tests/ui/manual_is_ascii_check.rs
@@ -33,6 +33,7 @@ fn msrv_1_23() {
     assert!(matches!(b'1', b'0'..=b'9'));
     assert!(matches!('X', 'A'..='Z'));
     assert!(matches!('x', 'A'..='Z' | 'a'..='z'));
+    assert!(matches!('x', '0'..='9' | 'a'..='f' | 'A'..='F'));
 }
 
 #[clippy::msrv = "1.24"]
@@ -40,14 +41,17 @@ fn msrv_1_24() {
     assert!(matches!(b'1', b'0'..=b'9'));
     assert!(matches!('X', 'A'..='Z'));
     assert!(matches!('x', 'A'..='Z' | 'a'..='z'));
+    assert!(matches!('x', '0'..='9' | 'a'..='f' | 'A'..='F'));
 }
 
 #[clippy::msrv = "1.46"]
 fn msrv_1_46() {
     const FOO: bool = matches!('x', '0'..='9');
+    const BAR: bool = matches!('x', '0'..='9' | 'a'..='f' | 'A'..='F');
 }
 
 #[clippy::msrv = "1.47"]
 fn msrv_1_47() {
     const FOO: bool = matches!('x', '0'..='9');
+    const BAR: bool = matches!('x', '0'..='9' | 'a'..='f' | 'A'..='F');
 }
diff --git a/tests/ui/manual_is_ascii_check.stderr b/tests/ui/manual_is_ascii_check.stderr
index e0fb46e59fa..f69522c5ff8 100644
--- a/tests/ui/manual_is_ascii_check.stderr
+++ b/tests/ui/manual_is_ascii_check.stderr
@@ -98,28 +98,40 @@ LL |     ('A'..='Z').contains(cool_letter);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `cool_letter.is_ascii_uppercase()`
 
 error: manual check for common ascii range
-  --> $DIR/manual_is_ascii_check.rs:40:13
+  --> $DIR/manual_is_ascii_check.rs:41:13
    |
 LL |     assert!(matches!(b'1', b'0'..=b'9'));
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `b'1'.is_ascii_digit()`
 
 error: manual check for common ascii range
-  --> $DIR/manual_is_ascii_check.rs:41:13
+  --> $DIR/manual_is_ascii_check.rs:42:13
    |
 LL |     assert!(matches!('X', 'A'..='Z'));
    |             ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `'X'.is_ascii_uppercase()`
 
 error: manual check for common ascii range
-  --> $DIR/manual_is_ascii_check.rs:42:13
+  --> $DIR/manual_is_ascii_check.rs:43:13
    |
 LL |     assert!(matches!('x', 'A'..='Z' | 'a'..='z'));
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `'x'.is_ascii_alphabetic()`
 
 error: manual check for common ascii range
-  --> $DIR/manual_is_ascii_check.rs:52:23
+  --> $DIR/manual_is_ascii_check.rs:44:13
+   |
+LL |     assert!(matches!('x', '0'..='9' | 'a'..='f' | 'A'..='F'));
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `'x'.is_ascii_hexdigit()`
+
+error: manual check for common ascii range
+  --> $DIR/manual_is_ascii_check.rs:55:23
    |
 LL |     const FOO: bool = matches!('x', '0'..='9');
    |                       ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `'x'.is_ascii_digit()`
 
-error: aborting due to 20 previous errors
+error: manual check for common ascii range
+  --> $DIR/manual_is_ascii_check.rs:56:23
+   |
+LL |     const BAR: bool = matches!('x', '0'..='9' | 'a'..='f' | 'A'..='F');
+   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `'x'.is_ascii_hexdigit()`
+
+error: aborting due to 22 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From eb6fb18a99b54455505ea6be7f0484eb8af62189 Mon Sep 17 00:00:00 2001
From: koka <koka.code@gmail.com>
Date: Fri, 13 Oct 2023 17:07:29 +0900
Subject: Avoid `panic!`, omit instead

---
 clippy_lints/src/utils/author.rs        | 18 ++++++++-------
 tests/ui/author/macro_in_closure.rs     |  5 +++++
 tests/ui/author/macro_in_closure.stdout | 39 +++++++++++++++++++++++++++++++++
 3 files changed, 54 insertions(+), 8 deletions(-)
 create mode 100644 tests/ui/author/macro_in_closure.rs
 create mode 100644 tests/ui/author/macro_in_closure.stdout

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/utils/author.rs b/clippy_lints/src/utils/author.rs
index f02c33cc674..aecb0c6dbfa 100644
--- a/clippy_lints/src/utils/author.rs
+++ b/clippy_lints/src/utils/author.rs
@@ -268,8 +268,8 @@ impl<'a, 'tcx> PrintVisitor<'a, 'tcx> {
     fn qpath(&self, qpath: &Binding<&QPath<'_>>) {
         if let QPath::LangItem(lang_item, ..) = *qpath.value {
             chain!(self, "matches!({qpath}, QPath::LangItem(LangItem::{lang_item:?}, _))");
-        } else {
-            chain!(self, "match_qpath({qpath}, &[{}])", path_to_string(qpath.value));
+        } else if let Ok(path) = path_to_string(qpath.value) {
+            chain!(self, "match_qpath({qpath}, &[{}])", path);
         }
     }
 
@@ -738,8 +738,8 @@ fn has_attr(cx: &LateContext<'_>, hir_id: hir::HirId) -> bool {
     get_attr(cx.sess(), attrs, "author").count() > 0
 }
 
-fn path_to_string(path: &QPath<'_>) -> String {
-    fn inner(s: &mut String, path: &QPath<'_>) {
+fn path_to_string(path: &QPath<'_>) -> Result<String, ()> {
+    fn inner(s: &mut String, path: &QPath<'_>) -> Result<(), ()> {
         match *path {
             QPath::Resolved(_, path) => {
                 for (i, segment) in path.segments.iter().enumerate() {
@@ -751,16 +751,18 @@ fn path_to_string(path: &QPath<'_>) -> String {
             },
             QPath::TypeRelative(ty, segment) => match &ty.kind {
                 hir::TyKind::Path(inner_path) => {
-                    inner(s, inner_path);
+                    inner(s, inner_path)?;
                     *s += ", ";
                     write!(s, "{:?}", segment.ident.as_str()).unwrap();
                 },
                 other => write!(s, "/* unimplemented: {other:?}*/").unwrap(),
             },
-            QPath::LangItem(..) => panic!("path_to_string: called for lang item qpath"),
+            QPath::LangItem(..) => return Err(()),
         }
+
+        Ok(())
     }
     let mut s = String::new();
-    inner(&mut s, path);
-    s
+    inner(&mut s, path)?;
+    Ok(s)
 }
diff --git a/tests/ui/author/macro_in_closure.rs b/tests/ui/author/macro_in_closure.rs
new file mode 100644
index 00000000000..444e6a12165
--- /dev/null
+++ b/tests/ui/author/macro_in_closure.rs
@@ -0,0 +1,5 @@
+fn main() {
+    #[clippy::author]
+    let print_text = |x| println!("{}", x);
+    print_text("hello");
+}
diff --git a/tests/ui/author/macro_in_closure.stdout b/tests/ui/author/macro_in_closure.stdout
new file mode 100644
index 00000000000..9ab71986f40
--- /dev/null
+++ b/tests/ui/author/macro_in_closure.stdout
@@ -0,0 +1,39 @@
+if let StmtKind::Local(local) = stmt.kind
+    && let Some(init) = local.init
+    && let ExprKind::Closure(CaptureBy::Ref, fn_decl, body_id, _, None) = init.kind
+    && let FnRetTy::DefaultReturn(_) = fn_decl.output
+    && expr = &cx.tcx.hir().body(body_id).value
+    && let ExprKind::Block(block, None) = expr.kind
+    && block.stmts.len() == 1
+    && let StmtKind::Semi(e) = block.stmts[0].kind
+    && let ExprKind::Call(func, args) = e.kind
+    && let ExprKind::Path(ref qpath) = func.kind
+    && match_qpath(qpath, &["$crate", "io", "_print"])
+    && args.len() == 1
+    && let ExprKind::Call(func1, args1) = args[0].kind
+    && let ExprKind::Path(ref qpath1) = func1.kind
+    && args1.len() == 2
+    && let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Not, inner) = args1[0].kind
+    && let ExprKind::Array(elements) = inner.kind
+    && elements.len() == 2
+    && let ExprKind::Lit(ref lit) = elements[0].kind
+    && let LitKind::Str(s, _) = lit.node
+    && s.as_str() == ""
+    && let ExprKind::Lit(ref lit1) = elements[1].kind
+    && let LitKind::Str(s1, _) = lit1.node
+    && s1.as_str() == "\n"
+    && let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Not, inner1) = args1[1].kind
+    && let ExprKind::Array(elements1) = inner1.kind
+    && elements1.len() == 1
+    && let ExprKind::Call(func2, args2) = elements1[0].kind
+    && let ExprKind::Path(ref qpath2) = func2.kind
+    && args2.len() == 1
+    && let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Not, inner2) = args2[0].kind
+    && let ExprKind::Path(ref qpath3) = inner2.kind
+    && match_qpath(qpath3, &["x"])
+    && block.expr.is_none()
+    && let PatKind::Binding(BindingAnnotation::NONE, _, name, None) = local.pat.kind
+    && name.as_str() == "print_text"
+{
+    // report your lint here
+}
-- 
cgit 1.4.1-3-g733a5


From 6ed04af81c3bf79ee49f88e219fd168ff51886c8 Mon Sep 17 00:00:00 2001
From: Nilstrieb <48135649+Nilstrieb@users.noreply.github.com>
Date: Sun, 8 Oct 2023 21:52:16 +0200
Subject: Make `multiple_unsafe_ops_per_block` ignore await desugaring

The await desugaring contains two calls (`Poll::new_unchecked` and
`get_context`) inside a single unsafe block. That violates the lint.
---
 clippy_lints/src/multiple_unsafe_ops_per_block.rs | 7 +++++--
 tests/ui/multiple_unsafe_ops_per_block.rs         | 7 +++++++
 2 files changed, 12 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/multiple_unsafe_ops_per_block.rs b/clippy_lints/src/multiple_unsafe_ops_per_block.rs
index fe35126aab2..2c42a7a3676 100644
--- a/clippy_lints/src/multiple_unsafe_ops_per_block.rs
+++ b/clippy_lints/src/multiple_unsafe_ops_per_block.rs
@@ -9,7 +9,7 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::Span;
+use rustc_span::{DesugaringKind, Span};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -64,7 +64,10 @@ declare_lint_pass!(MultipleUnsafeOpsPerBlock => [MULTIPLE_UNSAFE_OPS_PER_BLOCK])
 
 impl<'tcx> LateLintPass<'tcx> for MultipleUnsafeOpsPerBlock {
     fn check_block(&mut self, cx: &LateContext<'tcx>, block: &'tcx hir::Block<'_>) {
-        if !matches!(block.rules, BlockCheckMode::UnsafeBlock(_)) || in_external_macro(cx.tcx.sess, block.span) {
+        if !matches!(block.rules, BlockCheckMode::UnsafeBlock(_))
+            || in_external_macro(cx.tcx.sess, block.span)
+            || block.span.is_desugaring(DesugaringKind::Await)
+        {
             return;
         }
         let mut unsafe_ops = vec![];
diff --git a/tests/ui/multiple_unsafe_ops_per_block.rs b/tests/ui/multiple_unsafe_ops_per_block.rs
index 4ef6f0ca92f..8afb4df20af 100644
--- a/tests/ui/multiple_unsafe_ops_per_block.rs
+++ b/tests/ui/multiple_unsafe_ops_per_block.rs
@@ -147,4 +147,11 @@ fn _field_fn_ptr(x: unsafe fn()) {
     }
 }
 
+// await expands to an unsafe block with several operations, but this is fine.: #11312
+async fn await_desugaring_silent() {
+    async fn helper() {}
+
+    helper().await;
+}
+
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From bb6516ace013a2ec33ca1276b029786dfbb46ee1 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Mon, 16 Oct 2023 00:29:28 +0200
Subject: [`unnecessary_lazy_eval`]: don't emit autofix suggestion if closure
 has return type

---
 clippy_lints/src/methods/unnecessary_lazy_eval.rs | 12 ++-
 tests/ui/unnecessary_lazy_eval.fixed              |  3 +
 tests/ui/unnecessary_lazy_eval.rs                 |  3 +
 tests/ui/unnecessary_lazy_eval.stderr             | 94 +++++++++++++----------
 tests/ui/unnecessary_lazy_eval_unfixable.rs       |  5 ++
 tests/ui/unnecessary_lazy_eval_unfixable.stderr   | 10 ++-
 6 files changed, 85 insertions(+), 42 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/unnecessary_lazy_eval.rs b/clippy_lints/src/methods/unnecessary_lazy_eval.rs
index 47e2e744112..4a651396f14 100644
--- a/clippy_lints/src/methods/unnecessary_lazy_eval.rs
+++ b/clippy_lints/src/methods/unnecessary_lazy_eval.rs
@@ -2,6 +2,7 @@ use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::{eager_or_lazy, is_from_proc_macro, usage};
+use hir::FnRetTy;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
@@ -27,7 +28,7 @@ pub(super) fn check<'tcx>(
     let is_bool = cx.typeck_results().expr_ty(recv).is_bool();
 
     if is_option || is_result || is_bool {
-        if let hir::ExprKind::Closure(&hir::Closure { body, .. }) = arg.kind {
+        if let hir::ExprKind::Closure(&hir::Closure { body, fn_decl, .. }) = arg.kind {
             let body = cx.tcx.hir().body(body);
             let body_expr = &body.value;
 
@@ -48,7 +49,14 @@ pub(super) fn check<'tcx>(
                     .iter()
                     // bindings are checked to be unused above
                     .all(|param| matches!(param.pat.kind, hir::PatKind::Binding(..) | hir::PatKind::Wild))
-                {
+                    && matches!(
+                        fn_decl.output,
+                        FnRetTy::DefaultReturn(_)
+                            | FnRetTy::Return(hir::Ty {
+                                kind: hir::TyKind::Infer,
+                                ..
+                            })
+                    ) {
                     Applicability::MachineApplicable
                 } else {
                     // replacing the lambda may break type inference
diff --git a/tests/ui/unnecessary_lazy_eval.fixed b/tests/ui/unnecessary_lazy_eval.fixed
index 304e7b7fd7f..4778eaefdbd 100644
--- a/tests/ui/unnecessary_lazy_eval.fixed
+++ b/tests/ui/unnecessary_lazy_eval.fixed
@@ -5,6 +5,7 @@
 #![allow(clippy::map_identity)]
 #![allow(clippy::needless_borrow)]
 #![allow(clippy::unnecessary_literal_unwrap)]
+#![allow(clippy::unit_arg)]
 
 use std::ops::Deref;
 
@@ -76,6 +77,8 @@ fn main() {
     let _ = opt.ok_or(2);
     let _ = nested_tuple_opt.unwrap_or(Some((1, 2)));
     let _ = cond.then_some(astronomers_pi);
+    let _ = true.then_some({});
+    let _ = true.then_some({});
 
     // Should lint - Builtin deref
     let r = &1;
diff --git a/tests/ui/unnecessary_lazy_eval.rs b/tests/ui/unnecessary_lazy_eval.rs
index ddfa6bb3ef6..d4b7fd31b1b 100644
--- a/tests/ui/unnecessary_lazy_eval.rs
+++ b/tests/ui/unnecessary_lazy_eval.rs
@@ -5,6 +5,7 @@
 #![allow(clippy::map_identity)]
 #![allow(clippy::needless_borrow)]
 #![allow(clippy::unnecessary_literal_unwrap)]
+#![allow(clippy::unit_arg)]
 
 use std::ops::Deref;
 
@@ -76,6 +77,8 @@ fn main() {
     let _ = opt.ok_or_else(|| 2);
     let _ = nested_tuple_opt.unwrap_or_else(|| Some((1, 2)));
     let _ = cond.then(|| astronomers_pi);
+    let _ = true.then(|| -> _ {});
+    let _ = true.then(|| {});
 
     // Should lint - Builtin deref
     let r = &1;
diff --git a/tests/ui/unnecessary_lazy_eval.stderr b/tests/ui/unnecessary_lazy_eval.stderr
index 4f1ca374872..1b0db4759bb 100644
--- a/tests/ui/unnecessary_lazy_eval.stderr
+++ b/tests/ui/unnecessary_lazy_eval.stderr
@@ -1,5 +1,5 @@
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:68:13
+  --> $DIR/unnecessary_lazy_eval.rs:69:13
    |
 LL |     let _ = opt.unwrap_or_else(|| 2);
    |             ^^^^--------------------
@@ -10,7 +10,7 @@ LL |     let _ = opt.unwrap_or_else(|| 2);
    = help: to override `-D warnings` add `#[allow(clippy::unnecessary_lazy_evaluations)]`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:69:13
+  --> $DIR/unnecessary_lazy_eval.rs:70:13
    |
 LL |     let _ = opt.unwrap_or_else(|| astronomers_pi);
    |             ^^^^---------------------------------
@@ -18,7 +18,7 @@ LL |     let _ = opt.unwrap_or_else(|| astronomers_pi);
    |                 help: use `unwrap_or(..)` instead: `unwrap_or(astronomers_pi)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:70:13
+  --> $DIR/unnecessary_lazy_eval.rs:71:13
    |
 LL |     let _ = opt.unwrap_or_else(|| ext_str.some_field);
    |             ^^^^-------------------------------------
@@ -26,7 +26,7 @@ LL |     let _ = opt.unwrap_or_else(|| ext_str.some_field);
    |                 help: use `unwrap_or(..)` instead: `unwrap_or(ext_str.some_field)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:72:13
+  --> $DIR/unnecessary_lazy_eval.rs:73:13
    |
 LL |     let _ = opt.and_then(|_| ext_opt);
    |             ^^^^---------------------
@@ -34,7 +34,7 @@ LL |     let _ = opt.and_then(|_| ext_opt);
    |                 help: use `and(..)` instead: `and(ext_opt)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:73:13
+  --> $DIR/unnecessary_lazy_eval.rs:74:13
    |
 LL |     let _ = opt.or_else(|| ext_opt);
    |             ^^^^-------------------
@@ -42,7 +42,7 @@ LL |     let _ = opt.or_else(|| ext_opt);
    |                 help: use `or(..)` instead: `or(ext_opt)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:74:13
+  --> $DIR/unnecessary_lazy_eval.rs:75:13
    |
 LL |     let _ = opt.or_else(|| None);
    |             ^^^^----------------
@@ -50,7 +50,7 @@ LL |     let _ = opt.or_else(|| None);
    |                 help: use `or(..)` instead: `or(None)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:75:13
+  --> $DIR/unnecessary_lazy_eval.rs:76:13
    |
 LL |     let _ = opt.get_or_insert_with(|| 2);
    |             ^^^^------------------------
@@ -58,7 +58,7 @@ LL |     let _ = opt.get_or_insert_with(|| 2);
    |                 help: use `get_or_insert(..)` instead: `get_or_insert(2)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:76:13
+  --> $DIR/unnecessary_lazy_eval.rs:77:13
    |
 LL |     let _ = opt.ok_or_else(|| 2);
    |             ^^^^----------------
@@ -66,7 +66,7 @@ LL |     let _ = opt.ok_or_else(|| 2);
    |                 help: use `ok_or(..)` instead: `ok_or(2)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:77:13
+  --> $DIR/unnecessary_lazy_eval.rs:78:13
    |
 LL |     let _ = nested_tuple_opt.unwrap_or_else(|| Some((1, 2)));
    |             ^^^^^^^^^^^^^^^^^-------------------------------
@@ -74,15 +74,31 @@ LL |     let _ = nested_tuple_opt.unwrap_or_else(|| Some((1, 2)));
    |                              help: use `unwrap_or(..)` instead: `unwrap_or(Some((1, 2)))`
 
 error: unnecessary closure used with `bool::then`
-  --> $DIR/unnecessary_lazy_eval.rs:78:13
+  --> $DIR/unnecessary_lazy_eval.rs:79:13
    |
 LL |     let _ = cond.then(|| astronomers_pi);
    |             ^^^^^-----------------------
    |                  |
    |                  help: use `then_some(..)` instead: `then_some(astronomers_pi)`
 
+error: unnecessary closure used with `bool::then`
+  --> $DIR/unnecessary_lazy_eval.rs:80:13
+   |
+LL |     let _ = true.then(|| -> _ {});
+   |             ^^^^^----------------
+   |                  |
+   |                  help: use `then_some(..)` instead: `then_some({})`
+
+error: unnecessary closure used with `bool::then`
+  --> $DIR/unnecessary_lazy_eval.rs:81:13
+   |
+LL |     let _ = true.then(|| {});
+   |             ^^^^^-----------
+   |                  |
+   |                  help: use `then_some(..)` instead: `then_some({})`
+
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:82:13
+  --> $DIR/unnecessary_lazy_eval.rs:85:13
    |
 LL |     let _ = Some(1).unwrap_or_else(|| *r);
    |             ^^^^^^^^---------------------
@@ -90,7 +106,7 @@ LL |     let _ = Some(1).unwrap_or_else(|| *r);
    |                     help: use `unwrap_or(..)` instead: `unwrap_or(*r)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:84:13
+  --> $DIR/unnecessary_lazy_eval.rs:87:13
    |
 LL |     let _ = Some(1).unwrap_or_else(|| *b);
    |             ^^^^^^^^---------------------
@@ -98,7 +114,7 @@ LL |     let _ = Some(1).unwrap_or_else(|| *b);
    |                     help: use `unwrap_or(..)` instead: `unwrap_or(*b)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:86:13
+  --> $DIR/unnecessary_lazy_eval.rs:89:13
    |
 LL |     let _ = Some(1).as_ref().unwrap_or_else(|| &r);
    |             ^^^^^^^^^^^^^^^^^---------------------
@@ -106,7 +122,7 @@ LL |     let _ = Some(1).as_ref().unwrap_or_else(|| &r);
    |                              help: use `unwrap_or(..)` instead: `unwrap_or(&r)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:87:13
+  --> $DIR/unnecessary_lazy_eval.rs:90:13
    |
 LL |     let _ = Some(1).as_ref().unwrap_or_else(|| &b);
    |             ^^^^^^^^^^^^^^^^^---------------------
@@ -114,7 +130,7 @@ LL |     let _ = Some(1).as_ref().unwrap_or_else(|| &b);
    |                              help: use `unwrap_or(..)` instead: `unwrap_or(&b)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:90:13
+  --> $DIR/unnecessary_lazy_eval.rs:93:13
    |
 LL |     let _ = Some(10).unwrap_or_else(|| 2);
    |             ^^^^^^^^^--------------------
@@ -122,7 +138,7 @@ LL |     let _ = Some(10).unwrap_or_else(|| 2);
    |                      help: use `unwrap_or(..)` instead: `unwrap_or(2)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:91:13
+  --> $DIR/unnecessary_lazy_eval.rs:94:13
    |
 LL |     let _ = Some(10).and_then(|_| ext_opt);
    |             ^^^^^^^^^---------------------
@@ -130,7 +146,7 @@ LL |     let _ = Some(10).and_then(|_| ext_opt);
    |                      help: use `and(..)` instead: `and(ext_opt)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:92:28
+  --> $DIR/unnecessary_lazy_eval.rs:95:28
    |
 LL |     let _: Option<usize> = None.or_else(|| ext_opt);
    |                            ^^^^^-------------------
@@ -138,7 +154,7 @@ LL |     let _: Option<usize> = None.or_else(|| ext_opt);
    |                                 help: use `or(..)` instead: `or(ext_opt)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:93:13
+  --> $DIR/unnecessary_lazy_eval.rs:96:13
    |
 LL |     let _ = None.get_or_insert_with(|| 2);
    |             ^^^^^------------------------
@@ -146,7 +162,7 @@ LL |     let _ = None.get_or_insert_with(|| 2);
    |                  help: use `get_or_insert(..)` instead: `get_or_insert(2)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:94:35
+  --> $DIR/unnecessary_lazy_eval.rs:97:35
    |
 LL |     let _: Result<usize, usize> = None.ok_or_else(|| 2);
    |                                   ^^^^^----------------
@@ -154,7 +170,7 @@ LL |     let _: Result<usize, usize> = None.ok_or_else(|| 2);
    |                                        help: use `ok_or(..)` instead: `ok_or(2)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:95:28
+  --> $DIR/unnecessary_lazy_eval.rs:98:28
    |
 LL |     let _: Option<usize> = None.or_else(|| None);
    |                            ^^^^^----------------
@@ -162,7 +178,7 @@ LL |     let _: Option<usize> = None.or_else(|| None);
    |                                 help: use `or(..)` instead: `or(None)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:98:13
+  --> $DIR/unnecessary_lazy_eval.rs:101:13
    |
 LL |     let _ = deep.0.unwrap_or_else(|| 2);
    |             ^^^^^^^--------------------
@@ -170,7 +186,7 @@ LL |     let _ = deep.0.unwrap_or_else(|| 2);
    |                    help: use `unwrap_or(..)` instead: `unwrap_or(2)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:99:13
+  --> $DIR/unnecessary_lazy_eval.rs:102:13
    |
 LL |     let _ = deep.0.and_then(|_| ext_opt);
    |             ^^^^^^^---------------------
@@ -178,7 +194,7 @@ LL |     let _ = deep.0.and_then(|_| ext_opt);
    |                    help: use `and(..)` instead: `and(ext_opt)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:100:13
+  --> $DIR/unnecessary_lazy_eval.rs:103:13
    |
 LL |     let _ = deep.0.or_else(|| None);
    |             ^^^^^^^----------------
@@ -186,7 +202,7 @@ LL |     let _ = deep.0.or_else(|| None);
    |                    help: use `or(..)` instead: `or(None)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:101:13
+  --> $DIR/unnecessary_lazy_eval.rs:104:13
    |
 LL |     let _ = deep.0.get_or_insert_with(|| 2);
    |             ^^^^^^^------------------------
@@ -194,7 +210,7 @@ LL |     let _ = deep.0.get_or_insert_with(|| 2);
    |                    help: use `get_or_insert(..)` instead: `get_or_insert(2)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:102:13
+  --> $DIR/unnecessary_lazy_eval.rs:105:13
    |
 LL |     let _ = deep.0.ok_or_else(|| 2);
    |             ^^^^^^^----------------
@@ -202,7 +218,7 @@ LL |     let _ = deep.0.ok_or_else(|| 2);
    |                    help: use `ok_or(..)` instead: `ok_or(2)`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:132:28
+  --> $DIR/unnecessary_lazy_eval.rs:135:28
    |
 LL |     let _: Option<usize> = None.or_else(|| Some(3));
    |                            ^^^^^-------------------
@@ -210,7 +226,7 @@ LL |     let _: Option<usize> = None.or_else(|| Some(3));
    |                                 help: use `or(..)` instead: `or(Some(3))`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:133:13
+  --> $DIR/unnecessary_lazy_eval.rs:136:13
    |
 LL |     let _ = deep.0.or_else(|| Some(3));
    |             ^^^^^^^-------------------
@@ -218,7 +234,7 @@ LL |     let _ = deep.0.or_else(|| Some(3));
    |                    help: use `or(..)` instead: `or(Some(3))`
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> $DIR/unnecessary_lazy_eval.rs:134:13
+  --> $DIR/unnecessary_lazy_eval.rs:137:13
    |
 LL |     let _ = opt.or_else(|| Some(3));
    |             ^^^^-------------------
@@ -226,7 +242,7 @@ LL |     let _ = opt.or_else(|| Some(3));
    |                 help: use `or(..)` instead: `or(Some(3))`
 
 error: unnecessary closure used to substitute value for `Result::Err`
-  --> $DIR/unnecessary_lazy_eval.rs:140:13
+  --> $DIR/unnecessary_lazy_eval.rs:143:13
    |
 LL |     let _ = res2.unwrap_or_else(|_| 2);
    |             ^^^^^---------------------
@@ -234,7 +250,7 @@ LL |     let _ = res2.unwrap_or_else(|_| 2);
    |                  help: use `unwrap_or(..)` instead: `unwrap_or(2)`
 
 error: unnecessary closure used to substitute value for `Result::Err`
-  --> $DIR/unnecessary_lazy_eval.rs:141:13
+  --> $DIR/unnecessary_lazy_eval.rs:144:13
    |
 LL |     let _ = res2.unwrap_or_else(|_| astronomers_pi);
    |             ^^^^^----------------------------------
@@ -242,7 +258,7 @@ LL |     let _ = res2.unwrap_or_else(|_| astronomers_pi);
    |                  help: use `unwrap_or(..)` instead: `unwrap_or(astronomers_pi)`
 
 error: unnecessary closure used to substitute value for `Result::Err`
-  --> $DIR/unnecessary_lazy_eval.rs:142:13
+  --> $DIR/unnecessary_lazy_eval.rs:145:13
    |
 LL |     let _ = res2.unwrap_or_else(|_| ext_str.some_field);
    |             ^^^^^--------------------------------------
@@ -250,7 +266,7 @@ LL |     let _ = res2.unwrap_or_else(|_| ext_str.some_field);
    |                  help: use `unwrap_or(..)` instead: `unwrap_or(ext_str.some_field)`
 
 error: unnecessary closure used to substitute value for `Result::Err`
-  --> $DIR/unnecessary_lazy_eval.rs:164:35
+  --> $DIR/unnecessary_lazy_eval.rs:167:35
    |
 LL |     let _: Result<usize, usize> = res.and_then(|_| Err(2));
    |                                   ^^^^--------------------
@@ -258,7 +274,7 @@ LL |     let _: Result<usize, usize> = res.and_then(|_| Err(2));
    |                                       help: use `and(..)` instead: `and(Err(2))`
 
 error: unnecessary closure used to substitute value for `Result::Err`
-  --> $DIR/unnecessary_lazy_eval.rs:165:35
+  --> $DIR/unnecessary_lazy_eval.rs:168:35
    |
 LL |     let _: Result<usize, usize> = res.and_then(|_| Err(astronomers_pi));
    |                                   ^^^^---------------------------------
@@ -266,7 +282,7 @@ LL |     let _: Result<usize, usize> = res.and_then(|_| Err(astronomers_pi));
    |                                       help: use `and(..)` instead: `and(Err(astronomers_pi))`
 
 error: unnecessary closure used to substitute value for `Result::Err`
-  --> $DIR/unnecessary_lazy_eval.rs:166:35
+  --> $DIR/unnecessary_lazy_eval.rs:169:35
    |
 LL |     let _: Result<usize, usize> = res.and_then(|_| Err(ext_str.some_field));
    |                                   ^^^^-------------------------------------
@@ -274,7 +290,7 @@ LL |     let _: Result<usize, usize> = res.and_then(|_| Err(ext_str.some_field))
    |                                       help: use `and(..)` instead: `and(Err(ext_str.some_field))`
 
 error: unnecessary closure used to substitute value for `Result::Err`
-  --> $DIR/unnecessary_lazy_eval.rs:168:35
+  --> $DIR/unnecessary_lazy_eval.rs:171:35
    |
 LL |     let _: Result<usize, usize> = res.or_else(|_| Ok(2));
    |                                   ^^^^------------------
@@ -282,7 +298,7 @@ LL |     let _: Result<usize, usize> = res.or_else(|_| Ok(2));
    |                                       help: use `or(..)` instead: `or(Ok(2))`
 
 error: unnecessary closure used to substitute value for `Result::Err`
-  --> $DIR/unnecessary_lazy_eval.rs:169:35
+  --> $DIR/unnecessary_lazy_eval.rs:172:35
    |
 LL |     let _: Result<usize, usize> = res.or_else(|_| Ok(astronomers_pi));
    |                                   ^^^^-------------------------------
@@ -290,7 +306,7 @@ LL |     let _: Result<usize, usize> = res.or_else(|_| Ok(astronomers_pi));
    |                                       help: use `or(..)` instead: `or(Ok(astronomers_pi))`
 
 error: unnecessary closure used to substitute value for `Result::Err`
-  --> $DIR/unnecessary_lazy_eval.rs:170:35
+  --> $DIR/unnecessary_lazy_eval.rs:173:35
    |
 LL |     let _: Result<usize, usize> = res.or_else(|_| Ok(ext_str.some_field));
    |                                   ^^^^-----------------------------------
@@ -298,7 +314,7 @@ LL |     let _: Result<usize, usize> = res.or_else(|_| Ok(ext_str.some_field));
    |                                       help: use `or(..)` instead: `or(Ok(ext_str.some_field))`
 
 error: unnecessary closure used to substitute value for `Result::Err`
-  --> $DIR/unnecessary_lazy_eval.rs:171:35
+  --> $DIR/unnecessary_lazy_eval.rs:174:35
    |
 LL |       let _: Result<usize, usize> = res.
    |  ___________________________________^
@@ -312,5 +328,5 @@ LL | |     or_else(|_| Ok(ext_str.some_field));
    |       |
    |       help: use `or(..)` instead: `or(Ok(ext_str.some_field))`
 
-error: aborting due to 38 previous errors
+error: aborting due to 40 previous errors
 
diff --git a/tests/ui/unnecessary_lazy_eval_unfixable.rs b/tests/ui/unnecessary_lazy_eval_unfixable.rs
index 33685bfb738..412d4aaafb4 100644
--- a/tests/ui/unnecessary_lazy_eval_unfixable.rs
+++ b/tests/ui/unnecessary_lazy_eval_unfixable.rs
@@ -25,3 +25,8 @@ fn main() {
     let arr = [(Some(1),)];
     Some(&0).and_then(|&i| arr[i].0);
 }
+
+fn issue11672() {
+    // Return type annotation helps type inference and removing it can break code
+    let _ = true.then(|| -> &[u8] { &[] });
+}
diff --git a/tests/ui/unnecessary_lazy_eval_unfixable.stderr b/tests/ui/unnecessary_lazy_eval_unfixable.stderr
index 27fa560d4d7..95b02be91ca 100644
--- a/tests/ui/unnecessary_lazy_eval_unfixable.stderr
+++ b/tests/ui/unnecessary_lazy_eval_unfixable.stderr
@@ -25,5 +25,13 @@ LL |     let _ = Ok(1).unwrap_or_else(|SomeStruct { .. }| 2);
    |                   |
    |                   help: use `unwrap_or(..)` instead: `unwrap_or(2)`
 
-error: aborting due to 3 previous errors
+error: unnecessary closure used with `bool::then`
+  --> $DIR/unnecessary_lazy_eval_unfixable.rs:31:13
+   |
+LL |     let _ = true.then(|| -> &[u8] { &[] });
+   |             ^^^^^-------------------------
+   |                  |
+   |                  help: use `then_some(..)` instead: `then_some({ &[] })`
+
+error: aborting due to 4 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 3960bc024c8d329c3c6c3d9986c52ca7510aa1d5 Mon Sep 17 00:00:00 2001
From: Francesco Guardiani <francescoguard@gmail.com>
Date: Mon, 16 Oct 2023 16:56:47 +0200
Subject: Now `declare_interior_mutable_const` and
 `borrow_interior_mutable_const` respect the `ignore-interior-mutability`
 configuration entry

changelog: Now `declare_interior_mutable_const` and `borrow_interior_mutable_const` respect the `ignore-interior-mutability` configuration entry
Signed-off-by: slinkydeveloper <francescoguard@gmail.com>
---
 clippy_lints/src/lib.rs                            |   3 +-
 clippy_lints/src/non_copy_const.rs                 | 315 ++++++++++++---------
 .../borrow_interior_mutable_const/clippy.toml      |   1 +
 .../borrow_interior_mutable_const/ignore.rs        |  37 +++
 .../declare_interior_mutable_const/clippy.toml     |   1 +
 .../declare_interior_mutable_const/ignore.rs       |  46 +++
 6 files changed, 270 insertions(+), 133 deletions(-)
 create mode 100644 tests/ui-toml/borrow_interior_mutable_const/clippy.toml
 create mode 100644 tests/ui-toml/borrow_interior_mutable_const/ignore.rs
 create mode 100644 tests/ui-toml/declare_interior_mutable_const/clippy.toml
 create mode 100644 tests/ui-toml/declare_interior_mutable_const/ignore.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 2d02ce8b4f0..3f04746cbee 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -807,7 +807,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
             suppress_restriction_lint_in_const,
         ))
     });
-    store.register_late_pass(|_| Box::new(non_copy_const::NonCopyConst));
+    let ignore_interior_mutability = conf.ignore_interior_mutability.clone();
+    store.register_late_pass(move |_| Box::new(non_copy_const::NonCopyConst::new(ignore_interior_mutability.clone())));
     store.register_late_pass(|_| Box::new(ptr_offset_with_cast::PtrOffsetWithCast));
     store.register_late_pass(|_| Box::new(redundant_clone::RedundantClone));
     store.register_late_pass(|_| Box::new(slow_vector_initialization::SlowVectorInit));
diff --git a/clippy_lints/src/non_copy_const.rs b/clippy_lints/src/non_copy_const.rs
index 2b4e3260c56..613afa46a91 100644
--- a/clippy_lints/src/non_copy_const.rs
+++ b/clippy_lints/src/non_copy_const.rs
@@ -5,9 +5,10 @@
 use std::ptr;
 
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::in_constant;
 use clippy_utils::macros::macro_backtrace;
+use clippy_utils::{def_path_def_ids, in_constant};
 use if_chain::if_chain;
+use rustc_data_structures::fx::FxHashSet;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::def_id::DefId;
 use rustc_hir::{
@@ -15,9 +16,10 @@ use rustc_hir::{
 };
 use rustc_lint::{LateContext, LateLintPass, Lint};
 use rustc_middle::mir::interpret::{ErrorHandled, EvalToValTreeResult, GlobalId};
+use rustc_middle::query::Key;
 use rustc_middle::ty::adjustment::Adjust;
 use rustc_middle::ty::{self, Ty, TyCtxt};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::{sym, InnerSpan, Span};
 use rustc_target::abi::VariantIdx;
 
@@ -126,128 +128,6 @@ declare_clippy_lint! {
     "referencing `const` with interior mutability"
 }
 
-fn is_unfrozen<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
-    // Ignore types whose layout is unknown since `is_freeze` reports every generic types as `!Freeze`,
-    // making it indistinguishable from `UnsafeCell`. i.e. it isn't a tool to prove a type is
-    // 'unfrozen'. However, this code causes a false negative in which
-    // a type contains a layout-unknown type, but also an unsafe cell like `const CELL: Cell<T>`.
-    // Yet, it's better than `ty.has_type_flags(TypeFlags::HAS_TY_PARAM | TypeFlags::HAS_PROJECTION)`
-    // since it works when a pointer indirection involves (`Cell<*const T>`).
-    // Making up a `ParamEnv` where every generic params and assoc types are `Freeze`is another option;
-    // but I'm not sure whether it's a decent way, if possible.
-    cx.tcx.layout_of(cx.param_env.and(ty)).is_ok() && !ty.is_freeze(cx.tcx, cx.param_env)
-}
-
-fn is_value_unfrozen_raw<'tcx>(
-    cx: &LateContext<'tcx>,
-    result: Result<Option<ty::ValTree<'tcx>>, ErrorHandled>,
-    ty: Ty<'tcx>,
-) -> bool {
-    fn inner<'tcx>(cx: &LateContext<'tcx>, val: ty::ValTree<'tcx>, ty: Ty<'tcx>) -> bool {
-        match *ty.kind() {
-            // the fact that we have to dig into every structs to search enums
-            // leads us to the point checking `UnsafeCell` directly is the only option.
-            ty::Adt(ty_def, ..) if ty_def.is_unsafe_cell() => true,
-            // As of 2022-09-08 miri doesn't track which union field is active so there's no safe way to check the
-            // contained value.
-            ty::Adt(def, ..) if def.is_union() => false,
-            ty::Array(ty, _) => val.unwrap_branch().iter().any(|field| inner(cx, *field, ty)),
-            ty::Adt(def, _) if def.is_union() => false,
-            ty::Adt(def, args) if def.is_enum() => {
-                let (&variant_index, fields) = val.unwrap_branch().split_first().unwrap();
-                let variant_index = VariantIdx::from_u32(variant_index.unwrap_leaf().try_to_u32().ok().unwrap());
-                fields
-                    .iter()
-                    .copied()
-                    .zip(
-                        def.variants()[variant_index]
-                            .fields
-                            .iter()
-                            .map(|field| field.ty(cx.tcx, args)),
-                    )
-                    .any(|(field, ty)| inner(cx, field, ty))
-            },
-            ty::Adt(def, args) => val
-                .unwrap_branch()
-                .iter()
-                .zip(def.non_enum_variant().fields.iter().map(|field| field.ty(cx.tcx, args)))
-                .any(|(field, ty)| inner(cx, *field, ty)),
-            ty::Tuple(tys) => val
-                .unwrap_branch()
-                .iter()
-                .zip(tys)
-                .any(|(field, ty)| inner(cx, *field, ty)),
-            _ => false,
-        }
-    }
-    result.map_or_else(
-        |err| {
-            // Consider `TooGeneric` cases as being unfrozen.
-            // This causes a false positive where an assoc const whose type is unfrozen
-            // have a value that is a frozen variant with a generic param (an example is
-            // `declare_interior_mutable_const::enums::BothOfCellAndGeneric::GENERIC_VARIANT`).
-            // However, it prevents a number of false negatives that is, I think, important:
-            // 1. assoc consts in trait defs referring to consts of themselves (an example is
-            //    `declare_interior_mutable_const::traits::ConcreteTypes::ANOTHER_ATOMIC`).
-            // 2. a path expr referring to assoc consts whose type is doesn't have any frozen variants in trait
-            //    defs (i.e. without substitute for `Self`). (e.g. borrowing
-            //    `borrow_interior_mutable_const::trait::ConcreteTypes::ATOMIC`)
-            // 3. similar to the false positive above; but the value is an unfrozen variant, or the type has no
-            //    enums. (An example is
-            //    `declare_interior_mutable_const::enums::BothOfCellAndGeneric::UNFROZEN_VARIANT` and
-            //    `declare_interior_mutable_const::enums::BothOfCellAndGeneric::NO_ENUM`).
-            // One might be able to prevent these FNs correctly, and replace this with `false`;
-            // e.g. implementing `has_frozen_variant` described above, and not running this function
-            // when the type doesn't have any frozen variants would be the 'correct' way for the 2nd
-            // case (that actually removes another suboptimal behavior (I won't say 'false positive') where,
-            // similar to 2., but with the a frozen variant) (e.g. borrowing
-            // `borrow_interior_mutable_const::enums::AssocConsts::TO_BE_FROZEN_VARIANT`).
-            // I chose this way because unfrozen enums as assoc consts are rare (or, hopefully, none).
-            matches!(err, ErrorHandled::TooGeneric(..))
-        },
-        |val| val.map_or(true, |val| inner(cx, val, ty)),
-    )
-}
-
-fn is_value_unfrozen_poly<'tcx>(cx: &LateContext<'tcx>, body_id: BodyId, ty: Ty<'tcx>) -> bool {
-    let def_id = body_id.hir_id.owner.to_def_id();
-    let args = ty::GenericArgs::identity_for_item(cx.tcx, def_id);
-    let instance = ty::Instance::new(def_id, args);
-    let cid = rustc_middle::mir::interpret::GlobalId {
-        instance,
-        promoted: None,
-    };
-    let param_env = cx.tcx.param_env(def_id).with_reveal_all_normalized(cx.tcx);
-    let result = cx.tcx.const_eval_global_id_for_typeck(param_env, cid, None);
-    is_value_unfrozen_raw(cx, result, ty)
-}
-
-fn is_value_unfrozen_expr<'tcx>(cx: &LateContext<'tcx>, hir_id: HirId, def_id: DefId, ty: Ty<'tcx>) -> bool {
-    let args = cx.typeck_results().node_args(hir_id);
-
-    let result = const_eval_resolve(cx.tcx, cx.param_env, ty::UnevaluatedConst::new(def_id, args), None);
-    is_value_unfrozen_raw(cx, result, ty)
-}
-
-pub fn const_eval_resolve<'tcx>(
-    tcx: TyCtxt<'tcx>,
-    param_env: ty::ParamEnv<'tcx>,
-    ct: ty::UnevaluatedConst<'tcx>,
-    span: Option<Span>,
-) -> EvalToValTreeResult<'tcx> {
-    match ty::Instance::resolve(tcx, param_env, ct.def, ct.args) {
-        Ok(Some(instance)) => {
-            let cid = GlobalId {
-                instance,
-                promoted: None,
-            };
-            tcx.const_eval_global_id_for_typeck(param_env, cid, span)
-        },
-        Ok(None) => Err(ErrorHandled::TooGeneric(span.unwrap_or(rustc_span::DUMMY_SP))),
-        Err(err) => Err(ErrorHandled::Reported(err.into(), span.unwrap_or(rustc_span::DUMMY_SP))),
-    }
-}
-
 #[derive(Copy, Clone)]
 enum Source {
     Item { item: Span },
@@ -292,13 +172,178 @@ fn lint(cx: &LateContext<'_>, source: Source) {
     });
 }
 
-declare_lint_pass!(NonCopyConst => [DECLARE_INTERIOR_MUTABLE_CONST, BORROW_INTERIOR_MUTABLE_CONST]);
+#[derive(Clone)]
+pub struct NonCopyConst {
+    ignore_interior_mutability: Vec<String>,
+    ignore_mut_def_ids: FxHashSet<DefId>,
+}
+
+impl_lint_pass!(NonCopyConst => [DECLARE_INTERIOR_MUTABLE_CONST, BORROW_INTERIOR_MUTABLE_CONST]);
+
+impl NonCopyConst {
+    pub fn new(ignore_interior_mutability: Vec<String>) -> Self {
+        Self {
+            ignore_interior_mutability,
+            ignore_mut_def_ids: FxHashSet::default(),
+        }
+    }
+
+    fn is_ty_ignored(&self, ty: Ty<'_>) -> bool {
+        matches!(ty.ty_adt_id(), Some(adt_id) if self.ignore_mut_def_ids.contains(&adt_id))
+    }
+
+    fn is_unfrozen<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
+        // Ignore types whose layout is unknown since `is_freeze` reports every generic types as `!Freeze`,
+        // making it indistinguishable from `UnsafeCell`. i.e. it isn't a tool to prove a type is
+        // 'unfrozen'. However, this code causes a false negative in which
+        // a type contains a layout-unknown type, but also an unsafe cell like `const CELL: Cell<T>`.
+        // Yet, it's better than `ty.has_type_flags(TypeFlags::HAS_TY_PARAM | TypeFlags::HAS_PROJECTION)`
+        // since it works when a pointer indirection involves (`Cell<*const T>`).
+        // Making up a `ParamEnv` where every generic params and assoc types are `Freeze`is another option;
+        // but I'm not sure whether it's a decent way, if possible.
+        cx.tcx.layout_of(cx.param_env.and(ty)).is_ok() && !ty.is_freeze(cx.tcx, cx.param_env)
+    }
+
+    fn is_value_unfrozen_raw_inner<'tcx>(&self, cx: &LateContext<'tcx>, val: ty::ValTree<'tcx>, ty: Ty<'tcx>) -> bool {
+        if self.is_ty_ignored(ty) {
+            return false;
+        }
+        match *ty.kind() {
+            // the fact that we have to dig into every structs to search enums
+            // leads us to the point checking `UnsafeCell` directly is the only option.
+            ty::Adt(ty_def, ..) if ty_def.is_unsafe_cell() => true,
+            // As of 2022-09-08 miri doesn't track which union field is active so there's no safe way to check the
+            // contained value.
+            ty::Adt(def, ..) if def.is_union() => false,
+            ty::Array(ty, _) => val
+                .unwrap_branch()
+                .iter()
+                .any(|field| self.is_value_unfrozen_raw_inner(cx, *field, ty)),
+            ty::Adt(def, _) if def.is_union() => false,
+            ty::Adt(def, args) if def.is_enum() => {
+                let (&variant_index, fields) = val.unwrap_branch().split_first().unwrap();
+                let variant_index = VariantIdx::from_u32(variant_index.unwrap_leaf().try_to_u32().ok().unwrap());
+                fields
+                    .iter()
+                    .copied()
+                    .zip(
+                        def.variants()[variant_index]
+                            .fields
+                            .iter()
+                            .map(|field| field.ty(cx.tcx, args)),
+                    )
+                    .any(|(field, ty)| self.is_value_unfrozen_raw_inner(cx, field, ty))
+            },
+            ty::Adt(def, args) => val
+                .unwrap_branch()
+                .iter()
+                .zip(def.non_enum_variant().fields.iter().map(|field| field.ty(cx.tcx, args)))
+                .any(|(field, ty)| self.is_value_unfrozen_raw_inner(cx, *field, ty)),
+            ty::Tuple(tys) => val
+                .unwrap_branch()
+                .iter()
+                .zip(tys)
+                .any(|(field, ty)| self.is_value_unfrozen_raw_inner(cx, *field, ty)),
+            _ => false,
+        }
+    }
+
+    fn is_value_unfrozen_raw<'tcx>(
+        &self,
+        cx: &LateContext<'tcx>,
+        result: Result<Option<ty::ValTree<'tcx>>, ErrorHandled>,
+        ty: Ty<'tcx>,
+    ) -> bool {
+        result.map_or_else(
+            |err| {
+                // Consider `TooGeneric` cases as being unfrozen.
+                // This causes a false positive where an assoc const whose type is unfrozen
+                // have a value that is a frozen variant with a generic param (an example is
+                // `declare_interior_mutable_const::enums::BothOfCellAndGeneric::GENERIC_VARIANT`).
+                // However, it prevents a number of false negatives that is, I think, important:
+                // 1. assoc consts in trait defs referring to consts of themselves (an example is
+                //    `declare_interior_mutable_const::traits::ConcreteTypes::ANOTHER_ATOMIC`).
+                // 2. a path expr referring to assoc consts whose type is doesn't have any frozen variants in trait
+                //    defs (i.e. without substitute for `Self`). (e.g. borrowing
+                //    `borrow_interior_mutable_const::trait::ConcreteTypes::ATOMIC`)
+                // 3. similar to the false positive above; but the value is an unfrozen variant, or the type has no
+                //    enums. (An example is
+                //    `declare_interior_mutable_const::enums::BothOfCellAndGeneric::UNFROZEN_VARIANT` and
+                //    `declare_interior_mutable_const::enums::BothOfCellAndGeneric::NO_ENUM`).
+                // One might be able to prevent these FNs correctly, and replace this with `false`;
+                // e.g. implementing `has_frozen_variant` described above, and not running this function
+                // when the type doesn't have any frozen variants would be the 'correct' way for the 2nd
+                // case (that actually removes another suboptimal behavior (I won't say 'false positive') where,
+                // similar to 2., but with the a frozen variant) (e.g. borrowing
+                // `borrow_interior_mutable_const::enums::AssocConsts::TO_BE_FROZEN_VARIANT`).
+                // I chose this way because unfrozen enums as assoc consts are rare (or, hopefully, none).
+                matches!(err, ErrorHandled::TooGeneric(..))
+            },
+            |val| val.map_or(true, |val| self.is_value_unfrozen_raw_inner(cx, val, ty)),
+        )
+    }
+
+    fn is_value_unfrozen_poly<'tcx>(&self, cx: &LateContext<'tcx>, body_id: BodyId, ty: Ty<'tcx>) -> bool {
+        let def_id = body_id.hir_id.owner.to_def_id();
+        let args = ty::GenericArgs::identity_for_item(cx.tcx, def_id);
+        let instance = ty::Instance::new(def_id, args);
+        let cid = rustc_middle::mir::interpret::GlobalId {
+            instance,
+            promoted: None,
+        };
+        let param_env = cx.tcx.param_env(def_id).with_reveal_all_normalized(cx.tcx);
+        let result = cx.tcx.const_eval_global_id_for_typeck(param_env, cid, None);
+        self.is_value_unfrozen_raw(cx, result, ty)
+    }
+
+    fn is_value_unfrozen_expr<'tcx>(&self, cx: &LateContext<'tcx>, hir_id: HirId, def_id: DefId, ty: Ty<'tcx>) -> bool {
+        let args = cx.typeck_results().node_args(hir_id);
+
+        let result = Self::const_eval_resolve(cx.tcx, cx.param_env, ty::UnevaluatedConst::new(def_id, args), None);
+        self.is_value_unfrozen_raw(cx, result, ty)
+    }
+
+    pub fn const_eval_resolve<'tcx>(
+        tcx: TyCtxt<'tcx>,
+        param_env: ty::ParamEnv<'tcx>,
+        ct: ty::UnevaluatedConst<'tcx>,
+        span: Option<Span>,
+    ) -> EvalToValTreeResult<'tcx> {
+        match ty::Instance::resolve(tcx, param_env, ct.def, ct.args) {
+            Ok(Some(instance)) => {
+                let cid = GlobalId {
+                    instance,
+                    promoted: None,
+                };
+                tcx.const_eval_global_id_for_typeck(param_env, cid, span)
+            },
+            Ok(None) => Err(ErrorHandled::TooGeneric(span.unwrap_or(rustc_span::DUMMY_SP))),
+            Err(err) => Err(ErrorHandled::Reported(err.into(), span.unwrap_or(rustc_span::DUMMY_SP))),
+        }
+    }
+}
 
 impl<'tcx> LateLintPass<'tcx> for NonCopyConst {
+    fn check_crate(&mut self, cx: &LateContext<'tcx>) {
+        self.ignore_mut_def_ids.clear();
+        let mut path = Vec::new();
+        for ty in &self.ignore_interior_mutability {
+            path.extend(ty.split("::"));
+            for id in def_path_def_ids(cx, &path[..]) {
+                self.ignore_mut_def_ids.insert(id);
+            }
+            path.clear();
+        }
+    }
+
     fn check_item(&mut self, cx: &LateContext<'tcx>, it: &'tcx Item<'_>) {
         if let ItemKind::Const(.., body_id) = it.kind {
             let ty = cx.tcx.type_of(it.owner_id).instantiate_identity();
-            if !ignored_macro(cx, it) && is_unfrozen(cx, ty) && is_value_unfrozen_poly(cx, body_id, ty) {
+            if !ignored_macro(cx, it)
+                && !self.is_ty_ignored(ty)
+                && Self::is_unfrozen(cx, ty)
+                && self.is_value_unfrozen_poly(cx, body_id, ty)
+            {
                 lint(cx, Source::Item { item: it.span });
             }
         }
@@ -311,7 +356,7 @@ impl<'tcx> LateLintPass<'tcx> for NonCopyConst {
             // Normalize assoc types because ones originated from generic params
             // bounded other traits could have their bound.
             let normalized = cx.tcx.normalize_erasing_regions(cx.param_env, ty);
-            if is_unfrozen(cx, normalized)
+            if !self.is_ty_ignored(ty) && Self::is_unfrozen(cx, normalized)
                 // When there's no default value, lint it only according to its type;
                 // in other words, lint consts whose value *could* be unfrozen, not definitely is.
                 // This feels inconsistent with how the lint treats generic types,
@@ -324,7 +369,7 @@ impl<'tcx> LateLintPass<'tcx> for NonCopyConst {
                 // i.e. having an enum doesn't necessary mean a type has a frozen variant.
                 // And, implementing it isn't a trivial task; it'll probably end up
                 // re-implementing the trait predicate evaluation specific to `Freeze`.
-                && body_id_opt.map_or(true, |body_id| is_value_unfrozen_poly(cx, body_id, normalized))
+                && body_id_opt.map_or(true, |body_id| self.is_value_unfrozen_poly(cx, body_id, normalized))
             {
                 lint(cx, Source::Assoc { item: trait_item.span });
             }
@@ -367,8 +412,8 @@ impl<'tcx> LateLintPass<'tcx> for NonCopyConst {
                             // e.g. `layout_of(...).is_err() || has_frozen_variant(...);`
                         let ty = cx.tcx.type_of(impl_item.owner_id).instantiate_identity();
                         let normalized = cx.tcx.normalize_erasing_regions(cx.param_env, ty);
-                        if is_unfrozen(cx, normalized);
-                        if is_value_unfrozen_poly(cx, *body_id, normalized);
+                        if !self.is_ty_ignored(ty) && Self::is_unfrozen(cx, normalized);
+                        if self.is_value_unfrozen_poly(cx, *body_id, normalized);
                         then {
                             lint(
                                cx,
@@ -384,7 +429,10 @@ impl<'tcx> LateLintPass<'tcx> for NonCopyConst {
                     // Normalize assoc types originated from generic params.
                     let normalized = cx.tcx.normalize_erasing_regions(cx.param_env, ty);
 
-                    if is_unfrozen(cx, ty) && is_value_unfrozen_poly(cx, *body_id, normalized) {
+                    if !self.is_ty_ignored(ty)
+                        && Self::is_unfrozen(cx, ty)
+                        && self.is_value_unfrozen_poly(cx, *body_id, normalized)
+                    {
                         lint(cx, Source::Assoc { item: impl_item.span });
                     }
                 },
@@ -478,7 +526,10 @@ impl<'tcx> LateLintPass<'tcx> for NonCopyConst {
                 cx.typeck_results().expr_ty(dereferenced_expr)
             };
 
-            if is_unfrozen(cx, ty) && is_value_unfrozen_expr(cx, expr.hir_id, item_def_id, ty) {
+            if !self.is_ty_ignored(ty)
+                && Self::is_unfrozen(cx, ty)
+                && self.is_value_unfrozen_expr(cx, expr.hir_id, item_def_id, ty)
+            {
                 lint(cx, Source::Expr { expr: expr.span });
             }
         }
diff --git a/tests/ui-toml/borrow_interior_mutable_const/clippy.toml b/tests/ui-toml/borrow_interior_mutable_const/clippy.toml
new file mode 100644
index 00000000000..34a1036e891
--- /dev/null
+++ b/tests/ui-toml/borrow_interior_mutable_const/clippy.toml
@@ -0,0 +1 @@
+ignore-interior-mutability = ["borrow_interior_mutable_const_ignore::Counted"]
\ No newline at end of file
diff --git a/tests/ui-toml/borrow_interior_mutable_const/ignore.rs b/tests/ui-toml/borrow_interior_mutable_const/ignore.rs
new file mode 100644
index 00000000000..79c7cef6ce1
--- /dev/null
+++ b/tests/ui-toml/borrow_interior_mutable_const/ignore.rs
@@ -0,0 +1,37 @@
+//@compile-flags: --crate-name borrow_interior_mutable_const_ignore
+
+#![warn(clippy::borrow_interior_mutable_const)]
+#![allow(clippy::declare_interior_mutable_const)]
+
+use core::cell::Cell;
+use std::cmp::{Eq, PartialEq};
+use std::collections::{HashMap, HashSet};
+use std::hash::{Hash, Hasher};
+use std::ops::Deref;
+use std::sync::atomic::{AtomicUsize, Ordering};
+
+struct Counted<T> {
+    count: AtomicUsize,
+    val: T,
+}
+
+impl<T> Counted<T> {
+    const fn new(val: T) -> Self {
+        Self {
+            count: AtomicUsize::new(0),
+            val,
+        }
+    }
+}
+
+enum OptionalCell {
+    Unfrozen(Counted<bool>),
+    Frozen,
+}
+
+const UNFROZEN_VARIANT: OptionalCell = OptionalCell::Unfrozen(Counted::new(true));
+const FROZEN_VARIANT: OptionalCell = OptionalCell::Frozen;
+
+fn main() {
+    let _ = &UNFROZEN_VARIANT;
+}
diff --git a/tests/ui-toml/declare_interior_mutable_const/clippy.toml b/tests/ui-toml/declare_interior_mutable_const/clippy.toml
new file mode 100644
index 00000000000..71d13212e2a
--- /dev/null
+++ b/tests/ui-toml/declare_interior_mutable_const/clippy.toml
@@ -0,0 +1 @@
+ignore-interior-mutability = ["declare_interior_mutable_const_ignore::Counted"]
\ No newline at end of file
diff --git a/tests/ui-toml/declare_interior_mutable_const/ignore.rs b/tests/ui-toml/declare_interior_mutable_const/ignore.rs
new file mode 100644
index 00000000000..6385cf4f852
--- /dev/null
+++ b/tests/ui-toml/declare_interior_mutable_const/ignore.rs
@@ -0,0 +1,46 @@
+//@compile-flags: --crate-name declare_interior_mutable_const_ignore
+
+#![warn(clippy::declare_interior_mutable_const)]
+#![allow(clippy::borrow_interior_mutable_const)]
+
+use core::cell::Cell;
+use std::cmp::{Eq, PartialEq};
+use std::collections::{HashMap, HashSet};
+use std::hash::{Hash, Hasher};
+use std::ops::Deref;
+use std::sync::atomic::{AtomicUsize, Ordering};
+
+struct Counted<T> {
+    count: AtomicUsize,
+    val: T,
+}
+
+impl<T> Counted<T> {
+    const fn new(val: T) -> Self {
+        Self {
+            count: AtomicUsize::new(0),
+            val,
+        }
+    }
+}
+
+enum OptionalCell {
+    Unfrozen(Counted<bool>),
+    Frozen,
+}
+
+const UNFROZEN_VARIANT: OptionalCell = OptionalCell::Unfrozen(Counted::new(true));
+const FROZEN_VARIANT: OptionalCell = OptionalCell::Frozen;
+
+const fn unfrozen_variant() -> OptionalCell {
+    OptionalCell::Unfrozen(Counted::new(true))
+}
+
+const fn frozen_variant() -> OptionalCell {
+    OptionalCell::Frozen
+}
+
+const UNFROZEN_VARIANT_FROM_FN: OptionalCell = unfrozen_variant();
+const FROZEN_VARIANT_FROM_FN: OptionalCell = frozen_variant();
+
+fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 536114c8572357db28c349c5ec1e822c7c0e2267 Mon Sep 17 00:00:00 2001
From: lengyijun <sjtu5140809011@gmail.com>
Date: Sun, 15 Oct 2023 08:40:47 +0800
Subject: [`ignored_unit_patterns`]: check &(), &&(), ...

---
 clippy_lints/src/ignored_unit_patterns.rs |  2 +-
 tests/ui/ignored_unit_patterns.fixed      | 16 ++++++++++++++++
 tests/ui/ignored_unit_patterns.rs         | 16 ++++++++++++++++
 tests/ui/ignored_unit_patterns.stderr     | 14 +++++++++++++-
 4 files changed, 46 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/ignored_unit_patterns.rs b/clippy_lints/src/ignored_unit_patterns.rs
index ef2a66d4a20..3e77bededcd 100644
--- a/clippy_lints/src/ignored_unit_patterns.rs
+++ b/clippy_lints/src/ignored_unit_patterns.rs
@@ -52,7 +52,7 @@ impl<'tcx> LateLintPass<'tcx> for IgnoredUnitPatterns {
             },
             _ => {},
         }
-        if matches!(pat.kind, PatKind::Wild) && cx.typeck_results().pat_ty(pat).is_unit() {
+        if matches!(pat.kind, PatKind::Wild) && cx.typeck_results().pat_ty(pat).peel_refs().is_unit() {
             span_lint_and_sugg(
                 cx,
                 IGNORED_UNIT_PATTERNS,
diff --git a/tests/ui/ignored_unit_patterns.fixed b/tests/ui/ignored_unit_patterns.fixed
index 15eaf1f659a..707a0e76e4e 100644
--- a/tests/ui/ignored_unit_patterns.fixed
+++ b/tests/ui/ignored_unit_patterns.fixed
@@ -38,3 +38,19 @@ pub fn moo(_: ()) {
     let _: () = foo().unwrap();
     let _: () = ();
 }
+
+fn test_unit_ref_1() {
+    let x: (usize, &&&&&()) = (1, &&&&&&());
+    match x {
+        (1, ()) => unimplemented!(),
+        //~^ ERROR: matching over `()` is more explicit
+        _ => unimplemented!(),
+    };
+}
+
+fn test_unit_ref_2(v: &[(usize, ())]) {
+    for (x, ()) in v {
+        //~^ ERROR: matching over `()` is more explicit
+        let _ = x;
+    }
+}
diff --git a/tests/ui/ignored_unit_patterns.rs b/tests/ui/ignored_unit_patterns.rs
index 9cac3a440ab..544f2b8f692 100644
--- a/tests/ui/ignored_unit_patterns.rs
+++ b/tests/ui/ignored_unit_patterns.rs
@@ -38,3 +38,19 @@ pub fn moo(_: ()) {
     let _: () = foo().unwrap();
     let _: () = ();
 }
+
+fn test_unit_ref_1() {
+    let x: (usize, &&&&&()) = (1, &&&&&&());
+    match x {
+        (1, _) => unimplemented!(),
+        //~^ ERROR: matching over `()` is more explicit
+        _ => unimplemented!(),
+    };
+}
+
+fn test_unit_ref_2(v: &[(usize, ())]) {
+    for (x, _) in v {
+        //~^ ERROR: matching over `()` is more explicit
+        let _ = x;
+    }
+}
diff --git a/tests/ui/ignored_unit_patterns.stderr b/tests/ui/ignored_unit_patterns.stderr
index cac01a87dba..05c8f281e55 100644
--- a/tests/ui/ignored_unit_patterns.stderr
+++ b/tests/ui/ignored_unit_patterns.stderr
@@ -43,5 +43,17 @@ error: matching over `()` is more explicit
 LL |     let _ = foo().unwrap();
    |         ^ help: use `()` instead of `_`: `()`
 
-error: aborting due to 7 previous errors
+error: matching over `()` is more explicit
+  --> $DIR/ignored_unit_patterns.rs:45:13
+   |
+LL |         (1, _) => unimplemented!(),
+   |             ^ help: use `()` instead of `_`: `()`
+
+error: matching over `()` is more explicit
+  --> $DIR/ignored_unit_patterns.rs:52:13
+   |
+LL |     for (x, _) in v {
+   |             ^ help: use `()` instead of `_`: `()`
+
+error: aborting due to 9 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From bc97f7d0c91649a7cdedbabde0edc9e33854f6a9 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Fri, 6 Oct 2023 12:00:21 +0200
Subject: Don't emit `needless_pass_by_ref_mut` if the variable is used in an
 unsafe block or function

---
 clippy_lints/src/needless_pass_by_ref_mut.rs | 77 +++++++++++++++++++++++++---
 1 file changed, 71 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/needless_pass_by_ref_mut.rs b/clippy_lints/src/needless_pass_by_ref_mut.rs
index 212d6234bdb..e7424ba7c6d 100644
--- a/clippy_lints/src/needless_pass_by_ref_mut.rs
+++ b/clippy_lints/src/needless_pass_by_ref_mut.rs
@@ -7,7 +7,8 @@ use rustc_data_structures::fx::{FxHashSet, FxIndexMap};
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_qpath, FnKind, Visitor};
 use rustc_hir::{
-    Body, Closure, Expr, ExprKind, FnDecl, HirId, HirIdMap, HirIdSet, Impl, ItemKind, Mutability, Node, PatKind, QPath,
+    BlockCheckMode, Body, Closure, Expr, ExprKind, FnDecl, HirId, HirIdMap, HirIdSet, Impl, ItemKind, Mutability, Node,
+    PatKind, QPath,
 };
 use rustc_hir_typeck::expr_use_visitor as euv;
 use rustc_infer::infer::{InferCtxt, TyCtxtInferExt};
@@ -139,13 +140,23 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByRefMut<'tcx> {
         let hir_id = cx.tcx.hir().local_def_id_to_hir_id(fn_def_id);
         let is_async = match kind {
             FnKind::ItemFn(.., header) => {
+                if header.is_unsafe() {
+                    // We don't check unsafe functions.
+                    return;
+                }
                 let attrs = cx.tcx.hir().attrs(hir_id);
                 if header.abi != Abi::Rust || requires_exact_signature(attrs) {
                     return;
                 }
                 header.is_async()
             },
-            FnKind::Method(.., sig) => sig.header.is_async(),
+            FnKind::Method(.., sig) => {
+                if sig.header.is_unsafe() {
+                    // We don't check unsafe functions.
+                    return;
+                }
+                sig.header.is_async()
+            },
             FnKind::Closure => return,
         };
 
@@ -304,10 +315,27 @@ impl<'tcx> MutablyUsedVariablesCtxt<'tcx> {
         }
         self.aliases.insert(alias, target);
     }
+
+    // The goal here is to find if the current scope is unsafe or not. It stops when it finds
+    // a function or an unsafe block.
+    fn is_in_unsafe_block(&self, item: HirId) -> bool {
+        let hir = self.tcx.hir();
+        for (parent, node) in hir.parent_iter(item) {
+            if let Some(fn_sig) = hir.fn_sig_by_hir_id(parent) {
+                return fn_sig.header.is_unsafe();
+            } else if let Node::Block(block) = node {
+                if matches!(block.rules, BlockCheckMode::UnsafeBlock(_)) {
+                    return true;
+                }
+            }
+        }
+        false
+    }
 }
 
 impl<'tcx> euv::Delegate<'tcx> for MutablyUsedVariablesCtxt<'tcx> {
-    fn consume(&mut self, cmt: &euv::PlaceWithHirId<'tcx>, _id: HirId) {
+    #[allow(clippy::if_same_then_else)]
+    fn consume(&mut self, cmt: &euv::PlaceWithHirId<'tcx>, id: HirId) {
         if let euv::Place {
             base:
                 euv::PlaceBase::Local(vid)
@@ -327,13 +355,18 @@ impl<'tcx> euv::Delegate<'tcx> for MutablyUsedVariablesCtxt<'tcx> {
                 && matches!(base_ty.ref_mutability(), Some(Mutability::Mut))
             {
                 self.add_mutably_used_var(*vid);
+            } else if self.is_in_unsafe_block(id) {
+                // If we are in an unsafe block, any operation on this variable must not be warned
+                // upon!
+                self.add_mutably_used_var(*vid);
             }
             self.prev_bind = None;
             self.prev_move_to_closure.remove(vid);
         }
     }
 
-    fn borrow(&mut self, cmt: &euv::PlaceWithHirId<'tcx>, _id: HirId, borrow: ty::BorrowKind) {
+    #[allow(clippy::if_same_then_else)]
+    fn borrow(&mut self, cmt: &euv::PlaceWithHirId<'tcx>, id: HirId, borrow: ty::BorrowKind) {
         self.prev_bind = None;
         if let euv::Place {
             base:
@@ -355,6 +388,10 @@ impl<'tcx> euv::Delegate<'tcx> for MutablyUsedVariablesCtxt<'tcx> {
                 || (borrow == ty::BorrowKind::UniqueImmBorrow && base_ty.ref_mutability() == Some(Mutability::Mut))
             {
                 self.add_mutably_used_var(*vid);
+            } else if self.is_in_unsafe_block(id) {
+                // If we are in an unsafe block, any operation on this variable must not be warned
+                // upon!
+                self.add_mutably_used_var(*vid);
             }
         } else if borrow == ty::ImmBorrow {
             // If there is an `async block`, it'll contain a call to a closure which we need to
@@ -397,7 +434,21 @@ impl<'tcx> euv::Delegate<'tcx> for MutablyUsedVariablesCtxt<'tcx> {
         }
     }
 
-    fn copy(&mut self, _cmt: &euv::PlaceWithHirId<'tcx>, _id: HirId) {
+    fn copy(&mut self, cmt: &euv::PlaceWithHirId<'tcx>, id: HirId) {
+        if let euv::Place {
+            base:
+                euv::PlaceBase::Local(vid)
+                | euv::PlaceBase::Upvar(UpvarId {
+                    var_path: UpvarPath { hir_id: vid },
+                    ..
+                }),
+            ..
+        } = &cmt.place
+        {
+            if self.is_in_unsafe_block(id) {
+                self.add_mutably_used_var(*vid);
+            }
+        }
         self.prev_bind = None;
     }
 
@@ -427,8 +478,22 @@ impl<'tcx> euv::Delegate<'tcx> for MutablyUsedVariablesCtxt<'tcx> {
         }
     }
 
-    fn bind(&mut self, _cmt: &euv::PlaceWithHirId<'tcx>, id: HirId) {
+    fn bind(&mut self, cmt: &euv::PlaceWithHirId<'tcx>, id: HirId) {
         self.prev_bind = Some(id);
+        if let euv::Place {
+            base:
+                euv::PlaceBase::Local(vid)
+                | euv::PlaceBase::Upvar(UpvarId {
+                    var_path: UpvarPath { hir_id: vid },
+                    ..
+                }),
+            ..
+        } = &cmt.place
+        {
+            if self.is_in_unsafe_block(id) {
+                self.add_mutably_used_var(*vid);
+            }
+        }
     }
 }
 
-- 
cgit 1.4.1-3-g733a5


From 8b02dac54244efc2968c164bff129f2a64bb845e Mon Sep 17 00:00:00 2001
From: jonboh <jon.bosque.hernando@gmail.com>
Date: Tue, 17 Oct 2023 18:34:27 +0200
Subject: add lint for struct field names

side effect for `enum_variants`:
use .first() instead of .get(0) in enum_variants lint
move to_camel_case to str_util module
move module, enum and struct name repetitions check to a single file `item_name_repetitions`
rename enum_variants threshold config option
---
 CHANGELOG.md                                       |   2 +
 book/src/lint_configuration.md                     |  10 +
 clippy_lints/src/declared_lints.rs                 |   7 +-
 clippy_lints/src/enum_variants.rs                  | 313 ---------------
 clippy_lints/src/functions/mod.rs                  |   1 +
 clippy_lints/src/item_name_repetitions.rs          | 444 +++++++++++++++++++++
 clippy_lints/src/lib.rs                            |   6 +-
 clippy_lints/src/only_used_in_recursion.rs         |   1 +
 clippy_lints/src/types/mod.rs                      |   2 +-
 clippy_lints/src/utils/conf.rs                     |   4 +
 clippy_utils/src/str_utils.rs                      |  53 +++
 tests/ui-toml/enum_variant_names/clippy.toml       |   1 -
 .../enum_variant_names/enum_variant_names.rs       |  16 -
 .../enum_variant_names/enum_variant_names.stderr   |  18 -
 tests/ui-toml/enum_variants_threshold0/clippy.toml |   1 -
 .../enum_variants_name_threshold.rs                |   3 -
 .../item_name_repetitions/threshold0/clippy.toml   |   2 +
 .../threshold0/item_name_repetitions.rs            |   5 +
 .../item_name_repetitions/threshold5/clippy.toml   |   2 +
 .../threshold5/item_name_repetitions.rs            |  32 ++
 .../threshold5/item_name_repetitions.stderr        |  34 ++
 .../pub_crate_missing_doc.rs                       |   1 +
 .../pub_crate_missing_doc.stderr                   |  14 +-
 .../toml_unknown_key/conf_unknown_key.stderr       |   2 +
 tests/ui/manual_filter_map.fixed                   |   1 +
 tests/ui/manual_filter_map.rs                      |   1 +
 tests/ui/manual_filter_map.stderr                  |  76 ++--
 tests/ui/manual_find_map.fixed                     |   1 +
 tests/ui/manual_find_map.rs                        |   1 +
 tests/ui/manual_find_map.stderr                    |  78 ++--
 tests/ui/min_ident_chars.rs                        |   1 +
 tests/ui/min_ident_chars.stderr                    |  58 +--
 tests/ui/misnamed_getters.fixed                    |   1 +
 tests/ui/misnamed_getters.rs                       |   1 +
 tests/ui/misnamed_getters.stderr                   |  36 +-
 tests/ui/needless_bool/fixable.fixed               |   3 +-
 tests/ui/needless_bool/fixable.rs                  |   3 +-
 tests/ui/needless_bool/fixable.stderr              |  42 +-
 tests/ui/rest_pat_in_fully_bound_structs.rs        |   1 +
 tests/ui/rest_pat_in_fully_bound_structs.stderr    |   6 +-
 tests/ui/struct_fields.rs                          | 331 +++++++++++++++
 tests/ui/struct_fields.stderr                      | 265 ++++++++++++
 42 files changed, 1365 insertions(+), 515 deletions(-)
 delete mode 100644 clippy_lints/src/enum_variants.rs
 create mode 100644 clippy_lints/src/item_name_repetitions.rs
 delete mode 100644 tests/ui-toml/enum_variant_names/clippy.toml
 delete mode 100644 tests/ui-toml/enum_variant_names/enum_variant_names.rs
 delete mode 100644 tests/ui-toml/enum_variant_names/enum_variant_names.stderr
 delete mode 100644 tests/ui-toml/enum_variants_threshold0/clippy.toml
 delete mode 100644 tests/ui-toml/enum_variants_threshold0/enum_variants_name_threshold.rs
 create mode 100644 tests/ui-toml/item_name_repetitions/threshold0/clippy.toml
 create mode 100644 tests/ui-toml/item_name_repetitions/threshold0/item_name_repetitions.rs
 create mode 100644 tests/ui-toml/item_name_repetitions/threshold5/clippy.toml
 create mode 100644 tests/ui-toml/item_name_repetitions/threshold5/item_name_repetitions.rs
 create mode 100644 tests/ui-toml/item_name_repetitions/threshold5/item_name_repetitions.stderr
 create mode 100644 tests/ui/struct_fields.rs
 create mode 100644 tests/ui/struct_fields.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index fef25ad8635..26c9877dbff 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5463,6 +5463,7 @@ Released 2018-09-13
 [`string_to_string`]: https://rust-lang.github.io/rust-clippy/master/index.html#string_to_string
 [`strlen_on_c_strings`]: https://rust-lang.github.io/rust-clippy/master/index.html#strlen_on_c_strings
 [`struct_excessive_bools`]: https://rust-lang.github.io/rust-clippy/master/index.html#struct_excessive_bools
+[`struct_field_names`]: https://rust-lang.github.io/rust-clippy/master/index.html#struct_field_names
 [`stutter`]: https://rust-lang.github.io/rust-clippy/master/index.html#stutter
 [`suboptimal_flops`]: https://rust-lang.github.io/rust-clippy/master/index.html#suboptimal_flops
 [`suspicious_arithmetic_impl`]: https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_arithmetic_impl
@@ -5625,6 +5626,7 @@ Released 2018-09-13
 [`single-char-binding-names-threshold`]: https://doc.rust-lang.org/clippy/lint_configuration.html#single-char-binding-names-threshold
 [`too-large-for-stack`]: https://doc.rust-lang.org/clippy/lint_configuration.html#too-large-for-stack
 [`enum-variant-name-threshold`]: https://doc.rust-lang.org/clippy/lint_configuration.html#enum-variant-name-threshold
+[`struct-field-name-threshold`]: https://doc.rust-lang.org/clippy/lint_configuration.html#struct-field-name-threshold
 [`enum-variant-size-threshold`]: https://doc.rust-lang.org/clippy/lint_configuration.html#enum-variant-size-threshold
 [`verbose-bit-mask-threshold`]: https://doc.rust-lang.org/clippy/lint_configuration.html#verbose-bit-mask-threshold
 [`literal-representation-threshold`]: https://doc.rust-lang.org/clippy/lint_configuration.html#literal-representation-threshold
diff --git a/book/src/lint_configuration.md b/book/src/lint_configuration.md
index 2c958ccbbc2..2c1ec748a4e 100644
--- a/book/src/lint_configuration.md
+++ b/book/src/lint_configuration.md
@@ -273,6 +273,16 @@ The minimum number of enum variants for the lints about variant names to trigger
 * [`enum_variant_names`](https://rust-lang.github.io/rust-clippy/master/index.html#enum_variant_names)
 
 
+## `struct-field-name-threshold`
+The minimum number of struct fields for the lints about field names to trigger
+
+**Default Value:** `3` (`u64`)
+
+---
+**Affected lints:**
+* [`struct_variant_names`](https://rust-lang.github.io/rust-clippy/master/index.html#struct_variant_names)
+
+
 ## `enum-variant-size-threshold`
 The maximum size of an enum's variant to avoid box suggestion
 
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 481c44031cf..77438b27f90 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -154,9 +154,6 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::endian_bytes::LITTLE_ENDIAN_BYTES_INFO,
     crate::entry::MAP_ENTRY_INFO,
     crate::enum_clike::ENUM_CLIKE_UNPORTABLE_VARIANT_INFO,
-    crate::enum_variants::ENUM_VARIANT_NAMES_INFO,
-    crate::enum_variants::MODULE_INCEPTION_INFO,
-    crate::enum_variants::MODULE_NAME_REPETITIONS_INFO,
     crate::equatable_if_let::EQUATABLE_IF_LET_INFO,
     crate::error_impl_error::ERROR_IMPL_ERROR_INFO,
     crate::escape::BOXED_LOCAL_INFO,
@@ -226,6 +223,10 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::instant_subtraction::UNCHECKED_DURATION_SUBTRACTION_INFO,
     crate::int_plus_one::INT_PLUS_ONE_INFO,
     crate::invalid_upcast_comparisons::INVALID_UPCAST_COMPARISONS_INFO,
+    crate::item_name_repetitions::ENUM_VARIANT_NAMES_INFO,
+    crate::item_name_repetitions::MODULE_INCEPTION_INFO,
+    crate::item_name_repetitions::MODULE_NAME_REPETITIONS_INFO,
+    crate::item_name_repetitions::STRUCT_FIELD_NAMES_INFO,
     crate::items_after_statements::ITEMS_AFTER_STATEMENTS_INFO,
     crate::items_after_test_module::ITEMS_AFTER_TEST_MODULE_INFO,
     crate::iter_not_returning_iterator::ITER_NOT_RETURNING_ITERATOR_INFO,
diff --git a/clippy_lints/src/enum_variants.rs b/clippy_lints/src/enum_variants.rs
deleted file mode 100644
index e332f681b6d..00000000000
--- a/clippy_lints/src/enum_variants.rs
+++ /dev/null
@@ -1,313 +0,0 @@
-//! lint on enum variants that are prefixed or suffixed by the same characters
-
-use clippy_utils::diagnostics::{span_lint, span_lint_and_help, span_lint_hir};
-use clippy_utils::source::is_present_in_source;
-use clippy_utils::str_utils::{camel_case_split, count_match_end, count_match_start};
-use rustc_hir::{EnumDef, Item, ItemKind, OwnerId, Variant};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::source_map::Span;
-use rustc_span::symbol::Symbol;
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Detects enumeration variants that are prefixed or suffixed
-    /// by the same characters.
-    ///
-    /// ### Why is this bad?
-    /// Enumeration variant names should specify their variant,
-    /// not repeat the enumeration name.
-    ///
-    /// ### Limitations
-    /// Characters with no casing will be considered when comparing prefixes/suffixes
-    /// This applies to numbers and non-ascii characters without casing
-    /// e.g. `Foo1` and `Foo2` is considered to have different prefixes
-    /// (the prefixes are `Foo1` and `Foo2` respectively), as also `Bar螃`, `Bar蟹`
-    ///
-    /// ### Example
-    /// ```rust
-    /// enum Cake {
-    ///     BlackForestCake,
-    ///     HummingbirdCake,
-    ///     BattenbergCake,
-    /// }
-    /// ```
-    /// Use instead:
-    /// ```rust
-    /// enum Cake {
-    ///     BlackForest,
-    ///     Hummingbird,
-    ///     Battenberg,
-    /// }
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub ENUM_VARIANT_NAMES,
-    style,
-    "enums where all variants share a prefix/postfix"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Detects type names that are prefixed or suffixed by the
-    /// containing module's name.
-    ///
-    /// ### Why is this bad?
-    /// It requires the user to type the module name twice.
-    ///
-    /// ### Example
-    /// ```rust
-    /// mod cake {
-    ///     struct BlackForestCake;
-    /// }
-    /// ```
-    ///
-    /// Use instead:
-    /// ```rust
-    /// mod cake {
-    ///     struct BlackForest;
-    /// }
-    /// ```
-    #[clippy::version = "1.33.0"]
-    pub MODULE_NAME_REPETITIONS,
-    pedantic,
-    "type names prefixed/postfixed with their containing module's name"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for modules that have the same name as their
-    /// parent module
-    ///
-    /// ### Why is this bad?
-    /// A typical beginner mistake is to have `mod foo;` and
-    /// again `mod foo { ..
-    /// }` in `foo.rs`.
-    /// The expectation is that items inside the inner `mod foo { .. }` are then
-    /// available
-    /// through `foo::x`, but they are only available through
-    /// `foo::foo::x`.
-    /// If this is done on purpose, it would be better to choose a more
-    /// representative module name.
-    ///
-    /// ### Example
-    /// ```ignore
-    /// // lib.rs
-    /// mod foo;
-    /// // foo.rs
-    /// mod foo {
-    ///     ...
-    /// }
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub MODULE_INCEPTION,
-    style,
-    "modules that have the same name as their parent module"
-}
-
-pub struct EnumVariantNames {
-    modules: Vec<(Symbol, String, OwnerId)>,
-    threshold: u64,
-    avoid_breaking_exported_api: bool,
-    allow_private_module_inception: bool,
-}
-
-impl EnumVariantNames {
-    #[must_use]
-    pub fn new(threshold: u64, avoid_breaking_exported_api: bool, allow_private_module_inception: bool) -> Self {
-        Self {
-            modules: Vec::new(),
-            threshold,
-            avoid_breaking_exported_api,
-            allow_private_module_inception,
-        }
-    }
-}
-
-impl_lint_pass!(EnumVariantNames => [
-    ENUM_VARIANT_NAMES,
-    MODULE_NAME_REPETITIONS,
-    MODULE_INCEPTION
-]);
-
-fn check_enum_start(cx: &LateContext<'_>, item_name: &str, variant: &Variant<'_>) {
-    let name = variant.ident.name.as_str();
-    let item_name_chars = item_name.chars().count();
-
-    if count_match_start(item_name, name).char_count == item_name_chars
-        && name.chars().nth(item_name_chars).map_or(false, |c| !c.is_lowercase())
-        && name.chars().nth(item_name_chars + 1).map_or(false, |c| !c.is_numeric())
-    {
-        span_lint_hir(
-            cx,
-            ENUM_VARIANT_NAMES,
-            variant.hir_id,
-            variant.span,
-            "variant name starts with the enum's name",
-        );
-    }
-}
-
-fn check_enum_end(cx: &LateContext<'_>, item_name: &str, variant: &Variant<'_>) {
-    let name = variant.ident.name.as_str();
-    let item_name_chars = item_name.chars().count();
-
-    if count_match_end(item_name, name).char_count == item_name_chars {
-        span_lint_hir(
-            cx,
-            ENUM_VARIANT_NAMES,
-            variant.hir_id,
-            variant.span,
-            "variant name ends with the enum's name",
-        );
-    }
-}
-
-fn check_variant(cx: &LateContext<'_>, threshold: u64, def: &EnumDef<'_>, item_name: &str, span: Span) {
-    if (def.variants.len() as u64) < threshold {
-        return;
-    }
-
-    let first = match def.variants.first() {
-        Some(variant) => variant.ident.name.as_str(),
-        None => return,
-    };
-    let mut pre = camel_case_split(first);
-    let mut post = pre.clone();
-    post.reverse();
-    for var in def.variants {
-        check_enum_start(cx, item_name, var);
-        check_enum_end(cx, item_name, var);
-        let name = var.ident.name.as_str();
-
-        let variant_split = camel_case_split(name);
-        if variant_split.len() == 1 {
-            return;
-        }
-
-        pre = pre
-            .iter()
-            .zip(variant_split.iter())
-            .take_while(|(a, b)| a == b)
-            .map(|e| *e.0)
-            .collect();
-        post = post
-            .iter()
-            .zip(variant_split.iter().rev())
-            .take_while(|(a, b)| a == b)
-            .map(|e| *e.0)
-            .collect();
-    }
-    let (what, value) = match (have_no_extra_prefix(&pre), post.is_empty()) {
-        (true, true) => return,
-        (false, _) => ("pre", pre.join("")),
-        (true, false) => {
-            post.reverse();
-            ("post", post.join(""))
-        },
-    };
-    span_lint_and_help(
-        cx,
-        ENUM_VARIANT_NAMES,
-        span,
-        &format!("all variants have the same {what}fix: `{value}`"),
-        None,
-        &format!(
-            "remove the {what}fixes and use full paths to \
-             the variants instead of glob imports"
-        ),
-    );
-}
-
-#[must_use]
-fn have_no_extra_prefix(prefixes: &[&str]) -> bool {
-    prefixes.iter().all(|p| p == &"" || p == &"_")
-}
-
-#[must_use]
-fn to_camel_case(item_name: &str) -> String {
-    let mut s = String::new();
-    let mut up = true;
-    for c in item_name.chars() {
-        if c.is_uppercase() {
-            // we only turn snake case text into CamelCase
-            return item_name.to_string();
-        }
-        if c == '_' {
-            up = true;
-            continue;
-        }
-        if up {
-            up = false;
-            s.extend(c.to_uppercase());
-        } else {
-            s.push(c);
-        }
-    }
-    s
-}
-
-impl LateLintPass<'_> for EnumVariantNames {
-    fn check_item_post(&mut self, _cx: &LateContext<'_>, _item: &Item<'_>) {
-        let last = self.modules.pop();
-        assert!(last.is_some());
-    }
-
-    #[expect(clippy::similar_names)]
-    fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
-        let item_name = item.ident.name.as_str();
-        let item_camel = to_camel_case(item_name);
-        if !item.span.from_expansion() && is_present_in_source(cx, item.span) {
-            if let [.., (mod_name, mod_camel, owner_id)] = &*self.modules {
-                // constants don't have surrounding modules
-                if !mod_camel.is_empty() {
-                    if mod_name == &item.ident.name
-                        && let ItemKind::Mod(..) = item.kind
-                        && (!self.allow_private_module_inception || cx.tcx.visibility(owner_id.def_id).is_public())
-                    {
-                        span_lint(
-                            cx,
-                            MODULE_INCEPTION,
-                            item.span,
-                            "module has the same name as its containing module",
-                        );
-                    }
-                    // The `module_name_repetitions` lint should only trigger if the item has the module in its
-                    // name. Having the same name is accepted.
-                    if cx.tcx.visibility(item.owner_id).is_public() && item_camel.len() > mod_camel.len() {
-                        let matching = count_match_start(mod_camel, &item_camel);
-                        let rmatching = count_match_end(mod_camel, &item_camel);
-                        let nchars = mod_camel.chars().count();
-
-                        let is_word_beginning = |c: char| c == '_' || c.is_uppercase() || c.is_numeric();
-
-                        if matching.char_count == nchars {
-                            match item_camel.chars().nth(nchars) {
-                                Some(c) if is_word_beginning(c) => span_lint(
-                                    cx,
-                                    MODULE_NAME_REPETITIONS,
-                                    item.ident.span,
-                                    "item name starts with its containing module's name",
-                                ),
-                                _ => (),
-                            }
-                        }
-                        if rmatching.char_count == nchars {
-                            span_lint(
-                                cx,
-                                MODULE_NAME_REPETITIONS,
-                                item.ident.span,
-                                "item name ends with its containing module's name",
-                            );
-                        }
-                    }
-                }
-            }
-        }
-        if let ItemKind::Enum(ref def, _) = item.kind {
-            if !(self.avoid_breaking_exported_api && cx.effective_visibilities.is_exported(item.owner_id.def_id)) {
-                check_variant(cx, self.threshold, def, item_name, item.span);
-            }
-        }
-        self.modules.push((item.ident.name, item_camel, item.owner_id));
-    }
-}
diff --git a/clippy_lints/src/functions/mod.rs b/clippy_lints/src/functions/mod.rs
index 55ebd44a60c..716908483e9 100644
--- a/clippy_lints/src/functions/mod.rs
+++ b/clippy_lints/src/functions/mod.rs
@@ -360,6 +360,7 @@ declare_clippy_lint! {
 }
 
 #[derive(Copy, Clone)]
+#[allow(clippy::struct_field_names)]
 pub struct Functions {
     too_many_arguments_threshold: u64,
     too_many_lines_threshold: u64,
diff --git a/clippy_lints/src/item_name_repetitions.rs b/clippy_lints/src/item_name_repetitions.rs
new file mode 100644
index 00000000000..8b4984da3dd
--- /dev/null
+++ b/clippy_lints/src/item_name_repetitions.rs
@@ -0,0 +1,444 @@
+//! lint on enum variants that are prefixed or suffixed by the same characters
+
+use clippy_utils::diagnostics::{span_lint, span_lint_and_help, span_lint_hir};
+use clippy_utils::macros::span_is_local;
+use clippy_utils::source::is_present_in_source;
+use clippy_utils::str_utils::{camel_case_split, count_match_end, count_match_start, to_camel_case, to_snake_case};
+use rustc_hir::{EnumDef, FieldDef, Item, ItemKind, OwnerId, Variant, VariantData};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::source_map::Span;
+use rustc_span::symbol::Symbol;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Detects enumeration variants that are prefixed or suffixed
+    /// by the same characters.
+    ///
+    /// ### Why is this bad?
+    /// Enumeration variant names should specify their variant,
+    /// not repeat the enumeration name.
+    ///
+    /// ### Limitations
+    /// Characters with no casing will be considered when comparing prefixes/suffixes
+    /// This applies to numbers and non-ascii characters without casing
+    /// e.g. `Foo1` and `Foo2` is considered to have different prefixes
+    /// (the prefixes are `Foo1` and `Foo2` respectively), as also `Bar螃`, `Bar蟹`
+    ///
+    /// ### Example
+    /// ```rust
+    /// enum Cake {
+    ///     BlackForestCake,
+    ///     HummingbirdCake,
+    ///     BattenbergCake,
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// enum Cake {
+    ///     BlackForest,
+    ///     Hummingbird,
+    ///     Battenberg,
+    /// }
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub ENUM_VARIANT_NAMES,
+    style,
+    "enums where all variants share a prefix/postfix"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Detects type names that are prefixed or suffixed by the
+    /// containing module's name.
+    ///
+    /// ### Why is this bad?
+    /// It requires the user to type the module name twice.
+    ///
+    /// ### Example
+    /// ```rust
+    /// mod cake {
+    ///     struct BlackForestCake;
+    /// }
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust
+    /// mod cake {
+    ///     struct BlackForest;
+    /// }
+    /// ```
+    #[clippy::version = "1.33.0"]
+    pub MODULE_NAME_REPETITIONS,
+    pedantic,
+    "type names prefixed/postfixed with their containing module's name"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for modules that have the same name as their
+    /// parent module
+    ///
+    /// ### Why is this bad?
+    /// A typical beginner mistake is to have `mod foo;` and
+    /// again `mod foo { ..
+    /// }` in `foo.rs`.
+    /// The expectation is that items inside the inner `mod foo { .. }` are then
+    /// available
+    /// through `foo::x`, but they are only available through
+    /// `foo::foo::x`.
+    /// If this is done on purpose, it would be better to choose a more
+    /// representative module name.
+    ///
+    /// ### Example
+    /// ```ignore
+    /// // lib.rs
+    /// mod foo;
+    /// // foo.rs
+    /// mod foo {
+    ///     ...
+    /// }
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub MODULE_INCEPTION,
+    style,
+    "modules that have the same name as their parent module"
+}
+declare_clippy_lint! {
+    /// ### What it does
+    /// Detects struct fields that are prefixed or suffixed
+    /// by the same characters or the name of the struct itself.
+    ///
+    /// ### Why is this bad?
+    /// Information common to all struct fields is better represented in the struct name.
+    ///
+    /// ### Limitations
+    /// Characters with no casing will be considered when comparing prefixes/suffixes
+    /// This applies to numbers and non-ascii characters without casing
+    /// e.g. `foo1` and `foo2` is considered to have different prefixes
+    /// (the prefixes are `foo1` and `foo2` respectively), as also `bar螃`, `bar蟹`
+    ///
+    /// ### Example
+    /// ```rust
+    /// struct Cake {
+    ///     cake_sugar: u8,
+    ///     cake_flour: u8,
+    ///     cake_eggs: u8
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// struct Cake {
+    ///     sugar: u8,
+    ///     flour: u8,
+    ///     eggs: u8
+    /// }
+    /// ```
+    #[clippy::version = "1.75.0"]
+    pub STRUCT_FIELD_NAMES,
+    pedantic,
+    "structs where all fields share a prefix/postfix or contain the name of the struct"
+}
+
+pub struct ItemNameRepetitions {
+    modules: Vec<(Symbol, String, OwnerId)>,
+    enum_threshold: u64,
+    struct_threshold: u64,
+    avoid_breaking_exported_api: bool,
+    allow_private_module_inception: bool,
+}
+
+impl ItemNameRepetitions {
+    #[must_use]
+    pub fn new(
+        enum_threshold: u64,
+        struct_threshold: u64,
+        avoid_breaking_exported_api: bool,
+        allow_private_module_inception: bool,
+    ) -> Self {
+        Self {
+            modules: Vec::new(),
+            enum_threshold,
+            struct_threshold,
+            avoid_breaking_exported_api,
+            allow_private_module_inception,
+        }
+    }
+}
+
+impl_lint_pass!(ItemNameRepetitions => [
+    ENUM_VARIANT_NAMES,
+    STRUCT_FIELD_NAMES,
+    MODULE_NAME_REPETITIONS,
+    MODULE_INCEPTION
+]);
+
+#[must_use]
+fn have_no_extra_prefix(prefixes: &[&str]) -> bool {
+    prefixes.iter().all(|p| p == &"" || p == &"_")
+}
+
+fn check_fields(cx: &LateContext<'_>, threshold: u64, item: &Item<'_>, fields: &[FieldDef<'_>]) {
+    if (fields.len() as u64) < threshold {
+        return;
+    }
+
+    check_struct_name_repetition(cx, item, fields);
+
+    // if the SyntaxContext of the identifiers of the fields and struct differ dont lint them.
+    // this prevents linting in macros in which the location of the field identifier names differ
+    if !fields.iter().all(|field| item.ident.span.eq_ctxt(field.ident.span)) {
+        return;
+    }
+
+    let mut pre: Vec<&str> = match fields.first() {
+        Some(first_field) => first_field.ident.name.as_str().split('_').collect(),
+        None => return,
+    };
+    let mut post = pre.clone();
+    post.reverse();
+    for field in fields {
+        let field_split: Vec<&str> = field.ident.name.as_str().split('_').collect();
+        if field_split.len() == 1 {
+            return;
+        }
+
+        pre = pre
+            .into_iter()
+            .zip(field_split.iter())
+            .take_while(|(a, b)| &a == b)
+            .map(|e| e.0)
+            .collect();
+        post = post
+            .into_iter()
+            .zip(field_split.iter().rev())
+            .take_while(|(a, b)| &a == b)
+            .map(|e| e.0)
+            .collect();
+    }
+    let prefix = pre.join("_");
+    post.reverse();
+    let postfix = match post.last() {
+        Some(&"") => post.join("_") + "_",
+        Some(_) | None => post.join("_"),
+    };
+    if fields.len() > 1 {
+        let (what, value) = match (
+            prefix.is_empty() || prefix.chars().all(|c| c == '_'),
+            postfix.is_empty(),
+        ) {
+            (true, true) => return,
+            (false, _) => ("pre", prefix),
+            (true, false) => ("post", postfix),
+        };
+        span_lint_and_help(
+            cx,
+            STRUCT_FIELD_NAMES,
+            item.span,
+            &format!("all fields have the same {what}fix: `{value}`"),
+            None,
+            &format!("remove the {what}fixes"),
+        );
+    }
+}
+
+fn check_struct_name_repetition(cx: &LateContext<'_>, item: &Item<'_>, fields: &[FieldDef<'_>]) {
+    let snake_name = to_snake_case(item.ident.name.as_str());
+    let item_name_words: Vec<&str> = snake_name.split('_').collect();
+    for field in fields {
+        if field.ident.span.eq_ctxt(item.ident.span) {
+            //consider linting only if the field identifier has the same SyntaxContext as the item(struct)
+            let field_words: Vec<&str> = field.ident.name.as_str().split('_').collect();
+            if field_words.len() >= item_name_words.len() {
+                // if the field name is shorter than the struct name it cannot contain it
+                if field_words.iter().zip(item_name_words.iter()).all(|(a, b)| a == b) {
+                    span_lint_hir(
+                        cx,
+                        STRUCT_FIELD_NAMES,
+                        field.hir_id,
+                        field.span,
+                        "field name starts with the struct's name",
+                    );
+                }
+                if field_words.len() > item_name_words.len() {
+                    // lint only if the end is not covered by the start
+                    if field_words
+                        .iter()
+                        .rev()
+                        .zip(item_name_words.iter().rev())
+                        .all(|(a, b)| a == b)
+                    {
+                        span_lint_hir(
+                            cx,
+                            STRUCT_FIELD_NAMES,
+                            field.hir_id,
+                            field.span,
+                            "field name ends with the struct's name",
+                        );
+                    }
+                }
+            }
+        }
+    }
+}
+
+fn check_enum_start(cx: &LateContext<'_>, item_name: &str, variant: &Variant<'_>) {
+    let name = variant.ident.name.as_str();
+    let item_name_chars = item_name.chars().count();
+
+    if count_match_start(item_name, name).char_count == item_name_chars
+        && name.chars().nth(item_name_chars).map_or(false, |c| !c.is_lowercase())
+        && name.chars().nth(item_name_chars + 1).map_or(false, |c| !c.is_numeric())
+    {
+        span_lint_hir(
+            cx,
+            ENUM_VARIANT_NAMES,
+            variant.hir_id,
+            variant.span,
+            "variant name starts with the enum's name",
+        );
+    }
+}
+
+fn check_enum_end(cx: &LateContext<'_>, item_name: &str, variant: &Variant<'_>) {
+    let name = variant.ident.name.as_str();
+    let item_name_chars = item_name.chars().count();
+
+    if count_match_end(item_name, name).char_count == item_name_chars {
+        span_lint_hir(
+            cx,
+            ENUM_VARIANT_NAMES,
+            variant.hir_id,
+            variant.span,
+            "variant name ends with the enum's name",
+        );
+    }
+}
+
+fn check_variant(cx: &LateContext<'_>, threshold: u64, def: &EnumDef<'_>, item_name: &str, span: Span) {
+    if (def.variants.len() as u64) < threshold {
+        return;
+    }
+
+    let first = match def.variants.first() {
+        Some(variant) => variant.ident.name.as_str(),
+        None => return,
+    };
+    let mut pre = camel_case_split(first);
+    let mut post = pre.clone();
+    post.reverse();
+    for var in def.variants {
+        check_enum_start(cx, item_name, var);
+        check_enum_end(cx, item_name, var);
+        let name = var.ident.name.as_str();
+
+        let variant_split = camel_case_split(name);
+        if variant_split.len() == 1 {
+            return;
+        }
+
+        pre = pre
+            .iter()
+            .zip(variant_split.iter())
+            .take_while(|(a, b)| a == b)
+            .map(|e| *e.0)
+            .collect();
+        post = post
+            .iter()
+            .zip(variant_split.iter().rev())
+            .take_while(|(a, b)| a == b)
+            .map(|e| *e.0)
+            .collect();
+    }
+    let (what, value) = match (have_no_extra_prefix(&pre), post.is_empty()) {
+        (true, true) => return,
+        (false, _) => ("pre", pre.join("")),
+        (true, false) => {
+            post.reverse();
+            ("post", post.join(""))
+        },
+    };
+    span_lint_and_help(
+        cx,
+        ENUM_VARIANT_NAMES,
+        span,
+        &format!("all variants have the same {what}fix: `{value}`"),
+        None,
+        &format!(
+            "remove the {what}fixes and use full paths to \
+             the variants instead of glob imports"
+        ),
+    );
+}
+
+impl LateLintPass<'_> for ItemNameRepetitions {
+    fn check_item_post(&mut self, _cx: &LateContext<'_>, _item: &Item<'_>) {
+        let last = self.modules.pop();
+        assert!(last.is_some());
+    }
+
+    #[expect(clippy::similar_names)]
+    fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
+        let item_name = item.ident.name.as_str();
+        let item_camel = to_camel_case(item_name);
+        if !item.span.from_expansion() && is_present_in_source(cx, item.span) {
+            if let [.., (mod_name, mod_camel, owner_id)] = &*self.modules {
+                // constants don't have surrounding modules
+                if !mod_camel.is_empty() {
+                    if mod_name == &item.ident.name
+                        && let ItemKind::Mod(..) = item.kind
+                        && (!self.allow_private_module_inception || cx.tcx.visibility(owner_id.def_id).is_public())
+                    {
+                        span_lint(
+                            cx,
+                            MODULE_INCEPTION,
+                            item.span,
+                            "module has the same name as its containing module",
+                        );
+                    }
+                    // The `module_name_repetitions` lint should only trigger if the item has the module in its
+                    // name. Having the same name is accepted.
+                    if cx.tcx.visibility(item.owner_id).is_public() && item_camel.len() > mod_camel.len() {
+                        let matching = count_match_start(mod_camel, &item_camel);
+                        let rmatching = count_match_end(mod_camel, &item_camel);
+                        let nchars = mod_camel.chars().count();
+
+                        let is_word_beginning = |c: char| c == '_' || c.is_uppercase() || c.is_numeric();
+
+                        if matching.char_count == nchars {
+                            match item_camel.chars().nth(nchars) {
+                                Some(c) if is_word_beginning(c) => span_lint(
+                                    cx,
+                                    MODULE_NAME_REPETITIONS,
+                                    item.ident.span,
+                                    "item name starts with its containing module's name",
+                                ),
+                                _ => (),
+                            }
+                        }
+                        if rmatching.char_count == nchars {
+                            span_lint(
+                                cx,
+                                MODULE_NAME_REPETITIONS,
+                                item.ident.span,
+                                "item name ends with its containing module's name",
+                            );
+                        }
+                    }
+                }
+            }
+        }
+        if !(self.avoid_breaking_exported_api && cx.effective_visibilities.is_exported(item.owner_id.def_id))
+            && span_is_local(item.span)
+        {
+            match item.kind {
+                ItemKind::Enum(def, _) => check_variant(cx, self.enum_threshold, &def, item_name, item.span),
+                ItemKind::Struct(VariantData::Struct(fields, _), _) => {
+                    check_fields(cx, self.struct_threshold, item, fields);
+                },
+                _ => (),
+            }
+        }
+        self.modules.push((item.ident.name, item_camel, item.owner_id));
+    }
+}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 2d02ce8b4f0..7b97adcf226 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -121,7 +121,6 @@ mod empty_structs_with_brackets;
 mod endian_bytes;
 mod entry;
 mod enum_clike;
-mod enum_variants;
 mod equatable_if_let;
 mod error_impl_error;
 mod escape;
@@ -166,6 +165,7 @@ mod inline_fn_without_body;
 mod instant_subtraction;
 mod int_plus_one;
 mod invalid_upcast_comparisons;
+mod item_name_repetitions;
 mod items_after_statements;
 mod items_after_test_module;
 mod iter_not_returning_iterator;
@@ -852,10 +852,12 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         ))
     });
     let enum_variant_name_threshold = conf.enum_variant_name_threshold;
+    let struct_field_name_threshold = conf.struct_field_name_threshold;
     let allow_private_module_inception = conf.allow_private_module_inception;
     store.register_late_pass(move |_| {
-        Box::new(enum_variants::EnumVariantNames::new(
+        Box::new(item_name_repetitions::ItemNameRepetitions::new(
             enum_variant_name_threshold,
+            struct_field_name_threshold,
             avoid_breaking_exported_api,
             allow_private_module_inception,
         ))
diff --git a/clippy_lints/src/only_used_in_recursion.rs b/clippy_lints/src/only_used_in_recursion.rs
index 3dc652f9dc0..f0f8d510c7e 100644
--- a/clippy_lints/src/only_used_in_recursion.rs
+++ b/clippy_lints/src/only_used_in_recursion.rs
@@ -134,6 +134,7 @@ impl Usage {
 /// The parameters being checked by the lint, indexed by both the parameter's `HirId` and the
 /// `DefId` of the function paired with the parameter's index.
 #[derive(Default)]
+#[allow(clippy::struct_field_names)]
 struct Params {
     params: Vec<Param>,
     by_id: HirIdMap<usize>,
diff --git a/clippy_lints/src/types/mod.rs b/clippy_lints/src/types/mod.rs
index 71a4b3fba1b..788678a63b7 100644
--- a/clippy_lints/src/types/mod.rs
+++ b/clippy_lints/src/types/mod.rs
@@ -578,7 +578,7 @@ impl Types {
     }
 }
 
-#[allow(clippy::struct_excessive_bools)]
+#[allow(clippy::struct_excessive_bools, clippy::struct_field_names)]
 #[derive(Clone, Copy, Default)]
 struct CheckTyContext {
     is_in_trait_impl: bool,
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 23da1de7730..519e27b0367 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -360,6 +360,10 @@ define_Conf! {
     ///
     /// The minimum number of enum variants for the lints about variant names to trigger
     (enum_variant_name_threshold: u64 = 3),
+    /// Lint: STRUCT_VARIANT_NAMES.
+    ///
+    /// The minimum number of struct fields for the lints about field names to trigger
+    (struct_field_name_threshold: u64 = 3),
     /// Lint: LARGE_ENUM_VARIANT.
     ///
     /// The maximum size of an enum's variant to avoid box suggestion
diff --git a/clippy_utils/src/str_utils.rs b/clippy_utils/src/str_utils.rs
index 03a9d3c25fd..69c25b427e1 100644
--- a/clippy_utils/src/str_utils.rs
+++ b/clippy_utils/src/str_utils.rs
@@ -236,6 +236,59 @@ pub fn count_match_end(str1: &str, str2: &str) -> StrCount {
         })
 }
 
+/// Returns a `snake_case` version of the input
+/// ```
+/// use clippy_utils::str_utils::to_snake_case;
+/// assert_eq!(to_snake_case("AbcDef"), "abc_def");
+/// assert_eq!(to_snake_case("ABCD"), "a_b_c_d");
+/// assert_eq!(to_snake_case("AbcDD"), "abc_d_d");
+/// assert_eq!(to_snake_case("Abc1DD"), "abc1_d_d");
+/// ```
+pub fn to_snake_case(name: &str) -> String {
+    let mut s = String::new();
+    for (i, c) in name.chars().enumerate() {
+        if c.is_uppercase() {
+            // characters without capitalization are considered lowercase
+            if i != 0 {
+                s.push('_');
+            }
+            s.extend(c.to_lowercase());
+        } else {
+            s.push(c);
+        }
+    }
+    s
+}
+/// Returns a `CamelCase` version of the input
+/// ```
+/// use clippy_utils::str_utils::to_camel_case;
+/// assert_eq!(to_camel_case("abc_def"), "AbcDef");
+/// assert_eq!(to_camel_case("a_b_c_d"), "ABCD");
+/// assert_eq!(to_camel_case("abc_d_d"), "AbcDD");
+/// assert_eq!(to_camel_case("abc1_d_d"), "Abc1DD");
+/// ```
+pub fn to_camel_case(item_name: &str) -> String {
+    let mut s = String::new();
+    let mut up = true;
+    for c in item_name.chars() {
+        if c.is_uppercase() {
+            // we only turn snake case text into CamelCase
+            return item_name.to_string();
+        }
+        if c == '_' {
+            up = true;
+            continue;
+        }
+        if up {
+            up = false;
+            s.extend(c.to_uppercase());
+        } else {
+            s.push(c);
+        }
+    }
+    s
+}
+
 #[cfg(test)]
 mod test {
     use super::*;
diff --git a/tests/ui-toml/enum_variant_names/clippy.toml b/tests/ui-toml/enum_variant_names/clippy.toml
deleted file mode 100644
index 0ad7a979948..00000000000
--- a/tests/ui-toml/enum_variant_names/clippy.toml
+++ /dev/null
@@ -1 +0,0 @@
-enum-variant-name-threshold = 5
diff --git a/tests/ui-toml/enum_variant_names/enum_variant_names.rs b/tests/ui-toml/enum_variant_names/enum_variant_names.rs
deleted file mode 100644
index 8f4e178ccfe..00000000000
--- a/tests/ui-toml/enum_variant_names/enum_variant_names.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-enum Foo {
-    AFoo,
-    BFoo,
-    CFoo,
-    DFoo,
-}
-enum Foo2 {
-    //~^ ERROR: all variants have the same postfix
-    AFoo,
-    BFoo,
-    CFoo,
-    DFoo,
-    EFoo,
-}
-
-fn main() {}
diff --git a/tests/ui-toml/enum_variant_names/enum_variant_names.stderr b/tests/ui-toml/enum_variant_names/enum_variant_names.stderr
deleted file mode 100644
index 11039b1db48..00000000000
--- a/tests/ui-toml/enum_variant_names/enum_variant_names.stderr
+++ /dev/null
@@ -1,18 +0,0 @@
-error: all variants have the same postfix: `Foo`
-  --> $DIR/enum_variant_names.rs:7:1
-   |
-LL | / enum Foo2 {
-LL | |
-LL | |     AFoo,
-LL | |     BFoo,
-...  |
-LL | |     EFoo,
-LL | | }
-   | |_^
-   |
-   = help: remove the postfixes and use full paths to the variants instead of glob imports
-   = note: `-D clippy::enum-variant-names` implied by `-D warnings`
-   = help: to override `-D warnings` add `#[allow(clippy::enum_variant_names)]`
-
-error: aborting due to previous error
-
diff --git a/tests/ui-toml/enum_variants_threshold0/clippy.toml b/tests/ui-toml/enum_variants_threshold0/clippy.toml
deleted file mode 100644
index f85aade6ae8..00000000000
--- a/tests/ui-toml/enum_variants_threshold0/clippy.toml
+++ /dev/null
@@ -1 +0,0 @@
-enum-variant-name-threshold = 0
diff --git a/tests/ui-toml/enum_variants_threshold0/enum_variants_name_threshold.rs b/tests/ui-toml/enum_variants_threshold0/enum_variants_name_threshold.rs
deleted file mode 100644
index 6918d7528c1..00000000000
--- a/tests/ui-toml/enum_variants_threshold0/enum_variants_name_threshold.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-enum Actions {}
-
-fn main() {}
diff --git a/tests/ui-toml/item_name_repetitions/threshold0/clippy.toml b/tests/ui-toml/item_name_repetitions/threshold0/clippy.toml
new file mode 100644
index 00000000000..d41edbaf7fa
--- /dev/null
+++ b/tests/ui-toml/item_name_repetitions/threshold0/clippy.toml
@@ -0,0 +1,2 @@
+struct-field-name-threshold = 0
+enum-variant-name-threshold = 0
diff --git a/tests/ui-toml/item_name_repetitions/threshold0/item_name_repetitions.rs b/tests/ui-toml/item_name_repetitions/threshold0/item_name_repetitions.rs
new file mode 100644
index 00000000000..b633dcbd19e
--- /dev/null
+++ b/tests/ui-toml/item_name_repetitions/threshold0/item_name_repetitions.rs
@@ -0,0 +1,5 @@
+struct Data {}
+
+enum Actions {}
+
+fn main() {}
diff --git a/tests/ui-toml/item_name_repetitions/threshold5/clippy.toml b/tests/ui-toml/item_name_repetitions/threshold5/clippy.toml
new file mode 100644
index 00000000000..028a6279079
--- /dev/null
+++ b/tests/ui-toml/item_name_repetitions/threshold5/clippy.toml
@@ -0,0 +1,2 @@
+enum-variant-name-threshold = 5
+struct-field-name-threshold = 5
diff --git a/tests/ui-toml/item_name_repetitions/threshold5/item_name_repetitions.rs b/tests/ui-toml/item_name_repetitions/threshold5/item_name_repetitions.rs
new file mode 100644
index 00000000000..d437311691d
--- /dev/null
+++ b/tests/ui-toml/item_name_repetitions/threshold5/item_name_repetitions.rs
@@ -0,0 +1,32 @@
+#![warn(clippy::struct_field_names)]
+
+struct Data {
+    a_data: u8,
+    b_data: u8,
+    c_data: u8,
+    d_data: u8,
+}
+struct Data2 {
+    //~^ ERROR: all fields have the same postfix
+    a_data: u8,
+    b_data: u8,
+    c_data: u8,
+    d_data: u8,
+    e_data: u8,
+}
+enum Foo {
+    AFoo,
+    BFoo,
+    CFoo,
+    DFoo,
+}
+enum Foo2 {
+    //~^ ERROR: all variants have the same postfix
+    AFoo,
+    BFoo,
+    CFoo,
+    DFoo,
+    EFoo,
+}
+
+fn main() {}
diff --git a/tests/ui-toml/item_name_repetitions/threshold5/item_name_repetitions.stderr b/tests/ui-toml/item_name_repetitions/threshold5/item_name_repetitions.stderr
new file mode 100644
index 00000000000..33802c44bf9
--- /dev/null
+++ b/tests/ui-toml/item_name_repetitions/threshold5/item_name_repetitions.stderr
@@ -0,0 +1,34 @@
+error: all fields have the same postfix: `data`
+  --> $DIR/item_name_repetitions.rs:9:1
+   |
+LL | / struct Data2 {
+LL | |
+LL | |     a_data: u8,
+LL | |     b_data: u8,
+...  |
+LL | |     e_data: u8,
+LL | | }
+   | |_^
+   |
+   = help: remove the postfixes
+   = note: `-D clippy::struct-field-names` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::struct_field_names)]`
+
+error: all variants have the same postfix: `Foo`
+  --> $DIR/item_name_repetitions.rs:23:1
+   |
+LL | / enum Foo2 {
+LL | |
+LL | |     AFoo,
+LL | |     BFoo,
+...  |
+LL | |     EFoo,
+LL | | }
+   | |_^
+   |
+   = help: remove the postfixes and use full paths to the variants instead of glob imports
+   = note: `-D clippy::enum-variant-names` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::enum_variant_names)]`
+
+error: aborting due to 2 previous errors
+
diff --git a/tests/ui-toml/pub_crate_missing_docs/pub_crate_missing_doc.rs b/tests/ui-toml/pub_crate_missing_docs/pub_crate_missing_doc.rs
index 830d71f61dd..cd53f504459 100644
--- a/tests/ui-toml/pub_crate_missing_docs/pub_crate_missing_doc.rs
+++ b/tests/ui-toml/pub_crate_missing_docs/pub_crate_missing_doc.rs
@@ -1,5 +1,6 @@
 //! this is crate
 #![allow(missing_docs)]
+#![allow(clippy::struct_field_names)]
 #![warn(clippy::missing_docs_in_private_items)]
 
 /// this is mod
diff --git a/tests/ui-toml/pub_crate_missing_docs/pub_crate_missing_doc.stderr b/tests/ui-toml/pub_crate_missing_docs/pub_crate_missing_doc.stderr
index 1ecdabbc03e..2cf20b46049 100644
--- a/tests/ui-toml/pub_crate_missing_docs/pub_crate_missing_doc.stderr
+++ b/tests/ui-toml/pub_crate_missing_docs/pub_crate_missing_doc.stderr
@@ -1,5 +1,5 @@
 error: missing documentation for a function
-  --> $DIR/pub_crate_missing_doc.rs:12:5
+  --> $DIR/pub_crate_missing_doc.rs:13:5
    |
 LL |     pub(crate) fn crate_no_docs() {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -8,25 +8,25 @@ LL |     pub(crate) fn crate_no_docs() {}
    = help: to override `-D warnings` add `#[allow(clippy::missing_docs_in_private_items)]`
 
 error: missing documentation for a function
-  --> $DIR/pub_crate_missing_doc.rs:15:5
+  --> $DIR/pub_crate_missing_doc.rs:16:5
    |
 LL |     pub(super) fn super_no_docs() {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: missing documentation for a function
-  --> $DIR/pub_crate_missing_doc.rs:23:9
+  --> $DIR/pub_crate_missing_doc.rs:24:9
    |
 LL |         pub(crate) fn sub_crate_no_docs() {}
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: missing documentation for a struct field
-  --> $DIR/pub_crate_missing_doc.rs:33:9
+  --> $DIR/pub_crate_missing_doc.rs:34:9
    |
 LL |         pub(crate) crate_field_no_docs: (),
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: missing documentation for a struct
-  --> $DIR/pub_crate_missing_doc.rs:39:5
+  --> $DIR/pub_crate_missing_doc.rs:40:5
    |
 LL | /     pub(crate) struct CrateStructNoDocs {
 LL | |         /// some docs
@@ -38,13 +38,13 @@ LL | |     }
    | |_____^
 
 error: missing documentation for a struct field
-  --> $DIR/pub_crate_missing_doc.rs:42:9
+  --> $DIR/pub_crate_missing_doc.rs:43:9
    |
 LL |         pub(crate) crate_field_no_docs: (),
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: missing documentation for a type alias
-  --> $DIR/pub_crate_missing_doc.rs:51:1
+  --> $DIR/pub_crate_missing_doc.rs:52:1
    |
 LL | type CrateTypedefNoDocs = String;
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
index 4bed5c149f5..2f9eaa5178c 100644
--- a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
+++ b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
@@ -53,6 +53,7 @@ error: error reading Clippy's configuration file: unknown field `foobar`, expect
            single-char-binding-names-threshold
            stack-size-threshold
            standard-macro-braces
+           struct-field-name-threshold
            suppress-restriction-lint-in-const
            third-party
            too-large-for-stack
@@ -126,6 +127,7 @@ error: error reading Clippy's configuration file: unknown field `barfoo`, expect
            single-char-binding-names-threshold
            stack-size-threshold
            standard-macro-braces
+           struct-field-name-threshold
            suppress-restriction-lint-in-const
            third-party
            too-large-for-stack
diff --git a/tests/ui/manual_filter_map.fixed b/tests/ui/manual_filter_map.fixed
index 4de45e39b10..a44c46c145c 100644
--- a/tests/ui/manual_filter_map.fixed
+++ b/tests/ui/manual_filter_map.fixed
@@ -2,6 +2,7 @@
 #![warn(clippy::manual_filter_map)]
 #![allow(clippy::redundant_closure)] // FIXME suggestion may have redundant closure
 #![allow(clippy::useless_vec)]
+#![allow(clippy::struct_field_names)]
 
 fn main() {
     // is_some(), unwrap()
diff --git a/tests/ui/manual_filter_map.rs b/tests/ui/manual_filter_map.rs
index 22f316f90b6..e72d0c4305b 100644
--- a/tests/ui/manual_filter_map.rs
+++ b/tests/ui/manual_filter_map.rs
@@ -2,6 +2,7 @@
 #![warn(clippy::manual_filter_map)]
 #![allow(clippy::redundant_closure)] // FIXME suggestion may have redundant closure
 #![allow(clippy::useless_vec)]
+#![allow(clippy::struct_field_names)]
 
 fn main() {
     // is_some(), unwrap()
diff --git a/tests/ui/manual_filter_map.stderr b/tests/ui/manual_filter_map.stderr
index 0bfc1f5c745..cf64bb25951 100644
--- a/tests/ui/manual_filter_map.stderr
+++ b/tests/ui/manual_filter_map.stderr
@@ -1,11 +1,11 @@
 error: `filter(..).map(..)` can be simplified as `filter_map(..)`
-  --> $DIR/manual_filter_map.rs:8:19
+  --> $DIR/manual_filter_map.rs:9:19
    |
 LL |     let _ = (0..).filter(|n| to_opt(*n).is_some()).map(|a| to_opt(a).unwrap());
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `filter_map(|a| to_opt(a))`
    |
 note: the suggestion might change the behavior of the program when merging `filter` and `map`, because this expression potentially contains side effects and will only execute once
-  --> $DIR/manual_filter_map.rs:8:30
+  --> $DIR/manual_filter_map.rs:9:30
    |
 LL |     let _ = (0..).filter(|n| to_opt(*n).is_some()).map(|a| to_opt(a).unwrap());
    |                              ^^^^^^^^^^
@@ -13,31 +13,31 @@ LL |     let _ = (0..).filter(|n| to_opt(*n).is_some()).map(|a| to_opt(a).unwrap
    = help: to override `-D warnings` add `#[allow(clippy::manual_filter_map)]`
 
 error: `filter(..).map(..)` can be simplified as `filter_map(..)`
-  --> $DIR/manual_filter_map.rs:11:19
+  --> $DIR/manual_filter_map.rs:12:19
    |
 LL |     let _ = (0..).filter(|&n| to_opt(n).is_some()).map(|a| to_opt(a).expect("hi"));
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `filter_map(|a| to_opt(a))`
    |
 note: the suggestion might change the behavior of the program when merging `filter` and `map`, because this expression potentially contains side effects and will only execute once
-  --> $DIR/manual_filter_map.rs:11:31
+  --> $DIR/manual_filter_map.rs:12:31
    |
 LL |     let _ = (0..).filter(|&n| to_opt(n).is_some()).map(|a| to_opt(a).expect("hi"));
    |                               ^^^^^^^^^
 
 error: `filter(..).map(..)` can be simplified as `filter_map(..)`
-  --> $DIR/manual_filter_map.rs:14:19
+  --> $DIR/manual_filter_map.rs:15:19
    |
 LL |     let _ = (0..).filter(|&n| to_res(n).is_ok()).map(|a| to_res(a).unwrap_or(1));
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `filter_map(|a| to_res(a).ok())`
    |
 note: the suggestion might change the behavior of the program when merging `filter` and `map`, because this expression potentially contains side effects and will only execute once
-  --> $DIR/manual_filter_map.rs:14:31
+  --> $DIR/manual_filter_map.rs:15:31
    |
 LL |     let _ = (0..).filter(|&n| to_res(n).is_ok()).map(|a| to_res(a).unwrap_or(1));
    |                               ^^^^^^^^^
 
 error: `filter(..).map(..)` can be simplified as `filter_map(..)`
-  --> $DIR/manual_filter_map.rs:17:10
+  --> $DIR/manual_filter_map.rs:18:10
    |
 LL |           .filter(|&x| to_ref(to_opt(x)).is_some())
    |  __________^
@@ -45,13 +45,13 @@ LL | |         .map(|y| to_ref(to_opt(y)).unwrap());
    | |____________________________________________^ help: try: `filter_map(|y| *to_ref(to_opt(y)))`
    |
 note: the suggestion might change the behavior of the program when merging `filter` and `map`, because this expression potentially contains side effects and will only execute once
-  --> $DIR/manual_filter_map.rs:17:22
+  --> $DIR/manual_filter_map.rs:18:22
    |
 LL |         .filter(|&x| to_ref(to_opt(x)).is_some())
    |                      ^^^^^^^^^^^^^^^^^
 
 error: `filter(..).map(..)` can be simplified as `filter_map(..)`
-  --> $DIR/manual_filter_map.rs:20:10
+  --> $DIR/manual_filter_map.rs:21:10
    |
 LL |           .filter(|x| to_ref(to_opt(*x)).is_some())
    |  __________^
@@ -59,13 +59,13 @@ LL | |         .map(|y| to_ref(to_opt(y)).unwrap());
    | |____________________________________________^ help: try: `filter_map(|y| *to_ref(to_opt(y)))`
    |
 note: the suggestion might change the behavior of the program when merging `filter` and `map`, because this expression potentially contains side effects and will only execute once
-  --> $DIR/manual_filter_map.rs:20:21
+  --> $DIR/manual_filter_map.rs:21:21
    |
 LL |         .filter(|x| to_ref(to_opt(*x)).is_some())
    |                     ^^^^^^^^^^^^^^^^^^
 
 error: `filter(..).map(..)` can be simplified as `filter_map(..)`
-  --> $DIR/manual_filter_map.rs:24:10
+  --> $DIR/manual_filter_map.rs:25:10
    |
 LL |           .filter(|&x| to_ref(to_res(x)).is_ok())
    |  __________^
@@ -73,13 +73,13 @@ LL | |         .map(|y| to_ref(to_res(y)).unwrap());
    | |____________________________________________^ help: try: `filter_map(|y| to_ref(to_res(y)).ok())`
    |
 note: the suggestion might change the behavior of the program when merging `filter` and `map`, because this expression potentially contains side effects and will only execute once
-  --> $DIR/manual_filter_map.rs:24:22
+  --> $DIR/manual_filter_map.rs:25:22
    |
 LL |         .filter(|&x| to_ref(to_res(x)).is_ok())
    |                      ^^^^^^^^^^^^^^^^^
 
 error: `filter(..).map(..)` can be simplified as `filter_map(..)`
-  --> $DIR/manual_filter_map.rs:27:10
+  --> $DIR/manual_filter_map.rs:28:10
    |
 LL |           .filter(|x| to_ref(to_res(*x)).is_ok())
    |  __________^
@@ -87,13 +87,13 @@ LL | |         .map(|y| to_ref(to_res(y)).unwrap());
    | |____________________________________________^ help: try: `filter_map(|y| to_ref(to_res(y)).ok())`
    |
 note: the suggestion might change the behavior of the program when merging `filter` and `map`, because this expression potentially contains side effects and will only execute once
-  --> $DIR/manual_filter_map.rs:27:21
+  --> $DIR/manual_filter_map.rs:28:21
    |
 LL |         .filter(|x| to_ref(to_res(*x)).is_ok())
    |                     ^^^^^^^^^^^^^^^^^^
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> $DIR/manual_filter_map.rs:33:27
+  --> $DIR/manual_filter_map.rs:34:27
    |
 LL |     iter::<Option<&u8>>().find(|x| x.is_some()).map(|x| x.cloned().unwrap());
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|x| x.cloned())`
@@ -102,79 +102,79 @@ LL |     iter::<Option<&u8>>().find(|x| x.is_some()).map(|x| x.cloned().unwrap()
    = help: to override `-D warnings` add `#[allow(clippy::manual_find_map)]`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> $DIR/manual_filter_map.rs:34:28
+  --> $DIR/manual_filter_map.rs:35:28
    |
 LL |     iter::<&Option<&u8>>().find(|x| x.is_some()).map(|x| x.cloned().unwrap());
    |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|x| x.cloned())`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> $DIR/manual_filter_map.rs:35:31
+  --> $DIR/manual_filter_map.rs:36:31
    |
 LL |     iter::<&Option<String>>().find(|x| x.is_some()).map(|x| x.as_deref().unwrap());
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|x| x.as_deref())`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> $DIR/manual_filter_map.rs:36:31
+  --> $DIR/manual_filter_map.rs:37:31
    |
 LL |     iter::<Option<&String>>().find(|&x| to_ref(x).is_some()).map(|y| to_ref(y).cloned().unwrap());
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|y| to_ref(y).cloned())`
    |
 note: the suggestion might change the behavior of the program when merging `filter` and `map`, because this expression potentially contains side effects and will only execute once
-  --> $DIR/manual_filter_map.rs:36:41
+  --> $DIR/manual_filter_map.rs:37:41
    |
 LL |     iter::<Option<&String>>().find(|&x| to_ref(x).is_some()).map(|y| to_ref(y).cloned().unwrap());
    |                                         ^^^^^^^^^
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> $DIR/manual_filter_map.rs:38:30
+  --> $DIR/manual_filter_map.rs:39:30
    |
 LL |     iter::<Result<u8, ()>>().find(|x| x.is_ok()).map(|x| x.unwrap());
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|x| x.ok())`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> $DIR/manual_filter_map.rs:39:31
+  --> $DIR/manual_filter_map.rs:40:31
    |
 LL |     iter::<&Result<u8, ()>>().find(|x| x.is_ok()).map(|x| x.unwrap());
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|x| x.ok())`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> $DIR/manual_filter_map.rs:40:32
+  --> $DIR/manual_filter_map.rs:41:32
    |
 LL |     iter::<&&Result<u8, ()>>().find(|x| x.is_ok()).map(|x| x.unwrap());
    |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|x| x.ok())`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> $DIR/manual_filter_map.rs:41:31
+  --> $DIR/manual_filter_map.rs:42:31
    |
 LL |     iter::<Result<&u8, ()>>().find(|x| x.is_ok()).map(|x| x.cloned().unwrap());
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|x| x.cloned().ok())`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> $DIR/manual_filter_map.rs:42:32
+  --> $DIR/manual_filter_map.rs:43:32
    |
 LL |     iter::<&Result<&u8, ()>>().find(|x| x.is_ok()).map(|x| x.cloned().unwrap());
    |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|x| x.cloned().ok())`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> $DIR/manual_filter_map.rs:43:35
+  --> $DIR/manual_filter_map.rs:44:35
    |
 LL |     iter::<&Result<String, ()>>().find(|x| x.is_ok()).map(|x| x.as_deref().unwrap());
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|x| x.as_deref().ok())`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> $DIR/manual_filter_map.rs:44:35
+  --> $DIR/manual_filter_map.rs:45:35
    |
 LL |     iter::<Result<&String, ()>>().find(|&x| to_ref(x).is_ok()).map(|y| to_ref(y).cloned().unwrap());
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|y| to_ref(y).cloned().ok())`
    |
 note: the suggestion might change the behavior of the program when merging `filter` and `map`, because this expression potentially contains side effects and will only execute once
-  --> $DIR/manual_filter_map.rs:44:45
+  --> $DIR/manual_filter_map.rs:45:45
    |
 LL |     iter::<Result<&String, ()>>().find(|&x| to_ref(x).is_ok()).map(|y| to_ref(y).cloned().unwrap());
    |                                             ^^^^^^^^^
 
 error: `filter(..).map(..)` can be simplified as `filter_map(..)`
-  --> $DIR/manual_filter_map.rs:92:10
+  --> $DIR/manual_filter_map.rs:93:10
    |
 LL |           .filter(|f| f.option_field.is_some())
    |  __________^
@@ -182,7 +182,7 @@ LL | |         .map(|f| f.option_field.clone().unwrap());
    | |_________________________________________________^ help: try: `filter_map(|f| f.option_field.clone())`
 
 error: `filter(..).map(..)` can be simplified as `filter_map(..)`
-  --> $DIR/manual_filter_map.rs:97:10
+  --> $DIR/manual_filter_map.rs:98:10
    |
 LL |           .filter(|f| f.ref_field.is_some())
    |  __________^
@@ -190,7 +190,7 @@ LL | |         .map(|f| f.ref_field.cloned().unwrap());
    | |_______________________________________________^ help: try: `filter_map(|f| f.ref_field.cloned())`
 
 error: `filter(..).map(..)` can be simplified as `filter_map(..)`
-  --> $DIR/manual_filter_map.rs:102:10
+  --> $DIR/manual_filter_map.rs:103:10
    |
 LL |           .filter(|f| f.ref_field.is_some())
    |  __________^
@@ -198,7 +198,7 @@ LL | |         .map(|f| f.ref_field.copied().unwrap());
    | |_______________________________________________^ help: try: `filter_map(|f| f.ref_field.copied())`
 
 error: `filter(..).map(..)` can be simplified as `filter_map(..)`
-  --> $DIR/manual_filter_map.rs:107:10
+  --> $DIR/manual_filter_map.rs:108:10
    |
 LL |           .filter(|f| f.result_field.is_ok())
    |  __________^
@@ -206,7 +206,7 @@ LL | |         .map(|f| f.result_field.clone().unwrap());
    | |_________________________________________________^ help: try: `filter_map(|f| f.result_field.clone().ok())`
 
 error: `filter(..).map(..)` can be simplified as `filter_map(..)`
-  --> $DIR/manual_filter_map.rs:112:10
+  --> $DIR/manual_filter_map.rs:113:10
    |
 LL |           .filter(|f| f.result_field.is_ok())
    |  __________^
@@ -214,7 +214,7 @@ LL | |         .map(|f| f.result_field.as_ref().unwrap());
    | |__________________________________________________^ help: try: `filter_map(|f| f.result_field.as_ref().ok())`
 
 error: `filter(..).map(..)` can be simplified as `filter_map(..)`
-  --> $DIR/manual_filter_map.rs:117:10
+  --> $DIR/manual_filter_map.rs:118:10
    |
 LL |           .filter(|f| f.result_field.is_ok())
    |  __________^
@@ -222,7 +222,7 @@ LL | |         .map(|f| f.result_field.as_deref().unwrap());
    | |____________________________________________________^ help: try: `filter_map(|f| f.result_field.as_deref().ok())`
 
 error: `filter(..).map(..)` can be simplified as `filter_map(..)`
-  --> $DIR/manual_filter_map.rs:122:10
+  --> $DIR/manual_filter_map.rs:123:10
    |
 LL |           .filter(|f| f.result_field.is_ok())
    |  __________^
@@ -230,7 +230,7 @@ LL | |         .map(|f| f.result_field.as_mut().unwrap());
    | |__________________________________________________^ help: try: `filter_map(|f| f.result_field.as_mut().ok())`
 
 error: `filter(..).map(..)` can be simplified as `filter_map(..)`
-  --> $DIR/manual_filter_map.rs:127:10
+  --> $DIR/manual_filter_map.rs:128:10
    |
 LL |           .filter(|f| f.result_field.is_ok())
    |  __________^
@@ -238,7 +238,7 @@ LL | |         .map(|f| f.result_field.as_deref_mut().unwrap());
    | |________________________________________________________^ help: try: `filter_map(|f| f.result_field.as_deref_mut().ok())`
 
 error: `filter(..).map(..)` can be simplified as `filter_map(..)`
-  --> $DIR/manual_filter_map.rs:132:10
+  --> $DIR/manual_filter_map.rs:133:10
    |
 LL |           .filter(|f| f.result_field.is_ok())
    |  __________^
@@ -246,7 +246,7 @@ LL | |         .map(|f| f.result_field.to_owned().unwrap());
    | |____________________________________________________^ help: try: `filter_map(|f| f.result_field.to_owned().ok())`
 
 error: `filter(..).map(..)` can be simplified as `filter_map(..)`
-  --> $DIR/manual_filter_map.rs:145:27
+  --> $DIR/manual_filter_map.rs:146:27
    |
 LL |       let _x = iter.clone().filter(|x| matches!(x, Enum::A(_))).map(|x| match x {
    |  ___________________________^
@@ -256,7 +256,7 @@ LL | |     });
    | |______^ help: try: `filter_map(|x| match x { Enum::A(s) => Some(s), _ => None })`
 
 error: `filter(..).map(..)` can be simplified as `filter_map(..)`
-  --> $DIR/manual_filter_map.rs:155:10
+  --> $DIR/manual_filter_map.rs:156:10
    |
 LL |           .filter(|x| matches!(x, Enum::A(_)))
    |  __________^
diff --git a/tests/ui/manual_find_map.fixed b/tests/ui/manual_find_map.fixed
index 0e92d25e68f..2d9a356b9bc 100644
--- a/tests/ui/manual_find_map.fixed
+++ b/tests/ui/manual_find_map.fixed
@@ -2,6 +2,7 @@
 #![warn(clippy::manual_find_map)]
 #![allow(clippy::redundant_closure)] // FIXME suggestion may have redundant closure
 #![allow(clippy::useless_vec)]
+#![allow(clippy::struct_field_names)]
 
 fn main() {
     // is_some(), unwrap()
diff --git a/tests/ui/manual_find_map.rs b/tests/ui/manual_find_map.rs
index b2568c823eb..7c5cc136695 100644
--- a/tests/ui/manual_find_map.rs
+++ b/tests/ui/manual_find_map.rs
@@ -2,6 +2,7 @@
 #![warn(clippy::manual_find_map)]
 #![allow(clippy::redundant_closure)] // FIXME suggestion may have redundant closure
 #![allow(clippy::useless_vec)]
+#![allow(clippy::struct_field_names)]
 
 fn main() {
     // is_some(), unwrap()
diff --git a/tests/ui/manual_find_map.stderr b/tests/ui/manual_find_map.stderr
index 0dc9ae1df03..0526382323d 100644
--- a/tests/ui/manual_find_map.stderr
+++ b/tests/ui/manual_find_map.stderr
@@ -1,11 +1,11 @@
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> $DIR/manual_find_map.rs:8:19
+  --> $DIR/manual_find_map.rs:9:19
    |
 LL |     let _ = (0..).find(|n| to_opt(*n).is_some()).map(|a| to_opt(a).unwrap());
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|a| to_opt(a))`
    |
 note: the suggestion might change the behavior of the program when merging `filter` and `map`, because this expression potentially contains side effects and will only execute once
-  --> $DIR/manual_find_map.rs:8:28
+  --> $DIR/manual_find_map.rs:9:28
    |
 LL |     let _ = (0..).find(|n| to_opt(*n).is_some()).map(|a| to_opt(a).unwrap());
    |                            ^^^^^^^^^^
@@ -13,31 +13,31 @@ LL |     let _ = (0..).find(|n| to_opt(*n).is_some()).map(|a| to_opt(a).unwrap()
    = help: to override `-D warnings` add `#[allow(clippy::manual_find_map)]`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> $DIR/manual_find_map.rs:11:19
+  --> $DIR/manual_find_map.rs:12:19
    |
 LL |     let _ = (0..).find(|&n| to_opt(n).is_some()).map(|a| to_opt(a).expect("hi"));
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|a| to_opt(a))`
    |
 note: the suggestion might change the behavior of the program when merging `filter` and `map`, because this expression potentially contains side effects and will only execute once
-  --> $DIR/manual_find_map.rs:11:29
+  --> $DIR/manual_find_map.rs:12:29
    |
 LL |     let _ = (0..).find(|&n| to_opt(n).is_some()).map(|a| to_opt(a).expect("hi"));
    |                             ^^^^^^^^^
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> $DIR/manual_find_map.rs:14:19
+  --> $DIR/manual_find_map.rs:15:19
    |
 LL |     let _ = (0..).find(|&n| to_res(n).is_ok()).map(|a| to_res(a).unwrap_or(1));
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|a| to_res(a).ok())`
    |
 note: the suggestion might change the behavior of the program when merging `filter` and `map`, because this expression potentially contains side effects and will only execute once
-  --> $DIR/manual_find_map.rs:14:29
+  --> $DIR/manual_find_map.rs:15:29
    |
 LL |     let _ = (0..).find(|&n| to_res(n).is_ok()).map(|a| to_res(a).unwrap_or(1));
    |                             ^^^^^^^^^
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> $DIR/manual_find_map.rs:17:10
+  --> $DIR/manual_find_map.rs:18:10
    |
 LL |           .find(|&x| to_ref(to_opt(x)).is_some())
    |  __________^
@@ -45,13 +45,13 @@ LL | |         .map(|y| to_ref(to_opt(y)).unwrap());
    | |____________________________________________^ help: try: `find_map(|y| *to_ref(to_opt(y)))`
    |
 note: the suggestion might change the behavior of the program when merging `filter` and `map`, because this expression potentially contains side effects and will only execute once
-  --> $DIR/manual_find_map.rs:17:20
+  --> $DIR/manual_find_map.rs:18:20
    |
 LL |         .find(|&x| to_ref(to_opt(x)).is_some())
    |                    ^^^^^^^^^^^^^^^^^
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> $DIR/manual_find_map.rs:20:10
+  --> $DIR/manual_find_map.rs:21:10
    |
 LL |           .find(|x| to_ref(to_opt(*x)).is_some())
    |  __________^
@@ -59,13 +59,13 @@ LL | |         .map(|y| to_ref(to_opt(y)).unwrap());
    | |____________________________________________^ help: try: `find_map(|y| *to_ref(to_opt(y)))`
    |
 note: the suggestion might change the behavior of the program when merging `filter` and `map`, because this expression potentially contains side effects and will only execute once
-  --> $DIR/manual_find_map.rs:20:19
+  --> $DIR/manual_find_map.rs:21:19
    |
 LL |         .find(|x| to_ref(to_opt(*x)).is_some())
    |                   ^^^^^^^^^^^^^^^^^^
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> $DIR/manual_find_map.rs:24:10
+  --> $DIR/manual_find_map.rs:25:10
    |
 LL |           .find(|&x| to_ref(to_res(x)).is_ok())
    |  __________^
@@ -73,13 +73,13 @@ LL | |         .map(|y| to_ref(to_res(y)).unwrap());
    | |____________________________________________^ help: try: `find_map(|y| to_ref(to_res(y)).ok())`
    |
 note: the suggestion might change the behavior of the program when merging `filter` and `map`, because this expression potentially contains side effects and will only execute once
-  --> $DIR/manual_find_map.rs:24:20
+  --> $DIR/manual_find_map.rs:25:20
    |
 LL |         .find(|&x| to_ref(to_res(x)).is_ok())
    |                    ^^^^^^^^^^^^^^^^^
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> $DIR/manual_find_map.rs:27:10
+  --> $DIR/manual_find_map.rs:28:10
    |
 LL |           .find(|x| to_ref(to_res(*x)).is_ok())
    |  __________^
@@ -87,109 +87,109 @@ LL | |         .map(|y| to_ref(to_res(y)).unwrap());
    | |____________________________________________^ help: try: `find_map(|y| to_ref(to_res(y)).ok())`
    |
 note: the suggestion might change the behavior of the program when merging `filter` and `map`, because this expression potentially contains side effects and will only execute once
-  --> $DIR/manual_find_map.rs:27:19
+  --> $DIR/manual_find_map.rs:28:19
    |
 LL |         .find(|x| to_ref(to_res(*x)).is_ok())
    |                   ^^^^^^^^^^^^^^^^^^
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> $DIR/manual_find_map.rs:33:26
+  --> $DIR/manual_find_map.rs:34:26
    |
 LL |     iter::<Option<u8>>().find(|x| x.is_some()).map(|x| x.unwrap());
    |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|x| x)`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> $DIR/manual_find_map.rs:34:27
+  --> $DIR/manual_find_map.rs:35:27
    |
 LL |     iter::<&Option<u8>>().find(|x| x.is_some()).map(|x| x.unwrap());
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|x| *x)`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> $DIR/manual_find_map.rs:35:28
+  --> $DIR/manual_find_map.rs:36:28
    |
 LL |     iter::<&&Option<u8>>().find(|x| x.is_some()).map(|x| x.unwrap());
    |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|x| **x)`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> $DIR/manual_find_map.rs:36:27
+  --> $DIR/manual_find_map.rs:37:27
    |
 LL |     iter::<Option<&u8>>().find(|x| x.is_some()).map(|x| x.cloned().unwrap());
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|x| x.cloned())`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> $DIR/manual_find_map.rs:37:28
+  --> $DIR/manual_find_map.rs:38:28
    |
 LL |     iter::<&Option<&u8>>().find(|x| x.is_some()).map(|x| x.cloned().unwrap());
    |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|x| x.cloned())`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> $DIR/manual_find_map.rs:38:31
+  --> $DIR/manual_find_map.rs:39:31
    |
 LL |     iter::<&Option<String>>().find(|x| x.is_some()).map(|x| x.as_deref().unwrap());
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|x| x.as_deref())`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> $DIR/manual_find_map.rs:39:31
+  --> $DIR/manual_find_map.rs:40:31
    |
 LL |     iter::<Option<&String>>().find(|&x| to_ref(x).is_some()).map(|y| to_ref(y).cloned().unwrap());
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|y| to_ref(y).cloned())`
    |
 note: the suggestion might change the behavior of the program when merging `filter` and `map`, because this expression potentially contains side effects and will only execute once
-  --> $DIR/manual_find_map.rs:39:41
+  --> $DIR/manual_find_map.rs:40:41
    |
 LL |     iter::<Option<&String>>().find(|&x| to_ref(x).is_some()).map(|y| to_ref(y).cloned().unwrap());
    |                                         ^^^^^^^^^
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> $DIR/manual_find_map.rs:41:30
+  --> $DIR/manual_find_map.rs:42:30
    |
 LL |     iter::<Result<u8, ()>>().find(|x| x.is_ok()).map(|x| x.unwrap());
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|x| x.ok())`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> $DIR/manual_find_map.rs:42:31
+  --> $DIR/manual_find_map.rs:43:31
    |
 LL |     iter::<&Result<u8, ()>>().find(|x| x.is_ok()).map(|x| x.unwrap());
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|x| x.ok())`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> $DIR/manual_find_map.rs:43:32
+  --> $DIR/manual_find_map.rs:44:32
    |
 LL |     iter::<&&Result<u8, ()>>().find(|x| x.is_ok()).map(|x| x.unwrap());
    |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|x| x.ok())`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> $DIR/manual_find_map.rs:44:31
+  --> $DIR/manual_find_map.rs:45:31
    |
 LL |     iter::<Result<&u8, ()>>().find(|x| x.is_ok()).map(|x| x.cloned().unwrap());
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|x| x.cloned().ok())`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> $DIR/manual_find_map.rs:45:32
+  --> $DIR/manual_find_map.rs:46:32
    |
 LL |     iter::<&Result<&u8, ()>>().find(|x| x.is_ok()).map(|x| x.cloned().unwrap());
    |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|x| x.cloned().ok())`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> $DIR/manual_find_map.rs:46:35
+  --> $DIR/manual_find_map.rs:47:35
    |
 LL |     iter::<&Result<String, ()>>().find(|x| x.is_ok()).map(|x| x.as_deref().unwrap());
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|x| x.as_deref().ok())`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> $DIR/manual_find_map.rs:47:35
+  --> $DIR/manual_find_map.rs:48:35
    |
 LL |     iter::<Result<&String, ()>>().find(|&x| to_ref(x).is_ok()).map(|y| to_ref(y).cloned().unwrap());
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|y| to_ref(y).cloned().ok())`
    |
 note: the suggestion might change the behavior of the program when merging `filter` and `map`, because this expression potentially contains side effects and will only execute once
-  --> $DIR/manual_find_map.rs:47:45
+  --> $DIR/manual_find_map.rs:48:45
    |
 LL |     iter::<Result<&String, ()>>().find(|&x| to_ref(x).is_ok()).map(|y| to_ref(y).cloned().unwrap());
    |                                             ^^^^^^^^^
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> $DIR/manual_find_map.rs:95:10
+  --> $DIR/manual_find_map.rs:96:10
    |
 LL |           .find(|f| f.option_field.is_some())
    |  __________^
@@ -197,7 +197,7 @@ LL | |         .map(|f| f.option_field.clone().unwrap());
    | |_________________________________________________^ help: try: `find_map(|f| f.option_field.clone())`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> $DIR/manual_find_map.rs:100:10
+  --> $DIR/manual_find_map.rs:101:10
    |
 LL |           .find(|f| f.ref_field.is_some())
    |  __________^
@@ -205,7 +205,7 @@ LL | |         .map(|f| f.ref_field.cloned().unwrap());
    | |_______________________________________________^ help: try: `find_map(|f| f.ref_field.cloned())`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> $DIR/manual_find_map.rs:105:10
+  --> $DIR/manual_find_map.rs:106:10
    |
 LL |           .find(|f| f.ref_field.is_some())
    |  __________^
@@ -213,7 +213,7 @@ LL | |         .map(|f| f.ref_field.copied().unwrap());
    | |_______________________________________________^ help: try: `find_map(|f| f.ref_field.copied())`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> $DIR/manual_find_map.rs:110:10
+  --> $DIR/manual_find_map.rs:111:10
    |
 LL |           .find(|f| f.result_field.is_ok())
    |  __________^
@@ -221,7 +221,7 @@ LL | |         .map(|f| f.result_field.clone().unwrap());
    | |_________________________________________________^ help: try: `find_map(|f| f.result_field.clone().ok())`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> $DIR/manual_find_map.rs:115:10
+  --> $DIR/manual_find_map.rs:116:10
    |
 LL |           .find(|f| f.result_field.is_ok())
    |  __________^
@@ -229,7 +229,7 @@ LL | |         .map(|f| f.result_field.as_ref().unwrap());
    | |__________________________________________________^ help: try: `find_map(|f| f.result_field.as_ref().ok())`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> $DIR/manual_find_map.rs:120:10
+  --> $DIR/manual_find_map.rs:121:10
    |
 LL |           .find(|f| f.result_field.is_ok())
    |  __________^
@@ -237,7 +237,7 @@ LL | |         .map(|f| f.result_field.as_deref().unwrap());
    | |____________________________________________________^ help: try: `find_map(|f| f.result_field.as_deref().ok())`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> $DIR/manual_find_map.rs:125:10
+  --> $DIR/manual_find_map.rs:126:10
    |
 LL |           .find(|f| f.result_field.is_ok())
    |  __________^
@@ -245,7 +245,7 @@ LL | |         .map(|f| f.result_field.as_mut().unwrap());
    | |__________________________________________________^ help: try: `find_map(|f| f.result_field.as_mut().ok())`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> $DIR/manual_find_map.rs:130:10
+  --> $DIR/manual_find_map.rs:131:10
    |
 LL |           .find(|f| f.result_field.is_ok())
    |  __________^
@@ -253,7 +253,7 @@ LL | |         .map(|f| f.result_field.as_deref_mut().unwrap());
    | |________________________________________________________^ help: try: `find_map(|f| f.result_field.as_deref_mut().ok())`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> $DIR/manual_find_map.rs:135:10
+  --> $DIR/manual_find_map.rs:136:10
    |
 LL |           .find(|f| f.result_field.is_ok())
    |  __________^
diff --git a/tests/ui/min_ident_chars.rs b/tests/ui/min_ident_chars.rs
index 030863ca0d3..f99c35d5c57 100644
--- a/tests/ui/min_ident_chars.rs
+++ b/tests/ui/min_ident_chars.rs
@@ -1,5 +1,6 @@
 //@aux-build:proc_macros.rs
 #![allow(irrefutable_let_patterns, nonstandard_style, unused)]
+#![allow(clippy::struct_field_names)]
 #![warn(clippy::min_ident_chars)]
 
 extern crate proc_macros;
diff --git a/tests/ui/min_ident_chars.stderr b/tests/ui/min_ident_chars.stderr
index 253636cf91d..e4181157ea2 100644
--- a/tests/ui/min_ident_chars.stderr
+++ b/tests/ui/min_ident_chars.stderr
@@ -1,5 +1,5 @@
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:8:8
+  --> $DIR/min_ident_chars.rs:9:8
    |
 LL | struct A {
    |        ^
@@ -8,169 +8,169 @@ LL | struct A {
    = help: to override `-D warnings` add `#[allow(clippy::min_ident_chars)]`
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:9:5
+  --> $DIR/min_ident_chars.rs:10:5
    |
 LL |     a: u32,
    |     ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:11:5
+  --> $DIR/min_ident_chars.rs:12:5
    |
 LL |     A: u32,
    |     ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:12:5
+  --> $DIR/min_ident_chars.rs:13:5
    |
 LL |     I: u32,
    |     ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:15:8
+  --> $DIR/min_ident_chars.rs:16:8
    |
 LL | struct B(u32);
    |        ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:17:8
+  --> $DIR/min_ident_chars.rs:18:8
    |
 LL | struct O {
    |        ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:18:5
+  --> $DIR/min_ident_chars.rs:19:5
    |
 LL |     o: u32,
    |     ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:23:6
+  --> $DIR/min_ident_chars.rs:24:6
    |
 LL | enum C {
    |      ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:24:5
+  --> $DIR/min_ident_chars.rs:25:5
    |
 LL |     D,
    |     ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:25:5
+  --> $DIR/min_ident_chars.rs:26:5
    |
 LL |     E,
    |     ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:26:5
+  --> $DIR/min_ident_chars.rs:27:5
    |
 LL |     F,
    |     ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:50:9
+  --> $DIR/min_ident_chars.rs:51:9
    |
 LL |     let h = 1;
    |         ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:51:9
+  --> $DIR/min_ident_chars.rs:52:9
    |
 LL |     let e = 2;
    |         ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:52:9
+  --> $DIR/min_ident_chars.rs:53:9
    |
 LL |     let l = 3;
    |         ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:53:9
+  --> $DIR/min_ident_chars.rs:54:9
    |
 LL |     let l = 4;
    |         ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:54:9
+  --> $DIR/min_ident_chars.rs:55:9
    |
 LL |     let o = 6;
    |         ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:58:10
+  --> $DIR/min_ident_chars.rs:59:10
    |
 LL |     let (h, o, w) = (1, 2, 3);
    |          ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:58:13
+  --> $DIR/min_ident_chars.rs:59:13
    |
 LL |     let (h, o, w) = (1, 2, 3);
    |             ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:59:10
+  --> $DIR/min_ident_chars.rs:60:10
    |
 LL |     for (a, (r, e)) in (0..1000).enumerate().enumerate() {}
    |          ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:59:14
+  --> $DIR/min_ident_chars.rs:60:14
    |
 LL |     for (a, (r, e)) in (0..1000).enumerate().enumerate() {}
    |              ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:59:17
+  --> $DIR/min_ident_chars.rs:60:17
    |
 LL |     for (a, (r, e)) in (0..1000).enumerate().enumerate() {}
    |                 ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:61:16
+  --> $DIR/min_ident_chars.rs:62:16
    |
 LL |     while let (d, o, _i, n, g) = (true, true, false, false, true) {}
    |                ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:61:19
+  --> $DIR/min_ident_chars.rs:62:19
    |
 LL |     while let (d, o, _i, n, g) = (true, true, false, false, true) {}
    |                   ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:61:29
+  --> $DIR/min_ident_chars.rs:62:29
    |
 LL |     while let (d, o, _i, n, g) = (true, true, false, false, true) {}
    |                             ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:65:9
+  --> $DIR/min_ident_chars.rs:66:9
    |
 LL |     let o = 1;
    |         ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:66:9
+  --> $DIR/min_ident_chars.rs:67:9
    |
 LL |     let o = O { o };
    |         ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:80:4
+  --> $DIR/min_ident_chars.rs:81:4
    |
 LL | fn b() {}
    |    ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:81:21
+  --> $DIR/min_ident_chars.rs:82:21
    |
 LL | fn wrong_pythagoras(a: f32, b: f32) -> f32 {
    |                     ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:81:29
+  --> $DIR/min_ident_chars.rs:82:29
    |
 LL | fn wrong_pythagoras(a: f32, b: f32) -> f32 {
    |                             ^
diff --git a/tests/ui/misnamed_getters.fixed b/tests/ui/misnamed_getters.fixed
index 2a7a2067ee0..70af604b214 100644
--- a/tests/ui/misnamed_getters.fixed
+++ b/tests/ui/misnamed_getters.fixed
@@ -1,4 +1,5 @@
 #![allow(unused)]
+#![allow(clippy::struct_field_names)]
 #![warn(clippy::misnamed_getters)]
 
 struct A {
diff --git a/tests/ui/misnamed_getters.rs b/tests/ui/misnamed_getters.rs
index 56ddc46c4d4..23c3e7bc5cf 100644
--- a/tests/ui/misnamed_getters.rs
+++ b/tests/ui/misnamed_getters.rs
@@ -1,4 +1,5 @@
 #![allow(unused)]
+#![allow(clippy::struct_field_names)]
 #![warn(clippy::misnamed_getters)]
 
 struct A {
diff --git a/tests/ui/misnamed_getters.stderr b/tests/ui/misnamed_getters.stderr
index aadec654908..120a3f3112e 100644
--- a/tests/ui/misnamed_getters.stderr
+++ b/tests/ui/misnamed_getters.stderr
@@ -1,5 +1,5 @@
 error: getter function appears to return the wrong field
-  --> $DIR/misnamed_getters.rs:11:5
+  --> $DIR/misnamed_getters.rs:12:5
    |
 LL | /     fn a(&self) -> &u8 {
 LL | |
@@ -13,7 +13,7 @@ LL | |     }
    = help: to override `-D warnings` add `#[allow(clippy::misnamed_getters)]`
 
 error: getter function appears to return the wrong field
-  --> $DIR/misnamed_getters.rs:16:5
+  --> $DIR/misnamed_getters.rs:17:5
    |
 LL | /     fn a_mut(&mut self) -> &mut u8 {
 LL | |
@@ -23,7 +23,7 @@ LL | |     }
    | |_____^
 
 error: getter function appears to return the wrong field
-  --> $DIR/misnamed_getters.rs:21:5
+  --> $DIR/misnamed_getters.rs:22:5
    |
 LL | /     fn b(self) -> u8 {
 LL | |
@@ -33,7 +33,7 @@ LL | |     }
    | |_____^
 
 error: getter function appears to return the wrong field
-  --> $DIR/misnamed_getters.rs:26:5
+  --> $DIR/misnamed_getters.rs:27:5
    |
 LL | /     fn b_mut(&mut self) -> &mut u8 {
 LL | |
@@ -43,7 +43,7 @@ LL | |     }
    | |_____^
 
 error: getter function appears to return the wrong field
-  --> $DIR/misnamed_getters.rs:31:5
+  --> $DIR/misnamed_getters.rs:32:5
    |
 LL | /     fn c(&self) -> &u8 {
 LL | |
@@ -53,7 +53,7 @@ LL | |     }
    | |_____^
 
 error: getter function appears to return the wrong field
-  --> $DIR/misnamed_getters.rs:36:5
+  --> $DIR/misnamed_getters.rs:37:5
    |
 LL | /     fn c_mut(&mut self) -> &mut u8 {
 LL | |
@@ -63,7 +63,7 @@ LL | |     }
    | |_____^
 
 error: getter function appears to return the wrong field
-  --> $DIR/misnamed_getters.rs:48:5
+  --> $DIR/misnamed_getters.rs:49:5
    |
 LL | /     unsafe fn a(&self) -> &u8 {
 LL | |
@@ -73,7 +73,7 @@ LL | |     }
    | |_____^
 
 error: getter function appears to return the wrong field
-  --> $DIR/misnamed_getters.rs:52:5
+  --> $DIR/misnamed_getters.rs:53:5
    |
 LL | /     unsafe fn a_mut(&mut self) -> &mut u8 {
 LL | |
@@ -83,7 +83,7 @@ LL | |     }
    | |_____^
 
 error: getter function appears to return the wrong field
-  --> $DIR/misnamed_getters.rs:57:5
+  --> $DIR/misnamed_getters.rs:58:5
    |
 LL | /     unsafe fn b(self) -> u8 {
 LL | |
@@ -93,7 +93,7 @@ LL | |     }
    | |_____^
 
 error: getter function appears to return the wrong field
-  --> $DIR/misnamed_getters.rs:62:5
+  --> $DIR/misnamed_getters.rs:63:5
    |
 LL | /     unsafe fn b_mut(&mut self) -> &mut u8 {
 LL | |
@@ -103,7 +103,7 @@ LL | |     }
    | |_____^
 
 error: getter function appears to return the wrong field
-  --> $DIR/misnamed_getters.rs:75:5
+  --> $DIR/misnamed_getters.rs:76:5
    |
 LL | /     unsafe fn a_unchecked(&self) -> &u8 {
 LL | |
@@ -113,7 +113,7 @@ LL | |     }
    | |_____^
 
 error: getter function appears to return the wrong field
-  --> $DIR/misnamed_getters.rs:79:5
+  --> $DIR/misnamed_getters.rs:80:5
    |
 LL | /     unsafe fn a_unchecked_mut(&mut self) -> &mut u8 {
 LL | |
@@ -123,7 +123,7 @@ LL | |     }
    | |_____^
 
 error: getter function appears to return the wrong field
-  --> $DIR/misnamed_getters.rs:84:5
+  --> $DIR/misnamed_getters.rs:85:5
    |
 LL | /     unsafe fn b_unchecked(self) -> u8 {
 LL | |
@@ -133,7 +133,7 @@ LL | |     }
    | |_____^
 
 error: getter function appears to return the wrong field
-  --> $DIR/misnamed_getters.rs:89:5
+  --> $DIR/misnamed_getters.rs:90:5
    |
 LL | /     unsafe fn b_unchecked_mut(&mut self) -> &mut u8 {
 LL | |
@@ -143,7 +143,7 @@ LL | |     }
    | |_____^
 
 error: getter function appears to return the wrong field
-  --> $DIR/misnamed_getters.rs:122:5
+  --> $DIR/misnamed_getters.rs:123:5
    |
 LL | /     fn a(&self) -> &u8 {
 LL | |
@@ -153,7 +153,7 @@ LL | |     }
    | |_____^
 
 error: getter function appears to return the wrong field
-  --> $DIR/misnamed_getters.rs:126:5
+  --> $DIR/misnamed_getters.rs:127:5
    |
 LL | /     fn a_mut(&mut self) -> &mut u8 {
 LL | |
@@ -163,7 +163,7 @@ LL | |     }
    | |_____^
 
 error: getter function appears to return the wrong field
-  --> $DIR/misnamed_getters.rs:131:5
+  --> $DIR/misnamed_getters.rs:132:5
    |
 LL | /     fn d(&self) -> &u8 {
 LL | |
@@ -173,7 +173,7 @@ LL | |     }
    | |_____^
 
 error: getter function appears to return the wrong field
-  --> $DIR/misnamed_getters.rs:135:5
+  --> $DIR/misnamed_getters.rs:136:5
    |
 LL | /     fn d_mut(&mut self) -> &mut u8 {
 LL | |
diff --git a/tests/ui/needless_bool/fixable.fixed b/tests/ui/needless_bool/fixable.fixed
index c9ea831f8b2..3059de8f89c 100644
--- a/tests/ui/needless_bool/fixable.fixed
+++ b/tests/ui/needless_bool/fixable.fixed
@@ -7,7 +7,8 @@
     clippy::equatable_if_let,
     clippy::needless_if,
     clippy::needless_return,
-    clippy::self_named_constructors
+    clippy::self_named_constructors,
+    clippy::struct_field_names
 )]
 
 use std::cell::Cell;
diff --git a/tests/ui/needless_bool/fixable.rs b/tests/ui/needless_bool/fixable.rs
index b83d9c3f209..b2cbe86e223 100644
--- a/tests/ui/needless_bool/fixable.rs
+++ b/tests/ui/needless_bool/fixable.rs
@@ -7,7 +7,8 @@
     clippy::equatable_if_let,
     clippy::needless_if,
     clippy::needless_return,
-    clippy::self_named_constructors
+    clippy::self_named_constructors,
+    clippy::struct_field_names
 )]
 
 use std::cell::Cell;
diff --git a/tests/ui/needless_bool/fixable.stderr b/tests/ui/needless_bool/fixable.stderr
index 2b189c89851..72b0670c95b 100644
--- a/tests/ui/needless_bool/fixable.stderr
+++ b/tests/ui/needless_bool/fixable.stderr
@@ -1,5 +1,5 @@
 error: this if-then-else expression returns a bool literal
-  --> $DIR/fixable.rs:40:5
+  --> $DIR/fixable.rs:41:5
    |
 LL | /     if x {
 LL | |         true
@@ -12,7 +12,7 @@ LL | |     };
    = help: to override `-D warnings` add `#[allow(clippy::needless_bool)]`
 
 error: this if-then-else expression returns a bool literal
-  --> $DIR/fixable.rs:45:5
+  --> $DIR/fixable.rs:46:5
    |
 LL | /     if x {
 LL | |         false
@@ -22,7 +22,7 @@ LL | |     };
    | |_____^ help: you can reduce it to: `!x`
 
 error: this if-then-else expression returns a bool literal
-  --> $DIR/fixable.rs:50:5
+  --> $DIR/fixable.rs:51:5
    |
 LL | /     if x && y {
 LL | |         false
@@ -32,7 +32,7 @@ LL | |     };
    | |_____^ help: you can reduce it to: `!(x && y)`
 
 error: this if-then-else expression returns a bool literal
-  --> $DIR/fixable.rs:58:5
+  --> $DIR/fixable.rs:59:5
    |
 LL | /     if a == b {
 LL | |         false
@@ -42,7 +42,7 @@ LL | |     };
    | |_____^ help: you can reduce it to: `a != b`
 
 error: this if-then-else expression returns a bool literal
-  --> $DIR/fixable.rs:63:5
+  --> $DIR/fixable.rs:64:5
    |
 LL | /     if a != b {
 LL | |         false
@@ -52,7 +52,7 @@ LL | |     };
    | |_____^ help: you can reduce it to: `a == b`
 
 error: this if-then-else expression returns a bool literal
-  --> $DIR/fixable.rs:68:5
+  --> $DIR/fixable.rs:69:5
    |
 LL | /     if a < b {
 LL | |         false
@@ -62,7 +62,7 @@ LL | |     };
    | |_____^ help: you can reduce it to: `a >= b`
 
 error: this if-then-else expression returns a bool literal
-  --> $DIR/fixable.rs:73:5
+  --> $DIR/fixable.rs:74:5
    |
 LL | /     if a <= b {
 LL | |         false
@@ -72,7 +72,7 @@ LL | |     };
    | |_____^ help: you can reduce it to: `a > b`
 
 error: this if-then-else expression returns a bool literal
-  --> $DIR/fixable.rs:78:5
+  --> $DIR/fixable.rs:79:5
    |
 LL | /     if a > b {
 LL | |         false
@@ -82,7 +82,7 @@ LL | |     };
    | |_____^ help: you can reduce it to: `a <= b`
 
 error: this if-then-else expression returns a bool literal
-  --> $DIR/fixable.rs:83:5
+  --> $DIR/fixable.rs:84:5
    |
 LL | /     if a >= b {
 LL | |         false
@@ -92,7 +92,7 @@ LL | |     };
    | |_____^ help: you can reduce it to: `a < b`
 
 error: this if-then-else expression returns a bool literal
-  --> $DIR/fixable.rs:111:5
+  --> $DIR/fixable.rs:112:5
    |
 LL | /     if x {
 LL | |         return true;
@@ -102,7 +102,7 @@ LL | |     };
    | |_____^ help: you can reduce it to: `return x`
 
 error: this if-then-else expression returns a bool literal
-  --> $DIR/fixable.rs:119:5
+  --> $DIR/fixable.rs:120:5
    |
 LL | /     if x {
 LL | |         return false;
@@ -112,7 +112,7 @@ LL | |     };
    | |_____^ help: you can reduce it to: `return !x`
 
 error: this if-then-else expression returns a bool literal
-  --> $DIR/fixable.rs:127:5
+  --> $DIR/fixable.rs:128:5
    |
 LL | /     if x && y {
 LL | |         return true;
@@ -122,7 +122,7 @@ LL | |     };
    | |_____^ help: you can reduce it to: `return x && y`
 
 error: this if-then-else expression returns a bool literal
-  --> $DIR/fixable.rs:135:5
+  --> $DIR/fixable.rs:136:5
    |
 LL | /     if x && y {
 LL | |         return false;
@@ -132,7 +132,7 @@ LL | |     };
    | |_____^ help: you can reduce it to: `return !(x && y)`
 
 error: equality checks against true are unnecessary
-  --> $DIR/fixable.rs:143:8
+  --> $DIR/fixable.rs:144:8
    |
 LL |     if x == true {};
    |        ^^^^^^^^^ help: try simplifying it as shown: `x`
@@ -141,25 +141,25 @@ LL |     if x == true {};
    = help: to override `-D warnings` add `#[allow(clippy::bool_comparison)]`
 
 error: equality checks against false can be replaced by a negation
-  --> $DIR/fixable.rs:147:8
+  --> $DIR/fixable.rs:148:8
    |
 LL |     if x == false {};
    |        ^^^^^^^^^^ help: try simplifying it as shown: `!x`
 
 error: equality checks against true are unnecessary
-  --> $DIR/fixable.rs:157:8
+  --> $DIR/fixable.rs:158:8
    |
 LL |     if x == true {};
    |        ^^^^^^^^^ help: try simplifying it as shown: `x`
 
 error: equality checks against false can be replaced by a negation
-  --> $DIR/fixable.rs:158:8
+  --> $DIR/fixable.rs:159:8
    |
 LL |     if x == false {};
    |        ^^^^^^^^^^ help: try simplifying it as shown: `!x`
 
 error: this if-then-else expression returns a bool literal
-  --> $DIR/fixable.rs:167:12
+  --> $DIR/fixable.rs:168:12
    |
 LL |       } else if returns_bool() {
    |  ____________^
@@ -170,7 +170,7 @@ LL | |     };
    | |_____^ help: you can reduce it to: `{ !returns_bool() }`
 
 error: this if-then-else expression returns a bool literal
-  --> $DIR/fixable.rs:180:5
+  --> $DIR/fixable.rs:181:5
    |
 LL | /     if unsafe { no(4) } & 1 != 0 {
 LL | |         true
@@ -180,13 +180,13 @@ LL | |     };
    | |_____^ help: you can reduce it to: `(unsafe { no(4) } & 1 != 0)`
 
 error: this if-then-else expression returns a bool literal
-  --> $DIR/fixable.rs:185:30
+  --> $DIR/fixable.rs:186:30
    |
 LL |     let _brackets_unneeded = if unsafe { no(4) } & 1 != 0 { true } else { false };
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: you can reduce it to: `unsafe { no(4) } & 1 != 0`
 
 error: this if-then-else expression returns a bool literal
-  --> $DIR/fixable.rs:188:9
+  --> $DIR/fixable.rs:189:9
    |
 LL |         if unsafe { no(4) } & 1 != 0 { true } else { false }
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: you can reduce it to: `(unsafe { no(4) } & 1 != 0)`
diff --git a/tests/ui/rest_pat_in_fully_bound_structs.rs b/tests/ui/rest_pat_in_fully_bound_structs.rs
index e25609f7560..51fe346d092 100644
--- a/tests/ui/rest_pat_in_fully_bound_structs.rs
+++ b/tests/ui/rest_pat_in_fully_bound_structs.rs
@@ -1,4 +1,5 @@
 #![warn(clippy::rest_pat_in_fully_bound_structs)]
+#![allow(clippy::struct_field_names)]
 
 struct A {
     a: i32,
diff --git a/tests/ui/rest_pat_in_fully_bound_structs.stderr b/tests/ui/rest_pat_in_fully_bound_structs.stderr
index 2c221b4dbb2..a62f1d0b65f 100644
--- a/tests/ui/rest_pat_in_fully_bound_structs.stderr
+++ b/tests/ui/rest_pat_in_fully_bound_structs.stderr
@@ -1,5 +1,5 @@
 error: unnecessary use of `..` pattern in struct binding. All fields were already bound
-  --> $DIR/rest_pat_in_fully_bound_structs.rs:22:9
+  --> $DIR/rest_pat_in_fully_bound_structs.rs:23:9
    |
 LL |         A { a: 5, b: 42, c: "", .. } => {}, // Lint
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -9,7 +9,7 @@ LL |         A { a: 5, b: 42, c: "", .. } => {}, // Lint
    = help: to override `-D warnings` add `#[allow(clippy::rest_pat_in_fully_bound_structs)]`
 
 error: unnecessary use of `..` pattern in struct binding. All fields were already bound
-  --> $DIR/rest_pat_in_fully_bound_structs.rs:24:9
+  --> $DIR/rest_pat_in_fully_bound_structs.rs:25:9
    |
 LL |         A { a: 0, b: 0, c: "", .. } => {}, // Lint
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -17,7 +17,7 @@ LL |         A { a: 0, b: 0, c: "", .. } => {}, // Lint
    = help: consider removing `..` from this binding
 
 error: unnecessary use of `..` pattern in struct binding. All fields were already bound
-  --> $DIR/rest_pat_in_fully_bound_structs.rs:31:9
+  --> $DIR/rest_pat_in_fully_bound_structs.rs:32:9
    |
 LL |         A { a: 0, b: 0, c: "", .. } => {}, // Lint
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/struct_fields.rs b/tests/ui/struct_fields.rs
new file mode 100644
index 00000000000..8b1a1446e3c
--- /dev/null
+++ b/tests/ui/struct_fields.rs
@@ -0,0 +1,331 @@
+//@aux-build:proc_macros.rs
+
+#![warn(clippy::struct_field_names)]
+#![allow(unused)]
+
+#[macro_use]
+extern crate proc_macros;
+
+struct Data1 {
+    field_data1: u8,
+    //~^ ERROR: field name ends with the struct's name
+    another: u8,
+    foo: u8,
+    bar: u8,
+}
+
+struct Data2 {
+    another: u8,
+    foo: u8,
+    data2_field: u8,
+    //~^ ERROR: field name starts with the struct's name
+    bar: u8,
+}
+
+struct StructData {
+    //~^ ERROR: all fields have the same postfix: `data`
+    movable_data: u8,
+    fixed_data: u8,
+    invisible_data: u8,
+}
+
+struct DataStruct {
+    //~^ ERROR: all fields have the same prefix: `data`
+    data_movable: u8,
+    data_fixed: u8,
+    data_invisible: u8,
+}
+
+struct DoublePrefix {
+    //~^ ERROR: all fields have the same prefix: `some_data`
+    some_data_a: bool,
+    some_data_b: bool,
+    some_data_c: bool,
+}
+
+struct DoublePostfix {
+    //~^ ERROR: all fields have the same postfix: `some_data`
+    a_some_data: bool,
+    b_some_data: bool,
+    c_some_data: bool,
+}
+
+#[allow(non_snake_case)]
+struct NotSnakeCase {
+    //~^ ERROR: all fields have the same postfix: `someData`
+    a_someData: bool,
+    b_someData: bool,
+    c_someData: bool,
+}
+#[allow(non_snake_case)]
+struct NotSnakeCase2 {
+    //~^ ERROR: all fields have the same prefix: `someData`
+    someData_c: bool,
+    someData_b: bool,
+    someData_a_b: bool,
+}
+
+// no error, threshold is 3 fiels by default
+struct Fooo {
+    foo: u8,
+    bar: u8,
+}
+
+struct NonCaps {
+    //~^ ERROR: all fields have the same prefix: `prefix`
+    prefix_的: u8,
+    prefix_tea: u8,
+    prefix_cake: u8,
+}
+
+// should not lint
+#[allow(clippy::struct_field_names)]
+pub mod allowed {
+    pub struct PubAllowed {
+        some_this: u8,
+        some_that: u8,
+        some_other_what: u8,
+    }
+}
+
+// should not lint
+struct SomeData {
+    foo: u8,
+    bar: bool,
+    path: u8,
+    answer: u8,
+}
+
+// should not lint
+pub struct NetworkLayer {
+    layer1: Vec<u8>,
+    layer2: Vec<u8>,
+    layer3: Vec<u8>,
+    layer4: Vec<u8>,
+}
+
+//should not lint
+struct North {
+    normal: u8,
+    no_left: u8,
+    no_right: u8,
+}
+
+mod issue8324_from_enum_variant_names {
+    // 8324: enum_variant_names warns even if removing the suffix would leave an empty string
+    struct Phase {
+        pre_lookup: u8,
+        lookup: u8,
+        post_lookup: u8,
+    }
+}
+
+mod issue9018_from_enum_variant_names {
+    struct DoLint {
+        //~^ ERROR: all fields have the same prefix: `_type`
+        _type_create: u8,
+        _type_read: u8,
+        _type_update: u8,
+        _type_destroy: u8,
+    }
+
+    struct DoLint2 {
+        //~^ ERROR: all fields have the same prefix: `__type`
+        __type_create: u8,
+        __type_read: u8,
+        __type_update: u8,
+        __type_destroy: u8,
+    }
+
+    struct DoLint3 {
+        //~^ ERROR: all fields have the same prefix: `___type`
+        ___type_create: u8,
+        ___type_read: u8,
+        ___type_update: u8,
+        ___type_destroy: u8,
+    }
+
+    struct DoLint4 {
+        //~^ ERROR: all fields have the same postfix: `_`
+        create_: u8,
+        read_: u8,
+        update_: u8,
+        destroy_: u8,
+    }
+
+    struct DoLint5 {
+        //~^ ERROR: all fields have the same postfix: `__`
+        create__: u8,
+        read__: u8,
+        update__: u8,
+        destroy__: u8,
+    }
+
+    struct DoLint6 {
+        //~^ ERROR: all fields have the same postfix: `___`
+        create___: u8,
+        read___: u8,
+        update___: u8,
+        destroy___: u8,
+    }
+
+    struct DoLintToo {
+        //~^ ERROR: all fields have the same postfix: `type`
+        _create_type: u8,
+        _update_type: u8,
+        _delete_type: u8,
+    }
+
+    struct DoNotLint {
+        _foo: u8,
+        _bar: u8,
+        _baz: u8,
+    }
+
+    struct DoNotLint2 {
+        __foo: u8,
+        __bar: u8,
+        __baz: u8,
+    }
+}
+
+mod allow_attributes_on_fields {
+    struct Struct {
+        #[allow(clippy::struct_field_names)]
+        struct_starts_with: u8,
+        #[allow(clippy::struct_field_names)]
+        ends_with_struct: u8,
+        foo: u8,
+    }
+}
+
+// food field should not lint
+struct Foo {
+    food: i32,
+    a: i32,
+    b: i32,
+}
+
+struct Proxy {
+    proxy: i32,
+    //~^ ERROR: field name starts with the struct's name
+    unrelated1: bool,
+    unrelated2: bool,
+}
+
+// should not lint
+pub struct RegexT {
+    __buffer: i32,
+    __allocated: i32,
+    __used: i32,
+}
+
+mod macro_tests {
+    macro_rules! mk_struct {
+        () => {
+            struct MacroStruct {
+                some_a: i32,
+                some_b: i32,
+                some_c: i32,
+            }
+        };
+    }
+    mk_struct!();
+    //~^ ERROR: all fields have the same prefix: `some`
+
+    macro_rules! mk_struct2 {
+        () => {
+            struct Macrobaz {
+                macrobaz_a: i32,
+                some_b: i32,
+                some_c: i32,
+            }
+        };
+    }
+    mk_struct2!();
+    //~^ ERROR: field name starts with the struct's name
+
+    macro_rules! mk_struct_with_names {
+        ($struct_name:ident, $field:ident) => {
+            struct $struct_name {
+                $field: i32,
+                other_something: i32,
+                other_field: i32,
+            }
+        };
+    }
+    // expands to `struct Foo { foo: i32, ... }`
+    mk_struct_with_names!(Foo, foo);
+    //~^ ERROR: field name starts with the struct's name
+
+    // expands to a struct with all fields starting with `other` but should not
+    // be linted because some fields come from the macro definition and the other from the input
+    mk_struct_with_names!(Some, other_data);
+
+    // should not lint when names come from different places
+    macro_rules! mk_struct_with_field_name {
+        ($field_name:ident) => {
+            struct Baz {
+                one: i32,
+                two: i32,
+                $field_name: i32,
+            }
+        };
+    }
+    mk_struct_with_field_name!(baz_three);
+
+    // should not lint when names come from different places
+    macro_rules! mk_struct_with_field_name {
+        ($field_name:ident) => {
+            struct Bazilisk {
+                baz_one: i32,
+                baz_two: i32,
+                $field_name: i32,
+            }
+        };
+    }
+    mk_struct_with_field_name!(baz_three);
+
+    macro_rules! mk_struct_full_def {
+        ($struct_name:ident, $field1:ident, $field2:ident, $field3:ident) => {
+            struct $struct_name {
+                $field1: i32,
+                $field2: i32,
+                $field3: i32,
+            }
+        };
+    }
+    mk_struct_full_def!(PrefixData, some_data, some_meta, some_other);
+    //~^ ERROR: all fields have the same prefix: `some`
+}
+
+// should not lint on external code
+external! {
+    struct DataExternal {
+        field_data1: u8,
+        another: u8,
+        foo: u8,
+        bar: u8,
+    }
+
+    struct NotSnakeCaseExternal {
+        someData_c: bool,
+        someData_b: bool,
+        someData_a_b: bool,
+    }
+
+    struct DoublePrefixExternal {
+        some_data_a: bool,
+        some_data_b: bool,
+        some_data_c: bool,
+    }
+
+    struct StructDataExternal {
+        movable_data: u8,
+        fixed_data: u8,
+        invisible_data: u8,
+    }
+
+}
+
+fn main() {}
diff --git a/tests/ui/struct_fields.stderr b/tests/ui/struct_fields.stderr
new file mode 100644
index 00000000000..4ca57715b18
--- /dev/null
+++ b/tests/ui/struct_fields.stderr
@@ -0,0 +1,265 @@
+error: field name ends with the struct's name
+  --> $DIR/struct_fields.rs:10:5
+   |
+LL |     field_data1: u8,
+   |     ^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::struct-field-names` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::struct_field_names)]`
+
+error: field name starts with the struct's name
+  --> $DIR/struct_fields.rs:20:5
+   |
+LL |     data2_field: u8,
+   |     ^^^^^^^^^^^^^^^
+
+error: all fields have the same postfix: `data`
+  --> $DIR/struct_fields.rs:25:1
+   |
+LL | / struct StructData {
+LL | |
+LL | |     movable_data: u8,
+LL | |     fixed_data: u8,
+LL | |     invisible_data: u8,
+LL | | }
+   | |_^
+   |
+   = help: remove the postfixes
+
+error: all fields have the same prefix: `data`
+  --> $DIR/struct_fields.rs:32:1
+   |
+LL | / struct DataStruct {
+LL | |
+LL | |     data_movable: u8,
+LL | |     data_fixed: u8,
+LL | |     data_invisible: u8,
+LL | | }
+   | |_^
+   |
+   = help: remove the prefixes
+
+error: all fields have the same prefix: `some_data`
+  --> $DIR/struct_fields.rs:39:1
+   |
+LL | / struct DoublePrefix {
+LL | |
+LL | |     some_data_a: bool,
+LL | |     some_data_b: bool,
+LL | |     some_data_c: bool,
+LL | | }
+   | |_^
+   |
+   = help: remove the prefixes
+
+error: all fields have the same postfix: `some_data`
+  --> $DIR/struct_fields.rs:46:1
+   |
+LL | / struct DoublePostfix {
+LL | |
+LL | |     a_some_data: bool,
+LL | |     b_some_data: bool,
+LL | |     c_some_data: bool,
+LL | | }
+   | |_^
+   |
+   = help: remove the postfixes
+
+error: all fields have the same postfix: `someData`
+  --> $DIR/struct_fields.rs:54:1
+   |
+LL | / struct NotSnakeCase {
+LL | |
+LL | |     a_someData: bool,
+LL | |     b_someData: bool,
+LL | |     c_someData: bool,
+LL | | }
+   | |_^
+   |
+   = help: remove the postfixes
+
+error: all fields have the same prefix: `someData`
+  --> $DIR/struct_fields.rs:61:1
+   |
+LL | / struct NotSnakeCase2 {
+LL | |
+LL | |     someData_c: bool,
+LL | |     someData_b: bool,
+LL | |     someData_a_b: bool,
+LL | | }
+   | |_^
+   |
+   = help: remove the prefixes
+
+error: all fields have the same prefix: `prefix`
+  --> $DIR/struct_fields.rs:74:1
+   |
+LL | / struct NonCaps {
+LL | |
+LL | |     prefix_的: u8,
+LL | |     prefix_tea: u8,
+LL | |     prefix_cake: u8,
+LL | | }
+   | |_^
+   |
+   = help: remove the prefixes
+
+error: all fields have the same prefix: `_type`
+  --> $DIR/struct_fields.rs:124:5
+   |
+LL | /     struct DoLint {
+LL | |
+LL | |         _type_create: u8,
+LL | |         _type_read: u8,
+LL | |         _type_update: u8,
+LL | |         _type_destroy: u8,
+LL | |     }
+   | |_____^
+   |
+   = help: remove the prefixes
+
+error: all fields have the same prefix: `__type`
+  --> $DIR/struct_fields.rs:132:5
+   |
+LL | /     struct DoLint2 {
+LL | |
+LL | |         __type_create: u8,
+LL | |         __type_read: u8,
+LL | |         __type_update: u8,
+LL | |         __type_destroy: u8,
+LL | |     }
+   | |_____^
+   |
+   = help: remove the prefixes
+
+error: all fields have the same prefix: `___type`
+  --> $DIR/struct_fields.rs:140:5
+   |
+LL | /     struct DoLint3 {
+LL | |
+LL | |         ___type_create: u8,
+LL | |         ___type_read: u8,
+LL | |         ___type_update: u8,
+LL | |         ___type_destroy: u8,
+LL | |     }
+   | |_____^
+   |
+   = help: remove the prefixes
+
+error: all fields have the same postfix: `_`
+  --> $DIR/struct_fields.rs:148:5
+   |
+LL | /     struct DoLint4 {
+LL | |
+LL | |         create_: u8,
+LL | |         read_: u8,
+LL | |         update_: u8,
+LL | |         destroy_: u8,
+LL | |     }
+   | |_____^
+   |
+   = help: remove the postfixes
+
+error: all fields have the same postfix: `__`
+  --> $DIR/struct_fields.rs:156:5
+   |
+LL | /     struct DoLint5 {
+LL | |
+LL | |         create__: u8,
+LL | |         read__: u8,
+LL | |         update__: u8,
+LL | |         destroy__: u8,
+LL | |     }
+   | |_____^
+   |
+   = help: remove the postfixes
+
+error: all fields have the same postfix: `___`
+  --> $DIR/struct_fields.rs:164:5
+   |
+LL | /     struct DoLint6 {
+LL | |
+LL | |         create___: u8,
+LL | |         read___: u8,
+LL | |         update___: u8,
+LL | |         destroy___: u8,
+LL | |     }
+   | |_____^
+   |
+   = help: remove the postfixes
+
+error: all fields have the same postfix: `type`
+  --> $DIR/struct_fields.rs:172:5
+   |
+LL | /     struct DoLintToo {
+LL | |
+LL | |         _create_type: u8,
+LL | |         _update_type: u8,
+LL | |         _delete_type: u8,
+LL | |     }
+   | |_____^
+   |
+   = help: remove the postfixes
+
+error: field name starts with the struct's name
+  --> $DIR/struct_fields.rs:210:5
+   |
+LL |     proxy: i32,
+   |     ^^^^^^^^^^
+
+error: all fields have the same prefix: `some`
+  --> $DIR/struct_fields.rs:226:13
+   |
+LL | /             struct MacroStruct {
+LL | |                 some_a: i32,
+LL | |                 some_b: i32,
+LL | |                 some_c: i32,
+LL | |             }
+   | |_____________^
+...
+LL |       mk_struct!();
+   |       ------------ in this macro invocation
+   |
+   = help: remove the prefixes
+   = note: this error originates in the macro `mk_struct` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: field name starts with the struct's name
+  --> $DIR/struct_fields.rs:239:17
+   |
+LL |                 macrobaz_a: i32,
+   |                 ^^^^^^^^^^^^^^^
+...
+LL |     mk_struct2!();
+   |     ------------- in this macro invocation
+   |
+   = note: this error originates in the macro `mk_struct2` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: field name starts with the struct's name
+  --> $DIR/struct_fields.rs:251:17
+   |
+LL |                 $field: i32,
+   |                 ^^^^^^^^^^^
+...
+LL |     mk_struct_with_names!(Foo, foo);
+   |     ------------------------------- in this macro invocation
+   |
+   = note: this error originates in the macro `mk_struct_with_names` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: all fields have the same prefix: `some`
+  --> $DIR/struct_fields.rs:291:13
+   |
+LL | /             struct $struct_name {
+LL | |                 $field1: i32,
+LL | |                 $field2: i32,
+LL | |                 $field3: i32,
+LL | |             }
+   | |_____________^
+...
+LL |       mk_struct_full_def!(PrefixData, some_data, some_meta, some_other);
+   |       ----------------------------------------------------------------- in this macro invocation
+   |
+   = help: remove the prefixes
+   = note: this error originates in the macro `mk_struct_full_def` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: aborting due to 21 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From ec2b8ab83a5260013fd491255f60b806d3fe2084 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Fri, 6 Oct 2023 11:11:57 +0200
Subject: Fix invalid warning for closure in non-async function for
 `needless_pass_by_ref_mut` lint

---
 clippy_lints/src/needless_pass_by_ref_mut.rs | 27 ++++++++++++++-------------
 1 file changed, 14 insertions(+), 13 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/needless_pass_by_ref_mut.rs b/clippy_lints/src/needless_pass_by_ref_mut.rs
index e7424ba7c6d..1d5874f6fea 100644
--- a/clippy_lints/src/needless_pass_by_ref_mut.rs
+++ b/clippy_lints/src/needless_pass_by_ref_mut.rs
@@ -197,20 +197,21 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByRefMut<'tcx> {
             };
             let infcx = cx.tcx.infer_ctxt().build();
             euv::ExprUseVisitor::new(&mut ctx, &infcx, fn_def_id, cx.param_env, cx.typeck_results()).consume_body(body);
-            if is_async {
-                let mut checked_closures = FxHashSet::default();
-
-                // We retrieve all the closures declared in the async function because they will
-                // not be found by `euv::Delegate`.
-                let mut closures: FxHashSet<LocalDefId> = FxHashSet::default();
-                for_each_expr_with_closures(cx, body, |expr| {
-                    if let ExprKind::Closure(closure) = expr.kind {
-                        closures.insert(closure.def_id);
-                    }
-                    ControlFlow::<()>::Continue(())
-                });
-                check_closures(&mut ctx, cx, &infcx, &mut checked_closures, closures);
 
+            let mut checked_closures = FxHashSet::default();
+
+            // We retrieve all the closures declared in the function because they will not be found
+            // by `euv::Delegate`.
+            let mut closures: FxHashSet<LocalDefId> = FxHashSet::default();
+            for_each_expr_with_closures(cx, body, |expr| {
+                if let ExprKind::Closure(closure) = expr.kind {
+                    closures.insert(closure.def_id);
+                }
+                ControlFlow::<()>::Continue(())
+            });
+            check_closures(&mut ctx, cx, &infcx, &mut checked_closures, closures);
+
+            if is_async {
                 while !ctx.async_closures.is_empty() {
                     let async_closures = ctx.async_closures.clone();
                     ctx.async_closures.clear();
-- 
cgit 1.4.1-3-g733a5


From 1528c1db471fa6a056177bea5ad0594e85d8d4e1 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Wed, 18 Oct 2023 18:08:41 +0000
Subject: Deserialize Msrv directly in Conf

---
 book/src/lint_configuration.md                     |   2 +-
 clippy_lints/src/lib.rs                            |  65 +-----------
 clippy_lints/src/matches/mod.rs                    |   3 +-
 clippy_lints/src/use_self.rs                       |   3 +-
 clippy_lints/src/utils/conf.rs                     | 111 ++++++++++++---------
 clippy_utils/Cargo.toml                            |   1 +
 clippy_utils/src/msrvs.rs                          |  90 +++++++----------
 src/driver.rs                                      |   6 +-
 .../invalid_min_rust_version.rs                    |   2 +-
 .../invalid_min_rust_version.stderr                |   6 +-
 10 files changed, 119 insertions(+), 170 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/book/src/lint_configuration.md b/book/src/lint_configuration.md
index 2c958ccbbc2..3d654f21de4 100644
--- a/book/src/lint_configuration.md
+++ b/book/src/lint_configuration.md
@@ -100,7 +100,7 @@ Suppress lints whenever the suggested change would cause breakage for other crat
 ## `msrv`
 The minimum rust version that the project supports
 
-**Default Value:** `None` (`Option<String>`)
+**Default Value:** `Msrv { stack: [] }` (`crate::Msrv`)
 
 ---
 **Affected lints:**
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 2d02ce8b4f0..c3be203329b 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -50,9 +50,6 @@ extern crate clippy_utils;
 #[macro_use]
 extern crate declare_clippy_lint;
 
-use std::io;
-use std::path::PathBuf;
-
 use clippy_utils::msrvs::Msrv;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_lint::{Lint, LintId};
@@ -362,7 +359,6 @@ mod zero_sized_map_values;
 // end lints modules, do not remove this comment, it’s used in `update_lints`
 
 use crate::utils::conf::metadata::get_configuration_metadata;
-use crate::utils::conf::TryConf;
 pub use crate::utils::conf::{lookup_conf_file, Conf};
 use crate::utils::FindAll;
 
@@ -374,65 +370,13 @@ use crate::utils::FindAll;
 /// level (i.e `#![cfg_attr(...)]`) will still be expanded even when using a pre-expansion pass.
 ///
 /// Used in `./src/driver.rs`.
-pub fn register_pre_expansion_lints(store: &mut rustc_lint::LintStore, sess: &Session, conf: &Conf) {
+pub fn register_pre_expansion_lints(store: &mut rustc_lint::LintStore, conf: &'static Conf) {
     // NOTE: Do not add any more pre-expansion passes. These should be removed eventually.
-    let msrv = Msrv::read(&conf.msrv, sess);
-    let msrv = move || msrv.clone();
+    let msrv = || conf.msrv.clone();
 
     store.register_pre_expansion_pass(move || Box::new(attrs::EarlyAttributes { msrv: msrv() }));
 }
 
-#[doc(hidden)]
-pub fn read_conf(sess: &Session, path: &io::Result<(Option<PathBuf>, Vec<String>)>) -> Conf {
-    if let Ok((_, warnings)) = path {
-        for warning in warnings {
-            sess.warn(warning.clone());
-        }
-    }
-    let file_name = match path {
-        Ok((Some(path), _)) => path,
-        Ok((None, _)) => return Conf::default(),
-        Err(error) => {
-            sess.err(format!("error finding Clippy's configuration file: {error}"));
-            return Conf::default();
-        },
-    };
-
-    let TryConf { conf, errors, warnings } = utils::conf::read(sess, file_name);
-    // all conf errors are non-fatal, we just use the default conf in case of error
-    for error in errors {
-        if let Some(span) = error.span {
-            sess.span_err(
-                span,
-                format!("error reading Clippy's configuration file: {}", error.message),
-            );
-        } else {
-            sess.err(format!(
-                "error reading Clippy's configuration file `{}`: {}",
-                file_name.display(),
-                error.message
-            ));
-        }
-    }
-
-    for warning in warnings {
-        if let Some(span) = warning.span {
-            sess.span_warn(
-                span,
-                format!("error reading Clippy's configuration file: {}", warning.message),
-            );
-        } else {
-            sess.warn(format!(
-                "error reading Clippy's configuration file `{}`: {}",
-                file_name.display(),
-                warning.message
-            ));
-        }
-    }
-
-    conf
-}
-
 #[derive(Default)]
 struct RegistrationGroups {
     all: Vec<LintId>,
@@ -558,7 +502,7 @@ fn register_categories(store: &mut rustc_lint::LintStore) {
 ///
 /// Used in `./src/driver.rs`.
 #[expect(clippy::too_many_lines)]
-pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf: &Conf) {
+pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf: &'static Conf) {
     register_removed_non_tool_lints(store);
     register_categories(store);
 
@@ -660,8 +604,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(non_octal_unix_permissions::NonOctalUnixPermissions));
     store.register_early_pass(|| Box::new(unnecessary_self_imports::UnnecessarySelfImports));
 
-    let msrv = Msrv::read(&conf.msrv, sess);
-    let msrv = move || msrv.clone();
+    let msrv = || conf.msrv.clone();
     let avoid_breaking_exported_api = conf.avoid_breaking_exported_api;
     let allow_expect_in_tests = conf.allow_expect_in_tests;
     let allow_unwrap_in_tests = conf.allow_unwrap_in_tests;
diff --git a/clippy_lints/src/matches/mod.rs b/clippy_lints/src/matches/mod.rs
index a23000e5fe1..b5ab94b3a2f 100644
--- a/clippy_lints/src/matches/mod.rs
+++ b/clippy_lints/src/matches/mod.rs
@@ -967,7 +967,6 @@ declare_clippy_lint! {
     "checks for unnecessary guards in match expressions"
 }
 
-#[derive(Default)]
 pub struct Matches {
     msrv: Msrv,
     infallible_destructuring_match_linted: bool,
@@ -978,7 +977,7 @@ impl Matches {
     pub fn new(msrv: Msrv) -> Self {
         Self {
             msrv,
-            ..Matches::default()
+            infallible_destructuring_match_linted: false,
         }
     }
 }
diff --git a/clippy_lints/src/use_self.rs b/clippy_lints/src/use_self.rs
index 50231d930d0..f10ed4b3d41 100644
--- a/clippy_lints/src/use_self.rs
+++ b/clippy_lints/src/use_self.rs
@@ -54,7 +54,6 @@ declare_clippy_lint! {
     "unnecessary structure name repetition whereas `Self` is applicable"
 }
 
-#[derive(Default)]
 pub struct UseSelf {
     msrv: Msrv,
     stack: Vec<StackItem>,
@@ -65,7 +64,7 @@ impl UseSelf {
     pub fn new(msrv: Msrv) -> Self {
         Self {
             msrv,
-            ..Self::default()
+            stack: Vec::new(),
         }
     }
 }
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 23da1de7730..0075f611eb7 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -8,8 +8,9 @@ use serde::de::{Deserializer, IgnoredAny, IntoDeserializer, MapAccess, Visitor};
 use serde::Deserialize;
 use std::fmt::{Debug, Display, Formatter};
 use std::ops::Range;
-use std::path::{Path, PathBuf};
+use std::path::PathBuf;
 use std::str::FromStr;
+use std::sync::OnceLock;
 use std::{cmp, env, fmt, fs, io};
 
 #[rustfmt::skip]
@@ -78,62 +79,35 @@ pub struct TryConf {
 
 impl TryConf {
     fn from_toml_error(file: &SourceFile, error: &toml::de::Error) -> Self {
-        ConfError::from_toml(file, error).into()
-    }
-}
-
-impl From<ConfError> for TryConf {
-    fn from(value: ConfError) -> Self {
         Self {
             conf: Conf::default(),
-            errors: vec![value],
+            errors: vec![ConfError::from_toml(file, error)],
             warnings: vec![],
         }
     }
 }
 
-impl From<io::Error> for TryConf {
-    fn from(value: io::Error) -> Self {
-        ConfError::from(value).into()
-    }
-}
-
 #[derive(Debug)]
 pub struct ConfError {
     pub message: String,
-    pub span: Option<Span>,
+    pub span: Span,
 }
 
 impl ConfError {
     fn from_toml(file: &SourceFile, error: &toml::de::Error) -> Self {
-        if let Some(span) = error.span() {
-            Self::spanned(file, error.message(), span)
-        } else {
-            Self {
-                message: error.message().to_string(),
-                span: None,
-            }
-        }
+        let span = error.span().unwrap_or(0..file.source_len.0 as usize);
+        Self::spanned(file, error.message(), span)
     }
 
     fn spanned(file: &SourceFile, message: impl Into<String>, span: Range<usize>) -> Self {
         Self {
             message: message.into(),
-            span: Some(Span::new(
+            span: Span::new(
                 file.start_pos + BytePos::from_usize(span.start),
                 file.start_pos + BytePos::from_usize(span.end),
                 SyntaxContext::root(),
                 None,
-            )),
-        }
-    }
-}
-
-impl From<io::Error> for ConfError {
-    fn from(value: io::Error) -> Self {
-        Self {
-            message: value.to_string(),
-            span: None,
+            ),
         }
     }
 }
@@ -297,7 +271,7 @@ define_Conf! {
     /// Lint: MANUAL_SPLIT_ONCE, MANUAL_STR_REPEAT, CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, OPTION_MAP_UNWRAP_OR, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR, IF_THEN_SOME_ELSE_NONE, APPROX_CONSTANT, DEPRECATED_CFG_ATTR, INDEX_REFUTABLE_SLICE, MAP_CLONE, BORROW_AS_PTR, MANUAL_BITS, ERR_EXPECT, CAST_ABS_TO_UNSIGNED, UNINLINED_FORMAT_ARGS, MANUAL_CLAMP, MANUAL_LET_ELSE, UNCHECKED_DURATION_SUBTRACTION, COLLAPSIBLE_STR_REPLACE, SEEK_FROM_CURRENT, SEEK_REWIND, UNNECESSARY_LAZY_EVALUATIONS, TRANSMUTE_PTR_TO_REF, ALMOST_COMPLETE_RANGE, NEEDLESS_BORROW, DERIVABLE_IMPLS, MANUAL_IS_ASCII_CHECK, MANUAL_REM_EUCLID, MANUAL_RETAIN, TYPE_REPETITION_IN_BOUNDS, TUPLE_ARRAY_CONVERSIONS, MANUAL_TRY_FOLD, MANUAL_HASH_ONE.
     ///
     /// The minimum rust version that the project supports
-    (msrv: Option<String> = None),
+    (msrv: crate::Msrv = crate::Msrv::empty()),
     /// DEPRECATED LINT: BLACKLISTED_NAME.
     ///
     /// Use the Disallowed Names lint instead
@@ -641,15 +615,8 @@ pub fn lookup_conf_file() -> io::Result<(Option<PathBuf>, Vec<String>)> {
     }
 }
 
-/// Read the `toml` configuration file.
-///
-/// In case of error, the function tries to continue as much as possible.
-pub fn read(sess: &Session, path: &Path) -> TryConf {
-    let file = match sess.source_map().load_file(path) {
-        Err(e) => return e.into(),
-        Ok(file) => file,
-    };
-    match toml::de::Deserializer::new(file.src.as_ref().unwrap()).deserialize_map(ConfVisitor(&file)) {
+fn deserialize(file: &SourceFile) -> TryConf {
+    match toml::de::Deserializer::new(file.src.as_ref().unwrap()).deserialize_map(ConfVisitor(file)) {
         Ok(mut conf) => {
             extend_vec_if_indicator_present(&mut conf.conf.doc_valid_idents, DEFAULT_DOC_VALID_IDENTS);
             extend_vec_if_indicator_present(&mut conf.conf.disallowed_names, DEFAULT_DISALLOWED_NAMES);
@@ -662,7 +629,7 @@ pub fn read(sess: &Session, path: &Path) -> TryConf {
 
             conf
         },
-        Err(e) => TryConf::from_toml_error(&file, &e),
+        Err(e) => TryConf::from_toml_error(file, &e),
     }
 }
 
@@ -672,6 +639,60 @@ fn extend_vec_if_indicator_present(vec: &mut Vec<String>, default: &[&str]) {
     }
 }
 
+impl Conf {
+    pub fn read(sess: &Session, path: &io::Result<(Option<PathBuf>, Vec<String>)>) -> &'static Conf {
+        static CONF: OnceLock<Conf> = OnceLock::new();
+        CONF.get_or_init(|| Conf::read_inner(sess, path))
+    }
+
+    fn read_inner(sess: &Session, path: &io::Result<(Option<PathBuf>, Vec<String>)>) -> Conf {
+        match path {
+            Ok((_, warnings)) => {
+                for warning in warnings {
+                    sess.warn(warning.clone());
+                }
+            },
+            Err(error) => {
+                sess.err(format!("error finding Clippy's configuration file: {error}"));
+            },
+        }
+
+        let TryConf {
+            mut conf,
+            errors,
+            warnings,
+        } = match path {
+            Ok((Some(path), _)) => match sess.source_map().load_file(path) {
+                Ok(file) => deserialize(&file),
+                Err(error) => {
+                    sess.err(format!("failed to read `{}`: {error}", path.display()));
+                    TryConf::default()
+                },
+            },
+            _ => TryConf::default(),
+        };
+
+        conf.msrv.read_cargo(sess);
+
+        // all conf errors are non-fatal, we just use the default conf in case of error
+        for error in errors {
+            sess.span_err(
+                error.span,
+                format!("error reading Clippy's configuration file: {}", error.message),
+            );
+        }
+
+        for warning in warnings {
+            sess.span_warn(
+                warning.span,
+                format!("error reading Clippy's configuration file: {}", warning.message),
+            );
+        }
+
+        conf
+    }
+}
+
 const SEPARATOR_WIDTH: usize = 4;
 
 #[derive(Debug)]
diff --git a/clippy_utils/Cargo.toml b/clippy_utils/Cargo.toml
index 8522493f67b..90091ca927a 100644
--- a/clippy_utils/Cargo.toml
+++ b/clippy_utils/Cargo.toml
@@ -9,6 +9,7 @@ arrayvec = { version = "0.7", default-features = false }
 if_chain = "1.0"
 itertools = "0.10.1"
 rustc-semver = "1.1"
+serde = { version = "1.0" }
 
 [features]
 deny-warnings = []
diff --git a/clippy_utils/src/msrvs.rs b/clippy_utils/src/msrvs.rs
index df839c2106f..c6a48874e09 100644
--- a/clippy_utils/src/msrvs.rs
+++ b/clippy_utils/src/msrvs.rs
@@ -1,9 +1,7 @@
-use std::sync::OnceLock;
-
 use rustc_ast::Attribute;
 use rustc_semver::RustcVersion;
 use rustc_session::Session;
-use rustc_span::Span;
+use serde::Deserialize;
 
 use crate::attrs::get_unique_attr;
 
@@ -53,65 +51,45 @@ msrv_aliases! {
     1,15,0 { MAYBE_BOUND_IN_WHERE }
 }
 
-fn parse_msrv(msrv: &str, sess: Option<&Session>, span: Option<Span>) -> Option<RustcVersion> {
-    if let Ok(version) = RustcVersion::parse(msrv) {
-        return Some(version);
-    } else if let Some(sess) = sess {
-        if let Some(span) = span {
-            sess.span_err(span, format!("`{msrv}` is not a valid Rust version"));
-        }
-    }
-    None
-}
-
 /// Tracks the current MSRV from `clippy.toml`, `Cargo.toml` or set via `#[clippy::msrv]`
-#[derive(Debug, Clone, Default)]
+#[derive(Debug, Clone)]
 pub struct Msrv {
     stack: Vec<RustcVersion>,
 }
 
+impl<'de> Deserialize<'de> for Msrv {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let v = String::deserialize(deserializer)?;
+        RustcVersion::parse(&v)
+            .map(|v| Msrv { stack: vec![v] })
+            .map_err(|_| serde::de::Error::custom("not a valid Rust version"))
+    }
+}
+
 impl Msrv {
-    fn new(initial: Option<RustcVersion>) -> Self {
-        Self {
-            stack: Vec::from_iter(initial),
-        }
+    pub fn empty() -> Msrv {
+        Msrv { stack: Vec::new() }
     }
 
-    fn read_inner(conf_msrv: &Option<String>, sess: &Session) -> Self {
+    pub fn read_cargo(&mut self, sess: &Session) {
         let cargo_msrv = std::env::var("CARGO_PKG_RUST_VERSION")
             .ok()
-            .and_then(|v| parse_msrv(&v, None, None));
-        let clippy_msrv = conf_msrv.as_ref().and_then(|s| {
-            parse_msrv(s, None, None).or_else(|| {
-                sess.err(format!(
-                    "error reading Clippy's configuration file. `{s}` is not a valid Rust version"
-                ));
-                None
-            })
-        });
-
-        // if both files have an msrv, let's compare them and emit a warning if they differ
-        if let Some(cargo_msrv) = cargo_msrv
-            && let Some(clippy_msrv) = clippy_msrv
-            && clippy_msrv != cargo_msrv
-        {
-            sess.warn(format!(
-                "the MSRV in `clippy.toml` and `Cargo.toml` differ; using `{clippy_msrv}` from `clippy.toml`"
-            ));
+            .and_then(|v| RustcVersion::parse(&v).ok());
+
+        match (self.current(), cargo_msrv) {
+            (None, Some(cargo_msrv)) => self.stack = vec![cargo_msrv],
+            (Some(clippy_msrv), Some(cargo_msrv)) => {
+                if clippy_msrv != cargo_msrv {
+                    sess.warn(format!(
+                        "the MSRV in `clippy.toml` and `Cargo.toml` differ; using `{clippy_msrv}` from `clippy.toml`"
+                    ));
+                }
+            },
+            _ => {},
         }
-
-        Self::new(clippy_msrv.or(cargo_msrv))
-    }
-
-    /// Set the initial MSRV from the Clippy config file or from Cargo due to the `rust-version`
-    /// field in `Cargo.toml`
-    ///
-    /// Returns a `&'static Msrv` as `Copy` types are more easily passed to the
-    /// `register_{late,early}_pass` callbacks
-    pub fn read(conf_msrv: &Option<String>, sess: &Session) -> &'static Self {
-        static PARSED: OnceLock<Msrv> = OnceLock::new();
-
-        PARSED.get_or_init(|| Self::read_inner(conf_msrv, sess))
     }
 
     pub fn current(&self) -> Option<RustcVersion> {
@@ -125,10 +103,14 @@ impl Msrv {
     fn parse_attr(sess: &Session, attrs: &[Attribute]) -> Option<RustcVersion> {
         if let Some(msrv_attr) = get_unique_attr(sess, attrs, "msrv") {
             if let Some(msrv) = msrv_attr.value_str() {
-                return parse_msrv(&msrv.to_string(), Some(sess), Some(msrv_attr.span));
-            }
+                if let Ok(version) = RustcVersion::parse(msrv.as_str()) {
+                    return Some(version);
+                }
 
-            sess.span_err(msrv_attr.span, "bad clippy attribute");
+                sess.span_err(msrv_attr.span, format!("`{msrv}` is not a valid Rust version"));
+            } else {
+                sess.span_err(msrv_attr.span, "bad clippy attribute");
+            }
         }
 
         None
diff --git a/src/driver.rs b/src/driver.rs
index d47767faed9..0e81419f1fa 100644
--- a/src/driver.rs
+++ b/src/driver.rs
@@ -147,9 +147,9 @@ impl rustc_driver::Callbacks for ClippyCallbacks {
                 (previous)(sess, lint_store);
             }
 
-            let conf = clippy_lints::read_conf(sess, &conf_path);
-            clippy_lints::register_plugins(lint_store, sess, &conf);
-            clippy_lints::register_pre_expansion_lints(lint_store, sess, &conf);
+            let conf = clippy_lints::Conf::read(sess, &conf_path);
+            clippy_lints::register_plugins(lint_store, sess, conf);
+            clippy_lints::register_pre_expansion_lints(lint_store, conf);
             clippy_lints::register_renamed(lint_store);
         }));
 
diff --git a/tests/ui-toml/invalid_min_rust_version/invalid_min_rust_version.rs b/tests/ui-toml/invalid_min_rust_version/invalid_min_rust_version.rs
index 03fa719975b..85e2fb8c797 100644
--- a/tests/ui-toml/invalid_min_rust_version/invalid_min_rust_version.rs
+++ b/tests/ui-toml/invalid_min_rust_version/invalid_min_rust_version.rs
@@ -1,4 +1,4 @@
-//@error-in-other-file: `invalid.version` is not a valid Rust version
+//@error-in-other-file: not a valid Rust version
 
 #![allow(clippy::redundant_clone)]
 
diff --git a/tests/ui-toml/invalid_min_rust_version/invalid_min_rust_version.stderr b/tests/ui-toml/invalid_min_rust_version/invalid_min_rust_version.stderr
index e9d8fd2e0f5..f127c2408f9 100644
--- a/tests/ui-toml/invalid_min_rust_version/invalid_min_rust_version.stderr
+++ b/tests/ui-toml/invalid_min_rust_version/invalid_min_rust_version.stderr
@@ -1,4 +1,8 @@
-error: error reading Clippy's configuration file. `invalid.version` is not a valid Rust version
+error: error reading Clippy's configuration file: not a valid Rust version
+  --> $DIR/$DIR/clippy.toml:1:8
+   |
+LL | msrv = "invalid.version"
+   |        ^^^^^^^^^^^^^^^^^
 
 error: aborting due to previous error
 
-- 
cgit 1.4.1-3-g733a5


From 3c501e4e4110ca107e739275c348e395dbfff8ea Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Sun, 22 Oct 2023 14:05:01 +0200
Subject: [`iter_without_into_iter`]: fix papercuts + only lint on pub types

---
 clippy_lints/src/iter_without_into_iter.rs |  12 +-
 tests/ui/into_iter_without_iter.rs         | 202 ++++++++++++-------------
 tests/ui/into_iter_without_iter.stderr     |  90 +++++------
 tests/ui/iter_without_into_iter.rs         | 230 +++++++++++++++--------------
 tests/ui/iter_without_into_iter.stderr     | 154 +++++++++----------
 5 files changed, 345 insertions(+), 343 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/iter_without_into_iter.rs b/clippy_lints/src/iter_without_into_iter.rs
index 0ee291a4e9d..1add49a2542 100644
--- a/clippy_lints/src/iter_without_into_iter.rs
+++ b/clippy_lints/src/iter_without_into_iter.rs
@@ -104,6 +104,12 @@ fn is_nameable_in_impl_trait(ty: &rustc_hir::Ty<'_>) -> bool {
     !matches!(ty.kind, TyKind::OpaqueDef(..))
 }
 
+fn is_ty_exported(cx: &LateContext<'_>, ty: Ty<'_>) -> bool {
+    ty.ty_adt_def()
+        .and_then(|adt| adt.did().as_local())
+        .is_some_and(|did| cx.effective_visibilities.is_exported(did))
+}
+
 /// Returns the deref chain of a type, starting with the type itself.
 fn deref_chain<'cx, 'tcx>(cx: &'cx LateContext<'tcx>, ty: Ty<'tcx>) -> impl Iterator<Item = Ty<'tcx>> + 'cx {
     iter::successors(Some(ty), |&ty| {
@@ -154,6 +160,7 @@ impl LateLintPass<'_> for IterWithoutIntoIter {
                     None
                 }
             })
+            && is_ty_exported(cx, ty)
         {
             span_lint_and_then(
                 cx,
@@ -226,6 +233,7 @@ impl {self_ty_without_ref} {{
             )
             // Only lint if the `IntoIterator` impl doesn't actually exist
             && !implements_trait(cx, ref_ty, into_iter_did, &[])
+            && is_ty_exported(cx, ref_ty.peel_refs())
         {
             let self_ty_snippet = format!("{borrow_prefix}{}", snippet(cx, imp.self_ty.span, ".."));
 
@@ -247,8 +255,8 @@ impl {self_ty_without_ref} {{
 "
 impl IntoIterator for {self_ty_snippet} {{
     type IntoIter = {ret_ty};
-    type Iter = {iter_ty};
-    fn into_iter() -> Self::IntoIter {{
+    type Item = {iter_ty};
+    fn into_iter(self) -> Self::IntoIter {{
         self.iter()
     }}
 }}
diff --git a/tests/ui/into_iter_without_iter.rs b/tests/ui/into_iter_without_iter.rs
index e6ff821a8ad..448d0114dff 100644
--- a/tests/ui/into_iter_without_iter.rs
+++ b/tests/ui/into_iter_without_iter.rs
@@ -3,127 +3,117 @@
 
 use std::iter::IntoIterator;
 
-fn main() {
-    {
-        struct S;
-
-        impl<'a> IntoIterator for &'a S {
-            //~^ ERROR: `IntoIterator` implemented for a reference type without an `iter` method
-            type IntoIter = std::slice::Iter<'a, u8>;
-            type Item = &'a u8;
-            fn into_iter(self) -> Self::IntoIter {
-                todo!()
-            }
-        }
-        impl<'a> IntoIterator for &'a mut S {
-            //~^ ERROR: `IntoIterator` implemented for a reference type without an `iter_mut` method
-            type IntoIter = std::slice::IterMut<'a, u8>;
-            type Item = &'a mut u8;
-            fn into_iter(self) -> Self::IntoIter {
-                todo!()
-            }
-        }
+pub struct S1;
+impl<'a> IntoIterator for &'a S1 {
+    //~^ ERROR: `IntoIterator` implemented for a reference type without an `iter` method
+    type IntoIter = std::slice::Iter<'a, u8>;
+    type Item = &'a u8;
+    fn into_iter(self) -> Self::IntoIter {
+        todo!()
     }
-    {
-        struct S<T>(T);
-        impl<'a, T> IntoIterator for &'a S<T> {
-            //~^ ERROR: `IntoIterator` implemented for a reference type without an `iter` method
-            type IntoIter = std::slice::Iter<'a, T>;
-            type Item = &'a T;
-            fn into_iter(self) -> Self::IntoIter {
-                todo!()
-            }
-        }
-        impl<'a, T> IntoIterator for &'a mut S<T> {
-            //~^ ERROR: `IntoIterator` implemented for a reference type without an `iter_mut` method
-            type IntoIter = std::slice::IterMut<'a, T>;
-            type Item = &'a mut T;
-            fn into_iter(self) -> Self::IntoIter {
-                todo!()
-            }
-        }
+}
+impl<'a> IntoIterator for &'a mut S1 {
+    //~^ ERROR: `IntoIterator` implemented for a reference type without an `iter_mut` method
+    type IntoIter = std::slice::IterMut<'a, u8>;
+    type Item = &'a mut u8;
+    fn into_iter(self) -> Self::IntoIter {
+        todo!()
     }
-    {
-        // Both iter and iter_mut methods exist, don't lint
-        struct S<'a, T>(&'a T);
-
-        impl<'a, T> S<'a, T> {
-            fn iter(&self) -> std::slice::Iter<'a, T> {
-                todo!()
-            }
-            fn iter_mut(&mut self) -> std::slice::IterMut<'a, T> {
-                todo!()
-            }
-        }
+}
 
-        impl<'a, T> IntoIterator for &S<'a, T> {
-            type IntoIter = std::slice::Iter<'a, T>;
-            type Item = &'a T;
-            fn into_iter(self) -> Self::IntoIter {
-                todo!()
-            }
-        }
+pub struct S2<T>(T);
+impl<'a, T> IntoIterator for &'a S2<T> {
+    //~^ ERROR: `IntoIterator` implemented for a reference type without an `iter` method
+    type IntoIter = std::slice::Iter<'a, T>;
+    type Item = &'a T;
+    fn into_iter(self) -> Self::IntoIter {
+        todo!()
+    }
+}
+impl<'a, T> IntoIterator for &'a mut S2<T> {
+    //~^ ERROR: `IntoIterator` implemented for a reference type without an `iter_mut` method
+    type IntoIter = std::slice::IterMut<'a, T>;
+    type Item = &'a mut T;
+    fn into_iter(self) -> Self::IntoIter {
+        todo!()
+    }
+}
 
-        impl<'a, T> IntoIterator for &mut S<'a, T> {
-            type IntoIter = std::slice::IterMut<'a, T>;
-            type Item = &'a mut T;
-            fn into_iter(self) -> Self::IntoIter {
-                todo!()
-            }
-        }
+// Both iter and iter_mut methods exist, don't lint
+pub struct S3<'a, T>(&'a T);
+impl<'a, T> S3<'a, T> {
+    fn iter(&self) -> std::slice::Iter<'a, T> {
+        todo!()
+    }
+    fn iter_mut(&mut self) -> std::slice::IterMut<'a, T> {
+        todo!()
+    }
+}
+impl<'a, T> IntoIterator for &S3<'a, T> {
+    type IntoIter = std::slice::Iter<'a, T>;
+    type Item = &'a T;
+    fn into_iter(self) -> Self::IntoIter {
+        todo!()
+    }
+}
+impl<'a, T> IntoIterator for &mut S3<'a, T> {
+    type IntoIter = std::slice::IterMut<'a, T>;
+    type Item = &'a mut T;
+    fn into_iter(self) -> Self::IntoIter {
+        todo!()
     }
-    {
-        // Only `iter` exists, no `iter_mut`
-        struct S<'a, T>(&'a T);
+}
 
-        impl<'a, T> S<'a, T> {
-            fn iter(&self) -> std::slice::Iter<'a, T> {
-                todo!()
-            }
-        }
+// Only `iter` exists, no `iter_mut`
+pub struct S4<'a, T>(&'a T);
 
-        impl<'a, T> IntoIterator for &S<'a, T> {
-            type IntoIter = std::slice::Iter<'a, T>;
-            type Item = &'a T;
-            fn into_iter(self) -> Self::IntoIter {
-                todo!()
-            }
-        }
+impl<'a, T> S4<'a, T> {
+    fn iter(&self) -> std::slice::Iter<'a, T> {
+        todo!()
+    }
+}
 
-        impl<'a, T> IntoIterator for &mut S<'a, T> {
-            //~^ ERROR: `IntoIterator` implemented for a reference type without an `iter_mut` method
-            type IntoIter = std::slice::IterMut<'a, T>;
-            type Item = &'a mut T;
-            fn into_iter(self) -> Self::IntoIter {
-                todo!()
-            }
-        }
+impl<'a, T> IntoIterator for &S4<'a, T> {
+    type IntoIter = std::slice::Iter<'a, T>;
+    type Item = &'a T;
+    fn into_iter(self) -> Self::IntoIter {
+        todo!()
     }
-    {
-        // `iter` exists, but `IntoIterator` is implemented for an alias. inherent_impls doesn't "normalize"
-        // aliases so that `inherent_impls(Alias)` where `type Alias = S` returns nothing, so this can lead
-        // to fun FPs. Make sure it doesn't happen here (we're using type_of, which should skip the alias).
-        struct S;
+}
 
-        impl S {
-            fn iter(&self) -> std::slice::Iter<'static, u8> {
-                todo!()
-            }
-        }
+impl<'a, T> IntoIterator for &mut S4<'a, T> {
+    //~^ ERROR: `IntoIterator` implemented for a reference type without an `iter_mut` method
+    type IntoIter = std::slice::IterMut<'a, T>;
+    type Item = &'a mut T;
+    fn into_iter(self) -> Self::IntoIter {
+        todo!()
+    }
+}
 
-        type Alias = S;
+// `iter` exists, but `IntoIterator` is implemented for an alias. inherent_impls doesn't "normalize"
+// aliases so that `inherent_impls(Alias)` where `type Alias = S` returns nothing, so this can lead
+// to fun FPs. Make sure it doesn't happen here (we're using type_of, which should skip the alias).
+pub struct S5;
 
-        impl IntoIterator for &Alias {
-            type IntoIter = std::slice::Iter<'static, u8>;
-            type Item = &'static u8;
-            fn into_iter(self) -> Self::IntoIter {
-                todo!()
-            }
-        }
+impl S5 {
+    fn iter(&self) -> std::slice::Iter<'static, u8> {
+        todo!()
+    }
+}
+
+pub type Alias = S5;
+
+impl IntoIterator for &Alias {
+    type IntoIter = std::slice::Iter<'static, u8>;
+    type Item = &'static u8;
+    fn into_iter(self) -> Self::IntoIter {
+        todo!()
     }
 }
 
-fn issue11635() {
+fn main() {}
+
+pub mod issue11635 {
     // A little more involved than the original repro in the issue, but this tests that it correctly
     // works for more than one deref step
 
diff --git a/tests/ui/into_iter_without_iter.stderr b/tests/ui/into_iter_without_iter.stderr
index f543d1d8e86..70f3f82a936 100644
--- a/tests/ui/into_iter_without_iter.stderr
+++ b/tests/ui/into_iter_without_iter.stderr
@@ -1,21 +1,21 @@
 error: `IntoIterator` implemented for a reference type without an `iter` method
-  --> $DIR/into_iter_without_iter.rs:10:9
+  --> $DIR/into_iter_without_iter.rs:7:1
    |
-LL | /         impl<'a> IntoIterator for &'a S {
+LL | / impl<'a> IntoIterator for &'a S1 {
 LL | |
-LL | |             type IntoIter = std::slice::Iter<'a, u8>;
-LL | |             type Item = &'a u8;
+LL | |     type IntoIter = std::slice::Iter<'a, u8>;
+LL | |     type Item = &'a u8;
 ...  |
-LL | |             }
-LL | |         }
-   | |_________^
+LL | |     }
+LL | | }
+   | |_^
    |
    = note: `-D clippy::into-iter-without-iter` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::into_iter_without_iter)]`
 help: consider implementing `iter`
    |
-LL ~         
-LL + impl S {
+LL + 
+LL + impl S1 {
 LL +     fn iter(&self) -> std::slice::Iter<'a, u8> {
 LL +         <&Self as IntoIterator>::into_iter(self)
 LL +     }
@@ -23,21 +23,21 @@ LL + }
    |
 
 error: `IntoIterator` implemented for a reference type without an `iter_mut` method
-  --> $DIR/into_iter_without_iter.rs:18:9
+  --> $DIR/into_iter_without_iter.rs:15:1
    |
-LL | /         impl<'a> IntoIterator for &'a mut S {
+LL | / impl<'a> IntoIterator for &'a mut S1 {
 LL | |
-LL | |             type IntoIter = std::slice::IterMut<'a, u8>;
-LL | |             type Item = &'a mut u8;
+LL | |     type IntoIter = std::slice::IterMut<'a, u8>;
+LL | |     type Item = &'a mut u8;
 ...  |
-LL | |             }
-LL | |         }
-   | |_________^
+LL | |     }
+LL | | }
+   | |_^
    |
 help: consider implementing `iter_mut`
    |
-LL ~         
-LL + impl S {
+LL + 
+LL + impl S1 {
 LL +     fn iter_mut(&mut self) -> std::slice::IterMut<'a, u8> {
 LL +         <&mut Self as IntoIterator>::into_iter(self)
 LL +     }
@@ -45,21 +45,21 @@ LL + }
    |
 
 error: `IntoIterator` implemented for a reference type without an `iter` method
-  --> $DIR/into_iter_without_iter.rs:29:9
+  --> $DIR/into_iter_without_iter.rs:25:1
    |
-LL | /         impl<'a, T> IntoIterator for &'a S<T> {
+LL | / impl<'a, T> IntoIterator for &'a S2<T> {
 LL | |
-LL | |             type IntoIter = std::slice::Iter<'a, T>;
-LL | |             type Item = &'a T;
+LL | |     type IntoIter = std::slice::Iter<'a, T>;
+LL | |     type Item = &'a T;
 ...  |
-LL | |             }
-LL | |         }
-   | |_________^
+LL | |     }
+LL | | }
+   | |_^
    |
 help: consider implementing `iter`
    |
-LL ~         
-LL + impl S<T> {
+LL + 
+LL + impl S2<T> {
 LL +     fn iter(&self) -> std::slice::Iter<'a, T> {
 LL +         <&Self as IntoIterator>::into_iter(self)
 LL +     }
@@ -67,21 +67,21 @@ LL + }
    |
 
 error: `IntoIterator` implemented for a reference type without an `iter_mut` method
-  --> $DIR/into_iter_without_iter.rs:37:9
+  --> $DIR/into_iter_without_iter.rs:33:1
    |
-LL | /         impl<'a, T> IntoIterator for &'a mut S<T> {
+LL | / impl<'a, T> IntoIterator for &'a mut S2<T> {
 LL | |
-LL | |             type IntoIter = std::slice::IterMut<'a, T>;
-LL | |             type Item = &'a mut T;
+LL | |     type IntoIter = std::slice::IterMut<'a, T>;
+LL | |     type Item = &'a mut T;
 ...  |
-LL | |             }
-LL | |         }
-   | |_________^
+LL | |     }
+LL | | }
+   | |_^
    |
 help: consider implementing `iter_mut`
    |
-LL ~         
-LL + impl S<T> {
+LL + 
+LL + impl S2<T> {
 LL +     fn iter_mut(&mut self) -> std::slice::IterMut<'a, T> {
 LL +         <&mut Self as IntoIterator>::into_iter(self)
 LL +     }
@@ -89,21 +89,21 @@ LL + }
    |
 
 error: `IntoIterator` implemented for a reference type without an `iter_mut` method
-  --> $DIR/into_iter_without_iter.rs:93:9
+  --> $DIR/into_iter_without_iter.rs:84:1
    |
-LL | /         impl<'a, T> IntoIterator for &mut S<'a, T> {
+LL | / impl<'a, T> IntoIterator for &mut S4<'a, T> {
 LL | |
-LL | |             type IntoIter = std::slice::IterMut<'a, T>;
-LL | |             type Item = &'a mut T;
+LL | |     type IntoIter = std::slice::IterMut<'a, T>;
+LL | |     type Item = &'a mut T;
 ...  |
-LL | |             }
-LL | |         }
-   | |_________^
+LL | |     }
+LL | | }
+   | |_^
    |
 help: consider implementing `iter_mut`
    |
-LL ~         
-LL + impl S<'a, T> {
+LL + 
+LL + impl S4<'a, T> {
 LL +     fn iter_mut(&mut self) -> std::slice::IterMut<'a, T> {
 LL +         <&mut Self as IntoIterator>::into_iter(self)
 LL +     }
diff --git a/tests/ui/iter_without_into_iter.rs b/tests/ui/iter_without_into_iter.rs
index cedb756c79d..29f526b455c 100644
--- a/tests/ui/iter_without_into_iter.rs
+++ b/tests/ui/iter_without_into_iter.rs
@@ -1,120 +1,124 @@
 //@no-rustfix
 #![warn(clippy::iter_without_into_iter)]
 
-fn main() {
-    {
-        struct S;
-        impl S {
-            pub fn iter(&self) -> std::slice::Iter<'_, u8> {
-                //~^ ERROR: `iter` method without an `IntoIterator` impl
-                [].iter()
-            }
-            pub fn iter_mut(&mut self) -> std::slice::IterMut<'_, u8> {
-                //~^ ERROR: `iter_mut` method without an `IntoIterator` impl
-                [].iter_mut()
-            }
-        }
-    }
-    {
-        struct S;
-        impl S {
-            pub fn iter(&self) -> impl Iterator<Item = &u8> {
-                // RPITIT is not stable, so we can't generally suggest it here yet
-                [].iter()
-            }
-        }
-    }
-    {
-        struct S<'a>(&'a mut [u8]);
-        impl<'a> S<'a> {
-            pub fn iter(&self) -> std::slice::Iter<'_, u8> {
-                //~^ ERROR: `iter` method without an `IntoIterator` impl
-                self.0.iter()
-            }
-            pub fn iter_mut(&mut self) -> std::slice::IterMut<'_, u8> {
-                //~^ ERROR: `iter_mut` method without an `IntoIterator` impl
-                self.0.iter_mut()
-            }
-        }
-    }
-    {
-        // Incompatible signatures
-        struct S;
-        impl S {
-            pub fn iter(self) -> std::slice::Iter<'static, u8> {
-                todo!()
-            }
-        }
-        struct S2;
-        impl S2 {
-            pub async fn iter(&self) -> std::slice::Iter<'static, u8> {
-                todo!()
-            }
-        }
-        struct S3;
-        impl S3 {
-            pub fn iter(&self, _additional_param: ()) -> std::slice::Iter<'static, u8> {
-                todo!()
-            }
-        }
-        struct S4<T>(T);
-        impl<T> S4<T> {
-            pub fn iter<U>(&self) -> std::slice::Iter<'static, (T, U)> {
-                todo!()
-            }
-        }
-        struct S5<T>(T);
-        impl<T> S5<T> {
-            pub fn iter(&self) -> std::slice::Iter<'static, T> {
-                todo!()
-            }
-        }
-    }
-    {
-        struct S<T>(T);
-        impl<T> S<T> {
-            pub fn iter(&self) -> std::slice::Iter<'_, T> {
-                //~^ ERROR: `iter` method without an `IntoIterator` impl
-                todo!()
-            }
-            pub fn iter_mut(&mut self) -> std::slice::IterMut<'_, T> {
-                //~^ ERROR: `iter_mut` method without an `IntoIterator` impl
-                todo!()
-            }
-        }
-    }
-    {
-        struct S<T>(T);
-        impl<T> S<T> {
-            pub fn iter(&self) -> std::slice::Iter<'_, T> {
-                // Don't lint, there's an existing (wrong) IntoIterator impl
-                todo!()
-            }
-        }
+pub struct S1;
+impl S1 {
+    pub fn iter(&self) -> std::slice::Iter<'_, u8> {
+        //~^ ERROR: `iter` method without an `IntoIterator` impl
+        [].iter()
+    }
+    pub fn iter_mut(&mut self) -> std::slice::IterMut<'_, u8> {
+        //~^ ERROR: `iter_mut` method without an `IntoIterator` impl
+        [].iter_mut()
+    }
+}
+
+pub struct S2;
+impl S2 {
+    pub fn iter(&self) -> impl Iterator<Item = &u8> {
+        // RPITIT is not stable, so we can't generally suggest it here yet
+        [].iter()
+    }
+}
+
+pub struct S3<'a>(&'a mut [u8]);
+impl<'a> S3<'a> {
+    pub fn iter(&self) -> std::slice::Iter<'_, u8> {
+        //~^ ERROR: `iter` method without an `IntoIterator` impl
+        self.0.iter()
+    }
+    pub fn iter_mut(&mut self) -> std::slice::IterMut<'_, u8> {
+        //~^ ERROR: `iter_mut` method without an `IntoIterator` impl
+        self.0.iter_mut()
+    }
+}
+
+// Incompatible signatures
+pub struct S4;
+impl S4 {
+    pub fn iter(self) -> std::slice::Iter<'static, u8> {
+        todo!()
+    }
+}
+
+pub struct S5;
+impl S5 {
+    pub async fn iter(&self) -> std::slice::Iter<'static, u8> {
+        todo!()
+    }
+}
+
+pub struct S6;
+impl S6 {
+    pub fn iter(&self, _additional_param: ()) -> std::slice::Iter<'static, u8> {
+        todo!()
+    }
+}
+
+pub struct S7<T>(T);
+impl<T> S7<T> {
+    pub fn iter<U>(&self) -> std::slice::Iter<'static, (T, U)> {
+        todo!()
+    }
+}
+
+pub struct S8<T>(T);
+impl<T> S8<T> {
+    pub fn iter(&self) -> std::slice::Iter<'static, T> {
+        todo!()
+    }
+}
+
+// ===========================
+pub struct S9<T>(T);
+impl<T> S9<T> {
+    pub fn iter(&self) -> std::slice::Iter<'_, T> {
+        //~^ ERROR: `iter` method without an `IntoIterator` impl
+        todo!()
+    }
+    pub fn iter_mut(&mut self) -> std::slice::IterMut<'_, T> {
+        //~^ ERROR: `iter_mut` method without an `IntoIterator` impl
+        todo!()
+    }
+}
+
+pub struct S10<T>(T);
+impl<T> S10<T> {
+    pub fn iter(&self) -> std::slice::Iter<'_, T> {
+        // Don't lint, there's an existing (wrong) IntoIterator impl
+        todo!()
+    }
+}
+
+impl<'a, T> IntoIterator for &'a S10<T> {
+    type Item = &'a String;
+    type IntoIter = std::slice::Iter<'a, String>;
+    fn into_iter(self) -> Self::IntoIter {
+        todo!()
+    }
+}
 
-        impl<'a, T> IntoIterator for &'a S<T> {
-            type Item = &'a String;
-            type IntoIter = std::slice::Iter<'a, String>;
-            fn into_iter(self) -> Self::IntoIter {
-                todo!()
-            }
-        }
-    }
-    {
-        struct S<T>(T);
-        impl<T> S<T> {
-            pub fn iter_mut(&self) -> std::slice::IterMut<'_, T> {
-                // Don't lint, there's an existing (wrong) IntoIterator impl
-                todo!()
-            }
-        }
+pub struct S11<T>(T);
+impl<T> S11<T> {
+    pub fn iter_mut(&self) -> std::slice::IterMut<'_, T> {
+        // Don't lint, there's an existing (wrong) IntoIterator impl
+        todo!()
+    }
+}
+impl<'a, T> IntoIterator for &'a mut S11<T> {
+    type Item = &'a mut String;
+    type IntoIter = std::slice::IterMut<'a, String>;
+    fn into_iter(self) -> Self::IntoIter {
+        todo!()
+    }
+}
 
-        impl<'a, T> IntoIterator for &'a mut S<T> {
-            type Item = &'a mut String;
-            type IntoIter = std::slice::IterMut<'a, String>;
-            fn into_iter(self) -> Self::IntoIter {
-                todo!()
-            }
-        }
+// Private type not exported: don't lint
+struct S12;
+impl S12 {
+    fn iter(&self) -> std::slice::Iter<'_, u8> {
+        todo!()
     }
 }
+
+fn main() {}
diff --git a/tests/ui/iter_without_into_iter.stderr b/tests/ui/iter_without_into_iter.stderr
index 9d0b99415a5..af5afd47bfc 100644
--- a/tests/ui/iter_without_into_iter.stderr
+++ b/tests/ui/iter_without_into_iter.stderr
@@ -1,146 +1,146 @@
-error: `iter` method without an `IntoIterator` impl for `&S`
-  --> $DIR/iter_without_into_iter.rs:8:13
+error: `iter` method without an `IntoIterator` impl for `&S1`
+  --> $DIR/iter_without_into_iter.rs:6:5
    |
-LL | /             pub fn iter(&self) -> std::slice::Iter<'_, u8> {
+LL | /     pub fn iter(&self) -> std::slice::Iter<'_, u8> {
 LL | |
-LL | |                 [].iter()
-LL | |             }
-   | |_____________^
+LL | |         [].iter()
+LL | |     }
+   | |_____^
    |
    = note: `-D clippy::iter-without-into-iter` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::iter_without_into_iter)]`
-help: consider implementing `IntoIterator` for `&S`
+help: consider implementing `IntoIterator` for `&S1`
    |
-LL ~         
-LL + impl IntoIterator for &S {
+LL + 
+LL + impl IntoIterator for &S1 {
 LL +     type IntoIter = std::slice::Iter<'_, u8>;
-LL +     type Iter = &u8;
-LL +     fn into_iter() -> Self::IntoIter {
+LL +     type Item = &u8;
+LL +     fn into_iter(self) -> Self::IntoIter {
 LL +         self.iter()
 LL +     }
 LL + }
    |
 
-error: `iter_mut` method without an `IntoIterator` impl for `&mut S`
-  --> $DIR/iter_without_into_iter.rs:12:13
+error: `iter_mut` method without an `IntoIterator` impl for `&mut S1`
+  --> $DIR/iter_without_into_iter.rs:10:5
    |
-LL | /             pub fn iter_mut(&mut self) -> std::slice::IterMut<'_, u8> {
+LL | /     pub fn iter_mut(&mut self) -> std::slice::IterMut<'_, u8> {
 LL | |
-LL | |                 [].iter_mut()
-LL | |             }
-   | |_____________^
+LL | |         [].iter_mut()
+LL | |     }
+   | |_____^
    |
-help: consider implementing `IntoIterator` for `&mut S`
+help: consider implementing `IntoIterator` for `&mut S1`
    |
-LL ~         
-LL + impl IntoIterator for &mut S {
+LL + 
+LL + impl IntoIterator for &mut S1 {
 LL +     type IntoIter = std::slice::IterMut<'_, u8>;
-LL +     type Iter = &mut u8;
-LL +     fn into_iter() -> Self::IntoIter {
+LL +     type Item = &mut u8;
+LL +     fn into_iter(self) -> Self::IntoIter {
 LL +         self.iter()
 LL +     }
 LL + }
    |
 
-error: `iter` method without an `IntoIterator` impl for `&S<'a>`
-  --> $DIR/iter_without_into_iter.rs:30:13
+error: `iter` method without an `IntoIterator` impl for `&S3<'a>`
+  --> $DIR/iter_without_into_iter.rs:26:5
    |
-LL | /             pub fn iter(&self) -> std::slice::Iter<'_, u8> {
+LL | /     pub fn iter(&self) -> std::slice::Iter<'_, u8> {
 LL | |
-LL | |                 self.0.iter()
-LL | |             }
-   | |_____________^
+LL | |         self.0.iter()
+LL | |     }
+   | |_____^
    |
-help: consider implementing `IntoIterator` for `&S<'a>`
+help: consider implementing `IntoIterator` for `&S3<'a>`
    |
-LL ~         
-LL + impl IntoIterator for &S<'a> {
+LL + 
+LL + impl IntoIterator for &S3<'a> {
 LL +     type IntoIter = std::slice::Iter<'_, u8>;
-LL +     type Iter = &u8;
-LL +     fn into_iter() -> Self::IntoIter {
+LL +     type Item = &u8;
+LL +     fn into_iter(self) -> Self::IntoIter {
 LL +         self.iter()
 LL +     }
 LL + }
    |
 
-error: `iter_mut` method without an `IntoIterator` impl for `&mut S<'a>`
-  --> $DIR/iter_without_into_iter.rs:34:13
+error: `iter_mut` method without an `IntoIterator` impl for `&mut S3<'a>`
+  --> $DIR/iter_without_into_iter.rs:30:5
    |
-LL | /             pub fn iter_mut(&mut self) -> std::slice::IterMut<'_, u8> {
+LL | /     pub fn iter_mut(&mut self) -> std::slice::IterMut<'_, u8> {
 LL | |
-LL | |                 self.0.iter_mut()
-LL | |             }
-   | |_____________^
+LL | |         self.0.iter_mut()
+LL | |     }
+   | |_____^
    |
-help: consider implementing `IntoIterator` for `&mut S<'a>`
+help: consider implementing `IntoIterator` for `&mut S3<'a>`
    |
-LL ~         
-LL + impl IntoIterator for &mut S<'a> {
+LL + 
+LL + impl IntoIterator for &mut S3<'a> {
 LL +     type IntoIter = std::slice::IterMut<'_, u8>;
-LL +     type Iter = &mut u8;
-LL +     fn into_iter() -> Self::IntoIter {
+LL +     type Item = &mut u8;
+LL +     fn into_iter(self) -> Self::IntoIter {
 LL +         self.iter()
 LL +     }
 LL + }
    |
 
-error: `iter` method without an `IntoIterator` impl for `&S5<T>`
-  --> $DIR/iter_without_into_iter.rs:68:13
+error: `iter` method without an `IntoIterator` impl for `&S8<T>`
+  --> $DIR/iter_without_into_iter.rs:67:5
    |
-LL | /             pub fn iter(&self) -> std::slice::Iter<'static, T> {
-LL | |                 todo!()
-LL | |             }
-   | |_____________^
+LL | /     pub fn iter(&self) -> std::slice::Iter<'static, T> {
+LL | |         todo!()
+LL | |     }
+   | |_____^
    |
-help: consider implementing `IntoIterator` for `&S5<T>`
+help: consider implementing `IntoIterator` for `&S8<T>`
    |
-LL ~         
-LL + impl IntoIterator for &S5<T> {
+LL + 
+LL + impl IntoIterator for &S8<T> {
 LL +     type IntoIter = std::slice::Iter<'static, T>;
-LL +     type Iter = &T;
-LL +     fn into_iter() -> Self::IntoIter {
+LL +     type Item = &T;
+LL +     fn into_iter(self) -> Self::IntoIter {
 LL +         self.iter()
 LL +     }
 LL + }
    |
 
-error: `iter` method without an `IntoIterator` impl for `&S<T>`
-  --> $DIR/iter_without_into_iter.rs:76:13
+error: `iter` method without an `IntoIterator` impl for `&S9<T>`
+  --> $DIR/iter_without_into_iter.rs:75:5
    |
-LL | /             pub fn iter(&self) -> std::slice::Iter<'_, T> {
+LL | /     pub fn iter(&self) -> std::slice::Iter<'_, T> {
 LL | |
-LL | |                 todo!()
-LL | |             }
-   | |_____________^
+LL | |         todo!()
+LL | |     }
+   | |_____^
    |
-help: consider implementing `IntoIterator` for `&S<T>`
+help: consider implementing `IntoIterator` for `&S9<T>`
    |
-LL ~         
-LL + impl IntoIterator for &S<T> {
+LL + 
+LL + impl IntoIterator for &S9<T> {
 LL +     type IntoIter = std::slice::Iter<'_, T>;
-LL +     type Iter = &T;
-LL +     fn into_iter() -> Self::IntoIter {
+LL +     type Item = &T;
+LL +     fn into_iter(self) -> Self::IntoIter {
 LL +         self.iter()
 LL +     }
 LL + }
    |
 
-error: `iter_mut` method without an `IntoIterator` impl for `&mut S<T>`
-  --> $DIR/iter_without_into_iter.rs:80:13
+error: `iter_mut` method without an `IntoIterator` impl for `&mut S9<T>`
+  --> $DIR/iter_without_into_iter.rs:79:5
    |
-LL | /             pub fn iter_mut(&mut self) -> std::slice::IterMut<'_, T> {
+LL | /     pub fn iter_mut(&mut self) -> std::slice::IterMut<'_, T> {
 LL | |
-LL | |                 todo!()
-LL | |             }
-   | |_____________^
+LL | |         todo!()
+LL | |     }
+   | |_____^
    |
-help: consider implementing `IntoIterator` for `&mut S<T>`
+help: consider implementing `IntoIterator` for `&mut S9<T>`
    |
-LL ~         
-LL + impl IntoIterator for &mut S<T> {
+LL + 
+LL + impl IntoIterator for &mut S9<T> {
 LL +     type IntoIter = std::slice::IterMut<'_, T>;
-LL +     type Iter = &mut T;
-LL +     fn into_iter() -> Self::IntoIter {
+LL +     type Item = &mut T;
+LL +     fn into_iter(self) -> Self::IntoIter {
 LL +         self.iter()
 LL +     }
 LL + }
-- 
cgit 1.4.1-3-g733a5


From 7347c1803fa9c151033eb30fd722ff6d6d08ee49 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Mon, 23 Oct 2023 13:49:18 +0000
Subject: Set existing doc-tests to `no_run`

---
 book/src/lint_configuration.md                     |   4 +-
 clippy_lints/src/absolute_paths.rs                 |   4 +-
 clippy_lints/src/almost_complete_range.rs          |   4 +-
 clippy_lints/src/approx_const.rs                   |   4 +-
 clippy_lints/src/arc_with_non_send_sync.rs         |   2 +-
 clippy_lints/src/async_yields_async.rs             |   4 +-
 clippy_lints/src/attrs.rs                          |  42 +--
 clippy_lints/src/await_holding_invalid.rs          |  10 +-
 clippy_lints/src/blocks_in_if_conditions.rs        |   4 +-
 clippy_lints/src/bool_assert_comparison.rs         |   4 +-
 clippy_lints/src/bool_to_int_with_if.rs            |   6 +-
 clippy_lints/src/borrow_deref_ref.rs               |   6 +-
 clippy_lints/src/box_default.rs                    |   4 +-
 clippy_lints/src/casts/mod.rs                      |  70 ++--
 clippy_lints/src/checked_conversions.rs            |   4 +-
 clippy_lints/src/collapsible_if.rs                 |   4 +-
 clippy_lints/src/collection_is_never_read.rs       |   4 +-
 clippy_lints/src/crate_in_macro_def.rs             |   4 +-
 clippy_lints/src/default.rs                        |   8 +-
 .../src/default_constructed_unit_structs.rs        |   4 +-
 clippy_lints/src/default_instead_of_iter_empty.rs  |   4 +-
 clippy_lints/src/default_numeric_fallback.rs       |   4 +-
 clippy_lints/src/default_union_representation.rs   |   4 +-
 clippy_lints/src/dereference.rs                    |  16 +-
 clippy_lints/src/derivable_impls.rs                |   4 +-
 clippy_lints/src/derive.rs                         |   4 +-
 clippy_lints/src/disallowed_macros.rs              |   2 +-
 clippy_lints/src/disallowed_names.rs               |   2 +-
 clippy_lints/src/disallowed_script_idents.rs       |   2 +-
 clippy_lints/src/doc.rs                            |  22 +-
 clippy_lints/src/double_parens.rs                  |   4 +-
 clippy_lints/src/drop_forget_ref.rs                |   6 +-
 clippy_lints/src/else_if_without_else.rs           |   4 +-
 clippy_lints/src/empty_drop.rs                     |   4 +-
 clippy_lints/src/empty_enum.rs                     |   4 +-
 clippy_lints/src/empty_structs_with_brackets.rs    |   4 +-
 clippy_lints/src/entry.rs                          |   6 +-
 clippy_lints/src/enum_clike.rs                     |   2 +-
 clippy_lints/src/escape.rs                         |   4 +-
 clippy_lints/src/excessive_bools.rs                |   4 +-
 clippy_lints/src/exhaustive_items.rs               |   8 +-
 clippy_lints/src/exit.rs                           |   2 +-
 clippy_lints/src/explicit_write.rs                 |   4 +-
 clippy_lints/src/extra_unused_type_parameters.rs   |   4 +-
 clippy_lints/src/fallible_impl_from.rs             |   4 +-
 clippy_lints/src/float_literal.rs                  |   8 +-
 clippy_lints/src/floating_point_arithmetic.rs      |   8 +-
 clippy_lints/src/format.rs                         |   4 +-
 clippy_lints/src/format_args.rs                    |  20 +-
 clippy_lints/src/format_impl.rs                    |   8 +-
 clippy_lints/src/format_push_string.rs             |   4 +-
 clippy_lints/src/formatting.rs                     |   4 +-
 clippy_lints/src/four_forward_slashes.rs           |   4 +-
 clippy_lints/src/from_over_into.rs                 |   4 +-
 clippy_lints/src/from_raw_with_void_ptr.rs         |   4 +-
 clippy_lints/src/functions/mod.rs                  |  24 +-
 clippy_lints/src/future_not_send.rs                |   4 +-
 clippy_lints/src/if_not_else.rs                    |   4 +-
 clippy_lints/src/if_then_some_else_none.rs         |   4 +-
 clippy_lints/src/ignored_unit_patterns.rs          |   4 +-
 clippy_lints/src/implicit_hasher.rs                |   4 +-
 clippy_lints/src/implicit_return.rs                |   4 +-
 clippy_lints/src/implicit_saturating_add.rs        |   4 +-
 clippy_lints/src/implicit_saturating_sub.rs        |   4 +-
 clippy_lints/src/implied_bounds_in_impls.rs        |   4 +-
 .../src/inconsistent_struct_constructor.rs         |   6 +-
 clippy_lints/src/index_refutable_slice.rs          |   4 +-
 clippy_lints/src/indexing_slicing.rs               |   4 +-
 clippy_lints/src/infinite_iter.rs                  |   2 +-
 clippy_lints/src/inherent_impl.rs                  |   4 +-
 clippy_lints/src/inherent_to_string.rs             |   8 +-
 clippy_lints/src/init_numbered_fields.rs           |   2 +-
 clippy_lints/src/inline_fn_without_body.rs         |   2 +-
 clippy_lints/src/instant_subtraction.rs            |   8 +-
 clippy_lints/src/int_plus_one.rs                   |   4 +-
 clippy_lints/src/invalid_upcast_comparisons.rs     |   2 +-
 clippy_lints/src/item_name_repetitions.rs          |  12 +-
 clippy_lints/src/items_after_statements.rs         |   4 +-
 clippy_lints/src/items_after_test_module.rs        |   4 +-
 clippy_lints/src/iter_not_returning_iterator.rs    |   4 +-
 clippy_lints/src/iter_without_into_iter.rs         |   8 +-
 clippy_lints/src/large_enum_variant.rs             |   4 +-
 clippy_lints/src/large_futures.rs                  |   4 +-
 clippy_lints/src/large_stack_frames.rs             |   4 +-
 clippy_lints/src/let_underscore.rs                 |  10 +-
 clippy_lints/src/lifetimes.rs                      |   8 +-
 clippy_lints/src/lines_filter_map_ok.rs            |   4 +-
 clippy_lints/src/literal_representation.rs         |  12 +-
 clippy_lints/src/loops/mod.rs                      |  48 +--
 clippy_lints/src/manual_assert.rs                  |   4 +-
 clippy_lints/src/manual_async_fn.rs                |   4 +-
 clippy_lints/src/manual_bits.rs                    |   4 +-
 clippy_lints/src/manual_clamp.rs                   |  22 +-
 clippy_lints/src/manual_float_methods.rs           |   8 +-
 clippy_lints/src/manual_hash_one.rs                |   4 +-
 clippy_lints/src/manual_is_ascii_check.rs          |   4 +-
 clippy_lints/src/manual_let_else.rs                |   4 +-
 clippy_lints/src/manual_main_separator_str.rs      |   4 +-
 clippy_lints/src/manual_non_exhaustive.rs          |   4 +-
 clippy_lints/src/manual_range_patterns.rs          |   4 +-
 clippy_lints/src/manual_rem_euclid.rs              |   4 +-
 clippy_lints/src/manual_retain.rs                  |   4 +-
 clippy_lints/src/manual_slice_size_calculation.rs  |   4 +-
 clippy_lints/src/manual_string_new.rs              |   4 +-
 clippy_lints/src/manual_strip.rs                   |   4 +-
 clippy_lints/src/map_unit_fn.rs                    |   8 +-
 clippy_lints/src/matches/mod.rs                    |  78 ++--
 clippy_lints/src/mem_replace.rs                    |  10 +-
 clippy_lints/src/methods/mod.rs                    | 420 ++++++++++-----------
 clippy_lints/src/methods/str_splitn.rs             |   2 +-
 clippy_lints/src/misc.rs                           |   6 +-
 clippy_lints/src/misc_early/mod.rs                 |  32 +-
 clippy_lints/src/mismatching_type_param_order.rs   |   4 +-
 clippy_lints/src/missing_assert_message.rs         |   4 +-
 clippy_lints/src/missing_asserts_for_indexing.rs   |   4 +-
 clippy_lints/src/missing_const_for_fn.rs           |   6 +-
 clippy_lints/src/missing_fields_in_debug.rs        |   4 +-
 clippy_lints/src/missing_inline.rs                 |   2 +-
 clippy_lints/src/missing_trait_methods.rs          |   4 +-
 clippy_lints/src/mixed_read_write_in_expression.rs |   4 +-
 clippy_lints/src/multi_assignments.rs              |   4 +-
 clippy_lints/src/multiple_unsafe_ops_per_block.rs  |   4 +-
 clippy_lints/src/mut_key.rs                        |   2 +-
 clippy_lints/src/mut_mut.rs                        |   2 +-
 clippy_lints/src/mut_reference.rs                  |   4 +-
 clippy_lints/src/mutex_atomic.rs                   |   8 +-
 clippy_lints/src/needless_arbitrary_self_type.rs   |   4 +-
 clippy_lints/src/needless_bool.rs                  |   4 +-
 clippy_lints/src/needless_borrowed_ref.rs          |   4 +-
 .../src/needless_borrows_for_generic_args.rs       |   4 +-
 clippy_lints/src/needless_continue.rs              |  10 +-
 clippy_lints/src/needless_else.rs                  |   4 +-
 clippy_lints/src/needless_for_each.rs              |   4 +-
 clippy_lints/src/needless_late_init.rs             |   4 +-
 .../src/needless_parens_on_range_literals.rs       |   4 +-
 clippy_lints/src/needless_pass_by_ref_mut.rs       |   4 +-
 clippy_lints/src/needless_pass_by_value.rs         |   4 +-
 clippy_lints/src/needless_question_mark.rs         |   4 +-
 clippy_lints/src/needless_update.rs                |   2 +-
 clippy_lints/src/neg_cmp_op_on_partial_ord.rs      |   4 +-
 clippy_lints/src/no_effect.rs                      |   2 +-
 clippy_lints/src/no_mangle_with_rust_abi.rs        |   4 +-
 clippy_lints/src/non_canonical_impls.rs            |   4 +-
 clippy_lints/src/non_copy_const.rs                 |   8 +-
 clippy_lints/src/non_expressive_names.rs           |   2 +-
 clippy_lints/src/nonstandard_macro_braces.rs       |   4 +-
 clippy_lints/src/octal_escapes.rs                  |   4 +-
 clippy_lints/src/only_used_in_recursion.rs         |   6 +-
 clippy_lints/src/operators/mod.rs                  |  72 ++--
 clippy_lints/src/option_if_let_else.rs             |   4 +-
 clippy_lints/src/overflow_check_conditional.rs     |   2 +-
 clippy_lints/src/panic_in_result_fn.rs             |   4 +-
 clippy_lints/src/partial_pub_fields.rs             |   4 +-
 clippy_lints/src/partialeq_ne_impl.rs              |   2 +-
 clippy_lints/src/partialeq_to_none.rs              |   4 +-
 clippy_lints/src/pass_by_ref_or_value.rs           |   8 +-
 clippy_lints/src/permissions_set_readonly_false.rs |   2 +-
 clippy_lints/src/ptr_offset_with_cast.rs           |   4 +-
 clippy_lints/src/pub_use.rs                        |   4 +-
 clippy_lints/src/ranges.rs                         |  14 +-
 clippy_lints/src/raw_strings.rs                    |   8 +-
 clippy_lints/src/rc_clone_in_vec_init.rs           |   4 +-
 clippy_lints/src/read_zero_byte_vec.rs             |   4 +-
 clippy_lints/src/redundant_async_block.rs          |   4 +-
 clippy_lints/src/redundant_clone.rs                |   2 +-
 clippy_lints/src/redundant_closure_call.rs         |   4 +-
 clippy_lints/src/redundant_else.rs                 |   4 +-
 clippy_lints/src/redundant_field_names.rs          |   2 +-
 clippy_lints/src/redundant_locals.rs               |   4 +-
 clippy_lints/src/redundant_pub_crate.rs            |   4 +-
 clippy_lints/src/redundant_slicing.rs              |   4 +-
 clippy_lints/src/redundant_type_annotations.rs     |   4 +-
 clippy_lints/src/ref_patterns.rs                   |   4 +-
 clippy_lints/src/reserve_after_initialization.rs   |   4 +-
 clippy_lints/src/return_self_not_must_use.rs       |   4 +-
 clippy_lints/src/returns.rs                        |   8 +-
 clippy_lints/src/same_name_method.rs               |   2 +-
 clippy_lints/src/semicolon_block.rs                |   8 +-
 clippy_lints/src/semicolon_if_nothing_returned.rs  |   4 +-
 clippy_lints/src/shadow.rs                         |  12 +-
 clippy_lints/src/single_call_fn.rs                 |   4 +-
 clippy_lints/src/single_char_lifetime_names.rs     |   4 +-
 clippy_lints/src/single_range_in_vec_init.rs       |   4 +-
 clippy_lints/src/size_of_ref.rs                    |   4 +-
 clippy_lints/src/slow_vector_initialization.rs     |   4 +-
 clippy_lints/src/std_instead_of_core.rs            |  12 +-
 clippy_lints/src/strings.rs                        |  26 +-
 clippy_lints/src/suspicious_doc_comments.rs        |   4 +-
 clippy_lints/src/suspicious_operation_groupings.rs |   4 +-
 clippy_lints/src/suspicious_xor_used_as_pow.rs     |   4 +-
 clippy_lints/src/swap.rs                           |   8 +-
 clippy_lints/src/swap_ptr_to_ref.rs                |   4 +-
 clippy_lints/src/tabs_in_doc_comments.rs           |   4 +-
 clippy_lints/src/temporary_assignment.rs           |   2 +-
 clippy_lints/src/tests_outside_test_module.rs      |   4 +-
 clippy_lints/src/to_digit_is_some.rs               |   4 +-
 clippy_lints/src/trailing_empty_array.rs           |   4 +-
 clippy_lints/src/trait_bounds.rs                   |  16 +-
 clippy_lints/src/transmute/mod.rs                  |  36 +-
 clippy_lints/src/types/mod.rs                      |  16 +-
 clippy_lints/src/undocumented_unsafe_blocks.rs     |   8 +-
 clippy_lints/src/unicode.rs                        |   4 +-
 clippy_lints/src/unit_return_expecting_ord.rs      |   2 +-
 clippy_lints/src/unit_types/mod.rs                 |   8 +-
 clippy_lints/src/unnamed_address.rs                |   2 +-
 clippy_lints/src/unnecessary_box_returns.rs        |   4 +-
 clippy_lints/src/unnecessary_map_on_constructor.rs |   4 +-
 .../src/unnecessary_owned_empty_strings.rs         |   4 +-
 clippy_lints/src/unnecessary_self_imports.rs       |   4 +-
 .../src/unnecessary_struct_initialization.rs       |   4 +-
 clippy_lints/src/unnecessary_wraps.rs              |   4 +-
 clippy_lints/src/unnested_or_patterns.rs           |   4 +-
 clippy_lints/src/unused_async.rs                   |   4 +-
 clippy_lints/src/unused_peekable.rs                |   4 +-
 clippy_lints/src/unused_rounding.rs                |   4 +-
 clippy_lints/src/unused_unit.rs                    |   4 +-
 clippy_lints/src/unwrap.rs                         |   6 +-
 clippy_lints/src/unwrap_in_result.rs               |   4 +-
 clippy_lints/src/upper_case_acronyms.rs            |   4 +-
 clippy_lints/src/use_self.rs                       |   4 +-
 clippy_lints/src/useless_conversion.rs             |   4 +-
 clippy_lints/src/utils/conf.rs                     |   4 +-
 clippy_lints/src/vec.rs                            |   4 +-
 clippy_lints/src/vec_init_then_push.rs             |   4 +-
 clippy_lints/src/wildcard_imports.rs               |   4 +-
 clippy_lints/src/write.rs                          |  30 +-
 clippy_lints/src/zero_div_zero.rs                  |   4 +-
 clippy_lints/src/zero_sized_map_values.rs          |   4 +-
 clippy_utils/src/lib.rs                            |  10 +-
 clippy_utils/src/source.rs                         |   2 +-
 clippy_utils/src/str_utils.rs                      |  18 +-
 declare_clippy_lint/src/lib.rs                     |   2 +-
 232 files changed, 989 insertions(+), 989 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/book/src/lint_configuration.md b/book/src/lint_configuration.md
index c7eeed17954..cbdf8a3001d 100644
--- a/book/src/lint_configuration.md
+++ b/book/src/lint_configuration.md
@@ -774,7 +774,7 @@ Additional dotfiles (files or directories starting with a dot) to allow
 
 ## `enforce-iter-loop-reborrow`
 #### Example
-```
+```no_run
 let mut vec = vec![1, 2, 3];
 let rmvec = &mut vec;
 for _ in rmvec.iter() {}
@@ -782,7 +782,7 @@ for _ in rmvec.iter_mut() {}
 ```
 
 Use instead:
-```
+```no_run
 let mut vec = vec![1, 2, 3];
 let rmvec = &mut vec;
 for _ in &*rmvec {}
diff --git a/clippy_lints/src/absolute_paths.rs b/clippy_lints/src/absolute_paths.rs
index 04417c4c460..582423603eb 100644
--- a/clippy_lints/src/absolute_paths.rs
+++ b/clippy_lints/src/absolute_paths.rs
@@ -24,11 +24,11 @@ declare_clippy_lint! {
     /// using absolute paths is the proper way of referencing items in one.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let x = std::f64::consts::PI;
     /// ```
     /// Use any of the below instead, or anything else:
-    /// ```rust
+    /// ```no_run
     /// use std::f64;
     /// use std::f64::consts;
     /// use std::f64::consts::PI;
diff --git a/clippy_lints/src/almost_complete_range.rs b/clippy_lints/src/almost_complete_range.rs
index 32d80f42e7e..4afb3957aa1 100644
--- a/clippy_lints/src/almost_complete_range.rs
+++ b/clippy_lints/src/almost_complete_range.rs
@@ -17,11 +17,11 @@ declare_clippy_lint! {
     /// This (`'a'..'z'`) is almost certainly a typo meant to include all letters.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let _ = 'a'..'z';
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let _ = 'a'..='z';
     /// ```
     #[clippy::version = "1.68.0"]
diff --git a/clippy_lints/src/approx_const.rs b/clippy_lints/src/approx_const.rs
index ccf82f132f4..591c78cb246 100644
--- a/clippy_lints/src/approx_const.rs
+++ b/clippy_lints/src/approx_const.rs
@@ -24,12 +24,12 @@ declare_clippy_lint! {
     /// issue](https://github.com/rust-lang/rust/issues).
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let x = 3.14;
     /// let y = 1_f64 / x;
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let x = std::f32::consts::PI;
     /// let y = std::f64::consts::FRAC_1_PI;
     /// ```
diff --git a/clippy_lints/src/arc_with_non_send_sync.rs b/clippy_lints/src/arc_with_non_send_sync.rs
index 35a04b5e44a..40e8281b260 100644
--- a/clippy_lints/src/arc_with_non_send_sync.rs
+++ b/clippy_lints/src/arc_with_non_send_sync.rs
@@ -18,7 +18,7 @@ declare_clippy_lint! {
     /// either `T` should be made `Send + Sync` or an `Rc` should be used instead of an `Arc`
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # use std::cell::RefCell;
     /// # use std::sync::Arc;
     ///
diff --git a/clippy_lints/src/async_yields_async.rs b/clippy_lints/src/async_yields_async.rs
index 56f56fff1e7..b27d0ec1f42 100644
--- a/clippy_lints/src/async_yields_async.rs
+++ b/clippy_lints/src/async_yields_async.rs
@@ -15,7 +15,7 @@ declare_clippy_lint! {
     /// An await is likely missing.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// async fn foo() {}
     ///
     /// fn bar() {
@@ -26,7 +26,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// async fn foo() {}
     ///
     /// fn bar() {
diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs
index db01ddbde04..8a918c13cfc 100644
--- a/clippy_lints/src/attrs.rs
+++ b/clippy_lints/src/attrs.rs
@@ -129,7 +129,7 @@ declare_clippy_lint! {
     /// a valid semver. Failing that, the contained information is useless.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// #[deprecated(since = "forever")]
     /// fn something_else() { /* ... */ }
     /// ```
@@ -156,14 +156,14 @@ declare_clippy_lint! {
     /// currently works for basic cases but is not perfect.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// #[allow(dead_code)]
     ///
     /// fn not_quite_good_code() { }
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// // Good (as inner attribute)
     /// #![allow(dead_code)]
     ///
@@ -198,25 +198,25 @@ declare_clippy_lint! {
     /// Does not detect empty lines after doc attributes (e.g. `#[doc = ""]`).
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// /// Some doc comment with a blank line after it.
     ///
     /// fn not_quite_good_code() { }
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// /// Good (no blank line)
     /// fn this_is_fine() { }
     /// ```
     ///
-    /// ```rust
+    /// ```no_run
     /// // Good (convert to a regular comment)
     ///
     /// fn this_is_fine_too() { }
     /// ```
     ///
-    /// ```rust
+    /// ```no_run
     /// //! Good (convert to a comment on an inner attribute)
     ///
     /// fn this_is_fine_as_well() { }
@@ -236,12 +236,12 @@ declare_clippy_lint! {
     /// These lints should only be enabled on a lint-by-lint basis and with careful consideration.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// #![deny(clippy::restriction)]
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// #![deny(clippy::as_conversions)]
     /// ```
     #[clippy::version = "1.47.0"]
@@ -265,13 +265,13 @@ declare_clippy_lint! {
     /// [#3123](https://github.com/rust-lang/rust-clippy/pull/3123#issuecomment-422321765)
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// #[cfg_attr(rustfmt, rustfmt_skip)]
     /// fn main() { }
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// #[rustfmt::skip]
     /// fn main() { }
     /// ```
@@ -290,13 +290,13 @@ declare_clippy_lint! {
     /// by the conditional compilation engine.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// #[cfg(linux)]
     /// fn conditional() { }
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # mod hidden {
     /// #[cfg(target_os = "linux")]
     /// fn conditional() { }
@@ -325,14 +325,14 @@ declare_clippy_lint! {
     /// ensure that others understand the reasoning
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// #![feature(lint_reasons)]
     ///
     /// #![allow(clippy::some_lint)]
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// #![feature(lint_reasons)]
     ///
     /// #![allow(clippy::some_lint, reason = "False positive rust-lang/rust-clippy#1002020")]
@@ -352,7 +352,7 @@ declare_clippy_lint! {
     /// panicking with the expected message, and not another unrelated panic.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// fn random() -> i32 { 0 }
     ///
     /// #[should_panic]
@@ -363,7 +363,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// fn random() -> i32 { 0 }
     ///
     /// #[should_panic = "attempt to divide by zero"]
@@ -386,13 +386,13 @@ declare_clippy_lint! {
     /// If there is only one condition, no need to wrap it into `any` or `all` combinators.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// #[cfg(any(unix))]
     /// pub struct Bar;
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// #[cfg(unix)]
     /// pub struct Bar;
     /// ```
@@ -412,13 +412,13 @@ declare_clippy_lint! {
     /// may cause conditional compilation not work quitely.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// #[cfg(features = "some-feature")]
     /// fn conditional() { }
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// #[cfg(feature = "some-feature")]
     /// fn conditional() { }
     /// ```
diff --git a/clippy_lints/src/await_holding_invalid.rs b/clippy_lints/src/await_holding_invalid.rs
index ae8618dcaa0..494374e967b 100644
--- a/clippy_lints/src/await_holding_invalid.rs
+++ b/clippy_lints/src/await_holding_invalid.rs
@@ -29,7 +29,7 @@ declare_clippy_lint! {
     /// to wrap the `.lock()` call in a block instead of explicitly dropping the guard.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # use std::sync::Mutex;
     /// # async fn baz() {}
     /// async fn foo(x: &Mutex<u32>) {
@@ -47,7 +47,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # use std::sync::Mutex;
     /// # async fn baz() {}
     /// async fn foo(x: &Mutex<u32>) {
@@ -87,7 +87,7 @@ declare_clippy_lint! {
     /// to wrap the `.borrow[_mut]()` call in a block instead of explicitly dropping the ref.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # use std::cell::RefCell;
     /// # async fn baz() {}
     /// async fn foo(x: &RefCell<u32>) {
@@ -105,7 +105,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # use std::cell::RefCell;
     /// # async fn baz() {}
     /// async fn foo(x: &RefCell<u32>) {
@@ -151,7 +151,7 @@ declare_clippy_lint! {
     /// ]
     /// ```
     ///
-    /// ```rust
+    /// ```no_run
     /// # async fn baz() {}
     /// struct CustomLockType;
     /// struct OtherCustomLockType;
diff --git a/clippy_lints/src/blocks_in_if_conditions.rs b/clippy_lints/src/blocks_in_if_conditions.rs
index 1593d7b0fb3..04bf541a5bd 100644
--- a/clippy_lints/src/blocks_in_if_conditions.rs
+++ b/clippy_lints/src/blocks_in_if_conditions.rs
@@ -21,7 +21,7 @@ declare_clippy_lint! {
     /// Style, using blocks in the condition makes it hard to read.
     ///
     /// ### Examples
-    /// ```rust
+    /// ```no_run
     /// # fn somefunc() -> bool { true };
     /// if { true } { /* ... */ }
     ///
@@ -29,7 +29,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # fn somefunc() -> bool { true };
     /// if true { /* ... */ }
     ///
diff --git a/clippy_lints/src/bool_assert_comparison.rs b/clippy_lints/src/bool_assert_comparison.rs
index 4503597713a..665dbd6f708 100644
--- a/clippy_lints/src/bool_assert_comparison.rs
+++ b/clippy_lints/src/bool_assert_comparison.rs
@@ -18,13 +18,13 @@ declare_clippy_lint! {
     /// It is shorter to use the equivalent.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// assert_eq!("a".is_empty(), false);
     /// assert_ne!("a".is_empty(), true);
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// assert!(!"a".is_empty());
     /// ```
     #[clippy::version = "1.53.0"]
diff --git a/clippy_lints/src/bool_to_int_with_if.rs b/clippy_lints/src/bool_to_int_with_if.rs
index 1828dd65152..ca305d0c6e5 100644
--- a/clippy_lints/src/bool_to_int_with_if.rs
+++ b/clippy_lints/src/bool_to_int_with_if.rs
@@ -21,7 +21,7 @@ declare_clippy_lint! {
     /// See https://doc.rust-lang.org/std/primitive.bool.html#impl-From%3Cbool%3E
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # let condition = false;
     /// if condition {
     ///     1_i64
@@ -30,12 +30,12 @@ declare_clippy_lint! {
     /// };
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # let condition = false;
     /// i64::from(condition);
     /// ```
     /// or
-    /// ```rust
+    /// ```no_run
     /// # let condition = false;
     /// condition as i64;
     /// ```
diff --git a/clippy_lints/src/borrow_deref_ref.rs b/clippy_lints/src/borrow_deref_ref.rs
index b3dbbb08f8e..739ce8f67c2 100644
--- a/clippy_lints/src/borrow_deref_ref.rs
+++ b/clippy_lints/src/borrow_deref_ref.rs
@@ -19,7 +19,7 @@ declare_clippy_lint! {
     ///
     /// ### Known problems
     /// False negative on such code:
-    /// ```
+    /// ```no_run
     /// let x = &12;
     /// let addr_x = &x as *const _ as usize;
     /// let addr_y = &&*x as *const _ as usize; // assert ok now, and lint triggered.
@@ -28,14 +28,14 @@ declare_clippy_lint! {
     /// ```
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let s = &String::new();
     ///
     /// let a: &String = &* s;
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # let s = &String::new();
     /// let a: &String = s;
     /// ```
diff --git a/clippy_lints/src/box_default.rs b/clippy_lints/src/box_default.rs
index cc9bd727937..47672cb5fb5 100644
--- a/clippy_lints/src/box_default.rs
+++ b/clippy_lints/src/box_default.rs
@@ -24,11 +24,11 @@ declare_clippy_lint! {
     /// [in certain cases](https://nnethercote.github.io/perf-book/standard-library-types.html#box).
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let x: Box<String> = Box::new(Default::default());
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let x: Box<String> = Box::default();
     /// ```
     #[clippy::version = "1.66.0"]
diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index b00130ffd76..2edbc6db5c3 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -45,7 +45,7 @@ declare_clippy_lint! {
     /// those places in the code.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let x = u64::MAX;
     /// x as f64;
     /// ```
@@ -67,7 +67,7 @@ declare_clippy_lint! {
     /// as a one-time check to see where numerical wrapping can arise.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let y: i8 = -1;
     /// y as u128; // will return 18446744073709551615
     /// ```
@@ -90,13 +90,13 @@ declare_clippy_lint! {
     /// checks could be beneficial.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// fn as_u8(x: u64) -> u8 {
     ///     x as u8
     /// }
     /// ```
     /// Use instead:
-    /// ```
+    /// ```no_run
     /// fn as_u8(x: u64) -> u8 {
     ///     if let Ok(x) = u8::try_from(x) {
     ///         x
@@ -132,7 +132,7 @@ declare_clippy_lint! {
     /// example below.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// u32::MAX as i32; // will yield a value of `-1`
     /// ```
     #[clippy::version = "pre 1.29.0"]
@@ -155,7 +155,7 @@ declare_clippy_lint! {
     /// people reading the code to know that the conversion is lossless.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// fn as_u64(x: u8) -> u64 {
     ///     x as u64
     /// }
@@ -163,7 +163,7 @@ declare_clippy_lint! {
     ///
     /// Using `::from` would look like this:
     ///
-    /// ```rust
+    /// ```no_run
     /// fn as_u64(x: u8) -> u64 {
     ///     u64::from(x)
     /// }
@@ -191,14 +191,14 @@ declare_clippy_lint! {
     /// intermediate references, raw pointers and trait objects may or may not work.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let _ = 2i32 as i32;
     /// let _ = 0.5 as f32;
     /// ```
     ///
     /// Better:
     ///
-    /// ```rust
+    /// ```no_run
     /// let _ = 2_i32;
     /// let _ = 0.5_f32;
     /// ```
@@ -223,7 +223,7 @@ declare_clippy_lint! {
     /// u64-> u8 -> u16 can be fine. Miri is able to do a more in-depth analysis.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let _ = (&1u8 as *const u8) as *const u16;
     /// let _ = (&mut 1u8 as *mut u8) as *mut u16;
     ///
@@ -249,13 +249,13 @@ declare_clippy_lint! {
     /// Casting to isize also doesn't make sense since there are no signed addresses.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// fn fun() -> i32 { 1 }
     /// let _ = fun as i64;
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # fn fun() -> i32 { 1 }
     /// let _ = fun as usize;
     /// ```
@@ -276,7 +276,7 @@ declare_clippy_lint! {
     /// a comment) to perform the truncation.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// fn fn1() -> i16 {
     ///     1
     /// };
@@ -284,7 +284,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// // Cast to usize first, then comment with the reason for the truncation
     /// fn fn1() -> i16 {
     ///     1
@@ -310,7 +310,7 @@ declare_clippy_lint! {
     /// pointer casts in your code.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// // fn1 is cast as `usize`
     /// fn fn1() -> u16 {
     ///     1
@@ -319,7 +319,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// // maybe you intended to call the function?
     /// fn fn2() -> u16 {
     ///     1
@@ -378,14 +378,14 @@ declare_clippy_lint! {
     /// it cannot accidentally change the pointer's mutability nor cast the pointer to other types like `usize`.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let ptr: *const u32 = &42_u32;
     /// let mut_ptr: *mut u32 = &mut 42_u32;
     /// let _ = ptr as *const i32;
     /// let _ = mut_ptr as *mut i32;
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let ptr: *const u32 = &42_u32;
     /// let mut_ptr: *mut u32 = &mut 42_u32;
     /// let _ = ptr.cast::<i32>();
@@ -408,13 +408,13 @@ declare_clippy_lint! {
     /// type.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let ptr: *const u32 = &42_u32;
     /// let mut_ptr = ptr as *mut u32;
     /// let ptr = mut_ptr as *const u32;
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let ptr: *const u32 = &42_u32;
     /// let mut_ptr = ptr.cast_mut();
     /// let ptr = mut_ptr.cast_const();
@@ -434,7 +434,7 @@ declare_clippy_lint! {
     /// The resulting integral value will not match the value of the variant it came from.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// enum E { X = 256 };
     /// let _ = E::X as u8;
     /// ```
@@ -457,7 +457,7 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// // Missing data
-    /// ```rust
+    /// ```no_run
     /// let a = [1_i32, 2, 3, 4];
     /// let p = &a as *const [i32] as *const [u8];
     /// unsafe {
@@ -465,7 +465,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     /// // Undefined Behavior (note: also potential alignment issues)
-    /// ```rust
+    /// ```no_run
     /// let a = [1_u8, 2, 3, 4];
     /// let p = &a as *const [u8] as *const [u32];
     /// unsafe {
@@ -473,7 +473,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     /// Instead use `ptr::slice_from_raw_parts` to construct a slice from a data pointer and the correct length
-    /// ```rust
+    /// ```no_run
     /// let a = [1_i32, 2, 3, 4];
     /// let old_ptr = &a as *const [i32];
     /// // The data pointer is cast to a pointer to the target `u8` not `[u8]`
@@ -497,7 +497,7 @@ declare_clippy_lint! {
     /// The cast is easily confused with casting a c-like enum value to an integer.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// enum E { X(i32) };
     /// let _ = E::X as usize;
     /// ```
@@ -515,12 +515,12 @@ declare_clippy_lint! {
     /// The `unsigned_abs()` method avoids panic when called on the MIN value.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let x: i32 = -42;
     /// let y: u32 = x.abs() as u32;
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let x: i32 = -42;
     /// let y: u32 = x.unsigned_abs();
     /// ```
@@ -541,13 +541,13 @@ declare_clippy_lint! {
     /// The lint is allowed by default as using `_` is less wordy than always specifying the type.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// fn foo(n: usize) {}
     /// let n: u16 = 256;
     /// foo(n as _);
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// fn foo(n: usize) {}
     /// let n: u16 = 256;
     /// foo(n as usize);
@@ -570,7 +570,7 @@ declare_clippy_lint! {
     /// Read the `ptr::addr_of` docs for more information.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let val = 1;
     /// let p = &val as *const i32;
     ///
@@ -578,7 +578,7 @@ declare_clippy_lint! {
     /// let p_mut = &mut val_mut as *mut i32;
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let val = 1;
     /// let p = std::ptr::addr_of!(val);
     ///
@@ -627,13 +627,13 @@ declare_clippy_lint! {
     /// mutability is used, making it unlikely that having it as a mutable pointer is correct.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let mut vec = Vec::<u8>::with_capacity(1);
     /// let ptr = vec.as_ptr() as *mut u8;
     /// unsafe { ptr.write(4) }; // UNDEFINED BEHAVIOUR
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let mut vec = Vec::<u8>::with_capacity(1);
     /// let ptr = vec.as_mut_ptr();
     /// unsafe { ptr.write(4) };
@@ -675,12 +675,12 @@ declare_clippy_lint! {
     /// {`std`, `core`}`::ptr::`{`null`, `null_mut`}.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let a = 0 as *const u32;
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let a = std::ptr::null::<u32>();
     /// ```
     #[clippy::version = "pre 1.29.0"]
diff --git a/clippy_lints/src/checked_conversions.rs b/clippy_lints/src/checked_conversions.rs
index 9102a89e377..1cfd0d1157c 100644
--- a/clippy_lints/src/checked_conversions.rs
+++ b/clippy_lints/src/checked_conversions.rs
@@ -19,13 +19,13 @@ declare_clippy_lint! {
     /// Reduces the readability of statements & is error prone.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # let foo: u32 = 5;
     /// foo <= i32::MAX as u32;
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # let foo = 1;
     /// # #[allow(unused)]
     /// i32::try_from(foo).is_ok();
diff --git a/clippy_lints/src/collapsible_if.rs b/clippy_lints/src/collapsible_if.rs
index b38e09dc09f..d21ef195d9b 100644
--- a/clippy_lints/src/collapsible_if.rs
+++ b/clippy_lints/src/collapsible_if.rs
@@ -32,7 +32,7 @@ declare_clippy_lint! {
     /// makes code look more complex than it really is.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # let (x, y) = (true, true);
     /// if x {
     ///     if y {
@@ -42,7 +42,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # let (x, y) = (true, true);
     /// if x && y {
     ///     // …
diff --git a/clippy_lints/src/collection_is_never_read.rs b/clippy_lints/src/collection_is_never_read.rs
index ac5ac542cf9..1dfc2e251d9 100644
--- a/clippy_lints/src/collection_is_never_read.rs
+++ b/clippy_lints/src/collection_is_never_read.rs
@@ -20,7 +20,7 @@ declare_clippy_lint! {
     /// instead.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # let samples = vec![3, 1, 2];
     /// let mut sorted_samples = samples.clone();
     /// sorted_samples.sort();
@@ -29,7 +29,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # let samples = vec![3, 1, 2];
     /// let mut sorted_samples = samples.clone();
     /// sorted_samples.sort();
diff --git a/clippy_lints/src/crate_in_macro_def.rs b/clippy_lints/src/crate_in_macro_def.rs
index 726674d88f1..a2005638d24 100644
--- a/clippy_lints/src/crate_in_macro_def.rs
+++ b/clippy_lints/src/crate_in_macro_def.rs
@@ -18,7 +18,7 @@ declare_clippy_lint! {
     /// https://doc.rust-lang.org/reference/macros-by-example.html#hygiene
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// #[macro_export]
     /// macro_rules! print_message {
     ///     () => {
@@ -28,7 +28,7 @@ declare_clippy_lint! {
     /// pub const MESSAGE: &str = "Hello!";
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// #[macro_export]
     /// macro_rules! print_message {
     ///     () => {
diff --git a/clippy_lints/src/default.rs b/clippy_lints/src/default.rs
index 5787f19cc6c..c74b2b8831e 100644
--- a/clippy_lints/src/default.rs
+++ b/clippy_lints/src/default.rs
@@ -23,12 +23,12 @@ declare_clippy_lint! {
     /// generic `Default`.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let s: String = Default::default();
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let s = String::default();
     /// ```
     #[clippy::version = "pre 1.29.0"]
@@ -49,7 +49,7 @@ declare_clippy_lint! {
     /// Assignments to patterns that are of tuple type are not linted.
     ///
     /// ### Example
-    /// ```
+    /// ```no_run
     /// # #[derive(Default)]
     /// # struct A { i: i32 }
     /// let mut a: A = Default::default();
@@ -57,7 +57,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```
+    /// ```no_run
     /// # #[derive(Default)]
     /// # struct A { i: i32 }
     /// let a = A {
diff --git a/clippy_lints/src/default_constructed_unit_structs.rs b/clippy_lints/src/default_constructed_unit_structs.rs
index 0676777e796..bf070432ef9 100644
--- a/clippy_lints/src/default_constructed_unit_structs.rs
+++ b/clippy_lints/src/default_constructed_unit_structs.rs
@@ -17,7 +17,7 @@ declare_clippy_lint! {
     /// This adds code complexity and an unnecessary function call.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # use std::marker::PhantomData;
     /// #[derive(Default)]
     /// struct S<T> {
@@ -29,7 +29,7 @@ declare_clippy_lint! {
     /// };
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # use std::marker::PhantomData;
     /// struct S<T> {
     ///     _marker: PhantomData<T>
diff --git a/clippy_lints/src/default_instead_of_iter_empty.rs b/clippy_lints/src/default_instead_of_iter_empty.rs
index 2d11fa6b647..77f8243c969 100644
--- a/clippy_lints/src/default_instead_of_iter_empty.rs
+++ b/clippy_lints/src/default_instead_of_iter_empty.rs
@@ -14,12 +14,12 @@ declare_clippy_lint! {
     /// ### Why is this bad?
     /// `std::iter::empty()` is the more idiomatic way.
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let _ = std::iter::Empty::<usize>::default();
     /// let iter: std::iter::Empty<usize> = std::iter::Empty::default();
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let _ = std::iter::empty::<usize>();
     /// let iter: std::iter::Empty<usize> = std::iter::empty();
     /// ```
diff --git a/clippy_lints/src/default_numeric_fallback.rs b/clippy_lints/src/default_numeric_fallback.rs
index d09428dbc1f..b296ea20f9c 100644
--- a/clippy_lints/src/default_numeric_fallback.rs
+++ b/clippy_lints/src/default_numeric_fallback.rs
@@ -31,13 +31,13 @@ declare_clippy_lint! {
     /// This lint can only be allowed at the function level or above.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let i = 10;
     /// let f = 1.23;
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let i = 10i32;
     /// let f = 1.23f64;
     /// ```
diff --git a/clippy_lints/src/default_union_representation.rs b/clippy_lints/src/default_union_representation.rs
index 63ec8195020..8c6749a95fa 100644
--- a/clippy_lints/src/default_union_representation.rs
+++ b/clippy_lints/src/default_union_representation.rs
@@ -17,7 +17,7 @@ declare_clippy_lint! {
     /// specified layout. These cases may lead to undefined behavior in unsafe blocks.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// union Foo {
     ///     a: i32,
     ///     b: u32,
@@ -30,7 +30,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// #[repr(C)]
     /// union Foo {
     ///     a: i32,
diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index efe82036dc8..ca4913ce1d1 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -29,14 +29,14 @@ declare_clippy_lint! {
     /// when not part of a method chain.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// use std::ops::Deref;
     /// let a: &mut String = &mut String::from("foo");
     /// let b: &str = a.deref();
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let a: &mut String = &mut String::from("foo");
     /// let b = &*a;
     /// ```
@@ -68,7 +68,7 @@ declare_clippy_lint! {
     /// in such a case can change the semantics of the code.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// fn fun(_a: &i32) {}
     ///
     /// let x: &i32 = &&&&&&5;
@@ -76,7 +76,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # fn fun(_a: &i32) {}
     /// let x: &i32 = &5;
     /// fun(x);
@@ -95,7 +95,7 @@ declare_clippy_lint! {
     /// The address-of operator at the use site is clearer about the need for a reference.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let x = Some("");
     /// if let Some(ref x) = x {
     ///     // use `x` here
@@ -103,7 +103,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let x = Some("");
     /// if let Some(x) = x {
     ///     // use `&x` here
@@ -123,12 +123,12 @@ declare_clippy_lint! {
     /// This unnecessarily complicates the code.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let x = String::new();
     /// let y: &str = &*x;
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let x = String::new();
     /// let y: &str = &x;
     /// ```
diff --git a/clippy_lints/src/derivable_impls.rs b/clippy_lints/src/derivable_impls.rs
index d2bfc4f8e27..ca3f1acfc0c 100644
--- a/clippy_lints/src/derivable_impls.rs
+++ b/clippy_lints/src/derivable_impls.rs
@@ -21,7 +21,7 @@ declare_clippy_lint! {
     /// It is less concise.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// struct Foo {
     ///     bar: bool
     /// }
@@ -36,7 +36,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// #[derive(Default)]
     /// struct Foo {
     ///     bar: bool
diff --git a/clippy_lints/src/derive.rs b/clippy_lints/src/derive.rs
index 2bdac1352dc..6aaa9e39b8b 100644
--- a/clippy_lints/src/derive.rs
+++ b/clippy_lints/src/derive.rs
@@ -173,7 +173,7 @@ declare_clippy_lint! {
     /// `Eq` themselves.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// #[derive(PartialEq)]
     /// struct Foo {
     ///     i_am_eq: i32,
@@ -181,7 +181,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// #[derive(PartialEq, Eq)]
     /// struct Foo {
     ///     i_am_eq: i32,
diff --git a/clippy_lints/src/disallowed_macros.rs b/clippy_lints/src/disallowed_macros.rs
index 7469f813ef8..e4f2328bc1f 100644
--- a/clippy_lints/src/disallowed_macros.rs
+++ b/clippy_lints/src/disallowed_macros.rs
@@ -35,7 +35,7 @@ declare_clippy_lint! {
     ///     { path = "serde::Serialize", reason = "no serializing" },
     /// ]
     /// ```
-    /// ```
+    /// ```no_run
     /// use serde::Serialize;
     ///
     /// // Example code where clippy issues a warning
diff --git a/clippy_lints/src/disallowed_names.rs b/clippy_lints/src/disallowed_names.rs
index 04c2d44137a..5e46b29b639 100644
--- a/clippy_lints/src/disallowed_names.rs
+++ b/clippy_lints/src/disallowed_names.rs
@@ -15,7 +15,7 @@ declare_clippy_lint! {
     /// avoided.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let foo = 3.14;
     /// ```
     #[clippy::version = "pre 1.29.0"]
diff --git a/clippy_lints/src/disallowed_script_idents.rs b/clippy_lints/src/disallowed_script_idents.rs
index c9fad98e437..96a7f0e4fde 100644
--- a/clippy_lints/src/disallowed_script_idents.rs
+++ b/clippy_lints/src/disallowed_script_idents.rs
@@ -30,7 +30,7 @@ declare_clippy_lint! {
     /// [`non_ascii_idents`]: https://doc.rust-lang.org/rustc/lints/listing/allowed-by-default.html#non-ascii-idents
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// // Assuming that `clippy.toml` contains the following line:
     /// // allowed-scripts = ["Latin", "Cyrillic"]
     /// let counter = 10; // OK, latin is allowed.
diff --git a/clippy_lints/src/doc.rs b/clippy_lints/src/doc.rs
index fc9b381664a..a2e05e5ba8d 100644
--- a/clippy_lints/src/doc.rs
+++ b/clippy_lints/src/doc.rs
@@ -58,14 +58,14 @@ declare_clippy_lint! {
     /// would fail.
     ///
     /// ### Examples
-    /// ```rust
+    /// ```no_run
     /// /// Do something with the foo_bar parameter. See also
     /// /// that::other::module::foo.
     /// // ^ `foo_bar` and `that::other::module::foo` should be ticked.
     /// fn doit(foo_bar: usize) {}
     /// ```
     ///
-    /// ```rust
+    /// ```no_run
     /// // Link text with `[]` brackets should be written as following:
     /// /// Consume the array and return the inner
     /// /// [`SmallVec<[T; INLINE_CAPACITY]>`][SmallVec].
@@ -88,7 +88,7 @@ declare_clippy_lint! {
     /// preconditions, so that users can be sure they are using them safely.
     ///
     /// ### Examples
-    /// ```rust
+    /// ```no_run
     ///# type Universe = ();
     /// /// This function should really be documented
     /// pub unsafe fn start_apocalypse(u: &mut Universe) {
@@ -98,7 +98,7 @@ declare_clippy_lint! {
     ///
     /// At least write a line about safety:
     ///
-    /// ```rust
+    /// ```no_run
     ///# type Universe = ();
     /// /// # Safety
     /// ///
@@ -126,7 +126,7 @@ declare_clippy_lint! {
     /// Since the following function returns a `Result` it has an `# Errors` section in
     /// its doc comment:
     ///
-    /// ```rust
+    /// ```no_run
     ///# use std::io;
     /// /// # Errors
     /// ///
@@ -155,7 +155,7 @@ declare_clippy_lint! {
     /// Since the following function may panic it has a `# Panics` section in
     /// its doc comment:
     ///
-    /// ```rust
+    /// ```no_run
     /// /// # Panics
     /// ///
     /// /// Will panic if y is 0
@@ -182,7 +182,7 @@ declare_clippy_lint! {
     /// if the `fn main()` is left implicit.
     ///
     /// ### Examples
-    /// ```rust
+    /// ```no_run
     /// /// An example of a doctest with a `main()` function
     /// ///
     /// /// # Examples
@@ -210,12 +210,12 @@ declare_clippy_lint! {
     /// It is likely a typo when defining an intra-doc link
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// /// See also: ['foo']
     /// fn bar() {}
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// /// See also: [`foo`]
     /// fn bar() {}
     /// ```
@@ -235,7 +235,7 @@ declare_clippy_lint! {
     /// need to describe safety preconditions that users are required to uphold.
     ///
     /// ### Examples
-    /// ```rust
+    /// ```no_run
     ///# type Universe = ();
     /// /// # Safety
     /// ///
@@ -248,7 +248,7 @@ declare_clippy_lint! {
     /// The function is safe, so there shouldn't be any preconditions
     /// that have to be explained for safety reasons.
     ///
-    /// ```rust
+    /// ```no_run
     ///# type Universe = ();
     /// /// This function should really be documented
     /// pub fn start_apocalypse(u: &mut Universe) {
diff --git a/clippy_lints/src/double_parens.rs b/clippy_lints/src/double_parens.rs
index 29425b2e554..63f32173b05 100644
--- a/clippy_lints/src/double_parens.rs
+++ b/clippy_lints/src/double_parens.rs
@@ -12,7 +12,7 @@ declare_clippy_lint! {
     /// mistake.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// fn simple_double_parens() -> i32 {
     ///     ((0))
     /// }
@@ -22,7 +22,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// fn simple_no_parens() -> i32 {
     ///     0
     /// }
diff --git a/clippy_lints/src/drop_forget_ref.rs b/clippy_lints/src/drop_forget_ref.rs
index 14122abbf2c..63394ea5fa3 100644
--- a/clippy_lints/src/drop_forget_ref.rs
+++ b/clippy_lints/src/drop_forget_ref.rs
@@ -16,7 +16,7 @@ declare_clippy_lint! {
     /// have been intended.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// struct Foo;
     /// let x = Foo;
     /// std::mem::drop(x);
@@ -36,7 +36,7 @@ declare_clippy_lint! {
     /// have been intended.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// struct Foo;
     /// let x = Foo;
     /// std::mem::forget(x);
@@ -57,7 +57,7 @@ declare_clippy_lint! {
     /// destructor, possibly causing leaks.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # use std::mem;
     /// # use std::rc::Rc;
     /// mem::forget(Rc::new(55))
diff --git a/clippy_lints/src/else_if_without_else.rs b/clippy_lints/src/else_if_without_else.rs
index bf4488570ea..61db1c1abd1 100644
--- a/clippy_lints/src/else_if_without_else.rs
+++ b/clippy_lints/src/else_if_without_else.rs
@@ -15,7 +15,7 @@ declare_clippy_lint! {
     /// Some coding guidelines require this (e.g., MISRA-C:2004 Rule 14.10).
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # fn a() {}
     /// # fn b() {}
     /// # let x: i32 = 1;
@@ -28,7 +28,7 @@ declare_clippy_lint! {
     ///
     /// Use instead:
     ///
-    /// ```rust
+    /// ```no_run
     /// # fn a() {}
     /// # fn b() {}
     /// # let x: i32 = 1;
diff --git a/clippy_lints/src/empty_drop.rs b/clippy_lints/src/empty_drop.rs
index 209fb66fa40..5fcdca7cf36 100644
--- a/clippy_lints/src/empty_drop.rs
+++ b/clippy_lints/src/empty_drop.rs
@@ -16,7 +16,7 @@ declare_clippy_lint! {
     /// destructured, which might be the intention behind adding the implementation as a marker.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// struct S;
     ///
     /// impl Drop for S {
@@ -24,7 +24,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// struct S;
     /// ```
     #[clippy::version = "1.62.0"]
diff --git a/clippy_lints/src/empty_enum.rs b/clippy_lints/src/empty_enum.rs
index 1701d061128..a5699727b5b 100644
--- a/clippy_lints/src/empty_enum.rs
+++ b/clippy_lints/src/empty_enum.rs
@@ -23,12 +23,12 @@ declare_clippy_lint! {
     ///
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// enum Test {}
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// #![feature(never_type)]
     ///
     /// struct Test(!);
diff --git a/clippy_lints/src/empty_structs_with_brackets.rs b/clippy_lints/src/empty_structs_with_brackets.rs
index 282157181ab..3122c1c1757 100644
--- a/clippy_lints/src/empty_structs_with_brackets.rs
+++ b/clippy_lints/src/empty_structs_with_brackets.rs
@@ -15,11 +15,11 @@ declare_clippy_lint! {
     /// Empty brackets after a struct declaration can be omitted.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// struct Cookie {}
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// struct Cookie;
     /// ```
     #[clippy::version = "1.62.0"]
diff --git a/clippy_lints/src/entry.rs b/clippy_lints/src/entry.rs
index 70a467dde61..3e3c62e85d0 100644
--- a/clippy_lints/src/entry.rs
+++ b/clippy_lints/src/entry.rs
@@ -23,7 +23,7 @@ declare_clippy_lint! {
     ///
     /// ### Known problems
     /// The suggestion may have type inference errors in some cases. e.g.
-    /// ```rust
+    /// ```no_run
     /// let mut map = std::collections::HashMap::new();
     /// let _ = if !map.contains_key(&0) {
     ///     map.insert(0, 0)
@@ -33,7 +33,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # use std::collections::HashMap;
     /// # let mut map = HashMap::new();
     /// # let k = 1;
@@ -43,7 +43,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # use std::collections::HashMap;
     /// # let mut map = HashMap::new();
     /// # let k = 1;
diff --git a/clippy_lints/src/enum_clike.rs b/clippy_lints/src/enum_clike.rs
index 646767868e2..003b5fc7261 100644
--- a/clippy_lints/src/enum_clike.rs
+++ b/clippy_lints/src/enum_clike.rs
@@ -19,7 +19,7 @@ declare_clippy_lint! {
     /// architectures, but works fine on 64 bit.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # #[cfg(target_pointer_width = "64")]
     /// #[repr(usize)]
     /// enum NonPortable {
diff --git a/clippy_lints/src/escape.rs b/clippy_lints/src/escape.rs
index dbe3453e7bf..47ffde61fb7 100644
--- a/clippy_lints/src/escape.rs
+++ b/clippy_lints/src/escape.rs
@@ -28,12 +28,12 @@ declare_clippy_lint! {
     /// into something.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// fn foo(x: Box<u32>) {}
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// fn foo(x: u32) {}
     /// ```
     #[clippy::version = "pre 1.29.0"]
diff --git a/clippy_lints/src/excessive_bools.rs b/clippy_lints/src/excessive_bools.rs
index aef2db38583..1b0b88896ea 100644
--- a/clippy_lints/src/excessive_bools.rs
+++ b/clippy_lints/src/excessive_bools.rs
@@ -22,7 +22,7 @@ declare_clippy_lint! {
     /// readability and API.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// struct S {
     ///     is_pending: bool,
     ///     is_processing: bool,
@@ -31,7 +31,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// enum S {
     ///     Pending,
     ///     Processing,
diff --git a/clippy_lints/src/exhaustive_items.rs b/clippy_lints/src/exhaustive_items.rs
index 9fd13084dc9..f976cfd3f22 100644
--- a/clippy_lints/src/exhaustive_items.rs
+++ b/clippy_lints/src/exhaustive_items.rs
@@ -17,14 +17,14 @@ declare_clippy_lint! {
     /// disable them by default.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// enum Foo {
     ///     Bar,
     ///     Baz
     /// }
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// #[non_exhaustive]
     /// enum Foo {
     ///     Bar,
@@ -47,14 +47,14 @@ declare_clippy_lint! {
     /// disable them by default.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// struct Foo {
     ///     bar: u8,
     ///     baz: String,
     /// }
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// #[non_exhaustive]
     /// struct Foo {
     ///     bar: u8,
diff --git a/clippy_lints/src/exit.rs b/clippy_lints/src/exit.rs
index 5ecd0ffadf3..e14b1c556ec 100644
--- a/clippy_lints/src/exit.rs
+++ b/clippy_lints/src/exit.rs
@@ -17,7 +17,7 @@ declare_clippy_lint! {
     /// the main function.
     ///
     /// ### Example
-    /// ```
+    /// ```no_run
     /// std::process::exit(0)
     /// ```
     ///
diff --git a/clippy_lints/src/explicit_write.rs b/clippy_lints/src/explicit_write.rs
index 6f6177340f4..595da886601 100644
--- a/clippy_lints/src/explicit_write.rs
+++ b/clippy_lints/src/explicit_write.rs
@@ -19,7 +19,7 @@ declare_clippy_lint! {
     /// Using `(e)println! is clearer and more concise
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # use std::io::Write;
     /// # let bar = "furchtbar";
     /// writeln!(&mut std::io::stderr(), "foo: {:?}", bar).unwrap();
@@ -27,7 +27,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # use std::io::Write;
     /// # let bar = "furchtbar";
     /// eprintln!("foo: {:?}", bar);
diff --git a/clippy_lints/src/extra_unused_type_parameters.rs b/clippy_lints/src/extra_unused_type_parameters.rs
index 0a885984abb..73034b94206 100644
--- a/clippy_lints/src/extra_unused_type_parameters.rs
+++ b/clippy_lints/src/extra_unused_type_parameters.rs
@@ -23,13 +23,13 @@ declare_clippy_lint! {
     /// requires using a turbofish, which serves no purpose but to satisfy the compiler.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// fn unused_ty<T>(x: u8) {
     ///     // ..
     /// }
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// fn no_unused_ty(x: u8) {
     ///     // ..
     /// }
diff --git a/clippy_lints/src/fallible_impl_from.rs b/clippy_lints/src/fallible_impl_from.rs
index 2ef547526d4..efb69476b94 100644
--- a/clippy_lints/src/fallible_impl_from.rs
+++ b/clippy_lints/src/fallible_impl_from.rs
@@ -17,7 +17,7 @@ declare_clippy_lint! {
     /// `TryFrom` should be used if there's a possibility of failure.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// struct Foo(i32);
     ///
     /// impl From<String> for Foo {
@@ -28,7 +28,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// struct Foo(i32);
     ///
     /// impl TryFrom<String> for Foo {
diff --git a/clippy_lints/src/float_literal.rs b/clippy_lints/src/float_literal.rs
index d182bb62195..506a1191747 100644
--- a/clippy_lints/src/float_literal.rs
+++ b/clippy_lints/src/float_literal.rs
@@ -18,13 +18,13 @@ declare_clippy_lint! {
     /// Rust will truncate the literal silently.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let v: f32 = 0.123_456_789_9;
     /// println!("{}", v); //  0.123_456_789
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let v: f64 = 0.123_456_789_9;
     /// println!("{}", v); //  0.123_456_789_9
     /// ```
@@ -44,12 +44,12 @@ declare_clippy_lint! {
     /// conversion to a float.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let _: f32 = 16_777_217.0; // 16_777_216.0
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let _: f32 = 16_777_216.0;
     /// let _: f64 = 16_777_217.0;
     /// ```
diff --git a/clippy_lints/src/floating_point_arithmetic.rs b/clippy_lints/src/floating_point_arithmetic.rs
index 29e5315f88b..3d51dfc3497 100644
--- a/clippy_lints/src/floating_point_arithmetic.rs
+++ b/clippy_lints/src/floating_point_arithmetic.rs
@@ -27,7 +27,7 @@ declare_clippy_lint! {
     /// Negatively impacts accuracy.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let a = 3f32;
     /// let _ = a.powf(1.0 / 3.0);
     /// let _ = (1.0 + a).ln();
@@ -35,7 +35,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let a = 3f32;
     /// let _ = a.cbrt();
     /// let _ = a.ln_1p();
@@ -57,7 +57,7 @@ declare_clippy_lint! {
     /// Negatively impacts accuracy and performance.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// use std::f32::consts::E;
     ///
     /// let a = 3f32;
@@ -83,7 +83,7 @@ declare_clippy_lint! {
     ///
     /// is better expressed as
     ///
-    /// ```rust
+    /// ```no_run
     /// use std::f32::consts::E;
     ///
     /// let a = 3f32;
diff --git a/clippy_lints/src/format.rs b/clippy_lints/src/format.rs
index b748d329367..fd34c8cddc0 100644
--- a/clippy_lints/src/format.rs
+++ b/clippy_lints/src/format.rs
@@ -23,13 +23,13 @@ declare_clippy_lint! {
     /// if `foo: &str`.
     ///
     /// ### Examples
-    /// ```rust
+    /// ```no_run
     /// let foo = "foo";
     /// format!("{}", foo);
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let foo = "foo";
     /// foo.to_owned();
     /// ```
diff --git a/clippy_lints/src/format_args.rs b/clippy_lints/src/format_args.rs
index 39abf5c2def..e674e03f17b 100644
--- a/clippy_lints/src/format_args.rs
+++ b/clippy_lints/src/format_args.rs
@@ -35,12 +35,12 @@ declare_clippy_lint! {
     /// The recommended code is both shorter and avoids a temporary allocation.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # use std::panic::Location;
     /// println!("error: {}", format!("something failed at {}", Location::caller()));
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # use std::panic::Location;
     /// println!("error: something failed at {}", Location::caller());
     /// ```
@@ -61,12 +61,12 @@ declare_clippy_lint! {
     /// unnecessary.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # use std::panic::Location;
     /// println!("error: something failed at {}", Location::caller().to_string());
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # use std::panic::Location;
     /// println!("error: something failed at {}", Location::caller());
     /// ```
@@ -87,7 +87,7 @@ declare_clippy_lint! {
     /// The inlined syntax, where allowed, is simpler.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # let var = 42;
     /// # let width = 1;
     /// # let prec = 2;
@@ -98,7 +98,7 @@ declare_clippy_lint! {
     /// format!("{:.*}", prec, var);
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # let var = 42;
     /// # let width = 1;
     /// # let prec = 2;
@@ -111,12 +111,12 @@ declare_clippy_lint! {
     ///
     /// If allow-mixed-uninlined-format-args is set to false in clippy.toml,
     /// the following code will also trigger the lint:
-    /// ```rust
+    /// ```no_run
     /// # let var = 42;
     /// format!("{} {}", var, 1+2);
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # let var = 42;
     /// format!("{var} {}", 1+2);
     /// ```
@@ -141,13 +141,13 @@ declare_clippy_lint! {
     /// an expected formatting operation such as adding padding isn't happening.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// println!("{:.}", 1.0);
     ///
     /// println!("not padded: {:5}", format_args!("..."));
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// println!("{}", 1.0);
     ///
     /// println!("not padded: {}", format_args!("..."));
diff --git a/clippy_lints/src/format_impl.rs b/clippy_lints/src/format_impl.rs
index 1d2f7cb7130..08ee7032c09 100644
--- a/clippy_lints/src/format_impl.rs
+++ b/clippy_lints/src/format_impl.rs
@@ -21,7 +21,7 @@ declare_clippy_lint! {
     ///
     /// ### Example
     ///
-    /// ```rust
+    /// ```no_run
     /// use std::fmt;
     ///
     /// struct Structure(i32);
@@ -33,7 +33,7 @@ declare_clippy_lint! {
     ///
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// use std::fmt;
     ///
     /// struct Structure(i32);
@@ -59,7 +59,7 @@ declare_clippy_lint! {
     /// should write to the `Formatter`, not stdout/stderr.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// use std::fmt::{Display, Error, Formatter};
     ///
     /// struct S;
@@ -72,7 +72,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// use std::fmt::{Display, Error, Formatter};
     ///
     /// struct S;
diff --git a/clippy_lints/src/format_push_string.rs b/clippy_lints/src/format_push_string.rs
index 45f67020c2d..858ec91412b 100644
--- a/clippy_lints/src/format_push_string.rs
+++ b/clippy_lints/src/format_push_string.rs
@@ -21,13 +21,13 @@ declare_clippy_lint! {
     /// While using `write!` in the suggested way should never fail, this isn't necessarily clear to the programmer.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let mut s = String::new();
     /// s += &format!("0x{:X}", 1024);
     /// s.push_str(&format!("0x{:X}", 1024));
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// use std::fmt::Write as _; // import without risk of name clashing
     ///
     /// let mut s = String::new();
diff --git a/clippy_lints/src/formatting.rs b/clippy_lints/src/formatting.rs
index 4ebf0e9667d..10ddc3bda34 100644
--- a/clippy_lints/src/formatting.rs
+++ b/clippy_lints/src/formatting.rs
@@ -37,7 +37,7 @@ declare_clippy_lint! {
     /// This is either a typo in the binary operator or confusing.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # let foo = true;
     /// # let bar = false;
     /// // &&! looks like a different operator
@@ -45,7 +45,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # let foo = true;
     /// # let bar = false;
     /// if foo && !bar {}
diff --git a/clippy_lints/src/four_forward_slashes.rs b/clippy_lints/src/four_forward_slashes.rs
index 0ec52f89e71..69bc0b726fc 100644
--- a/clippy_lints/src/four_forward_slashes.rs
+++ b/clippy_lints/src/four_forward_slashes.rs
@@ -14,7 +14,7 @@ declare_clippy_lint! {
     /// comment.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// //// My amazing data structure
     /// pub struct Foo {
     ///     // ...
@@ -22,7 +22,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// /// My amazing data structure
     /// pub struct Foo {
     ///     // ...
diff --git a/clippy_lints/src/from_over_into.rs b/clippy_lints/src/from_over_into.rs
index 2b899e21ef5..a100fd6c595 100644
--- a/clippy_lints/src/from_over_into.rs
+++ b/clippy_lints/src/from_over_into.rs
@@ -24,7 +24,7 @@ declare_clippy_lint! {
     /// According the std docs implementing `From<..>` is preferred since it gives you `Into<..>` for free where the reverse isn't true.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// struct StringWrapper(String);
     ///
     /// impl Into<StringWrapper> for String {
@@ -34,7 +34,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// struct StringWrapper(String);
     ///
     /// impl From<String> for StringWrapper {
diff --git a/clippy_lints/src/from_raw_with_void_ptr.rs b/clippy_lints/src/from_raw_with_void_ptr.rs
index 617c96b4fcb..b66746d08f8 100644
--- a/clippy_lints/src/from_raw_with_void_ptr.rs
+++ b/clippy_lints/src/from_raw_with_void_ptr.rs
@@ -18,13 +18,13 @@ declare_clippy_lint! {
     /// For this to be safe, `c_void` would need to have the same memory layout as the original type, which is often not the case.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # use std::ffi::c_void;
     /// let ptr = Box::into_raw(Box::new(42usize)) as *mut c_void;
     /// let _ = unsafe { Box::from_raw(ptr) };
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # use std::ffi::c_void;
     /// # let ptr = Box::into_raw(Box::new(42usize)) as *mut c_void;
     /// let _ = unsafe { Box::from_raw(ptr as *mut usize) };
diff --git a/clippy_lints/src/functions/mod.rs b/clippy_lints/src/functions/mod.rs
index 716908483e9..3f5cceec70e 100644
--- a/clippy_lints/src/functions/mod.rs
+++ b/clippy_lints/src/functions/mod.rs
@@ -23,7 +23,7 @@ declare_clippy_lint! {
     /// grouping some parameters into a new type.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # struct Color;
     /// fn foo(x: u32, y: u32, name: &str, c: Color, w: f32, h: f32, a: f32, b: f32) {
     ///     // ..
@@ -46,7 +46,7 @@ declare_clippy_lint! {
     /// multiple functions.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// fn im_too_long() {
     ///     println!("");
     ///     // ... 100 more LoC
@@ -129,7 +129,7 @@ declare_clippy_lint! {
     /// a remnant of a refactoring that removed the return type.
     ///
     /// ### Examples
-    /// ```rust
+    /// ```no_run
     /// #[must_use]
     /// fn useless() { }
     /// ```
@@ -151,7 +151,7 @@ declare_clippy_lint! {
     /// attribute to improve the lint message.
     ///
     /// ### Examples
-    /// ```rust
+    /// ```no_run
     /// #[must_use]
     /// fn double_must_use() -> Result<(), ()> {
     ///     unimplemented!();
@@ -183,7 +183,7 @@ declare_clippy_lint! {
     /// `#[must_use]`.
     ///
     /// ### Examples
-    /// ```rust
+    /// ```no_run
     /// // this could be annotated with `#[must_use]`.
     /// pub fn id<T>(t: T) -> T { t }
     /// ```
@@ -211,7 +211,7 @@ declare_clippy_lint! {
     /// instead.
     ///
     /// ### Examples
-    /// ```rust
+    /// ```no_run
     /// pub fn read_u8() -> Result<u8, ()> { Err(()) }
     /// ```
     /// should become
@@ -262,7 +262,7 @@ declare_clippy_lint! {
     /// The size determined by Clippy is platform-dependent.
     ///
     /// ### Examples
-    /// ```rust
+    /// ```no_run
     /// pub enum ParseError {
     ///     UnparsedBytes([u8; 512]),
     ///     UnexpectedEof,
@@ -274,7 +274,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     /// should be
-    /// ```
+    /// ```no_run
     /// pub enum ParseError {
     ///     UnparsedBytes(Box<[u8; 512]>),
     ///     UnexpectedEof,
@@ -301,7 +301,7 @@ declare_clippy_lint! {
     ///
     /// ### Example
 
-    /// ```rust
+    /// ```no_run
     /// struct A {
     ///     a: String,
     ///     b: String,
@@ -315,7 +315,7 @@ declare_clippy_lint! {
 
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// struct A {
     ///     a: String,
     ///     b: String,
@@ -340,14 +340,14 @@ declare_clippy_lint! {
     /// Turbofish syntax (`::<>`) cannot be used when `impl Trait` is being used, making `impl Trait` less powerful. Readability may also be a factor.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// trait MyTrait {}
     /// fn foo(a: impl MyTrait) {
     /// 	// [...]
     /// }
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// trait MyTrait {}
     /// fn foo<T: MyTrait>(a: T) {
     /// 	// [...]
diff --git a/clippy_lints/src/future_not_send.rs b/clippy_lints/src/future_not_send.rs
index 621415c881c..eee5b7540ba 100644
--- a/clippy_lints/src/future_not_send.rs
+++ b/clippy_lints/src/future_not_send.rs
@@ -34,11 +34,11 @@ declare_clippy_lint! {
     /// produced.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// async fn not_send(bytes: std::rc::Rc<[u8]>) {}
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// async fn is_send(bytes: std::sync::Arc<[u8]>) {}
     /// ```
     #[clippy::version = "1.44.0"]
diff --git a/clippy_lints/src/if_not_else.rs b/clippy_lints/src/if_not_else.rs
index 640819890b9..cae561f7802 100644
--- a/clippy_lints/src/if_not_else.rs
+++ b/clippy_lints/src/if_not_else.rs
@@ -17,7 +17,7 @@ declare_clippy_lint! {
     /// Negations reduce the readability of statements.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # let v: Vec<usize> = vec![];
     /// # fn a() {}
     /// # fn b() {}
@@ -30,7 +30,7 @@ declare_clippy_lint! {
     ///
     /// Could be written:
     ///
-    /// ```rust
+    /// ```no_run
     /// # let v: Vec<usize> = vec![];
     /// # fn a() {}
     /// # fn b() {}
diff --git a/clippy_lints/src/if_then_some_else_none.rs b/clippy_lints/src/if_then_some_else_none.rs
index e2d19e24557..ebd529bd356 100644
--- a/clippy_lints/src/if_then_some_else_none.rs
+++ b/clippy_lints/src/if_then_some_else_none.rs
@@ -21,7 +21,7 @@ declare_clippy_lint! {
     /// in comparison to `bool::then`.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # let v = vec![0];
     /// let a = if v.is_empty() {
     ///     println!("true!");
@@ -33,7 +33,7 @@ declare_clippy_lint! {
     ///
     /// Could be written:
     ///
-    /// ```rust
+    /// ```no_run
     /// # let v = vec![0];
     /// let a = v.is_empty().then(|| {
     ///     println!("true!");
diff --git a/clippy_lints/src/ignored_unit_patterns.rs b/clippy_lints/src/ignored_unit_patterns.rs
index ef2a66d4a20..0798f26d8f6 100644
--- a/clippy_lints/src/ignored_unit_patterns.rs
+++ b/clippy_lints/src/ignored_unit_patterns.rs
@@ -15,14 +15,14 @@ declare_clippy_lint! {
     /// would detect a type change that `_` would ignore.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// match std::fs::create_dir("tmp-work-dir") {
     ///    Ok(_) => println!("Working directory created"),
     ///    Err(s) => eprintln!("Could not create directory: {s}"),
     /// }
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// match std::fs::create_dir("tmp-work-dir") {
     ///    Ok(()) => println!("Working directory created"),
     ///    Err(s) => eprintln!("Could not create directory: {s}"),
diff --git a/clippy_lints/src/implicit_hasher.rs b/clippy_lints/src/implicit_hasher.rs
index 2b2ea156cd4..a1fcce18ff6 100644
--- a/clippy_lints/src/implicit_hasher.rs
+++ b/clippy_lints/src/implicit_hasher.rs
@@ -35,7 +35,7 @@ declare_clippy_lint! {
     /// pieces of code, possibly including external crates.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # use std::collections::HashMap;
     /// # use std::hash::{Hash, BuildHasher};
     /// # trait Serialize {};
@@ -44,7 +44,7 @@ declare_clippy_lint! {
     /// pub fn foo(map: &mut HashMap<i32, i32>) { }
     /// ```
     /// could be rewritten as
-    /// ```rust
+    /// ```no_run
     /// # use std::collections::HashMap;
     /// # use std::hash::{Hash, BuildHasher};
     /// # trait Serialize {};
diff --git a/clippy_lints/src/implicit_return.rs b/clippy_lints/src/implicit_return.rs
index a6b035d5106..c6bcf3ba40c 100644
--- a/clippy_lints/src/implicit_return.rs
+++ b/clippy_lints/src/implicit_return.rs
@@ -24,13 +24,13 @@ declare_clippy_lint! {
     /// corresponding statements.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// fn foo(x: usize) -> usize {
     ///     x
     /// }
     /// ```
     /// add return
-    /// ```rust
+    /// ```no_run
     /// fn foo(x: usize) -> usize {
     ///     return x;
     /// }
diff --git a/clippy_lints/src/implicit_saturating_add.rs b/clippy_lints/src/implicit_saturating_add.rs
index ee7973b82ab..453797f1853 100644
--- a/clippy_lints/src/implicit_saturating_add.rs
+++ b/clippy_lints/src/implicit_saturating_add.rs
@@ -18,7 +18,7 @@ declare_clippy_lint! {
     /// The built-in function is more readable and may be faster.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     ///let mut u:u32 = 7000;
     ///
     /// if u != u32::MAX {
@@ -26,7 +26,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     ///let mut u:u32 = 7000;
     ///
     /// u = u.saturating_add(1);
diff --git a/clippy_lints/src/implicit_saturating_sub.rs b/clippy_lints/src/implicit_saturating_sub.rs
index b99d4544681..859404289d9 100644
--- a/clippy_lints/src/implicit_saturating_sub.rs
+++ b/clippy_lints/src/implicit_saturating_sub.rs
@@ -15,7 +15,7 @@ declare_clippy_lint! {
     /// Simplicity and readability. Instead we can easily use an builtin function.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # let end: u32 = 10;
     /// # let start: u32 = 5;
     /// let mut i: u32 = end - start;
@@ -26,7 +26,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # let end: u32 = 10;
     /// # let start: u32 = 5;
     /// let mut i: u32 = end - start;
diff --git a/clippy_lints/src/implied_bounds_in_impls.rs b/clippy_lints/src/implied_bounds_in_impls.rs
index ec9044bba5c..cbe2b9c1dd4 100644
--- a/clippy_lints/src/implied_bounds_in_impls.rs
+++ b/clippy_lints/src/implied_bounds_in_impls.rs
@@ -29,7 +29,7 @@ declare_clippy_lint! {
     /// (e.g. `trait A {} trait B: A {} trait C: B {}`, then having an `fn() -> impl A + C`)
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # use std::ops::{Deref,DerefMut};
     /// fn f() -> impl Deref<Target = i32> + DerefMut<Target = i32> {
     /// //             ^^^^^^^^^^^^^^^^^^^ unnecessary bound, already implied by the `DerefMut` trait bound
@@ -37,7 +37,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # use std::ops::{Deref,DerefMut};
     /// fn f() -> impl DerefMut<Target = i32> {
     ///     Box::new(123)
diff --git a/clippy_lints/src/inconsistent_struct_constructor.rs b/clippy_lints/src/inconsistent_struct_constructor.rs
index 1ad886f2cf3..a84f7351ad6 100644
--- a/clippy_lints/src/inconsistent_struct_constructor.rs
+++ b/clippy_lints/src/inconsistent_struct_constructor.rs
@@ -19,7 +19,7 @@ declare_clippy_lint! {
     /// Since the order of fields in a constructor doesn't affect the
     /// resulted instance as the below example indicates,
     ///
-    /// ```rust
+    /// ```no_run
     /// #[derive(Debug, PartialEq, Eq)]
     /// struct Foo {
     ///     x: i32,
@@ -35,7 +35,7 @@ declare_clippy_lint! {
     /// inconsistent order can be confusing and decreases readability and consistency.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// struct Foo {
     ///     x: i32,
     ///     y: i32,
@@ -47,7 +47,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # struct Foo {
     /// #     x: i32,
     /// #     y: i32,
diff --git a/clippy_lints/src/index_refutable_slice.rs b/clippy_lints/src/index_refutable_slice.rs
index f507f45d5bb..ab5e6a93300 100644
--- a/clippy_lints/src/index_refutable_slice.rs
+++ b/clippy_lints/src/index_refutable_slice.rs
@@ -31,7 +31,7 @@ declare_clippy_lint! {
     /// patterns.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let slice: Option<&[u32]> = Some(&[1, 2, 3]);
     ///
     /// if let Some(slice) = slice {
@@ -39,7 +39,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let slice: Option<&[u32]> = Some(&[1, 2, 3]);
     ///
     /// if let Some(&[first, ..]) = slice {
diff --git a/clippy_lints/src/indexing_slicing.rs b/clippy_lints/src/indexing_slicing.rs
index 4f4f571773f..1ce7d85d382 100644
--- a/clippy_lints/src/indexing_slicing.rs
+++ b/clippy_lints/src/indexing_slicing.rs
@@ -26,7 +26,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # let x = [1, 2, 3, 4];
     /// // Index within bounds
     ///
@@ -65,7 +65,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # #![allow(unused)]
     ///
     /// # let x = vec![0; 5];
diff --git a/clippy_lints/src/infinite_iter.rs b/clippy_lints/src/infinite_iter.rs
index fe28c526be3..e9c53671a93 100644
--- a/clippy_lints/src/infinite_iter.rs
+++ b/clippy_lints/src/infinite_iter.rs
@@ -39,7 +39,7 @@ declare_clippy_lint! {
     /// this lint is not clever enough to analyze it.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let infinite_iter = 0..;
     /// # #[allow(unused)]
     /// [0..].iter().zip(infinite_iter.take_while(|x| *x > 5));
diff --git a/clippy_lints/src/inherent_impl.rs b/clippy_lints/src/inherent_impl.rs
index 3d1113ff9cc..a61a6416193 100644
--- a/clippy_lints/src/inherent_impl.rs
+++ b/clippy_lints/src/inherent_impl.rs
@@ -18,7 +18,7 @@ declare_clippy_lint! {
     /// Splitting the implementation of a type makes the code harder to navigate.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// struct X;
     /// impl X {
     ///     fn one() {}
@@ -30,7 +30,7 @@ declare_clippy_lint! {
     ///
     /// Could be written:
     ///
-    /// ```rust
+    /// ```no_run
     /// struct X;
     /// impl X {
     ///     fn one() {}
diff --git a/clippy_lints/src/inherent_to_string.rs b/clippy_lints/src/inherent_to_string.rs
index bc4ec33b733..fe5eb5ccac5 100644
--- a/clippy_lints/src/inherent_to_string.rs
+++ b/clippy_lints/src/inherent_to_string.rs
@@ -15,7 +15,7 @@ declare_clippy_lint! {
     /// This method is also implicitly defined if a type implements the `Display` trait. As the functionality of `Display` is much more versatile, it should be preferred.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// pub struct A;
     ///
     /// impl A {
@@ -26,7 +26,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// use std::fmt;
     ///
     /// pub struct A;
@@ -51,7 +51,7 @@ declare_clippy_lint! {
     /// This method is also implicitly defined if a type implements the `Display` trait. The less versatile inherent method will then shadow the implementation introduced by `Display`.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// use std::fmt;
     ///
     /// pub struct A;
@@ -70,7 +70,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// use std::fmt;
     ///
     /// pub struct A;
diff --git a/clippy_lints/src/init_numbered_fields.rs b/clippy_lints/src/init_numbered_fields.rs
index f95d2c2edb1..269311a67d6 100644
--- a/clippy_lints/src/init_numbered_fields.rs
+++ b/clippy_lints/src/init_numbered_fields.rs
@@ -20,7 +20,7 @@ declare_clippy_lint! {
     /// benefit as opposed to tuple initializers
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// struct TupleStruct(u8, u16);
     ///
     /// let _ = TupleStruct {
diff --git a/clippy_lints/src/inline_fn_without_body.rs b/clippy_lints/src/inline_fn_without_body.rs
index d609a5ca4d4..899126565f7 100644
--- a/clippy_lints/src/inline_fn_without_body.rs
+++ b/clippy_lints/src/inline_fn_without_body.rs
@@ -18,7 +18,7 @@ declare_clippy_lint! {
     /// The inline attribute is ignored for trait methods without bodies.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// trait Animal {
     ///     #[inline]
     ///     fn name(&self) -> &'static str;
diff --git a/clippy_lints/src/instant_subtraction.rs b/clippy_lints/src/instant_subtraction.rs
index a1a115f6d79..cb01f7aac14 100644
--- a/clippy_lints/src/instant_subtraction.rs
+++ b/clippy_lints/src/instant_subtraction.rs
@@ -21,13 +21,13 @@ declare_clippy_lint! {
     /// `prev_instant.elapsed()` also more clearly signals intention.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// use std::time::Instant;
     /// let prev_instant = Instant::now();
     /// let duration = Instant::now() - prev_instant;
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// use std::time::Instant;
     /// let prev_instant = Instant::now();
     /// let duration = prev_instant.elapsed();
@@ -47,13 +47,13 @@ declare_clippy_lint! {
     /// unintentional panics.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # use std::time::{Instant, Duration};
     /// let time_passed = Instant::now() - Duration::from_secs(5);
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # use std::time::{Instant, Duration};
     /// let time_passed = Instant::now().checked_sub(Duration::from_secs(5));
     /// ```
diff --git a/clippy_lints/src/int_plus_one.rs b/clippy_lints/src/int_plus_one.rs
index 1b14e525d9a..9ffcee07d28 100644
--- a/clippy_lints/src/int_plus_one.rs
+++ b/clippy_lints/src/int_plus_one.rs
@@ -16,14 +16,14 @@ declare_clippy_lint! {
     /// Readability -- better to use `> y` instead of `>= y + 1`.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # let x = 1;
     /// # let y = 1;
     /// if x >= y + 1 {}
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # let x = 1;
     /// # let y = 1;
     /// if x > y {}
diff --git a/clippy_lints/src/invalid_upcast_comparisons.rs b/clippy_lints/src/invalid_upcast_comparisons.rs
index 6ea637412d5..de82935e66b 100644
--- a/clippy_lints/src/invalid_upcast_comparisons.rs
+++ b/clippy_lints/src/invalid_upcast_comparisons.rs
@@ -26,7 +26,7 @@ declare_clippy_lint! {
     /// https://github.com/rust-lang/rust-clippy/issues/886
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let x: u8 = 1;
     /// (x as u32) > 300;
     /// ```
diff --git a/clippy_lints/src/item_name_repetitions.rs b/clippy_lints/src/item_name_repetitions.rs
index 8b4984da3dd..923d90187e9 100644
--- a/clippy_lints/src/item_name_repetitions.rs
+++ b/clippy_lints/src/item_name_repetitions.rs
@@ -26,7 +26,7 @@ declare_clippy_lint! {
     /// (the prefixes are `Foo1` and `Foo2` respectively), as also `Bar螃`, `Bar蟹`
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// enum Cake {
     ///     BlackForestCake,
     ///     HummingbirdCake,
@@ -34,7 +34,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// enum Cake {
     ///     BlackForest,
     ///     Hummingbird,
@@ -56,14 +56,14 @@ declare_clippy_lint! {
     /// It requires the user to type the module name twice.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// mod cake {
     ///     struct BlackForestCake;
     /// }
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// mod cake {
     ///     struct BlackForest;
     /// }
@@ -119,7 +119,7 @@ declare_clippy_lint! {
     /// (the prefixes are `foo1` and `foo2` respectively), as also `bar螃`, `bar蟹`
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// struct Cake {
     ///     cake_sugar: u8,
     ///     cake_flour: u8,
@@ -127,7 +127,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// struct Cake {
     ///     sugar: u8,
     ///     flour: u8,
diff --git a/clippy_lints/src/items_after_statements.rs b/clippy_lints/src/items_after_statements.rs
index a7ec57e2850..9605d76fbf0 100644
--- a/clippy_lints/src/items_after_statements.rs
+++ b/clippy_lints/src/items_after_statements.rs
@@ -16,7 +16,7 @@ declare_clippy_lint! {
     /// it's hard to figure out which item is meant in a statement.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// fn foo() {
     ///     println!("cake");
     /// }
@@ -31,7 +31,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// fn foo() {
     ///     println!("cake");
     /// }
diff --git a/clippy_lints/src/items_after_test_module.rs b/clippy_lints/src/items_after_test_module.rs
index 41477242bcc..fde6bff9417 100644
--- a/clippy_lints/src/items_after_test_module.rs
+++ b/clippy_lints/src/items_after_test_module.rs
@@ -14,7 +14,7 @@ declare_clippy_lint! {
     /// ### Why is this bad?
     /// Having items declared after the testing module is confusing and may lead to bad test coverage.
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// #[cfg(test)]
     /// mod tests {
     ///     // [...]
@@ -25,7 +25,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// fn my_function() {
     ///     // [...]
     /// }
diff --git a/clippy_lints/src/iter_not_returning_iterator.rs b/clippy_lints/src/iter_not_returning_iterator.rs
index 066d2c4b787..505aadd1a11 100644
--- a/clippy_lints/src/iter_not_returning_iterator.rs
+++ b/clippy_lints/src/iter_not_returning_iterator.rs
@@ -15,7 +15,7 @@ declare_clippy_lint! {
     /// Methods named `iter` or `iter_mut` conventionally return an `Iterator`.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// // `String` does not implement `Iterator`
     /// struct Data {}
     /// impl Data {
@@ -25,7 +25,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// use std::str::Chars;
     /// struct Data {}
     /// impl Data {
diff --git a/clippy_lints/src/iter_without_into_iter.rs b/clippy_lints/src/iter_without_into_iter.rs
index 0ee291a4e9d..88042525c4f 100644
--- a/clippy_lints/src/iter_without_into_iter.rs
+++ b/clippy_lints/src/iter_without_into_iter.rs
@@ -20,7 +20,7 @@ declare_clippy_lint! {
     /// (`for val in &iter {}`), without having to first call `iter()` or `iter_mut()`.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// struct MySlice<'a>(&'a [u8]);
     /// impl<'a> MySlice<'a> {
     ///     pub fn iter(&self) -> std::slice::Iter<'a, u8> {
@@ -29,7 +29,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// struct MySlice<'a>(&'a [u8]);
     /// impl<'a> MySlice<'a> {
     ///     pub fn iter(&self) -> std::slice::Iter<'a, u8> {
@@ -62,7 +62,7 @@ declare_clippy_lint! {
     /// in case of ambiguity with another `IntoIterator` impl.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// struct MySlice<'a>(&'a [u8]);
     /// impl<'a> IntoIterator for &MySlice<'a> {
     ///     type Item = &'a u8;
@@ -73,7 +73,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// struct MySlice<'a>(&'a [u8]);
     /// impl<'a> MySlice<'a> {
     ///     pub fn iter(&self) -> std::slice::Iter<'a, u8> {
diff --git a/clippy_lints/src/large_enum_variant.rs b/clippy_lints/src/large_enum_variant.rs
index b22b57a3006..79522db3718 100644
--- a/clippy_lints/src/large_enum_variant.rs
+++ b/clippy_lints/src/large_enum_variant.rs
@@ -38,7 +38,7 @@ declare_clippy_lint! {
     /// this may lead to a false positive.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// enum Test {
     ///     A(i32),
     ///     B([i32; 8000]),
@@ -46,7 +46,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// // Possibly better
     /// enum Test2 {
     ///     A(i32),
diff --git a/clippy_lints/src/large_futures.rs b/clippy_lints/src/large_futures.rs
index 90096f0f506..26a7278524e 100644
--- a/clippy_lints/src/large_futures.rs
+++ b/clippy_lints/src/large_futures.rs
@@ -16,7 +16,7 @@ declare_clippy_lint! {
     /// large size of a `Future` may cause stack overflows.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// async fn large_future(_x: [u8; 16 * 1024]) {}
     ///
     /// pub async fn trigger() {
@@ -26,7 +26,7 @@ declare_clippy_lint! {
     ///
     /// `Box::pin` the big future instead.
     ///
-    /// ```rust
+    /// ```no_run
     /// async fn large_future(_x: [u8; 16 * 1024]) {}
     ///
     /// pub async fn trigger() {
diff --git a/clippy_lints/src/large_stack_frames.rs b/clippy_lints/src/large_stack_frames.rs
index 1d28d7dd0e7..33636eb687f 100644
--- a/clippy_lints/src/large_stack_frames.rs
+++ b/clippy_lints/src/large_stack_frames.rs
@@ -49,7 +49,7 @@ declare_clippy_lint! {
     /// ### Example
     /// This function creates four 500 KB arrays on the stack. Quite big but just small enough to not trigger `large_stack_arrays`.
     /// However, looking at the function as a whole, it's clear that this uses a lot of stack space.
-    /// ```rust
+    /// ```no_run
     /// struct QuiteLargeType([u8; 500_000]);
     /// fn foo() {
     ///     // ... some function that uses a lot of stack space ...
@@ -62,7 +62,7 @@ declare_clippy_lint! {
     ///
     /// Instead of doing this, allocate the arrays on the heap.
     /// This currently requires going through a `Vec` first and then converting it to a `Box`:
-    /// ```rust
+    /// ```no_run
     /// struct NotSoLargeType(Box<[u8]>);
     ///
     /// fn foo() {
diff --git a/clippy_lints/src/let_underscore.rs b/clippy_lints/src/let_underscore.rs
index e7c875ab3a9..7a19b1c4273 100644
--- a/clippy_lints/src/let_underscore.rs
+++ b/clippy_lints/src/let_underscore.rs
@@ -17,7 +17,7 @@ declare_clippy_lint! {
     /// expr
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// fn f() -> Result<u32, u32> {
     ///     Ok(0)
     /// }
@@ -69,7 +69,7 @@ declare_clippy_lint! {
     /// and ignore the resulting value.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// async fn foo() -> Result<(), ()> {
     ///     Ok(())
     /// }
@@ -77,7 +77,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # async fn context() {
     /// async fn foo() -> Result<(), ()> {
     ///     Ok(())
@@ -107,14 +107,14 @@ declare_clippy_lint! {
     /// lints.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// fn foo() -> Result<u32, ()> {
     ///     Ok(123)
     /// }
     /// let _ = foo();
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// fn foo() -> Result<u32, ()> {
     ///     Ok(123)
     /// }
diff --git a/clippy_lints/src/lifetimes.rs b/clippy_lints/src/lifetimes.rs
index 0004a150d51..35d7a9540af 100644
--- a/clippy_lints/src/lifetimes.rs
+++ b/clippy_lints/src/lifetimes.rs
@@ -38,7 +38,7 @@ declare_clippy_lint! {
     /// are mentioned due to potential false positives.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// // Unnecessary lifetime annotations
     /// fn in_and_out<'a>(x: &'a u8, y: u8) -> &'a u8 {
     ///     x
@@ -46,7 +46,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// fn elided(x: &u8, y: u8) -> &u8 {
     ///     x
     /// }
@@ -69,7 +69,7 @@ declare_clippy_lint! {
     /// them leads to more readable code.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// // unnecessary lifetimes
     /// fn unused_lifetime<'a>(x: u8) {
     ///     // ..
@@ -77,7 +77,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// fn no_lifetime(x: u8) {
     ///     // ...
     /// }
diff --git a/clippy_lints/src/lines_filter_map_ok.rs b/clippy_lints/src/lines_filter_map_ok.rs
index ac949b67260..1304654efa6 100644
--- a/clippy_lints/src/lines_filter_map_ok.rs
+++ b/clippy_lints/src/lines_filter_map_ok.rs
@@ -34,7 +34,7 @@ declare_clippy_lint! {
     ///   successful results, using `map_while()` would stop at the first error.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # use std::{fs::File, io::{self, BufRead, BufReader}};
     /// # let _ = || -> io::Result<()> {
     /// let mut lines = BufReader::new(File::open("some-path")?).lines().filter_map(Result::ok);
@@ -43,7 +43,7 @@ declare_clippy_lint! {
     /// # Ok(()) };
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # use std::{fs::File, io::{self, BufRead, BufReader}};
     /// # let _ = || -> io::Result<()> {
     /// let mut lines = BufReader::new(File::open("some-path")?).lines().map_while(Result::ok);
diff --git a/clippy_lints/src/literal_representation.rs b/clippy_lints/src/literal_representation.rs
index 09ca0317337..2c14bb72a9e 100644
--- a/clippy_lints/src/literal_representation.rs
+++ b/clippy_lints/src/literal_representation.rs
@@ -23,14 +23,14 @@ declare_clippy_lint! {
     /// Reading long numbers is difficult without separators.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # let _: u64 =
     /// 61864918973511
     /// # ;
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # let _: u64 =
     /// 61_864_918_973_511
     /// # ;
@@ -73,14 +73,14 @@ declare_clippy_lint! {
     /// grouped digits.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # let _: u64 =
     /// 618_64_9189_73_511
     /// # ;
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # let _: u64 =
     /// 61_864_918_973_511
     /// # ;
@@ -100,7 +100,7 @@ declare_clippy_lint! {
     /// Negatively impacts readability.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let x: u32 = 0xFFF_FFF;
     /// let y: u8 = 0b01_011_101;
     /// ```
@@ -120,7 +120,7 @@ declare_clippy_lint! {
     /// Negatively impacts readability.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let x: u64 = 6186491_8973511;
     /// ```
     #[clippy::version = "pre 1.29.0"]
diff --git a/clippy_lints/src/loops/mod.rs b/clippy_lints/src/loops/mod.rs
index 1fb16adad7a..747fc7eb40e 100644
--- a/clippy_lints/src/loops/mod.rs
+++ b/clippy_lints/src/loops/mod.rs
@@ -36,7 +36,7 @@ declare_clippy_lint! {
     /// It is not as fast as a memcpy.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # let src = vec![1];
     /// # let mut dst = vec![0; 65];
     /// for i in 0..src.len() {
@@ -45,7 +45,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # let src = vec![1];
     /// # let mut dst = vec![0; 65];
     /// dst[64..(src.len() + 64)].clone_from_slice(&src[..]);
@@ -67,7 +67,7 @@ declare_clippy_lint! {
     /// the bounds check that is done when indexing.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let vec = vec!['a', 'b', 'c'];
     /// for i in 0..vec.len() {
     ///     println!("{}", vec[i]);
@@ -75,7 +75,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let vec = vec!['a', 'b', 'c'];
     /// for i in vec {
     ///     println!("{}", i);
@@ -100,7 +100,7 @@ declare_clippy_lint! {
     /// types.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// // with `y` a `Vec` or slice:
     /// # let y = vec![1];
     /// for x in y.iter() {
@@ -109,7 +109,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # let y = vec![1];
     /// for x in &y {
     ///     // ..
@@ -130,7 +130,7 @@ declare_clippy_lint! {
     /// Readability.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # let y = vec![1];
     /// // with `y` a `Vec` or slice:
     /// for x in y.into_iter() {
@@ -138,7 +138,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     /// can be rewritten to
-    /// ```rust
+    /// ```no_run
     /// # let y = vec![1];
     /// for x in y {
     ///     // ..
@@ -217,7 +217,7 @@ declare_clippy_lint! {
     /// declutters the code and may be faster in some instances.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # let v = vec![1];
     /// # fn bar(bar: usize, baz: usize) {}
     /// let mut i = 0;
@@ -228,7 +228,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # let v = vec![1];
     /// # fn bar(bar: usize, baz: usize) {}
     /// for (i, item) in v.iter().enumerate() { bar(i, *item); }
@@ -339,7 +339,7 @@ declare_clippy_lint! {
     /// code.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// loop {
     ///     ..;
     ///     break;
@@ -362,7 +362,7 @@ declare_clippy_lint! {
     /// False positive when mutation is followed by a `break`, but the `break` is not immediately
     /// after the mutation:
     ///
-    /// ```rust
+    /// ```no_run
     /// let mut x = 5;
     /// for _ in 0..x {
     ///     x += 1; // x is a range bound that is mutated
@@ -374,7 +374,7 @@ declare_clippy_lint! {
     /// False positive on nested loops ([#6072](https://github.com/rust-lang/rust-clippy/issues/6072))
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let mut foo = 42;
     /// for i in 0..foo {
     ///     foo -= 1;
@@ -402,7 +402,7 @@ declare_clippy_lint! {
     /// in the condition and only `Upvar` `b` gets mutated in the body, the lint will not trigger.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let i = 0;
     /// while i > 10 {
     ///     println!("let me loop forever!");
@@ -425,7 +425,7 @@ declare_clippy_lint! {
     /// have better performance.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let item1 = 2;
     /// let item2 = 3;
     /// let mut vec: Vec<u8> = Vec::new();
@@ -438,7 +438,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let item1 = 2;
     /// let item2 = 3;
     /// let mut vec: Vec<u8> = vec![item1; 20];
@@ -459,7 +459,7 @@ declare_clippy_lint! {
     /// single element.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let item1 = 2;
     /// for item in &[item1] {
     ///     println!("{}", item);
@@ -467,7 +467,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let item1 = 2;
     /// let item = &item1;
     /// println!("{}", item);
@@ -489,7 +489,7 @@ declare_clippy_lint! {
     ///
     /// ### Example
     ///
-    /// ```rust
+    /// ```no_run
     /// let x = vec![Some(1), Some(2), Some(3)];
     /// for n in x {
     ///     if let Some(n) = n {
@@ -498,7 +498,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let x = vec![Some(1), Some(2), Some(3)];
     /// for n in x.into_iter().flatten() {
     ///     println!("{}", n);
@@ -555,7 +555,7 @@ declare_clippy_lint! {
     ///
     /// ### Example
     ///
-    /// ```rust
+    /// ```no_run
     /// fn example(arr: Vec<i32>) -> Option<i32> {
     ///     for el in arr {
     ///         if el == 1 {
@@ -566,7 +566,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// fn example(arr: Vec<i32>) -> Option<i32> {
     ///     arr.into_iter().find(|&el| el == 1)
     /// }
@@ -587,7 +587,7 @@ declare_clippy_lint! {
     /// pattern matching on the return value of `Vec::pop()`.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let mut numbers = vec![1, 2, 3, 4, 5];
     /// while !numbers.is_empty() {
     ///     let number = numbers.pop().unwrap();
@@ -595,7 +595,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let mut numbers = vec![1, 2, 3, 4, 5];
     /// while let Some(number) = numbers.pop() {
     ///     // use `number`
diff --git a/clippy_lints/src/manual_assert.rs b/clippy_lints/src/manual_assert.rs
index 45ea5aab4c2..044d99bc0f7 100644
--- a/clippy_lints/src/manual_assert.rs
+++ b/clippy_lints/src/manual_assert.rs
@@ -16,14 +16,14 @@ declare_clippy_lint! {
     /// `assert!` is simpler than `if`-then-`panic!`.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let sad_people: Vec<&str> = vec![];
     /// if !sad_people.is_empty() {
     ///     panic!("there are sad people: {:?}", sad_people);
     /// }
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let sad_people: Vec<&str> = vec![];
     /// assert!(sad_people.is_empty(), "there are sad people: {:?}", sad_people);
     /// ```
diff --git a/clippy_lints/src/manual_async_fn.rs b/clippy_lints/src/manual_async_fn.rs
index 5a87e75722d..f2c278f4747 100644
--- a/clippy_lints/src/manual_async_fn.rs
+++ b/clippy_lints/src/manual_async_fn.rs
@@ -20,13 +20,13 @@ declare_clippy_lint! {
     /// It's more idiomatic to use the dedicated syntax.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// use std::future::Future;
     ///
     /// fn foo() -> impl Future<Output = i32> { async { 42 } }
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// async fn foo() -> i32 { 42 }
     /// ```
     #[clippy::version = "1.45.0"]
diff --git a/clippy_lints/src/manual_bits.rs b/clippy_lints/src/manual_bits.rs
index 552c57d5e02..2db4443e059 100644
--- a/clippy_lints/src/manual_bits.rs
+++ b/clippy_lints/src/manual_bits.rs
@@ -20,11 +20,11 @@ declare_clippy_lint! {
     /// Can be written as the shorter `T::BITS`.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// std::mem::size_of::<usize>() * 8;
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// usize::BITS as usize;
     /// ```
     #[clippy::version = "1.60.0"]
diff --git a/clippy_lints/src/manual_clamp.rs b/clippy_lints/src/manual_clamp.rs
index e75666e61f5..4afeb5eebc3 100644
--- a/clippy_lints/src/manual_clamp.rs
+++ b/clippy_lints/src/manual_clamp.rs
@@ -38,7 +38,7 @@ declare_clippy_lint! {
     /// PR](https://github.com/rust-lang/rust-clippy/pull/9484#issuecomment-1278922613).
     ///
     /// ### Examples
-    /// ```rust
+    /// ```no_run
     /// # let (input, min, max) = (0, -2, 1);
     /// if input > max {
     ///     max
@@ -50,13 +50,13 @@ declare_clippy_lint! {
     /// # ;
     /// ```
     ///
-    /// ```rust
+    /// ```no_run
     /// # let (input, min, max) = (0, -2, 1);
     /// input.max(min).min(max)
     /// # ;
     /// ```
     ///
-    /// ```rust
+    /// ```no_run
     /// # let (input, min, max) = (0, -2, 1);
     /// match input {
     ///     x if x > max => max,
@@ -66,14 +66,14 @@ declare_clippy_lint! {
     /// # ;
     /// ```
     ///
-    /// ```rust
+    /// ```no_run
     /// # let (input, min, max) = (0, -2, 1);
     /// let mut x = input;
     /// if x < min { x = min; }
     /// if x > max { x = max; }
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # let (input, min, max) = (0, -2, 1);
     /// input.clamp(min, max)
     /// # ;
@@ -207,7 +207,7 @@ impl TypeClampability {
 
 /// Targets patterns like
 ///
-/// ```
+/// ```no_run
 /// # let (input, min, max) = (0, -3, 12);
 ///
 /// if input < min {
@@ -256,7 +256,7 @@ fn is_if_elseif_else_pattern<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx
 
 /// Targets patterns like
 ///
-/// ```
+/// ```no_run
 /// # let (input, min_value, max_value) = (0, -3, 12);
 ///
 /// input.max(min_value).min(max_value)
@@ -287,7 +287,7 @@ fn is_max_min_pattern<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> O
 
 /// Targets patterns like
 ///
-/// ```
+/// ```no_run
 /// # let (input, min_value, max_value) = (0, -3, 12);
 /// # use std::cmp::{max, min};
 /// min(max(input, min_value), max_value)
@@ -369,7 +369,7 @@ fn is_call_max_min_pattern<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>)
 
 /// Targets patterns like
 ///
-/// ```
+/// ```no_run
 /// # let (input, min, max) = (0, -3, 12);
 ///
 /// match input {
@@ -428,7 +428,7 @@ fn is_match_pattern<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> Opt
 
 /// Targets patterns like
 ///
-/// ```
+/// ```no_run
 /// # let (input, min, max) = (0, -3, 12);
 ///
 /// let mut x = input;
@@ -485,7 +485,7 @@ fn is_two_if_pattern<'tcx>(cx: &LateContext<'tcx>, block: &'tcx Block<'tcx>) ->
 
 /// Targets patterns like
 ///
-/// ```
+/// ```no_run
 /// # let (mut input, min, max) = (0, -3, 12);
 ///
 /// if input < min {
diff --git a/clippy_lints/src/manual_float_methods.rs b/clippy_lints/src/manual_float_methods.rs
index f0994695565..c27ce062338 100644
--- a/clippy_lints/src/manual_float_methods.rs
+++ b/clippy_lints/src/manual_float_methods.rs
@@ -17,12 +17,12 @@ declare_clippy_lint! {
     /// The method `is_infinite` is shorter and more readable.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # let x = 1.0f32;
     /// if x == f32::INFINITY || x == f32::NEG_INFINITY {}
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # let x = 1.0f32;
     /// if x.is_infinite() {}
     /// ```
@@ -40,13 +40,13 @@ declare_clippy_lint! {
     /// The method `is_finite` is shorter and more readable.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # let x = 1.0f32;
     /// if x != f32::INFINITY && x != f32::NEG_INFINITY {}
     /// if x.abs() < f32::INFINITY {}
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # let x = 1.0f32;
     /// if x.is_finite() {}
     /// if x.is_finite() {}
diff --git a/clippy_lints/src/manual_hash_one.rs b/clippy_lints/src/manual_hash_one.rs
index ea911335450..cbad700c99a 100644
--- a/clippy_lints/src/manual_hash_one.rs
+++ b/clippy_lints/src/manual_hash_one.rs
@@ -19,7 +19,7 @@ declare_clippy_lint! {
     /// It is more concise to use the `hash_one` method.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// use std::hash::{BuildHasher, Hash, Hasher};
     /// use std::collections::hash_map::RandomState;
     ///
@@ -31,7 +31,7 @@ declare_clippy_lint! {
     /// let hash = hasher.finish();
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// use std::hash::BuildHasher;
     /// use std::collections::hash_map::RandomState;
     ///
diff --git a/clippy_lints/src/manual_is_ascii_check.rs b/clippy_lints/src/manual_is_ascii_check.rs
index 9da20a28fba..2474c672e18 100644
--- a/clippy_lints/src/manual_is_ascii_check.rs
+++ b/clippy_lints/src/manual_is_ascii_check.rs
@@ -23,7 +23,7 @@ declare_clippy_lint! {
     /// clear that it's not a specific subset of characters, but all
     /// ASCII (lowercase|uppercase|digit|hexdigit) characters.
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// fn main() {
     ///     assert!(matches!('x', 'a'..='z'));
     ///     assert!(matches!(b'X', b'A'..=b'Z'));
@@ -37,7 +37,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// fn main() {
     ///     assert!('x'.is_ascii_lowercase());
     ///     assert!(b'X'.is_ascii_uppercase());
diff --git a/clippy_lints/src/manual_let_else.rs b/clippy_lints/src/manual_let_else.rs
index 86bbdb4ea19..fb8ddd8c2be 100644
--- a/clippy_lints/src/manual_let_else.rs
+++ b/clippy_lints/src/manual_let_else.rs
@@ -30,14 +30,14 @@ declare_clippy_lint! {
     ///
     /// ### Example
     ///
-    /// ```rust
+    /// ```no_run
     /// # let w = Some(0);
     /// let v = if let Some(v) = w { v } else { return };
     /// ```
     ///
     /// Could be written:
     ///
-    /// ```rust
+    /// ```no_run
     /// # fn main () {
     /// # let w = Some(0);
     /// let Some(v) = w else { return };
diff --git a/clippy_lints/src/manual_main_separator_str.rs b/clippy_lints/src/manual_main_separator_str.rs
index c292bbe4e93..8bd62b080c4 100644
--- a/clippy_lints/src/manual_main_separator_str.rs
+++ b/clippy_lints/src/manual_main_separator_str.rs
@@ -19,11 +19,11 @@ declare_clippy_lint! {
     /// an extra memory allocation.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let s: &str = &std::path::MAIN_SEPARATOR.to_string();
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let s: &str = std::path::MAIN_SEPARATOR_STR;
     /// ```
     #[clippy::version = "1.70.0"]
diff --git a/clippy_lints/src/manual_non_exhaustive.rs b/clippy_lints/src/manual_non_exhaustive.rs
index c12727c4a28..85ca8486315 100644
--- a/clippy_lints/src/manual_non_exhaustive.rs
+++ b/clippy_lints/src/manual_non_exhaustive.rs
@@ -22,7 +22,7 @@ declare_clippy_lint! {
     /// and allows possible optimizations when applied to enums.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// struct S {
     ///     pub a: i32,
     ///     pub b: i32,
@@ -39,7 +39,7 @@ declare_clippy_lint! {
     /// struct T(pub i32, pub i32, ());
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// #[non_exhaustive]
     /// struct S {
     ///     pub a: i32,
diff --git a/clippy_lints/src/manual_range_patterns.rs b/clippy_lints/src/manual_range_patterns.rs
index 90557b55560..d24bfe18224 100644
--- a/clippy_lints/src/manual_range_patterns.rs
+++ b/clippy_lints/src/manual_range_patterns.rs
@@ -22,12 +22,12 @@ declare_clippy_lint! {
     /// in order to support negative numbers.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let x = 6;
     /// let foo = matches!(x, 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10);
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let x = 6;
     /// let foo = matches!(x, 1..=10);
     /// ```
diff --git a/clippy_lints/src/manual_rem_euclid.rs b/clippy_lints/src/manual_rem_euclid.rs
index 0e89ca132ef..80b83aac413 100644
--- a/clippy_lints/src/manual_rem_euclid.rs
+++ b/clippy_lints/src/manual_rem_euclid.rs
@@ -18,12 +18,12 @@ declare_clippy_lint! {
     /// It's simpler and more readable.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let x: i32 = 24;
     /// let rem = ((x % 4) + 4) % 4;
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let x: i32 = 24;
     /// let rem = x.rem_euclid(4);
     /// ```
diff --git a/clippy_lints/src/manual_retain.rs b/clippy_lints/src/manual_retain.rs
index f923413f434..bfce92c0251 100644
--- a/clippy_lints/src/manual_retain.rs
+++ b/clippy_lints/src/manual_retain.rs
@@ -35,13 +35,13 @@ declare_clippy_lint! {
     /// ### Why is this bad?
     /// `.retain()` is simpler and avoids needless allocation.
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let mut vec = vec![0, 1, 2];
     /// vec = vec.iter().filter(|&x| x % 2 == 0).copied().collect();
     /// vec = vec.into_iter().filter(|x| x % 2 == 0).collect();
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let mut vec = vec![0, 1, 2];
     /// vec.retain(|x| x % 2 == 0);
     /// ```
diff --git a/clippy_lints/src/manual_slice_size_calculation.rs b/clippy_lints/src/manual_slice_size_calculation.rs
index f97600b53e4..3b97d165998 100644
--- a/clippy_lints/src/manual_slice_size_calculation.rs
+++ b/clippy_lints/src/manual_slice_size_calculation.rs
@@ -22,12 +22,12 @@ declare_clippy_lint! {
     /// * Less turbofishing
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # let data : &[i32] = &[1, 2, 3];
     /// let newlen = data.len() * std::mem::size_of::<i32>();
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # let data : &[i32] = &[1, 2, 3];
     /// let newlen = std::mem::size_of_val(data);
     /// ```
diff --git a/clippy_lints/src/manual_string_new.rs b/clippy_lints/src/manual_string_new.rs
index c20d7959fc4..726087d4562 100644
--- a/clippy_lints/src/manual_string_new.rs
+++ b/clippy_lints/src/manual_string_new.rs
@@ -19,12 +19,12 @@ declare_clippy_lint! {
     /// be confusing.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let a = "".to_string();
     /// let b: String = "".into();
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let a = String::new();
     /// let b = String::new();
     /// ```
diff --git a/clippy_lints/src/manual_strip.rs b/clippy_lints/src/manual_strip.rs
index 201bb56efcd..e653064dbde 100644
--- a/clippy_lints/src/manual_strip.rs
+++ b/clippy_lints/src/manual_strip.rs
@@ -27,14 +27,14 @@ declare_clippy_lint! {
     /// used by `str::{starts,ends}_with` and in the slicing.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let s = "hello, world!";
     /// if s.starts_with("hello, ") {
     ///     assert_eq!(s["hello, ".len()..].to_uppercase(), "WORLD!");
     /// }
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let s = "hello, world!";
     /// if let Some(end) = s.strip_prefix("hello, ") {
     ///     assert_eq!(end.to_uppercase(), "WORLD!");
diff --git a/clippy_lints/src/map_unit_fn.rs b/clippy_lints/src/map_unit_fn.rs
index f0a0f482af2..766beb980a5 100644
--- a/clippy_lints/src/map_unit_fn.rs
+++ b/clippy_lints/src/map_unit_fn.rs
@@ -21,7 +21,7 @@ declare_clippy_lint! {
     /// an if let statement
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # fn do_stuff() -> Option<String> { Some(String::new()) }
     /// # fn log_err_msg(foo: String) -> Option<String> { Some(foo) }
     /// # fn format_msg(foo: String) -> String { String::new() }
@@ -33,7 +33,7 @@ declare_clippy_lint! {
     ///
     /// The correct use would be:
     ///
-    /// ```rust
+    /// ```no_run
     /// # fn do_stuff() -> Option<String> { Some(String::new()) }
     /// # fn log_err_msg(foo: String) -> Option<String> { Some(foo) }
     /// # fn format_msg(foo: String) -> String { String::new() }
@@ -63,7 +63,7 @@ declare_clippy_lint! {
     /// an if let statement
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # fn do_stuff() -> Result<String, String> { Ok(String::new()) }
     /// # fn log_err_msg(foo: String) -> Result<String, String> { Ok(foo) }
     /// # fn format_msg(foo: String) -> String { String::new() }
@@ -75,7 +75,7 @@ declare_clippy_lint! {
     ///
     /// The correct use would be:
     ///
-    /// ```rust
+    /// ```no_run
     /// # fn do_stuff() -> Result<String, String> { Ok(String::new()) }
     /// # fn log_err_msg(foo: String) -> Result<String, String> { Ok(foo) }
     /// # fn format_msg(foo: String) -> String { String::new() }
diff --git a/clippy_lints/src/matches/mod.rs b/clippy_lints/src/matches/mod.rs
index b5ab94b3a2f..8f1ad962276 100644
--- a/clippy_lints/src/matches/mod.rs
+++ b/clippy_lints/src/matches/mod.rs
@@ -48,7 +48,7 @@ declare_clippy_lint! {
     /// Just readability – `if let` nests less than a `match`.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # fn bar(stool: &str) {}
     /// # let x = Some("abc");
     /// match x {
@@ -58,7 +58,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # fn bar(stool: &str) {}
     /// # let x = Some("abc");
     /// if let Some(ref foo) = x {
@@ -85,7 +85,7 @@ declare_clippy_lint! {
     /// ### Example
     /// Using `match`:
     ///
-    /// ```rust
+    /// ```no_run
     /// # fn bar(foo: &usize) {}
     /// # let other_ref: usize = 1;
     /// # let x: Option<&usize> = Some(&1);
@@ -97,7 +97,7 @@ declare_clippy_lint! {
     ///
     /// Using `if let` with `else`:
     ///
-    /// ```rust
+    /// ```no_run
     /// # fn bar(foo: &usize) {}
     /// # let other_ref: usize = 1;
     /// # let x: Option<&usize> = Some(&1);
@@ -155,7 +155,7 @@ declare_clippy_lint! {
     /// It makes the code less readable.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # fn foo() {}
     /// # fn bar() {}
     /// let condition: bool = true;
@@ -165,7 +165,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     /// Use if/else instead:
-    /// ```rust
+    /// ```no_run
     /// # fn foo() {}
     /// # fn bar() {}
     /// let condition: bool = true;
@@ -190,7 +190,7 @@ declare_clippy_lint! {
     /// less obvious.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let x = 5;
     /// match x {
     ///     1..=10 => println!("1 ... 10"),
@@ -214,7 +214,7 @@ declare_clippy_lint! {
     /// catching all exceptions in java with `catch(Exception)`
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let x: Result<i32, &str> = Ok(3);
     /// match x {
     ///     Ok(_) => println!("ok"),
@@ -236,7 +236,7 @@ declare_clippy_lint! {
     /// Using `as_ref()` or `as_mut()` instead is shorter.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let x: Option<()> = None;
     ///
     /// let r: Option<&()> = match x {
@@ -246,7 +246,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let x: Option<()> = None;
     ///
     /// let r: Option<&()> = x.as_ref();
@@ -269,7 +269,7 @@ declare_clippy_lint! {
     /// variants, and also may not use correct path to enum if it's not present in the current scope.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # enum Foo { A(usize), B(usize) }
     /// # let x = Foo::B(1);
     /// match x {
@@ -279,7 +279,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # enum Foo { A(usize), B(usize) }
     /// # let x = Foo::B(1);
     /// match x {
@@ -305,7 +305,7 @@ declare_clippy_lint! {
     /// if it's not present in the current scope.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # enum Foo { A, B, C }
     /// # let x = Foo::B;
     /// match x {
@@ -316,7 +316,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # enum Foo { A, B, C }
     /// # let x = Foo::B;
     /// match x {
@@ -340,7 +340,7 @@ declare_clippy_lint! {
     /// It makes the code less readable, especially to spot wildcard pattern use in match arm.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # let s = "foo";
     /// match s {
     ///     "a" => {},
@@ -349,7 +349,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # let s = "foo";
     /// match s {
     ///     "a" => {},
@@ -371,7 +371,7 @@ declare_clippy_lint! {
     /// Just readability – `let` doesn't nest, whereas a `match` does.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// enum Wrapper {
     ///     Data(i32),
     /// }
@@ -384,7 +384,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// The correct use would be:
-    /// ```rust
+    /// ```no_run
     /// enum Wrapper {
     ///     Data(i32),
     /// }
@@ -410,7 +410,7 @@ declare_clippy_lint! {
     /// is actually binding temporary value, bringing a 'dropped while borrowed' error.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # let a = 1;
     /// # let b = 2;
     /// match (a, b) {
@@ -421,7 +421,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # let a = 1;
     /// # let b = 2;
     /// let (c, d) = (a, b);
@@ -441,7 +441,7 @@ declare_clippy_lint! {
     /// matching all enum variants explicitly.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # struct A { a: i32 }
     /// let a = A { a: 5 };
     ///
@@ -452,7 +452,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # struct A { a: i32 }
     /// # let a = A { a: 5 };
     /// match a {
@@ -484,7 +484,7 @@ declare_clippy_lint! {
     /// drop order.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # use std::task::Poll;
     /// # use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
     /// if let Ok(_) = Ok::<i32, i32>(42) {}
@@ -503,7 +503,7 @@ declare_clippy_lint! {
     ///
     /// The more idiomatic use would be:
     ///
-    /// ```rust
+    /// ```no_run
     /// # use std::task::Poll;
     /// # use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
     /// if Ok::<i32, i32>(42).is_ok() {}
@@ -535,7 +535,7 @@ declare_clippy_lint! {
     /// `cfg` attributes that remove an arm evaluating to `false`.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let x = Some(5);
     ///
     /// let a = match x {
@@ -551,7 +551,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let x = Some(5);
     /// let a = matches!(x, Some(0));
     /// ```
@@ -664,7 +664,7 @@ declare_clippy_lint! {
     /// It is unnecessarily verbose and complex.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// fn func(opt: Option<Result<u64, String>>) {
     ///     let n = match opt {
     ///         Some(n) => match n {
@@ -676,7 +676,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// fn func(opt: Option<Result<u64, String>>) {
     ///     let n = match opt {
     ///         Some(Ok(n)) => n,
@@ -698,7 +698,7 @@ declare_clippy_lint! {
     /// Concise code helps focusing on behavior instead of boilerplate.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let foo: Option<i32> = None;
     /// match foo {
     ///     Some(v) => v,
@@ -707,7 +707,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let foo: Option<i32> = None;
     /// foo.unwrap_or(1);
     /// ```
@@ -761,7 +761,7 @@ declare_clippy_lint! {
     /// The arm is unreachable, which is likely a mistake
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # let text = "Foo";
     /// match &*text.to_ascii_lowercase() {
     ///     "foo" => {},
@@ -770,7 +770,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # let text = "Foo";
     /// match &*text.to_ascii_lowercase() {
     ///     "foo" => {},
@@ -823,7 +823,7 @@ declare_clippy_lint! {
     /// println!("All done!");
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # use std::sync::Mutex;
     /// # struct State {}
     /// # impl State {
@@ -861,7 +861,7 @@ declare_clippy_lint! {
     /// always return), it is more clear to write `return Err(x)`.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// fn foo(fail: bool) -> Result<i32, String> {
     ///     if fail {
     ///       Err("failed")?;
@@ -871,7 +871,7 @@ declare_clippy_lint! {
     /// ```
     /// Could be written:
     ///
-    /// ```rust
+    /// ```no_run
     /// fn foo(fail: bool) -> Result<i32, String> {
     ///     if fail {
     ///       return Err("failed".into());
@@ -893,14 +893,14 @@ declare_clippy_lint! {
     /// Using the `map` method is clearer and more concise.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// match Some(0) {
     ///     Some(x) => Some(x + 1),
     ///     None => None,
     /// };
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// Some(0).map(|x| x + 1);
     /// ```
     #[clippy::version = "1.52.0"]
@@ -917,7 +917,7 @@ declare_clippy_lint! {
     /// Using the `filter` method is clearer and more concise.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// match Some(0) {
     ///     Some(x) => if x % 2 == 0 {
     ///                     Some(x)
@@ -928,7 +928,7 @@ declare_clippy_lint! {
     /// };
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// Some(0).filter(|&x| x % 2 == 0);
     /// ```
     #[clippy::version = "1.66.0"]
diff --git a/clippy_lints/src/mem_replace.rs b/clippy_lints/src/mem_replace.rs
index 8a921d4af16..645c26f39c4 100644
--- a/clippy_lints/src/mem_replace.rs
+++ b/clippy_lints/src/mem_replace.rs
@@ -25,14 +25,14 @@ declare_clippy_lint! {
     /// `None`.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// use std::mem;
     ///
     /// let mut an_option = Some(0);
     /// let replaced = mem::replace(&mut an_option, None);
     /// ```
     /// Is better expressed with:
-    /// ```rust
+    /// ```no_run
     /// let mut an_option = Some(0);
     /// let taken = an_option.take();
     /// ```
@@ -53,7 +53,7 @@ declare_clippy_lint! {
     /// observed in the case of a panic.
     ///
     /// ### Example
-    /// ```
+    /// ```no_run
     /// use std::mem;
     ///# fn may_panic(v: Vec<i32>) -> Vec<i32> { v }
     ///
@@ -84,12 +84,12 @@ declare_clippy_lint! {
     /// take the current value and replace it with the default value of that type.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let mut text = String::from("foo");
     /// let replaced = std::mem::replace(&mut text, String::default());
     /// ```
     /// Is better expressed with:
-    /// ```rust
+    /// ```no_run
     /// let mut text = String::from("foo");
     /// let taken = std::mem::take(&mut text);
     /// ```
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index a935aea5075..6d937b8619d 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -142,11 +142,11 @@ declare_clippy_lint! {
     /// implements `Copy`.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// [1, 2, 3].iter().cloned();
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// [1, 2, 3].iter().copied();
     /// ```
     #[clippy::version = "1.53.0"]
@@ -165,14 +165,14 @@ declare_clippy_lint! {
     /// with repetitive code.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let hello = "hesuo worpd"
     ///     .replace('s', "l")
     ///     .replace("u", "l")
     ///     .replace('p', "l");
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let hello = "hesuo worpd".replace(['s', 'u', 'p'], "l");
     /// ```
     #[clippy::version = "1.65.0"]
@@ -194,14 +194,14 @@ declare_clippy_lint! {
     /// A code that relies on that side-effect could fail.
     ///
     /// ### Examples
-    /// ```rust
+    /// ```no_run
     /// # let vec = vec!["string".to_string()];
     /// vec.iter().cloned().take(10);
     /// vec.iter().cloned().last();
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # let vec = vec!["string".to_string()];
     /// vec.iter().take(10).cloned();
     /// vec.iter().last().cloned();
@@ -222,11 +222,11 @@ declare_clippy_lint! {
     /// `Option` is used to produce 0 or 1 items.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let nums: Vec<i32> = ["1", "2", "whee!"].iter().flat_map(|x| x.parse().ok()).collect();
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let nums: Vec<i32> = ["1", "2", "whee!"].iter().filter_map(|x| x.parse().ok()).collect();
     /// ```
     #[clippy::version = "1.53.0"]
@@ -254,7 +254,7 @@ declare_clippy_lint! {
     /// where they may get displayed. Activate this lint to do just that.
     ///
     /// ### Examples
-    /// ```rust
+    /// ```no_run
     /// # let option = Some(1);
     /// # let result: Result<usize, ()> = Ok(1);
     /// option.unwrap();
@@ -262,7 +262,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # let option = Some(1);
     /// # let result: Result<usize, ()> = Ok(1);
     /// option.expect("more helpful message");
@@ -293,14 +293,14 @@ declare_clippy_lint! {
     /// It is better to write the value directly without the indirection.
     ///
     /// ### Examples
-    /// ```rust
+    /// ```no_run
     /// let val1 = Some(1).unwrap();
     /// let val2 = Ok::<_, ()>(1).unwrap();
     /// let val3 = Err::<(), _>(1).unwrap_err();
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let val1 = 1;
     /// let val2 = 1;
     /// let val3 = 1;
@@ -363,7 +363,7 @@ declare_clippy_lint! {
     /// them.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// struct X;
     /// impl X {
     ///     fn add(&self, other: &X) -> X {
@@ -412,7 +412,7 @@ declare_clippy_lint! {
     /// mutable reference to a `as_..` function.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # struct X;
     /// impl X {
     ///     fn as_str(self) -> &'static str {
@@ -439,13 +439,13 @@ declare_clippy_lint! {
     /// The error type needs to implement `Debug`
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # let x = Ok::<_, ()>(());
     /// x.ok().expect("why did I do this again?");
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # let x = Ok::<_, ()>(());
     /// x.expect("why did I do this again?");
     /// ```
@@ -496,7 +496,7 @@ declare_clippy_lint! {
     /// heuristic to try to identify such cases. However, the heuristic can produce false negatives.
     ///
     /// ### Examples
-    /// ```rust
+    /// ```no_run
     /// # let x = Some(1);
     /// # let mut map = std::collections::HashMap::<u64, String>::new();
     /// x.unwrap_or(Default::default());
@@ -504,7 +504,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # let x = Some(1);
     /// # let mut map = std::collections::HashMap::<u64, String>::new();
     /// x.unwrap_or_default();
@@ -529,7 +529,7 @@ declare_clippy_lint! {
     /// The order of the arguments is not in execution order
     ///
     /// ### Examples
-    /// ```rust
+    /// ```no_run
     /// # let option = Some(1);
     /// # let result: Result<usize, ()> = Ok(1);
     /// # fn some_function(foo: ()) -> usize { 1 }
@@ -539,7 +539,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # let option = Some(1);
     /// # let result: Result<usize, ()> = Ok(1);
     /// # fn some_function(foo: ()) -> usize { 1 }
@@ -565,13 +565,13 @@ declare_clippy_lint! {
     /// The order of the arguments is not in execution order.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # let opt = Some(1);
     /// opt.map_or(None, |a| Some(a + 1));
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # let opt = Some(1);
     /// opt.and_then(|a| Some(a + 1));
     /// ```
@@ -590,13 +590,13 @@ declare_clippy_lint! {
     /// `_.ok()`.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # let r: Result<u32, &str> = Ok(1);
     /// assert_eq!(Some(1), r.map_or(None, Some));
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # let r: Result<u32, &str> = Ok(1);
     /// assert_eq!(Some(1), r.ok());
     /// ```
@@ -616,7 +616,7 @@ declare_clippy_lint! {
     /// `_.map(|x| y)` or `_.map_err(|x| y)`.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # fn opt() -> Option<&'static str> { Some("42") }
     /// # fn res() -> Result<&'static str, &'static str> { Ok("42") }
     /// let _ = opt().and_then(|s| Some(s.len()));
@@ -626,7 +626,7 @@ declare_clippy_lint! {
     ///
     /// The correct use would be:
     ///
-    /// ```rust
+    /// ```no_run
     /// # fn opt() -> Option<&'static str> { Some("42") }
     /// # fn res() -> Result<&'static str, &'static str> { Ok("42") }
     /// let _ = opt().map(|s| s.len());
@@ -648,13 +648,13 @@ declare_clippy_lint! {
     /// `_.find(_)`.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # let vec = vec![1];
     /// vec.iter().filter(|x| **x == 0).next();
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # let vec = vec![1];
     /// vec.iter().find(|x| **x == 0);
     /// ```
@@ -673,13 +673,13 @@ declare_clippy_lint! {
     /// `_.find(!condition)`.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # let vec = vec![1];
     /// vec.iter().skip_while(|x| **x == 0).next();
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # let vec = vec![1];
     /// vec.iter().find(|x| **x != 0);
     /// ```
@@ -698,7 +698,7 @@ declare_clippy_lint! {
     /// `_.flat_map(_)` for `Iterator` or `_.and_then(_)` for `Option`
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let vec = vec![vec![1]];
     /// let opt = Some(5);
     ///
@@ -707,7 +707,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # let vec = vec![vec![1]];
     /// # let opt = Some(5);
     /// vec.iter().flat_map(|x| x.iter());
@@ -729,7 +729,7 @@ declare_clippy_lint! {
     /// less performant.
     ///
      /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # #![allow(unused)]
     /// (0_i32..10)
     ///     .filter(|n| n.checked_add(1).is_some())
@@ -737,7 +737,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # #[allow(unused)]
     /// (0_i32..10).filter_map(|n| n.checked_add(1));
     /// ```
@@ -757,14 +757,14 @@ declare_clippy_lint! {
     /// less performant.
     ///
      /// ### Example
-    /// ```rust
+    /// ```no_run
     /// (0_i32..10)
     ///     .find(|n| n.checked_add(1).is_some())
     ///     .map(|n| n.checked_add(1).unwrap());
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// (0_i32..10).find_map(|n| n.checked_add(1));
     /// ```
     #[clippy::version = "1.51.0"]
@@ -782,12 +782,12 @@ declare_clippy_lint! {
     /// `_.find_map(_)`.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     ///  (0..3).filter_map(|x| if x == 2 { Some(x) } else { None }).next();
     /// ```
     /// Can be written as
     ///
-    /// ```rust
+    /// ```no_run
     ///  (0..3).find_map(|x| if x == 2 { Some(x) } else { None });
     /// ```
     #[clippy::version = "1.36.0"]
@@ -804,12 +804,12 @@ declare_clippy_lint! {
     /// Readability, this can be written more concisely by using `flatten`.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # let iter = vec![vec![0]].into_iter();
     /// iter.flat_map(|x| x);
     /// ```
     /// Can be written as
-    /// ```rust
+    /// ```no_run
     /// # let iter = vec![vec![0]].into_iter();
     /// iter.flatten();
     /// ```
@@ -830,7 +830,7 @@ declare_clippy_lint! {
     /// * `!_.any(_)`, or `!_.contains(_)` for `is_none()`.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # #![allow(unused)]
     /// let vec = vec![1];
     /// vec.iter().find(|x| **x == 0).is_some();
@@ -839,7 +839,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let vec = vec![1];
     /// vec.iter().any(|x| *x == 0);
     ///
@@ -862,13 +862,13 @@ declare_clippy_lint! {
     /// `_.starts_with(_)`.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let name = "foo";
     /// if name.chars().next() == Some('_') {};
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let name = "foo";
     /// if name.starts_with('_') {};
     /// ```
@@ -897,13 +897,13 @@ declare_clippy_lint! {
     /// actually expensive to call or not.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # let foo = Some(String::new());
     /// foo.unwrap_or(String::from("empty"));
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # let foo = Some(String::new());
     /// foo.unwrap_or_else(|| String::from("empty"));
     /// ```
@@ -921,7 +921,7 @@ declare_clippy_lint! {
     /// You should use `.unwrap_or(…)` instead for clarity.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # let fallback = "fallback";
     /// // Result
     /// # type Error = &'static str;
@@ -933,7 +933,7 @@ declare_clippy_lint! {
     /// let value = option.or(Some(fallback)).unwrap();
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # let fallback = "fallback";
     /// // Result
     /// # let result: Result<&str, &str> = Err("error");
@@ -962,7 +962,7 @@ declare_clippy_lint! {
     /// change the semantics of the program, but you shouldn't rely on that anyway.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # let foo = Some(String::new());
     /// # let err_code = "418";
     /// # let err_msg = "I'm a teapot";
@@ -975,7 +975,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # let foo = Some(String::new());
     /// # let err_code = "418";
     /// # let err_msg = "I'm a teapot";
@@ -996,7 +996,7 @@ declare_clippy_lint! {
     /// generics, not for using the `clone` method on a concrete type.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// 42u64.clone();
     /// ```
     #[clippy::version = "pre 1.29.0"]
@@ -1017,7 +1017,7 @@ declare_clippy_lint! {
     /// data.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # use std::rc::Rc;
     /// let x = Rc::new(1);
     ///
@@ -1025,7 +1025,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # use std::rc::Rc;
     /// # let x = Rc::new(1);
     /// Rc::clone(&x);
@@ -1047,7 +1047,7 @@ declare_clippy_lint! {
     /// facilities.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// // Generic implementation for `T: Display` is used (slow)
     /// ["foo", "bar"].iter().map(|s| s.to_string());
     ///
@@ -1070,7 +1070,7 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// In an impl block:
-    /// ```rust
+    /// ```no_run
     /// # struct Foo;
     /// # struct NotAFoo;
     /// impl Foo {
@@ -1080,7 +1080,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     ///
-    /// ```rust
+    /// ```no_run
     /// # struct Foo;
     /// struct Bar(Foo);
     /// impl Foo {
@@ -1091,7 +1091,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     ///
-    /// ```rust
+    /// ```no_run
     /// # struct Foo;
     /// # struct FooError;
     /// impl Foo {
@@ -1103,14 +1103,14 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Or in a trait definition:
-    /// ```rust
+    /// ```no_run
     /// pub trait Trait {
     ///     // Bad. The type name must contain `Self`
     ///     fn new();
     /// }
     /// ```
     ///
-    /// ```rust
+    /// ```no_run
     /// pub trait Trait {
     ///     // Good. Return type contains `Self`
     ///     fn new() -> Self;
@@ -1178,11 +1178,11 @@ declare_clippy_lint! {
     /// automatically does this without suspicious-looking `unwrap` calls.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let _ = std::iter::empty::<Option<i32>>().filter(Option::is_some).map(Option::unwrap);
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let _ = std::iter::empty::<Option<i32>>().flatten();
     /// ```
     #[clippy::version = "1.53.0"]
@@ -1201,7 +1201,7 @@ declare_clippy_lint! {
     ///  but is more readable.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # use std::collections::HashSet;
     /// # let mut s = HashSet::new();
     /// # s.insert(1);
@@ -1209,7 +1209,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # use std::collections::HashSet;
     /// # let mut s = HashSet::new();
     /// # s.insert(1);
@@ -1231,13 +1231,13 @@ declare_clippy_lint! {
     /// readable.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let some_vec = vec![0, 1, 2, 3];
     /// let bad_vec = some_vec.iter().nth(3);
     /// let bad_slice = &some_vec[..].iter().nth(3);
     /// ```
     /// The correct use would be:
-    /// ```rust
+    /// ```no_run
     /// let some_vec = vec![0, 1, 2, 3];
     /// let bad_vec = some_vec.get(3);
     /// let bad_slice = &some_vec[..].get(3);
@@ -1256,13 +1256,13 @@ declare_clippy_lint! {
     /// `.nth(x)` is cleaner
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let some_vec = vec![0, 1, 2, 3];
     /// let bad_vec = some_vec.iter().skip(3).next();
     /// let bad_slice = &some_vec[..].iter().skip(3).next();
     /// ```
     /// The correct use would be:
-    /// ```rust
+    /// ```no_run
     /// let some_vec = vec![0, 1, 2, 3];
     /// let bad_vec = some_vec.iter().nth(3);
     /// let bad_slice = &some_vec[..].iter().nth(3);
@@ -1281,13 +1281,13 @@ declare_clippy_lint! {
     /// `.into_iter()` is simpler with better performance.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # use std::collections::HashSet;
     /// let mut foo = vec![0, 1, 2, 3];
     /// let bar: HashSet<usize> = foo.drain(..).collect();
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # use std::collections::HashSet;
     /// let foo = vec![0, 1, 2, 3];
     /// let bar: HashSet<usize> = foo.into_iter().collect();
@@ -1315,13 +1315,13 @@ declare_clippy_lint! {
     /// `x.get(index).unwrap()` instead of `x[index]`.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let x = vec![2, 3, 5];
     /// let last_element = x.get(x.len() - 1);
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let x = vec![2, 3, 5];
     /// let last_element = x.last();
     /// ```
@@ -1351,13 +1351,13 @@ declare_clippy_lint! {
     /// trait.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let mut some_vec = vec![0, 1, 2, 3];
     /// let last = some_vec.get(3).unwrap();
     /// *some_vec.get_mut(0).unwrap() = 1;
     /// ```
     /// The correct use would be:
-    /// ```rust
+    /// ```no_run
     /// let mut some_vec = vec![0, 1, 2, 3];
     /// let last = some_vec[3];
     /// some_vec[0] = 1;
@@ -1376,7 +1376,7 @@ declare_clippy_lint! {
     /// Using `append` instead of `extend` is more concise and faster
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let mut a = vec![1, 2, 3];
     /// let mut b = vec![4, 5, 6];
     ///
@@ -1384,7 +1384,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let mut a = vec![1, 2, 3];
     /// let mut b = vec![4, 5, 6];
     ///
@@ -1405,7 +1405,7 @@ declare_clippy_lint! {
     /// `.push_str(s)` is clearer
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let abc = "abc";
     /// let def = String::from("def");
     /// let mut s = String::new();
@@ -1413,7 +1413,7 @@ declare_clippy_lint! {
     /// s.extend(def.chars());
     /// ```
     /// The correct use would be:
-    /// ```rust
+    /// ```no_run
     /// let abc = "abc";
     /// let def = String::from("def");
     /// let mut s = String::new();
@@ -1435,12 +1435,12 @@ declare_clippy_lint! {
     /// `.to_vec()` is clearer
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let s = [1, 2, 3, 4, 5];
     /// let s2: Vec<isize> = s[..].iter().cloned().collect();
     /// ```
     /// The better use would be:
-    /// ```rust
+    /// ```no_run
     /// let s = [1, 2, 3, 4, 5];
     /// let s2: Vec<isize> = s.to_vec();
     /// ```
@@ -1460,13 +1460,13 @@ declare_clippy_lint! {
     /// `_.ends_with(_)`.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # let name = "_";
     /// name.chars().last() == Some('_') || name.chars().next_back() == Some('-');
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # let name = "_";
     /// name.ends_with('_') || name.ends_with('-');
     /// ```
@@ -1485,13 +1485,13 @@ declare_clippy_lint! {
     /// The call is unnecessary.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # fn do_stuff(x: &[i32]) {}
     /// let x: &[i32] = &[1, 2, 3, 4, 5];
     /// do_stuff(x.as_ref());
     /// ```
     /// The correct use would be:
-    /// ```rust
+    /// ```no_run
     /// # fn do_stuff(x: &[i32]) {}
     /// let x: &[i32] = &[1, 2, 3, 4, 5];
     /// do_stuff(x);
@@ -1512,13 +1512,13 @@ declare_clippy_lint! {
     /// Readability.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # #[allow(unused)]
     /// (0..3).fold(false, |acc, x| acc || x > 2);
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// (0..3).any(|x| x > 2);
     /// ```
     #[clippy::version = "pre 1.29.0"]
@@ -1538,14 +1538,14 @@ declare_clippy_lint! {
     /// operation is being performed.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let _ = (0..3).filter_map(|x| if x > 2 { Some(x) } else { None });
     ///
     /// // As there is no transformation of the argument this could be written as:
     /// let _ = (0..3).filter(|&x| x > 2);
     /// ```
     ///
-    /// ```rust
+    /// ```no_run
     /// let _ = (0..4).filter_map(|x| Some(x + 1));
     ///
     /// // As there is no conditional check on the argument this could be written as:
@@ -1568,14 +1568,14 @@ declare_clippy_lint! {
     /// operation is being performed.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let _ = (0..3).find_map(|x| if x > 2 { Some(x) } else { None });
     ///
     /// // As there is no transformation of the argument this could be written as:
     /// let _ = (0..3).find(|&x| x > 2);
     /// ```
     ///
-    /// ```rust
+    /// ```no_run
     /// let _ = (0..4).find_map(|x| Some(x + 1));
     ///
     /// // As there is no conditional check on the argument this could be written as:
@@ -1598,13 +1598,13 @@ declare_clippy_lint! {
     /// `iter_mut` directly.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # let vec = vec![3, 4, 5];
     /// (&vec).into_iter();
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # let vec = vec![3, 4, 5];
     /// (&vec).iter();
     /// ```
@@ -1625,7 +1625,7 @@ declare_clippy_lint! {
     /// completion, you can just use `for_each` instead.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let _ = (0..3).map(|x| x + 2).count();
     /// ```
     #[clippy::version = "1.39.0"]
@@ -1647,7 +1647,7 @@ declare_clippy_lint! {
     /// data, but those are not yet rigorously defined.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// // Beware the UB
     /// use std::mem::MaybeUninit;
     ///
@@ -1656,7 +1656,7 @@ declare_clippy_lint! {
     ///
     /// Note that the following is OK:
     ///
-    /// ```rust
+    /// ```no_run
     /// use std::mem::MaybeUninit;
     ///
     /// let _: [MaybeUninit<bool>; 5] = unsafe {
@@ -1677,7 +1677,7 @@ declare_clippy_lint! {
     /// These can be written simply with `saturating_add/sub` methods.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # let y: u32 = 0;
     /// # let x: u32 = 100;
     /// let add = x.checked_add(y).unwrap_or(u32::MAX);
@@ -1686,7 +1686,7 @@ declare_clippy_lint! {
     ///
     /// can be written using dedicated methods for saturating addition/subtraction as:
     ///
-    /// ```rust
+    /// ```no_run
     /// # let y: u32 = 0;
     /// # let x: u32 = 100;
     /// let add = x.saturating_add(y);
@@ -1707,7 +1707,7 @@ declare_clippy_lint! {
     /// This is a no-op, and likely unintended
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// unsafe { (&() as *const ()).offset(1) };
     /// ```
     #[clippy::version = "1.41.0"]
@@ -1727,7 +1727,7 @@ declare_clippy_lint! {
     /// symlink in windows. Using `!FileType::is_dir()` is a better way to that intention.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # || {
     /// let metadata = std::fs::metadata("foo.txt")?;
     /// let filetype = metadata.file_type();
@@ -1741,7 +1741,7 @@ declare_clippy_lint! {
     ///
     /// should be written as:
     ///
-    /// ```rust
+    /// ```no_run
     /// # || {
     /// let metadata = std::fs::metadata("foo.txt")?;
     /// let filetype = metadata.file_type();
@@ -1767,13 +1767,13 @@ declare_clippy_lint! {
     /// `_.as_deref()`.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # let opt = Some("".to_string());
     /// opt.as_ref().map(String::as_str)
     /// # ;
     /// ```
     /// Can be written as
-    /// ```rust
+    /// ```no_run
     /// # let opt = Some("".to_string());
     /// opt.as_deref()
     /// # ;
@@ -1792,14 +1792,14 @@ declare_clippy_lint! {
     /// These can be shortened into `.get()`
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # let a = [1, 2, 3];
     /// # let b = vec![1, 2, 3];
     /// a[2..].iter().next();
     /// b.iter().next();
     /// ```
     /// should be written as:
-    /// ```rust
+    /// ```no_run
     /// # let a = [1, 2, 3];
     /// # let b = vec![1, 2, 3];
     /// a.get(2);
@@ -1820,14 +1820,14 @@ declare_clippy_lint! {
     /// It's less clear that we are pushing a single character.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # let mut string = String::new();
     /// string.insert_str(0, "R");
     /// string.push_str("R");
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # let mut string = String::new();
     /// string.insert(0, 'R');
     /// string.push('R');
@@ -1860,14 +1860,14 @@ declare_clippy_lint! {
     /// side effects. Eagerly evaluating them can change the semantics of the program.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// // example code where clippy issues a warning
     /// let opt: Option<u32> = None;
     ///
     /// opt.unwrap_or_else(|| 42);
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let opt: Option<u32> = None;
     ///
     /// opt.unwrap_or(42);
@@ -1886,11 +1886,11 @@ declare_clippy_lint! {
     /// Using `try_for_each` instead is more readable and idiomatic.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// (0..3).map(|t| Err(t)).collect::<Result<(), _>>();
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// (0..3).try_for_each(|t| Err(t));
     /// ```
     #[clippy::version = "1.49.0"]
@@ -1909,7 +1909,7 @@ declare_clippy_lint! {
     /// [FromIterator documentation](https://doc.rust-lang.org/std/iter/trait.FromIterator.html)
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let five_fives = std::iter::repeat(5).take(5);
     ///
     /// let v = Vec::from_iter(five_fives);
@@ -1917,7 +1917,7 @@ declare_clippy_lint! {
     /// assert_eq!(v, vec![5, 5, 5, 5, 5]);
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let five_fives = std::iter::repeat(5).take(5);
     ///
     /// let v: Vec<i32> = five_fives.collect();
@@ -1939,7 +1939,7 @@ declare_clippy_lint! {
     /// inside `inspect` at the beginning of the closure in `for_each`.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// [1,2,3,4,5].iter()
     /// .inspect(|&x| println!("inspect the number: {}", x))
     /// .for_each(|&x| {
@@ -1947,7 +1947,7 @@ declare_clippy_lint! {
     /// });
     /// ```
     /// Can be written as
-    /// ```rust
+    /// ```no_run
     /// [1,2,3,4,5].iter()
     /// .for_each(|&x| {
     ///     println!("inspect the number: {}", x);
@@ -1968,12 +1968,12 @@ declare_clippy_lint! {
     /// Readability, this can be written more concisely by using `flatten`.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # let iter = vec![Some(1)].into_iter();
     /// iter.filter_map(|x| x);
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # let iter = vec![Some(1)].into_iter();
     /// iter.flatten();
     /// ```
@@ -1991,12 +1991,12 @@ declare_clippy_lint! {
     /// It can be written more concisely without the call to `map`.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let x = [1, 2, 3];
     /// let y: Vec<_> = x.iter().map(|x| x).map(|x| 2*x).collect();
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let x = [1, 2, 3];
     /// let y: Vec<_> = x.iter().map(|x| 2*x).collect();
     /// ```
@@ -2015,13 +2015,13 @@ declare_clippy_lint! {
     /// readable.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # #[allow(unused)]
     /// "Hello".bytes().nth(3);
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # #[allow(unused)]
     /// "Hello".as_bytes().get(3);
     /// ```
@@ -2040,13 +2040,13 @@ declare_clippy_lint! {
     /// to why we are calling `to_vec` on something that is already a `Vec` or calling `to_owned` on something that is already owned.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let a = vec![1, 2, 3];
     /// let b = a.to_vec();
     /// let c = a.to_owned();
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let a = vec![1, 2, 3];
     /// let b = a.clone();
     /// let c = a.clone();
@@ -2066,7 +2066,7 @@ declare_clippy_lint! {
     /// readable.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # #![allow(unused)]
     /// let some_vec = vec![0, 1, 2, 3];
     ///
@@ -2075,7 +2075,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let some_vec = vec![0, 1, 2, 3];
     ///
     /// some_vec.len();
@@ -2104,7 +2104,7 @@ declare_clippy_lint! {
     /// was the original intent, using `into_owned` instead.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # use std::borrow::Cow;
     /// let s = "Hello world!";
     /// let cow = Cow::Borrowed(s);
@@ -2113,7 +2113,7 @@ declare_clippy_lint! {
     /// assert!(matches!(data, Cow::Borrowed(_)))
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # use std::borrow::Cow;
     /// let s = "Hello world!";
     /// let cow = Cow::Borrowed(s);
@@ -2122,7 +2122,7 @@ declare_clippy_lint! {
     /// assert!(matches!(data, Cow::Borrowed(_)))
     /// ```
     /// or
-    /// ```rust
+    /// ```no_run
     /// # use std::borrow::Cow;
     /// let s = "Hello world!";
     /// let cow = Cow::Borrowed(s);
@@ -2146,7 +2146,7 @@ declare_clippy_lint! {
     /// likely to be intended as a different number.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # let s = "";
     /// for x in s.splitn(1, ":") {
     ///     // ..
@@ -2154,7 +2154,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # let s = "";
     /// for x in s.splitn(2, ":") {
     ///     // ..
@@ -2174,12 +2174,12 @@ declare_clippy_lint! {
     /// These are both harder to read, as well as less performant.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let x: String = std::iter::repeat('x').take(10).collect();
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let x: String = "x".repeat(10);
     /// ```
     #[clippy::version = "1.54.0"]
@@ -2231,13 +2231,13 @@ declare_clippy_lint! {
     /// The function `split` is simpler and there is no performance difference in these cases, considering
     /// that both functions return a lazy iterator.
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let str = "key=value=add";
     /// let _ = str.splitn(3, '=').next().unwrap();
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let str = "key=value=add";
     /// let _ = str.split('=').next().unwrap();
     /// ```
@@ -2261,13 +2261,13 @@ declare_clippy_lint! {
     /// [#8148](https://github.com/rust-lang/rust-clippy/issues/8148).
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let path = std::path::Path::new("x");
     /// foo(&path.to_string_lossy().to_string());
     /// fn foo(s: &str) {}
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let path = std::path::Path::new("x");
     /// foo(&path.to_string_lossy());
     /// fn foo(s: &str) {}
@@ -2286,13 +2286,13 @@ declare_clippy_lint! {
     /// `.collect::<String>()` is more concise and might be more performant
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let vector = vec!["hello",  "world"];
     /// let output = vector.iter().map(|item| item.to_uppercase()).collect::<Vec<String>>().join("");
     /// println!("{}", output);
     /// ```
     /// The correct use would be:
-    /// ```rust
+    /// ```no_run
     /// let vector = vec!["hello",  "world"];
     /// let output = vector.iter().map(|item| item.to_uppercase()).collect::<String>();
     /// println!("{}", output);
@@ -2319,13 +2319,13 @@ declare_clippy_lint! {
     /// Redundant code and improving readability.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let a = Some(&1);
     /// let b = a.as_deref(); // goes from Option<&i32> to Option<&i32>
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let a = Some(&1);
     /// let b = a;
     /// ```
@@ -2345,13 +2345,13 @@ declare_clippy_lint! {
     /// `is_digit(..)` is slower and requires specifying the radix.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let c: char = '6';
     /// c.is_digit(10);
     /// c.is_digit(16);
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let c: char = '6';
     /// c.is_ascii_digit();
     /// c.is_ascii_hexdigit();
@@ -2371,12 +2371,12 @@ declare_clippy_lint! {
     /// In this case the modification is useless as it's a temporary that cannot be read from afterwards.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let x = Some(3);
     /// x.as_ref().take();
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let x = Some(3);
     /// x.as_ref();
     /// ```
@@ -2394,7 +2394,7 @@ declare_clippy_lint! {
     /// It's either a mistake or confusing.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// "1234".replace("12", "12");
     /// "1234".replacen("12", "12", 1);
     /// ```
@@ -2417,12 +2417,12 @@ declare_clippy_lint! {
     /// to account for similar patterns.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let x = true;
     /// x.then_some("a").unwrap_or("b");
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let x = true;
     /// if x { "a" } else { "b" };
     /// ```
@@ -2444,12 +2444,12 @@ declare_clippy_lint! {
     ///
     /// ### Example
     ///
-    /// ```rust
+    /// ```no_run
     /// let a = [123].iter();
     /// let b = Some(123).into_iter();
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// use std::iter;
     /// let a = iter::once(&123);
     /// let b = iter::once(123);
@@ -2475,13 +2475,13 @@ declare_clippy_lint! {
     ///
     /// ### Example
     ///
-    /// ```rust
+    /// ```no_run
     /// use std::{slice, option};
     /// let a: slice::Iter<i32> = [].iter();
     /// let f: option::IntoIter<i32> = None.into_iter();
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// use std::iter;
     /// let a: iter::Empty<i32> = iter::empty();
     /// let b: iter::Empty<i32> = iter::empty();
@@ -2511,7 +2511,7 @@ declare_clippy_lint! {
     /// faster in those cases.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # let vec = vec![1_u8];
     /// let count = vec.iter().filter(|x| **x == 0u8).count();
     /// ```
@@ -2537,12 +2537,12 @@ declare_clippy_lint! {
     /// `str::len()`.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// "hello".bytes().count();
     /// String::from("hello").bytes().count();
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// "hello".len();
     /// String::from("hello").len();
     /// ```
@@ -2561,13 +2561,13 @@ declare_clippy_lint! {
     /// `ends_with` is case-sensitive and may not detect files with a valid extension.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// fn is_rust_file(filename: &str) -> bool {
     ///     filename.ends_with(".rs")
     /// }
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// fn is_rust_file(filename: &str) -> bool {
     ///     let filename = std::path::Path::new(filename);
     ///     filename.extension()
@@ -2590,13 +2590,13 @@ declare_clippy_lint! {
     /// result.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let x = vec![2, 3, 5];
     /// let first_element = x.get(0);
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let x = vec![2, 3, 5];
     /// let first_element = x.first();
     /// ```
@@ -2616,13 +2616,13 @@ declare_clippy_lint! {
     /// Concise code helps focusing on behavior instead of boilerplate.
     ///
     /// ### Examples
-    /// ```rust
+    /// ```no_run
     /// let foo: Option<i32> = None;
     /// foo.map_or(Err("error"), |v| Ok(v));
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let foo: Option<i32> = None;
     /// foo.ok_or("error");
     /// ```
@@ -2642,7 +2642,7 @@ declare_clippy_lint! {
     /// Readability, this can be written more concisely
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let x = vec![42, 43];
     /// let y = x.iter();
     /// let z = y.map(|i| *i);
@@ -2650,7 +2650,7 @@ declare_clippy_lint! {
     ///
     /// The correct use would be:
     ///
-    /// ```rust
+    /// ```no_run
     /// let x = vec![42, 43];
     /// let y = x.iter();
     /// let z = y.cloned();
@@ -2670,7 +2670,7 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// Before:
-    /// ```rust
+    /// ```no_run
     /// use std::fmt;
     ///
     /// #[derive(Debug)]
@@ -2772,7 +2772,7 @@ declare_clippy_lint! {
     /// guarantee.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// use std::sync::{Arc, Mutex};
     ///
     /// let mut value_rc = Arc::new(Mutex::new(42_u8));
@@ -2782,7 +2782,7 @@ declare_clippy_lint! {
     /// *value += 1;
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// use std::sync::{Arc, Mutex};
     ///
     /// let mut value_rc = Arc::new(Mutex::new(42_u8));
@@ -2807,7 +2807,7 @@ declare_clippy_lint! {
     /// necessary. I don't know the worst case.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// use std::fs::OpenOptions;
     ///
     /// OpenOptions::new().read(true).truncate(true);
@@ -2828,7 +2828,7 @@ declare_clippy_lint! {
     /// previous defined path.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// use std::path::PathBuf;
     ///
     /// let mut x = PathBuf::from("/foo");
@@ -2837,7 +2837,7 @@ declare_clippy_lint! {
     /// ```
     /// Could be written:
     ///
-    /// ```rust
+    /// ```no_run
     /// use std::path::PathBuf;
     ///
     /// let mut x = PathBuf::from("/foo");
@@ -2859,13 +2859,13 @@ declare_clippy_lint! {
     /// The code is better expressed with `.enumerate()`.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # let x = vec![1];
     /// let _ = x.iter().zip(0..x.len());
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # let x = vec![1];
     /// let _ = x.iter().enumerate();
     /// ```
@@ -2890,13 +2890,13 @@ declare_clippy_lint! {
     /// the string is the intention behind this, `clone()` should be used.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// fn main() {
     ///     let x = String::from("hello world").repeat(1);
     /// }
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// fn main() {
     ///     let x = String::from("hello world").clone();
     /// }
@@ -2930,12 +2930,12 @@ declare_clippy_lint! {
     /// issue linked above.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let mut vec = vec![2, 1, 3];
     /// vec.sort();
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let mut vec = vec![2, 1, 3];
     /// vec.sort_unstable();
     /// ```
@@ -2963,7 +2963,7 @@ declare_clippy_lint! {
     /// assert_eq!(any_box.type_id(), TypeId::of::<i32>()); // ⚠️ this fails!
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// use std::any::{Any, TypeId};
     ///
     /// let any_box: Box<dyn Any> = Box::new(42_i32);
@@ -2984,7 +2984,7 @@ declare_clippy_lint! {
     /// Hashing a unit value doesn't do anything as the implementation of `Hash` for `()` is a no-op.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # use std::hash::Hash;
     /// # use std::collections::hash_map::DefaultHasher;
     /// # enum Foo { Empty, WithValue(u8) }
@@ -2997,7 +2997,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # use std::hash::Hash;
     /// # use std::collections::hash_map::DefaultHasher;
     /// # enum Foo { Empty, WithValue(u8) }
@@ -3030,14 +3030,14 @@ declare_clippy_lint! {
     /// imported by a use statement, then it will need to be added manually.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # struct A;
     /// # impl A { fn foo(&self) {} }
     /// # let mut vec: Vec<A> = Vec::new();
     /// vec.sort_by(|a, b| a.foo().cmp(&b.foo()));
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # struct A;
     /// # impl A { fn foo(&self) {} }
     /// # let mut vec: Vec<A> = Vec::new();
@@ -3057,12 +3057,12 @@ declare_clippy_lint! {
     /// This is probably an argument inversion mistake.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// vec![1, 2, 3, 4, 5].resize(0, 5)
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// vec![1, 2, 3, 4, 5].clear()
     /// ```
     #[clippy::version = "1.46.0"]
@@ -3111,14 +3111,14 @@ declare_clippy_lint! {
     ///
     /// ### Example
     ///
-    /// ```
+    /// ```no_run
     /// # use std::collections::HashMap;
     /// let map: HashMap<u32, u32> = HashMap::new();
     /// let values = map.iter().map(|(_, value)| value).collect::<Vec<_>>();
     /// ```
     ///
     /// Use instead:
-    /// ```
+    /// ```no_run
     /// # use std::collections::HashMap;
     /// let map: HashMap<u32, u32> = HashMap::new();
     /// let values = map.values().collect::<Vec<_>>();
@@ -3184,14 +3184,14 @@ declare_clippy_lint! {
     /// this exact scenario.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # use std::io;
     /// fn foo<T: io::Seek>(t: &mut T) {
     ///     t.seek(io::SeekFrom::Start(0));
     /// }
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # use std::io;
     /// fn foo<T: io::Seek>(t: &mut T) {
     ///     t.rewind();
@@ -3213,12 +3213,12 @@ declare_clippy_lint! {
     /// when this allocation may not be needed.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # let iterator = vec![1].into_iter();
     /// let len = iterator.collect::<Vec<_>>().len();
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # let iterator = vec![1].into_iter();
     /// let len = iterator.count();
     /// ```
@@ -3241,11 +3241,11 @@ declare_clippy_lint! {
     /// which is likely not what was intended.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// std::process::Command::new("echo").arg("-n hello").spawn().unwrap();
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// std::process::Command::new("echo").args(["-n", "hello"]).spawn().unwrap();
     /// ```
     #[clippy::version = "1.69.0"]
@@ -3264,12 +3264,12 @@ declare_clippy_lint! {
     /// Calling `.clear()` also makes the intent clearer.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let mut v = vec![1, 2, 3];
     /// v.drain(..);
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let mut v = vec![1, 2, 3];
     /// v.clear();
     /// ```
@@ -3287,12 +3287,12 @@ declare_clippy_lint! {
     /// `.next_back()` is cleaner.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # let foo = [0; 10];
     /// foo.iter().rev().next();
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # let foo = [0; 10];
     /// foo.iter().next_back();
     /// ```
@@ -3320,13 +3320,13 @@ declare_clippy_lint! {
     /// to keep the capacity on the original `Vec`.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// fn remove_all(v: &mut Vec<i32>) -> Vec<i32> {
     ///     v.drain(..).collect()
     /// }
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// use std::mem;
     /// fn remove_all(v: &mut Vec<i32>) -> Vec<i32> {
     ///     mem::take(v)
@@ -3354,11 +3354,11 @@ declare_clippy_lint! {
     /// desirable in those cases.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// vec![1, 2, 3].iter().fold(Some(0i32), |sum, i| sum?.checked_add(*i));
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// vec![1, 2, 3].iter().try_fold(0i32, |sum, i| sum.checked_add(*i));
     /// ```
     #[clippy::version = "1.72.0"]
@@ -3410,12 +3410,12 @@ declare_clippy_lint! {
     /// for situations where that additional performance is absolutely necessary.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # let c = 'c';
     /// "\\.+*?()|[]{}^$#&-~".chars().any(|x| x == c);
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # let c = 'c';
     /// matches!(c, '\\' | '.' | '+' | '*' | '(' | ')' | '|' | '[' | ']' | '{' | '}' | '^' | '$' | '#' | '&' | '-' | '~');
     /// ```
@@ -3439,13 +3439,13 @@ declare_clippy_lint! {
     /// so it can be safely ignored or unwrapped.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// fn hex_encode(bytes: &[u8]) -> String {
     ///     bytes.iter().map(|b| format!("{b:02X}")).collect()
     /// }
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// use std::fmt::Write;
     /// fn hex_encode(bytes: &[u8]) -> String {
     ///     bytes.iter().fold(String::new(), |mut output, b| {
@@ -3469,7 +3469,7 @@ declare_clippy_lint! {
     /// nothing. If not, the call should be removed.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let v = vec![1, 2, 3];
     /// let x = v.iter().skip(0).collect::<Vec<_>>();
     /// let y = v.iter().collect::<Vec<_>>();
@@ -3495,13 +3495,13 @@ declare_clippy_lint! {
     /// This can create differing behavior, so better safe than sorry.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # fn really_expensive_fn(i: i32) -> i32 { i }
     /// # let v = vec![];
     /// _ = v.into_iter().filter_map(|i| (i % 2 == 0).then(|| really_expensive_fn(i)));
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # fn really_expensive_fn(i: i32) -> i32 { i }
     /// # let v = vec![];
     /// _ = v.into_iter().filter(|i| i % 2 == 0).map(|i| really_expensive_fn(i));
@@ -3521,7 +3521,7 @@ declare_clippy_lint! {
     /// can access the lock while this writer is active.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// use std::sync::RwLock;
     /// fn assert_is_zero(lock: &RwLock<i32>) {
     ///     let num = lock.write().unwrap();
@@ -3530,7 +3530,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// use std::sync::RwLock;
     /// fn assert_is_zero(lock: &RwLock<i32>) {
     ///     let num = lock.read().unwrap();
@@ -3554,11 +3554,11 @@ declare_clippy_lint! {
     /// This is most likely not what the user intended to do.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// for _ in [1, 2, 3].iter().take(4) {}
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// for _ in [1, 2, 3].iter() {}
     /// ```
     #[clippy::version = "1.74.0"]
@@ -3587,14 +3587,14 @@ declare_clippy_lint! {
     /// therefore ignored.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # use std::path::Path;
     /// fn is_markdown(path: &Path) -> bool {
     ///     path.ends_with(".md")
     /// }
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # use std::path::Path;
     /// fn is_markdown(path: &Path) -> bool {
     ///     path.extension().is_some_and(|ext| ext == "md")
@@ -3614,14 +3614,14 @@ declare_clippy_lint! {
     /// The `as_str()` conversion is pointless and can be removed for simplicity and cleanliness.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # #![allow(unused)]
     /// let owned_string = "This is a string".to_owned();
     /// owned_string.as_str().as_bytes();
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # #![allow(unused)]
     /// let owned_string = "This is a string".to_owned();
     /// owned_string.as_bytes();
diff --git a/clippy_lints/src/methods/str_splitn.rs b/clippy_lints/src/methods/str_splitn.rs
index 7016ad0a80f..5d4b0e53762 100644
--- a/clippy_lints/src/methods/str_splitn.rs
+++ b/clippy_lints/src/methods/str_splitn.rs
@@ -115,7 +115,7 @@ fn check_manual_split_once(
 
 /// checks for
 ///
-/// ```
+/// ```no_run
 /// let mut iter = "a.b.c".splitn(2, '.');
 /// let a = iter.next();
 /// let b = iter.next();
diff --git a/clippy_lints/src/misc.rs b/clippy_lints/src/misc.rs
index 9c8b47fb303..a102b5dfde6 100644
--- a/clippy_lints/src/misc.rs
+++ b/clippy_lints/src/misc.rs
@@ -41,12 +41,12 @@ declare_clippy_lint! {
     /// dereferences, e.g., changing `*x` to `x` within the function.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// fn foo(ref _x: u8) {}
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// fn foo(_x: &u8) {}
     /// ```
     #[clippy::version = "pre 1.29.0"]
@@ -70,7 +70,7 @@ declare_clippy_lint! {
     /// macro, it has been allowed in the mean time.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let _x = 0;
     /// let y = _x + 1; // Here we are using `_x`, even though it has a leading
     ///                 // underscore. We should rename `_x` to `x`
diff --git a/clippy_lints/src/misc_early/mod.rs b/clippy_lints/src/misc_early/mod.rs
index b226b878123..f758cbb47fc 100644
--- a/clippy_lints/src/misc_early/mod.rs
+++ b/clippy_lints/src/misc_early/mod.rs
@@ -28,7 +28,7 @@ declare_clippy_lint! {
     /// the fields that are actually bound.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # struct Foo {
     /// #     a: i32,
     /// #     b: i32,
@@ -43,7 +43,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # struct Foo {
     /// #     a: i32,
     /// #     b: i32,
@@ -71,12 +71,12 @@ declare_clippy_lint! {
     /// It affects code readability.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// fn foo(a: i32, _a: i32) {}
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// fn bar(a: i32, _b: i32) {}
     /// ```
     #[clippy::version = "pre 1.29.0"]
@@ -94,7 +94,7 @@ declare_clippy_lint! {
     /// decremented.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let mut x = 3;
     /// --x;
     /// ```
@@ -113,14 +113,14 @@ declare_clippy_lint! {
     /// It looks confusing.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # let _ =
     /// 0x1a9BAcD
     /// # ;
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # let _ =
     /// 0x1A9BACD
     /// # ;
@@ -142,14 +142,14 @@ declare_clippy_lint! {
     /// Suffix style should be consistent.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # let _ =
     /// 123832i32
     /// # ;
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # let _ =
     /// 123832_i32
     /// # ;
@@ -170,14 +170,14 @@ declare_clippy_lint! {
     /// Suffix style should be consistent.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # let _ =
     /// 123832_i32
     /// # ;
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # let _ =
     /// 123832i32
     /// # ;
@@ -202,7 +202,7 @@ declare_clippy_lint! {
     /// ### Example
     ///
     /// In Rust:
-    /// ```rust
+    /// ```no_run
     /// fn main() {
     ///     let a = 0123;
     ///     println!("{}", a);
@@ -258,7 +258,7 @@ declare_clippy_lint! {
     /// bindings.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # let v = Some("abc");
     /// match v {
     ///     Some(x) => (),
@@ -267,7 +267,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # let v = Some("abc");
     /// match v {
     ///     Some(x) => (),
@@ -295,7 +295,7 @@ declare_clippy_lint! {
     /// can match that element as well.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # struct TupleStruct(u32, u32, u32);
     /// # let t = TupleStruct(1, 2, 3);
     /// match t {
@@ -305,7 +305,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # struct TupleStruct(u32, u32, u32);
     /// # let t = TupleStruct(1, 2, 3);
     /// match t {
diff --git a/clippy_lints/src/mismatching_type_param_order.rs b/clippy_lints/src/mismatching_type_param_order.rs
index 28e041dee0d..0d79ece087f 100644
--- a/clippy_lints/src/mismatching_type_param_order.rs
+++ b/clippy_lints/src/mismatching_type_param_order.rs
@@ -24,7 +24,7 @@ declare_clippy_lint! {
     /// ignored.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// struct Foo<A, B> {
     ///     x: A,
     ///     y: B,
@@ -33,7 +33,7 @@ declare_clippy_lint! {
     /// impl<B, A> Foo<B, A> {}
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// struct Foo<A, B> {
     ///     x: A,
     ///     y: B,
diff --git a/clippy_lints/src/missing_assert_message.rs b/clippy_lints/src/missing_assert_message.rs
index 136947a2c8c..4e00215c5cb 100644
--- a/clippy_lints/src/missing_assert_message.rs
+++ b/clippy_lints/src/missing_assert_message.rs
@@ -27,14 +27,14 @@ declare_clippy_lint! {
     /// don't provide any extra information.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # struct Service { ready: bool }
     /// fn call(service: Service) {
     ///     assert!(service.ready);
     /// }
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # struct Service { ready: bool }
     /// fn call(service: Service) {
     ///     assert!(service.ready, "`service.poll_ready()` must be called first to ensure that service is ready to receive requests");
diff --git a/clippy_lints/src/missing_asserts_for_indexing.rs b/clippy_lints/src/missing_asserts_for_indexing.rs
index 08fec2b8ec8..094939f862e 100644
--- a/clippy_lints/src/missing_asserts_for_indexing.rs
+++ b/clippy_lints/src/missing_asserts_for_indexing.rs
@@ -43,14 +43,14 @@ declare_clippy_lint! {
     /// about the length of a slice, but this lint will not detect that.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// fn sum(v: &[u8]) -> u8 {
     ///     // 4 bounds checks
     ///     v[0] + v[1] + v[2] + v[3]
     /// }
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// fn sum(v: &[u8]) -> u8 {
     ///     assert!(v.len() > 4);
     ///     // no bounds checks
diff --git a/clippy_lints/src/missing_const_for_fn.rs b/clippy_lints/src/missing_const_for_fn.rs
index f598a65d2e4..b39f1de0b41 100644
--- a/clippy_lints/src/missing_const_for_fn.rs
+++ b/clippy_lints/src/missing_const_for_fn.rs
@@ -27,7 +27,7 @@ declare_clippy_lint! {
     ///
     /// Also, the lint only runs one pass over the code. Consider these two non-const functions:
     ///
-    /// ```rust
+    /// ```no_run
     /// fn a() -> i32 {
     ///     0
     /// }
@@ -42,7 +42,7 @@ declare_clippy_lint! {
     ///
     /// If you are marking a public function with `const`, removing it again will break API compatibility.
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # struct Foo {
     /// #     random_number: usize,
     /// # }
@@ -55,7 +55,7 @@ declare_clippy_lint! {
     ///
     /// Could be a const fn:
     ///
-    /// ```rust
+    /// ```no_run
     /// # struct Foo {
     /// #     random_number: usize,
     /// # }
diff --git a/clippy_lints/src/missing_fields_in_debug.rs b/clippy_lints/src/missing_fields_in_debug.rs
index d205237a591..95f9df4e42a 100644
--- a/clippy_lints/src/missing_fields_in_debug.rs
+++ b/clippy_lints/src/missing_fields_in_debug.rs
@@ -40,7 +40,7 @@ declare_clippy_lint! {
     /// making it much less likely to accidentally forget to update the `Debug` impl when adding a new variant.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// use std::fmt;
     /// struct Foo {
     ///     data: String,
@@ -57,7 +57,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// use std::fmt;
     /// struct Foo {
     ///     data: String,
diff --git a/clippy_lints/src/missing_inline.rs b/clippy_lints/src/missing_inline.rs
index 93f6025c71d..0346d80c676 100644
--- a/clippy_lints/src/missing_inline.rs
+++ b/clippy_lints/src/missing_inline.rs
@@ -21,7 +21,7 @@ declare_clippy_lint! {
     /// then opt out for specific methods where this might not make sense.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// pub fn foo() {} // missing #[inline]
     /// fn ok() {} // ok
     /// #[inline] pub fn bar() {} // ok
diff --git a/clippy_lints/src/missing_trait_methods.rs b/clippy_lints/src/missing_trait_methods.rs
index 1adecd2caac..ad5f45a3280 100644
--- a/clippy_lints/src/missing_trait_methods.rs
+++ b/clippy_lints/src/missing_trait_methods.rs
@@ -21,7 +21,7 @@ declare_clippy_lint! {
     /// Indicates that a method is missing.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// trait Trait {
     ///     fn required();
     ///
@@ -35,7 +35,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// trait Trait {
     ///     fn required();
     ///
diff --git a/clippy_lints/src/mixed_read_write_in_expression.rs b/clippy_lints/src/mixed_read_write_in_expression.rs
index e87aea263d4..215161b04c7 100644
--- a/clippy_lints/src/mixed_read_write_in_expression.rs
+++ b/clippy_lints/src/mixed_read_write_in_expression.rs
@@ -22,7 +22,7 @@ declare_clippy_lint! {
     /// order, or which is correct for any evaluation order.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let mut x = 0;
     ///
     /// let a = {
@@ -33,7 +33,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # let mut x = 0;
     /// let tmp = {
     ///     x = 1;
diff --git a/clippy_lints/src/multi_assignments.rs b/clippy_lints/src/multi_assignments.rs
index 81eb1a085ae..b42dce7a13a 100644
--- a/clippy_lints/src/multi_assignments.rs
+++ b/clippy_lints/src/multi_assignments.rs
@@ -13,12 +13,12 @@ declare_clippy_lint! {
     /// where such assignments return a copy of the assigned value.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     ///# let (a, b);
     /// a = b = 42;
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     ///# let (a, b);
     /// b = 42;
     /// a = b;
diff --git a/clippy_lints/src/multiple_unsafe_ops_per_block.rs b/clippy_lints/src/multiple_unsafe_ops_per_block.rs
index 2c42a7a3676..d4f8008aece 100644
--- a/clippy_lints/src/multiple_unsafe_ops_per_block.rs
+++ b/clippy_lints/src/multiple_unsafe_ops_per_block.rs
@@ -22,7 +22,7 @@ declare_clippy_lint! {
     /// elimination of unnecessary unsafe blocks through refactoring.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// /// Reads a `char` from the given pointer.
     /// ///
     /// /// # Safety
@@ -36,7 +36,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// /// Reads a `char` from the given pointer.
     /// ///
     /// /// # Safety
diff --git a/clippy_lints/src/mut_key.rs b/clippy_lints/src/mut_key.rs
index 5878f899541..683ff859d37 100644
--- a/clippy_lints/src/mut_key.rs
+++ b/clippy_lints/src/mut_key.rs
@@ -47,7 +47,7 @@ declare_clippy_lint! {
     /// [#6745](https://github.com/rust-lang/rust-clippy/issues/6745).
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// use std::cmp::{PartialEq, Eq};
     /// use std::collections::HashSet;
     /// use std::hash::{Hash, Hasher};
diff --git a/clippy_lints/src/mut_mut.rs b/clippy_lints/src/mut_mut.rs
index 64d8333a093..6989504a4a9 100644
--- a/clippy_lints/src/mut_mut.rs
+++ b/clippy_lints/src/mut_mut.rs
@@ -17,7 +17,7 @@ declare_clippy_lint! {
     /// misunderstanding of references.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # let mut y = 1;
     /// let x = &mut &mut y;
     /// ```
diff --git a/clippy_lints/src/mut_reference.rs b/clippy_lints/src/mut_reference.rs
index 01b850cdb11..4f8e244222d 100644
--- a/clippy_lints/src/mut_reference.rs
+++ b/clippy_lints/src/mut_reference.rs
@@ -15,14 +15,14 @@ declare_clippy_lint! {
     /// the value. Also the code misleads about the intent of the call site.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # let mut vec = Vec::new();
     /// # let mut value = 5;
     /// vec.push(&mut value);
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # let mut vec = Vec::new();
     /// # let value = 5;
     /// vec.push(&value);
diff --git a/clippy_lints/src/mutex_atomic.rs b/clippy_lints/src/mutex_atomic.rs
index 99394b9e5fb..9d8c06cd077 100644
--- a/clippy_lints/src/mutex_atomic.rs
+++ b/clippy_lints/src/mutex_atomic.rs
@@ -29,14 +29,14 @@ declare_clippy_lint! {
     /// for waiting before a critical section.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # let y = true;
     /// # use std::sync::Mutex;
     /// let x = Mutex::new(&y);
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # let y = true;
     /// # use std::sync::atomic::AtomicBool;
     /// let x = AtomicBool::new(y);
@@ -62,13 +62,13 @@ declare_clippy_lint! {
     /// for waiting before a critical section.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # use std::sync::Mutex;
     /// let x = Mutex::new(0usize);
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # use std::sync::atomic::AtomicUsize;
     /// let x = AtomicUsize::new(0usize);
     /// ```
diff --git a/clippy_lints/src/needless_arbitrary_self_type.rs b/clippy_lints/src/needless_arbitrary_self_type.rs
index 5457eeec4ea..97e8f1c030a 100644
--- a/clippy_lints/src/needless_arbitrary_self_type.rs
+++ b/clippy_lints/src/needless_arbitrary_self_type.rs
@@ -15,7 +15,7 @@ declare_clippy_lint! {
     /// Increases the amount and decreases the readability of code
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// enum ValType {
     ///     I32,
     ///     I64,
@@ -35,7 +35,7 @@ declare_clippy_lint! {
     ///
     /// Could be rewritten as
     ///
-    /// ```rust
+    /// ```no_run
     /// enum ValType {
     ///     I32,
     ///     I64,
diff --git a/clippy_lints/src/needless_bool.rs b/clippy_lints/src/needless_bool.rs
index f6b87b071b9..025eba2d166 100644
--- a/clippy_lints/src/needless_bool.rs
+++ b/clippy_lints/src/needless_bool.rs
@@ -32,7 +32,7 @@ declare_clippy_lint! {
     /// shorter code.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # let x = true;
     /// if x {
     ///     false
@@ -43,7 +43,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # let x = true;
     /// !x
     /// # ;
diff --git a/clippy_lints/src/needless_borrowed_ref.rs b/clippy_lints/src/needless_borrowed_ref.rs
index 11bf9e9ca17..fdb91f0dc0d 100644
--- a/clippy_lints/src/needless_borrowed_ref.rs
+++ b/clippy_lints/src/needless_borrowed_ref.rs
@@ -13,7 +13,7 @@ declare_clippy_lint! {
     /// This pattern has no effect in almost all cases.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let mut v = Vec::<String>::new();
     /// v.iter_mut().filter(|&ref a| a.is_empty());
     ///
@@ -21,7 +21,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let mut v = Vec::<String>::new();
     /// v.iter_mut().filter(|a| a.is_empty());
     ///
diff --git a/clippy_lints/src/needless_borrows_for_generic_args.rs b/clippy_lints/src/needless_borrows_for_generic_args.rs
index d55c77a92b1..542b81f3a12 100644
--- a/clippy_lints/src/needless_borrows_for_generic_args.rs
+++ b/clippy_lints/src/needless_borrows_for_generic_args.rs
@@ -36,7 +36,7 @@ declare_clippy_lint! {
     /// in such a case can change the semantics of the code.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// fn f(_: impl AsRef<str>) {}
     ///
     /// let x = "foo";
@@ -44,7 +44,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// fn f(_: impl AsRef<str>) {}
     ///
     /// let x = "foo";
diff --git a/clippy_lints/src/needless_continue.rs b/clippy_lints/src/needless_continue.rs
index 377cbef7b99..cb2738947d4 100644
--- a/clippy_lints/src/needless_continue.rs
+++ b/clippy_lints/src/needless_continue.rs
@@ -55,7 +55,7 @@ declare_clippy_lint! {
     /// statement within the THEN block and omitting the else block completely.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # fn condition() -> bool { false }
     /// # fn update_condition() {}
     /// # let x = false;
@@ -72,7 +72,7 @@ declare_clippy_lint! {
     ///
     /// Could be rewritten as
     ///
-    /// ```rust
+    /// ```no_run
     /// # fn condition() -> bool { false }
     /// # fn update_condition() {}
     /// # let x = false;
@@ -87,7 +87,7 @@ declare_clippy_lint! {
     ///
     /// As another example, the following code
     ///
-    /// ```rust
+    /// ```no_run
     /// # fn waiting() -> bool { false }
     /// loop {
     ///     if waiting() {
@@ -100,7 +100,7 @@ declare_clippy_lint! {
     /// ```
     /// Could be rewritten as
     ///
-    /// ```rust
+    /// ```no_run
     /// # fn waiting() -> bool { false }
     /// loop {
     ///     if waiting() {
@@ -408,7 +408,7 @@ fn check_and_warn(cx: &EarlyContext<'_>, expr: &ast::Expr) {
 /// till a non-whitespace character is found.  e.g., the string. If no closing `}` is present, the
 /// string will be preserved.
 ///
-/// ```rust
+/// ```no_run
 /// {
 ///     let x = 5;
 /// }
diff --git a/clippy_lints/src/needless_else.rs b/clippy_lints/src/needless_else.rs
index 0c1fe881fc1..d881c13f84a 100644
--- a/clippy_lints/src/needless_else.rs
+++ b/clippy_lints/src/needless_else.rs
@@ -13,7 +13,7 @@ declare_clippy_lint! {
     /// An empty else branch does nothing and can be removed.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     ///# fn check() -> bool { true }
     /// if check() {
     ///     println!("Check successful!");
@@ -21,7 +21,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     ///# fn check() -> bool { true }
     /// if check() {
     ///     println!("Check successful!");
diff --git a/clippy_lints/src/needless_for_each.rs b/clippy_lints/src/needless_for_each.rs
index 98bf122fab7..086c8e6fffe 100644
--- a/clippy_lints/src/needless_for_each.rs
+++ b/clippy_lints/src/needless_for_each.rs
@@ -25,14 +25,14 @@ declare_clippy_lint! {
     /// But when none of these apply, a simple `for` loop is more idiomatic.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let v = vec![0, 1, 2];
     /// v.iter().for_each(|elem| {
     ///     println!("{}", elem);
     /// })
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let v = vec![0, 1, 2];
     /// for elem in v.iter() {
     ///     println!("{}", elem);
diff --git a/clippy_lints/src/needless_late_init.rs b/clippy_lints/src/needless_late_init.rs
index 948454d13ae..c8888c744b6 100644
--- a/clippy_lints/src/needless_late_init.rs
+++ b/clippy_lints/src/needless_late_init.rs
@@ -22,7 +22,7 @@ declare_clippy_lint! {
     /// Assigning in the `let` statement is less repetitive.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let a;
     /// a = 1;
     ///
@@ -41,7 +41,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let a = 1;
     ///
     /// let b = match 3 {
diff --git a/clippy_lints/src/needless_parens_on_range_literals.rs b/clippy_lints/src/needless_parens_on_range_literals.rs
index d17a383e882..15589680220 100644
--- a/clippy_lints/src/needless_parens_on_range_literals.rs
+++ b/clippy_lints/src/needless_parens_on_range_literals.rs
@@ -20,7 +20,7 @@ declare_clippy_lint! {
   ///
   /// ### Example
   ///
-  /// ```rust
+  /// ```no_run
   /// for i in (0)..10 {
   ///   println!("{i}");
   /// }
@@ -28,7 +28,7 @@ declare_clippy_lint! {
   ///
   /// Use instead:
   ///
-  /// ```rust
+  /// ```no_run
   /// for i in 0..10 {
   ///   println!("{i}");
   /// }
diff --git a/clippy_lints/src/needless_pass_by_ref_mut.rs b/clippy_lints/src/needless_pass_by_ref_mut.rs
index 1d5874f6fea..efb218cd316 100644
--- a/clippy_lints/src/needless_pass_by_ref_mut.rs
+++ b/clippy_lints/src/needless_pass_by_ref_mut.rs
@@ -37,13 +37,13 @@ declare_clippy_lint! {
     /// opportunities for parallelization.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// fn foo(y: &mut i32) -> i32 {
     ///     12 + *y
     /// }
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// fn foo(y: &i32) -> i32 {
     ///     12 + *y
     /// }
diff --git a/clippy_lints/src/needless_pass_by_value.rs b/clippy_lints/src/needless_pass_by_value.rs
index f3c0d616473..8fa461ac12c 100644
--- a/clippy_lints/src/needless_pass_by_value.rs
+++ b/clippy_lints/src/needless_pass_by_value.rs
@@ -43,13 +43,13 @@ declare_clippy_lint! {
     /// (by using `Borrow` trait, for example), depending on how the function is used.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// fn foo(v: Vec<i32>) {
     ///     assert_eq!(v.len(), 42);
     /// }
     /// ```
     /// should be
-    /// ```rust
+    /// ```no_run
     /// fn foo(v: &[i32]) {
     ///     assert_eq!(v.len(), 42);
     /// }
diff --git a/clippy_lints/src/needless_question_mark.rs b/clippy_lints/src/needless_question_mark.rs
index ed279a3813d..b783edd346a 100644
--- a/clippy_lints/src/needless_question_mark.rs
+++ b/clippy_lints/src/needless_question_mark.rs
@@ -16,7 +16,7 @@ declare_clippy_lint! {
     /// There's no reason to use `?` to short-circuit when execution of the body will end there anyway.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// struct TO {
     ///     magic: Option<usize>,
     /// }
@@ -35,7 +35,7 @@ declare_clippy_lint! {
     ///
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// struct TO {
     ///     magic: Option<usize>,
     /// }
diff --git a/clippy_lints/src/needless_update.rs b/clippy_lints/src/needless_update.rs
index 0bd29d1776b..f8888d36878 100644
--- a/clippy_lints/src/needless_update.rs
+++ b/clippy_lints/src/needless_update.rs
@@ -17,7 +17,7 @@ declare_clippy_lint! {
     /// somewhere), and make the code less readable.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # struct Point {
     /// #     x: i32,
     /// #     y: i32,
diff --git a/clippy_lints/src/neg_cmp_op_on_partial_ord.rs b/clippy_lints/src/neg_cmp_op_on_partial_ord.rs
index a022fc156fc..56c67406d6f 100644
--- a/clippy_lints/src/neg_cmp_op_on_partial_ord.rs
+++ b/clippy_lints/src/neg_cmp_op_on_partial_ord.rs
@@ -18,7 +18,7 @@ declare_clippy_lint! {
     /// especially easy to miss if the operator based comparison result is negated.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let a = 1.0;
     /// let b = f64::NAN;
     ///
@@ -26,7 +26,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// use std::cmp::Ordering;
     /// # let a = 1.0;
     /// # let b = f64::NAN;
diff --git a/clippy_lints/src/no_effect.rs b/clippy_lints/src/no_effect.rs
index aee184252fb..60b40aecafa 100644
--- a/clippy_lints/src/no_effect.rs
+++ b/clippy_lints/src/no_effect.rs
@@ -23,7 +23,7 @@ declare_clippy_lint! {
     /// readable.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// 0;
     /// ```
     #[clippy::version = "pre 1.29.0"]
diff --git a/clippy_lints/src/no_mangle_with_rust_abi.rs b/clippy_lints/src/no_mangle_with_rust_abi.rs
index 8fd9ae351a0..f2a7debc930 100644
--- a/clippy_lints/src/no_mangle_with_rust_abi.rs
+++ b/clippy_lints/src/no_mangle_with_rust_abi.rs
@@ -18,13 +18,13 @@ declare_clippy_lint! {
     /// Rust ABI can break this at any point.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     ///  #[no_mangle]
     ///  fn example(arg_one: u32, arg_two: usize) {}
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     ///  #[no_mangle]
     ///  extern "C" fn example(arg_one: u32, arg_two: usize) {}
     /// ```
diff --git a/clippy_lints/src/non_canonical_impls.rs b/clippy_lints/src/non_canonical_impls.rs
index 0e4b6aa1b7d..427e636bdf8 100644
--- a/clippy_lints/src/non_canonical_impls.rs
+++ b/clippy_lints/src/non_canonical_impls.rs
@@ -64,7 +64,7 @@ declare_clippy_lint! {
     /// in `Some`.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # use std::cmp::Ordering;
     /// #[derive(Eq, PartialEq)]
     /// struct A(u32);
@@ -84,7 +84,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # use std::cmp::Ordering;
     /// #[derive(Eq, PartialEq)]
     /// struct A(u32);
diff --git a/clippy_lints/src/non_copy_const.rs b/clippy_lints/src/non_copy_const.rs
index 613afa46a91..54cec066ba1 100644
--- a/clippy_lints/src/non_copy_const.rs
+++ b/clippy_lints/src/non_copy_const.rs
@@ -58,7 +58,7 @@ declare_clippy_lint! {
     /// [#5812](https://github.com/rust-lang/rust-clippy/issues/5812) and
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// use std::sync::atomic::{AtomicUsize, Ordering::SeqCst};
     ///
     /// const CONST_ATOM: AtomicUsize = AtomicUsize::new(12);
@@ -67,7 +67,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # use std::sync::atomic::{AtomicUsize, Ordering::SeqCst};
     /// static STATIC_ATOM: AtomicUsize = AtomicUsize::new(15);
     /// STATIC_ATOM.store(9, SeqCst);
@@ -105,7 +105,7 @@ declare_clippy_lint! {
     /// [#3825](https://github.com/rust-lang/rust-clippy/issues/3825)
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// use std::sync::atomic::{AtomicUsize, Ordering::SeqCst};
     /// const CONST_ATOM: AtomicUsize = AtomicUsize::new(12);
     ///
@@ -114,7 +114,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// use std::sync::atomic::{AtomicUsize, Ordering::SeqCst};
     /// const CONST_ATOM: AtomicUsize = AtomicUsize::new(12);
     ///
diff --git a/clippy_lints/src/non_expressive_names.rs b/clippy_lints/src/non_expressive_names.rs
index d562047cbf1..182d3747f78 100644
--- a/clippy_lints/src/non_expressive_names.rs
+++ b/clippy_lints/src/non_expressive_names.rs
@@ -63,7 +63,7 @@ declare_clippy_lint! {
     /// descriptive name.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let _1 = 1;
     /// let ___1 = 1;
     /// let __1___2 = 11;
diff --git a/clippy_lints/src/nonstandard_macro_braces.rs b/clippy_lints/src/nonstandard_macro_braces.rs
index bd194b93584..35d06897eb4 100644
--- a/clippy_lints/src/nonstandard_macro_braces.rs
+++ b/clippy_lints/src/nonstandard_macro_braces.rs
@@ -23,11 +23,11 @@ declare_clippy_lint! {
     /// doesn't give you a semicolon in item position, which can be unexpected.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// vec!{1, 2, 3};
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// vec![1, 2, 3];
     /// ```
     #[clippy::version = "1.55.0"]
diff --git a/clippy_lints/src/octal_escapes.rs b/clippy_lints/src/octal_escapes.rs
index 6d3865080a6..0faf4ce3d3e 100644
--- a/clippy_lints/src/octal_escapes.rs
+++ b/clippy_lints/src/octal_escapes.rs
@@ -32,13 +32,13 @@ declare_clippy_lint! {
     /// can see it.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let one = "\033[1m Bold? \033[0m";  // \033 intended as escape
     /// let two = "\033\0";                 // \033 intended as null-3-3
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let one = "\x1b[1mWill this be bold?\x1b[0m";
     /// let two = "\x0033\x00";
     /// ```
diff --git a/clippy_lints/src/only_used_in_recursion.rs b/clippy_lints/src/only_used_in_recursion.rs
index f0f8d510c7e..abc8927909b 100644
--- a/clippy_lints/src/only_used_in_recursion.rs
+++ b/clippy_lints/src/only_used_in_recursion.rs
@@ -30,7 +30,7 @@ declare_clippy_lint! {
     ///
     /// In some cases, this would not catch all useless arguments.
     ///
-    /// ```rust
+    /// ```no_run
     /// fn foo(a: usize, b: usize) -> usize {
     ///     let f = |x| x + 1;
     ///
@@ -53,7 +53,7 @@ declare_clippy_lint! {
     /// Also, when you recurse the function name with path segments, it is not possible to detect.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// fn f(a: usize, b: usize) -> usize {
     ///     if a == 0 {
     ///         1
@@ -66,7 +66,7 @@ declare_clippy_lint! {
     /// # }
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// fn f(a: usize) -> usize {
     ///     if a == 0 {
     ///         1
diff --git a/clippy_lints/src/operators/mod.rs b/clippy_lints/src/operators/mod.rs
index 6b247cf5f6a..ee79ea27689 100644
--- a/clippy_lints/src/operators/mod.rs
+++ b/clippy_lints/src/operators/mod.rs
@@ -48,7 +48,7 @@ declare_clippy_lint! {
     /// like `#[cfg(target_pointer_width = "64")] ..` instead.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let vec: Vec<isize> = Vec::new();
     /// if vec.len() <= 0 {}
     /// if 100 > i32::MAX {}
@@ -76,7 +76,7 @@ declare_clippy_lint! {
     /// desirable to explicitly call checked, wrapping or saturating arithmetic methods.
     ///
     /// #### Example
-    /// ```rust
+    /// ```no_run
     /// // `n` can be any number, including `i32::MAX`.
     /// fn foo(n: i32) -> i32 {
     ///   n + 1
@@ -105,7 +105,7 @@ declare_clippy_lint! {
     /// can be useful to rule out floating-point numbers.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # let a = 0.0;
     /// a + 1.0;
     /// ```
@@ -128,7 +128,7 @@ declare_clippy_lint! {
     /// implementations that differ from the regular `Op` impl.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let mut a = 5;
     /// let b = 0;
     /// // ...
@@ -137,7 +137,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let mut a = 5;
     /// let b = 0;
     /// // ...
@@ -165,7 +165,7 @@ declare_clippy_lint! {
     /// written as `a = a op a op b` as it's less confusing.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let mut a = 5;
     /// let b = 2;
     /// // ...
@@ -205,7 +205,7 @@ declare_clippy_lint! {
     /// test-case for this lint.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # let x = 1;
     /// if (x & 1 == 2) { }
     /// ```
@@ -238,7 +238,7 @@ declare_clippy_lint! {
     /// uncommon).
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # let x = 1;
     /// if (x | 1 > 3) {  }
     /// ```
@@ -261,7 +261,7 @@ declare_clippy_lint! {
     /// llvm generates better code for `x & 15 == 0` on x86
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # let x = 1;
     /// if x & 0b1111 == 0 { }
     /// ```
@@ -280,7 +280,7 @@ declare_clippy_lint! {
     /// Readability.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # let x = 1;
     /// # let y = 2;
     /// if x == y || x < y {}
@@ -288,7 +288,7 @@ declare_clippy_lint! {
     ///
     /// Use instead:
     ///
-    /// ```rust
+    /// ```no_run
     /// # let x = 1;
     /// # let y = 2;
     /// if x <= y {}
@@ -308,7 +308,7 @@ declare_clippy_lint! {
     /// which is probably not the programmer's intention
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # let status_code = 200;
     /// if status_code <= 400 && status_code > 500 {}
     /// ```
@@ -328,7 +328,7 @@ declare_clippy_lint! {
     /// different value entirely.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # let status_code = 200;
     /// if status_code <= 400 && status_code < 500 {}
     /// ```
@@ -348,7 +348,7 @@ declare_clippy_lint! {
     /// `Duration::subsec_millis()` than to calculate them.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # use std::time::Duration;
     /// # let duration = Duration::new(5, 0);
     /// let micros = duration.subsec_nanos() / 1_000;
@@ -356,7 +356,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # use std::time::Duration;
     /// # let duration = Duration::new(5, 0);
     /// let micros = duration.subsec_micros();
@@ -384,7 +384,7 @@ declare_clippy_lint! {
     /// calls. We may introduce a list of known pure functions in the future.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # let x = 1;
     /// if x + 1 == x + 1 {}
     ///
@@ -434,7 +434,7 @@ declare_clippy_lint! {
     /// corrected
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let x = 1;
     /// 0 / x;
     /// 0 * x;
@@ -462,13 +462,13 @@ declare_clippy_lint! {
     /// with an allow.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// pub fn is_roughly_equal(a: f32, b: f32) -> bool {
     ///     (a - b) < f32::EPSILON
     /// }
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// pub fn is_roughly_equal(a: f32, b: f32) -> bool {
     ///     (a - b).abs() < f32::EPSILON
     /// }
@@ -488,7 +488,7 @@ declare_clippy_lint! {
     /// meaning. So it just obscures what's going on. Delete it mercilessly.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # let x = 1;
     /// x / 1 + 0 * 1 - 0 | 0;
     /// ```
@@ -508,13 +508,13 @@ declare_clippy_lint! {
     /// remainder.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let x = 3 / 2;
     /// println!("{}", x);
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let x = 3f32 / 2f32;
     /// println!("{}", x);
     /// ```
@@ -535,14 +535,14 @@ declare_clippy_lint! {
     /// needlessly consuming code and heap space.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # let x = "foo";
     /// # let y = String::from("foo");
     /// if x.to_owned() == y {}
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # let x = "foo";
     /// # let y = String::from("foo");
     /// if x == y {}
@@ -566,7 +566,7 @@ declare_clippy_lint! {
     /// guide](http://www.floating-point-gui.de/errors/comparison).
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let x = 1.2331f64;
     /// let y = 1.2332f64;
     ///
@@ -575,7 +575,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # let x = 1.2331f64;
     /// # let y = 1.2332f64;
     /// let error_margin = f64::EPSILON; // Use an epsilon for comparison
@@ -603,7 +603,7 @@ declare_clippy_lint! {
     /// guide](http://www.floating-point-gui.de/errors/comparison).
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let x: f64 = 1.0;
     /// const ONE: f64 = 1.00;
     ///
@@ -611,7 +611,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # let x: f64 = 1.0;
     /// # const ONE: f64 = 1.00;
     /// let error_margin = f64::EPSILON; // Use an epsilon for comparison
@@ -638,7 +638,7 @@ declare_clippy_lint! {
     /// contest, it's probably a bad idea. Use something more underhanded.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # let x = 1;
     /// let a = x % 1;
     /// let a = x % -1;
@@ -662,7 +662,7 @@ declare_clippy_lint! {
     /// For example, in Rust `17 % -3 = 2`, but in Python `17 % -3 = -1`.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let x = -17 % 3;
     /// ```
     #[clippy::version = "1.42.0"]
@@ -685,12 +685,12 @@ declare_clippy_lint! {
     /// determination is quite conservative.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let (x,y) = (true, false);
     /// if x & !y {} // where both x and y are booleans
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let (x,y) = (true, false);
     /// if x && !y {}
     /// ```
@@ -710,14 +710,14 @@ declare_clippy_lint! {
     /// comparing the values they point to.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let a = &[1, 2, 3];
     /// let b = &[1, 2, 3];
     ///
     /// assert!(a as *const _ as usize == b as *const _ as usize);
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let a = &[1, 2, 3];
     /// let b = &[1, 2, 3];
     ///
@@ -742,7 +742,7 @@ declare_clippy_lint! {
     /// indexing operations they are assumed not to have any side effects.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// struct Event {
     ///     x: i32,
     /// }
@@ -753,7 +753,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Should be:
-    /// ```rust
+    /// ```no_run
     /// struct Event {
     ///     x: i32,
     /// }
diff --git a/clippy_lints/src/option_if_let_else.rs b/clippy_lints/src/option_if_let_else.rs
index a7a7f4fd8fa..022053f5e7d 100644
--- a/clippy_lints/src/option_if_let_else.rs
+++ b/clippy_lints/src/option_if_let_else.rs
@@ -32,7 +32,7 @@ declare_clippy_lint! {
     /// this lint will not be raised.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # let optional: Option<u32> = Some(0);
     /// # fn do_complicated_function() -> u32 { 5 };
     /// let _ = if let Some(foo) = optional {
@@ -54,7 +54,7 @@ declare_clippy_lint! {
     ///
     /// should be
     ///
-    /// ```rust
+    /// ```no_run
     /// # let optional: Option<u32> = Some(0);
     /// # fn do_complicated_function() -> u32 { 5 };
     /// let _ = optional.map_or(5, |foo| foo);
diff --git a/clippy_lints/src/overflow_check_conditional.rs b/clippy_lints/src/overflow_check_conditional.rs
index 6dabbd48031..38cd5043adc 100644
--- a/clippy_lints/src/overflow_check_conditional.rs
+++ b/clippy_lints/src/overflow_check_conditional.rs
@@ -14,7 +14,7 @@ declare_clippy_lint! {
     /// Rust. Users can use functions like `overflowing_*` and `wrapping_*` instead.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # let a = 1;
     /// # let b = 2;
     /// a + b < a;
diff --git a/clippy_lints/src/panic_in_result_fn.rs b/clippy_lints/src/panic_in_result_fn.rs
index a049427d85d..6a760f9fe64 100644
--- a/clippy_lints/src/panic_in_result_fn.rs
+++ b/clippy_lints/src/panic_in_result_fn.rs
@@ -22,14 +22,14 @@ declare_clippy_lint! {
     /// Functions called from a function returning a `Result` may invoke a panicking macro. This is not checked.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// fn result_with_panic() -> Result<bool, String>
     /// {
     ///     panic!("error");
     /// }
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// fn result_without_panic() -> Result<bool, String> {
     ///     Err(String::from("error"))
     /// }
diff --git a/clippy_lints/src/partial_pub_fields.rs b/clippy_lints/src/partial_pub_fields.rs
index f60d9d65b12..99ba55b6b31 100644
--- a/clippy_lints/src/partial_pub_fields.rs
+++ b/clippy_lints/src/partial_pub_fields.rs
@@ -16,7 +16,7 @@ declare_clippy_lint! {
     /// * Data: relatively simple objects which group a bunch of related attributes together.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// pub struct Color {
     ///     pub r: u8,
     ///     pub g: u8,
@@ -24,7 +24,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// pub struct Color {
     ///     pub r: u8,
     ///     pub g: u8,
diff --git a/clippy_lints/src/partialeq_ne_impl.rs b/clippy_lints/src/partialeq_ne_impl.rs
index a8c4823fe53..68d3d00ac16 100644
--- a/clippy_lints/src/partialeq_ne_impl.rs
+++ b/clippy_lints/src/partialeq_ne_impl.rs
@@ -16,7 +16,7 @@ declare_clippy_lint! {
     /// re-implement it.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// struct Foo;
     ///
     /// impl PartialEq for Foo {
diff --git a/clippy_lints/src/partialeq_to_none.rs b/clippy_lints/src/partialeq_to_none.rs
index d9f5d1642d7..11e9a2bc394 100644
--- a/clippy_lints/src/partialeq_to_none.rs
+++ b/clippy_lints/src/partialeq_to_none.rs
@@ -21,13 +21,13 @@ declare_clippy_lint! {
     /// way relies on `T: PartialEq` to do the comparison, which is unneeded.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// fn foo(f: Option<u32>) -> &'static str {
     ///     if f != None { "yay" } else { "nay" }
     /// }
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// fn foo(f: Option<u32>) -> &'static str {
     ///     if f.is_some() { "yay" } else { "nay" }
     /// }
diff --git a/clippy_lints/src/pass_by_ref_or_value.rs b/clippy_lints/src/pass_by_ref_or_value.rs
index 41513647f05..4814b3cd661 100644
--- a/clippy_lints/src/pass_by_ref_or_value.rs
+++ b/clippy_lints/src/pass_by_ref_or_value.rs
@@ -58,12 +58,12 @@ declare_clippy_lint! {
     ///
     /// ### Example
     ///
-    /// ```rust
+    /// ```no_run
     /// fn foo(v: &u32) {}
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// fn foo(v: u32) {}
     /// ```
     #[clippy::version = "pre 1.29.0"]
@@ -86,7 +86,7 @@ declare_clippy_lint! {
     /// `memcpy`, which can be expensive.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// #[derive(Clone, Copy)]
     /// struct TooLarge([u8; 2048]);
     ///
@@ -94,7 +94,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # #[derive(Clone, Copy)]
     /// # struct TooLarge([u8; 2048]);
     /// fn foo(v: &TooLarge) {}
diff --git a/clippy_lints/src/permissions_set_readonly_false.rs b/clippy_lints/src/permissions_set_readonly_false.rs
index f3089d716ff..bca8d0b6be8 100644
--- a/clippy_lints/src/permissions_set_readonly_false.rs
+++ b/clippy_lints/src/permissions_set_readonly_false.rs
@@ -14,7 +14,7 @@ declare_clippy_lint! {
     /// On Unix platforms this results in the file being world writable,
     /// equivalent to `chmod a+w <file>`.
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// use std::fs::File;
     /// let f = File::create("foo.txt").unwrap();
     /// let metadata = f.metadata().unwrap();
diff --git a/clippy_lints/src/ptr_offset_with_cast.rs b/clippy_lints/src/ptr_offset_with_cast.rs
index 20e032d4b01..66d869bc45a 100644
--- a/clippy_lints/src/ptr_offset_with_cast.rs
+++ b/clippy_lints/src/ptr_offset_with_cast.rs
@@ -17,7 +17,7 @@ declare_clippy_lint! {
     /// cast by using the `add` method instead.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let vec = vec![b'a', b'b', b'c'];
     /// let ptr = vec.as_ptr();
     /// let offset = 1_usize;
@@ -29,7 +29,7 @@ declare_clippy_lint! {
     ///
     /// Could be written:
     ///
-    /// ```rust
+    /// ```no_run
     /// let vec = vec![b'a', b'b', b'c'];
     /// let ptr = vec.as_ptr();
     /// let offset = 1_usize;
diff --git a/clippy_lints/src/pub_use.rs b/clippy_lints/src/pub_use.rs
index 9d2b0cedb60..a967b19b838 100644
--- a/clippy_lints/src/pub_use.rs
+++ b/clippy_lints/src/pub_use.rs
@@ -14,7 +14,7 @@ declare_clippy_lint! {
     /// unintentional exports or to encourage placing exported items directly in public modules
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// pub mod outer {
     ///     mod inner {
     ///         pub struct Test {}
@@ -25,7 +25,7 @@ declare_clippy_lint! {
     /// use outer::Test;
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// pub mod outer {
     ///     pub struct Test {}
     /// }
diff --git a/clippy_lints/src/ranges.rs b/clippy_lints/src/ranges.rs
index 3287675a82d..4a5c6b33298 100644
--- a/clippy_lints/src/ranges.rs
+++ b/clippy_lints/src/ranges.rs
@@ -39,7 +39,7 @@ declare_clippy_lint! {
     /// ([#3307](https://github.com/rust-lang/rust-clippy/issues/3307)).
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # let x = 0;
     /// # let y = 1;
     /// for i in x..(y+1) {
@@ -48,7 +48,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # let x = 0;
     /// # let y = 1;
     /// for i in x..=y {
@@ -77,7 +77,7 @@ declare_clippy_lint! {
     /// ([#3307](https://github.com/rust-lang/rust-clippy/issues/3307)).
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # let x = 0;
     /// # let y = 1;
     /// for i in x..=(y-1) {
@@ -86,7 +86,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # let x = 0;
     /// # let y = 1;
     /// for i in x..y {
@@ -118,7 +118,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// fn main() {
     ///     (0..=10).rev().for_each(|x| println!("{}", x));
     ///
@@ -142,14 +142,14 @@ declare_clippy_lint! {
     /// failure modes (such as fencepost errors or using `||` instead of `&&`).
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// // given
     /// let x = 6;
     ///
     /// assert!(x >= 3 && x < 8);
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     ///# let x = 6;
     /// assert!((3..8).contains(&x));
     /// ```
diff --git a/clippy_lints/src/raw_strings.rs b/clippy_lints/src/raw_strings.rs
index c951d9a4a09..391c77dbf90 100644
--- a/clippy_lints/src/raw_strings.rs
+++ b/clippy_lints/src/raw_strings.rs
@@ -20,11 +20,11 @@ declare_clippy_lint! {
     /// idiomatic than a string literal, so it's opt-in.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let r = r"Hello, world!";
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let r = "Hello, world!";
     /// ```
     #[clippy::version = "1.72.0"]
@@ -41,11 +41,11 @@ declare_clippy_lint! {
     /// necessary.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let r = r###"Hello, "world"!"###;
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let r = r#"Hello, "world"!"#;
     /// ```
     #[clippy::version = "1.72.0"]
diff --git a/clippy_lints/src/rc_clone_in_vec_init.rs b/clippy_lints/src/rc_clone_in_vec_init.rs
index bd0ca66b761..59ce289e7d2 100644
--- a/clippy_lints/src/rc_clone_in_vec_init.rs
+++ b/clippy_lints/src/rc_clone_in_vec_init.rs
@@ -21,13 +21,13 @@ declare_clippy_lint! {
     /// than different instances.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let v = vec![std::sync::Arc::new("some data".to_string()); 100];
     /// // or
     /// let v = vec![std::rc::Rc::new("some data".to_string()); 100];
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// // Initialize each value separately:
     /// let mut data = Vec::with_capacity(100);
     /// for _ in 0..100 {
diff --git a/clippy_lints/src/read_zero_byte_vec.rs b/clippy_lints/src/read_zero_byte_vec.rs
index 2bf90815caa..71261ad275c 100644
--- a/clippy_lints/src/read_zero_byte_vec.rs
+++ b/clippy_lints/src/read_zero_byte_vec.rs
@@ -24,7 +24,7 @@ declare_clippy_lint! {
     /// a zero-byte read would allocate a `Vec` for it.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// use std::io;
     /// fn foo<F: io::Read>(mut f: F) {
     ///     let mut data = Vec::with_capacity(100);
@@ -32,7 +32,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// use std::io;
     /// fn foo<F: io::Read>(mut f: F) {
     ///     let mut data = Vec::with_capacity(100);
diff --git a/clippy_lints/src/redundant_async_block.rs b/clippy_lints/src/redundant_async_block.rs
index 2e895d5f236..d97a32b749e 100644
--- a/clippy_lints/src/redundant_async_block.rs
+++ b/clippy_lints/src/redundant_async_block.rs
@@ -19,7 +19,7 @@ declare_clippy_lint! {
     /// It is simpler and more efficient to use the future directly.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let f = async {
     ///    1 + 2
     /// };
@@ -28,7 +28,7 @@ declare_clippy_lint! {
     /// };
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let f = async {
     ///    1 + 2
     /// };
diff --git a/clippy_lints/src/redundant_clone.rs b/clippy_lints/src/redundant_clone.rs
index 2c0086b0981..ef14e68967e 100644
--- a/clippy_lints/src/redundant_clone.rs
+++ b/clippy_lints/src/redundant_clone.rs
@@ -37,7 +37,7 @@ declare_clippy_lint! {
     /// False-negatives: analysis performed by this lint is conservative and limited.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # use std::path::Path;
     /// # #[derive(Clone)]
     /// # struct Foo;
diff --git a/clippy_lints/src/redundant_closure_call.rs b/clippy_lints/src/redundant_closure_call.rs
index c18237e887d..be57ed05e78 100644
--- a/clippy_lints/src/redundant_closure_call.rs
+++ b/clippy_lints/src/redundant_closure_call.rs
@@ -23,12 +23,12 @@ declare_clippy_lint! {
     /// complexity.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let a = (|| 42)();
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let a = 42;
     /// ```
     #[clippy::version = "pre 1.29.0"]
diff --git a/clippy_lints/src/redundant_else.rs b/clippy_lints/src/redundant_else.rs
index 73088ce1a87..221aa317e5d 100644
--- a/clippy_lints/src/redundant_else.rs
+++ b/clippy_lints/src/redundant_else.rs
@@ -16,7 +16,7 @@ declare_clippy_lint! {
     /// Some may prefer to keep the `else` block for clarity.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// fn my_func(count: u32) {
     ///     if count == 0 {
     ///         print!("Nothing to do");
@@ -27,7 +27,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// fn my_func(count: u32) {
     ///     if count == 0 {
     ///         print!("Nothing to do");
diff --git a/clippy_lints/src/redundant_field_names.rs b/clippy_lints/src/redundant_field_names.rs
index 61bff4a0e38..6bf512a0e2d 100644
--- a/clippy_lints/src/redundant_field_names.rs
+++ b/clippy_lints/src/redundant_field_names.rs
@@ -16,7 +16,7 @@ declare_clippy_lint! {
     /// the field name is redundant.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let bar: u8 = 123;
     ///
     /// struct Foo {
diff --git a/clippy_lints/src/redundant_locals.rs b/clippy_lints/src/redundant_locals.rs
index a1a0e8f3520..6bc0d06183f 100644
--- a/clippy_lints/src/redundant_locals.rs
+++ b/clippy_lints/src/redundant_locals.rs
@@ -20,7 +20,7 @@ declare_clippy_lint! {
     /// Note that although these bindings do not affect your code's meaning, they _may_ affect `rustc`'s stack allocation.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let a = 0;
     /// let a = a;
     ///
@@ -29,7 +29,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let a = 0;
     /// // no redefinition with the same name
     ///
diff --git a/clippy_lints/src/redundant_pub_crate.rs b/clippy_lints/src/redundant_pub_crate.rs
index c2a8db7df03..03673eb27f8 100644
--- a/clippy_lints/src/redundant_pub_crate.rs
+++ b/clippy_lints/src/redundant_pub_crate.rs
@@ -18,14 +18,14 @@ declare_clippy_lint! {
     /// module's visibility.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// mod internal {
     ///     pub(crate) fn internal_fn() { }
     /// }
     /// ```
     /// This function is not visible outside the module and it can be declared with `pub` or
     /// private visibility
-    /// ```rust
+    /// ```no_run
     /// mod internal {
     ///     pub fn internal_fn() { }
     /// }
diff --git a/clippy_lints/src/redundant_slicing.rs b/clippy_lints/src/redundant_slicing.rs
index 4abfa0fc35c..7adbd67912c 100644
--- a/clippy_lints/src/redundant_slicing.rs
+++ b/clippy_lints/src/redundant_slicing.rs
@@ -51,12 +51,12 @@ declare_clippy_lint! {
     /// Some people may prefer to dereference rather than slice.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let vec = vec![1, 2, 3];
     /// let slice = &vec[..];
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let vec = vec![1, 2, 3];
     /// let slice = &*vec;
     /// ```
diff --git a/clippy_lints/src/redundant_type_annotations.rs b/clippy_lints/src/redundant_type_annotations.rs
index 1d4fdb43a0b..5a3bee1caad 100644
--- a/clippy_lints/src/redundant_type_annotations.rs
+++ b/clippy_lints/src/redundant_type_annotations.rs
@@ -24,11 +24,11 @@ declare_clippy_lint! {
     /// - `Path` to anything else than a primitive type.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let foo: String = String::new();
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let foo = String::new();
     /// ```
     #[clippy::version = "1.72.0"]
diff --git a/clippy_lints/src/ref_patterns.rs b/clippy_lints/src/ref_patterns.rs
index b1530eed1c1..ce4ca7b06e9 100644
--- a/clippy_lints/src/ref_patterns.rs
+++ b/clippy_lints/src/ref_patterns.rs
@@ -10,12 +10,12 @@ declare_clippy_lint! {
     /// The `ref` keyword can be confusing for people unfamiliar with it, and often
     /// it is more concise to use `&` instead.
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let opt = Some(5);
     /// if let Some(ref foo) = opt {}
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let opt = Some(5);
     /// if let Some(foo) = &opt {}
     /// ```
diff --git a/clippy_lints/src/reserve_after_initialization.rs b/clippy_lints/src/reserve_after_initialization.rs
index 0c8c904e374..f1ef3709514 100644
--- a/clippy_lints/src/reserve_after_initialization.rs
+++ b/clippy_lints/src/reserve_after_initialization.rs
@@ -18,12 +18,12 @@ declare_clippy_lint! {
     /// The `Vec::with_capacity` constructor is less complex.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let mut v: Vec<usize> = vec![];
     /// v.reserve(10);
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let mut v: Vec<usize> = Vec::with_capacity(10);
     /// ```
     #[clippy::version = "1.73.0"]
diff --git a/clippy_lints/src/return_self_not_must_use.rs b/clippy_lints/src/return_self_not_must_use.rs
index bccf421e8f3..245029a066d 100644
--- a/clippy_lints/src/return_self_not_must_use.rs
+++ b/clippy_lints/src/return_self_not_must_use.rs
@@ -26,7 +26,7 @@ declare_clippy_lint! {
     /// if it was added on constructors for example.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// pub struct Bar;
     /// impl Bar {
     ///     // Missing attribute
@@ -37,7 +37,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # {
     /// // It's better to have the `#[must_use]` attribute on the method like this:
     /// pub struct Bar;
diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
index d6b9a49d2fe..11acc3c2d62 100644
--- a/clippy_lints/src/returns.rs
+++ b/clippy_lints/src/returns.rs
@@ -34,14 +34,14 @@ declare_clippy_lint! {
     /// bound without first assigning it to a let-binding.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// fn foo() -> String {
     ///     let x = String::new();
     ///     x
     /// }
     /// ```
     /// instead, use
-    /// ```
+    /// ```no_run
     /// fn foo() -> String {
     ///     String::new()
     /// }
@@ -61,13 +61,13 @@ declare_clippy_lint! {
     /// more rusty.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// fn foo(x: usize) -> usize {
     ///     return x;
     /// }
     /// ```
     /// simplify to
-    /// ```rust
+    /// ```no_run
     /// fn foo(x: usize) -> usize {
     ///     x
     /// }
diff --git a/clippy_lints/src/same_name_method.rs b/clippy_lints/src/same_name_method.rs
index 45433b2adf0..d7fd3163801 100644
--- a/clippy_lints/src/same_name_method.rs
+++ b/clippy_lints/src/same_name_method.rs
@@ -18,7 +18,7 @@ declare_clippy_lint! {
     /// Confusing.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// trait T {
     ///     fn foo(&self) {}
     /// }
diff --git a/clippy_lints/src/semicolon_block.rs b/clippy_lints/src/semicolon_block.rs
index 88f295c72eb..b0601bba4af 100644
--- a/clippy_lints/src/semicolon_block.rs
+++ b/clippy_lints/src/semicolon_block.rs
@@ -19,13 +19,13 @@ declare_clippy_lint! {
     ///
     /// ### Example
     ///
-    /// ```rust
+    /// ```no_run
     /// # fn f(_: u32) {}
     /// # let x = 0;
     /// unsafe { f(x) };
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # fn f(_: u32) {}
     /// # let x = 0;
     /// unsafe { f(x); }
@@ -48,13 +48,13 @@ declare_clippy_lint! {
     ///
     /// ### Example
     ///
-    /// ```rust
+    /// ```no_run
     /// # fn f(_: u32) {}
     /// # let x = 0;
     /// unsafe { f(x); }
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # fn f(_: u32) {}
     /// # let x = 0;
     /// unsafe { f(x) };
diff --git a/clippy_lints/src/semicolon_if_nothing_returned.rs b/clippy_lints/src/semicolon_if_nothing_returned.rs
index c9547cd95dc..ccf8b997705 100644
--- a/clippy_lints/src/semicolon_if_nothing_returned.rs
+++ b/clippy_lints/src/semicolon_if_nothing_returned.rs
@@ -17,13 +17,13 @@ declare_clippy_lint! {
     /// code, it doesn't require a change in previous last line.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// fn main() {
     ///     println!("Hello world")
     /// }
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// fn main() {
     ///     println!("Hello world");
     /// }
diff --git a/clippy_lints/src/shadow.rs b/clippy_lints/src/shadow.rs
index 78418b22392..41c10b34a42 100644
--- a/clippy_lints/src/shadow.rs
+++ b/clippy_lints/src/shadow.rs
@@ -21,13 +21,13 @@ declare_clippy_lint! {
     /// lint to `Warn`.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # let x = 1;
     /// let x = &x;
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # let x = 1;
     /// let y = &x; // use different variable name
     /// ```
@@ -49,12 +49,12 @@ declare_clippy_lint! {
     /// the code.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let x = 2;
     /// let x = x + 1;
     /// ```
     /// use different variable name:
-    /// ```rust
+    /// ```no_run
     /// let x = 2;
     /// let y = x + 1;
     /// ```
@@ -77,7 +77,7 @@ declare_clippy_lint! {
     /// names to bindings or introducing more scopes to contain the bindings.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # let y = 1;
     /// # let z = 2;
     /// let x = y;
@@ -85,7 +85,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # let y = 1;
     /// # let z = 2;
     /// let x = y;
diff --git a/clippy_lints/src/single_call_fn.rs b/clippy_lints/src/single_call_fn.rs
index 7bbe98e0a7f..ae81e1198af 100644
--- a/clippy_lints/src/single_call_fn.rs
+++ b/clippy_lints/src/single_call_fn.rs
@@ -23,7 +23,7 @@ declare_clippy_lint! {
     /// Note: If this lint is used, prepare to allow this a lot.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// pub fn a<T>(t: &T)
     /// where
     ///     T: AsRef<str>,
@@ -37,7 +37,7 @@ declare_clippy_lint! {
     ///
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// pub fn a<T>(t: &T)
     /// where
     ///     T: AsRef<str>,
diff --git a/clippy_lints/src/single_char_lifetime_names.rs b/clippy_lints/src/single_char_lifetime_names.rs
index 3dc995e2fa5..74ee8ce2de7 100644
--- a/clippy_lints/src/single_char_lifetime_names.rs
+++ b/clippy_lints/src/single_char_lifetime_names.rs
@@ -22,13 +22,13 @@ declare_clippy_lint! {
     /// be obvious or, rarely, expressible in one character.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// struct DiagnosticCtx<'a> {
     ///     source: &'a str,
     /// }
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// struct DiagnosticCtx<'src> {
     ///     source: &'src str,
     /// }
diff --git a/clippy_lints/src/single_range_in_vec_init.rs b/clippy_lints/src/single_range_in_vec_init.rs
index 321c8988988..099743d229d 100644
--- a/clippy_lints/src/single_range_in_vec_init.rs
+++ b/clippy_lints/src/single_range_in_vec_init.rs
@@ -21,11 +21,11 @@ declare_clippy_lint! {
     /// the end of the range to be the length instead.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let x = [0..200];
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// // If it was intended to include every element in the range...
     /// let x = (0..200).collect::<Vec<i32>>();
     /// // ...Or if 200 was meant to be the len
diff --git a/clippy_lints/src/size_of_ref.rs b/clippy_lints/src/size_of_ref.rs
index 89ac8cd8ca9..7de029b7b94 100644
--- a/clippy_lints/src/size_of_ref.rs
+++ b/clippy_lints/src/size_of_ref.rs
@@ -19,7 +19,7 @@ declare_clippy_lint! {
     /// the reference.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// struct Foo {
     ///     buffer: [u8],
     /// }
@@ -35,7 +35,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// struct Foo {
     ///     buffer: [u8],
     /// }
diff --git a/clippy_lints/src/slow_vector_initialization.rs b/clippy_lints/src/slow_vector_initialization.rs
index 2278e41be37..2244eab96ca 100644
--- a/clippy_lints/src/slow_vector_initialization.rs
+++ b/clippy_lints/src/slow_vector_initialization.rs
@@ -31,7 +31,7 @@ declare_clippy_lint! {
     /// The `resize` call first allocates memory (since `Vec::new()` did not), and only *then* zero-initializes it.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # use core::iter::repeat;
     /// # let len = 4;
     /// let mut vec1 = Vec::new();
@@ -45,7 +45,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # let len = 4;
     /// let mut vec1 = vec![0; len];
     /// let mut vec2 = vec![0; len];
diff --git a/clippy_lints/src/std_instead_of_core.rs b/clippy_lints/src/std_instead_of_core.rs
index b7396535eed..a50ba0c0c7e 100644
--- a/clippy_lints/src/std_instead_of_core.rs
+++ b/clippy_lints/src/std_instead_of_core.rs
@@ -22,11 +22,11 @@ declare_clippy_lint! {
     /// migrating to become `no_std` compatible.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// use std::hash::Hasher;
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// use core::hash::Hasher;
     /// ```
     #[clippy::version = "1.64.0"]
@@ -47,11 +47,11 @@ declare_clippy_lint! {
     /// for crates migrating to become `no_std` compatible.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// use std::vec::Vec;
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # extern crate alloc;
     /// use alloc::vec::Vec;
     /// ```
@@ -73,12 +73,12 @@ declare_clippy_lint! {
     /// is also useful for crates migrating to become `no_std` compatible.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # extern crate alloc;
     /// use alloc::slice::from_ref;
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// use core::slice::from_ref;
     /// ```
     #[clippy::version = "1.64.0"]
diff --git a/clippy_lints/src/strings.rs b/clippy_lints/src/strings.rs
index 76f463fff7d..a44adc93855 100644
--- a/clippy_lints/src/strings.rs
+++ b/clippy_lints/src/strings.rs
@@ -26,7 +26,7 @@ declare_clippy_lint! {
     /// `.push_str(_)` method is more readable.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let mut x = "Hello".to_owned();
     /// x = x + ", World";
     ///
@@ -58,13 +58,13 @@ declare_clippy_lint! {
     /// particular lint `allow` by default.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let x = "Hello".to_owned();
     /// x + ", World";
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let mut x = "Hello".to_owned();
     /// x.push_str(", World");
     /// ```
@@ -106,12 +106,12 @@ declare_clippy_lint! {
     /// more readable than a function call.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let bstr = "a byte string".as_bytes();
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let bstr = b"a byte string";
     /// ```
     #[clippy::version = "pre 1.29.0"]
@@ -231,12 +231,12 @@ declare_clippy_lint! {
     /// It's unnecessary, the string can be used directly.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// std::str::from_utf8(&"Hello World!".as_bytes()[6..11]).unwrap();
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// &"Hello World!"[6..11];
     /// ```
     #[clippy::version = "1.50.0"]
@@ -387,12 +387,12 @@ declare_clippy_lint! {
     /// expressed with `.to_owned()`.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// // example code where clippy issues a warning
     /// let _ = "str".to_string();
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// // example code which does not raise clippy warning
     /// let _ = "str".to_owned();
     /// ```
@@ -435,13 +435,13 @@ declare_clippy_lint! {
     /// When called on a `String` it only clones the `String`, which can be better expressed with `.clone()`.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// // example code where clippy issues a warning
     /// let msg = String::from("Hello World");
     /// let _ = msg.to_string();
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// // example code which does not raise clippy warning
     /// let msg = String::from("Hello World");
     /// let _ = msg.clone();
@@ -483,11 +483,11 @@ declare_clippy_lint! {
     /// `split_whitespace` already ignores leading and trailing whitespace.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// " A B C ".trim().split_whitespace();
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// " A B C ".split_whitespace();
     /// ```
     #[clippy::version = "1.62.0"]
diff --git a/clippy_lints/src/suspicious_doc_comments.rs b/clippy_lints/src/suspicious_doc_comments.rs
index 8be4ec3dc64..0abc199da16 100644
--- a/clippy_lints/src/suspicious_doc_comments.rs
+++ b/clippy_lints/src/suspicious_doc_comments.rs
@@ -32,7 +32,7 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// In this example, the doc comment is attached to the *function*, rather than the *module*.
-    /// ```rust
+    /// ```no_run
     /// pub mod util {
     ///     ///! This module contains utility functions.
     ///
@@ -41,7 +41,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// pub mod util {
     ///     //! This module contains utility functions.
     ///
diff --git a/clippy_lints/src/suspicious_operation_groupings.rs b/clippy_lints/src/suspicious_operation_groupings.rs
index d10f10ef87e..356156d699c 100644
--- a/clippy_lints/src/suspicious_operation_groupings.rs
+++ b/clippy_lints/src/suspicious_operation_groupings.rs
@@ -28,7 +28,7 @@ declare_clippy_lint! {
     /// unusual that happens to look like a typo.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// struct Vec3 {
     ///     x: f64,
     ///     y: f64,
@@ -45,7 +45,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # struct Vec3 {
     /// #     x: f64,
     /// #     y: f64,
diff --git a/clippy_lints/src/suspicious_xor_used_as_pow.rs b/clippy_lints/src/suspicious_xor_used_as_pow.rs
index 39cd289b67a..42cf034f22a 100644
--- a/clippy_lints/src/suspicious_xor_used_as_pow.rs
+++ b/clippy_lints/src/suspicious_xor_used_as_pow.rs
@@ -14,11 +14,11 @@ declare_clippy_lint! {
     /// ### Why is this bad?
     /// It's most probably a typo and may lead to unexpected behaviours.
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let x = 3_i32 ^ 4_i32;
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let x = 3_i32.pow(4);
     /// ```
     #[clippy::version = "1.67.0"]
diff --git a/clippy_lints/src/swap.rs b/clippy_lints/src/swap.rs
index 548fabb8b73..b24252a90d9 100644
--- a/clippy_lints/src/swap.rs
+++ b/clippy_lints/src/swap.rs
@@ -25,7 +25,7 @@ declare_clippy_lint! {
     /// without deinitializing or copying either variable.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let mut a = 42;
     /// let mut b = 1337;
     ///
@@ -34,7 +34,7 @@ declare_clippy_lint! {
     /// a = t;
     /// ```
     /// Use std::mem::swap():
-    /// ```rust
+    /// ```no_run
     /// let mut a = 1;
     /// let mut b = 2;
     /// std::mem::swap(&mut a, &mut b);
@@ -53,14 +53,14 @@ declare_clippy_lint! {
     /// This looks like a failed attempt to swap.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # let mut a = 1;
     /// # let mut b = 2;
     /// a = b;
     /// b = a;
     /// ```
     /// If swapping is intended, use `swap()` instead:
-    /// ```rust
+    /// ```no_run
     /// # let mut a = 1;
     /// # let mut b = 2;
     /// std::mem::swap(&mut a, &mut b);
diff --git a/clippy_lints/src/swap_ptr_to_ref.rs b/clippy_lints/src/swap_ptr_to_ref.rs
index 4bfbe3bf37e..1667b74da7f 100644
--- a/clippy_lints/src/swap_ptr_to_ref.rs
+++ b/clippy_lints/src/swap_ptr_to_ref.rs
@@ -16,7 +16,7 @@ declare_clippy_lint! {
     /// other. This would then lead to undefined behavior.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// unsafe fn swap(x: &[*mut u32], y: &[*mut u32]) {
     ///     for (&x, &y) in x.iter().zip(y) {
     ///         core::mem::swap(&mut *x, &mut *y);
@@ -24,7 +24,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// unsafe fn swap(x: &[*mut u32], y: &[*mut u32]) {
     ///     for (&x, &y) in x.iter().zip(y) {
     ///         core::ptr::swap(x, y);
diff --git a/clippy_lints/src/tabs_in_doc_comments.rs b/clippy_lints/src/tabs_in_doc_comments.rs
index e223aea297f..71b6fef16ba 100644
--- a/clippy_lints/src/tabs_in_doc_comments.rs
+++ b/clippy_lints/src/tabs_in_doc_comments.rs
@@ -16,7 +16,7 @@ declare_clippy_lint! {
     /// display settings of the author and reader differ.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// ///
     /// /// Struct to hold two strings:
     /// /// 	- first		one
@@ -34,7 +34,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Will be converted to:
-    /// ```rust
+    /// ```no_run
     /// ///
     /// /// Struct to hold two strings:
     /// ///     - first        one
diff --git a/clippy_lints/src/temporary_assignment.rs b/clippy_lints/src/temporary_assignment.rs
index b6b653f6610..c717ccc35a6 100644
--- a/clippy_lints/src/temporary_assignment.rs
+++ b/clippy_lints/src/temporary_assignment.rs
@@ -14,7 +14,7 @@ declare_clippy_lint! {
     /// updated, why not write the structure you want in the first place?
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// (0, 0).0 = 1
     /// ```
     #[clippy::version = "pre 1.29.0"]
diff --git a/clippy_lints/src/tests_outside_test_module.rs b/clippy_lints/src/tests_outside_test_module.rs
index b356666d852..0cfb1c1253c 100644
--- a/clippy_lints/src/tests_outside_test_module.rs
+++ b/clippy_lints/src/tests_outside_test_module.rs
@@ -15,7 +15,7 @@ declare_clippy_lint! {
     /// The idiomatic (and more performant) way of writing tests is inside a testing module (flagged with `#[cfg(test)]`),
     /// having test functions outside of this module is confusing and may lead to them being "hidden".
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// #[test]
     /// fn my_cool_test() {
     ///     // [...]
@@ -28,7 +28,7 @@ declare_clippy_lint! {
     ///
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// #[cfg(test)]
     /// mod tests {
     ///     #[test]
diff --git a/clippy_lints/src/to_digit_is_some.rs b/clippy_lints/src/to_digit_is_some.rs
index f1b703fde0e..a171d225f1e 100644
--- a/clippy_lints/src/to_digit_is_some.rs
+++ b/clippy_lints/src/to_digit_is_some.rs
@@ -17,13 +17,13 @@ declare_clippy_lint! {
     /// more straight forward to use the dedicated `is_digit` method.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # let c = 'c';
     /// # let radix = 10;
     /// let is_digit = c.to_digit(radix).is_some();
     /// ```
     /// can be written as:
-    /// ```
+    /// ```no_run
     /// # let c = 'c';
     /// # let radix = 10;
     /// let is_digit = c.is_digit(radix);
diff --git a/clippy_lints/src/trailing_empty_array.rs b/clippy_lints/src/trailing_empty_array.rs
index bb9da3a2047..87181adc24b 100644
--- a/clippy_lints/src/trailing_empty_array.rs
+++ b/clippy_lints/src/trailing_empty_array.rs
@@ -13,7 +13,7 @@ declare_clippy_lint! {
     /// Zero-sized arrays aren't very useful in Rust itself, so such a struct is likely being created to pass to C code or in some other situation where control over memory layout matters (for example, in conjunction with manual allocation to make it easy to compute the offset of the array). Either way, `#[repr(C)]` (or another `repr` attribute) is needed.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// struct RarelyUseful {
     ///     some_field: u32,
     ///     last: [u32; 0],
@@ -21,7 +21,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// #[repr(C)]
     /// struct MoreOftenUseful {
     ///     some_field: usize,
diff --git a/clippy_lints/src/trait_bounds.rs b/clippy_lints/src/trait_bounds.rs
index 6db330dfa61..42b7b8645d4 100644
--- a/clippy_lints/src/trait_bounds.rs
+++ b/clippy_lints/src/trait_bounds.rs
@@ -27,12 +27,12 @@ declare_clippy_lint! {
     /// less readable than combining the bounds
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// pub fn foo<T>(t: T) where T: Copy, T: Clone {}
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// pub fn foo<T>(t: T) where T: Copy + Clone {}
     /// ```
     #[clippy::version = "1.38.0"]
@@ -51,12 +51,12 @@ declare_clippy_lint! {
     /// less readable than specifying them only once.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// fn func<T: Clone + Default>(arg: T) where T: Clone + Default {}
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # mod hidden {
     /// fn func<T: Clone + Default>(arg: T) {}
     /// # }
@@ -66,19 +66,19 @@ declare_clippy_lint! {
     /// fn func<T>(arg: T) where T: Clone + Default {}
     /// ```
     ///
-    /// ```rust
+    /// ```no_run
     /// fn foo<T: Default + Default>(bar: T) {}
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// fn foo<T: Default>(bar: T) {}
     /// ```
     ///
-    /// ```rust
+    /// ```no_run
     /// fn foo<T>(bar: T) where T: Default + Default {}
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// fn foo<T>(bar: T) where T: Default {}
     /// ```
     #[clippy::version = "1.47.0"]
diff --git a/clippy_lints/src/transmute/mod.rs b/clippy_lints/src/transmute/mod.rs
index 0dc30f7a935..a6231ceb658 100644
--- a/clippy_lints/src/transmute/mod.rs
+++ b/clippy_lints/src/transmute/mod.rs
@@ -78,12 +78,12 @@ declare_clippy_lint! {
     ///
     /// ### Example
     ///
-    /// ```rust
+    /// ```no_run
     /// # let p: *const [i32] = &[];
     /// unsafe { std::mem::transmute::<*const [i32], *const [u16]>(p) };
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # let p: *const [i32] = &[];
     /// p as *const [u16];
     /// ```
@@ -159,7 +159,7 @@ declare_clippy_lint! {
     /// [`from_u32_unchecked`]: https://doc.rust-lang.org/std/char/fn.from_u32_unchecked.html
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let x = 1_u32;
     /// unsafe {
     ///     let _: char = std::mem::transmute(x); // where x: u32
@@ -193,7 +193,7 @@ declare_clippy_lint! {
     /// [`from_utf8_unchecked`]: https://doc.rust-lang.org/std/str/fn.from_utf8_unchecked.html
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let b: &[u8] = &[1_u8, 2_u8];
     /// unsafe {
     ///     let _: &str = std::mem::transmute(b); // where b: &[u8]
@@ -216,7 +216,7 @@ declare_clippy_lint! {
     /// This might result in an invalid in-memory representation of a `bool`.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let x = 1_u8;
     /// unsafe {
     ///     let _: bool = std::mem::transmute(x); // where x: u8
@@ -240,7 +240,7 @@ declare_clippy_lint! {
     /// and safe.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// unsafe {
     ///     let _: f32 = std::mem::transmute(1_u32); // where x: u32
     /// }
@@ -264,12 +264,12 @@ declare_clippy_lint! {
     /// elsewhere. `new_unchecked` only works for the appropriate types instead.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # use core::num::NonZeroU32;
     /// let _non_zero: NonZeroU32 = unsafe { std::mem::transmute(123) };
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # use core::num::NonZeroU32;
     /// let _non_zero = unsafe { NonZeroU32::new_unchecked(123) };
     /// ```
@@ -288,7 +288,7 @@ declare_clippy_lint! {
     /// and safe.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// unsafe {
     ///     let _: u32 = std::mem::transmute(1f32);
     /// }
@@ -311,7 +311,7 @@ declare_clippy_lint! {
     /// is intuitive and safe.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// unsafe {
     ///     let x: [u8; 8] = std::mem::transmute(1i64);
     /// }
@@ -335,7 +335,7 @@ declare_clippy_lint! {
     /// written as casts.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let ptr = &1u32 as *const u32;
     /// unsafe {
     ///     // pointer-to-pointer transmute
@@ -366,7 +366,7 @@ declare_clippy_lint! {
     /// collection, so we just lint the ones that come with `std`.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// // different size, therefore likely out-of-bounds memory access
     /// // You absolutely do not want this in your code!
     /// unsafe {
@@ -376,7 +376,7 @@ declare_clippy_lint! {
     ///
     /// You must always iterate, map and collect the values:
     ///
-    /// ```rust
+    /// ```no_run
     /// vec![2_u16].into_iter().map(u32::from).collect::<Vec<_>>();
     /// ```
     #[clippy::version = "1.40.0"]
@@ -398,12 +398,12 @@ declare_clippy_lint! {
     /// [#8496](https://github.com/rust-lang/rust-clippy/issues/8496) for more details.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// struct Foo<T>(u32, T);
     /// let _ = unsafe { core::mem::transmute::<Foo<u32>, Foo<i32>>(Foo(0u32, 0u32)) };
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// #[repr(C)]
     /// struct Foo<T>(u32, T);
     /// let _ = unsafe { core::mem::transmute::<Foo<u32>, Foo<i32>>(Foo(0u32, 0u32)) };
@@ -427,7 +427,7 @@ declare_clippy_lint! {
     /// call, aren't detectable yet.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let null_ref: &u64 = unsafe { std::mem::transmute(0 as *const u64) };
     /// ```
     #[clippy::version = "1.35.0"]
@@ -451,11 +451,11 @@ declare_clippy_lint! {
     /// call, aren't detectable yet.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let null_fn: fn() = unsafe { std::mem::transmute( std::ptr::null::<()>() ) };
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let null_fn: Option<fn()> = None;
     /// ```
     #[clippy::version = "1.68.0"]
diff --git a/clippy_lints/src/types/mod.rs b/clippy_lints/src/types/mod.rs
index 788678a63b7..781e0aa22ed 100644
--- a/clippy_lints/src/types/mod.rs
+++ b/clippy_lints/src/types/mod.rs
@@ -64,7 +64,7 @@ declare_clippy_lint! {
     /// 1st comment).
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// struct X {
     ///     values: Vec<Box<i32>>,
     /// }
@@ -72,7 +72,7 @@ declare_clippy_lint! {
     ///
     /// Better:
     ///
-    /// ```rust
+    /// ```no_run
     /// struct X {
     ///     values: Vec<i32>,
     /// }
@@ -97,7 +97,7 @@ declare_clippy_lint! {
     /// consider a custom `enum` instead, with clear names for each case.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// fn get_data() -> Option<Option<u32>> {
     ///     None
     /// }
@@ -105,7 +105,7 @@ declare_clippy_lint! {
     ///
     /// Better:
     ///
-    /// ```rust
+    /// ```no_run
     /// pub enum Contents {
     ///     Data(Vec<u8>), // Was Some(Some(Vec<u8>))
     ///     NotYetFetched, // Was Some(None)
@@ -152,7 +152,7 @@ declare_clippy_lint! {
     /// `LinkedList` makes sense are few and far between, but they can still happen.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # use std::collections::LinkedList;
     /// let x: LinkedList<usize> = LinkedList::new();
     /// ```
@@ -197,14 +197,14 @@ declare_clippy_lint! {
     /// `Arc<Arc<T>>`, `Arc<Box<T>>`, `Box<&T>`, `Box<Rc<T>>`, `Box<Arc<T>>`, `Box<Box<T>>`, add an unnecessary level of indirection.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # use std::rc::Rc;
     /// fn foo(bar: Rc<&usize>) {}
     /// ```
     ///
     /// Better:
     ///
-    /// ```rust
+    /// ```no_run
     /// fn foo(bar: &usize) {}
     /// ```
     #[clippy::version = "1.44.0"]
@@ -258,7 +258,7 @@ declare_clippy_lint! {
     /// using a `type` definition to simplify them.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # use std::rc::Rc;
     /// struct Foo {
     ///     inner: Rc<Vec<Vec<Box<(u32, u32, u32, u32)>>>>,
diff --git a/clippy_lints/src/undocumented_unsafe_blocks.rs b/clippy_lints/src/undocumented_unsafe_blocks.rs
index 6193fdeb433..4d0b548d0a2 100644
--- a/clippy_lints/src/undocumented_unsafe_blocks.rs
+++ b/clippy_lints/src/undocumented_unsafe_blocks.rs
@@ -44,14 +44,14 @@ declare_clippy_lint! {
     /// and bugs.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// use std::ptr::NonNull;
     /// let a = &mut 42;
     ///
     /// let ptr = unsafe { NonNull::new_unchecked(a) };
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// use std::ptr::NonNull;
     /// let a = &mut 42;
     ///
@@ -72,7 +72,7 @@ declare_clippy_lint! {
     /// describe safety invariants.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// use std::ptr::NonNull;
     /// let a = &mut 42;
     ///
@@ -80,7 +80,7 @@ declare_clippy_lint! {
     /// let ptr = NonNull::new(a).unwrap();
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// use std::ptr::NonNull;
     /// let a = &mut 42;
     ///
diff --git a/clippy_lints/src/unicode.rs b/clippy_lints/src/unicode.rs
index e275bfd37b0..37bf2a35251 100644
--- a/clippy_lints/src/unicode.rs
+++ b/clippy_lints/src/unicode.rs
@@ -39,12 +39,12 @@ declare_clippy_lint! {
     /// requirements, activating this lint could be useful.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let x = String::from("€");
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let x = String::from("\u{20ac}");
     /// ```
     #[clippy::version = "pre 1.29.0"]
diff --git a/clippy_lints/src/unit_return_expecting_ord.rs b/clippy_lints/src/unit_return_expecting_ord.rs
index de4b8738e35..e76cc65fd46 100644
--- a/clippy_lints/src/unit_return_expecting_ord.rs
+++ b/clippy_lints/src/unit_return_expecting_ord.rs
@@ -25,7 +25,7 @@ declare_clippy_lint! {
     /// way of specifying this without triggering needless_return lint
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let mut twins = vec![(1, 1), (2, 2)];
     /// twins.sort_by_key(|x| { x.1; });
     /// ```
diff --git a/clippy_lints/src/unit_types/mod.rs b/clippy_lints/src/unit_types/mod.rs
index 546242ebd9a..884c6ca4d31 100644
--- a/clippy_lints/src/unit_types/mod.rs
+++ b/clippy_lints/src/unit_types/mod.rs
@@ -16,7 +16,7 @@ declare_clippy_lint! {
     /// binding one is kind of pointless.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let x = {
     ///     1;
     /// };
@@ -38,7 +38,7 @@ declare_clippy_lint! {
     /// adds semicolons at the end of the operands.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # fn foo() {};
     /// # fn bar() {};
     /// # fn baz() {};
@@ -51,7 +51,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     /// is equal to
-    /// ```rust
+    /// ```no_run
     /// # fn foo() {};
     /// # fn bar() {};
     /// # fn baz() {};
@@ -63,7 +63,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// For asserts:
-    /// ```rust
+    /// ```no_run
     /// # fn foo() {};
     /// # fn bar() {};
     /// assert_eq!({ foo(); }, { bar(); });
diff --git a/clippy_lints/src/unnamed_address.rs b/clippy_lints/src/unnamed_address.rs
index 996e7edf557..e7355f92304 100644
--- a/clippy_lints/src/unnamed_address.rs
+++ b/clippy_lints/src/unnamed_address.rs
@@ -16,7 +16,7 @@ declare_clippy_lint! {
     /// the same address after being merged together.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// type F = fn();
     /// fn a() {}
     /// let f: F = a;
diff --git a/clippy_lints/src/unnecessary_box_returns.rs b/clippy_lints/src/unnecessary_box_returns.rs
index ed2ef506381..ca159eb4d5f 100644
--- a/clippy_lints/src/unnecessary_box_returns.rs
+++ b/clippy_lints/src/unnecessary_box_returns.rs
@@ -22,13 +22,13 @@ declare_clippy_lint! {
     /// `Box<T>` been dropped.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// fn foo() -> Box<String> {
     ///     Box::new(String::from("Hello, world!"))
     /// }
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// fn foo() -> String {
     ///     String::from("Hello, world!")
     /// }
diff --git a/clippy_lints/src/unnecessary_map_on_constructor.rs b/clippy_lints/src/unnecessary_map_on_constructor.rs
index 894de0d85c1..f9d9650db04 100644
--- a/clippy_lints/src/unnecessary_map_on_constructor.rs
+++ b/clippy_lints/src/unnecessary_map_on_constructor.rs
@@ -16,11 +16,11 @@ declare_clippy_lint! {
     /// construct the Option or Result from the output.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// Some(4).map(i32::swap_bytes);
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// Some(i32::swap_bytes(4));
     /// ```
     #[clippy::version = "1.73.0"]
diff --git a/clippy_lints/src/unnecessary_owned_empty_strings.rs b/clippy_lints/src/unnecessary_owned_empty_strings.rs
index 57a4a429e12..28ea02e4d9a 100644
--- a/clippy_lints/src/unnecessary_owned_empty_strings.rs
+++ b/clippy_lints/src/unnecessary_owned_empty_strings.rs
@@ -20,11 +20,11 @@ declare_clippy_lint! {
     /// This results in longer and less readable code
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// vec!["1", "2", "3"].join(&String::new());
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// vec!["1", "2", "3"].join("");
     /// ```
     #[clippy::version = "1.62.0"]
diff --git a/clippy_lints/src/unnecessary_self_imports.rs b/clippy_lints/src/unnecessary_self_imports.rs
index 397633f533b..a1083a0a68e 100644
--- a/clippy_lints/src/unnecessary_self_imports.rs
+++ b/clippy_lints/src/unnecessary_self_imports.rs
@@ -19,11 +19,11 @@ declare_clippy_lint! {
     /// to detect this scenario and that is why it is a restriction lint.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// use std::io::{self};
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// use std::io;
     /// ```
     #[clippy::version = "1.53.0"]
diff --git a/clippy_lints/src/unnecessary_struct_initialization.rs b/clippy_lints/src/unnecessary_struct_initialization.rs
index f4111186c64..b75df0dec9a 100644
--- a/clippy_lints/src/unnecessary_struct_initialization.rs
+++ b/clippy_lints/src/unnecessary_struct_initialization.rs
@@ -15,14 +15,14 @@ declare_clippy_lint! {
     /// Readability suffers from unnecessary struct building.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// struct S { s: String }
     ///
     /// let a = S { s: String::from("Hello, world!") };
     /// let b = S { ..a };
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// struct S { s: String }
     ///
     /// let a = S { s: String::from("Hello, world!") };
diff --git a/clippy_lints/src/unnecessary_wraps.rs b/clippy_lints/src/unnecessary_wraps.rs
index f34f8d0e353..ab8de17b091 100644
--- a/clippy_lints/src/unnecessary_wraps.rs
+++ b/clippy_lints/src/unnecessary_wraps.rs
@@ -26,7 +26,7 @@ declare_clippy_lint! {
     /// fit some external requirement.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// fn get_cool_number(a: bool, b: bool) -> Option<i32> {
     ///     if a && b {
     ///         return Some(50);
@@ -39,7 +39,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// fn get_cool_number(a: bool, b: bool) -> i32 {
     ///     if a && b {
     ///         return 50;
diff --git a/clippy_lints/src/unnested_or_patterns.rs b/clippy_lints/src/unnested_or_patterns.rs
index 766a5481451..e8ec22831c3 100644
--- a/clippy_lints/src/unnested_or_patterns.rs
+++ b/clippy_lints/src/unnested_or_patterns.rs
@@ -29,13 +29,13 @@ declare_clippy_lint! {
     /// In the example above, `Some` is repeated, which unnecessarily complicates the pattern.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// fn main() {
     ///     if let Some(0) | Some(2) = Some(0) {}
     /// }
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// fn main() {
     ///     if let Some(0 | 2) = Some(0) {}
     /// }
diff --git a/clippy_lints/src/unused_async.rs b/clippy_lints/src/unused_async.rs
index 3649f8792ae..aea72c798be 100644
--- a/clippy_lints/src/unused_async.rs
+++ b/clippy_lints/src/unused_async.rs
@@ -19,7 +19,7 @@ declare_clippy_lint! {
     /// causes runtime overhead and hassle for the caller.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// async fn get_random_number() -> i64 {
     ///     4 // Chosen by fair dice roll. Guaranteed to be random.
     /// }
@@ -27,7 +27,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// fn get_random_number_improved() -> i64 {
     ///     4 // Chosen by fair dice roll. Guaranteed to be random.
     /// }
diff --git a/clippy_lints/src/unused_peekable.rs b/clippy_lints/src/unused_peekable.rs
index db91beec0ef..66b52dc94c2 100644
--- a/clippy_lints/src/unused_peekable.rs
+++ b/clippy_lints/src/unused_peekable.rs
@@ -18,7 +18,7 @@ declare_clippy_lint! {
     /// or just a leftover after a refactor.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let collection = vec![1, 2, 3];
     /// let iter = collection.iter().peekable();
     ///
@@ -28,7 +28,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let collection = vec![1, 2, 3];
     /// let iter = collection.iter();
     ///
diff --git a/clippy_lints/src/unused_rounding.rs b/clippy_lints/src/unused_rounding.rs
index 097568cd1f7..de43c5cbae4 100644
--- a/clippy_lints/src/unused_rounding.rs
+++ b/clippy_lints/src/unused_rounding.rs
@@ -16,11 +16,11 @@ declare_clippy_lint! {
     /// This is unnecessary and confusing to the reader. Doing this is probably a mistake.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let x = 1f32.ceil();
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let x = 1f32;
     /// ```
     #[clippy::version = "1.63.0"]
diff --git a/clippy_lints/src/unused_unit.rs b/clippy_lints/src/unused_unit.rs
index 95e74718d80..ae844673b15 100644
--- a/clippy_lints/src/unused_unit.rs
+++ b/clippy_lints/src/unused_unit.rs
@@ -19,13 +19,13 @@ declare_clippy_lint! {
     /// statement look like a function call.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// fn return_unit() -> () {
     ///     ()
     /// }
     /// ```
     /// is equivalent to
-    /// ```rust
+    /// ```no_run
     /// fn return_unit() {}
     /// ```
     #[clippy::version = "1.31.0"]
diff --git a/clippy_lints/src/unwrap.rs b/clippy_lints/src/unwrap.rs
index 9a0d83d83f1..e52cfb29fe5 100644
--- a/clippy_lints/src/unwrap.rs
+++ b/clippy_lints/src/unwrap.rs
@@ -26,7 +26,7 @@ declare_clippy_lint! {
     /// Using `if let` or `match` is more idiomatic.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # let option = Some(0);
     /// # fn do_something_with(_x: usize) {}
     /// if option.is_some() {
@@ -36,7 +36,7 @@ declare_clippy_lint! {
     ///
     /// Could be written:
     ///
-    /// ```rust
+    /// ```no_run
     /// # let option = Some(0);
     /// # fn do_something_with(_x: usize) {}
     /// if let Some(value) = option {
@@ -61,7 +61,7 @@ declare_clippy_lint! {
     /// So something like `let x: Option<()> = None; x.unwrap();` will not be recognized.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # let option = Some(0);
     /// # fn do_something_with(_x: usize) {}
     /// if option.is_none() {
diff --git a/clippy_lints/src/unwrap_in_result.rs b/clippy_lints/src/unwrap_in_result.rs
index 3a1845425a2..21592abbf16 100644
--- a/clippy_lints/src/unwrap_in_result.rs
+++ b/clippy_lints/src/unwrap_in_result.rs
@@ -22,7 +22,7 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// Before:
-    /// ```rust
+    /// ```no_run
     /// fn divisible_by_3(i_str: String) -> Result<(), String> {
     ///     let i = i_str
     ///         .parse::<i32>()
@@ -37,7 +37,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// After:
-    /// ```rust
+    /// ```no_run
     /// fn divisible_by_3(i_str: String) -> Result<(), String> {
     ///     let i = i_str
     ///         .parse::<i32>()
diff --git a/clippy_lints/src/upper_case_acronyms.rs b/clippy_lints/src/upper_case_acronyms.rs
index 4df1e3299ed..de6a75b79fc 100644
--- a/clippy_lints/src/upper_case_acronyms.rs
+++ b/clippy_lints/src/upper_case_acronyms.rs
@@ -26,11 +26,11 @@ declare_clippy_lint! {
     /// the letters in the second acronym.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// struct HTTPResponse;
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// struct HttpResponse;
     /// ```
     #[clippy::version = "1.51.0"]
diff --git a/clippy_lints/src/use_self.rs b/clippy_lints/src/use_self.rs
index f10ed4b3d41..0f57c5def21 100644
--- a/clippy_lints/src/use_self.rs
+++ b/clippy_lints/src/use_self.rs
@@ -31,7 +31,7 @@ declare_clippy_lint! {
     /// - Unaddressed false negative in fn bodies of trait implementations
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// struct Foo;
     /// impl Foo {
     ///     fn new() -> Foo {
@@ -40,7 +40,7 @@ declare_clippy_lint! {
     /// }
     /// ```
     /// could be
-    /// ```rust
+    /// ```no_run
     /// struct Foo;
     /// impl Foo {
     ///     fn new() -> Self {
diff --git a/clippy_lints/src/useless_conversion.rs b/clippy_lints/src/useless_conversion.rs
index 3cc91838c00..edb5935f606 100644
--- a/clippy_lints/src/useless_conversion.rs
+++ b/clippy_lints/src/useless_conversion.rs
@@ -26,13 +26,13 @@ declare_clippy_lint! {
     /// Redundant code.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// // format!() returns a `String`
     /// let s: String = format!("hello").into();
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let s: String = format!("hello");
     /// ```
     #[clippy::version = "1.45.0"]
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
index 8829f188fe7..e5409328b4d 100644
--- a/clippy_lints/src/utils/conf.rs
+++ b/clippy_lints/src/utils/conf.rs
@@ -549,7 +549,7 @@ define_Conf! {
     /// Whether to recommend using implicit into iter for reborrowed values.
     ///
     /// #### Example
-    /// ```
+    /// ```no_run
     /// let mut vec = vec![1, 2, 3];
     /// let rmvec = &mut vec;
     /// for _ in rmvec.iter() {}
@@ -557,7 +557,7 @@ define_Conf! {
     /// ```
     ///
     /// Use instead:
-    /// ```
+    /// ```no_run
     /// let mut vec = vec![1, 2, 3];
     /// let rmvec = &mut vec;
     /// for _ in &*rmvec {}
diff --git a/clippy_lints/src/vec.rs b/clippy_lints/src/vec.rs
index fc17e7c6d5a..42a69fa1133 100644
--- a/clippy_lints/src/vec.rs
+++ b/clippy_lints/src/vec.rs
@@ -33,14 +33,14 @@ declare_clippy_lint! {
     /// This is less efficient.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// fn foo(_x: &[u8]) {}
     ///
     /// foo(&vec![1, 2]);
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # fn foo(_x: &[u8]) {}
     /// foo(&[1, 2]);
     /// ```
diff --git a/clippy_lints/src/vec_init_then_push.rs b/clippy_lints/src/vec_init_then_push.rs
index 3fa51216c77..f0ae4e2a3ec 100644
--- a/clippy_lints/src/vec_init_then_push.rs
+++ b/clippy_lints/src/vec_init_then_push.rs
@@ -30,12 +30,12 @@ declare_clippy_lint! {
     /// multiple `push` calls.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let mut v = Vec::new();
     /// v.push(0);
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let v = vec![0];
     /// ```
     #[clippy::version = "1.51.0"]
diff --git a/clippy_lints/src/wildcard_imports.rs b/clippy_lints/src/wildcard_imports.rs
index 70b83149ce1..d88ede76398 100644
--- a/clippy_lints/src/wildcard_imports.rs
+++ b/clippy_lints/src/wildcard_imports.rs
@@ -24,7 +24,7 @@ declare_clippy_lint! {
     /// still around.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// use std::cmp::Ordering::*;
     ///
     /// # fn foo(_: std::cmp::Ordering) {}
@@ -32,7 +32,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// use std::cmp::Ordering;
     ///
     /// # fn foo(_: Ordering) {}
diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs
index 855aefa70cb..ea22be24a0d 100644
--- a/clippy_lints/src/write.rs
+++ b/clippy_lints/src/write.rs
@@ -22,12 +22,12 @@ declare_clippy_lint! {
     /// You should use `println!()`, which is simpler.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// println!("");
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// println!();
     /// ```
     #[clippy::version = "pre 1.29.0"]
@@ -46,12 +46,12 @@ declare_clippy_lint! {
     /// newline.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # let name = "World";
     /// print!("Hello {}!\n", name);
     /// ```
     /// use println!() instead
-    /// ```rust
+    /// ```no_run
     /// # let name = "World";
     /// println!("Hello {}!", name);
     /// ```
@@ -74,7 +74,7 @@ declare_clippy_lint! {
     /// Only catches `print!` and `println!` calls.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// println!("Hello world!");
     /// ```
     #[clippy::version = "pre 1.29.0"]
@@ -96,7 +96,7 @@ declare_clippy_lint! {
     /// Only catches `eprint!` and `eprintln!` calls.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// eprintln!("Hello world!");
     /// ```
     #[clippy::version = "1.50.0"]
@@ -115,7 +115,7 @@ declare_clippy_lint! {
     /// debugging Rust code. It should not be used in user-facing output.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # let foo = "bar";
     /// println!("{:?}", foo);
     /// ```
@@ -135,11 +135,11 @@ declare_clippy_lint! {
     /// (i.e., just put the literal in the format string)
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// println!("{}", "foo");
     /// ```
     /// use the literal without formatting:
-    /// ```rust
+    /// ```no_run
     /// println!("foo");
     /// ```
     #[clippy::version = "pre 1.29.0"]
@@ -157,14 +157,14 @@ declare_clippy_lint! {
     /// You should use `writeln!(buf)`, which is simpler.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # use std::fmt::Write;
     /// # let mut buf = String::new();
     /// writeln!(buf, "");
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # use std::fmt::Write;
     /// # let mut buf = String::new();
     /// writeln!(buf);
@@ -186,7 +186,7 @@ declare_clippy_lint! {
     /// newline.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # use std::fmt::Write;
     /// # let mut buf = String::new();
     /// # let name = "World";
@@ -194,7 +194,7 @@ declare_clippy_lint! {
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # use std::fmt::Write;
     /// # let mut buf = String::new();
     /// # let name = "World";
@@ -216,14 +216,14 @@ declare_clippy_lint! {
     /// (i.e., just put the literal in the format string)
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # use std::fmt::Write;
     /// # let mut buf = String::new();
     /// writeln!(buf, "{}", "foo");
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # use std::fmt::Write;
     /// # let mut buf = String::new();
     /// writeln!(buf, "foo");
diff --git a/clippy_lints/src/zero_div_zero.rs b/clippy_lints/src/zero_div_zero.rs
index 9b3de35dbd3..f2f0699ef48 100644
--- a/clippy_lints/src/zero_div_zero.rs
+++ b/clippy_lints/src/zero_div_zero.rs
@@ -13,12 +13,12 @@ declare_clippy_lint! {
     /// It's less readable than `f32::NAN` or `f64::NAN`.
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// let nan = 0.0f32 / 0.0;
     /// ```
     ///
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// let nan = f32::NAN;
     /// ```
     #[clippy::version = "pre 1.29.0"]
diff --git a/clippy_lints/src/zero_sized_map_values.rs b/clippy_lints/src/zero_sized_map_values.rs
index 002304f8840..fee100fe1ea 100644
--- a/clippy_lints/src/zero_sized_map_values.rs
+++ b/clippy_lints/src/zero_sized_map_values.rs
@@ -23,14 +23,14 @@ declare_clippy_lint! {
     /// * This lints the signature of public items
     ///
     /// ### Example
-    /// ```rust
+    /// ```no_run
     /// # use std::collections::HashMap;
     /// fn unique_words(text: &str) -> HashMap<&str, ()> {
     ///     todo!();
     /// }
     /// ```
     /// Use instead:
-    /// ```rust
+    /// ```no_run
     /// # use std::collections::HashSet;
     /// fn unique_words(text: &str) -> HashSet<&str> {
     ///     todo!();
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index b4099bed5fc..9fed6130a28 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -144,7 +144,7 @@ macro_rules! extract_msrv_attr {
 /// instead.
 ///
 /// Examples:
-/// ```
+/// ```no_run
 /// let abc = 1;
 /// //        ^ output
 /// let def = abc;
@@ -699,7 +699,7 @@ pub fn get_trait_def_id(cx: &LateContext<'_>, path: &[&str]) -> Option<DefId> {
 ///
 /// Use this if you want to find the `TraitRef` of the `Add` trait in this example:
 ///
-/// ```rust
+/// ```no_run
 /// struct Point(isize, isize);
 ///
 /// impl std::ops::Add for Point {
@@ -895,7 +895,7 @@ fn is_default_equivalent_from(cx: &LateContext<'_>, from_func: &Expr<'_>, arg: &
 ///
 /// For example, given the following function:
 ///
-/// ```
+/// ```no_run
 /// fn f<'a>(iter: &mut impl Iterator<Item = (usize, &'a mut String)>) {
 ///     for item in iter {
 ///         let s = item.1;
@@ -1609,7 +1609,7 @@ pub fn is_expn_of(mut span: Span, name: &str) -> Option<Span> {
 /// Returns the pre-expansion span if the span directly comes from an expansion
 /// of the macro `name`.
 /// The difference with [`is_expn_of`] is that in
-/// ```rust
+/// ```no_run
 /// # macro_rules! foo { ($name:tt!$args:tt) => { $name!$args } }
 /// # macro_rules! bar { ($e:expr) => { $e } }
 /// foo!(bar!(42));
@@ -2204,7 +2204,7 @@ pub fn is_no_core_crate(cx: &LateContext<'_>) -> bool {
 
 /// Check if parent of a hir node is a trait implementation block.
 /// For example, `f` in
-/// ```rust
+/// ```no_run
 /// # struct S;
 /// # trait Trait { fn f(); }
 /// impl Trait for S {
diff --git a/clippy_utils/src/source.rs b/clippy_utils/src/source.rs
index bb9cdbbcaeb..916f7892944 100644
--- a/clippy_utils/src/source.rs
+++ b/clippy_utils/src/source.rs
@@ -108,7 +108,7 @@ fn first_char_in_first_line<T: LintContext>(cx: &T, span: Span) -> Option<BytePo
 
 /// Extends the span to the beginning of the spans line, incl. whitespaces.
 ///
-/// ```rust
+/// ```no_run
 ///        let x = ();
 /// //             ^^
 /// // will be converted to
diff --git a/clippy_utils/src/str_utils.rs b/clippy_utils/src/str_utils.rs
index 69c25b427e1..421b25a77fe 100644
--- a/clippy_utils/src/str_utils.rs
+++ b/clippy_utils/src/str_utils.rs
@@ -14,7 +14,7 @@ impl StrIndex {
 
 /// Returns the index of the character after the first camel-case component of `s`.
 ///
-/// ```
+/// ```no_run
 /// # use clippy_utils::str_utils::{camel_case_until, StrIndex};
 /// assert_eq!(camel_case_until("AbcDef"), StrIndex::new(6, 6));
 /// assert_eq!(camel_case_until("ABCD"), StrIndex::new(0, 0));
@@ -58,7 +58,7 @@ pub fn camel_case_until(s: &str) -> StrIndex {
 
 /// Returns index of the first camel-case component of `s`.
 ///
-/// ```
+/// ```no_run
 /// # use clippy_utils::str_utils::{camel_case_start, StrIndex};
 /// assert_eq!(camel_case_start("AbcDef"), StrIndex::new(0, 0));
 /// assert_eq!(camel_case_start("abcDef"), StrIndex::new(3, 3));
@@ -73,7 +73,7 @@ pub fn camel_case_start(s: &str) -> StrIndex {
 
 /// Returns `StrIndex` of the last camel-case component of `s[idx..]`.
 ///
-/// ```
+/// ```no_run
 /// # use clippy_utils::str_utils::{camel_case_start_from_idx, StrIndex};
 /// assert_eq!(camel_case_start_from_idx("AbcDef", 0), StrIndex::new(0, 0));
 /// assert_eq!(camel_case_start_from_idx("AbcDef", 1), StrIndex::new(3, 3));
@@ -122,7 +122,7 @@ pub fn camel_case_start_from_idx(s: &str, start_idx: usize) -> StrIndex {
 
 /// Get the indexes of camel case components of a string `s`
 ///
-/// ```
+/// ```no_run
 /// # use clippy_utils::str_utils::{camel_case_indices, StrIndex};
 /// assert_eq!(
 ///     camel_case_indices("AbcDef"),
@@ -149,7 +149,7 @@ pub fn camel_case_indices(s: &str) -> Vec<StrIndex> {
 
 /// Split camel case string into a vector of its components
 ///
-/// ```
+/// ```no_run
 /// # use clippy_utils::str_utils::{camel_case_split, StrIndex};
 /// assert_eq!(camel_case_split("AbcDef"), vec!["Abc", "Def"]);
 /// ```
@@ -181,7 +181,7 @@ impl StrCount {
 
 /// Returns the number of chars that match from the start
 ///
-/// ```
+/// ```no_run
 /// # use clippy_utils::str_utils::{count_match_start, StrCount};
 /// assert_eq!(count_match_start("hello_mouse", "hello_penguin"), StrCount::new(6, 6));
 /// assert_eq!(count_match_start("hello_clippy", "bye_bugs"), StrCount::new(0, 0));
@@ -207,7 +207,7 @@ pub fn count_match_start(str1: &str, str2: &str) -> StrCount {
 
 /// Returns the number of chars and bytes that match from the end
 ///
-/// ```
+/// ```no_run
 /// # use clippy_utils::str_utils::{count_match_end, StrCount};
 /// assert_eq!(count_match_end("hello_cat", "bye_cat"), StrCount::new(4, 4));
 /// assert_eq!(count_match_end("if_item_thing", "enum_value"), StrCount::new(0, 0));
@@ -237,7 +237,7 @@ pub fn count_match_end(str1: &str, str2: &str) -> StrCount {
 }
 
 /// Returns a `snake_case` version of the input
-/// ```
+/// ```no_run
 /// use clippy_utils::str_utils::to_snake_case;
 /// assert_eq!(to_snake_case("AbcDef"), "abc_def");
 /// assert_eq!(to_snake_case("ABCD"), "a_b_c_d");
@@ -260,7 +260,7 @@ pub fn to_snake_case(name: &str) -> String {
     s
 }
 /// Returns a `CamelCase` version of the input
-/// ```
+/// ```no_run
 /// use clippy_utils::str_utils::to_camel_case;
 /// assert_eq!(to_camel_case("abc_def"), "AbcDef");
 /// assert_eq!(to_camel_case("a_b_c_d"), "ABCD");
diff --git a/declare_clippy_lint/src/lib.rs b/declare_clippy_lint/src/lib.rs
index 0057256f659..ad8f77662ee 100644
--- a/declare_clippy_lint/src/lib.rs
+++ b/declare_clippy_lint/src/lib.rs
@@ -94,7 +94,7 @@ impl Parse for ClippyLint {
 ///
 /// # Example
 ///
-/// ```
+/// ```ignore
 /// use rustc_session::declare_tool_lint;
 ///
 /// declare_clippy_lint! {
-- 
cgit 1.4.1-3-g733a5


From e1b287c3a651f247d47d331a8ac02f14222f8d55 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Mon, 23 Oct 2023 18:31:35 +0000
Subject: Use multiple pushes in `vec_init_then_push` example

---
 clippy_lints/src/vec_init_then_push.rs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/vec_init_then_push.rs b/clippy_lints/src/vec_init_then_push.rs
index f0ae4e2a3ec..eb9bac4210b 100644
--- a/clippy_lints/src/vec_init_then_push.rs
+++ b/clippy_lints/src/vec_init_then_push.rs
@@ -33,10 +33,12 @@ declare_clippy_lint! {
     /// ```no_run
     /// let mut v = Vec::new();
     /// v.push(0);
+    /// v.push(1);
+    /// v.push(2);
     /// ```
     /// Use instead:
     /// ```no_run
-    /// let v = vec![0];
+    /// let v = vec![0, 1, 2];
     /// ```
     #[clippy::version = "1.51.0"]
     pub VEC_INIT_THEN_PUSH,
-- 
cgit 1.4.1-3-g733a5


From 4622203c9b19e0d93bb70acca15c9895d749b8dc Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Thu, 19 Oct 2023 14:59:44 +0000
Subject: Move configuration to new `clippy_config` crate

---
 Cargo.toml                                         |   5 +-
 book/src/lint_configuration.md                     |  26 +-
 clippy_config/Cargo.toml                           |  19 +
 clippy_config/src/conf.rs                          | 775 ++++++++++++++++++++
 clippy_config/src/lib.rs                           |  16 +
 clippy_config/src/metadata.rs                      | 112 +++
 clippy_config/src/msrvs.rs                         | 138 ++++
 clippy_config/src/types.rs                         | 119 +++
 clippy_lints/Cargo.toml                            |   3 +-
 clippy_lints/src/almost_complete_range.rs          |   2 +-
 clippy_lints/src/approx_const.rs                   |   2 +-
 clippy_lints/src/attrs.rs                          |   2 +-
 clippy_lints/src/await_holding_invalid.rs          |   3 +-
 clippy_lints/src/casts/cast_abs_to_unsigned.rs     |   2 +-
 clippy_lints/src/casts/cast_lossless.rs            |   2 +-
 .../src/casts/cast_slice_different_sizes.rs        |   2 +-
 .../src/casts/cast_slice_from_raw_parts.rs         |   2 +-
 clippy_lints/src/casts/mod.rs                      |   2 +-
 clippy_lints/src/casts/ptr_as_ptr.rs               |   2 +-
 clippy_lints/src/casts/ptr_cast_constness.rs       |   4 +-
 clippy_lints/src/checked_conversions.rs            |   2 +-
 clippy_lints/src/derivable_impls.rs                |   2 +-
 clippy_lints/src/disallowed_macros.rs              |   7 +-
 clippy_lints/src/disallowed_methods.rs             |   8 +-
 clippy_lints/src/disallowed_types.rs               |  11 +-
 clippy_lints/src/format_args.rs                    |   2 +-
 clippy_lints/src/from_over_into.rs                 |   2 +-
 clippy_lints/src/if_then_some_else_none.rs         |   2 +-
 clippy_lints/src/index_refutable_slice.rs          |   2 +-
 clippy_lints/src/instant_subtraction.rs            |   2 +-
 clippy_lints/src/lib.rs                            |   4 +-
 clippy_lints/src/loops/explicit_iter_loop.rs       |   2 +-
 clippy_lints/src/loops/mod.rs                      |   2 +-
 clippy_lints/src/manual_bits.rs                    |   2 +-
 clippy_lints/src/manual_clamp.rs                   |   2 +-
 clippy_lints/src/manual_hash_one.rs                |   2 +-
 clippy_lints/src/manual_is_ascii_check.rs          |   2 +-
 clippy_lints/src/manual_let_else.rs                |  12 +-
 clippy_lints/src/manual_main_separator_str.rs      |   2 +-
 clippy_lints/src/manual_non_exhaustive.rs          |   2 +-
 clippy_lints/src/manual_rem_euclid.rs              |   2 +-
 clippy_lints/src/manual_retain.rs                  |   2 +-
 clippy_lints/src/manual_strip.rs                   |   2 +-
 clippy_lints/src/matches/mod.rs                    |   2 +-
 clippy_lints/src/mem_replace.rs                    |   2 +-
 .../src/methods/cloned_instead_of_copied.rs        |   2 +-
 clippy_lints/src/methods/err_expect.rs             |   2 +-
 clippy_lints/src/methods/filter_map_next.rs        |   2 +-
 clippy_lints/src/methods/is_digit_ascii_radix.rs   |   2 +-
 clippy_lints/src/methods/manual_try_fold.rs        |   4 +-
 clippy_lints/src/methods/map_clone.rs              |   2 +-
 clippy_lints/src/methods/map_unwrap_or.rs          |   2 +-
 clippy_lints/src/methods/mod.rs                    |   2 +-
 clippy_lints/src/methods/option_as_ref_deref.rs    |   2 +-
 clippy_lints/src/methods/option_map_unwrap_or.rs   |   2 +-
 clippy_lints/src/methods/path_ends_with_ext.rs     |   3 +-
 clippy_lints/src/methods/str_splitn.rs             |   2 +-
 clippy_lints/src/methods/string_lit_chars_any.rs   |   4 +-
 clippy_lints/src/methods/unnecessary_to_owned.rs   |   2 +-
 clippy_lints/src/missing_const_for_fn.rs           |   2 +-
 clippy_lints/src/missing_enforced_import_rename.rs |   4 +-
 .../src/needless_borrows_for_generic_args.rs       |   2 +-
 clippy_lints/src/nonstandard_macro_braces.rs       |  85 +--
 clippy_lints/src/question_mark.rs                  |   5 +-
 clippy_lints/src/ranges.rs                         |   2 +-
 clippy_lints/src/redundant_field_names.rs          |   2 +-
 clippy_lints/src/redundant_static_lifetimes.rs     |   2 +-
 clippy_lints/src/trait_bounds.rs                   |   2 +-
 clippy_lints/src/transmute/mod.rs                  |   2 +-
 clippy_lints/src/transmute/transmute_ptr_to_ref.rs |   2 +-
 clippy_lints/src/tuple_array_conversions.rs        |   2 +-
 clippy_lints/src/unnested_or_patterns.rs           |   2 +-
 clippy_lints/src/use_self.rs                       |   2 +-
 clippy_lints/src/utils/conf.rs                     | 812 ---------------------
 clippy_lints/src/utils/format_args_collector.rs    |  15 +-
 .../src/utils/internal_lints/metadata_collector.rs |  14 +-
 clippy_lints/src/utils/mod.rs                      | 110 ---
 clippy_lints/src/vec.rs                            |   2 +-
 clippy_utils/Cargo.toml                            |   2 +-
 clippy_utils/src/lib.rs                            |   1 -
 clippy_utils/src/msrvs.rs                          | 130 ----
 clippy_utils/src/paths.rs                          |   2 +-
 clippy_utils/src/qualify_min_const_fn.rs           |   2 +-
 src/driver.rs                                      |   4 +-
 tests/compile-test.rs                              |   1 +
 tests/dogfood.rs                                   |  11 +-
 tests/ui-internal/invalid_msrv_attr_impl.fixed     |   2 +-
 tests/ui-internal/invalid_msrv_attr_impl.rs        |   2 +-
 tests/ui/min_rust_version_invalid_attr.rs          |   5 +-
 tests/ui/min_rust_version_invalid_attr.stderr      |  24 +-
 tests/versioncheck.rs                              |   1 +
 91 files changed, 1309 insertions(+), 1300 deletions(-)
 create mode 100644 clippy_config/Cargo.toml
 create mode 100644 clippy_config/src/conf.rs
 create mode 100644 clippy_config/src/lib.rs
 create mode 100644 clippy_config/src/metadata.rs
 create mode 100644 clippy_config/src/msrvs.rs
 create mode 100644 clippy_config/src/types.rs
 delete mode 100644 clippy_lints/src/utils/conf.rs
 delete mode 100644 clippy_utils/src/msrvs.rs

(limited to 'clippy_lints/src')

diff --git a/Cargo.toml b/Cargo.toml
index 2c50addfd7d..28f006957cd 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -21,11 +21,12 @@ name = "clippy-driver"
 path = "src/driver.rs"
 
 [dependencies]
+clippy_config = { path = "clippy_config" }
 clippy_lints = { path = "clippy_lints" }
 rustc_tools_util = "0.3.0"
 tempfile = { version = "3.2", optional = true }
 termize = "0.1"
-color-print = "0.3.4" # Sync version with Cargo
+color-print = "0.3.4"
 anstream = "0.5.0"
 
 [dev-dependencies]
@@ -54,7 +55,7 @@ rustc_tools_util = "0.3.0"
 [features]
 deny-warnings = ["clippy_lints/deny-warnings"]
 integration = ["tempfile"]
-internal = ["clippy_lints/internal", "tempfile"]
+internal = ["clippy_config/internal", "clippy_lints/internal", "tempfile"]
 
 [package.metadata.rust-analyzer]
 # This package uses #[feature(rustc_private)]
diff --git a/book/src/lint_configuration.md b/book/src/lint_configuration.md
index cbdf8a3001d..6b1a7ba54c6 100644
--- a/book/src/lint_configuration.md
+++ b/book/src/lint_configuration.md
@@ -26,7 +26,7 @@ arithmetic-side-effects-allowed = ["SomeType", "AnotherType"]
 A type, say `SomeType`, listed in this configuration has the same behavior of
 `["SomeType" , "*"], ["*", "SomeType"]` in `arithmetic_side_effects_allowed_binary`.
 
-**Default Value:** `{}` (`rustc_data_structures::fx::FxHashSet<String>`)
+**Default Value:** `{}` (`FxHashSet<String>`)
 
 ---
 **Affected lints:**
@@ -65,7 +65,7 @@ Suppress checking of the passed type names in unary operations like "negation" (
 arithmetic-side-effects-allowed-unary = ["SomeType", "AnotherType"]
 ```
 
-**Default Value:** `{}` (`rustc_data_structures::fx::FxHashSet<String>`)
+**Default Value:** `{}` (`FxHashSet<String>`)
 
 ---
 **Affected lints:**
@@ -100,7 +100,7 @@ Suppress lints whenever the suggested change would cause breakage for other crat
 ## `msrv`
 The minimum rust version that the project supports
 
-**Default Value:** `Msrv { stack: [] }` (`crate::Msrv`)
+**Default Value:** `Msrv { stack: [] }` (`Msrv`)
 
 ---
 **Affected lints:**
@@ -417,7 +417,7 @@ Whether to allow certain wildcard imports (prelude, super in tests).
 ## `disallowed-macros`
 The list of disallowed macros, written as fully qualified paths.
 
-**Default Value:** `[]` (`Vec<crate::utils::conf::DisallowedPath>`)
+**Default Value:** `[]` (`Vec<DisallowedPath>`)
 
 ---
 **Affected lints:**
@@ -427,7 +427,7 @@ The list of disallowed macros, written as fully qualified paths.
 ## `disallowed-methods`
 The list of disallowed methods, written as fully qualified paths.
 
-**Default Value:** `[]` (`Vec<crate::utils::conf::DisallowedPath>`)
+**Default Value:** `[]` (`Vec<DisallowedPath>`)
 
 ---
 **Affected lints:**
@@ -437,7 +437,7 @@ The list of disallowed methods, written as fully qualified paths.
 ## `disallowed-types`
 The list of disallowed types, written as fully qualified paths.
 
-**Default Value:** `[]` (`Vec<crate::utils::conf::DisallowedPath>`)
+**Default Value:** `[]` (`Vec<DisallowedPath>`)
 
 ---
 **Affected lints:**
@@ -468,7 +468,7 @@ Enables verbose mode. Triggers if there is more than one uppercase char next to
 Whether the matches should be considered by the lint, and whether there should
 be filtering for common types.
 
-**Default Value:** `WellKnownTypes` (`crate::manual_let_else::MatchLintBehaviour`)
+**Default Value:** `WellKnownTypes` (`MatchLintBehaviour`)
 
 ---
 **Affected lints:**
@@ -492,7 +492,7 @@ A `MacroMatcher` can be added like so `{ name = "macro_name", brace = "(" }`. If
 could be used with a full path two `MacroMatcher`s have to be added one with the full path
 `crate_name::macro_name` and one with just the macro name.
 
-**Default Value:** `[]` (`Vec<crate::nonstandard_macro_braces::MacroMatcher>`)
+**Default Value:** `[]` (`Vec<MacroMatcher>`)
 
 ---
 **Affected lints:**
@@ -502,7 +502,7 @@ could be used with a full path two `MacroMatcher`s have to be added one with the
 ## `enforced-import-renames`
 The list of imports to always rename, a fully qualified path followed by the rename.
 
-**Default Value:** `[]` (`Vec<crate::utils::conf::Rename>`)
+**Default Value:** `[]` (`Vec<Rename>`)
 
 ---
 **Affected lints:**
@@ -544,7 +544,7 @@ For example, `[_, _, _, e, ..]` is a slice pattern with 4 elements.
 ## `await-holding-invalid-types`
 
 
-**Default Value:** `[]` (`Vec<crate::utils::conf::DisallowedPath>`)
+**Default Value:** `[]` (`Vec<DisallowedPath>`)
 
 ---
 **Affected lints:**
@@ -694,7 +694,7 @@ Allowed names below the minimum allowed characters. The value `".."` can be used
 the list to indicate, that the configured values should be appended to the default
 configuration of Clippy. By default, any configuration will replace the default value.
 
-**Default Value:** `{"j", "z", "i", "y", "n", "x", "w"}` (`rustc_data_structures::fx::FxHashSet<String>`)
+**Default Value:** `{"j", "z", "i", "y", "n", "x", "w"}` (`FxHashSet<String>`)
 
 ---
 **Affected lints:**
@@ -755,7 +755,7 @@ be linted.
 ## `absolute-paths-allowed-crates`
 Which crates to allow absolute paths from
 
-**Default Value:** `{}` (`rustc_data_structures::fx::FxHashSet<String>`)
+**Default Value:** `{}` (`FxHashSet<String>`)
 
 ---
 **Affected lints:**
@@ -765,7 +765,7 @@ Which crates to allow absolute paths from
 ## `allowed-dotfiles`
 Additional dotfiles (files or directories starting with a dot) to allow
 
-**Default Value:** `{}` (`rustc_data_structures::fx::FxHashSet<String>`)
+**Default Value:** `{}` (`FxHashSet<String>`)
 
 ---
 **Affected lints:**
diff --git a/clippy_config/Cargo.toml b/clippy_config/Cargo.toml
new file mode 100644
index 00000000000..55f67b585e2
--- /dev/null
+++ b/clippy_config/Cargo.toml
@@ -0,0 +1,19 @@
+[package]
+name = "clippy_config"
+version = "0.1.75"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+rustc-semver = "1.1"
+serde = { version = "1.0", features = ["derive"] }
+toml = "0.7.3"
+
+[features]
+deny-warnings = []
+internal = []
+
+[package.metadata.rust-analyzer]
+# This crate uses #[feature(rustc_private)]
+rustc_private = true
diff --git a/clippy_config/src/conf.rs b/clippy_config/src/conf.rs
new file mode 100644
index 00000000000..d010dd5f42a
--- /dev/null
+++ b/clippy_config/src/conf.rs
@@ -0,0 +1,775 @@
+use crate::msrvs::Msrv;
+use crate::types::{DisallowedPath, MacroMatcher, MatchLintBehaviour, Rename};
+use crate::ClippyConfiguration;
+use rustc_data_structures::fx::FxHashSet;
+use rustc_session::Session;
+use rustc_span::{BytePos, Pos, SourceFile, Span, SyntaxContext};
+use serde::de::{Deserializer, IgnoredAny, IntoDeserializer, MapAccess, Visitor};
+use serde::Deserialize;
+use std::fmt::{Debug, Display, Formatter};
+use std::ops::Range;
+use std::path::PathBuf;
+use std::str::FromStr;
+use std::sync::OnceLock;
+use std::{cmp, env, fmt, fs, io};
+
+#[rustfmt::skip]
+const DEFAULT_DOC_VALID_IDENTS: &[&str] = &[
+    "KiB", "MiB", "GiB", "TiB", "PiB", "EiB",
+    "DirectX",
+    "ECMAScript",
+    "GPLv2", "GPLv3",
+    "GitHub", "GitLab",
+    "IPv4", "IPv6",
+    "ClojureScript", "CoffeeScript", "JavaScript", "PureScript", "TypeScript",
+    "WebAssembly",
+    "NaN", "NaNs",
+    "OAuth", "GraphQL",
+    "OCaml",
+    "OpenGL", "OpenMP", "OpenSSH", "OpenSSL", "OpenStreetMap", "OpenDNS",
+    "WebGL",
+    "TensorFlow",
+    "TrueType",
+    "iOS", "macOS", "FreeBSD",
+    "TeX", "LaTeX", "BibTeX", "BibLaTeX",
+    "MinGW",
+    "CamelCase",
+];
+const DEFAULT_DISALLOWED_NAMES: &[&str] = &["foo", "baz", "quux"];
+const DEFAULT_ALLOWED_IDENTS_BELOW_MIN_CHARS: &[&str] = &["i", "j", "x", "y", "z", "w", "n"];
+
+/// Conf with parse errors
+#[derive(Default)]
+pub struct TryConf {
+    pub conf: Conf,
+    pub errors: Vec<ConfError>,
+    pub warnings: Vec<ConfError>,
+}
+
+impl TryConf {
+    fn from_toml_error(file: &SourceFile, error: &toml::de::Error) -> Self {
+        Self {
+            conf: Conf::default(),
+            errors: vec![ConfError::from_toml(file, error)],
+            warnings: vec![],
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct ConfError {
+    pub message: String,
+    pub span: Span,
+}
+
+impl ConfError {
+    fn from_toml(file: &SourceFile, error: &toml::de::Error) -> Self {
+        let span = error.span().unwrap_or(0..file.source_len.0 as usize);
+        Self::spanned(file, error.message(), span)
+    }
+
+    fn spanned(file: &SourceFile, message: impl Into<String>, span: Range<usize>) -> Self {
+        Self {
+            message: message.into(),
+            span: Span::new(
+                file.start_pos + BytePos::from_usize(span.start),
+                file.start_pos + BytePos::from_usize(span.end),
+                SyntaxContext::root(),
+                None,
+            ),
+        }
+    }
+}
+
+macro_rules! define_Conf {
+    ($(
+        $(#[doc = $doc:literal])+
+        $(#[conf_deprecated($dep:literal, $new_conf:ident)])?
+        ($name:ident: $ty:ty = $default:expr),
+    )*) => {
+        /// Clippy lint configuration
+        pub struct Conf {
+            $($(#[doc = $doc])+ pub $name: $ty,)*
+        }
+
+        mod defaults {
+            use super::*;
+            $(pub fn $name() -> $ty { $default })*
+        }
+
+        impl Default for Conf {
+            fn default() -> Self {
+                Self { $($name: defaults::$name(),)* }
+            }
+        }
+
+        #[derive(Deserialize)]
+        #[serde(field_identifier, rename_all = "kebab-case")]
+        #[allow(non_camel_case_types)]
+        enum Field { $($name,)* third_party, }
+
+        struct ConfVisitor<'a>(&'a SourceFile);
+
+        impl<'de> Visitor<'de> for ConfVisitor<'_> {
+            type Value = TryConf;
+
+            fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+                formatter.write_str("Conf")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> Result<Self::Value, V::Error> where V: MapAccess<'de> {
+                let mut errors = Vec::new();
+                let mut warnings = Vec::new();
+                $(let mut $name = None;)*
+                // could get `Field` here directly, but get `String` first for diagnostics
+                while let Some(name) = map.next_key::<toml::Spanned<String>>()? {
+                    match Field::deserialize(name.get_ref().as_str().into_deserializer()) {
+                        Err(e) => {
+                            let e: FieldError = e;
+                            errors.push(ConfError::spanned(self.0, e.0, name.span()));
+                        }
+                        $(Ok(Field::$name) => {
+                            $(warnings.push(ConfError::spanned(self.0, format!("deprecated field `{}`. {}", name.get_ref(), $dep), name.span()));)?
+                            let raw_value = map.next_value::<toml::Spanned<toml::Value>>()?;
+                            let value_span = raw_value.span();
+                            match <$ty>::deserialize(raw_value.into_inner()) {
+                                Err(e) => errors.push(ConfError::spanned(self.0, e.to_string().replace('\n', " ").trim(), value_span)),
+                                Ok(value) => match $name {
+                                    Some(_) => errors.push(ConfError::spanned(self.0, format!("duplicate field `{}`", name.get_ref()), name.span())),
+                                    None => {
+                                        $name = Some(value);
+                                        // $new_conf is the same as one of the defined `$name`s, so
+                                        // this variable is defined in line 2 of this function.
+                                        $(match $new_conf {
+                                            Some(_) => errors.push(ConfError::spanned(self.0, concat!(
+                                                "duplicate field `", stringify!($new_conf),
+                                                "` (provided as `", stringify!($name), "`)"
+                                            ), name.span())),
+                                            None => $new_conf = $name.clone(),
+                                        })?
+                                    },
+                                }
+                            }
+                        })*
+                        // ignore contents of the third_party key
+                        Ok(Field::third_party) => drop(map.next_value::<IgnoredAny>())
+                    }
+                }
+                let conf = Conf { $($name: $name.unwrap_or_else(defaults::$name),)* };
+                Ok(TryConf { conf, errors, warnings })
+            }
+        }
+
+        macro_rules! wrap_option {
+            () => (None);
+            ($x:literal) => (Some($x));
+        }
+
+        pub fn get_configuration_metadata() -> Vec<ClippyConfiguration> {
+            vec![
+                $(
+                    {
+                        let deprecation_reason = wrap_option!($($dep)?);
+
+                        ClippyConfiguration::new(
+                            stringify!($name),
+                            stringify!($ty),
+                            format!("{:?}", defaults::$name()),
+                            concat!($($doc, '\n',)*),
+                            deprecation_reason,
+                        )
+                    },
+                )+
+            ]
+        }
+    };
+}
+
+define_Conf! {
+    /// Lint: ARITHMETIC_SIDE_EFFECTS.
+    ///
+    /// Suppress checking of the passed type names in all types of operations.
+    ///
+    /// If a specific operation is desired, consider using `arithmetic_side_effects_allowed_binary` or `arithmetic_side_effects_allowed_unary` instead.
+    ///
+    /// #### Example
+    ///
+    /// ```toml
+    /// arithmetic-side-effects-allowed = ["SomeType", "AnotherType"]
+    /// ```
+    ///
+    /// #### Noteworthy
+    ///
+    /// A type, say `SomeType`, listed in this configuration has the same behavior of
+    /// `["SomeType" , "*"], ["*", "SomeType"]` in `arithmetic_side_effects_allowed_binary`.
+    (arithmetic_side_effects_allowed: FxHashSet<String> = <_>::default()),
+    /// Lint: ARITHMETIC_SIDE_EFFECTS.
+    ///
+    /// Suppress checking of the passed type pair names in binary operations like addition or
+    /// multiplication.
+    ///
+    /// Supports the "*" wildcard to indicate that a certain type won't trigger the lint regardless
+    /// of the involved counterpart. For example, `["SomeType", "*"]` or `["*", "AnotherType"]`.
+    ///
+    /// Pairs are asymmetric, which means that `["SomeType", "AnotherType"]` is not the same as
+    /// `["AnotherType", "SomeType"]`.
+    ///
+    /// #### Example
+    ///
+    /// ```toml
+    /// arithmetic-side-effects-allowed-binary = [["SomeType" , "f32"], ["AnotherType", "*"]]
+    /// ```
+    (arithmetic_side_effects_allowed_binary: Vec<[String; 2]> = <_>::default()),
+    /// Lint: ARITHMETIC_SIDE_EFFECTS.
+    ///
+    /// Suppress checking of the passed type names in unary operations like "negation" (`-`).
+    ///
+    /// #### Example
+    ///
+    /// ```toml
+    /// arithmetic-side-effects-allowed-unary = ["SomeType", "AnotherType"]
+    /// ```
+    (arithmetic_side_effects_allowed_unary: FxHashSet<String> = <_>::default()),
+    /// Lint: ENUM_VARIANT_NAMES, LARGE_TYPES_PASSED_BY_VALUE, TRIVIALLY_COPY_PASS_BY_REF, UNNECESSARY_WRAPS, UNUSED_SELF, UPPER_CASE_ACRONYMS, WRONG_SELF_CONVENTION, BOX_COLLECTION, REDUNDANT_ALLOCATION, RC_BUFFER, VEC_BOX, OPTION_OPTION, LINKEDLIST, RC_MUTEX, UNNECESSARY_BOX_RETURNS, SINGLE_CALL_FN.
+    ///
+    /// Suppress lints whenever the suggested change would cause breakage for other crates.
+    (avoid_breaking_exported_api: bool = true),
+    /// Lint: MANUAL_SPLIT_ONCE, MANUAL_STR_REPEAT, CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, OPTION_MAP_UNWRAP_OR, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR, IF_THEN_SOME_ELSE_NONE, APPROX_CONSTANT, DEPRECATED_CFG_ATTR, INDEX_REFUTABLE_SLICE, MAP_CLONE, BORROW_AS_PTR, MANUAL_BITS, ERR_EXPECT, CAST_ABS_TO_UNSIGNED, UNINLINED_FORMAT_ARGS, MANUAL_CLAMP, MANUAL_LET_ELSE, UNCHECKED_DURATION_SUBTRACTION, COLLAPSIBLE_STR_REPLACE, SEEK_FROM_CURRENT, SEEK_REWIND, UNNECESSARY_LAZY_EVALUATIONS, TRANSMUTE_PTR_TO_REF, ALMOST_COMPLETE_RANGE, NEEDLESS_BORROW, DERIVABLE_IMPLS, MANUAL_IS_ASCII_CHECK, MANUAL_REM_EUCLID, MANUAL_RETAIN, TYPE_REPETITION_IN_BOUNDS, TUPLE_ARRAY_CONVERSIONS, MANUAL_TRY_FOLD, MANUAL_HASH_ONE.
+    ///
+    /// The minimum rust version that the project supports
+    (msrv: Msrv = Msrv::empty()),
+    /// DEPRECATED LINT: BLACKLISTED_NAME.
+    ///
+    /// Use the Disallowed Names lint instead
+    #[conf_deprecated("Please use `disallowed-names` instead", disallowed_names)]
+    (blacklisted_names: Vec<String> = Vec::new()),
+    /// Lint: COGNITIVE_COMPLEXITY.
+    ///
+    /// The maximum cognitive complexity a function can have
+    (cognitive_complexity_threshold: u64 = 25),
+    /// Lint: EXCESSIVE_NESTING.
+    ///
+    /// The maximum amount of nesting a block can reside in
+    (excessive_nesting_threshold: u64 = 0),
+    /// DEPRECATED LINT: CYCLOMATIC_COMPLEXITY.
+    ///
+    /// Use the Cognitive Complexity lint instead.
+    #[conf_deprecated("Please use `cognitive-complexity-threshold` instead", cognitive_complexity_threshold)]
+    (cyclomatic_complexity_threshold: u64 = 25),
+    /// Lint: DISALLOWED_NAMES.
+    ///
+    /// The list of disallowed names to lint about. NB: `bar` is not here since it has legitimate uses. The value
+    /// `".."` can be used as part of the list to indicate that the configured values should be appended to the
+    /// default configuration of Clippy. By default, any configuration will replace the default value.
+    (disallowed_names: Vec<String> = DEFAULT_DISALLOWED_NAMES.iter().map(ToString::to_string).collect()),
+    /// Lint: SEMICOLON_INSIDE_BLOCK.
+    ///
+    /// Whether to lint only if it's multiline.
+    (semicolon_inside_block_ignore_singleline: bool = false),
+    /// Lint: SEMICOLON_OUTSIDE_BLOCK.
+    ///
+    /// Whether to lint only if it's singleline.
+    (semicolon_outside_block_ignore_multiline: bool = false),
+    /// Lint: DOC_MARKDOWN.
+    ///
+    /// The list of words this lint should not consider as identifiers needing ticks. The value
+    /// `".."` can be used as part of the list to indicate, that the configured values should be appended to the
+    /// default configuration of Clippy. By default, any configuration will replace the default value. For example:
+    /// * `doc-valid-idents = ["ClipPy"]` would replace the default list with `["ClipPy"]`.
+    /// * `doc-valid-idents = ["ClipPy", ".."]` would append `ClipPy` to the default list.
+    ///
+    /// Default list:
+    (doc_valid_idents: Vec<String> = DEFAULT_DOC_VALID_IDENTS.iter().map(ToString::to_string).collect()),
+    /// Lint: TOO_MANY_ARGUMENTS.
+    ///
+    /// The maximum number of argument a function or method can have
+    (too_many_arguments_threshold: u64 = 7),
+    /// Lint: TYPE_COMPLEXITY.
+    ///
+    /// The maximum complexity a type can have
+    (type_complexity_threshold: u64 = 250),
+    /// Lint: MANY_SINGLE_CHAR_NAMES.
+    ///
+    /// The maximum number of single char bindings a scope may have
+    (single_char_binding_names_threshold: u64 = 4),
+    /// Lint: BOXED_LOCAL, USELESS_VEC.
+    ///
+    /// The maximum size of objects (in bytes) that will be linted. Larger objects are ok on the heap
+    (too_large_for_stack: u64 = 200),
+    /// Lint: ENUM_VARIANT_NAMES.
+    ///
+    /// The minimum number of enum variants for the lints about variant names to trigger
+    (enum_variant_name_threshold: u64 = 3),
+    /// Lint: STRUCT_VARIANT_NAMES.
+    ///
+    /// The minimum number of struct fields for the lints about field names to trigger
+    (struct_field_name_threshold: u64 = 3),
+    /// Lint: LARGE_ENUM_VARIANT.
+    ///
+    /// The maximum size of an enum's variant to avoid box suggestion
+    (enum_variant_size_threshold: u64 = 200),
+    /// Lint: VERBOSE_BIT_MASK.
+    ///
+    /// The maximum allowed size of a bit mask before suggesting to use 'trailing_zeros'
+    (verbose_bit_mask_threshold: u64 = 1),
+    /// Lint: DECIMAL_LITERAL_REPRESENTATION.
+    ///
+    /// The lower bound for linting decimal literals
+    (literal_representation_threshold: u64 = 16384),
+    /// Lint: TRIVIALLY_COPY_PASS_BY_REF.
+    ///
+    /// The maximum size (in bytes) to consider a `Copy` type for passing by value instead of by reference.
+    (trivial_copy_size_limit: Option<u64> = None),
+    /// Lint: LARGE_TYPES_PASSED_BY_VALUE.
+    ///
+    /// The minimum size (in bytes) to consider a type for passing by reference instead of by value.
+    (pass_by_value_size_limit: u64 = 256),
+    /// Lint: TOO_MANY_LINES.
+    ///
+    /// The maximum number of lines a function or method can have
+    (too_many_lines_threshold: u64 = 100),
+    /// Lint: LARGE_STACK_ARRAYS, LARGE_CONST_ARRAYS.
+    ///
+    /// The maximum allowed size for arrays on the stack
+    (array_size_threshold: u64 = 512_000),
+    /// Lint: LARGE_STACK_FRAMES.
+    ///
+    /// The maximum allowed stack size for functions in bytes
+    (stack_size_threshold: u64 = 512_000),
+    /// Lint: VEC_BOX.
+    ///
+    /// The size of the boxed type in bytes, where boxing in a `Vec` is allowed
+    (vec_box_size_threshold: u64 = 4096),
+    /// Lint: TYPE_REPETITION_IN_BOUNDS.
+    ///
+    /// The maximum number of bounds a trait can have to be linted
+    (max_trait_bounds: u64 = 3),
+    /// Lint: STRUCT_EXCESSIVE_BOOLS.
+    ///
+    /// The maximum number of bool fields a struct can have
+    (max_struct_bools: u64 = 3),
+    /// Lint: FN_PARAMS_EXCESSIVE_BOOLS.
+    ///
+    /// The maximum number of bool parameters a function can have
+    (max_fn_params_bools: u64 = 3),
+    /// Lint: WILDCARD_IMPORTS.
+    ///
+    /// Whether to allow certain wildcard imports (prelude, super in tests).
+    (warn_on_all_wildcard_imports: bool = false),
+    /// Lint: DISALLOWED_MACROS.
+    ///
+    /// The list of disallowed macros, written as fully qualified paths.
+    (disallowed_macros: Vec<DisallowedPath> = Vec::new()),
+    /// Lint: DISALLOWED_METHODS.
+    ///
+    /// The list of disallowed methods, written as fully qualified paths.
+    (disallowed_methods: Vec<DisallowedPath> = Vec::new()),
+    /// Lint: DISALLOWED_TYPES.
+    ///
+    /// The list of disallowed types, written as fully qualified paths.
+    (disallowed_types: Vec<DisallowedPath> = Vec::new()),
+    /// Lint: UNREADABLE_LITERAL.
+    ///
+    /// Should the fraction of a decimal be linted to include separators.
+    (unreadable_literal_lint_fractions: bool = true),
+    /// Lint: UPPER_CASE_ACRONYMS.
+    ///
+    /// Enables verbose mode. Triggers if there is more than one uppercase char next to each other
+    (upper_case_acronyms_aggressive: bool = false),
+    /// Lint: MANUAL_LET_ELSE.
+    ///
+    /// Whether the matches should be considered by the lint, and whether there should
+    /// be filtering for common types.
+    (matches_for_let_else: MatchLintBehaviour = MatchLintBehaviour::WellKnownTypes),
+    /// Lint: _CARGO_COMMON_METADATA.
+    ///
+    /// For internal testing only, ignores the current `publish` settings in the Cargo manifest.
+    (cargo_ignore_publish: bool = false),
+    /// Lint: NONSTANDARD_MACRO_BRACES.
+    ///
+    /// Enforce the named macros always use the braces specified.
+    ///
+    /// A `MacroMatcher` can be added like so `{ name = "macro_name", brace = "(" }`. If the macro
+    /// could be used with a full path two `MacroMatcher`s have to be added one with the full path
+    /// `crate_name::macro_name` and one with just the macro name.
+    (standard_macro_braces: Vec<MacroMatcher> = Vec::new()),
+    /// Lint: MISSING_ENFORCED_IMPORT_RENAMES.
+    ///
+    /// The list of imports to always rename, a fully qualified path followed by the rename.
+    (enforced_import_renames: Vec<Rename> = Vec::new()),
+    /// Lint: DISALLOWED_SCRIPT_IDENTS.
+    ///
+    /// The list of unicode scripts allowed to be used in the scope.
+    (allowed_scripts: Vec<String> = vec!["Latin".to_string()]),
+    /// Lint: NON_SEND_FIELDS_IN_SEND_TY.
+    ///
+    /// Whether to apply the raw pointer heuristic to determine if a type is `Send`.
+    (enable_raw_pointer_heuristic_for_send: bool = true),
+    /// Lint: INDEX_REFUTABLE_SLICE.
+    ///
+    /// When Clippy suggests using a slice pattern, this is the maximum number of elements allowed in
+    /// the slice pattern that is suggested. If more elements are necessary, the lint is suppressed.
+    /// For example, `[_, _, _, e, ..]` is a slice pattern with 4 elements.
+    (max_suggested_slice_pattern_length: u64 = 3),
+    /// Lint: AWAIT_HOLDING_INVALID_TYPE.
+    (await_holding_invalid_types: Vec<DisallowedPath> = Vec::new()),
+    /// Lint: LARGE_INCLUDE_FILE.
+    ///
+    /// The maximum size of a file included via `include_bytes!()` or `include_str!()`, in bytes
+    (max_include_file_size: u64 = 1_000_000),
+    /// Lint: EXPECT_USED.
+    ///
+    /// Whether `expect` should be allowed in test functions or `#[cfg(test)]`
+    (allow_expect_in_tests: bool = false),
+    /// Lint: UNWRAP_USED.
+    ///
+    /// Whether `unwrap` should be allowed in test functions or `#[cfg(test)]`
+    (allow_unwrap_in_tests: bool = false),
+    /// Lint: DBG_MACRO.
+    ///
+    /// Whether `dbg!` should be allowed in test functions or `#[cfg(test)]`
+    (allow_dbg_in_tests: bool = false),
+    /// Lint: PRINT_STDOUT, PRINT_STDERR.
+    ///
+    /// Whether print macros (ex. `println!`) should be allowed in test functions or `#[cfg(test)]`
+    (allow_print_in_tests: bool = false),
+    /// Lint: RESULT_LARGE_ERR.
+    ///
+    /// The maximum size of the `Err`-variant in a `Result` returned from a function
+    (large_error_threshold: u64 = 128),
+    /// Lint: MUTABLE_KEY_TYPE, IFS_SAME_COND.
+    ///
+    /// A list of paths to types that should be treated like `Arc`, i.e. ignored but
+    /// for the generic parameters for determining interior mutability
+    (ignore_interior_mutability: Vec<String> = Vec::from(["bytes::Bytes".into()])),
+    /// Lint: UNINLINED_FORMAT_ARGS.
+    ///
+    /// Whether to allow mixed uninlined format args, e.g. `format!("{} {}", a, foo.bar)`
+    (allow_mixed_uninlined_format_args: bool = true),
+    /// Lint: INDEXING_SLICING.
+    ///
+    /// Whether to suppress a restriction lint in constant code. In same
+    /// cases the restructured operation might not be unavoidable, as the
+    /// suggested counterparts are unavailable in constant code. This
+    /// configuration will cause restriction lints to trigger even
+    /// if no suggestion can be made.
+    (suppress_restriction_lint_in_const: bool = false),
+    /// Lint: MISSING_DOCS_IN_PRIVATE_ITEMS.
+    ///
+    /// Whether to **only** check for missing documentation in items visible within the current
+    /// crate. For example, `pub(crate)` items.
+    (missing_docs_in_crate_items: bool = false),
+    /// Lint: LARGE_FUTURES.
+    ///
+    /// The maximum byte size a `Future` can have, before it triggers the `clippy::large_futures` lint
+    (future_size_threshold: u64 = 16 * 1024),
+    /// Lint: UNNECESSARY_BOX_RETURNS.
+    ///
+    /// The byte size a `T` in `Box<T>` can have, below which it triggers the `clippy::unnecessary_box` lint
+    (unnecessary_box_size: u64 = 128),
+    /// Lint: MODULE_INCEPTION.
+    ///
+    /// Whether to allow module inception if it's not public.
+    (allow_private_module_inception: bool = false),
+    /// Lint: MIN_IDENT_CHARS.
+    ///
+    /// Allowed names below the minimum allowed characters. The value `".."` can be used as part of
+    /// the list to indicate, that the configured values should be appended to the default
+    /// configuration of Clippy. By default, any configuration will replace the default value.
+    (allowed_idents_below_min_chars: FxHashSet<String> =
+        DEFAULT_ALLOWED_IDENTS_BELOW_MIN_CHARS.iter().map(ToString::to_string).collect()),
+    /// Lint: MIN_IDENT_CHARS.
+    ///
+    /// Minimum chars an ident can have, anything below or equal to this will be linted.
+    (min_ident_chars_threshold: u64 = 1),
+    /// Lint: UNDOCUMENTED_UNSAFE_BLOCKS.
+    ///
+    /// Whether to accept a safety comment to be placed above the statement containing the `unsafe` block
+    (accept_comment_above_statement: bool = true),
+    /// Lint: UNDOCUMENTED_UNSAFE_BLOCKS.
+    ///
+    /// Whether to accept a safety comment to be placed above the attributes for the `unsafe` block
+    (accept_comment_above_attributes: bool = true),
+    /// Lint: UNNECESSARY_RAW_STRING_HASHES.
+    ///
+    /// Whether to allow `r#""#` when `r""` can be used
+    (allow_one_hash_in_raw_strings: bool = false),
+    /// Lint: ABSOLUTE_PATHS.
+    ///
+    /// The maximum number of segments a path can have before being linted, anything above this will
+    /// be linted.
+    (absolute_paths_max_segments: u64 = 2),
+    /// Lint: ABSOLUTE_PATHS.
+    ///
+    /// Which crates to allow absolute paths from
+    (absolute_paths_allowed_crates: FxHashSet<String> = FxHashSet::default()),
+    /// Lint: PATH_ENDS_WITH_EXT.
+    ///
+    /// Additional dotfiles (files or directories starting with a dot) to allow
+    (allowed_dotfiles: FxHashSet<String> = FxHashSet::default()),
+    /// Lint: EXPLICIT_ITER_LOOP
+    ///
+    /// Whether to recommend using implicit into iter for reborrowed values.
+    ///
+    /// #### Example
+    /// ```no_run
+    /// let mut vec = vec![1, 2, 3];
+    /// let rmvec = &mut vec;
+    /// for _ in rmvec.iter() {}
+    /// for _ in rmvec.iter_mut() {}
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// let mut vec = vec![1, 2, 3];
+    /// let rmvec = &mut vec;
+    /// for _ in &*rmvec {}
+    /// for _ in &mut *rmvec {}
+    /// ```
+    (enforce_iter_loop_reborrow: bool = false),
+}
+
+/// Search for the configuration file.
+///
+/// # Errors
+///
+/// Returns any unexpected filesystem error encountered when searching for the config file
+pub fn lookup_conf_file() -> io::Result<(Option<PathBuf>, Vec<String>)> {
+    /// Possible filename to search for.
+    const CONFIG_FILE_NAMES: [&str; 2] = [".clippy.toml", "clippy.toml"];
+
+    // Start looking for a config file in CLIPPY_CONF_DIR, or failing that, CARGO_MANIFEST_DIR.
+    // If neither of those exist, use ".". (Update documentation if this priority changes)
+    let mut current = env::var_os("CLIPPY_CONF_DIR")
+        .or_else(|| env::var_os("CARGO_MANIFEST_DIR"))
+        .map_or_else(|| PathBuf::from("."), PathBuf::from)
+        .canonicalize()?;
+
+    let mut found_config: Option<PathBuf> = None;
+    let mut warnings = vec![];
+
+    loop {
+        for config_file_name in &CONFIG_FILE_NAMES {
+            if let Ok(config_file) = current.join(config_file_name).canonicalize() {
+                match fs::metadata(&config_file) {
+                    Err(e) if e.kind() == io::ErrorKind::NotFound => {},
+                    Err(e) => return Err(e),
+                    Ok(md) if md.is_dir() => {},
+                    Ok(_) => {
+                        // warn if we happen to find two config files #8323
+                        if let Some(ref found_config) = found_config {
+                            warnings.push(format!(
+                                "using config file `{}`, `{}` will be ignored",
+                                found_config.display(),
+                                config_file.display()
+                            ));
+                        } else {
+                            found_config = Some(config_file);
+                        }
+                    },
+                }
+            }
+        }
+
+        if found_config.is_some() {
+            return Ok((found_config, warnings));
+        }
+
+        // If the current directory has no parent, we're done searching.
+        if !current.pop() {
+            return Ok((None, warnings));
+        }
+    }
+}
+
+fn deserialize(file: &SourceFile) -> TryConf {
+    match toml::de::Deserializer::new(file.src.as_ref().unwrap()).deserialize_map(ConfVisitor(file)) {
+        Ok(mut conf) => {
+            extend_vec_if_indicator_present(&mut conf.conf.doc_valid_idents, DEFAULT_DOC_VALID_IDENTS);
+            extend_vec_if_indicator_present(&mut conf.conf.disallowed_names, DEFAULT_DISALLOWED_NAMES);
+            // TODO: THIS SHOULD BE TESTED, this comment will be gone soon
+            if conf.conf.allowed_idents_below_min_chars.contains(&"..".to_owned()) {
+                conf.conf
+                    .allowed_idents_below_min_chars
+                    .extend(DEFAULT_ALLOWED_IDENTS_BELOW_MIN_CHARS.iter().map(ToString::to_string));
+            }
+
+            conf
+        },
+        Err(e) => TryConf::from_toml_error(file, &e),
+    }
+}
+
+fn extend_vec_if_indicator_present(vec: &mut Vec<String>, default: &[&str]) {
+    if vec.contains(&"..".to_string()) {
+        vec.extend(default.iter().map(ToString::to_string));
+    }
+}
+
+impl Conf {
+    pub fn read(sess: &Session, path: &io::Result<(Option<PathBuf>, Vec<String>)>) -> &'static Conf {
+        static CONF: OnceLock<Conf> = OnceLock::new();
+        CONF.get_or_init(|| Conf::read_inner(sess, path))
+    }
+
+    fn read_inner(sess: &Session, path: &io::Result<(Option<PathBuf>, Vec<String>)>) -> Conf {
+        match path {
+            Ok((_, warnings)) => {
+                for warning in warnings {
+                    sess.warn(warning.clone());
+                }
+            },
+            Err(error) => {
+                sess.err(format!("error finding Clippy's configuration file: {error}"));
+            },
+        }
+
+        let TryConf {
+            mut conf,
+            errors,
+            warnings,
+        } = match path {
+            Ok((Some(path), _)) => match sess.source_map().load_file(path) {
+                Ok(file) => deserialize(&file),
+                Err(error) => {
+                    sess.err(format!("failed to read `{}`: {error}", path.display()));
+                    TryConf::default()
+                },
+            },
+            _ => TryConf::default(),
+        };
+
+        conf.msrv.read_cargo(sess);
+
+        // all conf errors are non-fatal, we just use the default conf in case of error
+        for error in errors {
+            sess.span_err(
+                error.span,
+                format!("error reading Clippy's configuration file: {}", error.message),
+            );
+        }
+
+        for warning in warnings {
+            sess.span_warn(
+                warning.span,
+                format!("error reading Clippy's configuration file: {}", warning.message),
+            );
+        }
+
+        conf
+    }
+}
+
+const SEPARATOR_WIDTH: usize = 4;
+
+#[derive(Debug)]
+struct FieldError(String);
+
+impl std::error::Error for FieldError {}
+
+impl Display for FieldError {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        f.pad(&self.0)
+    }
+}
+
+impl serde::de::Error for FieldError {
+    fn custom<T: Display>(msg: T) -> Self {
+        Self(msg.to_string())
+    }
+
+    fn unknown_field(field: &str, expected: &'static [&'static str]) -> Self {
+        // List the available fields sorted and at least one per line, more if `CLIPPY_TERMINAL_WIDTH` is
+        // set and allows it.
+        use fmt::Write;
+
+        let mut expected = expected.to_vec();
+        expected.sort_unstable();
+
+        let (rows, column_widths) = calculate_dimensions(&expected);
+
+        let mut msg = format!("unknown field `{field}`, expected one of");
+        for row in 0..rows {
+            writeln!(msg).unwrap();
+            for (column, column_width) in column_widths.iter().copied().enumerate() {
+                let index = column * rows + row;
+                let field = expected.get(index).copied().unwrap_or_default();
+                write!(msg, "{:SEPARATOR_WIDTH$}{field:column_width$}", " ").unwrap();
+            }
+        }
+        Self(msg)
+    }
+}
+
+fn calculate_dimensions(fields: &[&str]) -> (usize, Vec<usize>) {
+    let columns = env::var("CLIPPY_TERMINAL_WIDTH")
+        .ok()
+        .and_then(|s| <usize as FromStr>::from_str(&s).ok())
+        .map_or(1, |terminal_width| {
+            let max_field_width = fields.iter().map(|field| field.len()).max().unwrap();
+            cmp::max(1, terminal_width / (SEPARATOR_WIDTH + max_field_width))
+        });
+
+    let rows = (fields.len() + (columns - 1)) / columns;
+
+    let column_widths = (0..columns)
+        .map(|column| {
+            if column < columns - 1 {
+                (0..rows)
+                    .map(|row| {
+                        let index = column * rows + row;
+                        let field = fields.get(index).copied().unwrap_or_default();
+                        field.len()
+                    })
+                    .max()
+                    .unwrap()
+            } else {
+                // Avoid adding extra space to the last column.
+                0
+            }
+        })
+        .collect::<Vec<_>>();
+
+    (rows, column_widths)
+}
+
+#[cfg(test)]
+mod tests {
+    use rustc_data_structures::fx::{FxHashMap, FxHashSet};
+    use serde::de::IgnoredAny;
+    use std::fs;
+    use walkdir::WalkDir;
+
+    #[test]
+    fn configs_are_tested() {
+        let mut names: FxHashSet<String> = super::metadata::get_configuration_metadata()
+            .into_iter()
+            .map(|meta| meta.name.replace('_', "-"))
+            .collect();
+
+        let toml_files = WalkDir::new("../tests")
+            .into_iter()
+            .map(Result::unwrap)
+            .filter(|entry| entry.file_name() == "clippy.toml");
+
+        for entry in toml_files {
+            let file = fs::read_to_string(entry.path()).unwrap();
+            #[allow(clippy::zero_sized_map_values)]
+            if let Ok(map) = toml::from_str::<FxHashMap<String, IgnoredAny>>(&file) {
+                for name in map.keys() {
+                    names.remove(name.as_str());
+                }
+            }
+        }
+
+        assert!(
+            names.remove("allow-one-hash-in-raw-strings"),
+            "remove this when #11481 is fixed"
+        );
+
+        assert!(
+            names.is_empty(),
+            "Configuration variable lacks test: {names:?}\nAdd a test to `tests/ui-toml`"
+        );
+    }
+}
diff --git a/clippy_config/src/lib.rs b/clippy_config/src/lib.rs
new file mode 100644
index 00000000000..44bbeb17209
--- /dev/null
+++ b/clippy_config/src/lib.rs
@@ -0,0 +1,16 @@
+#![feature(rustc_private, let_chains)]
+#![cfg_attr(feature = "deny-warnings", deny(warnings))]
+#![warn(rust_2018_idioms, unused_lifetimes)]
+
+extern crate rustc_ast;
+extern crate rustc_data_structures;
+extern crate rustc_session;
+extern crate rustc_span;
+
+mod conf;
+mod metadata;
+pub mod msrvs;
+pub mod types;
+
+pub use conf::{get_configuration_metadata, lookup_conf_file, Conf};
+pub use metadata::ClippyConfiguration;
diff --git a/clippy_config/src/metadata.rs b/clippy_config/src/metadata.rs
new file mode 100644
index 00000000000..c40cbd6330f
--- /dev/null
+++ b/clippy_config/src/metadata.rs
@@ -0,0 +1,112 @@
+use std::fmt;
+
+#[derive(Debug, Clone, Default)]
+pub struct ClippyConfiguration {
+    pub name: String,
+    config_type: &'static str,
+    pub default: String,
+    pub lints: Vec<String>,
+    pub doc: String,
+    #[allow(dead_code)]
+    pub deprecation_reason: Option<&'static str>,
+}
+
+impl fmt::Display for ClippyConfiguration {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        writeln!(
+            f,
+            "* `{}`: `{}`(defaults to `{}`): {}",
+            self.name, self.config_type, self.default, self.doc
+        )
+    }
+}
+
+impl ClippyConfiguration {
+    pub fn new(
+        name: &'static str,
+        config_type: &'static str,
+        default: String,
+        doc_comment: &'static str,
+        deprecation_reason: Option<&'static str>,
+    ) -> Self {
+        let (lints, doc) = parse_config_field_doc(doc_comment)
+            .unwrap_or_else(|| (vec![], "[ERROR] MALFORMED DOC COMMENT".to_string()));
+
+        Self {
+            name: to_kebab(name),
+            lints,
+            doc,
+            config_type,
+            default,
+            deprecation_reason,
+        }
+    }
+
+    #[cfg(feature = "internal")]
+    pub fn to_markdown_paragraph(&self) -> String {
+        format!(
+            "## `{}`\n{}\n\n**Default Value:** `{}` (`{}`)\n\n---\n**Affected lints:**\n{}\n\n",
+            self.name,
+            self.doc
+                .lines()
+                .map(|line| line.strip_prefix("    ").unwrap_or(line))
+                .collect::<Vec<_>>()
+                .join("\n"),
+            self.default,
+            self.config_type,
+            self.lints
+                .iter()
+                .map(|name| name.to_string().split_whitespace().next().unwrap().to_string())
+                .map(|name| format!("* [`{name}`](https://rust-lang.github.io/rust-clippy/master/index.html#{name})"))
+                .collect::<Vec<_>>()
+                .join("\n"),
+        )
+    }
+
+    #[cfg(feature = "internal")]
+    pub fn to_markdown_link(&self) -> String {
+        const BOOK_CONFIGS_PATH: &str = "https://doc.rust-lang.org/clippy/lint_configuration.html";
+        format!("[`{}`]: {BOOK_CONFIGS_PATH}#{}", self.name, self.name)
+    }
+}
+
+/// This parses the field documentation of the config struct.
+///
+/// ```rust, ignore
+/// parse_config_field_doc(cx, "Lint: LINT_NAME_1, LINT_NAME_2. Papa penguin, papa penguin")
+/// ```
+///
+/// Would yield:
+/// ```rust, ignore
+/// Some(["lint_name_1", "lint_name_2"], "Papa penguin, papa penguin")
+/// ```
+fn parse_config_field_doc(doc_comment: &str) -> Option<(Vec<String>, String)> {
+    const DOC_START: &str = " Lint: ";
+    if doc_comment.starts_with(DOC_START)
+        && let Some(split_pos) = doc_comment.find('.')
+    {
+        let mut doc_comment = doc_comment.to_string();
+        let mut documentation = doc_comment.split_off(split_pos);
+
+        // Extract lints
+        doc_comment.make_ascii_lowercase();
+        let lints: Vec<String> = doc_comment
+            .split_off(DOC_START.len())
+            .split(", ")
+            .map(str::to_string)
+            .collect();
+
+        // Format documentation correctly
+        // split off leading `.` from lint name list and indent for correct formatting
+        documentation = documentation.trim_start_matches('.').trim().replace("\n ", "\n    ");
+
+        Some((lints, documentation))
+    } else {
+        None
+    }
+}
+
+/// Transforms a given `snake_case_string` to a tasty `kebab-case-string`
+fn to_kebab(config_name: &str) -> String {
+    config_name.replace('_', "-")
+}
diff --git a/clippy_config/src/msrvs.rs b/clippy_config/src/msrvs.rs
new file mode 100644
index 00000000000..2cdfa6b42f9
--- /dev/null
+++ b/clippy_config/src/msrvs.rs
@@ -0,0 +1,138 @@
+use rustc_ast::Attribute;
+use rustc_semver::RustcVersion;
+use rustc_session::Session;
+use rustc_span::{sym, Symbol};
+use serde::Deserialize;
+
+macro_rules! msrv_aliases {
+    ($($major:literal,$minor:literal,$patch:literal {
+        $($name:ident),* $(,)?
+    })*) => {
+        $($(
+        pub const $name: RustcVersion = RustcVersion::new($major, $minor, $patch);
+        )*)*
+    };
+}
+
+// names may refer to stabilized feature flags or library items
+msrv_aliases! {
+    1,71,0 { TUPLE_ARRAY_CONVERSIONS, BUILD_HASHER_HASH_ONE }
+    1,70,0 { OPTION_IS_SOME_AND, BINARY_HEAP_RETAIN }
+    1,68,0 { PATH_MAIN_SEPARATOR_STR }
+    1,65,0 { LET_ELSE, POINTER_CAST_CONSTNESS }
+    1,62,0 { BOOL_THEN_SOME, DEFAULT_ENUM_ATTRIBUTE }
+    1,58,0 { FORMAT_ARGS_CAPTURE, PATTERN_TRAIT_CHAR_ARRAY }
+    1,55,0 { SEEK_REWIND }
+    1,53,0 { OR_PATTERNS, MANUAL_BITS, BTREE_MAP_RETAIN, BTREE_SET_RETAIN, ARRAY_INTO_ITERATOR }
+    1,52,0 { STR_SPLIT_ONCE, REM_EUCLID_CONST }
+    1,51,0 { BORROW_AS_PTR, SEEK_FROM_CURRENT, UNSIGNED_ABS }
+    1,50,0 { BOOL_THEN, CLAMP }
+    1,47,0 { TAU, IS_ASCII_DIGIT_CONST, ARRAY_IMPL_ANY_LEN }
+    1,46,0 { CONST_IF_MATCH }
+    1,45,0 { STR_STRIP_PREFIX }
+    1,43,0 { LOG2_10, LOG10_2 }
+    1,42,0 { MATCHES_MACRO, SLICE_PATTERNS, PTR_SLICE_RAW_PARTS }
+    1,41,0 { RE_REBALANCING_COHERENCE, RESULT_MAP_OR_ELSE }
+    1,40,0 { MEM_TAKE, NON_EXHAUSTIVE, OPTION_AS_DEREF }
+    1,38,0 { POINTER_CAST, REM_EUCLID }
+    1,37,0 { TYPE_ALIAS_ENUM_VARIANTS }
+    1,36,0 { ITERATOR_COPIED }
+    1,35,0 { OPTION_COPIED, RANGE_CONTAINS }
+    1,34,0 { TRY_FROM }
+    1,30,0 { ITERATOR_FIND_MAP, TOOL_ATTRIBUTES }
+    1,28,0 { FROM_BOOL }
+    1,27,0 { ITERATOR_TRY_FOLD }
+    1,26,0 { RANGE_INCLUSIVE, STRING_RETAIN }
+    1,24,0 { IS_ASCII_DIGIT }
+    1,18,0 { HASH_MAP_RETAIN, HASH_SET_RETAIN }
+    1,17,0 { FIELD_INIT_SHORTHAND, STATIC_IN_CONST, EXPECT_ERR }
+    1,16,0 { STR_REPEAT }
+    1,15,0 { MAYBE_BOUND_IN_WHERE }
+}
+
+/// Tracks the current MSRV from `clippy.toml`, `Cargo.toml` or set via `#[clippy::msrv]`
+#[derive(Debug, Clone)]
+pub struct Msrv {
+    stack: Vec<RustcVersion>,
+}
+
+impl<'de> Deserialize<'de> for Msrv {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let v = String::deserialize(deserializer)?;
+        RustcVersion::parse(&v)
+            .map(|v| Msrv { stack: vec![v] })
+            .map_err(|_| serde::de::Error::custom("not a valid Rust version"))
+    }
+}
+
+impl Msrv {
+    pub fn empty() -> Msrv {
+        Msrv { stack: Vec::new() }
+    }
+
+    pub fn read_cargo(&mut self, sess: &Session) {
+        let cargo_msrv = std::env::var("CARGO_PKG_RUST_VERSION")
+            .ok()
+            .and_then(|v| RustcVersion::parse(&v).ok());
+
+        match (self.current(), cargo_msrv) {
+            (None, Some(cargo_msrv)) => self.stack = vec![cargo_msrv],
+            (Some(clippy_msrv), Some(cargo_msrv)) => {
+                if clippy_msrv != cargo_msrv {
+                    sess.warn(format!(
+                        "the MSRV in `clippy.toml` and `Cargo.toml` differ; using `{clippy_msrv}` from `clippy.toml`"
+                    ));
+                }
+            },
+            _ => {},
+        }
+    }
+
+    pub fn current(&self) -> Option<RustcVersion> {
+        self.stack.last().copied()
+    }
+
+    pub fn meets(&self, required: RustcVersion) -> bool {
+        self.current().map_or(true, |version| version.meets(required))
+    }
+
+    fn parse_attr(sess: &Session, attrs: &[Attribute]) -> Option<RustcVersion> {
+        let sym_msrv = Symbol::intern("msrv");
+        let mut msrv_attrs = attrs.iter().filter(|attr| attr.path_matches(&[sym::clippy, sym_msrv]));
+
+        if let Some(msrv_attr) = msrv_attrs.next() {
+            if let Some(duplicate) = msrv_attrs.last() {
+                sess.struct_span_err(duplicate.span, format!("`clippy::msrv` is defined multiple times"))
+                    .span_note(msrv_attr.span, "first definition found here")
+                    .emit();
+            }
+
+            if let Some(msrv) = msrv_attr.value_str() {
+                if let Ok(version) = RustcVersion::parse(msrv.as_str()) {
+                    return Some(version);
+                }
+
+                sess.span_err(msrv_attr.span, format!("`{msrv}` is not a valid Rust version"));
+            } else {
+                sess.span_err(msrv_attr.span, "bad clippy attribute");
+            }
+        }
+
+        None
+    }
+
+    pub fn enter_lint_attrs(&mut self, sess: &Session, attrs: &[Attribute]) {
+        if let Some(version) = Self::parse_attr(sess, attrs) {
+            self.stack.push(version);
+        }
+    }
+
+    pub fn exit_lint_attrs(&mut self, sess: &Session, attrs: &[Attribute]) {
+        if Self::parse_attr(sess, attrs).is_some() {
+            self.stack.pop();
+        }
+    }
+}
diff --git a/clippy_config/src/types.rs b/clippy_config/src/types.rs
new file mode 100644
index 00000000000..d179f6baab7
--- /dev/null
+++ b/clippy_config/src/types.rs
@@ -0,0 +1,119 @@
+use serde::de::{self, Deserializer, Visitor};
+use serde::Deserialize;
+use std::fmt;
+use std::hash::{Hash, Hasher};
+
+#[derive(Clone, Debug, Deserialize)]
+pub struct Rename {
+    pub path: String,
+    pub rename: String,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(untagged)]
+pub enum DisallowedPath {
+    Simple(String),
+    WithReason { path: String, reason: Option<String> },
+}
+
+impl DisallowedPath {
+    pub fn path(&self) -> &str {
+        let (Self::Simple(path) | Self::WithReason { path, .. }) = self;
+
+        path
+    }
+
+    pub fn reason(&self) -> Option<String> {
+        match self {
+            Self::WithReason {
+                reason: Some(reason), ..
+            } => Some(format!("{reason} (from clippy.toml)")),
+            _ => None,
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Deserialize)]
+pub enum MatchLintBehaviour {
+    AllTypes,
+    WellKnownTypes,
+    Never,
+}
+
+#[derive(Clone, Debug)]
+pub struct MacroMatcher {
+    pub name: String,
+    pub braces: (String, String),
+}
+
+impl Hash for MacroMatcher {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.name.hash(state);
+    }
+}
+
+impl PartialEq for MacroMatcher {
+    fn eq(&self, other: &Self) -> bool {
+        self.name == other.name
+    }
+}
+impl Eq for MacroMatcher {}
+
+impl<'de> Deserialize<'de> for MacroMatcher {
+    fn deserialize<D>(deser: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        #[derive(Deserialize)]
+        #[serde(field_identifier, rename_all = "lowercase")]
+        enum Field {
+            Name,
+            Brace,
+        }
+        struct MacVisitor;
+        impl<'de> Visitor<'de> for MacVisitor {
+            type Value = MacroMatcher;
+
+            fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+                formatter.write_str("struct MacroMatcher")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> Result<Self::Value, V::Error>
+            where
+                V: de::MapAccess<'de>,
+            {
+                let mut name = None;
+                let mut brace: Option<String> = None;
+                while let Some(key) = map.next_key()? {
+                    match key {
+                        Field::Name => {
+                            if name.is_some() {
+                                return Err(de::Error::duplicate_field("name"));
+                            }
+                            name = Some(map.next_value()?);
+                        },
+                        Field::Brace => {
+                            if brace.is_some() {
+                                return Err(de::Error::duplicate_field("brace"));
+                            }
+                            brace = Some(map.next_value()?);
+                        },
+                    }
+                }
+                let name = name.ok_or_else(|| de::Error::missing_field("name"))?;
+                let brace = brace.ok_or_else(|| de::Error::missing_field("brace"))?;
+                Ok(MacroMatcher {
+                    name,
+                    braces: [("(", ")"), ("{", "}"), ("[", "]")]
+                        .into_iter()
+                        .find(|b| b.0 == brace)
+                        .map(|(o, c)| (o.to_owned(), c.to_owned()))
+                        .ok_or_else(|| de::Error::custom(format!("expected one of `(`, `{{`, `[` found `{brace}`")))?,
+                })
+            }
+        }
+
+        const FIELDS: &[&str] = &["name", "brace"];
+        deser.deserialize_struct("MacroMatcher", FIELDS, MacVisitor)
+    }
+}
diff --git a/clippy_lints/Cargo.toml b/clippy_lints/Cargo.toml
index 4d5b3bf8a94..54f67c59761 100644
--- a/clippy_lints/Cargo.toml
+++ b/clippy_lints/Cargo.toml
@@ -11,6 +11,7 @@ edition = "2021"
 [dependencies]
 arrayvec = { version = "0.7", default-features = false }
 cargo_metadata = "0.15.3"
+clippy_config = { path = "../clippy_config" }
 clippy_utils = { path = "../clippy_utils" }
 declare_clippy_lint = { path = "../declare_clippy_lint" }
 if_chain = "1.0"
@@ -34,7 +35,7 @@ walkdir = "2.3"
 [features]
 deny-warnings = ["clippy_utils/deny-warnings"]
 # build clippy with internal lints enabled, off by default
-internal = ["clippy_utils/internal", "serde_json", "tempfile", "regex"]
+internal = ["clippy_config/internal", "clippy_utils/internal", "serde_json", "tempfile", "regex"]
 
 [package.metadata.rust-analyzer]
 # This crate uses #[feature(rustc_private)]
diff --git a/clippy_lints/src/almost_complete_range.rs b/clippy_lints/src/almost_complete_range.rs
index 4afb3957aa1..82c6712506d 100644
--- a/clippy_lints/src/almost_complete_range.rs
+++ b/clippy_lints/src/almost_complete_range.rs
@@ -1,5 +1,5 @@
+use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::{trim_span, walk_span_to_context};
 use rustc_ast::ast::{Expr, ExprKind, LitKind, Pat, PatKind, RangeEnd, RangeLimits};
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/approx_const.rs b/clippy_lints/src/approx_const.rs
index 591c78cb246..b4f778f12b9 100644
--- a/clippy_lints/src/approx_const.rs
+++ b/clippy_lints/src/approx_const.rs
@@ -1,5 +1,5 @@
+use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::diagnostics::span_lint_and_help;
-use clippy_utils::msrvs::{self, Msrv};
 use rustc_ast::ast::{FloatTy, LitFloatType, LitKind};
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs
index 8a918c13cfc..c720eba11b1 100644
--- a/clippy_lints/src/attrs.rs
+++ b/clippy_lints/src/attrs.rs
@@ -1,9 +1,9 @@
 //! checks for attributes
 
+use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::diagnostics::{span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::is_from_proc_macro;
 use clippy_utils::macros::{is_panic, macro_backtrace};
-use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::{first_line_of_span, is_present_in_source, snippet_opt, without_block_comments};
 use if_chain::if_chain;
 use rustc_ast::token::{Token, TokenKind};
diff --git a/clippy_lints/src/await_holding_invalid.rs b/clippy_lints/src/await_holding_invalid.rs
index 494374e967b..dbeca372b4d 100644
--- a/clippy_lints/src/await_holding_invalid.rs
+++ b/clippy_lints/src/await_holding_invalid.rs
@@ -1,3 +1,4 @@
+use clippy_config::types::DisallowedPath;
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::{match_def_path, paths};
 use rustc_data_structures::fx::FxHashMap;
@@ -8,8 +9,6 @@ use rustc_middle::mir::CoroutineLayout;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::{sym, Span};
 
-use crate::utils::conf::DisallowedPath;
-
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for calls to await while holding a non-async-aware MutexGuard.
diff --git a/clippy_lints/src/casts/cast_abs_to_unsigned.rs b/clippy_lints/src/casts/cast_abs_to_unsigned.rs
index 44226298333..c1663348321 100644
--- a/clippy_lints/src/casts/cast_abs_to_unsigned.rs
+++ b/clippy_lints/src/casts/cast_abs_to_unsigned.rs
@@ -1,5 +1,5 @@
+use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::sugg::Sugg;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
diff --git a/clippy_lints/src/casts/cast_lossless.rs b/clippy_lints/src/casts/cast_lossless.rs
index c586b572be9..fe2455f4b23 100644
--- a/clippy_lints/src/casts/cast_lossless.rs
+++ b/clippy_lints/src/casts/cast_lossless.rs
@@ -1,6 +1,6 @@
+use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::in_constant;
-use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::is_isize_or_usize;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/casts/cast_slice_different_sizes.rs b/clippy_lints/src/casts/cast_slice_different_sizes.rs
index 4d9cc4cacc3..d1410402913 100644
--- a/clippy_lints/src/casts/cast_slice_different_sizes.rs
+++ b/clippy_lints/src/casts/cast_slice_different_sizes.rs
@@ -1,5 +1,5 @@
+use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source;
 use if_chain::if_chain;
 use rustc_ast::Mutability;
diff --git a/clippy_lints/src/casts/cast_slice_from_raw_parts.rs b/clippy_lints/src/casts/cast_slice_from_raw_parts.rs
index eb0f75b2f60..badadf2c9f6 100644
--- a/clippy_lints/src/casts/cast_slice_from_raw_parts.rs
+++ b/clippy_lints/src/casts/cast_slice_from_raw_parts.rs
@@ -1,5 +1,5 @@
+use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::snippet_with_context;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index 2edbc6db5c3..49a90a2f3c2 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -22,8 +22,8 @@ mod unnecessary_cast;
 mod utils;
 mod zero_ptr;
 
+use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::is_hir_ty_cfg_dependant;
-use clippy_utils::msrvs::{self, Msrv};
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
diff --git a/clippy_lints/src/casts/ptr_as_ptr.rs b/clippy_lints/src/casts/ptr_as_ptr.rs
index 181dbcf6e9a..0c555c1acc5 100644
--- a/clippy_lints/src/casts/ptr_as_ptr.rs
+++ b/clippy_lints/src/casts/ptr_as_ptr.rs
@@ -1,5 +1,5 @@
+use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::sugg::Sugg;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/casts/ptr_cast_constness.rs b/clippy_lints/src/casts/ptr_cast_constness.rs
index ce1ab10910c..0172e933649 100644
--- a/clippy_lints/src/casts/ptr_cast_constness.rs
+++ b/clippy_lints/src/casts/ptr_cast_constness.rs
@@ -1,5 +1,5 @@
+use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::msrvs::{Msrv, POINTER_CAST_CONSTNESS};
 use clippy_utils::sugg::Sugg;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
@@ -18,7 +18,7 @@ pub(super) fn check<'tcx>(
     msrv: &Msrv,
 ) {
     if_chain! {
-        if msrv.meets(POINTER_CAST_CONSTNESS);
+        if msrv.meets(msrvs::POINTER_CAST_CONSTNESS);
         if let ty::RawPtr(TypeAndMut { mutbl: from_mutbl, ty: from_ty }) = cast_from.kind();
         if let ty::RawPtr(TypeAndMut { mutbl: to_mutbl, ty: to_ty }) = cast_to.kind();
         if matches!((from_mutbl, to_mutbl),
diff --git a/clippy_lints/src/checked_conversions.rs b/clippy_lints/src/checked_conversions.rs
index 1cfd0d1157c..d31c2268a65 100644
--- a/clippy_lints/src/checked_conversions.rs
+++ b/clippy_lints/src/checked_conversions.rs
@@ -1,7 +1,7 @@
 //! lint on manually implemented checked conversions that could be transformed into `try_from`
 
+use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::{in_constant, is_integer_literal, SpanlessEq};
 use if_chain::if_chain;
diff --git a/clippy_lints/src/derivable_impls.rs b/clippy_lints/src/derivable_impls.rs
index ca3f1acfc0c..a450becc647 100644
--- a/clippy_lints/src/derivable_impls.rs
+++ b/clippy_lints/src/derivable_impls.rs
@@ -1,5 +1,5 @@
+use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::indent_of;
 use clippy_utils::{is_default_equivalent, peel_blocks};
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/disallowed_macros.rs b/clippy_lints/src/disallowed_macros.rs
index e4f2328bc1f..324b5e0798e 100644
--- a/clippy_lints/src/disallowed_macros.rs
+++ b/clippy_lints/src/disallowed_macros.rs
@@ -1,3 +1,4 @@
+use clippy_config::types::DisallowedPath;
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::macros::macro_backtrace;
 use rustc_ast::Attribute;
@@ -8,8 +9,6 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::{ExpnId, Span};
 
-use crate::utils::conf;
-
 declare_clippy_lint! {
     /// ### What it does
     /// Denies the configured macros in clippy.toml
@@ -55,13 +54,13 @@ declare_clippy_lint! {
 }
 
 pub struct DisallowedMacros {
-    conf_disallowed: Vec<conf::DisallowedPath>,
+    conf_disallowed: Vec<DisallowedPath>,
     disallowed: DefIdMap<usize>,
     seen: FxHashSet<ExpnId>,
 }
 
 impl DisallowedMacros {
-    pub fn new(conf_disallowed: Vec<conf::DisallowedPath>) -> Self {
+    pub fn new(conf_disallowed: Vec<DisallowedPath>) -> Self {
         Self {
             conf_disallowed,
             disallowed: DefIdMap::default(),
diff --git a/clippy_lints/src/disallowed_methods.rs b/clippy_lints/src/disallowed_methods.rs
index 95d3f7547b4..d23aeebb5a8 100644
--- a/clippy_lints/src/disallowed_methods.rs
+++ b/clippy_lints/src/disallowed_methods.rs
@@ -1,13 +1,11 @@
+use clippy_config::types::DisallowedPath;
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::{fn_def_id, get_parent_expr, path_def_id};
-
 use rustc_hir::def_id::DefIdMap;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 
-use crate::utils::conf;
-
 declare_clippy_lint! {
     /// ### What it does
     /// Denies the configured methods and functions in clippy.toml
@@ -59,12 +57,12 @@ declare_clippy_lint! {
 
 #[derive(Clone, Debug)]
 pub struct DisallowedMethods {
-    conf_disallowed: Vec<conf::DisallowedPath>,
+    conf_disallowed: Vec<DisallowedPath>,
     disallowed: DefIdMap<usize>,
 }
 
 impl DisallowedMethods {
-    pub fn new(conf_disallowed: Vec<conf::DisallowedPath>) -> Self {
+    pub fn new(conf_disallowed: Vec<DisallowedPath>) -> Self {
         Self {
             conf_disallowed,
             disallowed: DefIdMap::default(),
diff --git a/clippy_lints/src/disallowed_types.rs b/clippy_lints/src/disallowed_types.rs
index 1f56d0118a4..3578fb640fc 100644
--- a/clippy_lints/src/disallowed_types.rs
+++ b/clippy_lints/src/disallowed_types.rs
@@ -1,5 +1,5 @@
+use clippy_config::types::DisallowedPath;
 use clippy_utils::diagnostics::span_lint_and_then;
-
 use rustc_data_structures::fx::FxHashMap;
 use rustc_hir::def::Res;
 use rustc_hir::def_id::DefId;
@@ -8,8 +8,6 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::Span;
 
-use crate::utils::conf;
-
 declare_clippy_lint! {
     /// ### What it does
     /// Denies the configured types in clippy.toml.
@@ -50,15 +48,16 @@ declare_clippy_lint! {
     style,
     "use of disallowed types"
 }
+
 #[derive(Clone, Debug)]
 pub struct DisallowedTypes {
-    conf_disallowed: Vec<conf::DisallowedPath>,
+    conf_disallowed: Vec<DisallowedPath>,
     def_ids: FxHashMap<DefId, usize>,
     prim_tys: FxHashMap<PrimTy, usize>,
 }
 
 impl DisallowedTypes {
-    pub fn new(conf_disallowed: Vec<conf::DisallowedPath>) -> Self {
+    pub fn new(conf_disallowed: Vec<DisallowedPath>) -> Self {
         Self {
             conf_disallowed,
             def_ids: FxHashMap::default(),
@@ -123,7 +122,7 @@ impl<'tcx> LateLintPass<'tcx> for DisallowedTypes {
     }
 }
 
-fn emit(cx: &LateContext<'_>, name: &str, span: Span, conf: &conf::DisallowedPath) {
+fn emit(cx: &LateContext<'_>, name: &str, span: Span, conf: &DisallowedPath) {
     span_lint_and_then(
         cx,
         DISALLOWED_TYPES,
diff --git a/clippy_lints/src/format_args.rs b/clippy_lints/src/format_args.rs
index e674e03f17b..7d60fdd1b03 100644
--- a/clippy_lints/src/format_args.rs
+++ b/clippy_lints/src/format_args.rs
@@ -1,11 +1,11 @@
 use arrayvec::ArrayVec;
+use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::is_diag_trait_item;
 use clippy_utils::macros::{
     find_format_arg_expr, find_format_args, format_arg_removal_span, format_placeholder_format_span, is_assert_macro,
     is_format_macro, is_panic, root_macro_call, root_macro_call_first_node, FormatParamUsage,
 };
-use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::{implements_trait, is_type_lang_item};
 use if_chain::if_chain;
diff --git a/clippy_lints/src/from_over_into.rs b/clippy_lints/src/from_over_into.rs
index a100fd6c595..948d709ce3f 100644
--- a/clippy_lints/src/from_over_into.rs
+++ b/clippy_lints/src/from_over_into.rs
@@ -1,6 +1,6 @@
+use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::macros::span_is_local;
-use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::path_def_id;
 use clippy_utils::source::snippet_opt;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/if_then_some_else_none.rs b/clippy_lints/src/if_then_some_else_none.rs
index ebd529bd356..55dab10ac88 100644
--- a/clippy_lints/src/if_then_some_else_none.rs
+++ b/clippy_lints/src/if_then_some_else_none.rs
@@ -1,6 +1,6 @@
+use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::eager_or_lazy::switch_to_eager_eval;
-use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::snippet_with_context;
 use clippy_utils::sugg::Sugg;
 use clippy_utils::{contains_return, higher, is_else_clause, is_res_lang_ctor, path_res, peel_blocks};
diff --git a/clippy_lints/src/index_refutable_slice.rs b/clippy_lints/src/index_refutable_slice.rs
index ab5e6a93300..c2f1f18e39d 100644
--- a/clippy_lints/src/index_refutable_slice.rs
+++ b/clippy_lints/src/index_refutable_slice.rs
@@ -1,7 +1,7 @@
+use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::consts::{constant, Constant};
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::higher::IfLet;
-use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::ty::is_copy;
 use clippy_utils::{is_expn_of, is_lint_allowed, path_to_local};
 use if_chain::if_chain;
diff --git a/clippy_lints/src/instant_subtraction.rs b/clippy_lints/src/instant_subtraction.rs
index cb01f7aac14..32b2cb4385f 100644
--- a/clippy_lints/src/instant_subtraction.rs
+++ b/clippy_lints/src/instant_subtraction.rs
@@ -1,5 +1,5 @@
+use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::diagnostics::{self, span_lint_and_sugg};
-use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::snippet_with_context;
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty;
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index a70a38ee08b..a64efbca74f 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -50,7 +50,6 @@ extern crate clippy_utils;
 #[macro_use]
 extern crate declare_clippy_lint;
 
-use clippy_utils::msrvs::Msrv;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_lint::{Lint, LintId};
 use rustc_session::Session;
@@ -358,9 +357,8 @@ mod zero_div_zero;
 mod zero_sized_map_values;
 // end lints modules, do not remove this comment, it’s used in `update_lints`
 
-use crate::utils::conf::metadata::get_configuration_metadata;
-pub use crate::utils::conf::{lookup_conf_file, Conf};
 use crate::utils::FindAll;
+use clippy_config::{get_configuration_metadata, Conf};
 
 /// Register all pre expansion lints
 ///
diff --git a/clippy_lints/src/loops/explicit_iter_loop.rs b/clippy_lints/src/loops/explicit_iter_loop.rs
index 6ab256ef001..92ee033df47 100644
--- a/clippy_lints/src/loops/explicit_iter_loop.rs
+++ b/clippy_lints/src/loops/explicit_iter_loop.rs
@@ -1,6 +1,6 @@
 use super::EXPLICIT_ITER_LOOP;
+use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::{
     implements_trait, implements_trait_with_env, is_copy, make_normalized_projection,
diff --git a/clippy_lints/src/loops/mod.rs b/clippy_lints/src/loops/mod.rs
index 747fc7eb40e..575a84c8c63 100644
--- a/clippy_lints/src/loops/mod.rs
+++ b/clippy_lints/src/loops/mod.rs
@@ -19,8 +19,8 @@ mod while_immutable_condition;
 mod while_let_loop;
 mod while_let_on_iterator;
 
+use clippy_config::msrvs::Msrv;
 use clippy_utils::higher;
-use clippy_utils::msrvs::Msrv;
 use rustc_hir::{Expr, ExprKind, LoopSource, Pat};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
diff --git a/clippy_lints/src/manual_bits.rs b/clippy_lints/src/manual_bits.rs
index 2db4443e059..cd614c8951c 100644
--- a/clippy_lints/src/manual_bits.rs
+++ b/clippy_lints/src/manual_bits.rs
@@ -1,6 +1,6 @@
+use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::get_parent_expr;
-use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::snippet_with_context;
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/manual_clamp.rs b/clippy_lints/src/manual_clamp.rs
index 4afeb5eebc3..ec87ff3ef6a 100644
--- a/clippy_lints/src/manual_clamp.rs
+++ b/clippy_lints/src/manual_clamp.rs
@@ -1,6 +1,6 @@
+use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::diagnostics::{span_lint_and_then, span_lint_hir_and_then};
 use clippy_utils::higher::If;
-use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::implements_trait;
 use clippy_utils::visitors::is_const_evaluatable;
diff --git a/clippy_lints/src/manual_hash_one.rs b/clippy_lints/src/manual_hash_one.rs
index cbad700c99a..19f2e1dc42c 100644
--- a/clippy_lints/src/manual_hash_one.rs
+++ b/clippy_lints/src/manual_hash_one.rs
@@ -1,5 +1,5 @@
+use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::diagnostics::span_lint_hir_and_then;
-use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::snippet_opt;
 use clippy_utils::visitors::{is_local_used, local_used_once};
 use clippy_utils::{is_trait_method, path_to_local_id};
diff --git a/clippy_lints/src/manual_is_ascii_check.rs b/clippy_lints/src/manual_is_ascii_check.rs
index 2474c672e18..17415b58d9e 100644
--- a/clippy_lints/src/manual_is_ascii_check.rs
+++ b/clippy_lints/src/manual_is_ascii_check.rs
@@ -1,6 +1,6 @@
+use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::macros::root_macro_call;
-use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::sugg::Sugg;
 use clippy_utils::{higher, in_constant};
 use rustc_ast::ast::RangeLimits;
diff --git a/clippy_lints/src/manual_let_else.rs b/clippy_lints/src/manual_let_else.rs
index fb8ddd8c2be..7888fc10a0b 100644
--- a/clippy_lints/src/manual_let_else.rs
+++ b/clippy_lints/src/manual_let_else.rs
@@ -1,10 +1,12 @@
 use crate::question_mark::{QuestionMark, QUESTION_MARK};
+use clippy_config::msrvs;
+use clippy_config::types::MatchLintBehaviour;
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::higher::IfLetOrMatch;
 use clippy_utils::source::snippet_with_context;
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::visitors::{Descend, Visitable};
-use clippy_utils::{is_lint_allowed, msrvs, pat_and_expr_can_be_question_mark, peel_blocks};
+use clippy_utils::{is_lint_allowed, pat_and_expr_can_be_question_mark, peel_blocks};
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_expr, Visitor};
@@ -14,7 +16,6 @@ use rustc_middle::lint::in_external_macro;
 use rustc_session::declare_tool_lint;
 use rustc_span::symbol::{sym, Symbol};
 use rustc_span::Span;
-use serde::Deserialize;
 use std::ops::ControlFlow;
 use std::slice;
 
@@ -477,10 +478,3 @@ fn expr_simple_identity_map<'a, 'hir>(
     }
     Some(ident_map)
 }
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Deserialize)]
-pub enum MatchLintBehaviour {
-    AllTypes,
-    WellKnownTypes,
-    Never,
-}
diff --git a/clippy_lints/src/manual_main_separator_str.rs b/clippy_lints/src/manual_main_separator_str.rs
index 8bd62b080c4..8f5e7982242 100644
--- a/clippy_lints/src/manual_main_separator_str.rs
+++ b/clippy_lints/src/manual_main_separator_str.rs
@@ -1,5 +1,5 @@
+use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::{is_trait_method, match_def_path, paths, peel_hir_expr_refs};
 use rustc_errors::Applicability;
 use rustc_hir::def::{DefKind, Res};
diff --git a/clippy_lints/src/manual_non_exhaustive.rs b/clippy_lints/src/manual_non_exhaustive.rs
index 85ca8486315..4c44ac7fa11 100644
--- a/clippy_lints/src/manual_non_exhaustive.rs
+++ b/clippy_lints/src/manual_non_exhaustive.rs
@@ -1,6 +1,6 @@
+use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::diagnostics::{span_lint_and_then, span_lint_hir_and_then};
 use clippy_utils::is_doc_hidden;
-use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::snippet_opt;
 use rustc_ast::ast::{self, VisibilityKind};
 use rustc_ast::attr;
diff --git a/clippy_lints/src/manual_rem_euclid.rs b/clippy_lints/src/manual_rem_euclid.rs
index 80b83aac413..b435fcf61df 100644
--- a/clippy_lints/src/manual_rem_euclid.rs
+++ b/clippy_lints/src/manual_rem_euclid.rs
@@ -1,6 +1,6 @@
+use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::consts::{constant_full_int, FullInt};
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::snippet_with_context;
 use clippy_utils::{in_constant, path_to_local};
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/manual_retain.rs b/clippy_lints/src/manual_retain.rs
index bfce92c0251..f902b48fa81 100644
--- a/clippy_lints/src/manual_retain.rs
+++ b/clippy_lints/src/manual_retain.rs
@@ -1,5 +1,5 @@
+use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::snippet;
 use clippy_utils::ty::{is_type_diagnostic_item, is_type_lang_item};
 use clippy_utils::{get_parent_expr, match_def_path, paths, SpanlessEq};
diff --git a/clippy_lints/src/manual_strip.rs b/clippy_lints/src/manual_strip.rs
index e653064dbde..9a9e6af5084 100644
--- a/clippy_lints/src/manual_strip.rs
+++ b/clippy_lints/src/manual_strip.rs
@@ -1,6 +1,6 @@
+use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::consts::{constant, Constant};
 use clippy_utils::diagnostics::{multispan_sugg, span_lint_and_then};
-use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::snippet;
 use clippy_utils::usage::mutated_variables;
 use clippy_utils::{eq_expr_value, higher, match_def_path, paths};
diff --git a/clippy_lints/src/matches/mod.rs b/clippy_lints/src/matches/mod.rs
index 8f1ad962276..dea46d4d360 100644
--- a/clippy_lints/src/matches/mod.rs
+++ b/clippy_lints/src/matches/mod.rs
@@ -24,7 +24,7 @@ mod single_match;
 mod try_err;
 mod wild_in_or_pats;
 
-use clippy_utils::msrvs::{self, Msrv};
+use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::source::{snippet_opt, walk_span_to_context};
 use clippy_utils::{higher, in_constant, is_direct_expn_of, is_span_match, tokenize_with_text};
 use rustc_hir::{Arm, Expr, ExprKind, Local, MatchSource, Pat};
diff --git a/clippy_lints/src/mem_replace.rs b/clippy_lints/src/mem_replace.rs
index 645c26f39c4..c6a1b45a9fa 100644
--- a/clippy_lints/src/mem_replace.rs
+++ b/clippy_lints/src/mem_replace.rs
@@ -1,5 +1,5 @@
+use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg, span_lint_and_then};
-use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::{snippet, snippet_with_applicability};
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::is_non_aggregate_primitive_type;
diff --git a/clippy_lints/src/methods/cloned_instead_of_copied.rs b/clippy_lints/src/methods/cloned_instead_of_copied.rs
index 4e6ec61f6a8..fcafa162236 100644
--- a/clippy_lints/src/methods/cloned_instead_of_copied.rs
+++ b/clippy_lints/src/methods/cloned_instead_of_copied.rs
@@ -1,6 +1,6 @@
+use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::is_trait_method;
-use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::ty::{get_iterator_item_ty, is_copy};
 use rustc_errors::Applicability;
 use rustc_hir::Expr;
diff --git a/clippy_lints/src/methods/err_expect.rs b/clippy_lints/src/methods/err_expect.rs
index 3d82441c0e6..a8d4dd5e4f3 100644
--- a/clippy_lints/src/methods/err_expect.rs
+++ b/clippy_lints/src/methods/err_expect.rs
@@ -1,6 +1,6 @@
 use super::ERR_EXPECT;
+use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::ty::{has_debug_impl, is_type_diagnostic_item};
 use rustc_errors::Applicability;
 use rustc_lint::LateContext;
diff --git a/clippy_lints/src/methods/filter_map_next.rs b/clippy_lints/src/methods/filter_map_next.rs
index 3f89e593148..f94fe221833 100644
--- a/clippy_lints/src/methods/filter_map_next.rs
+++ b/clippy_lints/src/methods/filter_map_next.rs
@@ -1,6 +1,6 @@
+use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg};
 use clippy_utils::is_trait_method;
-use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::snippet;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
diff --git a/clippy_lints/src/methods/is_digit_ascii_radix.rs b/clippy_lints/src/methods/is_digit_ascii_radix.rs
index 120f3d5f42c..e963950960a 100644
--- a/clippy_lints/src/methods/is_digit_ascii_radix.rs
+++ b/clippy_lints/src/methods/is_digit_ascii_radix.rs
@@ -1,9 +1,9 @@
 //! Lint for `c.is_digit(10)`
 
 use super::IS_DIGIT_ASCII_RADIX;
+use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::consts::{constant_full_int, FullInt};
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::snippet_with_applicability;
 use rustc_errors::Applicability;
 use rustc_hir::Expr;
diff --git a/clippy_lints/src/methods/manual_try_fold.rs b/clippy_lints/src/methods/manual_try_fold.rs
index dabed0affcf..5fc968f793f 100644
--- a/clippy_lints/src/methods/manual_try_fold.rs
+++ b/clippy_lints/src/methods/manual_try_fold.rs
@@ -1,6 +1,6 @@
+use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::is_from_proc_macro;
-use clippy_utils::msrvs::{Msrv, ITERATOR_TRY_FOLD};
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::implements_trait;
 use rustc_errors::Applicability;
@@ -21,7 +21,7 @@ pub(super) fn check<'tcx>(
     msrv: &Msrv,
 ) {
     if !in_external_macro(cx.sess(), fold_span)
-        && msrv.meets(ITERATOR_TRY_FOLD)
+        && msrv.meets(msrvs::ITERATOR_TRY_FOLD)
         && let init_ty = cx.typeck_results().expr_ty(init)
         && let Some(try_trait) = cx.tcx.lang_items().try_trait()
         && implements_trait(cx, init_ty, try_trait, &[])
diff --git a/clippy_lints/src/methods/map_clone.rs b/clippy_lints/src/methods/map_clone.rs
index 880efe60c1a..e0f8cb1b955 100644
--- a/clippy_lints/src/methods/map_clone.rs
+++ b/clippy_lints/src/methods/map_clone.rs
@@ -1,5 +1,5 @@
+use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::{is_copy, is_type_diagnostic_item};
 use clippy_utils::{is_diag_trait_item, peel_blocks};
diff --git a/clippy_lints/src/methods/map_unwrap_or.rs b/clippy_lints/src/methods/map_unwrap_or.rs
index e70a1bc9879..cb81b3919bf 100644
--- a/clippy_lints/src/methods/map_unwrap_or.rs
+++ b/clippy_lints/src/methods/map_unwrap_or.rs
@@ -1,5 +1,5 @@
+use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg};
-use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::snippet;
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::usage::mutated_variables;
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 6d937b8619d..373d8606b1d 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -116,9 +116,9 @@ mod wrong_self_convention;
 mod zst_offset;
 
 use bind_instead_of_map::BindInsteadOfMap;
+use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::consts::{constant, Constant};
 use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
-use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::ty::{contains_ty_adt_constructor_opaque, implements_trait, is_copy, is_type_diagnostic_item};
 use clippy_utils::{contains_return, is_bool, is_trait_method, iter_input_pats, peel_blocks, return_ty};
 use if_chain::if_chain;
diff --git a/clippy_lints/src/methods/option_as_ref_deref.rs b/clippy_lints/src/methods/option_as_ref_deref.rs
index d0c27f9631f..7b81d4571b2 100644
--- a/clippy_lints/src/methods/option_as_ref_deref.rs
+++ b/clippy_lints/src/methods/option_as_ref_deref.rs
@@ -1,5 +1,5 @@
+use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::snippet;
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::{match_def_path, path_to_local_id, paths, peel_blocks};
diff --git a/clippy_lints/src/methods/option_map_unwrap_or.rs b/clippy_lints/src/methods/option_map_unwrap_or.rs
index fcbe005fb28..ebb0a7b562d 100644
--- a/clippy_lints/src/methods/option_map_unwrap_or.rs
+++ b/clippy_lints/src/methods/option_map_unwrap_or.rs
@@ -1,5 +1,5 @@
+use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::{is_copy, is_type_diagnostic_item};
 use rustc_data_structures::fx::FxHashSet;
diff --git a/clippy_lints/src/methods/path_ends_with_ext.rs b/clippy_lints/src/methods/path_ends_with_ext.rs
index 3347c8c1620..9ec0ef0ea39 100644
--- a/clippy_lints/src/methods/path_ends_with_ext.rs
+++ b/clippy_lints/src/methods/path_ends_with_ext.rs
@@ -1,7 +1,6 @@
 use super::PATH_ENDS_WITH_EXT;
+use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::msrvs;
-use clippy_utils::msrvs::Msrv;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_ast::{LitKind, StrStyle};
diff --git a/clippy_lints/src/methods/str_splitn.rs b/clippy_lints/src/methods/str_splitn.rs
index 5d4b0e53762..6e00e0fd1fb 100644
--- a/clippy_lints/src/methods/str_splitn.rs
+++ b/clippy_lints/src/methods/str_splitn.rs
@@ -1,6 +1,6 @@
+use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::consts::{constant, Constant};
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
-use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::snippet_with_context;
 use clippy_utils::usage::local_used_after_expr;
 use clippy_utils::visitors::{for_each_expr_with_closures, Descend};
diff --git a/clippy_lints/src/methods/string_lit_chars_any.rs b/clippy_lints/src/methods/string_lit_chars_any.rs
index 70da6ad58bd..fb8075e2362 100644
--- a/clippy_lints/src/methods/string_lit_chars_any.rs
+++ b/clippy_lints/src/methods/string_lit_chars_any.rs
@@ -1,5 +1,5 @@
+use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::msrvs::{Msrv, MATCHES_MACRO};
 use clippy_utils::source::snippet_opt;
 use clippy_utils::{is_from_proc_macro, is_trait_method, path_to_local};
 use itertools::Itertools;
@@ -19,7 +19,7 @@ pub(super) fn check<'tcx>(
     body: &Expr<'_>,
     msrv: &Msrv,
 ) {
-    if msrv.meets(MATCHES_MACRO)
+    if msrv.meets(msrvs::MATCHES_MACRO)
         && is_trait_method(cx, expr, sym::Iterator)
         && let PatKind::Binding(_, arg, _, _) = param.pat.kind
         && let ExprKind::Lit(lit_kind) = recv.kind
diff --git a/clippy_lints/src/methods/unnecessary_to_owned.rs b/clippy_lints/src/methods/unnecessary_to_owned.rs
index 50d6f3b7e55..78d4bae60e5 100644
--- a/clippy_lints/src/methods/unnecessary_to_owned.rs
+++ b/clippy_lints/src/methods/unnecessary_to_owned.rs
@@ -1,7 +1,7 @@
 use super::implicit_clone::is_clone_like;
 use super::unnecessary_iter_cloned::{self, is_into_iter};
+use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::{get_iterator_item_ty, implements_trait, is_copy, peel_mid_ty_refs};
 use clippy_utils::visitors::find_all_ret_expressions;
diff --git a/clippy_lints/src/missing_const_for_fn.rs b/clippy_lints/src/missing_const_for_fn.rs
index b39f1de0b41..97522cbe6ce 100644
--- a/clippy_lints/src/missing_const_for_fn.rs
+++ b/clippy_lints/src/missing_const_for_fn.rs
@@ -1,5 +1,5 @@
+use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::diagnostics::span_lint;
-use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::qualify_min_const_fn::is_min_const_fn;
 use clippy_utils::ty::has_drop;
 use clippy_utils::{fn_has_unsatisfiable_preds, is_entrypoint_fn, is_from_proc_macro, trait_ref_of_method};
diff --git a/clippy_lints/src/missing_enforced_import_rename.rs b/clippy_lints/src/missing_enforced_import_rename.rs
index fc088710e42..16ff98a5922 100644
--- a/clippy_lints/src/missing_enforced_import_rename.rs
+++ b/clippy_lints/src/missing_enforced_import_rename.rs
@@ -1,6 +1,6 @@
+use clippy_config::types::Rename;
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_opt;
-
 use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::Applicability;
 use rustc_hir::def::Res;
@@ -10,8 +10,6 @@ use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::Symbol;
 
-use crate::utils::conf::Rename;
-
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for imports that do not rename the item as specified
diff --git a/clippy_lints/src/needless_borrows_for_generic_args.rs b/clippy_lints/src/needless_borrows_for_generic_args.rs
index 542b81f3a12..53f449f2d43 100644
--- a/clippy_lints/src/needless_borrows_for_generic_args.rs
+++ b/clippy_lints/src/needless_borrows_for_generic_args.rs
@@ -1,6 +1,6 @@
+use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::mir::{enclosing_mir, expr_local, local_assignments, used_exactly_once, PossibleBorrowerMap};
-use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::snippet_with_context;
 use clippy_utils::ty::is_copy;
 use clippy_utils::{expr_use_ctxt, peel_n_hir_expr_refs, DefinedTy, ExprUseNode};
diff --git a/clippy_lints/src/nonstandard_macro_braces.rs b/clippy_lints/src/nonstandard_macro_braces.rs
index 35d06897eb4..11c3a5417b5 100644
--- a/clippy_lints/src/nonstandard_macro_braces.rs
+++ b/clippy_lints/src/nonstandard_macro_braces.rs
@@ -1,6 +1,4 @@
-use std::fmt;
-use std::hash::{Hash, Hasher};
-
+use clippy_config::types::MacroMatcher;
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_opt;
 use if_chain::if_chain;
@@ -12,7 +10,6 @@ use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::hygiene::{ExpnKind, MacroKind};
 use rustc_span::Span;
-use serde::{de, Deserialize};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -36,8 +33,6 @@ declare_clippy_lint! {
     "check consistent use of braces in macro"
 }
 
-const BRACES: &[(&str, &str)] = &[("(", ")"), ("{", "}"), ("[", "]")];
-
 /// The (callsite span, (open brace, close brace), source snippet)
 type MacroInfo<'a> = (Span, &'a (String, String), String);
 
@@ -195,81 +190,3 @@ macro_rules! macro_matcher {
     };
 }
 pub(crate) use macro_matcher;
-
-#[derive(Clone, Debug)]
-pub struct MacroMatcher {
-    name: String,
-    braces: (String, String),
-}
-
-impl Hash for MacroMatcher {
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        self.name.hash(state);
-    }
-}
-
-impl PartialEq for MacroMatcher {
-    fn eq(&self, other: &Self) -> bool {
-        self.name == other.name
-    }
-}
-impl Eq for MacroMatcher {}
-
-impl<'de> Deserialize<'de> for MacroMatcher {
-    fn deserialize<D>(deser: D) -> Result<Self, D::Error>
-    where
-        D: de::Deserializer<'de>,
-    {
-        #[derive(Deserialize)]
-        #[serde(field_identifier, rename_all = "lowercase")]
-        enum Field {
-            Name,
-            Brace,
-        }
-        struct MacVisitor;
-        impl<'de> de::Visitor<'de> for MacVisitor {
-            type Value = MacroMatcher;
-
-            fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
-                formatter.write_str("struct MacroMatcher")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> Result<Self::Value, V::Error>
-            where
-                V: de::MapAccess<'de>,
-            {
-                let mut name = None;
-                let mut brace: Option<String> = None;
-                while let Some(key) = map.next_key()? {
-                    match key {
-                        Field::Name => {
-                            if name.is_some() {
-                                return Err(de::Error::duplicate_field("name"));
-                            }
-                            name = Some(map.next_value()?);
-                        },
-                        Field::Brace => {
-                            if brace.is_some() {
-                                return Err(de::Error::duplicate_field("brace"));
-                            }
-                            brace = Some(map.next_value()?);
-                        },
-                    }
-                }
-                let name = name.ok_or_else(|| de::Error::missing_field("name"))?;
-                let brace = brace.ok_or_else(|| de::Error::missing_field("brace"))?;
-                Ok(MacroMatcher {
-                    name,
-                    braces: BRACES
-                        .iter()
-                        .find(|b| b.0 == brace)
-                        .map(|(o, c)| ((*o).to_owned(), (*c).to_owned()))
-                        .ok_or_else(|| de::Error::custom(format!("expected one of `(`, `{{`, `[` found `{brace}`")))?,
-                })
-            }
-        }
-
-        const FIELDS: &[&str] = &["name", "brace"];
-        deser.deserialize_struct("MacroMatcher", FIELDS, MacVisitor)
-    }
-}
diff --git a/clippy_lints/src/question_mark.rs b/clippy_lints/src/question_mark.rs
index 734ca2914f5..4305792873c 100644
--- a/clippy_lints/src/question_mark.rs
+++ b/clippy_lints/src/question_mark.rs
@@ -1,7 +1,8 @@
-use crate::manual_let_else::{MatchLintBehaviour, MANUAL_LET_ELSE};
+use crate::manual_let_else::MANUAL_LET_ELSE;
 use crate::question_mark_used::QUESTION_MARK_USED;
+use clippy_config::msrvs::Msrv;
+use clippy_config::types::MatchLintBehaviour;
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::msrvs::Msrv;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::{
diff --git a/clippy_lints/src/ranges.rs b/clippy_lints/src/ranges.rs
index 4a5c6b33298..ffd49de3820 100644
--- a/clippy_lints/src/ranges.rs
+++ b/clippy_lints/src/ranges.rs
@@ -1,6 +1,6 @@
+use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::consts::{constant, Constant};
 use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg, span_lint_and_then};
-use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::{snippet, snippet_opt, snippet_with_applicability};
 use clippy_utils::sugg::Sugg;
 use clippy_utils::{get_parent_expr, higher, in_constant, is_integer_const, path_to_local};
diff --git a/clippy_lints/src/redundant_field_names.rs b/clippy_lints/src/redundant_field_names.rs
index 6bf512a0e2d..b8e606df737 100644
--- a/clippy_lints/src/redundant_field_names.rs
+++ b/clippy_lints/src/redundant_field_names.rs
@@ -1,5 +1,5 @@
+use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::msrvs::{self, Msrv};
 use rustc_ast::ast::{Expr, ExprKind};
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
diff --git a/clippy_lints/src/redundant_static_lifetimes.rs b/clippy_lints/src/redundant_static_lifetimes.rs
index ed42a422b4b..a70b831a80c 100644
--- a/clippy_lints/src/redundant_static_lifetimes.rs
+++ b/clippy_lints/src/redundant_static_lifetimes.rs
@@ -1,5 +1,5 @@
+use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::snippet;
 use rustc_ast::ast::{ConstItem, Item, ItemKind, StaticItem, Ty, TyKind};
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/trait_bounds.rs b/clippy_lints/src/trait_bounds.rs
index 42b7b8645d4..f065d215e48 100644
--- a/clippy_lints/src/trait_bounds.rs
+++ b/clippy_lints/src/trait_bounds.rs
@@ -1,5 +1,5 @@
+use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg};
-use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::{snippet, snippet_opt, snippet_with_applicability};
 use clippy_utils::{is_from_proc_macro, SpanlessEq, SpanlessHash};
 use core::hash::{Hash, Hasher};
diff --git a/clippy_lints/src/transmute/mod.rs b/clippy_lints/src/transmute/mod.rs
index a6231ceb658..6eec40cb529 100644
--- a/clippy_lints/src/transmute/mod.rs
+++ b/clippy_lints/src/transmute/mod.rs
@@ -17,8 +17,8 @@ mod useless_transmute;
 mod utils;
 mod wrong_transmute;
 
+use clippy_config::msrvs::Msrv;
 use clippy_utils::in_constant;
-use clippy_utils::msrvs::Msrv;
 use if_chain::if_chain;
 use rustc_hir::{Expr, ExprKind, QPath};
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/transmute/transmute_ptr_to_ref.rs b/clippy_lints/src/transmute/transmute_ptr_to_ref.rs
index 6bdb9aa5a26..4ab3afbe714 100644
--- a/clippy_lints/src/transmute/transmute_ptr_to_ref.rs
+++ b/clippy_lints/src/transmute/transmute_ptr_to_ref.rs
@@ -1,6 +1,6 @@
 use super::TRANSMUTE_PTR_TO_REF;
+use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::sugg;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/tuple_array_conversions.rs b/clippy_lints/src/tuple_array_conversions.rs
index c12519d723c..642e39e8270 100644
--- a/clippy_lints/src/tuple_array_conversions.rs
+++ b/clippy_lints/src/tuple_array_conversions.rs
@@ -1,5 +1,5 @@
+use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::diagnostics::span_lint_and_help;
-use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::visitors::for_each_local_use_after_expr;
 use clippy_utils::{is_from_proc_macro, path_to_local};
 use itertools::Itertools;
diff --git a/clippy_lints/src/unnested_or_patterns.rs b/clippy_lints/src/unnested_or_patterns.rs
index e8ec22831c3..8ff088a208f 100644
--- a/clippy_lints/src/unnested_or_patterns.rs
+++ b/clippy_lints/src/unnested_or_patterns.rs
@@ -1,8 +1,8 @@
 #![allow(clippy::wildcard_imports, clippy::enum_glob_use)]
 
+use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::ast_utils::{eq_field_pat, eq_id, eq_maybe_qself, eq_pat, eq_path};
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::over;
 use rustc_ast::mut_visit::*;
 use rustc_ast::ptr::P;
diff --git a/clippy_lints/src/use_self.rs b/clippy_lints/src/use_self.rs
index 0f57c5def21..c3fe16ad5c3 100644
--- a/clippy_lints/src/use_self.rs
+++ b/clippy_lints/src/use_self.rs
@@ -1,6 +1,6 @@
+use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::is_from_proc_macro;
-use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::ty::same_type_and_consts;
 use if_chain::if_chain;
 use rustc_data_structures::fx::FxHashSet;
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs
deleted file mode 100644
index e5409328b4d..00000000000
--- a/clippy_lints/src/utils/conf.rs
+++ /dev/null
@@ -1,812 +0,0 @@
-//! Read configurations files.
-
-#![allow(clippy::module_name_repetitions)]
-
-use rustc_session::Session;
-use rustc_span::{BytePos, Pos, SourceFile, Span, SyntaxContext};
-use serde::de::{Deserializer, IgnoredAny, IntoDeserializer, MapAccess, Visitor};
-use serde::Deserialize;
-use std::fmt::{Debug, Display, Formatter};
-use std::ops::Range;
-use std::path::PathBuf;
-use std::str::FromStr;
-use std::sync::OnceLock;
-use std::{cmp, env, fmt, fs, io};
-
-#[rustfmt::skip]
-const DEFAULT_DOC_VALID_IDENTS: &[&str] = &[
-    "KiB", "MiB", "GiB", "TiB", "PiB", "EiB",
-    "DirectX",
-    "ECMAScript",
-    "GPLv2", "GPLv3",
-    "GitHub", "GitLab",
-    "IPv4", "IPv6",
-    "ClojureScript", "CoffeeScript", "JavaScript", "PureScript", "TypeScript",
-    "WebAssembly",
-    "NaN", "NaNs",
-    "OAuth", "GraphQL",
-    "OCaml",
-    "OpenGL", "OpenMP", "OpenSSH", "OpenSSL", "OpenStreetMap", "OpenDNS",
-    "WebGL",
-    "TensorFlow",
-    "TrueType",
-    "iOS", "macOS", "FreeBSD",
-    "TeX", "LaTeX", "BibTeX", "BibLaTeX",
-    "MinGW",
-    "CamelCase",
-];
-const DEFAULT_DISALLOWED_NAMES: &[&str] = &["foo", "baz", "quux"];
-const DEFAULT_ALLOWED_IDENTS_BELOW_MIN_CHARS: &[&str] = &["i", "j", "x", "y", "z", "w", "n"];
-
-/// Holds information used by `MISSING_ENFORCED_IMPORT_RENAMES` lint.
-#[derive(Clone, Debug, Deserialize)]
-pub struct Rename {
-    pub path: String,
-    pub rename: String,
-}
-
-#[derive(Clone, Debug, Deserialize)]
-#[serde(untagged)]
-pub enum DisallowedPath {
-    Simple(String),
-    WithReason { path: String, reason: Option<String> },
-}
-
-impl DisallowedPath {
-    pub fn path(&self) -> &str {
-        let (Self::Simple(path) | Self::WithReason { path, .. }) = self;
-
-        path
-    }
-
-    pub fn reason(&self) -> Option<String> {
-        match self {
-            Self::WithReason {
-                reason: Some(reason), ..
-            } => Some(format!("{reason} (from clippy.toml)")),
-            _ => None,
-        }
-    }
-}
-
-/// Conf with parse errors
-#[derive(Default)]
-pub struct TryConf {
-    pub conf: Conf,
-    pub errors: Vec<ConfError>,
-    pub warnings: Vec<ConfError>,
-}
-
-impl TryConf {
-    fn from_toml_error(file: &SourceFile, error: &toml::de::Error) -> Self {
-        Self {
-            conf: Conf::default(),
-            errors: vec![ConfError::from_toml(file, error)],
-            warnings: vec![],
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct ConfError {
-    pub message: String,
-    pub span: Span,
-}
-
-impl ConfError {
-    fn from_toml(file: &SourceFile, error: &toml::de::Error) -> Self {
-        let span = error.span().unwrap_or(0..file.source_len.0 as usize);
-        Self::spanned(file, error.message(), span)
-    }
-
-    fn spanned(file: &SourceFile, message: impl Into<String>, span: Range<usize>) -> Self {
-        Self {
-            message: message.into(),
-            span: Span::new(
-                file.start_pos + BytePos::from_usize(span.start),
-                file.start_pos + BytePos::from_usize(span.end),
-                SyntaxContext::root(),
-                None,
-            ),
-        }
-    }
-}
-
-macro_rules! define_Conf {
-    ($(
-        $(#[doc = $doc:literal])+
-        $(#[conf_deprecated($dep:literal, $new_conf:ident)])?
-        ($name:ident: $ty:ty = $default:expr),
-    )*) => {
-        /// Clippy lint configuration
-        pub struct Conf {
-            $($(#[doc = $doc])+ pub $name: $ty,)*
-        }
-
-        mod defaults {
-            $(pub fn $name() -> $ty { $default })*
-        }
-
-        impl Default for Conf {
-            fn default() -> Self {
-                Self { $($name: defaults::$name(),)* }
-            }
-        }
-
-        #[derive(Deserialize)]
-        #[serde(field_identifier, rename_all = "kebab-case")]
-        #[allow(non_camel_case_types)]
-        enum Field { $($name,)* third_party, }
-
-        struct ConfVisitor<'a>(&'a SourceFile);
-
-        impl<'de> Visitor<'de> for ConfVisitor<'_> {
-            type Value = TryConf;
-
-            fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
-                formatter.write_str("Conf")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> Result<Self::Value, V::Error> where V: MapAccess<'de> {
-                let mut errors = Vec::new();
-                let mut warnings = Vec::new();
-                $(let mut $name = None;)*
-                // could get `Field` here directly, but get `String` first for diagnostics
-                while let Some(name) = map.next_key::<toml::Spanned<String>>()? {
-                    match Field::deserialize(name.get_ref().as_str().into_deserializer()) {
-                        Err(e) => {
-                            let e: FieldError = e;
-                            errors.push(ConfError::spanned(self.0, e.0, name.span()));
-                        }
-                        $(Ok(Field::$name) => {
-                            $(warnings.push(ConfError::spanned(self.0, format!("deprecated field `{}`. {}", name.get_ref(), $dep), name.span()));)?
-                            let raw_value = map.next_value::<toml::Spanned<toml::Value>>()?;
-                            let value_span = raw_value.span();
-                            match <$ty>::deserialize(raw_value.into_inner()) {
-                                Err(e) => errors.push(ConfError::spanned(self.0, e.to_string().replace('\n', " ").trim(), value_span)),
-                                Ok(value) => match $name {
-                                    Some(_) => errors.push(ConfError::spanned(self.0, format!("duplicate field `{}`", name.get_ref()), name.span())),
-                                    None => {
-                                        $name = Some(value);
-                                        // $new_conf is the same as one of the defined `$name`s, so
-                                        // this variable is defined in line 2 of this function.
-                                        $(match $new_conf {
-                                            Some(_) => errors.push(ConfError::spanned(self.0, concat!(
-                                                "duplicate field `", stringify!($new_conf),
-                                                "` (provided as `", stringify!($name), "`)"
-                                            ), name.span())),
-                                            None => $new_conf = $name.clone(),
-                                        })?
-                                    },
-                                }
-                            }
-                        })*
-                        // ignore contents of the third_party key
-                        Ok(Field::third_party) => drop(map.next_value::<IgnoredAny>())
-                    }
-                }
-                let conf = Conf { $($name: $name.unwrap_or_else(defaults::$name),)* };
-                Ok(TryConf { conf, errors, warnings })
-            }
-        }
-
-        pub mod metadata {
-            use crate::utils::ClippyConfiguration;
-
-            macro_rules! wrap_option {
-                () => (None);
-                ($x:literal) => (Some($x));
-            }
-
-            pub fn get_configuration_metadata() -> Vec<ClippyConfiguration> {
-                vec![
-                    $(
-                        {
-                            let deprecation_reason = wrap_option!($($dep)?);
-
-                            ClippyConfiguration::new(
-                                stringify!($name),
-                                stringify!($ty),
-                                format!("{:?}", super::defaults::$name()),
-                                concat!($($doc, '\n',)*),
-                                deprecation_reason,
-                            )
-                        },
-                    )+
-                ]
-            }
-        }
-    };
-}
-
-define_Conf! {
-    /// Lint: ARITHMETIC_SIDE_EFFECTS.
-    ///
-    /// Suppress checking of the passed type names in all types of operations.
-    ///
-    /// If a specific operation is desired, consider using `arithmetic_side_effects_allowed_binary` or `arithmetic_side_effects_allowed_unary` instead.
-    ///
-    /// #### Example
-    ///
-    /// ```toml
-    /// arithmetic-side-effects-allowed = ["SomeType", "AnotherType"]
-    /// ```
-    ///
-    /// #### Noteworthy
-    ///
-    /// A type, say `SomeType`, listed in this configuration has the same behavior of
-    /// `["SomeType" , "*"], ["*", "SomeType"]` in `arithmetic_side_effects_allowed_binary`.
-    (arithmetic_side_effects_allowed: rustc_data_structures::fx::FxHashSet<String> = <_>::default()),
-    /// Lint: ARITHMETIC_SIDE_EFFECTS.
-    ///
-    /// Suppress checking of the passed type pair names in binary operations like addition or
-    /// multiplication.
-    ///
-    /// Supports the "*" wildcard to indicate that a certain type won't trigger the lint regardless
-    /// of the involved counterpart. For example, `["SomeType", "*"]` or `["*", "AnotherType"]`.
-    ///
-    /// Pairs are asymmetric, which means that `["SomeType", "AnotherType"]` is not the same as
-    /// `["AnotherType", "SomeType"]`.
-    ///
-    /// #### Example
-    ///
-    /// ```toml
-    /// arithmetic-side-effects-allowed-binary = [["SomeType" , "f32"], ["AnotherType", "*"]]
-    /// ```
-    (arithmetic_side_effects_allowed_binary: Vec<[String; 2]> = <_>::default()),
-    /// Lint: ARITHMETIC_SIDE_EFFECTS.
-    ///
-    /// Suppress checking of the passed type names in unary operations like "negation" (`-`).
-    ///
-    /// #### Example
-    ///
-    /// ```toml
-    /// arithmetic-side-effects-allowed-unary = ["SomeType", "AnotherType"]
-    /// ```
-    (arithmetic_side_effects_allowed_unary: rustc_data_structures::fx::FxHashSet<String> = <_>::default()),
-    /// Lint: ENUM_VARIANT_NAMES, LARGE_TYPES_PASSED_BY_VALUE, TRIVIALLY_COPY_PASS_BY_REF, UNNECESSARY_WRAPS, UNUSED_SELF, UPPER_CASE_ACRONYMS, WRONG_SELF_CONVENTION, BOX_COLLECTION, REDUNDANT_ALLOCATION, RC_BUFFER, VEC_BOX, OPTION_OPTION, LINKEDLIST, RC_MUTEX, UNNECESSARY_BOX_RETURNS, SINGLE_CALL_FN.
-    ///
-    /// Suppress lints whenever the suggested change would cause breakage for other crates.
-    (avoid_breaking_exported_api: bool = true),
-    /// Lint: MANUAL_SPLIT_ONCE, MANUAL_STR_REPEAT, CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, OPTION_MAP_UNWRAP_OR, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR, IF_THEN_SOME_ELSE_NONE, APPROX_CONSTANT, DEPRECATED_CFG_ATTR, INDEX_REFUTABLE_SLICE, MAP_CLONE, BORROW_AS_PTR, MANUAL_BITS, ERR_EXPECT, CAST_ABS_TO_UNSIGNED, UNINLINED_FORMAT_ARGS, MANUAL_CLAMP, MANUAL_LET_ELSE, UNCHECKED_DURATION_SUBTRACTION, COLLAPSIBLE_STR_REPLACE, SEEK_FROM_CURRENT, SEEK_REWIND, UNNECESSARY_LAZY_EVALUATIONS, TRANSMUTE_PTR_TO_REF, ALMOST_COMPLETE_RANGE, NEEDLESS_BORROW, DERIVABLE_IMPLS, MANUAL_IS_ASCII_CHECK, MANUAL_REM_EUCLID, MANUAL_RETAIN, TYPE_REPETITION_IN_BOUNDS, TUPLE_ARRAY_CONVERSIONS, MANUAL_TRY_FOLD, MANUAL_HASH_ONE.
-    ///
-    /// The minimum rust version that the project supports
-    (msrv: crate::Msrv = crate::Msrv::empty()),
-    /// DEPRECATED LINT: BLACKLISTED_NAME.
-    ///
-    /// Use the Disallowed Names lint instead
-    #[conf_deprecated("Please use `disallowed-names` instead", disallowed_names)]
-    (blacklisted_names: Vec<String> = Vec::new()),
-    /// Lint: COGNITIVE_COMPLEXITY.
-    ///
-    /// The maximum cognitive complexity a function can have
-    (cognitive_complexity_threshold: u64 = 25),
-    /// Lint: EXCESSIVE_NESTING.
-    ///
-    /// The maximum amount of nesting a block can reside in
-    (excessive_nesting_threshold: u64 = 0),
-    /// DEPRECATED LINT: CYCLOMATIC_COMPLEXITY.
-    ///
-    /// Use the Cognitive Complexity lint instead.
-    #[conf_deprecated("Please use `cognitive-complexity-threshold` instead", cognitive_complexity_threshold)]
-    (cyclomatic_complexity_threshold: u64 = 25),
-    /// Lint: DISALLOWED_NAMES.
-    ///
-    /// The list of disallowed names to lint about. NB: `bar` is not here since it has legitimate uses. The value
-    /// `".."` can be used as part of the list to indicate that the configured values should be appended to the
-    /// default configuration of Clippy. By default, any configuration will replace the default value.
-    (disallowed_names: Vec<String> = super::DEFAULT_DISALLOWED_NAMES.iter().map(ToString::to_string).collect()),
-    /// Lint: SEMICOLON_INSIDE_BLOCK.
-    ///
-    /// Whether to lint only if it's multiline.
-    (semicolon_inside_block_ignore_singleline: bool = false),
-    /// Lint: SEMICOLON_OUTSIDE_BLOCK.
-    ///
-    /// Whether to lint only if it's singleline.
-    (semicolon_outside_block_ignore_multiline: bool = false),
-    /// Lint: DOC_MARKDOWN.
-    ///
-    /// The list of words this lint should not consider as identifiers needing ticks. The value
-    /// `".."` can be used as part of the list to indicate, that the configured values should be appended to the
-    /// default configuration of Clippy. By default, any configuration will replace the default value. For example:
-    /// * `doc-valid-idents = ["ClipPy"]` would replace the default list with `["ClipPy"]`.
-    /// * `doc-valid-idents = ["ClipPy", ".."]` would append `ClipPy` to the default list.
-    ///
-    /// Default list:
-    (doc_valid_idents: Vec<String> = super::DEFAULT_DOC_VALID_IDENTS.iter().map(ToString::to_string).collect()),
-    /// Lint: TOO_MANY_ARGUMENTS.
-    ///
-    /// The maximum number of argument a function or method can have
-    (too_many_arguments_threshold: u64 = 7),
-    /// Lint: TYPE_COMPLEXITY.
-    ///
-    /// The maximum complexity a type can have
-    (type_complexity_threshold: u64 = 250),
-    /// Lint: MANY_SINGLE_CHAR_NAMES.
-    ///
-    /// The maximum number of single char bindings a scope may have
-    (single_char_binding_names_threshold: u64 = 4),
-    /// Lint: BOXED_LOCAL, USELESS_VEC.
-    ///
-    /// The maximum size of objects (in bytes) that will be linted. Larger objects are ok on the heap
-    (too_large_for_stack: u64 = 200),
-    /// Lint: ENUM_VARIANT_NAMES.
-    ///
-    /// The minimum number of enum variants for the lints about variant names to trigger
-    (enum_variant_name_threshold: u64 = 3),
-    /// Lint: STRUCT_VARIANT_NAMES.
-    ///
-    /// The minimum number of struct fields for the lints about field names to trigger
-    (struct_field_name_threshold: u64 = 3),
-    /// Lint: LARGE_ENUM_VARIANT.
-    ///
-    /// The maximum size of an enum's variant to avoid box suggestion
-    (enum_variant_size_threshold: u64 = 200),
-    /// Lint: VERBOSE_BIT_MASK.
-    ///
-    /// The maximum allowed size of a bit mask before suggesting to use 'trailing_zeros'
-    (verbose_bit_mask_threshold: u64 = 1),
-    /// Lint: DECIMAL_LITERAL_REPRESENTATION.
-    ///
-    /// The lower bound for linting decimal literals
-    (literal_representation_threshold: u64 = 16384),
-    /// Lint: TRIVIALLY_COPY_PASS_BY_REF.
-    ///
-    /// The maximum size (in bytes) to consider a `Copy` type for passing by value instead of by reference.
-    (trivial_copy_size_limit: Option<u64> = None),
-    /// Lint: LARGE_TYPES_PASSED_BY_VALUE.
-    ///
-    /// The minimum size (in bytes) to consider a type for passing by reference instead of by value.
-    (pass_by_value_size_limit: u64 = 256),
-    /// Lint: TOO_MANY_LINES.
-    ///
-    /// The maximum number of lines a function or method can have
-    (too_many_lines_threshold: u64 = 100),
-    /// Lint: LARGE_STACK_ARRAYS, LARGE_CONST_ARRAYS.
-    ///
-    /// The maximum allowed size for arrays on the stack
-    (array_size_threshold: u64 = 512_000),
-    /// Lint: LARGE_STACK_FRAMES.
-    ///
-    /// The maximum allowed stack size for functions in bytes
-    (stack_size_threshold: u64 = 512_000),
-    /// Lint: VEC_BOX.
-    ///
-    /// The size of the boxed type in bytes, where boxing in a `Vec` is allowed
-    (vec_box_size_threshold: u64 = 4096),
-    /// Lint: TYPE_REPETITION_IN_BOUNDS.
-    ///
-    /// The maximum number of bounds a trait can have to be linted
-    (max_trait_bounds: u64 = 3),
-    /// Lint: STRUCT_EXCESSIVE_BOOLS.
-    ///
-    /// The maximum number of bool fields a struct can have
-    (max_struct_bools: u64 = 3),
-    /// Lint: FN_PARAMS_EXCESSIVE_BOOLS.
-    ///
-    /// The maximum number of bool parameters a function can have
-    (max_fn_params_bools: u64 = 3),
-    /// Lint: WILDCARD_IMPORTS.
-    ///
-    /// Whether to allow certain wildcard imports (prelude, super in tests).
-    (warn_on_all_wildcard_imports: bool = false),
-    /// Lint: DISALLOWED_MACROS.
-    ///
-    /// The list of disallowed macros, written as fully qualified paths.
-    (disallowed_macros: Vec<crate::utils::conf::DisallowedPath> = Vec::new()),
-    /// Lint: DISALLOWED_METHODS.
-    ///
-    /// The list of disallowed methods, written as fully qualified paths.
-    (disallowed_methods: Vec<crate::utils::conf::DisallowedPath> = Vec::new()),
-    /// Lint: DISALLOWED_TYPES.
-    ///
-    /// The list of disallowed types, written as fully qualified paths.
-    (disallowed_types: Vec<crate::utils::conf::DisallowedPath> = Vec::new()),
-    /// Lint: UNREADABLE_LITERAL.
-    ///
-    /// Should the fraction of a decimal be linted to include separators.
-    (unreadable_literal_lint_fractions: bool = true),
-    /// Lint: UPPER_CASE_ACRONYMS.
-    ///
-    /// Enables verbose mode. Triggers if there is more than one uppercase char next to each other
-    (upper_case_acronyms_aggressive: bool = false),
-    /// Lint: MANUAL_LET_ELSE.
-    ///
-    /// Whether the matches should be considered by the lint, and whether there should
-    /// be filtering for common types.
-    (matches_for_let_else: crate::manual_let_else::MatchLintBehaviour =
-        crate::manual_let_else::MatchLintBehaviour::WellKnownTypes),
-    /// Lint: _CARGO_COMMON_METADATA.
-    ///
-    /// For internal testing only, ignores the current `publish` settings in the Cargo manifest.
-    (cargo_ignore_publish: bool = false),
-    /// Lint: NONSTANDARD_MACRO_BRACES.
-    ///
-    /// Enforce the named macros always use the braces specified.
-    ///
-    /// A `MacroMatcher` can be added like so `{ name = "macro_name", brace = "(" }`. If the macro
-    /// could be used with a full path two `MacroMatcher`s have to be added one with the full path
-    /// `crate_name::macro_name` and one with just the macro name.
-    (standard_macro_braces: Vec<crate::nonstandard_macro_braces::MacroMatcher> = Vec::new()),
-    /// Lint: MISSING_ENFORCED_IMPORT_RENAMES.
-    ///
-    /// The list of imports to always rename, a fully qualified path followed by the rename.
-    (enforced_import_renames: Vec<crate::utils::conf::Rename> = Vec::new()),
-    /// Lint: DISALLOWED_SCRIPT_IDENTS.
-    ///
-    /// The list of unicode scripts allowed to be used in the scope.
-    (allowed_scripts: Vec<String> = vec!["Latin".to_string()]),
-    /// Lint: NON_SEND_FIELDS_IN_SEND_TY.
-    ///
-    /// Whether to apply the raw pointer heuristic to determine if a type is `Send`.
-    (enable_raw_pointer_heuristic_for_send: bool = true),
-    /// Lint: INDEX_REFUTABLE_SLICE.
-    ///
-    /// When Clippy suggests using a slice pattern, this is the maximum number of elements allowed in
-    /// the slice pattern that is suggested. If more elements are necessary, the lint is suppressed.
-    /// For example, `[_, _, _, e, ..]` is a slice pattern with 4 elements.
-    (max_suggested_slice_pattern_length: u64 = 3),
-    /// Lint: AWAIT_HOLDING_INVALID_TYPE.
-    (await_holding_invalid_types: Vec<crate::utils::conf::DisallowedPath> = Vec::new()),
-    /// Lint: LARGE_INCLUDE_FILE.
-    ///
-    /// The maximum size of a file included via `include_bytes!()` or `include_str!()`, in bytes
-    (max_include_file_size: u64 = 1_000_000),
-    /// Lint: EXPECT_USED.
-    ///
-    /// Whether `expect` should be allowed in test functions or `#[cfg(test)]`
-    (allow_expect_in_tests: bool = false),
-    /// Lint: UNWRAP_USED.
-    ///
-    /// Whether `unwrap` should be allowed in test functions or `#[cfg(test)]`
-    (allow_unwrap_in_tests: bool = false),
-    /// Lint: DBG_MACRO.
-    ///
-    /// Whether `dbg!` should be allowed in test functions or `#[cfg(test)]`
-    (allow_dbg_in_tests: bool = false),
-    /// Lint: PRINT_STDOUT, PRINT_STDERR.
-    ///
-    /// Whether print macros (ex. `println!`) should be allowed in test functions or `#[cfg(test)]`
-    (allow_print_in_tests: bool = false),
-    /// Lint: RESULT_LARGE_ERR.
-    ///
-    /// The maximum size of the `Err`-variant in a `Result` returned from a function
-    (large_error_threshold: u64 = 128),
-    /// Lint: MUTABLE_KEY_TYPE, IFS_SAME_COND.
-    ///
-    /// A list of paths to types that should be treated like `Arc`, i.e. ignored but
-    /// for the generic parameters for determining interior mutability
-    (ignore_interior_mutability: Vec<String> = Vec::from(["bytes::Bytes".into()])),
-    /// Lint: UNINLINED_FORMAT_ARGS.
-    ///
-    /// Whether to allow mixed uninlined format args, e.g. `format!("{} {}", a, foo.bar)`
-    (allow_mixed_uninlined_format_args: bool = true),
-    /// Lint: INDEXING_SLICING.
-    ///
-    /// Whether to suppress a restriction lint in constant code. In same
-    /// cases the restructured operation might not be unavoidable, as the
-    /// suggested counterparts are unavailable in constant code. This
-    /// configuration will cause restriction lints to trigger even
-    /// if no suggestion can be made.
-    (suppress_restriction_lint_in_const: bool = false),
-    /// Lint: MISSING_DOCS_IN_PRIVATE_ITEMS.
-    ///
-    /// Whether to **only** check for missing documentation in items visible within the current
-    /// crate. For example, `pub(crate)` items.
-    (missing_docs_in_crate_items: bool = false),
-    /// Lint: LARGE_FUTURES.
-    ///
-    /// The maximum byte size a `Future` can have, before it triggers the `clippy::large_futures` lint
-    (future_size_threshold: u64 = 16 * 1024),
-    /// Lint: UNNECESSARY_BOX_RETURNS.
-    ///
-    /// The byte size a `T` in `Box<T>` can have, below which it triggers the `clippy::unnecessary_box` lint
-    (unnecessary_box_size: u64 = 128),
-    /// Lint: MODULE_INCEPTION.
-    ///
-    /// Whether to allow module inception if it's not public.
-    (allow_private_module_inception: bool = false),
-    /// Lint: MIN_IDENT_CHARS.
-    ///
-    /// Allowed names below the minimum allowed characters. The value `".."` can be used as part of
-    /// the list to indicate, that the configured values should be appended to the default
-    /// configuration of Clippy. By default, any configuration will replace the default value.
-    (allowed_idents_below_min_chars: rustc_data_structures::fx::FxHashSet<String> =
-        super::DEFAULT_ALLOWED_IDENTS_BELOW_MIN_CHARS.iter().map(ToString::to_string).collect()),
-    /// Lint: MIN_IDENT_CHARS.
-    ///
-    /// Minimum chars an ident can have, anything below or equal to this will be linted.
-    (min_ident_chars_threshold: u64 = 1),
-    /// Lint: UNDOCUMENTED_UNSAFE_BLOCKS.
-    ///
-    /// Whether to accept a safety comment to be placed above the statement containing the `unsafe` block
-    (accept_comment_above_statement: bool = true),
-    /// Lint: UNDOCUMENTED_UNSAFE_BLOCKS.
-    ///
-    /// Whether to accept a safety comment to be placed above the attributes for the `unsafe` block
-    (accept_comment_above_attributes: bool = true),
-    /// Lint: UNNECESSARY_RAW_STRING_HASHES.
-    ///
-    /// Whether to allow `r#""#` when `r""` can be used
-    (allow_one_hash_in_raw_strings: bool = false),
-    /// Lint: ABSOLUTE_PATHS.
-    ///
-    /// The maximum number of segments a path can have before being linted, anything above this will
-    /// be linted.
-    (absolute_paths_max_segments: u64 = 2),
-    /// Lint: ABSOLUTE_PATHS.
-    ///
-    /// Which crates to allow absolute paths from
-    (absolute_paths_allowed_crates: rustc_data_structures::fx::FxHashSet<String> =
-        rustc_data_structures::fx::FxHashSet::default()),
-    /// Lint: PATH_ENDS_WITH_EXT.
-    ///
-    /// Additional dotfiles (files or directories starting with a dot) to allow
-    (allowed_dotfiles: rustc_data_structures::fx::FxHashSet<String> =
-        rustc_data_structures::fx::FxHashSet::default()),
-    /// Lint: EXPLICIT_ITER_LOOP
-    ///
-    /// Whether to recommend using implicit into iter for reborrowed values.
-    ///
-    /// #### Example
-    /// ```no_run
-    /// let mut vec = vec![1, 2, 3];
-    /// let rmvec = &mut vec;
-    /// for _ in rmvec.iter() {}
-    /// for _ in rmvec.iter_mut() {}
-    /// ```
-    ///
-    /// Use instead:
-    /// ```no_run
-    /// let mut vec = vec![1, 2, 3];
-    /// let rmvec = &mut vec;
-    /// for _ in &*rmvec {}
-    /// for _ in &mut *rmvec {}
-    /// ```
-    (enforce_iter_loop_reborrow: bool = false),
-}
-
-/// Search for the configuration file.
-///
-/// # Errors
-///
-/// Returns any unexpected filesystem error encountered when searching for the config file
-pub fn lookup_conf_file() -> io::Result<(Option<PathBuf>, Vec<String>)> {
-    /// Possible filename to search for.
-    const CONFIG_FILE_NAMES: [&str; 2] = [".clippy.toml", "clippy.toml"];
-
-    // Start looking for a config file in CLIPPY_CONF_DIR, or failing that, CARGO_MANIFEST_DIR.
-    // If neither of those exist, use ".". (Update documentation if this priority changes)
-    let mut current = env::var_os("CLIPPY_CONF_DIR")
-        .or_else(|| env::var_os("CARGO_MANIFEST_DIR"))
-        .map_or_else(|| PathBuf::from("."), PathBuf::from)
-        .canonicalize()?;
-
-    let mut found_config: Option<PathBuf> = None;
-    let mut warnings = vec![];
-
-    loop {
-        for config_file_name in &CONFIG_FILE_NAMES {
-            if let Ok(config_file) = current.join(config_file_name).canonicalize() {
-                match fs::metadata(&config_file) {
-                    Err(e) if e.kind() == io::ErrorKind::NotFound => {},
-                    Err(e) => return Err(e),
-                    Ok(md) if md.is_dir() => {},
-                    Ok(_) => {
-                        // warn if we happen to find two config files #8323
-                        if let Some(ref found_config) = found_config {
-                            warnings.push(format!(
-                                "using config file `{}`, `{}` will be ignored",
-                                found_config.display(),
-                                config_file.display()
-                            ));
-                        } else {
-                            found_config = Some(config_file);
-                        }
-                    },
-                }
-            }
-        }
-
-        if found_config.is_some() {
-            return Ok((found_config, warnings));
-        }
-
-        // If the current directory has no parent, we're done searching.
-        if !current.pop() {
-            return Ok((None, warnings));
-        }
-    }
-}
-
-fn deserialize(file: &SourceFile) -> TryConf {
-    match toml::de::Deserializer::new(file.src.as_ref().unwrap()).deserialize_map(ConfVisitor(file)) {
-        Ok(mut conf) => {
-            extend_vec_if_indicator_present(&mut conf.conf.doc_valid_idents, DEFAULT_DOC_VALID_IDENTS);
-            extend_vec_if_indicator_present(&mut conf.conf.disallowed_names, DEFAULT_DISALLOWED_NAMES);
-            // TODO: THIS SHOULD BE TESTED, this comment will be gone soon
-            if conf.conf.allowed_idents_below_min_chars.contains(&"..".to_owned()) {
-                conf.conf
-                    .allowed_idents_below_min_chars
-                    .extend(DEFAULT_ALLOWED_IDENTS_BELOW_MIN_CHARS.iter().map(ToString::to_string));
-            }
-
-            conf
-        },
-        Err(e) => TryConf::from_toml_error(file, &e),
-    }
-}
-
-fn extend_vec_if_indicator_present(vec: &mut Vec<String>, default: &[&str]) {
-    if vec.contains(&"..".to_string()) {
-        vec.extend(default.iter().map(ToString::to_string));
-    }
-}
-
-impl Conf {
-    pub fn read(sess: &Session, path: &io::Result<(Option<PathBuf>, Vec<String>)>) -> &'static Conf {
-        static CONF: OnceLock<Conf> = OnceLock::new();
-        CONF.get_or_init(|| Conf::read_inner(sess, path))
-    }
-
-    fn read_inner(sess: &Session, path: &io::Result<(Option<PathBuf>, Vec<String>)>) -> Conf {
-        match path {
-            Ok((_, warnings)) => {
-                for warning in warnings {
-                    sess.warn(warning.clone());
-                }
-            },
-            Err(error) => {
-                sess.err(format!("error finding Clippy's configuration file: {error}"));
-            },
-        }
-
-        let TryConf {
-            mut conf,
-            errors,
-            warnings,
-        } = match path {
-            Ok((Some(path), _)) => match sess.source_map().load_file(path) {
-                Ok(file) => deserialize(&file),
-                Err(error) => {
-                    sess.err(format!("failed to read `{}`: {error}", path.display()));
-                    TryConf::default()
-                },
-            },
-            _ => TryConf::default(),
-        };
-
-        conf.msrv.read_cargo(sess);
-
-        // all conf errors are non-fatal, we just use the default conf in case of error
-        for error in errors {
-            sess.span_err(
-                error.span,
-                format!("error reading Clippy's configuration file: {}", error.message),
-            );
-        }
-
-        for warning in warnings {
-            sess.span_warn(
-                warning.span,
-                format!("error reading Clippy's configuration file: {}", warning.message),
-            );
-        }
-
-        conf
-    }
-}
-
-const SEPARATOR_WIDTH: usize = 4;
-
-#[derive(Debug)]
-struct FieldError(String);
-
-impl std::error::Error for FieldError {}
-
-impl Display for FieldError {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        f.pad(&self.0)
-    }
-}
-
-impl serde::de::Error for FieldError {
-    fn custom<T: Display>(msg: T) -> Self {
-        Self(msg.to_string())
-    }
-
-    fn unknown_field(field: &str, expected: &'static [&'static str]) -> Self {
-        // List the available fields sorted and at least one per line, more if `CLIPPY_TERMINAL_WIDTH` is
-        // set and allows it.
-        use fmt::Write;
-
-        let mut expected = expected.to_vec();
-        expected.sort_unstable();
-
-        let (rows, column_widths) = calculate_dimensions(&expected);
-
-        let mut msg = format!("unknown field `{field}`, expected one of");
-        for row in 0..rows {
-            writeln!(msg).unwrap();
-            for (column, column_width) in column_widths.iter().copied().enumerate() {
-                let index = column * rows + row;
-                let field = expected.get(index).copied().unwrap_or_default();
-                write!(msg, "{:SEPARATOR_WIDTH$}{field:column_width$}", " ").unwrap();
-            }
-        }
-        Self(msg)
-    }
-}
-
-fn calculate_dimensions(fields: &[&str]) -> (usize, Vec<usize>) {
-    let columns = env::var("CLIPPY_TERMINAL_WIDTH")
-        .ok()
-        .and_then(|s| <usize as FromStr>::from_str(&s).ok())
-        .map_or(1, |terminal_width| {
-            let max_field_width = fields.iter().map(|field| field.len()).max().unwrap();
-            cmp::max(1, terminal_width / (SEPARATOR_WIDTH + max_field_width))
-        });
-
-    let rows = (fields.len() + (columns - 1)) / columns;
-
-    let column_widths = (0..columns)
-        .map(|column| {
-            if column < columns - 1 {
-                (0..rows)
-                    .map(|row| {
-                        let index = column * rows + row;
-                        let field = fields.get(index).copied().unwrap_or_default();
-                        field.len()
-                    })
-                    .max()
-                    .unwrap()
-            } else {
-                // Avoid adding extra space to the last column.
-                0
-            }
-        })
-        .collect::<Vec<_>>();
-
-    (rows, column_widths)
-}
-
-#[cfg(test)]
-mod tests {
-    use rustc_data_structures::fx::{FxHashMap, FxHashSet};
-    use serde::de::IgnoredAny;
-    use std::fs;
-    use walkdir::WalkDir;
-
-    #[test]
-    fn configs_are_tested() {
-        let mut names: FxHashSet<String> = super::metadata::get_configuration_metadata()
-            .into_iter()
-            .map(|meta| meta.name.replace('_', "-"))
-            .collect();
-
-        let toml_files = WalkDir::new("../tests")
-            .into_iter()
-            .map(Result::unwrap)
-            .filter(|entry| entry.file_name() == "clippy.toml");
-
-        for entry in toml_files {
-            let file = fs::read_to_string(entry.path()).unwrap();
-            #[allow(clippy::zero_sized_map_values)]
-            if let Ok(map) = toml::from_str::<FxHashMap<String, IgnoredAny>>(&file) {
-                for name in map.keys() {
-                    names.remove(name.as_str());
-                }
-            }
-        }
-
-        assert!(
-            names.remove("allow-one-hash-in-raw-strings"),
-            "remove this when #11481 is fixed"
-        );
-
-        assert!(
-            names.is_empty(),
-            "Configuration variable lacks test: {names:?}\nAdd a test to `tests/ui-toml`"
-        );
-    }
-}
diff --git a/clippy_lints/src/utils/format_args_collector.rs b/clippy_lints/src/utils/format_args_collector.rs
index 94a9a7c241b..58e66c9f9b9 100644
--- a/clippy_lints/src/utils/format_args_collector.rs
+++ b/clippy_lints/src/utils/format_args_collector.rs
@@ -5,27 +5,20 @@ use rustc_ast::{Crate, Expr, ExprKind, FormatArgs};
 use rustc_data_structures::fx::FxHashMap;
 use rustc_lexer::{tokenize, TokenKind};
 use rustc_lint::{EarlyContext, EarlyLintPass};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::{hygiene, Span};
 use std::iter::once;
 use std::mem;
 use std::rc::Rc;
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Collects [`rustc_ast::FormatArgs`] so that future late passes can call
-    /// [`clippy_utils::macros::find_format_args`]
-    pub FORMAT_ARGS_COLLECTOR,
-    internal_warn,
-    "collects `format_args` AST nodes for use in later lints"
-}
-
+/// Collects [`rustc_ast::FormatArgs`] so that future late passes can call
+/// [`clippy_utils::macros::find_format_args`]
 #[derive(Default)]
 pub struct FormatArgsCollector {
     format_args: FxHashMap<Span, Rc<FormatArgs>>,
 }
 
-impl_lint_pass!(FormatArgsCollector => [FORMAT_ARGS_COLLECTOR]);
+impl_lint_pass!(FormatArgsCollector => []);
 
 impl EarlyLintPass for FormatArgsCollector {
     fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index c8600badf18..01929e1ba10 100644
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -9,7 +9,7 @@
 
 use crate::renamed_lints::RENAMED_LINTS;
 use crate::utils::internal_lints::lint_without_lint_pass::{extract_clippy_version_value, is_lint_ref_type};
-use crate::utils::{collect_configs, ClippyConfiguration};
+use clippy_config::{get_configuration_metadata, ClippyConfiguration};
 
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::ty::{match_type, walk_ptrs_ty_depth};
@@ -155,7 +155,7 @@ impl MetadataCollector {
         Self {
             lints: BinaryHeap::<LintMetadata>::default(),
             applicability_info: FxHashMap::<String, ApplicabilityInfo>::default(),
-            config: collect_configs(),
+            config: get_configuration_metadata(),
             clippy_project_root: std::env::current_dir()
                 .expect("failed to get current dir")
                 .ancestors()
@@ -528,16 +528,6 @@ impl Serialize for ApplicabilityInfo {
     }
 }
 
-impl fmt::Display for ClippyConfiguration {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> fmt::Result {
-        writeln!(
-            f,
-            "* `{}`: `{}`(defaults to `{}`): {}",
-            self.name, self.config_type, self.default, self.doc
-        )
-    }
-}
-
 // ==================================================================
 // Lint pass
 // ==================================================================
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index 4fef8c0717d..78096092a0e 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -1,122 +1,12 @@
 pub mod author;
-pub mod conf;
 pub mod dump_hir;
 pub mod format_args_collector;
 #[cfg(feature = "internal")]
 pub mod internal_lints;
-#[cfg(feature = "internal")]
-use itertools::Itertools;
-
-/// Transforms a given `snake_case_string` to a tasty `kebab-case-string`
-fn to_kebab(config_name: &str) -> String {
-    config_name.replace('_', "-")
-}
-
-#[cfg(feature = "internal")]
-const BOOK_CONFIGS_PATH: &str = "https://doc.rust-lang.org/clippy/lint_configuration.html";
 
 // ==================================================================
 // Configuration
 // ==================================================================
-#[derive(Debug, Clone, Default)]
-pub struct ClippyConfiguration {
-    pub name: String,
-    #[allow(dead_code)]
-    config_type: &'static str,
-    pub default: String,
-    pub lints: Vec<String>,
-    pub doc: String,
-    #[allow(dead_code)]
-    deprecation_reason: Option<&'static str>,
-}
-
-impl ClippyConfiguration {
-    pub fn new(
-        name: &'static str,
-        config_type: &'static str,
-        default: String,
-        doc_comment: &'static str,
-        deprecation_reason: Option<&'static str>,
-    ) -> Self {
-        let (lints, doc) = parse_config_field_doc(doc_comment)
-            .unwrap_or_else(|| (vec![], "[ERROR] MALFORMED DOC COMMENT".to_string()));
-
-        Self {
-            name: to_kebab(name),
-            lints,
-            doc,
-            config_type,
-            default,
-            deprecation_reason,
-        }
-    }
-
-    #[cfg(feature = "internal")]
-    fn to_markdown_paragraph(&self) -> String {
-        format!(
-            "## `{}`\n{}\n\n**Default Value:** `{}` (`{}`)\n\n---\n**Affected lints:**\n{}\n\n",
-            self.name,
-            self.doc
-                .lines()
-                .map(|line| line.strip_prefix("    ").unwrap_or(line))
-                .join("\n"),
-            self.default,
-            self.config_type,
-            self.lints
-                .iter()
-                .map(|name| name.to_string().split_whitespace().next().unwrap().to_string())
-                .map(|name| format!("* [`{name}`](https://rust-lang.github.io/rust-clippy/master/index.html#{name})"))
-                .join("\n"),
-        )
-    }
-    #[cfg(feature = "internal")]
-    fn to_markdown_link(&self) -> String {
-        format!("[`{}`]: {BOOK_CONFIGS_PATH}#{}", self.name, self.name)
-    }
-}
-
-#[cfg(feature = "internal")]
-fn collect_configs() -> Vec<ClippyConfiguration> {
-    crate::utils::conf::metadata::get_configuration_metadata()
-}
-
-/// This parses the field documentation of the config struct.
-///
-/// ```rust, ignore
-/// parse_config_field_doc(cx, "Lint: LINT_NAME_1, LINT_NAME_2. Papa penguin, papa penguin")
-/// ```
-///
-/// Would yield:
-/// ```rust, ignore
-/// Some(["lint_name_1", "lint_name_2"], "Papa penguin, papa penguin")
-/// ```
-fn parse_config_field_doc(doc_comment: &str) -> Option<(Vec<String>, String)> {
-    const DOC_START: &str = " Lint: ";
-    if_chain! {
-        if doc_comment.starts_with(DOC_START);
-        if let Some(split_pos) = doc_comment.find('.');
-        then {
-            let mut doc_comment = doc_comment.to_string();
-            let mut documentation = doc_comment.split_off(split_pos);
-
-            // Extract lints
-            doc_comment.make_ascii_lowercase();
-            let lints: Vec<String> = doc_comment
-                .split_off(DOC_START.len())
-                .split(", ")
-                .map(str::to_string)
-                .collect();
-
-            // Format documentation correctly
-            // split off leading `.` from lint name list and indent for correct formatting
-            documentation = documentation.trim_start_matches('.').trim().replace("\n ", "\n    ");
-
-            Some((lints, documentation))
-        } else {
-            None
-        }
-    }
-}
 
 // Shamelessly stolen from find_all (https://github.com/nectariner/find_all)
 pub trait FindAll: Iterator + Sized {
diff --git a/clippy_lints/src/vec.rs b/clippy_lints/src/vec.rs
index 42a69fa1133..17294450acf 100644
--- a/clippy_lints/src/vec.rs
+++ b/clippy_lints/src/vec.rs
@@ -1,8 +1,8 @@
 use std::ops::ControlFlow;
 
+use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::consts::{constant, Constant};
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::is_copy;
 use clippy_utils::visitors::for_each_local_use_after_expr;
diff --git a/clippy_utils/Cargo.toml b/clippy_utils/Cargo.toml
index 90091ca927a..8c9cfbbd8fc 100644
--- a/clippy_utils/Cargo.toml
+++ b/clippy_utils/Cargo.toml
@@ -5,11 +5,11 @@ edition = "2021"
 publish = false
 
 [dependencies]
+clippy_config = { path = "../clippy_config" }
 arrayvec = { version = "0.7", default-features = false }
 if_chain = "1.0"
 itertools = "0.10.1"
 rustc-semver = "1.1"
-serde = { version = "1.0" }
 
 [features]
 deny-warnings = []
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 9fed6130a28..11467138a58 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -54,7 +54,6 @@ pub mod higher;
 mod hir_utils;
 pub mod macros;
 pub mod mir;
-pub mod msrvs;
 pub mod numeric_literal;
 pub mod paths;
 pub mod ptr;
diff --git a/clippy_utils/src/msrvs.rs b/clippy_utils/src/msrvs.rs
deleted file mode 100644
index c6a48874e09..00000000000
--- a/clippy_utils/src/msrvs.rs
+++ /dev/null
@@ -1,130 +0,0 @@
-use rustc_ast::Attribute;
-use rustc_semver::RustcVersion;
-use rustc_session::Session;
-use serde::Deserialize;
-
-use crate::attrs::get_unique_attr;
-
-macro_rules! msrv_aliases {
-    ($($major:literal,$minor:literal,$patch:literal {
-        $($name:ident),* $(,)?
-    })*) => {
-        $($(
-        pub const $name: RustcVersion = RustcVersion::new($major, $minor, $patch);
-        )*)*
-    };
-}
-
-// names may refer to stabilized feature flags or library items
-msrv_aliases! {
-    1,71,0 { TUPLE_ARRAY_CONVERSIONS, BUILD_HASHER_HASH_ONE }
-    1,70,0 { OPTION_IS_SOME_AND, BINARY_HEAP_RETAIN }
-    1,68,0 { PATH_MAIN_SEPARATOR_STR }
-    1,65,0 { LET_ELSE, POINTER_CAST_CONSTNESS }
-    1,62,0 { BOOL_THEN_SOME, DEFAULT_ENUM_ATTRIBUTE }
-    1,58,0 { FORMAT_ARGS_CAPTURE, PATTERN_TRAIT_CHAR_ARRAY }
-    1,55,0 { SEEK_REWIND }
-    1,53,0 { OR_PATTERNS, MANUAL_BITS, BTREE_MAP_RETAIN, BTREE_SET_RETAIN, ARRAY_INTO_ITERATOR }
-    1,52,0 { STR_SPLIT_ONCE, REM_EUCLID_CONST }
-    1,51,0 { BORROW_AS_PTR, SEEK_FROM_CURRENT, UNSIGNED_ABS }
-    1,50,0 { BOOL_THEN, CLAMP }
-    1,47,0 { TAU, IS_ASCII_DIGIT_CONST, ARRAY_IMPL_ANY_LEN }
-    1,46,0 { CONST_IF_MATCH }
-    1,45,0 { STR_STRIP_PREFIX }
-    1,43,0 { LOG2_10, LOG10_2 }
-    1,42,0 { MATCHES_MACRO, SLICE_PATTERNS, PTR_SLICE_RAW_PARTS }
-    1,41,0 { RE_REBALANCING_COHERENCE, RESULT_MAP_OR_ELSE }
-    1,40,0 { MEM_TAKE, NON_EXHAUSTIVE, OPTION_AS_DEREF }
-    1,38,0 { POINTER_CAST, REM_EUCLID }
-    1,37,0 { TYPE_ALIAS_ENUM_VARIANTS }
-    1,36,0 { ITERATOR_COPIED }
-    1,35,0 { OPTION_COPIED, RANGE_CONTAINS }
-    1,34,0 { TRY_FROM }
-    1,30,0 { ITERATOR_FIND_MAP, TOOL_ATTRIBUTES }
-    1,28,0 { FROM_BOOL }
-    1,27,0 { ITERATOR_TRY_FOLD }
-    1,26,0 { RANGE_INCLUSIVE, STRING_RETAIN }
-    1,24,0 { IS_ASCII_DIGIT }
-    1,18,0 { HASH_MAP_RETAIN, HASH_SET_RETAIN }
-    1,17,0 { FIELD_INIT_SHORTHAND, STATIC_IN_CONST, EXPECT_ERR }
-    1,16,0 { STR_REPEAT }
-    1,15,0 { MAYBE_BOUND_IN_WHERE }
-}
-
-/// Tracks the current MSRV from `clippy.toml`, `Cargo.toml` or set via `#[clippy::msrv]`
-#[derive(Debug, Clone)]
-pub struct Msrv {
-    stack: Vec<RustcVersion>,
-}
-
-impl<'de> Deserialize<'de> for Msrv {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        let v = String::deserialize(deserializer)?;
-        RustcVersion::parse(&v)
-            .map(|v| Msrv { stack: vec![v] })
-            .map_err(|_| serde::de::Error::custom("not a valid Rust version"))
-    }
-}
-
-impl Msrv {
-    pub fn empty() -> Msrv {
-        Msrv { stack: Vec::new() }
-    }
-
-    pub fn read_cargo(&mut self, sess: &Session) {
-        let cargo_msrv = std::env::var("CARGO_PKG_RUST_VERSION")
-            .ok()
-            .and_then(|v| RustcVersion::parse(&v).ok());
-
-        match (self.current(), cargo_msrv) {
-            (None, Some(cargo_msrv)) => self.stack = vec![cargo_msrv],
-            (Some(clippy_msrv), Some(cargo_msrv)) => {
-                if clippy_msrv != cargo_msrv {
-                    sess.warn(format!(
-                        "the MSRV in `clippy.toml` and `Cargo.toml` differ; using `{clippy_msrv}` from `clippy.toml`"
-                    ));
-                }
-            },
-            _ => {},
-        }
-    }
-
-    pub fn current(&self) -> Option<RustcVersion> {
-        self.stack.last().copied()
-    }
-
-    pub fn meets(&self, required: RustcVersion) -> bool {
-        self.current().map_or(true, |version| version.meets(required))
-    }
-
-    fn parse_attr(sess: &Session, attrs: &[Attribute]) -> Option<RustcVersion> {
-        if let Some(msrv_attr) = get_unique_attr(sess, attrs, "msrv") {
-            if let Some(msrv) = msrv_attr.value_str() {
-                if let Ok(version) = RustcVersion::parse(msrv.as_str()) {
-                    return Some(version);
-                }
-
-                sess.span_err(msrv_attr.span, format!("`{msrv}` is not a valid Rust version"));
-            } else {
-                sess.span_err(msrv_attr.span, "bad clippy attribute");
-            }
-        }
-
-        None
-    }
-
-    pub fn enter_lint_attrs(&mut self, sess: &Session, attrs: &[Attribute]) {
-        if let Some(version) = Self::parse_attr(sess, attrs) {
-            self.stack.push(version);
-        }
-    }
-
-    pub fn exit_lint_attrs(&mut self, sess: &Session, attrs: &[Attribute]) {
-        if Self::parse_attr(sess, attrs).is_some() {
-            self.stack.pop();
-        }
-    }
-}
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index 4a20399e364..0b0e8cdc9f4 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -53,7 +53,7 @@ pub const LATE_LINT_PASS: [&str; 3] = ["rustc_lint", "passes", "LateLintPass"];
 #[cfg(feature = "internal")]
 pub const LINT: [&str; 2] = ["rustc_lint_defs", "Lint"];
 #[cfg(feature = "internal")]
-pub const MSRV: [&str; 3] = ["clippy_utils", "msrvs", "Msrv"];
+pub const MSRV: [&str; 3] = ["clippy_config", "msrvs", "Msrv"];
 pub const OS_STRING_AS_OS_STR: [&str; 5] = ["std", "ffi", "os_str", "OsString", "as_os_str"];
 pub const OS_STR_TO_OS_STRING: [&str; 5] = ["std", "ffi", "os_str", "OsStr", "to_os_string"];
 pub const PARKING_LOT_MUTEX_GUARD: [&str; 3] = ["lock_api", "mutex", "MutexGuard"];
diff --git a/clippy_utils/src/qualify_min_const_fn.rs b/clippy_utils/src/qualify_min_const_fn.rs
index f6096ea546d..6cfd621d7f0 100644
--- a/clippy_utils/src/qualify_min_const_fn.rs
+++ b/clippy_utils/src/qualify_min_const_fn.rs
@@ -3,7 +3,7 @@
 // of terminologies might not be relevant in the context of Clippy. Note that its behavior might
 // differ from the time of `rustc` even if the name stays the same.
 
-use crate::msrvs::Msrv;
+use clippy_config::msrvs::Msrv;
 use hir::LangItem;
 use rustc_const_eval::transform::check_consts::ConstCx;
 use rustc_hir as hir;
diff --git a/src/driver.rs b/src/driver.rs
index 0e81419f1fa..17d57c30f08 100644
--- a/src/driver.rs
+++ b/src/driver.rs
@@ -126,7 +126,7 @@ impl rustc_driver::Callbacks for ClippyCallbacks {
     // JUSTIFICATION: necessary in clippy driver to set `mir_opt_level`
     #[allow(rustc::bad_opt_access)]
     fn config(&mut self, config: &mut interface::Config) {
-        let conf_path = clippy_lints::lookup_conf_file();
+        let conf_path = clippy_config::lookup_conf_file();
         let previous = config.register_lints.take();
         let clippy_args_var = self.clippy_args_var.take();
         config.parse_sess_created = Some(Box::new(move |parse_sess| {
@@ -147,7 +147,7 @@ impl rustc_driver::Callbacks for ClippyCallbacks {
                 (previous)(sess, lint_store);
             }
 
-            let conf = clippy_lints::Conf::read(sess, &conf_path);
+            let conf = clippy_config::Conf::read(sess, &conf_path);
             clippy_lints::register_plugins(lint_store, sess, conf);
             clippy_lints::register_pre_expansion_lints(lint_store, conf);
             clippy_lints::register_renamed(lint_store);
diff --git a/tests/compile-test.rs b/tests/compile-test.rs
index 1494c7d3179..3b7c974b65b 100644
--- a/tests/compile-test.rs
+++ b/tests/compile-test.rs
@@ -30,6 +30,7 @@ mod test_utils;
 
 /// All crates used in UI tests are listed here
 static TEST_DEPENDENCIES: &[&str] = &[
+    "clippy_config",
     "clippy_lints",
     "clippy_utils",
     "futures",
diff --git a/tests/dogfood.rs b/tests/dogfood.rs
index afde31face1..59c7c53000b 100644
--- a/tests/dogfood.rs
+++ b/tests/dogfood.rs
@@ -56,7 +56,10 @@ fn run_metadata_collection_lint() {
 
     // Run collection as is
     std::env::set_var("ENABLE_METADATA_COLLECTION", "1");
-    run_clippy_for_package("clippy_lints", &["-A", "unfulfilled_lint_expectations"]);
+    assert!(run_clippy_for_package(
+        "clippy_lints",
+        &["-A", "unfulfilled_lint_expectations"]
+    ));
 
     // Check if cargo caching got in the way
     if let Ok(file) = File::open(metadata_output_path) {
@@ -79,9 +82,13 @@ fn run_metadata_collection_lint() {
     .unwrap();
 
     // Running the collection again
-    run_clippy_for_package("clippy_lints", &["-A", "unfulfilled_lint_expectations"]);
+    assert!(run_clippy_for_package(
+        "clippy_lints",
+        &["-A", "unfulfilled_lint_expectations"]
+    ));
 }
 
+#[must_use]
 fn run_clippy_for_package(project: &str, args: &[&str]) -> bool {
     let root_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
 
diff --git a/tests/ui-internal/invalid_msrv_attr_impl.fixed b/tests/ui-internal/invalid_msrv_attr_impl.fixed
index 928596d0809..9b5bf736f13 100644
--- a/tests/ui-internal/invalid_msrv_attr_impl.fixed
+++ b/tests/ui-internal/invalid_msrv_attr_impl.fixed
@@ -8,8 +8,8 @@ extern crate rustc_lint;
 extern crate rustc_middle;
 #[macro_use]
 extern crate rustc_session;
+use clippy_config::msrvs::Msrv;
 use clippy_utils::extract_msrv_attr;
-use clippy_utils::msrvs::Msrv;
 use rustc_hir::Expr;
 use rustc_lint::{EarlyContext, EarlyLintPass, LateContext, LateLintPass};
 
diff --git a/tests/ui-internal/invalid_msrv_attr_impl.rs b/tests/ui-internal/invalid_msrv_attr_impl.rs
index 50b28648ccc..c5bde47e4ce 100644
--- a/tests/ui-internal/invalid_msrv_attr_impl.rs
+++ b/tests/ui-internal/invalid_msrv_attr_impl.rs
@@ -8,8 +8,8 @@ extern crate rustc_lint;
 extern crate rustc_middle;
 #[macro_use]
 extern crate rustc_session;
+use clippy_config::msrvs::Msrv;
 use clippy_utils::extract_msrv_attr;
-use clippy_utils::msrvs::Msrv;
 use rustc_hir::Expr;
 use rustc_lint::{EarlyContext, EarlyLintPass, LateContext, LateLintPass};
 
diff --git a/tests/ui/min_rust_version_invalid_attr.rs b/tests/ui/min_rust_version_invalid_attr.rs
index c8a0d664167..3917bb9e03d 100644
--- a/tests/ui/min_rust_version_invalid_attr.rs
+++ b/tests/ui/min_rust_version_invalid_attr.rs
@@ -11,13 +11,12 @@ fn outer_attr() {}
 mod multiple {
     #![clippy::msrv = "1.40"]
     #![clippy::msrv = "=1.35.0"]
-    //~^ ERROR: `msrv` is defined multiple times
     #![clippy::msrv = "1.10.1"]
-    //~^ ERROR: `msrv` is defined multiple times
+    //~^ ERROR: `clippy::msrv` is defined multiple times
 
     mod foo {
         #![clippy::msrv = "1"]
         #![clippy::msrv = "1.0.0"]
-        //~^ ERROR: `msrv` is defined multiple times
+        //~^ ERROR: `clippy::msrv` is defined multiple times
     }
 }
diff --git a/tests/ui/min_rust_version_invalid_attr.stderr b/tests/ui/min_rust_version_invalid_attr.stderr
index 8d4071e258e..cf8392f0316 100644
--- a/tests/ui/min_rust_version_invalid_attr.stderr
+++ b/tests/ui/min_rust_version_invalid_attr.stderr
@@ -10,20 +10,8 @@ error: `invalid.version` is not a valid Rust version
 LL | #[clippy::msrv = "invalid.version"]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: `msrv` is defined multiple times
-  --> $DIR/min_rust_version_invalid_attr.rs:13:5
-   |
-LL |     #![clippy::msrv = "=1.35.0"]
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-note: first definition found here
-  --> $DIR/min_rust_version_invalid_attr.rs:12:5
-   |
-LL |     #![clippy::msrv = "1.40"]
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: `msrv` is defined multiple times
-  --> $DIR/min_rust_version_invalid_attr.rs:15:5
+error: `clippy::msrv` is defined multiple times
+  --> $DIR/min_rust_version_invalid_attr.rs:14:5
    |
 LL |     #![clippy::msrv = "1.10.1"]
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -34,17 +22,17 @@ note: first definition found here
 LL |     #![clippy::msrv = "1.40"]
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: `msrv` is defined multiple times
-  --> $DIR/min_rust_version_invalid_attr.rs:20:9
+error: `clippy::msrv` is defined multiple times
+  --> $DIR/min_rust_version_invalid_attr.rs:19:9
    |
 LL |         #![clippy::msrv = "1.0.0"]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: first definition found here
-  --> $DIR/min_rust_version_invalid_attr.rs:19:9
+  --> $DIR/min_rust_version_invalid_attr.rs:18:9
    |
 LL |         #![clippy::msrv = "1"]
    |         ^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 5 previous errors
+error: aborting due to 4 previous errors
 
diff --git a/tests/versioncheck.rs b/tests/versioncheck.rs
index c721e9969c9..eba5405e67e 100644
--- a/tests/versioncheck.rs
+++ b/tests/versioncheck.rs
@@ -26,6 +26,7 @@ fn consistent_clippy_crate_versions() {
 
     let paths = [
         "declare_clippy_lint/Cargo.toml",
+        "clippy_config/Cargo.toml",
         "clippy_lints/Cargo.toml",
         "clippy_utils/Cargo.toml",
     ];
-- 
cgit 1.4.1-3-g733a5


From f8790963d9dd9fd4fd22456eef1cbfe2fb8cb12a Mon Sep 17 00:00:00 2001
From: Benoît du Garreau <bdgdlm@outlook.com>
Date: Mon, 23 Oct 2023 14:41:10 +0200
Subject: Add a lint to check needless `Waker` clones

---
 CHANGELOG.md                                 |  1 +
 clippy_lints/src/declared_lints.rs           |  1 +
 clippy_lints/src/methods/mod.rs              | 27 ++++++++++++++++++++++
 clippy_lints/src/methods/waker_clone_wake.rs | 34 ++++++++++++++++++++++++++++
 clippy_utils/src/paths.rs                    |  1 +
 tests/ui/waker_clone_wake.fixed              | 22 ++++++++++++++++++
 tests/ui/waker_clone_wake.rs                 | 22 ++++++++++++++++++
 tests/ui/waker_clone_wake.stderr             | 11 +++++++++
 8 files changed, 119 insertions(+)
 create mode 100644 clippy_lints/src/methods/waker_clone_wake.rs
 create mode 100644 tests/ui/waker_clone_wake.fixed
 create mode 100644 tests/ui/waker_clone_wake.rs
 create mode 100644 tests/ui/waker_clone_wake.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 26c9877dbff..b28075d8eb3 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5589,6 +5589,7 @@ Released 2018-09-13
 [`verbose_bit_mask`]: https://rust-lang.github.io/rust-clippy/master/index.html#verbose_bit_mask
 [`verbose_file_reads`]: https://rust-lang.github.io/rust-clippy/master/index.html#verbose_file_reads
 [`vtable_address_comparisons`]: https://rust-lang.github.io/rust-clippy/master/index.html#vtable_address_comparisons
+[`waker_clone_wake`]: https://rust-lang.github.io/rust-clippy/master/index.html#waker_clone_wake
 [`while_immutable_condition`]: https://rust-lang.github.io/rust-clippy/master/index.html#while_immutable_condition
 [`while_let_loop`]: https://rust-lang.github.io/rust-clippy/master/index.html#while_let_loop
 [`while_let_on_iterator`]: https://rust-lang.github.io/rust-clippy/master/index.html#while_let_on_iterator
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 77438b27f90..9de4a8598b4 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -441,6 +441,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::methods::USELESS_ASREF_INFO,
     crate::methods::VEC_RESIZE_TO_ZERO_INFO,
     crate::methods::VERBOSE_FILE_READS_INFO,
+    crate::methods::WAKER_CLONE_WAKE_INFO,
     crate::methods::WRONG_SELF_CONVENTION_INFO,
     crate::methods::ZST_OFFSET_INFO,
     crate::min_ident_chars::MIN_IDENT_CHARS_INFO,
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index a935aea5075..9c8d2711c3d 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -112,6 +112,7 @@ mod useless_asref;
 mod utils;
 mod vec_resize_to_zero;
 mod verbose_file_reads;
+mod waker_clone_wake;
 mod wrong_self_convention;
 mod zst_offset;
 
@@ -3632,6 +3633,28 @@ declare_clippy_lint! {
     "`as_str` used to call a method on `str` that is also available on `String`"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of `waker.clone().wake()`
+    ///
+    /// ### Why is this bad?
+    /// Cloning the waker is not necessary, `wake_by_ref()` enables the same operation
+    /// without extra cloning/dropping.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// waker.clone().wake();
+    /// ```
+    /// Should be written
+    /// ```rust,ignore
+    /// waker.wake_by_ref();
+    /// ```
+    #[clippy::version = "1.75.0"]
+    pub WAKER_CLONE_WAKE,
+    perf,
+    "cloning a `Waker` only to wake it"
+}
+
 pub struct Methods {
     avoid_breaking_exported_api: bool,
     msrv: Msrv,
@@ -3777,6 +3800,7 @@ impl_lint_pass!(Methods => [
     ITER_OUT_OF_BOUNDS,
     PATH_ENDS_WITH_EXT,
     REDUNDANT_AS_STR,
+    WAKER_CLONE_WAKE,
 ]);
 
 /// Extracts a method call name, args, and `Span` of the method name.
@@ -4365,6 +4389,9 @@ impl Methods {
                     }
                     unnecessary_literal_unwrap::check(cx, expr, recv, name, args);
                 },
+                ("wake", []) => {
+                    waker_clone_wake::check(cx, expr, recv);
+                }
                 ("write", []) => {
                     readonly_write_lock::check(cx, expr, recv);
                 }
diff --git a/clippy_lints/src/methods/waker_clone_wake.rs b/clippy_lints/src/methods/waker_clone_wake.rs
new file mode 100644
index 00000000000..db13266db80
--- /dev/null
+++ b/clippy_lints/src/methods/waker_clone_wake.rs
@@ -0,0 +1,34 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::{match_def_path, paths};
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind};
+use rustc_lint::LateContext;
+use rustc_span::sym;
+
+use super::WAKER_CLONE_WAKE;
+
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, recv: &'tcx Expr<'_>) {
+    let ty = cx.typeck_results().expr_ty(recv);
+
+    if let Some(did) = ty.ty_adt_def()
+        && match_def_path(cx, did.did(), &paths::WAKER)
+        && let ExprKind::MethodCall(func, waker_ref, &[], _) = recv.kind
+        && func.ident.name == sym::clone
+    {
+        let mut applicability = Applicability::MachineApplicable;
+
+        span_lint_and_sugg(
+            cx,
+            WAKER_CLONE_WAKE,
+            expr.span,
+            "cloning a `Waker` only to wake it",
+            "replace with",
+            format!(
+                "{}.wake_by_ref()",
+                snippet_with_applicability(cx, waker_ref.span, "..", &mut applicability)
+            ),
+            applicability,
+        );
+    }
+}
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index 4a20399e364..2cf7e2cde96 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -112,6 +112,7 @@ pub const VEC_RESIZE: [&str; 4] = ["alloc", "vec", "Vec", "resize"];
 pub const INSTANT_NOW: [&str; 4] = ["std", "time", "Instant", "now"];
 pub const VEC_IS_EMPTY: [&str; 4] = ["alloc", "vec", "Vec", "is_empty"];
 pub const VEC_POP: [&str; 4] = ["alloc", "vec", "Vec", "pop"];
+pub const WAKER: [&str; 4] = ["core", "task", "wake", "Waker"];
 pub const OPTION_UNWRAP: [&str; 4] = ["core", "option", "Option", "unwrap"];
 pub const OPTION_EXPECT: [&str; 4] = ["core", "option", "Option", "expect"];
 #[expect(clippy::invalid_paths)] // not sure why it thinks this, it works so
diff --git a/tests/ui/waker_clone_wake.fixed b/tests/ui/waker_clone_wake.fixed
new file mode 100644
index 00000000000..2df52f57d65
--- /dev/null
+++ b/tests/ui/waker_clone_wake.fixed
@@ -0,0 +1,22 @@
+#[derive(Clone)]
+pub struct Custom;
+
+impl Custom {
+    pub fn wake(self) {}
+}
+
+pub fn wake(cx: &mut std::task::Context) {
+    cx.waker().wake_by_ref();
+
+    // We don't do that for now
+    let w = cx.waker().clone();
+    w.wake();
+
+    cx.waker().clone().wake_by_ref();
+}
+
+pub fn no_lint(c: &Custom) {
+    c.clone().wake()
+}
+
+fn main() {}
diff --git a/tests/ui/waker_clone_wake.rs b/tests/ui/waker_clone_wake.rs
new file mode 100644
index 00000000000..4fe354b0ef1
--- /dev/null
+++ b/tests/ui/waker_clone_wake.rs
@@ -0,0 +1,22 @@
+#[derive(Clone)]
+pub struct Custom;
+
+impl Custom {
+    pub fn wake(self) {}
+}
+
+pub fn wake(cx: &mut std::task::Context) {
+    cx.waker().clone().wake();
+
+    // We don't do that for now
+    let w = cx.waker().clone();
+    w.wake();
+
+    cx.waker().clone().wake_by_ref();
+}
+
+pub fn no_lint(c: &Custom) {
+    c.clone().wake()
+}
+
+fn main() {}
diff --git a/tests/ui/waker_clone_wake.stderr b/tests/ui/waker_clone_wake.stderr
new file mode 100644
index 00000000000..426a577e620
--- /dev/null
+++ b/tests/ui/waker_clone_wake.stderr
@@ -0,0 +1,11 @@
+error: cloning a `Waker` only to wake it
+  --> $DIR/waker_clone_wake.rs:9:5
+   |
+LL |     cx.waker().clone().wake();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `cx.waker().wake_by_ref()`
+   |
+   = note: `-D clippy::waker-clone-wake` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::waker_clone_wake)]`
+
+error: aborting due to previous error
+
-- 
cgit 1.4.1-3-g733a5


From 7df1c8aa78db9db06f55e6f99d58194594933d7a Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Thu, 19 Oct 2023 18:12:49 +0000
Subject: Hide config implementation details from public docs

---
 .github/workflows/clippy_bors.yml |   4 ++
 Cargo.toml                        |   2 +-
 book/src/lint_configuration.md    | 139 ++++++++++++++++++--------------------
 clippy_config/Cargo.toml          |   4 +-
 clippy_config/src/conf.rs         |  60 ++++++++++------
 clippy_config/src/lib.rs          |   7 ++
 clippy_config/src/metadata.rs     |  36 +++++-----
 clippy_config/src/msrvs.rs        |   2 +-
 clippy_config/src/types.rs        |  27 +++++++-
 clippy_lints/Cargo.toml           |   2 +-
 clippy_lints/src/lib.rs           |  16 ++---
 clippy_lints/src/utils/mod.rs     |  33 ---------
 tests/dogfood.rs                  |   1 +
 13 files changed, 174 insertions(+), 159 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/.github/workflows/clippy_bors.yml b/.github/workflows/clippy_bors.yml
index 9b96f8dc253..cb2b4d8d621 100644
--- a/.github/workflows/clippy_bors.yml
+++ b/.github/workflows/clippy_bors.yml
@@ -123,6 +123,10 @@ jobs:
       run: cargo test --features deny-warnings,internal
       working-directory: clippy_utils
 
+    - name: Test clippy_config
+      run: cargo test --features deny-warnings
+      working-directory: clippy_config
+
     - name: Test rustc_tools_util
       run: cargo test --features deny-warnings
       working-directory: rustc_tools_util
diff --git a/Cargo.toml b/Cargo.toml
index 28f006957cd..4b6688a76b4 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -55,7 +55,7 @@ rustc_tools_util = "0.3.0"
 [features]
 deny-warnings = ["clippy_lints/deny-warnings"]
 integration = ["tempfile"]
-internal = ["clippy_config/internal", "clippy_lints/internal", "tempfile"]
+internal = ["clippy_lints/internal", "tempfile"]
 
 [package.metadata.rust-analyzer]
 # This package uses #[feature(rustc_private)]
diff --git a/book/src/lint_configuration.md b/book/src/lint_configuration.md
index 6b1a7ba54c6..841a5b6d007 100644
--- a/book/src/lint_configuration.md
+++ b/book/src/lint_configuration.md
@@ -26,7 +26,7 @@ arithmetic-side-effects-allowed = ["SomeType", "AnotherType"]
 A type, say `SomeType`, listed in this configuration has the same behavior of
 `["SomeType" , "*"], ["*", "SomeType"]` in `arithmetic_side_effects_allowed_binary`.
 
-**Default Value:** `{}` (`FxHashSet<String>`)
+**Default Value:** `[]`
 
 ---
 **Affected lints:**
@@ -49,7 +49,7 @@ Pairs are asymmetric, which means that `["SomeType", "AnotherType"]` is not the
 arithmetic-side-effects-allowed-binary = [["SomeType" , "f32"], ["AnotherType", "*"]]
 ```
 
-**Default Value:** `[]` (`Vec<[String; 2]>`)
+**Default Value:** `[]`
 
 ---
 **Affected lints:**
@@ -65,7 +65,7 @@ Suppress checking of the passed type names in unary operations like "negation" (
 arithmetic-side-effects-allowed-unary = ["SomeType", "AnotherType"]
 ```
 
-**Default Value:** `{}` (`FxHashSet<String>`)
+**Default Value:** `[]`
 
 ---
 **Affected lints:**
@@ -75,7 +75,7 @@ arithmetic-side-effects-allowed-unary = ["SomeType", "AnotherType"]
 ## `avoid-breaking-exported-api`
 Suppress lints whenever the suggested change would cause breakage for other crates.
 
-**Default Value:** `true` (`bool`)
+**Default Value:** `true`
 
 ---
 **Affected lints:**
@@ -98,9 +98,7 @@ Suppress lints whenever the suggested change would cause breakage for other crat
 
 
 ## `msrv`
-The minimum rust version that the project supports
-
-**Default Value:** `Msrv { stack: [] }` (`Msrv`)
+The minimum rust version that the project supports. Defaults to the `rust-version` field in `Cargo.toml`
 
 ---
 **Affected lints:**
@@ -157,7 +155,7 @@ The minimum rust version that the project supports
 ## `cognitive-complexity-threshold`
 The maximum cognitive complexity a function can have
 
-**Default Value:** `25` (`u64`)
+**Default Value:** `25`
 
 ---
 **Affected lints:**
@@ -167,7 +165,7 @@ The maximum cognitive complexity a function can have
 ## `excessive-nesting-threshold`
 The maximum amount of nesting a block can reside in
 
-**Default Value:** `0` (`u64`)
+**Default Value:** `0`
 
 ---
 **Affected lints:**
@@ -179,7 +177,7 @@ The list of disallowed names to lint about. NB: `bar` is not here since it has l
 `".."` can be used as part of the list to indicate that the configured values should be appended to the
 default configuration of Clippy. By default, any configuration will replace the default value.
 
-**Default Value:** `["foo", "baz", "quux"]` (`Vec<String>`)
+**Default Value:** `["foo", "baz", "quux"]`
 
 ---
 **Affected lints:**
@@ -189,7 +187,7 @@ default configuration of Clippy. By default, any configuration will replace the
 ## `semicolon-inside-block-ignore-singleline`
 Whether to lint only if it's multiline.
 
-**Default Value:** `false` (`bool`)
+**Default Value:** `false`
 
 ---
 **Affected lints:**
@@ -199,7 +197,7 @@ Whether to lint only if it's multiline.
 ## `semicolon-outside-block-ignore-multiline`
 Whether to lint only if it's singleline.
 
-**Default Value:** `false` (`bool`)
+**Default Value:** `false`
 
 ---
 **Affected lints:**
@@ -213,9 +211,7 @@ default configuration of Clippy. By default, any configuration will replace the
 * `doc-valid-idents = ["ClipPy"]` would replace the default list with `["ClipPy"]`.
 * `doc-valid-idents = ["ClipPy", ".."]` would append `ClipPy` to the default list.
 
-Default list:
-
-**Default Value:** `["KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "DirectX", "ECMAScript", "GPLv2", "GPLv3", "GitHub", "GitLab", "IPv4", "IPv6", "ClojureScript", "CoffeeScript", "JavaScript", "PureScript", "TypeScript", "WebAssembly", "NaN", "NaNs", "OAuth", "GraphQL", "OCaml", "OpenGL", "OpenMP", "OpenSSH", "OpenSSL", "OpenStreetMap", "OpenDNS", "WebGL", "TensorFlow", "TrueType", "iOS", "macOS", "FreeBSD", "TeX", "LaTeX", "BibTeX", "BibLaTeX", "MinGW", "CamelCase"]` (`Vec<String>`)
+**Default Value:** `["KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "DirectX", "ECMAScript", "GPLv2", "GPLv3", "GitHub", "GitLab", "IPv4", "IPv6", "ClojureScript", "CoffeeScript", "JavaScript", "PureScript", "TypeScript", "WebAssembly", "NaN", "NaNs", "OAuth", "GraphQL", "OCaml", "OpenGL", "OpenMP", "OpenSSH", "OpenSSL", "OpenStreetMap", "OpenDNS", "WebGL", "TensorFlow", "TrueType", "iOS", "macOS", "FreeBSD", "TeX", "LaTeX", "BibTeX", "BibLaTeX", "MinGW", "CamelCase"]`
 
 ---
 **Affected lints:**
@@ -225,7 +221,7 @@ Default list:
 ## `too-many-arguments-threshold`
 The maximum number of argument a function or method can have
 
-**Default Value:** `7` (`u64`)
+**Default Value:** `7`
 
 ---
 **Affected lints:**
@@ -235,7 +231,7 @@ The maximum number of argument a function or method can have
 ## `type-complexity-threshold`
 The maximum complexity a type can have
 
-**Default Value:** `250` (`u64`)
+**Default Value:** `250`
 
 ---
 **Affected lints:**
@@ -245,7 +241,7 @@ The maximum complexity a type can have
 ## `single-char-binding-names-threshold`
 The maximum number of single char bindings a scope may have
 
-**Default Value:** `4` (`u64`)
+**Default Value:** `4`
 
 ---
 **Affected lints:**
@@ -255,7 +251,7 @@ The maximum number of single char bindings a scope may have
 ## `too-large-for-stack`
 The maximum size of objects (in bytes) that will be linted. Larger objects are ok on the heap
 
-**Default Value:** `200` (`u64`)
+**Default Value:** `200`
 
 ---
 **Affected lints:**
@@ -266,7 +262,7 @@ The maximum size of objects (in bytes) that will be linted. Larger objects are o
 ## `enum-variant-name-threshold`
 The minimum number of enum variants for the lints about variant names to trigger
 
-**Default Value:** `3` (`u64`)
+**Default Value:** `3`
 
 ---
 **Affected lints:**
@@ -276,7 +272,7 @@ The minimum number of enum variants for the lints about variant names to trigger
 ## `struct-field-name-threshold`
 The minimum number of struct fields for the lints about field names to trigger
 
-**Default Value:** `3` (`u64`)
+**Default Value:** `3`
 
 ---
 **Affected lints:**
@@ -286,7 +282,7 @@ The minimum number of struct fields for the lints about field names to trigger
 ## `enum-variant-size-threshold`
 The maximum size of an enum's variant to avoid box suggestion
 
-**Default Value:** `200` (`u64`)
+**Default Value:** `200`
 
 ---
 **Affected lints:**
@@ -296,7 +292,7 @@ The maximum size of an enum's variant to avoid box suggestion
 ## `verbose-bit-mask-threshold`
 The maximum allowed size of a bit mask before suggesting to use 'trailing_zeros'
 
-**Default Value:** `1` (`u64`)
+**Default Value:** `1`
 
 ---
 **Affected lints:**
@@ -306,7 +302,7 @@ The maximum allowed size of a bit mask before suggesting to use 'trailing_zeros'
 ## `literal-representation-threshold`
 The lower bound for linting decimal literals
 
-**Default Value:** `16384` (`u64`)
+**Default Value:** `16384`
 
 ---
 **Affected lints:**
@@ -314,9 +310,8 @@ The lower bound for linting decimal literals
 
 
 ## `trivial-copy-size-limit`
-The maximum size (in bytes) to consider a `Copy` type for passing by value instead of by reference.
-
-**Default Value:** `None` (`Option<u64>`)
+The maximum size (in bytes) to consider a `Copy` type for passing by value instead of by
+reference. By default there is no limit
 
 ---
 **Affected lints:**
@@ -326,7 +321,7 @@ The maximum size (in bytes) to consider a `Copy` type for passing by value inste
 ## `pass-by-value-size-limit`
 The minimum size (in bytes) to consider a type for passing by reference instead of by value.
 
-**Default Value:** `256` (`u64`)
+**Default Value:** `256`
 
 ---
 **Affected lints:**
@@ -336,7 +331,7 @@ The minimum size (in bytes) to consider a type for passing by reference instead
 ## `too-many-lines-threshold`
 The maximum number of lines a function or method can have
 
-**Default Value:** `100` (`u64`)
+**Default Value:** `100`
 
 ---
 **Affected lints:**
@@ -346,7 +341,7 @@ The maximum number of lines a function or method can have
 ## `array-size-threshold`
 The maximum allowed size for arrays on the stack
 
-**Default Value:** `512000` (`u64`)
+**Default Value:** `512000`
 
 ---
 **Affected lints:**
@@ -357,7 +352,7 @@ The maximum allowed size for arrays on the stack
 ## `stack-size-threshold`
 The maximum allowed stack size for functions in bytes
 
-**Default Value:** `512000` (`u64`)
+**Default Value:** `512000`
 
 ---
 **Affected lints:**
@@ -367,7 +362,7 @@ The maximum allowed stack size for functions in bytes
 ## `vec-box-size-threshold`
 The size of the boxed type in bytes, where boxing in a `Vec` is allowed
 
-**Default Value:** `4096` (`u64`)
+**Default Value:** `4096`
 
 ---
 **Affected lints:**
@@ -377,7 +372,7 @@ The size of the boxed type in bytes, where boxing in a `Vec` is allowed
 ## `max-trait-bounds`
 The maximum number of bounds a trait can have to be linted
 
-**Default Value:** `3` (`u64`)
+**Default Value:** `3`
 
 ---
 **Affected lints:**
@@ -387,7 +382,7 @@ The maximum number of bounds a trait can have to be linted
 ## `max-struct-bools`
 The maximum number of bool fields a struct can have
 
-**Default Value:** `3` (`u64`)
+**Default Value:** `3`
 
 ---
 **Affected lints:**
@@ -397,7 +392,7 @@ The maximum number of bool fields a struct can have
 ## `max-fn-params-bools`
 The maximum number of bool parameters a function can have
 
-**Default Value:** `3` (`u64`)
+**Default Value:** `3`
 
 ---
 **Affected lints:**
@@ -407,7 +402,7 @@ The maximum number of bool parameters a function can have
 ## `warn-on-all-wildcard-imports`
 Whether to allow certain wildcard imports (prelude, super in tests).
 
-**Default Value:** `false` (`bool`)
+**Default Value:** `false`
 
 ---
 **Affected lints:**
@@ -417,7 +412,7 @@ Whether to allow certain wildcard imports (prelude, super in tests).
 ## `disallowed-macros`
 The list of disallowed macros, written as fully qualified paths.
 
-**Default Value:** `[]` (`Vec<DisallowedPath>`)
+**Default Value:** `[]`
 
 ---
 **Affected lints:**
@@ -427,7 +422,7 @@ The list of disallowed macros, written as fully qualified paths.
 ## `disallowed-methods`
 The list of disallowed methods, written as fully qualified paths.
 
-**Default Value:** `[]` (`Vec<DisallowedPath>`)
+**Default Value:** `[]`
 
 ---
 **Affected lints:**
@@ -437,7 +432,7 @@ The list of disallowed methods, written as fully qualified paths.
 ## `disallowed-types`
 The list of disallowed types, written as fully qualified paths.
 
-**Default Value:** `[]` (`Vec<DisallowedPath>`)
+**Default Value:** `[]`
 
 ---
 **Affected lints:**
@@ -447,7 +442,7 @@ The list of disallowed types, written as fully qualified paths.
 ## `unreadable-literal-lint-fractions`
 Should the fraction of a decimal be linted to include separators.
 
-**Default Value:** `true` (`bool`)
+**Default Value:** `true`
 
 ---
 **Affected lints:**
@@ -457,7 +452,7 @@ Should the fraction of a decimal be linted to include separators.
 ## `upper-case-acronyms-aggressive`
 Enables verbose mode. Triggers if there is more than one uppercase char next to each other
 
-**Default Value:** `false` (`bool`)
+**Default Value:** `false`
 
 ---
 **Affected lints:**
@@ -468,7 +463,7 @@ Enables verbose mode. Triggers if there is more than one uppercase char next to
 Whether the matches should be considered by the lint, and whether there should
 be filtering for common types.
 
-**Default Value:** `WellKnownTypes` (`MatchLintBehaviour`)
+**Default Value:** `"WellKnownTypes"`
 
 ---
 **Affected lints:**
@@ -478,11 +473,11 @@ be filtering for common types.
 ## `cargo-ignore-publish`
 For internal testing only, ignores the current `publish` settings in the Cargo manifest.
 
-**Default Value:** `false` (`bool`)
+**Default Value:** `false`
 
 ---
 **Affected lints:**
-* [`_cargo_common_metadata`](https://rust-lang.github.io/rust-clippy/master/index.html#_cargo_common_metadata)
+* [`cargo_common_metadata`](https://rust-lang.github.io/rust-clippy/master/index.html#cargo_common_metadata)
 
 
 ## `standard-macro-braces`
@@ -492,7 +487,7 @@ A `MacroMatcher` can be added like so `{ name = "macro_name", brace = "(" }`. If
 could be used with a full path two `MacroMatcher`s have to be added one with the full path
 `crate_name::macro_name` and one with just the macro name.
 
-**Default Value:** `[]` (`Vec<MacroMatcher>`)
+**Default Value:** `[]`
 
 ---
 **Affected lints:**
@@ -502,7 +497,7 @@ could be used with a full path two `MacroMatcher`s have to be added one with the
 ## `enforced-import-renames`
 The list of imports to always rename, a fully qualified path followed by the rename.
 
-**Default Value:** `[]` (`Vec<Rename>`)
+**Default Value:** `[]`
 
 ---
 **Affected lints:**
@@ -512,7 +507,7 @@ The list of imports to always rename, a fully qualified path followed by the ren
 ## `allowed-scripts`
 The list of unicode scripts allowed to be used in the scope.
 
-**Default Value:** `["Latin"]` (`Vec<String>`)
+**Default Value:** `["Latin"]`
 
 ---
 **Affected lints:**
@@ -522,7 +517,7 @@ The list of unicode scripts allowed to be used in the scope.
 ## `enable-raw-pointer-heuristic-for-send`
 Whether to apply the raw pointer heuristic to determine if a type is `Send`.
 
-**Default Value:** `true` (`bool`)
+**Default Value:** `true`
 
 ---
 **Affected lints:**
@@ -534,7 +529,7 @@ When Clippy suggests using a slice pattern, this is the maximum number of elemen
 the slice pattern that is suggested. If more elements are necessary, the lint is suppressed.
 For example, `[_, _, _, e, ..]` is a slice pattern with 4 elements.
 
-**Default Value:** `3` (`u64`)
+**Default Value:** `3`
 
 ---
 **Affected lints:**
@@ -544,7 +539,7 @@ For example, `[_, _, _, e, ..]` is a slice pattern with 4 elements.
 ## `await-holding-invalid-types`
 
 
-**Default Value:** `[]` (`Vec<DisallowedPath>`)
+**Default Value:** `[]`
 
 ---
 **Affected lints:**
@@ -554,7 +549,7 @@ For example, `[_, _, _, e, ..]` is a slice pattern with 4 elements.
 ## `max-include-file-size`
 The maximum size of a file included via `include_bytes!()` or `include_str!()`, in bytes
 
-**Default Value:** `1000000` (`u64`)
+**Default Value:** `1000000`
 
 ---
 **Affected lints:**
@@ -564,7 +559,7 @@ The maximum size of a file included via `include_bytes!()` or `include_str!()`,
 ## `allow-expect-in-tests`
 Whether `expect` should be allowed in test functions or `#[cfg(test)]`
 
-**Default Value:** `false` (`bool`)
+**Default Value:** `false`
 
 ---
 **Affected lints:**
@@ -574,7 +569,7 @@ Whether `expect` should be allowed in test functions or `#[cfg(test)]`
 ## `allow-unwrap-in-tests`
 Whether `unwrap` should be allowed in test functions or `#[cfg(test)]`
 
-**Default Value:** `false` (`bool`)
+**Default Value:** `false`
 
 ---
 **Affected lints:**
@@ -584,7 +579,7 @@ Whether `unwrap` should be allowed in test functions or `#[cfg(test)]`
 ## `allow-dbg-in-tests`
 Whether `dbg!` should be allowed in test functions or `#[cfg(test)]`
 
-**Default Value:** `false` (`bool`)
+**Default Value:** `false`
 
 ---
 **Affected lints:**
@@ -594,7 +589,7 @@ Whether `dbg!` should be allowed in test functions or `#[cfg(test)]`
 ## `allow-print-in-tests`
 Whether print macros (ex. `println!`) should be allowed in test functions or `#[cfg(test)]`
 
-**Default Value:** `false` (`bool`)
+**Default Value:** `false`
 
 ---
 **Affected lints:**
@@ -605,7 +600,7 @@ Whether print macros (ex. `println!`) should be allowed in test functions or `#[
 ## `large-error-threshold`
 The maximum size of the `Err`-variant in a `Result` returned from a function
 
-**Default Value:** `128` (`u64`)
+**Default Value:** `128`
 
 ---
 **Affected lints:**
@@ -616,7 +611,7 @@ The maximum size of the `Err`-variant in a `Result` returned from a function
 A list of paths to types that should be treated like `Arc`, i.e. ignored but
 for the generic parameters for determining interior mutability
 
-**Default Value:** `["bytes::Bytes"]` (`Vec<String>`)
+**Default Value:** `["bytes::Bytes"]`
 
 ---
 **Affected lints:**
@@ -627,7 +622,7 @@ for the generic parameters for determining interior mutability
 ## `allow-mixed-uninlined-format-args`
 Whether to allow mixed uninlined format args, e.g. `format!("{} {}", a, foo.bar)`
 
-**Default Value:** `true` (`bool`)
+**Default Value:** `true`
 
 ---
 **Affected lints:**
@@ -641,7 +636,7 @@ suggested counterparts are unavailable in constant code. This
 configuration will cause restriction lints to trigger even
 if no suggestion can be made.
 
-**Default Value:** `false` (`bool`)
+**Default Value:** `false`
 
 ---
 **Affected lints:**
@@ -652,7 +647,7 @@ if no suggestion can be made.
 Whether to **only** check for missing documentation in items visible within the current
 crate. For example, `pub(crate)` items.
 
-**Default Value:** `false` (`bool`)
+**Default Value:** `false`
 
 ---
 **Affected lints:**
@@ -662,7 +657,7 @@ crate. For example, `pub(crate)` items.
 ## `future-size-threshold`
 The maximum byte size a `Future` can have, before it triggers the `clippy::large_futures` lint
 
-**Default Value:** `16384` (`u64`)
+**Default Value:** `16384`
 
 ---
 **Affected lints:**
@@ -672,7 +667,7 @@ The maximum byte size a `Future` can have, before it triggers the `clippy::large
 ## `unnecessary-box-size`
 The byte size a `T` in `Box<T>` can have, below which it triggers the `clippy::unnecessary_box` lint
 
-**Default Value:** `128` (`u64`)
+**Default Value:** `128`
 
 ---
 **Affected lints:**
@@ -682,7 +677,7 @@ The byte size a `T` in `Box<T>` can have, below which it triggers the `clippy::u
 ## `allow-private-module-inception`
 Whether to allow module inception if it's not public.
 
-**Default Value:** `false` (`bool`)
+**Default Value:** `false`
 
 ---
 **Affected lints:**
@@ -694,7 +689,7 @@ Allowed names below the minimum allowed characters. The value `".."` can be used
 the list to indicate, that the configured values should be appended to the default
 configuration of Clippy. By default, any configuration will replace the default value.
 
-**Default Value:** `{"j", "z", "i", "y", "n", "x", "w"}` (`FxHashSet<String>`)
+**Default Value:** `["j", "z", "i", "y", "n", "x", "w"]`
 
 ---
 **Affected lints:**
@@ -704,7 +699,7 @@ configuration of Clippy. By default, any configuration will replace the default
 ## `min-ident-chars-threshold`
 Minimum chars an ident can have, anything below or equal to this will be linted.
 
-**Default Value:** `1` (`u64`)
+**Default Value:** `1`
 
 ---
 **Affected lints:**
@@ -714,7 +709,7 @@ Minimum chars an ident can have, anything below or equal to this will be linted.
 ## `accept-comment-above-statement`
 Whether to accept a safety comment to be placed above the statement containing the `unsafe` block
 
-**Default Value:** `true` (`bool`)
+**Default Value:** `true`
 
 ---
 **Affected lints:**
@@ -724,7 +719,7 @@ Whether to accept a safety comment to be placed above the statement containing t
 ## `accept-comment-above-attributes`
 Whether to accept a safety comment to be placed above the attributes for the `unsafe` block
 
-**Default Value:** `true` (`bool`)
+**Default Value:** `true`
 
 ---
 **Affected lints:**
@@ -734,7 +729,7 @@ Whether to accept a safety comment to be placed above the attributes for the `un
 ## `allow-one-hash-in-raw-strings`
 Whether to allow `r#""#` when `r""` can be used
 
-**Default Value:** `false` (`bool`)
+**Default Value:** `false`
 
 ---
 **Affected lints:**
@@ -745,7 +740,7 @@ Whether to allow `r#""#` when `r""` can be used
 The maximum number of segments a path can have before being linted, anything above this will
 be linted.
 
-**Default Value:** `2` (`u64`)
+**Default Value:** `2`
 
 ---
 **Affected lints:**
@@ -755,7 +750,7 @@ be linted.
 ## `absolute-paths-allowed-crates`
 Which crates to allow absolute paths from
 
-**Default Value:** `{}` (`FxHashSet<String>`)
+**Default Value:** `[]`
 
 ---
 **Affected lints:**
@@ -765,7 +760,7 @@ Which crates to allow absolute paths from
 ## `allowed-dotfiles`
 Additional dotfiles (files or directories starting with a dot) to allow
 
-**Default Value:** `{}` (`FxHashSet<String>`)
+**Default Value:** `[]`
 
 ---
 **Affected lints:**
@@ -789,7 +784,7 @@ for _ in &*rmvec {}
 for _ in &mut *rmvec {}
 ```
 
-**Default Value:** `false` (`bool`)
+**Default Value:** `false`
 
 ---
 **Affected lints:**
diff --git a/clippy_config/Cargo.toml b/clippy_config/Cargo.toml
index 55f67b585e2..2d41087b51d 100644
--- a/clippy_config/Cargo.toml
+++ b/clippy_config/Cargo.toml
@@ -10,9 +10,11 @@ rustc-semver = "1.1"
 serde = { version = "1.0", features = ["derive"] }
 toml = "0.7.3"
 
+[dev-dependencies]
+walkdir = "2.3"
+
 [features]
 deny-warnings = []
-internal = []
 
 [package.metadata.rust-analyzer]
 # This crate uses #[feature(rustc_private)]
diff --git a/clippy_config/src/conf.rs b/clippy_config/src/conf.rs
index d010dd5f42a..47259776921 100644
--- a/clippy_config/src/conf.rs
+++ b/clippy_config/src/conf.rs
@@ -4,8 +4,8 @@ use crate::ClippyConfiguration;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_session::Session;
 use rustc_span::{BytePos, Pos, SourceFile, Span, SyntaxContext};
-use serde::de::{Deserializer, IgnoredAny, IntoDeserializer, MapAccess, Visitor};
-use serde::Deserialize;
+use serde::de::{IgnoredAny, IntoDeserializer, MapAccess, Visitor};
+use serde::{Deserialize, Deserializer, Serialize};
 use std::fmt::{Debug, Display, Formatter};
 use std::ops::Range;
 use std::path::PathBuf;
@@ -40,10 +40,10 @@ const DEFAULT_ALLOWED_IDENTS_BELOW_MIN_CHARS: &[&str] = &["i", "j", "x", "y", "z
 
 /// Conf with parse errors
 #[derive(Default)]
-pub struct TryConf {
-    pub conf: Conf,
-    pub errors: Vec<ConfError>,
-    pub warnings: Vec<ConfError>,
+struct TryConf {
+    conf: Conf,
+    errors: Vec<ConfError>,
+    warnings: Vec<ConfError>,
 }
 
 impl TryConf {
@@ -57,9 +57,9 @@ impl TryConf {
 }
 
 #[derive(Debug)]
-pub struct ConfError {
-    pub message: String,
-    pub span: Span,
+struct ConfError {
+    message: String,
+    span: Span,
 }
 
 impl ConfError {
@@ -81,10 +81,31 @@ impl ConfError {
     }
 }
 
+macro_rules! wrap_option {
+    () => {
+        None
+    };
+    ($x:literal) => {
+        Some($x)
+    };
+}
+
+macro_rules! default_text {
+    ($value:expr) => {{
+        let mut text = String::new();
+        $value.serialize(toml::ser::ValueSerializer::new(&mut text)).unwrap();
+        text
+    }};
+    ($value:expr, $override:expr) => {
+        $override.to_string()
+    };
+}
+
 macro_rules! define_Conf {
     ($(
         $(#[doc = $doc:literal])+
         $(#[conf_deprecated($dep:literal, $new_conf:ident)])?
+        $(#[default_text = $default_text:expr])?
         ($name:ident: $ty:ty = $default:expr),
     )*) => {
         /// Clippy lint configuration
@@ -160,11 +181,6 @@ macro_rules! define_Conf {
             }
         }
 
-        macro_rules! wrap_option {
-            () => (None);
-            ($x:literal) => (Some($x));
-        }
-
         pub fn get_configuration_metadata() -> Vec<ClippyConfiguration> {
             vec![
                 $(
@@ -173,8 +189,7 @@ macro_rules! define_Conf {
 
                         ClippyConfiguration::new(
                             stringify!($name),
-                            stringify!($ty),
-                            format!("{:?}", defaults::$name()),
+                            default_text!(defaults::$name() $(, $default_text)?),
                             concat!($($doc, '\n',)*),
                             deprecation_reason,
                         )
@@ -236,7 +251,8 @@ define_Conf! {
     (avoid_breaking_exported_api: bool = true),
     /// Lint: MANUAL_SPLIT_ONCE, MANUAL_STR_REPEAT, CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, OPTION_MAP_UNWRAP_OR, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR, IF_THEN_SOME_ELSE_NONE, APPROX_CONSTANT, DEPRECATED_CFG_ATTR, INDEX_REFUTABLE_SLICE, MAP_CLONE, BORROW_AS_PTR, MANUAL_BITS, ERR_EXPECT, CAST_ABS_TO_UNSIGNED, UNINLINED_FORMAT_ARGS, MANUAL_CLAMP, MANUAL_LET_ELSE, UNCHECKED_DURATION_SUBTRACTION, COLLAPSIBLE_STR_REPLACE, SEEK_FROM_CURRENT, SEEK_REWIND, UNNECESSARY_LAZY_EVALUATIONS, TRANSMUTE_PTR_TO_REF, ALMOST_COMPLETE_RANGE, NEEDLESS_BORROW, DERIVABLE_IMPLS, MANUAL_IS_ASCII_CHECK, MANUAL_REM_EUCLID, MANUAL_RETAIN, TYPE_REPETITION_IN_BOUNDS, TUPLE_ARRAY_CONVERSIONS, MANUAL_TRY_FOLD, MANUAL_HASH_ONE.
     ///
-    /// The minimum rust version that the project supports
+    /// The minimum rust version that the project supports. Defaults to the `rust-version` field in `Cargo.toml`
+    #[default_text = ""]
     (msrv: Msrv = Msrv::empty()),
     /// DEPRECATED LINT: BLACKLISTED_NAME.
     ///
@@ -277,8 +293,6 @@ define_Conf! {
     /// default configuration of Clippy. By default, any configuration will replace the default value. For example:
     /// * `doc-valid-idents = ["ClipPy"]` would replace the default list with `["ClipPy"]`.
     /// * `doc-valid-idents = ["ClipPy", ".."]` would append `ClipPy` to the default list.
-    ///
-    /// Default list:
     (doc_valid_idents: Vec<String> = DEFAULT_DOC_VALID_IDENTS.iter().map(ToString::to_string).collect()),
     /// Lint: TOO_MANY_ARGUMENTS.
     ///
@@ -318,7 +332,9 @@ define_Conf! {
     (literal_representation_threshold: u64 = 16384),
     /// Lint: TRIVIALLY_COPY_PASS_BY_REF.
     ///
-    /// The maximum size (in bytes) to consider a `Copy` type for passing by value instead of by reference.
+    /// The maximum size (in bytes) to consider a `Copy` type for passing by value instead of by
+    /// reference. By default there is no limit
+    #[default_text = ""]
     (trivial_copy_size_limit: Option<u64> = None),
     /// Lint: LARGE_TYPES_PASSED_BY_VALUE.
     ///
@@ -381,7 +397,7 @@ define_Conf! {
     /// Whether the matches should be considered by the lint, and whether there should
     /// be filtering for common types.
     (matches_for_let_else: MatchLintBehaviour = MatchLintBehaviour::WellKnownTypes),
-    /// Lint: _CARGO_COMMON_METADATA.
+    /// Lint: CARGO_COMMON_METADATA.
     ///
     /// For internal testing only, ignores the current `publish` settings in the Cargo manifest.
     (cargo_ignore_publish: bool = false),
@@ -742,7 +758,7 @@ mod tests {
 
     #[test]
     fn configs_are_tested() {
-        let mut names: FxHashSet<String> = super::metadata::get_configuration_metadata()
+        let mut names: FxHashSet<String> = crate::get_configuration_metadata()
             .into_iter()
             .map(|meta| meta.name.replace('_', "-"))
             .collect();
diff --git a/clippy_config/src/lib.rs b/clippy_config/src/lib.rs
index 44bbeb17209..f5dcb16d670 100644
--- a/clippy_config/src/lib.rs
+++ b/clippy_config/src/lib.rs
@@ -1,9 +1,16 @@
 #![feature(rustc_private, let_chains)]
 #![cfg_attr(feature = "deny-warnings", deny(warnings))]
 #![warn(rust_2018_idioms, unused_lifetimes)]
+#![allow(
+    clippy::must_use_candidate,
+    clippy::missing_panics_doc,
+    rustc::untranslatable_diagnostic_trivial
+)]
 
 extern crate rustc_ast;
 extern crate rustc_data_structures;
+#[allow(unused_extern_crates)]
+extern crate rustc_driver;
 extern crate rustc_session;
 extern crate rustc_span;
 
diff --git a/clippy_config/src/metadata.rs b/clippy_config/src/metadata.rs
index c40cbd6330f..2451fbc91e8 100644
--- a/clippy_config/src/metadata.rs
+++ b/clippy_config/src/metadata.rs
@@ -1,30 +1,27 @@
-use std::fmt;
+use std::fmt::{self, Write};
 
 #[derive(Debug, Clone, Default)]
 pub struct ClippyConfiguration {
     pub name: String,
-    config_type: &'static str,
     pub default: String,
     pub lints: Vec<String>,
     pub doc: String,
-    #[allow(dead_code)]
     pub deprecation_reason: Option<&'static str>,
 }
 
 impl fmt::Display for ClippyConfiguration {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        writeln!(
-            f,
-            "* `{}`: `{}`(defaults to `{}`): {}",
-            self.name, self.config_type, self.default, self.doc
-        )
+        write!(f, "- `{}`: {}", self.name, self.doc)?;
+        if !self.default.is_empty() {
+            write!(f, " (default: `{}`)", self.default)?;
+        }
+        Ok(())
     }
 }
 
 impl ClippyConfiguration {
     pub fn new(
         name: &'static str,
-        config_type: &'static str,
         default: String,
         doc_comment: &'static str,
         deprecation_reason: Option<&'static str>,
@@ -36,24 +33,29 @@ impl ClippyConfiguration {
             name: to_kebab(name),
             lints,
             doc,
-            config_type,
             default,
             deprecation_reason,
         }
     }
 
-    #[cfg(feature = "internal")]
     pub fn to_markdown_paragraph(&self) -> String {
-        format!(
-            "## `{}`\n{}\n\n**Default Value:** `{}` (`{}`)\n\n---\n**Affected lints:**\n{}\n\n",
+        let mut out = format!(
+            "## `{}`\n{}\n\n",
             self.name,
             self.doc
                 .lines()
                 .map(|line| line.strip_prefix("    ").unwrap_or(line))
                 .collect::<Vec<_>>()
                 .join("\n"),
-            self.default,
-            self.config_type,
+        );
+
+        if !self.default.is_empty() {
+            write!(out, "**Default Value:** `{}`\n\n", self.default).unwrap();
+        }
+
+        write!(
+            out,
+            "---\n**Affected lints:**\n{}\n\n",
             self.lints
                 .iter()
                 .map(|name| name.to_string().split_whitespace().next().unwrap().to_string())
@@ -61,9 +63,11 @@ impl ClippyConfiguration {
                 .collect::<Vec<_>>()
                 .join("\n"),
         )
+        .unwrap();
+
+        out
     }
 
-    #[cfg(feature = "internal")]
     pub fn to_markdown_link(&self) -> String {
         const BOOK_CONFIGS_PATH: &str = "https://doc.rust-lang.org/clippy/lint_configuration.html";
         format!("[`{}`]: {BOOK_CONFIGS_PATH}#{}", self.name, self.name)
diff --git a/clippy_config/src/msrvs.rs b/clippy_config/src/msrvs.rs
index 2cdfa6b42f9..011d54629d4 100644
--- a/clippy_config/src/msrvs.rs
+++ b/clippy_config/src/msrvs.rs
@@ -105,7 +105,7 @@ impl Msrv {
 
         if let Some(msrv_attr) = msrv_attrs.next() {
             if let Some(duplicate) = msrv_attrs.last() {
-                sess.struct_span_err(duplicate.span, format!("`clippy::msrv` is defined multiple times"))
+                sess.struct_span_err(duplicate.span, "`clippy::msrv` is defined multiple times")
                     .span_note(msrv_attr.span, "first definition found here")
                     .emit();
             }
diff --git a/clippy_config/src/types.rs b/clippy_config/src/types.rs
index d179f6baab7..e898221ffa7 100644
--- a/clippy_config/src/types.rs
+++ b/clippy_config/src/types.rs
@@ -1,5 +1,5 @@
 use serde::de::{self, Deserializer, Visitor};
-use serde::Deserialize;
+use serde::{ser, Deserialize, Serialize};
 use std::fmt;
 use std::hash::{Hash, Hasher};
 
@@ -33,7 +33,7 @@ impl DisallowedPath {
     }
 }
 
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Deserialize)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Deserialize, Serialize)]
 pub enum MatchLintBehaviour {
     AllTypes,
     WellKnownTypes,
@@ -117,3 +117,26 @@ impl<'de> Deserialize<'de> for MacroMatcher {
         deser.deserialize_struct("MacroMatcher", FIELDS, MacVisitor)
     }
 }
+
+// these impls are never actually called but are used by the various config options that default to
+// empty lists
+macro_rules! unimplemented_serialize {
+    ($($t:ty,)*) => {
+        $(
+            impl Serialize for $t {
+                fn serialize<S>(&self, _serializer: S) -> Result<S::Ok, S::Error>
+                where
+                    S: ser::Serializer,
+                {
+                    Err(ser::Error::custom("unimplemented"))
+                }
+            }
+        )*
+    }
+}
+
+unimplemented_serialize! {
+    DisallowedPath,
+    Rename,
+    MacroMatcher,
+}
diff --git a/clippy_lints/Cargo.toml b/clippy_lints/Cargo.toml
index 54f67c59761..bb74ef237cf 100644
--- a/clippy_lints/Cargo.toml
+++ b/clippy_lints/Cargo.toml
@@ -35,7 +35,7 @@ walkdir = "2.3"
 [features]
 deny-warnings = ["clippy_utils/deny-warnings"]
 # build clippy with internal lints enabled, off by default
-internal = ["clippy_config/internal", "clippy_utils/internal", "serde_json", "tempfile", "regex"]
+internal = ["clippy_utils/internal", "serde_json", "tempfile", "regex"]
 
 [package.metadata.rust-analyzer]
 # This crate uses #[feature(rustc_private)]
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index a64efbca74f..37053c84e9b 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -357,7 +357,6 @@ mod zero_div_zero;
 mod zero_sized_map_values;
 // end lints modules, do not remove this comment, it’s used in `update_lints`
 
-use crate::utils::FindAll;
 use clippy_config::{get_configuration_metadata, Conf};
 
 /// Register all pre expansion lints
@@ -460,16 +459,13 @@ pub fn explain(name: &str) -> i32 {
     if let Some(info) = declared_lints::LINTS.iter().find(|info| info.lint.name == target) {
         println!("{}", info.explanation);
         // Check if the lint has configuration
-        let mdconf = get_configuration_metadata();
-        if let Some(config_vec_positions) = mdconf
-            .iter()
-            .find_all(|cconf| cconf.lints.contains(&info.lint.name_lower()[8..].to_owned()))
-        {
-            // If it has, print it
+        let mut mdconf = get_configuration_metadata();
+        let name = name.to_ascii_lowercase();
+        mdconf.retain(|cconf| cconf.lints.contains(&name));
+        if !mdconf.is_empty() {
             println!("### Configuration for {}:\n", info.lint.name_lower());
-            for position in config_vec_positions {
-                let conf = &mdconf[position];
-                println!("  - {}: {} (default: {})", conf.name, conf.doc, conf.default);
+            for conf in mdconf {
+                println!("{conf}");
             }
         }
         0
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
index 78096092a0e..13e9ead9a57 100644
--- a/clippy_lints/src/utils/mod.rs
+++ b/clippy_lints/src/utils/mod.rs
@@ -3,36 +3,3 @@ pub mod dump_hir;
 pub mod format_args_collector;
 #[cfg(feature = "internal")]
 pub mod internal_lints;
-
-// ==================================================================
-// Configuration
-// ==================================================================
-
-// Shamelessly stolen from find_all (https://github.com/nectariner/find_all)
-pub trait FindAll: Iterator + Sized {
-    fn find_all<P>(&mut self, predicate: P) -> Option<Vec<usize>>
-    where
-        P: FnMut(&Self::Item) -> bool;
-}
-
-impl<I> FindAll for I
-where
-    I: Iterator,
-{
-    fn find_all<P>(&mut self, mut predicate: P) -> Option<Vec<usize>>
-    where
-        P: FnMut(&Self::Item) -> bool,
-    {
-        let mut occurences = Vec::<usize>::default();
-        for (index, element) in self.enumerate() {
-            if predicate(&element) {
-                occurences.push(index);
-            }
-        }
-
-        match occurences.len() {
-            0 => None,
-            _ => Some(occurences),
-        }
-    }
-}
diff --git a/tests/dogfood.rs b/tests/dogfood.rs
index 59c7c53000b..3f16c180ea7 100644
--- a/tests/dogfood.rs
+++ b/tests/dogfood.rs
@@ -28,6 +28,7 @@ fn dogfood_clippy() {
         "clippy_dev",
         "clippy_lints",
         "clippy_utils",
+        "clippy_config",
         "lintcheck",
         "rustc_tools_util",
     ] {
-- 
cgit 1.4.1-3-g733a5


From 0580080940d3d330512edb4f192a21943523c778 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Wed, 25 Oct 2023 12:19:04 +0000
Subject: Remove the `internal_warn` lint category

---
 clippy_dev/src/main.rs                             |  1 -
 clippy_dev/src/update_lints.rs                     |  2 +-
 clippy_lints/src/declared_lints.rs                 |  6 ++-
 clippy_lints/src/lib.rs                            |  4 +-
 clippy_lints/src/utils/author.rs                   | 12 ++----
 clippy_lints/src/utils/dump_hir.rs                 | 12 ++----
 clippy_lints/src/utils/internal_lints.rs           |  2 +-
 .../utils/internal_lints/clippy_lints_internal.rs  | 49 ----------------------
 .../src/utils/internal_lints/metadata_collector.rs | 14 +++----
 .../internal_lints/unsorted_clippy_utils_paths.rs  | 49 ++++++++++++++++++++++
 declare_clippy_lint/src/lib.rs                     | 26 ++++--------
 11 files changed, 80 insertions(+), 97 deletions(-)
 delete mode 100644 clippy_lints/src/utils/internal_lints/clippy_lints_internal.rs
 create mode 100644 clippy_lints/src/utils/internal_lints/unsorted_clippy_utils_paths.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_dev/src/main.rs b/clippy_dev/src/main.rs
index fca750fafc7..5bd9994e18d 100644
--- a/clippy_dev/src/main.rs
+++ b/clippy_dev/src/main.rs
@@ -199,7 +199,6 @@ fn get_clap_config() -> ArgMatches {
                             "cargo",
                             "nursery",
                             "internal",
-                            "internal_warn",
                         ]),
                     Arg::new("type").long("type").help("What directory the lint belongs in"),
                     Arg::new("msrv")
diff --git a/clippy_dev/src/update_lints.rs b/clippy_dev/src/update_lints.rs
index 842aeed2aa4..6b76a44debf 100644
--- a/clippy_dev/src/update_lints.rs
+++ b/clippy_dev/src/update_lints.rs
@@ -588,7 +588,7 @@ impl Lint {
             .collect()
     }
 
-    /// Returns all internal lints (not `internal_warn` lints)
+    /// Returns all internal lints
     #[must_use]
     fn internal_lints(lints: &[Self]) -> Vec<Self> {
         lints.iter().filter(|l| l.group == "internal").cloned().collect()
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 77438b27f90..558fb658b20 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -6,8 +6,6 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     #[cfg(feature = "internal")]
     crate::utils::internal_lints::almost_standard_lint_formulation::ALMOST_STANDARD_LINT_FORMULATION_INFO,
     #[cfg(feature = "internal")]
-    crate::utils::internal_lints::clippy_lints_internal::CLIPPY_LINTS_INTERNAL_INFO,
-    #[cfg(feature = "internal")]
     crate::utils::internal_lints::collapsible_calls::COLLAPSIBLE_SPAN_LINT_CALLS_INFO,
     #[cfg(feature = "internal")]
     crate::utils::internal_lints::compiler_lint_functions::COMPILER_LINT_FUNCTIONS_INFO,
@@ -30,6 +28,8 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     #[cfg(feature = "internal")]
     crate::utils::internal_lints::lint_without_lint_pass::MISSING_CLIPPY_VERSION_ATTRIBUTE_INFO,
     #[cfg(feature = "internal")]
+    crate::utils::internal_lints::metadata_collector::METADATA_COLLECTOR_INFO,
+    #[cfg(feature = "internal")]
     crate::utils::internal_lints::msrv_attr_impl::MISSING_MSRV_ATTR_IMPL_INFO,
     #[cfg(feature = "internal")]
     crate::utils::internal_lints::outer_expn_data_pass::OUTER_EXPN_EXPN_DATA_INFO,
@@ -37,6 +37,8 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::utils::internal_lints::produce_ice::PRODUCE_ICE_INFO,
     #[cfg(feature = "internal")]
     crate::utils::internal_lints::unnecessary_def_path::UNNECESSARY_DEF_PATH_INFO,
+    #[cfg(feature = "internal")]
+    crate::utils::internal_lints::unsorted_clippy_utils_paths::UNSORTED_CLIPPY_UTILS_PATHS_INFO,
     crate::absolute_paths::ABSOLUTE_PATHS_INFO,
     crate::allow_attributes::ALLOW_ATTRIBUTES_INFO,
     crate::almost_complete_range::ALMOST_COMPLETE_RANGE_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 37053c84e9b..ab978a677c2 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -513,7 +513,9 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     // all the internal lints
     #[cfg(feature = "internal")]
     {
-        store.register_early_pass(|| Box::new(utils::internal_lints::clippy_lints_internal::ClippyLintsInternal));
+        store.register_early_pass(|| {
+            Box::new(utils::internal_lints::unsorted_clippy_utils_paths::UnsortedClippyUtilsPaths)
+        });
         store.register_early_pass(|| Box::new(utils::internal_lints::produce_ice::ProduceIce));
         store.register_late_pass(|_| Box::new(utils::internal_lints::collapsible_calls::CollapsibleCalls));
         store.register_late_pass(|_| {
diff --git a/clippy_lints/src/utils/author.rs b/clippy_lints/src/utils/author.rs
index aecb0c6dbfa..ce93aea2136 100644
--- a/clippy_lints/src/utils/author.rs
+++ b/clippy_lints/src/utils/author.rs
@@ -10,12 +10,12 @@ use rustc_hir::{
     ArrayLen, BindingAnnotation, Closure, ExprKind, FnRetTy, HirId, Lit, PatKind, QPath, StmtKind, TyKind,
 };
 use rustc_lint::{LateContext, LateLintPass, LintContext};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::symbol::{Ident, Symbol};
 use std::cell::Cell;
 use std::fmt::{Display, Formatter, Write as _};
 
-declare_clippy_lint! {
+declare_lint_pass!(
     /// ### What it does
     /// Generates clippy code that detects the offending pattern
     ///
@@ -47,12 +47,8 @@ declare_clippy_lint! {
     ///     // report your lint here
     /// }
     /// ```
-    pub LINT_AUTHOR,
-    internal_warn,
-    "helper for writing lints"
-}
-
-declare_lint_pass!(Author => [LINT_AUTHOR]);
+    Author => []
+);
 
 /// Writes a line of output with indentation added
 macro_rules! out {
diff --git a/clippy_lints/src/utils/dump_hir.rs b/clippy_lints/src/utils/dump_hir.rs
index 092041aecf2..b108951978f 100644
--- a/clippy_lints/src/utils/dump_hir.rs
+++ b/clippy_lints/src/utils/dump_hir.rs
@@ -2,9 +2,9 @@ use clippy_utils::get_attr;
 use hir::TraitItem;
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass, LintContext};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 
-declare_clippy_lint! {
+declare_lint_pass!(
     /// ### What it does
     /// It formats the attached node with `{:#?}` and writes the result to the
     /// standard output. This is intended for debugging.
@@ -19,12 +19,8 @@ declare_clippy_lint! {
     ///     input as u64
     /// }
     /// ```
-    pub DUMP_HIR,
-    internal_warn,
-    "helper to dump info about code"
-}
-
-declare_lint_pass!(DumpHir => [DUMP_HIR]);
+    DumpHir => []
+);
 
 impl<'tcx> LateLintPass<'tcx> for DumpHir {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) {
diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs
index e222a5448c9..ddcb9f27c6c 100644
--- a/clippy_lints/src/utils/internal_lints.rs
+++ b/clippy_lints/src/utils/internal_lints.rs
@@ -1,5 +1,4 @@
 pub mod almost_standard_lint_formulation;
-pub mod clippy_lints_internal;
 pub mod collapsible_calls;
 pub mod compiler_lint_functions;
 pub mod if_chain_style;
@@ -11,3 +10,4 @@ pub mod msrv_attr_impl;
 pub mod outer_expn_data_pass;
 pub mod produce_ice;
 pub mod unnecessary_def_path;
+pub mod unsorted_clippy_utils_paths;
diff --git a/clippy_lints/src/utils/internal_lints/clippy_lints_internal.rs b/clippy_lints/src/utils/internal_lints/clippy_lints_internal.rs
deleted file mode 100644
index da9514dd15e..00000000000
--- a/clippy_lints/src/utils/internal_lints/clippy_lints_internal.rs
+++ /dev/null
@@ -1,49 +0,0 @@
-use clippy_utils::diagnostics::span_lint;
-use rustc_ast::ast::{Crate, ItemKind, ModKind};
-use rustc_lint::{EarlyContext, EarlyLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for various things we like to keep tidy in clippy.
-    ///
-    /// ### Why is this bad?
-    /// We like to pretend we're an example of tidy code.
-    ///
-    /// ### Example
-    /// Wrong ordering of the util::paths constants.
-    pub CLIPPY_LINTS_INTERNAL,
-    internal,
-    "various things that will negatively affect your clippy experience"
-}
-
-declare_lint_pass!(ClippyLintsInternal => [CLIPPY_LINTS_INTERNAL]);
-
-impl EarlyLintPass for ClippyLintsInternal {
-    fn check_crate(&mut self, cx: &EarlyContext<'_>, krate: &Crate) {
-        if let Some(utils) = krate.items.iter().find(|item| item.ident.name.as_str() == "utils") {
-            if let ItemKind::Mod(_, ModKind::Loaded(ref items, ..)) = utils.kind {
-                if let Some(paths) = items.iter().find(|item| item.ident.name.as_str() == "paths") {
-                    if let ItemKind::Mod(_, ModKind::Loaded(ref items, ..)) = paths.kind {
-                        let mut last_name: Option<&str> = None;
-                        for item in items {
-                            let name = item.ident.as_str();
-                            if let Some(last_name) = last_name {
-                                if *last_name > *name {
-                                    span_lint(
-                                        cx,
-                                        CLIPPY_LINTS_INTERNAL,
-                                        item.span,
-                                        "this constant should be before the previous constant due to lexical \
-                                         ordering",
-                                    );
-                                }
-                            }
-                            last_name = Some(name);
-                        }
-                    }
-                }
-            }
-        }
-    }
-}
diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index 01929e1ba10..51abe0c1dc3 100644
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -40,8 +40,6 @@ use std::process::Command;
 const JSON_OUTPUT_FILE: &str = "../util/gh-pages/lints.json";
 /// This is the markdown output file of the lint collector.
 const MARKDOWN_OUTPUT_FILE: &str = "../book/src/lint_configuration.md";
-/// These lints are excluded from the export.
-const BLACK_LISTED_LINTS: &[&str] = &["lint_author", "dump_hir", "internal_metadata_collector"];
 /// These groups will be ignored by the lint group matcher. This is useful for collections like
 /// `clippy::all`
 const IGNORED_LINT_GROUPS: [&str; 1] = ["clippy::all"];
@@ -121,7 +119,7 @@ declare_clippy_lint! {
     /// ### Example output
     /// ```json,ignore
     /// {
-    ///     "id": "internal_metadata_collector",
+    ///     "id": "metadata_collector",
     ///     "id_span": {
     ///         "path": "clippy_lints/src/utils/internal_lints/metadata_collector.rs",
     ///         "line": 1
@@ -131,12 +129,12 @@ declare_clippy_lint! {
     /// }
     /// ```
     #[clippy::version = "1.56.0"]
-    pub INTERNAL_METADATA_COLLECTOR,
-    internal_warn,
+    pub METADATA_COLLECTOR,
+    internal,
     "A busy bee collection metadata about lints"
 }
 
-impl_lint_pass!(MetadataCollector => [INTERNAL_METADATA_COLLECTOR]);
+impl_lint_pass!(MetadataCollector => [METADATA_COLLECTOR]);
 
 #[allow(clippy::module_name_repetitions)]
 #[derive(Debug, Clone)]
@@ -550,7 +548,6 @@ impl<'hir> LateLintPass<'hir> for MetadataCollector {
                 if is_lint_ref_type(cx, ty);
                 // disallow check
                 let lint_name = sym_to_string(item.ident.name).to_ascii_lowercase();
-                if !BLACK_LISTED_LINTS.contains(&lint_name.as_str());
                 // metadata extraction
                 if let Some((group, level)) = get_lint_group_and_level_or_lint(cx, &lint_name, item);
                 if let Some(mut raw_docs) = extract_attr_docs_or_lint(cx, item);
@@ -575,7 +572,6 @@ impl<'hir> LateLintPass<'hir> for MetadataCollector {
                 if is_deprecated_lint(cx, ty);
                 // disallow check
                 let lint_name = sym_to_string(item.ident.name).to_ascii_lowercase();
-                if !BLACK_LISTED_LINTS.contains(&lint_name.as_str());
                 // Metadata the little we can get from a deprecated lint
                 if let Some(raw_docs) = extract_attr_docs_or_lint(cx, item);
                 then {
@@ -831,7 +827,7 @@ fn collect_renames(lints: &mut Vec<LintMetadata>) {
 fn lint_collection_error_item(cx: &LateContext<'_>, item: &Item<'_>, message: &str) {
     span_lint(
         cx,
-        INTERNAL_METADATA_COLLECTOR,
+        METADATA_COLLECTOR,
         item.ident.span,
         &format!("metadata collection error for `{}`: {message}", item.ident.name),
     );
diff --git a/clippy_lints/src/utils/internal_lints/unsorted_clippy_utils_paths.rs b/clippy_lints/src/utils/internal_lints/unsorted_clippy_utils_paths.rs
new file mode 100644
index 00000000000..fd51bca9e5b
--- /dev/null
+++ b/clippy_lints/src/utils/internal_lints/unsorted_clippy_utils_paths.rs
@@ -0,0 +1,49 @@
+use clippy_utils::diagnostics::span_lint;
+use rustc_ast::ast::{Crate, ItemKind, ModKind};
+use rustc_lint::{EarlyContext, EarlyLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks that [`clippy_utils::paths`] is sorted lexically
+    ///
+    /// ### Why is this bad?
+    /// We like to pretend we're an example of tidy code.
+    ///
+    /// ### Example
+    /// Wrong ordering of the util::paths constants.
+    pub UNSORTED_CLIPPY_UTILS_PATHS,
+    internal,
+    "various things that will negatively affect your clippy experience"
+}
+
+declare_lint_pass!(UnsortedClippyUtilsPaths => [UNSORTED_CLIPPY_UTILS_PATHS]);
+
+impl EarlyLintPass for UnsortedClippyUtilsPaths {
+    fn check_crate(&mut self, cx: &EarlyContext<'_>, krate: &Crate) {
+        if let Some(utils) = krate.items.iter().find(|item| item.ident.name.as_str() == "utils") {
+            if let ItemKind::Mod(_, ModKind::Loaded(ref items, ..)) = utils.kind {
+                if let Some(paths) = items.iter().find(|item| item.ident.name.as_str() == "paths") {
+                    if let ItemKind::Mod(_, ModKind::Loaded(ref items, ..)) = paths.kind {
+                        let mut last_name: Option<&str> = None;
+                        for item in items {
+                            let name = item.ident.as_str();
+                            if let Some(last_name) = last_name {
+                                if *last_name > *name {
+                                    span_lint(
+                                        cx,
+                                        UNSORTED_CLIPPY_UTILS_PATHS,
+                                        item.span,
+                                        "this constant should be before the previous constant due to lexical \
+                                         ordering",
+                                    );
+                                }
+                            }
+                            last_name = Some(name);
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/declare_clippy_lint/src/lib.rs b/declare_clippy_lint/src/lib.rs
index ad8f77662ee..dc3037f6669 100644
--- a/declare_clippy_lint/src/lib.rs
+++ b/declare_clippy_lint/src/lib.rs
@@ -136,28 +136,16 @@ pub fn declare_clippy_lint(input: TokenStream) -> TokenStream {
         "{}",
         match category.as_str() {
             "correctness" => "Deny",
-            "style" | "suspicious" | "complexity" | "perf" | "internal_warn" => "Warn",
+            "style" | "suspicious" | "complexity" | "perf" => "Warn",
             "pedantic" | "restriction" | "cargo" | "nursery" | "internal" => "Allow",
             _ => panic!("unknown category {category}"),
         },
     );
 
-    let info = if category == "internal_warn" {
-        None
-    } else {
-        let info_name = format_ident!("{name}_INFO");
+    let info_name = format_ident!("{name}_INFO");
 
-        (&mut category[0..1]).make_ascii_uppercase();
-        let category_variant = format_ident!("{category}");
-
-        Some(quote! {
-            pub(crate) static #info_name: &'static crate::LintInfo = &crate::LintInfo {
-                lint: &#name,
-                category: crate::LintCategory::#category_variant,
-                explanation: #explanation,
-            };
-        })
-    };
+    (&mut category[0..1]).make_ascii_uppercase();
+    let category_variant = format_ident!("{category}");
 
     let output = quote! {
         declare_tool_lint! {
@@ -168,7 +156,11 @@ pub fn declare_clippy_lint(input: TokenStream) -> TokenStream {
             report_in_external_macro: true
         }
 
-        #info
+        pub(crate) static #info_name: &'static crate::LintInfo = &crate::LintInfo {
+            lint: &#name,
+            category: crate::LintCategory::#category_variant,
+            explanation: #explanation,
+        };
     };
 
     TokenStream::from(output)
-- 
cgit 1.4.1-3-g733a5


From ebf6667b571568e88e4b8934013515cb69db74e8 Mon Sep 17 00:00:00 2001
From: Benoît du Garreau <bdgdlm@outlook.com>
Date: Wed, 25 Oct 2023 15:15:29 +0200
Subject: Apply suggestions

---
 clippy_lints/src/methods/waker_clone_wake.rs | 12 +++++-------
 tests/ui/waker_clone_wake.fixed              | 17 ++++++++++++-----
 tests/ui/waker_clone_wake.rs                 | 17 ++++++++++++-----
 tests/ui/waker_clone_wake.stderr             | 10 ++++++++--
 4 files changed, 37 insertions(+), 19 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/waker_clone_wake.rs b/clippy_lints/src/methods/waker_clone_wake.rs
index db13266db80..da66632d55f 100644
--- a/clippy_lints/src/methods/waker_clone_wake.rs
+++ b/clippy_lints/src/methods/waker_clone_wake.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::{match_def_path, paths};
+use clippy_utils::{is_trait_method, match_def_path, paths};
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::LateContext;
@@ -13,10 +13,11 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, recv: &'
 
     if let Some(did) = ty.ty_adt_def()
         && match_def_path(cx, did.did(), &paths::WAKER)
-        && let ExprKind::MethodCall(func, waker_ref, &[], _) = recv.kind
-        && func.ident.name == sym::clone
+        && let ExprKind::MethodCall(_, waker_ref, &[], _) = recv.kind
+        && is_trait_method(cx, recv, sym::Clone)
     {
         let mut applicability = Applicability::MachineApplicable;
+        let snippet = snippet_with_applicability(cx, waker_ref.span.source_callsite(), "..", &mut applicability);
 
         span_lint_and_sugg(
             cx,
@@ -24,10 +25,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, recv: &'
             expr.span,
             "cloning a `Waker` only to wake it",
             "replace with",
-            format!(
-                "{}.wake_by_ref()",
-                snippet_with_applicability(cx, waker_ref.span, "..", &mut applicability)
-            ),
+            format!("{snippet}.wake_by_ref()"),
             applicability,
         );
     }
diff --git a/tests/ui/waker_clone_wake.fixed b/tests/ui/waker_clone_wake.fixed
index 2df52f57d65..9c02b9a90fd 100644
--- a/tests/ui/waker_clone_wake.fixed
+++ b/tests/ui/waker_clone_wake.fixed
@@ -5,18 +5,25 @@ impl Custom {
     pub fn wake(self) {}
 }
 
+macro_rules! mac {
+    ($cx:ident) => {
+        $cx.waker()
+    };
+}
+
 pub fn wake(cx: &mut std::task::Context) {
     cx.waker().wake_by_ref();
 
-    // We don't do that for now
+    mac!(cx).wake_by_ref();
+}
+
+pub fn no_lint(cx: &mut std::task::Context, c: &Custom) {
+    c.clone().wake();
+
     let w = cx.waker().clone();
     w.wake();
 
     cx.waker().clone().wake_by_ref();
 }
 
-pub fn no_lint(c: &Custom) {
-    c.clone().wake()
-}
-
 fn main() {}
diff --git a/tests/ui/waker_clone_wake.rs b/tests/ui/waker_clone_wake.rs
index 4fe354b0ef1..edc3bbd8fc0 100644
--- a/tests/ui/waker_clone_wake.rs
+++ b/tests/ui/waker_clone_wake.rs
@@ -5,18 +5,25 @@ impl Custom {
     pub fn wake(self) {}
 }
 
+macro_rules! mac {
+    ($cx:ident) => {
+        $cx.waker()
+    };
+}
+
 pub fn wake(cx: &mut std::task::Context) {
     cx.waker().clone().wake();
 
-    // We don't do that for now
+    mac!(cx).clone().wake();
+}
+
+pub fn no_lint(cx: &mut std::task::Context, c: &Custom) {
+    c.clone().wake();
+
     let w = cx.waker().clone();
     w.wake();
 
     cx.waker().clone().wake_by_ref();
 }
 
-pub fn no_lint(c: &Custom) {
-    c.clone().wake()
-}
-
 fn main() {}
diff --git a/tests/ui/waker_clone_wake.stderr b/tests/ui/waker_clone_wake.stderr
index 426a577e620..f1abf4d9cb0 100644
--- a/tests/ui/waker_clone_wake.stderr
+++ b/tests/ui/waker_clone_wake.stderr
@@ -1,5 +1,5 @@
 error: cloning a `Waker` only to wake it
-  --> $DIR/waker_clone_wake.rs:9:5
+  --> $DIR/waker_clone_wake.rs:15:5
    |
 LL |     cx.waker().clone().wake();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `cx.waker().wake_by_ref()`
@@ -7,5 +7,11 @@ LL |     cx.waker().clone().wake();
    = note: `-D clippy::waker-clone-wake` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::waker_clone_wake)]`
 
-error: aborting due to previous error
+error: cloning a `Waker` only to wake it
+  --> $DIR/waker_clone_wake.rs:17:5
+   |
+LL |     mac!(cx).clone().wake();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `mac!(cx).wake_by_ref()`
+
+error: aborting due to 2 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 45f94c7598b5720c1f2d3fdd7485e53e6a651930 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Thu, 26 Oct 2023 01:07:20 +0200
Subject: mention restriction to exported types as a limitation

---
 clippy_lints/src/iter_without_into_iter.rs | 11 +++++++++++
 1 file changed, 11 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/iter_without_into_iter.rs b/clippy_lints/src/iter_without_into_iter.rs
index 1add49a2542..e3cb29da5e1 100644
--- a/clippy_lints/src/iter_without_into_iter.rs
+++ b/clippy_lints/src/iter_without_into_iter.rs
@@ -19,6 +19,11 @@ declare_clippy_lint! {
     /// It's not bad, but having them is idiomatic and allows the type to be used in for loops directly
     /// (`for val in &iter {}`), without having to first call `iter()` or `iter_mut()`.
     ///
+    /// ### Limitations
+    /// This lint is restricted to exported types only, because it is aimed at guiding towards an
+    /// idiomatic, _public_ API.
+    /// Implementing the `IntoIterator` trait when it is not needed or used anywhere doesn't help or improve the code.
+    ///
     /// ### Example
     /// ```rust
     /// struct MySlice<'a>(&'a [u8]);
@@ -61,6 +66,12 @@ declare_clippy_lint! {
     /// by just calling `.iter()`, instead of the more awkward `<&Type>::into_iter` or `(&val).into_iter()` syntax
     /// in case of ambiguity with another `IntoIterator` impl.
     ///
+    /// ### Limitations
+    /// This lint is restricted to exported types only, because it is aimed at guiding towards an
+    /// idiomatic, _public_ API.
+    /// Adding an `iter` or `iter_mut` for private types when it is not needed or used doesn't improve code,
+    /// and in fact, is linted against by the `dead_code` lint.
+    ///
     /// ### Example
     /// ```rust
     /// struct MySlice<'a>(&'a [u8]);
-- 
cgit 1.4.1-3-g733a5


From 1ed100144028cd08dcdc3c17475ab5cfce8629d1 Mon Sep 17 00:00:00 2001
From: Andre Bogus <bogusandre@gmail.com>
Date: Fri, 27 Oct 2023 16:28:10 +0200
Subject: Fix missing parenthesis in suboptimal floating point help

---
 clippy_lints/src/floating_point_arithmetic.rs | 22 +++++-----------------
 clippy_utils/src/sugg.rs                      |  5 ++++-
 tests/ui/floating_point_mul_add.fixed         |  3 +++
 tests/ui/floating_point_mul_add.rs            |  3 +++
 tests/ui/floating_point_mul_add.stderr        |  8 +++++++-
 5 files changed, 22 insertions(+), 19 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/floating_point_arithmetic.rs b/clippy_lints/src/floating_point_arithmetic.rs
index 3d51dfc3497..09a9d9924de 100644
--- a/clippy_lints/src/floating_point_arithmetic.rs
+++ b/clippy_lints/src/floating_point_arithmetic.rs
@@ -323,9 +323,9 @@ fn check_powi(cx: &LateContext<'_>, expr: &Expr<'_>, receiver: &Expr<'_>, args:
                     let maybe_neg_sugg = |expr, hir_id| {
                         let sugg = Sugg::hir(cx, expr, "..");
                         if matches!(op, BinOpKind::Sub) && hir_id == rhs.hir_id {
-                            format!("-{}", sugg.maybe_par())
+                            -sugg
                         } else {
-                            sugg.to_string()
+                            sugg
                         }
                     };
 
@@ -470,25 +470,13 @@ fn check_mul_add(cx: &LateContext<'_>, expr: &Expr<'_>) {
 
         let maybe_neg_sugg = |expr| {
             let sugg = Sugg::hir(cx, expr, "..");
-            if let BinOpKind::Sub = op {
-                format!("-{sugg}")
-            } else {
-                sugg.to_string()
-            }
+            if let BinOpKind::Sub = op { -sugg } else { sugg }
         };
 
         let (recv, arg1, arg2) = if let Some((inner_lhs, inner_rhs)) = is_float_mul_expr(cx, lhs) {
-            (
-                inner_lhs,
-                Sugg::hir(cx, inner_rhs, "..").to_string(),
-                maybe_neg_sugg(rhs),
-            )
+            (inner_lhs, Sugg::hir(cx, inner_rhs, ".."), maybe_neg_sugg(rhs))
         } else if let Some((inner_lhs, inner_rhs)) = is_float_mul_expr(cx, rhs) {
-            (
-                inner_lhs,
-                maybe_neg_sugg(inner_rhs),
-                Sugg::hir(cx, lhs, "..").to_string(),
-            )
+            (inner_lhs, maybe_neg_sugg(inner_rhs), Sugg::hir(cx, lhs, ".."))
         } else {
             return;
         };
diff --git a/clippy_utils/src/sugg.rs b/clippy_utils/src/sugg.rs
index ae8ee371ffa..f6b9fb3979b 100644
--- a/clippy_utils/src/sugg.rs
+++ b/clippy_utils/src/sugg.rs
@@ -465,7 +465,10 @@ forward_binop_impls_to_ref!(impl Sub, sub for Sugg<'_>, type Output = Sugg<'stat
 impl Neg for Sugg<'_> {
     type Output = Sugg<'static>;
     fn neg(self) -> Sugg<'static> {
-        make_unop("-", self)
+        match &self {
+            Self::BinOp(AssocOp::As, ..) => Sugg::MaybeParen(format!("-({self})").into()),
+            _ => make_unop("-", self),
+        }
     }
 }
 
diff --git a/tests/ui/floating_point_mul_add.fixed b/tests/ui/floating_point_mul_add.fixed
index c23f4d7c4d3..a4d6d49e57c 100644
--- a/tests/ui/floating_point_mul_add.fixed
+++ b/tests/ui/floating_point_mul_add.fixed
@@ -33,6 +33,9 @@ fn main() {
 
     let _ = a.mul_add(a, b).sqrt();
 
+    let u = 1usize;
+    let _ = b.mul_add(-(u as f64), a);
+
     // Cases where the lint shouldn't be applied
     let _ = (a * a + b * b).sqrt();
 }
diff --git a/tests/ui/floating_point_mul_add.rs b/tests/ui/floating_point_mul_add.rs
index 431badc8db4..262a20f0f55 100644
--- a/tests/ui/floating_point_mul_add.rs
+++ b/tests/ui/floating_point_mul_add.rs
@@ -33,6 +33,9 @@ fn main() {
 
     let _ = (a * a + b).sqrt();
 
+    let u = 1usize;
+    let _ = a - (b * u as f64);
+
     // Cases where the lint shouldn't be applied
     let _ = (a * a + b * b).sqrt();
 }
diff --git a/tests/ui/floating_point_mul_add.stderr b/tests/ui/floating_point_mul_add.stderr
index 81b7126db54..38dbefbe14c 100644
--- a/tests/ui/floating_point_mul_add.stderr
+++ b/tests/ui/floating_point_mul_add.stderr
@@ -73,5 +73,11 @@ error: multiply and add expressions can be calculated more efficiently and accur
 LL |     let _ = (a * a + b).sqrt();
    |             ^^^^^^^^^^^ help: consider using: `a.mul_add(a, b)`
 
-error: aborting due to 12 previous errors
+error: multiply and add expressions can be calculated more efficiently and accurately
+  --> $DIR/floating_point_mul_add.rs:37:13
+   |
+LL |     let _ = a - (b * u as f64);
+   |             ^^^^^^^^^^^^^^^^^^ help: consider using: `b.mul_add(-(u as f64), a)`
+
+error: aborting due to 13 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 58fe45102de21fb0806f7f58e85ce1f4ec7e490e Mon Sep 17 00:00:00 2001
From: Wilfred Hughes <wilfred@meta.com>
Date: Fri, 27 Oct 2023 10:22:41 -0700
Subject: Expand docs on clippy::todo

https://doc.rust-lang.org/nightly/core/macro.todo.html
describes that `todo!()` is intended for explicitly unfinished
code. Explain this, and mention `unimplemented!()` as an alternative.

Whilst we're here, improve the punctuation on the other lints.
---
 clippy_lints/src/panic_unimplemented.rs | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/panic_unimplemented.rs b/clippy_lints/src/panic_unimplemented.rs
index a72aefe91c1..f4f1f6ddb3f 100644
--- a/clippy_lints/src/panic_unimplemented.rs
+++ b/clippy_lints/src/panic_unimplemented.rs
@@ -9,7 +9,7 @@ declare_clippy_lint! {
     /// Checks for usage of `panic!`.
     ///
     /// ### Why is this bad?
-    /// `panic!` will stop the execution of the executable
+    /// `panic!` will stop the execution of the executable.
     ///
     /// ### Example
     /// ```no_run
@@ -26,7 +26,7 @@ declare_clippy_lint! {
     /// Checks for usage of `unimplemented!`.
     ///
     /// ### Why is this bad?
-    /// This macro should not be present in production code
+    /// This macro should not be present in production code.
     ///
     /// ### Example
     /// ```no_run
@@ -43,12 +43,17 @@ declare_clippy_lint! {
     /// Checks for usage of `todo!`.
     ///
     /// ### Why is this bad?
-    /// This macro should not be present in production code
+    /// The `todo!` macro is often used for unfinished code, and it causes
+    /// code to panic. It should not be present in production code.
     ///
     /// ### Example
     /// ```no_run
     /// todo!();
     /// ```
+    /// Finish the implementation, or consider marking it as explicitly unimplemented.
+    /// ```no_run
+    /// unimplemented!();
+    /// ```
     #[clippy::version = "1.40.0"]
     pub TODO,
     restriction,
@@ -60,7 +65,7 @@ declare_clippy_lint! {
     /// Checks for usage of `unreachable!`.
     ///
     /// ### Why is this bad?
-    /// This macro can cause code to panic
+    /// This macro can cause code to panic.
     ///
     /// ### Example
     /// ```no_run
-- 
cgit 1.4.1-3-g733a5


From 9a10d32c9a2c2c7ff26a56c399d3b1f39138d40d Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Sat, 28 Oct 2023 02:29:33 +0200
Subject: reword limitation section

---
 clippy_lints/src/iter_without_into_iter.rs | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/iter_without_into_iter.rs b/clippy_lints/src/iter_without_into_iter.rs
index e3cb29da5e1..eb5f1747d83 100644
--- a/clippy_lints/src/iter_without_into_iter.rs
+++ b/clippy_lints/src/iter_without_into_iter.rs
@@ -20,9 +20,9 @@ declare_clippy_lint! {
     /// (`for val in &iter {}`), without having to first call `iter()` or `iter_mut()`.
     ///
     /// ### Limitations
-    /// This lint is restricted to exported types only, because it is aimed at guiding towards an
-    /// idiomatic, _public_ API.
-    /// Implementing the `IntoIterator` trait when it is not needed or used anywhere doesn't help or improve the code.
+    /// This lint focuses on providing an idiomatic API. Therefore, it will only
+    /// lint on types which are accessible outside of the crate. For internal types,
+    /// the `IntoIterator` trait can be implemented on demand if it is actually needed.
     ///
     /// ### Example
     /// ```rust
@@ -67,10 +67,12 @@ declare_clippy_lint! {
     /// in case of ambiguity with another `IntoIterator` impl.
     ///
     /// ### Limitations
-    /// This lint is restricted to exported types only, because it is aimed at guiding towards an
-    /// idiomatic, _public_ API.
-    /// Adding an `iter` or `iter_mut` for private types when it is not needed or used doesn't improve code,
-    /// and in fact, is linted against by the `dead_code` lint.
+    /// This lint focuses on providing an idiomatic API. Therefore, it will only
+    /// lint on types which are accessible outside of the crate. For internal types,
+    /// these methods can be added on demand if they are actually needed. Otherwise,
+    /// it would trigger the [`dead_code`] lint for the unused method.
+    ///
+    /// [`dead_code`]: https://doc.rust-lang.org/rustc/lints/listing/warn-by-default.html#dead-code
     ///
     /// ### Example
     /// ```rust
-- 
cgit 1.4.1-3-g733a5


From 2fea83b8c971ea75e704fc4814db988997911cf8 Mon Sep 17 00:00:00 2001
From: dswij <dswijj@gmail.com>
Date: Sun, 29 Oct 2023 03:40:45 +0800
Subject: move `read_zero_byte_vec` to nursery

---
 clippy_lints/src/read_zero_byte_vec.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/read_zero_byte_vec.rs b/clippy_lints/src/read_zero_byte_vec.rs
index 2bf90815caa..c0e066760b7 100644
--- a/clippy_lints/src/read_zero_byte_vec.rs
+++ b/clippy_lints/src/read_zero_byte_vec.rs
@@ -42,7 +42,7 @@ declare_clippy_lint! {
     /// ```
     #[clippy::version = "1.63.0"]
     pub READ_ZERO_BYTE_VEC,
-    correctness,
+    nursery,
     "checks for reads into a zero-length `Vec`"
 }
 declare_lint_pass!(ReadZeroByteVec => [READ_ZERO_BYTE_VEC]);
-- 
cgit 1.4.1-3-g733a5


From 2030c58b81bffab3277913af99472055886e319e Mon Sep 17 00:00:00 2001
From: cui fliter <imcusg@gmail.com>
Date: Sun, 29 Oct 2023 11:59:40 +0800
Subject: Fix some typos

Signed-off-by: cui fliter <imcusg@gmail.com>
---
 clippy_lints/src/attrs.rs                                           | 2 +-
 clippy_lints/src/from_over_into.rs                                  | 6 +++---
 clippy_lints/src/matches/single_match.rs                            | 2 +-
 clippy_lints/src/reserve_after_initialization.rs                    | 2 +-
 clippy_lints/src/unnecessary_map_on_constructor.rs                  | 2 +-
 .../src/utils/internal_lints/almost_standard_lint_formulation.rs    | 2 +-
 6 files changed, 8 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs
index c720eba11b1..7a5e3d3f30f 100644
--- a/clippy_lints/src/attrs.rs
+++ b/clippy_lints/src/attrs.rs
@@ -409,7 +409,7 @@ declare_clippy_lint! {
     ///
     /// ### Why is this bad?
     /// Misspelling `feature` as `features` can be sometimes hard to spot. It
-    /// may cause conditional compilation not work quitely.
+    /// may cause conditional compilation not work quietly.
     ///
     /// ### Example
     /// ```no_run
diff --git a/clippy_lints/src/from_over_into.rs b/clippy_lints/src/from_over_into.rs
index 948d709ce3f..4ccdba910eb 100644
--- a/clippy_lints/src/from_over_into.rs
+++ b/clippy_lints/src/from_over_into.rs
@@ -110,12 +110,12 @@ impl<'tcx> LateLintPass<'tcx> for FromOverInto {
     extract_msrv_attr!(LateContext);
 }
 
-/// Finds the occurences of `Self` and `self`
+/// Finds the occurrences of `Self` and `self`
 struct SelfFinder<'a, 'tcx> {
     cx: &'a LateContext<'tcx>,
-    /// Occurences of `Self`
+    /// Occurrences of `Self`
     upper: Vec<Span>,
-    /// Occurences of `self`
+    /// Occurrences of `self`
     lower: Vec<Span>,
     /// If any of the `self`/`Self` usages were from an expansion, or the body contained a binding
     /// already named `val`
diff --git a/clippy_lints/src/matches/single_match.rs b/clippy_lints/src/matches/single_match.rs
index 6b05c6bfffd..5b92c0f7dc8 100644
--- a/clippy_lints/src/matches/single_match.rs
+++ b/clippy_lints/src/matches/single_match.rs
@@ -51,7 +51,7 @@ pub(crate) fn check(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>], expr:
             // block with 2+ statements or 1 expr and 1+ statement
             Some(els)
         } else {
-            // not a block or an emtpy block w/ comments, don't lint
+            // not a block or an empty block w/ comments, don't lint
             return;
         };
 
diff --git a/clippy_lints/src/reserve_after_initialization.rs b/clippy_lints/src/reserve_after_initialization.rs
index f1ef3709514..c2294303082 100644
--- a/clippy_lints/src/reserve_after_initialization.rs
+++ b/clippy_lints/src/reserve_after_initialization.rs
@@ -29,7 +29,7 @@ declare_clippy_lint! {
     #[clippy::version = "1.73.0"]
     pub RESERVE_AFTER_INITIALIZATION,
     complexity,
-    "`reserve` called immediatly after `Vec` creation"
+    "`reserve` called immediately after `Vec` creation"
 }
 impl_lint_pass!(ReserveAfterInitialization => [RESERVE_AFTER_INITIALIZATION]);
 
diff --git a/clippy_lints/src/unnecessary_map_on_constructor.rs b/clippy_lints/src/unnecessary_map_on_constructor.rs
index f9d9650db04..b154f75c7ca 100644
--- a/clippy_lints/src/unnecessary_map_on_constructor.rs
+++ b/clippy_lints/src/unnecessary_map_on_constructor.rs
@@ -9,7 +9,7 @@ use rustc_span::sym;
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Suggest removing the use of a may (or map_err) method when an Option or Result is being construted.
+    /// Suggest removing the use of a may (or map_err) method when an Option or Result is being constructed.
     ///
     /// ### Why is this bad?
     /// It introduces unnecessary complexity. In this case the function can be used directly and
diff --git a/clippy_lints/src/utils/internal_lints/almost_standard_lint_formulation.rs b/clippy_lints/src/utils/internal_lints/almost_standard_lint_formulation.rs
index 570a88a0ed2..d78f67c05f0 100644
--- a/clippy_lints/src/utils/internal_lints/almost_standard_lint_formulation.rs
+++ b/clippy_lints/src/utils/internal_lints/almost_standard_lint_formulation.rs
@@ -11,7 +11,7 @@ declare_clippy_lint! {
     /// Checks if lint formulations have a standardized format.
     ///
     /// ### Why is this bad?
-    /// It's not neccessarily bad, but we try to enforce a standard in Clippy.
+    /// It's not necessarily bad, but we try to enforce a standard in Clippy.
     ///
     /// ### Example
     /// `Checks for use...` can be written as `Checks for usage...` .
-- 
cgit 1.4.1-3-g733a5


From c51e2a0f756f6de83800d4dfd68c455e4a089eb8 Mon Sep 17 00:00:00 2001
From: jonboh <jon.bosque.hernando@gmail.com>
Date: Wed, 13 Sep 2023 20:55:54 +0200
Subject: fix enum_variant_names depending lint depending on order

---
 clippy_lints/src/item_name_repetitions.rs |  7 +++++--
 tests/ui/enum_variants.rs                 | 17 +++++++++++++++++
 tests/ui/enum_variants.stderr             | 14 +++++++++++++-
 3 files changed, 35 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/item_name_repetitions.rs b/clippy_lints/src/item_name_repetitions.rs
index 923d90187e9..fe30697b9de 100644
--- a/clippy_lints/src/item_name_repetitions.rs
+++ b/clippy_lints/src/item_name_repetitions.rs
@@ -320,6 +320,11 @@ fn check_variant(cx: &LateContext<'_>, threshold: u64, def: &EnumDef<'_>, item_n
         return;
     }
 
+    for var in def.variants {
+        check_enum_start(cx, item_name, var);
+        check_enum_end(cx, item_name, var);
+    }
+
     let first = match def.variants.first() {
         Some(variant) => variant.ident.name.as_str(),
         None => return,
@@ -328,8 +333,6 @@ fn check_variant(cx: &LateContext<'_>, threshold: u64, def: &EnumDef<'_>, item_n
     let mut post = pre.clone();
     post.reverse();
     for var in def.variants {
-        check_enum_start(cx, item_name, var);
-        check_enum_end(cx, item_name, var);
         let name = var.ident.name.as_str();
 
         let variant_split = camel_case_split(name);
diff --git a/tests/ui/enum_variants.rs b/tests/ui/enum_variants.rs
index 85df852f729..ddf2dfdaea9 100644
--- a/tests/ui/enum_variants.rs
+++ b/tests/ui/enum_variants.rs
@@ -204,4 +204,21 @@ mod allow_attributes_on_variants {
     }
 }
 
+mod issue11494 {
+    // variant order should not affect lint
+    enum Data {
+        Valid,
+        Invalid,
+        DataDependent,
+        //~^ ERROR: variant name starts with the enum's name
+    }
+
+    enum Datas {
+        DatasDependent,
+        //~^ ERROR: variant name starts with the enum's name
+        Valid,
+        Invalid,
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/enum_variants.stderr b/tests/ui/enum_variants.stderr
index 9ea80b635f4..b1e88de0fcf 100644
--- a/tests/ui/enum_variants.stderr
+++ b/tests/ui/enum_variants.stderr
@@ -158,5 +158,17 @@ LL | |     }
    |
    = help: remove the postfixes and use full paths to the variants instead of glob imports
 
-error: aborting due to 14 previous errors
+error: variant name starts with the enum's name
+  --> $DIR/enum_variants.rs:212:9
+   |
+LL |         DataDependent,
+   |         ^^^^^^^^^^^^^
+
+error: variant name starts with the enum's name
+  --> $DIR/enum_variants.rs:217:9
+   |
+LL |         DatasDependent,
+   |         ^^^^^^^^^^^^^^
+
+error: aborting due to 16 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From e6c804c457ba20d65d3aac2e21c0e534ad479237 Mon Sep 17 00:00:00 2001
From: Andre Bogus <bogusandre@gmail.com>
Date: Sun, 29 Oct 2023 23:04:17 +0100
Subject: ignore lower-camel-case words in `doc_markdown`

---
 clippy_lints/src/doc.rs        | 7 ++++---
 tests/ui/doc/doc-fixable.fixed | 3 +++
 tests/ui/doc/doc-fixable.rs    | 3 +++
 3 files changed, 10 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/doc.rs b/clippy_lints/src/doc.rs
index a2e05e5ba8d..e2f595dcf18 100644
--- a/clippy_lints/src/doc.rs
+++ b/clippy_lints/src/doc.rs
@@ -756,11 +756,12 @@ fn check_text(cx: &LateContext<'_>, valid_idents: &FxHashSet<String>, text: &str
 }
 
 fn check_word(cx: &LateContext<'_>, word: &str, span: Span) {
-    /// Checks if a string is camel-case, i.e., contains at least two uppercase
-    /// letters (`Clippy` is ok) and one lower-case letter (`NASA` is ok).
+    /// Checks if a string is upper-camel-case, i.e., starts with an uppercase and
+    /// contains at least two uppercase letters (`Clippy` is ok) and one lower-case
+    /// letter (`NASA` is ok).
     /// Plurals are also excluded (`IDs` is ok).
     fn is_camel_case(s: &str) -> bool {
-        if s.starts_with(|c: char| c.is_ascii_digit()) {
+        if s.starts_with(|c: char| c.is_ascii_digit() | c.is_ascii_lowercase()) {
             return false;
         }
 
diff --git a/tests/ui/doc/doc-fixable.fixed b/tests/ui/doc/doc-fixable.fixed
index 47b56960a00..aee89719728 100644
--- a/tests/ui/doc/doc-fixable.fixed
+++ b/tests/ui/doc/doc-fixable.fixed
@@ -224,3 +224,6 @@ where [(); N.checked_next_power_of_two().unwrap()]: {
         }
     }
 }
+
+/// this checks if the lowerCamelCase issue is fixed
+fn issue_11568() {}
diff --git a/tests/ui/doc/doc-fixable.rs b/tests/ui/doc/doc-fixable.rs
index 4d9a4eafa5f..b6346b881ad 100644
--- a/tests/ui/doc/doc-fixable.rs
+++ b/tests/ui/doc/doc-fixable.rs
@@ -224,3 +224,6 @@ where [(); N.checked_next_power_of_two().unwrap()]: {
         }
     }
 }
+
+/// this checks if the lowerCamelCase issue is fixed
+fn issue_11568() {}
-- 
cgit 1.4.1-3-g733a5


From 69c3b9c2523290f07713efdbfb4dc4a0369416b1 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Sun, 15 Oct 2023 00:57:33 +0200
Subject: new lint: `unnecessary_fallible_conversions`

---
 CHANGELOG.md                                       |   1 +
 clippy_lints/src/declared_lints.rs                 |   1 +
 clippy_lints/src/implicit_saturating_add.rs        |  24 ++---
 clippy_lints/src/methods/mod.rs                    |  33 ++++++
 .../methods/unnecessary_fallible_conversions.rs    | 119 +++++++++++++++++++++
 tests/ui/manual_string_new.fixed                   |   1 +
 tests/ui/manual_string_new.rs                      |   1 +
 tests/ui/manual_string_new.stderr                  |  18 ++--
 tests/ui/unnecessary_fallible_conversions.fixed    |   6 ++
 tests/ui/unnecessary_fallible_conversions.rs       |   6 ++
 tests/ui/unnecessary_fallible_conversions.stderr   |  17 +++
 .../unnecessary_fallible_conversions_unfixable.rs  |  43 ++++++++
 ...necessary_fallible_conversions_unfixable.stderr |  41 +++++++
 tests/ui/useless_conversion_try.rs                 |   2 +-
 14 files changed, 291 insertions(+), 22 deletions(-)
 create mode 100644 clippy_lints/src/methods/unnecessary_fallible_conversions.rs
 create mode 100644 tests/ui/unnecessary_fallible_conversions.fixed
 create mode 100644 tests/ui/unnecessary_fallible_conversions.rs
 create mode 100644 tests/ui/unnecessary_fallible_conversions.stderr
 create mode 100644 tests/ui/unnecessary_fallible_conversions_unfixable.rs
 create mode 100644 tests/ui/unnecessary_fallible_conversions_unfixable.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index b28075d8eb3..993406b692c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5528,6 +5528,7 @@ Released 2018-09-13
 [`unknown_clippy_lints`]: https://rust-lang.github.io/rust-clippy/master/index.html#unknown_clippy_lints
 [`unnecessary_box_returns`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_box_returns
 [`unnecessary_cast`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_cast
+[`unnecessary_fallible_conversions`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_fallible_conversions
 [`unnecessary_filter_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_filter_map
 [`unnecessary_find_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_find_map
 [`unnecessary_fold`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_fold
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 8a341513303..d9c97a8cc97 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -430,6 +430,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::methods::TYPE_ID_ON_BOX_INFO,
     crate::methods::UNINIT_ASSUMED_INIT_INFO,
     crate::methods::UNIT_HASH_INFO,
+    crate::methods::UNNECESSARY_FALLIBLE_CONVERSIONS_INFO,
     crate::methods::UNNECESSARY_FILTER_MAP_INFO,
     crate::methods::UNNECESSARY_FIND_MAP_INFO,
     crate::methods::UNNECESSARY_FOLD_INFO,
diff --git a/clippy_lints/src/implicit_saturating_add.rs b/clippy_lints/src/implicit_saturating_add.rs
index 453797f1853..24f62490f96 100644
--- a/clippy_lints/src/implicit_saturating_add.rs
+++ b/clippy_lints/src/implicit_saturating_add.rs
@@ -82,18 +82,18 @@ impl<'tcx> LateLintPass<'tcx> for ImplicitSaturatingAdd {
 
 fn get_int_max(ty: Ty<'_>) -> Option<u128> {
     match ty.peel_refs().kind() {
-        Int(IntTy::I8) => i8::max_value().try_into().ok(),
-        Int(IntTy::I16) => i16::max_value().try_into().ok(),
-        Int(IntTy::I32) => i32::max_value().try_into().ok(),
-        Int(IntTy::I64) => i64::max_value().try_into().ok(),
-        Int(IntTy::I128) => i128::max_value().try_into().ok(),
-        Int(IntTy::Isize) => isize::max_value().try_into().ok(),
-        Uint(UintTy::U8) => u8::max_value().try_into().ok(),
-        Uint(UintTy::U16) => u16::max_value().try_into().ok(),
-        Uint(UintTy::U32) => u32::max_value().try_into().ok(),
-        Uint(UintTy::U64) => u64::max_value().try_into().ok(),
-        Uint(UintTy::U128) => Some(u128::max_value()),
-        Uint(UintTy::Usize) => usize::max_value().try_into().ok(),
+        Int(IntTy::I8) => i8::MAX.try_into().ok(),
+        Int(IntTy::I16) => i16::MAX.try_into().ok(),
+        Int(IntTy::I32) => i32::MAX.try_into().ok(),
+        Int(IntTy::I64) => i64::MAX.try_into().ok(),
+        Int(IntTy::I128) => i128::MAX.try_into().ok(),
+        Int(IntTy::Isize) => isize::MAX.try_into().ok(),
+        Uint(UintTy::U8) => Some(u8::MAX.into()),
+        Uint(UintTy::U16) => Some(u16::MAX.into()),
+        Uint(UintTy::U32) => Some(u32::MAX.into()),
+        Uint(UintTy::U64) => Some(u64::MAX.into()),
+        Uint(UintTy::U128) => Some(u128::MAX),
+        Uint(UintTy::Usize) => usize::MAX.try_into().ok(),
         _ => None,
     }
 }
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index e1a14e29358..90f6bc5e3d3 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -99,6 +99,7 @@ mod suspicious_to_owned;
 mod type_id_on_box;
 mod uninit_assumed_init;
 mod unit_hash;
+mod unnecessary_fallible_conversions;
 mod unnecessary_filter_map;
 mod unnecessary_fold;
 mod unnecessary_iter_cloned;
@@ -3655,6 +3656,33 @@ declare_clippy_lint! {
     "cloning a `Waker` only to wake it"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for calls to `TryInto::try_into` and `TryFrom::try_from` when their infallible counterparts
+    /// could be used.
+    ///
+    /// ### Why is this bad?
+    /// In those cases, the `TryInto` and `TryFrom` trait implementation is a blanket impl that forwards
+    /// to `Into` or `From`, which always succeeds.
+    /// The returned `Result<_, Infallible>` requires error handling to get the contained value
+    /// even though the conversion can never fail.
+    ///
+    /// ### Example
+    /// ```rust
+    /// let _: Result<i64, _> = 1i32.try_into();
+    /// let _: Result<i64, _> = <_>::try_from(1i32);
+    /// ```
+    /// Use `from`/`into` instead:
+    /// ```rust
+    /// let _: i64 = 1i32.into();
+    /// let _: i64 = <_>::from(1i32);
+    /// ```
+    #[clippy::version = "1.75.0"]
+    pub UNNECESSARY_FALLIBLE_CONVERSIONS,
+    style,
+    "calling the `try_from` and `try_into` trait methods when `From`/`Into` is implemented"
+}
+
 pub struct Methods {
     avoid_breaking_exported_api: bool,
     msrv: Msrv,
@@ -3801,6 +3829,7 @@ impl_lint_pass!(Methods => [
     PATH_ENDS_WITH_EXT,
     REDUNDANT_AS_STR,
     WAKER_CLONE_WAKE,
+    UNNECESSARY_FALLIBLE_CONVERSIONS,
 ]);
 
 /// Extracts a method call name, args, and `Span` of the method name.
@@ -3827,6 +3856,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
         match expr.kind {
             hir::ExprKind::Call(func, args) => {
                 from_iter_instead_of_collect::check(cx, expr, args, func);
+                unnecessary_fallible_conversions::check_function(cx, expr, func);
             },
             hir::ExprKind::MethodCall(method_call, receiver, args, _) => {
                 let method_span = method_call.ident.span;
@@ -4316,6 +4346,9 @@ impl Methods {
                     }
                     unnecessary_lazy_eval::check(cx, expr, recv, arg, "then_some");
                 },
+                ("try_into", []) if is_trait_method(cx, expr, sym::TryInto) => {
+                    unnecessary_fallible_conversions::check_method(cx, expr);
+                }
                 ("to_owned", []) => {
                     if !suspicious_to_owned::check(cx, expr, recv) {
                         implicit_clone::check(cx, name, expr, recv);
diff --git a/clippy_lints/src/methods/unnecessary_fallible_conversions.rs b/clippy_lints/src/methods/unnecessary_fallible_conversions.rs
new file mode 100644
index 00000000000..6660ad215d8
--- /dev/null
+++ b/clippy_lints/src/methods/unnecessary_fallible_conversions.rs
@@ -0,0 +1,119 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::get_parent_expr;
+use clippy_utils::ty::implements_trait;
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind};
+use rustc_lint::LateContext;
+use rustc_middle::ty;
+use rustc_span::{sym, Span};
+
+use super::UNNECESSARY_FALLIBLE_CONVERSIONS;
+
+/// What function is being called and whether that call is written as a method call or a function
+/// call
+#[derive(Copy, Clone)]
+#[expect(clippy::enum_variant_names)]
+enum FunctionKind {
+    /// `T::try_from(U)`
+    TryFromFunction,
+    /// `t.try_into()`
+    TryIntoMethod,
+    /// `U::try_into(t)`
+    TryIntoFunction,
+}
+
+fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &Expr<'_>,
+    node_args: ty::GenericArgsRef<'tcx>,
+    kind: FunctionKind,
+    primary_span: Span,
+) {
+    if let &[self_ty, other_ty] = node_args.as_slice()
+        // useless_conversion already warns `T::try_from(T)`, so ignore it here
+        && self_ty != other_ty
+        && let Some(self_ty) = self_ty.as_type()
+        && let Some(from_into_trait) = cx.tcx.get_diagnostic_item(match kind {
+            FunctionKind::TryFromFunction => sym::From,
+            FunctionKind::TryIntoMethod | FunctionKind::TryIntoFunction => sym::Into,
+        })
+        // If `T: TryFrom<U>` and `T: From<U>` both exist, then that means that the `TryFrom`
+        // _must_ be from the blanket impl and cannot have been manually implemented
+        // (else there would be conflicting impls, even with #![feature(spec)]), so we don't even need to check
+        // what `<T as TryFrom<U>>::Error` is: it's always `Infallible`
+        && implements_trait(cx, self_ty, from_into_trait, &[other_ty])
+    {
+        let parent_unwrap_call = get_parent_expr(cx, expr)
+            .and_then(|parent| {
+                if let ExprKind::MethodCall(path, .., span) = parent.kind
+                    && let sym::unwrap | sym::expect = path.ident.name
+                {
+                    Some(span)
+                } else {
+                    None
+                }
+            });
+
+        let (sugg, span, applicability) = match kind {
+            FunctionKind::TryIntoMethod if let Some(unwrap_span) = parent_unwrap_call => {
+                // Extend the span to include the unwrap/expect call:
+                // `foo.try_into().expect("..")`
+                //      ^^^^^^^^^^^^^^^^^^^^^^^
+                //
+                // `try_into().unwrap()` specifically can be trivially replaced with just `into()`,
+                // so that can be machine-applicable
+
+                ("into()", primary_span.with_hi(unwrap_span.hi()), Applicability::MachineApplicable)
+            }
+            FunctionKind::TryFromFunction => ("From::from", primary_span, Applicability::Unspecified),
+            FunctionKind::TryIntoFunction => ("Into::into", primary_span, Applicability::Unspecified),
+            FunctionKind::TryIntoMethod => ("into", primary_span, Applicability::Unspecified),
+        };
+
+        span_lint_and_sugg(
+            cx,
+            UNNECESSARY_FALLIBLE_CONVERSIONS,
+            span,
+            "use of a fallible conversion when an infallible one could be used",
+            "use",
+            sugg.into(),
+            applicability
+        );
+    }
+}
+
+/// Checks method call exprs:
+/// - `0i32.try_into()`
+pub(super) fn check_method(cx: &LateContext<'_>, expr: &Expr<'_>) {
+    if let ExprKind::MethodCall(path, ..) = expr.kind {
+        check(
+            cx,
+            expr,
+            cx.typeck_results().node_args(expr.hir_id),
+            FunctionKind::TryIntoMethod,
+            path.ident.span,
+        );
+    }
+}
+
+/// Checks function call exprs:
+/// - `<i64 as TryFrom<_>>::try_from(0i32)`
+/// - `<_ as TryInto<i64>>::try_into(0i32)`
+pub(super) fn check_function(cx: &LateContext<'_>, expr: &Expr<'_>, callee: &Expr<'_>) {
+    if let ExprKind::Path(ref qpath) = callee.kind
+        && let Some(item_def_id) = cx.qpath_res(qpath, callee.hir_id).opt_def_id()
+        && let Some(trait_def_id) = cx.tcx.trait_of_item(item_def_id)
+    {
+        check(
+            cx,
+            expr,
+            cx.typeck_results().node_args(callee.hir_id),
+            match cx.tcx.get_diagnostic_name(trait_def_id) {
+                Some(sym::TryFrom) => FunctionKind::TryFromFunction,
+                Some(sym::TryInto) => FunctionKind::TryIntoFunction,
+                _ => return,
+            },
+            callee.span,
+        );
+    }
+}
diff --git a/tests/ui/manual_string_new.fixed b/tests/ui/manual_string_new.fixed
index 273be4e0fd2..2d4c5a02915 100644
--- a/tests/ui/manual_string_new.fixed
+++ b/tests/ui/manual_string_new.fixed
@@ -1,4 +1,5 @@
 #![warn(clippy::manual_string_new)]
+#![allow(clippy::unnecessary_fallible_conversions)]
 
 macro_rules! create_strings_from_macro {
     // When inside a macro, nothing should warn to prevent false positives.
diff --git a/tests/ui/manual_string_new.rs b/tests/ui/manual_string_new.rs
index 0d5514fc893..20f0be6aaf9 100644
--- a/tests/ui/manual_string_new.rs
+++ b/tests/ui/manual_string_new.rs
@@ -1,4 +1,5 @@
 #![warn(clippy::manual_string_new)]
+#![allow(clippy::unnecessary_fallible_conversions)]
 
 macro_rules! create_strings_from_macro {
     // When inside a macro, nothing should warn to prevent false positives.
diff --git a/tests/ui/manual_string_new.stderr b/tests/ui/manual_string_new.stderr
index 399652d3fec..cb2d78c39ed 100644
--- a/tests/ui/manual_string_new.stderr
+++ b/tests/ui/manual_string_new.stderr
@@ -1,5 +1,5 @@
 error: empty String is being created manually
-  --> $DIR/manual_string_new.rs:13:13
+  --> $DIR/manual_string_new.rs:14:13
    |
 LL |     let _ = "".to_string();
    |             ^^^^^^^^^^^^^^ help: consider using: `String::new()`
@@ -8,49 +8,49 @@ LL |     let _ = "".to_string();
    = help: to override `-D warnings` add `#[allow(clippy::manual_string_new)]`
 
 error: empty String is being created manually
-  --> $DIR/manual_string_new.rs:16:13
+  --> $DIR/manual_string_new.rs:17:13
    |
 LL |     let _ = "".to_owned();
    |             ^^^^^^^^^^^^^ help: consider using: `String::new()`
 
 error: empty String is being created manually
-  --> $DIR/manual_string_new.rs:19:21
+  --> $DIR/manual_string_new.rs:20:21
    |
 LL |     let _: String = "".into();
    |                     ^^^^^^^^^ help: consider using: `String::new()`
 
 error: empty String is being created manually
-  --> $DIR/manual_string_new.rs:26:13
+  --> $DIR/manual_string_new.rs:27:13
    |
 LL |     let _ = String::from("");
    |             ^^^^^^^^^^^^^^^^ help: consider using: `String::new()`
 
 error: empty String is being created manually
-  --> $DIR/manual_string_new.rs:27:13
+  --> $DIR/manual_string_new.rs:28:13
    |
 LL |     let _ = <String>::from("");
    |             ^^^^^^^^^^^^^^^^^^ help: consider using: `String::new()`
 
 error: empty String is being created manually
-  --> $DIR/manual_string_new.rs:32:13
+  --> $DIR/manual_string_new.rs:33:13
    |
 LL |     let _ = String::try_from("").unwrap();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `String::new()`
 
 error: empty String is being created manually
-  --> $DIR/manual_string_new.rs:38:21
+  --> $DIR/manual_string_new.rs:39:21
    |
 LL |     let _: String = From::from("");
    |                     ^^^^^^^^^^^^^^ help: consider using: `String::new()`
 
 error: empty String is being created manually
-  --> $DIR/manual_string_new.rs:43:21
+  --> $DIR/manual_string_new.rs:44:21
    |
 LL |     let _: String = TryFrom::try_from("").unwrap();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `String::new()`
 
 error: empty String is being created manually
-  --> $DIR/manual_string_new.rs:46:21
+  --> $DIR/manual_string_new.rs:47:21
    |
 LL |     let _: String = TryFrom::try_from("").expect("this should warn");
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `String::new()`
diff --git a/tests/ui/unnecessary_fallible_conversions.fixed b/tests/ui/unnecessary_fallible_conversions.fixed
new file mode 100644
index 00000000000..9668a6b99bf
--- /dev/null
+++ b/tests/ui/unnecessary_fallible_conversions.fixed
@@ -0,0 +1,6 @@
+#![warn(clippy::unnecessary_fallible_conversions)]
+
+fn main() {
+    let _: i64 = 0i32.into();
+    let _: i64 = 0i32.into();
+}
diff --git a/tests/ui/unnecessary_fallible_conversions.rs b/tests/ui/unnecessary_fallible_conversions.rs
new file mode 100644
index 00000000000..9fa6c08b1b0
--- /dev/null
+++ b/tests/ui/unnecessary_fallible_conversions.rs
@@ -0,0 +1,6 @@
+#![warn(clippy::unnecessary_fallible_conversions)]
+
+fn main() {
+    let _: i64 = 0i32.try_into().unwrap();
+    let _: i64 = 0i32.try_into().expect("can't happen");
+}
diff --git a/tests/ui/unnecessary_fallible_conversions.stderr b/tests/ui/unnecessary_fallible_conversions.stderr
new file mode 100644
index 00000000000..b918fdf774b
--- /dev/null
+++ b/tests/ui/unnecessary_fallible_conversions.stderr
@@ -0,0 +1,17 @@
+error: use of a fallible conversion when an infallible one could be used
+  --> $DIR/unnecessary_fallible_conversions.rs:4:23
+   |
+LL |     let _: i64 = 0i32.try_into().unwrap();
+   |                       ^^^^^^^^^^^^^^^^^^^ help: use: `into()`
+   |
+   = note: `-D clippy::unnecessary-fallible-conversions` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::unnecessary_fallible_conversions)]`
+
+error: use of a fallible conversion when an infallible one could be used
+  --> $DIR/unnecessary_fallible_conversions.rs:5:23
+   |
+LL |     let _: i64 = 0i32.try_into().expect("can't happen");
+   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `into()`
+
+error: aborting due to 2 previous errors
+
diff --git a/tests/ui/unnecessary_fallible_conversions_unfixable.rs b/tests/ui/unnecessary_fallible_conversions_unfixable.rs
new file mode 100644
index 00000000000..68e617cc062
--- /dev/null
+++ b/tests/ui/unnecessary_fallible_conversions_unfixable.rs
@@ -0,0 +1,43 @@
+//@aux-build:proc_macros.rs
+//@no-rustfix
+#![warn(clippy::unnecessary_fallible_conversions)]
+
+extern crate proc_macros;
+
+struct Foo;
+impl TryFrom<i32> for Foo {
+    type Error = ();
+    fn try_from(_: i32) -> Result<Self, Self::Error> {
+        Ok(Foo)
+    }
+}
+impl From<i64> for Foo {
+    fn from(_: i64) -> Self {
+        Foo
+    }
+}
+
+fn main() {
+    // `Foo` only implements `TryFrom<i32>` and not `From<i32>`, so don't lint
+    let _: Result<Foo, _> = 0i32.try_into();
+    let _: Result<Foo, _> = i32::try_into(0i32);
+    let _: Result<Foo, _> = Foo::try_from(0i32);
+
+    // ... it does impl From<i64> however
+    let _: Result<Foo, _> = 0i64.try_into();
+    //~^ ERROR: use of a fallible conversion when an infallible one could be used
+    let _: Result<Foo, _> = i64::try_into(0i64);
+    //~^ ERROR: use of a fallible conversion when an infallible one could be used
+    let _: Result<Foo, _> = Foo::try_from(0i64);
+    //~^ ERROR: use of a fallible conversion when an infallible one could be used
+
+    let _: Result<i64, _> = 0i32.try_into();
+    //~^ ERROR: use of a fallible conversion when an infallible one could be used
+    let _: Result<i64, _> = i32::try_into(0i32);
+    //~^ ERROR: use of a fallible conversion when an infallible one could be used
+    let _: Result<i64, _> = <_>::try_from(0i32);
+    //~^ ERROR: use of a fallible conversion when an infallible one could be used
+
+    // From a macro
+    let _: Result<i64, _> = proc_macros::external!(0i32).try_into();
+}
diff --git a/tests/ui/unnecessary_fallible_conversions_unfixable.stderr b/tests/ui/unnecessary_fallible_conversions_unfixable.stderr
new file mode 100644
index 00000000000..286decf8f35
--- /dev/null
+++ b/tests/ui/unnecessary_fallible_conversions_unfixable.stderr
@@ -0,0 +1,41 @@
+error: use of a fallible conversion when an infallible one could be used
+  --> $DIR/unnecessary_fallible_conversions_unfixable.rs:27:34
+   |
+LL |     let _: Result<Foo, _> = 0i64.try_into();
+   |                                  ^^^^^^^^ help: use: `into`
+   |
+   = note: `-D clippy::unnecessary-fallible-conversions` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::unnecessary_fallible_conversions)]`
+
+error: use of a fallible conversion when an infallible one could be used
+  --> $DIR/unnecessary_fallible_conversions_unfixable.rs:29:29
+   |
+LL |     let _: Result<Foo, _> = i64::try_into(0i64);
+   |                             ^^^^^^^^^^^^^ help: use: `Into::into`
+
+error: use of a fallible conversion when an infallible one could be used
+  --> $DIR/unnecessary_fallible_conversions_unfixable.rs:31:29
+   |
+LL |     let _: Result<Foo, _> = Foo::try_from(0i64);
+   |                             ^^^^^^^^^^^^^ help: use: `From::from`
+
+error: use of a fallible conversion when an infallible one could be used
+  --> $DIR/unnecessary_fallible_conversions_unfixable.rs:34:34
+   |
+LL |     let _: Result<i64, _> = 0i32.try_into();
+   |                                  ^^^^^^^^ help: use: `into`
+
+error: use of a fallible conversion when an infallible one could be used
+  --> $DIR/unnecessary_fallible_conversions_unfixable.rs:36:29
+   |
+LL |     let _: Result<i64, _> = i32::try_into(0i32);
+   |                             ^^^^^^^^^^^^^ help: use: `Into::into`
+
+error: use of a fallible conversion when an infallible one could be used
+  --> $DIR/unnecessary_fallible_conversions_unfixable.rs:38:29
+   |
+LL |     let _: Result<i64, _> = <_>::try_from(0i32);
+   |                             ^^^^^^^^^^^^^ help: use: `From::from`
+
+error: aborting due to 6 previous errors
+
diff --git a/tests/ui/useless_conversion_try.rs b/tests/ui/useless_conversion_try.rs
index a5feefbe0f0..803d3b39f37 100644
--- a/tests/ui/useless_conversion_try.rs
+++ b/tests/ui/useless_conversion_try.rs
@@ -1,5 +1,5 @@
 #![deny(clippy::useless_conversion)]
-#![allow(clippy::needless_if)]
+#![allow(clippy::needless_if, clippy::unnecessary_fallible_conversions)]
 
 fn test_generic<T: Copy>(val: T) -> T {
     let _ = T::try_from(val).unwrap();
-- 
cgit 1.4.1-3-g733a5


From 0b90f72064cba3ced487773679aba48ae78af007 Mon Sep 17 00:00:00 2001
From: Dinu Blanovschi <git@dnbln.dev>
Date: Sun, 26 Feb 2023 02:18:08 +0100
Subject: feat: unused_enumerate_index lint

---
 CHANGELOG.md                                     |  1 +
 clippy_lints/src/declared_lints.rs               |  1 +
 clippy_lints/src/loops/mod.rs                    | 33 ++++++++++-
 clippy_lints/src/loops/unused_enumerate_index.rs | 75 ++++++++++++++++++++++++
 tests/ui/unused_enumerate_index.fixed            | 10 ++++
 tests/ui/unused_enumerate_index.rs               | 10 ++++
 tests/ui/unused_enumerate_index.stderr           | 15 +++++
 7 files changed, 144 insertions(+), 1 deletion(-)
 create mode 100644 clippy_lints/src/loops/unused_enumerate_index.rs
 create mode 100644 tests/ui/unused_enumerate_index.fixed
 create mode 100644 tests/ui/unused_enumerate_index.rs
 create mode 100644 tests/ui/unused_enumerate_index.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 993406b692c..87a96bdeba6 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5561,6 +5561,7 @@ Released 2018-09-13
 [`unstable_as_slice`]: https://rust-lang.github.io/rust-clippy/master/index.html#unstable_as_slice
 [`unused_async`]: https://rust-lang.github.io/rust-clippy/master/index.html#unused_async
 [`unused_collect`]: https://rust-lang.github.io/rust-clippy/master/index.html#unused_collect
+[`unused_enumerate_index`]: https://rust-lang.github.io/rust-clippy/master/index.html#unused_enumerate_index
 [`unused_format_specs`]: https://rust-lang.github.io/rust-clippy/master/index.html#unused_format_specs
 [`unused_io_amount`]: https://rust-lang.github.io/rust-clippy/master/index.html#unused_io_amount
 [`unused_label`]: https://rust-lang.github.io/rust-clippy/master/index.html#unused_label
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index d9c97a8cc97..1a646ba38c3 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -274,6 +274,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::loops::NEVER_LOOP_INFO,
     crate::loops::SAME_ITEM_PUSH_INFO,
     crate::loops::SINGLE_ELEMENT_LOOP_INFO,
+    crate::loops::UNUSED_ENUMERATE_INDEX_INFO,
     crate::loops::WHILE_IMMUTABLE_CONDITION_INFO,
     crate::loops::WHILE_LET_LOOP_INFO,
     crate::loops::WHILE_LET_ON_ITERATOR_INFO,
diff --git a/clippy_lints/src/loops/mod.rs b/clippy_lints/src/loops/mod.rs
index 575a84c8c63..c2b07920932 100644
--- a/clippy_lints/src/loops/mod.rs
+++ b/clippy_lints/src/loops/mod.rs
@@ -14,6 +14,7 @@ mod needless_range_loop;
 mod never_loop;
 mod same_item_push;
 mod single_element_loop;
+mod unused_enumerate_index;
 mod utils;
 mod while_immutable_condition;
 mod while_let_loop;
@@ -577,6 +578,33 @@ declare_clippy_lint! {
     "manual implementation of `Iterator::find`"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `for (_, v) in a.iter().enumerate()`
+    ///
+    /// ### Why is this bad?
+    /// The index from `.enumerate()` is immediately dropped.
+    ///
+    /// ### Example
+    /// ```rust
+    /// let v = vec![1, 2, 3, 4];
+    /// for (_, x) in v.iter().enumerate() {
+    ///     print!("{x}")
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// let v = vec![1, 2, 3, 4];
+    /// for x in v.iter() {
+    ///     print!("{x}")
+    /// }
+    /// ```
+    #[clippy::version = "1.69.0"]
+    pub UNUSED_ENUMERATE_INDEX,
+    style,
+    "using .enumerate() and immediately dropping the index"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Looks for loops that check for emptiness of a `Vec` in the condition and pop an element
@@ -619,6 +647,7 @@ impl Loops {
         }
     }
 }
+
 impl_lint_pass!(Loops => [
     MANUAL_MEMCPY,
     MANUAL_FLATTEN,
@@ -638,7 +667,8 @@ impl_lint_pass!(Loops => [
     SINGLE_ELEMENT_LOOP,
     MISSING_SPIN_LOOP,
     MANUAL_FIND,
-    MANUAL_WHILE_LET_SOME
+    MANUAL_WHILE_LET_SOME,
+    UNUSED_ENUMERATE_INDEX,
 ]);
 
 impl<'tcx> LateLintPass<'tcx> for Loops {
@@ -717,6 +747,7 @@ impl Loops {
         same_item_push::check(cx, pat, arg, body, expr);
         manual_flatten::check(cx, pat, arg, body, span);
         manual_find::check(cx, pat, arg, body, span, expr);
+        unused_enumerate_index::check(cx, pat, arg, body);
     }
 
     fn check_for_loop_arg(&self, cx: &LateContext<'_>, _: &Pat<'_>, arg: &Expr<'_>) {
diff --git a/clippy_lints/src/loops/unused_enumerate_index.rs b/clippy_lints/src/loops/unused_enumerate_index.rs
new file mode 100644
index 00000000000..33c29499ee9
--- /dev/null
+++ b/clippy_lints/src/loops/unused_enumerate_index.rs
@@ -0,0 +1,75 @@
+use super::UNUSED_ENUMERATE_INDEX;
+use clippy_utils::diagnostics::{multispan_sugg, span_lint_and_then};
+use clippy_utils::source::snippet;
+use clippy_utils::sugg;
+use clippy_utils::visitors::is_local_used;
+use rustc_hir::{Expr, ExprKind, Pat, PatKind};
+use rustc_lint::LateContext;
+use rustc_middle::ty;
+
+/// Checks for the `UNUSED_ENUMERATE_INDEX` lint.
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>, arg: &'tcx Expr<'_>, body: &'tcx Expr<'_>) {
+    let pat_span = pat.span;
+
+    let PatKind::Tuple(pat, _) = pat.kind else {
+        return;
+    };
+
+    if pat.len() != 2 {
+        return;
+    }
+
+    let arg_span = arg.span;
+
+    let ExprKind::MethodCall(method, self_arg, [], _) = arg.kind else {
+        return;
+    };
+
+    if method.ident.as_str() != "enumerate" {
+        return;
+    }
+
+    let ty = cx.typeck_results().expr_ty(arg);
+
+    if !pat_is_wild(cx, &pat[0].kind, body) {
+        return;
+    }
+
+    let new_pat_span = pat[1].span;
+
+    let name = match *ty.kind() {
+        ty::Adt(base, _substs) => cx.tcx.def_path_str(base.did()),
+        _ => return,
+    };
+
+    if name != "std::iter::Enumerate" && name != "core::iter::Enumerate" {
+        return;
+    }
+
+    span_lint_and_then(
+        cx,
+        UNUSED_ENUMERATE_INDEX,
+        arg_span,
+        "you seem to use `.enumerate()` and immediately discard the index",
+        |diag| {
+            let base_iter = sugg::Sugg::hir(cx, self_arg, "base iter");
+            multispan_sugg(
+                diag,
+                "remove the `.enumerate()` call",
+                vec![
+                    (pat_span, snippet(cx, new_pat_span, "value").into_owned()),
+                    (arg_span, base_iter.to_string()),
+                ],
+            );
+        },
+    );
+}
+
+/// Returns `true` if the pattern is a `PatWild` or an ident prefixed with `_`.
+fn pat_is_wild<'tcx>(cx: &LateContext<'tcx>, pat: &'tcx PatKind<'_>, body: &'tcx Expr<'_>) -> bool {
+    match *pat {
+        PatKind::Wild => true,
+        PatKind::Binding(_, id, ident, None) if ident.as_str().starts_with('_') => !is_local_used(cx, body, id),
+        _ => false,
+    }
+}
diff --git a/tests/ui/unused_enumerate_index.fixed b/tests/ui/unused_enumerate_index.fixed
new file mode 100644
index 00000000000..3a9f89063fd
--- /dev/null
+++ b/tests/ui/unused_enumerate_index.fixed
@@ -0,0 +1,10 @@
+// run-rustfix
+#![allow(unused)]
+#![warn(clippy::unused_enumerate_index)]
+
+fn main() {
+    let v = [1, 2, 3];
+    for x in v.iter() {
+        print!("{x}");
+    }
+}
diff --git a/tests/ui/unused_enumerate_index.rs b/tests/ui/unused_enumerate_index.rs
new file mode 100644
index 00000000000..d047371f0b9
--- /dev/null
+++ b/tests/ui/unused_enumerate_index.rs
@@ -0,0 +1,10 @@
+// run-rustfix
+#![allow(unused)]
+#![warn(clippy::unused_enumerate_index)]
+
+fn main() {
+    let v = [1, 2, 3];
+    for (_, x) in v.iter().enumerate() {
+        print!("{x}");
+    }
+}
diff --git a/tests/ui/unused_enumerate_index.stderr b/tests/ui/unused_enumerate_index.stderr
new file mode 100644
index 00000000000..7bd9e374151
--- /dev/null
+++ b/tests/ui/unused_enumerate_index.stderr
@@ -0,0 +1,15 @@
+error: you seem to use `.enumerate()` and immediately discard the index
+  --> $DIR/unused_enumerate_index.rs:7:19
+   |
+LL |     for (_, x) in v.iter().enumerate() {
+   |                   ^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::unused-enumerate-index` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::unused_enumerate_index)]`
+help: remove the `.enumerate()` call
+   |
+LL |     for x in v.iter() {
+   |         ~    ~~~~~~~~
+
+error: aborting due to previous error
+
-- 
cgit 1.4.1-3-g733a5


From 14b82909b02b14c5b0c475bfbb5e507ddbd8f7c0 Mon Sep 17 00:00:00 2001
From: Dinu Blanovschi <git@dnbln.dev>
Date: Thu, 12 Oct 2023 19:05:22 +0200
Subject: Apply suggestions from code review
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Alejandra González <blyxyas@gmail.com>
---
 clippy_lints/src/loops/mod.rs                    | 10 ++---
 clippy_lints/src/loops/unused_enumerate_index.rs | 37 ++++++++---------
 tests/ui/unused_enumerate_index.fixed            | 52 +++++++++++++++++++++++-
 tests/ui/unused_enumerate_index.rs               | 52 +++++++++++++++++++++++-
 tests/ui/unused_enumerate_index.stderr           | 15 ++++++-
 5 files changed, 135 insertions(+), 31 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/mod.rs b/clippy_lints/src/loops/mod.rs
index c2b07920932..b99e0fd814f 100644
--- a/clippy_lints/src/loops/mod.rs
+++ b/clippy_lints/src/loops/mod.rs
@@ -580,7 +580,7 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for `for (_, v) in a.iter().enumerate()`
+    /// Checks for uses of the `enumerate` method where the index is unused (`_`)
     ///
     /// ### Why is this bad?
     /// The index from `.enumerate()` is immediately dropped.
@@ -589,20 +589,20 @@ declare_clippy_lint! {
     /// ```rust
     /// let v = vec![1, 2, 3, 4];
     /// for (_, x) in v.iter().enumerate() {
-    ///     print!("{x}")
+    ///     println!("{x}");
     /// }
     /// ```
     /// Use instead:
     /// ```rust
     /// let v = vec![1, 2, 3, 4];
     /// for x in v.iter() {
-    ///     print!("{x}")
+    ///     println!("{x}");
     /// }
     /// ```
-    #[clippy::version = "1.69.0"]
+    #[clippy::version = "1.75.0"]
     pub UNUSED_ENUMERATE_INDEX,
     style,
-    "using .enumerate() and immediately dropping the index"
+    "using `.enumerate()` and immediately dropping the index"
 }
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/loops/unused_enumerate_index.rs b/clippy_lints/src/loops/unused_enumerate_index.rs
index 33c29499ee9..18b73f77e81 100644
--- a/clippy_lints/src/loops/unused_enumerate_index.rs
+++ b/clippy_lints/src/loops/unused_enumerate_index.rs
@@ -3,40 +3,27 @@ use clippy_utils::diagnostics::{multispan_sugg, span_lint_and_then};
 use clippy_utils::source::snippet;
 use clippy_utils::sugg;
 use clippy_utils::visitors::is_local_used;
+use rustc_hir::def::DefKind;
 use rustc_hir::{Expr, ExprKind, Pat, PatKind};
 use rustc_lint::LateContext;
 use rustc_middle::ty;
 
 /// Checks for the `UNUSED_ENUMERATE_INDEX` lint.
 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>, arg: &'tcx Expr<'_>, body: &'tcx Expr<'_>) {
-    let pat_span = pat.span;
-
-    let PatKind::Tuple(pat, _) = pat.kind else {
+    let PatKind::Tuple(tuple, _) = pat.kind else {
         return;
     };
 
-    if pat.len() != 2 {
-        return;
-    }
-
-    let arg_span = arg.span;
-
-    let ExprKind::MethodCall(method, self_arg, [], _) = arg.kind else {
+    let ExprKind::MethodCall(_method, self_arg, [], _) = arg.kind else {
         return;
     };
 
-    if method.ident.as_str() != "enumerate" {
-        return;
-    }
-
     let ty = cx.typeck_results().expr_ty(arg);
 
-    if !pat_is_wild(cx, &pat[0].kind, body) {
+    if !pat_is_wild(cx, &tuple[0].kind, body) {
         return;
     }
 
-    let new_pat_span = pat[1].span;
-
     let name = match *ty.kind() {
         ty::Adt(base, _substs) => cx.tcx.def_path_str(base.did()),
         _ => return,
@@ -46,10 +33,20 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>, arg: &'tcx
         return;
     }
 
+    let Some((DefKind::AssocFn, call_id)) = cx.typeck_results().type_dependent_def(arg.hir_id) else {
+        return;
+    };
+
+    let call_name = cx.tcx.def_path_str(call_id);
+
+    if call_name != "std::iter::Iterator::enumerate" && call_name != "core::iter::Iterator::enumerate" {
+        return;
+    }
+
     span_lint_and_then(
         cx,
         UNUSED_ENUMERATE_INDEX,
-        arg_span,
+        arg.span,
         "you seem to use `.enumerate()` and immediately discard the index",
         |diag| {
             let base_iter = sugg::Sugg::hir(cx, self_arg, "base iter");
@@ -57,8 +54,8 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>, arg: &'tcx
                 diag,
                 "remove the `.enumerate()` call",
                 vec![
-                    (pat_span, snippet(cx, new_pat_span, "value").into_owned()),
-                    (arg_span, base_iter.to_string()),
+                    (pat.span, snippet(cx, tuple[1].span, "..").into_owned()),
+                    (arg.span, base_iter.to_string()),
                 ],
             );
         },
diff --git a/tests/ui/unused_enumerate_index.fixed b/tests/ui/unused_enumerate_index.fixed
index 3a9f89063fd..d079807ab58 100644
--- a/tests/ui/unused_enumerate_index.fixed
+++ b/tests/ui/unused_enumerate_index.fixed
@@ -1,10 +1,58 @@
-// run-rustfix
 #![allow(unused)]
 #![warn(clippy::unused_enumerate_index)]
 
+use std::iter::Enumerate;
+
 fn main() {
     let v = [1, 2, 3];
     for x in v.iter() {
-        print!("{x}");
+        println!("{x}");
+    }
+
+    struct Dummy1;
+    impl Dummy1 {
+        fn enumerate(self) -> Vec<usize> {
+            vec![]
+        }
+    }
+    let dummy = Dummy1;
+    for x in dummy.enumerate() {
+        println!("{x}");
+    }
+
+    struct Dummy2;
+    impl Dummy2 {
+        fn enumerate(self) -> Enumerate<std::vec::IntoIter<usize>> {
+            vec![1, 2].into_iter().enumerate()
+        }
+    }
+    let dummy = Dummy2;
+    for (_, x) in dummy.enumerate() {
+        println!("{x}");
+    }
+
+    let mut with_used_iterator = [1, 2, 3].into_iter().enumerate();
+    with_used_iterator.next();
+    for (_, x) in with_used_iterator {
+        println!("{x}");
+    }
+
+    struct Dummy3(std::vec::IntoIter<usize>);
+
+    impl Iterator for Dummy3 {
+        type Item = usize;
+
+        fn next(&mut self) -> Option<Self::Item> {
+            self.0.next()
+        }
+
+        fn size_hint(&self) -> (usize, Option<usize>) {
+            self.0.size_hint()
+        }
+    }
+
+    let dummy = Dummy3(vec![1, 2, 3].into_iter());
+    for x in dummy {
+        println!("{x}");
     }
 }
diff --git a/tests/ui/unused_enumerate_index.rs b/tests/ui/unused_enumerate_index.rs
index d047371f0b9..2d524da7632 100644
--- a/tests/ui/unused_enumerate_index.rs
+++ b/tests/ui/unused_enumerate_index.rs
@@ -1,10 +1,58 @@
-// run-rustfix
 #![allow(unused)]
 #![warn(clippy::unused_enumerate_index)]
 
+use std::iter::Enumerate;
+
 fn main() {
     let v = [1, 2, 3];
     for (_, x) in v.iter().enumerate() {
-        print!("{x}");
+        println!("{x}");
+    }
+
+    struct Dummy1;
+    impl Dummy1 {
+        fn enumerate(self) -> Vec<usize> {
+            vec![]
+        }
+    }
+    let dummy = Dummy1;
+    for x in dummy.enumerate() {
+        println!("{x}");
+    }
+
+    struct Dummy2;
+    impl Dummy2 {
+        fn enumerate(self) -> Enumerate<std::vec::IntoIter<usize>> {
+            vec![1, 2].into_iter().enumerate()
+        }
+    }
+    let dummy = Dummy2;
+    for (_, x) in dummy.enumerate() {
+        println!("{x}");
+    }
+
+    let mut with_used_iterator = [1, 2, 3].into_iter().enumerate();
+    with_used_iterator.next();
+    for (_, x) in with_used_iterator {
+        println!("{x}");
+    }
+
+    struct Dummy3(std::vec::IntoIter<usize>);
+
+    impl Iterator for Dummy3 {
+        type Item = usize;
+
+        fn next(&mut self) -> Option<Self::Item> {
+            self.0.next()
+        }
+
+        fn size_hint(&self) -> (usize, Option<usize>) {
+            self.0.size_hint()
+        }
+    }
+
+    let dummy = Dummy3(vec![1, 2, 3].into_iter());
+    for (_, x) in dummy.enumerate() {
+        println!("{x}");
     }
 }
diff --git a/tests/ui/unused_enumerate_index.stderr b/tests/ui/unused_enumerate_index.stderr
index 7bd9e374151..b575fbbc4e6 100644
--- a/tests/ui/unused_enumerate_index.stderr
+++ b/tests/ui/unused_enumerate_index.stderr
@@ -1,5 +1,5 @@
 error: you seem to use `.enumerate()` and immediately discard the index
-  --> $DIR/unused_enumerate_index.rs:7:19
+  --> $DIR/unused_enumerate_index.rs:8:19
    |
 LL |     for (_, x) in v.iter().enumerate() {
    |                   ^^^^^^^^^^^^^^^^^^^^
@@ -11,5 +11,16 @@ help: remove the `.enumerate()` call
 LL |     for x in v.iter() {
    |         ~    ~~~~~~~~
 
-error: aborting due to previous error
+error: you seem to use `.enumerate()` and immediately discard the index
+  --> $DIR/unused_enumerate_index.rs:55:19
+   |
+LL |     for (_, x) in dummy.enumerate() {
+   |                   ^^^^^^^^^^^^^^^^^
+   |
+help: remove the `.enumerate()` call
+   |
+LL |     for x in dummy {
+   |         ~    ~~~~~
+
+error: aborting due to 2 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From bb9cc6d47c11d33087d5776ecc261b95c6dace74 Mon Sep 17 00:00:00 2001
From: Dinu Blanovschi <git@dnbln.dev>
Date: Wed, 1 Nov 2023 14:10:42 +0100
Subject: refactor: extract common pat_is_wild to clippy_utils

This function was previously defined for the iter_kv_map,
for_kw_map, and unused_enumerate_index lints. This commit extracts
it into clippy_utils.
---
 clippy_lints/src/loops/for_kv_map.rs             | 12 +-----------
 clippy_lints/src/loops/unused_enumerate_index.rs | 12 +-----------
 clippy_lints/src/methods/iter_kv_map.rs          | 13 +------------
 clippy_utils/src/lib.rs                          | 12 ++++++++++++
 4 files changed, 15 insertions(+), 34 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/for_kv_map.rs b/clippy_lints/src/loops/for_kv_map.rs
index ed620460dbe..94c951fc10a 100644
--- a/clippy_lints/src/loops/for_kv_map.rs
+++ b/clippy_lints/src/loops/for_kv_map.rs
@@ -1,9 +1,8 @@
 use super::FOR_KV_MAP;
 use clippy_utils::diagnostics::{multispan_sugg, span_lint_and_then};
 use clippy_utils::source::snippet;
-use clippy_utils::sugg;
 use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::visitors::is_local_used;
+use clippy_utils::{pat_is_wild, sugg};
 use rustc_hir::{BorrowKind, Expr, ExprKind, Mutability, Pat, PatKind};
 use rustc_lint::LateContext;
 use rustc_middle::ty;
@@ -55,12 +54,3 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>, arg: &'tcx
         }
     }
 }
-
-/// Returns `true` if the pattern is a `PatWild` or an ident prefixed with `_`.
-fn pat_is_wild<'tcx>(cx: &LateContext<'tcx>, pat: &'tcx PatKind<'_>, body: &'tcx Expr<'_>) -> bool {
-    match *pat {
-        PatKind::Wild => true,
-        PatKind::Binding(_, id, ident, None) if ident.as_str().starts_with('_') => !is_local_used(cx, body, id),
-        _ => false,
-    }
-}
diff --git a/clippy_lints/src/loops/unused_enumerate_index.rs b/clippy_lints/src/loops/unused_enumerate_index.rs
index 18b73f77e81..62a2ab1ccb4 100644
--- a/clippy_lints/src/loops/unused_enumerate_index.rs
+++ b/clippy_lints/src/loops/unused_enumerate_index.rs
@@ -1,8 +1,7 @@
 use super::UNUSED_ENUMERATE_INDEX;
 use clippy_utils::diagnostics::{multispan_sugg, span_lint_and_then};
 use clippy_utils::source::snippet;
-use clippy_utils::sugg;
-use clippy_utils::visitors::is_local_used;
+use clippy_utils::{pat_is_wild, sugg};
 use rustc_hir::def::DefKind;
 use rustc_hir::{Expr, ExprKind, Pat, PatKind};
 use rustc_lint::LateContext;
@@ -61,12 +60,3 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>, arg: &'tcx
         },
     );
 }
-
-/// Returns `true` if the pattern is a `PatWild` or an ident prefixed with `_`.
-fn pat_is_wild<'tcx>(cx: &LateContext<'tcx>, pat: &'tcx PatKind<'_>, body: &'tcx Expr<'_>) -> bool {
-    match *pat {
-        PatKind::Wild => true,
-        PatKind::Binding(_, id, ident, None) if ident.as_str().starts_with('_') => !is_local_used(cx, body, id),
-        _ => false,
-    }
-}
diff --git a/clippy_lints/src/methods/iter_kv_map.rs b/clippy_lints/src/methods/iter_kv_map.rs
index b44a2716dde..625325d4cf5 100644
--- a/clippy_lints/src/methods/iter_kv_map.rs
+++ b/clippy_lints/src/methods/iter_kv_map.rs
@@ -3,9 +3,8 @@
 use super::ITER_KV_MAP;
 use clippy_utils::diagnostics::{multispan_sugg, span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::{snippet, snippet_with_applicability};
-use clippy_utils::sugg;
 use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::visitors::is_local_used;
+use clippy_utils::{pat_is_wild, sugg};
 use rustc_hir::{BindingAnnotation, Body, BorrowKind, ByRef, Expr, ExprKind, Mutability, Pat, PatKind};
 use rustc_lint::{LateContext, LintContext};
 use rustc_middle::ty;
@@ -84,13 +83,3 @@ pub(super) fn check<'tcx>(
         }
     }
 }
-
-/// Returns `true` if the pattern is a `PatWild`, or is an ident prefixed with `_`
-/// that is not locally used.
-fn pat_is_wild<'tcx>(cx: &LateContext<'tcx>, pat: &'tcx PatKind<'_>, body: &'tcx Expr<'_>) -> bool {
-    match *pat {
-        PatKind::Wild => true,
-        PatKind::Binding(_, id, ident, None) if ident.as_str().starts_with('_') => !is_local_used(cx, body, id),
-        _ => false,
-    }
-}
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 11467138a58..7497d4b2cf1 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -2960,3 +2960,15 @@ op_utils! {
     Shl    ShlAssign
     Shr    ShrAssign
 }
+
+/// Returns `true` if the pattern is a `PatWild`, or is an ident prefixed with `_`
+/// that is not locally used.
+pub fn pat_is_wild<'tcx>(cx: &LateContext<'tcx>, pat: &'tcx PatKind<'_>, body: impl Visitable<'tcx>) -> bool {
+    match *pat {
+        PatKind::Wild => true,
+        PatKind::Binding(_, id, ident, None) if ident.as_str().starts_with('_') => {
+            !visitors::is_local_used(cx, body, id)
+        },
+        _ => false,
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 57a464439ec57d33815f75483b3bc6a6b6712325 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Wed, 1 Nov 2023 16:19:06 +0000
Subject: Fix `dbg_macro` semi span calculation

---
 clippy_lints/src/dbg_macro.rs             |  33 +----
 tests/ui/dbg_macro.rs                     | 107 ---------------
 tests/ui/dbg_macro.stderr                 | 203 ----------------------------
 tests/ui/dbg_macro/auxiliary/submodule.rs |   3 +
 tests/ui/dbg_macro/dbg_macro.rs           | 109 +++++++++++++++
 tests/ui/dbg_macro/dbg_macro.stderr       | 215 ++++++++++++++++++++++++++++++
 6 files changed, 331 insertions(+), 339 deletions(-)
 delete mode 100644 tests/ui/dbg_macro.rs
 delete mode 100644 tests/ui/dbg_macro.stderr
 create mode 100644 tests/ui/dbg_macro/auxiliary/submodule.rs
 create mode 100644 tests/ui/dbg_macro/dbg_macro.rs
 create mode 100644 tests/ui/dbg_macro/dbg_macro.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/dbg_macro.rs b/clippy_lints/src/dbg_macro.rs
index 49452136d6f..4774917c7b5 100644
--- a/clippy_lints/src/dbg_macro.rs
+++ b/clippy_lints/src/dbg_macro.rs
@@ -6,7 +6,7 @@ use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, Node};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::{sym, BytePos, Pos, Span};
+use rustc_span::sym;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -31,31 +31,6 @@ declare_clippy_lint! {
     "`dbg!` macro is intended as a debugging tool"
 }
 
-/// Gets the span of the statement up to the next semicolon, if and only if the next
-/// non-whitespace character actually is a semicolon.
-/// E.g.
-/// ```rust,ignore
-/// 
-///    dbg!();
-///    ^^^^^^^  this span is returned
-///
-///   foo!(dbg!());
-///             no span is returned
-/// ```
-fn span_including_semi(cx: &LateContext<'_>, span: Span) -> Option<Span> {
-    let sm = cx.sess().source_map();
-    let sf = sm.lookup_source_file(span.hi());
-    let src = sf.src.as_ref()?.get(span.hi().to_usize()..)?;
-    let first_non_whitespace = src.find(|c: char| !c.is_whitespace())?;
-
-    if src.as_bytes()[first_non_whitespace] == b';' {
-        let hi = span.hi() + BytePos::from_usize(first_non_whitespace + 1);
-        Some(span.with_hi(hi))
-    } else {
-        None
-    }
-}
-
 #[derive(Copy, Clone)]
 pub struct DbgMacro {
     allow_dbg_in_tests: bool,
@@ -88,10 +63,10 @@ impl LateLintPass<'_> for DbgMacro {
                 ExprKind::Block(..) => {
                     // If the `dbg!` macro is a "free" statement and not contained within other expressions,
                     // remove the whole statement.
-                    if let Some(Node::Stmt(stmt)) = cx.tcx.hir().find_parent(expr.hir_id)
-                        && let Some(span) = span_including_semi(cx, stmt.span.source_callsite())
+                    if let Some(Node::Stmt(_)) = cx.tcx.hir().find_parent(expr.hir_id)
+                        && let Some(semi_span) = cx.sess().source_map().mac_call_stmt_semi_span(macro_call.span)
                     {
-                        (span, String::new())
+                        (macro_call.span.to(semi_span), String::new())
                     } else {
                         (macro_call.span, String::from("()"))
                     }
diff --git a/tests/ui/dbg_macro.rs b/tests/ui/dbg_macro.rs
deleted file mode 100644
index 149b0847619..00000000000
--- a/tests/ui/dbg_macro.rs
+++ /dev/null
@@ -1,107 +0,0 @@
-//@no-rustfix
-
-#![warn(clippy::dbg_macro)]
-
-fn foo(n: u32) -> u32 {
-    if let Some(n) = dbg!(n.checked_sub(4)) { n } else { n }
-    //~^ ERROR: the `dbg!` macro is intended as a debugging tool
-    //~| NOTE: `-D clippy::dbg-macro` implied by `-D warnings`
-}
-fn bar(_: ()) {}
-
-fn factorial(n: u32) -> u32 {
-    if dbg!(n <= 1) {
-        //~^ ERROR: the `dbg!` macro is intended as a debugging tool
-        dbg!(1)
-        //~^ ERROR: the `dbg!` macro is intended as a debugging tool
-    } else {
-        dbg!(n * factorial(n - 1))
-        //~^ ERROR: the `dbg!` macro is intended as a debugging tool
-    }
-}
-
-fn main() {
-    dbg!(42);
-    //~^ ERROR: the `dbg!` macro is intended as a debugging tool
-    dbg!(dbg!(dbg!(42)));
-    //~^ ERROR: the `dbg!` macro is intended as a debugging tool
-    foo(3) + dbg!(factorial(4));
-    //~^ ERROR: the `dbg!` macro is intended as a debugging tool
-    dbg!(1, 2, dbg!(3, 4));
-    //~^ ERROR: the `dbg!` macro is intended as a debugging tool
-    dbg!(1, 2, 3, 4, 5);
-    //~^ ERROR: the `dbg!` macro is intended as a debugging tool
-}
-
-fn issue9914() {
-    macro_rules! foo {
-        ($x:expr) => {
-            $x;
-        };
-    }
-    macro_rules! foo2 {
-        ($x:expr) => {
-            $x;
-        };
-    }
-    macro_rules! expand_to_dbg {
-        () => {
-            dbg!();
-        };
-    }
-
-    dbg!();
-    //~^ ERROR: the `dbg!` macro is intended as a debugging tool
-    #[allow(clippy::let_unit_value)]
-    let _ = dbg!();
-    //~^ ERROR: the `dbg!` macro is intended as a debugging tool
-    bar(dbg!());
-    //~^ ERROR: the `dbg!` macro is intended as a debugging tool
-    foo!(dbg!());
-    //~^ ERROR: the `dbg!` macro is intended as a debugging tool
-    foo2!(foo!(dbg!()));
-    //~^ ERROR: the `dbg!` macro is intended as a debugging tool
-    expand_to_dbg!();
-}
-
-mod issue7274 {
-    trait Thing<'b> {
-        fn foo(&self);
-    }
-
-    macro_rules! define_thing {
-        ($thing:ident, $body:expr) => {
-            impl<'a> Thing<'a> for $thing {
-                fn foo<'b>(&self) {
-                    $body
-                }
-            }
-        };
-    }
-
-    struct MyThing;
-    define_thing!(MyThing, {
-        dbg!(2);
-        //~^ ERROR: the `dbg!` macro is intended as a debugging tool
-    });
-}
-
-#[test]
-pub fn issue8481() {
-    dbg!(1);
-    //~^ ERROR: the `dbg!` macro is intended as a debugging tool
-}
-
-#[cfg(test)]
-fn foo2() {
-    dbg!(1);
-    //~^ ERROR: the `dbg!` macro is intended as a debugging tool
-}
-
-#[cfg(test)]
-mod mod1 {
-    fn func() {
-        dbg!(1);
-        //~^ ERROR: the `dbg!` macro is intended as a debugging tool
-    }
-}
diff --git a/tests/ui/dbg_macro.stderr b/tests/ui/dbg_macro.stderr
deleted file mode 100644
index f45a7ba1fae..00000000000
--- a/tests/ui/dbg_macro.stderr
+++ /dev/null
@@ -1,203 +0,0 @@
-error: the `dbg!` macro is intended as a debugging tool
-  --> $DIR/dbg_macro.rs:6:22
-   |
-LL |     if let Some(n) = dbg!(n.checked_sub(4)) { n } else { n }
-   |                      ^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: `-D clippy::dbg-macro` implied by `-D warnings`
-   = help: to override `-D warnings` add `#[allow(clippy::dbg_macro)]`
-help: remove the invocation before committing it to a version control system
-   |
-LL |     if let Some(n) = n.checked_sub(4) { n } else { n }
-   |                      ~~~~~~~~~~~~~~~~
-
-error: the `dbg!` macro is intended as a debugging tool
-  --> $DIR/dbg_macro.rs:13:8
-   |
-LL |     if dbg!(n <= 1) {
-   |        ^^^^^^^^^^^^
-   |
-help: remove the invocation before committing it to a version control system
-   |
-LL |     if n <= 1 {
-   |        ~~~~~~
-
-error: the `dbg!` macro is intended as a debugging tool
-  --> $DIR/dbg_macro.rs:15:9
-   |
-LL |         dbg!(1)
-   |         ^^^^^^^
-   |
-help: remove the invocation before committing it to a version control system
-   |
-LL |         1
-   |
-
-error: the `dbg!` macro is intended as a debugging tool
-  --> $DIR/dbg_macro.rs:18:9
-   |
-LL |         dbg!(n * factorial(n - 1))
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: remove the invocation before committing it to a version control system
-   |
-LL |         n * factorial(n - 1)
-   |
-
-error: the `dbg!` macro is intended as a debugging tool
-  --> $DIR/dbg_macro.rs:24:5
-   |
-LL |     dbg!(42);
-   |     ^^^^^^^^
-   |
-help: remove the invocation before committing it to a version control system
-   |
-LL |     42;
-   |     ~~
-
-error: the `dbg!` macro is intended as a debugging tool
-  --> $DIR/dbg_macro.rs:26:5
-   |
-LL |     dbg!(dbg!(dbg!(42)));
-   |     ^^^^^^^^^^^^^^^^^^^^
-   |
-help: remove the invocation before committing it to a version control system
-   |
-LL |     dbg!(dbg!(42));
-   |     ~~~~~~~~~~~~~~
-
-error: the `dbg!` macro is intended as a debugging tool
-  --> $DIR/dbg_macro.rs:28:14
-   |
-LL |     foo(3) + dbg!(factorial(4));
-   |              ^^^^^^^^^^^^^^^^^^
-   |
-help: remove the invocation before committing it to a version control system
-   |
-LL |     foo(3) + factorial(4);
-   |              ~~~~~~~~~~~~
-
-error: the `dbg!` macro is intended as a debugging tool
-  --> $DIR/dbg_macro.rs:30:5
-   |
-LL |     dbg!(1, 2, dbg!(3, 4));
-   |     ^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: remove the invocation before committing it to a version control system
-   |
-LL |     (1, 2, dbg!(3, 4));
-   |     ~~~~~~~~~~~~~~~~~~
-
-error: the `dbg!` macro is intended as a debugging tool
-  --> $DIR/dbg_macro.rs:32:5
-   |
-LL |     dbg!(1, 2, 3, 4, 5);
-   |     ^^^^^^^^^^^^^^^^^^^
-   |
-help: remove the invocation before committing it to a version control system
-   |
-LL |     (1, 2, 3, 4, 5);
-   |     ~~~~~~~~~~~~~~~
-
-error: the `dbg!` macro is intended as a debugging tool
-  --> $DIR/dbg_macro.rs:53:5
-   |
-LL |     dbg!();
-   |     ^^^^^^^
-   |
-help: remove the invocation before committing it to a version control system
-   |
-LL -     dbg!();
-LL +     
-   |
-
-error: the `dbg!` macro is intended as a debugging tool
-  --> $DIR/dbg_macro.rs:56:13
-   |
-LL |     let _ = dbg!();
-   |             ^^^^^^
-   |
-help: remove the invocation before committing it to a version control system
-   |
-LL |     let _ = ();
-   |             ~~
-
-error: the `dbg!` macro is intended as a debugging tool
-  --> $DIR/dbg_macro.rs:58:9
-   |
-LL |     bar(dbg!());
-   |         ^^^^^^
-   |
-help: remove the invocation before committing it to a version control system
-   |
-LL |     bar(());
-   |         ~~
-
-error: the `dbg!` macro is intended as a debugging tool
-  --> $DIR/dbg_macro.rs:60:10
-   |
-LL |     foo!(dbg!());
-   |          ^^^^^^
-   |
-help: remove the invocation before committing it to a version control system
-   |
-LL |     foo!(());
-   |          ~~
-
-error: the `dbg!` macro is intended as a debugging tool
-  --> $DIR/dbg_macro.rs:62:16
-   |
-LL |     foo2!(foo!(dbg!()));
-   |                ^^^^^^
-   |
-help: remove the invocation before committing it to a version control system
-   |
-LL |     foo2!(foo!(()));
-   |                ~~
-
-error: the `dbg!` macro is intended as a debugging tool
-  --> $DIR/dbg_macro.rs:84:9
-   |
-LL |         dbg!(2);
-   |         ^^^^^^^
-   |
-help: remove the invocation before committing it to a version control system
-   |
-LL |         2;
-   |         ~
-
-error: the `dbg!` macro is intended as a debugging tool
-  --> $DIR/dbg_macro.rs:91:5
-   |
-LL |     dbg!(1);
-   |     ^^^^^^^
-   |
-help: remove the invocation before committing it to a version control system
-   |
-LL |     1;
-   |     ~
-
-error: the `dbg!` macro is intended as a debugging tool
-  --> $DIR/dbg_macro.rs:97:5
-   |
-LL |     dbg!(1);
-   |     ^^^^^^^
-   |
-help: remove the invocation before committing it to a version control system
-   |
-LL |     1;
-   |     ~
-
-error: the `dbg!` macro is intended as a debugging tool
-  --> $DIR/dbg_macro.rs:104:9
-   |
-LL |         dbg!(1);
-   |         ^^^^^^^
-   |
-help: remove the invocation before committing it to a version control system
-   |
-LL |         1;
-   |         ~
-
-error: aborting due to 18 previous errors
-
diff --git a/tests/ui/dbg_macro/auxiliary/submodule.rs b/tests/ui/dbg_macro/auxiliary/submodule.rs
new file mode 100644
index 00000000000..b1df24737a2
--- /dev/null
+++ b/tests/ui/dbg_macro/auxiliary/submodule.rs
@@ -0,0 +1,3 @@
+fn f() {
+    dbg!();
+}
diff --git a/tests/ui/dbg_macro/dbg_macro.rs b/tests/ui/dbg_macro/dbg_macro.rs
new file mode 100644
index 00000000000..3f4770c63d0
--- /dev/null
+++ b/tests/ui/dbg_macro/dbg_macro.rs
@@ -0,0 +1,109 @@
+//@no-rustfix
+
+#![warn(clippy::dbg_macro)]
+
+#[path = "auxiliary/submodule.rs"]
+mod submodule;
+
+fn foo(n: u32) -> u32 {
+    if let Some(n) = dbg!(n.checked_sub(4)) { n } else { n }
+    //~^ ERROR: the `dbg!` macro is intended as a debugging tool
+}
+fn bar(_: ()) {}
+
+fn factorial(n: u32) -> u32 {
+    if dbg!(n <= 1) {
+        //~^ ERROR: the `dbg!` macro is intended as a debugging tool
+        dbg!(1)
+        //~^ ERROR: the `dbg!` macro is intended as a debugging tool
+    } else {
+        dbg!(n * factorial(n - 1))
+        //~^ ERROR: the `dbg!` macro is intended as a debugging tool
+    }
+}
+
+fn main() {
+    dbg!(42);
+    //~^ ERROR: the `dbg!` macro is intended as a debugging tool
+    dbg!(dbg!(dbg!(42)));
+    //~^ ERROR: the `dbg!` macro is intended as a debugging tool
+    foo(3) + dbg!(factorial(4));
+    //~^ ERROR: the `dbg!` macro is intended as a debugging tool
+    dbg!(1, 2, dbg!(3, 4));
+    //~^ ERROR: the `dbg!` macro is intended as a debugging tool
+    dbg!(1, 2, 3, 4, 5);
+    //~^ ERROR: the `dbg!` macro is intended as a debugging tool
+}
+
+fn issue9914() {
+    macro_rules! foo {
+        ($x:expr) => {
+            $x;
+        };
+    }
+    macro_rules! foo2 {
+        ($x:expr) => {
+            $x;
+        };
+    }
+    macro_rules! expand_to_dbg {
+        () => {
+            dbg!();
+        };
+    }
+
+    dbg!();
+    //~^ ERROR: the `dbg!` macro is intended as a debugging tool
+    #[allow(clippy::let_unit_value)]
+    let _ = dbg!();
+    //~^ ERROR: the `dbg!` macro is intended as a debugging tool
+    bar(dbg!());
+    //~^ ERROR: the `dbg!` macro is intended as a debugging tool
+    foo!(dbg!());
+    //~^ ERROR: the `dbg!` macro is intended as a debugging tool
+    foo2!(foo!(dbg!()));
+    //~^ ERROR: the `dbg!` macro is intended as a debugging tool
+    expand_to_dbg!();
+}
+
+mod issue7274 {
+    trait Thing<'b> {
+        fn foo(&self);
+    }
+
+    macro_rules! define_thing {
+        ($thing:ident, $body:expr) => {
+            impl<'a> Thing<'a> for $thing {
+                fn foo<'b>(&self) {
+                    $body
+                }
+            }
+        };
+    }
+
+    struct MyThing;
+    define_thing!(MyThing, {
+        dbg!(2);
+        //~^ ERROR: the `dbg!` macro is intended as a debugging tool
+    });
+}
+
+#[test]
+pub fn issue8481() {
+    dbg!(1);
+    //~^ ERROR: the `dbg!` macro is intended as a debugging tool
+}
+
+#[cfg(test)]
+fn foo2() {
+    dbg!(1);
+    //~^ ERROR: the `dbg!` macro is intended as a debugging tool
+}
+
+#[cfg(test)]
+mod mod1 {
+    fn func() {
+        dbg!(1);
+        //~^ ERROR: the `dbg!` macro is intended as a debugging tool
+    }
+}
diff --git a/tests/ui/dbg_macro/dbg_macro.stderr b/tests/ui/dbg_macro/dbg_macro.stderr
new file mode 100644
index 00000000000..4d00421c711
--- /dev/null
+++ b/tests/ui/dbg_macro/dbg_macro.stderr
@@ -0,0 +1,215 @@
+error: the `dbg!` macro is intended as a debugging tool
+  --> $DIR/auxiliary/submodule.rs:2:5
+   |
+LL |     dbg!();
+   |     ^^^^^^^
+   |
+   = note: `-D clippy::dbg-macro` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::dbg_macro)]`
+help: remove the invocation before committing it to a version control system
+   |
+LL -     dbg!();
+LL +     
+   |
+
+error: the `dbg!` macro is intended as a debugging tool
+  --> $DIR/dbg_macro.rs:9:22
+   |
+LL |     if let Some(n) = dbg!(n.checked_sub(4)) { n } else { n }
+   |                      ^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the invocation before committing it to a version control system
+   |
+LL |     if let Some(n) = n.checked_sub(4) { n } else { n }
+   |                      ~~~~~~~~~~~~~~~~
+
+error: the `dbg!` macro is intended as a debugging tool
+  --> $DIR/dbg_macro.rs:15:8
+   |
+LL |     if dbg!(n <= 1) {
+   |        ^^^^^^^^^^^^
+   |
+help: remove the invocation before committing it to a version control system
+   |
+LL |     if n <= 1 {
+   |        ~~~~~~
+
+error: the `dbg!` macro is intended as a debugging tool
+  --> $DIR/dbg_macro.rs:17:9
+   |
+LL |         dbg!(1)
+   |         ^^^^^^^
+   |
+help: remove the invocation before committing it to a version control system
+   |
+LL |         1
+   |
+
+error: the `dbg!` macro is intended as a debugging tool
+  --> $DIR/dbg_macro.rs:20:9
+   |
+LL |         dbg!(n * factorial(n - 1))
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the invocation before committing it to a version control system
+   |
+LL |         n * factorial(n - 1)
+   |
+
+error: the `dbg!` macro is intended as a debugging tool
+  --> $DIR/dbg_macro.rs:26:5
+   |
+LL |     dbg!(42);
+   |     ^^^^^^^^
+   |
+help: remove the invocation before committing it to a version control system
+   |
+LL |     42;
+   |     ~~
+
+error: the `dbg!` macro is intended as a debugging tool
+  --> $DIR/dbg_macro.rs:28:5
+   |
+LL |     dbg!(dbg!(dbg!(42)));
+   |     ^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the invocation before committing it to a version control system
+   |
+LL |     dbg!(dbg!(42));
+   |     ~~~~~~~~~~~~~~
+
+error: the `dbg!` macro is intended as a debugging tool
+  --> $DIR/dbg_macro.rs:30:14
+   |
+LL |     foo(3) + dbg!(factorial(4));
+   |              ^^^^^^^^^^^^^^^^^^
+   |
+help: remove the invocation before committing it to a version control system
+   |
+LL |     foo(3) + factorial(4);
+   |              ~~~~~~~~~~~~
+
+error: the `dbg!` macro is intended as a debugging tool
+  --> $DIR/dbg_macro.rs:32:5
+   |
+LL |     dbg!(1, 2, dbg!(3, 4));
+   |     ^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the invocation before committing it to a version control system
+   |
+LL |     (1, 2, dbg!(3, 4));
+   |     ~~~~~~~~~~~~~~~~~~
+
+error: the `dbg!` macro is intended as a debugging tool
+  --> $DIR/dbg_macro.rs:34:5
+   |
+LL |     dbg!(1, 2, 3, 4, 5);
+   |     ^^^^^^^^^^^^^^^^^^^
+   |
+help: remove the invocation before committing it to a version control system
+   |
+LL |     (1, 2, 3, 4, 5);
+   |     ~~~~~~~~~~~~~~~
+
+error: the `dbg!` macro is intended as a debugging tool
+  --> $DIR/dbg_macro.rs:55:5
+   |
+LL |     dbg!();
+   |     ^^^^^^^
+   |
+help: remove the invocation before committing it to a version control system
+   |
+LL -     dbg!();
+LL +     
+   |
+
+error: the `dbg!` macro is intended as a debugging tool
+  --> $DIR/dbg_macro.rs:58:13
+   |
+LL |     let _ = dbg!();
+   |             ^^^^^^
+   |
+help: remove the invocation before committing it to a version control system
+   |
+LL |     let _ = ();
+   |             ~~
+
+error: the `dbg!` macro is intended as a debugging tool
+  --> $DIR/dbg_macro.rs:60:9
+   |
+LL |     bar(dbg!());
+   |         ^^^^^^
+   |
+help: remove the invocation before committing it to a version control system
+   |
+LL |     bar(());
+   |         ~~
+
+error: the `dbg!` macro is intended as a debugging tool
+  --> $DIR/dbg_macro.rs:62:10
+   |
+LL |     foo!(dbg!());
+   |          ^^^^^^
+   |
+help: remove the invocation before committing it to a version control system
+   |
+LL |     foo!(());
+   |          ~~
+
+error: the `dbg!` macro is intended as a debugging tool
+  --> $DIR/dbg_macro.rs:64:16
+   |
+LL |     foo2!(foo!(dbg!()));
+   |                ^^^^^^
+   |
+help: remove the invocation before committing it to a version control system
+   |
+LL |     foo2!(foo!(()));
+   |                ~~
+
+error: the `dbg!` macro is intended as a debugging tool
+  --> $DIR/dbg_macro.rs:86:9
+   |
+LL |         dbg!(2);
+   |         ^^^^^^^
+   |
+help: remove the invocation before committing it to a version control system
+   |
+LL |         2;
+   |         ~
+
+error: the `dbg!` macro is intended as a debugging tool
+  --> $DIR/dbg_macro.rs:93:5
+   |
+LL |     dbg!(1);
+   |     ^^^^^^^
+   |
+help: remove the invocation before committing it to a version control system
+   |
+LL |     1;
+   |     ~
+
+error: the `dbg!` macro is intended as a debugging tool
+  --> $DIR/dbg_macro.rs:99:5
+   |
+LL |     dbg!(1);
+   |     ^^^^^^^
+   |
+help: remove the invocation before committing it to a version control system
+   |
+LL |     1;
+   |     ~
+
+error: the `dbg!` macro is intended as a debugging tool
+  --> $DIR/dbg_macro.rs:106:9
+   |
+LL |         dbg!(1);
+   |         ^^^^^^^
+   |
+help: remove the invocation before committing it to a version control system
+   |
+LL |         1;
+   |         ~
+
+error: aborting due to 19 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 3b759bce9d01c27d776af54bc69784c79af06048 Mon Sep 17 00:00:00 2001
From: Matthias Richter <matthias.ri97@gmail.com>
Date: Wed, 1 Nov 2023 23:26:43 +0100
Subject: fix get_first false negative for VecDeque

---
 clippy_lints/src/methods/get_first.rs | 22 ++++++++++++++++++++++
 tests/ui/get_first.fixed              |  5 ++++-
 tests/ui/get_first.rs                 |  5 ++++-
 tests/ui/get_first.stderr             | 10 ++++++++--
 4 files changed, 38 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/get_first.rs b/clippy_lints/src/methods/get_first.rs
index e7b4564c651..855246d8c9f 100644
--- a/clippy_lints/src/methods/get_first.rs
+++ b/clippy_lints/src/methods/get_first.rs
@@ -1,11 +1,13 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::ty::is_type_diagnostic_item;
 use if_chain::if_chain;
 use rustc_ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
 use rustc_span::source_map::Spanned;
+use rustc_span::sym;
 
 use super::GET_FIRST;
 
@@ -34,4 +36,24 @@ pub(super) fn check<'tcx>(
             );
         }
     }
+
+    if_chain! {
+        if let Some(method_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
+        if let Some(impl_id) = cx.tcx.impl_of_method(method_id);
+        if is_type_diagnostic_item(cx, cx.tcx.type_of(impl_id).instantiate_identity(), sym::VecDeque);
+        if let hir::ExprKind::Lit(Spanned { node: LitKind::Int(0, _), .. }) = arg.kind;
+        then {
+            let mut app = Applicability::MachineApplicable;
+                    let slice_name = snippet_with_applicability(cx, recv.span, "..", &mut app);
+                    span_lint_and_sugg(
+                        cx,
+                        GET_FIRST,
+                        expr.span,
+                        &format!("accessing first element with `{slice_name}.get(0)`"),
+                        "try",
+                        format!("{slice_name}.front()"),
+                        app,
+                    );
+        }
+    }
 }
diff --git a/tests/ui/get_first.fixed b/tests/ui/get_first.fixed
index a7cdd2a93ba..710ebab1ef2 100644
--- a/tests/ui/get_first.fixed
+++ b/tests/ui/get_first.fixed
@@ -32,9 +32,12 @@ fn main() {
     let _ = z[0];
 
     let vecdeque: VecDeque<_> = x.iter().cloned().collect();
+    let _ = vecdeque.front();
+    //~^ ERROR: accessing first element with `vecdeque.get(0)`
+    let _ = vecdeque.get(1);
+
     let hashmap: HashMap<u8, char> = HashMap::from_iter(vec![(0, 'a'), (1, 'b')]);
     let btreemap: BTreeMap<u8, char> = BTreeMap::from_iter(vec![(0, 'a'), (1, 'b')]);
-    let _ = vecdeque.get(0); // Do not lint, because VecDeque is not slice.
     let _ = hashmap.get(&0); // Do not lint, because HashMap is not slice.
     let _ = btreemap.get(&0); // Do not lint, because BTreeMap is not slice.
 
diff --git a/tests/ui/get_first.rs b/tests/ui/get_first.rs
index cca743c4bf5..ad2ba6ce2c3 100644
--- a/tests/ui/get_first.rs
+++ b/tests/ui/get_first.rs
@@ -32,9 +32,12 @@ fn main() {
     let _ = z[0];
 
     let vecdeque: VecDeque<_> = x.iter().cloned().collect();
+    let _ = vecdeque.get(0);
+    //~^ ERROR: accessing first element with `vecdeque.get(0)`
+    let _ = vecdeque.get(1);
+
     let hashmap: HashMap<u8, char> = HashMap::from_iter(vec![(0, 'a'), (1, 'b')]);
     let btreemap: BTreeMap<u8, char> = BTreeMap::from_iter(vec![(0, 'a'), (1, 'b')]);
-    let _ = vecdeque.get(0); // Do not lint, because VecDeque is not slice.
     let _ = hashmap.get(&0); // Do not lint, because HashMap is not slice.
     let _ = btreemap.get(&0); // Do not lint, because BTreeMap is not slice.
 
diff --git a/tests/ui/get_first.stderr b/tests/ui/get_first.stderr
index 8ee66e33cc8..7474a2ada66 100644
--- a/tests/ui/get_first.stderr
+++ b/tests/ui/get_first.stderr
@@ -19,11 +19,17 @@ error: accessing first element with `z.get(0)`
 LL |     let _ = z.get(0);
    |             ^^^^^^^^ help: try: `z.first()`
 
+error: accessing first element with `vecdeque.get(0)`
+  --> $DIR/get_first.rs:35:13
+   |
+LL |     let _ = vecdeque.get(0);
+   |             ^^^^^^^^^^^^^^^ help: try: `vecdeque.front()`
+
 error: accessing first element with `non_primitives.get(0)`
-  --> $DIR/get_first.rs:45:13
+  --> $DIR/get_first.rs:48:13
    |
 LL |     let _ = non_primitives.get(0);
    |             ^^^^^^^^^^^^^^^^^^^^^ help: try: `non_primitives.first()`
 
-error: aborting due to 4 previous errors
+error: aborting due to 5 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 61c76dd4ffd8c96acb45bfcd290f95ae0938513e Mon Sep 17 00:00:00 2001
From: Matthias Richter <matthias.ri97@gmail.com>
Date: Wed, 1 Nov 2023 23:35:28 +0100
Subject: remove code duplication

---
 clippy_lints/src/methods/get_first.rs | 38 +++++++++++++++--------------------
 1 file changed, 16 insertions(+), 22 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/get_first.rs b/clippy_lints/src/methods/get_first.rs
index 855246d8c9f..2e1dd3ec649 100644
--- a/clippy_lints/src/methods/get_first.rs
+++ b/clippy_lints/src/methods/get_first.rs
@@ -20,30 +20,23 @@ pub(super) fn check<'tcx>(
     if_chain! {
         if let Some(method_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
         if let Some(impl_id) = cx.tcx.impl_of_method(method_id);
-        if cx.tcx.type_of(impl_id).instantiate_identity().is_slice();
+        let identity = cx.tcx.type_of(impl_id).instantiate_identity();
         if let hir::ExprKind::Lit(Spanned { node: LitKind::Int(0, _), .. }) = arg.kind;
         then {
-            let mut app = Applicability::MachineApplicable;
-            let slice_name = snippet_with_applicability(cx, recv.span, "..", &mut app);
-            span_lint_and_sugg(
-                cx,
-                GET_FIRST,
-                expr.span,
-                &format!("accessing first element with `{slice_name}.get(0)`"),
-                "try",
-                format!("{slice_name}.first()"),
-                app,
-            );
-        }
-    }
-
-    if_chain! {
-        if let Some(method_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
-        if let Some(impl_id) = cx.tcx.impl_of_method(method_id);
-        if is_type_diagnostic_item(cx, cx.tcx.type_of(impl_id).instantiate_identity(), sym::VecDeque);
-        if let hir::ExprKind::Lit(Spanned { node: LitKind::Int(0, _), .. }) = arg.kind;
-        then {
-            let mut app = Applicability::MachineApplicable;
+            if identity.is_slice() {
+                let mut app = Applicability::MachineApplicable;
+                let slice_name = snippet_with_applicability(cx, recv.span, "..", &mut app);
+                span_lint_and_sugg(
+                    cx,
+                    GET_FIRST,
+                    expr.span,
+                    &format!("accessing first element with `{slice_name}.get(0)`"),
+                    "try",
+                    format!("{slice_name}.first()"),
+                    app,
+                );
+            } else if is_type_diagnostic_item(cx, identity, sym::VecDeque){
+                    let mut app = Applicability::MachineApplicable;
                     let slice_name = snippet_with_applicability(cx, recv.span, "..", &mut app);
                     span_lint_and_sugg(
                         cx,
@@ -54,6 +47,7 @@ pub(super) fn check<'tcx>(
                         format!("{slice_name}.front()"),
                         app,
                     );
+            }
         }
     }
 }
-- 
cgit 1.4.1-3-g733a5


From 62a82b361c02838afdf607d461726e0407f1a5ec Mon Sep 17 00:00:00 2001
From: Philipp Krones <hello@philkrones.com>
Date: Thu, 2 Nov 2023 17:12:25 +0100
Subject: Format let-chains across the code base

In the updated nightly version, it seems that rustfmt now supports formatting
let-chains. Since we're using them a lot, it's a lot of reformatting.
---
 clippy_lints/src/almost_complete_range.rs          |  25 +--
 clippy_lints/src/arc_with_non_send_sync.rs         |  24 +--
 clippy_lints/src/assertions_on_result_states.rs    |   6 +-
 clippy_lints/src/async_yields_async.rs             |   2 +-
 clippy_lints/src/attrs.rs                          |  35 +++-
 clippy_lints/src/await_holding_invalid.rs          |   2 +-
 clippy_lints/src/bool_to_int_with_if.rs            |  25 +--
 clippy_lints/src/booleans.rs                       |  13 +-
 clippy_lints/src/box_default.rs                    |  15 +-
 clippy_lints/src/casts/as_ptr_cast_mut.rs          |  17 +-
 clippy_lints/src/casts/cast_ptr_alignment.rs       |   9 +-
 clippy_lints/src/casts/unnecessary_cast.rs         |  17 +-
 clippy_lints/src/default_instead_of_iter_empty.rs  |   5 +-
 clippy_lints/src/dereference.rs                    |  45 +++--
 clippy_lints/src/doc.rs                            |  13 +-
 clippy_lints/src/drop_forget_ref.rs                |   8 +-
 clippy_lints/src/empty_structs_with_brackets.rs    |   8 +-
 clippy_lints/src/equatable_if_let.rs               |   7 +-
 clippy_lints/src/error_impl_error.rs               |  28 +--
 clippy_lints/src/eta_reduction.rs                  |  66 +++----
 clippy_lints/src/excessive_bools.rs                |   9 +-
 clippy_lints/src/explicit_write.rs                 |  17 +-
 clippy_lints/src/extra_unused_type_parameters.rs   |  28 +--
 clippy_lints/src/format.rs                         |   9 +-
 clippy_lints/src/format_args.rs                    |   2 +-
 clippy_lints/src/format_push_string.rs             |  12 +-
 clippy_lints/src/from_over_into.rs                 |   8 +-
 clippy_lints/src/from_raw_with_void_ptr.rs         |  22 ++-
 clippy_lints/src/functions/must_use.rs             |   7 +-
 clippy_lints/src/functions/result.rs               |   4 +-
 clippy_lints/src/if_then_some_else_none.rs         |  15 +-
 clippy_lints/src/implied_bounds_in_impls.rs        |  78 ++++----
 clippy_lints/src/items_after_test_module.rs        |   9 +-
 clippy_lints/src/iter_without_into_iter.rs         |  32 ++--
 clippy_lints/src/large_stack_arrays.rs             |  52 ++---
 clippy_lints/src/len_zero.rs                       |  35 ++--
 clippy_lints/src/let_underscore.rs                 |  19 +-
 clippy_lints/src/lifetimes.rs                      |   8 +-
 clippy_lints/src/lines_filter_map_ok.rs            |  49 +++--
 clippy_lints/src/loops/explicit_iter_loop.rs       |  38 ++--
 clippy_lints/src/loops/never_loop.rs               |   6 +-
 clippy_lints/src/manual_assert.rs                  |  14 +-
 clippy_lints/src/manual_async_fn.rs                |   2 +-
 clippy_lints/src/manual_clamp.rs                   |  70 +++----
 clippy_lints/src/manual_float_methods.rs           |  74 ++++---
 clippy_lints/src/manual_hash_one.rs                |   5 +-
 clippy_lints/src/manual_is_ascii_check.rs          |  14 +-
 clippy_lints/src/manual_let_else.rs                |  37 ++--
 clippy_lints/src/manual_main_separator_str.rs      |  42 ++--
 clippy_lints/src/manual_non_exhaustive.rs          |   2 +-
 clippy_lints/src/manual_rem_euclid.rs              |  45 ++---
 clippy_lints/src/manual_retain.rs                  |  44 +++--
 clippy_lints/src/manual_string_new.rs              |  29 ++-
 clippy_lints/src/matches/manual_filter.rs          |  20 +-
 clippy_lints/src/matches/redundant_guards.rs       |  39 +---
 clippy_lints/src/matches/single_match.rs           |   3 +-
 clippy_lints/src/methods/bytes_nth.rs              |  11 +-
 clippy_lints/src/methods/filter_map.rs             |  30 +--
 clippy_lints/src/methods/filter_map_bool_then.rs   |   2 +-
 clippy_lints/src/methods/format_collect.rs         |  16 +-
 clippy_lints/src/methods/get_unwrap.rs             |   6 +-
 clippy_lints/src/methods/iter_out_of_bounds.rs     |   2 +-
 clippy_lints/src/methods/iter_overeager_cloned.rs  |  88 ++++-----
 clippy_lints/src/methods/manual_try_fold.rs        |   2 +-
 clippy_lints/src/methods/mod.rs                    | 212 ++++++++++++++-------
 clippy_lints/src/methods/needless_collect.rs       |  37 ++--
 clippy_lints/src/methods/or_fun_call.rs            |   6 +-
 clippy_lints/src/methods/path_ends_with_ext.rs     |   2 +-
 clippy_lints/src/methods/read_line_without_trim.rs |   9 +-
 clippy_lints/src/methods/readonly_write_lock.rs    |  21 +-
 clippy_lints/src/methods/seek_from_current.rs      |  18 +-
 .../src/methods/seek_to_start_instead_of_rewind.rs |  18 +-
 clippy_lints/src/methods/str_splitn.rs             |  16 +-
 clippy_lints/src/methods/string_lit_chars_any.rs   |   2 +-
 .../src/methods/suspicious_command_arg_space.rs    |   7 +-
 clippy_lints/src/methods/type_id_on_box.rs         |   4 +-
 .../methods/unnecessary_fallible_conversions.rs    |  29 +--
 .../src/methods/unnecessary_literal_unwrap.rs      |   2 +-
 clippy_lints/src/methods/unnecessary_to_owned.rs   |  87 +++++----
 clippy_lints/src/min_ident_chars.rs                |   8 +-
 clippy_lints/src/misc.rs                           |   2 +-
 clippy_lints/src/missing_asserts_for_indexing.rs   |  23 ++-
 clippy_lints/src/needless_bool.rs                  |   8 +-
 .../src/needless_borrows_for_generic_args.rs       |  37 ++--
 .../src/needless_parens_on_range_literals.rs       |   6 +-
 clippy_lints/src/needless_pass_by_ref_mut.rs       |  11 +-
 clippy_lints/src/needless_question_mark.rs         |   2 +-
 clippy_lints/src/no_effect.rs                      |  11 +-
 clippy_lints/src/no_mangle_with_rust_abi.rs        |   3 +-
 clippy_lints/src/non_canonical_impls.rs            |  25 +--
 clippy_lints/src/only_used_in_recursion.rs         |  15 +-
 .../src/operators/arithmetic_side_effects.rs       |  16 +-
 clippy_lints/src/operators/eq_op.rs                |  19 +-
 clippy_lints/src/option_env_unwrap.rs              |  23 ++-
 clippy_lints/src/option_if_let_else.rs             |   2 +-
 clippy_lints/src/pass_by_ref_or_value.rs           |   5 +-
 clippy_lints/src/permissions_set_readonly_false.rs |   8 +-
 clippy_lints/src/ptr.rs                            | 185 +++++++++---------
 clippy_lints/src/pub_use.rs                        |  23 +--
 clippy_lints/src/question_mark.rs                  |  19 +-
 clippy_lints/src/read_zero_byte_vec.rs             |  23 ++-
 clippy_lints/src/redundant_async_block.rs          |  24 +--
 clippy_lints/src/redundant_closure_call.rs         |  21 +-
 clippy_lints/src/redundant_type_annotations.rs     |  20 +-
 clippy_lints/src/ref_patterns.rs                   |   2 +-
 clippy_lints/src/reserve_after_initialization.rs   |  37 ++--
 clippy_lints/src/same_name_method.rs               |  14 +-
 clippy_lints/src/significant_drop_tightening.rs    |  33 ++--
 clippy_lints/src/std_instead_of_core.rs            |  21 +-
 clippy_lints/src/suspicious_xor_used_as_pow.rs     |  29 ++-
 clippy_lints/src/swap.rs                           |   2 +-
 clippy_lints/src/swap_ptr_to_ref.rs                |  14 +-
 .../src/transmute/transmute_undefined_repr.rs      |  22 +--
 clippy_lints/src/transmute/transmuting_null.rs     |  12 +-
 clippy_lints/src/undocumented_unsafe_blocks.rs     |  16 +-
 clippy_lints/src/unit_types/let_unit_value.rs      |  11 +-
 clippy_lints/src/unnecessary_map_on_constructor.rs |  30 +--
 .../src/unnecessary_struct_initialization.rs       |  16 +-
 clippy_lints/src/unused_peekable.rs                |  10 +-
 clippy_lints/src/unused_rounding.rs                |  19 +-
 clippy_lints/src/useless_conversion.rs             |  65 ++++---
 .../utils/internal_lints/lint_without_lint_pass.rs |   5 +-
 .../utils/internal_lints/unnecessary_def_path.rs   |   3 +-
 clippy_lints/src/vec.rs                            |   5 +-
 clippy_lints/src/vec_init_then_push.rs             |   2 +-
 clippy_lints/src/visibility.rs                     |   4 +-
 clippy_lints/src/write.rs                          |  15 +-
 clippy_utils/src/check_proc_macro.rs               |   4 +-
 clippy_utils/src/consts.rs                         |  22 ++-
 clippy_utils/src/hir_utils.rs                      |   8 +-
 clippy_utils/src/lib.rs                            |  88 ++++-----
 clippy_utils/src/source.rs                         |   6 +-
 clippy_utils/src/ty.rs                             |  22 ++-
 clippy_utils/src/ty/type_certainty/mod.rs          |   4 +-
 src/driver.rs                                      |   6 +-
 tests/ui/auxiliary/proc_macros.rs                  |  10 +-
 tests/ui/bool_to_int_with_if.fixed                 |   8 +-
 tests/ui/bool_to_int_with_if.rs                    |   8 +-
 tests/ui/bool_to_int_with_if.stderr                |   2 +-
 tests/ui/comparison_to_empty.fixed                 |   8 +-
 tests/ui/comparison_to_empty.rs                    |   8 +-
 tests/ui/comparison_to_empty.stderr                |   8 +-
 tests/ui/manual_filter.rs                          |   4 +-
 tests/ui/manual_filter.stderr                      |   6 +-
 tests/ui/manual_let_else.rs                        |   4 +-
 tests/ui/manual_let_else.stderr                    |  48 ++---
 tests/ui/manual_map_option_2.fixed                 |   4 +-
 tests/ui/manual_map_option_2.rs                    |   4 +-
 tests/ui/manual_map_option_2.stderr                |  19 +-
 tests/ui/needless_if.fixed                         |  16 +-
 tests/ui/needless_if.rs                            |  16 +-
 tests/ui/needless_if.stderr                        |  21 +-
 tests/ui/needless_late_init.fixed                  |   4 +-
 tests/ui/needless_late_init.rs                     |   4 +-
 tests/ui/redundant_guards.fixed                    |   2 +-
 tests/ui/redundant_guards.rs                       |   2 +-
 tests/ui/redundant_pattern_matching_option.fixed   |  13 +-
 tests/ui/redundant_pattern_matching_option.rs      |  13 +-
 tests/ui/redundant_pattern_matching_option.stderr  |  56 +++---
 159 files changed, 1799 insertions(+), 1471 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/almost_complete_range.rs b/clippy_lints/src/almost_complete_range.rs
index 82c6712506d..e85878eb570 100644
--- a/clippy_lints/src/almost_complete_range.rs
+++ b/clippy_lints/src/almost_complete_range.rs
@@ -82,33 +82,20 @@ fn check_range(cx: &EarlyContext<'_>, span: Span, start: &Expr, end: &Expr, sugg
             (
                 Ok(LitKind::Byte(b'a') | LitKind::Char('a')),
                 Ok(LitKind::Byte(b'z') | LitKind::Char('z'))
-            )
-            | (
+            ) | (
                 Ok(LitKind::Byte(b'A') | LitKind::Char('A')),
                 Ok(LitKind::Byte(b'Z') | LitKind::Char('Z')),
-            )
-            | (
+            ) | (
                 Ok(LitKind::Byte(b'0') | LitKind::Char('0')),
                 Ok(LitKind::Byte(b'9') | LitKind::Char('9')),
             )
         )
         && !in_external_macro(cx.sess(), span)
     {
-        span_lint_and_then(
-            cx,
-            ALMOST_COMPLETE_RANGE,
-            span,
-            "almost complete ascii range",
-            |diag| {
-                if let Some((span, sugg)) = sugg {
-                    diag.span_suggestion(
-                        span,
-                        "use an inclusive range",
-                        sugg,
-                        Applicability::MaybeIncorrect,
-                    );
-                }
+        span_lint_and_then(cx, ALMOST_COMPLETE_RANGE, span, "almost complete ascii range", |diag| {
+            if let Some((span, sugg)) = sugg {
+                diag.span_suggestion(span, "use an inclusive range", sugg, Applicability::MaybeIncorrect);
             }
-        );
+        });
     }
 }
diff --git a/clippy_lints/src/arc_with_non_send_sync.rs b/clippy_lints/src/arc_with_non_send_sync.rs
index 40e8281b260..192bc7d9ddc 100644
--- a/clippy_lints/src/arc_with_non_send_sync.rs
+++ b/clippy_lints/src/arc_with_non_send_sync.rs
@@ -62,19 +62,21 @@ impl<'tcx> LateLintPass<'tcx> for ArcWithNonSendSync {
                 ARC_WITH_NON_SEND_SYNC,
                 expr.span,
                 "usage of an `Arc` that is not `Send` or `Sync`",
-                |diag| with_forced_trimmed_paths!({
-                    if !is_send {
-                        diag.note(format!("the trait `Send` is not implemented for `{arg_ty}`"));
-                    }
-                    if !is_sync {
-                        diag.note(format!("the trait `Sync` is not implemented for `{arg_ty}`"));
-                    }
+                |diag| {
+                    with_forced_trimmed_paths!({
+                        if !is_send {
+                            diag.note(format!("the trait `Send` is not implemented for `{arg_ty}`"));
+                        }
+                        if !is_sync {
+                            diag.note(format!("the trait `Sync` is not implemented for `{arg_ty}`"));
+                        }
 
-                    diag.note(format!("required for `{ty}` to implement `Send` and `Sync`"));
+                        diag.note(format!("required for `{ty}` to implement `Send` and `Sync`"));
 
-                    diag.help("consider using an `Rc` instead or wrapping the inner type with a `Mutex`");
-                }
-            ));
+                        diag.help("consider using an `Rc` instead or wrapping the inner type with a `Mutex`");
+                    });
+                },
+            );
         }
     }
 }
diff --git a/clippy_lints/src/assertions_on_result_states.rs b/clippy_lints/src/assertions_on_result_states.rs
index 2980c9d6db3..71ec87a8874 100644
--- a/clippy_lints/src/assertions_on_result_states.rs
+++ b/clippy_lints/src/assertions_on_result_states.rs
@@ -58,7 +58,7 @@ impl<'tcx> LateLintPass<'tcx> for AssertionsOnResultStates {
                     return;
                 }
             }
-            let semicolon = if is_expr_final_block_expr(cx.tcx, e) {";"} else {""};
+            let semicolon = if is_expr_final_block_expr(cx.tcx, e) { ";" } else { "" };
             let mut app = Applicability::MachineApplicable;
             match method_segment.ident.as_str() {
                 "is_ok" if type_suitable_to_unwrap(cx, args.type_at(1)) => {
@@ -74,7 +74,7 @@ impl<'tcx> LateLintPass<'tcx> for AssertionsOnResultStates {
                         ),
                         app,
                     );
-                }
+                },
                 "is_err" if type_suitable_to_unwrap(cx, args.type_at(0)) => {
                     span_lint_and_sugg(
                         cx,
@@ -88,7 +88,7 @@ impl<'tcx> LateLintPass<'tcx> for AssertionsOnResultStates {
                         ),
                         app,
                     );
-                }
+                },
                 _ => (),
             };
         }
diff --git a/clippy_lints/src/async_yields_async.rs b/clippy_lints/src/async_yields_async.rs
index 6aab91a7f18..ec2447dae96 100644
--- a/clippy_lints/src/async_yields_async.rs
+++ b/clippy_lints/src/async_yields_async.rs
@@ -2,7 +2,7 @@ use clippy_utils::diagnostics::span_lint_hir_and_then;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::implements_trait;
 use rustc_errors::Applicability;
-use rustc_hir::{CoroutineSource, Body, BodyId, CoroutineKind, ExprKind, QPath};
+use rustc_hir::{Body, BodyId, CoroutineKind, CoroutineSource, ExprKind, QPath};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs
index 7a5e3d3f30f..64bfa8d904c 100644
--- a/clippy_lints/src/attrs.rs
+++ b/clippy_lints/src/attrs.rs
@@ -602,9 +602,26 @@ fn check_should_panic_reason(cx: &LateContext<'_>, attr: &Attribute) {
 
         if let AttrArgs::Delimited(args) = &normal_attr.item.args
             && let mut tt_iter = args.tokens.trees()
-            && let Some(TokenTree::Token(Token { kind: TokenKind::Ident(sym::expected, _), .. }, _)) = tt_iter.next()
-            && let Some(TokenTree::Token(Token { kind: TokenKind::Eq, .. }, _)) = tt_iter.next()
-            && let Some(TokenTree::Token(Token { kind: TokenKind::Literal(_), .. }, _)) = tt_iter.next()
+            && let Some(TokenTree::Token(
+                Token {
+                    kind: TokenKind::Ident(sym::expected, _),
+                    ..
+                },
+                _,
+            )) = tt_iter.next()
+            && let Some(TokenTree::Token(
+                Token {
+                    kind: TokenKind::Eq, ..
+                },
+                _,
+            )) = tt_iter.next()
+            && let Some(TokenTree::Token(
+                Token {
+                    kind: TokenKind::Literal(_),
+                    ..
+                },
+                _,
+            )) = tt_iter.next()
         {
             // `#[should_panic(expected = "..")]` found, good
             return;
@@ -914,7 +931,9 @@ fn check_nested_cfg(cx: &EarlyContext<'_>, items: &[NestedMetaItem]) {
 fn check_nested_misused_cfg(cx: &EarlyContext<'_>, items: &[NestedMetaItem]) {
     for item in items {
         if let NestedMetaItem::MetaItem(meta) = item {
-            if meta.has_name(sym!(features)) && let Some(val) = meta.value_str() {
+            if meta.has_name(sym!(features))
+                && let Some(val) = meta.value_str()
+            {
                 span_lint_and_sugg(
                     cx,
                     MAYBE_MISUSED_CFG,
@@ -933,16 +952,16 @@ fn check_nested_misused_cfg(cx: &EarlyContext<'_>, items: &[NestedMetaItem]) {
 }
 
 fn check_minimal_cfg_condition(cx: &EarlyContext<'_>, attr: &Attribute) {
-    if attr.has_name(sym::cfg) &&
-        let Some(items) = attr.meta_item_list()
+    if attr.has_name(sym::cfg)
+        && let Some(items) = attr.meta_item_list()
     {
         check_nested_cfg(cx, &items);
     }
 }
 
 fn check_misused_cfg(cx: &EarlyContext<'_>, attr: &Attribute) {
-    if attr.has_name(sym::cfg) &&
-        let Some(items) = attr.meta_item_list()
+    if attr.has_name(sym::cfg)
+        && let Some(items) = attr.meta_item_list()
     {
         check_nested_misused_cfg(cx, &items);
     }
diff --git a/clippy_lints/src/await_holding_invalid.rs b/clippy_lints/src/await_holding_invalid.rs
index e5ec504fa91..06b74b972b7 100644
--- a/clippy_lints/src/await_holding_invalid.rs
+++ b/clippy_lints/src/await_holding_invalid.rs
@@ -3,7 +3,7 @@ use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::{match_def_path, paths};
 use rustc_data_structures::fx::FxHashMap;
 use rustc_hir::def_id::DefId;
-use rustc_hir::{CoroutineSource, Body, CoroutineKind};
+use rustc_hir::{Body, CoroutineKind, CoroutineSource};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::mir::CoroutineLayout;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
diff --git a/clippy_lints/src/bool_to_int_with_if.rs b/clippy_lints/src/bool_to_int_with_if.rs
index ca305d0c6e5..156cb34df9c 100644
--- a/clippy_lints/src/bool_to_int_with_if.rs
+++ b/clippy_lints/src/bool_to_int_with_if.rs
@@ -55,7 +55,11 @@ impl<'tcx> LateLintPass<'tcx> for BoolToIntWithIf {
 }
 
 fn check_if_else<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx rustc_hir::Expr<'tcx>) {
-    if let Some(If { cond, then, r#else: Some(r#else) }) = If::hir(expr)
+    if let Some(If {
+        cond,
+        then,
+        r#else: Some(r#else),
+    }) = If::hir(expr)
         && let Some(then_lit) = int_literal(then)
         && let Some(else_lit) = int_literal(r#else)
     {
@@ -90,19 +94,18 @@ fn check_if_else<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx rustc_hir::Expr<'tcx>
         let into_snippet = snippet.clone().maybe_par();
         let as_snippet = snippet.as_ty(ty);
 
-        span_lint_and_then(cx,
+        span_lint_and_then(
+            cx,
             BOOL_TO_INT_WITH_IF,
             expr.span,
             "boolean to int conversion using if",
             |diag| {
-            diag.span_suggestion(
-                expr.span,
-                "replace with from",
-                suggestion,
-                applicability,
-            );
-            diag.note(format!("`{as_snippet}` or `{into_snippet}.into()` can also be valid options"));
-        });
+                diag.span_suggestion(expr.span, "replace with from", suggestion, applicability);
+                diag.note(format!(
+                    "`{as_snippet}` or `{into_snippet}.into()` can also be valid options"
+                ));
+            },
+        );
     };
 }
 
@@ -110,7 +113,7 @@ fn check_if_else<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx rustc_hir::Expr<'tcx>
 fn int_literal<'tcx>(expr: &'tcx rustc_hir::Expr<'tcx>) -> Option<&'tcx rustc_hir::Expr<'tcx>> {
     if let ExprKind::Block(block, _) = expr.kind
         && let Block {
-            stmts: [],       // Shouldn't lint if statements with side effects
+            stmts: [], // Shouldn't lint if statements with side effects
             expr: Some(expr),
             ..
         } = block
diff --git a/clippy_lints/src/booleans.rs b/clippy_lints/src/booleans.rs
index 04cca9e3177..37ce65676c7 100644
--- a/clippy_lints/src/booleans.rs
+++ b/clippy_lints/src/booleans.rs
@@ -472,8 +472,9 @@ impl<'a, 'tcx> Visitor<'tcx> for NonminimalBoolVisitor<'a, 'tcx> {
                     self.bool_expr(e);
                 },
                 ExprKind::Unary(UnOp::Not, inner) => {
-                    if let ExprKind::Unary(UnOp::Not, ex) = inner.kind &&
-                    !self.cx.typeck_results().node_types()[ex.hir_id].is_bool() {
+                    if let ExprKind::Unary(UnOp::Not, ex) = inner.kind
+                        && !self.cx.typeck_results().node_types()[ex.hir_id].is_bool()
+                    {
                         return;
                     }
                     if self.cx.typeck_results().node_types()[inner.hir_id].is_bool() {
@@ -500,10 +501,10 @@ struct NotSimplificationVisitor<'a, 'tcx> {
 
 impl<'a, 'tcx> Visitor<'tcx> for NotSimplificationVisitor<'a, 'tcx> {
     fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
-        if let ExprKind::Unary(UnOp::Not, inner) = &expr.kind &&
-            !inner.span.from_expansion() &&
-            let Some(suggestion) = simplify_not(self.cx, inner)
-			&& self.cx.tcx.lint_level_at_node(NONMINIMAL_BOOL, expr.hir_id).0 != Level::Allow
+        if let ExprKind::Unary(UnOp::Not, inner) = &expr.kind
+            && !inner.span.from_expansion()
+            && let Some(suggestion) = simplify_not(self.cx, inner)
+            && self.cx.tcx.lint_level_at_node(NONMINIMAL_BOOL, expr.hir_id).0 != Level::Allow
         {
             span_lint_and_sugg(
                 self.cx,
diff --git a/clippy_lints/src/box_default.rs b/clippy_lints/src/box_default.rs
index 47672cb5fb5..9c78c6e532d 100644
--- a/clippy_lints/src/box_default.rs
+++ b/clippy_lints/src/box_default.rs
@@ -61,9 +61,9 @@ impl LateLintPass<'_> for BoxDefault {
                 } else if let Some(arg_ty) = cx.typeck_results().expr_ty(arg).make_suggestable(cx.tcx, true) {
                     with_forced_trimmed_paths!(format!("Box::<{arg_ty}>::default()"))
                 } else {
-                    return
+                    return;
                 },
-                Applicability::MachineApplicable
+                Applicability::MachineApplicable,
             );
         }
     }
@@ -110,7 +110,8 @@ fn given_type(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
             Node::Expr(Expr {
                 kind: ExprKind::Call(path, args),
                 ..
-            }) | Node::Block(Block {
+            })
+            | Node::Block(Block {
                 expr:
                     Some(Expr {
                         kind: ExprKind::Call(path, args),
@@ -119,10 +120,10 @@ fn given_type(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
                 ..
             }),
         ) => {
-            if let Some(index) = args.iter().position(|arg| arg.hir_id == expr.hir_id) &&
-                let Some(sig) = expr_sig(cx, path) &&
-                let Some(input) = sig.input(index) &&
-                !cx.typeck_results().expr_ty_adjusted(expr).boxed_ty().is_trait()
+            if let Some(index) = args.iter().position(|arg| arg.hir_id == expr.hir_id)
+                && let Some(sig) = expr_sig(cx, path)
+                && let Some(input) = sig.input(index)
+                && !cx.typeck_results().expr_ty_adjusted(expr).boxed_ty().is_trait()
             {
                 input.no_bound_vars().is_some()
             } else {
diff --git a/clippy_lints/src/casts/as_ptr_cast_mut.rs b/clippy_lints/src/casts/as_ptr_cast_mut.rs
index 1e56ed5f450..55294f5f386 100644
--- a/clippy_lints/src/casts/as_ptr_cast_mut.rs
+++ b/clippy_lints/src/casts/as_ptr_cast_mut.rs
@@ -9,12 +9,19 @@ use rustc_middle::ty::{self, Ty, TypeAndMut};
 use super::AS_PTR_CAST_MUT;
 
 pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_expr: &Expr<'_>, cast_to: Ty<'_>) {
-    if let ty::RawPtr(ptrty @ TypeAndMut { mutbl: Mutability::Mut, .. }) = cast_to.kind()
-        && let ty::RawPtr(TypeAndMut { mutbl: Mutability::Not, .. }) =
-            cx.typeck_results().node_type(cast_expr.hir_id).kind()
+    if let ty::RawPtr(
+        ptrty @ TypeAndMut {
+            mutbl: Mutability::Mut, ..
+        },
+    ) = cast_to.kind()
+        && let ty::RawPtr(TypeAndMut {
+            mutbl: Mutability::Not, ..
+        }) = cx.typeck_results().node_type(cast_expr.hir_id).kind()
         && let ExprKind::MethodCall(method_name, receiver, [], _) = cast_expr.peel_blocks().kind
         && method_name.ident.name == rustc_span::sym::as_ptr
-        && let Some(as_ptr_did) = cx.typeck_results().type_dependent_def_id(cast_expr.peel_blocks().hir_id)
+        && let Some(as_ptr_did) = cx
+            .typeck_results()
+            .type_dependent_def_id(cast_expr.peel_blocks().hir_id)
         && let as_ptr_sig = cx.tcx.fn_sig(as_ptr_did).instantiate_identity()
         && let Some(first_param_ty) = as_ptr_sig.skip_binder().inputs().iter().next()
         && let ty::Ref(_, _, Mutability::Not) = first_param_ty.kind()
@@ -30,7 +37,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_expr: &Expr<'_>,
             &format!("casting the result of `as_ptr` to *{ptrty}"),
             "replace with",
             format!("{recv}.as_mut_ptr()"),
-            applicability
+            applicability,
         );
     }
 }
diff --git a/clippy_lints/src/casts/cast_ptr_alignment.rs b/clippy_lints/src/casts/cast_ptr_alignment.rs
index 9e8ef282537..f12f03fbe79 100644
--- a/clippy_lints/src/casts/cast_ptr_alignment.rs
+++ b/clippy_lints/src/casts/cast_ptr_alignment.rs
@@ -26,8 +26,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>) {
             // There probably is no obvious reason to do this, just to be consistent with `as` cases.
             && !is_hir_ty_cfg_dependant(cx, cast_to)
         {
-            let (cast_from, cast_to) =
-                (cx.typeck_results().expr_ty(self_arg), cx.typeck_results().expr_ty(expr));
+            let (cast_from, cast_to) = (cx.typeck_results().expr_ty(self_arg), cx.typeck_results().expr_ty(expr));
             lint_cast_ptr_alignment(cx, expr, cast_from, cast_to);
         }
     }
@@ -81,9 +80,9 @@ fn is_used_as_unaligned(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
                     cx.tcx.get_diagnostic_name(def_id),
                     Some(
                         sym::ptr_write_unaligned
-                        | sym::ptr_read_unaligned
-                        | sym::intrinsics_unaligned_volatile_load
-                        | sym::intrinsics_unaligned_volatile_store
+                            | sym::ptr_read_unaligned
+                            | sym::intrinsics_unaligned_volatile_load
+                            | sym::intrinsics_unaligned_volatile_store
                     )
                 )
             {
diff --git a/clippy_lints/src/casts/unnecessary_cast.rs b/clippy_lints/src/casts/unnecessary_cast.rs
index 86057bb74ee..61bfce07e1a 100644
--- a/clippy_lints/src/casts/unnecessary_cast.rs
+++ b/clippy_lints/src/casts/unnecessary_cast.rs
@@ -97,7 +97,9 @@ pub(super) fn check<'tcx>(
     }
 
     // skip cast of fn call that returns type alias
-    if let ExprKind::Cast(inner, ..) = expr.kind && is_cast_from_ty_alias(cx, inner, cast_from) {
+    if let ExprKind::Cast(inner, ..) = expr.kind
+        && is_cast_from_ty_alias(cx, inner, cast_from)
+    {
         return false;
     }
 
@@ -189,11 +191,10 @@ fn lint_unnecessary_cast(
     let sugg = if let Some(parent_expr) = get_parent_expr(cx, expr)
         && let ExprKind::MethodCall(..) = parent_expr.kind
         && literal_str.starts_with('-')
-        {
-            format!("({literal_str}_{cast_to})")
-
-        } else {
-            format!("{literal_str}_{cast_to}")
+    {
+        format!("({literal_str}_{cast_to})")
+    } else {
+        format!("{literal_str}_{cast_to}")
     };
 
     span_lint_and_sugg(
@@ -269,7 +270,9 @@ fn is_cast_from_ty_alias<'tcx>(cx: &LateContext<'tcx>, expr: impl Visitable<'tcx
                 && let Some(parent) = get_parent_node(cx.tcx, hir_id)
                 && let Node::Local(l) = parent
             {
-                if let Some(e) = l.init && is_cast_from_ty_alias(cx, e, cast_from) {
+                if let Some(e) = l.init
+                    && is_cast_from_ty_alias(cx, e, cast_from)
+                {
                     return ControlFlow::Break::<()>(());
                 }
 
diff --git a/clippy_lints/src/default_instead_of_iter_empty.rs b/clippy_lints/src/default_instead_of_iter_empty.rs
index 77f8243c969..553b670fdb7 100644
--- a/clippy_lints/src/default_instead_of_iter_empty.rs
+++ b/clippy_lints/src/default_instead_of_iter_empty.rs
@@ -68,7 +68,10 @@ fn make_sugg(
             _ => None,
         })
     {
-        format!("std::iter::empty::<{}>()", snippet_with_context(cx, iter_ty.span, ctxt, "..", applicability).0)
+        format!(
+            "std::iter::empty::<{}>()",
+            snippet_with_context(cx, iter_ty.span, ctxt, "..", applicability).0
+        )
     } else {
         "std::iter::empty()".to_owned()
     }
diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index ca4913ce1d1..6c109a51f83 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -353,23 +353,26 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing<'tcx> {
                                 //   priority.
                                 if let Some(fn_id) = typeck.type_dependent_def_id(hir_id)
                                     && let Some(trait_id) = cx.tcx.trait_of_item(fn_id)
-                                    && let arg_ty
-                                        = cx.tcx.erase_regions(use_cx.adjustments.last().map_or(expr_ty, |a| a.target))
+                                    && let arg_ty = cx
+                                        .tcx
+                                        .erase_regions(use_cx.adjustments.last().map_or(expr_ty, |a| a.target))
                                     && let ty::Ref(_, sub_ty, _) = *arg_ty.kind()
                                     && let args = cx
                                         .typeck_results()
-                                        .node_args_opt(hir_id).map(|args| &args[1..]).unwrap_or_default()
-                                    && let impl_ty = if cx.tcx.fn_sig(fn_id)
-                                        .instantiate_identity()
-                                        .skip_binder()
-                                        .inputs()[0].is_ref()
-                                    {
-                                        // Trait methods taking `&self`
-                                        sub_ty
-                                    } else {
-                                        // Trait methods taking `self`
-                                        arg_ty
-                                    } && impl_ty.is_ref()
+                                        .node_args_opt(hir_id)
+                                        .map(|args| &args[1..])
+                                        .unwrap_or_default()
+                                    && let impl_ty =
+                                        if cx.tcx.fn_sig(fn_id).instantiate_identity().skip_binder().inputs()[0]
+                                            .is_ref()
+                                        {
+                                            // Trait methods taking `&self`
+                                            sub_ty
+                                        } else {
+                                            // Trait methods taking `self`
+                                            arg_ty
+                                        }
+                                    && impl_ty.is_ref()
                                     && implements_trait(
                                         cx,
                                         impl_ty,
@@ -414,9 +417,9 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing<'tcx> {
                         let (required_refs, msg) = if can_auto_borrow {
                             (1, if deref_count == 1 { borrow_msg } else { deref_msg })
                         } else if let Some(&Adjustment {
-                                kind: Adjust::Borrow(AutoBorrow::Ref(_, mutability)),
-                                ..
-                            }) = next_adjust
+                            kind: Adjust::Borrow(AutoBorrow::Ref(_, mutability)),
+                            ..
+                        }) = next_adjust
                             && matches!(mutability, AutoBorrowMutability::Mut { .. })
                             && !stability.is_reborrow_stable()
                         {
@@ -705,9 +708,11 @@ fn in_postfix_position<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'tcx>) -> boo
     {
         match parent.kind {
             ExprKind::Call(child, _) | ExprKind::MethodCall(_, child, _, _) | ExprKind::Index(child, _, _)
-                if child.hir_id == e.hir_id => true,
-            ExprKind::Match(.., MatchSource::TryDesugar(_) | MatchSource::AwaitDesugar)
-                | ExprKind::Field(_, _) => true,
+                if child.hir_id == e.hir_id =>
+            {
+                true
+            },
+            ExprKind::Match(.., MatchSource::TryDesugar(_) | MatchSource::AwaitDesugar) | ExprKind::Field(_, _) => true,
             _ => false,
         }
     } else {
diff --git a/clippy_lints/src/doc.rs b/clippy_lints/src/doc.rs
index e2f595dcf18..d4a698521ac 100644
--- a/clippy_lints/src/doc.rs
+++ b/clippy_lints/src/doc.rs
@@ -569,9 +569,7 @@ fn check_doc<'a, Events: Iterator<Item = (pulldown_cmark::Event<'a>, Range<usize
                 if let End(Heading(_, _, _)) = event {
                     in_heading = false;
                 }
-                if ticks_unbalanced
-                    && let Some(span) = fragments.span(cx, paragraph_range.clone())
-                {
+                if ticks_unbalanced && let Some(span) = fragments.span(cx, paragraph_range.clone()) {
                     span_lint_and_help(
                         cx,
                         DOC_MARKDOWN,
@@ -617,8 +615,9 @@ fn check_doc<'a, Events: Iterator<Item = (pulldown_cmark::Event<'a>, Range<usize
                         check_link_quotes(cx, trimmed_text, range.clone(), fragments);
                     }
                     if let Some(link) = in_link.as_ref()
-                      && let Ok(url) = Url::parse(link)
-                      && (url.scheme() == "https" || url.scheme() == "http") {
+                        && let Ok(url) = Url::parse(link)
+                        && (url.scheme() == "https" || url.scheme() == "http")
+                    {
                         // Don't check the text associated with external URLs
                         continue;
                     }
@@ -716,7 +715,9 @@ fn check_code(cx: &LateContext<'_>, text: &str, edition: Edition, range: Range<u
     // Because of the global session, we need to create a new session in a different thread with
     // the edition we need.
     let text = text.to_owned();
-    if thread::spawn(move || has_needless_main(text, edition)).join().expect("thread::spawn failed")
+    if thread::spawn(move || has_needless_main(text, edition))
+        .join()
+        .expect("thread::spawn failed")
         && let Some(span) = fragments.span(cx, range.start..range.end - trailing_whitespace)
     {
         span_lint(cx, NEEDLESS_DOCTEST_MAIN, span, "needless `fn main` in doctest");
diff --git a/clippy_lints/src/drop_forget_ref.rs b/clippy_lints/src/drop_forget_ref.rs
index 63394ea5fa3..177e04dfa6b 100644
--- a/clippy_lints/src/drop_forget_ref.rs
+++ b/clippy_lints/src/drop_forget_ref.rs
@@ -90,7 +90,8 @@ impl<'tcx> LateLintPass<'tcx> for DropForgetRef {
             let is_copy = is_copy(cx, arg_ty);
             let drop_is_single_call_in_arm = is_single_call_in_arm(cx, arg, expr);
             let (lint, msg, note_span) = match fn_name {
-                // early return for uplifted lints: dropping_references, dropping_copy_types, forgetting_references, forgetting_copy_types
+                // early return for uplifted lints: dropping_references, dropping_copy_types, forgetting_references,
+                // forgetting_copy_types
                 sym::mem_drop if arg_ty.is_ref() && !drop_is_single_call_in_arm => return,
                 sym::mem_forget if arg_ty.is_ref() => return,
                 sym::mem_drop if is_copy && !drop_is_single_call_in_arm => return,
@@ -100,8 +101,7 @@ impl<'tcx> LateLintPass<'tcx> for DropForgetRef {
                     if !(arg_ty.needs_drop(cx.tcx, cx.param_env)
                         || is_must_use_func_call(cx, arg)
                         || is_must_use_ty(cx, arg_ty)
-                        || drop_is_single_call_in_arm
-                        ) =>
+                        || drop_is_single_call_in_arm) =>
                 {
                     (DROP_NON_DROP, DROP_NON_DROP_SUMMARY.into(), Some(arg.span))
                 },
@@ -122,7 +122,7 @@ impl<'tcx> LateLintPass<'tcx> for DropForgetRef {
                     } else {
                         (FORGET_NON_DROP, FORGET_NON_DROP_SUMMARY.into(), Some(arg.span))
                     }
-                }
+                },
                 _ => return,
             };
             span_lint_and_note(
diff --git a/clippy_lints/src/empty_structs_with_brackets.rs b/clippy_lints/src/empty_structs_with_brackets.rs
index 3122c1c1757..4e2a8b73c0a 100644
--- a/clippy_lints/src/empty_structs_with_brackets.rs
+++ b/clippy_lints/src/empty_structs_with_brackets.rs
@@ -35,7 +35,8 @@ impl EarlyLintPass for EmptyStructsWithBrackets {
 
         if let ItemKind::Struct(var_data, _) = &item.kind
             && has_brackets(var_data)
-            && has_no_fields(cx, var_data, span_after_ident) {
+            && has_no_fields(cx, var_data, span_after_ident)
+        {
             span_lint_and_then(
                 cx,
                 EMPTY_STRUCTS_WITH_BRACKETS,
@@ -46,8 +47,9 @@ impl EarlyLintPass for EmptyStructsWithBrackets {
                         span_after_ident,
                         "remove the brackets",
                         ";",
-                        Applicability::Unspecified);
-                    },
+                        Applicability::Unspecified,
+                    );
+                },
             );
         }
     }
diff --git a/clippy_lints/src/equatable_if_let.rs b/clippy_lints/src/equatable_if_let.rs
index c691e6c5402..575fead5bf3 100644
--- a/clippy_lints/src/equatable_if_let.rs
+++ b/clippy_lints/src/equatable_if_let.rs
@@ -68,7 +68,8 @@ impl<'tcx> LateLintPass<'tcx> for PatternEquality {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
         if !in_external_macro(cx.sess(), expr.span)
             && let ExprKind::Let(let_expr) = expr.kind
-            && unary_pattern(let_expr.pat) {
+            && unary_pattern(let_expr.pat)
+        {
             let exp_ty = cx.typeck_results().expr_ty(let_expr.init);
             let pat_ty = cx.typeck_results().pat_ty(let_expr.pat);
             let mut applicability = Applicability::MachineApplicable;
@@ -79,7 +80,9 @@ impl<'tcx> LateLintPass<'tcx> for PatternEquality {
                         "({})",
                         snippet_with_context(cx, let_expr.pat.span, expr.span.ctxt(), "..", &mut applicability).0,
                     ),
-                    _ => snippet_with_context(cx, let_expr.pat.span, expr.span.ctxt(), "..", &mut applicability).0.to_string(),
+                    _ => snippet_with_context(cx, let_expr.pat.span, expr.span.ctxt(), "..", &mut applicability)
+                        .0
+                        .to_string(),
                 };
                 span_lint_and_sugg(
                     cx,
diff --git a/clippy_lints/src/error_impl_error.rs b/clippy_lints/src/error_impl_error.rs
index 6d429fbd035..bc878555c66 100644
--- a/clippy_lints/src/error_impl_error.rs
+++ b/clippy_lints/src/error_impl_error.rs
@@ -41,10 +41,11 @@ impl<'tcx> LateLintPass<'tcx> for ErrorImplError {
         };
 
         match item.kind {
-            ItemKind::TyAlias(..) if item.ident.name == sym::Error
-                && is_visible_outside_module(cx, item.owner_id.def_id)
-                && let ty = cx.tcx.type_of(item.owner_id).instantiate_identity()
-                && implements_trait(cx, ty, error_def_id, &[]) =>
+            ItemKind::TyAlias(..)
+                if item.ident.name == sym::Error
+                    && is_visible_outside_module(cx, item.owner_id.def_id)
+                    && let ty = cx.tcx.type_of(item.owner_id).instantiate_identity()
+                    && implements_trait(cx, ty, error_def_id, &[]) =>
             {
                 span_lint(
                     cx,
@@ -53,13 +54,14 @@ impl<'tcx> LateLintPass<'tcx> for ErrorImplError {
                     "exported type alias named `Error` that implements `Error`",
                 );
             },
-            ItemKind::Impl(imp) if let Some(trait_def_id) = imp.of_trait.and_then(|t| t.trait_def_id())
-                && error_def_id == trait_def_id
-                && let Some(def_id) = path_res(cx, imp.self_ty).opt_def_id().and_then(DefId::as_local)
-                && let hir_id = cx.tcx.hir().local_def_id_to_hir_id(def_id)
-                && let Some(ident) = cx.tcx.opt_item_ident(def_id.to_def_id())
-                && ident.name == sym::Error
-                && is_visible_outside_module(cx, def_id) =>
+            ItemKind::Impl(imp)
+                if let Some(trait_def_id) = imp.of_trait.and_then(|t| t.trait_def_id())
+                    && error_def_id == trait_def_id
+                    && let Some(def_id) = path_res(cx, imp.self_ty).opt_def_id().and_then(DefId::as_local)
+                    && let hir_id = cx.tcx.hir().local_def_id_to_hir_id(def_id)
+                    && let Some(ident) = cx.tcx.opt_item_ident(def_id.to_def_id())
+                    && ident.name == sym::Error
+                    && is_visible_outside_module(cx, def_id) =>
             {
                 span_lint_hir_and_then(
                     cx,
@@ -69,9 +71,9 @@ impl<'tcx> LateLintPass<'tcx> for ErrorImplError {
                     "exported type named `Error` that implements `Error`",
                     |diag| {
                         diag.span_note(item.span, "`Error` was implemented here");
-                    }
+                    },
                 );
-            }
+            },
             _ => {},
         }
     }
diff --git a/clippy_lints/src/eta_reduction.rs b/clippy_lints/src/eta_reduction.rs
index 38066503c07..fad8fbf0449 100644
--- a/clippy_lints/src/eta_reduction.rs
+++ b/clippy_lints/src/eta_reduction.rs
@@ -119,19 +119,21 @@ impl<'tcx> LateLintPass<'tcx> for EtaReduction {
 
         match body.value.kind {
             ExprKind::Call(callee, args)
-                if matches!(callee.kind, ExprKind::Path(QPath::Resolved(..) | QPath::TypeRelative(..))) =>
+                if matches!(
+                    callee.kind,
+                    ExprKind::Path(QPath::Resolved(..) | QPath::TypeRelative(..))
+                ) =>
             {
                 let callee_ty = typeck.expr_ty(callee).peel_refs();
-                if matches!(
-                    type_diagnostic_name(cx, callee_ty),
-                    Some(sym::Arc | sym::Rc)
-                ) || !check_inputs(typeck, body.params, None, args) {
+                if matches!(type_diagnostic_name(cx, callee_ty), Some(sym::Arc | sym::Rc))
+                    || !check_inputs(typeck, body.params, None, args)
+                {
                     return;
                 }
-                let callee_ty_adjusted = typeck.expr_adjustments(callee).last().map_or(
-                    callee_ty,
-                    |a| a.target.peel_refs(),
-                );
+                let callee_ty_adjusted = typeck
+                    .expr_adjustments(callee)
+                    .last()
+                    .map_or(callee_ty, |a| a.target.peel_refs());
 
                 let sig = match callee_ty_adjusted.kind() {
                     ty::FnDef(def, _) => cx.tcx.fn_sig(def).skip_binder().skip_binder(),
@@ -160,36 +162,26 @@ impl<'tcx> LateLintPass<'tcx> for EtaReduction {
                     // For now ignore all callee types which reference a type parameter.
                     && !generic_args.types().any(|t| matches!(t.kind(), ty::Param(_)))
                 {
-                    span_lint_and_then(
-                        cx,
-                        REDUNDANT_CLOSURE,
-                        expr.span,
-                        "redundant closure",
-                        |diag| {
-                            if let Some(mut snippet) = snippet_opt(cx, callee.span) {
-                                if let Ok((ClosureKind::FnMut, _))
-                                    = cx.tcx.infer_ctxt().build().type_implements_fn_trait(
-                                        cx.param_env,
-                                        Binder::bind_with_vars(callee_ty_adjusted, List::empty()),
-                                        ImplPolarity::Positive,
-                                    ) && path_to_local(callee)
-                                        .map_or(
-                                            false,
-                                            |l| local_used_in(cx, l, args) || local_used_after_expr(cx, l, expr),
-                                        )
-                                {
-                                    // Mutable closure is used after current expr; we cannot consume it.
-                                    snippet = format!("&mut {snippet}");
-                                }
-                                diag.span_suggestion(
-                                    expr.span,
-                                    "replace the closure with the function itself",
-                                    snippet,
-                                    Applicability::MachineApplicable,
-                                );
+                    span_lint_and_then(cx, REDUNDANT_CLOSURE, expr.span, "redundant closure", |diag| {
+                        if let Some(mut snippet) = snippet_opt(cx, callee.span) {
+                            if let Ok((ClosureKind::FnMut, _)) = cx.tcx.infer_ctxt().build().type_implements_fn_trait(
+                                cx.param_env,
+                                Binder::bind_with_vars(callee_ty_adjusted, List::empty()),
+                                ImplPolarity::Positive,
+                            ) && path_to_local(callee).map_or(false, |l| {
+                                local_used_in(cx, l, args) || local_used_after_expr(cx, l, expr)
+                            }) {
+                                // Mutable closure is used after current expr; we cannot consume it.
+                                snippet = format!("&mut {snippet}");
                             }
+                            diag.span_suggestion(
+                                expr.span,
+                                "replace the closure with the function itself",
+                                snippet,
+                                Applicability::MachineApplicable,
+                            );
                         }
-                    );
+                    });
                 }
             },
             ExprKind::MethodCall(path, self_, args, _) if check_inputs(typeck, body.params, Some(self_), args) => {
diff --git a/clippy_lints/src/excessive_bools.rs b/clippy_lints/src/excessive_bools.rs
index 1b0b88896ea..1d18e194d15 100644
--- a/clippy_lints/src/excessive_bools.rs
+++ b/clippy_lints/src/excessive_bools.rs
@@ -157,7 +157,7 @@ impl<'tcx> LateLintPass<'tcx> for ExcessiveBools {
         // functions with a body are already checked by `check_fn`
         if let TraitItemKind::Fn(fn_sig, TraitFn::Required(_)) = &trait_item.kind
             && fn_sig.header.abi == Abi::Rust
-            {
+        {
             self.check_fn_sig(cx, fn_sig.decl, fn_sig.span);
         }
     }
@@ -174,11 +174,8 @@ impl<'tcx> LateLintPass<'tcx> for ExcessiveBools {
         let hir_id = cx.tcx.hir().local_def_id_to_hir_id(def_id);
         if let Some(fn_header) = fn_kind.header()
             && fn_header.abi == Abi::Rust
-            && get_parent_as_impl(cx.tcx, hir_id)
-                .map_or(true,
-                    |impl_item| impl_item.of_trait.is_none()
-                )
-            {
+            && get_parent_as_impl(cx.tcx, hir_id).map_or(true, |impl_item| impl_item.of_trait.is_none())
+        {
             self.check_fn_sig(cx, fn_decl, span);
         }
     }
diff --git a/clippy_lints/src/explicit_write.rs b/clippy_lints/src/explicit_write.rs
index 595da886601..4b5bcb06a1e 100644
--- a/clippy_lints/src/explicit_write.rs
+++ b/clippy_lints/src/explicit_write.rs
@@ -58,7 +58,9 @@ impl<'tcx> LateLintPass<'tcx> for ExplicitWrite {
                 Some(sym::io_stderr) => ("stderr", "e"),
                 _ => return,
             };
-            let Some(format_args) = find_format_args(cx, write_arg, ExpnId::root()) else { return; };
+            let Some(format_args) = find_format_args(cx, write_arg, ExpnId::root()) else {
+                return;
+            };
 
             // ordering is important here, since `writeln!` uses `write!` internally
             let calling_macro = if is_expn_of(write_call.span, "writeln").is_some() {
@@ -78,18 +80,11 @@ impl<'tcx> LateLintPass<'tcx> for ExplicitWrite {
                     macro_name.replace("write", "print"),
                 )
             } else {
-                (
-                    format!("{dest_name}().write_fmt(...)"),
-                    "print".into(),
-                )
+                (format!("{dest_name}().write_fmt(...)"), "print".into())
             };
             let mut applicability = Applicability::MachineApplicable;
-            let inputs_snippet = snippet_with_applicability(
-                cx,
-                format_args_inputs_span(&format_args),
-                "..",
-                &mut applicability,
-            );
+            let inputs_snippet =
+                snippet_with_applicability(cx, format_args_inputs_span(&format_args), "..", &mut applicability);
             span_lint_and_sugg(
                 cx,
                 EXPLICIT_WRITE,
diff --git a/clippy_lints/src/extra_unused_type_parameters.rs b/clippy_lints/src/extra_unused_type_parameters.rs
index 73034b94206..d6c746901fc 100644
--- a/clippy_lints/src/extra_unused_type_parameters.rs
+++ b/clippy_lints/src/extra_unused_type_parameters.rs
@@ -177,20 +177,22 @@ impl<'cx, 'tcx> TypeWalker<'cx, 'tcx> {
                     .iter()
                     .rev()
                     .map(|(idx, param)| {
-                        if let Some(next) = explicit_params.get(idx + 1) && end != Some(next.def_id) {
-                        // Extend the current span forward, up until the next param in the list.
-                        param.span.until(next.span)
-                    } else {
-                        // Extend the current span back to include the comma following the previous
-                        // param. If the span of the next param in the list has already been
-                        // extended, we continue the chain. This is why we're iterating in reverse.
-                        end = Some(param.def_id);
+                        if let Some(next) = explicit_params.get(idx + 1)
+                            && end != Some(next.def_id)
+                        {
+                            // Extend the current span forward, up until the next param in the list.
+                            param.span.until(next.span)
+                        } else {
+                            // Extend the current span back to include the comma following the previous
+                            // param. If the span of the next param in the list has already been
+                            // extended, we continue the chain. This is why we're iterating in reverse.
+                            end = Some(param.def_id);
 
-                        // idx will never be 0, else we'd be removing the entire list of generics
-                        let prev = explicit_params[idx - 1];
-                        let prev_span = self.get_bound_span(prev);
-                        self.get_bound_span(param).with_lo(prev_span.hi())
-                    }
+                            // idx will never be 0, else we'd be removing the entire list of generics
+                            let prev = explicit_params[idx - 1];
+                            let prev_span = self.get_bound_span(prev);
+                            self.get_bound_span(param).with_lo(prev_span.hi())
+                        }
                     })
                     .collect()
             };
diff --git a/clippy_lints/src/format.rs b/clippy_lints/src/format.rs
index fd34c8cddc0..18ed05c1ca6 100644
--- a/clippy_lints/src/format.rs
+++ b/clippy_lints/src/format.rs
@@ -54,7 +54,9 @@ impl<'tcx> LateLintPass<'tcx> for UselessFormat {
                 ([], []) => span_useless_format_empty(cx, call_site, "String::new()".to_owned(), applicability),
                 ([], [_]) => {
                     // Simulate macro expansion, converting {{ and }} to { and }.
-                    let Some(snippet) = snippet_opt(cx, format_args.span) else { return };
+                    let Some(snippet) = snippet_opt(cx, format_args.span) else {
+                        return;
+                    };
                     let s_expand = snippet.replace("{{", "{").replace("}}", "}");
                     let sugg = format!("{s_expand}.to_string()");
                     span_useless_format(cx, call_site, sugg, applicability);
@@ -76,13 +78,14 @@ impl<'tcx> LateLintPass<'tcx> for UselessFormat {
                             _ => false,
                         };
                         let sugg = if is_new_string {
-                            snippet_with_context(cx, value.span, call_site.ctxt(), "..", &mut applicability).0.into_owned()
+                            snippet_with_context(cx, value.span, call_site.ctxt(), "..", &mut applicability)
+                                .0
+                                .into_owned()
                         } else {
                             let sugg = Sugg::hir_with_context(cx, value, call_site.ctxt(), "<arg>", &mut applicability);
                             format!("{}.to_string()", sugg.maybe_par())
                         };
                         span_useless_format(cx, call_site, sugg, applicability);
-
                     }
                 },
                 _ => {},
diff --git a/clippy_lints/src/format_args.rs b/clippy_lints/src/format_args.rs
index 7d60fdd1b03..3c1f2d9d5dc 100644
--- a/clippy_lints/src/format_args.rs
+++ b/clippy_lints/src/format_args.rs
@@ -370,7 +370,7 @@ fn check_one_arg(
         };
         fixes.push((pos_span, replacement));
         fixes.push((arg_span, String::new()));
-        true  // successful inlining, continue checking
+        true // successful inlining, continue checking
     } else {
         // Do not continue inlining (return false) in case
         // * if we can't inline a numbered argument, e.g. `print!("{0} ...", foo.bar, ...)`
diff --git a/clippy_lints/src/format_push_string.rs b/clippy_lints/src/format_push_string.rs
index 858ec91412b..ac45f5aedfa 100644
--- a/clippy_lints/src/format_push_string.rs
+++ b/clippy_lints/src/format_push_string.rs
@@ -58,7 +58,7 @@ fn is_format(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
                 arms.iter().any(|arm| is_format(cx, arm.body))
             },
             Some(higher::IfLetOrMatch::IfLet(_, _, then, r#else)) => {
-                is_format(cx, then) ||r#else.is_some_and(|e| is_format(cx, e))
+                is_format(cx, then) || r#else.is_some_and(|e| is_format(cx, e))
             },
             _ => false,
         }
@@ -69,17 +69,15 @@ impl<'tcx> LateLintPass<'tcx> for FormatPushString {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         let arg = match expr.kind {
             ExprKind::MethodCall(_, _, [arg], _) => {
-                if let Some(fn_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id) &&
-                match_def_path(cx, fn_def_id, &paths::PUSH_STR) {
+                if let Some(fn_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id)
+                    && match_def_path(cx, fn_def_id, &paths::PUSH_STR)
+                {
                     arg
                 } else {
                     return;
                 }
-            }
-            ExprKind::AssignOp(op, left, arg)
-            if op.node == BinOpKind::Add && is_string(cx, left) => {
-                arg
             },
+            ExprKind::AssignOp(op, left, arg) if op.node == BinOpKind::Add && is_string(cx, left) => arg,
             _ => return,
         };
         if is_format(cx, arg) {
diff --git a/clippy_lints/src/from_over_into.rs b/clippy_lints/src/from_over_into.rs
index 4ccdba910eb..5477532bb95 100644
--- a/clippy_lints/src/from_over_into.rs
+++ b/clippy_lints/src/from_over_into.rs
@@ -88,7 +88,8 @@ impl<'tcx> LateLintPass<'tcx> for FromOverInto {
                 cx.tcx.sess.source_map().guess_head_span(item.span),
                 "an implementation of `From` is preferred since it gives you `Into<_>` for free where the reverse isn't true",
                 |diag| {
-                    // If the target type is likely foreign mention the orphan rules as it's a common source of confusion
+                    // If the target type is likely foreign mention the orphan rules as it's a common source of
+                    // confusion
                     if path_def_id(cx, target_ty.peel_refs()).map_or(true, |id| !id.is_local()) {
                         diag.help(
                             "`impl From<Local> for Foreign` is allowed by the orphan rules, for more information see\n\
@@ -96,7 +97,10 @@ impl<'tcx> LateLintPass<'tcx> for FromOverInto {
                         );
                     }
 
-                    let message = format!("replace the `Into` implementation with `From<{}>`", middle_trait_ref.self_ty());
+                    let message = format!(
+                        "replace the `Into` implementation with `From<{}>`",
+                        middle_trait_ref.self_ty()
+                    );
                     if let Some(suggestions) = convert_to_from(cx, into_trait_seg, target_ty, self_ty, impl_item_ref) {
                         diag.multipart_suggestion(message, suggestions, Applicability::MachineApplicable);
                     } else {
diff --git a/clippy_lints/src/from_raw_with_void_ptr.rs b/clippy_lints/src/from_raw_with_void_ptr.rs
index b66746d08f8..d9138d48b2c 100644
--- a/clippy_lints/src/from_raw_with_void_ptr.rs
+++ b/clippy_lints/src/from_raw_with_void_ptr.rs
@@ -40,14 +40,22 @@ declare_lint_pass!(FromRawWithVoidPtr => [FROM_RAW_WITH_VOID_PTR]);
 impl LateLintPass<'_> for FromRawWithVoidPtr {
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
         if let ExprKind::Call(box_from_raw, [arg]) = expr.kind
-        && let ExprKind::Path(QPath::TypeRelative(ty, seg)) = box_from_raw.kind
-        && seg.ident.name == sym!(from_raw)
-        && let Some(type_str) = path_def_id(cx, ty).and_then(|id| def_id_matches_type(cx, id))
-        && let arg_kind = cx.typeck_results().expr_ty(arg).kind()
-        && let RawPtr(TypeAndMut { ty, .. }) = arg_kind
-        && is_c_void(cx, *ty) {
+            && let ExprKind::Path(QPath::TypeRelative(ty, seg)) = box_from_raw.kind
+            && seg.ident.name == sym!(from_raw)
+            && let Some(type_str) = path_def_id(cx, ty).and_then(|id| def_id_matches_type(cx, id))
+            && let arg_kind = cx.typeck_results().expr_ty(arg).kind()
+            && let RawPtr(TypeAndMut { ty, .. }) = arg_kind
+            && is_c_void(cx, *ty)
+        {
             let msg = format!("creating a `{type_str}` from a void raw pointer");
-            span_lint_and_help(cx, FROM_RAW_WITH_VOID_PTR, expr.span, &msg, Some(arg.span), "cast this to a pointer of the appropriate type");
+            span_lint_and_help(
+                cx,
+                FROM_RAW_WITH_VOID_PTR,
+                expr.span,
+                &msg,
+                Some(arg.span),
+                "cast this to a pointer of the appropriate type",
+            );
         }
     }
 }
diff --git a/clippy_lints/src/functions/must_use.rs b/clippy_lints/src/functions/must_use.rs
index 57df5683c9d..3aaf63ce340 100644
--- a/clippy_lints/src/functions/must_use.rs
+++ b/clippy_lints/src/functions/must_use.rs
@@ -118,9 +118,10 @@ fn check_needless_must_use(
         if sig.header.is_async() {
             let infcx = cx.tcx.infer_ctxt().build();
             if let Some(future_ty) = infcx.get_impl_future_output_ty(return_ty(cx, item_id))
-			&& !is_must_use_ty(cx, future_ty) {
-				return;
-			}
+                && !is_must_use_ty(cx, future_ty)
+            {
+                return;
+            }
         }
 
         span_lint_and_help(
diff --git a/clippy_lints/src/functions/result.rs b/clippy_lints/src/functions/result.rs
index 90fc0d4f662..485235514de 100644
--- a/clippy_lints/src/functions/result.rs
+++ b/clippy_lints/src/functions/result.rs
@@ -21,7 +21,9 @@ fn result_err_ty<'tcx>(
 ) -> Option<(&'tcx hir::Ty<'tcx>, Ty<'tcx>)> {
     if !in_external_macro(cx.sess(), item_span)
         && let hir::FnRetTy::Return(hir_ty) = decl.output
-        && let ty = cx.tcx.erase_late_bound_regions(cx.tcx.fn_sig(id).instantiate_identity().output())
+        && let ty = cx
+            .tcx
+            .erase_late_bound_regions(cx.tcx.fn_sig(id).instantiate_identity().output())
         && is_type_diagnostic_item(cx, ty, sym::Result)
         && let ty::Adt(_, args) = ty.kind()
     {
diff --git a/clippy_lints/src/if_then_some_else_none.rs b/clippy_lints/src/if_then_some_else_none.rs
index 55dab10ac88..66c10ab228f 100644
--- a/clippy_lints/src/if_then_some_else_none.rs
+++ b/clippy_lints/src/if_then_some_else_none.rs
@@ -76,7 +76,11 @@ impl<'tcx> LateLintPass<'tcx> for IfThenSomeElseNone {
 
         let ctxt = expr.span.ctxt();
 
-        if let Some(higher::If { cond, then, r#else: Some(els) }) = higher::If::hir(expr)
+        if let Some(higher::If {
+            cond,
+            then,
+            r#else: Some(els),
+        }) = higher::If::hir(expr)
             && let ExprKind::Block(then_block, _) = then.kind
             && let Some(then_expr) = then_block.expr
             && let ExprKind::Call(then_call, [then_arg]) = then_expr.kind
@@ -86,7 +90,9 @@ impl<'tcx> LateLintPass<'tcx> for IfThenSomeElseNone {
             && !contains_return(then_block.stmts)
         {
             let mut app = Applicability::Unspecified;
-            let cond_snip = Sugg::hir_with_context(cx, cond, expr.span.ctxt(), "[condition]", &mut app).maybe_par().to_string();
+            let cond_snip = Sugg::hir_with_context(cx, cond, expr.span.ctxt(), "[condition]", &mut app)
+                .maybe_par()
+                .to_string();
             let arg_snip = snippet_with_context(cx, then_arg.span, ctxt, "[body]", &mut app).0;
             let mut method_body = if then_block.stmts.is_empty() {
                 arg_snip.into_owned()
@@ -100,9 +106,8 @@ impl<'tcx> LateLintPass<'tcx> for IfThenSomeElseNone {
                 "then"
             };
 
-            let help = format!(
-                "consider using `bool::{method_name}` like: `{cond_snip}.{method_name}({method_body})`",
-            );
+            let help =
+                format!("consider using `bool::{method_name}` like: `{cond_snip}.{method_name}({method_body})`",);
             span_lint_and_help(
                 cx,
                 IF_THEN_SOME_ELSE_NONE,
diff --git a/clippy_lints/src/implied_bounds_in_impls.rs b/clippy_lints/src/implied_bounds_in_impls.rs
index cbe2b9c1dd4..ff27a5d666d 100644
--- a/clippy_lints/src/implied_bounds_in_impls.rs
+++ b/clippy_lints/src/implied_bounds_in_impls.rs
@@ -230,19 +230,24 @@ fn check(cx: &LateContext<'_>, decl: &FnDecl<'_>) {
         // Example:
         // `impl Deref<Target = i32> + DerefMut<Target = u32>` is not allowed.
         // `DerefMut::Target` needs to match `Deref::Target`.
-        let implied_bounds: Vec<_> = opaque_ty.bounds.iter().filter_map(|bound| {
-            if let GenericBound::Trait(poly_trait, TraitBoundModifier::None) = bound
-                && let [.., path]  = poly_trait.trait_ref.path.segments
-                && poly_trait.bound_generic_params.is_empty()
-                && let Some(trait_def_id) = path.res.opt_def_id()
-                && let predicates = cx.tcx.super_predicates_of(trait_def_id).predicates
-                && !predicates.is_empty() // If the trait has no supertrait, there is nothing to add.
-            {
-                Some((bound.span(), path, predicates, trait_def_id))
-            } else {
-                None
-            }
-        }).collect();
+        let implied_bounds: Vec<_> = opaque_ty
+            .bounds
+            .iter()
+            .filter_map(|bound| {
+                if let GenericBound::Trait(poly_trait, TraitBoundModifier::None) = bound
+                    && let [.., path] = poly_trait.trait_ref.path.segments
+                    && poly_trait.bound_generic_params.is_empty()
+                    && let Some(trait_def_id) = path.res.opt_def_id()
+                    && let predicates = cx.tcx.super_predicates_of(trait_def_id).predicates
+                    && !predicates.is_empty()
+                // If the trait has no supertrait, there is nothing to add.
+                {
+                    Some((bound.span(), path, predicates, trait_def_id))
+                } else {
+                    None
+                }
+            })
+            .collect();
 
         // Lint all bounds in the `impl Trait` type that are also in the `implied_bounds` vec.
         // This involves some extra logic when generic arguments are present, since
@@ -253,30 +258,31 @@ fn check(cx: &LateContext<'_>, decl: &FnDecl<'_>) {
                 && let implied_args = path.args.map_or([].as_slice(), |a| a.args)
                 && let implied_bindings = path.args.map_or([].as_slice(), |a| a.bindings)
                 && let Some(def_id) = poly_trait.trait_ref.path.res.opt_def_id()
-                && let Some((implied_by_span, implied_by_args, implied_by_bindings)) = implied_bounds
-                    .iter()
-                    .find_map(|&(span, implied_by_path, preds, implied_by_def_id)| {
-                        let implied_by_args = implied_by_path.args.map_or([].as_slice(), |a| a.args);
-                        let implied_by_bindings = implied_by_path.args.map_or([].as_slice(), |a| a.bindings);
+                && let Some((implied_by_span, implied_by_args, implied_by_bindings)) =
+                    implied_bounds
+                        .iter()
+                        .find_map(|&(span, implied_by_path, preds, implied_by_def_id)| {
+                            let implied_by_args = implied_by_path.args.map_or([].as_slice(), |a| a.args);
+                            let implied_by_bindings = implied_by_path.args.map_or([].as_slice(), |a| a.bindings);
 
-                        preds.iter().find_map(|(clause, _)| {
-                            if let ClauseKind::Trait(tr) = clause.kind().skip_binder()
-                                && tr.def_id() == def_id
-                                && is_same_generics(
-                                    cx.tcx,
-                                    tr.trait_ref.args,
-                                    implied_by_args,
-                                    implied_args,
-                                    implied_by_def_id,
-                                    def_id,
-                                )
-                            {
-                                Some((span, implied_by_args, implied_by_bindings))
-                            } else {
-                                None
-                            }
+                            preds.iter().find_map(|(clause, _)| {
+                                if let ClauseKind::Trait(tr) = clause.kind().skip_binder()
+                                    && tr.def_id() == def_id
+                                    && is_same_generics(
+                                        cx.tcx,
+                                        tr.trait_ref.args,
+                                        implied_by_args,
+                                        implied_args,
+                                        implied_by_def_id,
+                                        def_id,
+                                    )
+                                {
+                                    Some((span, implied_by_args, implied_by_bindings))
+                                } else {
+                                    None
+                                }
+                            })
                         })
-                    })
             {
                 emit_lint(
                     cx,
@@ -286,7 +292,7 @@ fn check(cx: &LateContext<'_>, decl: &FnDecl<'_>) {
                     implied_bindings,
                     implied_by_bindings,
                     implied_by_args,
-                    implied_by_span
+                    implied_by_span,
                 );
             }
         }
diff --git a/clippy_lints/src/items_after_test_module.rs b/clippy_lints/src/items_after_test_module.rs
index fde6bff9417..35e01862cee 100644
--- a/clippy_lints/src/items_after_test_module.rs
+++ b/clippy_lints/src/items_after_test_module.rs
@@ -74,9 +74,7 @@ impl LateLintPass<'_> for ItemsAfterTestModule {
 
         if let Some(last) = after.last()
             && after.iter().all(|&item| {
-                !matches!(item.kind, ItemKind::Mod(_))
-                    && !item.span.from_expansion()
-                    && !is_from_proc_macro(cx, item)
+                !matches!(item.kind, ItemKind::Mod(_)) && !item.span.from_expansion() && !is_from_proc_macro(cx, item)
             })
             && !fulfill_or_allowed(cx, ITEMS_AFTER_TEST_MODULE, after.iter().map(|item| item.hir_id()))
         {
@@ -99,10 +97,7 @@ impl LateLintPass<'_> for ItemsAfterTestModule {
                     {
                         diag.multipart_suggestion_with_style(
                             "move the items to before the test module was defined",
-                            vec![
-                                (prev.span.shrink_to_hi(), items),
-                                (items_span, String::new())
-                            ],
+                            vec![(prev.span.shrink_to_hi(), items), (items_span, String::new())],
                             Applicability::MachineApplicable,
                             SuggestionStyle::HideCodeAlways,
                         );
diff --git a/clippy_lints/src/iter_without_into_iter.rs b/clippy_lints/src/iter_without_into_iter.rs
index 3f45c5dc259..3c291f25590 100644
--- a/clippy_lints/src/iter_without_into_iter.rs
+++ b/clippy_lints/src/iter_without_into_iter.rs
@@ -155,17 +155,18 @@ impl LateLintPass<'_> for IterWithoutIntoIter {
         if let ItemKind::Impl(imp) = item.kind
             && let TyKind::Ref(_, self_ty_without_ref) = &imp.self_ty.kind
             && let Some(trait_ref) = imp.of_trait
-            && trait_ref.trait_def_id().is_some_and(|did| cx.tcx.is_diagnostic_item(sym::IntoIterator, did))
+            && trait_ref
+                .trait_def_id()
+                .is_some_and(|did| cx.tcx.is_diagnostic_item(sym::IntoIterator, did))
             && let &ty::Ref(_, ty, mtbl) = cx.tcx.type_of(item.owner_id).instantiate_identity().kind()
             && let expected_method_name = match mtbl {
                 Mutability::Mut => sym::iter_mut,
                 Mutability::Not => sym::iter,
             }
-            && !deref_chain(cx, ty)
-                .any(|ty| {
-                    // We can't check inherent impls for slices, but we know that they have an `iter(_mut)` method
-                    ty.peel_refs().is_slice() || adt_has_inherent_method(cx, ty, expected_method_name)
-                })
+            && !deref_chain(cx, ty).any(|ty| {
+                // We can't check inherent impls for slices, but we know that they have an `iter(_mut)` method
+                ty.peel_refs().is_slice() || adt_has_inherent_method(cx, ty, expected_method_name)
+            })
             && let Some(iter_assoc_span) = imp.items.iter().find_map(|item| {
                 if item.ident.name == sym!(IntoIter) {
                     Some(cx.tcx.hir().impl_item(item.id).expect_type().span)
@@ -185,7 +186,7 @@ impl LateLintPass<'_> for IterWithoutIntoIter {
                     // to avoid name ambiguities, as there might be an inherent into_iter method
                     // that we don't want to call.
                     let sugg = format!(
-"
+                        "
 impl {self_ty_without_ref} {{
     fn {expected_method_name}({ref_self}self) -> {iter_ty} {{
         <{ref_self}Self as IntoIterator>::into_iter(self)
@@ -203,9 +204,9 @@ impl {self_ty_without_ref} {{
                         sugg,
                         // Just like iter_without_into_iter, this suggestion is on a best effort basis
                         // and requires potentially adding lifetimes or moving them around.
-                        Applicability::Unspecified
+                        Applicability::Unspecified,
                     );
-                }
+                },
             );
         }
     }
@@ -254,18 +255,22 @@ impl {self_ty_without_ref} {{
                 cx,
                 ITER_WITHOUT_INTO_ITER,
                 item.span,
-                &format!("`{}` method without an `IntoIterator` impl for `{self_ty_snippet}`", item.ident),
+                &format!(
+                    "`{}` method without an `IntoIterator` impl for `{self_ty_snippet}`",
+                    item.ident
+                ),
                 |diag| {
                     // Get the lower span of the `impl` block, and insert the suggestion right before it:
                     // impl X {
                     // ^   fn iter(&self) -> impl IntoIterator { ... }
                     // }
-                    let span_behind_impl = cx.tcx
+                    let span_behind_impl = cx
+                        .tcx
                         .def_span(cx.tcx.hir().parent_id(item.hir_id()).owner.def_id)
                         .shrink_to_lo();
 
                     let sugg = format!(
-"
+                        "
 impl IntoIterator for {self_ty_snippet} {{
     type IntoIter = {ret_ty};
     type Item = {iter_ty};
@@ -283,7 +288,8 @@ impl IntoIterator for {self_ty_snippet} {{
                         // such as adding some lifetimes in the associated types, or importing types.
                         Applicability::Unspecified,
                     );
-            });
+                },
+            );
         }
     }
 }
diff --git a/clippy_lints/src/large_stack_arrays.rs b/clippy_lints/src/large_stack_arrays.rs
index 0a5901bce04..5e312ab7240 100644
--- a/clippy_lints/src/large_stack_arrays.rs
+++ b/clippy_lints/src/large_stack_arrays.rs
@@ -39,27 +39,35 @@ impl_lint_pass!(LargeStackArrays => [LARGE_STACK_ARRAYS]);
 impl<'tcx> LateLintPass<'tcx> for LargeStackArrays {
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
         if let ExprKind::Repeat(_, _) | ExprKind::Array(_) = expr.kind
-          && let ty::Array(element_type, cst) = cx.typeck_results().expr_ty(expr).kind()
-          && let ConstKind::Value(ty::ValTree::Leaf(element_count)) = cst.kind()
-          && let Ok(element_count) = element_count.try_to_target_usize(cx.tcx)
-          && let Ok(element_size) = cx.layout_of(*element_type).map(|l| l.size.bytes())
-          && !cx.tcx.hir().parent_iter(expr.hir_id)
-              .any(|(_, node)| matches!(node, Node::Item(Item { kind: ItemKind::Static(..), .. })))
-          && self.maximum_allowed_size < u128::from(element_count) * u128::from(element_size) {
-              span_lint_and_help(
-                  cx,
-                  LARGE_STACK_ARRAYS,
-                  expr.span,
-                  &format!(
-                      "allocating a local array larger than {} bytes",
-                      self.maximum_allowed_size
-                  ),
-                  None,
-                  &format!(
-                      "consider allocating on the heap with `vec!{}.into_boxed_slice()`",
-                      snippet(cx, expr.span, "[...]")
-                  ),
-              );
-          }
+            && let ty::Array(element_type, cst) = cx.typeck_results().expr_ty(expr).kind()
+            && let ConstKind::Value(ty::ValTree::Leaf(element_count)) = cst.kind()
+            && let Ok(element_count) = element_count.try_to_target_usize(cx.tcx)
+            && let Ok(element_size) = cx.layout_of(*element_type).map(|l| l.size.bytes())
+            && !cx.tcx.hir().parent_iter(expr.hir_id).any(|(_, node)| {
+                matches!(
+                    node,
+                    Node::Item(Item {
+                        kind: ItemKind::Static(..),
+                        ..
+                    })
+                )
+            })
+            && self.maximum_allowed_size < u128::from(element_count) * u128::from(element_size)
+        {
+            span_lint_and_help(
+                cx,
+                LARGE_STACK_ARRAYS,
+                expr.span,
+                &format!(
+                    "allocating a local array larger than {} bytes",
+                    self.maximum_allowed_size
+                ),
+                None,
+                &format!(
+                    "consider allocating on the heap with `vec!{}.into_boxed_slice()`",
+                    snippet(cx, expr.span, "[...]")
+                ),
+            );
+        }
     }
 }
diff --git a/clippy_lints/src/len_zero.rs b/clippy_lints/src/len_zero.rs
index c06b35ca0da..08f095859e5 100644
--- a/clippy_lints/src/len_zero.rs
+++ b/clippy_lints/src/len_zero.rs
@@ -181,8 +181,7 @@ impl<'tcx> LateLintPass<'tcx> for LenZero {
             let mut applicability = Applicability::MachineApplicable;
 
             let lit1 = peel_ref_operators(cx, lt.init);
-            let lit_str =
-                Sugg::hir_with_context(cx, lit1, lt.span.ctxt(), "_", &mut applicability).maybe_par();
+            let lit_str = Sugg::hir_with_context(cx, lit1, lt.span.ctxt(), "_", &mut applicability).maybe_par();
 
             span_lint_and_sugg(
                 cx,
@@ -288,18 +287,26 @@ enum LenOutput {
 }
 
 fn extract_future_output<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Option<&'tcx PathSegment<'tcx>> {
-    if let ty::Alias(_, alias_ty) = ty.kind() &&
-        let Some(Node::Item(item)) = cx.tcx.hir().get_if_local(alias_ty.def_id) &&
-        let Item { kind: ItemKind::OpaqueTy(opaque), .. } = item &&
-        opaque.bounds.len() == 1 &&
-        let GenericBound::LangItemTrait(LangItem::Future, _, _, generic_args) = &opaque.bounds[0] &&
-        generic_args.bindings.len() == 1 &&
-        let TypeBindingKind::Equality {
-            term: rustc_hir::Term::Ty(rustc_hir::Ty {kind: TyKind::Path(QPath::Resolved(_, path)), .. }),
-        } = &generic_args.bindings[0].kind &&
-        path.segments.len() == 1 {
-            return Some(&path.segments[0]);
-        }
+    if let ty::Alias(_, alias_ty) = ty.kind()
+        && let Some(Node::Item(item)) = cx.tcx.hir().get_if_local(alias_ty.def_id)
+        && let Item {
+            kind: ItemKind::OpaqueTy(opaque),
+            ..
+        } = item
+        && opaque.bounds.len() == 1
+        && let GenericBound::LangItemTrait(LangItem::Future, _, _, generic_args) = &opaque.bounds[0]
+        && generic_args.bindings.len() == 1
+        && let TypeBindingKind::Equality {
+            term:
+                rustc_hir::Term::Ty(rustc_hir::Ty {
+                    kind: TyKind::Path(QPath::Resolved(_, path)),
+                    ..
+                }),
+        } = &generic_args.bindings[0].kind
+        && path.segments.len() == 1
+    {
+        return Some(&path.segments[0]);
+    }
 
     None
 }
diff --git a/clippy_lints/src/let_underscore.rs b/clippy_lints/src/let_underscore.rs
index 7a19b1c4273..04f23a213f2 100644
--- a/clippy_lints/src/let_underscore.rs
+++ b/clippy_lints/src/let_underscore.rs
@@ -159,14 +159,15 @@ impl<'tcx> LateLintPass<'tcx> for LetUnderscore {
                             binding or dropping explicitly with `std::mem::drop`",
                 );
             } else if let Some(future_trait_def_id) = cx.tcx.lang_items().future_trait()
-                && implements_trait(cx, cx.typeck_results().expr_ty(init), future_trait_def_id, &[]) {
+                && implements_trait(cx, cx.typeck_results().expr_ty(init), future_trait_def_id, &[])
+            {
                 span_lint_and_help(
                     cx,
                     LET_UNDERSCORE_FUTURE,
                     local.span,
                     "non-binding `let` on a future",
                     None,
-                    "consider awaiting the future or dropping explicitly with `std::mem::drop`"
+                    "consider awaiting the future or dropping explicitly with `std::mem::drop`",
                 );
             } else if is_must_use_ty(cx, cx.typeck_results().expr_ty(init)) {
                 span_lint_and_help(
@@ -203,17 +204,17 @@ impl<'tcx> LateLintPass<'tcx> for LetUnderscore {
                     return;
                 }
 
-				span_lint_and_help(
+                span_lint_and_help(
                     cx,
                     LET_UNDERSCORE_UNTYPED,
                     local.span,
                     "non-binding `let` without a type annotation",
-                    Some(
-						Span::new(local.pat.span.hi(),
-						local.pat.span.hi() + BytePos(1),
-						local.pat.span.ctxt(),
-						local.pat.span.parent()
-					)),
+                    Some(Span::new(
+                        local.pat.span.hi(),
+                        local.pat.span.hi() + BytePos(1),
+                        local.pat.span.ctxt(),
+                        local.pat.span.parent(),
+                    )),
                     "consider adding a type annotation",
                 );
             }
diff --git a/clippy_lints/src/lifetimes.rs b/clippy_lints/src/lifetimes.rs
index 35d7a9540af..4b89c0fa361 100644
--- a/clippy_lints/src/lifetimes.rs
+++ b/clippy_lints/src/lifetimes.rs
@@ -517,9 +517,11 @@ impl<'a, 'tcx> Visitor<'tcx> for RefVisitor<'a, 'tcx> {
 
     fn visit_poly_trait_ref(&mut self, poly_tref: &'tcx PolyTraitRef<'tcx>) {
         let trait_ref = &poly_tref.trait_ref;
-        if let Some(id) = trait_ref.trait_def_id() && lang_items::FN_TRAITS.iter().any(|&item| {
-            self.cx.tcx.lang_items().get(item) == Some(id)
-        }) {
+        if let Some(id) = trait_ref.trait_def_id()
+            && lang_items::FN_TRAITS
+                .iter()
+                .any(|&item| self.cx.tcx.lang_items().get(item) == Some(id))
+        {
             let mut sub_visitor = RefVisitor::new(self.cx);
             sub_visitor.visit_trait_ref(trait_ref);
             self.nested_elision_site_lts.append(&mut sub_visitor.all_lts());
diff --git a/clippy_lints/src/lines_filter_map_ok.rs b/clippy_lints/src/lines_filter_map_ok.rs
index 1304654efa6..0a5f5a80cb7 100644
--- a/clippy_lints/src/lines_filter_map_ok.rs
+++ b/clippy_lints/src/lines_filter_map_ok.rs
@@ -59,41 +59,56 @@ declare_lint_pass!(LinesFilterMapOk => [LINES_FILTER_MAP_OK]);
 
 impl LateLintPass<'_> for LinesFilterMapOk {
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
-        if let ExprKind::MethodCall(fm_method, fm_receiver, [fm_arg], fm_span) = expr.kind &&
-            is_trait_method(cx, expr, sym::Iterator) &&
-            (fm_method.ident.as_str() == "filter_map" || fm_method.ident.as_str() == "flat_map") &&
-            is_type_diagnostic_item(cx, cx.typeck_results().expr_ty_adjusted(fm_receiver), sym::IoLines)
+        if let ExprKind::MethodCall(fm_method, fm_receiver, [fm_arg], fm_span) = expr.kind
+            && is_trait_method(cx, expr, sym::Iterator)
+            && (fm_method.ident.as_str() == "filter_map" || fm_method.ident.as_str() == "flat_map")
+            && is_type_diagnostic_item(cx, cx.typeck_results().expr_ty_adjusted(fm_receiver), sym::IoLines)
         {
             let lint = match &fm_arg.kind {
                 // Detect `Result::ok`
-                ExprKind::Path(qpath) =>
-                    cx.qpath_res(qpath, fm_arg.hir_id).opt_def_id().map(|did|
-                        match_def_path(cx, did, &paths::CORE_RESULT_OK_METHOD)).unwrap_or_default(),
+                ExprKind::Path(qpath) => cx
+                    .qpath_res(qpath, fm_arg.hir_id)
+                    .opt_def_id()
+                    .map(|did| match_def_path(cx, did, &paths::CORE_RESULT_OK_METHOD))
+                    .unwrap_or_default(),
                 // Detect `|x| x.ok()`
-                ExprKind::Closure(Closure { body, .. }) =>
-                    if let Body { params: [param], value, .. } = cx.tcx.hir().body(*body) &&
-                        let ExprKind::MethodCall(method, receiver, [], _) = value.kind &&
-                        path_to_local_id(receiver, param.pat.hir_id) &&
-                        let Some(method_did) = cx.typeck_results().type_dependent_def_id(value.hir_id)
+                ExprKind::Closure(Closure { body, .. }) => {
+                    if let Body {
+                        params: [param], value, ..
+                    } = cx.tcx.hir().body(*body)
+                        && let ExprKind::MethodCall(method, receiver, [], _) = value.kind
+                        && path_to_local_id(receiver, param.pat.hir_id)
+                        && let Some(method_did) = cx.typeck_results().type_dependent_def_id(value.hir_id)
                     {
                         is_diag_item_method(cx, method_did, sym::Result) && method.ident.as_str() == "ok"
                     } else {
                         false
                     }
+                },
                 _ => false,
             };
             if lint {
-                span_lint_and_then(cx,
+                span_lint_and_then(
+                    cx,
                     LINES_FILTER_MAP_OK,
                     fm_span,
-                    &format!("`{}()` will run forever if the iterator repeatedly produces an `Err`", fm_method.ident),
+                    &format!(
+                        "`{}()` will run forever if the iterator repeatedly produces an `Err`",
+                        fm_method.ident
+                    ),
                     |diag| {
                         diag.span_note(
                             fm_receiver.span,
                             "this expression returning a `std::io::Lines` may produce an infinite number of `Err` in case of a read error");
-                        diag.span_suggestion(fm_span, "replace with", "map_while(Result::ok)", Applicability::MaybeIncorrect);
-                    });
-                }
+                        diag.span_suggestion(
+                            fm_span,
+                            "replace with",
+                            "map_while(Result::ok)",
+                            Applicability::MaybeIncorrect,
+                        );
+                    },
+                );
+            }
         }
     }
 }
diff --git a/clippy_lints/src/loops/explicit_iter_loop.rs b/clippy_lints/src/loops/explicit_iter_loop.rs
index 92ee033df47..1c2b7a169fc 100644
--- a/clippy_lints/src/loops/explicit_iter_loop.rs
+++ b/clippy_lints/src/loops/explicit_iter_loop.rs
@@ -113,7 +113,9 @@ fn is_ref_iterable<'tcx>(
     let typeck = cx.typeck_results();
     if let Some(trait_id) = cx.tcx.get_diagnostic_item(sym::IntoIterator)
         && let Some(fn_id) = typeck.type_dependent_def_id(call_expr.hir_id)
-        && let sig = cx.tcx.liberate_late_bound_regions(fn_id, cx.tcx.fn_sig(fn_id).skip_binder())
+        && let sig = cx
+            .tcx
+            .liberate_late_bound_regions(fn_id, cx.tcx.fn_sig(fn_id).skip_binder())
         && let &[req_self_ty, req_res_ty] = &**sig.inputs_and_output
         && let param_env = cx.tcx.param_env(fn_id)
         && implements_trait_with_env(cx.tcx, param_env, req_self_ty, trait_id, &[])
@@ -131,8 +133,9 @@ fn is_ref_iterable<'tcx>(
             return Some((AdjustKind::None, self_ty));
         }
 
-        let res_ty = cx.tcx.erase_regions(EarlyBinder::bind(req_res_ty)
-            .instantiate(cx.tcx, typeck.node_args(call_expr.hir_id)));
+        let res_ty = cx
+            .tcx
+            .erase_regions(EarlyBinder::bind(req_res_ty).instantiate(cx.tcx, typeck.node_args(call_expr.hir_id)));
         let mutbl = if let ty::Ref(_, _, mutbl) = *req_self_ty.kind() {
             Some(mutbl)
         } else {
@@ -157,7 +160,7 @@ fn is_ref_iterable<'tcx>(
                 let self_ty = if mutbl.is_mut() {
                     self_ty
                 } else {
-                    Ty::new_ref(cx.tcx,region, TypeAndMut { ty, mutbl })
+                    Ty::new_ref(cx.tcx, region, TypeAndMut { ty, mutbl })
                 };
                 if implements_trait(cx, self_ty, trait_id, &[])
                     && let Some(ty) =
@@ -172,10 +175,7 @@ fn is_ref_iterable<'tcx>(
             && !self_ty.is_ref()
         {
             // Attempt to borrow
-            let self_ty = Ty::new_ref(cx.tcx,cx.tcx.lifetimes.re_erased, TypeAndMut {
-                ty: self_ty,
-                mutbl,
-            });
+            let self_ty = Ty::new_ref(cx.tcx, cx.tcx.lifetimes.re_erased, TypeAndMut { ty: self_ty, mutbl });
             if implements_trait(cx, self_ty, trait_id, &[])
                 && let Some(ty) = make_normalized_projection(cx.tcx, cx.param_env, trait_id, sym!(IntoIter), [self_ty])
                 && ty == res_ty
@@ -187,12 +187,14 @@ fn is_ref_iterable<'tcx>(
         match adjustments {
             [] => Some((AdjustKind::None, self_ty)),
             &[
-                Adjustment { kind: Adjust::Deref(_), ..},
+                Adjustment {
+                    kind: Adjust::Deref(_), ..
+                },
                 Adjustment {
                     kind: Adjust::Borrow(AutoBorrow::Ref(_, mutbl)),
                     target,
                 },
-                ..
+                ..,
             ] => {
                 if enforce_iter_loop_reborrow
                     && target != self_ty
@@ -205,8 +207,14 @@ fn is_ref_iterable<'tcx>(
                 } else {
                     None
                 }
-            }
-            &[Adjustment { kind: Adjust::Deref(_), target }, ..] => {
+            },
+            &[
+                Adjustment {
+                    kind: Adjust::Deref(_),
+                    target,
+                },
+                ..,
+            ] => {
                 if is_copy(cx, target)
                     && implements_trait(cx, target, trait_id, &[])
                     && let Some(ty) =
@@ -217,13 +225,13 @@ fn is_ref_iterable<'tcx>(
                 } else {
                     None
                 }
-            }
+            },
             &[
                 Adjustment {
                     kind: Adjust::Borrow(AutoBorrow::Ref(_, mutbl)),
                     target,
                 },
-                ..
+                ..,
             ] => {
                 if self_ty.is_ref()
                     && implements_trait(cx, target, trait_id, &[])
@@ -235,7 +243,7 @@ fn is_ref_iterable<'tcx>(
                 } else {
                     None
                 }
-            }
+            },
             _ => None,
         }
     } else {
diff --git a/clippy_lints/src/loops/never_loop.rs b/clippy_lints/src/loops/never_loop.rs
index 3d8a4cd948a..cc054cb4669 100644
--- a/clippy_lints/src/loops/never_loop.rs
+++ b/clippy_lints/src/loops/never_loop.rs
@@ -271,9 +271,9 @@ fn never_loop_expr<'tcx>(
             NeverLoopResult::Normal
         }
     });
-    if  let NeverLoopResult::Diverging = result &&
-        let Some(macro_call) = root_macro_call_first_node(cx, expr) &&
-        let Some(sym::todo_macro) = cx.tcx.get_diagnostic_name(macro_call.def_id)
+    if let NeverLoopResult::Diverging = result
+        && let Some(macro_call) = root_macro_call_first_node(cx, expr)
+        && let Some(sym::todo_macro) = cx.tcx.get_diagnostic_name(macro_call.def_id)
     {
         // We return MayContinueMainLoop here because we treat `todo!()`
         // as potentially containing any code, including a continue of the main loop.
diff --git a/clippy_lints/src/manual_assert.rs b/clippy_lints/src/manual_assert.rs
index 044d99bc0f7..9a3da975f83 100644
--- a/clippy_lints/src/manual_assert.rs
+++ b/clippy_lints/src/manual_assert.rs
@@ -64,7 +64,8 @@ impl<'tcx> LateLintPass<'tcx> for ManualAssert {
             };
             let cond_sugg = sugg::Sugg::hir_with_applicability(cx, cond, "..", &mut applicability).maybe_par();
             let sugg = format!("assert!({not}{cond_sugg}, {format_args_snip});");
-            // we show to the user the suggestion without the comments, but when applying the fix, include the comments in the block
+            // we show to the user the suggestion without the comments, but when applying the fix, include the
+            // comments in the block
             span_lint_and_then(
                 cx,
                 MANUAL_ASSERT,
@@ -77,16 +78,11 @@ impl<'tcx> LateLintPass<'tcx> for ManualAssert {
                             expr.span.shrink_to_lo(),
                             "add comments back",
                             comments,
-                            applicability
+                            applicability,
                         );
                     }
-                    diag.span_suggestion(
-                        expr.span,
-                        "try instead",
-                        sugg,
-                        applicability
-                    );
-                }
+                    diag.span_suggestion(expr.span, "try instead", sugg, applicability);
+                },
             );
         }
     }
diff --git a/clippy_lints/src/manual_async_fn.rs b/clippy_lints/src/manual_async_fn.rs
index c0b67a14388..998de38a995 100644
--- a/clippy_lints/src/manual_async_fn.rs
+++ b/clippy_lints/src/manual_async_fn.rs
@@ -4,7 +4,7 @@ use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::{
-    CoroutineSource, Block, Body, Closure, CoroutineKind, Expr, ExprKind, FnDecl, FnRetTy, GenericArg, GenericBound,
+    Block, Body, Closure, CoroutineKind, CoroutineSource, Expr, ExprKind, FnDecl, FnRetTy, GenericArg, GenericBound,
     ImplItem, Item, ItemKind, LifetimeName, Node, Term, TraitRef, Ty, TyKind, TypeBindingKind,
 };
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/manual_clamp.rs b/clippy_lints/src/manual_clamp.rs
index ec87ff3ef6a..09c90e38e11 100644
--- a/clippy_lints/src/manual_clamp.rs
+++ b/clippy_lints/src/manual_clamp.rs
@@ -225,11 +225,11 @@ fn is_if_elseif_else_pattern<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx
         then,
         r#else: Some(else_if),
     }) = If::hir(expr)
-    && let Some(If {
-        cond: else_if_cond,
-        then: else_if_then,
-        r#else: Some(else_body),
-    }) = If::hir(peel_blocks(else_if))
+        && let Some(If {
+            cond: else_if_cond,
+            then: else_if_then,
+            r#else: Some(else_body),
+        }) = If::hir(peel_blocks(else_if))
     {
         let params = is_clamp_meta_pattern(
             cx,
@@ -275,7 +275,12 @@ fn is_max_min_pattern<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> O
             _ => return None,
         };
         Some(ClampSuggestion {
-            params: InputMinMax { input, min, max, is_float },
+            params: InputMinMax {
+                input,
+                min,
+                max,
+                is_float,
+            },
             span: expr.span,
             make_assignment: None,
             hir_with_ignore_attr: None,
@@ -346,11 +351,16 @@ fn is_call_max_min_pattern<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>)
                         ("max", "min") => (inner_arg, outer_arg),
                         _ => return None,
                     }
-                }
+                },
                 _ => return None,
             };
             Some(ClampSuggestion {
-                params: InputMinMax { input, min, max, is_float },
+                params: InputMinMax {
+                    input,
+                    min,
+                    max,
+                    is_float,
+                },
                 span,
                 make_assignment: None,
                 hir_with_ignore_attr: None,
@@ -384,7 +394,8 @@ fn is_match_pattern<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> Opt
         // Find possible min/max branches
         let minmax_values = |a: &'tcx Arm<'tcx>| {
             if let PatKind::Binding(_, var_hir_id, _, None) = &a.pat.kind
-            && let Some(Guard::If(e)) = a.guard {
+                && let Some(Guard::If(e)) = a.guard
+            {
                 Some((e, var_hir_id, a.body))
             } else {
                 None
@@ -441,18 +452,20 @@ fn is_two_if_pattern<'tcx>(cx: &LateContext<'tcx>, block: &'tcx Block<'tcx>) ->
         .filter_map(|(maybe_set_first, maybe_set_second)| {
             if let StmtKind::Expr(first_expr) = *maybe_set_first
                 && let StmtKind::Expr(second_expr) = *maybe_set_second
-                && let Some(If { cond: first_cond, then: first_then, r#else: None }) = If::hir(first_expr)
-                && let Some(If { cond: second_cond, then: second_then, r#else: None }) = If::hir(second_expr)
-                && let ExprKind::Assign(
-                    maybe_input_first_path,
-                    maybe_min_max_first,
-                    _
-                ) = peel_blocks_with_stmt(first_then).kind
-                && let ExprKind::Assign(
-                    maybe_input_second_path,
-                    maybe_min_max_second,
-                    _
-                ) = peel_blocks_with_stmt(second_then).kind
+                && let Some(If {
+                    cond: first_cond,
+                    then: first_then,
+                    r#else: None,
+                }) = If::hir(first_expr)
+                && let Some(If {
+                    cond: second_cond,
+                    then: second_then,
+                    r#else: None,
+                }) = If::hir(second_expr)
+                && let ExprKind::Assign(maybe_input_first_path, maybe_min_max_first, _) =
+                    peel_blocks_with_stmt(first_then).kind
+                && let ExprKind::Assign(maybe_input_second_path, maybe_min_max_second, _) =
+                    peel_blocks_with_stmt(second_then).kind
                 && eq_expr_value(cx, maybe_input_first_path, maybe_input_second_path)
                 && let Some(first_bin) = BinaryOp::new(first_cond)
                 && let Some(second_bin) = BinaryOp::new(second_cond)
@@ -462,7 +475,7 @@ fn is_two_if_pattern<'tcx>(cx: &LateContext<'tcx>, block: &'tcx Block<'tcx>) ->
                     &second_bin,
                     maybe_min_max_first,
                     maybe_min_max_second,
-                    None
+                    None,
                 )
             {
                 Some(ClampSuggestion {
@@ -505,16 +518,9 @@ fn is_if_elseif_pattern<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) ->
             then: else_if_then,
             r#else: None,
         }) = If::hir(peel_blocks(else_if))
-        && let ExprKind::Assign(
-            maybe_input_first_path,
-            maybe_min_max_first,
-            _
-        ) = peel_blocks_with_stmt(then).kind
-        && let ExprKind::Assign(
-            maybe_input_second_path,
-            maybe_min_max_second,
-            _
-        ) = peel_blocks_with_stmt(else_if_then).kind
+        && let ExprKind::Assign(maybe_input_first_path, maybe_min_max_first, _) = peel_blocks_with_stmt(then).kind
+        && let ExprKind::Assign(maybe_input_second_path, maybe_min_max_second, _) =
+            peel_blocks_with_stmt(else_if_then).kind
     {
         let params = is_clamp_meta_pattern(
             cx,
diff --git a/clippy_lints/src/manual_float_methods.rs b/clippy_lints/src/manual_float_methods.rs
index c27ce062338..0c4101ceb6b 100644
--- a/clippy_lints/src/manual_float_methods.rs
+++ b/clippy_lints/src/manual_float_methods.rs
@@ -114,46 +114,40 @@ impl<'tcx> LateLintPass<'tcx> for ManualFloatMethods {
                 _ => return,
             };
 
-            span_lint_and_then(
-                cx,
-                variant.lint(),
-                expr.span,
-                variant.msg(),
-                |diag| {
-                    match variant {
-                        Variant::ManualIsInfinite => {
-                            diag.span_suggestion(
-                                expr.span,
-                                "use the dedicated method instead",
-                                format!("{local_snippet}.is_infinite()"),
-                                Applicability::MachineApplicable,
-                            );
-                        },
-                        Variant::ManualIsFinite => {
-                            // TODO: There's probably some better way to do this, i.e., create
-                            // multiple suggestions with notes between each of them
-                            diag.span_suggestion_verbose(
-                                expr.span,
-                                "use the dedicated method instead",
-                                format!("{local_snippet}.is_finite()"),
-                                Applicability::MaybeIncorrect,
-                            )
-                            .span_suggestion_verbose(
-                                expr.span,
-                                "this will alter how it handles NaN; if that is a problem, use instead",
-                                format!("{local_snippet}.is_finite() || {local_snippet}.is_nan()"),
-                                Applicability::MaybeIncorrect,
-                            )
-                            .span_suggestion_verbose(
-                                expr.span,
-                                "or, for conciseness",
-                                format!("!{local_snippet}.is_infinite()"),
-                                Applicability::MaybeIncorrect,
-                            );
-                        },
-                    }
-                },
-            );
+            span_lint_and_then(cx, variant.lint(), expr.span, variant.msg(), |diag| {
+                match variant {
+                    Variant::ManualIsInfinite => {
+                        diag.span_suggestion(
+                            expr.span,
+                            "use the dedicated method instead",
+                            format!("{local_snippet}.is_infinite()"),
+                            Applicability::MachineApplicable,
+                        );
+                    },
+                    Variant::ManualIsFinite => {
+                        // TODO: There's probably some better way to do this, i.e., create
+                        // multiple suggestions with notes between each of them
+                        diag.span_suggestion_verbose(
+                            expr.span,
+                            "use the dedicated method instead",
+                            format!("{local_snippet}.is_finite()"),
+                            Applicability::MaybeIncorrect,
+                        )
+                        .span_suggestion_verbose(
+                            expr.span,
+                            "this will alter how it handles NaN; if that is a problem, use instead",
+                            format!("{local_snippet}.is_finite() || {local_snippet}.is_nan()"),
+                            Applicability::MaybeIncorrect,
+                        )
+                        .span_suggestion_verbose(
+                            expr.span,
+                            "or, for conciseness",
+                            format!("!{local_snippet}.is_infinite()"),
+                            Applicability::MaybeIncorrect,
+                        );
+                    },
+                }
+            });
         }
     }
 }
diff --git a/clippy_lints/src/manual_hash_one.rs b/clippy_lints/src/manual_hash_one.rs
index 19f2e1dc42c..472b4eb9006 100644
--- a/clippy_lints/src/manual_hash_one.rs
+++ b/clippy_lints/src/manual_hash_one.rs
@@ -117,12 +117,11 @@ impl LateLintPass<'_> for ManualHashOne {
                                     finish_expr.span,
                                     // `needless_borrows_for_generic_args` will take care of
                                     // removing the `&` when it isn't needed
-                                    format!("{build_hasher}.hash_one(&{hashed_value})")
-                                )
+                                    format!("{build_hasher}.hash_one(&{hashed_value})"),
+                                ),
                             ],
                             Applicability::MachineApplicable,
                         );
-
                     }
                 },
             );
diff --git a/clippy_lints/src/manual_is_ascii_check.rs b/clippy_lints/src/manual_is_ascii_check.rs
index 17415b58d9e..468f4170732 100644
--- a/clippy_lints/src/manual_is_ascii_check.rs
+++ b/clippy_lints/src/manual_is_ascii_check.rs
@@ -98,15 +98,20 @@ impl<'tcx> LateLintPass<'tcx> for ManualIsAsciiCheck {
         }
 
         if let Some(macro_call) = root_macro_call(expr.span)
-            && is_matches_macro(cx, macro_call.def_id) {
+            && is_matches_macro(cx, macro_call.def_id)
+        {
             if let ExprKind::Match(recv, [arm, ..], _) = expr.kind {
                 let range = check_pat(&arm.pat.kind);
                 check_is_ascii(cx, macro_call.span, recv, &range);
             }
         } else if let ExprKind::MethodCall(path, receiver, [arg], ..) = expr.kind
             && path.ident.name == sym!(contains)
-            && let Some(higher::Range { start: Some(start), end: Some(end), limits: RangeLimits::Closed })
-            = higher::Range::hir(receiver) {
+            && let Some(higher::Range {
+                start: Some(start),
+                end: Some(end),
+                limits: RangeLimits::Closed,
+            }) = higher::Range::hir(receiver)
+        {
             let range = check_range(start, end);
             if let ExprKind::AddrOf(BorrowKind::Ref, _, e) = arg.kind {
                 check_is_ascii(cx, expr.span, e, &range);
@@ -168,7 +173,8 @@ fn check_pat(pat_kind: &PatKind<'_>) -> CharRange {
 
 fn check_range(start: &Expr<'_>, end: &Expr<'_>) -> CharRange {
     if let ExprKind::Lit(start_lit) = &start.kind
-        && let ExprKind::Lit(end_lit) = &end.kind {
+        && let ExprKind::Lit(end_lit) = &end.kind
+    {
         match (&start_lit.node, &end_lit.node) {
             (Char('a'), Char('z')) | (Byte(b'a'), Byte(b'z')) => CharRange::LowerChar,
             (Char('A'), Char('Z')) | (Byte(b'A'), Byte(b'Z')) => CharRange::UpperChar,
diff --git a/clippy_lints/src/manual_let_else.rs b/clippy_lints/src/manual_let_else.rs
index 7888fc10a0b..170a040d4ae 100644
--- a/clippy_lints/src/manual_let_else.rs
+++ b/clippy_lints/src/manual_let_else.rs
@@ -56,21 +56,20 @@ impl<'tcx> QuestionMark {
             return;
         }
 
-        if let StmtKind::Local(local) = stmt.kind &&
-            let Some(init) = local.init &&
-            local.els.is_none() &&
-            local.ty.is_none() &&
-            init.span.eq_ctxt(stmt.span) &&
-            let Some(if_let_or_match) = IfLetOrMatch::parse(cx, init)
+        if let StmtKind::Local(local) = stmt.kind
+            && let Some(init) = local.init
+            && local.els.is_none()
+            && local.ty.is_none()
+            && init.span.eq_ctxt(stmt.span)
+            && 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
-                        let Some(ident_map) = expr_simple_identity_map(local.pat, let_pat, if_then) &&
-                        let Some(if_else) = if_else &&
-                        expr_diverges(cx, if_else) &&
-                        let qm_allowed = is_lint_allowed(cx, QUESTION_MARK, stmt.hir_id) &&
-                        (qm_allowed || pat_and_expr_can_be_question_mark(cx, let_pat, if_else).is_none())
+                    if let Some(ident_map) = expr_simple_identity_map(local.pat, let_pat, if_then)
+                        && let Some(if_else) = if_else
+                        && expr_diverges(cx, if_else)
+                        && let qm_allowed = is_lint_allowed(cx, QUESTION_MARK, stmt.hir_id)
+                        && (qm_allowed || pat_and_expr_can_be_question_mark(cx, let_pat, if_else).is_none())
                     {
                         emit_manual_let_else(cx, stmt.span, if_let_expr, &ident_map, let_pat, if_else);
                     }
@@ -96,7 +95,9 @@ impl<'tcx> QuestionMark {
                         .iter()
                         .enumerate()
                         .find(|(_, arm)| expr_diverges(cx, arm.body) && pat_allowed_for_else(cx, arm.pat, check_types));
-                    let Some((idx, diverging_arm)) = diverging_arm_opt else { return; };
+                    let Some((idx, diverging_arm)) = diverging_arm_opt else {
+                        return;
+                    };
                     // If the non-diverging arm is the first one, its pattern can be reused in a let/else statement.
                     // However, if it arrives in second position, its pattern may cover some cases already covered
                     // by the diverging one.
@@ -106,7 +107,7 @@ impl<'tcx> QuestionMark {
                     }
                     let pat_arm = &arms[1 - idx];
                     let Some(ident_map) = expr_simple_identity_map(local.pat, pat_arm.pat, pat_arm.body) else {
-                        return
+                        return;
                     };
 
                     emit_manual_let_else(cx, stmt.span, match_expr, &ident_map, pat_arm.pat, diverging_arm.body);
@@ -217,8 +218,8 @@ fn replace_in_pattern(
                 let fields = fields
                     .iter()
                     .map(|fld| {
-                        if let PatKind::Binding(_, _, name, None) = fld.pat.kind &&
-                            let Some(pat_to_put) = ident_map.get(&name.name)
+                        if let PatKind::Binding(_, _, name, None) = fld.pat.kind
+                            && let Some(pat_to_put) = ident_map.get(&name.name)
                         {
                             let (sn_fld_name, _) = snippet_with_context(cx, fld.ident.span, span.ctxt(), "", app);
                             let (sn_ptp, _) = snippet_with_context(cx, pat_to_put.span, span.ctxt(), "", app);
@@ -464,8 +465,8 @@ fn expr_simple_identity_map<'a, 'hir>(
     }
     let mut ident_map = FxHashMap::default();
     for (sub_pat, path) in sub_pats.iter().zip(paths.iter()) {
-        if let ExprKind::Path(QPath::Resolved(_ty, path)) = path.kind &&
-            let [path_seg] = path.segments
+        if let ExprKind::Path(QPath::Resolved(_ty, path)) = path.kind
+            && let [path_seg] = path.segments
         {
             let ident = path_seg.ident;
             if !pat_bindings.remove(&ident) {
diff --git a/clippy_lints/src/manual_main_separator_str.rs b/clippy_lints/src/manual_main_separator_str.rs
index 8f5e7982242..23f47c86fcc 100644
--- a/clippy_lints/src/manual_main_separator_str.rs
+++ b/clippy_lints/src/manual_main_separator_str.rs
@@ -47,27 +47,27 @@ impl_lint_pass!(ManualMainSeparatorStr => [MANUAL_MAIN_SEPARATOR_STR]);
 
 impl LateLintPass<'_> for ManualMainSeparatorStr {
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
-        if self.msrv.meets(msrvs::PATH_MAIN_SEPARATOR_STR) &&
-            let (target, _) = peel_hir_expr_refs(expr) &&
-            is_trait_method(cx, target, sym::ToString) &&
-            let ExprKind::MethodCall(path, receiver, &[], _) = target.kind &&
-            path.ident.name == sym::to_string &&
-            let ExprKind::Path(QPath::Resolved(None, path)) = receiver.kind &&
-            let Res::Def(DefKind::Const, receiver_def_id) = path.res &&
-            match_def_path(cx, receiver_def_id, &paths::PATH_MAIN_SEPARATOR) &&
-            let ty::Ref(_, ty, Mutability::Not) = cx.typeck_results().expr_ty_adjusted(expr).kind() &&
-            ty.is_str()
-            {
-                span_lint_and_sugg(
-                    cx,
-                    MANUAL_MAIN_SEPARATOR_STR,
-                    expr.span,
-                    "taking a reference on `std::path::MAIN_SEPARATOR` conversion to `String`",
-                    "replace with",
-                    "std::path::MAIN_SEPARATOR_STR".to_owned(),
-                    Applicability::MachineApplicable,
-                );
-            }
+        if self.msrv.meets(msrvs::PATH_MAIN_SEPARATOR_STR)
+            && let (target, _) = peel_hir_expr_refs(expr)
+            && is_trait_method(cx, target, sym::ToString)
+            && let ExprKind::MethodCall(path, receiver, &[], _) = target.kind
+            && path.ident.name == sym::to_string
+            && let ExprKind::Path(QPath::Resolved(None, path)) = receiver.kind
+            && let Res::Def(DefKind::Const, receiver_def_id) = path.res
+            && match_def_path(cx, receiver_def_id, &paths::PATH_MAIN_SEPARATOR)
+            && let ty::Ref(_, ty, Mutability::Not) = cx.typeck_results().expr_ty_adjusted(expr).kind()
+            && ty.is_str()
+        {
+            span_lint_and_sugg(
+                cx,
+                MANUAL_MAIN_SEPARATOR_STR,
+                expr.span,
+                "taking a reference on `std::path::MAIN_SEPARATOR` conversion to `String`",
+                "replace with",
+                "std::path::MAIN_SEPARATOR_STR".to_owned(),
+                Applicability::MachineApplicable,
+            );
+        }
     }
 
     extract_msrv_attr!(LateContext);
diff --git a/clippy_lints/src/manual_non_exhaustive.rs b/clippy_lints/src/manual_non_exhaustive.rs
index 4c44ac7fa11..fc8f2363001 100644
--- a/clippy_lints/src/manual_non_exhaustive.rs
+++ b/clippy_lints/src/manual_non_exhaustive.rs
@@ -138,7 +138,7 @@ impl EarlyLintPass for ManualNonExhaustiveStruct {
                             );
                         }
                         diag.span_help(field.span, "remove this field");
-                    }
+                    },
                 );
             }
         }
diff --git a/clippy_lints/src/manual_rem_euclid.rs b/clippy_lints/src/manual_rem_euclid.rs
index b435fcf61df..bc8372fbd41 100644
--- a/clippy_lints/src/manual_rem_euclid.rs
+++ b/clippy_lints/src/manual_rem_euclid.rs
@@ -76,30 +76,31 @@ impl<'tcx> LateLintPass<'tcx> for ManualRemEuclid {
             // Also ensures the const is nonzero since zero can't be a divisor
             && const1 == const2 && const2 == const3
             && let Some(hir_id) = path_to_local(expr3)
-            && let Some(Node::Pat(_)) = cx.tcx.hir().find(hir_id) {
-                // Apply only to params or locals with annotated types
-                match cx.tcx.hir().find_parent(hir_id) {
-                    Some(Node::Param(..)) => (),
-                    Some(Node::Local(local)) => {
-                        let Some(ty) = local.ty else { return };
-                        if matches!(ty.kind, TyKind::Infer) {
-                            return;
-                        }
+            && let Some(Node::Pat(_)) = cx.tcx.hir().find(hir_id)
+        {
+            // Apply only to params or locals with annotated types
+            match cx.tcx.hir().find_parent(hir_id) {
+                Some(Node::Param(..)) => (),
+                Some(Node::Local(local)) => {
+                    let Some(ty) = local.ty else { return };
+                    if matches!(ty.kind, TyKind::Infer) {
+                        return;
                     }
-                    _ => return,
-                };
+                },
+                _ => return,
+            };
 
-                let mut app = Applicability::MachineApplicable;
-                let rem_of = snippet_with_context(cx, expr3.span, ctxt, "_", &mut app).0;
-                span_lint_and_sugg(
-                    cx,
-                    MANUAL_REM_EUCLID,
-                    expr.span,
-                    "manual `rem_euclid` implementation",
-                    "consider using",
-                    format!("{rem_of}.rem_euclid({const1})"),
-                    app,
-                );
+            let mut app = Applicability::MachineApplicable;
+            let rem_of = snippet_with_context(cx, expr3.span, ctxt, "_", &mut app).0;
+            span_lint_and_sugg(
+                cx,
+                MANUAL_REM_EUCLID,
+                expr.span,
+                "manual `rem_euclid` implementation",
+                "consider using",
+                format!("{rem_of}.rem_euclid({const1})"),
+                app,
+            );
         }
     }
 
diff --git a/clippy_lints/src/manual_retain.rs b/clippy_lints/src/manual_retain.rs
index f902b48fa81..2f8682d0418 100644
--- a/clippy_lints/src/manual_retain.rs
+++ b/clippy_lints/src/manual_retain.rs
@@ -97,7 +97,8 @@ fn check_into_iter(
         && let Some(into_iter_def_id) = cx.typeck_results().type_dependent_def_id(into_iter_expr.hir_id)
         && Some(into_iter_def_id) == cx.tcx.lang_items().into_iter_fn()
         && match_acceptable_type(cx, left_expr, msrv)
-        && SpanlessEq::new(cx).eq_expr(left_expr, struct_expr) {
+        && SpanlessEq::new(cx).eq_expr(left_expr, struct_expr)
+    {
         suggest(cx, parent_expr, left_expr, target_expr);
     }
 }
@@ -120,7 +121,8 @@ fn check_iter(
         && let Some(iter_expr_def_id) = cx.typeck_results().type_dependent_def_id(iter_expr.hir_id)
         && match_acceptable_def_path(cx, iter_expr_def_id)
         && match_acceptable_type(cx, left_expr, msrv)
-        && SpanlessEq::new(cx).eq_expr(left_expr, struct_expr) {
+        && SpanlessEq::new(cx).eq_expr(left_expr, struct_expr)
+    {
         suggest(cx, parent_expr, left_expr, filter_expr);
     }
 }
@@ -144,33 +146,35 @@ fn check_to_owned(
         && match_def_path(cx, chars_expr_def_id, &paths::STR_CHARS)
         && let ty = cx.typeck_results().expr_ty(str_expr).peel_refs()
         && is_type_lang_item(cx, ty, hir::LangItem::String)
-        && SpanlessEq::new(cx).eq_expr(left_expr, str_expr) {
+        && SpanlessEq::new(cx).eq_expr(left_expr, str_expr)
+    {
         suggest(cx, parent_expr, left_expr, filter_expr);
     }
 }
 
 fn suggest(cx: &LateContext<'_>, parent_expr: &hir::Expr<'_>, left_expr: &hir::Expr<'_>, filter_expr: &hir::Expr<'_>) {
     if let hir::ExprKind::MethodCall(_, _, [closure], _) = filter_expr.kind
-        && let hir::ExprKind::Closure(&hir::Closure { body, ..}) = closure.kind
+        && let hir::ExprKind::Closure(&hir::Closure { body, .. }) = closure.kind
         && let filter_body = cx.tcx.hir().body(body)
         && let [filter_params] = filter_body.params
         && let Some(sugg) = match filter_params.pat.kind {
-            hir::PatKind::Binding(_, _, filter_param_ident, None) => {
-                Some(format!("{}.retain(|{filter_param_ident}| {})", snippet(cx, left_expr.span, ".."), snippet(cx, filter_body.value.span, "..")))
-            },
-            hir::PatKind::Tuple([key_pat, value_pat], _) => {
-                make_sugg(cx, key_pat, value_pat, left_expr, filter_body)
-            },
-            hir::PatKind::Ref(pat, _) => {
-                match pat.kind {
-                    hir::PatKind::Binding(_, _, filter_param_ident, None) => {
-                        Some(format!("{}.retain(|{filter_param_ident}| {})", snippet(cx, left_expr.span, ".."), snippet(cx, filter_body.value.span, "..")))
-                    },
-                    _ => None
-                }
+            hir::PatKind::Binding(_, _, filter_param_ident, None) => Some(format!(
+                "{}.retain(|{filter_param_ident}| {})",
+                snippet(cx, left_expr.span, ".."),
+                snippet(cx, filter_body.value.span, "..")
+            )),
+            hir::PatKind::Tuple([key_pat, value_pat], _) => make_sugg(cx, key_pat, value_pat, left_expr, filter_body),
+            hir::PatKind::Ref(pat, _) => match pat.kind {
+                hir::PatKind::Binding(_, _, filter_param_ident, None) => Some(format!(
+                    "{}.retain(|{filter_param_ident}| {})",
+                    snippet(cx, left_expr.span, ".."),
+                    snippet(cx, filter_body.value.span, "..")
+                )),
+                _ => None,
             },
-            _ => None
-        } {
+            _ => None,
+        }
+    {
         span_lint_and_sugg(
             cx,
             MANUAL_RETAIN,
@@ -178,7 +182,7 @@ fn suggest(cx: &LateContext<'_>, parent_expr: &hir::Expr<'_>, left_expr: &hir::E
             "this expression can be written more simply using `.retain()`",
             "consider calling `.retain()` instead",
             sugg,
-            Applicability::MachineApplicable
+            Applicability::MachineApplicable,
         );
     }
 }
diff --git a/clippy_lints/src/manual_string_new.rs b/clippy_lints/src/manual_string_new.rs
index 726087d4562..f8afae0e1f5 100644
--- a/clippy_lints/src/manual_string_new.rs
+++ b/clippy_lints/src/manual_string_new.rs
@@ -65,9 +65,9 @@ impl LateLintPass<'_> for ManualStringNew {
 
 /// Checks if an expression's kind corresponds to an empty &str.
 fn is_expr_kind_empty_str(expr_kind: &ExprKind<'_>) -> bool {
-    if  let ExprKind::Lit(lit) = expr_kind &&
-        let LitKind::Str(value, _) = lit.node &&
-        value == symbol::kw::Empty
+    if let ExprKind::Lit(lit) = expr_kind
+        && let LitKind::Str(value, _) = lit.node
+        && value == symbol::kw::Empty
     {
         return true;
     }
@@ -110,23 +110,22 @@ fn parse_call(cx: &LateContext<'_>, span: Span, func: &Expr<'_>, args: &[Expr<'_
     if let ExprKind::Path(qpath) = &func.kind {
         if let QPath::TypeRelative(_, _) = qpath {
             // String::from(...) or String::try_from(...)
-            if  let QPath::TypeRelative(ty, path_seg) = qpath &&
-                [sym::from, sym::try_from].contains(&path_seg.ident.name) &&
-                let TyKind::Path(qpath) = &ty.kind &&
-                let QPath::Resolved(_, path) = qpath &&
-                let [path_seg] = path.segments &&
-                path_seg.ident.name == sym::String &&
-                is_expr_kind_empty_str(arg_kind)
+            if let QPath::TypeRelative(ty, path_seg) = qpath
+                && [sym::from, sym::try_from].contains(&path_seg.ident.name)
+                && let TyKind::Path(qpath) = &ty.kind
+                && let QPath::Resolved(_, path) = qpath
+                && let [path_seg] = path.segments
+                && path_seg.ident.name == sym::String
+                && is_expr_kind_empty_str(arg_kind)
             {
                 warn_then_suggest(cx, span);
             }
         } else if let QPath::Resolved(_, path) = qpath {
             // From::from(...) or TryFrom::try_from(...)
-            if  let [path_seg1, path_seg2] = path.segments &&
-                is_expr_kind_empty_str(arg_kind) && (
-                    (path_seg1.ident.name == sym::From && path_seg2.ident.name == sym::from) ||
-                    (path_seg1.ident.name == sym::TryFrom && path_seg2.ident.name == sym::try_from)
-                )
+            if let [path_seg1, path_seg2] = path.segments
+                && is_expr_kind_empty_str(arg_kind)
+                && ((path_seg1.ident.name == sym::From && path_seg2.ident.name == sym::from)
+                    || (path_seg1.ident.name == sym::TryFrom && path_seg2.ident.name == sym::try_from))
             {
                 warn_then_suggest(cx, span);
             }
diff --git a/clippy_lints/src/matches/manual_filter.rs b/clippy_lints/src/matches/manual_filter.rs
index e0181a4757c..cdb51c33aaf 100644
--- a/clippy_lints/src/matches/manual_filter.rs
+++ b/clippy_lints/src/matches/manual_filter.rs
@@ -99,12 +99,20 @@ pub(super) fn check_match<'tcx>(
 ) {
     let ty = cx.typeck_results().expr_ty(expr);
     if is_type_diagnostic_item(cx, ty, sym::Option)
-    && let [first_arm, second_arm] = arms
-    && first_arm.guard.is_none()
-    && second_arm.guard.is_none()
-         {
-            check(cx, expr, scrutinee, first_arm.pat, first_arm.body, Some(second_arm.pat), second_arm.body);
-        }
+        && let [first_arm, second_arm] = arms
+        && first_arm.guard.is_none()
+        && second_arm.guard.is_none()
+    {
+        check(
+            cx,
+            expr,
+            scrutinee,
+            first_arm.pat,
+            first_arm.body,
+            Some(second_arm.pat),
+            second_arm.body,
+        );
+    }
 }
 
 pub(super) fn check_if_let<'tcx>(
diff --git a/clippy_lints/src/matches/redundant_guards.rs b/clippy_lints/src/matches/redundant_guards.rs
index 0efeeacc9d9..4a44d596a46 100644
--- a/clippy_lints/src/matches/redundant_guards.rs
+++ b/clippy_lints/src/matches/redundant_guards.rs
@@ -27,8 +27,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'tcx>]) {
                     arm,
                     Arm {
                         pat: Pat {
-                            kind: PatKind::Wild,
-                            ..
+                            kind: PatKind::Wild, ..
                         },
                         ..
                     },
@@ -42,14 +41,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'tcx>]) {
                 (PatKind::Ref(..), None) | (_, Some(_)) => continue,
                 _ => arm.pat.span,
             };
-            emit_redundant_guards(
-                cx,
-                outer_arm,
-                if_expr.span,
-                pat_span,
-                &binding,
-                arm.guard,
-            );
+            emit_redundant_guards(cx, outer_arm, if_expr.span, pat_span, &binding, arm.guard);
         }
         // `Some(x) if let Some(2) = x`
         else if let Guard::IfLet(let_expr) = guard
@@ -60,14 +52,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'tcx>]) {
                 (PatKind::Ref(..), None) | (_, Some(_)) => continue,
                 _ => let_expr.pat.span,
             };
-            emit_redundant_guards(
-                cx,
-                outer_arm,
-                let_expr.span,
-                pat_span,
-                &binding,
-                None,
-            );
+            emit_redundant_guards(cx, outer_arm, let_expr.span, pat_span, &binding, None);
         }
         // `Some(x) if x == Some(2)`
         // `Some(x) if Some(2) == x`
@@ -93,14 +78,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'tcx>]) {
                 (ExprKind::AddrOf(..), None) | (_, Some(_)) => continue,
                 _ => pat.span,
             };
-            emit_redundant_guards(
-                cx,
-                outer_arm,
-                if_expr.span,
-                pat_span,
-                &binding,
-                None,
-            );
+            emit_redundant_guards(cx, outer_arm, if_expr.span, pat_span, &binding, None);
         }
     }
 }
@@ -116,7 +94,9 @@ fn get_pat_binding<'tcx>(
     guard_expr: &Expr<'_>,
     outer_arm: &Arm<'tcx>,
 ) -> Option<PatBindingInfo> {
-    if let Some(local) = path_to_local(guard_expr) && !is_local_used(cx, outer_arm.body, local) {
+    if let Some(local) = path_to_local(guard_expr)
+        && !is_local_used(cx, outer_arm.body, local)
+    {
         let mut span = None;
         let mut byref_ident = None;
         let mut multiple_bindings = false;
@@ -223,10 +203,7 @@ fn expr_can_be_pat(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
                     Res::Def(DefKind::Struct | DefKind::Enum | DefKind::Ctor(..), ..),
                 )
             },
-            ExprKind::AddrOf(..)
-            | ExprKind::Array(..)
-            | ExprKind::Tup(..)
-            | ExprKind::Struct(..) => true,
+            ExprKind::AddrOf(..) | ExprKind::Array(..) | ExprKind::Tup(..) | ExprKind::Struct(..) => true,
             ExprKind::Lit(lit) if !matches!(lit.node, LitKind::Float(..)) => true,
             _ => false,
         } {
diff --git a/clippy_lints/src/matches/single_match.rs b/clippy_lints/src/matches/single_match.rs
index 5b92c0f7dc8..48efd023017 100644
--- a/clippy_lints/src/matches/single_match.rs
+++ b/clippy_lints/src/matches/single_match.rs
@@ -20,8 +20,7 @@ fn empty_arm_has_comment(cx: &LateContext<'_>, span: Span) -> bool {
     if let Some(ff) = get_source_text(cx, span)
         && let Some(text) = ff.as_str()
     {
-        text.as_bytes().windows(2)
-            .any(|w| w == b"//" || w == b"/*")
+        text.as_bytes().windows(2).any(|w| w == b"//" || w == b"/*")
     } else {
         false
     }
diff --git a/clippy_lints/src/methods/bytes_nth.rs b/clippy_lints/src/methods/bytes_nth.rs
index c5fc145b289..baafb7030aa 100644
--- a/clippy_lints/src/methods/bytes_nth.rs
+++ b/clippy_lints/src/methods/bytes_nth.rs
@@ -24,8 +24,9 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, recv: &'tcx E
     let n = snippet_with_applicability(cx, n_arg.span, "..", &mut applicability);
 
     if let Some(parent) = clippy_utils::get_parent_expr(cx, expr)
-      && let Some((name, _, _, _, _)) = method_call(parent)
-      && name == "unwrap" {
+        && let Some((name, _, _, _, _)) = method_call(parent)
+        && name == "unwrap"
+    {
         span_lint_and_sugg(
             cx,
             BYTES_NTH,
@@ -33,7 +34,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, recv: &'tcx E
             &format!("called `.bytes().nth().unwrap()` on a `{caller_type}`"),
             "try",
             format!("{receiver}.as_bytes()[{n}]",),
-            applicability
+            applicability,
         );
     } else {
         span_lint_and_sugg(
@@ -42,8 +43,8 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, recv: &'tcx E
             expr.span,
             &format!("called `.bytes().nth()` on a `{caller_type}`"),
             "try",
-            format!("{receiver}.as_bytes().get({n}).copied()"), 
-            applicability
+            format!("{receiver}.as_bytes().get({n}).copied()"),
+            applicability,
         );
     };
 }
diff --git a/clippy_lints/src/methods/filter_map.rs b/clippy_lints/src/methods/filter_map.rs
index c9eaa185acc..22b67923e50 100644
--- a/clippy_lints/src/methods/filter_map.rs
+++ b/clippy_lints/src/methods/filter_map.rs
@@ -159,7 +159,7 @@ impl<'tcx> OffendingFilterExpr<'tcx> {
                             OffendingFilterExpr::IsSome { .. } => CalledMethod::OptionIsSome,
                             OffendingFilterExpr::IsOk { .. } => CalledMethod::ResultIsOk,
                             OffendingFilterExpr::Matches { .. } => unreachable!("only IsSome and IsOk can get here"),
-                        }
+                        },
                     })
                 } else {
                     None
@@ -189,7 +189,8 @@ impl<'tcx> OffendingFilterExpr<'tcx> {
                 //     scrutinee  variant_span  variant_ident        else_
                 let (scrutinee, else_, variant_ident, variant_span) =
                     match higher::IfLetOrMatch::parse(cx, map_body.value) {
-                        // For `if let` we want to check that the variant matching arm references the local created by its pattern
+                        // For `if let` we want to check that the variant matching arm references the local created by
+                        // its pattern
                         Some(higher::IfLetOrMatch::IfLet(sc, pat, then, Some(else_)))
                             if let Some((ident, span)) = expr_uses_local(pat, then) =>
                         {
@@ -211,7 +212,10 @@ impl<'tcx> OffendingFilterExpr<'tcx> {
                     && let Some(mac) = root_macro_call(else_.peel_blocks().span)
                     && (is_panic(cx, mac.def_id) || cx.tcx.opt_item_name(mac.def_id) == Some(sym::unreachable))
                 {
-                    Some(CheckResult::PatternMatching { variant_span, variant_ident })
+                    Some(CheckResult::PatternMatching {
+                        variant_span,
+                        variant_ident,
+                    })
                 } else {
                     None
                 }
@@ -228,18 +232,20 @@ impl<'tcx> OffendingFilterExpr<'tcx> {
             // .filter(|x| effect(x).is_some()).map(|x| effect(x).unwrap())
             // vs.
             // .filter_map(|x| effect(x))
-            // 
+            //
             // the latter only calls `effect` once
             let side_effect_expr_span = receiver.can_have_side_effects().then_some(receiver.span);
 
-            if cx.tcx.is_diagnostic_item(sym::Option, recv_ty.did())
-                && path.ident.name == sym!(is_some)
-            {
-                Some(Self::IsSome { receiver, side_effect_expr_span })
-            } else if cx.tcx.is_diagnostic_item(sym::Result, recv_ty.did())
-                && path.ident.name == sym!(is_ok)
-            {
-                Some(Self::IsOk { receiver, side_effect_expr_span })
+            if cx.tcx.is_diagnostic_item(sym::Option, recv_ty.did()) && path.ident.name == sym!(is_some) {
+                Some(Self::IsSome {
+                    receiver,
+                    side_effect_expr_span,
+                })
+            } else if cx.tcx.is_diagnostic_item(sym::Result, recv_ty.did()) && path.ident.name == sym!(is_ok) {
+                Some(Self::IsOk {
+                    receiver,
+                    side_effect_expr_span,
+                })
             } else {
                 None
             }
diff --git a/clippy_lints/src/methods/filter_map_bool_then.rs b/clippy_lints/src/methods/filter_map_bool_then.rs
index 33657254965..9950c442855 100644
--- a/clippy_lints/src/methods/filter_map_bool_then.rs
+++ b/clippy_lints/src/methods/filter_map_bool_then.rs
@@ -54,7 +54,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, arg: &
             "use `filter` then `map` instead",
             format!(
                 "filter(|&{param_snippet}| {derefs}{filter}).map(|{param_snippet}| {map})",
-                derefs="*".repeat(needed_derefs)
+                derefs = "*".repeat(needed_derefs)
             ),
             Applicability::MachineApplicable,
         );
diff --git a/clippy_lints/src/methods/format_collect.rs b/clippy_lints/src/methods/format_collect.rs
index 1f8863f8521..3e5162ef458 100644
--- a/clippy_lints/src/methods/format_collect.rs
+++ b/clippy_lints/src/methods/format_collect.rs
@@ -24,10 +24,16 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, map_arg: &Expr<'_>, m
         && let Some(mac) = root_macro_call_first_node(cx, value)
         && is_format_macro(cx, mac.def_id)
     {
-        span_lint_and_then(cx, FORMAT_COLLECT, expr.span, "use of `format!` to build up a string from an iterator", |diag| {
-            diag.span_help(map_span, "call `fold` instead")
-                .span_help(value.span.source_callsite(), "... and use the `write!` macro here")
-                .note("this can be written more efficiently by appending to a `String` directly");
-        });
+        span_lint_and_then(
+            cx,
+            FORMAT_COLLECT,
+            expr.span,
+            "use of `format!` to build up a string from an iterator",
+            |diag| {
+                diag.span_help(map_span, "call `fold` instead")
+                    .span_help(value.span.source_callsite(), "... and use the `write!` macro here")
+                    .note("this can be written more efficiently by appending to a `String` directly");
+            },
+        );
     }
 }
diff --git a/clippy_lints/src/methods/get_unwrap.rs b/clippy_lints/src/methods/get_unwrap.rs
index a8f090d1de1..afdcb3b6549 100644
--- a/clippy_lints/src/methods/get_unwrap.rs
+++ b/clippy_lints/src/methods/get_unwrap.rs
@@ -43,9 +43,9 @@ pub(super) fn check<'tcx>(
     // by not requiring an explicit reference
     let needs_ref = if let Some(parent) = get_parent_expr(cx, expr)
         && let hir::ExprKind::Unary(hir::UnOp::Deref, _)
-            | hir::ExprKind::MethodCall(..)
-            | hir::ExprKind::Field(..)
-            | hir::ExprKind::Index(..) = parent.kind
+        | hir::ExprKind::MethodCall(..)
+        | hir::ExprKind::Field(..)
+        | hir::ExprKind::Index(..) = parent.kind
     {
         if let hir::ExprKind::Unary(hir::UnOp::Deref, _) = parent.kind {
             // if the user explicitly dereferences the result, we can adjust
diff --git a/clippy_lints/src/methods/iter_out_of_bounds.rs b/clippy_lints/src/methods/iter_out_of_bounds.rs
index 99ea7f03df4..29e69b111de 100644
--- a/clippy_lints/src/methods/iter_out_of_bounds.rs
+++ b/clippy_lints/src/methods/iter_out_of_bounds.rs
@@ -51,7 +51,7 @@ fn get_iterator_length<'tcx>(cx: &LateContext<'tcx>, iter: &'tcx Expr<'tcx>) ->
         Some(0)
     } else if cx.tcx.is_diagnostic_item(sym::IterOnce, did) {
         Some(1)
-    }  else {
+    } else {
         None
     }
 }
diff --git a/clippy_lints/src/methods/iter_overeager_cloned.rs b/clippy_lints/src/methods/iter_overeager_cloned.rs
index a49dd98db87..eac6df0545f 100644
--- a/clippy_lints/src/methods/iter_overeager_cloned.rs
+++ b/clippy_lints/src/methods/iter_overeager_cloned.rs
@@ -60,9 +60,15 @@ pub(super) fn check<'tcx>(
         }
 
         if let Op::NeedlessMove(_, expr) = op {
-            let rustc_hir::ExprKind::Closure(closure) = expr.kind else { return } ;
-            let body @ Body { params: [p], .. } = cx.tcx.hir().body(closure.body) else { return };
-            let mut delegate = MoveDelegate {used_move : HirIdSet::default()};
+            let rustc_hir::ExprKind::Closure(closure) = expr.kind else {
+                return;
+            };
+            let body @ Body { params: [p], .. } = cx.tcx.hir().body(closure.body) else {
+                return;
+            };
+            let mut delegate = MoveDelegate {
+                used_move: HirIdSet::default(),
+            };
             let infcx = cx.tcx.infer_ctxt().build();
 
             ExprUseVisitor::new(
@@ -77,7 +83,7 @@ pub(super) fn check<'tcx>(
             let mut to_be_discarded = false;
 
             p.pat.walk(|it| {
-                if delegate.used_move.contains(&it.hir_id){
+                if delegate.used_move.contains(&it.hir_id) {
                     to_be_discarded = true;
                     return false;
                 }
@@ -87,8 +93,8 @@ pub(super) fn check<'tcx>(
                     | PatKind::Ref(_, Mutability::Mut) => {
                         to_be_discarded = true;
                         false
-                    }
-                    _ => { true }
+                    },
+                    _ => true,
                 }
             });
 
@@ -99,46 +105,42 @@ pub(super) fn check<'tcx>(
 
         let (lint, msg, trailing_clone) = match op {
             Op::RmCloned | Op::NeedlessMove(_, _) => (REDUNDANT_CLONE, "unneeded cloning of iterator items", ""),
-            Op::LaterCloned | Op::FixClosure(_, _) => (ITER_OVEREAGER_CLONED, "unnecessarily eager cloning of iterator items", ".cloned()"),
+            Op::LaterCloned | Op::FixClosure(_, _) => (
+                ITER_OVEREAGER_CLONED,
+                "unnecessarily eager cloning of iterator items",
+                ".cloned()",
+            ),
         };
 
-        span_lint_and_then(
-            cx,
-            lint,
-            expr.span,
-            msg,
-            |diag| {
-                match op {
-                    Op::RmCloned | Op::LaterCloned => {
-                        let method_span = expr.span.with_lo(cloned_call.span.hi());
-                        if let Some(mut snip) = snippet_opt(cx, method_span) {
-                            snip.push_str(trailing_clone);
-                            let replace_span = expr.span.with_lo(cloned_recv.span.hi());
-                            diag.span_suggestion(replace_span, "try", snip, Applicability::MachineApplicable);
-                        }
-                    }
-                    Op::FixClosure(name, predicate_expr) => {
-                        if let Some(predicate) = snippet_opt(cx, predicate_expr.span) {
-                            let new_closure = if let ExprKind::Closure(_) = predicate_expr.kind {
-                                predicate.replacen('|', "|&", 1)
-                            } else {
-                                format!("|&x| {predicate}(x)")
-                            };
-                            let snip = format!(".{name}({new_closure}).cloned()" );
-                            let replace_span = expr.span.with_lo(cloned_recv.span.hi());
-                            diag.span_suggestion(replace_span, "try", snip, Applicability::MachineApplicable);
-                        }
-                    }
-                    Op::NeedlessMove(_, _) => {
-                        let method_span = expr.span.with_lo(cloned_call.span.hi());
-                        if let Some(snip) = snippet_opt(cx, method_span) {
-                            let replace_span = expr.span.with_lo(cloned_recv.span.hi());
-                            diag.span_suggestion(replace_span, "try", snip, Applicability::MaybeIncorrect);
-                        }
-                    }
+        span_lint_and_then(cx, lint, expr.span, msg, |diag| match op {
+            Op::RmCloned | Op::LaterCloned => {
+                let method_span = expr.span.with_lo(cloned_call.span.hi());
+                if let Some(mut snip) = snippet_opt(cx, method_span) {
+                    snip.push_str(trailing_clone);
+                    let replace_span = expr.span.with_lo(cloned_recv.span.hi());
+                    diag.span_suggestion(replace_span, "try", snip, Applicability::MachineApplicable);
                 }
-            }
-        );
+            },
+            Op::FixClosure(name, predicate_expr) => {
+                if let Some(predicate) = snippet_opt(cx, predicate_expr.span) {
+                    let new_closure = if let ExprKind::Closure(_) = predicate_expr.kind {
+                        predicate.replacen('|', "|&", 1)
+                    } else {
+                        format!("|&x| {predicate}(x)")
+                    };
+                    let snip = format!(".{name}({new_closure}).cloned()");
+                    let replace_span = expr.span.with_lo(cloned_recv.span.hi());
+                    diag.span_suggestion(replace_span, "try", snip, Applicability::MachineApplicable);
+                }
+            },
+            Op::NeedlessMove(_, _) => {
+                let method_span = expr.span.with_lo(cloned_call.span.hi());
+                if let Some(snip) = snippet_opt(cx, method_span) {
+                    let replace_span = expr.span.with_lo(cloned_recv.span.hi());
+                    diag.span_suggestion(replace_span, "try", snip, Applicability::MaybeIncorrect);
+                }
+            },
+        });
     }
 }
 
diff --git a/clippy_lints/src/methods/manual_try_fold.rs b/clippy_lints/src/methods/manual_try_fold.rs
index 5fc968f793f..51145afda7f 100644
--- a/clippy_lints/src/methods/manual_try_fold.rs
+++ b/clippy_lints/src/methods/manual_try_fold.rs
@@ -44,7 +44,7 @@ pub(super) fn check<'tcx>(
             fold_span,
             "usage of `Iterator::fold` on a type that implements `Try`",
             "use `try_fold` instead",
-            format!("try_fold({init_snip}, {args_snip} ...)", ),
+            format!("try_fold({init_snip}, {args_snip} ...)",),
             Applicability::HasPlaceholders,
         );
     }
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 90f6bc5e3d3..a71a136eba5 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3932,21 +3932,21 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             }
 
             if sig.decl.implicit_self.has_implicit_self()
-                    && !(self.avoid_breaking_exported_api
+                && !(self.avoid_breaking_exported_api
                     && cx.effective_visibilities.is_exported(impl_item.owner_id.def_id))
-                    && let Some(first_arg) = iter_input_pats(sig.decl, cx.tcx.hir().body(id)).next()
-                    && let Some(first_arg_ty) = first_arg_ty_opt
-                {
-                    wrong_self_convention::check(
-                        cx,
-                        name,
-                        self_ty,
-                        first_arg_ty,
-                        first_arg.pat.span,
-                        implements_trait,
-                        false
-                    );
-                }
+                && let Some(first_arg) = iter_input_pats(sig.decl, cx.tcx.hir().body(id)).next()
+                && let Some(first_arg_ty) = first_arg_ty_opt
+            {
+                wrong_self_convention::check(
+                    cx,
+                    name,
+                    self_ty,
+                    first_arg_ty,
+                    first_arg.pat.span,
+                    implements_trait,
+                    false,
+                );
+            }
         }
 
         // if this impl block implements a trait, lint in trait definition instead
@@ -4031,10 +4031,16 @@ impl Methods {
                 },
                 ("all", [arg]) => {
                     if let Some(("cloned", recv2, [], _, _)) = method_call(recv) {
-                        iter_overeager_cloned::check(cx, expr, recv, recv2,
-                                iter_overeager_cloned::Op::NeedlessMove(name, arg), false);
+                        iter_overeager_cloned::check(
+                            cx,
+                            expr,
+                            recv,
+                            recv2,
+                            iter_overeager_cloned::Op::NeedlessMove(name, arg),
+                            false,
+                        );
                     }
-                }
+                },
                 ("and_then", [arg]) => {
                     let biom_option_linted = bind_instead_of_map::OptionAndThenSome::check(cx, expr, recv, arg);
                     let biom_result_linted = bind_instead_of_map::ResultAndThenOk::check(cx, expr, recv, arg);
@@ -4042,24 +4048,35 @@ impl Methods {
                         unnecessary_lazy_eval::check(cx, expr, recv, arg, "and");
                     }
                 },
-                ("any", [arg]) => {
-                    match method_call(recv) {
-                        Some(("cloned", recv2, [], _, _)) => iter_overeager_cloned::check(cx, expr, recv, recv2, iter_overeager_cloned::Op::NeedlessMove(name, arg), false),
-                        Some(("chars", recv, _, _, _)) if let ExprKind::Closure(arg) = arg.kind
-                        && let body = cx.tcx.hir().body(arg.body)
-                        && let [param] = body.params => {
-                            string_lit_chars_any::check(cx, expr, recv, param, peel_blocks(body.value), &self.msrv);
-                        }
-                        _ => {}
-                    }
-                }
+                ("any", [arg]) => match method_call(recv) {
+                    Some(("cloned", recv2, [], _, _)) => iter_overeager_cloned::check(
+                        cx,
+                        expr,
+                        recv,
+                        recv2,
+                        iter_overeager_cloned::Op::NeedlessMove(name, arg),
+                        false,
+                    ),
+                    Some(("chars", recv, _, _, _))
+                        if let ExprKind::Closure(arg) = arg.kind
+                            && let body = cx.tcx.hir().body(arg.body)
+                            && let [param] = body.params =>
+                    {
+                        string_lit_chars_any::check(cx, expr, recv, param, peel_blocks(body.value), &self.msrv);
+                    },
+                    _ => {},
+                },
                 ("arg", [arg]) => {
                     suspicious_command_arg_space::check(cx, recv, arg, span);
-                }
+                },
                 ("as_deref" | "as_deref_mut", []) => {
                     needless_option_as_deref::check(cx, expr, recv, name);
                 },
-                ("as_bytes" | "is_empty", []) => if let Some(("as_str", recv, [], as_str_span, _)) = method_call(recv) { redundant_as_str::check(cx, expr, recv, as_str_span, span); },
+                ("as_bytes" | "is_empty", []) => {
+                    if let Some(("as_str", recv, [], as_str_span, _)) = method_call(recv) {
+                        redundant_as_str::check(cx, expr, recv, as_str_span, span);
+                    }
+                },
                 ("as_mut", []) => useless_asref::check(cx, expr, "as_mut", recv),
                 ("as_ref", []) => useless_asref::check(cx, expr, "as_ref", recv),
                 ("assume_init", []) => uninit_assumed_init::check(cx, expr, recv),
@@ -4081,12 +4098,14 @@ impl Methods {
                         },
                         Some(("drain", recv, args, ..)) => {
                             drain_collect::check(cx, args, expr, recv);
-                        }
+                        },
                         _ => {},
                     }
                 },
                 ("count", []) if is_trait_method(cx, expr, sym::Iterator) => match method_call(recv) {
-                    Some(("cloned", recv2, [], _, _)) => iter_overeager_cloned::check(cx, expr, recv, recv2, iter_overeager_cloned::Op::RmCloned , false),
+                    Some(("cloned", recv2, [], _, _)) => {
+                        iter_overeager_cloned::check(cx, expr, recv, recv2, iter_overeager_cloned::Op::RmCloned, false);
+                    },
                     Some((name2 @ ("into_iter" | "iter" | "iter_mut"), recv2, [], _, _)) => {
                         iter_count::check(cx, expr, recv2, name2);
                     },
@@ -4114,7 +4133,9 @@ impl Methods {
                 ("expect", [_]) => {
                     match method_call(recv) {
                         Some(("ok", recv, [], _, _)) => ok_expect::check(cx, expr, recv),
-                        Some(("err", recv, [], err_span, _)) => err_expect::check(cx, expr, recv, span, err_span, &self.msrv),
+                        Some(("err", recv, [], err_span, _)) => {
+                            err_expect::check(cx, expr, recv, span, err_span, &self.msrv);
+                        },
                         _ => unwrap_expect_used::check(
                             cx,
                             expr,
@@ -4141,13 +4162,19 @@ impl Methods {
                     string_extend_chars::check(cx, expr, recv, arg);
                     extend_with_drain::check(cx, expr, recv, arg);
                 },
-                (name @ ( "filter" | "find" ) , [arg]) => {
+                (name @ ("filter" | "find"), [arg]) => {
                     if let Some(("cloned", recv2, [], _span2, _)) = method_call(recv) {
                         // if `arg` has side-effect, the semantic will change
-                        iter_overeager_cloned::check(cx, expr, recv, recv2,
-                                iter_overeager_cloned::Op::FixClosure(name, arg), false);
+                        iter_overeager_cloned::check(
+                            cx,
+                            expr,
+                            recv,
+                            recv2,
+                            iter_overeager_cloned::Op::FixClosure(name, arg),
+                            false,
+                        );
                     }
-                }
+                },
                 ("filter_map", [arg]) => {
                     unnecessary_filter_map::check(cx, expr, arg, name);
                     filter_map_bool_then::check(cx, expr, arg, call_span);
@@ -4161,20 +4188,34 @@ impl Methods {
                     flat_map_option::check(cx, expr, arg, span);
                 },
                 ("flatten", []) => match method_call(recv) {
-                    Some(("map", recv, [map_arg], map_span, _)) => map_flatten::check(cx, expr, recv, map_arg, map_span),
-                    Some(("cloned", recv2, [], _, _)) => iter_overeager_cloned::check(cx, expr, recv, recv2, iter_overeager_cloned::Op::LaterCloned , true),
+                    Some(("map", recv, [map_arg], map_span, _)) => {
+                        map_flatten::check(cx, expr, recv, map_arg, map_span);
+                    },
+                    Some(("cloned", recv2, [], _, _)) => iter_overeager_cloned::check(
+                        cx,
+                        expr,
+                        recv,
+                        recv2,
+                        iter_overeager_cloned::Op::LaterCloned,
+                        true,
+                    ),
                     _ => {},
                 },
                 ("fold", [init, acc]) => {
                     manual_try_fold::check(cx, expr, init, acc, call_span, &self.msrv);
                     unnecessary_fold::check(cx, expr, init, acc, span);
                 },
-                ("for_each", [arg]) => {
-                    match method_call(recv) {
-                        Some(("inspect", _, [_], span2, _)) => inspect_for_each::check(cx, expr, span2),
-                        Some(("cloned", recv2, [], _, _)) => iter_overeager_cloned::check(cx, expr, recv, recv2, iter_overeager_cloned::Op::NeedlessMove(name, arg), false),
-                        _ => {}
-                    }
+                ("for_each", [arg]) => match method_call(recv) {
+                    Some(("inspect", _, [_], span2, _)) => inspect_for_each::check(cx, expr, span2),
+                    Some(("cloned", recv2, [], _, _)) => iter_overeager_cloned::check(
+                        cx,
+                        expr,
+                        recv,
+                        recv2,
+                        iter_overeager_cloned::Op::NeedlessMove(name, arg),
+                        false,
+                    ),
+                    _ => {},
                 },
                 ("get", [arg]) => {
                     get_first::check(cx, expr, recv, arg);
@@ -4198,8 +4239,14 @@ impl Methods {
                 },
                 ("last", []) => {
                     if let Some(("cloned", recv2, [], _span2, _)) = method_call(recv) {
-                        iter_overeager_cloned::check(cx, expr, recv, recv2,
-                                iter_overeager_cloned::Op::LaterCloned , false);
+                        iter_overeager_cloned::check(
+                            cx,
+                            expr,
+                            recv,
+                            recv2,
+                            iter_overeager_cloned::Op::LaterCloned,
+                            false,
+                        );
                     }
                 },
                 ("lock", []) => {
@@ -4209,14 +4256,23 @@ impl Methods {
                     if name == "map" {
                         map_clone::check(cx, expr, recv, m_arg, &self.msrv);
                         match method_call(recv) {
-                            Some((map_name @ ("iter" | "into_iter"), recv2, _, _, _)) => iter_kv_map::check(cx, map_name, expr, recv2, m_arg),
-                            Some(("cloned", recv2, [], _, _)) => iter_overeager_cloned::check(cx, expr, recv, recv2, iter_overeager_cloned::Op::NeedlessMove(name, m_arg), false),
-                            _ => {}
+                            Some((map_name @ ("iter" | "into_iter"), recv2, _, _, _)) => {
+                                iter_kv_map::check(cx, map_name, expr, recv2, m_arg);
+                            },
+                            Some(("cloned", recv2, [], _, _)) => iter_overeager_cloned::check(
+                                cx,
+                                expr,
+                                recv,
+                                recv2,
+                                iter_overeager_cloned::Op::NeedlessMove(name, m_arg),
+                                false,
+                            ),
+                            _ => {},
                         }
                     } else {
                         map_err_ignore::check(cx, expr, m_arg);
                     }
-                    if let Some((name, recv2, args, span2,_)) = method_call(recv) {
+                    if let Some((name, recv2, args, span2, _)) = method_call(recv) {
                         match (name, args) {
                             ("as_mut", []) => option_as_ref_deref::check(cx, expr, recv2, m_arg, true, &self.msrv),
                             ("as_ref", []) => option_as_ref_deref::check(cx, expr, recv2, m_arg, false, &self.msrv),
@@ -4238,20 +4294,34 @@ impl Methods {
                 ("next", []) => {
                     if let Some((name2, recv2, args2, _, _)) = method_call(recv) {
                         match (name2, args2) {
-                            ("cloned", []) => iter_overeager_cloned::check(cx, expr, recv, recv2, iter_overeager_cloned::Op::LaterCloned, false),
+                            ("cloned", []) => iter_overeager_cloned::check(
+                                cx,
+                                expr,
+                                recv,
+                                recv2,
+                                iter_overeager_cloned::Op::LaterCloned,
+                                false,
+                            ),
                             ("filter", [arg]) => filter_next::check(cx, expr, recv2, arg),
                             ("filter_map", [arg]) => filter_map_next::check(cx, expr, recv2, arg, &self.msrv),
                             ("iter", []) => iter_next_slice::check(cx, expr, recv2),
                             ("skip", [arg]) => iter_skip_next::check(cx, expr, recv2, arg),
                             ("skip_while", [_]) => skip_while_next::check(cx, expr),
-                            ("rev", [])=> manual_next_back::check(cx, expr, recv, recv2),
+                            ("rev", []) => manual_next_back::check(cx, expr, recv, recv2),
                             _ => {},
                         }
                     }
                 },
                 ("nth", [n_arg]) => match method_call(recv) {
                     Some(("bytes", recv2, [], _, _)) => bytes_nth::check(cx, expr, recv2, n_arg),
-                    Some(("cloned", recv2, [], _, _)) => iter_overeager_cloned::check(cx, expr, recv, recv2, iter_overeager_cloned::Op::LaterCloned , false),
+                    Some(("cloned", recv2, [], _, _)) => iter_overeager_cloned::check(
+                        cx,
+                        expr,
+                        recv,
+                        recv2,
+                        iter_overeager_cloned::Op::LaterCloned,
+                        false,
+                    ),
                     Some(("iter", recv2, [], _, _)) => iter_nth::check(cx, expr, recv2, recv, n_arg, false),
                     Some(("iter_mut", recv2, [], _, _)) => iter_nth::check(cx, expr, recv2, recv, n_arg, true),
                     _ => iter_nth_zero::check(cx, expr, recv, n_arg),
@@ -4276,7 +4346,7 @@ impl Methods {
                 },
                 ("read_line", [arg]) => {
                     read_line_without_trim::check(cx, expr, recv, arg);
-                }
+                },
                 ("repeat", [arg]) => {
                     repeat_once::check(cx, expr, recv, arg);
                 },
@@ -4307,10 +4377,16 @@ impl Methods {
                     iter_out_of_bounds::check_skip(cx, expr, recv, arg);
 
                     if let Some(("cloned", recv2, [], _span2, _)) = method_call(recv) {
-                        iter_overeager_cloned::check(cx, expr, recv, recv2,
-                                iter_overeager_cloned::Op::LaterCloned , false);
+                        iter_overeager_cloned::check(
+                            cx,
+                            expr,
+                            recv,
+                            recv2,
+                            iter_overeager_cloned::Op::LaterCloned,
+                            false,
+                        );
                     }
-                }
+                },
                 ("sort", []) => {
                     stable_sort_primitive::check(cx, expr, recv);
                 },
@@ -4335,8 +4411,14 @@ impl Methods {
                 ("take", [arg]) => {
                     iter_out_of_bounds::check_take(cx, expr, recv, arg);
                     if let Some(("cloned", recv2, [], _span2, _)) = method_call(recv) {
-                        iter_overeager_cloned::check(cx, expr, recv, recv2,
-                                iter_overeager_cloned::Op::LaterCloned, false);
+                        iter_overeager_cloned::check(
+                            cx,
+                            expr,
+                            recv,
+                            recv2,
+                            iter_overeager_cloned::Op::LaterCloned,
+                            false,
+                        );
                     }
                 },
                 ("take", []) => needless_option_take::check(cx, expr, recv),
@@ -4348,7 +4430,7 @@ impl Methods {
                 },
                 ("try_into", []) if is_trait_method(cx, expr, sym::TryInto) => {
                     unnecessary_fallible_conversions::check_method(cx, expr);
-                }
+                },
                 ("to_owned", []) => {
                     if !suspicious_to_owned::check(cx, expr, recv) {
                         implicit_clone::check(cx, name, expr, recv);
@@ -4359,7 +4441,7 @@ impl Methods {
                 },
                 ("type_id", []) => {
                     type_id_on_box::check(cx, recv, expr.span);
-                }
+                },
                 ("unwrap", []) => {
                     match method_call(recv) {
                         Some(("get", recv, [get_arg], _, _)) => {
@@ -4411,7 +4493,7 @@ impl Methods {
                 },
                 ("unwrap_or_default" | "unwrap_unchecked" | "unwrap_err_unchecked", []) => {
                     unnecessary_literal_unwrap::check(cx, expr, recv, name, args);
-                }
+                },
                 ("unwrap_or_else", [u_arg]) => {
                     match method_call(recv) {
                         Some(("map", recv, [map_arg], _, _))
@@ -4424,10 +4506,10 @@ impl Methods {
                 },
                 ("wake", []) => {
                     waker_clone_wake::check(cx, expr, recv);
-                }
+                },
                 ("write", []) => {
                     readonly_write_lock::check(cx, expr, recv);
-                }
+                },
                 ("zip", [arg]) => {
                     if let ExprKind::MethodCall(name, iter_recv, [], _) = recv.kind
                         && name.ident.name == sym::iter
diff --git a/clippy_lints/src/methods/needless_collect.rs b/clippy_lints/src/methods/needless_collect.rs
index a1f8e27654f..2ef71be3217 100644
--- a/clippy_lints/src/methods/needless_collect.rs
+++ b/clippy_lints/src/methods/needless_collect.rs
@@ -17,7 +17,7 @@ use rustc_lint::LateContext;
 use rustc_middle::hir::nested_filter;
 use rustc_middle::ty::{self, AssocKind, ClauseKind, EarlyBinder, GenericArg, GenericArgKind, Ty};
 use rustc_span::symbol::Ident;
-use rustc_span::{sym, Span, Symbol};
+use rustc_span::{sym, Span};
 
 const NEEDLESS_COLLECT_MSG: &str = "avoid using `collect()` when not needed";
 
@@ -87,21 +87,17 @@ pub(super) fn check<'tcx>(
                 }
             },
             Node::Local(l) => {
-                if let PatKind::Binding(BindingAnnotation::NONE | BindingAnnotation::MUT, id, _, None)
-                    = l.pat.kind
+                if let PatKind::Binding(BindingAnnotation::NONE | BindingAnnotation::MUT, id, _, None) = l.pat.kind
                     && let ty = cx.typeck_results().expr_ty(collect_expr)
-                    && [sym::Vec, sym::VecDeque, sym::BinaryHeap, sym::LinkedList].into_iter()
+                    && [sym::Vec, sym::VecDeque, sym::BinaryHeap, sym::LinkedList]
+                        .into_iter()
                         .any(|item| is_type_diagnostic_item(cx, ty, item))
                     && let iter_ty = cx.typeck_results().expr_ty(iter_expr)
                     && let Some(block) = get_enclosing_block(cx, l.hir_id)
                     && let Some(iter_calls) = detect_iter_and_into_iters(block, id, cx, get_captured_ids(cx, iter_ty))
                     && let [iter_call] = &*iter_calls
                 {
-                    let mut used_count_visitor = UsedCountVisitor {
-                        cx,
-                        id,
-                        count: 0,
-                    };
+                    let mut used_count_visitor = UsedCountVisitor { cx, id, count: 0 };
                     walk_block(&mut used_count_visitor, block);
                     if used_count_visitor.count > 1 {
                         return;
@@ -117,13 +113,11 @@ pub(super) fn check<'tcx>(
                         span,
                         NEEDLESS_COLLECT_MSG,
                         |diag| {
-                            let iter_replacement = format!("{}{}", Sugg::hir(cx, iter_expr, ".."), iter_call.get_iter_method(cx));
+                            let iter_replacement =
+                                format!("{}{}", Sugg::hir(cx, iter_expr, ".."), iter_call.get_iter_method(cx));
                             diag.multipart_suggestion(
                                 iter_call.get_suggestion_text(),
-                                vec![
-                                    (l.span, String::new()),
-                                    (iter_call.span, iter_replacement)
-                                ],
+                                vec![(l.span, String::new()), (iter_call.span, iter_replacement)],
                                 Applicability::MaybeIncorrect,
                             );
                         },
@@ -175,11 +169,12 @@ fn check_collect_into_intoiterator<'tcx>(
                 .into_iter()
                 .filter_map(|p| {
                     if let ClauseKind::Trait(t) = p.kind().skip_binder()
-                            && cx.tcx.is_diagnostic_item(sym::IntoIterator,t.trait_ref.def_id) {
-                                Some(t.self_ty())
-                            } else {
-                                None
-                            }
+                        && cx.tcx.is_diagnostic_item(sym::IntoIterator, t.trait_ref.def_id)
+                    {
+                        Some(t.self_ty())
+                    } else {
+                        None
+                    }
                 })
                 .any(|ty| ty == inputs[arg_idx])
             {
@@ -213,7 +208,7 @@ fn iterates_same_ty<'tcx>(cx: &LateContext<'tcx>, iter_ty: Ty<'tcx>, collect_ty:
         && let Some(into_iter_item_proj) = make_projection(cx.tcx, into_iter_trait, sym::Item, [collect_ty])
         && let Ok(into_iter_item_ty) = cx.tcx.try_normalize_erasing_regions(
             cx.param_env,
-            Ty::new_projection(cx.tcx,into_iter_item_proj.def_id, into_iter_item_proj.args)
+            Ty::new_projection(cx.tcx, into_iter_item_proj.def_id, into_iter_item_proj.args),
         )
     {
         iter_item_ty == into_iter_item_ty
@@ -239,7 +234,7 @@ fn is_contains_sig(cx: &LateContext<'_>, call_id: HirId, iter_expr: &Expr<'_>) -
             iter_trait,
         )
         && let args = cx.tcx.mk_args(&[GenericArg::from(typeck.expr_ty_adjusted(iter_expr))])
-        && let proj_ty = Ty::new_projection(cx.tcx,iter_item.def_id, args)
+        && let proj_ty = Ty::new_projection(cx.tcx, iter_item.def_id, args)
         && let Ok(item_ty) = cx.tcx.try_normalize_erasing_regions(cx.param_env, proj_ty)
     {
         item_ty == EarlyBinder::bind(search_ty).instantiate(cx.tcx, cx.typeck_results().node_args(call_id))
diff --git a/clippy_lints/src/methods/or_fun_call.rs b/clippy_lints/src/methods/or_fun_call.rs
index 942f3bd79a6..b942346d5c3 100644
--- a/clippy_lints/src/methods/or_fun_call.rs
+++ b/clippy_lints/src/methods/or_fun_call.rs
@@ -235,10 +235,10 @@ fn closure_body_returns_empty_to_string(cx: &LateContext<'_>, e: &hir::Expr<'_>)
         let body = cx.tcx.hir().body(body);
 
         if body.params.is_empty()
-            && let hir::Expr{ kind, .. } = &body.value
-            && let hir::ExprKind::MethodCall(hir::PathSegment {ident, ..}, self_arg, _, _) = kind
+            && let hir::Expr { kind, .. } = &body.value
+            && let hir::ExprKind::MethodCall(hir::PathSegment { ident, .. }, self_arg, _, _) = kind
             && ident.name == sym::to_string
-            && let hir::Expr{ kind, .. } = self_arg
+            && let hir::Expr { kind, .. } = self_arg
             && let hir::ExprKind::Lit(lit) = kind
             && let ast::LitKind::Str(symbol::kw::Empty, _) = lit.node
         {
diff --git a/clippy_lints/src/methods/path_ends_with_ext.rs b/clippy_lints/src/methods/path_ends_with_ext.rs
index 9ec0ef0ea39..094ead9f4ad 100644
--- a/clippy_lints/src/methods/path_ends_with_ext.rs
+++ b/clippy_lints/src/methods/path_ends_with_ext.rs
@@ -46,7 +46,7 @@ pub(super) fn check(
             "this looks like a failed attempt at checking for the file extension",
             "try",
             sugg,
-            Applicability::MaybeIncorrect
+            Applicability::MaybeIncorrect,
         );
     }
 }
diff --git a/clippy_lints/src/methods/read_line_without_trim.rs b/clippy_lints/src/methods/read_line_without_trim.rs
index 81f9e2a77fc..3b903ec5cdb 100644
--- a/clippy_lints/src/methods/read_line_without_trim.rs
+++ b/clippy_lints/src/methods/read_line_without_trim.rs
@@ -46,9 +46,12 @@ pub fn check(cx: &LateContext<'_>, call: &Expr<'_>, recv: &Expr<'_>, arg: &Expr<
                     span,
                     "calling `.parse()` without trimming the trailing newline character",
                     |diag| {
-                        diag.span_note(call.span, "call to `.read_line()` here, \
+                        diag.span_note(
+                            call.span,
+                            "call to `.read_line()` here, \
                             which leaves a trailing newline character in the buffer, \
-                            which in turn will cause `.parse()` to fail");
+                            which in turn will cause `.parse()` to fail",
+                        );
 
                         diag.span_suggestion(
                             expr.span,
@@ -56,7 +59,7 @@ pub fn check(cx: &LateContext<'_>, call: &Expr<'_>, recv: &Expr<'_>, arg: &Expr<
                             format!("{local_snippet}.trim_end()"),
                             Applicability::MachineApplicable,
                         );
-                    }
+                    },
                 );
             }
 
diff --git a/clippy_lints/src/methods/readonly_write_lock.rs b/clippy_lints/src/methods/readonly_write_lock.rs
index e3ec921da0c..1184dd4525a 100644
--- a/clippy_lints/src/methods/readonly_write_lock.rs
+++ b/clippy_lints/src/methods/readonly_write_lock.rs
@@ -26,13 +26,18 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, receiver
         && let parent = cx.tcx.hir().get_parent(unwrap_call_expr.hir_id)
         && let Node::Local(local) = parent
         && let Some(mir) = enclosing_mir(cx.tcx, expr.hir_id)
-        && let Some((local, _)) = mir.local_decls.iter_enumerated().find(|(_, decl)| {
-            local.span.contains(decl.source_info.span)
-        })
-        && let Some(usages) = visit_local_usage(&[local], mir, Location {
-            block: START_BLOCK,
-            statement_index: 0,
-        })
+        && let Some((local, _)) = mir
+            .local_decls
+            .iter_enumerated()
+            .find(|(_, decl)| local.span.contains(decl.source_info.span))
+        && let Some(usages) = visit_local_usage(
+            &[local],
+            mir,
+            Location {
+                block: START_BLOCK,
+                statement_index: 0,
+            },
+        )
         && let [usage] = usages.as_slice()
     {
         let writer_never_mutated = usage.local_consume_or_mutate_locs.is_empty();
@@ -45,7 +50,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, receiver
                 "this write lock is used only for reading",
                 "consider using a read lock instead",
                 format!("{}.read()", snippet(cx, receiver.span, "<receiver>")),
-                Applicability::MaybeIncorrect // write lock might be intentional for enforcing exclusiveness
+                Applicability::MaybeIncorrect, // write lock might be intentional for enforcing exclusiveness
             );
         }
     }
diff --git a/clippy_lints/src/methods/seek_from_current.rs b/clippy_lints/src/methods/seek_from_current.rs
index 4ea87027a9e..63d41677fee 100644
--- a/clippy_lints/src/methods/seek_from_current.rs
+++ b/clippy_lints/src/methods/seek_from_current.rs
@@ -33,15 +33,17 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, recv: &'
 }
 
 fn arg_is_seek_from_current<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> bool {
-    if let ExprKind::Call(f, args) = expr.kind &&
-        let ExprKind::Path(ref path) = f.kind &&
-        let Some(def_id) = cx.qpath_res(path, f.hir_id).opt_def_id() &&
-        match_def_path(cx, def_id, &paths::STD_IO_SEEK_FROM_CURRENT) {
+    if let ExprKind::Call(f, args) = expr.kind
+        && let ExprKind::Path(ref path) = f.kind
+        && let Some(def_id) = cx.qpath_res(path, f.hir_id).opt_def_id()
+        && match_def_path(cx, def_id, &paths::STD_IO_SEEK_FROM_CURRENT)
+    {
         // check if argument of `SeekFrom::Current` is `0`
-        if args.len() == 1 &&
-            let ExprKind::Lit(lit) = args[0].kind &&
-            let LitKind::Int(0, LitIntType::Unsuffixed) = lit.node {
-            return true
+        if args.len() == 1
+            && let ExprKind::Lit(lit) = args[0].kind
+            && let LitKind::Int(0, LitIntType::Unsuffixed) = lit.node
+        {
+            return true;
         }
     }
 
diff --git a/clippy_lints/src/methods/seek_to_start_instead_of_rewind.rs b/clippy_lints/src/methods/seek_to_start_instead_of_rewind.rs
index 50d4de7a680..9f38460357b 100644
--- a/clippy_lints/src/methods/seek_to_start_instead_of_rewind.rs
+++ b/clippy_lints/src/methods/seek_to_start_instead_of_rewind.rs
@@ -23,15 +23,15 @@ pub(super) fn check<'tcx>(
         return;
     }
 
-    if let Some(seek_trait_id) = cx.tcx.get_diagnostic_item(sym::IoSeek) &&
-        implements_trait(cx, ty, seek_trait_id, &[]) &&
-        let ExprKind::Call(func, args1) = arg.kind &&
-        let ExprKind::Path(ref path) = func.kind &&
-        let Some(def_id) = cx.qpath_res(path, func.hir_id).opt_def_id() &&
-        match_def_path(cx, def_id, &paths::STD_IO_SEEKFROM_START) &&
-        args1.len() == 1 &&
-        let ExprKind::Lit(lit) = args1[0].kind &&
-        let LitKind::Int(0, LitIntType::Unsuffixed) = lit.node
+    if let Some(seek_trait_id) = cx.tcx.get_diagnostic_item(sym::IoSeek)
+        && implements_trait(cx, ty, seek_trait_id, &[])
+        && let ExprKind::Call(func, args1) = arg.kind
+        && let ExprKind::Path(ref path) = func.kind
+        && let Some(def_id) = cx.qpath_res(path, func.hir_id).opt_def_id()
+        && match_def_path(cx, def_id, &paths::STD_IO_SEEKFROM_START)
+        && args1.len() == 1
+        && let ExprKind::Lit(lit) = args1[0].kind
+        && let LitKind::Int(0, LitIntType::Unsuffixed) = lit.node
     {
         let method_call_span = expr.span.with_lo(name_span.lo());
         span_lint_and_then(
diff --git a/clippy_lints/src/methods/str_splitn.rs b/clippy_lints/src/methods/str_splitn.rs
index 6e00e0fd1fb..9da61bca52c 100644
--- a/clippy_lints/src/methods/str_splitn.rs
+++ b/clippy_lints/src/methods/str_splitn.rs
@@ -133,13 +133,11 @@ fn check_manual_split_once_indirect(
         && let PatKind::Binding(BindingAnnotation::MUT, iter_binding_id, iter_ident, None) = local.pat.kind
         && let (iter_stmt_id, Node::Stmt(_)) = parents.next()?
         && let (_, Node::Block(enclosing_block)) = parents.next()?
-
         && let mut stmts = enclosing_block
             .stmts
             .iter()
             .skip_while(|stmt| stmt.hir_id != iter_stmt_id)
             .skip(1)
-
         && let first = indirect_usage(cx, stmts.next()?, iter_binding_id, ctxt)?
         && let second = indirect_usage(cx, stmts.next()?, iter_binding_id, ctxt)?
         && first.unwrap_kind == second.unwrap_kind
@@ -173,18 +171,8 @@ fn check_manual_split_once_indirect(
             );
 
             let remove_msg = format!("remove the `{iter_ident}` usages");
-            diag.span_suggestion(
-                first.span,
-                remove_msg.clone(),
-                "",
-                app,
-            );
-            diag.span_suggestion(
-                second.span,
-                remove_msg,
-                "",
-                app,
-            );
+            diag.span_suggestion(first.span, remove_msg.clone(), "", app);
+            diag.span_suggestion(second.span, remove_msg, "", app);
         });
     }
 
diff --git a/clippy_lints/src/methods/string_lit_chars_any.rs b/clippy_lints/src/methods/string_lit_chars_any.rs
index fb8075e2362..5f6f027a3b5 100644
--- a/clippy_lints/src/methods/string_lit_chars_any.rs
+++ b/clippy_lints/src/methods/string_lit_chars_any.rs
@@ -52,7 +52,7 @@ pub(super) fn check<'tcx>(
                     format!("matches!({scrutinee_snip}, {pat_snip})"),
                     Applicability::MachineApplicable,
                 );
-            }
+            },
         );
     }
 }
diff --git a/clippy_lints/src/methods/suspicious_command_arg_space.rs b/clippy_lints/src/methods/suspicious_command_arg_space.rs
index 8959e2c1d75..b2c5987e43d 100644
--- a/clippy_lints/src/methods/suspicious_command_arg_space.rs
+++ b/clippy_lints/src/methods/suspicious_command_arg_space.rs
@@ -25,13 +25,10 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, recv: &'tcx hir::Expr<'_>, arg
             |diag: &mut Diagnostic| {
                 diag.multipart_suggestion_verbose(
                     "consider splitting the argument",
-                    vec![
-                        (span, "args".to_string()),
-                        (arg.span, format!("[{arg1:?}, {arg2:?}]")),
-                    ],
+                    vec![(span, "args".to_string()), (arg.span, format!("[{arg1:?}, {arg2:?}]"))],
                     Applicability::MaybeIncorrect,
                 );
-            }
+            },
         );
     }
 }
diff --git a/clippy_lints/src/methods/type_id_on_box.rs b/clippy_lints/src/methods/type_id_on_box.rs
index 3404bdfe79b..4917936a932 100644
--- a/clippy_lints/src/methods/type_id_on_box.rs
+++ b/clippy_lints/src/methods/type_id_on_box.rs
@@ -44,11 +44,11 @@ pub(super) fn check(cx: &LateContext<'_>, receiver: &Expr<'_>, call_span: Span)
 
                 diag.note(
                     "this returns the type id of the literal type `Box<dyn Any>` instead of the \
-                    type id of the boxed value, which is most likely not what you want"
+                    type id of the boxed value, which is most likely not what you want",
                 )
                 .note(
                     "if this is intentional, use `TypeId::of::<Box<dyn Any>>()` instead, \
-                    which makes it more clear"
+                    which makes it more clear",
                 )
                 .span_suggestion(
                     receiver.span,
diff --git a/clippy_lints/src/methods/unnecessary_fallible_conversions.rs b/clippy_lints/src/methods/unnecessary_fallible_conversions.rs
index 6660ad215d8..bb32b1bb7fc 100644
--- a/clippy_lints/src/methods/unnecessary_fallible_conversions.rs
+++ b/clippy_lints/src/methods/unnecessary_fallible_conversions.rs
@@ -43,16 +43,15 @@ fn check<'tcx>(
         // what `<T as TryFrom<U>>::Error` is: it's always `Infallible`
         && implements_trait(cx, self_ty, from_into_trait, &[other_ty])
     {
-        let parent_unwrap_call = get_parent_expr(cx, expr)
-            .and_then(|parent| {
-                if let ExprKind::MethodCall(path, .., span) = parent.kind
-                    && let sym::unwrap | sym::expect = path.ident.name
-                {
-                    Some(span)
-                } else {
-                    None
-                }
-            });
+        let parent_unwrap_call = get_parent_expr(cx, expr).and_then(|parent| {
+            if let ExprKind::MethodCall(path, .., span) = parent.kind
+                && let sym::unwrap | sym::expect = path.ident.name
+            {
+                Some(span)
+            } else {
+                None
+            }
+        });
 
         let (sugg, span, applicability) = match kind {
             FunctionKind::TryIntoMethod if let Some(unwrap_span) = parent_unwrap_call => {
@@ -63,8 +62,12 @@ fn check<'tcx>(
                 // `try_into().unwrap()` specifically can be trivially replaced with just `into()`,
                 // so that can be machine-applicable
 
-                ("into()", primary_span.with_hi(unwrap_span.hi()), Applicability::MachineApplicable)
-            }
+                (
+                    "into()",
+                    primary_span.with_hi(unwrap_span.hi()),
+                    Applicability::MachineApplicable,
+                )
+            },
             FunctionKind::TryFromFunction => ("From::from", primary_span, Applicability::Unspecified),
             FunctionKind::TryIntoFunction => ("Into::into", primary_span, Applicability::Unspecified),
             FunctionKind::TryIntoMethod => ("into", primary_span, Applicability::Unspecified),
@@ -77,7 +80,7 @@ fn check<'tcx>(
             "use of a fallible conversion when an infallible one could be used",
             "use",
             sugg.into(),
-            applicability
+            applicability,
         );
     }
 }
diff --git a/clippy_lints/src/methods/unnecessary_literal_unwrap.rs b/clippy_lints/src/methods/unnecessary_literal_unwrap.rs
index 3e19d72ec91..a1125d70db3 100644
--- a/clippy_lints/src/methods/unnecessary_literal_unwrap.rs
+++ b/clippy_lints/src/methods/unnecessary_literal_unwrap.rs
@@ -81,7 +81,7 @@ pub(super) fn check(
                 {
                     suggs.extend([
                         (block.span.shrink_to_lo().to(expr.span.shrink_to_lo()), String::new()),
-                        (expr.span.shrink_to_hi().to(block.span.shrink_to_hi()), String::new())
+                        (expr.span.shrink_to_hi().to(block.span.shrink_to_hi()), String::new()),
                     ]);
                 }
                 Some(suggs)
diff --git a/clippy_lints/src/methods/unnecessary_to_owned.rs b/clippy_lints/src/methods/unnecessary_to_owned.rs
index 78d4bae60e5..772686d93dd 100644
--- a/clippy_lints/src/methods/unnecessary_to_owned.rs
+++ b/clippy_lints/src/methods/unnecessary_to_owned.rs
@@ -382,10 +382,10 @@ fn can_change_type<'a>(cx: &LateContext<'a>, mut expr: &'a Expr<'a>, mut ty: Ty<
             Node::Block(..) => continue,
             Node::Item(item) => {
                 if let ItemKind::Fn(_, _, body_id) = &item.kind
-                && let output_ty = return_ty(cx, item.owner_id)
-                && let inherited = Inherited::new(cx.tcx, item.owner_id.def_id)
-                && let fn_ctxt = FnCtxt::new(&inherited, cx.param_env, item.owner_id.def_id)
-                && fn_ctxt.can_coerce(ty, output_ty)
+                    && let output_ty = return_ty(cx, item.owner_id)
+                    && let inherited = Inherited::new(cx.tcx, item.owner_id.def_id)
+                    && let fn_ctxt = FnCtxt::new(&inherited, cx.param_env, item.owner_id.def_id)
+                    && fn_ctxt.can_coerce(ty, output_ty)
                 {
                     if has_lifetime(output_ty) && has_lifetime(ty) {
                         return false;
@@ -393,12 +393,15 @@ fn can_change_type<'a>(cx: &LateContext<'a>, mut expr: &'a Expr<'a>, mut ty: Ty<
                     let body = cx.tcx.hir().body(*body_id);
                     let body_expr = &body.value;
                     let mut count = 0;
-                    return find_all_ret_expressions(cx, body_expr, |_| { count += 1; count <= 1 });
+                    return find_all_ret_expressions(cx, body_expr, |_| {
+                        count += 1;
+                        count <= 1
+                    });
                 }
-            }
+            },
             Node::Expr(parent_expr) => {
-                if let Some((callee_def_id, call_generic_args, recv, call_args))
-                    = get_callee_generic_args_and_args(cx, parent_expr)
+                if let Some((callee_def_id, call_generic_args, recv, call_args)) =
+                    get_callee_generic_args_and_args(cx, parent_expr)
                 {
                     // FIXME: the `instantiate_identity()` below seems incorrect, since we eventually
                     // call `tcx.try_instantiate_and_normalize_erasing_regions` further down
@@ -420,40 +423,49 @@ fn can_change_type<'a>(cx: &LateContext<'a>, mut expr: &'a Expr<'a>, mut ty: Ty<
                             return false;
                         }
 
-                        let mut trait_predicates = cx.tcx.param_env(callee_def_id)
-                            .caller_bounds().iter().filter(|predicate| {
-                            if let ClauseKind::Trait(trait_predicate)
-                                    = predicate.kind().skip_binder()
-                                && trait_predicate.trait_ref.self_ty() == *param_ty
-                            {
-                                true
-                            } else {
-                                false
-                            }
-                        });
+                        let mut trait_predicates =
+                            cx.tcx
+                                .param_env(callee_def_id)
+                                .caller_bounds()
+                                .iter()
+                                .filter(|predicate| {
+                                    if let ClauseKind::Trait(trait_predicate) = predicate.kind().skip_binder()
+                                        && trait_predicate.trait_ref.self_ty() == *param_ty
+                                    {
+                                        true
+                                    } else {
+                                        false
+                                    }
+                                });
 
-                        let new_subst = cx.tcx.mk_args_from_iter(
-                            call_generic_args.iter()
-                                .enumerate()
-                                .map(|(i, t)|
-                                     if i == (*param_index as usize) {
-                                         GenericArg::from(ty)
-                                     } else {
-                                         t
-                                     }));
+                        let new_subst = cx
+                            .tcx
+                            .mk_args_from_iter(call_generic_args.iter().enumerate().map(|(i, t)| {
+                                if i == (*param_index as usize) {
+                                    GenericArg::from(ty)
+                                } else {
+                                    t
+                                }
+                            }));
 
                         if trait_predicates.any(|predicate| {
                             let predicate = EarlyBinder::bind(predicate).instantiate(cx.tcx, new_subst);
                             let obligation = Obligation::new(cx.tcx, ObligationCause::dummy(), cx.param_env, predicate);
-                            !cx.tcx.infer_ctxt().build().predicate_must_hold_modulo_regions(&obligation)
+                            !cx.tcx
+                                .infer_ctxt()
+                                .build()
+                                .predicate_must_hold_modulo_regions(&obligation)
                         }) {
                             return false;
                         }
 
                         let output_ty = fn_sig.output();
                         if output_ty.contains(*param_ty) {
-                            if let Ok(new_ty)  = cx.tcx.try_instantiate_and_normalize_erasing_regions(
-                                new_subst, cx.param_env, EarlyBinder::bind(output_ty)) {
+                            if let Ok(new_ty) = cx.tcx.try_instantiate_and_normalize_erasing_regions(
+                                new_subst,
+                                cx.param_env,
+                                EarlyBinder::bind(output_ty),
+                            ) {
                                 expr = parent_expr;
                                 ty = new_ty;
                                 continue;
@@ -515,10 +527,11 @@ fn is_to_string_on_string_like<'a>(
         && let GenericArgKind::Type(ty) = generic_arg.unpack()
         && let Some(deref_trait_id) = cx.tcx.get_diagnostic_item(sym::Deref)
         && let Some(as_ref_trait_id) = cx.tcx.get_diagnostic_item(sym::AsRef)
-        && (cx.get_associated_type(ty, deref_trait_id, "Target") == Some(cx.tcx.types.str_) ||
-            implements_trait(cx, ty, as_ref_trait_id, &[cx.tcx.types.str_.into()])) {
-            true
-        } else {
-            false
-        }
+        && (cx.get_associated_type(ty, deref_trait_id, "Target") == Some(cx.tcx.types.str_)
+            || implements_trait(cx, ty, as_ref_trait_id, &[cx.tcx.types.str_.into()]))
+    {
+        true
+    } else {
+        false
+    }
 }
diff --git a/clippy_lints/src/min_ident_chars.rs b/clippy_lints/src/min_ident_chars.rs
index c79a1a7b9d4..4ad12e899fe 100644
--- a/clippy_lints/src/min_ident_chars.rs
+++ b/clippy_lints/src/min_ident_chars.rs
@@ -107,13 +107,17 @@ impl Visitor<'_> for IdentVisitor<'_, '_> {
 
         let str = ident.as_str();
         if conf.is_ident_too_short(cx, str, ident.span) {
-            if let Node::Item(item) = node && let ItemKind::Use(..) = item.kind {
+            if let Node::Item(item) = node
+                && let ItemKind::Use(..) = item.kind
+            {
                 return;
             }
             // `struct Awa<T>(T)`
             //                ^
             if let Node::PathSegment(path) = node {
-                if let Res::Def(def_kind, ..) = path.res && let DefKind::TyParam = def_kind {
+                if let Res::Def(def_kind, ..) = path.res
+                    && let DefKind::TyParam = def_kind
+                {
                     return;
                 }
                 if matches!(path.res, Res::PrimTy(..)) || path.res.opt_def_id().is_some_and(|def_id| !def_id.is_local())
diff --git a/clippy_lints/src/misc.rs b/clippy_lints/src/misc.rs
index a102b5dfde6..01eace6c48c 100644
--- a/clippy_lints/src/misc.rs
+++ b/clippy_lints/src/misc.rs
@@ -263,7 +263,7 @@ impl<'tcx> LateLintPass<'tcx> for LintPass {
                 ),
                 |diag| {
                     diag.span_note(definition_span, format!("`{name}` is defined here"));
-                }
+                },
             );
         }
     }
diff --git a/clippy_lints/src/missing_asserts_for_indexing.rs b/clippy_lints/src/missing_asserts_for_indexing.rs
index 094939f862e..dccf72d3c84 100644
--- a/clippy_lints/src/missing_asserts_for_indexing.rs
+++ b/clippy_lints/src/missing_asserts_for_indexing.rs
@@ -200,9 +200,13 @@ impl<'hir> IndexEntry<'hir> {
 /// E.g. for `5` this returns `Some(5)`, for `..5` this returns `Some(4)`,
 /// for `..=5` this returns `Some(5)`
 fn upper_index_expr(expr: &Expr<'_>) -> Option<usize> {
-    if let ExprKind::Lit(lit) = &expr.kind && let LitKind::Int(index, _) = lit.node {
+    if let ExprKind::Lit(lit) = &expr.kind
+        && let LitKind::Int(index, _) = lit.node
+    {
         Some(index as usize)
-    } else if let Some(higher::Range { end: Some(end), limits, .. }) = higher::Range::hir(expr)
+    } else if let Some(higher::Range {
+        end: Some(end), limits, ..
+    }) = higher::Range::hir(expr)
         && let ExprKind::Lit(lit) = &end.kind
         && let LitKind::Int(index @ 1.., _) = lit.node
     {
@@ -228,7 +232,12 @@ fn check_index<'hir>(cx: &LateContext<'_>, expr: &'hir Expr<'hir>, map: &mut Unh
 
         if let Some(entry) = entry {
             match entry {
-                IndexEntry::StrayAssert { asserted_len, comparison, assert_span, slice } => {
+                IndexEntry::StrayAssert {
+                    asserted_len,
+                    comparison,
+                    assert_span,
+                    slice,
+                } => {
                     *entry = IndexEntry::AssertWithIndex {
                         highest_index: index,
                         asserted_len: *asserted_len,
@@ -238,8 +247,12 @@ fn check_index<'hir>(cx: &LateContext<'_>, expr: &'hir Expr<'hir>, map: &mut Unh
                         comparison: *comparison,
                     };
                 },
-                IndexEntry::IndexWithoutAssert { highest_index, indexes, .. }
-                | IndexEntry::AssertWithIndex { highest_index, indexes, .. } => {
+                IndexEntry::IndexWithoutAssert {
+                    highest_index, indexes, ..
+                }
+                | IndexEntry::AssertWithIndex {
+                    highest_index, indexes, ..
+                } => {
                     indexes.push(expr.span);
                     *highest_index = (*highest_index).max(index);
                 },
diff --git a/clippy_lints/src/needless_bool.rs b/clippy_lints/src/needless_bool.rs
index 025eba2d166..02c177c9227 100644
--- a/clippy_lints/src/needless_bool.rs
+++ b/clippy_lints/src/needless_bool.rs
@@ -207,9 +207,9 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessBool {
                     _ => (),
                 }
             }
-            if let Some((lhs_a, a)) = fetch_assign(then) &&
-                let Some((lhs_b, b)) = fetch_assign(r#else) &&
-                SpanlessEq::new(cx).eq_expr(lhs_a, lhs_b)
+            if let Some((lhs_a, a)) = fetch_assign(then)
+                && let Some((lhs_b, b)) = fetch_assign(r#else)
+                && SpanlessEq::new(cx).eq_expr(lhs_a, lhs_b)
             {
                 let mut applicability = Applicability::MachineApplicable;
                 let cond = Sugg::hir_with_applicability(cx, cond, "..", &mut applicability);
@@ -226,7 +226,7 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessBool {
                     "this if-then-else expression assigns a bool literal",
                     "you can reduce it to",
                     sugg,
-                    applicability
+                    applicability,
                 );
             }
         }
diff --git a/clippy_lints/src/needless_borrows_for_generic_args.rs b/clippy_lints/src/needless_borrows_for_generic_args.rs
index 53f449f2d43..dcfb109a4c4 100644
--- a/clippy_lints/src/needless_borrows_for_generic_args.rs
+++ b/clippy_lints/src/needless_borrows_for_generic_args.rs
@@ -87,18 +87,24 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessBorrowsForGenericArgs<'tcx> {
             && let ty::Param(ty) = *ty.value.skip_binder().kind()
             && let Some((hir_id, fn_id, i)) = match use_cx.node {
                 ExprUseNode::MethodArg(_, _, 0) => None,
-                ExprUseNode::MethodArg(hir_id, None, i) => {
-                    cx.typeck_results().type_dependent_def_id(hir_id).map(|id| (hir_id, id, i))
-                },
-                ExprUseNode::FnArg(&Expr { kind: ExprKind::Path(ref p), hir_id, .. }, i)
-                if !path_has_args(p) => match cx.typeck_results().qpath_res(p, hir_id) {
-                    Res::Def(DefKind::Fn | DefKind::Ctor(..) | DefKind::AssocFn, id) => {
-                        Some((hir_id, id, i))
+                ExprUseNode::MethodArg(hir_id, None, i) => cx
+                    .typeck_results()
+                    .type_dependent_def_id(hir_id)
+                    .map(|id| (hir_id, id, i)),
+                ExprUseNode::FnArg(
+                    &Expr {
+                        kind: ExprKind::Path(ref p),
+                        hir_id,
+                        ..
                     },
+                    i,
+                ) if !path_has_args(p) => match cx.typeck_results().qpath_res(p, hir_id) {
+                    Res::Def(DefKind::Fn | DefKind::Ctor(..) | DefKind::AssocFn, id) => Some((hir_id, id, i)),
                     _ => None,
                 },
                 _ => None,
-            } && let count = needless_borrow_count(
+            }
+            && let count = needless_borrow_count(
                 cx,
                 &mut self.possible_borrowers,
                 fn_id,
@@ -107,7 +113,8 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessBorrowsForGenericArgs<'tcx> {
                 ty,
                 expr,
                 &self.msrv,
-            ) && count != 0
+            )
+            && count != 0
         {
             span_lint_and_then(
                 cx,
@@ -119,7 +126,7 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessBorrowsForGenericArgs<'tcx> {
                     let snip_span = peel_n_hir_expr_refs(expr, count).0.span;
                     let snip = snippet_with_context(cx, snip_span, expr.span.ctxt(), "..", &mut app).0;
                     diag.span_suggestion(expr.span, "change this to", snip.into_owned(), app);
-                }
+                },
             );
         }
     }
@@ -245,7 +252,9 @@ fn needless_borrow_count<'tcx>(
 
         predicates.iter().all(|predicate| {
             if let ClauseKind::Trait(trait_predicate) = predicate.kind().skip_binder()
-                && cx.tcx.is_diagnostic_item(sym::IntoIterator, trait_predicate.trait_ref.def_id)
+                && cx
+                    .tcx
+                    .is_diagnostic_item(sym::IntoIterator, trait_predicate.trait_ref.def_id)
                 && let ty::Param(param_ty) = trait_predicate.self_ty().kind()
                 && let GenericArgKind::Type(ty) = args_with_referent_ty[param_ty.index as usize].unpack()
                 && ty.is_array()
@@ -308,13 +317,13 @@ fn is_mixed_projection_predicate<'tcx>(
             match projection_ty.self_ty().kind() {
                 ty::Alias(ty::Projection, inner_projection_ty) => {
                     projection_ty = *inner_projection_ty;
-                }
+                },
                 ty::Param(param_ty) => {
                     return (param_ty.index as usize) >= generics.parent_count;
-                }
+                },
                 _ => {
                     return false;
-                }
+                },
             }
         }
     } else {
diff --git a/clippy_lints/src/needless_parens_on_range_literals.rs b/clippy_lints/src/needless_parens_on_range_literals.rs
index 15589680220..7bbf1fb4cd9 100644
--- a/clippy_lints/src/needless_parens_on_range_literals.rs
+++ b/clippy_lints/src/needless_parens_on_range_literals.rs
@@ -46,9 +46,9 @@ fn snippet_enclosed_in_parenthesis(snippet: &str) -> bool {
 }
 
 fn check_for_parens(cx: &LateContext<'_>, e: &Expr<'_>, is_start: bool) {
-    if is_start &&
-    let ExprKind::Lit(literal) = e.kind &&
-    let ast::LitKind::Float(_sym, ast::LitFloatType::Unsuffixed) = literal.node
+    if is_start
+        && let ExprKind::Lit(literal) = e.kind
+        && let ast::LitKind::Float(_sym, ast::LitFloatType::Unsuffixed) = literal.node
     {
         // don't check floating point literals on the start expression of a range
         return;
diff --git a/clippy_lints/src/needless_pass_by_ref_mut.rs b/clippy_lints/src/needless_pass_by_ref_mut.rs
index efb218cd316..d610ba520a4 100644
--- a/clippy_lints/src/needless_pass_by_ref_mut.rs
+++ b/clippy_lints/src/needless_pass_by_ref_mut.rs
@@ -225,7 +225,10 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByRefMut<'tcx> {
             if let PatKind::Binding(_, canonical_id, ..) = arg.pat.kind
                 && !mutably_used_vars.contains(&canonical_id)
             {
-                self.fn_def_ids_to_maybe_unused_mut.entry(fn_def_id).or_default().push(input);
+                self.fn_def_ids_to_maybe_unused_mut
+                    .entry(fn_def_id)
+                    .or_default()
+                    .push(input);
             }
         }
     }
@@ -520,7 +523,11 @@ impl<'tcx> Visitor<'tcx> for FnNeedsMutVisitor<'_, 'tcx> {
         // #11182; do not lint if mutability is required elsewhere
         if let Node::Expr(expr) = cx.tcx.hir().get(hir_id)
             && let Some(parent) = get_parent_node(cx.tcx, expr.hir_id)
-            && let ty::FnDef(def_id, _) = cx.tcx.typeck(cx.tcx.hir().enclosing_body_owner(hir_id)).expr_ty(expr).kind()
+            && let ty::FnDef(def_id, _) = cx
+                .tcx
+                .typeck(cx.tcx.hir().enclosing_body_owner(hir_id))
+                .expr_ty(expr)
+                .kind()
             && let Some(def_id) = def_id.as_local()
         {
             if let Node::Expr(e) = parent
diff --git a/clippy_lints/src/needless_question_mark.rs b/clippy_lints/src/needless_question_mark.rs
index 76a751012fb..074c9fef1b2 100644
--- a/clippy_lints/src/needless_question_mark.rs
+++ b/clippy_lints/src/needless_question_mark.rs
@@ -4,7 +4,7 @@ use clippy_utils::source::snippet;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::def::{DefKind, Res};
-use rustc_hir::{CoroutineSource, Block, Body, CoroutineKind, Expr, ExprKind, LangItem, MatchSource, QPath};
+use rustc_hir::{Block, Body, CoroutineKind, CoroutineSource, Expr, ExprKind, LangItem, MatchSource, QPath};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
diff --git a/clippy_lints/src/no_effect.rs b/clippy_lints/src/no_effect.rs
index 60b40aecafa..3a28e511fdd 100644
--- a/clippy_lints/src/no_effect.rs
+++ b/clippy_lints/src/no_effect.rs
@@ -103,11 +103,16 @@ fn check_no_effect(cx: &LateContext<'_>, stmt: &Stmt<'_>) -> bool {
                             && final_stmt.hir_id == stmt.hir_id
                         {
                             let expr_ty = cx.typeck_results().expr_ty(expr);
-                            let mut ret_ty = cx.tcx.fn_sig(item.owner_id).instantiate_identity().output().skip_binder();
+                            let mut ret_ty = cx
+                                .tcx
+                                .fn_sig(item.owner_id)
+                                .instantiate_identity()
+                                .output()
+                                .skip_binder();
 
                             // Remove `impl Future<Output = T>` to get `T`
-                            if cx.tcx.ty_is_opaque_future(ret_ty) &&
-                                let Some(true_ret_ty) = cx.tcx.infer_ctxt().build().get_impl_future_output_ty(ret_ty)
+                            if cx.tcx.ty_is_opaque_future(ret_ty)
+                                && let Some(true_ret_ty) = cx.tcx.infer_ctxt().build().get_impl_future_output_ty(ret_ty)
                             {
                                 ret_ty = true_ret_ty;
                             }
diff --git a/clippy_lints/src/no_mangle_with_rust_abi.rs b/clippy_lints/src/no_mangle_with_rust_abi.rs
index f2a7debc930..04d75014892 100644
--- a/clippy_lints/src/no_mangle_with_rust_abi.rs
+++ b/clippy_lints/src/no_mangle_with_rust_abi.rs
@@ -48,7 +48,8 @@ impl<'tcx> LateLintPass<'tcx> for NoMangleWithRustAbi {
                     && let Some((fn_attrs, _)) = snippet.split_once("fn")
                     && !fn_attrs.contains("extern")
                 {
-                    let sugg_span = fn_sig.span
+                    let sugg_span = fn_sig
+                        .span
                         .with_lo(fn_sig.span.lo() + BytePos::from_usize(fn_attrs.len()))
                         .shrink_to_lo();
 
diff --git a/clippy_lints/src/non_canonical_impls.rs b/clippy_lints/src/non_canonical_impls.rs
index 427e636bdf8..9689f63a013 100644
--- a/clippy_lints/src/non_canonical_impls.rs
+++ b/clippy_lints/src/non_canonical_impls.rs
@@ -131,12 +131,7 @@ impl LateLintPass<'_> for NonCanonicalImpls {
 
         if cx.tcx.is_diagnostic_item(sym::Clone, trait_impl.def_id)
             && let Some(copy_def_id) = cx.tcx.get_diagnostic_item(sym::Copy)
-            && implements_trait(
-                    cx,
-                    trait_impl.self_ty(),
-                    copy_def_id,
-                    &[],
-                )
+            && implements_trait(cx, trait_impl.self_ty(), copy_def_id, &[])
         {
             if impl_item.ident.name == sym::clone {
                 if block.stmts.is_empty()
@@ -144,7 +139,8 @@ impl LateLintPass<'_> for NonCanonicalImpls {
                     && let ExprKind::Unary(UnOp::Deref, deref) = expr.kind
                     && let ExprKind::Path(qpath) = deref.kind
                     && last_path_segment(&qpath).ident.name == kw::SelfLower
-                {} else {
+                {
+                } else {
                     span_lint_and_sugg(
                         cx,
                         NON_CANONICAL_CLONE_IMPL,
@@ -197,10 +193,13 @@ impl LateLintPass<'_> for NonCanonicalImpls {
                 && is_res_lang_ctor(cx, cx.qpath_res(some_path, *some_hir_id), LangItem::OptionSome)
                 // Fix #11178, allow `Self::cmp(self, ..)` too
                 && self_cmp_call(cx, cmp_expr, impl_item.owner_id.def_id, &mut needs_fully_qualified)
-            {} else {
+            {
+            } else {
                 // If `Self` and `Rhs` are not the same type, bail. This makes creating a valid
                 // suggestion tons more complex.
-                if let [lhs, rhs, ..] = trait_impl.args.as_slice() && lhs != rhs {
+                if let [lhs, rhs, ..] = trait_impl.args.as_slice()
+                    && lhs != rhs
+                {
                     return;
                 }
 
@@ -238,12 +237,8 @@ impl LateLintPass<'_> for NonCanonicalImpls {
                             ],
                         };
 
-                        diag.multipart_suggestion(
-                            "change this to",
-                            suggs,
-                            Applicability::Unspecified,
-                        );
-                    }
+                        diag.multipart_suggestion("change this to", suggs, Applicability::Unspecified);
+                    },
                 );
             }
         }
diff --git a/clippy_lints/src/only_used_in_recursion.rs b/clippy_lints/src/only_used_in_recursion.rs
index abc8927909b..ef7b367649f 100644
--- a/clippy_lints/src/only_used_in_recursion.rs
+++ b/clippy_lints/src/only_used_in_recursion.rs
@@ -244,7 +244,10 @@ impl<'tcx> LateLintPass<'tcx> for OnlyUsedInRecursion {
             })) => {
                 #[allow(trivial_casts)]
                 if let Some(Node::Item(item)) = get_parent_node(cx.tcx, owner_id.into())
-                    && let Some(trait_ref) = cx.tcx.impl_trait_ref(item.owner_id).map(EarlyBinder::instantiate_identity)
+                    && let Some(trait_ref) = cx
+                        .tcx
+                        .impl_trait_ref(item.owner_id)
+                        .map(EarlyBinder::instantiate_identity)
                     && let Some(trait_item_id) = cx.tcx.associated_item(owner_id).trait_item_def_id
                 {
                     (
@@ -288,8 +291,7 @@ impl<'tcx> LateLintPass<'tcx> for OnlyUsedInRecursion {
                         // Recursive call. Track which index the parameter is used in.
                         ExprKind::Call(callee, args)
                             if path_def_id(cx, callee).map_or(false, |id| {
-                                id == param.fn_id
-                                    && has_matching_args(param.fn_kind, typeck.node_args(callee.hir_id))
+                                id == param.fn_id && has_matching_args(param.fn_kind, typeck.node_args(callee.hir_id))
                             }) =>
                         {
                             if let Some(idx) = args.iter().position(|arg| arg.hir_id == child_id) {
@@ -299,8 +301,7 @@ impl<'tcx> LateLintPass<'tcx> for OnlyUsedInRecursion {
                         },
                         ExprKind::MethodCall(_, receiver, args, _)
                             if typeck.type_dependent_def_id(parent.hir_id).map_or(false, |id| {
-                                id == param.fn_id
-                                    && has_matching_args(param.fn_kind, typeck.node_args(parent.hir_id))
+                                id == param.fn_id && has_matching_args(param.fn_kind, typeck.node_args(parent.hir_id))
                             }) =>
                         {
                             if let Some(idx) = iter::once(receiver).chain(args).position(|arg| arg.hir_id == child_id) {
@@ -336,8 +337,8 @@ impl<'tcx> LateLintPass<'tcx> for OnlyUsedInRecursion {
                         // Only allow field accesses without auto-deref
                         ExprKind::Field(..) if typeck.adjustments().get(child_id).is_none() => {
                             e = parent;
-                            continue
-                        }
+                            continue;
+                        },
                         _ => (),
                     },
                     _ => (),
diff --git a/clippy_lints/src/operators/arithmetic_side_effects.rs b/clippy_lints/src/operators/arithmetic_side_effects.rs
index a10aa65e594..4e8631eefa1 100644
--- a/clippy_lints/src/operators/arithmetic_side_effects.rs
+++ b/clippy_lints/src/operators/arithmetic_side_effects.rs
@@ -71,7 +71,7 @@ impl ArithmeticSideEffects {
                 rhs_has_allowed_ty || rhs_from_specific.contains("*")
             }
         {
-           true
+            true
         } else if let Some(rhs_from_glob) = self.allowed_binary.get("*") {
             rhs_from_glob.contains(rhs_ty_string_elem)
         } else {
@@ -144,8 +144,10 @@ impl ArithmeticSideEffects {
     /// like `i32::MAX` or constant references like `N` from `const N: i32 = 1;`,
     fn literal_integer(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> Option<u128> {
         let actual = peel_hir_expr_unary(expr).0;
-        if let hir::ExprKind::Lit(lit) = actual.kind && let ast::LitKind::Int(n, _) = lit.node {
-            return Some(n)
+        if let hir::ExprKind::Lit(lit) = actual.kind
+            && let ast::LitKind::Int(n, _) = lit.node
+        {
+            return Some(n);
         }
         if let Some(Constant::Int(n)) = constant(cx, cx.typeck_results(), expr) {
             return Some(n);
@@ -317,7 +319,9 @@ impl<'tcx> LateLintPass<'tcx> for ArithmeticSideEffects {
         let body_owner_kind = cx.tcx.hir().body_owner_kind(body_owner_def_id);
         if let hir::BodyOwnerKind::Const { .. } | hir::BodyOwnerKind::Static(_) = body_owner_kind {
             let body_span = cx.tcx.hir().span_with_body(body_owner);
-            if let Some(span) = self.const_span && span.contains(body_span) {
+            if let Some(span) = self.const_span
+                && span.contains(body_span)
+            {
                 return;
             }
             self.const_span = Some(body_span);
@@ -327,7 +331,9 @@ impl<'tcx> LateLintPass<'tcx> for ArithmeticSideEffects {
     fn check_body_post(&mut self, cx: &LateContext<'_>, body: &hir::Body<'_>) {
         let body_owner = cx.tcx.hir().body_owner(body.id());
         let body_span = cx.tcx.hir().span(body_owner);
-        if let Some(span) = self.const_span && span.contains(body_span) {
+        if let Some(span) = self.const_span
+            && span.contains(body_span)
+        {
             return;
         }
         self.const_span = None;
diff --git a/clippy_lints/src/operators/eq_op.rs b/clippy_lints/src/operators/eq_op.rs
index 88d56631841..fd3502ad878 100644
--- a/clippy_lints/src/operators/eq_op.rs
+++ b/clippy_lints/src/operators/eq_op.rs
@@ -8,13 +8,14 @@ use rustc_lint::LateContext;
 use super::EQ_OP;
 
 pub(crate) fn check_assert<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
-    if let Some((macro_call, macro_name))
-        = first_node_macro_backtrace(cx, e).find_map(|macro_call| {
-            let name = cx.tcx.item_name(macro_call.def_id);
-            matches!(name.as_str(), "assert_eq" | "assert_ne" | "debug_assert_eq" | "debug_assert_ne")
-                .then(|| (macro_call, name))
-        })
-        && let Some((lhs, rhs, _)) = find_assert_eq_args(cx, e, macro_call.expn)
+    if let Some((macro_call, macro_name)) = first_node_macro_backtrace(cx, e).find_map(|macro_call| {
+        let name = cx.tcx.item_name(macro_call.def_id);
+        matches!(
+            name.as_str(),
+            "assert_eq" | "assert_ne" | "debug_assert_eq" | "debug_assert_ne"
+        )
+        .then(|| (macro_call, name))
+    }) && let Some((lhs, rhs, _)) = find_assert_eq_args(cx, e, macro_call.expn)
         && eq_expr_value(cx, lhs, rhs)
         && macro_call.is_local()
         && !is_in_test_function(cx.tcx, e.hir_id)
@@ -42,7 +43,9 @@ pub(crate) fn check<'tcx>(
             e.span,
             &format!("equal expressions as operands to `{}`", op.as_str()),
             |diag| {
-                if let BinOpKind::Ne = op && cx.typeck_results().expr_ty(left).is_floating_point() {
+                if let BinOpKind::Ne = op
+                    && cx.typeck_results().expr_ty(left).is_floating_point()
+                {
                     diag.note("if you intended to check if the operand is NaN, use `.is_nan()` instead");
                 }
             },
diff --git a/clippy_lints/src/option_env_unwrap.rs b/clippy_lints/src/option_env_unwrap.rs
index 9c7f7e1cd7f..7792efe6acd 100644
--- a/clippy_lints/src/option_env_unwrap.rs
+++ b/clippy_lints/src/option_env_unwrap.rs
@@ -46,16 +46,19 @@ impl EarlyLintPass for OptionEnvUnwrap {
             );
         }
 
-        if let ExprKind::MethodCall(box MethodCall { seg, receiver, .. }) = &expr.kind &&
-		matches!(seg.ident.name, sym::expect | sym::unwrap) {
-			if let ExprKind::Call(caller, _) = &receiver.kind &&
+        if let ExprKind::MethodCall(box MethodCall { seg, receiver, .. }) = &expr.kind
+            && matches!(seg.ident.name, sym::expect | sym::unwrap)
+        {
+            if let ExprKind::Call(caller, _) = &receiver.kind &&
             // If it exists, it will be ::core::option::Option::Some("<env var>").unwrap() (A method call in the HIR)
-            is_direct_expn_of(caller.span, "option_env").is_some() {
-				lint(cx, expr.span);
-			} else if let ExprKind::Path(_, caller) = &receiver.kind && // If it doesn't exist, it will be ::core::option::Option::None::<&'static str>.unwrap() (A path in the HIR)
-            is_direct_expn_of(caller.span, "option_env").is_some() {
-				lint(cx, expr.span);
-			}
-		}
+            is_direct_expn_of(caller.span, "option_env").is_some()
+            {
+                lint(cx, expr.span);
+            } else if let ExprKind::Path(_, caller) = &receiver.kind && // If it doesn't exist, it will be ::core::option::Option::None::<&'static str>.unwrap() (A path in the HIR)
+            is_direct_expn_of(caller.span, "option_env").is_some()
+            {
+                lint(cx, expr.span);
+            }
+        }
     }
 }
diff --git a/clippy_lints/src/option_if_let_else.rs b/clippy_lints/src/option_if_let_else.rs
index 4fd238cdc9f..d7cbbe13a26 100644
--- a/clippy_lints/src/option_if_let_else.rs
+++ b/clippy_lints/src/option_if_let_else.rs
@@ -240,7 +240,7 @@ fn try_convert_match<'tcx>(
     if let [first_arm, second_arm] = arms
         && first_arm.guard.is_none()
         && second_arm.guard.is_none()
-        {
+    {
         return if is_none_or_err_arm(cx, second_arm) {
             Some((first_arm.pat, first_arm.body, second_arm.body))
         } else if is_none_or_err_arm(cx, first_arm) {
diff --git a/clippy_lints/src/pass_by_ref_or_value.rs b/clippy_lints/src/pass_by_ref_or_value.rs
index 4814b3cd661..4d7a055dae1 100644
--- a/clippy_lints/src/pass_by_ref_or_value.rs
+++ b/clippy_lints/src/pass_by_ref_or_value.rs
@@ -208,7 +208,10 @@ impl<'tcx> PassByRefOrValue {
                             cx,
                             TRIVIALLY_COPY_PASS_BY_REF,
                             input.span,
-                            &format!("this argument ({size} byte) is passed by reference, but would be more efficient if passed by value (limit: {} byte)", self.ref_min_size),
+                            &format!(
+                                "this argument ({size} byte) is passed by reference, but would be more efficient if passed by value (limit: {} byte)",
+                                self.ref_min_size
+                            ),
                             "consider passing by value instead",
                             value_type,
                             Applicability::Unspecified,
diff --git a/clippy_lints/src/permissions_set_readonly_false.rs b/clippy_lints/src/permissions_set_readonly_false.rs
index bca8d0b6be8..b98005d5922 100644
--- a/clippy_lints/src/permissions_set_readonly_false.rs
+++ b/clippy_lints/src/permissions_set_readonly_false.rs
@@ -43,9 +43,11 @@ impl<'tcx> LateLintPass<'tcx> for PermissionsSetReadonlyFalse {
                 "call to `set_readonly` with argument `false`",
                 |diag| {
                     diag.note("on Unix platforms this results in the file being world writable");
-                    diag.help("you can set the desired permissions using `PermissionsExt`. For more information, see\n\
-                        https://doc.rust-lang.org/std/os/unix/fs/trait.PermissionsExt.html");
-                }
+                    diag.help(
+                        "you can set the desired permissions using `PermissionsExt`. For more information, see\n\
+                        https://doc.rust-lang.org/std/os/unix/fs/trait.PermissionsExt.html",
+                    );
+                },
             );
         }
     }
diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs
index 310051efc50..945b78185d9 100644
--- a/clippy_lints/src/ptr.rs
+++ b/clippy_lints/src/ptr.rs
@@ -289,10 +289,7 @@ fn check_invalid_ptr_usage<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
             | sym::ptr_write_volatile
             | sym::slice_from_raw_parts
             | sym::slice_from_raw_parts_mut => &[0],
-            sym::ptr_copy
-            | sym::ptr_copy_nonoverlapping
-            | sym::ptr_swap
-            | sym::ptr_swap_nonoverlapping => &[0, 1],
+            sym::ptr_copy | sym::ptr_copy_nonoverlapping | sym::ptr_swap | sym::ptr_swap_nonoverlapping => &[0, 1],
             _ => return,
         };
 
@@ -416,7 +413,6 @@ impl<'tcx> DerefTy<'tcx> {
     }
 }
 
-#[expect(clippy::too_many_lines)]
 fn check_fn_args<'cx, 'tcx: 'cx>(
     cx: &'cx LateContext<'tcx>,
     fn_sig: ty::FnSig<'tcx>,
@@ -438,104 +434,93 @@ fn check_fn_args<'cx, 'tcx: 'cx>(
                 && let [.., name] = path.segments
                 && cx.tcx.item_name(adt.did()) == name.ident.name
             {
-                    let emission_id = params.get(i).map_or(hir_ty.hir_id, |param| param.hir_id);
-                    let (method_renames, deref_ty) = match cx.tcx.get_diagnostic_name(adt.did()) {
-                        Some(sym::Vec) => (
-                            [("clone", ".to_owned()")].as_slice(),
-                            DerefTy::Slice(
-                                name.args
-                                    .and_then(|args| args.args.first())
-                                    .and_then(|arg| if let GenericArg::Type(ty) = arg {
-                                        Some(ty.span)
-                                    } else {
-                                        None
-                                    }),
-                                args.type_at(0),
-                            ),
-                        ),
-                        _ if Some(adt.did()) == cx.tcx.lang_items().string() => (
-                            [("clone", ".to_owned()"), ("as_str", "")].as_slice(),
-                            DerefTy::Str,
-                        ),
-                        Some(sym::PathBuf) => (
-                            [("clone", ".to_path_buf()"), ("as_path", "")].as_slice(),
-                            DerefTy::Path,
-                        ),
-                        Some(sym::Cow) if mutability == Mutability::Not => {
-                            if let Some((lifetime, ty)) = name.args
-                                .and_then(|args| {
-                                    if let [GenericArg::Lifetime(lifetime), ty] = args.args {
-                                        return Some((lifetime, ty));
-                                    }
+                let emission_id = params.get(i).map_or(hir_ty.hir_id, |param| param.hir_id);
+                let (method_renames, deref_ty) = match cx.tcx.get_diagnostic_name(adt.did()) {
+                    Some(sym::Vec) => (
+                        [("clone", ".to_owned()")].as_slice(),
+                        DerefTy::Slice(
+                            name.args.and_then(|args| args.args.first()).and_then(|arg| {
+                                if let GenericArg::Type(ty) = arg {
+                                    Some(ty.span)
+                                } else {
                                     None
-                                })
-                            {
-                                if !lifetime.is_anonymous()
-                                    && fn_sig.output()
-                                        .walk()
-                                        .filter_map(|arg| {
-                                            arg.as_region().and_then(|lifetime| {
-                                                match lifetime.kind() {
-                                                    ty::ReEarlyBound(r) => Some(r.def_id),
-                                                    ty::ReLateBound(_, r) => r.kind.get_id(),
-                                                    ty::ReFree(r) => r.bound_region.get_id(),
-                                                    ty::ReStatic
-                                                    | ty::ReVar(_)
-                                                    | ty::RePlaceholder(_)
-                                                    | ty::ReErased
-                                                    | ty::ReError(_) => None,
-                                                }
-                                            })
-                                        })
-                                        .any(|def_id| {
-                                            matches!(
-                                                lifetime.res,
-                                                LifetimeName::Param(param_def_id) if def_id
-                                                    .as_local()
-                                                    .is_some_and(|def_id| def_id == param_def_id),
-                                            )
-                                        })
-                                {
-                                    // `&Cow<'a, T>` when the return type uses 'a is okay
-                                    return None;
                                 }
-
-                                let ty_name =
-                                    snippet_opt(cx, ty.span()).unwrap_or_else(|| args.type_at(1).to_string());
-
-                                span_lint_hir_and_then(
-                                    cx,
-                                    PTR_ARG,
-                                    emission_id,
-                                    hir_ty.span,
-                                    "using a reference to `Cow` is not recommended",
-                                    |diag| {
-                                        diag.span_suggestion(
-                                            hir_ty.span,
-                                            "change this to",
-                                            format!("&{}{ty_name}", mutability.prefix_str()),
-                                            Applicability::Unspecified,
-                                        );
-                                    }
-                                );
+                            }),
+                            args.type_at(0),
+                        ),
+                    ),
+                    _ if Some(adt.did()) == cx.tcx.lang_items().string() => {
+                        ([("clone", ".to_owned()"), ("as_str", "")].as_slice(), DerefTy::Str)
+                    },
+                    Some(sym::PathBuf) => ([("clone", ".to_path_buf()"), ("as_path", "")].as_slice(), DerefTy::Path),
+                    Some(sym::Cow) if mutability == Mutability::Not => {
+                        if let Some((lifetime, ty)) = name.args.and_then(|args| {
+                            if let [GenericArg::Lifetime(lifetime), ty] = args.args {
+                                return Some((lifetime, ty));
+                            }
+                            None
+                        }) {
+                            if !lifetime.is_anonymous()
+                                && fn_sig
+                                    .output()
+                                    .walk()
+                                    .filter_map(|arg| {
+                                        arg.as_region().and_then(|lifetime| match lifetime.kind() {
+                                            ty::ReEarlyBound(r) => Some(r.def_id),
+                                            ty::ReLateBound(_, r) => r.kind.get_id(),
+                                            ty::ReFree(r) => r.bound_region.get_id(),
+                                            ty::ReStatic
+                                            | ty::ReVar(_)
+                                            | ty::RePlaceholder(_)
+                                            | ty::ReErased
+                                            | ty::ReError(_) => None,
+                                        })
+                                    })
+                                    .any(|def_id| {
+                                        matches!(
+                                            lifetime.res,
+                                            LifetimeName::Param(param_def_id) if def_id
+                                                .as_local()
+                                                .is_some_and(|def_id| def_id == param_def_id),
+                                        )
+                                    })
+                            {
+                                // `&Cow<'a, T>` when the return type uses 'a is okay
+                                return None;
                             }
-                            return None;
-                        },
-                        _ => return None,
-                    };
-                    return Some(PtrArg {
-                        idx: i,
-                        emission_id,
-                        span: hir_ty.span,
-                        ty_did: adt.did(),
-                        ty_name: name.ident.name,
-                        method_renames,
-                        ref_prefix: RefPrefix {
-                            lt: *lt,
-                            mutability,
-                        },
-                        deref_ty,
-                    });
+
+                            let ty_name = snippet_opt(cx, ty.span()).unwrap_or_else(|| args.type_at(1).to_string());
+
+                            span_lint_hir_and_then(
+                                cx,
+                                PTR_ARG,
+                                emission_id,
+                                hir_ty.span,
+                                "using a reference to `Cow` is not recommended",
+                                |diag| {
+                                    diag.span_suggestion(
+                                        hir_ty.span,
+                                        "change this to",
+                                        format!("&{}{ty_name}", mutability.prefix_str()),
+                                        Applicability::Unspecified,
+                                    );
+                                },
+                            );
+                        }
+                        return None;
+                    },
+                    _ => return None,
+                };
+                return Some(PtrArg {
+                    idx: i,
+                    emission_id,
+                    span: hir_ty.span,
+                    ty_did: adt.did(),
+                    ty_name: name.ident.name,
+                    method_renames,
+                    ref_prefix: RefPrefix { lt: *lt, mutability },
+                    deref_ty,
+                });
             }
             None
         })
diff --git a/clippy_lints/src/pub_use.rs b/clippy_lints/src/pub_use.rs
index a967b19b838..316a72988aa 100644
--- a/clippy_lints/src/pub_use.rs
+++ b/clippy_lints/src/pub_use.rs
@@ -41,16 +41,17 @@ declare_lint_pass!(PubUse => [PUB_USE]);
 
 impl EarlyLintPass for PubUse {
     fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {
-        if let ItemKind::Use(_) = item.kind &&
-            let VisibilityKind::Public = item.vis.kind {
-                span_lint_and_help(
-                    cx,
-                    PUB_USE,
-                    item.span,
-                    "using `pub use`",
-                    None,
-                    "move the exported item to a public module instead",
-                );
-            }
+        if let ItemKind::Use(_) = item.kind
+            && let VisibilityKind::Public = item.vis.kind
+        {
+            span_lint_and_help(
+                cx,
+                PUB_USE,
+                item.span,
+                "using `pub use`",
+                None,
+                "move the exported item to a public module instead",
+            );
+        }
     }
 }
diff --git a/clippy_lints/src/question_mark.rs b/clippy_lints/src/question_mark.rs
index 4305792873c..b133635e883 100644
--- a/clippy_lints/src/question_mark.rs
+++ b/clippy_lints/src/question_mark.rs
@@ -98,16 +98,23 @@ enum IfBlockType<'hir> {
 }
 
 fn check_let_some_else_return_none(cx: &LateContext<'_>, stmt: &Stmt<'_>) {
-    if let StmtKind::Local(Local { pat, init: Some(init_expr), els: Some(els), .. }) = stmt.kind &&
-        let Block { stmts: &[], expr: Some(els), .. } = els &&
-        let Some(inner_pat) = pat_and_expr_can_be_question_mark(cx, pat, els)
+    if let StmtKind::Local(Local {
+        pat,
+        init: Some(init_expr),
+        els: Some(els),
+        ..
+    }) = stmt.kind
+        && let Block {
+            stmts: &[],
+            expr: Some(els),
+            ..
+        } = els
+        && let Some(inner_pat) = pat_and_expr_can_be_question_mark(cx, pat, els)
     {
         let mut applicability = Applicability::MaybeIncorrect;
         let init_expr_str = snippet_with_applicability(cx, init_expr.span, "..", &mut applicability);
         let receiver_str = snippet_with_applicability(cx, inner_pat.span, "..", &mut applicability);
-        let sugg = format!(
-            "let {receiver_str} = {init_expr_str}?;",
-        );
+        let sugg = format!("let {receiver_str} = {init_expr_str}?;",);
         span_lint_and_sugg(
             cx,
             QUESTION_MARK,
diff --git a/clippy_lints/src/read_zero_byte_vec.rs b/clippy_lints/src/read_zero_byte_vec.rs
index 9405b49665e..b27d4cc6e4f 100644
--- a/clippy_lints/src/read_zero_byte_vec.rs
+++ b/clippy_lints/src/read_zero_byte_vec.rs
@@ -59,7 +59,10 @@ impl<'tcx> LateLintPass<'tcx> for ReadZeroByteVec {
             {
                 let visitor = |expr: &Expr<'_>| {
                     if let ExprKind::MethodCall(path, _, [arg], _) = expr.kind
-                        && let PathSegment { ident: read_or_read_exact, .. } = *path
+                        && let PathSegment {
+                            ident: read_or_read_exact,
+                            ..
+                        } = *path
                         && matches!(read_or_read_exact.as_str(), "read" | "read_exact")
                         && let ExprKind::AddrOf(_, hir::Mutability::Mut, inner) = arg.kind
                         && let ExprKind::Path(QPath::Resolved(None, inner_path)) = inner.kind
@@ -72,15 +75,14 @@ impl<'tcx> LateLintPass<'tcx> for ReadZeroByteVec {
                     }
                 };
 
-                let (read_found, next_stmt_span) =
-                if let Some(next_stmt) = block.stmts.get(idx + 1) {
+                let (read_found, next_stmt_span) = if let Some(next_stmt) = block.stmts.get(idx + 1) {
                     // case { .. stmt; stmt; .. }
                     (for_each_expr(next_stmt, visitor).is_some(), next_stmt.span)
                 } else if let Some(e) = block.expr {
                     // case { .. stmt; expr }
                     (for_each_expr(e, visitor).is_some(), e.span)
                 } else {
-                    return
+                    return;
                 };
 
                 if read_found && !next_stmt_span.from_expansion() {
@@ -93,13 +95,14 @@ impl<'tcx> LateLintPass<'tcx> for ReadZeroByteVec {
                                 next_stmt_span,
                                 "reading zero byte data to `Vec`",
                                 "try",
-                                format!("{}.resize({len}, 0); {}",
+                                format!(
+                                    "{}.resize({len}, 0); {}",
                                     ident.as_str(),
                                     snippet(cx, next_stmt_span, "..")
                                 ),
                                 applicability,
                             );
-                        }
+                        },
                         VecInitKind::WithExprCapacity(hir_id) => {
                             let e = cx.tcx.hir().expect_expr(hir_id);
                             span_lint_and_sugg(
@@ -108,14 +111,15 @@ impl<'tcx> LateLintPass<'tcx> for ReadZeroByteVec {
                                 next_stmt_span,
                                 "reading zero byte data to `Vec`",
                                 "try",
-                                format!("{}.resize({}, 0); {}",
+                                format!(
+                                    "{}.resize({}, 0); {}",
                                     ident.as_str(),
                                     snippet(cx, e.span, ".."),
                                     snippet(cx, next_stmt_span, "..")
                                 ),
                                 applicability,
                             );
-                        }
+                        },
                         _ => {
                             span_lint(
                                 cx,
@@ -123,8 +127,7 @@ impl<'tcx> LateLintPass<'tcx> for ReadZeroByteVec {
                                 next_stmt_span,
                                 "reading zero byte data to `Vec`",
                             );
-
-                        }
+                        },
                     }
                 }
             }
diff --git a/clippy_lints/src/redundant_async_block.rs b/clippy_lints/src/redundant_async_block.rs
index 8dfc849bff9..90297ca8bb6 100644
--- a/clippy_lints/src/redundant_async_block.rs
+++ b/clippy_lints/src/redundant_async_block.rs
@@ -5,7 +5,7 @@ use clippy_utils::peel_blocks;
 use clippy_utils::source::{snippet, walk_span_to_context};
 use clippy_utils::visitors::for_each_expr;
 use rustc_errors::Applicability;
-use rustc_hir::{CoroutineSource, Closure, CoroutineKind, Expr, ExprKind, MatchSource};
+use rustc_hir::{Closure, CoroutineKind, CoroutineSource, Expr, ExprKind, MatchSource};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::UpvarCapture;
@@ -69,12 +69,11 @@ impl<'tcx> LateLintPass<'tcx> for RedundantAsyncBlock {
 /// If `expr` is a desugared `async` block, return the original expression if it does not capture
 /// any variable by ref.
 fn desugar_async_block<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<&'tcx Expr<'tcx>> {
-    if let ExprKind::Closure(Closure { body, def_id, .. }) = expr.kind &&
-        let body = cx.tcx.hir().body(*body) &&
-        matches!(body.coroutine_kind, Some(CoroutineKind::Async(CoroutineSource::Block)))
+    if let ExprKind::Closure(Closure { body, def_id, .. }) = expr.kind
+        && let body = cx.tcx.hir().body(*body)
+        && matches!(body.coroutine_kind, Some(CoroutineKind::Async(CoroutineSource::Block)))
     {
-        cx
-            .typeck_results()
+        cx.typeck_results()
             .closure_min_captures
             .get(def_id)
             .map_or(true, |m| {
@@ -93,12 +92,13 @@ fn desugar_async_block<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Op
 /// If `expr` is a desugared `.await`, return the original expression if it does not come from a
 /// macro expansion.
 fn desugar_await<'tcx>(expr: &'tcx Expr<'_>) -> Option<&'tcx Expr<'tcx>> {
-    if let ExprKind::Match(match_value, _, MatchSource::AwaitDesugar) = expr.kind &&
-        let ExprKind::Call(_, [into_future_arg]) = match_value.kind &&
-        let ctxt = expr.span.ctxt() &&
-        for_each_expr(into_future_arg, |e|
-            walk_span_to_context(e.span, ctxt)
-                .map_or(ControlFlow::Break(()), |_| ControlFlow::Continue(()))).is_none()
+    if let ExprKind::Match(match_value, _, MatchSource::AwaitDesugar) = expr.kind
+        && let ExprKind::Call(_, [into_future_arg]) = match_value.kind
+        && let ctxt = expr.span.ctxt()
+        && for_each_expr(into_future_arg, |e| {
+            walk_span_to_context(e.span, ctxt).map_or(ControlFlow::Break(()), |_| ControlFlow::Continue(()))
+        })
+        .is_none()
     {
         Some(into_future_arg)
     } else {
diff --git a/clippy_lints/src/redundant_closure_call.rs b/clippy_lints/src/redundant_closure_call.rs
index be57ed05e78..e679fab5323 100644
--- a/clippy_lints/src/redundant_closure_call.rs
+++ b/clippy_lints/src/redundant_closure_call.rs
@@ -98,11 +98,15 @@ fn find_innermost_closure<'tcx>(
         && steps > 0
     {
         expr = body.value;
-        data = Some((body.value, closure.fn_decl, if is_async_closure(body) {
-            ty::Asyncness::Yes
-        } else {
-            ty::Asyncness::No
-        }));
+        data = Some((
+            body.value,
+            closure.fn_decl,
+            if is_async_closure(body) {
+                ty::Asyncness::Yes
+            } else {
+                ty::Asyncness::No
+            },
+        ));
         steps -= 1;
     }
 
@@ -154,7 +158,8 @@ impl<'tcx> LateLintPass<'tcx> for RedundantClosureCall {
                 |diag| {
                     if fn_decl.inputs.is_empty() {
                         let mut applicability = Applicability::MachineApplicable;
-                        let mut hint = Sugg::hir_with_context(cx, body, full_expr.span.ctxt(), "..", &mut applicability);
+                        let mut hint =
+                            Sugg::hir_with_context(cx, body, full_expr.span.ctxt(), "..", &mut applicability);
 
                         if coroutine_kind.is_async()
                             && let hir::ExprKind::Closure(closure) = body.kind
@@ -173,10 +178,10 @@ impl<'tcx> LateLintPass<'tcx> for RedundantClosureCall {
                             full_expr.span,
                             "try doing something like",
                             hint.maybe_par(),
-                            applicability
+                            applicability,
                         );
                     }
-                }
+                },
             );
         }
     }
diff --git a/clippy_lints/src/redundant_type_annotations.rs b/clippy_lints/src/redundant_type_annotations.rs
index 5a3bee1caad..f6af9cac3de 100644
--- a/clippy_lints/src/redundant_type_annotations.rs
+++ b/clippy_lints/src/redundant_type_annotations.rs
@@ -145,8 +145,8 @@ impl LateLintPass<'_> for RedundantTypeAnnotations {
                 hir::ExprKind::Call(init_call, _) => {
                     if let hir::TyKind::Path(ty_path) = &ty.kind
                         && let hir::QPath::Resolved(_, resolved_path_ty) = ty_path
-
-                        && is_redundant_in_func_call(cx, resolved_path_ty.res, init_call) {
+                        && is_redundant_in_func_call(cx, resolved_path_ty.res, init_call)
+                    {
                         span_lint(cx, REDUNDANT_TYPE_ANNOTATIONS, local.span, "redundant type annotation");
                     }
                 },
@@ -164,11 +164,11 @@ impl LateLintPass<'_> for RedundantTypeAnnotations {
                         && let hir::QPath::Resolved(_, resolved_path_ty) = ty_path
                         && let Some(func_ty) = func_hir_id_to_func_ty(cx, init.hir_id)
                         && let Some(return_type) = func_ty_to_return_type(cx, func_ty)
-                        && is_same_type(cx, resolved_path_ty.res, if is_ref {
-                            return_type.peel_refs()
-                        } else {
-                            return_type
-                        })
+                        && is_same_type(
+                            cx,
+                            resolved_path_ty.res,
+                            if is_ref { return_type.peel_refs() } else { return_type },
+                        )
                     {
                         span_lint(cx, REDUNDANT_TYPE_ANNOTATIONS, local.span, "redundant type annotation");
                     }
@@ -177,10 +177,8 @@ impl LateLintPass<'_> for RedundantTypeAnnotations {
                 hir::ExprKind::Path(init_path) => {
                     // TODO: check for non primty
                     if let Some(primty) = extract_primty(&ty.kind)
-
                         && let hir::QPath::TypeRelative(init_ty, _) = init_path
                         && let Some(primty_init) = extract_primty(&init_ty.kind)
-
                         && primty == primty_init
                     {
                         span_lint(cx, REDUNDANT_TYPE_ANNOTATIONS, local.span, "redundant type annotation");
@@ -205,8 +203,8 @@ impl LateLintPass<'_> for RedundantTypeAnnotations {
                         },
                         LitKind::Err => (),
                     }
-                }
-                _ => ()
+                },
+                _ => (),
             }
         };
     }
diff --git a/clippy_lints/src/ref_patterns.rs b/clippy_lints/src/ref_patterns.rs
index ce4ca7b06e9..8b3dabde9be 100644
--- a/clippy_lints/src/ref_patterns.rs
+++ b/clippy_lints/src/ref_patterns.rs
@@ -29,7 +29,7 @@ declare_lint_pass!(RefPatterns => [REF_PATTERNS]);
 impl EarlyLintPass for RefPatterns {
     fn check_pat(&mut self, cx: &EarlyContext<'_>, pat: &Pat) {
         if let PatKind::Ident(BindingAnnotation::REF, _, _) = pat.kind
-                && !pat.span.from_expansion()
+            && !pat.span.from_expansion()
         {
             span_lint_and_help(
                 cx,
diff --git a/clippy_lints/src/reserve_after_initialization.rs b/clippy_lints/src/reserve_after_initialization.rs
index c2294303082..1975946c6e6 100644
--- a/clippy_lints/src/reserve_after_initialization.rs
+++ b/clippy_lints/src/reserve_after_initialization.rs
@@ -74,15 +74,24 @@ impl<'tcx> LateLintPass<'tcx> for ReserveAfterInitialization {
             && let PatKind::Binding(BindingAnnotation::MUT, id, _, None) = local.pat.kind
             && !in_external_macro(cx.sess(), local.span)
             && let Some(init) = get_vec_init_kind(cx, init_expr)
-            && !matches!(init, VecInitKind::WithExprCapacity(_) | VecInitKind::WithConstCapacity(_))
+            && !matches!(
+                init,
+                VecInitKind::WithExprCapacity(_) | VecInitKind::WithConstCapacity(_)
+            )
         {
             self.searcher = Some(VecReserveSearcher {
                 local_id: id,
                 err_span: local.span,
-                init_part: snippet(cx, local.span.shrink_to_lo()
-                    .to(init_expr.span.source_callsite().shrink_to_lo()), "..")
-                    .into_owned(),
-                space_hint: String::new()
+                init_part: snippet(
+                    cx,
+                    local
+                        .span
+                        .shrink_to_lo()
+                        .to(init_expr.span.source_callsite().shrink_to_lo()),
+                    "..",
+                )
+                .into_owned(),
+                space_hint: String::new(),
             });
         }
     }
@@ -94,15 +103,21 @@ impl<'tcx> LateLintPass<'tcx> for ReserveAfterInitialization {
             && let Res::Local(id) = path.res
             && !in_external_macro(cx.sess(), expr.span)
             && let Some(init) = get_vec_init_kind(cx, right)
-            && !matches!(init, VecInitKind::WithExprCapacity(_) | VecInitKind::WithConstCapacity(_))
+            && !matches!(
+                init,
+                VecInitKind::WithExprCapacity(_) | VecInitKind::WithConstCapacity(_)
+            )
         {
             self.searcher = Some(VecReserveSearcher {
                 local_id: id,
                 err_span: expr.span,
-                init_part: snippet(cx, left.span.shrink_to_lo()
-                    .to(right.span.source_callsite().shrink_to_lo()), "..")
-                    .into_owned(), // see `assign_expression` test
-                space_hint: String::new()
+                init_part: snippet(
+                    cx,
+                    left.span.shrink_to_lo().to(right.span.source_callsite().shrink_to_lo()),
+                    "..",
+                )
+                .into_owned(), // see `assign_expression` test
+                space_hint: String::new(),
             });
         }
     }
@@ -118,7 +133,7 @@ impl<'tcx> LateLintPass<'tcx> for ReserveAfterInitialization {
                 self.searcher = Some(VecReserveSearcher {
                     err_span: searcher.err_span.to(stmt.span),
                     space_hint: snippet(cx, space_hint.span, "..").into_owned(),
-                    .. searcher
+                    ..searcher
                 });
             } else {
                 searcher.display_err(cx);
diff --git a/clippy_lints/src/same_name_method.rs b/clippy_lints/src/same_name_method.rs
index d7fd3163801..9587326ca00 100644
--- a/clippy_lints/src/same_name_method.rs
+++ b/clippy_lints/src/same_name_method.rs
@@ -120,9 +120,10 @@ impl<'tcx> LateLintPass<'tcx> for SameNameMethod {
                             }
                         };
 
-                        for impl_item_ref in (*items).iter().filter(|impl_item_ref| {
-                            matches!(impl_item_ref.kind, rustc_hir::AssocItemKind::Fn { .. })
-                        }) {
+                        for impl_item_ref in (*items)
+                            .iter()
+                            .filter(|impl_item_ref| matches!(impl_item_ref.kind, rustc_hir::AssocItemKind::Fn { .. }))
+                        {
                             let method_name = impl_item_ref.ident.name;
                             methods_in_trait.remove(&method_name);
                             check_trait_method(method_name, impl_item_ref.span);
@@ -133,9 +134,10 @@ impl<'tcx> LateLintPass<'tcx> for SameNameMethod {
                         }
                     },
                     None => {
-                        for impl_item_ref in (*items).iter().filter(|impl_item_ref| {
-                            matches!(impl_item_ref.kind, rustc_hir::AssocItemKind::Fn { .. })
-                        }) {
+                        for impl_item_ref in (*items)
+                            .iter()
+                            .filter(|impl_item_ref| matches!(impl_item_ref.kind, rustc_hir::AssocItemKind::Fn { .. }))
+                        {
                             let method_name = impl_item_ref.ident.name;
                             let impl_span = impl_item_ref.span;
                             let hir_id = impl_item_ref.id.hir_id();
diff --git a/clippy_lints/src/significant_drop_tightening.rs b/clippy_lints/src/significant_drop_tightening.rs
index 4b248c9c790..57bcee1a871 100644
--- a/clippy_lints/src/significant_drop_tightening.rs
+++ b/clippy_lints/src/significant_drop_tightening.rs
@@ -236,9 +236,13 @@ impl<'ap, 'lc, 'others, 'stmt, 'tcx> StmtsChecker<'ap, 'lc, 'others, 'stmt, 'tcx
     fn manage_has_expensive_expr_after_last_attr(&mut self) {
         let has_expensive_stmt = match self.ap.curr_stmt.kind {
             hir::StmtKind::Expr(expr) if is_inexpensive_expr(expr) => false,
-            hir::StmtKind::Local(local) if let Some(expr) = local.init
-                && let hir::ExprKind::Path(_) = expr.kind => false,
-            _ => true
+            hir::StmtKind::Local(local)
+                if let Some(expr) = local.init
+                    && let hir::ExprKind::Path(_) = expr.kind =>
+            {
+                false
+            },
+            _ => true,
         };
         if has_expensive_stmt {
             for apa in self.ap.apas.values_mut() {
@@ -292,8 +296,7 @@ impl<'ap, 'lc, 'others, 'stmt, 'tcx> Visitor<'tcx> for StmtsChecker<'ap, 'lc, 'o
                 && {
                     if let Some(local_hir_id) = path_to_local(expr) {
                         local_hir_id == hir_id
-                    }
-                    else {
+                    } else {
                         true
                     }
                 }
@@ -306,8 +309,7 @@ impl<'ap, 'lc, 'others, 'stmt, 'tcx> Visitor<'tcx> for StmtsChecker<'ap, 'lc, 'o
                         let expr_or_init = expr_or_init(self.cx, expr);
                         if let hir::ExprKind::MethodCall(_, local_expr, _, span) = expr_or_init.kind {
                             local_expr.span.to(span)
-                        }
-                        else {
+                        } else {
                             expr_or_init.span
                         }
                     },
@@ -317,8 +319,12 @@ impl<'ap, 'lc, 'others, 'stmt, 'tcx> Visitor<'tcx> for StmtsChecker<'ap, 'lc, 'o
                 modify_apa_params(&mut apa);
                 let _ = self.ap.apas.insert(hir_id, apa);
             } else {
-                let Some(hir_id) = path_to_local(expr) else { return; };
-                let Some(apa) = self.ap.apas.get_mut(&hir_id) else { return; };
+                let Some(hir_id) = path_to_local(expr) else {
+                    return;
+                };
+                let Some(apa) = self.ap.apas.get_mut(&hir_id) else {
+                    return;
+                };
                 match self.ap.curr_stmt.kind {
                     hir::StmtKind::Local(local) => {
                         if let hir::PatKind::Binding(_, _, ident, _) = local.pat.kind {
@@ -437,19 +443,20 @@ fn has_drop(expr: &hir::Expr<'_>, first_bind_ident: &Ident, lcx: &LateContext<'_
     {
         let has_ident = |local_expr: &hir::Expr<'_>| {
             if let hir::ExprKind::Path(hir::QPath::Resolved(_, arg_path)) = &local_expr.kind
-                && let [first_arg_ps, .. ] = arg_path.segments
+                && let [first_arg_ps, ..] = arg_path.segments
                 && &first_arg_ps.ident == first_bind_ident
             {
                 true
-            }
-            else {
+            } else {
                 false
             }
         };
         if has_ident(first_arg) {
             return true;
         }
-        if let hir::ExprKind::Tup(value) = &first_arg.kind && value.iter().any(has_ident) {
+        if let hir::ExprKind::Tup(value) = &first_arg.kind
+            && value.iter().any(has_ident)
+        {
             return true;
         }
     }
diff --git a/clippy_lints/src/std_instead_of_core.rs b/clippy_lints/src/std_instead_of_core.rs
index a50ba0c0c7e..d07a44770cc 100644
--- a/clippy_lints/src/std_instead_of_core.rs
+++ b/clippy_lints/src/std_instead_of_core.rs
@@ -106,16 +106,8 @@ impl<'tcx> LateLintPass<'tcx> for StdReexports {
         {
             let (lint, used_mod, replace_with) = match first_segment.ident.name {
                 sym::std => match cx.tcx.crate_name(def_id.krate) {
-                    sym::core => (
-                        STD_INSTEAD_OF_CORE,
-                        "std",
-                        "core",
-                    ),
-                    sym::alloc => (
-                        STD_INSTEAD_OF_ALLOC,
-                        "std",
-                        "alloc",
-                    ),
+                    sym::core => (STD_INSTEAD_OF_CORE, "std", "core"),
+                    sym::alloc => (STD_INSTEAD_OF_ALLOC, "std", "alloc"),
                     _ => {
                         self.prev_span = path.span;
                         return;
@@ -123,11 +115,7 @@ impl<'tcx> LateLintPass<'tcx> for StdReexports {
                 },
                 sym::alloc => {
                     if cx.tcx.crate_name(def_id.krate) == sym::core {
-                        (
-                            ALLOC_INSTEAD_OF_CORE,
-                            "alloc",
-                            "core",
-                        )
+                        (ALLOC_INSTEAD_OF_CORE, "alloc", "core")
                     } else {
                         self.prev_span = path.span;
                         return;
@@ -143,7 +131,8 @@ impl<'tcx> LateLintPass<'tcx> for StdReexports {
                     &format!("used import from `{used_mod}` instead of `{replace_with}`"),
                     &format!("consider importing the item from `{replace_with}`"),
                     replace_with.to_string(),
-                    Applicability::MachineApplicable);
+                    Applicability::MachineApplicable,
+                );
                 self.prev_span = path.span;
             }
         }
diff --git a/clippy_lints/src/suspicious_xor_used_as_pow.rs b/clippy_lints/src/suspicious_xor_used_as_pow.rs
index 42cf034f22a..4340c23f830 100644
--- a/clippy_lints/src/suspicious_xor_used_as_pow.rs
+++ b/clippy_lints/src/suspicious_xor_used_as_pow.rs
@@ -38,21 +38,18 @@ impl LateLintPass<'_> for ConfusingXorAndPow {
             && let ExprKind::Lit(lit_right) = &right.kind
             && matches!(lit_right.node, LitKind::Int(..) | LitKind::Float(..))
             && matches!(lit_left.node, LitKind::Int(..) | LitKind::Float(..))
-            && NumericLiteral::from_lit_kind(&snippet(cx, lit_right.span, ".."), &lit_right.node).is_some_and(|x| x.is_decimal())
-            {
-                span_lint_and_sugg(
-                    cx,
-                    SUSPICIOUS_XOR_USED_AS_POW,
-                    expr.span,
-                    "`^` is not the exponentiation operator",
-                    "did you mean to write",
-                    format!(
-                        "{}.pow({})",
-                        lit_left.node,
-                        lit_right.node
-                    ),
-                    Applicability::MaybeIncorrect,
-                );
-		}
+            && NumericLiteral::from_lit_kind(&snippet(cx, lit_right.span, ".."), &lit_right.node)
+                .is_some_and(|x| x.is_decimal())
+        {
+            span_lint_and_sugg(
+                cx,
+                SUSPICIOUS_XOR_USED_AS_POW,
+                expr.span,
+                "`^` is not the exponentiation operator",
+                "did you mean to write",
+                format!("{}.pow({})", lit_left.node, lit_right.node),
+                Applicability::MaybeIncorrect,
+            );
+        }
     }
 }
diff --git a/clippy_lints/src/swap.rs b/clippy_lints/src/swap.rs
index b24252a90d9..660e6835e46 100644
--- a/clippy_lints/src/swap.rs
+++ b/clippy_lints/src/swap.rs
@@ -232,7 +232,7 @@ fn is_same(cx: &LateContext<'_>, lhs: ExprOrIdent<'_>, rhs: &Expr<'_>) -> bool {
             } else {
                 false
             }
-        }
+        },
     }
 }
 
diff --git a/clippy_lints/src/swap_ptr_to_ref.rs b/clippy_lints/src/swap_ptr_to_ref.rs
index 1667b74da7f..6a6c94425d1 100644
--- a/clippy_lints/src/swap_ptr_to_ref.rs
+++ b/clippy_lints/src/swap_ptr_to_ref.rs
@@ -58,9 +58,14 @@ impl LateLintPass<'_> for SwapPtrToRef {
                         let mut app = Applicability::MachineApplicable;
                         let snip1 = snippet_with_context(cx, arg1_span.unwrap_or(arg1.span), ctxt, "..", &mut app).0;
                         let snip2 = snippet_with_context(cx, arg2_span.unwrap_or(arg2.span), ctxt, "..", &mut app).0;
-                        diag.span_suggestion(e.span, "use ptr::swap", format!("core::ptr::swap({snip1}, {snip2})"), app);
+                        diag.span_suggestion(
+                            e.span,
+                            "use ptr::swap",
+                            format!("core::ptr::swap({snip1}, {snip2})"),
+                            app,
+                        );
                     }
-                }
+                },
             );
         }
     }
@@ -73,7 +78,10 @@ fn is_ptr_to_ref(cx: &LateContext<'_>, e: &Expr<'_>, ctxt: SyntaxContext) -> (bo
         && let ExprKind::Unary(UnOp::Deref, derefed_expr) = borrowed_expr.kind
         && cx.typeck_results().expr_ty(derefed_expr).is_unsafe_ptr()
     {
-        (true, (borrowed_expr.span.ctxt() == ctxt || derefed_expr.span.ctxt() == ctxt).then_some(derefed_expr.span))
+        (
+            true,
+            (borrowed_expr.span.ctxt() == ctxt || derefed_expr.span.ctxt() == ctxt).then_some(derefed_expr.span),
+        )
     } else {
         (false, None)
     }
diff --git a/clippy_lints/src/transmute/transmute_undefined_repr.rs b/clippy_lints/src/transmute/transmute_undefined_repr.rs
index c61eb0a9311..7c2223ca3ab 100644
--- a/clippy_lints/src/transmute/transmute_undefined_repr.rs
+++ b/clippy_lints/src/transmute/transmute_undefined_repr.rs
@@ -98,17 +98,17 @@ pub(super) fn check<'tcx>(
             },
 
             (ReducedTy::UnorderedFields(from_ty), ReducedTy::UnorderedFields(to_ty)) if from_ty != to_ty => {
-                let same_adt_did = if let (ty::Adt(from_def, from_subs), ty::Adt(to_def, to_subs))
-                        = (from_ty.kind(), to_ty.kind())
-                        && from_def == to_def
-                    {
-                        if same_except_params(from_subs, to_subs) {
-                            return false;
-                        }
-                        Some(from_def.did())
-                    } else {
-                        None
-                    };
+                let same_adt_did = if let (ty::Adt(from_def, from_subs), ty::Adt(to_def, to_subs)) =
+                    (from_ty.kind(), to_ty.kind())
+                    && from_def == to_def
+                {
+                    if same_except_params(from_subs, to_subs) {
+                        return false;
+                    }
+                    Some(from_def.did())
+                } else {
+                    None
+                };
                 span_lint_and_then(
                     cx,
                     TRANSMUTE_UNDEFINED_REPR,
diff --git a/clippy_lints/src/transmute/transmuting_null.rs b/clippy_lints/src/transmute/transmuting_null.rs
index 770914e99e1..471bd44b5d5 100644
--- a/clippy_lints/src/transmute/transmuting_null.rs
+++ b/clippy_lints/src/transmute/transmuting_null.rs
@@ -16,8 +16,8 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, arg: &'t
     }
 
     // Catching transmute over constants that resolve to `null`.
-    if let ExprKind::Path(ref _qpath) = arg.kind &&
-        let Some(Constant::RawPtr(0)) = constant(cx, cx.typeck_results(), arg)
+    if let ExprKind::Path(ref _qpath) = arg.kind
+        && let Some(Constant::RawPtr(0)) = constant(cx, cx.typeck_results(), arg)
     {
         span_lint(cx, TRANSMUTING_NULL, expr.span, LINT_MSG);
         return true;
@@ -25,15 +25,17 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, arg: &'t
 
     // Catching:
     // `std::mem::transmute(0 as *const i32)`
-    if let ExprKind::Cast(inner_expr, _cast_ty) = arg.kind && is_integer_literal(inner_expr, 0) {
+    if let ExprKind::Cast(inner_expr, _cast_ty) = arg.kind
+        && is_integer_literal(inner_expr, 0)
+    {
         span_lint(cx, TRANSMUTING_NULL, expr.span, LINT_MSG);
         return true;
     }
 
     // Catching:
     // `std::mem::transmute(std::ptr::null::<i32>())`
-    if let ExprKind::Call(func1, []) = arg.kind &&
-        is_path_diagnostic_item(cx, func1, sym::ptr_null)
+    if let ExprKind::Call(func1, []) = arg.kind
+        && is_path_diagnostic_item(cx, func1, sym::ptr_null)
     {
         span_lint(cx, TRANSMUTING_NULL, expr.span, LINT_MSG);
         return true;
diff --git a/clippy_lints/src/undocumented_unsafe_blocks.rs b/clippy_lints/src/undocumented_unsafe_blocks.rs
index 4d0b548d0a2..32aebdd8c0f 100644
--- a/clippy_lints/src/undocumented_unsafe_blocks.rs
+++ b/clippy_lints/src/undocumented_unsafe_blocks.rs
@@ -638,7 +638,9 @@ fn get_body_search_span(cx: &LateContext<'_>) -> Option<Span> {
 fn span_has_safety_comment(cx: &LateContext<'_>, span: Span) -> bool {
     let source_map = cx.sess().source_map();
     let ctxt = span.ctxt();
-    if ctxt.is_root() && let Some(search_span) = get_body_search_span(cx) {
+    if ctxt.is_root()
+        && let Some(search_span) = get_body_search_span(cx)
+    {
         if let Ok(unsafe_line) = source_map.lookup_line(span.lo())
             && let Some(body_span) = walk_span_to_context(search_span, SyntaxContext::root())
             && let Ok(body_line) = source_map.lookup_line(body_span.lo())
@@ -648,11 +650,13 @@ fn span_has_safety_comment(cx: &LateContext<'_>, span: Span) -> bool {
             // Get the text from the start of function body to the unsafe block.
             //     fn foo() { some_stuff; unsafe { stuff }; other_stuff; }
             //              ^-------------^
-            body_line.line < unsafe_line.line && text_has_safety_comment(
-                src,
-                &unsafe_line.sf.lines()[body_line.line + 1..=unsafe_line.line],
-                unsafe_line.sf.start_pos,
-            ).is_some()
+            body_line.line < unsafe_line.line
+                && text_has_safety_comment(
+                    src,
+                    &unsafe_line.sf.lines()[body_line.line + 1..=unsafe_line.line],
+                    unsafe_line.sf.start_pos,
+                )
+                .is_some()
         } else {
             // Problem getting source text. Pretend a comment was found.
             true
diff --git a/clippy_lints/src/unit_types/let_unit_value.rs b/clippy_lints/src/unit_types/let_unit_value.rs
index e7915953d85..ef67f4b04b5 100644
--- a/clippy_lints/src/unit_types/let_unit_value.rs
+++ b/clippy_lints/src/unit_types/let_unit_value.rs
@@ -24,7 +24,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, local: &'tcx Local<'_>) {
             && expr_needs_inferred_result(cx, init)
         {
             if !matches!(local.pat.kind, PatKind::Wild)
-               && !matches!(local.pat.kind, PatKind::Tuple([], ddpos) if ddpos.as_opt_usize().is_none())
+                && !matches!(local.pat.kind, PatKind::Tuple([], ddpos) if ddpos.as_opt_usize().is_none())
             {
                 span_lint_and_then(
                     cx,
@@ -43,7 +43,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, local: &'tcx Local<'_>) {
             }
         } else {
             if let ExprKind::Match(_, _, MatchSource::AwaitDesugar) = init.kind {
-                return
+                return;
             }
 
             span_lint_and_then(
@@ -55,12 +55,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, local: &'tcx Local<'_>) {
                     if let Some(expr) = &local.init {
                         let mut app = Applicability::MachineApplicable;
                         let snip = snippet_with_context(cx, expr.span, local.span.ctxt(), "()", &mut app).0;
-                        diag.span_suggestion(
-                            local.span,
-                            "omit the `let` binding",
-                            format!("{snip};"),
-                            app,
-                        );
+                        diag.span_suggestion(local.span, "omit the `let` binding", format!("{snip};"), app);
                     }
                 },
             );
diff --git a/clippy_lints/src/unnecessary_map_on_constructor.rs b/clippy_lints/src/unnecessary_map_on_constructor.rs
index b154f75c7ca..9107b2b99b8 100644
--- a/clippy_lints/src/unnecessary_map_on_constructor.rs
+++ b/clippy_lints/src/unnecessary_map_on_constructor.rs
@@ -36,19 +36,20 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryMapOnConstructor {
             return;
         }
         if let hir::ExprKind::MethodCall(path, recv, args, ..) = expr.kind
-            && let Some(sym::Option | sym::Result) = get_type_diagnostic_name(cx, cx.typeck_results().expr_ty(recv)){
-            let (constructor_path, constructor_item) =
-                if let hir::ExprKind::Call(constructor, constructor_args) = recv.kind
-                    && let hir::ExprKind::Path(constructor_path) = constructor.kind
-                    && let Some(arg) = constructor_args.first()
-                {
-                    if constructor.span.from_expansion() || arg.span.from_expansion() {
-                        return;
-                    }
-                    (constructor_path, arg)
-                } else {
+            && let Some(sym::Option | sym::Result) = get_type_diagnostic_name(cx, cx.typeck_results().expr_ty(recv))
+        {
+            let (constructor_path, constructor_item) = if let hir::ExprKind::Call(constructor, constructor_args) =
+                recv.kind
+                && let hir::ExprKind::Path(constructor_path) = constructor.kind
+                && let Some(arg) = constructor_args.first()
+            {
+                if constructor.span.from_expansion() || arg.span.from_expansion() {
                     return;
-                };
+                }
+                (constructor_path, arg)
+            } else {
+                return;
+            };
             let constructor_symbol = match constructor_path {
                 hir::QPath::Resolved(_, path) => {
                     if let Some(path_segment) = path.segments.last() {
@@ -82,7 +83,10 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryMapOnConstructor {
                     cx,
                     UNNECESSARY_MAP_ON_CONSTRUCTOR,
                     expr.span,
-                    &format!("unnecessary {} on constructor {constructor_snippet}(_)", path.ident.name),
+                    &format!(
+                        "unnecessary {} on constructor {constructor_snippet}(_)",
+                        path.ident.name
+                    ),
                     "try",
                     format!("{constructor_snippet}({fun_snippet}({constructor_arg_snippet}))"),
                     applicability,
diff --git a/clippy_lints/src/unnecessary_struct_initialization.rs b/clippy_lints/src/unnecessary_struct_initialization.rs
index b75df0dec9a..c35a2afab48 100644
--- a/clippy_lints/src/unnecessary_struct_initialization.rs
+++ b/clippy_lints/src/unnecessary_struct_initialization.rs
@@ -42,9 +42,9 @@ declare_lint_pass!(UnnecessaryStruct => [UNNECESSARY_STRUCT_INITIALIZATION]);
 impl LateLintPass<'_> for UnnecessaryStruct {
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
         if let ExprKind::Struct(_, &[], Some(base)) = expr.kind {
-            if let Some(parent) = get_parent_expr(cx, expr) &&
-                let parent_ty = cx.typeck_results().expr_ty_adjusted(parent) &&
-                parent_ty.is_any_ptr()
+            if let Some(parent) = get_parent_expr(cx, expr)
+                && let parent_ty = cx.typeck_results().expr_ty_adjusted(parent)
+                && parent_ty.is_any_ptr()
             {
                 if is_copy(cx, cx.typeck_results().expr_ty(expr)) && path_to_local(base).is_some() {
                     // When the type implements `Copy`, a reference to the new struct works on the
@@ -59,9 +59,9 @@ impl LateLintPass<'_> for UnnecessaryStruct {
             }
 
             // TODO: do not propose to replace *XX if XX is not Copy
-            if let ExprKind::Unary(UnOp::Deref, target) = base.kind &&
-                matches!(target.kind, ExprKind::Path(..)) &&
-                !is_copy(cx, cx.typeck_results().expr_ty(expr))
+            if let ExprKind::Unary(UnOp::Deref, target) = base.kind
+                && matches!(target.kind, ExprKind::Path(..))
+                && !is_copy(cx, cx.typeck_results().expr_ty(expr))
             {
                 // `*base` cannot be used instead of the struct in the general case if it is not Copy.
                 return;
@@ -81,8 +81,8 @@ impl LateLintPass<'_> for UnnecessaryStruct {
 }
 
 fn is_mutable(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-    if let Some(hir_id) = path_to_local(expr) &&
-        let Node::Pat(pat) = cx.tcx.hir().get(hir_id)
+    if let Some(hir_id) = path_to_local(expr)
+        && let Node::Pat(pat) = cx.tcx.hir().get(hir_id)
     {
         matches!(pat.kind, PatKind::Binding(BindingAnnotation::MUT, ..))
     } else {
diff --git a/clippy_lints/src/unused_peekable.rs b/clippy_lints/src/unused_peekable.rs
index 66b52dc94c2..0473ecaabeb 100644
--- a/clippy_lints/src/unused_peekable.rs
+++ b/clippy_lints/src/unused_peekable.rs
@@ -85,8 +85,8 @@ impl<'tcx> LateLintPass<'tcx> for UnusedPeekable {
                         ident.span,
                         "`peek` never called on `Peekable` iterator",
                         None,
-                        "consider removing the call to `peekable`"
-                   );
+                        "consider removing the call to `peekable`",
+                    );
                 }
             }
         }
@@ -131,11 +131,7 @@ impl<'tcx> Visitor<'tcx> for PeekableVisitor<'_, 'tcx> {
                             // If the Peekable is passed to a function, stop
                             ExprKind::Call(_, args) => {
                                 if let Some(func_did) = fn_def_id(self.cx, expr)
-                                    && let Some(into_iter_did) = self
-                                        .cx
-                                        .tcx
-                                        .lang_items()
-                                        .into_iter_fn()
+                                    && let Some(into_iter_did) = self.cx.tcx.lang_items().into_iter_fn()
                                     && func_did == into_iter_did
                                 {
                                     // Probably a for loop desugar, stop searching
diff --git a/clippy_lints/src/unused_rounding.rs b/clippy_lints/src/unused_rounding.rs
index de43c5cbae4..fbb36bea068 100644
--- a/clippy_lints/src/unused_rounding.rs
+++ b/clippy_lints/src/unused_rounding.rs
@@ -31,18 +31,21 @@ declare_clippy_lint! {
 declare_lint_pass!(UnusedRounding => [UNUSED_ROUNDING]);
 
 fn is_useless_rounding<'a>(cx: &EarlyContext<'_>, expr: &'a Expr) -> Option<(&'a str, String)> {
-    if let ExprKind::MethodCall(box MethodCall { seg:name_ident, receiver, .. }) = &expr.kind
+    if let ExprKind::MethodCall(box MethodCall {
+        seg: name_ident,
+        receiver,
+        ..
+    }) = &expr.kind
         && let method_name = name_ident.ident.name.as_str()
         && (method_name == "ceil" || method_name == "round" || method_name == "floor")
         && let ExprKind::Lit(token_lit) = &receiver.kind
         && token_lit.is_semantic_float()
-        && let Ok(f) = token_lit.symbol.as_str().replace('_', "").parse::<f64>() {
-            (f.fract() == 0.0).then(||
-                (method_name, snippet(cx, receiver.span, "..").to_string())
-            )
-        } else {
-            None
-        }
+        && let Ok(f) = token_lit.symbol.as_str().replace('_', "").parse::<f64>()
+    {
+        (f.fract() == 0.0).then(|| (method_name, snippet(cx, receiver.span, "..").to_string()))
+    } else {
+        None
+    }
 }
 
 impl EarlyLintPass for UnusedRounding {
diff --git a/clippy_lints/src/useless_conversion.rs b/clippy_lints/src/useless_conversion.rs
index edb5935f606..28f1d487eb5 100644
--- a/clippy_lints/src/useless_conversion.rs
+++ b/clippy_lints/src/useless_conversion.rs
@@ -215,20 +215,19 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
                                     did,
                                     args,
                                     cx.typeck_results().node_args(recv.hir_id),
-                                    MethodOrFunction::Function
+                                    MethodOrFunction::Function,
                                 ))
-                            }
+                            },
                             ExprKind::MethodCall(.., args, _) => {
-                                cx.typeck_results().type_dependent_def_id(parent.hir_id)
-                                    .map(|did| {
-                                        return (
-                                            did,
-                                            args,
-                                            cx.typeck_results().node_args(parent.hir_id),
-                                            MethodOrFunction::Method
-                                        );
-                                    })
-                            }
+                                cx.typeck_results().type_dependent_def_id(parent.hir_id).map(|did| {
+                                    return (
+                                        did,
+                                        args,
+                                        cx.typeck_results().node_args(parent.hir_id),
+                                        MethodOrFunction::Method,
+                                    );
+                                })
+                            },
                             _ => None,
                         };
 
@@ -244,7 +243,7 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
                                 into_iter_did,
                                 cx.typeck_results().expr_ty(into_iter_recv),
                                 param.index,
-                                node_args
+                                node_args,
                             )
                             && self.expn_depth == 0
                         {
@@ -255,26 +254,38 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
 
                             let plural = if depth == 0 { "" } else { "s" };
                             let mut applicability = Applicability::MachineApplicable;
-                            let sugg = snippet_with_applicability(cx, into_iter_recv.span.source_callsite(), "<expr>", &mut applicability).into_owned();
-                            span_lint_and_then(cx, USELESS_CONVERSION, e.span, "explicit call to `.into_iter()` in function argument accepting `IntoIterator`", |diag| {
-                                diag.span_suggestion(
-                                    e.span,
-                                    format!("consider removing the `.into_iter()`{plural}"),
-                                    sugg,
-                                    applicability,
-                                );
-                                diag.span_note(span, "this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`");
-                            });
+                            let sugg = snippet_with_applicability(
+                                cx,
+                                into_iter_recv.span.source_callsite(),
+                                "<expr>",
+                                &mut applicability,
+                            )
+                            .into_owned();
+                            span_lint_and_then(
+                                cx,
+                                USELESS_CONVERSION,
+                                e.span,
+                                "explicit call to `.into_iter()` in function argument accepting `IntoIterator`",
+                                |diag| {
+                                    diag.span_suggestion(
+                                        e.span,
+                                        format!("consider removing the `.into_iter()`{plural}"),
+                                        sugg,
+                                        applicability,
+                                    );
+                                    diag.span_note(span, "this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`");
+                                },
+                            );
 
                             // Early return to avoid linting again with contradicting suggestions
                             return;
                         }
                     }
 
-                    if let Some(id) = path_to_local(recv) &&
-                       let Node::Pat(pat) = cx.tcx.hir().get(id) &&
-                       let PatKind::Binding(ann, ..) = pat.kind &&
-                       ann != BindingAnnotation::MUT
+                    if let Some(id) = path_to_local(recv)
+                        && let Node::Pat(pat) = cx.tcx.hir().get(id)
+                        && let PatKind::Binding(ann, ..) = pat.kind
+                        && ann != BindingAnnotation::MUT
                     {
                         // Do not remove .into_iter() applied to a non-mutable local variable used in
                         // a larger expression context as it would differ in mutability.
diff --git a/clippy_lints/src/utils/internal_lints/lint_without_lint_pass.rs b/clippy_lints/src/utils/internal_lints/lint_without_lint_pass.rs
index bbb5ade8b9f..00e352961bd 100644
--- a/clippy_lints/src/utils/internal_lints/lint_without_lint_pass.rs
+++ b/clippy_lints/src/utils/internal_lints/lint_without_lint_pass.rs
@@ -153,8 +153,9 @@ impl<'tcx> LateLintPass<'tcx> for LintWithoutLintPass {
                 let fields;
                 if is_lint_ref_ty {
                     if let ExprKind::AddrOf(_, _, inner_exp) = expr.kind
-                        && let ExprKind::Struct(_, struct_fields, _) = inner_exp.kind {
-                            fields = struct_fields;
+                        && let ExprKind::Struct(_, struct_fields, _) = inner_exp.kind
+                    {
+                        fields = struct_fields;
                     } else {
                         return;
                     }
diff --git a/clippy_lints/src/utils/internal_lints/unnecessary_def_path.rs b/clippy_lints/src/utils/internal_lints/unnecessary_def_path.rs
index a3acb8f1762..81be04659b9 100644
--- a/clippy_lints/src/utils/internal_lints/unnecessary_def_path.rs
+++ b/clippy_lints/src/utils/internal_lints/unnecessary_def_path.rs
@@ -270,7 +270,8 @@ fn read_mir_alloc_def_path<'tcx>(cx: &LateContext<'tcx>, alloc: &'tcx Allocation
                 if let GlobalAlloc::Memory(alloc) = cx.tcx.global_alloc(alloc) {
                     let alloc = alloc.inner();
                     str::from_utf8(alloc.inspect_with_uninit_and_ptr_outside_interpreter(0..alloc.len()))
-                        .ok().map(ToOwned::to_owned)
+                        .ok()
+                        .map(ToOwned::to_owned)
                 } else {
                     None
                 }
diff --git a/clippy_lints/src/vec.rs b/clippy_lints/src/vec.rs
index 17294450acf..a9dd44afaf7 100644
--- a/clippy_lints/src/vec.rs
+++ b/clippy_lints/src/vec.rs
@@ -110,14 +110,15 @@ impl<'tcx> LateLintPass<'tcx> for UselessVec {
                 } else {
                     ControlFlow::Break(())
                 }
-            }).is_continue();
+            })
+            .is_continue();
 
             if only_slice_uses {
                 self.check_vec_macro(
                     cx,
                     &vec_args,
                     expr.span.ctxt().outer_expn_data().call_site,
-                    SuggestedType::Array
+                    SuggestedType::Array,
                 );
             }
         }
diff --git a/clippy_lints/src/vec_init_then_push.rs b/clippy_lints/src/vec_init_then_push.rs
index eb9bac4210b..c8b9402f1ae 100644
--- a/clippy_lints/src/vec_init_then_push.rs
+++ b/clippy_lints/src/vec_init_then_push.rs
@@ -211,7 +211,7 @@ impl<'tcx> LateLintPass<'tcx> for VecInitThenPush {
                     found: searcher.found + 1,
                     err_span: searcher.err_span.to(stmt.span),
                     last_push_expr: expr.hir_id,
-                    .. searcher
+                    ..searcher
                 });
             } else {
                 searcher.display_err(cx);
diff --git a/clippy_lints/src/visibility.rs b/clippy_lints/src/visibility.rs
index 49637652001..8abcc964b89 100644
--- a/clippy_lints/src/visibility.rs
+++ b/clippy_lints/src/visibility.rs
@@ -82,7 +82,9 @@ impl EarlyLintPass for Visibility {
         if !in_external_macro(cx.sess(), item.span)
             && let VisibilityKind::Restricted { path, shorthand, .. } = &item.vis.kind
         {
-            if **path == kw::SelfLower && let Some(false) = is_from_proc_macro(cx, item.vis.span) {
+            if **path == kw::SelfLower
+                && let Some(false) = is_from_proc_macro(cx, item.vis.span)
+            {
                 span_lint_and_sugg(
                     cx,
                     NEEDLESS_PUB_SELF,
diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs
index ea22be24a0d..b6f942a90d3 100644
--- a/clippy_lints/src/write.rs
+++ b/clippy_lints/src/write.rs
@@ -342,7 +342,10 @@ impl<'tcx> LateLintPass<'tcx> for Write {
 }
 
 fn is_debug_impl(cx: &LateContext<'_>, item: &Item<'_>) -> bool {
-    if let ItemKind::Impl(Impl { of_trait: Some(trait_ref), .. }) = &item.kind
+    if let ItemKind::Impl(Impl {
+        of_trait: Some(trait_ref),
+        ..
+    }) = &item.kind
         && let Some(trait_id) = trait_ref.trait_def_id()
     {
         cx.tcx.is_diagnostic_item(sym::Debug, trait_id)
@@ -508,7 +511,9 @@ fn check_literal(cx: &LateContext<'_>, format_args: &FormatArgs, name: &str) {
                 _ => continue,
             };
 
-            let Some(format_string_snippet) = snippet_opt(cx, format_args.span) else { continue };
+            let Some(format_string_snippet) = snippet_opt(cx, format_args.span) else {
+                continue;
+            };
             let format_string_is_raw = format_string_snippet.starts_with('r');
 
             let replacement = match (format_string_is_raw, replace_raw) {
@@ -537,7 +542,8 @@ fn check_literal(cx: &LateContext<'_>, format_args: &FormatArgs, name: &str) {
             if let Some(replacement) = replacement
                 // `format!("{}", "a")`, `format!("{named}", named = "b")
                 //              ~~~~~                      ~~~~~~~~~~~~~
-                && let Some(removal_span) = format_arg_removal_span(format_args, index) {
+                && let Some(removal_span) = format_arg_removal_span(format_args, index)
+            {
                 let replacement = escape_braces(&replacement, !format_string_is_raw && !replace_raw);
                 suggestion.push((*placeholder_span, replacement));
                 suggestion.push((removal_span, String::new()));
@@ -549,7 +555,8 @@ fn check_literal(cx: &LateContext<'_>, format_args: &FormatArgs, name: &str) {
     if !suggestion.is_empty() {
         for piece in &format_args.template {
             if let Some((span, index)) = positional_arg_piece_span(piece)
-                && suggestion.iter().all(|(s, _)| *s != span) {
+                && suggestion.iter().all(|(s, _)| *s != span)
+            {
                 let decrement = replaced_position.iter().filter(|i| **i < index).count();
                 suggestion.push((span, format!("{{{}}}", index.saturating_sub(decrement))));
             }
diff --git a/clippy_utils/src/check_proc_macro.rs b/clippy_utils/src/check_proc_macro.rs
index 6be8b8bb916..3bac0626f88 100644
--- a/clippy_utils/src/check_proc_macro.rs
+++ b/clippy_utils/src/check_proc_macro.rs
@@ -292,7 +292,9 @@ fn attr_search_pat(attr: &Attribute) -> (Pat, Pat) {
                 (Pat::Str("#!["), Pat::Str("]"))
             };
 
-            if let Some(ident) = attr.ident() && let Pat::Str(old_pat) = pat.0 {
+            if let Some(ident) = attr.ident()
+                && let Pat::Str(old_pat) = pat.0
+            {
                 // TODO: I feel like it's likely we can use `Cow` instead but this will require quite a bit of
                 // refactoring
                 // NOTE: This will likely have false positives, like `allow = 1`
diff --git a/clippy_utils/src/consts.rs b/clippy_utils/src/consts.rs
index 79c04c7c7f4..b7d8c0a8fd7 100644
--- a/clippy_utils/src/consts.rs
+++ b/clippy_utils/src/consts.rs
@@ -405,8 +405,7 @@ impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
                     && let Some(desired_field) = field_of_struct(*adt_def, self.lcx, *constant, field)
                 {
                     mir_to_const(self.lcx, desired_field)
-                }
-                else {
+                } else {
                     result
                 }
             },
@@ -462,11 +461,15 @@ impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
                 // Check if this constant is based on `cfg!(..)`,
                 // which is NOT constant for our purposes.
                 if let Some(node) = self.lcx.tcx.hir().get_if_local(def_id)
-                    && let Node::Item(Item { kind: ItemKind::Const(.., body_id), .. }) = node
-                    && let Node::Expr(Expr { kind: ExprKind::Lit(_), span, .. }) = self.lcx
-                        .tcx
-                        .hir()
-                        .get(body_id.hir_id)
+                    && let Node::Item(Item {
+                        kind: ItemKind::Const(.., body_id),
+                        ..
+                    }) = node
+                    && let Node::Expr(Expr {
+                        kind: ExprKind::Lit(_),
+                        span,
+                        ..
+                    }) = self.lcx.tcx.hir().get(body_id.hir_id)
                     && is_direct_expn_of(*span, "cfg").is_some()
                 {
                     return None;
@@ -531,7 +534,7 @@ impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
                     && let Some(src) = get_source_text(self.lcx, span.lo..expr_lo)
                     && let Some(src) = src.as_str()
                 {
-                    use rustc_lexer::TokenKind::{Whitespace, LineComment, BlockComment, Semi, OpenBrace};
+                    use rustc_lexer::TokenKind::{BlockComment, LineComment, OpenBrace, Semi, Whitespace};
                     if !tokenize(src)
                         .map(|t| t.kind)
                         .filter(|t| !matches!(t, Whitespace | LineComment { .. } | BlockComment { .. } | Semi))
@@ -717,8 +720,7 @@ fn field_of_struct<'tcx>(
         && let Some(&(val, ty)) = dc.fields.get(field_idx)
     {
         Some(mir::Const::Val(val, ty))
-    }
-    else {
+    } else {
         None
     }
 }
diff --git a/clippy_utils/src/hir_utils.rs b/clippy_utils/src/hir_utils.rs
index 52214e733f1..2a8b2ebd5fb 100644
--- a/clippy_utils/src/hir_utils.rs
+++ b/clippy_utils/src/hir_utils.rs
@@ -1142,12 +1142,8 @@ fn eq_span_tokens(
             let pred = |t: &(_, _)| pred(t.0);
             let map = |(_, x)| x;
 
-            let ltok = tokenize_with_text(lsrc)
-                .filter(pred)
-                .map(map);
-            let rtok = tokenize_with_text(rsrc)
-                .filter(pred)
-                .map(map);
+            let ltok = tokenize_with_text(lsrc).filter(pred).map(map);
+            let rtok = tokenize_with_text(rsrc).filter(pred).map(map);
             ltok.eq(rtok)
         } else {
             // Unable to access the source. Conservatively assume the blocks aren't equal.
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 7497d4b2cf1..1181dfc0ef9 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -287,7 +287,7 @@ pub fn is_wild(pat: &Pat<'_>) -> bool {
 pub fn is_ty_alias(qpath: &QPath<'_>) -> bool {
     match *qpath {
         QPath::Resolved(_, path) => matches!(path.res, Res::Def(DefKind::TyAlias | DefKind::AssocTy, ..)),
-        QPath::TypeRelative(ty, _) if let TyKind::Path(qpath) = ty.kind => { is_ty_alias(&qpath) },
+        QPath::TypeRelative(ty, _) if let TyKind::Path(qpath) = ty.kind => is_ty_alias(&qpath),
         _ => false,
     }
 }
@@ -863,8 +863,8 @@ pub fn is_default_equivalent(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
 }
 
 fn is_default_equivalent_from(cx: &LateContext<'_>, from_func: &Expr<'_>, arg: &Expr<'_>) -> bool {
-    if let ExprKind::Path(QPath::TypeRelative(ty, seg)) = from_func.kind &&
-        seg.ident.name == sym::from
+    if let ExprKind::Path(QPath::TypeRelative(ty, seg)) = from_func.kind
+        && seg.ident.name == sym::from
     {
         match arg.kind {
             ExprKind::Lit(hir::Lit {
@@ -873,12 +873,12 @@ fn is_default_equivalent_from(cx: &LateContext<'_>, from_func: &Expr<'_>, arg: &
             }) => return sym.is_empty() && is_path_lang_item(cx, ty, LangItem::String),
             ExprKind::Array([]) => return is_path_diagnostic_item(cx, ty, sym::Vec),
             ExprKind::Repeat(_, ArrayLen::Body(len)) => {
-                if let ExprKind::Lit(const_lit) = cx.tcx.hir().body(len.body).value.kind &&
-                    let LitKind::Int(v, _) = const_lit.node
+                if let ExprKind::Lit(const_lit) = cx.tcx.hir().body(len.body).value.kind
+                    && let LitKind::Int(v, _) = const_lit.node
                 {
-                        return v == 0 && is_path_diagnostic_item(cx, ty, sym::Vec);
+                    return v == 0 && is_path_diagnostic_item(cx, ty, sym::Vec);
                 }
-            }
+            },
             _ => (),
         }
     }
@@ -1515,32 +1515,30 @@ pub fn is_range_full(cx: &LateContext<'_>, expr: &Expr<'_>, container_path: Opti
                 false
             }
         });
-        let end_is_none_or_max = end.map_or(true, |end| {
-            match limits {
-                RangeLimits::Closed => {
-                    if let rustc_ty::Adt(_, subst) = ty.kind()
-                        && let bnd_ty = subst.type_at(0)
-                        && let Some(max_val) = bnd_ty.numeric_max_val(cx.tcx)
-                        && let Some(max_const) = mir_to_const(cx, Const::from_ty_const(max_val, cx.tcx))
-                        && let Some(end_const) = constant(cx, cx.typeck_results(), end)
-                    {
-                        end_const == max_const
-                    } else {
-                        false
-                    }
-                },
-                RangeLimits::HalfOpen => {
-                    if let Some(container_path) = container_path
-                        && let ExprKind::MethodCall(name, self_arg, [], _) = end.kind
-                        && name.ident.name == sym::len
-                        && let ExprKind::Path(QPath::Resolved(None, path)) = self_arg.kind
-                    {
-                        container_path.res == path.res
-                    } else {
-                        false
-                    }
-                },
-            }
+        let end_is_none_or_max = end.map_or(true, |end| match limits {
+            RangeLimits::Closed => {
+                if let rustc_ty::Adt(_, subst) = ty.kind()
+                    && let bnd_ty = subst.type_at(0)
+                    && let Some(max_val) = bnd_ty.numeric_max_val(cx.tcx)
+                    && let Some(max_const) = mir_to_const(cx, Const::from_ty_const(max_val, cx.tcx))
+                    && let Some(end_const) = constant(cx, cx.typeck_results(), end)
+                {
+                    end_const == max_const
+                } else {
+                    false
+                }
+            },
+            RangeLimits::HalfOpen => {
+                if let Some(container_path) = container_path
+                    && let ExprKind::MethodCall(name, self_arg, [], _) = end.kind
+                    && name.ident.name == sym::len
+                    && let ExprKind::Path(QPath::Resolved(None, path)) = self_arg.kind
+                {
+                    container_path.res == path.res
+                } else {
+                    false
+                }
+            },
         });
         return start_is_none_or_min && end_is_none_or_max;
     }
@@ -2101,7 +2099,8 @@ pub fn is_expr_untyped_identity_function(cx: &LateContext<'_>, expr: &Expr<'_>)
         },
         ExprKind::Path(QPath::Resolved(_, path))
             if path.segments.iter().all(|seg| seg.infer_args)
-                && let Some(did) = path.res.opt_def_id() => {
+                && let Some(did) = path.res.opt_def_id() =>
+        {
             cx.tcx.is_diagnostic_item(sym::convert_identity, did)
         },
         _ => false,
@@ -2455,7 +2454,8 @@ fn with_test_item_names(tcx: TyCtxt<'_>, module: LocalModDefId, f: impl Fn(&[Sym
             for id in tcx.hir().module_items(module) {
                 if matches!(tcx.def_kind(id.owner_id), DefKind::Const)
                     && let item = tcx.hir().item(id)
-                    && let ItemKind::Const(ty, _generics, _body) = item.kind {
+                    && let ItemKind::Const(ty, _generics, _body) = item.kind
+                {
                     if let TyKind::Path(QPath::Resolved(_, path)) = ty.kind {
                         // We could also check for the type name `test::TestDescAndFn`
                         if let Res::Def(DefKind::Struct, _) = path.res {
@@ -2719,7 +2719,9 @@ pub fn expr_use_ctxt<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'tcx>) -> Optio
     let ctxt = e.span.ctxt();
     walk_to_expr_usage(cx, e, &mut |parent, child_id| {
         // LocalTableInContext returns the wrong lifetime, so go use `expr_adjustments` instead.
-        if adjustments.is_empty() && let Node::Expr(e) = cx.tcx.hir().get(child_id) {
+        if adjustments.is_empty()
+            && let Node::Expr(e) = cx.tcx.hir().get(child_id)
+        {
             adjustments = cx.typeck_results().expr_adjustments(e);
         }
         match parent {
@@ -2916,13 +2918,13 @@ pub fn pat_and_expr_can_be_question_mark<'a, 'hir>(
     pat: &'a Pat<'hir>,
     else_body: &Expr<'_>,
 ) -> Option<&'a Pat<'hir>> {
-    if let PatKind::TupleStruct(pat_path, [inner_pat], _) = pat.kind &&
-        is_res_lang_ctor(cx, cx.qpath_res(&pat_path, pat.hir_id), OptionSome) &&
-        !is_refutable(cx, inner_pat) &&
-        let else_body = peel_blocks(else_body) &&
-        let ExprKind::Ret(Some(ret_val)) = else_body.kind &&
-        let ExprKind::Path(ret_path) = ret_val.kind &&
-        is_res_lang_ctor(cx, cx.qpath_res(&ret_path, ret_val.hir_id), OptionNone)
+    if let PatKind::TupleStruct(pat_path, [inner_pat], _) = pat.kind
+        && is_res_lang_ctor(cx, cx.qpath_res(&pat_path, pat.hir_id), OptionSome)
+        && !is_refutable(cx, inner_pat)
+        && let else_body = peel_blocks(else_body)
+        && let ExprKind::Ret(Some(ret_val)) = else_body.kind
+        && let ExprKind::Path(ret_path) = ret_val.kind
+        && is_res_lang_ctor(cx, cx.qpath_res(&ret_path, ret_val.hir_id), OptionNone)
     {
         Some(inner_pat)
     } else {
diff --git a/clippy_utils/src/source.rs b/clippy_utils/src/source.rs
index 916f7892944..a4a6f8e15f9 100644
--- a/clippy_utils/src/source.rs
+++ b/clippy_utils/src/source.rs
@@ -70,9 +70,9 @@ pub fn expr_block<T: LintContext>(
     app: &mut Applicability,
 ) -> String {
     let (code, from_macro) = snippet_block_with_context(cx, expr.span, outer, default, indent_relative_to, app);
-    if !from_macro &&
-        let ExprKind::Block(block, _) = expr.kind &&
-        block.rules != BlockCheckMode::UnsafeBlock(UnsafeSource::UserProvided)
+    if !from_macro
+        && let ExprKind::Block(block, _) = expr.kind
+        && block.rules != BlockCheckMode::UnsafeBlock(UnsafeSource::UserProvided)
     {
         format!("{code}")
     } else {
diff --git a/clippy_utils/src/ty.rs b/clippy_utils/src/ty.rs
index 673b259523e..7eff93881b2 100644
--- a/clippy_utils/src/ty.rs
+++ b/clippy_utils/src/ty.rs
@@ -890,7 +890,9 @@ pub fn for_each_top_level_late_bound_region<B>(
     impl<'tcx, B, F: FnMut(BoundRegion) -> ControlFlow<B>> TypeVisitor<TyCtxt<'tcx>> for V<F> {
         type BreakTy = B;
         fn visit_region(&mut self, r: Region<'tcx>) -> ControlFlow<Self::BreakTy> {
-            if let RegionKind::ReLateBound(idx, bound) = r.kind() && idx.as_u32() == self.index {
+            if let RegionKind::ReLateBound(idx, bound) = r.kind()
+                && idx.as_u32() == self.index
+            {
                 (self.f)(bound)
             } else {
                 ControlFlow::Continue(())
@@ -984,16 +986,16 @@ pub fn ty_is_fn_once_param<'tcx>(tcx: TyCtxt<'_>, ty: Ty<'tcx>, predicates: &'tc
         .iter()
         .try_fold(false, |found, p| {
             if let ty::ClauseKind::Trait(p) = p.kind().skip_binder()
-            && let ty::Param(self_ty) = p.trait_ref.self_ty().kind()
-            && ty.index == self_ty.index
-        {
-            // This should use `super_traits_of`, but that's a private function.
-            if p.trait_ref.def_id == fn_once_id {
-                return Some(true);
-            } else if p.trait_ref.def_id == fn_mut_id || p.trait_ref.def_id == fn_id {
-                return None;
+                && let ty::Param(self_ty) = p.trait_ref.self_ty().kind()
+                && ty.index == self_ty.index
+            {
+                // This should use `super_traits_of`, but that's a private function.
+                if p.trait_ref.def_id == fn_once_id {
+                    return Some(true);
+                } else if p.trait_ref.def_id == fn_mut_id || p.trait_ref.def_id == fn_id {
+                    return None;
+                }
             }
-        }
             Some(found)
         })
         .unwrap_or(false)
diff --git a/clippy_utils/src/ty/type_certainty/mod.rs b/clippy_utils/src/ty/type_certainty/mod.rs
index 75064672326..76fa15e1588 100644
--- a/clippy_utils/src/ty/type_certainty/mod.rs
+++ b/clippy_utils/src/ty/type_certainty/mod.rs
@@ -267,7 +267,9 @@ fn path_segment_certainty(
 /// For at least some `QPath::TypeRelative`, the path segment's `res` can be `Res::Err`.
 /// `update_res` tries to fix the resolution when `parent_certainty` is `Certain(Some(..))`.
 fn update_res(cx: &LateContext<'_>, parent_certainty: Certainty, path_segment: &PathSegment<'_>) -> Option<Res> {
-    if path_segment.res == Res::Err && let Some(def_id) = parent_certainty.to_def_id() {
+    if path_segment.res == Res::Err
+        && let Some(def_id) = parent_certainty.to_def_id()
+    {
         let mut def_path = cx.get_def_path(def_id);
         def_path.push(path_segment.ident.name);
         let reses = def_path_res(cx, &def_path.iter().map(Symbol::as_str).collect::<Vec<_>>());
diff --git a/src/driver.rs b/src/driver.rs
index 74f8ed69b4d..7bb49d08da6 100644
--- a/src/driver.rs
+++ b/src/driver.rs
@@ -266,10 +266,12 @@ pub fn main() {
         if clippy_enabled {
             args.extend(clippy_args);
             rustc_driver::RunCompiler::new(&args, &mut ClippyCallbacks { clippy_args_var })
-                .set_using_internal_features(using_internal_features).run()
+                .set_using_internal_features(using_internal_features)
+                .run()
         } else {
             rustc_driver::RunCompiler::new(&args, &mut RustcCallbacks { clippy_args_var })
-                .set_using_internal_features(using_internal_features).run()
+                .set_using_internal_features(using_internal_features)
+                .run()
         }
     }))
 }
diff --git a/tests/ui/auxiliary/proc_macros.rs b/tests/ui/auxiliary/proc_macros.rs
index 43df654389b..3303eb14567 100644
--- a/tests/ui/auxiliary/proc_macros.rs
+++ b/tests/ui/auxiliary/proc_macros.rs
@@ -379,7 +379,8 @@ impl MacroArm {
                         p.span(),
                     )?;
                     self.add_parenthesized_arg_def(kind, dollar_span, g.span(), out);
-                    self.args.push(TT::Group(group_with_span(Parenthesis, inner.collect(), g.span())))
+                    self.args
+                        .push(TT::Group(group_with_span(Parenthesis, inner.collect(), g.span())))
                 } else {
                     self.add_multi_arg_def(dollar_span, g.span(), out);
                     self.args.push(TT::Group(g));
@@ -436,7 +437,12 @@ impl Expander {
                 && p.as_char() == ESCAPE_CHAR
                 && let Some(arm) = self.arm.as_mut()
             {
-                arm.add_arg(p.span(), mem::replace(&mut input.tt, tt), &mut input.iter, &mut self.expn)?;
+                arm.add_arg(
+                    p.span(),
+                    mem::replace(&mut input.tt, tt),
+                    &mut input.iter,
+                    &mut self.expn,
+                )?;
                 if input.next().is_none() {
                     return Ok(());
                 }
diff --git a/tests/ui/bool_to_int_with_if.fixed b/tests/ui/bool_to_int_with_if.fixed
index 44d7f6e6d79..167263d31df 100644
--- a/tests/ui/bool_to_int_with_if.fixed
+++ b/tests/ui/bool_to_int_with_if.fixed
@@ -80,9 +80,7 @@ fn main() {
     // https://github.com/rust-lang/rust-clippy/issues/10452
     let should_not_lint = [(); if true { 1 } else { 0 }];
 
-    let should_not_lint = const {
-        if true { 1 } else { 0 }
-    };
+    let should_not_lint = const { if true { 1 } else { 0 } };
 
     some_fn(a);
 }
@@ -110,7 +108,9 @@ fn if_let(a: Enum, b: Enum) {
         0
     };
 
-    if let Enum::A = a && let Enum::B = b {
+    if let Enum::A = a
+        && let Enum::B = b
+    {
         1
     } else {
         0
diff --git a/tests/ui/bool_to_int_with_if.rs b/tests/ui/bool_to_int_with_if.rs
index 7d989ae4bb3..f3f055eb7f0 100644
--- a/tests/ui/bool_to_int_with_if.rs
+++ b/tests/ui/bool_to_int_with_if.rs
@@ -112,9 +112,7 @@ fn main() {
     // https://github.com/rust-lang/rust-clippy/issues/10452
     let should_not_lint = [(); if true { 1 } else { 0 }];
 
-    let should_not_lint = const {
-        if true { 1 } else { 0 }
-    };
+    let should_not_lint = const { if true { 1 } else { 0 } };
 
     some_fn(a);
 }
@@ -142,7 +140,9 @@ fn if_let(a: Enum, b: Enum) {
         0
     };
 
-    if let Enum::A = a && let Enum::B = b {
+    if let Enum::A = a
+        && let Enum::B = b
+    {
         1
     } else {
         0
diff --git a/tests/ui/bool_to_int_with_if.stderr b/tests/ui/bool_to_int_with_if.stderr
index 837ed05d3a6..714da8a4169 100644
--- a/tests/ui/bool_to_int_with_if.stderr
+++ b/tests/ui/bool_to_int_with_if.stderr
@@ -99,7 +99,7 @@ LL | |     };
    = note: `!b as i32` or `(!b).into()` can also be valid options
 
 error: boolean to int conversion using if
-  --> $DIR/bool_to_int_with_if.rs:124:5
+  --> $DIR/bool_to_int_with_if.rs:122:5
    |
 LL |     if a { 1 } else { 0 }
    |     ^^^^^^^^^^^^^^^^^^^^^ help: replace with from: `u8::from(a)`
diff --git a/tests/ui/comparison_to_empty.fixed b/tests/ui/comparison_to_empty.fixed
index 90eb50715a2..e102b13a761 100644
--- a/tests/ui/comparison_to_empty.fixed
+++ b/tests/ui/comparison_to_empty.fixed
@@ -15,7 +15,9 @@ fn main() {
     let s = [0].as_slice();
     if s.is_empty() {}
     if s.is_empty() {}
-    if s.is_empty() && s.is_empty() {}
+    if s.is_empty()
+        && s.is_empty()
+    {}
 
     // Allow comparisons to non-empty
     let s = String::new();
@@ -28,5 +30,7 @@ fn main() {
     if let [0] = &*v {}
     let s = [0].as_slice();
     if let [0] = s {}
-    if let [0] = &*s && s == [0] {}
+    if let [0] = &*s
+        && s == [0]
+    {}
 }
diff --git a/tests/ui/comparison_to_empty.rs b/tests/ui/comparison_to_empty.rs
index 0964c4a20a9..69a6c967d38 100644
--- a/tests/ui/comparison_to_empty.rs
+++ b/tests/ui/comparison_to_empty.rs
@@ -15,7 +15,9 @@ fn main() {
     let s = [0].as_slice();
     if let [] = s {}
     if let [] = &*s {}
-    if let [] = &*s && s == [] {}
+    if let [] = &*s
+        && s == []
+    {}
 
     // Allow comparisons to non-empty
     let s = String::new();
@@ -28,5 +30,7 @@ fn main() {
     if let [0] = &*v {}
     let s = [0].as_slice();
     if let [0] = s {}
-    if let [0] = &*s && s == [0] {}
+    if let [0] = &*s
+        && s == [0]
+    {}
 }
diff --git a/tests/ui/comparison_to_empty.stderr b/tests/ui/comparison_to_empty.stderr
index b97ab4c3c93..83d431fd52b 100644
--- a/tests/ui/comparison_to_empty.stderr
+++ b/tests/ui/comparison_to_empty.stderr
@@ -46,14 +46,14 @@ LL |     if let [] = &*s {}
 error: comparison to empty slice using `if let`
   --> $DIR/comparison_to_empty.rs:18:8
    |
-LL |     if let [] = &*s && s == [] {}
+LL |     if let [] = &*s
    |        ^^^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `s.is_empty()`
 
 error: comparison to empty slice
-  --> $DIR/comparison_to_empty.rs:18:24
+  --> $DIR/comparison_to_empty.rs:19:12
    |
-LL |     if let [] = &*s && s == [] {}
-   |                        ^^^^^^^ help: using `is_empty` is clearer and more explicit: `s.is_empty()`
+LL |         && s == []
+   |            ^^^^^^^ help: using `is_empty` is clearer and more explicit: `s.is_empty()`
 
 error: aborting due to 9 previous errors
 
diff --git a/tests/ui/manual_filter.rs b/tests/ui/manual_filter.rs
index 06968f8bae4..ee44909f37e 100644
--- a/tests/ui/manual_filter.rs
+++ b/tests/ui/manual_filter.rs
@@ -191,9 +191,7 @@ fn main() {
         None => None,
     };
     let _ = match Some(15) {
-        Some(x) => unsafe {
-            if f(x) { Some(x) } else { None }
-        },
+        Some(x) => unsafe { if f(x) { Some(x) } else { None } },
         None => None,
     };
 
diff --git a/tests/ui/manual_filter.stderr b/tests/ui/manual_filter.stderr
index 1490f209735..b23ad887eb2 100644
--- a/tests/ui/manual_filter.stderr
+++ b/tests/ui/manual_filter.stderr
@@ -169,15 +169,13 @@ error: manual implementation of `Option::filter`
    |
 LL |       let _ = match Some(15) {
    |  _____________^
-LL | |         Some(x) => unsafe {
-LL | |             if f(x) { Some(x) } else { None }
-LL | |         },
+LL | |         Some(x) => unsafe { if f(x) { Some(x) } else { None } },
 LL | |         None => None,
 LL | |     };
    | |_____^ help: try: `Some(15).filter(|&x| unsafe { f(x) })`
 
 error: manual implementation of `Option::filter`
-  --> $DIR/manual_filter.rs:203:12
+  --> $DIR/manual_filter.rs:201:12
    |
 LL |       } else if let Some(x) = Some(16) {
    |  ____________^
diff --git a/tests/ui/manual_let_else.rs b/tests/ui/manual_let_else.rs
index 6775fdc921f..27717ab3a73 100644
--- a/tests/ui/manual_let_else.rs
+++ b/tests/ui/manual_let_else.rs
@@ -35,9 +35,7 @@ fn fire() {
     let v = if let Some(v) = g() {
         //~^ ERROR: this could be rewritten as `let...else`
         // Blocks around the identity should have no impact
-        {
-            { v }
-        }
+        { { v } }
     } else {
         // Some computation should still make it fire
         g();
diff --git a/tests/ui/manual_let_else.stderr b/tests/ui/manual_let_else.stderr
index 49dbd7615e0..2b6504a1827 100644
--- a/tests/ui/manual_let_else.stderr
+++ b/tests/ui/manual_let_else.stderr
@@ -31,7 +31,7 @@ error: this could be rewritten as `let...else`
 LL | /     let v = if let Some(v) = g() {
 LL | |
 LL | |         // Blocks around the identity should have no impact
-LL | |         {
+LL | |         { { v } }
 ...  |
 LL | |         return;
 LL | |     };
@@ -47,25 +47,25 @@ LL +     };
    |
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:49:9
+  --> $DIR/manual_let_else.rs:47:9
    |
 LL |         let v = if let Some(v_some) = g() { v_some } else { continue };
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let Some(v) = g() else { continue };`
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:51:9
+  --> $DIR/manual_let_else.rs:49:9
    |
 LL |         let v = if let Some(v_some) = g() { v_some } else { break };
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let Some(v) = g() else { break };`
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:56:5
+  --> $DIR/manual_let_else.rs:54:5
    |
 LL |     let v = if let Some(v_some) = g() { v_some } else { panic!() };
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let Some(v) = g() else { panic!() };`
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:60:5
+  --> $DIR/manual_let_else.rs:58:5
    |
 LL | /     let v = if let Some(v_some) = g() {
 LL | |
@@ -83,7 +83,7 @@ LL +     };
    |
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:68:5
+  --> $DIR/manual_let_else.rs:66:5
    |
 LL | /     let v = if let Some(v_some) = g() {
 LL | |
@@ -101,7 +101,7 @@ LL +     };
    |
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:76:5
+  --> $DIR/manual_let_else.rs:74:5
    |
 LL | /     let v = if let Some(v_some) = g() {
 LL | |
@@ -121,7 +121,7 @@ LL +     };
    |
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:87:5
+  --> $DIR/manual_let_else.rs:85:5
    |
 LL | /     let v = if let Some(v_some) = g() {
 LL | |
@@ -143,13 +143,13 @@ LL +     };
    |
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:98:5
+  --> $DIR/manual_let_else.rs:96:5
    |
 LL |     let v = if let Some(v_some) = g() { v_some } 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:102:5
+  --> $DIR/manual_let_else.rs:100:5
    |
 LL | /     let v = if let Some(v_some) = g() {
 LL | |
@@ -170,7 +170,7 @@ LL +     };
    |
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:112:5
+  --> $DIR/manual_let_else.rs:110:5
    |
 LL | /     let v = if let Some(v_some) = g() {
 LL | |
@@ -191,7 +191,7 @@ LL +     } };
    |
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:122:5
+  --> $DIR/manual_let_else.rs:120:5
    |
 LL | /     let v = if let Some(v_some) = g() {
 LL | |
@@ -220,7 +220,7 @@ LL +     };
    |
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:140:5
+  --> $DIR/manual_let_else.rs:138:5
    |
 LL | /     let (v, w) = if let Some(v_some) = g().map(|v| (v, 42)) {
 LL | |
@@ -238,7 +238,7 @@ LL +     };
    |
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:148:5
+  --> $DIR/manual_let_else.rs:146:5
    |
 LL | /     let (w, S { v }) = if let (Some(v_some), w_some) = (g().map(|_| S { v: 0 }), 0) {
 LL | |
@@ -256,7 +256,7 @@ LL +     };
    |
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:158:13
+  --> $DIR/manual_let_else.rs:156:13
    |
 LL |             let $n = if let Some(v) = $e { v } else { return };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let Some($n) = g() else { return };`
@@ -267,19 +267,19 @@ LL |     create_binding_if_some!(w, g());
    = 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:167:5
+  --> $DIR/manual_let_else.rs:165:5
    |
 LL |     let v = if let Variant::A(a, 0) = e() { a } else { return };
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let Variant::A(v, 0) = e() else { return };`
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:171:5
+  --> $DIR/manual_let_else.rs:169:5
    |
 LL |     let mut v = if let Variant::B(b) = e() { b } else { return };
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let Variant::B(mut v) = e() else { return };`
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:176:5
+  --> $DIR/manual_let_else.rs:174:5
    |
 LL | /     let v = if let Ok(Some(Variant::B(b))) | Err(Some(Variant::A(b, _))) = nested {
 LL | |
@@ -297,19 +297,19 @@ LL +     };
    |
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:183:5
+  --> $DIR/manual_let_else.rs:181:5
    |
 LL |     let v = if let Variant::A(.., a) = e() { a } else { return };
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let Variant::A(.., v) = e() else { return };`
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:187:5
+  --> $DIR/manual_let_else.rs:185:5
    |
 LL |     let w = if let (Some(v), ()) = (g(), ()) { v } else { return };
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let (Some(w), ()) = (g(), ()) else { return };`
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:191:5
+  --> $DIR/manual_let_else.rs:189:5
    |
 LL | /     let w = if let Some(S { v: x }) = Some(S { v: 0 }) {
 LL | |
@@ -327,7 +327,7 @@ LL +     };
    |
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:199:5
+  --> $DIR/manual_let_else.rs:197:5
    |
 LL | /     let v = if let Some(S { v: x }) = Some(S { v: 0 }) {
 LL | |
@@ -345,7 +345,7 @@ LL +     };
    |
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:207:5
+  --> $DIR/manual_let_else.rs:205:5
    |
 LL | /     let (x, S { v }, w) = if let Some(U { v, w, x }) = None::<U<S<()>>> {
 LL | |
@@ -363,7 +363,7 @@ LL +     };
    |
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:324:5
+  --> $DIR/manual_let_else.rs:322:5
    |
 LL | /     let _ = match ff {
 LL | |
diff --git a/tests/ui/manual_map_option_2.fixed b/tests/ui/manual_map_option_2.fixed
index 513f6e32340..f5bb4e0af1b 100644
--- a/tests/ui/manual_map_option_2.fixed
+++ b/tests/ui/manual_map_option_2.fixed
@@ -42,9 +42,7 @@ fn main() {
 
     // Lint. `s` is captured by reference, so no lifetime issues.
     let s = Some(String::new());
-    let _ = s.as_ref().map(|x| {
-            if let Some(ref s) = s { (x.clone(), s) } else { panic!() }
-        });
+    let _ = s.as_ref().map(|x| { if let Some(ref s) = s { (x.clone(), s) } else { panic!() } });
 
     // Issue #7820
     unsafe fn f(x: u32) -> u32 {
diff --git a/tests/ui/manual_map_option_2.rs b/tests/ui/manual_map_option_2.rs
index fd186743fe2..cbc2356e0a2 100644
--- a/tests/ui/manual_map_option_2.rs
+++ b/tests/ui/manual_map_option_2.rs
@@ -46,9 +46,7 @@ fn main() {
     // Lint. `s` is captured by reference, so no lifetime issues.
     let s = Some(String::new());
     let _ = match &s {
-        Some(x) => Some({
-            if let Some(ref s) = s { (x.clone(), s) } else { panic!() }
-        }),
+        Some(x) => Some({ if let Some(ref s) = s { (x.clone(), s) } else { panic!() } }),
         None => None,
     };
 
diff --git a/tests/ui/manual_map_option_2.stderr b/tests/ui/manual_map_option_2.stderr
index bf242c0416c..d3754f22d89 100644
--- a/tests/ui/manual_map_option_2.stderr
+++ b/tests/ui/manual_map_option_2.stderr
@@ -26,22 +26,13 @@ error: manual implementation of `Option::map`
    |
 LL |       let _ = match &s {
    |  _____________^
-LL | |         Some(x) => Some({
-LL | |             if let Some(ref s) = s { (x.clone(), s) } else { panic!() }
-LL | |         }),
+LL | |         Some(x) => Some({ if let Some(ref s) = s { (x.clone(), s) } else { panic!() } }),
 LL | |         None => None,
 LL | |     };
-   | |_____^
-   |
-help: try
-   |
-LL ~     let _ = s.as_ref().map(|x| {
-LL +             if let Some(ref s) = s { (x.clone(), s) } else { panic!() }
-LL ~         });
-   |
+   | |_____^ help: try: `s.as_ref().map(|x| { if let Some(ref s) = s { (x.clone(), s) } else { panic!() } })`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option_2.rs:60:17
+  --> $DIR/manual_map_option_2.rs:58:17
    |
 LL |           let _ = match Some(0) {
    |  _________________^
@@ -51,7 +42,7 @@ LL | |         };
    | |_________^ help: try: `Some(0).map(|x| f(x))`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option_2.rs:65:13
+  --> $DIR/manual_map_option_2.rs:63:13
    |
 LL |       let _ = match Some(0) {
    |  _____________^
@@ -61,7 +52,7 @@ LL | |     };
    | |_____^ help: try: `Some(0).map(|x| unsafe { f(x) })`
 
 error: manual implementation of `Option::map`
-  --> $DIR/manual_map_option_2.rs:69:13
+  --> $DIR/manual_map_option_2.rs:67:13
    |
 LL |       let _ = match Some(0) {
    |  _____________^
diff --git a/tests/ui/needless_if.fixed b/tests/ui/needless_if.fixed
index b84182c5756..be35dcddbe6 100644
--- a/tests/ui/needless_if.fixed
+++ b/tests/ui/needless_if.fixed
@@ -39,11 +39,21 @@ fn main() {
     }
     // Do not lint `if let` or let chains
     if let true = true {}
-    if let true = true && true {}
-    if true && let true = true {}
+    if let true = true
+        && true
+    {}
+    if true
+        && let true = true
+    {}
     // Can lint nested `if let`s
     ({
-        if let true = true && true { true } else { false }
+        if let true = true
+            && true
+        {
+            true
+        } else {
+            false
+        }
     } && true);
     external! { if (true) {} }
     with_span! {
diff --git a/tests/ui/needless_if.rs b/tests/ui/needless_if.rs
index 6c6023c72dc..e2ad17e69a8 100644
--- a/tests/ui/needless_if.rs
+++ b/tests/ui/needless_if.rs
@@ -39,11 +39,21 @@ fn main() {
     }
     // Do not lint `if let` or let chains
     if let true = true {}
-    if let true = true && true {}
-    if true && let true = true {}
+    if let true = true
+        && true
+    {}
+    if true
+        && let true = true
+    {}
     // Can lint nested `if let`s
     if {
-        if let true = true && true { true } else { false }
+        if let true = true
+            && true
+        {
+            true
+        } else {
+            false
+        }
     } && true
     {}
     external! { if (true) {} }
diff --git a/tests/ui/needless_if.stderr b/tests/ui/needless_if.stderr
index ed5b9452b86..c3e83c0f1f5 100644
--- a/tests/ui/needless_if.stderr
+++ b/tests/ui/needless_if.stderr
@@ -29,10 +29,13 @@ LL +     });
    |
 
 error: this `if` branch is empty
-  --> $DIR/needless_if.rs:45:5
+  --> $DIR/needless_if.rs:49:5
    |
 LL | /     if {
-LL | |         if let true = true && true { true } else { false }
+LL | |         if let true = true
+LL | |             && true
+LL | |         {
+...  |
 LL | |     } && true
 LL | |     {}
    | |______^
@@ -40,24 +43,30 @@ LL | |     {}
 help: you can remove it
    |
 LL ~     ({
-LL +         if let true = true && true { true } else { false }
+LL +         if let true = true
+LL +             && true
+LL +         {
+LL +             true
+LL +         } else {
+LL +             false
+LL +         }
 LL +     } && true);
    |
 
 error: this `if` branch is empty
-  --> $DIR/needless_if.rs:83:5
+  --> $DIR/needless_if.rs:93:5
    |
 LL |     if { maybe_side_effect() } {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: you can remove it: `({ maybe_side_effect() });`
 
 error: this `if` branch is empty
-  --> $DIR/needless_if.rs:85:5
+  --> $DIR/needless_if.rs:95:5
    |
 LL |     if { maybe_side_effect() } && true {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: you can remove it: `({ maybe_side_effect() } && true);`
 
 error: this `if` branch is empty
-  --> $DIR/needless_if.rs:89:5
+  --> $DIR/needless_if.rs:99:5
    |
 LL |     if true {}
    |     ^^^^^^^^^^ help: you can remove it: `true;`
diff --git a/tests/ui/needless_late_init.fixed b/tests/ui/needless_late_init.fixed
index 9f45da04862..891b2b01437 100644
--- a/tests/ui/needless_late_init.fixed
+++ b/tests/ui/needless_late_init.fixed
@@ -230,7 +230,9 @@ fn does_not_lint() {
     }
 
     let x;
-    if true && let Some(n) = Some("let chains too") {
+    if true
+        && let Some(n) = Some("let chains too")
+    {
         x = 1;
     } else {
         x = 2;
diff --git a/tests/ui/needless_late_init.rs b/tests/ui/needless_late_init.rs
index 0dab0faad56..55399511639 100644
--- a/tests/ui/needless_late_init.rs
+++ b/tests/ui/needless_late_init.rs
@@ -230,7 +230,9 @@ fn does_not_lint() {
     }
 
     let x;
-    if true && let Some(n) = Some("let chains too") {
+    if true
+        && let Some(n) = Some("let chains too")
+    {
         x = 1;
     } else {
         x = 2;
diff --git a/tests/ui/redundant_guards.fixed b/tests/ui/redundant_guards.fixed
index f23116a7e1c..f8af9092725 100644
--- a/tests/ui/redundant_guards.fixed
+++ b/tests/ui/redundant_guards.fixed
@@ -48,7 +48,7 @@ fn main() {
         Some(x) if let Some(1) = x => {
             x;
             ..
-        }
+        },
         _ => todo!(),
     };
     let y = 1;
diff --git a/tests/ui/redundant_guards.rs b/tests/ui/redundant_guards.rs
index c0206b4cec7..b46f8a6207e 100644
--- a/tests/ui/redundant_guards.rs
+++ b/tests/ui/redundant_guards.rs
@@ -48,7 +48,7 @@ fn main() {
         Some(x) if let Some(1) = x => {
             x;
             ..
-        }
+        },
         _ => todo!(),
     };
     let y = 1;
diff --git a/tests/ui/redundant_pattern_matching_option.fixed b/tests/ui/redundant_pattern_matching_option.fixed
index 60f9fb6d493..c9b76262d70 100644
--- a/tests/ui/redundant_pattern_matching_option.fixed
+++ b/tests/ui/redundant_pattern_matching_option.fixed
@@ -16,10 +16,15 @@ fn issue_11174<T>(boolean: bool, maybe_some: Option<T>) -> bool {
 
 fn issue_11174_edge_cases<T>(boolean: bool, boolean2: bool, maybe_some: Option<T>) {
     let _ = maybe_some.is_none() && (boolean || boolean2); // guard needs parentheses
-    let _ = match maybe_some { // can't use `matches!` here
-                               // because `expr` metavars in macros don't allow let exprs
-        None if let Some(x) = Some(0) && x > 5 => true,
-        _ => false
+    let _ = match maybe_some {
+        // can't use `matches!` here
+        // because `expr` metavars in macros don't allow let exprs
+        None if let Some(x) = Some(0)
+            && x > 5 =>
+        {
+            true
+        },
+        _ => false,
     };
 }
 
diff --git a/tests/ui/redundant_pattern_matching_option.rs b/tests/ui/redundant_pattern_matching_option.rs
index 94bbb569c2a..a5f9caf659c 100644
--- a/tests/ui/redundant_pattern_matching_option.rs
+++ b/tests/ui/redundant_pattern_matching_option.rs
@@ -16,10 +16,15 @@ fn issue_11174<T>(boolean: bool, maybe_some: Option<T>) -> bool {
 
 fn issue_11174_edge_cases<T>(boolean: bool, boolean2: bool, maybe_some: Option<T>) {
     let _ = matches!(maybe_some, None if boolean || boolean2); // guard needs parentheses
-    let _ = match maybe_some { // can't use `matches!` here
-                               // because `expr` metavars in macros don't allow let exprs
-        None if let Some(x) = Some(0) && x > 5 => true,
-        _ => false
+    let _ = match maybe_some {
+        // can't use `matches!` here
+        // because `expr` metavars in macros don't allow let exprs
+        None if let Some(x) = Some(0)
+            && x > 5 =>
+        {
+            true
+        },
+        _ => false,
     };
 }
 
diff --git a/tests/ui/redundant_pattern_matching_option.stderr b/tests/ui/redundant_pattern_matching_option.stderr
index fdf395d8286..a75551c56f2 100644
--- a/tests/ui/redundant_pattern_matching_option.stderr
+++ b/tests/ui/redundant_pattern_matching_option.stderr
@@ -14,49 +14,49 @@ LL |     let _ = matches!(maybe_some, None if boolean || boolean2); // guard nee
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `maybe_some.is_none() && (boolean || boolean2)`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:27:12
+  --> $DIR/redundant_pattern_matching_option.rs:32:12
    |
 LL |     if let None = None::<()> {}
    |     -------^^^^------------- help: try: `if None::<()>.is_none()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/redundant_pattern_matching_option.rs:29:12
+  --> $DIR/redundant_pattern_matching_option.rs:34:12
    |
 LL |     if let Some(_) = Some(42) {}
    |     -------^^^^^^^----------- help: try: `if Some(42).is_some()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/redundant_pattern_matching_option.rs:31:12
+  --> $DIR/redundant_pattern_matching_option.rs:36:12
    |
 LL |     if let Some(_) = Some(42) {
    |     -------^^^^^^^----------- help: try: `if Some(42).is_some()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/redundant_pattern_matching_option.rs:37:15
+  --> $DIR/redundant_pattern_matching_option.rs:42:15
    |
 LL |     while let Some(_) = Some(42) {}
    |     ----------^^^^^^^----------- help: try: `while Some(42).is_some()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:39:15
+  --> $DIR/redundant_pattern_matching_option.rs:44:15
    |
 LL |     while let None = Some(42) {}
    |     ----------^^^^----------- help: try: `while Some(42).is_none()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:41:15
+  --> $DIR/redundant_pattern_matching_option.rs:46:15
    |
 LL |     while let None = None::<()> {}
    |     ----------^^^^------------- help: try: `while None::<()>.is_none()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/redundant_pattern_matching_option.rs:44:15
+  --> $DIR/redundant_pattern_matching_option.rs:49:15
    |
 LL |     while let Some(_) = v.pop() {
    |     ----------^^^^^^^---------- help: try: `while v.pop().is_some()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/redundant_pattern_matching_option.rs:52:5
+  --> $DIR/redundant_pattern_matching_option.rs:57:5
    |
 LL | /     match Some(42) {
 LL | |         Some(_) => true,
@@ -65,7 +65,7 @@ LL | |     };
    | |_____^ help: try: `Some(42).is_some()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:57:5
+  --> $DIR/redundant_pattern_matching_option.rs:62:5
    |
 LL | /     match None::<()> {
 LL | |         Some(_) => false,
@@ -74,7 +74,7 @@ LL | |     };
    | |_____^ help: try: `None::<()>.is_none()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:62:13
+  --> $DIR/redundant_pattern_matching_option.rs:67:13
    |
 LL |       let _ = match None::<()> {
    |  _____________^
@@ -84,55 +84,55 @@ LL | |     };
    | |_____^ help: try: `None::<()>.is_none()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/redundant_pattern_matching_option.rs:68:20
+  --> $DIR/redundant_pattern_matching_option.rs:73:20
    |
 LL |     let _ = if let Some(_) = opt { true } else { false };
    |             -------^^^^^^^------ help: try: `if opt.is_some()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/redundant_pattern_matching_option.rs:74:20
+  --> $DIR/redundant_pattern_matching_option.rs:79:20
    |
 LL |     let _ = if let Some(_) = gen_opt() {
    |             -------^^^^^^^------------ help: try: `if gen_opt().is_some()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:76:19
+  --> $DIR/redundant_pattern_matching_option.rs:81:19
    |
 LL |     } else if let None = gen_opt() {
    |            -------^^^^------------ help: try: `if gen_opt().is_none()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/redundant_pattern_matching_option.rs:82:12
+  --> $DIR/redundant_pattern_matching_option.rs:87:12
    |
 LL |     if let Some(..) = gen_opt() {}
    |     -------^^^^^^^^------------ help: try: `if gen_opt().is_some()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/redundant_pattern_matching_option.rs:97:12
+  --> $DIR/redundant_pattern_matching_option.rs:102:12
    |
 LL |     if let Some(_) = Some(42) {}
    |     -------^^^^^^^----------- help: try: `if Some(42).is_some()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:99:12
+  --> $DIR/redundant_pattern_matching_option.rs:104:12
    |
 LL |     if let None = None::<()> {}
    |     -------^^^^------------- help: try: `if None::<()>.is_none()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/redundant_pattern_matching_option.rs:101:15
+  --> $DIR/redundant_pattern_matching_option.rs:106:15
    |
 LL |     while let Some(_) = Some(42) {}
    |     ----------^^^^^^^----------- help: try: `while Some(42).is_some()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:103:15
+  --> $DIR/redundant_pattern_matching_option.rs:108:15
    |
 LL |     while let None = None::<()> {}
    |     ----------^^^^------------- help: try: `while None::<()>.is_none()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/redundant_pattern_matching_option.rs:105:5
+  --> $DIR/redundant_pattern_matching_option.rs:110:5
    |
 LL | /     match Some(42) {
 LL | |         Some(_) => true,
@@ -141,7 +141,7 @@ LL | |     };
    | |_____^ help: try: `Some(42).is_some()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:110:5
+  --> $DIR/redundant_pattern_matching_option.rs:115:5
    |
 LL | /     match None::<()> {
 LL | |         Some(_) => false,
@@ -150,19 +150,19 @@ LL | |     };
    | |_____^ help: try: `None::<()>.is_none()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:118:12
+  --> $DIR/redundant_pattern_matching_option.rs:123:12
    |
 LL |     if let None = *(&None::<()>) {}
    |     -------^^^^----------------- help: try: `if (&None::<()>).is_none()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:119:12
+  --> $DIR/redundant_pattern_matching_option.rs:124:12
    |
 LL |     if let None = *&None::<()> {}
    |     -------^^^^--------------- help: try: `if (&None::<()>).is_none()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/redundant_pattern_matching_option.rs:125:5
+  --> $DIR/redundant_pattern_matching_option.rs:130:5
    |
 LL | /     match x {
 LL | |         Some(_) => true,
@@ -171,7 +171,7 @@ LL | |     };
    | |_____^ help: try: `x.is_some()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:130:5
+  --> $DIR/redundant_pattern_matching_option.rs:135:5
    |
 LL | /     match x {
 LL | |         None => true,
@@ -180,7 +180,7 @@ LL | |     };
    | |_____^ help: try: `x.is_none()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:135:5
+  --> $DIR/redundant_pattern_matching_option.rs:140:5
    |
 LL | /     match x {
 LL | |         Some(_) => false,
@@ -189,7 +189,7 @@ LL | |     };
    | |_____^ help: try: `x.is_none()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/redundant_pattern_matching_option.rs:140:5
+  --> $DIR/redundant_pattern_matching_option.rs:145:5
    |
 LL | /     match x {
 LL | |         None => false,
@@ -198,13 +198,13 @@ LL | |     };
    | |_____^ help: try: `x.is_some()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> $DIR/redundant_pattern_matching_option.rs:155:13
+  --> $DIR/redundant_pattern_matching_option.rs:160:13
    |
 LL |     let _ = matches!(x, Some(_));
    |             ^^^^^^^^^^^^^^^^^^^^ help: try: `x.is_some()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> $DIR/redundant_pattern_matching_option.rs:157:13
+  --> $DIR/redundant_pattern_matching_option.rs:162:13
    |
 LL |     let _ = matches!(x, None);
    |             ^^^^^^^^^^^^^^^^^ help: try: `x.is_none()`
-- 
cgit 1.4.1-3-g733a5


From 39eded7b0547df68c171195e0437bac57d05c3df Mon Sep 17 00:00:00 2001
From: sjwang05 <63834813+sjwang05@users.noreply.github.com>
Date: Fri, 20 Oct 2023 10:19:46 -0700
Subject: Lint `flatten()` under `lines_filter_map_ok`

---
 clippy_lints/src/lines_filter_map_ok.rs | 55 +++++++++++++++++----------------
 tests/ui/lines_filter_map_ok.fixed      |  6 ++++
 tests/ui/lines_filter_map_ok.rs         |  6 ++++
 tests/ui/lines_filter_map_ok.stderr     | 34 +++++++++++++++++---
 4 files changed, 69 insertions(+), 32 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lines_filter_map_ok.rs b/clippy_lints/src/lines_filter_map_ok.rs
index 0a5f5a80cb7..1449357e25c 100644
--- a/clippy_lints/src/lines_filter_map_ok.rs
+++ b/clippy_lints/src/lines_filter_map_ok.rs
@@ -53,40 +53,41 @@ declare_clippy_lint! {
     #[clippy::version = "1.70.0"]
     pub LINES_FILTER_MAP_OK,
     suspicious,
-    "filtering `std::io::Lines` with `filter_map()` or `flat_map()` might cause an infinite loop"
+    "filtering `std::io::Lines` with `filter_map()`, `flat_map()`, or `flatten()` might cause an infinite loop"
 }
 declare_lint_pass!(LinesFilterMapOk => [LINES_FILTER_MAP_OK]);
 
 impl LateLintPass<'_> for LinesFilterMapOk {
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
-        if let ExprKind::MethodCall(fm_method, fm_receiver, [fm_arg], fm_span) = expr.kind
-            && is_trait_method(cx, expr, sym::Iterator)
-            && (fm_method.ident.as_str() == "filter_map" || fm_method.ident.as_str() == "flat_map")
-            && is_type_diagnostic_item(cx, cx.typeck_results().expr_ty_adjusted(fm_receiver), sym::IoLines)
+        if let ExprKind::MethodCall(fm_method, fm_receiver, fm_args, fm_span) = expr.kind &&
+            is_trait_method(cx, expr, sym::Iterator) &&
+            let fm_method_str = fm_method.ident.as_str() &&
+            matches!(fm_method_str, "filter_map" | "flat_map" | "flatten") &&
+            is_type_diagnostic_item(cx, cx.typeck_results().expr_ty_adjusted(fm_receiver), sym::IoLines)
         {
-            let lint = match &fm_arg.kind {
-                // Detect `Result::ok`
-                ExprKind::Path(qpath) => cx
-                    .qpath_res(qpath, fm_arg.hir_id)
-                    .opt_def_id()
-                    .map(|did| match_def_path(cx, did, &paths::CORE_RESULT_OK_METHOD))
-                    .unwrap_or_default(),
-                // Detect `|x| x.ok()`
-                ExprKind::Closure(Closure { body, .. }) => {
-                    if let Body {
-                        params: [param], value, ..
-                    } = cx.tcx.hir().body(*body)
-                        && let ExprKind::MethodCall(method, receiver, [], _) = value.kind
-                        && path_to_local_id(receiver, param.pat.hir_id)
-                        && let Some(method_did) = cx.typeck_results().type_dependent_def_id(value.hir_id)
-                    {
-                        is_diag_item_method(cx, method_did, sym::Result) && method.ident.as_str() == "ok"
-                    } else {
-                        false
-                    }
-                },
-                _ => false,
+            let lint = if let [fm_arg] = fm_args {
+                match &fm_arg.kind {
+                    // Detect `Result::ok`
+                    ExprKind::Path(qpath) =>
+                        cx.qpath_res(qpath, fm_arg.hir_id).opt_def_id().map(|did|
+                            match_def_path(cx, did, &paths::CORE_RESULT_OK_METHOD)).unwrap_or_default(),
+                    // Detect `|x| x.ok()`
+                    ExprKind::Closure(Closure { body, .. }) =>
+                        if let Body { params: [param], value, .. } = cx.tcx.hir().body(*body) &&
+                            let ExprKind::MethodCall(method, receiver, [], _) = value.kind &&
+                            path_to_local_id(receiver, param.pat.hir_id) &&
+                            let Some(method_did) = cx.typeck_results().type_dependent_def_id(value.hir_id)
+                        {
+                            is_diag_item_method(cx, method_did, sym::Result) && method.ident.as_str() == "ok"
+                        } else {
+                            false
+                        },
+                    _ => false,
+                }
+            } else {
+                fm_method_str == "flatten"
             };
+
             if lint {
                 span_lint_and_then(
                     cx,
diff --git a/tests/ui/lines_filter_map_ok.fixed b/tests/ui/lines_filter_map_ok.fixed
index 74ef6f72957..621115cc132 100644
--- a/tests/ui/lines_filter_map_ok.fixed
+++ b/tests/ui/lines_filter_map_ok.fixed
@@ -10,11 +10,17 @@ fn main() -> io::Result<()> {
     // Lint
     let f = std::fs::File::open("/")?;
     BufReader::new(f).lines().map_while(Result::ok).for_each(|_| ());
+    // Lint
+    let f = std::fs::File::open("/")?;
+    BufReader::new(f).lines().map_while(Result::ok).for_each(|_| ());
+
     let s = "foo\nbar\nbaz\n";
     // Lint
     io::stdin().lines().map_while(Result::ok).for_each(|_| ());
     // Lint
     io::stdin().lines().map_while(Result::ok).for_each(|_| ());
+    // Lint
+    io::stdin().lines().map_while(Result::ok).for_each(|_| ());
     // Do not lint (not a `Lines` iterator)
     io::stdin()
         .lines()
diff --git a/tests/ui/lines_filter_map_ok.rs b/tests/ui/lines_filter_map_ok.rs
index 345f4dc5f30..a86efbd6686 100644
--- a/tests/ui/lines_filter_map_ok.rs
+++ b/tests/ui/lines_filter_map_ok.rs
@@ -10,11 +10,17 @@ fn main() -> io::Result<()> {
     // Lint
     let f = std::fs::File::open("/")?;
     BufReader::new(f).lines().flat_map(Result::ok).for_each(|_| ());
+    // Lint
+    let f = std::fs::File::open("/")?;
+    BufReader::new(f).lines().flatten().for_each(|_| ());
+
     let s = "foo\nbar\nbaz\n";
     // Lint
     io::stdin().lines().filter_map(Result::ok).for_each(|_| ());
     // Lint
     io::stdin().lines().filter_map(|x| x.ok()).for_each(|_| ());
+    // Lint
+    io::stdin().lines().flatten().for_each(|_| ());
     // Do not lint (not a `Lines` iterator)
     io::stdin()
         .lines()
diff --git a/tests/ui/lines_filter_map_ok.stderr b/tests/ui/lines_filter_map_ok.stderr
index fa2ba0a9a46..9833ab16473 100644
--- a/tests/ui/lines_filter_map_ok.stderr
+++ b/tests/ui/lines_filter_map_ok.stderr
@@ -24,29 +24,53 @@ note: this expression returning a `std::io::Lines` may produce an infinite numbe
 LL |     BufReader::new(f).lines().flat_map(Result::ok).for_each(|_| ());
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
 
+error: `flatten()` will run forever if the iterator repeatedly produces an `Err`
+  --> $DIR/lines_filter_map_ok.rs:15:31
+   |
+LL |     BufReader::new(f).lines().flatten().for_each(|_| ());
+   |                               ^^^^^^^^^ help: replace with: `map_while(Result::ok)`
+   |
+note: this expression returning a `std::io::Lines` may produce an infinite number of `Err` in case of a read error
+  --> $DIR/lines_filter_map_ok.rs:15:5
+   |
+LL |     BufReader::new(f).lines().flatten().for_each(|_| ());
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
+
 error: `filter_map()` will run forever if the iterator repeatedly produces an `Err`
-  --> $DIR/lines_filter_map_ok.rs:15:25
+  --> $DIR/lines_filter_map_ok.rs:19:25
    |
 LL |     io::stdin().lines().filter_map(Result::ok).for_each(|_| ());
    |                         ^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `map_while(Result::ok)`
    |
 note: this expression returning a `std::io::Lines` may produce an infinite number of `Err` in case of a read error
-  --> $DIR/lines_filter_map_ok.rs:15:5
+  --> $DIR/lines_filter_map_ok.rs:19:5
    |
 LL |     io::stdin().lines().filter_map(Result::ok).for_each(|_| ());
    |     ^^^^^^^^^^^^^^^^^^^
 
 error: `filter_map()` will run forever if the iterator repeatedly produces an `Err`
-  --> $DIR/lines_filter_map_ok.rs:17:25
+  --> $DIR/lines_filter_map_ok.rs:21:25
    |
 LL |     io::stdin().lines().filter_map(|x| x.ok()).for_each(|_| ());
    |                         ^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `map_while(Result::ok)`
    |
 note: this expression returning a `std::io::Lines` may produce an infinite number of `Err` in case of a read error
-  --> $DIR/lines_filter_map_ok.rs:17:5
+  --> $DIR/lines_filter_map_ok.rs:21:5
    |
 LL |     io::stdin().lines().filter_map(|x| x.ok()).for_each(|_| ());
    |     ^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 4 previous errors
+error: `flatten()` will run forever if the iterator repeatedly produces an `Err`
+  --> $DIR/lines_filter_map_ok.rs:23:25
+   |
+LL |     io::stdin().lines().flatten().for_each(|_| ());
+   |                         ^^^^^^^^^ help: replace with: `map_while(Result::ok)`
+   |
+note: this expression returning a `std::io::Lines` may produce an infinite number of `Err` in case of a read error
+  --> $DIR/lines_filter_map_ok.rs:23:5
+   |
+LL |     io::stdin().lines().flatten().for_each(|_| ());
+   |     ^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 6 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 103200967e690d25eb8c042fd63f6abe848b0fdd Mon Sep 17 00:00:00 2001
From: sjwang05 <63834813+sjwang05@users.noreply.github.com>
Date: Mon, 30 Oct 2023 18:39:39 +0000
Subject: Use `match` on method args instead of `if let`

---
 clippy_lints/src/lines_filter_map_ok.rs | 42 +++++++++++++++++----------------
 1 file changed, 22 insertions(+), 20 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lines_filter_map_ok.rs b/clippy_lints/src/lines_filter_map_ok.rs
index 1449357e25c..f12d042ec66 100644
--- a/clippy_lints/src/lines_filter_map_ok.rs
+++ b/clippy_lints/src/lines_filter_map_ok.rs
@@ -65,27 +65,29 @@ impl LateLintPass<'_> for LinesFilterMapOk {
             matches!(fm_method_str, "filter_map" | "flat_map" | "flatten") &&
             is_type_diagnostic_item(cx, cx.typeck_results().expr_ty_adjusted(fm_receiver), sym::IoLines)
         {
-            let lint = if let [fm_arg] = fm_args {
-                match &fm_arg.kind {
-                    // Detect `Result::ok`
-                    ExprKind::Path(qpath) =>
-                        cx.qpath_res(qpath, fm_arg.hir_id).opt_def_id().map(|did|
-                            match_def_path(cx, did, &paths::CORE_RESULT_OK_METHOD)).unwrap_or_default(),
-                    // Detect `|x| x.ok()`
-                    ExprKind::Closure(Closure { body, .. }) =>
-                        if let Body { params: [param], value, .. } = cx.tcx.hir().body(*body) &&
-                            let ExprKind::MethodCall(method, receiver, [], _) = value.kind &&
-                            path_to_local_id(receiver, param.pat.hir_id) &&
-                            let Some(method_did) = cx.typeck_results().type_dependent_def_id(value.hir_id)
-                        {
-                            is_diag_item_method(cx, method_did, sym::Result) && method.ident.as_str() == "ok"
-                        } else {
-                            false
-                        },
-                    _ => false,
+            let lint = match fm_args {
+                [] => fm_method_str == "flatten",
+                [fm_arg] => {
+                    match &fm_arg.kind {
+                        // Detect `Result::ok`
+                        ExprKind::Path(qpath) =>
+                            cx.qpath_res(qpath, fm_arg.hir_id).opt_def_id().map(|did|
+                                match_def_path(cx, did, &paths::CORE_RESULT_OK_METHOD)).unwrap_or_default(),
+                        // Detect `|x| x.ok()`
+                        ExprKind::Closure(Closure { body, .. }) =>
+                            if let Body { params: [param], value, .. } = cx.tcx.hir().body(*body) &&
+                                let ExprKind::MethodCall(method, receiver, [], _) = value.kind &&
+                                path_to_local_id(receiver, param.pat.hir_id) &&
+                                let Some(method_did) = cx.typeck_results().type_dependent_def_id(value.hir_id)
+                            {
+                                is_diag_item_method(cx, method_did, sym::Result) && method.ident.as_str() == "ok"
+                            } else {
+                                false
+                            },
+                        _ => false,
+                    }
                 }
-            } else {
-                fm_method_str == "flatten"
+                _ => false,
             };
 
             if lint {
-- 
cgit 1.4.1-3-g733a5


From 10f3977ebaf384ffa1e99914fa8f7663e9399025 Mon Sep 17 00:00:00 2001
From: sjwang05 <63834813+sjwang05@users.noreply.github.com>
Date: Mon, 30 Oct 2023 19:12:03 +0000
Subject: Split arg/method checking into its own function

---
 clippy_lints/src/lines_filter_map_ok.rs | 106 +++++++++++++++++---------------
 1 file changed, 56 insertions(+), 50 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lines_filter_map_ok.rs b/clippy_lints/src/lines_filter_map_ok.rs
index f12d042ec66..39e5e271d73 100644
--- a/clippy_lints/src/lines_filter_map_ok.rs
+++ b/clippy_lints/src/lines_filter_map_ok.rs
@@ -59,59 +59,65 @@ declare_lint_pass!(LinesFilterMapOk => [LINES_FILTER_MAP_OK]);
 
 impl LateLintPass<'_> for LinesFilterMapOk {
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
-        if let ExprKind::MethodCall(fm_method, fm_receiver, fm_args, fm_span) = expr.kind &&
-            is_trait_method(cx, expr, sym::Iterator) &&
-            let fm_method_str = fm_method.ident.as_str() &&
-            matches!(fm_method_str, "filter_map" | "flat_map" | "flatten") &&
-            is_type_diagnostic_item(cx, cx.typeck_results().expr_ty_adjusted(fm_receiver), sym::IoLines)
+        if let ExprKind::MethodCall(fm_method, fm_receiver, fm_args, fm_span) = expr.kind
+            && is_trait_method(cx, expr, sym::Iterator)
+            && let fm_method_str = fm_method.ident.as_str()
+            && matches!(fm_method_str, "filter_map" | "flat_map" | "flatten")
+            && is_type_diagnostic_item(cx, cx.typeck_results().expr_ty_adjusted(fm_receiver), sym::IoLines)
+            && should_lint(cx, fm_args, fm_method_str)
         {
-            let lint = match fm_args {
-                [] => fm_method_str == "flatten",
-                [fm_arg] => {
-                    match &fm_arg.kind {
-                        // Detect `Result::ok`
-                        ExprKind::Path(qpath) =>
-                            cx.qpath_res(qpath, fm_arg.hir_id).opt_def_id().map(|did|
-                                match_def_path(cx, did, &paths::CORE_RESULT_OK_METHOD)).unwrap_or_default(),
-                        // Detect `|x| x.ok()`
-                        ExprKind::Closure(Closure { body, .. }) =>
-                            if let Body { params: [param], value, .. } = cx.tcx.hir().body(*body) &&
-                                let ExprKind::MethodCall(method, receiver, [], _) = value.kind &&
-                                path_to_local_id(receiver, param.pat.hir_id) &&
-                                let Some(method_did) = cx.typeck_results().type_dependent_def_id(value.hir_id)
-                            {
-                                is_diag_item_method(cx, method_did, sym::Result) && method.ident.as_str() == "ok"
-                            } else {
-                                false
-                            },
-                        _ => false,
+            span_lint_and_then(
+                cx,
+                LINES_FILTER_MAP_OK,
+                fm_span,
+                &format!(
+                    "`{}()` will run forever if the iterator repeatedly produces an `Err`",
+                    fm_method.ident
+                ),
+                |diag| {
+                    diag.span_note(
+                        fm_receiver.span,
+                        "this expression returning a `std::io::Lines` may produce an infinite number of `Err` in case of a read error");
+                    diag.span_suggestion(
+                        fm_span,
+                        "replace with",
+                        "map_while(Result::ok)",
+                        Applicability::MaybeIncorrect,
+                    );
+                },
+            );
+        }
+    }
+}
+
+fn should_lint(cx: &LateContext<'_>, args: &[Expr<'_>], method_str: &str) -> bool {
+    match args {
+        [] => method_str == "flatten",
+        [fm_arg] => {
+            match &fm_arg.kind {
+                // Detect `Result::ok`
+                ExprKind::Path(qpath) => cx
+                    .qpath_res(qpath, fm_arg.hir_id)
+                    .opt_def_id()
+                    .map(|did| match_def_path(cx, did, &paths::CORE_RESULT_OK_METHOD))
+                    .unwrap_or_default(),
+                // Detect `|x| x.ok()`
+                ExprKind::Closure(Closure { body, .. }) => {
+                    if let Body {
+                        params: [param], value, ..
+                    } = cx.tcx.hir().body(*body)
+                        && let ExprKind::MethodCall(method, receiver, [], _) = value.kind
+                        && path_to_local_id(receiver, param.pat.hir_id)
+                        && let Some(method_did) = cx.typeck_results().type_dependent_def_id(value.hir_id)
+                    {
+                        is_diag_item_method(cx, method_did, sym::Result) && method.ident.as_str() == "ok"
+                    } else {
+                        false
                     }
-                }
+                },
                 _ => false,
-            };
-
-            if lint {
-                span_lint_and_then(
-                    cx,
-                    LINES_FILTER_MAP_OK,
-                    fm_span,
-                    &format!(
-                        "`{}()` will run forever if the iterator repeatedly produces an `Err`",
-                        fm_method.ident
-                    ),
-                    |diag| {
-                        diag.span_note(
-                            fm_receiver.span,
-                            "this expression returning a `std::io::Lines` may produce an infinite number of `Err` in case of a read error");
-                        diag.span_suggestion(
-                            fm_span,
-                            "replace with",
-                            "map_while(Result::ok)",
-                            Applicability::MaybeIncorrect,
-                        );
-                    },
-                );
             }
-        }
+        },
+        _ => false,
     }
 }
-- 
cgit 1.4.1-3-g733a5


From c50af350a1bf2b120844fd1dc8dcca362ce437d5 Mon Sep 17 00:00:00 2001
From: sjwang05 <63834813+sjwang05@users.noreply.github.com>
Date: Fri, 3 Nov 2023 10:32:19 -0700
Subject: Use `fm_method_str` in lint formatting

Co-authored-by: Catherine Flores <catherine.3.flores@gmail.com>
---
 clippy_lints/src/lines_filter_map_ok.rs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lines_filter_map_ok.rs b/clippy_lints/src/lines_filter_map_ok.rs
index 39e5e271d73..eec65d6a1fd 100644
--- a/clippy_lints/src/lines_filter_map_ok.rs
+++ b/clippy_lints/src/lines_filter_map_ok.rs
@@ -71,8 +71,7 @@ impl LateLintPass<'_> for LinesFilterMapOk {
                 LINES_FILTER_MAP_OK,
                 fm_span,
                 &format!(
-                    "`{}()` will run forever if the iterator repeatedly produces an `Err`",
-                    fm_method.ident
+                    "`{fm_method_str}()` will run forever if the iterator repeatedly produces an `Err`",
                 ),
                 |diag| {
                     diag.span_note(
-- 
cgit 1.4.1-3-g733a5


From 294df80e2cdfbd16b9e5531b0581f8710b7b8862 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Fri, 3 Nov 2023 21:04:14 +0100
Subject: [`unused_enumerate_index`]: don't ICE on empty tuples

---
 clippy_lints/src/loops/unused_enumerate_index.rs | 6 +++---
 tests/ui/crashes/ice-11755.rs                    | 5 +++++
 2 files changed, 8 insertions(+), 3 deletions(-)
 create mode 100644 tests/ui/crashes/ice-11755.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/unused_enumerate_index.rs b/clippy_lints/src/loops/unused_enumerate_index.rs
index 62a2ab1ccb4..dd7fae79d9b 100644
--- a/clippy_lints/src/loops/unused_enumerate_index.rs
+++ b/clippy_lints/src/loops/unused_enumerate_index.rs
@@ -9,7 +9,7 @@ use rustc_middle::ty;
 
 /// Checks for the `UNUSED_ENUMERATE_INDEX` lint.
 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>, arg: &'tcx Expr<'_>, body: &'tcx Expr<'_>) {
-    let PatKind::Tuple(tuple, _) = pat.kind else {
+    let PatKind::Tuple([index, elem], _) = pat.kind else {
         return;
     };
 
@@ -19,7 +19,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>, arg: &'tcx
 
     let ty = cx.typeck_results().expr_ty(arg);
 
-    if !pat_is_wild(cx, &tuple[0].kind, body) {
+    if !pat_is_wild(cx, &index.kind, body) {
         return;
     }
 
@@ -53,7 +53,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>, arg: &'tcx
                 diag,
                 "remove the `.enumerate()` call",
                 vec![
-                    (pat.span, snippet(cx, tuple[1].span, "..").into_owned()),
+                    (pat.span, snippet(cx, elem.span, "..").into_owned()),
                     (arg.span, base_iter.to_string()),
                 ],
             );
diff --git a/tests/ui/crashes/ice-11755.rs b/tests/ui/crashes/ice-11755.rs
new file mode 100644
index 00000000000..367cb699857
--- /dev/null
+++ b/tests/ui/crashes/ice-11755.rs
@@ -0,0 +1,5 @@
+#![warn(clippy::unused_enumerate_index)]
+
+fn main() {
+    for () in [()].iter() {}
+}
-- 
cgit 1.4.1-3-g733a5


From 4388158d248a7a601de2b53a206a4281cc5d6d57 Mon Sep 17 00:00:00 2001
From: sjwang05 <63834813+sjwang05@users.noreply.github.com>
Date: Fri, 3 Nov 2023 13:48:04 -0700
Subject: Fix formatting

---
 clippy_lints/src/lines_filter_map_ok.rs | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lines_filter_map_ok.rs b/clippy_lints/src/lines_filter_map_ok.rs
index eec65d6a1fd..00ca553445f 100644
--- a/clippy_lints/src/lines_filter_map_ok.rs
+++ b/clippy_lints/src/lines_filter_map_ok.rs
@@ -70,9 +70,7 @@ impl LateLintPass<'_> for LinesFilterMapOk {
                 cx,
                 LINES_FILTER_MAP_OK,
                 fm_span,
-                &format!(
-                    "`{fm_method_str}()` will run forever if the iterator repeatedly produces an `Err`",
-                ),
+                &format!("`{fm_method_str}()` will run forever if the iterator repeatedly produces an `Err`",),
                 |diag| {
                     diag.span_note(
                         fm_receiver.span,
-- 
cgit 1.4.1-3-g733a5


From b9efa3ee2c71856ceccbca4063c7e6dcc0912500 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Sat, 4 Nov 2023 01:15:32 +0100
Subject: update references of `clippy_utils::msrvs` and
 `clippy_lints::util::conf`

---
 book/src/development/adding_lints.md | 10 +++++-----
 clippy_dev/src/new_lint.rs           |  4 ++--
 clippy_lints/src/types/mod.rs        |  2 +-
 3 files changed, 8 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/book/src/development/adding_lints.md b/book/src/development/adding_lints.md
index 55c0e105b30..3b26565369c 100644
--- a/book/src/development/adding_lints.md
+++ b/book/src/development/adding_lints.md
@@ -436,7 +436,7 @@ need to ensure that the MSRV configured for the project is >= the MSRV of the
 required Rust feature. If multiple features are required, just use the one with
 a lower MSRV.
 
-First, add an MSRV alias for the required feature in [`clippy_utils::msrvs`].
+First, add an MSRV alias for the required feature in [`clippy_config::msrvs`].
 This can be accessed later as `msrvs::STR_STRIP_PREFIX`, for example.
 
 ```rust
@@ -506,7 +506,7 @@ fn msrv_1_45() {
 ```
 
 As a last step, the lint should be added to the lint documentation. This is done
-in `clippy_lints/src/utils/conf.rs`:
+in `clippy_config/src/conf.rs`:
 
 ```rust
 define_Conf! {
@@ -516,7 +516,7 @@ define_Conf! {
 }
 ```
 
-[`clippy_utils::msrvs`]: https://doc.rust-lang.org/nightly/nightly-rustc/clippy_utils/msrvs/index.html
+[`clippy_config::msrvs`]: https://doc.rust-lang.org/nightly/nightly-rustc/clippy_config/msrvs/index.html
 
 ## Author lint
 
@@ -657,7 +657,7 @@ Adding a configuration to a lint can be useful for
 thresholds or to constrain some behavior that can be seen as a false positive
 for some users. Adding a configuration is done in the following steps:
 
-1. Adding a new configuration entry to [`clippy_lints::utils::conf`] like this:
+1. Adding a new configuration entry to [`clippy_config::conf`] like this:
 
    ```rust,ignore
    /// Lint: LINT_NAME.
@@ -736,7 +736,7 @@ for some users. Adding a configuration is done in the following steps:
 
    Run `cargo collect-metadata` to generate documentation changes for the book.
 
-[`clippy_lints::utils::conf`]: https://github.com/rust-lang/rust-clippy/blob/master/clippy_lints/src/utils/conf.rs
+[`clippy_config::conf`]: https://github.com/rust-lang/rust-clippy/blob/master/clippy_config/src/conf.rs
 [`clippy_lints` lib file]: https://github.com/rust-lang/rust-clippy/blob/master/clippy_lints/src/lib.rs
 [`tests/ui`]: https://github.com/rust-lang/rust-clippy/blob/master/tests/ui
 [`tests/ui-toml`]: https://github.com/rust-lang/rust-clippy/blob/master/tests/ui-toml
diff --git a/clippy_dev/src/new_lint.rs b/clippy_dev/src/new_lint.rs
index eeea53ce46f..ddc20f7f37f 100644
--- a/clippy_dev/src/new_lint.rs
+++ b/clippy_dev/src/new_lint.rs
@@ -320,8 +320,8 @@ fn get_lint_file_contents(lint: &LintData<'_>, enable_msrv: bool) -> String {
                 extract_msrv_attr!({context_import});
             }}
 
-            // TODO: Add MSRV level to `clippy_utils/src/msrvs.rs` if needed.
-            // TODO: Update msrv config comment in `clippy_lints/src/utils/conf.rs`
+            // TODO: Add MSRV level to `clippy_config/src/msrvs.rs` if needed.
+            // TODO: Update msrv config comment in `clippy_config/src/conf.rs`
         "#
         )
     } else {
diff --git a/clippy_lints/src/types/mod.rs b/clippy_lints/src/types/mod.rs
index 781e0aa22ed..3870936ef00 100644
--- a/clippy_lints/src/types/mod.rs
+++ b/clippy_lints/src/types/mod.rs
@@ -490,7 +490,7 @@ impl Types {
                         // All lints that are being checked in this block are guarded by
                         // the `avoid_breaking_exported_api` configuration. When adding a
                         // new lint, please also add the name to the configuration documentation
-                        // in `clippy_lints::utils::conf.rs`
+                        // in `clippy_config::conf`
 
                         let mut triggered = false;
                         triggered |= box_collection::check(cx, hir_ty, qpath, def_id);
-- 
cgit 1.4.1-3-g733a5


From 8c79f7840d399e3de52c63b1951a46adf6dda515 Mon Sep 17 00:00:00 2001
From: dswij <dswijj@gmail.com>
Date: Tue, 7 Nov 2023 17:57:31 +0800
Subject: `read_zero_byte_vec` refactor for better heuristics

---
 clippy_lints/src/read_zero_byte_vec.rs | 118 ++++++++++++++++++++-------------
 tests/ui/read_zero_byte_vec.rs         |  29 +++++---
 tests/ui/read_zero_byte_vec.stderr     |  34 ++++++----
 3 files changed, 112 insertions(+), 69 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/read_zero_byte_vec.rs b/clippy_lints/src/read_zero_byte_vec.rs
index b27d4cc6e4f..f5a8287d2e0 100644
--- a/clippy_lints/src/read_zero_byte_vec.rs
+++ b/clippy_lints/src/read_zero_byte_vec.rs
@@ -1,11 +1,13 @@
 use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg};
+use clippy_utils::get_enclosing_block;
 use clippy_utils::higher::{get_vec_init_kind, VecInitKind};
 use clippy_utils::source::snippet;
-use clippy_utils::visitors::for_each_expr;
-use core::ops::ControlFlow;
-use hir::{Expr, ExprKind, Local, PatKind, PathSegment, QPath, StmtKind};
+
+use hir::{Expr, ExprKind, HirId, Local, PatKind, PathSegment, QPath, StmtKind};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
+use rustc_hir::def::Res;
+use rustc_hir::intravisit::{walk_expr, Visitor};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 
@@ -49,57 +51,40 @@ declare_lint_pass!(ReadZeroByteVec => [READ_ZERO_BYTE_VEC]);
 
 impl<'tcx> LateLintPass<'tcx> for ReadZeroByteVec {
     fn check_block(&mut self, cx: &LateContext<'tcx>, block: &hir::Block<'tcx>) {
-        for (idx, stmt) in block.stmts.iter().enumerate() {
-            if !stmt.span.from_expansion()
-                // matches `let v = Vec::new();`
-                && let StmtKind::Local(local) = stmt.kind
-                && let Local { pat, init: Some(init), .. } = local
-                && let PatKind::Binding(_, _, ident, _) = pat.kind
+        for stmt in block.stmts {
+            if stmt.span.from_expansion() {
+                return;
+            }
+
+            if let StmtKind::Local(local) = stmt.kind
+                && let Local {
+                    pat, init: Some(init), ..
+                } = local
+                && let PatKind::Binding(_, id, ident, _) = pat.kind
                 && let Some(vec_init_kind) = get_vec_init_kind(cx, init)
             {
-                let visitor = |expr: &Expr<'_>| {
-                    if let ExprKind::MethodCall(path, _, [arg], _) = expr.kind
-                        && let PathSegment {
-                            ident: read_or_read_exact,
-                            ..
-                        } = *path
-                        && matches!(read_or_read_exact.as_str(), "read" | "read_exact")
-                        && let ExprKind::AddrOf(_, hir::Mutability::Mut, inner) = arg.kind
-                        && let ExprKind::Path(QPath::Resolved(None, inner_path)) = inner.kind
-                        && let [inner_seg] = inner_path.segments
-                        && ident.name == inner_seg.ident.name
-                    {
-                        ControlFlow::Break(())
-                    } else {
-                        ControlFlow::Continue(())
-                    }
+                let mut visitor = ReadVecVisitor {
+                    local_id: id,
+                    read_zero_expr: None,
+                    has_resize: false,
                 };
 
-                let (read_found, next_stmt_span) = if let Some(next_stmt) = block.stmts.get(idx + 1) {
-                    // case { .. stmt; stmt; .. }
-                    (for_each_expr(next_stmt, visitor).is_some(), next_stmt.span)
-                } else if let Some(e) = block.expr {
-                    // case { .. stmt; expr }
-                    (for_each_expr(e, visitor).is_some(), e.span)
-                } else {
+                let Some(enclosing_block) = get_enclosing_block(cx, id) else {
                     return;
                 };
+                visitor.visit_block(enclosing_block);
 
-                if read_found && !next_stmt_span.from_expansion() {
+                if let Some(expr) = visitor.read_zero_expr {
                     let applicability = Applicability::MaybeIncorrect;
                     match vec_init_kind {
                         VecInitKind::WithConstCapacity(len) => {
                             span_lint_and_sugg(
                                 cx,
                                 READ_ZERO_BYTE_VEC,
-                                next_stmt_span,
+                                expr.span,
                                 "reading zero byte data to `Vec`",
                                 "try",
-                                format!(
-                                    "{}.resize({len}, 0); {}",
-                                    ident.as_str(),
-                                    snippet(cx, next_stmt_span, "..")
-                                ),
+                                format!("{}.resize({len}, 0); {}", ident.as_str(), snippet(cx, expr.span, "..")),
                                 applicability,
                             );
                         },
@@ -108,25 +93,20 @@ impl<'tcx> LateLintPass<'tcx> for ReadZeroByteVec {
                             span_lint_and_sugg(
                                 cx,
                                 READ_ZERO_BYTE_VEC,
-                                next_stmt_span,
+                                expr.span,
                                 "reading zero byte data to `Vec`",
                                 "try",
                                 format!(
                                     "{}.resize({}, 0); {}",
                                     ident.as_str(),
                                     snippet(cx, e.span, ".."),
-                                    snippet(cx, next_stmt_span, "..")
+                                    snippet(cx, expr.span, "..")
                                 ),
                                 applicability,
                             );
                         },
                         _ => {
-                            span_lint(
-                                cx,
-                                READ_ZERO_BYTE_VEC,
-                                next_stmt_span,
-                                "reading zero byte data to `Vec`",
-                            );
+                            span_lint(cx, READ_ZERO_BYTE_VEC, expr.span, "reading zero byte data to `Vec`");
                         },
                     }
                 }
@@ -134,3 +114,47 @@ impl<'tcx> LateLintPass<'tcx> for ReadZeroByteVec {
         }
     }
 }
+
+struct ReadVecVisitor<'tcx> {
+    local_id: HirId,
+    read_zero_expr: Option<&'tcx Expr<'tcx>>,
+    has_resize: bool,
+}
+
+impl<'tcx> Visitor<'tcx> for ReadVecVisitor<'tcx> {
+    fn visit_expr(&mut self, e: &'tcx Expr<'tcx>) {
+        if let ExprKind::MethodCall(path, receiver, args, _) = e.kind {
+            let PathSegment { ident, .. } = *path;
+
+            match ident.as_str() {
+                "read" | "read_exact" => {
+                    let [arg] = args else { return };
+                    if let ExprKind::AddrOf(_, hir::Mutability::Mut, inner) = arg.kind
+                        && let ExprKind::Path(QPath::Resolved(None, inner_path)) = inner.kind
+                        && let [inner_seg] = inner_path.segments
+                        && let Res::Local(res_id) = inner_seg.res
+                        && self.local_id == res_id
+                    {
+                        self.read_zero_expr = Some(e);
+                        return;
+                    }
+                },
+                "resize" => {
+                    // If the Vec is resized, then it's a valid read
+                    if let ExprKind::Path(QPath::Resolved(_, inner_path)) = receiver.kind
+                        && let Res::Local(res_id) = inner_path.res
+                        && self.local_id == res_id
+                    {
+                        self.has_resize = true;
+                        return;
+                    }
+                },
+                _ => {},
+            }
+        }
+
+        if !self.has_resize && self.read_zero_expr.is_none() {
+            walk_expr(self, e);
+        }
+    }
+}
diff --git a/tests/ui/read_zero_byte_vec.rs b/tests/ui/read_zero_byte_vec.rs
index 76b9b981851..fd5a88a37a6 100644
--- a/tests/ui/read_zero_byte_vec.rs
+++ b/tests/ui/read_zero_byte_vec.rs
@@ -55,14 +55,6 @@ fn test() -> io::Result<()> {
     let mut buf = [0u8; 100];
     f.read(&mut buf)?;
 
-    // should not lint
-    let mut empty = vec![];
-    let mut data7 = vec![];
-    f.read(&mut empty);
-
-    // should not lint
-    f.read(&mut data7);
-
     // should not lint
     let mut data8 = Vec::new();
     data8.resize(100, 0);
@@ -75,6 +67,27 @@ fn test() -> io::Result<()> {
     Ok(())
 }
 
+fn test_nested() -> io::Result<()> {
+    let cap = 1000;
+    let mut f = File::open("foo.txt").unwrap();
+
+    // Issue #9274
+    // Should not lint
+    let mut v = Vec::new();
+    {
+        v.resize(10, 0);
+        f.read(&mut v)?;
+    }
+
+    let mut v = Vec::new();
+    {
+        f.read(&mut v)?;
+        //~^ ERROR: reading zero byte data to `Vec`
+    }
+
+    Ok(())
+}
+
 async fn test_futures<R: AsyncRead + Unpin>(r: &mut R) {
     // should lint
     let mut data = Vec::new();
diff --git a/tests/ui/read_zero_byte_vec.stderr b/tests/ui/read_zero_byte_vec.stderr
index 523ecb2948d..e85aa051c34 100644
--- a/tests/ui/read_zero_byte_vec.stderr
+++ b/tests/ui/read_zero_byte_vec.stderr
@@ -2,7 +2,7 @@ error: reading zero byte data to `Vec`
   --> $DIR/read_zero_byte_vec.rs:21:5
    |
 LL |     f.read_exact(&mut data).unwrap();
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `data.resize(20, 0); f.read_exact(&mut data).unwrap();`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^ help: try: `data.resize(20, 0); f.read_exact(&mut data)`
    |
    = note: `-D clippy::read-zero-byte-vec` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::read_zero_byte_vec)]`
@@ -11,19 +11,19 @@ error: reading zero byte data to `Vec`
   --> $DIR/read_zero_byte_vec.rs:27:5
    |
 LL |     f.read_exact(&mut data2)?;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `data2.resize(cap, 0); f.read_exact(&mut data2)?;`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `data2.resize(cap, 0); f.read_exact(&mut data2)`
 
 error: reading zero byte data to `Vec`
   --> $DIR/read_zero_byte_vec.rs:32:5
    |
 LL |     f.read_exact(&mut data3)?;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: reading zero byte data to `Vec`
-  --> $DIR/read_zero_byte_vec.rs:37:5
+  --> $DIR/read_zero_byte_vec.rs:37:13
    |
 LL |     let _ = f.read(&mut data4)?;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |             ^^^^^^^^^^^^^^^^^^
 
 error: reading zero byte data to `Vec`
   --> $DIR/read_zero_byte_vec.rs:43:9
@@ -38,28 +38,34 @@ LL |         f.read(&mut data6)
    |         ^^^^^^^^^^^^^^^^^^
 
 error: reading zero byte data to `Vec`
-  --> $DIR/read_zero_byte_vec.rs:81:5
+  --> $DIR/read_zero_byte_vec.rs:84:9
+   |
+LL |         f.read(&mut v)?;
+   |         ^^^^^^^^^^^^^^
+
+error: reading zero byte data to `Vec`
+  --> $DIR/read_zero_byte_vec.rs:94:5
    |
 LL |     r.read(&mut data).await.unwrap();
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^
 
 error: reading zero byte data to `Vec`
-  --> $DIR/read_zero_byte_vec.rs:86:5
+  --> $DIR/read_zero_byte_vec.rs:99:5
    |
 LL |     r.read_exact(&mut data2).await.unwrap();
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: reading zero byte data to `Vec`
-  --> $DIR/read_zero_byte_vec.rs:93:5
+  --> $DIR/read_zero_byte_vec.rs:106:5
    |
 LL |     r.read(&mut data).await.unwrap();
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^
 
 error: reading zero byte data to `Vec`
-  --> $DIR/read_zero_byte_vec.rs:98:5
+  --> $DIR/read_zero_byte_vec.rs:111:5
    |
 LL |     r.read_exact(&mut data2).await.unwrap();
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 10 previous errors
+error: aborting due to 11 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 73b9841a3e39ed84597ab9548616b46c80604116 Mon Sep 17 00:00:00 2001
From: Jacherr <jwc2002@outlook.com>
Date: Wed, 8 Nov 2023 17:41:28 +0000
Subject: remove unnecessary `find_map` calls

---
 clippy_lints/src/types/vec_box.rs | 63 +++++++++++++++++----------------------
 1 file changed, 27 insertions(+), 36 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types/vec_box.rs b/clippy_lints/src/types/vec_box.rs
index decc183ad96..89b5bd11f9f 100644
--- a/clippy_lints/src/types/vec_box.rs
+++ b/clippy_lints/src/types/vec_box.rs
@@ -1,7 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::last_path_segment;
 use clippy_utils::source::snippet;
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::def_id::DefId;
 use rustc_hir::{self as hir, GenericArg, QPath, TyKind};
@@ -21,45 +20,37 @@ pub(super) fn check(
     box_size_threshold: u64,
 ) -> bool {
     if cx.tcx.is_diagnostic_item(sym::Vec, def_id) {
-        if_chain! {
+        if let Some(last) = last_path_segment(qpath).args
             // Get the _ part of Vec<_>
-            if let Some(last) = last_path_segment(qpath).args;
-            if let Some(ty) = last.args.iter().find_map(|arg| match arg {
-                GenericArg::Type(ty) => Some(ty),
-                _ => None,
-            });
+            && let Some(GenericArg::Type(ty)) = last.args.first()
             // ty is now _ at this point
-            if let TyKind::Path(ref ty_qpath) = ty.kind;
-            let res = cx.qpath_res(ty_qpath, ty.hir_id);
-            if let Some(def_id) = res.opt_def_id();
-            if Some(def_id) == cx.tcx.lang_items().owned_box();
+            && let TyKind::Path(ref ty_qpath) = ty.kind
+            && let res = cx.qpath_res(ty_qpath, ty.hir_id)
+            && let Some(def_id) = res.opt_def_id()
+            && Some(def_id) == cx.tcx.lang_items().owned_box()
             // At this point, we know ty is Box<T>, now get T
-            if let Some(last) = last_path_segment(ty_qpath).args;
-            if let Some(boxed_ty) = last.args.iter().find_map(|arg| match arg {
-                GenericArg::Type(ty) => Some(ty),
-                _ => None,
-            });
-            let ty_ty = hir_ty_to_ty(cx.tcx, boxed_ty);
-            if !ty_ty.has_escaping_bound_vars();
-            if ty_ty.is_sized(cx.tcx, cx.param_env);
-            if let Ok(ty_ty_size) = cx.layout_of(ty_ty).map(|l| l.size.bytes());
-            if ty_ty_size < box_size_threshold;
-            then {
-                span_lint_and_sugg(
-                    cx,
-                    VEC_BOX,
-                    hir_ty.span,
-                    "`Vec<T>` is already on the heap, the boxing is unnecessary",
-                    "try",
-                    format!("Vec<{}>", snippet(cx, boxed_ty.span, "..")),
-                    Applicability::MachineApplicable,
-                );
-                true
-            } else {
-                false
-            }
+            && let Some(last) = last_path_segment(ty_qpath).args
+            && let Some(GenericArg::Type(boxed_ty)) = last.args.first()
+            && let ty_ty = hir_ty_to_ty(cx.tcx, boxed_ty)
+            && !ty_ty.has_escaping_bound_vars()
+            && ty_ty.is_sized(cx.tcx, cx.param_env)
+            && let Ok(ty_ty_size) = cx.layout_of(ty_ty).map(|l| l.size.bytes())
+            && ty_ty_size < box_size_threshold
+        {
+            span_lint_and_sugg(
+                cx,
+                VEC_BOX,
+                hir_ty.span,
+                "`Vec<T>` is already on the heap, the boxing is unnecessary",
+                "try",
+                format!("Vec<{}>", snippet(cx, boxed_ty.span, "..")),
+                Applicability::MachineApplicable,
+            );
+            true
+        } else {
+            false
         }
     } else {
         false
     }
-}
+}
\ No newline at end of file
-- 
cgit 1.4.1-3-g733a5


From 3a91a1174094b7b5da241076d26026af873408be Mon Sep 17 00:00:00 2001
From: Jacherr <jwc2002@outlook.com>
Date: Wed, 8 Nov 2023 18:27:33 +0000
Subject: add logic to check allocator matching

---
 clippy_lints/src/types/vec_box.rs | 15 ++++++++++++++-
 1 file changed, 14 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types/vec_box.rs b/clippy_lints/src/types/vec_box.rs
index 89b5bd11f9f..25e5b886681 100644
--- a/clippy_lints/src/types/vec_box.rs
+++ b/clippy_lints/src/types/vec_box.rs
@@ -23,6 +23,8 @@ pub(super) fn check(
         if let Some(last) = last_path_segment(qpath).args
             // Get the _ part of Vec<_>
             && let Some(GenericArg::Type(ty)) = last.args.first()
+            // extract allocator from the Vec for later
+            && let vec_alloc_ty = last.args.get(1)
             // ty is now _ at this point
             && let TyKind::Path(ref ty_qpath) = ty.kind
             && let res = cx.qpath_res(ty_qpath, ty.hir_id)
@@ -30,12 +32,23 @@ pub(super) fn check(
             && Some(def_id) == cx.tcx.lang_items().owned_box()
             // At this point, we know ty is Box<T>, now get T
             && let Some(last) = last_path_segment(ty_qpath).args
+            // extract allocator from thr Box for later
             && let Some(GenericArg::Type(boxed_ty)) = last.args.first()
+            && let boxed_alloc_ty = last.args.get(1)
             && let ty_ty = hir_ty_to_ty(cx.tcx, boxed_ty)
             && !ty_ty.has_escaping_bound_vars()
             && ty_ty.is_sized(cx.tcx, cx.param_env)
             && let Ok(ty_ty_size) = cx.layout_of(ty_ty).map(|l| l.size.bytes())
             && ty_ty_size < box_size_threshold
+            // https://github.com/rust-lang/rust-clippy/issues/7114
+            // this code also does not consider that Global can be explicitly
+            // defined (yet) as in Vec<_, Global> so a very slight false negative edge case
+            && match (vec_alloc_ty, boxed_alloc_ty) {
+                (None, None) => true,
+                (Some(GenericArg::Type(l)), Some(GenericArg::Type(r))) =>
+                    hir_ty_to_ty(cx.tcx, l) == hir_ty_to_ty(cx.tcx, r),
+                _ => false
+            }
         {
             span_lint_and_sugg(
                 cx,
@@ -53,4 +66,4 @@ pub(super) fn check(
     } else {
         false
     }
-}
\ No newline at end of file
+}
-- 
cgit 1.4.1-3-g733a5


From 399fe32893ea74b815b01c505ddac3b02d08bd27 Mon Sep 17 00:00:00 2001
From: PartiallyTyped <me@partiallytyped.dev>
Date: Tue, 7 Nov 2023 23:34:36 +0100
Subject: [arc_with_non_send_sync] Improve suggested resolution
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Fixes: #11714
changelog: [`arc_with_non_send_sync`]: Suggest RC over unsafe impl

Co-authored-by: Alejandra González <blyxyas@gmail.com>
---
 clippy_lints/src/arc_with_non_send_sync.rs | 22 +++++++++++++-------
 tests/ui/arc_with_non_send_sync.rs         |  6 +++---
 tests/ui/arc_with_non_send_sync.stderr     | 32 ++++++++++++++++++------------
 3 files changed, 37 insertions(+), 23 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/arc_with_non_send_sync.rs b/clippy_lints/src/arc_with_non_send_sync.rs
index 192bc7d9ddc..9799e703afe 100644
--- a/clippy_lints/src/arc_with_non_send_sync.rs
+++ b/clippy_lints/src/arc_with_non_send_sync.rs
@@ -14,7 +14,9 @@ declare_clippy_lint! {
     /// This lint warns when you use `Arc` with a type that does not implement `Send` or `Sync`.
     ///
     /// ### Why is this bad?
-    /// `Arc<T>` is only `Send`/`Sync` when `T` is [both `Send` and `Sync`](https://doc.rust-lang.org/std/sync/struct.Arc.html#impl-Send-for-Arc%3CT%3E),
+    /// `Arc<T>` is an Atomic `RC<T>` and guarantees that updates to the reference counter are
+    /// Atomic. This is useful in multiprocessing scenarios. To send an `Arc<T>` across processes
+    /// and make use of the atomic ref counter, `T` must be [both `Send` and `Sync`](https://doc.rust-lang.org/std/sync/struct.Arc.html#impl-Send-for-Arc%3CT%3E),
     /// either `T` should be made `Send + Sync` or an `Rc` should be used instead of an `Arc`
     ///
     /// ### Example
@@ -34,7 +36,7 @@ declare_clippy_lint! {
     #[clippy::version = "1.72.0"]
     pub ARC_WITH_NON_SEND_SYNC,
     suspicious,
-    "using `Arc` with a type that does not implement `Send` or `Sync`"
+    "using `Arc` with a type that does not implement `Send` and `Sync`"
 }
 declare_lint_pass!(ArcWithNonSendSync => [ARC_WITH_NON_SEND_SYNC]);
 
@@ -61,19 +63,25 @@ impl<'tcx> LateLintPass<'tcx> for ArcWithNonSendSync {
                 cx,
                 ARC_WITH_NON_SEND_SYNC,
                 expr.span,
-                "usage of an `Arc` that is not `Send` or `Sync`",
+                "usage of an `Arc` that is not `Send` and `Sync`",
                 |diag| {
                     with_forced_trimmed_paths!({
+                        diag.note(format!("`Arc<{arg_ty}>` is not `Send` and `Sync` as:"));
+
                         if !is_send {
-                            diag.note(format!("the trait `Send` is not implemented for `{arg_ty}`"));
+                            diag.note(format!("- the trait `Send` is not implemented for `{arg_ty}`"));
                         }
                         if !is_sync {
-                            diag.note(format!("the trait `Sync` is not implemented for `{arg_ty}`"));
+                            diag.note(format!("- the trait `Sync` is not implemented for `{arg_ty}`"));
                         }
 
-                        diag.note(format!("required for `{ty}` to implement `Send` and `Sync`"));
+                        diag.help("consider using an `Rc` instead. `Arc` does not provide benefits for non `Send` and `Sync` types");
+
+                        diag.note("if you intend to use `Arc` with `Send` and `Sync` traits");
 
-                        diag.help("consider using an `Rc` instead or wrapping the inner type with a `Mutex`");
+                        diag.note(format!(
+                            "wrap the inner type with a `Mutex` or implement `Send` and `Sync` for `{arg_ty}`"
+                        ));
                     });
                 },
             );
diff --git a/tests/ui/arc_with_non_send_sync.rs b/tests/ui/arc_with_non_send_sync.rs
index d03a577c454..349e81912e3 100644
--- a/tests/ui/arc_with_non_send_sync.rs
+++ b/tests/ui/arc_with_non_send_sync.rs
@@ -33,16 +33,16 @@ fn main() {
     let _ = Arc::new(42);
 
     let _ = Arc::new(RefCell::new(42));
-    //~^ ERROR: usage of an `Arc` that is not `Send` or `Sync`
+    //~^ ERROR: usage of an `Arc` that is not `Send` and `Sync`
     //~| NOTE: the trait `Sync` is not implemented for `RefCell<i32>`
 
     let mutex = Mutex::new(1);
     let _ = Arc::new(mutex.lock().unwrap());
-    //~^ ERROR: usage of an `Arc` that is not `Send` or `Sync`
+    //~^ ERROR: usage of an `Arc` that is not `Send` and `Sync`
     //~| NOTE: the trait `Send` is not implemented for `MutexGuard<'_, i32>`
 
     let _ = Arc::new(&42 as *const i32);
-    //~^ ERROR: usage of an `Arc` that is not `Send` or `Sync`
+    //~^ ERROR: usage of an `Arc` that is not `Send` and `Sync`
     //~| NOTE: the trait `Send` is not implemented for `*const i32`
     //~| NOTE: the trait `Sync` is not implemented for `*const i32`
 }
diff --git a/tests/ui/arc_with_non_send_sync.stderr b/tests/ui/arc_with_non_send_sync.stderr
index fd239580d28..a7f91abda4e 100644
--- a/tests/ui/arc_with_non_send_sync.stderr
+++ b/tests/ui/arc_with_non_send_sync.stderr
@@ -1,35 +1,41 @@
-error: usage of an `Arc` that is not `Send` or `Sync`
+error: usage of an `Arc` that is not `Send` and `Sync`
   --> $DIR/arc_with_non_send_sync.rs:35:13
    |
 LL |     let _ = Arc::new(RefCell::new(42));
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = note: the trait `Sync` is not implemented for `RefCell<i32>`
-   = note: required for `Arc<RefCell<i32>>` to implement `Send` and `Sync`
-   = help: consider using an `Rc` instead or wrapping the inner type with a `Mutex`
+   = note: `Arc<RefCell<i32>>` is not `Send` and `Sync` as:
+   = note: - the trait `Sync` is not implemented for `RefCell<i32>`
+   = help: consider using an `Rc` instead. `Arc` does not provide benefits for non `Send` and `Sync` types
+   = note: if you intend to use `Arc` with `Send` and `Sync` traits
+   = note: wrap the inner type with a `Mutex` or implement `Send` and `Sync` for `RefCell<i32>`
    = note: `-D clippy::arc-with-non-send-sync` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::arc_with_non_send_sync)]`
 
-error: usage of an `Arc` that is not `Send` or `Sync`
+error: usage of an `Arc` that is not `Send` and `Sync`
   --> $DIR/arc_with_non_send_sync.rs:40:13
    |
 LL |     let _ = Arc::new(mutex.lock().unwrap());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = note: the trait `Send` is not implemented for `MutexGuard<'_, i32>`
-   = note: required for `Arc<MutexGuard<'_, i32>>` to implement `Send` and `Sync`
-   = help: consider using an `Rc` instead or wrapping the inner type with a `Mutex`
+   = note: `Arc<MutexGuard<'_, i32>>` is not `Send` and `Sync` as:
+   = note: - the trait `Send` is not implemented for `MutexGuard<'_, i32>`
+   = help: consider using an `Rc` instead. `Arc` does not provide benefits for non `Send` and `Sync` types
+   = note: if you intend to use `Arc` with `Send` and `Sync` traits
+   = note: wrap the inner type with a `Mutex` or implement `Send` and `Sync` for `MutexGuard<'_, i32>`
 
-error: usage of an `Arc` that is not `Send` or `Sync`
+error: usage of an `Arc` that is not `Send` and `Sync`
   --> $DIR/arc_with_non_send_sync.rs:44:13
    |
 LL |     let _ = Arc::new(&42 as *const i32);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = note: the trait `Send` is not implemented for `*const i32`
-   = note: the trait `Sync` is not implemented for `*const i32`
-   = note: required for `Arc<*const i32>` to implement `Send` and `Sync`
-   = help: consider using an `Rc` instead or wrapping the inner type with a `Mutex`
+   = note: `Arc<*const i32>` is not `Send` and `Sync` as:
+   = note: - the trait `Send` is not implemented for `*const i32`
+   = note: - the trait `Sync` is not implemented for `*const i32`
+   = help: consider using an `Rc` instead. `Arc` does not provide benefits for non `Send` and `Sync` types
+   = note: if you intend to use `Arc` with `Send` and `Sync` traits
+   = note: wrap the inner type with a `Mutex` or implement `Send` and `Sync` for `*const i32`
 
 error: aborting due to 3 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 79325604da4b0000b7bd6c6fb6553f108a5983d7 Mon Sep 17 00:00:00 2001
From: Jacherr <jwc2002@outlook.com>
Date: Wed, 8 Nov 2023 18:42:58 +0000
Subject: update testcases, cleanup

---
 clippy_lints/src/types/vec_box.rs |  2 +-
 tests/ui/vec_box_sized.fixed      | 17 +++++++++++++++++
 tests/ui/vec_box_sized.rs         | 17 +++++++++++++++++
 tests/ui/vec_box_sized.stderr     | 12 ++++++------
 4 files changed, 41 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types/vec_box.rs b/clippy_lints/src/types/vec_box.rs
index 25e5b886681..887439560d1 100644
--- a/clippy_lints/src/types/vec_box.rs
+++ b/clippy_lints/src/types/vec_box.rs
@@ -32,8 +32,8 @@ pub(super) fn check(
             && Some(def_id) == cx.tcx.lang_items().owned_box()
             // At this point, we know ty is Box<T>, now get T
             && let Some(last) = last_path_segment(ty_qpath).args
-            // extract allocator from thr Box for later
             && let Some(GenericArg::Type(boxed_ty)) = last.args.first()
+            // extract allocator from the Box for later
             && let boxed_alloc_ty = last.args.get(1)
             && let ty_ty = hir_ty_to_ty(cx.tcx, boxed_ty)
             && !ty_ty.has_escaping_bound_vars()
diff --git a/tests/ui/vec_box_sized.fixed b/tests/ui/vec_box_sized.fixed
index 4363d2224af..67067de91cc 100644
--- a/tests/ui/vec_box_sized.fixed
+++ b/tests/ui/vec_box_sized.fixed
@@ -1,4 +1,5 @@
 #![allow(dead_code)]
+#![feature(allocator_api)]
 
 struct SizedStruct(i32);
 struct UnsizedStruct([i32]);
@@ -21,6 +22,8 @@ mod should_trigger {
 /// The following should not trigger the lint
 mod should_not_trigger {
     use super::{BigStruct, UnsizedStruct};
+    use std::alloc::{Layout, AllocError, Allocator};
+    use std::ptr::NonNull;
 
     struct C(Vec<Box<UnsizedStruct>>);
     struct D(Vec<Box<BigStruct>>);
@@ -33,6 +36,20 @@ mod should_not_trigger {
         // Regression test for #3720. This was causing an ICE.
         inner: Vec<Box<T>>,
     }
+
+    struct DummyAllocator;
+    unsafe impl Allocator for DummyAllocator {
+        fn allocate(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError> {
+            todo!()
+        }
+        unsafe fn deallocate(&self, ptr: NonNull<u8>, layout: Layout) {
+            todo!()
+        }
+    }
+
+    fn allocator_mismatch() -> Vec<Box<i32, DummyAllocator>> {
+        vec![]
+    }
 }
 
 mod inner_mod {
diff --git a/tests/ui/vec_box_sized.rs b/tests/ui/vec_box_sized.rs
index f4e27fe4bd5..2b5c2c99945 100644
--- a/tests/ui/vec_box_sized.rs
+++ b/tests/ui/vec_box_sized.rs
@@ -1,4 +1,5 @@
 #![allow(dead_code)]
+#![feature(allocator_api)]
 
 struct SizedStruct(i32);
 struct UnsizedStruct([i32]);
@@ -21,6 +22,8 @@ mod should_trigger {
 /// The following should not trigger the lint
 mod should_not_trigger {
     use super::{BigStruct, UnsizedStruct};
+    use std::alloc::{Layout, AllocError, Allocator};
+    use std::ptr::NonNull;
 
     struct C(Vec<Box<UnsizedStruct>>);
     struct D(Vec<Box<BigStruct>>);
@@ -33,6 +36,20 @@ mod should_not_trigger {
         // Regression test for #3720. This was causing an ICE.
         inner: Vec<Box<T>>,
     }
+
+    struct DummyAllocator;
+    unsafe impl Allocator for DummyAllocator {
+        fn allocate(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError> {
+            todo!()
+        }
+        unsafe fn deallocate(&self, ptr: NonNull<u8>, layout: Layout) {
+            todo!()
+        }
+    }
+
+    fn allocator_mismatch() -> Vec<Box<i32, DummyAllocator>> {
+        vec![]
+    }
 }
 
 mod inner_mod {
diff --git a/tests/ui/vec_box_sized.stderr b/tests/ui/vec_box_sized.stderr
index 9118f284bb9..0e68aa57dcb 100644
--- a/tests/ui/vec_box_sized.stderr
+++ b/tests/ui/vec_box_sized.stderr
@@ -1,5 +1,5 @@
 error: `Vec<T>` is already on the heap, the boxing is unnecessary
-  --> $DIR/vec_box_sized.rs:10:14
+  --> $DIR/vec_box_sized.rs:11:14
    |
 LL |     const C: Vec<Box<i32>> = Vec::new();
    |              ^^^^^^^^^^^^^ help: try: `Vec<i32>`
@@ -8,31 +8,31 @@ LL |     const C: Vec<Box<i32>> = Vec::new();
    = help: to override `-D warnings` add `#[allow(clippy::vec_box)]`
 
 error: `Vec<T>` is already on the heap, the boxing is unnecessary
-  --> $DIR/vec_box_sized.rs:11:15
+  --> $DIR/vec_box_sized.rs:12:15
    |
 LL |     static S: Vec<Box<i32>> = Vec::new();
    |               ^^^^^^^^^^^^^ help: try: `Vec<i32>`
 
 error: `Vec<T>` is already on the heap, the boxing is unnecessary
-  --> $DIR/vec_box_sized.rs:14:21
+  --> $DIR/vec_box_sized.rs:15:21
    |
 LL |         sized_type: Vec<Box<SizedStruct>>,
    |                     ^^^^^^^^^^^^^^^^^^^^^ help: try: `Vec<SizedStruct>`
 
 error: `Vec<T>` is already on the heap, the boxing is unnecessary
-  --> $DIR/vec_box_sized.rs:17:14
+  --> $DIR/vec_box_sized.rs:18:14
    |
 LL |     struct A(Vec<Box<SizedStruct>>);
    |              ^^^^^^^^^^^^^^^^^^^^^ help: try: `Vec<SizedStruct>`
 
 error: `Vec<T>` is already on the heap, the boxing is unnecessary
-  --> $DIR/vec_box_sized.rs:18:18
+  --> $DIR/vec_box_sized.rs:19:18
    |
 LL |     struct B(Vec<Vec<Box<(u32)>>>);
    |                  ^^^^^^^^^^^^^^^ help: try: `Vec<u32>`
 
 error: `Vec<T>` is already on the heap, the boxing is unnecessary
-  --> $DIR/vec_box_sized.rs:46:23
+  --> $DIR/vec_box_sized.rs:63:23
    |
 LL |         pub fn f() -> Vec<Box<S>> {
    |                       ^^^^^^^^^^^ help: try: `Vec<S>`
-- 
cgit 1.4.1-3-g733a5


From 67bb503f26ad5d695229153995bd2ab296e590cb Mon Sep 17 00:00:00 2001
From: Jacherr <jwc2002@outlook.com>
Date: Wed, 8 Nov 2023 21:10:27 +0000
Subject: add support for std::alloc::Global, add more tests

---
 clippy_lints/src/types/vec_box.rs | 18 +++++++++++++----
 clippy_utils/src/paths.rs         |  1 +
 tests/ui/vec_box_sized.fixed      | 41 +++++++++++++++++++++++++--------------
 tests/ui/vec_box_sized.rs         | 41 +++++++++++++++++++++++++--------------
 tests/ui/vec_box_sized.stderr     | 32 +++++++++++++++++++++++-------
 5 files changed, 92 insertions(+), 41 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types/vec_box.rs b/clippy_lints/src/types/vec_box.rs
index 887439560d1..43f72f1031d 100644
--- a/clippy_lints/src/types/vec_box.rs
+++ b/clippy_lints/src/types/vec_box.rs
@@ -1,5 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::last_path_segment;
+use clippy_utils::{last_path_segment, match_def_path};
+use clippy_utils::paths::ALLOCATOR_GLOBAL;
 use clippy_utils::source::snippet;
 use rustc_errors::Applicability;
 use rustc_hir::def_id::DefId;
@@ -41,10 +42,19 @@ pub(super) fn check(
             && let Ok(ty_ty_size) = cx.layout_of(ty_ty).map(|l| l.size.bytes())
             && ty_ty_size < box_size_threshold
             // https://github.com/rust-lang/rust-clippy/issues/7114
-            // this code also does not consider that Global can be explicitly
-            // defined (yet) as in Vec<_, Global> so a very slight false negative edge case
             && match (vec_alloc_ty, boxed_alloc_ty) {
                 (None, None) => true,
+                // this is in the event that we have something like
+                // Vec<_, Global>, in which case is equivalent to
+                // Vec<_>
+                (None, Some(GenericArg::Type(inner))) | (Some(GenericArg::Type(inner)), None) => {
+                    if let TyKind::Path(path) = inner.kind
+                        && let Some(did) = cx.qpath_res(&path, inner.hir_id).opt_def_id() {
+                        match_def_path(cx, did, &ALLOCATOR_GLOBAL)
+                    } else {
+                        true
+                    }
+                },
                 (Some(GenericArg::Type(l)), Some(GenericArg::Type(r))) =>
                     hir_ty_to_ty(cx.tcx, l) == hir_ty_to_ty(cx.tcx, r),
                 _ => false
@@ -57,7 +67,7 @@ pub(super) fn check(
                 "`Vec<T>` is already on the heap, the boxing is unnecessary",
                 "try",
                 format!("Vec<{}>", snippet(cx, boxed_ty.span, "..")),
-                Applicability::MachineApplicable,
+                Applicability::Unspecified,
             );
             true
         } else {
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index 5bca554378e..bde8eb892e9 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -99,3 +99,4 @@ pub const OPTION_UNWRAP: [&str; 4] = ["core", "option", "Option", "unwrap"];
 pub const OPTION_EXPECT: [&str; 4] = ["core", "option", "Option", "expect"];
 #[expect(clippy::invalid_paths)] // not sure why it thinks this, it works so
 pub const BOOL_THEN: [&str; 4] = ["core", "bool", "<impl bool>", "then"];
+pub const ALLOCATOR_GLOBAL: [&str; 3] = ["alloc", "alloc", "Global"];
\ No newline at end of file
diff --git a/tests/ui/vec_box_sized.fixed b/tests/ui/vec_box_sized.fixed
index 67067de91cc..0be891a92bc 100644
--- a/tests/ui/vec_box_sized.fixed
+++ b/tests/ui/vec_box_sized.fixed
@@ -1,13 +1,26 @@
 #![allow(dead_code)]
 #![feature(allocator_api)]
 
+use std::alloc::{Layout, AllocError, Allocator};
+use std::ptr::NonNull;
+
 struct SizedStruct(i32);
 struct UnsizedStruct([i32]);
 struct BigStruct([i32; 10000]);
 
+struct DummyAllocator;
+unsafe impl Allocator for DummyAllocator {
+    fn allocate(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError> {
+        todo!()
+    }
+    unsafe fn deallocate(&self, ptr: NonNull<u8>, layout: Layout) {
+        todo!()
+    }
+}
+
 /// The following should trigger the lint
 mod should_trigger {
-    use super::SizedStruct;
+    use super::{SizedStruct, DummyAllocator};
     const C: Vec<i32> = Vec::new();
     static S: Vec<i32> = Vec::new();
 
@@ -17,13 +30,21 @@ mod should_trigger {
 
     struct A(Vec<SizedStruct>);
     struct B(Vec<Vec<u32>>);
+
+    fn allocator_global_defined_vec() -> Vec<i32> {
+        Vec::new()
+    }
+    fn allocator_global_defined_box() -> Vec<i32> {
+        Vec::new()
+    }
+    fn allocator_match() -> Vec<i32> {
+        Vec::new_in(DummyAllocator)
+    }
 }
 
 /// The following should not trigger the lint
 mod should_not_trigger {
-    use super::{BigStruct, UnsizedStruct};
-    use std::alloc::{Layout, AllocError, Allocator};
-    use std::ptr::NonNull;
+    use super::{BigStruct, UnsizedStruct, DummyAllocator};
 
     struct C(Vec<Box<UnsizedStruct>>);
     struct D(Vec<Box<BigStruct>>);
@@ -37,18 +58,8 @@ mod should_not_trigger {
         inner: Vec<Box<T>>,
     }
 
-    struct DummyAllocator;
-    unsafe impl Allocator for DummyAllocator {
-        fn allocate(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError> {
-            todo!()
-        }
-        unsafe fn deallocate(&self, ptr: NonNull<u8>, layout: Layout) {
-            todo!()
-        }
-    }
-
     fn allocator_mismatch() -> Vec<Box<i32, DummyAllocator>> {
-        vec![]
+        Vec::new()
     }
 }
 
diff --git a/tests/ui/vec_box_sized.rs b/tests/ui/vec_box_sized.rs
index 2b5c2c99945..9314195b103 100644
--- a/tests/ui/vec_box_sized.rs
+++ b/tests/ui/vec_box_sized.rs
@@ -1,13 +1,26 @@
 #![allow(dead_code)]
 #![feature(allocator_api)]
 
+use std::alloc::{Layout, AllocError, Allocator};
+use std::ptr::NonNull;
+
 struct SizedStruct(i32);
 struct UnsizedStruct([i32]);
 struct BigStruct([i32; 10000]);
 
+struct DummyAllocator;
+unsafe impl Allocator for DummyAllocator {
+    fn allocate(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError> {
+        todo!()
+    }
+    unsafe fn deallocate(&self, ptr: NonNull<u8>, layout: Layout) {
+        todo!()
+    }
+}
+
 /// The following should trigger the lint
 mod should_trigger {
-    use super::SizedStruct;
+    use super::{SizedStruct, DummyAllocator};
     const C: Vec<Box<i32>> = Vec::new();
     static S: Vec<Box<i32>> = Vec::new();
 
@@ -17,13 +30,21 @@ mod should_trigger {
 
     struct A(Vec<Box<SizedStruct>>);
     struct B(Vec<Vec<Box<(u32)>>>);
+
+    fn allocator_global_defined_vec() -> Vec<Box<i32>, std::alloc::Global> {
+        Vec::new()
+    }
+    fn allocator_global_defined_box() -> Vec<Box<i32, std::alloc::Global>> {
+        Vec::new()
+    }
+    fn allocator_match() -> Vec<Box<i32, DummyAllocator>, DummyAllocator> {
+        Vec::new_in(DummyAllocator)
+    }
 }
 
 /// The following should not trigger the lint
 mod should_not_trigger {
-    use super::{BigStruct, UnsizedStruct};
-    use std::alloc::{Layout, AllocError, Allocator};
-    use std::ptr::NonNull;
+    use super::{BigStruct, UnsizedStruct, DummyAllocator};
 
     struct C(Vec<Box<UnsizedStruct>>);
     struct D(Vec<Box<BigStruct>>);
@@ -37,18 +58,8 @@ mod should_not_trigger {
         inner: Vec<Box<T>>,
     }
 
-    struct DummyAllocator;
-    unsafe impl Allocator for DummyAllocator {
-        fn allocate(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError> {
-            todo!()
-        }
-        unsafe fn deallocate(&self, ptr: NonNull<u8>, layout: Layout) {
-            todo!()
-        }
-    }
-
     fn allocator_mismatch() -> Vec<Box<i32, DummyAllocator>> {
-        vec![]
+        Vec::new()
     }
 }
 
diff --git a/tests/ui/vec_box_sized.stderr b/tests/ui/vec_box_sized.stderr
index 0e68aa57dcb..2fa5679650b 100644
--- a/tests/ui/vec_box_sized.stderr
+++ b/tests/ui/vec_box_sized.stderr
@@ -1,5 +1,5 @@
 error: `Vec<T>` is already on the heap, the boxing is unnecessary
-  --> $DIR/vec_box_sized.rs:11:14
+  --> $DIR/vec_box_sized.rs:24:14
    |
 LL |     const C: Vec<Box<i32>> = Vec::new();
    |              ^^^^^^^^^^^^^ help: try: `Vec<i32>`
@@ -8,34 +8,52 @@ LL |     const C: Vec<Box<i32>> = Vec::new();
    = help: to override `-D warnings` add `#[allow(clippy::vec_box)]`
 
 error: `Vec<T>` is already on the heap, the boxing is unnecessary
-  --> $DIR/vec_box_sized.rs:12:15
+  --> $DIR/vec_box_sized.rs:25:15
    |
 LL |     static S: Vec<Box<i32>> = Vec::new();
    |               ^^^^^^^^^^^^^ help: try: `Vec<i32>`
 
 error: `Vec<T>` is already on the heap, the boxing is unnecessary
-  --> $DIR/vec_box_sized.rs:15:21
+  --> $DIR/vec_box_sized.rs:28:21
    |
 LL |         sized_type: Vec<Box<SizedStruct>>,
    |                     ^^^^^^^^^^^^^^^^^^^^^ help: try: `Vec<SizedStruct>`
 
 error: `Vec<T>` is already on the heap, the boxing is unnecessary
-  --> $DIR/vec_box_sized.rs:18:14
+  --> $DIR/vec_box_sized.rs:31:14
    |
 LL |     struct A(Vec<Box<SizedStruct>>);
    |              ^^^^^^^^^^^^^^^^^^^^^ help: try: `Vec<SizedStruct>`
 
 error: `Vec<T>` is already on the heap, the boxing is unnecessary
-  --> $DIR/vec_box_sized.rs:19:18
+  --> $DIR/vec_box_sized.rs:32:18
    |
 LL |     struct B(Vec<Vec<Box<(u32)>>>);
    |                  ^^^^^^^^^^^^^^^ help: try: `Vec<u32>`
 
 error: `Vec<T>` is already on the heap, the boxing is unnecessary
-  --> $DIR/vec_box_sized.rs:63:23
+  --> $DIR/vec_box_sized.rs:34:42
+   |
+LL |     fn allocator_global_defined_vec() -> Vec<Box<i32>, std::alloc::Global> {
+   |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Vec<i32>`
+
+error: `Vec<T>` is already on the heap, the boxing is unnecessary
+  --> $DIR/vec_box_sized.rs:37:42
+   |
+LL |     fn allocator_global_defined_box() -> Vec<Box<i32, std::alloc::Global>> {
+   |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Vec<i32>`
+
+error: `Vec<T>` is already on the heap, the boxing is unnecessary
+  --> $DIR/vec_box_sized.rs:40:29
+   |
+LL |     fn allocator_match() -> Vec<Box<i32, DummyAllocator>, DummyAllocator> {
+   |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Vec<i32>`
+
+error: `Vec<T>` is already on the heap, the boxing is unnecessary
+  --> $DIR/vec_box_sized.rs:74:23
    |
 LL |         pub fn f() -> Vec<Box<S>> {
    |                       ^^^^^^^^^^^ help: try: `Vec<S>`
 
-error: aborting due to 6 previous errors
+error: aborting due to 9 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 483b109e6e7f741f0827fde46c9263636498b12a Mon Sep 17 00:00:00 2001
From: Jacherr <jwc2002@outlook.com>
Date: Wed, 8 Nov 2023 21:17:40 +0000
Subject: cargo dev fmt

---
 clippy_lints/src/types/vec_box.rs | 2 +-
 clippy_utils/src/paths.rs         | 2 +-
 tests/ui/vec_box_sized.rs         | 6 +++---
 3 files changed, 5 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types/vec_box.rs b/clippy_lints/src/types/vec_box.rs
index 43f72f1031d..da4392418ca 100644
--- a/clippy_lints/src/types/vec_box.rs
+++ b/clippy_lints/src/types/vec_box.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::{last_path_segment, match_def_path};
 use clippy_utils::paths::ALLOCATOR_GLOBAL;
 use clippy_utils::source::snippet;
+use clippy_utils::{last_path_segment, match_def_path};
 use rustc_errors::Applicability;
 use rustc_hir::def_id::DefId;
 use rustc_hir::{self as hir, GenericArg, QPath, TyKind};
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index bde8eb892e9..859bffd6c9c 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -99,4 +99,4 @@ pub const OPTION_UNWRAP: [&str; 4] = ["core", "option", "Option", "unwrap"];
 pub const OPTION_EXPECT: [&str; 4] = ["core", "option", "Option", "expect"];
 #[expect(clippy::invalid_paths)] // not sure why it thinks this, it works so
 pub const BOOL_THEN: [&str; 4] = ["core", "bool", "<impl bool>", "then"];
-pub const ALLOCATOR_GLOBAL: [&str; 3] = ["alloc", "alloc", "Global"];
\ No newline at end of file
+pub const ALLOCATOR_GLOBAL: [&str; 3] = ["alloc", "alloc", "Global"];
diff --git a/tests/ui/vec_box_sized.rs b/tests/ui/vec_box_sized.rs
index af471f1eb8d..e46f5bf2126 100644
--- a/tests/ui/vec_box_sized.rs
+++ b/tests/ui/vec_box_sized.rs
@@ -3,7 +3,7 @@
 #![allow(dead_code)]
 #![feature(allocator_api)]
 
-use std::alloc::{Layout, AllocError, Allocator};
+use std::alloc::{AllocError, Allocator, Layout};
 use std::ptr::NonNull;
 
 struct SizedStruct(i32);
@@ -22,7 +22,7 @@ unsafe impl Allocator for DummyAllocator {
 
 /// The following should trigger the lint
 mod should_trigger {
-    use super::{SizedStruct, DummyAllocator};
+    use super::{DummyAllocator, SizedStruct};
     const C: Vec<Box<i32>> = Vec::new();
     static S: Vec<Box<i32>> = Vec::new();
 
@@ -46,7 +46,7 @@ mod should_trigger {
 
 /// The following should not trigger the lint
 mod should_not_trigger {
-    use super::{BigStruct, UnsizedStruct, DummyAllocator};
+    use super::{BigStruct, DummyAllocator, UnsizedStruct};
 
     struct C(Vec<Box<UnsizedStruct>>);
     struct D(Vec<Box<BigStruct>>);
-- 
cgit 1.4.1-3-g733a5


From 7e716ff9551965c8b458e6a2a935a4a36463fb77 Mon Sep 17 00:00:00 2001
From: PartiallyTyped <me@partiallytyped.dev>
Date: Wed, 8 Nov 2023 22:28:06 +0100
Subject: [`mod_module_files`] Don't emit lint for modules in tests

fixes: #11775

current state: indiscriminately emits the lint for mod files in tests.

The following

tests/
  common/
    mod.rs
  test.rs

is a common pattern for code shared across the tests and is suggested in
the rust book. The change adds an additional check to verify that the
mod file is not in tests.

changelog: Fix [`mod_module_files`]: false positive for mod files in
tests folder
---
 clippy_lints/src/module_style.rs | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/module_style.rs b/clippy_lints/src/module_style.rs
index efdc7560ee4..b49a5614329 100644
--- a/clippy_lints/src/module_style.rs
+++ b/clippy_lints/src/module_style.rs
@@ -153,8 +153,11 @@ fn process_paths_for_mod_files<'a>(
 }
 
 /// Checks every path for the presence of `mod.rs` files and emits the lint if found.
+/// We should not emit a lint for test modules in the presence of `mod.rs`.
+/// Using `mod.rs` in integration tests is a [common pattern](https://doc.rust-lang.org/book/ch11-03-test-organization.html#submodules-in-integration-test)
+/// for code-sharing between tests.
 fn check_self_named_mod_exists(cx: &EarlyContext<'_>, path: &Path, file: &SourceFile) {
-    if path.ends_with("mod.rs") {
+    if path.ends_with("mod.rs") && !path.starts_with("tests") {
         let mut mod_file = path.to_path_buf();
         mod_file.pop();
         mod_file.set_extension("rs");
-- 
cgit 1.4.1-3-g733a5


From 7cdaa3b574a1c9dd94c1d0abc260f8a4d366cd98 Mon Sep 17 00:00:00 2001
From: Jacherr <jwc2002@outlook.com>
Date: Wed, 8 Nov 2023 21:47:58 +0000
Subject: replace incorrect bool

---
 clippy_lints/src/types/vec_box.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/types/vec_box.rs b/clippy_lints/src/types/vec_box.rs
index da4392418ca..9d5066199bd 100644
--- a/clippy_lints/src/types/vec_box.rs
+++ b/clippy_lints/src/types/vec_box.rs
@@ -52,7 +52,7 @@ pub(super) fn check(
                         && let Some(did) = cx.qpath_res(&path, inner.hir_id).opt_def_id() {
                         match_def_path(cx, did, &ALLOCATOR_GLOBAL)
                     } else {
-                        true
+                        false
                     }
                 },
                 (Some(GenericArg::Type(l)), Some(GenericArg::Type(r))) =>
-- 
cgit 1.4.1-3-g733a5


From d8c0e6460b6e08c503acb34179957d387684f90c Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Thu, 9 Nov 2023 13:34:00 +0000
Subject: Make `macro_use_imports` lint ordering more stable

---
 clippy_lints/src/macro_use.rs     | 25 +++++++++++--------------
 tests/ui/macro_use_imports.stderr | 12 ++++++------
 2 files changed, 17 insertions(+), 20 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/macro_use.rs b/clippy_lints/src/macro_use.rs
index 70c5182472a..38862a47db7 100644
--- a/clippy_lints/src/macro_use.rs
+++ b/clippy_lints/src/macro_use.rs
@@ -3,13 +3,14 @@ use clippy_utils::source::snippet;
 use hir::def::{DefKind, Res};
 use if_chain::if_chain;
 use rustc_ast::ast;
-use rustc_data_structures::fx::{FxHashMap, FxHashSet};
+use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::edition::Edition;
 use rustc_span::{sym, Span};
+use std::collections::BTreeMap;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -142,7 +143,7 @@ impl<'tcx> LateLintPass<'tcx> for MacroUseImports {
         }
     }
     fn check_crate_post(&mut self, cx: &LateContext<'_>) {
-        let mut used = FxHashMap::default();
+        let mut used = BTreeMap::new();
         let mut check_dup = vec![];
         for (import, span, hir_id) in &self.imports {
             let found_idx = self.mac_refs.iter().position(|mac| import.ends_with(&mac.name));
@@ -191,20 +192,16 @@ impl<'tcx> LateLintPass<'tcx> for MacroUseImports {
             }
         }
 
-        let mut suggestions = vec![];
-        for ((root, span, hir_id), path) in used {
-            if path.len() == 1 {
-                suggestions.push((span, format!("{root}::{}", path[0]), hir_id));
-            } else {
-                suggestions.push((span, format!("{root}::{{{}}}", path.join(", ")), hir_id));
-            }
-        }
-
         // If mac_refs is not empty we have encountered an import we could not handle
         // such as `std::prelude::v1::foo` or some other macro that expands to an import.
         if self.mac_refs.is_empty() {
-            for (span, import, hir_id) in suggestions {
-                let help = format!("use {import};");
+            for ((root, span, hir_id), path) in used {
+                let import = if let [single] = &path[..] {
+                    format!("{root}::{single}")
+                } else {
+                    format!("{root}::{{{}}}", path.join(", "))
+                };
+
                 span_lint_hir_and_then(
                     cx,
                     MACRO_USE_IMPORTS,
@@ -215,7 +212,7 @@ impl<'tcx> LateLintPass<'tcx> for MacroUseImports {
                         diag.span_suggestion(
                             *span,
                             "remove the attribute and import the macro directly, try",
-                            help,
+                            format!("use {import};"),
                             Applicability::MaybeIncorrect,
                         );
                     },
diff --git a/tests/ui/macro_use_imports.stderr b/tests/ui/macro_use_imports.stderr
index 6de869699ec..5524e7e5642 100644
--- a/tests/ui/macro_use_imports.stderr
+++ b/tests/ui/macro_use_imports.stderr
@@ -1,8 +1,8 @@
 error: `macro_use` attributes are no longer needed in the Rust 2018 edition
-  --> $DIR/macro_use_imports.rs:25:5
+  --> $DIR/macro_use_imports.rs:19:5
    |
 LL |     #[macro_use]
-   |     ^^^^^^^^^^^^ help: remove the attribute and import the macro directly, try: `use mac::inner::nested::string_add;`
+   |     ^^^^^^^^^^^^ help: remove the attribute and import the macro directly, try: `use mac::{pub_macro, inner_mod_macro, function_macro, ty_macro, pub_in_private_macro};`
    |
    = note: `-D clippy::macro-use-imports` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::macro_use_imports)]`
@@ -14,16 +14,16 @@ LL |     #[macro_use]
    |     ^^^^^^^^^^^^ help: remove the attribute and import the macro directly, try: `use mac::{inner::mut_mut, inner::try_err};`
 
 error: `macro_use` attributes are no longer needed in the Rust 2018 edition
-  --> $DIR/macro_use_imports.rs:21:5
+  --> $DIR/macro_use_imports.rs:25:5
    |
 LL |     #[macro_use]
-   |     ^^^^^^^^^^^^ help: remove the attribute and import the macro directly, try: `use mini_mac::ClippyMiniMacroTest;`
+   |     ^^^^^^^^^^^^ help: remove the attribute and import the macro directly, try: `use mac::inner::nested::string_add;`
 
 error: `macro_use` attributes are no longer needed in the Rust 2018 edition
-  --> $DIR/macro_use_imports.rs:19:5
+  --> $DIR/macro_use_imports.rs:21:5
    |
 LL |     #[macro_use]
-   |     ^^^^^^^^^^^^ help: remove the attribute and import the macro directly, try: `use mac::{pub_macro, inner_mod_macro, function_macro, ty_macro, pub_in_private_macro};`
+   |     ^^^^^^^^^^^^ help: remove the attribute and import the macro directly, try: `use mini_mac::ClippyMiniMacroTest;`
 
 error: aborting due to 4 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 16d58a298232e026c05d69f4e8b5740f0f428bdb Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Tue, 7 Nov 2023 15:11:57 -0500
Subject: Lift `expr_diverges` to `clippy_utils` as `is_never_expr`

---
 clippy_lints/src/manual_let_else.rs | 111 ++----------------------------------
 clippy_utils/src/lib.rs             | 102 ++++++++++++++++++++++++++++++++-
 2 files changed, 105 insertions(+), 108 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_let_else.rs b/clippy_lints/src/manual_let_else.rs
index 170a040d4ae..67a2a0ef8ba 100644
--- a/clippy_lints/src/manual_let_else.rs
+++ b/clippy_lints/src/manual_let_else.rs
@@ -5,18 +5,15 @@ use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::higher::IfLetOrMatch;
 use clippy_utils::source::snippet_with_context;
 use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::visitors::{Descend, Visitable};
-use clippy_utils::{is_lint_allowed, pat_and_expr_can_be_question_mark, peel_blocks};
+use clippy_utils::{is_lint_allowed, is_never_expr, pat_and_expr_can_be_question_mark, peel_blocks};
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_errors::Applicability;
-use rustc_hir::intravisit::{walk_expr, Visitor};
-use rustc_hir::{Expr, ExprKind, HirId, ItemId, Local, MatchSource, Pat, PatKind, QPath, Stmt, StmtKind, Ty};
+use rustc_hir::{Expr, ExprKind, MatchSource, Pat, PatKind, QPath, Stmt, StmtKind};
 use rustc_lint::{LateContext, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::declare_tool_lint;
 use rustc_span::symbol::{sym, Symbol};
 use rustc_span::Span;
-use std::ops::ControlFlow;
 use std::slice;
 
 declare_clippy_lint! {
@@ -51,7 +48,7 @@ declare_clippy_lint! {
 }
 
 impl<'tcx> QuestionMark {
-    pub(crate) fn check_manual_let_else(&mut self, cx: &LateContext<'_>, stmt: &'tcx Stmt<'tcx>) {
+    pub(crate) fn check_manual_let_else(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'tcx>) {
         if !self.msrv.meets(msrvs::LET_ELSE) || in_external_macro(cx.sess(), stmt.span) {
             return;
         }
@@ -67,7 +64,7 @@ impl<'tcx> QuestionMark {
                 IfLetOrMatch::IfLet(if_let_expr, let_pat, if_then, if_else) => {
                     if let Some(ident_map) = expr_simple_identity_map(local.pat, let_pat, if_then)
                         && let Some(if_else) = if_else
-                        && expr_diverges(cx, if_else)
+                        && is_never_expr(cx, if_else)
                         && let qm_allowed = is_lint_allowed(cx, QUESTION_MARK, stmt.hir_id)
                         && (qm_allowed || pat_and_expr_can_be_question_mark(cx, let_pat, if_else).is_none())
                     {
@@ -94,7 +91,7 @@ impl<'tcx> QuestionMark {
                     let diverging_arm_opt = arms
                         .iter()
                         .enumerate()
-                        .find(|(_, arm)| expr_diverges(cx, arm.body) && pat_allowed_for_else(cx, arm.pat, check_types));
+                        .find(|(_, arm)| is_never_expr(cx, arm.body) && pat_allowed_for_else(cx, arm.pat, check_types));
                     let Some((idx, diverging_arm)) = diverging_arm_opt else {
                         return;
                     };
@@ -272,104 +269,6 @@ fn replace_in_pattern(
     sn_pat.into_owned()
 }
 
-/// Check whether an expression is divergent. May give false negatives.
-fn expr_diverges(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-    struct V<'cx, 'tcx> {
-        cx: &'cx LateContext<'tcx>,
-        res: ControlFlow<(), Descend>,
-    }
-    impl<'tcx> Visitor<'tcx> for V<'_, '_> {
-        fn visit_expr(&mut self, e: &'tcx Expr<'tcx>) {
-            fn is_never(cx: &LateContext<'_>, expr: &'_ Expr<'_>) -> bool {
-                if let Some(ty) = cx.typeck_results().expr_ty_opt(expr) {
-                    return ty.is_never();
-                }
-                false
-            }
-
-            if self.res.is_break() {
-                return;
-            }
-
-            // We can't just call is_never on expr and be done, because the type system
-            // sometimes coerces the ! type to something different before we can get
-            // our hands on it. So instead, we do a manual search. We do fall back to
-            // is_never in some places when there is no better alternative.
-            self.res = match e.kind {
-                ExprKind::Continue(_) | ExprKind::Break(_, _) | ExprKind::Ret(_) => ControlFlow::Break(()),
-                ExprKind::Call(call, _) => {
-                    if is_never(self.cx, e) || is_never(self.cx, call) {
-                        ControlFlow::Break(())
-                    } else {
-                        ControlFlow::Continue(Descend::Yes)
-                    }
-                },
-                ExprKind::MethodCall(..) => {
-                    if is_never(self.cx, e) {
-                        ControlFlow::Break(())
-                    } else {
-                        ControlFlow::Continue(Descend::Yes)
-                    }
-                },
-                ExprKind::If(if_expr, if_then, if_else) => {
-                    let else_diverges = if_else.map_or(false, |ex| expr_diverges(self.cx, ex));
-                    let diverges =
-                        expr_diverges(self.cx, if_expr) || (else_diverges && expr_diverges(self.cx, if_then));
-                    if diverges {
-                        ControlFlow::Break(())
-                    } else {
-                        ControlFlow::Continue(Descend::No)
-                    }
-                },
-                ExprKind::Match(match_expr, match_arms, _) => {
-                    let diverges = expr_diverges(self.cx, match_expr)
-                        || match_arms.iter().all(|arm| {
-                            let guard_diverges = arm.guard.as_ref().map_or(false, |g| expr_diverges(self.cx, g.body()));
-                            guard_diverges || expr_diverges(self.cx, arm.body)
-                        });
-                    if diverges {
-                        ControlFlow::Break(())
-                    } else {
-                        ControlFlow::Continue(Descend::No)
-                    }
-                },
-
-                // Don't continue into loops or labeled blocks, as they are breakable,
-                // and we'd have to start checking labels.
-                ExprKind::Block(_, Some(_)) | ExprKind::Loop(..) => ControlFlow::Continue(Descend::No),
-
-                // Default: descend
-                _ => ControlFlow::Continue(Descend::Yes),
-            };
-            if let ControlFlow::Continue(Descend::Yes) = self.res {
-                walk_expr(self, e);
-            }
-        }
-
-        fn visit_local(&mut self, local: &'tcx Local<'_>) {
-            // Don't visit the else block of a let/else statement as it will not make
-            // the statement divergent even though the else block is divergent.
-            if let Some(init) = local.init {
-                self.visit_expr(init);
-            }
-        }
-
-        // Avoid unnecessary `walk_*` calls.
-        fn visit_ty(&mut self, _: &'tcx Ty<'tcx>) {}
-        fn visit_pat(&mut self, _: &'tcx Pat<'tcx>) {}
-        fn visit_qpath(&mut self, _: &'tcx QPath<'tcx>, _: HirId, _: Span) {}
-        // Avoid monomorphising all `visit_*` functions.
-        fn visit_nested_item(&mut self, _: ItemId) {}
-    }
-
-    let mut v = V {
-        cx,
-        res: ControlFlow::Continue(Descend::Yes),
-    };
-    expr.visit(&mut v);
-    v.res.is_break()
-}
-
 fn pat_allowed_for_else(cx: &LateContext<'_>, pat: &'_ Pat<'_>, check_types: bool) -> bool {
     // Check whether the pattern contains any bindings, as the
     // binding might potentially be used in the body.
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 1181dfc0ef9..e11f7867ff0 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -88,7 +88,7 @@ use rustc_hir::intravisit::{walk_expr, FnKind, Visitor};
 use rustc_hir::LangItem::{OptionNone, OptionSome, ResultErr, ResultOk};
 use rustc_hir::{
     self as hir, def, Arm, ArrayLen, BindingAnnotation, Block, BlockCheckMode, Body, Closure, Destination, Expr,
-    ExprField, ExprKind, FnDecl, FnRetTy, GenericArgs, HirId, Impl, ImplItem, ImplItemKind, ImplItemRef, Item,
+    ExprField, ExprKind, FnDecl, FnRetTy, GenericArgs, HirId, Impl, ImplItem, ImplItemKind, ImplItemRef, Item, ItemId,
     ItemKind, LangItem, Local, MatchSource, Mutability, Node, OwnerId, Param, Pat, PatKind, Path, PathSegment, PrimTy,
     QPath, Stmt, StmtKind, TraitItem, TraitItemKind, TraitItemRef, TraitRef, TyKind, UnOp,
 };
@@ -117,7 +117,7 @@ use crate::ty::{
     adt_and_variant_of_res, can_partially_move_ty, expr_sig, is_copy, is_recursively_primitive_type,
     ty_is_fn_once_param,
 };
-use crate::visitors::for_each_expr;
+use crate::visitors::{for_each_expr, Descend};
 
 use rustc_middle::hir::nested_filter;
 
@@ -2974,3 +2974,101 @@ pub fn pat_is_wild<'tcx>(cx: &LateContext<'tcx>, pat: &'tcx PatKind<'_>, body: i
         _ => false,
     }
 }
+
+/// Check if the expression either returns, or could be coerced into returning, `!`.
+pub fn is_never_expr(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+    struct V<'cx, 'tcx> {
+        cx: &'cx LateContext<'tcx>,
+        res: ControlFlow<(), Descend>,
+    }
+    impl<'tcx> Visitor<'tcx> for V<'_, '_> {
+        fn visit_expr(&mut self, e: &'tcx Expr<'tcx>) {
+            fn is_never(cx: &LateContext<'_>, expr: &'_ Expr<'_>) -> bool {
+                if let Some(ty) = cx.typeck_results().expr_ty_opt(expr) {
+                    return ty.is_never();
+                }
+                false
+            }
+
+            if self.res.is_break() {
+                return;
+            }
+
+            // We can't just call is_never on expr and be done, because the type system
+            // sometimes coerces the ! type to something different before we can get
+            // our hands on it. So instead, we do a manual search. We do fall back to
+            // is_never in some places when there is no better alternative.
+            self.res = match e.kind {
+                ExprKind::Continue(_) | ExprKind::Break(_, _) | ExprKind::Ret(_) => ControlFlow::Break(()),
+                ExprKind::Call(call, _) => {
+                    if is_never(self.cx, e) || is_never(self.cx, call) {
+                        ControlFlow::Break(())
+                    } else {
+                        ControlFlow::Continue(Descend::Yes)
+                    }
+                },
+                ExprKind::MethodCall(..) => {
+                    if is_never(self.cx, e) {
+                        ControlFlow::Break(())
+                    } else {
+                        ControlFlow::Continue(Descend::Yes)
+                    }
+                },
+                ExprKind::If(if_expr, if_then, if_else) => {
+                    let else_diverges = if_else.map_or(false, |ex| is_never_expr(self.cx, ex));
+                    let diverges =
+                        is_never_expr(self.cx, if_expr) || (else_diverges && is_never_expr(self.cx, if_then));
+                    if diverges {
+                        ControlFlow::Break(())
+                    } else {
+                        ControlFlow::Continue(Descend::No)
+                    }
+                },
+                ExprKind::Match(match_expr, match_arms, _) => {
+                    let diverges = is_never_expr(self.cx, match_expr)
+                        || match_arms.iter().all(|arm| {
+                            let guard_diverges = arm.guard.as_ref().map_or(false, |g| is_never_expr(self.cx, g.body()));
+                            guard_diverges || is_never_expr(self.cx, arm.body)
+                        });
+                    if diverges {
+                        ControlFlow::Break(())
+                    } else {
+                        ControlFlow::Continue(Descend::No)
+                    }
+                },
+
+                // Don't continue into loops or labeled blocks, as they are breakable,
+                // and we'd have to start checking labels.
+                ExprKind::Block(_, Some(_)) | ExprKind::Loop(..) => ControlFlow::Continue(Descend::No),
+
+                // Default: descend
+                _ => ControlFlow::Continue(Descend::Yes),
+            };
+            if let ControlFlow::Continue(Descend::Yes) = self.res {
+                walk_expr(self, e);
+            }
+        }
+
+        fn visit_local(&mut self, local: &'tcx Local<'_>) {
+            // Don't visit the else block of a let/else statement as it will not make
+            // the statement divergent even though the else block is divergent.
+            if let Some(init) = local.init {
+                self.visit_expr(init);
+            }
+        }
+
+        // Avoid unnecessary `walk_*` calls.
+        fn visit_ty(&mut self, _: &'tcx hir::Ty<'tcx>) {}
+        fn visit_pat(&mut self, _: &'tcx Pat<'tcx>) {}
+        fn visit_qpath(&mut self, _: &'tcx QPath<'tcx>, _: HirId, _: Span) {}
+        // Avoid monomorphising all `visit_*` functions.
+        fn visit_nested_item(&mut self, _: ItemId) {}
+    }
+
+    let mut v = V {
+        cx,
+        res: ControlFlow::Continue(Descend::Yes),
+    };
+    expr.visit(&mut v);
+    v.res.is_break()
+}
-- 
cgit 1.4.1-3-g733a5


From a44bb079005bac4dca0bdf7d94d5d87c52166674 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Thu, 9 Nov 2023 17:29:01 -0500
Subject: Change divergence checking to match the compiler's type system based
 definition of divergence.

---
 clippy_lints/src/manual_let_else.rs |   9 +-
 clippy_utils/src/lib.rs             | 292 +++++++++++++++++++++++++++---------
 tests/ui/manual_let_else.rs         | 113 ++++++++++++--
 tests/ui/manual_let_else.stderr     | 172 +++++++++++++++++----
 4 files changed, 467 insertions(+), 119 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_let_else.rs b/clippy_lints/src/manual_let_else.rs
index 67a2a0ef8ba..01eccb56a0a 100644
--- a/clippy_lints/src/manual_let_else.rs
+++ b/clippy_lints/src/manual_let_else.rs
@@ -64,7 +64,7 @@ impl<'tcx> QuestionMark {
                 IfLetOrMatch::IfLet(if_let_expr, let_pat, if_then, if_else) => {
                     if let Some(ident_map) = expr_simple_identity_map(local.pat, let_pat, if_then)
                         && let Some(if_else) = if_else
-                        && is_never_expr(cx, if_else)
+                        && is_never_expr(cx, if_else).is_some()
                         && let qm_allowed = is_lint_allowed(cx, QUESTION_MARK, stmt.hir_id)
                         && (qm_allowed || pat_and_expr_can_be_question_mark(cx, let_pat, if_else).is_none())
                     {
@@ -88,10 +88,9 @@ impl<'tcx> QuestionMark {
                         return;
                     }
                     let check_types = self.matches_behaviour == MatchLintBehaviour::WellKnownTypes;
-                    let diverging_arm_opt = arms
-                        .iter()
-                        .enumerate()
-                        .find(|(_, arm)| is_never_expr(cx, arm.body) && pat_allowed_for_else(cx, arm.pat, check_types));
+                    let diverging_arm_opt = arms.iter().enumerate().find(|(_, arm)| {
+                        is_never_expr(cx, arm.body).is_some() && pat_allowed_for_else(cx, arm.pat, check_types)
+                    });
                     let Some((idx, diverging_arm)) = diverging_arm_opt else {
                         return;
                     };
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index e11f7867ff0..19e4d4ad759 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -71,6 +71,7 @@ pub use self::hir_utils::{
     both, count_eq, eq_expr_value, hash_expr, hash_stmt, is_bool, over, HirEqInterExpr, SpanlessEq, SpanlessHash,
 };
 
+use core::mem;
 use core::ops::ControlFlow;
 use std::collections::hash_map::Entry;
 use std::hash::BuildHasherDefault;
@@ -88,7 +89,7 @@ use rustc_hir::intravisit::{walk_expr, FnKind, Visitor};
 use rustc_hir::LangItem::{OptionNone, OptionSome, ResultErr, ResultOk};
 use rustc_hir::{
     self as hir, def, Arm, ArrayLen, BindingAnnotation, Block, BlockCheckMode, Body, Closure, Destination, Expr,
-    ExprField, ExprKind, FnDecl, FnRetTy, GenericArgs, HirId, Impl, ImplItem, ImplItemKind, ImplItemRef, Item, ItemId,
+    ExprField, ExprKind, FnDecl, FnRetTy, GenericArgs, HirId, Impl, ImplItem, ImplItemKind, ImplItemRef, Item,
     ItemKind, LangItem, Local, MatchSource, Mutability, Node, OwnerId, Param, Pat, PatKind, Path, PathSegment, PrimTy,
     QPath, Stmt, StmtKind, TraitItem, TraitItemKind, TraitItemRef, TraitRef, TyKind, UnOp,
 };
@@ -117,7 +118,7 @@ use crate::ty::{
     adt_and_variant_of_res, can_partially_move_ty, expr_sig, is_copy, is_recursively_primitive_type,
     ty_is_fn_once_param,
 };
-use crate::visitors::{for_each_expr, Descend};
+use crate::visitors::for_each_expr;
 
 use rustc_middle::hir::nested_filter;
 
@@ -2975,100 +2976,247 @@ pub fn pat_is_wild<'tcx>(cx: &LateContext<'tcx>, pat: &'tcx PatKind<'_>, body: i
     }
 }
 
-/// Check if the expression either returns, or could be coerced into returning, `!`.
-pub fn is_never_expr(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+#[derive(Clone, Copy)]
+pub enum RequiresSemi {
+    Yes,
+    No,
+}
+impl RequiresSemi {
+    pub fn requires_semi(self) -> bool {
+        matches!(self, Self::Yes)
+    }
+}
+
+/// Check if the expression return `!`, a type coerced from `!`, or could return `!` if the final
+/// expression were turned into a statement.
+#[expect(clippy::too_many_lines)]
+pub fn is_never_expr<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> Option<RequiresSemi> {
+    struct BreakTarget {
+        id: HirId,
+        unused: bool,
+    }
+
     struct V<'cx, 'tcx> {
         cx: &'cx LateContext<'tcx>,
-        res: ControlFlow<(), Descend>,
+        break_targets: Vec<BreakTarget>,
+        break_targets_for_result_ty: u32,
+        in_final_expr: bool,
+        requires_semi: bool,
+        is_never: bool,
     }
-    impl<'tcx> Visitor<'tcx> for V<'_, '_> {
-        fn visit_expr(&mut self, e: &'tcx Expr<'tcx>) {
-            fn is_never(cx: &LateContext<'_>, expr: &'_ Expr<'_>) -> bool {
-                if let Some(ty) = cx.typeck_results().expr_ty_opt(expr) {
-                    return ty.is_never();
-                }
-                false
-            }
 
-            if self.res.is_break() {
+    impl<'tcx> V<'_, 'tcx> {
+        fn push_break_target(&mut self, id: HirId) {
+            self.break_targets.push(BreakTarget { id, unused: true });
+            self.break_targets_for_result_ty += u32::from(self.in_final_expr);
+        }
+    }
+
+    impl<'tcx> Visitor<'tcx> for V<'_, 'tcx> {
+        fn visit_expr(&mut self, e: &'tcx Expr<'_>) {
+            // Note: Part of the complexity here comes from the fact that
+            // coercions are applied to the innermost expression.
+            // e.g. In `let x: u32 = { break () };` the never-to-any coercion
+            // is applied to the break expression. This means we can't just
+            // check the block's type as it will be `u32` despite the fact
+            // that the block always diverges.
+
+            // The rest of the complexity comes from checking blocks which
+            // syntactically return a value, but will always diverge before
+            // reaching that point.
+            // e.g. In `let x = { foo(panic!()) };` the block's type will be the
+            // return type of `foo` even though it will never actually run. This
+            // can be trivially fixed by adding a semicolon after the call, but
+            // we must first detect that a semicolon is needed to make that
+            // suggestion.
+
+            if self.is_never && self.break_targets.is_empty() {
+                if self.in_final_expr && !self.requires_semi {
+                    // This expression won't ever run, but we still need to check
+                    // if it can affect the type of the final expression.
+                    match e.kind {
+                        ExprKind::DropTemps(e) => self.visit_expr(e),
+                        ExprKind::If(_, then, Some(else_)) => {
+                            self.visit_expr(then);
+                            self.visit_expr(else_);
+                        },
+                        ExprKind::Match(_, arms, _) => {
+                            for arm in arms {
+                                self.visit_expr(arm.body);
+                            }
+                        },
+                        ExprKind::Loop(b, ..) => {
+                            self.push_break_target(e.hir_id);
+                            self.in_final_expr = false;
+                            self.visit_block(b);
+                            self.break_targets.pop();
+                        },
+                        ExprKind::Block(b, _) => {
+                            if b.targeted_by_break {
+                                self.push_break_target(b.hir_id);
+                                self.visit_block(b);
+                                self.break_targets.pop();
+                            } else {
+                                self.visit_block(b);
+                            }
+                        },
+                        _ => {
+                            self.requires_semi = !self.cx.typeck_results().expr_ty(e).is_never();
+                        },
+                    }
+                }
                 return;
             }
-
-            // We can't just call is_never on expr and be done, because the type system
-            // sometimes coerces the ! type to something different before we can get
-            // our hands on it. So instead, we do a manual search. We do fall back to
-            // is_never in some places when there is no better alternative.
-            self.res = match e.kind {
-                ExprKind::Continue(_) | ExprKind::Break(_, _) | ExprKind::Ret(_) => ControlFlow::Break(()),
-                ExprKind::Call(call, _) => {
-                    if is_never(self.cx, e) || is_never(self.cx, call) {
-                        ControlFlow::Break(())
-                    } else {
-                        ControlFlow::Continue(Descend::Yes)
+            match e.kind {
+                ExprKind::DropTemps(e) => self.visit_expr(e),
+                ExprKind::Ret(None) | ExprKind::Continue(_) => self.is_never = true,
+                ExprKind::Ret(Some(e)) | ExprKind::Become(e) => {
+                    self.in_final_expr = false;
+                    self.visit_expr(e);
+                    self.is_never = true;
+                },
+                ExprKind::Break(dest, e) => {
+                    if let Some(e) = e {
+                        self.in_final_expr = false;
+                        self.visit_expr(e);
+                    }
+                    if let Ok(id) = dest.target_id
+                        && let Some((i, target)) = self
+                            .break_targets
+                            .iter_mut()
+                            .enumerate()
+                            .find(|(_, target)| target.id == id)
+                    {
+                        target.unused &= self.is_never;
+                        if i < self.break_targets_for_result_ty as usize {
+                            self.requires_semi = true;
+                        }
                     }
+                    self.is_never = true;
                 },
-                ExprKind::MethodCall(..) => {
-                    if is_never(self.cx, e) {
-                        ControlFlow::Break(())
+                ExprKind::If(cond, then, else_) => {
+                    let in_final_expr = mem::replace(&mut self.in_final_expr, false);
+                    self.visit_expr(cond);
+                    self.in_final_expr = in_final_expr;
+
+                    if self.is_never {
+                        self.visit_expr(then);
+                        if let Some(else_) = else_ {
+                            self.visit_expr(else_);
+                        }
                     } else {
-                        ControlFlow::Continue(Descend::Yes)
+                        self.visit_expr(then);
+                        let is_never = mem::replace(&mut self.is_never, false);
+                        if let Some(else_) = else_ {
+                            self.visit_expr(else_);
+                            self.is_never &= is_never;
+                        }
                     }
                 },
-                ExprKind::If(if_expr, if_then, if_else) => {
-                    let else_diverges = if_else.map_or(false, |ex| is_never_expr(self.cx, ex));
-                    let diverges =
-                        is_never_expr(self.cx, if_expr) || (else_diverges && is_never_expr(self.cx, if_then));
-                    if diverges {
-                        ControlFlow::Break(())
+                ExprKind::Match(scrutinee, arms, _) => {
+                    let in_final_expr = mem::replace(&mut self.in_final_expr, false);
+                    self.visit_expr(scrutinee);
+                    self.in_final_expr = in_final_expr;
+
+                    if self.is_never {
+                        for arm in arms {
+                            self.visit_arm(arm);
+                        }
                     } else {
-                        ControlFlow::Continue(Descend::No)
+                        let mut is_never = true;
+                        for arm in arms {
+                            self.is_never = false;
+                            if let Some(guard) = arm.guard {
+                                let in_final_expr = mem::replace(&mut self.in_final_expr, false);
+                                self.visit_expr(guard.body());
+                                self.in_final_expr = in_final_expr;
+                                // The compiler doesn't consider diverging guards as causing the arm to diverge.
+                                self.is_never = false;
+                            }
+                            self.visit_expr(arm.body);
+                            is_never &= self.is_never;
+                        }
+                        self.is_never = is_never;
                     }
                 },
-                ExprKind::Match(match_expr, match_arms, _) => {
-                    let diverges = is_never_expr(self.cx, match_expr)
-                        || match_arms.iter().all(|arm| {
-                            let guard_diverges = arm.guard.as_ref().map_or(false, |g| is_never_expr(self.cx, g.body()));
-                            guard_diverges || is_never_expr(self.cx, arm.body)
-                        });
-                    if diverges {
-                        ControlFlow::Break(())
+                ExprKind::Loop(b, _, _, _) => {
+                    self.push_break_target(e.hir_id);
+                    self.in_final_expr = false;
+                    self.visit_block(b);
+                    self.is_never = self.break_targets.pop().unwrap().unused;
+                },
+                ExprKind::Block(b, _) => {
+                    if b.targeted_by_break {
+                        self.push_break_target(b.hir_id);
+                        self.visit_block(b);
+                        self.is_never &= self.break_targets.pop().unwrap().unused;
                     } else {
-                        ControlFlow::Continue(Descend::No)
+                        self.visit_block(b);
                     }
                 },
+                _ => {
+                    self.in_final_expr = false;
+                    walk_expr(self, e);
+                    self.is_never |= self.cx.typeck_results().expr_ty(e).is_never();
+                },
+            }
+        }
 
-                // Don't continue into loops or labeled blocks, as they are breakable,
-                // and we'd have to start checking labels.
-                ExprKind::Block(_, Some(_)) | ExprKind::Loop(..) => ControlFlow::Continue(Descend::No),
-
-                // Default: descend
-                _ => ControlFlow::Continue(Descend::Yes),
-            };
-            if let ControlFlow::Continue(Descend::Yes) = self.res {
-                walk_expr(self, e);
+        fn visit_block(&mut self, b: &'tcx Block<'_>) {
+            let in_final_expr = mem::replace(&mut self.in_final_expr, false);
+            for s in b.stmts {
+                self.visit_stmt(s);
+            }
+            self.in_final_expr = in_final_expr;
+            if let Some(e) = b.expr {
+                self.visit_expr(e);
             }
         }
 
-        fn visit_local(&mut self, local: &'tcx Local<'_>) {
-            // Don't visit the else block of a let/else statement as it will not make
-            // the statement divergent even though the else block is divergent.
-            if let Some(init) = local.init {
-                self.visit_expr(init);
+        fn visit_local(&mut self, l: &'tcx Local<'_>) {
+            if let Some(e) = l.init {
+                self.visit_expr(e);
+            }
+            if let Some(else_) = l.els {
+                let is_never = self.is_never;
+                self.visit_block(else_);
+                self.is_never = is_never;
             }
         }
 
-        // Avoid unnecessary `walk_*` calls.
-        fn visit_ty(&mut self, _: &'tcx hir::Ty<'tcx>) {}
-        fn visit_pat(&mut self, _: &'tcx Pat<'tcx>) {}
-        fn visit_qpath(&mut self, _: &'tcx QPath<'tcx>, _: HirId, _: Span) {}
-        // Avoid monomorphising all `visit_*` functions.
-        fn visit_nested_item(&mut self, _: ItemId) {}
+        fn visit_arm(&mut self, arm: &Arm<'tcx>) {
+            if let Some(guard) = arm.guard {
+                let in_final_expr = mem::replace(&mut self.in_final_expr, false);
+                self.visit_expr(guard.body());
+                self.in_final_expr = in_final_expr;
+            }
+            self.visit_expr(arm.body);
+        }
     }
 
-    let mut v = V {
-        cx,
-        res: ControlFlow::Continue(Descend::Yes),
-    };
-    expr.visit(&mut v);
-    v.res.is_break()
+    if cx.typeck_results().expr_ty(e).is_never() {
+        Some(RequiresSemi::No)
+    } else if let ExprKind::Block(b, _) = e.kind
+        && !b.targeted_by_break
+        && b.expr.is_none()
+    {
+        // If a block diverges without a final expression then it's type is `!`.
+        None
+    } else {
+        let mut v = V {
+            cx,
+            break_targets: Vec::new(),
+            break_targets_for_result_ty: 0,
+            in_final_expr: true,
+            requires_semi: false,
+            is_never: false,
+        };
+        v.visit_expr(e);
+        v.is_never
+            .then_some(if v.requires_semi && matches!(e.kind, ExprKind::Block(..)) {
+                RequiresSemi::Yes
+            } else {
+                RequiresSemi::No
+            })
+    }
 }
diff --git a/tests/ui/manual_let_else.rs b/tests/ui/manual_let_else.rs
index 27717ab3a73..5d94660ec89 100644
--- a/tests/ui/manual_let_else.rs
+++ b/tests/ui/manual_let_else.rs
@@ -5,7 +5,9 @@
     clippy::let_unit_value,
     clippy::match_single_binding,
     clippy::never_loop,
-    clippy::needless_if
+    clippy::needless_if,
+    clippy::diverging_sub_expression,
+    clippy::single_match
 )]
 #![warn(clippy::manual_let_else)]
 //@no-rustfix
@@ -24,7 +26,7 @@ fn main() {}
 fn fire() {
     let v = if let Some(v_some) = g() { v_some } else { return };
     //~^ ERROR: this could be rewritten as `let...else`
-    //~| NOTE: `-D clippy::manual-let-else` implied by `-D warnings`
+
     let v = if let Some(v_some) = g() {
         //~^ ERROR: this could be rewritten as `let...else`
         v_some
@@ -79,22 +81,76 @@ fn fire() {
         panic!();
     };
 
+    // The final expression will need to be turned into a statement.
+    let v = if let Some(v_some) = g() {
+        //~^ ERROR: this could be rewritten as `let...else`
+        v_some
+    } else {
+        panic!();
+        ()
+    };
+
+    // Even if the result is buried multiple expressions deep.
+    let v = if let Some(v_some) = g() {
+        //~^ ERROR: this could be rewritten as `let...else`
+        v_some
+    } else {
+        panic!();
+        if true {
+            match 0 {
+                0 => (),
+                _ => (),
+            }
+        } else {
+            panic!()
+        }
+    };
+
+    // Or if a break gives the value.
+    let v = if let Some(v_some) = g() {
+        //~^ ERROR: this could be rewritten as `let...else`
+        v_some
+    } else {
+        loop {
+            panic!();
+            break ();
+        }
+    };
+
+    // Even if the break is in a weird position.
+    let v = if let Some(v_some) = g() {
+        //~^ ERROR: this could be rewritten as `let...else`
+        v_some
+    } else {
+        'a: loop {
+            panic!();
+            loop {
+                match 0 {
+                    0 if (return break 'a ()) => {},
+                    _ => {},
+                }
+            }
+        }
+    };
+
     // A match diverges if all branches diverge:
-    // Note: the corresponding let-else requires a ; at the end of the match
-    // as otherwise the type checker does not turn it into a ! type.
     let v = if let Some(v_some) = g() {
         //~^ ERROR: this could be rewritten as `let...else`
         v_some
     } else {
-        match () {
-            _ if panic!() => {},
+        match 0 {
+            0 if true => panic!(),
             _ => panic!(),
-        }
+        };
     };
 
     // An if's expression can cause divergence:
-    let v = if let Some(v_some) = g() { v_some } else { if panic!() {} };
-    //~^ ERROR: this could be rewritten as `let...else`
+    let v = if let Some(v_some) = g() {
+        //~^ ERROR: this could be rewritten as `let...else`
+        v_some
+    } else {
+        if panic!() {};
+    };
 
     // An expression of a match can cause divergence:
     let v = if let Some(v_some) = g() {
@@ -103,7 +159,7 @@ fn fire() {
     } else {
         match panic!() {
             _ => {},
-        }
+        };
     };
 
     // Top level else if
@@ -342,6 +398,43 @@ fn not_fire() {
     } else {
         return;
     };
+
+    // A break that skips the divergent statement will cause the expression to be non-divergent.
+    let _x = if let Some(x) = Some(0) {
+        x
+    } else {
+        'foo: loop {
+            break 'foo 0;
+            panic!();
+        }
+    };
+
+    // Even in inner loops.
+    let _x = if let Some(x) = Some(0) {
+        x
+    } else {
+        'foo: {
+            loop {
+                break 'foo 0;
+            }
+            panic!();
+        }
+    };
+
+    // But a break that can't ever be reached still affects divergence checking.
+    let _x = if let Some(x) = g() {
+        x
+    } else {
+        'foo: {
+            'bar: loop {
+                loop {
+                    break 'bar ();
+                }
+                break 'foo ();
+            }
+            panic!();
+        };
+    };
 }
 
 struct S<T> {
diff --git a/tests/ui/manual_let_else.stderr b/tests/ui/manual_let_else.stderr
index 2b6504a1827..3beaf766efb 100644
--- a/tests/ui/manual_let_else.stderr
+++ b/tests/ui/manual_let_else.stderr
@@ -1,5 +1,5 @@
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:25:5
+  --> $DIR/manual_let_else.rs:27:5
    |
 LL |     let v = if let Some(v_some) = g() { v_some } else { return };
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let Some(v) = g() else { return };`
@@ -8,7 +8,7 @@ LL |     let v = if let Some(v_some) = g() { v_some } else { return };
    = help: to override `-D warnings` add `#[allow(clippy::manual_let_else)]`
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:28:5
+  --> $DIR/manual_let_else.rs:30:5
    |
 LL | /     let v = if let Some(v_some) = g() {
 LL | |
@@ -26,7 +26,7 @@ LL +     };
    |
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:35:5
+  --> $DIR/manual_let_else.rs:37:5
    |
 LL | /     let v = if let Some(v) = g() {
 LL | |
@@ -47,25 +47,25 @@ LL +     };
    |
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:47:9
+  --> $DIR/manual_let_else.rs:49:9
    |
 LL |         let v = if let Some(v_some) = g() { v_some } else { continue };
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let Some(v) = g() else { continue };`
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:49:9
+  --> $DIR/manual_let_else.rs:51:9
    |
 LL |         let v = if let Some(v_some) = g() { v_some } else { break };
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let Some(v) = g() else { break };`
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:54:5
+  --> $DIR/manual_let_else.rs:56:5
    |
 LL |     let v = if let Some(v_some) = g() { v_some } else { panic!() };
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let Some(v) = g() else { panic!() };`
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:58:5
+  --> $DIR/manual_let_else.rs:60:5
    |
 LL | /     let v = if let Some(v_some) = g() {
 LL | |
@@ -83,7 +83,7 @@ LL +     };
    |
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:66:5
+  --> $DIR/manual_let_else.rs:68:5
    |
 LL | /     let v = if let Some(v_some) = g() {
 LL | |
@@ -101,7 +101,7 @@ LL +     };
    |
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:74:5
+  --> $DIR/manual_let_else.rs:76:5
    |
 LL | /     let v = if let Some(v_some) = g() {
 LL | |
@@ -127,6 +127,26 @@ LL | /     let v = if let Some(v_some) = g() {
 LL | |
 LL | |         v_some
 LL | |     } else {
+LL | |         panic!();
+LL | |         ()
+LL | |     };
+   | |______^
+   |
+help: consider writing
+   |
+LL ~     let Some(v) = g() else {
+LL +         panic!();
+LL +         ()
+LL +     };
+   |
+
+error: this could be rewritten as `let...else`
+  --> $DIR/manual_let_else.rs:94:5
+   |
+LL | /     let v = if let Some(v_some) = g() {
+LL | |
+LL | |         v_some
+LL | |     } else {
 ...  |
 LL | |         }
 LL | |     };
@@ -135,21 +155,42 @@ LL | |     };
 help: consider writing
    |
 LL ~     let Some(v) = g() else {
-LL +         match () {
-LL +             _ if panic!() => {},
-LL +             _ => panic!(),
+LL +         panic!();
+LL +         if true {
+LL +             match 0 {
+LL +                 0 => (),
+LL +                 _ => (),
+LL +             }
+LL +         } else {
+LL +             panic!()
 LL +         }
 LL +     };
    |
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:96:5
+  --> $DIR/manual_let_else.rs:110:5
+   |
+LL | /     let v = if let Some(v_some) = g() {
+LL | |
+LL | |         v_some
+LL | |     } else {
+...  |
+LL | |         }
+LL | |     };
+   | |______^
+   |
+help: consider writing
+   |
+LL ~     let Some(v) = g() else {
+LL +         loop {
+LL +             panic!();
+LL +             break ();
+LL +         }
+LL +     };
    |
-LL |     let v = if let Some(v_some) = g() { v_some } 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:100:5
+  --> $DIR/manual_let_else.rs:121:5
    |
 LL | /     let v = if let Some(v_some) = g() {
 LL | |
@@ -163,14 +204,81 @@ LL | |     };
 help: consider writing
    |
 LL ~     let Some(v) = g() else {
+LL +         'a: loop {
+LL +             panic!();
+LL +             loop {
+LL +                 match 0 {
+LL +                     0 if (return break 'a ()) => {},
+LL +                     _ => {},
+LL +                 }
+LL +             }
+LL +         }
+LL +     };
+   |
+
+error: this could be rewritten as `let...else`
+  --> $DIR/manual_let_else.rs:137:5
+   |
+LL | /     let v = if let Some(v_some) = g() {
+LL | |
+LL | |         v_some
+LL | |     } else {
+...  |
+LL | |         };
+LL | |     };
+   | |______^
+   |
+help: consider writing
+   |
+LL ~     let Some(v) = g() else {
+LL +         match 0 {
+LL +             0 if true => panic!(),
+LL +             _ => panic!(),
+LL +         };
+LL +     };
+   |
+
+error: this could be rewritten as `let...else`
+  --> $DIR/manual_let_else.rs:148:5
+   |
+LL | /     let v = if let Some(v_some) = g() {
+LL | |
+LL | |         v_some
+LL | |     } else {
+LL | |         if panic!() {};
+LL | |     };
+   | |______^
+   |
+help: consider writing
+   |
+LL ~     let Some(v) = g() else {
+LL +         if panic!() {};
+LL +     };
+   |
+
+error: this could be rewritten as `let...else`
+  --> $DIR/manual_let_else.rs:156:5
+   |
+LL | /     let v = if let Some(v_some) = g() {
+LL | |
+LL | |         v_some
+LL | |     } else {
+...  |
+LL | |         };
+LL | |     };
+   | |______^
+   |
+help: consider writing
+   |
+LL ~     let Some(v) = g() else {
 LL +         match panic!() {
 LL +             _ => {},
-LL +         }
+LL +         };
 LL +     };
    |
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:110:5
+  --> $DIR/manual_let_else.rs:166:5
    |
 LL | /     let v = if let Some(v_some) = g() {
 LL | |
@@ -191,7 +299,7 @@ LL +     } };
    |
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:120:5
+  --> $DIR/manual_let_else.rs:176:5
    |
 LL | /     let v = if let Some(v_some) = g() {
 LL | |
@@ -220,7 +328,7 @@ LL +     };
    |
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:138:5
+  --> $DIR/manual_let_else.rs:194:5
    |
 LL | /     let (v, w) = if let Some(v_some) = g().map(|v| (v, 42)) {
 LL | |
@@ -238,7 +346,7 @@ LL +     };
    |
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:146:5
+  --> $DIR/manual_let_else.rs:202:5
    |
 LL | /     let (w, S { v }) = if let (Some(v_some), w_some) = (g().map(|_| S { v: 0 }), 0) {
 LL | |
@@ -256,7 +364,7 @@ LL +     };
    |
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:156:13
+  --> $DIR/manual_let_else.rs:212:13
    |
 LL |             let $n = if let Some(v) = $e { v } else { return };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let Some($n) = g() else { return };`
@@ -267,19 +375,19 @@ LL |     create_binding_if_some!(w, g());
    = 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:165:5
+  --> $DIR/manual_let_else.rs:221:5
    |
 LL |     let v = if let Variant::A(a, 0) = e() { a } else { return };
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let Variant::A(v, 0) = e() else { return };`
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:169:5
+  --> $DIR/manual_let_else.rs:225:5
    |
 LL |     let mut v = if let Variant::B(b) = e() { b } else { return };
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let Variant::B(mut v) = e() else { return };`
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:174:5
+  --> $DIR/manual_let_else.rs:230:5
    |
 LL | /     let v = if let Ok(Some(Variant::B(b))) | Err(Some(Variant::A(b, _))) = nested {
 LL | |
@@ -297,19 +405,19 @@ LL +     };
    |
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:181:5
+  --> $DIR/manual_let_else.rs:237:5
    |
 LL |     let v = if let Variant::A(.., a) = e() { a } else { return };
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let Variant::A(.., v) = e() else { return };`
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:185:5
+  --> $DIR/manual_let_else.rs:241:5
    |
 LL |     let w = if let (Some(v), ()) = (g(), ()) { v } else { return };
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let (Some(w), ()) = (g(), ()) else { return };`
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:189:5
+  --> $DIR/manual_let_else.rs:245:5
    |
 LL | /     let w = if let Some(S { v: x }) = Some(S { v: 0 }) {
 LL | |
@@ -327,7 +435,7 @@ LL +     };
    |
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:197:5
+  --> $DIR/manual_let_else.rs:253:5
    |
 LL | /     let v = if let Some(S { v: x }) = Some(S { v: 0 }) {
 LL | |
@@ -345,7 +453,7 @@ LL +     };
    |
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:205:5
+  --> $DIR/manual_let_else.rs:261:5
    |
 LL | /     let (x, S { v }, w) = if let Some(U { v, w, x }) = None::<U<S<()>>> {
 LL | |
@@ -363,7 +471,7 @@ LL +     };
    |
 
 error: this could be rewritten as `let...else`
-  --> $DIR/manual_let_else.rs:322:5
+  --> $DIR/manual_let_else.rs:378:5
    |
 LL | /     let _ = match ff {
 LL | |
@@ -372,5 +480,5 @@ LL | |         _ => macro_call!(),
 LL | |     };
    | |______^ help: consider writing: `let Some(_) = ff else { macro_call!() };`
 
-error: aborting due to 26 previous errors
+error: aborting due to 30 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 9681b4afe09600c175c951705f0a69a51ac30ac8 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Fri, 10 Nov 2023 17:29:28 +0000
Subject: Run `if-to-let-chain clippy*/**/*.rs`

https://github.com/Alexendoo/if-to-let-chain
---
 clippy_lints/src/allow_attributes.rs               |  34 +-
 clippy_lints/src/attrs.rs                          | 124 ++++---
 clippy_lints/src/blocks_in_if_conditions.rs        |  16 +-
 clippy_lints/src/booleans.rs                       |  20 +-
 clippy_lints/src/borrow_deref_ref.rs               | 106 +++---
 clippy_lints/src/cargo/multiple_crate_versions.rs  |  46 ++-
 clippy_lints/src/cargo/wildcard_dependencies.rs    |  24 +-
 clippy_lints/src/casts/cast_sign_loss.rs           |  24 +-
 .../src/casts/cast_slice_different_sizes.rs        |  36 +-
 .../src/casts/cast_slice_from_raw_parts.rs         |  56 ++--
 clippy_lints/src/casts/char_lit_as_u8.rs           |  48 ++-
 clippy_lints/src/casts/ptr_cast_constness.rs       |  44 ++-
 clippy_lints/src/casts/unnecessary_cast.rs         |  92 +++---
 clippy_lints/src/checked_conversions.rs            | 110 +++----
 clippy_lints/src/collapsible_if.rs                 | 100 +++---
 clippy_lints/src/copy_iterator.rs                  |  32 +-
 clippy_lints/src/crate_in_macro_def.rs             |  66 ++--
 clippy_lints/src/create_dir.rs                     |  30 +-
 clippy_lints/src/default.rs                        | 174 +++++-----
 .../src/default_constructed_unit_structs.rs        |  44 ++-
 clippy_lints/src/default_numeric_fallback.rs       | 122 ++++---
 clippy_lints/src/dereference.rs                    |  36 +-
 clippy_lints/src/derivable_impls.rs                | 132 ++++----
 clippy_lints/src/derive.rs                         | 236 +++++++------
 clippy_lints/src/doc.rs                            |  32 +-
 clippy_lints/src/empty_drop.rs                     |  42 ++-
 clippy_lints/src/endian_bytes.rs                   |  34 +-
 clippy_lints/src/exhaustive_items.rs               |  64 ++--
 clippy_lints/src/exit.rs                           |  20 +-
 clippy_lints/src/explicit_write.rs                 |  24 +-
 clippy_lints/src/fallible_impl_from.rs             |  64 ++--
 clippy_lints/src/float_literal.rs                  | 106 +++---
 clippy_lints/src/floating_point_arithmetic.rs      | 364 ++++++++++-----------
 clippy_lints/src/format_args.rs                    |  84 +++--
 clippy_lints/src/format_impl.rs                    | 112 +++----
 clippy_lints/src/formatting.rs                     | 210 ++++++------
 clippy_lints/src/from_str_radix_10.rs              |  66 ++--
 clippy_lints/src/functions/impl_trait_in_params.rs |  66 ++--
 clippy_lints/src/functions/misnamed_getters.rs     |  30 +-
 clippy_lints/src/functions/result.rs               |  92 +++---
 clippy_lints/src/if_let_mutex.rs                   |  18 +-
 clippy_lints/src/implicit_hasher.rs                |  68 ++--
 clippy_lints/src/implicit_saturating_add.rs        |  62 ++--
 clippy_lints/src/implicit_saturating_sub.rs        | 138 ++++----
 .../src/inconsistent_struct_constructor.rs         |  82 +++--
 clippy_lints/src/index_refutable_slice.rs          |  54 ++-
 clippy_lints/src/instant_subtraction.rs            |  36 +-
 clippy_lints/src/large_const_arrays.rs             |  64 ++--
 clippy_lints/src/large_include_file.rs             |  56 ++--
 clippy_lints/src/len_zero.rs                       |  56 ++--
 clippy_lints/src/let_if_seq.rs                     | 142 ++++----
 clippy_lints/src/let_with_type_underscore.rs       |  38 +--
 clippy_lints/src/lifetimes.rs                      |  22 +-
 clippy_lints/src/literal_representation.rs         | 114 ++++---
 clippy_lints/src/loops/explicit_counter_loop.rs    |  98 +++---
 clippy_lints/src/loops/manual_find.rs              | 172 +++++-----
 clippy_lints/src/loops/manual_flatten.rs           | 104 +++---
 clippy_lints/src/loops/manual_memcpy.rs            |  64 ++--
 clippy_lints/src/loops/missing_spin_loop.rs        |  40 ++-
 clippy_lints/src/loops/mut_range_bound.rs          |  30 +-
 clippy_lints/src/loops/needless_range_loop.rs      | 168 +++++-----
 clippy_lints/src/loops/same_item_push.rs           | 116 +++----
 clippy_lints/src/loops/single_element_loop.rs      |  56 ++--
 clippy_lints/src/loops/utils.rs                    |  24 +-
 .../src/loops/while_immutable_condition.rs         |  26 +-
 clippy_lints/src/loops/while_let_on_iterator.rs    |  26 +-
 clippy_lints/src/macro_use.rs                      |  38 +--
 clippy_lints/src/main_recursion.rs                 |  28 +-
 clippy_lints/src/manual_async_fn.rs                | 176 +++++-----
 clippy_lints/src/manual_bits.rs                    |  80 +++--
 clippy_lints/src/manual_strip.rs                   | 162 +++++----
 clippy_lints/src/map_unit_fn.rs                    |  18 +-
 clippy_lints/src/match_result_ok.rs                |  52 ++-
 clippy_lints/src/matches/collapsible_match.rs      |  94 +++---
 .../src/matches/infallible_destructuring_match.rs  |  60 ++--
 clippy_lints/src/matches/manual_filter.rs          |  26 +-
 clippy_lints/src/matches/manual_unwrap_or.rs       |  82 +++--
 clippy_lints/src/matches/manual_utils.rs           |  46 ++-
 clippy_lints/src/matches/match_as_ref.rs           |  42 ++-
 clippy_lints/src/matches/match_like_matches.rs     | 128 ++++----
 clippy_lints/src/matches/match_on_vec_items.rs     |  54 ++-
 clippy_lints/src/matches/match_same_arms.rs        |  28 +-
 .../src/matches/match_str_case_mismatch.rs         |  44 ++-
 clippy_lints/src/matches/match_wild_err_arm.rs     |  26 +-
 .../src/matches/redundant_pattern_match.rs         |  30 +-
 .../src/matches/rest_pat_in_fully_bound_struct.rs  |  36 +-
 clippy_lints/src/matches/single_match.rs           |  84 +++--
 clippy_lints/src/matches/try_err.rs                | 158 +++++----
 clippy_lints/src/mem_replace.rs                    |  98 +++---
 clippy_lints/src/methods/bind_instead_of_map.rs    |  92 +++---
 clippy_lints/src/methods/bytecount.rs              |  74 ++---
 clippy_lints/src/methods/bytes_count_to_len.rs     |  34 +-
 .../case_sensitive_file_extension_comparisons.rs   |  82 +++--
 clippy_lints/src/methods/chars_cmp.rs              |  48 ++-
 clippy_lints/src/methods/chars_cmp_with_unwrap.rs  |  42 ++-
 clippy_lints/src/methods/err_expect.rs             |  32 +-
 clippy_lints/src/methods/extend_with_drain.rs      |  52 ++-
 clippy_lints/src/methods/filetype_is_file.rs       |  28 +-
 clippy_lints/src/methods/filter_map.rs             | 146 ++++-----
 .../src/methods/from_iter_instead_of_collect.rs    | 102 +++---
 clippy_lints/src/methods/get_first.rs              |  40 ++-
 clippy_lints/src/methods/implicit_clone.rs         |  54 ++-
 clippy_lints/src/methods/inefficient_to_string.rs  |  60 ++--
 clippy_lints/src/methods/into_iter_on_ref.rs       |  34 +-
 clippy_lints/src/methods/iter_cloned_collect.rs    |  30 +-
 clippy_lints/src/methods/iter_kv_map.rs            |  96 +++---
 clippy_lints/src/methods/iter_next_slice.rs        |  44 ++-
 clippy_lints/src/methods/iter_skip_next.rs         |  22 +-
 clippy_lints/src/methods/manual_ok_or.rs           |  46 ++-
 .../src/methods/manual_saturating_arithmetic.rs    |  18 +-
 clippy_lints/src/methods/manual_str_repeat.rs      |  70 ++--
 clippy_lints/src/methods/map_clone.rs              |  92 +++---
 .../src/methods/map_collect_result_unit.rs         |  38 +--
 clippy_lints/src/methods/map_identity.rs           |  30 +-
 clippy_lints/src/methods/mod.rs                    |  62 ++--
 clippy_lints/src/methods/mut_mutex_lock.rs         |  32 +-
 clippy_lints/src/methods/no_effect_replace.rs      |  16 +-
 clippy_lints/src/methods/ok_expect.rs              |  28 +-
 clippy_lints/src/methods/option_as_ref_deref.rs    |  38 +--
 clippy_lints/src/methods/option_map_or_none.rs     |  40 ++-
 clippy_lints/src/methods/or_fun_call.rs            |  92 +++---
 .../src/methods/path_buf_push_overwrite.rs         |  42 ++-
 clippy_lints/src/methods/range_zip_with_len.rs     |  32 +-
 clippy_lints/src/methods/search_is_some.rs         | 102 +++---
 clippy_lints/src/methods/single_char_pattern.rs    |  34 +-
 clippy_lints/src/methods/str_splitn.rs             |  50 ++-
 clippy_lints/src/methods/suspicious_map.rs         |  36 +-
 clippy_lints/src/methods/suspicious_splitn.rs      |  64 ++--
 clippy_lints/src/methods/suspicious_to_owned.rs    |  64 ++--
 clippy_lints/src/methods/uninit_assumed_init.rs    |  24 +-
 clippy_lints/src/methods/unnecessary_fold.rs       |  90 +++--
 .../src/methods/unnecessary_iter_cloned.rs         | 116 ++++---
 clippy_lints/src/methods/unnecessary_join.rs       |  34 +-
 clippy_lints/src/methods/unnecessary_sort_by.rs    |  86 +++--
 clippy_lints/src/methods/unnecessary_to_owned.rs   | 310 +++++++++---------
 clippy_lints/src/methods/useless_asref.rs          |  12 +-
 clippy_lints/src/methods/utils.rs                  |  62 ++--
 clippy_lints/src/methods/vec_resize_to_zero.rs     |  46 ++-
 clippy_lints/src/methods/zst_offset.rs             |  12 +-
 clippy_lints/src/misc.rs                           | 126 ++++---
 clippy_lints/src/mismatching_type_param_order.rs   |  98 +++---
 clippy_lints/src/missing_doc.rs                    |  18 +-
 clippy_lints/src/missing_enforced_import_rename.rs |  36 +-
 clippy_lints/src/mixed_read_write_in_expression.rs |  10 +-
 clippy_lints/src/needless_arbitrary_self_type.rs   |  90 +++--
 clippy_lints/src/needless_continue.rs              |  28 +-
 clippy_lints/src/needless_for_each.rs              |  94 +++---
 clippy_lints/src/needless_late_init.rs             |  34 +-
 .../src/needless_parens_on_range_literals.rs       |  24 +-
 clippy_lints/src/needless_pass_by_value.rs         | 184 +++++------
 clippy_lints/src/needless_question_mark.rs         |  44 ++-
 clippy_lints/src/neg_cmp_op_on_partial_ord.rs      |  62 ++--
 clippy_lints/src/neg_multiply.rs                   |  42 ++-
 clippy_lints/src/new_without_default.rs            | 122 ++++---
 clippy_lints/src/no_effect.rs                      | 138 ++++----
 clippy_lints/src/non_copy_const.rs                 |  34 +-
 clippy_lints/src/non_octal_unix_permissions.rs     |  44 ++-
 clippy_lints/src/non_send_fields_in_send_ty.rs     | 124 ++++---
 clippy_lints/src/nonstandard_macro_braces.rs       |  28 +-
 clippy_lints/src/operators/assign_op_pattern.rs    |  68 ++--
 clippy_lints/src/operators/const_comparisons.rs    | 136 ++++----
 clippy_lints/src/operators/float_cmp.rs            |  10 +-
 .../src/operators/float_equality_without_abs.rs    |  60 ++--
 clippy_lints/src/operators/modulo_arithmetic.rs    |  16 +-
 clippy_lints/src/operators/op_ref.rs               |  56 ++--
 clippy_lints/src/operators/ptr_eq.rs               |  30 +-
 clippy_lints/src/option_if_let_else.rs             | 116 ++++---
 clippy_lints/src/overflow_check_conditional.rs     |  60 ++--
 clippy_lints/src/partialeq_ne_impl.rs              |  30 +-
 clippy_lints/src/pass_by_ref_or_value.rs           |  30 +-
 clippy_lints/src/precedence.rs                     |  36 +-
 clippy_lints/src/question_mark.rs                  | 140 ++++----
 clippy_lints/src/ranges.rs                         | 204 ++++++------
 clippy_lints/src/rc_clone_in_vec_init.rs           |  34 +-
 clippy_lints/src/redundant_clone.rs                | 114 +++----
 clippy_lints/src/redundant_closure_call.rs         |  50 ++-
 clippy_lints/src/redundant_locals.rs               |  48 ++-
 clippy_lints/src/redundant_pub_crate.rs            |  42 ++-
 clippy_lints/src/redundant_slicing.rs              | 148 +++++----
 clippy_lints/src/ref_option_ref.rs                 |  46 ++-
 clippy_lints/src/reference.rs                      |  88 +++--
 clippy_lints/src/regex.rs                          |  12 +-
 clippy_lints/src/return_self_not_must_use.rs       |  52 ++-
 clippy_lints/src/returns.rs                        |  80 +++--
 clippy_lints/src/same_name_method.rs               |  38 +--
 clippy_lints/src/self_named_constructors.rs        |  28 +-
 clippy_lints/src/semicolon_if_nothing_returned.rs  |  44 ++-
 clippy_lints/src/size_of_in_element_count.rs       |  78 ++---
 clippy_lints/src/slow_vector_initialization.rs     | 112 +++----
 clippy_lints/src/strings.rs                        | 278 ++++++++--------
 clippy_lints/src/strlen_on_c_strings.rs            |  78 +++--
 clippy_lints/src/suspicious_doc_comments.rs        |  24 +-
 clippy_lints/src/suspicious_operation_groupings.rs | 104 +++---
 clippy_lints/src/suspicious_trait_impl.rs          |  46 ++-
 clippy_lints/src/swap.rs                           |  68 ++--
 clippy_lints/src/tests_outside_test_module.rs      |  26 +-
 clippy_lints/src/to_digit_is_some.rs               |  92 +++---
 clippy_lints/src/trailing_empty_array.rs           |  22 +-
 clippy_lints/src/trait_bounds.rs                   | 302 ++++++++---------
 clippy_lints/src/transmute/mod.rs                  |  80 +++--
 .../src/transmute/transmute_float_to_int.rs        |  16 +-
 clippy_lints/src/transmute/transmute_ref_to_ref.rs | 106 +++---
 .../src/transmute/transmute_undefined_repr.rs      |  14 +-
 clippy_lints/src/types/borrowed_box.rs             | 144 ++++----
 clippy_lints/src/types/box_collection.rs           |  44 ++-
 clippy_lints/src/types/option_option.rs            |  30 +-
 clippy_lints/src/types/rc_mutex.rs                 |  30 +-
 clippy_lints/src/types/utils.rs                    |  16 +-
 clippy_lints/src/uninit_vec.rs                     |  72 ++--
 clippy_lints/src/unit_return_expecting_ord.rs      |  82 +++--
 clippy_lints/src/unit_types/unit_arg.rs            |  38 +--
 clippy_lints/src/unnamed_address.rs                |  84 +++--
 .../src/unnecessary_owned_empty_strings.rs         |  74 ++---
 clippy_lints/src/unnecessary_self_imports.rs       |  54 ++-
 clippy_lints/src/unnecessary_wraps.rs              |  38 +--
 clippy_lints/src/unused_self.rs                    |  36 +-
 clippy_lints/src/unused_unit.rs                    |  72 ++--
 clippy_lints/src/unwrap.rs                         | 190 ++++++-----
 clippy_lints/src/unwrap_in_result.rs               |  12 +-
 clippy_lints/src/use_self.rs                       | 184 +++++------
 clippy_lints/src/useless_conversion.rs             | 108 +++---
 .../src/utils/internal_lints/collapsible_calls.rs  |  76 +++--
 .../internal_lints/compiler_lint_functions.rs      |  30 +-
 .../src/utils/internal_lints/if_chain_style.rs     |  38 +--
 .../internal_lints/interning_defined_symbol.rs     |  88 +++--
 .../src/utils/internal_lints/invalid_paths.rs      |  22 +-
 .../utils/internal_lints/lint_without_lint_pass.rs |  14 +-
 .../src/utils/internal_lints/metadata_collector.rs | 120 ++++---
 .../src/utils/internal_lints/msrv_attr_impl.rs     |  48 ++-
 .../utils/internal_lints/outer_expn_data_pass.rs   |  32 +-
 .../utils/internal_lints/unnecessary_def_path.rs   | 190 ++++++-----
 clippy_lints/src/vec.rs                            |  44 ++-
 clippy_lints/src/wildcard_imports.rs               | 118 ++++---
 clippy_lints/src/zero_div_zero.rs                  |  50 ++-
 clippy_lints/src/zero_sized_map_values.rs          |  26 +-
 clippy_utils/src/consts.rs                         |  40 ++-
 clippy_utils/src/higher.rs                         |  74 ++---
 clippy_utils/src/lib.rs                            | 140 ++++----
 238 files changed, 7895 insertions(+), 8761 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/allow_attributes.rs b/clippy_lints/src/allow_attributes.rs
index e3f4cf79d31..98299e1e4bd 100644
--- a/clippy_lints/src/allow_attributes.rs
+++ b/clippy_lints/src/allow_attributes.rs
@@ -52,24 +52,22 @@ declare_lint_pass!(AllowAttribute => [ALLOW_ATTRIBUTES]);
 impl LateLintPass<'_> for AllowAttribute {
     // Separate each crate's features.
     fn check_attribute<'cx>(&mut self, cx: &LateContext<'cx>, attr: &'cx Attribute) {
-        if_chain! {
-            if !in_external_macro(cx.sess(), attr.span);
-            if cx.tcx.features().lint_reasons;
-            if let AttrStyle::Outer = attr.style;
-            if let Some(ident) = attr.ident();
-            if ident.name == rustc_span::symbol::sym::allow;
-            if !is_from_proc_macro(cx, &attr);
-            then {
-                span_lint_and_sugg(
-                    cx,
-                    ALLOW_ATTRIBUTES,
-                    ident.span,
-                    "#[allow] attribute found",
-                    "replace it with",
-                    "expect".into(),
-                    Applicability::MachineApplicable,
-                );
-            }
+        if !in_external_macro(cx.sess(), attr.span)
+            && cx.tcx.features().lint_reasons
+            && let AttrStyle::Outer = attr.style
+            && let Some(ident) = attr.ident()
+            && ident.name == rustc_span::symbol::sym::allow
+            && !is_from_proc_macro(cx, &attr)
+        {
+            span_lint_and_sugg(
+                cx,
+                ALLOW_ATTRIBUTES,
+                ident.span,
+                "#[allow] attribute found",
+                "replace it with",
+                "expect".into(),
+                Applicability::MachineApplicable,
+            );
         }
     }
 }
diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs
index 64bfa8d904c..112ded59e13 100644
--- a/clippy_lints/src/attrs.rs
+++ b/clippy_lints/src/attrs.rs
@@ -471,13 +471,11 @@ impl<'tcx> LateLintPass<'tcx> for Attributes {
                     return;
                 }
                 for item in items {
-                    if_chain! {
-                        if let NestedMetaItem::MetaItem(mi) = &item;
-                        if let MetaItemKind::NameValue(lit) = &mi.kind;
-                        if mi.has_name(sym::since);
-                        then {
-                            check_semver(cx, item.span(), lit);
-                        }
+                    if let NestedMetaItem::MetaItem(mi) = &item
+                        && let MetaItemKind::NameValue(lit) = &mi.kind
+                        && mi.has_name(sym::since)
+                    {
+                        check_semver(cx, item.span(), lit);
                     }
                 }
             }
@@ -580,15 +578,13 @@ impl<'tcx> LateLintPass<'tcx> for Attributes {
 
 /// Returns the lint name if it is clippy lint.
 fn extract_clippy_lint(lint: &NestedMetaItem) -> Option<Symbol> {
-    if_chain! {
-        if let Some(meta_item) = lint.meta_item();
-        if meta_item.path.segments.len() > 1;
-        if let tool_name = meta_item.path.segments[0].ident;
-        if tool_name.name == sym::clippy;
-        then {
-            let lint_name = meta_item.path.segments.last().unwrap().ident.name;
-            return Some(lint_name);
-        }
+    if let Some(meta_item) = lint.meta_item()
+        && meta_item.path.segments.len() > 1
+        && let tool_name = meta_item.path.segments[0].ident
+        && tool_name.name == sym::clippy
+    {
+        let lint_name = meta_item.path.segments.last().unwrap().ident.name;
+        return Some(lint_name);
     }
     None
 }
@@ -857,18 +853,17 @@ fn check_empty_line_after_outer_attr(cx: &EarlyContext<'_>, item: &rustc_ast::It
 }
 
 fn check_deprecated_cfg_attr(cx: &EarlyContext<'_>, attr: &Attribute, msrv: &Msrv) {
-    if_chain! {
-        if msrv.meets(msrvs::TOOL_ATTRIBUTES);
+    if msrv.meets(msrvs::TOOL_ATTRIBUTES)
         // check cfg_attr
-        if attr.has_name(sym::cfg_attr);
-        if let Some(items) = attr.meta_item_list();
-        if items.len() == 2;
+        && attr.has_name(sym::cfg_attr)
+        && let Some(items) = attr.meta_item_list()
+        && items.len() == 2
         // check for `rustfmt`
-        if let Some(feature_item) = items[0].meta_item();
-        if feature_item.has_name(sym::rustfmt);
+        && let Some(feature_item) = items[0].meta_item()
+        && feature_item.has_name(sym::rustfmt)
         // check for `rustfmt_skip` and `rustfmt::skip`
-        if let Some(skip_item) = &items[1].meta_item();
-        if skip_item.has_name(sym!(rustfmt_skip))
+        && let Some(skip_item) = &items[1].meta_item()
+        && (skip_item.has_name(sym!(rustfmt_skip))
             || skip_item
                 .path
                 .segments
@@ -876,21 +871,20 @@ fn check_deprecated_cfg_attr(cx: &EarlyContext<'_>, attr: &Attribute, msrv: &Msr
                 .expect("empty path in attribute")
                 .ident
                 .name
-                == sym::skip;
+                == sym::skip)
         // Only lint outer attributes, because custom inner attributes are unstable
         // Tracking issue: https://github.com/rust-lang/rust/issues/54726
-        if attr.style == AttrStyle::Outer;
-        then {
-            span_lint_and_sugg(
-                cx,
-                DEPRECATED_CFG_ATTR,
-                attr.span,
-                "`cfg_attr` is deprecated for rustfmt and got replaced by tool attributes",
-                "use",
-                "#[rustfmt::skip]".to_string(),
-                Applicability::MachineApplicable,
-            );
-        }
+        && attr.style == AttrStyle::Outer
+    {
+        span_lint_and_sugg(
+            cx,
+            DEPRECATED_CFG_ATTR,
+            attr.span,
+            "`cfg_attr` is deprecated for rustfmt and got replaced by tool attributes",
+            "use",
+            "#[rustfmt::skip]".to_string(),
+            Applicability::MachineApplicable,
+        );
     }
 }
 
@@ -990,12 +984,10 @@ fn check_mismatched_target_os(cx: &EarlyContext<'_>, attr: &Attribute) {
                         mismatched.extend(find_mismatched_target_os(list));
                     },
                     MetaItemKind::Word => {
-                        if_chain! {
-                            if let Some(ident) = meta.ident();
-                            if let Some(os) = find_os(ident.name.as_str());
-                            then {
-                                mismatched.push((os, ident.span));
-                            }
+                        if let Some(ident) = meta.ident()
+                            && let Some(os) = find_os(ident.name.as_str())
+                        {
+                            mismatched.push((os, ident.span));
                         }
                     },
                     MetaItemKind::NameValue(..) => {},
@@ -1006,30 +998,28 @@ fn check_mismatched_target_os(cx: &EarlyContext<'_>, attr: &Attribute) {
         mismatched
     }
 
-    if_chain! {
-        if attr.has_name(sym::cfg);
-        if let Some(list) = attr.meta_item_list();
-        let mismatched = find_mismatched_target_os(&list);
-        if !mismatched.is_empty();
-        then {
-            let mess = "operating system used in target family position";
-
-            span_lint_and_then(cx, MISMATCHED_TARGET_OS, attr.span, mess, |diag| {
-                // Avoid showing the unix suggestion multiple times in case
-                // we have more than one mismatch for unix-like systems
-                let mut unix_suggested = false;
-
-                for (os, span) in mismatched {
-                    let sugg = format!("target_os = \"{os}\"");
-                    diag.span_suggestion(span, "try", sugg, Applicability::MaybeIncorrect);
-
-                    if !unix_suggested && is_unix(os) {
-                        diag.help("did you mean `unix`?");
-                        unix_suggested = true;
-                    }
+    if attr.has_name(sym::cfg)
+        && let Some(list) = attr.meta_item_list()
+        && let mismatched = find_mismatched_target_os(&list)
+        && !mismatched.is_empty()
+    {
+        let mess = "operating system used in target family position";
+
+        span_lint_and_then(cx, MISMATCHED_TARGET_OS, attr.span, mess, |diag| {
+            // Avoid showing the unix suggestion multiple times in case
+            // we have more than one mismatch for unix-like systems
+            let mut unix_suggested = false;
+
+            for (os, span) in mismatched {
+                let sugg = format!("target_os = \"{os}\"");
+                diag.span_suggestion(span, "try", sugg, Applicability::MaybeIncorrect);
+
+                if !unix_suggested && is_unix(os) {
+                    diag.help("did you mean `unix`?");
+                    unix_suggested = true;
                 }
-            });
-        }
+            }
+        });
     }
 }
 
diff --git a/clippy_lints/src/blocks_in_if_conditions.rs b/clippy_lints/src/blocks_in_if_conditions.rs
index 04bf541a5bd..9ad68f115ea 100644
--- a/clippy_lints/src/blocks_in_if_conditions.rs
+++ b/clippy_lints/src/blocks_in_if_conditions.rs
@@ -114,15 +114,13 @@ impl<'tcx> LateLintPass<'tcx> for BlocksInIfConditions {
                 let _: Option<!> = for_each_expr(cond, |e| {
                     if let ExprKind::Closure(closure) = e.kind {
                         // do not lint if the closure is called using an iterator (see #1141)
-                        if_chain! {
-                            if let Some(parent) = get_parent_expr(cx, e);
-                            if let ExprKind::MethodCall(_, self_arg, _, _) = &parent.kind;
-                            let caller = cx.typeck_results().expr_ty(self_arg);
-                            if let Some(iter_id) = cx.tcx.get_diagnostic_item(sym::Iterator);
-                            if implements_trait(cx, caller, iter_id, &[]);
-                            then {
-                                return ControlFlow::Continue(Descend::No);
-                            }
+                        if let Some(parent) = get_parent_expr(cx, e)
+                            && let ExprKind::MethodCall(_, self_arg, _, _) = &parent.kind
+                            && let caller = cx.typeck_results().expr_ty(self_arg)
+                            && let Some(iter_id) = cx.tcx.get_diagnostic_item(sym::Iterator)
+                            && implements_trait(cx, caller, iter_id, &[])
+                        {
+                            return ControlFlow::Continue(Descend::No);
                         }
 
                         let body = cx.tcx.hir().body(closure.body);
diff --git a/clippy_lints/src/booleans.rs b/clippy_lints/src/booleans.rs
index 37ce65676c7..69550f6879a 100644
--- a/clippy_lints/src/booleans.rs
+++ b/clippy_lints/src/booleans.rs
@@ -152,17 +152,15 @@ impl<'a, 'tcx, 'v> Hir2Qmm<'a, 'tcx, 'v> {
                 return Ok(Bool::Term(n as u8));
             }
 
-            if_chain! {
-                if let ExprKind::Binary(e_binop, e_lhs, e_rhs) = &e.kind;
-                if implements_ord(self.cx, e_lhs);
-                if let ExprKind::Binary(expr_binop, expr_lhs, expr_rhs) = &expr.kind;
-                if negate(e_binop.node) == Some(expr_binop.node);
-                if eq_expr_value(self.cx, e_lhs, expr_lhs);
-                if eq_expr_value(self.cx, e_rhs, expr_rhs);
-                then {
-                    #[expect(clippy::cast_possible_truncation)]
-                    return Ok(Bool::Not(Box::new(Bool::Term(n as u8))));
-                }
+            if let ExprKind::Binary(e_binop, e_lhs, e_rhs) = &e.kind
+                && implements_ord(self.cx, e_lhs)
+                && let ExprKind::Binary(expr_binop, expr_lhs, expr_rhs) = &expr.kind
+                && negate(e_binop.node) == Some(expr_binop.node)
+                && eq_expr_value(self.cx, e_lhs, expr_lhs)
+                && eq_expr_value(self.cx, e_rhs, expr_rhs)
+            {
+                #[expect(clippy::cast_possible_truncation)]
+                return Ok(Bool::Not(Box::new(Bool::Term(n as u8))));
             }
         }
         let n = self.terminals.len();
diff --git a/clippy_lints/src/borrow_deref_ref.rs b/clippy_lints/src/borrow_deref_ref.rs
index 739ce8f67c2..33b7bde3a41 100644
--- a/clippy_lints/src/borrow_deref_ref.rs
+++ b/clippy_lints/src/borrow_deref_ref.rs
@@ -49,69 +49,67 @@ declare_lint_pass!(BorrowDerefRef => [BORROW_DEREF_REF]);
 
 impl<'tcx> LateLintPass<'tcx> for BorrowDerefRef {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &rustc_hir::Expr<'tcx>) {
-        if_chain! {
-            if !e.span.from_expansion();
-            if let ExprKind::AddrOf(_, Mutability::Not, addrof_target) = e.kind;
-            if !addrof_target.span.from_expansion();
-            if let ExprKind::Unary(UnOp::Deref, deref_target) = addrof_target.kind;
-            if !deref_target.span.from_expansion();
-            if !matches!(deref_target.kind, ExprKind::Unary(UnOp::Deref, ..) );
-            let ref_ty = cx.typeck_results().expr_ty(deref_target);
-            if let ty::Ref(_, inner_ty, Mutability::Not) = ref_ty.kind();
-            if !is_from_proc_macro(cx, e);
-            then{
+        if !e.span.from_expansion()
+            && let ExprKind::AddrOf(_, Mutability::Not, addrof_target) = e.kind
+            && !addrof_target.span.from_expansion()
+            && let ExprKind::Unary(UnOp::Deref, deref_target) = addrof_target.kind
+            && !deref_target.span.from_expansion()
+            && !matches!(deref_target.kind, ExprKind::Unary(UnOp::Deref, ..) )
+            && let ref_ty = cx.typeck_results().expr_ty(deref_target)
+            && let ty::Ref(_, inner_ty, Mutability::Not) = ref_ty.kind()
+            && !is_from_proc_macro(cx, e)
+        {
 
-                if let Some(parent_expr) = get_parent_expr(cx, e){
-                    if matches!(parent_expr.kind, ExprKind::Unary(UnOp::Deref, ..)) &&
-                       !is_lint_allowed(cx, DEREF_ADDROF, parent_expr.hir_id) {
-                        return;
-                    }
+            if let Some(parent_expr) = get_parent_expr(cx, e){
+                if matches!(parent_expr.kind, ExprKind::Unary(UnOp::Deref, ..)) &&
+                   !is_lint_allowed(cx, DEREF_ADDROF, parent_expr.hir_id) {
+                    return;
+                }
 
-                    // modification to `&mut &*x` is different from `&mut x`
-                    if matches!(deref_target.kind, ExprKind::Path(..)
-                                             | ExprKind::Field(..)
-                                             | ExprKind::Index(..)
-                                             | ExprKind::Unary(UnOp::Deref, ..))
-                     && matches!(parent_expr.kind, ExprKind::AddrOf(_, Mutability::Mut, _)) {
-                       return;
-                    }
+                // modification to `&mut &*x` is different from `&mut x`
+                if matches!(deref_target.kind, ExprKind::Path(..)
+                                         | ExprKind::Field(..)
+                                         | ExprKind::Index(..)
+                                         | ExprKind::Unary(UnOp::Deref, ..))
+                 && matches!(parent_expr.kind, ExprKind::AddrOf(_, Mutability::Mut, _)) {
+                   return;
                 }
+            }
 
-                span_lint_and_then(
-                    cx,
-                    BORROW_DEREF_REF,
-                    e.span,
-                    "deref on an immutable reference",
-                    |diag| {
-                        diag.span_suggestion(
-                            e.span,
-                            "if you would like to reborrow, try removing `&*`",
-                            snippet_opt(cx, deref_target.span).unwrap(),
-                            Applicability::MachineApplicable
-                        );
+            span_lint_and_then(
+                cx,
+                BORROW_DEREF_REF,
+                e.span,
+                "deref on an immutable reference",
+                |diag| {
+                    diag.span_suggestion(
+                        e.span,
+                        "if you would like to reborrow, try removing `&*`",
+                        snippet_opt(cx, deref_target.span).unwrap(),
+                        Applicability::MachineApplicable
+                    );
 
-                        // has deref trait -> give 2 help
-                        // doesn't have deref trait -> give 1 help
-                        if let Some(deref_trait_id) = cx.tcx.lang_items().deref_trait(){
-                            if !implements_trait(cx, *inner_ty, deref_trait_id, &[]) {
-                                return;
-                            }
+                    // has deref trait -> give 2 help
+                    // doesn't have deref trait -> give 1 help
+                    if let Some(deref_trait_id) = cx.tcx.lang_items().deref_trait(){
+                        if !implements_trait(cx, *inner_ty, deref_trait_id, &[]) {
+                            return;
                         }
+                    }
 
-                        diag.span_suggestion(
-                            e.span,
-                            "if you would like to deref, try using `&**`",
-                            format!(
-                                "&**{}",
-                                &snippet_opt(cx, deref_target.span).unwrap(),
-                             ),
-                            Applicability::MaybeIncorrect
-                        );
+                    diag.span_suggestion(
+                        e.span,
+                        "if you would like to deref, try using `&**`",
+                        format!(
+                            "&**{}",
+                            &snippet_opt(cx, deref_target.span).unwrap(),
+                         ),
+                        Applicability::MaybeIncorrect
+                    );
 
-                    }
-                );
+                }
+            );
 
-            }
         }
     }
 }
diff --git a/clippy_lints/src/cargo/multiple_crate_versions.rs b/clippy_lints/src/cargo/multiple_crate_versions.rs
index f9b17d45e9f..446b1f961b9 100644
--- a/clippy_lints/src/cargo/multiple_crate_versions.rs
+++ b/clippy_lints/src/cargo/multiple_crate_versions.rs
@@ -15,31 +15,29 @@ pub(super) fn check(cx: &LateContext<'_>, metadata: &Metadata) {
     let mut packages = metadata.packages.clone();
     packages.sort_by(|a, b| a.name.cmp(&b.name));
 
-    if_chain! {
-        if let Some(resolve) = &metadata.resolve;
-        if let Some(local_id) = packages
+    if let Some(resolve) = &metadata.resolve
+        && let Some(local_id) = packages
             .iter()
-            .find_map(|p| if p.name == local_name.as_str() { Some(&p.id) } else { None });
-        then {
-            for (name, group) in &packages.iter().group_by(|p| p.name.clone()) {
-                let group: Vec<&Package> = group.collect();
-
-                if group.len() <= 1 {
-                    continue;
-                }
-
-                if group.iter().all(|p| is_normal_dep(&resolve.nodes, local_id, &p.id)) {
-                    let mut versions: Vec<_> = group.into_iter().map(|p| &p.version).collect();
-                    versions.sort();
-                    let versions = versions.iter().join(", ");
-
-                    span_lint(
-                        cx,
-                        MULTIPLE_CRATE_VERSIONS,
-                        DUMMY_SP,
-                        &format!("multiple versions for dependency `{name}`: {versions}"),
-                    );
-                }
+            .find_map(|p| if p.name == local_name.as_str() { Some(&p.id) } else { None })
+    {
+        for (name, group) in &packages.iter().group_by(|p| p.name.clone()) {
+            let group: Vec<&Package> = group.collect();
+
+            if group.len() <= 1 {
+                continue;
+            }
+
+            if group.iter().all(|p| is_normal_dep(&resolve.nodes, local_id, &p.id)) {
+                let mut versions: Vec<_> = group.into_iter().map(|p| &p.version).collect();
+                versions.sort();
+                let versions = versions.iter().join(", ");
+
+                span_lint(
+                    cx,
+                    MULTIPLE_CRATE_VERSIONS,
+                    DUMMY_SP,
+                    &format!("multiple versions for dependency `{name}`: {versions}"),
+                );
             }
         }
     }
diff --git a/clippy_lints/src/cargo/wildcard_dependencies.rs b/clippy_lints/src/cargo/wildcard_dependencies.rs
index 7fa6acbf557..f255963e480 100644
--- a/clippy_lints/src/cargo/wildcard_dependencies.rs
+++ b/clippy_lints/src/cargo/wildcard_dependencies.rs
@@ -9,19 +9,17 @@ use super::WILDCARD_DEPENDENCIES;
 pub(super) fn check(cx: &LateContext<'_>, metadata: &Metadata) {
     for dep in &metadata.packages[0].dependencies {
         // VersionReq::any() does not work
-        if_chain! {
-            if let Ok(wildcard_ver) = semver::VersionReq::parse("*");
-            if let Some(ref source) = dep.source;
-            if !source.starts_with("git");
-            if dep.req == wildcard_ver;
-            then {
-                span_lint(
-                    cx,
-                    WILDCARD_DEPENDENCIES,
-                    DUMMY_SP,
-                    &format!("wildcard dependency for `{}`", dep.name),
-                );
-            }
+        if let Ok(wildcard_ver) = semver::VersionReq::parse("*")
+            && let Some(ref source) = dep.source
+            && !source.starts_with("git")
+            && dep.req == wildcard_ver
+        {
+            span_lint(
+                cx,
+                WILDCARD_DEPENDENCIES,
+                DUMMY_SP,
+                &format!("wildcard dependency for `{}`", dep.name),
+            );
         }
     }
 }
diff --git a/clippy_lints/src/casts/cast_sign_loss.rs b/clippy_lints/src/casts/cast_sign_loss.rs
index a83dfd94dc2..71a2581613d 100644
--- a/clippy_lints/src/casts/cast_sign_loss.rs
+++ b/clippy_lints/src/casts/cast_sign_loss.rs
@@ -28,13 +28,11 @@ fn should_lint(cx: &LateContext<'_>, cast_op: &Expr<'_>, cast_from: Ty<'_>, cast
 
             // Don't lint for positive constants.
             let const_val = constant(cx, cx.typeck_results(), cast_op);
-            if_chain! {
-                if let Some(Constant::Int(n)) = const_val;
-                if let ty::Int(ity) = *cast_from.kind();
-                if sext(cx.tcx, n, ity) >= 0;
-                then {
-                    return false;
-                }
+            if let Some(Constant::Int(n)) = const_val
+                && let ty::Int(ity) = *cast_from.kind()
+                && sext(cx.tcx, n, ity) >= 0
+            {
+                return false;
             }
 
             // Don't lint for the result of methods that always return non-negative values.
@@ -42,13 +40,11 @@ fn should_lint(cx: &LateContext<'_>, cast_op: &Expr<'_>, cast_from: Ty<'_>, cast
                 let mut method_name = path.ident.name.as_str();
                 let allowed_methods = ["abs", "checked_abs", "rem_euclid", "checked_rem_euclid"];
 
-                if_chain! {
-                    if method_name == "unwrap";
-                    if let Some(arglist) = method_chain_args(cast_op, &["unwrap"]);
-                    if let ExprKind::MethodCall(inner_path, ..) = &arglist[0].0.kind;
-                    then {
-                        method_name = inner_path.ident.name.as_str();
-                    }
+                if method_name == "unwrap"
+                    && let Some(arglist) = method_chain_args(cast_op, &["unwrap"])
+                    && let ExprKind::MethodCall(inner_path, ..) = &arglist[0].0.kind
+                {
+                    method_name = inner_path.ident.name.as_str();
                 }
 
                 if allowed_methods.iter().any(|&name| method_name == name) {
diff --git a/clippy_lints/src/casts/cast_slice_different_sizes.rs b/clippy_lints/src/casts/cast_slice_different_sizes.rs
index d1410402913..6eae45e6c7b 100644
--- a/clippy_lints/src/casts/cast_slice_different_sizes.rs
+++ b/clippy_lints/src/casts/cast_slice_different_sizes.rs
@@ -69,26 +69,24 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>, msrv: &Msrv
 
 fn is_child_of_cast(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
     let map = cx.tcx.hir();
-    if_chain! {
-        if let Some(parent_id) = map.opt_parent_id(expr.hir_id);
-        if let Some(parent) = map.find(parent_id);
-        then {
-            let expr = match parent {
-                Node::Block(block) => {
-                    if let Some(parent_expr) = block.expr {
-                        parent_expr
-                    } else {
-                        return false;
-                    }
-                },
-                Node::Expr(expr) => expr,
-                _ => return false,
-            };
+    if let Some(parent_id) = map.opt_parent_id(expr.hir_id)
+        && let Some(parent) = map.find(parent_id)
+    {
+        let expr = match parent {
+            Node::Block(block) => {
+                if let Some(parent_expr) = block.expr {
+                    parent_expr
+                } else {
+                    return false;
+                }
+            },
+            Node::Expr(expr) => expr,
+            _ => return false,
+        };
 
-            matches!(expr.kind, ExprKind::Cast(..))
-        } else {
-            false
-        }
+        matches!(expr.kind, ExprKind::Cast(..))
+    } else {
+        false
     }
 }
 
diff --git a/clippy_lints/src/casts/cast_slice_from_raw_parts.rs b/clippy_lints/src/casts/cast_slice_from_raw_parts.rs
index badadf2c9f6..bacbea39768 100644
--- a/clippy_lints/src/casts/cast_slice_from_raw_parts.rs
+++ b/clippy_lints/src/casts/cast_slice_from_raw_parts.rs
@@ -25,34 +25,32 @@ fn raw_parts_kind(cx: &LateContext<'_>, did: DefId) -> Option<RawPartsKind> {
 }
 
 pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_expr: &Expr<'_>, cast_to: Ty<'_>, msrv: &Msrv) {
-    if_chain! {
-        if msrv.meets(msrvs::PTR_SLICE_RAW_PARTS);
-        if let ty::RawPtr(ptrty) = cast_to.kind();
-        if let ty::Slice(_) = ptrty.ty.kind();
-        if let ExprKind::Call(fun, [ptr_arg, len_arg]) = cast_expr.peel_blocks().kind;
-        if let ExprKind::Path(ref qpath) = fun.kind;
-        if let Some(fun_def_id) = cx.qpath_res(qpath, fun.hir_id).opt_def_id();
-        if let Some(rpk) = raw_parts_kind(cx, fun_def_id);
-        let ctxt = expr.span.ctxt();
-        if cast_expr.span.ctxt() == ctxt;
-        then {
-            let func = match rpk {
-                RawPartsKind::Immutable => "from_raw_parts",
-                RawPartsKind::Mutable => "from_raw_parts_mut"
-            };
-            let span = expr.span;
-            let mut applicability = Applicability::MachineApplicable;
-            let ptr = snippet_with_context(cx, ptr_arg.span, ctxt, "ptr", &mut applicability).0;
-            let len = snippet_with_context(cx, len_arg.span, ctxt, "len", &mut applicability).0;
-            span_lint_and_sugg(
-                cx,
-                CAST_SLICE_FROM_RAW_PARTS,
-                span,
-                &format!("casting the result of `{func}` to {cast_to}"),
-                "replace with",
-                format!("core::ptr::slice_{func}({ptr}, {len})"),
-                applicability
-            );
-        }
+    if msrv.meets(msrvs::PTR_SLICE_RAW_PARTS)
+        && let ty::RawPtr(ptrty) = cast_to.kind()
+        && let ty::Slice(_) = ptrty.ty.kind()
+        && let ExprKind::Call(fun, [ptr_arg, len_arg]) = cast_expr.peel_blocks().kind
+        && let ExprKind::Path(ref qpath) = fun.kind
+        && let Some(fun_def_id) = cx.qpath_res(qpath, fun.hir_id).opt_def_id()
+        && let Some(rpk) = raw_parts_kind(cx, fun_def_id)
+        && let ctxt = expr.span.ctxt()
+        && cast_expr.span.ctxt() == ctxt
+    {
+        let func = match rpk {
+            RawPartsKind::Immutable => "from_raw_parts",
+            RawPartsKind::Mutable => "from_raw_parts_mut"
+        };
+        let span = expr.span;
+        let mut applicability = Applicability::MachineApplicable;
+        let ptr = snippet_with_context(cx, ptr_arg.span, ctxt, "ptr", &mut applicability).0;
+        let len = snippet_with_context(cx, len_arg.span, ctxt, "len", &mut applicability).0;
+        span_lint_and_sugg(
+            cx,
+            CAST_SLICE_FROM_RAW_PARTS,
+            span,
+            &format!("casting the result of `{func}` to {cast_to}"),
+            "replace with",
+            format!("core::ptr::slice_{func}({ptr}, {len})"),
+            applicability
+        );
     }
 }
diff --git a/clippy_lints/src/casts/char_lit_as_u8.rs b/clippy_lints/src/casts/char_lit_as_u8.rs
index 82e07c98a7e..802f2614796 100644
--- a/clippy_lints/src/casts/char_lit_as_u8.rs
+++ b/clippy_lints/src/casts/char_lit_as_u8.rs
@@ -10,32 +10,30 @@ use rustc_middle::ty::{self, UintTy};
 use super::CHAR_LIT_AS_U8;
 
 pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>) {
-    if_chain! {
-        if let ExprKind::Cast(e, _) = &expr.kind;
-        if let ExprKind::Lit(l) = &e.kind;
-        if let LitKind::Char(c) = l.node;
-        if ty::Uint(UintTy::U8) == *cx.typeck_results().expr_ty(expr).kind();
-        then {
-            let mut applicability = Applicability::MachineApplicable;
-            let snippet = snippet_with_applicability(cx, e.span, "'x'", &mut applicability);
+    if let ExprKind::Cast(e, _) = &expr.kind
+        && let ExprKind::Lit(l) = &e.kind
+        && let LitKind::Char(c) = l.node
+        && ty::Uint(UintTy::U8) == *cx.typeck_results().expr_ty(expr).kind()
+    {
+        let mut applicability = Applicability::MachineApplicable;
+        let snippet = snippet_with_applicability(cx, e.span, "'x'", &mut applicability);
 
-            span_lint_and_then(
-                cx,
-                CHAR_LIT_AS_U8,
-                expr.span,
-                "casting a character literal to `u8` truncates",
-                |diag| {
-                    diag.note("`char` is four bytes wide, but `u8` is a single byte");
+        span_lint_and_then(
+            cx,
+            CHAR_LIT_AS_U8,
+            expr.span,
+            "casting a character literal to `u8` truncates",
+            |diag| {
+                diag.note("`char` is four bytes wide, but `u8` is a single byte");
 
-                    if c.is_ascii() {
-                        diag.span_suggestion(
-                            expr.span,
-                            "use a byte literal instead",
-                            format!("b{snippet}"),
-                            applicability,
-                        );
-                    }
-            });
-        }
+                if c.is_ascii() {
+                    diag.span_suggestion(
+                        expr.span,
+                        "use a byte literal instead",
+                        format!("b{snippet}"),
+                        applicability,
+                    );
+                }
+        });
     }
 }
diff --git a/clippy_lints/src/casts/ptr_cast_constness.rs b/clippy_lints/src/casts/ptr_cast_constness.rs
index 0172e933649..68a409824e7 100644
--- a/clippy_lints/src/casts/ptr_cast_constness.rs
+++ b/clippy_lints/src/casts/ptr_cast_constness.rs
@@ -17,29 +17,27 @@ pub(super) fn check<'tcx>(
     cast_to: Ty<'tcx>,
     msrv: &Msrv,
 ) {
-    if_chain! {
-        if msrv.meets(msrvs::POINTER_CAST_CONSTNESS);
-        if let ty::RawPtr(TypeAndMut { mutbl: from_mutbl, ty: from_ty }) = cast_from.kind();
-        if let ty::RawPtr(TypeAndMut { mutbl: to_mutbl, ty: to_ty }) = cast_to.kind();
-        if matches!((from_mutbl, to_mutbl),
-            (Mutability::Not, Mutability::Mut) | (Mutability::Mut, Mutability::Not));
-        if from_ty == to_ty;
-        then {
-            let sugg = Sugg::hir(cx, cast_expr, "_");
-            let constness = match *to_mutbl {
-                Mutability::Not => "const",
-                Mutability::Mut => "mut",
-            };
+    if msrv.meets(msrvs::POINTER_CAST_CONSTNESS)
+        && let ty::RawPtr(TypeAndMut { mutbl: from_mutbl, ty: from_ty }) = cast_from.kind()
+        && let ty::RawPtr(TypeAndMut { mutbl: to_mutbl, ty: to_ty }) = cast_to.kind()
+        && matches!((from_mutbl, to_mutbl),
+            (Mutability::Not, Mutability::Mut) | (Mutability::Mut, Mutability::Not))
+        && from_ty == to_ty
+    {
+        let sugg = Sugg::hir(cx, cast_expr, "_");
+        let constness = match *to_mutbl {
+            Mutability::Not => "const",
+            Mutability::Mut => "mut",
+        };
 
-            span_lint_and_sugg(
-                cx,
-                PTR_CAST_CONSTNESS,
-                expr.span,
-                "`as` casting between raw pointers while changing only its constness",
-                &format!("try `pointer::cast_{constness}`, a safer alternative"),
-                format!("{}.cast_{constness}()", sugg.maybe_par()),
-                Applicability::MachineApplicable,
-            );
-        }
+        span_lint_and_sugg(
+            cx,
+            PTR_CAST_CONSTNESS,
+            expr.span,
+            "`as` casting between raw pointers while changing only its constness",
+            &format!("try `pointer::cast_{constness}`, a safer alternative"),
+            format!("{}.cast_{constness}()", sugg.maybe_par()),
+            Applicability::MachineApplicable,
+        );
     }
 }
diff --git a/clippy_lints/src/casts/unnecessary_cast.rs b/clippy_lints/src/casts/unnecessary_cast.rs
index 61bfce07e1a..e060977d253 100644
--- a/clippy_lints/src/casts/unnecessary_cast.rs
+++ b/clippy_lints/src/casts/unnecessary_cast.rs
@@ -25,40 +25,38 @@ pub(super) fn check<'tcx>(
 ) -> bool {
     let cast_str = snippet_opt(cx, cast_expr.span).unwrap_or_default();
 
-    if_chain! {
-        if let ty::RawPtr(..) = cast_from.kind();
+    if let ty::RawPtr(..) = cast_from.kind()
         // check both mutability and type are the same
-        if cast_from.kind() == cast_to.kind();
-        if let ExprKind::Cast(_, cast_to_hir) = expr.kind;
+        && cast_from.kind() == cast_to.kind()
+        && let ExprKind::Cast(_, cast_to_hir) = expr.kind
         // Ignore casts to e.g. type aliases and infer types
         // - p as pointer_alias
         // - p as _
-        if let TyKind::Ptr(to_pointee) = cast_to_hir.kind;
-        then {
-            match to_pointee.ty.kind {
-                // Ignore casts to pointers that are aliases or cfg dependant, e.g.
-                // - p as *const std::ffi::c_char (alias)
-                // - p as *const std::os::raw::c_char (cfg dependant)
-                TyKind::Path(qpath) => {
-                    if is_ty_alias(&qpath) || is_hir_ty_cfg_dependant(cx, to_pointee.ty) {
-                        return false;
-                    }
-                },
-                // Ignore `p as *const _`
-                TyKind::Infer => return false,
-                _ => {},
-            }
-
-            span_lint_and_sugg(
-                cx,
-                UNNECESSARY_CAST,
-                expr.span,
-                &format!("casting raw pointers to the same type and constness is unnecessary (`{cast_from}` -> `{cast_to}`)"),
-                "try",
-                cast_str.clone(),
-                Applicability::MaybeIncorrect,
-            );
+        && let TyKind::Ptr(to_pointee) = cast_to_hir.kind
+    {
+        match to_pointee.ty.kind {
+            // Ignore casts to pointers that are aliases or cfg dependant, e.g.
+            // - p as *const std::ffi::c_char (alias)
+            // - p as *const std::os::raw::c_char (cfg dependant)
+            TyKind::Path(qpath) => {
+                if is_ty_alias(&qpath) || is_hir_ty_cfg_dependant(cx, to_pointee.ty) {
+                    return false;
+                }
+            },
+            // Ignore `p as *const _`
+            TyKind::Infer => return false,
+            _ => {},
         }
+
+        span_lint_and_sugg(
+            cx,
+            UNNECESSARY_CAST,
+            expr.span,
+            &format!("casting raw pointers to the same type and constness is unnecessary (`{cast_from}` -> `{cast_to}`)"),
+            "try",
+            cast_str.clone(),
+            Applicability::MaybeIncorrect,
+        );
     }
 
     // skip cast of local that is a type alias
@@ -86,14 +84,12 @@ pub(super) fn check<'tcx>(
     }
 
     // skip cast to non-primitive type
-    if_chain! {
-        if let ExprKind::Cast(_, cast_to) = expr.kind;
-        if let TyKind::Path(QPath::Resolved(_, path)) = &cast_to.kind;
-        if let Res::PrimTy(_) = path.res;
-        then {}
-        else {
-            return false;
-        }
+    if let ExprKind::Cast(_, cast_to) = expr.kind
+        && let TyKind::Path(QPath::Resolved(_, path)) = &cast_to.kind
+        && let Res::PrimTy(_) = path.res
+    {}
+    else {
+        return false;
     }
 
     // skip cast of fn call that returns type alias
@@ -106,18 +102,16 @@ pub(super) fn check<'tcx>(
     if let Some(lit) = get_numeric_literal(cast_expr) {
         let literal_str = &cast_str;
 
-        if_chain! {
-            if let LitKind::Int(n, _) = lit.node;
-            if let Some(src) = snippet_opt(cx, cast_expr.span);
-            if cast_to.is_floating_point();
-            if let Some(num_lit) = NumericLiteral::from_lit_kind(&src, &lit.node);
-            let from_nbits = 128 - n.leading_zeros();
-            let to_nbits = fp_ty_mantissa_nbits(cast_to);
-            if from_nbits != 0 && to_nbits != 0 && from_nbits <= to_nbits && num_lit.is_decimal();
-            then {
-                lint_unnecessary_cast(cx, expr, num_lit.integer, cast_from, cast_to);
-                return true
-            }
+        if let LitKind::Int(n, _) = lit.node
+            && let Some(src) = snippet_opt(cx, cast_expr.span)
+            && cast_to.is_floating_point()
+            && let Some(num_lit) = NumericLiteral::from_lit_kind(&src, &lit.node)
+            && let from_nbits = 128 - n.leading_zeros()
+            && let to_nbits = fp_ty_mantissa_nbits(cast_to)
+            && from_nbits != 0 && to_nbits != 0 && from_nbits <= to_nbits && num_lit.is_decimal()
+        {
+            lint_unnecessary_cast(cx, expr, num_lit.integer, cast_from, cast_to);
+            return true
         }
 
         match lit.node {
diff --git a/clippy_lints/src/checked_conversions.rs b/clippy_lints/src/checked_conversions.rs
index d31c2268a65..26ec1dd2d43 100644
--- a/clippy_lints/src/checked_conversions.rs
+++ b/clippy_lints/src/checked_conversions.rs
@@ -55,20 +55,18 @@ impl<'tcx> LateLintPass<'tcx> for CheckedConversions {
             return;
         }
 
-        let result = if_chain! {
-            if !in_constant(cx, item.hir_id);
-            if !in_external_macro(cx.sess(), item.span);
-            if let ExprKind::Binary(op, left, right) = &item.kind;
-
-            then {
-                match op.node {
-                    BinOpKind::Ge | BinOpKind::Le => single_check(item),
-                    BinOpKind::And => double_check(cx, left, right),
-                    _ => None,
-                }
-            } else {
-                None
+        let result = if !in_constant(cx, item.hir_id)
+            && !in_external_macro(cx.sess(), item.span)
+            && let ExprKind::Binary(op, left, right) = &item.kind
+
+        {
+            match op.node {
+                BinOpKind::Ge | BinOpKind::Le => single_check(item),
+                BinOpKind::And => double_check(cx, left, right),
+                _ => None,
             }
+        } else {
+            None
         };
 
         if let Some(cv) = result {
@@ -193,16 +191,14 @@ impl ConversionType {
 
 /// Check for `expr <= (to_type::MAX as from_type)`
 fn check_upper_bound<'tcx>(expr: &'tcx Expr<'tcx>) -> Option<Conversion<'tcx>> {
-    if_chain! {
-         if let ExprKind::Binary(ref op, left, right) = &expr.kind;
-         if let Some((candidate, check)) = normalize_le_ge(op, left, right);
-         if let Some((from, to)) = get_types_from_cast(check, INTS, "max_value", "MAX");
-
-         then {
-             Conversion::try_new(candidate, from, to)
-         } else {
-            None
-        }
+    if let ExprKind::Binary(ref op, left, right) = &expr.kind
+         && let Some((candidate, check)) = normalize_le_ge(op, left, right)
+         && let Some((from, to)) = get_types_from_cast(check, INTS, "max_value", "MAX")
+
+     {
+         Conversion::try_new(candidate, from, to)
+     } else {
+        None
     }
 }
 
@@ -243,33 +239,29 @@ fn get_types_from_cast<'a>(
 ) -> Option<(&'a str, &'a str)> {
     // `to_type::max_value() as from_type`
     // or `to_type::MAX as from_type`
-    let call_from_cast: Option<(&Expr<'_>, &str)> = if_chain! {
+    let call_from_cast: Option<(&Expr<'_>, &str)> = if let ExprKind::Cast(limit, from_type) = &expr.kind
         // to_type::max_value(), from_type
-        if let ExprKind::Cast(limit, from_type) = &expr.kind;
-        if let TyKind::Path(ref from_type_path) = &from_type.kind;
-        if let Some(from_sym) = int_ty_to_sym(from_type_path);
+        && let TyKind::Path(ref from_type_path) = &from_type.kind
+        && let Some(from_sym) = int_ty_to_sym(from_type_path)
 
-        then {
-            Some((limit, from_sym))
-        } else {
-            None
-        }
+    {
+        Some((limit, from_sym))
+    } else {
+        None
     };
 
     // `from_type::from(to_type::max_value())`
     let limit_from: Option<(&Expr<'_>, &str)> = call_from_cast.or_else(|| {
-        if_chain! {
+        if let ExprKind::Call(from_func, [limit]) = &expr.kind
             // `from_type::from, to_type::max_value()`
-            if let ExprKind::Call(from_func, [limit]) = &expr.kind;
             // `from_type::from`
-            if let ExprKind::Path(ref path) = &from_func.kind;
-            if let Some(from_sym) = get_implementing_type(path, INTS, "from");
+            && let ExprKind::Path(ref path) = &from_func.kind
+            && let Some(from_sym) = get_implementing_type(path, INTS, "from")
 
-            then {
-                Some((limit, from_sym))
-            } else {
-                None
-            }
+        {
+            Some((limit, from_sym))
+        } else {
+            None
         }
     });
 
@@ -298,31 +290,27 @@ fn get_types_from_cast<'a>(
 
 /// Gets the type which implements the called function
 fn get_implementing_type<'a>(path: &QPath<'_>, candidates: &'a [&str], function: &str) -> Option<&'a str> {
-    if_chain! {
-        if let QPath::TypeRelative(ty, path) = &path;
-        if path.ident.name.as_str() == function;
-        if let TyKind::Path(QPath::Resolved(None, tp)) = &ty.kind;
-        if let [int] = tp.segments;
-        then {
-            let name = int.ident.name.as_str();
-            candidates.iter().find(|c| &name == *c).copied()
-        } else {
-            None
-        }
+    if let QPath::TypeRelative(ty, path) = &path
+        && path.ident.name.as_str() == function
+        && let TyKind::Path(QPath::Resolved(None, tp)) = &ty.kind
+        && let [int] = tp.segments
+    {
+        let name = int.ident.name.as_str();
+        candidates.iter().find(|c| &name == *c).copied()
+    } else {
+        None
     }
 }
 
 /// Gets the type as a string, if it is a supported integer
 fn int_ty_to_sym<'tcx>(path: &QPath<'_>) -> Option<&'tcx str> {
-    if_chain! {
-        if let QPath::Resolved(_, path) = *path;
-        if let [ty] = path.segments;
-        then {
-            let name = ty.ident.name.as_str();
-            INTS.iter().find(|c| &name == *c).copied()
-        } else {
-            None
-        }
+    if let QPath::Resolved(_, path) = *path
+        && let [ty] = path.segments
+    {
+        let name = ty.ident.name.as_str();
+        INTS.iter().find(|c| &name == *c).copied()
+    } else {
+        None
     }
 }
 
diff --git a/clippy_lints/src/collapsible_if.rs b/clippy_lints/src/collapsible_if.rs
index d21ef195d9b..763a2d2ad89 100644
--- a/clippy_lints/src/collapsible_if.rs
+++ b/clippy_lints/src/collapsible_if.rs
@@ -121,64 +121,60 @@ fn block_starts_with_comment(cx: &EarlyContext<'_>, expr: &ast::Block) -> bool {
 }
 
 fn check_collapsible_maybe_if_let(cx: &EarlyContext<'_>, then_span: Span, else_: &ast::Expr) {
-    if_chain! {
-        if let ast::ExprKind::Block(ref block, _) = else_.kind;
-        if !block_starts_with_comment(cx, block);
-        if let Some(else_) = expr_block(block);
-        if else_.attrs.is_empty();
-        if !else_.span.from_expansion();
-        if let ast::ExprKind::If(..) = else_.kind;
-        then {
-            // Prevent "elseif"
-            // Check that the "else" is followed by whitespace
-            let up_to_else = then_span.between(block.span);
-            let requires_space = if let Some(c) = snippet(cx, up_to_else, "..").chars().last() { !c.is_whitespace() } else { false };
+    if let ast::ExprKind::Block(ref block, _) = else_.kind
+        && !block_starts_with_comment(cx, block)
+        && let Some(else_) = expr_block(block)
+        && else_.attrs.is_empty()
+        && !else_.span.from_expansion()
+        && let ast::ExprKind::If(..) = else_.kind
+    {
+        // Prevent "elseif"
+        // Check that the "else" is followed by whitespace
+        let up_to_else = then_span.between(block.span);
+        let requires_space = if let Some(c) = snippet(cx, up_to_else, "..").chars().last() { !c.is_whitespace() } else { false };
 
-            let mut applicability = Applicability::MachineApplicable;
-            span_lint_and_sugg(
-                cx,
-                COLLAPSIBLE_ELSE_IF,
-                block.span,
-                "this `else { if .. }` block can be collapsed",
-                "collapse nested if block",
-                format!(
-                    "{}{}",
-                    if requires_space { " " } else { "" },
-                    snippet_block_with_applicability(cx, else_.span, "..", Some(block.span), &mut applicability)
-                ),
-                applicability,
-            );
-        }
+        let mut applicability = Applicability::MachineApplicable;
+        span_lint_and_sugg(
+            cx,
+            COLLAPSIBLE_ELSE_IF,
+            block.span,
+            "this `else { if .. }` block can be collapsed",
+            "collapse nested if block",
+            format!(
+                "{}{}",
+                if requires_space { " " } else { "" },
+                snippet_block_with_applicability(cx, else_.span, "..", Some(block.span), &mut applicability)
+            ),
+            applicability,
+        );
     }
 }
 
 fn check_collapsible_no_if_let(cx: &EarlyContext<'_>, expr: &ast::Expr, check: &ast::Expr, then: &ast::Block) {
-    if_chain! {
-        if !block_starts_with_comment(cx, then);
-        if let Some(inner) = expr_block(then);
-        if inner.attrs.is_empty();
-        if let ast::ExprKind::If(ref check_inner, ref content, None) = inner.kind;
+    if !block_starts_with_comment(cx, then)
+        && let Some(inner) = expr_block(then)
+        && inner.attrs.is_empty()
+        && let ast::ExprKind::If(ref check_inner, ref content, None) = inner.kind
         // Prevent triggering on `if c { if let a = b { .. } }`.
-        if !matches!(check_inner.kind, ast::ExprKind::Let(..));
-        let ctxt = expr.span.ctxt();
-        if inner.span.ctxt() == ctxt;
-        then {
-            span_lint_and_then(cx, COLLAPSIBLE_IF, expr.span, "this `if` statement can be collapsed", |diag| {
-                let mut app = Applicability::MachineApplicable;
-                let lhs = Sugg::ast(cx, check, "..", ctxt, &mut app);
-                let rhs = Sugg::ast(cx, check_inner, "..", ctxt, &mut app);
-                diag.span_suggestion(
-                    expr.span,
-                    "collapse nested if block",
-                    format!(
-                        "if {} {}",
-                        lhs.and(&rhs),
-                        snippet_block(cx, content.span, "..", Some(expr.span)),
-                    ),
-                    app, // snippet
-                );
-            });
-        }
+        && !matches!(check_inner.kind, ast::ExprKind::Let(..))
+        && let ctxt = expr.span.ctxt()
+        && inner.span.ctxt() == ctxt
+    {
+        span_lint_and_then(cx, COLLAPSIBLE_IF, expr.span, "this `if` statement can be collapsed", |diag| {
+            let mut app = Applicability::MachineApplicable;
+            let lhs = Sugg::ast(cx, check, "..", ctxt, &mut app);
+            let rhs = Sugg::ast(cx, check_inner, "..", ctxt, &mut app);
+            diag.span_suggestion(
+                expr.span,
+                "collapse nested if block",
+                format!(
+                    "if {} {}",
+                    lhs.and(&rhs),
+                    snippet_block(cx, content.span, "..", Some(expr.span)),
+                ),
+                app, // snippet
+            );
+        });
     }
 }
 
diff --git a/clippy_lints/src/copy_iterator.rs b/clippy_lints/src/copy_iterator.rs
index 5d04ad0112d..9d578054188 100644
--- a/clippy_lints/src/copy_iterator.rs
+++ b/clippy_lints/src/copy_iterator.rs
@@ -38,25 +38,23 @@ declare_lint_pass!(CopyIterator => [COPY_ITERATOR]);
 
 impl<'tcx> LateLintPass<'tcx> for CopyIterator {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
-        if_chain! {
-            if let ItemKind::Impl(Impl {
+        if let ItemKind::Impl(Impl {
                 of_trait: Some(ref trait_ref),
                 ..
-            }) = item.kind;
-            let ty = cx.tcx.type_of(item.owner_id).instantiate_identity();
-            if is_copy(cx, ty);
-            if let Some(trait_id) = trait_ref.trait_def_id();
-            if cx.tcx.is_diagnostic_item(sym::Iterator, trait_id);
-            then {
-                span_lint_and_note(
-                    cx,
-                    COPY_ITERATOR,
-                    item.span,
-                    "you are implementing `Iterator` on a `Copy` type",
-                    None,
-                    "consider implementing `IntoIterator` instead",
-                );
-            }
+            }) = item.kind
+            && let ty = cx.tcx.type_of(item.owner_id).instantiate_identity()
+            && is_copy(cx, ty)
+            && let Some(trait_id) = trait_ref.trait_def_id()
+            && cx.tcx.is_diagnostic_item(sym::Iterator, trait_id)
+        {
+            span_lint_and_note(
+                cx,
+                COPY_ITERATOR,
+                item.span,
+                "you are implementing `Iterator` on a `Copy` type",
+                None,
+                "consider implementing `IntoIterator` instead",
+            );
         }
     }
 }
diff --git a/clippy_lints/src/crate_in_macro_def.rs b/clippy_lints/src/crate_in_macro_def.rs
index a2005638d24..8d9b2ebff7f 100644
--- a/clippy_lints/src/crate_in_macro_def.rs
+++ b/clippy_lints/src/crate_in_macro_def.rs
@@ -53,35 +53,31 @@ declare_lint_pass!(CrateInMacroDef => [CRATE_IN_MACRO_DEF]);
 
 impl EarlyLintPass for CrateInMacroDef {
     fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {
-        if_chain! {
-            if item.attrs.iter().any(is_macro_export);
-            if let ItemKind::MacroDef(macro_def) = &item.kind;
-            let tts = macro_def.body.tokens.clone();
-            if let Some(span) = contains_unhygienic_crate_reference(&tts);
-            then {
-                span_lint_and_sugg(
-                    cx,
-                    CRATE_IN_MACRO_DEF,
-                    span,
-                    "`crate` references the macro call's crate",
-                    "to reference the macro definition's crate, use",
-                    String::from("$crate"),
-                    Applicability::MachineApplicable,
-                );
-            }
+        if item.attrs.iter().any(is_macro_export)
+            && let ItemKind::MacroDef(macro_def) = &item.kind
+            && let tts = macro_def.body.tokens.clone()
+            && let Some(span) = contains_unhygienic_crate_reference(&tts)
+        {
+            span_lint_and_sugg(
+                cx,
+                CRATE_IN_MACRO_DEF,
+                span,
+                "`crate` references the macro call's crate",
+                "to reference the macro definition's crate, use",
+                String::from("$crate"),
+                Applicability::MachineApplicable,
+            );
         }
     }
 }
 
 fn is_macro_export(attr: &Attribute) -> bool {
-    if_chain! {
-        if let AttrKind::Normal(normal) = &attr.kind;
-        if let [segment] = normal.item.path.segments.as_slice();
-        then {
-            segment.ident.name == sym::macro_export
-        } else {
-            false
-        }
+    if let AttrKind::Normal(normal) = &attr.kind
+        && let [segment] = normal.item.path.segments.as_slice()
+    {
+        segment.ident.name == sym::macro_export
+    } else {
+        false
     }
 }
 
@@ -89,14 +85,12 @@ fn contains_unhygienic_crate_reference(tts: &TokenStream) -> Option<Span> {
     let mut prev_is_dollar = false;
     let mut cursor = tts.trees();
     while let Some(curr) = cursor.next() {
-        if_chain! {
-            if !prev_is_dollar;
-            if let Some(span) = is_crate_keyword(curr);
-            if let Some(next) = cursor.look_ahead(0);
-            if is_token(next, &TokenKind::ModSep);
-            then {
-                return Some(span);
-            }
+        if !prev_is_dollar
+            && let Some(span) = is_crate_keyword(curr)
+            && let Some(next) = cursor.look_ahead(0)
+            && is_token(next, &TokenKind::ModSep)
+        {
+            return Some(span);
         }
         if let TokenTree::Delimited(_, _, tts) = &curr {
             let span = contains_unhygienic_crate_reference(tts);
@@ -110,11 +104,9 @@ fn contains_unhygienic_crate_reference(tts: &TokenStream) -> Option<Span> {
 }
 
 fn is_crate_keyword(tt: &TokenTree) -> Option<Span> {
-    if_chain! {
-        if let TokenTree::Token(Token { kind: TokenKind::Ident(symbol, _), span }, _) = tt;
-        if symbol.as_str() == "crate";
-        then { Some(*span) } else { None }
-    }
+    if let TokenTree::Token(Token { kind: TokenKind::Ident(symbol, _), span }, _) = tt
+        && symbol.as_str() == "crate"
+    { Some(*span) } else { None }
 }
 
 fn is_token(tt: &TokenTree, kind: &TokenKind) -> bool {
diff --git a/clippy_lints/src/create_dir.rs b/clippy_lints/src/create_dir.rs
index 2bca695c43b..cd92f38b0ca 100644
--- a/clippy_lints/src/create_dir.rs
+++ b/clippy_lints/src/create_dir.rs
@@ -33,22 +33,20 @@ declare_lint_pass!(CreateDir => [CREATE_DIR]);
 
 impl LateLintPass<'_> for CreateDir {
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
-        if_chain! {
-            if let ExprKind::Call(func, [arg, ..]) = expr.kind;
-            if let ExprKind::Path(ref path) = func.kind;
-            if let Some(def_id) = cx.qpath_res(path, func.hir_id).opt_def_id();
-            if cx.tcx.is_diagnostic_item(sym::fs_create_dir, def_id);
-            then {
-                span_lint_and_sugg(
-                    cx,
-                    CREATE_DIR,
-                    expr.span,
-                    "calling `std::fs::create_dir` where there may be a better way",
-                    "consider calling `std::fs::create_dir_all` instead",
-                    format!("create_dir_all({})", snippet(cx, arg.span, "..")),
-                    Applicability::MaybeIncorrect,
-                )
-            }
+        if let ExprKind::Call(func, [arg, ..]) = expr.kind
+            && let ExprKind::Path(ref path) = func.kind
+            && let Some(def_id) = cx.qpath_res(path, func.hir_id).opt_def_id()
+            && cx.tcx.is_diagnostic_item(sym::fs_create_dir, def_id)
+        {
+            span_lint_and_sugg(
+                cx,
+                CREATE_DIR,
+                expr.span,
+                "calling `std::fs::create_dir` where there may be a better way",
+                "consider calling `std::fs::create_dir_all` instead",
+                format!("create_dir_all({})", snippet(cx, arg.span, "..")),
+                Applicability::MaybeIncorrect,
+            )
         }
     }
 }
diff --git a/clippy_lints/src/default.rs b/clippy_lints/src/default.rs
index c74b2b8831e..1ad71631089 100644
--- a/clippy_lints/src/default.rs
+++ b/clippy_lints/src/default.rs
@@ -81,33 +81,31 @@ impl_lint_pass!(Default => [DEFAULT_TRAIT_ACCESS, FIELD_REASSIGN_WITH_DEFAULT]);
 
 impl<'tcx> LateLintPass<'tcx> for Default {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if_chain! {
-            if !expr.span.from_expansion();
+        if !expr.span.from_expansion()
             // Avoid cases already linted by `field_reassign_with_default`
-            if !self.reassigned_linted.contains(&expr.span);
-            if let ExprKind::Call(path, ..) = expr.kind;
-            if !any_parent_is_automatically_derived(cx.tcx, expr.hir_id);
-            if let ExprKind::Path(ref qpath) = path.kind;
-            if let Some(def_id) = cx.qpath_res(qpath, path.hir_id).opt_def_id();
-            if cx.tcx.is_diagnostic_item(sym::default_fn, def_id);
-            if !is_update_syntax_base(cx, expr);
+            && !self.reassigned_linted.contains(&expr.span)
+            && let ExprKind::Call(path, ..) = expr.kind
+            && !any_parent_is_automatically_derived(cx.tcx, expr.hir_id)
+            && let ExprKind::Path(ref qpath) = path.kind
+            && let Some(def_id) = cx.qpath_res(qpath, path.hir_id).opt_def_id()
+            && cx.tcx.is_diagnostic_item(sym::default_fn, def_id)
+            && !is_update_syntax_base(cx, expr)
             // Detect and ignore <Foo as Default>::default() because these calls do explicitly name the type.
-            if let QPath::Resolved(None, _path) = qpath;
-            let expr_ty = cx.typeck_results().expr_ty(expr);
-            if let ty::Adt(def, ..) = expr_ty.kind();
-            if !is_from_proc_macro(cx, expr);
-            then {
-                let replacement = with_forced_trimmed_paths!(format!("{}::default()", cx.tcx.def_path_str(def.did())));
-                span_lint_and_sugg(
-                    cx,
-                    DEFAULT_TRAIT_ACCESS,
-                    expr.span,
-                    &format!("calling `{replacement}` is more clear than this expression"),
-                    "try",
-                    replacement,
-                    Applicability::Unspecified, // First resolve the TODO above
-                );
-            }
+            && let QPath::Resolved(None, _path) = qpath
+            && let expr_ty = cx.typeck_results().expr_ty(expr)
+            && let ty::Adt(def, ..) = expr_ty.kind()
+            && !is_from_proc_macro(cx, expr)
+        {
+            let replacement = with_forced_trimmed_paths!(format!("{}::default()", cx.tcx.def_path_str(def.did())));
+            span_lint_and_sugg(
+                cx,
+                DEFAULT_TRAIT_ACCESS,
+                expr.span,
+                &format!("calling `{replacement}` is more clear than this expression"),
+                "try",
+                replacement,
+                Applicability::Unspecified, // First resolve the TODO above
+            );
         }
     }
 
@@ -124,38 +122,36 @@ impl<'tcx> LateLintPass<'tcx> for Default {
             // find all binding statements like `let mut _ = T::default()` where `T::default()` is the
             // `default` method of the `Default` trait, and store statement index in current block being
             // checked and the name of the bound variable
-            let (local, variant, binding_name, binding_type, span) = if_chain! {
+            let (local, variant, binding_name, binding_type, span) = if let StmtKind::Local(local) = stmt.kind
                 // only take `let ...` statements
-                if let StmtKind::Local(local) = stmt.kind;
-                if let Some(expr) = local.init;
-                if !any_parent_is_automatically_derived(cx.tcx, expr.hir_id);
-                if !expr.span.from_expansion();
+                && let Some(expr) = local.init
+                && !any_parent_is_automatically_derived(cx.tcx, expr.hir_id)
+                && !expr.span.from_expansion()
                 // only take bindings to identifiers
-                if let PatKind::Binding(_, binding_id, ident, _) = local.pat.kind;
+                && let PatKind::Binding(_, binding_id, ident, _) = local.pat.kind
                 // only when assigning `... = Default::default()`
-                if is_expr_default(expr, cx);
-                let binding_type = cx.typeck_results().node_type(binding_id);
-                if let Some(adt) = binding_type.ty_adt_def();
-                if adt.is_struct();
-                let variant = adt.non_enum_variant();
-                if adt.did().is_local() || !variant.is_field_list_non_exhaustive();
-                let module_did = cx.tcx.parent_module(stmt.hir_id);
-                if variant
+                && is_expr_default(expr, cx)
+                && let binding_type = cx.typeck_results().node_type(binding_id)
+                && let Some(adt) = binding_type.ty_adt_def()
+                && adt.is_struct()
+                && let variant = adt.non_enum_variant()
+                && (adt.did().is_local() || !variant.is_field_list_non_exhaustive())
+                && let module_did = cx.tcx.parent_module(stmt.hir_id)
+                && variant
                     .fields
                     .iter()
-                    .all(|field| field.vis.is_accessible_from(module_did, cx.tcx));
-                let all_fields_are_copy = variant
+                    .all(|field| field.vis.is_accessible_from(module_did, cx.tcx))
+                && let all_fields_are_copy = variant
                     .fields
                     .iter()
                     .all(|field| {
                         is_copy(cx, cx.tcx.type_of(field.did).instantiate_identity())
-                    });
-                if !has_drop(cx, binding_type) || all_fields_are_copy;
-                then {
-                    (local, variant, ident.name, binding_type, expr.span)
-                } else {
-                    continue;
-                }
+                    })
+                && (!has_drop(cx, binding_type) || all_fields_are_copy)
+            {
+                (local, variant, ident.name, binding_type, expr.span)
+            } else {
+                continue;
             };
 
             let init_ctxt = local.span.ctxt();
@@ -216,21 +212,19 @@ impl<'tcx> LateLintPass<'tcx> for Default {
                     .join(", ");
 
                 // give correct suggestion if generics are involved (see #6944)
-                let binding_type = if_chain! {
-                    if let ty::Adt(adt_def, args) = binding_type.kind();
-                    if !args.is_empty();
-                    then {
-                        let adt_def_ty_name = cx.tcx.item_name(adt_def.did());
-                        let generic_args = args.iter().collect::<Vec<_>>();
-                        let tys_str = generic_args
-                            .iter()
-                            .map(ToString::to_string)
-                            .collect::<Vec<_>>()
-                            .join(", ");
-                        format!("{adt_def_ty_name}::<{}>", &tys_str)
-                    } else {
-                        binding_type.to_string()
-                    }
+                let binding_type = if let ty::Adt(adt_def, args) = binding_type.kind()
+                    && !args.is_empty()
+                {
+                    let adt_def_ty_name = cx.tcx.item_name(adt_def.did());
+                    let generic_args = args.iter().collect::<Vec<_>>();
+                    let tys_str = generic_args
+                        .iter()
+                        .map(ToString::to_string)
+                        .collect::<Vec<_>>()
+                        .join(", ");
+                    format!("{adt_def_ty_name}::<{}>", &tys_str)
+                } else {
+                    binding_type.to_string()
                 };
 
                 let sugg = if ext_with_default {
@@ -260,48 +254,42 @@ impl<'tcx> LateLintPass<'tcx> for Default {
 
 /// Checks if the given expression is the `default` method belonging to the `Default` trait.
 fn is_expr_default<'tcx>(expr: &'tcx Expr<'tcx>, cx: &LateContext<'tcx>) -> bool {
-    if_chain! {
-        if let ExprKind::Call(fn_expr, _) = &expr.kind;
-        if let ExprKind::Path(qpath) = &fn_expr.kind;
-        if let Res::Def(_, def_id) = cx.qpath_res(qpath, fn_expr.hir_id);
-        then {
-            // right hand side of assignment is `Default::default`
-            cx.tcx.is_diagnostic_item(sym::default_fn, def_id)
-        } else {
-            false
-        }
+    if let ExprKind::Call(fn_expr, _) = &expr.kind
+        && let ExprKind::Path(qpath) = &fn_expr.kind
+        && let Res::Def(_, def_id) = cx.qpath_res(qpath, fn_expr.hir_id)
+    {
+        // right hand side of assignment is `Default::default`
+        cx.tcx.is_diagnostic_item(sym::default_fn, def_id)
+    } else {
+        false
     }
 }
 
 /// Returns the reassigned field and the assigning expression (right-hand side of assign).
 fn field_reassigned_by_stmt<'tcx>(this: &Stmt<'tcx>, binding_name: Symbol) -> Option<(Ident, &'tcx Expr<'tcx>)> {
-    if_chain! {
+    if let StmtKind::Semi(later_expr) = this.kind
         // only take assignments
-        if let StmtKind::Semi(later_expr) = this.kind;
-        if let ExprKind::Assign(assign_lhs, assign_rhs, _) = later_expr.kind;
+        && let ExprKind::Assign(assign_lhs, assign_rhs, _) = later_expr.kind
         // only take assignments to fields where the left-hand side field is a field of
         // the same binding as the previous statement
-        if let ExprKind::Field(binding, field_ident) = assign_lhs.kind;
-        if let ExprKind::Path(QPath::Resolved(_, path)) = binding.kind;
-        if let Some(second_binding_name) = path.segments.last();
-        if second_binding_name.ident.name == binding_name;
-        then {
-            Some((field_ident, assign_rhs))
-        } else {
-            None
-        }
+        && let ExprKind::Field(binding, field_ident) = assign_lhs.kind
+        && let ExprKind::Path(QPath::Resolved(_, path)) = binding.kind
+        && let Some(second_binding_name) = path.segments.last()
+        && second_binding_name.ident.name == binding_name
+    {
+        Some((field_ident, assign_rhs))
+    } else {
+        None
     }
 }
 
 /// Returns whether `expr` is the update syntax base: `Foo { a: 1, .. base }`
 fn is_update_syntax_base<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> bool {
-    if_chain! {
-        if let Some(parent) = get_parent_expr(cx, expr);
-        if let ExprKind::Struct(_, _, Some(base)) = parent.kind;
-        then {
-            base.hir_id == expr.hir_id
-        } else {
-            false
-        }
+    if let Some(parent) = get_parent_expr(cx, expr)
+        && let ExprKind::Struct(_, _, Some(base)) = parent.kind
+    {
+        base.hir_id == expr.hir_id
+    } else {
+        false
     }
 }
diff --git a/clippy_lints/src/default_constructed_unit_structs.rs b/clippy_lints/src/default_constructed_unit_structs.rs
index bf070432ef9..edd47be5840 100644
--- a/clippy_lints/src/default_constructed_unit_structs.rs
+++ b/clippy_lints/src/default_constructed_unit_structs.rs
@@ -56,32 +56,30 @@ fn is_alias(ty: hir::Ty<'_>) -> bool {
 
 impl LateLintPass<'_> for DefaultConstructedUnitStructs {
     fn check_expr<'tcx>(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'tcx>) {
-        if_chain!(
+        if let hir::ExprKind::Call(fn_expr, &[]) = expr.kind
             // make sure we have a call to `Default::default`
-            if let hir::ExprKind::Call(fn_expr, &[]) = expr.kind;
-            if let ExprKind::Path(ref qpath @ hir::QPath::TypeRelative(base, _)) = fn_expr.kind;
+            && let ExprKind::Path(ref qpath @ hir::QPath::TypeRelative(base, _)) = fn_expr.kind
             // make sure this isn't a type alias:
             // `<Foo as Bar>::Assoc` cannot be used as a constructor
-            if !is_alias(*base);
-            if let Res::Def(_, def_id) = cx.qpath_res(qpath, fn_expr.hir_id);
-            if cx.tcx.is_diagnostic_item(sym::default_fn, def_id);
+            && !is_alias(*base)
+            && let Res::Def(_, def_id) = cx.qpath_res(qpath, fn_expr.hir_id)
+            && cx.tcx.is_diagnostic_item(sym::default_fn, def_id)
             // make sure we have a struct with no fields (unit struct)
-            if let ty::Adt(def, ..) = cx.typeck_results().expr_ty(expr).kind();
-            if def.is_struct();
-            if let var @ ty::VariantDef { ctor: Some((hir::def::CtorKind::Const, _)), .. } = def.non_enum_variant();
-            if !var.is_field_list_non_exhaustive();
-            if !expr.span.from_expansion() && !qpath.span().from_expansion();
-            then {
-                span_lint_and_sugg(
-                    cx,
-                    DEFAULT_CONSTRUCTED_UNIT_STRUCTS,
-                    expr.span.with_lo(qpath.qself_span().hi()),
-                    "use of `default` to create a unit struct",
-                    "remove this call to `default`",
-                    String::new(),
-                    Applicability::MachineApplicable,
-                )
-            }
-        );
+            && let ty::Adt(def, ..) = cx.typeck_results().expr_ty(expr).kind()
+            && def.is_struct()
+            && let var @ ty::VariantDef { ctor: Some((hir::def::CtorKind::Const, _)), .. } = def.non_enum_variant()
+            && !var.is_field_list_non_exhaustive()
+            && !expr.span.from_expansion() && !qpath.span().from_expansion()
+        {
+            span_lint_and_sugg(
+                cx,
+                DEFAULT_CONSTRUCTED_UNIT_STRUCTS,
+                expr.span.with_lo(qpath.qself_span().hi()),
+                "use of `default` to create a unit struct",
+                "remove this call to `default`",
+                String::new(),
+                Applicability::MachineApplicable,
+            )
+        };
     }
 }
diff --git a/clippy_lints/src/default_numeric_fallback.rs b/clippy_lints/src/default_numeric_fallback.rs
index b296ea20f9c..62583b99eaa 100644
--- a/clippy_lints/src/default_numeric_fallback.rs
+++ b/clippy_lints/src/default_numeric_fallback.rs
@@ -82,41 +82,39 @@ impl<'a, 'tcx> NumericFallbackVisitor<'a, 'tcx> {
 
     /// Check whether a passed literal has potential to cause fallback or not.
     fn check_lit(&self, lit: &Lit, lit_ty: Ty<'tcx>, emit_hir_id: HirId) {
-        if_chain! {
-                if !in_external_macro(self.cx.sess(), lit.span);
-                if matches!(self.ty_bounds.last(), Some(ExplicitTyBound(false)));
-                if matches!(lit.node,
-                            LitKind::Int(_, LitIntType::Unsuffixed) | LitKind::Float(_, LitFloatType::Unsuffixed));
-                then {
-                    let (suffix, is_float) = match lit_ty.kind() {
-                        ty::Int(IntTy::I32) => ("i32", false),
-                        ty::Float(FloatTy::F64) => ("f64", true),
-                        // Default numeric fallback never results in other types.
+        if !in_external_macro(self.cx.sess(), lit.span)
+                && matches!(self.ty_bounds.last(), Some(ExplicitTyBound(false)))
+                && matches!(lit.node,
+                            LitKind::Int(_, LitIntType::Unsuffixed) | LitKind::Float(_, LitFloatType::Unsuffixed))
+            {
+                let (suffix, is_float) = match lit_ty.kind() {
+                    ty::Int(IntTy::I32) => ("i32", false),
+                    ty::Float(FloatTy::F64) => ("f64", true),
+                    // Default numeric fallback never results in other types.
+                    _ => return,
+                };
+
+                let src = if let Some(src) = snippet_opt(self.cx, lit.span) {
+                    src
+                } else {
+                    match lit.node {
+                        LitKind::Int(src, _) => format!("{src}"),
+                        LitKind::Float(src, _) => format!("{src}"),
                         _ => return,
-                    };
-
-                    let src = if let Some(src) = snippet_opt(self.cx, lit.span) {
-                        src
-                    } else {
-                        match lit.node {
-                            LitKind::Int(src, _) => format!("{src}"),
-                            LitKind::Float(src, _) => format!("{src}"),
-                            _ => return,
-                        }
-                    };
-                    let sugg = numeric_literal::format(&src, Some(suffix), is_float);
-                    span_lint_hir_and_then(
-                        self.cx,
-                        DEFAULT_NUMERIC_FALLBACK,
-                        emit_hir_id,
-                        lit.span,
-                        "default numeric fallback might occur",
-                        |diag| {
-                            diag.span_suggestion(lit.span, "consider adding suffix", sugg, Applicability::MaybeIncorrect);
-                        }
-                    );
-                }
-        }
+                    }
+                };
+                let sugg = numeric_literal::format(&src, Some(suffix), is_float);
+                span_lint_hir_and_then(
+                    self.cx,
+                    DEFAULT_NUMERIC_FALLBACK,
+                    emit_hir_id,
+                    lit.span,
+                    "default numeric fallback might occur",
+                    |diag| {
+                        diag.span_suggestion(lit.span, "consider adding suffix", sugg, Applicability::MaybeIncorrect);
+                    }
+                );
+            }
     }
 }
 
@@ -149,36 +147,34 @@ impl<'a, 'tcx> Visitor<'tcx> for NumericFallbackVisitor<'a, 'tcx> {
 
             ExprKind::Struct(_, fields, base) => {
                 let ty = self.cx.typeck_results().expr_ty(expr);
-                if_chain! {
-                    if let Some(adt_def) = ty.ty_adt_def();
-                    if adt_def.is_struct();
-                    if let Some(variant) = adt_def.variants().iter().next();
-                    then {
-                        let fields_def = &variant.fields;
-
-                        // Push field type then visit each field expr.
-                        for field in *fields {
-                            let bound =
-                                fields_def
-                                    .iter()
-                                    .find_map(|f_def| {
-                                        if f_def.ident(self.cx.tcx) == field.ident
-                                            { Some(self.cx.tcx.type_of(f_def.did).instantiate_identity()) }
-                                        else { None }
-                                    });
-                            self.ty_bounds.push(bound.into());
-                            self.visit_expr(field.expr);
-                            self.ty_bounds.pop();
-                        }
-
-                        // Visit base with no bound.
-                        if let Some(base) = base {
-                            self.ty_bounds.push(ExplicitTyBound(false));
-                            self.visit_expr(base);
-                            self.ty_bounds.pop();
-                        }
-                        return;
+                if let Some(adt_def) = ty.ty_adt_def()
+                    && adt_def.is_struct()
+                    && let Some(variant) = adt_def.variants().iter().next()
+                {
+                    let fields_def = &variant.fields;
+
+                    // Push field type then visit each field expr.
+                    for field in *fields {
+                        let bound =
+                            fields_def
+                                .iter()
+                                .find_map(|f_def| {
+                                    if f_def.ident(self.cx.tcx) == field.ident
+                                        { Some(self.cx.tcx.type_of(f_def.did).instantiate_identity()) }
+                                    else { None }
+                                });
+                        self.ty_bounds.push(bound.into());
+                        self.visit_expr(field.expr);
+                        self.ty_bounds.pop();
                     }
+
+                    // Visit base with no bound.
+                    if let Some(base) = base {
+                        self.ty_bounds.push(ExplicitTyBound(false));
+                        self.visit_expr(base);
+                        self.ty_bounds.pop();
+                    }
+                    return;
                 }
             },
 
diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index 6c109a51f83..34dd43cfe84 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -597,26 +597,24 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing<'tcx> {
                 return;
             }
 
-            if_chain! {
-                if !pat.span.from_expansion();
-                if let ty::Ref(_, tam, _) = *cx.typeck_results().pat_ty(pat).kind();
+            if !pat.span.from_expansion()
+                && let ty::Ref(_, tam, _) = *cx.typeck_results().pat_ty(pat).kind()
                 // only lint immutable refs, because borrowed `&mut T` cannot be moved out
-                if let ty::Ref(_, _, Mutability::Not) = *tam.kind();
-                then {
-                    let mut app = Applicability::MachineApplicable;
-                    let snip = snippet_with_context(cx, name.span, pat.span.ctxt(), "..", &mut app).0;
-                    self.current_body = self.current_body.or(cx.enclosing_body);
-                    self.ref_locals.insert(
-                        id,
-                        Some(RefPat {
-                            always_deref: true,
-                            spans: vec![pat.span],
-                            app,
-                            replacements: vec![(pat.span, snip.into())],
-                            hir_id: pat.hir_id,
-                        }),
-                    );
-                }
+                && let ty::Ref(_, _, Mutability::Not) = *tam.kind()
+            {
+                let mut app = Applicability::MachineApplicable;
+                let snip = snippet_with_context(cx, name.span, pat.span.ctxt(), "..", &mut app).0;
+                self.current_body = self.current_body.or(cx.enclosing_body);
+                self.ref_locals.insert(
+                    id,
+                    Some(RefPat {
+                        always_deref: true,
+                        spans: vec![pat.span],
+                        app,
+                        replacements: vec![(pat.span, snip.into())],
+                        hir_id: pat.hir_id,
+                    }),
+                );
             }
         }
     }
diff --git a/clippy_lints/src/derivable_impls.rs b/clippy_lints/src/derivable_impls.rs
index a450becc647..233391ff3bb 100644
--- a/clippy_lints/src/derivable_impls.rs
+++ b/clippy_lints/src/derivable_impls.rs
@@ -148,83 +148,79 @@ fn check_struct<'tcx>(
 }
 
 fn check_enum<'tcx>(cx: &LateContext<'tcx>, item: &'tcx Item<'_>, func_expr: &Expr<'_>, adt_def: AdtDef<'_>) {
-    if_chain! {
-        if let ExprKind::Path(QPath::Resolved(None, p)) = &peel_blocks(func_expr).kind;
-        if let Res::Def(DefKind::Ctor(CtorOf::Variant, CtorKind::Const), id) = p.res;
-        if let variant_id = cx.tcx.parent(id);
-        if let Some(variant_def) = adt_def.variants().iter().find(|v| v.def_id == variant_id);
-        if variant_def.fields.is_empty();
-        if !variant_def.is_field_list_non_exhaustive();
-
-        then {
-            let enum_span = cx.tcx.def_span(adt_def.did());
-            let indent_enum = indent_of(cx, enum_span).unwrap_or(0);
-            let variant_span = cx.tcx.def_span(variant_def.def_id);
-            let indent_variant = indent_of(cx, variant_span).unwrap_or(0);
-            span_lint_and_then(
-                cx,
-                DERIVABLE_IMPLS,
-                item.span,
-                "this `impl` can be derived",
-                |diag| {
-                    diag.span_suggestion_hidden(
-                        item.span,
-                        "remove the manual implementation...",
-                        String::new(),
-                        Applicability::MachineApplicable
-                    );
-                    diag.span_suggestion(
-                        enum_span.shrink_to_lo(),
-                        "...and instead derive it...",
-                        format!(
-                            "#[derive(Default)]\n{indent}",
-                            indent = " ".repeat(indent_enum),
-                        ),
-                        Applicability::MachineApplicable
-                    );
-                    diag.span_suggestion(
-                        variant_span.shrink_to_lo(),
-                        "...and mark the default variant",
-                        format!(
-                            "#[default]\n{indent}",
-                            indent = " ".repeat(indent_variant),
-                        ),
-                        Applicability::MachineApplicable
-                    );
-                }
-            );
-        }
+    if let ExprKind::Path(QPath::Resolved(None, p)) = &peel_blocks(func_expr).kind
+        && let Res::Def(DefKind::Ctor(CtorOf::Variant, CtorKind::Const), id) = p.res
+        && let variant_id = cx.tcx.parent(id)
+        && let Some(variant_def) = adt_def.variants().iter().find(|v| v.def_id == variant_id)
+        && variant_def.fields.is_empty()
+        && !variant_def.is_field_list_non_exhaustive()
+
+    {
+        let enum_span = cx.tcx.def_span(adt_def.did());
+        let indent_enum = indent_of(cx, enum_span).unwrap_or(0);
+        let variant_span = cx.tcx.def_span(variant_def.def_id);
+        let indent_variant = indent_of(cx, variant_span).unwrap_or(0);
+        span_lint_and_then(
+            cx,
+            DERIVABLE_IMPLS,
+            item.span,
+            "this `impl` can be derived",
+            |diag| {
+                diag.span_suggestion_hidden(
+                    item.span,
+                    "remove the manual implementation...",
+                    String::new(),
+                    Applicability::MachineApplicable
+                );
+                diag.span_suggestion(
+                    enum_span.shrink_to_lo(),
+                    "...and instead derive it...",
+                    format!(
+                        "#[derive(Default)]\n{indent}",
+                        indent = " ".repeat(indent_enum),
+                    ),
+                    Applicability::MachineApplicable
+                );
+                diag.span_suggestion(
+                    variant_span.shrink_to_lo(),
+                    "...and mark the default variant",
+                    format!(
+                        "#[default]\n{indent}",
+                        indent = " ".repeat(indent_variant),
+                    ),
+                    Applicability::MachineApplicable
+                );
+            }
+        );
     }
 }
 
 impl<'tcx> LateLintPass<'tcx> for DerivableImpls {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
-        if_chain! {
-            if let ItemKind::Impl(Impl {
+        if let ItemKind::Impl(Impl {
                 of_trait: Some(ref trait_ref),
                 items: [child],
                 self_ty,
                 ..
-            }) = item.kind;
-            if !cx.tcx.has_attr(item.owner_id, sym::automatically_derived);
-            if !item.span.from_expansion();
-            if let Some(def_id) = trait_ref.trait_def_id();
-            if cx.tcx.is_diagnostic_item(sym::Default, def_id);
-            if let impl_item_hir = child.id.hir_id();
-            if let Some(Node::ImplItem(impl_item)) = cx.tcx.hir().find(impl_item_hir);
-            if let ImplItemKind::Fn(_, b) = &impl_item.kind;
-            if let Body { value: func_expr, .. } = cx.tcx.hir().body(*b);
-            if let &Adt(adt_def, args) = cx.tcx.type_of(item.owner_id).instantiate_identity().kind();
-            if let attrs = cx.tcx.hir().attrs(item.hir_id());
-            if !attrs.iter().any(|attr| attr.doc_str().is_some());
-            if cx.tcx.hir().attrs(impl_item_hir).is_empty();
-
-            then {
-                if adt_def.is_struct() {
-                    check_struct(cx, item, self_ty, func_expr, adt_def, args, cx.tcx.typeck_body(*b));
-                } else if adt_def.is_enum() && self.msrv.meets(msrvs::DEFAULT_ENUM_ATTRIBUTE) {
-                    check_enum(cx, item, func_expr, adt_def);
-                }
+            }) = item.kind
+            && !cx.tcx.has_attr(item.owner_id, sym::automatically_derived)
+            && !item.span.from_expansion()
+            && let Some(def_id) = trait_ref.trait_def_id()
+            && cx.tcx.is_diagnostic_item(sym::Default, def_id)
+            && let impl_item_hir = child.id.hir_id()
+            && let Some(Node::ImplItem(impl_item)) = cx.tcx.hir().find(impl_item_hir)
+            && let ImplItemKind::Fn(_, b) = &impl_item.kind
+            && let Body { value: func_expr, .. } = cx.tcx.hir().body(*b)
+            && let &Adt(adt_def, args) = cx.tcx.type_of(item.owner_id).instantiate_identity().kind()
+            && let attrs = cx.tcx.hir().attrs(item.hir_id())
+            && !attrs.iter().any(|attr| attr.doc_str().is_some())
+            && cx.tcx.hir().attrs(impl_item_hir).is_empty()
+
+        {
+            if adt_def.is_struct() {
+                check_struct(cx, item, self_ty, func_expr, adt_def, args, cx.tcx.typeck_body(*b));
+            } else if adt_def.is_enum() && self.msrv.meets(msrvs::DEFAULT_ENUM_ATTRIBUTE) {
+                check_enum(cx, item, func_expr, adt_def);
             }
         }
     }
diff --git a/clippy_lints/src/derive.rs b/clippy_lints/src/derive.rs
index 6aaa9e39b8b..6913c87ae01 100644
--- a/clippy_lints/src/derive.rs
+++ b/clippy_lints/src/derive.rs
@@ -233,42 +233,40 @@ fn check_hash_peq<'tcx>(
     ty: Ty<'tcx>,
     hash_is_automatically_derived: bool,
 ) {
-    if_chain! {
-        if let Some(peq_trait_def_id) = cx.tcx.lang_items().eq_trait();
-        if let Some(def_id) = trait_ref.trait_def_id();
-        if cx.tcx.is_diagnostic_item(sym::Hash, def_id);
-        then {
-            // Look for the PartialEq implementations for `ty`
-            cx.tcx.for_each_relevant_impl(peq_trait_def_id, ty, |impl_id| {
-                let peq_is_automatically_derived = cx.tcx.has_attr(impl_id, sym::automatically_derived);
-
-                if !hash_is_automatically_derived || peq_is_automatically_derived {
-                    return;
-                }
-
-                let trait_ref = cx.tcx.impl_trait_ref(impl_id).expect("must be a trait implementation");
-
-                // Only care about `impl PartialEq<Foo> for Foo`
-                // For `impl PartialEq<B> for A, input_types is [A, B]
-                if trait_ref.instantiate_identity().args.type_at(1) == ty {
-                    span_lint_and_then(
-                        cx,
-                        DERIVED_HASH_WITH_MANUAL_EQ,
-                        span,
-                        "you are deriving `Hash` but have implemented `PartialEq` explicitly",
-                        |diag| {
-                            if let Some(local_def_id) = impl_id.as_local() {
-                                let hir_id = cx.tcx.hir().local_def_id_to_hir_id(local_def_id);
-                                diag.span_note(
-                                    cx.tcx.hir().span(hir_id),
-                                    "`PartialEq` implemented here"
-                                );
-                            }
+    if let Some(peq_trait_def_id) = cx.tcx.lang_items().eq_trait()
+        && let Some(def_id) = trait_ref.trait_def_id()
+        && cx.tcx.is_diagnostic_item(sym::Hash, def_id)
+    {
+        // Look for the PartialEq implementations for `ty`
+        cx.tcx.for_each_relevant_impl(peq_trait_def_id, ty, |impl_id| {
+            let peq_is_automatically_derived = cx.tcx.has_attr(impl_id, sym::automatically_derived);
+
+            if !hash_is_automatically_derived || peq_is_automatically_derived {
+                return;
+            }
+
+            let trait_ref = cx.tcx.impl_trait_ref(impl_id).expect("must be a trait implementation");
+
+            // Only care about `impl PartialEq<Foo> for Foo`
+            // For `impl PartialEq<B> for A, input_types is [A, B]
+            if trait_ref.instantiate_identity().args.type_at(1) == ty {
+                span_lint_and_then(
+                    cx,
+                    DERIVED_HASH_WITH_MANUAL_EQ,
+                    span,
+                    "you are deriving `Hash` but have implemented `PartialEq` explicitly",
+                    |diag| {
+                        if let Some(local_def_id) = impl_id.as_local() {
+                            let hir_id = cx.tcx.hir().local_def_id_to_hir_id(local_def_id);
+                            diag.span_note(
+                                cx.tcx.hir().span(hir_id),
+                                "`PartialEq` implemented here"
+                            );
                         }
-                    );
-                }
-            });
-        }
+                    }
+                );
+            }
+        });
     }
 }
 
@@ -280,49 +278,47 @@ fn check_ord_partial_ord<'tcx>(
     ty: Ty<'tcx>,
     ord_is_automatically_derived: bool,
 ) {
-    if_chain! {
-        if let Some(ord_trait_def_id) = cx.tcx.get_diagnostic_item(sym::Ord);
-        if let Some(partial_ord_trait_def_id) = cx.tcx.lang_items().partial_ord_trait();
-        if let Some(def_id) = &trait_ref.trait_def_id();
-        if *def_id == ord_trait_def_id;
-        then {
-            // Look for the PartialOrd implementations for `ty`
-            cx.tcx.for_each_relevant_impl(partial_ord_trait_def_id, ty, |impl_id| {
-                let partial_ord_is_automatically_derived = cx.tcx.has_attr(impl_id, sym::automatically_derived);
-
-                if partial_ord_is_automatically_derived == ord_is_automatically_derived {
-                    return;
-                }
-
-                let trait_ref = cx.tcx.impl_trait_ref(impl_id).expect("must be a trait implementation");
-
-                // Only care about `impl PartialOrd<Foo> for Foo`
-                // For `impl PartialOrd<B> for A, input_types is [A, B]
-                if trait_ref.instantiate_identity().args.type_at(1) == ty {
-                    let mess = if partial_ord_is_automatically_derived {
-                        "you are implementing `Ord` explicitly but have derived `PartialOrd`"
-                    } else {
-                        "you are deriving `Ord` but have implemented `PartialOrd` explicitly"
-                    };
-
-                    span_lint_and_then(
-                        cx,
-                        DERIVE_ORD_XOR_PARTIAL_ORD,
-                        span,
-                        mess,
-                        |diag| {
-                            if let Some(local_def_id) = impl_id.as_local() {
-                                let hir_id = cx.tcx.hir().local_def_id_to_hir_id(local_def_id);
-                                diag.span_note(
-                                    cx.tcx.hir().span(hir_id),
-                                    "`PartialOrd` implemented here"
-                                );
-                            }
+    if let Some(ord_trait_def_id) = cx.tcx.get_diagnostic_item(sym::Ord)
+        && let Some(partial_ord_trait_def_id) = cx.tcx.lang_items().partial_ord_trait()
+        && let Some(def_id) = &trait_ref.trait_def_id()
+        && *def_id == ord_trait_def_id
+    {
+        // Look for the PartialOrd implementations for `ty`
+        cx.tcx.for_each_relevant_impl(partial_ord_trait_def_id, ty, |impl_id| {
+            let partial_ord_is_automatically_derived = cx.tcx.has_attr(impl_id, sym::automatically_derived);
+
+            if partial_ord_is_automatically_derived == ord_is_automatically_derived {
+                return;
+            }
+
+            let trait_ref = cx.tcx.impl_trait_ref(impl_id).expect("must be a trait implementation");
+
+            // Only care about `impl PartialOrd<Foo> for Foo`
+            // For `impl PartialOrd<B> for A, input_types is [A, B]
+            if trait_ref.instantiate_identity().args.type_at(1) == ty {
+                let mess = if partial_ord_is_automatically_derived {
+                    "you are implementing `Ord` explicitly but have derived `PartialOrd`"
+                } else {
+                    "you are deriving `Ord` but have implemented `PartialOrd` explicitly"
+                };
+
+                span_lint_and_then(
+                    cx,
+                    DERIVE_ORD_XOR_PARTIAL_ORD,
+                    span,
+                    mess,
+                    |diag| {
+                        if let Some(local_def_id) = impl_id.as_local() {
+                            let hir_id = cx.tcx.hir().local_def_id_to_hir_id(local_def_id);
+                            diag.span_note(
+                                cx.tcx.hir().span(hir_id),
+                                "`PartialOrd` implemented here"
+                            );
                         }
-                    );
-                }
-            });
-        }
+                    }
+                );
+            }
+        });
     }
 }
 
@@ -395,27 +391,25 @@ fn check_unsafe_derive_deserialize<'tcx>(
         visitor.has_unsafe
     }
 
-    if_chain! {
-        if let Some(trait_def_id) = trait_ref.trait_def_id();
-        if match_def_path(cx, trait_def_id, &paths::SERDE_DESERIALIZE);
-        if let ty::Adt(def, _) = ty.kind();
-        if let Some(local_def_id) = def.did().as_local();
-        let adt_hir_id = cx.tcx.hir().local_def_id_to_hir_id(local_def_id);
-        if !is_lint_allowed(cx, UNSAFE_DERIVE_DESERIALIZE, adt_hir_id);
-        if cx.tcx.inherent_impls(def.did())
+    if let Some(trait_def_id) = trait_ref.trait_def_id()
+        && match_def_path(cx, trait_def_id, &paths::SERDE_DESERIALIZE)
+        && let ty::Adt(def, _) = ty.kind()
+        && let Some(local_def_id) = def.did().as_local()
+        && let adt_hir_id = cx.tcx.hir().local_def_id_to_hir_id(local_def_id)
+        && !is_lint_allowed(cx, UNSAFE_DERIVE_DESERIALIZE, adt_hir_id)
+        && cx.tcx.inherent_impls(def.did())
             .iter()
             .map(|imp_did| cx.tcx.hir().expect_item(imp_did.expect_local()))
-            .any(|imp| has_unsafe(cx, imp));
-        then {
-            span_lint_and_help(
-                cx,
-                UNSAFE_DERIVE_DESERIALIZE,
-                item.span,
-                "you are deriving `serde::Deserialize` on a type that has methods using `unsafe`",
-                None,
-                "consider implementing `serde::Deserialize` manually. See https://serde.rs/impl-deserialize.html"
-            );
-        }
+            .any(|imp| has_unsafe(cx, imp))
+    {
+        span_lint_and_help(
+            cx,
+            UNSAFE_DERIVE_DESERIALIZE,
+            item.span,
+            "you are deriving `serde::Deserialize` on a type that has methods using `unsafe`",
+            None,
+            "consider implementing `serde::Deserialize` manually. See https://serde.rs/impl-deserialize.html"
+        );
     }
 }
 
@@ -432,12 +426,10 @@ impl<'tcx> Visitor<'tcx> for UnsafeVisitor<'_, 'tcx> {
             return;
         }
 
-        if_chain! {
-            if let Some(header) = kind.header();
-            if header.unsafety == Unsafety::Unsafe;
-            then {
-                self.has_unsafe = true;
-            }
+        if let Some(header) = kind.header()
+            && header.unsafety == Unsafety::Unsafe
+        {
+            self.has_unsafe = true;
         }
 
         walk_fn(self, kind, decl, body_id, id);
@@ -464,30 +456,28 @@ impl<'tcx> Visitor<'tcx> for UnsafeVisitor<'_, 'tcx> {
 
 /// Implementation of the `DERIVE_PARTIAL_EQ_WITHOUT_EQ` lint.
 fn check_partial_eq_without_eq<'tcx>(cx: &LateContext<'tcx>, span: Span, trait_ref: &hir::TraitRef<'_>, ty: Ty<'tcx>) {
-    if_chain! {
-        if let ty::Adt(adt, args) = ty.kind();
-        if cx.tcx.visibility(adt.did()).is_public();
-        if let Some(eq_trait_def_id) = cx.tcx.get_diagnostic_item(sym::Eq);
-        if let Some(def_id) = trait_ref.trait_def_id();
-        if cx.tcx.is_diagnostic_item(sym::PartialEq, def_id);
-        let param_env = param_env_for_derived_eq(cx.tcx, adt.did(), eq_trait_def_id);
-        if !implements_trait_with_env(cx.tcx, param_env, ty, eq_trait_def_id, &[]);
+    if let ty::Adt(adt, args) = ty.kind()
+        && cx.tcx.visibility(adt.did()).is_public()
+        && let Some(eq_trait_def_id) = cx.tcx.get_diagnostic_item(sym::Eq)
+        && let Some(def_id) = trait_ref.trait_def_id()
+        && cx.tcx.is_diagnostic_item(sym::PartialEq, def_id)
+        && let param_env = param_env_for_derived_eq(cx.tcx, adt.did(), eq_trait_def_id)
+        && !implements_trait_with_env(cx.tcx, param_env, ty, eq_trait_def_id, &[])
         // If all of our fields implement `Eq`, we can implement `Eq` too
-        if adt
+        && adt
             .all_fields()
             .map(|f| f.ty(cx.tcx, args))
-            .all(|ty| implements_trait_with_env(cx.tcx, param_env, ty, eq_trait_def_id, &[]));
-        then {
-            span_lint_and_sugg(
-                cx,
-                DERIVE_PARTIAL_EQ_WITHOUT_EQ,
-                span.ctxt().outer_expn_data().call_site,
-                "you are deriving `PartialEq` and can implement `Eq`",
-                "consider deriving `Eq` as well",
-                "PartialEq, Eq".to_string(),
-                Applicability::MachineApplicable,
-            )
-        }
+            .all(|ty| implements_trait_with_env(cx.tcx, param_env, ty, eq_trait_def_id, &[]))
+    {
+        span_lint_and_sugg(
+            cx,
+            DERIVE_PARTIAL_EQ_WITHOUT_EQ,
+            span.ctxt().outer_expn_data().call_site,
+            "you are deriving `PartialEq` and can implement `Eq`",
+            "consider deriving `Eq` as well",
+            "PartialEq, Eq".to_string(),
+            Applicability::MachineApplicable,
+        )
     }
 }
 
diff --git a/clippy_lints/src/doc.rs b/clippy_lints/src/doc.rs
index d4a698521ac..f6dde3232bf 100644
--- a/clippy_lints/src/doc.rs
+++ b/clippy_lints/src/doc.rs
@@ -429,23 +429,21 @@ fn lint_for_missing_headers(
                 "docs for function returning `Result` missing `# Errors` section",
             );
         } else {
-            if_chain! {
-                if let Some(body_id) = body_id;
-                if let Some(future) = cx.tcx.lang_items().future_trait();
-                let typeck = cx.tcx.typeck_body(body_id);
-                let body = cx.tcx.hir().body(body_id);
-                let ret_ty = typeck.expr_ty(body.value);
-                if implements_trait(cx, ret_ty, future, &[]);
-                if let ty::Coroutine(_, subs, _) = ret_ty.kind();
-                if is_type_diagnostic_item(cx, subs.as_coroutine().return_ty(), sym::Result);
-                then {
-                    span_lint(
-                        cx,
-                        MISSING_ERRORS_DOC,
-                        span,
-                        "docs for function returning `Result` missing `# Errors` section",
-                    );
-                }
+            if let Some(body_id) = body_id
+                && let Some(future) = cx.tcx.lang_items().future_trait()
+                && let typeck = cx.tcx.typeck_body(body_id)
+                && let body = cx.tcx.hir().body(body_id)
+                && let ret_ty = typeck.expr_ty(body.value)
+                && implements_trait(cx, ret_ty, future, &[])
+                && let ty::Coroutine(_, subs, _) = ret_ty.kind()
+                && is_type_diagnostic_item(cx, subs.as_coroutine().return_ty(), sym::Result)
+            {
+                span_lint(
+                    cx,
+                    MISSING_ERRORS_DOC,
+                    span,
+                    "docs for function returning `Result` missing `# Errors` section",
+                );
             }
         }
     }
diff --git a/clippy_lints/src/empty_drop.rs b/clippy_lints/src/empty_drop.rs
index 5fcdca7cf36..da1103f39e0 100644
--- a/clippy_lints/src/empty_drop.rs
+++ b/clippy_lints/src/empty_drop.rs
@@ -36,31 +36,29 @@ declare_lint_pass!(EmptyDrop => [EMPTY_DROP]);
 
 impl LateLintPass<'_> for EmptyDrop {
     fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
-        if_chain! {
-            if let ItemKind::Impl(Impl {
+        if let ItemKind::Impl(Impl {
                 of_trait: Some(ref trait_ref),
                 items: [child],
                 ..
-            }) = item.kind;
-            if trait_ref.trait_def_id() == cx.tcx.lang_items().drop_trait();
-            if let impl_item_hir = child.id.hir_id();
-            if let Some(Node::ImplItem(impl_item)) = cx.tcx.hir().find(impl_item_hir);
-            if let ImplItemKind::Fn(_, b) = &impl_item.kind;
-            if let Body { value: func_expr, .. } = cx.tcx.hir().body(*b);
-            let func_expr = peel_blocks(func_expr);
-            if let ExprKind::Block(block, _) = func_expr.kind;
-            if block.stmts.is_empty() && block.expr.is_none();
-            then {
-                span_lint_and_sugg(
-                    cx,
-                    EMPTY_DROP,
-                    item.span,
-                    "empty drop implementation",
-                    "try removing this impl",
-                    String::new(),
-                    Applicability::MaybeIncorrect
-                );
-            }
+            }) = item.kind
+            && trait_ref.trait_def_id() == cx.tcx.lang_items().drop_trait()
+            && let impl_item_hir = child.id.hir_id()
+            && let Some(Node::ImplItem(impl_item)) = cx.tcx.hir().find(impl_item_hir)
+            && let ImplItemKind::Fn(_, b) = &impl_item.kind
+            && let Body { value: func_expr, .. } = cx.tcx.hir().body(*b)
+            && let func_expr = peel_blocks(func_expr)
+            && let ExprKind::Block(block, _) = func_expr.kind
+            && block.stmts.is_empty() && block.expr.is_none()
+        {
+            span_lint_and_sugg(
+                cx,
+                EMPTY_DROP,
+                item.span,
+                "empty drop implementation",
+                "try removing this impl",
+                String::new(),
+                Applicability::MaybeIncorrect
+            );
         }
     }
 }
diff --git a/clippy_lints/src/endian_bytes.rs b/clippy_lints/src/endian_bytes.rs
index affd0822120..6f5a0cb8801 100644
--- a/clippy_lints/src/endian_bytes.rs
+++ b/clippy_lints/src/endian_bytes.rs
@@ -114,27 +114,23 @@ impl LateLintPass<'_> for EndianBytes {
             return;
         }
 
-        if_chain! {
-            if let ExprKind::MethodCall(method_name, receiver, args, ..) = expr.kind;
-            if args.is_empty();
-            let ty = cx.typeck_results().expr_ty(receiver);
-            if ty.is_primitive_ty();
-            if maybe_lint_endian_bytes(cx, expr, Prefix::To, method_name.ident.name, ty);
-            then {
-                return;
-            }
+        if let ExprKind::MethodCall(method_name, receiver, args, ..) = expr.kind
+            && args.is_empty()
+            && let ty = cx.typeck_results().expr_ty(receiver)
+            && ty.is_primitive_ty()
+            && maybe_lint_endian_bytes(cx, expr, Prefix::To, method_name.ident.name, ty)
+        {
+            return;
         }
 
-        if_chain! {
-            if let ExprKind::Call(function, ..) = expr.kind;
-            if let ExprKind::Path(qpath) = function.kind;
-            if let Some(def_id) = cx.qpath_res(&qpath, function.hir_id).opt_def_id();
-            if let Some(function_name) = cx.get_def_path(def_id).last();
-            let ty = cx.typeck_results().expr_ty(expr);
-            if ty.is_primitive_ty();
-            then {
-                maybe_lint_endian_bytes(cx, expr, Prefix::From, *function_name, ty);
-            }
+        if let ExprKind::Call(function, ..) = expr.kind
+            && let ExprKind::Path(qpath) = function.kind
+            && let Some(def_id) = cx.qpath_res(&qpath, function.hir_id).opt_def_id()
+            && let Some(function_name) = cx.get_def_path(def_id).last()
+            && let ty = cx.typeck_results().expr_ty(expr)
+            && ty.is_primitive_ty()
+        {
+            maybe_lint_endian_bytes(cx, expr, Prefix::From, *function_name, ty);
         }
     }
 }
diff --git a/clippy_lints/src/exhaustive_items.rs b/clippy_lints/src/exhaustive_items.rs
index f976cfd3f22..201bf13a0df 100644
--- a/clippy_lints/src/exhaustive_items.rs
+++ b/clippy_lints/src/exhaustive_items.rs
@@ -71,40 +71,38 @@ declare_lint_pass!(ExhaustiveItems => [EXHAUSTIVE_ENUMS, EXHAUSTIVE_STRUCTS]);
 
 impl LateLintPass<'_> for ExhaustiveItems {
     fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
-        if_chain! {
-            if let ItemKind::Enum(..) | ItemKind::Struct(..) = item.kind;
-            if cx.effective_visibilities.is_exported(item.owner_id.def_id);
-            let attrs = cx.tcx.hir().attrs(item.hir_id());
-            if !attrs.iter().any(|a| a.has_name(sym::non_exhaustive));
-            then {
-                let (lint, msg) = if let ItemKind::Struct(ref v, ..) = item.kind {
-                    if v.fields().iter().any(|f| {
-                        !cx.tcx.visibility(f.def_id).is_public()
-                    }) {
-                        // skip structs with private fields
-                        return;
-                    }
-                    (EXHAUSTIVE_STRUCTS, "exported structs should not be exhaustive")
-                } else {
-                    (EXHAUSTIVE_ENUMS, "exported enums should not be exhaustive")
-                };
-                let suggestion_span = item.span.shrink_to_lo();
-                let indent = " ".repeat(indent_of(cx, item.span).unwrap_or(0));
-                span_lint_and_then(
-                    cx,
-                    lint,
-                    item.span,
-                    msg,
-                    |diag| {
-                        let sugg = format!("#[non_exhaustive]\n{indent}");
-                        diag.span_suggestion(suggestion_span,
-                                             "try adding #[non_exhaustive]",
-                                             sugg,
-                                             Applicability::MaybeIncorrect);
-                    }
-                );
+        if let ItemKind::Enum(..) | ItemKind::Struct(..) = item.kind
+            && cx.effective_visibilities.is_exported(item.owner_id.def_id)
+            && let attrs = cx.tcx.hir().attrs(item.hir_id())
+            && !attrs.iter().any(|a| a.has_name(sym::non_exhaustive))
+        {
+            let (lint, msg) = if let ItemKind::Struct(ref v, ..) = item.kind {
+                if v.fields().iter().any(|f| {
+                    !cx.tcx.visibility(f.def_id).is_public()
+                }) {
+                    // skip structs with private fields
+                    return;
+                }
+                (EXHAUSTIVE_STRUCTS, "exported structs should not be exhaustive")
+            } else {
+                (EXHAUSTIVE_ENUMS, "exported enums should not be exhaustive")
+            };
+            let suggestion_span = item.span.shrink_to_lo();
+            let indent = " ".repeat(indent_of(cx, item.span).unwrap_or(0));
+            span_lint_and_then(
+                cx,
+                lint,
+                item.span,
+                msg,
+                |diag| {
+                    let sugg = format!("#[non_exhaustive]\n{indent}");
+                    diag.span_suggestion(suggestion_span,
+                                         "try adding #[non_exhaustive]",
+                                         sugg,
+                                         Applicability::MaybeIncorrect);
+                }
+            );
 
-            }
         }
     }
 }
diff --git a/clippy_lints/src/exit.rs b/clippy_lints/src/exit.rs
index e14b1c556ec..a366749560b 100644
--- a/clippy_lints/src/exit.rs
+++ b/clippy_lints/src/exit.rs
@@ -42,19 +42,17 @@ declare_lint_pass!(Exit => [EXIT]);
 
 impl<'tcx> LateLintPass<'tcx> for Exit {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
-        if_chain! {
-            if let ExprKind::Call(path_expr, _args) = e.kind;
-            if let ExprKind::Path(ref path) = path_expr.kind;
-            if let Some(def_id) = cx.qpath_res(path, path_expr.hir_id).opt_def_id();
-            if cx.tcx.is_diagnostic_item(sym::process_exit, def_id);
-            let parent = cx.tcx.hir().get_parent_item(e.hir_id).def_id;
-            if let Some(Node::Item(Item{kind: ItemKind::Fn(..), ..})) = cx.tcx.hir().find_by_def_id(parent);
+        if let ExprKind::Call(path_expr, _args) = e.kind
+            && let ExprKind::Path(ref path) = path_expr.kind
+            && let Some(def_id) = cx.qpath_res(path, path_expr.hir_id).opt_def_id()
+            && cx.tcx.is_diagnostic_item(sym::process_exit, def_id)
+            && let parent = cx.tcx.hir().get_parent_item(e.hir_id).def_id
+            && let Some(Node::Item(Item{kind: ItemKind::Fn(..), ..})) = cx.tcx.hir().find_by_def_id(parent)
             // If the next item up is a function we check if it is an entry point
             // and only then emit a linter warning
-            if !is_entrypoint_fn(cx, parent.to_def_id());
-            then {
-                span_lint(cx, EXIT, e.span, "usage of `process::exit`");
-            }
+            && !is_entrypoint_fn(cx, parent.to_def_id())
+        {
+            span_lint(cx, EXIT, e.span, "usage of `process::exit`");
         }
     }
 }
diff --git a/clippy_lints/src/explicit_write.rs b/clippy_lints/src/explicit_write.rs
index 4b5bcb06a1e..c8d901d08bd 100644
--- a/clippy_lints/src/explicit_write.rs
+++ b/clippy_lints/src/explicit_write.rs
@@ -101,30 +101,28 @@ impl<'tcx> LateLintPass<'tcx> for ExplicitWrite {
 /// If `kind` is a block that looks like `{ let result = $expr; result }` then
 /// returns $expr. Otherwise returns `kind`.
 fn look_in_block<'tcx, 'hir>(cx: &LateContext<'tcx>, kind: &'tcx ExprKind<'hir>) -> &'tcx ExprKind<'hir> {
-    if_chain! {
-        if let ExprKind::Block(block, _label @ None) = kind;
-        if let Block {
+    if let ExprKind::Block(block, _label @ None) = kind
+        && let Block {
             stmts: [Stmt { kind: StmtKind::Local(local), .. }],
             expr: Some(expr_end_of_block),
             rules: BlockCheckMode::DefaultBlock,
             ..
-        } = block;
+        } = block
 
         // Find id of the local that expr_end_of_block resolves to
-        if let ExprKind::Path(QPath::Resolved(None, expr_path)) = expr_end_of_block.kind;
-        if let Res::Local(expr_res) = expr_path.res;
-        if let Some(Node::Pat(res_pat)) = cx.tcx.hir().find(expr_res);
+        && let ExprKind::Path(QPath::Resolved(None, expr_path)) = expr_end_of_block.kind
+        && let Res::Local(expr_res) = expr_path.res
+        && let Some(Node::Pat(res_pat)) = cx.tcx.hir().find(expr_res)
 
         // Find id of the local we found in the block
-        if let PatKind::Binding(BindingAnnotation::NONE, local_hir_id, _ident, None) = local.pat.kind;
+        && let PatKind::Binding(BindingAnnotation::NONE, local_hir_id, _ident, None) = local.pat.kind
 
         // If those two are the same hir id
-        if res_pat.hir_id == local_hir_id;
+        && res_pat.hir_id == local_hir_id
 
-        if let Some(init) = local.init;
-        then {
-            return &init.kind;
-        }
+        && let Some(init) = local.init
+    {
+        return &init.kind;
     }
     kind
 }
diff --git a/clippy_lints/src/fallible_impl_from.rs b/clippy_lints/src/fallible_impl_from.rs
index efb69476b94..5824f462f4b 100644
--- a/clippy_lints/src/fallible_impl_from.rs
+++ b/clippy_lints/src/fallible_impl_from.rs
@@ -53,13 +53,11 @@ declare_lint_pass!(FallibleImplFrom => [FALLIBLE_IMPL_FROM]);
 impl<'tcx> LateLintPass<'tcx> for FallibleImplFrom {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) {
         // check for `impl From<???> for ..`
-        if_chain! {
-            if let hir::ItemKind::Impl(impl_) = &item.kind;
-            if let Some(impl_trait_ref) = cx.tcx.impl_trait_ref(item.owner_id);
-            if cx.tcx.is_diagnostic_item(sym::From, impl_trait_ref.skip_binder().def_id);
-            then {
-                lint_impl_body(cx, item.span, impl_.items);
-            }
+        if let hir::ItemKind::Impl(impl_) = &item.kind
+            && let Some(impl_trait_ref) = cx.tcx.impl_trait_ref(item.owner_id)
+            && cx.tcx.is_diagnostic_item(sym::From, impl_trait_ref.skip_binder().def_id)
+        {
+            lint_impl_body(cx, item.span, impl_.items);
         }
     }
 }
@@ -98,34 +96,32 @@ fn lint_impl_body(cx: &LateContext<'_>, impl_span: Span, impl_items: &[hir::Impl
     }
 
     for impl_item in impl_items {
-        if_chain! {
-            if impl_item.ident.name == sym::from;
-            if let ImplItemKind::Fn(_, body_id) =
-                cx.tcx.hir().impl_item(impl_item.id).kind;
-            then {
-                // check the body for `begin_panic` or `unwrap`
-                let body = cx.tcx.hir().body(body_id);
-                let mut fpu = FindPanicUnwrap {
-                    lcx: cx,
-                    typeck_results: cx.tcx.typeck(impl_item.id.owner_id.def_id),
-                    result: Vec::new(),
-                };
-                fpu.visit_expr(body.value);
+        if impl_item.ident.name == sym::from
+            && let ImplItemKind::Fn(_, body_id) =
+                cx.tcx.hir().impl_item(impl_item.id).kind
+        {
+            // check the body for `begin_panic` or `unwrap`
+            let body = cx.tcx.hir().body(body_id);
+            let mut fpu = FindPanicUnwrap {
+                lcx: cx,
+                typeck_results: cx.tcx.typeck(impl_item.id.owner_id.def_id),
+                result: Vec::new(),
+            };
+            fpu.visit_expr(body.value);
 
-                // if we've found one, lint
-                if !fpu.result.is_empty() {
-                    span_lint_and_then(
-                        cx,
-                        FALLIBLE_IMPL_FROM,
-                        impl_span,
-                        "consider implementing `TryFrom` instead",
-                        move |diag| {
-                            diag.help(
-                                "`From` is intended for infallible conversions only. \
-                                Use `TryFrom` if there's a possibility for the conversion to fail");
-                            diag.span_note(fpu.result, "potential failure(s)");
-                        });
-                }
+            // if we've found one, lint
+            if !fpu.result.is_empty() {
+                span_lint_and_then(
+                    cx,
+                    FALLIBLE_IMPL_FROM,
+                    impl_span,
+                    "consider implementing `TryFrom` instead",
+                    move |diag| {
+                        diag.help(
+                            "`From` is intended for infallible conversions only. \
+                            Use `TryFrom` if there's a possibility for the conversion to fail");
+                        diag.span_note(fpu.result, "potential failure(s)");
+                    });
             }
         }
     }
diff --git a/clippy_lints/src/float_literal.rs b/clippy_lints/src/float_literal.rs
index 506a1191747..07640a77584 100644
--- a/clippy_lints/src/float_literal.rs
+++ b/clippy_lints/src/float_literal.rs
@@ -64,73 +64,71 @@ declare_lint_pass!(FloatLiteral => [EXCESSIVE_PRECISION, LOSSY_FLOAT_LITERAL]);
 impl<'tcx> LateLintPass<'tcx> for FloatLiteral {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
         let ty = cx.typeck_results().expr_ty(expr);
-        if_chain! {
-            if let ty::Float(fty) = *ty.kind();
-            if let hir::ExprKind::Lit(lit) = expr.kind;
-            if let LitKind::Float(sym, lit_float_ty) = lit.node;
-            then {
-                let sym_str = sym.as_str();
-                let formatter = FloatFormat::new(sym_str);
-                // Try to bail out if the float is for sure fine.
-                // If its within the 2 decimal digits of being out of precision we
-                // check if the parsed representation is the same as the string
-                // since we'll need the truncated string anyway.
-                let digits = count_digits(sym_str);
-                let max = max_digits(fty);
-                let type_suffix = match lit_float_ty {
-                    LitFloatType::Suffixed(ast::FloatTy::F32) => Some("f32"),
-                    LitFloatType::Suffixed(ast::FloatTy::F64) => Some("f64"),
-                    LitFloatType::Unsuffixed => None
-                };
-                let (is_whole, is_inf, mut float_str) = match fty {
-                    FloatTy::F32 => {
-                        let value = sym_str.parse::<f32>().unwrap();
+        if let ty::Float(fty) = *ty.kind()
+            && let hir::ExprKind::Lit(lit) = expr.kind
+            && let LitKind::Float(sym, lit_float_ty) = lit.node
+        {
+            let sym_str = sym.as_str();
+            let formatter = FloatFormat::new(sym_str);
+            // Try to bail out if the float is for sure fine.
+            // If its within the 2 decimal digits of being out of precision we
+            // check if the parsed representation is the same as the string
+            // since we'll need the truncated string anyway.
+            let digits = count_digits(sym_str);
+            let max = max_digits(fty);
+            let type_suffix = match lit_float_ty {
+                LitFloatType::Suffixed(ast::FloatTy::F32) => Some("f32"),
+                LitFloatType::Suffixed(ast::FloatTy::F64) => Some("f64"),
+                LitFloatType::Unsuffixed => None
+            };
+            let (is_whole, is_inf, mut float_str) = match fty {
+                FloatTy::F32 => {
+                    let value = sym_str.parse::<f32>().unwrap();
 
-                        (value.fract() == 0.0, value.is_infinite(), formatter.format(value))
-                    },
-                    FloatTy::F64 => {
-                        let value = sym_str.parse::<f64>().unwrap();
+                    (value.fract() == 0.0, value.is_infinite(), formatter.format(value))
+                },
+                FloatTy::F64 => {
+                    let value = sym_str.parse::<f64>().unwrap();
 
 
-                        (value.fract() == 0.0, value.is_infinite(), formatter.format(value))
-                    },
-                };
+                    (value.fract() == 0.0, value.is_infinite(), formatter.format(value))
+                },
+            };
 
-                if is_inf {
-                    return;
-                }
-
-                if is_whole && !sym_str.contains(|c| c == 'e' || c == 'E') {
-                    // Normalize the literal by stripping the fractional portion
-                    if sym_str.split('.').next().unwrap() != float_str {
-                        // If the type suffix is missing the suggestion would be
-                        // incorrectly interpreted as an integer so adding a `.0`
-                        // suffix to prevent that.
-                        if type_suffix.is_none() {
-                            float_str.push_str(".0");
-                        }
+            if is_inf {
+                return;
+            }
 
-                        span_lint_and_sugg(
-                            cx,
-                            LOSSY_FLOAT_LITERAL,
-                            expr.span,
-                            "literal cannot be represented as the underlying type without loss of precision",
-                            "consider changing the type or replacing it with",
-                            numeric_literal::format(&float_str, type_suffix, true),
-                            Applicability::MachineApplicable,
-                        );
+            if is_whole && !sym_str.contains(|c| c == 'e' || c == 'E') {
+                // Normalize the literal by stripping the fractional portion
+                if sym_str.split('.').next().unwrap() != float_str {
+                    // If the type suffix is missing the suggestion would be
+                    // incorrectly interpreted as an integer so adding a `.0`
+                    // suffix to prevent that.
+                    if type_suffix.is_none() {
+                        float_str.push_str(".0");
                     }
-                } else if digits > max as usize && float_str.len() < sym_str.len() {
+
                     span_lint_and_sugg(
                         cx,
-                        EXCESSIVE_PRECISION,
+                        LOSSY_FLOAT_LITERAL,
                         expr.span,
-                        "float has excessive precision",
-                        "consider changing the type or truncating it to",
+                        "literal cannot be represented as the underlying type without loss of precision",
+                        "consider changing the type or replacing it with",
                         numeric_literal::format(&float_str, type_suffix, true),
                         Applicability::MachineApplicable,
                     );
                 }
+            } else if digits > max as usize && float_str.len() < sym_str.len() {
+                span_lint_and_sugg(
+                    cx,
+                    EXCESSIVE_PRECISION,
+                    expr.span,
+                    "float has excessive precision",
+                    "consider changing the type or truncating it to",
+                    numeric_literal::format(&float_str, type_suffix, true),
+                    Applicability::MachineApplicable,
+                );
             }
         }
     }
diff --git a/clippy_lints/src/floating_point_arithmetic.rs b/clippy_lints/src/floating_point_arithmetic.rs
index 09a9d9924de..21cedf17385 100644
--- a/clippy_lints/src/floating_point_arithmetic.rs
+++ b/clippy_lints/src/floating_point_arithmetic.rs
@@ -133,30 +133,28 @@ fn prepare_receiver_sugg<'a>(cx: &LateContext<'_>, mut expr: &'a Expr<'a>) -> Su
         expr = inner_expr;
     }
 
-    if_chain! {
+    if let ty::Float(float_ty) = cx.typeck_results().expr_ty(expr).kind()
         // if the expression is a float literal and it is unsuffixed then
         // add a suffix so the suggestion is valid and unambiguous
-        if let ty::Float(float_ty) = cx.typeck_results().expr_ty(expr).kind();
-        if let ExprKind::Lit(lit) = &expr.kind;
-        if let ast::LitKind::Float(sym, ast::LitFloatType::Unsuffixed) = lit.node;
-        then {
-            let op = format!(
-                "{suggestion}{}{}",
-                // Check for float literals without numbers following the decimal
-                // separator such as `2.` and adds a trailing zero
-                if sym.as_str().ends_with('.') {
-                    "0"
-                } else {
-                    ""
-                },
-                float_ty.name_str()
-            ).into();
-
-            suggestion = match suggestion {
-                Sugg::MaybeParen(_) => Sugg::MaybeParen(op),
-                _ => Sugg::NonParen(op)
-            };
-        }
+        && let ExprKind::Lit(lit) = &expr.kind
+        && let ast::LitKind::Float(sym, ast::LitFloatType::Unsuffixed) = lit.node
+    {
+        let op = format!(
+            "{suggestion}{}{}",
+            // Check for float literals without numbers following the decimal
+            // separator such as `2.` and adds a trailing zero
+            if sym.as_str().ends_with('.') {
+                "0"
+            } else {
+                ""
+            },
+            float_ty.name_str()
+        ).into();
+
+        suggestion = match suggestion {
+            Sugg::MaybeParen(_) => Sugg::MaybeParen(op),
+            _ => Sugg::NonParen(op)
+        };
     }
 
     suggestion.maybe_par()
@@ -359,35 +357,31 @@ fn detect_hypot(cx: &LateContext<'_>, receiver: &Expr<'_>) -> Option<String> {
     ) = receiver.kind
     {
         // check if expression of the form x * x + y * y
-        if_chain! {
-            if let ExprKind::Binary(Spanned { node: BinOpKind::Mul, .. }, lmul_lhs, lmul_rhs) = add_lhs.kind;
-            if let ExprKind::Binary(Spanned { node: BinOpKind::Mul, .. }, rmul_lhs, rmul_rhs) = add_rhs.kind;
-            if eq_expr_value(cx, lmul_lhs, lmul_rhs);
-            if eq_expr_value(cx, rmul_lhs, rmul_rhs);
-            then {
-                return Some(format!("{}.hypot({})", Sugg::hir(cx, lmul_lhs, "..").maybe_par(), Sugg::hir(cx, rmul_lhs, "..")));
-            }
+        if let ExprKind::Binary(Spanned { node: BinOpKind::Mul, .. }, lmul_lhs, lmul_rhs) = add_lhs.kind
+            && let ExprKind::Binary(Spanned { node: BinOpKind::Mul, .. }, rmul_lhs, rmul_rhs) = add_rhs.kind
+            && eq_expr_value(cx, lmul_lhs, lmul_rhs)
+            && eq_expr_value(cx, rmul_lhs, rmul_rhs)
+        {
+            return Some(format!("{}.hypot({})", Sugg::hir(cx, lmul_lhs, "..").maybe_par(), Sugg::hir(cx, rmul_lhs, "..")));
         }
 
         // check if expression of the form x.powi(2) + y.powi(2)
-        if_chain! {
-            if let ExprKind::MethodCall(
+        if let ExprKind::MethodCall(
                 PathSegment { ident: lmethod_name, .. },
                 largs_0, [largs_1, ..],
                 _
-            ) = &add_lhs.kind;
-            if let ExprKind::MethodCall(
+            ) = &add_lhs.kind
+            && let ExprKind::MethodCall(
                 PathSegment { ident: rmethod_name, .. },
                 rargs_0, [rargs_1, ..],
                 _
-            ) = &add_rhs.kind;
-            if lmethod_name.as_str() == "powi" && rmethod_name.as_str() == "powi";
-            if let Some(lvalue) = constant(cx, cx.typeck_results(), largs_1);
-            if let Some(rvalue) = constant(cx, cx.typeck_results(), rargs_1);
-            if Int(2) == lvalue && Int(2) == rvalue;
-            then {
-                return Some(format!("{}.hypot({})", Sugg::hir(cx, largs_0, "..").maybe_par(), Sugg::hir(cx, rargs_0, "..")));
-            }
+            ) = &add_rhs.kind
+            && lmethod_name.as_str() == "powi" && rmethod_name.as_str() == "powi"
+            && let Some(lvalue) = constant(cx, cx.typeck_results(), largs_1)
+            && let Some(rvalue) = constant(cx, cx.typeck_results(), rargs_1)
+            && Int(2) == lvalue && Int(2) == rvalue
+        {
+            return Some(format!("{}.hypot({})", Sugg::hir(cx, largs_0, "..").maybe_par(), Sugg::hir(cx, rargs_0, "..")));
         }
     }
 
@@ -411,39 +405,35 @@ fn check_hypot(cx: &LateContext<'_>, expr: &Expr<'_>, receiver: &Expr<'_>) {
 // TODO: Lint expressions of the form `x.exp() - y` where y > 1
 // and suggest usage of `x.exp_m1() - (y - 1)` instead
 fn check_expm1(cx: &LateContext<'_>, expr: &Expr<'_>) {
-    if_chain! {
-        if let ExprKind::Binary(Spanned { node: BinOpKind::Sub, .. }, lhs, rhs) = expr.kind;
-        if cx.typeck_results().expr_ty(lhs).is_floating_point();
-        if let Some(value) = constant(cx, cx.typeck_results(), rhs);
-        if F32(1.0) == value || F64(1.0) == value;
-        if let ExprKind::MethodCall(path, self_arg, ..) = &lhs.kind;
-        if cx.typeck_results().expr_ty(self_arg).is_floating_point();
-        if path.ident.name.as_str() == "exp";
-        then {
-            span_lint_and_sugg(
-                cx,
-                IMPRECISE_FLOPS,
-                expr.span,
-                "(e.pow(x) - 1) can be computed more accurately",
-                "consider using",
-                format!(
-                    "{}.exp_m1()",
-                    Sugg::hir(cx, self_arg, "..").maybe_par()
-                ),
-                Applicability::MachineApplicable,
-            );
-        }
+    if let ExprKind::Binary(Spanned { node: BinOpKind::Sub, .. }, lhs, rhs) = expr.kind
+        && cx.typeck_results().expr_ty(lhs).is_floating_point()
+        && let Some(value) = constant(cx, cx.typeck_results(), rhs)
+        && (F32(1.0) == value || F64(1.0) == value)
+        && let ExprKind::MethodCall(path, self_arg, ..) = &lhs.kind
+        && cx.typeck_results().expr_ty(self_arg).is_floating_point()
+        && path.ident.name.as_str() == "exp"
+    {
+        span_lint_and_sugg(
+            cx,
+            IMPRECISE_FLOPS,
+            expr.span,
+            "(e.pow(x) - 1) can be computed more accurately",
+            "consider using",
+            format!(
+                "{}.exp_m1()",
+                Sugg::hir(cx, self_arg, "..").maybe_par()
+            ),
+            Applicability::MachineApplicable,
+        );
     }
 }
 
 fn is_float_mul_expr<'a>(cx: &LateContext<'_>, expr: &'a Expr<'a>) -> Option<(&'a Expr<'a>, &'a Expr<'a>)> {
-    if_chain! {
-        if let ExprKind::Binary(Spanned { node: BinOpKind::Mul, .. }, lhs, rhs) = &expr.kind;
-        if cx.typeck_results().expr_ty(lhs).is_floating_point();
-        if cx.typeck_results().expr_ty(rhs).is_floating_point();
-        then {
-            return Some((lhs, rhs));
-        }
+    if let ExprKind::Binary(Spanned { node: BinOpKind::Mul, .. }, lhs, rhs) = &expr.kind
+        && cx.typeck_results().expr_ty(lhs).is_floating_point()
+        && cx.typeck_results().expr_ty(rhs).is_floating_point()
+    {
+        return Some((lhs, rhs));
     }
 
     None
@@ -553,60 +543,56 @@ fn are_negated<'a>(cx: &LateContext<'_>, expr1: &'a Expr<'a>, expr2: &'a Expr<'a
 }
 
 fn check_custom_abs(cx: &LateContext<'_>, expr: &Expr<'_>) {
-    if_chain! {
-        if let Some(higher::If { cond, then, r#else: Some(r#else) }) = higher::If::hir(expr);
-        let if_body_expr = peel_blocks(then);
-        let else_body_expr = peel_blocks(r#else);
-        if let Some((if_expr_positive, body)) = are_negated(cx, if_body_expr, else_body_expr);
-        then {
-            let positive_abs_sugg = (
-                "manual implementation of `abs` method",
-                format!("{}.abs()", Sugg::hir(cx, body, "..").maybe_par()),
-            );
-            let negative_abs_sugg = (
-                "manual implementation of negation of `abs` method",
-                format!("-{}.abs()", Sugg::hir(cx, body, "..").maybe_par()),
-            );
-            let sugg = if is_testing_positive(cx, cond, body) {
-                if if_expr_positive {
-                    positive_abs_sugg
-                } else {
-                    negative_abs_sugg
-                }
-            } else if is_testing_negative(cx, cond, body) {
-                if if_expr_positive {
-                    negative_abs_sugg
-                } else {
-                    positive_abs_sugg
-                }
+    if let Some(higher::If { cond, then, r#else: Some(r#else) }) = higher::If::hir(expr)
+        && let if_body_expr = peel_blocks(then)
+        && let else_body_expr = peel_blocks(r#else)
+        && let Some((if_expr_positive, body)) = are_negated(cx, if_body_expr, else_body_expr)
+    {
+        let positive_abs_sugg = (
+            "manual implementation of `abs` method",
+            format!("{}.abs()", Sugg::hir(cx, body, "..").maybe_par()),
+        );
+        let negative_abs_sugg = (
+            "manual implementation of negation of `abs` method",
+            format!("-{}.abs()", Sugg::hir(cx, body, "..").maybe_par()),
+        );
+        let sugg = if is_testing_positive(cx, cond, body) {
+            if if_expr_positive {
+                positive_abs_sugg
             } else {
-                return;
-            };
-            span_lint_and_sugg(
-                cx,
-                SUBOPTIMAL_FLOPS,
-                expr.span,
-                sugg.0,
-                "try",
-                sugg.1,
-                Applicability::MachineApplicable,
-            );
-        }
+                negative_abs_sugg
+            }
+        } else if is_testing_negative(cx, cond, body) {
+            if if_expr_positive {
+                negative_abs_sugg
+            } else {
+                positive_abs_sugg
+            }
+        } else {
+            return;
+        };
+        span_lint_and_sugg(
+            cx,
+            SUBOPTIMAL_FLOPS,
+            expr.span,
+            sugg.0,
+            "try",
+            sugg.1,
+            Applicability::MachineApplicable,
+        );
     }
 }
 
 fn are_same_base_logs(cx: &LateContext<'_>, expr_a: &Expr<'_>, expr_b: &Expr<'_>) -> bool {
-    if_chain! {
-        if let ExprKind::MethodCall(PathSegment { ident: method_name_a, .. }, _, args_a, _) = expr_a.kind;
-        if let ExprKind::MethodCall(PathSegment { ident: method_name_b, .. }, _, args_b, _) = expr_b.kind;
-        then {
-            return method_name_a.as_str() == method_name_b.as_str() &&
-                args_a.len() == args_b.len() &&
-                (
-                    ["ln", "log2", "log10"].contains(&method_name_a.as_str()) ||
-                    method_name_a.as_str() == "log" && args_a.len() == 1 && eq_expr_value(cx, &args_a[0], &args_b[0])
-                );
-        }
+    if let ExprKind::MethodCall(PathSegment { ident: method_name_a, .. }, _, args_a, _) = expr_a.kind
+        && let ExprKind::MethodCall(PathSegment { ident: method_name_b, .. }, _, args_b, _) = expr_b.kind
+    {
+        return method_name_a.as_str() == method_name_b.as_str() &&
+            args_a.len() == args_b.len() &&
+            (
+                ["ln", "log2", "log10"].contains(&method_name_a.as_str()) ||
+                method_name_a.as_str() == "log" && args_a.len() == 1 && eq_expr_value(cx, &args_a[0], &args_b[0])
+            );
     }
 
     false
@@ -614,103 +600,95 @@ fn are_same_base_logs(cx: &LateContext<'_>, expr_a: &Expr<'_>, expr_b: &Expr<'_>
 
 fn check_log_division(cx: &LateContext<'_>, expr: &Expr<'_>) {
     // check if expression of the form x.logN() / y.logN()
-    if_chain! {
-        if let ExprKind::Binary(
+    if let ExprKind::Binary(
             Spanned {
                 node: BinOpKind::Div, ..
             },
             lhs,
             rhs,
-        ) = &expr.kind;
-        if are_same_base_logs(cx, lhs, rhs);
-        if let ExprKind::MethodCall(_, largs_self, ..) = &lhs.kind;
-        if let ExprKind::MethodCall(_, rargs_self, ..) = &rhs.kind;
-        then {
-            span_lint_and_sugg(
-                cx,
-                SUBOPTIMAL_FLOPS,
-                expr.span,
-                "log base can be expressed more clearly",
-                "consider using",
-                format!("{}.log({})", Sugg::hir(cx, largs_self, "..").maybe_par(), Sugg::hir(cx, rargs_self, ".."),),
-                Applicability::MachineApplicable,
-            );
-        }
+        ) = &expr.kind
+        && are_same_base_logs(cx, lhs, rhs)
+        && let ExprKind::MethodCall(_, largs_self, ..) = &lhs.kind
+        && let ExprKind::MethodCall(_, rargs_self, ..) = &rhs.kind
+    {
+        span_lint_and_sugg(
+            cx,
+            SUBOPTIMAL_FLOPS,
+            expr.span,
+            "log base can be expressed more clearly",
+            "consider using",
+            format!("{}.log({})", Sugg::hir(cx, largs_self, "..").maybe_par(), Sugg::hir(cx, rargs_self, ".."),),
+            Applicability::MachineApplicable,
+        );
     }
 }
 
 fn check_radians(cx: &LateContext<'_>, expr: &Expr<'_>) {
-    if_chain! {
-        if let ExprKind::Binary(
+    if let ExprKind::Binary(
             Spanned {
                 node: BinOpKind::Div, ..
             },
             div_lhs,
             div_rhs,
-        ) = &expr.kind;
-        if let ExprKind::Binary(
+        ) = &expr.kind
+        && let ExprKind::Binary(
             Spanned {
                 node: BinOpKind::Mul, ..
             },
             mul_lhs,
             mul_rhs,
-        ) = &div_lhs.kind;
-        if let Some(rvalue) = constant(cx, cx.typeck_results(), div_rhs);
-        if let Some(lvalue) = constant(cx, cx.typeck_results(), mul_rhs);
-        then {
-            // TODO: also check for constant values near PI/180 or 180/PI
-            if (F32(f32_consts::PI) == rvalue || F64(f64_consts::PI) == rvalue) &&
-               (F32(180_f32) == lvalue || F64(180_f64) == lvalue)
+        ) = &div_lhs.kind
+        && let Some(rvalue) = constant(cx, cx.typeck_results(), div_rhs)
+        && let Some(lvalue) = constant(cx, cx.typeck_results(), mul_rhs)
+    {
+        // TODO: also check for constant values near PI/180 or 180/PI
+        if (F32(f32_consts::PI) == rvalue || F64(f64_consts::PI) == rvalue) &&
+           (F32(180_f32) == lvalue || F64(180_f64) == lvalue)
+        {
+            let mut proposal = format!("{}.to_degrees()", Sugg::hir(cx, mul_lhs, "..").maybe_par());
+            if let ExprKind::Lit(literal) = mul_lhs.kind
+                && let ast::LitKind::Float(ref value, float_type) = literal.node
+                && float_type == ast::LitFloatType::Unsuffixed
             {
-                let mut proposal = format!("{}.to_degrees()", Sugg::hir(cx, mul_lhs, "..").maybe_par());
-                if_chain! {
-                    if let ExprKind::Lit(literal) = mul_lhs.kind;
-                    if let ast::LitKind::Float(ref value, float_type) = literal.node;
-                    if float_type == ast::LitFloatType::Unsuffixed;
-                    then {
-                        if value.as_str().ends_with('.') {
-                            proposal = format!("{}0_f64.to_degrees()", Sugg::hir(cx, mul_lhs, ".."));
-                        } else {
-                            proposal = format!("{}_f64.to_degrees()", Sugg::hir(cx, mul_lhs, ".."));
-                        }
-                    }
+                if value.as_str().ends_with('.') {
+                    proposal = format!("{}0_f64.to_degrees()", Sugg::hir(cx, mul_lhs, ".."));
+                } else {
+                    proposal = format!("{}_f64.to_degrees()", Sugg::hir(cx, mul_lhs, ".."));
                 }
-                span_lint_and_sugg(
-                    cx,
-                    SUBOPTIMAL_FLOPS,
-                    expr.span,
-                    "conversion to degrees can be done more accurately",
-                    "consider using",
-                    proposal,
-                    Applicability::MachineApplicable,
-                );
-            } else if
-                (F32(180_f32) == rvalue || F64(180_f64) == rvalue) &&
-                (F32(f32_consts::PI) == lvalue || F64(f64_consts::PI) == lvalue)
+            }
+            span_lint_and_sugg(
+                cx,
+                SUBOPTIMAL_FLOPS,
+                expr.span,
+                "conversion to degrees can be done more accurately",
+                "consider using",
+                proposal,
+                Applicability::MachineApplicable,
+            );
+        } else if
+            (F32(180_f32) == rvalue || F64(180_f64) == rvalue) &&
+            (F32(f32_consts::PI) == lvalue || F64(f64_consts::PI) == lvalue)
+        {
+            let mut proposal = format!("{}.to_radians()", Sugg::hir(cx, mul_lhs, "..").maybe_par());
+            if let ExprKind::Lit(literal) = mul_lhs.kind
+                && let ast::LitKind::Float(ref value, float_type) = literal.node
+                && float_type == ast::LitFloatType::Unsuffixed
             {
-                let mut proposal = format!("{}.to_radians()", Sugg::hir(cx, mul_lhs, "..").maybe_par());
-                if_chain! {
-                    if let ExprKind::Lit(literal) = mul_lhs.kind;
-                    if let ast::LitKind::Float(ref value, float_type) = literal.node;
-                    if float_type == ast::LitFloatType::Unsuffixed;
-                    then {
-                        if value.as_str().ends_with('.') {
-                            proposal = format!("{}0_f64.to_radians()", Sugg::hir(cx, mul_lhs, ".."));
-                        } else {
-                            proposal = format!("{}_f64.to_radians()", Sugg::hir(cx, mul_lhs, ".."));
-                        }
-                    }
+                if value.as_str().ends_with('.') {
+                    proposal = format!("{}0_f64.to_radians()", Sugg::hir(cx, mul_lhs, ".."));
+                } else {
+                    proposal = format!("{}_f64.to_radians()", Sugg::hir(cx, mul_lhs, ".."));
                 }
-                span_lint_and_sugg(
-                    cx,
-                    SUBOPTIMAL_FLOPS,
-                    expr.span,
-                    "conversion to radians can be done more accurately",
-                    "consider using",
-                    proposal,
-                    Applicability::MachineApplicable,
-                );
             }
+            span_lint_and_sugg(
+                cx,
+                SUBOPTIMAL_FLOPS,
+                expr.span,
+                "conversion to radians can be done more accurately",
+                "consider using",
+                proposal,
+                Applicability::MachineApplicable,
+            );
         }
     }
 }
diff --git a/clippy_lints/src/format_args.rs b/clippy_lints/src/format_args.rs
index 3c1f2d9d5dc..737ea05d92d 100644
--- a/clippy_lints/src/format_args.rs
+++ b/clippy_lints/src/format_args.rs
@@ -404,49 +404,47 @@ fn check_format_in_format_args(cx: &LateContext<'_>, call_site: Span, name: Symb
 }
 
 fn check_to_string_in_format_args(cx: &LateContext<'_>, name: Symbol, value: &Expr<'_>) {
-    if_chain! {
-        if !value.span.from_expansion();
-        if let ExprKind::MethodCall(_, receiver, [], to_string_span) = value.kind;
-        if let Some(method_def_id) = cx.typeck_results().type_dependent_def_id(value.hir_id);
-        if is_diag_trait_item(cx, method_def_id, sym::ToString);
-        let receiver_ty = cx.typeck_results().expr_ty(receiver);
-        if let Some(display_trait_id) = cx.tcx.get_diagnostic_item(sym::Display);
-        let (n_needed_derefs, target) =
-            count_needed_derefs(receiver_ty, cx.typeck_results().expr_adjustments(receiver).iter());
-        if implements_trait(cx, target, display_trait_id, &[]);
-        if let Some(sized_trait_id) = cx.tcx.lang_items().sized_trait();
-        if let Some(receiver_snippet) = snippet_opt(cx, receiver.span);
-        then {
-            let needs_ref = !implements_trait(cx, receiver_ty, sized_trait_id, &[]);
-            if n_needed_derefs == 0 && !needs_ref {
-                span_lint_and_sugg(
-                    cx,
-                    TO_STRING_IN_FORMAT_ARGS,
-                    to_string_span.with_lo(receiver.span.hi()),
-                    &format!(
-                        "`to_string` applied to a type that implements `Display` in `{name}!` args"
-                    ),
-                    "remove this",
-                    String::new(),
-                    Applicability::MachineApplicable,
-                );
-            } else {
-                span_lint_and_sugg(
-                    cx,
-                    TO_STRING_IN_FORMAT_ARGS,
-                    value.span,
-                    &format!(
-                        "`to_string` applied to a type that implements `Display` in `{name}!` args"
-                    ),
-                    "use this",
-                    format!(
-                        "{}{:*>n_needed_derefs$}{receiver_snippet}",
-                        if needs_ref { "&" } else { "" },
-                        ""
-                    ),
-                    Applicability::MachineApplicable,
-                );
-            }
+    if !value.span.from_expansion()
+        && let ExprKind::MethodCall(_, receiver, [], to_string_span) = value.kind
+        && let Some(method_def_id) = cx.typeck_results().type_dependent_def_id(value.hir_id)
+        && is_diag_trait_item(cx, method_def_id, sym::ToString)
+        && let receiver_ty = cx.typeck_results().expr_ty(receiver)
+        && let Some(display_trait_id) = cx.tcx.get_diagnostic_item(sym::Display)
+        && let (n_needed_derefs, target) =
+            count_needed_derefs(receiver_ty, cx.typeck_results().expr_adjustments(receiver).iter())
+        && implements_trait(cx, target, display_trait_id, &[])
+        && let Some(sized_trait_id) = cx.tcx.lang_items().sized_trait()
+        && let Some(receiver_snippet) = snippet_opt(cx, receiver.span)
+    {
+        let needs_ref = !implements_trait(cx, receiver_ty, sized_trait_id, &[]);
+        if n_needed_derefs == 0 && !needs_ref {
+            span_lint_and_sugg(
+                cx,
+                TO_STRING_IN_FORMAT_ARGS,
+                to_string_span.with_lo(receiver.span.hi()),
+                &format!(
+                    "`to_string` applied to a type that implements `Display` in `{name}!` args"
+                ),
+                "remove this",
+                String::new(),
+                Applicability::MachineApplicable,
+            );
+        } else {
+            span_lint_and_sugg(
+                cx,
+                TO_STRING_IN_FORMAT_ARGS,
+                value.span,
+                &format!(
+                    "`to_string` applied to a type that implements `Display` in `{name}!` args"
+                ),
+                "use this",
+                format!(
+                    "{}{:*>n_needed_derefs$}{receiver_snippet}",
+                    if needs_ref { "&" } else { "" },
+                    ""
+                ),
+                Applicability::MachineApplicable,
+            );
         }
     }
 }
diff --git a/clippy_lints/src/format_impl.rs b/clippy_lints/src/format_impl.rs
index 08ee7032c09..7eee3a97669 100644
--- a/clippy_lints/src/format_impl.rs
+++ b/clippy_lints/src/format_impl.rs
@@ -141,27 +141,25 @@ impl<'tcx> LateLintPass<'tcx> for FormatImpl {
 }
 
 fn check_to_string_in_display(cx: &LateContext<'_>, expr: &Expr<'_>) {
-    if_chain! {
+    if let ExprKind::MethodCall(path, self_arg, ..) = expr.kind
         // Get the hir_id of the object we are calling the method on
-        if let ExprKind::MethodCall(path, self_arg, ..) = expr.kind;
         // Is the method to_string() ?
-        if path.ident.name == sym::to_string;
+        && path.ident.name == sym::to_string
         // Is the method a part of the ToString trait? (i.e. not to_string() implemented
         // separately)
-        if let Some(expr_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
-        if is_diag_trait_item(cx, expr_def_id, sym::ToString);
+        && let Some(expr_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id)
+        && is_diag_trait_item(cx, expr_def_id, sym::ToString)
         // Is the method is called on self
-        if let ExprKind::Path(QPath::Resolved(_, path)) = self_arg.kind;
-        if let [segment] = path.segments;
-        if segment.ident.name == kw::SelfLower;
-        then {
-            span_lint(
-                cx,
-                RECURSIVE_FORMAT_IMPL,
-                expr.span,
-                "using `self.to_string` in `fmt::Display` implementation will cause infinite recursion",
-            );
-        }
+        && let ExprKind::Path(QPath::Resolved(_, path)) = self_arg.kind
+        && let [segment] = path.segments
+        && segment.ident.name == kw::SelfLower
+    {
+        span_lint(
+            cx,
+            RECURSIVE_FORMAT_IMPL,
+            expr.span,
+            "using `self.to_string` in `fmt::Display` implementation will cause infinite recursion",
+        );
     }
 }
 
@@ -215,55 +213,51 @@ fn check_format_arg_self(cx: &LateContext<'_>, span: Span, arg: &Expr<'_>, impl_
 }
 
 fn check_print_in_format_impl(cx: &LateContext<'_>, expr: &Expr<'_>, impl_trait: FormatTraitNames) {
-    if_chain! {
-        if let Some(macro_call) = root_macro_call_first_node(cx, expr);
-        if let Some(name) = cx.tcx.get_diagnostic_name(macro_call.def_id);
-        then {
-            let replacement = match name {
-                sym::print_macro | sym::eprint_macro => "write",
-                sym::println_macro | sym::eprintln_macro => "writeln",
-                _ => return,
-            };
+    if let Some(macro_call) = root_macro_call_first_node(cx, expr)
+        && let Some(name) = cx.tcx.get_diagnostic_name(macro_call.def_id)
+    {
+        let replacement = match name {
+            sym::print_macro | sym::eprint_macro => "write",
+            sym::println_macro | sym::eprintln_macro => "writeln",
+            _ => return,
+        };
 
-            let name = name.as_str().strip_suffix("_macro").unwrap();
+        let name = name.as_str().strip_suffix("_macro").unwrap();
 
-            span_lint_and_sugg(
-                cx,
-                PRINT_IN_FORMAT_IMPL,
-                macro_call.span,
-                &format!("use of `{name}!` in `{}` impl", impl_trait.name),
-                "replace with",
-                if let Some(formatter_name) = impl_trait.formatter_name {
-                    format!("{replacement}!({formatter_name}, ..)")
-                } else {
-                    format!("{replacement}!(..)")
-                },
-                Applicability::HasPlaceholders,
-            );
-        }
+        span_lint_and_sugg(
+            cx,
+            PRINT_IN_FORMAT_IMPL,
+            macro_call.span,
+            &format!("use of `{name}!` in `{}` impl", impl_trait.name),
+            "replace with",
+            if let Some(formatter_name) = impl_trait.formatter_name {
+                format!("{replacement}!({formatter_name}, ..)")
+            } else {
+                format!("{replacement}!(..)")
+            },
+            Applicability::HasPlaceholders,
+        );
     }
 }
 
 fn is_format_trait_impl(cx: &LateContext<'_>, impl_item: &ImplItem<'_>) -> Option<FormatTraitNames> {
-    if_chain! {
-        if impl_item.ident.name == sym::fmt;
-        if let ImplItemKind::Fn(_, body_id) = impl_item.kind;
-        if let Some(Impl { of_trait: Some(trait_ref),..}) = get_parent_as_impl(cx.tcx, impl_item.hir_id());
-        if let Some(did) = trait_ref.trait_def_id();
-        if let Some(name) = cx.tcx.get_diagnostic_name(did);
-        if matches!(name, sym::Debug | sym::Display);
-        then {
-            let body = cx.tcx.hir().body(body_id);
-            let formatter_name = body.params.get(1)
-                .and_then(|param| param.pat.simple_ident())
-                .map(|ident| ident.name);
+    if impl_item.ident.name == sym::fmt
+        && let ImplItemKind::Fn(_, body_id) = impl_item.kind
+        && let Some(Impl { of_trait: Some(trait_ref),..}) = get_parent_as_impl(cx.tcx, impl_item.hir_id())
+        && let Some(did) = trait_ref.trait_def_id()
+        && let Some(name) = cx.tcx.get_diagnostic_name(did)
+        && matches!(name, sym::Debug | sym::Display)
+    {
+        let body = cx.tcx.hir().body(body_id);
+        let formatter_name = body.params.get(1)
+            .and_then(|param| param.pat.simple_ident())
+            .map(|ident| ident.name);
 
-            Some(FormatTraitNames {
-                name,
-                formatter_name,
-            })
-        } else {
-            None
-        }
+        Some(FormatTraitNames {
+            name,
+            formatter_name,
+        })
+    } else {
+        None
     }
 }
diff --git a/clippy_lints/src/formatting.rs b/clippy_lints/src/formatting.rs
index 10ddc3bda34..be35b850c0a 100644
--- a/clippy_lints/src/formatting.rs
+++ b/clippy_lints/src/formatting.rs
@@ -168,93 +168,87 @@ fn check_assign(cx: &EarlyContext<'_>, expr: &Expr) {
 
 /// Implementation of the `SUSPICIOUS_UNARY_OP_FORMATTING` lint.
 fn check_unop(cx: &EarlyContext<'_>, expr: &Expr) {
-    if_chain! {
-        if let ExprKind::Binary(ref binop, ref lhs, ref rhs) = expr.kind;
-        if !lhs.span.from_expansion() && !rhs.span.from_expansion();
+    if let ExprKind::Binary(ref binop, ref lhs, ref rhs) = expr.kind
+        && !lhs.span.from_expansion() && !rhs.span.from_expansion()
         // span between BinOp LHS and RHS
-        let binop_span = lhs.span.between(rhs.span);
+        && let binop_span = lhs.span.between(rhs.span)
         // if RHS is an UnOp
-        if let ExprKind::Unary(op, ref un_rhs) = rhs.kind;
+        && let ExprKind::Unary(op, ref un_rhs) = rhs.kind
         // from UnOp operator to UnOp operand
-        let unop_operand_span = rhs.span.until(un_rhs.span);
-        if let Some(binop_snippet) = snippet_opt(cx, binop_span);
-        if let Some(unop_operand_snippet) = snippet_opt(cx, unop_operand_span);
-        let binop_str = BinOpKind::to_string(&binop.node);
+        && let unop_operand_span = rhs.span.until(un_rhs.span)
+        && let Some(binop_snippet) = snippet_opt(cx, binop_span)
+        && let Some(unop_operand_snippet) = snippet_opt(cx, unop_operand_span)
+        && let binop_str = BinOpKind::to_string(&binop.node)
         // no space after BinOp operator and space after UnOp operator
-        if binop_snippet.ends_with(binop_str) && unop_operand_snippet.ends_with(' ');
-        then {
-            let unop_str = UnOp::to_string(op);
-            let eqop_span = lhs.span.between(un_rhs.span);
-            span_lint_and_help(
-                cx,
-                SUSPICIOUS_UNARY_OP_FORMATTING,
-                eqop_span,
-                &format!(
-                    "by not having a space between `{binop_str}` and `{unop_str}` it looks like \
-                     `{binop_str}{unop_str}` is a single operator"
-                ),
-                None,
-                &format!(
-                    "put a space between `{binop_str}` and `{unop_str}` and remove the space after `{unop_str}`"
-                ),
-            );
-        }
+        && binop_snippet.ends_with(binop_str) && unop_operand_snippet.ends_with(' ')
+    {
+        let unop_str = UnOp::to_string(op);
+        let eqop_span = lhs.span.between(un_rhs.span);
+        span_lint_and_help(
+            cx,
+            SUSPICIOUS_UNARY_OP_FORMATTING,
+            eqop_span,
+            &format!(
+                "by not having a space between `{binop_str}` and `{unop_str}` it looks like \
+                 `{binop_str}{unop_str}` is a single operator"
+            ),
+            None,
+            &format!(
+                "put a space between `{binop_str}` and `{unop_str}` and remove the space after `{unop_str}`"
+            ),
+        );
     }
 }
 
 /// Implementation of the `SUSPICIOUS_ELSE_FORMATTING` lint for weird `else`.
 fn check_else(cx: &EarlyContext<'_>, expr: &Expr) {
-    if_chain! {
-        if let ExprKind::If(_, then, Some(else_)) = &expr.kind;
-        if is_block(else_) || is_if(else_);
-        if !then.span.from_expansion() && !else_.span.from_expansion();
-        if !in_external_macro(cx.sess(), expr.span);
+    if let ExprKind::If(_, then, Some(else_)) = &expr.kind
+        && (is_block(else_) || is_if(else_))
+        && !then.span.from_expansion() && !else_.span.from_expansion()
+        && !in_external_macro(cx.sess(), expr.span)
 
         // workaround for rust-lang/rust#43081
-        if expr.span.lo().0 != 0 && expr.span.hi().0 != 0;
+        && expr.span.lo().0 != 0 && expr.span.hi().0 != 0
 
         // this will be a span from the closing ‘}’ of the “then” block (excluding) to
         // the “if” of the “else if” block (excluding)
-        let else_span = then.span.between(else_.span);
+        && let else_span = then.span.between(else_.span)
 
         // the snippet should look like " else \n    " with maybe comments anywhere
         // it’s bad when there is a ‘\n’ after the “else”
-        if let Some(else_snippet) = snippet_opt(cx, else_span);
-        if let Some((pre_else, post_else)) = else_snippet.split_once("else");
-        if let Some((_, post_else_post_eol)) = post_else.split_once('\n');
+        && let Some(else_snippet) = snippet_opt(cx, else_span)
+        && let Some((pre_else, post_else)) = else_snippet.split_once("else")
+        && let Some((_, post_else_post_eol)) = post_else.split_once('\n')
 
-        then {
-            // Allow allman style braces `} \n else \n {`
-            if_chain! {
-                if is_block(else_);
-                if let Some((_, pre_else_post_eol)) = pre_else.split_once('\n');
-                // Exactly one eol before and after the else
-                if !pre_else_post_eol.contains('\n');
-                if !post_else_post_eol.contains('\n');
-                then {
-                    return;
-                }
-            }
-
-            // Don't warn if the only thing inside post_else_post_eol is a comment block.
-            let trimmed_post_else_post_eol = post_else_post_eol.trim();
-            if trimmed_post_else_post_eol.starts_with("/*") && trimmed_post_else_post_eol.ends_with("*/") {
-                return
-            }
+    {
+        // Allow allman style braces `} \n else \n {`
+        if is_block(else_)
+            && let Some((_, pre_else_post_eol)) = pre_else.split_once('\n')
+            // Exactly one eol before and after the else
+            && !pre_else_post_eol.contains('\n')
+            && !post_else_post_eol.contains('\n')
+        {
+            return;
+        }
 
-            let else_desc = if is_if(else_) { "if" } else { "{..}" };
-            span_lint_and_note(
-                cx,
-                SUSPICIOUS_ELSE_FORMATTING,
-                else_span,
-                &format!("this is an `else {else_desc}` but the formatting might hide it"),
-                None,
-                &format!(
-                    "to remove this lint, remove the `else` or remove the new line between \
-                     `else` and `{else_desc}`",
-                ),
-            );
+        // Don't warn if the only thing inside post_else_post_eol is a comment block.
+        let trimmed_post_else_post_eol = post_else_post_eol.trim();
+        if trimmed_post_else_post_eol.starts_with("/*") && trimmed_post_else_post_eol.ends_with("*/") {
+            return
         }
+
+        let else_desc = if is_if(else_) { "if" } else { "{..}" };
+        span_lint_and_note(
+            cx,
+            SUSPICIOUS_ELSE_FORMATTING,
+            else_span,
+            &format!("this is an `else {else_desc}` but the formatting might hide it"),
+            None,
+            &format!(
+                "to remove this lint, remove the `else` or remove the new line between \
+                 `else` and `{else_desc}`",
+            ),
+        );
     }
 }
 
@@ -272,61 +266,57 @@ fn indentation(cx: &EarlyContext<'_>, span: Span) -> usize {
 fn check_array(cx: &EarlyContext<'_>, expr: &Expr) {
     if let ExprKind::Array(ref array) = expr.kind {
         for element in array {
-            if_chain! {
-                if let ExprKind::Binary(ref op, ref lhs, _) = element.kind;
-                if has_unary_equivalent(op.node) && lhs.span.eq_ctxt(op.span);
-                let space_span = lhs.span.between(op.span);
-                if let Some(space_snippet) = snippet_opt(cx, space_span);
-                let lint_span = lhs.span.with_lo(lhs.span.hi());
-                if space_snippet.contains('\n');
-                if indentation(cx, op.span) <= indentation(cx, lhs.span);
-                then {
-                    span_lint_and_note(
-                        cx,
-                        POSSIBLE_MISSING_COMMA,
-                        lint_span,
-                        "possibly missing a comma here",
-                        None,
-                        "to remove this lint, add a comma or write the expr in a single line",
-                    );
-                }
+            if let ExprKind::Binary(ref op, ref lhs, _) = element.kind
+                && has_unary_equivalent(op.node) && lhs.span.eq_ctxt(op.span)
+                && let space_span = lhs.span.between(op.span)
+                && let Some(space_snippet) = snippet_opt(cx, space_span)
+                && let lint_span = lhs.span.with_lo(lhs.span.hi())
+                && space_snippet.contains('\n')
+                && indentation(cx, op.span) <= indentation(cx, lhs.span)
+            {
+                span_lint_and_note(
+                    cx,
+                    POSSIBLE_MISSING_COMMA,
+                    lint_span,
+                    "possibly missing a comma here",
+                    None,
+                    "to remove this lint, add a comma or write the expr in a single line",
+                );
             }
         }
     }
 }
 
 fn check_missing_else(cx: &EarlyContext<'_>, first: &Expr, second: &Expr) {
-    if_chain! {
-        if !first.span.from_expansion() && !second.span.from_expansion();
-        if matches!(first.kind, ExprKind::If(..));
-        if is_block(second) || is_if(second);
+    if !first.span.from_expansion() && !second.span.from_expansion()
+        && matches!(first.kind, ExprKind::If(..))
+        && (is_block(second) || is_if(second))
 
         // Proc-macros can give weird spans. Make sure this is actually an `if`.
-        if is_span_if(cx, first.span);
+        && is_span_if(cx, first.span)
 
         // If there is a line break between the two expressions, don't lint.
         // If there is a non-whitespace character, this span came from a proc-macro.
-        let else_span = first.span.between(second.span);
-        if let Some(else_snippet) = snippet_opt(cx, else_span);
-        if !else_snippet.chars().any(|c| c == '\n' || !c.is_whitespace());
-        then {
-            let (looks_like, next_thing) = if is_if(second) {
-                ("an `else if`", "the second `if`")
-            } else {
-                ("an `else {..}`", "the next block")
-            };
+        && let else_span = first.span.between(second.span)
+        && let Some(else_snippet) = snippet_opt(cx, else_span)
+        && !else_snippet.chars().any(|c| c == '\n' || !c.is_whitespace())
+    {
+        let (looks_like, next_thing) = if is_if(second) {
+            ("an `else if`", "the second `if`")
+        } else {
+            ("an `else {..}`", "the next block")
+        };
 
-            span_lint_and_note(
-                cx,
-                SUSPICIOUS_ELSE_FORMATTING,
-                else_span,
-                &format!("this looks like {looks_like} but the `else` is missing"),
-                None,
-                &format!(
-                    "to remove this lint, add the missing `else` or add a new line before {next_thing}",
-                ),
-            );
-        }
+        span_lint_and_note(
+            cx,
+            SUSPICIOUS_ELSE_FORMATTING,
+            else_span,
+            &format!("this looks like {looks_like} but the `else` is missing"),
+            None,
+            &format!(
+                "to remove this lint, add the missing `else` or add a new line before {next_thing}",
+            ),
+        );
     }
 }
 
diff --git a/clippy_lints/src/from_str_radix_10.rs b/clippy_lints/src/from_str_radix_10.rs
index 74a60b6a0d2..804b6d31e61 100644
--- a/clippy_lints/src/from_str_radix_10.rs
+++ b/clippy_lints/src/from_str_radix_10.rs
@@ -46,52 +46,50 @@ declare_lint_pass!(FromStrRadix10 => [FROM_STR_RADIX_10]);
 
 impl<'tcx> LateLintPass<'tcx> for FromStrRadix10 {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, exp: &Expr<'tcx>) {
-        if_chain! {
-            if let ExprKind::Call(maybe_path, [src, radix]) = &exp.kind;
-            if let ExprKind::Path(QPath::TypeRelative(ty, pathseg)) = &maybe_path.kind;
+        if let ExprKind::Call(maybe_path, [src, radix]) = &exp.kind
+            && let ExprKind::Path(QPath::TypeRelative(ty, pathseg)) = &maybe_path.kind
 
             // check if the first part of the path is some integer primitive
-            if let TyKind::Path(ty_qpath) = &ty.kind;
-            let ty_res = cx.qpath_res(ty_qpath, ty.hir_id);
-            if let def::Res::PrimTy(prim_ty) = ty_res;
-            if matches!(prim_ty, PrimTy::Int(_) | PrimTy::Uint(_));
+            && let TyKind::Path(ty_qpath) = &ty.kind
+            && let ty_res = cx.qpath_res(ty_qpath, ty.hir_id)
+            && let def::Res::PrimTy(prim_ty) = ty_res
+            && matches!(prim_ty, PrimTy::Int(_) | PrimTy::Uint(_))
 
             // check if the second part of the path indeed calls the associated
             // function `from_str_radix`
-            if pathseg.ident.name.as_str() == "from_str_radix";
+            && pathseg.ident.name.as_str() == "from_str_radix"
 
             // check if the second argument is a primitive `10`
-            if is_integer_literal(radix, 10);
+            && is_integer_literal(radix, 10)
 
-            then {
-                let expr = if let ExprKind::AddrOf(_, _, expr) = &src.kind {
-                    let ty = cx.typeck_results().expr_ty(expr);
-                    if is_ty_stringish(cx, ty) {
-                        expr
-                    } else {
-                        &src
-                    }
+        {
+            let expr = if let ExprKind::AddrOf(_, _, expr) = &src.kind {
+                let ty = cx.typeck_results().expr_ty(expr);
+                if is_ty_stringish(cx, ty) {
+                    expr
                 } else {
                     &src
-                };
+                }
+            } else {
+                &src
+            };
 
-                let sugg = Sugg::hir_with_applicability(
-                    cx,
-                    expr,
-                    "<string>",
-                    &mut Applicability::MachineApplicable
-                ).maybe_par();
+            let sugg = Sugg::hir_with_applicability(
+                cx,
+                expr,
+                "<string>",
+                &mut Applicability::MachineApplicable
+            ).maybe_par();
 
-                span_lint_and_sugg(
-                    cx,
-                    FROM_STR_RADIX_10,
-                    exp.span,
-                    "this call to `from_str_radix` can be replaced with a call to `str::parse`",
-                    "try",
-                    format!("{sugg}.parse::<{}>()", prim_ty.name_str()),
-                    Applicability::MaybeIncorrect
-                );
-            }
+            span_lint_and_sugg(
+                cx,
+                FROM_STR_RADIX_10,
+                exp.span,
+                "this call to `from_str_radix` can be replaced with a call to `str::parse`",
+                "try",
+                format!("{sugg}.parse::<{}>()", prim_ty.name_str()),
+                Applicability::MaybeIncorrect
+            );
         }
     }
 }
diff --git a/clippy_lints/src/functions/impl_trait_in_params.rs b/clippy_lints/src/functions/impl_trait_in_params.rs
index ee66c841ed2..4afff8a2434 100644
--- a/clippy_lints/src/functions/impl_trait_in_params.rs
+++ b/clippy_lints/src/functions/impl_trait_in_params.rs
@@ -52,54 +52,48 @@ fn report(
 }
 
 pub(super) fn check_fn<'tcx>(cx: &LateContext<'_>, kind: &'tcx FnKind<'_>, body: &'tcx Body<'_>, hir_id: HirId) {
-    if_chain! {
-        if let FnKind::ItemFn(ident, generics, _) = kind;
-        if cx.tcx.visibility(cx.tcx.hir().body_owner_def_id(body.id())).is_public();
-        if !is_in_test_function(cx.tcx, hir_id);
-        then {
-            for param in generics.params {
-                if param.is_impl_trait() {
-                    report(cx, param, ident, generics, body.params[0].span);
-                };
-            }
+    if let FnKind::ItemFn(ident, generics, _) = kind
+        && cx.tcx.visibility(cx.tcx.hir().body_owner_def_id(body.id())).is_public()
+        && !is_in_test_function(cx.tcx, hir_id)
+    {
+        for param in generics.params {
+            if param.is_impl_trait() {
+                report(cx, param, ident, generics, body.params[0].span);
+            };
         }
     }
 }
 
 pub(super) fn check_impl_item(cx: &LateContext<'_>, impl_item: &ImplItem<'_>) {
-    if_chain! {
-        if let ImplItemKind::Fn(_, body_id) = impl_item.kind;
-        if let hir::Node::Item(item) = cx.tcx.hir().get_parent(impl_item.hir_id());
-        if let hir::ItemKind::Impl(impl_) = item.kind;
-        if let hir::Impl { of_trait, .. } = *impl_;
-        if of_trait.is_none();
-        let body = cx.tcx.hir().body(body_id);
-        if cx.tcx.visibility(cx.tcx.hir().body_owner_def_id(body.id())).is_public();
-        if !is_in_test_function(cx.tcx, impl_item.hir_id());
-        then {
-            for param in impl_item.generics.params {
-                if param.is_impl_trait() {
-                    report(cx, param, &impl_item.ident, impl_item.generics, body.params[0].span);
-                }
+    if let ImplItemKind::Fn(_, body_id) = impl_item.kind
+        && let hir::Node::Item(item) = cx.tcx.hir().get_parent(impl_item.hir_id())
+        && let hir::ItemKind::Impl(impl_) = item.kind
+        && let hir::Impl { of_trait, .. } = *impl_
+        && of_trait.is_none()
+        && let body = cx.tcx.hir().body(body_id)
+        && cx.tcx.visibility(cx.tcx.hir().body_owner_def_id(body.id())).is_public()
+        && !is_in_test_function(cx.tcx, impl_item.hir_id())
+    {
+        for param in impl_item.generics.params {
+            if param.is_impl_trait() {
+                report(cx, param, &impl_item.ident, impl_item.generics, body.params[0].span);
             }
         }
     }
 }
 
 pub(super) fn check_trait_item(cx: &LateContext<'_>, trait_item: &TraitItem<'_>, avoid_breaking_exported_api: bool) {
-    if_chain! {
-        if !avoid_breaking_exported_api;
-        if let TraitItemKind::Fn(_, _) = trait_item.kind;
-        if let hir::Node::Item(item) = cx.tcx.hir().get_parent(trait_item.hir_id());
+    if !avoid_breaking_exported_api
+        && let TraitItemKind::Fn(_, _) = trait_item.kind
+        && let hir::Node::Item(item) = cx.tcx.hir().get_parent(trait_item.hir_id())
         // ^^ (Will always be a trait)
-        if !item.vis_span.is_empty(); // Is public
-        if !is_in_test_function(cx.tcx, trait_item.hir_id());
-        then {
-            for param in trait_item.generics.params {
-                if param.is_impl_trait() {
-                    let sp = trait_item.ident.span.with_hi(trait_item.ident.span.hi() + BytePos(1));
-                    report(cx, param, &trait_item.ident, trait_item.generics, sp.shrink_to_hi());
-                }
+        && !item.vis_span.is_empty() // Is public
+        && !is_in_test_function(cx.tcx, trait_item.hir_id())
+    {
+        for param in trait_item.generics.params {
+            if param.is_impl_trait() {
+                let sp = trait_item.ident.span.with_hi(trait_item.ident.span.hi() + BytePos(1));
+                report(cx, param, &trait_item.ident, trait_item.generics, sp.shrink_to_hi());
             }
         }
     }
diff --git a/clippy_lints/src/functions/misnamed_getters.rs b/clippy_lints/src/functions/misnamed_getters.rs
index 18f7368dafb..77718893300 100644
--- a/clippy_lints/src/functions/misnamed_getters.rs
+++ b/clippy_lints/src/functions/misnamed_getters.rs
@@ -43,15 +43,13 @@ pub fn check_fn(cx: &LateContext<'_>, kind: FnKind<'_>, decl: &FnDecl<'_>, body:
     // Body must be &(mut) <self_data>.name
     // self_data is not necessarily self, to also lint sub-getters, etc…
 
-    let block_expr = if_chain! {
-        if let ExprKind::Block(block,_) = body.value.kind;
-        if block.stmts.is_empty();
-        if let Some(block_expr) = block.expr;
-        then {
-            block_expr
-        } else {
-            return;
-        }
+    let block_expr = if let ExprKind::Block(block,_) = body.value.kind
+        && block.stmts.is_empty()
+        && let Some(block_expr) = block.expr
+    {
+        block_expr
+    } else {
+        return;
     };
     let expr_span = block_expr.span;
 
@@ -61,14 +59,12 @@ pub fn check_fn(cx: &LateContext<'_>, kind: FnKind<'_>, decl: &FnDecl<'_>, body:
     } else {
         block_expr
     };
-    let (self_data, used_ident) = if_chain! {
-        if let ExprKind::Field(self_data, ident) = expr.kind;
-        if ident.name.as_str() != name;
-        then {
-            (self_data, ident)
-        } else {
-            return;
-        }
+    let (self_data, used_ident) = if let ExprKind::Field(self_data, ident) = expr.kind
+        && ident.name.as_str() != name
+    {
+        (self_data, ident)
+    } else {
+        return;
     };
 
     let mut used_field = None;
diff --git a/clippy_lints/src/functions/result.rs b/clippy_lints/src/functions/result.rs
index 485235514de..aab9cce1e00 100644
--- a/clippy_lints/src/functions/result.rs
+++ b/clippy_lints/src/functions/result.rs
@@ -86,59 +86,57 @@ fn check_result_unit_err(cx: &LateContext<'_>, err_ty: Ty<'_>, fn_header_span: S
 }
 
 fn check_result_large_err<'tcx>(cx: &LateContext<'tcx>, err_ty: Ty<'tcx>, hir_ty_span: Span, large_err_threshold: u64) {
-    if_chain! {
-        if let Adt(adt, subst) = err_ty.kind();
-        if let Some(local_def_id) = err_ty.ty_adt_def().expect("already checked this is adt").did().as_local();
-        if let Some(hir::Node::Item(item)) = cx
+    if let Adt(adt, subst) = err_ty.kind()
+        && let Some(local_def_id) = err_ty.ty_adt_def().expect("already checked this is adt").did().as_local()
+        && let Some(hir::Node::Item(item)) = cx
             .tcx
             .hir()
-            .find_by_def_id(local_def_id);
-        if let hir::ItemKind::Enum(ref def, _) = item.kind;
-        then {
-            let variants_size = AdtVariantInfo::new(cx, *adt, subst);
-            if let Some((first_variant, variants)) = variants_size.split_first()
-                && first_variant.size >= large_err_threshold
-            {
-                span_lint_and_then(
-                    cx,
-                    RESULT_LARGE_ERR,
-                    hir_ty_span,
-                    "the `Err`-variant returned from this function is very large",
-                    |diag| {
-                        diag.span_label(
-                            def.variants[first_variant.ind].span,
-                            format!("the largest variant contains at least {} bytes", variants_size[0].size),
-                        );
+            .find_by_def_id(local_def_id)
+        && let hir::ItemKind::Enum(ref def, _) = item.kind
+    {
+        let variants_size = AdtVariantInfo::new(cx, *adt, subst);
+        if let Some((first_variant, variants)) = variants_size.split_first()
+            && first_variant.size >= large_err_threshold
+        {
+            span_lint_and_then(
+                cx,
+                RESULT_LARGE_ERR,
+                hir_ty_span,
+                "the `Err`-variant returned from this function is very large",
+                |diag| {
+                    diag.span_label(
+                        def.variants[first_variant.ind].span,
+                        format!("the largest variant contains at least {} bytes", variants_size[0].size),
+                    );
 
-                        for variant in variants {
-                            if variant.size >= large_err_threshold {
-                                let variant_def = &def.variants[variant.ind];
-                                diag.span_label(
-                                    variant_def.span,
-                                    format!("the variant `{}` contains at least {} bytes", variant_def.ident, variant.size),
-                                );
-                            }
+                    for variant in variants {
+                        if variant.size >= large_err_threshold {
+                            let variant_def = &def.variants[variant.ind];
+                            diag.span_label(
+                                variant_def.span,
+                                format!("the variant `{}` contains at least {} bytes", variant_def.ident, variant.size),
+                            );
                         }
-
-                        diag.help(format!("try reducing the size of `{err_ty}`, for example by boxing large elements or replacing it with `Box<{err_ty}>`"));
                     }
-                );
-            }
+
+                    diag.help(format!("try reducing the size of `{err_ty}`, for example by boxing large elements or replacing it with `Box<{err_ty}>`"));
+                }
+            );
         }
-        else {
-            let ty_size = approx_ty_size(cx, err_ty);
-            if ty_size >= large_err_threshold {
-                span_lint_and_then(
-                    cx,
-                    RESULT_LARGE_ERR,
-                    hir_ty_span,
-                    "the `Err`-variant returned from this function is very large",
-                    |diag: &mut Diagnostic| {
-                        diag.span_label(hir_ty_span, format!("the `Err`-variant is at least {ty_size} bytes"));
-                        diag.help(format!("try reducing the size of `{err_ty}`, for example by boxing large elements or replacing it with `Box<{err_ty}>`"));
-                    },
-                );
-            }
+    }
+    else {
+        let ty_size = approx_ty_size(cx, err_ty);
+        if ty_size >= large_err_threshold {
+            span_lint_and_then(
+                cx,
+                RESULT_LARGE_ERR,
+                hir_ty_span,
+                "the `Err`-variant returned from this function is very large",
+                |diag: &mut Diagnostic| {
+                    diag.span_label(hir_ty_span, format!("the `Err`-variant is at least {ty_size} bytes"));
+                    diag.help(format!("try reducing the size of `{err_ty}`, for example by boxing large elements or replacing it with `Box<{err_ty}>`"));
+                },
+            );
         }
     }
 }
diff --git a/clippy_lints/src/if_let_mutex.rs b/clippy_lints/src/if_let_mutex.rs
index e614a8f694f..7f111925657 100644
--- a/clippy_lints/src/if_let_mutex.rs
+++ b/clippy_lints/src/if_let_mutex.rs
@@ -127,15 +127,13 @@ impl<'tcx, 'l> ArmVisitor<'tcx, 'l> {
 }
 
 fn is_mutex_lock_call<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<&'tcx Expr<'tcx>> {
-    if_chain! {
-        if let ExprKind::MethodCall(path, self_arg, ..) = &expr.kind;
-        if path.ident.as_str() == "lock";
-        let ty = cx.typeck_results().expr_ty(self_arg).peel_refs();
-        if is_type_diagnostic_item(cx, ty, sym::Mutex);
-        then {
-            Some(self_arg)
-        } else {
-            None
-        }
+    if let ExprKind::MethodCall(path, self_arg, ..) = &expr.kind
+        && path.ident.as_str() == "lock"
+        && let ty = cx.typeck_results().expr_ty(self_arg).peel_refs()
+        && is_type_diagnostic_item(cx, ty, sym::Mutex)
+    {
+        Some(self_arg)
+    } else {
+        None
     }
 }
diff --git a/clippy_lints/src/implicit_hasher.rs b/clippy_lints/src/implicit_hasher.rs
index a1fcce18ff6..16af49a092a 100644
--- a/clippy_lints/src/implicit_hasher.rs
+++ b/clippy_lints/src/implicit_hasher.rs
@@ -337,42 +337,40 @@ impl<'a, 'b, 'tcx> Visitor<'tcx> for ImplicitHasherConstructorVisitor<'a, 'b, 't
     }
 
     fn visit_expr(&mut self, e: &'tcx Expr<'_>) {
-        if_chain! {
-            if let ExprKind::Call(fun, args) = e.kind;
-            if let ExprKind::Path(QPath::TypeRelative(ty, method)) = fun.kind;
-            if let TyKind::Path(QPath::Resolved(None, ty_path)) = ty.kind;
-            if let Some(ty_did) = ty_path.res.opt_def_id();
-            then {
-                if self.target.ty() != self.maybe_typeck_results.unwrap().expr_ty(e) {
-                    return;
-                }
+        if let ExprKind::Call(fun, args) = e.kind
+            && let ExprKind::Path(QPath::TypeRelative(ty, method)) = fun.kind
+            && let TyKind::Path(QPath::Resolved(None, ty_path)) = ty.kind
+            && let Some(ty_did) = ty_path.res.opt_def_id()
+        {
+            if self.target.ty() != self.maybe_typeck_results.unwrap().expr_ty(e) {
+                return;
+            }
 
-                if self.cx.tcx.is_diagnostic_item(sym::HashMap, ty_did) {
-                    if method.ident.name == sym::new {
-                        self.suggestions
-                            .insert(e.span, "HashMap::default()".to_string());
-                    } else if method.ident.name == sym!(with_capacity) {
-                        self.suggestions.insert(
-                            e.span,
-                            format!(
-                                "HashMap::with_capacity_and_hasher({}, Default::default())",
-                                snippet(self.cx, args[0].span, "capacity"),
-                            ),
-                        );
-                    }
-                } else if self.cx.tcx.is_diagnostic_item(sym::HashSet, ty_did) {
-                    if method.ident.name == sym::new {
-                        self.suggestions
-                            .insert(e.span, "HashSet::default()".to_string());
-                    } else if method.ident.name == sym!(with_capacity) {
-                        self.suggestions.insert(
-                            e.span,
-                            format!(
-                                "HashSet::with_capacity_and_hasher({}, Default::default())",
-                                snippet(self.cx, args[0].span, "capacity"),
-                            ),
-                        );
-                    }
+            if self.cx.tcx.is_diagnostic_item(sym::HashMap, ty_did) {
+                if method.ident.name == sym::new {
+                    self.suggestions
+                        .insert(e.span, "HashMap::default()".to_string());
+                } else if method.ident.name == sym!(with_capacity) {
+                    self.suggestions.insert(
+                        e.span,
+                        format!(
+                            "HashMap::with_capacity_and_hasher({}, Default::default())",
+                            snippet(self.cx, args[0].span, "capacity"),
+                        ),
+                    );
+                }
+            } else if self.cx.tcx.is_diagnostic_item(sym::HashSet, ty_did) {
+                if method.ident.name == sym::new {
+                    self.suggestions
+                        .insert(e.span, "HashSet::default()".to_string());
+                } else if method.ident.name == sym!(with_capacity) {
+                    self.suggestions.insert(
+                        e.span,
+                        format!(
+                            "HashSet::with_capacity_and_hasher({}, Default::default())",
+                            snippet(self.cx, args[0].span, "capacity"),
+                        ),
+                    );
                 }
             }
         }
diff --git a/clippy_lints/src/implicit_saturating_add.rs b/clippy_lints/src/implicit_saturating_add.rs
index 24f62490f96..af21d261644 100644
--- a/clippy_lints/src/implicit_saturating_add.rs
+++ b/clippy_lints/src/implicit_saturating_add.rs
@@ -40,42 +40,40 @@ declare_lint_pass!(ImplicitSaturatingAdd => [IMPLICIT_SATURATING_ADD]);
 
 impl<'tcx> LateLintPass<'tcx> for ImplicitSaturatingAdd {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
-        if_chain! {
-            if let ExprKind::If(cond, then, None) = expr.kind;
-            if let ExprKind::DropTemps(expr1) = cond.kind;
-            if let Some((c, op_node, l)) = get_const(cx, expr1);
-            if let BinOpKind::Ne | BinOpKind::Lt = op_node;
-            if let ExprKind::Block(block, None) = then.kind;
-            if let Block {
+        if let ExprKind::If(cond, then, None) = expr.kind
+            && let ExprKind::DropTemps(expr1) = cond.kind
+            && let Some((c, op_node, l)) = get_const(cx, expr1)
+            && let BinOpKind::Ne | BinOpKind::Lt = op_node
+            && let ExprKind::Block(block, None) = then.kind
+            && let Block {
                 stmts:
                     [Stmt
                         { kind: StmtKind::Expr(ex) | StmtKind::Semi(ex), .. }],
                         expr: None, ..} |
-                        Block { stmts: [], expr: Some(ex), ..} = block;
-            if let ExprKind::AssignOp(op1, target, value) = ex.kind;
-            let ty = cx.typeck_results().expr_ty(target);
-            if Some(c) == get_int_max(ty);
-            let ctxt = expr.span.ctxt();
-            if ex.span.ctxt() == ctxt;
-            if expr1.span.ctxt() == ctxt;
-            if clippy_utils::SpanlessEq::new(cx).eq_expr(l, target);
-            if BinOpKind::Add == op1.node;
-            if let ExprKind::Lit(lit) = value.kind;
-            if let LitKind::Int(1, LitIntType::Unsuffixed) = lit.node;
-            if block.expr.is_none();
-            then {
-                let mut app = Applicability::MachineApplicable;
-                let code = snippet_with_context(cx, target.span, ctxt, "_", &mut app).0;
-                let sugg = if let Some(parent) = get_parent_expr(cx, expr)
-                    && let ExprKind::If(_cond, _then, Some(else_)) = parent.kind
-                    && else_.hir_id == expr.hir_id
-                {
-                    format!("{{{code} = {code}.saturating_add(1); }}")
-                } else {
-                    format!("{code} = {code}.saturating_add(1);")
-                };
-                span_lint_and_sugg(cx, IMPLICIT_SATURATING_ADD, expr.span, "manual saturating add detected", "use instead", sugg, app);
-            }
+                        Block { stmts: [], expr: Some(ex), ..} = block
+            && let ExprKind::AssignOp(op1, target, value) = ex.kind
+            && let ty = cx.typeck_results().expr_ty(target)
+            && Some(c) == get_int_max(ty)
+            && let ctxt = expr.span.ctxt()
+            && ex.span.ctxt() == ctxt
+            && expr1.span.ctxt() == ctxt
+            && clippy_utils::SpanlessEq::new(cx).eq_expr(l, target)
+            && BinOpKind::Add == op1.node
+            && let ExprKind::Lit(lit) = value.kind
+            && let LitKind::Int(1, LitIntType::Unsuffixed) = lit.node
+            && block.expr.is_none()
+        {
+            let mut app = Applicability::MachineApplicable;
+            let code = snippet_with_context(cx, target.span, ctxt, "_", &mut app).0;
+            let sugg = if let Some(parent) = get_parent_expr(cx, expr)
+                && let ExprKind::If(_cond, _then, Some(else_)) = parent.kind
+                && else_.hir_id == expr.hir_id
+            {
+                format!("{{{code} = {code}.saturating_add(1); }}")
+            } else {
+                format!("{code} = {code}.saturating_add(1);")
+            };
+            span_lint_and_sugg(cx, IMPLICIT_SATURATING_ADD, expr.span, "manual saturating add detected", "use instead", sugg, app);
         }
     }
 }
diff --git a/clippy_lints/src/implicit_saturating_sub.rs b/clippy_lints/src/implicit_saturating_sub.rs
index 859404289d9..3a45c68c255 100644
--- a/clippy_lints/src/implicit_saturating_sub.rs
+++ b/clippy_lints/src/implicit_saturating_sub.rs
@@ -46,83 +46,77 @@ impl<'tcx> LateLintPass<'tcx> for ImplicitSaturatingSub {
         if expr.span.from_expansion() {
             return;
         }
-        if_chain! {
-            if let Some(higher::If { cond, then, r#else: None }) = higher::If::hir(expr);
+        if let Some(higher::If { cond, then, r#else: None }) = higher::If::hir(expr)
 
             // Check if the conditional expression is a binary operation
-            if let ExprKind::Binary(ref cond_op, cond_left, cond_right) = cond.kind;
+            && let ExprKind::Binary(ref cond_op, cond_left, cond_right) = cond.kind
 
             // Ensure that the binary operator is >, !=, or <
-            if BinOpKind::Ne == cond_op.node || BinOpKind::Gt == cond_op.node || BinOpKind::Lt == cond_op.node;
+            && (BinOpKind::Ne == cond_op.node || BinOpKind::Gt == cond_op.node || BinOpKind::Lt == cond_op.node)
 
             // Check if assign operation is done
-            if let Some(target) = subtracts_one(cx, then);
+            && let Some(target) = subtracts_one(cx, then)
 
             // Extracting out the variable name
-            if let ExprKind::Path(QPath::Resolved(_, ares_path)) = target.kind;
+            && let ExprKind::Path(QPath::Resolved(_, ares_path)) = target.kind
 
-            then {
-                // Handle symmetric conditions in the if statement
-                let (cond_var, cond_num_val) = if SpanlessEq::new(cx).eq_expr(cond_left, target) {
-                    if BinOpKind::Gt == cond_op.node || BinOpKind::Ne == cond_op.node {
-                        (cond_left, cond_right)
-                    } else {
-                        return;
-                    }
-                } else if SpanlessEq::new(cx).eq_expr(cond_right, target) {
-                    if BinOpKind::Lt == cond_op.node || BinOpKind::Ne == cond_op.node {
-                        (cond_right, cond_left)
-                    } else {
-                        return;
-                    }
+        {
+            // Handle symmetric conditions in the if statement
+            let (cond_var, cond_num_val) = if SpanlessEq::new(cx).eq_expr(cond_left, target) {
+                if BinOpKind::Gt == cond_op.node || BinOpKind::Ne == cond_op.node {
+                    (cond_left, cond_right)
                 } else {
                     return;
-                };
-
-                // Check if the variable in the condition statement is an integer
-                if !cx.typeck_results().expr_ty(cond_var).is_integral() {
+                }
+            } else if SpanlessEq::new(cx).eq_expr(cond_right, target) {
+                if BinOpKind::Lt == cond_op.node || BinOpKind::Ne == cond_op.node {
+                    (cond_right, cond_left)
+                } else {
                     return;
                 }
+            } else {
+                return;
+            };
 
-                // Get the variable name
-                let var_name = ares_path.segments[0].ident.name.as_str();
-                match cond_num_val.kind {
-                    ExprKind::Lit(cond_lit) => {
-                        // Check if the constant is zero
-                        if let LitKind::Int(0, _) = cond_lit.node {
-                            if cx.typeck_results().expr_ty(cond_left).is_signed() {
-                            } else {
-                                print_lint_and_sugg(cx, var_name, expr);
-                            };
-                        }
-                    },
-                    ExprKind::Path(QPath::TypeRelative(_, name)) => {
-                        if_chain! {
-                            if name.ident.as_str() == "MIN";
-                            if let Some(const_id) = cx.typeck_results().type_dependent_def_id(cond_num_val.hir_id);
-                            if let Some(impl_id) = cx.tcx.impl_of_method(const_id);
-                            if let None = cx.tcx.impl_trait_ref(impl_id); // An inherent impl
-                            if cx.tcx.type_of(impl_id).instantiate_identity().is_integral();
-                            then {
-                                print_lint_and_sugg(cx, var_name, expr)
-                            }
-                        }
-                    },
-                    ExprKind::Call(func, []) => {
-                        if_chain! {
-                            if let ExprKind::Path(QPath::TypeRelative(_, name)) = func.kind;
-                            if name.ident.as_str() == "min_value";
-                            if let Some(func_id) = cx.typeck_results().type_dependent_def_id(func.hir_id);
-                            if let Some(impl_id) = cx.tcx.impl_of_method(func_id);
-                            if let None = cx.tcx.impl_trait_ref(impl_id); // An inherent impl
-                            if cx.tcx.type_of(impl_id).instantiate_identity().is_integral();
-                            then {
-                                print_lint_and_sugg(cx, var_name, expr)
-                            }
-                        }
-                    },
-                    _ => (),
-                }
+            // Check if the variable in the condition statement is an integer
+            if !cx.typeck_results().expr_ty(cond_var).is_integral() {
+                return;
+            }
+
+            // Get the variable name
+            let var_name = ares_path.segments[0].ident.name.as_str();
+            match cond_num_val.kind {
+                ExprKind::Lit(cond_lit) => {
+                    // Check if the constant is zero
+                    if let LitKind::Int(0, _) = cond_lit.node {
+                        if cx.typeck_results().expr_ty(cond_left).is_signed() {
+                        } else {
+                            print_lint_and_sugg(cx, var_name, expr);
+                        };
+                    }
+                },
+                ExprKind::Path(QPath::TypeRelative(_, name)) => {
+                    if name.ident.as_str() == "MIN"
+                        && let Some(const_id) = cx.typeck_results().type_dependent_def_id(cond_num_val.hir_id)
+                        && let Some(impl_id) = cx.tcx.impl_of_method(const_id)
+                        && let None = cx.tcx.impl_trait_ref(impl_id) // An inherent impl
+                        && cx.tcx.type_of(impl_id).instantiate_identity().is_integral()
+                    {
+                        print_lint_and_sugg(cx, var_name, expr)
+                    }
+                },
+                ExprKind::Call(func, []) => {
+                    if let ExprKind::Path(QPath::TypeRelative(_, name)) = func.kind
+                        && name.ident.as_str() == "min_value"
+                        && let Some(func_id) = cx.typeck_results().type_dependent_def_id(func.hir_id)
+                        && let Some(impl_id) = cx.tcx.impl_of_method(func_id)
+                        && let None = cx.tcx.impl_trait_ref(impl_id) // An inherent impl
+                        && cx.tcx.type_of(impl_id).instantiate_identity().is_integral()
+                    {
+                        print_lint_and_sugg(cx, var_name, expr)
+                    }
+                },
+                _ => (),
             }
         }
     }
@@ -135,18 +129,16 @@ fn subtracts_one<'a>(cx: &LateContext<'_>, expr: &'a Expr<'a>) -> Option<&'a Exp
             (BinOpKind::Sub == op1.node && is_integer_literal(value, 1)).then_some(target)
         },
         ExprKind::Assign(target, value, _) => {
-            if_chain! {
-                if let ExprKind::Binary(ref op1, left1, right1) = value.kind;
-                if BinOpKind::Sub == op1.node;
+            if let ExprKind::Binary(ref op1, left1, right1) = value.kind
+                && BinOpKind::Sub == op1.node
 
-                if SpanlessEq::new(cx).eq_expr(left1, target);
+                && SpanlessEq::new(cx).eq_expr(left1, target)
 
-                if is_integer_literal(right1, 1);
-                then {
-                    Some(target)
-                } else {
-                    None
-                }
+                && is_integer_literal(right1, 1)
+            {
+                Some(target)
+            } else {
+                None
             }
         },
         _ => None,
diff --git a/clippy_lints/src/inconsistent_struct_constructor.rs b/clippy_lints/src/inconsistent_struct_constructor.rs
index a84f7351ad6..14842800b57 100644
--- a/clippy_lints/src/inconsistent_struct_constructor.rs
+++ b/clippy_lints/src/inconsistent_struct_constructor.rs
@@ -66,54 +66,52 @@ declare_lint_pass!(InconsistentStructConstructor => [INCONSISTENT_STRUCT_CONSTRU
 
 impl<'tcx> LateLintPass<'tcx> for InconsistentStructConstructor {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
-        if_chain! {
-            if !expr.span.from_expansion();
-            if let ExprKind::Struct(qpath, fields, base) = expr.kind;
-            let ty = cx.typeck_results().expr_ty(expr);
-            if let Some(adt_def) = ty.ty_adt_def();
-            if adt_def.is_struct();
-            if let Some(variant) = adt_def.variants().iter().next();
-            if fields.iter().all(|f| f.is_shorthand);
-            then {
-                let mut def_order_map = FxHashMap::default();
-                for (idx, field) in variant.fields.iter().enumerate() {
-                    def_order_map.insert(field.name, idx);
-                }
+        if !expr.span.from_expansion()
+            && let ExprKind::Struct(qpath, fields, base) = expr.kind
+            && let ty = cx.typeck_results().expr_ty(expr)
+            && let Some(adt_def) = ty.ty_adt_def()
+            && adt_def.is_struct()
+            && let Some(variant) = adt_def.variants().iter().next()
+            && fields.iter().all(|f| f.is_shorthand)
+        {
+            let mut def_order_map = FxHashMap::default();
+            for (idx, field) in variant.fields.iter().enumerate() {
+                def_order_map.insert(field.name, idx);
+            }
 
-                if is_consistent_order(fields, &def_order_map) {
-                    return;
-                }
+            if is_consistent_order(fields, &def_order_map) {
+                return;
+            }
 
-                let mut ordered_fields: Vec<_> = fields.iter().map(|f| f.ident.name).collect();
-                ordered_fields.sort_unstable_by_key(|id| def_order_map[id]);
+            let mut ordered_fields: Vec<_> = fields.iter().map(|f| f.ident.name).collect();
+            ordered_fields.sort_unstable_by_key(|id| def_order_map[id]);
 
-                let mut fields_snippet = String::new();
-                let (last_ident, idents) = ordered_fields.split_last().unwrap();
-                for ident in idents {
-                    let _: fmt::Result = write!(fields_snippet, "{ident}, ");
-                }
-                fields_snippet.push_str(&last_ident.to_string());
+            let mut fields_snippet = String::new();
+            let (last_ident, idents) = ordered_fields.split_last().unwrap();
+            for ident in idents {
+                let _: fmt::Result = write!(fields_snippet, "{ident}, ");
+            }
+            fields_snippet.push_str(&last_ident.to_string());
 
-                let base_snippet = if let Some(base) = base {
-                        format!(", ..{}", snippet(cx, base.span, ".."))
-                    } else {
-                        String::new()
-                    };
+            let base_snippet = if let Some(base) = base {
+                    format!(", ..{}", snippet(cx, base.span, ".."))
+                } else {
+                    String::new()
+                };
 
-                let sugg = format!("{} {{ {fields_snippet}{base_snippet} }}",
-                    snippet(cx, qpath.span(), ".."),
-                    );
+            let sugg = format!("{} {{ {fields_snippet}{base_snippet} }}",
+                snippet(cx, qpath.span(), ".."),
+                );
 
-                span_lint_and_sugg(
-                    cx,
-                    INCONSISTENT_STRUCT_CONSTRUCTOR,
-                    expr.span,
-                    "struct constructor field order is inconsistent with struct definition field order",
-                    "try",
-                    sugg,
-                    Applicability::MachineApplicable,
-                )
-            }
+            span_lint_and_sugg(
+                cx,
+                INCONSISTENT_STRUCT_CONSTRUCTOR,
+                expr.span,
+                "struct constructor field order is inconsistent with struct definition field order",
+                "try",
+                sugg,
+                Applicability::MachineApplicable,
+            )
         }
     }
 }
diff --git a/clippy_lints/src/index_refutable_slice.rs b/clippy_lints/src/index_refutable_slice.rs
index c2f1f18e39d..5b831af3045 100644
--- a/clippy_lints/src/index_refutable_slice.rs
+++ b/clippy_lints/src/index_refutable_slice.rs
@@ -70,20 +70,18 @@ impl_lint_pass!(IndexRefutableSlice => [INDEX_REFUTABLE_SLICE]);
 
 impl<'tcx> LateLintPass<'tcx> for IndexRefutableSlice {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
-        if_chain! {
-            if !expr.span.from_expansion() || is_expn_of(expr.span, "if_chain").is_some();
-            if let Some(IfLet {let_pat, if_then, ..}) = IfLet::hir(cx, expr);
-            if !is_lint_allowed(cx, INDEX_REFUTABLE_SLICE, expr.hir_id);
-            if self.msrv.meets(msrvs::SLICE_PATTERNS);
+        if (!expr.span.from_expansion() || is_expn_of(expr.span, "if_chain").is_some())
+            && let Some(IfLet {let_pat, if_then, ..}) = IfLet::hir(cx, expr)
+            && !is_lint_allowed(cx, INDEX_REFUTABLE_SLICE, expr.hir_id)
+            && self.msrv.meets(msrvs::SLICE_PATTERNS)
 
-            let found_slices = find_slice_values(cx, let_pat);
-            if !found_slices.is_empty();
-            let filtered_slices = filter_lintable_slices(cx, found_slices, self.max_suggested_slice, if_then);
-            if !filtered_slices.is_empty();
-            then {
-                for slice in filtered_slices.values() {
-                    lint_slice(cx, slice);
-                }
+            && let found_slices = find_slice_values(cx, let_pat)
+            && !found_slices.is_empty()
+            && let filtered_slices = filter_lintable_slices(cx, found_slices, self.max_suggested_slice, if_then)
+            && !filtered_slices.is_empty()
+        {
+            for slice in filtered_slices.values() {
+                lint_slice(cx, slice);
             }
         }
     }
@@ -245,28 +243,26 @@ impl<'a, 'tcx> Visitor<'tcx> for SliceIndexLintingVisitor<'a, 'tcx> {
                 max_suggested_slice,
             } = *self;
 
-            if_chain! {
+            if let Some(use_info) = slice_lint_info.get_mut(&local_id)
                 // Check if this is even a local we're interested in
-                if let Some(use_info) = slice_lint_info.get_mut(&local_id);
 
-                let map = cx.tcx.hir();
+                && let map = cx.tcx.hir()
 
                 // Checking for slice indexing
-                let parent_id = map.parent_id(expr.hir_id);
-                if let Some(hir::Node::Expr(parent_expr)) = map.find(parent_id);
-                if let hir::ExprKind::Index(_, index_expr, _) = parent_expr.kind;
-                if let Some(Constant::Int(index_value)) = constant(cx, cx.typeck_results(), index_expr);
-                if let Ok(index_value) = index_value.try_into();
-                if index_value < max_suggested_slice;
+                && let parent_id = map.parent_id(expr.hir_id)
+                && let Some(hir::Node::Expr(parent_expr)) = map.find(parent_id)
+                && let hir::ExprKind::Index(_, index_expr, _) = parent_expr.kind
+                && let Some(Constant::Int(index_value)) = constant(cx, cx.typeck_results(), index_expr)
+                && let Ok(index_value) = index_value.try_into()
+                && index_value < max_suggested_slice
 
                 // Make sure that this slice index is read only
-                let maybe_addrof_id = map.parent_id(parent_id);
-                if let Some(hir::Node::Expr(maybe_addrof_expr)) = map.find(maybe_addrof_id);
-                if let hir::ExprKind::AddrOf(_kind, hir::Mutability::Not, _inner_expr) = maybe_addrof_expr.kind;
-                then {
-                    use_info.index_use.push((index_value, map.span(parent_expr.hir_id)));
-                    return;
-                }
+                && let maybe_addrof_id = map.parent_id(parent_id)
+                && let Some(hir::Node::Expr(maybe_addrof_expr)) = map.find(maybe_addrof_id)
+                && let hir::ExprKind::AddrOf(_kind, hir::Mutability::Not, _inner_expr) = maybe_addrof_expr.kind
+            {
+                use_info.index_use.push((index_value, map.span(parent_expr.hir_id)));
+                return;
             }
 
             // The slice was used for something other than indexing
diff --git a/clippy_lints/src/instant_subtraction.rs b/clippy_lints/src/instant_subtraction.rs
index 32b2cb4385f..d8966dddeac 100644
--- a/clippy_lints/src/instant_subtraction.rs
+++ b/clippy_lints/src/instant_subtraction.rs
@@ -89,26 +89,22 @@ impl LateLintPass<'_> for InstantSubtraction {
             rhs,
         ) = expr.kind
         {
-            if_chain! {
-                if is_instant_now_call(cx, lhs);
-
-                if is_an_instant(cx, rhs);
-                if let Some(sugg) = Sugg::hir_opt(cx, rhs);
-
-                then {
-                    print_manual_instant_elapsed_sugg(cx, expr, sugg)
-                } else {
-                    if_chain! {
-                        if !expr.span.from_expansion();
-                        if self.msrv.meets(msrvs::TRY_FROM);
-
-                        if is_an_instant(cx, lhs);
-                        if is_a_duration(cx, rhs);
-
-                        then {
-                            print_unchecked_duration_subtraction_sugg(cx, lhs, rhs, expr)
-                        }
-                    }
+            if is_instant_now_call(cx, lhs)
+
+                && is_an_instant(cx, rhs)
+                && let Some(sugg) = Sugg::hir_opt(cx, rhs)
+
+            {
+                print_manual_instant_elapsed_sugg(cx, expr, sugg)
+            } else {
+                if !expr.span.from_expansion()
+                    && self.msrv.meets(msrvs::TRY_FROM)
+
+                    && is_an_instant(cx, lhs)
+                    && is_a_duration(cx, rhs)
+
+                {
+                    print_unchecked_duration_subtraction_sugg(cx, lhs, rhs, expr)
                 }
             }
         }
diff --git a/clippy_lints/src/large_const_arrays.rs b/clippy_lints/src/large_const_arrays.rs
index a4f3d498345..385945045bc 100644
--- a/clippy_lints/src/large_const_arrays.rs
+++ b/clippy_lints/src/large_const_arrays.rs
@@ -47,43 +47,41 @@ impl_lint_pass!(LargeConstArrays => [LARGE_CONST_ARRAYS]);
 
 impl<'tcx> LateLintPass<'tcx> for LargeConstArrays {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
-        if_chain! {
-            if !item.span.from_expansion();
-            if let ItemKind::Const(_, generics, _) = &item.kind;
+        if !item.span.from_expansion()
+            && let ItemKind::Const(_, generics, _) = &item.kind
             // Since static items may not have generics, skip generic const items.
             // FIXME(generic_const_items): I don't think checking `generics.hwcp` suffices as it
             // doesn't account for empty where-clauses that only consist of keyword `where` IINM.
-            if generics.params.is_empty() && !generics.has_where_clause_predicates;
-            let ty = cx.tcx.type_of(item.owner_id).instantiate_identity();
-            if let ty::Array(element_type, cst) = ty.kind();
-            if let ConstKind::Value(ty::ValTree::Leaf(element_count)) = cst.kind();
-            if let Ok(element_count) = element_count.try_to_target_usize(cx.tcx);
-            if let Ok(element_size) = cx.layout_of(*element_type).map(|l| l.size.bytes());
-            if self.maximum_allowed_size < u128::from(element_count) * u128::from(element_size);
+            && generics.params.is_empty() && !generics.has_where_clause_predicates
+            && let ty = cx.tcx.type_of(item.owner_id).instantiate_identity()
+            && let ty::Array(element_type, cst) = ty.kind()
+            && let ConstKind::Value(ty::ValTree::Leaf(element_count)) = cst.kind()
+            && let Ok(element_count) = element_count.try_to_target_usize(cx.tcx)
+            && let Ok(element_size) = cx.layout_of(*element_type).map(|l| l.size.bytes())
+            && self.maximum_allowed_size < u128::from(element_count) * u128::from(element_size)
 
-            then {
-                let hi_pos = item.ident.span.lo() - BytePos::from_usize(1);
-                let sugg_span = Span::new(
-                    hi_pos - BytePos::from_usize("const".len()),
-                    hi_pos,
-                    item.span.ctxt(),
-                    item.span.parent(),
-                );
-                span_lint_and_then(
-                    cx,
-                    LARGE_CONST_ARRAYS,
-                    item.span,
-                    "large array defined as const",
-                    |diag| {
-                        diag.span_suggestion(
-                            sugg_span,
-                            "make this a static item",
-                            "static",
-                            Applicability::MachineApplicable,
-                        );
-                    }
-                );
-            }
+        {
+            let hi_pos = item.ident.span.lo() - BytePos::from_usize(1);
+            let sugg_span = Span::new(
+                hi_pos - BytePos::from_usize("const".len()),
+                hi_pos,
+                item.span.ctxt(),
+                item.span.parent(),
+            );
+            span_lint_and_then(
+                cx,
+                LARGE_CONST_ARRAYS,
+                item.span,
+                "large array defined as const",
+                |diag| {
+                    diag.span_suggestion(
+                        sugg_span,
+                        "make this a static item",
+                        "static",
+                        Applicability::MachineApplicable,
+                    );
+                }
+            );
         }
     }
 }
diff --git a/clippy_lints/src/large_include_file.rs b/clippy_lints/src/large_include_file.rs
index 566901de347..f998a00edee 100644
--- a/clippy_lints/src/large_include_file.rs
+++ b/clippy_lints/src/large_include_file.rs
@@ -50,37 +50,35 @@ impl_lint_pass!(LargeIncludeFile => [LARGE_INCLUDE_FILE]);
 
 impl LateLintPass<'_> for LargeIncludeFile {
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &'_ Expr<'_>) {
-        if_chain! {
-            if let Some(macro_call) = root_macro_call_first_node(cx, expr);
-            if !is_lint_allowed(cx, LARGE_INCLUDE_FILE, expr.hir_id);
-            if cx.tcx.is_diagnostic_item(sym::include_bytes_macro, macro_call.def_id)
-            || cx.tcx.is_diagnostic_item(sym::include_str_macro, macro_call.def_id);
-            if let ExprKind::Lit(lit) = &expr.kind;
-            then {
-                let len = match &lit.node {
-                    // include_bytes
-                    LitKind::ByteStr(bstr, _) => bstr.len(),
-                    // include_str
-                    LitKind::Str(sym, _) => sym.as_str().len(),
-                    _ => return,
-                };
+        if let Some(macro_call) = root_macro_call_first_node(cx, expr)
+            && !is_lint_allowed(cx, LARGE_INCLUDE_FILE, expr.hir_id)
+            && (cx.tcx.is_diagnostic_item(sym::include_bytes_macro, macro_call.def_id)
+            || cx.tcx.is_diagnostic_item(sym::include_str_macro, macro_call.def_id))
+            && let ExprKind::Lit(lit) = &expr.kind
+        {
+            let len = match &lit.node {
+                // include_bytes
+                LitKind::ByteStr(bstr, _) => bstr.len(),
+                // include_str
+                LitKind::Str(sym, _) => sym.as_str().len(),
+                _ => return,
+            };
 
-                if len as u64 <= self.max_file_size {
-                    return;
-                }
-
-                span_lint_and_note(
-                    cx,
-                    LARGE_INCLUDE_FILE,
-                    expr.span,
-                    "attempted to include a large file",
-                    None,
-                    &format!(
-                        "the configuration allows a maximum size of {} bytes",
-                        self.max_file_size
-                    ),
-                );
+            if len as u64 <= self.max_file_size {
+                return;
             }
+
+            span_lint_and_note(
+                cx,
+                LARGE_INCLUDE_FILE,
+                expr.span,
+                "attempted to include a large file",
+                None,
+                &format!(
+                    "the configuration allows a maximum size of {} bytes",
+                    self.max_file_size
+                ),
+            );
         }
     }
 }
diff --git a/clippy_lints/src/len_zero.rs b/clippy_lints/src/len_zero.rs
index 08f095859e5..6d9cec5e957 100644
--- a/clippy_lints/src/len_zero.rs
+++ b/clippy_lints/src/len_zero.rs
@@ -131,37 +131,35 @@ impl<'tcx> LateLintPass<'tcx> for LenZero {
     }
 
     fn check_impl_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx ImplItem<'_>) {
-        if_chain! {
-            if item.ident.name == sym::len;
-            if let ImplItemKind::Fn(sig, _) = &item.kind;
-            if sig.decl.implicit_self.has_implicit_self();
-            if sig.decl.inputs.len() == 1;
-            if cx.effective_visibilities.is_exported(item.owner_id.def_id);
-            if matches!(sig.decl.output, FnRetTy::Return(_));
-            if let Some(imp) = get_parent_as_impl(cx.tcx, item.hir_id());
-            if imp.of_trait.is_none();
-            if let TyKind::Path(ty_path) = &imp.self_ty.kind;
-            if let Some(ty_id) = cx.qpath_res(ty_path, imp.self_ty.hir_id).opt_def_id();
-            if let Some(local_id) = ty_id.as_local();
-            let ty_hir_id = cx.tcx.hir().local_def_id_to_hir_id(local_id);
-            if !is_lint_allowed(cx, LEN_WITHOUT_IS_EMPTY, ty_hir_id);
-            if let Some(output) = parse_len_output(
+        if item.ident.name == sym::len
+            && let ImplItemKind::Fn(sig, _) = &item.kind
+            && sig.decl.implicit_self.has_implicit_self()
+            && sig.decl.inputs.len() == 1
+            && cx.effective_visibilities.is_exported(item.owner_id.def_id)
+            && matches!(sig.decl.output, FnRetTy::Return(_))
+            && let Some(imp) = get_parent_as_impl(cx.tcx, item.hir_id())
+            && imp.of_trait.is_none()
+            && let TyKind::Path(ty_path) = &imp.self_ty.kind
+            && let Some(ty_id) = cx.qpath_res(ty_path, imp.self_ty.hir_id).opt_def_id()
+            && let Some(local_id) = ty_id.as_local()
+            && let ty_hir_id = cx.tcx.hir().local_def_id_to_hir_id(local_id)
+            && !is_lint_allowed(cx, LEN_WITHOUT_IS_EMPTY, ty_hir_id)
+            && let Some(output) = parse_len_output(
                 cx,
                 cx.tcx.fn_sig(item.owner_id).instantiate_identity().skip_binder()
-            );
-            then {
-                let (name, kind) = match cx.tcx.hir().find(ty_hir_id) {
-                    Some(Node::ForeignItem(x)) => (x.ident.name, "extern type"),
-                    Some(Node::Item(x)) => match x.kind {
-                        ItemKind::Struct(..) => (x.ident.name, "struct"),
-                        ItemKind::Enum(..) => (x.ident.name, "enum"),
-                        ItemKind::Union(..) => (x.ident.name, "union"),
-                        _ => (x.ident.name, "type"),
-                    }
-                    _ => return,
-                };
-                check_for_is_empty(cx, sig.span, sig.decl.implicit_self, output, ty_id, name, kind)
-            }
+            )
+        {
+            let (name, kind) = match cx.tcx.hir().find(ty_hir_id) {
+                Some(Node::ForeignItem(x)) => (x.ident.name, "extern type"),
+                Some(Node::Item(x)) => match x.kind {
+                    ItemKind::Struct(..) => (x.ident.name, "struct"),
+                    ItemKind::Enum(..) => (x.ident.name, "enum"),
+                    ItemKind::Union(..) => (x.ident.name, "union"),
+                    _ => (x.ident.name, "type"),
+                }
+                _ => return,
+            };
+            check_for_is_empty(cx, sig.span, sig.decl.implicit_self, output, ty_id, name, kind)
         }
     }
 
diff --git a/clippy_lints/src/let_if_seq.rs b/clippy_lints/src/let_if_seq.rs
index 2f6f36c3960..49c25e3dd9a 100644
--- a/clippy_lints/src/let_if_seq.rs
+++ b/clippy_lints/src/let_if_seq.rs
@@ -61,76 +61,74 @@ impl<'tcx> LateLintPass<'tcx> for LetIfSeq {
     fn check_block(&mut self, cx: &LateContext<'tcx>, block: &'tcx hir::Block<'_>) {
         let mut it = block.stmts.iter().peekable();
         while let Some(stmt) = it.next() {
-            if_chain! {
-                if let Some(expr) = it.peek();
-                if let hir::StmtKind::Local(local) = stmt.kind;
-                if let hir::PatKind::Binding(mode, canonical_id, ident, None) = local.pat.kind;
-                if let hir::StmtKind::Expr(if_) = expr.kind;
-                if let hir::ExprKind::If(hir::Expr { kind: hir::ExprKind::DropTemps(cond), ..}, then, else_) = if_.kind;
-                if !is_local_used(cx, *cond, canonical_id);
-                if let hir::ExprKind::Block(then, _) = then.kind;
-                if let Some(value) = check_assign(cx, canonical_id, then);
-                if !is_local_used(cx, value, canonical_id);
-                then {
-                    let span = stmt.span.to(if_.span);
+            if let Some(expr) = it.peek()
+                && let hir::StmtKind::Local(local) = stmt.kind
+                && let hir::PatKind::Binding(mode, canonical_id, ident, None) = local.pat.kind
+                && let hir::StmtKind::Expr(if_) = expr.kind
+                && let hir::ExprKind::If(hir::Expr { kind: hir::ExprKind::DropTemps(cond), ..}, then, else_) = if_.kind
+                && !is_local_used(cx, *cond, canonical_id)
+                && let hir::ExprKind::Block(then, _) = then.kind
+                && let Some(value) = check_assign(cx, canonical_id, then)
+                && !is_local_used(cx, value, canonical_id)
+            {
+                let span = stmt.span.to(if_.span);
 
-                    let has_interior_mutability = !cx.typeck_results().node_type(canonical_id).is_freeze(
-                        cx.tcx,
-                        cx.param_env,
-                    );
-                    if has_interior_mutability { return; }
+                let has_interior_mutability = !cx.typeck_results().node_type(canonical_id).is_freeze(
+                    cx.tcx,
+                    cx.param_env,
+                );
+                if has_interior_mutability { return; }
 
-                    let (default_multi_stmts, default) = if let Some(else_) = else_ {
-                        if let hir::ExprKind::Block(else_, _) = else_.kind {
-                            if let Some(default) = check_assign(cx, canonical_id, else_) {
-                                (else_.stmts.len() > 1, default)
-                            } else if let Some(default) = local.init {
-                                (true, default)
-                            } else {
-                                continue;
-                            }
+                let (default_multi_stmts, default) = if let Some(else_) = else_ {
+                    if let hir::ExprKind::Block(else_, _) = else_.kind {
+                        if let Some(default) = check_assign(cx, canonical_id, else_) {
+                            (else_.stmts.len() > 1, default)
+                        } else if let Some(default) = local.init {
+                            (true, default)
                         } else {
                             continue;
                         }
-                    } else if let Some(default) = local.init {
-                        (false, default)
                     } else {
                         continue;
-                    };
+                    }
+                } else if let Some(default) = local.init {
+                    (false, default)
+                } else {
+                    continue;
+                };
 
-                    let mutability = match mode {
-                        BindingAnnotation(_, Mutability::Mut) => "<mut> ",
-                        _ => "",
-                    };
+                let mutability = match mode {
+                    BindingAnnotation(_, Mutability::Mut) => "<mut> ",
+                    _ => "",
+                };
 
-                    // FIXME: this should not suggest `mut` if we can detect that the variable is not
-                    // use mutably after the `if`
+                // FIXME: this should not suggest `mut` if we can detect that the variable is not
+                // use mutably after the `if`
 
-                    let sug = format!(
-                        "let {mutability}{name} = if {cond} {{{then} {value} }} else {{{else} {default} }};",
-                        name=ident.name,
-                        cond=snippet(cx, cond.span, "_"),
-                        then=if then.stmts.len() > 1 { " ..;" } else { "" },
-                        else=if default_multi_stmts { " ..;" } else { "" },
-                        value=snippet(cx, value.span, "<value>"),
-                        default=snippet(cx, default.span, "<default>"),
-                    );
-                    span_lint_and_then(cx,
-                                       USELESS_LET_IF_SEQ,
-                                       span,
-                                       "`if _ { .. } else { .. }` is an expression",
-                                       |diag| {
-                                           diag.span_suggestion(
-                                                span,
-                                                "it is more idiomatic to write",
-                                                sug,
-                                                Applicability::HasPlaceholders,
-                                            );
-                                           if !mutability.is_empty() {
-                                               diag.note("you might not need `mut` at all");
-                                           }
-                                       });
-                }
+                let sug = format!(
+                    "let {mutability}{name} = if {cond} {{{then} {value} }} else {{{else} {default} }};",
+                    name=ident.name,
+                    cond=snippet(cx, cond.span, "_"),
+                    then=if then.stmts.len() > 1 { " ..;" } else { "" },
+                    else=if default_multi_stmts { " ..;" } else { "" },
+                    value=snippet(cx, value.span, "<value>"),
+                    default=snippet(cx, default.span, "<default>"),
+                );
+                span_lint_and_then(cx,
+                                   USELESS_LET_IF_SEQ,
+                                   span,
+                                   "`if _ { .. } else { .. }` is an expression",
+                                   |diag| {
+                                       diag.span_suggestion(
+                                            span,
+                                            "it is more idiomatic to write",
+                                            sug,
+                                            Applicability::HasPlaceholders,
+                                        );
+                                       if !mutability.is_empty() {
+                                           diag.note("you might not need `mut` at all");
+                                       }
+                                   });
             }
         }
     }
@@ -141,20 +139,18 @@ fn check_assign<'tcx>(
     decl: hir::HirId,
     block: &'tcx hir::Block<'_>,
 ) -> Option<&'tcx hir::Expr<'tcx>> {
-    if_chain! {
-        if block.expr.is_none();
-        if let Some(expr) = block.stmts.iter().last();
-        if let hir::StmtKind::Semi(expr) = expr.kind;
-        if let hir::ExprKind::Assign(var, value, _) = expr.kind;
-        if path_to_local_id(var, decl);
-        then {
-            if block.stmts.iter().take(block.stmts.len()-1).any(|stmt| is_local_used(cx, stmt, decl)) {
-                None
-            } else {
-                Some(value)
-            }
-        } else {
+    if block.expr.is_none()
+        && let Some(expr) = block.stmts.iter().last()
+        && let hir::StmtKind::Semi(expr) = expr.kind
+        && let hir::ExprKind::Assign(var, value, _) = expr.kind
+        && path_to_local_id(var, decl)
+    {
+        if block.stmts.iter().take(block.stmts.len()-1).any(|stmt| is_local_used(cx, stmt, decl)) {
             None
+        } else {
+            Some(value)
         }
+    } else {
+        None
     }
 }
diff --git a/clippy_lints/src/let_with_type_underscore.rs b/clippy_lints/src/let_with_type_underscore.rs
index 79d728a021c..e7b887d800b 100644
--- a/clippy_lints/src/let_with_type_underscore.rs
+++ b/clippy_lints/src/let_with_type_underscore.rs
@@ -27,27 +27,25 @@ declare_lint_pass!(UnderscoreTyped => [LET_WITH_TYPE_UNDERSCORE]);
 
 impl LateLintPass<'_> for UnderscoreTyped {
     fn check_local(&mut self, cx: &LateContext<'_>, local: &Local<'_>) {
-        if_chain! {
-            if !in_external_macro(cx.tcx.sess, local.span);
-            if let Some(ty) = local.ty; // Ensure that it has a type defined
-            if let TyKind::Infer = &ty.kind; // that type is '_'
-            if local.span.eq_ctxt(ty.span);
-            then {
-                // NOTE: Using `is_from_proc_macro` on `init` will require that it's initialized,
-                // this doesn't. Alternatively, `WithSearchPat` can be implemented for `Ty`
-                if snippet(cx, ty.span, "_").trim() != "_" {
-                    return;
-                }
-
-                span_lint_and_help(
-                    cx,
-                    LET_WITH_TYPE_UNDERSCORE,
-                    local.span,
-                    "variable declared with type underscore",
-                    Some(ty.span.with_lo(local.pat.span.hi())),
-                    "remove the explicit type `_` declaration"
-                )
+        if !in_external_macro(cx.tcx.sess, local.span)
+            && let Some(ty) = local.ty // Ensure that it has a type defined
+            && let TyKind::Infer = &ty.kind // that type is '_'
+            && local.span.eq_ctxt(ty.span)
+        {
+            // NOTE: Using `is_from_proc_macro` on `init` will require that it's initialized,
+            // this doesn't. Alternatively, `WithSearchPat` can be implemented for `Ty`
+            if snippet(cx, ty.span, "_").trim() != "_" {
+                return;
             }
+
+            span_lint_and_help(
+                cx,
+                LET_WITH_TYPE_UNDERSCORE,
+                local.span,
+                "variable declared with type underscore",
+                Some(ty.span.with_lo(local.pat.span.hi())),
+                "remove the explicit type `_` declaration"
+            )
         };
     }
 }
diff --git a/clippy_lints/src/lifetimes.rs b/clippy_lints/src/lifetimes.rs
index 4b89c0fa361..05cc9ac035f 100644
--- a/clippy_lints/src/lifetimes.rs
+++ b/clippy_lints/src/lifetimes.rs
@@ -310,20 +310,18 @@ fn elision_suggestions(
 
 // elision doesn't work for explicit self types, see rust-lang/rust#69064
 fn explicit_self_type<'tcx>(cx: &LateContext<'tcx>, func: &FnDecl<'tcx>, ident: Option<Ident>) -> bool {
-    if_chain! {
-        if let Some(ident) = ident;
-        if ident.name == kw::SelfLower;
-        if !func.implicit_self.has_implicit_self();
+    if let Some(ident) = ident
+        && ident.name == kw::SelfLower
+        && !func.implicit_self.has_implicit_self()
 
-        if let Some(self_ty) = func.inputs.first();
-        then {
-            let mut visitor = RefVisitor::new(cx);
-            visitor.visit_ty(self_ty);
+        && let Some(self_ty) = func.inputs.first()
+    {
+        let mut visitor = RefVisitor::new(cx);
+        visitor.visit_ty(self_ty);
 
-            !visitor.all_lts().is_empty()
-        } else {
-            false
-        }
+        !visitor.all_lts().is_empty()
+    } else {
+        false
     }
 }
 
diff --git a/clippy_lints/src/literal_representation.rs b/clippy_lints/src/literal_representation.rs
index 2c14bb72a9e..1e67183f13a 100644
--- a/clippy_lints/src/literal_representation.rs
+++ b/clippy_lints/src/literal_representation.rs
@@ -255,56 +255,54 @@ impl LiteralDigitGrouping {
     }
 
     fn check_lit(self, cx: &EarlyContext<'_>, lit: token::Lit, span: Span) {
-        if_chain! {
-            if let Some(src) = snippet_opt(cx, span);
-            if let Ok(lit_kind) = LitKind::from_token_lit(lit);
-            if let Some(mut num_lit) = NumericLiteral::from_lit_kind(&src, &lit_kind);
-            then {
-                if !Self::check_for_mistyped_suffix(cx, span, &mut num_lit) {
-                    return;
-                }
+        if let Some(src) = snippet_opt(cx, span)
+            && let Ok(lit_kind) = LitKind::from_token_lit(lit)
+            && let Some(mut num_lit) = NumericLiteral::from_lit_kind(&src, &lit_kind)
+        {
+            if !Self::check_for_mistyped_suffix(cx, span, &mut num_lit) {
+                return;
+            }
+
+            if Self::is_literal_uuid_formatted(&num_lit) {
+                return;
+            }
 
-                if Self::is_literal_uuid_formatted(&num_lit) {
-                    return;
+            let result = (|| {
+
+                let integral_group_size = Self::get_group_size(num_lit.integer.split('_'), num_lit.radix, true)?;
+                if let Some(fraction) = num_lit.fraction {
+                    let fractional_group_size = Self::get_group_size(
+                        fraction.rsplit('_'),
+                        num_lit.radix,
+                        self.lint_fraction_readability)?;
+
+                    let consistent = Self::parts_consistent(integral_group_size,
+                                                            fractional_group_size,
+                                                            num_lit.integer.len(),
+                                                            fraction.len());
+                    if !consistent {
+                        return Err(WarningType::InconsistentDigitGrouping);
+                    };
                 }
 
-                let result = (|| {
-
-                    let integral_group_size = Self::get_group_size(num_lit.integer.split('_'), num_lit.radix, true)?;
-                    if let Some(fraction) = num_lit.fraction {
-                        let fractional_group_size = Self::get_group_size(
-                            fraction.rsplit('_'),
-                            num_lit.radix,
-                            self.lint_fraction_readability)?;
-
-                        let consistent = Self::parts_consistent(integral_group_size,
-                                                                fractional_group_size,
-                                                                num_lit.integer.len(),
-                                                                fraction.len());
-                        if !consistent {
-                            return Err(WarningType::InconsistentDigitGrouping);
-                        };
-                    }
+                Ok(())
+            })();
 
-                    Ok(())
-                })();
-
-
-                if let Err(warning_type) = result {
-                    let should_warn = match warning_type {
-                        | WarningType::UnreadableLiteral
-                        | WarningType::InconsistentDigitGrouping
-                        | WarningType::UnusualByteGroupings
-                        | WarningType::LargeDigitGroups => {
-                            !span.from_expansion()
-                        }
-                        WarningType::DecimalRepresentation | WarningType::MistypedLiteralSuffix => {
-                            true
-                        }
-                    };
-                    if should_warn {
-                        warning_type.display(num_lit.format(), cx, span);
+
+            if let Err(warning_type) = result {
+                let should_warn = match warning_type {
+                    | WarningType::UnreadableLiteral
+                    | WarningType::InconsistentDigitGrouping
+                    | WarningType::UnusualByteGroupings
+                    | WarningType::LargeDigitGroups => {
+                        !span.from_expansion()
+                    }
+                    WarningType::DecimalRepresentation | WarningType::MistypedLiteralSuffix => {
+                        true
                     }
+                };
+                if should_warn {
+                    warning_type.display(num_lit.format(), cx, span);
                 }
             }
         }
@@ -478,20 +476,18 @@ impl DecimalLiteralRepresentation {
     }
     fn check_lit(self, cx: &EarlyContext<'_>, lit: token::Lit, span: Span) {
         // Lint integral literals.
-        if_chain! {
-            if let Ok(lit_kind) = LitKind::from_token_lit(lit);
-            if let LitKind::Int(val, _) = lit_kind;
-            if let Some(src) = snippet_opt(cx, span);
-            if let Some(num_lit) = NumericLiteral::from_lit_kind(&src, &lit_kind);
-            if num_lit.radix == Radix::Decimal;
-            if val >= u128::from(self.threshold);
-            then {
-                let hex = format!("{val:#X}");
-                let num_lit = NumericLiteral::new(&hex, num_lit.suffix, false);
-                let _: Result<(), ()> = Self::do_lint(num_lit.integer).map_err(|warning_type| {
-                    warning_type.display(num_lit.format(), cx, span);
-                });
-            }
+        if let Ok(lit_kind) = LitKind::from_token_lit(lit)
+            && let LitKind::Int(val, _) = lit_kind
+            && let Some(src) = snippet_opt(cx, span)
+            && let Some(num_lit) = NumericLiteral::from_lit_kind(&src, &lit_kind)
+            && num_lit.radix == Radix::Decimal
+            && val >= u128::from(self.threshold)
+        {
+            let hex = format!("{val:#X}");
+            let num_lit = NumericLiteral::new(&hex, num_lit.suffix, false);
+            let _: Result<(), ()> = Self::do_lint(num_lit.integer).map_err(|warning_type| {
+                warning_type.display(num_lit.format(), cx, span);
+            });
         }
     }
 
diff --git a/clippy_lints/src/loops/explicit_counter_loop.rs b/clippy_lints/src/loops/explicit_counter_loop.rs
index 1953ee8a717..f49508cf97d 100644
--- a/clippy_lints/src/loops/explicit_counter_loop.rs
+++ b/clippy_lints/src/loops/explicit_counter_loop.rs
@@ -30,59 +30,57 @@ pub(super) fn check<'tcx>(
             let mut initialize_visitor = InitializeVisitor::new(cx, expr, id);
             walk_block(&mut initialize_visitor, block);
 
-            if_chain! {
-                if let Some((name, ty, initializer)) = initialize_visitor.get_result();
-                if is_integer_const(cx, initializer, 0);
-                then {
-                    let mut applicability = Applicability::MaybeIncorrect;
-                    let span = expr.span.with_hi(arg.span.hi());
+            if let Some((name, ty, initializer)) = initialize_visitor.get_result()
+                && is_integer_const(cx, initializer, 0)
+            {
+                let mut applicability = Applicability::MaybeIncorrect;
+                let span = expr.span.with_hi(arg.span.hi());
 
-                    let int_name = match ty.map(Ty::kind) {
-                        // usize or inferred
-                        Some(ty::Uint(UintTy::Usize)) | None => {
-                            span_lint_and_sugg(
-                                cx,
-                                EXPLICIT_COUNTER_LOOP,
-                                span,
-                                &format!("the variable `{name}` is used as a loop counter"),
-                                "consider using",
-                                format!(
-                                    "for ({name}, {}) in {}.enumerate()",
-                                    snippet_with_applicability(cx, pat.span, "item", &mut applicability),
-                                    make_iterator_snippet(cx, arg, &mut applicability),
-                                ),
-                                applicability,
-                            );
-                            return;
-                        }
-                        Some(ty::Int(int_ty)) => int_ty.name_str(),
-                        Some(ty::Uint(uint_ty)) => uint_ty.name_str(),
-                        _ => return,
-                    };
+                let int_name = match ty.map(Ty::kind) {
+                    // usize or inferred
+                    Some(ty::Uint(UintTy::Usize)) | None => {
+                        span_lint_and_sugg(
+                            cx,
+                            EXPLICIT_COUNTER_LOOP,
+                            span,
+                            &format!("the variable `{name}` is used as a loop counter"),
+                            "consider using",
+                            format!(
+                                "for ({name}, {}) in {}.enumerate()",
+                                snippet_with_applicability(cx, pat.span, "item", &mut applicability),
+                                make_iterator_snippet(cx, arg, &mut applicability),
+                            ),
+                            applicability,
+                        );
+                        return;
+                    }
+                    Some(ty::Int(int_ty)) => int_ty.name_str(),
+                    Some(ty::Uint(uint_ty)) => uint_ty.name_str(),
+                    _ => return,
+                };
 
-                    span_lint_and_then(
-                        cx,
-                        EXPLICIT_COUNTER_LOOP,
-                        span,
-                        &format!("the variable `{name}` is used as a loop counter"),
-                        |diag| {
-                            diag.span_suggestion(
-                                span,
-                                "consider using",
-                                format!(
-                                    "for ({name}, {}) in (0_{int_name}..).zip({})",
-                                    snippet_with_applicability(cx, pat.span, "item", &mut applicability),
-                                    make_iterator_snippet(cx, arg, &mut applicability),
-                                ),
-                                applicability,
-                            );
+                span_lint_and_then(
+                    cx,
+                    EXPLICIT_COUNTER_LOOP,
+                    span,
+                    &format!("the variable `{name}` is used as a loop counter"),
+                    |diag| {
+                        diag.span_suggestion(
+                            span,
+                            "consider using",
+                            format!(
+                                "for ({name}, {}) in (0_{int_name}..).zip({})",
+                                snippet_with_applicability(cx, pat.span, "item", &mut applicability),
+                                make_iterator_snippet(cx, arg, &mut applicability),
+                            ),
+                            applicability,
+                        );
 
-                            diag.note(format!(
-                                "`{name}` is of type `{int_name}`, making it ineligible for `Iterator::enumerate`"
-                            ));
-                        },
-                    );
-                }
+                        diag.note(format!(
+                            "`{name}` is of type `{int_name}`, making it ineligible for `Iterator::enumerate`"
+                        ));
+                    },
+                );
             }
         }
     }
diff --git a/clippy_lints/src/loops/manual_find.rs b/clippy_lints/src/loops/manual_find.rs
index 0aaa66e6bce..2b49e188e3c 100644
--- a/clippy_lints/src/loops/manual_find.rs
+++ b/clippy_lints/src/loops/manual_find.rs
@@ -23,77 +23,75 @@ pub(super) fn check<'tcx>(
     let inner_expr = peel_blocks_with_stmt(body);
     // Check for the specific case that the result is returned and optimize suggestion for that (more
     // cases can be added later)
-    if_chain! {
-        if let Some(higher::If { cond, then, r#else: None, }) = higher::If::hir(inner_expr);
-        if let Some(binding_id) = get_binding(pat);
-        if let ExprKind::Block(block, _) = then.kind;
-        if let [stmt] = block.stmts;
-        if let StmtKind::Semi(semi) = stmt.kind;
-        if let ExprKind::Ret(Some(ret_value)) = semi.kind;
-        if let ExprKind::Call(ctor, [inner_ret]) = ret_value.kind;
-        if is_res_lang_ctor(cx, path_res(cx, ctor), LangItem::OptionSome);
-        if path_res(cx, inner_ret) == Res::Local(binding_id);
-        if let Some((last_stmt, last_ret)) = last_stmt_and_ret(cx, expr);
-        then {
-            let mut applicability = Applicability::MachineApplicable;
-            let mut snippet = make_iterator_snippet(cx, arg, &mut applicability);
-            // Checks if `pat` is a single reference to a binding (`&x`)
-            let is_ref_to_binding =
-                matches!(pat.kind, PatKind::Ref(inner, _) if matches!(inner.kind, PatKind::Binding(..)));
-            // If `pat` is not a binding or a reference to a binding (`x` or `&x`)
-            // we need to map it to the binding returned by the function (i.e. `.map(|(x, _)| x)`)
-            if !(matches!(pat.kind, PatKind::Binding(..)) || is_ref_to_binding) {
-                snippet.push_str(
-                    &format!(
-                        ".map(|{}| {})",
-                        snippet_with_applicability(cx, pat.span, "..", &mut applicability),
-                        snippet_with_applicability(cx, inner_ret.span, "..", &mut applicability),
-                    )[..],
-                );
-            }
-            let ty = cx.typeck_results().expr_ty(inner_ret);
-            if cx.tcx.lang_items().copy_trait().map_or(false, |id| implements_trait(cx, ty, id, &[])) {
-                snippet.push_str(
-                    &format!(
-                        ".find(|{}{}| {})",
-                        "&".repeat(1 + usize::from(is_ref_to_binding)),
-                        snippet_with_applicability(cx, inner_ret.span, "..", &mut applicability),
-                        snippet_with_applicability(cx, cond.span, "..", &mut applicability),
-                    )[..],
-                );
-                if is_ref_to_binding {
-                    snippet.push_str(".copied()");
-                }
-            } else {
-                applicability = Applicability::MaybeIncorrect;
-                snippet.push_str(
-                    &format!(
-                        ".find(|{}| {})",
-                        snippet_with_applicability(cx, inner_ret.span, "..", &mut applicability),
-                        snippet_with_applicability(cx, cond.span, "..", &mut applicability),
-                    )[..],
-                );
+    if let Some(higher::If { cond, then, r#else: None, }) = higher::If::hir(inner_expr)
+        && let Some(binding_id) = get_binding(pat)
+        && let ExprKind::Block(block, _) = then.kind
+        && let [stmt] = block.stmts
+        && let StmtKind::Semi(semi) = stmt.kind
+        && let ExprKind::Ret(Some(ret_value)) = semi.kind
+        && let ExprKind::Call(ctor, [inner_ret]) = ret_value.kind
+        && is_res_lang_ctor(cx, path_res(cx, ctor), LangItem::OptionSome)
+        && path_res(cx, inner_ret) == Res::Local(binding_id)
+        && let Some((last_stmt, last_ret)) = last_stmt_and_ret(cx, expr)
+    {
+        let mut applicability = Applicability::MachineApplicable;
+        let mut snippet = make_iterator_snippet(cx, arg, &mut applicability);
+        // Checks if `pat` is a single reference to a binding (`&x`)
+        let is_ref_to_binding =
+            matches!(pat.kind, PatKind::Ref(inner, _) if matches!(inner.kind, PatKind::Binding(..)));
+        // If `pat` is not a binding or a reference to a binding (`x` or `&x`)
+        // we need to map it to the binding returned by the function (i.e. `.map(|(x, _)| x)`)
+        if !(matches!(pat.kind, PatKind::Binding(..)) || is_ref_to_binding) {
+            snippet.push_str(
+                &format!(
+                    ".map(|{}| {})",
+                    snippet_with_applicability(cx, pat.span, "..", &mut applicability),
+                    snippet_with_applicability(cx, inner_ret.span, "..", &mut applicability),
+                )[..],
+            );
+        }
+        let ty = cx.typeck_results().expr_ty(inner_ret);
+        if cx.tcx.lang_items().copy_trait().map_or(false, |id| implements_trait(cx, ty, id, &[])) {
+            snippet.push_str(
+                &format!(
+                    ".find(|{}{}| {})",
+                    "&".repeat(1 + usize::from(is_ref_to_binding)),
+                    snippet_with_applicability(cx, inner_ret.span, "..", &mut applicability),
+                    snippet_with_applicability(cx, cond.span, "..", &mut applicability),
+                )[..],
+            );
+            if is_ref_to_binding {
+                snippet.push_str(".copied()");
             }
-            // Extends to `last_stmt` to include semicolon in case of `return None;`
-            let lint_span = span.to(last_stmt.span).to(last_ret.span);
-            span_lint_and_then(
-                cx,
-                MANUAL_FIND,
-                lint_span,
-                "manual implementation of `Iterator::find`",
-                |diag| {
-                    if applicability == Applicability::MaybeIncorrect {
-                        diag.note("you may need to dereference some variables");
-                    }
-                    diag.span_suggestion(
-                        lint_span,
-                        "replace with an iterator",
-                        snippet,
-                        applicability,
-                    );
-                },
+        } else {
+            applicability = Applicability::MaybeIncorrect;
+            snippet.push_str(
+                &format!(
+                    ".find(|{}| {})",
+                    snippet_with_applicability(cx, inner_ret.span, "..", &mut applicability),
+                    snippet_with_applicability(cx, cond.span, "..", &mut applicability),
+                )[..],
             );
         }
+        // Extends to `last_stmt` to include semicolon in case of `return None;`
+        let lint_span = span.to(last_stmt.span).to(last_ret.span);
+        span_lint_and_then(
+            cx,
+            MANUAL_FIND,
+            lint_span,
+            "manual implementation of `Iterator::find`",
+            |diag| {
+                if applicability == Applicability::MaybeIncorrect {
+                    diag.note("you may need to dereference some variables");
+                }
+                diag.span_suggestion(
+                    lint_span,
+                    "replace with an iterator",
+                    snippet,
+                    applicability,
+                );
+            },
+        );
     }
 }
 
@@ -124,34 +122,30 @@ fn last_stmt_and_ret<'tcx>(
             if let Some(ret) = block.expr {
                 return Some((last_stmt, ret));
             }
-            if_chain! {
-                if let [.., snd_last, _] = block.stmts;
-                if let StmtKind::Semi(last_expr) = last_stmt.kind;
-                if let ExprKind::Ret(Some(ret)) = last_expr.kind;
-                then {
-                    return Some((snd_last, ret));
-                }
+            if let [.., snd_last, _] = block.stmts
+                && let StmtKind::Semi(last_expr) = last_stmt.kind
+                && let ExprKind::Ret(Some(ret)) = last_expr.kind
+            {
+                return Some((snd_last, ret));
             }
         }
         None
     }
     let mut parent_iter = cx.tcx.hir().parent_iter(expr.hir_id);
-    if_chain! {
+    if let Some((node_hir, Node::Stmt(..))) = parent_iter.next()
         // This should be the loop
-        if let Some((node_hir, Node::Stmt(..))) = parent_iter.next();
         // This should be the function body
-        if let Some((_, Node::Block(block))) = parent_iter.next();
-        if let Some((last_stmt, last_ret)) = extract(block);
-        if last_stmt.hir_id == node_hir;
-        if is_res_lang_ctor(cx, path_res(cx, last_ret), LangItem::OptionNone);
-        if let Some((_, Node::Expr(_block))) = parent_iter.next();
+        && let Some((_, Node::Block(block))) = parent_iter.next()
+        && let Some((last_stmt, last_ret)) = extract(block)
+        && last_stmt.hir_id == node_hir
+        && is_res_lang_ctor(cx, path_res(cx, last_ret), LangItem::OptionNone)
+        && let Some((_, Node::Expr(_block))) = parent_iter.next()
         // This includes the function header
-        if let Some((_, func)) = parent_iter.next();
-        if func.fn_kind().is_some();
-        then {
-            Some((block.stmts.last().unwrap(), last_ret))
-        } else {
-            None
-        }
+        && let Some((_, func)) = parent_iter.next()
+        && func.fn_kind().is_some()
+    {
+        Some((block.stmts.last().unwrap(), last_ret))
+    } else {
+        None
     }
 }
diff --git a/clippy_lints/src/loops/manual_flatten.rs b/clippy_lints/src/loops/manual_flatten.rs
index 559a2c03f14..7659b506e97 100644
--- a/clippy_lints/src/loops/manual_flatten.rs
+++ b/clippy_lints/src/loops/manual_flatten.rs
@@ -21,66 +21,64 @@ pub(super) fn check<'tcx>(
     span: Span,
 ) {
     let inner_expr = peel_blocks_with_stmt(body);
-    if_chain! {
-        if let Some(higher::IfLet { let_pat, let_expr, if_then, if_else: None })
-            = higher::IfLet::hir(cx, inner_expr);
+    if let Some(higher::IfLet { let_pat, let_expr, if_then, if_else: None })
+            = higher::IfLet::hir(cx, inner_expr)
         // Ensure match_expr in `if let` statement is the same as the pat from the for-loop
-        if let PatKind::Binding(_, pat_hir_id, _, _) = pat.kind;
-        if path_to_local_id(let_expr, pat_hir_id);
+        && let PatKind::Binding(_, pat_hir_id, _, _) = pat.kind
+        && path_to_local_id(let_expr, pat_hir_id)
         // Ensure the `if let` statement is for the `Some` variant of `Option` or the `Ok` variant of `Result`
-        if let PatKind::TupleStruct(ref qpath, _, _) = let_pat.kind;
-        if let Res::Def(DefKind::Ctor(..), ctor_id) = cx.qpath_res(qpath, let_pat.hir_id);
-        if let Some(variant_id) = cx.tcx.opt_parent(ctor_id);
-        let some_ctor = cx.tcx.lang_items().option_some_variant() == Some(variant_id);
-        let ok_ctor = cx.tcx.lang_items().result_ok_variant() == Some(variant_id);
-        if some_ctor || ok_ctor;
+        && let PatKind::TupleStruct(ref qpath, _, _) = let_pat.kind
+        && let Res::Def(DefKind::Ctor(..), ctor_id) = cx.qpath_res(qpath, let_pat.hir_id)
+        && let Some(variant_id) = cx.tcx.opt_parent(ctor_id)
+        && let some_ctor = cx.tcx.lang_items().option_some_variant() == Some(variant_id)
+        && let ok_ctor = cx.tcx.lang_items().result_ok_variant() == Some(variant_id)
+        && (some_ctor || ok_ctor)
         // Ensure expr in `if let` is not used afterwards
-        if !is_local_used(cx, if_then, pat_hir_id);
-        then {
-            let if_let_type = if some_ctor { "Some" } else { "Ok" };
-            // Prepare the error message
-            let msg = format!("unnecessary `if let` since only the `{if_let_type}` variant of the iterator element is used");
+        && !is_local_used(cx, if_then, pat_hir_id)
+    {
+        let if_let_type = if some_ctor { "Some" } else { "Ok" };
+        // Prepare the error message
+        let msg = format!("unnecessary `if let` since only the `{if_let_type}` variant of the iterator element is used");
 
-            // Prepare the help message
-            let mut applicability = Applicability::MaybeIncorrect;
-            let arg_snippet = make_iterator_snippet(cx, arg, &mut applicability);
-            let copied = match cx.typeck_results().expr_ty(let_expr).kind() {
-                ty::Ref(_, inner, _) => match inner.kind() {
-                    ty::Ref(..) => ".copied()",
-                    _ => ""
-                }
+        // Prepare the help message
+        let mut applicability = Applicability::MaybeIncorrect;
+        let arg_snippet = make_iterator_snippet(cx, arg, &mut applicability);
+        let copied = match cx.typeck_results().expr_ty(let_expr).kind() {
+            ty::Ref(_, inner, _) => match inner.kind() {
+                ty::Ref(..) => ".copied()",
                 _ => ""
-            };
+            }
+            _ => ""
+        };
 
-            let sugg = format!("{arg_snippet}{copied}.flatten()");
+        let sugg = format!("{arg_snippet}{copied}.flatten()");
 
-            // If suggestion is not a one-liner, it won't be shown inline within the error message. In that case,
-            // it will be shown in the extra `help` message at the end, which is why the first `help_msg` needs
-            // to refer to the correct relative position of the suggestion.
-            let help_msg = if sugg.contains('\n') {
-                "remove the `if let` statement in the for loop and then..."
-            } else {
-                "...and remove the `if let` statement in the for loop"
-            };
+        // If suggestion is not a one-liner, it won't be shown inline within the error message. In that case,
+        // it will be shown in the extra `help` message at the end, which is why the first `help_msg` needs
+        // to refer to the correct relative position of the suggestion.
+        let help_msg = if sugg.contains('\n') {
+            "remove the `if let` statement in the for loop and then..."
+        } else {
+            "...and remove the `if let` statement in the for loop"
+        };
 
-            span_lint_and_then(
-                cx,
-                MANUAL_FLATTEN,
-                span,
-                &msg,
-                |diag| {
-                    diag.span_suggestion(
-                        arg.span,
-                        "try",
-                        sugg,
-                        applicability,
-                    );
-                    diag.span_help(
-                        inner_expr.span,
-                        help_msg,
-                    );
-                }
-            );
-        }
+        span_lint_and_then(
+            cx,
+            MANUAL_FLATTEN,
+            span,
+            &msg,
+            |diag| {
+                diag.span_suggestion(
+                    arg.span,
+                    "try",
+                    sugg,
+                    applicability,
+                );
+                diag.span_help(
+                    inner_expr.span,
+                    help_msg,
+                );
+            }
+        );
     }
 }
diff --git a/clippy_lints/src/loops/manual_memcpy.rs b/clippy_lints/src/loops/manual_memcpy.rs
index d3fd0e8639e..9be888578b5 100644
--- a/clippy_lints/src/loops/manual_memcpy.rs
+++ b/clippy_lints/src/loops/manual_memcpy.rs
@@ -59,22 +59,20 @@ pub(super) fn check<'tcx>(
                 .map(|o| {
                     o.and_then(|(lhs, rhs)| {
                         let rhs = fetch_cloned_expr(rhs);
-                        if_chain! {
-                            if let ExprKind::Index(base_left, idx_left, _) = lhs.kind;
-                            if let ExprKind::Index(base_right, idx_right, _) = rhs.kind;
-                            if let Some(ty) = get_slice_like_element_ty(cx, cx.typeck_results().expr_ty(base_left));
-                            if get_slice_like_element_ty(cx, cx.typeck_results().expr_ty(base_right)).is_some();
-                            if let Some((start_left, offset_left)) = get_details_from_idx(cx, idx_left, &starts);
-                            if let Some((start_right, offset_right)) = get_details_from_idx(cx, idx_right, &starts);
+                        if let ExprKind::Index(base_left, idx_left, _) = lhs.kind
+                            && let ExprKind::Index(base_right, idx_right, _) = rhs.kind
+                            && let Some(ty) = get_slice_like_element_ty(cx, cx.typeck_results().expr_ty(base_left))
+                            && get_slice_like_element_ty(cx, cx.typeck_results().expr_ty(base_right)).is_some()
+                            && let Some((start_left, offset_left)) = get_details_from_idx(cx, idx_left, &starts)
+                            && let Some((start_right, offset_right)) = get_details_from_idx(cx, idx_right, &starts)
 
                             // Source and destination must be different
-                            if path_to_local(base_left) != path_to_local(base_right);
-                            then {
-                                Some((ty, IndexExpr { base: base_left, idx: start_left, idx_offset: offset_left },
-                                    IndexExpr { base: base_right, idx: start_right, idx_offset: offset_right }))
-                            } else {
-                                None
-                            }
+                            && path_to_local(base_left) != path_to_local(base_right)
+                        {
+                            Some((ty, IndexExpr { base: base_left, idx: start_left, idx_offset: offset_left },
+                                IndexExpr { base: base_right, idx: start_right, idx_offset: offset_right }))
+                        } else {
+                            None
                         }
                     })
                 })
@@ -118,23 +116,21 @@ fn build_manual_memcpy_suggestion<'tcx>(
     }
 
     let print_limit = |end: &Expr<'_>, end_str: &str, base: &Expr<'_>, sugg: MinifyingSugg<'static>| {
-        if_chain! {
-            if let ExprKind::MethodCall(method, recv, [], _) = end.kind;
-            if method.ident.name == sym::len;
-            if path_to_local(recv) == path_to_local(base);
-            then {
-                if sugg.to_string() == end_str {
-                    sugg::EMPTY.into()
-                } else {
-                    sugg
-                }
+        if let ExprKind::MethodCall(method, recv, [], _) = end.kind
+            && method.ident.name == sym::len
+            && path_to_local(recv) == path_to_local(base)
+        {
+            if sugg.to_string() == end_str {
+                sugg::EMPTY.into()
             } else {
-                match limits {
-                    ast::RangeLimits::Closed => {
-                        sugg + &sugg::ONE.into()
-                    },
-                    ast::RangeLimits::HalfOpen => sugg,
-                }
+                sugg
+            }
+        } else {
+            match limits {
+                ast::RangeLimits::Closed => {
+                    sugg + &sugg::ONE.into()
+                },
+                ast::RangeLimits::HalfOpen => sugg,
             }
         }
     };
@@ -331,11 +327,9 @@ fn get_slice_like_element_ty<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Opti
 }
 
 fn fetch_cloned_expr<'tcx>(expr: &'tcx Expr<'tcx>) -> &'tcx Expr<'tcx> {
-    if_chain! {
-        if let ExprKind::MethodCall(method, arg, [], _) = expr.kind;
-        if method.ident.name == sym::clone;
-        then { arg } else { expr }
-    }
+    if let ExprKind::MethodCall(method, arg, [], _) = expr.kind
+        && method.ident.name == sym::clone
+    { arg } else { expr }
 }
 
 fn get_details_from_idx<'tcx>(
diff --git a/clippy_lints/src/loops/missing_spin_loop.rs b/clippy_lints/src/loops/missing_spin_loop.rs
index 7b7d19c753f..f332cd87707 100644
--- a/clippy_lints/src/loops/missing_spin_loop.rs
+++ b/clippy_lints/src/loops/missing_spin_loop.rs
@@ -31,26 +31,24 @@ fn unpack_cond<'tcx>(cond: &'tcx Expr<'tcx>) -> &'tcx Expr<'tcx> {
 }
 
 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, cond: &'tcx Expr<'_>, body: &'tcx Expr<'_>) {
-    if_chain! {
-        if let ExprKind::Block(Block { stmts: [], expr: None, ..}, _) = body.kind;
-        if let ExprKind::MethodCall(method, callee, ..) = unpack_cond(cond).kind;
-        if [sym::load, sym::compare_exchange, sym::compare_exchange_weak].contains(&method.ident.name);
-        if let ty::Adt(def, _args) = cx.typeck_results().expr_ty(callee).kind();
-        if cx.tcx.is_diagnostic_item(sym::AtomicBool, def.did());
-        then {
-            span_lint_and_sugg(
-                cx,
-                MISSING_SPIN_LOOP,
-                body.span,
-                "busy-waiting loop should at least have a spin loop hint",
-                "try",
-                (if is_no_std_crate(cx) {
-                    "{ core::hint::spin_loop() }"
-                } else {
-                    "{ std::hint::spin_loop() }"
-                }).into(),
-                Applicability::MachineApplicable
-            );
-        }
+    if let ExprKind::Block(Block { stmts: [], expr: None, ..}, _) = body.kind
+        && let ExprKind::MethodCall(method, callee, ..) = unpack_cond(cond).kind
+        && [sym::load, sym::compare_exchange, sym::compare_exchange_weak].contains(&method.ident.name)
+        && let ty::Adt(def, _args) = cx.typeck_results().expr_ty(callee).kind()
+        && cx.tcx.is_diagnostic_item(sym::AtomicBool, def.did())
+    {
+        span_lint_and_sugg(
+            cx,
+            MISSING_SPIN_LOOP,
+            body.span,
+            "busy-waiting loop should at least have a spin loop hint",
+            "try",
+            (if is_no_std_crate(cx) {
+                "{ core::hint::spin_loop() }"
+            } else {
+                "{ std::hint::spin_loop() }"
+            }).into(),
+            Applicability::MachineApplicable
+        );
     }
 }
diff --git a/clippy_lints/src/loops/mut_range_bound.rs b/clippy_lints/src/loops/mut_range_bound.rs
index b83d148b5f2..ad0b7e33354 100644
--- a/clippy_lints/src/loops/mut_range_bound.rs
+++ b/clippy_lints/src/loops/mut_range_bound.rs
@@ -12,19 +12,17 @@ use rustc_middle::ty;
 use rustc_span::source_map::Span;
 
 pub(super) fn check(cx: &LateContext<'_>, arg: &Expr<'_>, body: &Expr<'_>) {
-    if_chain! {
-        if let Some(higher::Range {
+    if let Some(higher::Range {
             start: Some(start),
             end: Some(end),
             ..
-        }) = higher::Range::hir(arg);
-        let (mut_id_start, mut_id_end) = (check_for_mutability(cx, start), check_for_mutability(cx, end));
-        if mut_id_start.is_some() || mut_id_end.is_some();
-        then {
-            let (span_low, span_high) = check_for_mutation(cx, body, mut_id_start, mut_id_end);
-            mut_warn_with_span(cx, span_low);
-            mut_warn_with_span(cx, span_high);
-        }
+        }) = higher::Range::hir(arg)
+        && let (mut_id_start, mut_id_end) = (check_for_mutability(cx, start), check_for_mutability(cx, end))
+        && (mut_id_start.is_some() || mut_id_end.is_some())
+    {
+        let (span_low, span_high) = check_for_mutation(cx, body, mut_id_start, mut_id_end);
+        mut_warn_with_span(cx, span_low);
+        mut_warn_with_span(cx, span_high);
     }
 }
 
@@ -42,13 +40,11 @@ fn mut_warn_with_span(cx: &LateContext<'_>, span: Option<Span>) {
 }
 
 fn check_for_mutability(cx: &LateContext<'_>, bound: &Expr<'_>) -> Option<HirId> {
-    if_chain! {
-        if let Some(hir_id) = path_to_local(bound);
-        if let Node::Pat(pat) = cx.tcx.hir().get(hir_id);
-        if let PatKind::Binding(BindingAnnotation::MUT, ..) = pat.kind;
-        then {
-            return Some(hir_id);
-        }
+    if let Some(hir_id) = path_to_local(bound)
+        && let Node::Pat(pat) = cx.tcx.hir().get(hir_id)
+        && let PatKind::Binding(BindingAnnotation::MUT, ..) = pat.kind
+    {
+        return Some(hir_id);
     }
     None
 }
diff --git a/clippy_lints/src/loops/needless_range_loop.rs b/clippy_lints/src/loops/needless_range_loop.rs
index c4af46b8fd3..036247c2318 100644
--- a/clippy_lints/src/loops/needless_range_loop.rs
+++ b/clippy_lints/src/loops/needless_range_loop.rs
@@ -187,15 +187,13 @@ pub(super) fn check<'tcx>(
 }
 
 fn is_len_call(expr: &Expr<'_>, var: Symbol) -> bool {
-    if_chain! {
-        if let ExprKind::MethodCall(method, recv, [], _) = expr.kind;
-        if method.ident.name == sym::len;
-        if let ExprKind::Path(QPath::Resolved(_, path)) = recv.kind;
-        if path.segments.len() == 1;
-        if path.segments[0].ident.name == var;
-        then {
-            return true;
-        }
+    if let ExprKind::MethodCall(method, recv, [], _) = expr.kind
+        && method.ident.name == sym::len
+        && let ExprKind::Path(QPath::Resolved(_, path)) = recv.kind
+        && path.segments.len() == 1
+        && path.segments[0].ident.name == var
+    {
+        return true;
     }
 
     false
@@ -207,17 +205,15 @@ fn is_end_eq_array_len<'tcx>(
     limits: ast::RangeLimits,
     indexed_ty: Ty<'tcx>,
 ) -> bool {
-    if_chain! {
-        if let ExprKind::Lit(lit) = end.kind;
-        if let ast::LitKind::Int(end_int, _) = lit.node;
-        if let ty::Array(_, arr_len_const) = indexed_ty.kind();
-        if let Some(arr_len) = arr_len_const.try_eval_target_usize(cx.tcx, cx.param_env);
-        then {
-            return match limits {
-                ast::RangeLimits::Closed => end_int + 1 >= arr_len.into(),
-                ast::RangeLimits::HalfOpen => end_int >= arr_len.into(),
-            };
-        }
+    if let ExprKind::Lit(lit) = end.kind
+        && let ast::LitKind::Int(end_int, _) = lit.node
+        && let ty::Array(_, arr_len_const) = indexed_ty.kind()
+        && let Some(arr_len) = arr_len_const.try_eval_target_usize(cx.tcx, cx.param_env)
+    {
+        return match limits {
+            ast::RangeLimits::Closed => end_int + 1 >= arr_len.into(),
+            ast::RangeLimits::HalfOpen => end_int >= arr_len.into(),
+        };
     }
 
     false
@@ -248,51 +244,49 @@ struct VarVisitor<'a, 'tcx> {
 
 impl<'a, 'tcx> VarVisitor<'a, 'tcx> {
     fn check(&mut self, idx: &'tcx Expr<'_>, seqexpr: &'tcx Expr<'_>, expr: &'tcx Expr<'_>) -> bool {
-        if_chain! {
+        if let ExprKind::Path(ref seqpath) = seqexpr.kind
             // the indexed container is referenced by a name
-            if let ExprKind::Path(ref seqpath) = seqexpr.kind;
-            if let QPath::Resolved(None, seqvar) = *seqpath;
-            if seqvar.segments.len() == 1;
-            if is_local_used(self.cx, idx, self.var);
-            then {
-                if self.prefer_mutable {
-                    self.indexed_mut.insert(seqvar.segments[0].ident.name);
-                }
-                let index_used_directly = matches!(idx.kind, ExprKind::Path(_));
-                let res = self.cx.qpath_res(seqpath, seqexpr.hir_id);
-                match res {
-                    Res::Local(hir_id) => {
-                        let parent_def_id = self.cx.tcx.hir().get_parent_item(expr.hir_id);
-                        let extent = self
-                            .cx
-                            .tcx
-                            .region_scope_tree(parent_def_id)
-                            .var_scope(hir_id.local_id)
-                            .unwrap();
-                        if index_used_directly {
-                            self.indexed_directly.insert(
-                                seqvar.segments[0].ident.name,
-                                (Some(extent), self.cx.typeck_results().node_type(seqexpr.hir_id)),
-                            );
-                        } else {
-                            self.indexed_indirectly
-                                .insert(seqvar.segments[0].ident.name, Some(extent));
-                        }
-                        return false; // no need to walk further *on the variable*
-                    },
-                    Res::Def(DefKind::Static(_) | DefKind::Const, ..) => {
-                        if index_used_directly {
-                            self.indexed_directly.insert(
-                                seqvar.segments[0].ident.name,
-                                (None, self.cx.typeck_results().node_type(seqexpr.hir_id)),
-                            );
-                        } else {
-                            self.indexed_indirectly.insert(seqvar.segments[0].ident.name, None);
-                        }
-                        return false; // no need to walk further *on the variable*
-                    },
-                    _ => (),
-                }
+            && let QPath::Resolved(None, seqvar) = *seqpath
+            && seqvar.segments.len() == 1
+            && is_local_used(self.cx, idx, self.var)
+        {
+            if self.prefer_mutable {
+                self.indexed_mut.insert(seqvar.segments[0].ident.name);
+            }
+            let index_used_directly = matches!(idx.kind, ExprKind::Path(_));
+            let res = self.cx.qpath_res(seqpath, seqexpr.hir_id);
+            match res {
+                Res::Local(hir_id) => {
+                    let parent_def_id = self.cx.tcx.hir().get_parent_item(expr.hir_id);
+                    let extent = self
+                        .cx
+                        .tcx
+                        .region_scope_tree(parent_def_id)
+                        .var_scope(hir_id.local_id)
+                        .unwrap();
+                    if index_used_directly {
+                        self.indexed_directly.insert(
+                            seqvar.segments[0].ident.name,
+                            (Some(extent), self.cx.typeck_results().node_type(seqexpr.hir_id)),
+                        );
+                    } else {
+                        self.indexed_indirectly
+                            .insert(seqvar.segments[0].ident.name, Some(extent));
+                    }
+                    return false; // no need to walk further *on the variable*
+                },
+                Res::Def(DefKind::Static(_) | DefKind::Const, ..) => {
+                    if index_used_directly {
+                        self.indexed_directly.insert(
+                            seqvar.segments[0].ident.name,
+                            (None, self.cx.typeck_results().node_type(seqexpr.hir_id)),
+                        );
+                    } else {
+                        self.indexed_indirectly.insert(seqvar.segments[0].ident.name, None);
+                    }
+                    return false; // no need to walk further *on the variable*
+                },
+                _ => (),
             }
         }
         true
@@ -301,42 +295,36 @@ impl<'a, 'tcx> VarVisitor<'a, 'tcx> {
 
 impl<'a, 'tcx> Visitor<'tcx> for VarVisitor<'a, 'tcx> {
     fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
-        if_chain! {
+        if let ExprKind::MethodCall(meth, args_0, [args_1, ..], _) = &expr.kind
             // a range index op
-            if let ExprKind::MethodCall(meth, args_0, [args_1, ..], _) = &expr.kind;
-            if let Some(trait_id) = self
+            && let Some(trait_id) = self
                 .cx
                 .typeck_results()
                 .type_dependent_def_id(expr.hir_id)
-                .and_then(|def_id| self.cx.tcx.trait_of_item(def_id));
-            if (meth.ident.name == sym::index && self.cx.tcx.lang_items().index_trait() == Some(trait_id))
-                || (meth.ident.name == sym::index_mut && self.cx.tcx.lang_items().index_mut_trait() == Some(trait_id));
-            if !self.check(args_1, args_0, expr);
-            then {
-                return;
-            }
+                .and_then(|def_id| self.cx.tcx.trait_of_item(def_id))
+            && ((meth.ident.name == sym::index && self.cx.tcx.lang_items().index_trait() == Some(trait_id))
+                || (meth.ident.name == sym::index_mut && self.cx.tcx.lang_items().index_mut_trait() == Some(trait_id)))
+            && !self.check(args_1, args_0, expr)
+        {
+            return;
         }
 
-        if_chain! {
+        if let ExprKind::Index(seqexpr, idx, _) = expr.kind
             // an index op
-            if let ExprKind::Index(seqexpr, idx, _) = expr.kind;
-            if !self.check(idx, seqexpr, expr);
-            then {
-                return;
-            }
+            && !self.check(idx, seqexpr, expr)
+        {
+            return;
         }
 
-        if_chain! {
+        if let ExprKind::Path(QPath::Resolved(None, path)) = expr.kind
             // directly using a variable
-            if let ExprKind::Path(QPath::Resolved(None, path)) = expr.kind;
-            if let Res::Local(local_id) = path.res;
-            then {
-                if local_id == self.var {
-                    self.nonindex = true;
-                } else {
-                    // not the correct variable, but still a variable
-                    self.referenced.insert(path.segments[0].ident.name);
-                }
+            && let Res::Local(local_id) = path.res
+        {
+            if local_id == self.var {
+                self.nonindex = true;
+            } else {
+                // not the correct variable, but still a variable
+                self.referenced.insert(path.segments[0].ident.name);
             }
         }
 
diff --git a/clippy_lints/src/loops/same_item_push.rs b/clippy_lints/src/loops/same_item_push.rs
index 5fffb27cda2..0c0a9138b27 100644
--- a/clippy_lints/src/loops/same_item_push.rs
+++ b/clippy_lints/src/loops/same_item_push.rs
@@ -44,54 +44,50 @@ pub(super) fn check<'tcx>(
     // Determine whether it is safe to lint the body
     let mut same_item_push_visitor = SameItemPushVisitor::new(cx);
     walk_expr(&mut same_item_push_visitor, body);
-    if_chain! {
-        if same_item_push_visitor.should_lint();
-        if let Some((vec, pushed_item, ctxt)) = same_item_push_visitor.vec_push;
-        let vec_ty = cx.typeck_results().expr_ty(vec);
-        let ty = vec_ty.walk().nth(1).unwrap().expect_ty();
-        if cx
+    if same_item_push_visitor.should_lint()
+        && let Some((vec, pushed_item, ctxt)) = same_item_push_visitor.vec_push
+        && let vec_ty = cx.typeck_results().expr_ty(vec)
+        && let ty = vec_ty.walk().nth(1).unwrap().expect_ty()
+        && cx
             .tcx
             .lang_items()
             .clone_trait()
-            .map_or(false, |id| implements_trait(cx, ty, id, &[]));
-        then {
-            // Make sure that the push does not involve possibly mutating values
-            match pushed_item.kind {
-                ExprKind::Path(ref qpath) => {
-                    match cx.qpath_res(qpath, pushed_item.hir_id) {
-                        // immutable bindings that are initialized with literal or constant
-                        Res::Local(hir_id) => {
-                            let node = cx.tcx.hir().get(hir_id);
-                            if_chain! {
-                                if let Node::Pat(pat) = node;
-                                if let PatKind::Binding(bind_ann, ..) = pat.kind;
-                                if !matches!(bind_ann, BindingAnnotation(_, Mutability::Mut));
-                                let parent_node = cx.tcx.hir().parent_id(hir_id);
-                                if let Some(Node::Local(parent_let_expr)) = cx.tcx.hir().find(parent_node);
-                                if let Some(init) = parent_let_expr.init;
-                                then {
-                                    match init.kind {
-                                        // immutable bindings that are initialized with literal
-                                        ExprKind::Lit(..) => emit_lint(cx, vec, pushed_item, ctxt),
-                                        // immutable bindings that are initialized with constant
-                                        ExprKind::Path(ref path) => {
-                                            if let Res::Def(DefKind::Const, ..) = cx.qpath_res(path, init.hir_id) {
-                                                emit_lint(cx, vec, pushed_item, ctxt);
-                                            }
-                                        }
-                                        _ => {},
+            .map_or(false, |id| implements_trait(cx, ty, id, &[]))
+    {
+        // Make sure that the push does not involve possibly mutating values
+        match pushed_item.kind {
+            ExprKind::Path(ref qpath) => {
+                match cx.qpath_res(qpath, pushed_item.hir_id) {
+                    // immutable bindings that are initialized with literal or constant
+                    Res::Local(hir_id) => {
+                        let node = cx.tcx.hir().get(hir_id);
+                        if let Node::Pat(pat) = node
+                            && let PatKind::Binding(bind_ann, ..) = pat.kind
+                            && !matches!(bind_ann, BindingAnnotation(_, Mutability::Mut))
+                            && let parent_node = cx.tcx.hir().parent_id(hir_id)
+                            && let Some(Node::Local(parent_let_expr)) = cx.tcx.hir().find(parent_node)
+                            && let Some(init) = parent_let_expr.init
+                        {
+                            match init.kind {
+                                // immutable bindings that are initialized with literal
+                                ExprKind::Lit(..) => emit_lint(cx, vec, pushed_item, ctxt),
+                                // immutable bindings that are initialized with constant
+                                ExprKind::Path(ref path) => {
+                                    if let Res::Def(DefKind::Const, ..) = cx.qpath_res(path, init.hir_id) {
+                                        emit_lint(cx, vec, pushed_item, ctxt);
                                     }
                                 }
+                                _ => {},
                             }
-                        },
-                        // constant
-                        Res::Def(DefKind::Const, ..) => emit_lint(cx, vec, pushed_item, ctxt),
-                        _ => {},
-                    }
-                },
-                ExprKind::Lit(..) => emit_lint(cx, vec, pushed_item, ctxt),
-                _ => {},
-            }
+                        }
+                    },
+                    // constant
+                    Res::Def(DefKind::Const, ..) => emit_lint(cx, vec, pushed_item, ctxt),
+                    _ => {},
+                }
+            },
+            ExprKind::Lit(..) => emit_lint(cx, vec, pushed_item, ctxt),
+            _ => {},
         }
     }
 }
@@ -118,16 +114,14 @@ impl<'a, 'tcx> SameItemPushVisitor<'a, 'tcx> {
     }
 
     fn should_lint(&self) -> bool {
-        if_chain! {
-            if !self.non_deterministic_expr;
-            if !self.multiple_pushes;
-            if let Some((vec, _, _)) = self.vec_push;
-            if let Some(hir_id) = path_to_local(vec);
-            then {
-                !self.used_locals.contains(&hir_id)
-            } else {
-                false
-            }
+        if !self.non_deterministic_expr
+            && !self.multiple_pushes
+            && let Some((vec, _, _)) = self.vec_push
+            && let Some(hir_id) = path_to_local(vec)
+        {
+            !self.used_locals.contains(&hir_id)
+        } else {
+            false
         }
     }
 }
@@ -180,18 +174,16 @@ fn get_vec_push<'tcx>(
     cx: &LateContext<'tcx>,
     stmt: &'tcx Stmt<'_>,
 ) -> Option<(&'tcx Expr<'tcx>, &'tcx Expr<'tcx>, SyntaxContext)> {
-    if_chain! {
+    if let StmtKind::Semi(semi_stmt) = &stmt.kind
             // Extract method being called
-            if let StmtKind::Semi(semi_stmt) = &stmt.kind;
-            if let ExprKind::MethodCall(path, self_expr, args, _) = &semi_stmt.kind;
+            && let ExprKind::MethodCall(path, self_expr, args, _) = &semi_stmt.kind
             // Figure out the parameters for the method call
-            if let Some(pushed_item) = args.first();
+            && let Some(pushed_item) = args.first()
             // Check that the method being called is push() on a Vec
-            if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(self_expr), sym::Vec);
-            if path.ident.name.as_str() == "push";
-            then {
-                return Some((self_expr, pushed_item, semi_stmt.span.ctxt()))
-            }
-    }
+            && is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(self_expr), sym::Vec)
+            && path.ident.name.as_str() == "push"
+        {
+            return Some((self_expr, pushed_item, semi_stmt.span.ctxt()))
+        }
     None
 }
diff --git a/clippy_lints/src/loops/single_element_loop.rs b/clippy_lints/src/loops/single_element_loop.rs
index dfb800ccf71..0511ec011c4 100644
--- a/clippy_lints/src/loops/single_element_loop.rs
+++ b/clippy_lints/src/loops/single_element_loop.rs
@@ -66,36 +66,34 @@ pub(super) fn check<'tcx>(
         ExprKind::Array([arg]) if cx.tcx.sess.edition() >= Edition::Edition2021 => (arg, ""),
         _ => return,
     };
-    if_chain! {
-        if let ExprKind::Block(block, _) = body.kind;
-        if !block.stmts.is_empty();
-        if !contains_break_or_continue(body);
-        then {
-            let mut applicability = Applicability::MachineApplicable;
-            let pat_snip = snippet_with_applicability(cx, pat.span, "..", &mut applicability);
-            let mut arg_snip = snippet_with_applicability(cx, arg_expression.span, "..", &mut applicability);
-            let mut block_str = snippet_with_applicability(cx, block.span, "..", &mut applicability).into_owned();
-            block_str.remove(0);
-            block_str.pop();
-            let indent = " ".repeat(indent_of(cx, block.stmts[0].span).unwrap_or(0));
+    if let ExprKind::Block(block, _) = body.kind
+        && !block.stmts.is_empty()
+        && !contains_break_or_continue(body)
+    {
+        let mut applicability = Applicability::MachineApplicable;
+        let pat_snip = snippet_with_applicability(cx, pat.span, "..", &mut applicability);
+        let mut arg_snip = snippet_with_applicability(cx, arg_expression.span, "..", &mut applicability);
+        let mut block_str = snippet_with_applicability(cx, block.span, "..", &mut applicability).into_owned();
+        block_str.remove(0);
+        block_str.pop();
+        let indent = " ".repeat(indent_of(cx, block.stmts[0].span).unwrap_or(0));
 
-            // Reference iterator from `&(mut) []` or `[].iter(_mut)()`.
-            if !prefix.is_empty() && (
-                // Precedence of internal expression is less than or equal to precedence of `&expr`.
-                arg_expression.precedence().order() <= PREC_PREFIX || is_range_literal(arg_expression)
-            ) {
-                arg_snip = format!("({arg_snip})").into();
-            }
-
-            span_lint_and_sugg(
-                cx,
-                SINGLE_ELEMENT_LOOP,
-                expr.span,
-                "for loop over a single element",
-                "try",
-                format!("{{\n{indent}let {pat_snip} = {prefix}{arg_snip};{block_str}}}"),
-                applicability,
-            )
+        // Reference iterator from `&(mut) []` or `[].iter(_mut)()`.
+        if !prefix.is_empty() && (
+            // Precedence of internal expression is less than or equal to precedence of `&expr`.
+            arg_expression.precedence().order() <= PREC_PREFIX || is_range_literal(arg_expression)
+        ) {
+            arg_snip = format!("({arg_snip})").into();
         }
+
+        span_lint_and_sugg(
+            cx,
+            SINGLE_ELEMENT_LOOP,
+            expr.span,
+            "for loop over a single element",
+            "try",
+            format!("{{\n{indent}let {pat_snip} = {prefix}{arg_snip};{block_str}}}"),
+            applicability,
+        )
     }
 }
diff --git a/clippy_lints/src/loops/utils.rs b/clippy_lints/src/loops/utils.rs
index 0a2bd89eb3c..c4d89dc3f0e 100644
--- a/clippy_lints/src/loops/utils.rs
+++ b/clippy_lints/src/loops/utils.rs
@@ -145,20 +145,18 @@ impl<'a, 'tcx> Visitor<'tcx> for InitializeVisitor<'a, 'tcx> {
 
     fn visit_local(&mut self, l: &'tcx Local<'_>) {
         // Look for declarations of the variable
-        if_chain! {
-            if l.pat.hir_id == self.var_id;
-            if let PatKind::Binding(.., ident, _) = l.pat.kind;
-            then {
-                let ty = l.ty.map(|_| self.cx.typeck_results().pat_ty(l.pat));
+        if l.pat.hir_id == self.var_id
+            && let PatKind::Binding(.., ident, _) = l.pat.kind
+        {
+            let ty = l.ty.map(|_| self.cx.typeck_results().pat_ty(l.pat));
 
-                self.state = l.init.map_or(InitializeVisitorState::Declared(ident.name, ty), |init| {
-                    InitializeVisitorState::Initialized {
-                        initializer: init,
-                        ty,
-                        name: ident.name,
-                    }
-                })
-            }
+            self.state = l.init.map_or(InitializeVisitorState::Declared(ident.name, ty), |init| {
+                InitializeVisitorState::Initialized {
+                    initializer: init,
+                    ty,
+                    name: ident.name,
+                }
+            })
         }
 
         walk_local(self, l);
diff --git a/clippy_lints/src/loops/while_immutable_condition.rs b/clippy_lints/src/loops/while_immutable_condition.rs
index 7f24f3c5dc2..d5b50db4501 100644
--- a/clippy_lints/src/loops/while_immutable_condition.rs
+++ b/clippy_lints/src/loops/while_immutable_condition.rs
@@ -95,20 +95,18 @@ struct VarCollectorVisitor<'a, 'tcx> {
 
 impl<'a, 'tcx> VarCollectorVisitor<'a, 'tcx> {
     fn insert_def_id(&mut self, ex: &'tcx Expr<'_>) {
-        if_chain! {
-            if let ExprKind::Path(ref qpath) = ex.kind;
-            if let QPath::Resolved(None, _) = *qpath;
-            then {
-                match self.cx.qpath_res(qpath, ex.hir_id) {
-                    Res::Local(hir_id) => {
-                        self.ids.insert(hir_id);
-                    },
-                    Res::Def(DefKind::Static(_), def_id) => {
-                        let mutable = self.cx.tcx.is_mutable_static(def_id);
-                        self.def_ids.insert(def_id, mutable);
-                    },
-                    _ => {},
-                }
+        if let ExprKind::Path(ref qpath) = ex.kind
+            && let QPath::Resolved(None, _) = *qpath
+        {
+            match self.cx.qpath_res(qpath, ex.hir_id) {
+                Res::Local(hir_id) => {
+                    self.ids.insert(hir_id);
+                },
+                Res::Def(DefKind::Static(_), def_id) => {
+                    let mutable = self.cx.tcx.is_mutable_static(def_id);
+                    self.def_ids.insert(def_id, mutable);
+                },
+                _ => {},
             }
         }
     }
diff --git a/clippy_lints/src/loops/while_let_on_iterator.rs b/clippy_lints/src/loops/while_let_on_iterator.rs
index 5153070cfe6..144f4b0fb4c 100644
--- a/clippy_lints/src/loops/while_let_on_iterator.rs
+++ b/clippy_lints/src/loops/while_let_on_iterator.rs
@@ -15,23 +15,21 @@ use rustc_span::symbol::sym;
 use rustc_span::Symbol;
 
 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-    let (scrutinee_expr, iter_expr_struct, iter_expr, some_pat, loop_expr) = if_chain! {
-        if let Some(higher::WhileLet { if_then, let_pat, let_expr }) = higher::WhileLet::hir(expr);
+    let (scrutinee_expr, iter_expr_struct, iter_expr, some_pat, loop_expr) = if let Some(higher::WhileLet { if_then, let_pat, let_expr }) = higher::WhileLet::hir(expr)
         // check for `Some(..)` pattern
-        if let PatKind::TupleStruct(ref pat_path, some_pat, _) = let_pat.kind;
-        if is_res_lang_ctor(cx, cx.qpath_res(pat_path, let_pat.hir_id), LangItem::OptionSome);
+        && let PatKind::TupleStruct(ref pat_path, some_pat, _) = let_pat.kind
+        && is_res_lang_ctor(cx, cx.qpath_res(pat_path, let_pat.hir_id), LangItem::OptionSome)
         // check for call to `Iterator::next`
-        if let ExprKind::MethodCall(method_name, iter_expr, [], _) = let_expr.kind;
-        if method_name.ident.name == sym::next;
-        if is_trait_method(cx, let_expr, sym::Iterator);
-        if let Some(iter_expr_struct) = try_parse_iter_expr(cx, iter_expr);
+        && let ExprKind::MethodCall(method_name, iter_expr, [], _) = let_expr.kind
+        && method_name.ident.name == sym::next
+        && is_trait_method(cx, let_expr, sym::Iterator)
+        && let Some(iter_expr_struct) = try_parse_iter_expr(cx, iter_expr)
         // get the loop containing the match expression
-        if !uses_iter(cx, &iter_expr_struct, if_then);
-        then {
-            (let_expr, iter_expr_struct, iter_expr, some_pat, expr)
-        } else {
-            return;
-        }
+        && !uses_iter(cx, &iter_expr_struct, if_then)
+    {
+        (let_expr, iter_expr_struct, iter_expr, some_pat, expr)
+    } else {
+        return;
     };
 
     let mut applicability = Applicability::MachineApplicable;
diff --git a/clippy_lints/src/macro_use.rs b/clippy_lints/src/macro_use.rs
index 70c5182472a..42987e583af 100644
--- a/clippy_lints/src/macro_use.rs
+++ b/clippy_lints/src/macro_use.rs
@@ -90,30 +90,28 @@ impl MacroUseImports {
 
 impl<'tcx> LateLintPass<'tcx> for MacroUseImports {
     fn check_item(&mut self, cx: &LateContext<'_>, item: &hir::Item<'_>) {
-        if_chain! {
-            if cx.sess().opts.edition >= Edition::Edition2018;
-            if let hir::ItemKind::Use(path, _kind) = &item.kind;
-            let hir_id = item.hir_id();
-            let attrs = cx.tcx.hir().attrs(hir_id);
-            if let Some(mac_attr) = attrs.iter().find(|attr| attr.has_name(sym::macro_use));
-            if let Some(id) = path.res.iter().find_map(|res| match res {
+        if cx.sess().opts.edition >= Edition::Edition2018
+            && let hir::ItemKind::Use(path, _kind) = &item.kind
+            && let hir_id = item.hir_id()
+            && let attrs = cx.tcx.hir().attrs(hir_id)
+            && let Some(mac_attr) = attrs.iter().find(|attr| attr.has_name(sym::macro_use))
+            && let Some(id) = path.res.iter().find_map(|res| match res {
                 Res::Def(DefKind::Mod, id) => Some(id),
                 _ => None,
-            });
-            if !id.is_local();
-            then {
-                for kid in cx.tcx.module_children(id) {
-                    if let Res::Def(DefKind::Macro(_mac_type), mac_id) = kid.res {
-                        let span = mac_attr.span;
-                        let def_path = cx.tcx.def_path_str(mac_id);
-                        self.imports.push((def_path, span, hir_id));
-                    }
-                }
-            } else {
-                if item.span.from_expansion() {
-                    self.push_unique_macro_pat_ty(cx, item.span);
+            })
+            && !id.is_local()
+        {
+            for kid in cx.tcx.module_children(id) {
+                if let Res::Def(DefKind::Macro(_mac_type), mac_id) = kid.res {
+                    let span = mac_attr.span;
+                    let def_path = cx.tcx.def_path_str(mac_id);
+                    self.imports.push((def_path, span, hir_id));
                 }
             }
+        } else {
+            if item.span.from_expansion() {
+                self.push_unique_macro_pat_ty(cx, item.span);
+            }
         }
     }
     fn check_attribute(&mut self, cx: &LateContext<'_>, attr: &ast::Attribute) {
diff --git a/clippy_lints/src/main_recursion.rs b/clippy_lints/src/main_recursion.rs
index 20333c150e3..0be0b2850c4 100644
--- a/clippy_lints/src/main_recursion.rs
+++ b/clippy_lints/src/main_recursion.rs
@@ -43,21 +43,19 @@ impl LateLintPass<'_> for MainRecursion {
             return;
         }
 
-        if_chain! {
-            if let ExprKind::Call(func, _) = &expr.kind;
-            if let ExprKind::Path(QPath::Resolved(_, path)) = &func.kind;
-            if let Some(def_id) = path.res.opt_def_id();
-            if is_entrypoint_fn(cx, def_id);
-            then {
-                span_lint_and_help(
-                    cx,
-                    MAIN_RECURSION,
-                    func.span,
-                    &format!("recursing into entrypoint `{}`", snippet(cx, func.span, "main")),
-                    None,
-                    "consider using another function for this recursion"
-                )
-            }
+        if let ExprKind::Call(func, _) = &expr.kind
+            && let ExprKind::Path(QPath::Resolved(_, path)) = &func.kind
+            && let Some(def_id) = path.res.opt_def_id()
+            && is_entrypoint_fn(cx, def_id)
+        {
+            span_lint_and_help(
+                cx,
+                MAIN_RECURSION,
+                func.span,
+                &format!("recursing into entrypoint `{}`", snippet(cx, func.span, "main")),
+                None,
+                "consider using another function for this recursion"
+            )
         }
     }
 }
diff --git a/clippy_lints/src/manual_async_fn.rs b/clippy_lints/src/manual_async_fn.rs
index 998de38a995..efa40a9929c 100644
--- a/clippy_lints/src/manual_async_fn.rs
+++ b/clippy_lints/src/manual_async_fn.rs
@@ -47,61 +47,57 @@ impl<'tcx> LateLintPass<'tcx> for ManualAsyncFn {
         span: Span,
         def_id: LocalDefId,
     ) {
-        if_chain! {
-            if let Some(header) = kind.header();
-            if !header.asyncness.is_async();
+        if let Some(header) = kind.header()
+            && !header.asyncness.is_async()
             // Check that this function returns `impl Future`
-            if let FnRetTy::Return(ret_ty) = decl.output;
-            if let Some((trait_ref, output_lifetimes)) = future_trait_ref(cx, ret_ty);
-            if let Some(output) = future_output_ty(trait_ref);
-            if captures_all_lifetimes(decl.inputs, &output_lifetimes);
+            && let FnRetTy::Return(ret_ty) = decl.output
+            && let Some((trait_ref, output_lifetimes)) = future_trait_ref(cx, ret_ty)
+            && let Some(output) = future_output_ty(trait_ref)
+            && captures_all_lifetimes(decl.inputs, &output_lifetimes)
             // Check that the body of the function consists of one async block
-            if let ExprKind::Block(block, _) = body.value.kind;
-            if block.stmts.is_empty();
-            if let Some(closure_body) = desugared_async_block(cx, block);
-            if let Node::Item(Item {vis_span, ..}) | Node::ImplItem(ImplItem {vis_span, ..}) =
-                cx.tcx.hir().get_by_def_id(def_id);
-            then {
-                let header_span = span.with_hi(ret_ty.span.hi());
-
-                span_lint_and_then(
-                    cx,
-                    MANUAL_ASYNC_FN,
-                    header_span,
-                    "this function can be simplified using the `async fn` syntax",
-                    |diag| {
-                        if_chain! {
-                            if let Some(vis_snip) = snippet_opt(cx, *vis_span);
-                            if let Some(header_snip) = snippet_opt(cx, header_span);
-                            if let Some(ret_pos) = position_before_rarrow(&header_snip);
-                            if let Some((ret_sugg, ret_snip)) = suggested_ret(cx, output);
-                            then {
-                                let header_snip = if vis_snip.is_empty() {
-                                    format!("async {}", &header_snip[..ret_pos])
-                                } else {
-                                    format!("{} async {}", vis_snip, &header_snip[vis_snip.len() + 1..ret_pos])
-                                };
-
-                                let help = format!("make the function `async` and {ret_sugg}");
-                                diag.span_suggestion(
-                                    header_span,
-                                    help,
-                                    format!("{header_snip}{ret_snip}"),
-                                    Applicability::MachineApplicable
-                                );
-
-                                let body_snip = snippet_block(cx, closure_body.value.span, "..", Some(block.span));
-                                diag.span_suggestion(
-                                    block.span,
-                                    "move the body of the async block to the enclosing function",
-                                    body_snip,
-                                    Applicability::MachineApplicable
-                                );
-                            }
-                        }
-                    },
-                );
-            }
+            && let ExprKind::Block(block, _) = body.value.kind
+            && block.stmts.is_empty()
+            && let Some(closure_body) = desugared_async_block(cx, block)
+            && let Node::Item(Item {vis_span, ..}) | Node::ImplItem(ImplItem {vis_span, ..}) =
+                cx.tcx.hir().get_by_def_id(def_id)
+        {
+            let header_span = span.with_hi(ret_ty.span.hi());
+
+            span_lint_and_then(
+                cx,
+                MANUAL_ASYNC_FN,
+                header_span,
+                "this function can be simplified using the `async fn` syntax",
+                |diag| {
+                    if let Some(vis_snip) = snippet_opt(cx, *vis_span)
+                        && let Some(header_snip) = snippet_opt(cx, header_span)
+                        && let Some(ret_pos) = position_before_rarrow(&header_snip)
+                        && let Some((ret_sugg, ret_snip)) = suggested_ret(cx, output)
+                    {
+                        let header_snip = if vis_snip.is_empty() {
+                            format!("async {}", &header_snip[..ret_pos])
+                        } else {
+                            format!("{} async {}", vis_snip, &header_snip[vis_snip.len() + 1..ret_pos])
+                        };
+
+                        let help = format!("make the function `async` and {ret_sugg}");
+                        diag.span_suggestion(
+                            header_span,
+                            help,
+                            format!("{header_snip}{ret_snip}"),
+                            Applicability::MachineApplicable
+                        );
+
+                        let body_snip = snippet_block(cx, closure_body.value.span, "..", Some(block.span));
+                        diag.span_suggestion(
+                            block.span,
+                            "move the body of the async block to the enclosing function",
+                            body_snip,
+                            Applicability::MachineApplicable
+                        );
+                    }
+                },
+            );
         }
     }
 }
@@ -110,48 +106,44 @@ fn future_trait_ref<'tcx>(
     cx: &LateContext<'tcx>,
     ty: &'tcx Ty<'tcx>,
 ) -> Option<(&'tcx TraitRef<'tcx>, Vec<LifetimeName>)> {
-    if_chain! {
-        if let TyKind::OpaqueDef(item_id, bounds, false) = ty.kind;
-        let item = cx.tcx.hir().item(item_id);
-        if let ItemKind::OpaqueTy(opaque) = &item.kind;
-        if let Some(trait_ref) = opaque.bounds.iter().find_map(|bound| {
+    if let TyKind::OpaqueDef(item_id, bounds, false) = ty.kind
+        && let item = cx.tcx.hir().item(item_id)
+        && let ItemKind::OpaqueTy(opaque) = &item.kind
+        && let Some(trait_ref) = opaque.bounds.iter().find_map(|bound| {
             if let GenericBound::Trait(poly, _) = bound {
                 Some(&poly.trait_ref)
             } else {
                 None
             }
-        });
-        if trait_ref.trait_def_id() == cx.tcx.lang_items().future_trait();
-        then {
-            let output_lifetimes = bounds
-                .iter()
-                .filter_map(|bound| {
-                    if let GenericArg::Lifetime(lt) = bound {
-                        Some(lt.res)
-                    } else {
-                        None
-                    }
-                })
-                .collect();
-
-            return Some((trait_ref, output_lifetimes));
-        }
+        })
+        && trait_ref.trait_def_id() == cx.tcx.lang_items().future_trait()
+    {
+        let output_lifetimes = bounds
+            .iter()
+            .filter_map(|bound| {
+                if let GenericArg::Lifetime(lt) = bound {
+                    Some(lt.res)
+                } else {
+                    None
+                }
+            })
+            .collect();
+
+        return Some((trait_ref, output_lifetimes));
     }
 
     None
 }
 
 fn future_output_ty<'tcx>(trait_ref: &'tcx TraitRef<'tcx>) -> Option<&'tcx Ty<'tcx>> {
-    if_chain! {
-        if let Some(segment) = trait_ref.path.segments.last();
-        if let Some(args) = segment.args;
-        if args.bindings.len() == 1;
-        let binding = &args.bindings[0];
-        if binding.ident.name == sym::Output;
-        if let TypeBindingKind::Equality { term: Term::Ty(output) } = binding.kind;
-        then {
-            return Some(output);
-        }
+    if let Some(segment) = trait_ref.path.segments.last()
+        && let Some(args) = segment.args
+        && args.bindings.len() == 1
+        && let binding = &args.bindings[0]
+        && binding.ident.name == sym::Output
+        && let TypeBindingKind::Equality { term: Term::Ty(output) } = binding.kind
+    {
+        return Some(output);
     }
 
     None
@@ -181,17 +173,15 @@ fn captures_all_lifetimes(inputs: &[Ty<'_>], output_lifetimes: &[LifetimeName])
 }
 
 fn desugared_async_block<'tcx>(cx: &LateContext<'tcx>, block: &'tcx Block<'tcx>) -> Option<&'tcx Body<'tcx>> {
-    if_chain! {
-        if let Some(block_expr) = block.expr;
-        if let Expr {
+    if let Some(block_expr) = block.expr
+        && let Expr {
             kind: ExprKind::Closure(&Closure { body, .. }),
             ..
-        } = block_expr;
-        let closure_body = cx.tcx.hir().body(body);
-        if closure_body.coroutine_kind == Some(CoroutineKind::Async(CoroutineSource::Block));
-        then {
-            return Some(closure_body);
-        }
+        } = block_expr
+        && let closure_body = cx.tcx.hir().body(body)
+        && closure_body.coroutine_kind == Some(CoroutineKind::Async(CoroutineSource::Block))
+    {
+        return Some(closure_body);
     }
 
     None
diff --git a/clippy_lints/src/manual_bits.rs b/clippy_lints/src/manual_bits.rs
index cd614c8951c..3452177c525 100644
--- a/clippy_lints/src/manual_bits.rs
+++ b/clippy_lints/src/manual_bits.rs
@@ -53,32 +53,30 @@ impl<'tcx> LateLintPass<'tcx> for ManualBits {
             return;
         }
 
-        if_chain! {
-            if let ExprKind::Binary(bin_op, left_expr, right_expr) = expr.kind;
-            if let BinOpKind::Mul = &bin_op.node;
-            if !in_external_macro(cx.sess(), expr.span);
-            let ctxt = expr.span.ctxt();
-            if left_expr.span.ctxt() == ctxt;
-            if right_expr.span.ctxt() == ctxt;
-            if let Some((real_ty, resolved_ty, other_expr)) = get_one_size_of_ty(cx, left_expr, right_expr);
-            if matches!(resolved_ty.kind(), ty::Int(_) | ty::Uint(_));
-            if let ExprKind::Lit(lit) = &other_expr.kind;
-            if let LitKind::Int(8, _) = lit.node;
-            then {
-                let mut app = Applicability::MachineApplicable;
-                let ty_snip = snippet_with_context(cx, real_ty.span, ctxt, "..", &mut app).0;
-                let sugg = create_sugg(cx, expr, format!("{ty_snip}::BITS"));
-
-                span_lint_and_sugg(
-                    cx,
-                    MANUAL_BITS,
-                    expr.span,
-                    "usage of `mem::size_of::<T>()` to obtain the size of `T` in bits",
-                    "consider using",
-                    sugg,
-                    app,
-                );
-            }
+        if let ExprKind::Binary(bin_op, left_expr, right_expr) = expr.kind
+            && let BinOpKind::Mul = &bin_op.node
+            && !in_external_macro(cx.sess(), expr.span)
+            && let ctxt = expr.span.ctxt()
+            && left_expr.span.ctxt() == ctxt
+            && right_expr.span.ctxt() == ctxt
+            && let Some((real_ty, resolved_ty, other_expr)) = get_one_size_of_ty(cx, left_expr, right_expr)
+            && matches!(resolved_ty.kind(), ty::Int(_) | ty::Uint(_))
+            && let ExprKind::Lit(lit) = &other_expr.kind
+            && let LitKind::Int(8, _) = lit.node
+        {
+            let mut app = Applicability::MachineApplicable;
+            let ty_snip = snippet_with_context(cx, real_ty.span, ctxt, "..", &mut app).0;
+            let sugg = create_sugg(cx, expr, format!("{ty_snip}::BITS"));
+
+            span_lint_and_sugg(
+                cx,
+                MANUAL_BITS,
+                expr.span,
+                "usage of `mem::size_of::<T>()` to obtain the size of `T` in bits",
+                "consider using",
+                sugg,
+                app,
+            );
         }
     }
 
@@ -98,22 +96,20 @@ fn get_one_size_of_ty<'tcx>(
 }
 
 fn get_size_of_ty<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<(&'tcx rustc_hir::Ty<'tcx>, Ty<'tcx>)> {
-    if_chain! {
-        if let ExprKind::Call(count_func, _func_args) = expr.kind;
-        if let ExprKind::Path(ref count_func_qpath) = count_func.kind;
-
-        if let QPath::Resolved(_, count_func_path) = count_func_qpath;
-        if let Some(segment_zero) = count_func_path.segments.first();
-        if let Some(args) = segment_zero.args;
-        if let Some(GenericArg::Type(real_ty)) = args.args.first();
-
-        if let Some(def_id) = cx.qpath_res(count_func_qpath, count_func.hir_id).opt_def_id();
-        if cx.tcx.is_diagnostic_item(sym::mem_size_of, def_id);
-        then {
-            cx.typeck_results().node_args(count_func.hir_id).types().next().map(|resolved_ty| (*real_ty, resolved_ty))
-        } else {
-            None
-        }
+    if let ExprKind::Call(count_func, _func_args) = expr.kind
+        && let ExprKind::Path(ref count_func_qpath) = count_func.kind
+
+        && let QPath::Resolved(_, count_func_path) = count_func_qpath
+        && let Some(segment_zero) = count_func_path.segments.first()
+        && let Some(args) = segment_zero.args
+        && let Some(GenericArg::Type(real_ty)) = args.args.first()
+
+        && let Some(def_id) = cx.qpath_res(count_func_qpath, count_func.hir_id).opt_def_id()
+        && cx.tcx.is_diagnostic_item(sym::mem_size_of, def_id)
+    {
+        cx.typeck_results().node_args(count_func.hir_id).types().next().map(|resolved_ty| (*real_ty, resolved_ty))
+    } else {
+        None
     }
 }
 
diff --git a/clippy_lints/src/manual_strip.rs b/clippy_lints/src/manual_strip.rs
index 9a9e6af5084..0559dc39363 100644
--- a/clippy_lints/src/manual_strip.rs
+++ b/clippy_lints/src/manual_strip.rs
@@ -71,55 +71,51 @@ impl<'tcx> LateLintPass<'tcx> for ManualStrip {
             return;
         }
 
-        if_chain! {
-            if let Some(higher::If { cond, then, .. }) = higher::If::hir(expr);
-            if let ExprKind::MethodCall(_, target_arg, [pattern], _) = cond.kind;
-            if let Some(method_def_id) = cx.typeck_results().type_dependent_def_id(cond.hir_id);
-            if let ExprKind::Path(target_path) = &target_arg.kind;
-            then {
-                let strip_kind = if match_def_path(cx, method_def_id, &paths::STR_STARTS_WITH) {
-                    StripKind::Prefix
-                } else if match_def_path(cx, method_def_id, &paths::STR_ENDS_WITH) {
-                    StripKind::Suffix
-                } else {
-                    return;
-                };
-                let target_res = cx.qpath_res(target_path, target_arg.hir_id);
-                if target_res == Res::Err {
-                    return;
-                };
+        if let Some(higher::If { cond, then, .. }) = higher::If::hir(expr)
+            && let ExprKind::MethodCall(_, target_arg, [pattern], _) = cond.kind
+            && let Some(method_def_id) = cx.typeck_results().type_dependent_def_id(cond.hir_id)
+            && let ExprKind::Path(target_path) = &target_arg.kind
+        {
+            let strip_kind = if match_def_path(cx, method_def_id, &paths::STR_STARTS_WITH) {
+                StripKind::Prefix
+            } else if match_def_path(cx, method_def_id, &paths::STR_ENDS_WITH) {
+                StripKind::Suffix
+            } else {
+                return;
+            };
+            let target_res = cx.qpath_res(target_path, target_arg.hir_id);
+            if target_res == Res::Err {
+                return;
+            };
+
+            if let Res::Local(hir_id) = target_res
+                && let Some(used_mutably) = mutated_variables(then, cx)
+                && used_mutably.contains(&hir_id)
+            {
+                return;
+            }
 
-                if_chain! {
-                    if let Res::Local(hir_id) = target_res;
-                    if let Some(used_mutably) = mutated_variables(then, cx);
-                    if used_mutably.contains(&hir_id);
-                    then {
-                        return;
-                    }
-                }
+            let strippings = find_stripping(cx, strip_kind, target_res, pattern, then);
+            if !strippings.is_empty() {
 
-                let strippings = find_stripping(cx, strip_kind, target_res, pattern, then);
-                if !strippings.is_empty() {
-
-                    let kind_word = match strip_kind {
-                        StripKind::Prefix => "prefix",
-                        StripKind::Suffix => "suffix",
-                    };
-
-                    let test_span = expr.span.until(then.span);
-                    span_lint_and_then(cx, MANUAL_STRIP, strippings[0], &format!("stripping a {kind_word} manually"), |diag| {
-                        diag.span_note(test_span, format!("the {kind_word} was tested here"));
-                        multispan_sugg(
-                            diag,
-                            &format!("try using the `strip_{kind_word}` method"),
-                            vec![(test_span,
-                                  format!("if let Some(<stripped>) = {}.strip_{kind_word}({}) ",
-                                          snippet(cx, target_arg.span, ".."),
-                                          snippet(cx, pattern.span, "..")))]
-                            .into_iter().chain(strippings.into_iter().map(|span| (span, "<stripped>".into()))),
-                        );
-                    });
-                }
+                let kind_word = match strip_kind {
+                    StripKind::Prefix => "prefix",
+                    StripKind::Suffix => "suffix",
+                };
+
+                let test_span = expr.span.until(then.span);
+                span_lint_and_then(cx, MANUAL_STRIP, strippings[0], &format!("stripping a {kind_word} manually"), |diag| {
+                    diag.span_note(test_span, format!("the {kind_word} was tested here"));
+                    multispan_sugg(
+                        diag,
+                        &format!("try using the `strip_{kind_word}` method"),
+                        vec![(test_span,
+                              format!("if let Some(<stripped>) = {}.strip_{kind_word}({}) ",
+                                      snippet(cx, target_arg.span, ".."),
+                                      snippet(cx, pattern.span, "..")))]
+                        .into_iter().chain(strippings.into_iter().map(|span| (span, "<stripped>".into()))),
+                    );
+                });
             }
         }
     }
@@ -129,15 +125,13 @@ impl<'tcx> LateLintPass<'tcx> for ManualStrip {
 
 // Returns `Some(arg)` if `expr` matches `arg.len()` and `None` otherwise.
 fn len_arg<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<&'tcx Expr<'tcx>> {
-    if_chain! {
-        if let ExprKind::MethodCall(_, arg, [], _) = expr.kind;
-        if let Some(method_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
-        if match_def_path(cx, method_def_id, &paths::STR_LEN);
-        then {
-            Some(arg)
-        } else {
-            None
-        }
+    if let ExprKind::MethodCall(_, arg, [], _) = expr.kind
+        && let Some(method_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id)
+        && match_def_path(cx, method_def_id, &paths::STR_LEN)
+    {
+        Some(arg)
+    } else {
+        None
     }
 }
 
@@ -201,36 +195,32 @@ fn find_stripping<'tcx>(
 
     impl<'a, 'tcx> Visitor<'tcx> for StrippingFinder<'a, 'tcx> {
         fn visit_expr(&mut self, ex: &'tcx Expr<'_>) {
-            if_chain! {
-                if is_ref_str(self.cx, ex);
-                let unref = peel_ref(ex);
-                if let ExprKind::Index(indexed, index, _) = &unref.kind;
-                if let Some(higher::Range { start, end, .. }) = higher::Range::hir(index);
-                if let ExprKind::Path(path) = &indexed.kind;
-                if self.cx.qpath_res(path, ex.hir_id) == self.target;
-                then {
-                    match (self.strip_kind, start, end) {
-                        (StripKind::Prefix, Some(start), None) => {
-                            if eq_pattern_length(self.cx, self.pattern, start) {
-                                self.results.push(ex.span);
-                                return;
-                            }
-                        },
-                        (StripKind::Suffix, None, Some(end)) => {
-                            if_chain! {
-                                if let ExprKind::Binary(Spanned { node: BinOpKind::Sub, .. }, left, right) = end.kind;
-                                if let Some(left_arg) = len_arg(self.cx, left);
-                                if let ExprKind::Path(left_path) = &left_arg.kind;
-                                if self.cx.qpath_res(left_path, left_arg.hir_id) == self.target;
-                                if eq_pattern_length(self.cx, self.pattern, right);
-                                then {
-                                    self.results.push(ex.span);
-                                    return;
-                                }
-                            }
-                        },
-                        _ => {}
-                    }
+            if is_ref_str(self.cx, ex)
+                && let unref = peel_ref(ex)
+                && let ExprKind::Index(indexed, index, _) = &unref.kind
+                && let Some(higher::Range { start, end, .. }) = higher::Range::hir(index)
+                && let ExprKind::Path(path) = &indexed.kind
+                && self.cx.qpath_res(path, ex.hir_id) == self.target
+            {
+                match (self.strip_kind, start, end) {
+                    (StripKind::Prefix, Some(start), None) => {
+                        if eq_pattern_length(self.cx, self.pattern, start) {
+                            self.results.push(ex.span);
+                            return;
+                        }
+                    },
+                    (StripKind::Suffix, None, Some(end)) => {
+                        if let ExprKind::Binary(Spanned { node: BinOpKind::Sub, .. }, left, right) = end.kind
+                            && let Some(left_arg) = len_arg(self.cx, left)
+                            && let ExprKind::Path(left_path) = &left_arg.kind
+                            && self.cx.qpath_res(left_path, left_arg.hir_id) == self.target
+                            && eq_pattern_length(self.cx, self.pattern, right)
+                        {
+                            self.results.push(ex.span);
+                            return;
+                        }
+                    },
+                    _ => {}
                 }
             }
 
diff --git a/clippy_lints/src/map_unit_fn.rs b/clippy_lints/src/map_unit_fn.rs
index 766beb980a5..03df8a67540 100644
--- a/clippy_lints/src/map_unit_fn.rs
+++ b/clippy_lints/src/map_unit_fn.rs
@@ -164,16 +164,14 @@ fn unit_closure<'tcx>(
     cx: &LateContext<'tcx>,
     expr: &hir::Expr<'_>,
 ) -> Option<(&'tcx hir::Param<'tcx>, &'tcx hir::Expr<'tcx>)> {
-    if_chain! {
-        if let hir::ExprKind::Closure(&hir::Closure { fn_decl, body, .. }) = expr.kind;
-        let body = cx.tcx.hir().body(body);
-        let body_expr = &body.value;
-        if fn_decl.inputs.len() == 1;
-        if is_unit_expression(cx, body_expr);
-        if let Some(binding) = iter_input_pats(fn_decl, body).next();
-        then {
-            return Some((binding, body_expr));
-        }
+    if let hir::ExprKind::Closure(&hir::Closure { fn_decl, body, .. }) = expr.kind
+        && let body = cx.tcx.hir().body(body)
+        && let body_expr = &body.value
+        && fn_decl.inputs.len() == 1
+        && is_unit_expression(cx, body_expr)
+        && let Some(binding) = iter_input_pats(fn_decl, body).next()
+    {
+        return Some((binding, body_expr));
     }
     None
 }
diff --git a/clippy_lints/src/match_result_ok.rs b/clippy_lints/src/match_result_ok.rs
index 841c020f2d3..750f8305730 100644
--- a/clippy_lints/src/match_result_ok.rs
+++ b/clippy_lints/src/match_result_ok.rs
@@ -56,33 +56,31 @@ impl<'tcx> LateLintPass<'tcx> for MatchResultOk {
                 return;
             };
 
-        if_chain! {
-            if let ExprKind::MethodCall(ok_path, recv, [], ..) = let_expr.kind; //check is expr.ok() has type Result<T,E>.ok(, _)
-            if let PatKind::TupleStruct(ref pat_path, [ok_pat], _)  = let_pat.kind; //get operation
-            if ok_path.ident.as_str() == "ok";
-            if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(recv), sym::Result);
-            if is_res_lang_ctor(cx, cx.qpath_res(pat_path, let_pat.hir_id), LangItem::OptionSome);
-            let ctxt = expr.span.ctxt();
-            if let_expr.span.ctxt() == ctxt;
-            if let_pat.span.ctxt() == ctxt;
-            then {
-                let mut applicability = Applicability::MachineApplicable;
-                let some_expr_string = snippet_with_context(cx, ok_pat.span, ctxt, "", &mut applicability).0;
-                let trimmed_ok = snippet_with_context(cx, recv.span, ctxt, "", &mut applicability).0;
-                let sugg = format!(
-                    "{ifwhile} let Ok({some_expr_string}) = {}",
-                    trimmed_ok.trim().trim_end_matches('.'),
-                );
-                span_lint_and_sugg(
-                    cx,
-                    MATCH_RESULT_OK,
-                    expr.span.with_hi(let_expr.span.hi()),
-                    "matching on `Some` with `ok()` is redundant",
-                    &format!("consider matching on `Ok({some_expr_string})` and removing the call to `ok` instead"),
-                    sugg,
-                    applicability,
-                );
-            }
+        if let ExprKind::MethodCall(ok_path, recv, [], ..) = let_expr.kind //check is expr.ok() has type Result<T,E>.ok(, _)
+            && let PatKind::TupleStruct(ref pat_path, [ok_pat], _)  = let_pat.kind //get operation
+            && ok_path.ident.as_str() == "ok"
+            && is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(recv), sym::Result)
+            && is_res_lang_ctor(cx, cx.qpath_res(pat_path, let_pat.hir_id), LangItem::OptionSome)
+            && let ctxt = expr.span.ctxt()
+            && let_expr.span.ctxt() == ctxt
+            && let_pat.span.ctxt() == ctxt
+        {
+            let mut applicability = Applicability::MachineApplicable;
+            let some_expr_string = snippet_with_context(cx, ok_pat.span, ctxt, "", &mut applicability).0;
+            let trimmed_ok = snippet_with_context(cx, recv.span, ctxt, "", &mut applicability).0;
+            let sugg = format!(
+                "{ifwhile} let Ok({some_expr_string}) = {}",
+                trimmed_ok.trim().trim_end_matches('.'),
+            );
+            span_lint_and_sugg(
+                cx,
+                MATCH_RESULT_OK,
+                expr.span.with_hi(let_expr.span.hi()),
+                "matching on `Some` with `ok()` is redundant",
+                &format!("consider matching on `Ok({some_expr_string})` and removing the call to `ok` instead"),
+                sugg,
+                applicability,
+            );
         }
     }
 }
diff --git a/clippy_lints/src/matches/collapsible_match.rs b/clippy_lints/src/matches/collapsible_match.rs
index 29b935fb61a..f9dc8440aca 100644
--- a/clippy_lints/src/matches/collapsible_match.rs
+++ b/clippy_lints/src/matches/collapsible_match.rs
@@ -40,76 +40,72 @@ fn check_arm<'tcx>(
     outer_else_body: Option<&'tcx Expr<'tcx>>,
 ) {
     let inner_expr = peel_blocks_with_stmt(outer_then_body);
-    if_chain! {
-        if let Some(inner) = IfLetOrMatch::parse(cx, inner_expr);
-        if let Some((inner_scrutinee, inner_then_pat, inner_else_body)) = match inner {
+    if let Some(inner) = IfLetOrMatch::parse(cx, inner_expr)
+        && let Some((inner_scrutinee, inner_then_pat, inner_else_body)) = match inner {
             IfLetOrMatch::IfLet(scrutinee, pat, _, els) => Some((scrutinee, pat, els)),
-            IfLetOrMatch::Match(scrutinee, arms, ..) => if_chain! {
+            IfLetOrMatch::Match(scrutinee, arms, ..) => if arms.len() == 2 && arms.iter().all(|a| a.guard.is_none())
                 // if there are more than two arms, collapsing would be non-trivial
-                if arms.len() == 2 && arms.iter().all(|a| a.guard.is_none());
                 // one of the arms must be "wild-like"
-                if let Some(wild_idx) = arms.iter().rposition(|a| arm_is_wild_like(cx, a));
-                then {
-                    let (then, els) = (&arms[1 - wild_idx], &arms[wild_idx]);
-                    Some((scrutinee, then.pat, Some(els.body)))
-                } else {
-                    None
-                }
+                && let Some(wild_idx) = arms.iter().rposition(|a| arm_is_wild_like(cx, a))
+            {
+                let (then, els) = (&arms[1 - wild_idx], &arms[wild_idx]);
+                Some((scrutinee, then.pat, Some(els.body)))
+            } else {
+                None
             },
-        };
-        if outer_pat.span.eq_ctxt(inner_scrutinee.span);
+        }
+        && outer_pat.span.eq_ctxt(inner_scrutinee.span)
         // match expression must be a local binding
         // match <local> { .. }
-        if let Some(binding_id) = path_to_local(peel_ref_operators(cx, inner_scrutinee));
-        if !pat_contains_or(inner_then_pat);
+        && let Some(binding_id) = path_to_local(peel_ref_operators(cx, inner_scrutinee))
+        && !pat_contains_or(inner_then_pat)
         // the binding must come from the pattern of the containing match arm
         // ..<local>.. => match <local> { .. }
-        if let (Some(binding_span), is_innermost_parent_pat_struct)
-            = find_pat_binding_and_is_innermost_parent_pat_struct(outer_pat, binding_id);
+        && let (Some(binding_span), is_innermost_parent_pat_struct)
+            = find_pat_binding_and_is_innermost_parent_pat_struct(outer_pat, binding_id)
         // the "else" branches must be equal
-        if match (outer_else_body, inner_else_body) {
+        && match (outer_else_body, inner_else_body) {
             (None, None) => true,
             (None, Some(e)) | (Some(e), None) => is_unit_expr(e),
             (Some(a), Some(b)) => SpanlessEq::new(cx).eq_expr(a, b),
-        };
+        }
         // the binding must not be used in the if guard
-        if outer_guard.map_or(
+        && outer_guard.map_or(
             true,
             |(Guard::If(e) | Guard::IfLet(Let { init: e, .. }))| !is_local_used(cx, *e, binding_id)
-        );
+        )
         // ...or anywhere in the inner expression
-        if match inner {
+        && match inner {
             IfLetOrMatch::IfLet(_, _, body, els) => {
                 !is_local_used(cx, body, binding_id) && els.map_or(true, |e| !is_local_used(cx, e, binding_id))
             },
             IfLetOrMatch::Match(_, arms, ..) => !arms.iter().any(|arm| is_local_used(cx, arm, binding_id)),
-        };
-        then {
-            let msg = format!(
-                "this `{}` can be collapsed into the outer `{}`",
-                if matches!(inner, IfLetOrMatch::Match(..)) { "match" } else { "if let" },
-                if outer_is_match { "match" } else { "if let" },
-            );
-            // collapsing patterns need an explicit field name in struct pattern matching
-            // ex: Struct {x: Some(1)}
-            let replace_msg = if is_innermost_parent_pat_struct {
-                format!(", prefixed by {}:", snippet(cx, binding_span, "their field name"))
-            } else {
-                String::new()
-            };
-            span_lint_and_then(
-                cx,
-                COLLAPSIBLE_MATCH,
-                inner_expr.span,
-                &msg,
-                |diag| {
-                    let mut help_span = MultiSpan::from_spans(vec![binding_span, inner_then_pat.span]);
-                    help_span.push_span_label(binding_span, "replace this binding");
-                    help_span.push_span_label(inner_then_pat.span, format!("with this pattern{replace_msg}"));
-                    diag.span_help(help_span, "the outer pattern can be modified to include the inner pattern");
-                },
-            );
         }
+    {
+        let msg = format!(
+            "this `{}` can be collapsed into the outer `{}`",
+            if matches!(inner, IfLetOrMatch::Match(..)) { "match" } else { "if let" },
+            if outer_is_match { "match" } else { "if let" },
+        );
+        // collapsing patterns need an explicit field name in struct pattern matching
+        // ex: Struct {x: Some(1)}
+        let replace_msg = if is_innermost_parent_pat_struct {
+            format!(", prefixed by {}:", snippet(cx, binding_span, "their field name"))
+        } else {
+            String::new()
+        };
+        span_lint_and_then(
+            cx,
+            COLLAPSIBLE_MATCH,
+            inner_expr.span,
+            &msg,
+            |diag| {
+                let mut help_span = MultiSpan::from_spans(vec![binding_span, inner_then_pat.span]);
+                help_span.push_span_label(binding_span, "replace this binding");
+                help_span.push_span_label(inner_then_pat.span, format!("with this pattern{replace_msg}"));
+                diag.span_help(help_span, "the outer pattern can be modified to include the inner pattern");
+            },
+        );
     }
 }
 
diff --git a/clippy_lints/src/matches/infallible_destructuring_match.rs b/clippy_lints/src/matches/infallible_destructuring_match.rs
index 3329f93b73c..313a9cba327 100644
--- a/clippy_lints/src/matches/infallible_destructuring_match.rs
+++ b/clippy_lints/src/matches/infallible_destructuring_match.rs
@@ -8,38 +8,36 @@ use rustc_lint::LateContext;
 use super::INFALLIBLE_DESTRUCTURING_MATCH;
 
 pub(crate) fn check(cx: &LateContext<'_>, local: &Local<'_>) -> bool {
-    if_chain! {
-        if !local.span.from_expansion();
-        if let Some(expr) = local.init;
-        if let ExprKind::Match(target, arms, MatchSource::Normal) = expr.kind;
-        if arms.len() == 1 && arms[0].guard.is_none();
-        if let PatKind::TupleStruct(
-            QPath::Resolved(None, variant_name), args, _) = arms[0].pat.kind;
-        if args.len() == 1;
-        if let PatKind::Binding(binding, arg, ..) = strip_pat_refs(&args[0]).kind;
-        let body = peel_blocks(arms[0].body);
-        if path_to_local_id(body, arg);
+    if !local.span.from_expansion()
+        && let Some(expr) = local.init
+        && let ExprKind::Match(target, arms, MatchSource::Normal) = expr.kind
+        && arms.len() == 1 && arms[0].guard.is_none()
+        && let PatKind::TupleStruct(
+            QPath::Resolved(None, variant_name), args, _) = arms[0].pat.kind
+        && args.len() == 1
+        && let PatKind::Binding(binding, arg, ..) = strip_pat_refs(&args[0]).kind
+        && let body = peel_blocks(arms[0].body)
+        && path_to_local_id(body, arg)
 
-        then {
-            let mut applicability = Applicability::MachineApplicable;
-            span_lint_and_sugg(
-                cx,
-                INFALLIBLE_DESTRUCTURING_MATCH,
-                local.span,
-                "you seem to be trying to use `match` to destructure a single infallible pattern. \
-                Consider using `let`",
-                "try",
-                format!(
-                    "let {}({}{}) = {};",
-                    snippet_with_applicability(cx, variant_name.span, "..", &mut applicability),
-                    if binding.0 == ByRef::Yes { "ref " } else { "" },
-                    snippet_with_applicability(cx, local.pat.span, "..", &mut applicability),
-                    snippet_with_applicability(cx, target.span, "..", &mut applicability),
-                ),
-                applicability,
-            );
-            return true;
-        }
+    {
+        let mut applicability = Applicability::MachineApplicable;
+        span_lint_and_sugg(
+            cx,
+            INFALLIBLE_DESTRUCTURING_MATCH,
+            local.span,
+            "you seem to be trying to use `match` to destructure a single infallible pattern. \
+            Consider using `let`",
+            "try",
+            format!(
+                "let {}({}{}) = {};",
+                snippet_with_applicability(cx, variant_name.span, "..", &mut applicability),
+                if binding.0 == ByRef::Yes { "ref " } else { "" },
+                snippet_with_applicability(cx, local.pat.span, "..", &mut applicability),
+                snippet_with_applicability(cx, target.span, "..", &mut applicability),
+            ),
+            applicability,
+        );
+        return true;
     }
     false
 }
diff --git a/clippy_lints/src/matches/manual_filter.rs b/clippy_lints/src/matches/manual_filter.rs
index cdb51c33aaf..bd8a9d10e8a 100644
--- a/clippy_lints/src/matches/manual_filter.rs
+++ b/clippy_lints/src/matches/manual_filter.rs
@@ -21,20 +21,18 @@ fn get_cond_expr<'tcx>(
     expr: &'tcx Expr<'_>,
     ctxt: SyntaxContext,
 ) -> Option<SomeExpr<'tcx>> {
-    if_chain! {
-        if let Some(block_expr) = peels_blocks_incl_unsafe_opt(expr);
-        if let ExprKind::If(cond, then_expr, Some(else_expr)) = block_expr.kind;
-        if let PatKind::Binding(_,target, ..) = pat.kind;
-        if is_some_expr(cx, target, ctxt, then_expr) && is_none_expr(cx, else_expr)
-            || is_none_expr(cx, then_expr) && is_some_expr(cx, target, ctxt, else_expr); // check that one expr resolves to `Some(x)`, the other to `None`
-        then {
-            return Some(SomeExpr {
-                    expr: peels_blocks_incl_unsafe(cond.peel_drop_temps()),
-                    needs_unsafe_block: contains_unsafe_block(cx, expr),
-                    needs_negated: is_none_expr(cx, then_expr) // if the `then_expr` resolves to `None`, need to negate the cond
-                })
-            }
-    };
+    if let Some(block_expr) = peels_blocks_incl_unsafe_opt(expr)
+        && let ExprKind::If(cond, then_expr, Some(else_expr)) = block_expr.kind
+        && let PatKind::Binding(_,target, ..) = pat.kind
+        && (is_some_expr(cx, target, ctxt, then_expr) && is_none_expr(cx, else_expr)
+            || is_none_expr(cx, then_expr) && is_some_expr(cx, target, ctxt, else_expr)) // check that one expr resolves to `Some(x)`, the other to `None`
+    {
+        return Some(SomeExpr {
+                expr: peels_blocks_incl_unsafe(cond.peel_drop_temps()),
+                needs_unsafe_block: contains_unsafe_block(cx, expr),
+                needs_negated: is_none_expr(cx, then_expr) // if the `then_expr` resolves to `None`, need to negate the cond
+            })
+        };
     None
 }
 
diff --git a/clippy_lints/src/matches/manual_unwrap_or.rs b/clippy_lints/src/matches/manual_unwrap_or.rs
index b94501bf0ad..723528bbe2e 100644
--- a/clippy_lints/src/matches/manual_unwrap_or.rs
+++ b/clippy_lints/src/matches/manual_unwrap_or.rs
@@ -16,43 +16,40 @@ use super::MANUAL_UNWRAP_OR;
 
 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>, scrutinee: &'tcx Expr<'_>, arms: &'tcx [Arm<'_>]) {
     let ty = cx.typeck_results().expr_ty(scrutinee);
-    if_chain! {
-        if let Some(ty_name) = if is_type_diagnostic_item(cx, ty, sym::Option) {
+    if let Some(ty_name) = if is_type_diagnostic_item(cx, ty, sym::Option) {
             Some("Option")
         } else if is_type_diagnostic_item(cx, ty, sym::Result) {
             Some("Result")
         } else {
             None
-        };
-        if let Some(or_arm) = applicable_or_arm(cx, arms);
-        if let Some(or_body_snippet) = snippet_opt(cx, or_arm.body.span);
-        if let Some(indent) = indent_of(cx, expr.span);
-        if constant_simple(cx, cx.typeck_results(), or_arm.body).is_some();
-        then {
-            let reindented_or_body =
-                reindent_multiline(or_body_snippet.into(), true, Some(indent));
-
-            let mut app = Applicability::MachineApplicable;
-            let suggestion = sugg::Sugg::hir_with_context(cx, scrutinee, expr.span.ctxt(), "..", &mut app).maybe_par();
-            span_lint_and_sugg(
-                cx,
-                MANUAL_UNWRAP_OR, expr.span,
-                &format!("this pattern reimplements `{ty_name}::unwrap_or`"),
-                "replace with",
-                format!(
-                    "{suggestion}.unwrap_or({reindented_or_body})",
-                ),
-                app,
-            );
         }
+        && let Some(or_arm) = applicable_or_arm(cx, arms)
+        && let Some(or_body_snippet) = snippet_opt(cx, or_arm.body.span)
+        && let Some(indent) = indent_of(cx, expr.span)
+        && constant_simple(cx, cx.typeck_results(), or_arm.body).is_some()
+    {
+        let reindented_or_body =
+            reindent_multiline(or_body_snippet.into(), true, Some(indent));
+
+        let mut app = Applicability::MachineApplicable;
+        let suggestion = sugg::Sugg::hir_with_context(cx, scrutinee, expr.span.ctxt(), "..", &mut app).maybe_par();
+        span_lint_and_sugg(
+            cx,
+            MANUAL_UNWRAP_OR, expr.span,
+            &format!("this pattern reimplements `{ty_name}::unwrap_or`"),
+            "replace with",
+            format!(
+                "{suggestion}.unwrap_or({reindented_or_body})",
+            ),
+            app,
+        );
     }
 }
 
 fn applicable_or_arm<'a>(cx: &LateContext<'_>, arms: &'a [Arm<'a>]) -> Option<&'a Arm<'a>> {
-    if_chain! {
-        if arms.len() == 2;
-        if arms.iter().all(|arm| arm.guard.is_none());
-        if let Some((idx, or_arm)) = arms.iter().enumerate().find(|(_, arm)| {
+    if arms.len() == 2
+        && arms.iter().all(|arm| arm.guard.is_none())
+        && let Some((idx, or_arm)) = arms.iter().enumerate().find(|(_, arm)| {
             match arm.pat.kind {
                 PatKind::Path(ref qpath) => is_res_lang_ctor(cx, cx.qpath_res(qpath, arm.pat.hir_id), OptionNone),
                 PatKind::TupleStruct(ref qpath, [pat], _) =>
@@ -60,21 +57,20 @@ fn applicable_or_arm<'a>(cx: &LateContext<'_>, arms: &'a [Arm<'a>]) -> Option<&'
                         && is_res_lang_ctor(cx, cx.qpath_res(qpath, arm.pat.hir_id), ResultErr),
                 _ => false,
             }
-        });
-        let unwrap_arm = &arms[1 - idx];
-        if let PatKind::TupleStruct(ref qpath, [unwrap_pat], _) = unwrap_arm.pat.kind;
-        if let Res::Def(DefKind::Ctor(..), ctor_id) = cx.qpath_res(qpath, unwrap_arm.pat.hir_id);
-        if let Some(variant_id) = cx.tcx.opt_parent(ctor_id);
-        if cx.tcx.lang_items().option_some_variant() == Some(variant_id)
-            || cx.tcx.lang_items().result_ok_variant() == Some(variant_id);
-        if let PatKind::Binding(_, binding_hir_id, ..) = unwrap_pat.kind;
-        if path_to_local_id(unwrap_arm.body, binding_hir_id);
-        if cx.typeck_results().expr_adjustments(unwrap_arm.body).is_empty();
-        if !contains_return_break_continue_macro(or_arm.body);
-        then {
-            Some(or_arm)
-        } else {
-            None
-        }
+        })
+        && let unwrap_arm = &arms[1 - idx]
+        && let PatKind::TupleStruct(ref qpath, [unwrap_pat], _) = unwrap_arm.pat.kind
+        && let Res::Def(DefKind::Ctor(..), ctor_id) = cx.qpath_res(qpath, unwrap_arm.pat.hir_id)
+        && let Some(variant_id) = cx.tcx.opt_parent(ctor_id)
+        && (cx.tcx.lang_items().option_some_variant() == Some(variant_id)
+            || cx.tcx.lang_items().result_ok_variant() == Some(variant_id))
+        && let PatKind::Binding(_, binding_hir_id, ..) = unwrap_pat.kind
+        && path_to_local_id(unwrap_arm.body, binding_hir_id)
+        && cx.typeck_results().expr_adjustments(unwrap_arm.body).is_empty()
+        && !contains_return_break_continue_macro(or_arm.body)
+    {
+        Some(or_arm)
+    } else {
+        None
     }
 }
diff --git a/clippy_lints/src/matches/manual_utils.rs b/clippy_lints/src/matches/manual_utils.rs
index 781ee138c76..0627e458dfe 100644
--- a/clippy_lints/src/matches/manual_utils.rs
+++ b/clippy_lints/src/matches/manual_utils.rs
@@ -127,32 +127,30 @@ where
 
     let closure_expr_snip = some_expr.to_snippet_with_context(cx, expr_ctxt, &mut app);
     let body_str = if let PatKind::Binding(annotation, id, some_binding, None) = some_pat.kind {
-        if_chain! {
-            if !some_expr.needs_unsafe_block;
-            if let Some(func) = can_pass_as_func(cx, id, some_expr.expr);
-            if func.span.eq_ctxt(some_expr.expr.span);
-            then {
-                snippet_with_applicability(cx, func.span, "..", &mut app).into_owned()
-            } else {
-                if path_to_local_id(some_expr.expr, id)
-                    && !is_lint_allowed(cx, MATCH_AS_REF, expr.hir_id)
-                    && binding_ref.is_some()
-                {
-                    return None;
-                }
+        if !some_expr.needs_unsafe_block
+            && let Some(func) = can_pass_as_func(cx, id, some_expr.expr)
+            && func.span.eq_ctxt(some_expr.expr.span)
+        {
+            snippet_with_applicability(cx, func.span, "..", &mut app).into_owned()
+        } else {
+            if path_to_local_id(some_expr.expr, id)
+                && !is_lint_allowed(cx, MATCH_AS_REF, expr.hir_id)
+                && binding_ref.is_some()
+            {
+                return None;
+            }
 
-                // `ref` and `ref mut` annotations were handled earlier.
-                let annotation = if matches!(annotation, BindingAnnotation::MUT) {
-                    "mut "
-                } else {
-                    ""
-                };
+            // `ref` and `ref mut` annotations were handled earlier.
+            let annotation = if matches!(annotation, BindingAnnotation::MUT) {
+                "mut "
+            } else {
+                ""
+            };
 
-                if some_expr.needs_unsafe_block {
-                    format!("|{annotation}{some_binding}| unsafe {{ {closure_expr_snip} }}")
-                } else {
-                    format!("|{annotation}{some_binding}| {closure_expr_snip}")
-                }
+            if some_expr.needs_unsafe_block {
+                format!("|{annotation}{some_binding}| unsafe {{ {closure_expr_snip} }}")
+            } else {
+                format!("|{annotation}{some_binding}| {closure_expr_snip}")
             }
         }
     } else if !is_wild_none && explicit_ref.is_none() {
diff --git a/clippy_lints/src/matches/match_as_ref.rs b/clippy_lints/src/matches/match_as_ref.rs
index d51cca040a2..812a0aab94f 100644
--- a/clippy_lints/src/matches/match_as_ref.rs
+++ b/clippy_lints/src/matches/match_as_ref.rs
@@ -26,18 +26,16 @@ pub(crate) fn check(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>], expr:
             let output_ty = cx.typeck_results().expr_ty(expr);
             let input_ty = cx.typeck_results().expr_ty(ex);
 
-            let cast = if_chain! {
-                if let ty::Adt(_, args) = input_ty.kind();
-                let input_ty = args.type_at(0);
-                if let ty::Adt(_, args) = output_ty.kind();
-                let output_ty = args.type_at(0);
-                if let ty::Ref(_, output_ty, _) = *output_ty.kind();
-                if input_ty != output_ty;
-                then {
-                    ".map(|x| x as _)"
-                } else {
-                    ""
-                }
+            let cast = if let ty::Adt(_, args) = input_ty.kind()
+                && let input_ty = args.type_at(0)
+                && let ty::Adt(_, args) = output_ty.kind()
+                && let output_ty = args.type_at(0)
+                && let ty::Ref(_, output_ty, _) = *output_ty.kind()
+                && input_ty != output_ty
+            {
+                ".map(|x| x as _)"
+            } else {
+                ""
             };
 
             let mut applicability = Applicability::MachineApplicable;
@@ -67,17 +65,15 @@ fn is_none_arm(cx: &LateContext<'_>, arm: &Arm<'_>) -> bool {
 
 // Checks if arm has the form `Some(ref v) => Some(v)` (checks for `ref` and `ref mut`)
 fn is_ref_some_arm(cx: &LateContext<'_>, arm: &Arm<'_>) -> Option<Mutability> {
-    if_chain! {
-        if let PatKind::TupleStruct(ref qpath, [first_pat, ..], _) = arm.pat.kind;
-        if is_res_lang_ctor(cx, cx.qpath_res(qpath, arm.pat.hir_id), LangItem::OptionSome);
-        if let PatKind::Binding(BindingAnnotation(ByRef::Yes, mutabl), .., ident, _) = first_pat.kind;
-        if let ExprKind::Call(e, [arg]) = peel_blocks(arm.body).kind;
-        if is_res_lang_ctor(cx, path_res(cx, e), LangItem::OptionSome);
-        if let ExprKind::Path(QPath::Resolved(_, path2)) = arg.kind;
-        if path2.segments.len() == 1 && ident.name == path2.segments[0].ident.name;
-        then {
-            return Some(mutabl)
-        }
+    if let PatKind::TupleStruct(ref qpath, [first_pat, ..], _) = arm.pat.kind
+        && is_res_lang_ctor(cx, cx.qpath_res(qpath, arm.pat.hir_id), LangItem::OptionSome)
+        && let PatKind::Binding(BindingAnnotation(ByRef::Yes, mutabl), .., ident, _) = first_pat.kind
+        && let ExprKind::Call(e, [arg]) = peel_blocks(arm.body).kind
+        && is_res_lang_ctor(cx, path_res(cx, e), LangItem::OptionSome)
+        && let ExprKind::Path(QPath::Resolved(_, path2)) = arg.kind
+        && path2.segments.len() == 1 && ident.name == path2.segments[0].ident.name
+    {
+        return Some(mutabl)
     }
     None
 }
diff --git a/clippy_lints/src/matches/match_like_matches.rs b/clippy_lints/src/matches/match_like_matches.rs
index e2ddf11abe2..f100cb97a19 100644
--- a/clippy_lints/src/matches/match_like_matches.rs
+++ b/clippy_lints/src/matches/match_like_matches.rs
@@ -76,79 +76,77 @@ where
             ),
         >,
 {
-    if_chain! {
-        if !span_contains_comment(cx.sess().source_map(), expr.span);
-        if iter.len() >= 2;
-        if cx.typeck_results().expr_ty(expr).is_bool();
-        if let Some((_, last_pat_opt, last_expr, _)) = iter.next_back();
-        let iter_without_last = iter.clone();
-        if let Some((first_attrs, _, first_expr, first_guard)) = iter.next();
-        if let Some(b0) = find_bool_lit(&first_expr.kind);
-        if let Some(b1) = find_bool_lit(&last_expr.kind);
-        if b0 != b1;
-        if first_guard.is_none() || iter.len() == 0;
-        if first_attrs.is_empty();
-        if iter
+    if !span_contains_comment(cx.sess().source_map(), expr.span)
+        && iter.len() >= 2
+        && cx.typeck_results().expr_ty(expr).is_bool()
+        && let Some((_, last_pat_opt, last_expr, _)) = iter.next_back()
+        && let iter_without_last = iter.clone()
+        && let Some((first_attrs, _, first_expr, first_guard)) = iter.next()
+        && let Some(b0) = find_bool_lit(&first_expr.kind)
+        && let Some(b1) = find_bool_lit(&last_expr.kind)
+        && b0 != b1
+        && (first_guard.is_none() || iter.len() == 0)
+        && first_attrs.is_empty()
+        && iter
             .all(|arm| {
                 find_bool_lit(&arm.2.kind).map_or(false, |b| b == b0) && arm.3.is_none() && arm.0.is_empty()
-            });
-        then {
-            if let Some(last_pat) = last_pat_opt {
-                if !is_wild(last_pat) {
-                    return false;
-                }
+            })
+    {
+        if let Some(last_pat) = last_pat_opt {
+            if !is_wild(last_pat) {
+                return false;
             }
+        }
 
-            for arm in iter_without_last.clone() {
-                if let Some(pat) = arm.1 {
-                    if !is_lint_allowed(cx, REDUNDANT_PATTERN_MATCHING, pat.hir_id) && is_some(pat.kind) {
-                        return false;
-                    }
+        for arm in iter_without_last.clone() {
+            if let Some(pat) = arm.1 {
+                if !is_lint_allowed(cx, REDUNDANT_PATTERN_MATCHING, pat.hir_id) && is_some(pat.kind) {
+                    return false;
                 }
             }
+        }
 
-            // The suggestion may be incorrect, because some arms can have `cfg` attributes
-            // evaluated into `false` and so such arms will be stripped before.
-            let mut applicability = Applicability::MaybeIncorrect;
-            let pat = {
-                use itertools::Itertools as _;
-                iter_without_last
-                    .filter_map(|arm| {
-                        let pat_span = arm.1?.span;
-                        Some(snippet_with_applicability(cx, pat_span, "..", &mut applicability))
-                    })
-                    .join(" | ")
-            };
-            let pat_and_guard = if let Some(Guard::If(g)) = first_guard {
-                format!("{pat} if {}", snippet_with_applicability(cx, g.span, "..", &mut applicability))
-            } else {
-                pat
-            };
-
-            // strip potential borrows (#6503), but only if the type is a reference
-            let mut ex_new = ex;
-            if let ExprKind::AddrOf(BorrowKind::Ref, .., ex_inner) = ex.kind {
-                if let ty::Ref(..) = cx.typeck_results().expr_ty(ex_inner).kind() {
-                    ex_new = ex_inner;
-                }
-            };
-            span_lint_and_sugg(
-                cx,
-                MATCH_LIKE_MATCHES_MACRO,
-                expr.span,
-                &format!("{} expression looks like `matches!` macro", if is_if_let { "if let .. else" } else { "match" }),
-                "try",
-                format!(
-                    "{}matches!({}, {pat_and_guard})",
-                    if b0 { "" } else { "!" },
-                    snippet_with_applicability(cx, ex_new.span, "..", &mut applicability),
-                ),
-                applicability,
-            );
-            true
+        // The suggestion may be incorrect, because some arms can have `cfg` attributes
+        // evaluated into `false` and so such arms will be stripped before.
+        let mut applicability = Applicability::MaybeIncorrect;
+        let pat = {
+            use itertools::Itertools as _;
+            iter_without_last
+                .filter_map(|arm| {
+                    let pat_span = arm.1?.span;
+                    Some(snippet_with_applicability(cx, pat_span, "..", &mut applicability))
+                })
+                .join(" | ")
+        };
+        let pat_and_guard = if let Some(Guard::If(g)) = first_guard {
+            format!("{pat} if {}", snippet_with_applicability(cx, g.span, "..", &mut applicability))
         } else {
-            false
-        }
+            pat
+        };
+
+        // strip potential borrows (#6503), but only if the type is a reference
+        let mut ex_new = ex;
+        if let ExprKind::AddrOf(BorrowKind::Ref, .., ex_inner) = ex.kind {
+            if let ty::Ref(..) = cx.typeck_results().expr_ty(ex_inner).kind() {
+                ex_new = ex_inner;
+            }
+        };
+        span_lint_and_sugg(
+            cx,
+            MATCH_LIKE_MATCHES_MACRO,
+            expr.span,
+            &format!("{} expression looks like `matches!` macro", if is_if_let { "if let .. else" } else { "match" }),
+            "try",
+            format!(
+                "{}matches!({}, {pat_and_guard})",
+                if b0 { "" } else { "!" },
+                snippet_with_applicability(cx, ex_new.span, "..", &mut applicability),
+            ),
+            applicability,
+        );
+        true
+    } else {
+        false
     }
 }
 
diff --git a/clippy_lints/src/matches/match_on_vec_items.rs b/clippy_lints/src/matches/match_on_vec_items.rs
index bd53ebd48c8..d15ecce34f1 100644
--- a/clippy_lints/src/matches/match_on_vec_items.rs
+++ b/clippy_lints/src/matches/match_on_vec_items.rs
@@ -10,39 +10,35 @@ use rustc_span::sym;
 use super::MATCH_ON_VEC_ITEMS;
 
 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, scrutinee: &'tcx Expr<'_>) {
-    if_chain! {
-        if let Some(idx_expr) = is_vec_indexing(cx, scrutinee);
-        if let ExprKind::Index(vec, idx, _) = idx_expr.kind;
-
-        then {
-            // FIXME: could be improved to suggest surrounding every pattern with Some(_),
-            // but only when `or_patterns` are stabilized.
-            span_lint_and_sugg(
-                cx,
-                MATCH_ON_VEC_ITEMS,
-                scrutinee.span,
-                "indexing into a vector may panic",
-                "try",
-                format!(
-                    "{}.get({})",
-                    snippet(cx, vec.span, ".."),
-                    snippet(cx, idx.span, "..")
-                ),
-                Applicability::MaybeIncorrect
-            );
-        }
+    if let Some(idx_expr) = is_vec_indexing(cx, scrutinee)
+        && let ExprKind::Index(vec, idx, _) = idx_expr.kind
+
+    {
+        // FIXME: could be improved to suggest surrounding every pattern with Some(_),
+        // but only when `or_patterns` are stabilized.
+        span_lint_and_sugg(
+            cx,
+            MATCH_ON_VEC_ITEMS,
+            scrutinee.span,
+            "indexing into a vector may panic",
+            "try",
+            format!(
+                "{}.get({})",
+                snippet(cx, vec.span, ".."),
+                snippet(cx, idx.span, "..")
+            ),
+            Applicability::MaybeIncorrect
+        );
     }
 }
 
 fn is_vec_indexing<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> Option<&'tcx Expr<'tcx>> {
-    if_chain! {
-        if let ExprKind::Index(array, index, _) = expr.kind;
-        if is_vector(cx, array);
-        if !is_full_range(cx, index);
-
-        then {
-            return Some(expr);
-        }
+    if let ExprKind::Index(array, index, _) = expr.kind
+        && is_vector(cx, array)
+        && !is_full_range(cx, index)
+
+    {
+        return Some(expr);
     }
 
     None
diff --git a/clippy_lints/src/matches/match_same_arms.rs b/clippy_lints/src/matches/match_same_arms.rs
index 6fc79faddbe..745be671b86 100644
--- a/clippy_lints/src/matches/match_same_arms.rs
+++ b/clippy_lints/src/matches/match_same_arms.rs
@@ -66,25 +66,23 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>]) {
 
         let mut local_map: HirIdMap<HirId> = HirIdMap::default();
         let eq_fallback = |a: &Expr<'_>, b: &Expr<'_>| {
-            if_chain! {
-                if let Some(a_id) = path_to_local(a);
-                if let Some(b_id) = path_to_local(b);
-                let entry = match local_map.entry(a_id) {
+            if let Some(a_id) = path_to_local(a)
+                && let Some(b_id) = path_to_local(b)
+                && let entry = match local_map.entry(a_id) {
                     HirIdMapEntry::Vacant(entry) => entry,
                     // check if using the same bindings as before
                     HirIdMapEntry::Occupied(entry) => return *entry.get() == b_id,
-                };
-                // the names technically don't have to match; this makes the lint more conservative
-                if cx.tcx.hir().name(a_id) == cx.tcx.hir().name(b_id);
-                if cx.typeck_results().expr_ty(a) == cx.typeck_results().expr_ty(b);
-                if pat_contains_local(lhs.pat, a_id);
-                if pat_contains_local(rhs.pat, b_id);
-                then {
-                    entry.insert(b_id);
-                    true
-                } else {
-                    false
                 }
+                // the names technically don't have to match; this makes the lint more conservative
+                && cx.tcx.hir().name(a_id) == cx.tcx.hir().name(b_id)
+                && cx.typeck_results().expr_ty(a) == cx.typeck_results().expr_ty(b)
+                && pat_contains_local(lhs.pat, a_id)
+                && pat_contains_local(rhs.pat, b_id)
+            {
+                entry.insert(b_id);
+                true
+            } else {
+                false
             }
         };
         // Arms with a guard are ignored, those can’t always be merged together
diff --git a/clippy_lints/src/matches/match_str_case_mismatch.rs b/clippy_lints/src/matches/match_str_case_mismatch.rs
index 675a85ae555..3d920e9537f 100644
--- a/clippy_lints/src/matches/match_str_case_mismatch.rs
+++ b/clippy_lints/src/matches/match_str_case_mismatch.rs
@@ -20,21 +20,19 @@ enum CaseMethod {
 }
 
 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, scrutinee: &'tcx Expr<'_>, arms: &'tcx [Arm<'_>]) {
-    if_chain! {
-        if let ty::Ref(_, ty, _) = cx.typeck_results().expr_ty(scrutinee).kind();
-        if let ty::Str = ty.kind();
-        then {
-            let mut visitor = MatchExprVisitor {
-                cx,
-                case_method: None,
-            };
-
-            visitor.visit_expr(scrutinee);
-
-            if let Some(case_method) = visitor.case_method {
-                if let Some((bad_case_span, bad_case_sym)) = verify_case(&case_method, arms) {
-                    lint(cx, &case_method, bad_case_span, bad_case_sym.as_str());
-                }
+    if let ty::Ref(_, ty, _) = cx.typeck_results().expr_ty(scrutinee).kind()
+        && let ty::Str = ty.kind()
+    {
+        let mut visitor = MatchExprVisitor {
+            cx,
+            case_method: None,
+        };
+
+        visitor.visit_expr(scrutinee);
+
+        if let Some(case_method) = visitor.case_method {
+            if let Some((bad_case_span, bad_case_sym)) = verify_case(&case_method, arms) {
+                lint(cx, &case_method, bad_case_span, bad_case_sym.as_str());
             }
         }
     }
@@ -88,17 +86,15 @@ fn verify_case<'a>(case_method: &'a CaseMethod, arms: &'a [Arm<'_>]) -> Option<(
     };
 
     for arm in arms {
-        if_chain! {
-            if let PatKind::Lit(Expr {
+        if let PatKind::Lit(Expr {
                                 kind: ExprKind::Lit(lit),
                                 ..
-                            }) = arm.pat.kind;
-            if let LitKind::Str(symbol, _) = lit.node;
-            let input = symbol.as_str();
-            if !case_check(input);
-            then {
-                return Some((lit.span, symbol));
-            }
+                            }) = arm.pat.kind
+            && let LitKind::Str(symbol, _) = lit.node
+            && let input = symbol.as_str()
+            && !case_check(input)
+        {
+            return Some((lit.span, symbol));
         }
     }
 
diff --git a/clippy_lints/src/matches/match_wild_err_arm.rs b/clippy_lints/src/matches/match_wild_err_arm.rs
index a2903e52ae0..f2fa404db5a 100644
--- a/clippy_lints/src/matches/match_wild_err_arm.rs
+++ b/clippy_lints/src/matches/match_wild_err_arm.rs
@@ -34,20 +34,18 @@ pub(crate) fn check<'tcx>(cx: &LateContext<'tcx>, ex: &Expr<'tcx>, arms: &[Arm<'
                             }
                         }
                     }
-                    if_chain! {
-                        if matching_wild;
-                        if let Some(macro_call) = root_macro_call(peel_blocks_with_stmt(arm.body).span);
-                        if is_panic(cx, macro_call.def_id);
-                        then {
-                            // `Err(_)` or `Err(_e)` arm with `panic!` found
-                            span_lint_and_note(cx,
-                                MATCH_WILD_ERR_ARM,
-                                arm.pat.span,
-                                &format!("`Err({ident_bind_name})` matches all errors"),
-                                None,
-                                "match each error separately or use the error output, or use `.expect(msg)` if the error case is unreachable",
-                            );
-                        }
+                    if matching_wild
+                        && let Some(macro_call) = root_macro_call(peel_blocks_with_stmt(arm.body).span)
+                        && is_panic(cx, macro_call.def_id)
+                    {
+                        // `Err(_)` or `Err(_e)` arm with `panic!` found
+                        span_lint_and_note(cx,
+                            MATCH_WILD_ERR_ARM,
+                            arm.pat.span,
+                            &format!("`Err({ident_bind_name})` matches all errors"),
+                            None,
+                            "match each error separately or use the error output, or use `.expect(msg)` if the error case is unreachable",
+                        );
                     }
                 }
             }
diff --git a/clippy_lints/src/matches/redundant_pattern_match.rs b/clippy_lints/src/matches/redundant_pattern_match.rs
index 9a7c00823b6..9ce9c2e8381 100644
--- a/clippy_lints/src/matches/redundant_pattern_match.rs
+++ b/clippy_lints/src/matches/redundant_pattern_match.rs
@@ -35,15 +35,13 @@ pub(super) fn check_if_let<'tcx>(
 
 // Extract the generic arguments out of a type
 fn try_get_generic_ty(ty: Ty<'_>, index: usize) -> Option<Ty<'_>> {
-    if_chain! {
-        if let ty::Adt(_, subs) = ty.kind();
-        if let Some(sub) = subs.get(index);
-        if let GenericArgKind::Type(sub_ty) = sub.unpack();
-        then {
-            Some(sub_ty)
-        } else {
-            None
-        }
+    if let ty::Adt(_, subs) = ty.kind()
+        && let Some(sub) = subs.get(index)
+        && let GenericArgKind::Type(sub_ty) = sub.unpack()
+    {
+        Some(sub_ty)
+    } else {
+        None
     }
 }
 
@@ -142,14 +140,12 @@ fn find_sugg_for_if_let<'tcx>(
     let needs_drop = needs_ordered_drop(cx, check_ty) || any_temporaries_need_ordered_drop(cx, let_expr);
 
     // check that `while_let_on_iterator` lint does not trigger
-    if_chain! {
-        if keyword == "while";
-        if let ExprKind::MethodCall(method_path, ..) = let_expr.kind;
-        if method_path.ident.name == sym::next;
-        if is_trait_method(cx, let_expr, sym::Iterator);
-        then {
-            return;
-        }
+    if keyword == "while"
+        && let ExprKind::MethodCall(method_path, ..) = let_expr.kind
+        && method_path.ident.name == sym::next
+        && is_trait_method(cx, let_expr, sym::Iterator)
+    {
+        return;
     }
 
     let result_expr = match &let_expr.kind {
diff --git a/clippy_lints/src/matches/rest_pat_in_fully_bound_struct.rs b/clippy_lints/src/matches/rest_pat_in_fully_bound_struct.rs
index 4efe93d4b54..2e19bbe42e4 100644
--- a/clippy_lints/src/matches/rest_pat_in_fully_bound_struct.rs
+++ b/clippy_lints/src/matches/rest_pat_in_fully_bound_struct.rs
@@ -6,25 +6,23 @@ use rustc_middle::ty;
 use super::REST_PAT_IN_FULLY_BOUND_STRUCTS;
 
 pub(crate) fn check(cx: &LateContext<'_>, pat: &Pat<'_>) {
-    if_chain! {
-        if !pat.span.from_expansion();
-        if let PatKind::Struct(QPath::Resolved(_, path), fields, true) = pat.kind;
-        if let Some(def_id) = path.res.opt_def_id();
-        let ty = cx.tcx.type_of(def_id).instantiate_identity();
-        if let ty::Adt(def, _) = ty.kind();
-        if def.is_struct() || def.is_union();
-        if fields.len() == def.non_enum_variant().fields.len();
-        if !def.non_enum_variant().is_field_list_non_exhaustive();
+    if !pat.span.from_expansion()
+        && let PatKind::Struct(QPath::Resolved(_, path), fields, true) = pat.kind
+        && let Some(def_id) = path.res.opt_def_id()
+        && let ty = cx.tcx.type_of(def_id).instantiate_identity()
+        && let ty::Adt(def, _) = ty.kind()
+        && (def.is_struct() || def.is_union())
+        && fields.len() == def.non_enum_variant().fields.len()
+        && !def.non_enum_variant().is_field_list_non_exhaustive()
 
-        then {
-            span_lint_and_help(
-                cx,
-                REST_PAT_IN_FULLY_BOUND_STRUCTS,
-                pat.span,
-                "unnecessary use of `..` pattern in struct binding. All fields were already bound",
-                None,
-                "consider removing `..` from this binding",
-            );
-        }
+    {
+        span_lint_and_help(
+            cx,
+            REST_PAT_IN_FULLY_BOUND_STRUCTS,
+            pat.span,
+            "unnecessary use of `..` pattern in struct binding. All fields were already bound",
+            None,
+            "consider removing `..` from this binding",
+        );
     }
 }
diff --git a/clippy_lints/src/matches/single_match.rs b/clippy_lints/src/matches/single_match.rs
index 48efd023017..bbf59643aad 100644
--- a/clippy_lints/src/matches/single_match.rs
+++ b/clippy_lints/src/matches/single_match.rs
@@ -89,50 +89,48 @@ fn report_single_pattern(
     });
 
     let (pat, pat_ref_count) = peel_hir_pat_refs(arms[0].pat);
-    let (msg, sugg) = if_chain! {
-        if let PatKind::Path(_) | PatKind::Lit(_) = pat.kind;
-        let (ty, ty_ref_count) = peel_mid_ty_refs(cx.typeck_results().expr_ty(ex));
-        if let Some(spe_trait_id) = cx.tcx.lang_items().structural_peq_trait();
-        if let Some(pe_trait_id) = cx.tcx.lang_items().eq_trait();
-        if ty.is_integral() || ty.is_char() || ty.is_str()
+    let (msg, sugg) = if let PatKind::Path(_) | PatKind::Lit(_) = pat.kind
+        && let (ty, ty_ref_count) = peel_mid_ty_refs(cx.typeck_results().expr_ty(ex))
+        && let Some(spe_trait_id) = cx.tcx.lang_items().structural_peq_trait()
+        && let Some(pe_trait_id) = cx.tcx.lang_items().eq_trait()
+        && (ty.is_integral() || ty.is_char() || ty.is_str()
             || (implements_trait(cx, ty, spe_trait_id, &[])
-                && implements_trait(cx, ty, pe_trait_id, &[ty.into()]));
-        then {
-            // scrutinee derives PartialEq and the pattern is a constant.
-            let pat_ref_count = match pat.kind {
-                // string literals are already a reference.
-                PatKind::Lit(Expr { kind: ExprKind::Lit(lit), .. }) if lit.node.is_str() => pat_ref_count + 1,
-                _ => pat_ref_count,
-            };
-            // References are only implicitly added to the pattern, so no overflow here.
-            // e.g. will work: match &Some(_) { Some(_) => () }
-            // will not: match Some(_) { &Some(_) => () }
-            let ref_count_diff = ty_ref_count - pat_ref_count;
-
-            // Try to remove address of expressions first.
-            let (ex, removed) = peel_n_hir_expr_refs(ex, ref_count_diff);
-            let ref_count_diff = ref_count_diff - removed;
-
-            let msg = "you seem to be trying to use `match` for an equality check. Consider using `if`";
-            let sugg = format!(
-                "if {} == {}{} {}{els_str}",
-                snippet(cx, ex.span, ".."),
-                // PartialEq for different reference counts may not exist.
-                "&".repeat(ref_count_diff),
-                snippet(cx, arms[0].pat.span, ".."),
-                expr_block(cx, arms[0].body, ctxt, "..", Some(expr.span), &mut app),
-            );
-            (msg, sugg)
-        } else {
-            let msg = "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`";
-            let sugg = format!(
-                "if let {} = {} {}{els_str}",
-                snippet(cx, arms[0].pat.span, ".."),
-                snippet(cx, ex.span, ".."),
-                expr_block(cx, arms[0].body, ctxt, "..", Some(expr.span), &mut app),
-            );
-            (msg, sugg)
-        }
+                && implements_trait(cx, ty, pe_trait_id, &[ty.into()])))
+    {
+        // scrutinee derives PartialEq and the pattern is a constant.
+        let pat_ref_count = match pat.kind {
+            // string literals are already a reference.
+            PatKind::Lit(Expr { kind: ExprKind::Lit(lit), .. }) if lit.node.is_str() => pat_ref_count + 1,
+            _ => pat_ref_count,
+        };
+        // References are only implicitly added to the pattern, so no overflow here.
+        // e.g. will work: match &Some(_) { Some(_) => () }
+        // will not: match Some(_) { &Some(_) => () }
+        let ref_count_diff = ty_ref_count - pat_ref_count;
+
+        // Try to remove address of expressions first.
+        let (ex, removed) = peel_n_hir_expr_refs(ex, ref_count_diff);
+        let ref_count_diff = ref_count_diff - removed;
+
+        let msg = "you seem to be trying to use `match` for an equality check. Consider using `if`";
+        let sugg = format!(
+            "if {} == {}{} {}{els_str}",
+            snippet(cx, ex.span, ".."),
+            // PartialEq for different reference counts may not exist.
+            "&".repeat(ref_count_diff),
+            snippet(cx, arms[0].pat.span, ".."),
+            expr_block(cx, arms[0].body, ctxt, "..", Some(expr.span), &mut app),
+        );
+        (msg, sugg)
+    } else {
+        let msg = "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`";
+        let sugg = format!(
+            "if let {} = {} {}{els_str}",
+            snippet(cx, arms[0].pat.span, ".."),
+            snippet(cx, ex.span, ".."),
+            expr_block(cx, arms[0].body, ctxt, "..", Some(expr.span), &mut app),
+        );
+        (msg, sugg)
     };
 
     span_lint_and_sugg(cx, lint, expr.span, msg, "try", sugg, app);
diff --git a/clippy_lints/src/matches/try_err.rs b/clippy_lints/src/matches/try_err.rs
index 0fd6f533db0..7e573aafef9 100644
--- a/clippy_lints/src/matches/try_err.rs
+++ b/clippy_lints/src/matches/try_err.rs
@@ -22,59 +22,57 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, scrutine
     //         #[allow(unreachable_code)]
     //         val,
     // };
-    if_chain! {
-        if let ExprKind::Call(match_fun, [try_arg, ..]) = scrutinee.kind;
-        if let ExprKind::Path(ref match_fun_path) = match_fun.kind;
-        if matches!(match_fun_path, QPath::LangItem(LangItem::TryTraitBranch, ..));
-        if let ExprKind::Call(err_fun, [err_arg, ..]) = try_arg.kind;
-        if is_res_lang_ctor(cx, path_res(cx, err_fun), ResultErr);
-        if let Some(return_ty) = find_return_type(cx, &expr.kind);
-        then {
-            let prefix;
-            let suffix;
-            let err_ty;
+    if let ExprKind::Call(match_fun, [try_arg, ..]) = scrutinee.kind
+        && let ExprKind::Path(ref match_fun_path) = match_fun.kind
+        && matches!(match_fun_path, QPath::LangItem(LangItem::TryTraitBranch, ..))
+        && let ExprKind::Call(err_fun, [err_arg, ..]) = try_arg.kind
+        && is_res_lang_ctor(cx, path_res(cx, err_fun), ResultErr)
+        && let Some(return_ty) = find_return_type(cx, &expr.kind)
+    {
+        let prefix;
+        let suffix;
+        let err_ty;
 
-            if let Some(ty) = result_error_type(cx, return_ty) {
-                prefix = "Err(";
-                suffix = ")";
-                err_ty = ty;
-            } else if let Some(ty) = poll_result_error_type(cx, return_ty) {
-                prefix = "Poll::Ready(Err(";
-                suffix = "))";
-                err_ty = ty;
-            } else if let Some(ty) = poll_option_result_error_type(cx, return_ty) {
-                prefix = "Poll::Ready(Some(Err(";
-                suffix = ")))";
-                err_ty = ty;
-            } else {
-                return;
-            };
+        if let Some(ty) = result_error_type(cx, return_ty) {
+            prefix = "Err(";
+            suffix = ")";
+            err_ty = ty;
+        } else if let Some(ty) = poll_result_error_type(cx, return_ty) {
+            prefix = "Poll::Ready(Err(";
+            suffix = "))";
+            err_ty = ty;
+        } else if let Some(ty) = poll_option_result_error_type(cx, return_ty) {
+            prefix = "Poll::Ready(Some(Err(";
+            suffix = ")))";
+            err_ty = ty;
+        } else {
+            return;
+        };
 
-            let expr_err_ty = cx.typeck_results().expr_ty(err_arg);
-            let span = hygiene::walk_chain(err_arg.span, try_arg.span.ctxt());
-            let mut applicability = Applicability::MachineApplicable;
-            let origin_snippet = snippet_with_applicability(cx, span, "_", &mut applicability);
-            let ret_prefix = if get_parent_expr(cx, expr).map_or(false, |e| matches!(e.kind, ExprKind::Ret(_))) {
-                "" // already returns
-            } else {
-                "return "
-            };
-            let suggestion = if err_ty == expr_err_ty {
-                format!("{ret_prefix}{prefix}{origin_snippet}{suffix}")
-            } else {
-                format!("{ret_prefix}{prefix}{origin_snippet}.into(){suffix}")
-            };
+        let expr_err_ty = cx.typeck_results().expr_ty(err_arg);
+        let span = hygiene::walk_chain(err_arg.span, try_arg.span.ctxt());
+        let mut applicability = Applicability::MachineApplicable;
+        let origin_snippet = snippet_with_applicability(cx, span, "_", &mut applicability);
+        let ret_prefix = if get_parent_expr(cx, expr).map_or(false, |e| matches!(e.kind, ExprKind::Ret(_))) {
+            "" // already returns
+        } else {
+            "return "
+        };
+        let suggestion = if err_ty == expr_err_ty {
+            format!("{ret_prefix}{prefix}{origin_snippet}{suffix}")
+        } else {
+            format!("{ret_prefix}{prefix}{origin_snippet}.into(){suffix}")
+        };
 
-            span_lint_and_sugg(
-                cx,
-                TRY_ERR,
-                expr.span,
-                "returning an `Err(_)` with the `?` operator",
-                "try",
-                suggestion,
-                applicability,
-            );
-        }
+        span_lint_and_sugg(
+            cx,
+            TRY_ERR,
+            expr.span,
+            "returning an `Err(_)` with the `?` operator",
+            "try",
+            suggestion,
+            applicability,
+        );
     }
 }
 
@@ -92,51 +90,45 @@ fn find_return_type<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx ExprKind<'_>) -> O
 
 /// Extracts the error type from Result<T, E>.
 fn result_error_type<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Option<Ty<'tcx>> {
-    if_chain! {
-        if let ty::Adt(_, subst) = ty.kind();
-        if is_type_diagnostic_item(cx, ty, sym::Result);
-        then {
-            Some(subst.type_at(1))
-        } else {
-            None
-        }
+    if let ty::Adt(_, subst) = ty.kind()
+        && is_type_diagnostic_item(cx, ty, sym::Result)
+    {
+        Some(subst.type_at(1))
+    } else {
+        None
     }
 }
 
 /// Extracts the error type from Poll<Result<T, E>>.
 fn poll_result_error_type<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Option<Ty<'tcx>> {
-    if_chain! {
-        if let ty::Adt(def, subst) = ty.kind();
-        if cx.tcx.lang_items().get(LangItem::Poll) == Some(def.did());
-        let ready_ty = subst.type_at(0);
+    if let ty::Adt(def, subst) = ty.kind()
+        && cx.tcx.lang_items().get(LangItem::Poll) == Some(def.did())
+        && let ready_ty = subst.type_at(0)
 
-        if let ty::Adt(ready_def, ready_subst) = ready_ty.kind();
-        if cx.tcx.is_diagnostic_item(sym::Result, ready_def.did());
-        then {
-            Some(ready_subst.type_at(1))
-        } else {
-            None
-        }
+        && let ty::Adt(ready_def, ready_subst) = ready_ty.kind()
+        && cx.tcx.is_diagnostic_item(sym::Result, ready_def.did())
+    {
+        Some(ready_subst.type_at(1))
+    } else {
+        None
     }
 }
 
 /// Extracts the error type from Poll<Option<Result<T, E>>>.
 fn poll_option_result_error_type<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Option<Ty<'tcx>> {
-    if_chain! {
-        if let ty::Adt(def, subst) = ty.kind();
-        if cx.tcx.lang_items().get(LangItem::Poll) == Some(def.did());
-        let ready_ty = subst.type_at(0);
+    if let ty::Adt(def, subst) = ty.kind()
+        && cx.tcx.lang_items().get(LangItem::Poll) == Some(def.did())
+        && let ready_ty = subst.type_at(0)
 
-        if let ty::Adt(ready_def, ready_subst) = ready_ty.kind();
-        if cx.tcx.is_diagnostic_item(sym::Option, ready_def.did());
-        let some_ty = ready_subst.type_at(0);
+        && let ty::Adt(ready_def, ready_subst) = ready_ty.kind()
+        && cx.tcx.is_diagnostic_item(sym::Option, ready_def.did())
+        && let some_ty = ready_subst.type_at(0)
 
-        if let ty::Adt(some_def, some_subst) = some_ty.kind();
-        if cx.tcx.is_diagnostic_item(sym::Result, some_def.did());
-        then {
-            Some(some_subst.type_at(1))
-        } else {
-            None
-        }
+        && let ty::Adt(some_def, some_subst) = some_ty.kind()
+        && cx.tcx.is_diagnostic_item(sym::Result, some_def.did())
+    {
+        Some(some_subst.type_at(1))
+    } else {
+        None
     }
 }
diff --git a/clippy_lints/src/mem_replace.rs b/clippy_lints/src/mem_replace.rs
index c6a1b45a9fa..0377af3f5db 100644
--- a/clippy_lints/src/mem_replace.rs
+++ b/clippy_lints/src/mem_replace.rs
@@ -125,17 +125,37 @@ fn check_replace_option_with_none(cx: &LateContext<'_>, dest: &Expr<'_>, expr_sp
 }
 
 fn check_replace_with_uninit(cx: &LateContext<'_>, src: &Expr<'_>, dest: &Expr<'_>, expr_span: Span) {
-    if_chain! {
+    if let Some(method_def_id) = cx.typeck_results().type_dependent_def_id(src.hir_id)
         // check if replacement is mem::MaybeUninit::uninit().assume_init()
-        if let Some(method_def_id) = cx.typeck_results().type_dependent_def_id(src.hir_id);
-        if cx.tcx.is_diagnostic_item(sym::assume_init, method_def_id);
-        then {
+        && cx.tcx.is_diagnostic_item(sym::assume_init, method_def_id)
+    {
+        let mut applicability = Applicability::MachineApplicable;
+        span_lint_and_sugg(
+            cx,
+            MEM_REPLACE_WITH_UNINIT,
+            expr_span,
+            "replacing with `mem::MaybeUninit::uninit().assume_init()`",
+            "consider using",
+            format!(
+                "std::ptr::read({})",
+                snippet_with_applicability(cx, dest.span, "", &mut applicability)
+            ),
+            applicability,
+        );
+        return;
+    }
+
+    if let ExprKind::Call(repl_func, []) = src.kind
+        && let ExprKind::Path(ref repl_func_qpath) = repl_func.kind
+        && let Some(repl_def_id) = cx.qpath_res(repl_func_qpath, repl_func.hir_id).opt_def_id()
+    {
+        if cx.tcx.is_diagnostic_item(sym::mem_uninitialized, repl_def_id) {
             let mut applicability = Applicability::MachineApplicable;
             span_lint_and_sugg(
                 cx,
                 MEM_REPLACE_WITH_UNINIT,
                 expr_span,
-                "replacing with `mem::MaybeUninit::uninit().assume_init()`",
+                "replacing with `mem::uninitialized()`",
                 "consider using",
                 format!(
                     "std::ptr::read({})",
@@ -143,40 +163,16 @@ fn check_replace_with_uninit(cx: &LateContext<'_>, src: &Expr<'_>, dest: &Expr<'
                 ),
                 applicability,
             );
-            return;
-        }
-    }
-
-    if_chain! {
-        if let ExprKind::Call(repl_func, []) = src.kind;
-        if let ExprKind::Path(ref repl_func_qpath) = repl_func.kind;
-        if let Some(repl_def_id) = cx.qpath_res(repl_func_qpath, repl_func.hir_id).opt_def_id();
-        then {
-            if cx.tcx.is_diagnostic_item(sym::mem_uninitialized, repl_def_id) {
-                let mut applicability = Applicability::MachineApplicable;
-                span_lint_and_sugg(
-                    cx,
-                    MEM_REPLACE_WITH_UNINIT,
-                    expr_span,
-                    "replacing with `mem::uninitialized()`",
-                    "consider using",
-                    format!(
-                        "std::ptr::read({})",
-                        snippet_with_applicability(cx, dest.span, "", &mut applicability)
-                    ),
-                    applicability,
-                );
-            } else if cx.tcx.is_diagnostic_item(sym::mem_zeroed, repl_def_id) &&
-                    !cx.typeck_results().expr_ty(src).is_primitive() {
-                span_lint_and_help(
-                    cx,
-                    MEM_REPLACE_WITH_UNINIT,
-                    expr_span,
-                    "replacing with `mem::zeroed()`",
-                    None,
-                    "consider using a default value or the `take_mut` crate instead",
-                );
-            }
+        } else if cx.tcx.is_diagnostic_item(sym::mem_zeroed, repl_def_id) &&
+                !cx.typeck_results().expr_ty(src).is_primitive() {
+            span_lint_and_help(
+                cx,
+                MEM_REPLACE_WITH_UNINIT,
+                expr_span,
+                "replacing with `mem::zeroed()`",
+                None,
+                "consider using a default value or the `take_mut` crate instead",
+            );
         }
     }
 }
@@ -222,21 +218,19 @@ impl MemReplace {
 
 impl<'tcx> LateLintPass<'tcx> for MemReplace {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if_chain! {
+        if let ExprKind::Call(func, [dest, src]) = expr.kind
             // Check that `expr` is a call to `mem::replace()`
-            if let ExprKind::Call(func, [dest, src]) = expr.kind;
-            if let ExprKind::Path(ref func_qpath) = func.kind;
-            if let Some(def_id) = cx.qpath_res(func_qpath, func.hir_id).opt_def_id();
-            if cx.tcx.is_diagnostic_item(sym::mem_replace, def_id);
-            then {
-                // Check that second argument is `Option::None`
-                if is_res_lang_ctor(cx, path_res(cx, src), OptionNone) {
-                    check_replace_option_with_none(cx, dest, expr.span);
-                } else if self.msrv.meets(msrvs::MEM_TAKE) {
-                    check_replace_with_default(cx, src, dest, expr.span);
-                }
-                check_replace_with_uninit(cx, src, dest, expr.span);
+            && let ExprKind::Path(ref func_qpath) = func.kind
+            && let Some(def_id) = cx.qpath_res(func_qpath, func.hir_id).opt_def_id()
+            && cx.tcx.is_diagnostic_item(sym::mem_replace, def_id)
+        {
+            // Check that second argument is `Option::None`
+            if is_res_lang_ctor(cx, path_res(cx, src), OptionNone) {
+                check_replace_option_with_none(cx, dest, expr.span);
+            } else if self.msrv.meets(msrvs::MEM_TAKE) {
+                check_replace_with_default(cx, src, dest, expr.span);
             }
+            check_replace_with_uninit(cx, src, dest, expr.span);
         }
     }
     extract_msrv_attr!(LateContext);
diff --git a/clippy_lints/src/methods/bind_instead_of_map.rs b/clippy_lints/src/methods/bind_instead_of_map.rs
index 3a8cc41748e..4e6a8c58bef 100644
--- a/clippy_lints/src/methods/bind_instead_of_map.rs
+++ b/clippy_lints/src/methods/bind_instead_of_map.rs
@@ -70,58 +70,52 @@ pub(crate) trait BindInsteadOfMap {
         closure_expr: &hir::Expr<'_>,
         closure_args_span: Span,
     ) -> bool {
-        if_chain! {
-            if let hir::ExprKind::Call(some_expr, [inner_expr]) = closure_expr.kind;
-            if let hir::ExprKind::Path(QPath::Resolved(_, path)) = some_expr.kind;
-            if Self::is_variant(cx, path.res);
-            if !contains_return(inner_expr);
-            if let Some(msg) = Self::lint_msg(cx);
-            then {
-                let mut app = Applicability::MachineApplicable;
-                let some_inner_snip = snippet_with_context(cx, inner_expr.span, closure_expr.span.ctxt(), "_", &mut app).0;
-
-                let closure_args_snip = snippet(cx, closure_args_span, "..");
-                let option_snip = snippet(cx, recv.span, "..");
-                let note = format!("{option_snip}.{}({closure_args_snip} {some_inner_snip})", Self::GOOD_METHOD_NAME);
-                span_lint_and_sugg(
-                    cx,
-                    BIND_INSTEAD_OF_MAP,
-                    expr.span,
-                    &msg,
-                    "try",
-                    note,
-                    app,
-                );
-                true
-            } else {
-                false
-            }
+        if let hir::ExprKind::Call(some_expr, [inner_expr]) = closure_expr.kind
+            && let hir::ExprKind::Path(QPath::Resolved(_, path)) = some_expr.kind
+            && Self::is_variant(cx, path.res)
+            && !contains_return(inner_expr)
+            && let Some(msg) = Self::lint_msg(cx)
+        {
+            let mut app = Applicability::MachineApplicable;
+            let some_inner_snip = snippet_with_context(cx, inner_expr.span, closure_expr.span.ctxt(), "_", &mut app).0;
+
+            let closure_args_snip = snippet(cx, closure_args_span, "..");
+            let option_snip = snippet(cx, recv.span, "..");
+            let note = format!("{option_snip}.{}({closure_args_snip} {some_inner_snip})", Self::GOOD_METHOD_NAME);
+            span_lint_and_sugg(
+                cx,
+                BIND_INSTEAD_OF_MAP,
+                expr.span,
+                &msg,
+                "try",
+                note,
+                app,
+            );
+            true
+        } else {
+            false
         }
     }
 
     fn lint_closure(cx: &LateContext<'_>, expr: &hir::Expr<'_>, closure_expr: &hir::Expr<'_>) -> bool {
         let mut suggs = Vec::new();
         let can_sugg: bool = find_all_ret_expressions(cx, closure_expr, |ret_expr| {
-            if_chain! {
-                if !ret_expr.span.from_expansion();
-                if let hir::ExprKind::Call(func_path, [arg]) = ret_expr.kind;
-                if let hir::ExprKind::Path(QPath::Resolved(_, path)) = func_path.kind;
-                if Self::is_variant(cx, path.res);
-                if !contains_return(arg);
-                then {
-                    suggs.push((ret_expr.span, arg.span.source_callsite()));
-                    true
-                } else {
-                    false
-                }
+            if !ret_expr.span.from_expansion()
+                && let hir::ExprKind::Call(func_path, [arg]) = ret_expr.kind
+                && let hir::ExprKind::Path(QPath::Resolved(_, path)) = func_path.kind
+                && Self::is_variant(cx, path.res)
+                && !contains_return(arg)
+            {
+                suggs.push((ret_expr.span, arg.span.source_callsite()));
+                true
+            } else {
+                false
             }
         });
-        let (span, msg) = if_chain! {
-            if can_sugg;
-            if let hir::ExprKind::MethodCall(segment, ..) = expr.kind;
-            if let Some(msg) = Self::lint_msg(cx);
-            then { (segment.ident.span, msg) } else { return false; }
-        };
+        let (span, msg) = if can_sugg
+            && let hir::ExprKind::MethodCall(segment, ..) = expr.kind
+            && let Some(msg) = Self::lint_msg(cx)
+        { (segment.ident.span, msg) } else { return false; };
         span_lint_and_then(cx, BIND_INSTEAD_OF_MAP, expr.span, &msg, |diag| {
             multispan_sugg_with_applicability(
                 diag,
@@ -139,12 +133,10 @@ pub(crate) trait BindInsteadOfMap {
 
     /// Lint use of `_.and_then(|x| Some(y))` for `Option`s
     fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr<'_>, arg: &hir::Expr<'_>) -> bool {
-        if_chain! {
-            if let Some(adt) = cx.typeck_results().expr_ty(recv).ty_adt_def();
-            if let Some(vid) = cx.tcx.lang_items().get(Self::VARIANT_LANG_ITEM);
-            if adt.did() == cx.tcx.parent(vid);
-            then {} else { return false; }
-        }
+        if let Some(adt) = cx.typeck_results().expr_ty(recv).ty_adt_def()
+            && let Some(vid) = cx.tcx.lang_items().get(Self::VARIANT_LANG_ITEM)
+            && adt.did() == cx.tcx.parent(vid)
+        {} else { return false; }
 
         match arg.kind {
             hir::ExprKind::Closure(&hir::Closure { body, fn_decl_span, .. }) => {
diff --git a/clippy_lints/src/methods/bytecount.rs b/clippy_lints/src/methods/bytecount.rs
index 35370355f83..039b92da1e1 100644
--- a/clippy_lints/src/methods/bytecount.rs
+++ b/clippy_lints/src/methods/bytecount.rs
@@ -18,53 +18,51 @@ pub(super) fn check<'tcx>(
     filter_recv: &'tcx Expr<'_>,
     filter_arg: &'tcx Expr<'_>,
 ) {
-    if_chain! {
-        if let ExprKind::Closure(&Closure { body, .. }) = filter_arg.kind;
-        let body = cx.tcx.hir().body(body);
-        if let [param] = body.params;
-        if let PatKind::Binding(_, arg_id, _, _) = strip_pat_refs(param.pat).kind;
-        if let ExprKind::Binary(ref op, l, r) = body.value.kind;
-        if op.node == BinOpKind::Eq;
-        if is_type_diagnostic_item(cx,
+    if let ExprKind::Closure(&Closure { body, .. }) = filter_arg.kind
+        && let body = cx.tcx.hir().body(body)
+        && let [param] = body.params
+        && let PatKind::Binding(_, arg_id, _, _) = strip_pat_refs(param.pat).kind
+        && let ExprKind::Binary(ref op, l, r) = body.value.kind
+        && op.node == BinOpKind::Eq
+        && is_type_diagnostic_item(cx,
                     cx.typeck_results().expr_ty(filter_recv).peel_refs(),
-                    sym::SliceIter);
-        let operand_is_arg = |expr| {
+                    sym::SliceIter)
+        && let operand_is_arg = (|expr| {
             let expr = peel_ref_operators(cx, peel_blocks(expr));
             path_to_local_id(expr, arg_id)
-        };
-        let needle = if operand_is_arg(l) {
+        })
+        && let needle = if operand_is_arg(l) {
             r
         } else if operand_is_arg(r) {
             l
         } else {
             return;
-        };
-        if ty::Uint(UintTy::U8) == *cx.typeck_results().expr_ty(needle).peel_refs().kind();
-        if !is_local_used(cx, needle, arg_id);
-        then {
-            let haystack = if let ExprKind::MethodCall(path, receiver, [], _) =
-                    filter_recv.kind {
-                let p = path.ident.name;
-                if p == sym::iter || p == sym::iter_mut {
-                    receiver
-                } else {
-                    filter_recv
-                }
+        }
+        && ty::Uint(UintTy::U8) == *cx.typeck_results().expr_ty(needle).peel_refs().kind()
+        && !is_local_used(cx, needle, arg_id)
+    {
+        let haystack = if let ExprKind::MethodCall(path, receiver, [], _) =
+                filter_recv.kind {
+            let p = path.ident.name;
+            if p == sym::iter || p == sym::iter_mut {
+                receiver
             } else {
                 filter_recv
-            };
-            let mut applicability = Applicability::MaybeIncorrect;
-            span_lint_and_sugg(
-                cx,
-                NAIVE_BYTECOUNT,
-                expr.span,
-                "you appear to be counting bytes the naive way",
-                "consider using the bytecount crate",
-                format!("bytecount::count({}, {})",
-                        snippet_with_applicability(cx, haystack.span, "..", &mut applicability),
-                        snippet_with_applicability(cx, needle.span, "..", &mut applicability)),
-                applicability,
-            );
-        }
+            }
+        } else {
+            filter_recv
+        };
+        let mut applicability = Applicability::MaybeIncorrect;
+        span_lint_and_sugg(
+            cx,
+            NAIVE_BYTECOUNT,
+            expr.span,
+            "you appear to be counting bytes the naive way",
+            "consider using the bytecount crate",
+            format!("bytecount::count({}, {})",
+                    snippet_with_applicability(cx, haystack.span, "..", &mut applicability),
+                    snippet_with_applicability(cx, needle.span, "..", &mut applicability)),
+            applicability,
+        );
     };
 }
diff --git a/clippy_lints/src/methods/bytes_count_to_len.rs b/clippy_lints/src/methods/bytes_count_to_len.rs
index 649fc46e4ad..eebd8428cff 100644
--- a/clippy_lints/src/methods/bytes_count_to_len.rs
+++ b/clippy_lints/src/methods/bytes_count_to_len.rs
@@ -14,23 +14,21 @@ pub(super) fn check<'tcx>(
     count_recv: &'tcx hir::Expr<'_>,
     bytes_recv: &'tcx hir::Expr<'_>,
 ) {
-    if_chain! {
-        if let Some(bytes_id) = cx.typeck_results().type_dependent_def_id(count_recv.hir_id);
-        if let Some(impl_id) = cx.tcx.impl_of_method(bytes_id);
-        if cx.tcx.type_of(impl_id).instantiate_identity().is_str();
-        let ty = cx.typeck_results().expr_ty(bytes_recv).peel_refs();
-        if ty.is_str() || is_type_lang_item(cx, ty, hir::LangItem::String);
-        then {
-            let mut applicability = Applicability::MachineApplicable;
-            span_lint_and_sugg(
-                cx,
-                BYTES_COUNT_TO_LEN,
-                expr.span,
-                "using long and hard to read `.bytes().count()`",
-                "consider calling `.len()` instead",
-                format!("{}.len()", snippet_with_applicability(cx, bytes_recv.span, "..", &mut applicability)),
-                applicability
-            );
-        }
+    if let Some(bytes_id) = cx.typeck_results().type_dependent_def_id(count_recv.hir_id)
+        && let Some(impl_id) = cx.tcx.impl_of_method(bytes_id)
+        && cx.tcx.type_of(impl_id).instantiate_identity().is_str()
+        && let ty = cx.typeck_results().expr_ty(bytes_recv).peel_refs()
+        && (ty.is_str() || is_type_lang_item(cx, ty, hir::LangItem::String))
+    {
+        let mut applicability = Applicability::MachineApplicable;
+        span_lint_and_sugg(
+            cx,
+            BYTES_COUNT_TO_LEN,
+            expr.span,
+            "using long and hard to read `.bytes().count()`",
+            "consider calling `.len()` instead",
+            format!("{}.len()", snippet_with_applicability(cx, bytes_recv.span, "..", &mut applicability)),
+            applicability
+        );
     };
 }
diff --git a/clippy_lints/src/methods/case_sensitive_file_extension_comparisons.rs b/clippy_lints/src/methods/case_sensitive_file_extension_comparisons.rs
index d5897822eda..b773e762d93 100644
--- a/clippy_lints/src/methods/case_sensitive_file_extension_comparisons.rs
+++ b/clippy_lints/src/methods/case_sensitive_file_extension_comparisons.rs
@@ -27,51 +27,49 @@ pub(super) fn check<'tcx>(
         }
     }
 
-    if_chain! {
-        if let Some(method_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
-        if let Some(impl_id) = cx.tcx.impl_of_method(method_id);
-        if cx.tcx.type_of(impl_id).instantiate_identity().is_str();
-        if let ExprKind::Lit(Spanned { node: LitKind::Str(ext_literal, ..), ..}) = arg.kind;
-        if (2..=6).contains(&ext_literal.as_str().len());
-        let ext_str = ext_literal.as_str();
-        if ext_str.starts_with('.');
-        if ext_str.chars().skip(1).all(|c| c.is_uppercase() || c.is_ascii_digit())
-            || ext_str.chars().skip(1).all(|c| c.is_lowercase() || c.is_ascii_digit());
-        let recv_ty = cx.typeck_results().expr_ty(recv).peel_refs();
-        if recv_ty.is_str() || is_type_lang_item(cx, recv_ty, LangItem::String);
-        then {
-            span_lint_and_then(
-                cx,
-                CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS,
-                recv.span.to(call_span),
-                "case-sensitive file extension comparison",
-                |diag| {
-                    diag.help("consider using a case-insensitive comparison instead");
-                    if let Some(mut recv_source) = snippet_opt(cx, recv.span) {
+    if let Some(method_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id)
+        && let Some(impl_id) = cx.tcx.impl_of_method(method_id)
+        && cx.tcx.type_of(impl_id).instantiate_identity().is_str()
+        && let ExprKind::Lit(Spanned { node: LitKind::Str(ext_literal, ..), ..}) = arg.kind
+        && (2..=6).contains(&ext_literal.as_str().len())
+        && let ext_str = ext_literal.as_str()
+        && ext_str.starts_with('.')
+        && (ext_str.chars().skip(1).all(|c| c.is_uppercase() || c.is_ascii_digit())
+            || ext_str.chars().skip(1).all(|c| c.is_lowercase() || c.is_ascii_digit()))
+        && let recv_ty = cx.typeck_results().expr_ty(recv).peel_refs()
+        && (recv_ty.is_str() || is_type_lang_item(cx, recv_ty, LangItem::String))
+    {
+        span_lint_and_then(
+            cx,
+            CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS,
+            recv.span.to(call_span),
+            "case-sensitive file extension comparison",
+            |diag| {
+                diag.help("consider using a case-insensitive comparison instead");
+                if let Some(mut recv_source) = snippet_opt(cx, recv.span) {
 
-                        if !cx.typeck_results().expr_ty(recv).is_ref() {
-                            recv_source = format!("&{recv_source}");
-                        }
+                    if !cx.typeck_results().expr_ty(recv).is_ref() {
+                        recv_source = format!("&{recv_source}");
+                    }
 
-                        let suggestion_source = reindent_multiline(
-                            format!(
-                                "std::path::Path::new({})
-                                    .extension()
-                                    .map_or(false, |ext| ext.eq_ignore_ascii_case(\"{}\"))",
-                                recv_source, ext_str.strip_prefix('.').unwrap()).into(),
-                            true,
-                            Some(indent_of(cx, call_span).unwrap_or(0) + 4)
-                        );
+                    let suggestion_source = reindent_multiline(
+                        format!(
+                            "std::path::Path::new({})
+                                .extension()
+                                .map_or(false, |ext| ext.eq_ignore_ascii_case(\"{}\"))",
+                            recv_source, ext_str.strip_prefix('.').unwrap()).into(),
+                        true,
+                        Some(indent_of(cx, call_span).unwrap_or(0) + 4)
+                    );
 
-                        diag.span_suggestion(
-                            recv.span.to(call_span),
-                            "use std::path::Path",
-                            suggestion_source,
-                            Applicability::MaybeIncorrect,
-                        );
-                    }
+                    diag.span_suggestion(
+                        recv.span.to(call_span),
+                        "use std::path::Path",
+                        suggestion_source,
+                        Applicability::MaybeIncorrect,
+                    );
                 }
-            );
-        }
+            }
+        );
     }
 }
diff --git a/clippy_lints/src/methods/chars_cmp.rs b/clippy_lints/src/methods/chars_cmp.rs
index 0e41f3c2107..06c0ee2e691 100644
--- a/clippy_lints/src/methods/chars_cmp.rs
+++ b/clippy_lints/src/methods/chars_cmp.rs
@@ -15,34 +15,32 @@ pub(super) fn check(
     lint: &'static Lint,
     suggest: &str,
 ) -> bool {
-    if_chain! {
-        if let Some(args) = method_chain_args(info.chain, chain_methods);
-        if let hir::ExprKind::Call(fun, [arg_char]) = info.other.kind;
-        if let Some(id) = path_def_id(cx, fun).map(|ctor_id| cx.tcx.parent(ctor_id));
-        if Some(id) == cx.tcx.lang_items().option_some_variant();
-        then {
-            let mut applicability = Applicability::MachineApplicable;
-            let self_ty = cx.typeck_results().expr_ty_adjusted(args[0].0).peel_refs();
+    if let Some(args) = method_chain_args(info.chain, chain_methods)
+        && let hir::ExprKind::Call(fun, [arg_char]) = info.other.kind
+        && let Some(id) = path_def_id(cx, fun).map(|ctor_id| cx.tcx.parent(ctor_id))
+        && Some(id) == cx.tcx.lang_items().option_some_variant()
+    {
+        let mut applicability = Applicability::MachineApplicable;
+        let self_ty = cx.typeck_results().expr_ty_adjusted(args[0].0).peel_refs();
 
-            if *self_ty.kind() != ty::Str {
-                return false;
-            }
+        if *self_ty.kind() != ty::Str {
+            return false;
+        }
 
-            span_lint_and_sugg(
-                cx,
-                lint,
-                info.expr.span,
-                &format!("you should use the `{suggest}` method"),
-                "like this",
-                format!("{}{}.{suggest}({})",
-                        if info.eq { "" } else { "!" },
-                        snippet_with_applicability(cx, args[0].0.span, "..", &mut applicability),
-                        snippet_with_applicability(cx, arg_char.span, "..", &mut applicability)),
-                applicability,
-            );
+        span_lint_and_sugg(
+            cx,
+            lint,
+            info.expr.span,
+            &format!("you should use the `{suggest}` method"),
+            "like this",
+            format!("{}{}.{suggest}({})",
+                    if info.eq { "" } else { "!" },
+                    snippet_with_applicability(cx, args[0].0.span, "..", &mut applicability),
+                    snippet_with_applicability(cx, arg_char.span, "..", &mut applicability)),
+            applicability,
+        );
 
-            return true;
-        }
+        return true;
     }
 
     false
diff --git a/clippy_lints/src/methods/chars_cmp_with_unwrap.rs b/clippy_lints/src/methods/chars_cmp_with_unwrap.rs
index c9d50a5b03d..a364bc9e525 100644
--- a/clippy_lints/src/methods/chars_cmp_with_unwrap.rs
+++ b/clippy_lints/src/methods/chars_cmp_with_unwrap.rs
@@ -15,28 +15,26 @@ pub(super) fn check(
     lint: &'static Lint,
     suggest: &str,
 ) -> bool {
-    if_chain! {
-        if let Some(args) = method_chain_args(info.chain, chain_methods);
-        if let hir::ExprKind::Lit(lit) = info.other.kind;
-        if let ast::LitKind::Char(c) = lit.node;
-        then {
-            let mut applicability = Applicability::MachineApplicable;
-            span_lint_and_sugg(
-                cx,
-                lint,
-                info.expr.span,
-                &format!("you should use the `{suggest}` method"),
-                "like this",
-                format!("{}{}.{suggest}('{}')",
-                        if info.eq { "" } else { "!" },
-                        snippet_with_applicability(cx, args[0].0.span, "..", &mut applicability),
-                        c.escape_default()),
-                applicability,
-            );
+    if let Some(args) = method_chain_args(info.chain, chain_methods)
+        && let hir::ExprKind::Lit(lit) = info.other.kind
+        && let ast::LitKind::Char(c) = lit.node
+    {
+        let mut applicability = Applicability::MachineApplicable;
+        span_lint_and_sugg(
+            cx,
+            lint,
+            info.expr.span,
+            &format!("you should use the `{suggest}` method"),
+            "like this",
+            format!("{}{}.{suggest}('{}')",
+                    if info.eq { "" } else { "!" },
+                    snippet_with_applicability(cx, args[0].0.span, "..", &mut applicability),
+                    c.escape_default()),
+            applicability,
+        );
 
-            true
-        } else {
-            false
-        }
+        true
+    } else {
+        false
     }
 }
diff --git a/clippy_lints/src/methods/err_expect.rs b/clippy_lints/src/methods/err_expect.rs
index a8d4dd5e4f3..89df0652855 100644
--- a/clippy_lints/src/methods/err_expect.rs
+++ b/clippy_lints/src/methods/err_expect.rs
@@ -16,30 +16,28 @@ pub(super) fn check(
     err_span: Span,
     msrv: &Msrv,
 ) {
-    if_chain! {
-        if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(recv), sym::Result);
+    if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(recv), sym::Result)
         // Test the version to make sure the lint can be showed (expect_err has been
         // introduced in rust 1.17.0 : https://github.com/rust-lang/rust/pull/38982)
-        if msrv.meets(msrvs::EXPECT_ERR);
+        && msrv.meets(msrvs::EXPECT_ERR)
 
         // Grabs the `Result<T, E>` type
-        let result_type = cx.typeck_results().expr_ty(recv);
+        && let result_type = cx.typeck_results().expr_ty(recv)
         // Tests if the T type in a `Result<T, E>` is not None
-        if let Some(data_type) = get_data_type(cx, result_type);
+        && let Some(data_type) = get_data_type(cx, result_type)
         // Tests if the T type in a `Result<T, E>` implements debug
-        if has_debug_impl(cx, data_type);
+        && has_debug_impl(cx, data_type)
 
-        then {
-            span_lint_and_sugg(
-                cx,
-                ERR_EXPECT,
-                err_span.to(expect_span),
-                "called `.err().expect()` on a `Result` value",
-                "try",
-                "expect_err".to_string(),
-                Applicability::MachineApplicable
-        );
-        }
+    {
+        span_lint_and_sugg(
+            cx,
+            ERR_EXPECT,
+            err_span.to(expect_span),
+            "called `.err().expect()` on a `Result` value",
+            "try",
+            "expect_err".to_string(),
+            Applicability::MachineApplicable
+    );
     };
 }
 
diff --git a/clippy_lints/src/methods/extend_with_drain.rs b/clippy_lints/src/methods/extend_with_drain.rs
index 495b266529b..43a85f6e8a6 100644
--- a/clippy_lints/src/methods/extend_with_drain.rs
+++ b/clippy_lints/src/methods/extend_with_drain.rs
@@ -11,35 +11,33 @@ use super::EXTEND_WITH_DRAIN;
 
 pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'_>, arg: &Expr<'_>) {
     let ty = cx.typeck_results().expr_ty(recv).peel_refs();
-    if_chain! {
-        if is_type_diagnostic_item(cx, ty, sym::Vec);
+    if is_type_diagnostic_item(cx, ty, sym::Vec)
         //check source object
-        if let ExprKind::MethodCall(src_method, drain_vec, [drain_arg], _) = &arg.kind;
-        if src_method.ident.as_str() == "drain";
-        let src_ty = cx.typeck_results().expr_ty(drain_vec);
+        && let ExprKind::MethodCall(src_method, drain_vec, [drain_arg], _) = &arg.kind
+        && src_method.ident.as_str() == "drain"
+        && let src_ty = cx.typeck_results().expr_ty(drain_vec)
         //check if actual src type is mutable for code suggestion
-        let immutable = src_ty.is_mutable_ptr();
-        let src_ty = src_ty.peel_refs();
-        if is_type_diagnostic_item(cx, src_ty, sym::Vec);
+        && let immutable = src_ty.is_mutable_ptr()
+        && let src_ty = src_ty.peel_refs()
+        && is_type_diagnostic_item(cx, src_ty, sym::Vec)
         //check drain range
-        if let src_ty_range = cx.typeck_results().expr_ty(drain_arg).peel_refs();
-        if is_type_lang_item(cx, src_ty_range, LangItem::RangeFull);
-        then {
-            let mut applicability = Applicability::MachineApplicable;
-            span_lint_and_sugg(
-                cx,
-                EXTEND_WITH_DRAIN,
-                expr.span,
-                "use of `extend` instead of `append` for adding the full range of a second vector",
-                "try",
-                format!(
-                    "{}.append({}{})",
-                    snippet_with_applicability(cx, recv.span, "..", &mut applicability),
-                    if immutable { "" } else { "&mut " },
-                    snippet_with_applicability(cx, drain_vec.span, "..", &mut applicability)
-                ),
-                applicability,
-            );
-        }
+        && let src_ty_range = cx.typeck_results().expr_ty(drain_arg).peel_refs()
+        && is_type_lang_item(cx, src_ty_range, LangItem::RangeFull)
+    {
+        let mut applicability = Applicability::MachineApplicable;
+        span_lint_and_sugg(
+            cx,
+            EXTEND_WITH_DRAIN,
+            expr.span,
+            "use of `extend` instead of `append` for adding the full range of a second vector",
+            "try",
+            format!(
+                "{}.append({}{})",
+                snippet_with_applicability(cx, recv.span, "..", &mut applicability),
+                if immutable { "" } else { "&mut " },
+                snippet_with_applicability(cx, drain_vec.span, "..", &mut applicability)
+            ),
+            applicability,
+        );
     }
 }
diff --git a/clippy_lints/src/methods/filetype_is_file.rs b/clippy_lints/src/methods/filetype_is_file.rs
index 3fef53739fb..362f2589329 100644
--- a/clippy_lints/src/methods/filetype_is_file.rs
+++ b/clippy_lints/src/methods/filetype_is_file.rs
@@ -20,21 +20,19 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr
     let verb: &str;
     let lint_unary: &str;
     let help_unary: &str;
-    if_chain! {
-        if let Some(parent) = get_parent_expr(cx, expr);
-        if let hir::ExprKind::Unary(op, _) = parent.kind;
-        if op == hir::UnOp::Not;
-        then {
-            lint_unary = "!";
-            verb = "denies";
-            help_unary = "";
-            span = parent.span;
-        } else {
-            lint_unary = "";
-            verb = "covers";
-            help_unary = "!";
-            span = expr.span;
-        }
+    if let Some(parent) = get_parent_expr(cx, expr)
+        && let hir::ExprKind::Unary(op, _) = parent.kind
+        && op == hir::UnOp::Not
+    {
+        lint_unary = "!";
+        verb = "denies";
+        help_unary = "";
+        span = parent.span;
+    } else {
+        lint_unary = "";
+        verb = "covers";
+        help_unary = "!";
+        span = expr.span;
     }
     let lint_msg = format!("`{lint_unary}FileType::is_file()` only {verb} regular files");
     let help_msg = format!("use `{help_unary}FileType::is_dir()` instead");
diff --git a/clippy_lints/src/methods/filter_map.rs b/clippy_lints/src/methods/filter_map.rs
index 22b67923e50..ee7a1538a5f 100644
--- a/clippy_lints/src/methods/filter_map.rs
+++ b/clippy_lints/src/methods/filter_map.rs
@@ -29,13 +29,11 @@ fn is_method(cx: &LateContext<'_>, expr: &hir::Expr<'_>, method_name: Symbol) ->
             let arg_id = body.params[0].pat.hir_id;
             match closure_expr.kind {
                 hir::ExprKind::MethodCall(hir::PathSegment { ident, .. }, receiver, ..) => {
-                    if_chain! {
-                        if ident.name == method_name;
-                        if let hir::ExprKind::Path(path) = &receiver.kind;
-                        if let Res::Local(ref local) = cx.qpath_res(path, receiver.hir_id);
-                        then {
-                            return arg_id == *local
-                        }
+                    if ident.name == method_name
+                        && let hir::ExprKind::Path(path) = &receiver.kind
+                        && let Res::Local(ref local) = cx.qpath_res(path, receiver.hir_id)
+                    {
+                        return arg_id == *local
                     }
                     false
                 },
@@ -139,11 +137,9 @@ impl<'tcx> OffendingFilterExpr<'tcx> {
                         && path_to_local_id(map_arg_peeled, map_param_id))
                     && let eq_fallback = (|a: &Expr<'_>, b: &Expr<'_>| {
                         // in `filter(|x| ..)`, replace `*x` with `x`
-                        let a_path = if_chain! {
-                            if !is_filter_param_ref;
-                            if let ExprKind::Unary(UnOp::Deref, expr_path) = a.kind;
-                            then { expr_path } else { a }
-                        };
+                        let a_path = if !is_filter_param_ref
+                            && let ExprKind::Unary(UnOp::Deref, expr_path) = a.kind
+                        { expr_path } else { a };
                         // let the filter closure arg and the map closure arg be equal
                         path_to_local_id(a_path, filter_param_id)
                             && path_to_local_id(b, map_param_id)
@@ -305,87 +301,85 @@ pub(super) fn check(
         return;
     }
 
-    if_chain! {
-        if is_trait_method(cx, map_recv, sym::Iterator);
+    if is_trait_method(cx, map_recv, sym::Iterator)
 
         // filter(|x| ...is_some())...
-        if let ExprKind::Closure(&Closure { body: filter_body_id, .. }) = filter_arg.kind;
-        let filter_body = cx.tcx.hir().body(filter_body_id);
-        if let [filter_param] = filter_body.params;
+        && let ExprKind::Closure(&Closure { body: filter_body_id, .. }) = filter_arg.kind
+        && let filter_body = cx.tcx.hir().body(filter_body_id)
+        && let [filter_param] = filter_body.params
         // optional ref pattern: `filter(|&x| ..)`
-        let (filter_pat, is_filter_param_ref) = if let PatKind::Ref(ref_pat, _) = filter_param.pat.kind {
+        && let (filter_pat, is_filter_param_ref) = if let PatKind::Ref(ref_pat, _) = filter_param.pat.kind {
             (ref_pat, true)
         } else {
             (filter_param.pat, false)
-        };
+        }
 
-        if let PatKind::Binding(_, filter_param_id, _, None) = filter_pat.kind;
-        if let Some(mut offending_expr) = OffendingFilterExpr::hir(cx, filter_body.value, filter_param_id);
+        && let PatKind::Binding(_, filter_param_id, _, None) = filter_pat.kind
+        && let Some(mut offending_expr) = OffendingFilterExpr::hir(cx, filter_body.value, filter_param_id)
 
-        if let ExprKind::Closure(&Closure { body: map_body_id, .. }) = map_arg.kind;
-        let map_body = cx.tcx.hir().body(map_body_id);
-        if let [map_param] = map_body.params;
-        if let PatKind::Binding(_, map_param_id, map_param_ident, None) = map_param.pat.kind;
+        && let ExprKind::Closure(&Closure { body: map_body_id, .. }) = map_arg.kind
+        && let map_body = cx.tcx.hir().body(map_body_id)
+        && let [map_param] = map_body.params
+        && let PatKind::Binding(_, map_param_id, map_param_ident, None) = map_param.pat.kind
 
-        if let Some(check_result) =
-            offending_expr.check_map_call(cx, map_body, map_param_id, filter_param_id, is_filter_param_ref);
+        && let Some(check_result) =
+            offending_expr.check_map_call(cx, map_body, map_param_id, filter_param_id, is_filter_param_ref)
 
-        then {
-            let span = filter_span.with_hi(expr.span.hi());
-            let (filter_name, lint) = if is_find {
-                ("find", MANUAL_FIND_MAP)
-            } else {
-                ("filter", MANUAL_FILTER_MAP)
-            };
-            let msg = format!("`{filter_name}(..).map(..)` can be simplified as `{filter_name}_map(..)`");
+    {
+        let span = filter_span.with_hi(expr.span.hi());
+        let (filter_name, lint) = if is_find {
+            ("find", MANUAL_FIND_MAP)
+        } else {
+            ("filter", MANUAL_FILTER_MAP)
+        };
+        let msg = format!("`{filter_name}(..).map(..)` can be simplified as `{filter_name}_map(..)`");
 
-            let (sugg, note_and_span, applicability) = match check_result {
-                CheckResult::Method { map_arg, method, side_effect_expr_span } => {
-                    let (to_opt, deref) = match method {
-                        CalledMethod::ResultIsOk => (".ok()", String::new()),
-                        CalledMethod::OptionIsSome => {
-                            let derefs = cx.typeck_results()
-                                .expr_adjustments(map_arg)
-                                .iter()
-                                .filter(|adj| matches!(adj.kind, Adjust::Deref(_)))
-                                .count();
+        let (sugg, note_and_span, applicability) = match check_result {
+            CheckResult::Method { map_arg, method, side_effect_expr_span } => {
+                let (to_opt, deref) = match method {
+                    CalledMethod::ResultIsOk => (".ok()", String::new()),
+                    CalledMethod::OptionIsSome => {
+                        let derefs = cx.typeck_results()
+                            .expr_adjustments(map_arg)
+                            .iter()
+                            .filter(|adj| matches!(adj.kind, Adjust::Deref(_)))
+                            .count();
 
-                            ("", "*".repeat(derefs))
-                        }
-                    };
+                        ("", "*".repeat(derefs))
+                    }
+                };
 
-                    let sugg = format!(
-                        "{filter_name}_map(|{map_param_ident}| {deref}{}{to_opt})",
-                        snippet(cx, map_arg.span, ".."),
-                    );
-                    let (note_and_span, applicability) = if let Some(span) = side_effect_expr_span {
-                        let note = "the suggestion might change the behavior of the program when merging `filter` and `map`, \
-                            because this expression potentially contains side effects and will only execute once";
+                let sugg = format!(
+                    "{filter_name}_map(|{map_param_ident}| {deref}{}{to_opt})",
+                    snippet(cx, map_arg.span, ".."),
+                );
+                let (note_and_span, applicability) = if let Some(span) = side_effect_expr_span {
+                    let note = "the suggestion might change the behavior of the program when merging `filter` and `map`, \
+                        because this expression potentially contains side effects and will only execute once";
 
-                        (Some((note, span)), Applicability::MaybeIncorrect)
-                    } else {
-                        (None, Applicability::MachineApplicable)
-                    };
+                    (Some((note, span)), Applicability::MaybeIncorrect)
+                } else {
+                    (None, Applicability::MachineApplicable)
+                };
 
-                    (sugg, note_and_span, applicability)
-                }
-                CheckResult::PatternMatching { variant_span, variant_ident } => {
-                    let pat = snippet(cx, variant_span, "<pattern>");
+                (sugg, note_and_span, applicability)
+            }
+            CheckResult::PatternMatching { variant_span, variant_ident } => {
+                let pat = snippet(cx, variant_span, "<pattern>");
 
-                    (format!("{filter_name}_map(|{map_param_ident}| match {map_param_ident} {{ \
-                        {pat} => Some({variant_ident}), \
-                        _ => None \
-                    }})"), None, Applicability::MachineApplicable)
-                }
-            };
-            span_lint_and_then(cx, lint, span, &msg, |diag| {
-                diag.span_suggestion(span, "try", sugg, applicability);
+                (format!("{filter_name}_map(|{map_param_ident}| match {map_param_ident} {{ \
+                    {pat} => Some({variant_ident}), \
+                    _ => None \
+                }})"), None, Applicability::MachineApplicable)
+            }
+        };
+        span_lint_and_then(cx, lint, span, &msg, |diag| {
+            diag.span_suggestion(span, "try", sugg, applicability);
 
-                if let Some((note, span)) = note_and_span {
-                    diag.span_note(span, note);
-                }
-            });
-        }
+            if let Some((note, span)) = note_and_span {
+                diag.span_note(span, note);
+            }
+        });
     }
 }
 
diff --git a/clippy_lints/src/methods/from_iter_instead_of_collect.rs b/clippy_lints/src/methods/from_iter_instead_of_collect.rs
index 4040d3a5fe1..cee8d8eb029 100644
--- a/clippy_lints/src/methods/from_iter_instead_of_collect.rs
+++ b/clippy_lints/src/methods/from_iter_instead_of_collect.rs
@@ -12,28 +12,26 @@ use rustc_span::sym;
 use super::FROM_ITER_INSTEAD_OF_COLLECT;
 
 pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::Expr<'_>], func: &hir::Expr<'_>) {
-    if_chain! {
-        if is_path_diagnostic_item(cx, func, sym::from_iter_fn);
-        let ty = cx.typeck_results().expr_ty(expr);
-        let arg_ty = cx.typeck_results().expr_ty(&args[0]);
-        if let Some(iter_id) = cx.tcx.get_diagnostic_item(sym::Iterator);
+    if is_path_diagnostic_item(cx, func, sym::from_iter_fn)
+        && let ty = cx.typeck_results().expr_ty(expr)
+        && let arg_ty = cx.typeck_results().expr_ty(&args[0])
+        && let Some(iter_id) = cx.tcx.get_diagnostic_item(sym::Iterator)
 
-        if implements_trait(cx, arg_ty, iter_id, &[]);
-        then {
-            // `expr` implements `FromIterator` trait
-            let iter_expr = sugg::Sugg::hir(cx, &args[0], "..").maybe_par();
-            let turbofish = extract_turbofish(cx, expr, ty);
-            let sugg = format!("{iter_expr}.collect::<{turbofish}>()");
-            span_lint_and_sugg(
-                cx,
-                FROM_ITER_INSTEAD_OF_COLLECT,
-                expr.span,
-                "usage of `FromIterator::from_iter`",
-                "use `.collect()` instead of `::from_iter()`",
-                sugg,
-                Applicability::MaybeIncorrect,
-            );
-        }
+        && implements_trait(cx, arg_ty, iter_id, &[])
+    {
+        // `expr` implements `FromIterator` trait
+        let iter_expr = sugg::Sugg::hir(cx, &args[0], "..").maybe_par();
+        let turbofish = extract_turbofish(cx, expr, ty);
+        let sugg = format!("{iter_expr}.collect::<{turbofish}>()");
+        span_lint_and_sugg(
+            cx,
+            FROM_ITER_INSTEAD_OF_COLLECT,
+            expr.span,
+            "usage of `FromIterator::from_iter`",
+            "use `.collect()` instead of `::from_iter()`",
+            sugg,
+            Applicability::MaybeIncorrect,
+        );
     }
 }
 
@@ -43,41 +41,37 @@ fn extract_turbofish(cx: &LateContext<'_>, expr: &hir::Expr<'_>, ty: Ty<'_>) ->
     }
 
     let call_site = expr.span.source_callsite();
-    if_chain! {
-        if let Some(snippet) = snippet_opt(cx, call_site);
-        let snippet_split = snippet.split("::").collect::<Vec<_>>();
-        if let Some((_, elements)) = snippet_split.split_last();
+    if let Some(snippet) = snippet_opt(cx, call_site)
+        && let snippet_split = snippet.split("::").collect::<Vec<_>>()
+        && let Some((_, elements)) = snippet_split.split_last()
 
-        then {
-            if_chain! {
-                if let [type_specifier, _] = snippet_split.as_slice();
-                if let Some(type_specifier) = strip_angle_brackets(type_specifier);
-                if let Some((type_specifier, ..)) = type_specifier.split_once(" as ");
-                then {
-                    type_specifier.to_string()
-                } else {
-                    // is there a type specifier? (i.e.: like `<u32>` in `collections::BTreeSet::<u32>::`)
-                    if let Some(type_specifier) = snippet_split.iter().find(|e| strip_angle_brackets(e).is_some()) {
-                        // remove the type specifier from the path elements
-                        let without_ts = elements.iter().filter_map(|e| {
-                            if e == type_specifier { None } else { Some((*e).to_string()) }
-                        }).collect::<Vec<_>>();
-                        // join and add the type specifier at the end (i.e.: `collections::BTreeSet<u32>`)
-                        format!("{}{type_specifier}", without_ts.join("::"))
-                    } else {
-                        // type is not explicitly specified so wildcards are needed
-                        // i.e.: 2 wildcards in `std::collections::BTreeMap<&i32, &char>`
-                        let ty_str = ty.to_string();
-                        let start = ty_str.find('<').unwrap_or(0);
-                        let end = ty_str.find('>').unwrap_or(ty_str.len());
-                        let nb_wildcard = ty_str[start..end].split(',').count();
-                        let wildcards = format!("_{}", ", _".repeat(nb_wildcard - 1));
-                        format!("{}<{wildcards}>", elements.join("::"))
-                    }
-                }
-            }
+    {
+        if let [type_specifier, _] = snippet_split.as_slice()
+            && let Some(type_specifier) = strip_angle_brackets(type_specifier)
+            && let Some((type_specifier, ..)) = type_specifier.split_once(" as ")
+        {
+            type_specifier.to_string()
         } else {
-            ty.to_string()
+            // is there a type specifier? (i.e.: like `<u32>` in `collections::BTreeSet::<u32>::`)
+            if let Some(type_specifier) = snippet_split.iter().find(|e| strip_angle_brackets(e).is_some()) {
+                // remove the type specifier from the path elements
+                let without_ts = elements.iter().filter_map(|e| {
+                    if e == type_specifier { None } else { Some((*e).to_string()) }
+                }).collect::<Vec<_>>();
+                // join and add the type specifier at the end (i.e.: `collections::BTreeSet<u32>`)
+                format!("{}{type_specifier}", without_ts.join("::"))
+            } else {
+                // type is not explicitly specified so wildcards are needed
+                // i.e.: 2 wildcards in `std::collections::BTreeMap<&i32, &char>`
+                let ty_str = ty.to_string();
+                let start = ty_str.find('<').unwrap_or(0);
+                let end = ty_str.find('>').unwrap_or(ty_str.len());
+                let nb_wildcard = ty_str[start..end].split(',').count();
+                let wildcards = format!("_{}", ", _".repeat(nb_wildcard - 1));
+                format!("{}<{wildcards}>", elements.join("::"))
+            }
         }
+    } else {
+        ty.to_string()
     }
 }
diff --git a/clippy_lints/src/methods/get_first.rs b/clippy_lints/src/methods/get_first.rs
index 2e1dd3ec649..9b6f76f0f42 100644
--- a/clippy_lints/src/methods/get_first.rs
+++ b/clippy_lints/src/methods/get_first.rs
@@ -17,13 +17,24 @@ pub(super) fn check<'tcx>(
     recv: &'tcx hir::Expr<'_>,
     arg: &'tcx hir::Expr<'_>,
 ) {
-    if_chain! {
-        if let Some(method_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
-        if let Some(impl_id) = cx.tcx.impl_of_method(method_id);
-        let identity = cx.tcx.type_of(impl_id).instantiate_identity();
-        if let hir::ExprKind::Lit(Spanned { node: LitKind::Int(0, _), .. }) = arg.kind;
-        then {
-            if identity.is_slice() {
+    if let Some(method_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id)
+        && let Some(impl_id) = cx.tcx.impl_of_method(method_id)
+        && let identity = cx.tcx.type_of(impl_id).instantiate_identity()
+        && let hir::ExprKind::Lit(Spanned { node: LitKind::Int(0, _), .. }) = arg.kind
+    {
+        if identity.is_slice() {
+            let mut app = Applicability::MachineApplicable;
+            let slice_name = snippet_with_applicability(cx, recv.span, "..", &mut app);
+            span_lint_and_sugg(
+                cx,
+                GET_FIRST,
+                expr.span,
+                &format!("accessing first element with `{slice_name}.get(0)`"),
+                "try",
+                format!("{slice_name}.first()"),
+                app,
+            );
+        } else if is_type_diagnostic_item(cx, identity, sym::VecDeque){
                 let mut app = Applicability::MachineApplicable;
                 let slice_name = snippet_with_applicability(cx, recv.span, "..", &mut app);
                 span_lint_and_sugg(
@@ -32,22 +43,9 @@ pub(super) fn check<'tcx>(
                     expr.span,
                     &format!("accessing first element with `{slice_name}.get(0)`"),
                     "try",
-                    format!("{slice_name}.first()"),
+                    format!("{slice_name}.front()"),
                     app,
                 );
-            } else if is_type_diagnostic_item(cx, identity, sym::VecDeque){
-                    let mut app = Applicability::MachineApplicable;
-                    let slice_name = snippet_with_applicability(cx, recv.span, "..", &mut app);
-                    span_lint_and_sugg(
-                        cx,
-                        GET_FIRST,
-                        expr.span,
-                        &format!("accessing first element with `{slice_name}.get(0)`"),
-                        "try",
-                        format!("{slice_name}.front()"),
-                        app,
-                    );
-            }
         }
     }
 }
diff --git a/clippy_lints/src/methods/implicit_clone.rs b/clippy_lints/src/methods/implicit_clone.rs
index e91ce64d8c8..73747340ef1 100644
--- a/clippy_lints/src/methods/implicit_clone.rs
+++ b/clippy_lints/src/methods/implicit_clone.rs
@@ -11,34 +11,32 @@ use rustc_span::sym;
 use super::IMPLICIT_CLONE;
 
 pub fn check(cx: &LateContext<'_>, method_name: &str, expr: &hir::Expr<'_>, recv: &hir::Expr<'_>) {
-    if_chain! {
-        if let Some(method_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
-        if is_clone_like(cx, method_name, method_def_id);
-        let return_type = cx.typeck_results().expr_ty(expr);
-        let input_type = cx.typeck_results().expr_ty(recv);
-        let (input_type, ref_count) = peel_mid_ty_refs(input_type);
-        if !(ref_count > 0 && is_diag_trait_item(cx, method_def_id, sym::ToOwned));
-        if let Some(ty_name) = input_type.ty_adt_def().map(|adt_def| cx.tcx.item_name(adt_def.did()));
-        if return_type == input_type;
-        if let Some(clone_trait) = cx.tcx.lang_items().clone_trait();
-        if implements_trait(cx, return_type, clone_trait, &[]);
-        then {
-            let mut app = Applicability::MachineApplicable;
-            let recv_snip = snippet_with_context(cx, recv.span, expr.span.ctxt(), "..", &mut app).0;
-            span_lint_and_sugg(
-                cx,
-                IMPLICIT_CLONE,
-                expr.span,
-                &format!("implicitly cloning a `{ty_name}` by calling `{method_name}` on its dereferenced type"),
-                "consider using",
-                if ref_count > 1 {
-                    format!("({}{recv_snip}).clone()", "*".repeat(ref_count - 1))
-                } else {
-                    format!("{recv_snip}.clone()")
-                },
-                app,
-            );
-        }
+    if let Some(method_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id)
+        && is_clone_like(cx, method_name, method_def_id)
+        && let return_type = cx.typeck_results().expr_ty(expr)
+        && let input_type = cx.typeck_results().expr_ty(recv)
+        && let (input_type, ref_count) = peel_mid_ty_refs(input_type)
+        && !(ref_count > 0 && is_diag_trait_item(cx, method_def_id, sym::ToOwned))
+        && let Some(ty_name) = input_type.ty_adt_def().map(|adt_def| cx.tcx.item_name(adt_def.did()))
+        && return_type == input_type
+        && let Some(clone_trait) = cx.tcx.lang_items().clone_trait()
+        && implements_trait(cx, return_type, clone_trait, &[])
+    {
+        let mut app = Applicability::MachineApplicable;
+        let recv_snip = snippet_with_context(cx, recv.span, expr.span.ctxt(), "..", &mut app).0;
+        span_lint_and_sugg(
+            cx,
+            IMPLICIT_CLONE,
+            expr.span,
+            &format!("implicitly cloning a `{ty_name}` by calling `{method_name}` on its dereferenced type"),
+            "consider using",
+            if ref_count > 1 {
+                format!("({}{recv_snip}).clone()", "*".repeat(ref_count - 1))
+            } else {
+                format!("{recv_snip}.clone()")
+            },
+            app,
+        );
     }
 }
 
diff --git a/clippy_lints/src/methods/inefficient_to_string.rs b/clippy_lints/src/methods/inefficient_to_string.rs
index 6686d42c95f..c0b7b3ae972 100644
--- a/clippy_lints/src/methods/inefficient_to_string.rs
+++ b/clippy_lints/src/methods/inefficient_to_string.rs
@@ -18,37 +18,35 @@ pub fn check(
     receiver: &hir::Expr<'_>,
     args: &[hir::Expr<'_>],
 ) {
-    if_chain! {
-        if args.is_empty() && method_name == sym::to_string;
-        if let Some(to_string_meth_did) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
-        if cx.tcx.is_diagnostic_item(sym::to_string_method, to_string_meth_did);
-        if let Some(args) = cx.typeck_results().node_args_opt(expr.hir_id);
-        let arg_ty = cx.typeck_results().expr_ty_adjusted(receiver);
-        let self_ty = args.type_at(0);
-        let (deref_self_ty, deref_count) = walk_ptrs_ty_depth(self_ty);
-        if deref_count >= 1;
-        if specializes_tostring(cx, deref_self_ty);
-        then {
-            span_lint_and_then(
-                cx,
-                INEFFICIENT_TO_STRING,
-                expr.span,
-                &format!("calling `to_string` on `{arg_ty}`"),
-                |diag| {
-                    diag.help(format!(
-                        "`{self_ty}` implements `ToString` through a slower blanket impl, but `{deref_self_ty}` has a fast specialization of `ToString`"
-                    ));
-                    let mut applicability = Applicability::MachineApplicable;
-                    let arg_snippet = snippet_with_applicability(cx, receiver.span, "..", &mut applicability);
-                    diag.span_suggestion(
-                        expr.span,
-                        "try dereferencing the receiver",
-                        format!("({}{arg_snippet}).to_string()", "*".repeat(deref_count)),
-                        applicability,
-                    );
-                },
-            );
-        }
+    if args.is_empty() && method_name == sym::to_string
+        && let Some(to_string_meth_did) = cx.typeck_results().type_dependent_def_id(expr.hir_id)
+        && cx.tcx.is_diagnostic_item(sym::to_string_method, to_string_meth_did)
+        && let Some(args) = cx.typeck_results().node_args_opt(expr.hir_id)
+        && let arg_ty = cx.typeck_results().expr_ty_adjusted(receiver)
+        && let self_ty = args.type_at(0)
+        && let (deref_self_ty, deref_count) = walk_ptrs_ty_depth(self_ty)
+        && deref_count >= 1
+        && specializes_tostring(cx, deref_self_ty)
+    {
+        span_lint_and_then(
+            cx,
+            INEFFICIENT_TO_STRING,
+            expr.span,
+            &format!("calling `to_string` on `{arg_ty}`"),
+            |diag| {
+                diag.help(format!(
+                    "`{self_ty}` implements `ToString` through a slower blanket impl, but `{deref_self_ty}` has a fast specialization of `ToString`"
+                ));
+                let mut applicability = Applicability::MachineApplicable;
+                let arg_snippet = snippet_with_applicability(cx, receiver.span, "..", &mut applicability);
+                diag.span_suggestion(
+                    expr.span,
+                    "try dereferencing the receiver",
+                    format!("({}{arg_snippet}).to_string()", "*".repeat(deref_count)),
+                    applicability,
+                );
+            },
+        );
     }
 }
 
diff --git a/clippy_lints/src/methods/into_iter_on_ref.rs b/clippy_lints/src/methods/into_iter_on_ref.rs
index 8adf9e37059..7bb32d6ea65 100644
--- a/clippy_lints/src/methods/into_iter_on_ref.rs
+++ b/clippy_lints/src/methods/into_iter_on_ref.rs
@@ -19,24 +19,22 @@ pub(super) fn check(
     receiver: &hir::Expr<'_>,
 ) {
     let self_ty = cx.typeck_results().expr_ty_adjusted(receiver);
-    if_chain! {
-        if let ty::Ref(..) = self_ty.kind();
-        if method_name == sym::into_iter;
-        if is_trait_method(cx, expr, sym::IntoIterator);
-        if let Some((kind, method_name)) = ty_has_iter_method(cx, self_ty);
-        then {
-            span_lint_and_sugg(
-                cx,
-                INTO_ITER_ON_REF,
-                method_span,
-                &format!(
-                    "this `.into_iter()` call is equivalent to `.{method_name}()` and will not consume the `{kind}`",
-                ),
-                "call directly",
-                method_name.to_string(),
-                Applicability::MachineApplicable,
-            );
-        }
+    if let ty::Ref(..) = self_ty.kind()
+        && method_name == sym::into_iter
+        && is_trait_method(cx, expr, sym::IntoIterator)
+        && let Some((kind, method_name)) = ty_has_iter_method(cx, self_ty)
+    {
+        span_lint_and_sugg(
+            cx,
+            INTO_ITER_ON_REF,
+            method_span,
+            &format!(
+                "this `.into_iter()` call is equivalent to `.{method_name}()` and will not consume the `{kind}`",
+            ),
+            "call directly",
+            method_name.to_string(),
+            Applicability::MachineApplicable,
+        );
     }
 }
 
diff --git a/clippy_lints/src/methods/iter_cloned_collect.rs b/clippy_lints/src/methods/iter_cloned_collect.rs
index bde6f92b076..da841ca50f4 100644
--- a/clippy_lints/src/methods/iter_cloned_collect.rs
+++ b/clippy_lints/src/methods/iter_cloned_collect.rs
@@ -10,22 +10,20 @@ use rustc_span::sym;
 use super::ITER_CLONED_COLLECT;
 
 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, method_name: &str, expr: &hir::Expr<'_>, recv: &'tcx hir::Expr<'_>) {
-    if_chain! {
-        if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(expr), sym::Vec);
-        if let Some(slice) = derefs_to_slice(cx, recv, cx.typeck_results().expr_ty(recv));
-        if let Some(to_replace) = expr.span.trim_start(slice.span.source_callsite());
+    if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(expr), sym::Vec)
+        && let Some(slice) = derefs_to_slice(cx, recv, cx.typeck_results().expr_ty(recv))
+        && let Some(to_replace) = expr.span.trim_start(slice.span.source_callsite())
 
-        then {
-            span_lint_and_sugg(
-                cx,
-                ITER_CLONED_COLLECT,
-                to_replace,
-                &format!("called `iter().{method_name}().collect()` on a slice to create a `Vec`. Calling `to_vec()` is both faster and \
-                more readable"),
-                "try",
-                ".to_vec()".to_string(),
-                Applicability::MachineApplicable,
-            );
-        }
+    {
+        span_lint_and_sugg(
+            cx,
+            ITER_CLONED_COLLECT,
+            to_replace,
+            &format!("called `iter().{method_name}().collect()` on a slice to create a `Vec`. Calling `to_vec()` is both faster and \
+            more readable"),
+            "try",
+            ".to_vec()".to_string(),
+            Applicability::MachineApplicable,
+        );
     }
 }
diff --git a/clippy_lints/src/methods/iter_kv_map.rs b/clippy_lints/src/methods/iter_kv_map.rs
index 625325d4cf5..687aee267fa 100644
--- a/clippy_lints/src/methods/iter_kv_map.rs
+++ b/clippy_lints/src/methods/iter_kv_map.rs
@@ -22,64 +22,60 @@ pub(super) fn check<'tcx>(
     recv: &'tcx Expr<'tcx>,  // hashmap
     m_arg: &'tcx Expr<'tcx>, // |(_, v)| v
 ) {
-    if_chain! {
-        if !expr.span.from_expansion();
-        if let ExprKind::Closure(c) = m_arg.kind;
-        if let Body {params: [p], value: body_expr, coroutine_kind: _ } = cx.tcx.hir().body(c.body);
-        if let PatKind::Tuple([key_pat, val_pat], _) = p.pat.kind;
+    if !expr.span.from_expansion()
+        && let ExprKind::Closure(c) = m_arg.kind
+        && let Body {params: [p], value: body_expr, coroutine_kind: _ } = cx.tcx.hir().body(c.body)
+        && let PatKind::Tuple([key_pat, val_pat], _) = p.pat.kind
 
-        let (replacement_kind, annotation, bound_ident) = match (&key_pat.kind, &val_pat.kind) {
+        && let (replacement_kind, annotation, bound_ident) = match (&key_pat.kind, &val_pat.kind) {
             (key, PatKind::Binding(ann, _, value, _)) if pat_is_wild(cx, key, m_arg) => ("value", ann, value),
             (PatKind::Binding(ann, _, key, _), value) if pat_is_wild(cx, value, m_arg) => ("key", ann, key),
             _ => return,
-        };
+        }
 
-        let ty = cx.typeck_results().expr_ty(recv);
-        if is_type_diagnostic_item(cx, ty, sym::HashMap) || is_type_diagnostic_item(cx, ty, sym::BTreeMap);
+        && let ty = cx.typeck_results().expr_ty(recv)
+        && (is_type_diagnostic_item(cx, ty, sym::HashMap) || is_type_diagnostic_item(cx, ty, sym::BTreeMap))
 
-        then {
-            let mut applicability = rustc_errors::Applicability::MachineApplicable;
-            let recv_snippet = snippet_with_applicability(cx, recv.span, "map", &mut applicability);
-            let into_prefix = if map_type == "into_iter" {"into_"} else {""};
+    {
+        let mut applicability = rustc_errors::Applicability::MachineApplicable;
+        let recv_snippet = snippet_with_applicability(cx, recv.span, "map", &mut applicability);
+        let into_prefix = if map_type == "into_iter" {"into_"} else {""};
 
-            if_chain! {
-                if let ExprKind::Path(rustc_hir::QPath::Resolved(_, path)) = body_expr.kind;
-                if let [local_ident] = path.segments;
-                if local_ident.ident.as_str() == bound_ident.as_str();
+        if let ExprKind::Path(rustc_hir::QPath::Resolved(_, path)) = body_expr.kind
+            && let [local_ident] = path.segments
+            && local_ident.ident.as_str() == bound_ident.as_str()
 
-                then {
-                    span_lint_and_sugg(
-                        cx,
-                        ITER_KV_MAP,
-                        expr.span,
-                        &format!("iterating on a map's {replacement_kind}s"),
-                        "try",
-                        format!("{recv_snippet}.{into_prefix}{replacement_kind}s()"),
-                        applicability,
-                    );
-                } else {
-                    let ref_annotation = if annotation.0 == ByRef::Yes {
-                        "ref "
-                    } else {
-                        ""
-                    };
-                    let mut_annotation = if annotation.1 == Mutability::Mut {
-                        "mut "
-                    } else {
-                        ""
-                    };
-                    span_lint_and_sugg(
-                        cx,
-                        ITER_KV_MAP,
-                        expr.span,
-                        &format!("iterating on a map's {replacement_kind}s"),
-                        "try",
-                        format!("{recv_snippet}.{into_prefix}{replacement_kind}s().map(|{ref_annotation}{mut_annotation}{bound_ident}| {})",
-                            snippet_with_applicability(cx, body_expr.span, "/* body */", &mut applicability)),
-                        applicability,
-                    );
-                }
-            }
+        {
+            span_lint_and_sugg(
+                cx,
+                ITER_KV_MAP,
+                expr.span,
+                &format!("iterating on a map's {replacement_kind}s"),
+                "try",
+                format!("{recv_snippet}.{into_prefix}{replacement_kind}s()"),
+                applicability,
+            );
+        } else {
+            let ref_annotation = if annotation.0 == ByRef::Yes {
+                "ref "
+            } else {
+                ""
+            };
+            let mut_annotation = if annotation.1 == Mutability::Mut {
+                "mut "
+            } else {
+                ""
+            };
+            span_lint_and_sugg(
+                cx,
+                ITER_KV_MAP,
+                expr.span,
+                &format!("iterating on a map's {replacement_kind}s"),
+                "try",
+                format!("{recv_snippet}.{into_prefix}{replacement_kind}s().map(|{ref_annotation}{mut_annotation}{bound_ident}| {})",
+                    snippet_with_applicability(cx, body_expr.span, "/* body */", &mut applicability)),
+                applicability,
+            );
         }
     }
 }
diff --git a/clippy_lints/src/methods/iter_next_slice.rs b/clippy_lints/src/methods/iter_next_slice.rs
index 8f885e9f729..9d97370116e 100644
--- a/clippy_lints/src/methods/iter_next_slice.rs
+++ b/clippy_lints/src/methods/iter_next_slice.rs
@@ -26,29 +26,27 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, cal
 
     if derefs_to_slice(cx, caller_expr, cx.typeck_results().expr_ty(caller_expr)).is_some() {
         // caller is a Slice
-        if_chain! {
-            if let hir::ExprKind::Index(caller_var, index_expr, _) = &caller_expr.kind;
-            if let Some(higher::Range { start: Some(start_expr), end: None, limits: ast::RangeLimits::HalfOpen })
-                = higher::Range::hir(index_expr);
-            if let hir::ExprKind::Lit(start_lit) = &start_expr.kind;
-            if let ast::LitKind::Int(start_idx, _) = start_lit.node;
-            then {
-                let mut applicability = Applicability::MachineApplicable;
-                let suggest = if start_idx == 0 {
-                    format!("{}.first()", snippet_with_applicability(cx, caller_var.span, "..", &mut applicability))
-                } else {
-                    format!("{}.get({start_idx})", snippet_with_applicability(cx, caller_var.span, "..", &mut applicability))
-                };
-                span_lint_and_sugg(
-                    cx,
-                    ITER_NEXT_SLICE,
-                    expr.span,
-                    "using `.iter().next()` on a Slice without end index",
-                    "try calling",
-                    suggest,
-                    applicability,
-                );
-            }
+        if let hir::ExprKind::Index(caller_var, index_expr, _) = &caller_expr.kind
+            && let Some(higher::Range { start: Some(start_expr), end: None, limits: ast::RangeLimits::HalfOpen })
+                = higher::Range::hir(index_expr)
+            && let hir::ExprKind::Lit(start_lit) = &start_expr.kind
+            && let ast::LitKind::Int(start_idx, _) = start_lit.node
+        {
+            let mut applicability = Applicability::MachineApplicable;
+            let suggest = if start_idx == 0 {
+                format!("{}.first()", snippet_with_applicability(cx, caller_var.span, "..", &mut applicability))
+            } else {
+                format!("{}.get({start_idx})", snippet_with_applicability(cx, caller_var.span, "..", &mut applicability))
+            };
+            span_lint_and_sugg(
+                cx,
+                ITER_NEXT_SLICE,
+                expr.span,
+                "using `.iter().next()` on a Slice without end index",
+                "try calling",
+                suggest,
+                applicability,
+            );
         }
     } else if is_vec_or_array(cx, caller_expr) {
         // caller is a Vec or an Array
diff --git a/clippy_lints/src/methods/iter_skip_next.rs b/clippy_lints/src/methods/iter_skip_next.rs
index 39af52141bb..872476a314c 100644
--- a/clippy_lints/src/methods/iter_skip_next.rs
+++ b/clippy_lints/src/methods/iter_skip_next.rs
@@ -19,18 +19,16 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr
             expr.span.trim_start(recv.span).unwrap(),
             "called `skip(..).next()` on an iterator",
             |diag| {
-                if_chain! {
-                    if let Some(id) = path_to_local(recv);
-                    if let Node::Pat(pat) = cx.tcx.hir().get(id);
-                    if let PatKind::Binding(ann, _, _, _)  = pat.kind;
-                    if ann != BindingAnnotation::MUT;
-                    then {
-                        application = Applicability::Unspecified;
-                        diag.span_help(
-                            pat.span,
-                            format!("for this change `{}` has to be mutable", snippet(cx, pat.span, "..")),
-                        );
-                    }
+                if let Some(id) = path_to_local(recv)
+                    && let Node::Pat(pat) = cx.tcx.hir().get(id)
+                    && let PatKind::Binding(ann, _, _, _)  = pat.kind
+                    && ann != BindingAnnotation::MUT
+                {
+                    application = Applicability::Unspecified;
+                    diag.span_help(
+                        pat.span,
+                        format!("for this change `{}` has to be mutable", snippet(cx, pat.span, "..")),
+                    );
                 }
 
                 diag.span_suggestion(
diff --git a/clippy_lints/src/methods/manual_ok_or.rs b/clippy_lints/src/methods/manual_ok_or.rs
index 3031193e531..35d5e090cc8 100644
--- a/clippy_lints/src/methods/manual_ok_or.rs
+++ b/clippy_lints/src/methods/manual_ok_or.rs
@@ -18,30 +18,28 @@ pub(super) fn check<'tcx>(
     or_expr: &'tcx Expr<'_>,
     map_expr: &'tcx Expr<'_>,
 ) {
-    if_chain! {
-        if let Some(method_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
-        if let Some(impl_id) = cx.tcx.impl_of_method(method_id);
-        if is_type_diagnostic_item(cx, cx.tcx.type_of(impl_id).instantiate_identity(), sym::Option);
-        if let ExprKind::Call(err_path, [err_arg]) = or_expr.kind;
-        if is_res_lang_ctor(cx, path_res(cx, err_path), ResultErr);
-        if is_ok_wrapping(cx, map_expr);
-        if let Some(recv_snippet) = snippet_opt(cx, recv.span);
-        if let Some(err_arg_snippet) = snippet_opt(cx, err_arg.span);
-        if let Some(indent) = indent_of(cx, expr.span);
-        then {
-            let reindented_err_arg_snippet = reindent_multiline(err_arg_snippet.into(), true, Some(indent + 4));
-            span_lint_and_sugg(
-                cx,
-                MANUAL_OK_OR,
-                expr.span,
-                "this pattern reimplements `Option::ok_or`",
-                "replace with",
-                format!(
-                    "{recv_snippet}.ok_or({reindented_err_arg_snippet})"
-                ),
-                Applicability::MachineApplicable,
-            );
-        }
+    if let Some(method_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id)
+        && let Some(impl_id) = cx.tcx.impl_of_method(method_id)
+        && is_type_diagnostic_item(cx, cx.tcx.type_of(impl_id).instantiate_identity(), sym::Option)
+        && let ExprKind::Call(err_path, [err_arg]) = or_expr.kind
+        && is_res_lang_ctor(cx, path_res(cx, err_path), ResultErr)
+        && is_ok_wrapping(cx, map_expr)
+        && let Some(recv_snippet) = snippet_opt(cx, recv.span)
+        && let Some(err_arg_snippet) = snippet_opt(cx, err_arg.span)
+        && let Some(indent) = indent_of(cx, expr.span)
+    {
+        let reindented_err_arg_snippet = reindent_multiline(err_arg_snippet.into(), true, Some(indent + 4));
+        span_lint_and_sugg(
+            cx,
+            MANUAL_OK_OR,
+            expr.span,
+            "this pattern reimplements `Option::ok_or`",
+            "replace with",
+            format!(
+                "{recv_snippet}.ok_or({reindented_err_arg_snippet})"
+            ),
+            Applicability::MachineApplicable,
+        );
     }
 }
 
diff --git a/clippy_lints/src/methods/manual_saturating_arithmetic.rs b/clippy_lints/src/methods/manual_saturating_arithmetic.rs
index 540425eef8c..464d4c37a87 100644
--- a/clippy_lints/src/methods/manual_saturating_arithmetic.rs
+++ b/clippy_lints/src/methods/manual_saturating_arithmetic.rs
@@ -69,16 +69,14 @@ enum MinMax {
 
 fn is_min_or_max(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> Option<MinMax> {
     // `T::max_value()` `T::min_value()` inherent methods
-    if_chain! {
-        if let hir::ExprKind::Call(func, args) = &expr.kind;
-        if args.is_empty();
-        if let hir::ExprKind::Path(hir::QPath::TypeRelative(_, segment)) = &func.kind;
-        then {
-            match segment.ident.as_str() {
-                "max_value" => return Some(MinMax::Max),
-                "min_value" => return Some(MinMax::Min),
-                _ => {}
-            }
+    if let hir::ExprKind::Call(func, args) = &expr.kind
+        && args.is_empty()
+        && let hir::ExprKind::Path(hir::QPath::TypeRelative(_, segment)) = &func.kind
+    {
+        match segment.ident.as_str() {
+            "max_value" => return Some(MinMax::Max),
+            "min_value" => return Some(MinMax::Min),
+            _ => {}
         }
     }
 
diff --git a/clippy_lints/src/methods/manual_str_repeat.rs b/clippy_lints/src/methods/manual_str_repeat.rs
index ab13d30d845..5b4517f3d6c 100644
--- a/clippy_lints/src/methods/manual_str_repeat.rs
+++ b/clippy_lints/src/methods/manual_str_repeat.rs
@@ -55,43 +55,41 @@ pub(super) fn check(
     take_self_arg: &Expr<'_>,
     take_arg: &Expr<'_>,
 ) {
-    if_chain! {
-        if let ExprKind::Call(repeat_fn, [repeat_arg]) = take_self_arg.kind;
-        if is_path_diagnostic_item(cx, repeat_fn, sym::iter_repeat);
-        if is_type_lang_item(cx, cx.typeck_results().expr_ty(collect_expr), LangItem::String);
-        if let Some(take_id) = cx.typeck_results().type_dependent_def_id(take_expr.hir_id);
-        if let Some(iter_trait_id) = cx.tcx.get_diagnostic_item(sym::Iterator);
-        if cx.tcx.trait_of_item(take_id) == Some(iter_trait_id);
-        if let Some(repeat_kind) = parse_repeat_arg(cx, repeat_arg);
-        let ctxt = collect_expr.span.ctxt();
-        if ctxt == take_expr.span.ctxt();
-        if ctxt == take_self_arg.span.ctxt();
-        then {
-            let mut app = Applicability::MachineApplicable;
-            let count_snip = snippet_with_context(cx, take_arg.span, ctxt, "..", &mut app).0;
+    if let ExprKind::Call(repeat_fn, [repeat_arg]) = take_self_arg.kind
+        && is_path_diagnostic_item(cx, repeat_fn, sym::iter_repeat)
+        && is_type_lang_item(cx, cx.typeck_results().expr_ty(collect_expr), LangItem::String)
+        && let Some(take_id) = cx.typeck_results().type_dependent_def_id(take_expr.hir_id)
+        && let Some(iter_trait_id) = cx.tcx.get_diagnostic_item(sym::Iterator)
+        && cx.tcx.trait_of_item(take_id) == Some(iter_trait_id)
+        && let Some(repeat_kind) = parse_repeat_arg(cx, repeat_arg)
+        && let ctxt = collect_expr.span.ctxt()
+        && ctxt == take_expr.span.ctxt()
+        && ctxt == take_self_arg.span.ctxt()
+    {
+        let mut app = Applicability::MachineApplicable;
+        let count_snip = snippet_with_context(cx, take_arg.span, ctxt, "..", &mut app).0;
 
-            let val_str = match repeat_kind {
-                RepeatKind::Char(_) if repeat_arg.span.ctxt() != ctxt => return,
-                RepeatKind::Char('\'') => r#""'""#.into(),
-                RepeatKind::Char('"') => r#""\"""#.into(),
-                RepeatKind::Char(_) =>
-                    match snippet_with_applicability(cx, repeat_arg.span, "..", &mut app) {
-                        Cow::Owned(s) => Cow::Owned(format!("\"{}\"", &s[1..s.len() - 1])),
-                        s @ Cow::Borrowed(_) => s,
-                    },
-                RepeatKind::String =>
-                    Sugg::hir_with_context(cx, repeat_arg, ctxt, "..", &mut app).maybe_par().to_string().into(),
-            };
+        let val_str = match repeat_kind {
+            RepeatKind::Char(_) if repeat_arg.span.ctxt() != ctxt => return,
+            RepeatKind::Char('\'') => r#""'""#.into(),
+            RepeatKind::Char('"') => r#""\"""#.into(),
+            RepeatKind::Char(_) =>
+                match snippet_with_applicability(cx, repeat_arg.span, "..", &mut app) {
+                    Cow::Owned(s) => Cow::Owned(format!("\"{}\"", &s[1..s.len() - 1])),
+                    s @ Cow::Borrowed(_) => s,
+                },
+            RepeatKind::String =>
+                Sugg::hir_with_context(cx, repeat_arg, ctxt, "..", &mut app).maybe_par().to_string().into(),
+        };
 
-            span_lint_and_sugg(
-                cx,
-                MANUAL_STR_REPEAT,
-                collect_expr.span,
-                "manual implementation of `str::repeat` using iterators",
-                "try",
-                format!("{val_str}.repeat({count_snip})"),
-                app
-            )
-        }
+        span_lint_and_sugg(
+            cx,
+            MANUAL_STR_REPEAT,
+            collect_expr.span,
+            "manual implementation of `str::repeat` using iterators",
+            "try",
+            format!("{val_str}.repeat({count_snip})"),
+            app
+        )
     }
 }
diff --git a/clippy_lints/src/methods/map_clone.rs b/clippy_lints/src/methods/map_clone.rs
index e0f8cb1b955..417bcc41a28 100644
--- a/clippy_lints/src/methods/map_clone.rs
+++ b/clippy_lints/src/methods/map_clone.rs
@@ -16,57 +16,53 @@ use rustc_span::{sym, Span};
 use super::MAP_CLONE;
 
 pub(super) fn check(cx: &LateContext<'_>, e: &hir::Expr<'_>, recv: &hir::Expr<'_>, arg: &hir::Expr<'_>, msrv: &Msrv) {
-    if_chain! {
-        if let Some(method_id) = cx.typeck_results().type_dependent_def_id(e.hir_id);
-        if cx.tcx.impl_of_method(method_id)
+    if let Some(method_id) = cx.typeck_results().type_dependent_def_id(e.hir_id)
+        && (cx.tcx.impl_of_method(method_id)
             .map_or(false, |id| is_type_diagnostic_item(cx, cx.tcx.type_of(id).instantiate_identity(), sym::Option))
-            || is_diag_trait_item(cx, method_id, sym::Iterator);
-        if let hir::ExprKind::Closure(&hir::Closure{ body, .. }) = arg.kind;
-        then {
-            let closure_body = cx.tcx.hir().body(body);
-            let closure_expr = peel_blocks(closure_body.value);
-            match closure_body.params[0].pat.kind {
-                hir::PatKind::Ref(inner, hir::Mutability::Not) => if let hir::PatKind::Binding(
-                    hir::BindingAnnotation::NONE, .., name, None
-                ) = inner.kind {
-                    if ident_eq(name, closure_expr) {
-                        lint_explicit_closure(cx, e.span, recv.span, true, msrv);
-                    }
-                },
-                hir::PatKind::Binding(hir::BindingAnnotation::NONE, .., name, None) => {
-                    match closure_expr.kind {
-                        hir::ExprKind::Unary(hir::UnOp::Deref, inner) => {
-                            if ident_eq(name, inner) {
-                                if let ty::Ref(.., Mutability::Not) = cx.typeck_results().expr_ty(inner).kind() {
-                                    lint_explicit_closure(cx, e.span, recv.span, true, msrv);
-                                }
+            || is_diag_trait_item(cx, method_id, sym::Iterator))
+        && let hir::ExprKind::Closure(&hir::Closure{ body, .. }) = arg.kind
+    {
+        let closure_body = cx.tcx.hir().body(body);
+        let closure_expr = peel_blocks(closure_body.value);
+        match closure_body.params[0].pat.kind {
+            hir::PatKind::Ref(inner, hir::Mutability::Not) => if let hir::PatKind::Binding(
+                hir::BindingAnnotation::NONE, .., name, None
+            ) = inner.kind {
+                if ident_eq(name, closure_expr) {
+                    lint_explicit_closure(cx, e.span, recv.span, true, msrv);
+                }
+            },
+            hir::PatKind::Binding(hir::BindingAnnotation::NONE, .., name, None) => {
+                match closure_expr.kind {
+                    hir::ExprKind::Unary(hir::UnOp::Deref, inner) => {
+                        if ident_eq(name, inner) {
+                            if let ty::Ref(.., Mutability::Not) = cx.typeck_results().expr_ty(inner).kind() {
+                                lint_explicit_closure(cx, e.span, recv.span, true, msrv);
                             }
-                        },
-                        hir::ExprKind::MethodCall(method, obj, [], _) => if_chain! {
-                            if ident_eq(name, obj) && method.ident.name == sym::clone;
-                            if let Some(fn_id) = cx.typeck_results().type_dependent_def_id(closure_expr.hir_id);
-                            if let Some(trait_id) = cx.tcx.trait_of_item(fn_id);
-                            if cx.tcx.lang_items().clone_trait().map_or(false, |id| id == trait_id);
-                            // no autoderefs
-                            if !cx.typeck_results().expr_adjustments(obj).iter()
-                                .any(|a| matches!(a.kind, Adjust::Deref(Some(..))));
-                            then {
-                                let obj_ty = cx.typeck_results().expr_ty(obj);
-                                if let ty::Ref(_, ty, mutability) = obj_ty.kind() {
-                                    if matches!(mutability, Mutability::Not) {
-                                        let copy = is_copy(cx, *ty);
-                                        lint_explicit_closure(cx, e.span, recv.span, copy, msrv);
-                                    }
-                                } else {
-                                    lint_needless_cloning(cx, e.span, recv.span);
-                                }
+                        }
+                    },
+                    hir::ExprKind::MethodCall(method, obj, [], _) => if ident_eq(name, obj) && method.ident.name == sym::clone
+                        && let Some(fn_id) = cx.typeck_results().type_dependent_def_id(closure_expr.hir_id)
+                        && let Some(trait_id) = cx.tcx.trait_of_item(fn_id)
+                        && cx.tcx.lang_items().clone_trait().map_or(false, |id| id == trait_id)
+                        // no autoderefs
+                        && !cx.typeck_results().expr_adjustments(obj).iter()
+                            .any(|a| matches!(a.kind, Adjust::Deref(Some(..))))
+                    {
+                        let obj_ty = cx.typeck_results().expr_ty(obj);
+                        if let ty::Ref(_, ty, mutability) = obj_ty.kind() {
+                            if matches!(mutability, Mutability::Not) {
+                                let copy = is_copy(cx, *ty);
+                                lint_explicit_closure(cx, e.span, recv.span, copy, msrv);
                             }
-                        },
-                        _ => {},
-                    }
-                },
-                _ => {},
-            }
+                        } else {
+                            lint_needless_cloning(cx, e.span, recv.span);
+                        }
+                    },
+                    _ => {},
+                }
+            },
+            _ => {},
         }
     }
 }
diff --git a/clippy_lints/src/methods/map_collect_result_unit.rs b/clippy_lints/src/methods/map_collect_result_unit.rs
index 01cdd02e602..0f8cacc3435 100644
--- a/clippy_lints/src/methods/map_collect_result_unit.rs
+++ b/clippy_lints/src/methods/map_collect_result_unit.rs
@@ -13,26 +13,24 @@ use super::MAP_COLLECT_RESULT_UNIT;
 pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, iter: &hir::Expr<'_>, map_fn: &hir::Expr<'_>) {
     // return of collect `Result<(),_>`
     let collect_ret_ty = cx.typeck_results().expr_ty(expr);
-    if_chain! {
-        if is_type_diagnostic_item(cx, collect_ret_ty, sym::Result);
-        if let ty::Adt(_, args) = collect_ret_ty.kind();
-        if let Some(result_t) = args.types().next();
-        if result_t.is_unit();
+    if is_type_diagnostic_item(cx, collect_ret_ty, sym::Result)
+        && let ty::Adt(_, args) = collect_ret_ty.kind()
+        && let Some(result_t) = args.types().next()
+        && result_t.is_unit()
         // get parts for snippet
-        then {
-            span_lint_and_sugg(
-                cx,
-                MAP_COLLECT_RESULT_UNIT,
-                expr.span,
-                "`.map().collect()` can be replaced with `.try_for_each()`",
-                "try",
-                format!(
-                    "{}.try_for_each({})",
-                    snippet(cx, iter.span, ".."),
-                    snippet(cx, map_fn.span, "..")
-                ),
-                Applicability::MachineApplicable,
-            );
-        }
+    {
+        span_lint_and_sugg(
+            cx,
+            MAP_COLLECT_RESULT_UNIT,
+            expr.span,
+            "`.map().collect()` can be replaced with `.try_for_each()`",
+            "try",
+            format!(
+                "{}.try_for_each({})",
+                snippet(cx, iter.span, ".."),
+                snippet(cx, map_fn.span, "..")
+            ),
+            Applicability::MachineApplicable,
+        );
     }
 }
diff --git a/clippy_lints/src/methods/map_identity.rs b/clippy_lints/src/methods/map_identity.rs
index 57581363cfa..88545b7286c 100644
--- a/clippy_lints/src/methods/map_identity.rs
+++ b/clippy_lints/src/methods/map_identity.rs
@@ -19,22 +19,20 @@ pub(super) fn check(
 ) {
     let caller_ty = cx.typeck_results().expr_ty(caller);
 
-    if_chain! {
-        if is_trait_method(cx, expr, sym::Iterator)
+    if (is_trait_method(cx, expr, sym::Iterator)
             || is_type_diagnostic_item(cx, caller_ty, sym::Result)
-            || is_type_diagnostic_item(cx, caller_ty, sym::Option);
-        if is_expr_untyped_identity_function(cx, map_arg);
-        if let Some(sugg_span) = expr.span.trim_start(caller.span);
-        then {
-            span_lint_and_sugg(
-                cx,
-                MAP_IDENTITY,
-                sugg_span,
-                "unnecessary map of the identity function",
-                &format!("remove the call to `{name}`"),
-                String::new(),
-                Applicability::MachineApplicable,
-            )
-        }
+            || is_type_diagnostic_item(cx, caller_ty, sym::Option))
+        && is_expr_untyped_identity_function(cx, map_arg)
+        && let Some(sugg_span) = expr.span.trim_start(caller.span)
+    {
+        span_lint_and_sugg(
+            cx,
+            MAP_IDENTITY,
+            sugg_span,
+            "unnecessary map of the identity function",
+            &format!("remove the call to `{name}`"),
+            String::new(),
+            Applicability::MachineApplicable,
+        )
     }
 }
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index a71a136eba5..1664a313fa9 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3977,44 +3977,40 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             return;
         }
 
-        if_chain! {
-            if let TraitItemKind::Fn(ref sig, _) = item.kind;
-            if sig.decl.implicit_self.has_implicit_self();
-            if let Some(first_arg_hir_ty) = sig.decl.inputs.first();
-            if let Some(&first_arg_ty) = cx.tcx.fn_sig(item.owner_id)
+        if let TraitItemKind::Fn(ref sig, _) = item.kind
+            && sig.decl.implicit_self.has_implicit_self()
+            && let Some(first_arg_hir_ty) = sig.decl.inputs.first()
+            && let Some(&first_arg_ty) = cx.tcx.fn_sig(item.owner_id)
                 .instantiate_identity()
                 .inputs()
                 .skip_binder()
-                .first();
-            then {
-                let self_ty = TraitRef::identity(cx.tcx, item.owner_id.to_def_id()).self_ty();
-                wrong_self_convention::check(
-                    cx,
-                    item.ident.name.as_str(),
-                    self_ty,
-                    first_arg_ty,
-                    first_arg_hir_ty.span,
-                    false,
-                    true,
-                );
-            }
-        }
-
-        if_chain! {
-            if item.ident.name == sym::new;
-            if let TraitItemKind::Fn(_, _) = item.kind;
-            let ret_ty = return_ty(cx, item.owner_id);
+                .first()
+        {
             let self_ty = TraitRef::identity(cx.tcx, item.owner_id.to_def_id()).self_ty();
-            if !ret_ty.contains(self_ty);
+            wrong_self_convention::check(
+                cx,
+                item.ident.name.as_str(),
+                self_ty,
+                first_arg_ty,
+                first_arg_hir_ty.span,
+                false,
+                true,
+            );
+        }
 
-            then {
-                span_lint(
-                    cx,
-                    NEW_RET_NO_SELF,
-                    item.span,
-                    "methods called `new` usually return `Self`",
-                );
-            }
+        if item.ident.name == sym::new
+            && let TraitItemKind::Fn(_, _) = item.kind
+            && let ret_ty = return_ty(cx, item.owner_id)
+            && let self_ty = TraitRef::identity(cx.tcx, item.owner_id.to_def_id()).self_ty()
+            && !ret_ty.contains(self_ty)
+
+        {
+            span_lint(
+                cx,
+                NEW_RET_NO_SELF,
+                item.span,
+                "methods called `new` usually return `Self`",
+            );
         }
     }
 
diff --git a/clippy_lints/src/methods/mut_mutex_lock.rs b/clippy_lints/src/methods/mut_mutex_lock.rs
index 2855e23bf5b..15ce7c2eee6 100644
--- a/clippy_lints/src/methods/mut_mutex_lock.rs
+++ b/clippy_lints/src/methods/mut_mutex_lock.rs
@@ -11,22 +11,20 @@ use rustc_span::{sym, Span};
 use super::MUT_MUTEX_LOCK;
 
 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, ex: &'tcx Expr<'tcx>, recv: &'tcx Expr<'tcx>, name_span: Span) {
-    if_chain! {
-        if matches!(expr_custom_deref_adjustment(cx, recv), None | Some(Mutability::Mut));
-        if let ty::Ref(_, _, Mutability::Mut) = cx.typeck_results().expr_ty(recv).kind();
-        if let Some(method_id) = cx.typeck_results().type_dependent_def_id(ex.hir_id);
-        if let Some(impl_id) = cx.tcx.impl_of_method(method_id);
-        if is_type_diagnostic_item(cx, cx.tcx.type_of(impl_id).instantiate_identity(), sym::Mutex);
-        then {
-            span_lint_and_sugg(
-                cx,
-                MUT_MUTEX_LOCK,
-                name_span,
-                "calling `&mut Mutex::lock` unnecessarily locks an exclusive (mutable) reference",
-                "change this to",
-                "get_mut".to_owned(),
-                Applicability::MaybeIncorrect,
-            );
-        }
+    if matches!(expr_custom_deref_adjustment(cx, recv), None | Some(Mutability::Mut))
+        && let ty::Ref(_, _, Mutability::Mut) = cx.typeck_results().expr_ty(recv).kind()
+        && let Some(method_id) = cx.typeck_results().type_dependent_def_id(ex.hir_id)
+        && let Some(impl_id) = cx.tcx.impl_of_method(method_id)
+        && is_type_diagnostic_item(cx, cx.tcx.type_of(impl_id).instantiate_identity(), sym::Mutex)
+    {
+        span_lint_and_sugg(
+            cx,
+            MUT_MUTEX_LOCK,
+            name_span,
+            "calling `&mut Mutex::lock` unnecessarily locks an exclusive (mutable) reference",
+            "change this to",
+            "get_mut".to_owned(),
+            Applicability::MaybeIncorrect,
+        );
     }
 }
diff --git a/clippy_lints/src/methods/no_effect_replace.rs b/clippy_lints/src/methods/no_effect_replace.rs
index 01655e860c4..f6ba165a9a1 100644
--- a/clippy_lints/src/methods/no_effect_replace.rs
+++ b/clippy_lints/src/methods/no_effect_replace.rs
@@ -19,17 +19,15 @@ pub(super) fn check<'tcx>(
         return;
     }
 
-    if_chain! {
-        if let ExprKind::Lit(spanned) = &arg1.kind;
-        if let Some(param1) = lit_string_value(&spanned.node);
+    if let ExprKind::Lit(spanned) = &arg1.kind
+        && let Some(param1) = lit_string_value(&spanned.node)
 
-        if let ExprKind::Lit(spanned) = &arg2.kind;
-        if let LitKind::Str(param2, _) = &spanned.node;
-        if param1 == param2.as_str();
+        && let ExprKind::Lit(spanned) = &arg2.kind
+        && let LitKind::Str(param2, _) = &spanned.node
+        && param1 == param2.as_str()
 
-        then {
-            span_lint(cx, NO_EFFECT_REPLACE, expr.span, "replacing text with itself");
-        }
+    {
+        span_lint(cx, NO_EFFECT_REPLACE, expr.span, "replacing text with itself");
     }
 
     if SpanlessEq::new(cx).eq_expr(arg1, arg2) {
diff --git a/clippy_lints/src/methods/ok_expect.rs b/clippy_lints/src/methods/ok_expect.rs
index f2ef42933df..7c86c820a42 100644
--- a/clippy_lints/src/methods/ok_expect.rs
+++ b/clippy_lints/src/methods/ok_expect.rs
@@ -10,23 +10,21 @@ use super::OK_EXPECT;
 
 /// lint use of `ok().expect()` for `Result`s
 pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr<'_>) {
-    if_chain! {
+    if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(recv), sym::Result)
         // lint if the caller of `ok()` is a `Result`
-        if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(recv), sym::Result);
-        let result_type = cx.typeck_results().expr_ty(recv);
-        if let Some(error_type) = get_error_type(cx, result_type);
-        if has_debug_impl(cx, error_type);
+        && let result_type = cx.typeck_results().expr_ty(recv)
+        && let Some(error_type) = get_error_type(cx, result_type)
+        && has_debug_impl(cx, error_type)
 
-        then {
-            span_lint_and_help(
-                cx,
-                OK_EXPECT,
-                expr.span,
-                "called `ok().expect()` on a `Result` value",
-                None,
-                "you can call `expect()` directly on the `Result`",
-            );
-        }
+    {
+        span_lint_and_help(
+            cx,
+            OK_EXPECT,
+            expr.span,
+            "called `ok().expect()` on a `Result` value",
+            None,
+            "you can call `expect()` directly on the `Result`",
+        );
     }
 }
 
diff --git a/clippy_lints/src/methods/option_as_ref_deref.rs b/clippy_lints/src/methods/option_as_ref_deref.rs
index 7b81d4571b2..9463c39229d 100644
--- a/clippy_lints/src/methods/option_as_ref_deref.rs
+++ b/clippy_lints/src/methods/option_as_ref_deref.rs
@@ -58,34 +58,30 @@ pub(super) fn check(
 
             match &closure_expr.kind {
                 hir::ExprKind::MethodCall(_, receiver, [], _) => {
-                    if_chain! {
-                        if path_to_local_id(receiver, closure_body.params[0].pat.hir_id);
-                        let adj = cx
+                    if path_to_local_id(receiver, closure_body.params[0].pat.hir_id)
+                        && let adj = cx
                             .typeck_results()
                             .expr_adjustments(receiver)
                             .iter()
                             .map(|x| &x.kind)
-                            .collect::<Box<[_]>>();
-                        if let [ty::adjustment::Adjust::Deref(None), ty::adjustment::Adjust::Borrow(_)] = *adj;
-                        then {
-                            let method_did = cx.typeck_results().type_dependent_def_id(closure_expr.hir_id).unwrap();
-                            cx.tcx.is_diagnostic_item(sym::deref_method, method_did)
-                                || cx.tcx.is_diagnostic_item(sym::deref_mut_method, method_did)
-                                || deref_aliases.iter().any(|path| match_def_path(cx, method_did, path))
-                        } else {
-                            false
-                        }
+                            .collect::<Box<[_]>>()
+                        && let [ty::adjustment::Adjust::Deref(None), ty::adjustment::Adjust::Borrow(_)] = *adj
+                    {
+                        let method_did = cx.typeck_results().type_dependent_def_id(closure_expr.hir_id).unwrap();
+                        cx.tcx.is_diagnostic_item(sym::deref_method, method_did)
+                            || cx.tcx.is_diagnostic_item(sym::deref_mut_method, method_did)
+                            || deref_aliases.iter().any(|path| match_def_path(cx, method_did, path))
+                    } else {
+                        false
                     }
                 },
                 hir::ExprKind::AddrOf(hir::BorrowKind::Ref, m, inner) if same_mutability(m) => {
-                    if_chain! {
-                        if let hir::ExprKind::Unary(hir::UnOp::Deref, inner1) = inner.kind;
-                        if let hir::ExprKind::Unary(hir::UnOp::Deref, inner2) = inner1.kind;
-                        then {
-                            path_to_local_id(inner2, closure_body.params[0].pat.hir_id)
-                        } else {
-                            false
-                        }
+                    if let hir::ExprKind::Unary(hir::UnOp::Deref, inner1) = inner.kind
+                        && let hir::ExprKind::Unary(hir::UnOp::Deref, inner2) = inner1.kind
+                    {
+                        path_to_local_id(inner2, closure_body.params[0].pat.hir_id)
+                    } else {
+                        false
                     }
                 },
                 _ => false,
diff --git a/clippy_lints/src/methods/option_map_or_none.rs b/clippy_lints/src/methods/option_map_or_none.rs
index cb6a2306857..418e6a7d6a0 100644
--- a/clippy_lints/src/methods/option_map_or_none.rs
+++ b/clippy_lints/src/methods/option_map_or_none.rs
@@ -58,27 +58,25 @@ pub(super) fn check<'tcx>(
 
     if is_option {
         let self_snippet = snippet(cx, recv.span, "..");
-        if_chain! {
-            if let hir::ExprKind::Closure(&hir::Closure { body, fn_decl_span, .. }) = map_arg.kind;
-            let arg_snippet = snippet(cx, fn_decl_span, "..");
-            let body = cx.tcx.hir().body(body);
-            if let Some((func, [arg_char])) = reduce_unit_expression(body.value);
-            if let Some(id) = path_def_id(cx, func).map(|ctor_id| cx.tcx.parent(ctor_id));
-            if Some(id) == cx.tcx.lang_items().option_some_variant();
-            then {
-                let func_snippet = snippet(cx, arg_char.span, "..");
-                let msg = "called `map_or(None, ..)` on an `Option` value. This can be done more directly by calling \
-                   `map(..)` instead";
-                return span_lint_and_sugg(
-                    cx,
-                    OPTION_MAP_OR_NONE,
-                    expr.span,
-                    msg,
-                    "try using `map` instead",
-                    format!("{self_snippet}.map({arg_snippet} {func_snippet})"),
-                    Applicability::MachineApplicable,
-                );
-            }
+        if let hir::ExprKind::Closure(&hir::Closure { body, fn_decl_span, .. }) = map_arg.kind
+            && let arg_snippet = snippet(cx, fn_decl_span, "..")
+            && let body = cx.tcx.hir().body(body)
+            && let Some((func, [arg_char])) = reduce_unit_expression(body.value)
+            && let Some(id) = path_def_id(cx, func).map(|ctor_id| cx.tcx.parent(ctor_id))
+            && Some(id) == cx.tcx.lang_items().option_some_variant()
+        {
+            let func_snippet = snippet(cx, arg_char.span, "..");
+            let msg = "called `map_or(None, ..)` on an `Option` value. This can be done more directly by calling \
+               `map(..)` instead";
+            return span_lint_and_sugg(
+                cx,
+                OPTION_MAP_OR_NONE,
+                expr.span,
+                msg,
+                "try using `map` instead",
+                format!("{self_snippet}.map({arg_snippet} {func_snippet})"),
+                Applicability::MachineApplicable,
+            );
         }
 
         let func_snippet = snippet(cx, map_arg.span, "..");
diff --git a/clippy_lints/src/methods/or_fun_call.rs b/clippy_lints/src/methods/or_fun_call.rs
index b942346d5c3..6d970dbfab2 100644
--- a/clippy_lints/src/methods/or_fun_call.rs
+++ b/clippy_lints/src/methods/or_fun_call.rs
@@ -131,54 +131,52 @@ pub(super) fn check<'tcx>(
             (sym::Result, true, &["or", "unwrap_or"], "else"),
         ];
 
-        if_chain! {
-            if KNOW_TYPES.iter().any(|k| k.2.contains(&name));
-
-            if switch_to_lazy_eval(cx, arg);
-            if !contains_return(arg);
-
-            let self_ty = cx.typeck_results().expr_ty(self_expr);
-
-            if let Some(&(_, fn_has_arguments, poss, suffix)) =
-                KNOW_TYPES.iter().find(|&&i| is_type_diagnostic_item(cx, self_ty, i.0));
-
-            if poss.contains(&name);
-
-            then {
-                let ctxt = span.ctxt();
-                let mut app = Applicability::HasPlaceholders;
-                let sugg = {
-                    let (snippet_span, use_lambda) = match (fn_has_arguments, fun_span) {
-                        (false, Some(fun_span)) => (fun_span, false),
-                        _ => (arg.span, true),
-                    };
-
-                    let snip = snippet_with_context(cx, snippet_span, ctxt, "..", &mut app).0;
-                    let snip = if use_lambda {
-                        let l_arg = if fn_has_arguments { "_" } else { "" };
-                        format!("|{l_arg}| {snip}")
-                    } else {
-                        snip.into_owned()
-                    };
-
-                    if let Some(f) = second_arg {
-                        let f = snippet_with_context(cx, f.span, ctxt, "..", &mut app).0;
-                        format!("{snip}, {f}")
-                    } else {
-                        snip
-                    }
+        if KNOW_TYPES.iter().any(|k| k.2.contains(&name))
+
+            && switch_to_lazy_eval(cx, arg)
+            && !contains_return(arg)
+
+            && let self_ty = cx.typeck_results().expr_ty(self_expr)
+
+            && let Some(&(_, fn_has_arguments, poss, suffix)) =
+                KNOW_TYPES.iter().find(|&&i| is_type_diagnostic_item(cx, self_ty, i.0))
+
+            && poss.contains(&name)
+
+        {
+            let ctxt = span.ctxt();
+            let mut app = Applicability::HasPlaceholders;
+            let sugg = {
+                let (snippet_span, use_lambda) = match (fn_has_arguments, fun_span) {
+                    (false, Some(fun_span)) => (fun_span, false),
+                    _ => (arg.span, true),
                 };
-                let span_replace_word = method_span.with_hi(span.hi());
-                span_lint_and_sugg(
-                    cx,
-                    OR_FUN_CALL,
-                    span_replace_word,
-                    &format!("use of `{name}` followed by a function call"),
-                    "try",
-                    format!("{name}_{suffix}({sugg})"),
-                    app,
-                );
-            }
+
+                let snip = snippet_with_context(cx, snippet_span, ctxt, "..", &mut app).0;
+                let snip = if use_lambda {
+                    let l_arg = if fn_has_arguments { "_" } else { "" };
+                    format!("|{l_arg}| {snip}")
+                } else {
+                    snip.into_owned()
+                };
+
+                if let Some(f) = second_arg {
+                    let f = snippet_with_context(cx, f.span, ctxt, "..", &mut app).0;
+                    format!("{snip}, {f}")
+                } else {
+                    snip
+                }
+            };
+            let span_replace_word = method_span.with_hi(span.hi());
+            span_lint_and_sugg(
+                cx,
+                OR_FUN_CALL,
+                span_replace_word,
+                &format!("use of `{name}` followed by a function call"),
+                "try",
+                format!("{name}_{suffix}({sugg})"),
+                app,
+            );
         }
     }
 
diff --git a/clippy_lints/src/methods/path_buf_push_overwrite.rs b/clippy_lints/src/methods/path_buf_push_overwrite.rs
index 1c07d2a3a59..c292b93843b 100644
--- a/clippy_lints/src/methods/path_buf_push_overwrite.rs
+++ b/clippy_lints/src/methods/path_buf_push_overwrite.rs
@@ -11,27 +11,25 @@ use std::path::{Component, Path};
 use super::PATH_BUF_PUSH_OVERWRITE;
 
 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, arg: &'tcx Expr<'_>) {
-    if_chain! {
-        if let Some(method_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
-        if let Some(impl_id) = cx.tcx.impl_of_method(method_id);
-        if is_type_diagnostic_item(cx, cx.tcx.type_of(impl_id).instantiate_identity(), sym::PathBuf);
-        if let ExprKind::Lit(lit) = arg.kind;
-        if let LitKind::Str(ref path_lit, _) = lit.node;
-        if let pushed_path = Path::new(path_lit.as_str());
-        if let Some(pushed_path_lit) = pushed_path.to_str();
-        if pushed_path.has_root();
-        if let Some(root) = pushed_path.components().next();
-        if root == Component::RootDir;
-        then {
-            span_lint_and_sugg(
-                cx,
-                PATH_BUF_PUSH_OVERWRITE,
-                lit.span,
-                "calling `push` with '/' or '\\' (file system root) will overwrite the previous path definition",
-                "try",
-                format!("\"{}\"", pushed_path_lit.trim_start_matches(|c| c == '/' || c == '\\')),
-                Applicability::MachineApplicable,
-            );
-        }
+    if let Some(method_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id)
+        && let Some(impl_id) = cx.tcx.impl_of_method(method_id)
+        && is_type_diagnostic_item(cx, cx.tcx.type_of(impl_id).instantiate_identity(), sym::PathBuf)
+        && let ExprKind::Lit(lit) = arg.kind
+        && let LitKind::Str(ref path_lit, _) = lit.node
+        && let pushed_path = Path::new(path_lit.as_str())
+        && let Some(pushed_path_lit) = pushed_path.to_str()
+        && pushed_path.has_root()
+        && let Some(root) = pushed_path.components().next()
+        && root == Component::RootDir
+    {
+        span_lint_and_sugg(
+            cx,
+            PATH_BUF_PUSH_OVERWRITE,
+            lit.span,
+            "calling `push` with '/' or '\\' (file system root) will overwrite the previous path definition",
+            "try",
+            format!("\"{}\"", pushed_path_lit.trim_start_matches(|c| c == '/' || c == '\\')),
+            Applicability::MachineApplicable,
+        );
     }
 }
diff --git a/clippy_lints/src/methods/range_zip_with_len.rs b/clippy_lints/src/methods/range_zip_with_len.rs
index f253d8de91f..dabeba0b3c3 100644
--- a/clippy_lints/src/methods/range_zip_with_len.rs
+++ b/clippy_lints/src/methods/range_zip_with_len.rs
@@ -9,25 +9,23 @@ use rustc_span::sym;
 use super::RANGE_ZIP_WITH_LEN;
 
 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, recv: &'tcx Expr<'_>, zip_arg: &'tcx Expr<'_>) {
-    if_chain! {
-        if is_trait_method(cx, expr, sym::Iterator);
+    if is_trait_method(cx, expr, sym::Iterator)
         // range expression in `.zip()` call: `0..x.len()`
-        if let Some(higher::Range { start: Some(start), end: Some(end), .. }) = higher::Range::hir(zip_arg);
-        if is_integer_const(cx, start, 0);
+        && let Some(higher::Range { start: Some(start), end: Some(end), .. }) = higher::Range::hir(zip_arg)
+        && is_integer_const(cx, start, 0)
         // `.len()` call
-        if let ExprKind::MethodCall(len_path, len_recv, [], _) = end.kind;
-        if len_path.ident.name == sym::len;
+        && let ExprKind::MethodCall(len_path, len_recv, [], _) = end.kind
+        && len_path.ident.name == sym::len
         // `.iter()` and `.len()` called on same `Path`
-        if let ExprKind::Path(QPath::Resolved(_, iter_path)) = recv.kind;
-        if let ExprKind::Path(QPath::Resolved(_, len_path)) = len_recv.kind;
-        if SpanlessEq::new(cx).eq_path_segments(iter_path.segments, len_path.segments);
-        then {
-            span_lint(cx,
-                RANGE_ZIP_WITH_LEN,
-                expr.span,
-                &format!("it is more idiomatic to use `{}.iter().enumerate()`",
-                    snippet(cx, recv.span, "_"))
-            );
-        }
+        && let ExprKind::Path(QPath::Resolved(_, iter_path)) = recv.kind
+        && let ExprKind::Path(QPath::Resolved(_, len_path)) = len_recv.kind
+        && SpanlessEq::new(cx).eq_path_segments(iter_path.segments, len_path.segments)
+    {
+        span_lint(cx,
+            RANGE_ZIP_WITH_LEN,
+            expr.span,
+            &format!("it is more idiomatic to use `{}.iter().enumerate()`",
+                snippet(cx, recv.span, "_"))
+        );
     }
 }
diff --git a/clippy_lints/src/methods/search_is_some.rs b/clippy_lints/src/methods/search_is_some.rs
index 04ddaaa2f46..01dc28a4076 100644
--- a/clippy_lints/src/methods/search_is_some.rs
+++ b/clippy_lints/src/methods/search_is_some.rs
@@ -35,29 +35,27 @@ pub(super) fn check<'tcx>(
             // suggest `any(|x| ..)` instead of `any(|&x| ..)` for `find(|&x| ..).is_some()`
             // suggest `any(|..| *..)` instead of `any(|..| **..)` for `find(|..| **..).is_some()`
             let mut applicability = Applicability::MachineApplicable;
-            let any_search_snippet = if_chain! {
-                if search_method == "find";
-                if let hir::ExprKind::Closure(&hir::Closure { body, .. }) = search_arg.kind;
-                let closure_body = cx.tcx.hir().body(body);
-                if let Some(closure_arg) = closure_body.params.first();
-                then {
-                    if let hir::PatKind::Ref(..) = closure_arg.pat.kind {
-                        Some(search_snippet.replacen('&', "", 1))
-                    } else if let PatKind::Binding(..) = strip_pat_refs(closure_arg.pat).kind {
-                        // `find()` provides a reference to the item, but `any` does not,
-                        // so we should fix item usages for suggestion
-                        if let Some(closure_sugg) = deref_closure_args(cx, search_arg) {
-                            applicability = closure_sugg.applicability;
-                            Some(closure_sugg.suggestion)
-                        } else {
-                            Some(search_snippet.to_string())
-                        }
+            let any_search_snippet = if search_method == "find"
+                && let hir::ExprKind::Closure(&hir::Closure { body, .. }) = search_arg.kind
+                && let closure_body = cx.tcx.hir().body(body)
+                && let Some(closure_arg) = closure_body.params.first()
+            {
+                if let hir::PatKind::Ref(..) = closure_arg.pat.kind {
+                    Some(search_snippet.replacen('&', "", 1))
+                } else if let PatKind::Binding(..) = strip_pat_refs(closure_arg.pat).kind {
+                    // `find()` provides a reference to the item, but `any` does not,
+                    // so we should fix item usages for suggestion
+                    if let Some(closure_sugg) = deref_closure_args(cx, search_arg) {
+                        applicability = closure_sugg.applicability;
+                        Some(closure_sugg.suggestion)
                     } else {
-                        None
+                        Some(search_snippet.to_string())
                     }
                 } else {
                     None
                 }
+            } else {
+                None
             };
             // add note if not multi-line
             if is_some {
@@ -110,41 +108,39 @@ pub(super) fn check<'tcx>(
                 self_ty.is_str()
             }
         };
-        if_chain! {
-            if is_string_or_str_slice(search_recv);
-            if is_string_or_str_slice(search_arg);
-            then {
-                let msg = format!("called `{option_check_method}()` after calling `find()` on a string");
-                match option_check_method {
-                    "is_some" => {
-                        let mut applicability = Applicability::MachineApplicable;
-                        let find_arg = snippet_with_applicability(cx, search_arg.span, "..", &mut applicability);
-                        span_lint_and_sugg(
-                            cx,
-                            SEARCH_IS_SOME,
-                            method_span.with_hi(expr.span.hi()),
-                            &msg,
-                            "use `contains()` instead",
-                            format!("contains({find_arg})"),
-                            applicability,
-                        );
-                    },
-                    "is_none" => {
-                        let string = snippet(cx, search_recv.span, "..");
-                        let mut applicability = Applicability::MachineApplicable;
-                        let find_arg = snippet_with_applicability(cx, search_arg.span, "..", &mut applicability);
-                        span_lint_and_sugg(
-                            cx,
-                            SEARCH_IS_SOME,
-                            expr.span,
-                            &msg,
-                            "use `!_.contains()` instead",
-                            format!("!{string}.contains({find_arg})"),
-                            applicability,
-                        );
-                    },
-                    _ => (),
-                }
+        if is_string_or_str_slice(search_recv)
+            && is_string_or_str_slice(search_arg)
+        {
+            let msg = format!("called `{option_check_method}()` after calling `find()` on a string");
+            match option_check_method {
+                "is_some" => {
+                    let mut applicability = Applicability::MachineApplicable;
+                    let find_arg = snippet_with_applicability(cx, search_arg.span, "..", &mut applicability);
+                    span_lint_and_sugg(
+                        cx,
+                        SEARCH_IS_SOME,
+                        method_span.with_hi(expr.span.hi()),
+                        &msg,
+                        "use `contains()` instead",
+                        format!("contains({find_arg})"),
+                        applicability,
+                    );
+                },
+                "is_none" => {
+                    let string = snippet(cx, search_recv.span, "..");
+                    let mut applicability = Applicability::MachineApplicable;
+                    let find_arg = snippet_with_applicability(cx, search_arg.span, "..", &mut applicability);
+                    span_lint_and_sugg(
+                        cx,
+                        SEARCH_IS_SOME,
+                        expr.span,
+                        &msg,
+                        "use `!_.contains()` instead",
+                        format!("!{string}.contains({find_arg})"),
+                        applicability,
+                    );
+                },
+                _ => (),
             }
         }
     }
diff --git a/clippy_lints/src/methods/single_char_pattern.rs b/clippy_lints/src/methods/single_char_pattern.rs
index 4d704ec39eb..d0b57bbf94e 100644
--- a/clippy_lints/src/methods/single_char_pattern.rs
+++ b/clippy_lints/src/methods/single_char_pattern.rs
@@ -45,24 +45,22 @@ pub(super) fn check(
     args: &[hir::Expr<'_>],
 ) {
     for &(method, pos) in &PATTERN_METHODS {
-        if_chain! {
-            if let ty::Ref(_, ty, _) = cx.typeck_results().expr_ty_adjusted(receiver).kind();
-            if ty.is_str();
-            if method_name.as_str() == method && args.len() > pos;
-            let arg = &args[pos];
-            let mut applicability = Applicability::MachineApplicable;
-            if let Some(hint) = get_hint_if_single_char_arg(cx, arg, &mut applicability);
-            then {
-                span_lint_and_sugg(
-                    cx,
-                    SINGLE_CHAR_PATTERN,
-                    arg.span,
-                    "single-character string constant used as pattern",
-                    "try using a `char` instead",
-                    hint,
-                    applicability,
-                );
-            }
+        if let ty::Ref(_, ty, _) = cx.typeck_results().expr_ty_adjusted(receiver).kind()
+            && ty.is_str()
+            && method_name.as_str() == method && args.len() > pos
+            && let arg = &args[pos]
+            && let mut applicability = Applicability::MachineApplicable
+            && let Some(hint) = get_hint_if_single_char_arg(cx, arg, &mut applicability)
+        {
+            span_lint_and_sugg(
+                cx,
+                SINGLE_CHAR_PATTERN,
+                arg.span,
+                "single-character string constant used as pattern",
+                "try using a `char` instead",
+                hint,
+                applicability,
+            );
         }
     }
 }
diff --git a/clippy_lints/src/methods/str_splitn.rs b/clippy_lints/src/methods/str_splitn.rs
index 9da61bca52c..c6b79876115 100644
--- a/clippy_lints/src/methods/str_splitn.rs
+++ b/clippy_lints/src/methods/str_splitn.rs
@@ -286,21 +286,19 @@ fn parse_iter_usage<'tcx>(
             match (name.ident.as_str(), args) {
                 ("next", []) if cx.tcx.trait_of_item(did) == Some(iter_id) => (IterUsageKind::Nth(0), e.span),
                 ("next_tuple", []) => {
-                    return if_chain! {
-                        if match_def_path(cx, did, &paths::ITERTOOLS_NEXT_TUPLE);
-                        if let ty::Adt(adt_def, subs) = cx.typeck_results().expr_ty(e).kind();
-                        if cx.tcx.is_diagnostic_item(sym::Option, adt_def.did());
-                        if let ty::Tuple(subs) = subs.type_at(0).kind();
-                        if subs.len() == 2;
-                        then {
-                            Some(IterUsage {
-                                kind: IterUsageKind::NextTuple,
-                                span: e.span,
-                                unwrap_kind: None
-                            })
-                        } else {
-                            None
-                        }
+                    return if match_def_path(cx, did, &paths::ITERTOOLS_NEXT_TUPLE)
+                        && let ty::Adt(adt_def, subs) = cx.typeck_results().expr_ty(e).kind()
+                        && cx.tcx.is_diagnostic_item(sym::Option, adt_def.did())
+                        && let ty::Tuple(subs) = subs.type_at(0).kind()
+                        && subs.len() == 2
+                    {
+                        Some(IterUsage {
+                            kind: IterUsageKind::NextTuple,
+                            span: e.span,
+                            unwrap_kind: None
+                        })
+                    } else {
+                        None
                     };
                 },
                 ("nth" | "skip", [idx_expr]) if cx.tcx.trait_of_item(did) == Some(iter_id) => {
@@ -308,18 +306,16 @@ fn parse_iter_usage<'tcx>(
                         let span = if name.ident.as_str() == "nth" {
                             e.span
                         } else {
-                            if_chain! {
-                                if let Some((_, Node::Expr(next_expr))) = iter.next();
-                                if let ExprKind::MethodCall(next_name, _, [], _) = next_expr.kind;
-                                if next_name.ident.name == sym::next;
-                                if next_expr.span.ctxt() == ctxt;
-                                if let Some(next_id) = cx.typeck_results().type_dependent_def_id(next_expr.hir_id);
-                                if cx.tcx.trait_of_item(next_id) == Some(iter_id);
-                                then {
-                                    next_expr.span
-                                } else {
-                                    return None;
-                                }
+                            if let Some((_, Node::Expr(next_expr))) = iter.next()
+                                && let ExprKind::MethodCall(next_name, _, [], _) = next_expr.kind
+                                && next_name.ident.name == sym::next
+                                && next_expr.span.ctxt() == ctxt
+                                && let Some(next_id) = cx.typeck_results().type_dependent_def_id(next_expr.hir_id)
+                                && cx.tcx.trait_of_item(next_id) == Some(iter_id)
+                            {
+                                next_expr.span
+                            } else {
+                                return None;
                             }
                         };
                         (IterUsageKind::Nth(idx), span)
diff --git a/clippy_lints/src/methods/suspicious_map.rs b/clippy_lints/src/methods/suspicious_map.rs
index 0dc7fe2a2c5..909f2fa6bfc 100644
--- a/clippy_lints/src/methods/suspicious_map.rs
+++ b/clippy_lints/src/methods/suspicious_map.rs
@@ -9,26 +9,24 @@ use rustc_span::sym;
 use super::SUSPICIOUS_MAP;
 
 pub fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, count_recv: &hir::Expr<'_>, map_arg: &hir::Expr<'_>) {
-    if_chain! {
-        if is_trait_method(cx, count_recv, sym::Iterator);
-        if let hir::ExprKind::Closure(closure) = expr_or_init(cx, map_arg).kind;
-        let closure_body = cx.tcx.hir().body(closure.body);
-        if !cx.typeck_results().expr_ty(closure_body.value).is_unit();
-        then {
-            if let Some(map_mutated_vars) = mutated_variables(closure_body.value, cx) {
-                // A variable is used mutably inside of the closure. Suppress the lint.
-                if !map_mutated_vars.is_empty() {
-                    return;
-                }
+    if is_trait_method(cx, count_recv, sym::Iterator)
+        && let hir::ExprKind::Closure(closure) = expr_or_init(cx, map_arg).kind
+        && let closure_body = cx.tcx.hir().body(closure.body)
+        && !cx.typeck_results().expr_ty(closure_body.value).is_unit()
+    {
+        if let Some(map_mutated_vars) = mutated_variables(closure_body.value, cx) {
+            // A variable is used mutably inside of the closure. Suppress the lint.
+            if !map_mutated_vars.is_empty() {
+                return;
             }
-            span_lint_and_help(
-                cx,
-                SUSPICIOUS_MAP,
-                expr.span,
-                "this call to `map()` won't have an effect on the call to `count()`",
-                None,
-                "make sure you did not confuse `map` with `filter`, `for_each` or `inspect`",
-            );
         }
+        span_lint_and_help(
+            cx,
+            SUSPICIOUS_MAP,
+            expr.span,
+            "this call to `map()` won't have an effect on the call to `count()`",
+            None,
+            "make sure you did not confuse `map` with `filter`, `for_each` or `inspect`",
+        );
     }
 }
diff --git a/clippy_lints/src/methods/suspicious_splitn.rs b/clippy_lints/src/methods/suspicious_splitn.rs
index 3cb2719e4a0..873968b6417 100644
--- a/clippy_lints/src/methods/suspicious_splitn.rs
+++ b/clippy_lints/src/methods/suspicious_splitn.rs
@@ -8,41 +8,39 @@ use rustc_span::source_map::Spanned;
 use super::SUSPICIOUS_SPLITN;
 
 pub(super) fn check(cx: &LateContext<'_>, method_name: &str, expr: &Expr<'_>, self_arg: &Expr<'_>, count: u128) {
-    if_chain! {
-        if count <= 1;
-        if let Some(call_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
-        if let Some(impl_id) = cx.tcx.impl_of_method(call_id);
-        if cx.tcx.impl_trait_ref(impl_id).is_none();
-        let self_ty = cx.tcx.type_of(impl_id).instantiate_identity();
-        if self_ty.is_slice() || self_ty.is_str();
-        then {
-            // Ignore empty slice and string literals when used with a literal count.
-            if matches!(self_arg.kind, ExprKind::Array([]))
-                || matches!(self_arg.kind, ExprKind::Lit(Spanned { node: LitKind::Str(s, _), .. }) if s.is_empty())
-            {
-                return;
-            }
+    if count <= 1
+        && let Some(call_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id)
+        && let Some(impl_id) = cx.tcx.impl_of_method(call_id)
+        && cx.tcx.impl_trait_ref(impl_id).is_none()
+        && let self_ty = cx.tcx.type_of(impl_id).instantiate_identity()
+        && (self_ty.is_slice() || self_ty.is_str())
+    {
+        // Ignore empty slice and string literals when used with a literal count.
+        if matches!(self_arg.kind, ExprKind::Array([]))
+            || matches!(self_arg.kind, ExprKind::Lit(Spanned { node: LitKind::Str(s, _), .. }) if s.is_empty())
+        {
+            return;
+        }
 
-            let (msg, note_msg) = if count == 0 {
-                (format!("`{method_name}` called with `0` splits"),
-                "the resulting iterator will always return `None`")
+        let (msg, note_msg) = if count == 0 {
+            (format!("`{method_name}` called with `0` splits"),
+            "the resulting iterator will always return `None`")
+        } else {
+            (format!("`{method_name}` called with `1` split"),
+            if self_ty.is_slice() {
+                "the resulting iterator will always return the entire slice followed by `None`"
             } else {
-                (format!("`{method_name}` called with `1` split"),
-                if self_ty.is_slice() {
-                    "the resulting iterator will always return the entire slice followed by `None`"
-                } else {
-                    "the resulting iterator will always return the entire string followed by `None`"
-                })
-            };
+                "the resulting iterator will always return the entire string followed by `None`"
+            })
+        };
 
-            span_lint_and_note(
-                cx,
-                SUSPICIOUS_SPLITN,
-                expr.span,
-                &msg,
-                None,
-                note_msg,
-            );
-        }
+        span_lint_and_note(
+            cx,
+            SUSPICIOUS_SPLITN,
+            expr.span,
+            &msg,
+            None,
+            note_msg,
+        );
     }
 }
diff --git a/clippy_lints/src/methods/suspicious_to_owned.rs b/clippy_lints/src/methods/suspicious_to_owned.rs
index 9eb8d6e6e78..f1ffa8fd808 100644
--- a/clippy_lints/src/methods/suspicious_to_owned.rs
+++ b/clippy_lints/src/methods/suspicious_to_owned.rs
@@ -12,40 +12,38 @@ use rustc_span::sym;
 use super::SUSPICIOUS_TO_OWNED;
 
 pub fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr<'_>) -> bool {
-    if_chain! {
-        if let Some(method_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
-        if is_diag_trait_item(cx, method_def_id, sym::ToOwned);
-        let input_type = cx.typeck_results().expr_ty(expr);
-        if let ty::Adt(adt, _) = cx.typeck_results().expr_ty(expr).kind();
-        if cx.tcx.is_diagnostic_item(sym::Cow, adt.did());
+    if let Some(method_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id)
+        && is_diag_trait_item(cx, method_def_id, sym::ToOwned)
+        && let input_type = cx.typeck_results().expr_ty(expr)
+        && let ty::Adt(adt, _) = cx.typeck_results().expr_ty(expr).kind()
+        && cx.tcx.is_diagnostic_item(sym::Cow, adt.did())
 
-        then {
-            let mut app = Applicability::MaybeIncorrect;
-            let recv_snip = snippet_with_context(cx, recv.span, expr.span.ctxt(), "..", &mut app).0;
-            span_lint_and_then(
-                cx,
-                SUSPICIOUS_TO_OWNED,
-                expr.span,
-                &with_forced_trimmed_paths!(format!(
-                    "this `to_owned` call clones the {input_type} itself and does not cause the {input_type} contents to become owned"
-                )),
-                |diag| {
-                    diag.span_suggestion(
-                        expr.span,
-                        "depending on intent, either make the Cow an Owned variant",
-                        format!("{recv_snip}.into_owned()"),
-                        app
-                    );
-                    diag.span_suggestion(
-                        expr.span,
-                        "or clone the Cow itself",
-                        format!("{recv_snip}.clone()"),
-                        app
-                    );
-                }
-            );
-            return true;
-        }
+    {
+        let mut app = Applicability::MaybeIncorrect;
+        let recv_snip = snippet_with_context(cx, recv.span, expr.span.ctxt(), "..", &mut app).0;
+        span_lint_and_then(
+            cx,
+            SUSPICIOUS_TO_OWNED,
+            expr.span,
+            &with_forced_trimmed_paths!(format!(
+                "this `to_owned` call clones the {input_type} itself and does not cause the {input_type} contents to become owned"
+            )),
+            |diag| {
+                diag.span_suggestion(
+                    expr.span,
+                    "depending on intent, either make the Cow an Owned variant",
+                    format!("{recv_snip}.into_owned()"),
+                    app
+                );
+                diag.span_suggestion(
+                    expr.span,
+                    "or clone the Cow itself",
+                    format!("{recv_snip}.clone()"),
+                    app
+                );
+            }
+        );
+        return true;
     }
     false
 }
diff --git a/clippy_lints/src/methods/uninit_assumed_init.rs b/clippy_lints/src/methods/uninit_assumed_init.rs
index bc9c518dbcf..fef309db462 100644
--- a/clippy_lints/src/methods/uninit_assumed_init.rs
+++ b/clippy_lints/src/methods/uninit_assumed_init.rs
@@ -10,18 +10,16 @@ use super::UNINIT_ASSUMED_INIT;
 
 /// lint for `MaybeUninit::uninit().assume_init()` (we already have the latter)
 pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr<'_>) {
-    if_chain! {
-        if let hir::ExprKind::Call(callee, args) = recv.kind;
-        if args.is_empty();
-        if is_path_diagnostic_item(cx, callee, sym::maybe_uninit_uninit);
-        if !is_uninit_value_valid_for_ty(cx, cx.typeck_results().expr_ty_adjusted(expr));
-        then {
-            span_lint(
-                cx,
-                UNINIT_ASSUMED_INIT,
-                expr.span,
-                "this call for this type may be undefined behavior"
-            );
-        }
+    if let hir::ExprKind::Call(callee, args) = recv.kind
+        && args.is_empty()
+        && is_path_diagnostic_item(cx, callee, sym::maybe_uninit_uninit)
+        && !is_uninit_value_valid_for_ty(cx, cx.typeck_results().expr_ty_adjusted(expr))
+    {
+        span_lint(
+            cx,
+            UNINIT_ASSUMED_INIT,
+            expr.span,
+            "this call for this type may be undefined behavior"
+        );
     }
 }
diff --git a/clippy_lints/src/methods/unnecessary_fold.rs b/clippy_lints/src/methods/unnecessary_fold.rs
index 6e23754bf46..7694cd42beb 100644
--- a/clippy_lints/src/methods/unnecessary_fold.rs
+++ b/clippy_lints/src/methods/unnecessary_fold.rs
@@ -61,57 +61,55 @@ fn check_fold_with_op(
     op: hir::BinOpKind,
     replacement: Replacement,
 ) {
-    if_chain! {
+    if let hir::ExprKind::Closure(&hir::Closure { body, .. }) = acc.kind
         // Extract the body of the closure passed to fold
-        if let hir::ExprKind::Closure(&hir::Closure { body, .. }) = acc.kind;
-        let closure_body = cx.tcx.hir().body(body);
-        let closure_expr = peel_blocks(closure_body.value);
+        && let closure_body = cx.tcx.hir().body(body)
+        && let closure_expr = peel_blocks(closure_body.value)
 
         // Check if the closure body is of the form `acc <op> some_expr(x)`
-        if let hir::ExprKind::Binary(ref bin_op, left_expr, right_expr) = closure_expr.kind;
-        if bin_op.node == op;
+        && let hir::ExprKind::Binary(ref bin_op, left_expr, right_expr) = closure_expr.kind
+        && bin_op.node == op
 
         // Extract the names of the two arguments to the closure
-        if let [param_a, param_b] = closure_body.params;
-        if let PatKind::Binding(_, first_arg_id, ..) = strip_pat_refs(param_a.pat).kind;
-        if let PatKind::Binding(_, second_arg_id, second_arg_ident, _) = strip_pat_refs(param_b.pat).kind;
-
-        if path_to_local_id(left_expr, first_arg_id);
-        if replacement.has_args || path_to_local_id(right_expr, second_arg_id);
-
-        then {
-            let mut applicability = Applicability::MachineApplicable;
-
-            let turbofish = if replacement.has_generic_return {
-                format!("::<{}>", cx.typeck_results().expr_ty_adjusted(right_expr).peel_refs())
-            } else {
-                String::new()
-            };
-
-            let sugg = if replacement.has_args {
-                format!(
-                    "{method}{turbofish}(|{second_arg_ident}| {r})",
-                    method = replacement.method_name,
-                    r = snippet_with_applicability(cx, right_expr.span, "EXPR", &mut applicability),
-                )
-            } else {
-                format!(
-                    "{method}{turbofish}()",
-                    method = replacement.method_name,
-                )
-            };
-
-            span_lint_and_sugg(
-                cx,
-                UNNECESSARY_FOLD,
-                fold_span.with_hi(expr.span.hi()),
-                // TODO #2371 don't suggest e.g., .any(|x| f(x)) if we can suggest .any(f)
-                "this `.fold` can be written more succinctly using another method",
-                "try",
-                sugg,
-                applicability,
-            );
-        }
+        && let [param_a, param_b] = closure_body.params
+        && let PatKind::Binding(_, first_arg_id, ..) = strip_pat_refs(param_a.pat).kind
+        && let PatKind::Binding(_, second_arg_id, second_arg_ident, _) = strip_pat_refs(param_b.pat).kind
+
+        && path_to_local_id(left_expr, first_arg_id)
+        && (replacement.has_args || path_to_local_id(right_expr, second_arg_id))
+
+    {
+        let mut applicability = Applicability::MachineApplicable;
+
+        let turbofish = if replacement.has_generic_return {
+            format!("::<{}>", cx.typeck_results().expr_ty_adjusted(right_expr).peel_refs())
+        } else {
+            String::new()
+        };
+
+        let sugg = if replacement.has_args {
+            format!(
+                "{method}{turbofish}(|{second_arg_ident}| {r})",
+                method = replacement.method_name,
+                r = snippet_with_applicability(cx, right_expr.span, "EXPR", &mut applicability),
+            )
+        } else {
+            format!(
+                "{method}{turbofish}()",
+                method = replacement.method_name,
+            )
+        };
+
+        span_lint_and_sugg(
+            cx,
+            UNNECESSARY_FOLD,
+            fold_span.with_hi(expr.span.hi()),
+            // TODO #2371 don't suggest e.g., .any(|x| f(x)) if we can suggest .any(f)
+            "this `.fold` can be written more succinctly using another method",
+            "try",
+            sugg,
+            applicability,
+        );
     }
 }
 
diff --git a/clippy_lints/src/methods/unnecessary_iter_cloned.rs b/clippy_lints/src/methods/unnecessary_iter_cloned.rs
index 0c72c13a3ca..f55de39c10d 100644
--- a/clippy_lints/src/methods/unnecessary_iter_cloned.rs
+++ b/clippy_lints/src/methods/unnecessary_iter_cloned.rs
@@ -13,15 +13,13 @@ use rustc_span::{sym, Symbol};
 use super::UNNECESSARY_TO_OWNED;
 
 pub fn check(cx: &LateContext<'_>, expr: &Expr<'_>, method_name: Symbol, receiver: &Expr<'_>) -> bool {
-    if_chain! {
-        if let Some(parent) = get_parent_expr(cx, expr);
-        if let Some(callee_def_id) = fn_def_id(cx, parent);
-        if is_into_iter(cx, callee_def_id);
-        then {
-            check_for_loop_iter(cx, parent, method_name, receiver, false)
-        } else {
-            false
-        }
+    if let Some(parent) = get_parent_expr(cx, expr)
+        && let Some(callee_def_id) = fn_def_id(cx, parent)
+        && is_into_iter(cx, callee_def_id)
+    {
+        check_for_loop_iter(cx, parent, method_name, receiver, false)
+    } else {
+        false
     }
 }
 
@@ -36,65 +34,61 @@ pub fn check_for_loop_iter(
     receiver: &Expr<'_>,
     cloned_before_iter: bool,
 ) -> bool {
-    if_chain! {
-        if let Some(grandparent) = get_parent_expr(cx, expr).and_then(|parent| get_parent_expr(cx, parent));
-        if let Some(ForLoop { pat, body, .. }) = ForLoop::hir(grandparent);
-        let (clone_or_copy_needed, addr_of_exprs) = clone_or_copy_needed(cx, pat, body);
-        if !clone_or_copy_needed;
-        if let Some(receiver_snippet) = snippet_opt(cx, receiver.span);
-        then {
-            let snippet = if_chain! {
-                if let ExprKind::MethodCall(maybe_iter_method_name, collection, [], _) = receiver.kind;
-                if maybe_iter_method_name.ident.name == sym::iter;
+    if let Some(grandparent) = get_parent_expr(cx, expr).and_then(|parent| get_parent_expr(cx, parent))
+        && let Some(ForLoop { pat, body, .. }) = ForLoop::hir(grandparent)
+        && let (clone_or_copy_needed, addr_of_exprs) = clone_or_copy_needed(cx, pat, body)
+        && !clone_or_copy_needed
+        && let Some(receiver_snippet) = snippet_opt(cx, receiver.span)
+    {
+        let snippet = if let ExprKind::MethodCall(maybe_iter_method_name, collection, [], _) = receiver.kind
+            && maybe_iter_method_name.ident.name == sym::iter
 
-                if let Some(iterator_trait_id) = cx.tcx.get_diagnostic_item(sym::Iterator);
-                let receiver_ty = cx.typeck_results().expr_ty(receiver);
-                if implements_trait(cx, receiver_ty, iterator_trait_id, &[]);
-                if let Some(iter_item_ty) = get_iterator_item_ty(cx, receiver_ty);
+            && let Some(iterator_trait_id) = cx.tcx.get_diagnostic_item(sym::Iterator)
+            && let receiver_ty = cx.typeck_results().expr_ty(receiver)
+            && implements_trait(cx, receiver_ty, iterator_trait_id, &[])
+            && let Some(iter_item_ty) = get_iterator_item_ty(cx, receiver_ty)
 
-                if let Some(into_iterator_trait_id) = cx.tcx.get_diagnostic_item(sym::IntoIterator);
-                let collection_ty = cx.typeck_results().expr_ty(collection);
-                if implements_trait(cx, collection_ty, into_iterator_trait_id, &[]);
-                if let Some(into_iter_item_ty) = cx.get_associated_type(collection_ty, into_iterator_trait_id, "Item");
+            && let Some(into_iterator_trait_id) = cx.tcx.get_diagnostic_item(sym::IntoIterator)
+            && let collection_ty = cx.typeck_results().expr_ty(collection)
+            && implements_trait(cx, collection_ty, into_iterator_trait_id, &[])
+            && let Some(into_iter_item_ty) = cx.get_associated_type(collection_ty, into_iterator_trait_id, "Item")
 
-                if iter_item_ty == into_iter_item_ty;
-                if let Some(collection_snippet) = snippet_opt(cx, collection.span);
-                then {
-                    collection_snippet
+            && iter_item_ty == into_iter_item_ty
+            && let Some(collection_snippet) = snippet_opt(cx, collection.span)
+        {
+            collection_snippet
+        } else {
+            receiver_snippet
+        };
+        span_lint_and_then(
+            cx,
+            UNNECESSARY_TO_OWNED,
+            expr.span,
+            &format!("unnecessary use of `{method_name}`"),
+            |diag| {
+                // If `check_into_iter_call_arg` called `check_for_loop_iter` because a call to
+                // a `to_owned`-like function was removed, then the next suggestion may be
+                // incorrect. This is because the iterator that results from the call's removal
+                // could hold a reference to a resource that is used mutably. See
+                // https://github.com/rust-lang/rust-clippy/issues/8148.
+                let applicability = if cloned_before_iter {
+                    Applicability::MaybeIncorrect
                 } else {
-                    receiver_snippet
-                }
-            };
-            span_lint_and_then(
-                cx,
-                UNNECESSARY_TO_OWNED,
-                expr.span,
-                &format!("unnecessary use of `{method_name}`"),
-                |diag| {
-                    // If `check_into_iter_call_arg` called `check_for_loop_iter` because a call to
-                    // a `to_owned`-like function was removed, then the next suggestion may be
-                    // incorrect. This is because the iterator that results from the call's removal
-                    // could hold a reference to a resource that is used mutably. See
-                    // https://github.com/rust-lang/rust-clippy/issues/8148.
-                    let applicability = if cloned_before_iter {
-                        Applicability::MaybeIncorrect
-                    } else {
-                        Applicability::MachineApplicable
-                    };
-                    diag.span_suggestion(expr.span, "use", snippet, applicability);
-                    for addr_of_expr in addr_of_exprs {
-                        match addr_of_expr.kind {
-                            ExprKind::AddrOf(_, _, referent) => {
-                                let span = addr_of_expr.span.with_hi(referent.span.lo());
-                                diag.span_suggestion(span, "remove this `&`", "", applicability);
-                            }
-                            _ => unreachable!(),
+                    Applicability::MachineApplicable
+                };
+                diag.span_suggestion(expr.span, "use", snippet, applicability);
+                for addr_of_expr in addr_of_exprs {
+                    match addr_of_expr.kind {
+                        ExprKind::AddrOf(_, _, referent) => {
+                            let span = addr_of_expr.span.with_hi(referent.span.lo());
+                            diag.span_suggestion(span, "remove this `&`", "", applicability);
                         }
+                        _ => unreachable!(),
                     }
                 }
-            );
-            return true;
-        }
+            }
+        );
+        return true;
     }
     false
 }
diff --git a/clippy_lints/src/methods/unnecessary_join.rs b/clippy_lints/src/methods/unnecessary_join.rs
index d0c62fb56dc..e2b389e96da 100644
--- a/clippy_lints/src/methods/unnecessary_join.rs
+++ b/clippy_lints/src/methods/unnecessary_join.rs
@@ -18,25 +18,23 @@ pub(super) fn check<'tcx>(
 ) {
     let applicability = Applicability::MachineApplicable;
     let collect_output_adjusted_type = cx.typeck_results().expr_ty_adjusted(join_self_arg);
-    if_chain! {
+    if let Ref(_, ref_type, _) = collect_output_adjusted_type.kind()
         // the turbofish for collect is ::<Vec<String>>
-        if let Ref(_, ref_type, _) = collect_output_adjusted_type.kind();
-        if let Slice(slice) = ref_type.kind();
-        if is_type_lang_item(cx, *slice, LangItem::String);
+        && let Slice(slice) = ref_type.kind()
+        && is_type_lang_item(cx, *slice, LangItem::String)
         // the argument for join is ""
-        if let ExprKind::Lit(spanned) = &join_arg.kind;
-        if let LitKind::Str(symbol, _) = spanned.node;
-        if symbol.is_empty();
-        then {
-            span_lint_and_sugg(
-                cx,
-                UNNECESSARY_JOIN,
-                span.with_hi(expr.span.hi()),
-                r#"called `.collect::<Vec<String>>().join("")` on an iterator"#,
-                "try using",
-                "collect::<String>()".to_owned(),
-                applicability,
-            );
-        }
+        && let ExprKind::Lit(spanned) = &join_arg.kind
+        && let LitKind::Str(symbol, _) = spanned.node
+        && symbol.is_empty()
+    {
+        span_lint_and_sugg(
+            cx,
+            UNNECESSARY_JOIN,
+            span.with_hi(expr.span.hi()),
+            r#"called `.collect::<Vec<String>>().join("")` on an iterator"#,
+            "try using",
+            "collect::<String>()".to_owned(),
+            applicability,
+        );
     }
 }
diff --git a/clippy_lints/src/methods/unnecessary_sort_by.rs b/clippy_lints/src/methods/unnecessary_sort_by.rs
index 79bff39379c..b66e962017c 100644
--- a/clippy_lints/src/methods/unnecessary_sort_by.rs
+++ b/clippy_lints/src/methods/unnecessary_sort_by.rs
@@ -116,55 +116,51 @@ fn mirrored_exprs(a_expr: &Expr<'_>, a_ident: &Ident, b_expr: &Expr<'_>, b_ident
 }
 
 fn detect_lint(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'_>, arg: &Expr<'_>) -> Option<LintTrigger> {
-    if_chain! {
-        if let Some(method_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
-        if let Some(impl_id) = cx.tcx.impl_of_method(method_id);
-        if cx.tcx.type_of(impl_id).instantiate_identity().is_slice();
-        if let ExprKind::Closure(&Closure { body, .. }) = arg.kind;
-        if let closure_body = cx.tcx.hir().body(body);
-        if let &[
+    if let Some(method_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id)
+        && let Some(impl_id) = cx.tcx.impl_of_method(method_id)
+        && cx.tcx.type_of(impl_id).instantiate_identity().is_slice()
+        && let ExprKind::Closure(&Closure { body, .. }) = arg.kind
+        && let closure_body = cx.tcx.hir().body(body)
+        && let &[
             Param { pat: Pat { kind: PatKind::Binding(_, _, left_ident, _), .. }, ..},
             Param { pat: Pat { kind: PatKind::Binding(_, _, right_ident, _), .. }, .. }
-        ] = &closure_body.params;
-        if let ExprKind::MethodCall(method_path, left_expr, [right_expr], _) = closure_body.value.kind;
-        if method_path.ident.name == sym::cmp;
-        if is_trait_method(cx, closure_body.value, sym::Ord);
-        then {
-            let (closure_body, closure_arg, reverse) = if mirrored_exprs(
-                left_expr,
-                left_ident,
-                right_expr,
-                right_ident
-            ) {
-                (Sugg::hir(cx, left_expr, "..").to_string(), left_ident.name.to_string(), false)
-            } else if mirrored_exprs(left_expr, right_ident, right_expr, left_ident) {
-                (Sugg::hir(cx, left_expr, "..").to_string(), right_ident.name.to_string(), true)
-            } else {
-                return None;
-            };
-            let vec_name = Sugg::hir(cx, recv, "..").to_string();
+        ] = &closure_body.params
+        && let ExprKind::MethodCall(method_path, left_expr, [right_expr], _) = closure_body.value.kind
+        && method_path.ident.name == sym::cmp
+        && is_trait_method(cx, closure_body.value, sym::Ord)
+    {
+        let (closure_body, closure_arg, reverse) = if mirrored_exprs(
+            left_expr,
+            left_ident,
+            right_expr,
+            right_ident
+        ) {
+            (Sugg::hir(cx, left_expr, "..").to_string(), left_ident.name.to_string(), false)
+        } else if mirrored_exprs(left_expr, right_ident, right_expr, left_ident) {
+            (Sugg::hir(cx, left_expr, "..").to_string(), right_ident.name.to_string(), true)
+        } else {
+            return None;
+        };
+        let vec_name = Sugg::hir(cx, recv, "..").to_string();
 
-            if_chain! {
-                if let ExprKind::Path(QPath::Resolved(_, Path {
-                    segments: [PathSegment { ident: left_name, .. }], ..
-                })) = &left_expr.kind;
-                if left_name == left_ident;
-                if cx.tcx.get_diagnostic_item(sym::Ord).map_or(false, |id| {
-                    implements_trait(cx, cx.typeck_results().expr_ty(left_expr), id, &[])
-                });
-                then {
-                    return Some(LintTrigger::Sort(SortDetection { vec_name }));
-                }
-            }
+        if let ExprKind::Path(QPath::Resolved(_, Path {
+                segments: [PathSegment { ident: left_name, .. }], ..
+            })) = &left_expr.kind
+            && left_name == left_ident
+            && cx.tcx.get_diagnostic_item(sym::Ord).map_or(false, |id| {
+                implements_trait(cx, cx.typeck_results().expr_ty(left_expr), id, &[])
+            })
+        {
+            return Some(LintTrigger::Sort(SortDetection { vec_name }));
+        }
 
-            if !expr_borrows(cx, left_expr) {
-                return Some(LintTrigger::SortByKey(SortByKeyDetection {
-                    vec_name,
-                    closure_arg,
-                    closure_body,
-                    reverse,
-                }));
-            }
+        if !expr_borrows(cx, left_expr) {
+            return Some(LintTrigger::SortByKey(SortByKeyDetection {
+                vec_name,
+                closure_arg,
+                closure_body,
+                reverse,
+            }));
         }
     }
 
diff --git a/clippy_lints/src/methods/unnecessary_to_owned.rs b/clippy_lints/src/methods/unnecessary_to_owned.rs
index 772686d93dd..395b22ebc5d 100644
--- a/clippy_lints/src/methods/unnecessary_to_owned.rs
+++ b/clippy_lints/src/methods/unnecessary_to_owned.rs
@@ -32,25 +32,23 @@ pub fn check<'tcx>(
     args: &'tcx [Expr<'_>],
     msrv: &Msrv,
 ) {
-    if_chain! {
-        if let Some(method_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
-        if args.is_empty();
-        then {
-            if is_cloned_or_copied(cx, method_name, method_def_id) {
-                unnecessary_iter_cloned::check(cx, expr, method_name, receiver);
-            } else if is_to_owned_like(cx, expr, method_name, method_def_id) {
-                // At this point, we know the call is of a `to_owned`-like function. The functions
-                // `check_addr_of_expr` and `check_call_arg` determine whether the call is unnecessary
-                // based on its context, that is, whether it is a referent in an `AddrOf` expression, an
-                // argument in a `into_iter` call, or an argument in the call of some other function.
-                if check_addr_of_expr(cx, expr, method_name, method_def_id, receiver) {
-                    return;
-                }
-                if check_into_iter_call_arg(cx, expr, method_name, receiver, msrv) {
-                    return;
-                }
-                check_other_call_arg(cx, expr, method_name, receiver);
+    if let Some(method_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id)
+        && args.is_empty()
+    {
+        if is_cloned_or_copied(cx, method_name, method_def_id) {
+            unnecessary_iter_cloned::check(cx, expr, method_name, receiver);
+        } else if is_to_owned_like(cx, expr, method_name, method_def_id) {
+            // At this point, we know the call is of a `to_owned`-like function. The functions
+            // `check_addr_of_expr` and `check_call_arg` determine whether the call is unnecessary
+            // based on its context, that is, whether it is a referent in an `AddrOf` expression, an
+            // argument in a `into_iter` call, or an argument in the call of some other function.
+            if check_addr_of_expr(cx, expr, method_name, method_def_id, receiver) {
+                return;
             }
+            if check_into_iter_call_arg(cx, expr, method_name, receiver, msrv) {
+                return;
+            }
+            check_other_call_arg(cx, expr, method_name, receiver);
         }
     }
 }
@@ -65,11 +63,10 @@ fn check_addr_of_expr(
     method_def_id: DefId,
     receiver: &Expr<'_>,
 ) -> bool {
-    if_chain! {
-        if let Some(parent) = get_parent_expr(cx, expr);
-        if let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Not, _) = parent.kind;
-        let adjustments = cx.typeck_results().expr_adjustments(parent).iter().collect::<Vec<_>>();
-        if let
+    if let Some(parent) = get_parent_expr(cx, expr)
+        && let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Not, _) = parent.kind
+        && let adjustments = cx.typeck_results().expr_adjustments(parent).iter().collect::<Vec<_>>()
+        && let
             // For matching uses of `Cow::from`
             [
                 Adjustment {
@@ -110,10 +107,10 @@ fn check_addr_of_expr(
                     kind: Adjust::Borrow(_),
                     target: target_ty,
                 },
-            ] = adjustments[..];
-        let receiver_ty = cx.typeck_results().expr_ty(receiver);
-        let (target_ty, n_target_refs) = peel_mid_ty_refs(*target_ty);
-        let (receiver_ty, n_receiver_refs) = peel_mid_ty_refs(receiver_ty);
+            ] = adjustments[..]
+        && let receiver_ty = cx.typeck_results().expr_ty(receiver)
+        && let (target_ty, n_target_refs) = peel_mid_ty_refs(*target_ty)
+        && let (receiver_ty, n_receiver_refs) = peel_mid_ty_refs(receiver_ty)
         // Only flag cases satisfying at least one of the following three conditions:
         // * the referent and receiver types are distinct
         // * the referent/receiver type is a copyable array
@@ -123,77 +120,72 @@ fn check_addr_of_expr(
         //  https://github.com/rust-lang/rust-clippy/issues/8759
         //   Arrays are a bit of a corner case. Non-copyable arrays are handled by
         // `redundant_clone`, but copyable arrays are not.
-        if *referent_ty != receiver_ty
+        && (*referent_ty != receiver_ty
             || (matches!(referent_ty.kind(), ty::Array(..)) && is_copy(cx, *referent_ty))
-            || is_cow_into_owned(cx, method_name, method_def_id);
-        if let Some(receiver_snippet) = snippet_opt(cx, receiver.span);
-        then {
-            if receiver_ty == target_ty && n_target_refs >= n_receiver_refs {
+            || is_cow_into_owned(cx, method_name, method_def_id))
+        && let Some(receiver_snippet) = snippet_opt(cx, receiver.span)
+    {
+        if receiver_ty == target_ty && n_target_refs >= n_receiver_refs {
+            span_lint_and_sugg(
+                cx,
+                UNNECESSARY_TO_OWNED,
+                parent.span,
+                &format!("unnecessary use of `{method_name}`"),
+                "use",
+                format!(
+                    "{:&>width$}{receiver_snippet}",
+                    "",
+                    width = n_target_refs - n_receiver_refs
+                ),
+                Applicability::MachineApplicable,
+            );
+            return true;
+        }
+        if let Some(deref_trait_id) = cx.tcx.get_diagnostic_item(sym::Deref)
+            && implements_trait(cx, receiver_ty, deref_trait_id, &[])
+            && cx.get_associated_type(receiver_ty, deref_trait_id, "Target") == Some(target_ty)
+            // Make sure that it's actually calling the right `.to_string()`, (#10033)
+            // *or* this is a `Cow::into_owned()` call (which would be the wrong into_owned receiver (str != Cow)
+            // but that's ok for Cow::into_owned specifically)
+            && (cx.typeck_results().expr_ty_adjusted(receiver).peel_refs() == target_ty
+                || is_cow_into_owned(cx, method_name, method_def_id))
+        {
+            if n_receiver_refs > 0 {
                 span_lint_and_sugg(
                     cx,
                     UNNECESSARY_TO_OWNED,
                     parent.span,
                     &format!("unnecessary use of `{method_name}`"),
                     "use",
-                    format!(
-                        "{:&>width$}{receiver_snippet}",
-                        "",
-                        width = n_target_refs - n_receiver_refs
-                    ),
+                    receiver_snippet,
+                    Applicability::MachineApplicable,
+                );
+            } else {
+                span_lint_and_sugg(
+                    cx,
+                    UNNECESSARY_TO_OWNED,
+                    expr.span.with_lo(receiver.span.hi()),
+                    &format!("unnecessary use of `{method_name}`"),
+                    "remove this",
+                    String::new(),
                     Applicability::MachineApplicable,
                 );
-                return true;
-            }
-            if_chain! {
-                if let Some(deref_trait_id) = cx.tcx.get_diagnostic_item(sym::Deref);
-                if implements_trait(cx, receiver_ty, deref_trait_id, &[]);
-                if cx.get_associated_type(receiver_ty, deref_trait_id, "Target") == Some(target_ty);
-                // Make sure that it's actually calling the right `.to_string()`, (#10033)
-                // *or* this is a `Cow::into_owned()` call (which would be the wrong into_owned receiver (str != Cow)
-                // but that's ok for Cow::into_owned specifically)
-                if cx.typeck_results().expr_ty_adjusted(receiver).peel_refs() == target_ty
-                    || is_cow_into_owned(cx, method_name, method_def_id);
-                then {
-                    if n_receiver_refs > 0 {
-                        span_lint_and_sugg(
-                            cx,
-                            UNNECESSARY_TO_OWNED,
-                            parent.span,
-                            &format!("unnecessary use of `{method_name}`"),
-                            "use",
-                            receiver_snippet,
-                            Applicability::MachineApplicable,
-                        );
-                    } else {
-                        span_lint_and_sugg(
-                            cx,
-                            UNNECESSARY_TO_OWNED,
-                            expr.span.with_lo(receiver.span.hi()),
-                            &format!("unnecessary use of `{method_name}`"),
-                            "remove this",
-                            String::new(),
-                            Applicability::MachineApplicable,
-                        );
-                    }
-                    return true;
-                }
-            }
-            if_chain! {
-                if let Some(as_ref_trait_id) = cx.tcx.get_diagnostic_item(sym::AsRef);
-                if implements_trait(cx, receiver_ty, as_ref_trait_id, &[GenericArg::from(target_ty)]);
-                then {
-                    span_lint_and_sugg(
-                        cx,
-                        UNNECESSARY_TO_OWNED,
-                        parent.span,
-                        &format!("unnecessary use of `{method_name}`"),
-                        "use",
-                        format!("{receiver_snippet}.as_ref()"),
-                        Applicability::MachineApplicable,
-                    );
-                    return true;
-                }
             }
+            return true;
+        }
+        if let Some(as_ref_trait_id) = cx.tcx.get_diagnostic_item(sym::AsRef)
+            && implements_trait(cx, receiver_ty, as_ref_trait_id, &[GenericArg::from(target_ty)])
+        {
+            span_lint_and_sugg(
+                cx,
+                UNNECESSARY_TO_OWNED,
+                parent.span,
+                &format!("unnecessary use of `{method_name}`"),
+                "use",
+                format!("{receiver_snippet}.as_ref()"),
+                Applicability::MachineApplicable,
+            );
+            return true;
         }
     }
     false
@@ -208,38 +200,36 @@ fn check_into_iter_call_arg(
     receiver: &Expr<'_>,
     msrv: &Msrv,
 ) -> bool {
-    if_chain! {
-        if let Some(parent) = get_parent_expr(cx, expr);
-        if let Some(callee_def_id) = fn_def_id(cx, parent);
-        if is_into_iter(cx, callee_def_id);
-        if let Some(iterator_trait_id) = cx.tcx.get_diagnostic_item(sym::Iterator);
-        let parent_ty = cx.typeck_results().expr_ty(parent);
-        if implements_trait(cx, parent_ty, iterator_trait_id, &[]);
-        if let Some(item_ty) = get_iterator_item_ty(cx, parent_ty);
-        if let Some(receiver_snippet) = snippet_opt(cx, receiver.span);
-        then {
-            if unnecessary_iter_cloned::check_for_loop_iter(cx, parent, method_name, receiver, true) {
-                return true;
-            }
-            let cloned_or_copied = if is_copy(cx, item_ty) && msrv.meets(msrvs::ITERATOR_COPIED) {
-                "copied"
-            } else {
-                "cloned"
-            };
-            // The next suggestion may be incorrect because the removal of the `to_owned`-like
-            // function could cause the iterator to hold a reference to a resource that is used
-            // mutably. See https://github.com/rust-lang/rust-clippy/issues/8148.
-            span_lint_and_sugg(
-                cx,
-                UNNECESSARY_TO_OWNED,
-                parent.span,
-                &format!("unnecessary use of `{method_name}`"),
-                "use",
-                format!("{receiver_snippet}.iter().{cloned_or_copied}()"),
-                Applicability::MaybeIncorrect,
-            );
+    if let Some(parent) = get_parent_expr(cx, expr)
+        && let Some(callee_def_id) = fn_def_id(cx, parent)
+        && is_into_iter(cx, callee_def_id)
+        && let Some(iterator_trait_id) = cx.tcx.get_diagnostic_item(sym::Iterator)
+        && let parent_ty = cx.typeck_results().expr_ty(parent)
+        && implements_trait(cx, parent_ty, iterator_trait_id, &[])
+        && let Some(item_ty) = get_iterator_item_ty(cx, parent_ty)
+        && let Some(receiver_snippet) = snippet_opt(cx, receiver.span)
+    {
+        if unnecessary_iter_cloned::check_for_loop_iter(cx, parent, method_name, receiver, true) {
             return true;
         }
+        let cloned_or_copied = if is_copy(cx, item_ty) && msrv.meets(msrvs::ITERATOR_COPIED) {
+            "copied"
+        } else {
+            "cloned"
+        };
+        // The next suggestion may be incorrect because the removal of the `to_owned`-like
+        // function could cause the iterator to hold a reference to a resource that is used
+        // mutably. See https://github.com/rust-lang/rust-clippy/issues/8148.
+        span_lint_and_sugg(
+            cx,
+            UNNECESSARY_TO_OWNED,
+            parent.span,
+            &format!("unnecessary use of `{method_name}`"),
+            "use",
+            format!("{receiver_snippet}.iter().{cloned_or_copied}()"),
+            Applicability::MaybeIncorrect,
+        );
+        return true;
     }
     false
 }
@@ -252,26 +242,25 @@ fn check_other_call_arg<'tcx>(
     method_name: Symbol,
     receiver: &'tcx Expr<'tcx>,
 ) -> bool {
-    if_chain! {
-        if let Some((maybe_call, maybe_arg)) = skip_addr_of_ancestors(cx, expr);
-        if let Some((callee_def_id, _, recv, call_args)) = get_callee_generic_args_and_args(cx, maybe_call);
-        let fn_sig = cx.tcx.fn_sig(callee_def_id).instantiate_identity().skip_binder();
-        if let Some(i) = recv.into_iter().chain(call_args).position(|arg| arg.hir_id == maybe_arg.hir_id);
-        if let Some(input) = fn_sig.inputs().get(i);
-        let (input, n_refs) = peel_mid_ty_refs(*input);
-        if let (trait_predicates, _) = get_input_traits_and_projections(cx, callee_def_id, input);
-        if let Some(sized_def_id) = cx.tcx.lang_items().sized_trait();
-        if let [trait_predicate] = trait_predicates
+    if let Some((maybe_call, maybe_arg)) = skip_addr_of_ancestors(cx, expr)
+        && let Some((callee_def_id, _, recv, call_args)) = get_callee_generic_args_and_args(cx, maybe_call)
+        && let fn_sig = cx.tcx.fn_sig(callee_def_id).instantiate_identity().skip_binder()
+        && let Some(i) = recv.into_iter().chain(call_args).position(|arg| arg.hir_id == maybe_arg.hir_id)
+        && let Some(input) = fn_sig.inputs().get(i)
+        && let (input, n_refs) = peel_mid_ty_refs(*input)
+        && let (trait_predicates, _) = get_input_traits_and_projections(cx, callee_def_id, input)
+        && let Some(sized_def_id) = cx.tcx.lang_items().sized_trait()
+        && let [trait_predicate] = trait_predicates
             .iter()
             .filter(|trait_predicate| trait_predicate.def_id() != sized_def_id)
-            .collect::<Vec<_>>()[..];
-        if let Some(deref_trait_id) = cx.tcx.get_diagnostic_item(sym::Deref);
-        if let Some(as_ref_trait_id) = cx.tcx.get_diagnostic_item(sym::AsRef);
-        if trait_predicate.def_id() == deref_trait_id || trait_predicate.def_id() == as_ref_trait_id;
-        let receiver_ty = cx.typeck_results().expr_ty(receiver);
+            .collect::<Vec<_>>()[..]
+        && let Some(deref_trait_id) = cx.tcx.get_diagnostic_item(sym::Deref)
+        && let Some(as_ref_trait_id) = cx.tcx.get_diagnostic_item(sym::AsRef)
+        && (trait_predicate.def_id() == deref_trait_id || trait_predicate.def_id() == as_ref_trait_id)
+        && let receiver_ty = cx.typeck_results().expr_ty(receiver)
         // We can't add an `&` when the trait is `Deref` because `Target = &T` won't match
         // `Target = T`.
-        if let Some((n_refs, receiver_ty)) = if n_refs > 0 || is_copy(cx, receiver_ty) {
+        && let Some((n_refs, receiver_ty)) = if n_refs > 0 || is_copy(cx, receiver_ty) {
             Some((n_refs, receiver_ty))
         } else if trait_predicate.def_id() != deref_trait_id {
             Some((1, Ty::new_ref(cx.tcx,
@@ -283,21 +272,20 @@ fn check_other_call_arg<'tcx>(
             )))
         } else {
             None
-        };
-        if can_change_type(cx, maybe_arg, receiver_ty);
-        if let Some(receiver_snippet) = snippet_opt(cx, receiver.span);
-        then {
-            span_lint_and_sugg(
-                cx,
-                UNNECESSARY_TO_OWNED,
-                maybe_arg.span,
-                &format!("unnecessary use of `{method_name}`"),
-                "use",
-                format!("{:&>n_refs$}{receiver_snippet}", ""),
-                Applicability::MachineApplicable,
-            );
-            return true;
         }
+        && can_change_type(cx, maybe_arg, receiver_ty)
+        && let Some(receiver_snippet) = snippet_opt(cx, receiver.span)
+    {
+        span_lint_and_sugg(
+            cx,
+            UNNECESSARY_TO_OWNED,
+            maybe_arg.span,
+            &format!("unnecessary use of `{method_name}`"),
+            "use",
+            format!("{:&>n_refs$}{receiver_snippet}", ""),
+            Applicability::MachineApplicable,
+        );
+        return true;
     }
     false
 }
@@ -329,22 +317,18 @@ fn get_callee_generic_args_and_args<'tcx>(
     Option<&'tcx Expr<'tcx>>,
     &'tcx [Expr<'tcx>],
 )> {
-    if_chain! {
-        if let ExprKind::Call(callee, args) = expr.kind;
-        let callee_ty = cx.typeck_results().expr_ty(callee);
-        if let ty::FnDef(callee_def_id, _) = callee_ty.kind();
-        then {
-            let generic_args = cx.typeck_results().node_args(callee.hir_id);
-            return Some((*callee_def_id, generic_args, None, args));
-        }
+    if let ExprKind::Call(callee, args) = expr.kind
+        && let callee_ty = cx.typeck_results().expr_ty(callee)
+        && let ty::FnDef(callee_def_id, _) = callee_ty.kind()
+    {
+        let generic_args = cx.typeck_results().node_args(callee.hir_id);
+        return Some((*callee_def_id, generic_args, None, args));
     }
-    if_chain! {
-        if let ExprKind::MethodCall(_, recv, args, _) = expr.kind;
-        if let Some(method_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
-        then {
-            let generic_args = cx.typeck_results().node_args(expr.hir_id);
-            return Some((method_def_id, generic_args, Some(recv), args));
-        }
+    if let ExprKind::MethodCall(_, recv, args, _) = expr.kind
+        && let Some(method_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id)
+    {
+        let generic_args = cx.typeck_results().node_args(expr.hir_id);
+        return Some((method_def_id, generic_args, Some(recv), args));
     }
     None
 }
diff --git a/clippy_lints/src/methods/useless_asref.rs b/clippy_lints/src/methods/useless_asref.rs
index b5f810eddf4..c23966f95e9 100644
--- a/clippy_lints/src/methods/useless_asref.rs
+++ b/clippy_lints/src/methods/useless_asref.rs
@@ -22,13 +22,11 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, call_name: &str,
         let (base_rcv_ty, rcv_depth) = walk_ptrs_ty_depth(rcv_ty);
         if base_rcv_ty == base_res_ty && rcv_depth >= res_depth {
             // allow the `as_ref` or `as_mut` if it is followed by another method call
-            if_chain! {
-                if let Some(parent) = get_parent_expr(cx, expr);
-                if let hir::ExprKind::MethodCall(segment, ..) = parent.kind;
-                if segment.ident.span != expr.span;
-                then {
-                    return;
-                }
+            if let Some(parent) = get_parent_expr(cx, expr)
+                && let hir::ExprKind::MethodCall(segment, ..) = parent.kind
+                && segment.ident.span != expr.span
+            {
+                return;
             }
 
             let mut applicability = Applicability::MachineApplicable;
diff --git a/clippy_lints/src/methods/utils.rs b/clippy_lints/src/methods/utils.rs
index 9f1f73e6021..f776e055833 100644
--- a/clippy_lints/src/methods/utils.rs
+++ b/clippy_lints/src/methods/utils.rs
@@ -55,32 +55,30 @@ pub(super) fn get_hint_if_single_char_arg(
     arg: &hir::Expr<'_>,
     applicability: &mut Applicability,
 ) -> Option<String> {
-    if_chain! {
-        if let hir::ExprKind::Lit(lit) = &arg.kind;
-        if let ast::LitKind::Str(r, style) = lit.node;
-        let string = r.as_str();
-        if string.chars().count() == 1;
-        then {
-            let snip = snippet_with_applicability(cx, arg.span, string, applicability);
-            let ch = if let ast::StrStyle::Raw(nhash) = style {
-                let nhash = nhash as usize;
-                // for raw string: r##"a"##
-                &snip[(nhash + 2)..(snip.len() - 1 - nhash)]
-            } else {
-                // for regular string: "a"
-                &snip[1..(snip.len() - 1)]
-            };
+    if let hir::ExprKind::Lit(lit) = &arg.kind
+        && let ast::LitKind::Str(r, style) = lit.node
+        && let string = r.as_str()
+        && string.chars().count() == 1
+    {
+        let snip = snippet_with_applicability(cx, arg.span, string, applicability);
+        let ch = if let ast::StrStyle::Raw(nhash) = style {
+            let nhash = nhash as usize;
+            // for raw string: r##"a"##
+            &snip[(nhash + 2)..(snip.len() - 1 - nhash)]
+        } else {
+            // for regular string: "a"
+            &snip[1..(snip.len() - 1)]
+        };
 
-            let hint = format!("'{}'", match ch {
-                "'" => "\\'" ,
-                r"\" => "\\\\",
-                _ => ch,
-            });
+        let hint = format!("'{}'", match ch {
+            "'" => "\\'" ,
+            r"\" => "\\\\",
+            _ => ch,
+        });
 
-            Some(hint)
-        } else {
-            None
-        }
+        Some(hint)
+    } else {
+        None
     }
 }
 
@@ -140,15 +138,13 @@ impl<'cx, 'tcx> Visitor<'tcx> for CloneOrCopyVisitor<'cx, 'tcx> {
                         return;
                     },
                     ExprKind::MethodCall(.., args, _) => {
-                        if_chain! {
-                            if args.iter().all(|arg| !self.is_binding(arg));
-                            if let Some(method_def_id) = self.cx.typeck_results().type_dependent_def_id(parent.hir_id);
-                            let method_ty = self.cx.tcx.type_of(method_def_id).instantiate_identity();
-                            let self_ty = method_ty.fn_sig(self.cx.tcx).input(0).skip_binder();
-                            if matches!(self_ty.kind(), ty::Ref(_, _, Mutability::Not));
-                            then {
-                                return;
-                            }
+                        if args.iter().all(|arg| !self.is_binding(arg))
+                            && let Some(method_def_id) = self.cx.typeck_results().type_dependent_def_id(parent.hir_id)
+                            && let method_ty = self.cx.tcx.type_of(method_def_id).instantiate_identity()
+                            && let self_ty = method_ty.fn_sig(self.cx.tcx).input(0).skip_binder()
+                            && matches!(self_ty.kind(), ty::Ref(_, _, Mutability::Not))
+                        {
+                            return;
                         }
                     },
                     _ => {},
diff --git a/clippy_lints/src/methods/vec_resize_to_zero.rs b/clippy_lints/src/methods/vec_resize_to_zero.rs
index 73072718678..9f0507916e1 100644
--- a/clippy_lints/src/methods/vec_resize_to_zero.rs
+++ b/clippy_lints/src/methods/vec_resize_to_zero.rs
@@ -17,29 +17,27 @@ pub(super) fn check<'tcx>(
     default_arg: &'tcx Expr<'_>,
     name_span: Span,
 ) {
-    if_chain! {
-        if let Some(method_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
-        if let Some(impl_id) = cx.tcx.impl_of_method(method_id);
-        if is_type_diagnostic_item(cx, cx.tcx.type_of(impl_id).instantiate_identity(), sym::Vec);
-        if let ExprKind::Lit(Spanned { node: LitKind::Int(0, _), .. }) = count_arg.kind;
-        if let ExprKind::Lit(Spanned { node: LitKind::Int(..), .. }) = default_arg.kind;
-        then {
-            let method_call_span = expr.span.with_lo(name_span.lo());
-            span_lint_and_then(
-                cx,
-                VEC_RESIZE_TO_ZERO,
-                expr.span,
-                "emptying a vector with `resize`",
-                |db| {
-                    db.help("the arguments may be inverted...");
-                    db.span_suggestion(
-                        method_call_span,
-                        "...or you can empty the vector with",
-                        "clear()".to_string(),
-                        Applicability::MaybeIncorrect,
-                    );
-                },
-            );
-        }
+    if let Some(method_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id)
+        && let Some(impl_id) = cx.tcx.impl_of_method(method_id)
+        && is_type_diagnostic_item(cx, cx.tcx.type_of(impl_id).instantiate_identity(), sym::Vec)
+        && let ExprKind::Lit(Spanned { node: LitKind::Int(0, _), .. }) = count_arg.kind
+        && let ExprKind::Lit(Spanned { node: LitKind::Int(..), .. }) = default_arg.kind
+    {
+        let method_call_span = expr.span.with_lo(name_span.lo());
+        span_lint_and_then(
+            cx,
+            VEC_RESIZE_TO_ZERO,
+            expr.span,
+            "emptying a vector with `resize`",
+            |db| {
+                db.help("the arguments may be inverted...");
+                db.span_suggestion(
+                    method_call_span,
+                    "...or you can empty the vector with",
+                    "clear()".to_string(),
+                    Applicability::MaybeIncorrect,
+                );
+            },
+        );
     }
 }
diff --git a/clippy_lints/src/methods/zst_offset.rs b/clippy_lints/src/methods/zst_offset.rs
index e9f268da691..4f5cf734fa4 100644
--- a/clippy_lints/src/methods/zst_offset.rs
+++ b/clippy_lints/src/methods/zst_offset.rs
@@ -7,12 +7,10 @@ use rustc_middle::ty;
 use super::ZST_OFFSET;
 
 pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr<'_>) {
-    if_chain! {
-        if let ty::RawPtr(ty::TypeAndMut { ty, .. }) = cx.typeck_results().expr_ty(recv).kind();
-        if let Ok(layout) = cx.tcx.layout_of(cx.param_env.and(*ty));
-        if layout.is_zst();
-        then {
-            span_lint(cx, ZST_OFFSET, expr.span, "offset calculation on zero-sized value");
-        }
+    if let ty::RawPtr(ty::TypeAndMut { ty, .. }) = cx.typeck_results().expr_ty(recv).kind()
+        && let Ok(layout) = cx.tcx.layout_of(cx.param_env.and(*ty))
+        && layout.is_zst()
+    {
+        span_lint(cx, ZST_OFFSET, expr.span, "offset calculation on zero-sized value");
     }
 }
diff --git a/clippy_lints/src/misc.rs b/clippy_lints/src/misc.rs
index 01eace6c48c..ee58a47743d 100644
--- a/clippy_lints/src/misc.rs
+++ b/clippy_lints/src/misc.rs
@@ -143,73 +143,69 @@ impl<'tcx> LateLintPass<'tcx> for LintPass {
     }
 
     fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) {
-        if_chain! {
-            if !in_external_macro(cx.tcx.sess, stmt.span);
-            if let StmtKind::Local(local) = stmt.kind;
-            if let PatKind::Binding(BindingAnnotation(ByRef::Yes, mutabl), .., name, None) = local.pat.kind;
-            if let Some(init) = local.init;
+        if !in_external_macro(cx.tcx.sess, stmt.span)
+            && let StmtKind::Local(local) = stmt.kind
+            && let PatKind::Binding(BindingAnnotation(ByRef::Yes, mutabl), .., name, None) = local.pat.kind
+            && let Some(init) = local.init
             // Do not emit if clippy::ref_patterns is not allowed to avoid having two lints for the same issue.
-            if is_lint_allowed(cx, REF_PATTERNS, local.pat.hir_id);
-            then {
-                let ctxt = local.span.ctxt();
-                let mut app = Applicability::MachineApplicable;
-                let sugg_init = Sugg::hir_with_context(cx, init, ctxt, "..", &mut app);
-                let (mutopt, initref) = if mutabl == Mutability::Mut {
-                    ("mut ", sugg_init.mut_addr())
-                } else {
-                    ("", sugg_init.addr())
-                };
-                let tyopt = if let Some(ty) = local.ty {
-                    let ty_snip = snippet_with_context(cx, ty.span, ctxt, "_", &mut app).0;
-                    format!(": &{mutopt}{ty_snip}")
-                } else {
-                    String::new()
-                };
-                span_lint_hir_and_then(
-                    cx,
-                    TOPLEVEL_REF_ARG,
-                    init.hir_id,
-                    local.pat.span,
-                    "`ref` on an entire `let` pattern is discouraged, take a reference with `&` instead",
-                    |diag| {
-                        diag.span_suggestion(
-                            stmt.span,
-                            "try",
-                            format!(
-                                "let {name}{tyopt} = {initref};",
-                                name=snippet(cx, name.span, ".."),
-                            ),
-                            app,
-                        );
-                    }
-                );
-            }
+            && is_lint_allowed(cx, REF_PATTERNS, local.pat.hir_id)
+        {
+            let ctxt = local.span.ctxt();
+            let mut app = Applicability::MachineApplicable;
+            let sugg_init = Sugg::hir_with_context(cx, init, ctxt, "..", &mut app);
+            let (mutopt, initref) = if mutabl == Mutability::Mut {
+                ("mut ", sugg_init.mut_addr())
+            } else {
+                ("", sugg_init.addr())
+            };
+            let tyopt = if let Some(ty) = local.ty {
+                let ty_snip = snippet_with_context(cx, ty.span, ctxt, "_", &mut app).0;
+                format!(": &{mutopt}{ty_snip}")
+            } else {
+                String::new()
+            };
+            span_lint_hir_and_then(
+                cx,
+                TOPLEVEL_REF_ARG,
+                init.hir_id,
+                local.pat.span,
+                "`ref` on an entire `let` pattern is discouraged, take a reference with `&` instead",
+                |diag| {
+                    diag.span_suggestion(
+                        stmt.span,
+                        "try",
+                        format!(
+                            "let {name}{tyopt} = {initref};",
+                            name=snippet(cx, name.span, ".."),
+                        ),
+                        app,
+                    );
+                }
+            );
         };
-        if_chain! {
-            if let StmtKind::Semi(expr) = stmt.kind;
-            if let ExprKind::Binary(ref binop, a, b) = expr.kind;
-            if binop.node == BinOpKind::And || binop.node == BinOpKind::Or;
-            if let Some(sugg) = Sugg::hir_opt(cx, a);
-            then {
-                span_lint_hir_and_then(
-                    cx,
-                    SHORT_CIRCUIT_STATEMENT,
-                    expr.hir_id,
-                    stmt.span,
-                    "boolean short circuit operator in statement may be clearer using an explicit test",
-                    |diag| {
-                        let sugg = if binop.node == BinOpKind::Or { !sugg } else { sugg };
-                        diag.span_suggestion(
-                            stmt.span,
-                            "replace it with",
-                            format!(
-                                "if {sugg} {{ {}; }}",
-                                &snippet(cx, b.span, ".."),
-                            ),
-                            Applicability::MachineApplicable, // snippet
-                        );
-                    });
-            }
+        if let StmtKind::Semi(expr) = stmt.kind
+            && let ExprKind::Binary(ref binop, a, b) = expr.kind
+            && (binop.node == BinOpKind::And || binop.node == BinOpKind::Or)
+            && let Some(sugg) = Sugg::hir_opt(cx, a)
+        {
+            span_lint_hir_and_then(
+                cx,
+                SHORT_CIRCUIT_STATEMENT,
+                expr.hir_id,
+                stmt.span,
+                "boolean short circuit operator in statement may be clearer using an explicit test",
+                |diag| {
+                    let sugg = if binop.node == BinOpKind::Or { !sugg } else { sugg };
+                    diag.span_suggestion(
+                        stmt.span,
+                        "replace it with",
+                        format!(
+                            "if {sugg} {{ {}; }}",
+                            &snippet(cx, b.span, ".."),
+                        ),
+                        Applicability::MachineApplicable, // snippet
+                    );
+                });
         };
     }
 
diff --git a/clippy_lints/src/mismatching_type_param_order.rs b/clippy_lints/src/mismatching_type_param_order.rs
index 0d79ece087f..724f2c8e597 100644
--- a/clippy_lints/src/mismatching_type_param_order.rs
+++ b/clippy_lints/src/mismatching_type_param_order.rs
@@ -49,59 +49,57 @@ declare_lint_pass!(TypeParamMismatch => [MISMATCHING_TYPE_PARAM_ORDER]);
 
 impl<'tcx> LateLintPass<'tcx> for TypeParamMismatch {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
-        if_chain! {
-            if !item.span.from_expansion();
-            if let ItemKind::Impl(imp) = &item.kind;
-            if let TyKind::Path(QPath::Resolved(_, path)) = &imp.self_ty.kind;
-            if let Some(segment) = path.segments.iter().next();
-            if let Some(generic_args) = segment.args;
-            if !generic_args.args.is_empty();
-            then {
-                // get the name and span of the generic parameters in the Impl
-                let mut impl_params = Vec::new();
-                for p in generic_args.args {
-                    match p {
-                        GenericArg::Type(Ty {kind: TyKind::Path(QPath::Resolved(_, path)), ..}) =>
-                            impl_params.push((path.segments[0].ident.to_string(), path.span)),
-                        GenericArg::Type(_) => return,
-                        _ => (),
-                    };
-                }
-
-                // find the type that the Impl is for
-                // only lint on struct/enum/union for now
-                let Res::Def(DefKind::Struct | DefKind::Enum | DefKind::Union, defid) = path.res else {
-                    return
+        if !item.span.from_expansion()
+            && let ItemKind::Impl(imp) = &item.kind
+            && let TyKind::Path(QPath::Resolved(_, path)) = &imp.self_ty.kind
+            && let Some(segment) = path.segments.iter().next()
+            && let Some(generic_args) = segment.args
+            && !generic_args.args.is_empty()
+        {
+            // get the name and span of the generic parameters in the Impl
+            let mut impl_params = Vec::new();
+            for p in generic_args.args {
+                match p {
+                    GenericArg::Type(Ty {kind: TyKind::Path(QPath::Resolved(_, path)), ..}) =>
+                        impl_params.push((path.segments[0].ident.to_string(), path.span)),
+                    GenericArg::Type(_) => return,
+                    _ => (),
                 };
+            }
 
-                // get the names of the generic parameters in the type
-                let type_params = &cx.tcx.generics_of(defid).params;
-                let type_param_names: Vec<_> = type_params.iter()
-                .filter_map(|p|
-                    match p.kind {
-                        GenericParamDefKind::Type {..} => Some(p.name.to_string()),
-                        _ => None,
-                    }
-                ).collect();
-                // hashmap of name -> index for mismatch_param_name
-                let type_param_names_hashmap: FxHashMap<&String, usize> =
-                    type_param_names.iter().enumerate().map(|(i, param)| (param, i)).collect();
+            // find the type that the Impl is for
+            // only lint on struct/enum/union for now
+            let Res::Def(DefKind::Struct | DefKind::Enum | DefKind::Union, defid) = path.res else {
+                return
+            };
+
+            // get the names of the generic parameters in the type
+            let type_params = &cx.tcx.generics_of(defid).params;
+            let type_param_names: Vec<_> = type_params.iter()
+            .filter_map(|p|
+                match p.kind {
+                    GenericParamDefKind::Type {..} => Some(p.name.to_string()),
+                    _ => None,
+                }
+            ).collect();
+            // hashmap of name -> index for mismatch_param_name
+            let type_param_names_hashmap: FxHashMap<&String, usize> =
+                type_param_names.iter().enumerate().map(|(i, param)| (param, i)).collect();
 
-                let type_name = segment.ident;
-                for (i, (impl_param_name, impl_param_span)) in impl_params.iter().enumerate() {
-                    if mismatch_param_name(i, impl_param_name, &type_param_names_hashmap) {
-                        let msg = format!("`{type_name}` has a similarly named generic type parameter `{impl_param_name}` in its declaration, but in a different order");
-                        let help = format!("try `{}`, or a name that does not conflict with `{type_name}`'s generic params",
-                                           type_param_names[i]);
-                        span_lint_and_help(
-                            cx,
-                            MISMATCHING_TYPE_PARAM_ORDER,
-                            *impl_param_span,
-                            &msg,
-                            None,
-                            &help
-                        );
-                    }
+            let type_name = segment.ident;
+            for (i, (impl_param_name, impl_param_span)) in impl_params.iter().enumerate() {
+                if mismatch_param_name(i, impl_param_name, &type_param_names_hashmap) {
+                    let msg = format!("`{type_name}` has a similarly named generic type parameter `{impl_param_name}` in its declaration, but in a different order");
+                    let help = format!("try `{}`, or a name that does not conflict with `{type_name}`'s generic params",
+                                       type_param_names[i]);
+                    span_lint_and_help(
+                        cx,
+                        MISMATCHING_TYPE_PARAM_ORDER,
+                        *impl_param_span,
+                        &msg,
+                        None,
+                        &help
+                    );
                 }
             }
         }
diff --git a/clippy_lints/src/missing_doc.rs b/clippy_lints/src/missing_doc.rs
index 0629dee4f72..cfc4af35f33 100644
--- a/clippy_lints/src/missing_doc.rs
+++ b/clippy_lints/src/missing_doc.rs
@@ -64,16 +64,14 @@ impl MissingDoc {
     }
 
     fn has_include(meta: Option<MetaItem>) -> bool {
-        if_chain! {
-            if let Some(meta) = meta;
-            if let MetaItemKind::List(list) = meta.kind;
-            if let Some(meta) = list.first();
-            if let Some(name) = meta.ident();
-            then {
-                name.name == sym::include
-            } else {
-                false
-            }
+        if let Some(meta) = meta
+            && let MetaItemKind::List(list) = meta.kind
+            && let Some(meta) = list.first()
+            && let Some(name) = meta.ident()
+        {
+            name.name == sym::include
+        } else {
+            false
         }
     }
 
diff --git a/clippy_lints/src/missing_enforced_import_rename.rs b/clippy_lints/src/missing_enforced_import_rename.rs
index 16ff98a5922..1d07727f1c0 100644
--- a/clippy_lints/src/missing_enforced_import_rename.rs
+++ b/clippy_lints/src/missing_enforced_import_rename.rs
@@ -72,13 +72,12 @@ impl LateLintPass<'_> for ImportRename {
     fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
         if let ItemKind::Use(path, UseKind::Single) = &item.kind {
             for &res in &path.res {
-                if_chain! {
-                    if let Res::Def(_, id) = res;
-                    if let Some(name) = self.renames.get(&id);
+                if let Res::Def(_, id) = res
+                    && let Some(name) = self.renames.get(&id)
                     // Remove semicolon since it is not present for nested imports
-                    let span_without_semi = cx.sess().source_map().span_until_char(item.span, ';');
-                    if let Some(snip) = snippet_opt(cx, span_without_semi);
-                    if let Some(import) = match snip.split_once(" as ") {
+                    && let span_without_semi = cx.sess().source_map().span_until_char(item.span, ';')
+                    && let Some(snip) = snippet_opt(cx, span_without_semi)
+                    && let Some(import) = match snip.split_once(" as ") {
                         None => Some(snip.as_str()),
                         Some((import, rename)) => {
                             if rename.trim() == name.as_str() {
@@ -87,20 +86,19 @@ impl LateLintPass<'_> for ImportRename {
                                 Some(import.trim())
                             }
                         },
-                    };
-                    then {
-                        span_lint_and_sugg(
-                            cx,
-                            MISSING_ENFORCED_IMPORT_RENAMES,
-                            span_without_semi,
-                            "this import should be renamed",
-                            "try",
-                            format!(
-                                "{import} as {name}",
-                            ),
-                            Applicability::MachineApplicable,
-                        );
                     }
+                {
+                    span_lint_and_sugg(
+                        cx,
+                        MISSING_ENFORCED_IMPORT_RENAMES,
+                        span_without_semi,
+                        "this import should be renamed",
+                        "try",
+                        format!(
+                            "{import} as {name}",
+                        ),
+                        Applicability::MachineApplicable,
+                    );
                 }
             }
         }
diff --git a/clippy_lints/src/mixed_read_write_in_expression.rs b/clippy_lints/src/mixed_read_write_in_expression.rs
index 215161b04c7..9634b4357c2 100644
--- a/clippy_lints/src/mixed_read_write_in_expression.rs
+++ b/clippy_lints/src/mixed_read_write_in_expression.rs
@@ -80,12 +80,10 @@ declare_lint_pass!(EvalOrderDependence => [MIXED_READ_WRITE_IN_EXPRESSION, DIVER
 impl<'tcx> LateLintPass<'tcx> for EvalOrderDependence {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         // Find a write to a local variable.
-        let var = if_chain! {
-            if let ExprKind::Assign(lhs, ..) | ExprKind::AssignOp(_, lhs, _) = expr.kind;
-            if let Some(var) = path_to_local(lhs);
-            if expr.span.desugaring_kind().is_none();
-            then { var } else { return; }
-        };
+        let var = if let ExprKind::Assign(lhs, ..) | ExprKind::AssignOp(_, lhs, _) = expr.kind
+            && let Some(var) = path_to_local(lhs)
+            && expr.span.desugaring_kind().is_none()
+        { var } else { return; };
         let mut visitor = ReadVisitor {
             cx,
             var,
diff --git a/clippy_lints/src/needless_arbitrary_self_type.rs b/clippy_lints/src/needless_arbitrary_self_type.rs
index 97e8f1c030a..b6aafd35b58 100644
--- a/clippy_lints/src/needless_arbitrary_self_type.rs
+++ b/clippy_lints/src/needless_arbitrary_self_type.rs
@@ -66,48 +66,46 @@ enum Mode {
 }
 
 fn check_param_inner(cx: &EarlyContext<'_>, path: &Path, span: Span, binding_mode: &Mode, mutbl: Mutability) {
-    if_chain! {
-        if let [segment] = &path.segments[..];
-        if segment.ident.name == kw::SelfUpper;
-        then {
-            // In case we have a named lifetime, we check if the name comes from expansion.
-            // If it does, at this point we know the rest of the parameter was written by the user,
-            // so let them decide what the name of the lifetime should be.
-            // See #6089 for more details.
-            let mut applicability = Applicability::MachineApplicable;
-            let self_param = match (binding_mode, mutbl) {
-                (Mode::Ref(None), Mutability::Mut) => "&mut self".to_string(),
-                (Mode::Ref(Some(lifetime)), Mutability::Mut) => {
-                    if lifetime.ident.span.from_expansion() {
-                        applicability = Applicability::HasPlaceholders;
-                        "&'_ mut self".to_string()
-                    } else {
-                        format!("&{} mut self", &lifetime.ident.name)
-                    }
-                },
-                (Mode::Ref(None), Mutability::Not) => "&self".to_string(),
-                (Mode::Ref(Some(lifetime)), Mutability::Not) => {
-                    if lifetime.ident.span.from_expansion() {
-                        applicability = Applicability::HasPlaceholders;
-                        "&'_ self".to_string()
-                    } else {
-                        format!("&{} self", &lifetime.ident.name)
-                    }
-                },
-                (Mode::Value, Mutability::Mut) => "mut self".to_string(),
-                (Mode::Value, Mutability::Not) => "self".to_string(),
-            };
+    if let [segment] = &path.segments[..]
+        && segment.ident.name == kw::SelfUpper
+    {
+        // In case we have a named lifetime, we check if the name comes from expansion.
+        // If it does, at this point we know the rest of the parameter was written by the user,
+        // so let them decide what the name of the lifetime should be.
+        // See #6089 for more details.
+        let mut applicability = Applicability::MachineApplicable;
+        let self_param = match (binding_mode, mutbl) {
+            (Mode::Ref(None), Mutability::Mut) => "&mut self".to_string(),
+            (Mode::Ref(Some(lifetime)), Mutability::Mut) => {
+                if lifetime.ident.span.from_expansion() {
+                    applicability = Applicability::HasPlaceholders;
+                    "&'_ mut self".to_string()
+                } else {
+                    format!("&{} mut self", &lifetime.ident.name)
+                }
+            },
+            (Mode::Ref(None), Mutability::Not) => "&self".to_string(),
+            (Mode::Ref(Some(lifetime)), Mutability::Not) => {
+                if lifetime.ident.span.from_expansion() {
+                    applicability = Applicability::HasPlaceholders;
+                    "&'_ self".to_string()
+                } else {
+                    format!("&{} self", &lifetime.ident.name)
+                }
+            },
+            (Mode::Value, Mutability::Mut) => "mut self".to_string(),
+            (Mode::Value, Mutability::Not) => "self".to_string(),
+        };
 
-            span_lint_and_sugg(
-                cx,
-                NEEDLESS_ARBITRARY_SELF_TYPE,
-                span,
-                "the type of the `self` parameter does not need to be arbitrary",
-                "consider to change this parameter to",
-                self_param,
-                applicability,
-            )
-        }
+        span_lint_and_sugg(
+            cx,
+            NEEDLESS_ARBITRARY_SELF_TYPE,
+            span,
+            "the type of the `self` parameter does not need to be arbitrary",
+            "consider to change this parameter to",
+            self_param,
+            applicability,
+        )
     }
 }
 
@@ -125,12 +123,10 @@ impl EarlyLintPass for NeedlessArbitrarySelfType {
                 }
             },
             TyKind::Ref(lifetime, mut_ty) => {
-                if_chain! {
-                if let TyKind::Path(None, path) = &mut_ty.ty.kind;
-                if let PatKind::Ident(BindingAnnotation::NONE, _, _) = p.pat.kind;
-                    then {
-                        check_param_inner(cx, path, p.span.to(p.ty.span), &Mode::Ref(*lifetime), mut_ty.mutbl);
-                    }
+                if let TyKind::Path(None, path) = &mut_ty.ty.kind
+                && let PatKind::Ident(BindingAnnotation::NONE, _, _) = p.pat.kind
+                {
+                    check_param_inner(cx, path, p.span.to(p.ty.span), &Mode::Ref(*lifetime), mut_ty.mutbl);
                 }
             },
             _ => {},
diff --git a/clippy_lints/src/needless_continue.rs b/clippy_lints/src/needless_continue.rs
index cb2738947d4..6803034f475 100644
--- a/clippy_lints/src/needless_continue.rs
+++ b/clippy_lints/src/needless_continue.rs
@@ -362,21 +362,19 @@ fn suggestion_snippet_for_continue_inside_else(cx: &EarlyContext<'_>, data: &Lin
 }
 
 fn check_and_warn(cx: &EarlyContext<'_>, expr: &ast::Expr) {
-    if_chain! {
-        if let ast::ExprKind::Loop(loop_block, ..) = &expr.kind;
-        if let Some(last_stmt) = loop_block.stmts.last();
-        if let ast::StmtKind::Expr(inner_expr) | ast::StmtKind::Semi(inner_expr) = &last_stmt.kind;
-        if let ast::ExprKind::Continue(_) = inner_expr.kind;
-        then {
-            span_lint_and_help(
-                cx,
-                NEEDLESS_CONTINUE,
-                last_stmt.span,
-                MSG_REDUNDANT_CONTINUE_EXPRESSION,
-                None,
-                DROP_CONTINUE_EXPRESSION_MSG,
-            );
-        }
+    if let ast::ExprKind::Loop(loop_block, ..) = &expr.kind
+        && let Some(last_stmt) = loop_block.stmts.last()
+        && let ast::StmtKind::Expr(inner_expr) | ast::StmtKind::Semi(inner_expr) = &last_stmt.kind
+        && let ast::ExprKind::Continue(_) = inner_expr.kind
+    {
+        span_lint_and_help(
+            cx,
+            NEEDLESS_CONTINUE,
+            last_stmt.span,
+            MSG_REDUNDANT_CONTINUE_EXPRESSION,
+            None,
+            DROP_CONTINUE_EXPRESSION_MSG,
+        );
     }
     with_loop_block(expr, |loop_block, label| {
         for (i, stmt) in loop_block.stmts.iter().enumerate() {
diff --git a/clippy_lints/src/needless_for_each.rs b/clippy_lints/src/needless_for_each.rs
index 086c8e6fffe..42bce1ee276 100644
--- a/clippy_lints/src/needless_for_each.rs
+++ b/clippy_lints/src/needless_for_each.rs
@@ -52,65 +52,63 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessForEach {
             return;
         };
 
-        if_chain! {
+        if let ExprKind::MethodCall(method_name, for_each_recv, [for_each_arg], _) = expr.kind
             // Check the method name is `for_each`.
-            if let ExprKind::MethodCall(method_name, for_each_recv, [for_each_arg], _) = expr.kind;
-            if method_name.ident.name == Symbol::intern("for_each");
+            && method_name.ident.name == Symbol::intern("for_each")
             // Check `for_each` is an associated function of `Iterator`.
-            if is_trait_method(cx, expr, sym::Iterator);
+            && is_trait_method(cx, expr, sym::Iterator)
             // Checks the receiver of `for_each` is also a method call.
-            if let ExprKind::MethodCall(_, iter_recv, [], _) = for_each_recv.kind;
+            && let ExprKind::MethodCall(_, iter_recv, [], _) = for_each_recv.kind
             // Skip the lint if the call chain is too long. e.g. `v.field.iter().for_each()` or
             // `v.foo().iter().for_each()` must be skipped.
-            if matches!(
+            && matches!(
                 iter_recv.kind,
                 ExprKind::Array(..) | ExprKind::Call(..) | ExprKind::Path(..)
-            );
+            )
             // Checks the type of the `iter` method receiver is NOT a user defined type.
-            if has_iter_method(cx, cx.typeck_results().expr_ty(iter_recv)).is_some();
+            && has_iter_method(cx, cx.typeck_results().expr_ty(iter_recv)).is_some()
             // Skip the lint if the body is not block because this is simpler than `for` loop.
             // e.g. `v.iter().for_each(f)` is simpler and clearer than using `for` loop.
-            if let ExprKind::Closure(&Closure { body, .. }) = for_each_arg.kind;
-            let body = cx.tcx.hir().body(body);
-            if let ExprKind::Block(..) = body.value.kind;
-            then {
-                let mut ret_collector = RetCollector::default();
-                ret_collector.visit_expr(body.value);
-
-                // Skip the lint if `return` is used in `Loop` in order not to suggest using `'label`.
-                if ret_collector.ret_in_loop {
-                    return;
-                }
-
-                let (mut applicability, ret_suggs) = if ret_collector.spans.is_empty() {
-                    (Applicability::MachineApplicable, None)
-                } else {
-                    (
-                        Applicability::MaybeIncorrect,
-                        Some(
-                            ret_collector
-                                .spans
-                                .into_iter()
-                                .map(|span| (span, "continue".to_string()))
-                                .collect(),
-                        ),
-                    )
-                };
-
-                let sugg = format!(
-                    "for {} in {} {}",
-                    snippet_with_applicability(cx, body.params[0].pat.span, "..", &mut applicability),
-                    snippet_with_applicability(cx, for_each_recv.span, "..", &mut applicability),
-                    snippet_with_applicability(cx, body.value.span, "..", &mut applicability),
-                );
-
-                span_lint_and_then(cx, NEEDLESS_FOR_EACH, stmt.span, "needless use of `for_each`", |diag| {
-                    diag.span_suggestion(stmt.span, "try", sugg, applicability);
-                    if let Some(ret_suggs) = ret_suggs {
-                        diag.multipart_suggestion("...and replace `return` with `continue`", ret_suggs, applicability);
-                    }
-                })
+            && let ExprKind::Closure(&Closure { body, .. }) = for_each_arg.kind
+            && let body = cx.tcx.hir().body(body)
+            && let ExprKind::Block(..) = body.value.kind
+        {
+            let mut ret_collector = RetCollector::default();
+            ret_collector.visit_expr(body.value);
+
+            // Skip the lint if `return` is used in `Loop` in order not to suggest using `'label`.
+            if ret_collector.ret_in_loop {
+                return;
             }
+
+            let (mut applicability, ret_suggs) = if ret_collector.spans.is_empty() {
+                (Applicability::MachineApplicable, None)
+            } else {
+                (
+                    Applicability::MaybeIncorrect,
+                    Some(
+                        ret_collector
+                            .spans
+                            .into_iter()
+                            .map(|span| (span, "continue".to_string()))
+                            .collect(),
+                    ),
+                )
+            };
+
+            let sugg = format!(
+                "for {} in {} {}",
+                snippet_with_applicability(cx, body.params[0].pat.span, "..", &mut applicability),
+                snippet_with_applicability(cx, for_each_recv.span, "..", &mut applicability),
+                snippet_with_applicability(cx, body.value.span, "..", &mut applicability),
+            );
+
+            span_lint_and_then(cx, NEEDLESS_FOR_EACH, stmt.span, "needless use of `for_each`", |diag| {
+                diag.span_suggestion(stmt.span, "try", sugg, applicability);
+                if let Some(ret_suggs) = ret_suggs {
+                    diag.multipart_suggestion("...and replace `return` with `continue`", ret_suggs, applicability);
+                }
+            })
         }
     }
 }
diff --git a/clippy_lints/src/needless_late_init.rs b/clippy_lints/src/needless_late_init.rs
index c8888c744b6..886c0f3a430 100644
--- a/clippy_lints/src/needless_late_init.rs
+++ b/clippy_lints/src/needless_late_init.rs
@@ -128,21 +128,19 @@ impl LocalAssign {
         let assign = match expr.kind {
             ExprKind::Block(Block { expr: Some(expr), .. }, _) => Self::from_expr(expr, expr.span),
             ExprKind::Block(block, _) => {
-                if_chain! {
-                    if let Some((last, other_stmts)) = block.stmts.split_last();
-                    if let StmtKind::Expr(expr) | StmtKind::Semi(expr) = last.kind;
+                if let Some((last, other_stmts)) = block.stmts.split_last()
+                    && let StmtKind::Expr(expr) | StmtKind::Semi(expr) = last.kind
 
-                    let assign = Self::from_expr(expr, last.span)?;
+                    && let assign = Self::from_expr(expr, last.span)?
 
                     // avoid visiting if not needed
-                    if assign.lhs_id == binding_id;
-                    if other_stmts.iter().all(|stmt| !contains_assign_expr(cx, stmt));
+                    && assign.lhs_id == binding_id
+                    && other_stmts.iter().all(|stmt| !contains_assign_expr(cx, stmt))
 
-                    then {
-                        Some(assign)
-                    } else {
-                        None
-                    }
+                {
+                    Some(assign)
+                } else {
+                    None
                 }
             },
             ExprKind::Assign(..) => Self::from_expr(expr, expr.span),
@@ -368,8 +366,7 @@ fn check<'tcx>(
 impl<'tcx> LateLintPass<'tcx> for NeedlessLateInit {
     fn check_local(&mut self, cx: &LateContext<'tcx>, local: &'tcx Local<'tcx>) {
         let mut parents = cx.tcx.hir().parent_iter(local.hir_id);
-        if_chain! {
-            if let Local {
+        if let Local {
                 init: None,
                 pat: &Pat {
                     kind: PatKind::Binding(BindingAnnotation::NONE, binding_id, _, None),
@@ -377,13 +374,12 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessLateInit {
                 },
                 source: LocalSource::Normal,
                 ..
-            } = local;
-            if let Some((_, Node::Stmt(local_stmt))) = parents.next();
-            if let Some((_, Node::Block(block))) = parents.next();
+            } = local
+            && let Some((_, Node::Stmt(local_stmt))) = parents.next()
+            && let Some((_, Node::Block(block))) = parents.next()
 
-            then {
-                check(cx, local, local_stmt, block, binding_id);
-            }
+        {
+            check(cx, local, local_stmt, block, binding_id);
         }
     }
 }
diff --git a/clippy_lints/src/needless_parens_on_range_literals.rs b/clippy_lints/src/needless_parens_on_range_literals.rs
index 7bbf1fb4cd9..6d4a4ee603e 100644
--- a/clippy_lints/src/needless_parens_on_range_literals.rs
+++ b/clippy_lints/src/needless_parens_on_range_literals.rs
@@ -53,21 +53,19 @@ fn check_for_parens(cx: &LateContext<'_>, e: &Expr<'_>, is_start: bool) {
         // don't check floating point literals on the start expression of a range
         return;
     }
-    if_chain! {
-        if let ExprKind::Lit(literal) = e.kind;
+    if let ExprKind::Lit(literal) = e.kind
         // the indicator that parenthesis surround the literal is that the span of the expression and the literal differ
-        if (literal.span.data().hi - literal.span.data().lo) != (e.span.data().hi - e.span.data().lo);
+        && (literal.span.data().hi - literal.span.data().lo) != (e.span.data().hi - e.span.data().lo)
         // inspect the source code of the expression for parenthesis
-        if snippet_enclosed_in_parenthesis(&snippet(cx, e.span, ""));
-        then {
-            let mut applicability = Applicability::MachineApplicable;
-            span_lint_and_then(cx, NEEDLESS_PARENS_ON_RANGE_LITERALS, e.span,
-                "needless parenthesis on range literals can be removed",
-                |diag| {
-                    let suggestion = snippet_with_applicability(cx, literal.span, "_", &mut applicability);
-                    diag.span_suggestion(e.span, "try", suggestion, applicability);
-                });
-        }
+        && snippet_enclosed_in_parenthesis(&snippet(cx, e.span, ""))
+    {
+        let mut applicability = Applicability::MachineApplicable;
+        span_lint_and_then(cx, NEEDLESS_PARENS_ON_RANGE_LITERALS, e.span,
+            "needless parenthesis on range literals can be removed",
+            |diag| {
+                let suggestion = snippet_with_applicability(cx, literal.span, "_", &mut applicability);
+                diag.span_suggestion(e.span, "try", suggestion, applicability);
+            });
     }
 }
 
diff --git a/clippy_lints/src/needless_pass_by_value.rs b/clippy_lints/src/needless_pass_by_value.rs
index 8fa461ac12c..24b9eaac088 100644
--- a/clippy_lints/src/needless_pass_by_value.rs
+++ b/clippy_lints/src/needless_pass_by_value.rs
@@ -177,118 +177,114 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByValue {
                 )
             };
 
-            if_chain! {
-                if !is_self(arg);
-                if !ty.is_mutable_ptr();
-                if !is_copy(cx, ty);
-                if ty.is_sized(cx.tcx, cx.param_env);
-                if !allowed_traits.iter().any(|&t| implements_trait_with_env_from_iter(
+            if !is_self(arg)
+                && !ty.is_mutable_ptr()
+                && !is_copy(cx, ty)
+                && ty.is_sized(cx.tcx, cx.param_env)
+                && !allowed_traits.iter().any(|&t| implements_trait_with_env_from_iter(
                     cx.tcx,
                     cx.param_env,
                     ty,
                     t,
                     [Option::<ty::GenericArg<'tcx>>::None],
-                ));
-                if !implements_borrow_trait;
-                if !all_borrowable_trait;
-
-                if let PatKind::Binding(BindingAnnotation(_, Mutability::Not), canonical_id, ..) = arg.pat.kind;
-                if !moved_vars.contains(&canonical_id);
-                then {
-                    // Dereference suggestion
-                    let sugg = |diag: &mut Diagnostic| {
-                        if let ty::Adt(def, ..) = ty.kind() {
-                            if let Some(span) = cx.tcx.hir().span_if_local(def.did()) {
-                                if type_allowed_to_implement_copy(
-                                    cx.tcx,
-                                    cx.param_env,
-                                    ty,
-                                    traits::ObligationCause::dummy_with_span(span),
-                                ).is_ok() {
-                                    diag.span_help(span, "consider marking this type as `Copy`");
-                                }
+                ))
+                && !implements_borrow_trait
+                && !all_borrowable_trait
+
+                && let PatKind::Binding(BindingAnnotation(_, Mutability::Not), canonical_id, ..) = arg.pat.kind
+                && !moved_vars.contains(&canonical_id)
+            {
+                // Dereference suggestion
+                let sugg = |diag: &mut Diagnostic| {
+                    if let ty::Adt(def, ..) = ty.kind() {
+                        if let Some(span) = cx.tcx.hir().span_if_local(def.did()) {
+                            if type_allowed_to_implement_copy(
+                                cx.tcx,
+                                cx.param_env,
+                                ty,
+                                traits::ObligationCause::dummy_with_span(span),
+                            ).is_ok() {
+                                diag.span_help(span, "consider marking this type as `Copy`");
                             }
                         }
+                    }
 
-                        if_chain! {
-                            if is_type_diagnostic_item(cx, ty, sym::Vec);
-                            if let Some(clone_spans) =
-                                get_spans(cx, Some(body.id()), idx, &[("clone", ".to_owned()")]);
-                            if let TyKind::Path(QPath::Resolved(_, path)) = input.kind;
-                            if let Some(elem_ty) = path.segments.iter()
-                                .find(|seg| seg.ident.name == sym::Vec)
-                                .and_then(|ps| ps.args.as_ref())
-                                .map(|params| params.args.iter().find_map(|arg| match arg {
-                                    GenericArg::Type(ty) => Some(ty),
-                                    _ => None,
-                                }).unwrap());
-                            then {
-                                let slice_ty = format!("&[{}]", snippet(cx, elem_ty.span, "_"));
-                                diag.span_suggestion(
-                                    input.span,
-                                    "consider changing the type to",
-                                    slice_ty,
-                                    Applicability::Unspecified,
-                                );
-
-                                for (span, suggestion) in clone_spans {
-                                    diag.span_suggestion(
-                                        span,
-                                        snippet_opt(cx, span)
-                                            .map_or(
-                                                "change the call to".into(),
-                                                |x| format!("change `{x}` to"),
-                                            ),
-                                        suggestion,
-                                        Applicability::Unspecified,
-                                    );
-                                }
-
-                                // cannot be destructured, no need for `*` suggestion
-                                return;
-                            }
+                    if is_type_diagnostic_item(cx, ty, sym::Vec)
+                        && let Some(clone_spans) =
+                            get_spans(cx, Some(body.id()), idx, &[("clone", ".to_owned()")])
+                        && let TyKind::Path(QPath::Resolved(_, path)) = input.kind
+                        && let Some(elem_ty) = path.segments.iter()
+                            .find(|seg| seg.ident.name == sym::Vec)
+                            .and_then(|ps| ps.args.as_ref())
+                            .map(|params| params.args.iter().find_map(|arg| match arg {
+                                GenericArg::Type(ty) => Some(ty),
+                                _ => None,
+                            }).unwrap())
+                    {
+                        let slice_ty = format!("&[{}]", snippet(cx, elem_ty.span, "_"));
+                        diag.span_suggestion(
+                            input.span,
+                            "consider changing the type to",
+                            slice_ty,
+                            Applicability::Unspecified,
+                        );
+
+                        for (span, suggestion) in clone_spans {
+                            diag.span_suggestion(
+                                span,
+                                snippet_opt(cx, span)
+                                    .map_or(
+                                        "change the call to".into(),
+                                        |x| format!("change `{x}` to"),
+                                    ),
+                                suggestion,
+                                Applicability::Unspecified,
+                            );
                         }
 
-                        if is_type_lang_item(cx, ty, LangItem::String) {
-                            if let Some(clone_spans) =
-                                get_spans(cx, Some(body.id()), idx, &[("clone", ".to_string()"), ("as_str", "")]) {
+                        // cannot be destructured, no need for `*` suggestion
+                        return;
+                    }
+
+                    if is_type_lang_item(cx, ty, LangItem::String) {
+                        if let Some(clone_spans) =
+                            get_spans(cx, Some(body.id()), idx, &[("clone", ".to_string()"), ("as_str", "")]) {
+                            diag.span_suggestion(
+                                input.span,
+                                "consider changing the type to",
+                                "&str",
+                                Applicability::Unspecified,
+                            );
+
+                            for (span, suggestion) in clone_spans {
                                 diag.span_suggestion(
-                                    input.span,
-                                    "consider changing the type to",
-                                    "&str",
+                                    span,
+                                    snippet_opt(cx, span)
+                                        .map_or(
+                                            "change the call to".into(),
+                                            |x| format!("change `{x}` to")
+                                        ),
+                                    suggestion,
                                     Applicability::Unspecified,
                                 );
-
-                                for (span, suggestion) in clone_spans {
-                                    diag.span_suggestion(
-                                        span,
-                                        snippet_opt(cx, span)
-                                            .map_or(
-                                                "change the call to".into(),
-                                                |x| format!("change `{x}` to")
-                                            ),
-                                        suggestion,
-                                        Applicability::Unspecified,
-                                    );
-                                }
-
-                                return;
                             }
+
+                            return;
                         }
+                    }
 
-                        let spans = vec![(input.span, format!("&{}", snippet(cx, input.span, "_")))];
+                    let spans = vec![(input.span, format!("&{}", snippet(cx, input.span, "_")))];
 
-                        multispan_sugg(diag, "consider taking a reference instead", spans);
-                    };
+                    multispan_sugg(diag, "consider taking a reference instead", spans);
+                };
 
-                    span_lint_and_then(
-                        cx,
-                        NEEDLESS_PASS_BY_VALUE,
-                        input.span,
-                        "this argument is passed by value, but not consumed in the function body",
-                        sugg,
-                    );
-                }
+                span_lint_and_then(
+                    cx,
+                    NEEDLESS_PASS_BY_VALUE,
+                    input.span,
+                    "this argument is passed by value, but not consumed in the function body",
+                    sugg,
+                );
             }
         }
     }
diff --git a/clippy_lints/src/needless_question_mark.rs b/clippy_lints/src/needless_question_mark.rs
index 074c9fef1b2..66ad45e1cb8 100644
--- a/clippy_lints/src/needless_question_mark.rs
+++ b/clippy_lints/src/needless_question_mark.rs
@@ -111,34 +111,32 @@ impl LateLintPass<'_> for NeedlessQuestionMark {
 }
 
 fn check(cx: &LateContext<'_>, expr: &Expr<'_>) {
-    if_chain! {
-        if let ExprKind::Call(path, [arg]) = expr.kind;
-        if let Res::Def(DefKind::Ctor(..), ctor_id) = path_res(cx, path);
-        if let Some(variant_id) = cx.tcx.opt_parent(ctor_id);
-        let sugg_remove = if cx.tcx.lang_items().option_some_variant() == Some(variant_id) {
+    if let ExprKind::Call(path, [arg]) = expr.kind
+        && let Res::Def(DefKind::Ctor(..), ctor_id) = path_res(cx, path)
+        && let Some(variant_id) = cx.tcx.opt_parent(ctor_id)
+        && let sugg_remove = if cx.tcx.lang_items().option_some_variant() == Some(variant_id) {
             "Some()"
         } else if cx.tcx.lang_items().result_ok_variant() == Some(variant_id) {
             "Ok()"
         } else {
             return;
-        };
-        if let ExprKind::Match(inner_expr_with_q, _, MatchSource::TryDesugar(_)) = &arg.kind;
-        if let ExprKind::Call(called, [inner_expr]) = &inner_expr_with_q.kind;
-        if let ExprKind::Path(QPath::LangItem(LangItem::TryTraitBranch, ..)) = &called.kind;
-        if expr.span.eq_ctxt(inner_expr.span);
-        let expr_ty = cx.typeck_results().expr_ty(expr);
-        let inner_ty = cx.typeck_results().expr_ty(inner_expr);
-        if expr_ty == inner_ty;
-        then {
-            span_lint_and_sugg(
-                cx,
-                NEEDLESS_QUESTION_MARK,
-                expr.span,
-                "question mark operator is useless here",
-                &format!("try removing question mark and `{sugg_remove}`"),
-                format!("{}", snippet(cx, inner_expr.span, r#""...""#)),
-                Applicability::MachineApplicable,
-            );
         }
+        && let ExprKind::Match(inner_expr_with_q, _, MatchSource::TryDesugar(_)) = &arg.kind
+        && let ExprKind::Call(called, [inner_expr]) = &inner_expr_with_q.kind
+        && let ExprKind::Path(QPath::LangItem(LangItem::TryTraitBranch, ..)) = &called.kind
+        && expr.span.eq_ctxt(inner_expr.span)
+        && let expr_ty = cx.typeck_results().expr_ty(expr)
+        && let inner_ty = cx.typeck_results().expr_ty(inner_expr)
+        && expr_ty == inner_ty
+    {
+        span_lint_and_sugg(
+            cx,
+            NEEDLESS_QUESTION_MARK,
+            expr.span,
+            "question mark operator is useless here",
+            &format!("try removing question mark and `{sugg_remove}`"),
+            format!("{}", snippet(cx, inner_expr.span, r#""...""#)),
+            Applicability::MachineApplicable,
+        );
     }
 }
diff --git a/clippy_lints/src/neg_cmp_op_on_partial_ord.rs b/clippy_lints/src/neg_cmp_op_on_partial_ord.rs
index 56c67406d6f..5e692d7d205 100644
--- a/clippy_lints/src/neg_cmp_op_on_partial_ord.rs
+++ b/clippy_lints/src/neg_cmp_op_on_partial_ord.rs
@@ -46,42 +46,40 @@ declare_lint_pass!(NoNegCompOpForPartialOrd => [NEG_CMP_OP_ON_PARTIAL_ORD]);
 
 impl<'tcx> LateLintPass<'tcx> for NoNegCompOpForPartialOrd {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if_chain! {
-            if !in_external_macro(cx.sess(), expr.span);
-            if let ExprKind::Unary(UnOp::Not, inner) = expr.kind;
-            if let ExprKind::Binary(ref op, left, _) = inner.kind;
-            if let BinOpKind::Le | BinOpKind::Ge | BinOpKind::Lt | BinOpKind::Gt = op.node;
+        if !in_external_macro(cx.sess(), expr.span)
+            && let ExprKind::Unary(UnOp::Not, inner) = expr.kind
+            && let ExprKind::Binary(ref op, left, _) = inner.kind
+            && let BinOpKind::Le | BinOpKind::Ge | BinOpKind::Lt | BinOpKind::Gt = op.node
 
-            then {
-                let ty = cx.typeck_results().expr_ty(left);
+        {
+            let ty = cx.typeck_results().expr_ty(left);
 
-                let implements_ord = {
-                    if let Some(id) = cx.tcx.get_diagnostic_item(sym::Ord) {
-                        implements_trait(cx, ty, id, &[])
-                    } else {
-                        return;
-                    }
-                };
-
-                let implements_partial_ord = {
-                    if let Some(id) = cx.tcx.lang_items().partial_ord_trait() {
-                        implements_trait(cx, ty, id, &[ty.into()])
-                    } else {
-                        return;
-                    }
-                };
+            let implements_ord = {
+                if let Some(id) = cx.tcx.get_diagnostic_item(sym::Ord) {
+                    implements_trait(cx, ty, id, &[])
+                } else {
+                    return;
+                }
+            };
 
-                if implements_partial_ord && !implements_ord {
-                    span_lint(
-                        cx,
-                        NEG_CMP_OP_ON_PARTIAL_ORD,
-                        expr.span,
-                        "the use of negated comparison operators on partially ordered \
-                        types produces code that is hard to read and refactor, please \
-                        consider using the `partial_cmp` method instead, to make it \
-                        clear that the two values could be incomparable",
-                    );
+            let implements_partial_ord = {
+                if let Some(id) = cx.tcx.lang_items().partial_ord_trait() {
+                    implements_trait(cx, ty, id, &[ty.into()])
+                } else {
+                    return;
                 }
+            };
+
+            if implements_partial_ord && !implements_ord {
+                span_lint(
+                    cx,
+                    NEG_CMP_OP_ON_PARTIAL_ORD,
+                    expr.span,
+                    "the use of negated comparison operators on partially ordered \
+                    types produces code that is hard to read and refactor, please \
+                    consider using the `partial_cmp` method instead, to make it \
+                    clear that the two values could be incomparable",
+                );
             }
         }
     }
diff --git a/clippy_lints/src/neg_multiply.rs b/clippy_lints/src/neg_multiply.rs
index db0e22842d1..62a8f04bf17 100644
--- a/clippy_lints/src/neg_multiply.rs
+++ b/clippy_lints/src/neg_multiply.rs
@@ -53,28 +53,26 @@ impl<'tcx> LateLintPass<'tcx> for NegMultiply {
 }
 
 fn check_mul(cx: &LateContext<'_>, span: Span, lit: &Expr<'_>, exp: &Expr<'_>) {
-    if_chain! {
-        if let ExprKind::Lit(l) = lit.kind;
-        if consts::lit_to_mir_constant(&l.node, cx.typeck_results().expr_ty_opt(lit)) == Constant::Int(1);
-        if cx.typeck_results().expr_ty(exp).is_integral();
+    if let ExprKind::Lit(l) = lit.kind
+        && consts::lit_to_mir_constant(&l.node, cx.typeck_results().expr_ty_opt(lit)) == Constant::Int(1)
+        && cx.typeck_results().expr_ty(exp).is_integral()
 
-        then {
-            let mut applicability = Applicability::MachineApplicable;
-            let (snip, from_macro) = snippet_with_context(cx, exp.span, span.ctxt(), "..", &mut applicability);
-            let suggestion = if !from_macro && exp.precedence().order() < PREC_PREFIX && !has_enclosing_paren(&snip) {
-                format!("-({snip})")
-            } else {
-                format!("-{snip}")
-            };
-            span_lint_and_sugg(
-                    cx,
-                    NEG_MULTIPLY,
-                    span,
-                    "this multiplication by -1 can be written more succinctly",
-                    "consider using",
-                    suggestion,
-                    applicability,
-                );
-        }
+    {
+        let mut applicability = Applicability::MachineApplicable;
+        let (snip, from_macro) = snippet_with_context(cx, exp.span, span.ctxt(), "..", &mut applicability);
+        let suggestion = if !from_macro && exp.precedence().order() < PREC_PREFIX && !has_enclosing_paren(&snip) {
+            format!("-({snip})")
+        } else {
+            format!("-{snip}")
+        };
+        span_lint_and_sugg(
+                cx,
+                NEG_MULTIPLY,
+                span,
+                "this multiplication by -1 can be written more succinctly",
+                "consider using",
+                suggestion,
+                applicability,
+            );
     }
 }
diff --git a/clippy_lints/src/new_without_default.rs b/clippy_lints/src/new_without_default.rs
index f7f9dccfbce..bd75a8c2a98 100644
--- a/clippy_lints/src/new_without_default.rs
+++ b/clippy_lints/src/new_without_default.rs
@@ -93,73 +93,69 @@ impl<'tcx> LateLintPass<'tcx> for NewWithoutDefault {
                             // an impl of `Default`
                             return;
                         }
-                        if_chain! {
-                            if sig.decl.inputs.is_empty();
-                            if name == sym::new;
-                            if cx.effective_visibilities.is_reachable(impl_item.owner_id.def_id);
-                            let self_def_id = cx.tcx.hir().get_parent_item(id.into());
-                            let self_ty = cx.tcx.type_of(self_def_id).instantiate_identity();
-                            if self_ty == return_ty(cx, id);
-                            if let Some(default_trait_id) = cx.tcx.get_diagnostic_item(sym::Default);
-                            then {
-                                if self.impling_types.is_none() {
-                                    let mut impls = HirIdSet::default();
-                                    cx.tcx.for_each_impl(default_trait_id, |d| {
-                                        let ty = cx.tcx.type_of(d).instantiate_identity();
-                                        if let Some(ty_def) = ty.ty_adt_def() {
-                                            if let Some(local_def_id) = ty_def.did().as_local() {
-                                                impls.insert(cx.tcx.hir().local_def_id_to_hir_id(local_def_id));
-                                            }
+                        if sig.decl.inputs.is_empty()
+                            && name == sym::new
+                            && cx.effective_visibilities.is_reachable(impl_item.owner_id.def_id)
+                            && let self_def_id = cx.tcx.hir().get_parent_item(id.into())
+                            && let self_ty = cx.tcx.type_of(self_def_id).instantiate_identity()
+                            && self_ty == return_ty(cx, id)
+                            && let Some(default_trait_id) = cx.tcx.get_diagnostic_item(sym::Default)
+                        {
+                            if self.impling_types.is_none() {
+                                let mut impls = HirIdSet::default();
+                                cx.tcx.for_each_impl(default_trait_id, |d| {
+                                    let ty = cx.tcx.type_of(d).instantiate_identity();
+                                    if let Some(ty_def) = ty.ty_adt_def() {
+                                        if let Some(local_def_id) = ty_def.did().as_local() {
+                                            impls.insert(cx.tcx.hir().local_def_id_to_hir_id(local_def_id));
                                         }
-                                    });
-                                    self.impling_types = Some(impls);
-                                }
-
-                                // Check if a Default implementation exists for the Self type, regardless of
-                                // generics
-                                if_chain! {
-                                    if let Some(ref impling_types) = self.impling_types;
-                                    let self_def = cx.tcx.type_of(self_def_id).instantiate_identity();
-                                    if let Some(self_def) = self_def.ty_adt_def();
-                                    if let Some(self_local_did) = self_def.did().as_local();
-                                    let self_id = cx.tcx.hir().local_def_id_to_hir_id(self_local_did);
-                                    if impling_types.contains(&self_id);
-                                    then {
-                                        return;
                                     }
-                                }
+                                });
+                                self.impling_types = Some(impls);
+                            }
 
-                                let generics_sugg = snippet(cx, generics.span, "");
-                                let where_clause_sugg = if generics.has_where_clause_predicates {
-                                    format!("\n{}\n", snippet(cx, generics.where_clause_span, ""))
-                                } else {
-                                    String::new()
-                                };
-                                let self_ty_fmt = self_ty.to_string();
-                                let self_type_snip = snippet(cx, impl_self_ty.span, &self_ty_fmt);
-                                span_lint_hir_and_then(
-                                    cx,
-                                    NEW_WITHOUT_DEFAULT,
-                                    id.into(),
-                                    impl_item.span,
-                                    &format!(
-                                        "you should consider adding a `Default` implementation for `{self_type_snip}`"
-                                    ),
-                                    |diag| {
-                                        diag.suggest_prepend_item(
-                                            cx,
-                                            item.span,
-                                            "try adding this",
-                                            &create_new_without_default_suggest_msg(
-                                                &self_type_snip,
-                                                &generics_sugg,
-                                                &where_clause_sugg
-                                            ),
-                                            Applicability::MachineApplicable,
-                                        );
-                                    },
-                                );
+                            // Check if a Default implementation exists for the Self type, regardless of
+                            // generics
+                            if let Some(ref impling_types) = self.impling_types
+                                && let self_def = cx.tcx.type_of(self_def_id).instantiate_identity()
+                                && let Some(self_def) = self_def.ty_adt_def()
+                                && let Some(self_local_did) = self_def.did().as_local()
+                                && let self_id = cx.tcx.hir().local_def_id_to_hir_id(self_local_did)
+                                && impling_types.contains(&self_id)
+                            {
+                                return;
                             }
+
+                            let generics_sugg = snippet(cx, generics.span, "");
+                            let where_clause_sugg = if generics.has_where_clause_predicates {
+                                format!("\n{}\n", snippet(cx, generics.where_clause_span, ""))
+                            } else {
+                                String::new()
+                            };
+                            let self_ty_fmt = self_ty.to_string();
+                            let self_type_snip = snippet(cx, impl_self_ty.span, &self_ty_fmt);
+                            span_lint_hir_and_then(
+                                cx,
+                                NEW_WITHOUT_DEFAULT,
+                                id.into(),
+                                impl_item.span,
+                                &format!(
+                                    "you should consider adding a `Default` implementation for `{self_type_snip}`"
+                                ),
+                                |diag| {
+                                    diag.suggest_prepend_item(
+                                        cx,
+                                        item.span,
+                                        "try adding this",
+                                        &create_new_without_default_suggest_msg(
+                                            &self_type_snip,
+                                            &generics_sugg,
+                                            &where_clause_sugg
+                                        ),
+                                        Applicability::MachineApplicable,
+                                    );
+                                },
+                            );
                         }
                     }
                 }
diff --git a/clippy_lints/src/no_effect.rs b/clippy_lints/src/no_effect.rs
index 3a28e511fdd..c5d6ff9b2f5 100644
--- a/clippy_lints/src/no_effect.rs
+++ b/clippy_lints/src/no_effect.rs
@@ -132,24 +132,22 @@ fn check_no_effect(cx: &LateContext<'_>, stmt: &Stmt<'_>) -> bool {
             return true;
         }
     } else if let StmtKind::Local(local) = stmt.kind {
-        if_chain! {
-            if !is_lint_allowed(cx, NO_EFFECT_UNDERSCORE_BINDING, local.hir_id);
-            if let Some(init) = local.init;
-            if local.els.is_none();
-            if !local.pat.span.from_expansion();
-            if has_no_effect(cx, init);
-            if let PatKind::Binding(_, _, ident, _) = local.pat.kind;
-            if ident.name.to_ident_string().starts_with('_');
-            then {
-                span_lint_hir(
-                    cx,
-                    NO_EFFECT_UNDERSCORE_BINDING,
-                    init.hir_id,
-                    stmt.span,
-                    "binding to `_` prefixed variable with no side-effect"
-                );
-                return true;
-            }
+        if !is_lint_allowed(cx, NO_EFFECT_UNDERSCORE_BINDING, local.hir_id)
+            && let Some(init) = local.init
+            && local.els.is_none()
+            && !local.pat.span.from_expansion()
+            && has_no_effect(cx, init)
+            && let PatKind::Binding(_, _, ident, _) = local.pat.kind
+            && ident.name.to_ident_string().starts_with('_')
+        {
+            span_lint_hir(
+                cx,
+                NO_EFFECT_UNDERSCORE_BINDING,
+                init.hir_id,
+                stmt.span,
+                "binding to `_` prefixed variable with no side-effect"
+            );
+            return true;
         }
     }
     false
@@ -199,63 +197,61 @@ fn has_no_effect(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
 }
 
 fn check_unnecessary_operation(cx: &LateContext<'_>, stmt: &Stmt<'_>) {
-    if_chain! {
-        if let StmtKind::Semi(expr) = stmt.kind;
-        let ctxt = stmt.span.ctxt();
-        if expr.span.ctxt() == ctxt;
-        if let Some(reduced) = reduce_expression(cx, expr);
-        if !in_external_macro(cx.sess(), stmt.span);
-        if reduced.iter().all(|e| e.span.ctxt() == ctxt);
-        then {
-            if let ExprKind::Index(..) = &expr.kind {
-                let snippet = if let (Some(arr), Some(func)) =
-                    (snippet_opt(cx, reduced[0].span), snippet_opt(cx, reduced[1].span))
-                {
-                    format!("assert!({}.len() > {});", &arr, &func)
+    if let StmtKind::Semi(expr) = stmt.kind
+        && let ctxt = stmt.span.ctxt()
+        && expr.span.ctxt() == ctxt
+        && let Some(reduced) = reduce_expression(cx, expr)
+        && !in_external_macro(cx.sess(), stmt.span)
+        && reduced.iter().all(|e| e.span.ctxt() == ctxt)
+    {
+        if let ExprKind::Index(..) = &expr.kind {
+            let snippet = if let (Some(arr), Some(func)) =
+                (snippet_opt(cx, reduced[0].span), snippet_opt(cx, reduced[1].span))
+            {
+                format!("assert!({}.len() > {});", &arr, &func)
+            } else {
+                return;
+            };
+            span_lint_hir_and_then(
+                cx,
+                UNNECESSARY_OPERATION,
+                expr.hir_id,
+                stmt.span,
+                "unnecessary operation",
+                |diag| {
+                    diag.span_suggestion(
+                        stmt.span,
+                        "statement can be written as",
+                        snippet,
+                        Applicability::MaybeIncorrect,
+                    );
+                },
+            );
+        } else {
+            let mut snippet = String::new();
+            for e in reduced {
+                if let Some(snip) = snippet_opt(cx, e.span) {
+                    snippet.push_str(&snip);
+                    snippet.push(';');
                 } else {
                     return;
-                };
-                span_lint_hir_and_then(
-                    cx,
-                    UNNECESSARY_OPERATION,
-                    expr.hir_id,
-                    stmt.span,
-                    "unnecessary operation",
-                    |diag| {
-                        diag.span_suggestion(
-                            stmt.span,
-                            "statement can be written as",
-                            snippet,
-                            Applicability::MaybeIncorrect,
-                        );
-                    },
-                );
-            } else {
-                let mut snippet = String::new();
-                for e in reduced {
-                    if let Some(snip) = snippet_opt(cx, e.span) {
-                        snippet.push_str(&snip);
-                        snippet.push(';');
-                    } else {
-                        return;
-                    }
                 }
-                span_lint_hir_and_then(
-                    cx,
-                    UNNECESSARY_OPERATION,
-                    expr.hir_id,
-                    stmt.span,
-                    "unnecessary operation",
-                    |diag| {
-                        diag.span_suggestion(
-                            stmt.span,
-                            "statement can be reduced to",
-                            snippet,
-                            Applicability::MachineApplicable,
-                        );
-                    },
-                );
             }
+            span_lint_hir_and_then(
+                cx,
+                UNNECESSARY_OPERATION,
+                expr.hir_id,
+                stmt.span,
+                "unnecessary operation",
+                |diag| {
+                    diag.span_suggestion(
+                        stmt.span,
+                        "statement can be reduced to",
+                        snippet,
+                        Applicability::MachineApplicable,
+                    );
+                },
+            );
         }
     }
 }
diff --git a/clippy_lints/src/non_copy_const.rs b/clippy_lints/src/non_copy_const.rs
index 54cec066ba1..5a91468a214 100644
--- a/clippy_lints/src/non_copy_const.rs
+++ b/clippy_lints/src/non_copy_const.rs
@@ -386,15 +386,14 @@ impl<'tcx> LateLintPass<'tcx> for NonCopyConst {
                     of_trait: Some(of_trait_ref),
                     ..
                 }) => {
-                    if_chain! {
+                    if let Some(of_trait_def_id) = of_trait_ref.trait_def_id()
                         // Lint a trait impl item only when the definition is a generic type,
                         // assuming an assoc const is not meant to be an interior mutable type.
-                        if let Some(of_trait_def_id) = of_trait_ref.trait_def_id();
-                        if let Some(of_assoc_item) = cx
+                        && let Some(of_assoc_item) = cx
                             .tcx
                             .associated_item(impl_item.owner_id)
-                            .trait_item_def_id;
-                        if cx
+                            .trait_item_def_id
+                        && cx
                             .tcx
                             .layout_of(cx.tcx.param_env(of_trait_def_id).and(
                                 // Normalize assoc types because ones originated from generic params
@@ -405,23 +404,22 @@ impl<'tcx> LateLintPass<'tcx> for NonCopyConst {
                                     cx.tcx.type_of(of_assoc_item).instantiate_identity(),
                                 ),
                             ))
-                            .is_err();
+                            .is_err()
                             // If there were a function like `has_frozen_variant` described above,
                             // we should use here as a frozen variant is a potential to be frozen
                             // similar to unknown layouts.
                             // e.g. `layout_of(...).is_err() || has_frozen_variant(...);`
-                        let ty = cx.tcx.type_of(impl_item.owner_id).instantiate_identity();
-                        let normalized = cx.tcx.normalize_erasing_regions(cx.param_env, ty);
-                        if !self.is_ty_ignored(ty) && Self::is_unfrozen(cx, normalized);
-                        if self.is_value_unfrozen_poly(cx, *body_id, normalized);
-                        then {
-                            lint(
-                               cx,
-                               Source::Assoc {
-                                   item: impl_item.span,
-                                },
-                            );
-                        }
+                        && let ty = cx.tcx.type_of(impl_item.owner_id).instantiate_identity()
+                        && let normalized = cx.tcx.normalize_erasing_regions(cx.param_env, ty)
+                        && !self.is_ty_ignored(ty) && Self::is_unfrozen(cx, normalized)
+                        && self.is_value_unfrozen_poly(cx, *body_id, normalized)
+                    {
+                        lint(
+                           cx,
+                           Source::Assoc {
+                               item: impl_item.span,
+                            },
+                        );
                     }
                 },
                 ItemKind::Impl(Impl { of_trait: None, .. }) => {
diff --git a/clippy_lints/src/non_octal_unix_permissions.rs b/clippy_lints/src/non_octal_unix_permissions.rs
index e94e4589966..ab52ed5a7ca 100644
--- a/clippy_lints/src/non_octal_unix_permissions.rs
+++ b/clippy_lints/src/non_octal_unix_permissions.rs
@@ -44,38 +44,34 @@ impl<'tcx> LateLintPass<'tcx> for NonOctalUnixPermissions {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
         match &expr.kind {
             ExprKind::MethodCall(path, func, [param], _) => {
-                if_chain! {
-                    if let Some(adt) = cx.typeck_results().expr_ty(func).peel_refs().ty_adt_def();
-                    if (path.ident.name == sym!(mode)
+                if let Some(adt) = cx.typeck_results().expr_ty(func).peel_refs().ty_adt_def()
+                    && ((path.ident.name == sym!(mode)
                         && matches!(cx.tcx.get_diagnostic_name(adt.did()), Some(sym::FsOpenOptions | sym::DirBuilder)))
                         || (path.ident.name == sym!(set_mode)
-                            && cx.tcx.is_diagnostic_item(sym::FsPermissions, adt.did()));
-                    if let ExprKind::Lit(_) = param.kind;
-                    if param.span.eq_ctxt(expr.span);
+                            && cx.tcx.is_diagnostic_item(sym::FsPermissions, adt.did())))
+                    && let ExprKind::Lit(_) = param.kind
+                    && param.span.eq_ctxt(expr.span)
 
-                    then {
-                        let Some(snip) = snippet_opt(cx, param.span) else {
-                            return
-                        };
+                {
+                    let Some(snip) = snippet_opt(cx, param.span) else {
+                        return
+                    };
 
-                        if !snip.starts_with("0o") {
-                            show_error(cx, param);
-                        }
+                    if !snip.starts_with("0o") {
+                        show_error(cx, param);
                     }
                 }
             },
             ExprKind::Call(func, [param]) => {
-                if_chain! {
-                    if let ExprKind::Path(ref path) = func.kind;
-                    if let Some(def_id) = cx.qpath_res(path, func.hir_id).opt_def_id();
-                    if match_def_path(cx, def_id, &paths::PERMISSIONS_FROM_MODE);
-                    if let ExprKind::Lit(_) = param.kind;
-                    if param.span.eq_ctxt(expr.span);
-                    if let Some(snip) = snippet_opt(cx, param.span);
-                    if !snip.starts_with("0o");
-                    then {
-                        show_error(cx, param);
-                    }
+                if let ExprKind::Path(ref path) = func.kind
+                    && let Some(def_id) = cx.qpath_res(path, func.hir_id).opt_def_id()
+                    && match_def_path(cx, def_id, &paths::PERMISSIONS_FROM_MODE)
+                    && let ExprKind::Lit(_) = param.kind
+                    && param.span.eq_ctxt(expr.span)
+                    && let Some(snip) = snippet_opt(cx, param.span)
+                    && !snip.starts_with("0o")
+                {
+                    show_error(cx, param);
                 }
             },
             _ => {},
diff --git a/clippy_lints/src/non_send_fields_in_send_ty.rs b/clippy_lints/src/non_send_fields_in_send_ty.rs
index 62ef48c8a90..23e756c850f 100644
--- a/clippy_lints/src/non_send_fields_in_send_ty.rs
+++ b/clippy_lints/src/non_send_fields_in_send_ty.rs
@@ -81,73 +81,69 @@ impl<'tcx> LateLintPass<'tcx> for NonSendFieldInSendTy {
         // We start from `Send` impl instead of `check_field_def()` because
         // single `AdtDef` may have multiple `Send` impls due to generic
         // parameters, and the lint is much easier to implement in this way.
-        if_chain! {
-            if !in_external_macro(cx.tcx.sess, item.span);
-            if let Some(send_trait) = cx.tcx.get_diagnostic_item(sym::Send);
-            if let ItemKind::Impl(hir_impl) = &item.kind;
-            if let Some(trait_ref) = &hir_impl.of_trait;
-            if let Some(trait_id) = trait_ref.trait_def_id();
-            if send_trait == trait_id;
-            if hir_impl.polarity == ImplPolarity::Positive;
-            if let Some(ty_trait_ref) = cx.tcx.impl_trait_ref(item.owner_id);
-            if let self_ty = ty_trait_ref.instantiate_identity().self_ty();
-            if let ty::Adt(adt_def, impl_trait_args) = self_ty.kind();
-            then {
-                let mut non_send_fields = Vec::new();
-
-                let hir_map = cx.tcx.hir();
-                for variant in adt_def.variants() {
-                    for field in &variant.fields {
-                        if_chain! {
-                            if let Some(field_hir_id) = field
-                                .did
-                                .as_local()
-                                .map(|local_def_id| hir_map.local_def_id_to_hir_id(local_def_id));
-                            if !is_lint_allowed(cx, NON_SEND_FIELDS_IN_SEND_TY, field_hir_id);
-                            if let field_ty = field.ty(cx.tcx, impl_trait_args);
-                            if !ty_allowed_in_send(cx, field_ty, send_trait);
-                            if let Node::Field(field_def) = hir_map.get(field_hir_id);
-                            then {
-                                non_send_fields.push(NonSendField {
-                                    def: field_def,
-                                    ty: field_ty,
-                                    generic_params: collect_generic_params(field_ty),
-                                })
-                            }
-                        }
+        if !in_external_macro(cx.tcx.sess, item.span)
+            && let Some(send_trait) = cx.tcx.get_diagnostic_item(sym::Send)
+            && let ItemKind::Impl(hir_impl) = &item.kind
+            && let Some(trait_ref) = &hir_impl.of_trait
+            && let Some(trait_id) = trait_ref.trait_def_id()
+            && send_trait == trait_id
+            && hir_impl.polarity == ImplPolarity::Positive
+            && let Some(ty_trait_ref) = cx.tcx.impl_trait_ref(item.owner_id)
+            && let self_ty = ty_trait_ref.instantiate_identity().self_ty()
+            && let ty::Adt(adt_def, impl_trait_args) = self_ty.kind()
+        {
+            let mut non_send_fields = Vec::new();
+
+            let hir_map = cx.tcx.hir();
+            for variant in adt_def.variants() {
+                for field in &variant.fields {
+                    if let Some(field_hir_id) = field
+                            .did
+                            .as_local()
+                            .map(|local_def_id| hir_map.local_def_id_to_hir_id(local_def_id))
+                        && !is_lint_allowed(cx, NON_SEND_FIELDS_IN_SEND_TY, field_hir_id)
+                        && let field_ty = field.ty(cx.tcx, impl_trait_args)
+                        && !ty_allowed_in_send(cx, field_ty, send_trait)
+                        && let Node::Field(field_def) = hir_map.get(field_hir_id)
+                    {
+                        non_send_fields.push(NonSendField {
+                            def: field_def,
+                            ty: field_ty,
+                            generic_params: collect_generic_params(field_ty),
+                        })
                     }
                 }
+            }
 
-                if !non_send_fields.is_empty() {
-                    span_lint_and_then(
-                        cx,
-                        NON_SEND_FIELDS_IN_SEND_TY,
-                        item.span,
-                        &format!(
-                            "some fields in `{}` are not safe to be sent to another thread",
-                            snippet(cx, hir_impl.self_ty.span, "Unknown")
-                        ),
-                        |diag| {
-                            for field in non_send_fields {
-                                diag.span_note(
-                                    field.def.span,
-                                    format!("it is not safe to send field `{}` to another thread", field.def.ident.name),
-                                );
-
-                                match field.generic_params.len() {
-                                    0 => diag.help("use a thread-safe type that implements `Send`"),
-                                    1 if is_ty_param(field.ty) => diag.help(format!("add `{}: Send` bound in `Send` impl", field.ty)),
-                                    _ => diag.help(format!(
-                                        "add bounds on type parameter{} `{}` that satisfy `{}: Send`",
-                                        if field.generic_params.len() > 1 { "s" } else { "" },
-                                        field.generic_params_string(),
-                                        snippet(cx, field.def.ty.span, "Unknown"),
-                                    )),
-                                };
-                            }
-                        },
-                    );
-                }
+            if !non_send_fields.is_empty() {
+                span_lint_and_then(
+                    cx,
+                    NON_SEND_FIELDS_IN_SEND_TY,
+                    item.span,
+                    &format!(
+                        "some fields in `{}` are not safe to be sent to another thread",
+                        snippet(cx, hir_impl.self_ty.span, "Unknown")
+                    ),
+                    |diag| {
+                        for field in non_send_fields {
+                            diag.span_note(
+                                field.def.span,
+                                format!("it is not safe to send field `{}` to another thread", field.def.ident.name),
+                            );
+
+                            match field.generic_params.len() {
+                                0 => diag.help("use a thread-safe type that implements `Send`"),
+                                1 if is_ty_param(field.ty) => diag.help(format!("add `{}: Send` bound in `Send` impl", field.ty)),
+                                _ => diag.help(format!(
+                                    "add bounds on type parameter{} `{}` that satisfy `{}: Send`",
+                                    if field.generic_params.len() > 1 { "s" } else { "" },
+                                    field.generic_params_string(),
+                                    snippet(cx, field.def.ty.span, "Unknown"),
+                                )),
+                            };
+                        }
+                    },
+                );
             }
         }
     }
diff --git a/clippy_lints/src/nonstandard_macro_braces.rs b/clippy_lints/src/nonstandard_macro_braces.rs
index 11c3a5417b5..87359086512 100644
--- a/clippy_lints/src/nonstandard_macro_braces.rs
+++ b/clippy_lints/src/nonstandard_macro_braces.rs
@@ -93,24 +93,22 @@ fn is_offending_macro<'a>(cx: &EarlyContext<'_>, span: Span, mac_braces: &'a Mac
                 .map_or(false, |e| e.macro_def_id.map_or(false, DefId::is_local))
     };
     let span_call_site = span.ctxt().outer_expn_data().call_site;
-    if_chain! {
-        if let ExpnKind::Macro(MacroKind::Bang, mac_name) = span.ctxt().outer_expn_data().kind;
-        let name = mac_name.as_str();
-        if let Some(braces) = mac_braces.macro_braces.get(name);
-        if let Some(snip) = snippet_opt(cx, span_call_site);
+    if let ExpnKind::Macro(MacroKind::Bang, mac_name) = span.ctxt().outer_expn_data().kind
+        && let name = mac_name.as_str()
+        && let Some(braces) = mac_braces.macro_braces.get(name)
+        && let Some(snip) = snippet_opt(cx, span_call_site)
         // we must check only invocation sites
         // https://github.com/rust-lang/rust-clippy/issues/7422
-        if snip.starts_with(&format!("{name}!"));
-        if unnested_or_local();
+        && snip.starts_with(&format!("{name}!"))
+        && unnested_or_local()
         // make formatting consistent
-        let c = snip.replace(' ', "");
-        if !c.starts_with(&format!("{name}!{}", braces.0));
-        if !mac_braces.done.contains(&span_call_site);
-        then {
-            Some((span_call_site, braces, snip))
-        } else {
-            None
-        }
+        && let c = snip.replace(' ', "")
+        && !c.starts_with(&format!("{name}!{}", braces.0))
+        && !mac_braces.done.contains(&span_call_site)
+    {
+        Some((span_call_site, braces, snip))
+    } else {
+        None
     }
 }
 
diff --git a/clippy_lints/src/operators/assign_op_pattern.rs b/clippy_lints/src/operators/assign_op_pattern.rs
index c4572a09db6..bc7ad151aee 100644
--- a/clippy_lints/src/operators/assign_op_pattern.rs
+++ b/clippy_lints/src/operators/assign_op_pattern.rs
@@ -25,43 +25,41 @@ pub(super) fn check<'tcx>(
         let lint = |assignee: &hir::Expr<'_>, rhs: &hir::Expr<'_>| {
             let ty = cx.typeck_results().expr_ty(assignee);
             let rty = cx.typeck_results().expr_ty(rhs);
-            if_chain! {
-                if let Some((_, lang_item)) = binop_traits(op.node);
-                if let Some(trait_id) = cx.tcx.lang_items().get(lang_item);
-                let parent_fn = cx.tcx.hir().get_parent_item(e.hir_id).def_id;
-                if trait_ref_of_method(cx, parent_fn)
-                    .map_or(true, |t| t.path.res.def_id() != trait_id);
-                if implements_trait(cx, ty, trait_id, &[rty.into()]);
-                then {
-                    // Primitive types execute assign-ops right-to-left. Every other type is left-to-right.
-                    if !(ty.is_primitive() && rty.is_primitive()) {
-                        // TODO: This will have false negatives as it doesn't check if the borrows are
-                        // actually live at the end of their respective expressions.
-                        let mut_borrows = mut_borrows_in_expr(cx, assignee);
-                        let imm_borrows = imm_borrows_in_expr(cx, rhs);
-                        if mut_borrows.iter().any(|id| imm_borrows.contains(id)) {
-                            return;
-                        }
+            if let Some((_, lang_item)) = binop_traits(op.node)
+                && let Some(trait_id) = cx.tcx.lang_items().get(lang_item)
+                && let parent_fn = cx.tcx.hir().get_parent_item(e.hir_id).def_id
+                && trait_ref_of_method(cx, parent_fn)
+                    .map_or(true, |t| t.path.res.def_id() != trait_id)
+                && implements_trait(cx, ty, trait_id, &[rty.into()])
+            {
+                // Primitive types execute assign-ops right-to-left. Every other type is left-to-right.
+                if !(ty.is_primitive() && rty.is_primitive()) {
+                    // TODO: This will have false negatives as it doesn't check if the borrows are
+                    // actually live at the end of their respective expressions.
+                    let mut_borrows = mut_borrows_in_expr(cx, assignee);
+                    let imm_borrows = imm_borrows_in_expr(cx, rhs);
+                    if mut_borrows.iter().any(|id| imm_borrows.contains(id)) {
+                        return;
                     }
-                    span_lint_and_then(
-                        cx,
-                        ASSIGN_OP_PATTERN,
-                        expr.span,
-                        "manual implementation of an assign operation",
-                        |diag| {
-                            if let (Some(snip_a), Some(snip_r)) =
-                                (snippet_opt(cx, assignee.span), snippet_opt(cx, rhs.span))
-                            {
-                                diag.span_suggestion(
-                                    expr.span,
-                                    "replace it with",
-                                    format!("{snip_a} {}= {snip_r}", op.node.as_str()),
-                                    Applicability::MachineApplicable,
-                                );
-                            }
-                        },
-                    );
                 }
+                span_lint_and_then(
+                    cx,
+                    ASSIGN_OP_PATTERN,
+                    expr.span,
+                    "manual implementation of an assign operation",
+                    |diag| {
+                        if let (Some(snip_a), Some(snip_r)) =
+                            (snippet_opt(cx, assignee.span), snippet_opt(cx, rhs.span))
+                        {
+                            diag.span_suggestion(
+                                expr.span,
+                                "replace it with",
+                                format!("{snip_a} {}= {snip_r}", op.node.as_str()),
+                                Applicability::MachineApplicable,
+                            );
+                        }
+                    },
+                );
             }
         };
 
diff --git a/clippy_lints/src/operators/const_comparisons.rs b/clippy_lints/src/operators/const_comparisons.rs
index abe8df19543..408c9a2cf29 100644
--- a/clippy_lints/src/operators/const_comparisons.rs
+++ b/clippy_lints/src/operators/const_comparisons.rs
@@ -23,19 +23,17 @@ fn comparison_to_const<'tcx>(
     typeck: &TypeckResults<'tcx>,
     expr: &'tcx Expr<'tcx>,
 ) -> Option<(CmpOp, &'tcx Expr<'tcx>, &'tcx Expr<'tcx>, Constant<'tcx>, Ty<'tcx>)> {
-    if_chain! {
-        if let ExprKind::Binary(operator, left, right) = expr.kind;
-        if let Ok(cmp_op) = CmpOp::try_from(operator.node);
-        then {
-            match (constant(cx, typeck, left), constant(cx, typeck, right)) {
-                (Some(_), Some(_)) => None,
-                (_, Some(con)) => Some((cmp_op, left, right, con, typeck.expr_ty(right))),
-                (Some(con), _) => Some((cmp_op.reverse(), right, left, con, typeck.expr_ty(left))),
-                _ => None,
-            }
-        } else {
-            None
+    if let ExprKind::Binary(operator, left, right) = expr.kind
+        && let Ok(cmp_op) = CmpOp::try_from(operator.node)
+    {
+        match (constant(cx, typeck, left), constant(cx, typeck, right)) {
+            (Some(_), Some(_)) => None,
+            (_, Some(con)) => Some((cmp_op, left, right, con, typeck.expr_ty(right))),
+            (Some(con), _) => Some((cmp_op.reverse(), right, left, con, typeck.expr_ty(left))),
+            _ => None,
         }
+    } else {
+        None
     }
 }
 
@@ -46,87 +44,85 @@ pub(super) fn check<'tcx>(
     right_cond: &'tcx Expr<'tcx>,
     span: Span,
 ) {
-    if_chain! {
+    if and_op.node == BinOpKind::And
         // Ensure that the binary operator is &&
-        if and_op.node == BinOpKind::And;
 
         // Check that both operands to '&&' are themselves a binary operation
         // The `comparison_to_const` step also checks this, so this step is just an optimization
-        if let ExprKind::Binary(_, _, _) = left_cond.kind;
-        if let ExprKind::Binary(_, _, _) = right_cond.kind;
+        && let ExprKind::Binary(_, _, _) = left_cond.kind
+        && let ExprKind::Binary(_, _, _) = right_cond.kind
 
-        let typeck = cx.typeck_results();
+        && let typeck = cx.typeck_results()
 
         // Check that both operands to '&&' compare a non-literal to a literal
-        if let Some((left_cmp_op, left_expr, left_const_expr, left_const, left_type)) =
-            comparison_to_const(cx, typeck, left_cond);
-        if let Some((right_cmp_op, right_expr, right_const_expr, right_const, right_type)) =
-            comparison_to_const(cx, typeck, right_cond);
+        && let Some((left_cmp_op, left_expr, left_const_expr, left_const, left_type)) =
+            comparison_to_const(cx, typeck, left_cond)
+        && let Some((right_cmp_op, right_expr, right_const_expr, right_const, right_type)) =
+            comparison_to_const(cx, typeck, right_cond)
 
-        if left_type == right_type;
+        && left_type == right_type
 
         // Check that the same expression is compared in both comparisons
-        if SpanlessEq::new(cx).eq_expr(left_expr, right_expr);
+        && SpanlessEq::new(cx).eq_expr(left_expr, right_expr)
 
-        if !left_expr.can_have_side_effects();
+        && !left_expr.can_have_side_effects()
 
         // Compare the two constant expressions
-        if let Some(ordering) = Constant::partial_cmp(cx.tcx(), left_type, &left_const, &right_const);
+        && let Some(ordering) = Constant::partial_cmp(cx.tcx(), left_type, &left_const, &right_const)
 
         // Rule out the `x >= 42 && x <= 42` corner case immediately
         // Mostly to simplify the implementation, but it is also covered by `clippy::double_comparisons`
-        if !matches!(
+        && !matches!(
             (&left_cmp_op, &right_cmp_op, ordering),
             (CmpOp::Le | CmpOp::Ge, CmpOp::Le | CmpOp::Ge, Ordering::Equal)
-        );
-
-        then {
-            if left_cmp_op.direction() == right_cmp_op.direction() {
-                let lhs_str = snippet(cx, left_cond.span, "<lhs>");
-                let rhs_str = snippet(cx, right_cond.span, "<rhs>");
-                // We already know that either side of `&&` has no effect,
-                // but emit a different error message depending on which side it is
-                if left_side_is_useless(left_cmp_op, ordering) {
-                    span_lint_and_note(
-                        cx,
-                        REDUNDANT_COMPARISONS,
-                        span,
-                        "left-hand side of `&&` operator has no effect",
-                        Some(left_cond.span.until(right_cond.span)),
-                        &format!("`if `{rhs_str}` evaluates to true, {lhs_str}` will always evaluate to true as well"),
-                    );
-                } else {
-                    span_lint_and_note(
-                        cx,
-                        REDUNDANT_COMPARISONS,
-                        span,
-                        "right-hand side of `&&` operator has no effect",
-                        Some(and_op.span.to(right_cond.span)),
-                        &format!("`if `{lhs_str}` evaluates to true, {rhs_str}` will always evaluate to true as well"),
-                    );
-                }
-                // We could autofix this error but choose not to,
-                // because code triggering this lint probably not behaving correctly in the first place
-            }
-            else if !comparison_is_possible(left_cmp_op.direction(), ordering) {
-                let expr_str = snippet(cx, left_expr.span, "..");
-                let lhs_str = snippet(cx, left_const_expr.span, "<lhs>");
-                let rhs_str = snippet(cx, right_const_expr.span, "<rhs>");
-                let note = match ordering {
-                    Ordering::Less => format!("since `{lhs_str}` < `{rhs_str}`, the expression evaluates to false for any value of `{expr_str}`"),
-                    Ordering::Equal => format!("`{expr_str}` cannot simultaneously be greater than and less than `{lhs_str}`"),
-                    Ordering::Greater => format!("since `{lhs_str}` > `{rhs_str}`, the expression evaluates to false for any value of `{expr_str}`"),
-                };
+        )
+
+    {
+        if left_cmp_op.direction() == right_cmp_op.direction() {
+            let lhs_str = snippet(cx, left_cond.span, "<lhs>");
+            let rhs_str = snippet(cx, right_cond.span, "<rhs>");
+            // We already know that either side of `&&` has no effect,
+            // but emit a different error message depending on which side it is
+            if left_side_is_useless(left_cmp_op, ordering) {
                 span_lint_and_note(
                     cx,
-                    IMPOSSIBLE_COMPARISONS,
+                    REDUNDANT_COMPARISONS,
                     span,
-                    "boolean expression will never evaluate to 'true'",
-                    None,
-                    &note,
+                    "left-hand side of `&&` operator has no effect",
+                    Some(left_cond.span.until(right_cond.span)),
+                    &format!("`if `{rhs_str}` evaluates to true, {lhs_str}` will always evaluate to true as well"),
                 );
-            };
+            } else {
+                span_lint_and_note(
+                    cx,
+                    REDUNDANT_COMPARISONS,
+                    span,
+                    "right-hand side of `&&` operator has no effect",
+                    Some(and_op.span.to(right_cond.span)),
+                    &format!("`if `{lhs_str}` evaluates to true, {rhs_str}` will always evaluate to true as well"),
+                );
+            }
+            // We could autofix this error but choose not to,
+            // because code triggering this lint probably not behaving correctly in the first place
         }
+        else if !comparison_is_possible(left_cmp_op.direction(), ordering) {
+            let expr_str = snippet(cx, left_expr.span, "..");
+            let lhs_str = snippet(cx, left_const_expr.span, "<lhs>");
+            let rhs_str = snippet(cx, right_const_expr.span, "<rhs>");
+            let note = match ordering {
+                Ordering::Less => format!("since `{lhs_str}` < `{rhs_str}`, the expression evaluates to false for any value of `{expr_str}`"),
+                Ordering::Equal => format!("`{expr_str}` cannot simultaneously be greater than and less than `{lhs_str}`"),
+                Ordering::Greater => format!("since `{lhs_str}` > `{rhs_str}`, the expression evaluates to false for any value of `{expr_str}`"),
+            };
+            span_lint_and_note(
+                cx,
+                IMPOSSIBLE_COMPARISONS,
+                span,
+                "boolean expression will never evaluate to 'true'",
+                None,
+                &note,
+            );
+        };
     }
 }
 
diff --git a/clippy_lints/src/operators/float_cmp.rs b/clippy_lints/src/operators/float_cmp.rs
index bce6bdcaf61..fecaf14bf5e 100644
--- a/clippy_lints/src/operators/float_cmp.rs
+++ b/clippy_lints/src/operators/float_cmp.rs
@@ -105,14 +105,12 @@ fn is_signum(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
         return is_signum(cx, child_expr);
     }
 
-    if_chain! {
-        if let ExprKind::MethodCall(method_name, self_arg, ..) = expr.kind;
-        if sym!(signum) == method_name.ident.name;
+    if let ExprKind::MethodCall(method_name, self_arg, ..) = expr.kind
+        && sym!(signum) == method_name.ident.name
         // Check that the receiver of the signum() is a float (expressions[0] is the receiver of
         // the method call)
-        then {
-            return is_float(cx, self_arg);
-        }
+    {
+        return is_float(cx, self_arg);
     }
     false
 }
diff --git a/clippy_lints/src/operators/float_equality_without_abs.rs b/clippy_lints/src/operators/float_equality_without_abs.rs
index a0a8b6aabd9..91eaa296f14 100644
--- a/clippy_lints/src/operators/float_equality_without_abs.rs
+++ b/clippy_lints/src/operators/float_equality_without_abs.rs
@@ -24,48 +24,46 @@ pub(crate) fn check<'tcx>(
         _ => return,
     };
 
-    if_chain! {
+    if let ExprKind::Binary(
         // left hand side is a subtraction
-        if let ExprKind::Binary(
             Spanned {
                 node: BinOpKind::Sub,
                 ..
             },
             val_l,
             val_r,
-        ) = lhs.kind;
+        ) = lhs.kind
 
         // right hand side matches either f32::EPSILON or f64::EPSILON
-        if let ExprKind::Path(ref epsilon_path) = rhs.kind;
-        if let Res::Def(DefKind::AssocConst, def_id) = cx.qpath_res(epsilon_path, rhs.hir_id);
-        if match_def_path(cx, def_id, &paths::F32_EPSILON) || match_def_path(cx, def_id, &paths::F64_EPSILON);
+        && let ExprKind::Path(ref epsilon_path) = rhs.kind
+        && let Res::Def(DefKind::AssocConst, def_id) = cx.qpath_res(epsilon_path, rhs.hir_id)
+        && (match_def_path(cx, def_id, &paths::F32_EPSILON) || match_def_path(cx, def_id, &paths::F64_EPSILON))
 
         // values of the subtractions on the left hand side are of the type float
-        let t_val_l = cx.typeck_results().expr_ty(val_l);
-        let t_val_r = cx.typeck_results().expr_ty(val_r);
-        if let ty::Float(_) = t_val_l.kind();
-        if let ty::Float(_) = t_val_r.kind();
+        && let t_val_l = cx.typeck_results().expr_ty(val_l)
+        && let t_val_r = cx.typeck_results().expr_ty(val_r)
+        && let ty::Float(_) = t_val_l.kind()
+        && let ty::Float(_) = t_val_r.kind()
 
-        then {
-            let sug_l = sugg::Sugg::hir(cx, val_l, "..");
-            let sug_r = sugg::Sugg::hir(cx, val_r, "..");
-            // format the suggestion
-            let suggestion = format!("{}.abs()", sugg::make_assoc(AssocOp::Subtract, &sug_l, &sug_r).maybe_par());
-            // spans the lint
-            span_lint_and_then(
-                cx,
-                FLOAT_EQUALITY_WITHOUT_ABS,
-                expr.span,
-                "float equality check without `.abs()`",
-                | diag | {
-                    diag.span_suggestion(
-                        lhs.span,
-                        "add `.abs()`",
-                        suggestion,
-                        Applicability::MaybeIncorrect,
-                    );
-                }
-            );
-        }
+    {
+        let sug_l = sugg::Sugg::hir(cx, val_l, "..");
+        let sug_r = sugg::Sugg::hir(cx, val_r, "..");
+        // format the suggestion
+        let suggestion = format!("{}.abs()", sugg::make_assoc(AssocOp::Subtract, &sug_l, &sug_r).maybe_par());
+        // spans the lint
+        span_lint_and_then(
+            cx,
+            FLOAT_EQUALITY_WITHOUT_ABS,
+            expr.span,
+            "float equality check without `.abs()`",
+            | diag | {
+                diag.span_suggestion(
+                    lhs.span,
+                    "add `.abs()`",
+                    suggestion,
+                    Applicability::MaybeIncorrect,
+                );
+            }
+        );
     }
 }
diff --git a/clippy_lints/src/operators/modulo_arithmetic.rs b/clippy_lints/src/operators/modulo_arithmetic.rs
index a2c3a4d8ba7..2c7eebc5ae9 100644
--- a/clippy_lints/src/operators/modulo_arithmetic.rs
+++ b/clippy_lints/src/operators/modulo_arithmetic.rs
@@ -19,15 +19,13 @@ pub(super) fn check<'tcx>(
     if op == BinOpKind::Rem {
         let lhs_operand = analyze_operand(lhs, cx, e);
         let rhs_operand = analyze_operand(rhs, cx, e);
-        if_chain! {
-            if let Some(lhs_operand) = lhs_operand;
-            if let Some(rhs_operand) = rhs_operand;
-            then {
-                check_const_operands(cx, e, &lhs_operand, &rhs_operand);
-            }
-            else {
-                check_non_const_operands(cx, e, lhs);
-            }
+        if let Some(lhs_operand) = lhs_operand
+            && let Some(rhs_operand) = rhs_operand
+        {
+            check_const_operands(cx, e, &lhs_operand, &rhs_operand);
+        }
+        else {
+            check_non_const_operands(cx, e, lhs);
         }
     };
 }
diff --git a/clippy_lints/src/operators/op_ref.rs b/clippy_lints/src/operators/op_ref.rs
index 932dd470f9e..77ef4a43497 100644
--- a/clippy_lints/src/operators/op_ref.rs
+++ b/clippy_lints/src/operators/op_ref.rs
@@ -180,41 +180,37 @@ fn in_impl<'tcx>(
     e: &'tcx Expr<'_>,
     bin_op: DefId,
 ) -> Option<(&'tcx rustc_hir::Ty<'tcx>, &'tcx rustc_hir::Ty<'tcx>)> {
-    if_chain! {
-        if let Some(block) = get_enclosing_block(cx, e.hir_id);
-        if let Some(impl_def_id) = cx.tcx.impl_of_method(block.hir_id.owner.to_def_id());
-        let item = cx.tcx.hir().expect_item(impl_def_id.expect_local());
-        if let ItemKind::Impl(item) = &item.kind;
-        if let Some(of_trait) = &item.of_trait;
-        if let Some(seg) = of_trait.path.segments.last();
-        if let Res::Def(_, trait_id) = seg.res;
-        if trait_id == bin_op;
-        if let Some(generic_args) = seg.args;
-        if let Some(GenericArg::Type(other_ty)) = generic_args.args.last();
+    if let Some(block) = get_enclosing_block(cx, e.hir_id)
+        && let Some(impl_def_id) = cx.tcx.impl_of_method(block.hir_id.owner.to_def_id())
+        && let item = cx.tcx.hir().expect_item(impl_def_id.expect_local())
+        && let ItemKind::Impl(item) = &item.kind
+        && let Some(of_trait) = &item.of_trait
+        && let Some(seg) = of_trait.path.segments.last()
+        && let Res::Def(_, trait_id) = seg.res
+        && trait_id == bin_op
+        && let Some(generic_args) = seg.args
+        && let Some(GenericArg::Type(other_ty)) = generic_args.args.last()
 
-        then {
-            Some((item.self_ty, other_ty))
-        }
-        else {
-            None
-        }
+    {
+        Some((item.self_ty, other_ty))
+    }
+    else {
+        None
     }
 }
 
 fn are_equal(cx: &LateContext<'_>, middle_ty: Ty<'_>, hir_ty: &rustc_hir::Ty<'_>) -> bool {
-    if_chain! {
-        if let ty::Adt(adt_def, _) = middle_ty.kind();
-        if let Some(local_did) = adt_def.did().as_local();
-        let item = cx.tcx.hir().expect_item(local_did);
-        let middle_ty_id = item.owner_id.to_def_id();
-        if let TyKind::Path(QPath::Resolved(_, path)) = hir_ty.kind;
-        if let Res::Def(_, hir_ty_id) = path.res;
+    if let ty::Adt(adt_def, _) = middle_ty.kind()
+        && let Some(local_did) = adt_def.did().as_local()
+        && let item = cx.tcx.hir().expect_item(local_did)
+        && let middle_ty_id = item.owner_id.to_def_id()
+        && let TyKind::Path(QPath::Resolved(_, path)) = hir_ty.kind
+        && let Res::Def(_, hir_ty_id) = path.res
 
-        then {
-            hir_ty_id == middle_ty_id
-        }
-        else {
-            false
-        }
+    {
+        hir_ty_id == middle_ty_id
+    }
+    else {
+        false
     }
 }
diff --git a/clippy_lints/src/operators/ptr_eq.rs b/clippy_lints/src/operators/ptr_eq.rs
index 1229c202f5a..7ae269655c6 100644
--- a/clippy_lints/src/operators/ptr_eq.rs
+++ b/clippy_lints/src/operators/ptr_eq.rs
@@ -22,22 +22,20 @@ pub(super) fn check<'tcx>(
             _ => (left, right),
         };
 
-        if_chain! {
-            if let Some(left_var) = expr_as_cast_to_raw_pointer(cx, left);
-            if let Some(right_var) = expr_as_cast_to_raw_pointer(cx, right);
-            if let Some(left_snip) = snippet_opt(cx, left_var.span);
-            if let Some(right_snip) = snippet_opt(cx, right_var.span);
-            then {
-                span_lint_and_sugg(
-                    cx,
-                    PTR_EQ,
-                    expr.span,
-                    LINT_MSG,
-                    "try",
-                    format!("std::ptr::eq({left_snip}, {right_snip})"),
-                    Applicability::MachineApplicable,
-                    );
-            }
+        if let Some(left_var) = expr_as_cast_to_raw_pointer(cx, left)
+            && let Some(right_var) = expr_as_cast_to_raw_pointer(cx, right)
+            && let Some(left_snip) = snippet_opt(cx, left_var.span)
+            && let Some(right_snip) = snippet_opt(cx, right_var.span)
+        {
+            span_lint_and_sugg(
+                cx,
+                PTR_EQ,
+                expr.span,
+                LINT_MSG,
+                "try",
+                format!("std::ptr::eq({left_snip}, {right_snip})"),
+                Applicability::MachineApplicable,
+                );
         }
     }
 }
diff --git a/clippy_lints/src/option_if_let_else.rs b/clippy_lints/src/option_if_let_else.rs
index d7cbbe13a26..b69d374fbfd 100644
--- a/clippy_lints/src/option_if_let_else.rs
+++ b/clippy_lints/src/option_if_let_else.rs
@@ -122,73 +122,71 @@ fn try_get_option_occurrence<'tcx>(
         _ => expr,
     };
     let (inner_pat, is_result) = try_get_inner_pat_and_is_result(cx, pat)?;
-    if_chain! {
-        if let PatKind::Binding(bind_annotation, _, id, None) = inner_pat.kind;
-        if let Some(some_captures) = can_move_expr_to_closure(cx, if_then);
-        if let Some(none_captures) = can_move_expr_to_closure(cx, if_else);
-        if some_captures
+    if let PatKind::Binding(bind_annotation, _, id, None) = inner_pat.kind
+        && let Some(some_captures) = can_move_expr_to_closure(cx, if_then)
+        && let Some(none_captures) = can_move_expr_to_closure(cx, if_else)
+        && some_captures
             .iter()
             .filter_map(|(id, &c)| none_captures.get(id).map(|&c2| (c, c2)))
-            .all(|(x, y)| x.is_imm_ref() && y.is_imm_ref());
-        then {
-            let capture_mut = if bind_annotation == BindingAnnotation::MUT { "mut " } else { "" };
-            let some_body = peel_blocks(if_then);
-            let none_body = peel_blocks(if_else);
-            let method_sugg = if eager_or_lazy::switch_to_eager_eval(cx, none_body) { "map_or" } else { "map_or_else" };
-            let capture_name = id.name.to_ident_string();
-            let (as_ref, as_mut) = match &expr.kind {
-                ExprKind::AddrOf(_, Mutability::Not, _) => (true, false),
-                ExprKind::AddrOf(_, Mutability::Mut, _) => (false, true),
-                _ if let Some(mutb) = cx.typeck_results().expr_ty(expr).ref_mutability() => {
-                    (mutb == Mutability::Not, mutb == Mutability::Mut)
-                }
-                _ => (bind_annotation == BindingAnnotation::REF, bind_annotation == BindingAnnotation::REF_MUT),
-            };
+            .all(|(x, y)| x.is_imm_ref() && y.is_imm_ref())
+    {
+        let capture_mut = if bind_annotation == BindingAnnotation::MUT { "mut " } else { "" };
+        let some_body = peel_blocks(if_then);
+        let none_body = peel_blocks(if_else);
+        let method_sugg = if eager_or_lazy::switch_to_eager_eval(cx, none_body) { "map_or" } else { "map_or_else" };
+        let capture_name = id.name.to_ident_string();
+        let (as_ref, as_mut) = match &expr.kind {
+            ExprKind::AddrOf(_, Mutability::Not, _) => (true, false),
+            ExprKind::AddrOf(_, Mutability::Mut, _) => (false, true),
+            _ if let Some(mutb) = cx.typeck_results().expr_ty(expr).ref_mutability() => {
+                (mutb == Mutability::Not, mutb == Mutability::Mut)
+            }
+            _ => (bind_annotation == BindingAnnotation::REF, bind_annotation == BindingAnnotation::REF_MUT),
+        };
 
-            // Check if captures the closure will need conflict with borrows made in the scrutinee.
-            // TODO: check all the references made in the scrutinee expression. This will require interacting
-            // with the borrow checker. Currently only `<local>[.<field>]*` is checked for.
-            if as_ref || as_mut {
-                let e = peel_hir_expr_while(cond_expr, |e| match e.kind {
-                    ExprKind::Field(e, _) | ExprKind::AddrOf(_, _, e) => Some(e),
-                    _ => None,
-                });
-                if let ExprKind::Path(QPath::Resolved(None, Path { res: Res::Local(local_id), .. })) = e.kind {
-                    match some_captures.get(local_id)
-                        .or_else(|| (method_sugg == "map_or_else").then_some(()).and_then(|()| none_captures.get(local_id)))
-                    {
-                        Some(CaptureKind::Value | CaptureKind::Ref(Mutability::Mut)) => return None,
-                        Some(CaptureKind::Ref(Mutability::Not)) if as_mut => return None,
-                        Some(CaptureKind::Ref(Mutability::Not)) | None => (),
-                    }
+        // Check if captures the closure will need conflict with borrows made in the scrutinee.
+        // TODO: check all the references made in the scrutinee expression. This will require interacting
+        // with the borrow checker. Currently only `<local>[.<field>]*` is checked for.
+        if as_ref || as_mut {
+            let e = peel_hir_expr_while(cond_expr, |e| match e.kind {
+                ExprKind::Field(e, _) | ExprKind::AddrOf(_, _, e) => Some(e),
+                _ => None,
+            });
+            if let ExprKind::Path(QPath::Resolved(None, Path { res: Res::Local(local_id), .. })) = e.kind {
+                match some_captures.get(local_id)
+                    .or_else(|| (method_sugg == "map_or_else").then_some(()).and_then(|()| none_captures.get(local_id)))
+                {
+                    Some(CaptureKind::Value | CaptureKind::Ref(Mutability::Mut)) => return None,
+                    Some(CaptureKind::Ref(Mutability::Not)) if as_mut => return None,
+                    Some(CaptureKind::Ref(Mutability::Not)) | None => (),
                 }
             }
+        }
 
-            let mut app = Applicability::Unspecified;
+        let mut app = Applicability::Unspecified;
 
-            let (none_body, is_argless_call) = match none_body.kind {
-                ExprKind::Call(call_expr, []) if !none_body.span.from_expansion() => (call_expr, true),
-                _ => (none_body, false),
-            };
+        let (none_body, is_argless_call) = match none_body.kind {
+            ExprKind::Call(call_expr, []) if !none_body.span.from_expansion() => (call_expr, true),
+            _ => (none_body, false),
+        };
 
-            return Some(OptionOccurrence {
-                option: format_option_in_sugg(
-                    Sugg::hir_with_context(cx, cond_expr, ctxt, "..", &mut app),
-                    as_ref,
-                    as_mut,
-                ),
-                method_sugg: method_sugg.to_string(),
-                some_expr: format!(
-                    "|{capture_mut}{capture_name}| {}",
-                    Sugg::hir_with_context(cx, some_body, ctxt, "..", &mut app),
-                ),
-                none_expr: format!(
-                    "{}{}",
-                    if method_sugg == "map_or" || is_argless_call { "" } else if is_result { "|_| " } else { "|| "},
-                    Sugg::hir_with_context(cx, none_body, ctxt, "..", &mut app),
-                ),
-            });
-        }
+        return Some(OptionOccurrence {
+            option: format_option_in_sugg(
+                Sugg::hir_with_context(cx, cond_expr, ctxt, "..", &mut app),
+                as_ref,
+                as_mut,
+            ),
+            method_sugg: method_sugg.to_string(),
+            some_expr: format!(
+                "|{capture_mut}{capture_name}| {}",
+                Sugg::hir_with_context(cx, some_body, ctxt, "..", &mut app),
+            ),
+            none_expr: format!(
+                "{}{}",
+                if method_sugg == "map_or" || is_argless_call { "" } else if is_result { "|_| " } else { "|| "},
+                Sugg::hir_with_context(cx, none_body, ctxt, "..", &mut app),
+            ),
+        });
     }
 
     None
diff --git a/clippy_lints/src/overflow_check_conditional.rs b/clippy_lints/src/overflow_check_conditional.rs
index 38cd5043adc..36ad6cf5f9b 100644
--- a/clippy_lints/src/overflow_check_conditional.rs
+++ b/clippy_lints/src/overflow_check_conditional.rs
@@ -34,41 +34,37 @@ impl<'tcx> LateLintPass<'tcx> for OverflowCheckConditional {
     // a + b < a, a > a + b, a < a - b, a - b > a
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         let eq = |l, r| SpanlessEq::new(cx).eq_path_segment(l, r);
-        if_chain! {
-            if let ExprKind::Binary(ref op, first, second) = expr.kind;
-            if let ExprKind::Binary(ref op2, ident1, ident2) = first.kind;
-            if let ExprKind::Path(QPath::Resolved(_, path1)) = ident1.kind;
-            if let ExprKind::Path(QPath::Resolved(_, path2)) = ident2.kind;
-            if let ExprKind::Path(QPath::Resolved(_, path3)) = second.kind;
-            if eq(&path1.segments[0], &path3.segments[0]) || eq(&path2.segments[0], &path3.segments[0]);
-            if cx.typeck_results().expr_ty(ident1).is_integral();
-            if cx.typeck_results().expr_ty(ident2).is_integral();
-            then {
-                if op.node == BinOpKind::Lt && op2.node == BinOpKind::Add {
-                    span_lint(cx, OVERFLOW_CHECK_CONDITIONAL, expr.span, OVERFLOW_MSG);
-                }
-                if op.node == BinOpKind::Gt && op2.node == BinOpKind::Sub {
-                    span_lint(cx, OVERFLOW_CHECK_CONDITIONAL, expr.span, UNDERFLOW_MSG);
-                }
+        if let ExprKind::Binary(ref op, first, second) = expr.kind
+            && let ExprKind::Binary(ref op2, ident1, ident2) = first.kind
+            && let ExprKind::Path(QPath::Resolved(_, path1)) = ident1.kind
+            && let ExprKind::Path(QPath::Resolved(_, path2)) = ident2.kind
+            && let ExprKind::Path(QPath::Resolved(_, path3)) = second.kind
+            && (eq(&path1.segments[0], &path3.segments[0]) || eq(&path2.segments[0], &path3.segments[0]))
+            && cx.typeck_results().expr_ty(ident1).is_integral()
+            && cx.typeck_results().expr_ty(ident2).is_integral()
+        {
+            if op.node == BinOpKind::Lt && op2.node == BinOpKind::Add {
+                span_lint(cx, OVERFLOW_CHECK_CONDITIONAL, expr.span, OVERFLOW_MSG);
+            }
+            if op.node == BinOpKind::Gt && op2.node == BinOpKind::Sub {
+                span_lint(cx, OVERFLOW_CHECK_CONDITIONAL, expr.span, UNDERFLOW_MSG);
             }
         }
 
-        if_chain! {
-            if let ExprKind::Binary(ref op, first, second) = expr.kind;
-            if let ExprKind::Binary(ref op2, ident1, ident2) = second.kind;
-            if let ExprKind::Path(QPath::Resolved(_, path1)) = ident1.kind;
-            if let ExprKind::Path(QPath::Resolved(_, path2)) = ident2.kind;
-            if let ExprKind::Path(QPath::Resolved(_, path3)) = first.kind;
-            if eq(&path1.segments[0], &path3.segments[0]) || eq(&path2.segments[0], &path3.segments[0]);
-            if cx.typeck_results().expr_ty(ident1).is_integral();
-            if cx.typeck_results().expr_ty(ident2).is_integral();
-            then {
-                if op.node == BinOpKind::Gt && op2.node == BinOpKind::Add {
-                    span_lint(cx, OVERFLOW_CHECK_CONDITIONAL, expr.span, OVERFLOW_MSG);
-                }
-                if op.node == BinOpKind::Lt && op2.node == BinOpKind::Sub {
-                    span_lint(cx, OVERFLOW_CHECK_CONDITIONAL, expr.span, UNDERFLOW_MSG);
-                }
+        if let ExprKind::Binary(ref op, first, second) = expr.kind
+            && let ExprKind::Binary(ref op2, ident1, ident2) = second.kind
+            && let ExprKind::Path(QPath::Resolved(_, path1)) = ident1.kind
+            && let ExprKind::Path(QPath::Resolved(_, path2)) = ident2.kind
+            && let ExprKind::Path(QPath::Resolved(_, path3)) = first.kind
+            && (eq(&path1.segments[0], &path3.segments[0]) || eq(&path2.segments[0], &path3.segments[0]))
+            && cx.typeck_results().expr_ty(ident1).is_integral()
+            && cx.typeck_results().expr_ty(ident2).is_integral()
+        {
+            if op.node == BinOpKind::Gt && op2.node == BinOpKind::Add {
+                span_lint(cx, OVERFLOW_CHECK_CONDITIONAL, expr.span, OVERFLOW_MSG);
+            }
+            if op.node == BinOpKind::Lt && op2.node == BinOpKind::Sub {
+                span_lint(cx, OVERFLOW_CHECK_CONDITIONAL, expr.span, UNDERFLOW_MSG);
             }
         }
     }
diff --git a/clippy_lints/src/partialeq_ne_impl.rs b/clippy_lints/src/partialeq_ne_impl.rs
index 68d3d00ac16..105af98f1aa 100644
--- a/clippy_lints/src/partialeq_ne_impl.rs
+++ b/clippy_lints/src/partialeq_ne_impl.rs
@@ -34,22 +34,20 @@ declare_lint_pass!(PartialEqNeImpl => [PARTIALEQ_NE_IMPL]);
 
 impl<'tcx> LateLintPass<'tcx> for PartialEqNeImpl {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
-        if_chain! {
-            if let ItemKind::Impl(Impl { of_trait: Some(ref trait_ref), items: impl_items, .. }) = item.kind;
-            if !cx.tcx.has_attr(item.owner_id, sym::automatically_derived);
-            if let Some(eq_trait) = cx.tcx.lang_items().eq_trait();
-            if trait_ref.path.res.def_id() == eq_trait;
-            then {
-                for impl_item in *impl_items {
-                    if impl_item.ident.name == sym::ne {
-                        span_lint_hir(
-                            cx,
-                            PARTIALEQ_NE_IMPL,
-                            impl_item.id.hir_id(),
-                            impl_item.span,
-                            "re-implementing `PartialEq::ne` is unnecessary",
-                        );
-                    }
+        if let ItemKind::Impl(Impl { of_trait: Some(ref trait_ref), items: impl_items, .. }) = item.kind
+            && !cx.tcx.has_attr(item.owner_id, sym::automatically_derived)
+            && let Some(eq_trait) = cx.tcx.lang_items().eq_trait()
+            && trait_ref.path.res.def_id() == eq_trait
+        {
+            for impl_item in *impl_items {
+                if impl_item.ident.name == sym::ne {
+                    span_lint_hir(
+                        cx,
+                        PARTIALEQ_NE_IMPL,
+                        impl_item.id.hir_id(),
+                        impl_item.span,
+                        "re-implementing `PartialEq::ne` is unnecessary",
+                    );
                 }
             }
         };
diff --git a/clippy_lints/src/pass_by_ref_or_value.rs b/clippy_lints/src/pass_by_ref_or_value.rs
index 4d7a055dae1..3a6f37f01a8 100644
--- a/clippy_lints/src/pass_by_ref_or_value.rs
+++ b/clippy_lints/src/pass_by_ref_or_value.rs
@@ -229,22 +229,20 @@ impl<'tcx> PassByRefOrValue {
                     }
                     let ty = cx.tcx.erase_late_bound_regions(ty);
 
-                    if_chain! {
-                        if is_copy(cx, ty);
-                        if !is_self_ty(input);
-                        if let Some(size) = cx.layout_of(ty).ok().map(|l| l.size.bytes());
-                        if size > self.value_max_size;
-                        then {
-                            span_lint_and_sugg(
-                                cx,
-                                LARGE_TYPES_PASSED_BY_VALUE,
-                                input.span,
-                                &format!("this argument ({size} byte) is passed by value, but might be more efficient if passed by reference (limit: {} byte)", self.value_max_size),
-                                "consider passing by reference instead",
-                                format!("&{}", snippet(cx, input.span, "_")),
-                                Applicability::MaybeIncorrect,
-                            );
-                        }
+                    if is_copy(cx, ty)
+                        && !is_self_ty(input)
+                        && let Some(size) = cx.layout_of(ty).ok().map(|l| l.size.bytes())
+                        && size > self.value_max_size
+                    {
+                        span_lint_and_sugg(
+                            cx,
+                            LARGE_TYPES_PASSED_BY_VALUE,
+                            input.span,
+                            &format!("this argument ({size} byte) is passed by value, but might be more efficient if passed by reference (limit: {} byte)", self.value_max_size),
+                            "consider passing by reference instead",
+                            format!("&{}", snippet(cx, input.span, "_")),
+                            Applicability::MaybeIncorrect,
+                        );
                     }
                 },
 
diff --git a/clippy_lints/src/precedence.rs b/clippy_lints/src/precedence.rs
index 057b7e30642..0aebd9a6df3 100644
--- a/clippy_lints/src/precedence.rs
+++ b/clippy_lints/src/precedence.rs
@@ -118,25 +118,23 @@ impl EarlyLintPass for Precedence {
                 arg = receiver;
             }
 
-            if_chain! {
-                if !all_odd;
-                if let ExprKind::Lit(lit) = &arg.kind;
-                if let token::LitKind::Integer | token::LitKind::Float = &lit.kind;
-                then {
-                    let mut applicability = Applicability::MachineApplicable;
-                    span_lint_and_sugg(
-                        cx,
-                        PRECEDENCE,
-                        expr.span,
-                        "unary minus has lower precedence than method call",
-                        "consider adding parentheses to clarify your intent",
-                        format!(
-                            "-({})",
-                            snippet_with_applicability(cx, operand.span, "..", &mut applicability)
-                        ),
-                        applicability,
-                    );
-                }
+            if !all_odd
+                && let ExprKind::Lit(lit) = &arg.kind
+                && let token::LitKind::Integer | token::LitKind::Float = &lit.kind
+            {
+                let mut applicability = Applicability::MachineApplicable;
+                span_lint_and_sugg(
+                    cx,
+                    PRECEDENCE,
+                    expr.span,
+                    "unary minus has lower precedence than method call",
+                    "consider adding parentheses to clarify your intent",
+                    format!(
+                        "-({})",
+                        snippet_with_applicability(cx, operand.span, "..", &mut applicability)
+                    ),
+                    applicability,
+                );
             }
         }
     }
diff --git a/clippy_lints/src/question_mark.rs b/clippy_lints/src/question_mark.rs
index b133635e883..0c01934433a 100644
--- a/clippy_lints/src/question_mark.rs
+++ b/clippy_lints/src/question_mark.rs
@@ -179,17 +179,15 @@ fn expr_return_none_or_err(
             _ => false,
         },
         ExprKind::Call(call_expr, args_expr) => {
-            if_chain! {
-                if smbl == sym::Result;
-                if let ExprKind::Path(QPath::Resolved(_, path)) = &call_expr.kind;
-                if let Some(segment) = path.segments.first();
-                if let Some(err_sym) = err_sym;
-                if let Some(arg) = args_expr.first();
-                if let ExprKind::Path(QPath::Resolved(_, arg_path)) = &arg.kind;
-                if let Some(PathSegment { ident, .. }) = arg_path.segments.first();
-                then {
-                    return segment.ident.name == sym::Err && err_sym == ident.name;
-                }
+            if smbl == sym::Result
+                && let ExprKind::Path(QPath::Resolved(_, path)) = &call_expr.kind
+                && let Some(segment) = path.segments.first()
+                && let Some(err_sym) = err_sym
+                && let Some(arg) = args_expr.first()
+                && let ExprKind::Path(QPath::Resolved(_, arg_path)) = &arg.kind
+                && let Some(PathSegment { ident, .. }) = arg_path.segments.first()
+            {
+                return segment.ident.name == sym::Err && err_sym == ident.name;
             }
             false
         },
@@ -218,81 +216,77 @@ impl QuestionMark {
     ///
     /// If it matches, it will suggest to use the question mark operator instead
     fn check_is_none_or_err_and_early_return<'tcx>(&self, cx: &LateContext<'tcx>, expr: &Expr<'tcx>) {
-        if_chain! {
-            if !self.inside_try_block();
-            if let Some(higher::If { cond, then, r#else }) = higher::If::hir(expr);
-            if !is_else_clause(cx.tcx, expr);
-            if let ExprKind::MethodCall(segment, caller, ..) = &cond.kind;
-            let caller_ty = cx.typeck_results().expr_ty(caller);
-            let if_block = IfBlockType::IfIs(caller, caller_ty, segment.ident.name, then, r#else);
-            if is_early_return(sym::Option, cx, &if_block) || is_early_return(sym::Result, cx, &if_block);
-            then {
-                let mut applicability = Applicability::MachineApplicable;
-                let receiver_str = snippet_with_applicability(cx, caller.span, "..", &mut applicability);
-                let by_ref = !caller_ty.is_copy_modulo_regions(cx.tcx, cx.param_env) &&
-                    !matches!(caller.kind, ExprKind::Call(..) | ExprKind::MethodCall(..));
-                let sugg = if let Some(else_inner) = r#else {
-                    if eq_expr_value(cx, caller, peel_blocks(else_inner)) {
-                        format!("Some({receiver_str}?)")
-                    } else {
-                        return;
-                    }
+        if !self.inside_try_block()
+            && let Some(higher::If { cond, then, r#else }) = higher::If::hir(expr)
+            && !is_else_clause(cx.tcx, expr)
+            && let ExprKind::MethodCall(segment, caller, ..) = &cond.kind
+            && let caller_ty = cx.typeck_results().expr_ty(caller)
+            && let if_block = IfBlockType::IfIs(caller, caller_ty, segment.ident.name, then, r#else)
+            && (is_early_return(sym::Option, cx, &if_block) || is_early_return(sym::Result, cx, &if_block))
+        {
+            let mut applicability = Applicability::MachineApplicable;
+            let receiver_str = snippet_with_applicability(cx, caller.span, "..", &mut applicability);
+            let by_ref = !caller_ty.is_copy_modulo_regions(cx.tcx, cx.param_env) &&
+                !matches!(caller.kind, ExprKind::Call(..) | ExprKind::MethodCall(..));
+            let sugg = if let Some(else_inner) = r#else {
+                if eq_expr_value(cx, caller, peel_blocks(else_inner)) {
+                    format!("Some({receiver_str}?)")
                 } else {
-                    format!("{receiver_str}{}?;", if by_ref { ".as_ref()" } else { "" })
-                };
+                    return;
+                }
+            } else {
+                format!("{receiver_str}{}?;", if by_ref { ".as_ref()" } else { "" })
+            };
 
-                span_lint_and_sugg(
-                    cx,
-                    QUESTION_MARK,
-                    expr.span,
-                    "this block may be rewritten with the `?` operator",
-                    "replace it with",
-                    sugg,
-                    applicability,
-                );
-            }
+            span_lint_and_sugg(
+                cx,
+                QUESTION_MARK,
+                expr.span,
+                "this block may be rewritten with the `?` operator",
+                "replace it with",
+                sugg,
+                applicability,
+            );
         }
     }
 
     fn check_if_let_some_or_err_and_early_return<'tcx>(&self, cx: &LateContext<'tcx>, expr: &Expr<'tcx>) {
-        if_chain! {
-            if !self.inside_try_block();
-            if let Some(higher::IfLet { let_pat, let_expr, if_then, if_else }) = higher::IfLet::hir(cx, expr);
-            if !is_else_clause(cx.tcx, expr);
-            if let PatKind::TupleStruct(ref path1, [field], ddpos) = let_pat.kind;
-            if ddpos.as_opt_usize().is_none();
-            if let PatKind::Binding(BindingAnnotation(by_ref, _), bind_id, ident, None) = field.kind;
-            let caller_ty = cx.typeck_results().expr_ty(let_expr);
-            let if_block = IfBlockType::IfLet(
+        if !self.inside_try_block()
+            && let Some(higher::IfLet { let_pat, let_expr, if_then, if_else }) = higher::IfLet::hir(cx, expr)
+            && !is_else_clause(cx.tcx, expr)
+            && let PatKind::TupleStruct(ref path1, [field], ddpos) = let_pat.kind
+            && ddpos.as_opt_usize().is_none()
+            && let PatKind::Binding(BindingAnnotation(by_ref, _), bind_id, ident, None) = field.kind
+            && let caller_ty = cx.typeck_results().expr_ty(let_expr)
+            && let if_block = IfBlockType::IfLet(
                 cx.qpath_res(path1, let_pat.hir_id),
                 caller_ty,
                 ident.name,
                 let_expr,
                 if_then,
                 if_else
+            )
+            && ((is_early_return(sym::Option, cx, &if_block) && path_to_local_id(peel_blocks(if_then), bind_id))
+                || is_early_return(sym::Result, cx, &if_block))
+            && if_else.map(|e| eq_expr_value(cx, let_expr, peel_blocks(e))).filter(|e| *e).is_none()
+        {
+            let mut applicability = Applicability::MachineApplicable;
+            let receiver_str = snippet_with_applicability(cx, let_expr.span, "..", &mut applicability);
+            let requires_semi = matches!(get_parent_node(cx.tcx, expr.hir_id), Some(Node::Stmt(_)));
+            let sugg = format!(
+                "{receiver_str}{}?{}",
+                if by_ref == ByRef::Yes { ".as_ref()" } else { "" },
+                if requires_semi { ";" } else { "" }
+            );
+            span_lint_and_sugg(
+                cx,
+                QUESTION_MARK,
+                expr.span,
+                "this block may be rewritten with the `?` operator",
+                "replace it with",
+                sugg,
+                applicability,
             );
-            if (is_early_return(sym::Option, cx, &if_block) && path_to_local_id(peel_blocks(if_then), bind_id))
-                || is_early_return(sym::Result, cx, &if_block);
-            if if_else.map(|e| eq_expr_value(cx, let_expr, peel_blocks(e))).filter(|e| *e).is_none();
-            then {
-                let mut applicability = Applicability::MachineApplicable;
-                let receiver_str = snippet_with_applicability(cx, let_expr.span, "..", &mut applicability);
-                let requires_semi = matches!(get_parent_node(cx.tcx, expr.hir_id), Some(Node::Stmt(_)));
-                let sugg = format!(
-                    "{receiver_str}{}?{}",
-                    if by_ref == ByRef::Yes { ".as_ref()" } else { "" },
-                    if requires_semi { ";" } else { "" }
-                );
-                span_lint_and_sugg(
-                    cx,
-                    QUESTION_MARK,
-                    expr.span,
-                    "this block may be rewritten with the `?` operator",
-                    "replace it with",
-                    sugg,
-                    applicability,
-                );
-            }
         }
     }
 }
diff --git a/clippy_lints/src/ranges.rs b/clippy_lints/src/ranges.rs
index ffd49de3820..f62acc79b03 100644
--- a/clippy_lints/src/ranges.rs
+++ b/clippy_lints/src/ranges.rs
@@ -282,16 +282,14 @@ fn check_possible_range_contains(
 
     // If the LHS is the same operator, we have to recurse to get the "real" RHS, since they have
     // the same operator precedence
-    if_chain! {
-        if let ExprKind::Binary(ref lhs_op, _left, new_lhs) = left.kind;
-        if op == lhs_op.node;
-        let new_span = Span::new(new_lhs.span.lo(), right.span.hi(), expr.span.ctxt(), expr.span.parent());
-        if let Some(snip) = &snippet_opt(cx, new_span);
+    if let ExprKind::Binary(ref lhs_op, _left, new_lhs) = left.kind
+        && op == lhs_op.node
+        && let new_span = Span::new(new_lhs.span.lo(), right.span.hi(), expr.span.ctxt(), expr.span.parent())
+        && let Some(snip) = &snippet_opt(cx, new_span)
         // Do not continue if we have mismatched number of parens, otherwise the suggestion is wrong
-        if snip.matches('(').count() == snip.matches(')').count();
-        then {
-            check_possible_range_contains(cx, op, new_lhs, right, expr, new_span);
-        }
+        && snip.matches('(').count() == snip.matches(')').count()
+    {
+        check_possible_range_contains(cx, op, new_lhs, right, expr, new_span);
     }
 }
 
@@ -348,71 +346,67 @@ fn check_range_bounds<'a, 'tcx>(cx: &'a LateContext<'tcx>, ex: &'a Expr<'_>) ->
 
 // exclusive range plus one: `x..(y+1)`
 fn check_exclusive_range_plus_one(cx: &LateContext<'_>, expr: &Expr<'_>) {
-    if_chain! {
-        if expr.span.can_be_used_for_suggestions();
-        if let Some(higher::Range {
+    if expr.span.can_be_used_for_suggestions()
+        && let Some(higher::Range {
             start,
             end: Some(end),
             limits: RangeLimits::HalfOpen
-        }) = higher::Range::hir(expr);
-        if let Some(y) = y_plus_one(cx, end);
-        then {
-            let span = expr.span;
-            span_lint_and_then(
-                cx,
-                RANGE_PLUS_ONE,
-                span,
-                "an inclusive range would be more readable",
-                |diag| {
-                    let start = start.map_or(String::new(), |x| Sugg::hir(cx, x, "x").maybe_par().to_string());
-                    let end = Sugg::hir(cx, y, "y").maybe_par();
-                    if let Some(is_wrapped) = &snippet_opt(cx, span) {
-                        if is_wrapped.starts_with('(') && is_wrapped.ends_with(')') {
-                            diag.span_suggestion(
-                                span,
-                                "use",
-                                format!("({start}..={end})"),
-                                Applicability::MaybeIncorrect,
-                            );
-                        } else {
-                            diag.span_suggestion(
-                                span,
-                                "use",
-                                format!("{start}..={end}"),
-                                Applicability::MachineApplicable, // snippet
-                            );
-                        }
+        }) = higher::Range::hir(expr)
+        && let Some(y) = y_plus_one(cx, end)
+    {
+        let span = expr.span;
+        span_lint_and_then(
+            cx,
+            RANGE_PLUS_ONE,
+            span,
+            "an inclusive range would be more readable",
+            |diag| {
+                let start = start.map_or(String::new(), |x| Sugg::hir(cx, x, "x").maybe_par().to_string());
+                let end = Sugg::hir(cx, y, "y").maybe_par();
+                if let Some(is_wrapped) = &snippet_opt(cx, span) {
+                    if is_wrapped.starts_with('(') && is_wrapped.ends_with(')') {
+                        diag.span_suggestion(
+                            span,
+                            "use",
+                            format!("({start}..={end})"),
+                            Applicability::MaybeIncorrect,
+                        );
+                    } else {
+                        diag.span_suggestion(
+                            span,
+                            "use",
+                            format!("{start}..={end}"),
+                            Applicability::MachineApplicable, // snippet
+                        );
                     }
-                },
-            );
-        }
+                }
+            },
+        );
     }
 }
 
 // inclusive range minus one: `x..=(y-1)`
 fn check_inclusive_range_minus_one(cx: &LateContext<'_>, expr: &Expr<'_>) {
-    if_chain! {
-        if expr.span.can_be_used_for_suggestions();
-        if let Some(higher::Range { start, end: Some(end), limits: RangeLimits::Closed }) = higher::Range::hir(expr);
-        if let Some(y) = y_minus_one(cx, end);
-        then {
-            span_lint_and_then(
-                cx,
-                RANGE_MINUS_ONE,
-                expr.span,
-                "an exclusive range would be more readable",
-                |diag| {
-                    let start = start.map_or(String::new(), |x| Sugg::hir(cx, x, "x").maybe_par().to_string());
-                    let end = Sugg::hir(cx, y, "y").maybe_par();
-                    diag.span_suggestion(
-                        expr.span,
-                        "use",
-                        format!("{start}..{end}"),
-                        Applicability::MachineApplicable, // snippet
-                    );
-                },
-            );
-        }
+    if expr.span.can_be_used_for_suggestions()
+        && let Some(higher::Range { start, end: Some(end), limits: RangeLimits::Closed }) = higher::Range::hir(expr)
+        && let Some(y) = y_minus_one(cx, end)
+    {
+        span_lint_and_then(
+            cx,
+            RANGE_MINUS_ONE,
+            expr.span,
+            "an exclusive range would be more readable",
+            |diag| {
+                let start = start.map_or(String::new(), |x| Sugg::hir(cx, x, "x").maybe_par().to_string());
+                let end = Sugg::hir(cx, y, "y").maybe_par();
+                diag.span_suggestion(
+                    expr.span,
+                    "use",
+                    format!("{start}..{end}"),
+                    Applicability::MachineApplicable, // snippet
+                );
+            },
+        );
     }
 }
 
@@ -446,52 +440,50 @@ fn check_reversed_empty_range(cx: &LateContext<'_>, expr: &Expr<'_>) {
         }
     }
 
-    if_chain! {
-        if let Some(higher::Range { start: Some(start), end: Some(end), limits }) = higher::Range::hir(expr);
-        let ty = cx.typeck_results().expr_ty(start);
-        if let ty::Int(_) | ty::Uint(_) = ty.kind();
-        if let Some(start_idx) = constant(cx, cx.typeck_results(), start);
-        if let Some(end_idx) = constant(cx, cx.typeck_results(), end);
-        if let Some(ordering) = Constant::partial_cmp(cx.tcx, ty, &start_idx, &end_idx);
-        if is_empty_range(limits, ordering);
-        then {
-            if inside_indexing_expr(cx, expr) {
-                // Avoid linting `N..N` as it has proven to be useful, see #5689 and #5628 ...
-                if ordering != Ordering::Equal {
-                    span_lint(
-                        cx,
-                        REVERSED_EMPTY_RANGES,
-                        expr.span,
-                        "this range is reversed and using it to index a slice will panic at run-time",
-                    );
-                }
-            // ... except in for loop arguments for backwards compatibility with `reverse_range_loop`
-            } else if ordering != Ordering::Equal || is_for_loop_arg(cx, expr) {
-                span_lint_and_then(
+    if let Some(higher::Range { start: Some(start), end: Some(end), limits }) = higher::Range::hir(expr)
+        && let ty = cx.typeck_results().expr_ty(start)
+        && let ty::Int(_) | ty::Uint(_) = ty.kind()
+        && let Some(start_idx) = constant(cx, cx.typeck_results(), start)
+        && let Some(end_idx) = constant(cx, cx.typeck_results(), end)
+        && let Some(ordering) = Constant::partial_cmp(cx.tcx, ty, &start_idx, &end_idx)
+        && is_empty_range(limits, ordering)
+    {
+        if inside_indexing_expr(cx, expr) {
+            // Avoid linting `N..N` as it has proven to be useful, see #5689 and #5628 ...
+            if ordering != Ordering::Equal {
+                span_lint(
                     cx,
                     REVERSED_EMPTY_RANGES,
                     expr.span,
-                    "this range is empty so it will yield no values",
-                    |diag| {
-                        if ordering != Ordering::Equal {
-                            let start_snippet = snippet(cx, start.span, "_");
-                            let end_snippet = snippet(cx, end.span, "_");
-                            let dots = match limits {
-                                RangeLimits::HalfOpen => "..",
-                                RangeLimits::Closed => "..="
-                            };
-
-                            diag.span_suggestion(
-                                expr.span,
-                                "consider using the following if you are attempting to iterate over this \
-                                 range in reverse",
-                                format!("({end_snippet}{dots}{start_snippet}).rev()"),
-                                Applicability::MaybeIncorrect,
-                            );
-                        }
-                    },
+                    "this range is reversed and using it to index a slice will panic at run-time",
                 );
             }
+        // ... except in for loop arguments for backwards compatibility with `reverse_range_loop`
+        } else if ordering != Ordering::Equal || is_for_loop_arg(cx, expr) {
+            span_lint_and_then(
+                cx,
+                REVERSED_EMPTY_RANGES,
+                expr.span,
+                "this range is empty so it will yield no values",
+                |diag| {
+                    if ordering != Ordering::Equal {
+                        let start_snippet = snippet(cx, start.span, "_");
+                        let end_snippet = snippet(cx, end.span, "_");
+                        let dots = match limits {
+                            RangeLimits::HalfOpen => "..",
+                            RangeLimits::Closed => "..="
+                        };
+
+                        diag.span_suggestion(
+                            expr.span,
+                            "consider using the following if you are attempting to iterate over this \
+                             range in reverse",
+                            format!("({end_snippet}{dots}{start_snippet}).rev()"),
+                            Applicability::MaybeIncorrect,
+                        );
+                    }
+                },
+            );
         }
     }
 }
diff --git a/clippy_lints/src/rc_clone_in_vec_init.rs b/clippy_lints/src/rc_clone_in_vec_init.rs
index 59ce289e7d2..7d86252e6c5 100644
--- a/clippy_lints/src/rc_clone_in_vec_init.rs
+++ b/clippy_lints/src/rc_clone_in_vec_init.rs
@@ -118,26 +118,24 @@ fn emit_lint(cx: &LateContext<'_>, symbol: Symbol, lint_span: Span, elem: &Expr<
 
 /// Checks whether the given `expr` is a call to `Arc::new`, `Rc::new`, or evaluates to a `Weak`
 fn ref_init(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<(Symbol, Span)> {
-    if_chain! {
-        if let ExprKind::Call(func, _args) = expr.kind;
-        if let ExprKind::Path(ref func_path @ QPath::TypeRelative(ty, _)) = func.kind;
-        if let TyKind::Path(ref ty_path) = ty.kind;
-        if let Some(def_id) = cx.qpath_res(ty_path, ty.hir_id).opt_def_id();
+    if let ExprKind::Call(func, _args) = expr.kind
+        && let ExprKind::Path(ref func_path @ QPath::TypeRelative(ty, _)) = func.kind
+        && let TyKind::Path(ref ty_path) = ty.kind
+        && let Some(def_id) = cx.qpath_res(ty_path, ty.hir_id).opt_def_id()
 
-        then {
-            if last_path_segment(func_path).ident.name == sym::new
-                && let Some(symbol) = cx
-                    .tcx
-                    .get_diagnostic_name(def_id)
-                    .filter(|symbol| symbol == &sym::Arc || symbol == &sym::Rc) {
-                return Some((symbol, func.span));
-            }
+    {
+        if last_path_segment(func_path).ident.name == sym::new
+            && let Some(symbol) = cx
+                .tcx
+                .get_diagnostic_name(def_id)
+                .filter(|symbol| symbol == &sym::Arc || symbol == &sym::Rc) {
+            return Some((symbol, func.span));
+        }
 
-            if let ty::Adt(adt, _) = *cx.typeck_results().expr_ty(expr).kind()
-                && matches!(cx.tcx.get_diagnostic_name(adt.did()), Some(sym::RcWeak | sym::ArcWeak))
-            {
-                return Some((Symbol::intern("Weak"), func.span));
-            }
+        if let ty::Adt(adt, _) = *cx.typeck_results().expr_ty(expr).kind()
+            && matches!(cx.tcx.get_diagnostic_name(adt.did()), Some(sym::RcWeak | sym::ArcWeak))
+        {
+            return Some((Symbol::intern("Weak"), func.span));
         }
     }
 
diff --git a/clippy_lints/src/redundant_clone.rs b/clippy_lints/src/redundant_clone.rs
index ef14e68967e..ecc5a28519b 100644
--- a/clippy_lints/src/redundant_clone.rs
+++ b/clippy_lints/src/redundant_clone.rs
@@ -146,18 +146,16 @@ impl<'tcx> LateLintPass<'tcx> for RedundantClone {
                 let pred_terminator = mir[ps[0]].terminator();
 
                 // receiver of the `deref()` call
-                let (pred_arg, deref_clone_ret) = if_chain! {
-                    if let Some((pred_fn_def_id, pred_arg, pred_arg_ty, res)) =
-                        is_call_with_ref_arg(cx, mir, &pred_terminator.kind);
-                    if res == cloned;
-                    if cx.tcx.is_diagnostic_item(sym::deref_method, pred_fn_def_id);
-                    if is_type_diagnostic_item(cx, pred_arg_ty, sym::PathBuf)
-                        || is_type_diagnostic_item(cx, pred_arg_ty, sym::OsString);
-                    then {
-                        (pred_arg, res)
-                    } else {
-                        continue;
-                    }
+                let (pred_arg, deref_clone_ret) = if let Some((pred_fn_def_id, pred_arg, pred_arg_ty, res)) =
+                        is_call_with_ref_arg(cx, mir, &pred_terminator.kind)
+                    && res == cloned
+                    && cx.tcx.is_diagnostic_item(sym::deref_method, pred_fn_def_id)
+                    && (is_type_diagnostic_item(cx, pred_arg_ty, sym::PathBuf)
+                        || is_type_diagnostic_item(cx, pred_arg_ty, sym::OsString))
+                {
+                    (pred_arg, res)
+                } else {
+                    continue;
                 };
 
                 let (local, cannot_move_out) =
@@ -212,45 +210,43 @@ impl<'tcx> LateLintPass<'tcx> for RedundantClone {
                 .assert_crate_local()
                 .lint_root;
 
-            if_chain! {
-                if let Some(snip) = snippet_opt(cx, span);
-                if let Some(dot) = snip.rfind('.');
-                then {
-                    let sugg_span = span.with_lo(
-                        span.lo() + BytePos(u32::try_from(dot).unwrap())
-                    );
-                    let mut app = Applicability::MaybeIncorrect;
-
-                    let call_snip = &snip[dot + 1..];
-                    // Machine applicable when `call_snip` looks like `foobar()`
-                    if let Some(call_snip) = call_snip.strip_suffix("()").map(str::trim) {
-                        if call_snip.as_bytes().iter().all(|b| b.is_ascii_alphabetic() || *b == b'_') {
-                            app = Applicability::MachineApplicable;
-                        }
+            if let Some(snip) = snippet_opt(cx, span)
+                && let Some(dot) = snip.rfind('.')
+            {
+                let sugg_span = span.with_lo(
+                    span.lo() + BytePos(u32::try_from(dot).unwrap())
+                );
+                let mut app = Applicability::MaybeIncorrect;
+
+                let call_snip = &snip[dot + 1..];
+                // Machine applicable when `call_snip` looks like `foobar()`
+                if let Some(call_snip) = call_snip.strip_suffix("()").map(str::trim) {
+                    if call_snip.as_bytes().iter().all(|b| b.is_ascii_alphabetic() || *b == b'_') {
+                        app = Applicability::MachineApplicable;
                     }
+                }
 
-                    span_lint_hir_and_then(cx, REDUNDANT_CLONE, node, sugg_span, "redundant clone", |diag| {
-                        diag.span_suggestion(
-                            sugg_span,
-                            "remove this",
-                            "",
-                            app,
+                span_lint_hir_and_then(cx, REDUNDANT_CLONE, node, sugg_span, "redundant clone", |diag| {
+                    diag.span_suggestion(
+                        sugg_span,
+                        "remove this",
+                        "",
+                        app,
+                    );
+                    if clone_usage.cloned_used {
+                        diag.span_note(
+                            span,
+                            "cloned value is neither consumed nor mutated",
                         );
-                        if clone_usage.cloned_used {
-                            diag.span_note(
-                                span,
-                                "cloned value is neither consumed nor mutated",
-                            );
-                        } else {
-                            diag.span_note(
-                                span.with_hi(span.lo() + BytePos(u32::try_from(dot).unwrap())),
-                                "this value is dropped without further use",
-                            );
-                        }
-                    });
-                } else {
-                    span_lint_hir(cx, REDUNDANT_CLONE, node, span, "redundant clone");
-                }
+                    } else {
+                        diag.span_note(
+                            span.with_hi(span.lo() + BytePos(u32::try_from(dot).unwrap())),
+                            "this value is dropped without further use",
+                        );
+                    }
+                });
+            } else {
+                span_lint_hir(cx, REDUNDANT_CLONE, node, span, "redundant clone");
             }
         }
     }
@@ -262,18 +258,16 @@ fn is_call_with_ref_arg<'tcx>(
     mir: &'tcx mir::Body<'tcx>,
     kind: &'tcx mir::TerminatorKind<'tcx>,
 ) -> Option<(def_id::DefId, mir::Local, Ty<'tcx>, mir::Local)> {
-    if_chain! {
-        if let mir::TerminatorKind::Call { func, args, destination, .. } = kind;
-        if args.len() == 1;
-        if let mir::Operand::Move(mir::Place { local, .. }) = &args[0];
-        if let ty::FnDef(def_id, _) = *func.ty(mir, cx.tcx).kind();
-        if let (inner_ty, 1) = walk_ptrs_ty_depth(args[0].ty(mir, cx.tcx));
-        if !is_copy(cx, inner_ty);
-        then {
-            Some((def_id, *local, inner_ty, destination.as_local()?))
-        } else {
-            None
-        }
+    if let mir::TerminatorKind::Call { func, args, destination, .. } = kind
+        && args.len() == 1
+        && let mir::Operand::Move(mir::Place { local, .. }) = &args[0]
+        && let ty::FnDef(def_id, _) = *func.ty(mir, cx.tcx).kind()
+        && let (inner_ty, 1) = walk_ptrs_ty_depth(args[0].ty(mir, cx.tcx))
+        && !is_copy(cx, inner_ty)
+    {
+        Some((def_id, *local, inner_ty, destination.as_local()?))
+    } else {
+        None
     }
 }
 
diff --git a/clippy_lints/src/redundant_closure_call.rs b/clippy_lints/src/redundant_closure_call.rs
index e679fab5323..e8906d51e88 100644
--- a/clippy_lints/src/redundant_closure_call.rs
+++ b/clippy_lints/src/redundant_closure_call.rs
@@ -201,14 +201,12 @@ impl<'tcx> LateLintPass<'tcx> for RedundantClosureCall {
                 type NestedFilter = nested_filter::OnlyBodies;
 
                 fn visit_expr(&mut self, expr: &'tcx hir::Expr<'tcx>) {
-                    if_chain! {
-                        if let hir::ExprKind::Call(closure, _) = expr.kind;
-                        if let hir::ExprKind::Path(hir::QPath::Resolved(_, path)) = closure.kind;
-                        if self.path.segments[0].ident == path.segments[0].ident;
-                        if self.path.res == path.res;
-                        then {
-                            self.count += 1;
-                        }
+                    if let hir::ExprKind::Call(closure, _) = expr.kind
+                        && let hir::ExprKind::Path(hir::QPath::Resolved(_, path)) = closure.kind
+                        && self.path.segments[0].ident == path.segments[0].ident
+                        && self.path.res == path.res
+                    {
+                        self.count += 1;
                     }
                     hir_visit::walk_expr(self, expr);
                 }
@@ -223,25 +221,23 @@ impl<'tcx> LateLintPass<'tcx> for RedundantClosureCall {
         }
 
         for w in block.stmts.windows(2) {
-            if_chain! {
-                if let hir::StmtKind::Local(local) = w[0].kind;
-                if let Option::Some(t) = local.init;
-                if let hir::ExprKind::Closure { .. } = t.kind;
-                if let hir::PatKind::Binding(_, _, ident, _) = local.pat.kind;
-                if let hir::StmtKind::Semi(second) = w[1].kind;
-                if let hir::ExprKind::Assign(_, call, _) = second.kind;
-                if let hir::ExprKind::Call(closure, _) = call.kind;
-                if let hir::ExprKind::Path(hir::QPath::Resolved(_, path)) = closure.kind;
-                if ident == path.segments[0].ident;
-                if count_closure_usage(cx, block, path) == 1;
-                then {
-                    span_lint(
-                        cx,
-                        REDUNDANT_CLOSURE_CALL,
-                        second.span,
-                        "closure called just once immediately after it was declared",
-                    );
-                }
+            if let hir::StmtKind::Local(local) = w[0].kind
+                && let Option::Some(t) = local.init
+                && let hir::ExprKind::Closure { .. } = t.kind
+                && let hir::PatKind::Binding(_, _, ident, _) = local.pat.kind
+                && let hir::StmtKind::Semi(second) = w[1].kind
+                && let hir::ExprKind::Assign(_, call, _) = second.kind
+                && let hir::ExprKind::Call(closure, _) = call.kind
+                && let hir::ExprKind::Path(hir::QPath::Resolved(_, path)) = closure.kind
+                && ident == path.segments[0].ident
+                && count_closure_usage(cx, block, path) == 1
+            {
+                span_lint(
+                    cx,
+                    REDUNDANT_CLOSURE_CALL,
+                    second.span,
+                    "closure called just once immediately after it was declared",
+                );
             }
         }
     }
diff --git a/clippy_lints/src/redundant_locals.rs b/clippy_lints/src/redundant_locals.rs
index 6bc0d06183f..15b784039b6 100644
--- a/clippy_lints/src/redundant_locals.rs
+++ b/clippy_lints/src/redundant_locals.rs
@@ -46,40 +46,38 @@ declare_lint_pass!(RedundantLocals => [REDUNDANT_LOCALS]);
 
 impl<'tcx> LateLintPass<'tcx> for RedundantLocals {
     fn check_local(&mut self, cx: &LateContext<'tcx>, local: &'tcx Local<'tcx>) {
-        if_chain! {
-            if !local.span.is_desugaring(DesugaringKind::Async);
+        if !local.span.is_desugaring(DesugaringKind::Async)
             // the pattern is a single by-value binding
-            if let PatKind::Binding(BindingAnnotation(ByRef::No, mutability), _, ident, None) = local.pat.kind;
+            && let PatKind::Binding(BindingAnnotation(ByRef::No, mutability), _, ident, None) = local.pat.kind
             // the binding is not type-ascribed
-            if local.ty.is_none();
+            && local.ty.is_none()
             // the expression is a resolved path
-            if let Some(expr) = local.init;
-            if let ExprKind::Path(qpath @ QPath::Resolved(None, path)) = expr.kind;
+            && let Some(expr) = local.init
+            && let ExprKind::Path(qpath @ QPath::Resolved(None, path)) = expr.kind
             // the path is a single segment equal to the local's name
-            if let [last_segment] = path.segments;
-            if last_segment.ident == ident;
+            && let [last_segment] = path.segments
+            && last_segment.ident == ident
             // resolve the path to its defining binding pattern
-            if let Res::Local(binding_id) = cx.qpath_res(&qpath, expr.hir_id);
-            if let Node::Pat(binding_pat) = cx.tcx.hir().get(binding_id);
+            && let Res::Local(binding_id) = cx.qpath_res(&qpath, expr.hir_id)
+            && let Node::Pat(binding_pat) = cx.tcx.hir().get(binding_id)
             // the previous binding has the same mutability
-            if find_binding(binding_pat, ident).is_some_and(|bind| bind.1 == mutability);
+            && find_binding(binding_pat, ident).is_some_and(|bind| bind.1 == mutability)
             // the local does not change the effect of assignments to the binding. see #11290
-            if !affects_assignments(cx, mutability, binding_id, local.hir_id);
+            && !affects_assignments(cx, mutability, binding_id, local.hir_id)
             // the local does not affect the code's drop behavior
-            if !needs_ordered_drop(cx, cx.typeck_results().expr_ty(expr));
+            && !needs_ordered_drop(cx, cx.typeck_results().expr_ty(expr))
             // the local is user-controlled
-            if !in_external_macro(cx.sess(), local.span);
-            if !is_from_proc_macro(cx, expr);
-            then {
-                span_lint_and_help(
-                    cx,
-                    REDUNDANT_LOCALS,
-                    local.span,
-                    &format!("redundant redefinition of a binding `{ident}`"),
-                    Some(binding_pat.span),
-                    &format!("`{ident}` is initially defined here"),
-                );
-            }
+            && !in_external_macro(cx.sess(), local.span)
+            && !is_from_proc_macro(cx, expr)
+        {
+            span_lint_and_help(
+                cx,
+                REDUNDANT_LOCALS,
+                local.span,
+                &format!("redundant redefinition of a binding `{ident}`"),
+                Some(binding_pat.span),
+                &format!("`{ident}` is initially defined here"),
+            );
         }
     }
 }
diff --git a/clippy_lints/src/redundant_pub_crate.rs b/clippy_lints/src/redundant_pub_crate.rs
index 03673eb27f8..d25e8c2de03 100644
--- a/clippy_lints/src/redundant_pub_crate.rs
+++ b/clippy_lints/src/redundant_pub_crate.rs
@@ -45,28 +45,26 @@ impl_lint_pass!(RedundantPubCrate => [REDUNDANT_PUB_CRATE]);
 
 impl<'tcx> LateLintPass<'tcx> for RedundantPubCrate {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
-        if_chain! {
-            if cx.tcx.visibility(item.owner_id.def_id) == ty::Visibility::Restricted(CRATE_DEF_ID.to_def_id());
-            if !cx.effective_visibilities.is_exported(item.owner_id.def_id) && self.is_exported.last() == Some(&false);
-            if is_not_macro_export(item);
-            then {
-                let span = item.span.with_hi(item.ident.span.hi());
-                let descr = cx.tcx.def_kind(item.owner_id).descr(item.owner_id.to_def_id());
-                span_lint_and_then(
-                    cx,
-                    REDUNDANT_PUB_CRATE,
-                    span,
-                    &format!("pub(crate) {descr} inside private module"),
-                    |diag| {
-                        diag.span_suggestion(
-                            item.vis_span,
-                            "consider using",
-                            "pub".to_string(),
-                            Applicability::MachineApplicable,
-                        );
-                    },
-                );
-            }
+        if cx.tcx.visibility(item.owner_id.def_id) == ty::Visibility::Restricted(CRATE_DEF_ID.to_def_id())
+            && !cx.effective_visibilities.is_exported(item.owner_id.def_id) && self.is_exported.last() == Some(&false)
+            && is_not_macro_export(item)
+        {
+            let span = item.span.with_hi(item.ident.span.hi());
+            let descr = cx.tcx.def_kind(item.owner_id).descr(item.owner_id.to_def_id());
+            span_lint_and_then(
+                cx,
+                REDUNDANT_PUB_CRATE,
+                span,
+                &format!("pub(crate) {descr} inside private module"),
+                |diag| {
+                    diag.span_suggestion(
+                        item.vis_span,
+                        "consider using",
+                        "pub".to_string(),
+                        Applicability::MachineApplicable,
+                    );
+                },
+            );
         }
 
         if let ItemKind::Mod { .. } = item.kind {
diff --git a/clippy_lints/src/redundant_slicing.rs b/clippy_lints/src/redundant_slicing.rs
index 7adbd67912c..48bcd676ab9 100644
--- a/clippy_lints/src/redundant_slicing.rs
+++ b/clippy_lints/src/redundant_slicing.rs
@@ -78,92 +78,90 @@ impl<'tcx> LateLintPass<'tcx> for RedundantSlicing {
         }
 
         let ctxt = expr.span.ctxt();
-        if_chain! {
-            if let ExprKind::AddrOf(BorrowKind::Ref, mutability, addressee) = expr.kind;
-            if addressee.span.ctxt() == ctxt;
-            if let ExprKind::Index(indexed, range, _) = addressee.kind;
-            if is_type_lang_item(cx, cx.typeck_results().expr_ty_adjusted(range), LangItem::RangeFull);
-            then {
-                let (expr_ty, expr_ref_count) = peel_mid_ty_refs(cx.typeck_results().expr_ty(expr));
-                let (indexed_ty, indexed_ref_count) = peel_mid_ty_refs(cx.typeck_results().expr_ty(indexed));
-                let parent_expr = get_parent_expr(cx, expr);
-                let needs_parens_for_prefix = parent_expr.map_or(false, |parent| {
-                    parent.precedence().order() > PREC_PREFIX
-                });
-                let mut app = Applicability::MachineApplicable;
+        if let ExprKind::AddrOf(BorrowKind::Ref, mutability, addressee) = expr.kind
+            && addressee.span.ctxt() == ctxt
+            && let ExprKind::Index(indexed, range, _) = addressee.kind
+            && is_type_lang_item(cx, cx.typeck_results().expr_ty_adjusted(range), LangItem::RangeFull)
+        {
+            let (expr_ty, expr_ref_count) = peel_mid_ty_refs(cx.typeck_results().expr_ty(expr));
+            let (indexed_ty, indexed_ref_count) = peel_mid_ty_refs(cx.typeck_results().expr_ty(indexed));
+            let parent_expr = get_parent_expr(cx, expr);
+            let needs_parens_for_prefix = parent_expr.map_or(false, |parent| {
+                parent.precedence().order() > PREC_PREFIX
+            });
+            let mut app = Applicability::MachineApplicable;
 
-                let ((lint, msg), help, sugg) = if expr_ty == indexed_ty {
-                    if expr_ref_count > indexed_ref_count {
-                        // Indexing takes self by reference and can't return a reference to that
-                        // reference as it's a local variable. The only way this could happen is if
-                        // `self` contains a reference to the `Self` type. If this occurs then the
-                        // lint no longer applies as it's essentially a field access, which is not
-                        // redundant.
-                        return;
-                    }
-                    let deref_count = indexed_ref_count - expr_ref_count;
+            let ((lint, msg), help, sugg) = if expr_ty == indexed_ty {
+                if expr_ref_count > indexed_ref_count {
+                    // Indexing takes self by reference and can't return a reference to that
+                    // reference as it's a local variable. The only way this could happen is if
+                    // `self` contains a reference to the `Self` type. If this occurs then the
+                    // lint no longer applies as it's essentially a field access, which is not
+                    // redundant.
+                    return;
+                }
+                let deref_count = indexed_ref_count - expr_ref_count;
 
-                    let (lint, reborrow_str, help_str) = if mutability == Mutability::Mut {
-                        // The slice was used to reborrow the mutable reference.
-                        (DEREF_BY_SLICING_LINT, "&mut *", "reborrow the original value instead")
-                    } else if matches!(
-                        parent_expr,
-                        Some(Expr {
-                            kind: ExprKind::AddrOf(BorrowKind::Ref, Mutability::Mut, _),
-                            ..
-                        })
-                    ) || cx.typeck_results().expr_adjustments(expr).first().map_or(false, |a| {
-                        matches!(a.kind, Adjust::Borrow(AutoBorrow::Ref(_, AutoBorrowMutability::Mut { .. })))
-                    }) {
-                        // The slice was used to make a temporary reference.
-                        (DEREF_BY_SLICING_LINT, "&*", "reborrow the original value instead")
-                    } else if deref_count != 0 {
-                        (DEREF_BY_SLICING_LINT, "", "dereference the original value instead")
-                    } else {
-                        (REDUNDANT_SLICING_LINT, "", "use the original value instead")
-                    };
+                let (lint, reborrow_str, help_str) = if mutability == Mutability::Mut {
+                    // The slice was used to reborrow the mutable reference.
+                    (DEREF_BY_SLICING_LINT, "&mut *", "reborrow the original value instead")
+                } else if matches!(
+                    parent_expr,
+                    Some(Expr {
+                        kind: ExprKind::AddrOf(BorrowKind::Ref, Mutability::Mut, _),
+                        ..
+                    })
+                ) || cx.typeck_results().expr_adjustments(expr).first().map_or(false, |a| {
+                    matches!(a.kind, Adjust::Borrow(AutoBorrow::Ref(_, AutoBorrowMutability::Mut { .. })))
+                }) {
+                    // The slice was used to make a temporary reference.
+                    (DEREF_BY_SLICING_LINT, "&*", "reborrow the original value instead")
+                } else if deref_count != 0 {
+                    (DEREF_BY_SLICING_LINT, "", "dereference the original value instead")
+                } else {
+                    (REDUNDANT_SLICING_LINT, "", "use the original value instead")
+                };
 
-                    let snip = snippet_with_context(cx, indexed.span, ctxt, "..", &mut app).0;
-                    let sugg = if (deref_count != 0 || !reborrow_str.is_empty()) && needs_parens_for_prefix {
-                        format!("({reborrow_str}{}{snip})", "*".repeat(deref_count))
-                    } else {
-                        format!("{reborrow_str}{}{snip}", "*".repeat(deref_count))
-                    };
+                let snip = snippet_with_context(cx, indexed.span, ctxt, "..", &mut app).0;
+                let sugg = if (deref_count != 0 || !reborrow_str.is_empty()) && needs_parens_for_prefix {
+                    format!("({reborrow_str}{}{snip})", "*".repeat(deref_count))
+                } else {
+                    format!("{reborrow_str}{}{snip}", "*".repeat(deref_count))
+                };
 
-                    (lint, help_str, sugg)
-                } else if let Some(target_id) = cx.tcx.lang_items().deref_target() {
-                    if let Ok(deref_ty) = cx.tcx.try_normalize_erasing_regions(
-                        cx.param_env,
-                        Ty::new_projection(cx.tcx,target_id, cx.tcx.mk_args(&[GenericArg::from(indexed_ty)])),
-                    ) {
-                        if deref_ty == expr_ty {
-                            let snip = snippet_with_context(cx, indexed.span, ctxt, "..", &mut app).0;
-                            let sugg = if needs_parens_for_prefix {
-                                format!("(&{}{}*{snip})", mutability.prefix_str(), "*".repeat(indexed_ref_count))
-                            } else {
-                                format!("&{}{}*{snip}", mutability.prefix_str(), "*".repeat(indexed_ref_count))
-                            };
-                            (DEREF_BY_SLICING_LINT, "dereference the original value instead", sugg)
+                (lint, help_str, sugg)
+            } else if let Some(target_id) = cx.tcx.lang_items().deref_target() {
+                if let Ok(deref_ty) = cx.tcx.try_normalize_erasing_regions(
+                    cx.param_env,
+                    Ty::new_projection(cx.tcx,target_id, cx.tcx.mk_args(&[GenericArg::from(indexed_ty)])),
+                ) {
+                    if deref_ty == expr_ty {
+                        let snip = snippet_with_context(cx, indexed.span, ctxt, "..", &mut app).0;
+                        let sugg = if needs_parens_for_prefix {
+                            format!("(&{}{}*{snip})", mutability.prefix_str(), "*".repeat(indexed_ref_count))
                         } else {
-                            return;
-                        }
+                            format!("&{}{}*{snip}", mutability.prefix_str(), "*".repeat(indexed_ref_count))
+                        };
+                        (DEREF_BY_SLICING_LINT, "dereference the original value instead", sugg)
                     } else {
                         return;
                     }
                 } else {
                     return;
-                };
+                }
+            } else {
+                return;
+            };
 
-                span_lint_and_sugg(
-                    cx,
-                    lint,
-                    expr.span,
-                    msg,
-                    help,
-                    sugg,
-                    app,
-                );
-            }
+            span_lint_and_sugg(
+                cx,
+                lint,
+                expr.span,
+                msg,
+                help,
+                sugg,
+                app,
+            );
         }
     }
 }
diff --git a/clippy_lints/src/ref_option_ref.rs b/clippy_lints/src/ref_option_ref.rs
index c984a8286eb..472cde7cd15 100644
--- a/clippy_lints/src/ref_option_ref.rs
+++ b/clippy_lints/src/ref_option_ref.rs
@@ -38,34 +38,32 @@ declare_lint_pass!(RefOptionRef => [REF_OPTION_REF]);
 
 impl<'tcx> LateLintPass<'tcx> for RefOptionRef {
     fn check_ty(&mut self, cx: &LateContext<'tcx>, ty: &'tcx Ty<'tcx>) {
-        if_chain! {
-            if let TyKind::Ref(_, ref mut_ty) = ty.kind;
-            if mut_ty.mutbl == Mutability::Not;
-            if let TyKind::Path(ref qpath) = &mut_ty.ty.kind;
-            let last = last_path_segment(qpath);
-            if let Some(def_id) = last.res.opt_def_id();
+        if let TyKind::Ref(_, ref mut_ty) = ty.kind
+            && mut_ty.mutbl == Mutability::Not
+            && let TyKind::Path(ref qpath) = &mut_ty.ty.kind
+            && let last = last_path_segment(qpath)
+            && let Some(def_id) = last.res.opt_def_id()
 
-            if cx.tcx.is_diagnostic_item(sym::Option, def_id);
-            if let Some(params) = last_path_segment(qpath).args ;
-            if params.parenthesized == GenericArgsParentheses::No;
-            if let Some(inner_ty) = params.args.iter().find_map(|arg| match arg {
+            && cx.tcx.is_diagnostic_item(sym::Option, def_id)
+            && let Some(params) = last_path_segment(qpath).args 
+            && params.parenthesized == GenericArgsParentheses::No
+            && let Some(inner_ty) = params.args.iter().find_map(|arg| match arg {
                 GenericArg::Type(inner_ty) => Some(inner_ty),
                 _ => None,
-            });
-            if let TyKind::Ref(_, ref inner_mut_ty) = inner_ty.kind;
-            if inner_mut_ty.mutbl == Mutability::Not;
+            })
+            && let TyKind::Ref(_, ref inner_mut_ty) = inner_ty.kind
+            && inner_mut_ty.mutbl == Mutability::Not
 
-            then {
-                span_lint_and_sugg(
-                    cx,
-                    REF_OPTION_REF,
-                    ty.span,
-                    "since `&` implements the `Copy` trait, `&Option<&T>` can be simplified to `Option<&T>`",
-                    "try",
-                    format!("Option<{}>", &snippet(cx, inner_ty.span, "..")),
-                    Applicability::MaybeIncorrect,
-                );
-            }
+        {
+            span_lint_and_sugg(
+                cx,
+                REF_OPTION_REF,
+                ty.span,
+                "since `&` implements the `Copy` trait, `&Option<&T>` can be simplified to `Option<&T>`",
+                "try",
+                format!("Option<{}>", &snippet(cx, inner_ty.span, "..")),
+                Applicability::MaybeIncorrect,
+            );
         }
     }
 }
diff --git a/clippy_lints/src/reference.rs b/clippy_lints/src/reference.rs
index 12da29f1108..74d2814f91e 100644
--- a/clippy_lints/src/reference.rs
+++ b/clippy_lints/src/reference.rs
@@ -47,58 +47,56 @@ fn without_parens(mut e: &Expr) -> &Expr {
 
 impl EarlyLintPass for DerefAddrOf {
     fn check_expr(&mut self, cx: &EarlyContext<'_>, e: &Expr) {
-        if_chain! {
-            if let ExprKind::Unary(UnOp::Deref, ref deref_target) = e.kind;
-            if let ExprKind::AddrOf(_, ref mutability, ref addrof_target) = without_parens(deref_target).kind;
-            if deref_target.span.eq_ctxt(e.span);
-            if !addrof_target.span.from_expansion();
-            then {
-                let mut applicability = Applicability::MachineApplicable;
-                let sugg = if e.span.from_expansion() {
-                    if let Some(macro_source) = snippet_opt(cx, e.span) {
-                        // Remove leading whitespace from the given span
-                        // e.g: ` $visitor` turns into `$visitor`
-                        let trim_leading_whitespaces = |span| {
-                            snippet_opt(cx, span).and_then(|snip| {
-                                #[expect(clippy::cast_possible_truncation)]
-                                snip.find(|c: char| !c.is_whitespace()).map(|pos| {
-                                    span.lo() + BytePos(pos as u32)
-                                })
-                            }).map_or(span, |start_no_whitespace| e.span.with_lo(start_no_whitespace))
-                        };
-
-                        let mut generate_snippet = |pattern: &str| {
+        if let ExprKind::Unary(UnOp::Deref, ref deref_target) = e.kind
+            && let ExprKind::AddrOf(_, ref mutability, ref addrof_target) = without_parens(deref_target).kind
+            && deref_target.span.eq_ctxt(e.span)
+            && !addrof_target.span.from_expansion()
+        {
+            let mut applicability = Applicability::MachineApplicable;
+            let sugg = if e.span.from_expansion() {
+                if let Some(macro_source) = snippet_opt(cx, e.span) {
+                    // Remove leading whitespace from the given span
+                    // e.g: ` $visitor` turns into `$visitor`
+                    let trim_leading_whitespaces = |span| {
+                        snippet_opt(cx, span).and_then(|snip| {
                             #[expect(clippy::cast_possible_truncation)]
-                            macro_source.rfind(pattern).map(|pattern_pos| {
-                                let rpos = pattern_pos + pattern.len();
-                                let span_after_ref = e.span.with_lo(BytePos(e.span.lo().0 + rpos as u32));
-                                let span = trim_leading_whitespaces(span_after_ref);
-                                snippet_with_applicability(cx, span, "_", &mut applicability)
+                            snip.find(|c: char| !c.is_whitespace()).map(|pos| {
+                                span.lo() + BytePos(pos as u32)
                             })
-                        };
+                        }).map_or(span, |start_no_whitespace| e.span.with_lo(start_no_whitespace))
+                    };
+
+                    let mut generate_snippet = |pattern: &str| {
+                        #[expect(clippy::cast_possible_truncation)]
+                        macro_source.rfind(pattern).map(|pattern_pos| {
+                            let rpos = pattern_pos + pattern.len();
+                            let span_after_ref = e.span.with_lo(BytePos(e.span.lo().0 + rpos as u32));
+                            let span = trim_leading_whitespaces(span_after_ref);
+                            snippet_with_applicability(cx, span, "_", &mut applicability)
+                        })
+                    };
 
-                        if *mutability == Mutability::Mut {
-                            generate_snippet("mut")
-                        } else {
-                            generate_snippet("&")
-                        }
+                    if *mutability == Mutability::Mut {
+                        generate_snippet("mut")
                     } else {
-                        Some(snippet_with_applicability(cx, e.span, "_", &mut applicability))
+                        generate_snippet("&")
                     }
                 } else {
-                    Some(snippet_with_applicability(cx, addrof_target.span, "_", &mut applicability))
-                };
-                if let Some(sugg) = sugg {
-                    span_lint_and_sugg(
-                        cx,
-                        DEREF_ADDROF,
-                        e.span,
-                        "immediately dereferencing a reference",
-                        "try",
-                        sugg.to_string(),
-                        applicability,
-                    );
+                    Some(snippet_with_applicability(cx, e.span, "_", &mut applicability))
                 }
+            } else {
+                Some(snippet_with_applicability(cx, addrof_target.span, "_", &mut applicability))
+            };
+            if let Some(sugg) = sugg {
+                span_lint_and_sugg(
+                    cx,
+                    DEREF_ADDROF,
+                    e.span,
+                    "immediately dereferencing a reference",
+                    "try",
+                    sugg.to_string(),
+                    applicability,
+                );
             }
         }
     }
diff --git a/clippy_lints/src/regex.rs b/clippy_lints/src/regex.rs
index b795e4b15ba..3571b9bfb8d 100644
--- a/clippy_lints/src/regex.rs
+++ b/clippy_lints/src/regex.rs
@@ -191,13 +191,11 @@ fn is_trivial_regex(s: &regex_syntax::hir::Hir) -> Option<&'static str> {
 }
 
 fn check_set<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, utf8: bool) {
-    if_chain! {
-        if let ExprKind::AddrOf(BorrowKind::Ref, _, expr) = expr.kind;
-        if let ExprKind::Array(exprs) = expr.kind;
-        then {
-            for expr in exprs {
-                check_regex(cx, expr, utf8);
-            }
+    if let ExprKind::AddrOf(BorrowKind::Ref, _, expr) = expr.kind
+        && let ExprKind::Array(exprs) = expr.kind
+    {
+        for expr in exprs {
+            check_regex(cx, expr, utf8);
         }
     }
 }
diff --git a/clippy_lints/src/return_self_not_must_use.rs b/clippy_lints/src/return_self_not_must_use.rs
index 245029a066d..8913f4a2e7e 100644
--- a/clippy_lints/src/return_self_not_must_use.rs
+++ b/clippy_lints/src/return_self_not_must_use.rs
@@ -69,35 +69,33 @@ declare_clippy_lint! {
 declare_lint_pass!(ReturnSelfNotMustUse => [RETURN_SELF_NOT_MUST_USE]);
 
 fn check_method(cx: &LateContext<'_>, decl: &FnDecl<'_>, fn_def: LocalDefId, span: Span, owner_id: OwnerId) {
-    if_chain! {
+    if !in_external_macro(cx.sess(), span)
         // If it comes from an external macro, better ignore it.
-        if !in_external_macro(cx.sess(), span);
-        if decl.implicit_self.has_implicit_self();
+        && decl.implicit_self.has_implicit_self()
         // We only show this warning for public exported methods.
-        if cx.effective_visibilities.is_exported(fn_def);
+        && cx.effective_visibilities.is_exported(fn_def)
         // We don't want to emit this lint if the `#[must_use]` attribute is already there.
-        if !cx.tcx.hir().attrs(owner_id.into()).iter().any(|attr| attr.has_name(sym::must_use));
-        if cx.tcx.visibility(fn_def.to_def_id()).is_public();
-        let ret_ty = return_ty(cx, owner_id);
-        let self_arg = nth_arg(cx, owner_id, 0);
+        && !cx.tcx.hir().attrs(owner_id.into()).iter().any(|attr| attr.has_name(sym::must_use))
+        && cx.tcx.visibility(fn_def.to_def_id()).is_public()
+        && let ret_ty = return_ty(cx, owner_id)
+        && let self_arg = nth_arg(cx, owner_id, 0)
         // If `Self` has the same type as the returned type, then we want to warn.
         //
         // For this check, we don't want to remove the reference on the returned type because if
         // there is one, we shouldn't emit a warning!
-        if self_arg.peel_refs() == ret_ty;
+        && self_arg.peel_refs() == ret_ty
         // If `Self` is already marked as `#[must_use]`, no need for the attribute here.
-        if !is_must_use_ty(cx, ret_ty);
+        && !is_must_use_ty(cx, ret_ty)
 
-        then {
-            span_lint_and_help(
-                cx,
-                RETURN_SELF_NOT_MUST_USE,
-                span,
-                "missing `#[must_use]` attribute on a method returning `Self`",
-                None,
-                "consider adding the `#[must_use]` attribute to the method or directly to the `Self` type"
-            );
-        }
+    {
+        span_lint_and_help(
+            cx,
+            RETURN_SELF_NOT_MUST_USE,
+            span,
+            "missing `#[must_use]` attribute on a method returning `Self`",
+            None,
+            "consider adding the `#[must_use]` attribute to the method or directly to the `Self` type"
+        );
     }
 }
 
@@ -111,18 +109,16 @@ impl<'tcx> LateLintPass<'tcx> for ReturnSelfNotMustUse {
         span: Span,
         fn_def: LocalDefId,
     ) {
-        if_chain! {
+        if matches!(kind, FnKind::Method(_, _))
             // We are only interested in methods, not in functions or associated functions.
-            if matches!(kind, FnKind::Method(_, _));
-            if let Some(impl_def) = cx.tcx.impl_of_method(fn_def.to_def_id());
+            && let Some(impl_def) = cx.tcx.impl_of_method(fn_def.to_def_id())
             // We don't want this method to be te implementation of a trait because the
             // `#[must_use]` should be put on the trait definition directly.
-            if cx.tcx.trait_id_of_impl(impl_def).is_none();
+            && cx.tcx.trait_id_of_impl(impl_def).is_none()
 
-            then {
-                let hir_id = cx.tcx.hir().local_def_id_to_hir_id(fn_def);
-                check_method(cx, decl, fn_def, span, hir_id.expect_owner());
-            }
+        {
+            let hir_id = cx.tcx.hir().local_def_id_to_hir_id(fn_def);
+            check_method(cx, decl, fn_def, span, hir_id.expect_owner());
         }
     }
 
diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
index 72235a954ba..bab20d0e1f6 100644
--- a/clippy_lints/src/returns.rs
+++ b/clippy_lints/src/returns.rs
@@ -189,50 +189,48 @@ impl<'tcx> LateLintPass<'tcx> for Return {
 
     fn check_block(&mut self, cx: &LateContext<'tcx>, block: &'tcx Block<'_>) {
         // we need both a let-binding stmt and an expr
-        if_chain! {
-            if let Some(retexpr) = block.expr;
-            if let Some(stmt) = block.stmts.iter().last();
-            if let StmtKind::Local(local) = &stmt.kind;
-            if local.ty.is_none();
-            if cx.tcx.hir().attrs(local.hir_id).is_empty();
-            if let Some(initexpr) = &local.init;
-            if let PatKind::Binding(_, local_id, _, _) = local.pat.kind;
-            if path_to_local_id(retexpr, local_id);
-            if !last_statement_borrows(cx, initexpr);
-            if !in_external_macro(cx.sess(), initexpr.span);
-            if !in_external_macro(cx.sess(), retexpr.span);
-            if !local.span.from_expansion();
-            then {
-                span_lint_hir_and_then(
-                    cx,
-                    LET_AND_RETURN,
-                    retexpr.hir_id,
-                    retexpr.span,
-                    "returning the result of a `let` binding from a block",
-                    |err| {
-                        err.span_label(local.span, "unnecessary `let` binding");
+        if let Some(retexpr) = block.expr
+            && let Some(stmt) = block.stmts.iter().last()
+            && let StmtKind::Local(local) = &stmt.kind
+            && local.ty.is_none()
+            && cx.tcx.hir().attrs(local.hir_id).is_empty()
+            && let Some(initexpr) = &local.init
+            && let PatKind::Binding(_, local_id, _, _) = local.pat.kind
+            && path_to_local_id(retexpr, local_id)
+            && !last_statement_borrows(cx, initexpr)
+            && !in_external_macro(cx.sess(), initexpr.span)
+            && !in_external_macro(cx.sess(), retexpr.span)
+            && !local.span.from_expansion()
+        {
+            span_lint_hir_and_then(
+                cx,
+                LET_AND_RETURN,
+                retexpr.hir_id,
+                retexpr.span,
+                "returning the result of a `let` binding from a block",
+                |err| {
+                    err.span_label(local.span, "unnecessary `let` binding");
 
-                        if let Some(mut snippet) = snippet_opt(cx, initexpr.span) {
-                            if !cx.typeck_results().expr_adjustments(retexpr).is_empty() {
-                                if !has_enclosing_paren(&snippet) {
-                                    snippet = format!("({snippet})");
-                                }
-                                snippet.push_str(" as _");
+                    if let Some(mut snippet) = snippet_opt(cx, initexpr.span) {
+                        if !cx.typeck_results().expr_adjustments(retexpr).is_empty() {
+                            if !has_enclosing_paren(&snippet) {
+                                snippet = format!("({snippet})");
                             }
-                            err.multipart_suggestion(
-                                "return the expression directly",
-                                vec![
-                                    (local.span, String::new()),
-                                    (retexpr.span, snippet),
-                                ],
-                                Applicability::MachineApplicable,
-                            );
-                        } else {
-                            err.span_help(initexpr.span, "this expression can be directly returned");
+                            snippet.push_str(" as _");
                         }
-                    },
-                );
-            }
+                        err.multipart_suggestion(
+                            "return the expression directly",
+                            vec![
+                                (local.span, String::new()),
+                                (retexpr.span, snippet),
+                            ],
+                            Applicability::MachineApplicable,
+                        );
+                    } else {
+                        err.span_help(initexpr.span, "this expression can be directly returned");
+                    }
+                },
+            );
         }
     }
 
diff --git a/clippy_lints/src/same_name_method.rs b/clippy_lints/src/same_name_method.rs
index 9587326ca00..a6ad0b5cc1e 100644
--- a/clippy_lints/src/same_name_method.rs
+++ b/clippy_lints/src/same_name_method.rs
@@ -75,26 +75,24 @@ impl<'tcx> LateLintPass<'tcx> for SameNameMethod {
 
                 match of_trait {
                     Some(trait_ref) => {
-                        let mut methods_in_trait: BTreeSet<Symbol> = if_chain! {
-                            if let Some(Node::TraitRef(TraitRef { path, .. })) =
-                                cx.tcx.hir().find(trait_ref.hir_ref_id);
-                            if let Res::Def(DefKind::Trait, did) = path.res;
-                            then{
-                                // FIXME: if
-                                // `rustc_middle::ty::assoc::AssocItems::items` is public,
-                                // we can iterate its keys instead of `in_definition_order`,
-                                // which's more efficient
-                                cx.tcx
-                                    .associated_items(did)
-                                    .in_definition_order()
-                                    .filter(|assoc_item| {
-                                        matches!(assoc_item.kind, AssocKind::Fn)
-                                    })
-                                    .map(|assoc_item| assoc_item.name)
-                                    .collect()
-                            }else{
-                                BTreeSet::new()
-                            }
+                        let mut methods_in_trait: BTreeSet<Symbol> = if let Some(Node::TraitRef(TraitRef { path, .. })) =
+                                cx.tcx.hir().find(trait_ref.hir_ref_id)
+                            && let Res::Def(DefKind::Trait, did) = path.res
+                        {
+                            // FIXME: if
+                            // `rustc_middle::ty::assoc::AssocItems::items` is public,
+                            // we can iterate its keys instead of `in_definition_order`,
+                            // which's more efficient
+                            cx.tcx
+                                .associated_items(did)
+                                .in_definition_order()
+                                .filter(|assoc_item| {
+                                    matches!(assoc_item.kind, AssocKind::Fn)
+                                })
+                                .map(|assoc_item| assoc_item.name)
+                                .collect()
+                        }else{
+                            BTreeSet::new()
                         };
 
                         let mut check_trait_method = |method_name: Symbol, trait_method_span: Span| {
diff --git a/clippy_lints/src/self_named_constructors.rs b/clippy_lints/src/self_named_constructors.rs
index b92014f68b3..578188a66af 100644
--- a/clippy_lints/src/self_named_constructors.rs
+++ b/clippy_lints/src/self_named_constructors.rs
@@ -70,22 +70,20 @@ impl<'tcx> LateLintPass<'tcx> for SelfNamedConstructors {
             return;
         }
 
-        if_chain! {
-            if let Some(self_def) = self_ty.ty_adt_def();
-            if let Some(self_local_did) = self_def.did().as_local();
-            let self_id = cx.tcx.hir().local_def_id_to_hir_id(self_local_did);
-            if let Some(Node::Item(x)) = cx.tcx.hir().find(self_id);
-            let type_name = x.ident.name.as_str().to_lowercase();
-            if impl_item.ident.name.as_str() == type_name || impl_item.ident.name.as_str().replace('_', "") == type_name;
+        if let Some(self_def) = self_ty.ty_adt_def()
+            && let Some(self_local_did) = self_def.did().as_local()
+            && let self_id = cx.tcx.hir().local_def_id_to_hir_id(self_local_did)
+            && let Some(Node::Item(x)) = cx.tcx.hir().find(self_id)
+            && let type_name = x.ident.name.as_str().to_lowercase()
+            && (impl_item.ident.name.as_str() == type_name || impl_item.ident.name.as_str().replace('_', "") == type_name)
 
-            then {
-                span_lint(
-                    cx,
-                    SELF_NAMED_CONSTRUCTORS,
-                    impl_item.span,
-                    &format!("constructor `{}` has the same name as the type", impl_item.ident.name),
-                );
-            }
+        {
+            span_lint(
+                cx,
+                SELF_NAMED_CONSTRUCTORS,
+                impl_item.span,
+                &format!("constructor `{}` has the same name as the type", impl_item.ident.name),
+            );
         }
     }
 }
diff --git a/clippy_lints/src/semicolon_if_nothing_returned.rs b/clippy_lints/src/semicolon_if_nothing_returned.rs
index ccf8b997705..dc606e90707 100644
--- a/clippy_lints/src/semicolon_if_nothing_returned.rs
+++ b/clippy_lints/src/semicolon_if_nothing_returned.rs
@@ -38,30 +38,28 @@ declare_lint_pass!(SemicolonIfNothingReturned => [SEMICOLON_IF_NOTHING_RETURNED]
 
 impl<'tcx> LateLintPass<'tcx> for SemicolonIfNothingReturned {
     fn check_block(&mut self, cx: &LateContext<'tcx>, block: &'tcx Block<'tcx>) {
-        if_chain! {
-            if !block.span.from_expansion();
-            if let Some(expr) = block.expr;
-            let t_expr = cx.typeck_results().expr_ty(expr);
-            if t_expr.is_unit();
-            let mut app = Applicability::MachineApplicable;
-            if let snippet = snippet_with_context(cx, expr.span, block.span.ctxt(), "}", &mut app).0;
-            if !snippet.ends_with('}') && !snippet.ends_with(';');
-            if cx.sess().source_map().is_multiline(block.span);
-            then {
-                // filter out the desugared `for` loop
-                if let ExprKind::DropTemps(..) = &expr.kind {
-                    return;
-                }
-                span_lint_and_sugg(
-                    cx,
-                    SEMICOLON_IF_NOTHING_RETURNED,
-                    expr.span.source_callsite(),
-                    "consider adding a `;` to the last statement for consistent formatting",
-                    "add a `;` here",
-                    format!("{snippet};"),
-                    app,
-                );
+        if !block.span.from_expansion()
+            && let Some(expr) = block.expr
+            && let t_expr = cx.typeck_results().expr_ty(expr)
+            && t_expr.is_unit()
+            && let mut app = Applicability::MachineApplicable
+            && let snippet = snippet_with_context(cx, expr.span, block.span.ctxt(), "}", &mut app).0
+            && !snippet.ends_with('}') && !snippet.ends_with(';')
+            && cx.sess().source_map().is_multiline(block.span)
+        {
+            // filter out the desugared `for` loop
+            if let ExprKind::DropTemps(..) = &expr.kind {
+                return;
             }
+            span_lint_and_sugg(
+                cx,
+                SEMICOLON_IF_NOTHING_RETURNED,
+                expr.span.source_callsite(),
+                "consider adding a `;` to the last statement for consistent formatting",
+                "add a `;` here",
+                format!("{snippet};"),
+                app,
+            );
         }
     }
 }
diff --git a/clippy_lints/src/size_of_in_element_count.rs b/clippy_lints/src/size_of_in_element_count.rs
index b940cac6047..2ea9122cfc4 100644
--- a/clippy_lints/src/size_of_in_element_count.rs
+++ b/clippy_lints/src/size_of_in_element_count.rs
@@ -39,16 +39,14 @@ declare_lint_pass!(SizeOfInElementCount => [SIZE_OF_IN_ELEMENT_COUNT]);
 fn get_size_of_ty<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, inverted: bool) -> Option<Ty<'tcx>> {
     match expr.kind {
         ExprKind::Call(count_func, _func_args) => {
-            if_chain! {
-                if !inverted;
-                if let ExprKind::Path(ref count_func_qpath) = count_func.kind;
-                if let Some(def_id) = cx.qpath_res(count_func_qpath, count_func.hir_id).opt_def_id();
-                if matches!(cx.tcx.get_diagnostic_name(def_id), Some(sym::mem_size_of | sym::mem_size_of_val));
-                then {
-                    cx.typeck_results().node_args(count_func.hir_id).types().next()
-                } else {
-                    None
-                }
+            if !inverted
+                && let ExprKind::Path(ref count_func_qpath) = count_func.kind
+                && let Some(def_id) = cx.qpath_res(count_func_qpath, count_func.hir_id).opt_def_id()
+                && matches!(cx.tcx.get_diagnostic_name(def_id), Some(sym::mem_size_of | sym::mem_size_of_val))
+            {
+                cx.typeck_results().node_args(count_func.hir_id).types().next()
+            } else {
+                None
             }
         },
         ExprKind::Binary(op, left, right) if BinOpKind::Mul == op.node => {
@@ -80,13 +78,12 @@ fn get_pointee_ty_and_count_expr<'tcx>(
         "wrapping_offset",
     ];
 
-    if_chain! {
+    if let ExprKind::Call(func, [.., count]) = expr.kind
         // Find calls to ptr::{copy, copy_nonoverlapping}
         // and ptr::{swap_nonoverlapping, write_bytes},
-        if let ExprKind::Call(func, [.., count]) = expr.kind;
-        if let ExprKind::Path(ref func_qpath) = func.kind;
-        if let Some(def_id) = cx.qpath_res(func_qpath, func.hir_id).opt_def_id();
-        if matches!(cx.tcx.get_diagnostic_name(def_id), Some(
+        && let ExprKind::Path(ref func_qpath) = func.kind
+        && let Some(def_id) = cx.qpath_res(func_qpath, func.hir_id).opt_def_id()
+        && matches!(cx.tcx.get_diagnostic_name(def_id), Some(
             sym::ptr_copy
             | sym::ptr_copy_nonoverlapping
             | sym::ptr_slice_from_raw_parts
@@ -95,26 +92,23 @@ fn get_pointee_ty_and_count_expr<'tcx>(
             | sym::ptr_write_bytes
             | sym::slice_from_raw_parts
             | sym::slice_from_raw_parts_mut
-        ));
+        ))
 
         // Get the pointee type
-        if let Some(pointee_ty) = cx.typeck_results().node_args(func.hir_id).types().next();
-        then {
-            return Some((pointee_ty, count));
-        }
+        && let Some(pointee_ty) = cx.typeck_results().node_args(func.hir_id).types().next()
+    {
+        return Some((pointee_ty, count));
     };
-    if_chain! {
+    if let ExprKind::MethodCall(method_path, ptr_self, [.., count], _) = expr.kind
         // Find calls to copy_{from,to}{,_nonoverlapping} and write_bytes methods
-        if let ExprKind::MethodCall(method_path, ptr_self, [.., count], _) = expr.kind;
-        let method_ident = method_path.ident.as_str();
-        if METHODS.iter().any(|m| *m == method_ident);
+        && let method_ident = method_path.ident.as_str()
+        && METHODS.iter().any(|m| *m == method_ident)
 
         // Get the pointee type
-        if let ty::RawPtr(TypeAndMut { ty: pointee_ty, .. }) =
-            cx.typeck_results().expr_ty(ptr_self).kind();
-        then {
-            return Some((*pointee_ty, count));
-        }
+        && let ty::RawPtr(TypeAndMut { ty: pointee_ty, .. }) =
+            cx.typeck_results().expr_ty(ptr_self).kind()
+    {
+        return Some((*pointee_ty, count));
     };
     None
 }
@@ -127,25 +121,23 @@ impl<'tcx> LateLintPass<'tcx> for SizeOfInElementCount {
         const LINT_MSG: &str = "found a count of bytes \
              instead of a count of elements of `T`";
 
-        if_chain! {
+        if let Some((pointee_ty, count_expr)) = get_pointee_ty_and_count_expr(cx, expr)
             // Find calls to functions with an element count parameter and get
             // the pointee type and count parameter expression
-            if let Some((pointee_ty, count_expr)) = get_pointee_ty_and_count_expr(cx, expr);
 
             // Find a size_of call in the count parameter expression and
             // check that it's the same type
-            if let Some(ty_used_for_size_of) = get_size_of_ty(cx, count_expr, false);
-            if pointee_ty == ty_used_for_size_of;
-            then {
-                span_lint_and_help(
-                    cx,
-                    SIZE_OF_IN_ELEMENT_COUNT,
-                    count_expr.span,
-                    LINT_MSG,
-                    None,
-                    HELP_MSG
-                );
-            }
+            && let Some(ty_used_for_size_of) = get_size_of_ty(cx, count_expr, false)
+            && pointee_ty == ty_used_for_size_of
+        {
+            span_lint_and_help(
+                cx,
+                SIZE_OF_IN_ELEMENT_COUNT,
+                count_expr.span,
+                LINT_MSG,
+                None,
+                HELP_MSG
+            );
         };
     }
 }
diff --git a/clippy_lints/src/slow_vector_initialization.rs b/clippy_lints/src/slow_vector_initialization.rs
index 2244eab96ca..7de0beb1292 100644
--- a/clippy_lints/src/slow_vector_initialization.rs
+++ b/clippy_lints/src/slow_vector_initialization.rs
@@ -103,41 +103,37 @@ enum InitializationType<'tcx> {
 impl<'tcx> LateLintPass<'tcx> for SlowVectorInit {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         // Matches initialization on reassignments. For example: `vec = Vec::with_capacity(100)`
-        if_chain! {
-            if let ExprKind::Assign(left, right, _) = expr.kind;
-            if let Some(local_id) = path_to_local(left);
-            if let Some(size_expr) = Self::as_vec_initializer(cx, right);
-
-            then {
-                let vi = VecAllocation {
-                    local_id,
-                    allocation_expr: right,
-                    size_expr,
-                };
-
-                Self::search_initialization(cx, vi, expr.hir_id);
-            }
+        if let ExprKind::Assign(left, right, _) = expr.kind
+            && let Some(local_id) = path_to_local(left)
+            && let Some(size_expr) = Self::as_vec_initializer(cx, right)
+
+        {
+            let vi = VecAllocation {
+                local_id,
+                allocation_expr: right,
+                size_expr,
+            };
+
+            Self::search_initialization(cx, vi, expr.hir_id);
         }
     }
 
     fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) {
         // Matches statements which initializes vectors. For example: `let mut vec = Vec::with_capacity(10)`
         // or `Vec::new()`
-        if_chain! {
-            if let StmtKind::Local(local) = stmt.kind;
-            if let PatKind::Binding(BindingAnnotation::MUT, local_id, _, None) = local.pat.kind;
-            if let Some(init) = local.init;
-            if let Some(size_expr) = Self::as_vec_initializer(cx, init);
-
-            then {
-                let vi = VecAllocation {
-                    local_id,
-                    allocation_expr: init,
-                    size_expr,
-                };
-
-                Self::search_initialization(cx, vi, stmt.hir_id);
-            }
+        if let StmtKind::Local(local) = stmt.kind
+            && let PatKind::Binding(BindingAnnotation::MUT, local_id, _, None) = local.pat.kind
+            && let Some(init) = local.init
+            && let Some(size_expr) = Self::as_vec_initializer(cx, init)
+
+        {
+            let vi = VecAllocation {
+                local_id,
+                allocation_expr: init,
+                size_expr,
+            };
+
+            Self::search_initialization(cx, vi, stmt.hir_id);
         }
     }
 }
@@ -242,16 +238,14 @@ struct VectorInitializationVisitor<'a, 'tcx> {
 impl<'a, 'tcx> VectorInitializationVisitor<'a, 'tcx> {
     /// Checks if the given expression is extending a vector with `repeat(0).take(..)`
     fn search_slow_extend_filling(&mut self, expr: &'tcx Expr<'_>) {
-        if_chain! {
-            if self.initialization_found;
-            if let ExprKind::MethodCall(path, self_arg, [extend_arg], _) = expr.kind;
-            if path_to_local_id(self_arg, self.vec_alloc.local_id);
-            if path.ident.name == sym!(extend);
-            if self.is_repeat_take(extend_arg);
-
-            then {
-                self.slow_expression = Some(InitializationType::Extend(expr));
-            }
+        if self.initialization_found
+            && let ExprKind::MethodCall(path, self_arg, [extend_arg], _) = expr.kind
+            && path_to_local_id(self_arg, self.vec_alloc.local_id)
+            && path.ident.name == sym!(extend)
+            && self.is_repeat_take(extend_arg)
+
+        {
+            self.slow_expression = Some(InitializationType::Extend(expr));
         }
     }
 
@@ -281,21 +275,19 @@ impl<'a, 'tcx> VectorInitializationVisitor<'a, 'tcx> {
 
     /// Returns `true` if give expression is `repeat(0).take(...)`
     fn is_repeat_take(&mut self, expr: &'tcx Expr<'tcx>) -> bool {
-        if_chain! {
-            if let ExprKind::MethodCall(take_path, recv, [len_arg, ..], _) = expr.kind;
-            if take_path.ident.name == sym!(take);
+        if let ExprKind::MethodCall(take_path, recv, [len_arg, ..], _) = expr.kind
+            && take_path.ident.name == sym!(take)
             // Check that take is applied to `repeat(0)`
-            if self.is_repeat_zero(recv);
-            then {
-                if let InitializedSize::Initialized(size_expr) = self.vec_alloc.size_expr {
-                    // Check that len expression is equals to `with_capacity` expression
-                    return SpanlessEq::new(self.cx).eq_expr(len_arg, size_expr)
-                        || matches!(len_arg.kind, ExprKind::MethodCall(path, ..) if path.ident.as_str() == "capacity")
-                }
-
-                self.vec_alloc.size_expr = InitializedSize::Initialized(len_arg);
-                return true;
+            && self.is_repeat_zero(recv)
+        {
+            if let InitializedSize::Initialized(size_expr) = self.vec_alloc.size_expr {
+                // Check that len expression is equals to `with_capacity` expression
+                return SpanlessEq::new(self.cx).eq_expr(len_arg, size_expr)
+                    || matches!(len_arg.kind, ExprKind::MethodCall(path, ..) if path.ident.as_str() == "capacity")
             }
+
+            self.vec_alloc.size_expr = InitializedSize::Initialized(len_arg);
+            return true;
         }
 
         false
@@ -303,15 +295,13 @@ impl<'a, 'tcx> VectorInitializationVisitor<'a, 'tcx> {
 
     /// Returns `true` if given expression is `repeat(0)`
     fn is_repeat_zero(&self, expr: &Expr<'_>) -> bool {
-        if_chain! {
-            if let ExprKind::Call(fn_expr, [repeat_arg]) = expr.kind;
-            if is_path_diagnostic_item(self.cx, fn_expr, sym::iter_repeat);
-            if is_integer_literal(repeat_arg, 0);
-            then {
-                true
-            } else {
-                false
-            }
+        if let ExprKind::Call(fn_expr, [repeat_arg]) = expr.kind
+            && is_path_diagnostic_item(self.cx, fn_expr, sym::iter_repeat)
+            && is_integer_literal(repeat_arg, 0)
+        {
+            true
+        } else {
+            false
         }
     }
 }
diff --git a/clippy_lints/src/strings.rs b/clippy_lints/src/strings.rs
index a44adc93855..f4f0d0ac551 100644
--- a/clippy_lints/src/strings.rs
+++ b/clippy_lints/src/strings.rs
@@ -255,124 +255,118 @@ impl<'tcx> LateLintPass<'tcx> for StringLitAsBytes {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
         use rustc_ast::LitKind;
 
-        if_chain! {
+        if let ExprKind::Call(fun, args) = e.kind
             // Find std::str::converts::from_utf8
-            if let ExprKind::Call(fun, args) = e.kind;
-            if is_path_diagnostic_item(cx, fun, sym::str_from_utf8);
+            && is_path_diagnostic_item(cx, fun, sym::str_from_utf8)
 
             // Find string::as_bytes
-            if let ExprKind::AddrOf(BorrowKind::Ref, _, args) = args[0].kind;
-            if let ExprKind::Index(left, right, _) = args.kind;
-            let (method_names, expressions, _) = method_calls(left, 1);
-            if method_names.len() == 1;
-            if expressions.len() == 1;
-            if expressions[0].1.is_empty();
-            if method_names[0] == sym!(as_bytes);
+            && let ExprKind::AddrOf(BorrowKind::Ref, _, args) = args[0].kind
+            && let ExprKind::Index(left, right, _) = args.kind
+            && let (method_names, expressions, _) = method_calls(left, 1)
+            && method_names.len() == 1
+            && expressions.len() == 1
+            && expressions[0].1.is_empty()
+            && method_names[0] == sym!(as_bytes)
 
             // Check for slicer
-            if let ExprKind::Struct(QPath::LangItem(LangItem::Range, ..), _, _) = right.kind;
+            && let ExprKind::Struct(QPath::LangItem(LangItem::Range, ..), _, _) = right.kind
 
-            then {
-                let mut applicability = Applicability::MachineApplicable;
-                let string_expression = &expressions[0].0;
+        {
+            let mut applicability = Applicability::MachineApplicable;
+            let string_expression = &expressions[0].0;
 
-                let snippet_app = snippet_with_applicability(
-                    cx,
-                    string_expression.span, "..",
-                    &mut applicability,
-                );
+            let snippet_app = snippet_with_applicability(
+                cx,
+                string_expression.span, "..",
+                &mut applicability,
+            );
+
+            span_lint_and_sugg(
+                cx,
+                STRING_FROM_UTF8_AS_BYTES,
+                e.span,
+                "calling a slice of `as_bytes()` with `from_utf8` should be not necessary",
+                "try",
+                format!("Some(&{snippet_app}[{}])", snippet(cx, right.span, "..")),
+                applicability
+            )
+        }
 
+        if !in_external_macro(cx.sess(), e.span)
+            && let ExprKind::MethodCall(path, receiver, ..) = &e.kind
+            && path.ident.name == sym!(as_bytes)
+            && let ExprKind::Lit(lit) = &receiver.kind
+            && let LitKind::Str(lit_content, _) = &lit.node
+        {
+            let callsite = snippet(cx, receiver.span.source_callsite(), r#""foo""#);
+            let mut applicability = Applicability::MachineApplicable;
+            if callsite.starts_with("include_str!") {
                 span_lint_and_sugg(
                     cx,
-                    STRING_FROM_UTF8_AS_BYTES,
+                    STRING_LIT_AS_BYTES,
                     e.span,
-                    "calling a slice of `as_bytes()` with `from_utf8` should be not necessary",
-                    "try",
-                    format!("Some(&{snippet_app}[{}])", snippet(cx, right.span, "..")),
-                    applicability
-                )
-            }
-        }
-
-        if_chain! {
-            if !in_external_macro(cx.sess(), e.span);
-            if let ExprKind::MethodCall(path, receiver, ..) = &e.kind;
-            if path.ident.name == sym!(as_bytes);
-            if let ExprKind::Lit(lit) = &receiver.kind;
-            if let LitKind::Str(lit_content, _) = &lit.node;
-            then {
-                let callsite = snippet(cx, receiver.span.source_callsite(), r#""foo""#);
-                let mut applicability = Applicability::MachineApplicable;
-                if callsite.starts_with("include_str!") {
+                    "calling `as_bytes()` on `include_str!(..)`",
+                    "consider using `include_bytes!(..)` instead",
+                    snippet_with_applicability(cx, receiver.span, r#""foo""#, &mut applicability).replacen(
+                        "include_str",
+                        "include_bytes",
+                        1,
+                    ),
+                    applicability,
+                );
+            } else if lit_content.as_str().is_ascii()
+                && lit_content.as_str().len() <= MAX_LENGTH_BYTE_STRING_LIT
+                && !receiver.span.from_expansion()
+            {
+                if let Some((parent, id)) = get_expr_use_or_unification_node(cx.tcx, e)
+                    && let Node::Expr(parent) = parent
+                    && let ExprKind::Match(scrutinee, ..) = parent.kind
+                    && scrutinee.hir_id == id
+                {
+                    // Don't lint. Byte strings produce `&[u8; N]` whereas `as_bytes()` produces
+                    // `&[u8]`. This change would prevent matching with different sized slices.
+                } else if !callsite.starts_with("env!") {
                     span_lint_and_sugg(
                         cx,
                         STRING_LIT_AS_BYTES,
                         e.span,
-                        "calling `as_bytes()` on `include_str!(..)`",
-                        "consider using `include_bytes!(..)` instead",
-                        snippet_with_applicability(cx, receiver.span, r#""foo""#, &mut applicability).replacen(
-                            "include_str",
-                            "include_bytes",
-                            1,
+                        "calling `as_bytes()` on a string literal",
+                        "consider using a byte string literal instead",
+                        format!(
+                            "b{}",
+                            snippet_with_applicability(cx, receiver.span, r#""foo""#, &mut applicability)
                         ),
                         applicability,
                     );
-                } else if lit_content.as_str().is_ascii()
-                    && lit_content.as_str().len() <= MAX_LENGTH_BYTE_STRING_LIT
-                    && !receiver.span.from_expansion()
-                {
-                    if let Some((parent, id)) = get_expr_use_or_unification_node(cx.tcx, e)
-                        && let Node::Expr(parent) = parent
-                        && let ExprKind::Match(scrutinee, ..) = parent.kind
-                        && scrutinee.hir_id == id
-                    {
-                        // Don't lint. Byte strings produce `&[u8; N]` whereas `as_bytes()` produces
-                        // `&[u8]`. This change would prevent matching with different sized slices.
-                    } else if !callsite.starts_with("env!") {
-                        span_lint_and_sugg(
-                            cx,
-                            STRING_LIT_AS_BYTES,
-                            e.span,
-                            "calling `as_bytes()` on a string literal",
-                            "consider using a byte string literal instead",
-                            format!(
-                                "b{}",
-                                snippet_with_applicability(cx, receiver.span, r#""foo""#, &mut applicability)
-                            ),
-                            applicability,
-                        );
-                    }
                 }
             }
         }
 
-        if_chain! {
-            if let ExprKind::MethodCall(path, recv, [], _) = &e.kind;
-            if path.ident.name == sym!(into_bytes);
-            if let ExprKind::MethodCall(path, recv, [], _) = &recv.kind;
-            if matches!(path.ident.name.as_str(), "to_owned" | "to_string");
-            if let ExprKind::Lit(lit) = &recv.kind;
-            if let LitKind::Str(lit_content, _) = &lit.node;
+        if let ExprKind::MethodCall(path, recv, [], _) = &e.kind
+            && path.ident.name == sym!(into_bytes)
+            && let ExprKind::MethodCall(path, recv, [], _) = &recv.kind
+            && matches!(path.ident.name.as_str(), "to_owned" | "to_string")
+            && let ExprKind::Lit(lit) = &recv.kind
+            && let LitKind::Str(lit_content, _) = &lit.node
 
-            if lit_content.as_str().is_ascii();
-            if lit_content.as_str().len() <= MAX_LENGTH_BYTE_STRING_LIT;
-            if !recv.span.from_expansion();
-            then {
-                let mut applicability = Applicability::MachineApplicable;
+            && lit_content.as_str().is_ascii()
+            && lit_content.as_str().len() <= MAX_LENGTH_BYTE_STRING_LIT
+            && !recv.span.from_expansion()
+        {
+            let mut applicability = Applicability::MachineApplicable;
 
-                span_lint_and_sugg(
-                    cx,
-                    STRING_LIT_AS_BYTES,
-                    e.span,
-                    "calling `into_bytes()` on a string literal",
-                    "consider using a byte string literal instead",
-                    format!(
-                        "b{}.to_vec()",
-                        snippet_with_applicability(cx, recv.span, r#""..""#, &mut applicability)
-                    ),
-                    applicability,
-                );
-            }
+            span_lint_and_sugg(
+                cx,
+                STRING_LIT_AS_BYTES,
+                e.span,
+                "calling `into_bytes()` on a string literal",
+                "consider using a byte string literal instead",
+                format!(
+                    "b{}.to_vec()",
+                    snippet_with_applicability(cx, recv.span, r#""..""#, &mut applicability)
+                ),
+                applicability,
+            );
         }
     }
 }
@@ -406,22 +400,20 @@ declare_lint_pass!(StrToString => [STR_TO_STRING]);
 
 impl<'tcx> LateLintPass<'tcx> for StrToString {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &Expr<'_>) {
-        if_chain! {
-            if let ExprKind::MethodCall(path, self_arg, ..) = &expr.kind;
-            if path.ident.name == sym::to_string;
-            let ty = cx.typeck_results().expr_ty(self_arg);
-            if let ty::Ref(_, ty, ..) = ty.kind();
-            if ty.is_str();
-            then {
-                span_lint_and_help(
-                    cx,
-                    STR_TO_STRING,
-                    expr.span,
-                    "`to_string()` called on a `&str`",
-                    None,
-                    "consider using `.to_owned()`",
-                );
-            }
+        if let ExprKind::MethodCall(path, self_arg, ..) = &expr.kind
+            && path.ident.name == sym::to_string
+            && let ty = cx.typeck_results().expr_ty(self_arg)
+            && let ty::Ref(_, ty, ..) = ty.kind()
+            && ty.is_str()
+        {
+            span_lint_and_help(
+                cx,
+                STR_TO_STRING,
+                expr.span,
+                "`to_string()` called on a `&str`",
+                None,
+                "consider using `.to_owned()`",
+            );
         }
     }
 }
@@ -456,21 +448,19 @@ declare_lint_pass!(StringToString => [STRING_TO_STRING]);
 
 impl<'tcx> LateLintPass<'tcx> for StringToString {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &Expr<'_>) {
-        if_chain! {
-            if let ExprKind::MethodCall(path, self_arg, ..) = &expr.kind;
-            if path.ident.name == sym::to_string;
-            let ty = cx.typeck_results().expr_ty(self_arg);
-            if is_type_lang_item(cx, ty, LangItem::String);
-            then {
-                span_lint_and_help(
-                    cx,
-                    STRING_TO_STRING,
-                    expr.span,
-                    "`to_string()` called on a `String`",
-                    None,
-                    "consider using `.clone()`",
-                );
-            }
+        if let ExprKind::MethodCall(path, self_arg, ..) = &expr.kind
+            && path.ident.name == sym::to_string
+            && let ty = cx.typeck_results().expr_ty(self_arg)
+            && is_type_lang_item(cx, ty, LangItem::String)
+        {
+            span_lint_and_help(
+                cx,
+                STRING_TO_STRING,
+                expr.span,
+                "`to_string()` called on a `String`",
+                None,
+                "consider using `.clone()`",
+            );
         }
     }
 }
@@ -500,26 +490,24 @@ declare_lint_pass!(TrimSplitWhitespace => [TRIM_SPLIT_WHITESPACE]);
 impl<'tcx> LateLintPass<'tcx> for TrimSplitWhitespace {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &Expr<'_>) {
         let tyckres = cx.typeck_results();
-        if_chain! {
-            if let ExprKind::MethodCall(path, split_recv, [], split_ws_span) = expr.kind;
-            if path.ident.name == sym!(split_whitespace);
-            if let Some(split_ws_def_id) = tyckres.type_dependent_def_id(expr.hir_id);
-            if cx.tcx.is_diagnostic_item(sym::str_split_whitespace, split_ws_def_id);
-            if let ExprKind::MethodCall(path, _trim_recv, [], trim_span) = split_recv.kind;
-            if let trim_fn_name @ ("trim" | "trim_start" | "trim_end") = path.ident.name.as_str();
-            if let Some(trim_def_id) = tyckres.type_dependent_def_id(split_recv.hir_id);
-            if is_one_of_trim_diagnostic_items(cx, trim_def_id);
-            then {
-                span_lint_and_sugg(
-                    cx,
-                    TRIM_SPLIT_WHITESPACE,
-                    trim_span.with_hi(split_ws_span.lo()),
-                    &format!("found call to `str::{trim_fn_name}` before `str::split_whitespace`"),
-                    &format!("remove `{trim_fn_name}()`"),
-                    String::new(),
-                    Applicability::MachineApplicable,
-                );
-            }
+        if let ExprKind::MethodCall(path, split_recv, [], split_ws_span) = expr.kind
+            && path.ident.name == sym!(split_whitespace)
+            && let Some(split_ws_def_id) = tyckres.type_dependent_def_id(expr.hir_id)
+            && cx.tcx.is_diagnostic_item(sym::str_split_whitespace, split_ws_def_id)
+            && let ExprKind::MethodCall(path, _trim_recv, [], trim_span) = split_recv.kind
+            && let trim_fn_name @ ("trim" | "trim_start" | "trim_end") = path.ident.name.as_str()
+            && let Some(trim_def_id) = tyckres.type_dependent_def_id(split_recv.hir_id)
+            && is_one_of_trim_diagnostic_items(cx, trim_def_id)
+        {
+            span_lint_and_sugg(
+                cx,
+                TRIM_SPLIT_WHITESPACE,
+                trim_span.with_hi(split_ws_span.lo()),
+                &format!("found call to `str::{trim_fn_name}` before `str::split_whitespace`"),
+                &format!("remove `{trim_fn_name}()`"),
+                String::new(),
+                Applicability::MachineApplicable,
+            );
         }
     }
 }
diff --git a/clippy_lints/src/strlen_on_c_strings.rs b/clippy_lints/src/strlen_on_c_strings.rs
index b3db5e9a422..23aa1f76d2d 100644
--- a/clippy_lints/src/strlen_on_c_strings.rs
+++ b/clippy_lints/src/strlen_on_c_strings.rs
@@ -41,48 +41,46 @@ declare_lint_pass!(StrlenOnCStrings => [STRLEN_ON_C_STRINGS]);
 
 impl<'tcx> LateLintPass<'tcx> for StrlenOnCStrings {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if_chain! {
-            if !expr.span.from_expansion();
-            if let ExprKind::Call(func, [recv]) = expr.kind;
-            if let ExprKind::Path(path) = &func.kind;
-            if let Some(did) = cx.qpath_res(path, func.hir_id).opt_def_id();
-            if match_libc_symbol(cx, did, "strlen");
-            if let ExprKind::MethodCall(path, self_arg, [], _) = recv.kind;
-            if !recv.span.from_expansion();
-            if path.ident.name == sym::as_ptr;
-            then {
-                let ctxt = expr.span.ctxt();
-                let span = match get_parent_node(cx.tcx, expr.hir_id) {
-                    Some(Node::Block(&Block {
-                        rules: BlockCheckMode::UnsafeBlock(UnsafeSource::UserProvided), span, ..
-                    }))
-                    if span.ctxt() == ctxt && !is_expr_unsafe(cx, self_arg) => {
-                        span
-                    }
-                    _ => expr.span,
-                };
+        if !expr.span.from_expansion()
+            && let ExprKind::Call(func, [recv]) = expr.kind
+            && let ExprKind::Path(path) = &func.kind
+            && let Some(did) = cx.qpath_res(path, func.hir_id).opt_def_id()
+            && match_libc_symbol(cx, did, "strlen")
+            && let ExprKind::MethodCall(path, self_arg, [], _) = recv.kind
+            && !recv.span.from_expansion()
+            && path.ident.name == sym::as_ptr
+        {
+            let ctxt = expr.span.ctxt();
+            let span = match get_parent_node(cx.tcx, expr.hir_id) {
+                Some(Node::Block(&Block {
+                    rules: BlockCheckMode::UnsafeBlock(UnsafeSource::UserProvided), span, ..
+                }))
+                if span.ctxt() == ctxt && !is_expr_unsafe(cx, self_arg) => {
+                    span
+                }
+                _ => expr.span,
+            };
 
-                let ty = cx.typeck_results().expr_ty(self_arg).peel_refs();
-                let mut app = Applicability::MachineApplicable;
-                let val_name = snippet_with_context(cx, self_arg.span, ctxt, "..", &mut app).0;
-                let method_name = if is_type_diagnostic_item(cx, ty, sym::cstring_type) {
-                    "as_bytes"
-                } else if is_type_lang_item(cx, ty, LangItem::CStr) {
-                    "to_bytes"
-                } else {
-                    return;
-                };
+            let ty = cx.typeck_results().expr_ty(self_arg).peel_refs();
+            let mut app = Applicability::MachineApplicable;
+            let val_name = snippet_with_context(cx, self_arg.span, ctxt, "..", &mut app).0;
+            let method_name = if is_type_diagnostic_item(cx, ty, sym::cstring_type) {
+                "as_bytes"
+            } else if is_type_lang_item(cx, ty, LangItem::CStr) {
+                "to_bytes"
+            } else {
+                return;
+            };
 
-                span_lint_and_sugg(
-                    cx,
-                    STRLEN_ON_C_STRINGS,
-                    span,
-                    "using `libc::strlen` on a `CString` or `CStr` value",
-                    "try",
-                    format!("{val_name}.{method_name}().len()"),
-                    app,
-                );
-            }
+            span_lint_and_sugg(
+                cx,
+                STRLEN_ON_C_STRINGS,
+                span,
+                "using `libc::strlen` on a `CString` or `CStr` value",
+                "try",
+                format!("{val_name}.{method_name}().len()"),
+                app,
+            );
         }
     }
 }
diff --git a/clippy_lints/src/suspicious_doc_comments.rs b/clippy_lints/src/suspicious_doc_comments.rs
index 0abc199da16..dd799d24ca3 100644
--- a/clippy_lints/src/suspicious_doc_comments.rs
+++ b/clippy_lints/src/suspicious_doc_comments.rs
@@ -76,19 +76,17 @@ fn collect_doc_comment_replacements(attrs: &[Attribute]) -> Vec<(Span, String)>
     attrs
         .iter()
         .filter_map(|attr| {
-            if_chain! {
-                if let AttrKind::DocComment(com_kind, sym) = attr.kind;
-                if let AttrStyle::Outer = attr.style;
-                if let Some(com) = sym.as_str().strip_prefix('!');
-                then {
-                    let sugg = match com_kind {
-                        CommentKind::Line => format!("//!{com}"),
-                        CommentKind::Block => format!("/*!{com}*/")
-                    };
-                    Some((attr.span, sugg))
-                } else {
-                    None
-                }
+            if let AttrKind::DocComment(com_kind, sym) = attr.kind
+                && let AttrStyle::Outer = attr.style
+                && let Some(com) = sym.as_str().strip_prefix('!')
+            {
+                let sugg = match com_kind {
+                    CommentKind::Line => format!("//!{com}"),
+                    CommentKind::Block => format!("/*!{com}*/")
+                };
+                Some((attr.span, sugg))
+            } else {
+                None
             }
         })
         .collect()
diff --git a/clippy_lints/src/suspicious_operation_groupings.rs b/clippy_lints/src/suspicious_operation_groupings.rs
index bb8cde5b94d..eff0c8cd561 100644
--- a/clippy_lints/src/suspicious_operation_groupings.rs
+++ b/clippy_lints/src/suspicious_operation_groupings.rs
@@ -155,34 +155,32 @@ fn check_binops(cx: &EarlyContext<'_>, binops: &[&BinaryOp<'_>]) {
         match (no_difference_info, double_difference_info) {
             (Some(i), None) => attempt_to_emit_no_difference_lint(cx, binops, i, expected_loc),
             (None, Some((double_difference_index, ident_loc1, ident_loc2))) => {
-                if_chain! {
-                    if one_ident_difference_count == binop_count - 1;
-                    if let Some(binop) = binops.get(double_difference_index);
-                    then {
-                        let changed_loc = if ident_loc1 == expected_loc {
-                            ident_loc2
-                        } else if ident_loc2 == expected_loc {
-                            ident_loc1
-                        } else {
-                            // This expression doesn't match the form we're
-                            // looking for.
-                            return;
-                        };
-
-                        if let Some(sugg) = ident_swap_sugg(
+                if one_ident_difference_count == binop_count - 1
+                    && let Some(binop) = binops.get(double_difference_index)
+                {
+                    let changed_loc = if ident_loc1 == expected_loc {
+                        ident_loc2
+                    } else if ident_loc2 == expected_loc {
+                        ident_loc1
+                    } else {
+                        // This expression doesn't match the form we're
+                        // looking for.
+                        return;
+                    };
+
+                    if let Some(sugg) = ident_swap_sugg(
+                        cx,
+                        &paired_identifiers,
+                        binop,
+                        changed_loc,
+                        &mut applicability,
+                    ) {
+                        emit_suggestion(
                             cx,
-                            &paired_identifiers,
-                            binop,
-                            changed_loc,
-                            &mut applicability,
-                        ) {
-                            emit_suggestion(
-                                cx,
-                                binop.span,
-                                sugg,
-                                applicability,
-                            );
-                        }
+                            binop.span,
+                            sugg,
+                            applicability,
+                        );
                     }
                 }
             },
@@ -212,48 +210,44 @@ fn attempt_to_emit_no_difference_lint(
         let old_right_ident = get_ident(binop.right, expected_loc);
 
         for b in skip_index(binops.iter(), i) {
-            if_chain! {
-                if let (Some(old_ident), Some(new_ident)) =
-                (old_left_ident, get_ident(b.left, expected_loc));
-                if old_ident != new_ident;
-                if let Some(sugg) = suggestion_with_swapped_ident(
+            if let (Some(old_ident), Some(new_ident)) =
+                (old_left_ident, get_ident(b.left, expected_loc))
+                && old_ident != new_ident
+                && let Some(sugg) = suggestion_with_swapped_ident(
                     cx,
                     binop.left,
                     expected_loc,
                     new_ident,
                     &mut applicability,
+                )
+            {
+                emit_suggestion(
+                    cx,
+                    binop.span,
+                    replace_left_sugg(cx, binop, &sugg, &mut applicability),
+                    applicability,
                 );
-                then {
-                    emit_suggestion(
-                        cx,
-                        binop.span,
-                        replace_left_sugg(cx, binop, &sugg, &mut applicability),
-                        applicability,
-                    );
-                    return;
-                }
+                return;
             }
 
-            if_chain! {
-                if let (Some(old_ident), Some(new_ident)) =
-                    (old_right_ident, get_ident(b.right, expected_loc));
-                if old_ident != new_ident;
-                if let Some(sugg) = suggestion_with_swapped_ident(
+            if let (Some(old_ident), Some(new_ident)) =
+                    (old_right_ident, get_ident(b.right, expected_loc))
+                && old_ident != new_ident
+                && let Some(sugg) = suggestion_with_swapped_ident(
                     cx,
                     binop.right,
                     expected_loc,
                     new_ident,
                     &mut applicability,
+                )
+            {
+                emit_suggestion(
+                    cx,
+                    binop.span,
+                    replace_right_sugg(cx, binop, &sugg, &mut applicability),
+                    applicability,
                 );
-                then {
-                    emit_suggestion(
-                        cx,
-                        binop.span,
-                        replace_right_sugg(cx, binop, &sugg, &mut applicability),
-                        applicability,
-                    );
-                    return;
-                }
+                return;
             }
         }
     }
diff --git a/clippy_lints/src/suspicious_trait_impl.rs b/clippy_lints/src/suspicious_trait_impl.rs
index 6271ea02731..b2badd7b2ac 100644
--- a/clippy_lints/src/suspicious_trait_impl.rs
+++ b/clippy_lints/src/suspicious_trait_impl.rs
@@ -57,37 +57,35 @@ declare_lint_pass!(SuspiciousImpl => [SUSPICIOUS_ARITHMETIC_IMPL, SUSPICIOUS_OP_
 
 impl<'tcx> LateLintPass<'tcx> for SuspiciousImpl {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
-        if_chain! {
-            if let hir::ExprKind::Binary(binop, _, _) | hir::ExprKind::AssignOp(binop, ..) = expr.kind;
-            if let Some((binop_trait_lang, op_assign_trait_lang)) = binop_traits(binop.node);
-            if let Some(binop_trait_id) = cx.tcx.lang_items().get(binop_trait_lang);
-            if let Some(op_assign_trait_id) = cx.tcx.lang_items().get(op_assign_trait_lang);
+        if let hir::ExprKind::Binary(binop, _, _) | hir::ExprKind::AssignOp(binop, ..) = expr.kind
+            && let Some((binop_trait_lang, op_assign_trait_lang)) = binop_traits(binop.node)
+            && let Some(binop_trait_id) = cx.tcx.lang_items().get(binop_trait_lang)
+            && let Some(op_assign_trait_id) = cx.tcx.lang_items().get(op_assign_trait_lang)
 
             // Check for more than one binary operation in the implemented function
             // Linting when multiple operations are involved can result in false positives
-            let parent_fn = cx.tcx.hir().get_parent_item(expr.hir_id).def_id;
-            if let hir::Node::ImplItem(impl_item) = cx.tcx.hir().get_by_def_id(parent_fn);
-            if let hir::ImplItemKind::Fn(_, body_id) = impl_item.kind;
-            let body = cx.tcx.hir().body(body_id);
-            let parent_fn = cx.tcx.hir().get_parent_item(expr.hir_id).def_id;
-            if let Some(trait_ref) = trait_ref_of_method(cx, parent_fn);
-            let trait_id = trait_ref.path.res.def_id();
-            if ![binop_trait_id, op_assign_trait_id].contains(&trait_id);
-            if let Some(&(_, lint)) = [
+            && let parent_fn = cx.tcx.hir().get_parent_item(expr.hir_id).def_id
+            && let hir::Node::ImplItem(impl_item) = cx.tcx.hir().get_by_def_id(parent_fn)
+            && let hir::ImplItemKind::Fn(_, body_id) = impl_item.kind
+            && let body = cx.tcx.hir().body(body_id)
+            && let parent_fn = cx.tcx.hir().get_parent_item(expr.hir_id).def_id
+            && let Some(trait_ref) = trait_ref_of_method(cx, parent_fn)
+            && let trait_id = trait_ref.path.res.def_id()
+            && ![binop_trait_id, op_assign_trait_id].contains(&trait_id)
+            && let Some(&(_, lint)) = [
                 (&BINOP_TRAITS, SUSPICIOUS_ARITHMETIC_IMPL),
                 (&OP_ASSIGN_TRAITS, SUSPICIOUS_OP_ASSIGN_IMPL),
             ]
                 .iter()
-                .find(|&(ts, _)| ts.iter().any(|&t| Some(trait_id) == cx.tcx.lang_items().get(t)));
-            if count_binops(body.value) == 1;
-            then {
-                span_lint(
-                    cx,
-                    lint,
-                    binop.span,
-                    &format!("suspicious use of `{}` in `{}` impl", binop.node.as_str(), cx.tcx.item_name(trait_id)),
-                );
-            }
+                .find(|&(ts, _)| ts.iter().any(|&t| Some(trait_id) == cx.tcx.lang_items().get(t)))
+            && count_binops(body.value) == 1
+        {
+            span_lint(
+                cx,
+                lint,
+                binop.span,
+                &format!("suspicious use of `{}` in `{}` impl", binop.node.as_str(), cx.tcx.item_name(trait_id)),
+            );
         }
     }
 }
diff --git a/clippy_lints/src/swap.rs b/clippy_lints/src/swap.rs
index 660e6835e46..29f85907f9e 100644
--- a/clippy_lints/src/swap.rs
+++ b/clippy_lints/src/swap.rs
@@ -149,36 +149,34 @@ fn check_manual_swap(cx: &LateContext<'_>, block: &Block<'_>) {
     }
 
     for [s1, s2, s3] in block.stmts.array_windows::<3>() {
-        if_chain! {
+        if let StmtKind::Local(tmp) = s1.kind
             // let t = foo();
-            if let StmtKind::Local(tmp) = s1.kind;
-            if let Some(tmp_init) = tmp.init;
-            if let PatKind::Binding(.., ident, None) = tmp.pat.kind;
+            && let Some(tmp_init) = tmp.init
+            && let PatKind::Binding(.., ident, None) = tmp.pat.kind
 
             // foo() = bar();
-            if let StmtKind::Semi(first) = s2.kind;
-            if let ExprKind::Assign(lhs1, rhs1, _) = first.kind;
+            && let StmtKind::Semi(first) = s2.kind
+            && let ExprKind::Assign(lhs1, rhs1, _) = first.kind
 
             // bar() = t;
-            if let StmtKind::Semi(second) = s3.kind;
-            if let ExprKind::Assign(lhs2, rhs2, _) = second.kind;
-            if let ExprKind::Path(QPath::Resolved(None, rhs2)) = rhs2.kind;
-            if rhs2.segments.len() == 1;
+            && let StmtKind::Semi(second) = s3.kind
+            && let ExprKind::Assign(lhs2, rhs2, _) = second.kind
+            && let ExprKind::Path(QPath::Resolved(None, rhs2)) = rhs2.kind
+            && rhs2.segments.len() == 1
 
-            if ident.name == rhs2.segments[0].ident.name;
-            if eq_expr_value(cx, tmp_init, lhs1);
-            if eq_expr_value(cx, rhs1, lhs2);
+            && ident.name == rhs2.segments[0].ident.name
+            && eq_expr_value(cx, tmp_init, lhs1)
+            && eq_expr_value(cx, rhs1, lhs2)
 
-            let ctxt = s1.span.ctxt();
-            if s2.span.ctxt() == ctxt;
-            if s3.span.ctxt() == ctxt;
-            if first.span.ctxt() == ctxt;
-            if second.span.ctxt() == ctxt;
+            && let ctxt = s1.span.ctxt()
+            && s2.span.ctxt() == ctxt
+            && s3.span.ctxt() == ctxt
+            && first.span.ctxt() == ctxt
+            && second.span.ctxt() == ctxt
 
-            then {
-                let span = s1.span.to(s3.span);
-                generate_swap_warning(cx, lhs1, lhs2, span, false);
-            }
+        {
+            let span = s1.span.to(s3.span);
+            generate_swap_warning(cx, lhs1, lhs2, span, false);
         }
     }
 }
@@ -261,20 +259,18 @@ fn parse<'a, 'hir>(stmt: &'a Stmt<'hir>) -> Option<(ExprOrIdent<'hir>, &'a Expr<
 fn check_xor_swap(cx: &LateContext<'_>, block: &Block<'_>) {
     for [s1, s2, s3] in block.stmts.array_windows::<3>() {
         let ctxt = s1.span.ctxt();
-        if_chain! {
-            if let Some((lhs0, rhs0)) = extract_sides_of_xor_assign(s1, ctxt);
-            if let Some((lhs1, rhs1)) = extract_sides_of_xor_assign(s2, ctxt);
-            if let Some((lhs2, rhs2)) = extract_sides_of_xor_assign(s3, ctxt);
-            if eq_expr_value(cx, lhs0, rhs1);
-            if eq_expr_value(cx, lhs2, rhs1);
-            if eq_expr_value(cx, lhs1, rhs0);
-            if eq_expr_value(cx, lhs1, rhs2);
-            if s2.span.ctxt() == ctxt;
-            if s3.span.ctxt() == ctxt;
-            then {
-                let span = s1.span.to(s3.span);
-                generate_swap_warning(cx, lhs0, rhs0, span, true);
-            }
+        if let Some((lhs0, rhs0)) = extract_sides_of_xor_assign(s1, ctxt)
+            && let Some((lhs1, rhs1)) = extract_sides_of_xor_assign(s2, ctxt)
+            && let Some((lhs2, rhs2)) = extract_sides_of_xor_assign(s3, ctxt)
+            && eq_expr_value(cx, lhs0, rhs1)
+            && eq_expr_value(cx, lhs2, rhs1)
+            && eq_expr_value(cx, lhs1, rhs0)
+            && eq_expr_value(cx, lhs1, rhs2)
+            && s2.span.ctxt() == ctxt
+            && s3.span.ctxt() == ctxt
+        {
+            let span = s1.span.to(s3.span);
+            generate_swap_warning(cx, lhs0, rhs0, span, true);
         };
     }
 }
diff --git a/clippy_lints/src/tests_outside_test_module.rs b/clippy_lints/src/tests_outside_test_module.rs
index 0cfb1c1253c..9481c78a505 100644
--- a/clippy_lints/src/tests_outside_test_module.rs
+++ b/clippy_lints/src/tests_outside_test_module.rs
@@ -55,20 +55,18 @@ impl LateLintPass<'_> for TestsOutsideTestModule {
         sp: Span,
         _: LocalDefId,
     ) {
-        if_chain! {
-            if !matches!(kind, FnKind::Closure);
-            if is_in_test_function(cx.tcx, body.id().hir_id);
-            if !is_in_cfg_test(cx.tcx, body.id().hir_id);
-            then {
-                span_lint_and_note(
-                    cx,
-                    TESTS_OUTSIDE_TEST_MODULE,
-                    sp,
-                    "this function marked with #[test] is outside a #[cfg(test)] module",
-                    None,
-                    "move it to a testing module marked with #[cfg(test)]",
-                );
-            }
+        if !matches!(kind, FnKind::Closure)
+            && is_in_test_function(cx.tcx, body.id().hir_id)
+            && !is_in_cfg_test(cx.tcx, body.id().hir_id)
+        {
+            span_lint_and_note(
+                cx,
+                TESTS_OUTSIDE_TEST_MODULE,
+                sp,
+                "this function marked with #[test] is outside a #[cfg(test)] module",
+                None,
+                "move it to a testing module marked with #[cfg(test)]",
+            );
         }
     }
 }
diff --git a/clippy_lints/src/to_digit_is_some.rs b/clippy_lints/src/to_digit_is_some.rs
index a171d225f1e..6990e7468f8 100644
--- a/clippy_lints/src/to_digit_is_some.rs
+++ b/clippy_lints/src/to_digit_is_some.rs
@@ -38,59 +38,53 @@ declare_lint_pass!(ToDigitIsSome => [TO_DIGIT_IS_SOME]);
 
 impl<'tcx> LateLintPass<'tcx> for ToDigitIsSome {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
-        if_chain! {
-            if let hir::ExprKind::MethodCall(is_some_path, to_digit_expr, [], _) = &expr.kind;
-            if is_some_path.ident.name.as_str() == "is_some";
-            then {
-                let match_result = match &to_digit_expr.kind {
-                    hir::ExprKind::MethodCall(to_digits_path, char_arg, [radix_arg], _) => {
-                        if_chain! {
-                            if to_digits_path.ident.name.as_str() == "to_digit";
-                            let char_arg_ty = cx.typeck_results().expr_ty_adjusted(char_arg);
-                            if *char_arg_ty.kind() == ty::Char;
-                            then {
-                                Some((true, *char_arg, radix_arg))
-                            } else {
-                                None
-                            }
-                        }
+        if let hir::ExprKind::MethodCall(is_some_path, to_digit_expr, [], _) = &expr.kind
+            && is_some_path.ident.name.as_str() == "is_some"
+        {
+            let match_result = match &to_digit_expr.kind {
+                hir::ExprKind::MethodCall(to_digits_path, char_arg, [radix_arg], _) => {
+                    if to_digits_path.ident.name.as_str() == "to_digit"
+                        && let char_arg_ty = cx.typeck_results().expr_ty_adjusted(char_arg)
+                        && *char_arg_ty.kind() == ty::Char
+                    {
+                        Some((true, *char_arg, radix_arg))
+                    } else {
+                        None
                     }
-                    hir::ExprKind::Call(to_digits_call, to_digit_args) => {
-                        if_chain! {
-                            if let [char_arg, radix_arg] = *to_digit_args;
-                            if let hir::ExprKind::Path(to_digits_path) = &to_digits_call.kind;
-                            if let to_digits_call_res = cx.qpath_res(to_digits_path, to_digits_call.hir_id);
-                            if let Some(to_digits_def_id) = to_digits_call_res.opt_def_id();
-                            if match_def_path(cx, to_digits_def_id, &["core", "char", "methods", "<impl char>", "to_digit"]);
-                            then {
-                                Some((false, char_arg, radix_arg))
-                            } else {
-                                None
-                            }
-                        }
+                }
+                hir::ExprKind::Call(to_digits_call, to_digit_args) => {
+                    if let [char_arg, radix_arg] = *to_digit_args
+                        && let hir::ExprKind::Path(to_digits_path) = &to_digits_call.kind
+                        && let to_digits_call_res = cx.qpath_res(to_digits_path, to_digits_call.hir_id)
+                        && let Some(to_digits_def_id) = to_digits_call_res.opt_def_id()
+                        && match_def_path(cx, to_digits_def_id, &["core", "char", "methods", "<impl char>", "to_digit"])
+                    {
+                        Some((false, char_arg, radix_arg))
+                    } else {
+                        None
                     }
-                    _ => None
-                };
+                }
+                _ => None
+            };
 
-                if let Some((is_method_call, char_arg, radix_arg)) = match_result {
-                    let mut applicability = Applicability::MachineApplicable;
-                    let char_arg_snip = snippet_with_applicability(cx, char_arg.span, "_", &mut applicability);
-                    let radix_snip = snippet_with_applicability(cx, radix_arg.span, "_", &mut applicability);
+            if let Some((is_method_call, char_arg, radix_arg)) = match_result {
+                let mut applicability = Applicability::MachineApplicable;
+                let char_arg_snip = snippet_with_applicability(cx, char_arg.span, "_", &mut applicability);
+                let radix_snip = snippet_with_applicability(cx, radix_arg.span, "_", &mut applicability);
 
-                    span_lint_and_sugg(
-                        cx,
-                        TO_DIGIT_IS_SOME,
-                        expr.span,
-                        "use of `.to_digit(..).is_some()`",
-                        "try",
-                        if is_method_call {
-                            format!("{char_arg_snip}.is_digit({radix_snip})")
-                        } else {
-                            format!("char::is_digit({char_arg_snip}, {radix_snip})")
-                        },
-                        applicability,
-                    );
-                }
+                span_lint_and_sugg(
+                    cx,
+                    TO_DIGIT_IS_SOME,
+                    expr.span,
+                    "use of `.to_digit(..).is_some()`",
+                    "try",
+                    if is_method_call {
+                        format!("{char_arg_snip}.is_digit({radix_snip})")
+                    } else {
+                        format!("char::is_digit({char_arg_snip}, {radix_snip})")
+                    },
+                    applicability,
+                );
             }
         }
     }
diff --git a/clippy_lints/src/trailing_empty_array.rs b/clippy_lints/src/trailing_empty_array.rs
index 87181adc24b..7eef02b3c65 100644
--- a/clippy_lints/src/trailing_empty_array.rs
+++ b/clippy_lints/src/trailing_empty_array.rs
@@ -54,20 +54,18 @@ impl<'tcx> LateLintPass<'tcx> for TrailingEmptyArray {
 }
 
 fn is_struct_with_trailing_zero_sized_array(cx: &LateContext<'_>, item: &Item<'_>) -> bool {
-    if_chain! {
+    if let ItemKind::Struct(data, _) = &item.kind
         // First check if last field is an array
-        if let ItemKind::Struct(data, _) = &item.kind;
-        if let Some(last_field) = data.fields().last();
-        if let rustc_hir::TyKind::Array(_, rustc_hir::ArrayLen::Body(length)) = last_field.ty.kind;
+        && let Some(last_field) = data.fields().last()
+        && let rustc_hir::TyKind::Array(_, rustc_hir::ArrayLen::Body(length)) = last_field.ty.kind
 
         // Then check if that array is zero-sized
-        let length = Const::from_anon_const(cx.tcx, length.def_id);
-        let length = length.try_eval_target_usize(cx.tcx, cx.param_env);
-        if let Some(length) = length;
-        then {
-            length == 0
-        } else {
-            false
-        }
+        && let length = Const::from_anon_const(cx.tcx, length.def_id)
+        && let length = length.try_eval_target_usize(cx.tcx, cx.param_env)
+        && let Some(length) = length
+    {
+        length == 0
+    } else {
+        false
     }
 }
diff --git a/clippy_lints/src/trait_bounds.rs b/clippy_lints/src/trait_bounds.rs
index f065d215e48..0bcb1afeea2 100644
--- a/clippy_lints/src/trait_bounds.rs
+++ b/clippy_lints/src/trait_bounds.rs
@@ -124,103 +124,99 @@ impl<'tcx> LateLintPass<'tcx> for TraitBounds {
         let mut self_bounds_map = FxHashMap::default();
 
         for predicate in item.generics.predicates {
-            if_chain! {
-                if let WherePredicate::BoundPredicate(ref bound_predicate) = predicate;
-                if bound_predicate.origin != PredicateOrigin::ImplTrait;
-                if !bound_predicate.span.from_expansion();
-                if let TyKind::Path(QPath::Resolved(_, Path { segments, .. })) = bound_predicate.bounded_ty.kind;
-                if let Some(PathSegment {
+            if let WherePredicate::BoundPredicate(ref bound_predicate) = predicate
+                && bound_predicate.origin != PredicateOrigin::ImplTrait
+                && !bound_predicate.span.from_expansion()
+                && let TyKind::Path(QPath::Resolved(_, Path { segments, .. })) = bound_predicate.bounded_ty.kind
+                && let Some(PathSegment {
                     res: Res::SelfTyParam { trait_: def_id }, ..
-                }) = segments.first();
-                if let Some(
+                }) = segments.first()
+                && let Some(
                     Node::Item(
                         Item {
                             kind: ItemKind::Trait(_, _, _, self_bounds, _),
                             .. }
                         )
-                    ) = cx.tcx.hir().get_if_local(*def_id);
-                then {
-                    if self_bounds_map.is_empty() {
-                        for bound in *self_bounds {
-                            let Some((self_res, self_segments, _)) = get_trait_info_from_bound(bound) else { continue };
-                            self_bounds_map.insert(self_res, self_segments);
-                        }
+                    ) = cx.tcx.hir().get_if_local(*def_id)
+            {
+                if self_bounds_map.is_empty() {
+                    for bound in *self_bounds {
+                        let Some((self_res, self_segments, _)) = get_trait_info_from_bound(bound) else { continue };
+                        self_bounds_map.insert(self_res, self_segments);
                     }
+                }
 
-                    bound_predicate
-                        .bounds
-                        .iter()
-                        .filter_map(get_trait_info_from_bound)
-                        .for_each(|(trait_item_res, trait_item_segments, span)| {
-                            if let Some(self_segments) = self_bounds_map.get(&trait_item_res) {
-                                if SpanlessEq::new(cx).eq_path_segments(self_segments, trait_item_segments) {
-                                    span_lint_and_help(
-                                        cx,
-                                        TRAIT_DUPLICATION_IN_BOUNDS,
-                                        span,
-                                        "this trait bound is already specified in trait declaration",
-                                        None,
-                                        "consider removing this trait bound",
-                                    );
-                                }
+                bound_predicate
+                    .bounds
+                    .iter()
+                    .filter_map(get_trait_info_from_bound)
+                    .for_each(|(trait_item_res, trait_item_segments, span)| {
+                        if let Some(self_segments) = self_bounds_map.get(&trait_item_res) {
+                            if SpanlessEq::new(cx).eq_path_segments(self_segments, trait_item_segments) {
+                                span_lint_and_help(
+                                    cx,
+                                    TRAIT_DUPLICATION_IN_BOUNDS,
+                                    span,
+                                    "this trait bound is already specified in trait declaration",
+                                    None,
+                                    "consider removing this trait bound",
+                                );
                             }
-                        });
-                }
+                        }
+                    });
             }
         }
     }
 
     fn check_ty(&mut self, cx: &LateContext<'tcx>, ty: &'tcx Ty<'tcx>) {
-        if_chain! {
-            if let TyKind::Ref(.., mut_ty) = &ty.kind;
-            if let TyKind::TraitObject(bounds, ..) = mut_ty.ty.kind;
-            if bounds.len() > 2;
-            then {
+        if let TyKind::Ref(.., mut_ty) = &ty.kind
+            && let TyKind::TraitObject(bounds, ..) = mut_ty.ty.kind
+            && bounds.len() > 2
+        {
 
-                // Build up a hash of every trait we've seen
-                // When we see a trait for the first time, add it to unique_traits
-                // so we can later use it to build a string of all traits exactly once, without duplicates
+            // Build up a hash of every trait we've seen
+            // When we see a trait for the first time, add it to unique_traits
+            // so we can later use it to build a string of all traits exactly once, without duplicates
 
-                let mut seen_def_ids = FxHashSet::default();
-                let mut unique_traits = Vec::new();
+            let mut seen_def_ids = FxHashSet::default();
+            let mut unique_traits = Vec::new();
 
-                // Iterate the bounds and add them to our seen hash
-                // If we haven't yet seen it, add it to the fixed traits
-                for bound in bounds {
-                    let Some(def_id) = bound.trait_ref.trait_def_id() else { continue; };
+            // Iterate the bounds and add them to our seen hash
+            // If we haven't yet seen it, add it to the fixed traits
+            for bound in bounds {
+                let Some(def_id) = bound.trait_ref.trait_def_id() else { continue; };
 
-                    let new_trait = seen_def_ids.insert(def_id);
+                let new_trait = seen_def_ids.insert(def_id);
 
-                    if new_trait {
-                        unique_traits.push(bound);
-                    }
+                if new_trait {
+                    unique_traits.push(bound);
                 }
+            }
 
-                // If the number of unique traits isn't the same as the number of traits in the bounds,
-                // there must be 1 or more duplicates
-                if bounds.len() != unique_traits.len() {
-                    let mut bounds_span = bounds[0].span;
-
-                    for bound in bounds.iter().skip(1) {
-                        bounds_span = bounds_span.to(bound.span);
-                    }
-
-                    let fixed_trait_snippet = unique_traits
-                        .iter()
-                        .filter_map(|b| snippet_opt(cx, b.span))
-                        .collect::<Vec<_>>()
-                        .join(" + ");
+            // If the number of unique traits isn't the same as the number of traits in the bounds,
+            // there must be 1 or more duplicates
+            if bounds.len() != unique_traits.len() {
+                let mut bounds_span = bounds[0].span;
 
-                    span_lint_and_sugg(
-                        cx,
-                        TRAIT_DUPLICATION_IN_BOUNDS,
-                        bounds_span,
-                        "this trait bound is already specified in trait declaration",
-                        "try",
-                        fixed_trait_snippet,
-                        Applicability::MaybeIncorrect,
-                    );
+                for bound in bounds.iter().skip(1) {
+                    bounds_span = bounds_span.to(bound.span);
                 }
+
+                let fixed_trait_snippet = unique_traits
+                    .iter()
+                    .filter_map(|b| snippet_opt(cx, b.span))
+                    .collect::<Vec<_>>()
+                    .join(" + ");
+
+                span_lint_and_sugg(
+                    cx,
+                    TRAIT_DUPLICATION_IN_BOUNDS,
+                    bounds_span,
+                    "this trait bound is already specified in trait declaration",
+                    "try",
+                    fixed_trait_snippet,
+                    Applicability::MaybeIncorrect,
+                );
             }
         }
     }
@@ -267,36 +263,34 @@ impl TraitBounds {
         let mut map: UnhashMap<SpanlessTy<'_, '_>, Vec<&GenericBound<'_>>> = UnhashMap::default();
         let mut applicability = Applicability::MaybeIncorrect;
         for bound in gen.predicates {
-            if_chain! {
-                if let WherePredicate::BoundPredicate(ref p) = bound;
-                if p.origin != PredicateOrigin::ImplTrait;
-                if p.bounds.len() as u64 <= self.max_trait_bounds;
-                if !p.span.from_expansion();
-                let bounds = p.bounds.iter().filter(|b| !self.cannot_combine_maybe_bound(cx, b)).collect::<Vec<_>>();
-                if !bounds.is_empty();
-                if let Some(ref v) = map.insert(SpanlessTy { ty: p.bounded_ty, cx }, bounds);
-                if !is_from_proc_macro(cx, p.bounded_ty);
-                then {
-                    let trait_bounds = v
-                        .iter()
-                        .copied()
-                        .chain(p.bounds.iter())
-                        .filter_map(get_trait_info_from_bound)
-                        .map(|(_, _, span)| snippet_with_applicability(cx, span, "..", &mut applicability))
-                        .join(" + ");
-                    let hint_string = format!(
-                        "consider combining the bounds: `{}: {trait_bounds}`",
-                        snippet(cx, p.bounded_ty.span, "_"),
-                    );
-                    span_lint_and_help(
-                        cx,
-                        TYPE_REPETITION_IN_BOUNDS,
-                        p.span,
-                        "this type has already been used as a bound predicate",
-                        None,
-                        &hint_string,
-                    );
-                }
+            if let WherePredicate::BoundPredicate(ref p) = bound
+                && p.origin != PredicateOrigin::ImplTrait
+                && p.bounds.len() as u64 <= self.max_trait_bounds
+                && !p.span.from_expansion()
+                && let bounds = p.bounds.iter().filter(|b| !self.cannot_combine_maybe_bound(cx, b)).collect::<Vec<_>>()
+                && !bounds.is_empty()
+                && let Some(ref v) = map.insert(SpanlessTy { ty: p.bounded_ty, cx }, bounds)
+                && !is_from_proc_macro(cx, p.bounded_ty)
+            {
+                let trait_bounds = v
+                    .iter()
+                    .copied()
+                    .chain(p.bounds.iter())
+                    .filter_map(get_trait_info_from_bound)
+                    .map(|(_, _, span)| snippet_with_applicability(cx, span, "..", &mut applicability))
+                    .join(" + ");
+                let hint_string = format!(
+                    "consider combining the bounds: `{}: {trait_bounds}`",
+                    snippet(cx, p.bounded_ty.span, "_"),
+                );
+                span_lint_and_help(
+                    cx,
+                    TYPE_REPETITION_IN_BOUNDS,
+                    p.span,
+                    "this type has already been used as a bound predicate",
+                    None,
+                    &hint_string,
+                );
             }
         }
     }
@@ -318,15 +312,13 @@ fn check_trait_bound_duplication(cx: &LateContext<'_>, gen: &'_ Generics<'_>) {
         .predicates
         .iter()
         .filter_map(|pred| {
-            if_chain! {
-                if pred.in_where_clause();
-                if let WherePredicate::BoundPredicate(bound_predicate) = pred;
-                if let TyKind::Path(QPath::Resolved(_, path)) =  bound_predicate.bounded_ty.kind;
-                then {
-                    return Some(
-                        rollup_traits(cx, bound_predicate.bounds, "these where clauses contain repeated elements")
-                        .into_iter().map(|(trait_ref, _)| (path.res, trait_ref)))
-                }
+            if pred.in_where_clause()
+                && let WherePredicate::BoundPredicate(bound_predicate) = pred
+                && let TyKind::Path(QPath::Resolved(_, path)) =  bound_predicate.bounded_ty.kind
+            {
+                return Some(
+                    rollup_traits(cx, bound_predicate.bounds, "these where clauses contain repeated elements")
+                    .into_iter().map(|(trait_ref, _)| (path.res, trait_ref)))
             }
             None
         })
@@ -340,25 +332,23 @@ fn check_trait_bound_duplication(cx: &LateContext<'_>, gen: &'_ Generics<'_>) {
     // compare trait bounds keyed by generic name and comparable trait to collected where
     // predicates eg. (T, Clone)
     for predicate in gen.predicates.iter().filter(|pred| !pred.in_where_clause()) {
-        if_chain! {
-            if let WherePredicate::BoundPredicate(bound_predicate) = predicate;
-            if bound_predicate.origin != PredicateOrigin::ImplTrait;
-            if !bound_predicate.span.from_expansion();
-            if let TyKind::Path(QPath::Resolved(_, path)) =  bound_predicate.bounded_ty.kind;
-            then {
-                let traits = rollup_traits(cx, bound_predicate.bounds, "these bounds contain repeated elements");
-                for (trait_ref, span) in traits {
-                    let key = (path.res, trait_ref);
-                    if where_predicates.contains(&key) {
-                        span_lint_and_help(
-                            cx,
-                            TRAIT_DUPLICATION_IN_BOUNDS,
-                            span,
-                            "this trait bound is already specified in the where clause",
-                            None,
-                            "consider removing this trait bound",
-                        );
-                    }
+        if let WherePredicate::BoundPredicate(bound_predicate) = predicate
+            && bound_predicate.origin != PredicateOrigin::ImplTrait
+            && !bound_predicate.span.from_expansion()
+            && let TyKind::Path(QPath::Resolved(_, path)) =  bound_predicate.bounded_ty.kind
+        {
+            let traits = rollup_traits(cx, bound_predicate.bounds, "these bounds contain repeated elements");
+            for (trait_ref, span) in traits {
+                let key = (path.res, trait_ref);
+                if where_predicates.contains(&key) {
+                    span_lint_and_help(
+                        cx,
+                        TRAIT_DUPLICATION_IN_BOUNDS,
+                        span,
+                        "this trait bound is already specified in the where clause",
+                        None,
+                        "consider removing this trait bound",
+                    );
                 }
             }
         }
@@ -401,11 +391,9 @@ fn into_comparable_trait_ref(trait_ref: &TraitRef<'_>) -> ComparableTraitRef {
             .filter_map(|segment| {
                 // get trait bound type arguments
                 Some(segment.args?.args.iter().filter_map(|arg| {
-                    if_chain! {
-                        if let GenericArg::Type(ty) = arg;
-                        if let TyKind::Path(QPath::Resolved(_, path)) = ty.kind;
-                        then { return Some(path.res) }
-                    }
+                    if let GenericArg::Type(ty) = arg
+                        && let TyKind::Path(QPath::Resolved(_, path)) = ty.kind
+                    { return Some(path.res) }
                     None
                 }))
             })
@@ -444,27 +432,25 @@ fn rollup_traits(cx: &LateContext<'_>, bounds: &[GenericBound<'_>], msg: &str) -
         comparable_bounds[i] = (k, v);
     }
 
-    if_chain! {
-        if repeated_res;
-        if let [first_trait, .., last_trait] = bounds;
-        then {
-            let all_trait_span = first_trait.span().to(last_trait.span());
-
-            let traits = comparable_bounds.iter()
-                .filter_map(|&(_, span)| snippet_opt(cx, span))
-                .collect::<Vec<_>>();
-            let traits = traits.join(" + ");
-
-            span_lint_and_sugg(
-                cx,
-                TRAIT_DUPLICATION_IN_BOUNDS,
-                all_trait_span,
-                msg,
-                "try",
-                traits,
-                Applicability::MachineApplicable
-            );
-        }
+    if repeated_res
+        && let [first_trait, .., last_trait] = bounds
+    {
+        let all_trait_span = first_trait.span().to(last_trait.span());
+
+        let traits = comparable_bounds.iter()
+            .filter_map(|&(_, span)| snippet_opt(cx, span))
+            .collect::<Vec<_>>();
+        let traits = traits.join(" + ");
+
+        span_lint_and_sugg(
+            cx,
+            TRAIT_DUPLICATION_IN_BOUNDS,
+            all_trait_span,
+            msg,
+            "try",
+            traits,
+            Applicability::MachineApplicable
+        );
     }
 
     comparable_bounds
diff --git a/clippy_lints/src/transmute/mod.rs b/clippy_lints/src/transmute/mod.rs
index 6eec40cb529..89580005c52 100644
--- a/clippy_lints/src/transmute/mod.rs
+++ b/clippy_lints/src/transmute/mod.rs
@@ -494,51 +494,49 @@ impl Transmute {
 }
 impl<'tcx> LateLintPass<'tcx> for Transmute {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
-        if_chain! {
-            if let ExprKind::Call(path_expr, [arg]) = e.kind;
-            if let ExprKind::Path(QPath::Resolved(None, path)) = path_expr.kind;
-            if let Some(def_id) = path.res.opt_def_id();
-            if cx.tcx.is_diagnostic_item(sym::transmute, def_id);
-            then {
-                // Avoid suggesting non-const operations in const contexts:
-                // - from/to bits (https://github.com/rust-lang/rust/issues/73736)
-                // - dereferencing raw pointers (https://github.com/rust-lang/rust/issues/51911)
-                // - char conversions (https://github.com/rust-lang/rust/issues/89259)
-                let const_context = in_constant(cx, e.hir_id);
+        if let ExprKind::Call(path_expr, [arg]) = e.kind
+            && let ExprKind::Path(QPath::Resolved(None, path)) = path_expr.kind
+            && let Some(def_id) = path.res.opt_def_id()
+            && cx.tcx.is_diagnostic_item(sym::transmute, def_id)
+        {
+            // Avoid suggesting non-const operations in const contexts:
+            // - from/to bits (https://github.com/rust-lang/rust/issues/73736)
+            // - dereferencing raw pointers (https://github.com/rust-lang/rust/issues/51911)
+            // - char conversions (https://github.com/rust-lang/rust/issues/89259)
+            let const_context = in_constant(cx, e.hir_id);
 
-                let (from_ty, from_ty_adjusted) = match cx.typeck_results().expr_adjustments(arg) {
-                    [] => (cx.typeck_results().expr_ty(arg), false),
-                    [.., a] => (a.target, true),
-                };
-                // Adjustments for `to_ty` happen after the call to `transmute`, so don't use them.
-                let to_ty = cx.typeck_results().expr_ty(e);
+            let (from_ty, from_ty_adjusted) = match cx.typeck_results().expr_adjustments(arg) {
+                [] => (cx.typeck_results().expr_ty(arg), false),
+                [.., a] => (a.target, true),
+            };
+            // Adjustments for `to_ty` happen after the call to `transmute`, so don't use them.
+            let to_ty = cx.typeck_results().expr_ty(e);
 
-                // If useless_transmute is triggered, the other lints can be skipped.
-                if useless_transmute::check(cx, e, from_ty, to_ty, arg) {
-                    return;
-                }
+            // If useless_transmute is triggered, the other lints can be skipped.
+            if useless_transmute::check(cx, e, from_ty, to_ty, arg) {
+                return;
+            }
 
-                let linted = wrong_transmute::check(cx, e, from_ty, to_ty)
-                    | crosspointer_transmute::check(cx, e, from_ty, to_ty)
-                    | transmuting_null::check(cx, e, arg, to_ty)
-                    | transmute_null_to_fn::check(cx, e, arg, to_ty)
-                    | transmute_ptr_to_ref::check(cx, e, from_ty, to_ty, arg, path, &self.msrv)
-                    | transmute_int_to_char::check(cx, e, from_ty, to_ty, arg, const_context)
-                    | transmute_ref_to_ref::check(cx, e, from_ty, to_ty, arg, const_context)
-                    | transmute_ptr_to_ptr::check(cx, e, from_ty, to_ty, arg)
-                    | transmute_int_to_bool::check(cx, e, from_ty, to_ty, arg)
-                    | transmute_int_to_float::check(cx, e, from_ty, to_ty, arg, const_context)
-                    | transmute_int_to_non_zero::check(cx, e, from_ty, to_ty, arg)
-                    | transmute_float_to_int::check(cx, e, from_ty, to_ty, arg, const_context)
-                    | transmute_num_to_bytes::check(cx, e, from_ty, to_ty, arg, const_context)
-                    | (
-                        unsound_collection_transmute::check(cx, e, from_ty, to_ty)
-                        || transmute_undefined_repr::check(cx, e, from_ty, to_ty)
-                    );
+            let linted = wrong_transmute::check(cx, e, from_ty, to_ty)
+                | crosspointer_transmute::check(cx, e, from_ty, to_ty)
+                | transmuting_null::check(cx, e, arg, to_ty)
+                | transmute_null_to_fn::check(cx, e, arg, to_ty)
+                | transmute_ptr_to_ref::check(cx, e, from_ty, to_ty, arg, path, &self.msrv)
+                | transmute_int_to_char::check(cx, e, from_ty, to_ty, arg, const_context)
+                | transmute_ref_to_ref::check(cx, e, from_ty, to_ty, arg, const_context)
+                | transmute_ptr_to_ptr::check(cx, e, from_ty, to_ty, arg)
+                | transmute_int_to_bool::check(cx, e, from_ty, to_ty, arg)
+                | transmute_int_to_float::check(cx, e, from_ty, to_ty, arg, const_context)
+                | transmute_int_to_non_zero::check(cx, e, from_ty, to_ty, arg)
+                | transmute_float_to_int::check(cx, e, from_ty, to_ty, arg, const_context)
+                | transmute_num_to_bytes::check(cx, e, from_ty, to_ty, arg, const_context)
+                | (
+                    unsound_collection_transmute::check(cx, e, from_ty, to_ty)
+                    || transmute_undefined_repr::check(cx, e, from_ty, to_ty)
+                );
 
-                if !linted {
-                    transmutes_expressible_as_ptr_casts::check(cx, e, from_ty, from_ty_adjusted, to_ty, arg);
-                }
+            if !linted {
+                transmutes_expressible_as_ptr_casts::check(cx, e, from_ty, from_ty_adjusted, to_ty, arg);
             }
         }
     }
diff --git a/clippy_lints/src/transmute/transmute_float_to_int.rs b/clippy_lints/src/transmute/transmute_float_to_int.rs
index 5ecba512b0f..fe30a585da0 100644
--- a/clippy_lints/src/transmute/transmute_float_to_int.rs
+++ b/clippy_lints/src/transmute/transmute_float_to_int.rs
@@ -32,17 +32,15 @@ pub(super) fn check<'tcx>(
                         arg = inner_expr;
                     }
 
-                    if_chain! {
+                    if let ExprKind::Lit(lit) = &arg.kind
                         // if the expression is a float literal and it is unsuffixed then
                         // add a suffix so the suggestion is valid and unambiguous
-                        if let ExprKind::Lit(lit) = &arg.kind;
-                        if let ast::LitKind::Float(_, ast::LitFloatType::Unsuffixed) = lit.node;
-                        then {
-                            let op = format!("{sugg}{}", float_ty.name_str()).into();
-                            match sugg {
-                                sugg::Sugg::MaybeParen(_) => sugg = sugg::Sugg::MaybeParen(op),
-                                _ => sugg = sugg::Sugg::NonParen(op)
-                            }
+                        && let ast::LitKind::Float(_, ast::LitFloatType::Unsuffixed) = lit.node
+                    {
+                        let op = format!("{sugg}{}", float_ty.name_str()).into();
+                        match sugg {
+                            sugg::Sugg::MaybeParen(_) => sugg = sugg::Sugg::MaybeParen(op),
+                            _ => sugg = sugg::Sugg::NonParen(op)
                         }
                     }
 
diff --git a/clippy_lints/src/transmute/transmute_ref_to_ref.rs b/clippy_lints/src/transmute/transmute_ref_to_ref.rs
index ea9ad99618a..52bb68845db 100644
--- a/clippy_lints/src/transmute/transmute_ref_to_ref.rs
+++ b/clippy_lints/src/transmute/transmute_ref_to_ref.rs
@@ -21,67 +21,65 @@ pub(super) fn check<'tcx>(
     let mut triggered = false;
 
     if let (ty::Ref(_, ty_from, from_mutbl), ty::Ref(_, ty_to, to_mutbl)) = (&from_ty.kind(), &to_ty.kind()) {
-        if_chain! {
-            if let ty::Slice(slice_ty) = *ty_from.kind();
-            if ty_to.is_str();
-            if let ty::Uint(ty::UintTy::U8) = slice_ty.kind();
-            if from_mutbl == to_mutbl;
-            then {
-                let postfix = if *from_mutbl == Mutability::Mut {
-                    "_mut"
-                } else {
-                    ""
-                };
+        if let ty::Slice(slice_ty) = *ty_from.kind()
+            && ty_to.is_str()
+            && let ty::Uint(ty::UintTy::U8) = slice_ty.kind()
+            && from_mutbl == to_mutbl
+        {
+            let postfix = if *from_mutbl == Mutability::Mut {
+                "_mut"
+            } else {
+                ""
+            };
 
-                let snippet = snippet(cx, arg.span, "..");
+            let snippet = snippet(cx, arg.span, "..");
 
-                span_lint_and_sugg(
+            span_lint_and_sugg(
+                cx,
+                TRANSMUTE_BYTES_TO_STR,
+                e.span,
+                &format!("transmute from a `{from_ty}` to a `{to_ty}`"),
+                "consider using",
+                if const_context {
+                    format!("std::str::from_utf8_unchecked{postfix}({snippet})")
+                } else {
+                    format!("std::str::from_utf8{postfix}({snippet}).unwrap()")
+                },
+                Applicability::MaybeIncorrect,
+            );
+            triggered = true;
+        } else {
+            if (cx.tcx.erase_regions(from_ty) != cx.tcx.erase_regions(to_ty))
+                && !const_context {
+                span_lint_and_then(
                     cx,
-                    TRANSMUTE_BYTES_TO_STR,
+                    TRANSMUTE_PTR_TO_PTR,
                     e.span,
-                    &format!("transmute from a `{from_ty}` to a `{to_ty}`"),
-                    "consider using",
-                    if const_context {
-                        format!("std::str::from_utf8_unchecked{postfix}({snippet})")
-                    } else {
-                        format!("std::str::from_utf8{postfix}({snippet}).unwrap()")
+                    "transmute from a reference to a reference",
+                    |diag| if let Some(arg) = sugg::Sugg::hir_opt(cx, arg) {
+                        let ty_from_and_mut = ty::TypeAndMut {
+                            ty: *ty_from,
+                            mutbl: *from_mutbl
+                        };
+                        let ty_to_and_mut = ty::TypeAndMut { ty: *ty_to, mutbl: *to_mutbl };
+                        let sugg_paren = arg
+                            .as_ty(Ty::new_ptr(cx.tcx,ty_from_and_mut))
+                            .as_ty(Ty::new_ptr(cx.tcx,ty_to_and_mut));
+                        let sugg = if *to_mutbl == Mutability::Mut {
+                            sugg_paren.mut_addr_deref()
+                        } else {
+                            sugg_paren.addr_deref()
+                        };
+                        diag.span_suggestion(
+                            e.span,
+                            "try",
+                            sugg,
+                            Applicability::Unspecified,
+                        );
                     },
-                    Applicability::MaybeIncorrect,
                 );
-                triggered = true;
-            } else {
-                if (cx.tcx.erase_regions(from_ty) != cx.tcx.erase_regions(to_ty))
-                    && !const_context {
-                    span_lint_and_then(
-                        cx,
-                        TRANSMUTE_PTR_TO_PTR,
-                        e.span,
-                        "transmute from a reference to a reference",
-                        |diag| if let Some(arg) = sugg::Sugg::hir_opt(cx, arg) {
-                            let ty_from_and_mut = ty::TypeAndMut {
-                                ty: *ty_from,
-                                mutbl: *from_mutbl
-                            };
-                            let ty_to_and_mut = ty::TypeAndMut { ty: *ty_to, mutbl: *to_mutbl };
-                            let sugg_paren = arg
-                                .as_ty(Ty::new_ptr(cx.tcx,ty_from_and_mut))
-                                .as_ty(Ty::new_ptr(cx.tcx,ty_to_and_mut));
-                            let sugg = if *to_mutbl == Mutability::Mut {
-                                sugg_paren.mut_addr_deref()
-                            } else {
-                                sugg_paren.addr_deref()
-                            };
-                            diag.span_suggestion(
-                                e.span,
-                                "try",
-                                sugg,
-                                Applicability::Unspecified,
-                            );
-                        },
-                    );
 
-                    triggered = true;
-                }
+                triggered = true;
             }
         }
     }
diff --git a/clippy_lints/src/transmute/transmute_undefined_repr.rs b/clippy_lints/src/transmute/transmute_undefined_repr.rs
index 7c2223ca3ab..a65bc0ce458 100644
--- a/clippy_lints/src/transmute/transmute_undefined_repr.rs
+++ b/clippy_lints/src/transmute/transmute_undefined_repr.rs
@@ -299,14 +299,12 @@ fn reduce_ty<'tcx>(cx: &LateContext<'tcx>, mut ty: Ty<'tcx>) -> ReducedTy<'tcx>
 }
 
 fn is_zero_sized_ty<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
-    if_chain! {
-        if let Ok(ty) = cx.tcx.try_normalize_erasing_regions(cx.param_env, ty);
-        if let Ok(layout) = cx.tcx.layout_of(cx.param_env.and(ty));
-        then {
-            layout.layout.size().bytes() == 0
-        } else {
-            false
-        }
+    if let Ok(ty) = cx.tcx.try_normalize_erasing_regions(cx.param_env, ty)
+        && let Ok(layout) = cx.tcx.layout_of(cx.param_env.and(ty))
+    {
+        layout.layout.size().bytes() == 0
+    } else {
+        false
     }
 }
 
diff --git a/clippy_lints/src/types/borrowed_box.rs b/clippy_lints/src/types/borrowed_box.rs
index 306ca5724da..a67431123ad 100644
--- a/clippy_lints/src/types/borrowed_box.rs
+++ b/clippy_lints/src/types/borrowed_box.rs
@@ -15,66 +15,64 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, lt: &Lifetime, m
         TyKind::Path(ref qpath) => {
             let hir_id = mut_ty.ty.hir_id;
             let def = cx.qpath_res(qpath, hir_id);
-            if_chain! {
-                if let Some(def_id) = def.opt_def_id();
-                if Some(def_id) == cx.tcx.lang_items().owned_box();
-                if let QPath::Resolved(None, path) = *qpath;
-                if let [ref bx] = *path.segments;
-                if let Some(params) = bx.args;
-                if params.parenthesized == hir::GenericArgsParentheses::No;
-                if let Some(inner) = params.args.iter().find_map(|arg| match arg {
+            if let Some(def_id) = def.opt_def_id()
+                && Some(def_id) == cx.tcx.lang_items().owned_box()
+                && let QPath::Resolved(None, path) = *qpath
+                && let [ref bx] = *path.segments
+                && let Some(params) = bx.args
+                && params.parenthesized == hir::GenericArgsParentheses::No
+                && let Some(inner) = params.args.iter().find_map(|arg| match arg {
                     GenericArg::Type(ty) => Some(ty),
                     _ => None,
-                });
-                then {
-                    if is_any_trait(cx, inner) {
-                        // Ignore `Box<Any>` types; see issue #1884 for details.
-                        return false;
-                    }
-
-                    let ltopt = if lt.is_anonymous() {
-                        String::new()
-                    } else {
-                        format!("{} ", lt.ident.as_str())
-                    };
+                })
+            {
+                if is_any_trait(cx, inner) {
+                    // Ignore `Box<Any>` types; see issue #1884 for details.
+                    return false;
+                }
 
-                    if mut_ty.mutbl == Mutability::Mut {
-                        // Ignore `&mut Box<T>` types; see issue #2907 for
-                        // details.
-                        return false;
-                    }
+                let ltopt = if lt.is_anonymous() {
+                    String::new()
+                } else {
+                    format!("{} ", lt.ident.as_str())
+                };
 
-                    // When trait objects or opaque types have lifetime or auto-trait bounds,
-                    // we need to add parentheses to avoid a syntax error due to its ambiguity.
-                    // Originally reported as the issue #3128.
-                    let inner_snippet = snippet(cx, inner.span, "..");
-                    let suggestion = match &inner.kind {
-                        TyKind::TraitObject(bounds, lt_bound, _) if bounds.len() > 1 || !lt_bound.is_elided() => {
-                            format!("&{ltopt}({})", &inner_snippet)
-                        },
-                        TyKind::Path(qpath)
-                            if get_bounds_if_impl_trait(cx, qpath, inner.hir_id)
-                                .map_or(false, |bounds| bounds.len() > 1) =>
-                        {
-                            format!("&{ltopt}({})", &inner_snippet)
-                        },
-                        _ => format!("&{ltopt}{}", &inner_snippet),
-                    };
-                    span_lint_and_sugg(
-                        cx,
-                        BORROWED_BOX,
-                        hir_ty.span,
-                        "you seem to be trying to use `&Box<T>`. Consider using just `&T`",
-                        "try",
-                        suggestion,
-                        // To make this `MachineApplicable`, at least one needs to check if it isn't a trait item
-                        // because the trait impls of it will break otherwise;
-                        // and there may be other cases that result in invalid code.
-                        // For example, type coercion doesn't work nicely.
-                        Applicability::Unspecified,
-                    );
-                    return true;
+                if mut_ty.mutbl == Mutability::Mut {
+                    // Ignore `&mut Box<T>` types; see issue #2907 for
+                    // details.
+                    return false;
                 }
+
+                // When trait objects or opaque types have lifetime or auto-trait bounds,
+                // we need to add parentheses to avoid a syntax error due to its ambiguity.
+                // Originally reported as the issue #3128.
+                let inner_snippet = snippet(cx, inner.span, "..");
+                let suggestion = match &inner.kind {
+                    TyKind::TraitObject(bounds, lt_bound, _) if bounds.len() > 1 || !lt_bound.is_elided() => {
+                        format!("&{ltopt}({})", &inner_snippet)
+                    },
+                    TyKind::Path(qpath)
+                        if get_bounds_if_impl_trait(cx, qpath, inner.hir_id)
+                            .map_or(false, |bounds| bounds.len() > 1) =>
+                    {
+                        format!("&{ltopt}({})", &inner_snippet)
+                    },
+                    _ => format!("&{ltopt}{}", &inner_snippet),
+                };
+                span_lint_and_sugg(
+                    cx,
+                    BORROWED_BOX,
+                    hir_ty.span,
+                    "you seem to be trying to use `&Box<T>`. Consider using just `&T`",
+                    "try",
+                    suggestion,
+                    // To make this `MachineApplicable`, at least one needs to check if it isn't a trait item
+                    // because the trait impls of it will break otherwise;
+                    // and there may be other cases that result in invalid code.
+                    // For example, type coercion doesn't work nicely.
+                    Applicability::Unspecified,
+                );
+                return true;
             };
             false
         },
@@ -84,33 +82,29 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, lt: &Lifetime, m
 
 // Returns true if given type is `Any` trait.
 fn is_any_trait(cx: &LateContext<'_>, t: &hir::Ty<'_>) -> bool {
-    if_chain! {
-        if let TyKind::TraitObject(traits, ..) = t.kind;
-        if !traits.is_empty();
-        if let Some(trait_did) = traits[0].trait_ref.trait_def_id();
+    if let TyKind::TraitObject(traits, ..) = t.kind
+        && !traits.is_empty()
+        && let Some(trait_did) = traits[0].trait_ref.trait_def_id()
         // Only Send/Sync can be used as additional traits, so it is enough to
         // check only the first trait.
-        if cx.tcx.is_diagnostic_item(sym::Any, trait_did);
-        then {
-            return true;
-        }
+        && cx.tcx.is_diagnostic_item(sym::Any, trait_did)
+    {
+        return true;
     }
 
     false
 }
 
 fn get_bounds_if_impl_trait<'tcx>(cx: &LateContext<'tcx>, qpath: &QPath<'_>, id: HirId) -> Option<GenericBounds<'tcx>> {
-    if_chain! {
-        if let Some(did) = cx.qpath_res(qpath, id).opt_def_id();
-        if let Some(Node::GenericParam(generic_param)) = cx.tcx.hir().get_if_local(did);
-        if let GenericParamKind::Type { synthetic, .. } = generic_param.kind;
-        if synthetic;
-        if let Some(generics) = cx.tcx.hir().get_generics(id.owner.def_id);
-        if let Some(pred) = generics.bounds_for_param(did.expect_local()).next();
-        then {
-            Some(pred.bounds)
-        } else {
-            None
-        }
+    if let Some(did) = cx.qpath_res(qpath, id).opt_def_id()
+        && let Some(Node::GenericParam(generic_param)) = cx.tcx.hir().get_if_local(did)
+        && let GenericParamKind::Type { synthetic, .. } = generic_param.kind
+        && synthetic
+        && let Some(generics) = cx.tcx.hir().get_generics(id.owner.def_id)
+        && let Some(pred) = generics.bounds_for_param(did.expect_local()).next()
+    {
+        Some(pred.bounds)
+    } else {
+        None
     }
 }
diff --git a/clippy_lints/src/types/box_collection.rs b/clippy_lints/src/types/box_collection.rs
index 4a5a94f2630..badd8acbc90 100644
--- a/clippy_lints/src/types/box_collection.rs
+++ b/clippy_lints/src/types/box_collection.rs
@@ -8,30 +8,28 @@ use rustc_span::{sym, Symbol};
 use super::BOX_COLLECTION;
 
 pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_>, def_id: DefId) -> bool {
-    if_chain! {
-        if Some(def_id) == cx.tcx.lang_items().owned_box();
-        if let Some(item_type) = get_std_collection(cx, qpath);
-        then {
-            let generic = match item_type {
-                sym::String => "",
-                _ => "<..>",
-            };
+    if Some(def_id) == cx.tcx.lang_items().owned_box()
+        && let Some(item_type) = get_std_collection(cx, qpath)
+    {
+        let generic = match item_type {
+            sym::String => "",
+            _ => "<..>",
+        };
 
-            let box_content = format!("{item_type}{generic}");
-            span_lint_and_help(
-                cx,
-                BOX_COLLECTION,
-                hir_ty.span,
-                &format!(
-                    "you seem to be trying to use `Box<{box_content}>`. Consider using just `{box_content}`"),
-                None,
-                &format!(
-                    "`{box_content}` is already on the heap, `Box<{box_content}>` makes an extra allocation")
-            );
-            true
-        } else {
-            false
-        }
+        let box_content = format!("{item_type}{generic}");
+        span_lint_and_help(
+            cx,
+            BOX_COLLECTION,
+            hir_ty.span,
+            &format!(
+                "you seem to be trying to use `Box<{box_content}>`. Consider using just `{box_content}`"),
+            None,
+            &format!(
+                "`{box_content}` is already on the heap, `Box<{box_content}>` makes an extra allocation")
+        );
+        true
+    } else {
+        false
     }
 }
 
diff --git a/clippy_lints/src/types/option_option.rs b/clippy_lints/src/types/option_option.rs
index 60622903af1..98284031344 100644
--- a/clippy_lints/src/types/option_option.rs
+++ b/clippy_lints/src/types/option_option.rs
@@ -9,21 +9,19 @@ use rustc_span::symbol::sym;
 use super::OPTION_OPTION;
 
 pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_>, def_id: DefId) -> bool {
-    if_chain! {
-        if cx.tcx.is_diagnostic_item(sym::Option, def_id);
-        if let Some(arg) = qpath_generic_tys(qpath).next();
-        if path_def_id(cx, arg) == Some(def_id);
-        then {
-            span_lint(
-                cx,
-                OPTION_OPTION,
-                hir_ty.span,
-                "consider using `Option<T>` instead of `Option<Option<T>>` or a custom \
-                                     enum if you need to distinguish all 3 cases",
-            );
-            true
-        } else {
-            false
-        }
+    if cx.tcx.is_diagnostic_item(sym::Option, def_id)
+        && let Some(arg) = qpath_generic_tys(qpath).next()
+        && path_def_id(cx, arg) == Some(def_id)
+    {
+        span_lint(
+            cx,
+            OPTION_OPTION,
+            hir_ty.span,
+            "consider using `Option<T>` instead of `Option<Option<T>>` or a custom \
+                                 enum if you need to distinguish all 3 cases",
+        );
+        true
+    } else {
+        false
     }
 }
diff --git a/clippy_lints/src/types/rc_mutex.rs b/clippy_lints/src/types/rc_mutex.rs
index a616c3e4ea8..1ab4d233ff7 100644
--- a/clippy_lints/src/types/rc_mutex.rs
+++ b/clippy_lints/src/types/rc_mutex.rs
@@ -9,22 +9,20 @@ use rustc_span::symbol::sym;
 use super::RC_MUTEX;
 
 pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_>, def_id: DefId) -> bool {
-    if_chain! {
-        if cx.tcx.is_diagnostic_item(sym::Rc, def_id) ;
-        if let Some(arg) = qpath_generic_tys(qpath).next();
-        if let Some(id) = path_def_id(cx, arg);
-        if cx.tcx.is_diagnostic_item(sym::Mutex, id);
-        then {
-            span_lint_and_help(
-                cx,
-                RC_MUTEX,
-                hir_ty.span,
-                "usage of `Rc<Mutex<_>>`",
-                None,
-                "consider using `Rc<RefCell<_>>` or `Arc<Mutex<_>>` instead",
-            );
-            return true;
-        }
+    if cx.tcx.is_diagnostic_item(sym::Rc, def_id) 
+        && let Some(arg) = qpath_generic_tys(qpath).next()
+        && let Some(id) = path_def_id(cx, arg)
+        && cx.tcx.is_diagnostic_item(sym::Mutex, id)
+    {
+        span_lint_and_help(
+            cx,
+            RC_MUTEX,
+            hir_ty.span,
+            "usage of `Rc<Mutex<_>>`",
+            None,
+            "consider using `Rc<RefCell<_>>` or `Arc<Mutex<_>>` instead",
+        );
+        return true;
     }
 
     false
diff --git a/clippy_lints/src/types/utils.rs b/clippy_lints/src/types/utils.rs
index a30748db88f..7278447a70e 100644
--- a/clippy_lints/src/types/utils.rs
+++ b/clippy_lints/src/types/utils.rs
@@ -6,17 +6,15 @@ use rustc_span::source_map::Span;
 
 pub(super) fn match_borrows_parameter(_cx: &LateContext<'_>, qpath: &QPath<'_>) -> Option<Span> {
     let last = last_path_segment(qpath);
-    if_chain! {
-        if let Some(params) = last.args;
-        if params.parenthesized == GenericArgsParentheses::No;
-        if let Some(ty) = params.args.iter().find_map(|arg| match arg {
+    if let Some(params) = last.args
+        && params.parenthesized == GenericArgsParentheses::No
+        && let Some(ty) = params.args.iter().find_map(|arg| match arg {
             GenericArg::Type(ty) => Some(ty),
             _ => None,
-        });
-        if let TyKind::Ref(..) = ty.kind;
-        then {
-            return Some(ty.span);
-        }
+        })
+        && let TyKind::Ref(..) = ty.kind
+    {
+        return Some(ty.span);
     }
     None
 }
diff --git a/clippy_lints/src/uninit_vec.rs b/clippy_lints/src/uninit_vec.rs
index 72569e10f05..ff616805d08 100644
--- a/clippy_lints/src/uninit_vec.rs
+++ b/clippy_lints/src/uninit_vec.rs
@@ -83,41 +83,39 @@ fn handle_uninit_vec_pair<'tcx>(
     maybe_init_or_reserve: &'tcx Stmt<'tcx>,
     maybe_set_len: &'tcx Expr<'tcx>,
 ) {
-    if_chain! {
-        if let Some(vec) = extract_init_or_reserve_target(cx, maybe_init_or_reserve);
-        if let Some((set_len_self, call_span)) = extract_set_len_self(cx, maybe_set_len);
-        if vec.location.eq_expr(cx, set_len_self);
-        if let ty::Ref(_, vec_ty, _) = cx.typeck_results().expr_ty_adjusted(set_len_self).kind();
-        if let ty::Adt(_, args) = vec_ty.kind();
+    if let Some(vec) = extract_init_or_reserve_target(cx, maybe_init_or_reserve)
+        && let Some((set_len_self, call_span)) = extract_set_len_self(cx, maybe_set_len)
+        && vec.location.eq_expr(cx, set_len_self)
+        && let ty::Ref(_, vec_ty, _) = cx.typeck_results().expr_ty_adjusted(set_len_self).kind()
+        && let ty::Adt(_, args) = vec_ty.kind()
         // `#[allow(...)]` attribute can be set on enclosing unsafe block of `set_len()`
-        if !is_lint_allowed(cx, UNINIT_VEC, maybe_set_len.hir_id);
-        then {
-            if vec.has_capacity() {
-                // with_capacity / reserve -> set_len
+        && !is_lint_allowed(cx, UNINIT_VEC, maybe_set_len.hir_id)
+    {
+        if vec.has_capacity() {
+            // with_capacity / reserve -> set_len
 
-                // Check T of Vec<T>
-                if !is_uninit_value_valid_for_ty(cx, args.type_at(0)) {
-                    // FIXME: #7698, false positive of the internal lints
-                    #[expect(clippy::collapsible_span_lint_calls)]
-                    span_lint_and_then(
-                        cx,
-                        UNINIT_VEC,
-                        vec![call_span, maybe_init_or_reserve.span],
-                        "calling `set_len()` immediately after reserving a buffer creates uninitialized values",
-                        |diag| {
-                            diag.help("initialize the buffer or wrap the content in `MaybeUninit`");
-                        },
-                    );
-                }
-            } else {
-                // new / default -> set_len
-                span_lint(
+            // Check T of Vec<T>
+            if !is_uninit_value_valid_for_ty(cx, args.type_at(0)) {
+                // FIXME: #7698, false positive of the internal lints
+                #[expect(clippy::collapsible_span_lint_calls)]
+                span_lint_and_then(
                     cx,
                     UNINIT_VEC,
                     vec![call_span, maybe_init_or_reserve.span],
-                    "calling `set_len()` on empty `Vec` creates out-of-bound values",
+                    "calling `set_len()` immediately after reserving a buffer creates uninitialized values",
+                    |diag| {
+                        diag.help("initialize the buffer or wrap the content in `MaybeUninit`");
+                    },
                 );
             }
+        } else {
+            // new / default -> set_len
+            span_lint(
+                cx,
+                UNINIT_VEC,
+                vec![call_span, maybe_init_or_reserve.span],
+                "calling `set_len()` on empty `Vec` creates out-of-bound values",
+            );
         }
     }
 }
@@ -156,16 +154,14 @@ impl<'tcx> VecLocation<'tcx> {
 fn extract_init_or_reserve_target<'tcx>(cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'tcx>) -> Option<TargetVec<'tcx>> {
     match stmt.kind {
         StmtKind::Local(local) => {
-            if_chain! {
-                if let Some(init_expr) = local.init;
-                if let PatKind::Binding(_, hir_id, _, None) = local.pat.kind;
-                if let Some(init_kind) = get_vec_init_kind(cx, init_expr);
-                then {
-                    return Some(TargetVec {
-                        location: VecLocation::Local(hir_id),
-                        init_kind: Some(init_kind),
-                    })
-                }
+            if let Some(init_expr) = local.init
+                && let PatKind::Binding(_, hir_id, _, None) = local.pat.kind
+                && let Some(init_kind) = get_vec_init_kind(cx, init_expr)
+            {
+                return Some(TargetVec {
+                    location: VecLocation::Local(hir_id),
+                    init_kind: Some(init_kind),
+                })
             }
         },
         StmtKind::Expr(expr) | StmtKind::Semi(expr) => match expr.kind {
diff --git a/clippy_lints/src/unit_return_expecting_ord.rs b/clippy_lints/src/unit_return_expecting_ord.rs
index e76cc65fd46..8145c4e5108 100644
--- a/clippy_lints/src/unit_return_expecting_ord.rs
+++ b/clippy_lints/src/unit_return_expecting_ord.rs
@@ -44,14 +44,12 @@ fn get_trait_predicates_for_trait_id<'tcx>(
 ) -> Vec<TraitPredicate<'tcx>> {
     let mut preds = Vec::new();
     for (pred, _) in generics.predicates {
-        if_chain! {
-            if let ClauseKind::Trait(poly_trait_pred) = pred.kind().skip_binder();
-            let trait_pred = cx.tcx.erase_late_bound_regions(pred.kind().rebind(poly_trait_pred));
-            if let Some(trait_def_id) = trait_id;
-            if trait_def_id == trait_pred.trait_ref.def_id;
-            then {
-                preds.push(trait_pred);
-            }
+        if let ClauseKind::Trait(poly_trait_pred) = pred.kind().skip_binder()
+            && let trait_pred = cx.tcx.erase_late_bound_regions(pred.kind().rebind(poly_trait_pred))
+            && let Some(trait_def_id) = trait_id
+            && trait_def_id == trait_pred.trait_ref.def_id
+        {
+            preds.push(trait_pred);
         }
     }
     preds
@@ -94,21 +92,19 @@ fn get_args_to_check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> Ve
             .enumerate()
             .for_each(|(i, inp)| {
                 for trait_pred in &fn_mut_preds {
-                    if_chain! {
-                        if trait_pred.self_ty() == inp;
-                        if let Some(return_ty_pred) = get_projection_pred(cx, generics, *trait_pred);
-                        then {
-                            if ord_preds
-                                .iter()
-                                .any(|ord| Some(ord.self_ty()) == return_ty_pred.term.ty())
-                            {
-                                args_to_check.push((i, "Ord".to_string()));
-                            } else if partial_ord_preds
-                                .iter()
-                                .any(|pord| pord.self_ty() == return_ty_pred.term.ty().unwrap())
-                            {
-                                args_to_check.push((i, "PartialOrd".to_string()));
-                            }
+                    if trait_pred.self_ty() == inp
+                        && let Some(return_ty_pred) = get_projection_pred(cx, generics, *trait_pred)
+                    {
+                        if ord_preds
+                            .iter()
+                            .any(|ord| Some(ord.self_ty()) == return_ty_pred.term.ty())
+                        {
+                            args_to_check.push((i, "Ord".to_string()));
+                        } else if partial_ord_preds
+                            .iter()
+                            .any(|pord| pord.self_ty() == return_ty_pred.term.ty().unwrap())
+                        {
+                            args_to_check.push((i, "PartialOrd".to_string()));
                         }
                     }
                 }
@@ -118,30 +114,26 @@ fn get_args_to_check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> Ve
 }
 
 fn check_arg<'tcx>(cx: &LateContext<'tcx>, arg: &'tcx Expr<'tcx>) -> Option<(Span, Option<Span>)> {
-    if_chain! {
-        if let ExprKind::Closure(&Closure { body, fn_decl_span, .. }) = arg.kind;
-        if let ty::Closure(_def_id, args) = &cx.typeck_results().node_type(arg.hir_id).kind();
-        let ret_ty = args.as_closure().sig().output();
-        let ty = cx.tcx.erase_late_bound_regions(ret_ty);
-        if ty.is_unit();
-        then {
-            let body = cx.tcx.hir().body(body);
-            if_chain! {
-                if let ExprKind::Block(block, _) = body.value.kind;
-                if block.expr.is_none();
-                if let Some(stmt) = block.stmts.last();
-                if let StmtKind::Semi(_) = stmt.kind;
-                then {
-                    let data = stmt.span.data();
-                    // Make a span out of the semicolon for the help message
-                    Some((fn_decl_span, Some(data.with_lo(data.hi-BytePos(1)))))
-                } else {
-                    Some((fn_decl_span, None))
-                }
-            }
+    if let ExprKind::Closure(&Closure { body, fn_decl_span, .. }) = arg.kind
+        && let ty::Closure(_def_id, args) = &cx.typeck_results().node_type(arg.hir_id).kind()
+        && let ret_ty = args.as_closure().sig().output()
+        && let ty = cx.tcx.erase_late_bound_regions(ret_ty)
+        && ty.is_unit()
+    {
+        let body = cx.tcx.hir().body(body);
+        if let ExprKind::Block(block, _) = body.value.kind
+            && block.expr.is_none()
+            && let Some(stmt) = block.stmts.last()
+            && let StmtKind::Semi(_) = stmt.kind
+        {
+            let data = stmt.span.data();
+            // Make a span out of the semicolon for the help message
+            Some((fn_decl_span, Some(data.with_lo(data.hi-BytePos(1)))))
         } else {
-            None
+            Some((fn_decl_span, None))
         }
+    } else {
+        None
     }
 }
 
diff --git a/clippy_lints/src/unit_types/unit_arg.rs b/clippy_lints/src/unit_types/unit_arg.rs
index 462b1aa8153..76d07f77f46 100644
--- a/clippy_lints/src/unit_types/unit_arg.rs
+++ b/clippy_lints/src/unit_types/unit_arg.rs
@@ -22,12 +22,10 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
     }
     let map = &cx.tcx.hir();
     let opt_parent_node = map.find_parent(expr.hir_id);
-    if_chain! {
-        if let Some(hir::Node::Expr(parent_expr)) = opt_parent_node;
-        if is_questionmark_desugar_marked_call(parent_expr);
-        then {
-            return;
-        }
+    if let Some(hir::Node::Expr(parent_expr)) = opt_parent_node
+        && is_questionmark_desugar_marked_call(parent_expr)
+    {
+        return;
     }
 
     let args: Vec<_> = match expr.kind {
@@ -80,21 +78,19 @@ fn lint_unit_args(cx: &LateContext<'_>, expr: &Expr<'_>, args_to_recover: &[&Exp
             args_to_recover
                 .iter()
                 .filter_map(|arg| {
-                    if_chain! {
-                        if let ExprKind::Block(block, _) = arg.kind;
-                        if block.expr.is_none();
-                        if let Some(last_stmt) = block.stmts.iter().last();
-                        if let StmtKind::Semi(last_expr) = last_stmt.kind;
-                        if let Some(snip) = snippet_opt(cx, last_expr.span);
-                        then {
-                            Some((
-                                last_stmt.span,
-                                snip,
-                            ))
-                        }
-                        else {
-                            None
-                        }
+                    if let ExprKind::Block(block, _) = arg.kind
+                        && block.expr.is_none()
+                        && let Some(last_stmt) = block.stmts.iter().last()
+                        && let StmtKind::Semi(last_expr) = last_stmt.kind
+                        && let Some(snip) = snippet_opt(cx, last_expr.span)
+                    {
+                        Some((
+                            last_stmt.span,
+                            snip,
+                        ))
+                    }
+                    else {
+                        None
                     }
                 })
                 .for_each(|(span, sugg)| {
diff --git a/clippy_lints/src/unnamed_address.rs b/clippy_lints/src/unnamed_address.rs
index e7355f92304..bc217ac2906 100644
--- a/clippy_lints/src/unnamed_address.rs
+++ b/clippy_lints/src/unnamed_address.rs
@@ -76,55 +76,49 @@ impl LateLintPass<'_> for UnnamedAddress {
             matches!(cx.typeck_results().expr_ty(expr).kind(), ty::FnDef(..))
         }
 
-        if_chain! {
-            if let ExprKind::Binary(binop, left, right) = expr.kind;
-            if is_comparison(binop.node);
-            if is_trait_ptr(cx, left) && is_trait_ptr(cx, right);
-            then {
-                span_lint_and_help(
-                    cx,
-                    VTABLE_ADDRESS_COMPARISONS,
-                    expr.span,
-                    "comparing trait object pointers compares a non-unique vtable address",
-                    None,
-                    "consider extracting and comparing data pointers only",
-                );
-            }
+        if let ExprKind::Binary(binop, left, right) = expr.kind
+            && is_comparison(binop.node)
+            && is_trait_ptr(cx, left) && is_trait_ptr(cx, right)
+        {
+            span_lint_and_help(
+                cx,
+                VTABLE_ADDRESS_COMPARISONS,
+                expr.span,
+                "comparing trait object pointers compares a non-unique vtable address",
+                None,
+                "consider extracting and comparing data pointers only",
+            );
         }
 
-        if_chain! {
-            if let ExprKind::Call(func, [ref _left, ref _right]) = expr.kind;
-            if let ExprKind::Path(ref func_qpath) = func.kind;
-            if let Some(def_id) = cx.qpath_res(func_qpath, func.hir_id).opt_def_id();
-            if cx.tcx.is_diagnostic_item(sym::ptr_eq, def_id);
-            let ty_param = cx.typeck_results().node_args(func.hir_id).type_at(0);
-            if ty_param.is_trait();
-            then {
-                span_lint_and_help(
-                    cx,
-                    VTABLE_ADDRESS_COMPARISONS,
-                    expr.span,
-                    "comparing trait object pointers compares a non-unique vtable address",
-                    None,
-                    "consider extracting and comparing data pointers only",
-                );
-            }
+        if let ExprKind::Call(func, [ref _left, ref _right]) = expr.kind
+            && let ExprKind::Path(ref func_qpath) = func.kind
+            && let Some(def_id) = cx.qpath_res(func_qpath, func.hir_id).opt_def_id()
+            && cx.tcx.is_diagnostic_item(sym::ptr_eq, def_id)
+            && let ty_param = cx.typeck_results().node_args(func.hir_id).type_at(0)
+            && ty_param.is_trait()
+        {
+            span_lint_and_help(
+                cx,
+                VTABLE_ADDRESS_COMPARISONS,
+                expr.span,
+                "comparing trait object pointers compares a non-unique vtable address",
+                None,
+                "consider extracting and comparing data pointers only",
+            );
         }
 
-        if_chain! {
-            if let ExprKind::Binary(binop, left, right) = expr.kind;
-            if is_comparison(binop.node);
-            if cx.typeck_results().expr_ty_adjusted(left).is_fn_ptr();
-            if cx.typeck_results().expr_ty_adjusted(right).is_fn_ptr();
-            if is_fn_def(cx, left) || is_fn_def(cx, right);
-            then {
-                span_lint(
-                    cx,
-                    FN_ADDRESS_COMPARISONS,
-                    expr.span,
-                    "comparing with a non-unique address of a function item",
-                );
-            }
+        if let ExprKind::Binary(binop, left, right) = expr.kind
+            && is_comparison(binop.node)
+            && cx.typeck_results().expr_ty_adjusted(left).is_fn_ptr()
+            && cx.typeck_results().expr_ty_adjusted(right).is_fn_ptr()
+            && (is_fn_def(cx, left) || is_fn_def(cx, right))
+        {
+            span_lint(
+                cx,
+                FN_ADDRESS_COMPARISONS,
+                expr.span,
+                "comparing with a non-unique address of a function item",
+            );
         }
     }
 }
diff --git a/clippy_lints/src/unnecessary_owned_empty_strings.rs b/clippy_lints/src/unnecessary_owned_empty_strings.rs
index 28ea02e4d9a..70c276fe1ce 100644
--- a/clippy_lints/src/unnecessary_owned_empty_strings.rs
+++ b/clippy_lints/src/unnecessary_owned_empty_strings.rs
@@ -36,45 +36,41 @@ declare_lint_pass!(UnnecessaryOwnedEmptyStrings => [UNNECESSARY_OWNED_EMPTY_STRI
 
 impl<'tcx> LateLintPass<'tcx> for UnnecessaryOwnedEmptyStrings {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
-        if_chain! {
-            if let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Not, inner_expr) = expr.kind;
-            if let ExprKind::Call(fun, args) = inner_expr.kind;
-            if let ExprKind::Path(ref qpath) = fun.kind;
-            if let Some(fun_def_id) = cx.qpath_res(qpath, fun.hir_id).opt_def_id();
-            if let ty::Ref(_, inner_str, _) = cx.typeck_results().expr_ty_adjusted(expr).kind();
-            if inner_str.is_str();
-            then {
-                if match_def_path(cx, fun_def_id, &paths::STRING_NEW) {
-                     span_lint_and_sugg(
-                            cx,
-                            UNNECESSARY_OWNED_EMPTY_STRINGS,
-                            expr.span,
-                            "usage of `&String::new()` for a function expecting a `&str` argument",
-                            "try",
-                            "\"\"".to_owned(),
-                            Applicability::MachineApplicable,
-                        );
-                } else {
-                    if_chain! {
-                        if cx.tcx.is_diagnostic_item(sym::from_fn, fun_def_id);
-                        if let [.., last_arg] = args;
-                        if let ExprKind::Lit(spanned) = &last_arg.kind;
-                        if let LitKind::Str(symbol, _) = spanned.node;
-                        if symbol.is_empty();
-                        let inner_expr_type = cx.typeck_results().expr_ty(inner_expr);
-                        if is_type_lang_item(cx, inner_expr_type, LangItem::String);
-                        then {
-                            span_lint_and_sugg(
-                                cx,
-                                UNNECESSARY_OWNED_EMPTY_STRINGS,
-                                expr.span,
-                                "usage of `&String::from(\"\")` for a function expecting a `&str` argument",
-                                "try",
-                                "\"\"".to_owned(),
-                                Applicability::MachineApplicable,
-                            );
-                        }
-                    }
+        if let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Not, inner_expr) = expr.kind
+            && let ExprKind::Call(fun, args) = inner_expr.kind
+            && let ExprKind::Path(ref qpath) = fun.kind
+            && let Some(fun_def_id) = cx.qpath_res(qpath, fun.hir_id).opt_def_id()
+            && let ty::Ref(_, inner_str, _) = cx.typeck_results().expr_ty_adjusted(expr).kind()
+            && inner_str.is_str()
+        {
+            if match_def_path(cx, fun_def_id, &paths::STRING_NEW) {
+                 span_lint_and_sugg(
+                        cx,
+                        UNNECESSARY_OWNED_EMPTY_STRINGS,
+                        expr.span,
+                        "usage of `&String::new()` for a function expecting a `&str` argument",
+                        "try",
+                        "\"\"".to_owned(),
+                        Applicability::MachineApplicable,
+                    );
+            } else {
+                if cx.tcx.is_diagnostic_item(sym::from_fn, fun_def_id)
+                    && let [.., last_arg] = args
+                    && let ExprKind::Lit(spanned) = &last_arg.kind
+                    && let LitKind::Str(symbol, _) = spanned.node
+                    && symbol.is_empty()
+                    && let inner_expr_type = cx.typeck_results().expr_ty(inner_expr)
+                    && is_type_lang_item(cx, inner_expr_type, LangItem::String)
+                {
+                    span_lint_and_sugg(
+                        cx,
+                        UNNECESSARY_OWNED_EMPTY_STRINGS,
+                        expr.span,
+                        "usage of `&String::from(\"\")` for a function expecting a `&str` argument",
+                        "try",
+                        "\"\"".to_owned(),
+                        Applicability::MachineApplicable,
+                    );
                 }
             }
         }
diff --git a/clippy_lints/src/unnecessary_self_imports.rs b/clippy_lints/src/unnecessary_self_imports.rs
index a1083a0a68e..338a4daf6c1 100644
--- a/clippy_lints/src/unnecessary_self_imports.rs
+++ b/clippy_lints/src/unnecessary_self_imports.rs
@@ -36,35 +36,33 @@ declare_lint_pass!(UnnecessarySelfImports => [UNNECESSARY_SELF_IMPORTS]);
 
 impl EarlyLintPass for UnnecessarySelfImports {
     fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {
-        if_chain! {
-            if let ItemKind::Use(use_tree) = &item.kind;
-            if let UseTreeKind::Nested(nodes) = &use_tree.kind;
-            if let [(self_tree, _)] = &**nodes;
-            if let [self_seg] = &*self_tree.prefix.segments;
-            if self_seg.ident.name == kw::SelfLower;
-            if let Some(last_segment) = use_tree.prefix.segments.last();
+        if let ItemKind::Use(use_tree) = &item.kind
+            && let UseTreeKind::Nested(nodes) = &use_tree.kind
+            && let [(self_tree, _)] = &**nodes
+            && let [self_seg] = &*self_tree.prefix.segments
+            && self_seg.ident.name == kw::SelfLower
+            && let Some(last_segment) = use_tree.prefix.segments.last()
 
-            then {
-                span_lint_and_then(
-                    cx,
-                    UNNECESSARY_SELF_IMPORTS,
-                    item.span,
-                    "import ending with `::{self}`",
-                    |diag| {
-                        diag.span_suggestion(
-                            last_segment.span().with_hi(item.span.hi()),
-                            "consider omitting `::{self}`",
-                            format!(
-                                "{}{};",
-                                last_segment.ident,
-                                if let UseTreeKind::Simple(Some(alias)) = self_tree.kind { format!(" as {alias}") } else { String::new() },
-                            ),
-                            Applicability::MaybeIncorrect,
-                        );
-                        diag.note("this will slightly change semantics; any non-module items at the same path will also be imported");
-                    },
-                );
-            }
+        {
+            span_lint_and_then(
+                cx,
+                UNNECESSARY_SELF_IMPORTS,
+                item.span,
+                "import ending with `::{self}`",
+                |diag| {
+                    diag.span_suggestion(
+                        last_segment.span().with_hi(item.span.hi()),
+                        "consider omitting `::{self}`",
+                        format!(
+                            "{}{};",
+                            last_segment.ident,
+                            if let UseTreeKind::Simple(Some(alias)) = self_tree.kind { format!(" as {alias}") } else { String::new() },
+                        ),
+                        Applicability::MaybeIncorrect,
+                    );
+                    diag.note("this will slightly change semantics; any non-module items at the same path will also be imported");
+                },
+            );
         }
     }
 }
diff --git a/clippy_lints/src/unnecessary_wraps.rs b/clippy_lints/src/unnecessary_wraps.rs
index ab8de17b091..8b1d9d4a739 100644
--- a/clippy_lints/src/unnecessary_wraps.rs
+++ b/clippy_lints/src/unnecessary_wraps.rs
@@ -119,28 +119,26 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryWraps {
         // Check if all return expression respect the following condition and collect them.
         let mut suggs = Vec::new();
         let can_sugg = find_all_ret_expressions(cx, body.value, |ret_expr| {
-            if_chain! {
-                if !ret_expr.span.from_expansion();
+            if !ret_expr.span.from_expansion()
                 // Check if a function call.
-                if let ExprKind::Call(func, [arg]) = ret_expr.kind;
-                if is_res_lang_ctor(cx, path_res(cx, func), lang_item);
+                && let ExprKind::Call(func, [arg]) = ret_expr.kind
+                && is_res_lang_ctor(cx, path_res(cx, func), lang_item)
                 // Make sure the function argument does not contain a return expression.
-                if !contains_return(arg);
-                then {
-                    suggs.push(
-                        (
-                            ret_expr.span,
-                            if inner_type.is_unit() {
-                                String::new()
-                            } else {
-                                snippet(cx, arg.span.source_callsite(), "..").to_string()
-                            }
-                        )
-                    );
-                    true
-                } else {
-                    false
-                }
+                && !contains_return(arg)
+            {
+                suggs.push(
+                    (
+                        ret_expr.span,
+                        if inner_type.is_unit() {
+                            String::new()
+                        } else {
+                            snippet(cx, arg.span.source_callsite(), "..").to_string()
+                        }
+                    )
+                );
+                true
+            } else {
+                false
             }
         });
 
diff --git a/clippy_lints/src/unused_self.rs b/clippy_lints/src/unused_self.rs
index f864c520302..1ecce18c9ae 100644
--- a/clippy_lints/src/unused_self.rs
+++ b/clippy_lints/src/unused_self.rs
@@ -73,25 +73,23 @@ impl<'tcx> LateLintPass<'tcx> for UnusedSelf {
             })
             .is_some()
         };
-        if_chain! {
-            if let ItemKind::Impl(Impl { of_trait: None, .. }) = parent_item.kind;
-            if assoc_item.fn_has_self_parameter;
-            if let ImplItemKind::Fn(.., body_id) = &impl_item.kind;
-            if !cx.effective_visibilities.is_exported(impl_item.owner_id.def_id) || !self.avoid_breaking_exported_api;
-            let body = cx.tcx.hir().body(*body_id);
-            if let [self_param, ..] = body.params;
-            if !is_local_used(cx, body, self_param.pat.hir_id);
-            if !contains_todo(cx, body);
-            then {
-                span_lint_and_help(
-                    cx,
-                    UNUSED_SELF,
-                    self_param.span,
-                    "unused `self` argument",
-                    None,
-                    "consider refactoring to an associated function",
-                );
-            }
+        if let ItemKind::Impl(Impl { of_trait: None, .. }) = parent_item.kind
+            && assoc_item.fn_has_self_parameter
+            && let ImplItemKind::Fn(.., body_id) = &impl_item.kind
+            && (!cx.effective_visibilities.is_exported(impl_item.owner_id.def_id) || !self.avoid_breaking_exported_api)
+            && let body = cx.tcx.hir().body(*body_id)
+            && let [self_param, ..] = body.params
+            && !is_local_used(cx, body, self_param.pat.hir_id)
+            && !contains_todo(cx, body)
+        {
+            span_lint_and_help(
+                cx,
+                UNUSED_SELF,
+                self_param.span,
+                "unused `self` argument",
+                None,
+                "consider refactoring to an associated function",
+            );
         }
     }
 }
diff --git a/clippy_lints/src/unused_unit.rs b/clippy_lints/src/unused_unit.rs
index ae844673b15..7ceb6df9c44 100644
--- a/clippy_lints/src/unused_unit.rs
+++ b/clippy_lints/src/unused_unit.rs
@@ -38,40 +38,36 @@ declare_lint_pass!(UnusedUnit => [UNUSED_UNIT]);
 
 impl EarlyLintPass for UnusedUnit {
     fn check_fn(&mut self, cx: &EarlyContext<'_>, kind: FnKind<'_>, span: Span, _: ast::NodeId) {
-        if_chain! {
-            if let ast::FnRetTy::Ty(ref ty) = kind.decl().output;
-            if let ast::TyKind::Tup(ref vals) = ty.kind;
-            if vals.is_empty() && !ty.span.from_expansion() && get_def(span) == get_def(ty.span);
-            then {
-                // implicit types in closure signatures are forbidden when `for<...>` is present
-                if let FnKind::Closure(&ClosureBinder::For { .. }, ..) = kind {
-                    return;
-                }
-
-                lint_unneeded_unit_return(cx, ty, span);
+        if let ast::FnRetTy::Ty(ref ty) = kind.decl().output
+            && let ast::TyKind::Tup(ref vals) = ty.kind
+            && vals.is_empty() && !ty.span.from_expansion() && get_def(span) == get_def(ty.span)
+        {
+            // implicit types in closure signatures are forbidden when `for<...>` is present
+            if let FnKind::Closure(&ClosureBinder::For { .. }, ..) = kind {
+                return;
             }
+
+            lint_unneeded_unit_return(cx, ty, span);
         }
     }
 
     fn check_block(&mut self, cx: &EarlyContext<'_>, block: &ast::Block) {
-        if_chain! {
-            if let Some(stmt) = block.stmts.last();
-            if let ast::StmtKind::Expr(ref expr) = stmt.kind;
-            if is_unit_expr(expr);
-            let ctxt = block.span.ctxt();
-            if stmt.span.ctxt() == ctxt && expr.span.ctxt() == ctxt;
-            then {
-                let sp = expr.span;
-                span_lint_and_sugg(
-                    cx,
-                    UNUSED_UNIT,
-                    sp,
-                    "unneeded unit expression",
-                    "remove the final `()`",
-                    String::new(),
-                    Applicability::MachineApplicable,
-                );
-            }
+        if let Some(stmt) = block.stmts.last()
+            && let ast::StmtKind::Expr(ref expr) = stmt.kind
+            && is_unit_expr(expr)
+            && let ctxt = block.span.ctxt()
+            && stmt.span.ctxt() == ctxt && expr.span.ctxt() == ctxt
+        {
+            let sp = expr.span;
+            span_lint_and_sugg(
+                cx,
+                UNUSED_UNIT,
+                sp,
+                "unneeded unit expression",
+                "remove the final `()`",
+                String::new(),
+                Applicability::MachineApplicable,
+            );
         }
     }
 
@@ -97,16 +93,14 @@ impl EarlyLintPass for UnusedUnit {
     fn check_poly_trait_ref(&mut self, cx: &EarlyContext<'_>, poly: &ast::PolyTraitRef) {
         let segments = &poly.trait_ref.path.segments;
 
-        if_chain! {
-            if segments.len() == 1;
-            if ["Fn", "FnMut", "FnOnce"].contains(&segments[0].ident.name.as_str());
-            if let Some(args) = &segments[0].args;
-            if let ast::GenericArgs::Parenthesized(generic_args) = &**args;
-            if let ast::FnRetTy::Ty(ty) = &generic_args.output;
-            if ty.kind.is_unit();
-            then {
-                lint_unneeded_unit_return(cx, ty, generic_args.span);
-            }
+        if segments.len() == 1
+            && ["Fn", "FnMut", "FnOnce"].contains(&segments[0].ident.name.as_str())
+            && let Some(args) = &segments[0].args
+            && let ast::GenericArgs::Parenthesized(generic_args) = &**args
+            && let ast::FnRetTy::Ty(ty) = &generic_args.output
+            && ty.kind.is_unit()
+        {
+            lint_unneeded_unit_return(cx, ty, generic_args.span);
         }
     }
 }
diff --git a/clippy_lints/src/unwrap.rs b/clippy_lints/src/unwrap.rs
index e52cfb29fe5..8b7429d8e38 100644
--- a/clippy_lints/src/unwrap.rs
+++ b/clippy_lints/src/unwrap.rs
@@ -157,39 +157,37 @@ fn collect_unwrap_info<'tcx>(
     } else if let ExprKind::Unary(UnOp::Not, expr) = &expr.kind {
         return collect_unwrap_info(cx, if_expr, expr, branch, !invert, false);
     } else {
-        if_chain! {
-            if let ExprKind::MethodCall(method_name, receiver, args, _) = &expr.kind;
-            if let Some(local_id) = path_to_local(receiver);
-            let ty = cx.typeck_results().expr_ty(receiver);
-            let name = method_name.ident.as_str();
-            if is_relevant_option_call(cx, ty, name) || is_relevant_result_call(cx, ty, name);
-            then {
-                assert!(args.is_empty());
-                let unwrappable = match name {
-                    "is_some" | "is_ok" => true,
-                    "is_err" | "is_none" => false,
-                    _ => unreachable!(),
-                };
-                let safe_to_unwrap = unwrappable != invert;
-                let kind = if is_type_diagnostic_item(cx, ty, sym::Option) {
-                    UnwrappableKind::Option
-                } else {
-                    UnwrappableKind::Result
-                };
+        if let ExprKind::MethodCall(method_name, receiver, args, _) = &expr.kind
+            && let Some(local_id) = path_to_local(receiver)
+            && let ty = cx.typeck_results().expr_ty(receiver)
+            && let name = method_name.ident.as_str()
+            && (is_relevant_option_call(cx, ty, name) || is_relevant_result_call(cx, ty, name))
+        {
+            assert!(args.is_empty());
+            let unwrappable = match name {
+                "is_some" | "is_ok" => true,
+                "is_err" | "is_none" => false,
+                _ => unreachable!(),
+            };
+            let safe_to_unwrap = unwrappable != invert;
+            let kind = if is_type_diagnostic_item(cx, ty, sym::Option) {
+                UnwrappableKind::Option
+            } else {
+                UnwrappableKind::Result
+            };
 
-                return vec![
-                    UnwrapInfo {
-                        local_id,
-                        if_expr,
-                        check: expr,
-                        check_name: method_name,
-                        branch,
-                        safe_to_unwrap,
-                        kind,
-                        is_entire_condition,
-                    }
-                ]
-            }
+            return vec![
+                UnwrapInfo {
+                    local_id,
+                    if_expr,
+                    check: expr,
+                    check_name: method_name,
+                    branch,
+                    safe_to_unwrap,
+                    kind,
+                    is_entire_condition,
+                }
+            ]
         }
     }
     Vec::new()
@@ -320,73 +318,71 @@ impl<'a, 'tcx> Visitor<'tcx> for UnwrappableVariablesVisitor<'a, 'tcx> {
             }
         } else {
             // find `unwrap[_err]()` calls:
-            if_chain! {
-                if let ExprKind::MethodCall(method_name, self_arg, ..) = expr.kind;
-                let (self_arg, as_ref_kind) = consume_option_as_ref(self_arg);
-                if let Some(id) = path_to_local(self_arg);
-                if [sym::unwrap, sym::expect, sym!(unwrap_err)].contains(&method_name.ident.name);
-                let call_to_unwrap = [sym::unwrap, sym::expect].contains(&method_name.ident.name);
-                if let Some(unwrappable) = self.unwrappables.iter()
-                    .find(|u| u.local_id == id);
+            if let ExprKind::MethodCall(method_name, self_arg, ..) = expr.kind
+                && let (self_arg, as_ref_kind) = consume_option_as_ref(self_arg)
+                && let Some(id) = path_to_local(self_arg)
+                && [sym::unwrap, sym::expect, sym!(unwrap_err)].contains(&method_name.ident.name)
+                && let call_to_unwrap = [sym::unwrap, sym::expect].contains(&method_name.ident.name)
+                && let Some(unwrappable) = self.unwrappables.iter()
+                    .find(|u| u.local_id == id)
                 // Span contexts should not differ with the conditional branch
-                let span_ctxt = expr.span.ctxt();
-                if unwrappable.branch.span.ctxt() == span_ctxt;
-                if unwrappable.check.span.ctxt() == span_ctxt;
-                then {
-                    if call_to_unwrap == unwrappable.safe_to_unwrap {
-                        let is_entire_condition = unwrappable.is_entire_condition;
-                        let unwrappable_variable_name = self.cx.tcx.hir().name(unwrappable.local_id);
-                        let suggested_pattern = if call_to_unwrap {
-                            unwrappable.kind.success_variant_pattern()
-                        } else {
-                            unwrappable.kind.error_variant_pattern()
-                        };
-
-                        span_lint_hir_and_then(
-                            self.cx,
-                            UNNECESSARY_UNWRAP,
-                            expr.hir_id,
-                            expr.span,
-                            &format!(
-                                "called `{}` on `{unwrappable_variable_name}` after checking its variant with `{}`",
-                                method_name.ident.name,
-                                unwrappable.check_name.ident.as_str(),
-                            ),
-                            |diag| {
-                                if is_entire_condition {
-                                    diag.span_suggestion(
-                                        unwrappable.check.span.with_lo(unwrappable.if_expr.span.lo()),
-                                        "try",
-                                        format!(
-                                            "if let {suggested_pattern} = {borrow_prefix}{unwrappable_variable_name}",
-                                            borrow_prefix = match as_ref_kind {
-                                                Some(AsRefKind::AsRef) => "&",
-                                                Some(AsRefKind::AsMut) => "&mut ",
-                                                None => "",
-                                            },
-                                        ),
-                                        // We don't track how the unwrapped value is used inside the
-                                        // block or suggest deleting the unwrap, so we can't offer a
-                                        // fixable solution.
-                                        Applicability::Unspecified,
-                                    );
-                                } else {
-                                    diag.span_label(unwrappable.check.span, "the check is happening here");
-                                    diag.help("try using `if let` or `match`");
-                                }
-                            },
-                        );
+                && let span_ctxt = expr.span.ctxt()
+                && unwrappable.branch.span.ctxt() == span_ctxt
+                && unwrappable.check.span.ctxt() == span_ctxt
+            {
+                if call_to_unwrap == unwrappable.safe_to_unwrap {
+                    let is_entire_condition = unwrappable.is_entire_condition;
+                    let unwrappable_variable_name = self.cx.tcx.hir().name(unwrappable.local_id);
+                    let suggested_pattern = if call_to_unwrap {
+                        unwrappable.kind.success_variant_pattern()
                     } else {
-                        span_lint_hir_and_then(
-                            self.cx,
-                            PANICKING_UNWRAP,
-                            expr.hir_id,
-                            expr.span,
-                            &format!("this call to `{}()` will always panic",
-                            method_name.ident.name),
-                            |diag| { diag.span_label(unwrappable.check.span, "because of this check"); },
-                        );
-                    }
+                        unwrappable.kind.error_variant_pattern()
+                    };
+
+                    span_lint_hir_and_then(
+                        self.cx,
+                        UNNECESSARY_UNWRAP,
+                        expr.hir_id,
+                        expr.span,
+                        &format!(
+                            "called `{}` on `{unwrappable_variable_name}` after checking its variant with `{}`",
+                            method_name.ident.name,
+                            unwrappable.check_name.ident.as_str(),
+                        ),
+                        |diag| {
+                            if is_entire_condition {
+                                diag.span_suggestion(
+                                    unwrappable.check.span.with_lo(unwrappable.if_expr.span.lo()),
+                                    "try",
+                                    format!(
+                                        "if let {suggested_pattern} = {borrow_prefix}{unwrappable_variable_name}",
+                                        borrow_prefix = match as_ref_kind {
+                                            Some(AsRefKind::AsRef) => "&",
+                                            Some(AsRefKind::AsMut) => "&mut ",
+                                            None => "",
+                                        },
+                                    ),
+                                    // We don't track how the unwrapped value is used inside the
+                                    // block or suggest deleting the unwrap, so we can't offer a
+                                    // fixable solution.
+                                    Applicability::Unspecified,
+                                );
+                            } else {
+                                diag.span_label(unwrappable.check.span, "the check is happening here");
+                                diag.help("try using `if let` or `match`");
+                            }
+                        },
+                    );
+                } else {
+                    span_lint_hir_and_then(
+                        self.cx,
+                        PANICKING_UNWRAP,
+                        expr.hir_id,
+                        expr.span,
+                        &format!("this call to `{}()` will always panic",
+                        method_name.ident.name),
+                        |diag| { diag.span_label(unwrappable.check.span, "because of this check"); },
+                    );
                 }
             }
             walk_expr(self, expr);
diff --git a/clippy_lints/src/unwrap_in_result.rs b/clippy_lints/src/unwrap_in_result.rs
index 21592abbf16..a3977f1b6c8 100644
--- a/clippy_lints/src/unwrap_in_result.rs
+++ b/clippy_lints/src/unwrap_in_result.rs
@@ -60,15 +60,13 @@ declare_lint_pass!(UnwrapInResult=> [UNWRAP_IN_RESULT]);
 
 impl<'tcx> LateLintPass<'tcx> for UnwrapInResult {
     fn check_impl_item(&mut self, cx: &LateContext<'tcx>, impl_item: &'tcx hir::ImplItem<'_>) {
-        if_chain! {
+        if let hir::ImplItemKind::Fn(ref _signature, _) = impl_item.kind
             // first check if it's a method or function
-            if let hir::ImplItemKind::Fn(ref _signature, _) = impl_item.kind;
             // checking if its return type is `result` or `option`
-            if is_type_diagnostic_item(cx, return_ty(cx, impl_item.owner_id), sym::Result)
-                || is_type_diagnostic_item(cx, return_ty(cx, impl_item.owner_id), sym::Option);
-            then {
-                lint_impl_body(cx, impl_item.span, impl_item);
-            }
+            && (is_type_diagnostic_item(cx, return_ty(cx, impl_item.owner_id), sym::Result)
+                || is_type_diagnostic_item(cx, return_ty(cx, impl_item.owner_id), sym::Option))
+        {
+            lint_impl_body(cx, impl_item.span, impl_item);
         }
     }
 }
diff --git a/clippy_lints/src/use_self.rs b/clippy_lints/src/use_self.rs
index c3fe16ad5c3..4bfd4d22c70 100644
--- a/clippy_lints/src/use_self.rs
+++ b/clippy_lints/src/use_self.rs
@@ -93,32 +93,30 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
         // relevant for linting, since this is the self type of the `impl` we're currently in. To
         // avoid linting on nested items, we push `StackItem::NoCheck` on the stack to signal, that
         // we're in an `impl` or nested item, that we don't want to lint
-        let stack_item = if_chain! {
-            if let ItemKind::Impl(Impl { self_ty, generics,.. }) = item.kind;
-            if let TyKind::Path(QPath::Resolved(_, item_path)) = self_ty.kind;
-            let parameters = &item_path.segments.last().expect(SEGMENTS_MSG).args;
-            if parameters.as_ref().map_or(true, |params| {
+        let stack_item = if let ItemKind::Impl(Impl { self_ty, generics,.. }) = item.kind
+            && let TyKind::Path(QPath::Resolved(_, item_path)) = self_ty.kind
+            && let parameters = &item_path.segments.last().expect(SEGMENTS_MSG).args
+            && parameters.as_ref().map_or(true, |params| {
                 params.parenthesized  == GenericArgsParentheses::No
                     && !params.args.iter().any(|arg| matches!(arg, GenericArg::Lifetime(_)))
-            });
-            if !item.span.from_expansion();
-            if !is_from_proc_macro(cx, item); // expensive, should be last check
-            then {
-                // Self cannot be used inside const generic parameters
-                let types_to_skip = generics.params.iter().filter_map(|param| {
-                    match param {
-                        GenericParam { kind: GenericParamKind::Const { ty: Ty { hir_id, ..}, ..}, ..} => Some(*hir_id),
-                        _ => None,
-                    }
-                }).chain(std::iter::once(self_ty.hir_id)).collect();
-                StackItem::Check {
-                    impl_id: item.owner_id.def_id,
-                    in_body: 0,
-                    types_to_skip,
+            })
+            && !item.span.from_expansion()
+            && !is_from_proc_macro(cx, item) // expensive, should be last check
+        {
+            // Self cannot be used inside const generic parameters
+            let types_to_skip = generics.params.iter().filter_map(|param| {
+                match param {
+                    GenericParam { kind: GenericParamKind::Const { ty: Ty { hir_id, ..}, ..}, ..} => Some(*hir_id),
+                    _ => None,
                 }
-            } else {
-                StackItem::NoCheck
+            }).chain(std::iter::once(self_ty.hir_id)).collect();
+            StackItem::Check {
+                impl_id: item.owner_id.def_id,
+                in_body: 0,
+                types_to_skip,
             }
+        } else {
+            StackItem::NoCheck
         };
         self.stack.push(stack_item);
     }
@@ -132,56 +130,54 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
     fn check_impl_item(&mut self, cx: &LateContext<'_>, impl_item: &hir::ImplItem<'_>) {
         // We want to skip types in trait `impl`s that aren't declared as `Self` in the trait
         // declaration. The collection of those types is all this method implementation does.
-        if_chain! {
-            if let ImplItemKind::Fn(FnSig { decl, .. }, ..) = impl_item.kind;
-            if let Some(&mut StackItem::Check {
+        if let ImplItemKind::Fn(FnSig { decl, .. }, ..) = impl_item.kind
+            && let Some(&mut StackItem::Check {
                 impl_id,
                 ref mut types_to_skip,
                 ..
-            }) = self.stack.last_mut();
-            if let Some(impl_trait_ref) = cx.tcx.impl_trait_ref(impl_id);
-            then {
-                // `self_ty` is the semantic self type of `impl <trait> for <type>`. This cannot be
-                // `Self`.
-                let self_ty = impl_trait_ref.instantiate_identity().self_ty();
+            }) = self.stack.last_mut()
+            && let Some(impl_trait_ref) = cx.tcx.impl_trait_ref(impl_id)
+        {
+            // `self_ty` is the semantic self type of `impl <trait> for <type>`. This cannot be
+            // `Self`.
+            let self_ty = impl_trait_ref.instantiate_identity().self_ty();
 
-                // `trait_method_sig` is the signature of the function, how it is declared in the
-                // trait, not in the impl of the trait.
-                let trait_method = cx
-                    .tcx
-                    .associated_item(impl_item.owner_id)
-                    .trait_item_def_id
-                    .expect("impl method matches a trait method");
-                let trait_method_sig = cx.tcx.fn_sig(trait_method).instantiate_identity();
-                let trait_method_sig = cx.tcx.erase_late_bound_regions(trait_method_sig);
+            // `trait_method_sig` is the signature of the function, how it is declared in the
+            // trait, not in the impl of the trait.
+            let trait_method = cx
+                .tcx
+                .associated_item(impl_item.owner_id)
+                .trait_item_def_id
+                .expect("impl method matches a trait method");
+            let trait_method_sig = cx.tcx.fn_sig(trait_method).instantiate_identity();
+            let trait_method_sig = cx.tcx.erase_late_bound_regions(trait_method_sig);
 
-                // `impl_inputs_outputs` is an iterator over the types (`hir::Ty`) declared in the
-                // implementation of the trait.
-                let output_hir_ty = if let FnRetTy::Return(ty) = &decl.output {
-                    Some(&**ty)
-                } else {
-                    None
-                };
-                let impl_inputs_outputs = decl.inputs.iter().chain(output_hir_ty);
+            // `impl_inputs_outputs` is an iterator over the types (`hir::Ty`) declared in the
+            // implementation of the trait.
+            let output_hir_ty = if let FnRetTy::Return(ty) = &decl.output {
+                Some(&**ty)
+            } else {
+                None
+            };
+            let impl_inputs_outputs = decl.inputs.iter().chain(output_hir_ty);
 
-                // `impl_hir_ty` (of type `hir::Ty`) represents the type written in the signature.
-                //
-                // `trait_sem_ty` (of type `ty::Ty`) is the semantic type for the signature in the
-                // trait declaration. This is used to check if `Self` was used in the trait
-                // declaration.
-                //
-                // If `any`where in the `trait_sem_ty` the `self_ty` was used verbatim (as opposed
-                // to `Self`), we want to skip linting that type and all subtypes of it. This
-                // avoids suggestions to e.g. replace `Vec<u8>` with `Vec<Self>`, in an `impl Trait
-                // for u8`, when the trait always uses `Vec<u8>`.
-                //
-                // See also https://github.com/rust-lang/rust-clippy/issues/2894.
-                for (impl_hir_ty, trait_sem_ty) in impl_inputs_outputs.zip(trait_method_sig.inputs_and_output) {
-                    if trait_sem_ty.walk().any(|inner| inner == self_ty.into()) {
-                        let mut visitor = SkipTyCollector::default();
-                        visitor.visit_ty(impl_hir_ty);
-                        types_to_skip.extend(visitor.types_to_skip);
-                    }
+            // `impl_hir_ty` (of type `hir::Ty`) represents the type written in the signature.
+            //
+            // `trait_sem_ty` (of type `ty::Ty`) is the semantic type for the signature in the
+            // trait declaration. This is used to check if `Self` was used in the trait
+            // declaration.
+            //
+            // If `any`where in the `trait_sem_ty` the `self_ty` was used verbatim (as opposed
+            // to `Self`), we want to skip linting that type and all subtypes of it. This
+            // avoids suggestions to e.g. replace `Vec<u8>` with `Vec<Self>`, in an `impl Trait
+            // for u8`, when the trait always uses `Vec<u8>`.
+            //
+            // See also https://github.com/rust-lang/rust-clippy/issues/2894.
+            for (impl_hir_ty, trait_sem_ty) in impl_inputs_outputs.zip(trait_method_sig.inputs_and_output) {
+                if trait_sem_ty.walk().any(|inner| inner == self_ty.into()) {
+                    let mut visitor = SkipTyCollector::default();
+                    visitor.visit_ty(impl_hir_ty);
+                    types_to_skip.extend(visitor.types_to_skip);
                 }
             }
         }
@@ -203,42 +199,38 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
     }
 
     fn check_ty(&mut self, cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>) {
-        if_chain! {
-            if !hir_ty.span.from_expansion();
-            if self.msrv.meets(msrvs::TYPE_ALIAS_ENUM_VARIANTS);
-            if let Some(&StackItem::Check {
+        if !hir_ty.span.from_expansion()
+            && self.msrv.meets(msrvs::TYPE_ALIAS_ENUM_VARIANTS)
+            && let Some(&StackItem::Check {
                 impl_id,
                 in_body,
                 ref types_to_skip,
-            }) = self.stack.last();
-            if let TyKind::Path(QPath::Resolved(_, path)) = hir_ty.kind;
-            if !matches!(
+            }) = self.stack.last()
+            && let TyKind::Path(QPath::Resolved(_, path)) = hir_ty.kind
+            && !matches!(
                 path.res,
                 Res::SelfTyParam { .. }
                 | Res::SelfTyAlias { .. }
                 | Res::Def(DefKind::TyParam, _)
-            );
-            if !types_to_skip.contains(&hir_ty.hir_id);
-            let ty = if in_body > 0 {
+            )
+            && !types_to_skip.contains(&hir_ty.hir_id)
+            && let ty = if in_body > 0 {
                 cx.typeck_results().node_type(hir_ty.hir_id)
             } else {
                 hir_ty_to_ty(cx.tcx, hir_ty)
-            };
-            if same_type_and_consts(ty, cx.tcx.type_of(impl_id).instantiate_identity());
-            then {
-                span_lint(cx, hir_ty.span);
             }
+            && same_type_and_consts(ty, cx.tcx.type_of(impl_id).instantiate_identity())
+        {
+            span_lint(cx, hir_ty.span);
         }
     }
 
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
-        if_chain! {
-            if !expr.span.from_expansion();
-            if self.msrv.meets(msrvs::TYPE_ALIAS_ENUM_VARIANTS);
-            if let Some(&StackItem::Check { impl_id, .. }) = self.stack.last();
-            if cx.typeck_results().expr_ty(expr) == cx.tcx.type_of(impl_id).instantiate_identity();
-            then {} else { return; }
-        }
+        if !expr.span.from_expansion()
+            && self.msrv.meets(msrvs::TYPE_ALIAS_ENUM_VARIANTS)
+            && let Some(&StackItem::Check { impl_id, .. }) = self.stack.last()
+            && cx.typeck_results().expr_ty(expr) == cx.tcx.type_of(impl_id).instantiate_identity()
+        {} else { return; }
         match expr.kind {
             ExprKind::Struct(QPath::Resolved(_, path), ..) => check_path(cx, path),
             ExprKind::Call(fun, _) => {
@@ -252,18 +244,16 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
     }
 
     fn check_pat(&mut self, cx: &LateContext<'_>, pat: &Pat<'_>) {
-        if_chain! {
-            if !pat.span.from_expansion();
-            if self.msrv.meets(msrvs::TYPE_ALIAS_ENUM_VARIANTS);
-            if let Some(&StackItem::Check { impl_id, .. }) = self.stack.last();
+        if !pat.span.from_expansion()
+            && self.msrv.meets(msrvs::TYPE_ALIAS_ENUM_VARIANTS)
+            && let Some(&StackItem::Check { impl_id, .. }) = self.stack.last()
             // get the path from the pattern
-            if let PatKind::Path(QPath::Resolved(_, path))
+            && let PatKind::Path(QPath::Resolved(_, path))
                  | PatKind::TupleStruct(QPath::Resolved(_, path), _, _)
-                 | PatKind::Struct(QPath::Resolved(_, path), _, _) = pat.kind;
-            if cx.typeck_results().pat_ty(pat) == cx.tcx.type_of(impl_id).instantiate_identity();
-            then {
-                check_path(cx, path);
-            }
+                 | PatKind::Struct(QPath::Resolved(_, path), _, _) = pat.kind
+            && cx.typeck_results().pat_ty(pat) == cx.tcx.type_of(impl_id).instantiate_identity()
+        {
+            check_path(cx, path);
         }
     }
 
diff --git a/clippy_lints/src/useless_conversion.rs b/clippy_lints/src/useless_conversion.rs
index 28f1d487eb5..bc83fddcc53 100644
--- a/clippy_lints/src/useless_conversion.rs
+++ b/clippy_lints/src/useless_conversion.rs
@@ -311,76 +311,68 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
                         );
                     }
                 }
-                if_chain! {
-                    if is_trait_method(cx, e, sym::TryInto) && name.ident.name == sym::try_into;
+                if is_trait_method(cx, e, sym::TryInto) && name.ident.name == sym::try_into
+                    && let a = cx.typeck_results().expr_ty(e)
+                    && let b = cx.typeck_results().expr_ty(recv)
+                    && is_type_diagnostic_item(cx, a, sym::Result)
+                    && let ty::Adt(_, args) = a.kind()
+                    && let Some(a_type) = args.types().next()
+                    && same_type_and_consts(a_type, b)
+
+                {
+                    span_lint_and_help(
+                        cx,
+                        USELESS_CONVERSION,
+                        e.span,
+                        &format!("useless conversion to the same type: `{b}`"),
+                        None,
+                        "consider removing `.try_into()`",
+                    );
+                }
+            },
+
+            ExprKind::Call(path, [arg]) => {
+                if let ExprKind::Path(ref qpath) = path.kind
+                    && let Some(def_id) = cx.qpath_res(qpath, path.hir_id).opt_def_id()
+                    && !is_ty_alias(qpath)
+                {
                     let a = cx.typeck_results().expr_ty(e);
-                    let b = cx.typeck_results().expr_ty(recv);
-                    if is_type_diagnostic_item(cx, a, sym::Result);
-                    if let ty::Adt(_, args) = a.kind();
-                    if let Some(a_type) = args.types().next();
-                    if same_type_and_consts(a_type, b);
+                    let b = cx.typeck_results().expr_ty(arg);
+                    if cx.tcx.is_diagnostic_item(sym::try_from_fn, def_id)
+                        && is_type_diagnostic_item(cx, a, sym::Result)
+                        && let ty::Adt(_, args) = a.kind()
+                        && let Some(a_type) = args.types().next()
+                        && same_type_and_consts(a_type, b)
 
-                    then {
+                    {
+                        let hint = format!("consider removing `{}()`", snippet(cx, path.span, "TryFrom::try_from"));
                         span_lint_and_help(
                             cx,
                             USELESS_CONVERSION,
                             e.span,
                             &format!("useless conversion to the same type: `{b}`"),
                             None,
-                            "consider removing `.try_into()`",
+                            &hint,
                         );
                     }
-                }
-            },
 
-            ExprKind::Call(path, [arg]) => {
-                if_chain! {
-                    if let ExprKind::Path(ref qpath) = path.kind;
-                    if let Some(def_id) = cx.qpath_res(qpath, path.hir_id).opt_def_id();
-                    if !is_ty_alias(qpath);
-                    then {
-                        let a = cx.typeck_results().expr_ty(e);
-                        let b = cx.typeck_results().expr_ty(arg);
-                        if_chain! {
-                            if cx.tcx.is_diagnostic_item(sym::try_from_fn, def_id);
-                            if is_type_diagnostic_item(cx, a, sym::Result);
-                            if let ty::Adt(_, args) = a.kind();
-                            if let Some(a_type) = args.types().next();
-                            if same_type_and_consts(a_type, b);
+                    if cx.tcx.is_diagnostic_item(sym::from_fn, def_id)
+                        && same_type_and_consts(a, b)
 
-                            then {
-                                let hint = format!("consider removing `{}()`", snippet(cx, path.span, "TryFrom::try_from"));
-                                span_lint_and_help(
-                                    cx,
-                                    USELESS_CONVERSION,
-                                    e.span,
-                                    &format!("useless conversion to the same type: `{b}`"),
-                                    None,
-                                    &hint,
-                                );
-                            }
-                        }
-
-                        if_chain! {
-                            if cx.tcx.is_diagnostic_item(sym::from_fn, def_id);
-                            if same_type_and_consts(a, b);
-
-                            then {
-                                let mut app = Applicability::MachineApplicable;
-                                let sugg = Sugg::hir_with_context(cx, arg, e.span.ctxt(), "<expr>", &mut app).maybe_par();
-                                let sugg_msg =
-                                    format!("consider removing `{}()`", snippet(cx, path.span, "From::from"));
-                                span_lint_and_sugg(
-                                    cx,
-                                    USELESS_CONVERSION,
-                                    e.span,
-                                    &format!("useless conversion to the same type: `{b}`"),
-                                    &sugg_msg,
-                                    sugg.to_string(),
-                                    app,
-                                );
-                            }
-                        }
+                    {
+                        let mut app = Applicability::MachineApplicable;
+                        let sugg = Sugg::hir_with_context(cx, arg, e.span.ctxt(), "<expr>", &mut app).maybe_par();
+                        let sugg_msg =
+                            format!("consider removing `{}()`", snippet(cx, path.span, "From::from"));
+                        span_lint_and_sugg(
+                            cx,
+                            USELESS_CONVERSION,
+                            e.span,
+                            &format!("useless conversion to the same type: `{b}`"),
+                            &sugg_msg,
+                            sugg.to_string(),
+                            app,
+                        );
                     }
                 }
             },
diff --git a/clippy_lints/src/utils/internal_lints/collapsible_calls.rs b/clippy_lints/src/utils/internal_lints/collapsible_calls.rs
index d7666b77f6e..1ed74982486 100644
--- a/clippy_lints/src/utils/internal_lints/collapsible_calls.rs
+++ b/clippy_lints/src/utils/internal_lints/collapsible_calls.rs
@@ -78,45 +78,43 @@ impl<'tcx> LateLintPass<'tcx> for CollapsibleCalls {
             return;
         }
 
-        if_chain! {
-            if let ExprKind::Call(func, and_then_args) = expr.kind;
-            if is_expr_path_def_path(cx, func, &["clippy_utils", "diagnostics", "span_lint_and_then"]);
-            if and_then_args.len() == 5;
-            if let ExprKind::Closure(&Closure { body, .. }) = &and_then_args[4].kind;
-            let body = cx.tcx.hir().body(body);
-            let only_expr = peel_blocks_with_stmt(body.value);
-            if let ExprKind::MethodCall(ps, recv, span_call_args, _) = &only_expr.kind;
-            if let ExprKind::Path(..) = recv.kind;
-            then {
-                let and_then_snippets = get_and_then_snippets(cx, and_then_args);
-                let mut sle = SpanlessEq::new(cx).deny_side_effects();
-                match ps.ident.as_str() {
-                    "span_suggestion" if sle.eq_expr(&and_then_args[2], &span_call_args[0]) => {
-                        suggest_suggestion(
-                            cx,
-                            expr,
-                            &and_then_snippets,
-                            &span_suggestion_snippets(cx, span_call_args),
-                        );
-                    },
-                    "span_help" if sle.eq_expr(&and_then_args[2], &span_call_args[0]) => {
-                        let help_snippet = snippet(cx, span_call_args[1].span, r#""...""#);
-                        suggest_help(cx, expr, &and_then_snippets, help_snippet.borrow(), true);
-                    },
-                    "span_note" if sle.eq_expr(&and_then_args[2], &span_call_args[0]) => {
-                        let note_snippet = snippet(cx, span_call_args[1].span, r#""...""#);
-                        suggest_note(cx, expr, &and_then_snippets, note_snippet.borrow(), true);
-                    },
-                    "help" => {
-                        let help_snippet = snippet(cx, span_call_args[0].span, r#""...""#);
-                        suggest_help(cx, expr, &and_then_snippets, help_snippet.borrow(), false);
-                    },
-                    "note" => {
-                        let note_snippet = snippet(cx, span_call_args[0].span, r#""...""#);
-                        suggest_note(cx, expr, &and_then_snippets, note_snippet.borrow(), false);
-                    },
-                    _ => (),
-                }
+        if let ExprKind::Call(func, and_then_args) = expr.kind
+            && is_expr_path_def_path(cx, func, &["clippy_utils", "diagnostics", "span_lint_and_then"])
+            && and_then_args.len() == 5
+            && let ExprKind::Closure(&Closure { body, .. }) = &and_then_args[4].kind
+            && let body = cx.tcx.hir().body(body)
+            && let only_expr = peel_blocks_with_stmt(body.value)
+            && let ExprKind::MethodCall(ps, recv, span_call_args, _) = &only_expr.kind
+            && let ExprKind::Path(..) = recv.kind
+        {
+            let and_then_snippets = get_and_then_snippets(cx, and_then_args);
+            let mut sle = SpanlessEq::new(cx).deny_side_effects();
+            match ps.ident.as_str() {
+                "span_suggestion" if sle.eq_expr(&and_then_args[2], &span_call_args[0]) => {
+                    suggest_suggestion(
+                        cx,
+                        expr,
+                        &and_then_snippets,
+                        &span_suggestion_snippets(cx, span_call_args),
+                    );
+                },
+                "span_help" if sle.eq_expr(&and_then_args[2], &span_call_args[0]) => {
+                    let help_snippet = snippet(cx, span_call_args[1].span, r#""...""#);
+                    suggest_help(cx, expr, &and_then_snippets, help_snippet.borrow(), true);
+                },
+                "span_note" if sle.eq_expr(&and_then_args[2], &span_call_args[0]) => {
+                    let note_snippet = snippet(cx, span_call_args[1].span, r#""...""#);
+                    suggest_note(cx, expr, &and_then_snippets, note_snippet.borrow(), true);
+                },
+                "help" => {
+                    let help_snippet = snippet(cx, span_call_args[0].span, r#""...""#);
+                    suggest_help(cx, expr, &and_then_snippets, help_snippet.borrow(), false);
+                },
+                "note" => {
+                    let note_snippet = snippet(cx, span_call_args[0].span, r#""...""#);
+                    suggest_note(cx, expr, &and_then_snippets, note_snippet.borrow(), false);
+                },
+                _ => (),
             }
         }
     }
diff --git a/clippy_lints/src/utils/internal_lints/compiler_lint_functions.rs b/clippy_lints/src/utils/internal_lints/compiler_lint_functions.rs
index cacd05262a2..6781c1aef3e 100644
--- a/clippy_lints/src/utils/internal_lints/compiler_lint_functions.rs
+++ b/clippy_lints/src/utils/internal_lints/compiler_lint_functions.rs
@@ -56,22 +56,20 @@ impl<'tcx> LateLintPass<'tcx> for CompilerLintFunctions {
             return;
         }
 
-        if_chain! {
-            if let ExprKind::MethodCall(path, self_arg, _, _) = &expr.kind;
-            let fn_name = path.ident;
-            if let Some(sugg) = self.map.get(fn_name.as_str());
-            let ty = cx.typeck_results().expr_ty(self_arg).peel_refs();
-            if match_type(cx, ty, &paths::EARLY_CONTEXT) || match_type(cx, ty, &paths::LATE_CONTEXT);
-            then {
-                span_lint_and_help(
-                    cx,
-                    COMPILER_LINT_FUNCTIONS,
-                    path.ident.span,
-                    "usage of a compiler lint function",
-                    None,
-                    &format!("please use the Clippy variant of this function: `{sugg}`"),
-                );
-            }
+        if let ExprKind::MethodCall(path, self_arg, _, _) = &expr.kind
+            && let fn_name = path.ident
+            && let Some(sugg) = self.map.get(fn_name.as_str())
+            && let ty = cx.typeck_results().expr_ty(self_arg).peel_refs()
+            && (match_type(cx, ty, &paths::EARLY_CONTEXT) || match_type(cx, ty, &paths::LATE_CONTEXT))
+        {
+            span_lint_and_help(
+                cx,
+                COMPILER_LINT_FUNCTIONS,
+                path.ident.span,
+                "usage of a compiler lint function",
+                None,
+                &format!("please use the Clippy variant of this function: `{sugg}`"),
+            );
         }
     }
 }
diff --git a/clippy_lints/src/utils/internal_lints/if_chain_style.rs b/clippy_lints/src/utils/internal_lints/if_chain_style.rs
index 8cdd5ea8903..873e136136f 100644
--- a/clippy_lints/src/utils/internal_lints/if_chain_style.rs
+++ b/clippy_lints/src/utils/internal_lints/if_chain_style.rs
@@ -18,11 +18,9 @@ declare_lint_pass!(IfChainStyle => [IF_CHAIN_STYLE]);
 
 impl<'tcx> LateLintPass<'tcx> for IfChainStyle {
     fn check_block(&mut self, cx: &LateContext<'tcx>, block: &'tcx hir::Block<'_>) {
-        let (local, after, if_chain_span) = if_chain! {
-            if let [Stmt { kind: StmtKind::Local(local), .. }, after @ ..] = block.stmts;
-            if let Some(if_chain_span) = is_expn_of(block.span, "if_chain");
-            then { (local, after, if_chain_span) } else { return }
-        };
+        let (local, after, if_chain_span) = if let [Stmt { kind: StmtKind::Local(local), .. }, after @ ..] = block.stmts
+            && let Some(if_chain_span) = is_expn_of(block.span, "if_chain")
+        { (local, after, if_chain_span) } else { return };
         if is_first_if_chain_expr(cx, block.hir_id, if_chain_span) {
             span_lint(
                 cx,
@@ -55,13 +53,11 @@ impl<'tcx> LateLintPass<'tcx> for IfChainStyle {
         }
         let Some(if_chain_span) = if_chain_span else { return };
         // check for `if a && b;`
-        if_chain! {
-            if let ExprKind::Binary(op, _, _) = cond.kind;
-            if op.node == BinOpKind::And;
-            if cx.sess().source_map().is_multiline(cond.span);
-            then {
-                span_lint(cx, IF_CHAIN_STYLE, cond.span, "`if a && b;` should be `if a; if b;`");
-            }
+        if let ExprKind::Binary(op, _, _) = cond.kind
+            && op.node == BinOpKind::And
+            && cx.sess().source_map().is_multiline(cond.span)
+        {
+            span_lint(cx, IF_CHAIN_STYLE, cond.span, "`if a && b;` should be `if a; if b;`");
         }
         if is_first_if_chain_expr(cx, expr.hir_id, if_chain_span)
             && is_if_chain_then(then_block.stmts, then_block.expr, if_chain_span)
@@ -89,17 +85,15 @@ fn check_nested_if_chains(
         } => (head, tail),
         _ => return,
     };
-    if_chain! {
-        if let Some(higher::IfOrIfLet { r#else: None, .. }) = higher::IfOrIfLet::hir(tail);
-        let sm = cx.sess().source_map();
-        if head
+    if let Some(higher::IfOrIfLet { r#else: None, .. }) = higher::IfOrIfLet::hir(tail)
+        && let sm = cx.sess().source_map()
+        && head
             .iter()
-            .all(|stmt| matches!(stmt.kind, StmtKind::Local(..)) && !sm.is_multiline(stmt.span));
-        if if_chain_span.is_some() || !is_else_clause(cx.tcx, if_expr);
-        then {
-        } else {
-            return;
-        }
+            .all(|stmt| matches!(stmt.kind, StmtKind::Local(..)) && !sm.is_multiline(stmt.span))
+        && (if_chain_span.is_some() || !is_else_clause(cx.tcx, if_expr))
+    {
+    } else {
+        return;
     }
     let (span, msg) = match (if_chain_span, is_expn_of(tail.span, "if_chain")) {
         (None, Some(_)) => (if_expr.span, "this `if` can be part of the inner `if_chain!`"),
diff --git a/clippy_lints/src/utils/internal_lints/interning_defined_symbol.rs b/clippy_lints/src/utils/internal_lints/interning_defined_symbol.rs
index fc9afe5ca8b..c2b36fc28f7 100644
--- a/clippy_lints/src/utils/internal_lints/interning_defined_symbol.rs
+++ b/clippy_lints/src/utils/internal_lints/interning_defined_symbol.rs
@@ -77,15 +77,13 @@ impl<'tcx> LateLintPass<'tcx> for InterningDefinedSymbol {
         for &module in &[&paths::KW_MODULE, &paths::SYM_MODULE] {
             for def_id in def_path_def_ids(cx, module) {
                 for item in cx.tcx.module_children(def_id) {
-                    if_chain! {
-                        if let Res::Def(DefKind::Const, item_def_id) = item.res;
-                        let ty = cx.tcx.type_of(item_def_id).instantiate_identity();
-                        if match_type(cx, ty, &paths::SYMBOL);
-                        if let Ok(ConstValue::Scalar(value)) = cx.tcx.const_eval_poly(item_def_id);
-                        if let Ok(value) = value.to_u32();
-                        then {
-                            self.symbol_map.insert(value, item_def_id);
-                        }
+                    if let Res::Def(DefKind::Const, item_def_id) = item.res
+                        && let ty = cx.tcx.type_of(item_def_id).instantiate_identity()
+                        && match_type(cx, ty, &paths::SYMBOL)
+                        && let Ok(ConstValue::Scalar(value)) = cx.tcx.const_eval_poly(item_def_id)
+                        && let Ok(value) = value.to_u32()
+                    {
+                        self.symbol_map.insert(value, item_def_id);
                     }
                 }
             }
@@ -93,24 +91,22 @@ impl<'tcx> LateLintPass<'tcx> for InterningDefinedSymbol {
     }
 
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if_chain! {
-            if let ExprKind::Call(func, [arg]) = &expr.kind;
-            if let ty::FnDef(def_id, _) = cx.typeck_results().expr_ty(func).kind();
-            if match_def_path(cx, *def_id, &paths::SYMBOL_INTERN);
-            if let Some(Constant::Str(arg)) = constant_simple(cx, cx.typeck_results(), arg);
-            let value = Symbol::intern(&arg).as_u32();
-            if let Some(&def_id) = self.symbol_map.get(&value);
-            then {
-                span_lint_and_sugg(
-                    cx,
-                    INTERNING_DEFINED_SYMBOL,
-                    is_expn_of(expr.span, "sym").unwrap_or(expr.span),
-                    "interning a defined symbol",
-                    "try",
-                    cx.tcx.def_path_str(def_id),
-                    Applicability::MachineApplicable,
-                );
-            }
+        if let ExprKind::Call(func, [arg]) = &expr.kind
+            && let ty::FnDef(def_id, _) = cx.typeck_results().expr_ty(func).kind()
+            && match_def_path(cx, *def_id, &paths::SYMBOL_INTERN)
+            && let Some(Constant::Str(arg)) = constant_simple(cx, cx.typeck_results(), arg)
+            && let value = Symbol::intern(&arg).as_u32()
+            && let Some(&def_id) = self.symbol_map.get(&value)
+        {
+            span_lint_and_sugg(
+                cx,
+                INTERNING_DEFINED_SYMBOL,
+                is_expn_of(expr.span, "sym").unwrap_or(expr.span),
+                "interning a defined symbol",
+                "try",
+                cx.tcx.def_path_str(def_id),
+                Applicability::MachineApplicable,
+            );
         }
         if let ExprKind::Binary(op, left, right) = expr.kind {
             if matches!(op.node, BinOpKind::Eq | BinOpKind::Ne) {
@@ -163,27 +159,24 @@ impl InterningDefinedSymbol {
     fn symbol_str_expr<'tcx>(&self, expr: &'tcx Expr<'tcx>, cx: &LateContext<'tcx>) -> Option<SymbolStrExpr<'tcx>> {
         static IDENT_STR_PATHS: &[&[&str]] = &[&paths::IDENT_AS_STR];
         static SYMBOL_STR_PATHS: &[&[&str]] = &[&paths::SYMBOL_AS_STR, &paths::SYMBOL_TO_IDENT_STRING];
-        let call = if_chain! {
-            if let ExprKind::AddrOf(_, _, e) = expr.kind;
-            if let ExprKind::Unary(UnOp::Deref, e) = e.kind;
-            then { e } else { expr }
-        };
-        if_chain! {
+        let call = if let ExprKind::AddrOf(_, _, e) = expr.kind
+            && let ExprKind::Unary(UnOp::Deref, e) = e.kind
+        { e } else { expr };
+        if let ExprKind::MethodCall(_, item, [], _) = call.kind
             // is a method call
-            if let ExprKind::MethodCall(_, item, [], _) = call.kind;
-            if let Some(did) = cx.typeck_results().type_dependent_def_id(call.hir_id);
-            let ty = cx.typeck_results().expr_ty(item);
+            && let Some(did) = cx.typeck_results().type_dependent_def_id(call.hir_id)
+            && let ty = cx.typeck_results().expr_ty(item)
             // ...on either an Ident or a Symbol
-            if let Some(is_ident) = if match_type(cx, ty, &paths::SYMBOL) {
+            && let Some(is_ident) = if match_type(cx, ty, &paths::SYMBOL) {
                 Some(false)
             } else if match_type(cx, ty, &paths::IDENT) {
                 Some(true)
             } else {
                 None
-            };
+            }
             // ...which converts it to a string
-            let paths = if is_ident { IDENT_STR_PATHS } else { SYMBOL_STR_PATHS };
-            if let Some(is_to_owned) = paths
+            && let paths = if is_ident { IDENT_STR_PATHS } else { SYMBOL_STR_PATHS }
+            && let Some(is_to_owned) = paths
                 .iter()
                 .find_map(|path| if match_def_path(cx, did, path) {
                     Some(path == &paths::SYMBOL_TO_IDENT_STRING)
@@ -194,14 +187,13 @@ impl InterningDefinedSymbol {
                     Some(true)
                 } else {
                     None
-                });
-            then {
-                return Some(SymbolStrExpr::Expr {
-                    item,
-                    is_ident,
-                    is_to_owned,
-                });
-            }
+                })
+        {
+            return Some(SymbolStrExpr::Expr {
+                item,
+                is_ident,
+                is_to_owned,
+            });
         }
         // is a string constant
         if let Some(Constant::Str(s)) = constant_simple(cx, cx.typeck_results(), expr) {
diff --git a/clippy_lints/src/utils/internal_lints/invalid_paths.rs b/clippy_lints/src/utils/internal_lints/invalid_paths.rs
index 25077223885..b5a4787175a 100644
--- a/clippy_lints/src/utils/internal_lints/invalid_paths.rs
+++ b/clippy_lints/src/utils/internal_lints/invalid_paths.rs
@@ -31,13 +31,12 @@ impl<'tcx> LateLintPass<'tcx> for InvalidPaths {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
         let local_def_id = &cx.tcx.parent_module(item.hir_id());
         let mod_name = &cx.tcx.item_name(local_def_id.to_def_id());
-        if_chain! {
-            if mod_name.as_str() == "paths";
-            if let hir::ItemKind::Const(.., body_id) = item.kind;
-            let body = cx.tcx.hir().body(body_id);
-            let typeck_results = cx.tcx.typeck_body(body_id);
-            if let Some(Constant::Vec(path)) = constant_simple(cx, typeck_results, body.value);
-            if let Some(path) = path
+        if mod_name.as_str() == "paths"
+            && let hir::ItemKind::Const(.., body_id) = item.kind
+            && let body = cx.tcx.hir().body(body_id)
+            && let typeck_results = cx.tcx.typeck_body(body_id)
+            && let Some(Constant::Vec(path)) = constant_simple(cx, typeck_results, body.value)
+            && let Some(path) = path
                 .iter()
                 .map(|x| {
                     if let Constant::Str(s) = x {
@@ -46,11 +45,10 @@ impl<'tcx> LateLintPass<'tcx> for InvalidPaths {
                         None
                     }
                 })
-                .collect::<Option<Vec<&str>>>();
-            if !check_path(cx, &path[..]);
-            then {
-                span_lint(cx, INVALID_PATHS, item.span, "invalid path");
-            }
+                .collect::<Option<Vec<&str>>>()
+            && !check_path(cx, &path[..])
+        {
+            span_lint(cx, INVALID_PATHS, item.span, "invalid path");
         }
     }
 }
diff --git a/clippy_lints/src/utils/internal_lints/lint_without_lint_pass.rs b/clippy_lints/src/utils/internal_lints/lint_without_lint_pass.rs
index 00e352961bd..871c8f99ebf 100644
--- a/clippy_lints/src/utils/internal_lints/lint_without_lint_pass.rs
+++ b/clippy_lints/src/utils/internal_lints/lint_without_lint_pass.rs
@@ -309,15 +309,13 @@ fn check_invalid_clippy_version_attribute(cx: &LateContext<'_>, item: &'_ Item<'
 pub(super) fn extract_clippy_version_value(cx: &LateContext<'_>, item: &'_ Item<'_>) -> Option<Symbol> {
     let attrs = cx.tcx.hir().attrs(item.hir_id());
     attrs.iter().find_map(|attr| {
-        if_chain! {
+        if let ast::AttrKind::Normal(ref attr_kind) = &attr.kind
             // Identify attribute
-            if let ast::AttrKind::Normal(ref attr_kind) = &attr.kind;
-            if let [tool_name, attr_name] = &attr_kind.item.path.segments[..];
-            if tool_name.ident.name == sym::clippy;
-            if attr_name.ident.name == sym::version;
-            if let Some(version) = attr.value_str();
-            then { Some(version) } else { None }
-        }
+            && let [tool_name, attr_name] = &attr_kind.item.path.segments[..]
+            && tool_name.ident.name == sym::clippy
+            && attr_name.ident.name == sym::version
+            && let Some(version) = attr.value_str()
+        { Some(version) } else { None }
     })
 }
 
diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index 51abe0c1dc3..e4e72bbc388 100644
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -543,49 +543,45 @@ impl<'hir> LateLintPass<'hir> for MetadataCollector {
     fn check_item(&mut self, cx: &LateContext<'hir>, item: &'hir Item<'_>) {
         if let ItemKind::Static(ty, Mutability::Not, _) = item.kind {
             // Normal lint
-            if_chain! {
+            if is_lint_ref_type(cx, ty)
                 // item validation
-                if is_lint_ref_type(cx, ty);
                 // disallow check
-                let lint_name = sym_to_string(item.ident.name).to_ascii_lowercase();
+                && let lint_name = sym_to_string(item.ident.name).to_ascii_lowercase()
                 // metadata extraction
-                if let Some((group, level)) = get_lint_group_and_level_or_lint(cx, &lint_name, item);
-                if let Some(mut raw_docs) = extract_attr_docs_or_lint(cx, item);
-                then {
-                    if let Some(configuration_section) = self.get_lint_configs(&lint_name) {
-                        raw_docs.push_str(&configuration_section);
-                    }
-                    let version = get_lint_version(cx, item);
-
-                    self.lints.push(LintMetadata::new(
-                        lint_name,
-                        SerializableSpan::from_item(cx, item),
-                        group,
-                        level,
-                        version,
-                        raw_docs,
-                    ));
+                && let Some((group, level)) = get_lint_group_and_level_or_lint(cx, &lint_name, item)
+                && let Some(mut raw_docs) = extract_attr_docs_or_lint(cx, item)
+            {
+                if let Some(configuration_section) = self.get_lint_configs(&lint_name) {
+                    raw_docs.push_str(&configuration_section);
                 }
+                let version = get_lint_version(cx, item);
+
+                self.lints.push(LintMetadata::new(
+                    lint_name,
+                    SerializableSpan::from_item(cx, item),
+                    group,
+                    level,
+                    version,
+                    raw_docs,
+                ));
             }
 
-            if_chain! {
-                if is_deprecated_lint(cx, ty);
+            if is_deprecated_lint(cx, ty)
                 // disallow check
-                let lint_name = sym_to_string(item.ident.name).to_ascii_lowercase();
+                && let lint_name = sym_to_string(item.ident.name).to_ascii_lowercase()
                 // Metadata the little we can get from a deprecated lint
-                if let Some(raw_docs) = extract_attr_docs_or_lint(cx, item);
-                then {
-                    let version = get_lint_version(cx, item);
-
-                    self.lints.push(LintMetadata::new(
-                        lint_name,
-                        SerializableSpan::from_item(cx, item),
-                        DEPRECATED_LINT_GROUP_STR.to_string(),
-                        DEPRECATED_LINT_LEVEL,
-                        version,
-                        raw_docs,
-                    ));
-                }
+                && let Some(raw_docs) = extract_attr_docs_or_lint(cx, item)
+            {
+                let version = get_lint_version(cx, item);
+
+                self.lints.push(LintMetadata::new(
+                    lint_name,
+                    SerializableSpan::from_item(cx, item),
+                    DEPRECATED_LINT_GROUP_STR.to_string(),
+                    DEPRECATED_LINT_LEVEL,
+                    version,
+                    raw_docs,
+                ));
             }
         }
     }
@@ -789,15 +785,13 @@ fn collect_renames(lints: &mut Vec<LintMetadata>) {
         loop {
             if let Some(lint_name) = names.pop() {
                 for (k, v) in RENAMED_LINTS {
-                    if_chain! {
-                        if let Some(name) = v.strip_prefix(CLIPPY_LINT_GROUP_PREFIX);
-                        if name == lint_name;
-                        if let Some(past_name) = k.strip_prefix(CLIPPY_LINT_GROUP_PREFIX);
-                        then {
-                            lint.former_ids.insert(past_name.to_owned());
-                            writeln!(collected, "* `{past_name}`").unwrap();
-                            names.push(past_name.to_string());
-                        }
+                    if let Some(name) = v.strip_prefix(CLIPPY_LINT_GROUP_PREFIX)
+                        && name == lint_name
+                        && let Some(past_name) = k.strip_prefix(CLIPPY_LINT_GROUP_PREFIX)
+                    {
+                        lint.former_ids.insert(past_name.to_owned());
+                        writeln!(collected, "* `{past_name}`").unwrap();
+                        names.push(past_name.to_string());
                     }
                 }
 
@@ -927,20 +921,18 @@ impl<'a, 'hir> intravisit::Visitor<'hir> for LintResolver<'a, 'hir> {
     }
 
     fn visit_expr(&mut self, expr: &'hir hir::Expr<'hir>) {
-        if_chain! {
-            if let ExprKind::Path(qpath) = &expr.kind;
-            if let QPath::Resolved(_, path) = qpath;
-
-            let (expr_ty, _) = walk_ptrs_ty_depth(self.cx.typeck_results().expr_ty(expr));
-            if match_type(self.cx, expr_ty, &paths::LINT);
-            then {
-                if let hir::def::Res::Def(DefKind::Static(..), _) = path.res {
-                    let lint_name = last_path_segment(qpath).ident.name;
-                    self.lints.push(sym_to_string(lint_name).to_ascii_lowercase());
-                } else if let Some(local) = get_parent_local(self.cx, expr) {
-                    if let Some(local_init) = local.init {
-                        intravisit::walk_expr(self, local_init);
-                    }
+        if let ExprKind::Path(qpath) = &expr.kind
+            && let QPath::Resolved(_, path) = qpath
+
+            && let (expr_ty, _) = walk_ptrs_ty_depth(self.cx.typeck_results().expr_ty(expr))
+            && match_type(self.cx, expr_ty, &paths::LINT)
+        {
+            if let hir::def::Res::Def(DefKind::Static(..), _) = path.res {
+                let lint_name = last_path_segment(qpath).ident.name;
+                self.lints.push(sym_to_string(lint_name).to_ascii_lowercase());
+            } else if let Some(local) = get_parent_local(self.cx, expr) {
+                if let Some(local_init) = local.init {
+                    intravisit::walk_expr(self, local_init);
                 }
             }
         }
@@ -992,13 +984,11 @@ impl<'a, 'hir> intravisit::Visitor<'hir> for ApplicabilityResolver<'a, 'hir> {
     fn visit_expr(&mut self, expr: &'hir hir::Expr<'hir>) {
         let (expr_ty, _) = walk_ptrs_ty_depth(self.cx.typeck_results().expr_ty(expr));
 
-        if_chain! {
-            if match_type(self.cx, expr_ty, &paths::APPLICABILITY);
-            if let Some(local) = get_parent_local(self.cx, expr);
-            if let Some(local_init) = local.init;
-            then {
-                intravisit::walk_expr(self, local_init);
-            }
+        if match_type(self.cx, expr_ty, &paths::APPLICABILITY)
+            && let Some(local) = get_parent_local(self.cx, expr)
+            && let Some(local_init) = local.init
+        {
+            intravisit::walk_expr(self, local_init);
         };
 
         intravisit::walk_expr(self, expr);
diff --git a/clippy_lints/src/utils/internal_lints/msrv_attr_impl.rs b/clippy_lints/src/utils/internal_lints/msrv_attr_impl.rs
index 86b77a77f17..1c09695c9dd 100644
--- a/clippy_lints/src/utils/internal_lints/msrv_attr_impl.rs
+++ b/clippy_lints/src/utils/internal_lints/msrv_attr_impl.rs
@@ -22,40 +22,38 @@ declare_lint_pass!(MsrvAttrImpl => [MISSING_MSRV_ATTR_IMPL]);
 
 impl LateLintPass<'_> for MsrvAttrImpl {
     fn check_item(&mut self, cx: &LateContext<'_>, item: &hir::Item<'_>) {
-        if_chain! {
-            if let hir::ItemKind::Impl(hir::Impl {
+        if let hir::ItemKind::Impl(hir::Impl {
                 of_trait: Some(_),
                 items,
                 ..
-            }) = &item.kind;
-            if let Some(trait_ref) = cx.tcx.impl_trait_ref(item.owner_id).map(EarlyBinder::instantiate_identity);
-            let is_late_pass = match_def_path(cx, trait_ref.def_id, &paths::LATE_LINT_PASS);
-            if is_late_pass || match_def_path(cx, trait_ref.def_id, &paths::EARLY_LINT_PASS);
-            if let ty::Adt(self_ty_def, _) = trait_ref.self_ty().kind();
-            if self_ty_def.is_struct();
-            if self_ty_def.all_fields().any(|f| {
+            }) = &item.kind
+            && let Some(trait_ref) = cx.tcx.impl_trait_ref(item.owner_id).map(EarlyBinder::instantiate_identity)
+            && let is_late_pass = match_def_path(cx, trait_ref.def_id, &paths::LATE_LINT_PASS)
+            && (is_late_pass || match_def_path(cx, trait_ref.def_id, &paths::EARLY_LINT_PASS))
+            && let ty::Adt(self_ty_def, _) = trait_ref.self_ty().kind()
+            && self_ty_def.is_struct()
+            && self_ty_def.all_fields().any(|f| {
                 cx.tcx
                     .type_of(f.did)
                     .instantiate_identity()
                     .walk()
                     .filter(|t| matches!(t.unpack(), GenericArgKind::Type(_)))
                     .any(|t| match_type(cx, t.expect_ty(), &paths::MSRV))
-            });
-            if !items.iter().any(|item| item.ident.name == sym!(enter_lint_attrs));
-            then {
-                let context = if is_late_pass { "LateContext" } else { "EarlyContext" };
-                let lint_pass = if is_late_pass { "LateLintPass" } else { "EarlyLintPass" };
-                let span = cx.sess().source_map().span_through_char(item.span, '{');
-                span_lint_and_sugg(
-                    cx,
-                    MISSING_MSRV_ATTR_IMPL,
-                    span,
-                    &format!("`extract_msrv_attr!` macro missing from `{lint_pass}` implementation"),
-                    &format!("add `extract_msrv_attr!({context})` to the `{lint_pass}` implementation"),
-                    format!("{}\n    extract_msrv_attr!({context});", snippet(cx, span, "..")),
-                    Applicability::MachineApplicable,
-                );
-            }
+            })
+            && !items.iter().any(|item| item.ident.name == sym!(enter_lint_attrs))
+        {
+            let context = if is_late_pass { "LateContext" } else { "EarlyContext" };
+            let lint_pass = if is_late_pass { "LateLintPass" } else { "EarlyLintPass" };
+            let span = cx.sess().source_map().span_through_char(item.span, '{');
+            span_lint_and_sugg(
+                cx,
+                MISSING_MSRV_ATTR_IMPL,
+                span,
+                &format!("`extract_msrv_attr!` macro missing from `{lint_pass}` implementation"),
+                &format!("add `extract_msrv_attr!({context})` to the `{lint_pass}` implementation"),
+                format!("{}\n    extract_msrv_attr!({context});", snippet(cx, span, "..")),
+                Applicability::MachineApplicable,
+            );
         }
     }
 }
diff --git a/clippy_lints/src/utils/internal_lints/outer_expn_data_pass.rs b/clippy_lints/src/utils/internal_lints/outer_expn_data_pass.rs
index 2b13fad8066..78eeb04d58d 100644
--- a/clippy_lints/src/utils/internal_lints/outer_expn_data_pass.rs
+++ b/clippy_lints/src/utils/internal_lints/outer_expn_data_pass.rs
@@ -40,23 +40,21 @@ impl<'tcx> LateLintPass<'tcx> for OuterExpnDataPass {
 
         let (method_names, arg_lists, spans) = method_calls(expr, 2);
         let method_names: Vec<&str> = method_names.iter().map(Symbol::as_str).collect();
-        if_chain! {
-            if let ["expn_data", "outer_expn"] = method_names.as_slice();
-            let (self_arg, args) = arg_lists[1];
-            if args.is_empty();
-            let self_ty = cx.typeck_results().expr_ty(self_arg).peel_refs();
-            if match_type(cx, self_ty, &paths::SYNTAX_CONTEXT);
-            then {
-                span_lint_and_sugg(
-                    cx,
-                    OUTER_EXPN_EXPN_DATA,
-                    spans[1].with_hi(expr.span.hi()),
-                    "usage of `outer_expn().expn_data()`",
-                    "try",
-                    "outer_expn_data()".to_string(),
-                    Applicability::MachineApplicable,
-                );
-            }
+        if let ["expn_data", "outer_expn"] = method_names.as_slice()
+            && let (self_arg, args) = arg_lists[1]
+            && args.is_empty()
+            && let self_ty = cx.typeck_results().expr_ty(self_arg).peel_refs()
+            && match_type(cx, self_ty, &paths::SYNTAX_CONTEXT)
+        {
+            span_lint_and_sugg(
+                cx,
+                OUTER_EXPN_EXPN_DATA,
+                spans[1].with_hi(expr.span.hi()),
+                "usage of `outer_expn().expn_data()`",
+                "try",
+                "outer_expn_data()".to_string(),
+                Applicability::MachineApplicable,
+            );
         }
     }
 }
diff --git a/clippy_lints/src/utils/internal_lints/unnecessary_def_path.rs b/clippy_lints/src/utils/internal_lints/unnecessary_def_path.rs
index 81be04659b9..3ad02afd88a 100644
--- a/clippy_lints/src/utils/internal_lints/unnecessary_def_path.rs
+++ b/clippy_lints/src/utils/internal_lints/unnecessary_def_path.rs
@@ -102,108 +102,106 @@ impl UnnecessaryDefPath {
             &["clippy_utils", "is_expr_path_def_path"],
         ];
 
-        if_chain! {
-            if let [cx_arg, def_arg, args @ ..] = args;
-            if let ExprKind::Path(path) = &func.kind;
-            if let Some(id) = cx.qpath_res(path, func.hir_id).opt_def_id();
-            if let Some(which_path) = match_any_def_paths(cx, id, PATHS);
-            let item_arg = if which_path == 4 { &args[1] } else { &args[0] };
+        if let [cx_arg, def_arg, args @ ..] = args
+            && let ExprKind::Path(path) = &func.kind
+            && let Some(id) = cx.qpath_res(path, func.hir_id).opt_def_id()
+            && let Some(which_path) = match_any_def_paths(cx, id, PATHS)
+            && let item_arg = if which_path == 4 { &args[1] } else { &args[0] }
             // Extract the path to the matched type
-            if let Some(segments) = path_to_matched_type(cx, item_arg);
-            let segments: Vec<&str> = segments.iter().map(|sym| &**sym).collect();
-            if let Some(def_id) = def_path_def_ids(cx, &segments[..]).next();
-            then {
-                // Check if the target item is a diagnostic item or LangItem.
-                #[rustfmt::skip]
-                let (msg, item) = if let Some(item_name)
-                    = cx.tcx.diagnostic_items(def_id.krate).id_to_name.get(&def_id)
-                {
-                    (
-                        "use of a def path to a diagnostic item",
-                        Item::DiagnosticItem(*item_name),
-                    )
-                } else if let Some(item_name) = get_lang_item_name(cx, def_id) {
-                    (
-                        "use of a def path to a `LangItem`",
-                        Item::LangItem(item_name),
-                    )
-                } else {
-                    return;
-                };
+            && let Some(segments) = path_to_matched_type(cx, item_arg)
+            && let segments: Vec<&str> = segments.iter().map(|sym| &**sym).collect()
+            && let Some(def_id) = def_path_def_ids(cx, &segments[..]).next()
+        {
+            // Check if the target item is a diagnostic item or LangItem.
+            #[rustfmt::skip]
+            let (msg, item) = if let Some(item_name)
+                = cx.tcx.diagnostic_items(def_id.krate).id_to_name.get(&def_id)
+            {
+                (
+                    "use of a def path to a diagnostic item",
+                    Item::DiagnosticItem(*item_name),
+                )
+            } else if let Some(item_name) = get_lang_item_name(cx, def_id) {
+                (
+                    "use of a def path to a `LangItem`",
+                    Item::LangItem(item_name),
+                )
+            } else {
+                return;
+            };
 
-                let has_ctor = match cx.tcx.def_kind(def_id) {
-                    DefKind::Struct => {
-                        let variant = cx.tcx.adt_def(def_id).non_enum_variant();
-                        variant.ctor.is_some() && variant.fields.iter().all(|f| f.vis.is_public())
-                    },
-                    DefKind::Variant => {
-                        let variant = cx.tcx.adt_def(cx.tcx.parent(def_id)).variant_with_id(def_id);
-                        variant.ctor.is_some() && variant.fields.iter().all(|f| f.vis.is_public())
-                    },
-                    _ => false,
-                };
+            let has_ctor = match cx.tcx.def_kind(def_id) {
+                DefKind::Struct => {
+                    let variant = cx.tcx.adt_def(def_id).non_enum_variant();
+                    variant.ctor.is_some() && variant.fields.iter().all(|f| f.vis.is_public())
+                },
+                DefKind::Variant => {
+                    let variant = cx.tcx.adt_def(cx.tcx.parent(def_id)).variant_with_id(def_id);
+                    variant.ctor.is_some() && variant.fields.iter().all(|f| f.vis.is_public())
+                },
+                _ => false,
+            };
 
-                let mut app = Applicability::MachineApplicable;
-                let cx_snip = snippet_with_applicability(cx, cx_arg.span, "..", &mut app);
-                let def_snip = snippet_with_applicability(cx, def_arg.span, "..", &mut app);
-                let (sugg, with_note) = match (which_path, item) {
-                    // match_def_path
-                    (0, Item::DiagnosticItem(item)) => (
-                        format!("{cx_snip}.tcx.is_diagnostic_item(sym::{item}, {def_snip})"),
-                        has_ctor,
-                    ),
-                    (0, Item::LangItem(item)) => (
-                        format!("{cx_snip}.tcx.lang_items().get(LangItem::{item}) == Some({def_snip})"),
-                        has_ctor,
-                    ),
-                    // match_trait_method
-                    (1, Item::DiagnosticItem(item)) => {
-                        (format!("is_trait_method({cx_snip}, {def_snip}, sym::{item})"), false)
-                    },
-                    // match_type
-                    (2, Item::DiagnosticItem(item)) => (
-                        format!("is_type_diagnostic_item({cx_snip}, {def_snip}, sym::{item})"),
-                        false,
-                    ),
-                    (2, Item::LangItem(item)) => (
-                        format!("is_type_lang_item({cx_snip}, {def_snip}, LangItem::{item})"),
-                        false,
-                    ),
-                    // is_expr_path_def_path
-                    (3, Item::DiagnosticItem(item)) if has_ctor => (
-                        format!("is_res_diag_ctor({cx_snip}, path_res({cx_snip}, {def_snip}), sym::{item})",),
-                        false,
-                    ),
-                    (3, Item::LangItem(item)) if has_ctor => (
-                        format!("is_res_lang_ctor({cx_snip}, path_res({cx_snip}, {def_snip}), LangItem::{item})",),
-                        false,
-                    ),
-                    (3, Item::DiagnosticItem(item)) => (
-                        format!("is_path_diagnostic_item({cx_snip}, {def_snip}, sym::{item})"),
-                        false,
-                    ),
-                    (3, Item::LangItem(item)) => (
-                        format!(
-                            "path_res({cx_snip}, {def_snip}).opt_def_id()\
-                                .map_or(false, |id| {cx_snip}.tcx.lang_items().get(LangItem::{item}) == Some(id))",
-                        ),
-                        false,
+            let mut app = Applicability::MachineApplicable;
+            let cx_snip = snippet_with_applicability(cx, cx_arg.span, "..", &mut app);
+            let def_snip = snippet_with_applicability(cx, def_arg.span, "..", &mut app);
+            let (sugg, with_note) = match (which_path, item) {
+                // match_def_path
+                (0, Item::DiagnosticItem(item)) => (
+                    format!("{cx_snip}.tcx.is_diagnostic_item(sym::{item}, {def_snip})"),
+                    has_ctor,
+                ),
+                (0, Item::LangItem(item)) => (
+                    format!("{cx_snip}.tcx.lang_items().get(LangItem::{item}) == Some({def_snip})"),
+                    has_ctor,
+                ),
+                // match_trait_method
+                (1, Item::DiagnosticItem(item)) => {
+                    (format!("is_trait_method({cx_snip}, {def_snip}, sym::{item})"), false)
+                },
+                // match_type
+                (2, Item::DiagnosticItem(item)) => (
+                    format!("is_type_diagnostic_item({cx_snip}, {def_snip}, sym::{item})"),
+                    false,
+                ),
+                (2, Item::LangItem(item)) => (
+                    format!("is_type_lang_item({cx_snip}, {def_snip}, LangItem::{item})"),
+                    false,
+                ),
+                // is_expr_path_def_path
+                (3, Item::DiagnosticItem(item)) if has_ctor => (
+                    format!("is_res_diag_ctor({cx_snip}, path_res({cx_snip}, {def_snip}), sym::{item})",),
+                    false,
+                ),
+                (3, Item::LangItem(item)) if has_ctor => (
+                    format!("is_res_lang_ctor({cx_snip}, path_res({cx_snip}, {def_snip}), LangItem::{item})",),
+                    false,
+                ),
+                (3, Item::DiagnosticItem(item)) => (
+                    format!("is_path_diagnostic_item({cx_snip}, {def_snip}, sym::{item})"),
+                    false,
+                ),
+                (3, Item::LangItem(item)) => (
+                    format!(
+                        "path_res({cx_snip}, {def_snip}).opt_def_id()\
+                            .map_or(false, |id| {cx_snip}.tcx.lang_items().get(LangItem::{item}) == Some(id))",
                     ),
-                    _ => return,
-                };
+                    false,
+                ),
+                _ => return,
+            };
 
-                span_lint_and_then(cx, UNNECESSARY_DEF_PATH, span, msg, |diag| {
-                    diag.span_suggestion(span, "try", sugg, app);
-                    if with_note {
-                        diag.help(
-                            "if this `DefId` came from a constructor expression or pattern then the \
-                                    parent `DefId` should be used instead",
-                        );
-                    }
-                });
+            span_lint_and_then(cx, UNNECESSARY_DEF_PATH, span, msg, |diag| {
+                diag.span_suggestion(span, "try", sugg, app);
+                if with_note {
+                    diag.help(
+                        "if this `DefId` came from a constructor expression or pattern then the \
+                                parent `DefId` should be used instead",
+                    );
+                }
+            });
 
-                self.linted_def_ids.insert(def_id);
-            }
+            self.linted_def_ids.insert(def_id);
         }
     }
 
diff --git a/clippy_lints/src/vec.rs b/clippy_lints/src/vec.rs
index a9dd44afaf7..d215e6b5768 100644
--- a/clippy_lints/src/vec.rs
+++ b/clippy_lints/src/vec.rs
@@ -72,21 +72,19 @@ fn is_allowed_vec_method(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
 impl<'tcx> LateLintPass<'tcx> for UselessVec {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         // search for `&vec![_]` or `vec![_]` expressions where the adjusted type is `&[_]`
-        if_chain! {
-            if adjusts_to_slice(cx, expr);
-            if let Some(vec_args) = higher::VecArgs::hir(cx, expr.peel_borrows());
-            then {
-                let (suggest_slice, span) = if let ExprKind::AddrOf(BorrowKind::Ref, mutability, _) = expr.kind {
-                    // `expr` is `&vec![_]`, so suggest `&[_]` (or `&mut[_]` resp.)
-                    (SuggestedType::SliceRef(mutability), expr.span)
-                } else {
-                    // `expr` is the `vec![_]` expansion, so suggest `[_]`
-                    // and also use the span of the actual `vec![_]` expression
-                    (SuggestedType::Array, expr.span.ctxt().outer_expn_data().call_site)
-                };
-
-                self.check_vec_macro(cx, &vec_args, span, suggest_slice);
-            }
+        if adjusts_to_slice(cx, expr)
+            && let Some(vec_args) = higher::VecArgs::hir(cx, expr.peel_borrows())
+        {
+            let (suggest_slice, span) = if let ExprKind::AddrOf(BorrowKind::Ref, mutability, _) = expr.kind {
+                // `expr` is `&vec![_]`, so suggest `&[_]` (or `&mut[_]` resp.)
+                (SuggestedType::SliceRef(mutability), expr.span)
+            } else {
+                // `expr` is the `vec![_]` expansion, so suggest `[_]`
+                // and also use the span of the actual `vec![_]` expression
+                (SuggestedType::Array, expr.span.ctxt().outer_expn_data().call_site)
+            };
+
+            self.check_vec_macro(cx, &vec_args, span, suggest_slice);
         }
 
         // search for `let foo = vec![_]` expressions where all uses of `foo`
@@ -124,15 +122,13 @@ impl<'tcx> LateLintPass<'tcx> for UselessVec {
         }
 
         // search for `for _ in vec![…]`
-        if_chain! {
-            if let Some(higher::ForLoop { arg, .. }) = higher::ForLoop::hir(expr);
-            if let Some(vec_args) = higher::VecArgs::hir(cx, arg);
-            if self.msrv.meets(msrvs::ARRAY_INTO_ITERATOR);
-            then {
-                // report the error around the `vec!` not inside `<std macros>:`
-                let span = arg.span.ctxt().outer_expn_data().call_site;
-                self.check_vec_macro(cx, &vec_args, span, SuggestedType::Array);
-            }
+        if let Some(higher::ForLoop { arg, .. }) = higher::ForLoop::hir(expr)
+            && let Some(vec_args) = higher::VecArgs::hir(cx, arg)
+            && self.msrv.meets(msrvs::ARRAY_INTO_ITERATOR)
+        {
+            // report the error around the `vec!` not inside `<std macros>:`
+            let span = arg.span.ctxt().outer_expn_data().call_site;
+            self.check_vec_macro(cx, &vec_args, span, SuggestedType::Array);
         }
     }
 
diff --git a/clippy_lints/src/wildcard_imports.rs b/clippy_lints/src/wildcard_imports.rs
index d88ede76398..c94ed82646e 100644
--- a/clippy_lints/src/wildcard_imports.rs
+++ b/clippy_lints/src/wildcard_imports.rs
@@ -127,70 +127,68 @@ impl LateLintPass<'_> for WildcardImports {
         if cx.tcx.visibility(item.owner_id.def_id) != ty::Visibility::Restricted(module.to_def_id()) {
             return;
         }
-        if_chain! {
-            if let ItemKind::Use(use_path, UseKind::Glob) = &item.kind;
-            if self.warn_on_all || !self.check_exceptions(item, use_path.segments);
-            let used_imports = cx.tcx.names_imported_by_glob_use(item.owner_id.def_id);
-            if !used_imports.is_empty(); // Already handled by `unused_imports`
-            if !used_imports.contains(&kw::Underscore);
-            then {
-                let mut applicability = Applicability::MachineApplicable;
-                let import_source_snippet = snippet_with_applicability(cx, use_path.span, "..", &mut applicability);
-                let (span, braced_glob) = if import_source_snippet.is_empty() {
-                    // This is a `_::{_, *}` import
-                    // In this case `use_path.span` is empty and ends directly in front of the `*`,
-                    // so we need to extend it by one byte.
-                    (
-                        use_path.span.with_hi(use_path.span.hi() + BytePos(1)),
-                        true,
-                    )
-                } else {
-                    // In this case, the `use_path.span` ends right before the `::*`, so we need to
-                    // extend it up to the `*`. Since it is hard to find the `*` in weird
-                    // formattings like `use _ ::  *;`, we extend it up to, but not including the
-                    // `;`. In nested imports, like `use _::{inner::*, _}` there is no `;` and we
-                    // can just use the end of the item span
-                    let mut span = use_path.span.with_hi(item.span.hi());
-                    if snippet(cx, span, "").ends_with(';') {
-                        span = use_path.span.with_hi(item.span.hi() - BytePos(1));
-                    }
-                    (
-                        span, false,
-                    )
-                };
+        if let ItemKind::Use(use_path, UseKind::Glob) = &item.kind
+            && (self.warn_on_all || !self.check_exceptions(item, use_path.segments))
+            && let used_imports = cx.tcx.names_imported_by_glob_use(item.owner_id.def_id)
+            && !used_imports.is_empty() // Already handled by `unused_imports`
+            && !used_imports.contains(&kw::Underscore)
+        {
+            let mut applicability = Applicability::MachineApplicable;
+            let import_source_snippet = snippet_with_applicability(cx, use_path.span, "..", &mut applicability);
+            let (span, braced_glob) = if import_source_snippet.is_empty() {
+                // This is a `_::{_, *}` import
+                // In this case `use_path.span` is empty and ends directly in front of the `*`,
+                // so we need to extend it by one byte.
+                (
+                    use_path.span.with_hi(use_path.span.hi() + BytePos(1)),
+                    true,
+                )
+            } else {
+                // In this case, the `use_path.span` ends right before the `::*`, so we need to
+                // extend it up to the `*`. Since it is hard to find the `*` in weird
+                // formattings like `use _ ::  *;`, we extend it up to, but not including the
+                // `;`. In nested imports, like `use _::{inner::*, _}` there is no `;` and we
+                // can just use the end of the item span
+                let mut span = use_path.span.with_hi(item.span.hi());
+                if snippet(cx, span, "").ends_with(';') {
+                    span = use_path.span.with_hi(item.span.hi() - BytePos(1));
+                }
+                (
+                    span, false,
+                )
+            };
 
-                let mut imports = used_imports.items().map(ToString::to_string).into_sorted_stable_ord();
-                let imports_string = if imports.len() == 1 {
-                    imports.pop().unwrap()
-                } else if braced_glob {
-                    imports.join(", ")
-                } else {
-                    format!("{{{}}}", imports.join(", "))
-                };
+            let mut imports = used_imports.items().map(ToString::to_string).into_sorted_stable_ord();
+            let imports_string = if imports.len() == 1 {
+                imports.pop().unwrap()
+            } else if braced_glob {
+                imports.join(", ")
+            } else {
+                format!("{{{}}}", imports.join(", "))
+            };
 
-                let sugg = if braced_glob {
-                    imports_string
-                } else {
-                    format!("{import_source_snippet}::{imports_string}")
-                };
+            let sugg = if braced_glob {
+                imports_string
+            } else {
+                format!("{import_source_snippet}::{imports_string}")
+            };
 
-                // Glob imports always have a single resolution.
-                let (lint, message) = if let Res::Def(DefKind::Enum, _) = use_path.res[0] {
-                    (ENUM_GLOB_USE, "usage of wildcard import for enum variants")
-                } else {
-                    (WILDCARD_IMPORTS, "usage of wildcard import")
-                };
+            // Glob imports always have a single resolution.
+            let (lint, message) = if let Res::Def(DefKind::Enum, _) = use_path.res[0] {
+                (ENUM_GLOB_USE, "usage of wildcard import for enum variants")
+            } else {
+                (WILDCARD_IMPORTS, "usage of wildcard import")
+            };
 
-                span_lint_and_sugg(
-                    cx,
-                    lint,
-                    span,
-                    message,
-                    "try",
-                    sugg,
-                    applicability,
-                );
-            }
+            span_lint_and_sugg(
+                cx,
+                lint,
+                span,
+                message,
+                "try",
+                sugg,
+                applicability,
+            );
         }
     }
 
diff --git a/clippy_lints/src/zero_div_zero.rs b/clippy_lints/src/zero_div_zero.rs
index f2f0699ef48..7f7d30d03ab 100644
--- a/clippy_lints/src/zero_div_zero.rs
+++ b/clippy_lints/src/zero_div_zero.rs
@@ -32,35 +32,33 @@ declare_lint_pass!(ZeroDiv => [ZERO_DIVIDED_BY_ZERO]);
 impl<'tcx> LateLintPass<'tcx> for ZeroDiv {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         // check for instances of 0.0/0.0
-        if_chain! {
-            if let ExprKind::Binary(ref op, left, right) = expr.kind;
-            if op.node == BinOpKind::Div;
+        if let ExprKind::Binary(ref op, left, right) = expr.kind
+            && op.node == BinOpKind::Div
             // TODO - constant_simple does not fold many operations involving floats.
             // That's probably fine for this lint - it's pretty unlikely that someone would
             // do something like 0.0/(2.0 - 2.0), but it would be nice to warn on that case too.
-            if let Some(lhs_value) = constant_simple(cx, cx.typeck_results(), left);
-            if let Some(rhs_value) = constant_simple(cx, cx.typeck_results(), right);
-            if Constant::F32(0.0) == lhs_value || Constant::F64(0.0) == lhs_value;
-            if Constant::F32(0.0) == rhs_value || Constant::F64(0.0) == rhs_value;
-            then {
-                // since we're about to suggest a use of f32::NAN or f64::NAN,
-                // match the precision of the literals that are given.
-                let float_type = match (lhs_value, rhs_value) {
-                    (Constant::F64(_), _)
-                    | (_, Constant::F64(_)) => "f64",
-                    _ => "f32"
-                };
-                span_lint_and_help(
-                    cx,
-                    ZERO_DIVIDED_BY_ZERO,
-                    expr.span,
-                    "constant division of `0.0` with `0.0` will always result in NaN",
-                    None,
-                    &format!(
-                        "consider using `{float_type}::NAN` if you would like a constant representing NaN",
-                    ),
-                );
-            }
+            && let Some(lhs_value) = constant_simple(cx, cx.typeck_results(), left)
+            && let Some(rhs_value) = constant_simple(cx, cx.typeck_results(), right)
+            && (Constant::F32(0.0) == lhs_value || Constant::F64(0.0) == lhs_value)
+            && (Constant::F32(0.0) == rhs_value || Constant::F64(0.0) == rhs_value)
+        {
+            // since we're about to suggest a use of f32::NAN or f64::NAN,
+            // match the precision of the literals that are given.
+            let float_type = match (lhs_value, rhs_value) {
+                (Constant::F64(_), _)
+                | (_, Constant::F64(_)) => "f64",
+                _ => "f32"
+            };
+            span_lint_and_help(
+                cx,
+                ZERO_DIVIDED_BY_ZERO,
+                expr.span,
+                "constant division of `0.0` with `0.0` will always result in NaN",
+                None,
+                &format!(
+                    "consider using `{float_type}::NAN` if you would like a constant representing NaN",
+                ),
+            );
         }
     }
 }
diff --git a/clippy_lints/src/zero_sized_map_values.rs b/clippy_lints/src/zero_sized_map_values.rs
index fee100fe1ea..6504b0fa5f9 100644
--- a/clippy_lints/src/zero_sized_map_values.rs
+++ b/clippy_lints/src/zero_sized_map_values.rs
@@ -46,23 +46,21 @@ declare_lint_pass!(ZeroSizedMapValues => [ZERO_SIZED_MAP_VALUES]);
 
 impl LateLintPass<'_> for ZeroSizedMapValues {
     fn check_ty(&mut self, cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>) {
-        if_chain! {
-            if !hir_ty.span.from_expansion();
-            if !in_trait_impl(cx, hir_ty.hir_id);
-            let ty = ty_from_hir_ty(cx, hir_ty);
-            if is_type_diagnostic_item(cx, ty, sym::HashMap) || is_type_diagnostic_item(cx, ty, sym::BTreeMap);
-            if let Adt(_, args) = ty.kind();
-            let ty = args.type_at(1);
+        if !hir_ty.span.from_expansion()
+            && !in_trait_impl(cx, hir_ty.hir_id)
+            && let ty = ty_from_hir_ty(cx, hir_ty)
+            && (is_type_diagnostic_item(cx, ty, sym::HashMap) || is_type_diagnostic_item(cx, ty, sym::BTreeMap))
+            && let Adt(_, args) = ty.kind()
+            && let ty = args.type_at(1)
             // Fixes https://github.com/rust-lang/rust-clippy/issues/7447 because of
             // https://github.com/rust-lang/rust/blob/master/compiler/rustc_middle/src/ty/sty.rs#L968
-            if !ty.has_escaping_bound_vars();
+            && !ty.has_escaping_bound_vars()
             // Do this to prevent `layout_of` crashing, being unable to fully normalize `ty`.
-            if is_normalizable(cx, cx.param_env, ty);
-            if let Ok(layout) = cx.layout_of(ty);
-            if layout.is_zst();
-            then {
-                span_lint_and_help(cx, ZERO_SIZED_MAP_VALUES, hir_ty.span, "map with zero-sized value type", None, "consider using a set instead");
-            }
+            && is_normalizable(cx, cx.param_env, ty)
+            && let Ok(layout) = cx.layout_of(ty)
+            && layout.is_zst()
+        {
+            span_lint_and_help(cx, ZERO_SIZED_MAP_VALUES, hir_ty.span, "map with zero-sized value type", None, "consider using a set instead");
         }
     }
 }
diff --git a/clippy_utils/src/consts.rs b/clippy_utils/src/consts.rs
index b7d8c0a8fd7..791f815c850 100644
--- a/clippy_utils/src/consts.rs
+++ b/clippy_utils/src/consts.rs
@@ -372,27 +372,25 @@ impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
             ExprKind::Binary(op, left, right) => self.binop(op, left, right),
             ExprKind::Call(callee, args) => {
                 // We only handle a few const functions for now.
-                if_chain! {
-                    if args.is_empty();
-                    if let ExprKind::Path(qpath) = &callee.kind;
-                    let res = self.typeck_results.qpath_res(qpath, callee.hir_id);
-                    if let Some(def_id) = res.opt_def_id();
-                    let def_path = self.lcx.get_def_path(def_id);
-                    let def_path: Vec<&str> = def_path.iter().take(4).map(Symbol::as_str).collect();
-                    if let ["core", "num", int_impl, "max_value"] = *def_path;
-                    then {
-                        let value = match int_impl {
-                            "<impl i8>" => i8::MAX as u128,
-                            "<impl i16>" => i16::MAX as u128,
-                            "<impl i32>" => i32::MAX as u128,
-                            "<impl i64>" => i64::MAX as u128,
-                            "<impl i128>" => i128::MAX as u128,
-                            _ => return None,
-                        };
-                        Some(Constant::Int(value))
-                    } else {
-                        None
-                    }
+                if args.is_empty()
+                    && let ExprKind::Path(qpath) = &callee.kind
+                    && let res = self.typeck_results.qpath_res(qpath, callee.hir_id)
+                    && let Some(def_id) = res.opt_def_id()
+                    && let def_path = self.lcx.get_def_path(def_id)
+                    && let def_path: Vec<&str> = def_path.iter().take(4).map(Symbol::as_str).collect()
+                    && let ["core", "num", int_impl, "max_value"] = *def_path
+                {
+                    let value = match int_impl {
+                        "<impl i8>" => i8::MAX as u128,
+                        "<impl i16>" => i16::MAX as u128,
+                        "<impl i32>" => i32::MAX as u128,
+                        "<impl i64>" => i64::MAX as u128,
+                        "<impl i128>" => i128::MAX as u128,
+                        _ => return None,
+                    };
+                    Some(Constant::Int(value))
+                } else {
+                    None
                 }
             },
             ExprKind::Index(arr, index, _) => self.index(arr, index),
diff --git a/clippy_utils/src/higher.rs b/clippy_utils/src/higher.rs
index edea4b3667f..93cd5b3fe1e 100644
--- a/clippy_utils/src/higher.rs
+++ b/clippy_utils/src/higher.rs
@@ -30,24 +30,22 @@ pub struct ForLoop<'tcx> {
 impl<'tcx> ForLoop<'tcx> {
     /// Parses a desugared `for` loop
     pub fn hir(expr: &Expr<'tcx>) -> Option<Self> {
-        if_chain! {
-            if let hir::ExprKind::DropTemps(e) = expr.kind;
-            if let hir::ExprKind::Match(iterexpr, [arm], hir::MatchSource::ForLoopDesugar) = e.kind;
-            if let hir::ExprKind::Call(_, [arg]) = iterexpr.kind;
-            if let hir::ExprKind::Loop(block, ..) = arm.body.kind;
-            if let [stmt] = block.stmts;
-            if let hir::StmtKind::Expr(e) = stmt.kind;
-            if let hir::ExprKind::Match(_, [_, some_arm], _) = e.kind;
-            if let hir::PatKind::Struct(_, [field], _) = some_arm.pat.kind;
-            then {
-                return Some(Self {
-                    pat: field.pat,
-                    arg,
-                    body: some_arm.body,
-                    loop_id: arm.body.hir_id,
-                    span: expr.span.ctxt().outer_expn_data().call_site,
-                });
-            }
+        if let hir::ExprKind::DropTemps(e) = expr.kind
+            && let hir::ExprKind::Match(iterexpr, [arm], hir::MatchSource::ForLoopDesugar) = e.kind
+            && let hir::ExprKind::Call(_, [arg]) = iterexpr.kind
+            && let hir::ExprKind::Loop(block, ..) = arm.body.kind
+            && let [stmt] = block.stmts
+            && let hir::StmtKind::Expr(e) = stmt.kind
+            && let hir::ExprKind::Match(_, [_, some_arm], _) = e.kind
+            && let hir::PatKind::Struct(_, [field], _) = some_arm.pat.kind
+        {
+            return Some(Self {
+                pat: field.pat,
+                arg,
+                body: some_arm.body,
+                loop_id: arm.body.hir_id,
+                span: expr.span.ctxt().outer_expn_data().call_site,
+            });
         }
         None
     }
@@ -277,29 +275,27 @@ impl<'a> VecArgs<'a> {
     /// Returns the arguments of the `vec!` macro if this expression was expanded
     /// from `vec!`.
     pub fn hir(cx: &LateContext<'_>, expr: &'a hir::Expr<'_>) -> Option<VecArgs<'a>> {
-        if_chain! {
-            if let hir::ExprKind::Call(fun, args) = expr.kind;
-            if let hir::ExprKind::Path(ref qpath) = fun.kind;
-            if is_expn_of(fun.span, "vec").is_some();
-            if let Some(fun_def_id) = cx.qpath_res(qpath, fun.hir_id).opt_def_id();
-            then {
-                return if match_def_path(cx, fun_def_id, &paths::VEC_FROM_ELEM) && args.len() == 2 {
-                    // `vec![elem; size]` case
-                    Some(VecArgs::Repeat(&args[0], &args[1]))
-                } else if match_def_path(cx, fun_def_id, &paths::SLICE_INTO_VEC) && args.len() == 1 {
-                    // `vec![a, b, c]` case
-                    if let hir::ExprKind::Call(_, [arg]) = &args[0].kind
-                        && let hir::ExprKind::Array(args) = arg.kind {
-                        Some(VecArgs::Vec(args))
-                    } else {
-                        None
-                    }
-                } else if match_def_path(cx, fun_def_id, &paths::VEC_NEW) && args.is_empty() {
-                    Some(VecArgs::Vec(&[]))
+        if let hir::ExprKind::Call(fun, args) = expr.kind
+            && let hir::ExprKind::Path(ref qpath) = fun.kind
+            && is_expn_of(fun.span, "vec").is_some()
+            && let Some(fun_def_id) = cx.qpath_res(qpath, fun.hir_id).opt_def_id()
+        {
+            return if match_def_path(cx, fun_def_id, &paths::VEC_FROM_ELEM) && args.len() == 2 {
+                // `vec![elem; size]` case
+                Some(VecArgs::Repeat(&args[0], &args[1]))
+            } else if match_def_path(cx, fun_def_id, &paths::SLICE_INTO_VEC) && args.len() == 1 {
+                // `vec![a, b, c]` case
+                if let hir::ExprKind::Call(_, [arg]) = &args[0].kind
+                    && let hir::ExprKind::Array(args) = arg.kind {
+                    Some(VecArgs::Vec(args))
                 } else {
                     None
-                };
-            }
+                }
+            } else if match_def_path(cx, fun_def_id, &paths::VEC_NEW) && args.is_empty() {
+                Some(VecArgs::Vec(&[]))
+            } else {
+                None
+            };
         }
 
         None
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 1181dfc0ef9..e3c26525a6a 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -176,14 +176,12 @@ pub fn expr_or_init<'a, 'b, 'tcx: 'b>(cx: &LateContext<'tcx>, mut expr: &'a Expr
 /// canonical binding `HirId`.
 pub fn find_binding_init<'tcx>(cx: &LateContext<'tcx>, hir_id: HirId) -> Option<&'tcx Expr<'tcx>> {
     let hir = cx.tcx.hir();
-    if_chain! {
-        if let Some(Node::Pat(pat)) = hir.find(hir_id);
-        if matches!(pat.kind, PatKind::Binding(BindingAnnotation::NONE, ..));
-        let parent = hir.parent_id(hir_id);
-        if let Some(Node::Local(local)) = hir.find(parent);
-        then {
-            return local.init;
-        }
+    if let Some(Node::Pat(pat)) = hir.find(hir_id)
+        && matches!(pat.kind, PatKind::Binding(BindingAnnotation::NONE, ..))
+        && let parent = hir.parent_id(hir_id)
+        && let Some(Node::Local(local)) = hir.find(parent)
+    {
+        return local.init;
     }
     None
 }
@@ -713,13 +711,11 @@ pub fn trait_ref_of_method<'tcx>(cx: &LateContext<'tcx>, def_id: LocalDefId) ->
     // Get the implemented trait for the current function
     let hir_id = cx.tcx.hir().local_def_id_to_hir_id(def_id);
     let parent_impl = cx.tcx.hir().get_parent_item(hir_id);
-    if_chain! {
-        if parent_impl != hir::CRATE_OWNER_ID;
-        if let hir::Node::Item(item) = cx.tcx.hir().get_by_def_id(parent_impl.def_id);
-        if let hir::ItemKind::Impl(impl_) = &item.kind;
-        then {
-            return impl_.of_trait.as_ref();
-        }
+    if parent_impl != hir::CRATE_OWNER_ID
+        && let hir::Node::Item(item) = cx.tcx.hir().get_by_def_id(parent_impl.def_id)
+        && let hir::ItemKind::Impl(impl_) = &item.kind
+    {
+        return impl_.of_trait.as_ref();
     }
     None
 }
@@ -823,13 +819,11 @@ fn is_default_equivalent_ctor(cx: &LateContext<'_>, def_id: DefId, path: &QPath<
 
 /// Returns true if the expr is equal to `Default::default` when evaluated.
 pub fn is_default_equivalent_call(cx: &LateContext<'_>, repl_func: &Expr<'_>) -> bool {
-    if_chain! {
-        if let hir::ExprKind::Path(ref repl_func_qpath) = repl_func.kind;
-        if let Some(repl_def_id) = cx.qpath_res(repl_func_qpath, repl_func.hir_id).opt_def_id();
-        if is_diag_trait_item(cx, repl_def_id, sym::Default)
-            || is_default_equivalent_ctor(cx, repl_def_id, repl_func_qpath);
-        then { true } else { false }
-    }
+    if let hir::ExprKind::Path(ref repl_func_qpath) = repl_func.kind
+        && let Some(repl_def_id) = cx.qpath_res(repl_func_qpath, repl_func.hir_id).opt_def_id()
+        && (is_diag_trait_item(cx, repl_def_id, sym::Default)
+            || is_default_equivalent_ctor(cx, repl_def_id, repl_func_qpath))
+    { true } else { false }
 }
 
 /// Returns true if the expr is equal to `Default::default()` of it's type when evaluated.
@@ -843,16 +837,14 @@ pub fn is_default_equivalent(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
             _ => false,
         },
         ExprKind::Tup(items) | ExprKind::Array(items) => items.iter().all(|x| is_default_equivalent(cx, x)),
-        ExprKind::Repeat(x, ArrayLen::Body(len)) => if_chain! {
-            if let ExprKind::Lit(const_lit) = cx.tcx.hir().body(len.body).value.kind;
-            if let LitKind::Int(v, _) = const_lit.node;
-            if v <= 32 && is_default_equivalent(cx, x);
-            then {
-                true
-            }
-            else {
-                false
-            }
+        ExprKind::Repeat(x, ArrayLen::Body(len)) => if let ExprKind::Lit(const_lit) = cx.tcx.hir().body(len.body).value.kind
+            && let LitKind::Int(v, _) = const_lit.node
+            && v <= 32 && is_default_equivalent(cx, x)
+        {
+            true
+        }
+        else {
+            false
         },
         ExprKind::Call(repl_func, []) => is_default_equivalent_call(cx, repl_func),
         ExprKind::Call(from_func, [ref arg]) => is_default_equivalent_from(cx, from_func, arg),
@@ -1736,15 +1728,13 @@ pub fn iter_input_pats<'tcx>(decl: &FnDecl<'_>, body: &'tcx Body<'_>) -> impl It
 /// operator or the `try` macro.
 pub fn is_try<'tcx>(cx: &LateContext<'_>, expr: &'tcx Expr<'tcx>) -> Option<&'tcx Expr<'tcx>> {
     fn is_ok(cx: &LateContext<'_>, arm: &Arm<'_>) -> bool {
-        if_chain! {
-            if let PatKind::TupleStruct(ref path, pat, ddpos) = arm.pat.kind;
-            if ddpos.as_opt_usize().is_none();
-            if is_res_lang_ctor(cx, cx.qpath_res(path, arm.pat.hir_id), ResultOk);
-            if let PatKind::Binding(_, hir_id, _, None) = pat[0].kind;
-            if path_to_local_id(arm.body, hir_id);
-            then {
-                return true;
-            }
+        if let PatKind::TupleStruct(ref path, pat, ddpos) = arm.pat.kind
+            && ddpos.as_opt_usize().is_none()
+            && is_res_lang_ctor(cx, cx.qpath_res(path, arm.pat.hir_id), ResultOk)
+            && let PatKind::Binding(_, hir_id, _, None) = pat[0].kind
+            && path_to_local_id(arm.body, hir_id)
+        {
+            return true;
         }
         false
     }
@@ -1763,14 +1753,12 @@ pub fn is_try<'tcx>(cx: &LateContext<'_>, expr: &'tcx Expr<'tcx>) -> Option<&'tc
             return Some(expr);
         }
 
-        if_chain! {
-            if arms.len() == 2;
-            if arms[0].guard.is_none();
-            if arms[1].guard.is_none();
-            if (is_ok(cx, &arms[0]) && is_err(cx, &arms[1])) || (is_ok(cx, &arms[1]) && is_err(cx, &arms[0]));
-            then {
-                return Some(expr);
-            }
+        if arms.len() == 2
+            && arms[0].guard.is_none()
+            && arms[1].guard.is_none()
+            && ((is_ok(cx, &arms[0]) && is_err(cx, &arms[1])) || (is_ok(cx, &arms[1]) && is_err(cx, &arms[0])))
+        {
+            return Some(expr);
         }
     }
 
@@ -1887,14 +1875,12 @@ pub fn match_function_call<'tcx>(
     expr: &'tcx Expr<'_>,
     path: &[&str],
 ) -> Option<&'tcx [Expr<'tcx>]> {
-    if_chain! {
-        if let ExprKind::Call(fun, args) = expr.kind;
-        if let ExprKind::Path(ref qpath) = fun.kind;
-        if let Some(fun_def_id) = cx.qpath_res(qpath, fun.hir_id).opt_def_id();
-        if match_def_path(cx, fun_def_id, path);
-        then {
-            return Some(args);
-        }
+    if let ExprKind::Call(fun, args) = expr.kind
+        && let ExprKind::Path(ref qpath) = fun.kind
+        && let Some(fun_def_id) = cx.qpath_res(qpath, fun.hir_id).opt_def_id()
+        && match_def_path(cx, fun_def_id, path)
+    {
+        return Some(args);
     };
     None
 }
@@ -1904,13 +1890,11 @@ pub fn match_function_call_with_def_id<'tcx>(
     expr: &'tcx Expr<'_>,
     fun_def_id: DefId,
 ) -> Option<&'tcx [Expr<'tcx>]> {
-    if_chain! {
-        if let ExprKind::Call(fun, args) = expr.kind;
-        if let ExprKind::Path(ref qpath) = fun.kind;
-        if cx.qpath_res(qpath, fun.hir_id).opt_def_id() == Some(fun_def_id);
-        then {
-            return Some(args);
-        }
+    if let ExprKind::Call(fun, args) = expr.kind
+        && let ExprKind::Path(ref qpath) = fun.kind
+        && cx.qpath_res(qpath, fun.hir_id).opt_def_id() == Some(fun_def_id)
+    {
+        return Some(args);
     };
     None
 }
@@ -2008,14 +1992,12 @@ pub fn get_async_fn_body<'tcx>(tcx: TyCtxt<'tcx>, body: &Body<'_>) -> Option<&'t
 // check if expr is calling method or function with #[must_use] attribute
 pub fn is_must_use_func_call(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
     let did = match expr.kind {
-        ExprKind::Call(path, _) => if_chain! {
-            if let ExprKind::Path(ref qpath) = path.kind;
-            if let def::Res::Def(_, did) = cx.qpath_res(qpath, path.hir_id);
-            then {
-                Some(did)
-            } else {
-                None
-            }
+        ExprKind::Call(path, _) => if let ExprKind::Path(ref qpath) = path.kind
+            && let def::Res::Def(_, did) = cx.qpath_res(qpath, path.hir_id)
+        {
+            Some(did)
+        } else {
+            None
         },
         ExprKind::MethodCall(..) => cx.typeck_results().type_dependent_def_id(expr.hir_id),
         _ => None,
@@ -2071,14 +2053,12 @@ fn is_body_identity_function(cx: &LateContext<'_>, func: &Body<'_>) -> bool {
                 },
                 _,
             ) => {
-                if_chain! {
-                    if let StmtKind::Semi(e) | StmtKind::Expr(e) = stmt.kind;
-                    if let ExprKind::Ret(Some(ret_val)) = e.kind;
-                    then {
-                        expr = ret_val;
-                    } else {
-                        return false;
-                    }
+                if let StmtKind::Semi(e) | StmtKind::Expr(e) = stmt.kind
+                    && let ExprKind::Ret(Some(ret_val)) = e.kind
+                {
+                    expr = ret_val;
+                } else {
+                    return false;
                 }
             },
             _ => return check_pat(cx, param.pat, expr),
-- 
cgit 1.4.1-3-g733a5


From 13b4bb12ad6ef84dea53c5a2547473b3d4ab93e3 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Thu, 2 Nov 2023 19:23:36 +0000
Subject: Clean up after if chain removal

---
 clippy_lints/Cargo.toml                            |   1 -
 clippy_lints/src/attrs.rs                          |   1 -
 clippy_lints/src/blocks_in_if_conditions.rs        |   1 -
 clippy_lints/src/booleans.rs                       |   1 -
 clippy_lints/src/borrow_deref_ref.rs               |  37 +++--
 clippy_lints/src/cargo/multiple_crate_versions.rs  |  11 +-
 clippy_lints/src/cargo/wildcard_dependencies.rs    |   1 -
 clippy_lints/src/casts/cast_sign_loss.rs           |   1 -
 .../src/casts/cast_slice_different_sizes.rs        |   1 -
 .../src/casts/cast_slice_from_raw_parts.rs         |   5 +-
 clippy_lints/src/casts/char_lit_as_u8.rs           |   4 +-
 clippy_lints/src/casts/ptr_cast_constness.rs       |  17 ++-
 clippy_lints/src/casts/unnecessary_cast.rs         |  16 ++-
 clippy_lints/src/checked_conversions.rs            |  15 +-
 clippy_lints/src/collapsible_if.rs                 |  43 +++---
 clippy_lints/src/copy_iterator.rs                  |   8 +-
 clippy_lints/src/crate_in_macro_def.rs             |  14 +-
 clippy_lints/src/create_dir.rs                     |   3 +-
 clippy_lints/src/declared_lints.rs                 |   2 -
 clippy_lints/src/default.rs                        |   1 -
 .../src/default_constructed_unit_structs.rs        |   2 +-
 clippy_lints/src/default_numeric_fallback.rs       |  80 +++++------
 clippy_lints/src/derivable_impls.rs                |  64 ++++-----
 clippy_lints/src/derive.rs                         |  35 ++---
 clippy_lints/src/doc.rs                            |  33 ++---
 clippy_lints/src/empty_drop.rs                     |  14 +-
 clippy_lints/src/exhaustive_items.rs               |  28 ++--
 clippy_lints/src/exit.rs                           |   1 -
 clippy_lints/src/explicit_write.rs                 |   1 -
 clippy_lints/src/fallible_impl_from.rs             |  14 +-
 clippy_lints/src/float_literal.rs                  |   4 +-
 clippy_lints/src/floating_point_arithmetic.rs      | 160 ++++++++++++++-------
 clippy_lints/src/format_args.rs                    |   9 +-
 clippy_lints/src/format_impl.rs                    |  15 +-
 clippy_lints/src/formatting.rs                     |  15 +-
 clippy_lints/src/from_str_radix_10.rs              |  18 +--
 clippy_lints/src/functions/misnamed_getters.rs     |   2 +-
 clippy_lints/src/functions/result.rs               |  21 +--
 clippy_lints/src/if_let_mutex.rs                   |   1 -
 clippy_lints/src/implicit_hasher.rs                |   8 +-
 clippy_lints/src/implicit_saturating_add.rs        |  29 +++-
 clippy_lints/src/implicit_saturating_sub.rs        |   8 +-
 .../src/inconsistent_struct_constructor.rs         |  16 +--
 clippy_lints/src/index_refutable_slice.rs          |   4 +-
 clippy_lints/src/instant_subtraction.rs            |  20 +--
 clippy_lints/src/large_const_arrays.rs             |   4 +-
 clippy_lints/src/large_include_file.rs             |   2 +-
 clippy_lints/src/len_zero.rs                       |  11 +-
 clippy_lints/src/let_if_seq.rs                     |  61 +++++---
 clippy_lints/src/let_with_type_underscore.rs       |   4 +-
 clippy_lints/src/lib.rs                            |   1 -
 clippy_lints/src/lifetimes.rs                      |   1 -
 clippy_lints/src/literal_representation.rs         |  31 ++--
 clippy_lints/src/loops/explicit_counter_loop.rs    |   3 +-
 clippy_lints/src/loops/manual_find.rs              |  21 +--
 clippy_lints/src/loops/manual_flatten.rs           |  38 ++---
 clippy_lints/src/loops/manual_memcpy.rs            |  26 +++-
 clippy_lints/src/loops/missing_spin_loop.rs        |  12 +-
 clippy_lints/src/loops/mut_range_bound.rs          |   9 +-
 clippy_lints/src/loops/needless_range_loop.rs      |   1 -
 clippy_lints/src/loops/same_item_push.rs           |   9 +-
 clippy_lints/src/loops/single_element_loop.rs      |  13 +-
 clippy_lints/src/loops/utils.rs                    |   3 +-
 .../src/loops/while_immutable_condition.rs         |   1 -
 clippy_lints/src/loops/while_let_on_iterator.rs    |  73 +++++-----
 clippy_lints/src/macro_use.rs                      |   7 +-
 clippy_lints/src/main_recursion.rs                 |   5 +-
 clippy_lints/src/manual_async_fn.rs                |   5 +-
 clippy_lints/src/manual_bits.rs                    |   8 +-
 clippy_lints/src/manual_strip.rs                   |  47 +++---
 clippy_lints/src/map_unit_fn.rs                    |   1 -
 clippy_lints/src/match_result_ok.rs                |   1 -
 clippy_lints/src/matches/collapsible_match.rs      |  28 ++--
 .../src/matches/infallible_destructuring_match.rs  |   7 +-
 clippy_lints/src/matches/manual_filter.rs          |  16 ++-
 clippy_lints/src/matches/manual_unwrap_or.rs       |  39 +++--
 clippy_lints/src/matches/match_as_ref.rs           |   5 +-
 clippy_lints/src/matches/match_like_matches.rs     |  15 +-
 clippy_lints/src/matches/match_on_vec_items.rs     |  11 +-
 .../src/matches/match_str_case_mismatch.rs         |  11 +-
 clippy_lints/src/matches/match_wild_err_arm.rs     |   3 +-
 .../src/matches/redundant_pattern_match.rs         |   1 -
 .../src/matches/rest_pat_in_fully_bound_struct.rs  |   1 -
 clippy_lints/src/matches/single_match.rs           |  12 +-
 clippy_lints/src/matches/try_err.rs                |   4 -
 clippy_lints/src/mem_replace.rs                    |   6 +-
 clippy_lints/src/methods/bind_instead_of_map.rs    |  25 ++--
 clippy_lints/src/methods/bytecount.rs              |  16 +--
 clippy_lints/src/methods/bytes_count_to_len.rs     |   8 +-
 .../case_sensitive_file_extension_comparisons.rs   |  16 ++-
 clippy_lints/src/methods/chars_cmp.rs              |  11 +-
 clippy_lints/src/methods/chars_cmp_with_unwrap.rs  |  11 +-
 clippy_lints/src/methods/err_expect.rs             |   5 +-
 clippy_lints/src/methods/extend_with_drain.rs      |   1 -
 clippy_lints/src/methods/filetype_is_file.rs       |   1 -
 clippy_lints/src/methods/filter_map.rs             |  34 +++--
 .../src/methods/from_iter_instead_of_collect.rs    |  16 ++-
 clippy_lints/src/methods/get_first.rs              |  30 ++--
 clippy_lints/src/methods/implicit_clone.rs         |   1 -
 clippy_lints/src/methods/inefficient_to_string.rs  |   4 +-
 clippy_lints/src/methods/into_iter_on_ref.rs       |   5 +-
 clippy_lints/src/methods/iter_cloned_collect.rs    |   8 +-
 clippy_lints/src/methods/iter_kv_map.rs            |  30 ++--
 clippy_lints/src/methods/iter_next_slice.rs        |  18 ++-
 clippy_lints/src/methods/iter_skip_next.rs         |   2 +-
 clippy_lints/src/methods/manual_ok_or.rs           |   5 +-
 .../src/methods/manual_saturating_arithmetic.rs    |   3 +-
 clippy_lints/src/methods/manual_str_repeat.rs      |  20 +--
 clippy_lints/src/methods/map_clone.rs              |  39 ++---
 .../src/methods/map_collect_result_unit.rs         |   3 +-
 clippy_lints/src/methods/map_identity.rs           |   6 +-
 clippy_lints/src/methods/mod.rs                    |   6 +-
 clippy_lints/src/methods/mut_mutex_lock.rs         |   1 -
 clippy_lints/src/methods/no_effect_replace.rs      |   3 -
 clippy_lints/src/methods/ok_expect.rs              |   2 -
 clippy_lints/src/methods/option_as_ref_deref.rs    |   1 -
 clippy_lints/src/methods/or_fun_call.rs            |   6 -
 .../src/methods/path_buf_push_overwrite.rs         |   1 -
 clippy_lints/src/methods/range_zip_with_len.rs     |  10 +-
 clippy_lints/src/methods/search_is_some.rs         |   5 +-
 clippy_lints/src/methods/single_char_pattern.rs    |   4 +-
 clippy_lints/src/methods/str_splitn.rs             |  23 ++-
 clippy_lints/src/methods/suspicious_map.rs         |   1 -
 clippy_lints/src/methods/suspicious_splitn.rs      |  30 ++--
 clippy_lints/src/methods/suspicious_to_owned.rs    |   8 +-
 clippy_lints/src/methods/uninit_assumed_init.rs    |   3 +-
 clippy_lints/src/methods/unnecessary_fold.rs       |   7 +-
 .../src/methods/unnecessary_iter_cloned.rs         |   7 +-
 clippy_lints/src/methods/unnecessary_sort_by.rs    |  48 +++++--
 clippy_lints/src/methods/useless_asref.rs          |   1 -
 clippy_lints/src/methods/utils.rs                  |  14 +-
 clippy_lints/src/methods/vec_resize_to_zero.rs     |  10 +-
 clippy_lints/src/methods/zst_offset.rs             |   1 -
 clippy_lints/src/misc.rs                           |  16 +--
 clippy_lints/src/mismatching_type_param_order.rs   |  44 +++---
 clippy_lints/src/missing_doc.rs                    |   1 -
 clippy_lints/src/missing_enforced_import_rename.rs |   4 +-
 clippy_lints/src/mixed_read_write_in_expression.rs |   7 +-
 clippy_lints/src/needless_arbitrary_self_type.rs   |   5 +-
 clippy_lints/src/needless_for_each.rs              |   4 +-
 clippy_lints/src/needless_late_init.rs             |  13 +-
 .../src/needless_parens_on_range_literals.rs       |   8 +-
 clippy_lints/src/needless_pass_by_value.rs         |  56 ++++----
 clippy_lints/src/needless_question_mark.rs         |   1 -
 clippy_lints/src/neg_cmp_op_on_partial_ord.rs      |   2 -
 clippy_lints/src/neg_multiply.rs                   |  18 ++-
 clippy_lints/src/new_without_default.rs            |   3 +-
 clippy_lints/src/no_effect.rs                      |  15 +-
 clippy_lints/src/non_copy_const.rs                 |   8 +-
 clippy_lints/src/non_octal_unix_permissions.rs     |   9 +-
 clippy_lints/src/non_send_fields_in_send_ty.rs     |  17 ++-
 clippy_lints/src/nonstandard_macro_braces.rs       |   1 -
 clippy_lints/src/operators/assign_op_pattern.rs    |   4 +-
 clippy_lints/src/operators/const_comparisons.rs    |  17 ++-
 clippy_lints/src/operators/float_cmp.rs            |   5 +-
 .../src/operators/float_equality_without_abs.rs    |  18 +--
 clippy_lints/src/operators/modulo_arithmetic.rs    |   4 +-
 clippy_lints/src/operators/op_ref.rs               |   9 +-
 clippy_lints/src/operators/ptr_eq.rs               |   3 +-
 clippy_lints/src/option_if_let_else.rs             |  45 ++++--
 clippy_lints/src/overflow_check_conditional.rs     |   1 -
 clippy_lints/src/partialeq_ne_impl.rs              |   7 +-
 clippy_lints/src/pass_by_ref_or_value.rs           |   6 +-
 clippy_lints/src/precedence.rs                     |   1 -
 clippy_lints/src/question_mark.rs                  |  19 ++-
 clippy_lints/src/ranges.rs                         |  24 ++--
 clippy_lints/src/rc_clone_in_vec_init.rs           |   4 +-
 clippy_lints/src/redundant_clone.rs                |  32 ++---
 clippy_lints/src/redundant_closure_call.rs         |   3 +-
 clippy_lints/src/redundant_pub_crate.rs            |   3 +-
 clippy_lints/src/redundant_slicing.rs              |  22 +--
 clippy_lints/src/ref_option_ref.rs                 |   5 +-
 clippy_lints/src/reference.rs                      |  19 ++-
 clippy_lints/src/return_self_not_must_use.rs       |   4 +-
 clippy_lints/src/returns.rs                        |   6 +-
 clippy_lints/src/same_name_method.rs               |  11 +-
 clippy_lints/src/self_named_constructors.rs        |   4 +-
 clippy_lints/src/semicolon_if_nothing_returned.rs  |   4 +-
 clippy_lints/src/size_of_in_element_count.rs       |  15 +-
 clippy_lints/src/slow_vector_initialization.rs     |   6 +-
 clippy_lints/src/strings.rs                        |  14 +-
 clippy_lints/src/strlen_on_c_strings.rs            |  10 +-
 clippy_lints/src/suspicious_doc_comments.rs        |   3 +-
 clippy_lints/src/suspicious_operation_groupings.rs |  41 ++----
 clippy_lints/src/suspicious_trait_impl.rs          |   7 +-
 clippy_lints/src/swap.rs                           |   2 -
 clippy_lints/src/to_digit_is_some.rs               |  13 +-
 clippy_lints/src/trait_bounds.rs                   |  57 +++++---
 clippy_lints/src/transmute/mod.rs                  |   7 +-
 .../src/transmute/transmute_float_to_int.rs        |   3 +-
 clippy_lints/src/transmute/transmute_ref_to_ref.rs |  50 +++----
 clippy_lints/src/types/borrowed_box.rs             |   1 -
 clippy_lints/src/types/box_collection.rs           |   6 +-
 clippy_lints/src/types/option_option.rs            |   1 -
 clippy_lints/src/types/rc_mutex.rs                 |   3 +-
 clippy_lints/src/types/utils.rs                    |   1 -
 clippy_lints/src/uninit_vec.rs                     |   2 +-
 clippy_lints/src/unit_return_expecting_ord.rs      |   3 +-
 clippy_lints/src/unit_types/unit_arg.rs            |   9 +-
 clippy_lints/src/unnamed_address.rs                |   4 +-
 .../src/unnecessary_owned_empty_strings.rs         |  55 ++++---
 clippy_lints/src/unnecessary_self_imports.rs       |   8 +-
 clippy_lints/src/unnecessary_wraps.rs              |  19 ++-
 clippy_lints/src/unused_self.rs                    |   1 -
 clippy_lints/src/unused_unit.rs                    |   8 +-
 clippy_lints/src/unwrap.rs                         |  68 +++++----
 clippy_lints/src/unwrap_in_result.rs               |   1 -
 clippy_lints/src/use_self.rs                       |  36 +++--
 clippy_lints/src/useless_conversion.rs             |  14 +-
 clippy_lints/src/utils/internal_lints.rs           |   1 -
 .../src/utils/internal_lints/collapsible_calls.rs  |   1 -
 .../internal_lints/compiler_lint_functions.rs      |   1 -
 .../src/utils/internal_lints/if_chain_style.rs     | 160 ---------------------
 .../internal_lints/interning_defined_symbol.rs     |   7 +-
 .../src/utils/internal_lints/invalid_paths.rs      |   1 -
 .../utils/internal_lints/lint_without_lint_pass.rs |   7 +-
 .../src/utils/internal_lints/metadata_collector.rs |   2 -
 .../src/utils/internal_lints/msrv_attr_impl.rs     |  14 +-
 .../utils/internal_lints/outer_expn_data_pass.rs   |   1 -
 .../utils/internal_lints/unnecessary_def_path.rs   |   3 +-
 clippy_lints/src/vec.rs                            |   1 -
 clippy_lints/src/wildcard_imports.rs               |  20 +--
 clippy_lints/src/zero_div_zero.rs                  |  10 +-
 clippy_lints/src/zero_sized_map_values.rs          |  10 +-
 clippy_utils/Cargo.toml                            |   1 -
 clippy_utils/src/consts.rs                         |   4 +-
 clippy_utils/src/higher.rs                         |   5 +-
 clippy_utils/src/lib.rs                            |  39 ++---
 tests/ui-internal/if_chain_style.rs                |  97 -------------
 tests/ui-internal/if_chain_style.stderr            |  86 -----------
 230 files changed, 1455 insertions(+), 1848 deletions(-)
 delete mode 100644 clippy_lints/src/utils/internal_lints/if_chain_style.rs
 delete mode 100644 tests/ui-internal/if_chain_style.rs
 delete mode 100644 tests/ui-internal/if_chain_style.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/Cargo.toml b/clippy_lints/Cargo.toml
index 4bc27fd48e2..a4116603688 100644
--- a/clippy_lints/Cargo.toml
+++ b/clippy_lints/Cargo.toml
@@ -14,7 +14,6 @@ cargo_metadata = "0.15.3"
 clippy_config = { path = "../clippy_config" }
 clippy_utils = { path = "../clippy_utils" }
 declare_clippy_lint = { path = "../declare_clippy_lint" }
-if_chain = "1.0"
 itertools = "0.10.1"
 quine-mc_cluskey = "0.2"
 regex-syntax = "0.7"
diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs
index 112ded59e13..240ff859764 100644
--- a/clippy_lints/src/attrs.rs
+++ b/clippy_lints/src/attrs.rs
@@ -5,7 +5,6 @@ use clippy_utils::diagnostics::{span_lint, span_lint_and_help, span_lint_and_sug
 use clippy_utils::is_from_proc_macro;
 use clippy_utils::macros::{is_panic, macro_backtrace};
 use clippy_utils::source::{first_line_of_span, is_present_in_source, snippet_opt, without_block_comments};
-use if_chain::if_chain;
 use rustc_ast::token::{Token, TokenKind};
 use rustc_ast::tokenstream::TokenTree;
 use rustc_ast::{
diff --git a/clippy_lints/src/blocks_in_if_conditions.rs b/clippy_lints/src/blocks_in_if_conditions.rs
index 9ad68f115ea..28bd3fc7011 100644
--- a/clippy_lints/src/blocks_in_if_conditions.rs
+++ b/clippy_lints/src/blocks_in_if_conditions.rs
@@ -4,7 +4,6 @@ use clippy_utils::ty::implements_trait;
 use clippy_utils::visitors::{for_each_expr, Descend};
 use clippy_utils::{get_parent_expr, higher};
 use core::ops::ControlFlow;
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{BlockCheckMode, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
diff --git a/clippy_lints/src/booleans.rs b/clippy_lints/src/booleans.rs
index 69550f6879a..66fd64c1cd0 100644
--- a/clippy_lints/src/booleans.rs
+++ b/clippy_lints/src/booleans.rs
@@ -2,7 +2,6 @@ use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_hir_and_then};
 use clippy_utils::eq_expr_value;
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::{implements_trait, is_type_diagnostic_item};
-use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_expr, FnKind, Visitor};
diff --git a/clippy_lints/src/borrow_deref_ref.rs b/clippy_lints/src/borrow_deref_ref.rs
index 33b7bde3a41..789cd3b6c21 100644
--- a/clippy_lints/src/borrow_deref_ref.rs
+++ b/clippy_lints/src/borrow_deref_ref.rs
@@ -54,25 +54,25 @@ impl<'tcx> LateLintPass<'tcx> for BorrowDerefRef {
             && !addrof_target.span.from_expansion()
             && let ExprKind::Unary(UnOp::Deref, deref_target) = addrof_target.kind
             && !deref_target.span.from_expansion()
-            && !matches!(deref_target.kind, ExprKind::Unary(UnOp::Deref, ..) )
+            && !matches!(deref_target.kind, ExprKind::Unary(UnOp::Deref, ..))
             && let ref_ty = cx.typeck_results().expr_ty(deref_target)
             && let ty::Ref(_, inner_ty, Mutability::Not) = ref_ty.kind()
             && !is_from_proc_macro(cx, e)
         {
-
-            if let Some(parent_expr) = get_parent_expr(cx, e){
-                if matches!(parent_expr.kind, ExprKind::Unary(UnOp::Deref, ..)) &&
-                   !is_lint_allowed(cx, DEREF_ADDROF, parent_expr.hir_id) {
+            if let Some(parent_expr) = get_parent_expr(cx, e) {
+                if matches!(parent_expr.kind, ExprKind::Unary(UnOp::Deref, ..))
+                    && !is_lint_allowed(cx, DEREF_ADDROF, parent_expr.hir_id)
+                {
                     return;
                 }
 
                 // modification to `&mut &*x` is different from `&mut x`
-                if matches!(deref_target.kind, ExprKind::Path(..)
-                                         | ExprKind::Field(..)
-                                         | ExprKind::Index(..)
-                                         | ExprKind::Unary(UnOp::Deref, ..))
-                 && matches!(parent_expr.kind, ExprKind::AddrOf(_, Mutability::Mut, _)) {
-                   return;
+                if matches!(
+                    deref_target.kind,
+                    ExprKind::Path(..) | ExprKind::Field(..) | ExprKind::Index(..) | ExprKind::Unary(UnOp::Deref, ..)
+                ) && matches!(parent_expr.kind, ExprKind::AddrOf(_, Mutability::Mut, _))
+                {
+                    return;
                 }
             }
 
@@ -86,12 +86,12 @@ impl<'tcx> LateLintPass<'tcx> for BorrowDerefRef {
                         e.span,
                         "if you would like to reborrow, try removing `&*`",
                         snippet_opt(cx, deref_target.span).unwrap(),
-                        Applicability::MachineApplicable
+                        Applicability::MachineApplicable,
                     );
 
                     // has deref trait -> give 2 help
                     // doesn't have deref trait -> give 1 help
-                    if let Some(deref_trait_id) = cx.tcx.lang_items().deref_trait(){
+                    if let Some(deref_trait_id) = cx.tcx.lang_items().deref_trait() {
                         if !implements_trait(cx, *inner_ty, deref_trait_id, &[]) {
                             return;
                         }
@@ -100,16 +100,11 @@ impl<'tcx> LateLintPass<'tcx> for BorrowDerefRef {
                     diag.span_suggestion(
                         e.span,
                         "if you would like to deref, try using `&**`",
-                        format!(
-                            "&**{}",
-                            &snippet_opt(cx, deref_target.span).unwrap(),
-                         ),
-                        Applicability::MaybeIncorrect
+                        format!("&**{}", &snippet_opt(cx, deref_target.span).unwrap()),
+                        Applicability::MaybeIncorrect,
                     );
-
-                }
+                },
             );
-
         }
     }
 }
diff --git a/clippy_lints/src/cargo/multiple_crate_versions.rs b/clippy_lints/src/cargo/multiple_crate_versions.rs
index 446b1f961b9..473646d00d5 100644
--- a/clippy_lints/src/cargo/multiple_crate_versions.rs
+++ b/clippy_lints/src/cargo/multiple_crate_versions.rs
@@ -2,7 +2,6 @@
 
 use cargo_metadata::{DependencyKind, Metadata, Node, Package, PackageId};
 use clippy_utils::diagnostics::span_lint;
-use if_chain::if_chain;
 use itertools::Itertools;
 use rustc_hir::def_id::LOCAL_CRATE;
 use rustc_lint::LateContext;
@@ -16,9 +15,13 @@ pub(super) fn check(cx: &LateContext<'_>, metadata: &Metadata) {
     packages.sort_by(|a, b| a.name.cmp(&b.name));
 
     if let Some(resolve) = &metadata.resolve
-        && let Some(local_id) = packages
-            .iter()
-            .find_map(|p| if p.name == local_name.as_str() { Some(&p.id) } else { None })
+        && let Some(local_id) = packages.iter().find_map(|p| {
+            if p.name == local_name.as_str() {
+                Some(&p.id)
+            } else {
+                None
+            }
+        })
     {
         for (name, group) in &packages.iter().group_by(|p| p.name.clone()) {
             let group: Vec<&Package> = group.collect();
diff --git a/clippy_lints/src/cargo/wildcard_dependencies.rs b/clippy_lints/src/cargo/wildcard_dependencies.rs
index f255963e480..3b7546dfd31 100644
--- a/clippy_lints/src/cargo/wildcard_dependencies.rs
+++ b/clippy_lints/src/cargo/wildcard_dependencies.rs
@@ -1,6 +1,5 @@
 use cargo_metadata::Metadata;
 use clippy_utils::diagnostics::span_lint;
-use if_chain::if_chain;
 use rustc_lint::LateContext;
 use rustc_span::source_map::DUMMY_SP;
 
diff --git a/clippy_lints/src/casts/cast_sign_loss.rs b/clippy_lints/src/casts/cast_sign_loss.rs
index 71a2581613d..bd12ee40628 100644
--- a/clippy_lints/src/casts/cast_sign_loss.rs
+++ b/clippy_lints/src/casts/cast_sign_loss.rs
@@ -1,7 +1,6 @@
 use clippy_utils::consts::{constant, Constant};
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::{method_chain_args, sext};
-use if_chain::if_chain;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::LateContext;
 use rustc_middle::ty::{self, Ty};
diff --git a/clippy_lints/src/casts/cast_slice_different_sizes.rs b/clippy_lints/src/casts/cast_slice_different_sizes.rs
index 6eae45e6c7b..2a9f7fec172 100644
--- a/clippy_lints/src/casts/cast_slice_different_sizes.rs
+++ b/clippy_lints/src/casts/cast_slice_different_sizes.rs
@@ -1,7 +1,6 @@
 use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source;
-use if_chain::if_chain;
 use rustc_ast::Mutability;
 use rustc_hir::{Expr, ExprKind, Node};
 use rustc_lint::LateContext;
diff --git a/clippy_lints/src/casts/cast_slice_from_raw_parts.rs b/clippy_lints/src/casts/cast_slice_from_raw_parts.rs
index bacbea39768..3db1e3e6d97 100644
--- a/clippy_lints/src/casts/cast_slice_from_raw_parts.rs
+++ b/clippy_lints/src/casts/cast_slice_from_raw_parts.rs
@@ -1,7 +1,6 @@
 use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_context;
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::def_id::DefId;
 use rustc_hir::{Expr, ExprKind};
@@ -37,7 +36,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_expr: &Expr<'_>,
     {
         let func = match rpk {
             RawPartsKind::Immutable => "from_raw_parts",
-            RawPartsKind::Mutable => "from_raw_parts_mut"
+            RawPartsKind::Mutable => "from_raw_parts_mut",
         };
         let span = expr.span;
         let mut applicability = Applicability::MachineApplicable;
@@ -50,7 +49,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_expr: &Expr<'_>,
             &format!("casting the result of `{func}` to {cast_to}"),
             "replace with",
             format!("core::ptr::slice_{func}({ptr}, {len})"),
-            applicability
+            applicability,
         );
     }
 }
diff --git a/clippy_lints/src/casts/char_lit_as_u8.rs b/clippy_lints/src/casts/char_lit_as_u8.rs
index 802f2614796..a7d3868f76c 100644
--- a/clippy_lints/src/casts/char_lit_as_u8.rs
+++ b/clippy_lints/src/casts/char_lit_as_u8.rs
@@ -1,6 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet_with_applicability;
-use if_chain::if_chain;
 use rustc_ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
@@ -34,6 +33,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>) {
                         applicability,
                     );
                 }
-        });
+            },
+        );
     }
 }
diff --git a/clippy_lints/src/casts/ptr_cast_constness.rs b/clippy_lints/src/casts/ptr_cast_constness.rs
index 68a409824e7..ff069860a11 100644
--- a/clippy_lints/src/casts/ptr_cast_constness.rs
+++ b/clippy_lints/src/casts/ptr_cast_constness.rs
@@ -1,7 +1,6 @@
 use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::sugg::Sugg;
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, Mutability};
 use rustc_lint::LateContext;
@@ -18,10 +17,18 @@ pub(super) fn check<'tcx>(
     msrv: &Msrv,
 ) {
     if msrv.meets(msrvs::POINTER_CAST_CONSTNESS)
-        && let ty::RawPtr(TypeAndMut { mutbl: from_mutbl, ty: from_ty }) = cast_from.kind()
-        && let ty::RawPtr(TypeAndMut { mutbl: to_mutbl, ty: to_ty }) = cast_to.kind()
-        && matches!((from_mutbl, to_mutbl),
-            (Mutability::Not, Mutability::Mut) | (Mutability::Mut, Mutability::Not))
+        && let ty::RawPtr(TypeAndMut {
+            mutbl: from_mutbl,
+            ty: from_ty,
+        }) = cast_from.kind()
+        && let ty::RawPtr(TypeAndMut {
+            mutbl: to_mutbl,
+            ty: to_ty,
+        }) = cast_to.kind()
+        && matches!(
+            (from_mutbl, to_mutbl),
+            (Mutability::Not, Mutability::Mut) | (Mutability::Mut, Mutability::Not)
+        )
         && from_ty == to_ty
     {
         let sugg = Sugg::hir(cx, cast_expr, "_");
diff --git a/clippy_lints/src/casts/unnecessary_cast.rs b/clippy_lints/src/casts/unnecessary_cast.rs
index e060977d253..849920bb76d 100644
--- a/clippy_lints/src/casts/unnecessary_cast.rs
+++ b/clippy_lints/src/casts/unnecessary_cast.rs
@@ -3,7 +3,6 @@ use clippy_utils::numeric_literal::NumericLiteral;
 use clippy_utils::source::snippet_opt;
 use clippy_utils::visitors::{for_each_expr, Visitable};
 use clippy_utils::{get_parent_expr, get_parent_node, is_hir_ty_cfg_dependant, is_ty_alias, path_to_local};
-use if_chain::if_chain;
 use rustc_ast::{LitFloatType, LitIntType, LitKind};
 use rustc_errors::Applicability;
 use rustc_hir::def::{DefKind, Res};
@@ -52,7 +51,9 @@ pub(super) fn check<'tcx>(
             cx,
             UNNECESSARY_CAST,
             expr.span,
-            &format!("casting raw pointers to the same type and constness is unnecessary (`{cast_from}` -> `{cast_to}`)"),
+            &format!(
+                "casting raw pointers to the same type and constness is unnecessary (`{cast_from}` -> `{cast_to}`)"
+            ),
             "try",
             cast_str.clone(),
             Applicability::MaybeIncorrect,
@@ -87,8 +88,8 @@ pub(super) fn check<'tcx>(
     if let ExprKind::Cast(_, cast_to) = expr.kind
         && let TyKind::Path(QPath::Resolved(_, path)) = &cast_to.kind
         && let Res::PrimTy(_) = path.res
-    {}
-    else {
+    {
+    } else {
         return false;
     }
 
@@ -108,10 +109,13 @@ pub(super) fn check<'tcx>(
             && let Some(num_lit) = NumericLiteral::from_lit_kind(&src, &lit.node)
             && let from_nbits = 128 - n.leading_zeros()
             && let to_nbits = fp_ty_mantissa_nbits(cast_to)
-            && from_nbits != 0 && to_nbits != 0 && from_nbits <= to_nbits && num_lit.is_decimal()
+            && from_nbits != 0
+            && to_nbits != 0
+            && from_nbits <= to_nbits
+            && num_lit.is_decimal()
         {
             lint_unnecessary_cast(cx, expr, num_lit.integer, cast_from, cast_to);
-            return true
+            return true;
         }
 
         match lit.node {
diff --git a/clippy_lints/src/checked_conversions.rs b/clippy_lints/src/checked_conversions.rs
index 26ec1dd2d43..69fa0821e3f 100644
--- a/clippy_lints/src/checked_conversions.rs
+++ b/clippy_lints/src/checked_conversions.rs
@@ -4,7 +4,6 @@ use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::{in_constant, is_integer_literal, SpanlessEq};
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOp, BinOpKind, Expr, ExprKind, QPath, TyKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
@@ -58,7 +57,6 @@ impl<'tcx> LateLintPass<'tcx> for CheckedConversions {
         let result = if !in_constant(cx, item.hir_id)
             && !in_external_macro(cx.sess(), item.span)
             && let ExprKind::Binary(op, left, right) = &item.kind
-
         {
             match op.node {
                 BinOpKind::Ge | BinOpKind::Le => single_check(item),
@@ -192,12 +190,11 @@ impl ConversionType {
 /// Check for `expr <= (to_type::MAX as from_type)`
 fn check_upper_bound<'tcx>(expr: &'tcx Expr<'tcx>) -> Option<Conversion<'tcx>> {
     if let ExprKind::Binary(ref op, left, right) = &expr.kind
-         && let Some((candidate, check)) = normalize_le_ge(op, left, right)
-         && let Some((from, to)) = get_types_from_cast(check, INTS, "max_value", "MAX")
-
-     {
-         Conversion::try_new(candidate, from, to)
-     } else {
+        && let Some((candidate, check)) = normalize_le_ge(op, left, right)
+        && let Some((from, to)) = get_types_from_cast(check, INTS, "max_value", "MAX")
+    {
+        Conversion::try_new(candidate, from, to)
+    } else {
         None
     }
 }
@@ -243,7 +240,6 @@ fn get_types_from_cast<'a>(
         // to_type::max_value(), from_type
         && let TyKind::Path(ref from_type_path) = &from_type.kind
         && let Some(from_sym) = int_ty_to_sym(from_type_path)
-
     {
         Some((limit, from_sym))
     } else {
@@ -257,7 +253,6 @@ fn get_types_from_cast<'a>(
             // `from_type::from`
             && let ExprKind::Path(ref path) = &from_func.kind
             && let Some(from_sym) = get_implementing_type(path, INTS, "from")
-
         {
             Some((limit, from_sym))
         } else {
diff --git a/clippy_lints/src/collapsible_if.rs b/clippy_lints/src/collapsible_if.rs
index 763a2d2ad89..e5aaf88ab6c 100644
--- a/clippy_lints/src/collapsible_if.rs
+++ b/clippy_lints/src/collapsible_if.rs
@@ -15,7 +15,6 @@
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::{snippet, snippet_block, snippet_block_with_applicability};
 use clippy_utils::sugg::Sugg;
-use if_chain::if_chain;
 use rustc_ast::ast;
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass};
@@ -131,7 +130,11 @@ fn check_collapsible_maybe_if_let(cx: &EarlyContext<'_>, then_span: Span, else_:
         // Prevent "elseif"
         // Check that the "else" is followed by whitespace
         let up_to_else = then_span.between(block.span);
-        let requires_space = if let Some(c) = snippet(cx, up_to_else, "..").chars().last() { !c.is_whitespace() } else { false };
+        let requires_space = if let Some(c) = snippet(cx, up_to_else, "..").chars().last() {
+            !c.is_whitespace()
+        } else {
+            false
+        };
 
         let mut applicability = Applicability::MachineApplicable;
         span_lint_and_sugg(
@@ -160,21 +163,27 @@ fn check_collapsible_no_if_let(cx: &EarlyContext<'_>, expr: &ast::Expr, check: &
         && let ctxt = expr.span.ctxt()
         && inner.span.ctxt() == ctxt
     {
-        span_lint_and_then(cx, COLLAPSIBLE_IF, expr.span, "this `if` statement can be collapsed", |diag| {
-            let mut app = Applicability::MachineApplicable;
-            let lhs = Sugg::ast(cx, check, "..", ctxt, &mut app);
-            let rhs = Sugg::ast(cx, check_inner, "..", ctxt, &mut app);
-            diag.span_suggestion(
-                expr.span,
-                "collapse nested if block",
-                format!(
-                    "if {} {}",
-                    lhs.and(&rhs),
-                    snippet_block(cx, content.span, "..", Some(expr.span)),
-                ),
-                app, // snippet
-            );
-        });
+        span_lint_and_then(
+            cx,
+            COLLAPSIBLE_IF,
+            expr.span,
+            "this `if` statement can be collapsed",
+            |diag| {
+                let mut app = Applicability::MachineApplicable;
+                let lhs = Sugg::ast(cx, check, "..", ctxt, &mut app);
+                let rhs = Sugg::ast(cx, check_inner, "..", ctxt, &mut app);
+                diag.span_suggestion(
+                    expr.span,
+                    "collapse nested if block",
+                    format!(
+                        "if {} {}",
+                        lhs.and(&rhs),
+                        snippet_block(cx, content.span, "..", Some(expr.span)),
+                    ),
+                    app, // snippet
+                );
+            },
+        );
     }
 }
 
diff --git a/clippy_lints/src/copy_iterator.rs b/clippy_lints/src/copy_iterator.rs
index 9d578054188..db850edd640 100644
--- a/clippy_lints/src/copy_iterator.rs
+++ b/clippy_lints/src/copy_iterator.rs
@@ -5,8 +5,6 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::sym;
 
-use if_chain::if_chain;
-
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for types that implement `Copy` as well as
@@ -39,9 +37,9 @@ declare_lint_pass!(CopyIterator => [COPY_ITERATOR]);
 impl<'tcx> LateLintPass<'tcx> for CopyIterator {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
         if let ItemKind::Impl(Impl {
-                of_trait: Some(ref trait_ref),
-                ..
-            }) = item.kind
+            of_trait: Some(ref trait_ref),
+            ..
+        }) = item.kind
             && let ty = cx.tcx.type_of(item.owner_id).instantiate_identity()
             && is_copy(cx, ty)
             && let Some(trait_id) = trait_ref.trait_def_id()
diff --git a/clippy_lints/src/crate_in_macro_def.rs b/clippy_lints/src/crate_in_macro_def.rs
index 8d9b2ebff7f..637d5aae1be 100644
--- a/clippy_lints/src/crate_in_macro_def.rs
+++ b/clippy_lints/src/crate_in_macro_def.rs
@@ -104,9 +104,19 @@ fn contains_unhygienic_crate_reference(tts: &TokenStream) -> Option<Span> {
 }
 
 fn is_crate_keyword(tt: &TokenTree) -> Option<Span> {
-    if let TokenTree::Token(Token { kind: TokenKind::Ident(symbol, _), span }, _) = tt
+    if let TokenTree::Token(
+        Token {
+            kind: TokenKind::Ident(symbol, _),
+            span,
+        },
+        _,
+    ) = tt
         && symbol.as_str() == "crate"
-    { Some(*span) } else { None }
+    {
+        Some(*span)
+    } else {
+        None
+    }
 }
 
 fn is_token(tt: &TokenTree, kind: &TokenKind) -> bool {
diff --git a/clippy_lints/src/create_dir.rs b/clippy_lints/src/create_dir.rs
index cd92f38b0ca..97b736dfd8f 100644
--- a/clippy_lints/src/create_dir.rs
+++ b/clippy_lints/src/create_dir.rs
@@ -1,6 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet;
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
@@ -46,7 +45,7 @@ impl LateLintPass<'_> for CreateDir {
                 "consider calling `std::fs::create_dir_all` instead",
                 format!("create_dir_all({})", snippet(cx, arg.span, "..")),
                 Applicability::MaybeIncorrect,
-            )
+            );
         }
     }
 }
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 1a646ba38c3..04dcccede08 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -10,8 +10,6 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     #[cfg(feature = "internal")]
     crate::utils::internal_lints::compiler_lint_functions::COMPILER_LINT_FUNCTIONS_INFO,
     #[cfg(feature = "internal")]
-    crate::utils::internal_lints::if_chain_style::IF_CHAIN_STYLE_INFO,
-    #[cfg(feature = "internal")]
     crate::utils::internal_lints::interning_defined_symbol::INTERNING_DEFINED_SYMBOL_INFO,
     #[cfg(feature = "internal")]
     crate::utils::internal_lints::interning_defined_symbol::UNNECESSARY_SYMBOL_STR_INFO,
diff --git a/clippy_lints/src/default.rs b/clippy_lints/src/default.rs
index 1ad71631089..b325449c5a3 100644
--- a/clippy_lints/src/default.rs
+++ b/clippy_lints/src/default.rs
@@ -2,7 +2,6 @@ use clippy_utils::diagnostics::{span_lint_and_note, span_lint_and_sugg};
 use clippy_utils::source::snippet_with_context;
 use clippy_utils::ty::{has_drop, is_copy};
 use clippy_utils::{any_parent_is_automatically_derived, contains_name, get_parent_expr, is_from_proc_macro};
-use if_chain::if_chain;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Applicability;
 use rustc_hir::def::Res;
diff --git a/clippy_lints/src/default_constructed_unit_structs.rs b/clippy_lints/src/default_constructed_unit_structs.rs
index edd47be5840..b90d01b765a 100644
--- a/clippy_lints/src/default_constructed_unit_structs.rs
+++ b/clippy_lints/src/default_constructed_unit_structs.rs
@@ -79,7 +79,7 @@ impl LateLintPass<'_> for DefaultConstructedUnitStructs {
                 "remove this call to `default`",
                 String::new(),
                 Applicability::MachineApplicable,
-            )
+            );
         };
     }
 }
diff --git a/clippy_lints/src/default_numeric_fallback.rs b/clippy_lints/src/default_numeric_fallback.rs
index 62583b99eaa..fb29703957d 100644
--- a/clippy_lints/src/default_numeric_fallback.rs
+++ b/clippy_lints/src/default_numeric_fallback.rs
@@ -1,7 +1,6 @@
 use clippy_utils::diagnostics::span_lint_hir_and_then;
 use clippy_utils::source::snippet_opt;
 use clippy_utils::{get_parent_node, numeric_literal};
-use if_chain::if_chain;
 use rustc_ast::ast::{LitFloatType, LitIntType, LitKind};
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_expr, walk_stmt, Visitor};
@@ -83,38 +82,40 @@ impl<'a, 'tcx> NumericFallbackVisitor<'a, 'tcx> {
     /// Check whether a passed literal has potential to cause fallback or not.
     fn check_lit(&self, lit: &Lit, lit_ty: Ty<'tcx>, emit_hir_id: HirId) {
         if !in_external_macro(self.cx.sess(), lit.span)
-                && matches!(self.ty_bounds.last(), Some(ExplicitTyBound(false)))
-                && matches!(lit.node,
-                            LitKind::Int(_, LitIntType::Unsuffixed) | LitKind::Float(_, LitFloatType::Unsuffixed))
-            {
-                let (suffix, is_float) = match lit_ty.kind() {
-                    ty::Int(IntTy::I32) => ("i32", false),
-                    ty::Float(FloatTy::F64) => ("f64", true),
-                    // Default numeric fallback never results in other types.
+            && matches!(self.ty_bounds.last(), Some(ExplicitTyBound(false)))
+            && matches!(
+                lit.node,
+                LitKind::Int(_, LitIntType::Unsuffixed) | LitKind::Float(_, LitFloatType::Unsuffixed)
+            )
+        {
+            let (suffix, is_float) = match lit_ty.kind() {
+                ty::Int(IntTy::I32) => ("i32", false),
+                ty::Float(FloatTy::F64) => ("f64", true),
+                // Default numeric fallback never results in other types.
+                _ => return,
+            };
+
+            let src = if let Some(src) = snippet_opt(self.cx, lit.span) {
+                src
+            } else {
+                match lit.node {
+                    LitKind::Int(src, _) => format!("{src}"),
+                    LitKind::Float(src, _) => format!("{src}"),
                     _ => return,
-                };
-
-                let src = if let Some(src) = snippet_opt(self.cx, lit.span) {
-                    src
-                } else {
-                    match lit.node {
-                        LitKind::Int(src, _) => format!("{src}"),
-                        LitKind::Float(src, _) => format!("{src}"),
-                        _ => return,
-                    }
-                };
-                let sugg = numeric_literal::format(&src, Some(suffix), is_float);
-                span_lint_hir_and_then(
-                    self.cx,
-                    DEFAULT_NUMERIC_FALLBACK,
-                    emit_hir_id,
-                    lit.span,
-                    "default numeric fallback might occur",
-                    |diag| {
-                        diag.span_suggestion(lit.span, "consider adding suffix", sugg, Applicability::MaybeIncorrect);
-                    }
-                );
-            }
+                }
+            };
+            let sugg = numeric_literal::format(&src, Some(suffix), is_float);
+            span_lint_hir_and_then(
+                self.cx,
+                DEFAULT_NUMERIC_FALLBACK,
+                emit_hir_id,
+                lit.span,
+                "default numeric fallback might occur",
+                |diag| {
+                    diag.span_suggestion(lit.span, "consider adding suffix", sugg, Applicability::MaybeIncorrect);
+                },
+            );
+        }
     }
 }
 
@@ -155,14 +156,13 @@ impl<'a, 'tcx> Visitor<'tcx> for NumericFallbackVisitor<'a, 'tcx> {
 
                     // Push field type then visit each field expr.
                     for field in *fields {
-                        let bound =
-                            fields_def
-                                .iter()
-                                .find_map(|f_def| {
-                                    if f_def.ident(self.cx.tcx) == field.ident
-                                        { Some(self.cx.tcx.type_of(f_def.did).instantiate_identity()) }
-                                    else { None }
-                                });
+                        let bound = fields_def.iter().find_map(|f_def| {
+                            if f_def.ident(self.cx.tcx) == field.ident {
+                                Some(self.cx.tcx.type_of(f_def.did).instantiate_identity())
+                            } else {
+                                None
+                            }
+                        });
                         self.ty_bounds.push(bound.into());
                         self.visit_expr(field.expr);
                         self.ty_bounds.pop();
diff --git a/clippy_lints/src/derivable_impls.rs b/clippy_lints/src/derivable_impls.rs
index 233391ff3bb..9db56fa8ad0 100644
--- a/clippy_lints/src/derivable_impls.rs
+++ b/clippy_lints/src/derivable_impls.rs
@@ -154,55 +154,42 @@ fn check_enum<'tcx>(cx: &LateContext<'tcx>, item: &'tcx Item<'_>, func_expr: &Ex
         && let Some(variant_def) = adt_def.variants().iter().find(|v| v.def_id == variant_id)
         && variant_def.fields.is_empty()
         && !variant_def.is_field_list_non_exhaustive()
-
     {
         let enum_span = cx.tcx.def_span(adt_def.did());
         let indent_enum = indent_of(cx, enum_span).unwrap_or(0);
         let variant_span = cx.tcx.def_span(variant_def.def_id);
         let indent_variant = indent_of(cx, variant_span).unwrap_or(0);
-        span_lint_and_then(
-            cx,
-            DERIVABLE_IMPLS,
-            item.span,
-            "this `impl` can be derived",
-            |diag| {
-                diag.span_suggestion_hidden(
-                    item.span,
-                    "remove the manual implementation...",
-                    String::new(),
-                    Applicability::MachineApplicable
-                );
-                diag.span_suggestion(
-                    enum_span.shrink_to_lo(),
-                    "...and instead derive it...",
-                    format!(
-                        "#[derive(Default)]\n{indent}",
-                        indent = " ".repeat(indent_enum),
-                    ),
-                    Applicability::MachineApplicable
-                );
-                diag.span_suggestion(
-                    variant_span.shrink_to_lo(),
-                    "...and mark the default variant",
-                    format!(
-                        "#[default]\n{indent}",
-                        indent = " ".repeat(indent_variant),
-                    ),
-                    Applicability::MachineApplicable
-                );
-            }
-        );
+        span_lint_and_then(cx, DERIVABLE_IMPLS, item.span, "this `impl` can be derived", |diag| {
+            diag.span_suggestion_hidden(
+                item.span,
+                "remove the manual implementation...",
+                String::new(),
+                Applicability::MachineApplicable,
+            );
+            diag.span_suggestion(
+                enum_span.shrink_to_lo(),
+                "...and instead derive it...",
+                format!("#[derive(Default)]\n{indent}", indent = " ".repeat(indent_enum),),
+                Applicability::MachineApplicable,
+            );
+            diag.span_suggestion(
+                variant_span.shrink_to_lo(),
+                "...and mark the default variant",
+                format!("#[default]\n{indent}", indent = " ".repeat(indent_variant),),
+                Applicability::MachineApplicable,
+            );
+        });
     }
 }
 
 impl<'tcx> LateLintPass<'tcx> for DerivableImpls {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
         if let ItemKind::Impl(Impl {
-                of_trait: Some(ref trait_ref),
-                items: [child],
-                self_ty,
-                ..
-            }) = item.kind
+            of_trait: Some(ref trait_ref),
+            items: [child],
+            self_ty,
+            ..
+        }) = item.kind
             && !cx.tcx.has_attr(item.owner_id, sym::automatically_derived)
             && !item.span.from_expansion()
             && let Some(def_id) = trait_ref.trait_def_id()
@@ -215,7 +202,6 @@ impl<'tcx> LateLintPass<'tcx> for DerivableImpls {
             && let attrs = cx.tcx.hir().attrs(item.hir_id())
             && !attrs.iter().any(|attr| attr.doc_str().is_some())
             && cx.tcx.hir().attrs(impl_item_hir).is_empty()
-
         {
             if adt_def.is_struct() {
                 check_struct(cx, item, self_ty, func_expr, adt_def, args, cx.tcx.typeck_body(*b));
diff --git a/clippy_lints/src/derive.rs b/clippy_lints/src/derive.rs
index 6913c87ae01..9807823ada3 100644
--- a/clippy_lints/src/derive.rs
+++ b/clippy_lints/src/derive.rs
@@ -1,7 +1,6 @@
 use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_note, span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::ty::{implements_trait, implements_trait_with_env, is_copy};
 use clippy_utils::{is_lint_allowed, match_def_path, paths};
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::def_id::DefId;
 use rustc_hir::intravisit::{walk_expr, walk_fn, walk_item, FnKind, Visitor};
@@ -258,12 +257,9 @@ fn check_hash_peq<'tcx>(
                     |diag| {
                         if let Some(local_def_id) = impl_id.as_local() {
                             let hir_id = cx.tcx.hir().local_def_id_to_hir_id(local_def_id);
-                            diag.span_note(
-                                cx.tcx.hir().span(hir_id),
-                                "`PartialEq` implemented here"
-                            );
+                            diag.span_note(cx.tcx.hir().span(hir_id), "`PartialEq` implemented here");
                         }
-                    }
+                    },
                 );
             }
         });
@@ -302,21 +298,12 @@ fn check_ord_partial_ord<'tcx>(
                     "you are deriving `Ord` but have implemented `PartialOrd` explicitly"
                 };
 
-                span_lint_and_then(
-                    cx,
-                    DERIVE_ORD_XOR_PARTIAL_ORD,
-                    span,
-                    mess,
-                    |diag| {
-                        if let Some(local_def_id) = impl_id.as_local() {
-                            let hir_id = cx.tcx.hir().local_def_id_to_hir_id(local_def_id);
-                            diag.span_note(
-                                cx.tcx.hir().span(hir_id),
-                                "`PartialOrd` implemented here"
-                            );
-                        }
+                span_lint_and_then(cx, DERIVE_ORD_XOR_PARTIAL_ORD, span, mess, |diag| {
+                    if let Some(local_def_id) = impl_id.as_local() {
+                        let hir_id = cx.tcx.hir().local_def_id_to_hir_id(local_def_id);
+                        diag.span_note(cx.tcx.hir().span(hir_id), "`PartialOrd` implemented here");
                     }
-                );
+                });
             }
         });
     }
@@ -397,7 +384,9 @@ fn check_unsafe_derive_deserialize<'tcx>(
         && let Some(local_def_id) = def.did().as_local()
         && let adt_hir_id = cx.tcx.hir().local_def_id_to_hir_id(local_def_id)
         && !is_lint_allowed(cx, UNSAFE_DERIVE_DESERIALIZE, adt_hir_id)
-        && cx.tcx.inherent_impls(def.did())
+        && cx
+            .tcx
+            .inherent_impls(def.did())
             .iter()
             .map(|imp_did| cx.tcx.hir().expect_item(imp_did.expect_local()))
             .any(|imp| has_unsafe(cx, imp))
@@ -408,7 +397,7 @@ fn check_unsafe_derive_deserialize<'tcx>(
             item.span,
             "you are deriving `serde::Deserialize` on a type that has methods using `unsafe`",
             None,
-            "consider implementing `serde::Deserialize` manually. See https://serde.rs/impl-deserialize.html"
+            "consider implementing `serde::Deserialize` manually. See https://serde.rs/impl-deserialize.html",
         );
     }
 }
@@ -477,7 +466,7 @@ fn check_partial_eq_without_eq<'tcx>(cx: &LateContext<'tcx>, span: Span, trait_r
             "consider deriving `Eq` as well",
             "PartialEq, Eq".to_string(),
             Applicability::MachineApplicable,
-        )
+        );
     }
 }
 
diff --git a/clippy_lints/src/doc.rs b/clippy_lints/src/doc.rs
index f6dde3232bf..587360545cb 100644
--- a/clippy_lints/src/doc.rs
+++ b/clippy_lints/src/doc.rs
@@ -4,7 +4,6 @@ use clippy_utils::macros::{is_panic, root_macro_call_first_node};
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::{implements_trait, is_type_diagnostic_item};
 use clippy_utils::{is_entrypoint_fn, method_chain_args, return_ty};
-use if_chain::if_chain;
 use pulldown_cmark::Event::{
     Code, End, FootnoteReference, HardBreak, Html, Rule, SoftBreak, Start, TaskListMarker, Text,
 };
@@ -428,23 +427,21 @@ fn lint_for_missing_headers(
                 span,
                 "docs for function returning `Result` missing `# Errors` section",
             );
-        } else {
-            if let Some(body_id) = body_id
-                && let Some(future) = cx.tcx.lang_items().future_trait()
-                && let typeck = cx.tcx.typeck_body(body_id)
-                && let body = cx.tcx.hir().body(body_id)
-                && let ret_ty = typeck.expr_ty(body.value)
-                && implements_trait(cx, ret_ty, future, &[])
-                && let ty::Coroutine(_, subs, _) = ret_ty.kind()
-                && is_type_diagnostic_item(cx, subs.as_coroutine().return_ty(), sym::Result)
-            {
-                span_lint(
-                    cx,
-                    MISSING_ERRORS_DOC,
-                    span,
-                    "docs for function returning `Result` missing `# Errors` section",
-                );
-            }
+        } else if let Some(body_id) = body_id
+            && let Some(future) = cx.tcx.lang_items().future_trait()
+            && let typeck = cx.tcx.typeck_body(body_id)
+            && let body = cx.tcx.hir().body(body_id)
+            && let ret_ty = typeck.expr_ty(body.value)
+            && implements_trait(cx, ret_ty, future, &[])
+            && let ty::Coroutine(_, subs, _) = ret_ty.kind()
+            && is_type_diagnostic_item(cx, subs.as_coroutine().return_ty(), sym::Result)
+        {
+            span_lint(
+                cx,
+                MISSING_ERRORS_DOC,
+                span,
+                "docs for function returning `Result` missing `# Errors` section",
+            );
         }
     }
 }
diff --git a/clippy_lints/src/empty_drop.rs b/clippy_lints/src/empty_drop.rs
index da1103f39e0..17be95780cc 100644
--- a/clippy_lints/src/empty_drop.rs
+++ b/clippy_lints/src/empty_drop.rs
@@ -1,6 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::peel_blocks;
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Body, ExprKind, Impl, ImplItemKind, Item, ItemKind, Node};
 use rustc_lint::{LateContext, LateLintPass};
@@ -37,10 +36,10 @@ declare_lint_pass!(EmptyDrop => [EMPTY_DROP]);
 impl LateLintPass<'_> for EmptyDrop {
     fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
         if let ItemKind::Impl(Impl {
-                of_trait: Some(ref trait_ref),
-                items: [child],
-                ..
-            }) = item.kind
+            of_trait: Some(ref trait_ref),
+            items: [child],
+            ..
+        }) = item.kind
             && trait_ref.trait_def_id() == cx.tcx.lang_items().drop_trait()
             && let impl_item_hir = child.id.hir_id()
             && let Some(Node::ImplItem(impl_item)) = cx.tcx.hir().find(impl_item_hir)
@@ -48,7 +47,8 @@ impl LateLintPass<'_> for EmptyDrop {
             && let Body { value: func_expr, .. } = cx.tcx.hir().body(*b)
             && let func_expr = peel_blocks(func_expr)
             && let ExprKind::Block(block, _) = func_expr.kind
-            && block.stmts.is_empty() && block.expr.is_none()
+            && block.stmts.is_empty()
+            && block.expr.is_none()
         {
             span_lint_and_sugg(
                 cx,
@@ -57,7 +57,7 @@ impl LateLintPass<'_> for EmptyDrop {
                 "empty drop implementation",
                 "try removing this impl",
                 String::new(),
-                Applicability::MaybeIncorrect
+                Applicability::MaybeIncorrect,
             );
         }
     }
diff --git a/clippy_lints/src/exhaustive_items.rs b/clippy_lints/src/exhaustive_items.rs
index 201bf13a0df..b7e62e082e4 100644
--- a/clippy_lints/src/exhaustive_items.rs
+++ b/clippy_lints/src/exhaustive_items.rs
@@ -1,6 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::indent_of;
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
@@ -77,9 +76,7 @@ impl LateLintPass<'_> for ExhaustiveItems {
             && !attrs.iter().any(|a| a.has_name(sym::non_exhaustive))
         {
             let (lint, msg) = if let ItemKind::Struct(ref v, ..) = item.kind {
-                if v.fields().iter().any(|f| {
-                    !cx.tcx.visibility(f.def_id).is_public()
-                }) {
+                if v.fields().iter().any(|f| !cx.tcx.visibility(f.def_id).is_public()) {
                     // skip structs with private fields
                     return;
                 }
@@ -89,20 +86,15 @@ impl LateLintPass<'_> for ExhaustiveItems {
             };
             let suggestion_span = item.span.shrink_to_lo();
             let indent = " ".repeat(indent_of(cx, item.span).unwrap_or(0));
-            span_lint_and_then(
-                cx,
-                lint,
-                item.span,
-                msg,
-                |diag| {
-                    let sugg = format!("#[non_exhaustive]\n{indent}");
-                    diag.span_suggestion(suggestion_span,
-                                         "try adding #[non_exhaustive]",
-                                         sugg,
-                                         Applicability::MaybeIncorrect);
-                }
-            );
-
+            span_lint_and_then(cx, lint, item.span, msg, |diag| {
+                let sugg = format!("#[non_exhaustive]\n{indent}");
+                diag.span_suggestion(
+                    suggestion_span,
+                    "try adding #[non_exhaustive]",
+                    sugg,
+                    Applicability::MaybeIncorrect,
+                );
+            });
         }
     }
 }
diff --git a/clippy_lints/src/exit.rs b/clippy_lints/src/exit.rs
index a366749560b..07d025f68c3 100644
--- a/clippy_lints/src/exit.rs
+++ b/clippy_lints/src/exit.rs
@@ -1,6 +1,5 @@
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::is_entrypoint_fn;
-use if_chain::if_chain;
 use rustc_hir::{Expr, ExprKind, Item, ItemKind, Node};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
diff --git a/clippy_lints/src/explicit_write.rs b/clippy_lints/src/explicit_write.rs
index c8d901d08bd..08cb2114a2b 100644
--- a/clippy_lints/src/explicit_write.rs
+++ b/clippy_lints/src/explicit_write.rs
@@ -2,7 +2,6 @@ use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::macros::{find_format_args, format_args_inputs_span};
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::{is_expn_of, path_def_id};
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::def::Res;
 use rustc_hir::{BindingAnnotation, Block, BlockCheckMode, Expr, ExprKind, Node, PatKind, QPath, Stmt, StmtKind};
diff --git a/clippy_lints/src/fallible_impl_from.rs b/clippy_lints/src/fallible_impl_from.rs
index 5824f462f4b..753f75d83a8 100644
--- a/clippy_lints/src/fallible_impl_from.rs
+++ b/clippy_lints/src/fallible_impl_from.rs
@@ -2,7 +2,6 @@ use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::macros::{is_panic, root_macro_call_first_node};
 use clippy_utils::method_chain_args;
 use clippy_utils::ty::is_type_diagnostic_item;
-use if_chain::if_chain;
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
@@ -55,7 +54,9 @@ impl<'tcx> LateLintPass<'tcx> for FallibleImplFrom {
         // check for `impl From<???> for ..`
         if let hir::ItemKind::Impl(impl_) = &item.kind
             && let Some(impl_trait_ref) = cx.tcx.impl_trait_ref(item.owner_id)
-            && cx.tcx.is_diagnostic_item(sym::From, impl_trait_ref.skip_binder().def_id)
+            && cx
+                .tcx
+                .is_diagnostic_item(sym::From, impl_trait_ref.skip_binder().def_id)
         {
             lint_impl_body(cx, item.span, impl_.items);
         }
@@ -97,8 +98,7 @@ fn lint_impl_body(cx: &LateContext<'_>, impl_span: Span, impl_items: &[hir::Impl
 
     for impl_item in impl_items {
         if impl_item.ident.name == sym::from
-            && let ImplItemKind::Fn(_, body_id) =
-                cx.tcx.hir().impl_item(impl_item.id).kind
+            && let ImplItemKind::Fn(_, body_id) = cx.tcx.hir().impl_item(impl_item.id).kind
         {
             // check the body for `begin_panic` or `unwrap`
             let body = cx.tcx.hir().body(body_id);
@@ -119,9 +119,11 @@ fn lint_impl_body(cx: &LateContext<'_>, impl_span: Span, impl_items: &[hir::Impl
                     move |diag| {
                         diag.help(
                             "`From` is intended for infallible conversions only. \
-                            Use `TryFrom` if there's a possibility for the conversion to fail");
+                            Use `TryFrom` if there's a possibility for the conversion to fail",
+                        );
                         diag.span_note(fpu.result, "potential failure(s)");
-                    });
+                    },
+                );
             }
         }
     }
diff --git a/clippy_lints/src/float_literal.rs b/clippy_lints/src/float_literal.rs
index 07640a77584..663c33e8cee 100644
--- a/clippy_lints/src/float_literal.rs
+++ b/clippy_lints/src/float_literal.rs
@@ -1,6 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::numeric_literal;
-use if_chain::if_chain;
 use rustc_ast::ast::{self, LitFloatType, LitKind};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
@@ -79,7 +78,7 @@ impl<'tcx> LateLintPass<'tcx> for FloatLiteral {
             let type_suffix = match lit_float_ty {
                 LitFloatType::Suffixed(ast::FloatTy::F32) => Some("f32"),
                 LitFloatType::Suffixed(ast::FloatTy::F64) => Some("f64"),
-                LitFloatType::Unsuffixed => None
+                LitFloatType::Unsuffixed => None,
             };
             let (is_whole, is_inf, mut float_str) = match fty {
                 FloatTy::F32 => {
@@ -90,7 +89,6 @@ impl<'tcx> LateLintPass<'tcx> for FloatLiteral {
                 FloatTy::F64 => {
                     let value = sym_str.parse::<f64>().unwrap();
 
-
                     (value.fract() == 0.0, value.is_infinite(), formatter.format(value))
                 },
             };
diff --git a/clippy_lints/src/floating_point_arithmetic.rs b/clippy_lints/src/floating_point_arithmetic.rs
index 21cedf17385..d522873472b 100644
--- a/clippy_lints/src/floating_point_arithmetic.rs
+++ b/clippy_lints/src/floating_point_arithmetic.rs
@@ -4,7 +4,6 @@ use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::{
     eq_expr_value, get_parent_expr, higher, in_constant, is_no_std_crate, numeric_literal, peel_blocks, sugg,
 };
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind, PathSegment, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
@@ -143,17 +142,14 @@ fn prepare_receiver_sugg<'a>(cx: &LateContext<'_>, mut expr: &'a Expr<'a>) -> Su
             "{suggestion}{}{}",
             // Check for float literals without numbers following the decimal
             // separator such as `2.` and adds a trailing zero
-            if sym.as_str().ends_with('.') {
-                "0"
-            } else {
-                ""
-            },
+            if sym.as_str().ends_with('.') { "0" } else { "" },
             float_ty.name_str()
-        ).into();
+        )
+        .into();
 
         suggestion = match suggestion {
             Sugg::MaybeParen(_) => Sugg::MaybeParen(op),
-            _ => Sugg::NonParen(op)
+            _ => Sugg::NonParen(op),
         };
     }
 
@@ -357,31 +353,59 @@ fn detect_hypot(cx: &LateContext<'_>, receiver: &Expr<'_>) -> Option<String> {
     ) = receiver.kind
     {
         // check if expression of the form x * x + y * y
-        if let ExprKind::Binary(Spanned { node: BinOpKind::Mul, .. }, lmul_lhs, lmul_rhs) = add_lhs.kind
-            && let ExprKind::Binary(Spanned { node: BinOpKind::Mul, .. }, rmul_lhs, rmul_rhs) = add_rhs.kind
+        if let ExprKind::Binary(
+            Spanned {
+                node: BinOpKind::Mul, ..
+            },
+            lmul_lhs,
+            lmul_rhs,
+        ) = add_lhs.kind
+            && let ExprKind::Binary(
+                Spanned {
+                    node: BinOpKind::Mul, ..
+                },
+                rmul_lhs,
+                rmul_rhs,
+            ) = add_rhs.kind
             && eq_expr_value(cx, lmul_lhs, lmul_rhs)
             && eq_expr_value(cx, rmul_lhs, rmul_rhs)
         {
-            return Some(format!("{}.hypot({})", Sugg::hir(cx, lmul_lhs, "..").maybe_par(), Sugg::hir(cx, rmul_lhs, "..")));
+            return Some(format!(
+                "{}.hypot({})",
+                Sugg::hir(cx, lmul_lhs, "..").maybe_par(),
+                Sugg::hir(cx, rmul_lhs, "..")
+            ));
         }
 
         // check if expression of the form x.powi(2) + y.powi(2)
         if let ExprKind::MethodCall(
-                PathSegment { ident: lmethod_name, .. },
-                largs_0, [largs_1, ..],
-                _
-            ) = &add_lhs.kind
+            PathSegment {
+                ident: lmethod_name, ..
+            },
+            largs_0,
+            [largs_1, ..],
+            _,
+        ) = &add_lhs.kind
             && let ExprKind::MethodCall(
-                PathSegment { ident: rmethod_name, .. },
-                rargs_0, [rargs_1, ..],
-                _
+                PathSegment {
+                    ident: rmethod_name, ..
+                },
+                rargs_0,
+                [rargs_1, ..],
+                _,
             ) = &add_rhs.kind
-            && lmethod_name.as_str() == "powi" && rmethod_name.as_str() == "powi"
+            && lmethod_name.as_str() == "powi"
+            && rmethod_name.as_str() == "powi"
             && let Some(lvalue) = constant(cx, cx.typeck_results(), largs_1)
             && let Some(rvalue) = constant(cx, cx.typeck_results(), rargs_1)
-            && Int(2) == lvalue && Int(2) == rvalue
+            && Int(2) == lvalue
+            && Int(2) == rvalue
         {
-            return Some(format!("{}.hypot({})", Sugg::hir(cx, largs_0, "..").maybe_par(), Sugg::hir(cx, rargs_0, "..")));
+            return Some(format!(
+                "{}.hypot({})",
+                Sugg::hir(cx, largs_0, "..").maybe_par(),
+                Sugg::hir(cx, rargs_0, "..")
+            ));
         }
     }
 
@@ -405,7 +429,13 @@ fn check_hypot(cx: &LateContext<'_>, expr: &Expr<'_>, receiver: &Expr<'_>) {
 // TODO: Lint expressions of the form `x.exp() - y` where y > 1
 // and suggest usage of `x.exp_m1() - (y - 1)` instead
 fn check_expm1(cx: &LateContext<'_>, expr: &Expr<'_>) {
-    if let ExprKind::Binary(Spanned { node: BinOpKind::Sub, .. }, lhs, rhs) = expr.kind
+    if let ExprKind::Binary(
+        Spanned {
+            node: BinOpKind::Sub, ..
+        },
+        lhs,
+        rhs,
+    ) = expr.kind
         && cx.typeck_results().expr_ty(lhs).is_floating_point()
         && let Some(value) = constant(cx, cx.typeck_results(), rhs)
         && (F32(1.0) == value || F64(1.0) == value)
@@ -419,17 +449,20 @@ fn check_expm1(cx: &LateContext<'_>, expr: &Expr<'_>) {
             expr.span,
             "(e.pow(x) - 1) can be computed more accurately",
             "consider using",
-            format!(
-                "{}.exp_m1()",
-                Sugg::hir(cx, self_arg, "..").maybe_par()
-            ),
+            format!("{}.exp_m1()", Sugg::hir(cx, self_arg, "..").maybe_par()),
             Applicability::MachineApplicable,
         );
     }
 }
 
 fn is_float_mul_expr<'a>(cx: &LateContext<'_>, expr: &'a Expr<'a>) -> Option<(&'a Expr<'a>, &'a Expr<'a>)> {
-    if let ExprKind::Binary(Spanned { node: BinOpKind::Mul, .. }, lhs, rhs) = &expr.kind
+    if let ExprKind::Binary(
+        Spanned {
+            node: BinOpKind::Mul, ..
+        },
+        lhs,
+        rhs,
+    ) = &expr.kind
         && cx.typeck_results().expr_ty(lhs).is_floating_point()
         && cx.typeck_results().expr_ty(rhs).is_floating_point()
     {
@@ -543,7 +576,11 @@ fn are_negated<'a>(cx: &LateContext<'_>, expr1: &'a Expr<'a>, expr2: &'a Expr<'a
 }
 
 fn check_custom_abs(cx: &LateContext<'_>, expr: &Expr<'_>) {
-    if let Some(higher::If { cond, then, r#else: Some(r#else) }) = higher::If::hir(expr)
+    if let Some(higher::If {
+        cond,
+        then,
+        r#else: Some(r#else),
+    }) = higher::If::hir(expr)
         && let if_body_expr = peel_blocks(then)
         && let else_body_expr = peel_blocks(r#else)
         && let Some((if_expr_positive, body)) = are_negated(cx, if_body_expr, else_body_expr)
@@ -584,15 +621,27 @@ fn check_custom_abs(cx: &LateContext<'_>, expr: &Expr<'_>) {
 }
 
 fn are_same_base_logs(cx: &LateContext<'_>, expr_a: &Expr<'_>, expr_b: &Expr<'_>) -> bool {
-    if let ExprKind::MethodCall(PathSegment { ident: method_name_a, .. }, _, args_a, _) = expr_a.kind
-        && let ExprKind::MethodCall(PathSegment { ident: method_name_b, .. }, _, args_b, _) = expr_b.kind
+    if let ExprKind::MethodCall(
+        PathSegment {
+            ident: method_name_a, ..
+        },
+        _,
+        args_a,
+        _,
+    ) = expr_a.kind
+        && let ExprKind::MethodCall(
+            PathSegment {
+                ident: method_name_b, ..
+            },
+            _,
+            args_b,
+            _,
+        ) = expr_b.kind
     {
-        return method_name_a.as_str() == method_name_b.as_str() &&
-            args_a.len() == args_b.len() &&
-            (
-                ["ln", "log2", "log10"].contains(&method_name_a.as_str()) ||
-                method_name_a.as_str() == "log" && args_a.len() == 1 && eq_expr_value(cx, &args_a[0], &args_b[0])
-            );
+        return method_name_a.as_str() == method_name_b.as_str()
+            && args_a.len() == args_b.len()
+            && (["ln", "log2", "log10"].contains(&method_name_a.as_str())
+                || method_name_a.as_str() == "log" && args_a.len() == 1 && eq_expr_value(cx, &args_a[0], &args_b[0]));
     }
 
     false
@@ -601,12 +650,12 @@ fn are_same_base_logs(cx: &LateContext<'_>, expr_a: &Expr<'_>, expr_b: &Expr<'_>
 fn check_log_division(cx: &LateContext<'_>, expr: &Expr<'_>) {
     // check if expression of the form x.logN() / y.logN()
     if let ExprKind::Binary(
-            Spanned {
-                node: BinOpKind::Div, ..
-            },
-            lhs,
-            rhs,
-        ) = &expr.kind
+        Spanned {
+            node: BinOpKind::Div, ..
+        },
+        lhs,
+        rhs,
+    ) = &expr.kind
         && are_same_base_logs(cx, lhs, rhs)
         && let ExprKind::MethodCall(_, largs_self, ..) = &lhs.kind
         && let ExprKind::MethodCall(_, rargs_self, ..) = &rhs.kind
@@ -617,7 +666,11 @@ fn check_log_division(cx: &LateContext<'_>, expr: &Expr<'_>) {
             expr.span,
             "log base can be expressed more clearly",
             "consider using",
-            format!("{}.log({})", Sugg::hir(cx, largs_self, "..").maybe_par(), Sugg::hir(cx, rargs_self, ".."),),
+            format!(
+                "{}.log({})",
+                Sugg::hir(cx, largs_self, "..").maybe_par(),
+                Sugg::hir(cx, rargs_self, ".."),
+            ),
             Applicability::MachineApplicable,
         );
     }
@@ -625,12 +678,12 @@ fn check_log_division(cx: &LateContext<'_>, expr: &Expr<'_>) {
 
 fn check_radians(cx: &LateContext<'_>, expr: &Expr<'_>) {
     if let ExprKind::Binary(
-            Spanned {
-                node: BinOpKind::Div, ..
-            },
-            div_lhs,
-            div_rhs,
-        ) = &expr.kind
+        Spanned {
+            node: BinOpKind::Div, ..
+        },
+        div_lhs,
+        div_rhs,
+    ) = &expr.kind
         && let ExprKind::Binary(
             Spanned {
                 node: BinOpKind::Mul, ..
@@ -642,8 +695,8 @@ fn check_radians(cx: &LateContext<'_>, expr: &Expr<'_>) {
         && let Some(lvalue) = constant(cx, cx.typeck_results(), mul_rhs)
     {
         // TODO: also check for constant values near PI/180 or 180/PI
-        if (F32(f32_consts::PI) == rvalue || F64(f64_consts::PI) == rvalue) &&
-           (F32(180_f32) == lvalue || F64(180_f64) == lvalue)
+        if (F32(f32_consts::PI) == rvalue || F64(f64_consts::PI) == rvalue)
+            && (F32(180_f32) == lvalue || F64(180_f64) == lvalue)
         {
             let mut proposal = format!("{}.to_degrees()", Sugg::hir(cx, mul_lhs, "..").maybe_par());
             if let ExprKind::Lit(literal) = mul_lhs.kind
@@ -665,9 +718,8 @@ fn check_radians(cx: &LateContext<'_>, expr: &Expr<'_>) {
                 proposal,
                 Applicability::MachineApplicable,
             );
-        } else if
-            (F32(180_f32) == rvalue || F64(180_f64) == rvalue) &&
-            (F32(f32_consts::PI) == lvalue || F64(f64_consts::PI) == lvalue)
+        } else if (F32(180_f32) == rvalue || F64(180_f64) == rvalue)
+            && (F32(f32_consts::PI) == lvalue || F64(f64_consts::PI) == lvalue)
         {
             let mut proposal = format!("{}.to_radians()", Sugg::hir(cx, mul_lhs, "..").maybe_par());
             if let ExprKind::Lit(literal) = mul_lhs.kind
diff --git a/clippy_lints/src/format_args.rs b/clippy_lints/src/format_args.rs
index 737ea05d92d..c9868255dcf 100644
--- a/clippy_lints/src/format_args.rs
+++ b/clippy_lints/src/format_args.rs
@@ -8,7 +8,6 @@ use clippy_utils::macros::{
 };
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::{implements_trait, is_type_lang_item};
-use if_chain::if_chain;
 use itertools::Itertools;
 use rustc_ast::{
     FormatArgPosition, FormatArgPositionKind, FormatArgsPiece, FormatArgumentKind, FormatCount, FormatOptions,
@@ -422,9 +421,7 @@ fn check_to_string_in_format_args(cx: &LateContext<'_>, name: Symbol, value: &Ex
                 cx,
                 TO_STRING_IN_FORMAT_ARGS,
                 to_string_span.with_lo(receiver.span.hi()),
-                &format!(
-                    "`to_string` applied to a type that implements `Display` in `{name}!` args"
-                ),
+                &format!("`to_string` applied to a type that implements `Display` in `{name}!` args"),
                 "remove this",
                 String::new(),
                 Applicability::MachineApplicable,
@@ -434,9 +431,7 @@ fn check_to_string_in_format_args(cx: &LateContext<'_>, name: Symbol, value: &Ex
                 cx,
                 TO_STRING_IN_FORMAT_ARGS,
                 value.span,
-                &format!(
-                    "`to_string` applied to a type that implements `Display` in `{name}!` args"
-                ),
+                &format!("`to_string` applied to a type that implements `Display` in `{name}!` args"),
                 "use this",
                 format!(
                     "{}{:*>n_needed_derefs$}{receiver_snippet}",
diff --git a/clippy_lints/src/format_impl.rs b/clippy_lints/src/format_impl.rs
index 7eee3a97669..ec87629a344 100644
--- a/clippy_lints/src/format_impl.rs
+++ b/clippy_lints/src/format_impl.rs
@@ -1,7 +1,6 @@
 use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg};
 use clippy_utils::macros::{find_format_arg_expr, find_format_args, is_format_macro, root_macro_call_first_node};
 use clippy_utils::{get_parent_as_impl, is_diag_trait_item, path_to_local, peel_ref_operators};
-use if_chain::if_chain;
 use rustc_ast::{FormatArgsPiece, FormatTrait};
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, Impl, ImplItem, ImplItemKind, QPath};
@@ -243,20 +242,22 @@ fn check_print_in_format_impl(cx: &LateContext<'_>, expr: &Expr<'_>, impl_trait:
 fn is_format_trait_impl(cx: &LateContext<'_>, impl_item: &ImplItem<'_>) -> Option<FormatTraitNames> {
     if impl_item.ident.name == sym::fmt
         && let ImplItemKind::Fn(_, body_id) = impl_item.kind
-        && let Some(Impl { of_trait: Some(trait_ref),..}) = get_parent_as_impl(cx.tcx, impl_item.hir_id())
+        && let Some(Impl {
+            of_trait: Some(trait_ref),
+            ..
+        }) = get_parent_as_impl(cx.tcx, impl_item.hir_id())
         && let Some(did) = trait_ref.trait_def_id()
         && let Some(name) = cx.tcx.get_diagnostic_name(did)
         && matches!(name, sym::Debug | sym::Display)
     {
         let body = cx.tcx.hir().body(body_id);
-        let formatter_name = body.params.get(1)
+        let formatter_name = body
+            .params
+            .get(1)
             .and_then(|param| param.pat.simple_ident())
             .map(|ident| ident.name);
 
-        Some(FormatTraitNames {
-            name,
-            formatter_name,
-        })
+        Some(FormatTraitNames { name, formatter_name })
     } else {
         None
     }
diff --git a/clippy_lints/src/formatting.rs b/clippy_lints/src/formatting.rs
index be35b850c0a..a1db7b63b17 100644
--- a/clippy_lints/src/formatting.rs
+++ b/clippy_lints/src/formatting.rs
@@ -1,7 +1,6 @@
 use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_note};
 use clippy_utils::is_span_if;
 use clippy_utils::source::snippet_opt;
-use if_chain::if_chain;
 use rustc_ast::ast::{BinOpKind, Block, Expr, ExprKind, StmtKind, UnOp};
 use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
@@ -193,9 +192,7 @@ fn check_unop(cx: &EarlyContext<'_>, expr: &Expr) {
                  `{binop_str}{unop_str}` is a single operator"
             ),
             None,
-            &format!(
-                "put a space between `{binop_str}` and `{unop_str}` and remove the space after `{unop_str}`"
-            ),
+            &format!("put a space between `{binop_str}` and `{unop_str}` and remove the space after `{unop_str}`"),
         );
     }
 }
@@ -219,7 +216,6 @@ fn check_else(cx: &EarlyContext<'_>, expr: &Expr) {
         && let Some(else_snippet) = snippet_opt(cx, else_span)
         && let Some((pre_else, post_else)) = else_snippet.split_once("else")
         && let Some((_, post_else_post_eol)) = post_else.split_once('\n')
-
     {
         // Allow allman style braces `} \n else \n {`
         if is_block(else_)
@@ -234,7 +230,7 @@ fn check_else(cx: &EarlyContext<'_>, expr: &Expr) {
         // Don't warn if the only thing inside post_else_post_eol is a comment block.
         let trimmed_post_else_post_eol = post_else_post_eol.trim();
         if trimmed_post_else_post_eol.starts_with("/*") && trimmed_post_else_post_eol.ends_with("*/") {
-            return
+            return;
         }
 
         let else_desc = if is_if(else_) { "if" } else { "{..}" };
@@ -267,7 +263,8 @@ fn check_array(cx: &EarlyContext<'_>, expr: &Expr) {
     if let ExprKind::Array(ref array) = expr.kind {
         for element in array {
             if let ExprKind::Binary(ref op, ref lhs, _) = element.kind
-                && has_unary_equivalent(op.node) && lhs.span.eq_ctxt(op.span)
+                && has_unary_equivalent(op.node)
+                && lhs.span.eq_ctxt(op.span)
                 && let space_span = lhs.span.between(op.span)
                 && let Some(space_snippet) = snippet_opt(cx, space_span)
                 && let lint_span = lhs.span.with_lo(lhs.span.hi())
@@ -313,9 +310,7 @@ fn check_missing_else(cx: &EarlyContext<'_>, first: &Expr, second: &Expr) {
             else_span,
             &format!("this looks like {looks_like} but the `else` is missing"),
             None,
-            &format!(
-                "to remove this lint, add the missing `else` or add a new line before {next_thing}",
-            ),
+            &format!("to remove this lint, add the missing `else` or add a new line before {next_thing}",),
         );
     }
 }
diff --git a/clippy_lints/src/from_str_radix_10.rs b/clippy_lints/src/from_str_radix_10.rs
index 804b6d31e61..18d11ccc0b5 100644
--- a/clippy_lints/src/from_str_radix_10.rs
+++ b/clippy_lints/src/from_str_radix_10.rs
@@ -2,7 +2,6 @@ use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::is_integer_literal;
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::{is_type_diagnostic_item, is_type_lang_item};
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{def, Expr, ExprKind, LangItem, PrimTy, QPath, TyKind};
 use rustc_lint::{LateContext, LateLintPass};
@@ -61,25 +60,16 @@ impl<'tcx> LateLintPass<'tcx> for FromStrRadix10 {
 
             // check if the second argument is a primitive `10`
             && is_integer_literal(radix, 10)
-
         {
             let expr = if let ExprKind::AddrOf(_, _, expr) = &src.kind {
                 let ty = cx.typeck_results().expr_ty(expr);
-                if is_ty_stringish(cx, ty) {
-                    expr
-                } else {
-                    &src
-                }
+                if is_ty_stringish(cx, ty) { expr } else { &src }
             } else {
                 &src
             };
 
-            let sugg = Sugg::hir_with_applicability(
-                cx,
-                expr,
-                "<string>",
-                &mut Applicability::MachineApplicable
-            ).maybe_par();
+            let sugg =
+                Sugg::hir_with_applicability(cx, expr, "<string>", &mut Applicability::MachineApplicable).maybe_par();
 
             span_lint_and_sugg(
                 cx,
@@ -88,7 +78,7 @@ impl<'tcx> LateLintPass<'tcx> for FromStrRadix10 {
                 "this call to `from_str_radix` can be replaced with a call to `str::parse`",
                 "try",
                 format!("{sugg}.parse::<{}>()", prim_ty.name_str()),
-                Applicability::MaybeIncorrect
+                Applicability::MaybeIncorrect,
             );
         }
     }
diff --git a/clippy_lints/src/functions/misnamed_getters.rs b/clippy_lints/src/functions/misnamed_getters.rs
index 77718893300..bf96c0d62b0 100644
--- a/clippy_lints/src/functions/misnamed_getters.rs
+++ b/clippy_lints/src/functions/misnamed_getters.rs
@@ -43,7 +43,7 @@ pub fn check_fn(cx: &LateContext<'_>, kind: FnKind<'_>, decl: &FnDecl<'_>, body:
     // Body must be &(mut) <self_data>.name
     // self_data is not necessarily self, to also lint sub-getters, etc…
 
-    let block_expr = if let ExprKind::Block(block,_) = body.value.kind
+    let block_expr = if let ExprKind::Block(block, _) = body.value.kind
         && block.stmts.is_empty()
         && let Some(block_expr) = block.expr
     {
diff --git a/clippy_lints/src/functions/result.rs b/clippy_lints/src/functions/result.rs
index aab9cce1e00..47db107d669 100644
--- a/clippy_lints/src/functions/result.rs
+++ b/clippy_lints/src/functions/result.rs
@@ -87,11 +87,12 @@ fn check_result_unit_err(cx: &LateContext<'_>, err_ty: Ty<'_>, fn_header_span: S
 
 fn check_result_large_err<'tcx>(cx: &LateContext<'tcx>, err_ty: Ty<'tcx>, hir_ty_span: Span, large_err_threshold: u64) {
     if let Adt(adt, subst) = err_ty.kind()
-        && let Some(local_def_id) = err_ty.ty_adt_def().expect("already checked this is adt").did().as_local()
-        && let Some(hir::Node::Item(item)) = cx
-            .tcx
-            .hir()
-            .find_by_def_id(local_def_id)
+        && let Some(local_def_id) = err_ty
+            .ty_adt_def()
+            .expect("already checked this is adt")
+            .did()
+            .as_local()
+        && let Some(hir::Node::Item(item)) = cx.tcx.hir().find_by_def_id(local_def_id)
         && let hir::ItemKind::Enum(ref def, _) = item.kind
     {
         let variants_size = AdtVariantInfo::new(cx, *adt, subst);
@@ -114,17 +115,19 @@ fn check_result_large_err<'tcx>(cx: &LateContext<'tcx>, err_ty: Ty<'tcx>, hir_ty
                             let variant_def = &def.variants[variant.ind];
                             diag.span_label(
                                 variant_def.span,
-                                format!("the variant `{}` contains at least {} bytes", variant_def.ident, variant.size),
+                                format!(
+                                    "the variant `{}` contains at least {} bytes",
+                                    variant_def.ident, variant.size
+                                ),
                             );
                         }
                     }
 
                     diag.help(format!("try reducing the size of `{err_ty}`, for example by boxing large elements or replacing it with `Box<{err_ty}>`"));
-                }
+                },
             );
         }
-    }
-    else {
+    } else {
         let ty_size = approx_ty_size(cx, err_ty);
         if ty_size >= large_err_threshold {
             span_lint_and_then(
diff --git a/clippy_lints/src/if_let_mutex.rs b/clippy_lints/src/if_let_mutex.rs
index 7f111925657..644b9cdaeb2 100644
--- a/clippy_lints/src/if_let_mutex.rs
+++ b/clippy_lints/src/if_let_mutex.rs
@@ -1,7 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::{higher, SpanlessEq};
-use if_chain::if_chain;
 use rustc_errors::Diagnostic;
 use rustc_hir::intravisit::{self as visit, Visitor};
 use rustc_hir::{Expr, ExprKind};
diff --git a/clippy_lints/src/implicit_hasher.rs b/clippy_lints/src/implicit_hasher.rs
index 16af49a092a..4545f6e42e3 100644
--- a/clippy_lints/src/implicit_hasher.rs
+++ b/clippy_lints/src/implicit_hasher.rs
@@ -13,8 +13,6 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
 use rustc_span::symbol::sym;
 
-use if_chain::if_chain;
-
 use clippy_utils::diagnostics::{multispan_sugg, span_lint_and_then};
 use clippy_utils::source::{snippet, snippet_opt};
 use clippy_utils::ty::is_type_diagnostic_item;
@@ -348,8 +346,7 @@ impl<'a, 'b, 'tcx> Visitor<'tcx> for ImplicitHasherConstructorVisitor<'a, 'b, 't
 
             if self.cx.tcx.is_diagnostic_item(sym::HashMap, ty_did) {
                 if method.ident.name == sym::new {
-                    self.suggestions
-                        .insert(e.span, "HashMap::default()".to_string());
+                    self.suggestions.insert(e.span, "HashMap::default()".to_string());
                 } else if method.ident.name == sym!(with_capacity) {
                     self.suggestions.insert(
                         e.span,
@@ -361,8 +358,7 @@ impl<'a, 'b, 'tcx> Visitor<'tcx> for ImplicitHasherConstructorVisitor<'a, 'b, 't
                 }
             } else if self.cx.tcx.is_diagnostic_item(sym::HashSet, ty_did) {
                 if method.ident.name == sym::new {
-                    self.suggestions
-                        .insert(e.span, "HashSet::default()".to_string());
+                    self.suggestions.insert(e.span, "HashSet::default()".to_string());
                 } else if method.ident.name == sym!(with_capacity) {
                     self.suggestions.insert(
                         e.span,
diff --git a/clippy_lints/src/implicit_saturating_add.rs b/clippy_lints/src/implicit_saturating_add.rs
index af21d261644..f2fac9a29cb 100644
--- a/clippy_lints/src/implicit_saturating_add.rs
+++ b/clippy_lints/src/implicit_saturating_add.rs
@@ -2,7 +2,6 @@ use clippy_utils::consts::{constant, Constant};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::get_parent_expr;
 use clippy_utils::source::snippet_with_context;
-use if_chain::if_chain;
 use rustc_ast::ast::{LitIntType, LitKind};
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Block, Expr, ExprKind, Stmt, StmtKind};
@@ -47,10 +46,20 @@ impl<'tcx> LateLintPass<'tcx> for ImplicitSaturatingAdd {
             && let ExprKind::Block(block, None) = then.kind
             && let Block {
                 stmts:
-                    [Stmt
-                        { kind: StmtKind::Expr(ex) | StmtKind::Semi(ex), .. }],
-                        expr: None, ..} |
-                        Block { stmts: [], expr: Some(ex), ..} = block
+                    [
+                        Stmt {
+                            kind: StmtKind::Expr(ex) | StmtKind::Semi(ex),
+                            ..
+                        },
+                    ],
+                expr: None,
+                ..
+            }
+            | Block {
+                stmts: [],
+                expr: Some(ex),
+                ..
+            } = block
             && let ExprKind::AssignOp(op1, target, value) = ex.kind
             && let ty = cx.typeck_results().expr_ty(target)
             && Some(c) == get_int_max(ty)
@@ -73,7 +82,15 @@ impl<'tcx> LateLintPass<'tcx> for ImplicitSaturatingAdd {
             } else {
                 format!("{code} = {code}.saturating_add(1);")
             };
-            span_lint_and_sugg(cx, IMPLICIT_SATURATING_ADD, expr.span, "manual saturating add detected", "use instead", sugg, app);
+            span_lint_and_sugg(
+                cx,
+                IMPLICIT_SATURATING_ADD,
+                expr.span,
+                "manual saturating add detected",
+                "use instead",
+                sugg,
+                app,
+            );
         }
     }
 }
diff --git a/clippy_lints/src/implicit_saturating_sub.rs b/clippy_lints/src/implicit_saturating_sub.rs
index 3a45c68c255..fc66f86ae86 100644
--- a/clippy_lints/src/implicit_saturating_sub.rs
+++ b/clippy_lints/src/implicit_saturating_sub.rs
@@ -1,6 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::{higher, is_integer_literal, peel_blocks_with_stmt, SpanlessEq};
-use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind, QPath};
@@ -59,7 +58,6 @@ impl<'tcx> LateLintPass<'tcx> for ImplicitSaturatingSub {
 
             // Extracting out the variable name
             && let ExprKind::Path(QPath::Resolved(_, ares_path)) = target.kind
-
         {
             // Handle symmetric conditions in the if statement
             let (cond_var, cond_num_val) = if SpanlessEq::new(cx).eq_expr(cond_left, target) {
@@ -102,7 +100,7 @@ impl<'tcx> LateLintPass<'tcx> for ImplicitSaturatingSub {
                         && let None = cx.tcx.impl_trait_ref(impl_id) // An inherent impl
                         && cx.tcx.type_of(impl_id).instantiate_identity().is_integral()
                     {
-                        print_lint_and_sugg(cx, var_name, expr)
+                        print_lint_and_sugg(cx, var_name, expr);
                     }
                 },
                 ExprKind::Call(func, []) => {
@@ -113,7 +111,7 @@ impl<'tcx> LateLintPass<'tcx> for ImplicitSaturatingSub {
                         && let None = cx.tcx.impl_trait_ref(impl_id) // An inherent impl
                         && cx.tcx.type_of(impl_id).instantiate_identity().is_integral()
                     {
-                        print_lint_and_sugg(cx, var_name, expr)
+                        print_lint_and_sugg(cx, var_name, expr);
                     }
                 },
                 _ => (),
@@ -131,9 +129,7 @@ fn subtracts_one<'a>(cx: &LateContext<'_>, expr: &'a Expr<'a>) -> Option<&'a Exp
         ExprKind::Assign(target, value, _) => {
             if let ExprKind::Binary(ref op1, left1, right1) = value.kind
                 && BinOpKind::Sub == op1.node
-
                 && SpanlessEq::new(cx).eq_expr(left1, target)
-
                 && is_integer_literal(right1, 1)
             {
                 Some(target)
diff --git a/clippy_lints/src/inconsistent_struct_constructor.rs b/clippy_lints/src/inconsistent_struct_constructor.rs
index 14842800b57..f6e1281a291 100644
--- a/clippy_lints/src/inconsistent_struct_constructor.rs
+++ b/clippy_lints/src/inconsistent_struct_constructor.rs
@@ -1,6 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet;
-use if_chain::if_chain;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::Applicability;
 use rustc_hir::{self as hir, ExprKind};
@@ -94,14 +93,15 @@ impl<'tcx> LateLintPass<'tcx> for InconsistentStructConstructor {
             fields_snippet.push_str(&last_ident.to_string());
 
             let base_snippet = if let Some(base) = base {
-                    format!(", ..{}", snippet(cx, base.span, ".."))
-                } else {
-                    String::new()
-                };
+                format!(", ..{}", snippet(cx, base.span, ".."))
+            } else {
+                String::new()
+            };
 
-            let sugg = format!("{} {{ {fields_snippet}{base_snippet} }}",
+            let sugg = format!(
+                "{} {{ {fields_snippet}{base_snippet} }}",
                 snippet(cx, qpath.span(), ".."),
-                );
+            );
 
             span_lint_and_sugg(
                 cx,
@@ -111,7 +111,7 @@ impl<'tcx> LateLintPass<'tcx> for InconsistentStructConstructor {
                 "try",
                 sugg,
                 Applicability::MachineApplicable,
-            )
+            );
         }
     }
 }
diff --git a/clippy_lints/src/index_refutable_slice.rs b/clippy_lints/src/index_refutable_slice.rs
index 5b831af3045..fa6536db796 100644
--- a/clippy_lints/src/index_refutable_slice.rs
+++ b/clippy_lints/src/index_refutable_slice.rs
@@ -4,7 +4,6 @@ use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::higher::IfLet;
 use clippy_utils::ty::is_copy;
 use clippy_utils::{is_expn_of, is_lint_allowed, path_to_local};
-use if_chain::if_chain;
 use rustc_data_structures::fx::{FxHashSet, FxIndexMap};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
@@ -71,10 +70,9 @@ impl_lint_pass!(IndexRefutableSlice => [INDEX_REFUTABLE_SLICE]);
 impl<'tcx> LateLintPass<'tcx> for IndexRefutableSlice {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
         if (!expr.span.from_expansion() || is_expn_of(expr.span, "if_chain").is_some())
-            && let Some(IfLet {let_pat, if_then, ..}) = IfLet::hir(cx, expr)
+            && let Some(IfLet { let_pat, if_then, .. }) = IfLet::hir(cx, expr)
             && !is_lint_allowed(cx, INDEX_REFUTABLE_SLICE, expr.hir_id)
             && self.msrv.meets(msrvs::SLICE_PATTERNS)
-
             && let found_slices = find_slice_values(cx, let_pat)
             && !found_slices.is_empty()
             && let filtered_slices = filter_lintable_slices(cx, found_slices, self.max_suggested_slice, if_then)
diff --git a/clippy_lints/src/instant_subtraction.rs b/clippy_lints/src/instant_subtraction.rs
index d8966dddeac..8e84c73666f 100644
--- a/clippy_lints/src/instant_subtraction.rs
+++ b/clippy_lints/src/instant_subtraction.rs
@@ -90,22 +90,16 @@ impl LateLintPass<'_> for InstantSubtraction {
         ) = expr.kind
         {
             if is_instant_now_call(cx, lhs)
-
                 && is_an_instant(cx, rhs)
                 && let Some(sugg) = Sugg::hir_opt(cx, rhs)
-
             {
-                print_manual_instant_elapsed_sugg(cx, expr, sugg)
-            } else {
-                if !expr.span.from_expansion()
-                    && self.msrv.meets(msrvs::TRY_FROM)
-
-                    && is_an_instant(cx, lhs)
-                    && is_a_duration(cx, rhs)
-
-                {
-                    print_unchecked_duration_subtraction_sugg(cx, lhs, rhs, expr)
-                }
+                print_manual_instant_elapsed_sugg(cx, expr, sugg);
+            } else if !expr.span.from_expansion()
+                && self.msrv.meets(msrvs::TRY_FROM)
+                && is_an_instant(cx, lhs)
+                && is_a_duration(cx, rhs)
+            {
+                print_unchecked_duration_subtraction_sugg(cx, lhs, rhs, expr);
             }
         }
     }
diff --git a/clippy_lints/src/large_const_arrays.rs b/clippy_lints/src/large_const_arrays.rs
index 385945045bc..7db088f986f 100644
--- a/clippy_lints/src/large_const_arrays.rs
+++ b/clippy_lints/src/large_const_arrays.rs
@@ -1,5 +1,4 @@
 use clippy_utils::diagnostics::span_lint_and_then;
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
@@ -59,7 +58,6 @@ impl<'tcx> LateLintPass<'tcx> for LargeConstArrays {
             && let Ok(element_count) = element_count.try_to_target_usize(cx.tcx)
             && let Ok(element_size) = cx.layout_of(*element_type).map(|l| l.size.bytes())
             && self.maximum_allowed_size < u128::from(element_count) * u128::from(element_size)
-
         {
             let hi_pos = item.ident.span.lo() - BytePos::from_usize(1);
             let sugg_span = Span::new(
@@ -80,7 +78,7 @@ impl<'tcx> LateLintPass<'tcx> for LargeConstArrays {
                         "static",
                         Applicability::MachineApplicable,
                     );
-                }
+                },
             );
         }
     }
diff --git a/clippy_lints/src/large_include_file.rs b/clippy_lints/src/large_include_file.rs
index f998a00edee..902b72ba5e4 100644
--- a/clippy_lints/src/large_include_file.rs
+++ b/clippy_lints/src/large_include_file.rs
@@ -53,7 +53,7 @@ impl LateLintPass<'_> for LargeIncludeFile {
         if let Some(macro_call) = root_macro_call_first_node(cx, expr)
             && !is_lint_allowed(cx, LARGE_INCLUDE_FILE, expr.hir_id)
             && (cx.tcx.is_diagnostic_item(sym::include_bytes_macro, macro_call.def_id)
-            || cx.tcx.is_diagnostic_item(sym::include_str_macro, macro_call.def_id))
+                || cx.tcx.is_diagnostic_item(sym::include_str_macro, macro_call.def_id))
             && let ExprKind::Lit(lit) = &expr.kind
         {
             let len = match &lit.node {
diff --git a/clippy_lints/src/len_zero.rs b/clippy_lints/src/len_zero.rs
index 6d9cec5e957..305dd2c7f29 100644
--- a/clippy_lints/src/len_zero.rs
+++ b/clippy_lints/src/len_zero.rs
@@ -2,7 +2,6 @@ use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg, span_lint_and_the
 use clippy_utils::source::snippet_with_context;
 use clippy_utils::sugg::Sugg;
 use clippy_utils::{get_item_name, get_parent_as_impl, is_lint_allowed, peel_ref_operators};
-use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::def::Res;
@@ -144,10 +143,8 @@ impl<'tcx> LateLintPass<'tcx> for LenZero {
             && let Some(local_id) = ty_id.as_local()
             && let ty_hir_id = cx.tcx.hir().local_def_id_to_hir_id(local_id)
             && !is_lint_allowed(cx, LEN_WITHOUT_IS_EMPTY, ty_hir_id)
-            && let Some(output) = parse_len_output(
-                cx,
-                cx.tcx.fn_sig(item.owner_id).instantiate_identity().skip_binder()
-            )
+            && let Some(output) =
+                parse_len_output(cx, cx.tcx.fn_sig(item.owner_id).instantiate_identity().skip_binder())
         {
             let (name, kind) = match cx.tcx.hir().find(ty_hir_id) {
                 Some(Node::ForeignItem(x)) => (x.ident.name, "extern type"),
@@ -156,10 +153,10 @@ impl<'tcx> LateLintPass<'tcx> for LenZero {
                     ItemKind::Enum(..) => (x.ident.name, "enum"),
                     ItemKind::Union(..) => (x.ident.name, "union"),
                     _ => (x.ident.name, "type"),
-                }
+                },
                 _ => return,
             };
-            check_for_is_empty(cx, sig.span, sig.decl.implicit_self, output, ty_id, name, kind)
+            check_for_is_empty(cx, sig.span, sig.decl.implicit_self, output, ty_id, name, kind);
         }
     }
 
diff --git a/clippy_lints/src/let_if_seq.rs b/clippy_lints/src/let_if_seq.rs
index 49c25e3dd9a..da269ec61ff 100644
--- a/clippy_lints/src/let_if_seq.rs
+++ b/clippy_lints/src/let_if_seq.rs
@@ -2,7 +2,6 @@ use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::path_to_local_id;
 use clippy_utils::source::snippet;
 use clippy_utils::visitors::is_local_used;
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_hir::{BindingAnnotation, Mutability};
@@ -65,7 +64,14 @@ impl<'tcx> LateLintPass<'tcx> for LetIfSeq {
                 && let hir::StmtKind::Local(local) = stmt.kind
                 && let hir::PatKind::Binding(mode, canonical_id, ident, None) = local.pat.kind
                 && let hir::StmtKind::Expr(if_) = expr.kind
-                && let hir::ExprKind::If(hir::Expr { kind: hir::ExprKind::DropTemps(cond), ..}, then, else_) = if_.kind
+                && let hir::ExprKind::If(
+                    hir::Expr {
+                        kind: hir::ExprKind::DropTemps(cond),
+                        ..
+                    },
+                    then,
+                    else_,
+                ) = if_.kind
                 && !is_local_used(cx, *cond, canonical_id)
                 && let hir::ExprKind::Block(then, _) = then.kind
                 && let Some(value) = check_assign(cx, canonical_id, then)
@@ -73,11 +79,13 @@ impl<'tcx> LateLintPass<'tcx> for LetIfSeq {
             {
                 let span = stmt.span.to(if_.span);
 
-                let has_interior_mutability = !cx.typeck_results().node_type(canonical_id).is_freeze(
-                    cx.tcx,
-                    cx.param_env,
-                );
-                if has_interior_mutability { return; }
+                let has_interior_mutability = !cx
+                    .typeck_results()
+                    .node_type(canonical_id)
+                    .is_freeze(cx.tcx, cx.param_env);
+                if has_interior_mutability {
+                    return;
+                }
 
                 let (default_multi_stmts, default) = if let Some(else_) = else_ {
                     if let hir::ExprKind::Block(else_, _) = else_.kind {
@@ -114,21 +122,23 @@ impl<'tcx> LateLintPass<'tcx> for LetIfSeq {
                     value=snippet(cx, value.span, "<value>"),
                     default=snippet(cx, default.span, "<default>"),
                 );
-                span_lint_and_then(cx,
-                                   USELESS_LET_IF_SEQ,
-                                   span,
-                                   "`if _ { .. } else { .. }` is an expression",
-                                   |diag| {
-                                       diag.span_suggestion(
-                                            span,
-                                            "it is more idiomatic to write",
-                                            sug,
-                                            Applicability::HasPlaceholders,
-                                        );
-                                       if !mutability.is_empty() {
-                                           diag.note("you might not need `mut` at all");
-                                       }
-                                   });
+                span_lint_and_then(
+                    cx,
+                    USELESS_LET_IF_SEQ,
+                    span,
+                    "`if _ { .. } else { .. }` is an expression",
+                    |diag| {
+                        diag.span_suggestion(
+                            span,
+                            "it is more idiomatic to write",
+                            sug,
+                            Applicability::HasPlaceholders,
+                        );
+                        if !mutability.is_empty() {
+                            diag.note("you might not need `mut` at all");
+                        }
+                    },
+                );
             }
         }
     }
@@ -145,7 +155,12 @@ fn check_assign<'tcx>(
         && let hir::ExprKind::Assign(var, value, _) = expr.kind
         && path_to_local_id(var, decl)
     {
-        if block.stmts.iter().take(block.stmts.len()-1).any(|stmt| is_local_used(cx, stmt, decl)) {
+        if block
+            .stmts
+            .iter()
+            .take(block.stmts.len() - 1)
+            .any(|stmt| is_local_used(cx, stmt, decl))
+        {
             None
         } else {
             Some(value)
diff --git a/clippy_lints/src/let_with_type_underscore.rs b/clippy_lints/src/let_with_type_underscore.rs
index e7b887d800b..d4f410de957 100644
--- a/clippy_lints/src/let_with_type_underscore.rs
+++ b/clippy_lints/src/let_with_type_underscore.rs
@@ -44,8 +44,8 @@ impl LateLintPass<'_> for UnderscoreTyped {
                 local.span,
                 "variable declared with type underscore",
                 Some(ty.span.with_lo(local.pat.span.hi())),
-                "remove the explicit type `_` declaration"
-            )
+                "remove the explicit type `_` declaration",
+            );
         };
     }
 }
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index ab978a677c2..e5f8bd5c471 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -521,7 +521,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         store.register_late_pass(|_| {
             Box::new(utils::internal_lints::compiler_lint_functions::CompilerLintFunctions::new())
         });
-        store.register_late_pass(|_| Box::new(utils::internal_lints::if_chain_style::IfChainStyle));
         store.register_late_pass(|_| Box::new(utils::internal_lints::invalid_paths::InvalidPaths));
         store.register_late_pass(|_| {
             Box::<utils::internal_lints::interning_defined_symbol::InterningDefinedSymbol>::default()
diff --git a/clippy_lints/src/lifetimes.rs b/clippy_lints/src/lifetimes.rs
index 05cc9ac035f..b190955d54c 100644
--- a/clippy_lints/src/lifetimes.rs
+++ b/clippy_lints/src/lifetimes.rs
@@ -313,7 +313,6 @@ fn explicit_self_type<'tcx>(cx: &LateContext<'tcx>, func: &FnDecl<'tcx>, ident:
     if let Some(ident) = ident
         && ident.name == kw::SelfLower
         && !func.implicit_self.has_implicit_self()
-
         && let Some(self_ty) = func.inputs.first()
     {
         let mut visitor = RefVisitor::new(cx);
diff --git a/clippy_lints/src/literal_representation.rs b/clippy_lints/src/literal_representation.rs
index 1e67183f13a..8f34a9b1fed 100644
--- a/clippy_lints/src/literal_representation.rs
+++ b/clippy_lints/src/literal_representation.rs
@@ -4,7 +4,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::numeric_literal::{NumericLiteral, Radix};
 use clippy_utils::source::snippet_opt;
-use if_chain::if_chain;
 use rustc_ast::ast::{Expr, ExprKind, LitKind};
 use rustc_ast::token;
 use rustc_errors::Applicability;
@@ -268,18 +267,17 @@ impl LiteralDigitGrouping {
             }
 
             let result = (|| {
-
                 let integral_group_size = Self::get_group_size(num_lit.integer.split('_'), num_lit.radix, true)?;
                 if let Some(fraction) = num_lit.fraction {
-                    let fractional_group_size = Self::get_group_size(
-                        fraction.rsplit('_'),
-                        num_lit.radix,
-                        self.lint_fraction_readability)?;
-
-                    let consistent = Self::parts_consistent(integral_group_size,
-                                                            fractional_group_size,
-                                                            num_lit.integer.len(),
-                                                            fraction.len());
+                    let fractional_group_size =
+                        Self::get_group_size(fraction.rsplit('_'), num_lit.radix, self.lint_fraction_readability)?;
+
+                    let consistent = Self::parts_consistent(
+                        integral_group_size,
+                        fractional_group_size,
+                        num_lit.integer.len(),
+                        fraction.len(),
+                    );
                     if !consistent {
                         return Err(WarningType::InconsistentDigitGrouping);
                     };
@@ -288,18 +286,13 @@ impl LiteralDigitGrouping {
                 Ok(())
             })();
 
-
             if let Err(warning_type) = result {
                 let should_warn = match warning_type {
-                    | WarningType::UnreadableLiteral
+                    WarningType::UnreadableLiteral
                     | WarningType::InconsistentDigitGrouping
                     | WarningType::UnusualByteGroupings
-                    | WarningType::LargeDigitGroups => {
-                        !span.from_expansion()
-                    }
-                    WarningType::DecimalRepresentation | WarningType::MistypedLiteralSuffix => {
-                        true
-                    }
+                    | WarningType::LargeDigitGroups => !span.from_expansion(),
+                    WarningType::DecimalRepresentation | WarningType::MistypedLiteralSuffix => true,
                 };
                 if should_warn {
                     warning_type.display(num_lit.format(), cx, span);
diff --git a/clippy_lints/src/loops/explicit_counter_loop.rs b/clippy_lints/src/loops/explicit_counter_loop.rs
index f49508cf97d..277062a8490 100644
--- a/clippy_lints/src/loops/explicit_counter_loop.rs
+++ b/clippy_lints/src/loops/explicit_counter_loop.rs
@@ -2,7 +2,6 @@ use super::{make_iterator_snippet, IncrementVisitor, InitializeVisitor, EXPLICIT
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::{get_enclosing_block, is_integer_const};
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_block, walk_expr};
 use rustc_hir::{Expr, Pat};
@@ -53,7 +52,7 @@ pub(super) fn check<'tcx>(
                             applicability,
                         );
                         return;
-                    }
+                    },
                     Some(ty::Int(int_ty)) => int_ty.name_str(),
                     Some(ty::Uint(uint_ty)) => uint_ty.name_str(),
                     _ => return,
diff --git a/clippy_lints/src/loops/manual_find.rs b/clippy_lints/src/loops/manual_find.rs
index 2b49e188e3c..c6c16f4673f 100644
--- a/clippy_lints/src/loops/manual_find.rs
+++ b/clippy_lints/src/loops/manual_find.rs
@@ -4,7 +4,6 @@ use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::implements_trait;
 use clippy_utils::{higher, is_res_lang_ctor, path_res, peel_blocks_with_stmt};
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::def::Res;
 use rustc_hir::lang_items::LangItem;
@@ -23,7 +22,11 @@ pub(super) fn check<'tcx>(
     let inner_expr = peel_blocks_with_stmt(body);
     // Check for the specific case that the result is returned and optimize suggestion for that (more
     // cases can be added later)
-    if let Some(higher::If { cond, then, r#else: None, }) = higher::If::hir(inner_expr)
+    if let Some(higher::If {
+        cond,
+        then,
+        r#else: None,
+    }) = higher::If::hir(inner_expr)
         && let Some(binding_id) = get_binding(pat)
         && let ExprKind::Block(block, _) = then.kind
         && let [stmt] = block.stmts
@@ -51,7 +54,12 @@ pub(super) fn check<'tcx>(
             );
         }
         let ty = cx.typeck_results().expr_ty(inner_ret);
-        if cx.tcx.lang_items().copy_trait().map_or(false, |id| implements_trait(cx, ty, id, &[])) {
+        if cx
+            .tcx
+            .lang_items()
+            .copy_trait()
+            .map_or(false, |id| implements_trait(cx, ty, id, &[]))
+        {
             snippet.push_str(
                 &format!(
                     ".find(|{}{}| {})",
@@ -84,12 +92,7 @@ pub(super) fn check<'tcx>(
                 if applicability == Applicability::MaybeIncorrect {
                     diag.note("you may need to dereference some variables");
                 }
-                diag.span_suggestion(
-                    lint_span,
-                    "replace with an iterator",
-                    snippet,
-                    applicability,
-                );
+                diag.span_suggestion(lint_span, "replace with an iterator", snippet, applicability);
             },
         );
     }
diff --git a/clippy_lints/src/loops/manual_flatten.rs b/clippy_lints/src/loops/manual_flatten.rs
index 7659b506e97..de4e13bd84f 100644
--- a/clippy_lints/src/loops/manual_flatten.rs
+++ b/clippy_lints/src/loops/manual_flatten.rs
@@ -3,7 +3,6 @@ use super::MANUAL_FLATTEN;
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::visitors::is_local_used;
 use clippy_utils::{higher, path_to_local_id, peel_blocks_with_stmt};
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::{Expr, Pat, PatKind};
@@ -38,7 +37,8 @@ pub(super) fn check<'tcx>(
     {
         let if_let_type = if some_ctor { "Some" } else { "Ok" };
         // Prepare the error message
-        let msg = format!("unnecessary `if let` since only the `{if_let_type}` variant of the iterator element is used");
+        let msg =
+            format!("unnecessary `if let` since only the `{if_let_type}` variant of the iterator element is used");
 
         // Prepare the help message
         let mut applicability = Applicability::MaybeIncorrect;
@@ -46,39 +46,25 @@ pub(super) fn check<'tcx>(
         let copied = match cx.typeck_results().expr_ty(let_expr).kind() {
             ty::Ref(_, inner, _) => match inner.kind() {
                 ty::Ref(..) => ".copied()",
-                _ => ""
-            }
-            _ => ""
+                _ => "",
+            },
+            _ => "",
         };
 
         let sugg = format!("{arg_snippet}{copied}.flatten()");
 
-        // If suggestion is not a one-liner, it won't be shown inline within the error message. In that case,
-        // it will be shown in the extra `help` message at the end, which is why the first `help_msg` needs
-        // to refer to the correct relative position of the suggestion.
+        // If suggestion is not a one-liner, it won't be shown inline within the error message. In that
+        // case, it will be shown in the extra `help` message at the end, which is why the first
+        // `help_msg` needs to refer to the correct relative position of the suggestion.
         let help_msg = if sugg.contains('\n') {
             "remove the `if let` statement in the for loop and then..."
         } else {
             "...and remove the `if let` statement in the for loop"
         };
 
-        span_lint_and_then(
-            cx,
-            MANUAL_FLATTEN,
-            span,
-            &msg,
-            |diag| {
-                diag.span_suggestion(
-                    arg.span,
-                    "try",
-                    sugg,
-                    applicability,
-                );
-                diag.span_help(
-                    inner_expr.span,
-                    help_msg,
-                );
-            }
-        );
+        span_lint_and_then(cx, MANUAL_FLATTEN, span, &msg, |diag| {
+            diag.span_suggestion(arg.span, "try", sugg, applicability);
+            diag.span_help(inner_expr.span, help_msg);
+        });
     }
 }
diff --git a/clippy_lints/src/loops/manual_memcpy.rs b/clippy_lints/src/loops/manual_memcpy.rs
index 9be888578b5..89f70519c20 100644
--- a/clippy_lints/src/loops/manual_memcpy.rs
+++ b/clippy_lints/src/loops/manual_memcpy.rs
@@ -4,7 +4,6 @@ use clippy_utils::source::snippet;
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::is_copy;
 use clippy_utils::{get_enclosing_block, higher, path_to_local, sugg};
-use if_chain::if_chain;
 use rustc_ast::ast;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::walk_block;
@@ -69,8 +68,19 @@ pub(super) fn check<'tcx>(
                             // Source and destination must be different
                             && path_to_local(base_left) != path_to_local(base_right)
                         {
-                            Some((ty, IndexExpr { base: base_left, idx: start_left, idx_offset: offset_left },
-                                IndexExpr { base: base_right, idx: start_right, idx_offset: offset_right }))
+                            Some((
+                                ty,
+                                IndexExpr {
+                                    base: base_left,
+                                    idx: start_left,
+                                    idx_offset: offset_left,
+                                },
+                                IndexExpr {
+                                    base: base_right,
+                                    idx: start_right,
+                                    idx_offset: offset_right,
+                                },
+                            ))
                         } else {
                             None
                         }
@@ -127,9 +137,7 @@ fn build_manual_memcpy_suggestion<'tcx>(
             }
         } else {
             match limits {
-                ast::RangeLimits::Closed => {
-                    sugg + &sugg::ONE.into()
-                },
+                ast::RangeLimits::Closed => sugg + &sugg::ONE.into(),
                 ast::RangeLimits::HalfOpen => sugg,
             }
         }
@@ -329,7 +337,11 @@ fn get_slice_like_element_ty<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Opti
 fn fetch_cloned_expr<'tcx>(expr: &'tcx Expr<'tcx>) -> &'tcx Expr<'tcx> {
     if let ExprKind::MethodCall(method, arg, [], _) = expr.kind
         && method.ident.name == sym::clone
-    { arg } else { expr }
+    {
+        arg
+    } else {
+        expr
+    }
 }
 
 fn get_details_from_idx<'tcx>(
diff --git a/clippy_lints/src/loops/missing_spin_loop.rs b/clippy_lints/src/loops/missing_spin_loop.rs
index f332cd87707..e405829b2f4 100644
--- a/clippy_lints/src/loops/missing_spin_loop.rs
+++ b/clippy_lints/src/loops/missing_spin_loop.rs
@@ -31,7 +31,12 @@ fn unpack_cond<'tcx>(cond: &'tcx Expr<'tcx>) -> &'tcx Expr<'tcx> {
 }
 
 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, cond: &'tcx Expr<'_>, body: &'tcx Expr<'_>) {
-    if let ExprKind::Block(Block { stmts: [], expr: None, ..}, _) = body.kind
+    if let ExprKind::Block(
+        Block {
+            stmts: [], expr: None, ..
+        },
+        _,
+    ) = body.kind
         && let ExprKind::MethodCall(method, callee, ..) = unpack_cond(cond).kind
         && [sym::load, sym::compare_exchange, sym::compare_exchange_weak].contains(&method.ident.name)
         && let ty::Adt(def, _args) = cx.typeck_results().expr_ty(callee).kind()
@@ -47,8 +52,9 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, cond: &'tcx Expr<'_>, body: &'
                 "{ core::hint::spin_loop() }"
             } else {
                 "{ std::hint::spin_loop() }"
-            }).into(),
-            Applicability::MachineApplicable
+            })
+            .into(),
+            Applicability::MachineApplicable,
         );
     }
 }
diff --git a/clippy_lints/src/loops/mut_range_bound.rs b/clippy_lints/src/loops/mut_range_bound.rs
index ad0b7e33354..6e3477a1c76 100644
--- a/clippy_lints/src/loops/mut_range_bound.rs
+++ b/clippy_lints/src/loops/mut_range_bound.rs
@@ -1,7 +1,6 @@
 use super::MUT_RANGE_BOUND;
 use clippy_utils::diagnostics::span_lint_and_note;
 use clippy_utils::{get_enclosing_block, higher, path_to_local};
-use if_chain::if_chain;
 use rustc_hir::intravisit::{self, Visitor};
 use rustc_hir::{BindingAnnotation, Expr, ExprKind, HirId, Node, PatKind};
 use rustc_hir_typeck::expr_use_visitor::{Delegate, ExprUseVisitor, PlaceBase, PlaceWithHirId};
@@ -13,10 +12,10 @@ use rustc_span::source_map::Span;
 
 pub(super) fn check(cx: &LateContext<'_>, arg: &Expr<'_>, body: &Expr<'_>) {
     if let Some(higher::Range {
-            start: Some(start),
-            end: Some(end),
-            ..
-        }) = higher::Range::hir(arg)
+        start: Some(start),
+        end: Some(end),
+        ..
+    }) = higher::Range::hir(arg)
         && let (mut_id_start, mut_id_end) = (check_for_mutability(cx, start), check_for_mutability(cx, end))
         && (mut_id_start.is_some() || mut_id_end.is_some())
     {
diff --git a/clippy_lints/src/loops/needless_range_loop.rs b/clippy_lints/src/loops/needless_range_loop.rs
index 036247c2318..e2be861a708 100644
--- a/clippy_lints/src/loops/needless_range_loop.rs
+++ b/clippy_lints/src/loops/needless_range_loop.rs
@@ -4,7 +4,6 @@ use clippy_utils::source::snippet;
 use clippy_utils::ty::has_iter_method;
 use clippy_utils::visitors::is_local_used;
 use clippy_utils::{contains_name, higher, is_integer_const, sugg, SpanlessEq};
-use if_chain::if_chain;
 use rustc_ast::ast;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_hir::def::{DefKind, Res};
diff --git a/clippy_lints/src/loops/same_item_push.rs b/clippy_lints/src/loops/same_item_push.rs
index 0c0a9138b27..15e11fd386c 100644
--- a/clippy_lints/src/loops/same_item_push.rs
+++ b/clippy_lints/src/loops/same_item_push.rs
@@ -3,7 +3,6 @@ use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::path_to_local;
 use clippy_utils::source::snippet_with_context;
 use clippy_utils::ty::{implements_trait, is_type_diagnostic_item};
-use if_chain::if_chain;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Applicability;
 use rustc_hir::def::{DefKind, Res};
@@ -76,7 +75,7 @@ pub(super) fn check<'tcx>(
                                     if let Res::Def(DefKind::Const, ..) = cx.qpath_res(path, init.hir_id) {
                                         emit_lint(cx, vec, pushed_item, ctxt);
                                     }
-                                }
+                                },
                                 _ => {},
                             }
                         }
@@ -182,8 +181,8 @@ fn get_vec_push<'tcx>(
             // Check that the method being called is push() on a Vec
             && is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(self_expr), sym::Vec)
             && path.ident.name.as_str() == "push"
-        {
-            return Some((self_expr, pushed_item, semi_stmt.span.ctxt()))
-        }
+    {
+        return Some((self_expr, pushed_item, semi_stmt.span.ctxt()));
+    }
     None
 }
diff --git a/clippy_lints/src/loops/single_element_loop.rs b/clippy_lints/src/loops/single_element_loop.rs
index 0511ec011c4..d860b297a02 100644
--- a/clippy_lints/src/loops/single_element_loop.rs
+++ b/clippy_lints/src/loops/single_element_loop.rs
@@ -2,7 +2,6 @@ use super::SINGLE_ELEMENT_LOOP;
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::{indent_of, snippet_with_applicability};
 use clippy_utils::visitors::contains_break_or_continue;
-use if_chain::if_chain;
 use rustc_ast::util::parser::PREC_PREFIX;
 use rustc_ast::Mutability;
 use rustc_errors::Applicability;
@@ -79,10 +78,12 @@ pub(super) fn check<'tcx>(
         let indent = " ".repeat(indent_of(cx, block.stmts[0].span).unwrap_or(0));
 
         // Reference iterator from `&(mut) []` or `[].iter(_mut)()`.
-        if !prefix.is_empty() && (
-            // Precedence of internal expression is less than or equal to precedence of `&expr`.
-            arg_expression.precedence().order() <= PREC_PREFIX || is_range_literal(arg_expression)
-        ) {
+        if !prefix.is_empty()
+            && (
+                // Precedence of internal expression is less than or equal to precedence of `&expr`.
+                arg_expression.precedence().order() <= PREC_PREFIX || is_range_literal(arg_expression)
+            )
+        {
             arg_snip = format!("({arg_snip})").into();
         }
 
@@ -94,6 +95,6 @@ pub(super) fn check<'tcx>(
             "try",
             format!("{{\n{indent}let {pat_snip} = {prefix}{arg_snip};{block_str}}}"),
             applicability,
-        )
+        );
     }
 }
diff --git a/clippy_lints/src/loops/utils.rs b/clippy_lints/src/loops/utils.rs
index c4d89dc3f0e..38fdca573c6 100644
--- a/clippy_lints/src/loops/utils.rs
+++ b/clippy_lints/src/loops/utils.rs
@@ -1,6 +1,5 @@
 use clippy_utils::ty::{has_iter_method, implements_trait};
 use clippy_utils::{get_parent_expr, is_integer_const, path_to_local, path_to_local_id, sugg};
-use if_chain::if_chain;
 use rustc_ast::ast::{LitIntType, LitKind};
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_expr, walk_local, walk_pat, walk_stmt, Visitor};
@@ -156,7 +155,7 @@ impl<'a, 'tcx> Visitor<'tcx> for InitializeVisitor<'a, 'tcx> {
                     ty,
                     name: ident.name,
                 }
-            })
+            });
         }
 
         walk_local(self, l);
diff --git a/clippy_lints/src/loops/while_immutable_condition.rs b/clippy_lints/src/loops/while_immutable_condition.rs
index d5b50db4501..9fd9b7a1631 100644
--- a/clippy_lints/src/loops/while_immutable_condition.rs
+++ b/clippy_lints/src/loops/while_immutable_condition.rs
@@ -2,7 +2,6 @@ use super::WHILE_IMMUTABLE_CONDITION;
 use clippy_utils::consts::constant;
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::usage::mutated_variables;
-use if_chain::if_chain;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::def_id::DefIdMap;
 use rustc_hir::intravisit::{walk_expr, Visitor};
diff --git a/clippy_lints/src/loops/while_let_on_iterator.rs b/clippy_lints/src/loops/while_let_on_iterator.rs
index 144f4b0fb4c..21b9efba54c 100644
--- a/clippy_lints/src/loops/while_let_on_iterator.rs
+++ b/clippy_lints/src/loops/while_let_on_iterator.rs
@@ -3,7 +3,6 @@ use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::visitors::is_res_used;
 use clippy_utils::{get_enclosing_loop_or_multi_call_closure, higher, is_refutable, is_res_lang_ctor, is_trait_method};
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::def::Res;
 use rustc_hir::intravisit::{walk_expr, Visitor};
@@ -15,7 +14,7 @@ use rustc_span::symbol::sym;
 use rustc_span::Symbol;
 
 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-    let (scrutinee_expr, iter_expr_struct, iter_expr, some_pat, loop_expr) = if let Some(higher::WhileLet { if_then, let_pat, let_expr }) = higher::WhileLet::hir(expr)
+    if let Some(higher::WhileLet { if_then, let_pat, let_expr }) = higher::WhileLet::hir(expr)
         // check for `Some(..)` pattern
         && let PatKind::TupleStruct(ref pat_path, some_pat, _) = let_pat.kind
         && is_res_lang_ctor(cx, cx.qpath_res(pat_path, let_pat.hir_id), LangItem::OptionSome)
@@ -27,45 +26,41 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         // get the loop containing the match expression
         && !uses_iter(cx, &iter_expr_struct, if_then)
     {
-        (let_expr, iter_expr_struct, iter_expr, some_pat, expr)
-    } else {
-        return;
-    };
-
-    let mut applicability = Applicability::MachineApplicable;
-    let loop_var = if let Some(some_pat) = some_pat.first() {
-        if is_refutable(cx, some_pat) {
-            // Refutable patterns don't work with for loops.
-            return;
-        }
-        snippet_with_applicability(cx, some_pat.span, "..", &mut applicability)
-    } else {
-        "_".into()
-    };
+        let mut applicability = Applicability::MachineApplicable;
+        let loop_var = if let Some(some_pat) = some_pat.first() {
+            if is_refutable(cx, some_pat) {
+                // Refutable patterns don't work with for loops.
+                return;
+            }
+            snippet_with_applicability(cx, some_pat.span, "..", &mut applicability)
+        } else {
+            "_".into()
+        };
 
-    // If the iterator is a field or the iterator is accessed after the loop is complete it needs to be
-    // borrowed mutably. TODO: If the struct can be partially moved from and the struct isn't used
-    // afterwards a mutable borrow of a field isn't necessary.
-    let by_ref = if cx.typeck_results().expr_ty(iter_expr).ref_mutability() == Some(Mutability::Mut)
-        || !iter_expr_struct.can_move
-        || !iter_expr_struct.fields.is_empty()
-        || needs_mutable_borrow(cx, &iter_expr_struct, loop_expr)
-    {
-        ".by_ref()"
-    } else {
-        ""
-    };
+        // If the iterator is a field or the iterator is accessed after the loop is complete it needs to be
+        // borrowed mutably. TODO: If the struct can be partially moved from and the struct isn't used
+        // afterwards a mutable borrow of a field isn't necessary.
+        let by_ref = if cx.typeck_results().expr_ty(iter_expr).ref_mutability() == Some(Mutability::Mut)
+            || !iter_expr_struct.can_move
+            || !iter_expr_struct.fields.is_empty()
+            || needs_mutable_borrow(cx, &iter_expr_struct, expr)
+        {
+            ".by_ref()"
+        } else {
+            ""
+        };
 
-    let iterator = snippet_with_applicability(cx, iter_expr.span, "_", &mut applicability);
-    span_lint_and_sugg(
-        cx,
-        WHILE_LET_ON_ITERATOR,
-        expr.span.with_hi(scrutinee_expr.span.hi()),
-        "this loop could be written as a `for` loop",
-        "try",
-        format!("for {loop_var} in {iterator}{by_ref}"),
-        applicability,
-    );
+        let iterator = snippet_with_applicability(cx, iter_expr.span, "_", &mut applicability);
+        span_lint_and_sugg(
+            cx,
+            WHILE_LET_ON_ITERATOR,
+            expr.span.with_hi(let_expr.span.hi()),
+            "this loop could be written as a `for` loop",
+            "try",
+            format!("for {loop_var} in {iterator}{by_ref}"),
+            applicability,
+        );
+    }
 }
 
 #[derive(Debug)]
diff --git a/clippy_lints/src/macro_use.rs b/clippy_lints/src/macro_use.rs
index 42987e583af..6f1c5461dc0 100644
--- a/clippy_lints/src/macro_use.rs
+++ b/clippy_lints/src/macro_use.rs
@@ -1,7 +1,6 @@
 use clippy_utils::diagnostics::span_lint_hir_and_then;
 use clippy_utils::source::snippet;
 use hir::def::{DefKind, Res};
-use if_chain::if_chain;
 use rustc_ast::ast;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_errors::Applicability;
@@ -108,10 +107,8 @@ impl<'tcx> LateLintPass<'tcx> for MacroUseImports {
                     self.imports.push((def_path, span, hir_id));
                 }
             }
-        } else {
-            if item.span.from_expansion() {
-                self.push_unique_macro_pat_ty(cx, item.span);
-            }
+        } else if item.span.from_expansion() {
+            self.push_unique_macro_pat_ty(cx, item.span);
         }
     }
     fn check_attribute(&mut self, cx: &LateContext<'_>, attr: &ast::Attribute) {
diff --git a/clippy_lints/src/main_recursion.rs b/clippy_lints/src/main_recursion.rs
index 0be0b2850c4..ea1d25d80e1 100644
--- a/clippy_lints/src/main_recursion.rs
+++ b/clippy_lints/src/main_recursion.rs
@@ -1,7 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::source::snippet;
 use clippy_utils::{is_entrypoint_fn, is_no_std_crate};
-use if_chain::if_chain;
 use rustc_hir::{Expr, ExprKind, QPath};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
@@ -54,8 +53,8 @@ impl LateLintPass<'_> for MainRecursion {
                 func.span,
                 &format!("recursing into entrypoint `{}`", snippet(cx, func.span, "main")),
                 None,
-                "consider using another function for this recursion"
-            )
+                "consider using another function for this recursion",
+            );
         }
     }
 }
diff --git a/clippy_lints/src/manual_async_fn.rs b/clippy_lints/src/manual_async_fn.rs
index efa40a9929c..a5d91c949bc 100644
--- a/clippy_lints/src/manual_async_fn.rs
+++ b/clippy_lints/src/manual_async_fn.rs
@@ -1,6 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::{position_before_rarrow, snippet_block, snippet_opt};
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::{
@@ -85,7 +84,7 @@ impl<'tcx> LateLintPass<'tcx> for ManualAsyncFn {
                             header_span,
                             help,
                             format!("{header_snip}{ret_snip}"),
-                            Applicability::MachineApplicable
+                            Applicability::MachineApplicable,
                         );
 
                         let body_snip = snippet_block(cx, closure_body.value.span, "..", Some(block.span));
@@ -93,7 +92,7 @@ impl<'tcx> LateLintPass<'tcx> for ManualAsyncFn {
                             block.span,
                             "move the body of the async block to the enclosing function",
                             body_snip,
-                            Applicability::MachineApplicable
+                            Applicability::MachineApplicable,
                         );
                     }
                 },
diff --git a/clippy_lints/src/manual_bits.rs b/clippy_lints/src/manual_bits.rs
index 3452177c525..69c65cf305c 100644
--- a/clippy_lints/src/manual_bits.rs
+++ b/clippy_lints/src/manual_bits.rs
@@ -98,16 +98,18 @@ fn get_one_size_of_ty<'tcx>(
 fn get_size_of_ty<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<(&'tcx rustc_hir::Ty<'tcx>, Ty<'tcx>)> {
     if let ExprKind::Call(count_func, _func_args) = expr.kind
         && let ExprKind::Path(ref count_func_qpath) = count_func.kind
-
         && let QPath::Resolved(_, count_func_path) = count_func_qpath
         && let Some(segment_zero) = count_func_path.segments.first()
         && let Some(args) = segment_zero.args
         && let Some(GenericArg::Type(real_ty)) = args.args.first()
-
         && let Some(def_id) = cx.qpath_res(count_func_qpath, count_func.hir_id).opt_def_id()
         && cx.tcx.is_diagnostic_item(sym::mem_size_of, def_id)
     {
-        cx.typeck_results().node_args(count_func.hir_id).types().next().map(|resolved_ty| (*real_ty, resolved_ty))
+        cx.typeck_results()
+            .node_args(count_func.hir_id)
+            .types()
+            .next()
+            .map(|resolved_ty| (*real_ty, resolved_ty))
     } else {
         None
     }
diff --git a/clippy_lints/src/manual_strip.rs b/clippy_lints/src/manual_strip.rs
index 0559dc39363..b41bf2d767e 100644
--- a/clippy_lints/src/manual_strip.rs
+++ b/clippy_lints/src/manual_strip.rs
@@ -4,7 +4,6 @@ use clippy_utils::diagnostics::{multispan_sugg, span_lint_and_then};
 use clippy_utils::source::snippet;
 use clippy_utils::usage::mutated_variables;
 use clippy_utils::{eq_expr_value, higher, match_def_path, paths};
-use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
 use rustc_hir::def::Res;
 use rustc_hir::intravisit::{walk_expr, Visitor};
@@ -97,25 +96,35 @@ impl<'tcx> LateLintPass<'tcx> for ManualStrip {
 
             let strippings = find_stripping(cx, strip_kind, target_res, pattern, then);
             if !strippings.is_empty() {
-
                 let kind_word = match strip_kind {
                     StripKind::Prefix => "prefix",
                     StripKind::Suffix => "suffix",
                 };
 
                 let test_span = expr.span.until(then.span);
-                span_lint_and_then(cx, MANUAL_STRIP, strippings[0], &format!("stripping a {kind_word} manually"), |diag| {
-                    diag.span_note(test_span, format!("the {kind_word} was tested here"));
-                    multispan_sugg(
-                        diag,
-                        &format!("try using the `strip_{kind_word}` method"),
-                        vec![(test_span,
-                              format!("if let Some(<stripped>) = {}.strip_{kind_word}({}) ",
-                                      snippet(cx, target_arg.span, ".."),
-                                      snippet(cx, pattern.span, "..")))]
-                        .into_iter().chain(strippings.into_iter().map(|span| (span, "<stripped>".into()))),
-                    );
-                });
+                span_lint_and_then(
+                    cx,
+                    MANUAL_STRIP,
+                    strippings[0],
+                    &format!("stripping a {kind_word} manually"),
+                    |diag| {
+                        diag.span_note(test_span, format!("the {kind_word} was tested here"));
+                        multispan_sugg(
+                            diag,
+                            &format!("try using the `strip_{kind_word}` method"),
+                            vec![(
+                                test_span,
+                                format!(
+                                    "if let Some(<stripped>) = {}.strip_{kind_word}({}) ",
+                                    snippet(cx, target_arg.span, ".."),
+                                    snippet(cx, pattern.span, "..")
+                                ),
+                            )]
+                            .into_iter()
+                            .chain(strippings.into_iter().map(|span| (span, "<stripped>".into()))),
+                        );
+                    },
+                );
             }
         }
     }
@@ -210,7 +219,13 @@ fn find_stripping<'tcx>(
                         }
                     },
                     (StripKind::Suffix, None, Some(end)) => {
-                        if let ExprKind::Binary(Spanned { node: BinOpKind::Sub, .. }, left, right) = end.kind
+                        if let ExprKind::Binary(
+                            Spanned {
+                                node: BinOpKind::Sub, ..
+                            },
+                            left,
+                            right,
+                        ) = end.kind
                             && let Some(left_arg) = len_arg(self.cx, left)
                             && let ExprKind::Path(left_path) = &left_arg.kind
                             && self.cx.qpath_res(left_path, left_arg.hir_id) == self.target
@@ -220,7 +235,7 @@ fn find_stripping<'tcx>(
                             return;
                         }
                     },
-                    _ => {}
+                    _ => {},
                 }
             }
 
diff --git a/clippy_lints/src/map_unit_fn.rs b/clippy_lints/src/map_unit_fn.rs
index 03df8a67540..5cef4d91b5b 100644
--- a/clippy_lints/src/map_unit_fn.rs
+++ b/clippy_lints/src/map_unit_fn.rs
@@ -2,7 +2,6 @@ use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::{snippet, snippet_with_applicability, snippet_with_context};
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::{iter_input_pats, method_chain_args};
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/match_result_ok.rs b/clippy_lints/src/match_result_ok.rs
index 750f8305730..bf035969477 100644
--- a/clippy_lints/src/match_result_ok.rs
+++ b/clippy_lints/src/match_result_ok.rs
@@ -2,7 +2,6 @@ use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_context;
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::{higher, is_res_lang_ctor};
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, LangItem, PatKind};
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/matches/collapsible_match.rs b/clippy_lints/src/matches/collapsible_match.rs
index f9dc8440aca..48fc5746b3c 100644
--- a/clippy_lints/src/matches/collapsible_match.rs
+++ b/clippy_lints/src/matches/collapsible_match.rs
@@ -5,7 +5,6 @@ use clippy_utils::visitors::is_local_used;
 use clippy_utils::{
     is_res_lang_ctor, is_unit_expr, path_to_local, peel_blocks_with_stmt, peel_ref_operators, SpanlessEq,
 };
-use if_chain::if_chain;
 use rustc_errors::MultiSpan;
 use rustc_hir::LangItem::OptionNone;
 use rustc_hir::{Arm, Expr, Guard, HirId, Let, Pat, PatKind};
@@ -84,7 +83,11 @@ fn check_arm<'tcx>(
     {
         let msg = format!(
             "this `{}` can be collapsed into the outer `{}`",
-            if matches!(inner, IfLetOrMatch::Match(..)) { "match" } else { "if let" },
+            if matches!(inner, IfLetOrMatch::Match(..)) {
+                "match"
+            } else {
+                "if let"
+            },
             if outer_is_match { "match" } else { "if let" },
         );
         // collapsing patterns need an explicit field name in struct pattern matching
@@ -94,18 +97,15 @@ fn check_arm<'tcx>(
         } else {
             String::new()
         };
-        span_lint_and_then(
-            cx,
-            COLLAPSIBLE_MATCH,
-            inner_expr.span,
-            &msg,
-            |diag| {
-                let mut help_span = MultiSpan::from_spans(vec![binding_span, inner_then_pat.span]);
-                help_span.push_span_label(binding_span, "replace this binding");
-                help_span.push_span_label(inner_then_pat.span, format!("with this pattern{replace_msg}"));
-                diag.span_help(help_span, "the outer pattern can be modified to include the inner pattern");
-            },
-        );
+        span_lint_and_then(cx, COLLAPSIBLE_MATCH, inner_expr.span, &msg, |diag| {
+            let mut help_span = MultiSpan::from_spans(vec![binding_span, inner_then_pat.span]);
+            help_span.push_span_label(binding_span, "replace this binding");
+            help_span.push_span_label(inner_then_pat.span, format!("with this pattern{replace_msg}"));
+            diag.span_help(
+                help_span,
+                "the outer pattern can be modified to include the inner pattern",
+            );
+        });
     }
 }
 
diff --git a/clippy_lints/src/matches/infallible_destructuring_match.rs b/clippy_lints/src/matches/infallible_destructuring_match.rs
index 313a9cba327..c8a48246e67 100644
--- a/clippy_lints/src/matches/infallible_destructuring_match.rs
+++ b/clippy_lints/src/matches/infallible_destructuring_match.rs
@@ -11,14 +11,13 @@ pub(crate) fn check(cx: &LateContext<'_>, local: &Local<'_>) -> bool {
     if !local.span.from_expansion()
         && let Some(expr) = local.init
         && let ExprKind::Match(target, arms, MatchSource::Normal) = expr.kind
-        && arms.len() == 1 && arms[0].guard.is_none()
-        && let PatKind::TupleStruct(
-            QPath::Resolved(None, variant_name), args, _) = arms[0].pat.kind
+        && arms.len() == 1
+        && arms[0].guard.is_none()
+        && let PatKind::TupleStruct(QPath::Resolved(None, variant_name), args, _) = arms[0].pat.kind
         && args.len() == 1
         && let PatKind::Binding(binding, arg, ..) = strip_pat_refs(&args[0]).kind
         && let body = peel_blocks(arms[0].body)
         && path_to_local_id(body, arg)
-
     {
         let mut applicability = Applicability::MachineApplicable;
         span_lint_and_sugg(
diff --git a/clippy_lints/src/matches/manual_filter.rs b/clippy_lints/src/matches/manual_filter.rs
index bd8a9d10e8a..619ec83127a 100644
--- a/clippy_lints/src/matches/manual_filter.rs
+++ b/clippy_lints/src/matches/manual_filter.rs
@@ -23,16 +23,18 @@ fn get_cond_expr<'tcx>(
 ) -> Option<SomeExpr<'tcx>> {
     if let Some(block_expr) = peels_blocks_incl_unsafe_opt(expr)
         && let ExprKind::If(cond, then_expr, Some(else_expr)) = block_expr.kind
-        && let PatKind::Binding(_,target, ..) = pat.kind
+        && let PatKind::Binding(_, target, ..) = pat.kind
         && (is_some_expr(cx, target, ctxt, then_expr) && is_none_expr(cx, else_expr)
-            || is_none_expr(cx, then_expr) && is_some_expr(cx, target, ctxt, else_expr)) // check that one expr resolves to `Some(x)`, the other to `None`
+            || is_none_expr(cx, then_expr) && is_some_expr(cx, target, ctxt, else_expr))
+    // check that one expr resolves to `Some(x)`, the other to `None`
     {
         return Some(SomeExpr {
-                expr: peels_blocks_incl_unsafe(cond.peel_drop_temps()),
-                needs_unsafe_block: contains_unsafe_block(cx, expr),
-                needs_negated: is_none_expr(cx, then_expr) // if the `then_expr` resolves to `None`, need to negate the cond
-            })
-        };
+            expr: peels_blocks_incl_unsafe(cond.peel_drop_temps()),
+            needs_unsafe_block: contains_unsafe_block(cx, expr),
+            needs_negated: is_none_expr(cx, then_expr), /* if the `then_expr` resolves to `None`, need to negate the
+                                                         * cond */
+        });
+    };
     None
 }
 
diff --git a/clippy_lints/src/matches/manual_unwrap_or.rs b/clippy_lints/src/matches/manual_unwrap_or.rs
index 723528bbe2e..3e79cabd795 100644
--- a/clippy_lints/src/matches/manual_unwrap_or.rs
+++ b/clippy_lints/src/matches/manual_unwrap_or.rs
@@ -4,7 +4,6 @@ use clippy_utils::source::{indent_of, reindent_multiline, snippet_opt};
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::usage::contains_return_break_continue_macro;
 use clippy_utils::{is_res_lang_ctor, path_to_local_id, sugg};
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::LangItem::{OptionNone, ResultErr};
@@ -17,30 +16,27 @@ use super::MANUAL_UNWRAP_OR;
 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>, scrutinee: &'tcx Expr<'_>, arms: &'tcx [Arm<'_>]) {
     let ty = cx.typeck_results().expr_ty(scrutinee);
     if let Some(ty_name) = if is_type_diagnostic_item(cx, ty, sym::Option) {
-            Some("Option")
-        } else if is_type_diagnostic_item(cx, ty, sym::Result) {
-            Some("Result")
-        } else {
-            None
-        }
-        && let Some(or_arm) = applicable_or_arm(cx, arms)
+        Some("Option")
+    } else if is_type_diagnostic_item(cx, ty, sym::Result) {
+        Some("Result")
+    } else {
+        None
+    } && let Some(or_arm) = applicable_or_arm(cx, arms)
         && let Some(or_body_snippet) = snippet_opt(cx, or_arm.body.span)
         && let Some(indent) = indent_of(cx, expr.span)
         && constant_simple(cx, cx.typeck_results(), or_arm.body).is_some()
     {
-        let reindented_or_body =
-            reindent_multiline(or_body_snippet.into(), true, Some(indent));
+        let reindented_or_body = reindent_multiline(or_body_snippet.into(), true, Some(indent));
 
         let mut app = Applicability::MachineApplicable;
         let suggestion = sugg::Sugg::hir_with_context(cx, scrutinee, expr.span.ctxt(), "..", &mut app).maybe_par();
         span_lint_and_sugg(
             cx,
-            MANUAL_UNWRAP_OR, expr.span,
+            MANUAL_UNWRAP_OR,
+            expr.span,
             &format!("this pattern reimplements `{ty_name}::unwrap_or`"),
             "replace with",
-            format!(
-                "{suggestion}.unwrap_or({reindented_or_body})",
-            ),
+            format!("{suggestion}.unwrap_or({reindented_or_body})",),
             app,
         );
     }
@@ -49,14 +45,13 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>, scrutinee:
 fn applicable_or_arm<'a>(cx: &LateContext<'_>, arms: &'a [Arm<'a>]) -> Option<&'a Arm<'a>> {
     if arms.len() == 2
         && arms.iter().all(|arm| arm.guard.is_none())
-        && let Some((idx, or_arm)) = arms.iter().enumerate().find(|(_, arm)| {
-            match arm.pat.kind {
-                PatKind::Path(ref qpath) => is_res_lang_ctor(cx, cx.qpath_res(qpath, arm.pat.hir_id), OptionNone),
-                PatKind::TupleStruct(ref qpath, [pat], _) =>
-                    matches!(pat.kind, PatKind::Wild)
-                        && is_res_lang_ctor(cx, cx.qpath_res(qpath, arm.pat.hir_id), ResultErr),
-                _ => false,
-            }
+        && let Some((idx, or_arm)) = arms.iter().enumerate().find(|(_, arm)| match arm.pat.kind {
+            PatKind::Path(ref qpath) => is_res_lang_ctor(cx, cx.qpath_res(qpath, arm.pat.hir_id), OptionNone),
+            PatKind::TupleStruct(ref qpath, [pat], _) => {
+                matches!(pat.kind, PatKind::Wild)
+                    && is_res_lang_ctor(cx, cx.qpath_res(qpath, arm.pat.hir_id), ResultErr)
+            },
+            _ => false,
         })
         && let unwrap_arm = &arms[1 - idx]
         && let PatKind::TupleStruct(ref qpath, [unwrap_pat], _) = unwrap_arm.pat.kind
diff --git a/clippy_lints/src/matches/match_as_ref.rs b/clippy_lints/src/matches/match_as_ref.rs
index 812a0aab94f..3f737da92c0 100644
--- a/clippy_lints/src/matches/match_as_ref.rs
+++ b/clippy_lints/src/matches/match_as_ref.rs
@@ -71,9 +71,10 @@ fn is_ref_some_arm(cx: &LateContext<'_>, arm: &Arm<'_>) -> Option<Mutability> {
         && let ExprKind::Call(e, [arg]) = peel_blocks(arm.body).kind
         && is_res_lang_ctor(cx, path_res(cx, e), LangItem::OptionSome)
         && let ExprKind::Path(QPath::Resolved(_, path2)) = arg.kind
-        && path2.segments.len() == 1 && ident.name == path2.segments[0].ident.name
+        && path2.segments.len() == 1
+        && ident.name == path2.segments[0].ident.name
     {
-        return Some(mutabl)
+        return Some(mutabl);
     }
     None
 }
diff --git a/clippy_lints/src/matches/match_like_matches.rs b/clippy_lints/src/matches/match_like_matches.rs
index f100cb97a19..56123326fe4 100644
--- a/clippy_lints/src/matches/match_like_matches.rs
+++ b/clippy_lints/src/matches/match_like_matches.rs
@@ -87,10 +87,7 @@ where
         && b0 != b1
         && (first_guard.is_none() || iter.len() == 0)
         && first_attrs.is_empty()
-        && iter
-            .all(|arm| {
-                find_bool_lit(&arm.2.kind).map_or(false, |b| b == b0) && arm.3.is_none() && arm.0.is_empty()
-            })
+        && iter.all(|arm| find_bool_lit(&arm.2.kind).map_or(false, |b| b == b0) && arm.3.is_none() && arm.0.is_empty())
     {
         if let Some(last_pat) = last_pat_opt {
             if !is_wild(last_pat) {
@@ -119,7 +116,10 @@ where
                 .join(" | ")
         };
         let pat_and_guard = if let Some(Guard::If(g)) = first_guard {
-            format!("{pat} if {}", snippet_with_applicability(cx, g.span, "..", &mut applicability))
+            format!(
+                "{pat} if {}",
+                snippet_with_applicability(cx, g.span, "..", &mut applicability)
+            )
         } else {
             pat
         };
@@ -135,7 +135,10 @@ where
             cx,
             MATCH_LIKE_MATCHES_MACRO,
             expr.span,
-            &format!("{} expression looks like `matches!` macro", if is_if_let { "if let .. else" } else { "match" }),
+            &format!(
+                "{} expression looks like `matches!` macro",
+                if is_if_let { "if let .. else" } else { "match" }
+            ),
             "try",
             format!(
                 "{}matches!({}, {pat_and_guard})",
diff --git a/clippy_lints/src/matches/match_on_vec_items.rs b/clippy_lints/src/matches/match_on_vec_items.rs
index d15ecce34f1..dd71560e169 100644
--- a/clippy_lints/src/matches/match_on_vec_items.rs
+++ b/clippy_lints/src/matches/match_on_vec_items.rs
@@ -1,7 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::{is_type_diagnostic_item, is_type_lang_item};
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, LangItem};
 use rustc_lint::LateContext;
@@ -12,7 +11,6 @@ use super::MATCH_ON_VEC_ITEMS;
 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, scrutinee: &'tcx Expr<'_>) {
     if let Some(idx_expr) = is_vec_indexing(cx, scrutinee)
         && let ExprKind::Index(vec, idx, _) = idx_expr.kind
-
     {
         // FIXME: could be improved to suggest surrounding every pattern with Some(_),
         // but only when `or_patterns` are stabilized.
@@ -22,12 +20,8 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, scrutinee: &'tcx Expr<'_>) {
             scrutinee.span,
             "indexing into a vector may panic",
             "try",
-            format!(
-                "{}.get({})",
-                snippet(cx, vec.span, ".."),
-                snippet(cx, idx.span, "..")
-            ),
-            Applicability::MaybeIncorrect
+            format!("{}.get({})", snippet(cx, vec.span, ".."), snippet(cx, idx.span, "..")),
+            Applicability::MaybeIncorrect,
         );
     }
 }
@@ -36,7 +30,6 @@ fn is_vec_indexing<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> Opti
     if let ExprKind::Index(array, index, _) = expr.kind
         && is_vector(cx, array)
         && !is_full_range(cx, index)
-
     {
         return Some(expr);
     }
diff --git a/clippy_lints/src/matches/match_str_case_mismatch.rs b/clippy_lints/src/matches/match_str_case_mismatch.rs
index 3d920e9537f..bd38648bcf1 100644
--- a/clippy_lints/src/matches/match_str_case_mismatch.rs
+++ b/clippy_lints/src/matches/match_str_case_mismatch.rs
@@ -23,10 +23,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, scrutinee: &'tcx Expr<'_>, arm
     if let ty::Ref(_, ty, _) = cx.typeck_results().expr_ty(scrutinee).kind()
         && let ty::Str = ty.kind()
     {
-        let mut visitor = MatchExprVisitor {
-            cx,
-            case_method: None,
-        };
+        let mut visitor = MatchExprVisitor { cx, case_method: None };
 
         visitor.visit_expr(scrutinee);
 
@@ -87,9 +84,9 @@ fn verify_case<'a>(case_method: &'a CaseMethod, arms: &'a [Arm<'_>]) -> Option<(
 
     for arm in arms {
         if let PatKind::Lit(Expr {
-                                kind: ExprKind::Lit(lit),
-                                ..
-                            }) = arm.pat.kind
+            kind: ExprKind::Lit(lit),
+            ..
+        }) = arm.pat.kind
             && let LitKind::Str(symbol, _) = lit.node
             && let input = symbol.as_str()
             && !case_check(input)
diff --git a/clippy_lints/src/matches/match_wild_err_arm.rs b/clippy_lints/src/matches/match_wild_err_arm.rs
index f2fa404db5a..8a4c0ab9062 100644
--- a/clippy_lints/src/matches/match_wild_err_arm.rs
+++ b/clippy_lints/src/matches/match_wild_err_arm.rs
@@ -39,7 +39,8 @@ pub(crate) fn check<'tcx>(cx: &LateContext<'tcx>, ex: &Expr<'tcx>, arms: &[Arm<'
                         && is_panic(cx, macro_call.def_id)
                     {
                         // `Err(_)` or `Err(_e)` arm with `panic!` found
-                        span_lint_and_note(cx,
+                        span_lint_and_note(
+                            cx,
                             MATCH_WILD_ERR_ARM,
                             arm.pat.span,
                             &format!("`Err({ident_bind_name})` matches all errors"),
diff --git a/clippy_lints/src/matches/redundant_pattern_match.rs b/clippy_lints/src/matches/redundant_pattern_match.rs
index 9ce9c2e8381..2582f7edcf6 100644
--- a/clippy_lints/src/matches/redundant_pattern_match.rs
+++ b/clippy_lints/src/matches/redundant_pattern_match.rs
@@ -5,7 +5,6 @@ use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::{is_type_diagnostic_item, needs_ordered_drop};
 use clippy_utils::visitors::{any_temporaries_need_ordered_drop, for_each_expr};
 use clippy_utils::{higher, is_expn_of, is_trait_method};
-use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::def::{DefKind, Res};
diff --git a/clippy_lints/src/matches/rest_pat_in_fully_bound_struct.rs b/clippy_lints/src/matches/rest_pat_in_fully_bound_struct.rs
index 2e19bbe42e4..316b2f63e4e 100644
--- a/clippy_lints/src/matches/rest_pat_in_fully_bound_struct.rs
+++ b/clippy_lints/src/matches/rest_pat_in_fully_bound_struct.rs
@@ -14,7 +14,6 @@ pub(crate) fn check(cx: &LateContext<'_>, pat: &Pat<'_>) {
         && (def.is_struct() || def.is_union())
         && fields.len() == def.non_enum_variant().fields.len()
         && !def.non_enum_variant().is_field_list_non_exhaustive()
-
     {
         span_lint_and_help(
             cx,
diff --git a/clippy_lints/src/matches/single_match.rs b/clippy_lints/src/matches/single_match.rs
index bbf59643aad..86c414dafcc 100644
--- a/clippy_lints/src/matches/single_match.rs
+++ b/clippy_lints/src/matches/single_match.rs
@@ -93,14 +93,18 @@ fn report_single_pattern(
         && let (ty, ty_ref_count) = peel_mid_ty_refs(cx.typeck_results().expr_ty(ex))
         && let Some(spe_trait_id) = cx.tcx.lang_items().structural_peq_trait()
         && let Some(pe_trait_id) = cx.tcx.lang_items().eq_trait()
-        && (ty.is_integral() || ty.is_char() || ty.is_str()
-            || (implements_trait(cx, ty, spe_trait_id, &[])
-                && implements_trait(cx, ty, pe_trait_id, &[ty.into()])))
+        && (ty.is_integral()
+            || ty.is_char()
+            || ty.is_str()
+            || (implements_trait(cx, ty, spe_trait_id, &[]) && implements_trait(cx, ty, pe_trait_id, &[ty.into()])))
     {
         // scrutinee derives PartialEq and the pattern is a constant.
         let pat_ref_count = match pat.kind {
             // string literals are already a reference.
-            PatKind::Lit(Expr { kind: ExprKind::Lit(lit), .. }) if lit.node.is_str() => pat_ref_count + 1,
+            PatKind::Lit(Expr {
+                kind: ExprKind::Lit(lit),
+                ..
+            }) if lit.node.is_str() => pat_ref_count + 1,
             _ => pat_ref_count,
         };
         // References are only implicitly added to the pattern, so no overflow here.
diff --git a/clippy_lints/src/matches/try_err.rs b/clippy_lints/src/matches/try_err.rs
index 7e573aafef9..dd489fc250b 100644
--- a/clippy_lints/src/matches/try_err.rs
+++ b/clippy_lints/src/matches/try_err.rs
@@ -2,7 +2,6 @@ use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::{get_parent_expr, is_res_lang_ctor, path_res};
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::LangItem::ResultErr;
 use rustc_hir::{Expr, ExprKind, LangItem, MatchSource, QPath};
@@ -104,7 +103,6 @@ fn poll_result_error_type<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Option<
     if let ty::Adt(def, subst) = ty.kind()
         && cx.tcx.lang_items().get(LangItem::Poll) == Some(def.did())
         && let ready_ty = subst.type_at(0)
-
         && let ty::Adt(ready_def, ready_subst) = ready_ty.kind()
         && cx.tcx.is_diagnostic_item(sym::Result, ready_def.did())
     {
@@ -119,11 +117,9 @@ fn poll_option_result_error_type<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) ->
     if let ty::Adt(def, subst) = ty.kind()
         && cx.tcx.lang_items().get(LangItem::Poll) == Some(def.did())
         && let ready_ty = subst.type_at(0)
-
         && let ty::Adt(ready_def, ready_subst) = ready_ty.kind()
         && cx.tcx.is_diagnostic_item(sym::Option, ready_def.did())
         && let some_ty = ready_subst.type_at(0)
-
         && let ty::Adt(some_def, some_subst) = some_ty.kind()
         && cx.tcx.is_diagnostic_item(sym::Result, some_def.did())
     {
diff --git a/clippy_lints/src/mem_replace.rs b/clippy_lints/src/mem_replace.rs
index 0377af3f5db..13d6f511281 100644
--- a/clippy_lints/src/mem_replace.rs
+++ b/clippy_lints/src/mem_replace.rs
@@ -4,7 +4,6 @@ use clippy_utils::source::{snippet, snippet_with_applicability};
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::is_non_aggregate_primitive_type;
 use clippy_utils::{is_default_equivalent, is_res_lang_ctor, path_res, peel_ref_operators};
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::LangItem::OptionNone;
 use rustc_hir::{Expr, ExprKind};
@@ -163,8 +162,9 @@ fn check_replace_with_uninit(cx: &LateContext<'_>, src: &Expr<'_>, dest: &Expr<'
                 ),
                 applicability,
             );
-        } else if cx.tcx.is_diagnostic_item(sym::mem_zeroed, repl_def_id) &&
-                !cx.typeck_results().expr_ty(src).is_primitive() {
+        } else if cx.tcx.is_diagnostic_item(sym::mem_zeroed, repl_def_id)
+            && !cx.typeck_results().expr_ty(src).is_primitive()
+        {
             span_lint_and_help(
                 cx,
                 MEM_REPLACE_WITH_UNINIT,
diff --git a/clippy_lints/src/methods/bind_instead_of_map.rs b/clippy_lints/src/methods/bind_instead_of_map.rs
index 4e6a8c58bef..08bfa2e009b 100644
--- a/clippy_lints/src/methods/bind_instead_of_map.rs
+++ b/clippy_lints/src/methods/bind_instead_of_map.rs
@@ -3,7 +3,6 @@ use clippy_utils::diagnostics::{multispan_sugg_with_applicability, span_lint_and
 use clippy_utils::peel_blocks;
 use clippy_utils::source::{snippet, snippet_with_context};
 use clippy_utils::visitors::find_all_ret_expressions;
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_hir::def::{CtorKind, CtorOf, DefKind, Res};
@@ -81,16 +80,11 @@ pub(crate) trait BindInsteadOfMap {
 
             let closure_args_snip = snippet(cx, closure_args_span, "..");
             let option_snip = snippet(cx, recv.span, "..");
-            let note = format!("{option_snip}.{}({closure_args_snip} {some_inner_snip})", Self::GOOD_METHOD_NAME);
-            span_lint_and_sugg(
-                cx,
-                BIND_INSTEAD_OF_MAP,
-                expr.span,
-                &msg,
-                "try",
-                note,
-                app,
+            let note = format!(
+                "{option_snip}.{}({closure_args_snip} {some_inner_snip})",
+                Self::GOOD_METHOD_NAME
             );
+            span_lint_and_sugg(cx, BIND_INSTEAD_OF_MAP, expr.span, &msg, "try", note, app);
             true
         } else {
             false
@@ -115,7 +109,11 @@ pub(crate) trait BindInsteadOfMap {
         let (span, msg) = if can_sugg
             && let hir::ExprKind::MethodCall(segment, ..) = expr.kind
             && let Some(msg) = Self::lint_msg(cx)
-        { (segment.ident.span, msg) } else { return false; };
+        {
+            (segment.ident.span, msg)
+        } else {
+            return false;
+        };
         span_lint_and_then(cx, BIND_INSTEAD_OF_MAP, expr.span, &msg, |diag| {
             multispan_sugg_with_applicability(
                 diag,
@@ -136,7 +134,10 @@ pub(crate) trait BindInsteadOfMap {
         if let Some(adt) = cx.typeck_results().expr_ty(recv).ty_adt_def()
             && let Some(vid) = cx.tcx.lang_items().get(Self::VARIANT_LANG_ITEM)
             && adt.did() == cx.tcx.parent(vid)
-        {} else { return false; }
+        {
+        } else {
+            return false;
+        }
 
         match arg.kind {
             hir::ExprKind::Closure(&hir::Closure { body, fn_decl_span, .. }) => {
diff --git a/clippy_lints/src/methods/bytecount.rs b/clippy_lints/src/methods/bytecount.rs
index 039b92da1e1..4a2124c74a8 100644
--- a/clippy_lints/src/methods/bytecount.rs
+++ b/clippy_lints/src/methods/bytecount.rs
@@ -3,7 +3,6 @@ use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::visitors::is_local_used;
 use clippy_utils::{path_to_local_id, peel_blocks, peel_ref_operators, strip_pat_refs};
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Closure, Expr, ExprKind, PatKind};
 use rustc_lint::LateContext;
@@ -24,9 +23,7 @@ pub(super) fn check<'tcx>(
         && let PatKind::Binding(_, arg_id, _, _) = strip_pat_refs(param.pat).kind
         && let ExprKind::Binary(ref op, l, r) = body.value.kind
         && op.node == BinOpKind::Eq
-        && is_type_diagnostic_item(cx,
-                    cx.typeck_results().expr_ty(filter_recv).peel_refs(),
-                    sym::SliceIter)
+        && is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(filter_recv).peel_refs(), sym::SliceIter)
         && let operand_is_arg = (|expr| {
             let expr = peel_ref_operators(cx, peel_blocks(expr));
             path_to_local_id(expr, arg_id)
@@ -41,8 +38,7 @@ pub(super) fn check<'tcx>(
         && ty::Uint(UintTy::U8) == *cx.typeck_results().expr_ty(needle).peel_refs().kind()
         && !is_local_used(cx, needle, arg_id)
     {
-        let haystack = if let ExprKind::MethodCall(path, receiver, [], _) =
-                filter_recv.kind {
+        let haystack = if let ExprKind::MethodCall(path, receiver, [], _) = filter_recv.kind {
             let p = path.ident.name;
             if p == sym::iter || p == sym::iter_mut {
                 receiver
@@ -59,9 +55,11 @@ pub(super) fn check<'tcx>(
             expr.span,
             "you appear to be counting bytes the naive way",
             "consider using the bytecount crate",
-            format!("bytecount::count({}, {})",
-                    snippet_with_applicability(cx, haystack.span, "..", &mut applicability),
-                    snippet_with_applicability(cx, needle.span, "..", &mut applicability)),
+            format!(
+                "bytecount::count({}, {})",
+                snippet_with_applicability(cx, haystack.span, "..", &mut applicability),
+                snippet_with_applicability(cx, needle.span, "..", &mut applicability)
+            ),
             applicability,
         );
     };
diff --git a/clippy_lints/src/methods/bytes_count_to_len.rs b/clippy_lints/src/methods/bytes_count_to_len.rs
index eebd8428cff..34159f2d150 100644
--- a/clippy_lints/src/methods/bytes_count_to_len.rs
+++ b/clippy_lints/src/methods/bytes_count_to_len.rs
@@ -1,7 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::is_type_lang_item;
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
@@ -27,8 +26,11 @@ pub(super) fn check<'tcx>(
             expr.span,
             "using long and hard to read `.bytes().count()`",
             "consider calling `.len()` instead",
-            format!("{}.len()", snippet_with_applicability(cx, bytes_recv.span, "..", &mut applicability)),
-            applicability
+            format!(
+                "{}.len()",
+                snippet_with_applicability(cx, bytes_recv.span, "..", &mut applicability)
+            ),
+            applicability,
         );
     };
 }
diff --git a/clippy_lints/src/methods/case_sensitive_file_extension_comparisons.rs b/clippy_lints/src/methods/case_sensitive_file_extension_comparisons.rs
index b773e762d93..a37087d0abf 100644
--- a/clippy_lints/src/methods/case_sensitive_file_extension_comparisons.rs
+++ b/clippy_lints/src/methods/case_sensitive_file_extension_comparisons.rs
@@ -1,7 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::{indent_of, reindent_multiline, snippet_opt};
 use clippy_utils::ty::is_type_lang_item;
-use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, LangItem};
@@ -30,7 +29,10 @@ pub(super) fn check<'tcx>(
     if let Some(method_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id)
         && let Some(impl_id) = cx.tcx.impl_of_method(method_id)
         && cx.tcx.type_of(impl_id).instantiate_identity().is_str()
-        && let ExprKind::Lit(Spanned { node: LitKind::Str(ext_literal, ..), ..}) = arg.kind
+        && let ExprKind::Lit(Spanned {
+            node: LitKind::Str(ext_literal, ..),
+            ..
+        }) = arg.kind
         && (2..=6).contains(&ext_literal.as_str().len())
         && let ext_str = ext_literal.as_str()
         && ext_str.starts_with('.')
@@ -47,7 +49,6 @@ pub(super) fn check<'tcx>(
             |diag| {
                 diag.help("consider using a case-insensitive comparison instead");
                 if let Some(mut recv_source) = snippet_opt(cx, recv.span) {
-
                     if !cx.typeck_results().expr_ty(recv).is_ref() {
                         recv_source = format!("&{recv_source}");
                     }
@@ -57,9 +58,12 @@ pub(super) fn check<'tcx>(
                             "std::path::Path::new({})
                                 .extension()
                                 .map_or(false, |ext| ext.eq_ignore_ascii_case(\"{}\"))",
-                            recv_source, ext_str.strip_prefix('.').unwrap()).into(),
+                            recv_source,
+                            ext_str.strip_prefix('.').unwrap()
+                        )
+                        .into(),
                         true,
-                        Some(indent_of(cx, call_span).unwrap_or(0) + 4)
+                        Some(indent_of(cx, call_span).unwrap_or(0) + 4),
                     );
 
                     diag.span_suggestion(
@@ -69,7 +73,7 @@ pub(super) fn check<'tcx>(
                         Applicability::MaybeIncorrect,
                     );
                 }
-            }
+            },
         );
     }
 }
diff --git a/clippy_lints/src/methods/chars_cmp.rs b/clippy_lints/src/methods/chars_cmp.rs
index 06c0ee2e691..c99cec067bf 100644
--- a/clippy_lints/src/methods/chars_cmp.rs
+++ b/clippy_lints/src/methods/chars_cmp.rs
@@ -1,7 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::{method_chain_args, path_def_id};
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::{LateContext, Lint};
@@ -33,10 +32,12 @@ pub(super) fn check(
             info.expr.span,
             &format!("you should use the `{suggest}` method"),
             "like this",
-            format!("{}{}.{suggest}({})",
-                    if info.eq { "" } else { "!" },
-                    snippet_with_applicability(cx, args[0].0.span, "..", &mut applicability),
-                    snippet_with_applicability(cx, arg_char.span, "..", &mut applicability)),
+            format!(
+                "{}{}.{suggest}({})",
+                if info.eq { "" } else { "!" },
+                snippet_with_applicability(cx, args[0].0.span, "..", &mut applicability),
+                snippet_with_applicability(cx, arg_char.span, "..", &mut applicability)
+            ),
             applicability,
         );
 
diff --git a/clippy_lints/src/methods/chars_cmp_with_unwrap.rs b/clippy_lints/src/methods/chars_cmp_with_unwrap.rs
index a364bc9e525..d07e45434a7 100644
--- a/clippy_lints/src/methods/chars_cmp_with_unwrap.rs
+++ b/clippy_lints/src/methods/chars_cmp_with_unwrap.rs
@@ -1,7 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::method_chain_args;
 use clippy_utils::source::snippet_with_applicability;
-use if_chain::if_chain;
 use rustc_ast::ast;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
@@ -26,10 +25,12 @@ pub(super) fn check(
             info.expr.span,
             &format!("you should use the `{suggest}` method"),
             "like this",
-            format!("{}{}.{suggest}('{}')",
-                    if info.eq { "" } else { "!" },
-                    snippet_with_applicability(cx, args[0].0.span, "..", &mut applicability),
-                    c.escape_default()),
+            format!(
+                "{}{}.{suggest}('{}')",
+                if info.eq { "" } else { "!" },
+                snippet_with_applicability(cx, args[0].0.span, "..", &mut applicability),
+                c.escape_default()
+            ),
             applicability,
         );
 
diff --git a/clippy_lints/src/methods/err_expect.rs b/clippy_lints/src/methods/err_expect.rs
index 89df0652855..dc978c8a584 100644
--- a/clippy_lints/src/methods/err_expect.rs
+++ b/clippy_lints/src/methods/err_expect.rs
@@ -27,7 +27,6 @@ pub(super) fn check(
         && let Some(data_type) = get_data_type(cx, result_type)
         // Tests if the T type in a `Result<T, E>` implements debug
         && has_debug_impl(cx, data_type)
-
     {
         span_lint_and_sugg(
             cx,
@@ -36,8 +35,8 @@ pub(super) fn check(
             "called `.err().expect()` on a `Result` value",
             "try",
             "expect_err".to_string(),
-            Applicability::MachineApplicable
-    );
+            Applicability::MachineApplicable,
+        );
     };
 }
 
diff --git a/clippy_lints/src/methods/extend_with_drain.rs b/clippy_lints/src/methods/extend_with_drain.rs
index 43a85f6e8a6..460ec7b3640 100644
--- a/clippy_lints/src/methods/extend_with_drain.rs
+++ b/clippy_lints/src/methods/extend_with_drain.rs
@@ -1,7 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::{is_type_diagnostic_item, is_type_lang_item};
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, LangItem};
 use rustc_lint::LateContext;
diff --git a/clippy_lints/src/methods/filetype_is_file.rs b/clippy_lints/src/methods/filetype_is_file.rs
index 362f2589329..15f21fa6ac0 100644
--- a/clippy_lints/src/methods/filetype_is_file.rs
+++ b/clippy_lints/src/methods/filetype_is_file.rs
@@ -1,7 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::get_parent_expr;
 use clippy_utils::ty::is_type_diagnostic_item;
-use if_chain::if_chain;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
 use rustc_span::source_map::Span;
diff --git a/clippy_lints/src/methods/filter_map.rs b/clippy_lints/src/methods/filter_map.rs
index ee7a1538a5f..e52974103b2 100644
--- a/clippy_lints/src/methods/filter_map.rs
+++ b/clippy_lints/src/methods/filter_map.rs
@@ -4,7 +4,6 @@ use clippy_utils::source::{indent_of, reindent_multiline, snippet};
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::{higher, is_trait_method, path_to_local_id, peel_blocks, SpanlessEq};
 use hir::{Body, HirId, MatchSource, Pat};
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_hir::def::Res;
@@ -33,7 +32,7 @@ fn is_method(cx: &LateContext<'_>, expr: &hir::Expr<'_>, method_name: Symbol) ->
                         && let hir::ExprKind::Path(path) = &receiver.kind
                         && let Res::Local(ref local) = cx.qpath_res(path, receiver.hir_id)
                     {
-                        return arg_id == *local
+                        return arg_id == *local;
                     }
                     false
                 },
@@ -324,7 +323,6 @@ pub(super) fn check(
 
         && let Some(check_result) =
             offending_expr.check_map_call(cx, map_body, map_param_id, filter_param_id, is_filter_param_ref)
-
     {
         let span = filter_span.with_hi(expr.span.hi());
         let (filter_name, lint) = if is_find {
@@ -335,18 +333,23 @@ pub(super) fn check(
         let msg = format!("`{filter_name}(..).map(..)` can be simplified as `{filter_name}_map(..)`");
 
         let (sugg, note_and_span, applicability) = match check_result {
-            CheckResult::Method { map_arg, method, side_effect_expr_span } => {
+            CheckResult::Method {
+                map_arg,
+                method,
+                side_effect_expr_span,
+            } => {
                 let (to_opt, deref) = match method {
                     CalledMethod::ResultIsOk => (".ok()", String::new()),
                     CalledMethod::OptionIsSome => {
-                        let derefs = cx.typeck_results()
+                        let derefs = cx
+                            .typeck_results()
                             .expr_adjustments(map_arg)
                             .iter()
                             .filter(|adj| matches!(adj.kind, Adjust::Deref(_)))
                             .count();
 
                         ("", "*".repeat(derefs))
-                    }
+                    },
                 };
 
                 let sugg = format!(
@@ -363,15 +366,24 @@ pub(super) fn check(
                 };
 
                 (sugg, note_and_span, applicability)
-            }
-            CheckResult::PatternMatching { variant_span, variant_ident } => {
+            },
+            CheckResult::PatternMatching {
+                variant_span,
+                variant_ident,
+            } => {
                 let pat = snippet(cx, variant_span, "<pattern>");
 
-                (format!("{filter_name}_map(|{map_param_ident}| match {map_param_ident} {{ \
+                (
+                    format!(
+                        "{filter_name}_map(|{map_param_ident}| match {map_param_ident} {{ \
                     {pat} => Some({variant_ident}), \
                     _ => None \
-                }})"), None, Applicability::MachineApplicable)
-            }
+                }})"
+                    ),
+                    None,
+                    Applicability::MachineApplicable,
+                )
+            },
         };
         span_lint_and_then(cx, lint, span, &msg, |diag| {
             diag.span_suggestion(span, "try", sugg, applicability);
diff --git a/clippy_lints/src/methods/from_iter_instead_of_collect.rs b/clippy_lints/src/methods/from_iter_instead_of_collect.rs
index cee8d8eb029..917a8e33eb9 100644
--- a/clippy_lints/src/methods/from_iter_instead_of_collect.rs
+++ b/clippy_lints/src/methods/from_iter_instead_of_collect.rs
@@ -2,7 +2,6 @@ use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::implements_trait;
 use clippy_utils::{is_path_diagnostic_item, sugg};
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
@@ -16,7 +15,6 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::Exp
         && let ty = cx.typeck_results().expr_ty(expr)
         && let arg_ty = cx.typeck_results().expr_ty(&args[0])
         && let Some(iter_id) = cx.tcx.get_diagnostic_item(sym::Iterator)
-
         && implements_trait(cx, arg_ty, iter_id, &[])
     {
         // `expr` implements `FromIterator` trait
@@ -44,7 +42,6 @@ fn extract_turbofish(cx: &LateContext<'_>, expr: &hir::Expr<'_>, ty: Ty<'_>) ->
     if let Some(snippet) = snippet_opt(cx, call_site)
         && let snippet_split = snippet.split("::").collect::<Vec<_>>()
         && let Some((_, elements)) = snippet_split.split_last()
-
     {
         if let [type_specifier, _] = snippet_split.as_slice()
             && let Some(type_specifier) = strip_angle_brackets(type_specifier)
@@ -55,9 +52,16 @@ fn extract_turbofish(cx: &LateContext<'_>, expr: &hir::Expr<'_>, ty: Ty<'_>) ->
             // is there a type specifier? (i.e.: like `<u32>` in `collections::BTreeSet::<u32>::`)
             if let Some(type_specifier) = snippet_split.iter().find(|e| strip_angle_brackets(e).is_some()) {
                 // remove the type specifier from the path elements
-                let without_ts = elements.iter().filter_map(|e| {
-                    if e == type_specifier { None } else { Some((*e).to_string()) }
-                }).collect::<Vec<_>>();
+                let without_ts = elements
+                    .iter()
+                    .filter_map(|e| {
+                        if e == type_specifier {
+                            None
+                        } else {
+                            Some((*e).to_string())
+                        }
+                    })
+                    .collect::<Vec<_>>();
                 // join and add the type specifier at the end (i.e.: `collections::BTreeSet<u32>`)
                 format!("{}{type_specifier}", without_ts.join("::"))
             } else {
diff --git a/clippy_lints/src/methods/get_first.rs b/clippy_lints/src/methods/get_first.rs
index 9b6f76f0f42..e1f1e489355 100644
--- a/clippy_lints/src/methods/get_first.rs
+++ b/clippy_lints/src/methods/get_first.rs
@@ -1,7 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::is_type_diagnostic_item;
-use if_chain::if_chain;
 use rustc_ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
@@ -20,7 +19,10 @@ pub(super) fn check<'tcx>(
     if let Some(method_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id)
         && let Some(impl_id) = cx.tcx.impl_of_method(method_id)
         && let identity = cx.tcx.type_of(impl_id).instantiate_identity()
-        && let hir::ExprKind::Lit(Spanned { node: LitKind::Int(0, _), .. }) = arg.kind
+        && let hir::ExprKind::Lit(Spanned {
+            node: LitKind::Int(0, _),
+            ..
+        }) = arg.kind
     {
         if identity.is_slice() {
             let mut app = Applicability::MachineApplicable;
@@ -34,18 +36,18 @@ pub(super) fn check<'tcx>(
                 format!("{slice_name}.first()"),
                 app,
             );
-        } else if is_type_diagnostic_item(cx, identity, sym::VecDeque){
-                let mut app = Applicability::MachineApplicable;
-                let slice_name = snippet_with_applicability(cx, recv.span, "..", &mut app);
-                span_lint_and_sugg(
-                    cx,
-                    GET_FIRST,
-                    expr.span,
-                    &format!("accessing first element with `{slice_name}.get(0)`"),
-                    "try",
-                    format!("{slice_name}.front()"),
-                    app,
-                );
+        } else if is_type_diagnostic_item(cx, identity, sym::VecDeque) {
+            let mut app = Applicability::MachineApplicable;
+            let slice_name = snippet_with_applicability(cx, recv.span, "..", &mut app);
+            span_lint_and_sugg(
+                cx,
+                GET_FIRST,
+                expr.span,
+                &format!("accessing first element with `{slice_name}.get(0)`"),
+                "try",
+                format!("{slice_name}.front()"),
+                app,
+            );
         }
     }
 }
diff --git a/clippy_lints/src/methods/implicit_clone.rs b/clippy_lints/src/methods/implicit_clone.rs
index 73747340ef1..78a553eb8c0 100644
--- a/clippy_lints/src/methods/implicit_clone.rs
+++ b/clippy_lints/src/methods/implicit_clone.rs
@@ -2,7 +2,6 @@ use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_context;
 use clippy_utils::ty::{implements_trait, peel_mid_ty_refs};
 use clippy_utils::{is_diag_item_method, is_diag_trait_item};
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
diff --git a/clippy_lints/src/methods/inefficient_to_string.rs b/clippy_lints/src/methods/inefficient_to_string.rs
index c0b7b3ae972..efc3ddd20b4 100644
--- a/clippy_lints/src/methods/inefficient_to_string.rs
+++ b/clippy_lints/src/methods/inefficient_to_string.rs
@@ -1,7 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::{is_type_lang_item, walk_ptrs_ty_depth};
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
@@ -18,7 +17,8 @@ pub fn check(
     receiver: &hir::Expr<'_>,
     args: &[hir::Expr<'_>],
 ) {
-    if args.is_empty() && method_name == sym::to_string
+    if args.is_empty()
+        && method_name == sym::to_string
         && let Some(to_string_meth_did) = cx.typeck_results().type_dependent_def_id(expr.hir_id)
         && cx.tcx.is_diagnostic_item(sym::to_string_method, to_string_meth_did)
         && let Some(args) = cx.typeck_results().node_args_opt(expr.hir_id)
diff --git a/clippy_lints/src/methods/into_iter_on_ref.rs b/clippy_lints/src/methods/into_iter_on_ref.rs
index 7bb32d6ea65..5ca841df5d9 100644
--- a/clippy_lints/src/methods/into_iter_on_ref.rs
+++ b/clippy_lints/src/methods/into_iter_on_ref.rs
@@ -1,7 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::is_trait_method;
 use clippy_utils::ty::has_iter_method;
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
@@ -28,9 +27,7 @@ pub(super) fn check(
             cx,
             INTO_ITER_ON_REF,
             method_span,
-            &format!(
-                "this `.into_iter()` call is equivalent to `.{method_name}()` and will not consume the `{kind}`",
-            ),
+            &format!("this `.into_iter()` call is equivalent to `.{method_name}()` and will not consume the `{kind}`",),
             "call directly",
             method_name.to_string(),
             Applicability::MachineApplicable,
diff --git a/clippy_lints/src/methods/iter_cloned_collect.rs b/clippy_lints/src/methods/iter_cloned_collect.rs
index da841ca50f4..dd741cd43f9 100644
--- a/clippy_lints/src/methods/iter_cloned_collect.rs
+++ b/clippy_lints/src/methods/iter_cloned_collect.rs
@@ -1,7 +1,6 @@
 use crate::methods::utils::derefs_to_slice;
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::ty::is_type_diagnostic_item;
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
@@ -13,14 +12,15 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, method_name: &str, expr: &hir:
     if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(expr), sym::Vec)
         && let Some(slice) = derefs_to_slice(cx, recv, cx.typeck_results().expr_ty(recv))
         && let Some(to_replace) = expr.span.trim_start(slice.span.source_callsite())
-
     {
         span_lint_and_sugg(
             cx,
             ITER_CLONED_COLLECT,
             to_replace,
-            &format!("called `iter().{method_name}().collect()` on a slice to create a `Vec`. Calling `to_vec()` is both faster and \
-            more readable"),
+            &format!(
+                "called `iter().{method_name}().collect()` on a slice to create a `Vec`. Calling `to_vec()` is both faster and \
+            more readable"
+            ),
             "try",
             ".to_vec()".to_string(),
             Applicability::MachineApplicable,
diff --git a/clippy_lints/src/methods/iter_kv_map.rs b/clippy_lints/src/methods/iter_kv_map.rs
index 687aee267fa..c5dbb6ad98b 100644
--- a/clippy_lints/src/methods/iter_kv_map.rs
+++ b/clippy_lints/src/methods/iter_kv_map.rs
@@ -24,27 +24,27 @@ pub(super) fn check<'tcx>(
 ) {
     if !expr.span.from_expansion()
         && let ExprKind::Closure(c) = m_arg.kind
-        && let Body {params: [p], value: body_expr, coroutine_kind: _ } = cx.tcx.hir().body(c.body)
+        && let Body {
+            params: [p],
+            value: body_expr,
+            coroutine_kind: _,
+        } = cx.tcx.hir().body(c.body)
         && let PatKind::Tuple([key_pat, val_pat], _) = p.pat.kind
-
         && let (replacement_kind, annotation, bound_ident) = match (&key_pat.kind, &val_pat.kind) {
             (key, PatKind::Binding(ann, _, value, _)) if pat_is_wild(cx, key, m_arg) => ("value", ann, value),
             (PatKind::Binding(ann, _, key, _), value) if pat_is_wild(cx, value, m_arg) => ("key", ann, key),
             _ => return,
         }
-
         && let ty = cx.typeck_results().expr_ty(recv)
         && (is_type_diagnostic_item(cx, ty, sym::HashMap) || is_type_diagnostic_item(cx, ty, sym::BTreeMap))
-
     {
         let mut applicability = rustc_errors::Applicability::MachineApplicable;
         let recv_snippet = snippet_with_applicability(cx, recv.span, "map", &mut applicability);
-        let into_prefix = if map_type == "into_iter" {"into_"} else {""};
+        let into_prefix = if map_type == "into_iter" { "into_" } else { "" };
 
         if let ExprKind::Path(rustc_hir::QPath::Resolved(_, path)) = body_expr.kind
             && let [local_ident] = path.segments
             && local_ident.ident.as_str() == bound_ident.as_str()
-
         {
             span_lint_and_sugg(
                 cx,
@@ -56,24 +56,18 @@ pub(super) fn check<'tcx>(
                 applicability,
             );
         } else {
-            let ref_annotation = if annotation.0 == ByRef::Yes {
-                "ref "
-            } else {
-                ""
-            };
-            let mut_annotation = if annotation.1 == Mutability::Mut {
-                "mut "
-            } else {
-                ""
-            };
+            let ref_annotation = if annotation.0 == ByRef::Yes { "ref " } else { "" };
+            let mut_annotation = if annotation.1 == Mutability::Mut { "mut " } else { "" };
             span_lint_and_sugg(
                 cx,
                 ITER_KV_MAP,
                 expr.span,
                 &format!("iterating on a map's {replacement_kind}s"),
                 "try",
-                format!("{recv_snippet}.{into_prefix}{replacement_kind}s().map(|{ref_annotation}{mut_annotation}{bound_ident}| {})",
-                    snippet_with_applicability(cx, body_expr.span, "/* body */", &mut applicability)),
+                format!(
+                    "{recv_snippet}.{into_prefix}{replacement_kind}s().map(|{ref_annotation}{mut_annotation}{bound_ident}| {})",
+                    snippet_with_applicability(cx, body_expr.span, "/* body */", &mut applicability)
+                ),
                 applicability,
             );
         }
diff --git a/clippy_lints/src/methods/iter_next_slice.rs b/clippy_lints/src/methods/iter_next_slice.rs
index 9d97370116e..fd4650e1e45 100644
--- a/clippy_lints/src/methods/iter_next_slice.rs
+++ b/clippy_lints/src/methods/iter_next_slice.rs
@@ -3,7 +3,6 @@ use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::{get_parent_expr, higher};
-use if_chain::if_chain;
 use rustc_ast::ast;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
@@ -27,16 +26,25 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, cal
     if derefs_to_slice(cx, caller_expr, cx.typeck_results().expr_ty(caller_expr)).is_some() {
         // caller is a Slice
         if let hir::ExprKind::Index(caller_var, index_expr, _) = &caller_expr.kind
-            && let Some(higher::Range { start: Some(start_expr), end: None, limits: ast::RangeLimits::HalfOpen })
-                = higher::Range::hir(index_expr)
+            && let Some(higher::Range {
+                start: Some(start_expr),
+                end: None,
+                limits: ast::RangeLimits::HalfOpen,
+            }) = higher::Range::hir(index_expr)
             && let hir::ExprKind::Lit(start_lit) = &start_expr.kind
             && let ast::LitKind::Int(start_idx, _) = start_lit.node
         {
             let mut applicability = Applicability::MachineApplicable;
             let suggest = if start_idx == 0 {
-                format!("{}.first()", snippet_with_applicability(cx, caller_var.span, "..", &mut applicability))
+                format!(
+                    "{}.first()",
+                    snippet_with_applicability(cx, caller_var.span, "..", &mut applicability)
+                )
             } else {
-                format!("{}.get({start_idx})", snippet_with_applicability(cx, caller_var.span, "..", &mut applicability))
+                format!(
+                    "{}.get({start_idx})",
+                    snippet_with_applicability(cx, caller_var.span, "..", &mut applicability)
+                )
             };
             span_lint_and_sugg(
                 cx,
diff --git a/clippy_lints/src/methods/iter_skip_next.rs b/clippy_lints/src/methods/iter_skip_next.rs
index 872476a314c..fbe20dfe54e 100644
--- a/clippy_lints/src/methods/iter_skip_next.rs
+++ b/clippy_lints/src/methods/iter_skip_next.rs
@@ -21,7 +21,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr
             |diag| {
                 if let Some(id) = path_to_local(recv)
                     && let Node::Pat(pat) = cx.tcx.hir().get(id)
-                    && let PatKind::Binding(ann, _, _, _)  = pat.kind
+                    && let PatKind::Binding(ann, _, _, _) = pat.kind
                     && ann != BindingAnnotation::MUT
                 {
                     application = Applicability::Unspecified;
diff --git a/clippy_lints/src/methods/manual_ok_or.rs b/clippy_lints/src/methods/manual_ok_or.rs
index 35d5e090cc8..b1af0083e65 100644
--- a/clippy_lints/src/methods/manual_ok_or.rs
+++ b/clippy_lints/src/methods/manual_ok_or.rs
@@ -2,7 +2,6 @@ use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::{indent_of, reindent_multiline, snippet_opt};
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::{is_res_lang_ctor, path_res, path_to_local_id};
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::LangItem::{ResultErr, ResultOk};
 use rustc_hir::{Expr, ExprKind, PatKind};
@@ -35,9 +34,7 @@ pub(super) fn check<'tcx>(
             expr.span,
             "this pattern reimplements `Option::ok_or`",
             "replace with",
-            format!(
-                "{recv_snippet}.ok_or({reindented_err_arg_snippet})"
-            ),
+            format!("{recv_snippet}.ok_or({reindented_err_arg_snippet})"),
             Applicability::MachineApplicable,
         );
     }
diff --git a/clippy_lints/src/methods/manual_saturating_arithmetic.rs b/clippy_lints/src/methods/manual_saturating_arithmetic.rs
index 464d4c37a87..04bdbc1ea25 100644
--- a/clippy_lints/src/methods/manual_saturating_arithmetic.rs
+++ b/clippy_lints/src/methods/manual_saturating_arithmetic.rs
@@ -1,7 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::{match_def_path, path_def_id};
-use if_chain::if_chain;
 use rustc_ast::ast;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
@@ -76,7 +75,7 @@ fn is_min_or_max(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> Option<MinMax> {
         match segment.ident.as_str() {
             "max_value" => return Some(MinMax::Max),
             "min_value" => return Some(MinMax::Min),
-            _ => {}
+            _ => {},
         }
     }
 
diff --git a/clippy_lints/src/methods/manual_str_repeat.rs b/clippy_lints/src/methods/manual_str_repeat.rs
index 5b4517f3d6c..61e74369cb0 100644
--- a/clippy_lints/src/methods/manual_str_repeat.rs
+++ b/clippy_lints/src/methods/manual_str_repeat.rs
@@ -3,7 +3,6 @@ use clippy_utils::is_path_diagnostic_item;
 use clippy_utils::source::{snippet_with_applicability, snippet_with_context};
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::{is_type_diagnostic_item, is_type_lang_item};
-use if_chain::if_chain;
 use rustc_ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, LangItem};
@@ -73,13 +72,14 @@ pub(super) fn check(
             RepeatKind::Char(_) if repeat_arg.span.ctxt() != ctxt => return,
             RepeatKind::Char('\'') => r#""'""#.into(),
             RepeatKind::Char('"') => r#""\"""#.into(),
-            RepeatKind::Char(_) =>
-                match snippet_with_applicability(cx, repeat_arg.span, "..", &mut app) {
-                    Cow::Owned(s) => Cow::Owned(format!("\"{}\"", &s[1..s.len() - 1])),
-                    s @ Cow::Borrowed(_) => s,
-                },
-            RepeatKind::String =>
-                Sugg::hir_with_context(cx, repeat_arg, ctxt, "..", &mut app).maybe_par().to_string().into(),
+            RepeatKind::Char(_) => match snippet_with_applicability(cx, repeat_arg.span, "..", &mut app) {
+                Cow::Owned(s) => Cow::Owned(format!("\"{}\"", &s[1..s.len() - 1])),
+                s @ Cow::Borrowed(_) => s,
+            },
+            RepeatKind::String => Sugg::hir_with_context(cx, repeat_arg, ctxt, "..", &mut app)
+                .maybe_par()
+                .to_string()
+                .into(),
         };
 
         span_lint_and_sugg(
@@ -89,7 +89,7 @@ pub(super) fn check(
             "manual implementation of `str::repeat` using iterators",
             "try",
             format!("{val_str}.repeat({count_snip})"),
-            app
-        )
+            app,
+        );
     }
 }
diff --git a/clippy_lints/src/methods/map_clone.rs b/clippy_lints/src/methods/map_clone.rs
index 417bcc41a28..cc6eeaa86e5 100644
--- a/clippy_lints/src/methods/map_clone.rs
+++ b/clippy_lints/src/methods/map_clone.rs
@@ -3,7 +3,6 @@ use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::{is_copy, is_type_diagnostic_item};
 use clippy_utils::{is_diag_trait_item, peel_blocks};
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
@@ -17,19 +16,19 @@ use super::MAP_CLONE;
 
 pub(super) fn check(cx: &LateContext<'_>, e: &hir::Expr<'_>, recv: &hir::Expr<'_>, arg: &hir::Expr<'_>, msrv: &Msrv) {
     if let Some(method_id) = cx.typeck_results().type_dependent_def_id(e.hir_id)
-        && (cx.tcx.impl_of_method(method_id)
-            .map_or(false, |id| is_type_diagnostic_item(cx, cx.tcx.type_of(id).instantiate_identity(), sym::Option))
-            || is_diag_trait_item(cx, method_id, sym::Iterator))
-        && let hir::ExprKind::Closure(&hir::Closure{ body, .. }) = arg.kind
+        && (cx.tcx.impl_of_method(method_id).map_or(false, |id| {
+            is_type_diagnostic_item(cx, cx.tcx.type_of(id).instantiate_identity(), sym::Option)
+        }) || is_diag_trait_item(cx, method_id, sym::Iterator))
+        && let hir::ExprKind::Closure(&hir::Closure { body, .. }) = arg.kind
     {
         let closure_body = cx.tcx.hir().body(body);
         let closure_expr = peel_blocks(closure_body.value);
         match closure_body.params[0].pat.kind {
-            hir::PatKind::Ref(inner, hir::Mutability::Not) => if let hir::PatKind::Binding(
-                hir::BindingAnnotation::NONE, .., name, None
-            ) = inner.kind {
-                if ident_eq(name, closure_expr) {
-                    lint_explicit_closure(cx, e.span, recv.span, true, msrv);
+            hir::PatKind::Ref(inner, hir::Mutability::Not) => {
+                if let hir::PatKind::Binding(hir::BindingAnnotation::NONE, .., name, None) = inner.kind {
+                    if ident_eq(name, closure_expr) {
+                        lint_explicit_closure(cx, e.span, recv.span, true, msrv);
+                    }
                 }
             },
             hir::PatKind::Binding(hir::BindingAnnotation::NONE, .., name, None) => {
@@ -41,22 +40,24 @@ pub(super) fn check(cx: &LateContext<'_>, e: &hir::Expr<'_>, recv: &hir::Expr<'_
                             }
                         }
                     },
-                    hir::ExprKind::MethodCall(method, obj, [], _) => if ident_eq(name, obj) && method.ident.name == sym::clone
+                    hir::ExprKind::MethodCall(method, obj, [], _) => {
+                        if ident_eq(name, obj) && method.ident.name == sym::clone
                         && let Some(fn_id) = cx.typeck_results().type_dependent_def_id(closure_expr.hir_id)
                         && let Some(trait_id) = cx.tcx.trait_of_item(fn_id)
                         && cx.tcx.lang_items().clone_trait().map_or(false, |id| id == trait_id)
                         // no autoderefs
                         && !cx.typeck_results().expr_adjustments(obj).iter()
                             .any(|a| matches!(a.kind, Adjust::Deref(Some(..))))
-                    {
-                        let obj_ty = cx.typeck_results().expr_ty(obj);
-                        if let ty::Ref(_, ty, mutability) = obj_ty.kind() {
-                            if matches!(mutability, Mutability::Not) {
-                                let copy = is_copy(cx, *ty);
-                                lint_explicit_closure(cx, e.span, recv.span, copy, msrv);
+                        {
+                            let obj_ty = cx.typeck_results().expr_ty(obj);
+                            if let ty::Ref(_, ty, mutability) = obj_ty.kind() {
+                                if matches!(mutability, Mutability::Not) {
+                                    let copy = is_copy(cx, *ty);
+                                    lint_explicit_closure(cx, e.span, recv.span, copy, msrv);
+                                }
+                            } else {
+                                lint_needless_cloning(cx, e.span, recv.span);
                             }
-                        } else {
-                            lint_needless_cloning(cx, e.span, recv.span);
                         }
                     },
                     _ => {},
diff --git a/clippy_lints/src/methods/map_collect_result_unit.rs b/clippy_lints/src/methods/map_collect_result_unit.rs
index 0f8cacc3435..e944eac91e7 100644
--- a/clippy_lints/src/methods/map_collect_result_unit.rs
+++ b/clippy_lints/src/methods/map_collect_result_unit.rs
@@ -1,7 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::is_type_diagnostic_item;
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
@@ -17,7 +16,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, iter: &hir::Expr
         && let ty::Adt(_, args) = collect_ret_ty.kind()
         && let Some(result_t) = args.types().next()
         && result_t.is_unit()
-        // get parts for snippet
+    // get parts for snippet
     {
         span_lint_and_sugg(
             cx,
diff --git a/clippy_lints/src/methods/map_identity.rs b/clippy_lints/src/methods/map_identity.rs
index 88545b7286c..d1072475843 100644
--- a/clippy_lints/src/methods/map_identity.rs
+++ b/clippy_lints/src/methods/map_identity.rs
@@ -20,8 +20,8 @@ pub(super) fn check(
     let caller_ty = cx.typeck_results().expr_ty(caller);
 
     if (is_trait_method(cx, expr, sym::Iterator)
-            || is_type_diagnostic_item(cx, caller_ty, sym::Result)
-            || is_type_diagnostic_item(cx, caller_ty, sym::Option))
+        || is_type_diagnostic_item(cx, caller_ty, sym::Result)
+        || is_type_diagnostic_item(cx, caller_ty, sym::Option))
         && is_expr_untyped_identity_function(cx, map_arg)
         && let Some(sugg_span) = expr.span.trim_start(caller.span)
     {
@@ -33,6 +33,6 @@ pub(super) fn check(
             &format!("remove the call to `{name}`"),
             String::new(),
             Applicability::MachineApplicable,
-        )
+        );
     }
 }
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 1664a313fa9..ab376d66966 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -123,7 +123,6 @@ use clippy_utils::consts::{constant, Constant};
 use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
 use clippy_utils::ty::{contains_ty_adt_constructor_opaque, implements_trait, is_copy, is_type_diagnostic_item};
 use clippy_utils::{contains_return, is_bool, is_trait_method, iter_input_pats, peel_blocks, return_ty};
-use if_chain::if_chain;
 pub use path_ends_with_ext::DEFAULT_ALLOWED_DOTFILES;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_hir as hir;
@@ -3980,7 +3979,9 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
         if let TraitItemKind::Fn(ref sig, _) = item.kind
             && sig.decl.implicit_self.has_implicit_self()
             && let Some(first_arg_hir_ty) = sig.decl.inputs.first()
-            && let Some(&first_arg_ty) = cx.tcx.fn_sig(item.owner_id)
+            && let Some(&first_arg_ty) = cx
+                .tcx
+                .fn_sig(item.owner_id)
                 .instantiate_identity()
                 .inputs()
                 .skip_binder()
@@ -4003,7 +4004,6 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             && let ret_ty = return_ty(cx, item.owner_id)
             && let self_ty = TraitRef::identity(cx.tcx, item.owner_id.to_def_id()).self_ty()
             && !ret_ty.contains(self_ty)
-
         {
             span_lint(
                 cx,
diff --git a/clippy_lints/src/methods/mut_mutex_lock.rs b/clippy_lints/src/methods/mut_mutex_lock.rs
index 15ce7c2eee6..1a0fce2876d 100644
--- a/clippy_lints/src/methods/mut_mutex_lock.rs
+++ b/clippy_lints/src/methods/mut_mutex_lock.rs
@@ -1,7 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::expr_custom_deref_adjustment;
 use clippy_utils::ty::is_type_diagnostic_item;
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, Mutability};
 use rustc_lint::LateContext;
diff --git a/clippy_lints/src/methods/no_effect_replace.rs b/clippy_lints/src/methods/no_effect_replace.rs
index f6ba165a9a1..81df32bdee2 100644
--- a/clippy_lints/src/methods/no_effect_replace.rs
+++ b/clippy_lints/src/methods/no_effect_replace.rs
@@ -1,7 +1,6 @@
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::ty::is_type_lang_item;
 use clippy_utils::SpanlessEq;
-use if_chain::if_chain;
 use rustc_ast::LitKind;
 use rustc_hir::{ExprKind, LangItem};
 use rustc_lint::LateContext;
@@ -21,11 +20,9 @@ pub(super) fn check<'tcx>(
 
     if let ExprKind::Lit(spanned) = &arg1.kind
         && let Some(param1) = lit_string_value(&spanned.node)
-
         && let ExprKind::Lit(spanned) = &arg2.kind
         && let LitKind::Str(param2, _) = &spanned.node
         && param1 == param2.as_str()
-
     {
         span_lint(cx, NO_EFFECT_REPLACE, expr.span, "replacing text with itself");
     }
diff --git a/clippy_lints/src/methods/ok_expect.rs b/clippy_lints/src/methods/ok_expect.rs
index 7c86c820a42..e10bc0216e5 100644
--- a/clippy_lints/src/methods/ok_expect.rs
+++ b/clippy_lints/src/methods/ok_expect.rs
@@ -1,6 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::ty::{has_debug_impl, is_type_diagnostic_item};
-use if_chain::if_chain;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
 use rustc_middle::ty::{self, Ty};
@@ -15,7 +14,6 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr
         && let result_type = cx.typeck_results().expr_ty(recv)
         && let Some(error_type) = get_error_type(cx, result_type)
         && has_debug_impl(cx, error_type)
-
     {
         span_lint_and_help(
             cx,
diff --git a/clippy_lints/src/methods/option_as_ref_deref.rs b/clippy_lints/src/methods/option_as_ref_deref.rs
index 9463c39229d..15111006133 100644
--- a/clippy_lints/src/methods/option_as_ref_deref.rs
+++ b/clippy_lints/src/methods/option_as_ref_deref.rs
@@ -3,7 +3,6 @@ use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::{match_def_path, path_to_local_id, paths, peel_blocks};
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
diff --git a/clippy_lints/src/methods/or_fun_call.rs b/clippy_lints/src/methods/or_fun_call.rs
index 6d970dbfab2..dd669e49956 100644
--- a/clippy_lints/src/methods/or_fun_call.rs
+++ b/clippy_lints/src/methods/or_fun_call.rs
@@ -3,7 +3,6 @@ use clippy_utils::eager_or_lazy::switch_to_lazy_eval;
 use clippy_utils::source::snippet_with_context;
 use clippy_utils::ty::{expr_type_is_certain, implements_trait, is_type_diagnostic_item};
 use clippy_utils::{contains_return, is_default_equivalent, is_default_equivalent_call, last_path_segment};
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_lint::LateContext;
 use rustc_middle::ty;
@@ -132,17 +131,12 @@ pub(super) fn check<'tcx>(
         ];
 
         if KNOW_TYPES.iter().any(|k| k.2.contains(&name))
-
             && switch_to_lazy_eval(cx, arg)
             && !contains_return(arg)
-
             && let self_ty = cx.typeck_results().expr_ty(self_expr)
-
             && let Some(&(_, fn_has_arguments, poss, suffix)) =
                 KNOW_TYPES.iter().find(|&&i| is_type_diagnostic_item(cx, self_ty, i.0))
-
             && poss.contains(&name)
-
         {
             let ctxt = span.ctxt();
             let mut app = Applicability::HasPlaceholders;
diff --git a/clippy_lints/src/methods/path_buf_push_overwrite.rs b/clippy_lints/src/methods/path_buf_push_overwrite.rs
index c292b93843b..04a27cc98f3 100644
--- a/clippy_lints/src/methods/path_buf_push_overwrite.rs
+++ b/clippy_lints/src/methods/path_buf_push_overwrite.rs
@@ -1,6 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::ty::is_type_diagnostic_item;
-use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
diff --git a/clippy_lints/src/methods/range_zip_with_len.rs b/clippy_lints/src/methods/range_zip_with_len.rs
index dabeba0b3c3..1148628b084 100644
--- a/clippy_lints/src/methods/range_zip_with_len.rs
+++ b/clippy_lints/src/methods/range_zip_with_len.rs
@@ -1,7 +1,6 @@
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::source::snippet;
 use clippy_utils::{higher, is_integer_const, is_trait_method, SpanlessEq};
-use if_chain::if_chain;
 use rustc_hir::{Expr, ExprKind, QPath};
 use rustc_lint::LateContext;
 use rustc_span::sym;
@@ -21,11 +20,14 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, recv: &'
         && let ExprKind::Path(QPath::Resolved(_, len_path)) = len_recv.kind
         && SpanlessEq::new(cx).eq_path_segments(iter_path.segments, len_path.segments)
     {
-        span_lint(cx,
+        span_lint(
+            cx,
             RANGE_ZIP_WITH_LEN,
             expr.span,
-            &format!("it is more idiomatic to use `{}.iter().enumerate()`",
-                snippet(cx, recv.span, "_"))
+            &format!(
+                "it is more idiomatic to use `{}.iter().enumerate()`",
+                snippet(cx, recv.span, "_")
+            ),
         );
     }
 }
diff --git a/clippy_lints/src/methods/search_is_some.rs b/clippy_lints/src/methods/search_is_some.rs
index 01dc28a4076..9b90a3df72f 100644
--- a/clippy_lints/src/methods/search_is_some.rs
+++ b/clippy_lints/src/methods/search_is_some.rs
@@ -3,7 +3,6 @@ use clippy_utils::source::{snippet, snippet_with_applicability};
 use clippy_utils::sugg::deref_closure_args;
 use clippy_utils::ty::is_type_lang_item;
 use clippy_utils::{is_trait_method, strip_pat_refs};
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_hir::PatKind;
@@ -108,9 +107,7 @@ pub(super) fn check<'tcx>(
                 self_ty.is_str()
             }
         };
-        if is_string_or_str_slice(search_recv)
-            && is_string_or_str_slice(search_arg)
-        {
+        if is_string_or_str_slice(search_recv) && is_string_or_str_slice(search_arg) {
             let msg = format!("called `{option_check_method}()` after calling `find()` on a string");
             match option_check_method {
                 "is_some" => {
diff --git a/clippy_lints/src/methods/single_char_pattern.rs b/clippy_lints/src/methods/single_char_pattern.rs
index d0b57bbf94e..3983f0c0cab 100644
--- a/clippy_lints/src/methods/single_char_pattern.rs
+++ b/clippy_lints/src/methods/single_char_pattern.rs
@@ -1,6 +1,5 @@
 use super::utils::get_hint_if_single_char_arg;
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
@@ -47,7 +46,8 @@ pub(super) fn check(
     for &(method, pos) in &PATTERN_METHODS {
         if let ty::Ref(_, ty, _) = cx.typeck_results().expr_ty_adjusted(receiver).kind()
             && ty.is_str()
-            && method_name.as_str() == method && args.len() > pos
+            && method_name.as_str() == method
+            && args.len() > pos
             && let arg = &args[pos]
             && let mut applicability = Applicability::MachineApplicable
             && let Some(hint) = get_hint_if_single_char_arg(cx, arg, &mut applicability)
diff --git a/clippy_lints/src/methods/str_splitn.rs b/clippy_lints/src/methods/str_splitn.rs
index c6b79876115..0e7ad8fc996 100644
--- a/clippy_lints/src/methods/str_splitn.rs
+++ b/clippy_lints/src/methods/str_splitn.rs
@@ -6,7 +6,6 @@ use clippy_utils::usage::local_used_after_expr;
 use clippy_utils::visitors::{for_each_expr_with_closures, Descend};
 use clippy_utils::{is_diag_item_method, match_def_path, path_to_local_id, paths};
 use core::ops::ControlFlow;
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{
     BindingAnnotation, Expr, ExprKind, HirId, LangItem, Local, MatchSource, Node, Pat, PatKind, QPath, Stmt, StmtKind,
@@ -295,7 +294,7 @@ fn parse_iter_usage<'tcx>(
                         Some(IterUsage {
                             kind: IterUsageKind::NextTuple,
                             span: e.span,
-                            unwrap_kind: None
+                            unwrap_kind: None,
                         })
                     } else {
                         None
@@ -305,18 +304,16 @@ fn parse_iter_usage<'tcx>(
                     if let Some(Constant::Int(idx)) = constant(cx, cx.typeck_results(), idx_expr) {
                         let span = if name.ident.as_str() == "nth" {
                             e.span
+                        } else if let Some((_, Node::Expr(next_expr))) = iter.next()
+                            && let ExprKind::MethodCall(next_name, _, [], _) = next_expr.kind
+                            && next_name.ident.name == sym::next
+                            && next_expr.span.ctxt() == ctxt
+                            && let Some(next_id) = cx.typeck_results().type_dependent_def_id(next_expr.hir_id)
+                            && cx.tcx.trait_of_item(next_id) == Some(iter_id)
+                        {
+                            next_expr.span
                         } else {
-                            if let Some((_, Node::Expr(next_expr))) = iter.next()
-                                && let ExprKind::MethodCall(next_name, _, [], _) = next_expr.kind
-                                && next_name.ident.name == sym::next
-                                && next_expr.span.ctxt() == ctxt
-                                && let Some(next_id) = cx.typeck_results().type_dependent_def_id(next_expr.hir_id)
-                                && cx.tcx.trait_of_item(next_id) == Some(iter_id)
-                            {
-                                next_expr.span
-                            } else {
-                                return None;
-                            }
+                            return None;
                         };
                         (IterUsageKind::Nth(idx), span)
                     } else {
diff --git a/clippy_lints/src/methods/suspicious_map.rs b/clippy_lints/src/methods/suspicious_map.rs
index 909f2fa6bfc..ed49233acb7 100644
--- a/clippy_lints/src/methods/suspicious_map.rs
+++ b/clippy_lints/src/methods/suspicious_map.rs
@@ -1,7 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::usage::mutated_variables;
 use clippy_utils::{expr_or_init, is_trait_method};
-use if_chain::if_chain;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
 use rustc_span::sym;
diff --git a/clippy_lints/src/methods/suspicious_splitn.rs b/clippy_lints/src/methods/suspicious_splitn.rs
index 873968b6417..c45212581ee 100644
--- a/clippy_lints/src/methods/suspicious_splitn.rs
+++ b/clippy_lints/src/methods/suspicious_splitn.rs
@@ -1,5 +1,4 @@
 use clippy_utils::diagnostics::span_lint_and_note;
-use if_chain::if_chain;
 use rustc_ast::LitKind;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::LateContext;
@@ -23,24 +22,21 @@ pub(super) fn check(cx: &LateContext<'_>, method_name: &str, expr: &Expr<'_>, se
         }
 
         let (msg, note_msg) = if count == 0 {
-            (format!("`{method_name}` called with `0` splits"),
-            "the resulting iterator will always return `None`")
+            (
+                format!("`{method_name}` called with `0` splits"),
+                "the resulting iterator will always return `None`",
+            )
         } else {
-            (format!("`{method_name}` called with `1` split"),
-            if self_ty.is_slice() {
-                "the resulting iterator will always return the entire slice followed by `None`"
-            } else {
-                "the resulting iterator will always return the entire string followed by `None`"
-            })
+            (
+                format!("`{method_name}` called with `1` split"),
+                if self_ty.is_slice() {
+                    "the resulting iterator will always return the entire slice followed by `None`"
+                } else {
+                    "the resulting iterator will always return the entire string followed by `None`"
+                },
+            )
         };
 
-        span_lint_and_note(
-            cx,
-            SUSPICIOUS_SPLITN,
-            expr.span,
-            &msg,
-            None,
-            note_msg,
-        );
+        span_lint_and_note(cx, SUSPICIOUS_SPLITN, expr.span, &msg, None, note_msg);
     }
 }
diff --git a/clippy_lints/src/methods/suspicious_to_owned.rs b/clippy_lints/src/methods/suspicious_to_owned.rs
index f1ffa8fd808..60864902a48 100644
--- a/clippy_lints/src/methods/suspicious_to_owned.rs
+++ b/clippy_lints/src/methods/suspicious_to_owned.rs
@@ -1,7 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::is_diag_trait_item;
 use clippy_utils::source::snippet_with_context;
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
@@ -17,7 +16,6 @@ pub fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr<'_>) -
         && let input_type = cx.typeck_results().expr_ty(expr)
         && let ty::Adt(adt, _) = cx.typeck_results().expr_ty(expr).kind()
         && cx.tcx.is_diagnostic_item(sym::Cow, adt.did())
-
     {
         let mut app = Applicability::MaybeIncorrect;
         let recv_snip = snippet_with_context(cx, recv.span, expr.span.ctxt(), "..", &mut app).0;
@@ -33,15 +31,15 @@ pub fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr<'_>) -
                     expr.span,
                     "depending on intent, either make the Cow an Owned variant",
                     format!("{recv_snip}.into_owned()"),
-                    app
+                    app,
                 );
                 diag.span_suggestion(
                     expr.span,
                     "or clone the Cow itself",
                     format!("{recv_snip}.clone()"),
-                    app
+                    app,
                 );
-            }
+            },
         );
         return true;
     }
diff --git a/clippy_lints/src/methods/uninit_assumed_init.rs b/clippy_lints/src/methods/uninit_assumed_init.rs
index fef309db462..1ee655d61e1 100644
--- a/clippy_lints/src/methods/uninit_assumed_init.rs
+++ b/clippy_lints/src/methods/uninit_assumed_init.rs
@@ -1,7 +1,6 @@
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::is_path_diagnostic_item;
 use clippy_utils::ty::is_uninit_value_valid_for_ty;
-use if_chain::if_chain;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
 use rustc_span::sym;
@@ -19,7 +18,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr
             cx,
             UNINIT_ASSUMED_INIT,
             expr.span,
-            "this call for this type may be undefined behavior"
+            "this call for this type may be undefined behavior",
         );
     }
 }
diff --git a/clippy_lints/src/methods/unnecessary_fold.rs b/clippy_lints/src/methods/unnecessary_fold.rs
index 7694cd42beb..7afd3802f7d 100644
--- a/clippy_lints/src/methods/unnecessary_fold.rs
+++ b/clippy_lints/src/methods/unnecessary_fold.rs
@@ -1,7 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::{is_trait_method, path_to_local_id, peel_blocks, strip_pat_refs};
-use if_chain::if_chain;
 use rustc_ast::ast;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
@@ -77,7 +76,6 @@ fn check_fold_with_op(
 
         && path_to_local_id(left_expr, first_arg_id)
         && (replacement.has_args || path_to_local_id(right_expr, second_arg_id))
-
     {
         let mut applicability = Applicability::MachineApplicable;
 
@@ -94,10 +92,7 @@ fn check_fold_with_op(
                 r = snippet_with_applicability(cx, right_expr.span, "EXPR", &mut applicability),
             )
         } else {
-            format!(
-                "{method}{turbofish}()",
-                method = replacement.method_name,
-            )
+            format!("{method}{turbofish}()", method = replacement.method_name,)
         };
 
         span_lint_and_sugg(
diff --git a/clippy_lints/src/methods/unnecessary_iter_cloned.rs b/clippy_lints/src/methods/unnecessary_iter_cloned.rs
index f55de39c10d..36497d59a5a 100644
--- a/clippy_lints/src/methods/unnecessary_iter_cloned.rs
+++ b/clippy_lints/src/methods/unnecessary_iter_cloned.rs
@@ -42,17 +42,14 @@ pub fn check_for_loop_iter(
     {
         let snippet = if let ExprKind::MethodCall(maybe_iter_method_name, collection, [], _) = receiver.kind
             && maybe_iter_method_name.ident.name == sym::iter
-
             && let Some(iterator_trait_id) = cx.tcx.get_diagnostic_item(sym::Iterator)
             && let receiver_ty = cx.typeck_results().expr_ty(receiver)
             && implements_trait(cx, receiver_ty, iterator_trait_id, &[])
             && let Some(iter_item_ty) = get_iterator_item_ty(cx, receiver_ty)
-
             && let Some(into_iterator_trait_id) = cx.tcx.get_diagnostic_item(sym::IntoIterator)
             && let collection_ty = cx.typeck_results().expr_ty(collection)
             && implements_trait(cx, collection_ty, into_iterator_trait_id, &[])
             && let Some(into_iter_item_ty) = cx.get_associated_type(collection_ty, into_iterator_trait_id, "Item")
-
             && iter_item_ty == into_iter_item_ty
             && let Some(collection_snippet) = snippet_opt(cx, collection.span)
         {
@@ -82,11 +79,11 @@ pub fn check_for_loop_iter(
                         ExprKind::AddrOf(_, _, referent) => {
                             let span = addr_of_expr.span.with_hi(referent.span.lo());
                             diag.span_suggestion(span, "remove this `&`", "", applicability);
-                        }
+                        },
                         _ => unreachable!(),
                     }
                 }
-            }
+            },
         );
         return true;
     }
diff --git a/clippy_lints/src/methods/unnecessary_sort_by.rs b/clippy_lints/src/methods/unnecessary_sort_by.rs
index b66e962017c..4949ccd770e 100644
--- a/clippy_lints/src/methods/unnecessary_sort_by.rs
+++ b/clippy_lints/src/methods/unnecessary_sort_by.rs
@@ -2,7 +2,6 @@ use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::is_trait_method;
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::implements_trait;
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Closure, Expr, ExprKind, Mutability, Param, Pat, PatKind, Path, PathSegment, QPath};
 use rustc_lint::LateContext;
@@ -122,30 +121,51 @@ fn detect_lint(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'_>, arg: &Exp
         && let ExprKind::Closure(&Closure { body, .. }) = arg.kind
         && let closure_body = cx.tcx.hir().body(body)
         && let &[
-            Param { pat: Pat { kind: PatKind::Binding(_, _, left_ident, _), .. }, ..},
-            Param { pat: Pat { kind: PatKind::Binding(_, _, right_ident, _), .. }, .. }
+            Param {
+                pat:
+                    Pat {
+                        kind: PatKind::Binding(_, _, left_ident, _),
+                        ..
+                    },
+                ..
+            },
+            Param {
+                pat:
+                    Pat {
+                        kind: PatKind::Binding(_, _, right_ident, _),
+                        ..
+                    },
+                ..
+            },
         ] = &closure_body.params
         && let ExprKind::MethodCall(method_path, left_expr, [right_expr], _) = closure_body.value.kind
         && method_path.ident.name == sym::cmp
         && is_trait_method(cx, closure_body.value, sym::Ord)
     {
-        let (closure_body, closure_arg, reverse) = if mirrored_exprs(
-            left_expr,
-            left_ident,
-            right_expr,
-            right_ident
-        ) {
-            (Sugg::hir(cx, left_expr, "..").to_string(), left_ident.name.to_string(), false)
+        let (closure_body, closure_arg, reverse) = if mirrored_exprs(left_expr, left_ident, right_expr, right_ident) {
+            (
+                Sugg::hir(cx, left_expr, "..").to_string(),
+                left_ident.name.to_string(),
+                false,
+            )
         } else if mirrored_exprs(left_expr, right_ident, right_expr, left_ident) {
-            (Sugg::hir(cx, left_expr, "..").to_string(), right_ident.name.to_string(), true)
+            (
+                Sugg::hir(cx, left_expr, "..").to_string(),
+                right_ident.name.to_string(),
+                true,
+            )
         } else {
             return None;
         };
         let vec_name = Sugg::hir(cx, recv, "..").to_string();
 
-        if let ExprKind::Path(QPath::Resolved(_, Path {
-                segments: [PathSegment { ident: left_name, .. }], ..
-            })) = &left_expr.kind
+        if let ExprKind::Path(QPath::Resolved(
+            _,
+            Path {
+                segments: [PathSegment { ident: left_name, .. }],
+                ..
+            },
+        )) = &left_expr.kind
             && left_name == left_ident
             && cx.tcx.get_diagnostic_item(sym::Ord).map_or(false, |id| {
                 implements_trait(cx, cx.typeck_results().expr_ty(left_expr), id, &[])
diff --git a/clippy_lints/src/methods/useless_asref.rs b/clippy_lints/src/methods/useless_asref.rs
index c23966f95e9..84ee64e88a6 100644
--- a/clippy_lints/src/methods/useless_asref.rs
+++ b/clippy_lints/src/methods/useless_asref.rs
@@ -2,7 +2,6 @@ use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::walk_ptrs_ty_depth;
 use clippy_utils::{get_parent_expr, is_trait_method};
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
diff --git a/clippy_lints/src/methods/utils.rs b/clippy_lints/src/methods/utils.rs
index f776e055833..9ad4250a141 100644
--- a/clippy_lints/src/methods/utils.rs
+++ b/clippy_lints/src/methods/utils.rs
@@ -1,7 +1,6 @@
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::{get_parent_expr, path_to_local_id, usage};
-use if_chain::if_chain;
 use rustc_ast::ast;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
@@ -70,11 +69,14 @@ pub(super) fn get_hint_if_single_char_arg(
             &snip[1..(snip.len() - 1)]
         };
 
-        let hint = format!("'{}'", match ch {
-            "'" => "\\'" ,
-            r"\" => "\\\\",
-            _ => ch,
-        });
+        let hint = format!(
+            "'{}'",
+            match ch {
+                "'" => "\\'",
+                r"\" => "\\\\",
+                _ => ch,
+            }
+        );
 
         Some(hint)
     } else {
diff --git a/clippy_lints/src/methods/vec_resize_to_zero.rs b/clippy_lints/src/methods/vec_resize_to_zero.rs
index 9f0507916e1..9e87fb45aa6 100644
--- a/clippy_lints/src/methods/vec_resize_to_zero.rs
+++ b/clippy_lints/src/methods/vec_resize_to_zero.rs
@@ -1,6 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::ty::is_type_diagnostic_item;
-use if_chain::if_chain;
 use rustc_ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
@@ -20,8 +19,13 @@ pub(super) fn check<'tcx>(
     if let Some(method_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id)
         && let Some(impl_id) = cx.tcx.impl_of_method(method_id)
         && is_type_diagnostic_item(cx, cx.tcx.type_of(impl_id).instantiate_identity(), sym::Vec)
-        && let ExprKind::Lit(Spanned { node: LitKind::Int(0, _), .. }) = count_arg.kind
-        && let ExprKind::Lit(Spanned { node: LitKind::Int(..), .. }) = default_arg.kind
+        && let ExprKind::Lit(Spanned {
+            node: LitKind::Int(0, _),
+            ..
+        }) = count_arg.kind
+        && let ExprKind::Lit(Spanned {
+            node: LitKind::Int(..), ..
+        }) = default_arg.kind
     {
         let method_call_span = expr.span.with_lo(name_span.lo());
         span_lint_and_then(
diff --git a/clippy_lints/src/methods/zst_offset.rs b/clippy_lints/src/methods/zst_offset.rs
index 4f5cf734fa4..0b829d99aef 100644
--- a/clippy_lints/src/methods/zst_offset.rs
+++ b/clippy_lints/src/methods/zst_offset.rs
@@ -1,5 +1,4 @@
 use clippy_utils::diagnostics::span_lint;
-use if_chain::if_chain;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
 use rustc_middle::ty;
diff --git a/clippy_lints/src/misc.rs b/clippy_lints/src/misc.rs
index ee58a47743d..a3d5a8a9d83 100644
--- a/clippy_lints/src/misc.rs
+++ b/clippy_lints/src/misc.rs
@@ -5,7 +5,6 @@ use clippy_utils::{
     any_parent_is_automatically_derived, fulfill_or_allowed, get_parent_expr, is_lint_allowed, iter_input_pats,
     last_path_segment, SpanlessEq,
 };
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::def::Res;
 use rustc_hir::intravisit::FnKind;
@@ -174,13 +173,10 @@ impl<'tcx> LateLintPass<'tcx> for LintPass {
                     diag.span_suggestion(
                         stmt.span,
                         "try",
-                        format!(
-                            "let {name}{tyopt} = {initref};",
-                            name=snippet(cx, name.span, ".."),
-                        ),
+                        format!("let {name}{tyopt} = {initref};", name = snippet(cx, name.span, ".."),),
                         app,
                     );
-                }
+                },
             );
         };
         if let StmtKind::Semi(expr) = stmt.kind
@@ -199,13 +195,11 @@ impl<'tcx> LateLintPass<'tcx> for LintPass {
                     diag.span_suggestion(
                         stmt.span,
                         "replace it with",
-                        format!(
-                            "if {sugg} {{ {}; }}",
-                            &snippet(cx, b.span, ".."),
-                        ),
+                        format!("if {sugg} {{ {}; }}", &snippet(cx, b.span, ".."),),
                         Applicability::MachineApplicable, // snippet
                     );
-                });
+                },
+            );
         };
     }
 
diff --git a/clippy_lints/src/mismatching_type_param_order.rs b/clippy_lints/src/mismatching_type_param_order.rs
index 724f2c8e597..c74d0d623df 100644
--- a/clippy_lints/src/mismatching_type_param_order.rs
+++ b/clippy_lints/src/mismatching_type_param_order.rs
@@ -60,8 +60,10 @@ impl<'tcx> LateLintPass<'tcx> for TypeParamMismatch {
             let mut impl_params = Vec::new();
             for p in generic_args.args {
                 match p {
-                    GenericArg::Type(Ty {kind: TyKind::Path(QPath::Resolved(_, path)), ..}) =>
-                        impl_params.push((path.segments[0].ident.to_string(), path.span)),
+                    GenericArg::Type(Ty {
+                        kind: TyKind::Path(QPath::Resolved(_, path)),
+                        ..
+                    }) => impl_params.push((path.segments[0].ident.to_string(), path.span)),
                     GenericArg::Type(_) => return,
                     _ => (),
                 };
@@ -70,36 +72,36 @@ impl<'tcx> LateLintPass<'tcx> for TypeParamMismatch {
             // find the type that the Impl is for
             // only lint on struct/enum/union for now
             let Res::Def(DefKind::Struct | DefKind::Enum | DefKind::Union, defid) = path.res else {
-                return
+                return;
             };
 
             // get the names of the generic parameters in the type
             let type_params = &cx.tcx.generics_of(defid).params;
-            let type_param_names: Vec<_> = type_params.iter()
-            .filter_map(|p|
-                match p.kind {
-                    GenericParamDefKind::Type {..} => Some(p.name.to_string()),
+            let type_param_names: Vec<_> = type_params
+                .iter()
+                .filter_map(|p| match p.kind {
+                    GenericParamDefKind::Type { .. } => Some(p.name.to_string()),
                     _ => None,
-                }
-            ).collect();
+                })
+                .collect();
             // hashmap of name -> index for mismatch_param_name
-            let type_param_names_hashmap: FxHashMap<&String, usize> =
-                type_param_names.iter().enumerate().map(|(i, param)| (param, i)).collect();
+            let type_param_names_hashmap: FxHashMap<&String, usize> = type_param_names
+                .iter()
+                .enumerate()
+                .map(|(i, param)| (param, i))
+                .collect();
 
             let type_name = segment.ident;
             for (i, (impl_param_name, impl_param_span)) in impl_params.iter().enumerate() {
                 if mismatch_param_name(i, impl_param_name, &type_param_names_hashmap) {
-                    let msg = format!("`{type_name}` has a similarly named generic type parameter `{impl_param_name}` in its declaration, but in a different order");
-                    let help = format!("try `{}`, or a name that does not conflict with `{type_name}`'s generic params",
-                                       type_param_names[i]);
-                    span_lint_and_help(
-                        cx,
-                        MISMATCHING_TYPE_PARAM_ORDER,
-                        *impl_param_span,
-                        &msg,
-                        None,
-                        &help
+                    let msg = format!(
+                        "`{type_name}` has a similarly named generic type parameter `{impl_param_name}` in its declaration, but in a different order"
+                    );
+                    let help = format!(
+                        "try `{}`, or a name that does not conflict with `{type_name}`'s generic params",
+                        type_param_names[i]
                     );
+                    span_lint_and_help(cx, MISMATCHING_TYPE_PARAM_ORDER, *impl_param_span, &msg, None, &help);
                 }
             }
         }
diff --git a/clippy_lints/src/missing_doc.rs b/clippy_lints/src/missing_doc.rs
index cfc4af35f33..1dcaa60ac7b 100644
--- a/clippy_lints/src/missing_doc.rs
+++ b/clippy_lints/src/missing_doc.rs
@@ -8,7 +8,6 @@
 use clippy_utils::attrs::is_doc_hidden;
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::is_from_proc_macro;
-use if_chain::if_chain;
 use rustc_ast::ast::{self, MetaItem, MetaItemKind};
 use rustc_hir as hir;
 use rustc_hir::def_id::LocalDefId;
diff --git a/clippy_lints/src/missing_enforced_import_rename.rs b/clippy_lints/src/missing_enforced_import_rename.rs
index 1d07727f1c0..f7e42815104 100644
--- a/clippy_lints/src/missing_enforced_import_rename.rs
+++ b/clippy_lints/src/missing_enforced_import_rename.rs
@@ -94,9 +94,7 @@ impl LateLintPass<'_> for ImportRename {
                         span_without_semi,
                         "this import should be renamed",
                         "try",
-                        format!(
-                            "{import} as {name}",
-                        ),
+                        format!("{import} as {name}",),
                         Applicability::MachineApplicable,
                     );
                 }
diff --git a/clippy_lints/src/mixed_read_write_in_expression.rs b/clippy_lints/src/mixed_read_write_in_expression.rs
index 9634b4357c2..b46c006cd57 100644
--- a/clippy_lints/src/mixed_read_write_in_expression.rs
+++ b/clippy_lints/src/mixed_read_write_in_expression.rs
@@ -1,6 +1,5 @@
 use clippy_utils::diagnostics::{span_lint, span_lint_and_note};
 use clippy_utils::{get_parent_expr, path_to_local, path_to_local_id};
-use if_chain::if_chain;
 use rustc_hir::intravisit::{walk_expr, Visitor};
 use rustc_hir::{BinOpKind, Block, Expr, ExprKind, Guard, HirId, Local, Node, Stmt, StmtKind};
 use rustc_lint::{LateContext, LateLintPass};
@@ -83,7 +82,11 @@ impl<'tcx> LateLintPass<'tcx> for EvalOrderDependence {
         let var = if let ExprKind::Assign(lhs, ..) | ExprKind::AssignOp(_, lhs, _) = expr.kind
             && let Some(var) = path_to_local(lhs)
             && expr.span.desugaring_kind().is_none()
-        { var } else { return; };
+        {
+            var
+        } else {
+            return;
+        };
         let mut visitor = ReadVisitor {
             cx,
             var,
diff --git a/clippy_lints/src/needless_arbitrary_self_type.rs b/clippy_lints/src/needless_arbitrary_self_type.rs
index b6aafd35b58..1712262ff3e 100644
--- a/clippy_lints/src/needless_arbitrary_self_type.rs
+++ b/clippy_lints/src/needless_arbitrary_self_type.rs
@@ -1,5 +1,4 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use if_chain::if_chain;
 use rustc_ast::ast::{BindingAnnotation, ByRef, Lifetime, Mutability, Param, PatKind, Path, TyKind};
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass};
@@ -105,7 +104,7 @@ fn check_param_inner(cx: &EarlyContext<'_>, path: &Path, span: Span, binding_mod
             "consider to change this parameter to",
             self_param,
             applicability,
-        )
+        );
     }
 }
 
@@ -124,7 +123,7 @@ impl EarlyLintPass for NeedlessArbitrarySelfType {
             },
             TyKind::Ref(lifetime, mut_ty) => {
                 if let TyKind::Path(None, path) = &mut_ty.ty.kind
-                && let PatKind::Ident(BindingAnnotation::NONE, _, _) = p.pat.kind
+                    && let PatKind::Ident(BindingAnnotation::NONE, _, _) = p.pat.kind
                 {
                     check_param_inner(cx, path, p.span.to(p.ty.span), &Mode::Ref(*lifetime), mut_ty.mutbl);
                 }
diff --git a/clippy_lints/src/needless_for_each.rs b/clippy_lints/src/needless_for_each.rs
index 42bce1ee276..0203e2ccd63 100644
--- a/clippy_lints/src/needless_for_each.rs
+++ b/clippy_lints/src/needless_for_each.rs
@@ -6,8 +6,6 @@ use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Span;
 use rustc_span::{sym, Symbol};
 
-use if_chain::if_chain;
-
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::is_trait_method;
 use clippy_utils::source::snippet_with_applicability;
@@ -108,7 +106,7 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessForEach {
                 if let Some(ret_suggs) = ret_suggs {
                     diag.multipart_suggestion("...and replace `return` with `continue`", ret_suggs, applicability);
                 }
-            })
+            });
         }
     }
 }
diff --git a/clippy_lints/src/needless_late_init.rs b/clippy_lints/src/needless_late_init.rs
index 886c0f3a430..0a95678d31a 100644
--- a/clippy_lints/src/needless_late_init.rs
+++ b/clippy_lints/src/needless_late_init.rs
@@ -136,7 +136,6 @@ impl LocalAssign {
                     // avoid visiting if not needed
                     && assign.lhs_id == binding_id
                     && other_stmts.iter().all(|stmt| !contains_assign_expr(cx, stmt))
-
                 {
                     Some(assign)
                 } else {
@@ -367,17 +366,17 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessLateInit {
     fn check_local(&mut self, cx: &LateContext<'tcx>, local: &'tcx Local<'tcx>) {
         let mut parents = cx.tcx.hir().parent_iter(local.hir_id);
         if let Local {
-                init: None,
-                pat: &Pat {
+            init: None,
+            pat:
+                &Pat {
                     kind: PatKind::Binding(BindingAnnotation::NONE, binding_id, _, None),
                     ..
                 },
-                source: LocalSource::Normal,
-                ..
-            } = local
+            source: LocalSource::Normal,
+            ..
+        } = local
             && let Some((_, Node::Stmt(local_stmt))) = parents.next()
             && let Some((_, Node::Block(block))) = parents.next()
-
         {
             check(cx, local, local_stmt, block, binding_id);
         }
diff --git a/clippy_lints/src/needless_parens_on_range_literals.rs b/clippy_lints/src/needless_parens_on_range_literals.rs
index 6d4a4ee603e..490c3f9c1ab 100644
--- a/clippy_lints/src/needless_parens_on_range_literals.rs
+++ b/clippy_lints/src/needless_parens_on_range_literals.rs
@@ -60,12 +60,16 @@ fn check_for_parens(cx: &LateContext<'_>, e: &Expr<'_>, is_start: bool) {
         && snippet_enclosed_in_parenthesis(&snippet(cx, e.span, ""))
     {
         let mut applicability = Applicability::MachineApplicable;
-        span_lint_and_then(cx, NEEDLESS_PARENS_ON_RANGE_LITERALS, e.span,
+        span_lint_and_then(
+            cx,
+            NEEDLESS_PARENS_ON_RANGE_LITERALS,
+            e.span,
             "needless parenthesis on range literals can be removed",
             |diag| {
                 let suggestion = snippet_with_applicability(cx, literal.span, "_", &mut applicability);
                 diag.span_suggestion(e.span, "try", suggestion, applicability);
-            });
+            },
+        );
     }
 }
 
diff --git a/clippy_lints/src/needless_pass_by_value.rs b/clippy_lints/src/needless_pass_by_value.rs
index 24b9eaac088..7c48b84e430 100644
--- a/clippy_lints/src/needless_pass_by_value.rs
+++ b/clippy_lints/src/needless_pass_by_value.rs
@@ -5,7 +5,6 @@ use clippy_utils::source::{snippet, snippet_opt};
 use clippy_utils::ty::{
     implements_trait, implements_trait_with_env_from_iter, is_copy, is_type_diagnostic_item, is_type_lang_item,
 };
-use if_chain::if_chain;
 use rustc_ast::ast::Attribute;
 use rustc_errors::{Applicability, Diagnostic};
 use rustc_hir::intravisit::FnKind;
@@ -181,16 +180,17 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByValue {
                 && !ty.is_mutable_ptr()
                 && !is_copy(cx, ty)
                 && ty.is_sized(cx.tcx, cx.param_env)
-                && !allowed_traits.iter().any(|&t| implements_trait_with_env_from_iter(
-                    cx.tcx,
-                    cx.param_env,
-                    ty,
-                    t,
-                    [Option::<ty::GenericArg<'tcx>>::None],
-                ))
+                && !allowed_traits.iter().any(|&t| {
+                    implements_trait_with_env_from_iter(
+                        cx.tcx,
+                        cx.param_env,
+                        ty,
+                        t,
+                        [Option::<ty::GenericArg<'tcx>>::None],
+                    )
+                })
                 && !implements_borrow_trait
                 && !all_borrowable_trait
-
                 && let PatKind::Binding(BindingAnnotation(_, Mutability::Not), canonical_id, ..) = arg.pat.kind
                 && !moved_vars.contains(&canonical_id)
             {
@@ -203,23 +203,32 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByValue {
                                 cx.param_env,
                                 ty,
                                 traits::ObligationCause::dummy_with_span(span),
-                            ).is_ok() {
+                            )
+                            .is_ok()
+                            {
                                 diag.span_help(span, "consider marking this type as `Copy`");
                             }
                         }
                     }
 
                     if is_type_diagnostic_item(cx, ty, sym::Vec)
-                        && let Some(clone_spans) =
-                            get_spans(cx, Some(body.id()), idx, &[("clone", ".to_owned()")])
+                        && let Some(clone_spans) = get_spans(cx, Some(body.id()), idx, &[("clone", ".to_owned()")])
                         && let TyKind::Path(QPath::Resolved(_, path)) = input.kind
-                        && let Some(elem_ty) = path.segments.iter()
+                        && let Some(elem_ty) = path
+                            .segments
+                            .iter()
                             .find(|seg| seg.ident.name == sym::Vec)
                             .and_then(|ps| ps.args.as_ref())
-                            .map(|params| params.args.iter().find_map(|arg| match arg {
-                                GenericArg::Type(ty) => Some(ty),
-                                _ => None,
-                            }).unwrap())
+                            .map(|params| {
+                                params
+                                    .args
+                                    .iter()
+                                    .find_map(|arg| match arg {
+                                        GenericArg::Type(ty) => Some(ty),
+                                        _ => None,
+                                    })
+                                    .unwrap()
+                            })
                     {
                         let slice_ty = format!("&[{}]", snippet(cx, elem_ty.span, "_"));
                         diag.span_suggestion(
@@ -233,10 +242,7 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByValue {
                             diag.span_suggestion(
                                 span,
                                 snippet_opt(cx, span)
-                                    .map_or(
-                                        "change the call to".into(),
-                                        |x| format!("change `{x}` to"),
-                                    ),
+                                    .map_or("change the call to".into(), |x| format!("change `{x}` to")),
                                 suggestion,
                                 Applicability::Unspecified,
                             );
@@ -248,7 +254,8 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByValue {
 
                     if is_type_lang_item(cx, ty, LangItem::String) {
                         if let Some(clone_spans) =
-                            get_spans(cx, Some(body.id()), idx, &[("clone", ".to_string()"), ("as_str", "")]) {
+                            get_spans(cx, Some(body.id()), idx, &[("clone", ".to_string()"), ("as_str", "")])
+                        {
                             diag.span_suggestion(
                                 input.span,
                                 "consider changing the type to",
@@ -260,10 +267,7 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByValue {
                                 diag.span_suggestion(
                                     span,
                                     snippet_opt(cx, span)
-                                        .map_or(
-                                            "change the call to".into(),
-                                            |x| format!("change `{x}` to")
-                                        ),
+                                        .map_or("change the call to".into(), |x| format!("change `{x}` to")),
                                     suggestion,
                                     Applicability::Unspecified,
                                 );
diff --git a/clippy_lints/src/needless_question_mark.rs b/clippy_lints/src/needless_question_mark.rs
index 66ad45e1cb8..7ec0879ba38 100644
--- a/clippy_lints/src/needless_question_mark.rs
+++ b/clippy_lints/src/needless_question_mark.rs
@@ -1,7 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::path_res;
 use clippy_utils::source::snippet;
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::{Block, Body, CoroutineKind, CoroutineSource, Expr, ExprKind, LangItem, MatchSource, QPath};
diff --git a/clippy_lints/src/neg_cmp_op_on_partial_ord.rs b/clippy_lints/src/neg_cmp_op_on_partial_ord.rs
index 5e692d7d205..30aed8cc04a 100644
--- a/clippy_lints/src/neg_cmp_op_on_partial_ord.rs
+++ b/clippy_lints/src/neg_cmp_op_on_partial_ord.rs
@@ -1,6 +1,5 @@
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::ty::implements_trait;
-use if_chain::if_chain;
 use rustc_hir::{BinOpKind, Expr, ExprKind, UnOp};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
@@ -50,7 +49,6 @@ impl<'tcx> LateLintPass<'tcx> for NoNegCompOpForPartialOrd {
             && let ExprKind::Unary(UnOp::Not, inner) = expr.kind
             && let ExprKind::Binary(ref op, left, _) = inner.kind
             && let BinOpKind::Le | BinOpKind::Ge | BinOpKind::Lt | BinOpKind::Gt = op.node
-
         {
             let ty = cx.typeck_results().expr_ty(left);
 
diff --git a/clippy_lints/src/neg_multiply.rs b/clippy_lints/src/neg_multiply.rs
index 62a8f04bf17..a6786e913e9 100644
--- a/clippy_lints/src/neg_multiply.rs
+++ b/clippy_lints/src/neg_multiply.rs
@@ -2,7 +2,6 @@ use clippy_utils::consts::{self, Constant};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_context;
 use clippy_utils::sugg::has_enclosing_paren;
-use if_chain::if_chain;
 use rustc_ast::util::parser::PREC_PREFIX;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind, UnOp};
@@ -56,7 +55,6 @@ fn check_mul(cx: &LateContext<'_>, span: Span, lit: &Expr<'_>, exp: &Expr<'_>) {
     if let ExprKind::Lit(l) = lit.kind
         && consts::lit_to_mir_constant(&l.node, cx.typeck_results().expr_ty_opt(lit)) == Constant::Int(1)
         && cx.typeck_results().expr_ty(exp).is_integral()
-
     {
         let mut applicability = Applicability::MachineApplicable;
         let (snip, from_macro) = snippet_with_context(cx, exp.span, span.ctxt(), "..", &mut applicability);
@@ -66,13 +64,13 @@ fn check_mul(cx: &LateContext<'_>, span: Span, lit: &Expr<'_>, exp: &Expr<'_>) {
             format!("-{snip}")
         };
         span_lint_and_sugg(
-                cx,
-                NEG_MULTIPLY,
-                span,
-                "this multiplication by -1 can be written more succinctly",
-                "consider using",
-                suggestion,
-                applicability,
-            );
+            cx,
+            NEG_MULTIPLY,
+            span,
+            "this multiplication by -1 can be written more succinctly",
+            "consider using",
+            suggestion,
+            applicability,
+        );
     }
 }
diff --git a/clippy_lints/src/new_without_default.rs b/clippy_lints/src/new_without_default.rs
index bd75a8c2a98..abba622a285 100644
--- a/clippy_lints/src/new_without_default.rs
+++ b/clippy_lints/src/new_without_default.rs
@@ -2,7 +2,6 @@ use clippy_utils::diagnostics::span_lint_hir_and_then;
 use clippy_utils::return_ty;
 use clippy_utils::source::snippet;
 use clippy_utils::sugg::DiagnosticExt;
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_hir::HirIdSet;
@@ -150,7 +149,7 @@ impl<'tcx> LateLintPass<'tcx> for NewWithoutDefault {
                                         &create_new_without_default_suggest_msg(
                                             &self_type_snip,
                                             &generics_sugg,
-                                            &where_clause_sugg
+                                            &where_clause_sugg,
                                         ),
                                         Applicability::MachineApplicable,
                                     );
diff --git a/clippy_lints/src/no_effect.rs b/clippy_lints/src/no_effect.rs
index c5d6ff9b2f5..de8bb123e9b 100644
--- a/clippy_lints/src/no_effect.rs
+++ b/clippy_lints/src/no_effect.rs
@@ -145,7 +145,7 @@ fn check_no_effect(cx: &LateContext<'_>, stmt: &Stmt<'_>) -> bool {
                 NO_EFFECT_UNDERSCORE_BINDING,
                 init.hir_id,
                 stmt.span,
-                "binding to `_` prefixed variable with no side-effect"
+                "binding to `_` prefixed variable with no side-effect",
             );
             return true;
         }
@@ -205,13 +205,12 @@ fn check_unnecessary_operation(cx: &LateContext<'_>, stmt: &Stmt<'_>) {
         && reduced.iter().all(|e| e.span.ctxt() == ctxt)
     {
         if let ExprKind::Index(..) = &expr.kind {
-            let snippet = if let (Some(arr), Some(func)) =
-                (snippet_opt(cx, reduced[0].span), snippet_opt(cx, reduced[1].span))
-            {
-                format!("assert!({}.len() > {});", &arr, &func)
-            } else {
-                return;
-            };
+            let snippet =
+                if let (Some(arr), Some(func)) = (snippet_opt(cx, reduced[0].span), snippet_opt(cx, reduced[1].span)) {
+                    format!("assert!({}.len() > {});", &arr, &func)
+                } else {
+                    return;
+                };
             span_lint_hir_and_then(
                 cx,
                 UNNECESSARY_OPERATION,
diff --git a/clippy_lints/src/non_copy_const.rs b/clippy_lints/src/non_copy_const.rs
index 5a91468a214..3059eb25d29 100644
--- a/clippy_lints/src/non_copy_const.rs
+++ b/clippy_lints/src/non_copy_const.rs
@@ -7,7 +7,6 @@ use std::ptr;
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::macros::macro_backtrace;
 use clippy_utils::{def_path_def_ids, in_constant};
-use if_chain::if_chain;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::def_id::DefId;
@@ -414,12 +413,7 @@ impl<'tcx> LateLintPass<'tcx> for NonCopyConst {
                         && !self.is_ty_ignored(ty) && Self::is_unfrozen(cx, normalized)
                         && self.is_value_unfrozen_poly(cx, *body_id, normalized)
                     {
-                        lint(
-                           cx,
-                           Source::Assoc {
-                               item: impl_item.span,
-                            },
-                        );
+                        lint(cx, Source::Assoc { item: impl_item.span });
                     }
                 },
                 ItemKind::Impl(Impl { of_trait: None, .. }) => {
diff --git a/clippy_lints/src/non_octal_unix_permissions.rs b/clippy_lints/src/non_octal_unix_permissions.rs
index ab52ed5a7ca..6cfcc81025d 100644
--- a/clippy_lints/src/non_octal_unix_permissions.rs
+++ b/clippy_lints/src/non_octal_unix_permissions.rs
@@ -1,7 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::{snippet_opt, snippet_with_applicability};
 use clippy_utils::{match_def_path, paths};
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
@@ -46,15 +45,17 @@ impl<'tcx> LateLintPass<'tcx> for NonOctalUnixPermissions {
             ExprKind::MethodCall(path, func, [param], _) => {
                 if let Some(adt) = cx.typeck_results().expr_ty(func).peel_refs().ty_adt_def()
                     && ((path.ident.name == sym!(mode)
-                        && matches!(cx.tcx.get_diagnostic_name(adt.did()), Some(sym::FsOpenOptions | sym::DirBuilder)))
+                        && matches!(
+                            cx.tcx.get_diagnostic_name(adt.did()),
+                            Some(sym::FsOpenOptions | sym::DirBuilder)
+                        ))
                         || (path.ident.name == sym!(set_mode)
                             && cx.tcx.is_diagnostic_item(sym::FsPermissions, adt.did())))
                     && let ExprKind::Lit(_) = param.kind
                     && param.span.eq_ctxt(expr.span)
-
                 {
                     let Some(snip) = snippet_opt(cx, param.span) else {
-                        return
+                        return;
                     };
 
                     if !snip.starts_with("0o") {
diff --git a/clippy_lints/src/non_send_fields_in_send_ty.rs b/clippy_lints/src/non_send_fields_in_send_ty.rs
index 23e756c850f..df1476e6809 100644
--- a/clippy_lints/src/non_send_fields_in_send_ty.rs
+++ b/clippy_lints/src/non_send_fields_in_send_ty.rs
@@ -98,9 +98,9 @@ impl<'tcx> LateLintPass<'tcx> for NonSendFieldInSendTy {
             for variant in adt_def.variants() {
                 for field in &variant.fields {
                     if let Some(field_hir_id) = field
-                            .did
-                            .as_local()
-                            .map(|local_def_id| hir_map.local_def_id_to_hir_id(local_def_id))
+                        .did
+                        .as_local()
+                        .map(|local_def_id| hir_map.local_def_id_to_hir_id(local_def_id))
                         && !is_lint_allowed(cx, NON_SEND_FIELDS_IN_SEND_TY, field_hir_id)
                         && let field_ty = field.ty(cx.tcx, impl_trait_args)
                         && !ty_allowed_in_send(cx, field_ty, send_trait)
@@ -110,7 +110,7 @@ impl<'tcx> LateLintPass<'tcx> for NonSendFieldInSendTy {
                             def: field_def,
                             ty: field_ty,
                             generic_params: collect_generic_params(field_ty),
-                        })
+                        });
                     }
                 }
             }
@@ -128,12 +128,17 @@ impl<'tcx> LateLintPass<'tcx> for NonSendFieldInSendTy {
                         for field in non_send_fields {
                             diag.span_note(
                                 field.def.span,
-                                format!("it is not safe to send field `{}` to another thread", field.def.ident.name),
+                                format!(
+                                    "it is not safe to send field `{}` to another thread",
+                                    field.def.ident.name
+                                ),
                             );
 
                             match field.generic_params.len() {
                                 0 => diag.help("use a thread-safe type that implements `Send`"),
-                                1 if is_ty_param(field.ty) => diag.help(format!("add `{}: Send` bound in `Send` impl", field.ty)),
+                                1 if is_ty_param(field.ty) => {
+                                    diag.help(format!("add `{}: Send` bound in `Send` impl", field.ty))
+                                },
                                 _ => diag.help(format!(
                                     "add bounds on type parameter{} `{}` that satisfy `{}: Send`",
                                     if field.generic_params.len() > 1 { "s" } else { "" },
diff --git a/clippy_lints/src/nonstandard_macro_braces.rs b/clippy_lints/src/nonstandard_macro_braces.rs
index 87359086512..8604fe08e50 100644
--- a/clippy_lints/src/nonstandard_macro_braces.rs
+++ b/clippy_lints/src/nonstandard_macro_braces.rs
@@ -1,7 +1,6 @@
 use clippy_config::types::MacroMatcher;
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_opt;
-use if_chain::if_chain;
 use rustc_ast::ast;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/operators/assign_op_pattern.rs b/clippy_lints/src/operators/assign_op_pattern.rs
index bc7ad151aee..2f85130fba1 100644
--- a/clippy_lints/src/operators/assign_op_pattern.rs
+++ b/clippy_lints/src/operators/assign_op_pattern.rs
@@ -4,7 +4,6 @@ use clippy_utils::ty::implements_trait;
 use clippy_utils::visitors::for_each_expr;
 use clippy_utils::{binop_traits, eq_expr_value, trait_ref_of_method};
 use core::ops::ControlFlow;
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_hir_typeck::expr_use_visitor::{Delegate, ExprUseVisitor, PlaceBase, PlaceWithHirId};
@@ -28,8 +27,7 @@ pub(super) fn check<'tcx>(
             if let Some((_, lang_item)) = binop_traits(op.node)
                 && let Some(trait_id) = cx.tcx.lang_items().get(lang_item)
                 && let parent_fn = cx.tcx.hir().get_parent_item(e.hir_id).def_id
-                && trait_ref_of_method(cx, parent_fn)
-                    .map_or(true, |t| t.path.res.def_id() != trait_id)
+                && trait_ref_of_method(cx, parent_fn).map_or(true, |t| t.path.res.def_id() != trait_id)
                 && implements_trait(cx, ty, trait_id, &[rty.into()])
             {
                 // Primitive types execute assign-ops right-to-left. Every other type is left-to-right.
diff --git a/clippy_lints/src/operators/const_comparisons.rs b/clippy_lints/src/operators/const_comparisons.rs
index 408c9a2cf29..52ef9546110 100644
--- a/clippy_lints/src/operators/const_comparisons.rs
+++ b/clippy_lints/src/operators/const_comparisons.rs
@@ -3,7 +3,6 @@
 use std::cmp::Ordering;
 
 use clippy_utils::consts::{constant, Constant};
-use if_chain::if_chain;
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::LateContext;
 use rustc_middle::ty::layout::HasTyCtxt;
@@ -76,7 +75,6 @@ pub(super) fn check<'tcx>(
             (&left_cmp_op, &right_cmp_op, ordering),
             (CmpOp::Le | CmpOp::Ge, CmpOp::Le | CmpOp::Ge, Ordering::Equal)
         )
-
     {
         if left_cmp_op.direction() == right_cmp_op.direction() {
             let lhs_str = snippet(cx, left_cond.span, "<lhs>");
@@ -104,15 +102,20 @@ pub(super) fn check<'tcx>(
             }
             // We could autofix this error but choose not to,
             // because code triggering this lint probably not behaving correctly in the first place
-        }
-        else if !comparison_is_possible(left_cmp_op.direction(), ordering) {
+        } else if !comparison_is_possible(left_cmp_op.direction(), ordering) {
             let expr_str = snippet(cx, left_expr.span, "..");
             let lhs_str = snippet(cx, left_const_expr.span, "<lhs>");
             let rhs_str = snippet(cx, right_const_expr.span, "<rhs>");
             let note = match ordering {
-                Ordering::Less => format!("since `{lhs_str}` < `{rhs_str}`, the expression evaluates to false for any value of `{expr_str}`"),
-                Ordering::Equal => format!("`{expr_str}` cannot simultaneously be greater than and less than `{lhs_str}`"),
-                Ordering::Greater => format!("since `{lhs_str}` > `{rhs_str}`, the expression evaluates to false for any value of `{expr_str}`"),
+                Ordering::Less => format!(
+                    "since `{lhs_str}` < `{rhs_str}`, the expression evaluates to false for any value of `{expr_str}`"
+                ),
+                Ordering::Equal => {
+                    format!("`{expr_str}` cannot simultaneously be greater than and less than `{lhs_str}`")
+                },
+                Ordering::Greater => format!(
+                    "since `{lhs_str}` > `{rhs_str}`, the expression evaluates to false for any value of `{expr_str}`"
+                ),
             };
             span_lint_and_note(
                 cx,
diff --git a/clippy_lints/src/operators/float_cmp.rs b/clippy_lints/src/operators/float_cmp.rs
index fecaf14bf5e..0561739d160 100644
--- a/clippy_lints/src/operators/float_cmp.rs
+++ b/clippy_lints/src/operators/float_cmp.rs
@@ -2,7 +2,6 @@ use clippy_utils::consts::{constant_with_source, Constant};
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::get_item_name;
 use clippy_utils::sugg::Sugg;
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind, UnOp};
 use rustc_lint::LateContext;
@@ -107,8 +106,8 @@ fn is_signum(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
 
     if let ExprKind::MethodCall(method_name, self_arg, ..) = expr.kind
         && sym!(signum) == method_name.ident.name
-        // Check that the receiver of the signum() is a float (expressions[0] is the receiver of
-        // the method call)
+    // Check that the receiver of the signum() is a float (expressions[0] is the receiver of
+    // the method call)
     {
         return is_float(cx, self_arg);
     }
diff --git a/clippy_lints/src/operators/float_equality_without_abs.rs b/clippy_lints/src/operators/float_equality_without_abs.rs
index 91eaa296f14..cace85a2451 100644
--- a/clippy_lints/src/operators/float_equality_without_abs.rs
+++ b/clippy_lints/src/operators/float_equality_without_abs.rs
@@ -1,6 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::{match_def_path, paths, sugg};
-use if_chain::if_chain;
 use rustc_ast::util::parser::AssocOp;
 use rustc_errors::Applicability;
 use rustc_hir::def::{DefKind, Res};
@@ -44,26 +43,23 @@ pub(crate) fn check<'tcx>(
         && let t_val_r = cx.typeck_results().expr_ty(val_r)
         && let ty::Float(_) = t_val_l.kind()
         && let ty::Float(_) = t_val_r.kind()
-
     {
         let sug_l = sugg::Sugg::hir(cx, val_l, "..");
         let sug_r = sugg::Sugg::hir(cx, val_r, "..");
         // format the suggestion
-        let suggestion = format!("{}.abs()", sugg::make_assoc(AssocOp::Subtract, &sug_l, &sug_r).maybe_par());
+        let suggestion = format!(
+            "{}.abs()",
+            sugg::make_assoc(AssocOp::Subtract, &sug_l, &sug_r).maybe_par()
+        );
         // spans the lint
         span_lint_and_then(
             cx,
             FLOAT_EQUALITY_WITHOUT_ABS,
             expr.span,
             "float equality check without `.abs()`",
-            | diag | {
-                diag.span_suggestion(
-                    lhs.span,
-                    "add `.abs()`",
-                    suggestion,
-                    Applicability::MaybeIncorrect,
-                );
-            }
+            |diag| {
+                diag.span_suggestion(lhs.span, "add `.abs()`", suggestion, Applicability::MaybeIncorrect);
+            },
         );
     }
 }
diff --git a/clippy_lints/src/operators/modulo_arithmetic.rs b/clippy_lints/src/operators/modulo_arithmetic.rs
index 2c7eebc5ae9..cb3916484c1 100644
--- a/clippy_lints/src/operators/modulo_arithmetic.rs
+++ b/clippy_lints/src/operators/modulo_arithmetic.rs
@@ -1,7 +1,6 @@
 use clippy_utils::consts::{constant, Constant};
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::sext;
-use if_chain::if_chain;
 use rustc_hir::{BinOpKind, Expr};
 use rustc_lint::LateContext;
 use rustc_middle::ty::{self, Ty};
@@ -23,8 +22,7 @@ pub(super) fn check<'tcx>(
             && let Some(rhs_operand) = rhs_operand
         {
             check_const_operands(cx, e, &lhs_operand, &rhs_operand);
-        }
-        else {
+        } else {
             check_non_const_operands(cx, e, lhs);
         }
     };
diff --git a/clippy_lints/src/operators/op_ref.rs b/clippy_lints/src/operators/op_ref.rs
index 77ef4a43497..7d8aa3f56fe 100644
--- a/clippy_lints/src/operators/op_ref.rs
+++ b/clippy_lints/src/operators/op_ref.rs
@@ -2,7 +2,6 @@ use clippy_utils::diagnostics::{multispan_sugg, span_lint_and_then};
 use clippy_utils::get_enclosing_block;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::{implements_trait, is_copy};
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::def::Res;
 use rustc_hir::def_id::DefId;
@@ -190,11 +189,9 @@ fn in_impl<'tcx>(
         && trait_id == bin_op
         && let Some(generic_args) = seg.args
         && let Some(GenericArg::Type(other_ty)) = generic_args.args.last()
-
     {
         Some((item.self_ty, other_ty))
-    }
-    else {
+    } else {
         None
     }
 }
@@ -206,11 +203,9 @@ fn are_equal(cx: &LateContext<'_>, middle_ty: Ty<'_>, hir_ty: &rustc_hir::Ty<'_>
         && let middle_ty_id = item.owner_id.to_def_id()
         && let TyKind::Path(QPath::Resolved(_, path)) = hir_ty.kind
         && let Res::Def(_, hir_ty_id) = path.res
-
     {
         hir_ty_id == middle_ty_id
-    }
-    else {
+    } else {
         false
     }
 }
diff --git a/clippy_lints/src/operators/ptr_eq.rs b/clippy_lints/src/operators/ptr_eq.rs
index 7ae269655c6..9db2e24630a 100644
--- a/clippy_lints/src/operators/ptr_eq.rs
+++ b/clippy_lints/src/operators/ptr_eq.rs
@@ -1,6 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_opt;
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::LateContext;
@@ -35,7 +34,7 @@ pub(super) fn check<'tcx>(
                 "try",
                 format!("std::ptr::eq({left_snip}, {right_snip})"),
                 Applicability::MachineApplicable,
-                );
+            );
         }
     }
 }
diff --git a/clippy_lints/src/option_if_let_else.rs b/clippy_lints/src/option_if_let_else.rs
index b69d374fbfd..6e4e0c98d29 100644
--- a/clippy_lints/src/option_if_let_else.rs
+++ b/clippy_lints/src/option_if_let_else.rs
@@ -4,7 +4,6 @@ use clippy_utils::{
     can_move_expr_to_closure, eager_or_lazy, higher, in_constant, is_else_clause, is_res_lang_ctor, peel_blocks,
     peel_hir_expr_while, CaptureKind,
 };
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::def::Res;
 use rustc_hir::LangItem::{OptionNone, OptionSome, ResultErr, ResultOk};
@@ -130,18 +129,29 @@ fn try_get_option_occurrence<'tcx>(
             .filter_map(|(id, &c)| none_captures.get(id).map(|&c2| (c, c2)))
             .all(|(x, y)| x.is_imm_ref() && y.is_imm_ref())
     {
-        let capture_mut = if bind_annotation == BindingAnnotation::MUT { "mut " } else { "" };
+        let capture_mut = if bind_annotation == BindingAnnotation::MUT {
+            "mut "
+        } else {
+            ""
+        };
         let some_body = peel_blocks(if_then);
         let none_body = peel_blocks(if_else);
-        let method_sugg = if eager_or_lazy::switch_to_eager_eval(cx, none_body) { "map_or" } else { "map_or_else" };
+        let method_sugg = if eager_or_lazy::switch_to_eager_eval(cx, none_body) {
+            "map_or"
+        } else {
+            "map_or_else"
+        };
         let capture_name = id.name.to_ident_string();
         let (as_ref, as_mut) = match &expr.kind {
             ExprKind::AddrOf(_, Mutability::Not, _) => (true, false),
             ExprKind::AddrOf(_, Mutability::Mut, _) => (false, true),
             _ if let Some(mutb) = cx.typeck_results().expr_ty(expr).ref_mutability() => {
                 (mutb == Mutability::Not, mutb == Mutability::Mut)
-            }
-            _ => (bind_annotation == BindingAnnotation::REF, bind_annotation == BindingAnnotation::REF_MUT),
+            },
+            _ => (
+                bind_annotation == BindingAnnotation::REF,
+                bind_annotation == BindingAnnotation::REF_MUT,
+            ),
         };
 
         // Check if captures the closure will need conflict with borrows made in the scrutinee.
@@ -152,10 +162,19 @@ fn try_get_option_occurrence<'tcx>(
                 ExprKind::Field(e, _) | ExprKind::AddrOf(_, _, e) => Some(e),
                 _ => None,
             });
-            if let ExprKind::Path(QPath::Resolved(None, Path { res: Res::Local(local_id), .. })) = e.kind {
-                match some_captures.get(local_id)
-                    .or_else(|| (method_sugg == "map_or_else").then_some(()).and_then(|()| none_captures.get(local_id)))
-                {
+            if let ExprKind::Path(QPath::Resolved(
+                None,
+                Path {
+                    res: Res::Local(local_id),
+                    ..
+                },
+            )) = e.kind
+            {
+                match some_captures.get(local_id).or_else(|| {
+                    (method_sugg == "map_or_else")
+                        .then_some(())
+                        .and_then(|()| none_captures.get(local_id))
+                }) {
                     Some(CaptureKind::Value | CaptureKind::Ref(Mutability::Mut)) => return None,
                     Some(CaptureKind::Ref(Mutability::Not)) if as_mut => return None,
                     Some(CaptureKind::Ref(Mutability::Not)) | None => (),
@@ -183,7 +202,13 @@ fn try_get_option_occurrence<'tcx>(
             ),
             none_expr: format!(
                 "{}{}",
-                if method_sugg == "map_or" || is_argless_call { "" } else if is_result { "|_| " } else { "|| "},
+                if method_sugg == "map_or" || is_argless_call {
+                    ""
+                } else if is_result {
+                    "|_| "
+                } else {
+                    "|| "
+                },
                 Sugg::hir_with_context(cx, none_body, ctxt, "..", &mut app),
             ),
         });
diff --git a/clippy_lints/src/overflow_check_conditional.rs b/clippy_lints/src/overflow_check_conditional.rs
index 36ad6cf5f9b..e661bfbb96c 100644
--- a/clippy_lints/src/overflow_check_conditional.rs
+++ b/clippy_lints/src/overflow_check_conditional.rs
@@ -1,6 +1,5 @@
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::SpanlessEq;
-use if_chain::if_chain;
 use rustc_hir::{BinOpKind, Expr, ExprKind, QPath};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
diff --git a/clippy_lints/src/partialeq_ne_impl.rs b/clippy_lints/src/partialeq_ne_impl.rs
index 105af98f1aa..1b06762415d 100644
--- a/clippy_lints/src/partialeq_ne_impl.rs
+++ b/clippy_lints/src/partialeq_ne_impl.rs
@@ -1,5 +1,4 @@
 use clippy_utils::diagnostics::span_lint_hir;
-use if_chain::if_chain;
 use rustc_hir::{Impl, Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -34,7 +33,11 @@ declare_lint_pass!(PartialEqNeImpl => [PARTIALEQ_NE_IMPL]);
 
 impl<'tcx> LateLintPass<'tcx> for PartialEqNeImpl {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
-        if let ItemKind::Impl(Impl { of_trait: Some(ref trait_ref), items: impl_items, .. }) = item.kind
+        if let ItemKind::Impl(Impl {
+            of_trait: Some(ref trait_ref),
+            items: impl_items,
+            ..
+        }) = item.kind
             && !cx.tcx.has_attr(item.owner_id, sym::automatically_derived)
             && let Some(eq_trait) = cx.tcx.lang_items().eq_trait()
             && trait_ref.path.res.def_id() == eq_trait
diff --git a/clippy_lints/src/pass_by_ref_or_value.rs b/clippy_lints/src/pass_by_ref_or_value.rs
index 3a6f37f01a8..0f025c16ab5 100644
--- a/clippy_lints/src/pass_by_ref_or_value.rs
+++ b/clippy_lints/src/pass_by_ref_or_value.rs
@@ -5,7 +5,6 @@ use clippy_utils::source::snippet;
 use clippy_utils::ty::{for_each_top_level_late_bound_region, is_copy};
 use clippy_utils::{is_self, is_self_ty};
 use core::ops::ControlFlow;
-use if_chain::if_chain;
 use rustc_ast::attr;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Applicability;
@@ -238,7 +237,10 @@ impl<'tcx> PassByRefOrValue {
                             cx,
                             LARGE_TYPES_PASSED_BY_VALUE,
                             input.span,
-                            &format!("this argument ({size} byte) is passed by value, but might be more efficient if passed by reference (limit: {} byte)", self.value_max_size),
+                            &format!(
+                                "this argument ({size} byte) is passed by value, but might be more efficient if passed by reference (limit: {} byte)",
+                                self.value_max_size
+                            ),
                             "consider passing by reference instead",
                             format!("&{}", snippet(cx, input.span, "_")),
                             Applicability::MaybeIncorrect,
diff --git a/clippy_lints/src/precedence.rs b/clippy_lints/src/precedence.rs
index 0aebd9a6df3..b638e83997a 100644
--- a/clippy_lints/src/precedence.rs
+++ b/clippy_lints/src/precedence.rs
@@ -1,6 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
-use if_chain::if_chain;
 use rustc_ast::ast::{BinOpKind, Expr, ExprKind, MethodCall, UnOp};
 use rustc_ast::token;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/question_mark.rs b/clippy_lints/src/question_mark.rs
index 0c01934433a..5c395143b9a 100644
--- a/clippy_lints/src/question_mark.rs
+++ b/clippy_lints/src/question_mark.rs
@@ -10,7 +10,6 @@ use clippy_utils::{
     is_res_lang_ctor, pat_and_expr_can_be_question_mark, path_to_local, path_to_local_id, peel_blocks,
     peel_blocks_with_stmt,
 };
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::def::Res;
 use rustc_hir::LangItem::{self, OptionNone, OptionSome, ResultErr, ResultOk};
@@ -226,8 +225,8 @@ impl QuestionMark {
         {
             let mut applicability = Applicability::MachineApplicable;
             let receiver_str = snippet_with_applicability(cx, caller.span, "..", &mut applicability);
-            let by_ref = !caller_ty.is_copy_modulo_regions(cx.tcx, cx.param_env) &&
-                !matches!(caller.kind, ExprKind::Call(..) | ExprKind::MethodCall(..));
+            let by_ref = !caller_ty.is_copy_modulo_regions(cx.tcx, cx.param_env)
+                && !matches!(caller.kind, ExprKind::Call(..) | ExprKind::MethodCall(..));
             let sugg = if let Some(else_inner) = r#else {
                 if eq_expr_value(cx, caller, peel_blocks(else_inner)) {
                     format!("Some({receiver_str}?)")
@@ -252,7 +251,12 @@ impl QuestionMark {
 
     fn check_if_let_some_or_err_and_early_return<'tcx>(&self, cx: &LateContext<'tcx>, expr: &Expr<'tcx>) {
         if !self.inside_try_block()
-            && let Some(higher::IfLet { let_pat, let_expr, if_then, if_else }) = higher::IfLet::hir(cx, expr)
+            && let Some(higher::IfLet {
+                let_pat,
+                let_expr,
+                if_then,
+                if_else,
+            }) = higher::IfLet::hir(cx, expr)
             && !is_else_clause(cx.tcx, expr)
             && let PatKind::TupleStruct(ref path1, [field], ddpos) = let_pat.kind
             && ddpos.as_opt_usize().is_none()
@@ -264,11 +268,14 @@ impl QuestionMark {
                 ident.name,
                 let_expr,
                 if_then,
-                if_else
+                if_else,
             )
             && ((is_early_return(sym::Option, cx, &if_block) && path_to_local_id(peel_blocks(if_then), bind_id))
                 || is_early_return(sym::Result, cx, &if_block))
-            && if_else.map(|e| eq_expr_value(cx, let_expr, peel_blocks(e))).filter(|e| *e).is_none()
+            && if_else
+                .map(|e| eq_expr_value(cx, let_expr, peel_blocks(e)))
+                .filter(|e| *e)
+                .is_none()
         {
             let mut applicability = Applicability::MachineApplicable;
             let receiver_str = snippet_with_applicability(cx, let_expr.span, "..", &mut applicability);
diff --git a/clippy_lints/src/ranges.rs b/clippy_lints/src/ranges.rs
index f62acc79b03..9bdba994020 100644
--- a/clippy_lints/src/ranges.rs
+++ b/clippy_lints/src/ranges.rs
@@ -4,7 +4,6 @@ use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg, span_lint_and_the
 use clippy_utils::source::{snippet, snippet_opt, snippet_with_applicability};
 use clippy_utils::sugg::Sugg;
 use clippy_utils::{get_parent_expr, higher, in_constant, is_integer_const, path_to_local};
-use if_chain::if_chain;
 use rustc_ast::ast::RangeLimits;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind, HirId};
@@ -350,7 +349,7 @@ fn check_exclusive_range_plus_one(cx: &LateContext<'_>, expr: &Expr<'_>) {
         && let Some(higher::Range {
             start,
             end: Some(end),
-            limits: RangeLimits::HalfOpen
+            limits: RangeLimits::HalfOpen,
         }) = higher::Range::hir(expr)
         && let Some(y) = y_plus_one(cx, end)
     {
@@ -365,12 +364,7 @@ fn check_exclusive_range_plus_one(cx: &LateContext<'_>, expr: &Expr<'_>) {
                 let end = Sugg::hir(cx, y, "y").maybe_par();
                 if let Some(is_wrapped) = &snippet_opt(cx, span) {
                     if is_wrapped.starts_with('(') && is_wrapped.ends_with(')') {
-                        diag.span_suggestion(
-                            span,
-                            "use",
-                            format!("({start}..={end})"),
-                            Applicability::MaybeIncorrect,
-                        );
+                        diag.span_suggestion(span, "use", format!("({start}..={end})"), Applicability::MaybeIncorrect);
                     } else {
                         diag.span_suggestion(
                             span,
@@ -388,7 +382,11 @@ fn check_exclusive_range_plus_one(cx: &LateContext<'_>, expr: &Expr<'_>) {
 // inclusive range minus one: `x..=(y-1)`
 fn check_inclusive_range_minus_one(cx: &LateContext<'_>, expr: &Expr<'_>) {
     if expr.span.can_be_used_for_suggestions()
-        && let Some(higher::Range { start, end: Some(end), limits: RangeLimits::Closed }) = higher::Range::hir(expr)
+        && let Some(higher::Range {
+            start,
+            end: Some(end),
+            limits: RangeLimits::Closed,
+        }) = higher::Range::hir(expr)
         && let Some(y) = y_minus_one(cx, end)
     {
         span_lint_and_then(
@@ -440,7 +438,11 @@ fn check_reversed_empty_range(cx: &LateContext<'_>, expr: &Expr<'_>) {
         }
     }
 
-    if let Some(higher::Range { start: Some(start), end: Some(end), limits }) = higher::Range::hir(expr)
+    if let Some(higher::Range {
+        start: Some(start),
+        end: Some(end),
+        limits,
+    }) = higher::Range::hir(expr)
         && let ty = cx.typeck_results().expr_ty(start)
         && let ty::Int(_) | ty::Uint(_) = ty.kind()
         && let Some(start_idx) = constant(cx, cx.typeck_results(), start)
@@ -471,7 +473,7 @@ fn check_reversed_empty_range(cx: &LateContext<'_>, expr: &Expr<'_>) {
                         let end_snippet = snippet(cx, end.span, "_");
                         let dots = match limits {
                             RangeLimits::HalfOpen => "..",
-                            RangeLimits::Closed => "..="
+                            RangeLimits::Closed => "..=",
                         };
 
                         diag.span_suggestion(
diff --git a/clippy_lints/src/rc_clone_in_vec_init.rs b/clippy_lints/src/rc_clone_in_vec_init.rs
index 7d86252e6c5..b99af44655d 100644
--- a/clippy_lints/src/rc_clone_in_vec_init.rs
+++ b/clippy_lints/src/rc_clone_in_vec_init.rs
@@ -122,13 +122,13 @@ fn ref_init(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<(Symbol, Span)> {
         && let ExprKind::Path(ref func_path @ QPath::TypeRelative(ty, _)) = func.kind
         && let TyKind::Path(ref ty_path) = ty.kind
         && let Some(def_id) = cx.qpath_res(ty_path, ty.hir_id).opt_def_id()
-
     {
         if last_path_segment(func_path).ident.name == sym::new
             && let Some(symbol) = cx
                 .tcx
                 .get_diagnostic_name(def_id)
-                .filter(|symbol| symbol == &sym::Arc || symbol == &sym::Rc) {
+                .filter(|symbol| symbol == &sym::Arc || symbol == &sym::Rc)
+        {
             return Some((symbol, func.span));
         }
 
diff --git a/clippy_lints/src/redundant_clone.rs b/clippy_lints/src/redundant_clone.rs
index ecc5a28519b..88dbf9ef549 100644
--- a/clippy_lints/src/redundant_clone.rs
+++ b/clippy_lints/src/redundant_clone.rs
@@ -3,7 +3,6 @@ use clippy_utils::mir::{visit_local_usage, LocalUsage, PossibleBorrowerMap};
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::{has_drop, is_copy, is_type_diagnostic_item, is_type_lang_item, walk_ptrs_ty_depth};
 use clippy_utils::{fn_has_unsatisfiable_preds, match_def_path, paths};
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::{def_id, Body, FnDecl, LangItem};
@@ -147,7 +146,7 @@ impl<'tcx> LateLintPass<'tcx> for RedundantClone {
 
                 // receiver of the `deref()` call
                 let (pred_arg, deref_clone_ret) = if let Some((pred_fn_def_id, pred_arg, pred_arg_ty, res)) =
-                        is_call_with_ref_arg(cx, mir, &pred_terminator.kind)
+                    is_call_with_ref_arg(cx, mir, &pred_terminator.kind)
                     && res == cloned
                     && cx.tcx.is_diagnostic_item(sym::deref_method, pred_fn_def_id)
                     && (is_type_diagnostic_item(cx, pred_arg_ty, sym::PathBuf)
@@ -213,31 +212,25 @@ impl<'tcx> LateLintPass<'tcx> for RedundantClone {
             if let Some(snip) = snippet_opt(cx, span)
                 && let Some(dot) = snip.rfind('.')
             {
-                let sugg_span = span.with_lo(
-                    span.lo() + BytePos(u32::try_from(dot).unwrap())
-                );
+                let sugg_span = span.with_lo(span.lo() + BytePos(u32::try_from(dot).unwrap()));
                 let mut app = Applicability::MaybeIncorrect;
 
                 let call_snip = &snip[dot + 1..];
                 // Machine applicable when `call_snip` looks like `foobar()`
                 if let Some(call_snip) = call_snip.strip_suffix("()").map(str::trim) {
-                    if call_snip.as_bytes().iter().all(|b| b.is_ascii_alphabetic() || *b == b'_') {
+                    if call_snip
+                        .as_bytes()
+                        .iter()
+                        .all(|b| b.is_ascii_alphabetic() || *b == b'_')
+                    {
                         app = Applicability::MachineApplicable;
                     }
                 }
 
                 span_lint_hir_and_then(cx, REDUNDANT_CLONE, node, sugg_span, "redundant clone", |diag| {
-                    diag.span_suggestion(
-                        sugg_span,
-                        "remove this",
-                        "",
-                        app,
-                    );
+                    diag.span_suggestion(sugg_span, "remove this", "", app);
                     if clone_usage.cloned_used {
-                        diag.span_note(
-                            span,
-                            "cloned value is neither consumed nor mutated",
-                        );
+                        diag.span_note(span, "cloned value is neither consumed nor mutated");
                     } else {
                         diag.span_note(
                             span.with_hi(span.lo() + BytePos(u32::try_from(dot).unwrap())),
@@ -258,7 +251,12 @@ fn is_call_with_ref_arg<'tcx>(
     mir: &'tcx mir::Body<'tcx>,
     kind: &'tcx mir::TerminatorKind<'tcx>,
 ) -> Option<(def_id::DefId, mir::Local, Ty<'tcx>, mir::Local)> {
-    if let mir::TerminatorKind::Call { func, args, destination, .. } = kind
+    if let mir::TerminatorKind::Call {
+        func,
+        args,
+        destination,
+        ..
+    } = kind
         && args.len() == 1
         && let mir::Operand::Move(mir::Place { local, .. }) = &args[0]
         && let ty::FnDef(def_id, _) = *func.ty(mir, cx.tcx).kind()
diff --git a/clippy_lints/src/redundant_closure_call.rs b/clippy_lints/src/redundant_closure_call.rs
index e8906d51e88..f2a006ebdfc 100644
--- a/clippy_lints/src/redundant_closure_call.rs
+++ b/clippy_lints/src/redundant_closure_call.rs
@@ -2,7 +2,6 @@ use crate::rustc_lint::LintContext;
 use clippy_utils::diagnostics::{span_lint, span_lint_and_then};
 use clippy_utils::get_parent_expr;
 use clippy_utils::sugg::Sugg;
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_hir::intravisit as hir_visit;
@@ -141,7 +140,7 @@ impl<'tcx> LateLintPass<'tcx> for RedundantClosureCall {
         }
 
         if let hir::ExprKind::Call(recv, _) = expr.kind
-            // don't lint if the receiver is a call, too. 
+            // don't lint if the receiver is a call, too.
             // we do this in order to prevent linting multiple times; consider:
             // `(|| || 1)()()`
             //           ^^  we only want to lint for this call (but we walk up the calls to consider both calls).
diff --git a/clippy_lints/src/redundant_pub_crate.rs b/clippy_lints/src/redundant_pub_crate.rs
index d25e8c2de03..32e0c3749ab 100644
--- a/clippy_lints/src/redundant_pub_crate.rs
+++ b/clippy_lints/src/redundant_pub_crate.rs
@@ -46,7 +46,8 @@ impl_lint_pass!(RedundantPubCrate => [REDUNDANT_PUB_CRATE]);
 impl<'tcx> LateLintPass<'tcx> for RedundantPubCrate {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
         if cx.tcx.visibility(item.owner_id.def_id) == ty::Visibility::Restricted(CRATE_DEF_ID.to_def_id())
-            && !cx.effective_visibilities.is_exported(item.owner_id.def_id) && self.is_exported.last() == Some(&false)
+            && !cx.effective_visibilities.is_exported(item.owner_id.def_id)
+            && self.is_exported.last() == Some(&false)
             && is_not_macro_export(item)
         {
             let span = item.span.with_hi(item.ident.span.hi());
diff --git a/clippy_lints/src/redundant_slicing.rs b/clippy_lints/src/redundant_slicing.rs
index 48bcd676ab9..c9fc65653c2 100644
--- a/clippy_lints/src/redundant_slicing.rs
+++ b/clippy_lints/src/redundant_slicing.rs
@@ -2,7 +2,6 @@ use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::get_parent_expr;
 use clippy_utils::source::snippet_with_context;
 use clippy_utils::ty::{is_type_lang_item, peel_mid_ty_refs};
-use if_chain::if_chain;
 use rustc_ast::util::parser::PREC_PREFIX;
 use rustc_errors::Applicability;
 use rustc_hir::{BorrowKind, Expr, ExprKind, LangItem, Mutability};
@@ -86,9 +85,7 @@ impl<'tcx> LateLintPass<'tcx> for RedundantSlicing {
             let (expr_ty, expr_ref_count) = peel_mid_ty_refs(cx.typeck_results().expr_ty(expr));
             let (indexed_ty, indexed_ref_count) = peel_mid_ty_refs(cx.typeck_results().expr_ty(indexed));
             let parent_expr = get_parent_expr(cx, expr);
-            let needs_parens_for_prefix = parent_expr.map_or(false, |parent| {
-                parent.precedence().order() > PREC_PREFIX
-            });
+            let needs_parens_for_prefix = parent_expr.map_or(false, |parent| parent.precedence().order() > PREC_PREFIX);
             let mut app = Applicability::MachineApplicable;
 
             let ((lint, msg), help, sugg) = if expr_ty == indexed_ty {
@@ -112,7 +109,10 @@ impl<'tcx> LateLintPass<'tcx> for RedundantSlicing {
                         ..
                     })
                 ) || cx.typeck_results().expr_adjustments(expr).first().map_or(false, |a| {
-                    matches!(a.kind, Adjust::Borrow(AutoBorrow::Ref(_, AutoBorrowMutability::Mut { .. })))
+                    matches!(
+                        a.kind,
+                        Adjust::Borrow(AutoBorrow::Ref(_, AutoBorrowMutability::Mut { .. }))
+                    )
                 }) {
                     // The slice was used to make a temporary reference.
                     (DEREF_BY_SLICING_LINT, "&*", "reborrow the original value instead")
@@ -133,7 +133,7 @@ impl<'tcx> LateLintPass<'tcx> for RedundantSlicing {
             } else if let Some(target_id) = cx.tcx.lang_items().deref_target() {
                 if let Ok(deref_ty) = cx.tcx.try_normalize_erasing_regions(
                     cx.param_env,
-                    Ty::new_projection(cx.tcx,target_id, cx.tcx.mk_args(&[GenericArg::from(indexed_ty)])),
+                    Ty::new_projection(cx.tcx, target_id, cx.tcx.mk_args(&[GenericArg::from(indexed_ty)])),
                 ) {
                     if deref_ty == expr_ty {
                         let snip = snippet_with_context(cx, indexed.span, ctxt, "..", &mut app).0;
@@ -153,15 +153,7 @@ impl<'tcx> LateLintPass<'tcx> for RedundantSlicing {
                 return;
             };
 
-            span_lint_and_sugg(
-                cx,
-                lint,
-                expr.span,
-                msg,
-                help,
-                sugg,
-                app,
-            );
+            span_lint_and_sugg(cx, lint, expr.span, msg, help, sugg, app);
         }
     }
 }
diff --git a/clippy_lints/src/ref_option_ref.rs b/clippy_lints/src/ref_option_ref.rs
index 472cde7cd15..0ba898e75a1 100644
--- a/clippy_lints/src/ref_option_ref.rs
+++ b/clippy_lints/src/ref_option_ref.rs
@@ -1,7 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::last_path_segment;
 use clippy_utils::source::snippet;
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{GenericArg, GenericArgsParentheses, Mutability, Ty, TyKind};
 use rustc_lint::{LateContext, LateLintPass};
@@ -43,9 +42,8 @@ impl<'tcx> LateLintPass<'tcx> for RefOptionRef {
             && let TyKind::Path(ref qpath) = &mut_ty.ty.kind
             && let last = last_path_segment(qpath)
             && let Some(def_id) = last.res.opt_def_id()
-
             && cx.tcx.is_diagnostic_item(sym::Option, def_id)
-            && let Some(params) = last_path_segment(qpath).args 
+            && let Some(params) = last_path_segment(qpath).args
             && params.parenthesized == GenericArgsParentheses::No
             && let Some(inner_ty) = params.args.iter().find_map(|arg| match arg {
                 GenericArg::Type(inner_ty) => Some(inner_ty),
@@ -53,7 +51,6 @@ impl<'tcx> LateLintPass<'tcx> for RefOptionRef {
             })
             && let TyKind::Ref(_, ref inner_mut_ty) = inner_ty.kind
             && inner_mut_ty.mutbl == Mutability::Not
-
         {
             span_lint_and_sugg(
                 cx,
diff --git a/clippy_lints/src/reference.rs b/clippy_lints/src/reference.rs
index 74d2814f91e..69818db7c82 100644
--- a/clippy_lints/src/reference.rs
+++ b/clippy_lints/src/reference.rs
@@ -1,6 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::{snippet_opt, snippet_with_applicability};
-use if_chain::if_chain;
 use rustc_ast::ast::{Expr, ExprKind, Mutability, UnOp};
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass};
@@ -58,12 +57,13 @@ impl EarlyLintPass for DerefAddrOf {
                     // Remove leading whitespace from the given span
                     // e.g: ` $visitor` turns into `$visitor`
                     let trim_leading_whitespaces = |span| {
-                        snippet_opt(cx, span).and_then(|snip| {
-                            #[expect(clippy::cast_possible_truncation)]
-                            snip.find(|c: char| !c.is_whitespace()).map(|pos| {
-                                span.lo() + BytePos(pos as u32)
+                        snippet_opt(cx, span)
+                            .and_then(|snip| {
+                                #[expect(clippy::cast_possible_truncation)]
+                                snip.find(|c: char| !c.is_whitespace())
+                                    .map(|pos| span.lo() + BytePos(pos as u32))
                             })
-                        }).map_or(span, |start_no_whitespace| e.span.with_lo(start_no_whitespace))
+                            .map_or(span, |start_no_whitespace| e.span.with_lo(start_no_whitespace))
                     };
 
                     let mut generate_snippet = |pattern: &str| {
@@ -85,7 +85,12 @@ impl EarlyLintPass for DerefAddrOf {
                     Some(snippet_with_applicability(cx, e.span, "_", &mut applicability))
                 }
             } else {
-                Some(snippet_with_applicability(cx, addrof_target.span, "_", &mut applicability))
+                Some(snippet_with_applicability(
+                    cx,
+                    addrof_target.span,
+                    "_",
+                    &mut applicability,
+                ))
             };
             if let Some(sugg) = sugg {
                 span_lint_and_sugg(
diff --git a/clippy_lints/src/return_self_not_must_use.rs b/clippy_lints/src/return_self_not_must_use.rs
index 8913f4a2e7e..ad22b751bef 100644
--- a/clippy_lints/src/return_self_not_must_use.rs
+++ b/clippy_lints/src/return_self_not_must_use.rs
@@ -86,7 +86,6 @@ fn check_method(cx: &LateContext<'_>, decl: &FnDecl<'_>, fn_def: LocalDefId, spa
         && self_arg.peel_refs() == ret_ty
         // If `Self` is already marked as `#[must_use]`, no need for the attribute here.
         && !is_must_use_ty(cx, ret_ty)
-
     {
         span_lint_and_help(
             cx,
@@ -94,7 +93,7 @@ fn check_method(cx: &LateContext<'_>, decl: &FnDecl<'_>, fn_def: LocalDefId, spa
             span,
             "missing `#[must_use]` attribute on a method returning `Self`",
             None,
-            "consider adding the `#[must_use]` attribute to the method or directly to the `Self` type"
+            "consider adding the `#[must_use]` attribute to the method or directly to the `Self` type",
         );
     }
 }
@@ -115,7 +114,6 @@ impl<'tcx> LateLintPass<'tcx> for ReturnSelfNotMustUse {
             // We don't want this method to be te implementation of a trait because the
             // `#[must_use]` should be put on the trait definition directly.
             && cx.tcx.trait_id_of_impl(impl_def).is_none()
-
         {
             let hir_id = cx.tcx.hir().local_def_id_to_hir_id(fn_def);
             check_method(cx, decl, fn_def, span, hir_id.expect_owner());
diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
index bab20d0e1f6..7468bda02e8 100644
--- a/clippy_lints/src/returns.rs
+++ b/clippy_lints/src/returns.rs
@@ -4,7 +4,6 @@ use clippy_utils::sugg::has_enclosing_paren;
 use clippy_utils::visitors::{for_each_expr_with_closures, Descend};
 use clippy_utils::{fn_def_id, is_from_proc_macro, path_to_local_id, span_find_starting_semi};
 use core::ops::ControlFlow;
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::{
@@ -220,10 +219,7 @@ impl<'tcx> LateLintPass<'tcx> for Return {
                         }
                         err.multipart_suggestion(
                             "return the expression directly",
-                            vec![
-                                (local.span, String::new()),
-                                (retexpr.span, snippet),
-                            ],
+                            vec![(local.span, String::new()), (retexpr.span, snippet)],
                             Applicability::MachineApplicable,
                         );
                     } else {
diff --git a/clippy_lints/src/same_name_method.rs b/clippy_lints/src/same_name_method.rs
index a6ad0b5cc1e..52475ff9ef7 100644
--- a/clippy_lints/src/same_name_method.rs
+++ b/clippy_lints/src/same_name_method.rs
@@ -75,8 +75,9 @@ impl<'tcx> LateLintPass<'tcx> for SameNameMethod {
 
                 match of_trait {
                     Some(trait_ref) => {
-                        let mut methods_in_trait: BTreeSet<Symbol> = if let Some(Node::TraitRef(TraitRef { path, .. })) =
-                                cx.tcx.hir().find(trait_ref.hir_ref_id)
+                        let mut methods_in_trait: BTreeSet<Symbol> = if let Some(Node::TraitRef(TraitRef {
+                            path, ..
+                        })) = cx.tcx.hir().find(trait_ref.hir_ref_id)
                             && let Res::Def(DefKind::Trait, did) = path.res
                         {
                             // FIXME: if
@@ -86,12 +87,10 @@ impl<'tcx> LateLintPass<'tcx> for SameNameMethod {
                             cx.tcx
                                 .associated_items(did)
                                 .in_definition_order()
-                                .filter(|assoc_item| {
-                                    matches!(assoc_item.kind, AssocKind::Fn)
-                                })
+                                .filter(|assoc_item| matches!(assoc_item.kind, AssocKind::Fn))
                                 .map(|assoc_item| assoc_item.name)
                                 .collect()
-                        }else{
+                        } else {
                             BTreeSet::new()
                         };
 
diff --git a/clippy_lints/src/self_named_constructors.rs b/clippy_lints/src/self_named_constructors.rs
index 578188a66af..c1edcf509ef 100644
--- a/clippy_lints/src/self_named_constructors.rs
+++ b/clippy_lints/src/self_named_constructors.rs
@@ -75,8 +75,8 @@ impl<'tcx> LateLintPass<'tcx> for SelfNamedConstructors {
             && let self_id = cx.tcx.hir().local_def_id_to_hir_id(self_local_did)
             && let Some(Node::Item(x)) = cx.tcx.hir().find(self_id)
             && let type_name = x.ident.name.as_str().to_lowercase()
-            && (impl_item.ident.name.as_str() == type_name || impl_item.ident.name.as_str().replace('_', "") == type_name)
-
+            && (impl_item.ident.name.as_str() == type_name
+                || impl_item.ident.name.as_str().replace('_', "") == type_name)
         {
             span_lint(
                 cx,
diff --git a/clippy_lints/src/semicolon_if_nothing_returned.rs b/clippy_lints/src/semicolon_if_nothing_returned.rs
index dc606e90707..3aabcadaa1f 100644
--- a/clippy_lints/src/semicolon_if_nothing_returned.rs
+++ b/clippy_lints/src/semicolon_if_nothing_returned.rs
@@ -1,7 +1,6 @@
 use crate::rustc_lint::LintContext;
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_context;
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Block, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
@@ -44,7 +43,8 @@ impl<'tcx> LateLintPass<'tcx> for SemicolonIfNothingReturned {
             && t_expr.is_unit()
             && let mut app = Applicability::MachineApplicable
             && let snippet = snippet_with_context(cx, expr.span, block.span.ctxt(), "}", &mut app).0
-            && !snippet.ends_with('}') && !snippet.ends_with(';')
+            && !snippet.ends_with('}')
+            && !snippet.ends_with(';')
             && cx.sess().source_map().is_multiline(block.span)
         {
             // filter out the desugared `for` loop
diff --git a/clippy_lints/src/size_of_in_element_count.rs b/clippy_lints/src/size_of_in_element_count.rs
index 2ea9122cfc4..0385f1a98e5 100644
--- a/clippy_lints/src/size_of_in_element_count.rs
+++ b/clippy_lints/src/size_of_in_element_count.rs
@@ -2,7 +2,6 @@
 //! expecting a count of T
 
 use clippy_utils::diagnostics::span_lint_and_help;
-use if_chain::if_chain;
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{self, Ty, TypeAndMut};
@@ -42,7 +41,10 @@ fn get_size_of_ty<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, inverted:
             if !inverted
                 && let ExprKind::Path(ref count_func_qpath) = count_func.kind
                 && let Some(def_id) = cx.qpath_res(count_func_qpath, count_func.hir_id).opt_def_id()
-                && matches!(cx.tcx.get_diagnostic_name(def_id), Some(sym::mem_size_of | sym::mem_size_of_val))
+                && matches!(
+                    cx.tcx.get_diagnostic_name(def_id),
+                    Some(sym::mem_size_of | sym::mem_size_of_val)
+                )
             {
                 cx.typeck_results().node_args(count_func.hir_id).types().next()
             } else {
@@ -130,14 +132,7 @@ impl<'tcx> LateLintPass<'tcx> for SizeOfInElementCount {
             && let Some(ty_used_for_size_of) = get_size_of_ty(cx, count_expr, false)
             && pointee_ty == ty_used_for_size_of
         {
-            span_lint_and_help(
-                cx,
-                SIZE_OF_IN_ELEMENT_COUNT,
-                count_expr.span,
-                LINT_MSG,
-                None,
-                HELP_MSG
-            );
+            span_lint_and_help(cx, SIZE_OF_IN_ELEMENT_COUNT, count_expr.span, LINT_MSG, None, HELP_MSG);
         };
     }
 }
diff --git a/clippy_lints/src/slow_vector_initialization.rs b/clippy_lints/src/slow_vector_initialization.rs
index 7de0beb1292..733da790441 100644
--- a/clippy_lints/src/slow_vector_initialization.rs
+++ b/clippy_lints/src/slow_vector_initialization.rs
@@ -5,7 +5,6 @@ use clippy_utils::{
     get_enclosing_block, is_expr_path_def_path, is_integer_literal, is_path_diagnostic_item, path_to_local,
     path_to_local_id, paths, SpanlessEq,
 };
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_block, walk_expr, walk_stmt, Visitor};
 use rustc_hir::{BindingAnnotation, Block, Expr, ExprKind, HirId, PatKind, Stmt, StmtKind};
@@ -106,7 +105,6 @@ impl<'tcx> LateLintPass<'tcx> for SlowVectorInit {
         if let ExprKind::Assign(left, right, _) = expr.kind
             && let Some(local_id) = path_to_local(left)
             && let Some(size_expr) = Self::as_vec_initializer(cx, right)
-
         {
             let vi = VecAllocation {
                 local_id,
@@ -125,7 +123,6 @@ impl<'tcx> LateLintPass<'tcx> for SlowVectorInit {
             && let PatKind::Binding(BindingAnnotation::MUT, local_id, _, None) = local.pat.kind
             && let Some(init) = local.init
             && let Some(size_expr) = Self::as_vec_initializer(cx, init)
-
         {
             let vi = VecAllocation {
                 local_id,
@@ -243,7 +240,6 @@ impl<'a, 'tcx> VectorInitializationVisitor<'a, 'tcx> {
             && path_to_local_id(self_arg, self.vec_alloc.local_id)
             && path.ident.name == sym!(extend)
             && self.is_repeat_take(extend_arg)
-
         {
             self.slow_expression = Some(InitializationType::Extend(expr));
         }
@@ -283,7 +279,7 @@ impl<'a, 'tcx> VectorInitializationVisitor<'a, 'tcx> {
             if let InitializedSize::Initialized(size_expr) = self.vec_alloc.size_expr {
                 // Check that len expression is equals to `with_capacity` expression
                 return SpanlessEq::new(self.cx).eq_expr(len_arg, size_expr)
-                    || matches!(len_arg.kind, ExprKind::MethodCall(path, ..) if path.ident.as_str() == "capacity")
+                    || matches!(len_arg.kind, ExprKind::MethodCall(path, ..) if path.ident.as_str() == "capacity");
             }
 
             self.vec_alloc.size_expr = InitializedSize::Initialized(len_arg);
diff --git a/clippy_lints/src/strings.rs b/clippy_lints/src/strings.rs
index f4f0d0ac551..baa9750cc01 100644
--- a/clippy_lints/src/strings.rs
+++ b/clippy_lints/src/strings.rs
@@ -5,7 +5,6 @@ use clippy_utils::{
     get_expr_use_or_unification_node, get_parent_expr, is_lint_allowed, is_path_diagnostic_item, method_calls,
     peel_blocks, SpanlessEq,
 };
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::def_id::DefId;
 use rustc_hir::{BinOpKind, BorrowKind, Expr, ExprKind, LangItem, Node, QPath};
@@ -251,7 +250,6 @@ const MAX_LENGTH_BYTE_STRING_LIT: usize = 32;
 declare_lint_pass!(StringLitAsBytes => [STRING_LIT_AS_BYTES, STRING_FROM_UTF8_AS_BYTES]);
 
 impl<'tcx> LateLintPass<'tcx> for StringLitAsBytes {
-    #[expect(clippy::too_many_lines)]
     fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
         use rustc_ast::LitKind;
 
@@ -270,16 +268,11 @@ impl<'tcx> LateLintPass<'tcx> for StringLitAsBytes {
 
             // Check for slicer
             && let ExprKind::Struct(QPath::LangItem(LangItem::Range, ..), _, _) = right.kind
-
         {
             let mut applicability = Applicability::MachineApplicable;
             let string_expression = &expressions[0].0;
 
-            let snippet_app = snippet_with_applicability(
-                cx,
-                string_expression.span, "..",
-                &mut applicability,
-            );
+            let snippet_app = snippet_with_applicability(cx, string_expression.span, "..", &mut applicability);
 
             span_lint_and_sugg(
                 cx,
@@ -288,8 +281,8 @@ impl<'tcx> LateLintPass<'tcx> for StringLitAsBytes {
                 "calling a slice of `as_bytes()` with `from_utf8` should be not necessary",
                 "try",
                 format!("Some(&{snippet_app}[{}])", snippet(cx, right.span, "..")),
-                applicability
-            )
+                applicability,
+            );
         }
 
         if !in_external_macro(cx.sess(), e.span)
@@ -348,7 +341,6 @@ impl<'tcx> LateLintPass<'tcx> for StringLitAsBytes {
             && matches!(path.ident.name.as_str(), "to_owned" | "to_string")
             && let ExprKind::Lit(lit) = &recv.kind
             && let LitKind::Str(lit_content, _) = &lit.node
-
             && lit_content.as_str().is_ascii()
             && lit_content.as_str().len() <= MAX_LENGTH_BYTE_STRING_LIT
             && !recv.span.from_expansion()
diff --git a/clippy_lints/src/strlen_on_c_strings.rs b/clippy_lints/src/strlen_on_c_strings.rs
index 23aa1f76d2d..644664b104d 100644
--- a/clippy_lints/src/strlen_on_c_strings.rs
+++ b/clippy_lints/src/strlen_on_c_strings.rs
@@ -3,7 +3,6 @@ use clippy_utils::source::snippet_with_context;
 use clippy_utils::ty::{is_type_diagnostic_item, is_type_lang_item};
 use clippy_utils::visitors::is_expr_unsafe;
 use clippy_utils::{get_parent_node, match_libc_symbol};
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Block, BlockCheckMode, Expr, ExprKind, LangItem, Node, UnsafeSource};
 use rustc_lint::{LateContext, LateLintPass};
@@ -53,11 +52,10 @@ impl<'tcx> LateLintPass<'tcx> for StrlenOnCStrings {
             let ctxt = expr.span.ctxt();
             let span = match get_parent_node(cx.tcx, expr.hir_id) {
                 Some(Node::Block(&Block {
-                    rules: BlockCheckMode::UnsafeBlock(UnsafeSource::UserProvided), span, ..
-                }))
-                if span.ctxt() == ctxt && !is_expr_unsafe(cx, self_arg) => {
-                    span
-                }
+                    rules: BlockCheckMode::UnsafeBlock(UnsafeSource::UserProvided),
+                    span,
+                    ..
+                })) if span.ctxt() == ctxt && !is_expr_unsafe(cx, self_arg) => span,
                 _ => expr.span,
             };
 
diff --git a/clippy_lints/src/suspicious_doc_comments.rs b/clippy_lints/src/suspicious_doc_comments.rs
index dd799d24ca3..cbd6e745841 100644
--- a/clippy_lints/src/suspicious_doc_comments.rs
+++ b/clippy_lints/src/suspicious_doc_comments.rs
@@ -1,5 +1,4 @@
 use clippy_utils::diagnostics::{multispan_sugg_with_applicability, span_lint_and_then};
-use if_chain::if_chain;
 use rustc_ast::token::CommentKind;
 use rustc_ast::{AttrKind, AttrStyle, Attribute, Item};
 use rustc_errors::Applicability;
@@ -82,7 +81,7 @@ fn collect_doc_comment_replacements(attrs: &[Attribute]) -> Vec<(Span, String)>
             {
                 let sugg = match com_kind {
                     CommentKind::Line => format!("//!{com}"),
-                    CommentKind::Block => format!("/*!{com}*/")
+                    CommentKind::Block => format!("/*!{com}*/"),
                 };
                 Some((attr.span, sugg))
             } else {
diff --git a/clippy_lints/src/suspicious_operation_groupings.rs b/clippy_lints/src/suspicious_operation_groupings.rs
index eff0c8cd561..92de7917871 100644
--- a/clippy_lints/src/suspicious_operation_groupings.rs
+++ b/clippy_lints/src/suspicious_operation_groupings.rs
@@ -2,7 +2,6 @@ use clippy_utils::ast_utils::{eq_id, is_useless_with_eq_exprs, IdentIter};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use core::ops::{Add, AddAssign};
-use if_chain::if_chain;
 use rustc_ast::ast::{BinOpKind, Expr, ExprKind, StmtKind};
 use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Applicability;
@@ -168,19 +167,9 @@ fn check_binops(cx: &EarlyContext<'_>, binops: &[&BinaryOp<'_>]) {
                         return;
                     };
 
-                    if let Some(sugg) = ident_swap_sugg(
-                        cx,
-                        &paired_identifiers,
-                        binop,
-                        changed_loc,
-                        &mut applicability,
-                    ) {
-                        emit_suggestion(
-                            cx,
-                            binop.span,
-                            sugg,
-                            applicability,
-                        );
+                    if let Some(sugg) = ident_swap_sugg(cx, &paired_identifiers, binop, changed_loc, &mut applicability)
+                    {
+                        emit_suggestion(cx, binop.span, sugg, applicability);
                     }
                 }
             },
@@ -210,16 +199,10 @@ fn attempt_to_emit_no_difference_lint(
         let old_right_ident = get_ident(binop.right, expected_loc);
 
         for b in skip_index(binops.iter(), i) {
-            if let (Some(old_ident), Some(new_ident)) =
-                (old_left_ident, get_ident(b.left, expected_loc))
+            if let (Some(old_ident), Some(new_ident)) = (old_left_ident, get_ident(b.left, expected_loc))
                 && old_ident != new_ident
-                && let Some(sugg) = suggestion_with_swapped_ident(
-                    cx,
-                    binop.left,
-                    expected_loc,
-                    new_ident,
-                    &mut applicability,
-                )
+                && let Some(sugg) =
+                    suggestion_with_swapped_ident(cx, binop.left, expected_loc, new_ident, &mut applicability)
             {
                 emit_suggestion(
                     cx,
@@ -230,16 +213,10 @@ fn attempt_to_emit_no_difference_lint(
                 return;
             }
 
-            if let (Some(old_ident), Some(new_ident)) =
-                    (old_right_ident, get_ident(b.right, expected_loc))
+            if let (Some(old_ident), Some(new_ident)) = (old_right_ident, get_ident(b.right, expected_loc))
                 && old_ident != new_ident
-                && let Some(sugg) = suggestion_with_swapped_ident(
-                    cx,
-                    binop.right,
-                    expected_loc,
-                    new_ident,
-                    &mut applicability,
-                )
+                && let Some(sugg) =
+                    suggestion_with_swapped_ident(cx, binop.right, expected_loc, new_ident, &mut applicability)
             {
                 emit_suggestion(
                     cx,
diff --git a/clippy_lints/src/suspicious_trait_impl.rs b/clippy_lints/src/suspicious_trait_impl.rs
index b2badd7b2ac..3244933a124 100644
--- a/clippy_lints/src/suspicious_trait_impl.rs
+++ b/clippy_lints/src/suspicious_trait_impl.rs
@@ -2,7 +2,6 @@ use clippy_utils::diagnostics::span_lint;
 use clippy_utils::visitors::for_each_expr;
 use clippy_utils::{binop_traits, trait_ref_of_method, BINOP_TRAITS, OP_ASSIGN_TRAITS};
 use core::ops::ControlFlow;
-use if_chain::if_chain;
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -84,7 +83,11 @@ impl<'tcx> LateLintPass<'tcx> for SuspiciousImpl {
                 cx,
                 lint,
                 binop.span,
-                &format!("suspicious use of `{}` in `{}` impl", binop.node.as_str(), cx.tcx.item_name(trait_id)),
+                &format!(
+                    "suspicious use of `{}` in `{}` impl",
+                    binop.node.as_str(),
+                    cx.tcx.item_name(trait_id)
+                ),
             );
         }
     }
diff --git a/clippy_lints/src/swap.rs b/clippy_lints/src/swap.rs
index 29f85907f9e..285f2f4f6f9 100644
--- a/clippy_lints/src/swap.rs
+++ b/clippy_lints/src/swap.rs
@@ -3,7 +3,6 @@ use clippy_utils::source::snippet_with_context;
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::{can_mut_borrow_both, eq_expr_value, in_constant, std_or_core};
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Block, Expr, ExprKind, PatKind, QPath, Stmt, StmtKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
@@ -173,7 +172,6 @@ fn check_manual_swap(cx: &LateContext<'_>, block: &Block<'_>) {
             && s3.span.ctxt() == ctxt
             && first.span.ctxt() == ctxt
             && second.span.ctxt() == ctxt
-
         {
             let span = s1.span.to(s3.span);
             generate_swap_warning(cx, lhs1, lhs2, span, false);
diff --git a/clippy_lints/src/to_digit_is_some.rs b/clippy_lints/src/to_digit_is_some.rs
index 6990e7468f8..1dca523a966 100644
--- a/clippy_lints/src/to_digit_is_some.rs
+++ b/clippy_lints/src/to_digit_is_some.rs
@@ -1,7 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::match_def_path;
 use clippy_utils::source::snippet_with_applicability;
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass};
@@ -51,20 +50,24 @@ impl<'tcx> LateLintPass<'tcx> for ToDigitIsSome {
                     } else {
                         None
                     }
-                }
+                },
                 hir::ExprKind::Call(to_digits_call, to_digit_args) => {
                     if let [char_arg, radix_arg] = *to_digit_args
                         && let hir::ExprKind::Path(to_digits_path) = &to_digits_call.kind
                         && let to_digits_call_res = cx.qpath_res(to_digits_path, to_digits_call.hir_id)
                         && let Some(to_digits_def_id) = to_digits_call_res.opt_def_id()
-                        && match_def_path(cx, to_digits_def_id, &["core", "char", "methods", "<impl char>", "to_digit"])
+                        && match_def_path(
+                            cx,
+                            to_digits_def_id,
+                            &["core", "char", "methods", "<impl char>", "to_digit"],
+                        )
                     {
                         Some((false, char_arg, radix_arg))
                     } else {
                         None
                     }
-                }
-                _ => None
+                },
+                _ => None,
             };
 
             if let Some((is_method_call, char_arg, radix_arg)) = match_result {
diff --git a/clippy_lints/src/trait_bounds.rs b/clippy_lints/src/trait_bounds.rs
index 0bcb1afeea2..e624bbe5ff1 100644
--- a/clippy_lints/src/trait_bounds.rs
+++ b/clippy_lints/src/trait_bounds.rs
@@ -3,7 +3,6 @@ use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg};
 use clippy_utils::source::{snippet, snippet_opt, snippet_with_applicability};
 use clippy_utils::{is_from_proc_macro, SpanlessEq, SpanlessHash};
 use core::hash::{Hash, Hasher};
-use if_chain::if_chain;
 use itertools::Itertools;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_data_structures::unhash::UnhashMap;
@@ -129,19 +128,19 @@ impl<'tcx> LateLintPass<'tcx> for TraitBounds {
                 && !bound_predicate.span.from_expansion()
                 && let TyKind::Path(QPath::Resolved(_, Path { segments, .. })) = bound_predicate.bounded_ty.kind
                 && let Some(PathSegment {
-                    res: Res::SelfTyParam { trait_: def_id }, ..
+                    res: Res::SelfTyParam { trait_: def_id },
+                    ..
                 }) = segments.first()
-                && let Some(
-                    Node::Item(
-                        Item {
-                            kind: ItemKind::Trait(_, _, _, self_bounds, _),
-                            .. }
-                        )
-                    ) = cx.tcx.hir().get_if_local(*def_id)
+                && let Some(Node::Item(Item {
+                    kind: ItemKind::Trait(_, _, _, self_bounds, _),
+                    ..
+                })) = cx.tcx.hir().get_if_local(*def_id)
             {
                 if self_bounds_map.is_empty() {
                     for bound in *self_bounds {
-                        let Some((self_res, self_segments, _)) = get_trait_info_from_bound(bound) else { continue };
+                        let Some((self_res, self_segments, _)) = get_trait_info_from_bound(bound) else {
+                            continue;
+                        };
                         self_bounds_map.insert(self_res, self_segments);
                     }
                 }
@@ -173,7 +172,6 @@ impl<'tcx> LateLintPass<'tcx> for TraitBounds {
             && let TyKind::TraitObject(bounds, ..) = mut_ty.ty.kind
             && bounds.len() > 2
         {
-
             // Build up a hash of every trait we've seen
             // When we see a trait for the first time, add it to unique_traits
             // so we can later use it to build a string of all traits exactly once, without duplicates
@@ -184,7 +182,9 @@ impl<'tcx> LateLintPass<'tcx> for TraitBounds {
             // Iterate the bounds and add them to our seen hash
             // If we haven't yet seen it, add it to the fixed traits
             for bound in bounds {
-                let Some(def_id) = bound.trait_ref.trait_def_id() else { continue; };
+                let Some(def_id) = bound.trait_ref.trait_def_id() else {
+                    continue;
+                };
 
                 let new_trait = seen_def_ids.insert(def_id);
 
@@ -267,7 +267,11 @@ impl TraitBounds {
                 && p.origin != PredicateOrigin::ImplTrait
                 && p.bounds.len() as u64 <= self.max_trait_bounds
                 && !p.span.from_expansion()
-                && let bounds = p.bounds.iter().filter(|b| !self.cannot_combine_maybe_bound(cx, b)).collect::<Vec<_>>()
+                && let bounds = p
+                    .bounds
+                    .iter()
+                    .filter(|b| !self.cannot_combine_maybe_bound(cx, b))
+                    .collect::<Vec<_>>()
                 && !bounds.is_empty()
                 && let Some(ref v) = map.insert(SpanlessTy { ty: p.bounded_ty, cx }, bounds)
                 && !is_from_proc_macro(cx, p.bounded_ty)
@@ -314,11 +318,17 @@ fn check_trait_bound_duplication(cx: &LateContext<'_>, gen: &'_ Generics<'_>) {
         .filter_map(|pred| {
             if pred.in_where_clause()
                 && let WherePredicate::BoundPredicate(bound_predicate) = pred
-                && let TyKind::Path(QPath::Resolved(_, path)) =  bound_predicate.bounded_ty.kind
+                && let TyKind::Path(QPath::Resolved(_, path)) = bound_predicate.bounded_ty.kind
             {
                 return Some(
-                    rollup_traits(cx, bound_predicate.bounds, "these where clauses contain repeated elements")
-                    .into_iter().map(|(trait_ref, _)| (path.res, trait_ref)))
+                    rollup_traits(
+                        cx,
+                        bound_predicate.bounds,
+                        "these where clauses contain repeated elements",
+                    )
+                    .into_iter()
+                    .map(|(trait_ref, _)| (path.res, trait_ref)),
+                );
             }
             None
         })
@@ -335,7 +345,7 @@ fn check_trait_bound_duplication(cx: &LateContext<'_>, gen: &'_ Generics<'_>) {
         if let WherePredicate::BoundPredicate(bound_predicate) = predicate
             && bound_predicate.origin != PredicateOrigin::ImplTrait
             && !bound_predicate.span.from_expansion()
-            && let TyKind::Path(QPath::Resolved(_, path)) =  bound_predicate.bounded_ty.kind
+            && let TyKind::Path(QPath::Resolved(_, path)) = bound_predicate.bounded_ty.kind
         {
             let traits = rollup_traits(cx, bound_predicate.bounds, "these bounds contain repeated elements");
             for (trait_ref, span) in traits {
@@ -393,7 +403,9 @@ fn into_comparable_trait_ref(trait_ref: &TraitRef<'_>) -> ComparableTraitRef {
                 Some(segment.args?.args.iter().filter_map(|arg| {
                     if let GenericArg::Type(ty) = arg
                         && let TyKind::Path(QPath::Resolved(_, path)) = ty.kind
-                    { return Some(path.res) }
+                    {
+                        return Some(path.res);
+                    }
                     None
                 }))
             })
@@ -432,12 +444,11 @@ fn rollup_traits(cx: &LateContext<'_>, bounds: &[GenericBound<'_>], msg: &str) -
         comparable_bounds[i] = (k, v);
     }
 
-    if repeated_res
-        && let [first_trait, .., last_trait] = bounds
-    {
+    if repeated_res && let [first_trait, .., last_trait] = bounds {
         let all_trait_span = first_trait.span().to(last_trait.span());
 
-        let traits = comparable_bounds.iter()
+        let traits = comparable_bounds
+            .iter()
             .filter_map(|&(_, span)| snippet_opt(cx, span))
             .collect::<Vec<_>>();
         let traits = traits.join(" + ");
@@ -449,7 +460,7 @@ fn rollup_traits(cx: &LateContext<'_>, bounds: &[GenericBound<'_>], msg: &str) -
             msg,
             "try",
             traits,
-            Applicability::MachineApplicable
+            Applicability::MachineApplicable,
         );
     }
 
diff --git a/clippy_lints/src/transmute/mod.rs b/clippy_lints/src/transmute/mod.rs
index 89580005c52..a3a50acb609 100644
--- a/clippy_lints/src/transmute/mod.rs
+++ b/clippy_lints/src/transmute/mod.rs
@@ -19,7 +19,6 @@ mod wrong_transmute;
 
 use clippy_config::msrvs::Msrv;
 use clippy_utils::in_constant;
-use if_chain::if_chain;
 use rustc_hir::{Expr, ExprKind, QPath};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
@@ -530,10 +529,8 @@ impl<'tcx> LateLintPass<'tcx> for Transmute {
                 | transmute_int_to_non_zero::check(cx, e, from_ty, to_ty, arg)
                 | transmute_float_to_int::check(cx, e, from_ty, to_ty, arg, const_context)
                 | transmute_num_to_bytes::check(cx, e, from_ty, to_ty, arg, const_context)
-                | (
-                    unsound_collection_transmute::check(cx, e, from_ty, to_ty)
-                    || transmute_undefined_repr::check(cx, e, from_ty, to_ty)
-                );
+                | (unsound_collection_transmute::check(cx, e, from_ty, to_ty)
+                    || transmute_undefined_repr::check(cx, e, from_ty, to_ty));
 
             if !linted {
                 transmutes_expressible_as_ptr_casts::check(cx, e, from_ty, from_ty_adjusted, to_ty, arg);
diff --git a/clippy_lints/src/transmute/transmute_float_to_int.rs b/clippy_lints/src/transmute/transmute_float_to_int.rs
index fe30a585da0..aef520923e4 100644
--- a/clippy_lints/src/transmute/transmute_float_to_int.rs
+++ b/clippy_lints/src/transmute/transmute_float_to_int.rs
@@ -1,7 +1,6 @@
 use super::TRANSMUTE_FLOAT_TO_INT;
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::sugg;
-use if_chain::if_chain;
 use rustc_ast as ast;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, UnOp};
@@ -40,7 +39,7 @@ pub(super) fn check<'tcx>(
                         let op = format!("{sugg}{}", float_ty.name_str()).into();
                         match sugg {
                             sugg::Sugg::MaybeParen(_) => sugg = sugg::Sugg::MaybeParen(op),
-                            _ => sugg = sugg::Sugg::NonParen(op)
+                            _ => sugg = sugg::Sugg::NonParen(op),
                         }
                     }
 
diff --git a/clippy_lints/src/transmute/transmute_ref_to_ref.rs b/clippy_lints/src/transmute/transmute_ref_to_ref.rs
index 52bb68845db..98e9ea2d775 100644
--- a/clippy_lints/src/transmute/transmute_ref_to_ref.rs
+++ b/clippy_lints/src/transmute/transmute_ref_to_ref.rs
@@ -2,7 +2,6 @@ use super::{TRANSMUTE_BYTES_TO_STR, TRANSMUTE_PTR_TO_PTR};
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::snippet;
 use clippy_utils::sugg;
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, Mutability};
 use rustc_lint::LateContext;
@@ -26,11 +25,7 @@ pub(super) fn check<'tcx>(
             && let ty::Uint(ty::UintTy::U8) = slice_ty.kind()
             && from_mutbl == to_mutbl
         {
-            let postfix = if *from_mutbl == Mutability::Mut {
-                "_mut"
-            } else {
-                ""
-            };
+            let postfix = if *from_mutbl == Mutability::Mut { "_mut" } else { "" };
 
             let snippet = snippet(cx, arg.span, "..");
 
@@ -48,39 +43,36 @@ pub(super) fn check<'tcx>(
                 Applicability::MaybeIncorrect,
             );
             triggered = true;
-        } else {
-            if (cx.tcx.erase_regions(from_ty) != cx.tcx.erase_regions(to_ty))
-                && !const_context {
-                span_lint_and_then(
-                    cx,
-                    TRANSMUTE_PTR_TO_PTR,
-                    e.span,
-                    "transmute from a reference to a reference",
-                    |diag| if let Some(arg) = sugg::Sugg::hir_opt(cx, arg) {
+        } else if (cx.tcx.erase_regions(from_ty) != cx.tcx.erase_regions(to_ty)) && !const_context {
+            span_lint_and_then(
+                cx,
+                TRANSMUTE_PTR_TO_PTR,
+                e.span,
+                "transmute from a reference to a reference",
+                |diag| {
+                    if let Some(arg) = sugg::Sugg::hir_opt(cx, arg) {
                         let ty_from_and_mut = ty::TypeAndMut {
                             ty: *ty_from,
-                            mutbl: *from_mutbl
+                            mutbl: *from_mutbl,
+                        };
+                        let ty_to_and_mut = ty::TypeAndMut {
+                            ty: *ty_to,
+                            mutbl: *to_mutbl,
                         };
-                        let ty_to_and_mut = ty::TypeAndMut { ty: *ty_to, mutbl: *to_mutbl };
                         let sugg_paren = arg
-                            .as_ty(Ty::new_ptr(cx.tcx,ty_from_and_mut))
-                            .as_ty(Ty::new_ptr(cx.tcx,ty_to_and_mut));
+                            .as_ty(Ty::new_ptr(cx.tcx, ty_from_and_mut))
+                            .as_ty(Ty::new_ptr(cx.tcx, ty_to_and_mut));
                         let sugg = if *to_mutbl == Mutability::Mut {
                             sugg_paren.mut_addr_deref()
                         } else {
                             sugg_paren.addr_deref()
                         };
-                        diag.span_suggestion(
-                            e.span,
-                            "try",
-                            sugg,
-                            Applicability::Unspecified,
-                        );
-                    },
-                );
+                        diag.span_suggestion(e.span, "try", sugg, Applicability::Unspecified);
+                    }
+                },
+            );
 
-                triggered = true;
-            }
+            triggered = true;
         }
     }
 
diff --git a/clippy_lints/src/types/borrowed_box.rs b/clippy_lints/src/types/borrowed_box.rs
index a67431123ad..801e8862619 100644
--- a/clippy_lints/src/types/borrowed_box.rs
+++ b/clippy_lints/src/types/borrowed_box.rs
@@ -1,6 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet;
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{
     self as hir, GenericArg, GenericBounds, GenericParamKind, HirId, Lifetime, MutTy, Mutability, Node, QPath, TyKind,
diff --git a/clippy_lints/src/types/box_collection.rs b/clippy_lints/src/types/box_collection.rs
index badd8acbc90..fc3420af020 100644
--- a/clippy_lints/src/types/box_collection.rs
+++ b/clippy_lints/src/types/box_collection.rs
@@ -21,11 +21,9 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_
             cx,
             BOX_COLLECTION,
             hir_ty.span,
-            &format!(
-                "you seem to be trying to use `Box<{box_content}>`. Consider using just `{box_content}`"),
+            &format!("you seem to be trying to use `Box<{box_content}>`. Consider using just `{box_content}`"),
             None,
-            &format!(
-                "`{box_content}` is already on the heap, `Box<{box_content}>` makes an extra allocation")
+            &format!("`{box_content}` is already on the heap, `Box<{box_content}>` makes an extra allocation"),
         );
         true
     } else {
diff --git a/clippy_lints/src/types/option_option.rs b/clippy_lints/src/types/option_option.rs
index 98284031344..d12d14f2b14 100644
--- a/clippy_lints/src/types/option_option.rs
+++ b/clippy_lints/src/types/option_option.rs
@@ -1,6 +1,5 @@
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::{path_def_id, qpath_generic_tys};
-use if_chain::if_chain;
 use rustc_hir::def_id::DefId;
 use rustc_hir::{self as hir, QPath};
 use rustc_lint::LateContext;
diff --git a/clippy_lints/src/types/rc_mutex.rs b/clippy_lints/src/types/rc_mutex.rs
index 1ab4d233ff7..afc31921704 100644
--- a/clippy_lints/src/types/rc_mutex.rs
+++ b/clippy_lints/src/types/rc_mutex.rs
@@ -1,6 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::{path_def_id, qpath_generic_tys};
-use if_chain::if_chain;
 use rustc_hir::def_id::DefId;
 use rustc_hir::{self as hir, QPath};
 use rustc_lint::LateContext;
@@ -9,7 +8,7 @@ use rustc_span::symbol::sym;
 use super::RC_MUTEX;
 
 pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_>, def_id: DefId) -> bool {
-    if cx.tcx.is_diagnostic_item(sym::Rc, def_id) 
+    if cx.tcx.is_diagnostic_item(sym::Rc, def_id)
         && let Some(arg) = qpath_generic_tys(qpath).next()
         && let Some(id) = path_def_id(cx, arg)
         && cx.tcx.is_diagnostic_item(sym::Mutex, id)
diff --git a/clippy_lints/src/types/utils.rs b/clippy_lints/src/types/utils.rs
index 7278447a70e..b1aa1ab4566 100644
--- a/clippy_lints/src/types/utils.rs
+++ b/clippy_lints/src/types/utils.rs
@@ -1,5 +1,4 @@
 use clippy_utils::last_path_segment;
-use if_chain::if_chain;
 use rustc_hir::{GenericArg, GenericArgsParentheses, QPath, TyKind};
 use rustc_lint::LateContext;
 use rustc_span::source_map::Span;
diff --git a/clippy_lints/src/uninit_vec.rs b/clippy_lints/src/uninit_vec.rs
index ff616805d08..a7119434517 100644
--- a/clippy_lints/src/uninit_vec.rs
+++ b/clippy_lints/src/uninit_vec.rs
@@ -161,7 +161,7 @@ fn extract_init_or_reserve_target<'tcx>(cx: &LateContext<'tcx>, stmt: &'tcx Stmt
                 return Some(TargetVec {
                     location: VecLocation::Local(hir_id),
                     init_kind: Some(init_kind),
-                })
+                });
             }
         },
         StmtKind::Expr(expr) | StmtKind::Semi(expr) => match expr.kind {
diff --git a/clippy_lints/src/unit_return_expecting_ord.rs b/clippy_lints/src/unit_return_expecting_ord.rs
index 8145c4e5108..385f8255a39 100644
--- a/clippy_lints/src/unit_return_expecting_ord.rs
+++ b/clippy_lints/src/unit_return_expecting_ord.rs
@@ -1,5 +1,4 @@
 use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
-use if_chain::if_chain;
 use rustc_hir::def_id::DefId;
 use rustc_hir::{Closure, Expr, ExprKind, StmtKind};
 use rustc_lint::{LateContext, LateLintPass};
@@ -128,7 +127,7 @@ fn check_arg<'tcx>(cx: &LateContext<'tcx>, arg: &'tcx Expr<'tcx>) -> Option<(Spa
         {
             let data = stmt.span.data();
             // Make a span out of the semicolon for the help message
-            Some((fn_decl_span, Some(data.with_lo(data.hi-BytePos(1)))))
+            Some((fn_decl_span, Some(data.with_lo(data.hi - BytePos(1)))))
         } else {
             Some((fn_decl_span, None))
         }
diff --git a/clippy_lints/src/unit_types/unit_arg.rs b/clippy_lints/src/unit_types/unit_arg.rs
index 76d07f77f46..44cff78a793 100644
--- a/clippy_lints/src/unit_types/unit_arg.rs
+++ b/clippy_lints/src/unit_types/unit_arg.rs
@@ -1,7 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::is_from_proc_macro;
 use clippy_utils::source::{indent_of, reindent_multiline, snippet_opt};
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{self as hir, Block, Expr, ExprKind, MatchSource, Node, StmtKind};
 use rustc_lint::LateContext;
@@ -84,12 +83,8 @@ fn lint_unit_args(cx: &LateContext<'_>, expr: &Expr<'_>, args_to_recover: &[&Exp
                         && let StmtKind::Semi(last_expr) = last_stmt.kind
                         && let Some(snip) = snippet_opt(cx, last_expr.span)
                     {
-                        Some((
-                            last_stmt.span,
-                            snip,
-                        ))
-                    }
-                    else {
+                        Some((last_stmt.span, snip))
+                    } else {
                         None
                     }
                 })
diff --git a/clippy_lints/src/unnamed_address.rs b/clippy_lints/src/unnamed_address.rs
index bc217ac2906..2223cbcb060 100644
--- a/clippy_lints/src/unnamed_address.rs
+++ b/clippy_lints/src/unnamed_address.rs
@@ -1,5 +1,4 @@
 use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
-use if_chain::if_chain;
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
@@ -78,7 +77,8 @@ impl LateLintPass<'_> for UnnamedAddress {
 
         if let ExprKind::Binary(binop, left, right) = expr.kind
             && is_comparison(binop.node)
-            && is_trait_ptr(cx, left) && is_trait_ptr(cx, right)
+            && is_trait_ptr(cx, left)
+            && is_trait_ptr(cx, right)
         {
             span_lint_and_help(
                 cx,
diff --git a/clippy_lints/src/unnecessary_owned_empty_strings.rs b/clippy_lints/src/unnecessary_owned_empty_strings.rs
index 70c276fe1ce..14694bb3a28 100644
--- a/clippy_lints/src/unnecessary_owned_empty_strings.rs
+++ b/clippy_lints/src/unnecessary_owned_empty_strings.rs
@@ -1,7 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::ty::is_type_lang_item;
 use clippy_utils::{match_def_path, paths};
-use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::{BorrowKind, Expr, ExprKind, LangItem, Mutability};
@@ -44,34 +43,32 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryOwnedEmptyStrings {
             && inner_str.is_str()
         {
             if match_def_path(cx, fun_def_id, &paths::STRING_NEW) {
-                 span_lint_and_sugg(
-                        cx,
-                        UNNECESSARY_OWNED_EMPTY_STRINGS,
-                        expr.span,
-                        "usage of `&String::new()` for a function expecting a `&str` argument",
-                        "try",
-                        "\"\"".to_owned(),
-                        Applicability::MachineApplicable,
-                    );
-            } else {
-                if cx.tcx.is_diagnostic_item(sym::from_fn, fun_def_id)
-                    && let [.., last_arg] = args
-                    && let ExprKind::Lit(spanned) = &last_arg.kind
-                    && let LitKind::Str(symbol, _) = spanned.node
-                    && symbol.is_empty()
-                    && let inner_expr_type = cx.typeck_results().expr_ty(inner_expr)
-                    && is_type_lang_item(cx, inner_expr_type, LangItem::String)
-                {
-                    span_lint_and_sugg(
-                        cx,
-                        UNNECESSARY_OWNED_EMPTY_STRINGS,
-                        expr.span,
-                        "usage of `&String::from(\"\")` for a function expecting a `&str` argument",
-                        "try",
-                        "\"\"".to_owned(),
-                        Applicability::MachineApplicable,
-                    );
-                }
+                span_lint_and_sugg(
+                    cx,
+                    UNNECESSARY_OWNED_EMPTY_STRINGS,
+                    expr.span,
+                    "usage of `&String::new()` for a function expecting a `&str` argument",
+                    "try",
+                    "\"\"".to_owned(),
+                    Applicability::MachineApplicable,
+                );
+            } else if cx.tcx.is_diagnostic_item(sym::from_fn, fun_def_id)
+                && let [.., last_arg] = args
+                && let ExprKind::Lit(spanned) = &last_arg.kind
+                && let LitKind::Str(symbol, _) = spanned.node
+                && symbol.is_empty()
+                && let inner_expr_type = cx.typeck_results().expr_ty(inner_expr)
+                && is_type_lang_item(cx, inner_expr_type, LangItem::String)
+            {
+                span_lint_and_sugg(
+                    cx,
+                    UNNECESSARY_OWNED_EMPTY_STRINGS,
+                    expr.span,
+                    "usage of `&String::from(\"\")` for a function expecting a `&str` argument",
+                    "try",
+                    "\"\"".to_owned(),
+                    Applicability::MachineApplicable,
+                );
             }
         }
     }
diff --git a/clippy_lints/src/unnecessary_self_imports.rs b/clippy_lints/src/unnecessary_self_imports.rs
index 338a4daf6c1..1e2b20469ef 100644
--- a/clippy_lints/src/unnecessary_self_imports.rs
+++ b/clippy_lints/src/unnecessary_self_imports.rs
@@ -1,5 +1,4 @@
 use clippy_utils::diagnostics::span_lint_and_then;
-use if_chain::if_chain;
 use rustc_ast::{Item, ItemKind, UseTreeKind};
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass};
@@ -42,7 +41,6 @@ impl EarlyLintPass for UnnecessarySelfImports {
             && let [self_seg] = &*self_tree.prefix.segments
             && self_seg.ident.name == kw::SelfLower
             && let Some(last_segment) = use_tree.prefix.segments.last()
-
         {
             span_lint_and_then(
                 cx,
@@ -56,7 +54,11 @@ impl EarlyLintPass for UnnecessarySelfImports {
                         format!(
                             "{}{};",
                             last_segment.ident,
-                            if let UseTreeKind::Simple(Some(alias)) = self_tree.kind { format!(" as {alias}") } else { String::new() },
+                            if let UseTreeKind::Simple(Some(alias)) = self_tree.kind {
+                                format!(" as {alias}")
+                            } else {
+                                String::new()
+                            },
                         ),
                         Applicability::MaybeIncorrect,
                     );
diff --git a/clippy_lints/src/unnecessary_wraps.rs b/clippy_lints/src/unnecessary_wraps.rs
index 8b1d9d4a739..5599a9dc4e8 100644
--- a/clippy_lints/src/unnecessary_wraps.rs
+++ b/clippy_lints/src/unnecessary_wraps.rs
@@ -2,7 +2,6 @@ use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet;
 use clippy_utils::visitors::find_all_ret_expressions;
 use clippy_utils::{contains_return, is_res_lang_ctor, path_res, return_ty};
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::LangItem::{OptionSome, ResultOk};
@@ -126,16 +125,14 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryWraps {
                 // Make sure the function argument does not contain a return expression.
                 && !contains_return(arg)
             {
-                suggs.push(
-                    (
-                        ret_expr.span,
-                        if inner_type.is_unit() {
-                            String::new()
-                        } else {
-                            snippet(cx, arg.span.source_callsite(), "..").to_string()
-                        }
-                    )
-                );
+                suggs.push((
+                    ret_expr.span,
+                    if inner_type.is_unit() {
+                        String::new()
+                    } else {
+                        snippet(cx, arg.span.source_callsite(), "..").to_string()
+                    },
+                ));
                 true
             } else {
                 false
diff --git a/clippy_lints/src/unused_self.rs b/clippy_lints/src/unused_self.rs
index 1ecce18c9ae..532207310bc 100644
--- a/clippy_lints/src/unused_self.rs
+++ b/clippy_lints/src/unused_self.rs
@@ -1,7 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::macros::root_macro_call_first_node;
 use clippy_utils::visitors::is_local_used;
-use if_chain::if_chain;
 use rustc_hir::{Body, Impl, ImplItem, ImplItemKind, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
diff --git a/clippy_lints/src/unused_unit.rs b/clippy_lints/src/unused_unit.rs
index 7ceb6df9c44..633040f2633 100644
--- a/clippy_lints/src/unused_unit.rs
+++ b/clippy_lints/src/unused_unit.rs
@@ -1,6 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::{position_before_rarrow, snippet_opt};
-use if_chain::if_chain;
 use rustc_ast::visit::FnKind;
 use rustc_ast::{ast, ClosureBinder};
 use rustc_errors::Applicability;
@@ -40,7 +39,9 @@ impl EarlyLintPass for UnusedUnit {
     fn check_fn(&mut self, cx: &EarlyContext<'_>, kind: FnKind<'_>, span: Span, _: ast::NodeId) {
         if let ast::FnRetTy::Ty(ref ty) = kind.decl().output
             && let ast::TyKind::Tup(ref vals) = ty.kind
-            && vals.is_empty() && !ty.span.from_expansion() && get_def(span) == get_def(ty.span)
+            && vals.is_empty()
+            && !ty.span.from_expansion()
+            && get_def(span) == get_def(ty.span)
         {
             // implicit types in closure signatures are forbidden when `for<...>` is present
             if let FnKind::Closure(&ClosureBinder::For { .. }, ..) = kind {
@@ -56,7 +57,8 @@ impl EarlyLintPass for UnusedUnit {
             && let ast::StmtKind::Expr(ref expr) = stmt.kind
             && is_unit_expr(expr)
             && let ctxt = block.span.ctxt()
-            && stmt.span.ctxt() == ctxt && expr.span.ctxt() == ctxt
+            && stmt.span.ctxt() == ctxt
+            && expr.span.ctxt() == ctxt
         {
             let sp = expr.span;
             span_lint_and_sugg(
diff --git a/clippy_lints/src/unwrap.rs b/clippy_lints/src/unwrap.rs
index 8b7429d8e38..5e5b1ab38e0 100644
--- a/clippy_lints/src/unwrap.rs
+++ b/clippy_lints/src/unwrap.rs
@@ -2,7 +2,6 @@ use clippy_utils::diagnostics::span_lint_hir_and_then;
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::usage::is_potentially_local_place;
 use clippy_utils::{higher, path_to_local};
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_expr, walk_fn, FnKind, Visitor};
 use rustc_hir::{BinOpKind, Body, Expr, ExprKind, FnDecl, HirId, Node, PathSegment, UnOp};
@@ -156,39 +155,35 @@ fn collect_unwrap_info<'tcx>(
         }
     } else if let ExprKind::Unary(UnOp::Not, expr) = &expr.kind {
         return collect_unwrap_info(cx, if_expr, expr, branch, !invert, false);
-    } else {
-        if let ExprKind::MethodCall(method_name, receiver, args, _) = &expr.kind
-            && let Some(local_id) = path_to_local(receiver)
-            && let ty = cx.typeck_results().expr_ty(receiver)
-            && let name = method_name.ident.as_str()
-            && (is_relevant_option_call(cx, ty, name) || is_relevant_result_call(cx, ty, name))
-        {
-            assert!(args.is_empty());
-            let unwrappable = match name {
-                "is_some" | "is_ok" => true,
-                "is_err" | "is_none" => false,
-                _ => unreachable!(),
-            };
-            let safe_to_unwrap = unwrappable != invert;
-            let kind = if is_type_diagnostic_item(cx, ty, sym::Option) {
-                UnwrappableKind::Option
-            } else {
-                UnwrappableKind::Result
-            };
+    } else if let ExprKind::MethodCall(method_name, receiver, args, _) = &expr.kind
+        && let Some(local_id) = path_to_local(receiver)
+        && let ty = cx.typeck_results().expr_ty(receiver)
+        && let name = method_name.ident.as_str()
+        && (is_relevant_option_call(cx, ty, name) || is_relevant_result_call(cx, ty, name))
+    {
+        assert!(args.is_empty());
+        let unwrappable = match name {
+            "is_some" | "is_ok" => true,
+            "is_err" | "is_none" => false,
+            _ => unreachable!(),
+        };
+        let safe_to_unwrap = unwrappable != invert;
+        let kind = if is_type_diagnostic_item(cx, ty, sym::Option) {
+            UnwrappableKind::Option
+        } else {
+            UnwrappableKind::Result
+        };
 
-            return vec![
-                UnwrapInfo {
-                    local_id,
-                    if_expr,
-                    check: expr,
-                    check_name: method_name,
-                    branch,
-                    safe_to_unwrap,
-                    kind,
-                    is_entire_condition,
-                }
-            ]
-        }
+        return vec![UnwrapInfo {
+            local_id,
+            if_expr,
+            check: expr,
+            check_name: method_name,
+            branch,
+            safe_to_unwrap,
+            kind,
+            is_entire_condition,
+        }];
     }
     Vec::new()
 }
@@ -379,9 +374,10 @@ impl<'a, 'tcx> Visitor<'tcx> for UnwrappableVariablesVisitor<'a, 'tcx> {
                         PANICKING_UNWRAP,
                         expr.hir_id,
                         expr.span,
-                        &format!("this call to `{}()` will always panic",
-                        method_name.ident.name),
-                        |diag| { diag.span_label(unwrappable.check.span, "because of this check"); },
+                        &format!("this call to `{}()` will always panic", method_name.ident.name),
+                        |diag| {
+                            diag.span_label(unwrappable.check.span, "because of this check");
+                        },
                     );
                 }
             }
diff --git a/clippy_lints/src/unwrap_in_result.rs b/clippy_lints/src/unwrap_in_result.rs
index a3977f1b6c8..df4b42133f8 100644
--- a/clippy_lints/src/unwrap_in_result.rs
+++ b/clippy_lints/src/unwrap_in_result.rs
@@ -3,7 +3,6 @@ use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::visitors::for_each_expr;
 use clippy_utils::{method_chain_args, return_ty};
 use core::ops::ControlFlow;
-use if_chain::if_chain;
 use rustc_hir as hir;
 use rustc_hir::ImplItemKind;
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/use_self.rs b/clippy_lints/src/use_self.rs
index 4bfd4d22c70..f058fe5f831 100644
--- a/clippy_lints/src/use_self.rs
+++ b/clippy_lints/src/use_self.rs
@@ -2,7 +2,6 @@ use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::is_from_proc_macro;
 use clippy_utils::ty::same_type_and_consts;
-use if_chain::if_chain;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Applicability;
 use rustc_hir::def::{CtorOf, DefKind, Res};
@@ -93,23 +92,33 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
         // relevant for linting, since this is the self type of the `impl` we're currently in. To
         // avoid linting on nested items, we push `StackItem::NoCheck` on the stack to signal, that
         // we're in an `impl` or nested item, that we don't want to lint
-        let stack_item = if let ItemKind::Impl(Impl { self_ty, generics,.. }) = item.kind
+        let stack_item = if let ItemKind::Impl(Impl { self_ty, generics, .. }) = item.kind
             && let TyKind::Path(QPath::Resolved(_, item_path)) = self_ty.kind
             && let parameters = &item_path.segments.last().expect(SEGMENTS_MSG).args
             && parameters.as_ref().map_or(true, |params| {
-                params.parenthesized  == GenericArgsParentheses::No
+                params.parenthesized == GenericArgsParentheses::No
                     && !params.args.iter().any(|arg| matches!(arg, GenericArg::Lifetime(_)))
             })
             && !item.span.from_expansion()
-            && !is_from_proc_macro(cx, item) // expensive, should be last check
+            && !is_from_proc_macro(cx, item)
+        // expensive, should be last check
         {
             // Self cannot be used inside const generic parameters
-            let types_to_skip = generics.params.iter().filter_map(|param| {
-                match param {
-                    GenericParam { kind: GenericParamKind::Const { ty: Ty { hir_id, ..}, ..}, ..} => Some(*hir_id),
+            let types_to_skip = generics
+                .params
+                .iter()
+                .filter_map(|param| match param {
+                    GenericParam {
+                        kind:
+                            GenericParamKind::Const {
+                                ty: Ty { hir_id, .. }, ..
+                            },
+                        ..
+                    } => Some(*hir_id),
                     _ => None,
-                }
-            }).chain(std::iter::once(self_ty.hir_id)).collect();
+                })
+                .chain(std::iter::once(self_ty.hir_id))
+                .collect();
             StackItem::Check {
                 impl_id: item.owner_id.def_id,
                 in_body: 0,
@@ -209,9 +218,7 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
             && let TyKind::Path(QPath::Resolved(_, path)) = hir_ty.kind
             && !matches!(
                 path.res,
-                Res::SelfTyParam { .. }
-                | Res::SelfTyAlias { .. }
-                | Res::Def(DefKind::TyParam, _)
+                Res::SelfTyParam { .. } | Res::SelfTyAlias { .. } | Res::Def(DefKind::TyParam, _)
             )
             && !types_to_skip.contains(&hir_ty.hir_id)
             && let ty = if in_body > 0 {
@@ -230,7 +237,10 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
             && self.msrv.meets(msrvs::TYPE_ALIAS_ENUM_VARIANTS)
             && let Some(&StackItem::Check { impl_id, .. }) = self.stack.last()
             && cx.typeck_results().expr_ty(expr) == cx.tcx.type_of(impl_id).instantiate_identity()
-        {} else { return; }
+        {
+        } else {
+            return;
+        }
         match expr.kind {
             ExprKind::Struct(QPath::Resolved(_, path), ..) => check_path(cx, path),
             ExprKind::Call(fun, _) => {
diff --git a/clippy_lints/src/useless_conversion.rs b/clippy_lints/src/useless_conversion.rs
index bc83fddcc53..52327b82e84 100644
--- a/clippy_lints/src/useless_conversion.rs
+++ b/clippy_lints/src/useless_conversion.rs
@@ -3,7 +3,6 @@ use clippy_utils::source::{snippet, snippet_with_applicability, snippet_with_con
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::{is_copy, is_type_diagnostic_item, same_type_and_consts};
 use clippy_utils::{get_parent_expr, is_trait_method, is_ty_alias, path_to_local};
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::def::DefKind;
 use rustc_hir::def_id::DefId;
@@ -311,14 +310,14 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
                         );
                     }
                 }
-                if is_trait_method(cx, e, sym::TryInto) && name.ident.name == sym::try_into
+                if is_trait_method(cx, e, sym::TryInto)
+                    && name.ident.name == sym::try_into
                     && let a = cx.typeck_results().expr_ty(e)
                     && let b = cx.typeck_results().expr_ty(recv)
                     && is_type_diagnostic_item(cx, a, sym::Result)
                     && let ty::Adt(_, args) = a.kind()
                     && let Some(a_type) = args.types().next()
                     && same_type_and_consts(a_type, b)
-
                 {
                     span_lint_and_help(
                         cx,
@@ -343,7 +342,6 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
                         && let ty::Adt(_, args) = a.kind()
                         && let Some(a_type) = args.types().next()
                         && same_type_and_consts(a_type, b)
-
                     {
                         let hint = format!("consider removing `{}()`", snippet(cx, path.span, "TryFrom::try_from"));
                         span_lint_and_help(
@@ -356,14 +354,10 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
                         );
                     }
 
-                    if cx.tcx.is_diagnostic_item(sym::from_fn, def_id)
-                        && same_type_and_consts(a, b)
-
-                    {
+                    if cx.tcx.is_diagnostic_item(sym::from_fn, def_id) && same_type_and_consts(a, b) {
                         let mut app = Applicability::MachineApplicable;
                         let sugg = Sugg::hir_with_context(cx, arg, e.span.ctxt(), "<expr>", &mut app).maybe_par();
-                        let sugg_msg =
-                            format!("consider removing `{}()`", snippet(cx, path.span, "From::from"));
+                        let sugg_msg = format!("consider removing `{}()`", snippet(cx, path.span, "From::from"));
                         span_lint_and_sugg(
                             cx,
                             USELESS_CONVERSION,
diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs
index ddcb9f27c6c..877a77fd6d2 100644
--- a/clippy_lints/src/utils/internal_lints.rs
+++ b/clippy_lints/src/utils/internal_lints.rs
@@ -1,7 +1,6 @@
 pub mod almost_standard_lint_formulation;
 pub mod collapsible_calls;
 pub mod compiler_lint_functions;
-pub mod if_chain_style;
 pub mod interning_defined_symbol;
 pub mod invalid_paths;
 pub mod lint_without_lint_pass;
diff --git a/clippy_lints/src/utils/internal_lints/collapsible_calls.rs b/clippy_lints/src/utils/internal_lints/collapsible_calls.rs
index 1ed74982486..f514f166cff 100644
--- a/clippy_lints/src/utils/internal_lints/collapsible_calls.rs
+++ b/clippy_lints/src/utils/internal_lints/collapsible_calls.rs
@@ -1,7 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet;
 use clippy_utils::{is_expr_path_def_path, is_lint_allowed, peel_blocks_with_stmt, SpanlessEq};
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_hir::{Closure, Expr, ExprKind};
diff --git a/clippy_lints/src/utils/internal_lints/compiler_lint_functions.rs b/clippy_lints/src/utils/internal_lints/compiler_lint_functions.rs
index 6781c1aef3e..5aa1417cfb4 100644
--- a/clippy_lints/src/utils/internal_lints/compiler_lint_functions.rs
+++ b/clippy_lints/src/utils/internal_lints/compiler_lint_functions.rs
@@ -1,7 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::ty::match_type;
 use clippy_utils::{is_lint_allowed, paths};
-use if_chain::if_chain;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/utils/internal_lints/if_chain_style.rs b/clippy_lints/src/utils/internal_lints/if_chain_style.rs
deleted file mode 100644
index 873e136136f..00000000000
--- a/clippy_lints/src/utils/internal_lints/if_chain_style.rs
+++ /dev/null
@@ -1,160 +0,0 @@
-use clippy_utils::diagnostics::{span_lint, span_lint_and_then};
-use clippy_utils::{higher, is_else_clause, is_expn_of};
-use if_chain::if_chain;
-use rustc_hir as hir;
-use rustc_hir::{BinOpKind, Block, Expr, ExprKind, HirId, Local, Node, Stmt, StmtKind};
-use rustc_lint::{LateContext, LateLintPass, LintContext};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::{BytePos, Span};
-
-declare_clippy_lint! {
-    /// Finds unidiomatic usage of `if_chain!`
-    pub IF_CHAIN_STYLE,
-    internal,
-    "non-idiomatic `if_chain!` usage"
-}
-
-declare_lint_pass!(IfChainStyle => [IF_CHAIN_STYLE]);
-
-impl<'tcx> LateLintPass<'tcx> for IfChainStyle {
-    fn check_block(&mut self, cx: &LateContext<'tcx>, block: &'tcx hir::Block<'_>) {
-        let (local, after, if_chain_span) = if let [Stmt { kind: StmtKind::Local(local), .. }, after @ ..] = block.stmts
-            && let Some(if_chain_span) = is_expn_of(block.span, "if_chain")
-        { (local, after, if_chain_span) } else { return };
-        if is_first_if_chain_expr(cx, block.hir_id, if_chain_span) {
-            span_lint(
-                cx,
-                IF_CHAIN_STYLE,
-                if_chain_local_span(cx, local, if_chain_span),
-                "`let` expression should be above the `if_chain!`",
-            );
-        } else if local.span.eq_ctxt(block.span) && is_if_chain_then(after, block.expr, if_chain_span) {
-            span_lint(
-                cx,
-                IF_CHAIN_STYLE,
-                if_chain_local_span(cx, local, if_chain_span),
-                "`let` expression should be inside `then { .. }`",
-            );
-        }
-    }
-
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
-        let (cond, then, els) = if let Some(higher::IfOrIfLet { cond, r#else, then }) = higher::IfOrIfLet::hir(expr) {
-            (cond, then, r#else.is_some())
-        } else {
-            return;
-        };
-        let ExprKind::Block(then_block, _) = then.kind else {
-            return;
-        };
-        let if_chain_span = is_expn_of(expr.span, "if_chain");
-        if !els {
-            check_nested_if_chains(cx, expr, then_block, if_chain_span);
-        }
-        let Some(if_chain_span) = if_chain_span else { return };
-        // check for `if a && b;`
-        if let ExprKind::Binary(op, _, _) = cond.kind
-            && op.node == BinOpKind::And
-            && cx.sess().source_map().is_multiline(cond.span)
-        {
-            span_lint(cx, IF_CHAIN_STYLE, cond.span, "`if a && b;` should be `if a; if b;`");
-        }
-        if is_first_if_chain_expr(cx, expr.hir_id, if_chain_span)
-            && is_if_chain_then(then_block.stmts, then_block.expr, if_chain_span)
-        {
-            span_lint(cx, IF_CHAIN_STYLE, expr.span, "`if_chain!` only has one `if`");
-        }
-    }
-}
-
-fn check_nested_if_chains(
-    cx: &LateContext<'_>,
-    if_expr: &Expr<'_>,
-    then_block: &Block<'_>,
-    if_chain_span: Option<Span>,
-) {
-    #[rustfmt::skip]
-    let (head, tail) = match *then_block {
-        Block { stmts, expr: Some(tail), .. } => (stmts, tail),
-        Block {
-            stmts: &[
-                ref head @ ..,
-                Stmt { kind: StmtKind::Expr(tail) | StmtKind::Semi(tail), .. }
-            ],
-            ..
-        } => (head, tail),
-        _ => return,
-    };
-    if let Some(higher::IfOrIfLet { r#else: None, .. }) = higher::IfOrIfLet::hir(tail)
-        && let sm = cx.sess().source_map()
-        && head
-            .iter()
-            .all(|stmt| matches!(stmt.kind, StmtKind::Local(..)) && !sm.is_multiline(stmt.span))
-        && (if_chain_span.is_some() || !is_else_clause(cx.tcx, if_expr))
-    {
-    } else {
-        return;
-    }
-    let (span, msg) = match (if_chain_span, is_expn_of(tail.span, "if_chain")) {
-        (None, Some(_)) => (if_expr.span, "this `if` can be part of the inner `if_chain!`"),
-        (Some(_), None) => (tail.span, "this `if` can be part of the outer `if_chain!`"),
-        (Some(a), Some(b)) if a != b => (b, "this `if_chain!` can be merged with the outer `if_chain!`"),
-        _ => return,
-    };
-    span_lint_and_then(cx, IF_CHAIN_STYLE, span, msg, |diag| {
-        let (span, msg) = match head {
-            [] => return,
-            [stmt] => (stmt.span, "this `let` statement can also be in the `if_chain!`"),
-            [a, .., b] => (
-                a.span.to(b.span),
-                "these `let` statements can also be in the `if_chain!`",
-            ),
-        };
-        diag.span_help(span, msg);
-    });
-}
-
-fn is_first_if_chain_expr(cx: &LateContext<'_>, hir_id: HirId, if_chain_span: Span) -> bool {
-    cx.tcx
-        .hir()
-        .parent_iter(hir_id)
-        .find(|(_, node)| {
-            #[rustfmt::skip]
-            !matches!(node, Node::Expr(Expr { kind: ExprKind::Block(..), .. }) | Node::Stmt(_))
-        })
-        .map_or(false, |(id, _)| {
-            is_expn_of(cx.tcx.hir().span(id), "if_chain") != Some(if_chain_span)
-        })
-}
-
-/// Checks a trailing slice of statements and expression of a `Block` to see if they are part
-/// of the `then {..}` portion of an `if_chain!`
-fn is_if_chain_then(stmts: &[Stmt<'_>], expr: Option<&Expr<'_>>, if_chain_span: Span) -> bool {
-    let span = if let [stmt, ..] = stmts {
-        stmt.span
-    } else if let Some(expr) = expr {
-        expr.span
-    } else {
-        // empty `then {}`
-        return true;
-    };
-    is_expn_of(span, "if_chain").map_or(true, |span| span != if_chain_span)
-}
-
-/// Creates a `Span` for `let x = ..;` in an `if_chain!` call.
-fn if_chain_local_span(cx: &LateContext<'_>, local: &Local<'_>, if_chain_span: Span) -> Span {
-    let mut span = local.pat.span;
-    if let Some(init) = local.init {
-        span = span.to(init.span);
-    }
-    span.adjust(if_chain_span.ctxt().outer_expn());
-    let sm = cx.sess().source_map();
-    let span = sm.span_extend_to_prev_str(span, "let", false, true).unwrap_or(span);
-    let span = sm.span_extend_to_next_char(span, ';', false);
-    Span::new(
-        span.lo() - BytePos(3),
-        span.hi() + BytePos(1),
-        span.ctxt(),
-        span.parent(),
-    )
-}
diff --git a/clippy_lints/src/utils/internal_lints/interning_defined_symbol.rs b/clippy_lints/src/utils/internal_lints/interning_defined_symbol.rs
index c2b36fc28f7..16d0636b834 100644
--- a/clippy_lints/src/utils/internal_lints/interning_defined_symbol.rs
+++ b/clippy_lints/src/utils/internal_lints/interning_defined_symbol.rs
@@ -3,7 +3,6 @@ use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::match_type;
 use clippy_utils::{def_path_def_ids, is_expn_of, match_def_path, paths};
-use if_chain::if_chain;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::Applicability;
 use rustc_hir::def::{DefKind, Res};
@@ -161,7 +160,11 @@ impl InterningDefinedSymbol {
         static SYMBOL_STR_PATHS: &[&[&str]] = &[&paths::SYMBOL_AS_STR, &paths::SYMBOL_TO_IDENT_STRING];
         let call = if let ExprKind::AddrOf(_, _, e) = expr.kind
             && let ExprKind::Unary(UnOp::Deref, e) = e.kind
-        { e } else { expr };
+        {
+            e
+        } else {
+            expr
+        };
         if let ExprKind::MethodCall(_, item, [], _) = call.kind
             // is a method call
             && let Some(did) = cx.typeck_results().type_dependent_def_id(call.hir_id)
diff --git a/clippy_lints/src/utils/internal_lints/invalid_paths.rs b/clippy_lints/src/utils/internal_lints/invalid_paths.rs
index b5a4787175a..66d32087fcd 100644
--- a/clippy_lints/src/utils/internal_lints/invalid_paths.rs
+++ b/clippy_lints/src/utils/internal_lints/invalid_paths.rs
@@ -1,7 +1,6 @@
 use clippy_utils::consts::{constant_simple, Constant};
 use clippy_utils::def_path_res;
 use clippy_utils::diagnostics::span_lint;
-use if_chain::if_chain;
 use rustc_hir as hir;
 use rustc_hir::def::DefKind;
 use rustc_hir::Item;
diff --git a/clippy_lints/src/utils/internal_lints/lint_without_lint_pass.rs b/clippy_lints/src/utils/internal_lints/lint_without_lint_pass.rs
index 871c8f99ebf..486e8220484 100644
--- a/clippy_lints/src/utils/internal_lints/lint_without_lint_pass.rs
+++ b/clippy_lints/src/utils/internal_lints/lint_without_lint_pass.rs
@@ -2,7 +2,6 @@ use crate::utils::internal_lints::metadata_collector::is_deprecated_lint;
 use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
 use clippy_utils::macros::root_macro_call_first_node;
 use clippy_utils::{is_lint_allowed, match_def_path, paths};
-use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_hir::def::{DefKind, Res};
@@ -315,7 +314,11 @@ pub(super) fn extract_clippy_version_value(cx: &LateContext<'_>, item: &'_ Item<
             && tool_name.ident.name == sym::clippy
             && attr_name.ident.name == sym::version
             && let Some(version) = attr.value_str()
-        { Some(version) } else { None }
+        {
+            Some(version)
+        } else {
+            None
+        }
     })
 }
 
diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index e4e72bbc388..8ecdba47f89 100644
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -14,7 +14,6 @@ use clippy_config::{get_configuration_metadata, ClippyConfiguration};
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::ty::{match_type, walk_ptrs_ty_depth};
 use clippy_utils::{last_path_segment, match_def_path, match_function_call, match_path, paths};
-use if_chain::if_chain;
 use itertools::Itertools;
 use rustc_ast as ast;
 use rustc_data_structures::fx::FxHashMap;
@@ -923,7 +922,6 @@ impl<'a, 'hir> intravisit::Visitor<'hir> for LintResolver<'a, 'hir> {
     fn visit_expr(&mut self, expr: &'hir hir::Expr<'hir>) {
         if let ExprKind::Path(qpath) = &expr.kind
             && let QPath::Resolved(_, path) = qpath
-
             && let (expr_ty, _) = walk_ptrs_ty_depth(self.cx.typeck_results().expr_ty(expr))
             && match_type(self.cx, expr_ty, &paths::LINT)
         {
diff --git a/clippy_lints/src/utils/internal_lints/msrv_attr_impl.rs b/clippy_lints/src/utils/internal_lints/msrv_attr_impl.rs
index 1c09695c9dd..86b1a0ae624 100644
--- a/clippy_lints/src/utils/internal_lints/msrv_attr_impl.rs
+++ b/clippy_lints/src/utils/internal_lints/msrv_attr_impl.rs
@@ -2,7 +2,6 @@ use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::match_type;
 use clippy_utils::{match_def_path, paths};
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass, LintContext};
@@ -23,11 +22,14 @@ declare_lint_pass!(MsrvAttrImpl => [MISSING_MSRV_ATTR_IMPL]);
 impl LateLintPass<'_> for MsrvAttrImpl {
     fn check_item(&mut self, cx: &LateContext<'_>, item: &hir::Item<'_>) {
         if let hir::ItemKind::Impl(hir::Impl {
-                of_trait: Some(_),
-                items,
-                ..
-            }) = &item.kind
-            && let Some(trait_ref) = cx.tcx.impl_trait_ref(item.owner_id).map(EarlyBinder::instantiate_identity)
+            of_trait: Some(_),
+            items,
+            ..
+        }) = &item.kind
+            && let Some(trait_ref) = cx
+                .tcx
+                .impl_trait_ref(item.owner_id)
+                .map(EarlyBinder::instantiate_identity)
             && let is_late_pass = match_def_path(cx, trait_ref.def_id, &paths::LATE_LINT_PASS)
             && (is_late_pass || match_def_path(cx, trait_ref.def_id, &paths::EARLY_LINT_PASS))
             && let ty::Adt(self_ty_def, _) = trait_ref.self_ty().kind()
diff --git a/clippy_lints/src/utils/internal_lints/outer_expn_data_pass.rs b/clippy_lints/src/utils/internal_lints/outer_expn_data_pass.rs
index 78eeb04d58d..77b95e51f62 100644
--- a/clippy_lints/src/utils/internal_lints/outer_expn_data_pass.rs
+++ b/clippy_lints/src/utils/internal_lints/outer_expn_data_pass.rs
@@ -1,7 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::ty::match_type;
 use clippy_utils::{is_lint_allowed, method_calls, paths};
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/utils/internal_lints/unnecessary_def_path.rs b/clippy_lints/src/utils/internal_lints/unnecessary_def_path.rs
index 3ad02afd88a..9aa23b6efe3 100644
--- a/clippy_lints/src/utils/internal_lints/unnecessary_def_path.rs
+++ b/clippy_lints/src/utils/internal_lints/unnecessary_def_path.rs
@@ -1,7 +1,6 @@
 use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_then};
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::{def_path_def_ids, is_lint_allowed, match_any_def_paths, peel_hir_expr_refs};
-use if_chain::if_chain;
 use rustc_ast::ast::LitKind;
 use rustc_data_structures::fx::{FxHashSet, FxIndexSet};
 use rustc_errors::Applicability;
@@ -109,7 +108,7 @@ impl UnnecessaryDefPath {
             && let item_arg = if which_path == 4 { &args[1] } else { &args[0] }
             // Extract the path to the matched type
             && let Some(segments) = path_to_matched_type(cx, item_arg)
-            && let segments: Vec<&str> = segments.iter().map(|sym| &**sym).collect()
+            && let segments = segments.iter().map(|sym| &**sym).collect::<Vec<_>>()
             && let Some(def_id) = def_path_def_ids(cx, &segments[..]).next()
         {
             // Check if the target item is a diagnostic item or LangItem.
diff --git a/clippy_lints/src/vec.rs b/clippy_lints/src/vec.rs
index d215e6b5768..9ad2ad2d195 100644
--- a/clippy_lints/src/vec.rs
+++ b/clippy_lints/src/vec.rs
@@ -7,7 +7,6 @@ use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::is_copy;
 use clippy_utils::visitors::for_each_local_use_after_expr;
 use clippy_utils::{get_parent_expr, higher, is_trait_method};
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{BorrowKind, Expr, ExprKind, Mutability, Node, PatKind};
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/wildcard_imports.rs b/clippy_lints/src/wildcard_imports.rs
index c94ed82646e..5c1bea74486 100644
--- a/clippy_lints/src/wildcard_imports.rs
+++ b/clippy_lints/src/wildcard_imports.rs
@@ -1,7 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::is_test_module_or_function;
 use clippy_utils::source::{snippet, snippet_with_applicability};
-use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::{Item, ItemKind, PathSegment, UseKind};
@@ -139,10 +138,7 @@ impl LateLintPass<'_> for WildcardImports {
                 // This is a `_::{_, *}` import
                 // In this case `use_path.span` is empty and ends directly in front of the `*`,
                 // so we need to extend it by one byte.
-                (
-                    use_path.span.with_hi(use_path.span.hi() + BytePos(1)),
-                    true,
-                )
+                (use_path.span.with_hi(use_path.span.hi() + BytePos(1)), true)
             } else {
                 // In this case, the `use_path.span` ends right before the `::*`, so we need to
                 // extend it up to the `*`. Since it is hard to find the `*` in weird
@@ -153,9 +149,7 @@ impl LateLintPass<'_> for WildcardImports {
                 if snippet(cx, span, "").ends_with(';') {
                     span = use_path.span.with_hi(item.span.hi() - BytePos(1));
                 }
-                (
-                    span, false,
-                )
+                (span, false)
             };
 
             let mut imports = used_imports.items().map(ToString::to_string).into_sorted_stable_ord();
@@ -180,15 +174,7 @@ impl LateLintPass<'_> for WildcardImports {
                 (WILDCARD_IMPORTS, "usage of wildcard import")
             };
 
-            span_lint_and_sugg(
-                cx,
-                lint,
-                span,
-                message,
-                "try",
-                sugg,
-                applicability,
-            );
+            span_lint_and_sugg(cx, lint, span, message, "try", sugg, applicability);
         }
     }
 
diff --git a/clippy_lints/src/zero_div_zero.rs b/clippy_lints/src/zero_div_zero.rs
index 7f7d30d03ab..1d6217d186c 100644
--- a/clippy_lints/src/zero_div_zero.rs
+++ b/clippy_lints/src/zero_div_zero.rs
@@ -1,6 +1,5 @@
 use clippy_utils::consts::{constant_simple, Constant};
 use clippy_utils::diagnostics::span_lint_and_help;
-use if_chain::if_chain;
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -45,9 +44,8 @@ impl<'tcx> LateLintPass<'tcx> for ZeroDiv {
             // since we're about to suggest a use of f32::NAN or f64::NAN,
             // match the precision of the literals that are given.
             let float_type = match (lhs_value, rhs_value) {
-                (Constant::F64(_), _)
-                | (_, Constant::F64(_)) => "f64",
-                _ => "f32"
+                (Constant::F64(_), _) | (_, Constant::F64(_)) => "f64",
+                _ => "f32",
             };
             span_lint_and_help(
                 cx,
@@ -55,9 +53,7 @@ impl<'tcx> LateLintPass<'tcx> for ZeroDiv {
                 expr.span,
                 "constant division of `0.0` with `0.0` will always result in NaN",
                 None,
-                &format!(
-                    "consider using `{float_type}::NAN` if you would like a constant representing NaN",
-                ),
+                &format!("consider using `{float_type}::NAN` if you would like a constant representing NaN",),
             );
         }
     }
diff --git a/clippy_lints/src/zero_sized_map_values.rs b/clippy_lints/src/zero_sized_map_values.rs
index 6504b0fa5f9..41c1757fde8 100644
--- a/clippy_lints/src/zero_sized_map_values.rs
+++ b/clippy_lints/src/zero_sized_map_values.rs
@@ -1,6 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::ty::{is_normalizable, is_type_diagnostic_item};
-use if_chain::if_chain;
 use rustc_hir::{self as hir, HirId, ItemKind, Node};
 use rustc_hir_analysis::hir_ty_to_ty;
 use rustc_lint::{LateContext, LateLintPass};
@@ -60,7 +59,14 @@ impl LateLintPass<'_> for ZeroSizedMapValues {
             && let Ok(layout) = cx.layout_of(ty)
             && layout.is_zst()
         {
-            span_lint_and_help(cx, ZERO_SIZED_MAP_VALUES, hir_ty.span, "map with zero-sized value type", None, "consider using a set instead");
+            span_lint_and_help(
+                cx,
+                ZERO_SIZED_MAP_VALUES,
+                hir_ty.span,
+                "map with zero-sized value type",
+                None,
+                "consider using a set instead",
+            );
         }
     }
 }
diff --git a/clippy_utils/Cargo.toml b/clippy_utils/Cargo.toml
index c9b01a68f42..1f9802dc5ee 100644
--- a/clippy_utils/Cargo.toml
+++ b/clippy_utils/Cargo.toml
@@ -7,7 +7,6 @@ publish = false
 [dependencies]
 clippy_config = { path = "../clippy_config" }
 arrayvec = { version = "0.7", default-features = false }
-if_chain = "1.0"
 itertools = "0.10.1"
 rustc-semver = "1.1"
 
diff --git a/clippy_utils/src/consts.rs b/clippy_utils/src/consts.rs
index 791f815c850..3748e2a26d1 100644
--- a/clippy_utils/src/consts.rs
+++ b/clippy_utils/src/consts.rs
@@ -2,7 +2,7 @@
 
 use crate::source::{get_source_text, walk_span_to_context};
 use crate::{clip, is_direct_expn_of, sext, unsext};
-use if_chain::if_chain;
+
 use rustc_ast::ast::{self, LitFloatType, LitKind};
 use rustc_data_structures::sync::Lrc;
 use rustc_hir::def::{DefKind, Res};
@@ -377,7 +377,7 @@ impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
                     && let res = self.typeck_results.qpath_res(qpath, callee.hir_id)
                     && let Some(def_id) = res.opt_def_id()
                     && let def_path = self.lcx.get_def_path(def_id)
-                    && let def_path: Vec<&str> = def_path.iter().take(4).map(Symbol::as_str).collect()
+                    && let def_path = def_path.iter().take(4).map(Symbol::as_str).collect::<Vec<_>>()
                     && let ["core", "num", int_impl, "max_value"] = *def_path
                 {
                     let value = match int_impl {
diff --git a/clippy_utils/src/higher.rs b/clippy_utils/src/higher.rs
index 93cd5b3fe1e..3135a033648 100644
--- a/clippy_utils/src/higher.rs
+++ b/clippy_utils/src/higher.rs
@@ -5,7 +5,7 @@
 use crate::consts::{constant_simple, Constant};
 use crate::ty::is_type_diagnostic_item;
 use crate::{is_expn_of, match_def_path, paths};
-use if_chain::if_chain;
+
 use rustc_ast::ast;
 use rustc_hir as hir;
 use rustc_hir::{Arm, Block, Expr, ExprKind, HirId, LoopSource, MatchSource, Node, Pat, QPath};
@@ -286,7 +286,8 @@ impl<'a> VecArgs<'a> {
             } else if match_def_path(cx, fun_def_id, &paths::SLICE_INTO_VEC) && args.len() == 1 {
                 // `vec![a, b, c]` case
                 if let hir::ExprKind::Call(_, [arg]) = &args[0].kind
-                    && let hir::ExprKind::Array(args) = arg.kind {
+                    && let hir::ExprKind::Array(args) = arg.kind
+                {
                     Some(VecArgs::Vec(args))
                 } else {
                     None
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index e3c26525a6a..21225dc7098 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -76,7 +76,6 @@ use std::collections::hash_map::Entry;
 use std::hash::BuildHasherDefault;
 use std::sync::{Mutex, MutexGuard, OnceLock};
 
-use if_chain::if_chain;
 use itertools::Itertools;
 use rustc_ast::ast::{self, LitKind, RangeLimits};
 use rustc_data_structures::fx::FxHashMap;
@@ -823,7 +822,11 @@ pub fn is_default_equivalent_call(cx: &LateContext<'_>, repl_func: &Expr<'_>) ->
         && let Some(repl_def_id) = cx.qpath_res(repl_func_qpath, repl_func.hir_id).opt_def_id()
         && (is_diag_trait_item(cx, repl_def_id, sym::Default)
             || is_default_equivalent_ctor(cx, repl_def_id, repl_func_qpath))
-    { true } else { false }
+    {
+        true
+    } else {
+        false
+    }
 }
 
 /// Returns true if the expr is equal to `Default::default()` of it's type when evaluated.
@@ -837,14 +840,16 @@ pub fn is_default_equivalent(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
             _ => false,
         },
         ExprKind::Tup(items) | ExprKind::Array(items) => items.iter().all(|x| is_default_equivalent(cx, x)),
-        ExprKind::Repeat(x, ArrayLen::Body(len)) => if let ExprKind::Lit(const_lit) = cx.tcx.hir().body(len.body).value.kind
-            && let LitKind::Int(v, _) = const_lit.node
-            && v <= 32 && is_default_equivalent(cx, x)
-        {
-            true
-        }
-        else {
-            false
+        ExprKind::Repeat(x, ArrayLen::Body(len)) => {
+            if let ExprKind::Lit(const_lit) = cx.tcx.hir().body(len.body).value.kind
+                && let LitKind::Int(v, _) = const_lit.node
+                && v <= 32
+                && is_default_equivalent(cx, x)
+            {
+                true
+            } else {
+                false
+            }
         },
         ExprKind::Call(repl_func, []) => is_default_equivalent_call(cx, repl_func),
         ExprKind::Call(from_func, [ref arg]) => is_default_equivalent_from(cx, from_func, arg),
@@ -1992,12 +1997,14 @@ pub fn get_async_fn_body<'tcx>(tcx: TyCtxt<'tcx>, body: &Body<'_>) -> Option<&'t
 // check if expr is calling method or function with #[must_use] attribute
 pub fn is_must_use_func_call(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
     let did = match expr.kind {
-        ExprKind::Call(path, _) => if let ExprKind::Path(ref qpath) = path.kind
-            && let def::Res::Def(_, did) = cx.qpath_res(qpath, path.hir_id)
-        {
-            Some(did)
-        } else {
-            None
+        ExprKind::Call(path, _) => {
+            if let ExprKind::Path(ref qpath) = path.kind
+                && let def::Res::Def(_, did) = cx.qpath_res(qpath, path.hir_id)
+            {
+                Some(did)
+            } else {
+                None
+            }
         },
         ExprKind::MethodCall(..) => cx.typeck_results().type_dependent_def_id(expr.hir_id),
         _ => None,
diff --git a/tests/ui-internal/if_chain_style.rs b/tests/ui-internal/if_chain_style.rs
deleted file mode 100644
index b462b20e04c..00000000000
--- a/tests/ui-internal/if_chain_style.rs
+++ /dev/null
@@ -1,97 +0,0 @@
-#![warn(clippy::if_chain_style)]
-#![allow(
-    clippy::needless_if,
-    clippy::no_effect,
-    clippy::nonminimal_bool,
-    clippy::missing_clippy_version_attribute
-)]
-
-extern crate if_chain;
-
-use if_chain::if_chain;
-
-fn main() {
-    if true {
-        let x = "";
-        // `if_chain!` inside `if`
-        if_chain! {
-            if true;
-            if true;
-            then {}
-        }
-    }
-    if_chain! {
-        if true
-            // multi-line AND'ed conditions
-            && false;
-        if let Some(1) = Some(1);
-        // `let` before `then`
-        let x = "";
-        then {
-            ();
-        }
-    }
-    if_chain! {
-        // single `if` condition
-        if true;
-        then {
-            let x = "";
-            // nested if
-            if true {}
-        }
-    }
-    if_chain! {
-        // starts with `let ..`
-        let x = "";
-        if let Some(1) = Some(1);
-        then {
-            let x = "";
-            let x = "";
-            // nested if_chain!
-            if_chain! {
-                if true;
-                if true;
-                then {}
-            }
-        }
-    }
-}
-
-fn negative() {
-    if true {
-        ();
-        if_chain! {
-            if true;
-            if true;
-            then { (); }
-        }
-    }
-    if_chain! {
-        if true;
-        let x = "";
-        if true;
-        then { (); }
-    }
-    if_chain! {
-        if true;
-        if true;
-        then {
-            if true { 1 } else { 2 }
-        } else {
-            3
-        }
-    };
-    if true {
-        if_chain! {
-            if true;
-            if true;
-            then {}
-        }
-    } else if false {
-        if_chain! {
-            if true;
-            if false;
-            then {}
-        }
-    }
-}
diff --git a/tests/ui-internal/if_chain_style.stderr b/tests/ui-internal/if_chain_style.stderr
deleted file mode 100644
index ea04955323d..00000000000
--- a/tests/ui-internal/if_chain_style.stderr
+++ /dev/null
@@ -1,86 +0,0 @@
-error: this `if` can be part of the inner `if_chain!`
-  --> $DIR/if_chain_style.rs:14:5
-   |
-LL | /     if true {
-LL | |         let x = "";
-LL | |         // `if_chain!` inside `if`
-LL | |         if_chain! {
-...  |
-LL | |         }
-LL | |     }
-   | |_____^
-   |
-help: this `let` statement can also be in the `if_chain!`
-  --> $DIR/if_chain_style.rs:15:9
-   |
-LL |         let x = "";
-   |         ^^^^^^^^^^^
-   = note: `-D clippy::if-chain-style` implied by `-D warnings`
-   = help: to override `-D warnings` add `#[allow(clippy::if_chain_style)]`
-
-error: `if a && b;` should be `if a; if b;`
-  --> $DIR/if_chain_style.rs:24:12
-   |
-LL |           if true
-   |  ____________^
-LL | |             // multi-line AND'ed conditions
-LL | |             && false;
-   | |____________________^
-
-error: `let` expression should be inside `then { .. }`
-  --> $DIR/if_chain_style.rs:29:9
-   |
-LL |         let x = "";
-   |         ^^^^^^^^^^^
-
-error: this `if` can be part of the outer `if_chain!`
-  --> $DIR/if_chain_style.rs:40:13
-   |
-LL |             if true {}
-   |             ^^^^^^^^^^
-   |
-help: this `let` statement can also be in the `if_chain!`
-  --> $DIR/if_chain_style.rs:38:13
-   |
-LL |             let x = "";
-   |             ^^^^^^^^^^^
-
-error: `if_chain!` only has one `if`
-  --> $DIR/if_chain_style.rs:34:5
-   |
-LL | /     if_chain! {
-LL | |         // single `if` condition
-LL | |         if true;
-LL | |         then {
-...  |
-LL | |         }
-LL | |     }
-   | |_____^
-   |
-   = note: this error originates in the macro `__if_chain` which comes from the expansion of the macro `if_chain` (in Nightly builds, run with -Z macro-backtrace for more info)
-
-error: `let` expression should be above the `if_chain!`
-  --> $DIR/if_chain_style.rs:45:9
-   |
-LL |         let x = "";
-   |         ^^^^^^^^^^^
-
-error: this `if_chain!` can be merged with the outer `if_chain!`
-  --> $DIR/if_chain_style.rs:51:13
-   |
-LL | /             if_chain! {
-LL | |                 if true;
-LL | |                 if true;
-LL | |                 then {}
-LL | |             }
-   | |_____________^
-   |
-help: these `let` statements can also be in the `if_chain!`
-  --> $DIR/if_chain_style.rs:48:13
-   |
-LL | /             let x = "";
-LL | |             let x = "";
-   | |_______________________^
-
-error: aborting due to 7 previous errors
-
-- 
cgit 1.4.1-3-g733a5


From f1979d48d7b8b90bc45b2c4fa1afe62c3c1066e8 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Fri, 10 Nov 2023 23:41:57 +0000
Subject: Destructure `Conf` in `register_lints`

---
 CONTRIBUTING.md                              |   8 +-
 book/src/development/adding_lints.md         |   2 +-
 book/src/development/defining_lints.md       |   2 +-
 clippy_config/src/types.rs                   |  24 +---
 clippy_lints/src/disallowed_names.rs         |   4 +-
 clippy_lints/src/doc.rs                      |   4 +-
 clippy_lints/src/lib.rs                      | 185 ++++++++++++++-------------
 clippy_lints/src/methods/mod.rs              |   4 +-
 clippy_lints/src/nonstandard_macro_braces.rs |  88 ++++---------
 clippy_lints/src/pass_by_ref_or_value.rs     |   5 +-
 clippy_lints/src/raw_strings.rs              |   2 +-
 src/driver.rs                                |   2 +-
 12 files changed, 138 insertions(+), 192 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 04af1b98b55..b1a59238c82 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -146,16 +146,10 @@ For example, the [`else_if_without_else`][else_if_without_else] lint is register
 pub mod else_if_without_else;
 // ...
 
-pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf: &Conf) {
+pub fn register_lints(store: &mut rustc_lint::LintStore, conf: &'static Conf) {
     // ...
     store.register_early_pass(|| Box::new(else_if_without_else::ElseIfWithoutElse));
     // ...
-
-    store.register_group(true, "clippy::restriction", Some("clippy_restriction"), vec![
-        // ...
-        LintId::of(&else_if_without_else::ELSE_IF_WITHOUT_ELSE),
-        // ...
-    ]);
 }
 ```
 
diff --git a/book/src/development/adding_lints.md b/book/src/development/adding_lints.md
index 3b26565369c..1803fc2d2f3 100644
--- a/book/src/development/adding_lints.md
+++ b/book/src/development/adding_lints.md
@@ -270,7 +270,7 @@ When using `cargo dev new_lint`, the lint is automatically registered and
 nothing more has to be done.
 
 When declaring a new lint by hand and `cargo dev update_lints` is used, the lint
-pass may have to be registered manually in the `register_plugins` function in
+pass may have to be registered manually in the `register_lints` function in
 `clippy_lints/src/lib.rs`:
 
 ```rust,ignore
diff --git a/book/src/development/defining_lints.md b/book/src/development/defining_lints.md
index 7c4aa5d4523..54f77b00190 100644
--- a/book/src/development/defining_lints.md
+++ b/book/src/development/defining_lints.md
@@ -186,7 +186,7 @@ However, sometimes we might want to declare a new lint by hand. In this case,
 we'd use `cargo dev update_lints` command afterwards.
 
 When a lint is manually declared, we might need to register the lint pass
-manually in the `register_plugins` function in `clippy_lints/src/lib.rs`:
+manually in the `register_lints` function in `clippy_lints/src/lib.rs`:
 
 ```rust
 store.register_late_pass(|_| Box::new(foo_functions::FooFunctions));
diff --git a/clippy_config/src/types.rs b/clippy_config/src/types.rs
index e898221ffa7..df48cc3f5e3 100644
--- a/clippy_config/src/types.rs
+++ b/clippy_config/src/types.rs
@@ -1,7 +1,6 @@
 use serde::de::{self, Deserializer, Visitor};
 use serde::{ser, Deserialize, Serialize};
 use std::fmt;
-use std::hash::{Hash, Hasher};
 
 #[derive(Clone, Debug, Deserialize)]
 pub struct Rename {
@@ -33,32 +32,19 @@ impl DisallowedPath {
     }
 }
 
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Deserialize, Serialize)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Deserialize, Serialize)]
 pub enum MatchLintBehaviour {
     AllTypes,
     WellKnownTypes,
     Never,
 }
 
-#[derive(Clone, Debug)]
+#[derive(Debug)]
 pub struct MacroMatcher {
     pub name: String,
-    pub braces: (String, String),
+    pub braces: (char, char),
 }
 
-impl Hash for MacroMatcher {
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        self.name.hash(state);
-    }
-}
-
-impl PartialEq for MacroMatcher {
-    fn eq(&self, other: &Self) -> bool {
-        self.name == other.name
-    }
-}
-impl Eq for MacroMatcher {}
-
 impl<'de> Deserialize<'de> for MacroMatcher {
     fn deserialize<D>(deser: D) -> Result<Self, D::Error>
     where
@@ -83,7 +69,7 @@ impl<'de> Deserialize<'de> for MacroMatcher {
                 V: de::MapAccess<'de>,
             {
                 let mut name = None;
-                let mut brace: Option<String> = None;
+                let mut brace: Option<char> = None;
                 while let Some(key) = map.next_key()? {
                     match key {
                         Field::Name => {
@@ -104,7 +90,7 @@ impl<'de> Deserialize<'de> for MacroMatcher {
                 let brace = brace.ok_or_else(|| de::Error::missing_field("brace"))?;
                 Ok(MacroMatcher {
                     name,
-                    braces: [("(", ")"), ("{", "}"), ("[", "]")]
+                    braces: [('(', ')'), ('{', '}'), ('[', ']')]
                         .into_iter()
                         .find(|b| b.0 == brace)
                         .map(|(o, c)| (o.to_owned(), c.to_owned()))
diff --git a/clippy_lints/src/disallowed_names.rs b/clippy_lints/src/disallowed_names.rs
index 5e46b29b639..a1dd4805b9c 100644
--- a/clippy_lints/src/disallowed_names.rs
+++ b/clippy_lints/src/disallowed_names.rs
@@ -31,9 +31,9 @@ pub struct DisallowedNames {
 }
 
 impl DisallowedNames {
-    pub fn new(disallow: FxHashSet<String>) -> Self {
+    pub fn new(disallowed_names: &[String]) -> Self {
         Self {
-            disallow,
+            disallow: disallowed_names.iter().cloned().collect(),
             test_modules_deep: 0,
         }
     }
diff --git a/clippy_lints/src/doc.rs b/clippy_lints/src/doc.rs
index 587360545cb..6a12baa4201 100644
--- a/clippy_lints/src/doc.rs
+++ b/clippy_lints/src/doc.rs
@@ -268,9 +268,9 @@ pub struct DocMarkdown {
 }
 
 impl DocMarkdown {
-    pub fn new(valid_idents: FxHashSet<String>) -> Self {
+    pub fn new(valid_idents: &[String]) -> Self {
         Self {
-            valid_idents,
+            valid_idents: valid_idents.iter().cloned().collect(),
             in_trait_impl: false,
         }
     }
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index e5f8bd5c471..609ff3d051a 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -52,7 +52,6 @@ extern crate declare_clippy_lint;
 
 use rustc_data_structures::fx::FxHashSet;
 use rustc_lint::{Lint, LintId};
-use rustc_session::Session;
 
 #[cfg(feature = "internal")]
 pub mod deprecated_lints;
@@ -492,11 +491,83 @@ fn register_categories(store: &mut rustc_lint::LintStore) {
     groups.register(store);
 }
 
-/// Register all lints and lint groups with the rustc plugin registry
+/// Register all lints and lint groups with the rustc lint store
 ///
 /// Used in `./src/driver.rs`.
 #[expect(clippy::too_many_lines)]
-pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf: &'static Conf) {
+pub fn register_lints(store: &mut rustc_lint::LintStore, conf: &'static Conf) {
+    let Conf {
+        ref absolute_paths_allowed_crates,
+        absolute_paths_max_segments,
+        accept_comment_above_attributes,
+        accept_comment_above_statement,
+        allow_dbg_in_tests,
+        allow_expect_in_tests,
+        allow_mixed_uninlined_format_args,
+        allow_one_hash_in_raw_strings,
+        allow_print_in_tests,
+        allow_private_module_inception,
+        allow_unwrap_in_tests,
+        ref allowed_dotfiles,
+        ref allowed_idents_below_min_chars,
+        ref allowed_scripts,
+        ref arithmetic_side_effects_allowed_binary,
+        ref arithmetic_side_effects_allowed_unary,
+        ref arithmetic_side_effects_allowed,
+        array_size_threshold,
+        avoid_breaking_exported_api,
+        ref await_holding_invalid_types,
+        cargo_ignore_publish,
+        cognitive_complexity_threshold,
+        ref disallowed_macros,
+        ref disallowed_methods,
+        ref disallowed_names,
+        ref disallowed_types,
+        ref doc_valid_idents,
+        enable_raw_pointer_heuristic_for_send,
+        enforce_iter_loop_reborrow,
+        ref enforced_import_renames,
+        enum_variant_name_threshold,
+        enum_variant_size_threshold,
+        excessive_nesting_threshold,
+        future_size_threshold,
+        ref ignore_interior_mutability,
+        large_error_threshold,
+        literal_representation_threshold,
+        matches_for_let_else,
+        max_fn_params_bools,
+        max_include_file_size,
+        max_struct_bools,
+        max_suggested_slice_pattern_length,
+        max_trait_bounds,
+        min_ident_chars_threshold,
+        missing_docs_in_crate_items,
+        ref msrv,
+        pass_by_value_size_limit,
+        semicolon_inside_block_ignore_singleline,
+        semicolon_outside_block_ignore_multiline,
+        single_char_binding_names_threshold,
+        stack_size_threshold,
+        ref standard_macro_braces,
+        struct_field_name_threshold,
+        suppress_restriction_lint_in_const,
+        too_large_for_stack,
+        too_many_arguments_threshold,
+        too_many_lines_threshold,
+        trivial_copy_size_limit,
+        type_complexity_threshold,
+        unnecessary_box_size,
+        unreadable_literal_lint_fractions,
+        upper_case_acronyms_aggressive,
+        vec_box_size_threshold,
+        verbose_bit_mask_threshold,
+        warn_on_all_wildcard_imports,
+
+        blacklisted_names: _,
+        cyclomatic_complexity_threshold: _,
+    } = *conf;
+    let msrv = || msrv.clone();
+
     register_removed_non_tool_lints(store);
     register_categories(store);
 
@@ -536,9 +607,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         });
     }
 
-    let arithmetic_side_effects_allowed = conf.arithmetic_side_effects_allowed.clone();
-    let arithmetic_side_effects_allowed_binary = conf.arithmetic_side_effects_allowed_binary.clone();
-    let arithmetic_side_effects_allowed_unary = conf.arithmetic_side_effects_allowed_unary.clone();
     store.register_late_pass(move |_| {
         Box::new(operators::arithmetic_side_effects::ArithmeticSideEffects::new(
             arithmetic_side_effects_allowed
@@ -556,16 +624,12 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_early_pass(|| Box::<utils::format_args_collector::FormatArgsCollector>::default());
     store.register_late_pass(|_| Box::new(utils::dump_hir::DumpHir));
     store.register_late_pass(|_| Box::new(utils::author::Author));
-    let await_holding_invalid_types = conf.await_holding_invalid_types.clone();
     store.register_late_pass(move |_| {
         Box::new(await_holding_invalid::AwaitHolding::new(
             await_holding_invalid_types.clone(),
         ))
     });
     store.register_late_pass(|_| Box::new(serde_api::SerdeApi));
-    let vec_box_size_threshold = conf.vec_box_size_threshold;
-    let type_complexity_threshold = conf.type_complexity_threshold;
-    let avoid_breaking_exported_api = conf.avoid_breaking_exported_api;
     store.register_late_pass(move |_| {
         Box::new(types::Types::new(
             vec_box_size_threshold,
@@ -598,19 +662,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(inconsistent_struct_constructor::InconsistentStructConstructor));
     store.register_late_pass(|_| Box::new(non_octal_unix_permissions::NonOctalUnixPermissions));
     store.register_early_pass(|| Box::new(unnecessary_self_imports::UnnecessarySelfImports));
-
-    let msrv = || conf.msrv.clone();
-    let avoid_breaking_exported_api = conf.avoid_breaking_exported_api;
-    let allow_expect_in_tests = conf.allow_expect_in_tests;
-    let allow_unwrap_in_tests = conf.allow_unwrap_in_tests;
-    let suppress_restriction_lint_in_const = conf.suppress_restriction_lint_in_const;
     store.register_late_pass(move |_| Box::new(approx_const::ApproxConstant::new(msrv())));
-    let allowed_dotfiles = conf
-        .allowed_dotfiles
-        .iter()
-        .cloned()
-        .chain(methods::DEFAULT_ALLOWED_DOTFILES.iter().copied().map(ToOwned::to_owned))
-        .collect::<FxHashSet<_>>();
     store.register_late_pass(move |_| {
         Box::new(methods::Methods::new(
             avoid_breaking_exported_api,
@@ -621,7 +673,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         ))
     });
     store.register_late_pass(move |_| Box::new(matches::Matches::new(msrv())));
-    let matches_for_let_else = conf.matches_for_let_else;
     store.register_early_pass(move || Box::new(manual_non_exhaustive::ManualNonExhaustiveStruct::new(msrv())));
     store.register_late_pass(move |_| Box::new(manual_non_exhaustive::ManualNonExhaustiveEnum::new(msrv())));
     store.register_late_pass(move |_| Box::new(manual_strip::ManualStrip::new(msrv())));
@@ -638,7 +689,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_early_pass(move || Box::new(unnested_or_patterns::UnnestedOrPatterns::new(msrv())));
     store.register_late_pass(|_| Box::new(size_of_in_element_count::SizeOfInElementCount));
     store.register_late_pass(|_| Box::new(same_name_method::SameNameMethod));
-    let max_suggested_slice_pattern_length = conf.max_suggested_slice_pattern_length;
     store.register_late_pass(move |_| {
         Box::new(index_refutable_slice::IndexRefutableSlice::new(
             max_suggested_slice_pattern_length,
@@ -647,7 +697,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     });
     store.register_late_pass(|_| Box::<shadow::Shadow>::default());
     store.register_late_pass(|_| Box::new(unit_types::UnitTypes));
-    let enforce_iter_loop_reborrow = conf.enforce_iter_loop_reborrow;
     store.register_late_pass(move |_| Box::new(loops::Loops::new(msrv(), enforce_iter_loop_reborrow)));
     store.register_late_pass(|_| Box::<main_recursion::MainRecursion>::default());
     store.register_late_pass(|_| Box::new(lifetimes::Lifetimes));
@@ -661,13 +710,11 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(no_effect::NoEffect));
     store.register_late_pass(|_| Box::new(temporary_assignment::TemporaryAssignment));
     store.register_late_pass(move |_| Box::new(transmute::Transmute::new(msrv())));
-    let cognitive_complexity_threshold = conf.cognitive_complexity_threshold;
     store.register_late_pass(move |_| {
         Box::new(cognitive_complexity::CognitiveComplexity::new(
             cognitive_complexity_threshold,
         ))
     });
-    let too_large_for_stack = conf.too_large_for_stack;
     store.register_late_pass(move |_| Box::new(escape::BoxedLocal { too_large_for_stack }));
     store.register_late_pass(move |_| {
         Box::new(vec::UselessVec {
@@ -683,18 +730,13 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(empty_enum::EmptyEnum));
     store.register_late_pass(|_| Box::new(invalid_upcast_comparisons::InvalidUpcastComparisons));
     store.register_late_pass(|_| Box::<regex::Regex>::default());
-    let ignore_interior_mutability = conf.ignore_interior_mutability.clone();
     store.register_late_pass(move |_| Box::new(copies::CopyAndPaste::new(ignore_interior_mutability.clone())));
     store.register_late_pass(|_| Box::new(copy_iterator::CopyIterator));
     store.register_late_pass(|_| Box::new(format::UselessFormat));
     store.register_late_pass(|_| Box::new(swap::Swap));
     store.register_late_pass(|_| Box::new(overflow_check_conditional::OverflowCheckConditional));
     store.register_late_pass(|_| Box::<new_without_default::NewWithoutDefault>::default());
-    let disallowed_names = conf.disallowed_names.iter().cloned().collect::<FxHashSet<_>>();
-    store.register_late_pass(move |_| Box::new(disallowed_names::DisallowedNames::new(disallowed_names.clone())));
-    let too_many_arguments_threshold = conf.too_many_arguments_threshold;
-    let too_many_lines_threshold = conf.too_many_lines_threshold;
-    let large_error_threshold = conf.large_error_threshold;
+    store.register_late_pass(move |_| Box::new(disallowed_names::DisallowedNames::new(disallowed_names)));
     store.register_late_pass(move |_| {
         Box::new(functions::Functions::new(
             too_many_arguments_threshold,
@@ -703,9 +745,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
             avoid_breaking_exported_api,
         ))
     });
-    let doc_valid_idents = conf.doc_valid_idents.iter().cloned().collect::<FxHashSet<_>>();
-    let missing_docs_in_crate_items = conf.missing_docs_in_crate_items;
-    store.register_late_pass(move |_| Box::new(doc::DocMarkdown::new(doc_valid_idents.clone())));
+    store.register_late_pass(move |_| Box::new(doc::DocMarkdown::new(doc_valid_idents)));
     store.register_late_pass(|_| Box::new(neg_multiply::NegMultiply));
     store.register_late_pass(|_| Box::new(let_if_seq::LetIfSeq));
     store.register_late_pass(|_| Box::new(mixed_read_write_in_expression::EvalOrderDependence));
@@ -715,17 +755,17 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(match_result_ok::MatchResultOk));
     store.register_late_pass(|_| Box::new(partialeq_ne_impl::PartialEqNeImpl));
     store.register_late_pass(|_| Box::new(unused_io_amount::UnusedIoAmount));
-    let enum_variant_size_threshold = conf.enum_variant_size_threshold;
     store.register_late_pass(move |_| Box::new(large_enum_variant::LargeEnumVariant::new(enum_variant_size_threshold)));
     store.register_late_pass(|_| Box::new(explicit_write::ExplicitWrite));
     store.register_late_pass(|_| Box::new(needless_pass_by_value::NeedlessPassByValue));
-    let pass_by_ref_or_value = pass_by_ref_or_value::PassByRefOrValue::new(
-        conf.trivial_copy_size_limit,
-        conf.pass_by_value_size_limit,
-        conf.avoid_breaking_exported_api,
-        &sess.target,
-    );
-    store.register_late_pass(move |_| Box::new(pass_by_ref_or_value));
+    store.register_late_pass(move |tcx| {
+        Box::new(pass_by_ref_or_value::PassByRefOrValue::new(
+            trivial_copy_size_limit,
+            pass_by_value_size_limit,
+            avoid_breaking_exported_api,
+            tcx.sess.target.pointer_width,
+        ))
+    });
     store.register_late_pass(|_| Box::new(ref_option_ref::RefOptionRef));
     store.register_late_pass(|_| Box::new(infinite_iter::InfiniteIter));
     store.register_late_pass(|_| Box::new(inline_fn_without_body::InlineFnWithoutBody));
@@ -745,7 +785,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
             suppress_restriction_lint_in_const,
         ))
     });
-    let ignore_interior_mutability = conf.ignore_interior_mutability.clone();
     store.register_late_pass(move |_| Box::new(non_copy_const::NonCopyConst::new(ignore_interior_mutability.clone())));
     store.register_late_pass(|_| Box::new(ptr_offset_with_cast::PtrOffsetWithCast));
     store.register_late_pass(|_| Box::new(redundant_clone::RedundantClone));
@@ -754,10 +793,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(assertions_on_constants::AssertionsOnConstants));
     store.register_late_pass(|_| Box::new(assertions_on_result_states::AssertionsOnResultStates));
     store.register_late_pass(|_| Box::new(inherent_to_string::InherentToString));
-    let max_trait_bounds = conf.max_trait_bounds;
     store.register_late_pass(move |_| Box::new(trait_bounds::TraitBounds::new(max_trait_bounds, msrv())));
     store.register_late_pass(|_| Box::new(comparison_chain::ComparisonChain));
-    let ignore_interior_mutability = conf.ignore_interior_mutability.clone();
     store.register_late_pass(move |_| Box::new(mut_key::MutableKeyType::new(ignore_interior_mutability.clone())));
     store.register_early_pass(|| Box::new(reference::DerefAddrOf));
     store.register_early_pass(|| Box::new(double_parens::DoubleParens));
@@ -778,21 +815,16 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_early_pass(|| Box::new(redundant_else::RedundantElse));
     store.register_late_pass(|_| Box::new(create_dir::CreateDir));
     store.register_early_pass(|| Box::new(needless_arbitrary_self_type::NeedlessArbitrarySelfType));
-    let literal_representation_lint_fraction_readability = conf.unreadable_literal_lint_fractions;
     store.register_early_pass(move || {
         Box::new(literal_representation::LiteralDigitGrouping::new(
-            literal_representation_lint_fraction_readability,
+            unreadable_literal_lint_fractions,
         ))
     });
-    let literal_representation_threshold = conf.literal_representation_threshold;
     store.register_early_pass(move || {
         Box::new(literal_representation::DecimalLiteralRepresentation::new(
             literal_representation_threshold,
         ))
     });
-    let enum_variant_name_threshold = conf.enum_variant_name_threshold;
-    let struct_field_name_threshold = conf.struct_field_name_threshold;
-    let allow_private_module_inception = conf.allow_private_module_inception;
     store.register_late_pass(move |_| {
         Box::new(item_name_repetitions::ItemNameRepetitions::new(
             enum_variant_name_threshold,
@@ -802,7 +834,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         ))
     });
     store.register_early_pass(|| Box::new(tabs_in_doc_comments::TabsInDocComments));
-    let upper_case_acronyms_aggressive = conf.upper_case_acronyms_aggressive;
     store.register_late_pass(move |_| {
         Box::new(upper_case_acronyms::UpperCaseAcronyms::new(
             avoid_breaking_exported_api,
@@ -814,15 +845,12 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(mutable_debug_assertion::DebugAssertWithMutCall));
     store.register_late_pass(|_| Box::new(exit::Exit));
     store.register_late_pass(|_| Box::new(to_digit_is_some::ToDigitIsSome));
-    let array_size_threshold = u128::from(conf.array_size_threshold);
-    store.register_late_pass(move |_| Box::new(large_stack_arrays::LargeStackArrays::new(array_size_threshold)));
-    store.register_late_pass(move |_| Box::new(large_const_arrays::LargeConstArrays::new(array_size_threshold)));
+    store.register_late_pass(move |_| Box::new(large_stack_arrays::LargeStackArrays::new(array_size_threshold.into())));
+    store.register_late_pass(move |_| Box::new(large_const_arrays::LargeConstArrays::new(array_size_threshold.into())));
     store.register_late_pass(|_| Box::new(floating_point_arithmetic::FloatingPointArithmetic));
     store.register_late_pass(|_| Box::new(as_conversions::AsConversions));
     store.register_late_pass(|_| Box::new(let_underscore::LetUnderscore));
     store.register_early_pass(|| Box::<single_component_path_imports::SingleComponentPathImports>::default());
-    let max_fn_params_bools = conf.max_fn_params_bools;
-    let max_struct_bools = conf.max_struct_bools;
     store.register_late_pass(move |_| {
         Box::new(excessive_bools::ExcessiveBools::new(
             max_struct_bools,
@@ -830,36 +858,30 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         ))
     });
     store.register_early_pass(|| Box::new(option_env_unwrap::OptionEnvUnwrap));
-    let warn_on_all_wildcard_imports = conf.warn_on_all_wildcard_imports;
     store.register_late_pass(move |_| Box::new(wildcard_imports::WildcardImports::new(warn_on_all_wildcard_imports)));
     store.register_late_pass(|_| Box::<redundant_pub_crate::RedundantPubCrate>::default());
     store.register_late_pass(|_| Box::new(unnamed_address::UnnamedAddress));
     store.register_late_pass(|_| Box::<dereference::Dereferencing<'_>>::default());
     store.register_late_pass(|_| Box::new(option_if_let_else::OptionIfLetElse));
     store.register_late_pass(|_| Box::new(future_not_send::FutureNotSend));
-    let future_size_threshold = conf.future_size_threshold;
     store.register_late_pass(move |_| Box::new(large_futures::LargeFuture::new(future_size_threshold)));
     store.register_late_pass(|_| Box::new(if_let_mutex::IfLetMutex));
     store.register_late_pass(|_| Box::new(if_not_else::IfNotElse));
     store.register_late_pass(|_| Box::new(equatable_if_let::PatternEquality));
     store.register_late_pass(|_| Box::new(manual_async_fn::ManualAsyncFn));
     store.register_late_pass(|_| Box::new(panic_in_result_fn::PanicInResultFn));
-    let single_char_binding_names_threshold = conf.single_char_binding_names_threshold;
     store.register_early_pass(move || {
         Box::new(non_expressive_names::NonExpressiveNames {
             single_char_binding_names_threshold,
         })
     });
-    let macro_matcher = conf.standard_macro_braces.iter().cloned().collect::<FxHashSet<_>>();
-    store.register_early_pass(move || Box::new(nonstandard_macro_braces::MacroBraces::new(&macro_matcher)));
+    store.register_early_pass(move || Box::new(nonstandard_macro_braces::MacroBraces::new(standard_macro_braces)));
     store.register_late_pass(|_| Box::<macro_use::MacroUseImports>::default());
     store.register_late_pass(|_| Box::new(pattern_type_mismatch::PatternTypeMismatch));
     store.register_late_pass(|_| Box::new(unwrap_in_result::UnwrapInResult));
     store.register_late_pass(|_| Box::new(semicolon_if_nothing_returned::SemicolonIfNothingReturned));
     store.register_late_pass(|_| Box::new(async_yields_async::AsyncYieldsAsync));
-    let disallowed_macros = conf.disallowed_macros.clone();
     store.register_late_pass(move |_| Box::new(disallowed_macros::DisallowedMacros::new(disallowed_macros.clone())));
-    let disallowed_methods = conf.disallowed_methods.clone();
     store.register_late_pass(move |_| Box::new(disallowed_methods::DisallowedMethods::new(disallowed_methods.clone())));
     store.register_early_pass(|| Box::new(asm_syntax::InlineAsmX86AttSyntax));
     store.register_early_pass(|| Box::new(asm_syntax::InlineAsmX86IntelSyntax));
@@ -874,36 +896,30 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(bool_assert_comparison::BoolAssertComparison));
     store.register_early_pass(move || Box::new(module_style::ModStyle));
     store.register_late_pass(|_| Box::<unused_async::UnusedAsync>::default());
-    let disallowed_types = conf.disallowed_types.clone();
     store.register_late_pass(move |_| Box::new(disallowed_types::DisallowedTypes::new(disallowed_types.clone())));
-    let import_renames = conf.enforced_import_renames.clone();
     store.register_late_pass(move |_| {
         Box::new(missing_enforced_import_rename::ImportRename::new(
-            import_renames.clone(),
+            enforced_import_renames.clone(),
         ))
     });
-    let scripts = conf.allowed_scripts.clone();
-    store.register_early_pass(move || Box::new(disallowed_script_idents::DisallowedScriptIdents::new(&scripts)));
+    store.register_early_pass(move || Box::new(disallowed_script_idents::DisallowedScriptIdents::new(allowed_scripts)));
     store.register_late_pass(|_| Box::new(strlen_on_c_strings::StrlenOnCStrings));
     store.register_late_pass(move |_| Box::new(self_named_constructors::SelfNamedConstructors));
     store.register_late_pass(move |_| Box::new(iter_not_returning_iterator::IterNotReturningIterator));
     store.register_late_pass(move |_| Box::new(manual_assert::ManualAssert));
-    let enable_raw_pointer_heuristic_for_send = conf.enable_raw_pointer_heuristic_for_send;
     store.register_late_pass(move |_| {
         Box::new(non_send_fields_in_send_ty::NonSendFieldInSendTy::new(
             enable_raw_pointer_heuristic_for_send,
         ))
     });
-    let accept_comment_above_statement = conf.accept_comment_above_statement;
-    let accept_comment_above_attributes = conf.accept_comment_above_attributes;
     store.register_late_pass(move |_| {
         Box::new(undocumented_unsafe_blocks::UndocumentedUnsafeBlocks::new(
             accept_comment_above_statement,
             accept_comment_above_attributes,
         ))
     });
-    let allow_mixed_uninlined = conf.allow_mixed_uninlined_format_args;
-    store.register_late_pass(move |_| Box::new(format_args::FormatArgs::new(msrv(), allow_mixed_uninlined)));
+    store
+        .register_late_pass(move |_| Box::new(format_args::FormatArgs::new(msrv(), allow_mixed_uninlined_format_args)));
     store.register_late_pass(|_| Box::new(trailing_empty_array::TrailingEmptyArray));
     store.register_early_pass(|| Box::new(octal_escapes::OctalEscapes));
     store.register_late_pass(|_| Box::new(needless_late_init::NeedlessLateInit));
@@ -913,11 +929,8 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(move |_| Box::new(manual_bits::ManualBits::new(msrv())));
     store.register_late_pass(|_| Box::new(default_union_representation::DefaultUnionRepresentation));
     store.register_late_pass(|_| Box::<only_used_in_recursion::OnlyUsedInRecursion>::default());
-    let allow_dbg_in_tests = conf.allow_dbg_in_tests;
     store.register_late_pass(move |_| Box::new(dbg_macro::DbgMacro::new(allow_dbg_in_tests)));
-    let allow_print_in_tests = conf.allow_print_in_tests;
     store.register_late_pass(move |_| Box::new(write::Write::new(allow_print_in_tests)));
-    let cargo_ignore_publish = conf.cargo_ignore_publish;
     store.register_late_pass(move |_| {
         Box::new(cargo::Cargo {
             ignore_publish: cargo_ignore_publish,
@@ -928,7 +941,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(unnecessary_owned_empty_strings::UnnecessaryOwnedEmptyStrings));
     store.register_early_pass(|| Box::new(pub_use::PubUse));
     store.register_late_pass(|_| Box::new(format_push_string::FormatPushString));
-    let max_include_file_size = conf.max_include_file_size;
     store.register_late_pass(move |_| Box::new(large_include_file::LargeIncludeFile::new(max_include_file_size)));
     store.register_late_pass(|_| Box::new(strings::TrimSplitWhitespace));
     store.register_late_pass(|_| Box::new(rc_clone_in_vec_init::RcCloneInVecInit));
@@ -941,7 +953,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(default_instead_of_iter_empty::DefaultIterEmpty));
     store.register_late_pass(move |_| Box::new(manual_rem_euclid::ManualRemEuclid::new(msrv())));
     store.register_late_pass(move |_| Box::new(manual_retain::ManualRetain::new(msrv())));
-    let verbose_bit_mask_threshold = conf.verbose_bit_mask_threshold;
     store.register_late_pass(move |_| Box::new(operators::Operators::new(verbose_bit_mask_threshold)));
     store.register_late_pass(|_| Box::<std_instead_of_core::StdReexports>::default());
     store.register_late_pass(move |_| Box::new(instant_subtraction::InstantSubtraction::new(msrv())));
@@ -958,8 +969,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(from_raw_with_void_ptr::FromRawWithVoidPtr));
     store.register_late_pass(|_| Box::new(suspicious_xor_used_as_pow::ConfusingXorAndPow));
     store.register_late_pass(move |_| Box::new(manual_is_ascii_check::ManualIsAsciiCheck::new(msrv())));
-    let semicolon_inside_block_ignore_singleline = conf.semicolon_inside_block_ignore_singleline;
-    let semicolon_outside_block_ignore_multiline = conf.semicolon_outside_block_ignore_multiline;
     store.register_late_pass(move |_| {
         Box::new(semicolon_block::SemicolonBlock::new(
             semicolon_inside_block_ignore_singleline,
@@ -982,7 +991,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(allow_attributes::AllowAttribute));
     store.register_late_pass(move |_| Box::new(manual_main_separator_str::ManualMainSeparatorStr::new(msrv())));
     store.register_late_pass(|_| Box::new(unnecessary_struct_initialization::UnnecessaryStruct));
-    let unnecessary_box_size = conf.unnecessary_box_size;
     store.register_late_pass(move |_| {
         Box::new(unnecessary_box_returns::UnnecessaryBoxReturns::new(
             avoid_breaking_exported_api,
@@ -993,7 +1001,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(tests_outside_test_module::TestsOutsideTestModule));
     store.register_late_pass(|_| Box::new(manual_slice_size_calculation::ManualSliceSizeCalculation));
     store.register_early_pass(|| Box::new(suspicious_doc_comments::SuspiciousDocComments));
-    let excessive_nesting_threshold = conf.excessive_nesting_threshold;
     store.register_early_pass(move || {
         Box::new(excessive_nesting::ExcessiveNesting {
             excessive_nesting_threshold,
@@ -1009,15 +1016,12 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(redundant_type_annotations::RedundantTypeAnnotations));
     store.register_late_pass(|_| Box::new(arc_with_non_send_sync::ArcWithNonSendSync));
     store.register_late_pass(|_| Box::new(needless_if::NeedlessIf));
-    let allowed_idents_below_min_chars = conf.allowed_idents_below_min_chars.clone();
-    let min_ident_chars_threshold = conf.min_ident_chars_threshold;
     store.register_late_pass(move |_| {
         Box::new(min_ident_chars::MinIdentChars {
             allowed_idents_below_min_chars: allowed_idents_below_min_chars.clone(),
             min_ident_chars_threshold,
         })
     });
-    let stack_size_threshold = conf.stack_size_threshold;
     store.register_late_pass(move |_| Box::new(large_stack_frames::LargeStackFrames::new(stack_size_threshold)));
     store.register_late_pass(|_| Box::new(single_range_in_vec_init::SingleRangeInVecInit));
     store.register_late_pass(move |_| {
@@ -1032,10 +1036,9 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
             def_id_to_usage: rustc_data_structures::fx::FxHashMap::default(),
         })
     });
-    let needless_raw_string_hashes_allow_one = conf.allow_one_hash_in_raw_strings;
     store.register_early_pass(move || {
         Box::new(raw_strings::RawStrings {
-            needless_raw_string_hashes_allow_one,
+            allow_one_hash_in_raw_strings,
         })
     });
     store.register_late_pass(|_| Box::new(manual_range_patterns::ManualRangePatterns));
@@ -1044,8 +1047,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|_| Box::new(manual_float_methods::ManualFloatMethods));
     store.register_late_pass(|_| Box::new(four_forward_slashes::FourForwardSlashes));
     store.register_late_pass(|_| Box::new(error_impl_error::ErrorImplError));
-    let absolute_paths_max_segments = conf.absolute_paths_max_segments;
-    let absolute_paths_allowed_crates = conf.absolute_paths_allowed_crates.clone();
     store.register_late_pass(move |_| {
         Box::new(absolute_paths::AbsolutePaths {
             absolute_paths_max_segments,
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index ab376d66966..57c3913944f 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3697,8 +3697,10 @@ impl Methods {
         msrv: Msrv,
         allow_expect_in_tests: bool,
         allow_unwrap_in_tests: bool,
-        allowed_dotfiles: FxHashSet<String>,
+        mut allowed_dotfiles: FxHashSet<String>,
     ) -> Self {
+        allowed_dotfiles.extend(DEFAULT_ALLOWED_DOTFILES.iter().map(ToString::to_string));
+
         Self {
             avoid_breaking_exported_api,
             msrv,
diff --git a/clippy_lints/src/nonstandard_macro_braces.rs b/clippy_lints/src/nonstandard_macro_braces.rs
index 8604fe08e50..1c6a8e16ae2 100644
--- a/clippy_lints/src/nonstandard_macro_braces.rs
+++ b/clippy_lints/src/nonstandard_macro_braces.rs
@@ -33,17 +33,17 @@ declare_clippy_lint! {
 }
 
 /// The (callsite span, (open brace, close brace), source snippet)
-type MacroInfo<'a> = (Span, &'a (String, String), String);
+type MacroInfo = (Span, (char, char), String);
 
-#[derive(Clone, Debug, Default)]
+#[derive(Debug)]
 pub struct MacroBraces {
-    macro_braces: FxHashMap<String, (String, String)>,
+    macro_braces: FxHashMap<String, (char, char)>,
     done: FxHashSet<Span>,
 }
 
 impl MacroBraces {
-    pub fn new(conf: &FxHashSet<MacroMatcher>) -> Self {
-        let macro_braces = macro_braces(conf.clone());
+    pub fn new(conf: &[MacroMatcher]) -> Self {
+        let macro_braces = macro_braces(conf);
         Self {
             macro_braces,
             done: FxHashSet::default(),
@@ -83,7 +83,7 @@ impl EarlyLintPass for MacroBraces {
     }
 }
 
-fn is_offending_macro<'a>(cx: &EarlyContext<'_>, span: Span, mac_braces: &'a MacroBraces) -> Option<MacroInfo<'a>> {
+fn is_offending_macro(cx: &EarlyContext<'_>, span: Span, mac_braces: &MacroBraces) -> Option<MacroInfo> {
     let unnested_or_local = || {
         !span.ctxt().outer_expn_data().call_site.from_expansion()
             || span
@@ -94,7 +94,7 @@ fn is_offending_macro<'a>(cx: &EarlyContext<'_>, span: Span, mac_braces: &'a Mac
     let span_call_site = span.ctxt().outer_expn_data().call_site;
     if let ExpnKind::Macro(MacroKind::Bang, mac_name) = span.ctxt().outer_expn_data().kind
         && let name = mac_name.as_str()
-        && let Some(braces) = mac_braces.macro_braces.get(name)
+        && let Some(&braces) = mac_braces.macro_braces.get(name)
         && let Some(snip) = snippet_opt(cx, span_call_site)
         // we must check only invocation sites
         // https://github.com/rust-lang/rust-clippy/issues/7422
@@ -111,7 +111,7 @@ fn is_offending_macro<'a>(cx: &EarlyContext<'_>, span: Span, mac_braces: &'a Mac
     }
 }
 
-fn emit_help(cx: &EarlyContext<'_>, snip: &str, braces: &(String, String), span: Span) {
+fn emit_help(cx: &EarlyContext<'_>, snip: &str, (open, close): (char, char), span: Span) {
     if let Some((macro_name, macro_args_str)) = snip.split_once('!') {
         let mut macro_args = macro_args_str.trim().to_string();
         // now remove the wrong braces
@@ -123,67 +123,31 @@ fn emit_help(cx: &EarlyContext<'_>, snip: &str, braces: &(String, String), span:
             span,
             &format!("use of irregular braces for `{macro_name}!` macro"),
             "consider writing",
-            format!("{macro_name}!{}{macro_args}{}", braces.0, braces.1),
+            format!("{macro_name}!{open}{macro_args}{close}"),
             Applicability::MachineApplicable,
         );
     }
 }
 
-fn macro_braces(conf: FxHashSet<MacroMatcher>) -> FxHashMap<String, (String, String)> {
-    let mut braces = vec![
-        macro_matcher!(
-            name: "print",
-            braces: ("(", ")"),
-        ),
-        macro_matcher!(
-            name: "println",
-            braces: ("(", ")"),
-        ),
-        macro_matcher!(
-            name: "eprint",
-            braces: ("(", ")"),
-        ),
-        macro_matcher!(
-            name: "eprintln",
-            braces: ("(", ")"),
-        ),
-        macro_matcher!(
-            name: "write",
-            braces: ("(", ")"),
-        ),
-        macro_matcher!(
-            name: "writeln",
-            braces: ("(", ")"),
-        ),
-        macro_matcher!(
-            name: "format",
-            braces: ("(", ")"),
-        ),
-        macro_matcher!(
-            name: "format_args",
-            braces: ("(", ")"),
-        ),
-        macro_matcher!(
-            name: "vec",
-            braces: ("[", "]"),
-        ),
-        macro_matcher!(
-            name: "matches",
-            braces: ("(", ")"),
-        ),
-    ]
-    .into_iter()
-    .collect::<FxHashMap<_, _>>();
+fn macro_braces(conf: &[MacroMatcher]) -> FxHashMap<String, (char, char)> {
+    let mut braces = FxHashMap::from_iter(
+        [
+            ("print", ('(', ')')),
+            ("println", ('(', ')')),
+            ("eprint", ('(', ')')),
+            ("eprintln", ('(', ')')),
+            ("write", ('(', ')')),
+            ("writeln", ('(', ')')),
+            ("format", ('(', ')')),
+            ("format_args", ('(', ')')),
+            ("vec", ('[', ']')),
+            ("matches", ('(', ')')),
+        ]
+        .map(|(k, v)| (k.to_string(), v)),
+    );
     // We want users items to override any existing items
     for it in conf {
-        braces.insert(it.name, it.braces);
+        braces.insert(it.name.clone(), it.braces);
     }
     braces
 }
-
-macro_rules! macro_matcher {
-    (name: $name:expr, braces: ($open:expr, $close:expr) $(,)?) => {
-        ($name.to_owned(), ($open.to_owned(), $close.to_owned()))
-    };
-}
-pub(crate) use macro_matcher;
diff --git a/clippy_lints/src/pass_by_ref_or_value.rs b/clippy_lints/src/pass_by_ref_or_value.rs
index 0f025c16ab5..85cea8db490 100644
--- a/clippy_lints/src/pass_by_ref_or_value.rs
+++ b/clippy_lints/src/pass_by_ref_or_value.rs
@@ -19,7 +19,6 @@ use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::def_id::LocalDefId;
 use rustc_span::{sym, Span};
 use rustc_target::spec::abi::Abi;
-use rustc_target::spec::Target;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -116,10 +115,10 @@ impl<'tcx> PassByRefOrValue {
         ref_min_size: Option<u64>,
         value_max_size: u64,
         avoid_breaking_exported_api: bool,
-        target: &Target,
+        pointer_width: u32,
     ) -> Self {
         let ref_min_size = ref_min_size.unwrap_or_else(|| {
-            let bit_width = u64::from(target.pointer_width);
+            let bit_width = u64::from(pointer_width);
             // Cap the calculated bit width at 32-bits to reduce
             // portability problems between 32 and 64-bit targets
             let bit_width = cmp::min(bit_width, 32);
diff --git a/clippy_lints/src/raw_strings.rs b/clippy_lints/src/raw_strings.rs
index 391c77dbf90..98f5a07da0d 100644
--- a/clippy_lints/src/raw_strings.rs
+++ b/clippy_lints/src/raw_strings.rs
@@ -56,7 +56,7 @@ declare_clippy_lint! {
 impl_lint_pass!(RawStrings => [NEEDLESS_RAW_STRINGS, NEEDLESS_RAW_STRING_HASHES]);
 
 pub struct RawStrings {
-    pub needless_raw_string_hashes_allow_one: bool,
+    pub allow_one_hash_in_raw_strings: bool,
 }
 
 impl EarlyLintPass for RawStrings {
diff --git a/src/driver.rs b/src/driver.rs
index 7bb49d08da6..1ae8ac81695 100644
--- a/src/driver.rs
+++ b/src/driver.rs
@@ -148,7 +148,7 @@ impl rustc_driver::Callbacks for ClippyCallbacks {
             }
 
             let conf = clippy_config::Conf::read(sess, &conf_path);
-            clippy_lints::register_plugins(lint_store, sess, conf);
+            clippy_lints::register_lints(lint_store, conf);
             clippy_lints::register_pre_expansion_lints(lint_store, conf);
             clippy_lints::register_renamed(lint_store);
         }));
-- 
cgit 1.4.1-3-g733a5


From cb90674aed9ec7b6c7bb471d2ec8cc3b36745b79 Mon Sep 17 00:00:00 2001
From: Jacherr <jwc2002@outlook.com>
Date: Sat, 11 Nov 2023 00:20:47 +0000
Subject: add iter_over_hash_type lint

---
 CHANGELOG.md                            |  1 +
 clippy_lints/src/declared_lints.rs      |  1 +
 clippy_lints/src/iter_over_hash_type.rs | 63 +++++++++++++++++++++++++++++++++
 clippy_lints/src/lib.rs                 |  2 ++
 clippy_utils/src/paths.rs               |  3 ++
 tests/ui/iter_over_hash_type.rs         | 44 +++++++++++++++++++++++
 tests/ui/iter_over_hash_type.stderr     | 53 +++++++++++++++++++++++++++
 7 files changed, 167 insertions(+)
 create mode 100644 clippy_lints/src/iter_over_hash_type.rs
 create mode 100644 tests/ui/iter_over_hash_type.rs
 create mode 100644 tests/ui/iter_over_hash_type.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 87a96bdeba6..5448b1267be 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5123,6 +5123,7 @@ Released 2018-09-13
 [`iter_on_empty_collections`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_on_empty_collections
 [`iter_on_single_items`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_on_single_items
 [`iter_out_of_bounds`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_out_of_bounds
+[`iter_over_hash_type`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_over_hash_type
 [`iter_overeager_cloned`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_overeager_cloned
 [`iter_skip_next`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_skip_next
 [`iter_skip_zero`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_skip_zero
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 04dcccede08..b4d5e074cdd 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -230,6 +230,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::items_after_statements::ITEMS_AFTER_STATEMENTS_INFO,
     crate::items_after_test_module::ITEMS_AFTER_TEST_MODULE_INFO,
     crate::iter_not_returning_iterator::ITER_NOT_RETURNING_ITERATOR_INFO,
+    crate::iter_over_hash_type::ITER_OVER_HASH_TYPE_INFO,
     crate::iter_without_into_iter::INTO_ITER_WITHOUT_ITER_INFO,
     crate::iter_without_into_iter::ITER_WITHOUT_INTO_ITER_INFO,
     crate::large_const_arrays::LARGE_CONST_ARRAYS_INFO,
diff --git a/clippy_lints/src/iter_over_hash_type.rs b/clippy_lints/src/iter_over_hash_type.rs
new file mode 100644
index 00000000000..554790ac61b
--- /dev/null
+++ b/clippy_lints/src/iter_over_hash_type.rs
@@ -0,0 +1,63 @@
+use clippy_utils::paths::{HASHMAP_KEYS, HASHMAP_VALUES, HASHSET_ITER_TY};
+use clippy_utils::{diagnostics::span_lint, match_def_path};
+use clippy_utils::higher::ForLoop;
+use clippy_utils::ty::is_type_diagnostic_item;
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::sym;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// This is a restriction lint which prevents the use of hash types (i.e., `HashSet` and `HashMap`) in for loops.
+    ///
+    /// ### Why is this bad?
+    /// Because hash types are unordered, when iterated through such as in a for loop, the values are returned in
+    /// a pseudo-random order. As a result, on redundant systems this may cause inconsistencies and anomalies.
+    /// In addition, the unknown order of the elements may reduce readability or introduce other undesired
+    /// side effects.
+    ///
+    /// ### Example
+    /// ```no_run
+    ///     let my_map = new Hashmap<i32, String>();
+    ///     for (key, value) in my_map { /* ... */ }
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    ///     let my_map = new Hashmap<i32, String>();
+    ///     let mut keys = my_map.keys().clone().collect::<Vec<_>();
+    ///     keys.sort();
+    ///     for key in keys {
+    ///         let value = &my_map[value];
+    ///     }
+    /// ```
+    #[clippy::version = "1.75.0"]
+    pub ITER_OVER_HASH_TYPE,
+    restriction,
+    "iterating over unordered hash-based types (`HashMap` and `HashSet`)"
+}
+
+declare_lint_pass!(IterOverHashType => [ITER_OVER_HASH_TYPE]);
+
+impl LateLintPass<'_> for IterOverHashType {
+    fn check_expr(&mut self, cx: &LateContext<'_>, expr: &'_ rustc_hir::Expr<'_>) {
+        if let Some(for_loop) = ForLoop::hir(expr)
+            && !for_loop.body.span.from_expansion()
+            && let ty = cx.typeck_results().expr_ty(for_loop.arg).peel_refs()
+            && let Some(adt) = ty.ty_adt_def()
+            && let did = adt.did()
+            && (match_def_path(cx, did, &HASHMAP_KEYS) 
+                || match_def_path(cx, did, &HASHMAP_VALUES)
+                || match_def_path(cx, did, &HASHSET_ITER_TY)
+                || is_type_diagnostic_item(cx, ty, sym::HashMap) 
+                || is_type_diagnostic_item(cx, ty, sym::HashSet))
+        {
+            span_lint(
+                cx,
+                ITER_OVER_HASH_TYPE,
+                expr.span,
+                "iterating over unordered hash-based type",
+            );
+        };
+    }
+}
+
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index e5f8bd5c471..9bdf6b0224d 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -165,6 +165,7 @@ mod item_name_repetitions;
 mod items_after_statements;
 mod items_after_test_module;
 mod iter_not_returning_iterator;
+mod iter_over_hash_type;
 mod iter_without_into_iter;
 mod large_const_arrays;
 mod large_enum_variant;
@@ -1065,6 +1066,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     });
     store.register_late_pass(move |_| Box::new(manual_hash_one::ManualHashOne::new(msrv())));
     store.register_late_pass(|_| Box::new(iter_without_into_iter::IterWithoutIntoIter));
+    store.register_late_pass(|_| Box::new(iter_over_hash_type::IterOverHashType));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index 859bffd6c9c..9c9fb381e54 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -32,6 +32,9 @@ pub const FUTURES_IO_ASYNCREADEXT: [&str; 3] = ["futures_util", "io", "AsyncRead
 pub const FUTURES_IO_ASYNCWRITEEXT: [&str; 3] = ["futures_util", "io", "AsyncWriteExt"];
 pub const HASHMAP_CONTAINS_KEY: [&str; 6] = ["std", "collections", "hash", "map", "HashMap", "contains_key"];
 pub const HASHMAP_INSERT: [&str; 6] = ["std", "collections", "hash", "map", "HashMap", "insert"];
+pub const HASHMAP_KEYS: [&str; 5] = ["std", "collections", "hash", "map", "Keys"];
+pub const HASHMAP_VALUES: [&str; 5] = ["std", "collections", "hash", "map", "Values"];
+pub const HASHSET_ITER_TY: [&str; 5] = ["std", "collections", "hash", "set", "Iter"];
 pub const HASHSET_ITER: [&str; 6] = ["std", "collections", "hash", "set", "HashSet", "iter"];
 pub const IDENT: [&str; 3] = ["rustc_span", "symbol", "Ident"];
 pub const IDENT_AS_STR: [&str; 4] = ["rustc_span", "symbol", "Ident", "as_str"];
diff --git a/tests/ui/iter_over_hash_type.rs b/tests/ui/iter_over_hash_type.rs
new file mode 100644
index 00000000000..fc340abf146
--- /dev/null
+++ b/tests/ui/iter_over_hash_type.rs
@@ -0,0 +1,44 @@
+//@aux-build:proc_macros.rs
+
+#![warn(clippy::iter_over_hash_type)]
+use std::collections::{HashMap, HashSet};
+
+extern crate proc_macros;
+
+fn main() {
+    let hash_set = HashSet::<i32>::new();
+    let hash_map = HashMap::<i32, i32>::new();
+    let vec = Vec::<i32>::new();
+
+    for x in &hash_set {
+        let _ = x;
+    }
+    for x in hash_set.iter() {
+        let _ = x;
+    }
+    for x in hash_set {
+        let _ = x;
+    }
+    for (x, y) in &hash_map {
+        let _ = (x, y);
+    }
+    for x in hash_map.keys() {
+        let _ = x;
+    }
+    for x in hash_map.values() {
+        let _ = x;
+    }
+
+    // shouldnt fire
+    for x in &vec {
+        let _ = x;
+    }
+    for x in vec {
+        let _ = x;
+    }
+
+    // should not lint, this comes from an external crate
+    proc_macros::external! {
+      for _ in HashMap::<i32, i32>::new() {}
+    }
+}
diff --git a/tests/ui/iter_over_hash_type.stderr b/tests/ui/iter_over_hash_type.stderr
new file mode 100644
index 00000000000..72d621c7b59
--- /dev/null
+++ b/tests/ui/iter_over_hash_type.stderr
@@ -0,0 +1,53 @@
+error: iterating over unordered hash-based type
+  --> $DIR/iter_over_hash_type.rs:13:5
+   |
+LL | /     for x in &hash_set {
+LL | |         let _ = x;
+LL | |     }
+   | |_____^
+   |
+   = note: `-D clippy::iter-over-hash-type` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::iter_over_hash_type)]`
+
+error: iterating over unordered hash-based type
+  --> $DIR/iter_over_hash_type.rs:16:5
+   |
+LL | /     for x in hash_set.iter() {
+LL | |         let _ = x;
+LL | |     }
+   | |_____^
+
+error: iterating over unordered hash-based type
+  --> $DIR/iter_over_hash_type.rs:19:5
+   |
+LL | /     for x in hash_set {
+LL | |         let _ = x;
+LL | |     }
+   | |_____^
+
+error: iterating over unordered hash-based type
+  --> $DIR/iter_over_hash_type.rs:22:5
+   |
+LL | /     for (x, y) in &hash_map {
+LL | |         let _ = (x, y);
+LL | |     }
+   | |_____^
+
+error: iterating over unordered hash-based type
+  --> $DIR/iter_over_hash_type.rs:25:5
+   |
+LL | /     for x in hash_map.keys() {
+LL | |         let _ = x;
+LL | |     }
+   | |_____^
+
+error: iterating over unordered hash-based type
+  --> $DIR/iter_over_hash_type.rs:28:5
+   |
+LL | /     for x in hash_map.values() {
+LL | |         let _ = x;
+LL | |     }
+   | |_____^
+
+error: aborting due to 6 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 7bc39f3af855868705b697888383ce00eb6d1bf4 Mon Sep 17 00:00:00 2001
From: Jacherr <jwc2002@outlook.com>
Date: Sat, 11 Nov 2023 00:21:35 +0000
Subject: format and fix examples

---
 clippy_lints/src/iter_over_hash_type.rs | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/iter_over_hash_type.rs b/clippy_lints/src/iter_over_hash_type.rs
index 554790ac61b..607d8e5fc28 100644
--- a/clippy_lints/src/iter_over_hash_type.rs
+++ b/clippy_lints/src/iter_over_hash_type.rs
@@ -1,6 +1,7 @@
-use clippy_utils::paths::{HASHMAP_KEYS, HASHMAP_VALUES, HASHSET_ITER_TY};
-use clippy_utils::{diagnostics::span_lint, match_def_path};
+use clippy_utils::diagnostics::span_lint;
 use clippy_utils::higher::ForLoop;
+use clippy_utils::match_def_path;
+use clippy_utils::paths::{HASHMAP_KEYS, HASHMAP_VALUES, HASHSET_ITER_TY};
 use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -18,16 +19,16 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```no_run
-    ///     let my_map = new Hashmap<i32, String>();
+    ///     let my_map = std::collections::HashMap::<i32, String>::new();
     ///     for (key, value) in my_map { /* ... */ }
     /// ```
     /// Use instead:
     /// ```no_run
-    ///     let my_map = new Hashmap<i32, String>();
-    ///     let mut keys = my_map.keys().clone().collect::<Vec<_>();
+    ///     let my_map = std::collections::HashMap::<i32, String>::new();
+    ///     let mut keys = my_map.keys().clone().collect::<Vec<_>>();
     ///     keys.sort();
     ///     for key in keys {
-    ///         let value = &my_map[value];
+    ///         let value = &my_map[key];
     ///     }
     /// ```
     #[clippy::version = "1.75.0"]
@@ -45,10 +46,10 @@ impl LateLintPass<'_> for IterOverHashType {
             && let ty = cx.typeck_results().expr_ty(for_loop.arg).peel_refs()
             && let Some(adt) = ty.ty_adt_def()
             && let did = adt.did()
-            && (match_def_path(cx, did, &HASHMAP_KEYS) 
+            && (match_def_path(cx, did, &HASHMAP_KEYS)
                 || match_def_path(cx, did, &HASHMAP_VALUES)
                 || match_def_path(cx, did, &HASHSET_ITER_TY)
-                || is_type_diagnostic_item(cx, ty, sym::HashMap) 
+                || is_type_diagnostic_item(cx, ty, sym::HashMap)
                 || is_type_diagnostic_item(cx, ty, sym::HashSet))
         {
             span_lint(
@@ -60,4 +61,3 @@ impl LateLintPass<'_> for IterOverHashType {
         };
     }
 }
-
-- 
cgit 1.4.1-3-g733a5


From a68cd88860fc9d25223416bb10782a70d556dca7 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Thu, 14 Sep 2023 12:41:16 -0400
Subject: Lint `needless_borrow` on most union field accesses

---
 clippy_lints/src/dereference.rs | 21 +++++++++++++++--
 tests/ui/needless_borrow.fixed  | 51 +++++++++++++++++++++++++++++------------
 tests/ui/needless_borrow.rs     | 51 +++++++++++++++++++++++++++++------------
 tests/ui/needless_borrow.stderr | 26 ++++++++++++++++++++-
 4 files changed, 116 insertions(+), 33 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index 6c109a51f83..5371704f66e 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -5,6 +5,7 @@ use clippy_utils::ty::{implements_trait, peel_mid_ty_refs};
 use clippy_utils::{
     expr_use_ctxt, get_parent_expr, get_parent_node, is_lint_allowed, path_to_local, DefinedTy, ExprUseNode,
 };
+use core::mem;
 use rustc_ast::util::parser::{PREC_POSTFIX, PREC_PREFIX};
 use rustc_data_structures::fx::FxIndexMap;
 use rustc_errors::Applicability;
@@ -342,8 +343,24 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing<'tcx> {
                             TyCoercionStability::for_defined_ty(cx, ty, use_cx.node.is_return())
                         });
                         let can_auto_borrow = match use_cx.node {
-                            ExprUseNode::Callee => true,
-                            ExprUseNode::FieldAccess(_) => adjusted_ty.ty_adt_def().map_or(true, |adt| !adt.is_union()),
+                            ExprUseNode::FieldAccess(_)
+                                if !use_cx.moved_before_use && matches!(sub_expr.kind, ExprKind::Field(..)) =>
+                            {
+                                // `ManuallyDrop` fields of a union will not automatically call
+                                // `deref_mut` when accessing a field.
+                                // Note: if the `ManuallyDrop` value is not directly a field of a
+                                // union then `DerefMut` will work as normal.
+                                //
+                                // This means we need to not modify an expression such as `(&mut x.y).z`
+                                // if accessing `z` would require `DerefMut`.
+                                let mut ty = expr_ty;
+                                !use_cx.adjustments.iter().any(|a| {
+                                    let ty = mem::replace(&mut ty, a.target);
+                                    matches!(a.kind, Adjust::Deref(Some(ref op)) if op.mutbl == Mutability::Mut)
+                                        && ty.ty_adt_def().map_or(false, |def| def.is_manually_drop())
+                                })
+                            },
+                            ExprUseNode::Callee | ExprUseNode::FieldAccess(_) => true,
                             ExprUseNode::MethodArg(hir_id, _, 0) if !use_cx.moved_before_use => {
                                 // Check for calls to trait methods where the trait is implemented
                                 // on a reference.
diff --git a/tests/ui/needless_borrow.fixed b/tests/ui/needless_borrow.fixed
index c2c5f765abf..ff1e2dc8875 100644
--- a/tests/ui/needless_borrow.fixed
+++ b/tests/ui/needless_borrow.fixed
@@ -190,27 +190,48 @@ fn issue9383() {
     // Should not lint because unions need explicit deref when accessing field
     use std::mem::ManuallyDrop;
 
-    union Coral {
-        crab: ManuallyDrop<Vec<i32>>,
+    #[derive(Clone, Copy)]
+    struct Wrap<T>(T);
+    impl<T> core::ops::Deref for Wrap<T> {
+        type Target = T;
+        fn deref(&self) -> &T {
+            &self.0
+        }
+    }
+    impl<T> core::ops::DerefMut for Wrap<T> {
+        fn deref_mut(&mut self) -> &mut T {
+            &mut self.0
+        }
     }
 
-    union Ocean {
-        coral: ManuallyDrop<Coral>,
+    union U<T: Copy> {
+        u: T,
     }
 
-    let mut ocean = Ocean {
-        coral: ManuallyDrop::new(Coral {
-            crab: ManuallyDrop::new(vec![1, 2, 3]),
-        }),
-    };
+    #[derive(Clone, Copy)]
+    struct Foo {
+        x: u32,
+    }
 
     unsafe {
-        ManuallyDrop::drop(&mut (&mut ocean.coral).crab);
-
-        (*ocean.coral).crab = ManuallyDrop::new(vec![4, 5, 6]);
-        ManuallyDrop::drop(&mut (*ocean.coral).crab);
-
-        ManuallyDrop::drop(&mut ocean.coral);
+        let mut x = U {
+            u: ManuallyDrop::new(Foo { x: 0 }),
+        };
+        let _ = &mut (&mut x.u).x;
+        let _ = &mut { x.u }.x;
+        let _ = &mut ({ &mut x.u }).x;
+
+        let mut x = U {
+            u: Wrap(ManuallyDrop::new(Foo { x: 0 })),
+        };
+        let _ = &mut (&mut x.u).x;
+        let _ = &mut { x.u }.x;
+        let _ = &mut ({ &mut x.u }).x;
+
+        let mut x = U { u: Wrap(Foo { x: 0 }) };
+        let _ = &mut x.u.x;
+        let _ = &mut { x.u }.x;
+        let _ = &mut ({ &mut x.u }).x;
     }
 }
 
diff --git a/tests/ui/needless_borrow.rs b/tests/ui/needless_borrow.rs
index 0cd6e41b8a4..597021539ac 100644
--- a/tests/ui/needless_borrow.rs
+++ b/tests/ui/needless_borrow.rs
@@ -190,27 +190,48 @@ fn issue9383() {
     // Should not lint because unions need explicit deref when accessing field
     use std::mem::ManuallyDrop;
 
-    union Coral {
-        crab: ManuallyDrop<Vec<i32>>,
+    #[derive(Clone, Copy)]
+    struct Wrap<T>(T);
+    impl<T> core::ops::Deref for Wrap<T> {
+        type Target = T;
+        fn deref(&self) -> &T {
+            &self.0
+        }
+    }
+    impl<T> core::ops::DerefMut for Wrap<T> {
+        fn deref_mut(&mut self) -> &mut T {
+            &mut self.0
+        }
     }
 
-    union Ocean {
-        coral: ManuallyDrop<Coral>,
+    union U<T: Copy> {
+        u: T,
     }
 
-    let mut ocean = Ocean {
-        coral: ManuallyDrop::new(Coral {
-            crab: ManuallyDrop::new(vec![1, 2, 3]),
-        }),
-    };
+    #[derive(Clone, Copy)]
+    struct Foo {
+        x: u32,
+    }
 
     unsafe {
-        ManuallyDrop::drop(&mut (&mut ocean.coral).crab);
-
-        (*ocean.coral).crab = ManuallyDrop::new(vec![4, 5, 6]);
-        ManuallyDrop::drop(&mut (*ocean.coral).crab);
-
-        ManuallyDrop::drop(&mut ocean.coral);
+        let mut x = U {
+            u: ManuallyDrop::new(Foo { x: 0 }),
+        };
+        let _ = &mut (&mut x.u).x;
+        let _ = &mut (&mut { x.u }).x;
+        let _ = &mut ({ &mut x.u }).x;
+
+        let mut x = U {
+            u: Wrap(ManuallyDrop::new(Foo { x: 0 })),
+        };
+        let _ = &mut (&mut x.u).x;
+        let _ = &mut (&mut { x.u }).x;
+        let _ = &mut ({ &mut x.u }).x;
+
+        let mut x = U { u: Wrap(Foo { x: 0 }) };
+        let _ = &mut (&mut x.u).x;
+        let _ = &mut (&mut { x.u }).x;
+        let _ = &mut ({ &mut x.u }).x;
     }
 }
 
diff --git a/tests/ui/needless_borrow.stderr b/tests/ui/needless_borrow.stderr
index e91b78b0a15..44552ee6abe 100644
--- a/tests/ui/needless_borrow.stderr
+++ b/tests/ui/needless_borrow.stderr
@@ -133,5 +133,29 @@ error: this expression borrows a value the compiler would automatically borrow
 LL |             (&mut self.f)()
    |             ^^^^^^^^^^^^^ help: change this to: `(self.f)`
 
-error: aborting due to 22 previous errors
+error: this expression borrows a value the compiler would automatically borrow
+  --> $DIR/needless_borrow.rs:221:22
+   |
+LL |         let _ = &mut (&mut { x.u }).x;
+   |                      ^^^^^^^^^^^^^^ help: change this to: `{ x.u }`
+
+error: this expression borrows a value the compiler would automatically borrow
+  --> $DIR/needless_borrow.rs:228:22
+   |
+LL |         let _ = &mut (&mut { x.u }).x;
+   |                      ^^^^^^^^^^^^^^ help: change this to: `{ x.u }`
+
+error: this expression borrows a value the compiler would automatically borrow
+  --> $DIR/needless_borrow.rs:232:22
+   |
+LL |         let _ = &mut (&mut x.u).x;
+   |                      ^^^^^^^^^^ help: change this to: `x.u`
+
+error: this expression borrows a value the compiler would automatically borrow
+  --> $DIR/needless_borrow.rs:233:22
+   |
+LL |         let _ = &mut (&mut { x.u }).x;
+   |                      ^^^^^^^^^^^^^^ help: change this to: `{ x.u }`
+
+error: aborting due to 26 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 4dead776e196832320f0c49a6e6d779934b97193 Mon Sep 17 00:00:00 2001
From: Matthias Richter <matthias.ri97@gmail.com>
Date: Tue, 7 Nov 2023 16:01:52 +0100
Subject: add type details to unnecessary_fallible_conversions note

---
 .../methods/unnecessary_fallible_conversions.rs    | 38 ++++++++++++++++------
 tests/ui/unnecessary_fallible_conversions.stderr   |  3 ++
 ...necessary_fallible_conversions_unfixable.stderr | 11 +++++++
 3 files changed, 42 insertions(+), 10 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/unnecessary_fallible_conversions.rs b/clippy_lints/src/methods/unnecessary_fallible_conversions.rs
index bb32b1bb7fc..89cf20c14fc 100644
--- a/clippy_lints/src/methods/unnecessary_fallible_conversions.rs
+++ b/clippy_lints/src/methods/unnecessary_fallible_conversions.rs
@@ -1,10 +1,11 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::get_parent_expr;
 use clippy_utils::ty::implements_trait;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::LateContext;
 use rustc_middle::ty;
+use rustc_middle::ty::print::with_forced_trimmed_paths;
 use rustc_span::{sym, Span};
 
 use super::UNNECESSARY_FALLIBLE_CONVERSIONS;
@@ -42,6 +43,7 @@ fn check<'tcx>(
         // (else there would be conflicting impls, even with #![feature(spec)]), so we don't even need to check
         // what `<T as TryFrom<U>>::Error` is: it's always `Infallible`
         && implements_trait(cx, self_ty, from_into_trait, &[other_ty])
+        && let Some(other_ty) = other_ty.as_type()
     {
         let parent_unwrap_call = get_parent_expr(cx, expr).and_then(|parent| {
             if let ExprKind::MethodCall(path, .., span) = parent.kind
@@ -52,8 +54,7 @@ fn check<'tcx>(
                 None
             }
         });
-
-        let (sugg, span, applicability) = match kind {
+        let (source_ty, target_ty, sugg, span, applicability) = match kind {
             FunctionKind::TryIntoMethod if let Some(unwrap_span) = parent_unwrap_call => {
                 // Extend the span to include the unwrap/expect call:
                 // `foo.try_into().expect("..")`
@@ -63,24 +64,41 @@ fn check<'tcx>(
                 // so that can be machine-applicable
 
                 (
+                    self_ty,
+                    other_ty,
                     "into()",
                     primary_span.with_hi(unwrap_span.hi()),
                     Applicability::MachineApplicable,
                 )
             },
-            FunctionKind::TryFromFunction => ("From::from", primary_span, Applicability::Unspecified),
-            FunctionKind::TryIntoFunction => ("Into::into", primary_span, Applicability::Unspecified),
-            FunctionKind::TryIntoMethod => ("into", primary_span, Applicability::Unspecified),
+            FunctionKind::TryFromFunction => (
+                other_ty,
+                self_ty,
+                "From::from",
+                primary_span,
+                Applicability::Unspecified,
+            ),
+            FunctionKind::TryIntoFunction => (
+                self_ty,
+                other_ty,
+                "Into::into",
+                primary_span,
+                Applicability::Unspecified,
+            ),
+            FunctionKind::TryIntoMethod => (self_ty, other_ty, "into", primary_span, Applicability::Unspecified),
         };
 
-        span_lint_and_sugg(
+        span_lint_and_then(
             cx,
             UNNECESSARY_FALLIBLE_CONVERSIONS,
             span,
             "use of a fallible conversion when an infallible one could be used",
-            "use",
-            sugg.into(),
-            applicability,
+            |diag| {
+                with_forced_trimmed_paths!({
+                    diag.note(format!("converting `{source_ty}` to `{target_ty}` cannot fail"));
+                });
+                diag.span_suggestion(span, "use", sugg, applicability);
+            },
         );
     }
 }
diff --git a/tests/ui/unnecessary_fallible_conversions.stderr b/tests/ui/unnecessary_fallible_conversions.stderr
index b918fdf774b..26b152515ac 100644
--- a/tests/ui/unnecessary_fallible_conversions.stderr
+++ b/tests/ui/unnecessary_fallible_conversions.stderr
@@ -4,6 +4,7 @@ error: use of a fallible conversion when an infallible one could be used
 LL |     let _: i64 = 0i32.try_into().unwrap();
    |                       ^^^^^^^^^^^^^^^^^^^ help: use: `into()`
    |
+   = note: converting `i32` to `i64` cannot fail
    = note: `-D clippy::unnecessary-fallible-conversions` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::unnecessary_fallible_conversions)]`
 
@@ -12,6 +13,8 @@ error: use of a fallible conversion when an infallible one could be used
    |
 LL |     let _: i64 = 0i32.try_into().expect("can't happen");
    |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `into()`
+   |
+   = note: converting `i32` to `i64` cannot fail
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/unnecessary_fallible_conversions_unfixable.stderr b/tests/ui/unnecessary_fallible_conversions_unfixable.stderr
index 286decf8f35..033de0e9250 100644
--- a/tests/ui/unnecessary_fallible_conversions_unfixable.stderr
+++ b/tests/ui/unnecessary_fallible_conversions_unfixable.stderr
@@ -4,6 +4,7 @@ error: use of a fallible conversion when an infallible one could be used
 LL |     let _: Result<Foo, _> = 0i64.try_into();
    |                                  ^^^^^^^^ help: use: `into`
    |
+   = note: converting `i64` to `Foo` cannot fail
    = note: `-D clippy::unnecessary-fallible-conversions` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::unnecessary_fallible_conversions)]`
 
@@ -12,30 +13,40 @@ error: use of a fallible conversion when an infallible one could be used
    |
 LL |     let _: Result<Foo, _> = i64::try_into(0i64);
    |                             ^^^^^^^^^^^^^ help: use: `Into::into`
+   |
+   = note: converting `i64` to `Foo` cannot fail
 
 error: use of a fallible conversion when an infallible one could be used
   --> $DIR/unnecessary_fallible_conversions_unfixable.rs:31:29
    |
 LL |     let _: Result<Foo, _> = Foo::try_from(0i64);
    |                             ^^^^^^^^^^^^^ help: use: `From::from`
+   |
+   = note: converting `i64` to `Foo` cannot fail
 
 error: use of a fallible conversion when an infallible one could be used
   --> $DIR/unnecessary_fallible_conversions_unfixable.rs:34:34
    |
 LL |     let _: Result<i64, _> = 0i32.try_into();
    |                                  ^^^^^^^^ help: use: `into`
+   |
+   = note: converting `i32` to `i64` cannot fail
 
 error: use of a fallible conversion when an infallible one could be used
   --> $DIR/unnecessary_fallible_conversions_unfixable.rs:36:29
    |
 LL |     let _: Result<i64, _> = i32::try_into(0i32);
    |                             ^^^^^^^^^^^^^ help: use: `Into::into`
+   |
+   = note: converting `i32` to `i64` cannot fail
 
 error: use of a fallible conversion when an infallible one could be used
   --> $DIR/unnecessary_fallible_conversions_unfixable.rs:38:29
    |
 LL |     let _: Result<i64, _> = <_>::try_from(0i32);
    |                             ^^^^^^^^^^^^^ help: use: `From::from`
+   |
+   = note: converting `i32` to `i64` cannot fail
 
 error: aborting due to 6 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 1a01132417b7068e9c7baaeef4246210427869bf Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Fri, 15 Sep 2023 01:48:57 -0400
Subject: Lint `explicit_auto_deref` on most union field accesses.

---
 clippy_lints/src/dereference.rs     | 250 +++++++++++++++++++++---------------
 clippy_utils/src/ty.rs              |   5 +
 tests/ui/explicit_auto_deref.fixed  |  45 +++++--
 tests/ui/explicit_auto_deref.rs     |  45 +++++--
 tests/ui/explicit_auto_deref.stderr |  32 ++++-
 5 files changed, 248 insertions(+), 129 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index 5371704f66e..63d2f0ce226 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_hir_and_then};
 use clippy_utils::source::{snippet_with_applicability, snippet_with_context};
 use clippy_utils::sugg::has_enclosing_paren;
-use clippy_utils::ty::{implements_trait, peel_mid_ty_refs};
+use clippy_utils::ty::{implements_trait, is_manually_drop, peel_mid_ty_refs};
 use clippy_utils::{
     expr_use_ctxt, get_parent_expr, get_parent_node, is_lint_allowed, path_to_local, DefinedTy, ExprUseNode,
 };
@@ -171,9 +171,7 @@ pub struct Dereferencing<'tcx> {
 
 #[derive(Debug)]
 struct StateData<'tcx> {
-    /// Span of the top level expression
-    span: Span,
-    hir_id: HirId,
+    first_expr: &'tcx Expr<'tcx>,
     adjusted_ty: Ty<'tcx>,
 }
 
@@ -199,6 +197,7 @@ enum State {
     },
     ExplicitDerefField {
         name: Symbol,
+        derefs_manually_drop: bool,
     },
     Reborrow {
         mutability: Mutability,
@@ -243,7 +242,7 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing<'tcx> {
         // Stop processing sub expressions when a macro call is seen
         if expr.span.from_expansion() {
             if let Some((state, data)) = self.state.take() {
-                report(cx, expr, state, data);
+                report(cx, expr, state, data, cx.typeck_results());
             }
             return;
         }
@@ -252,7 +251,7 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing<'tcx> {
         let Some((kind, sub_expr)) = try_parse_ref_op(cx.tcx, typeck, expr) else {
             // The whole chain of reference operations has been seen
             if let Some((state, data)) = self.state.take() {
-                report(cx, expr, state, data);
+                report(cx, expr, state, data, typeck);
             }
             return;
         };
@@ -273,14 +272,16 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing<'tcx> {
                     (Some(use_cx), RefOp::Deref) => {
                         let sub_ty = typeck.expr_ty(sub_expr);
                         if let ExprUseNode::FieldAccess(name) = use_cx.node
-                            && adjusted_ty.ty_adt_def().map_or(true, |adt| !adt.is_union())
+                            && !use_cx.moved_before_use
                             && !ty_contains_field(sub_ty, name.name)
                         {
                             self.state = Some((
-                                State::ExplicitDerefField { name: name.name },
+                                State::ExplicitDerefField {
+                                    name: name.name,
+                                    derefs_manually_drop: is_manually_drop(sub_ty),
+                                },
                                 StateData {
-                                    span: expr.span,
-                                    hir_id: expr.hir_id,
+                                    first_expr: expr,
                                     adjusted_ty,
                                 },
                             ));
@@ -294,8 +295,7 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing<'tcx> {
                             self.state = Some((
                                 State::ExplicitDeref { mutability: None },
                                 StateData {
-                                    span: expr.span,
-                                    hir_id: expr.hir_id,
+                                    first_expr: expr,
                                     adjusted_ty,
                                 },
                             ));
@@ -314,8 +314,7 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing<'tcx> {
                                 mutbl,
                             },
                             StateData {
-                                span: expr.span,
-                                hir_id: expr.hir_id,
+                                first_expr: expr,
                                 adjusted_ty,
                             },
                         ));
@@ -346,19 +345,13 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing<'tcx> {
                             ExprUseNode::FieldAccess(_)
                                 if !use_cx.moved_before_use && matches!(sub_expr.kind, ExprKind::Field(..)) =>
                             {
-                                // `ManuallyDrop` fields of a union will not automatically call
-                                // `deref_mut` when accessing a field.
-                                // Note: if the `ManuallyDrop` value is not directly a field of a
-                                // union then `DerefMut` will work as normal.
+                                // `DerefMut` will not be automatically applied to `ManuallyDrop<_>`
+                                // field expressions when the base type is a union and the parent
+                                // expression is also a field access.
                                 //
-                                // This means we need to not modify an expression such as `(&mut x.y).z`
-                                // if accessing `z` would require `DerefMut`.
-                                let mut ty = expr_ty;
-                                !use_cx.adjustments.iter().any(|a| {
-                                    let ty = mem::replace(&mut ty, a.target);
-                                    matches!(a.kind, Adjust::Deref(Some(ref op)) if op.mutbl == Mutability::Mut)
-                                        && ty.ty_adt_def().map_or(false, |def| def.is_manually_drop())
-                                })
+                                // e.g. `&mut x.y.z` where `x` is a union, and accessing `z` requires a
+                                // deref through `ManuallyDrop<_>` will not compile.
+                                !adjust_derefs_manually_drop(use_cx.adjustments, expr_ty)
                             },
                             ExprUseNode::Callee | ExprUseNode::FieldAccess(_) => true,
                             ExprUseNode::MethodArg(hir_id, _, 0) if !use_cx.moved_before_use => {
@@ -374,11 +367,8 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing<'tcx> {
                                         .tcx
                                         .erase_regions(use_cx.adjustments.last().map_or(expr_ty, |a| a.target))
                                     && let ty::Ref(_, sub_ty, _) = *arg_ty.kind()
-                                    && let args = cx
-                                        .typeck_results()
-                                        .node_args_opt(hir_id)
-                                        .map(|args| &args[1..])
-                                        .unwrap_or_default()
+                                    && let args =
+                                        typeck.node_args_opt(hir_id).map(|args| &args[1..]).unwrap_or_default()
                                     && let impl_ty =
                                         if cx.tcx.fn_sig(fn_id).instantiate_identity().skip_binder().inputs()[0]
                                             .is_ref()
@@ -453,14 +443,16 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing<'tcx> {
                                     count: deref_count - required_refs,
                                     msg,
                                     stability,
-                                    for_field_access: match use_cx.node {
-                                        ExprUseNode::FieldAccess(name) => Some(name.name),
-                                        _ => None,
+                                    for_field_access: if let ExprUseNode::FieldAccess(name) = use_cx.node
+                                        && !use_cx.moved_before_use
+                                    {
+                                        Some(name.name)
+                                    } else {
+                                        None
                                     },
                                 }),
                                 StateData {
-                                    span: expr.span,
-                                    hir_id: expr.hir_id,
+                                    first_expr: expr,
                                     adjusted_ty: use_cx.adjustments.last().map_or(expr_ty, |a| a.target),
                                 },
                             ));
@@ -472,8 +464,7 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing<'tcx> {
                             self.state = Some((
                                 State::Borrow { mutability },
                                 StateData {
-                                    span: expr.span,
-                                    hir_id: expr.hir_id,
+                                    first_expr: expr,
                                     adjusted_ty: use_cx.adjustments.last().map_or(expr_ty, |a| a.target),
                                 },
                             ));
@@ -518,13 +509,12 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing<'tcx> {
             (Some((State::DerefedBorrow(state), data)), RefOp::AddrOf(mutability)) => {
                 let adjusted_ty = data.adjusted_ty;
                 let stability = state.stability;
-                report(cx, expr, State::DerefedBorrow(state), data);
+                report(cx, expr, State::DerefedBorrow(state), data, typeck);
                 if stability.is_deref_stable() {
                     self.state = Some((
                         State::Borrow { mutability },
                         StateData {
-                            span: expr.span,
-                            hir_id: expr.hir_id,
+                            first_expr: expr,
                             adjusted_ty,
                         },
                     ));
@@ -534,15 +524,18 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing<'tcx> {
                 let adjusted_ty = data.adjusted_ty;
                 let stability = state.stability;
                 let for_field_access = state.for_field_access;
-                report(cx, expr, State::DerefedBorrow(state), data);
+                report(cx, expr, State::DerefedBorrow(state), data, typeck);
                 if let Some(name) = for_field_access
-                    && !ty_contains_field(typeck.expr_ty(sub_expr), name)
+                    && let sub_expr_ty = typeck.expr_ty(sub_expr)
+                    && !ty_contains_field(sub_expr_ty, name)
                 {
                     self.state = Some((
-                        State::ExplicitDerefField { name },
+                        State::ExplicitDerefField {
+                            name,
+                            derefs_manually_drop: is_manually_drop(sub_expr_ty),
+                        },
                         StateData {
-                            span: expr.span,
-                            hir_id: expr.hir_id,
+                            first_expr: expr,
                             adjusted_ty,
                         },
                     ));
@@ -552,8 +545,7 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing<'tcx> {
                     self.state = Some((
                         State::ExplicitDeref { mutability: None },
                         StateData {
-                            span: parent.span,
-                            hir_id: parent.hir_id,
+                            first_expr: parent,
                             adjusted_ty,
                         },
                     ));
@@ -583,13 +575,28 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing<'tcx> {
             (state @ Some((State::ExplicitDeref { .. }, _)), RefOp::Deref) => {
                 self.state = state;
             },
-            (Some((State::ExplicitDerefField { name }, data)), RefOp::Deref)
-                if !ty_contains_field(typeck.expr_ty(sub_expr), name) =>
+            (
+                Some((
+                    State::ExplicitDerefField {
+                        name,
+                        derefs_manually_drop,
+                    },
+                    data,
+                )),
+                RefOp::Deref,
+            ) if let sub_expr_ty = typeck.expr_ty(sub_expr)
+                && !ty_contains_field(sub_expr_ty, name) =>
             {
-                self.state = Some((State::ExplicitDerefField { name }, data));
+                self.state = Some((
+                    State::ExplicitDerefField {
+                        name,
+                        derefs_manually_drop: derefs_manually_drop || is_manually_drop(sub_expr_ty),
+                    },
+                    data,
+                ));
             },
 
-            (Some((state, data)), _) => report(cx, expr, state, data),
+            (Some((state, data)), _) => report(cx, expr, state, data, typeck),
         }
     }
 
@@ -706,6 +713,14 @@ fn try_parse_ref_op<'tcx>(
     }
 }
 
+// Checks if the adjustments contains a deref of `ManuallyDrop<_>`
+fn adjust_derefs_manually_drop<'tcx>(adjustments: &'tcx [Adjustment<'tcx>], mut ty: Ty<'tcx>) -> bool {
+    adjustments.iter().any(|a| {
+        let ty = mem::replace(&mut ty, a.target);
+        matches!(a.kind, Adjust::Deref(Some(ref op)) if op.mutbl == Mutability::Mut) && is_manually_drop(ty)
+    })
+}
+
 // Checks whether the type for a deref call actually changed the type, not just the mutability of
 // the reference.
 fn deref_method_same_type<'tcx>(result_ty: Ty<'tcx>, arg_ty: Ty<'tcx>) -> bool {
@@ -915,7 +930,13 @@ fn ty_contains_field(ty: Ty<'_>, name: Symbol) -> bool {
 }
 
 #[expect(clippy::needless_pass_by_value, clippy::too_many_lines)]
-fn report<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, state: State, data: StateData<'tcx>) {
+fn report<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx Expr<'_>,
+    state: State,
+    data: StateData<'tcx>,
+    typeck: &'tcx TypeckResults<'tcx>,
+) {
     match state {
         State::DerefMethod {
             ty_changed_count,
@@ -923,8 +944,9 @@ fn report<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, state: State, data
             mutbl,
         } => {
             let mut app = Applicability::MachineApplicable;
-            let (expr_str, _expr_is_macro_call) = snippet_with_context(cx, expr.span, data.span.ctxt(), "..", &mut app);
-            let ty = cx.typeck_results().expr_ty(expr);
+            let (expr_str, _expr_is_macro_call) =
+                snippet_with_context(cx, expr.span, data.first_expr.span.ctxt(), "..", &mut app);
+            let ty = typeck.expr_ty(expr);
             let (_, ref_count) = peel_mid_ty_refs(ty);
             let deref_str = if ty_changed_count >= ref_count && ref_count != 0 {
                 // a deref call changing &T -> &U requires two deref operators the first time
@@ -964,7 +986,7 @@ fn report<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, state: State, data
             span_lint_and_sugg(
                 cx,
                 EXPLICIT_DEREF_METHODS,
-                data.span,
+                data.first_expr.span,
                 match mutbl {
                     Mutability::Not => "explicit `deref` method call",
                     Mutability::Mut => "explicit `deref_mut` method call",
@@ -976,26 +998,34 @@ fn report<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, state: State, data
         },
         State::DerefedBorrow(state) => {
             let mut app = Applicability::MachineApplicable;
-            let (snip, snip_is_macro) = snippet_with_context(cx, expr.span, data.span.ctxt(), "..", &mut app);
-            span_lint_hir_and_then(cx, NEEDLESS_BORROW, data.hir_id, data.span, state.msg, |diag| {
-                let (precedence, calls_field) = match get_parent_node(cx.tcx, data.hir_id) {
-                    Some(Node::Expr(e)) => match e.kind {
-                        ExprKind::Call(callee, _) if callee.hir_id != data.hir_id => (0, false),
-                        ExprKind::Call(..) => (PREC_POSTFIX, matches!(expr.kind, ExprKind::Field(..))),
-                        _ => (e.precedence().order(), false),
-                    },
-                    _ => (0, false),
-                };
-                let sugg = if !snip_is_macro
-                    && (calls_field || expr.precedence().order() < precedence)
-                    && !has_enclosing_paren(&snip)
-                {
-                    format!("({snip})")
-                } else {
-                    snip.into()
-                };
-                diag.span_suggestion(data.span, "change this to", sugg, app);
-            });
+            let (snip, snip_is_macro) =
+                snippet_with_context(cx, expr.span, data.first_expr.span.ctxt(), "..", &mut app);
+            span_lint_hir_and_then(
+                cx,
+                NEEDLESS_BORROW,
+                data.first_expr.hir_id,
+                data.first_expr.span,
+                state.msg,
+                |diag| {
+                    let (precedence, calls_field) = match get_parent_node(cx.tcx, data.first_expr.hir_id) {
+                        Some(Node::Expr(e)) => match e.kind {
+                            ExprKind::Call(callee, _) if callee.hir_id != data.first_expr.hir_id => (0, false),
+                            ExprKind::Call(..) => (PREC_POSTFIX, matches!(expr.kind, ExprKind::Field(..))),
+                            _ => (e.precedence().order(), false),
+                        },
+                        _ => (0, false),
+                    };
+                    let sugg = if !snip_is_macro
+                        && (calls_field || expr.precedence().order() < precedence)
+                        && !has_enclosing_paren(&snip)
+                    {
+                        format!("({snip})")
+                    } else {
+                        snip.into()
+                    };
+                    diag.span_suggestion(data.first_expr.span, "change this to", sugg, app);
+                },
+            );
         },
         State::ExplicitDeref { mutability } => {
             if matches!(
@@ -1013,7 +1043,7 @@ fn report<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, state: State, data
             }
 
             let (prefix, precedence) = if let Some(mutability) = mutability
-                && !cx.typeck_results().expr_ty(expr).is_ref()
+                && !typeck.expr_ty(expr).is_ref()
             {
                 let prefix = match mutability {
                     Mutability::Not => "&",
@@ -1026,53 +1056,61 @@ fn report<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, state: State, data
             span_lint_hir_and_then(
                 cx,
                 EXPLICIT_AUTO_DEREF,
-                data.hir_id,
-                data.span,
+                data.first_expr.hir_id,
+                data.first_expr.span,
                 "deref which would be done by auto-deref",
                 |diag| {
                     let mut app = Applicability::MachineApplicable;
-                    let (snip, snip_is_macro) = snippet_with_context(cx, expr.span, data.span.ctxt(), "..", &mut app);
+                    let (snip, snip_is_macro) =
+                        snippet_with_context(cx, expr.span, data.first_expr.span.ctxt(), "..", &mut app);
                     let sugg =
                         if !snip_is_macro && expr.precedence().order() < precedence && !has_enclosing_paren(&snip) {
                             format!("{prefix}({snip})")
                         } else {
                             format!("{prefix}{snip}")
                         };
-                    diag.span_suggestion(data.span, "try", sugg, app);
+                    diag.span_suggestion(data.first_expr.span, "try", sugg, app);
                 },
             );
         },
-        State::ExplicitDerefField { .. } => {
-            if matches!(
-                expr.kind,
-                ExprKind::Block(..)
-                    | ExprKind::ConstBlock(_)
-                    | ExprKind::If(..)
-                    | ExprKind::Loop(..)
-                    | ExprKind::Match(..)
-            ) && data.adjusted_ty.is_sized(cx.tcx, cx.param_env)
-            {
-                // Rustc bug: auto deref doesn't work on block expression when targeting sized types.
-                return;
-            }
-
-            if let ExprKind::Field(parent_expr, _) = expr.kind
-                && let ty::Adt(adt, _) = cx.typeck_results().expr_ty(parent_expr).kind()
-                && adt.is_union()
-            {
-                // Auto deref does not apply on union field
-                return;
-            }
+        State::ExplicitDerefField {
+            derefs_manually_drop, ..
+        } => {
+            let (snip_span, needs_parens) = if matches!(expr.kind, ExprKind::Field(..))
+                && (derefs_manually_drop
+                    || adjust_derefs_manually_drop(
+                        typeck.expr_adjustments(data.first_expr),
+                        typeck.expr_ty(data.first_expr),
+                    )) {
+                // `DerefMut` will not be automatically applied to `ManuallyDrop<_>`
+                // field expressions when the base type is a union and the parent
+                // expression is also a field access.
+                //
+                // e.g. `&mut x.y.z` where `x` is a union, and accessing `z` requires a
+                // deref through `ManuallyDrop<_>` will not compile.
+                let parent_id = cx.tcx.hir().parent_id(expr.hir_id);
+                if parent_id == data.first_expr.hir_id {
+                    return;
+                }
+                (cx.tcx.hir().get(parent_id).expect_expr().span, true)
+            } else {
+                (expr.span, false)
+            };
             span_lint_hir_and_then(
                 cx,
                 EXPLICIT_AUTO_DEREF,
-                data.hir_id,
-                data.span,
+                data.first_expr.hir_id,
+                data.first_expr.span,
                 "deref which would be done by auto-deref",
                 |diag| {
                     let mut app = Applicability::MachineApplicable;
-                    let snip = snippet_with_context(cx, expr.span, data.span.ctxt(), "..", &mut app).0;
-                    diag.span_suggestion(data.span, "try", snip.into_owned(), app);
+                    let snip = snippet_with_context(cx, snip_span, data.first_expr.span.ctxt(), "..", &mut app).0;
+                    let sugg = if needs_parens {
+                        format!("({snip})")
+                    } else {
+                        snip.into_owned()
+                    };
+                    diag.span_suggestion(data.first_expr.span, "try", sugg, app);
                 },
             );
         },
diff --git a/clippy_utils/src/ty.rs b/clippy_utils/src/ty.rs
index 7eff93881b2..09d7749b2be 100644
--- a/clippy_utils/src/ty.rs
+++ b/clippy_utils/src/ty.rs
@@ -1266,3 +1266,8 @@ pub fn normalize_with_regions<'tcx>(tcx: TyCtxt<'tcx>, param_env: ParamEnv<'tcx>
         Err(_) => ty,
     }
 }
+
+/// Checks if the type is `core::mem::ManuallyDrop<_>`
+pub fn is_manually_drop(ty: Ty<'_>) -> bool {
+    ty.ty_adt_def().map_or(false, AdtDef::is_manually_drop)
+}
diff --git a/tests/ui/explicit_auto_deref.fixed b/tests/ui/explicit_auto_deref.fixed
index 12158d0d12a..e6ca4bb66cc 100644
--- a/tests/ui/explicit_auto_deref.fixed
+++ b/tests/ui/explicit_auto_deref.fixed
@@ -301,24 +301,47 @@ fn main() {
     };
 
     // Issue #11474
-    pub struct Variant {
-        pub anonymous: Variant0,
+    #[derive(Clone, Copy)]
+    struct Wrap<T>(T);
+    impl<T> core::ops::Deref for Wrap<T> {
+        type Target = T;
+        fn deref(&self) -> &T {
+            &self.0
+        }
     }
-
-    pub union Variant0 {
-        pub anonymous: std::mem::ManuallyDrop<Variant00>,
+    impl<T> core::ops::DerefMut for Wrap<T> {
+        fn deref_mut(&mut self) -> &mut T {
+            &mut self.0
+        }
     }
 
-    pub struct Variant00 {
-        pub anonymous: Variant000,
+    union U<T: Copy> {
+        u: T,
     }
 
-    pub union Variant000 {
-        pub val: i32,
+    #[derive(Clone, Copy)]
+    struct S8 {
+        x: &'static str,
     }
 
     unsafe {
-        let mut p = core::mem::zeroed::<Variant>();
-        (*p.anonymous.anonymous).anonymous.val = 1;
+        let mut x = U {
+            u: core::mem::ManuallyDrop::new(S8 { x: "" }),
+        };
+        let _ = &mut (*x.u).x;
+        let _ = &mut { x.u }.x;
+        let _ = &mut ({ *x.u }).x;
+
+        let mut x = U {
+            u: Wrap(core::mem::ManuallyDrop::new(S8 { x: "" })),
+        };
+        let _ = &mut (*x.u).x;
+        let _ = &mut { x.u }.x;
+        let _ = &mut ({ **x.u }).x;
+
+        let mut x = U { u: Wrap(S8 { x: "" }) };
+        let _ = &mut x.u.x;
+        let _ = &mut { x.u }.x;
+        let _ = &mut ({ *x.u }).x;
     }
 }
diff --git a/tests/ui/explicit_auto_deref.rs b/tests/ui/explicit_auto_deref.rs
index dec021c1834..7531e1f87b7 100644
--- a/tests/ui/explicit_auto_deref.rs
+++ b/tests/ui/explicit_auto_deref.rs
@@ -301,24 +301,47 @@ fn main() {
     };
 
     // Issue #11474
-    pub struct Variant {
-        pub anonymous: Variant0,
+    #[derive(Clone, Copy)]
+    struct Wrap<T>(T);
+    impl<T> core::ops::Deref for Wrap<T> {
+        type Target = T;
+        fn deref(&self) -> &T {
+            &self.0
+        }
     }
-
-    pub union Variant0 {
-        pub anonymous: std::mem::ManuallyDrop<Variant00>,
+    impl<T> core::ops::DerefMut for Wrap<T> {
+        fn deref_mut(&mut self) -> &mut T {
+            &mut self.0
+        }
     }
 
-    pub struct Variant00 {
-        pub anonymous: Variant000,
+    union U<T: Copy> {
+        u: T,
     }
 
-    pub union Variant000 {
-        pub val: i32,
+    #[derive(Clone, Copy)]
+    struct S8 {
+        x: &'static str,
     }
 
     unsafe {
-        let mut p = core::mem::zeroed::<Variant>();
-        (*p.anonymous.anonymous).anonymous.val = 1;
+        let mut x = U {
+            u: core::mem::ManuallyDrop::new(S8 { x: "" }),
+        };
+        let _ = &mut (*x.u).x;
+        let _ = &mut (*{ x.u }).x;
+        let _ = &mut ({ *x.u }).x;
+
+        let mut x = U {
+            u: Wrap(core::mem::ManuallyDrop::new(S8 { x: "" })),
+        };
+        let _ = &mut (**x.u).x;
+        let _ = &mut (**{ x.u }).x;
+        let _ = &mut ({ **x.u }).x;
+
+        let mut x = U { u: Wrap(S8 { x: "" }) };
+        let _ = &mut (*x.u).x;
+        let _ = &mut (*{ x.u }).x;
+        let _ = &mut ({ *x.u }).x;
     }
 }
diff --git a/tests/ui/explicit_auto_deref.stderr b/tests/ui/explicit_auto_deref.stderr
index 3d2a7b0d9f4..cc9eeeb5042 100644
--- a/tests/ui/explicit_auto_deref.stderr
+++ b/tests/ui/explicit_auto_deref.stderr
@@ -241,5 +241,35 @@ error: deref which would be done by auto-deref
 LL |         Some(x) => &mut *x,
    |                    ^^^^^^^ help: try: `x`
 
-error: aborting due to 40 previous errors
+error: deref which would be done by auto-deref
+  --> $DIR/explicit_auto_deref.rs:332:22
+   |
+LL |         let _ = &mut (*{ x.u }).x;
+   |                      ^^^^^^^^^^ help: try: `{ x.u }`
+
+error: deref which would be done by auto-deref
+  --> $DIR/explicit_auto_deref.rs:338:22
+   |
+LL |         let _ = &mut (**x.u).x;
+   |                      ^^^^^^^ help: try: `(*x.u)`
+
+error: deref which would be done by auto-deref
+  --> $DIR/explicit_auto_deref.rs:339:22
+   |
+LL |         let _ = &mut (**{ x.u }).x;
+   |                      ^^^^^^^^^^^ help: try: `{ x.u }`
+
+error: deref which would be done by auto-deref
+  --> $DIR/explicit_auto_deref.rs:343:22
+   |
+LL |         let _ = &mut (*x.u).x;
+   |                      ^^^^^^ help: try: `x.u`
+
+error: deref which would be done by auto-deref
+  --> $DIR/explicit_auto_deref.rs:344:22
+   |
+LL |         let _ = &mut (*{ x.u }).x;
+   |                      ^^^^^^^^^^ help: try: `{ x.u }`
+
+error: aborting due to 45 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 941164807f235e6609e697fa32e983f417d878ed Mon Sep 17 00:00:00 2001
From: Jacherr <jwc2002@outlook.com>
Date: Sat, 11 Nov 2023 21:26:50 +0000
Subject: implement more types to lint, fix wording

---
 clippy_lints/src/iter_over_hash_type.rs | 29 ++++++++++++----
 clippy_utils/src/paths.rs               |  5 +++
 tests/ui/iter_over_hash_type.rs         | 21 ++++++++++--
 tests/ui/iter_over_hash_type.stderr     | 60 +++++++++++++++++++++++++++------
 4 files changed, 95 insertions(+), 20 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/iter_over_hash_type.rs b/clippy_lints/src/iter_over_hash_type.rs
index 607d8e5fc28..d0fedcfc2f4 100644
--- a/clippy_lints/src/iter_over_hash_type.rs
+++ b/clippy_lints/src/iter_over_hash_type.rs
@@ -1,8 +1,11 @@
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::higher::ForLoop;
-use clippy_utils::match_def_path;
-use clippy_utils::paths::{HASHMAP_KEYS, HASHMAP_VALUES, HASHSET_ITER_TY};
+use clippy_utils::paths::{
+    HASHMAP_DRAIN, HASHMAP_ITER, HASHMAP_ITER_MUT, HASHMAP_KEYS, HASHMAP_VALUES, HASHMAP_VALUES_MUT, HASHSET_DRAIN,
+    HASHSET_ITER_TY,
+};
 use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::match_any_def_paths;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::sym;
@@ -13,7 +16,7 @@ declare_clippy_lint! {
     ///
     /// ### Why is this bad?
     /// Because hash types are unordered, when iterated through such as in a for loop, the values are returned in
-    /// a pseudo-random order. As a result, on redundant systems this may cause inconsistencies and anomalies.
+    /// an undefined order. As a result, on redundant systems this may cause inconsistencies and anomalies.
     /// In addition, the unknown order of the elements may reduce readability or introduce other undesired
     /// side effects.
     ///
@@ -46,9 +49,21 @@ impl LateLintPass<'_> for IterOverHashType {
             && let ty = cx.typeck_results().expr_ty(for_loop.arg).peel_refs()
             && let Some(adt) = ty.ty_adt_def()
             && let did = adt.did()
-            && (match_def_path(cx, did, &HASHMAP_KEYS)
-                || match_def_path(cx, did, &HASHMAP_VALUES)
-                || match_def_path(cx, did, &HASHSET_ITER_TY)
+            && (match_any_def_paths(
+                cx,
+                did,
+                &[
+                    &HASHMAP_KEYS,
+                    &HASHMAP_VALUES,
+                    &HASHMAP_VALUES_MUT,
+                    &HASHMAP_ITER,
+                    &HASHMAP_ITER_MUT,
+                    &HASHMAP_DRAIN,
+                    &HASHSET_ITER_TY,
+                    &HASHSET_DRAIN,
+                ],
+            )
+            .is_some()
                 || is_type_diagnostic_item(cx, ty, sym::HashMap)
                 || is_type_diagnostic_item(cx, ty, sym::HashSet))
         {
@@ -56,7 +71,7 @@ impl LateLintPass<'_> for IterOverHashType {
                 cx,
                 ITER_OVER_HASH_TYPE,
                 expr.span,
-                "iterating over unordered hash-based type",
+                "iteration over unordered hash-based type",
             );
         };
     }
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index 9c9fb381e54..0a820a1754c 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -32,10 +32,15 @@ pub const FUTURES_IO_ASYNCREADEXT: [&str; 3] = ["futures_util", "io", "AsyncRead
 pub const FUTURES_IO_ASYNCWRITEEXT: [&str; 3] = ["futures_util", "io", "AsyncWriteExt"];
 pub const HASHMAP_CONTAINS_KEY: [&str; 6] = ["std", "collections", "hash", "map", "HashMap", "contains_key"];
 pub const HASHMAP_INSERT: [&str; 6] = ["std", "collections", "hash", "map", "HashMap", "insert"];
+pub const HASHMAP_ITER: [&str; 5] = ["std", "collections", "hash", "map", "Iter"];
+pub const HASHMAP_ITER_MUT: [&str; 5] = ["std", "collections", "hash", "map", "IterMut"];
 pub const HASHMAP_KEYS: [&str; 5] = ["std", "collections", "hash", "map", "Keys"];
 pub const HASHMAP_VALUES: [&str; 5] = ["std", "collections", "hash", "map", "Values"];
+pub const HASHMAP_DRAIN: [&str; 5] = ["std", "collections", "hash", "map", "Drain"];
+pub const HASHMAP_VALUES_MUT: [&str; 5] = ["std", "collections", "hash", "map", "ValuesMut"];
 pub const HASHSET_ITER_TY: [&str; 5] = ["std", "collections", "hash", "set", "Iter"];
 pub const HASHSET_ITER: [&str; 6] = ["std", "collections", "hash", "set", "HashSet", "iter"];
+pub const HASHSET_DRAIN: [&str; 5] = ["std", "collections", "hash", "set", "Drain"];
 pub const IDENT: [&str; 3] = ["rustc_span", "symbol", "Ident"];
 pub const IDENT_AS_STR: [&str; 4] = ["rustc_span", "symbol", "Ident", "as_str"];
 pub const INSERT_STR: [&str; 4] = ["alloc", "string", "String", "insert_str"];
diff --git a/tests/ui/iter_over_hash_type.rs b/tests/ui/iter_over_hash_type.rs
index fc340abf146..9c3f5d33752 100644
--- a/tests/ui/iter_over_hash_type.rs
+++ b/tests/ui/iter_over_hash_type.rs
@@ -6,8 +6,8 @@ use std::collections::{HashMap, HashSet};
 extern crate proc_macros;
 
 fn main() {
-    let hash_set = HashSet::<i32>::new();
-    let hash_map = HashMap::<i32, i32>::new();
+    let mut hash_set = HashSet::<i32>::new();
+    let mut hash_map = HashMap::<i32, i32>::new();
     let vec = Vec::<i32>::new();
 
     for x in &hash_set {
@@ -16,7 +16,10 @@ fn main() {
     for x in hash_set.iter() {
         let _ = x;
     }
-    for x in hash_set {
+    for x in hash_set.clone() {
+        let _ = x;
+    }
+    for x in hash_set.drain() {
         let _ = x;
     }
     for (x, y) in &hash_map {
@@ -28,6 +31,18 @@ fn main() {
     for x in hash_map.values() {
         let _ = x;
     }
+    for x in hash_map.values_mut() {
+        *x += 1;
+    }
+    for x in hash_map.iter() {
+        let _ = x;
+    }
+    for x in hash_map.clone() {
+        let _ = x;
+    }
+    for x in hash_map.drain() {
+        let _ = x;
+    }
 
     // shouldnt fire
     for x in &vec {
diff --git a/tests/ui/iter_over_hash_type.stderr b/tests/ui/iter_over_hash_type.stderr
index 72d621c7b59..1204b88d283 100644
--- a/tests/ui/iter_over_hash_type.stderr
+++ b/tests/ui/iter_over_hash_type.stderr
@@ -1,4 +1,4 @@
-error: iterating over unordered hash-based type
+error: iteration over unordered hash-based type
   --> $DIR/iter_over_hash_type.rs:13:5
    |
 LL | /     for x in &hash_set {
@@ -9,7 +9,7 @@ LL | |     }
    = note: `-D clippy::iter-over-hash-type` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::iter_over_hash_type)]`
 
-error: iterating over unordered hash-based type
+error: iteration over unordered hash-based type
   --> $DIR/iter_over_hash_type.rs:16:5
    |
 LL | /     for x in hash_set.iter() {
@@ -17,37 +17,77 @@ LL | |         let _ = x;
 LL | |     }
    | |_____^
 
-error: iterating over unordered hash-based type
+error: iteration over unordered hash-based type
   --> $DIR/iter_over_hash_type.rs:19:5
    |
-LL | /     for x in hash_set {
+LL | /     for x in hash_set.clone() {
 LL | |         let _ = x;
 LL | |     }
    | |_____^
 
-error: iterating over unordered hash-based type
+error: iteration over unordered hash-based type
   --> $DIR/iter_over_hash_type.rs:22:5
    |
+LL | /     for x in hash_set.drain() {
+LL | |         let _ = x;
+LL | |     }
+   | |_____^
+
+error: iteration over unordered hash-based type
+  --> $DIR/iter_over_hash_type.rs:25:5
+   |
 LL | /     for (x, y) in &hash_map {
 LL | |         let _ = (x, y);
 LL | |     }
    | |_____^
 
-error: iterating over unordered hash-based type
-  --> $DIR/iter_over_hash_type.rs:25:5
+error: iteration over unordered hash-based type
+  --> $DIR/iter_over_hash_type.rs:28:5
    |
 LL | /     for x in hash_map.keys() {
 LL | |         let _ = x;
 LL | |     }
    | |_____^
 
-error: iterating over unordered hash-based type
-  --> $DIR/iter_over_hash_type.rs:28:5
+error: iteration over unordered hash-based type
+  --> $DIR/iter_over_hash_type.rs:31:5
    |
 LL | /     for x in hash_map.values() {
 LL | |         let _ = x;
 LL | |     }
    | |_____^
 
-error: aborting due to 6 previous errors
+error: iteration over unordered hash-based type
+  --> $DIR/iter_over_hash_type.rs:34:5
+   |
+LL | /     for x in hash_map.values_mut() {
+LL | |         *x += 1;
+LL | |     }
+   | |_____^
+
+error: iteration over unordered hash-based type
+  --> $DIR/iter_over_hash_type.rs:37:5
+   |
+LL | /     for x in hash_map.iter() {
+LL | |         let _ = x;
+LL | |     }
+   | |_____^
+
+error: iteration over unordered hash-based type
+  --> $DIR/iter_over_hash_type.rs:40:5
+   |
+LL | /     for x in hash_map.clone() {
+LL | |         let _ = x;
+LL | |     }
+   | |_____^
+
+error: iteration over unordered hash-based type
+  --> $DIR/iter_over_hash_type.rs:43:5
+   |
+LL | /     for x in hash_map.drain() {
+LL | |         let _ = x;
+LL | |     }
+   | |_____^
+
+error: aborting due to 11 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 938984a24e09b20bf972eff0a6e790b61b482b85 Mon Sep 17 00:00:00 2001
From: Jacherr <jwc2002@outlook.com>
Date: Sat, 11 Nov 2023 21:29:09 +0000
Subject: run cargo dev fmt

---
 clippy_lints/src/iter_over_hash_type.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/iter_over_hash_type.rs b/clippy_lints/src/iter_over_hash_type.rs
index d0fedcfc2f4..7755adc4c1d 100644
--- a/clippy_lints/src/iter_over_hash_type.rs
+++ b/clippy_lints/src/iter_over_hash_type.rs
@@ -1,11 +1,11 @@
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::higher::ForLoop;
+use clippy_utils::match_any_def_paths;
 use clippy_utils::paths::{
     HASHMAP_DRAIN, HASHMAP_ITER, HASHMAP_ITER_MUT, HASHMAP_KEYS, HASHMAP_VALUES, HASHMAP_VALUES_MUT, HASHSET_DRAIN,
     HASHSET_ITER_TY,
 };
 use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::match_any_def_paths;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::sym;
-- 
cgit 1.4.1-3-g733a5


From 5f651da2de3e4141df42a47ef47762b642c447bc Mon Sep 17 00:00:00 2001
From: Matthias Richter <matthias.ri97@gmail.com>
Date: Fri, 3 Nov 2023 23:23:59 +0100
Subject: fix iter_kv_map dont suggest into_keys and into_values if msrv is to
 low

---
 clippy_config/src/msrvs.rs              |  1 +
 clippy_lints/src/methods/iter_kv_map.rs |  5 +++
 clippy_lints/src/methods/mod.rs         |  2 +-
 tests/ui/iter_kv_map.fixed              | 43 +++++++++++++++++++++++
 tests/ui/iter_kv_map.rs                 | 43 +++++++++++++++++++++++
 tests/ui/iter_kv_map.stderr             | 62 ++++++++++++++++++++++++++++++++-
 6 files changed, 154 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_config/src/msrvs.rs b/clippy_config/src/msrvs.rs
index 011d54629d4..b3ef666e306 100644
--- a/clippy_config/src/msrvs.rs
+++ b/clippy_config/src/msrvs.rs
@@ -23,6 +23,7 @@ msrv_aliases! {
     1,62,0 { BOOL_THEN_SOME, DEFAULT_ENUM_ATTRIBUTE }
     1,58,0 { FORMAT_ARGS_CAPTURE, PATTERN_TRAIT_CHAR_ARRAY }
     1,55,0 { SEEK_REWIND }
+    1,54,0 { INTO_KEYS }
     1,53,0 { OR_PATTERNS, MANUAL_BITS, BTREE_MAP_RETAIN, BTREE_SET_RETAIN, ARRAY_INTO_ITERATOR }
     1,52,0 { STR_SPLIT_ONCE, REM_EUCLID_CONST }
     1,51,0 { BORROW_AS_PTR, SEEK_FROM_CURRENT, UNSIGNED_ABS }
diff --git a/clippy_lints/src/methods/iter_kv_map.rs b/clippy_lints/src/methods/iter_kv_map.rs
index c5dbb6ad98b..e1b934d36ea 100644
--- a/clippy_lints/src/methods/iter_kv_map.rs
+++ b/clippy_lints/src/methods/iter_kv_map.rs
@@ -1,6 +1,7 @@
 #![allow(unused_imports)]
 
 use super::ITER_KV_MAP;
+use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::diagnostics::{multispan_sugg, span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::{snippet, snippet_with_applicability};
 use clippy_utils::ty::is_type_diagnostic_item;
@@ -21,7 +22,11 @@ pub(super) fn check<'tcx>(
     expr: &'tcx Expr<'tcx>,  // .iter().map(|(_, v_| v))
     recv: &'tcx Expr<'tcx>,  // hashmap
     m_arg: &'tcx Expr<'tcx>, // |(_, v)| v
+    msrv: &Msrv,
 ) {
+    if map_type == "into_iter" && !msrv.meets(msrvs::INTO_KEYS) {
+        return;
+    }
     if !expr.span.from_expansion()
         && let ExprKind::Closure(c) = m_arg.kind
         && let Body {
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 57c3913944f..d9ab0f3b8ca 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -4255,7 +4255,7 @@ impl Methods {
                         map_clone::check(cx, expr, recv, m_arg, &self.msrv);
                         match method_call(recv) {
                             Some((map_name @ ("iter" | "into_iter"), recv2, _, _, _)) => {
-                                iter_kv_map::check(cx, map_name, expr, recv2, m_arg);
+                                iter_kv_map::check(cx, map_name, expr, recv2, m_arg, &self.msrv);
                             },
                             Some(("cloned", recv2, [], _, _)) => iter_overeager_cloned::check(
                                 cx,
diff --git a/tests/ui/iter_kv_map.fixed b/tests/ui/iter_kv_map.fixed
index 566a5b690d8..2cbf972fca5 100644
--- a/tests/ui/iter_kv_map.fixed
+++ b/tests/ui/iter_kv_map.fixed
@@ -89,3 +89,46 @@ fn main() {
     // Don't let a mut interfere.
     let _ = map.clone().into_values().count();
 }
+
+#[clippy::msrv = "1.53"]
+fn msrv_1_53() {
+    let map: HashMap<u32, u32> = HashMap::new();
+
+    // Don't lint because into_iter is not supported
+    let _ = map.clone().into_iter().map(|(key, _)| key).collect::<Vec<_>>();
+    let _ = map.clone().into_iter().map(|(key, _)| key + 2).collect::<Vec<_>>();
+
+    let _ = map.clone().into_iter().map(|(_, val)| val).collect::<Vec<_>>();
+    let _ = map.clone().into_iter().map(|(_, val)| val + 2).collect::<Vec<_>>();
+
+    // Lint
+    let _ = map.keys().collect::<Vec<_>>();
+    //~^ ERROR: iterating on a map's keys
+    let _ = map.values().collect::<Vec<_>>();
+    //~^ ERROR: iterating on a map's values
+    let _ = map.values().map(|v| v + 2).collect::<Vec<_>>();
+    //~^ ERROR: iterating on a map's values
+}
+
+#[clippy::msrv = "1.54"]
+fn msrv_1_54() {
+    // Lint all
+    let map: HashMap<u32, u32> = HashMap::new();
+
+    let _ = map.clone().into_keys().collect::<Vec<_>>();
+    //~^ ERROR: iterating on a map's keys
+    let _ = map.clone().into_keys().map(|key| key + 2).collect::<Vec<_>>();
+    //~^ ERROR: iterating on a map's keys
+
+    let _ = map.clone().into_values().collect::<Vec<_>>();
+    //~^ ERROR: iterating on a map's values
+    let _ = map.clone().into_values().map(|val| val + 2).collect::<Vec<_>>();
+    //~^ ERROR: iterating on a map's values
+
+    let _ = map.keys().collect::<Vec<_>>();
+    //~^ ERROR: iterating on a map's keys
+    let _ = map.values().collect::<Vec<_>>();
+    //~^ ERROR: iterating on a map's values
+    let _ = map.values().map(|v| v + 2).collect::<Vec<_>>();
+    //~^ ERROR: iterating on a map's values
+}
diff --git a/tests/ui/iter_kv_map.rs b/tests/ui/iter_kv_map.rs
index d85e501da48..6a9a4267a76 100644
--- a/tests/ui/iter_kv_map.rs
+++ b/tests/ui/iter_kv_map.rs
@@ -93,3 +93,46 @@ fn main() {
     // Don't let a mut interfere.
     let _ = map.clone().into_iter().map(|(_, mut val)| val).count();
 }
+
+#[clippy::msrv = "1.53"]
+fn msrv_1_53() {
+    let map: HashMap<u32, u32> = HashMap::new();
+
+    // Don't lint because into_iter is not supported
+    let _ = map.clone().into_iter().map(|(key, _)| key).collect::<Vec<_>>();
+    let _ = map.clone().into_iter().map(|(key, _)| key + 2).collect::<Vec<_>>();
+
+    let _ = map.clone().into_iter().map(|(_, val)| val).collect::<Vec<_>>();
+    let _ = map.clone().into_iter().map(|(_, val)| val + 2).collect::<Vec<_>>();
+
+    // Lint
+    let _ = map.iter().map(|(key, _)| key).collect::<Vec<_>>();
+    //~^ ERROR: iterating on a map's keys
+    let _ = map.iter().map(|(_, value)| value).collect::<Vec<_>>();
+    //~^ ERROR: iterating on a map's values
+    let _ = map.iter().map(|(_, v)| v + 2).collect::<Vec<_>>();
+    //~^ ERROR: iterating on a map's values
+}
+
+#[clippy::msrv = "1.54"]
+fn msrv_1_54() {
+    // Lint all
+    let map: HashMap<u32, u32> = HashMap::new();
+
+    let _ = map.clone().into_iter().map(|(key, _)| key).collect::<Vec<_>>();
+    //~^ ERROR: iterating on a map's keys
+    let _ = map.clone().into_iter().map(|(key, _)| key + 2).collect::<Vec<_>>();
+    //~^ ERROR: iterating on a map's keys
+
+    let _ = map.clone().into_iter().map(|(_, val)| val).collect::<Vec<_>>();
+    //~^ ERROR: iterating on a map's values
+    let _ = map.clone().into_iter().map(|(_, val)| val + 2).collect::<Vec<_>>();
+    //~^ ERROR: iterating on a map's values
+
+    let _ = map.iter().map(|(key, _)| key).collect::<Vec<_>>();
+    //~^ ERROR: iterating on a map's keys
+    let _ = map.iter().map(|(_, value)| value).collect::<Vec<_>>();
+    //~^ ERROR: iterating on a map's values
+    let _ = map.iter().map(|(_, v)| v + 2).collect::<Vec<_>>();
+    //~^ ERROR: iterating on a map's values
+}
diff --git a/tests/ui/iter_kv_map.stderr b/tests/ui/iter_kv_map.stderr
index 62155b7f838..471615978e1 100644
--- a/tests/ui/iter_kv_map.stderr
+++ b/tests/ui/iter_kv_map.stderr
@@ -201,5 +201,65 @@ error: iterating on a map's values
 LL |     let _ = map.clone().into_iter().map(|(_, mut val)| val).count();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.clone().into_values()`
 
-error: aborting due to 28 previous errors
+error: iterating on a map's keys
+  --> $DIR/iter_kv_map.rs:109:13
+   |
+LL |     let _ = map.iter().map(|(key, _)| key).collect::<Vec<_>>();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.keys()`
+
+error: iterating on a map's values
+  --> $DIR/iter_kv_map.rs:111:13
+   |
+LL |     let _ = map.iter().map(|(_, value)| value).collect::<Vec<_>>();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.values()`
+
+error: iterating on a map's values
+  --> $DIR/iter_kv_map.rs:113:13
+   |
+LL |     let _ = map.iter().map(|(_, v)| v + 2).collect::<Vec<_>>();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.values().map(|v| v + 2)`
+
+error: iterating on a map's keys
+  --> $DIR/iter_kv_map.rs:122:13
+   |
+LL |     let _ = map.clone().into_iter().map(|(key, _)| key).collect::<Vec<_>>();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.clone().into_keys()`
+
+error: iterating on a map's keys
+  --> $DIR/iter_kv_map.rs:124:13
+   |
+LL |     let _ = map.clone().into_iter().map(|(key, _)| key + 2).collect::<Vec<_>>();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.clone().into_keys().map(|key| key + 2)`
+
+error: iterating on a map's values
+  --> $DIR/iter_kv_map.rs:127:13
+   |
+LL |     let _ = map.clone().into_iter().map(|(_, val)| val).collect::<Vec<_>>();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.clone().into_values()`
+
+error: iterating on a map's values
+  --> $DIR/iter_kv_map.rs:129:13
+   |
+LL |     let _ = map.clone().into_iter().map(|(_, val)| val + 2).collect::<Vec<_>>();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.clone().into_values().map(|val| val + 2)`
+
+error: iterating on a map's keys
+  --> $DIR/iter_kv_map.rs:132:13
+   |
+LL |     let _ = map.iter().map(|(key, _)| key).collect::<Vec<_>>();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.keys()`
+
+error: iterating on a map's values
+  --> $DIR/iter_kv_map.rs:134:13
+   |
+LL |     let _ = map.iter().map(|(_, value)| value).collect::<Vec<_>>();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.values()`
+
+error: iterating on a map's values
+  --> $DIR/iter_kv_map.rs:136:13
+   |
+LL |     let _ = map.iter().map(|(_, v)| v + 2).collect::<Vec<_>>();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.values().map(|v| v + 2)`
+
+error: aborting due to 38 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From d89890d154f4d5ab148312421d1cb2022809fab4 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Mon, 13 Nov 2023 13:44:00 +0100
Subject: move `suspicious_doc_comments` to doc pass

---
 clippy_lints/src/declared_lints.rs          |  2 +-
 clippy_lints/src/doc.rs                     | 89 ++++++++++++++++++++++++++++
 clippy_lints/src/lib.rs                     |  2 -
 clippy_lints/src/suspicious_doc_comments.rs | 92 -----------------------------
 4 files changed, 90 insertions(+), 95 deletions(-)
 delete mode 100644 clippy_lints/src/suspicious_doc_comments.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 04dcccede08..ecfe8e1582c 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -139,6 +139,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::doc::MISSING_PANICS_DOC_INFO,
     crate::doc::MISSING_SAFETY_DOC_INFO,
     crate::doc::NEEDLESS_DOCTEST_MAIN_INFO,
+    crate::doc::SUSPICIOUS_DOC_COMMENTS_INFO,
     crate::doc::UNNECESSARY_SAFETY_DOC_INFO,
     crate::double_parens::DOUBLE_PARENS_INFO,
     crate::drop_forget_ref::DROP_NON_DROP_INFO,
@@ -626,7 +627,6 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::strings::STR_TO_STRING_INFO,
     crate::strings::TRIM_SPLIT_WHITESPACE_INFO,
     crate::strlen_on_c_strings::STRLEN_ON_C_STRINGS_INFO,
-    crate::suspicious_doc_comments::SUSPICIOUS_DOC_COMMENTS_INFO,
     crate::suspicious_operation_groupings::SUSPICIOUS_OPERATION_GROUPINGS_INFO,
     crate::suspicious_trait_impl::SUSPICIOUS_ARITHMETIC_IMPL_INFO,
     crate::suspicious_trait_impl::SUSPICIOUS_OP_ASSIGN_IMPL_INFO,
diff --git a/clippy_lints/src/doc.rs b/clippy_lints/src/doc.rs
index 6a12baa4201..632bbacb699 100644
--- a/clippy_lints/src/doc.rs
+++ b/clippy_lints/src/doc.rs
@@ -10,6 +10,8 @@ use pulldown_cmark::Event::{
 use pulldown_cmark::Tag::{CodeBlock, Heading, Item, Link, Paragraph};
 use pulldown_cmark::{BrokenLink, CodeBlockKind, CowStr, Options};
 use rustc_ast::ast::{Async, Attribute, Fn, FnRetTy, ItemKind};
+use rustc_ast::token::CommentKind;
+use rustc_ast::{AttrKind, AttrStyle};
 use rustc_data_structures::fx::FxHashSet;
 use rustc_data_structures::sync::Lrc;
 use rustc_errors::emitter::EmitterWriter;
@@ -260,6 +262,53 @@ declare_clippy_lint! {
     "`pub fn` or `pub trait` with `# Safety` docs"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Detects the use of outer doc comments (`///`, `/**`) followed by a bang (`!`): `///!`
+    ///
+    /// ### Why is this bad?
+    /// Triple-slash comments (known as "outer doc comments") apply to items that follow it.
+    /// An outer doc comment followed by a bang (i.e. `///!`) has no specific meaning.
+    ///
+    /// The user most likely meant to write an inner doc comment (`//!`, `/*!`), which
+    /// applies to the parent item (i.e. the item that the comment is contained in,
+    /// usually a module or crate).
+    ///
+    /// ### Known problems
+    /// Inner doc comments can only appear before items, so there are certain cases where the suggestion
+    /// made by this lint is not valid code. For example:
+    /// ```rs
+    /// fn foo() {}
+    /// ///!
+    /// fn bar() {}
+    /// ```
+    /// This lint detects the doc comment and suggests changing it to `//!`, but an inner doc comment
+    /// is not valid at that position.
+    ///
+    /// ### Example
+    /// In this example, the doc comment is attached to the *function*, rather than the *module*.
+    /// ```no_run
+    /// pub mod util {
+    ///     ///! This module contains utility functions.
+    ///
+    ///     pub fn dummy() {}
+    /// }
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// pub mod util {
+    ///     //! This module contains utility functions.
+    ///
+    ///     pub fn dummy() {}
+    /// }
+    /// ```
+    #[clippy::version = "1.70.0"]
+    pub SUSPICIOUS_DOC_COMMENTS,
+    suspicious,
+    "suspicious usage of (outer) doc comments"
+}
+
 #[expect(clippy::module_name_repetitions)]
 #[derive(Clone)]
 pub struct DocMarkdown {
@@ -284,6 +333,7 @@ impl_lint_pass!(DocMarkdown => [
     MISSING_PANICS_DOC,
     NEEDLESS_DOCTEST_MAIN,
     UNNECESSARY_SAFETY_DOC,
+    SUSPICIOUS_DOC_COMMENTS
 ]);
 
 impl<'tcx> LateLintPass<'tcx> for DocMarkdown {
@@ -478,6 +528,8 @@ fn check_attrs(cx: &LateContext<'_>, valid_idents: &FxHashSet<String>, attrs: &[
         return None;
     }
 
+    check_almost_inner_doc(cx, attrs);
+
     let (fragments, _) = attrs_to_doc_fragments(attrs.iter().map(|attr| (attr, None)), true);
     let mut doc = String::new();
     for fragment in &fragments {
@@ -506,6 +558,43 @@ fn check_attrs(cx: &LateContext<'_>, valid_idents: &FxHashSet<String>, attrs: &[
     ))
 }
 
+/// Looks for `///!` and `/**!` comments, which were probably meant to be `//!` and `/*!`
+fn check_almost_inner_doc(cx: &LateContext<'_>, attrs: &[Attribute]) {
+    let replacements: Vec<_> = attrs
+        .iter()
+        .filter_map(|attr| {
+            if let AttrKind::DocComment(com_kind, sym) = attr.kind
+                && let AttrStyle::Outer = attr.style
+                && let Some(com) = sym.as_str().strip_prefix('!')
+            {
+                let sugg = match com_kind {
+                    CommentKind::Line => format!("//!{com}"),
+                    CommentKind::Block => format!("/*!{com}*/"),
+                };
+                Some((attr.span, sugg))
+            } else {
+                None
+            }
+        })
+        .collect();
+
+    if let Some((&(lo_span, _), &(hi_span, _))) = replacements.first().zip(replacements.last()) {
+        span_lint_and_then(
+            cx,
+            SUSPICIOUS_DOC_COMMENTS,
+            lo_span.to(hi_span),
+            "this is an outer doc comment and does not apply to the parent module or crate",
+            |diag| {
+                diag.multipart_suggestion(
+                    "use an inner doc comment to document the parent module or crate",
+                    replacements,
+                    Applicability::MaybeIncorrect,
+                );
+            },
+        );
+    }
+}
+
 const RUST_CODE: &[&str] = &["rust", "no_run", "should_panic", "compile_fail"];
 
 #[allow(clippy::too_many_lines)] // Only a big match statement
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 609ff3d051a..463f880aa8a 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -307,7 +307,6 @@ mod slow_vector_initialization;
 mod std_instead_of_core;
 mod strings;
 mod strlen_on_c_strings;
-mod suspicious_doc_comments;
 mod suspicious_operation_groupings;
 mod suspicious_trait_impl;
 mod suspicious_xor_used_as_pow;
@@ -1000,7 +999,6 @@ pub fn register_lints(store: &mut rustc_lint::LintStore, conf: &'static Conf) {
     store.register_late_pass(|_| Box::new(lines_filter_map_ok::LinesFilterMapOk));
     store.register_late_pass(|_| Box::new(tests_outside_test_module::TestsOutsideTestModule));
     store.register_late_pass(|_| Box::new(manual_slice_size_calculation::ManualSliceSizeCalculation));
-    store.register_early_pass(|| Box::new(suspicious_doc_comments::SuspiciousDocComments));
     store.register_early_pass(move || {
         Box::new(excessive_nesting::ExcessiveNesting {
             excessive_nesting_threshold,
diff --git a/clippy_lints/src/suspicious_doc_comments.rs b/clippy_lints/src/suspicious_doc_comments.rs
deleted file mode 100644
index cbd6e745841..00000000000
--- a/clippy_lints/src/suspicious_doc_comments.rs
+++ /dev/null
@@ -1,92 +0,0 @@
-use clippy_utils::diagnostics::{multispan_sugg_with_applicability, span_lint_and_then};
-use rustc_ast::token::CommentKind;
-use rustc_ast::{AttrKind, AttrStyle, Attribute, Item};
-use rustc_errors::Applicability;
-use rustc_lint::{EarlyContext, EarlyLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
-use rustc_span::Span;
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Detects the use of outer doc comments (`///`, `/**`) followed by a bang (`!`): `///!`
-    ///
-    /// ### Why is this bad?
-    /// Triple-slash comments (known as "outer doc comments") apply to items that follow it.
-    /// An outer doc comment followed by a bang (i.e. `///!`) has no specific meaning.
-    ///
-    /// The user most likely meant to write an inner doc comment (`//!`, `/*!`), which
-    /// applies to the parent item (i.e. the item that the comment is contained in,
-    /// usually a module or crate).
-    ///
-    /// ### Known problems
-    /// Inner doc comments can only appear before items, so there are certain cases where the suggestion
-    /// made by this lint is not valid code. For example:
-    /// ```rs
-    /// fn foo() {}
-    /// ///!
-    /// fn bar() {}
-    /// ```
-    /// This lint detects the doc comment and suggests changing it to `//!`, but an inner doc comment
-    /// is not valid at that position.
-    ///
-    /// ### Example
-    /// In this example, the doc comment is attached to the *function*, rather than the *module*.
-    /// ```no_run
-    /// pub mod util {
-    ///     ///! This module contains utility functions.
-    ///
-    ///     pub fn dummy() {}
-    /// }
-    /// ```
-    ///
-    /// Use instead:
-    /// ```no_run
-    /// pub mod util {
-    ///     //! This module contains utility functions.
-    ///
-    ///     pub fn dummy() {}
-    /// }
-    /// ```
-    #[clippy::version = "1.70.0"]
-    pub SUSPICIOUS_DOC_COMMENTS,
-    suspicious,
-    "suspicious usage of (outer) doc comments"
-}
-declare_lint_pass!(SuspiciousDocComments => [SUSPICIOUS_DOC_COMMENTS]);
-
-const WARNING: &str = "this is an outer doc comment and does not apply to the parent module or crate";
-const HELP: &str = "use an inner doc comment to document the parent module or crate";
-
-impl EarlyLintPass for SuspiciousDocComments {
-    fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {
-        let replacements = collect_doc_comment_replacements(&item.attrs);
-
-        if let Some(((lo_span, _), (hi_span, _))) = replacements.first().zip(replacements.last()) {
-            let span = lo_span.to(*hi_span);
-
-            span_lint_and_then(cx, SUSPICIOUS_DOC_COMMENTS, span, WARNING, |diag| {
-                multispan_sugg_with_applicability(diag, HELP, Applicability::MaybeIncorrect, replacements);
-            });
-        }
-    }
-}
-
-fn collect_doc_comment_replacements(attrs: &[Attribute]) -> Vec<(Span, String)> {
-    attrs
-        .iter()
-        .filter_map(|attr| {
-            if let AttrKind::DocComment(com_kind, sym) = attr.kind
-                && let AttrStyle::Outer = attr.style
-                && let Some(com) = sym.as_str().strip_prefix('!')
-            {
-                let sugg = match com_kind {
-                    CommentKind::Line => format!("//!{com}"),
-                    CommentKind::Block => format!("/*!{com}*/"),
-                };
-                Some((attr.span, sugg))
-            } else {
-                None
-            }
-        })
-        .collect()
-}
-- 
cgit 1.4.1-3-g733a5


From 48f38eb131b06799b8aaab2efe859a39959754b4 Mon Sep 17 00:00:00 2001
From: dswij <dswijj@gmail.com>
Date: Tue, 14 Nov 2023 04:05:45 +0800
Subject: `needless_return_with_question_mark` ignore let-else

---
 clippy_lints/src/returns.rs                        |  3 +-
 clippy_utils/src/lib.rs                            | 37 ++++++++++++++++++++++
 tests/ui/needless_return_with_question_mark.fixed  | 22 +++++++++++++
 tests/ui/needless_return_with_question_mark.rs     | 22 +++++++++++++
 tests/ui/needless_return_with_question_mark.stderr |  2 +-
 5 files changed, 84 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
index 72235a954ba..27cd8b8c2df 100644
--- a/clippy_lints/src/returns.rs
+++ b/clippy_lints/src/returns.rs
@@ -2,7 +2,7 @@ use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then, span_lin
 use clippy_utils::source::{snippet_opt, snippet_with_context};
 use clippy_utils::sugg::has_enclosing_paren;
 use clippy_utils::visitors::{for_each_expr_with_closures, Descend};
-use clippy_utils::{fn_def_id, is_from_proc_macro, path_to_local_id, span_find_starting_semi};
+use clippy_utils::{fn_def_id, is_from_proc_macro, is_inside_let_else, path_to_local_id, span_find_starting_semi};
 use core::ops::ControlFlow;
 use if_chain::if_chain;
 use rustc_errors::Applicability;
@@ -171,6 +171,7 @@ impl<'tcx> LateLintPass<'tcx> for Return {
             && let ItemKind::Fn(_, _, body) = item.kind
             && let block = cx.tcx.hir().body(body).value
             && let ExprKind::Block(block, _) = block.kind
+            && !is_inside_let_else(cx.tcx, expr)
             && let [.., final_stmt] = block.stmts
             && final_stmt.hir_id != stmt.hir_id
             && !is_from_proc_macro(cx, expr)
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 1181dfc0ef9..c257f83afc8 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -1489,6 +1489,43 @@ pub fn is_else_clause(tcx: TyCtxt<'_>, expr: &Expr<'_>) -> bool {
     }
 }
 
+/// Checks if the given expression is a part of `let else`
+/// returns `true` for both the `init` and the `else` part
+pub fn is_inside_let_else(tcx: TyCtxt<'_>, expr: &Expr<'_>) -> bool {
+    let mut child_id = expr.hir_id;
+    for (parent_id, node) in tcx.hir().parent_iter(child_id) {
+        if let Node::Local(Local {
+            init: Some(init),
+            els: Some(els),
+            ..
+        }) = node
+            && (init.hir_id == child_id || els.hir_id == child_id)
+        {
+            return true;
+        }
+
+        child_id = parent_id;
+    }
+
+    false
+}
+
+/// Checks if the given expression is the else clause of a `let else` expression
+pub fn is_else_clause_in_let_else(tcx: TyCtxt<'_>, expr: &Expr<'_>) -> bool {
+    let mut child_id = expr.hir_id;
+    for (parent_id, node) in tcx.hir().parent_iter(child_id) {
+        if let Node::Local(Local { els: Some(els), .. }) = node
+            && els.hir_id == child_id
+        {
+            return true;
+        }
+
+        child_id = parent_id;
+    }
+
+    false
+}
+
 /// Checks whether the given `Expr` is a range equivalent to a `RangeFull`.
 /// For the lower bound, this means that:
 /// - either there is none
diff --git a/tests/ui/needless_return_with_question_mark.fixed b/tests/ui/needless_return_with_question_mark.fixed
index 52d54180921..d5932ebcf12 100644
--- a/tests/ui/needless_return_with_question_mark.fixed
+++ b/tests/ui/needless_return_with_question_mark.fixed
@@ -4,6 +4,7 @@
     clippy::no_effect,
     clippy::unit_arg,
     clippy::useless_conversion,
+    clippy::diverging_sub_expression,
     unused
 )]
 
@@ -35,5 +36,26 @@ fn main() -> Result<(), ()> {
     with_span! {
         return Err(())?;
     }
+
+    // Issue #11765
+    // Should not lint
+    let Some(s) = Some("") else {
+        return Err(())?;
+    };
+
+    let Some(s) = Some("") else {
+        let Some(s) = Some("") else {
+            return Err(())?;
+        };
+
+        return Err(())?;
+    };
+
+    let Some(_): Option<()> = ({
+        return Err(())?;
+    }) else {
+        panic!();
+    };
+
     Err(())
 }
diff --git a/tests/ui/needless_return_with_question_mark.rs b/tests/ui/needless_return_with_question_mark.rs
index d253cae4dc2..2485e25f05c 100644
--- a/tests/ui/needless_return_with_question_mark.rs
+++ b/tests/ui/needless_return_with_question_mark.rs
@@ -4,6 +4,7 @@
     clippy::no_effect,
     clippy::unit_arg,
     clippy::useless_conversion,
+    clippy::diverging_sub_expression,
     unused
 )]
 
@@ -35,5 +36,26 @@ fn main() -> Result<(), ()> {
     with_span! {
         return Err(())?;
     }
+
+    // Issue #11765
+    // Should not lint
+    let Some(s) = Some("") else {
+        return Err(())?;
+    };
+
+    let Some(s) = Some("") else {
+        let Some(s) = Some("") else {
+            return Err(())?;
+        };
+
+        return Err(())?;
+    };
+
+    let Some(_): Option<()> = ({
+        return Err(())?;
+    }) else {
+        panic!();
+    };
+
     Err(())
 }
diff --git a/tests/ui/needless_return_with_question_mark.stderr b/tests/ui/needless_return_with_question_mark.stderr
index 0de0633803b..580970a41aa 100644
--- a/tests/ui/needless_return_with_question_mark.stderr
+++ b/tests/ui/needless_return_with_question_mark.stderr
@@ -1,5 +1,5 @@
 error: unneeded `return` statement with `?` operator
-  --> $DIR/needless_return_with_question_mark.rs:27:5
+  --> $DIR/needless_return_with_question_mark.rs:28:5
    |
 LL |     return Err(())?;
    |     ^^^^^^^ help: remove it
-- 
cgit 1.4.1-3-g733a5


From 3f6b29ad32680d15f878ac89b80402ea447ed306 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Tue, 14 Nov 2023 13:52:44 +0100
Subject: [`impl_trait_in_params`]: fix span calculation

---
 clippy_lints/src/functions/impl_trait_in_params.rs | 26 +++++-----------------
 tests/ui/crashes/ice-11803.rs                      |  9 ++++++++
 tests/ui/crashes/ice-11803.stderr                  | 26 ++++++++++++++++++++++
 3 files changed, 41 insertions(+), 20 deletions(-)
 create mode 100644 tests/ui/crashes/ice-11803.rs
 create mode 100644 tests/ui/crashes/ice-11803.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/functions/impl_trait_in_params.rs b/clippy_lints/src/functions/impl_trait_in_params.rs
index 4afff8a2434..8fba41c0e24 100644
--- a/clippy_lints/src/functions/impl_trait_in_params.rs
+++ b/clippy_lints/src/functions/impl_trait_in_params.rs
@@ -5,18 +5,10 @@ use rustc_hir as hir;
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::{Body, GenericParam, Generics, HirId, ImplItem, ImplItemKind, TraitItem, TraitItemKind};
 use rustc_lint::LateContext;
-use rustc_span::symbol::Ident;
-use rustc_span::{BytePos, Span};
 
 use super::IMPL_TRAIT_IN_PARAMS;
 
-fn report(
-    cx: &LateContext<'_>,
-    param: &GenericParam<'_>,
-    ident: &Ident,
-    generics: &Generics<'_>,
-    first_param_span: Span,
-) {
+fn report(cx: &LateContext<'_>, param: &GenericParam<'_>, generics: &Generics<'_>) {
     // No generics with nested generics, and no generics like FnMut(x)
     span_lint_and_then(
         cx,
@@ -35,12 +27,7 @@ fn report(
                 );
             } else {
                 diag.span_suggestion_with_style(
-                    Span::new(
-                        first_param_span.lo() - rustc_span::BytePos(1),
-                        ident.span.hi(),
-                        ident.span.ctxt(),
-                        ident.span.parent(),
-                    ),
+                    generics.span,
                     "add a type parameter",
                     format!("<{{ /* Generic name */ }}: {}>", &param.name.ident().as_str()[5..]),
                     rustc_errors::Applicability::HasPlaceholders,
@@ -52,13 +39,13 @@ fn report(
 }
 
 pub(super) fn check_fn<'tcx>(cx: &LateContext<'_>, kind: &'tcx FnKind<'_>, body: &'tcx Body<'_>, hir_id: HirId) {
-    if let FnKind::ItemFn(ident, generics, _) = kind
+    if let FnKind::ItemFn(_, generics, _) = kind
         && cx.tcx.visibility(cx.tcx.hir().body_owner_def_id(body.id())).is_public()
         && !is_in_test_function(cx.tcx, hir_id)
     {
         for param in generics.params {
             if param.is_impl_trait() {
-                report(cx, param, ident, generics, body.params[0].span);
+                report(cx, param, generics);
             };
         }
     }
@@ -76,7 +63,7 @@ pub(super) fn check_impl_item(cx: &LateContext<'_>, impl_item: &ImplItem<'_>) {
     {
         for param in impl_item.generics.params {
             if param.is_impl_trait() {
-                report(cx, param, &impl_item.ident, impl_item.generics, body.params[0].span);
+                report(cx, param, impl_item.generics);
             }
         }
     }
@@ -92,8 +79,7 @@ pub(super) fn check_trait_item(cx: &LateContext<'_>, trait_item: &TraitItem<'_>,
     {
         for param in trait_item.generics.params {
             if param.is_impl_trait() {
-                let sp = trait_item.ident.span.with_hi(trait_item.ident.span.hi() + BytePos(1));
-                report(cx, param, &trait_item.ident, trait_item.generics, sp.shrink_to_hi());
+                report(cx, param, trait_item.generics);
             }
         }
     }
diff --git a/tests/ui/crashes/ice-11803.rs b/tests/ui/crashes/ice-11803.rs
new file mode 100644
index 00000000000..1bb8bf0c746
--- /dev/null
+++ b/tests/ui/crashes/ice-11803.rs
@@ -0,0 +1,9 @@
+//@no-rustfix
+
+#![warn(clippy::impl_trait_in_params)]
+
+pub fn g<T: IntoIterator<Item = impl Iterator<Item = impl Clone>>>() {
+    extern "C" fn implementation_detail() {}
+}
+
+fn main() {}
diff --git a/tests/ui/crashes/ice-11803.stderr b/tests/ui/crashes/ice-11803.stderr
new file mode 100644
index 00000000000..b8289048a8b
--- /dev/null
+++ b/tests/ui/crashes/ice-11803.stderr
@@ -0,0 +1,26 @@
+error: `impl Trait` used as a function parameter
+  --> $DIR/ice-11803.rs:5:54
+   |
+LL | pub fn g<T: IntoIterator<Item = impl Iterator<Item = impl Clone>>>() {
+   |                                                      ^^^^^^^^^^
+   |
+   = note: `-D clippy::impl-trait-in-params` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::impl_trait_in_params)]`
+help: add a type parameter
+   |
+LL | pub fn g<T: IntoIterator<Item = impl Iterator<Item = impl Clone>>, { /* Generic name */ }: Clone>() {
+   |                                                                  +++++++++++++++++++++++++++++++
+
+error: `impl Trait` used as a function parameter
+  --> $DIR/ice-11803.rs:5:33
+   |
+LL | pub fn g<T: IntoIterator<Item = impl Iterator<Item = impl Clone>>>() {
+   |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: add a type parameter
+   |
+LL | pub fn g<T: IntoIterator<Item = impl Iterator<Item = impl Clone>>, { /* Generic name */ }: Iterator<Item = impl Clone>>() {
+   |                                                                  +++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From a9d42e6d6d8ce6fe9789c8d06223b7b2e28ff253 Mon Sep 17 00:00:00 2001
From: Yudai Fukushima <49578068+granddaifuku@users.noreply.github.com>
Date: Wed, 8 Nov 2023 17:03:07 +0000
Subject: fix: reduce [`manual_memcpy`] indexing when array length is same to
 loop range

Format

refactor: extract function to shrink function length

fix: remove cmp to calculate range

fix: replace if_chain with let chains
---
 clippy_lints/src/loops/manual_memcpy.rs            | 47 +++++++++++++++++++---
 tests/ui/manual_memcpy/without_loop_counters.rs    | 20 +++++++++
 .../ui/manual_memcpy/without_loop_counters.stderr  | 31 +++++++++++++-
 3 files changed, 90 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/manual_memcpy.rs b/clippy_lints/src/loops/manual_memcpy.rs
index 89f70519c20..40d56240b9d 100644
--- a/clippy_lints/src/loops/manual_memcpy.rs
+++ b/clippy_lints/src/loops/manual_memcpy.rs
@@ -178,7 +178,9 @@ fn build_manual_memcpy_suggestion<'tcx>(
     let dst_base_str = snippet(cx, dst.base.span, "???");
     let src_base_str = snippet(cx, src.base.span, "???");
 
-    let dst = if dst_offset == sugg::EMPTY && dst_limit == sugg::EMPTY {
+    let dst = if (dst_offset == sugg::EMPTY && dst_limit == sugg::EMPTY)
+        || is_array_length_equal_to_range(cx, start, end, dst.base)
+    {
         dst_base_str
     } else {
         format!("{dst_base_str}[{}..{}]", dst_offset.maybe_par(), dst_limit.maybe_par()).into()
@@ -190,11 +192,13 @@ fn build_manual_memcpy_suggestion<'tcx>(
         "clone_from_slice"
     };
 
-    format!(
-        "{dst}.{method_str}(&{src_base_str}[{}..{}]);",
-        src_offset.maybe_par(),
-        src_limit.maybe_par()
-    )
+    let src = if is_array_length_equal_to_range(cx, start, end, src.base) {
+        src_base_str
+    } else {
+        format!("{src_base_str}[{}..{}]", src_offset.maybe_par(), src_limit.maybe_par()).into()
+    };
+
+    format!("{dst}.{method_str}(&{src});")
 }
 
 /// a wrapper of `Sugg`. Besides what `Sugg` do, this removes unnecessary `0`;
@@ -452,3 +456,34 @@ fn get_loop_counters<'a, 'tcx>(
             .into()
     })
 }
+
+fn is_array_length_equal_to_range(cx: &LateContext<'_>, start: &Expr<'_>, end: &Expr<'_>, arr: &Expr<'_>) -> bool {
+    fn extract_lit_value(expr: &Expr<'_>) -> Option<u128> {
+        if let ExprKind::Lit(lit) = expr.kind
+            && let ast::LitKind::Int(value, _) = lit.node
+        {
+            Some(value)
+        } else {
+            None
+        }
+    }
+
+    let arr_ty = cx.typeck_results().expr_ty(arr).peel_refs();
+
+    if let ty::Array(_, s) = arr_ty.kind() {
+        let size: u128 = if let Some(size) = s.try_eval_target_usize(cx.tcx, cx.param_env) {
+            size.into()
+        } else {
+            return false;
+        };
+
+        let range = match (extract_lit_value(start), extract_lit_value(end)) {
+            (Some(start_value), Some(end_value)) => end_value - start_value,
+            _ => return false,
+        };
+
+        size == range
+    } else {
+        false
+    }
+}
diff --git a/tests/ui/manual_memcpy/without_loop_counters.rs b/tests/ui/manual_memcpy/without_loop_counters.rs
index a224001a3df..8146091a2bb 100644
--- a/tests/ui/manual_memcpy/without_loop_counters.rs
+++ b/tests/ui/manual_memcpy/without_loop_counters.rs
@@ -138,6 +138,26 @@ pub fn manual_copy(src: &[i32], dst: &mut [i32], dst2: &mut [i32]) {
     for i in 0..dst.len() {
         dst[i] = src[i];
     }
+
+    // Range is equal to array length
+    let src = [0, 1, 2, 3, 4];
+    let mut dst = [0; 4];
+    for i in 0..4 {
+        //~^ ERROR: it looks like you're manually copying between slices
+        dst[i] = src[i];
+    }
+
+    let mut dst = [0; 6];
+    for i in 0..5 {
+        //~^ ERROR: it looks like you're manually copying between slices
+        dst[i] = src[i];
+    }
+
+    let mut dst = [0; 5];
+    for i in 0..5 {
+        //~^ ERROR: it looks like you're manually copying between slices
+        dst[i] = src[i];
+    }
 }
 
 #[warn(clippy::needless_range_loop, clippy::manual_memcpy)]
diff --git a/tests/ui/manual_memcpy/without_loop_counters.stderr b/tests/ui/manual_memcpy/without_loop_counters.stderr
index b9dbda6ede7..4b5cd274da7 100644
--- a/tests/ui/manual_memcpy/without_loop_counters.stderr
+++ b/tests/ui/manual_memcpy/without_loop_counters.stderr
@@ -106,7 +106,7 @@ LL | /     for i in 0..5 {
 LL | |
 LL | |         dst[i - 0] = src[i];
 LL | |     }
-   | |_____^ help: try replacing the loop by: `dst[..5].copy_from_slice(&src[..5]);`
+   | |_____^ help: try replacing the loop by: `dst[..5].copy_from_slice(&src);`
 
 error: it looks like you're manually copying between slices
   --> $DIR/without_loop_counters.rs:121:5
@@ -120,11 +120,38 @@ LL | |     }
 error: it looks like you're manually copying between slices
   --> $DIR/without_loop_counters.rs:145:5
    |
+LL | /     for i in 0..4 {
+LL | |
+LL | |         dst[i] = src[i];
+LL | |     }
+   | |_____^ help: try replacing the loop by: `dst.copy_from_slice(&src[..4]);`
+
+error: it looks like you're manually copying between slices
+  --> $DIR/without_loop_counters.rs:151:5
+   |
+LL | /     for i in 0..5 {
+LL | |
+LL | |         dst[i] = src[i];
+LL | |     }
+   | |_____^ help: try replacing the loop by: `dst[..5].copy_from_slice(&src);`
+
+error: it looks like you're manually copying between slices
+  --> $DIR/without_loop_counters.rs:157:5
+   |
+LL | /     for i in 0..5 {
+LL | |
+LL | |         dst[i] = src[i];
+LL | |     }
+   | |_____^ help: try replacing the loop by: `dst.copy_from_slice(&src);`
+
+error: it looks like you're manually copying between slices
+  --> $DIR/without_loop_counters.rs:165:5
+   |
 LL | /     for i in 0..src.len() {
 LL | |
 LL | |         dst[i] = src[i].clone();
 LL | |     }
    | |_____^ help: try replacing the loop by: `dst[..src.len()].clone_from_slice(&src[..]);`
 
-error: aborting due to 13 previous errors
+error: aborting due to 16 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 9401cf21e463d9808291357cd4fb1effa9254d4f Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Tue, 14 Nov 2023 18:04:48 +0100
Subject: Update version attribute for 1.74 lints

---
 clippy_lints/src/attrs.rs                             | 2 +-
 clippy_lints/src/implied_bounds_in_impls.rs           | 2 +-
 clippy_lints/src/missing_asserts_for_indexing.rs      | 2 +-
 clippy_lints/src/needless_borrows_for_generic_args.rs | 2 +-
 clippy_lints/src/reserve_after_initialization.rs      | 2 +-
 clippy_lints/src/unnecessary_map_on_constructor.rs    | 2 +-
 6 files changed, 6 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs
index 240ff859764..3801857bc3f 100644
--- a/clippy_lints/src/attrs.rs
+++ b/clippy_lints/src/attrs.rs
@@ -371,7 +371,7 @@ declare_clippy_lint! {
     ///     let _ = 1 / random();
     /// }
     /// ```
-    #[clippy::version = "1.73.0"]
+    #[clippy::version = "1.74.0"]
     pub SHOULD_PANIC_WITHOUT_EXPECT,
     pedantic,
     "ensures that all `should_panic` attributes specify its expected panic message"
diff --git a/clippy_lints/src/implied_bounds_in_impls.rs b/clippy_lints/src/implied_bounds_in_impls.rs
index ff27a5d666d..232d8eeb11b 100644
--- a/clippy_lints/src/implied_bounds_in_impls.rs
+++ b/clippy_lints/src/implied_bounds_in_impls.rs
@@ -43,7 +43,7 @@ declare_clippy_lint! {
     ///     Box::new(123)
     /// }
     /// ```
-    #[clippy::version = "1.73.0"]
+    #[clippy::version = "1.74.0"]
     pub IMPLIED_BOUNDS_IN_IMPLS,
     nursery,
     "specifying bounds that are implied by other bounds in `impl Trait` type"
diff --git a/clippy_lints/src/missing_asserts_for_indexing.rs b/clippy_lints/src/missing_asserts_for_indexing.rs
index dccf72d3c84..ff2792faf57 100644
--- a/clippy_lints/src/missing_asserts_for_indexing.rs
+++ b/clippy_lints/src/missing_asserts_for_indexing.rs
@@ -57,7 +57,7 @@ declare_clippy_lint! {
     ///     v[0] + v[1] + v[2] + v[3]
     /// }
     /// ```
-    #[clippy::version = "1.70.0"]
+    #[clippy::version = "1.74.0"]
     pub MISSING_ASSERTS_FOR_INDEXING,
     restriction,
     "indexing into a slice multiple times without an `assert`"
diff --git a/clippy_lints/src/needless_borrows_for_generic_args.rs b/clippy_lints/src/needless_borrows_for_generic_args.rs
index dcfb109a4c4..f25475aaa8e 100644
--- a/clippy_lints/src/needless_borrows_for_generic_args.rs
+++ b/clippy_lints/src/needless_borrows_for_generic_args.rs
@@ -50,7 +50,7 @@ declare_clippy_lint! {
     /// let x = "foo";
     /// f(x);
     /// ```
-    #[clippy::version = "pre 1.29.0"]
+    #[clippy::version = "1.74.0"]
     pub NEEDLESS_BORROWS_FOR_GENERIC_ARGS,
     style,
     "taking a reference that is going to be automatically dereferenced"
diff --git a/clippy_lints/src/reserve_after_initialization.rs b/clippy_lints/src/reserve_after_initialization.rs
index 1975946c6e6..b4842e7d48a 100644
--- a/clippy_lints/src/reserve_after_initialization.rs
+++ b/clippy_lints/src/reserve_after_initialization.rs
@@ -26,7 +26,7 @@ declare_clippy_lint! {
     /// ```no_run
     /// let mut v: Vec<usize> = Vec::with_capacity(10);
     /// ```
-    #[clippy::version = "1.73.0"]
+    #[clippy::version = "1.74.0"]
     pub RESERVE_AFTER_INITIALIZATION,
     complexity,
     "`reserve` called immediately after `Vec` creation"
diff --git a/clippy_lints/src/unnecessary_map_on_constructor.rs b/clippy_lints/src/unnecessary_map_on_constructor.rs
index 9107b2b99b8..06c017ea15a 100644
--- a/clippy_lints/src/unnecessary_map_on_constructor.rs
+++ b/clippy_lints/src/unnecessary_map_on_constructor.rs
@@ -23,7 +23,7 @@ declare_clippy_lint! {
     /// ```no_run
     /// Some(i32::swap_bytes(4));
     /// ```
-    #[clippy::version = "1.73.0"]
+    #[clippy::version = "1.74.0"]
     pub UNNECESSARY_MAP_ON_CONSTRUCTOR,
     complexity,
     "using `map`/`map_err` on `Option` or `Result` constructors"
-- 
cgit 1.4.1-3-g733a5


From b3073c536b349e6c80e24d8e85182d6d990c4c50 Mon Sep 17 00:00:00 2001
From: hrxi <hrrrxi@gmail.com>
Date: Tue, 14 Nov 2023 23:15:14 +0100
Subject: Change `if_same_then_else` to be a `style` lint

CC #3770

From https://github.com/rust-lang/rust-clippy/issues/3770#issuecomment-687565594 (@flip1995):

> Oh I thought I replied to this: I definitely see now that having this
> as a correctness lint might be the wrong categorization. What we might
> want to do is to just allow this lint, if there are comments in the
> arm bodies. But a good first step would be to downgrade this lint to
> style or complexity. I would vote for style since merging two arms is
> not always less complex.
---
 clippy_lints/src/copies.rs           | 2 +-
 tests/ui/needless_bool_assign.stderr | 3 ++-
 2 files changed, 3 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/copies.rs b/clippy_lints/src/copies.rs
index e3a09636e24..3b6d4886ba3 100644
--- a/clippy_lints/src/copies.rs
+++ b/clippy_lints/src/copies.rs
@@ -117,7 +117,7 @@ declare_clippy_lint! {
     /// ```
     #[clippy::version = "pre 1.29.0"]
     pub IF_SAME_THEN_ELSE,
-    correctness,
+    style,
     "`if` with the same `then` and `else` blocks"
 }
 
diff --git a/tests/ui/needless_bool_assign.stderr b/tests/ui/needless_bool_assign.stderr
index 7866c89bd61..244a88e6691 100644
--- a/tests/ui/needless_bool_assign.stderr
+++ b/tests/ui/needless_bool_assign.stderr
@@ -48,7 +48,8 @@ LL |       } else {
 LL | |         a.field = true;
 LL | |     }
    | |_____^
-   = note: `#[deny(clippy::if_same_then_else)]` on by default
+   = note: `-D clippy::if-same-then-else` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::if_same_then_else)]`
 
 error: aborting due to 4 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From a86a57079dcbd5144343a4dbc3dd318702a12ea5 Mon Sep 17 00:00:00 2001
From: Jacherr <jwc2002@outlook.com>
Date: Wed, 15 Nov 2023 00:14:38 +0000
Subject: replace lint with `span_lint_and_then`

---
 clippy_lints/src/casts/cast_possible_wrap.rs | 13 ++++++-------
 1 file changed, 6 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/cast_possible_wrap.rs b/clippy_lints/src/casts/cast_possible_wrap.rs
index ffa571abb39..2ddb0f00ecd 100644
--- a/clippy_lints/src/casts/cast_possible_wrap.rs
+++ b/clippy_lints/src/casts/cast_possible_wrap.rs
@@ -1,5 +1,6 @@
+use clippy_utils::diagnostics::span_lint_and_then;
 use rustc_hir::Expr;
-use rustc_lint::{LateContext, LintContext};
+use rustc_lint::LateContext;
 use rustc_middle::ty::Ty;
 
 use super::{utils, CAST_POSSIBLE_WRAP};
@@ -78,13 +79,11 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_from: Ty<'_>, ca
         ),
     };
 
-    cx.struct_span_lint(CAST_POSSIBLE_WRAP, expr.span, message, |diag| {
+    span_lint_and_then(cx, CAST_POSSIBLE_WRAP, expr.span, &message, |diag| {
         if let EmitState::LintOnPtrSize(16) = should_lint {
             diag
-            .note("`usize` and `isize` may be as small as 16 bits on some platforms")
-            .note("for more information see https://doc.rust-lang.org/reference/types/numeric.html#machine-dependent-integer-types")
-        } else {
-            diag
-        }
+                .note("`usize` and `isize` may be as small as 16 bits on some platforms")
+                .note("for more information see https://doc.rust-lang.org/reference/types/numeric.html#machine-dependent-integer-types");
+        };
     });
 }
-- 
cgit 1.4.1-3-g733a5


From 11881bee6bd99852ed7777ecfa1bee241fdd4c73 Mon Sep 17 00:00:00 2001
From: Jacherr <jwc2002@outlook.com>
Date: Wed, 15 Nov 2023 01:10:20 +0000
Subject: also move `module_style` to `span_lint_x` functions

---
 clippy_lints/src/module_style.rs | 17 +++++++++++------
 1 file changed, 11 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/module_style.rs b/clippy_lints/src/module_style.rs
index b49a5614329..cd45467407e 100644
--- a/clippy_lints/src/module_style.rs
+++ b/clippy_lints/src/module_style.rs
@@ -1,3 +1,4 @@
+use clippy_utils::diagnostics::span_lint_and_help;
 use rustc_ast::ast;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_lint::{EarlyContext, EarlyLintPass, Level, LintContext};
@@ -124,11 +125,13 @@ impl EarlyLintPass for ModStyle {
                     correct.pop();
                     correct.push(folder);
                     correct.push("mod.rs");
-                    cx.struct_span_lint(
+                    span_lint_and_help(
+                        cx,
                         SELF_NAMED_MODULE_FILES,
                         Span::new(file.start_pos, file.start_pos, SyntaxContext::root(), None),
-                        format!("`mod.rs` files are required, found `{}`", path.display()),
-                        |lint| lint.help(format!("move `{}` to `{}`", path.display(), correct.display(),)),
+                        &format!("`mod.rs` files are required, found `{}`", path.display()),
+                        None,
+                        &format!("move `{}` to `{}`", path.display(), correct.display(),),
                     );
                 }
             }
@@ -162,11 +165,13 @@ fn check_self_named_mod_exists(cx: &EarlyContext<'_>, path: &Path, file: &Source
         mod_file.pop();
         mod_file.set_extension("rs");
 
-        cx.struct_span_lint(
+        span_lint_and_help(
+            cx,
             MOD_MODULE_FILES,
             Span::new(file.start_pos, file.start_pos, SyntaxContext::root(), None),
-            format!("`mod.rs` files are not allowed, found `{}`", path.display()),
-            |lint| lint.help(format!("move `{}` to `{}`", path.display(), mod_file.display())),
+            &format!("`mod.rs` files are not allowed, found `{}`", path.display()),
+            None,
+            &format!("move `{}` to `{}`", path.display(), mod_file.display()),
         );
     }
 }
-- 
cgit 1.4.1-3-g733a5


From bb694615b83545a90477f0ad3030fc0cd84a1960 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Wed, 15 Nov 2023 14:59:11 +0100
Subject: [`ptr_arg`]: recognize methods that also exist on slices

---
 clippy_lints/src/ptr.rs                  |  4 ++-
 clippy_lints/src/vec.rs                  |  2 +-
 tests/ui/needless_pass_by_ref_mut.rs     |  7 ++++-
 tests/ui/needless_pass_by_ref_mut.stderr | 42 +++++++++++++--------------
 tests/ui/ptr_arg.rs                      |  6 ++++
 tests/ui/ptr_arg.stderr                  | 50 ++++++++++++++++++--------------
 6 files changed, 65 insertions(+), 46 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs
index 945b78185d9..6440a34dad6 100644
--- a/clippy_lints/src/ptr.rs
+++ b/clippy_lints/src/ptr.rs
@@ -29,6 +29,8 @@ use rustc_trait_selection::infer::InferCtxtExt as _;
 use rustc_trait_selection::traits::query::evaluate_obligation::InferCtxtExt as _;
 use std::{fmt, iter};
 
+use crate::vec::is_allowed_vec_method;
+
 declare_clippy_lint! {
     /// ### What it does
     /// This lint checks for function arguments of type `&String`, `&Vec`,
@@ -661,7 +663,7 @@ fn check_ptr_arg_usage<'tcx>(cx: &LateContext<'tcx>, body: &'tcx Body<'_>, args:
                             },
                             // If the types match check for methods which exist on both types. e.g. `Vec::len` and
                             // `slice::len`
-                            ty::Adt(def, _) if def.did() == args.ty_did => {
+                            ty::Adt(def, _) if def.did() == args.ty_did && !is_allowed_vec_method(self.cx, e) => {
                                 set_skip_flag();
                             },
                             _ => (),
diff --git a/clippy_lints/src/vec.rs b/clippy_lints/src/vec.rs
index 9ad2ad2d195..78e7129a88e 100644
--- a/clippy_lints/src/vec.rs
+++ b/clippy_lints/src/vec.rs
@@ -58,7 +58,7 @@ fn adjusts_to_slice(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
 /// Checks if the given expression is a method call to a `Vec` method
 /// that also exists on slices. If this returns true, it means that
 /// this expression does not actually require a `Vec` and could just work with an array.
-fn is_allowed_vec_method(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
+pub fn is_allowed_vec_method(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
     const ALLOWED_METHOD_NAMES: &[&str] = &["len", "as_ptr", "is_empty"];
 
     if let ExprKind::MethodCall(path, ..) = e.kind {
diff --git a/tests/ui/needless_pass_by_ref_mut.rs b/tests/ui/needless_pass_by_ref_mut.rs
index ea5e74c4c00..25a02bdd2f2 100644
--- a/tests/ui/needless_pass_by_ref_mut.rs
+++ b/tests/ui/needless_pass_by_ref_mut.rs
@@ -1,4 +1,9 @@
-#![allow(clippy::if_same_then_else, clippy::no_effect, clippy::redundant_closure_call)]
+#![allow(
+    clippy::if_same_then_else,
+    clippy::no_effect,
+    clippy::redundant_closure_call,
+    clippy::ptr_arg
+)]
 #![warn(clippy::needless_pass_by_ref_mut)]
 #![feature(lint_reasons)]
 //@no-rustfix
diff --git a/tests/ui/needless_pass_by_ref_mut.stderr b/tests/ui/needless_pass_by_ref_mut.stderr
index aa937c3f6af..92b753276ac 100644
--- a/tests/ui/needless_pass_by_ref_mut.stderr
+++ b/tests/ui/needless_pass_by_ref_mut.stderr
@@ -1,5 +1,5 @@
 error: this argument is a mutable reference, but not used mutably
-  --> $DIR/needless_pass_by_ref_mut.rs:7:11
+  --> $DIR/needless_pass_by_ref_mut.rs:12:11
    |
 LL | fn foo(s: &mut Vec<u32>, b: &u32, x: &mut u32) {
    |           ^^^^^^^^^^^^^ help: consider changing to: `&Vec<u32>`
@@ -8,79 +8,79 @@ LL | fn foo(s: &mut Vec<u32>, b: &u32, x: &mut u32) {
    = help: to override `-D warnings` add `#[allow(clippy::needless_pass_by_ref_mut)]`
 
 error: this argument is a mutable reference, but not used mutably
-  --> $DIR/needless_pass_by_ref_mut.rs:32:12
+  --> $DIR/needless_pass_by_ref_mut.rs:37:12
    |
 LL | fn foo6(s: &mut Vec<u32>) {
    |            ^^^^^^^^^^^^^ help: consider changing to: `&Vec<u32>`
 
 error: this argument is a mutable reference, but not used mutably
-  --> $DIR/needless_pass_by_ref_mut.rs:45:29
+  --> $DIR/needless_pass_by_ref_mut.rs:50:29
    |
 LL |     fn mushroom(&self, vec: &mut Vec<i32>) -> usize {
    |                             ^^^^^^^^^^^^^ help: consider changing to: `&Vec<i32>`
 
 error: this argument is a mutable reference, but not used mutably
-  --> $DIR/needless_pass_by_ref_mut.rs:50:31
+  --> $DIR/needless_pass_by_ref_mut.rs:55:31
    |
 LL |     fn badger(&mut self, vec: &mut Vec<i32>) -> usize {
    |                               ^^^^^^^^^^^^^ help: consider changing to: `&Vec<i32>`
 
 error: this argument is a mutable reference, but not used mutably
-  --> $DIR/needless_pass_by_ref_mut.rs:127:16
+  --> $DIR/needless_pass_by_ref_mut.rs:132:16
    |
 LL | async fn a1(x: &mut i32) {
    |                ^^^^^^^^ help: consider changing to: `&i32`
 
 error: this argument is a mutable reference, but not used mutably
-  --> $DIR/needless_pass_by_ref_mut.rs:131:16
+  --> $DIR/needless_pass_by_ref_mut.rs:136:16
    |
 LL | async fn a2(x: &mut i32, y: String) {
    |                ^^^^^^^^ help: consider changing to: `&i32`
 
 error: this argument is a mutable reference, but not used mutably
-  --> $DIR/needless_pass_by_ref_mut.rs:135:16
+  --> $DIR/needless_pass_by_ref_mut.rs:140:16
    |
 LL | async fn a3(x: &mut i32, y: String, z: String) {
    |                ^^^^^^^^ help: consider changing to: `&i32`
 
 error: this argument is a mutable reference, but not used mutably
-  --> $DIR/needless_pass_by_ref_mut.rs:139:16
+  --> $DIR/needless_pass_by_ref_mut.rs:144:16
    |
 LL | async fn a4(x: &mut i32, y: i32) {
    |                ^^^^^^^^ help: consider changing to: `&i32`
 
 error: this argument is a mutable reference, but not used mutably
-  --> $DIR/needless_pass_by_ref_mut.rs:143:24
+  --> $DIR/needless_pass_by_ref_mut.rs:148:24
    |
 LL | async fn a5(x: i32, y: &mut i32) {
    |                        ^^^^^^^^ help: consider changing to: `&i32`
 
 error: this argument is a mutable reference, but not used mutably
-  --> $DIR/needless_pass_by_ref_mut.rs:147:24
+  --> $DIR/needless_pass_by_ref_mut.rs:152:24
    |
 LL | async fn a6(x: i32, y: &mut i32) {
    |                        ^^^^^^^^ help: consider changing to: `&i32`
 
 error: this argument is a mutable reference, but not used mutably
-  --> $DIR/needless_pass_by_ref_mut.rs:151:32
+  --> $DIR/needless_pass_by_ref_mut.rs:156:32
    |
 LL | async fn a7(x: i32, y: i32, z: &mut i32) {
    |                                ^^^^^^^^ help: consider changing to: `&i32`
 
 error: this argument is a mutable reference, but not used mutably
-  --> $DIR/needless_pass_by_ref_mut.rs:155:24
+  --> $DIR/needless_pass_by_ref_mut.rs:160:24
    |
 LL | async fn a8(x: i32, a: &mut i32, y: i32, z: &mut i32) {
    |                        ^^^^^^^^ help: consider changing to: `&i32`
 
 error: this argument is a mutable reference, but not used mutably
-  --> $DIR/needless_pass_by_ref_mut.rs:155:45
+  --> $DIR/needless_pass_by_ref_mut.rs:160:45
    |
 LL | async fn a8(x: i32, a: &mut i32, y: i32, z: &mut i32) {
    |                                             ^^^^^^^^ help: consider changing to: `&i32`
 
 error: this argument is a mutable reference, but not used mutably
-  --> $DIR/needless_pass_by_ref_mut.rs:189:16
+  --> $DIR/needless_pass_by_ref_mut.rs:194:16
    |
 LL | fn cfg_warn(s: &mut u32) {}
    |                ^^^^^^^^ help: consider changing to: `&u32`
@@ -88,7 +88,7 @@ LL | fn cfg_warn(s: &mut u32) {}
    = note: this is cfg-gated and may require further changes
 
 error: this argument is a mutable reference, but not used mutably
-  --> $DIR/needless_pass_by_ref_mut.rs:195:20
+  --> $DIR/needless_pass_by_ref_mut.rs:200:20
    |
 LL |     fn cfg_warn(s: &mut u32) {}
    |                    ^^^^^^^^ help: consider changing to: `&u32`
@@ -96,19 +96,19 @@ LL |     fn cfg_warn(s: &mut u32) {}
    = note: this is cfg-gated and may require further changes
 
 error: this argument is a mutable reference, but not used mutably
-  --> $DIR/needless_pass_by_ref_mut.rs:209:39
+  --> $DIR/needless_pass_by_ref_mut.rs:214:39
    |
 LL | async fn inner_async2(x: &mut i32, y: &mut u32) {
    |                                       ^^^^^^^^ help: consider changing to: `&u32`
 
 error: this argument is a mutable reference, but not used mutably
-  --> $DIR/needless_pass_by_ref_mut.rs:217:26
+  --> $DIR/needless_pass_by_ref_mut.rs:222:26
    |
 LL | async fn inner_async3(x: &mut i32, y: &mut u32) {
    |                          ^^^^^^^^ help: consider changing to: `&i32`
 
 error: this argument is a mutable reference, but not used mutably
-  --> $DIR/needless_pass_by_ref_mut.rs:236:34
+  --> $DIR/needless_pass_by_ref_mut.rs:241:34
    |
 LL | pub async fn call_in_closure1(n: &mut str) {
    |                                  ^^^^^^^^ help: consider changing to: `&str`
@@ -116,7 +116,7 @@ LL | pub async fn call_in_closure1(n: &mut str) {
    = warning: changing this function will impact semver compatibility
 
 error: this argument is a mutable reference, but not used mutably
-  --> $DIR/needless_pass_by_ref_mut.rs:248:25
+  --> $DIR/needless_pass_by_ref_mut.rs:253:25
    |
 LL | pub async fn closure(n: &mut usize) -> impl '_ + FnMut() {
    |                         ^^^^^^^^^^ help: consider changing to: `&usize`
@@ -124,7 +124,7 @@ LL | pub async fn closure(n: &mut usize) -> impl '_ + FnMut() {
    = warning: changing this function will impact semver compatibility
 
 error: this argument is a mutable reference, but not used mutably
-  --> $DIR/needless_pass_by_ref_mut.rs:255:20
+  --> $DIR/needless_pass_by_ref_mut.rs:260:20
    |
 LL | pub fn closure2(n: &mut usize) -> impl '_ + FnMut() -> usize {
    |                    ^^^^^^^^^^ help: consider changing to: `&usize`
@@ -132,7 +132,7 @@ LL | pub fn closure2(n: &mut usize) -> impl '_ + FnMut() -> usize {
    = warning: changing this function will impact semver compatibility
 
 error: this argument is a mutable reference, but not used mutably
-  --> $DIR/needless_pass_by_ref_mut.rs:266:26
+  --> $DIR/needless_pass_by_ref_mut.rs:271:26
    |
 LL | pub async fn closure4(n: &mut usize) {
    |                          ^^^^^^^^^^ help: consider changing to: `&usize`
diff --git a/tests/ui/ptr_arg.rs b/tests/ui/ptr_arg.rs
index 91e2e7fd642..fcd716f4144 100644
--- a/tests/ui/ptr_arg.rs
+++ b/tests/ui/ptr_arg.rs
@@ -22,6 +22,12 @@ fn do_vec_mut(x: &mut Vec<i64>) {
     //Nothing here
 }
 
+fn do_vec_mut2(x: &mut Vec<i64>) {
+    //~^ ERROR: writing `&mut Vec` instead of `&mut [_]` involves a new object where a slice w
+    x.len();
+    x.is_empty();
+}
+
 fn do_str(x: &String) {
     //~^ ERROR: writing `&String` instead of `&str` involves a new object where a slice will d
     //Nothing here either
diff --git a/tests/ui/ptr_arg.stderr b/tests/ui/ptr_arg.stderr
index cccf2d62d63..35bd8509205 100644
--- a/tests/ui/ptr_arg.stderr
+++ b/tests/ui/ptr_arg.stderr
@@ -13,38 +13,44 @@ error: writing `&mut Vec` instead of `&mut [_]` involves a new object where a sl
 LL | fn do_vec_mut(x: &mut Vec<i64>) {
    |                  ^^^^^^^^^^^^^ help: change this to: `&mut [i64]`
 
+error: writing `&mut Vec` instead of `&mut [_]` involves a new object where a slice will do
+  --> $DIR/ptr_arg.rs:25:19
+   |
+LL | fn do_vec_mut2(x: &mut Vec<i64>) {
+   |                   ^^^^^^^^^^^^^ help: change this to: `&mut [i64]`
+
 error: writing `&String` instead of `&str` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:25:14
+  --> $DIR/ptr_arg.rs:31:14
    |
 LL | fn do_str(x: &String) {
    |              ^^^^^^^ help: change this to: `&str`
 
 error: writing `&mut String` instead of `&mut str` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:30:18
+  --> $DIR/ptr_arg.rs:36:18
    |
 LL | fn do_str_mut(x: &mut String) {
    |                  ^^^^^^^^^^^ help: change this to: `&mut str`
 
 error: writing `&PathBuf` instead of `&Path` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:35:15
+  --> $DIR/ptr_arg.rs:41:15
    |
 LL | fn do_path(x: &PathBuf) {
    |               ^^^^^^^^ help: change this to: `&Path`
 
 error: writing `&mut PathBuf` instead of `&mut Path` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:40:19
+  --> $DIR/ptr_arg.rs:46:19
    |
 LL | fn do_path_mut(x: &mut PathBuf) {
    |                   ^^^^^^^^^^^^ help: change this to: `&mut Path`
 
 error: writing `&Vec` instead of `&[_]` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:49:18
+  --> $DIR/ptr_arg.rs:55:18
    |
 LL |     fn do_vec(x: &Vec<i64>);
    |                  ^^^^^^^^^ help: change this to: `&[i64]`
 
 error: writing `&Vec` instead of `&[_]` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:63:14
+  --> $DIR/ptr_arg.rs:69:14
    |
 LL | fn cloned(x: &Vec<u8>) -> Vec<u8> {
    |              ^^^^^^^^
@@ -62,7 +68,7 @@ LL ~     x.to_owned()
    |
 
 error: writing `&String` instead of `&str` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:73:18
+  --> $DIR/ptr_arg.rs:79:18
    |
 LL | fn str_cloned(x: &String) -> String {
    |                  ^^^^^^^
@@ -79,7 +85,7 @@ LL ~     x.to_owned()
    |
 
 error: writing `&PathBuf` instead of `&Path` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:82:19
+  --> $DIR/ptr_arg.rs:88:19
    |
 LL | fn path_cloned(x: &PathBuf) -> PathBuf {
    |                   ^^^^^^^^
@@ -96,7 +102,7 @@ LL ~     x.to_path_buf()
    |
 
 error: writing `&String` instead of `&str` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:91:44
+  --> $DIR/ptr_arg.rs:97:44
    |
 LL | fn false_positive_capacity(x: &Vec<u8>, y: &String) {
    |                                            ^^^^^^^
@@ -111,19 +117,19 @@ LL ~     let c = y;
    |
 
 error: using a reference to `Cow` is not recommended
-  --> $DIR/ptr_arg.rs:106:25
+  --> $DIR/ptr_arg.rs:112:25
    |
 LL | fn test_cow_with_ref(c: &Cow<[i32]>) {}
    |                         ^^^^^^^^^^^ help: change this to: `&[i32]`
 
 error: writing `&String` instead of `&str` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:136:66
+  --> $DIR/ptr_arg.rs:142:66
    |
 LL |     fn some_allowed(#[allow(clippy::ptr_arg)] _v: &Vec<u32>, _s: &String) {}
    |                                                                  ^^^^^^^ help: change this to: `&str`
 
 error: writing `&Vec` instead of `&[_]` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:166:21
+  --> $DIR/ptr_arg.rs:172:21
    |
 LL |     fn foo_vec(vec: &Vec<u8>) {
    |                     ^^^^^^^^
@@ -137,7 +143,7 @@ LL ~         let _ = vec.to_owned().clone();
    |
 
 error: writing `&PathBuf` instead of `&Path` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:172:23
+  --> $DIR/ptr_arg.rs:178:23
    |
 LL |     fn foo_path(path: &PathBuf) {
    |                       ^^^^^^^^
@@ -151,7 +157,7 @@ LL ~         let _ = path.to_path_buf().clone();
    |
 
 error: writing `&PathBuf` instead of `&Path` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:178:21
+  --> $DIR/ptr_arg.rs:184:21
    |
 LL |     fn foo_str(str: &PathBuf) {
    |                     ^^^^^^^^
@@ -165,46 +171,46 @@ LL ~         let _ = str.to_path_buf().clone();
    |
 
 error: writing `&mut Vec` instead of `&mut [_]` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:185:29
+  --> $DIR/ptr_arg.rs:191:29
    |
 LL | fn mut_vec_slice_methods(v: &mut Vec<u32>) {
    |                             ^^^^^^^^^^^^^ help: change this to: `&mut [u32]`
 
 error: writing `&mut Vec` instead of `&mut [_]` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:248:17
+  --> $DIR/ptr_arg.rs:254:17
    |
 LL | fn dyn_trait(a: &mut Vec<u32>, b: &mut String, c: &mut PathBuf) {
    |                 ^^^^^^^^^^^^^ help: change this to: `&mut [u32]`
 
 error: writing `&mut String` instead of `&mut str` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:248:35
+  --> $DIR/ptr_arg.rs:254:35
    |
 LL | fn dyn_trait(a: &mut Vec<u32>, b: &mut String, c: &mut PathBuf) {
    |                                   ^^^^^^^^^^^ help: change this to: `&mut str`
 
 error: writing `&mut PathBuf` instead of `&mut Path` involves a new object where a slice will do
-  --> $DIR/ptr_arg.rs:248:51
+  --> $DIR/ptr_arg.rs:254:51
    |
 LL | fn dyn_trait(a: &mut Vec<u32>, b: &mut String, c: &mut PathBuf) {
    |                                                   ^^^^^^^^^^^^ help: change this to: `&mut Path`
 
 error: using a reference to `Cow` is not recommended
-  --> $DIR/ptr_arg.rs:274:39
+  --> $DIR/ptr_arg.rs:280:39
    |
 LL |     fn cow_elided_lifetime<'a>(input: &'a Cow<str>) -> &'a str {
    |                                       ^^^^^^^^^^^^ help: change this to: `&str`
 
 error: using a reference to `Cow` is not recommended
-  --> $DIR/ptr_arg.rs:280:36
+  --> $DIR/ptr_arg.rs:286:36
    |
 LL |     fn cow_bad_ret_ty_1<'a>(input: &'a Cow<'a, str>) -> &'static str {
    |                                    ^^^^^^^^^^^^^^^^ help: change this to: `&str`
 
 error: using a reference to `Cow` is not recommended
-  --> $DIR/ptr_arg.rs:284:40
+  --> $DIR/ptr_arg.rs:290:40
    |
 LL |     fn cow_bad_ret_ty_2<'a, 'b>(input: &'a Cow<'a, str>) -> &'b str {
    |                                        ^^^^^^^^^^^^^^^^ help: change this to: `&str`
 
-error: aborting due to 23 previous errors
+error: aborting due to 24 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From ef587d22a403ee5d637625d1ccf157efd6402ac3 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Wed, 15 Nov 2023 19:33:30 +0100
Subject: [`redundant_guards`]: lint empty string checks

---
 clippy_lints/src/matches/redundant_guards.rs | 53 +++++++++++++++++++++-------
 1 file changed, 40 insertions(+), 13 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/redundant_guards.rs b/clippy_lints/src/matches/redundant_guards.rs
index 4a44d596a46..9cc546de22e 100644
--- a/clippy_lints/src/matches/redundant_guards.rs
+++ b/clippy_lints/src/matches/redundant_guards.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::path_to_local;
-use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::source::snippet;
 use clippy_utils::visitors::{for_each_expr, is_local_used};
 use rustc_ast::{BorrowKind, LitKind};
 use rustc_errors::Applicability;
@@ -9,6 +9,7 @@ use rustc_hir::{Arm, BinOpKind, Expr, ExprKind, Guard, MatchSource, Node, Pat, P
 use rustc_lint::LateContext;
 use rustc_span::symbol::Ident;
 use rustc_span::Span;
+use std::borrow::Cow;
 use std::ops::ControlFlow;
 
 use super::REDUNDANT_GUARDS;
@@ -41,7 +42,14 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'tcx>]) {
                 (PatKind::Ref(..), None) | (_, Some(_)) => continue,
                 _ => arm.pat.span,
             };
-            emit_redundant_guards(cx, outer_arm, if_expr.span, pat_span, &binding, arm.guard);
+            emit_redundant_guards(
+                cx,
+                outer_arm,
+                if_expr.span,
+                snippet(cx, pat_span, "<binding>"),
+                &binding,
+                arm.guard,
+            );
         }
         // `Some(x) if let Some(2) = x`
         else if let Guard::IfLet(let_expr) = guard
@@ -52,7 +60,14 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'tcx>]) {
                 (PatKind::Ref(..), None) | (_, Some(_)) => continue,
                 _ => let_expr.pat.span,
             };
-            emit_redundant_guards(cx, outer_arm, let_expr.span, pat_span, &binding, None);
+            emit_redundant_guards(
+                cx,
+                outer_arm,
+                let_expr.span,
+                snippet(cx, pat_span, "<binding>"),
+                &binding,
+                None,
+            );
         }
         // `Some(x) if x == Some(2)`
         // `Some(x) if Some(2) == x`
@@ -78,7 +93,25 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'tcx>]) {
                 (ExprKind::AddrOf(..), None) | (_, Some(_)) => continue,
                 _ => pat.span,
             };
-            emit_redundant_guards(cx, outer_arm, if_expr.span, pat_span, &binding, None);
+            emit_redundant_guards(
+                cx,
+                outer_arm,
+                if_expr.span,
+                snippet(cx, pat_span, "<binding>"),
+                &binding,
+                None,
+            );
+        } else if let Guard::If(if_expr) = guard
+            && let ExprKind::MethodCall(path, recv, ..) = if_expr.kind
+            && let Some(binding) = get_pat_binding(cx, recv, outer_arm)
+        {
+            let ty = cx.typeck_results().expr_ty(recv).peel_refs();
+
+            if path.ident.name == sym!(is_empty) && ty.is_str() {
+                // `s if s.is_empty()` becomes ""
+
+                emit_redundant_guards(cx, outer_arm, if_expr.span, r#""""#.into(), &binding, None)
+            }
         }
     }
 }
@@ -134,19 +167,16 @@ fn emit_redundant_guards<'tcx>(
     cx: &LateContext<'tcx>,
     outer_arm: &Arm<'tcx>,
     guard_span: Span,
-    pat_span: Span,
+    binding_replacement: Cow<'static, str>,
     pat_binding: &PatBindingInfo,
     inner_guard: Option<Guard<'_>>,
 ) {
-    let mut app = Applicability::MaybeIncorrect;
-
     span_lint_and_then(
         cx,
         REDUNDANT_GUARDS,
         guard_span.source_callsite(),
         "redundant guard",
         |diag| {
-            let binding_replacement = snippet_with_applicability(cx, pat_span, "<binding_repl>", &mut app);
             let suggestion_span = match *pat_binding {
                 PatBindingInfo {
                     span,
@@ -170,14 +200,11 @@ fn emit_redundant_guards<'tcx>(
                                 Guard::IfLet(l) => ("if let", l.span),
                             };
 
-                            format!(
-                                " {prefix} {}",
-                                snippet_with_applicability(cx, span, "<guard>", &mut app),
-                            )
+                            format!(" {prefix} {}", snippet(cx, span, "<guard>"))
                         }),
                     ),
                 ],
-                app,
+                Applicability::MaybeIncorrect,
             );
         },
     );
-- 
cgit 1.4.1-3-g733a5


From 998a311a131068ea6d4c42ab21d076b0f386929d Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Wed, 15 Nov 2023 19:37:36 +0100
Subject: [`redundant_guards`]: lint empty slice checks

---
 clippy_lints/src/matches/redundant_guards.rs | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/redundant_guards.rs b/clippy_lints/src/matches/redundant_guards.rs
index 9cc546de22e..9133e785af0 100644
--- a/clippy_lints/src/matches/redundant_guards.rs
+++ b/clippy_lints/src/matches/redundant_guards.rs
@@ -106,11 +106,17 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'tcx>]) {
             && let Some(binding) = get_pat_binding(cx, recv, outer_arm)
         {
             let ty = cx.typeck_results().expr_ty(recv).peel_refs();
+            let slice_like = ty.is_slice() || ty.is_array();
 
-            if path.ident.name == sym!(is_empty) && ty.is_str() {
+            if path.ident.name == sym!(is_empty) {
                 // `s if s.is_empty()` becomes ""
+                // `arr if arr.is_empty()` becomes []
 
-                emit_redundant_guards(cx, outer_arm, if_expr.span, r#""""#.into(), &binding, None)
+                if ty.is_str() {
+                    emit_redundant_guards(cx, outer_arm, if_expr.span, r#""""#.into(), &binding, None)
+                } else if slice_like {
+                    emit_redundant_guards(cx, outer_arm, if_expr.span, "[]".into(), &binding, None)
+                }
             }
         }
     }
-- 
cgit 1.4.1-3-g733a5


From 676f1f6ef81ce5ee71f8eeecef4db9de6405900b Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Wed, 15 Nov 2023 20:53:43 +0100
Subject: [`redundant_guards`]: lint `slice::{starts_with,ends_with}`

---
 clippy_lints/src/matches/redundant_guards.rs | 36 ++++++++++++++++++++++++----
 1 file changed, 31 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/redundant_guards.rs b/clippy_lints/src/matches/redundant_guards.rs
index 9133e785af0..8d5907d6faf 100644
--- a/clippy_lints/src/matches/redundant_guards.rs
+++ b/clippy_lints/src/matches/redundant_guards.rs
@@ -102,22 +102,48 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'tcx>]) {
                 None,
             );
         } else if let Guard::If(if_expr) = guard
-            && let ExprKind::MethodCall(path, recv, ..) = if_expr.kind
+            && let ExprKind::MethodCall(path, recv, args, ..) = if_expr.kind
             && let Some(binding) = get_pat_binding(cx, recv, outer_arm)
         {
             let ty = cx.typeck_results().expr_ty(recv).peel_refs();
             let slice_like = ty.is_slice() || ty.is_array();
 
-            if path.ident.name == sym!(is_empty) {
+            let sugg = if path.ident.name == sym!(is_empty) {
                 // `s if s.is_empty()` becomes ""
                 // `arr if arr.is_empty()` becomes []
 
                 if ty.is_str() {
-                    emit_redundant_guards(cx, outer_arm, if_expr.span, r#""""#.into(), &binding, None)
+                    r#""""#.into()
                 } else if slice_like {
-                    emit_redundant_guards(cx, outer_arm, if_expr.span, "[]".into(), &binding, None)
+                    "[]".into()
+                } else {
+                    continue;
                 }
-            }
+            } else if slice_like
+                && let Some(needle) = args.first()
+                && let ExprKind::AddrOf(.., needle) = needle.kind
+                && let ExprKind::Array(needles) = needle.kind
+                && needles.iter().all(|needle| expr_can_be_pat(cx, needle))
+            {
+                // `arr if arr.starts_with(&[123])` becomes [123, ..]
+                // `arr if arr.ends_with(&[123])` becomes [.., 123]
+
+                let mut sugg = snippet(cx, needle.span, "<needle>").into_owned();
+
+                if path.ident.name == sym!(starts_with) {
+                    sugg.insert_str(sugg.len() - 1, ", ..");
+                } else if path.ident.name == sym!(ends_with) {
+                    sugg.insert_str(1, ".., ");
+                } else {
+                    continue;
+                }
+
+                sugg.into()
+            } else {
+                continue;
+            };
+
+            emit_redundant_guards(cx, outer_arm, if_expr.span, sugg, &binding, None);
         }
     }
 }
-- 
cgit 1.4.1-3-g733a5


From 1b4e2ef3d797b902a8d9870e5cc33795951ee619 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Wed, 15 Nov 2023 21:10:03 +0100
Subject: fix empty needle corner case and add tests

---
 clippy_lints/src/matches/redundant_guards.rs |  5 +-
 tests/ui/redundant_guards.fixed              | 57 ++++++++++++++++++
 tests/ui/redundant_guards.rs                 | 57 ++++++++++++++++++
 tests/ui/redundant_guards.stderr             | 86 +++++++++++++++++++++++++++-
 4 files changed, 203 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/redundant_guards.rs b/clippy_lints/src/matches/redundant_guards.rs
index 8d5907d6faf..365d178f548 100644
--- a/clippy_lints/src/matches/redundant_guards.rs
+++ b/clippy_lints/src/matches/redundant_guards.rs
@@ -127,10 +127,13 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'tcx>]) {
             {
                 // `arr if arr.starts_with(&[123])` becomes [123, ..]
                 // `arr if arr.ends_with(&[123])` becomes [.., 123]
+                // `arr if arr.starts_with(&[])` becomes [..]  (why would anyone write this?)
 
                 let mut sugg = snippet(cx, needle.span, "<needle>").into_owned();
 
-                if path.ident.name == sym!(starts_with) {
+                if needles.is_empty() {
+                    sugg.insert_str(1, "..");
+                } else if path.ident.name == sym!(starts_with) {
                     sugg.insert_str(sugg.len() - 1, ", ..");
                 } else if path.ident.name == sym!(ends_with) {
                     sugg.insert_str(1, ".., ");
diff --git a/tests/ui/redundant_guards.fixed b/tests/ui/redundant_guards.fixed
index f8af9092725..aef26ef225c 100644
--- a/tests/ui/redundant_guards.fixed
+++ b/tests/ui/redundant_guards.fixed
@@ -193,3 +193,60 @@ mod issue11465 {
         }
     }
 }
+
+fn issue11807() {
+    #![allow(clippy::single_match)]
+
+    match Some(Some("")) {
+        Some(Some("")) => {},
+        _ => {},
+    }
+
+    match Some(Some(String::new())) {
+        // Do not lint: String deref-coerces to &str
+        Some(Some(x)) if x.is_empty() => {},
+        _ => {},
+    }
+
+    match Some(Some(&[] as &[i32])) {
+        Some(Some([])) => {},
+        _ => {},
+    }
+
+    match Some(Some([] as [i32; 0])) {
+        Some(Some([])) => {},
+        _ => {},
+    }
+
+    match Some(Some(Vec::<()>::new())) {
+        // Do not lint: Vec deref-coerces to &[T]
+        Some(Some(x)) if x.is_empty() => {},
+        _ => {},
+    }
+
+    match Some(Some(&[] as &[i32])) {
+        Some(Some([..])) => {},
+        _ => {},
+    }
+
+    match Some(Some(&[] as &[i32])) {
+        Some(Some([1, ..])) => {},
+        _ => {},
+    }
+
+    match Some(Some(&[] as &[i32])) {
+        Some(Some([1, 2, ..])) => {},
+        _ => {},
+    }
+
+    match Some(Some(&[] as &[i32])) {
+        Some(Some([.., 1, 2])) => {},
+        _ => {},
+    }
+
+    match Some(Some(Vec::<i32>::new())) {
+        // Do not lint: deref coercion
+        Some(Some(x)) if x.starts_with(&[1, 2]) => {},
+        _ => {},
+    }
+}
diff --git a/tests/ui/redundant_guards.rs b/tests/ui/redundant_guards.rs
index b46f8a6207e..5d476f5b040 100644
--- a/tests/ui/redundant_guards.rs
+++ b/tests/ui/redundant_guards.rs
@@ -193,3 +193,60 @@ mod issue11465 {
         }
     }
 }
+
+fn issue11807() {
+    #![allow(clippy::single_match)]
+
+    match Some(Some("")) {
+        Some(Some(x)) if x.is_empty() => {},
+        _ => {},
+    }
+
+    match Some(Some(String::new())) {
+        // Do not lint: String deref-coerces to &str
+        Some(Some(x)) if x.is_empty() => {},
+        _ => {},
+    }
+
+    match Some(Some(&[] as &[i32])) {
+        Some(Some(x)) if x.is_empty() => {},
+        _ => {},
+    }
+
+    match Some(Some([] as [i32; 0])) {
+        Some(Some(x)) if x.is_empty() => {},
+        _ => {},
+    }
+
+    match Some(Some(Vec::<()>::new())) {
+        // Do not lint: Vec deref-coerces to &[T]
+        Some(Some(x)) if x.is_empty() => {},
+        _ => {},
+    }
+
+    match Some(Some(&[] as &[i32])) {
+        Some(Some(x)) if x.starts_with(&[]) => {},
+        _ => {},
+    }
+
+    match Some(Some(&[] as &[i32])) {
+        Some(Some(x)) if x.starts_with(&[1]) => {},
+        _ => {},
+    }
+
+    match Some(Some(&[] as &[i32])) {
+        Some(Some(x)) if x.starts_with(&[1, 2]) => {},
+        _ => {},
+    }
+
+    match Some(Some(&[] as &[i32])) {
+        Some(Some(x)) if x.ends_with(&[1, 2]) => {},
+        _ => {},
+    }
+
+    match Some(Some(Vec::<i32>::new())) {
+        // Do not lint: deref coercion
+        Some(Some(x)) if x.starts_with(&[1, 2]) => {},
+        _ => {},
+    }
+}
diff --git a/tests/ui/redundant_guards.stderr b/tests/ui/redundant_guards.stderr
index b8d7834e358..f78d2a814f9 100644
--- a/tests/ui/redundant_guards.stderr
+++ b/tests/ui/redundant_guards.stderr
@@ -203,5 +203,89 @@ LL -             B { ref c, .. } if matches!(c, &1) => {},
 LL +             B { c: 1, .. } => {},
    |
 
-error: aborting due to 17 previous errors
+error: redundant guard
+  --> $DIR/redundant_guards.rs:201:26
+   |
+LL |         Some(Some(x)) if x.is_empty() => {},
+   |                          ^^^^^^^^^^^^
+   |
+help: try
+   |
+LL -         Some(Some(x)) if x.is_empty() => {},
+LL +         Some(Some("")) => {},
+   |
+
+error: redundant guard
+  --> $DIR/redundant_guards.rs:212:26
+   |
+LL |         Some(Some(x)) if x.is_empty() => {},
+   |                          ^^^^^^^^^^^^
+   |
+help: try
+   |
+LL -         Some(Some(x)) if x.is_empty() => {},
+LL +         Some(Some([])) => {},
+   |
+
+error: redundant guard
+  --> $DIR/redundant_guards.rs:217:26
+   |
+LL |         Some(Some(x)) if x.is_empty() => {},
+   |                          ^^^^^^^^^^^^
+   |
+help: try
+   |
+LL -         Some(Some(x)) if x.is_empty() => {},
+LL +         Some(Some([])) => {},
+   |
+
+error: redundant guard
+  --> $DIR/redundant_guards.rs:228:26
+   |
+LL |         Some(Some(x)) if x.starts_with(&[]) => {},
+   |                          ^^^^^^^^^^^^^^^^^^
+   |
+help: try
+   |
+LL -         Some(Some(x)) if x.starts_with(&[]) => {},
+LL +         Some(Some([..])) => {},
+   |
+
+error: redundant guard
+  --> $DIR/redundant_guards.rs:233:26
+   |
+LL |         Some(Some(x)) if x.starts_with(&[1]) => {},
+   |                          ^^^^^^^^^^^^^^^^^^^
+   |
+help: try
+   |
+LL -         Some(Some(x)) if x.starts_with(&[1]) => {},
+LL +         Some(Some([1, ..])) => {},
+   |
+
+error: redundant guard
+  --> $DIR/redundant_guards.rs:238:26
+   |
+LL |         Some(Some(x)) if x.starts_with(&[1, 2]) => {},
+   |                          ^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: try
+   |
+LL -         Some(Some(x)) if x.starts_with(&[1, 2]) => {},
+LL +         Some(Some([1, 2, ..])) => {},
+   |
+
+error: redundant guard
+  --> $DIR/redundant_guards.rs:243:26
+   |
+LL |         Some(Some(x)) if x.ends_with(&[1, 2]) => {},
+   |                          ^^^^^^^^^^^^^^^^^^^^
+   |
+help: try
+   |
+LL -         Some(Some(x)) if x.ends_with(&[1, 2]) => {},
+LL +         Some(Some([.., 1, 2])) => {},
+   |
+
+error: aborting due to 24 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 8f9c738ce9b8912571761ac08e50585a77d270c3 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Wed, 15 Nov 2023 21:34:48 +0100
Subject: dogfood clippy

---
 clippy_lints/src/manual_async_fn.rs          | 15 ++---
 clippy_lints/src/matches/redundant_guards.rs | 90 ++++++++++++++++------------
 2 files changed, 57 insertions(+), 48 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_async_fn.rs b/clippy_lints/src/manual_async_fn.rs
index a5d91c949bc..f03cc89e13a 100644
--- a/clippy_lints/src/manual_async_fn.rs
+++ b/clippy_lints/src/manual_async_fn.rs
@@ -187,14 +187,11 @@ fn desugared_async_block<'tcx>(cx: &LateContext<'tcx>, block: &'tcx Block<'tcx>)
 }
 
 fn suggested_ret(cx: &LateContext<'_>, output: &Ty<'_>) -> Option<(&'static str, String)> {
-    match output.kind {
-        TyKind::Tup(tys) if tys.is_empty() => {
-            let sugg = "remove the return type";
-            Some((sugg, String::new()))
-        },
-        _ => {
-            let sugg = "return the output of the future directly";
-            snippet_opt(cx, output.span).map(|snip| (sugg, format!(" -> {snip}")))
-        },
+    if let TyKind::Tup([]) = output.kind {
+        let sugg = "remove the return type";
+        Some((sugg, String::new()))
+    } else {
+        let sugg = "return the output of the future directly";
+        snippet_opt(cx, output.span).map(|snip| (sugg, format!(" -> {snip}")))
     }
 }
diff --git a/clippy_lints/src/matches/redundant_guards.rs b/clippy_lints/src/matches/redundant_guards.rs
index 365d178f548..f57b22374c8 100644
--- a/clippy_lints/src/matches/redundant_guards.rs
+++ b/clippy_lints/src/matches/redundant_guards.rs
@@ -8,7 +8,7 @@ use rustc_hir::def::{DefKind, Res};
 use rustc_hir::{Arm, BinOpKind, Expr, ExprKind, Guard, MatchSource, Node, Pat, PatKind};
 use rustc_lint::LateContext;
 use rustc_span::symbol::Ident;
-use rustc_span::Span;
+use rustc_span::{Span, Symbol};
 use std::borrow::Cow;
 use std::ops::ControlFlow;
 
@@ -105,50 +105,62 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'tcx>]) {
             && let ExprKind::MethodCall(path, recv, args, ..) = if_expr.kind
             && let Some(binding) = get_pat_binding(cx, recv, outer_arm)
         {
-            let ty = cx.typeck_results().expr_ty(recv).peel_refs();
-            let slice_like = ty.is_slice() || ty.is_array();
-
-            let sugg = if path.ident.name == sym!(is_empty) {
-                // `s if s.is_empty()` becomes ""
-                // `arr if arr.is_empty()` becomes []
+            check_method_calls(cx, outer_arm, path.ident.name, recv, args, if_expr, &binding);
+        }
+    }
+}
 
-                if ty.is_str() {
-                    r#""""#.into()
-                } else if slice_like {
-                    "[]".into()
-                } else {
-                    continue;
-                }
-            } else if slice_like
-                && let Some(needle) = args.first()
-                && let ExprKind::AddrOf(.., needle) = needle.kind
-                && let ExprKind::Array(needles) = needle.kind
-                && needles.iter().all(|needle| expr_can_be_pat(cx, needle))
-            {
-                // `arr if arr.starts_with(&[123])` becomes [123, ..]
-                // `arr if arr.ends_with(&[123])` becomes [.., 123]
-                // `arr if arr.starts_with(&[])` becomes [..]  (why would anyone write this?)
+fn check_method_calls<'tcx>(
+    cx: &LateContext<'tcx>,
+    arm: &Arm<'tcx>,
+    method: Symbol,
+    recv: &Expr<'_>,
+    args: &[Expr<'_>],
+    if_expr: &Expr<'_>,
+    binding: &PatBindingInfo,
+) {
+    let ty = cx.typeck_results().expr_ty(recv).peel_refs();
+    let slice_like = ty.is_slice() || ty.is_array();
 
-                let mut sugg = snippet(cx, needle.span, "<needle>").into_owned();
+    let sugg = if method == sym!(is_empty) {
+        // `s if s.is_empty()` becomes ""
+        // `arr if arr.is_empty()` becomes []
 
-                if needles.is_empty() {
-                    sugg.insert_str(1, "..");
-                } else if path.ident.name == sym!(starts_with) {
-                    sugg.insert_str(sugg.len() - 1, ", ..");
-                } else if path.ident.name == sym!(ends_with) {
-                    sugg.insert_str(1, ".., ");
-                } else {
-                    continue;
-                }
+        if ty.is_str() {
+            r#""""#.into()
+        } else if slice_like {
+            "[]".into()
+        } else {
+            return;
+        }
+    } else if slice_like
+        && let Some(needle) = args.first()
+        && let ExprKind::AddrOf(.., needle) = needle.kind
+        && let ExprKind::Array(needles) = needle.kind
+        && needles.iter().all(|needle| expr_can_be_pat(cx, needle))
+    {
+        // `arr if arr.starts_with(&[123])` becomes [123, ..]
+        // `arr if arr.ends_with(&[123])` becomes [.., 123]
+        // `arr if arr.starts_with(&[])` becomes [..]  (why would anyone write this?)
 
-                sugg.into()
-            } else {
-                continue;
-            };
+        let mut sugg = snippet(cx, needle.span, "<needle>").into_owned();
 
-            emit_redundant_guards(cx, outer_arm, if_expr.span, sugg, &binding, None);
+        if needles.is_empty() {
+            sugg.insert_str(1, "..");
+        } else if method == sym!(starts_with) {
+            sugg.insert_str(sugg.len() - 1, ", ..");
+        } else if method == sym!(ends_with) {
+            sugg.insert_str(1, ".., ");
+        } else {
+            return;
         }
-    }
+
+        sugg.into()
+    } else {
+        return;
+    };
+
+    emit_redundant_guards(cx, arm, if_expr.span, sugg, binding, None);
 }
 
 struct PatBindingInfo {
-- 
cgit 1.4.1-3-g733a5


From 1e0597cb68134ae221765deb3f3e9dd6d66f7dcc Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Thu, 16 Nov 2023 17:28:37 +0100
Subject: [`match_same_arms`]: respect allow attrs on arms

---
 clippy_lints/src/matches/match_same_arms.rs | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/match_same_arms.rs b/clippy_lints/src/matches/match_same_arms.rs
index 6fc79faddbe..ba9ca7c5a52 100644
--- a/clippy_lints/src/matches/match_same_arms.rs
+++ b/clippy_lints/src/matches/match_same_arms.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::diagnostics::span_lint_hir_and_then;
 use clippy_utils::source::snippet;
 use clippy_utils::{is_lint_allowed, path_to_local, search_same, SpanlessEq, SpanlessHash};
 use core::cmp::Ordering;
@@ -106,9 +106,10 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>]) {
             if !cx.tcx.features().non_exhaustive_omitted_patterns_lint
                 || is_lint_allowed(cx, NON_EXHAUSTIVE_OMITTED_PATTERNS, arm2.hir_id)
             {
-                span_lint_and_then(
+                span_lint_hir_and_then(
                     cx,
                     MATCH_SAME_ARMS,
+                    arm1.hir_id,
                     arm1.span,
                     "this match arm has an identical body to the `_` wildcard arm",
                     |diag| {
@@ -126,9 +127,10 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>]) {
                 (arm2, arm1)
             };
 
-            span_lint_and_then(
+            span_lint_hir_and_then(
                 cx,
                 MATCH_SAME_ARMS,
+                keep_arm.hir_id,
                 keep_arm.span,
                 "this match arm has an identical body to another arm",
                 |diag| {
-- 
cgit 1.4.1-3-g733a5


From 74451cd060c72b1bf31e1d8da6a3ecf32a76c7fd Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Thu, 16 Nov 2023 11:32:08 +0100
Subject: Extend `maybe_misused_cfg` lint over `cfg(test)`

---
 clippy_lints/src/attrs.rs | 13 +++++++++++++
 1 file changed, 13 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs
index 64bfa8d904c..2d8f8e18fda 100644
--- a/clippy_lints/src/attrs.rs
+++ b/clippy_lints/src/attrs.rs
@@ -946,6 +946,19 @@ fn check_nested_misused_cfg(cx: &EarlyContext<'_>, items: &[NestedMetaItem]) {
             }
             if let MetaItemKind::List(list) = &meta.kind {
                 check_nested_misused_cfg(cx, list);
+            // If this is not a list, then we check for `cfg(test)`.
+            } else if let Some(ident) = meta.ident()
+                && matches!(ident.name.as_str(), "tests" | "Test")
+            {
+                span_lint_and_sugg(
+                    cx,
+                    MAYBE_MISUSED_CFG,
+                    meta.span,
+                    &format!("'test' may be misspelled as '{}'", ident.name.as_str()),
+                    "do you mean",
+                    "test".to_string(),
+                    Applicability::MaybeIncorrect,
+                );
             }
         }
     }
-- 
cgit 1.4.1-3-g733a5


From f08037c2f51bf65825a707a2dff1bcbe0c45278d Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Thu, 16 Nov 2023 13:40:48 +0100
Subject: Update documentation for `MAYBE_MISUSED_CFG` lint

---
 clippy_lints/src/attrs.rs | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs
index 2d8f8e18fda..cf244324ae1 100644
--- a/clippy_lints/src/attrs.rs
+++ b/clippy_lints/src/attrs.rs
@@ -407,20 +407,26 @@ declare_clippy_lint! {
     /// Checks for `#[cfg(features = "...")]` and suggests to replace it with
     /// `#[cfg(feature = "...")]`.
     ///
+    /// It also checks if `cfg(test)` was misspelled.
+    ///
     /// ### Why is this bad?
-    /// Misspelling `feature` as `features` can be sometimes hard to spot. It
+    /// Misspelling `feature` as `features` or `test` as `tests` can be sometimes hard to spot. It
     /// may cause conditional compilation not work quietly.
     ///
     /// ### Example
     /// ```no_run
     /// #[cfg(features = "some-feature")]
     /// fn conditional() { }
+    /// #[cfg(tests)]
+    /// mod tests { }
     /// ```
     ///
     /// Use instead:
     /// ```no_run
     /// #[cfg(feature = "some-feature")]
     /// fn conditional() { }
+    /// #[cfg(test)]
+    /// mod tests { }
     /// ```
     #[clippy::version = "1.69.0"]
     pub MAYBE_MISUSED_CFG,
-- 
cgit 1.4.1-3-g733a5


From 4143acf4c8a911a562ef1112a55f84c922a5c20f Mon Sep 17 00:00:00 2001
From: Nathan Stocks <cleancut@github.com>
Date: Thu, 16 Nov 2023 17:18:48 -0700
Subject: fix typo

---
 clippy_lints/src/unnecessary_map_on_constructor.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unnecessary_map_on_constructor.rs b/clippy_lints/src/unnecessary_map_on_constructor.rs
index 06c017ea15a..3a6d0895c72 100644
--- a/clippy_lints/src/unnecessary_map_on_constructor.rs
+++ b/clippy_lints/src/unnecessary_map_on_constructor.rs
@@ -9,7 +9,7 @@ use rustc_span::sym;
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Suggest removing the use of a may (or map_err) method when an Option or Result is being constructed.
+    /// Suggest removing the use of a map (or map_err) method when an Option or Result is being constructed.
     ///
     /// ### Why is this bad?
     /// It introduces unnecessary complexity. In this case the function can be used directly and
-- 
cgit 1.4.1-3-g733a5


From 2d9fc6dfc8160f47f13da9be3fb5fc48ef62880f Mon Sep 17 00:00:00 2001
From: J-ZhengLi <lizheng135@huawei.com>
Date: Fri, 17 Nov 2023 18:10:50 +0800
Subject: implement unoptimized code logic for [`infinite_loops`]

---
 CHANGELOG.md                             |   1 +
 clippy_lints/src/declared_lints.rs       |   1 +
 clippy_lints/src/loops/infinite_loops.rs |  92 +++++++++++
 clippy_lints/src/loops/mod.rs            |  79 +++++++++-
 tests/ui/infinite_loops.rs               | 259 +++++++++++++++++++++++++++++++
 tests/ui/infinite_loops.stderr           | 147 ++++++++++++++++++
 6 files changed, 571 insertions(+), 8 deletions(-)
 create mode 100644 clippy_lints/src/loops/infinite_loops.rs
 create mode 100644 tests/ui/infinite_loops.rs
 create mode 100644 tests/ui/infinite_loops.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index e74df808e06..5c62cf51559 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5147,6 +5147,7 @@ Released 2018-09-13
 [`inefficient_to_string`]: https://rust-lang.github.io/rust-clippy/master/index.html#inefficient_to_string
 [`infallible_destructuring_match`]: https://rust-lang.github.io/rust-clippy/master/index.html#infallible_destructuring_match
 [`infinite_iter`]: https://rust-lang.github.io/rust-clippy/master/index.html#infinite_iter
+[`infinite_loops`]: https://rust-lang.github.io/rust-clippy/master/index.html#infinite_loops
 [`inherent_to_string`]: https://rust-lang.github.io/rust-clippy/master/index.html#inherent_to_string
 [`inherent_to_string_shadow_display`]: https://rust-lang.github.io/rust-clippy/master/index.html#inherent_to_string_shadow_display
 [`init_numbered_fields`]: https://rust-lang.github.io/rust-clippy/master/index.html#init_numbered_fields
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 85854a0dfb7..7520b57891e 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -263,6 +263,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::loops::EXPLICIT_INTO_ITER_LOOP_INFO,
     crate::loops::EXPLICIT_ITER_LOOP_INFO,
     crate::loops::FOR_KV_MAP_INFO,
+    crate::loops::INFINITE_LOOPS_INFO,
     crate::loops::ITER_NEXT_LOOP_INFO,
     crate::loops::MANUAL_FIND_INFO,
     crate::loops::MANUAL_FLATTEN_INFO,
diff --git a/clippy_lints/src/loops/infinite_loops.rs b/clippy_lints/src/loops/infinite_loops.rs
new file mode 100644
index 00000000000..b97cd8bd006
--- /dev/null
+++ b/clippy_lints/src/loops/infinite_loops.rs
@@ -0,0 +1,92 @@
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::is_lint_allowed;
+use hir::intravisit::{walk_expr, Visitor};
+use hir::{Block, Destination, Expr, ExprKind, FnRetTy, Ty, TyKind};
+use rustc_ast::Label;
+use rustc_errors::Applicability;
+use rustc_hir as hir;
+use rustc_lint::LateContext;
+
+use super::INFINITE_LOOPS;
+
+pub(super) fn check(
+    cx: &LateContext<'_>,
+    expr: &Expr<'_>,
+    loop_block: &Block<'_>,
+    label: Option<Label>,
+    parent_fn_ret_ty: FnRetTy<'_>,
+) {
+    if is_lint_allowed(cx, INFINITE_LOOPS, expr.hir_id)
+        || matches!(
+            parent_fn_ret_ty,
+            FnRetTy::Return(Ty {
+                kind: TyKind::Never,
+                ..
+            })
+        )
+    {
+        return;
+    }
+
+    // First, find any `break` or `return` without entering any inner loop,
+    // then, find `return` or labeled `break` which breaks this loop with entering inner loop,
+    // otherwise this loop is a infinite loop.
+    let mut direct_br_or_ret_finder = BreakOrRetFinder::default();
+    direct_br_or_ret_finder.visit_block(loop_block);
+
+    let is_finite_loop = direct_br_or_ret_finder.found || {
+        let mut inner_br_or_ret_finder = BreakOrRetFinder {
+            label,
+            enter_nested_loop: true,
+            ..Default::default()
+        };
+        inner_br_or_ret_finder.visit_block(loop_block);
+        inner_br_or_ret_finder.found
+    };
+
+    if !is_finite_loop {
+        span_lint_and_then(cx, INFINITE_LOOPS, expr.span, "infinite loop detected", |diag| {
+            if let FnRetTy::DefaultReturn(ret_span) = parent_fn_ret_ty {
+                diag.span_suggestion(
+                    ret_span,
+                    "if this is intentional, consider specifing `!` as function return",
+                    " -> !",
+                    Applicability::MaybeIncorrect,
+                );
+            } else {
+                diag.span_help(
+                    expr.span,
+                    "if this is not intended, add a `break` or `return` condition in this loop",
+                );
+            }
+        });
+    }
+}
+
+#[derive(Default)]
+struct BreakOrRetFinder {
+    label: Option<Label>,
+    found: bool,
+    enter_nested_loop: bool,
+}
+
+impl<'hir> Visitor<'hir> for BreakOrRetFinder {
+    fn visit_expr(&mut self, ex: &'hir Expr<'_>) {
+        match &ex.kind {
+            ExprKind::Break(Destination { label, .. }, ..) => {
+                // When entering nested loop, only by breaking this loop's label
+                // would be considered as exiting this loop.
+                if self.enter_nested_loop {
+                    if label.is_some() && *label == self.label {
+                        self.found = true;
+                    }
+                } else {
+                    self.found = true;
+                }
+            },
+            ExprKind::Ret(..) => self.found = true,
+            ExprKind::Loop(..) if !self.enter_nested_loop => (),
+            _ => walk_expr(self, ex),
+        }
+    }
+}
diff --git a/clippy_lints/src/loops/mod.rs b/clippy_lints/src/loops/mod.rs
index b99e0fd814f..c69d0b68cf4 100644
--- a/clippy_lints/src/loops/mod.rs
+++ b/clippy_lints/src/loops/mod.rs
@@ -3,6 +3,7 @@ mod explicit_counter_loop;
 mod explicit_into_iter_loop;
 mod explicit_iter_loop;
 mod for_kv_map;
+mod infinite_loops;
 mod iter_next_loop;
 mod manual_find;
 mod manual_flatten;
@@ -22,7 +23,7 @@ mod while_let_on_iterator;
 
 use clippy_config::msrvs::Msrv;
 use clippy_utils::higher;
-use rustc_hir::{Expr, ExprKind, LoopSource, Pat};
+use rustc_hir::{self as hir, Expr, ExprKind, LoopSource, Pat};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::Span;
@@ -635,20 +636,64 @@ declare_clippy_lint! {
     "checking for emptiness of a `Vec` in the loop condition and popping an element in the body"
 }
 
-pub struct Loops {
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for infinite loops in a function where the return type is not `!`
+    /// and lint accordingly.
+    ///
+    /// ### Why is this bad?
+    /// A loop should be gently exited somewhere, or at lease mark its parent function as
+    /// never return (`!`).
+    ///
+    /// ### Example
+    /// ```no_run,ignore
+    /// fn run_forever() {
+    ///     loop {
+    ///         // do something
+    ///     }
+    /// }
+    /// ```
+    /// If infinite loops are as intended:
+    /// ```no_run,ignore
+    /// fn run_forever() -> ! {
+    ///     loop {
+    ///         // do something
+    ///     }
+    /// }
+    /// ```
+    /// Otherwise add a `break` or `return` condition:
+    /// ```no_run,ignore
+    /// fn run_forever() {
+    ///     loop {
+    ///         // do something
+    ///         if condition {
+    ///             break;
+    ///         }
+    ///     }
+    /// }
+    /// ```
+    #[clippy::version = "1.75.0"]
+    pub INFINITE_LOOPS,
+    restriction,
+    "possibly unintended infinite loops"
+}
+
+pub struct Loops<'tcx> {
     msrv: Msrv,
     enforce_iter_loop_reborrow: bool,
+    parent_fn_ret_ty: Option<hir::FnRetTy<'tcx>>,
 }
-impl Loops {
+impl<'tcx> Loops<'tcx> {
     pub fn new(msrv: Msrv, enforce_iter_loop_reborrow: bool) -> Self {
         Self {
             msrv,
             enforce_iter_loop_reborrow,
+            parent_fn_ret_ty: None,
         }
     }
 }
 
-impl_lint_pass!(Loops => [
+impl_lint_pass!(Loops<'_> => [
     MANUAL_MEMCPY,
     MANUAL_FLATTEN,
     NEEDLESS_RANGE_LOOP,
@@ -669,9 +714,10 @@ impl_lint_pass!(Loops => [
     MANUAL_FIND,
     MANUAL_WHILE_LET_SOME,
     UNUSED_ENUMERATE_INDEX,
+    INFINITE_LOOPS,
 ]);
 
-impl<'tcx> LateLintPass<'tcx> for Loops {
+impl<'tcx> LateLintPass<'tcx> for Loops<'tcx> {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         let for_loop = higher::ForLoop::hir(expr);
         if let Some(higher::ForLoop {
@@ -707,10 +753,13 @@ impl<'tcx> LateLintPass<'tcx> for Loops {
         // check for `loop { if let {} else break }` that could be `while let`
         // (also matches an explicit "match" instead of "if let")
         // (even if the "match" or "if let" is used for declaration)
-        if let ExprKind::Loop(block, _, LoopSource::Loop, _) = expr.kind {
+        if let ExprKind::Loop(block, label, LoopSource::Loop, _) = expr.kind {
             // also check for empty `loop {}` statements, skipping those in #[panic_handler]
             empty_loop::check(cx, expr, block);
             while_let_loop::check(cx, expr, block);
+            if let Some(parent_fn_ret_ty) = self.parent_fn_ret_ty {
+                infinite_loops::check(cx, expr, block, label, parent_fn_ret_ty);
+            }
         }
 
         while_let_on_iterator::check(cx, expr);
@@ -722,11 +771,25 @@ impl<'tcx> LateLintPass<'tcx> for Loops {
         }
     }
 
+    fn check_fn(
+        &mut self,
+        _: &LateContext<'tcx>,
+        kind: hir::intravisit::FnKind<'tcx>,
+        decl: &'tcx hir::FnDecl<'tcx>,
+        _: &'tcx hir::Body<'tcx>,
+        _: Span,
+        _: rustc_span::def_id::LocalDefId,
+    ) {
+        if let hir::intravisit::FnKind::ItemFn(..) = kind {
+            self.parent_fn_ret_ty = Some(decl.output);
+        }
+    }
+
     extract_msrv_attr!(LateContext);
 }
 
-impl Loops {
-    fn check_for_loop<'tcx>(
+impl<'tcx> Loops<'tcx> {
+    fn check_for_loop(
         &self,
         cx: &LateContext<'tcx>,
         pat: &'tcx Pat<'_>,
diff --git a/tests/ui/infinite_loops.rs b/tests/ui/infinite_loops.rs
new file mode 100644
index 00000000000..54ab63d80dd
--- /dev/null
+++ b/tests/ui/infinite_loops.rs
@@ -0,0 +1,259 @@
+//@no-rustfix
+#![allow(clippy::never_loop)]
+#![warn(clippy::infinite_loops)]
+
+fn do_something() {}
+
+fn no_break() {
+    loop {
+        //~^ ERROR: infinite loop detected
+        do_something();
+    }
+}
+
+fn no_break_never_ret() -> ! {
+    loop {
+        do_something();
+    }
+}
+
+fn no_break_never_ret_noise() {
+    loop {
+        fn inner_fn() -> ! {
+            std::process::exit(0);
+        }
+        do_something();
+    }
+}
+
+fn has_direct_break_1() {
+    loop {
+        do_something();
+        break;
+    }
+}
+
+fn has_direct_break_2() {
+    'outer: loop {
+        do_something();
+        break 'outer;
+    }
+}
+
+fn has_indirect_break_1(cond: bool) {
+    'outer: loop {
+        loop {
+            if cond {
+                break 'outer;
+            }
+        }
+    }
+}
+
+fn has_indirect_break_2(stop_num: i32) {
+    'outer: loop {
+        for x in 0..5 {
+            if x == stop_num {
+                break 'outer;
+            }
+        }
+    }
+}
+
+fn break_inner_but_not_outer_1(cond: bool) {
+    loop {
+        //~^ ERROR: infinite loop detected
+        loop {
+            if cond {
+                break;
+            }
+        }
+    }
+}
+
+fn break_inner_but_not_outer_2(cond: bool) {
+    loop {
+        //~^ ERROR: infinite loop detected
+        'inner: loop {
+            loop {
+                if cond {
+                    break 'inner;
+                }
+            }
+        }
+    }
+}
+
+fn break_outer_but_not_inner() {
+    loop {
+        loop {
+            //~^ ERROR: infinite loop detected
+            do_something();
+        }
+        break;
+    }
+}
+
+fn can_break_both_inner_and_outer(cond: bool) {
+    'outer: loop {
+        loop {
+            if cond {
+                break 'outer;
+            } else {
+                break;
+            }
+        }
+    }
+}
+
+fn break_wrong_loop(cond: bool) {
+    // 'inner has statement to break 'outer loop, but it was breaked early by a labeled child loop
+    'outer: loop {
+        loop {
+            //~^ ERROR: infinite loop detected
+            'inner: loop {
+                loop {
+                    loop {
+                        break 'inner;
+                    }
+                    break 'outer;
+                }
+            }
+        }
+    }
+}
+
+fn has_direct_return(cond: bool) {
+    loop {
+        if cond {
+            return;
+        }
+    }
+}
+
+fn ret_in_inner(cond: bool) {
+    loop {
+        loop {
+            if cond {
+                return;
+            }
+        }
+    }
+}
+
+enum Foo {
+    A,
+    B,
+    C,
+}
+
+fn match_like() {
+    let opt: Option<u8> = Some(1);
+    loop {
+        //~^ ERROR: infinite loop detected
+        match opt {
+            Some(v) => {
+                println!("{v}");
+            },
+            None => {
+                do_something();
+            },
+        }
+    }
+
+    loop {
+        match opt {
+            Some(v) => {
+                println!("{v}");
+            },
+            None => {
+                do_something();
+                break;
+            },
+        }
+    }
+
+    let result: Result<u8, u16> = Ok(1);
+    loop {
+        let _val = match result {
+            Ok(1) => 1 + 1,
+            Ok(v) => v / 2,
+            Err(_) => return,
+        };
+    }
+
+    loop {
+        let Ok(_val) = result else { return };
+    }
+
+    loop {
+        let Ok(_val) = result.map(|v| 10) else { break };
+    }
+
+    loop {
+        //~^ ERROR: infinite loop detected
+        let _x = matches!(result, Ok(v) if v != 0).then_some(0);
+    }
+
+    loop {
+        //~^ ERROR: infinite loop detected
+        // This `return` does not return the function, so it doesn't count
+        let _x = matches!(result, Ok(v) if v != 0).then(|| {
+            if true {
+                return;
+            }
+            do_something();
+        });
+    }
+
+    let mut val = 0;
+    let mut fooc = Foo::C;
+
+    loop {
+        val = match fooc {
+            Foo::A => 0,
+            Foo::B => {
+                fooc = Foo::C;
+                1
+            },
+            Foo::C => break,
+        };
+    }
+
+    loop {
+        val = match fooc {
+            Foo::A => 0,
+            Foo::B => 1,
+            Foo::C => {
+                break;
+            },
+        };
+    }
+}
+
+macro_rules! set_or_ret {
+    ($opt:expr, $a:expr) => {{
+        match $opt {
+            Some(val) => $a = val,
+            None => return,
+        }
+    }};
+}
+
+fn ret_in_macro(opt: Option<u8>) {
+    let opt: Option<u8> = Some(1);
+    let mut a: u8 = 0;
+    loop {
+        set_or_ret!(opt, a);
+    }
+
+    let res: Result<bool, u8> = Ok(true);
+    loop {
+        match res {
+            Ok(true) => set_or_ret!(opt, a),
+            _ => do_something(),
+        }
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/infinite_loops.stderr b/tests/ui/infinite_loops.stderr
new file mode 100644
index 00000000000..f6bca43f1a4
--- /dev/null
+++ b/tests/ui/infinite_loops.stderr
@@ -0,0 +1,147 @@
+error: infinite loop detected
+  --> $DIR/infinite_loops.rs:8:5
+   |
+LL | /     loop {
+LL | |
+LL | |         do_something();
+LL | |     }
+   | |_____^
+   |
+   = note: `-D clippy::infinite-loops` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::infinite_loops)]`
+help: if this is intentional, consider specifing `!` as function return
+   |
+LL | fn no_break() -> ! {
+   |               ++++
+
+error: infinite loop detected
+  --> $DIR/infinite_loops.rs:21:5
+   |
+LL | /     loop {
+LL | |         fn inner_fn() -> ! {
+LL | |             std::process::exit(0);
+LL | |         }
+LL | |         do_something();
+LL | |     }
+   | |_____^
+   |
+help: if this is intentional, consider specifing `!` as function return
+   |
+LL | fn no_break_never_ret_noise() -> ! {
+   |                               ++++
+
+error: infinite loop detected
+  --> $DIR/infinite_loops.rs:64:5
+   |
+LL | /     loop {
+LL | |
+LL | |         loop {
+LL | |             if cond {
+...  |
+LL | |         }
+LL | |     }
+   | |_____^
+   |
+help: if this is intentional, consider specifing `!` as function return
+   |
+LL | fn break_inner_but_not_outer_1(cond: bool) -> ! {
+   |                                            ++++
+
+error: infinite loop detected
+  --> $DIR/infinite_loops.rs:75:5
+   |
+LL | /     loop {
+LL | |
+LL | |         'inner: loop {
+LL | |             loop {
+...  |
+LL | |         }
+LL | |     }
+   | |_____^
+   |
+help: if this is intentional, consider specifing `!` as function return
+   |
+LL | fn break_inner_but_not_outer_2(cond: bool) -> ! {
+   |                                            ++++
+
+error: infinite loop detected
+  --> $DIR/infinite_loops.rs:89:9
+   |
+LL | /         loop {
+LL | |
+LL | |             do_something();
+LL | |         }
+   | |_________^
+   |
+help: if this is intentional, consider specifing `!` as function return
+   |
+LL | fn break_outer_but_not_inner() -> ! {
+   |                                ++++
+
+error: infinite loop detected
+  --> $DIR/infinite_loops.rs:112:9
+   |
+LL | /         loop {
+LL | |
+LL | |             'inner: loop {
+LL | |                 loop {
+...  |
+LL | |             }
+LL | |         }
+   | |_________^
+   |
+help: if this is intentional, consider specifing `!` as function return
+   |
+LL | fn break_wrong_loop(cond: bool) -> ! {
+   |                                 ++++
+
+error: infinite loop detected
+  --> $DIR/infinite_loops.rs:152:5
+   |
+LL | /     loop {
+LL | |
+LL | |         match opt {
+LL | |             Some(v) => {
+...  |
+LL | |         }
+LL | |     }
+   | |_____^
+   |
+help: if this is intentional, consider specifing `!` as function return
+   |
+LL | fn match_like() -> ! {
+   |                 ++++
+
+error: infinite loop detected
+  --> $DIR/infinite_loops.rs:193:5
+   |
+LL | /     loop {
+LL | |
+LL | |         let _x = matches!(result, Ok(v) if v != 0).then_some(0);
+LL | |     }
+   | |_____^
+   |
+help: if this is intentional, consider specifing `!` as function return
+   |
+LL | fn match_like() -> ! {
+   |                 ++++
+
+error: infinite loop detected
+  --> $DIR/infinite_loops.rs:198:5
+   |
+LL | /     loop {
+LL | |
+LL | |         // This `return` does not return the function, so it doesn't count
+LL | |         let _x = matches!(result, Ok(v) if v != 0).then(|| {
+...  |
+LL | |         });
+LL | |     }
+   | |_____^
+   |
+help: if this is intentional, consider specifing `!` as function return
+   |
+LL | fn match_like() -> ! {
+   |                 ++++
+
+error: aborting due to 9 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From bffb664fbf094f53d51bec66d1b042265db1cbad Mon Sep 17 00:00:00 2001
From: Kevin Reid <kpreid@switchb.org>
Date: Thu, 16 Nov 2023 10:11:13 -0800
Subject: Fix markup in recent lint documentation.

Also make the examples more realistic by hiding the `;`s so as not to
visibly be discarding the computed value.
---
 clippy_lints/src/methods/mod.rs                    |  8 +++++---
 clippy_lints/src/unnecessary_map_on_constructor.rs | 11 +++++++----
 2 files changed, 12 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 57c3913944f..3166a33fc2f 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3609,7 +3609,7 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of `as_str()` on a `String`` chained with a method available on the `String` itself.
+    /// Checks for usage of `as_str()` on a `String` chained with a method available on the `String` itself.
     ///
     /// ### Why is this bad?
     /// The `as_str()` conversion is pointless and can be removed for simplicity and cleanliness.
@@ -3618,14 +3618,16 @@ declare_clippy_lint! {
     /// ```no_run
     /// # #![allow(unused)]
     /// let owned_string = "This is a string".to_owned();
-    /// owned_string.as_str().as_bytes();
+    /// owned_string.as_str().as_bytes()
+    /// # ;
     /// ```
     ///
     /// Use instead:
     /// ```no_run
     /// # #![allow(unused)]
     /// let owned_string = "This is a string".to_owned();
-    /// owned_string.as_bytes();
+    /// owned_string.as_bytes()
+    /// # ;
     /// ```
     #[clippy::version = "1.74.0"]
     pub REDUNDANT_AS_STR,
diff --git a/clippy_lints/src/unnecessary_map_on_constructor.rs b/clippy_lints/src/unnecessary_map_on_constructor.rs
index 3a6d0895c72..39a83bfa005 100644
--- a/clippy_lints/src/unnecessary_map_on_constructor.rs
+++ b/clippy_lints/src/unnecessary_map_on_constructor.rs
@@ -9,19 +9,22 @@ use rustc_span::sym;
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Suggest removing the use of a map (or map_err) method when an Option or Result is being constructed.
+    /// Suggests removing the use of a `map()` (or `map_err()`) method when an `Option` or `Result`
+    ///  is being constructed.
     ///
     /// ### Why is this bad?
     /// It introduces unnecessary complexity. In this case the function can be used directly and
-    /// construct the Option or Result from the output.
+    /// construct the `Option` or `Result` from the output.
     ///
     /// ### Example
     /// ```no_run
-    /// Some(4).map(i32::swap_bytes);
+    /// Some(4).map(i32::swap_bytes)
+    /// # ;
     /// ```
     /// Use instead:
     /// ```no_run
-    /// Some(i32::swap_bytes(4));
+    /// Some(i32::swap_bytes(4))
+    /// # ;
     /// ```
     #[clippy::version = "1.74.0"]
     pub UNNECESSARY_MAP_ON_CONSTRUCTOR,
-- 
cgit 1.4.1-3-g733a5


From a2e396badfb1e36ba885480da4f7994fec1e2deb Mon Sep 17 00:00:00 2001
From: Lukas Lueg <lukas.lueg@gmail.com>
Date: Sat, 18 Nov 2023 13:50:18 +0100
Subject: Don't suggest `a.mul_add(b, c)` if parameters are not float

clippy::suboptimal_flops used to not check if the second parameter to f32/f64.mul_add() was float. Since the method is
only defined to take `Self` as paremters, the suggestion was wrong.

Fixes #11831
---
 clippy_lints/src/floating_point_arithmetic.rs |  8 ++++++--
 tests/ui/floating_point_mul_add.fixed         | 18 ++++++++++++++++++
 tests/ui/floating_point_mul_add.rs            | 18 ++++++++++++++++++
 3 files changed, 42 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/floating_point_arithmetic.rs b/clippy_lints/src/floating_point_arithmetic.rs
index d522873472b..de869b8377a 100644
--- a/clippy_lints/src/floating_point_arithmetic.rs
+++ b/clippy_lints/src/floating_point_arithmetic.rs
@@ -496,9 +496,13 @@ fn check_mul_add(cx: &LateContext<'_>, expr: &Expr<'_>) {
             if let BinOpKind::Sub = op { -sugg } else { sugg }
         };
 
-        let (recv, arg1, arg2) = if let Some((inner_lhs, inner_rhs)) = is_float_mul_expr(cx, lhs) {
+        let (recv, arg1, arg2) = if let Some((inner_lhs, inner_rhs)) = is_float_mul_expr(cx, lhs)
+            && cx.typeck_results().expr_ty(rhs).is_floating_point()
+        {
             (inner_lhs, Sugg::hir(cx, inner_rhs, ".."), maybe_neg_sugg(rhs))
-        } else if let Some((inner_lhs, inner_rhs)) = is_float_mul_expr(cx, rhs) {
+        } else if let Some((inner_lhs, inner_rhs)) = is_float_mul_expr(cx, rhs)
+            && cx.typeck_results().expr_ty(lhs).is_floating_point()
+        {
             (inner_lhs, maybe_neg_sugg(inner_rhs), Sugg::hir(cx, lhs, ".."))
         } else {
             return;
diff --git a/tests/ui/floating_point_mul_add.fixed b/tests/ui/floating_point_mul_add.fixed
index a4d6d49e57c..3ce2edf2c71 100644
--- a/tests/ui/floating_point_mul_add.fixed
+++ b/tests/ui/floating_point_mul_add.fixed
@@ -39,3 +39,21 @@ fn main() {
     // Cases where the lint shouldn't be applied
     let _ = (a * a + b * b).sqrt();
 }
+
+fn _issue11831() {
+    struct NotAFloat;
+
+    impl std::ops::Add<f64> for NotAFloat {
+        type Output = Self;
+
+        fn add(self, _: f64) -> Self {
+            NotAFloat
+        }
+    }
+
+    let a = NotAFloat;
+    let b = 1.0_f64;
+    let c = 1.0;
+
+    let _ = a + b * c;
+}
diff --git a/tests/ui/floating_point_mul_add.rs b/tests/ui/floating_point_mul_add.rs
index 262a20f0f55..b5e4a8db4db 100644
--- a/tests/ui/floating_point_mul_add.rs
+++ b/tests/ui/floating_point_mul_add.rs
@@ -39,3 +39,21 @@ fn main() {
     // Cases where the lint shouldn't be applied
     let _ = (a * a + b * b).sqrt();
 }
+
+fn _issue11831() {
+    struct NotAFloat;
+
+    impl std::ops::Add<f64> for NotAFloat {
+        type Output = Self;
+
+        fn add(self, _: f64) -> Self {
+            NotAFloat
+        }
+    }
+
+    let a = NotAFloat;
+    let b = 1.0_f64;
+    let c = 1.0;
+
+    let _ = a + b * c;
+}
-- 
cgit 1.4.1-3-g733a5


From 4de845e375c7679b919f624227a8004476e2c153 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Sat, 18 Nov 2023 14:59:24 +0100
Subject: [`missing_asserts_for_indexing`]: accept len equality checks

---
 clippy_lints/src/missing_asserts_for_indexing.rs | 21 ++++++---
 tests/ui/missing_asserts_for_indexing.fixed      | 15 +++++++
 tests/ui/missing_asserts_for_indexing.rs         | 15 +++++++
 tests/ui/missing_asserts_for_indexing.stderr     | 54 +++++++++++++++++++++++-
 4 files changed, 99 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/missing_asserts_for_indexing.rs b/clippy_lints/src/missing_asserts_for_indexing.rs
index ff2792faf57..01302c67f6a 100644
--- a/clippy_lints/src/missing_asserts_for_indexing.rs
+++ b/clippy_lints/src/missing_asserts_for_indexing.rs
@@ -52,7 +52,7 @@ declare_clippy_lint! {
     /// Use instead:
     /// ```no_run
     /// fn sum(v: &[u8]) -> u8 {
-    ///     assert!(v.len() > 4);
+    ///     assert!(v.len() > 3);
     ///     // no bounds checks
     ///     v[0] + v[1] + v[2] + v[3]
     /// }
@@ -87,6 +87,9 @@ enum LengthComparison {
     LengthLessThanOrEqualInt,
     /// `5 <= v.len()`
     IntLessThanOrEqualLength,
+    /// `5 == v.len()`
+    /// `v.len() == 5`
+    LengthEqualInt,
 }
 
 /// Extracts parts out of a length comparison expression.
@@ -114,6 +117,8 @@ fn len_comparison<'hir>(
         (Rel::Lt, _, int_lit_pat!(right)) => Some((LengthComparison::LengthLessThanInt, *right as usize, left)),
         (Rel::Le, int_lit_pat!(left), _) => Some((LengthComparison::IntLessThanOrEqualLength, *left as usize, right)),
         (Rel::Le, _, int_lit_pat!(right)) => Some((LengthComparison::LengthLessThanOrEqualInt, *right as usize, left)),
+        (Rel::Eq, int_lit_pat!(left), _) => Some((LengthComparison::LengthEqualInt, *left as usize, right)),
+        (Rel::Eq, _, int_lit_pat!(right)) => Some((LengthComparison::LengthEqualInt, *right as usize, left)),
         _ => None,
     }
 }
@@ -316,11 +321,11 @@ fn report_indexes(cx: &LateContext<'_>, map: &UnhashMap<u64, Vec<IndexEntry<'_>>
                 continue;
             };
 
-            match entry {
+            match *entry {
                 IndexEntry::AssertWithIndex {
                     highest_index,
                     asserted_len,
-                    indexes,
+                    ref indexes,
                     comparison,
                     assert_span,
                     slice,
@@ -343,6 +348,12 @@ fn report_indexes(cx: &LateContext<'_>, map: &UnhashMap<u64, Vec<IndexEntry<'_>>
                             "assert!({}.len() > {highest_index})",
                             snippet(cx, slice.span, "..")
                         )),
+                        // `highest_index` here is rather a length, so we need to add 1 to it
+                        LengthComparison::LengthEqualInt if asserted_len < highest_index + 1 => Some(format!(
+                            "assert!({}.len() == {})",
+                            snippet(cx, slice.span, ".."),
+                            highest_index + 1
+                        )),
                         _ => None,
                     };
 
@@ -354,7 +365,7 @@ fn report_indexes(cx: &LateContext<'_>, map: &UnhashMap<u64, Vec<IndexEntry<'_>>
                             indexes,
                             |diag| {
                                 diag.span_suggestion(
-                                    *assert_span,
+                                    assert_span,
                                     "provide the highest index that is indexed with",
                                     sugg,
                                     Applicability::MachineApplicable,
@@ -364,7 +375,7 @@ fn report_indexes(cx: &LateContext<'_>, map: &UnhashMap<u64, Vec<IndexEntry<'_>>
                     }
                 },
                 IndexEntry::IndexWithoutAssert {
-                    indexes,
+                    ref indexes,
                     highest_index,
                     slice,
                 } if indexes.len() > 1 => {
diff --git a/tests/ui/missing_asserts_for_indexing.fixed b/tests/ui/missing_asserts_for_indexing.fixed
index a96827259f5..ac44a6f3fdb 100644
--- a/tests/ui/missing_asserts_for_indexing.fixed
+++ b/tests/ui/missing_asserts_for_indexing.fixed
@@ -118,4 +118,19 @@ fn index_different_slice_in_same_expr(v1: &[u8], v2: &[u8]) {
     let _ = v1[0] + v2[1];
 }
 
+fn issue11835(v1: &[u8], v2: &[u8], v3: &[u8], v4: &[u8]) {
+    assert!(v1.len() == 3);
+    assert!(v2.len() == 4);
+    assert!(v3.len() == 3);
+    assert!(4 == v4.len());
+
+    let _ = v1[0] + v1[1] + v1[2];
+    //~^ ERROR: indexing into a slice multiple times with an `assert` that does not cover the
+    let _ = v2[0] + v2[1] + v2[2];
+
+    let _ = v3[0] + v3[1] + v3[2];
+    //~^ ERROR: indexing into a slice multiple times with an `assert` that does not cover the
+    let _ = v4[0] + v4[1] + v4[2];
+}
+
 fn main() {}
diff --git a/tests/ui/missing_asserts_for_indexing.rs b/tests/ui/missing_asserts_for_indexing.rs
index 0b4b883acf8..f05d5fea57d 100644
--- a/tests/ui/missing_asserts_for_indexing.rs
+++ b/tests/ui/missing_asserts_for_indexing.rs
@@ -118,4 +118,19 @@ fn index_different_slice_in_same_expr(v1: &[u8], v2: &[u8]) {
     let _ = v1[0] + v2[1];
 }
 
+fn issue11835(v1: &[u8], v2: &[u8], v3: &[u8], v4: &[u8]) {
+    assert!(v1.len() == 2);
+    assert!(v2.len() == 4);
+    assert!(2 == v3.len());
+    assert!(4 == v4.len());
+
+    let _ = v1[0] + v1[1] + v1[2];
+    //~^ ERROR: indexing into a slice multiple times with an `assert` that does not cover the
+    let _ = v2[0] + v2[1] + v2[2];
+
+    let _ = v3[0] + v3[1] + v3[2];
+    //~^ ERROR: indexing into a slice multiple times with an `assert` that does not cover the
+    let _ = v4[0] + v4[1] + v4[2];
+}
+
 fn main() {}
diff --git a/tests/ui/missing_asserts_for_indexing.stderr b/tests/ui/missing_asserts_for_indexing.stderr
index a3e66d7958e..61dce6ccc6c 100644
--- a/tests/ui/missing_asserts_for_indexing.stderr
+++ b/tests/ui/missing_asserts_for_indexing.stderr
@@ -249,5 +249,57 @@ LL |     let _ = v1[0] + v1[12];
    |                     ^^^^^^
    = note: asserting the length before indexing will elide bounds checks
 
-error: aborting due to 9 previous errors
+error: indexing into a slice multiple times with an `assert` that does not cover the highest index
+  --> $DIR/missing_asserts_for_indexing.rs:127:13
+   |
+LL |     assert!(v1.len() == 2);
+   |     ---------------------- help: provide the highest index that is indexed with: `assert!(v1.len() == 3)`
+...
+LL |     let _ = v1[0] + v1[1] + v1[2];
+   |             ^^^^^^^^^^^^^^^^^^^^^
+   |
+note: slice indexed here
+  --> $DIR/missing_asserts_for_indexing.rs:127:13
+   |
+LL |     let _ = v1[0] + v1[1] + v1[2];
+   |             ^^^^^
+note: slice indexed here
+  --> $DIR/missing_asserts_for_indexing.rs:127:21
+   |
+LL |     let _ = v1[0] + v1[1] + v1[2];
+   |                     ^^^^^
+note: slice indexed here
+  --> $DIR/missing_asserts_for_indexing.rs:127:29
+   |
+LL |     let _ = v1[0] + v1[1] + v1[2];
+   |                             ^^^^^
+   = note: asserting the length before indexing will elide bounds checks
+
+error: indexing into a slice multiple times with an `assert` that does not cover the highest index
+  --> $DIR/missing_asserts_for_indexing.rs:131:13
+   |
+LL |     assert!(2 == v3.len());
+   |     ---------------------- help: provide the highest index that is indexed with: `assert!(v3.len() == 3)`
+...
+LL |     let _ = v3[0] + v3[1] + v3[2];
+   |             ^^^^^^^^^^^^^^^^^^^^^
+   |
+note: slice indexed here
+  --> $DIR/missing_asserts_for_indexing.rs:131:13
+   |
+LL |     let _ = v3[0] + v3[1] + v3[2];
+   |             ^^^^^
+note: slice indexed here
+  --> $DIR/missing_asserts_for_indexing.rs:131:21
+   |
+LL |     let _ = v3[0] + v3[1] + v3[2];
+   |                     ^^^^^
+note: slice indexed here
+  --> $DIR/missing_asserts_for_indexing.rs:131:29
+   |
+LL |     let _ = v3[0] + v3[1] + v3[2];
+   |                             ^^^^^
+   = note: asserting the length before indexing will elide bounds checks
+
+error: aborting due to 11 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From b3f4a9015c9ee118574bb9d3419b874826552c24 Mon Sep 17 00:00:00 2001
From: Kevin Reid <kpreid@switchb.org>
Date: Sat, 18 Nov 2023 10:53:03 -0800
Subject: Remove space and rephrase `map()` advice.

---
 clippy_lints/src/unnecessary_map_on_constructor.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unnecessary_map_on_constructor.rs b/clippy_lints/src/unnecessary_map_on_constructor.rs
index 39a83bfa005..5c880288430 100644
--- a/clippy_lints/src/unnecessary_map_on_constructor.rs
+++ b/clippy_lints/src/unnecessary_map_on_constructor.rs
@@ -10,11 +10,11 @@ use rustc_span::sym;
 declare_clippy_lint! {
     /// ### What it does
     /// Suggests removing the use of a `map()` (or `map_err()`) method when an `Option` or `Result`
-    ///  is being constructed.
+    /// is being constructed.
     ///
     /// ### Why is this bad?
-    /// It introduces unnecessary complexity. In this case the function can be used directly and
-    /// construct the `Option` or `Result` from the output.
+    /// It introduces unnecessary complexity. Instead, the function can be called before
+    /// constructing the `Option` or `Result` from its return value.
     ///
     /// ### Example
     /// ```no_run
-- 
cgit 1.4.1-3-g733a5


From 3c1e0afa58dbe1287c1e9a9ea704f9b76b6845cc Mon Sep 17 00:00:00 2001
From: Quinn Sinclair <me@partiallytyped.dev>
Date: Sun, 19 Nov 2023 11:33:01 +0100
Subject: New Lint [`impl_hash_with_borrow_str_and_bytes`]

Implements a lint to prevent implementation of Hash, Borrow<str> and
Borrow<[u8]> as it breaks Borrow<T> "semantics". According to the book,
types that implement Borrow<A> and Borrow<B> must ensure equality of
borrow results under Eq,Ord and Hash.

> In particular Eq, Ord and Hash must be equivalent for borrowed and
owned values: x.borrow() == y.borrow() should give the same result as x == y.

In the same way, hash(x) == hash(x as Borrow<[u8]>) != hash(x as Borrow<str>).

changelog: newlint [`impl_hash_with_borrow_str_and_bytes`]
---
 CHANGELOG.md                                       |   1 +
 clippy_lints/src/declared_lints.rs                 |   1 +
 .../src/impl_hash_with_borrow_str_and_bytes.rs     | 106 ++++++++++++++++
 clippy_lints/src/lib.rs                            |   2 +
 tests/ui/impl_hash_with_borrow_str_and_bytes.rs    | 136 +++++++++++++++++++++
 .../ui/impl_hash_with_borrow_str_and_bytes.stderr  |  41 +++++++
 6 files changed, 287 insertions(+)
 create mode 100644 clippy_lints/src/impl_hash_with_borrow_str_and_bytes.rs
 create mode 100644 tests/ui/impl_hash_with_borrow_str_and_bytes.rs
 create mode 100644 tests/ui/impl_hash_with_borrow_str_and_bytes.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index e74df808e06..1760d19b385 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5128,6 +5128,7 @@ Released 2018-09-13
 [`if_then_some_else_none`]: https://rust-lang.github.io/rust-clippy/master/index.html#if_then_some_else_none
 [`ifs_same_cond`]: https://rust-lang.github.io/rust-clippy/master/index.html#ifs_same_cond
 [`ignored_unit_patterns`]: https://rust-lang.github.io/rust-clippy/master/index.html#ignored_unit_patterns
+[`impl_hash_borrow_with_str_and_bytes`]: https://rust-lang.github.io/rust-clippy/master/index.html#impl_hash_borrow_with_str_and_bytes
 [`impl_trait_in_params`]: https://rust-lang.github.io/rust-clippy/master/index.html#impl_trait_in_params
 [`implicit_clone`]: https://rust-lang.github.io/rust-clippy/master/index.html#implicit_clone
 [`implicit_hasher`]: https://rust-lang.github.io/rust-clippy/master/index.html#implicit_hasher
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 85854a0dfb7..55dedc0a658 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -204,6 +204,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::if_not_else::IF_NOT_ELSE_INFO,
     crate::if_then_some_else_none::IF_THEN_SOME_ELSE_NONE_INFO,
     crate::ignored_unit_patterns::IGNORED_UNIT_PATTERNS_INFO,
+    crate::impl_hash_with_borrow_str_and_bytes::IMPL_HASH_BORROW_WITH_STR_AND_BYTES_INFO,
     crate::implicit_hasher::IMPLICIT_HASHER_INFO,
     crate::implicit_return::IMPLICIT_RETURN_INFO,
     crate::implicit_saturating_add::IMPLICIT_SATURATING_ADD_INFO,
diff --git a/clippy_lints/src/impl_hash_with_borrow_str_and_bytes.rs b/clippy_lints/src/impl_hash_with_borrow_str_and_bytes.rs
new file mode 100644
index 00000000000..9374582b54b
--- /dev/null
+++ b/clippy_lints/src/impl_hash_with_borrow_str_and_bytes.rs
@@ -0,0 +1,106 @@
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::ty::implements_trait;
+use rustc_hir::def::{DefKind, Res};
+use rustc_hir::{Item, ItemKind, Path, TraitRef};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::Ty;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::symbol::sym;
+
+declare_clippy_lint! {
+    /// ### What it does
+    ///
+    /// This lint is concerned with the semantics of `Borrow` and `Hash` for a
+    /// type that implements all three of `Hash`, `Borrow<str>` and `Borrow<[u8]>`
+    /// as it is impossible to satisfy the semantics of Borrow and `Hash` for
+    /// both `Borrow<str>` and `Borrow<[u8]>`.
+    ///
+    /// ### Why is this bad?
+    ///
+    /// When providing implementations for `Borrow<T>`, one should consider whether the different
+    /// implementations should act as facets or representations of the underlying type. Generic code
+    /// typically uses `Borrow<T>` when it relies on the identical behavior of these additional trait
+    /// implementations. These traits will likely appear as additional trait bounds.
+    ///
+    /// In particular `Eq`, `Ord` and `Hash` must be equivalent for borrowed and owned values:
+    /// `x.borrow() == y.borrow()` should give the same result as `x == y`.
+    /// It follows then that the following equivalence must hold:
+    /// `hash(x) == hash((x as Borrow<[u8]>).borrow()) == hash((x as Borrow<str>).borrow())`
+    ///
+    /// Unfortunately it doesn't hold as `hash("abc") != hash("abc".as_bytes())`.
+    /// This happens because the `Hash` impl for str passes an additional `0xFF` byte to
+    /// the hasher to avoid collisions. For example, given the tuples `("a", "bc")`, and `("ab", "c")`,
+    /// the two tuples would have the same hash value if the `0xFF` byte was not added.
+    ///
+    /// ### Example
+    ///
+    /// ```
+    /// use std::borrow::Borrow;
+    /// use std::hash::{Hash, Hasher};
+    ///
+    /// struct ExampleType {
+    ///     data: String
+    /// }
+    ///
+    /// impl Hash for ExampleType {
+    ///     fn hash<H: Hasher>(&self, state: &mut H) {
+    ///         self.data.hash(state);
+    ///     }
+    /// }
+    ///
+    /// impl Borrow<str> for ExampleType {
+    ///     fn borrow(&self) -> &str {
+    ///         &self.data
+    ///     }
+    /// }
+    ///
+    /// impl Borrow<[u8]> for ExampleType {
+    ///     fn borrow(&self) -> &[u8] {
+    ///         self.data.as_bytes()
+    ///     }
+    /// }
+    /// ```
+    /// As a consequence, hashing a `&ExampleType` and hashing the result of the two
+    /// borrows will result in different values.
+    ///
+    #[clippy::version = "1.76.0"]
+    pub IMPL_HASH_BORROW_WITH_STR_AND_BYTES,
+    correctness,
+    "ensures that the semantics of `Borrow` for `Hash` are satisfied when `Borrow<str>` and `Borrow<[u8]>` are implemented"
+}
+
+declare_lint_pass!(ImplHashWithBorrowStrBytes => [IMPL_HASH_BORROW_WITH_STR_AND_BYTES]);
+
+impl LateLintPass<'_> for ImplHashWithBorrowStrBytes {
+    /// We are emitting this lint at the Hash impl of a type that implements all
+    /// three of `Hash`, `Borrow<str>` and `Borrow<[u8]>`.
+    fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
+        if let ItemKind::Impl(imp) = item.kind
+            && let Some(TraitRef {path: Path {span, res, ..}, ..}) = imp.of_trait
+            && let ty = cx.tcx.type_of(item.owner_id).instantiate_identity()
+            && let Some(hash_id) = cx.tcx.get_diagnostic_item(sym::Hash)
+            && Res::Def(DefKind::Trait, hash_id) == *res
+            && let Some(borrow_id) = cx.tcx.get_diagnostic_item(sym::Borrow)
+            // since we are in the `Hash` impl, we don't need to check for that.
+            // we need only to check for `Borrow<str>` and `Borrow<[u8]>`
+            && implements_trait(cx, ty, borrow_id, &[cx.tcx.types.str_.into()])
+            && implements_trait(cx, ty, borrow_id, &[Ty::new_slice(cx.tcx, cx.tcx.types.u8).into()])
+        {
+            span_lint_and_then(
+                cx,
+                IMPL_HASH_BORROW_WITH_STR_AND_BYTES,
+                *span,
+                "the semantics of `Borrow<T>` around `Hash` can't be satisfied when both `Borrow<str>` and `Borrow<[u8]>` are implemented",
+                |diag| {
+                    diag.note("the `Borrow` semantics require that `Hash` must behave the same for all implementations of Borrow<T>");
+                    diag.note(
+          "however, the hash implementations of a string (`str`) and the bytes of a string `[u8]` do not behave the same ..."
+      );
+                    diag.note("... as (`hash(\"abc\") != hash(\"abc\".as_bytes())`");
+                    diag.help("consider either removing one of the  `Borrow` implementations (`Borrow<str>` or `Borrow<[u8]>`) ...");
+                    diag.help("... or not implementing `Hash` for this type");
+                },
+            );
+        }
+    }
+}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index c462c933082..952625c78be 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -144,6 +144,7 @@ mod if_let_mutex;
 mod if_not_else;
 mod if_then_some_else_none;
 mod ignored_unit_patterns;
+mod impl_hash_with_borrow_str_and_bytes;
 mod implicit_hasher;
 mod implicit_return;
 mod implicit_saturating_add;
@@ -1066,6 +1067,7 @@ pub fn register_lints(store: &mut rustc_lint::LintStore, conf: &'static Conf) {
     store.register_late_pass(move |_| Box::new(manual_hash_one::ManualHashOne::new(msrv())));
     store.register_late_pass(|_| Box::new(iter_without_into_iter::IterWithoutIntoIter));
     store.register_late_pass(|_| Box::new(iter_over_hash_type::IterOverHashType));
+    store.register_late_pass(|_| Box::new(impl_hash_with_borrow_str_and_bytes::ImplHashWithBorrowStrBytes));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/tests/ui/impl_hash_with_borrow_str_and_bytes.rs b/tests/ui/impl_hash_with_borrow_str_and_bytes.rs
new file mode 100644
index 00000000000..f6ce6153e01
--- /dev/null
+++ b/tests/ui/impl_hash_with_borrow_str_and_bytes.rs
@@ -0,0 +1,136 @@
+#![warn(clippy::impl_hash_borrow_with_str_and_bytes)]
+
+use std::borrow::Borrow;
+use std::hash::{Hash, Hasher};
+
+struct ExampleType {
+    data: String,
+}
+
+impl Hash for ExampleType {
+    //~^ ERROR: can't
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.data.hash(state);
+    }
+}
+
+impl Borrow<str> for ExampleType {
+    fn borrow(&self) -> &str {
+        &self.data
+    }
+}
+
+impl Borrow<[u8]> for ExampleType {
+    fn borrow(&self) -> &[u8] {
+        self.data.as_bytes()
+    }
+}
+
+struct ShouldNotRaiseForHash {}
+impl Hash for ShouldNotRaiseForHash {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        todo!();
+    }
+}
+
+struct ShouldNotRaiseForBorrow {}
+impl Borrow<str> for ShouldNotRaiseForBorrow {
+    fn borrow(&self) -> &str {
+        todo!();
+    }
+}
+impl Borrow<[u8]> for ShouldNotRaiseForBorrow {
+    fn borrow(&self) -> &[u8] {
+        todo!();
+    }
+}
+
+struct ShouldNotRaiseForHashBorrowStr {}
+impl Hash for ShouldNotRaiseForHashBorrowStr {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        todo!();
+    }
+}
+impl Borrow<str> for ShouldNotRaiseForHashBorrowStr {
+    fn borrow(&self) -> &str {
+        todo!();
+    }
+}
+
+struct ShouldNotRaiseForHashBorrowSlice {}
+impl Hash for ShouldNotRaiseForHashBorrowSlice {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        todo!();
+    }
+}
+
+impl Borrow<[u8]> for ShouldNotRaiseForHashBorrowSlice {
+    fn borrow(&self) -> &[u8] {
+        todo!();
+    }
+}
+
+#[derive(Hash)]
+//~^ ERROR: can't
+struct Derived {
+    data: String,
+}
+
+impl Borrow<str> for Derived {
+    fn borrow(&self) -> &str {
+        self.data.as_str()
+    }
+}
+
+impl Borrow<[u8]> for Derived {
+    fn borrow(&self) -> &[u8] {
+        self.data.as_bytes()
+    }
+}
+
+struct GenericExampleType<T> {
+    data: T,
+}
+
+impl<T: Hash> Hash for GenericExampleType<T> {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.data.hash(state);
+    }
+}
+
+impl Borrow<str> for GenericExampleType<String> {
+    fn borrow(&self) -> &str {
+        &self.data
+    }
+}
+
+impl Borrow<[u8]> for GenericExampleType<&'static [u8]> {
+    fn borrow(&self) -> &[u8] {
+        self.data
+    }
+}
+
+struct GenericExampleType2<T> {
+    data: T,
+}
+
+impl Hash for GenericExampleType2<String> {
+    //~^ ERROR: can't
+    // this is correctly throwing an error for generic with concrete impl
+    // for all 3 types
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.data.hash(state);
+    }
+}
+
+impl Borrow<str> for GenericExampleType2<String> {
+    fn borrow(&self) -> &str {
+        &self.data
+    }
+}
+
+impl Borrow<[u8]> for GenericExampleType2<String> {
+    fn borrow(&self) -> &[u8] {
+        self.data.as_bytes()
+    }
+}
diff --git a/tests/ui/impl_hash_with_borrow_str_and_bytes.stderr b/tests/ui/impl_hash_with_borrow_str_and_bytes.stderr
new file mode 100644
index 00000000000..afc35ef9845
--- /dev/null
+++ b/tests/ui/impl_hash_with_borrow_str_and_bytes.stderr
@@ -0,0 +1,41 @@
+error: the semantics of `Borrow<T>` around `Hash` can't be satisfied when both `Borrow<str>` and `Borrow<[u8]>` are implemented
+  --> $DIR/impl_hash_with_borrow_str_and_bytes.rs:10:6
+   |
+LL | impl Hash for ExampleType {
+   |      ^^^^
+   |
+   = note: the `Borrow` semantics require that `Hash` must behave the same for all implementations of Borrow<T>
+   = note: however, the hash implementations of a string (`str`) and the bytes of a string `[u8]` do not behave the same ...
+   = note: ... as (`hash("abc") != hash("abc".as_bytes())`
+   = help: consider either removing one of the  `Borrow` implementations (`Borrow<str>` or `Borrow<[u8]>`) ...
+   = help: ... or not implementing `Hash` for this type
+   = note: `-D clippy::impl-hash-borrow-with-str-and-bytes` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::impl_hash_borrow_with_str_and_bytes)]`
+
+error: the semantics of `Borrow<T>` around `Hash` can't be satisfied when both `Borrow<str>` and `Borrow<[u8]>` are implemented
+  --> $DIR/impl_hash_with_borrow_str_and_bytes.rs:73:10
+   |
+LL | #[derive(Hash)]
+   |          ^^^^
+   |
+   = note: the `Borrow` semantics require that `Hash` must behave the same for all implementations of Borrow<T>
+   = note: however, the hash implementations of a string (`str`) and the bytes of a string `[u8]` do not behave the same ...
+   = note: ... as (`hash("abc") != hash("abc".as_bytes())`
+   = help: consider either removing one of the  `Borrow` implementations (`Borrow<str>` or `Borrow<[u8]>`) ...
+   = help: ... or not implementing `Hash` for this type
+   = note: this error originates in the derive macro `Hash` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: the semantics of `Borrow<T>` around `Hash` can't be satisfied when both `Borrow<str>` and `Borrow<[u8]>` are implemented
+  --> $DIR/impl_hash_with_borrow_str_and_bytes.rs:117:6
+   |
+LL | impl Hash for GenericExampleType2<String> {
+   |      ^^^^
+   |
+   = note: the `Borrow` semantics require that `Hash` must behave the same for all implementations of Borrow<T>
+   = note: however, the hash implementations of a string (`str`) and the bytes of a string `[u8]` do not behave the same ...
+   = note: ... as (`hash("abc") != hash("abc".as_bytes())`
+   = help: consider either removing one of the  `Borrow` implementations (`Borrow<str>` or `Borrow<[u8]>`) ...
+   = help: ... or not implementing `Hash` for this type
+
+error: aborting due to 3 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From dfbca7ffa8e0f7d69374f5f6dd351cc34ed0e811 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Sat, 18 Nov 2023 22:33:01 +0100
Subject: Improve `maybe_misused_cfg` lint output Small performance improvement
 when comparing symbols for `maybe_misused_cfg` Improve suggestion for
 `maybe_misused_cfg` lint

---
 clippy_lints/src/attrs.rs    |  9 +++++----
 tests/ui/cfg_features.fixed  |  8 ++++----
 tests/ui/cfg_features.rs     |  8 ++++----
 tests/ui/cfg_features.stderr | 24 ++++++++++++------------
 4 files changed, 25 insertions(+), 24 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs
index 9fe1ef2ed14..0a4a0ab9f07 100644
--- a/clippy_lints/src/attrs.rs
+++ b/clippy_lints/src/attrs.rs
@@ -929,15 +929,16 @@ fn check_nested_cfg(cx: &EarlyContext<'_>, items: &[NestedMetaItem]) {
 fn check_nested_misused_cfg(cx: &EarlyContext<'_>, items: &[NestedMetaItem]) {
     for item in items {
         if let NestedMetaItem::MetaItem(meta) = item {
-            if meta.has_name(sym!(features))
+            if let Some(ident) = meta.ident()
+                && ident.name.as_str() == "features"
                 && let Some(val) = meta.value_str()
             {
                 span_lint_and_sugg(
                     cx,
                     MAYBE_MISUSED_CFG,
                     meta.span,
-                    "feature may misspelled as features",
-                    "use",
+                    "'feature' may be misspelled as 'features'",
+                    "did you mean",
                     format!("feature = \"{val}\""),
                     Applicability::MaybeIncorrect,
                 );
@@ -953,7 +954,7 @@ fn check_nested_misused_cfg(cx: &EarlyContext<'_>, items: &[NestedMetaItem]) {
                     MAYBE_MISUSED_CFG,
                     meta.span,
                     &format!("'test' may be misspelled as '{}'", ident.name.as_str()),
-                    "do you mean",
+                    "did you mean",
                     "test".to_string(),
                     Applicability::MaybeIncorrect,
                 );
diff --git a/tests/ui/cfg_features.fixed b/tests/ui/cfg_features.fixed
index 2a02132a740..0fe38f169f9 100644
--- a/tests/ui/cfg_features.fixed
+++ b/tests/ui/cfg_features.fixed
@@ -2,17 +2,17 @@
 
 fn main() {
     #[cfg(feature = "not-really-a-feature")]
-    //~^ ERROR: feature may misspelled as features
+    //~^ ERROR: 'feature' may be misspelled as 'features'
     //~| NOTE: `-D clippy::maybe-misused-cfg` implied by `-D warnings`
     let _ = 1 + 2;
 
     #[cfg(all(feature = "right", feature = "wrong"))]
-    //~^ ERROR: feature may misspelled as features
+    //~^ ERROR: 'feature' may be misspelled as 'features'
     let _ = 1 + 2;
 
     #[cfg(all(feature = "wrong1", any(feature = "right", feature = "wrong2", feature, features)))]
-    //~^ ERROR: feature may misspelled as features
-    //~| ERROR: feature may misspelled as features
+    //~^ ERROR: 'feature' may be misspelled as 'features'
+    //~| ERROR: 'feature' may be misspelled as 'features'
     let _ = 1 + 2;
 
     #[cfg(test)]
diff --git a/tests/ui/cfg_features.rs b/tests/ui/cfg_features.rs
index efe2fb04922..9c0db035eac 100644
--- a/tests/ui/cfg_features.rs
+++ b/tests/ui/cfg_features.rs
@@ -2,17 +2,17 @@
 
 fn main() {
     #[cfg(features = "not-really-a-feature")]
-    //~^ ERROR: feature may misspelled as features
+    //~^ ERROR: 'feature' may be misspelled as 'features'
     //~| NOTE: `-D clippy::maybe-misused-cfg` implied by `-D warnings`
     let _ = 1 + 2;
 
     #[cfg(all(feature = "right", features = "wrong"))]
-    //~^ ERROR: feature may misspelled as features
+    //~^ ERROR: 'feature' may be misspelled as 'features'
     let _ = 1 + 2;
 
     #[cfg(all(features = "wrong1", any(feature = "right", features = "wrong2", feature, features)))]
-    //~^ ERROR: feature may misspelled as features
-    //~| ERROR: feature may misspelled as features
+    //~^ ERROR: 'feature' may be misspelled as 'features'
+    //~| ERROR: 'feature' may be misspelled as 'features'
     let _ = 1 + 2;
 
     #[cfg(tests)]
diff --git a/tests/ui/cfg_features.stderr b/tests/ui/cfg_features.stderr
index 441de5b41f4..e1593e2071b 100644
--- a/tests/ui/cfg_features.stderr
+++ b/tests/ui/cfg_features.stderr
@@ -1,53 +1,53 @@
-error: feature may misspelled as features
+error: 'feature' may be misspelled as 'features'
   --> $DIR/cfg_features.rs:4:11
    |
 LL |     #[cfg(features = "not-really-a-feature")]
-   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `feature = "not-really-a-feature"`
+   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: did you mean: `feature = "not-really-a-feature"`
    |
    = note: `-D clippy::maybe-misused-cfg` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::maybe_misused_cfg)]`
 
-error: feature may misspelled as features
+error: 'feature' may be misspelled as 'features'
   --> $DIR/cfg_features.rs:9:34
    |
 LL |     #[cfg(all(feature = "right", features = "wrong"))]
-   |                                  ^^^^^^^^^^^^^^^^^^ help: use: `feature = "wrong"`
+   |                                  ^^^^^^^^^^^^^^^^^^ help: did you mean: `feature = "wrong"`
 
-error: feature may misspelled as features
+error: 'feature' may be misspelled as 'features'
   --> $DIR/cfg_features.rs:13:15
    |
 LL |     #[cfg(all(features = "wrong1", any(feature = "right", features = "wrong2", feature, features)))]
-   |               ^^^^^^^^^^^^^^^^^^^ help: use: `feature = "wrong1"`
+   |               ^^^^^^^^^^^^^^^^^^^ help: did you mean: `feature = "wrong1"`
 
-error: feature may misspelled as features
+error: 'feature' may be misspelled as 'features'
   --> $DIR/cfg_features.rs:13:59
    |
 LL |     #[cfg(all(features = "wrong1", any(feature = "right", features = "wrong2", feature, features)))]
-   |                                                           ^^^^^^^^^^^^^^^^^^^ help: use: `feature = "wrong2"`
+   |                                                           ^^^^^^^^^^^^^^^^^^^ help: did you mean: `feature = "wrong2"`
 
 error: 'test' may be misspelled as 'tests'
   --> $DIR/cfg_features.rs:18:11
    |
 LL |     #[cfg(tests)]
-   |           ^^^^^ help: do you mean: `test`
+   |           ^^^^^ help: did you mean: `test`
 
 error: 'test' may be misspelled as 'Test'
   --> $DIR/cfg_features.rs:21:11
    |
 LL |     #[cfg(Test)]
-   |           ^^^^ help: do you mean: `test`
+   |           ^^^^ help: did you mean: `test`
 
 error: 'test' may be misspelled as 'tests'
   --> $DIR/cfg_features.rs:25:15
    |
 LL |     #[cfg(all(tests, Test))]
-   |               ^^^^^ help: do you mean: `test`
+   |               ^^^^^ help: did you mean: `test`
 
 error: 'test' may be misspelled as 'Test'
   --> $DIR/cfg_features.rs:25:22
    |
 LL |     #[cfg(all(tests, Test))]
-   |                      ^^^^ help: do you mean: `test`
+   |                      ^^^^ help: did you mean: `test`
 
 error: aborting due to 8 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 56cee3c58776d6af6e00fb035310b294392582b4 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Wed, 15 Nov 2023 22:38:50 +0100
Subject: move `doc.rs` to its own subdirectory

---
 clippy_lints/src/doc.rs                         | 957 ------------------------
 clippy_lints/src/doc/link_with_quotes.rs        |  20 +
 clippy_lints/src/doc/markdown.rs                | 109 +++
 clippy_lints/src/doc/missing_headers.rs         |  84 +++
 clippy_lints/src/doc/mod.rs                     | 664 ++++++++++++++++
 clippy_lints/src/doc/needless_doctest_main.rs   | 100 +++
 clippy_lints/src/doc/suspicious_doc_comments.rs |  48 ++
 tests/ui/doc_link_with_quotes.rs                |   6 +
 tests/ui/doc_link_with_quotes.stderr            |   8 +-
 9 files changed, 1038 insertions(+), 958 deletions(-)
 delete mode 100644 clippy_lints/src/doc.rs
 create mode 100644 clippy_lints/src/doc/link_with_quotes.rs
 create mode 100644 clippy_lints/src/doc/markdown.rs
 create mode 100644 clippy_lints/src/doc/missing_headers.rs
 create mode 100644 clippy_lints/src/doc/mod.rs
 create mode 100644 clippy_lints/src/doc/needless_doctest_main.rs
 create mode 100644 clippy_lints/src/doc/suspicious_doc_comments.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/doc.rs b/clippy_lints/src/doc.rs
deleted file mode 100644
index ca277e7eded..00000000000
--- a/clippy_lints/src/doc.rs
+++ /dev/null
@@ -1,957 +0,0 @@
-use clippy_utils::attrs::is_doc_hidden;
-use clippy_utils::diagnostics::{span_lint, span_lint_and_help, span_lint_and_note, span_lint_and_then};
-use clippy_utils::macros::{is_panic, root_macro_call_first_node};
-use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::ty::{implements_trait, is_type_diagnostic_item};
-use clippy_utils::{is_entrypoint_fn, method_chain_args, return_ty};
-use pulldown_cmark::Event::{
-    Code, End, FootnoteReference, HardBreak, Html, Rule, SoftBreak, Start, TaskListMarker, Text,
-};
-use pulldown_cmark::Tag::{CodeBlock, Heading, Item, Link, Paragraph};
-use pulldown_cmark::{BrokenLink, CodeBlockKind, CowStr, Options};
-use rustc_ast::ast::{Async, Attribute, Fn, FnRetTy, ItemKind};
-use rustc_ast::token::CommentKind;
-use rustc_ast::{AttrKind, AttrStyle};
-use rustc_data_structures::fx::FxHashSet;
-use rustc_data_structures::sync::Lrc;
-use rustc_errors::emitter::EmitterWriter;
-use rustc_errors::{Applicability, Handler, SuggestionStyle};
-use rustc_hir as hir;
-use rustc_hir::intravisit::{self, Visitor};
-use rustc_hir::{AnonConst, Expr};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::hir::nested_filter;
-use rustc_middle::lint::in_external_macro;
-use rustc_middle::ty;
-use rustc_parse::maybe_new_parser_from_source_str;
-use rustc_parse::parser::ForceCollect;
-use rustc_resolve::rustdoc::{
-    add_doc_fragment, attrs_to_doc_fragments, main_body_opts, source_span_for_markdown_range, DocFragment,
-};
-use rustc_session::parse::ParseSess;
-use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::edition::Edition;
-use rustc_span::source_map::{FilePathMapping, SourceMap};
-use rustc_span::{sym, BytePos, FileName, Pos, Span};
-use std::ops::Range;
-use std::{io, thread};
-use url::Url;
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for the presence of `_`, `::` or camel-case words
-    /// outside ticks in documentation.
-    ///
-    /// ### Why is this bad?
-    /// *Rustdoc* supports markdown formatting, `_`, `::` and
-    /// camel-case probably indicates some code which should be included between
-    /// ticks. `_` can also be used for emphasis in markdown, this lint tries to
-    /// consider that.
-    ///
-    /// ### Known problems
-    /// Lots of bad docs won’t be fixed, what the lint checks
-    /// for is limited, and there are still false positives. HTML elements and their
-    /// content are not linted.
-    ///
-    /// In addition, when writing documentation comments, including `[]` brackets
-    /// inside a link text would trip the parser. Therefore, documenting link with
-    /// `[`SmallVec<[T; INLINE_CAPACITY]>`]` and then [`SmallVec<[T; INLINE_CAPACITY]>`]: SmallVec
-    /// would fail.
-    ///
-    /// ### Examples
-    /// ```no_run
-    /// /// Do something with the foo_bar parameter. See also
-    /// /// that::other::module::foo.
-    /// // ^ `foo_bar` and `that::other::module::foo` should be ticked.
-    /// fn doit(foo_bar: usize) {}
-    /// ```
-    ///
-    /// ```no_run
-    /// // Link text with `[]` brackets should be written as following:
-    /// /// Consume the array and return the inner
-    /// /// [`SmallVec<[T; INLINE_CAPACITY]>`][SmallVec].
-    /// /// [SmallVec]: SmallVec
-    /// fn main() {}
-    /// ```
-    #[clippy::version = "pre 1.29.0"]
-    pub DOC_MARKDOWN,
-    pedantic,
-    "presence of `_`, `::` or camel-case outside backticks in documentation"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for the doc comments of publicly visible
-    /// unsafe functions and warns if there is no `# Safety` section.
-    ///
-    /// ### Why is this bad?
-    /// Unsafe functions should document their safety
-    /// preconditions, so that users can be sure they are using them safely.
-    ///
-    /// ### Examples
-    /// ```no_run
-    ///# type Universe = ();
-    /// /// This function should really be documented
-    /// pub unsafe fn start_apocalypse(u: &mut Universe) {
-    ///     unimplemented!();
-    /// }
-    /// ```
-    ///
-    /// At least write a line about safety:
-    ///
-    /// ```no_run
-    ///# type Universe = ();
-    /// /// # Safety
-    /// ///
-    /// /// This function should not be called before the horsemen are ready.
-    /// pub unsafe fn start_apocalypse(u: &mut Universe) {
-    ///     unimplemented!();
-    /// }
-    /// ```
-    #[clippy::version = "1.39.0"]
-    pub MISSING_SAFETY_DOC,
-    style,
-    "`pub unsafe fn` without `# Safety` docs"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks the doc comments of publicly visible functions that
-    /// return a `Result` type and warns if there is no `# Errors` section.
-    ///
-    /// ### Why is this bad?
-    /// Documenting the type of errors that can be returned from a
-    /// function can help callers write code to handle the errors appropriately.
-    ///
-    /// ### Examples
-    /// Since the following function returns a `Result` it has an `# Errors` section in
-    /// its doc comment:
-    ///
-    /// ```no_run
-    ///# use std::io;
-    /// /// # Errors
-    /// ///
-    /// /// Will return `Err` if `filename` does not exist or the user does not have
-    /// /// permission to read it.
-    /// pub fn read(filename: String) -> io::Result<String> {
-    ///     unimplemented!();
-    /// }
-    /// ```
-    #[clippy::version = "1.41.0"]
-    pub MISSING_ERRORS_DOC,
-    pedantic,
-    "`pub fn` returns `Result` without `# Errors` in doc comment"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks the doc comments of publicly visible functions that
-    /// may panic and warns if there is no `# Panics` section.
-    ///
-    /// ### Why is this bad?
-    /// Documenting the scenarios in which panicking occurs
-    /// can help callers who do not want to panic to avoid those situations.
-    ///
-    /// ### Examples
-    /// Since the following function may panic it has a `# Panics` section in
-    /// its doc comment:
-    ///
-    /// ```no_run
-    /// /// # Panics
-    /// ///
-    /// /// Will panic if y is 0
-    /// pub fn divide_by(x: i32, y: i32) -> i32 {
-    ///     if y == 0 {
-    ///         panic!("Cannot divide by 0")
-    ///     } else {
-    ///         x / y
-    ///     }
-    /// }
-    /// ```
-    #[clippy::version = "1.51.0"]
-    pub MISSING_PANICS_DOC,
-    pedantic,
-    "`pub fn` may panic without `# Panics` in doc comment"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for `fn main() { .. }` in doctests
-    ///
-    /// ### Why is this bad?
-    /// The test can be shorter (and likely more readable)
-    /// if the `fn main()` is left implicit.
-    ///
-    /// ### Examples
-    /// ```no_run
-    /// /// An example of a doctest with a `main()` function
-    /// ///
-    /// /// # Examples
-    /// ///
-    /// /// ```
-    /// /// fn main() {
-    /// ///     // this needs not be in an `fn`
-    /// /// }
-    /// /// ```
-    /// fn needless_main() {
-    ///     unimplemented!();
-    /// }
-    /// ```
-    #[clippy::version = "1.40.0"]
-    pub NEEDLESS_DOCTEST_MAIN,
-    style,
-    "presence of `fn main() {` in code examples"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Detects the syntax `['foo']` in documentation comments (notice quotes instead of backticks)
-    /// outside of code blocks
-    /// ### Why is this bad?
-    /// It is likely a typo when defining an intra-doc link
-    ///
-    /// ### Example
-    /// ```no_run
-    /// /// See also: ['foo']
-    /// fn bar() {}
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// /// See also: [`foo`]
-    /// fn bar() {}
-    /// ```
-    #[clippy::version = "1.63.0"]
-    pub DOC_LINK_WITH_QUOTES,
-    pedantic,
-    "possible typo for an intra-doc link"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for the doc comments of publicly visible
-    /// safe functions and traits and warns if there is a `# Safety` section.
-    ///
-    /// ### Why is this bad?
-    /// Safe functions and traits are safe to implement and therefore do not
-    /// need to describe safety preconditions that users are required to uphold.
-    ///
-    /// ### Examples
-    /// ```no_run
-    ///# type Universe = ();
-    /// /// # Safety
-    /// ///
-    /// /// This function should not be called before the horsemen are ready.
-    /// pub fn start_apocalypse_but_safely(u: &mut Universe) {
-    ///     unimplemented!();
-    /// }
-    /// ```
-    ///
-    /// The function is safe, so there shouldn't be any preconditions
-    /// that have to be explained for safety reasons.
-    ///
-    /// ```no_run
-    ///# type Universe = ();
-    /// /// This function should really be documented
-    /// pub fn start_apocalypse(u: &mut Universe) {
-    ///     unimplemented!();
-    /// }
-    /// ```
-    #[clippy::version = "1.67.0"]
-    pub UNNECESSARY_SAFETY_DOC,
-    restriction,
-    "`pub fn` or `pub trait` with `# Safety` docs"
-}
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Detects the use of outer doc comments (`///`, `/**`) followed by a bang (`!`): `///!`
-    ///
-    /// ### Why is this bad?
-    /// Triple-slash comments (known as "outer doc comments") apply to items that follow it.
-    /// An outer doc comment followed by a bang (i.e. `///!`) has no specific meaning.
-    ///
-    /// The user most likely meant to write an inner doc comment (`//!`, `/*!`), which
-    /// applies to the parent item (i.e. the item that the comment is contained in,
-    /// usually a module or crate).
-    ///
-    /// ### Known problems
-    /// Inner doc comments can only appear before items, so there are certain cases where the suggestion
-    /// made by this lint is not valid code. For example:
-    /// ```rs
-    /// fn foo() {}
-    /// ///!
-    /// fn bar() {}
-    /// ```
-    /// This lint detects the doc comment and suggests changing it to `//!`, but an inner doc comment
-    /// is not valid at that position.
-    ///
-    /// ### Example
-    /// In this example, the doc comment is attached to the *function*, rather than the *module*.
-    /// ```no_run
-    /// pub mod util {
-    ///     ///! This module contains utility functions.
-    ///
-    ///     pub fn dummy() {}
-    /// }
-    /// ```
-    ///
-    /// Use instead:
-    /// ```no_run
-    /// pub mod util {
-    ///     //! This module contains utility functions.
-    ///
-    ///     pub fn dummy() {}
-    /// }
-    /// ```
-    #[clippy::version = "1.70.0"]
-    pub SUSPICIOUS_DOC_COMMENTS,
-    suspicious,
-    "suspicious usage of (outer) doc comments"
-}
-
-#[expect(clippy::module_name_repetitions)]
-#[derive(Clone)]
-pub struct DocMarkdown {
-    valid_idents: FxHashSet<String>,
-    in_trait_impl: bool,
-}
-
-impl DocMarkdown {
-    pub fn new(valid_idents: &[String]) -> Self {
-        Self {
-            valid_idents: valid_idents.iter().cloned().collect(),
-            in_trait_impl: false,
-        }
-    }
-}
-
-impl_lint_pass!(DocMarkdown => [
-    DOC_LINK_WITH_QUOTES,
-    DOC_MARKDOWN,
-    MISSING_SAFETY_DOC,
-    MISSING_ERRORS_DOC,
-    MISSING_PANICS_DOC,
-    NEEDLESS_DOCTEST_MAIN,
-    UNNECESSARY_SAFETY_DOC,
-    SUSPICIOUS_DOC_COMMENTS
-]);
-
-impl<'tcx> LateLintPass<'tcx> for DocMarkdown {
-    fn check_crate(&mut self, cx: &LateContext<'tcx>) {
-        let attrs = cx.tcx.hir().attrs(hir::CRATE_HIR_ID);
-        check_attrs(cx, &self.valid_idents, attrs);
-    }
-
-    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) {
-        let attrs = cx.tcx.hir().attrs(item.hir_id());
-        let Some(headers) = check_attrs(cx, &self.valid_idents, attrs) else {
-            return;
-        };
-        match item.kind {
-            hir::ItemKind::Fn(ref sig, _, body_id) => {
-                if !(is_entrypoint_fn(cx, item.owner_id.to_def_id()) || in_external_macro(cx.tcx.sess, item.span)) {
-                    let body = cx.tcx.hir().body(body_id);
-                    let mut fpu = FindPanicUnwrap {
-                        cx,
-                        typeck_results: cx.tcx.typeck(item.owner_id.def_id),
-                        panic_span: None,
-                    };
-                    fpu.visit_expr(body.value);
-                    lint_for_missing_headers(cx, item.owner_id, sig, headers, Some(body_id), fpu.panic_span);
-                }
-            },
-            hir::ItemKind::Impl(impl_) => {
-                self.in_trait_impl = impl_.of_trait.is_some();
-            },
-            hir::ItemKind::Trait(_, unsafety, ..) => match (headers.safety, unsafety) {
-                (false, hir::Unsafety::Unsafe) => span_lint(
-                    cx,
-                    MISSING_SAFETY_DOC,
-                    cx.tcx.def_span(item.owner_id),
-                    "docs for unsafe trait missing `# Safety` section",
-                ),
-                (true, hir::Unsafety::Normal) => span_lint(
-                    cx,
-                    UNNECESSARY_SAFETY_DOC,
-                    cx.tcx.def_span(item.owner_id),
-                    "docs for safe trait have unnecessary `# Safety` section",
-                ),
-                _ => (),
-            },
-            _ => (),
-        }
-    }
-
-    fn check_item_post(&mut self, _cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) {
-        if let hir::ItemKind::Impl { .. } = item.kind {
-            self.in_trait_impl = false;
-        }
-    }
-
-    fn check_trait_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::TraitItem<'_>) {
-        let attrs = cx.tcx.hir().attrs(item.hir_id());
-        let Some(headers) = check_attrs(cx, &self.valid_idents, attrs) else {
-            return;
-        };
-        if let hir::TraitItemKind::Fn(ref sig, ..) = item.kind {
-            if !in_external_macro(cx.tcx.sess, item.span) {
-                lint_for_missing_headers(cx, item.owner_id, sig, headers, None, None);
-            }
-        }
-    }
-
-    fn check_impl_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::ImplItem<'_>) {
-        let attrs = cx.tcx.hir().attrs(item.hir_id());
-        let Some(headers) = check_attrs(cx, &self.valid_idents, attrs) else {
-            return;
-        };
-        if self.in_trait_impl || in_external_macro(cx.tcx.sess, item.span) {
-            return;
-        }
-        if let hir::ImplItemKind::Fn(ref sig, body_id) = item.kind {
-            let body = cx.tcx.hir().body(body_id);
-            let mut fpu = FindPanicUnwrap {
-                cx,
-                typeck_results: cx.tcx.typeck(item.owner_id.def_id),
-                panic_span: None,
-            };
-            fpu.visit_expr(body.value);
-            lint_for_missing_headers(cx, item.owner_id, sig, headers, Some(body_id), fpu.panic_span);
-        }
-    }
-}
-
-fn lint_for_missing_headers(
-    cx: &LateContext<'_>,
-    owner_id: hir::OwnerId,
-    sig: &hir::FnSig<'_>,
-    headers: DocHeaders,
-    body_id: Option<hir::BodyId>,
-    panic_span: Option<Span>,
-) {
-    if !cx.effective_visibilities.is_exported(owner_id.def_id) {
-        return; // Private functions do not require doc comments
-    }
-
-    // do not lint if any parent has `#[doc(hidden)]` attribute (#7347)
-    if cx
-        .tcx
-        .hir()
-        .parent_iter(owner_id.into())
-        .any(|(id, _node)| is_doc_hidden(cx.tcx.hir().attrs(id)))
-    {
-        return;
-    }
-
-    let span = cx.tcx.def_span(owner_id);
-    match (headers.safety, sig.header.unsafety) {
-        (false, hir::Unsafety::Unsafe) => span_lint(
-            cx,
-            MISSING_SAFETY_DOC,
-            span,
-            "unsafe function's docs miss `# Safety` section",
-        ),
-        (true, hir::Unsafety::Normal) => span_lint(
-            cx,
-            UNNECESSARY_SAFETY_DOC,
-            span,
-            "safe function's docs have unnecessary `# Safety` section",
-        ),
-        _ => (),
-    }
-    if !headers.panics && panic_span.is_some() {
-        span_lint_and_note(
-            cx,
-            MISSING_PANICS_DOC,
-            span,
-            "docs for function which may panic missing `# Panics` section",
-            panic_span,
-            "first possible panic found here",
-        );
-    }
-    if !headers.errors {
-        if is_type_diagnostic_item(cx, return_ty(cx, owner_id), sym::Result) {
-            span_lint(
-                cx,
-                MISSING_ERRORS_DOC,
-                span,
-                "docs for function returning `Result` missing `# Errors` section",
-            );
-        } else if let Some(body_id) = body_id
-            && let Some(future) = cx.tcx.lang_items().future_trait()
-            && let typeck = cx.tcx.typeck_body(body_id)
-            && let body = cx.tcx.hir().body(body_id)
-            && let ret_ty = typeck.expr_ty(body.value)
-            && implements_trait(cx, ret_ty, future, &[])
-            && let ty::Coroutine(_, subs, _) = ret_ty.kind()
-            && is_type_diagnostic_item(cx, subs.as_coroutine().return_ty(), sym::Result)
-        {
-            span_lint(
-                cx,
-                MISSING_ERRORS_DOC,
-                span,
-                "docs for function returning `Result` missing `# Errors` section",
-            );
-        }
-    }
-}
-
-#[derive(Copy, Clone)]
-struct Fragments<'a> {
-    doc: &'a str,
-    fragments: &'a [DocFragment],
-}
-
-impl Fragments<'_> {
-    fn span(self, cx: &LateContext<'_>, range: Range<usize>) -> Option<Span> {
-        source_span_for_markdown_range(cx.tcx, self.doc, &range, self.fragments)
-    }
-}
-
-#[derive(Copy, Clone, Default)]
-struct DocHeaders {
-    safety: bool,
-    errors: bool,
-    panics: bool,
-}
-
-fn check_attrs(cx: &LateContext<'_>, valid_idents: &FxHashSet<String>, attrs: &[Attribute]) -> Option<DocHeaders> {
-    /// We don't want the parser to choke on intra doc links. Since we don't
-    /// actually care about rendering them, just pretend that all broken links
-    /// point to a fake address.
-    #[expect(clippy::unnecessary_wraps)] // we're following a type signature
-    fn fake_broken_link_callback<'a>(_: BrokenLink<'_>) -> Option<(CowStr<'a>, CowStr<'a>)> {
-        Some(("fake".into(), "fake".into()))
-    }
-
-    if is_doc_hidden(attrs) {
-        return None;
-    }
-
-    check_almost_inner_doc(cx, attrs);
-
-    let (fragments, _) = attrs_to_doc_fragments(attrs.iter().map(|attr| (attr, None)), true);
-    let mut doc = String::new();
-    for fragment in &fragments {
-        add_doc_fragment(&mut doc, fragment);
-    }
-    doc.pop();
-
-    if doc.is_empty() {
-        return Some(DocHeaders::default());
-    }
-
-    let mut cb = fake_broken_link_callback;
-
-    // disable smart punctuation to pick up ['link'] more easily
-    let opts = main_body_opts() - Options::ENABLE_SMART_PUNCTUATION;
-    let parser = pulldown_cmark::Parser::new_with_broken_link_callback(&doc, opts, Some(&mut cb));
-
-    Some(check_doc(
-        cx,
-        valid_idents,
-        parser.into_offset_iter(),
-        Fragments {
-            fragments: &fragments,
-            doc: &doc,
-        },
-    ))
-}
-
-/// Looks for `///!` and `/**!` comments, which were probably meant to be `//!` and `/*!`
-fn check_almost_inner_doc(cx: &LateContext<'_>, attrs: &[Attribute]) {
-    let replacements: Vec<_> = attrs
-        .iter()
-        .filter_map(|attr| {
-            if let AttrKind::DocComment(com_kind, sym) = attr.kind
-                && let AttrStyle::Outer = attr.style
-                && let Some(com) = sym.as_str().strip_prefix('!')
-            {
-                let sugg = match com_kind {
-                    CommentKind::Line => format!("//!{com}"),
-                    CommentKind::Block => format!("/*!{com}*/"),
-                };
-                Some((attr.span, sugg))
-            } else {
-                None
-            }
-        })
-        .collect();
-
-    if let Some((&(lo_span, _), &(hi_span, _))) = replacements.first().zip(replacements.last()) {
-        span_lint_and_then(
-            cx,
-            SUSPICIOUS_DOC_COMMENTS,
-            lo_span.to(hi_span),
-            "this is an outer doc comment and does not apply to the parent module or crate",
-            |diag| {
-                diag.multipart_suggestion(
-                    "use an inner doc comment to document the parent module or crate",
-                    replacements,
-                    Applicability::MaybeIncorrect,
-                );
-            },
-        );
-    }
-}
-
-const RUST_CODE: &[&str] = &["rust", "no_run", "should_panic", "compile_fail"];
-
-#[allow(clippy::too_many_lines)] // Only a big match statement
-fn check_doc<'a, Events: Iterator<Item = (pulldown_cmark::Event<'a>, Range<usize>)>>(
-    cx: &LateContext<'_>,
-    valid_idents: &FxHashSet<String>,
-    events: Events,
-    fragments: Fragments<'_>,
-) -> DocHeaders {
-    // true if a safety header was found
-    let mut headers = DocHeaders::default();
-    let mut in_code = false;
-    let mut in_link = None;
-    let mut in_heading = false;
-    let mut is_rust = false;
-    let mut no_test = false;
-    let mut edition = None;
-    let mut ticks_unbalanced = false;
-    let mut text_to_check: Vec<(CowStr<'_>, Range<usize>)> = Vec::new();
-    let mut paragraph_range = 0..0;
-    for (event, range) in events {
-        match event {
-            Start(CodeBlock(ref kind)) => {
-                in_code = true;
-                if let CodeBlockKind::Fenced(lang) = kind {
-                    for item in lang.split(',') {
-                        if item == "ignore" {
-                            is_rust = false;
-                            break;
-                        } else if item == "no_test" {
-                            no_test = true;
-                        }
-                        if let Some(stripped) = item.strip_prefix("edition") {
-                            is_rust = true;
-                            edition = stripped.parse::<Edition>().ok();
-                        } else if item.is_empty() || RUST_CODE.contains(&item) {
-                            is_rust = true;
-                        }
-                    }
-                }
-            },
-            End(CodeBlock(_)) => {
-                in_code = false;
-                is_rust = false;
-            },
-            Start(Link(_, url, _)) => in_link = Some(url),
-            End(Link(..)) => in_link = None,
-            Start(Heading(_, _, _) | Paragraph | Item) => {
-                if let Start(Heading(_, _, _)) = event {
-                    in_heading = true;
-                }
-                ticks_unbalanced = false;
-                paragraph_range = range;
-            },
-            End(Heading(_, _, _) | Paragraph | Item) => {
-                if let End(Heading(_, _, _)) = event {
-                    in_heading = false;
-                }
-                if ticks_unbalanced && let Some(span) = fragments.span(cx, paragraph_range.clone()) {
-                    span_lint_and_help(
-                        cx,
-                        DOC_MARKDOWN,
-                        span,
-                        "backticks are unbalanced",
-                        None,
-                        "a backtick may be missing a pair",
-                    );
-                } else {
-                    for (text, range) in text_to_check {
-                        if let Some(span) = fragments.span(cx, range) {
-                            check_text(cx, valid_idents, &text, span);
-                        }
-                    }
-                }
-                text_to_check = Vec::new();
-            },
-            Start(_tag) | End(_tag) => (), // We don't care about other tags
-            Html(_html) => (),             // HTML is weird, just ignore it
-            SoftBreak | HardBreak | TaskListMarker(_) | Code(_) | Rule => (),
-            FootnoteReference(text) | Text(text) => {
-                paragraph_range.end = range.end;
-                ticks_unbalanced |= text.contains('`') && !in_code;
-                if Some(&text) == in_link.as_ref() || ticks_unbalanced {
-                    // Probably a link of the form `<http://example.com>`
-                    // Which are represented as a link to "http://example.com" with
-                    // text "http://example.com" by pulldown-cmark
-                    continue;
-                }
-                let trimmed_text = text.trim();
-                headers.safety |= in_heading && trimmed_text == "Safety";
-                headers.safety |= in_heading && trimmed_text == "Implementation safety";
-                headers.safety |= in_heading && trimmed_text == "Implementation Safety";
-                headers.errors |= in_heading && trimmed_text == "Errors";
-                headers.panics |= in_heading && trimmed_text == "Panics";
-                if in_code {
-                    if is_rust && !no_test {
-                        let edition = edition.unwrap_or_else(|| cx.tcx.sess.edition());
-                        check_code(cx, &text, edition, range.clone(), fragments);
-                    }
-                } else {
-                    if in_link.is_some() {
-                        check_link_quotes(cx, trimmed_text, range.clone(), fragments);
-                    }
-                    if let Some(link) = in_link.as_ref()
-                        && let Ok(url) = Url::parse(link)
-                        && (url.scheme() == "https" || url.scheme() == "http")
-                    {
-                        // Don't check the text associated with external URLs
-                        continue;
-                    }
-                    text_to_check.push((text, range));
-                }
-            },
-        }
-    }
-    headers
-}
-
-fn check_link_quotes(cx: &LateContext<'_>, trimmed_text: &str, range: Range<usize>, fragments: Fragments<'_>) {
-    if trimmed_text.starts_with('\'')
-        && trimmed_text.ends_with('\'')
-        && let Some(span) = fragments.span(cx, range)
-    {
-        span_lint(
-            cx,
-            DOC_LINK_WITH_QUOTES,
-            span,
-            "possible intra-doc link using quotes instead of backticks",
-        );
-    }
-}
-
-fn check_code(cx: &LateContext<'_>, text: &str, edition: Edition, range: Range<usize>, fragments: Fragments<'_>) {
-    fn has_needless_main(code: String, edition: Edition) -> bool {
-        rustc_driver::catch_fatal_errors(|| {
-            rustc_span::create_session_globals_then(edition, || {
-                let filename = FileName::anon_source_code(&code);
-
-                let fallback_bundle =
-                    rustc_errors::fallback_fluent_bundle(rustc_driver::DEFAULT_LOCALE_RESOURCES.to_vec(), false);
-                let emitter = EmitterWriter::new(Box::new(io::sink()), fallback_bundle);
-                let handler = Handler::with_emitter(Box::new(emitter)).disable_warnings();
-                #[expect(clippy::arc_with_non_send_sync)] // `Lrc` is expected by with_span_handler
-                let sm = Lrc::new(SourceMap::new(FilePathMapping::empty()));
-                let sess = ParseSess::with_span_handler(handler, sm);
-
-                let mut parser = match maybe_new_parser_from_source_str(&sess, filename, code) {
-                    Ok(p) => p,
-                    Err(errs) => {
-                        drop(errs);
-                        return false;
-                    },
-                };
-
-                let mut relevant_main_found = false;
-                loop {
-                    match parser.parse_item(ForceCollect::No) {
-                        Ok(Some(item)) => match &item.kind {
-                            ItemKind::Fn(box Fn {
-                                sig, body: Some(block), ..
-                            }) if item.ident.name == sym::main => {
-                                let is_async = matches!(sig.header.asyncness, Async::Yes { .. });
-                                let returns_nothing = match &sig.decl.output {
-                                    FnRetTy::Default(..) => true,
-                                    FnRetTy::Ty(ty) if ty.kind.is_unit() => true,
-                                    FnRetTy::Ty(_) => false,
-                                };
-
-                                if returns_nothing && !is_async && !block.stmts.is_empty() {
-                                    // This main function should be linted, but only if there are no other functions
-                                    relevant_main_found = true;
-                                } else {
-                                    // This main function should not be linted, we're done
-                                    return false;
-                                }
-                            },
-                            // Tests with one of these items are ignored
-                            ItemKind::Static(..)
-                            | ItemKind::Const(..)
-                            | ItemKind::ExternCrate(..)
-                            | ItemKind::ForeignMod(..)
-                            // Another function was found; this case is ignored
-                            | ItemKind::Fn(..) => return false,
-                            _ => {},
-                        },
-                        Ok(None) => break,
-                        Err(e) => {
-                            e.cancel();
-                            return false;
-                        },
-                    }
-                }
-
-                relevant_main_found
-            })
-        })
-        .ok()
-        .unwrap_or_default()
-    }
-
-    let trailing_whitespace = text.len() - text.trim_end().len();
-
-    // Because of the global session, we need to create a new session in a different thread with
-    // the edition we need.
-    let text = text.to_owned();
-    if thread::spawn(move || has_needless_main(text, edition))
-        .join()
-        .expect("thread::spawn failed")
-        && let Some(span) = fragments.span(cx, range.start..range.end - trailing_whitespace)
-    {
-        span_lint(cx, NEEDLESS_DOCTEST_MAIN, span, "needless `fn main` in doctest");
-    }
-}
-
-fn check_text(cx: &LateContext<'_>, valid_idents: &FxHashSet<String>, text: &str, span: Span) {
-    for word in text.split(|c: char| c.is_whitespace() || c == '\'') {
-        // Trim punctuation as in `some comment (see foo::bar).`
-        //                                                   ^^
-        // Or even as in `_foo bar_` which is emphasized. Also preserve `::` as a prefix/suffix.
-        let mut word = word.trim_matches(|c: char| !c.is_alphanumeric() && c != ':');
-
-        // Remove leading or trailing single `:` which may be part of a sentence.
-        if word.starts_with(':') && !word.starts_with("::") {
-            word = word.trim_start_matches(':');
-        }
-        if word.ends_with(':') && !word.ends_with("::") {
-            word = word.trim_end_matches(':');
-        }
-
-        if valid_idents.contains(word) || word.chars().all(|c| c == ':') {
-            continue;
-        }
-
-        // Adjust for the current word
-        let offset = word.as_ptr() as usize - text.as_ptr() as usize;
-        let span = Span::new(
-            span.lo() + BytePos::from_usize(offset),
-            span.lo() + BytePos::from_usize(offset + word.len()),
-            span.ctxt(),
-            span.parent(),
-        );
-
-        check_word(cx, word, span);
-    }
-}
-
-fn check_word(cx: &LateContext<'_>, word: &str, span: Span) {
-    /// Checks if a string is upper-camel-case, i.e., starts with an uppercase and
-    /// contains at least two uppercase letters (`Clippy` is ok) and one lower-case
-    /// letter (`NASA` is ok).
-    /// Plurals are also excluded (`IDs` is ok).
-    fn is_camel_case(s: &str) -> bool {
-        if s.starts_with(|c: char| c.is_ascii_digit() | c.is_ascii_lowercase()) {
-            return false;
-        }
-
-        let s = s.strip_suffix('s').unwrap_or(s);
-
-        s.chars().all(char::is_alphanumeric)
-            && s.chars().filter(|&c| c.is_uppercase()).take(2).count() > 1
-            && s.chars().filter(|&c| c.is_lowercase()).take(1).count() > 0
-    }
-
-    fn has_underscore(s: &str) -> bool {
-        s != "_" && !s.contains("\\_") && s.contains('_')
-    }
-
-    fn has_hyphen(s: &str) -> bool {
-        s != "-" && s.contains('-')
-    }
-
-    if let Ok(url) = Url::parse(word) {
-        // try to get around the fact that `foo::bar` parses as a valid URL
-        if !url.cannot_be_a_base() {
-            span_lint(
-                cx,
-                DOC_MARKDOWN,
-                span,
-                "you should put bare URLs between `<`/`>` or make a proper Markdown link",
-            );
-
-            return;
-        }
-    }
-
-    // We assume that mixed-case words are not meant to be put inside backticks. (Issue #2343)
-    if has_underscore(word) && has_hyphen(word) {
-        return;
-    }
-
-    if has_underscore(word) || word.contains("::") || is_camel_case(word) {
-        let mut applicability = Applicability::MachineApplicable;
-
-        span_lint_and_then(
-            cx,
-            DOC_MARKDOWN,
-            span,
-            "item in documentation is missing backticks",
-            |diag| {
-                let snippet = snippet_with_applicability(cx, span, "..", &mut applicability);
-                diag.span_suggestion_with_style(
-                    span,
-                    "try",
-                    format!("`{snippet}`"),
-                    applicability,
-                    // always show the suggestion in a separate line, since the
-                    // inline presentation adds another pair of backticks
-                    SuggestionStyle::ShowAlways,
-                );
-            },
-        );
-    }
-}
-
-struct FindPanicUnwrap<'a, 'tcx> {
-    cx: &'a LateContext<'tcx>,
-    panic_span: Option<Span>,
-    typeck_results: &'tcx ty::TypeckResults<'tcx>,
-}
-
-impl<'a, 'tcx> Visitor<'tcx> for FindPanicUnwrap<'a, 'tcx> {
-    type NestedFilter = nested_filter::OnlyBodies;
-
-    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
-        if self.panic_span.is_some() {
-            return;
-        }
-
-        if let Some(macro_call) = root_macro_call_first_node(self.cx, expr) {
-            if is_panic(self.cx, macro_call.def_id)
-                || matches!(
-                    self.cx.tcx.item_name(macro_call.def_id).as_str(),
-                    "assert" | "assert_eq" | "assert_ne"
-                )
-            {
-                self.panic_span = Some(macro_call.span);
-            }
-        }
-
-        // check for `unwrap` and `expect` for both `Option` and `Result`
-        if let Some(arglists) = method_chain_args(expr, &["unwrap"]).or(method_chain_args(expr, &["expect"])) {
-            let receiver_ty = self.typeck_results.expr_ty(arglists[0].0).peel_refs();
-            if is_type_diagnostic_item(self.cx, receiver_ty, sym::Option)
-                || is_type_diagnostic_item(self.cx, receiver_ty, sym::Result)
-            {
-                self.panic_span = Some(expr.span);
-            }
-        }
-
-        // and check sub-expressions
-        intravisit::walk_expr(self, expr);
-    }
-
-    // Panics in const blocks will cause compilation to fail.
-    fn visit_anon_const(&mut self, _: &'tcx AnonConst) {}
-
-    fn nested_visit_map(&mut self) -> Self::Map {
-        self.cx.tcx.hir()
-    }
-}
diff --git a/clippy_lints/src/doc/link_with_quotes.rs b/clippy_lints/src/doc/link_with_quotes.rs
new file mode 100644
index 00000000000..01191e811b0
--- /dev/null
+++ b/clippy_lints/src/doc/link_with_quotes.rs
@@ -0,0 +1,20 @@
+use std::ops::Range;
+
+use clippy_utils::diagnostics::span_lint;
+use rustc_lint::LateContext;
+
+use super::{Fragments, DOC_LINK_WITH_QUOTES};
+
+pub fn check(cx: &LateContext<'_>, trimmed_text: &str, range: Range<usize>, fragments: Fragments<'_>) {
+    if ((trimmed_text.starts_with('\'') && trimmed_text.ends_with('\''))
+        || (trimmed_text.starts_with('"') && trimmed_text.ends_with('"')))
+        && let Some(span) = fragments.span(cx, range)
+    {
+        span_lint(
+            cx,
+            DOC_LINK_WITH_QUOTES,
+            span,
+            "possible intra-doc link using quotes instead of backticks",
+        );
+    }
+}
diff --git a/clippy_lints/src/doc/markdown.rs b/clippy_lints/src/doc/markdown.rs
new file mode 100644
index 00000000000..c0b11eb0dd1
--- /dev/null
+++ b/clippy_lints/src/doc/markdown.rs
@@ -0,0 +1,109 @@
+use clippy_utils::diagnostics::{span_lint, span_lint_and_then};
+use clippy_utils::source::snippet_with_applicability;
+use rustc_data_structures::fx::FxHashSet;
+use rustc_errors::{Applicability, SuggestionStyle};
+use rustc_lint::LateContext;
+use rustc_span::{BytePos, Pos, Span};
+use url::Url;
+
+use crate::doc::DOC_MARKDOWN;
+
+pub fn check(cx: &LateContext<'_>, valid_idents: &FxHashSet<String>, text: &str, span: Span) {
+    for word in text.split(|c: char| c.is_whitespace() || c == '\'') {
+        // Trim punctuation as in `some comment (see foo::bar).`
+        //                                                   ^^
+        // Or even as in `_foo bar_` which is emphasized. Also preserve `::` as a prefix/suffix.
+        let mut word = word.trim_matches(|c: char| !c.is_alphanumeric() && c != ':');
+
+        // Remove leading or trailing single `:` which may be part of a sentence.
+        if word.starts_with(':') && !word.starts_with("::") {
+            word = word.trim_start_matches(':');
+        }
+        if word.ends_with(':') && !word.ends_with("::") {
+            word = word.trim_end_matches(':');
+        }
+
+        if valid_idents.contains(word) || word.chars().all(|c| c == ':') {
+            continue;
+        }
+
+        // Adjust for the current word
+        let offset = word.as_ptr() as usize - text.as_ptr() as usize;
+        let span = Span::new(
+            span.lo() + BytePos::from_usize(offset),
+            span.lo() + BytePos::from_usize(offset + word.len()),
+            span.ctxt(),
+            span.parent(),
+        );
+
+        check_word(cx, word, span);
+    }
+}
+
+fn check_word(cx: &LateContext<'_>, word: &str, span: Span) {
+    /// Checks if a string is upper-camel-case, i.e., starts with an uppercase and
+    /// contains at least two uppercase letters (`Clippy` is ok) and one lower-case
+    /// letter (`NASA` is ok).
+    /// Plurals are also excluded (`IDs` is ok).
+    fn is_camel_case(s: &str) -> bool {
+        if s.starts_with(|c: char| c.is_ascii_digit() | c.is_ascii_lowercase()) {
+            return false;
+        }
+
+        let s = s.strip_suffix('s').unwrap_or(s);
+
+        s.chars().all(char::is_alphanumeric)
+            && s.chars().filter(|&c| c.is_uppercase()).take(2).count() > 1
+            && s.chars().filter(|&c| c.is_lowercase()).take(1).count() > 0
+    }
+
+    fn has_underscore(s: &str) -> bool {
+        s != "_" && !s.contains("\\_") && s.contains('_')
+    }
+
+    fn has_hyphen(s: &str) -> bool {
+        s != "-" && s.contains('-')
+    }
+
+    if let Ok(url) = Url::parse(word) {
+        // try to get around the fact that `foo::bar` parses as a valid URL
+        if !url.cannot_be_a_base() {
+            span_lint(
+                cx,
+                DOC_MARKDOWN,
+                span,
+                "you should put bare URLs between `<`/`>` or make a proper Markdown link",
+            );
+
+            return;
+        }
+    }
+
+    // We assume that mixed-case words are not meant to be put inside backticks. (Issue #2343)
+    if has_underscore(word) && has_hyphen(word) {
+        return;
+    }
+
+    if has_underscore(word) || word.contains("::") || is_camel_case(word) {
+        let mut applicability = Applicability::MachineApplicable;
+
+        span_lint_and_then(
+            cx,
+            DOC_MARKDOWN,
+            span,
+            "item in documentation is missing backticks",
+            |diag| {
+                let snippet = snippet_with_applicability(cx, span, "..", &mut applicability);
+                diag.span_suggestion_with_style(
+                    span,
+                    "try",
+                    format!("`{snippet}`"),
+                    applicability,
+                    // always show the suggestion in a separate line, since the
+                    // inline presentation adds another pair of backticks
+                    SuggestionStyle::ShowAlways,
+                );
+            },
+        );
+    }
+}
diff --git a/clippy_lints/src/doc/missing_headers.rs b/clippy_lints/src/doc/missing_headers.rs
new file mode 100644
index 00000000000..703a100ef65
--- /dev/null
+++ b/clippy_lints/src/doc/missing_headers.rs
@@ -0,0 +1,84 @@
+use clippy_utils::diagnostics::{span_lint, span_lint_and_note};
+use clippy_utils::ty::{implements_trait, is_type_diagnostic_item};
+use clippy_utils::{is_doc_hidden, return_ty};
+use rustc_hir::{BodyId, FnSig, OwnerId, Unsafety};
+use rustc_lint::LateContext;
+use rustc_middle::ty;
+use rustc_span::{sym, Span};
+
+use super::{DocHeaders, MISSING_ERRORS_DOC, MISSING_PANICS_DOC, MISSING_SAFETY_DOC, UNNECESSARY_SAFETY_DOC};
+
+pub fn check(
+    cx: &LateContext<'_>,
+    owner_id: OwnerId,
+    sig: &FnSig<'_>,
+    headers: DocHeaders,
+    body_id: Option<BodyId>,
+    panic_span: Option<Span>,
+) {
+    if !cx.effective_visibilities.is_exported(owner_id.def_id) {
+        return; // Private functions do not require doc comments
+    }
+
+    // do not lint if any parent has `#[doc(hidden)]` attribute (#7347)
+    if cx
+        .tcx
+        .hir()
+        .parent_iter(owner_id.into())
+        .any(|(id, _node)| is_doc_hidden(cx.tcx.hir().attrs(id)))
+    {
+        return;
+    }
+
+    let span = cx.tcx.def_span(owner_id);
+    match (headers.safety, sig.header.unsafety) {
+        (false, Unsafety::Unsafe) => span_lint(
+            cx,
+            MISSING_SAFETY_DOC,
+            span,
+            "unsafe function's docs miss `# Safety` section",
+        ),
+        (true, Unsafety::Normal) => span_lint(
+            cx,
+            UNNECESSARY_SAFETY_DOC,
+            span,
+            "safe function's docs have unnecessary `# Safety` section",
+        ),
+        _ => (),
+    }
+    if !headers.panics && panic_span.is_some() {
+        span_lint_and_note(
+            cx,
+            MISSING_PANICS_DOC,
+            span,
+            "docs for function which may panic missing `# Panics` section",
+            panic_span,
+            "first possible panic found here",
+        );
+    }
+    if !headers.errors {
+        if is_type_diagnostic_item(cx, return_ty(cx, owner_id), sym::Result) {
+            span_lint(
+                cx,
+                MISSING_ERRORS_DOC,
+                span,
+                "docs for function returning `Result` missing `# Errors` section",
+            );
+        } else if let Some(body_id) = body_id
+            && let Some(future) = cx.tcx.lang_items().future_trait()
+            && let typeck = cx.tcx.typeck_body(body_id)
+            && let body = cx.tcx.hir().body(body_id)
+            && let ret_ty = typeck.expr_ty(body.value)
+            && implements_trait(cx, ret_ty, future, &[])
+            && let ty::Coroutine(_, subs, _) = ret_ty.kind()
+            && is_type_diagnostic_item(cx, subs.as_coroutine().return_ty(), sym::Result)
+        {
+            span_lint(
+                cx,
+                MISSING_ERRORS_DOC,
+                span,
+                "docs for function returning `Result` missing `# Errors` section",
+            );
+        }
+    }
+}
diff --git a/clippy_lints/src/doc/mod.rs b/clippy_lints/src/doc/mod.rs
new file mode 100644
index 00000000000..2b8f0bc503b
--- /dev/null
+++ b/clippy_lints/src/doc/mod.rs
@@ -0,0 +1,664 @@
+use clippy_utils::attrs::is_doc_hidden;
+use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
+use clippy_utils::macros::{is_panic, root_macro_call_first_node};
+use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::visitors::Visitable;
+use clippy_utils::{is_entrypoint_fn, method_chain_args};
+use pulldown_cmark::Event::{
+    Code, End, FootnoteReference, HardBreak, Html, Rule, SoftBreak, Start, TaskListMarker, Text,
+};
+use pulldown_cmark::Tag::{CodeBlock, Heading, Item, Link, Paragraph};
+use pulldown_cmark::{BrokenLink, CodeBlockKind, CowStr, Options};
+use rustc_ast::ast::Attribute;
+use rustc_data_structures::fx::FxHashSet;
+use rustc_hir as hir;
+use rustc_hir::intravisit::{self, Visitor};
+use rustc_hir::{AnonConst, Expr};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::hir::nested_filter;
+use rustc_middle::lint::in_external_macro;
+use rustc_middle::ty;
+use rustc_resolve::rustdoc::{
+    add_doc_fragment, attrs_to_doc_fragments, main_body_opts, source_span_for_markdown_range, DocFragment,
+};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::edition::Edition;
+use rustc_span::{sym, Span};
+use std::ops::Range;
+use url::Url;
+
+mod link_with_quotes;
+mod markdown;
+mod missing_headers;
+mod needless_doctest_main;
+mod suspicious_doc_comments;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for the presence of `_`, `::` or camel-case words
+    /// outside ticks in documentation.
+    ///
+    /// ### Why is this bad?
+    /// *Rustdoc* supports markdown formatting, `_`, `::` and
+    /// camel-case probably indicates some code which should be included between
+    /// ticks. `_` can also be used for emphasis in markdown, this lint tries to
+    /// consider that.
+    ///
+    /// ### Known problems
+    /// Lots of bad docs won’t be fixed, what the lint checks
+    /// for is limited, and there are still false positives. HTML elements and their
+    /// content are not linted.
+    ///
+    /// In addition, when writing documentation comments, including `[]` brackets
+    /// inside a link text would trip the parser. Therefore, documenting link with
+    /// `[`SmallVec<[T; INLINE_CAPACITY]>`]` and then [`SmallVec<[T; INLINE_CAPACITY]>`]: SmallVec
+    /// would fail.
+    ///
+    /// ### Examples
+    /// ```no_run
+    /// /// Do something with the foo_bar parameter. See also
+    /// /// that::other::module::foo.
+    /// // ^ `foo_bar` and `that::other::module::foo` should be ticked.
+    /// fn doit(foo_bar: usize) {}
+    /// ```
+    ///
+    /// ```no_run
+    /// // Link text with `[]` brackets should be written as following:
+    /// /// Consume the array and return the inner
+    /// /// [`SmallVec<[T; INLINE_CAPACITY]>`][SmallVec].
+    /// /// [SmallVec]: SmallVec
+    /// fn main() {}
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub DOC_MARKDOWN,
+    pedantic,
+    "presence of `_`, `::` or camel-case outside backticks in documentation"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for the doc comments of publicly visible
+    /// unsafe functions and warns if there is no `# Safety` section.
+    ///
+    /// ### Why is this bad?
+    /// Unsafe functions should document their safety
+    /// preconditions, so that users can be sure they are using them safely.
+    ///
+    /// ### Examples
+    /// ```no_run
+    ///# type Universe = ();
+    /// /// This function should really be documented
+    /// pub unsafe fn start_apocalypse(u: &mut Universe) {
+    ///     unimplemented!();
+    /// }
+    /// ```
+    ///
+    /// At least write a line about safety:
+    ///
+    /// ```no_run
+    ///# type Universe = ();
+    /// /// # Safety
+    /// ///
+    /// /// This function should not be called before the horsemen are ready.
+    /// pub unsafe fn start_apocalypse(u: &mut Universe) {
+    ///     unimplemented!();
+    /// }
+    /// ```
+    #[clippy::version = "1.39.0"]
+    pub MISSING_SAFETY_DOC,
+    style,
+    "`pub unsafe fn` without `# Safety` docs"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks the doc comments of publicly visible functions that
+    /// return a `Result` type and warns if there is no `# Errors` section.
+    ///
+    /// ### Why is this bad?
+    /// Documenting the type of errors that can be returned from a
+    /// function can help callers write code to handle the errors appropriately.
+    ///
+    /// ### Examples
+    /// Since the following function returns a `Result` it has an `# Errors` section in
+    /// its doc comment:
+    ///
+    /// ```no_run
+    ///# use std::io;
+    /// /// # Errors
+    /// ///
+    /// /// Will return `Err` if `filename` does not exist or the user does not have
+    /// /// permission to read it.
+    /// pub fn read(filename: String) -> io::Result<String> {
+    ///     unimplemented!();
+    /// }
+    /// ```
+    #[clippy::version = "1.41.0"]
+    pub MISSING_ERRORS_DOC,
+    pedantic,
+    "`pub fn` returns `Result` without `# Errors` in doc comment"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks the doc comments of publicly visible functions that
+    /// may panic and warns if there is no `# Panics` section.
+    ///
+    /// ### Why is this bad?
+    /// Documenting the scenarios in which panicking occurs
+    /// can help callers who do not want to panic to avoid those situations.
+    ///
+    /// ### Examples
+    /// Since the following function may panic it has a `# Panics` section in
+    /// its doc comment:
+    ///
+    /// ```no_run
+    /// /// # Panics
+    /// ///
+    /// /// Will panic if y is 0
+    /// pub fn divide_by(x: i32, y: i32) -> i32 {
+    ///     if y == 0 {
+    ///         panic!("Cannot divide by 0")
+    ///     } else {
+    ///         x / y
+    ///     }
+    /// }
+    /// ```
+    #[clippy::version = "1.51.0"]
+    pub MISSING_PANICS_DOC,
+    pedantic,
+    "`pub fn` may panic without `# Panics` in doc comment"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `fn main() { .. }` in doctests
+    ///
+    /// ### Why is this bad?
+    /// The test can be shorter (and likely more readable)
+    /// if the `fn main()` is left implicit.
+    ///
+    /// ### Examples
+    /// ```no_run
+    /// /// An example of a doctest with a `main()` function
+    /// ///
+    /// /// # Examples
+    /// ///
+    /// /// ```
+    /// /// fn main() {
+    /// ///     // this needs not be in an `fn`
+    /// /// }
+    /// /// ```
+    /// fn needless_main() {
+    ///     unimplemented!();
+    /// }
+    /// ```
+    #[clippy::version = "1.40.0"]
+    pub NEEDLESS_DOCTEST_MAIN,
+    style,
+    "presence of `fn main() {` in code examples"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Detects the syntax `['foo']` in documentation comments (notice quotes instead of backticks)
+    /// outside of code blocks
+    /// ### Why is this bad?
+    /// It is likely a typo when defining an intra-doc link
+    ///
+    /// ### Example
+    /// ```no_run
+    /// /// See also: ['foo']
+    /// fn bar() {}
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// /// See also: [`foo`]
+    /// fn bar() {}
+    /// ```
+    #[clippy::version = "1.63.0"]
+    pub DOC_LINK_WITH_QUOTES,
+    pedantic,
+    "possible typo for an intra-doc link"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for the doc comments of publicly visible
+    /// safe functions and traits and warns if there is a `# Safety` section.
+    ///
+    /// ### Why is this bad?
+    /// Safe functions and traits are safe to implement and therefore do not
+    /// need to describe safety preconditions that users are required to uphold.
+    ///
+    /// ### Examples
+    /// ```no_run
+    ///# type Universe = ();
+    /// /// # Safety
+    /// ///
+    /// /// This function should not be called before the horsemen are ready.
+    /// pub fn start_apocalypse_but_safely(u: &mut Universe) {
+    ///     unimplemented!();
+    /// }
+    /// ```
+    ///
+    /// The function is safe, so there shouldn't be any preconditions
+    /// that have to be explained for safety reasons.
+    ///
+    /// ```no_run
+    ///# type Universe = ();
+    /// /// This function should really be documented
+    /// pub fn start_apocalypse(u: &mut Universe) {
+    ///     unimplemented!();
+    /// }
+    /// ```
+    #[clippy::version = "1.67.0"]
+    pub UNNECESSARY_SAFETY_DOC,
+    restriction,
+    "`pub fn` or `pub trait` with `# Safety` docs"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Detects the use of outer doc comments (`///`, `/**`) followed by a bang (`!`): `///!`
+    ///
+    /// ### Why is this bad?
+    /// Triple-slash comments (known as "outer doc comments") apply to items that follow it.
+    /// An outer doc comment followed by a bang (i.e. `///!`) has no specific meaning.
+    ///
+    /// The user most likely meant to write an inner doc comment (`//!`, `/*!`), which
+    /// applies to the parent item (i.e. the item that the comment is contained in,
+    /// usually a module or crate).
+    ///
+    /// ### Known problems
+    /// Inner doc comments can only appear before items, so there are certain cases where the suggestion
+    /// made by this lint is not valid code. For example:
+    /// ```rs
+    /// fn foo() {}
+    /// ///!
+    /// fn bar() {}
+    /// ```
+    /// This lint detects the doc comment and suggests changing it to `//!`, but an inner doc comment
+    /// is not valid at that position.
+    ///
+    /// ### Example
+    /// In this example, the doc comment is attached to the *function*, rather than the *module*.
+    /// ```no_run
+    /// pub mod util {
+    ///     ///! This module contains utility functions.
+    ///
+    ///     pub fn dummy() {}
+    /// }
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// pub mod util {
+    ///     //! This module contains utility functions.
+    ///
+    ///     pub fn dummy() {}
+    /// }
+    /// ```
+    #[clippy::version = "1.70.0"]
+    pub SUSPICIOUS_DOC_COMMENTS,
+    suspicious,
+    "suspicious usage of (outer) doc comments"
+}
+
+#[expect(clippy::module_name_repetitions)]
+#[derive(Clone)]
+pub struct DocMarkdown {
+    valid_idents: FxHashSet<String>,
+    in_trait_impl: bool,
+}
+
+impl DocMarkdown {
+    pub fn new(valid_idents: &[String]) -> Self {
+        Self {
+            valid_idents: valid_idents.iter().cloned().collect(),
+            in_trait_impl: false,
+        }
+    }
+}
+
+impl_lint_pass!(DocMarkdown => [
+    DOC_LINK_WITH_QUOTES,
+    DOC_MARKDOWN,
+    MISSING_SAFETY_DOC,
+    MISSING_ERRORS_DOC,
+    MISSING_PANICS_DOC,
+    NEEDLESS_DOCTEST_MAIN,
+    UNNECESSARY_SAFETY_DOC,
+    SUSPICIOUS_DOC_COMMENTS
+]);
+
+impl<'tcx> LateLintPass<'tcx> for DocMarkdown {
+    fn check_crate(&mut self, cx: &LateContext<'tcx>) {
+        let attrs = cx.tcx.hir().attrs(hir::CRATE_HIR_ID);
+        check_attrs(cx, &self.valid_idents, attrs);
+    }
+
+    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) {
+        let attrs = cx.tcx.hir().attrs(item.hir_id());
+        let Some(headers) = check_attrs(cx, &self.valid_idents, attrs) else {
+            return;
+        };
+        match item.kind {
+            hir::ItemKind::Fn(ref sig, _, body_id) => {
+                if !(is_entrypoint_fn(cx, item.owner_id.to_def_id()) || in_external_macro(cx.tcx.sess, item.span)) {
+                    let body = cx.tcx.hir().body(body_id);
+
+                    let panic_span = FindPanicUnwrap::find_span(cx, cx.tcx.typeck(item.owner_id), body.value);
+                    missing_headers::check(cx, item.owner_id, sig, headers, Some(body_id), panic_span);
+                }
+            },
+            hir::ItemKind::Impl(impl_) => {
+                self.in_trait_impl = impl_.of_trait.is_some();
+            },
+            hir::ItemKind::Trait(_, unsafety, ..) => match (headers.safety, unsafety) {
+                (false, hir::Unsafety::Unsafe) => span_lint(
+                    cx,
+                    MISSING_SAFETY_DOC,
+                    cx.tcx.def_span(item.owner_id),
+                    "docs for unsafe trait missing `# Safety` section",
+                ),
+                (true, hir::Unsafety::Normal) => span_lint(
+                    cx,
+                    UNNECESSARY_SAFETY_DOC,
+                    cx.tcx.def_span(item.owner_id),
+                    "docs for safe trait have unnecessary `# Safety` section",
+                ),
+                _ => (),
+            },
+            _ => (),
+        }
+    }
+
+    fn check_item_post(&mut self, _cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) {
+        if let hir::ItemKind::Impl { .. } = item.kind {
+            self.in_trait_impl = false;
+        }
+    }
+
+    fn check_trait_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::TraitItem<'_>) {
+        let attrs = cx.tcx.hir().attrs(item.hir_id());
+        let Some(headers) = check_attrs(cx, &self.valid_idents, attrs) else {
+            return;
+        };
+        if let hir::TraitItemKind::Fn(ref sig, ..) = item.kind {
+            if !in_external_macro(cx.tcx.sess, item.span) {
+                missing_headers::check(cx, item.owner_id, sig, headers, None, None);
+            }
+        }
+    }
+
+    fn check_impl_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::ImplItem<'_>) {
+        let attrs = cx.tcx.hir().attrs(item.hir_id());
+        let Some(headers) = check_attrs(cx, &self.valid_idents, attrs) else {
+            return;
+        };
+        if self.in_trait_impl || in_external_macro(cx.tcx.sess, item.span) {
+            return;
+        }
+        if let hir::ImplItemKind::Fn(ref sig, body_id) = item.kind {
+            let body = cx.tcx.hir().body(body_id);
+
+            let panic_span = FindPanicUnwrap::find_span(cx, cx.tcx.typeck(item.owner_id), body.value);
+            missing_headers::check(cx, item.owner_id, sig, headers, Some(body_id), panic_span);
+        }
+    }
+}
+
+#[derive(Copy, Clone)]
+struct Fragments<'a> {
+    doc: &'a str,
+    fragments: &'a [DocFragment],
+}
+
+impl Fragments<'_> {
+    fn span(self, cx: &LateContext<'_>, range: Range<usize>) -> Option<Span> {
+        source_span_for_markdown_range(cx.tcx, self.doc, &range, self.fragments)
+    }
+}
+
+#[derive(Copy, Clone, Default)]
+struct DocHeaders {
+    safety: bool,
+    errors: bool,
+    panics: bool,
+}
+
+/// Does some pre-processing on raw, desugared `#[doc]` attributes such as parsing them and
+/// then delegates to `check_doc`.
+/// Some lints are already checked here if they can work with attributes directly and don't need
+/// to work with markdown.
+/// Others are checked elsewhere, e.g. in `check_doc` if they need access to markdown, or
+/// back in the various late lint pass methods if they need the final doc headers, like "Safety" or
+/// "Panics" sections.
+fn check_attrs(cx: &LateContext<'_>, valid_idents: &FxHashSet<String>, attrs: &[Attribute]) -> Option<DocHeaders> {
+    /// We don't want the parser to choke on intra doc links. Since we don't
+    /// actually care about rendering them, just pretend that all broken links
+    /// point to a fake address.
+    #[expect(clippy::unnecessary_wraps)] // we're following a type signature
+    fn fake_broken_link_callback<'a>(_: BrokenLink<'_>) -> Option<(CowStr<'a>, CowStr<'a>)> {
+        Some(("fake".into(), "fake".into()))
+    }
+
+    if is_doc_hidden(attrs) {
+        return None;
+    }
+
+    suspicious_doc_comments::check(cx, attrs);
+
+    let (fragments, _) = attrs_to_doc_fragments(attrs.iter().map(|attr| (attr, None)), true);
+    let mut doc = String::new();
+    for fragment in &fragments {
+        add_doc_fragment(&mut doc, fragment);
+    }
+    doc.pop();
+
+    if doc.is_empty() {
+        return Some(DocHeaders::default());
+    }
+
+    let mut cb = fake_broken_link_callback;
+
+    // disable smart punctuation to pick up ['link'] more easily
+    let opts = main_body_opts() - Options::ENABLE_SMART_PUNCTUATION;
+    let parser = pulldown_cmark::Parser::new_with_broken_link_callback(&doc, opts, Some(&mut cb));
+
+    Some(check_doc(
+        cx,
+        valid_idents,
+        parser.into_offset_iter(),
+        Fragments {
+            fragments: &fragments,
+            doc: &doc,
+        },
+    ))
+}
+
+const RUST_CODE: &[&str] = &["rust", "no_run", "should_panic", "compile_fail"];
+
+/// Checks parsed documentation.
+/// This walks the "events" (think sections of markdown) produced by `pulldown_cmark`,
+/// so lints here will generally access that information.
+/// Returns documentation headers -- whether a "Safety", "Errors", "Panic" section was found
+#[allow(clippy::too_many_lines)] // Only a big match statement
+fn check_doc<'a, Events: Iterator<Item = (pulldown_cmark::Event<'a>, Range<usize>)>>(
+    cx: &LateContext<'_>,
+    valid_idents: &FxHashSet<String>,
+    events: Events,
+    fragments: Fragments<'_>,
+) -> DocHeaders {
+    // true if a safety header was found
+    let mut headers = DocHeaders::default();
+    let mut in_code = false;
+    let mut in_link = None;
+    let mut in_heading = false;
+    let mut is_rust = false;
+    let mut no_test = false;
+    let mut edition = None;
+    let mut ticks_unbalanced = false;
+    let mut text_to_check: Vec<(CowStr<'_>, Range<usize>)> = Vec::new();
+    let mut paragraph_range = 0..0;
+    for (event, range) in events {
+        match event {
+            Start(CodeBlock(ref kind)) => {
+                in_code = true;
+                if let CodeBlockKind::Fenced(lang) = kind {
+                    for item in lang.split(',') {
+                        if item == "ignore" {
+                            is_rust = false;
+                            break;
+                        } else if item == "no_test" {
+                            no_test = true;
+                        }
+                        if let Some(stripped) = item.strip_prefix("edition") {
+                            is_rust = true;
+                            edition = stripped.parse::<Edition>().ok();
+                        } else if item.is_empty() || RUST_CODE.contains(&item) {
+                            is_rust = true;
+                        }
+                    }
+                }
+            },
+            End(CodeBlock(_)) => {
+                in_code = false;
+                is_rust = false;
+            },
+            Start(Link(_, url, _)) => in_link = Some(url),
+            End(Link(..)) => in_link = None,
+            Start(Heading(_, _, _) | Paragraph | Item) => {
+                if let Start(Heading(_, _, _)) = event {
+                    in_heading = true;
+                }
+                ticks_unbalanced = false;
+                paragraph_range = range;
+            },
+            End(Heading(_, _, _) | Paragraph | Item) => {
+                if let End(Heading(_, _, _)) = event {
+                    in_heading = false;
+                }
+                if ticks_unbalanced && let Some(span) = fragments.span(cx, paragraph_range.clone()) {
+                    span_lint_and_help(
+                        cx,
+                        DOC_MARKDOWN,
+                        span,
+                        "backticks are unbalanced",
+                        None,
+                        "a backtick may be missing a pair",
+                    );
+                } else {
+                    for (text, range) in text_to_check {
+                        if let Some(span) = fragments.span(cx, range) {
+                            markdown::check(cx, valid_idents, &text, span);
+                        }
+                    }
+                }
+                text_to_check = Vec::new();
+            },
+            Start(_tag) | End(_tag) => (), // We don't care about other tags
+            Html(_html) => (),             // HTML is weird, just ignore it
+            SoftBreak | HardBreak | TaskListMarker(_) | Code(_) | Rule => (),
+            FootnoteReference(text) | Text(text) => {
+                paragraph_range.end = range.end;
+                ticks_unbalanced |= text.contains('`') && !in_code;
+                if Some(&text) == in_link.as_ref() || ticks_unbalanced {
+                    // Probably a link of the form `<http://example.com>`
+                    // Which are represented as a link to "http://example.com" with
+                    // text "http://example.com" by pulldown-cmark
+                    continue;
+                }
+                let trimmed_text = text.trim();
+                headers.safety |= in_heading && trimmed_text == "Safety";
+                headers.safety |= in_heading && trimmed_text == "Implementation safety";
+                headers.safety |= in_heading && trimmed_text == "Implementation Safety";
+                headers.errors |= in_heading && trimmed_text == "Errors";
+                headers.panics |= in_heading && trimmed_text == "Panics";
+                if in_code {
+                    if is_rust && !no_test {
+                        let edition = edition.unwrap_or_else(|| cx.tcx.sess.edition());
+                        needless_doctest_main::check(cx, &text, edition, range.clone(), fragments);
+                    }
+                } else {
+                    if in_link.is_some() {
+                        link_with_quotes::check(cx, trimmed_text, range.clone(), fragments);
+                    }
+                    if let Some(link) = in_link.as_ref()
+                        && let Ok(url) = Url::parse(link)
+                        && (url.scheme() == "https" || url.scheme() == "http")
+                    {
+                        // Don't check the text associated with external URLs
+                        continue;
+                    }
+                    text_to_check.push((text, range));
+                }
+            },
+        }
+    }
+    headers
+}
+
+struct FindPanicUnwrap<'a, 'tcx> {
+    cx: &'a LateContext<'tcx>,
+    panic_span: Option<Span>,
+    typeck_results: &'tcx ty::TypeckResults<'tcx>,
+}
+
+impl<'a, 'tcx> FindPanicUnwrap<'a, 'tcx> {
+    pub fn find_span(
+        cx: &'a LateContext<'tcx>,
+        typeck_results: &'tcx ty::TypeckResults<'tcx>,
+        body: impl Visitable<'tcx>,
+    ) -> Option<Span> {
+        let mut vis = Self {
+            cx,
+            panic_span: None,
+            typeck_results,
+        };
+        body.visit(&mut vis);
+        vis.panic_span
+    }
+}
+
+impl<'a, 'tcx> Visitor<'tcx> for FindPanicUnwrap<'a, 'tcx> {
+    type NestedFilter = nested_filter::OnlyBodies;
+
+    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
+        if self.panic_span.is_some() {
+            return;
+        }
+
+        if let Some(macro_call) = root_macro_call_first_node(self.cx, expr) {
+            if is_panic(self.cx, macro_call.def_id)
+                || matches!(
+                    self.cx.tcx.item_name(macro_call.def_id).as_str(),
+                    "assert" | "assert_eq" | "assert_ne"
+                )
+            {
+                self.panic_span = Some(macro_call.span);
+            }
+        }
+
+        // check for `unwrap` and `expect` for both `Option` and `Result`
+        if let Some(arglists) = method_chain_args(expr, &["unwrap"]).or(method_chain_args(expr, &["expect"])) {
+            let receiver_ty = self.typeck_results.expr_ty(arglists[0].0).peel_refs();
+            if is_type_diagnostic_item(self.cx, receiver_ty, sym::Option)
+                || is_type_diagnostic_item(self.cx, receiver_ty, sym::Result)
+            {
+                self.panic_span = Some(expr.span);
+            }
+        }
+
+        // and check sub-expressions
+        intravisit::walk_expr(self, expr);
+    }
+
+    // Panics in const blocks will cause compilation to fail.
+    fn visit_anon_const(&mut self, _: &'tcx AnonConst) {}
+
+    fn nested_visit_map(&mut self) -> Self::Map {
+        self.cx.tcx.hir()
+    }
+}
diff --git a/clippy_lints/src/doc/needless_doctest_main.rs b/clippy_lints/src/doc/needless_doctest_main.rs
new file mode 100644
index 00000000000..4d7d7611dd8
--- /dev/null
+++ b/clippy_lints/src/doc/needless_doctest_main.rs
@@ -0,0 +1,100 @@
+use std::ops::Range;
+use std::{io, thread};
+
+use crate::doc::NEEDLESS_DOCTEST_MAIN;
+use clippy_utils::diagnostics::span_lint;
+use rustc_ast::{Async, Fn, FnRetTy, ItemKind};
+use rustc_data_structures::sync::Lrc;
+use rustc_errors::emitter::EmitterWriter;
+use rustc_errors::Handler;
+use rustc_lint::LateContext;
+use rustc_parse::maybe_new_parser_from_source_str;
+use rustc_parse::parser::ForceCollect;
+use rustc_session::parse::ParseSess;
+use rustc_span::edition::Edition;
+use rustc_span::source_map::{FilePathMapping, SourceMap};
+use rustc_span::{sym, FileName};
+
+use super::Fragments;
+
+pub fn check(cx: &LateContext<'_>, text: &str, edition: Edition, range: Range<usize>, fragments: Fragments<'_>) {
+    fn has_needless_main(code: String, edition: Edition) -> bool {
+        rustc_driver::catch_fatal_errors(|| {
+            rustc_span::create_session_globals_then(edition, || {
+                let filename = FileName::anon_source_code(&code);
+
+                let fallback_bundle =
+                    rustc_errors::fallback_fluent_bundle(rustc_driver::DEFAULT_LOCALE_RESOURCES.to_vec(), false);
+                let emitter = EmitterWriter::new(Box::new(io::sink()), fallback_bundle);
+                let handler = Handler::with_emitter(Box::new(emitter)).disable_warnings();
+                #[expect(clippy::arc_with_non_send_sync)] // `Lrc` is expected by with_span_handler
+                let sm = Lrc::new(SourceMap::new(FilePathMapping::empty()));
+                let sess = ParseSess::with_span_handler(handler, sm);
+
+                let mut parser = match maybe_new_parser_from_source_str(&sess, filename, code) {
+                    Ok(p) => p,
+                    Err(errs) => {
+                        drop(errs);
+                        return false;
+                    },
+                };
+
+                let mut relevant_main_found = false;
+                loop {
+                    match parser.parse_item(ForceCollect::No) {
+                        Ok(Some(item)) => match &item.kind {
+                            ItemKind::Fn(box Fn {
+                                sig, body: Some(block), ..
+                            }) if item.ident.name == sym::main => {
+                                let is_async = matches!(sig.header.asyncness, Async::Yes { .. });
+                                let returns_nothing = match &sig.decl.output {
+                                    FnRetTy::Default(..) => true,
+                                    FnRetTy::Ty(ty) if ty.kind.is_unit() => true,
+                                    FnRetTy::Ty(_) => false,
+                                };
+
+                                if returns_nothing && !is_async && !block.stmts.is_empty() {
+                                    // This main function should be linted, but only if there are no other functions
+                                    relevant_main_found = true;
+                                } else {
+                                    // This main function should not be linted, we're done
+                                    return false;
+                                }
+                            },
+                            // Tests with one of these items are ignored
+                            ItemKind::Static(..)
+                            | ItemKind::Const(..)
+                            | ItemKind::ExternCrate(..)
+                            | ItemKind::ForeignMod(..)
+                            // Another function was found; this case is ignored
+                            | ItemKind::Fn(..) => return false,
+                            _ => {},
+                        },
+                        Ok(None) => break,
+                        Err(e) => {
+                            e.cancel();
+                            return false;
+                        },
+                    }
+                }
+
+                relevant_main_found
+            })
+        })
+        .ok()
+        .unwrap_or_default()
+    }
+
+    let trailing_whitespace = text.len() - text.trim_end().len();
+
+    // Because of the global session, we need to create a new session in a different thread with
+    // the edition we need.
+    let text = text.to_owned();
+    if thread::spawn(move || has_needless_main(text, edition))
+        .join()
+        .expect("thread::spawn failed")
+        && let Some(span) = fragments.span(cx, range.start..range.end - trailing_whitespace)
+    {
+        span_lint(cx, NEEDLESS_DOCTEST_MAIN, span, "needless `fn main` in doctest");
+    }
+}
diff --git a/clippy_lints/src/doc/suspicious_doc_comments.rs b/clippy_lints/src/doc/suspicious_doc_comments.rs
new file mode 100644
index 00000000000..d7ad30efec3
--- /dev/null
+++ b/clippy_lints/src/doc/suspicious_doc_comments.rs
@@ -0,0 +1,48 @@
+use clippy_utils::diagnostics::span_lint_and_then;
+use rustc_ast::token::CommentKind;
+use rustc_ast::{AttrKind, AttrStyle, Attribute};
+use rustc_errors::Applicability;
+use rustc_lint::LateContext;
+use rustc_span::Span;
+
+use super::SUSPICIOUS_DOC_COMMENTS;
+
+pub fn check(cx: &LateContext<'_>, attrs: &[Attribute]) {
+    let replacements: Vec<_> = collect_doc_replacements(attrs);
+
+    if let Some((&(lo_span, _), &(hi_span, _))) = replacements.first().zip(replacements.last()) {
+        span_lint_and_then(
+            cx,
+            SUSPICIOUS_DOC_COMMENTS,
+            lo_span.to(hi_span),
+            "this is an outer doc comment and does not apply to the parent module or crate",
+            |diag| {
+                diag.multipart_suggestion(
+                    "use an inner doc comment to document the parent module or crate",
+                    replacements,
+                    Applicability::MaybeIncorrect,
+                );
+            },
+        );
+    }
+}
+
+fn collect_doc_replacements(attrs: &[Attribute]) -> Vec<(Span, String)> {
+    attrs
+        .iter()
+        .filter_map(|attr| {
+            if let AttrKind::DocComment(com_kind, sym) = attr.kind
+                && let AttrStyle::Outer = attr.style
+                && let Some(com) = sym.as_str().strip_prefix('!')
+            {
+                let sugg = match com_kind {
+                    CommentKind::Line => format!("//!{com}"),
+                    CommentKind::Block => format!("/*!{com}*/"),
+                };
+                Some((attr.span, sugg))
+            } else {
+                None
+            }
+        })
+        .collect()
+}
diff --git a/tests/ui/doc_link_with_quotes.rs b/tests/ui/doc_link_with_quotes.rs
index 37d0d135957..48e1b1819c6 100644
--- a/tests/ui/doc_link_with_quotes.rs
+++ b/tests/ui/doc_link_with_quotes.rs
@@ -11,6 +11,12 @@ pub fn foo() {
     bar()
 }
 
+/// Calls ["bar"] uselessly
+//~^ ERROR: possible intra-doc link using quotes instead of backticks
+pub fn foo2() {
+    bar()
+}
+
 /// # Examples
 /// This demonstrates issue \#8961
 /// ```
diff --git a/tests/ui/doc_link_with_quotes.stderr b/tests/ui/doc_link_with_quotes.stderr
index 2db1bc09289..cd4f87c56b4 100644
--- a/tests/ui/doc_link_with_quotes.stderr
+++ b/tests/ui/doc_link_with_quotes.stderr
@@ -7,5 +7,11 @@ LL | /// Calls ['bar'] uselessly
    = note: `-D clippy::doc-link-with-quotes` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::doc_link_with_quotes)]`
 
-error: aborting due to previous error
+error: possible intra-doc link using quotes instead of backticks
+  --> $DIR/doc_link_with_quotes.rs:14:12
+   |
+LL | /// Calls ["bar"] uselessly
+   |            ^^^^^
+
+error: aborting due to 2 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 34d9e88a4739a33d0d570947691c78d6980c48a9 Mon Sep 17 00:00:00 2001
From: ofeeg <mhanna0000@gmail.com>
Date: Sat, 2 Sep 2023 23:42:11 +0200
Subject: New lint `clippy::join_absolute_paths`

* `join_absolute_paths` Address PR review
* Move `clippy::join_absolute_paths` to `clippy::suspicious`
* `join_absolute_paths`: Address PR review

Co-Authored-By: ofeeg <mhanna0000@gmail.com>
---
 CHANGELOG.md                                    |  1 +
 clippy_lints/src/declared_lints.rs              |  1 +
 clippy_lints/src/methods/join_absolute_paths.rs | 52 +++++++++++++++++++
 clippy_lints/src/methods/mod.rs                 | 44 ++++++++++++++++
 tests/ui/join_absolute_paths.rs                 | 30 +++++++++++
 tests/ui/join_absolute_paths.stderr             | 68 +++++++++++++++++++++++++
 6 files changed, 196 insertions(+)
 create mode 100644 clippy_lints/src/methods/join_absolute_paths.rs
 create mode 100644 tests/ui/join_absolute_paths.rs
 create mode 100644 tests/ui/join_absolute_paths.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 1760d19b385..46f5ff168f6 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5190,6 +5190,7 @@ Released 2018-09-13
 [`iter_with_drain`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_with_drain
 [`iter_without_into_iter`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_without_into_iter
 [`iterator_step_by_zero`]: https://rust-lang.github.io/rust-clippy/master/index.html#iterator_step_by_zero
+[`join_absolute_paths`]: https://rust-lang.github.io/rust-clippy/master/index.html#join_absolute_paths
 [`just_underscores_and_digits`]: https://rust-lang.github.io/rust-clippy/master/index.html#just_underscores_and_digits
 [`large_const_arrays`]: https://rust-lang.github.io/rust-clippy/master/index.html#large_const_arrays
 [`large_digit_groups`]: https://rust-lang.github.io/rust-clippy/master/index.html#large_digit_groups
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 55dedc0a658..7d4ab9fde1f 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -377,6 +377,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::methods::ITER_SKIP_NEXT_INFO,
     crate::methods::ITER_SKIP_ZERO_INFO,
     crate::methods::ITER_WITH_DRAIN_INFO,
+    crate::methods::JOIN_ABSOLUTE_PATHS_INFO,
     crate::methods::MANUAL_FILTER_MAP_INFO,
     crate::methods::MANUAL_FIND_MAP_INFO,
     crate::methods::MANUAL_NEXT_BACK_INFO,
diff --git a/clippy_lints/src/methods/join_absolute_paths.rs b/clippy_lints/src/methods/join_absolute_paths.rs
new file mode 100644
index 00000000000..02f28779cf6
--- /dev/null
+++ b/clippy_lints/src/methods/join_absolute_paths.rs
@@ -0,0 +1,52 @@
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::expr_or_init;
+use clippy_utils::source::snippet_opt;
+use clippy_utils::ty::is_type_diagnostic_item;
+use rustc_ast::ast::LitKind;
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind};
+use rustc_lint::LateContext;
+use rustc_span::symbol::sym;
+use rustc_span::Span;
+
+use super::JOIN_ABSOLUTE_PATHS;
+
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, recv: &'tcx Expr<'tcx>, join_arg: &'tcx Expr<'tcx>, expr_span: Span) {
+    let ty = cx.typeck_results().expr_ty(recv).peel_refs();
+    if (is_type_diagnostic_item(cx, ty, sym::Path) || is_type_diagnostic_item(cx, ty, sym::PathBuf))
+        && let ExprKind::Lit(spanned) = expr_or_init(cx, join_arg).kind
+        && let LitKind::Str(symbol, _) = spanned.node
+        && let sym_str = symbol.as_str()
+        && sym_str.starts_with(['/', '\\'])
+    {
+        span_lint_and_then(
+            cx,
+            JOIN_ABSOLUTE_PATHS,
+            join_arg.span,
+            "argument to `Path::join` starts with a path separator",
+            |diag| {
+                let arg_str = snippet_opt(cx, spanned.span).unwrap_or_else(|| "..".to_string());
+
+                let no_separator = if sym_str.starts_with('/') {
+                    arg_str.replacen('/', "", 1)
+                } else {
+                    arg_str.replacen('\\', "", 1)
+                };
+
+                diag.note("joining a path starting with separator will replace the path instead")
+                    .span_suggestion(
+                        spanned.span,
+                        "if this is unintentional, try removing the starting separator",
+                        no_separator,
+                        Applicability::Unspecified,
+                    )
+                    .span_suggestion(
+                        expr_span,
+                        "if this is intentional, try using `Path::new` instead",
+                        format!("PathBuf::from({arg_str})"),
+                        Applicability::Unspecified,
+                    );
+            },
+        );
+    }
+}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 3166a33fc2f..9ea2f6448b6 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -49,6 +49,7 @@ mod iter_skip_next;
 mod iter_skip_zero;
 mod iter_with_drain;
 mod iterator_step_by_zero;
+mod join_absolute_paths;
 mod manual_next_back;
 mod manual_ok_or;
 mod manual_saturating_arithmetic;
@@ -3684,6 +3685,46 @@ declare_clippy_lint! {
     "calling the `try_from` and `try_into` trait methods when `From`/`Into` is implemented"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for calls to `Path::join` that start with a path separator (`\\` or `/`).
+    ///
+    /// ### Why is this bad?
+    /// If the argument to `Path::join` starts with a separator, it will overwrite
+    /// the original path. If this is intentional, prefer using `Path::new` instead.
+    ///
+    /// Note the behavior is platform dependent. A leading `\\` will be accepted
+    /// on unix systems as part of the file name
+    ///
+    /// See [`Path::join`](https://doc.rust-lang.org/std/path/struct.Path.html#method.join)
+    ///
+    /// ### Example
+    /// ```rust
+    /// # use std::path::{Path, PathBuf};
+    /// let path = Path::new("/bin");
+    /// let joined_path = path.join("/sh");
+    /// assert_eq!(joined_path, PathBuf::from("/sh"));
+    /// ```
+    ///
+    /// Use instead;
+    /// ```rust
+    /// # use std::path::{Path, PathBuf};
+    /// let path = Path::new("/bin");
+    ///
+    /// // If this was unintentional, remove the leading separator
+    /// let joined_path = path.join("sh");
+    /// assert_eq!(joined_path, PathBuf::from("/bin/sh"));
+    ///
+    /// // If this was intentional, create a new path instead
+    /// let new = Path::new("/sh");
+    /// assert_eq!(new, PathBuf::from("/sh"));
+    /// ```
+    #[clippy::version = "1.76.0"]
+    pub JOIN_ABSOLUTE_PATHS,
+    suspicious,
+    "calls to `Path::join` which will overwrite the original path"
+}
+
 pub struct Methods {
     avoid_breaking_exported_api: bool,
     msrv: Msrv,
@@ -3833,6 +3874,7 @@ impl_lint_pass!(Methods => [
     REDUNDANT_AS_STR,
     WAKER_CLONE_WAKE,
     UNNECESSARY_FALLIBLE_CONVERSIONS,
+    JOIN_ABSOLUTE_PATHS,
 ]);
 
 /// Extracts a method call name, args, and `Span` of the method name.
@@ -4235,6 +4277,8 @@ impl Methods {
                 ("join", [join_arg]) => {
                     if let Some(("collect", _, _, span, _)) = method_call(recv) {
                         unnecessary_join::check(cx, expr, recv, join_arg, span);
+                    } else {
+                        join_absolute_paths::check(cx, recv, join_arg, expr.span);
                     }
                 },
                 ("last", []) => {
diff --git a/tests/ui/join_absolute_paths.rs b/tests/ui/join_absolute_paths.rs
new file mode 100644
index 00000000000..efa77a0492e
--- /dev/null
+++ b/tests/ui/join_absolute_paths.rs
@@ -0,0 +1,30 @@
+//@no-rustfix
+
+#![allow(clippy::needless_raw_string_hashes)]
+#![warn(clippy::join_absolute_paths)]
+
+use std::path::{Path, PathBuf};
+
+fn main() {
+    let path = Path::new("/bin");
+    path.join("/sh");
+    //~^ ERROR: argument to `Path::join` starts with a path separator
+
+    let path = Path::new("C:\\Users");
+    path.join("\\user");
+    //~^ ERROR: argument to `Path::join` starts with a path separator
+
+    let path = PathBuf::from("/bin");
+    path.join("/sh");
+    //~^ ERROR: argument to `Path::join` starts with a path separator
+
+    let path = PathBuf::from("/bin");
+    path.join(r#"/sh"#);
+    //~^ ERROR: argument to `Path::join` starts with a path separator
+
+    let path: &[&str] = &["/bin"];
+    path.join("/sh");
+
+    let path = Path::new("/bin");
+    path.join("sh");
+}
diff --git a/tests/ui/join_absolute_paths.stderr b/tests/ui/join_absolute_paths.stderr
new file mode 100644
index 00000000000..0c2f89d9978
--- /dev/null
+++ b/tests/ui/join_absolute_paths.stderr
@@ -0,0 +1,68 @@
+error: argument to `Path::join` starts with a path separator
+  --> $DIR/join_absolute_paths.rs:10:15
+   |
+LL |     path.join("/sh");
+   |               ^^^^^
+   |
+   = note: joining a path starting with separator will replace the path instead
+   = note: `-D clippy::join-absolute-paths` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::join_absolute_paths)]`
+help: if this is unintentional, try removing the starting separator
+   |
+LL |     path.join("sh");
+   |               ~~~~
+help: if this is intentional, try using `Path::new` instead
+   |
+LL |     PathBuf::from("/sh");
+   |     ~~~~~~~~~~~~~~~~~~~~
+
+error: argument to `Path::join` starts with a path separator
+  --> $DIR/join_absolute_paths.rs:14:15
+   |
+LL |     path.join("\\user");
+   |               ^^^^^^^^
+   |
+   = note: joining a path starting with separator will replace the path instead
+help: if this is unintentional, try removing the starting separator
+   |
+LL |     path.join("\user");
+   |               ~~~~~~~
+help: if this is intentional, try using `Path::new` instead
+   |
+LL |     PathBuf::from("\\user");
+   |     ~~~~~~~~~~~~~~~~~~~~~~~
+
+error: argument to `Path::join` starts with a path separator
+  --> $DIR/join_absolute_paths.rs:18:15
+   |
+LL |     path.join("/sh");
+   |               ^^^^^
+   |
+   = note: joining a path starting with separator will replace the path instead
+help: if this is unintentional, try removing the starting separator
+   |
+LL |     path.join("sh");
+   |               ~~~~
+help: if this is intentional, try using `Path::new` instead
+   |
+LL |     PathBuf::from("/sh");
+   |     ~~~~~~~~~~~~~~~~~~~~
+
+error: argument to `Path::join` starts with a path separator
+  --> $DIR/join_absolute_paths.rs:22:15
+   |
+LL |     path.join(r#"/sh"#);
+   |               ^^^^^^^^
+   |
+   = note: joining a path starting with separator will replace the path instead
+help: if this is unintentional, try removing the starting separator
+   |
+LL |     path.join(r#"sh"#);
+   |               ~~~~~~~
+help: if this is intentional, try using `Path::new` instead
+   |
+LL |     PathBuf::from(r#"/sh"#);
+   |     ~~~~~~~~~~~~~~~~~~~~~~~
+
+error: aborting due to 4 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 3e9a6d142ecf637edc02b74b8a1e5b9d0e612219 Mon Sep 17 00:00:00 2001
From: J-ZhengLi <lizheng135@huawei.com>
Date: Tue, 21 Nov 2023 16:18:18 +0800
Subject: stop warning never-returning calls and add more test cases

---
 clippy_lints/src/loops/infinite_loops.rs | 113 +++++++++++++++++++--------
 clippy_lints/src/loops/mod.rs            |  34 ++-------
 tests/ui/infinite_loops.rs               | 101 +++++++++++++++++++++++++
 tests/ui/infinite_loops.stderr           | 126 ++++++++++++++++++++++++++++---
 4 files changed, 306 insertions(+), 68 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/infinite_loops.rs b/clippy_lints/src/loops/infinite_loops.rs
index b97cd8bd006..06f94c075eb 100644
--- a/clippy_lints/src/loops/infinite_loops.rs
+++ b/clippy_lints/src/loops/infinite_loops.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::is_lint_allowed;
+use clippy_utils::{fn_def_id, is_lint_allowed};
 use hir::intravisit::{walk_expr, Visitor};
-use hir::{Block, Destination, Expr, ExprKind, FnRetTy, Ty, TyKind};
+use hir::{Expr, ExprKind, FnRetTy, FnSig, Node};
 use rustc_ast::Label;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
@@ -9,44 +9,56 @@ use rustc_lint::LateContext;
 
 use super::INFINITE_LOOPS;
 
-pub(super) fn check(
-    cx: &LateContext<'_>,
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
     expr: &Expr<'_>,
-    loop_block: &Block<'_>,
+    loop_block: &'tcx hir::Block<'_>,
     label: Option<Label>,
-    parent_fn_ret_ty: FnRetTy<'_>,
 ) {
-    if is_lint_allowed(cx, INFINITE_LOOPS, expr.hir_id)
-        || matches!(
-            parent_fn_ret_ty,
-            FnRetTy::Return(Ty {
-                kind: TyKind::Never,
-                ..
-            })
-        )
-    {
+    if is_lint_allowed(cx, INFINITE_LOOPS, expr.hir_id) {
+        return;
+    }
+
+    // Skip check if this loop is not in a function/method/closure. (In some weird case)
+    let Some(parent_fn_ret) = get_parent_fn_ret_ty(cx, expr) else {
+        return;
+    };
+    // Or, its parent function is already returning `Never`
+    if matches!(
+        parent_fn_ret,
+        FnRetTy::Return(hir::Ty {
+            kind: hir::TyKind::Never,
+            ..
+        })
+    ) {
         return;
     }
 
     // First, find any `break` or `return` without entering any inner loop,
     // then, find `return` or labeled `break` which breaks this loop with entering inner loop,
     // otherwise this loop is a infinite loop.
-    let mut direct_br_or_ret_finder = BreakOrRetFinder::default();
-    direct_br_or_ret_finder.visit_block(loop_block);
+    let mut direct_visitor = LoopVisitor {
+        cx,
+        label,
+        is_finite: false,
+        enter_nested_loop: false,
+    };
+    direct_visitor.visit_block(loop_block);
 
-    let is_finite_loop = direct_br_or_ret_finder.found || {
-        let mut inner_br_or_ret_finder = BreakOrRetFinder {
+    let is_finite_loop = direct_visitor.is_finite || {
+        let mut inner_loop_visitor = LoopVisitor {
+            cx,
             label,
+            is_finite: false,
             enter_nested_loop: true,
-            ..Default::default()
         };
-        inner_br_or_ret_finder.visit_block(loop_block);
-        inner_br_or_ret_finder.found
+        inner_loop_visitor.visit_block(loop_block);
+        inner_loop_visitor.is_finite
     };
 
     if !is_finite_loop {
         span_lint_and_then(cx, INFINITE_LOOPS, expr.span, "infinite loop detected", |diag| {
-            if let FnRetTy::DefaultReturn(ret_span) = parent_fn_ret_ty {
+            if let FnRetTy::DefaultReturn(ret_span) = parent_fn_ret {
                 diag.span_suggestion(
                     ret_span,
                     "if this is intentional, consider specifing `!` as function return",
@@ -56,37 +68,72 @@ pub(super) fn check(
             } else {
                 diag.span_help(
                     expr.span,
-                    "if this is not intended, add a `break` or `return` condition in this loop",
+                    "if this is not intended, try adding a `break` or `return` condition in this loop",
                 );
             }
         });
     }
 }
 
-#[derive(Default)]
-struct BreakOrRetFinder {
+fn get_parent_fn_ret_ty<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>) -> Option<FnRetTy<'tcx>> {
+    for (_, parent_node) in cx.tcx.hir().parent_iter(expr.hir_id) {
+        match parent_node {
+            Node::Item(hir::Item {
+                kind: hir::ItemKind::Fn(FnSig { decl, .. }, _, _),
+                ..
+            })
+            | Node::TraitItem(hir::TraitItem {
+                kind: hir::TraitItemKind::Fn(FnSig { decl, .. }, _),
+                ..
+            })
+            | Node::ImplItem(hir::ImplItem {
+                kind: hir::ImplItemKind::Fn(FnSig { decl, .. }, _),
+                ..
+            })
+            | Node::Expr(Expr {
+                kind: ExprKind::Closure(hir::Closure { fn_decl: decl, .. }),
+                ..
+            }) => return Some(decl.output),
+            _ => (),
+        }
+    }
+    None
+}
+
+struct LoopVisitor<'hir, 'tcx> {
+    cx: &'hir LateContext<'tcx>,
     label: Option<Label>,
-    found: bool,
+    is_finite: bool,
     enter_nested_loop: bool,
 }
 
-impl<'hir> Visitor<'hir> for BreakOrRetFinder {
+impl<'hir> Visitor<'hir> for LoopVisitor<'hir, '_> {
     fn visit_expr(&mut self, ex: &'hir Expr<'_>) {
         match &ex.kind {
-            ExprKind::Break(Destination { label, .. }, ..) => {
+            ExprKind::Break(hir::Destination { label, .. }, ..) => {
                 // When entering nested loop, only by breaking this loop's label
                 // would be considered as exiting this loop.
                 if self.enter_nested_loop {
                     if label.is_some() && *label == self.label {
-                        self.found = true;
+                        self.is_finite = true;
                     }
                 } else {
-                    self.found = true;
+                    self.is_finite = true;
                 }
             },
-            ExprKind::Ret(..) => self.found = true,
+            ExprKind::Ret(..) => self.is_finite = true,
             ExprKind::Loop(..) if !self.enter_nested_loop => (),
-            _ => walk_expr(self, ex),
+            _ => {
+                // Calls to a function that never return
+                if let Some(did) = fn_def_id(self.cx, ex) {
+                    let fn_ret_ty = self.cx.tcx.fn_sig(did).skip_binder().output().skip_binder();
+                    if fn_ret_ty.is_never() {
+                        self.is_finite = true;
+                        return;
+                    }
+                }
+                walk_expr(self, ex);
+            },
         }
     }
 }
diff --git a/clippy_lints/src/loops/mod.rs b/clippy_lints/src/loops/mod.rs
index c69d0b68cf4..214e406374f 100644
--- a/clippy_lints/src/loops/mod.rs
+++ b/clippy_lints/src/loops/mod.rs
@@ -23,7 +23,7 @@ mod while_let_on_iterator;
 
 use clippy_config::msrvs::Msrv;
 use clippy_utils::higher;
-use rustc_hir::{self as hir, Expr, ExprKind, LoopSource, Pat};
+use rustc_hir::{Expr, ExprKind, LoopSource, Pat};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::source_map::Span;
@@ -678,22 +678,20 @@ declare_clippy_lint! {
     "possibly unintended infinite loops"
 }
 
-pub struct Loops<'tcx> {
+pub struct Loops {
     msrv: Msrv,
     enforce_iter_loop_reborrow: bool,
-    parent_fn_ret_ty: Option<hir::FnRetTy<'tcx>>,
 }
-impl<'tcx> Loops<'tcx> {
+impl Loops {
     pub fn new(msrv: Msrv, enforce_iter_loop_reborrow: bool) -> Self {
         Self {
             msrv,
             enforce_iter_loop_reborrow,
-            parent_fn_ret_ty: None,
         }
     }
 }
 
-impl_lint_pass!(Loops<'_> => [
+impl_lint_pass!(Loops => [
     MANUAL_MEMCPY,
     MANUAL_FLATTEN,
     NEEDLESS_RANGE_LOOP,
@@ -717,7 +715,7 @@ impl_lint_pass!(Loops<'_> => [
     INFINITE_LOOPS,
 ]);
 
-impl<'tcx> LateLintPass<'tcx> for Loops<'tcx> {
+impl<'tcx> LateLintPass<'tcx> for Loops {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         let for_loop = higher::ForLoop::hir(expr);
         if let Some(higher::ForLoop {
@@ -757,9 +755,7 @@ impl<'tcx> LateLintPass<'tcx> for Loops<'tcx> {
             // also check for empty `loop {}` statements, skipping those in #[panic_handler]
             empty_loop::check(cx, expr, block);
             while_let_loop::check(cx, expr, block);
-            if let Some(parent_fn_ret_ty) = self.parent_fn_ret_ty {
-                infinite_loops::check(cx, expr, block, label, parent_fn_ret_ty);
-            }
+            infinite_loops::check(cx, expr, block, label);
         }
 
         while_let_on_iterator::check(cx, expr);
@@ -771,25 +767,11 @@ impl<'tcx> LateLintPass<'tcx> for Loops<'tcx> {
         }
     }
 
-    fn check_fn(
-        &mut self,
-        _: &LateContext<'tcx>,
-        kind: hir::intravisit::FnKind<'tcx>,
-        decl: &'tcx hir::FnDecl<'tcx>,
-        _: &'tcx hir::Body<'tcx>,
-        _: Span,
-        _: rustc_span::def_id::LocalDefId,
-    ) {
-        if let hir::intravisit::FnKind::ItemFn(..) = kind {
-            self.parent_fn_ret_ty = Some(decl.output);
-        }
-    }
-
     extract_msrv_attr!(LateContext);
 }
 
-impl<'tcx> Loops<'tcx> {
-    fn check_for_loop(
+impl Loops {
+    fn check_for_loop<'tcx>(
         &self,
         cx: &LateContext<'tcx>,
         pat: &'tcx Pat<'_>,
diff --git a/tests/ui/infinite_loops.rs b/tests/ui/infinite_loops.rs
index 54ab63d80dd..0c18ad620bf 100644
--- a/tests/ui/infinite_loops.rs
+++ b/tests/ui/infinite_loops.rs
@@ -11,6 +11,31 @@ fn no_break() {
     }
 }
 
+fn all_inf() {
+    loop {
+        //~^ ERROR: infinite loop detected
+        loop {
+            //~^ ERROR: infinite loop detected
+            loop {
+                //~^ ERROR: infinite loop detected
+                do_something();
+            }
+        }
+        do_something();
+    }
+}
+
+fn no_break_return_some_ty() -> Option<u8> {
+    loop {
+        do_something();
+        return None;
+    }
+    loop {
+        //~^ ERROR: infinite loop detected
+        do_something();
+    }
+}
+
 fn no_break_never_ret() -> ! {
     loop {
         do_something();
@@ -256,4 +281,80 @@ fn ret_in_macro(opt: Option<u8>) {
     }
 }
 
+fn panic_like_macros_1() {
+    loop {
+        do_something();
+        panic!();
+    }
+}
+
+fn panic_like_macros_2() {
+    let mut x = 0;
+
+    loop {
+        do_something();
+        if true {
+            todo!();
+        }
+    }
+    loop {
+        do_something();
+        x += 1;
+        assert_eq!(x, 0);
+    }
+    loop {
+        do_something();
+        assert!(x % 2 == 0);
+    }
+    loop {
+        do_something();
+        match Some(1) {
+            Some(n) => println!("{n}"),
+            None => unreachable!("It won't happen"),
+        }
+    }
+}
+
+fn exit_directly(cond: bool) {
+    loop {
+        if cond {
+            std::process::exit(0);
+        }
+    }
+}
+
+trait MyTrait {
+    fn problematic_trait_method() {
+        loop {
+            //~^ ERROR: infinite loop detected
+            do_something();
+        }
+    }
+    fn could_be_problematic();
+}
+
+impl MyTrait for String {
+    fn could_be_problematic() {
+        loop {
+            //~^ ERROR: infinite loop detected
+            do_something();
+        }
+    }
+}
+
+fn inf_loop_in_closure() {
+    let _loop_forever = || {
+        loop {
+            //~^ ERROR: infinite loop detected
+            do_something();
+        }
+    };
+
+    let _somehow_ok = || -> ! {
+        loop {
+            do_something();
+        }
+    };
+}
+
 fn main() {}
diff --git a/tests/ui/infinite_loops.stderr b/tests/ui/infinite_loops.stderr
index f6bca43f1a4..ebbc6151188 100644
--- a/tests/ui/infinite_loops.stderr
+++ b/tests/ui/infinite_loops.stderr
@@ -15,7 +15,73 @@ LL | fn no_break() -> ! {
    |               ++++
 
 error: infinite loop detected
-  --> $DIR/infinite_loops.rs:21:5
+  --> $DIR/infinite_loops.rs:15:5
+   |
+LL | /     loop {
+LL | |
+LL | |         loop {
+LL | |
+...  |
+LL | |         do_something();
+LL | |     }
+   | |_____^
+   |
+help: if this is intentional, consider specifing `!` as function return
+   |
+LL | fn all_inf() -> ! {
+   |              ++++
+
+error: infinite loop detected
+  --> $DIR/infinite_loops.rs:17:9
+   |
+LL | /         loop {
+LL | |
+LL | |             loop {
+LL | |
+LL | |                 do_something();
+LL | |             }
+LL | |         }
+   | |_________^
+   |
+help: if this is intentional, consider specifing `!` as function return
+   |
+LL | fn all_inf() -> ! {
+   |              ++++
+
+error: infinite loop detected
+  --> $DIR/infinite_loops.rs:19:13
+   |
+LL | /             loop {
+LL | |
+LL | |                 do_something();
+LL | |             }
+   | |_____________^
+   |
+help: if this is intentional, consider specifing `!` as function return
+   |
+LL | fn all_inf() -> ! {
+   |              ++++
+
+error: infinite loop detected
+  --> $DIR/infinite_loops.rs:33:5
+   |
+LL | /     loop {
+LL | |
+LL | |         do_something();
+LL | |     }
+   | |_____^
+   |
+help: if this is not intended, try adding a `break` or `return` condition in this loop
+  --> $DIR/infinite_loops.rs:33:5
+   |
+LL | /     loop {
+LL | |
+LL | |         do_something();
+LL | |     }
+   | |_____^
+
+error: infinite loop detected
+  --> $DIR/infinite_loops.rs:46:5
    |
 LL | /     loop {
 LL | |         fn inner_fn() -> ! {
@@ -31,7 +97,7 @@ LL | fn no_break_never_ret_noise() -> ! {
    |                               ++++
 
 error: infinite loop detected
-  --> $DIR/infinite_loops.rs:64:5
+  --> $DIR/infinite_loops.rs:89:5
    |
 LL | /     loop {
 LL | |
@@ -48,7 +114,7 @@ LL | fn break_inner_but_not_outer_1(cond: bool) -> ! {
    |                                            ++++
 
 error: infinite loop detected
-  --> $DIR/infinite_loops.rs:75:5
+  --> $DIR/infinite_loops.rs:100:5
    |
 LL | /     loop {
 LL | |
@@ -65,7 +131,7 @@ LL | fn break_inner_but_not_outer_2(cond: bool) -> ! {
    |                                            ++++
 
 error: infinite loop detected
-  --> $DIR/infinite_loops.rs:89:9
+  --> $DIR/infinite_loops.rs:114:9
    |
 LL | /         loop {
 LL | |
@@ -79,7 +145,7 @@ LL | fn break_outer_but_not_inner() -> ! {
    |                                ++++
 
 error: infinite loop detected
-  --> $DIR/infinite_loops.rs:112:9
+  --> $DIR/infinite_loops.rs:137:9
    |
 LL | /         loop {
 LL | |
@@ -96,7 +162,7 @@ LL | fn break_wrong_loop(cond: bool) -> ! {
    |                                 ++++
 
 error: infinite loop detected
-  --> $DIR/infinite_loops.rs:152:5
+  --> $DIR/infinite_loops.rs:177:5
    |
 LL | /     loop {
 LL | |
@@ -113,7 +179,7 @@ LL | fn match_like() -> ! {
    |                 ++++
 
 error: infinite loop detected
-  --> $DIR/infinite_loops.rs:193:5
+  --> $DIR/infinite_loops.rs:218:5
    |
 LL | /     loop {
 LL | |
@@ -127,7 +193,7 @@ LL | fn match_like() -> ! {
    |                 ++++
 
 error: infinite loop detected
-  --> $DIR/infinite_loops.rs:198:5
+  --> $DIR/infinite_loops.rs:223:5
    |
 LL | /     loop {
 LL | |
@@ -143,5 +209,47 @@ help: if this is intentional, consider specifing `!` as function return
 LL | fn match_like() -> ! {
    |                 ++++
 
-error: aborting due to 9 previous errors
+error: infinite loop detected
+  --> $DIR/infinite_loops.rs:328:9
+   |
+LL | /         loop {
+LL | |
+LL | |             do_something();
+LL | |         }
+   | |_________^
+   |
+help: if this is intentional, consider specifing `!` as function return
+   |
+LL |     fn problematic_trait_method() -> ! {
+   |                                   ++++
+
+error: infinite loop detected
+  --> $DIR/infinite_loops.rs:338:9
+   |
+LL | /         loop {
+LL | |
+LL | |             do_something();
+LL | |         }
+   | |_________^
+   |
+help: if this is intentional, consider specifing `!` as function return
+   |
+LL |     fn could_be_problematic() -> ! {
+   |                               ++++
+
+error: infinite loop detected
+  --> $DIR/infinite_loops.rs:347:9
+   |
+LL | /         loop {
+LL | |
+LL | |             do_something();
+LL | |         }
+   | |_________^
+   |
+help: if this is intentional, consider specifing `!` as function return
+   |
+LL |     let _loop_forever = || -> ! {
+   |                            ++++
+
+error: aborting due to 16 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From abd9deb9f46942e6615187a4a6d515340ceb4cc6 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Sun, 19 Nov 2023 15:54:02 +0100
Subject: [`missing_safety_doc`], [`unnecessary_safety_doc`],
 [`missing_panics_doc`], [`missing_errors_doc`]: Added the
 [`check-private-items`] configuration to enable lints on private items.
 [#11842](https://github.com/rust-lang/rust-clippy/pull/11842)

---
 CHANGELOG.md                                       |  1 +
 book/src/lint_configuration.md                     | 13 +++++++++++
 clippy_config/src/conf.rs                          |  4 ++++
 clippy_lints/src/doc/missing_headers.rs            | 14 +++++++-----
 clippy_lints/src/doc/mod.rs                        | 26 ++++++++++++++++++----
 clippy_lints/src/lib.rs                            |  3 ++-
 .../toml_unknown_key/conf_unknown_key.stderr       |  2 ++
 7 files changed, 52 insertions(+), 11 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 46f5ff168f6..11a2d1e7ef9 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5740,4 +5740,5 @@ Released 2018-09-13
 [`absolute-paths-allowed-crates`]: https://doc.rust-lang.org/clippy/lint_configuration.html#absolute-paths-allowed-crates
 [`allowed-dotfiles`]: https://doc.rust-lang.org/clippy/lint_configuration.html#allowed-dotfiles
 [`enforce-iter-loop-reborrow`]: https://doc.rust-lang.org/clippy/lint_configuration.html#enforce-iter-loop-reborrow
+[`check-private-items`]: https://doc.rust-lang.org/clippy/lint_configuration.html#check-private-items
 <!-- end autogenerated links to configuration documentation -->
diff --git a/book/src/lint_configuration.md b/book/src/lint_configuration.md
index 841a5b6d007..eaef074b8c5 100644
--- a/book/src/lint_configuration.md
+++ b/book/src/lint_configuration.md
@@ -791,3 +791,16 @@ for _ in &mut *rmvec {}
 * [`explicit_iter_loop`](https://rust-lang.github.io/rust-clippy/master/index.html#explicit_iter_loop)
 
 
+## `check-private-items`
+
+
+**Default Value:** `false`
+
+---
+**Affected lints:**
+* [`missing_safety_doc`](https://rust-lang.github.io/rust-clippy/master/index.html#missing_safety_doc)
+* [`unnecessary_safety_doc`](https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_safety_doc)
+* [`missing_panics_doc`](https://rust-lang.github.io/rust-clippy/master/index.html#missing_panics_doc)
+* [`missing_errors_doc`](https://rust-lang.github.io/rust-clippy/master/index.html#missing_errors_doc)
+
+
diff --git a/clippy_config/src/conf.rs b/clippy_config/src/conf.rs
index 47259776921..064cb0426b4 100644
--- a/clippy_config/src/conf.rs
+++ b/clippy_config/src/conf.rs
@@ -543,6 +543,10 @@ define_Conf! {
     /// for _ in &mut *rmvec {}
     /// ```
     (enforce_iter_loop_reborrow: bool = false),
+    /// Lint: MISSING_SAFETY_DOC, UNNECESSARY_SAFETY_DOC, MISSING_PANICS_DOC, MISSING_ERRORS_DOC
+    ///
+    /// Whether to also run the listed lints on private items.
+    (check_private_items: bool = false),
 }
 
 /// Search for the configuration file.
diff --git a/clippy_lints/src/doc/missing_headers.rs b/clippy_lints/src/doc/missing_headers.rs
index 703a100ef65..4cbfa97a8a3 100644
--- a/clippy_lints/src/doc/missing_headers.rs
+++ b/clippy_lints/src/doc/missing_headers.rs
@@ -15,17 +15,19 @@ pub fn check(
     headers: DocHeaders,
     body_id: Option<BodyId>,
     panic_span: Option<Span>,
+    check_private_items: bool,
 ) {
-    if !cx.effective_visibilities.is_exported(owner_id.def_id) {
+    if !check_private_items && !cx.effective_visibilities.is_exported(owner_id.def_id) {
         return; // Private functions do not require doc comments
     }
 
     // do not lint if any parent has `#[doc(hidden)]` attribute (#7347)
-    if cx
-        .tcx
-        .hir()
-        .parent_iter(owner_id.into())
-        .any(|(id, _node)| is_doc_hidden(cx.tcx.hir().attrs(id)))
+    if !check_private_items
+        && cx
+            .tcx
+            .hir()
+            .parent_iter(owner_id.into())
+            .any(|(id, _node)| is_doc_hidden(cx.tcx.hir().attrs(id)))
     {
         return;
     }
diff --git a/clippy_lints/src/doc/mod.rs b/clippy_lints/src/doc/mod.rs
index 2b8f0bc503b..607af6ba905 100644
--- a/clippy_lints/src/doc/mod.rs
+++ b/clippy_lints/src/doc/mod.rs
@@ -310,13 +310,15 @@ declare_clippy_lint! {
 pub struct DocMarkdown {
     valid_idents: FxHashSet<String>,
     in_trait_impl: bool,
+    check_private_items: bool,
 }
 
 impl DocMarkdown {
-    pub fn new(valid_idents: &[String]) -> Self {
+    pub fn new(valid_idents: &[String], check_private_items: bool) -> Self {
         Self {
             valid_idents: valid_idents.iter().cloned().collect(),
             in_trait_impl: false,
+            check_private_items,
         }
     }
 }
@@ -349,7 +351,15 @@ impl<'tcx> LateLintPass<'tcx> for DocMarkdown {
                     let body = cx.tcx.hir().body(body_id);
 
                     let panic_span = FindPanicUnwrap::find_span(cx, cx.tcx.typeck(item.owner_id), body.value);
-                    missing_headers::check(cx, item.owner_id, sig, headers, Some(body_id), panic_span);
+                    missing_headers::check(
+                        cx,
+                        item.owner_id,
+                        sig,
+                        headers,
+                        Some(body_id),
+                        panic_span,
+                        self.check_private_items,
+                    );
                 }
             },
             hir::ItemKind::Impl(impl_) => {
@@ -387,7 +397,7 @@ impl<'tcx> LateLintPass<'tcx> for DocMarkdown {
         };
         if let hir::TraitItemKind::Fn(ref sig, ..) = item.kind {
             if !in_external_macro(cx.tcx.sess, item.span) {
-                missing_headers::check(cx, item.owner_id, sig, headers, None, None);
+                missing_headers::check(cx, item.owner_id, sig, headers, None, None, self.check_private_items);
             }
         }
     }
@@ -404,7 +414,15 @@ impl<'tcx> LateLintPass<'tcx> for DocMarkdown {
             let body = cx.tcx.hir().body(body_id);
 
             let panic_span = FindPanicUnwrap::find_span(cx, cx.tcx.typeck(item.owner_id), body.value);
-            missing_headers::check(cx, item.owner_id, sig, headers, Some(body_id), panic_span);
+            missing_headers::check(
+                cx,
+                item.owner_id,
+                sig,
+                headers,
+                Some(body_id),
+                panic_span,
+                self.check_private_items,
+            );
         }
     }
 }
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 952625c78be..abe768d50c7 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -563,6 +563,7 @@ pub fn register_lints(store: &mut rustc_lint::LintStore, conf: &'static Conf) {
         vec_box_size_threshold,
         verbose_bit_mask_threshold,
         warn_on_all_wildcard_imports,
+        check_private_items,
 
         blacklisted_names: _,
         cyclomatic_complexity_threshold: _,
@@ -746,7 +747,7 @@ pub fn register_lints(store: &mut rustc_lint::LintStore, conf: &'static Conf) {
             avoid_breaking_exported_api,
         ))
     });
-    store.register_late_pass(move |_| Box::new(doc::DocMarkdown::new(doc_valid_idents)));
+    store.register_late_pass(move |_| Box::new(doc::DocMarkdown::new(doc_valid_idents, check_private_items)));
     store.register_late_pass(|_| Box::new(neg_multiply::NegMultiply));
     store.register_late_pass(|_| Box::new(let_if_seq::LetIfSeq));
     store.register_late_pass(|_| Box::new(mixed_read_write_in_expression::EvalOrderDependence));
diff --git a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
index 2f9eaa5178c..12828cf9dec 100644
--- a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
+++ b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
@@ -21,6 +21,7 @@ error: error reading Clippy's configuration file: unknown field `foobar`, expect
            await-holding-invalid-types
            blacklisted-names
            cargo-ignore-publish
+           check-private-items
            cognitive-complexity-threshold
            cyclomatic-complexity-threshold
            disallowed-macros
@@ -95,6 +96,7 @@ error: error reading Clippy's configuration file: unknown field `barfoo`, expect
            await-holding-invalid-types
            blacklisted-names
            cargo-ignore-publish
+           check-private-items
            cognitive-complexity-threshold
            cyclomatic-complexity-threshold
            disallowed-macros
-- 
cgit 1.4.1-3-g733a5


From a74fa97faba208993073b0d5faf2092063109560 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Fri, 6 Oct 2023 15:06:06 +0200
Subject: [`needless_return_with_question_mark`]: dont lint in case of coercion

---
 clippy_lints/src/returns.rs                        | 21 ++++++++++++++++++++-
 tests/ui/needless_return_with_question_mark.fixed  | 18 ++++++++++++++++++
 tests/ui/needless_return_with_question_mark.rs     | 18 ++++++++++++++++++
 tests/ui/needless_return_with_question_mark.stderr | 10 ++++++++--
 4 files changed, 64 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
index 8595205691b..d64e931a2f3 100644
--- a/clippy_lints/src/returns.rs
+++ b/clippy_lints/src/returns.rs
@@ -7,10 +7,12 @@ use core::ops::ControlFlow;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::{
-    Block, Body, Expr, ExprKind, FnDecl, ItemKind, LangItem, MatchSource, OwnerNode, PatKind, QPath, Stmt, StmtKind,
+    Block, Body, Expr, ExprKind, FnDecl, HirId, ItemKind, LangItem, MatchSource, Node, OwnerNode, PatKind, QPath, Stmt,
+    StmtKind,
 };
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
+use rustc_middle::ty::adjustment::Adjust;
 use rustc_middle::ty::{self, GenericArgKind, Ty};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::def_id::LocalDefId;
@@ -158,6 +160,22 @@ impl<'tcx> ToString for RetReplacement<'tcx> {
 
 declare_lint_pass!(Return => [LET_AND_RETURN, NEEDLESS_RETURN, NEEDLESS_RETURN_WITH_QUESTION_MARK]);
 
+/// Checks if a return statement is "needed" in the middle of a block, or if it can be removed. This
+/// is the case when the enclosing block expression is coerced to some other type, which only works
+/// because of the never-ness of `return` expressions
+fn stmt_needs_never_type(cx: &LateContext<'_>, stmt_hir_id: HirId) -> bool {
+    cx.tcx
+        .hir()
+        .parent_iter(stmt_hir_id)
+        .find_map(|(_, node)| if let Node::Expr(expr) = node { Some(expr) } else { None })
+        .is_some_and(|e| {
+            cx.typeck_results()
+                .expr_adjustments(e)
+                .iter()
+                .any(|adjust| adjust.target != cx.tcx.types.unit && matches!(adjust.kind, Adjust::NeverToAny))
+        })
+}
+
 impl<'tcx> LateLintPass<'tcx> for Return {
     fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) {
         if !in_external_macro(cx.sess(), stmt.span)
@@ -173,6 +191,7 @@ impl<'tcx> LateLintPass<'tcx> for Return {
             && let [.., final_stmt] = block.stmts
             && final_stmt.hir_id != stmt.hir_id
             && !is_from_proc_macro(cx, expr)
+            && !stmt_needs_never_type(cx, stmt.hir_id)
         {
             span_lint_and_sugg(
                 cx,
diff --git a/tests/ui/needless_return_with_question_mark.fixed b/tests/ui/needless_return_with_question_mark.fixed
index d5932ebcf12..0147c73a94b 100644
--- a/tests/ui/needless_return_with_question_mark.fixed
+++ b/tests/ui/needless_return_with_question_mark.fixed
@@ -5,6 +5,7 @@
     clippy::unit_arg,
     clippy::useless_conversion,
     clippy::diverging_sub_expression,
+    clippy::let_unit_value,
     unused
 )]
 
@@ -59,3 +60,20 @@ fn main() -> Result<(), ()> {
 
     Err(())
 }
+
+fn issue11616() -> Result<(), ()> {
+    let _x: String = {
+        return Err(())?;
+    };
+    let _x: () = {
+        Err(())?;
+        //~^ ERROR: unneeded `return` statement with `?` operator
+    };
+    let _x = match 1 {
+        1 => vec![1, 2],
+        _ => {
+            return Err(())?;
+        },
+    };
+    Ok(())
+}
diff --git a/tests/ui/needless_return_with_question_mark.rs b/tests/ui/needless_return_with_question_mark.rs
index 2485e25f05c..66e1f438f8c 100644
--- a/tests/ui/needless_return_with_question_mark.rs
+++ b/tests/ui/needless_return_with_question_mark.rs
@@ -5,6 +5,7 @@
     clippy::unit_arg,
     clippy::useless_conversion,
     clippy::diverging_sub_expression,
+    clippy::let_unit_value,
     unused
 )]
 
@@ -59,3 +60,20 @@ fn main() -> Result<(), ()> {
 
     Err(())
 }
+
+fn issue11616() -> Result<(), ()> {
+    let _x: String = {
+        return Err(())?;
+    };
+    let _x: () = {
+        return Err(())?;
+        //~^ ERROR: unneeded `return` statement with `?` operator
+    };
+    let _x = match 1 {
+        1 => vec![1, 2],
+        _ => {
+            return Err(())?;
+        },
+    };
+    Ok(())
+}
diff --git a/tests/ui/needless_return_with_question_mark.stderr b/tests/ui/needless_return_with_question_mark.stderr
index 580970a41aa..17aa212ae8d 100644
--- a/tests/ui/needless_return_with_question_mark.stderr
+++ b/tests/ui/needless_return_with_question_mark.stderr
@@ -1,5 +1,5 @@
 error: unneeded `return` statement with `?` operator
-  --> $DIR/needless_return_with_question_mark.rs:28:5
+  --> $DIR/needless_return_with_question_mark.rs:29:5
    |
 LL |     return Err(())?;
    |     ^^^^^^^ help: remove it
@@ -7,5 +7,11 @@ LL |     return Err(())?;
    = note: `-D clippy::needless-return-with-question-mark` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::needless_return_with_question_mark)]`
 
-error: aborting due to previous error
+error: unneeded `return` statement with `?` operator
+  --> $DIR/needless_return_with_question_mark.rs:69:9
+   |
+LL |         return Err(())?;
+   |         ^^^^^^^ help: remove it
+
+error: aborting due to 2 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 43d8d51b6d3e7ed95a425a8bcca6aae0467fff9f Mon Sep 17 00:00:00 2001
From: Nilstrieb <48135649+Nilstrieb@users.noreply.github.com>
Date: Tue, 21 Nov 2023 22:03:00 +0100
Subject: Allow `#[deprecated(since = "TBD")]`

"TBD" is allowed by rustdoc, saying that it will be deprecated in a future version.
rustc will also not actually warn on it.
---
 clippy_lints/src/attrs.rs | 9 +++++----
 tests/ui/attrs.rs         | 3 +++
 2 files changed, 8 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs
index 0a4a0ab9f07..694bc8755a6 100644
--- a/clippy_lints/src/attrs.rs
+++ b/clippy_lints/src/attrs.rs
@@ -120,7 +120,8 @@ declare_clippy_lint! {
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for `#[deprecated]` annotations with a `since`
-    /// field that is not a valid semantic version.
+    /// field that is not a valid semantic version. Also allows "TBD" to signal
+    /// future deprecation.
     ///
     /// ### Why is this bad?
     /// For checking the version of the deprecation, it must be
@@ -479,7 +480,7 @@ impl<'tcx> LateLintPass<'tcx> for Attributes {
                         && let MetaItemKind::NameValue(lit) = &mi.kind
                         && mi.has_name(sym::since)
                     {
-                        check_semver(cx, item.span(), lit);
+                        check_deprecated_since(cx, item.span(), lit);
                     }
                 }
             }
@@ -760,9 +761,9 @@ fn check_attrs(cx: &LateContext<'_>, span: Span, name: Symbol, attrs: &[Attribut
     }
 }
 
-fn check_semver(cx: &LateContext<'_>, span: Span, lit: &MetaItemLit) {
+fn check_deprecated_since(cx: &LateContext<'_>, span: Span, lit: &MetaItemLit) {
     if let LitKind::Str(is, _) = lit.kind {
-        if Version::parse(is.as_str()).is_ok() {
+        if is.as_str() == "TBD" || Version::parse(is.as_str()).is_ok() {
             return;
         }
     }
diff --git a/tests/ui/attrs.rs b/tests/ui/attrs.rs
index 05ee48d17b1..da96eabede1 100644
--- a/tests/ui/attrs.rs
+++ b/tests/ui/attrs.rs
@@ -36,6 +36,9 @@ pub const ANOTHER_CONST: u8 = 23;
 #[deprecated(since = "0.1.1")]
 pub const YET_ANOTHER_CONST: u8 = 0;
 
+#[deprecated(since = "TBD")]
+pub const GONNA_DEPRECATE_THIS_LATER: u8 = 0;
+
 fn main() {
     test_attr_lint();
     if false {
-- 
cgit 1.4.1-3-g733a5


From 91fc4b300111fa32b9fa7169d4b14f8584fbaf11 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Mon, 20 Nov 2023 14:09:02 +0100
Subject: Remove underscore check for `manual_non_exhaustive` lint

---
 clippy_lints/src/manual_non_exhaustive.rs    |  4 ----
 tests/ui/manual_non_exhaustive_enum.rs       |  2 +-
 tests/ui/manual_non_exhaustive_enum.stderr   | 23 ++++++++++++++++++++++-
 tests/ui/manual_non_exhaustive_struct.stderr | 22 +++++++++++++++++++++-
 4 files changed, 44 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_non_exhaustive.rs b/clippy_lints/src/manual_non_exhaustive.rs
index fc8f2363001..fb30e371f59 100644
--- a/clippy_lints/src/manual_non_exhaustive.rs
+++ b/clippy_lints/src/manual_non_exhaustive.rs
@@ -118,7 +118,6 @@ impl EarlyLintPass for ManualNonExhaustiveStruct {
             if let Some(Ok(field)) = iter.next()
                 && iter.next().is_none()
                 && field.ty.kind.is_unit()
-                && field.ident.map_or(true, |name| name.as_str().starts_with('_'))
             {
                 span_lint_and_then(
                     cx,
@@ -158,7 +157,6 @@ impl<'tcx> LateLintPass<'tcx> for ManualNonExhaustiveEnum {
         {
             let mut iter = def.variants.iter().filter_map(|v| {
                 (matches!(v.data, hir::VariantData::Unit(_, _))
-                    && v.ident.as_str().starts_with('_')
                     && is_doc_hidden(cx.tcx.hir().attrs(v.hir_id))
                     && !attr::contains_name(cx.tcx.hir().attrs(item.hir_id()), sym::non_exhaustive))
                 .then_some((v.def_id, v.span))
@@ -173,9 +171,7 @@ impl<'tcx> LateLintPass<'tcx> for ManualNonExhaustiveEnum {
 
     fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
         if let ExprKind::Path(QPath::Resolved(None, p)) = &e.kind
-            && let [.., name] = p.segments
             && let Res::Def(DefKind::Ctor(CtorOf::Variant, CtorKind::Const), id) = p.res
-            && name.ident.as_str().starts_with('_')
         {
             let variant_id = cx.tcx.parent(id);
             let enum_id = cx.tcx.parent(variant_id);
diff --git a/tests/ui/manual_non_exhaustive_enum.rs b/tests/ui/manual_non_exhaustive_enum.rs
index e32ba863176..eb387532031 100644
--- a/tests/ui/manual_non_exhaustive_enum.rs
+++ b/tests/ui/manual_non_exhaustive_enum.rs
@@ -26,7 +26,7 @@ enum NoDocHidden {
     _C,
 }
 
-// name of variant with doc hidden does not start with underscore, should be ignored
+// name of variant with doc hidden does not start with underscore
 enum NoUnderscore {
     A,
     B,
diff --git a/tests/ui/manual_non_exhaustive_enum.stderr b/tests/ui/manual_non_exhaustive_enum.stderr
index 7361a4a2cbb..c4b13a577a9 100644
--- a/tests/ui/manual_non_exhaustive_enum.stderr
+++ b/tests/ui/manual_non_exhaustive_enum.stderr
@@ -22,5 +22,26 @@ LL |     _C,
    = note: `-D clippy::manual-non-exhaustive` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::manual_non_exhaustive)]`
 
-error: aborting due to previous error
+error: this seems like a manual implementation of the non-exhaustive pattern
+  --> $DIR/manual_non_exhaustive_enum.rs:30:1
+   |
+LL |   enum NoUnderscore {
+   |   ^----------------
+   |   |
+   |  _help: add the attribute: `#[non_exhaustive] enum NoUnderscore`
+   | |
+LL | |     A,
+LL | |     B,
+LL | |     #[doc(hidden)]
+LL | |     C,
+LL | | }
+   | |_^
+   |
+help: remove this variant
+  --> $DIR/manual_non_exhaustive_enum.rs:34:5
+   |
+LL |     C,
+   |     ^
+
+error: aborting due to 2 previous errors
 
diff --git a/tests/ui/manual_non_exhaustive_struct.stderr b/tests/ui/manual_non_exhaustive_struct.stderr
index 028b8ff7639..0b88b19691e 100644
--- a/tests/ui/manual_non_exhaustive_struct.stderr
+++ b/tests/ui/manual_non_exhaustive_struct.stderr
@@ -38,6 +38,26 @@ help: remove this field
 LL |         _c: (),
    |         ^^^^^^
 
+error: this seems like a manual implementation of the non-exhaustive pattern
+  --> $DIR/manual_non_exhaustive_struct.rs:29:5
+   |
+LL |       struct NoUnderscore {
+   |       ^------------------
+   |       |
+   |  _____help: add the attribute: `#[non_exhaustive] struct NoUnderscore`
+   | |
+LL | |         pub a: i32,
+LL | |         pub b: i32,
+LL | |         c: (),
+LL | |     }
+   | |_____^
+   |
+help: remove this field
+  --> $DIR/manual_non_exhaustive_struct.rs:32:9
+   |
+LL |         c: (),
+   |         ^^^^^
+
 error: this seems like a manual implementation of the non-exhaustive pattern
   --> $DIR/manual_non_exhaustive_struct.rs:56:5
    |
@@ -64,5 +84,5 @@ help: remove this field
 LL |     struct Tp(pub i32, pub i32, ());
    |                                 ^^
 
-error: aborting due to 4 previous errors
+error: aborting due to 5 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 553857bb2b7c4fa79f342d3797f421121d87e9d1 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Thu, 23 Nov 2023 08:48:36 +0100
Subject: check on a per-body level instead of blocks independently

---
 clippy_lints/src/missing_asserts_for_indexing.rs   |  6 +++---
 tests/ui/missing_asserts_for_indexing_unfixable.rs | 22 ++++++++++++++++++++++
 .../missing_asserts_for_indexing_unfixable.stderr  | 21 ++++++++++++++++++++-
 3 files changed, 45 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/missing_asserts_for_indexing.rs b/clippy_lints/src/missing_asserts_for_indexing.rs
index ff2792faf57..5d6dc8d5582 100644
--- a/clippy_lints/src/missing_asserts_for_indexing.rs
+++ b/clippy_lints/src/missing_asserts_for_indexing.rs
@@ -9,7 +9,7 @@ use clippy_utils::{eq_expr_value, hash_expr, higher};
 use rustc_ast::{LitKind, RangeLimits};
 use rustc_data_structures::unhash::UnhashMap;
 use rustc_errors::{Applicability, Diagnostic};
-use rustc_hir::{BinOp, Block, Expr, ExprKind, UnOp};
+use rustc_hir::{BinOp, Block, Body, Expr, ExprKind, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::source_map::Spanned;
@@ -390,10 +390,10 @@ fn report_indexes(cx: &LateContext<'_>, map: &UnhashMap<u64, Vec<IndexEntry<'_>>
 }
 
 impl LateLintPass<'_> for MissingAssertsForIndexing {
-    fn check_block(&mut self, cx: &LateContext<'_>, block: &Block<'_>) {
+    fn check_body(&mut self, cx: &LateContext<'_>, body: &Body<'_>) {
         let mut map = UnhashMap::default();
 
-        for_each_expr(block, |expr| {
+        for_each_expr(body.value, |expr| {
             check_index(cx, expr, &mut map);
             check_assert(cx, expr, &mut map);
             ControlFlow::<!, ()>::Continue(())
diff --git a/tests/ui/missing_asserts_for_indexing_unfixable.rs b/tests/ui/missing_asserts_for_indexing_unfixable.rs
index 4346ed892f2..de53079a476 100644
--- a/tests/ui/missing_asserts_for_indexing_unfixable.rs
+++ b/tests/ui/missing_asserts_for_indexing_unfixable.rs
@@ -46,4 +46,26 @@ fn index_struct_different_fields(f: &Foo<'_>) {
     let _ = f.v[0] + f.v2[1];
 }
 
+fn shadowing() {
+    let x: &[i32] = &[1];
+    assert!(x.len() > 1);
+
+    let x: &[i32] = &[1];
+    let _ = x[0] + x[1];
+    //~^ ERROR: indexing into a slice multiple times without an `assert`
+}
+
+pub fn issue11856(values: &[i32]) -> usize {
+    let mut ascending = Vec::new();
+    for w in values.windows(2) {
+        assert!(w.len() > 1);
+        if w[0] < w[1] {
+            ascending.push((w[0], w[1]));
+        } else {
+            ascending.push((w[1], w[0]));
+        }
+    }
+    ascending.len()
+}
+
 fn main() {}
diff --git a/tests/ui/missing_asserts_for_indexing_unfixable.stderr b/tests/ui/missing_asserts_for_indexing_unfixable.stderr
index 12c9eed5d66..12e05422798 100644
--- a/tests/ui/missing_asserts_for_indexing_unfixable.stderr
+++ b/tests/ui/missing_asserts_for_indexing_unfixable.stderr
@@ -160,5 +160,24 @@ LL |     let _ = f.v[0] + f.v[1];
    |                      ^^^^^^
    = note: asserting the length before indexing will elide bounds checks
 
-error: aborting due to 7 previous errors
+error: indexing into a slice multiple times without an `assert`
+  --> $DIR/missing_asserts_for_indexing_unfixable.rs:54:13
+   |
+LL |     let _ = x[0] + x[1];
+   |             ^^^^^^^^^^^
+   |
+   = help: consider asserting the length before indexing: `assert!(x.len() > 1);`
+note: slice indexed here
+  --> $DIR/missing_asserts_for_indexing_unfixable.rs:54:13
+   |
+LL |     let _ = x[0] + x[1];
+   |             ^^^^
+note: slice indexed here
+  --> $DIR/missing_asserts_for_indexing_unfixable.rs:54:20
+   |
+LL |     let _ = x[0] + x[1];
+   |                    ^^^^
+   = note: asserting the length before indexing will elide bounds checks
+
+error: aborting due to 8 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 2817c5fc14cbf44b07fae0d7fe9cec4c321b4705 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Mon, 20 Nov 2023 14:54:20 +0100
Subject: Extend `result_map_or_into_option` lint to handle
 `Result::map_or_else(|_| None, Some)`

---
 clippy_lints/src/methods/mod.rs                    |  4 ++
 .../src/methods/result_map_or_else_none.rs         | 46 ++++++++++++++++++++++
 2 files changed, 50 insertions(+)
 create mode 100644 clippy_lints/src/methods/result_map_or_else_none.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 82cd3ac0486..71de77acfc1 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -81,6 +81,7 @@ mod read_line_without_trim;
 mod readonly_write_lock;
 mod redundant_as_str;
 mod repeat_once;
+mod result_map_or_else_none;
 mod search_is_some;
 mod seek_from_current;
 mod seek_to_start_instead_of_rewind;
@@ -4335,6 +4336,9 @@ impl Methods {
                     option_map_or_none::check(cx, expr, recv, def, map);
                     manual_ok_or::check(cx, expr, recv, def, map);
                 },
+                ("map_or_else", [def, map]) => {
+                    result_map_or_else_none::check(cx, expr, recv, def, map);
+                },
                 ("next", []) => {
                     if let Some((name2, recv2, args2, _, _)) = method_call(recv) {
                         match (name2, args2) {
diff --git a/clippy_lints/src/methods/result_map_or_else_none.rs b/clippy_lints/src/methods/result_map_or_else_none.rs
new file mode 100644
index 00000000000..b0e3ca367b4
--- /dev/null
+++ b/clippy_lints/src/methods/result_map_or_else_none.rs
@@ -0,0 +1,46 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet;
+use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::{is_res_lang_ctor, path_res, peel_blocks};
+use rustc_errors::Applicability;
+use rustc_hir as hir;
+use rustc_hir::LangItem::{OptionNone, OptionSome};
+use rustc_lint::LateContext;
+use rustc_span::symbol::sym;
+
+use super::RESULT_MAP_OR_INTO_OPTION;
+
+/// lint use of `_.map_or_else(|_| None, Some)` for `Result`s
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx hir::Expr<'_>,
+    recv: &'tcx hir::Expr<'_>,
+    def_arg: &'tcx hir::Expr<'_>,
+    map_arg: &'tcx hir::Expr<'_>,
+) {
+    let is_result = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(recv), sym::Result);
+
+    if !is_result {
+        return;
+    }
+
+    let f_arg_is_some = is_res_lang_ctor(cx, path_res(cx, map_arg), OptionSome);
+
+    if f_arg_is_some
+        && let hir::ExprKind::Closure(&hir::Closure { body, .. }) = def_arg.kind
+        && let body = cx.tcx.hir().body(body)
+        && is_res_lang_ctor(cx, path_res(cx, peel_blocks(body.value)), OptionNone)
+    {
+        let msg = "called `map_or_else(|_| None, Some)` on a `Result` value";
+        let self_snippet = snippet(cx, recv.span, "..");
+        span_lint_and_sugg(
+            cx,
+            RESULT_MAP_OR_INTO_OPTION,
+            expr.span,
+            msg,
+            "try using `ok` instead",
+            format!("{self_snippet}.ok()"),
+            Applicability::MachineApplicable,
+        );
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 6c84b968862ef605eca33ec9770009be5e1f0adf Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Thu, 23 Nov 2023 13:30:36 +0100
Subject: Improve error messages format

---
 clippy_lints/src/methods/map_unwrap_or.rs        |  6 ++--
 clippy_lints/src/methods/option_as_ref_deref.rs  |  5 +---
 clippy_lints/src/methods/option_map_or_none.rs   |  9 ++----
 clippy_lints/src/methods/option_map_unwrap_or.rs |  5 +---
 tests/ui/map_unwrap_or.stderr                    | 30 ++++++++++----------
 tests/ui/map_unwrap_or_fixable.stderr            |  4 +--
 tests/ui/option_as_ref_deref.stderr              | 36 ++++++++++++------------
 tests/ui/option_map_or_none.stderr               | 10 +++----
 tests/ui/result_map_or_into_option.fixed         |  2 +-
 tests/ui/result_map_or_into_option.rs            |  2 +-
 tests/ui/result_map_or_into_option.stderr        |  2 +-
 11 files changed, 50 insertions(+), 61 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/map_unwrap_or.rs b/clippy_lints/src/methods/map_unwrap_or.rs
index cb81b3919bf..52ea584a2c8 100644
--- a/clippy_lints/src/methods/map_unwrap_or.rs
+++ b/clippy_lints/src/methods/map_unwrap_or.rs
@@ -44,11 +44,9 @@ pub(super) fn check<'tcx>(
 
         // lint message
         let msg = if is_option {
-            "called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling \
-            `map_or_else(<g>, <f>)` instead"
+            "called `map(<f>).unwrap_or_else(<g>)` on an `Option` value"
         } else {
-            "called `map(<f>).unwrap_or_else(<g>)` on a `Result` value. This can be done more directly by calling \
-            `.map_or_else(<g>, <f>)` instead"
+            "called `map(<f>).unwrap_or_else(<g>)` on a `Result` value"
         };
         // get snippets for args to map() and unwrap_or_else()
         let map_snippet = snippet(cx, map_arg.span, "..");
diff --git a/clippy_lints/src/methods/option_as_ref_deref.rs b/clippy_lints/src/methods/option_as_ref_deref.rs
index 15111006133..756dbe62d84 100644
--- a/clippy_lints/src/methods/option_as_ref_deref.rs
+++ b/clippy_lints/src/methods/option_as_ref_deref.rs
@@ -99,10 +99,7 @@ pub(super) fn check(
         let hint = format!("{}.{method_hint}()", snippet(cx, as_ref_recv.span, ".."));
         let suggestion = format!("try using {method_hint} instead");
 
-        let msg = format!(
-            "called `{current_method}` on an Option value. This can be done more directly \
-            by calling `{hint}` instead"
-        );
+        let msg = format!("called `{current_method}` on an `Option` value");
         span_lint_and_sugg(
             cx,
             OPTION_AS_REF_DEREF,
diff --git a/clippy_lints/src/methods/option_map_or_none.rs b/clippy_lints/src/methods/option_map_or_none.rs
index 418e6a7d6a0..ff4d8cc9e3e 100644
--- a/clippy_lints/src/methods/option_map_or_none.rs
+++ b/clippy_lints/src/methods/option_map_or_none.rs
@@ -66,8 +66,7 @@ pub(super) fn check<'tcx>(
             && Some(id) == cx.tcx.lang_items().option_some_variant()
         {
             let func_snippet = snippet(cx, arg_char.span, "..");
-            let msg = "called `map_or(None, ..)` on an `Option` value. This can be done more directly by calling \
-               `map(..)` instead";
+            let msg = "called `map_or(None, ..)` on an `Option` value";
             return span_lint_and_sugg(
                 cx,
                 OPTION_MAP_OR_NONE,
@@ -80,8 +79,7 @@ pub(super) fn check<'tcx>(
         }
 
         let func_snippet = snippet(cx, map_arg.span, "..");
-        let msg = "called `map_or(None, ..)` on an `Option` value. This can be done more directly by calling \
-                       `and_then(..)` instead";
+        let msg = "called `map_or(None, ..)` on an `Option` value";
         span_lint_and_sugg(
             cx,
             OPTION_MAP_OR_NONE,
@@ -92,8 +90,7 @@ pub(super) fn check<'tcx>(
             Applicability::MachineApplicable,
         );
     } else if f_arg_is_some {
-        let msg = "called `map_or(None, Some)` on a `Result` value. This can be done more directly by calling \
-                       `ok()` instead";
+        let msg = "called `map_or(None, Some)` on a `Result` value";
         let self_snippet = snippet(cx, recv.span, "..");
         span_lint_and_sugg(
             cx,
diff --git a/clippy_lints/src/methods/option_map_unwrap_or.rs b/clippy_lints/src/methods/option_map_unwrap_or.rs
index c78f8b71c78..575c2d8f157 100644
--- a/clippy_lints/src/methods/option_map_unwrap_or.rs
+++ b/clippy_lints/src/methods/option_map_unwrap_or.rs
@@ -97,10 +97,7 @@ pub(super) fn check<'tcx>(
         } else {
             "map_or(<a>, <f>)"
         };
-        let msg = &format!(
-            "called `map(<f>).unwrap_or({arg})` on an `Option` value. \
-            This can be done more directly by calling `{suggest}` instead"
-        );
+        let msg = &format!("called `map(<f>).unwrap_or({arg})` on an `Option` value");
 
         span_lint_and_then(cx, MAP_UNWRAP_OR, expr.span, msg, |diag| {
             let map_arg_span = map_arg.span;
diff --git a/tests/ui/map_unwrap_or.stderr b/tests/ui/map_unwrap_or.stderr
index 7b7eeb322a5..54ddd1402e3 100644
--- a/tests/ui/map_unwrap_or.stderr
+++ b/tests/ui/map_unwrap_or.stderr
@@ -1,4 +1,4 @@
-error: called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead
+error: called `map(<f>).unwrap_or(<a>)` on an `Option` value
   --> $DIR/map_unwrap_or.rs:17:13
    |
 LL |       let _ = opt.map(|x| x + 1)
@@ -15,7 +15,7 @@ LL -     let _ = opt.map(|x| x + 1)
 LL +     let _ = opt.map_or(0, |x| x + 1);
    |
 
-error: called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead
+error: called `map(<f>).unwrap_or(<a>)` on an `Option` value
   --> $DIR/map_unwrap_or.rs:21:13
    |
 LL |       let _ = opt.map(|x| {
@@ -33,7 +33,7 @@ LL |     }
 LL ~     );
    |
 
-error: called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead
+error: called `map(<f>).unwrap_or(<a>)` on an `Option` value
   --> $DIR/map_unwrap_or.rs:25:13
    |
 LL |       let _ = opt.map(|x| x + 1)
@@ -50,7 +50,7 @@ LL +             0
 LL ~         }, |x| x + 1);
    |
 
-error: called `map(<f>).unwrap_or(None)` on an `Option` value. This can be done more directly by calling `and_then(<f>)` instead
+error: called `map(<f>).unwrap_or(None)` on an `Option` value
   --> $DIR/map_unwrap_or.rs:30:13
    |
 LL |     let _ = opt.map(|x| Some(x + 1)).unwrap_or(None);
@@ -62,7 +62,7 @@ LL -     let _ = opt.map(|x| Some(x + 1)).unwrap_or(None);
 LL +     let _ = opt.and_then(|x| Some(x + 1));
    |
 
-error: called `map(<f>).unwrap_or(None)` on an `Option` value. This can be done more directly by calling `and_then(<f>)` instead
+error: called `map(<f>).unwrap_or(None)` on an `Option` value
   --> $DIR/map_unwrap_or.rs:32:13
    |
 LL |       let _ = opt.map(|x| {
@@ -80,7 +80,7 @@ LL |     }
 LL ~     );
    |
 
-error: called `map(<f>).unwrap_or(None)` on an `Option` value. This can be done more directly by calling `and_then(<f>)` instead
+error: called `map(<f>).unwrap_or(None)` on an `Option` value
   --> $DIR/map_unwrap_or.rs:36:13
    |
 LL |       let _ = opt
@@ -95,7 +95,7 @@ LL -         .map(|x| Some(x + 1))
 LL +         .and_then(|x| Some(x + 1));
    |
 
-error: called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead
+error: called `map(<f>).unwrap_or(<a>)` on an `Option` value
   --> $DIR/map_unwrap_or.rs:47:13
    |
 LL |     let _ = Some("prefix").map(|p| format!("{}.", p)).unwrap_or(id);
@@ -107,7 +107,7 @@ LL -     let _ = Some("prefix").map(|p| format!("{}.", p)).unwrap_or(id);
 LL +     let _ = Some("prefix").map_or(id, |p| format!("{}.", p));
    |
 
-error: called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling `map_or_else(<g>, <f>)` instead
+error: called `map(<f>).unwrap_or_else(<g>)` on an `Option` value
   --> $DIR/map_unwrap_or.rs:51:13
    |
 LL |       let _ = opt.map(|x| {
@@ -117,7 +117,7 @@ LL | |     }
 LL | |     ).unwrap_or_else(|| 0);
    | |__________________________^
 
-error: called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling `map_or_else(<g>, <f>)` instead
+error: called `map(<f>).unwrap_or_else(<g>)` on an `Option` value
   --> $DIR/map_unwrap_or.rs:55:13
    |
 LL |       let _ = opt.map(|x| x + 1)
@@ -127,7 +127,7 @@ LL | |             0
 LL | |         );
    | |_________^
 
-error: called `map(<f>).unwrap_or(false)` on an `Option` value. This can be done more directly by calling `is_some_and(<f>)` instead
+error: called `map(<f>).unwrap_or(false)` on an `Option` value
   --> $DIR/map_unwrap_or.rs:61:13
    |
 LL |     let _ = opt.map(|x| x > 5).unwrap_or(false);
@@ -139,7 +139,7 @@ LL -     let _ = opt.map(|x| x > 5).unwrap_or(false);
 LL +     let _ = opt.is_some_and(|x| x > 5);
    |
 
-error: called `map(<f>).unwrap_or_else(<g>)` on a `Result` value. This can be done more directly by calling `.map_or_else(<g>, <f>)` instead
+error: called `map(<f>).unwrap_or_else(<g>)` on a `Result` value
   --> $DIR/map_unwrap_or.rs:71:13
    |
 LL |       let _ = res.map(|x| {
@@ -149,7 +149,7 @@ LL | |     }
 LL | |     ).unwrap_or_else(|_e| 0);
    | |____________________________^
 
-error: called `map(<f>).unwrap_or_else(<g>)` on a `Result` value. This can be done more directly by calling `.map_or_else(<g>, <f>)` instead
+error: called `map(<f>).unwrap_or_else(<g>)` on a `Result` value
   --> $DIR/map_unwrap_or.rs:75:13
    |
 LL |       let _ = res.map(|x| x + 1)
@@ -159,13 +159,13 @@ LL | |             0
 LL | |         });
    | |__________^
 
-error: called `map(<f>).unwrap_or_else(<g>)` on a `Result` value. This can be done more directly by calling `.map_or_else(<g>, <f>)` instead
+error: called `map(<f>).unwrap_or_else(<g>)` on a `Result` value
   --> $DIR/map_unwrap_or.rs:99:13
    |
 LL |     let _ = res.map(|x| x + 1).unwrap_or_else(|_e| 0);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `res.map_or_else(|_e| 0, |x| x + 1)`
 
-error: called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead
+error: called `map(<f>).unwrap_or(<a>)` on an `Option` value
   --> $DIR/map_unwrap_or.rs:106:13
    |
 LL |     let _ = opt.map(|x| x > 5).unwrap_or(false);
@@ -177,7 +177,7 @@ LL -     let _ = opt.map(|x| x > 5).unwrap_or(false);
 LL +     let _ = opt.map_or(false, |x| x > 5);
    |
 
-error: called `map(<f>).unwrap_or(false)` on an `Option` value. This can be done more directly by calling `is_some_and(<f>)` instead
+error: called `map(<f>).unwrap_or(false)` on an `Option` value
   --> $DIR/map_unwrap_or.rs:113:13
    |
 LL |     let _ = opt.map(|x| x > 5).unwrap_or(false);
diff --git a/tests/ui/map_unwrap_or_fixable.stderr b/tests/ui/map_unwrap_or_fixable.stderr
index ca611ac9d7f..d1a9fdd6ecf 100644
--- a/tests/ui/map_unwrap_or_fixable.stderr
+++ b/tests/ui/map_unwrap_or_fixable.stderr
@@ -1,4 +1,4 @@
-error: called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling `map_or_else(<g>, <f>)` instead
+error: called `map(<f>).unwrap_or_else(<g>)` on an `Option` value
   --> $DIR/map_unwrap_or_fixable.rs:16:13
    |
 LL |       let _ = opt.map(|x| x + 1)
@@ -10,7 +10,7 @@ LL | |         .unwrap_or_else(|| 0);
    = note: `-D clippy::map-unwrap-or` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::map_unwrap_or)]`
 
-error: called `map(<f>).unwrap_or_else(<g>)` on a `Result` value. This can be done more directly by calling `.map_or_else(<g>, <f>)` instead
+error: called `map(<f>).unwrap_or_else(<g>)` on a `Result` value
   --> $DIR/map_unwrap_or_fixable.rs:46:13
    |
 LL |       let _ = res.map(|x| x + 1)
diff --git a/tests/ui/option_as_ref_deref.stderr b/tests/ui/option_as_ref_deref.stderr
index eb0661c523a..9d173e409ab 100644
--- a/tests/ui/option_as_ref_deref.stderr
+++ b/tests/ui/option_as_ref_deref.stderr
@@ -1,4 +1,4 @@
-error: called `.as_ref().map(Deref::deref)` on an Option value. This can be done more directly by calling `opt.clone().as_deref()` instead
+error: called `.as_ref().map(Deref::deref)` on an `Option` value
   --> $DIR/option_as_ref_deref.rs:11:13
    |
 LL |     let _ = opt.clone().as_ref().map(Deref::deref).map(str::len);
@@ -7,7 +7,7 @@ LL |     let _ = opt.clone().as_ref().map(Deref::deref).map(str::len);
    = note: `-D clippy::option-as-ref-deref` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::option_as_ref_deref)]`
 
-error: called `.as_ref().map(Deref::deref)` on an Option value. This can be done more directly by calling `opt.clone().as_deref()` instead
+error: called `.as_ref().map(Deref::deref)` on an `Option` value
   --> $DIR/option_as_ref_deref.rs:14:13
    |
 LL |       let _ = opt.clone()
@@ -17,97 +17,97 @@ LL | |             Deref::deref
 LL | |         )
    | |_________^ help: try using as_deref instead: `opt.clone().as_deref()`
 
-error: called `.as_mut().map(DerefMut::deref_mut)` on an Option value. This can be done more directly by calling `opt.as_deref_mut()` instead
+error: called `.as_mut().map(DerefMut::deref_mut)` on an `Option` value
   --> $DIR/option_as_ref_deref.rs:20:13
    |
 LL |     let _ = opt.as_mut().map(DerefMut::deref_mut);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try using as_deref_mut instead: `opt.as_deref_mut()`
 
-error: called `.as_ref().map(String::as_str)` on an Option value. This can be done more directly by calling `opt.as_deref()` instead
+error: called `.as_ref().map(String::as_str)` on an `Option` value
   --> $DIR/option_as_ref_deref.rs:22:13
    |
 LL |     let _ = opt.as_ref().map(String::as_str);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try using as_deref instead: `opt.as_deref()`
 
-error: called `.as_ref().map(|x| x.as_str())` on an Option value. This can be done more directly by calling `opt.as_deref()` instead
+error: called `.as_ref().map(|x| x.as_str())` on an `Option` value
   --> $DIR/option_as_ref_deref.rs:23:13
    |
 LL |     let _ = opt.as_ref().map(|x| x.as_str());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try using as_deref instead: `opt.as_deref()`
 
-error: called `.as_mut().map(String::as_mut_str)` on an Option value. This can be done more directly by calling `opt.as_deref_mut()` instead
+error: called `.as_mut().map(String::as_mut_str)` on an `Option` value
   --> $DIR/option_as_ref_deref.rs:24:13
    |
 LL |     let _ = opt.as_mut().map(String::as_mut_str);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try using as_deref_mut instead: `opt.as_deref_mut()`
 
-error: called `.as_mut().map(|x| x.as_mut_str())` on an Option value. This can be done more directly by calling `opt.as_deref_mut()` instead
+error: called `.as_mut().map(|x| x.as_mut_str())` on an `Option` value
   --> $DIR/option_as_ref_deref.rs:25:13
    |
 LL |     let _ = opt.as_mut().map(|x| x.as_mut_str());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try using as_deref_mut instead: `opt.as_deref_mut()`
 
-error: called `.as_ref().map(CString::as_c_str)` on an Option value. This can be done more directly by calling `Some(CString::new(vec![]).unwrap()).as_deref()` instead
+error: called `.as_ref().map(CString::as_c_str)` on an `Option` value
   --> $DIR/option_as_ref_deref.rs:26:13
    |
 LL |     let _ = Some(CString::new(vec![]).unwrap()).as_ref().map(CString::as_c_str);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try using as_deref instead: `Some(CString::new(vec![]).unwrap()).as_deref()`
 
-error: called `.as_ref().map(OsString::as_os_str)` on an Option value. This can be done more directly by calling `Some(OsString::new()).as_deref()` instead
+error: called `.as_ref().map(OsString::as_os_str)` on an `Option` value
   --> $DIR/option_as_ref_deref.rs:27:13
    |
 LL |     let _ = Some(OsString::new()).as_ref().map(OsString::as_os_str);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try using as_deref instead: `Some(OsString::new()).as_deref()`
 
-error: called `.as_ref().map(PathBuf::as_path)` on an Option value. This can be done more directly by calling `Some(PathBuf::new()).as_deref()` instead
+error: called `.as_ref().map(PathBuf::as_path)` on an `Option` value
   --> $DIR/option_as_ref_deref.rs:28:13
    |
 LL |     let _ = Some(PathBuf::new()).as_ref().map(PathBuf::as_path);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try using as_deref instead: `Some(PathBuf::new()).as_deref()`
 
-error: called `.as_ref().map(Vec::as_slice)` on an Option value. This can be done more directly by calling `Some(Vec::<()>::new()).as_deref()` instead
+error: called `.as_ref().map(Vec::as_slice)` on an `Option` value
   --> $DIR/option_as_ref_deref.rs:29:13
    |
 LL |     let _ = Some(Vec::<()>::new()).as_ref().map(Vec::as_slice);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try using as_deref instead: `Some(Vec::<()>::new()).as_deref()`
 
-error: called `.as_mut().map(Vec::as_mut_slice)` on an Option value. This can be done more directly by calling `Some(Vec::<()>::new()).as_deref_mut()` instead
+error: called `.as_mut().map(Vec::as_mut_slice)` on an `Option` value
   --> $DIR/option_as_ref_deref.rs:30:13
    |
 LL |     let _ = Some(Vec::<()>::new()).as_mut().map(Vec::as_mut_slice);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try using as_deref_mut instead: `Some(Vec::<()>::new()).as_deref_mut()`
 
-error: called `.as_ref().map(|x| x.deref())` on an Option value. This can be done more directly by calling `opt.as_deref()` instead
+error: called `.as_ref().map(|x| x.deref())` on an `Option` value
   --> $DIR/option_as_ref_deref.rs:32:13
    |
 LL |     let _ = opt.as_ref().map(|x| x.deref());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try using as_deref instead: `opt.as_deref()`
 
-error: called `.as_mut().map(|x| x.deref_mut())` on an Option value. This can be done more directly by calling `opt.clone().as_deref_mut()` instead
+error: called `.as_mut().map(|x| x.deref_mut())` on an `Option` value
   --> $DIR/option_as_ref_deref.rs:33:13
    |
 LL |     let _ = opt.clone().as_mut().map(|x| x.deref_mut()).map(|x| x.len());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try using as_deref_mut instead: `opt.clone().as_deref_mut()`
 
-error: called `.as_ref().map(|x| &**x)` on an Option value. This can be done more directly by calling `opt.as_deref()` instead
+error: called `.as_ref().map(|x| &**x)` on an `Option` value
   --> $DIR/option_as_ref_deref.rs:40:13
    |
 LL |     let _ = opt.as_ref().map(|x| &**x);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try using as_deref instead: `opt.as_deref()`
 
-error: called `.as_mut().map(|x| &mut **x)` on an Option value. This can be done more directly by calling `opt.as_deref_mut()` instead
+error: called `.as_mut().map(|x| &mut **x)` on an `Option` value
   --> $DIR/option_as_ref_deref.rs:41:13
    |
 LL |     let _ = opt.as_mut().map(|x| &mut **x);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try using as_deref_mut instead: `opt.as_deref_mut()`
 
-error: called `.as_ref().map(std::ops::Deref::deref)` on an Option value. This can be done more directly by calling `opt.as_deref()` instead
+error: called `.as_ref().map(std::ops::Deref::deref)` on an `Option` value
   --> $DIR/option_as_ref_deref.rs:44:13
    |
 LL |     let _ = opt.as_ref().map(std::ops::Deref::deref);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try using as_deref instead: `opt.as_deref()`
 
-error: called `.as_ref().map(String::as_str)` on an Option value. This can be done more directly by calling `opt.as_deref()` instead
+error: called `.as_ref().map(String::as_str)` on an `Option` value
   --> $DIR/option_as_ref_deref.rs:56:13
    |
 LL |     let _ = opt.as_ref().map(String::as_str);
diff --git a/tests/ui/option_map_or_none.stderr b/tests/ui/option_map_or_none.stderr
index fa150718f89..f2cfc3f9a28 100644
--- a/tests/ui/option_map_or_none.stderr
+++ b/tests/ui/option_map_or_none.stderr
@@ -1,4 +1,4 @@
-error: called `map_or(None, ..)` on an `Option` value. This can be done more directly by calling `map(..)` instead
+error: called `map_or(None, ..)` on an `Option` value
   --> $DIR/option_map_or_none.rs:10:26
    |
 LL |     let _: Option<i32> = opt.map_or(None, |x| Some(x + 1));
@@ -7,7 +7,7 @@ LL |     let _: Option<i32> = opt.map_or(None, |x| Some(x + 1));
    = note: `-D clippy::option-map-or-none` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::option_map_or_none)]`
 
-error: called `map_or(None, ..)` on an `Option` value. This can be done more directly by calling `map(..)` instead
+error: called `map_or(None, ..)` on an `Option` value
   --> $DIR/option_map_or_none.rs:13:26
    |
 LL |       let _: Option<i32> = opt.map_or(None, |x| {
@@ -16,13 +16,13 @@ LL | |                         Some(x + 1)
 LL | |                        });
    | |_________________________^ help: try using `map` instead: `opt.map(|x| x + 1)`
 
-error: called `map_or(None, ..)` on an `Option` value. This can be done more directly by calling `and_then(..)` instead
+error: called `map_or(None, ..)` on an `Option` value
   --> $DIR/option_map_or_none.rs:17:26
    |
 LL |     let _: Option<i32> = opt.map_or(None, bar);
    |                          ^^^^^^^^^^^^^^^^^^^^^ help: try using `and_then` instead: `opt.and_then(bar)`
 
-error: called `map_or(None, ..)` on an `Option` value. This can be done more directly by calling `and_then(..)` instead
+error: called `map_or(None, ..)` on an `Option` value
   --> $DIR/option_map_or_none.rs:18:26
    |
 LL |       let _: Option<i32> = opt.map_or(None, |x| {
@@ -42,7 +42,7 @@ LL +         Some(offset + height)
 LL ~     });
    |
 
-error: called `map_or(None, Some)` on a `Result` value. This can be done more directly by calling `ok()` instead
+error: called `map_or(None, Some)` on a `Result` value
   --> $DIR/option_map_or_none.rs:25:26
    |
 LL |     let _: Option<i32> = r.map_or(None, Some);
diff --git a/tests/ui/result_map_or_into_option.fixed b/tests/ui/result_map_or_into_option.fixed
index 8c1b2041ff8..cf42b24b2dd 100644
--- a/tests/ui/result_map_or_into_option.fixed
+++ b/tests/ui/result_map_or_into_option.fixed
@@ -3,7 +3,7 @@
 fn main() {
     let opt: Result<u32, &str> = Ok(1);
     let _ = opt.ok();
-    //~^ ERROR: called `map_or(None, Some)` on a `Result` value.
+    //~^ ERROR: called `map_or(None, Some)` on a `Result` value
     let _ = opt.ok();
     //~^ ERROR: called `map_or_else(|_| None, Some)` on a `Result` value
     #[rustfmt::skip]
diff --git a/tests/ui/result_map_or_into_option.rs b/tests/ui/result_map_or_into_option.rs
index 17bbed02fa4..cdb45d6b82a 100644
--- a/tests/ui/result_map_or_into_option.rs
+++ b/tests/ui/result_map_or_into_option.rs
@@ -3,7 +3,7 @@
 fn main() {
     let opt: Result<u32, &str> = Ok(1);
     let _ = opt.map_or(None, Some);
-    //~^ ERROR: called `map_or(None, Some)` on a `Result` value.
+    //~^ ERROR: called `map_or(None, Some)` on a `Result` value
     let _ = opt.map_or_else(|_| None, Some);
     //~^ ERROR: called `map_or_else(|_| None, Some)` on a `Result` value
     #[rustfmt::skip]
diff --git a/tests/ui/result_map_or_into_option.stderr b/tests/ui/result_map_or_into_option.stderr
index b0fc4a1fbca..3d6bfef48ec 100644
--- a/tests/ui/result_map_or_into_option.stderr
+++ b/tests/ui/result_map_or_into_option.stderr
@@ -1,4 +1,4 @@
-error: called `map_or(None, Some)` on a `Result` value. This can be done more directly by calling `ok()` instead
+error: called `map_or(None, Some)` on a `Result` value
   --> $DIR/result_map_or_into_option.rs:5:13
    |
 LL |     let _ = opt.map_or(None, Some);
-- 
cgit 1.4.1-3-g733a5


From 447edf92b4dfc96263665972c59b706c966a8833 Mon Sep 17 00:00:00 2001
From: Christoph Beberweil <christoph.beberweil@protonmail.com>
Date: Thu, 23 Nov 2023 23:07:36 +0100
Subject: suggest alternatives to iterate an array of ranges

Co-authored-by: ThinkerDreamer <74881094+ThinkerDreamer@users.noreply.github.com>
---
 clippy_lints/src/loops/single_element_loop.rs | 33 ++++++++----
 tests/ui/single_element_loop.fixed            | 12 ++---
 tests/ui/single_element_loop.stderr           | 72 ++++++---------------------
 3 files changed, 43 insertions(+), 74 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/single_element_loop.rs b/clippy_lints/src/loops/single_element_loop.rs
index d860b297a02..7164bf06b8d 100644
--- a/clippy_lints/src/loops/single_element_loop.rs
+++ b/clippy_lints/src/loops/single_element_loop.rs
@@ -1,6 +1,6 @@
 use super::SINGLE_ELEMENT_LOOP;
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::source::{indent_of, snippet_with_applicability};
+use clippy_utils::source::{indent_of, snippet, snippet_with_applicability};
 use clippy_utils::visitors::contains_break_or_continue;
 use rustc_ast::util::parser::PREC_PREFIX;
 use rustc_ast::Mutability;
@@ -87,14 +87,27 @@ pub(super) fn check<'tcx>(
             arg_snip = format!("({arg_snip})").into();
         }
 
-        span_lint_and_sugg(
-            cx,
-            SINGLE_ELEMENT_LOOP,
-            expr.span,
-            "for loop over a single element",
-            "try",
-            format!("{{\n{indent}let {pat_snip} = {prefix}{arg_snip};{block_str}}}"),
-            applicability,
-        );
+        if clippy_utils::higher::Range::hir(arg_expression).is_some() {
+            let sugg = snippet(cx, arg_expression.span, "..");
+            span_lint_and_sugg(
+                cx,
+                SINGLE_ELEMENT_LOOP,
+                arg.span,
+                "for loop over a single range inside an array, rather than iterating over the elements in the range directly",
+                "did you mean to iterate over the range instead?",
+                sugg.to_string(),
+                applicability,
+            );
+        } else {
+            span_lint_and_sugg(
+                cx,
+                SINGLE_ELEMENT_LOOP,
+                expr.span,
+                "for loop over a single element",
+                "try",
+                format!("{{\n{indent}let {pat_snip} = {prefix}{arg_snip};{block_str}}}"),
+                applicability,
+            );
+        }
     }
 }
diff --git a/tests/ui/single_element_loop.fixed b/tests/ui/single_element_loop.fixed
index a82eb6afcf5..4e59c763198 100644
--- a/tests/ui/single_element_loop.fixed
+++ b/tests/ui/single_element_loop.fixed
@@ -15,23 +15,19 @@ fn main() {
         dbg!(item);
     }
 
-    {
-        let item = &(0..5);
+    for item in 0..5 {
         dbg!(item);
     }
 
-    {
-        let item = &mut (0..5);
+    for item in 0..5 {
         dbg!(item);
     }
 
-    {
-        let item = 0..5;
+    for item in 0..5 {
         dbg!(item);
     }
 
-    {
-        let item = 0..5;
+    for item in 0..5 {
         dbg!(item);
     }
 
diff --git a/tests/ui/single_element_loop.stderr b/tests/ui/single_element_loop.stderr
index 603dd7406e4..3937bd95743 100644
--- a/tests/ui/single_element_loop.stderr
+++ b/tests/ui/single_element_loop.stderr
@@ -32,69 +32,29 @@ LL +         dbg!(item);
 LL +     }
    |
 
-error: for loop over a single element
-  --> $DIR/single_element_loop.rs:16:5
-   |
-LL | /     for item in &[0..5] {
-LL | |         dbg!(item);
-LL | |     }
-   | |_____^
-   |
-help: try
-   |
-LL ~     {
-LL +         let item = &(0..5);
-LL +         dbg!(item);
-LL +     }
+error: for loop over a single range inside an array, rather than iterating over the elements in the range directly
+  --> $DIR/single_element_loop.rs:16:17
    |
+LL |     for item in &[0..5] {
+   |                 ^^^^^^^ help: did you mean to iterate over the range instead?: `0..5`
 
-error: for loop over a single element
-  --> $DIR/single_element_loop.rs:20:5
-   |
-LL | /     for item in [0..5].iter_mut() {
-LL | |         dbg!(item);
-LL | |     }
-   | |_____^
-   |
-help: try
-   |
-LL ~     {
-LL +         let item = &mut (0..5);
-LL +         dbg!(item);
-LL +     }
+error: for loop over a single range inside an array, rather than iterating over the elements in the range directly
+  --> $DIR/single_element_loop.rs:20:17
    |
+LL |     for item in [0..5].iter_mut() {
+   |                 ^^^^^^^^^^^^^^^^^ help: did you mean to iterate over the range instead?: `0..5`
 
-error: for loop over a single element
-  --> $DIR/single_element_loop.rs:24:5
-   |
-LL | /     for item in [0..5] {
-LL | |         dbg!(item);
-LL | |     }
-   | |_____^
-   |
-help: try
-   |
-LL ~     {
-LL +         let item = 0..5;
-LL +         dbg!(item);
-LL +     }
+error: for loop over a single range inside an array, rather than iterating over the elements in the range directly
+  --> $DIR/single_element_loop.rs:24:17
    |
+LL |     for item in [0..5] {
+   |                 ^^^^^^ help: did you mean to iterate over the range instead?: `0..5`
 
-error: for loop over a single element
-  --> $DIR/single_element_loop.rs:28:5
-   |
-LL | /     for item in [0..5].into_iter() {
-LL | |         dbg!(item);
-LL | |     }
-   | |_____^
-   |
-help: try
-   |
-LL ~     {
-LL +         let item = 0..5;
-LL +         dbg!(item);
-LL +     }
+error: for loop over a single range inside an array, rather than iterating over the elements in the range directly
+  --> $DIR/single_element_loop.rs:28:17
    |
+LL |     for item in [0..5].into_iter() {
+   |                 ^^^^^^^^^^^^^^^^^^ help: did you mean to iterate over the range instead?: `0..5`
 
 error: for loop over a single element
   --> $DIR/single_element_loop.rs:47:5
-- 
cgit 1.4.1-3-g733a5


From c58d692e1ff39b0bdffacb907510663f26bbd7e1 Mon Sep 17 00:00:00 2001
From: Christoph Beberweil <christoph.beberweil@protonmail.com>
Date: Fri, 24 Nov 2023 10:30:19 +0100
Subject: fix: 7125 update lint applicability to Unspecified

---
 clippy_lints/src/loops/single_element_loop.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/single_element_loop.rs b/clippy_lints/src/loops/single_element_loop.rs
index 7164bf06b8d..5740da528c2 100644
--- a/clippy_lints/src/loops/single_element_loop.rs
+++ b/clippy_lints/src/loops/single_element_loop.rs
@@ -96,7 +96,7 @@ pub(super) fn check<'tcx>(
                 "for loop over a single range inside an array, rather than iterating over the elements in the range directly",
                 "did you mean to iterate over the range instead?",
                 sugg.to_string(),
-                applicability,
+                Applicability::Unspecified,
             );
         } else {
             span_lint_and_sugg(
-- 
cgit 1.4.1-3-g733a5


From 2512341fe45f62c5e1e5aea0d70a0430b73e639b Mon Sep 17 00:00:00 2001
From: Christoph Beberweil <christoph.beberweil@protonmail.com>
Date: Fri, 24 Nov 2023 10:38:45 +0100
Subject: feat: 7125 shorten lint text

---
 clippy_lints/src/loops/single_element_loop.rs | 4 +++-
 tests/ui/single_element_loop.stderr           | 8 ++++----
 2 files changed, 7 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/single_element_loop.rs b/clippy_lints/src/loops/single_element_loop.rs
index 5740da528c2..b3db88bd098 100644
--- a/clippy_lints/src/loops/single_element_loop.rs
+++ b/clippy_lints/src/loops/single_element_loop.rs
@@ -88,12 +88,14 @@ pub(super) fn check<'tcx>(
         }
 
         if clippy_utils::higher::Range::hir(arg_expression).is_some() {
+            let range_expr = snippet(cx, arg_expression.span, "?").to_string();
+
             let sugg = snippet(cx, arg_expression.span, "..");
             span_lint_and_sugg(
                 cx,
                 SINGLE_ELEMENT_LOOP,
                 arg.span,
-                "for loop over a single range inside an array, rather than iterating over the elements in the range directly",
+                format!("This loops only once with {pat_snip} being {range_expr}").as_str(),
                 "did you mean to iterate over the range instead?",
                 sugg.to_string(),
                 Applicability::Unspecified,
diff --git a/tests/ui/single_element_loop.stderr b/tests/ui/single_element_loop.stderr
index 3937bd95743..6d2a89a706a 100644
--- a/tests/ui/single_element_loop.stderr
+++ b/tests/ui/single_element_loop.stderr
@@ -32,25 +32,25 @@ LL +         dbg!(item);
 LL +     }
    |
 
-error: for loop over a single range inside an array, rather than iterating over the elements in the range directly
+error: This loops only once with item being 0..5
   --> $DIR/single_element_loop.rs:16:17
    |
 LL |     for item in &[0..5] {
    |                 ^^^^^^^ help: did you mean to iterate over the range instead?: `0..5`
 
-error: for loop over a single range inside an array, rather than iterating over the elements in the range directly
+error: This loops only once with item being 0..5
   --> $DIR/single_element_loop.rs:20:17
    |
 LL |     for item in [0..5].iter_mut() {
    |                 ^^^^^^^^^^^^^^^^^ help: did you mean to iterate over the range instead?: `0..5`
 
-error: for loop over a single range inside an array, rather than iterating over the elements in the range directly
+error: This loops only once with item being 0..5
   --> $DIR/single_element_loop.rs:24:17
    |
 LL |     for item in [0..5] {
    |                 ^^^^^^ help: did you mean to iterate over the range instead?: `0..5`
 
-error: for loop over a single range inside an array, rather than iterating over the elements in the range directly
+error: This loops only once with item being 0..5
   --> $DIR/single_element_loop.rs:28:17
    |
 LL |     for item in [0..5].into_iter() {
-- 
cgit 1.4.1-3-g733a5


From 4937fba456dd0e8fe4f1e5de35da3b2779eea031 Mon Sep 17 00:00:00 2001
From: Samuel Moelius <35515885+smoelius@users.noreply.github.com>
Date: Fri, 24 Nov 2023 07:10:28 -0500
Subject: Nit re `matches!` formatting

---
 clippy_lints/src/eta_reduction.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/eta_reduction.rs b/clippy_lints/src/eta_reduction.rs
index e0df87e08da..241b51eeca0 100644
--- a/clippy_lints/src/eta_reduction.rs
+++ b/clippy_lints/src/eta_reduction.rs
@@ -220,7 +220,8 @@ fn check_inputs(
     params.len() == self_arg.map_or(0, |_| 1) + args.len()
         && params.iter().zip(self_arg.into_iter().chain(args)).all(|(p, arg)| {
             matches!(
-                p.pat.kind,PatKind::Binding(BindingAnnotation::NONE, id, _, None)
+                p.pat.kind,
+                PatKind::Binding(BindingAnnotation::NONE, id, _, None)
                 if path_to_local_id(arg, id)
             )
             // Only allow adjustments which change regions (i.e. re-borrowing).
-- 
cgit 1.4.1-3-g733a5


From bce869f0c05ffe2ce341e79e2f4cf9c0a06078c1 Mon Sep 17 00:00:00 2001
From: Christoph Beberweil <christoph.beberweil@protonmail.com>
Date: Fri, 24 Nov 2023 17:29:03 +0100
Subject: fix: 7125 lint message should start with a small letter

---
 clippy_lints/src/loops/single_element_loop.rs | 2 +-
 tests/ui/single_element_loop.stderr           | 8 ++++----
 2 files changed, 5 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/single_element_loop.rs b/clippy_lints/src/loops/single_element_loop.rs
index b3db88bd098..b5786231a1a 100644
--- a/clippy_lints/src/loops/single_element_loop.rs
+++ b/clippy_lints/src/loops/single_element_loop.rs
@@ -95,7 +95,7 @@ pub(super) fn check<'tcx>(
                 cx,
                 SINGLE_ELEMENT_LOOP,
                 arg.span,
-                format!("This loops only once with {pat_snip} being {range_expr}").as_str(),
+                format!("this loops only once with {pat_snip} being {range_expr}").as_str(),
                 "did you mean to iterate over the range instead?",
                 sugg.to_string(),
                 Applicability::Unspecified,
diff --git a/tests/ui/single_element_loop.stderr b/tests/ui/single_element_loop.stderr
index 6d2a89a706a..c45f36b1d1c 100644
--- a/tests/ui/single_element_loop.stderr
+++ b/tests/ui/single_element_loop.stderr
@@ -32,25 +32,25 @@ LL +         dbg!(item);
 LL +     }
    |
 
-error: This loops only once with item being 0..5
+error: this loops only once with item being 0..5
   --> $DIR/single_element_loop.rs:16:17
    |
 LL |     for item in &[0..5] {
    |                 ^^^^^^^ help: did you mean to iterate over the range instead?: `0..5`
 
-error: This loops only once with item being 0..5
+error: this loops only once with item being 0..5
   --> $DIR/single_element_loop.rs:20:17
    |
 LL |     for item in [0..5].iter_mut() {
    |                 ^^^^^^^^^^^^^^^^^ help: did you mean to iterate over the range instead?: `0..5`
 
-error: This loops only once with item being 0..5
+error: this loops only once with item being 0..5
   --> $DIR/single_element_loop.rs:24:17
    |
 LL |     for item in [0..5] {
    |                 ^^^^^^ help: did you mean to iterate over the range instead?: `0..5`
 
-error: This loops only once with item being 0..5
+error: this loops only once with item being 0..5
   --> $DIR/single_element_loop.rs:28:17
    |
 LL |     for item in [0..5].into_iter() {
-- 
cgit 1.4.1-3-g733a5


From f9c6335a0f1a2a0fb17a67d0aa72eae63bbd8a3f Mon Sep 17 00:00:00 2001
From: Christoph Beberweil <christoph.beberweil@protonmail.com>
Date: Fri, 24 Nov 2023 17:47:31 +0100
Subject: feat: 7125 code snippets are wrapped in backticks

---
 clippy_lints/src/loops/single_element_loop.rs | 2 +-
 tests/ui/single_element_loop.stderr           | 8 ++++----
 2 files changed, 5 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/single_element_loop.rs b/clippy_lints/src/loops/single_element_loop.rs
index b5786231a1a..4773a1454b7 100644
--- a/clippy_lints/src/loops/single_element_loop.rs
+++ b/clippy_lints/src/loops/single_element_loop.rs
@@ -95,7 +95,7 @@ pub(super) fn check<'tcx>(
                 cx,
                 SINGLE_ELEMENT_LOOP,
                 arg.span,
-                format!("this loops only once with {pat_snip} being {range_expr}").as_str(),
+                format!("this loops only once with `{pat_snip}` being `{range_expr}`").as_str(),
                 "did you mean to iterate over the range instead?",
                 sugg.to_string(),
                 Applicability::Unspecified,
diff --git a/tests/ui/single_element_loop.stderr b/tests/ui/single_element_loop.stderr
index c45f36b1d1c..952d704143a 100644
--- a/tests/ui/single_element_loop.stderr
+++ b/tests/ui/single_element_loop.stderr
@@ -32,25 +32,25 @@ LL +         dbg!(item);
 LL +     }
    |
 
-error: this loops only once with item being 0..5
+error: this loops only once with `item` being `0..5`
   --> $DIR/single_element_loop.rs:16:17
    |
 LL |     for item in &[0..5] {
    |                 ^^^^^^^ help: did you mean to iterate over the range instead?: `0..5`
 
-error: this loops only once with item being 0..5
+error: this loops only once with `item` being `0..5`
   --> $DIR/single_element_loop.rs:20:17
    |
 LL |     for item in [0..5].iter_mut() {
    |                 ^^^^^^^^^^^^^^^^^ help: did you mean to iterate over the range instead?: `0..5`
 
-error: this loops only once with item being 0..5
+error: this loops only once with `item` being `0..5`
   --> $DIR/single_element_loop.rs:24:17
    |
 LL |     for item in [0..5] {
    |                 ^^^^^^ help: did you mean to iterate over the range instead?: `0..5`
 
-error: this loops only once with item being 0..5
+error: this loops only once with `item` being `0..5`
   --> $DIR/single_element_loop.rs:28:17
    |
 LL |     for item in [0..5].into_iter() {
-- 
cgit 1.4.1-3-g733a5


From ea733172e69844d772b4c9e80daf2745ac3355b1 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Fri, 24 Nov 2023 17:56:47 +0100
Subject: Create new lint `option_map_or_err_ok`

---
 clippy_lints/src/declared_lints.rs               |  1 +
 clippy_lints/src/methods/mod.rs                  | 28 ++++++++++++++++
 clippy_lints/src/methods/option_map_or_err_ok.rs | 41 ++++++++++++++++++++++++
 3 files changed, 70 insertions(+)
 create mode 100644 clippy_lints/src/methods/option_map_or_err_ok.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 7d4ab9fde1f..5a109fcc2cc 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -405,6 +405,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::methods::OK_EXPECT_INFO,
     crate::methods::OPTION_AS_REF_DEREF_INFO,
     crate::methods::OPTION_FILTER_MAP_INFO,
+    crate::methods::OPTION_MAP_OR_ERR_OK_INFO,
     crate::methods::OPTION_MAP_OR_NONE_INFO,
     crate::methods::OR_FUN_CALL_INFO,
     crate::methods::OR_THEN_UNWRAP_INFO,
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 71de77acfc1..7ce14242cae 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -70,6 +70,7 @@ mod obfuscated_if_else;
 mod ok_expect;
 mod open_options;
 mod option_as_ref_deref;
+mod option_map_or_err_ok;
 mod option_map_or_none;
 mod option_map_unwrap_or;
 mod or_fun_call;
@@ -3726,6 +3727,31 @@ declare_clippy_lint! {
     "calls to `Path::join` which will overwrite the original path"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of `_.map_or(Err(_), Ok)`.
+    ///
+    /// ### Why is this bad?
+    /// Readability, this can be written more concisely as
+    /// `_.ok_or(_)`.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # let opt = Some(1);
+    /// opt.map_or(Err("error"), Ok);
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// # let opt = Some(1);
+    /// opt.ok_or("error");
+    /// ```
+    #[clippy::version = "1.76.0"]
+    pub OPTION_MAP_OR_ERR_OK,
+    style,
+    "using `Option.map_or(Err(_), Ok)`, which is more succinctly expressed as `Option.ok_or(_)`"
+}
+
 pub struct Methods {
     avoid_breaking_exported_api: bool,
     msrv: Msrv,
@@ -3876,6 +3902,7 @@ impl_lint_pass!(Methods => [
     WAKER_CLONE_WAKE,
     UNNECESSARY_FALLIBLE_CONVERSIONS,
     JOIN_ABSOLUTE_PATHS,
+    OPTION_MAP_OR_ERR_OK,
 ]);
 
 /// Extracts a method call name, args, and `Span` of the method name.
@@ -4335,6 +4362,7 @@ impl Methods {
                 ("map_or", [def, map]) => {
                     option_map_or_none::check(cx, expr, recv, def, map);
                     manual_ok_or::check(cx, expr, recv, def, map);
+                    option_map_or_err_ok::check(cx, expr, recv, def, map);
                 },
                 ("map_or_else", [def, map]) => {
                     result_map_or_else_none::check(cx, expr, recv, def, map);
diff --git a/clippy_lints/src/methods/option_map_or_err_ok.rs b/clippy_lints/src/methods/option_map_or_err_ok.rs
new file mode 100644
index 00000000000..91e39d5a1cd
--- /dev/null
+++ b/clippy_lints/src/methods/option_map_or_err_ok.rs
@@ -0,0 +1,41 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet;
+use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::{is_res_lang_ctor, path_res};
+use rustc_errors::Applicability;
+use rustc_hir::LangItem::{ResultErr, ResultOk};
+use rustc_hir::{Expr, ExprKind};
+use rustc_lint::LateContext;
+use rustc_span::symbol::sym;
+
+use super::OPTION_MAP_OR_ERR_OK;
+
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx Expr<'tcx>,
+    recv: &'tcx Expr<'_>,
+    or_expr: &'tcx Expr<'_>,
+    map_expr: &'tcx Expr<'_>,
+) {
+    // We check that it's called on an `Option` type.
+    if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(recv), sym::Option)
+        // We check that first we pass an `Err`.
+        && let ExprKind::Call(call, &[arg]) = or_expr.kind
+        && is_res_lang_ctor(cx, path_res(cx, call), ResultErr)
+        // And finally we check that it is mapped as `Ok`.
+        && is_res_lang_ctor(cx, path_res(cx, map_expr), ResultOk)
+    {
+        let msg = "called `map_or(Err(_), Ok)` on an `Option` value";
+        let self_snippet = snippet(cx, recv.span, "..");
+        let err_snippet = snippet(cx, arg.span, "..");
+        span_lint_and_sugg(
+            cx,
+            OPTION_MAP_OR_ERR_OK,
+            expr.span,
+            msg,
+            "try using `ok_or` instead",
+            format!("{self_snippet}.ok_or({err_snippet})"),
+            Applicability::MachineApplicable,
+        );
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 148cd041406e8c950a5bb9cc655113fbcff53f98 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Sat, 25 Nov 2023 11:07:59 +0100
Subject: Simplify code for `result_map_or_else_none`

---
 clippy_lints/src/methods/result_map_or_else_none.rs | 14 +++++---------
 1 file changed, 5 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/result_map_or_else_none.rs b/clippy_lints/src/methods/result_map_or_else_none.rs
index b0e3ca367b4..bc16a112816 100644
--- a/clippy_lints/src/methods/result_map_or_else_none.rs
+++ b/clippy_lints/src/methods/result_map_or_else_none.rs
@@ -18,17 +18,13 @@ pub(super) fn check<'tcx>(
     def_arg: &'tcx hir::Expr<'_>,
     map_arg: &'tcx hir::Expr<'_>,
 ) {
-    let is_result = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(recv), sym::Result);
-
-    if !is_result {
-        return;
-    }
-
-    let f_arg_is_some = is_res_lang_ctor(cx, path_res(cx, map_arg), OptionSome);
-
-    if f_arg_is_some
+    // lint if the caller of `map_or_else()` is a `Result`
+    if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(recv), sym::Result)
+        // We check that it is mapped as `Some`.
+        && is_res_lang_ctor(cx, path_res(cx, map_arg), OptionSome)
         && let hir::ExprKind::Closure(&hir::Closure { body, .. }) = def_arg.kind
         && let body = cx.tcx.hir().body(body)
+        // And finally we check that we return a `None` in the "else case".
         && is_res_lang_ctor(cx, path_res(cx, peel_blocks(body.value)), OptionNone)
     {
         let msg = "called `map_or_else(|_| None, Some)` on a `Result` value";
-- 
cgit 1.4.1-3-g733a5


From 5689a86fb8a8e33435d60f9e8f5bb760ac0dad80 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Sat, 25 Nov 2023 13:54:37 +0100
Subject: move `implied_bounds_in_impls` to complexity

---
 clippy_lints/src/implied_bounds_in_impls.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/implied_bounds_in_impls.rs b/clippy_lints/src/implied_bounds_in_impls.rs
index 232d8eeb11b..a369fa00ea6 100644
--- a/clippy_lints/src/implied_bounds_in_impls.rs
+++ b/clippy_lints/src/implied_bounds_in_impls.rs
@@ -45,7 +45,7 @@ declare_clippy_lint! {
     /// ```
     #[clippy::version = "1.74.0"]
     pub IMPLIED_BOUNDS_IN_IMPLS,
-    nursery,
+    complexity,
     "specifying bounds that are implied by other bounds in `impl Trait` type"
 }
 declare_lint_pass!(ImpliedBoundsInImpls => [IMPLIED_BOUNDS_IN_IMPLS]);
-- 
cgit 1.4.1-3-g733a5


From 7093444bfac3b24e380d645b0da4f16ef5c25970 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Sat, 25 Nov 2023 17:45:27 +0000
Subject: Use absolute path for `declare_tool_lint` in `declare_clippy_lint`

---
 book/src/development/adding_lints.md                                  | 2 +-
 clippy_dev/src/new_lint.rs                                            | 4 ++--
 clippy_lints/src/absolute_paths.rs                                    | 2 +-
 clippy_lints/src/allow_attributes.rs                                  | 2 +-
 clippy_lints/src/almost_complete_range.rs                             | 2 +-
 clippy_lints/src/approx_const.rs                                      | 2 +-
 clippy_lints/src/arc_with_non_send_sync.rs                            | 2 +-
 clippy_lints/src/as_conversions.rs                                    | 2 +-
 clippy_lints/src/asm_syntax.rs                                        | 2 +-
 clippy_lints/src/assertions_on_constants.rs                           | 2 +-
 clippy_lints/src/assertions_on_result_states.rs                       | 2 +-
 clippy_lints/src/async_yields_async.rs                                | 2 +-
 clippy_lints/src/attrs.rs                                             | 2 +-
 clippy_lints/src/await_holding_invalid.rs                             | 2 +-
 clippy_lints/src/blocks_in_if_conditions.rs                           | 2 +-
 clippy_lints/src/bool_assert_comparison.rs                            | 2 +-
 clippy_lints/src/bool_to_int_with_if.rs                               | 2 +-
 clippy_lints/src/booleans.rs                                          | 2 +-
 clippy_lints/src/borrow_deref_ref.rs                                  | 2 +-
 clippy_lints/src/box_default.rs                                       | 2 +-
 clippy_lints/src/cargo/mod.rs                                         | 2 +-
 clippy_lints/src/casts/mod.rs                                         | 2 +-
 clippy_lints/src/checked_conversions.rs                               | 2 +-
 clippy_lints/src/cognitive_complexity.rs                              | 2 +-
 clippy_lints/src/collapsible_if.rs                                    | 2 +-
 clippy_lints/src/collection_is_never_read.rs                          | 2 +-
 clippy_lints/src/comparison_chain.rs                                  | 2 +-
 clippy_lints/src/copies.rs                                            | 2 +-
 clippy_lints/src/copy_iterator.rs                                     | 2 +-
 clippy_lints/src/crate_in_macro_def.rs                                | 2 +-
 clippy_lints/src/create_dir.rs                                        | 2 +-
 clippy_lints/src/dbg_macro.rs                                         | 2 +-
 clippy_lints/src/default.rs                                           | 2 +-
 clippy_lints/src/default_constructed_unit_structs.rs                  | 2 +-
 clippy_lints/src/default_instead_of_iter_empty.rs                     | 2 +-
 clippy_lints/src/default_numeric_fallback.rs                          | 2 +-
 clippy_lints/src/default_union_representation.rs                      | 2 +-
 clippy_lints/src/dereference.rs                                       | 2 +-
 clippy_lints/src/derivable_impls.rs                                   | 2 +-
 clippy_lints/src/derive.rs                                            | 2 +-
 clippy_lints/src/disallowed_macros.rs                                 | 2 +-
 clippy_lints/src/disallowed_methods.rs                                | 2 +-
 clippy_lints/src/disallowed_names.rs                                  | 2 +-
 clippy_lints/src/disallowed_script_idents.rs                          | 2 +-
 clippy_lints/src/disallowed_types.rs                                  | 2 +-
 clippy_lints/src/doc/mod.rs                                           | 2 +-
 clippy_lints/src/double_parens.rs                                     | 2 +-
 clippy_lints/src/drop_forget_ref.rs                                   | 2 +-
 clippy_lints/src/duplicate_mod.rs                                     | 2 +-
 clippy_lints/src/else_if_without_else.rs                              | 2 +-
 clippy_lints/src/empty_drop.rs                                        | 2 +-
 clippy_lints/src/empty_enum.rs                                        | 2 +-
 clippy_lints/src/empty_structs_with_brackets.rs                       | 2 +-
 clippy_lints/src/endian_bytes.rs                                      | 2 +-
 clippy_lints/src/entry.rs                                             | 2 +-
 clippy_lints/src/enum_clike.rs                                        | 2 +-
 clippy_lints/src/equatable_if_let.rs                                  | 2 +-
 clippy_lints/src/error_impl_error.rs                                  | 2 +-
 clippy_lints/src/escape.rs                                            | 2 +-
 clippy_lints/src/eta_reduction.rs                                     | 2 +-
 clippy_lints/src/excessive_bools.rs                                   | 2 +-
 clippy_lints/src/excessive_nesting.rs                                 | 2 +-
 clippy_lints/src/exhaustive_items.rs                                  | 2 +-
 clippy_lints/src/exit.rs                                              | 2 +-
 clippy_lints/src/explicit_write.rs                                    | 2 +-
 clippy_lints/src/extra_unused_type_parameters.rs                      | 2 +-
 clippy_lints/src/fallible_impl_from.rs                                | 2 +-
 clippy_lints/src/float_literal.rs                                     | 2 +-
 clippy_lints/src/floating_point_arithmetic.rs                         | 2 +-
 clippy_lints/src/format.rs                                            | 2 +-
 clippy_lints/src/format_args.rs                                       | 2 +-
 clippy_lints/src/format_impl.rs                                       | 2 +-
 clippy_lints/src/format_push_string.rs                                | 2 +-
 clippy_lints/src/formatting.rs                                        | 2 +-
 clippy_lints/src/four_forward_slashes.rs                              | 2 +-
 clippy_lints/src/from_over_into.rs                                    | 2 +-
 clippy_lints/src/from_raw_with_void_ptr.rs                            | 2 +-
 clippy_lints/src/from_str_radix_10.rs                                 | 2 +-
 clippy_lints/src/functions/mod.rs                                     | 2 +-
 clippy_lints/src/future_not_send.rs                                   | 2 +-
 clippy_lints/src/if_let_mutex.rs                                      | 2 +-
 clippy_lints/src/if_not_else.rs                                       | 2 +-
 clippy_lints/src/if_then_some_else_none.rs                            | 2 +-
 clippy_lints/src/ignored_unit_patterns.rs                             | 2 +-
 clippy_lints/src/impl_hash_with_borrow_str_and_bytes.rs               | 2 +-
 clippy_lints/src/implicit_hasher.rs                                   | 2 +-
 clippy_lints/src/implicit_return.rs                                   | 2 +-
 clippy_lints/src/implicit_saturating_add.rs                           | 2 +-
 clippy_lints/src/implicit_saturating_sub.rs                           | 2 +-
 clippy_lints/src/implied_bounds_in_impls.rs                           | 2 +-
 clippy_lints/src/inconsistent_struct_constructor.rs                   | 2 +-
 clippy_lints/src/index_refutable_slice.rs                             | 2 +-
 clippy_lints/src/indexing_slicing.rs                                  | 2 +-
 clippy_lints/src/infinite_iter.rs                                     | 2 +-
 clippy_lints/src/inherent_impl.rs                                     | 2 +-
 clippy_lints/src/inherent_to_string.rs                                | 2 +-
 clippy_lints/src/init_numbered_fields.rs                              | 2 +-
 clippy_lints/src/inline_fn_without_body.rs                            | 2 +-
 clippy_lints/src/instant_subtraction.rs                               | 2 +-
 clippy_lints/src/int_plus_one.rs                                      | 2 +-
 clippy_lints/src/invalid_upcast_comparisons.rs                        | 2 +-
 clippy_lints/src/item_name_repetitions.rs                             | 2 +-
 clippy_lints/src/items_after_statements.rs                            | 2 +-
 clippy_lints/src/items_after_test_module.rs                           | 2 +-
 clippy_lints/src/iter_not_returning_iterator.rs                       | 2 +-
 clippy_lints/src/iter_over_hash_type.rs                               | 2 +-
 clippy_lints/src/iter_without_into_iter.rs                            | 2 +-
 clippy_lints/src/large_const_arrays.rs                                | 2 +-
 clippy_lints/src/large_enum_variant.rs                                | 2 +-
 clippy_lints/src/large_futures.rs                                     | 2 +-
 clippy_lints/src/large_include_file.rs                                | 2 +-
 clippy_lints/src/large_stack_arrays.rs                                | 2 +-
 clippy_lints/src/large_stack_frames.rs                                | 2 +-
 clippy_lints/src/len_zero.rs                                          | 2 +-
 clippy_lints/src/let_if_seq.rs                                        | 2 +-
 clippy_lints/src/let_underscore.rs                                    | 2 +-
 clippy_lints/src/let_with_type_underscore.rs                          | 2 +-
 clippy_lints/src/lifetimes.rs                                         | 2 +-
 clippy_lints/src/lines_filter_map_ok.rs                               | 2 +-
 clippy_lints/src/literal_representation.rs                            | 2 +-
 clippy_lints/src/loops/mod.rs                                         | 2 +-
 clippy_lints/src/macro_use.rs                                         | 2 +-
 clippy_lints/src/main_recursion.rs                                    | 2 +-
 clippy_lints/src/manual_assert.rs                                     | 2 +-
 clippy_lints/src/manual_async_fn.rs                                   | 2 +-
 clippy_lints/src/manual_bits.rs                                       | 2 +-
 clippy_lints/src/manual_clamp.rs                                      | 2 +-
 clippy_lints/src/manual_float_methods.rs                              | 2 +-
 clippy_lints/src/manual_hash_one.rs                                   | 2 +-
 clippy_lints/src/manual_is_ascii_check.rs                             | 2 +-
 clippy_lints/src/manual_let_else.rs                                   | 2 +-
 clippy_lints/src/manual_main_separator_str.rs                         | 2 +-
 clippy_lints/src/manual_non_exhaustive.rs                             | 2 +-
 clippy_lints/src/manual_range_patterns.rs                             | 2 +-
 clippy_lints/src/manual_rem_euclid.rs                                 | 2 +-
 clippy_lints/src/manual_retain.rs                                     | 2 +-
 clippy_lints/src/manual_slice_size_calculation.rs                     | 2 +-
 clippy_lints/src/manual_string_new.rs                                 | 2 +-
 clippy_lints/src/manual_strip.rs                                      | 2 +-
 clippy_lints/src/map_unit_fn.rs                                       | 2 +-
 clippy_lints/src/match_result_ok.rs                                   | 2 +-
 clippy_lints/src/matches/mod.rs                                       | 2 +-
 clippy_lints/src/mem_replace.rs                                       | 2 +-
 clippy_lints/src/methods/mod.rs                                       | 2 +-
 clippy_lints/src/min_ident_chars.rs                                   | 2 +-
 clippy_lints/src/minmax.rs                                            | 2 +-
 clippy_lints/src/misc.rs                                              | 2 +-
 clippy_lints/src/misc_early/mod.rs                                    | 2 +-
 clippy_lints/src/mismatching_type_param_order.rs                      | 2 +-
 clippy_lints/src/missing_assert_message.rs                            | 2 +-
 clippy_lints/src/missing_asserts_for_indexing.rs                      | 2 +-
 clippy_lints/src/missing_const_for_fn.rs                              | 2 +-
 clippy_lints/src/missing_doc.rs                                       | 2 +-
 clippy_lints/src/missing_enforced_import_rename.rs                    | 2 +-
 clippy_lints/src/missing_fields_in_debug.rs                           | 2 +-
 clippy_lints/src/missing_inline.rs                                    | 2 +-
 clippy_lints/src/missing_trait_methods.rs                             | 2 +-
 clippy_lints/src/mixed_read_write_in_expression.rs                    | 2 +-
 clippy_lints/src/module_style.rs                                      | 2 +-
 clippy_lints/src/multi_assignments.rs                                 | 2 +-
 clippy_lints/src/multiple_unsafe_ops_per_block.rs                     | 2 +-
 clippy_lints/src/mut_key.rs                                           | 2 +-
 clippy_lints/src/mut_mut.rs                                           | 2 +-
 clippy_lints/src/mut_reference.rs                                     | 2 +-
 clippy_lints/src/mutable_debug_assertion.rs                           | 2 +-
 clippy_lints/src/mutex_atomic.rs                                      | 2 +-
 clippy_lints/src/needless_arbitrary_self_type.rs                      | 2 +-
 clippy_lints/src/needless_bool.rs                                     | 2 +-
 clippy_lints/src/needless_borrowed_ref.rs                             | 2 +-
 clippy_lints/src/needless_borrows_for_generic_args.rs                 | 2 +-
 clippy_lints/src/needless_continue.rs                                 | 2 +-
 clippy_lints/src/needless_else.rs                                     | 2 +-
 clippy_lints/src/needless_for_each.rs                                 | 2 +-
 clippy_lints/src/needless_if.rs                                       | 2 +-
 clippy_lints/src/needless_late_init.rs                                | 2 +-
 clippy_lints/src/needless_parens_on_range_literals.rs                 | 2 +-
 clippy_lints/src/needless_pass_by_ref_mut.rs                          | 2 +-
 clippy_lints/src/needless_pass_by_value.rs                            | 2 +-
 clippy_lints/src/needless_question_mark.rs                            | 2 +-
 clippy_lints/src/needless_update.rs                                   | 2 +-
 clippy_lints/src/neg_cmp_op_on_partial_ord.rs                         | 2 +-
 clippy_lints/src/neg_multiply.rs                                      | 2 +-
 clippy_lints/src/new_without_default.rs                               | 2 +-
 clippy_lints/src/no_effect.rs                                         | 2 +-
 clippy_lints/src/no_mangle_with_rust_abi.rs                           | 2 +-
 clippy_lints/src/non_canonical_impls.rs                               | 2 +-
 clippy_lints/src/non_copy_const.rs                                    | 2 +-
 clippy_lints/src/non_expressive_names.rs                              | 2 +-
 clippy_lints/src/non_octal_unix_permissions.rs                        | 2 +-
 clippy_lints/src/non_send_fields_in_send_ty.rs                        | 2 +-
 clippy_lints/src/nonstandard_macro_braces.rs                          | 2 +-
 clippy_lints/src/octal_escapes.rs                                     | 2 +-
 clippy_lints/src/only_used_in_recursion.rs                            | 2 +-
 clippy_lints/src/operators/mod.rs                                     | 2 +-
 clippy_lints/src/option_env_unwrap.rs                                 | 2 +-
 clippy_lints/src/option_if_let_else.rs                                | 2 +-
 clippy_lints/src/overflow_check_conditional.rs                        | 2 +-
 clippy_lints/src/panic_in_result_fn.rs                                | 2 +-
 clippy_lints/src/panic_unimplemented.rs                               | 2 +-
 clippy_lints/src/partial_pub_fields.rs                                | 2 +-
 clippy_lints/src/partialeq_ne_impl.rs                                 | 2 +-
 clippy_lints/src/partialeq_to_none.rs                                 | 2 +-
 clippy_lints/src/pass_by_ref_or_value.rs                              | 2 +-
 clippy_lints/src/pattern_type_mismatch.rs                             | 2 +-
 clippy_lints/src/permissions_set_readonly_false.rs                    | 2 +-
 clippy_lints/src/precedence.rs                                        | 2 +-
 clippy_lints/src/ptr.rs                                               | 2 +-
 clippy_lints/src/ptr_offset_with_cast.rs                              | 2 +-
 clippy_lints/src/pub_use.rs                                           | 2 +-
 clippy_lints/src/question_mark.rs                                     | 2 +-
 clippy_lints/src/question_mark_used.rs                                | 2 +-
 clippy_lints/src/ranges.rs                                            | 2 +-
 clippy_lints/src/raw_strings.rs                                       | 2 +-
 clippy_lints/src/rc_clone_in_vec_init.rs                              | 2 +-
 clippy_lints/src/read_zero_byte_vec.rs                                | 2 +-
 clippy_lints/src/redundant_async_block.rs                             | 2 +-
 clippy_lints/src/redundant_clone.rs                                   | 2 +-
 clippy_lints/src/redundant_closure_call.rs                            | 2 +-
 clippy_lints/src/redundant_else.rs                                    | 2 +-
 clippy_lints/src/redundant_field_names.rs                             | 2 +-
 clippy_lints/src/redundant_locals.rs                                  | 2 +-
 clippy_lints/src/redundant_pub_crate.rs                               | 2 +-
 clippy_lints/src/redundant_slicing.rs                                 | 2 +-
 clippy_lints/src/redundant_static_lifetimes.rs                        | 2 +-
 clippy_lints/src/redundant_type_annotations.rs                        | 2 +-
 clippy_lints/src/ref_option_ref.rs                                    | 2 +-
 clippy_lints/src/ref_patterns.rs                                      | 2 +-
 clippy_lints/src/reference.rs                                         | 2 +-
 clippy_lints/src/regex.rs                                             | 2 +-
 clippy_lints/src/reserve_after_initialization.rs                      | 2 +-
 clippy_lints/src/return_self_not_must_use.rs                          | 2 +-
 clippy_lints/src/returns.rs                                           | 2 +-
 clippy_lints/src/same_name_method.rs                                  | 2 +-
 clippy_lints/src/self_named_constructors.rs                           | 2 +-
 clippy_lints/src/semicolon_block.rs                                   | 2 +-
 clippy_lints/src/semicolon_if_nothing_returned.rs                     | 2 +-
 clippy_lints/src/serde_api.rs                                         | 2 +-
 clippy_lints/src/shadow.rs                                            | 2 +-
 clippy_lints/src/significant_drop_tightening.rs                       | 2 +-
 clippy_lints/src/single_call_fn.rs                                    | 2 +-
 clippy_lints/src/single_char_lifetime_names.rs                        | 2 +-
 clippy_lints/src/single_component_path_imports.rs                     | 2 +-
 clippy_lints/src/single_range_in_vec_init.rs                          | 2 +-
 clippy_lints/src/size_of_in_element_count.rs                          | 2 +-
 clippy_lints/src/size_of_ref.rs                                       | 2 +-
 clippy_lints/src/slow_vector_initialization.rs                        | 2 +-
 clippy_lints/src/std_instead_of_core.rs                               | 2 +-
 clippy_lints/src/strings.rs                                           | 2 +-
 clippy_lints/src/strlen_on_c_strings.rs                               | 2 +-
 clippy_lints/src/suspicious_operation_groupings.rs                    | 2 +-
 clippy_lints/src/suspicious_trait_impl.rs                             | 2 +-
 clippy_lints/src/suspicious_xor_used_as_pow.rs                        | 2 +-
 clippy_lints/src/swap.rs                                              | 2 +-
 clippy_lints/src/swap_ptr_to_ref.rs                                   | 2 +-
 clippy_lints/src/tabs_in_doc_comments.rs                              | 2 +-
 clippy_lints/src/temporary_assignment.rs                              | 2 +-
 clippy_lints/src/tests_outside_test_module.rs                         | 2 +-
 clippy_lints/src/to_digit_is_some.rs                                  | 2 +-
 clippy_lints/src/trailing_empty_array.rs                              | 2 +-
 clippy_lints/src/trait_bounds.rs                                      | 2 +-
 clippy_lints/src/transmute/mod.rs                                     | 2 +-
 clippy_lints/src/tuple_array_conversions.rs                           | 2 +-
 clippy_lints/src/types/mod.rs                                         | 2 +-
 clippy_lints/src/undocumented_unsafe_blocks.rs                        | 2 +-
 clippy_lints/src/unicode.rs                                           | 2 +-
 clippy_lints/src/uninit_vec.rs                                        | 2 +-
 clippy_lints/src/unit_return_expecting_ord.rs                         | 2 +-
 clippy_lints/src/unit_types/mod.rs                                    | 2 +-
 clippy_lints/src/unnamed_address.rs                                   | 2 +-
 clippy_lints/src/unnecessary_box_returns.rs                           | 2 +-
 clippy_lints/src/unnecessary_map_on_constructor.rs                    | 2 +-
 clippy_lints/src/unnecessary_owned_empty_strings.rs                   | 2 +-
 clippy_lints/src/unnecessary_self_imports.rs                          | 2 +-
 clippy_lints/src/unnecessary_struct_initialization.rs                 | 2 +-
 clippy_lints/src/unnecessary_wraps.rs                                 | 2 +-
 clippy_lints/src/unnested_or_patterns.rs                              | 2 +-
 clippy_lints/src/unsafe_removed_from_name.rs                          | 2 +-
 clippy_lints/src/unused_async.rs                                      | 2 +-
 clippy_lints/src/unused_io_amount.rs                                  | 2 +-
 clippy_lints/src/unused_peekable.rs                                   | 2 +-
 clippy_lints/src/unused_rounding.rs                                   | 2 +-
 clippy_lints/src/unused_self.rs                                       | 2 +-
 clippy_lints/src/unused_unit.rs                                       | 2 +-
 clippy_lints/src/unwrap.rs                                            | 2 +-
 clippy_lints/src/unwrap_in_result.rs                                  | 2 +-
 clippy_lints/src/upper_case_acronyms.rs                               | 2 +-
 clippy_lints/src/use_self.rs                                          | 2 +-
 clippy_lints/src/useless_conversion.rs                                | 2 +-
 .../src/utils/internal_lints/almost_standard_lint_formulation.rs      | 2 +-
 clippy_lints/src/utils/internal_lints/collapsible_calls.rs            | 2 +-
 clippy_lints/src/utils/internal_lints/compiler_lint_functions.rs      | 2 +-
 clippy_lints/src/utils/internal_lints/interning_defined_symbol.rs     | 2 +-
 clippy_lints/src/utils/internal_lints/invalid_paths.rs                | 2 +-
 clippy_lints/src/utils/internal_lints/lint_without_lint_pass.rs       | 2 +-
 clippy_lints/src/utils/internal_lints/metadata_collector.rs           | 2 +-
 clippy_lints/src/utils/internal_lints/msrv_attr_impl.rs               | 2 +-
 clippy_lints/src/utils/internal_lints/outer_expn_data_pass.rs         | 2 +-
 clippy_lints/src/utils/internal_lints/produce_ice.rs                  | 2 +-
 clippy_lints/src/utils/internal_lints/unnecessary_def_path.rs         | 2 +-
 clippy_lints/src/utils/internal_lints/unsorted_clippy_utils_paths.rs  | 2 +-
 clippy_lints/src/vec.rs                                               | 2 +-
 clippy_lints/src/vec_init_then_push.rs                                | 2 +-
 clippy_lints/src/visibility.rs                                        | 2 +-
 clippy_lints/src/wildcard_imports.rs                                  | 2 +-
 clippy_lints/src/write.rs                                             | 2 +-
 clippy_lints/src/zero_div_zero.rs                                     | 2 +-
 clippy_lints/src/zero_sized_map_values.rs                             | 2 +-
 declare_clippy_lint/src/lib.rs                                        | 2 +-
 308 files changed, 309 insertions(+), 309 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/book/src/development/adding_lints.md b/book/src/development/adding_lints.md
index e79e5e75cd1..e30a5f9fe10 100644
--- a/book/src/development/adding_lints.md
+++ b/book/src/development/adding_lints.md
@@ -202,7 +202,7 @@ is. This file has already imported some initial things we will need:
 
 ```rust
 use rustc_lint::{EarlyLintPass, EarlyContext};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_ast::ast::*;
 ```
 
diff --git a/clippy_dev/src/new_lint.rs b/clippy_dev/src/new_lint.rs
index ddc20f7f37f..31a42734c13 100644
--- a/clippy_dev/src/new_lint.rs
+++ b/clippy_dev/src/new_lint.rs
@@ -283,7 +283,7 @@ fn get_lint_file_contents(lint: &LintData<'_>, enable_msrv: bool) -> String {
             use clippy_utils::msrvs::{{self, Msrv}};
             {pass_import}
             use rustc_lint::{{{context_import}, {pass_type}, LintContext}};
-            use rustc_session::{{declare_tool_lint, impl_lint_pass}};
+            use rustc_session::impl_lint_pass;
 
         "#
         )
@@ -292,7 +292,7 @@ fn get_lint_file_contents(lint: &LintData<'_>, enable_msrv: bool) -> String {
             r#"
             {pass_import}
             use rustc_lint::{{{context_import}, {pass_type}}};
-            use rustc_session::{{declare_lint_pass, declare_tool_lint}};
+            use rustc_session::declare_lint_pass;
 
         "#
         )
diff --git a/clippy_lints/src/absolute_paths.rs b/clippy_lints/src/absolute_paths.rs
index 582423603eb..83d15c0c425 100644
--- a/clippy_lints/src/absolute_paths.rs
+++ b/clippy_lints/src/absolute_paths.rs
@@ -5,7 +5,7 @@ use rustc_hir::def::{DefKind, Res};
 use rustc_hir::def_id::{DefId, CRATE_DEF_INDEX};
 use rustc_hir::{HirId, ItemKind, Node, Path};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::symbol::kw;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/allow_attributes.rs b/clippy_lints/src/allow_attributes.rs
index 98299e1e4bd..39fc49dee37 100644
--- a/clippy_lints/src/allow_attributes.rs
+++ b/clippy_lints/src/allow_attributes.rs
@@ -5,7 +5,7 @@ use rustc_ast as ast;
 use rustc_errors::Applicability;
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/almost_complete_range.rs b/clippy_lints/src/almost_complete_range.rs
index e85878eb570..57a5cd8fba8 100644
--- a/clippy_lints/src/almost_complete_range.rs
+++ b/clippy_lints/src/almost_complete_range.rs
@@ -5,7 +5,7 @@ use rustc_ast::ast::{Expr, ExprKind, LitKind, Pat, PatKind, RangeEnd, RangeLimit
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::Span;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/approx_const.rs b/clippy_lints/src/approx_const.rs
index b4f778f12b9..409ae0c85ac 100644
--- a/clippy_lints/src/approx_const.rs
+++ b/clippy_lints/src/approx_const.rs
@@ -4,7 +4,7 @@ use rustc_ast::ast::{FloatTy, LitFloatType, LitKind};
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_semver::RustcVersion;
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::symbol;
 use std::f64::consts as f64;
 
diff --git a/clippy_lints/src/arc_with_non_send_sync.rs b/clippy_lints/src/arc_with_non_send_sync.rs
index 9799e703afe..657d52d0e9e 100644
--- a/clippy_lints/src/arc_with_non_send_sync.rs
+++ b/clippy_lints/src/arc_with_non_send_sync.rs
@@ -6,7 +6,7 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
 use rustc_middle::ty::print::with_forced_trimmed_paths;
 use rustc_middle::ty::GenericArgKind;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::symbol::sym;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/as_conversions.rs b/clippy_lints/src/as_conversions.rs
index b9dda49ca41..e052d36f115 100644
--- a/clippy_lints/src/as_conversions.rs
+++ b/clippy_lints/src/as_conversions.rs
@@ -3,7 +3,7 @@ use clippy_utils::is_from_proc_macro;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/asm_syntax.rs b/clippy_lints/src/asm_syntax.rs
index 9717aa9e981..feb6437ee26 100644
--- a/clippy_lints/src/asm_syntax.rs
+++ b/clippy_lints/src/asm_syntax.rs
@@ -3,7 +3,7 @@ use std::fmt;
 use clippy_utils::diagnostics::span_lint_and_help;
 use rustc_ast::ast::{Expr, ExprKind, InlineAsmOptions};
 use rustc_lint::{EarlyContext, EarlyLintPass, Lint};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 
 #[derive(Clone, Copy, PartialEq, Eq)]
 enum AsmStyle {
diff --git a/clippy_lints/src/assertions_on_constants.rs b/clippy_lints/src/assertions_on_constants.rs
index b90914e936a..a15ec199a28 100644
--- a/clippy_lints/src/assertions_on_constants.rs
+++ b/clippy_lints/src/assertions_on_constants.rs
@@ -3,7 +3,7 @@ use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::macros::{find_assert_args, root_macro_call_first_node, PanicExpn};
 use rustc_hir::Expr;
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::sym;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/assertions_on_result_states.rs b/clippy_lints/src/assertions_on_result_states.rs
index 71ec87a8874..aec22965b1b 100644
--- a/clippy_lints/src/assertions_on_result_states.rs
+++ b/clippy_lints/src/assertions_on_result_states.rs
@@ -9,7 +9,7 @@ use rustc_hir::def::Res;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{self, Ty};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::sym;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/async_yields_async.rs b/clippy_lints/src/async_yields_async.rs
index ec2447dae96..3e5a01c45df 100644
--- a/clippy_lints/src/async_yields_async.rs
+++ b/clippy_lints/src/async_yields_async.rs
@@ -4,7 +4,7 @@ use clippy_utils::ty::implements_trait;
 use rustc_errors::Applicability;
 use rustc_hir::{Body, BodyId, CoroutineKind, CoroutineSource, ExprKind, QPath};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs
index 694bc8755a6..da38422874b 100644
--- a/clippy_lints/src/attrs.rs
+++ b/clippy_lints/src/attrs.rs
@@ -17,7 +17,7 @@ use rustc_hir::{
 use rustc_lint::{EarlyContext, EarlyLintPass, LateContext, LateLintPass, Level, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty;
-use rustc_session::{declare_lint_pass, declare_tool_lint, impl_lint_pass};
+use rustc_session::{declare_lint_pass, impl_lint_pass};
 use rustc_span::symbol::Symbol;
 use rustc_span::{sym, Span, DUMMY_SP};
 use semver::Version;
diff --git a/clippy_lints/src/await_holding_invalid.rs b/clippy_lints/src/await_holding_invalid.rs
index 06b74b972b7..9894a163961 100644
--- a/clippy_lints/src/await_holding_invalid.rs
+++ b/clippy_lints/src/await_holding_invalid.rs
@@ -6,7 +6,7 @@ use rustc_hir::def_id::DefId;
 use rustc_hir::{Body, CoroutineKind, CoroutineSource};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::mir::CoroutineLayout;
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::{sym, Span};
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/blocks_in_if_conditions.rs b/clippy_lints/src/blocks_in_if_conditions.rs
index 28bd3fc7011..692309629b7 100644
--- a/clippy_lints/src/blocks_in_if_conditions.rs
+++ b/clippy_lints/src/blocks_in_if_conditions.rs
@@ -8,7 +8,7 @@ use rustc_errors::Applicability;
 use rustc_hir::{BlockCheckMode, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::sym;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/bool_assert_comparison.rs b/clippy_lints/src/bool_assert_comparison.rs
index 665dbd6f708..74201e9cc30 100644
--- a/clippy_lints/src/bool_assert_comparison.rs
+++ b/clippy_lints/src/bool_assert_comparison.rs
@@ -7,7 +7,7 @@ use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, Lit};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::ty::{self, Ty};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::symbol::Ident;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/bool_to_int_with_if.rs b/clippy_lints/src/bool_to_int_with_if.rs
index 156cb34df9c..cfb76cab6dc 100644
--- a/clippy_lints/src/bool_to_int_with_if.rs
+++ b/clippy_lints/src/bool_to_int_with_if.rs
@@ -2,7 +2,7 @@ use clippy_utils::higher::If;
 use rustc_ast::LitKind;
 use rustc_hir::{Block, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::sugg::Sugg;
diff --git a/clippy_lints/src/booleans.rs b/clippy_lints/src/booleans.rs
index d4f2e316890..e68ea2571b6 100644
--- a/clippy_lints/src/booleans.rs
+++ b/clippy_lints/src/booleans.rs
@@ -7,7 +7,7 @@ use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_expr, FnKind, Visitor};
 use rustc_hir::{BinOpKind, Body, Expr, ExprKind, FnDecl, UnOp};
 use rustc_lint::{LateContext, LateLintPass, Level};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::def_id::LocalDefId;
 use rustc_span::{sym, Span};
 
diff --git a/clippy_lints/src/borrow_deref_ref.rs b/clippy_lints/src/borrow_deref_ref.rs
index 789cd3b6c21..d3d4f3c41c8 100644
--- a/clippy_lints/src/borrow_deref_ref.rs
+++ b/clippy_lints/src/borrow_deref_ref.rs
@@ -8,7 +8,7 @@ use rustc_hir::{ExprKind, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::mir::Mutability;
 use rustc_middle::ty;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/box_default.rs b/clippy_lints/src/box_default.rs
index 9c78c6e532d..b69dc5c1291 100644
--- a/clippy_lints/src/box_default.rs
+++ b/clippy_lints/src/box_default.rs
@@ -10,7 +10,7 @@ use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::print::with_forced_trimmed_paths;
 use rustc_middle::ty::IsSuggestable;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::sym;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/cargo/mod.rs b/clippy_lints/src/cargo/mod.rs
index 3a872e54c9a..fea6924d89e 100644
--- a/clippy_lints/src/cargo/mod.rs
+++ b/clippy_lints/src/cargo/mod.rs
@@ -8,7 +8,7 @@ use clippy_utils::diagnostics::span_lint;
 use clippy_utils::is_lint_allowed;
 use rustc_hir::hir_id::CRATE_HIR_ID;
 use rustc_lint::{LateContext, LateLintPass, Lint};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::DUMMY_SP;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index 49a90a2f3c2..e05b8f66d86 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -27,7 +27,7 @@ use clippy_utils::is_hir_ty_cfg_dependant;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/checked_conversions.rs b/clippy_lints/src/checked_conversions.rs
index 69fa0821e3f..92810ea2aa0 100644
--- a/clippy_lints/src/checked_conversions.rs
+++ b/clippy_lints/src/checked_conversions.rs
@@ -8,7 +8,7 @@ use rustc_errors::Applicability;
 use rustc_hir::{BinOp, BinOpKind, Expr, ExprKind, QPath, TyKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/cognitive_complexity.rs b/clippy_lints/src/cognitive_complexity.rs
index 74ecaa60c7c..60f436dc5d2 100644
--- a/clippy_lints/src/cognitive_complexity.rs
+++ b/clippy_lints/src/cognitive_complexity.rs
@@ -10,7 +10,7 @@ use rustc_ast::ast::Attribute;
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::{Body, Expr, ExprKind, FnDecl};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::def_id::LocalDefId;
 use rustc_span::{sym, BytePos, Span};
 
diff --git a/clippy_lints/src/collapsible_if.rs b/clippy_lints/src/collapsible_if.rs
index e5aaf88ab6c..07b02c98df1 100644
--- a/clippy_lints/src/collapsible_if.rs
+++ b/clippy_lints/src/collapsible_if.rs
@@ -18,7 +18,7 @@ use clippy_utils::sugg::Sugg;
 use rustc_ast::ast;
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::Span;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/collection_is_never_read.rs b/clippy_lints/src/collection_is_never_read.rs
index 1dfc2e251d9..d0c989cfff3 100644
--- a/clippy_lints/src/collection_is_never_read.rs
+++ b/clippy_lints/src/collection_is_never_read.rs
@@ -5,7 +5,7 @@ use clippy_utils::{get_enclosing_block, get_parent_node, path_to_local_id};
 use core::ops::ControlFlow;
 use rustc_hir::{Block, ExprKind, HirId, LangItem, Local, Node, PatKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::symbol::sym;
 use rustc_span::Symbol;
 
diff --git a/clippy_lints/src/comparison_chain.rs b/clippy_lints/src/comparison_chain.rs
index 0fe973b49a3..2c23c0b4f15 100644
--- a/clippy_lints/src/comparison_chain.rs
+++ b/clippy_lints/src/comparison_chain.rs
@@ -3,7 +3,7 @@ use clippy_utils::ty::implements_trait;
 use clippy_utils::{if_sequence, in_constant, is_else_clause, SpanlessEq};
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::sym;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/copies.rs b/clippy_lints/src/copies.rs
index 3b6d4886ba3..d91af76f5e0 100644
--- a/clippy_lints/src/copies.rs
+++ b/clippy_lints/src/copies.rs
@@ -13,7 +13,7 @@ use rustc_hir::def_id::DefIdSet;
 use rustc_hir::{intravisit, BinOpKind, Block, Expr, ExprKind, HirId, HirIdSet, Stmt, StmtKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::query::Key;
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::hygiene::walk_chain;
 use rustc_span::source_map::SourceMap;
 use rustc_span::{BytePos, Span, Symbol};
diff --git a/clippy_lints/src/copy_iterator.rs b/clippy_lints/src/copy_iterator.rs
index db850edd640..50fd76a3a47 100644
--- a/clippy_lints/src/copy_iterator.rs
+++ b/clippy_lints/src/copy_iterator.rs
@@ -2,7 +2,7 @@ use clippy_utils::diagnostics::span_lint_and_note;
 use clippy_utils::ty::is_copy;
 use rustc_hir::{Impl, Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::sym;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/crate_in_macro_def.rs b/clippy_lints/src/crate_in_macro_def.rs
index 637d5aae1be..d4828778be2 100644
--- a/clippy_lints/src/crate_in_macro_def.rs
+++ b/clippy_lints/src/crate_in_macro_def.rs
@@ -4,7 +4,7 @@ use rustc_ast::token::{Token, TokenKind};
 use rustc_ast::tokenstream::{TokenStream, TokenTree};
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::symbol::sym;
 use rustc_span::Span;
 
diff --git a/clippy_lints/src/create_dir.rs b/clippy_lints/src/create_dir.rs
index 97b736dfd8f..7a3d5a07091 100644
--- a/clippy_lints/src/create_dir.rs
+++ b/clippy_lints/src/create_dir.rs
@@ -3,7 +3,7 @@ use clippy_utils::source::snippet;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::sym;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/dbg_macro.rs b/clippy_lints/src/dbg_macro.rs
index 4774917c7b5..9424a9103db 100644
--- a/clippy_lints/src/dbg_macro.rs
+++ b/clippy_lints/src/dbg_macro.rs
@@ -5,7 +5,7 @@ use clippy_utils::{is_in_cfg_test, is_in_test_function};
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, Node};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::sym;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/default.rs b/clippy_lints/src/default.rs
index b325449c5a3..d8a070b785d 100644
--- a/clippy_lints/src/default.rs
+++ b/clippy_lints/src/default.rs
@@ -9,7 +9,7 @@ use rustc_hir::{Block, Expr, ExprKind, PatKind, QPath, Stmt, StmtKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
 use rustc_middle::ty::print::with_forced_trimmed_paths;
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::symbol::{Ident, Symbol};
 use rustc_span::{sym, Span};
 
diff --git a/clippy_lints/src/default_constructed_unit_structs.rs b/clippy_lints/src/default_constructed_unit_structs.rs
index b90d01b765a..9ce5acfbcc2 100644
--- a/clippy_lints/src/default_constructed_unit_structs.rs
+++ b/clippy_lints/src/default_constructed_unit_structs.rs
@@ -6,7 +6,7 @@ use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::sym;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/default_instead_of_iter_empty.rs b/clippy_lints/src/default_instead_of_iter_empty.rs
index 553b670fdb7..2472e2ee76f 100644
--- a/clippy_lints/src/default_instead_of_iter_empty.rs
+++ b/clippy_lints/src/default_instead_of_iter_empty.rs
@@ -4,7 +4,7 @@ use clippy_utils::source::snippet_with_context;
 use rustc_errors::Applicability;
 use rustc_hir::{def, Expr, ExprKind, GenericArg, QPath, TyKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::{sym, SyntaxContext};
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/default_numeric_fallback.rs b/clippy_lints/src/default_numeric_fallback.rs
index fb29703957d..64a924a776a 100644
--- a/clippy_lints/src/default_numeric_fallback.rs
+++ b/clippy_lints/src/default_numeric_fallback.rs
@@ -8,7 +8,7 @@ use rustc_hir::{Body, Expr, ExprKind, HirId, ItemKind, Lit, Node, Stmt, StmtKind
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::{self, FloatTy, IntTy, PolyFnSig, Ty};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use std::iter;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/default_union_representation.rs b/clippy_lints/src/default_union_representation.rs
index 8c6749a95fa..db01ff2cd22 100644
--- a/clippy_lints/src/default_union_representation.rs
+++ b/clippy_lints/src/default_union_representation.rs
@@ -3,7 +3,7 @@ use rustc_hir::{HirId, Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::layout::LayoutOf;
 use rustc_middle::ty::{self, FieldDef, GenericArg, List};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::sym;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index afca8850ac5..09cb8feac6a 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -17,7 +17,7 @@ use rustc_hir::{
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::adjustment::{Adjust, Adjustment, AutoBorrow, AutoBorrowMutability};
 use rustc_middle::ty::{self, ParamEnv, Ty, TyCtxt, TypeVisitableExt, TypeckResults};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::symbol::sym;
 use rustc_span::{Span, Symbol};
 
diff --git a/clippy_lints/src/derivable_impls.rs b/clippy_lints/src/derivable_impls.rs
index 9db56fa8ad0..53ef6d7e387 100644
--- a/clippy_lints/src/derivable_impls.rs
+++ b/clippy_lints/src/derivable_impls.rs
@@ -10,7 +10,7 @@ use rustc_hir::{
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::adjustment::{Adjust, PointerCoercion};
 use rustc_middle::ty::{self, Adt, AdtDef, GenericArgsRef, Ty, TypeckResults};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::sym;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/derive.rs b/clippy_lints/src/derive.rs
index 169c2a15db7..77f15aa776b 100644
--- a/clippy_lints/src/derive.rs
+++ b/clippy_lints/src/derive.rs
@@ -14,7 +14,7 @@ use rustc_middle::ty::{
     self, ClauseKind, GenericArgKind, GenericParamDefKind, ImplPolarity, ParamEnv, ToPredicate, TraitPredicate, Ty,
     TyCtxt,
 };
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::def_id::LocalDefId;
 use rustc_span::{sym, Span};
 
diff --git a/clippy_lints/src/disallowed_macros.rs b/clippy_lints/src/disallowed_macros.rs
index 324b5e0798e..656b3d9bfaf 100644
--- a/clippy_lints/src/disallowed_macros.rs
+++ b/clippy_lints/src/disallowed_macros.rs
@@ -6,7 +6,7 @@ use rustc_data_structures::fx::FxHashSet;
 use rustc_hir::def_id::DefIdMap;
 use rustc_hir::{Expr, ExprKind, ForeignItem, HirId, ImplItem, Item, Pat, Path, Stmt, TraitItem, Ty};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::{ExpnId, Span};
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/disallowed_methods.rs b/clippy_lints/src/disallowed_methods.rs
index d23aeebb5a8..1868d3cd391 100644
--- a/clippy_lints/src/disallowed_methods.rs
+++ b/clippy_lints/src/disallowed_methods.rs
@@ -4,7 +4,7 @@ use clippy_utils::{fn_def_id, get_parent_expr, path_def_id};
 use rustc_hir::def_id::DefIdMap;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/disallowed_names.rs b/clippy_lints/src/disallowed_names.rs
index a1dd4805b9c..09dad5554ad 100644
--- a/clippy_lints/src/disallowed_names.rs
+++ b/clippy_lints/src/disallowed_names.rs
@@ -3,7 +3,7 @@ use clippy_utils::is_test_module_or_function;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_hir::{Item, Pat, PatKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/disallowed_script_idents.rs b/clippy_lints/src/disallowed_script_idents.rs
index 96a7f0e4fde..d5205e65cef 100644
--- a/clippy_lints/src/disallowed_script_idents.rs
+++ b/clippy_lints/src/disallowed_script_idents.rs
@@ -2,7 +2,7 @@ use clippy_utils::diagnostics::span_lint;
 use rustc_ast::ast;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_lint::{EarlyContext, EarlyLintPass, Level, LintContext};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use unicode_script::{Script, UnicodeScript};
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/disallowed_types.rs b/clippy_lints/src/disallowed_types.rs
index 3578fb640fc..130f56b698f 100644
--- a/clippy_lints/src/disallowed_types.rs
+++ b/clippy_lints/src/disallowed_types.rs
@@ -5,7 +5,7 @@ use rustc_hir::def::Res;
 use rustc_hir::def_id::DefId;
 use rustc_hir::{Item, ItemKind, PolyTraitRef, PrimTy, Ty, TyKind, UseKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::Span;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/doc/mod.rs b/clippy_lints/src/doc/mod.rs
index 607af6ba905..18874b1cb8e 100644
--- a/clippy_lints/src/doc/mod.rs
+++ b/clippy_lints/src/doc/mod.rs
@@ -21,7 +21,7 @@ use rustc_middle::ty;
 use rustc_resolve::rustdoc::{
     add_doc_fragment, attrs_to_doc_fragments, main_body_opts, source_span_for_markdown_range, DocFragment,
 };
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::edition::Edition;
 use rustc_span::{sym, Span};
 use std::ops::Range;
diff --git a/clippy_lints/src/double_parens.rs b/clippy_lints/src/double_parens.rs
index 63f32173b05..b51bb7951b7 100644
--- a/clippy_lints/src/double_parens.rs
+++ b/clippy_lints/src/double_parens.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::span_lint;
 use rustc_ast::ast::{Expr, ExprKind};
 use rustc_lint::{EarlyContext, EarlyLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/drop_forget_ref.rs b/clippy_lints/src/drop_forget_ref.rs
index 177e04dfa6b..124d78fc4ff 100644
--- a/clippy_lints/src/drop_forget_ref.rs
+++ b/clippy_lints/src/drop_forget_ref.rs
@@ -3,7 +3,7 @@ use clippy_utils::ty::{is_copy, is_must_use_ty, is_type_lang_item};
 use clippy_utils::{get_parent_node, is_must_use_func_call};
 use rustc_hir::{Arm, Expr, ExprKind, LangItem, Node};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::sym;
 use std::borrow::Cow;
 
diff --git a/clippy_lints/src/duplicate_mod.rs b/clippy_lints/src/duplicate_mod.rs
index 7ff7068f0b0..471335c098f 100644
--- a/clippy_lints/src/duplicate_mod.rs
+++ b/clippy_lints/src/duplicate_mod.rs
@@ -2,7 +2,7 @@ use clippy_utils::diagnostics::span_lint_and_help;
 use rustc_ast::ast::{Crate, Inline, Item, ItemKind, ModKind};
 use rustc_errors::MultiSpan;
 use rustc_lint::{EarlyContext, EarlyLintPass, Level, LintContext};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::{FileName, Span};
 use std::collections::BTreeMap;
 use std::path::PathBuf;
diff --git a/clippy_lints/src/else_if_without_else.rs b/clippy_lints/src/else_if_without_else.rs
index 61db1c1abd1..47780cab9ed 100644
--- a/clippy_lints/src/else_if_without_else.rs
+++ b/clippy_lints/src/else_if_without_else.rs
@@ -4,7 +4,7 @@ use clippy_utils::diagnostics::span_lint_and_help;
 use rustc_ast::ast::{Expr, ExprKind};
 use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/empty_drop.rs b/clippy_lints/src/empty_drop.rs
index 17be95780cc..e97030cc8b6 100644
--- a/clippy_lints/src/empty_drop.rs
+++ b/clippy_lints/src/empty_drop.rs
@@ -3,7 +3,7 @@ use clippy_utils::peel_blocks;
 use rustc_errors::Applicability;
 use rustc_hir::{Body, ExprKind, Impl, ImplItemKind, Item, ItemKind, Node};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/empty_enum.rs b/clippy_lints/src/empty_enum.rs
index a5699727b5b..420888b6ccb 100644
--- a/clippy_lints/src/empty_enum.rs
+++ b/clippy_lints/src/empty_enum.rs
@@ -3,7 +3,7 @@
 use clippy_utils::diagnostics::span_lint_and_help;
 use rustc_hir::{Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/empty_structs_with_brackets.rs b/clippy_lints/src/empty_structs_with_brackets.rs
index 4e2a8b73c0a..3cf67b3ecbf 100644
--- a/clippy_lints/src/empty_structs_with_brackets.rs
+++ b/clippy_lints/src/empty_structs_with_brackets.rs
@@ -4,7 +4,7 @@ use rustc_ast::ast::{Item, ItemKind, VariantData};
 use rustc_errors::Applicability;
 use rustc_lexer::TokenKind;
 use rustc_lint::{EarlyContext, EarlyLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::Span;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/endian_bytes.rs b/clippy_lints/src/endian_bytes.rs
index 6f5a0cb8801..b8a817e21b1 100644
--- a/clippy_lints/src/endian_bytes.rs
+++ b/clippy_lints/src/endian_bytes.rs
@@ -5,7 +5,7 @@ use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::Ty;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::Symbol;
 use std::borrow::Cow;
 
diff --git a/clippy_lints/src/entry.rs b/clippy_lints/src/entry.rs
index 3e3c62e85d0..ce0a1dfdc61 100644
--- a/clippy_lints/src/entry.rs
+++ b/clippy_lints/src/entry.rs
@@ -10,7 +10,7 @@ use rustc_hir::hir_id::HirIdSet;
 use rustc_hir::intravisit::{walk_expr, Visitor};
 use rustc_hir::{Block, Expr, ExprKind, Guard, HirId, Let, Pat, Stmt, StmtKind, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::{Span, SyntaxContext, DUMMY_SP};
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/enum_clike.rs b/clippy_lints/src/enum_clike.rs
index 003b5fc7261..30eb643c42e 100644
--- a/clippy_lints/src/enum_clike.rs
+++ b/clippy_lints/src/enum_clike.rs
@@ -7,7 +7,7 @@ use rustc_hir::{Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::util::IntTypeExt;
 use rustc_middle::ty::{self, IntTy, UintTy};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/equatable_if_let.rs b/clippy_lints/src/equatable_if_let.rs
index 575fead5bf3..9ea52750c84 100644
--- a/clippy_lints/src/equatable_if_let.rs
+++ b/clippy_lints/src/equatable_if_let.rs
@@ -6,7 +6,7 @@ use rustc_hir::{Expr, ExprKind, Pat, PatKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::Ty;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/error_impl_error.rs b/clippy_lints/src/error_impl_error.rs
index bc878555c66..c077bdd788c 100644
--- a/clippy_lints/src/error_impl_error.rs
+++ b/clippy_lints/src/error_impl_error.rs
@@ -5,7 +5,7 @@ use rustc_hir::def_id::{DefId, LocalDefId};
 use rustc_hir::{Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::Visibility;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::sym;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/escape.rs b/clippy_lints/src/escape.rs
index 2f22f344a21..546b228b1b0 100644
--- a/clippy_lints/src/escape.rs
+++ b/clippy_lints/src/escape.rs
@@ -6,7 +6,7 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::mir::FakeReadCause;
 use rustc_middle::ty::layout::LayoutOf;
 use rustc_middle::ty::{self, TraitRef, Ty};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::def_id::LocalDefId;
 use rustc_span::symbol::kw;
 use rustc_span::Span;
diff --git a/clippy_lints/src/eta_reduction.rs b/clippy_lints/src/eta_reduction.rs
index 241b51eeca0..450cee4007c 100644
--- a/clippy_lints/src/eta_reduction.rs
+++ b/clippy_lints/src/eta_reduction.rs
@@ -13,7 +13,7 @@ use rustc_middle::ty::{
     self, Binder, ClosureArgs, ClosureKind, EarlyBinder, FnSig, GenericArg, GenericArgKind, GenericArgsRef,
     ImplPolarity, List, Region, RegionKind, Ty, TypeVisitableExt, TypeckResults,
 };
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::symbol::sym;
 use rustc_target::spec::abi::Abi;
 use rustc_trait_selection::traits::error_reporting::InferCtxtExt as _;
diff --git a/clippy_lints/src/excessive_bools.rs b/clippy_lints/src/excessive_bools.rs
index 1d18e194d15..815352010f7 100644
--- a/clippy_lints/src/excessive_bools.rs
+++ b/clippy_lints/src/excessive_bools.rs
@@ -3,7 +3,7 @@ use clippy_utils::{get_parent_as_impl, has_repr_attr, is_bool};
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::{Body, FnDecl, Item, ItemKind, TraitFn, TraitItem, TraitItemKind, Ty};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::def_id::LocalDefId;
 use rustc_span::Span;
 use rustc_target::spec::abi::Abi;
diff --git a/clippy_lints/src/excessive_nesting.rs b/clippy_lints/src/excessive_nesting.rs
index 83480fc5eeb..4b0d11c5d1b 100644
--- a/clippy_lints/src/excessive_nesting.rs
+++ b/clippy_lints/src/excessive_nesting.rs
@@ -5,7 +5,7 @@ use rustc_ast::visit::{walk_block, walk_item, Visitor};
 use rustc_ast::{Block, Crate, Inline, Item, ItemKind, ModKind, NodeId};
 use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::Span;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/exhaustive_items.rs b/clippy_lints/src/exhaustive_items.rs
index b7e62e082e4..3a621d967f4 100644
--- a/clippy_lints/src/exhaustive_items.rs
+++ b/clippy_lints/src/exhaustive_items.rs
@@ -3,7 +3,7 @@ use clippy_utils::source::indent_of;
 use rustc_errors::Applicability;
 use rustc_hir::{Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::sym;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/exit.rs b/clippy_lints/src/exit.rs
index 07d025f68c3..a974c10bc7d 100644
--- a/clippy_lints/src/exit.rs
+++ b/clippy_lints/src/exit.rs
@@ -2,7 +2,7 @@ use clippy_utils::diagnostics::span_lint;
 use clippy_utils::is_entrypoint_fn;
 use rustc_hir::{Expr, ExprKind, Item, ItemKind, Node};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::sym;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/explicit_write.rs b/clippy_lints/src/explicit_write.rs
index 08cb2114a2b..4e2e1d1724a 100644
--- a/clippy_lints/src/explicit_write.rs
+++ b/clippy_lints/src/explicit_write.rs
@@ -6,7 +6,7 @@ use rustc_errors::Applicability;
 use rustc_hir::def::Res;
 use rustc_hir::{BindingAnnotation, Block, BlockCheckMode, Expr, ExprKind, Node, PatKind, QPath, Stmt, StmtKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::{sym, ExpnId};
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/extra_unused_type_parameters.rs b/clippy_lints/src/extra_unused_type_parameters.rs
index d6c746901fc..538d29eb43d 100644
--- a/clippy_lints/src/extra_unused_type_parameters.rs
+++ b/clippy_lints/src/extra_unused_type_parameters.rs
@@ -10,7 +10,7 @@ use rustc_hir::{
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::hir::nested_filter;
 use rustc_middle::lint::in_external_macro;
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::def_id::{DefId, LocalDefId};
 use rustc_span::Span;
 
diff --git a/clippy_lints/src/fallible_impl_from.rs b/clippy_lints/src/fallible_impl_from.rs
index 753f75d83a8..0446943321a 100644
--- a/clippy_lints/src/fallible_impl_from.rs
+++ b/clippy_lints/src/fallible_impl_from.rs
@@ -5,7 +5,7 @@ use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::{sym, Span};
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/float_literal.rs b/clippy_lints/src/float_literal.rs
index 663c33e8cee..38a16c5c8b0 100644
--- a/clippy_lints/src/float_literal.rs
+++ b/clippy_lints/src/float_literal.rs
@@ -5,7 +5,7 @@ use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{self, FloatTy};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use std::fmt;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/floating_point_arithmetic.rs b/clippy_lints/src/floating_point_arithmetic.rs
index d522873472b..aaf1fee3f00 100644
--- a/clippy_lints/src/floating_point_arithmetic.rs
+++ b/clippy_lints/src/floating_point_arithmetic.rs
@@ -8,7 +8,7 @@ use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind, PathSegment, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::source_map::Spanned;
 
 use rustc_ast::ast;
diff --git a/clippy_lints/src/format.rs b/clippy_lints/src/format.rs
index 18ed05c1ca6..8a0cd155d21 100644
--- a/clippy_lints/src/format.rs
+++ b/clippy_lints/src/format.rs
@@ -7,7 +7,7 @@ use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::{sym, Span};
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/format_args.rs b/clippy_lints/src/format_args.rs
index c9868255dcf..8af321e4d55 100644
--- a/clippy_lints/src/format_args.rs
+++ b/clippy_lints/src/format_args.rs
@@ -19,7 +19,7 @@ use rustc_hir::{Expr, ExprKind, LangItem};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::ty::adjustment::{Adjust, Adjustment};
 use rustc_middle::ty::Ty;
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::def_id::DefId;
 use rustc_span::edition::Edition::Edition2021;
 use rustc_span::{sym, Span, Symbol};
diff --git a/clippy_lints/src/format_impl.rs b/clippy_lints/src/format_impl.rs
index ec87629a344..9360eb1fa91 100644
--- a/clippy_lints/src/format_impl.rs
+++ b/clippy_lints/src/format_impl.rs
@@ -5,7 +5,7 @@ use rustc_ast::{FormatArgsPiece, FormatTrait};
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, Impl, ImplItem, ImplItemKind, QPath};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::symbol::kw;
 use rustc_span::{sym, Span, Symbol};
 
diff --git a/clippy_lints/src/format_push_string.rs b/clippy_lints/src/format_push_string.rs
index ac45f5aedfa..3901dd984f9 100644
--- a/clippy_lints/src/format_push_string.rs
+++ b/clippy_lints/src/format_push_string.rs
@@ -3,7 +3,7 @@ use clippy_utils::ty::is_type_lang_item;
 use clippy_utils::{higher, match_def_path, paths};
 use rustc_hir::{BinOpKind, Expr, ExprKind, LangItem, MatchSource};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::sym;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/formatting.rs b/clippy_lints/src/formatting.rs
index 70892ce608f..cdb593d9b0c 100644
--- a/clippy_lints/src/formatting.rs
+++ b/clippy_lints/src/formatting.rs
@@ -4,7 +4,7 @@ use clippy_utils::source::snippet_opt;
 use rustc_ast::ast::{BinOpKind, Block, Expr, ExprKind, StmtKind, UnOp};
 use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::Span;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/four_forward_slashes.rs b/clippy_lints/src/four_forward_slashes.rs
index 69bc0b726fc..0599e08e6c0 100644
--- a/clippy_lints/src/four_forward_slashes.rs
+++ b/clippy_lints/src/four_forward_slashes.rs
@@ -2,7 +2,7 @@ use clippy_utils::diagnostics::span_lint_and_then;
 use rustc_errors::Applicability;
 use rustc_hir::Item;
 use rustc_lint::{LateContext, LateLintPass, LintContext};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::Span;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/from_over_into.rs b/clippy_lints/src/from_over_into.rs
index 5477532bb95..fa1f98ba013 100644
--- a/clippy_lints/src/from_over_into.rs
+++ b/clippy_lints/src/from_over_into.rs
@@ -12,7 +12,7 @@ use rustc_hir::{
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::nested_filter::OnlyBodies;
 use rustc_middle::ty;
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::symbol::{kw, sym};
 use rustc_span::{Span, Symbol};
 
diff --git a/clippy_lints/src/from_raw_with_void_ptr.rs b/clippy_lints/src/from_raw_with_void_ptr.rs
index d9138d48b2c..c8d10dc4b92 100644
--- a/clippy_lints/src/from_raw_with_void_ptr.rs
+++ b/clippy_lints/src/from_raw_with_void_ptr.rs
@@ -5,7 +5,7 @@ use rustc_hir::def_id::DefId;
 use rustc_hir::{Expr, ExprKind, QPath};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{RawPtr, TypeAndMut};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::sym;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/from_str_radix_10.rs b/clippy_lints/src/from_str_radix_10.rs
index 18d11ccc0b5..633ed96d6a6 100644
--- a/clippy_lints/src/from_str_radix_10.rs
+++ b/clippy_lints/src/from_str_radix_10.rs
@@ -6,7 +6,7 @@ use rustc_errors::Applicability;
 use rustc_hir::{def, Expr, ExprKind, LangItem, PrimTy, QPath, TyKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::Ty;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::symbol::sym;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/functions/mod.rs b/clippy_lints/src/functions/mod.rs
index 3f5cceec70e..9cc958db645 100644
--- a/clippy_lints/src/functions/mod.rs
+++ b/clippy_lints/src/functions/mod.rs
@@ -9,7 +9,7 @@ mod too_many_lines;
 use rustc_hir as hir;
 use rustc_hir::intravisit;
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::def_id::LocalDefId;
 use rustc_span::Span;
 
diff --git a/clippy_lints/src/future_not_send.rs b/clippy_lints/src/future_not_send.rs
index eee5b7540ba..2c162baad1e 100644
--- a/clippy_lints/src/future_not_send.rs
+++ b/clippy_lints/src/future_not_send.rs
@@ -5,7 +5,7 @@ use rustc_hir::{Body, FnDecl};
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{self, AliasTy, ClauseKind, PredicateKind};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::def_id::LocalDefId;
 use rustc_span::{sym, Span};
 use rustc_trait_selection::traits::error_reporting::suggestions::TypeErrCtxtExt;
diff --git a/clippy_lints/src/if_let_mutex.rs b/clippy_lints/src/if_let_mutex.rs
index 644b9cdaeb2..5e354209cbf 100644
--- a/clippy_lints/src/if_let_mutex.rs
+++ b/clippy_lints/src/if_let_mutex.rs
@@ -5,7 +5,7 @@ use rustc_errors::Diagnostic;
 use rustc_hir::intravisit::{self as visit, Visitor};
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::sym;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/if_not_else.rs b/clippy_lints/src/if_not_else.rs
index cae561f7802..4dc1ff83771 100644
--- a/clippy_lints/src/if_not_else.rs
+++ b/clippy_lints/src/if_not_else.rs
@@ -6,7 +6,7 @@ use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::is_else_clause;
 use rustc_hir::{BinOpKind, Expr, ExprKind, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/if_then_some_else_none.rs b/clippy_lints/src/if_then_some_else_none.rs
index 66c10ab228f..cd6c46a71a8 100644
--- a/clippy_lints/src/if_then_some_else_none.rs
+++ b/clippy_lints/src/if_then_some_else_none.rs
@@ -9,7 +9,7 @@ use rustc_hir::LangItem::{OptionNone, OptionSome};
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/ignored_unit_patterns.rs b/clippy_lints/src/ignored_unit_patterns.rs
index 76bdfb94eb8..0a2fd0c663e 100644
--- a/clippy_lints/src/ignored_unit_patterns.rs
+++ b/clippy_lints/src/ignored_unit_patterns.rs
@@ -3,7 +3,7 @@ use hir::{Node, PatKind};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/impl_hash_with_borrow_str_and_bytes.rs b/clippy_lints/src/impl_hash_with_borrow_str_and_bytes.rs
index 9374582b54b..940adbae428 100644
--- a/clippy_lints/src/impl_hash_with_borrow_str_and_bytes.rs
+++ b/clippy_lints/src/impl_hash_with_borrow_str_and_bytes.rs
@@ -4,7 +4,7 @@ use rustc_hir::def::{DefKind, Res};
 use rustc_hir::{Item, ItemKind, Path, TraitRef};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::Ty;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::symbol::sym;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/implicit_hasher.rs b/clippy_lints/src/implicit_hasher.rs
index 6594636d884..43eb6a9b838 100644
--- a/clippy_lints/src/implicit_hasher.rs
+++ b/clippy_lints/src/implicit_hasher.rs
@@ -9,7 +9,7 @@ use rustc_hir_analysis::hir_ty_to_ty;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::nested_filter;
 use rustc_middle::ty::{Ty, TypeckResults};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::symbol::sym;
 use rustc_span::Span;
 
diff --git a/clippy_lints/src/implicit_return.rs b/clippy_lints/src/implicit_return.rs
index c6bcf3ba40c..d68c5c4bac6 100644
--- a/clippy_lints/src/implicit_return.rs
+++ b/clippy_lints/src/implicit_return.rs
@@ -8,7 +8,7 @@ use rustc_hir::intravisit::FnKind;
 use rustc_hir::{Block, Body, Expr, ExprKind, FnDecl, FnRetTy, HirId};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::def_id::LocalDefId;
 use rustc_span::{Span, SyntaxContext};
 
diff --git a/clippy_lints/src/implicit_saturating_add.rs b/clippy_lints/src/implicit_saturating_add.rs
index f2fac9a29cb..cc74844f294 100644
--- a/clippy_lints/src/implicit_saturating_add.rs
+++ b/clippy_lints/src/implicit_saturating_add.rs
@@ -7,7 +7,7 @@ use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Block, Expr, ExprKind, Stmt, StmtKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{Int, IntTy, Ty, Uint, UintTy};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/implicit_saturating_sub.rs b/clippy_lints/src/implicit_saturating_sub.rs
index fc66f86ae86..81df1a889c7 100644
--- a/clippy_lints/src/implicit_saturating_sub.rs
+++ b/clippy_lints/src/implicit_saturating_sub.rs
@@ -4,7 +4,7 @@ use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind, QPath};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/implied_bounds_in_impls.rs b/clippy_lints/src/implied_bounds_in_impls.rs
index 232d8eeb11b..589fcfbf1ea 100644
--- a/clippy_lints/src/implied_bounds_in_impls.rs
+++ b/clippy_lints/src/implied_bounds_in_impls.rs
@@ -10,7 +10,7 @@ use rustc_hir::{
 use rustc_hir_analysis::hir_ty_to_ty;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{self, ClauseKind, Generics, Ty, TyCtxt};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::Span;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/inconsistent_struct_constructor.rs b/clippy_lints/src/inconsistent_struct_constructor.rs
index f6e1281a291..1075975f0a2 100644
--- a/clippy_lints/src/inconsistent_struct_constructor.rs
+++ b/clippy_lints/src/inconsistent_struct_constructor.rs
@@ -4,7 +4,7 @@ use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::Applicability;
 use rustc_hir::{self as hir, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::symbol::Symbol;
 use std::fmt::{self, Write as _};
 
diff --git a/clippy_lints/src/index_refutable_slice.rs b/clippy_lints/src/index_refutable_slice.rs
index fa6536db796..b6f9d8b81f8 100644
--- a/clippy_lints/src/index_refutable_slice.rs
+++ b/clippy_lints/src/index_refutable_slice.rs
@@ -11,7 +11,7 @@ use rustc_hir::intravisit::{self, Visitor};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::nested_filter;
 use rustc_middle::ty;
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::symbol::Ident;
 use rustc_span::Span;
 
diff --git a/clippy_lints/src/indexing_slicing.rs b/clippy_lints/src/indexing_slicing.rs
index 1ce7d85d382..0ae03d101ab 100644
--- a/clippy_lints/src/indexing_slicing.rs
+++ b/clippy_lints/src/indexing_slicing.rs
@@ -7,7 +7,7 @@ use rustc_ast::ast::RangeLimits;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/infinite_iter.rs b/clippy_lints/src/infinite_iter.rs
index e9c53671a93..9ad02735878 100644
--- a/clippy_lints/src/infinite_iter.rs
+++ b/clippy_lints/src/infinite_iter.rs
@@ -3,7 +3,7 @@ use clippy_utils::higher;
 use clippy_utils::ty::{implements_trait, is_type_diagnostic_item};
 use rustc_hir::{BorrowKind, Closure, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::symbol::{sym, Symbol};
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/inherent_impl.rs b/clippy_lints/src/inherent_impl.rs
index a61a6416193..35b45a5b505 100644
--- a/clippy_lints/src/inherent_impl.rs
+++ b/clippy_lints/src/inherent_impl.rs
@@ -6,7 +6,7 @@ use rustc_data_structures::fx::FxHashMap;
 use rustc_hir::def_id::LocalDefId;
 use rustc_hir::{Item, ItemKind, Node};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::Span;
 use std::collections::hash_map::Entry;
 
diff --git a/clippy_lints/src/inherent_to_string.rs b/clippy_lints/src/inherent_to_string.rs
index fe5eb5ccac5..ca2ac60306b 100644
--- a/clippy_lints/src/inherent_to_string.rs
+++ b/clippy_lints/src/inherent_to_string.rs
@@ -3,7 +3,7 @@ use clippy_utils::ty::{implements_trait, is_type_lang_item};
 use clippy_utils::{return_ty, trait_ref_of_method};
 use rustc_hir::{GenericParamKind, ImplItem, ImplItemKind, LangItem, Unsafety};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::sym;
 use rustc_target::spec::abi::Abi;
 
diff --git a/clippy_lints/src/init_numbered_fields.rs b/clippy_lints/src/init_numbered_fields.rs
index 269311a67d6..e486563808a 100644
--- a/clippy_lints/src/init_numbered_fields.rs
+++ b/clippy_lints/src/init_numbered_fields.rs
@@ -4,7 +4,7 @@ use rustc_errors::Applicability;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use std::borrow::Cow;
 use std::cmp::Reverse;
 use std::collections::BinaryHeap;
diff --git a/clippy_lints/src/inline_fn_without_body.rs b/clippy_lints/src/inline_fn_without_body.rs
index 899126565f7..bc236c5c71f 100644
--- a/clippy_lints/src/inline_fn_without_body.rs
+++ b/clippy_lints/src/inline_fn_without_body.rs
@@ -6,7 +6,7 @@ use rustc_ast::ast::Attribute;
 use rustc_errors::Applicability;
 use rustc_hir::{TraitFn, TraitItem, TraitItemKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::{sym, Symbol};
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/instant_subtraction.rs b/clippy_lints/src/instant_subtraction.rs
index 8e84c73666f..655f4b82aa4 100644
--- a/clippy_lints/src/instant_subtraction.rs
+++ b/clippy_lints/src/instant_subtraction.rs
@@ -6,7 +6,7 @@ use clippy_utils::ty;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::source_map::Spanned;
 use rustc_span::sym;
 
diff --git a/clippy_lints/src/int_plus_one.rs b/clippy_lints/src/int_plus_one.rs
index 9ffcee07d28..b8e0eef7c7e 100644
--- a/clippy_lints/src/int_plus_one.rs
+++ b/clippy_lints/src/int_plus_one.rs
@@ -6,7 +6,7 @@ use rustc_ast::ast::{BinOpKind, Expr, ExprKind, LitKind};
 use rustc_ast::token;
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/invalid_upcast_comparisons.rs b/clippy_lints/src/invalid_upcast_comparisons.rs
index de82935e66b..8bcd9b532bd 100644
--- a/clippy_lints/src/invalid_upcast_comparisons.rs
+++ b/clippy_lints/src/invalid_upcast_comparisons.rs
@@ -2,7 +2,7 @@ use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::layout::LayoutOf;
 use rustc_middle::ty::{self, IntTy, UintTy};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::Span;
 
 use clippy_utils::comparisons;
diff --git a/clippy_lints/src/item_name_repetitions.rs b/clippy_lints/src/item_name_repetitions.rs
index 2b131d27b7b..b6aacba2517 100644
--- a/clippy_lints/src/item_name_repetitions.rs
+++ b/clippy_lints/src/item_name_repetitions.rs
@@ -6,7 +6,7 @@ use clippy_utils::source::is_present_in_source;
 use clippy_utils::str_utils::{camel_case_split, count_match_end, count_match_start, to_camel_case, to_snake_case};
 use rustc_hir::{EnumDef, FieldDef, Item, ItemKind, OwnerId, Variant, VariantData};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::symbol::Symbol;
 use rustc_span::Span;
 
diff --git a/clippy_lints/src/items_after_statements.rs b/clippy_lints/src/items_after_statements.rs
index 9605d76fbf0..39223c20470 100644
--- a/clippy_lints/src/items_after_statements.rs
+++ b/clippy_lints/src/items_after_statements.rs
@@ -4,7 +4,7 @@ use clippy_utils::diagnostics::span_lint_hir;
 use rustc_hir::{Block, ItemKind, StmtKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/items_after_test_module.rs b/clippy_lints/src/items_after_test_module.rs
index 35e01862cee..3614fb8cc96 100644
--- a/clippy_lints/src/items_after_test_module.rs
+++ b/clippy_lints/src/items_after_test_module.rs
@@ -4,7 +4,7 @@ use clippy_utils::{fulfill_or_allowed, is_cfg_test, is_from_proc_macro};
 use rustc_errors::{Applicability, SuggestionStyle};
 use rustc_hir::{HirId, Item, ItemKind, Mod};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::hygiene::AstPass;
 use rustc_span::{sym, ExpnKind};
 
diff --git a/clippy_lints/src/iter_not_returning_iterator.rs b/clippy_lints/src/iter_not_returning_iterator.rs
index 505aadd1a11..00ddadbaa4f 100644
--- a/clippy_lints/src/iter_not_returning_iterator.rs
+++ b/clippy_lints/src/iter_not_returning_iterator.rs
@@ -4,7 +4,7 @@ use clippy_utils::ty::implements_trait;
 use rustc_hir::def_id::LocalDefId;
 use rustc_hir::{FnSig, ImplItem, ImplItemKind, Item, ItemKind, Node, TraitItem, TraitItemKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::symbol::sym;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/iter_over_hash_type.rs b/clippy_lints/src/iter_over_hash_type.rs
index 7755adc4c1d..8110c1970d9 100644
--- a/clippy_lints/src/iter_over_hash_type.rs
+++ b/clippy_lints/src/iter_over_hash_type.rs
@@ -7,7 +7,7 @@ use clippy_utils::paths::{
 };
 use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::sym;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/iter_without_into_iter.rs b/clippy_lints/src/iter_without_into_iter.rs
index 3c291f25590..3a5756482a1 100644
--- a/clippy_lints/src/iter_without_into_iter.rs
+++ b/clippy_lints/src/iter_without_into_iter.rs
@@ -7,7 +7,7 @@ use rustc_errors::Applicability;
 use rustc_hir::{FnRetTy, ImplItemKind, ImplicitSelfKind, ItemKind, TyKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{self, Ty};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::{sym, Symbol};
 use std::iter;
 
diff --git a/clippy_lints/src/large_const_arrays.rs b/clippy_lints/src/large_const_arrays.rs
index 7db088f986f..b561054b582 100644
--- a/clippy_lints/src/large_const_arrays.rs
+++ b/clippy_lints/src/large_const_arrays.rs
@@ -4,7 +4,7 @@ use rustc_hir::{Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::layout::LayoutOf;
 use rustc_middle::ty::{self, ConstKind};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::{BytePos, Pos, Span};
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/large_enum_variant.rs b/clippy_lints/src/large_enum_variant.rs
index 0bf9b8718cd..6feb1885576 100644
--- a/clippy_lints/src/large_enum_variant.rs
+++ b/clippy_lints/src/large_enum_variant.rs
@@ -8,7 +8,7 @@ use rustc_hir::{Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::{Adt, Ty};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::Span;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/large_futures.rs b/clippy_lints/src/large_futures.rs
index 26a7278524e..eb7570e9b44 100644
--- a/clippy_lints/src/large_futures.rs
+++ b/clippy_lints/src/large_futures.rs
@@ -4,7 +4,7 @@ use clippy_utils::ty::implements_trait;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, LangItem, MatchSource, QPath};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_target::abi::Size;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/large_include_file.rs b/clippy_lints/src/large_include_file.rs
index 902b72ba5e4..1b5981ecc28 100644
--- a/clippy_lints/src/large_include_file.rs
+++ b/clippy_lints/src/large_include_file.rs
@@ -4,7 +4,7 @@ use clippy_utils::macros::root_macro_call_first_node;
 use rustc_ast::LitKind;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::sym;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/large_stack_arrays.rs b/clippy_lints/src/large_stack_arrays.rs
index 5e312ab7240..fd33ba91bfd 100644
--- a/clippy_lints/src/large_stack_arrays.rs
+++ b/clippy_lints/src/large_stack_arrays.rs
@@ -4,7 +4,7 @@ use rustc_hir::{Expr, ExprKind, Item, ItemKind, Node};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::layout::LayoutOf;
 use rustc_middle::ty::{self, ConstKind};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/large_stack_frames.rs b/clippy_lints/src/large_stack_frames.rs
index 33636eb687f..b397180a69c 100644
--- a/clippy_lints/src/large_stack_frames.rs
+++ b/clippy_lints/src/large_stack_frames.rs
@@ -6,7 +6,7 @@ use rustc_hir::def_id::LocalDefId;
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::{Body, FnDecl};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::Span;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/len_zero.rs b/clippy_lints/src/len_zero.rs
index 6fc14dd8941..08819b9f541 100644
--- a/clippy_lints/src/len_zero.rs
+++ b/clippy_lints/src/len_zero.rs
@@ -13,7 +13,7 @@ use rustc_hir::{
 };
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{self, AssocKind, FnSig, Ty};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::source_map::Spanned;
 use rustc_span::symbol::sym;
 use rustc_span::{Span, Symbol};
diff --git a/clippy_lints/src/let_if_seq.rs b/clippy_lints/src/let_if_seq.rs
index da269ec61ff..270162ae771 100644
--- a/clippy_lints/src/let_if_seq.rs
+++ b/clippy_lints/src/let_if_seq.rs
@@ -6,7 +6,7 @@ use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_hir::{BindingAnnotation, Mutability};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/let_underscore.rs b/clippy_lints/src/let_underscore.rs
index 04f23a213f2..606c2ed72be 100644
--- a/clippy_lints/src/let_underscore.rs
+++ b/clippy_lints/src/let_underscore.rs
@@ -5,7 +5,7 @@ use rustc_hir::{Local, PatKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::{GenericArgKind, IsSuggestable};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::{BytePos, Span};
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/let_with_type_underscore.rs b/clippy_lints/src/let_with_type_underscore.rs
index d4f410de957..5f3f9b43f45 100644
--- a/clippy_lints/src/let_with_type_underscore.rs
+++ b/clippy_lints/src/let_with_type_underscore.rs
@@ -3,7 +3,7 @@ use clippy_utils::source::snippet;
 use rustc_hir::{Local, TyKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::lint::in_external_macro;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/lifetimes.rs b/clippy_lints/src/lifetimes.rs
index bb0edec3373..17ca48683b3 100644
--- a/clippy_lints/src/lifetimes.rs
+++ b/clippy_lints/src/lifetimes.rs
@@ -18,7 +18,7 @@ use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::hir::map::Map;
 use rustc_middle::hir::nested_filter as middle_nested_filter;
 use rustc_middle::lint::in_external_macro;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::def_id::LocalDefId;
 use rustc_span::symbol::{kw, Ident, Symbol};
 use rustc_span::Span;
diff --git a/clippy_lints/src/lines_filter_map_ok.rs b/clippy_lints/src/lines_filter_map_ok.rs
index 00ca553445f..8a0955147bb 100644
--- a/clippy_lints/src/lines_filter_map_ok.rs
+++ b/clippy_lints/src/lines_filter_map_ok.rs
@@ -4,7 +4,7 @@ use clippy_utils::{is_diag_item_method, is_trait_method, match_def_path, path_to
 use rustc_errors::Applicability;
 use rustc_hir::{Body, Closure, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::sym;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/literal_representation.rs b/clippy_lints/src/literal_representation.rs
index 8f34a9b1fed..f33151cf4c5 100644
--- a/clippy_lints/src/literal_representation.rs
+++ b/clippy_lints/src/literal_representation.rs
@@ -9,7 +9,7 @@ use rustc_ast::token;
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::Span;
 use std::iter;
 
diff --git a/clippy_lints/src/loops/mod.rs b/clippy_lints/src/loops/mod.rs
index 67c80fb8387..892336878c7 100644
--- a/clippy_lints/src/loops/mod.rs
+++ b/clippy_lints/src/loops/mod.rs
@@ -24,7 +24,7 @@ use clippy_config::msrvs::Msrv;
 use clippy_utils::higher;
 use rustc_hir::{Expr, ExprKind, LoopSource, Pat};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::Span;
 use utils::{make_iterator_snippet, IncrementVisitor, InitializeVisitor};
 
diff --git a/clippy_lints/src/macro_use.rs b/clippy_lints/src/macro_use.rs
index 2744b0ca416..aea973bd249 100644
--- a/clippy_lints/src/macro_use.rs
+++ b/clippy_lints/src/macro_use.rs
@@ -6,7 +6,7 @@ use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass, LintContext};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::edition::Edition;
 use rustc_span::{sym, Span};
 use std::collections::BTreeMap;
diff --git a/clippy_lints/src/main_recursion.rs b/clippy_lints/src/main_recursion.rs
index ea1d25d80e1..a381b35cf2e 100644
--- a/clippy_lints/src/main_recursion.rs
+++ b/clippy_lints/src/main_recursion.rs
@@ -3,7 +3,7 @@ use clippy_utils::source::snippet;
 use clippy_utils::{is_entrypoint_fn, is_no_std_crate};
 use rustc_hir::{Expr, ExprKind, QPath};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/manual_assert.rs b/clippy_lints/src/manual_assert.rs
index 9a3da975f83..4f6a2cf017c 100644
--- a/clippy_lints/src/manual_assert.rs
+++ b/clippy_lints/src/manual_assert.rs
@@ -5,7 +5,7 @@ use clippy_utils::{is_else_clause, peel_blocks_with_stmt, span_extract_comment,
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::sym;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/manual_async_fn.rs b/clippy_lints/src/manual_async_fn.rs
index a5d91c949bc..41599f39d3a 100644
--- a/clippy_lints/src/manual_async_fn.rs
+++ b/clippy_lints/src/manual_async_fn.rs
@@ -7,7 +7,7 @@ use rustc_hir::{
     ImplItem, Item, ItemKind, LifetimeName, Node, Term, TraitRef, Ty, TyKind, TypeBindingKind,
 };
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::def_id::LocalDefId;
 use rustc_span::{sym, Span};
 
diff --git a/clippy_lints/src/manual_bits.rs b/clippy_lints/src/manual_bits.rs
index 69c65cf305c..96c652283da 100644
--- a/clippy_lints/src/manual_bits.rs
+++ b/clippy_lints/src/manual_bits.rs
@@ -8,7 +8,7 @@ use rustc_hir::{BinOpKind, Expr, ExprKind, GenericArg, QPath};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::{self, Ty};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::sym;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/manual_clamp.rs b/clippy_lints/src/manual_clamp.rs
index 09c90e38e11..385fe387a31 100644
--- a/clippy_lints/src/manual_clamp.rs
+++ b/clippy_lints/src/manual_clamp.rs
@@ -14,7 +14,7 @@ use rustc_hir::def::Res;
 use rustc_hir::{Arm, BinOpKind, Block, Expr, ExprKind, Guard, HirId, PatKind, PathSegment, PrimTy, QPath, StmtKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::Ty;
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::symbol::sym;
 use rustc_span::Span;
 use std::ops::Deref;
diff --git a/clippy_lints/src/manual_float_methods.rs b/clippy_lints/src/manual_float_methods.rs
index 0c4101ceb6b..31cfb41640d 100644
--- a/clippy_lints/src/manual_float_methods.rs
+++ b/clippy_lints/src/manual_float_methods.rs
@@ -6,7 +6,7 @@ use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Constness, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass, Lint, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/manual_hash_one.rs b/clippy_lints/src/manual_hash_one.rs
index 472b4eb9006..252b3a83a18 100644
--- a/clippy_lints/src/manual_hash_one.rs
+++ b/clippy_lints/src/manual_hash_one.rs
@@ -6,7 +6,7 @@ use clippy_utils::{is_trait_method, path_to_local_id};
 use rustc_errors::Applicability;
 use rustc_hir::{BindingAnnotation, ExprKind, Local, Node, PatKind, StmtKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::sym;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/manual_is_ascii_check.rs b/clippy_lints/src/manual_is_ascii_check.rs
index 468f4170732..e433c5a3b32 100644
--- a/clippy_lints/src/manual_is_ascii_check.rs
+++ b/clippy_lints/src/manual_is_ascii_check.rs
@@ -8,7 +8,7 @@ use rustc_ast::LitKind::{Byte, Char};
 use rustc_errors::Applicability;
 use rustc_hir::{BorrowKind, Expr, ExprKind, PatKind, RangeEnd};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::def_id::DefId;
 use rustc_span::{sym, Span};
 
diff --git a/clippy_lints/src/manual_let_else.rs b/clippy_lints/src/manual_let_else.rs
index 01eccb56a0a..92dc4d57ab1 100644
--- a/clippy_lints/src/manual_let_else.rs
+++ b/clippy_lints/src/manual_let_else.rs
@@ -11,7 +11,7 @@ use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, MatchSource, Pat, PatKind, QPath, Stmt, StmtKind};
 use rustc_lint::{LateContext, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_session::declare_tool_lint;
+
 use rustc_span::symbol::{sym, Symbol};
 use rustc_span::Span;
 use std::slice;
diff --git a/clippy_lints/src/manual_main_separator_str.rs b/clippy_lints/src/manual_main_separator_str.rs
index 23f47c86fcc..5732bdda7f2 100644
--- a/clippy_lints/src/manual_main_separator_str.rs
+++ b/clippy_lints/src/manual_main_separator_str.rs
@@ -6,7 +6,7 @@ use rustc_hir::def::{DefKind, Res};
 use rustc_hir::{Expr, ExprKind, Mutability, QPath};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::sym;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/manual_non_exhaustive.rs b/clippy_lints/src/manual_non_exhaustive.rs
index fb30e371f59..7e60764115e 100644
--- a/clippy_lints/src/manual_non_exhaustive.rs
+++ b/clippy_lints/src/manual_non_exhaustive.rs
@@ -9,7 +9,7 @@ use rustc_errors::Applicability;
 use rustc_hir::def::{CtorKind, CtorOf, DefKind, Res};
 use rustc_hir::{self as hir, Expr, ExprKind, QPath};
 use rustc_lint::{EarlyContext, EarlyLintPass, LateContext, LateLintPass, LintContext};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::def_id::{DefId, LocalDefId};
 use rustc_span::{sym, Span};
 
diff --git a/clippy_lints/src/manual_range_patterns.rs b/clippy_lints/src/manual_range_patterns.rs
index d24bfe18224..d585290f777 100644
--- a/clippy_lints/src/manual_range_patterns.rs
+++ b/clippy_lints/src/manual_range_patterns.rs
@@ -6,7 +6,7 @@ use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, PatKind, RangeEnd, UnOp};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::{Span, DUMMY_SP};
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/manual_rem_euclid.rs b/clippy_lints/src/manual_rem_euclid.rs
index bc8372fbd41..e006df7d666 100644
--- a/clippy_lints/src/manual_rem_euclid.rs
+++ b/clippy_lints/src/manual_rem_euclid.rs
@@ -7,7 +7,7 @@ use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind, Node, TyKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/manual_retain.rs b/clippy_lints/src/manual_retain.rs
index 2f8682d0418..1fe247dacb9 100644
--- a/clippy_lints/src/manual_retain.rs
+++ b/clippy_lints/src/manual_retain.rs
@@ -9,7 +9,7 @@ use rustc_hir::def_id::DefId;
 use rustc_hir::ExprKind::Assign;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_semver::RustcVersion;
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::symbol::sym;
 
 const ACCEPTABLE_METHODS: [&[&str]; 5] = [
diff --git a/clippy_lints/src/manual_slice_size_calculation.rs b/clippy_lints/src/manual_slice_size_calculation.rs
index 3b97d165998..1de686dbcb5 100644
--- a/clippy_lints/src/manual_slice_size_calculation.rs
+++ b/clippy_lints/src/manual_slice_size_calculation.rs
@@ -5,7 +5,7 @@ use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::symbol::sym;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/manual_string_new.rs b/clippy_lints/src/manual_string_new.rs
index f8afae0e1f5..737c70496c2 100644
--- a/clippy_lints/src/manual_string_new.rs
+++ b/clippy_lints/src/manual_string_new.rs
@@ -4,7 +4,7 @@ use rustc_errors::Applicability::MachineApplicable;
 use rustc_hir::{Expr, ExprKind, PathSegment, QPath, TyKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::{sym, symbol, Span};
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/manual_strip.rs b/clippy_lints/src/manual_strip.rs
index b41bf2d767e..7b04fd28b89 100644
--- a/clippy_lints/src/manual_strip.rs
+++ b/clippy_lints/src/manual_strip.rs
@@ -10,7 +10,7 @@ use rustc_hir::intravisit::{walk_expr, Visitor};
 use rustc_hir::{BinOpKind, BorrowKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::source_map::Spanned;
 use rustc_span::Span;
 
diff --git a/clippy_lints/src/map_unit_fn.rs b/clippy_lints/src/map_unit_fn.rs
index 147e72ea894..3b82c50a84e 100644
--- a/clippy_lints/src/map_unit_fn.rs
+++ b/clippy_lints/src/map_unit_fn.rs
@@ -6,7 +6,7 @@ use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{self, Ty};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::{sym, Span};
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/match_result_ok.rs b/clippy_lints/src/match_result_ok.rs
index bf035969477..62cedc8847b 100644
--- a/clippy_lints/src/match_result_ok.rs
+++ b/clippy_lints/src/match_result_ok.rs
@@ -5,7 +5,7 @@ use clippy_utils::{higher, is_res_lang_ctor};
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, LangItem, PatKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::sym;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/matches/mod.rs b/clippy_lints/src/matches/mod.rs
index dea46d4d360..4c7568f39b4 100644
--- a/clippy_lints/src/matches/mod.rs
+++ b/clippy_lints/src/matches/mod.rs
@@ -31,7 +31,7 @@ use rustc_hir::{Arm, Expr, ExprKind, Local, MatchSource, Pat};
 use rustc_lexer::TokenKind;
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::{Span, SpanData, SyntaxContext};
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/mem_replace.rs b/clippy_lints/src/mem_replace.rs
index 1517223ab9a..c22f76484d0 100644
--- a/clippy_lints/src/mem_replace.rs
+++ b/clippy_lints/src/mem_replace.rs
@@ -9,7 +9,7 @@ use rustc_hir::LangItem::OptionNone;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::lint::in_external_macro;
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::symbol::sym;
 use rustc_span::Span;
 
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 7ce14242cae..1f48b13987d 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -133,7 +133,7 @@ use rustc_hir::{Expr, ExprKind, Node, Stmt, StmtKind, TraitItem, TraitItemKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::{self, TraitRef, Ty};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::{sym, Span};
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/min_ident_chars.rs b/clippy_lints/src/min_ident_chars.rs
index 4ad12e899fe..f5b749c7f80 100644
--- a/clippy_lints/src/min_ident_chars.rs
+++ b/clippy_lints/src/min_ident_chars.rs
@@ -6,7 +6,7 @@ use rustc_hir::intravisit::{walk_item, Visitor};
 use rustc_hir::{GenericParamKind, HirId, Item, ItemKind, ItemLocalId, Node, Pat, PatKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::Span;
 use std::borrow::Cow;
 
diff --git a/clippy_lints/src/minmax.rs b/clippy_lints/src/minmax.rs
index e0904f17b8d..fca626fa5c3 100644
--- a/clippy_lints/src/minmax.rs
+++ b/clippy_lints/src/minmax.rs
@@ -3,7 +3,7 @@ use clippy_utils::diagnostics::span_lint;
 use clippy_utils::is_trait_method;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::sym;
 use std::cmp::Ordering;
 
diff --git a/clippy_lints/src/misc.rs b/clippy_lints/src/misc.rs
index 814fc3303b0..b9784a58596 100644
--- a/clippy_lints/src/misc.rs
+++ b/clippy_lints/src/misc.rs
@@ -13,7 +13,7 @@ use rustc_hir::{
 };
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::def_id::LocalDefId;
 use rustc_span::Span;
 
diff --git a/clippy_lints/src/misc_early/mod.rs b/clippy_lints/src/misc_early/mod.rs
index df0dd9e4e39..abe5b00e888 100644
--- a/clippy_lints/src/misc_early/mod.rs
+++ b/clippy_lints/src/misc_early/mod.rs
@@ -16,7 +16,7 @@ use rustc_ast::visit::FnKind;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::Span;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/mismatching_type_param_order.rs b/clippy_lints/src/mismatching_type_param_order.rs
index c74d0d623df..0739b49fe19 100644
--- a/clippy_lints/src/mismatching_type_param_order.rs
+++ b/clippy_lints/src/mismatching_type_param_order.rs
@@ -4,7 +4,7 @@ use rustc_hir::def::{DefKind, Res};
 use rustc_hir::{GenericArg, Item, ItemKind, QPath, Ty, TyKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::GenericParamDefKind;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/missing_assert_message.rs b/clippy_lints/src/missing_assert_message.rs
index 4e00215c5cb..04df7b7a7e5 100644
--- a/clippy_lints/src/missing_assert_message.rs
+++ b/clippy_lints/src/missing_assert_message.rs
@@ -3,7 +3,7 @@ use clippy_utils::macros::{find_assert_args, find_assert_eq_args, root_macro_cal
 use clippy_utils::{is_in_cfg_test, is_in_test_function};
 use rustc_hir::Expr;
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::sym;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/missing_asserts_for_indexing.rs b/clippy_lints/src/missing_asserts_for_indexing.rs
index 5d6dc8d5582..8f2a5390781 100644
--- a/clippy_lints/src/missing_asserts_for_indexing.rs
+++ b/clippy_lints/src/missing_asserts_for_indexing.rs
@@ -11,7 +11,7 @@ use rustc_data_structures::unhash::UnhashMap;
 use rustc_errors::{Applicability, Diagnostic};
 use rustc_hir::{BinOp, Block, Body, Expr, ExprKind, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::source_map::Spanned;
 use rustc_span::{sym, Span};
 
diff --git a/clippy_lints/src/missing_const_for_fn.rs b/clippy_lints/src/missing_const_for_fn.rs
index 97522cbe6ce..c8d8920635c 100644
--- a/clippy_lints/src/missing_const_for_fn.rs
+++ b/clippy_lints/src/missing_const_for_fn.rs
@@ -9,7 +9,7 @@ use rustc_hir::intravisit::FnKind;
 use rustc_hir::{Body, Constness, FnDecl, GenericParamKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::lint::in_external_macro;
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::def_id::LocalDefId;
 use rustc_span::Span;
 
diff --git a/clippy_lints/src/missing_doc.rs b/clippy_lints/src/missing_doc.rs
index b5a884f7c8b..bf4af7946f4 100644
--- a/clippy_lints/src/missing_doc.rs
+++ b/clippy_lints/src/missing_doc.rs
@@ -13,7 +13,7 @@ use rustc_hir as hir;
 use rustc_hir::def_id::LocalDefId;
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::ty::Visibility;
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::def_id::CRATE_DEF_ID;
 use rustc_span::{sym, Span};
 
diff --git a/clippy_lints/src/missing_enforced_import_rename.rs b/clippy_lints/src/missing_enforced_import_rename.rs
index f7e42815104..c1f6c71a63e 100644
--- a/clippy_lints/src/missing_enforced_import_rename.rs
+++ b/clippy_lints/src/missing_enforced_import_rename.rs
@@ -7,7 +7,7 @@ use rustc_hir::def::Res;
 use rustc_hir::def_id::DefId;
 use rustc_hir::{Item, ItemKind, UseKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::Symbol;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/missing_fields_in_debug.rs b/clippy_lints/src/missing_fields_in_debug.rs
index 95f9df4e42a..8be45b8c2f3 100644
--- a/clippy_lints/src/missing_fields_in_debug.rs
+++ b/clippy_lints/src/missing_fields_in_debug.rs
@@ -12,7 +12,7 @@ use rustc_hir::{
 };
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{Ty, TypeckResults};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::{sym, Span, Symbol};
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/missing_inline.rs b/clippy_lints/src/missing_inline.rs
index b815da79b69..07bcbfc4ff4 100644
--- a/clippy_lints/src/missing_inline.rs
+++ b/clippy_lints/src/missing_inline.rs
@@ -2,7 +2,7 @@ use clippy_utils::diagnostics::span_lint;
 use rustc_ast::ast;
 use rustc_hir as hir;
 use rustc_lint::{self, LateContext, LateLintPass, LintContext};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::{sym, Span};
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/missing_trait_methods.rs b/clippy_lints/src/missing_trait_methods.rs
index ad5f45a3280..6bbf18d52d1 100644
--- a/clippy_lints/src/missing_trait_methods.rs
+++ b/clippy_lints/src/missing_trait_methods.rs
@@ -5,7 +5,7 @@ use rustc_hir::def_id::DefIdMap;
 use rustc_hir::{Impl, Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::AssocItem;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/mixed_read_write_in_expression.rs b/clippy_lints/src/mixed_read_write_in_expression.rs
index b46c006cd57..9cea0ebff03 100644
--- a/clippy_lints/src/mixed_read_write_in_expression.rs
+++ b/clippy_lints/src/mixed_read_write_in_expression.rs
@@ -4,7 +4,7 @@ use rustc_hir::intravisit::{walk_expr, Visitor};
 use rustc_hir::{BinOpKind, Block, Expr, ExprKind, Guard, HirId, Local, Node, Stmt, StmtKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/module_style.rs b/clippy_lints/src/module_style.rs
index cd45467407e..0226b31dd19 100644
--- a/clippy_lints/src/module_style.rs
+++ b/clippy_lints/src/module_style.rs
@@ -2,7 +2,7 @@ use clippy_utils::diagnostics::span_lint_and_help;
 use rustc_ast::ast;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_lint::{EarlyContext, EarlyLintPass, Level, LintContext};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::def_id::LOCAL_CRATE;
 use rustc_span::{FileName, SourceFile, Span, SyntaxContext};
 use std::ffi::OsStr;
diff --git a/clippy_lints/src/multi_assignments.rs b/clippy_lints/src/multi_assignments.rs
index b42dce7a13a..9a6b1dfc52b 100644
--- a/clippy_lints/src/multi_assignments.rs
+++ b/clippy_lints/src/multi_assignments.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::span_lint;
 use rustc_ast::ast::{Expr, ExprKind, Stmt, StmtKind};
 use rustc_lint::{EarlyContext, EarlyLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/multiple_unsafe_ops_per_block.rs b/clippy_lints/src/multiple_unsafe_ops_per_block.rs
index d4f8008aece..049f44f3246 100644
--- a/clippy_lints/src/multiple_unsafe_ops_per_block.rs
+++ b/clippy_lints/src/multiple_unsafe_ops_per_block.rs
@@ -8,7 +8,7 @@ use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::{DesugaringKind, Span};
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/mut_key.rs b/clippy_lints/src/mut_key.rs
index 823715f8840..a8ec1d8cf1b 100644
--- a/clippy_lints/src/mut_key.rs
+++ b/clippy_lints/src/mut_key.rs
@@ -6,7 +6,7 @@ use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::query::Key;
 use rustc_middle::ty::{Adt, Ty};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::def_id::LocalDefId;
 use rustc_span::symbol::sym;
 use rustc_span::Span;
diff --git a/clippy_lints/src/mut_mut.rs b/clippy_lints/src/mut_mut.rs
index 6989504a4a9..72a2cca1e40 100644
--- a/clippy_lints/src/mut_mut.rs
+++ b/clippy_lints/src/mut_mut.rs
@@ -5,7 +5,7 @@ use rustc_hir::intravisit;
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/mut_reference.rs b/clippy_lints/src/mut_reference.rs
index 4f8e244222d..f905a4e5b64 100644
--- a/clippy_lints/src/mut_reference.rs
+++ b/clippy_lints/src/mut_reference.rs
@@ -2,7 +2,7 @@ use clippy_utils::diagnostics::span_lint;
 use rustc_hir::{BorrowKind, Expr, ExprKind, Mutability};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{self, Ty};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use std::iter;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/mutable_debug_assertion.rs b/clippy_lints/src/mutable_debug_assertion.rs
index 9256119e6a4..2d7ce7b52ae 100644
--- a/clippy_lints/src/mutable_debug_assertion.rs
+++ b/clippy_lints/src/mutable_debug_assertion.rs
@@ -5,7 +5,7 @@ use rustc_hir::{BorrowKind, Expr, ExprKind, MatchSource, Mutability};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::nested_filter;
 use rustc_middle::ty;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::Span;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/mutex_atomic.rs b/clippy_lints/src/mutex_atomic.rs
index 9d8c06cd077..a23e12f7a18 100644
--- a/clippy_lints/src/mutex_atomic.rs
+++ b/clippy_lints/src/mutex_atomic.rs
@@ -7,7 +7,7 @@ use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_hir::Expr;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{self, Ty};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::sym;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/needless_arbitrary_self_type.rs b/clippy_lints/src/needless_arbitrary_self_type.rs
index 1712262ff3e..2ab83f733cb 100644
--- a/clippy_lints/src/needless_arbitrary_self_type.rs
+++ b/clippy_lints/src/needless_arbitrary_self_type.rs
@@ -2,7 +2,7 @@ use clippy_utils::diagnostics::span_lint_and_sugg;
 use rustc_ast::ast::{BindingAnnotation, ByRef, Lifetime, Mutability, Param, PatKind, Path, TyKind};
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::symbol::kw;
 use rustc_span::Span;
 
diff --git a/clippy_lints/src/needless_bool.rs b/clippy_lints/src/needless_bool.rs
index 02c177c9227..218ca5e80f3 100644
--- a/clippy_lints/src/needless_bool.rs
+++ b/clippy_lints/src/needless_bool.rs
@@ -13,7 +13,7 @@ use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Block, Expr, ExprKind, HirId, Node, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::source_map::Spanned;
 use rustc_span::Span;
 
diff --git a/clippy_lints/src/needless_borrowed_ref.rs b/clippy_lints/src/needless_borrowed_ref.rs
index fdb91f0dc0d..4710a69443b 100644
--- a/clippy_lints/src/needless_borrowed_ref.rs
+++ b/clippy_lints/src/needless_borrowed_ref.rs
@@ -2,7 +2,7 @@ use clippy_utils::diagnostics::span_lint_and_then;
 use rustc_errors::Applicability;
 use rustc_hir::{BindingAnnotation, Mutability, Node, Pat, PatKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/needless_borrows_for_generic_args.rs b/clippy_lints/src/needless_borrows_for_generic_args.rs
index f25475aaa8e..85166b0dd95 100644
--- a/clippy_lints/src/needless_borrows_for_generic_args.rs
+++ b/clippy_lints/src/needless_borrows_for_generic_args.rs
@@ -15,7 +15,7 @@ use rustc_middle::mir::{Rvalue, StatementKind};
 use rustc_middle::ty::{
     self, ClauseKind, EarlyBinder, FnSig, GenericArg, GenericArgKind, List, ParamTy, ProjectionPredicate, Ty,
 };
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::symbol::sym;
 use rustc_trait_selection::traits::query::evaluate_obligation::InferCtxtExt as _;
 use rustc_trait_selection::traits::{Obligation, ObligationCause};
diff --git a/clippy_lints/src/needless_continue.rs b/clippy_lints/src/needless_continue.rs
index 6803034f475..4b9ab50e4fd 100644
--- a/clippy_lints/src/needless_continue.rs
+++ b/clippy_lints/src/needless_continue.rs
@@ -37,7 +37,7 @@ use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::source::{indent_of, snippet, snippet_block};
 use rustc_ast::ast;
 use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::Span;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/needless_else.rs b/clippy_lints/src/needless_else.rs
index d881c13f84a..b6aad69d166 100644
--- a/clippy_lints/src/needless_else.rs
+++ b/clippy_lints/src/needless_else.rs
@@ -3,7 +3,7 @@ use clippy_utils::source::{snippet_opt, trim_span};
 use rustc_ast::ast::{Expr, ExprKind};
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/needless_for_each.rs b/clippy_lints/src/needless_for_each.rs
index 70571d18e78..84a07df1bb0 100644
--- a/clippy_lints/src/needless_for_each.rs
+++ b/clippy_lints/src/needless_for_each.rs
@@ -2,7 +2,7 @@ use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_expr, Visitor};
 use rustc_hir::{Closure, Expr, ExprKind, Stmt, StmtKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::{sym, Span, Symbol};
 
 use clippy_utils::diagnostics::span_lint_and_then;
diff --git a/clippy_lints/src/needless_if.rs b/clippy_lints/src/needless_if.rs
index 1ed7ea6b325..41d05d72284 100644
--- a/clippy_lints/src/needless_if.rs
+++ b/clippy_lints/src/needless_if.rs
@@ -6,7 +6,7 @@ use rustc_errors::Applicability;
 use rustc_hir::{ExprKind, Stmt, StmtKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/needless_late_init.rs b/clippy_lints/src/needless_late_init.rs
index 0a95678d31a..3e63c0a1d36 100644
--- a/clippy_lints/src/needless_late_init.rs
+++ b/clippy_lints/src/needless_late_init.rs
@@ -10,7 +10,7 @@ use rustc_hir::{
     StmtKind,
 };
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::Span;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/needless_parens_on_range_literals.rs b/clippy_lints/src/needless_parens_on_range_literals.rs
index 490c3f9c1ab..8a62106377c 100644
--- a/clippy_lints/src/needless_parens_on_range_literals.rs
+++ b/clippy_lints/src/needless_parens_on_range_literals.rs
@@ -7,7 +7,7 @@ use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
 
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 
 declare_clippy_lint! {
   /// ### What it does
diff --git a/clippy_lints/src/needless_pass_by_ref_mut.rs b/clippy_lints/src/needless_pass_by_ref_mut.rs
index d610ba520a4..c55031f4722 100644
--- a/clippy_lints/src/needless_pass_by_ref_mut.rs
+++ b/clippy_lints/src/needless_pass_by_ref_mut.rs
@@ -17,7 +17,7 @@ use rustc_middle::hir::map::associated_body;
 use rustc_middle::hir::nested_filter::OnlyBodies;
 use rustc_middle::mir::FakeReadCause;
 use rustc_middle::ty::{self, Ty, TyCtxt, UpvarId, UpvarPath};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::def_id::LocalDefId;
 use rustc_span::symbol::kw;
 use rustc_span::Span;
diff --git a/clippy_lints/src/needless_pass_by_value.rs b/clippy_lints/src/needless_pass_by_value.rs
index 7c48b84e430..0fc2f03c6e2 100644
--- a/clippy_lints/src/needless_pass_by_value.rs
+++ b/clippy_lints/src/needless_pass_by_value.rs
@@ -17,7 +17,7 @@ use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::mir::FakeReadCause;
 use rustc_middle::ty::{self, Ty, TypeVisitableExt};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::def_id::LocalDefId;
 use rustc_span::symbol::kw;
 use rustc_span::{sym, Span};
diff --git a/clippy_lints/src/needless_question_mark.rs b/clippy_lints/src/needless_question_mark.rs
index 7ec0879ba38..a4d3aaf0de9 100644
--- a/clippy_lints/src/needless_question_mark.rs
+++ b/clippy_lints/src/needless_question_mark.rs
@@ -5,7 +5,7 @@ use rustc_errors::Applicability;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::{Block, Body, CoroutineKind, CoroutineSource, Expr, ExprKind, LangItem, MatchSource, QPath};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/needless_update.rs b/clippy_lints/src/needless_update.rs
index f8888d36878..6a2893cefbd 100644
--- a/clippy_lints/src/needless_update.rs
+++ b/clippy_lints/src/needless_update.rs
@@ -2,7 +2,7 @@ use clippy_utils::diagnostics::span_lint;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/neg_cmp_op_on_partial_ord.rs b/clippy_lints/src/neg_cmp_op_on_partial_ord.rs
index 30aed8cc04a..f7621822b66 100644
--- a/clippy_lints/src/neg_cmp_op_on_partial_ord.rs
+++ b/clippy_lints/src/neg_cmp_op_on_partial_ord.rs
@@ -3,7 +3,7 @@ use clippy_utils::ty::implements_trait;
 use rustc_hir::{BinOpKind, Expr, ExprKind, UnOp};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::sym;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/neg_multiply.rs b/clippy_lints/src/neg_multiply.rs
index a6adb7c8a5f..f84d9fadb85 100644
--- a/clippy_lints/src/neg_multiply.rs
+++ b/clippy_lints/src/neg_multiply.rs
@@ -6,7 +6,7 @@ use rustc_ast::util::parser::PREC_PREFIX;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::Span;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/new_without_default.rs b/clippy_lints/src/new_without_default.rs
index abba622a285..5af0e8b10d7 100644
--- a/clippy_lints/src/new_without_default.rs
+++ b/clippy_lints/src/new_without_default.rs
@@ -7,7 +7,7 @@ use rustc_hir as hir;
 use rustc_hir::HirIdSet;
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::sym;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/no_effect.rs b/clippy_lints/src/no_effect.rs
index de8bb123e9b..6e65dd628a4 100644
--- a/clippy_lints/src/no_effect.rs
+++ b/clippy_lints/src/no_effect.rs
@@ -10,7 +10,7 @@ use rustc_hir::{
 use rustc_infer::infer::TyCtxtInferExt as _;
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use std::ops::Deref;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/no_mangle_with_rust_abi.rs b/clippy_lints/src/no_mangle_with_rust_abi.rs
index 04d75014892..8d5a523fd8f 100644
--- a/clippy_lints/src/no_mangle_with_rust_abi.rs
+++ b/clippy_lints/src/no_mangle_with_rust_abi.rs
@@ -3,7 +3,7 @@ use clippy_utils::source::snippet_with_applicability;
 use rustc_errors::Applicability;
 use rustc_hir::{Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::{BytePos, Pos};
 use rustc_target::spec::abi::Abi;
 
diff --git a/clippy_lints/src/non_canonical_impls.rs b/clippy_lints/src/non_canonical_impls.rs
index 9689f63a013..63050080ac6 100644
--- a/clippy_lints/src/non_canonical_impls.rs
+++ b/clippy_lints/src/non_canonical_impls.rs
@@ -6,7 +6,7 @@ use rustc_hir::def_id::LocalDefId;
 use rustc_hir::{Expr, ExprKind, ImplItem, ImplItemKind, LangItem, Node, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::EarlyBinder;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::sym;
 use rustc_span::symbol::kw;
 
diff --git a/clippy_lints/src/non_copy_const.rs b/clippy_lints/src/non_copy_const.rs
index 3059eb25d29..4f8922aea17 100644
--- a/clippy_lints/src/non_copy_const.rs
+++ b/clippy_lints/src/non_copy_const.rs
@@ -18,7 +18,7 @@ use rustc_middle::mir::interpret::{ErrorHandled, EvalToValTreeResult, GlobalId};
 use rustc_middle::query::Key;
 use rustc_middle::ty::adjustment::Adjust;
 use rustc_middle::ty::{self, Ty, TyCtxt};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::{sym, InnerSpan, Span};
 use rustc_target::abi::VariantIdx;
 
diff --git a/clippy_lints/src/non_expressive_names.rs b/clippy_lints/src/non_expressive_names.rs
index 649a23565a9..70b7ef1a5ea 100644
--- a/clippy_lints/src/non_expressive_names.rs
+++ b/clippy_lints/src/non_expressive_names.rs
@@ -5,7 +5,7 @@ use rustc_ast::ast::{
 use rustc_ast::visit::{walk_block, walk_expr, walk_pat, Visitor};
 use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::symbol::{Ident, Symbol};
 use rustc_span::{sym, Span};
 use std::cmp::Ordering;
diff --git a/clippy_lints/src/non_octal_unix_permissions.rs b/clippy_lints/src/non_octal_unix_permissions.rs
index 6cfcc81025d..49e9e2c00cc 100644
--- a/clippy_lints/src/non_octal_unix_permissions.rs
+++ b/clippy_lints/src/non_octal_unix_permissions.rs
@@ -4,7 +4,7 @@ use clippy_utils::{match_def_path, paths};
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::sym;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/non_send_fields_in_send_ty.rs b/clippy_lints/src/non_send_fields_in_send_ty.rs
index df1476e6809..433664cda64 100644
--- a/clippy_lints/src/non_send_fields_in_send_ty.rs
+++ b/clippy_lints/src/non_send_fields_in_send_ty.rs
@@ -8,7 +8,7 @@ use rustc_hir::{FieldDef, Item, ItemKind, Node};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::{self, GenericArgKind, Ty};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::sym;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/nonstandard_macro_braces.rs b/clippy_lints/src/nonstandard_macro_braces.rs
index 1c6a8e16ae2..1c6069e9c65 100644
--- a/clippy_lints/src/nonstandard_macro_braces.rs
+++ b/clippy_lints/src/nonstandard_macro_braces.rs
@@ -6,7 +6,7 @@ use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_errors::Applicability;
 use rustc_hir::def_id::DefId;
 use rustc_lint::{EarlyContext, EarlyLintPass};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::hygiene::{ExpnKind, MacroKind};
 use rustc_span::Span;
 
diff --git a/clippy_lints/src/octal_escapes.rs b/clippy_lints/src/octal_escapes.rs
index 0faf4ce3d3e..8822dfeeddd 100644
--- a/clippy_lints/src/octal_escapes.rs
+++ b/clippy_lints/src/octal_escapes.rs
@@ -4,7 +4,7 @@ use rustc_ast::token::{Lit, LitKind};
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::Span;
 use std::fmt::Write;
 
diff --git a/clippy_lints/src/only_used_in_recursion.rs b/clippy_lints/src/only_used_in_recursion.rs
index ef7b367649f..d621051ef16 100644
--- a/clippy_lints/src/only_used_in_recursion.rs
+++ b/clippy_lints/src/only_used_in_recursion.rs
@@ -8,7 +8,7 @@ use rustc_hir::hir_id::HirIdMap;
 use rustc_hir::{Body, Expr, ExprKind, HirId, ImplItem, ImplItemKind, Node, PatKind, TraitItem, TraitItemKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{self, ConstKind, EarlyBinder, GenericArgKind, GenericArgsRef};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::symbol::{kw, Ident};
 use rustc_span::Span;
 use std::iter;
diff --git a/clippy_lints/src/operators/mod.rs b/clippy_lints/src/operators/mod.rs
index ee79ea27689..4c09c4eea58 100644
--- a/clippy_lints/src/operators/mod.rs
+++ b/clippy_lints/src/operators/mod.rs
@@ -25,7 +25,7 @@ pub(crate) mod arithmetic_side_effects;
 
 use rustc_hir::{Body, Expr, ExprKind, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/option_env_unwrap.rs b/clippy_lints/src/option_env_unwrap.rs
index 7792efe6acd..4bfb26209d2 100644
--- a/clippy_lints/src/option_env_unwrap.rs
+++ b/clippy_lints/src/option_env_unwrap.rs
@@ -2,7 +2,7 @@ use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::is_direct_expn_of;
 use rustc_ast::ast::{Expr, ExprKind, MethodCall};
 use rustc_lint::{EarlyContext, EarlyLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::{sym, Span};
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/option_if_let_else.rs b/clippy_lints/src/option_if_let_else.rs
index 6e4e0c98d29..cca90d813e0 100644
--- a/clippy_lints/src/option_if_let_else.rs
+++ b/clippy_lints/src/option_if_let_else.rs
@@ -9,7 +9,7 @@ use rustc_hir::def::Res;
 use rustc_hir::LangItem::{OptionNone, OptionSome, ResultErr, ResultOk};
 use rustc_hir::{Arm, BindingAnnotation, Expr, ExprKind, MatchSource, Mutability, Pat, PatKind, Path, QPath, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::SyntaxContext;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/overflow_check_conditional.rs b/clippy_lints/src/overflow_check_conditional.rs
index e661bfbb96c..de789879331 100644
--- a/clippy_lints/src/overflow_check_conditional.rs
+++ b/clippy_lints/src/overflow_check_conditional.rs
@@ -2,7 +2,7 @@ use clippy_utils::diagnostics::span_lint;
 use clippy_utils::SpanlessEq;
 use rustc_hir::{BinOpKind, Expr, ExprKind, QPath};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/panic_in_result_fn.rs b/clippy_lints/src/panic_in_result_fn.rs
index 6a760f9fe64..1d6a3f37eed 100644
--- a/clippy_lints/src/panic_in_result_fn.rs
+++ b/clippy_lints/src/panic_in_result_fn.rs
@@ -7,7 +7,7 @@ use core::ops::ControlFlow;
 use rustc_hir as hir;
 use rustc_hir::intravisit::FnKind;
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::def_id::LocalDefId;
 use rustc_span::{sym, Span};
 
diff --git a/clippy_lints/src/panic_unimplemented.rs b/clippy_lints/src/panic_unimplemented.rs
index f4f1f6ddb3f..ef51a9a9a1c 100644
--- a/clippy_lints/src/panic_unimplemented.rs
+++ b/clippy_lints/src/panic_unimplemented.rs
@@ -2,7 +2,7 @@ use clippy_utils::diagnostics::span_lint;
 use clippy_utils::macros::{is_panic, root_macro_call_first_node};
 use rustc_hir::Expr;
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/partial_pub_fields.rs b/clippy_lints/src/partial_pub_fields.rs
index 99ba55b6b31..ffa403e27ca 100644
--- a/clippy_lints/src/partial_pub_fields.rs
+++ b/clippy_lints/src/partial_pub_fields.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_help;
 use rustc_ast::ast::{Item, ItemKind};
 use rustc_lint::{EarlyContext, EarlyLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/partialeq_ne_impl.rs b/clippy_lints/src/partialeq_ne_impl.rs
index 1b06762415d..18e6aad9c9a 100644
--- a/clippy_lints/src/partialeq_ne_impl.rs
+++ b/clippy_lints/src/partialeq_ne_impl.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::span_lint_hir;
 use rustc_hir::{Impl, Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::sym;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/partialeq_to_none.rs b/clippy_lints/src/partialeq_to_none.rs
index 11e9a2bc394..6d4216970cc 100644
--- a/clippy_lints/src/partialeq_to_none.rs
+++ b/clippy_lints/src/partialeq_to_none.rs
@@ -4,7 +4,7 @@ use clippy_utils::{is_res_lang_ctor, path_res, peel_hir_expr_refs, peel_ref_oper
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind, LangItem};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::sym;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/pass_by_ref_or_value.rs b/clippy_lints/src/pass_by_ref_or_value.rs
index 0f6ddb35da3..2cb36af7b44 100644
--- a/clippy_lints/src/pass_by_ref_or_value.rs
+++ b/clippy_lints/src/pass_by_ref_or_value.rs
@@ -15,7 +15,7 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::adjustment::{Adjust, PointerCoercion};
 use rustc_middle::ty::layout::LayoutOf;
 use rustc_middle::ty::{self, RegionKind};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::def_id::LocalDefId;
 use rustc_span::{sym, Span};
 use rustc_target::spec::abi::Abi;
diff --git a/clippy_lints/src/pattern_type_mismatch.rs b/clippy_lints/src/pattern_type_mismatch.rs
index dcd1e7af0c2..60ced9c1208 100644
--- a/clippy_lints/src/pattern_type_mismatch.rs
+++ b/clippy_lints/src/pattern_type_mismatch.rs
@@ -3,7 +3,7 @@ use rustc_hir::{intravisit, Body, Expr, ExprKind, FnDecl, Let, LocalSource, Muta
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::def_id::LocalDefId;
 use rustc_span::Span;
 
diff --git a/clippy_lints/src/permissions_set_readonly_false.rs b/clippy_lints/src/permissions_set_readonly_false.rs
index b98005d5922..704acdc103e 100644
--- a/clippy_lints/src/permissions_set_readonly_false.rs
+++ b/clippy_lints/src/permissions_set_readonly_false.rs
@@ -3,7 +3,7 @@ use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_ast::ast::LitKind;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::sym;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/precedence.rs b/clippy_lints/src/precedence.rs
index b638e83997a..3cb9e05e912 100644
--- a/clippy_lints/src/precedence.rs
+++ b/clippy_lints/src/precedence.rs
@@ -4,7 +4,7 @@ use rustc_ast::ast::{BinOpKind, Expr, ExprKind, MethodCall, UnOp};
 use rustc_ast::token;
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::source_map::Spanned;
 
 const ALLOWED_ODD_FUNCTIONS: [&str; 14] = [
diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs
index 410f4ec651b..16581a934f2 100644
--- a/clippy_lints/src/ptr.rs
+++ b/clippy_lints/src/ptr.rs
@@ -20,7 +20,7 @@ use rustc_infer::traits::{Obligation, ObligationCause};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::nested_filter;
 use rustc_middle::ty::{self, Binder, ClauseKind, ExistentialPredicate, List, PredicateKind, Ty};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::symbol::Symbol;
 use rustc_span::{sym, Span};
 use rustc_target::spec::abi::Abi;
diff --git a/clippy_lints/src/ptr_offset_with_cast.rs b/clippy_lints/src/ptr_offset_with_cast.rs
index 66d869bc45a..ff8ec2ad57c 100644
--- a/clippy_lints/src/ptr_offset_with_cast.rs
+++ b/clippy_lints/src/ptr_offset_with_cast.rs
@@ -3,7 +3,7 @@ use clippy_utils::source::snippet_opt;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::sym;
 use std::fmt;
 
diff --git a/clippy_lints/src/pub_use.rs b/clippy_lints/src/pub_use.rs
index 316a72988aa..c0e999e76ef 100644
--- a/clippy_lints/src/pub_use.rs
+++ b/clippy_lints/src/pub_use.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_help;
 use rustc_ast::ast::{Item, ItemKind, VisibilityKind};
 use rustc_lint::{EarlyContext, EarlyLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/question_mark.rs b/clippy_lints/src/question_mark.rs
index 5c395143b9a..fc5835408a9 100644
--- a/clippy_lints/src/question_mark.rs
+++ b/clippy_lints/src/question_mark.rs
@@ -18,7 +18,7 @@ use rustc_hir::{
 };
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::Ty;
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::sym;
 use rustc_span::symbol::Symbol;
 
diff --git a/clippy_lints/src/question_mark_used.rs b/clippy_lints/src/question_mark_used.rs
index d0de33e3c4f..ddfc53083c4 100644
--- a/clippy_lints/src/question_mark_used.rs
+++ b/clippy_lints/src/question_mark_used.rs
@@ -3,7 +3,7 @@ use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::macros::span_is_local;
 use rustc_hir::{Expr, ExprKind, MatchSource};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/ranges.rs b/clippy_lints/src/ranges.rs
index fd9de76bacf..6b54258dd61 100644
--- a/clippy_lints/src/ranges.rs
+++ b/clippy_lints/src/ranges.rs
@@ -9,7 +9,7 @@ use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind, HirId};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::source_map::Spanned;
 use rustc_span::Span;
 use std::cmp::Ordering;
diff --git a/clippy_lints/src/raw_strings.rs b/clippy_lints/src/raw_strings.rs
index 98f5a07da0d..ac29d27303c 100644
--- a/clippy_lints/src/raw_strings.rs
+++ b/clippy_lints/src/raw_strings.rs
@@ -8,7 +8,7 @@ use rustc_ast::token::LitKind;
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::{BytePos, Pos, Span};
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/rc_clone_in_vec_init.rs b/clippy_lints/src/rc_clone_in_vec_init.rs
index b99af44655d..d0b45b59526 100644
--- a/clippy_lints/src/rc_clone_in_vec_init.rs
+++ b/clippy_lints/src/rc_clone_in_vec_init.rs
@@ -7,7 +7,7 @@ use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, QPath, TyKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::{sym, Span, Symbol};
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/read_zero_byte_vec.rs b/clippy_lints/src/read_zero_byte_vec.rs
index b27d4cc6e4f..62f3c09aa7e 100644
--- a/clippy_lints/src/read_zero_byte_vec.rs
+++ b/clippy_lints/src/read_zero_byte_vec.rs
@@ -7,7 +7,7 @@ use hir::{Expr, ExprKind, Local, PatKind, PathSegment, QPath, StmtKind};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/redundant_async_block.rs b/clippy_lints/src/redundant_async_block.rs
index 90297ca8bb6..19d9d64b31e 100644
--- a/clippy_lints/src/redundant_async_block.rs
+++ b/clippy_lints/src/redundant_async_block.rs
@@ -9,7 +9,7 @@ use rustc_hir::{Closure, CoroutineKind, CoroutineSource, Expr, ExprKind, MatchSo
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::UpvarCapture;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/redundant_clone.rs b/clippy_lints/src/redundant_clone.rs
index 698af9fb192..c62c351e716 100644
--- a/clippy_lints/src/redundant_clone.rs
+++ b/clippy_lints/src/redundant_clone.rs
@@ -9,7 +9,7 @@ use rustc_hir::{def_id, Body, FnDecl, LangItem};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::mir;
 use rustc_middle::ty::{self, Ty};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::def_id::LocalDefId;
 use rustc_span::{sym, BytePos, Span};
 
diff --git a/clippy_lints/src/redundant_closure_call.rs b/clippy_lints/src/redundant_closure_call.rs
index f2a006ebdfc..7971a5d86e3 100644
--- a/clippy_lints/src/redundant_closure_call.rs
+++ b/clippy_lints/src/redundant_closure_call.rs
@@ -10,7 +10,7 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::nested_filter;
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/redundant_else.rs b/clippy_lints/src/redundant_else.rs
index 221aa317e5d..1168e79bb0d 100644
--- a/clippy_lints/src/redundant_else.rs
+++ b/clippy_lints/src/redundant_else.rs
@@ -3,7 +3,7 @@ use rustc_ast::ast::{Block, Expr, ExprKind, Stmt, StmtKind};
 use rustc_ast::visit::{walk_expr, Visitor};
 use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/redundant_field_names.rs b/clippy_lints/src/redundant_field_names.rs
index b8e606df737..fb000cd7184 100644
--- a/clippy_lints/src/redundant_field_names.rs
+++ b/clippy_lints/src/redundant_field_names.rs
@@ -4,7 +4,7 @@ use rustc_ast::ast::{Expr, ExprKind};
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/redundant_locals.rs b/clippy_lints/src/redundant_locals.rs
index 15b784039b6..8c374d7d6db 100644
--- a/clippy_lints/src/redundant_locals.rs
+++ b/clippy_lints/src/redundant_locals.rs
@@ -6,7 +6,7 @@ use rustc_hir::def::Res;
 use rustc_hir::{BindingAnnotation, ByRef, ExprKind, HirId, Local, Node, Pat, PatKind, QPath};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::symbol::Ident;
 use rustc_span::DesugaringKind;
 
diff --git a/clippy_lints/src/redundant_pub_crate.rs b/clippy_lints/src/redundant_pub_crate.rs
index 32e0c3749ab..0e43e4a7ee5 100644
--- a/clippy_lints/src/redundant_pub_crate.rs
+++ b/clippy_lints/src/redundant_pub_crate.rs
@@ -4,7 +4,7 @@ use rustc_hir::def::{DefKind, Res};
 use rustc_hir::{Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::def_id::CRATE_DEF_ID;
 use rustc_span::hygiene::MacroKind;
 
diff --git a/clippy_lints/src/redundant_slicing.rs b/clippy_lints/src/redundant_slicing.rs
index c9fc65653c2..c99b657c23a 100644
--- a/clippy_lints/src/redundant_slicing.rs
+++ b/clippy_lints/src/redundant_slicing.rs
@@ -8,7 +8,7 @@ use rustc_hir::{BorrowKind, Expr, ExprKind, LangItem, Mutability};
 use rustc_lint::{LateContext, LateLintPass, Lint};
 use rustc_middle::ty::adjustment::{Adjust, AutoBorrow, AutoBorrowMutability};
 use rustc_middle::ty::{GenericArg, Ty};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/redundant_static_lifetimes.rs b/clippy_lints/src/redundant_static_lifetimes.rs
index a70b831a80c..07b604f2326 100644
--- a/clippy_lints/src/redundant_static_lifetimes.rs
+++ b/clippy_lints/src/redundant_static_lifetimes.rs
@@ -4,7 +4,7 @@ use clippy_utils::source::snippet;
 use rustc_ast::ast::{ConstItem, Item, ItemKind, StaticItem, Ty, TyKind};
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::symbol::kw;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/redundant_type_annotations.rs b/clippy_lints/src/redundant_type_annotations.rs
index f6af9cac3de..07fcb69afbc 100644
--- a/clippy_lints/src/redundant_type_annotations.rs
+++ b/clippy_lints/src/redundant_type_annotations.rs
@@ -5,7 +5,7 @@ use rustc_hir as hir;
 use rustc_hir::def::DefKind;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::Ty;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/ref_option_ref.rs b/clippy_lints/src/ref_option_ref.rs
index 0ba898e75a1..19ce08bde10 100644
--- a/clippy_lints/src/ref_option_ref.rs
+++ b/clippy_lints/src/ref_option_ref.rs
@@ -4,7 +4,7 @@ use clippy_utils::source::snippet;
 use rustc_errors::Applicability;
 use rustc_hir::{GenericArg, GenericArgsParentheses, Mutability, Ty, TyKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::symbol::sym;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/ref_patterns.rs b/clippy_lints/src/ref_patterns.rs
index 8b3dabde9be..a4be78b310b 100644
--- a/clippy_lints/src/ref_patterns.rs
+++ b/clippy_lints/src/ref_patterns.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_help;
 use rustc_ast::ast::{BindingAnnotation, Pat, PatKind};
 use rustc_lint::{EarlyContext, EarlyLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/reference.rs b/clippy_lints/src/reference.rs
index 69818db7c82..16086ba6637 100644
--- a/clippy_lints/src/reference.rs
+++ b/clippy_lints/src/reference.rs
@@ -3,7 +3,7 @@ use clippy_utils::source::{snippet_opt, snippet_with_applicability};
 use rustc_ast::ast::{Expr, ExprKind, Mutability, UnOp};
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::BytePos;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/regex.rs b/clippy_lints/src/regex.rs
index ae8be006781..687bad35a36 100644
--- a/clippy_lints/src/regex.rs
+++ b/clippy_lints/src/regex.rs
@@ -8,7 +8,7 @@ use rustc_ast::ast::{LitKind, StrStyle};
 use rustc_hir::def_id::DefIdMap;
 use rustc_hir::{BorrowKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::{BytePos, Span};
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/reserve_after_initialization.rs b/clippy_lints/src/reserve_after_initialization.rs
index b4842e7d48a..ca7a0c7c87b 100644
--- a/clippy_lints/src/reserve_after_initialization.rs
+++ b/clippy_lints/src/reserve_after_initialization.rs
@@ -7,7 +7,7 @@ use rustc_hir::def::Res;
 use rustc_hir::{BindingAnnotation, Block, Expr, ExprKind, HirId, Local, PatKind, QPath, Stmt, StmtKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::Span;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/return_self_not_must_use.rs b/clippy_lints/src/return_self_not_must_use.rs
index ad22b751bef..b84a8500c81 100644
--- a/clippy_lints/src/return_self_not_must_use.rs
+++ b/clippy_lints/src/return_self_not_must_use.rs
@@ -6,7 +6,7 @@ use rustc_hir::intravisit::FnKind;
 use rustc_hir::{Body, FnDecl, OwnerId, TraitItem, TraitItemKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::{sym, Span};
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
index d64e931a2f3..c32cc8b73d2 100644
--- a/clippy_lints/src/returns.rs
+++ b/clippy_lints/src/returns.rs
@@ -14,7 +14,7 @@ use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::adjustment::Adjust;
 use rustc_middle::ty::{self, GenericArgKind, Ty};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::def_id::LocalDefId;
 use rustc_span::{BytePos, Pos, Span};
 use std::borrow::Cow;
diff --git a/clippy_lints/src/same_name_method.rs b/clippy_lints/src/same_name_method.rs
index 52475ff9ef7..cddbbb317ef 100644
--- a/clippy_lints/src/same_name_method.rs
+++ b/clippy_lints/src/same_name_method.rs
@@ -4,7 +4,7 @@ use rustc_hir::def::{DefKind, Res};
 use rustc_hir::{HirId, Impl, ItemKind, Node, Path, QPath, TraitRef, TyKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::AssocKind;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::symbol::Symbol;
 use rustc_span::Span;
 use std::collections::{BTreeMap, BTreeSet};
diff --git a/clippy_lints/src/self_named_constructors.rs b/clippy_lints/src/self_named_constructors.rs
index c1edcf509ef..015f37abcbc 100644
--- a/clippy_lints/src/self_named_constructors.rs
+++ b/clippy_lints/src/self_named_constructors.rs
@@ -3,7 +3,7 @@ use clippy_utils::return_ty;
 use clippy_utils::ty::contains_adt_constructor;
 use rustc_hir::{Impl, ImplItem, ImplItemKind, ItemKind, Node};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/semicolon_block.rs b/clippy_lints/src/semicolon_block.rs
index b0601bba4af..0b3adfb7a4b 100644
--- a/clippy_lints/src/semicolon_block.rs
+++ b/clippy_lints/src/semicolon_block.rs
@@ -2,7 +2,7 @@ use clippy_utils::diagnostics::{multispan_sugg_with_applicability, span_lint_and
 use rustc_errors::Applicability;
 use rustc_hir::{Block, Expr, ExprKind, Stmt, StmtKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::Span;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/semicolon_if_nothing_returned.rs b/clippy_lints/src/semicolon_if_nothing_returned.rs
index 3aabcadaa1f..2cd3e57f885 100644
--- a/clippy_lints/src/semicolon_if_nothing_returned.rs
+++ b/clippy_lints/src/semicolon_if_nothing_returned.rs
@@ -4,7 +4,7 @@ use clippy_utils::source::snippet_with_context;
 use rustc_errors::Applicability;
 use rustc_hir::{Block, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/serde_api.rs b/clippy_lints/src/serde_api.rs
index fc1c2af9257..90834d784a5 100644
--- a/clippy_lints/src/serde_api.rs
+++ b/clippy_lints/src/serde_api.rs
@@ -2,7 +2,7 @@ use clippy_utils::diagnostics::span_lint;
 use clippy_utils::{get_trait_def_id, paths};
 use rustc_hir::{Impl, Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/shadow.rs b/clippy_lints/src/shadow.rs
index 41c10b34a42..c74364d89d6 100644
--- a/clippy_lints/src/shadow.rs
+++ b/clippy_lints/src/shadow.rs
@@ -7,7 +7,7 @@ use rustc_hir::def_id::LocalDefId;
 use rustc_hir::hir_id::ItemLocalId;
 use rustc_hir::{Block, Body, BodyOwnerKind, Expr, ExprKind, HirId, Let, Node, Pat, PatKind, QPath, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::{Span, Symbol};
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/significant_drop_tightening.rs b/clippy_lints/src/significant_drop_tightening.rs
index 57bcee1a871..6c99ccda7ea 100644
--- a/clippy_lints/src/significant_drop_tightening.rs
+++ b/clippy_lints/src/significant_drop_tightening.rs
@@ -8,7 +8,7 @@ use rustc_hir::intravisit::{walk_expr, Visitor};
 use rustc_hir::{self as hir};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::ty::{GenericArgKind, Ty, TypeAndMut};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::symbol::Ident;
 use rustc_span::{sym, Span, DUMMY_SP};
 use std::borrow::Cow;
diff --git a/clippy_lints/src/single_call_fn.rs b/clippy_lints/src/single_call_fn.rs
index ae81e1198af..396d2717a13 100644
--- a/clippy_lints/src/single_call_fn.rs
+++ b/clippy_lints/src/single_call_fn.rs
@@ -7,7 +7,7 @@ use rustc_hir::{Body, Expr, ExprKind, FnDecl};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::hir::nested_filter::OnlyBodies;
 use rustc_middle::lint::in_external_macro;
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::Span;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/single_char_lifetime_names.rs b/clippy_lints/src/single_char_lifetime_names.rs
index 74ee8ce2de7..42f1564db35 100644
--- a/clippy_lints/src/single_char_lifetime_names.rs
+++ b/clippy_lints/src/single_char_lifetime_names.rs
@@ -2,7 +2,7 @@ use clippy_utils::diagnostics::span_lint_and_help;
 use rustc_ast::ast::{GenericParam, GenericParamKind};
 use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/single_component_path_imports.rs b/clippy_lints/src/single_component_path_imports.rs
index 9c21d70c82c..18fbbdb4079 100644
--- a/clippy_lints/src/single_component_path_imports.rs
+++ b/clippy_lints/src/single_component_path_imports.rs
@@ -5,7 +5,7 @@ use rustc_ast::visit::{walk_expr, Visitor};
 use rustc_ast::{Crate, Expr, ExprKind, Item, ItemKind, MacroDef, ModKind, Ty, TyKind, UseTreeKind};
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::edition::Edition;
 use rustc_span::symbol::kw;
 use rustc_span::{Span, Symbol};
diff --git a/clippy_lints/src/single_range_in_vec_init.rs b/clippy_lints/src/single_range_in_vec_init.rs
index 099743d229d..95b4a11a783 100644
--- a/clippy_lints/src/single_range_in_vec_init.rs
+++ b/clippy_lints/src/single_range_in_vec_init.rs
@@ -8,7 +8,7 @@ use rustc_ast::{LitIntType, LitKind, UintTy};
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, LangItem, QPath};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use std::fmt::{self, Display, Formatter};
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/size_of_in_element_count.rs b/clippy_lints/src/size_of_in_element_count.rs
index 0385f1a98e5..756e47cbdf0 100644
--- a/clippy_lints/src/size_of_in_element_count.rs
+++ b/clippy_lints/src/size_of_in_element_count.rs
@@ -5,7 +5,7 @@ use clippy_utils::diagnostics::span_lint_and_help;
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{self, Ty, TypeAndMut};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::sym;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/size_of_ref.rs b/clippy_lints/src/size_of_ref.rs
index 7de029b7b94..14ca7a3f004 100644
--- a/clippy_lints/src/size_of_ref.rs
+++ b/clippy_lints/src/size_of_ref.rs
@@ -3,7 +3,7 @@ use clippy_utils::path_def_id;
 use clippy_utils::ty::peel_mid_ty_refs;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::sym;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/slow_vector_initialization.rs b/clippy_lints/src/slow_vector_initialization.rs
index 733da790441..c4a5e48e855 100644
--- a/clippy_lints/src/slow_vector_initialization.rs
+++ b/clippy_lints/src/slow_vector_initialization.rs
@@ -9,7 +9,7 @@ use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_block, walk_expr, walk_stmt, Visitor};
 use rustc_hir::{BindingAnnotation, Block, Expr, ExprKind, HirId, PatKind, Stmt, StmtKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::symbol::sym;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/std_instead_of_core.rs b/clippy_lints/src/std_instead_of_core.rs
index d07a44770cc..38fd54a0f1e 100644
--- a/clippy_lints/src/std_instead_of_core.rs
+++ b/clippy_lints/src/std_instead_of_core.rs
@@ -6,7 +6,7 @@ use rustc_hir::def_id::DefId;
 use rustc_hir::{HirId, Path, PathSegment};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::symbol::kw;
 use rustc_span::{sym, Span};
 
diff --git a/clippy_lints/src/strings.rs b/clippy_lints/src/strings.rs
index baa9750cc01..13ae1ff52dd 100644
--- a/clippy_lints/src/strings.rs
+++ b/clippy_lints/src/strings.rs
@@ -11,7 +11,7 @@ use rustc_hir::{BinOpKind, BorrowKind, Expr, ExprKind, LangItem, Node, QPath};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::source_map::Spanned;
 use rustc_span::sym;
 
diff --git a/clippy_lints/src/strlen_on_c_strings.rs b/clippy_lints/src/strlen_on_c_strings.rs
index 644664b104d..8cf4715eeb8 100644
--- a/clippy_lints/src/strlen_on_c_strings.rs
+++ b/clippy_lints/src/strlen_on_c_strings.rs
@@ -6,7 +6,7 @@ use clippy_utils::{get_parent_node, match_libc_symbol};
 use rustc_errors::Applicability;
 use rustc_hir::{Block, BlockCheckMode, Expr, ExprKind, LangItem, Node, UnsafeSource};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::symbol::sym;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/suspicious_operation_groupings.rs b/clippy_lints/src/suspicious_operation_groupings.rs
index 92de7917871..4cfccc3d869 100644
--- a/clippy_lints/src/suspicious_operation_groupings.rs
+++ b/clippy_lints/src/suspicious_operation_groupings.rs
@@ -6,7 +6,7 @@ use rustc_ast::ast::{BinOpKind, Expr, ExprKind, StmtKind};
 use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::source_map::Spanned;
 use rustc_span::symbol::Ident;
 use rustc_span::Span;
diff --git a/clippy_lints/src/suspicious_trait_impl.rs b/clippy_lints/src/suspicious_trait_impl.rs
index 3244933a124..268c0c1b2df 100644
--- a/clippy_lints/src/suspicious_trait_impl.rs
+++ b/clippy_lints/src/suspicious_trait_impl.rs
@@ -4,7 +4,7 @@ use clippy_utils::{binop_traits, trait_ref_of_method, BINOP_TRAITS, OP_ASSIGN_TR
 use core::ops::ControlFlow;
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/suspicious_xor_used_as_pow.rs b/clippy_lints/src/suspicious_xor_used_as_pow.rs
index 4340c23f830..1cc27670fa8 100644
--- a/clippy_lints/src/suspicious_xor_used_as_pow.rs
+++ b/clippy_lints/src/suspicious_xor_used_as_pow.rs
@@ -6,7 +6,7 @@ use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/swap.rs b/clippy_lints/src/swap.rs
index 285f2f4f6f9..daa6fe8715c 100644
--- a/clippy_lints/src/swap.rs
+++ b/clippy_lints/src/swap.rs
@@ -8,7 +8,7 @@ use rustc_hir::{BinOpKind, Block, Expr, ExprKind, PatKind, QPath, Stmt, StmtKind
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::source_map::Spanned;
 use rustc_span::symbol::Ident;
 use rustc_span::{sym, Span, SyntaxContext};
diff --git a/clippy_lints/src/swap_ptr_to_ref.rs b/clippy_lints/src/swap_ptr_to_ref.rs
index 6a6c94425d1..20e9608a15d 100644
--- a/clippy_lints/src/swap_ptr_to_ref.rs
+++ b/clippy_lints/src/swap_ptr_to_ref.rs
@@ -4,7 +4,7 @@ use clippy_utils::source::snippet_with_context;
 use rustc_errors::Applicability;
 use rustc_hir::{BorrowKind, Expr, ExprKind, Mutability, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::{sym, Span, SyntaxContext};
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/tabs_in_doc_comments.rs b/clippy_lints/src/tabs_in_doc_comments.rs
index dcf1fac023a..af9e13dba36 100644
--- a/clippy_lints/src/tabs_in_doc_comments.rs
+++ b/clippy_lints/src/tabs_in_doc_comments.rs
@@ -2,7 +2,7 @@ use clippy_utils::diagnostics::span_lint_and_sugg;
 use rustc_ast::ast;
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::{BytePos, Span};
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/temporary_assignment.rs b/clippy_lints/src/temporary_assignment.rs
index c717ccc35a6..8151dd8f2cf 100644
--- a/clippy_lints/src/temporary_assignment.rs
+++ b/clippy_lints/src/temporary_assignment.rs
@@ -2,7 +2,7 @@ use clippy_utils::diagnostics::span_lint;
 use clippy_utils::is_adjusted;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/tests_outside_test_module.rs b/clippy_lints/src/tests_outside_test_module.rs
index 9481c78a505..da557582647 100644
--- a/clippy_lints/src/tests_outside_test_module.rs
+++ b/clippy_lints/src/tests_outside_test_module.rs
@@ -3,7 +3,7 @@ use clippy_utils::{is_in_cfg_test, is_in_test_function};
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::{Body, FnDecl};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::def_id::LocalDefId;
 use rustc_span::Span;
 
diff --git a/clippy_lints/src/to_digit_is_some.rs b/clippy_lints/src/to_digit_is_some.rs
index 1dca523a966..dafe9e38818 100644
--- a/clippy_lints/src/to_digit_is_some.rs
+++ b/clippy_lints/src/to_digit_is_some.rs
@@ -5,7 +5,7 @@ use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/trailing_empty_array.rs b/clippy_lints/src/trailing_empty_array.rs
index 7eef02b3c65..cbdf31c9336 100644
--- a/clippy_lints/src/trailing_empty_array.rs
+++ b/clippy_lints/src/trailing_empty_array.rs
@@ -3,7 +3,7 @@ use clippy_utils::has_repr_attr;
 use rustc_hir::{Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::Const;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/trait_bounds.rs b/clippy_lints/src/trait_bounds.rs
index e624bbe5ff1..e4054393d0a 100644
--- a/clippy_lints/src/trait_bounds.rs
+++ b/clippy_lints/src/trait_bounds.rs
@@ -13,7 +13,7 @@ use rustc_hir::{
     TraitBoundModifier, TraitItem, TraitRef, Ty, TyKind, WherePredicate,
 };
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::{BytePos, Span};
 use std::collections::hash_map::Entry;
 
diff --git a/clippy_lints/src/transmute/mod.rs b/clippy_lints/src/transmute/mod.rs
index a3a50acb609..95a92afea66 100644
--- a/clippy_lints/src/transmute/mod.rs
+++ b/clippy_lints/src/transmute/mod.rs
@@ -21,7 +21,7 @@ use clippy_config::msrvs::Msrv;
 use clippy_utils::in_constant;
 use rustc_hir::{Expr, ExprKind, QPath};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::symbol::sym;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/tuple_array_conversions.rs b/clippy_lints/src/tuple_array_conversions.rs
index 642e39e8270..e1cd82e18d5 100644
--- a/clippy_lints/src/tuple_array_conversions.rs
+++ b/clippy_lints/src/tuple_array_conversions.rs
@@ -8,7 +8,7 @@ use rustc_hir::{Expr, ExprKind, Node, PatKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::{self, Ty};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use std::iter::once;
 use std::ops::ControlFlow;
 
diff --git a/clippy_lints/src/types/mod.rs b/clippy_lints/src/types/mod.rs
index f333b2cdcb4..4b6810b684b 100644
--- a/clippy_lints/src/types/mod.rs
+++ b/clippy_lints/src/types/mod.rs
@@ -16,7 +16,7 @@ use rustc_hir::{
     TraitItemKind, TyKind,
 };
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::def_id::LocalDefId;
 use rustc_span::Span;
 
diff --git a/clippy_lints/src/undocumented_unsafe_blocks.rs b/clippy_lints/src/undocumented_unsafe_blocks.rs
index 32aebdd8c0f..2e68bfe391e 100644
--- a/clippy_lints/src/undocumented_unsafe_blocks.rs
+++ b/clippy_lints/src/undocumented_unsafe_blocks.rs
@@ -11,7 +11,7 @@ use rustc_hir::{Block, BlockCheckMode, ItemKind, Node, UnsafeSource};
 use rustc_lexer::{tokenize, TokenKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::{BytePos, Pos, RelativeBytePos, Span, SyntaxContext};
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/unicode.rs b/clippy_lints/src/unicode.rs
index b824deac2c8..3d319b9fe76 100644
--- a/clippy_lints/src/unicode.rs
+++ b/clippy_lints/src/unicode.rs
@@ -6,7 +6,7 @@ use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, HirId};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::Span;
 use unicode_normalization::UnicodeNormalization;
 
diff --git a/clippy_lints/src/uninit_vec.rs b/clippy_lints/src/uninit_vec.rs
index a7119434517..fc8519d5628 100644
--- a/clippy_lints/src/uninit_vec.rs
+++ b/clippy_lints/src/uninit_vec.rs
@@ -6,7 +6,7 @@ use rustc_hir::{Block, Expr, ExprKind, HirId, PatKind, PathSegment, Stmt, StmtKi
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::{sym, Span};
 
 // TODO: add `ReadBuf` (RFC 2930) in "How to fix" once it is available in std
diff --git a/clippy_lints/src/unit_return_expecting_ord.rs b/clippy_lints/src/unit_return_expecting_ord.rs
index 385f8255a39..ad76e4c1f53 100644
--- a/clippy_lints/src/unit_return_expecting_ord.rs
+++ b/clippy_lints/src/unit_return_expecting_ord.rs
@@ -4,7 +4,7 @@ use rustc_hir::{Closure, Expr, ExprKind, StmtKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
 use rustc_middle::ty::{ClauseKind, GenericPredicates, ProjectionPredicate, TraitPredicate};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::{sym, BytePos, Span};
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/unit_types/mod.rs b/clippy_lints/src/unit_types/mod.rs
index 884c6ca4d31..0abd48e6423 100644
--- a/clippy_lints/src/unit_types/mod.rs
+++ b/clippy_lints/src/unit_types/mod.rs
@@ -5,7 +5,7 @@ mod utils;
 
 use rustc_hir::{Expr, Local};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/unnamed_address.rs b/clippy_lints/src/unnamed_address.rs
index 2223cbcb060..41e13e13e56 100644
--- a/clippy_lints/src/unnamed_address.rs
+++ b/clippy_lints/src/unnamed_address.rs
@@ -2,7 +2,7 @@ use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::sym;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/unnecessary_box_returns.rs b/clippy_lints/src/unnecessary_box_returns.rs
index ca159eb4d5f..a05fa149c4d 100644
--- a/clippy_lints/src/unnecessary_box_returns.rs
+++ b/clippy_lints/src/unnecessary_box_returns.rs
@@ -4,7 +4,7 @@ use rustc_errors::Applicability;
 use rustc_hir::def_id::LocalDefId;
 use rustc_hir::{FnDecl, FnRetTy, ImplItemKind, Item, ItemKind, Node, TraitItem, TraitItemKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::Symbol;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/unnecessary_map_on_constructor.rs b/clippy_lints/src/unnecessary_map_on_constructor.rs
index 5c880288430..148ad87beb2 100644
--- a/clippy_lints/src/unnecessary_map_on_constructor.rs
+++ b/clippy_lints/src/unnecessary_map_on_constructor.rs
@@ -4,7 +4,7 @@ use clippy_utils::ty::get_type_diagnostic_name;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::sym;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/unnecessary_owned_empty_strings.rs b/clippy_lints/src/unnecessary_owned_empty_strings.rs
index 14694bb3a28..6b5e6c6ab20 100644
--- a/clippy_lints/src/unnecessary_owned_empty_strings.rs
+++ b/clippy_lints/src/unnecessary_owned_empty_strings.rs
@@ -6,7 +6,7 @@ use rustc_errors::Applicability;
 use rustc_hir::{BorrowKind, Expr, ExprKind, LangItem, Mutability};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::symbol::sym;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/unnecessary_self_imports.rs b/clippy_lints/src/unnecessary_self_imports.rs
index 1e2b20469ef..ddee06b59ca 100644
--- a/clippy_lints/src/unnecessary_self_imports.rs
+++ b/clippy_lints/src/unnecessary_self_imports.rs
@@ -2,7 +2,7 @@ use clippy_utils::diagnostics::span_lint_and_then;
 use rustc_ast::{Item, ItemKind, UseTreeKind};
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::symbol::kw;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/unnecessary_struct_initialization.rs b/clippy_lints/src/unnecessary_struct_initialization.rs
index c35a2afab48..ed4d87ef8f8 100644
--- a/clippy_lints/src/unnecessary_struct_initialization.rs
+++ b/clippy_lints/src/unnecessary_struct_initialization.rs
@@ -4,7 +4,7 @@ use clippy_utils::ty::is_copy;
 use clippy_utils::{get_parent_expr, path_to_local};
 use rustc_hir::{BindingAnnotation, Expr, ExprKind, Node, PatKind, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/unnecessary_wraps.rs b/clippy_lints/src/unnecessary_wraps.rs
index 5599a9dc4e8..a5f087aaf5b 100644
--- a/clippy_lints/src/unnecessary_wraps.rs
+++ b/clippy_lints/src/unnecessary_wraps.rs
@@ -8,7 +8,7 @@ use rustc_hir::LangItem::{OptionSome, ResultOk};
 use rustc_hir::{Body, ExprKind, FnDecl, Impl, ItemKind, Node};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::def_id::LocalDefId;
 use rustc_span::symbol::sym;
 use rustc_span::Span;
diff --git a/clippy_lints/src/unnested_or_patterns.rs b/clippy_lints/src/unnested_or_patterns.rs
index 8ff088a208f..14d5bac7177 100644
--- a/clippy_lints/src/unnested_or_patterns.rs
+++ b/clippy_lints/src/unnested_or_patterns.rs
@@ -11,7 +11,7 @@ use rustc_ast::{self as ast, Mutability, Pat, PatKind, DUMMY_NODE_ID};
 use rustc_ast_pretty::pprust;
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::DUMMY_SP;
 use std::cell::Cell;
 use std::mem;
diff --git a/clippy_lints/src/unsafe_removed_from_name.rs b/clippy_lints/src/unsafe_removed_from_name.rs
index a7b2d2148e9..3f2f765f751 100644
--- a/clippy_lints/src/unsafe_removed_from_name.rs
+++ b/clippy_lints/src/unsafe_removed_from_name.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::span_lint;
 use rustc_ast::ast::{Item, ItemKind, UseTree, UseTreeKind};
 use rustc_lint::{EarlyContext, EarlyLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::symbol::Ident;
 use rustc_span::Span;
 
diff --git a/clippy_lints/src/unused_async.rs b/clippy_lints/src/unused_async.rs
index aea72c798be..d72adf678a6 100644
--- a/clippy_lints/src/unused_async.rs
+++ b/clippy_lints/src/unused_async.rs
@@ -5,7 +5,7 @@ use rustc_hir::intravisit::{walk_body, walk_expr, walk_fn, FnKind, Visitor};
 use rustc_hir::{Body, Expr, ExprKind, FnDecl, Node, YieldSource};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::nested_filter;
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::def_id::{LocalDefId, LocalDefIdSet};
 use rustc_span::Span;
 
diff --git a/clippy_lints/src/unused_io_amount.rs b/clippy_lints/src/unused_io_amount.rs
index 0fcb62017c6..1de9adfcb96 100644
--- a/clippy_lints/src/unused_io_amount.rs
+++ b/clippy_lints/src/unused_io_amount.rs
@@ -2,7 +2,7 @@ use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
 use clippy_utils::{is_trait_method, is_try, match_trait_method, paths};
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::sym;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/unused_peekable.rs b/clippy_lints/src/unused_peekable.rs
index 0473ecaabeb..ba72b3450b9 100644
--- a/clippy_lints/src/unused_peekable.rs
+++ b/clippy_lints/src/unused_peekable.rs
@@ -6,7 +6,7 @@ use rustc_hir::intravisit::{walk_expr, Visitor};
 use rustc_hir::{Block, Expr, ExprKind, HirId, Local, Node, PatKind, PathSegment, StmtKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::nested_filter::OnlyBodies;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::sym;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/unused_rounding.rs b/clippy_lints/src/unused_rounding.rs
index fbb36bea068..d5ca844b9e2 100644
--- a/clippy_lints/src/unused_rounding.rs
+++ b/clippy_lints/src/unused_rounding.rs
@@ -3,7 +3,7 @@ use clippy_utils::source::snippet;
 use rustc_ast::ast::{Expr, ExprKind, MethodCall};
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/unused_self.rs b/clippy_lints/src/unused_self.rs
index 532207310bc..a67f53f00ae 100644
--- a/clippy_lints/src/unused_self.rs
+++ b/clippy_lints/src/unused_self.rs
@@ -3,7 +3,7 @@ use clippy_utils::macros::root_macro_call_first_node;
 use clippy_utils::visitors::is_local_used;
 use rustc_hir::{Body, Impl, ImplItem, ImplItemKind, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use std::ops::ControlFlow;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/unused_unit.rs b/clippy_lints/src/unused_unit.rs
index 9627f4c7454..0a73da202ec 100644
--- a/clippy_lints/src/unused_unit.rs
+++ b/clippy_lints/src/unused_unit.rs
@@ -4,7 +4,7 @@ use rustc_ast::visit::FnKind;
 use rustc_ast::{ast, ClosureBinder};
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::{BytePos, Span};
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/unwrap.rs b/clippy_lints/src/unwrap.rs
index 6e1d0e09fe2..ae2ac38cffe 100644
--- a/clippy_lints/src/unwrap.rs
+++ b/clippy_lints/src/unwrap.rs
@@ -12,7 +12,7 @@ use rustc_middle::hir::nested_filter;
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::mir::FakeReadCause;
 use rustc_middle::ty::{self, Ty, TyCtxt};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::def_id::LocalDefId;
 use rustc_span::{sym, Span};
 
diff --git a/clippy_lints/src/unwrap_in_result.rs b/clippy_lints/src/unwrap_in_result.rs
index df4b42133f8..a615ef11691 100644
--- a/clippy_lints/src/unwrap_in_result.rs
+++ b/clippy_lints/src/unwrap_in_result.rs
@@ -6,7 +6,7 @@ use core::ops::ControlFlow;
 use rustc_hir as hir;
 use rustc_hir::ImplItemKind;
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::{sym, Span};
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/upper_case_acronyms.rs b/clippy_lints/src/upper_case_acronyms.rs
index de6a75b79fc..0d559821386 100644
--- a/clippy_lints/src/upper_case_acronyms.rs
+++ b/clippy_lints/src/upper_case_acronyms.rs
@@ -4,7 +4,7 @@ use rustc_errors::Applicability;
 use rustc_hir::{Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::symbol::Ident;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/use_self.rs b/clippy_lints/src/use_self.rs
index f058fe5f831..4fa92a45b96 100644
--- a/clippy_lints/src/use_self.rs
+++ b/clippy_lints/src/use_self.rs
@@ -13,7 +13,7 @@ use rustc_hir::{
 };
 use rustc_hir_analysis::hir_ty_to_ty;
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::Span;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/useless_conversion.rs b/clippy_lints/src/useless_conversion.rs
index 52327b82e84..ab6bd10aaba 100644
--- a/clippy_lints/src/useless_conversion.rs
+++ b/clippy_lints/src/useless_conversion.rs
@@ -12,7 +12,7 @@ use rustc_infer::traits::Obligation;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::traits::ObligationCause;
 use rustc_middle::ty::{self, EarlyBinder, GenericArg, GenericArgsRef, Ty, TypeVisitableExt};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::{sym, Span};
 use rustc_trait_selection::traits::query::evaluate_obligation::InferCtxtExt;
 
diff --git a/clippy_lints/src/utils/internal_lints/almost_standard_lint_formulation.rs b/clippy_lints/src/utils/internal_lints/almost_standard_lint_formulation.rs
index d78f67c05f0..5ddedb24b15 100644
--- a/clippy_lints/src/utils/internal_lints/almost_standard_lint_formulation.rs
+++ b/clippy_lints/src/utils/internal_lints/almost_standard_lint_formulation.rs
@@ -4,7 +4,7 @@ use regex::Regex;
 use rustc_ast as ast;
 use rustc_hir::{Item, ItemKind, Mutability};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/utils/internal_lints/collapsible_calls.rs b/clippy_lints/src/utils/internal_lints/collapsible_calls.rs
index f514f166cff..7c70d3f45db 100644
--- a/clippy_lints/src/utils/internal_lints/collapsible_calls.rs
+++ b/clippy_lints/src/utils/internal_lints/collapsible_calls.rs
@@ -5,7 +5,7 @@ use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_hir::{Closure, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 
 use std::borrow::{Borrow, Cow};
 
diff --git a/clippy_lints/src/utils/internal_lints/compiler_lint_functions.rs b/clippy_lints/src/utils/internal_lints/compiler_lint_functions.rs
index 5aa1417cfb4..5059712d69c 100644
--- a/clippy_lints/src/utils/internal_lints/compiler_lint_functions.rs
+++ b/clippy_lints/src/utils/internal_lints/compiler_lint_functions.rs
@@ -4,7 +4,7 @@ use clippy_utils::{is_lint_allowed, paths};
 use rustc_data_structures::fx::FxHashMap;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/utils/internal_lints/interning_defined_symbol.rs b/clippy_lints/src/utils/internal_lints/interning_defined_symbol.rs
index 16d0636b834..07879e81fc2 100644
--- a/clippy_lints/src/utils/internal_lints/interning_defined_symbol.rs
+++ b/clippy_lints/src/utils/internal_lints/interning_defined_symbol.rs
@@ -11,7 +11,7 @@ use rustc_hir::{BinOpKind, Expr, ExprKind, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::mir::ConstValue;
 use rustc_middle::ty;
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::sym;
 use rustc_span::symbol::Symbol;
 
diff --git a/clippy_lints/src/utils/internal_lints/invalid_paths.rs b/clippy_lints/src/utils/internal_lints/invalid_paths.rs
index 66d32087fcd..4fb615e1d57 100644
--- a/clippy_lints/src/utils/internal_lints/invalid_paths.rs
+++ b/clippy_lints/src/utils/internal_lints/invalid_paths.rs
@@ -7,7 +7,7 @@ use rustc_hir::Item;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::fast_reject::SimplifiedType;
 use rustc_middle::ty::FloatTy;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::symbol::Symbol;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/utils/internal_lints/lint_without_lint_pass.rs b/clippy_lints/src/utils/internal_lints/lint_without_lint_pass.rs
index 486e8220484..370ed430bcf 100644
--- a/clippy_lints/src/utils/internal_lints/lint_without_lint_pass.rs
+++ b/clippy_lints/src/utils/internal_lints/lint_without_lint_pass.rs
@@ -11,7 +11,7 @@ use rustc_hir::{ExprKind, HirId, Item, MutTy, Mutability, Path, TyKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::nested_filter;
 use rustc_semver::RustcVersion;
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::source_map::Spanned;
 use rustc_span::symbol::Symbol;
 use rustc_span::{sym, Span};
diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index 8ecdba47f89..f60ff1a93c7 100644
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -22,7 +22,7 @@ use rustc_hir::intravisit::Visitor;
 use rustc_hir::{self as hir, intravisit, Closure, ExprKind, Item, ItemKind, Mutability, QPath};
 use rustc_lint::{CheckLintNameResult, LateContext, LateLintPass, LintContext, LintId};
 use rustc_middle::hir::nested_filter;
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::symbol::Ident;
 use rustc_span::{sym, Loc, Span, Symbol};
 use serde::ser::SerializeStruct;
diff --git a/clippy_lints/src/utils/internal_lints/msrv_attr_impl.rs b/clippy_lints/src/utils/internal_lints/msrv_attr_impl.rs
index 86b1a0ae624..6d5240db832 100644
--- a/clippy_lints/src/utils/internal_lints/msrv_attr_impl.rs
+++ b/clippy_lints/src/utils/internal_lints/msrv_attr_impl.rs
@@ -6,7 +6,7 @@ use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::ty::{self, EarlyBinder, GenericArgKind};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/utils/internal_lints/outer_expn_data_pass.rs b/clippy_lints/src/utils/internal_lints/outer_expn_data_pass.rs
index 77b95e51f62..326e1721461 100644
--- a/clippy_lints/src/utils/internal_lints/outer_expn_data_pass.rs
+++ b/clippy_lints/src/utils/internal_lints/outer_expn_data_pass.rs
@@ -4,7 +4,7 @@ use clippy_utils::{is_lint_allowed, method_calls, paths};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::symbol::Symbol;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/utils/internal_lints/produce_ice.rs b/clippy_lints/src/utils/internal_lints/produce_ice.rs
index 5899b94e16b..9169e2968eb 100644
--- a/clippy_lints/src/utils/internal_lints/produce_ice.rs
+++ b/clippy_lints/src/utils/internal_lints/produce_ice.rs
@@ -1,7 +1,7 @@
 use rustc_ast::ast::NodeId;
 use rustc_ast::visit::FnKind;
 use rustc_lint::{EarlyContext, EarlyLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::Span;
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/utils/internal_lints/unnecessary_def_path.rs b/clippy_lints/src/utils/internal_lints/unnecessary_def_path.rs
index 9aa23b6efe3..70ca1b206b4 100644
--- a/clippy_lints/src/utils/internal_lints/unnecessary_def_path.rs
+++ b/clippy_lints/src/utils/internal_lints/unnecessary_def_path.rs
@@ -12,7 +12,7 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::mir::interpret::{Allocation, GlobalAlloc};
 use rustc_middle::mir::ConstValue;
 use rustc_middle::ty::{self, Ty};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::symbol::Symbol;
 use rustc_span::Span;
 
diff --git a/clippy_lints/src/utils/internal_lints/unsorted_clippy_utils_paths.rs b/clippy_lints/src/utils/internal_lints/unsorted_clippy_utils_paths.rs
index fd51bca9e5b..a5c4bf474f7 100644
--- a/clippy_lints/src/utils/internal_lints/unsorted_clippy_utils_paths.rs
+++ b/clippy_lints/src/utils/internal_lints/unsorted_clippy_utils_paths.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::span_lint;
 use rustc_ast::ast::{Crate, ItemKind, ModKind};
 use rustc_lint::{EarlyContext, EarlyLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/vec.rs b/clippy_lints/src/vec.rs
index f58641289f8..d49d3cc4cc9 100644
--- a/clippy_lints/src/vec.rs
+++ b/clippy_lints/src/vec.rs
@@ -12,7 +12,7 @@ use rustc_hir::{BorrowKind, Expr, ExprKind, Mutability, Node, PatKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::layout::LayoutOf;
 use rustc_middle::ty::{self, Ty};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::{sym, Span};
 
 #[expect(clippy::module_name_repetitions)]
diff --git a/clippy_lints/src/vec_init_then_push.rs b/clippy_lints/src/vec_init_then_push.rs
index c8b9402f1ae..ac3b2bdaf65 100644
--- a/clippy_lints/src/vec_init_then_push.rs
+++ b/clippy_lints/src/vec_init_then_push.rs
@@ -11,7 +11,7 @@ use rustc_hir::{
 };
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::{Span, Symbol};
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/visibility.rs b/clippy_lints/src/visibility.rs
index 8abcc964b89..83369c66367 100644
--- a/clippy_lints/src/visibility.rs
+++ b/clippy_lints/src/visibility.rs
@@ -4,7 +4,7 @@ use rustc_ast::ast::{Item, VisibilityKind};
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::symbol::kw;
 use rustc_span::Span;
 
diff --git a/clippy_lints/src/wildcard_imports.rs b/clippy_lints/src/wildcard_imports.rs
index 5c1bea74486..9b0dac6af25 100644
--- a/clippy_lints/src/wildcard_imports.rs
+++ b/clippy_lints/src/wildcard_imports.rs
@@ -6,7 +6,7 @@ use rustc_hir::def::{DefKind, Res};
 use rustc_hir::{Item, ItemKind, PathSegment, UseKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::ty;
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::symbol::kw;
 use rustc_span::{sym, BytePos};
 
diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs
index b6f942a90d3..be16d2e5cc3 100644
--- a/clippy_lints/src/write.rs
+++ b/clippy_lints/src/write.rs
@@ -10,7 +10,7 @@ use rustc_ast::{
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, Impl, Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
-use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_session::impl_lint_pass;
 use rustc_span::{sym, BytePos, Span};
 
 declare_clippy_lint! {
diff --git a/clippy_lints/src/zero_div_zero.rs b/clippy_lints/src/zero_div_zero.rs
index 1d6217d186c..d3623d6fda4 100644
--- a/clippy_lints/src/zero_div_zero.rs
+++ b/clippy_lints/src/zero_div_zero.rs
@@ -2,7 +2,7 @@ use clippy_utils::consts::{constant_simple, Constant};
 use clippy_utils::diagnostics::span_lint_and_help;
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/zero_sized_map_values.rs b/clippy_lints/src/zero_sized_map_values.rs
index 41c1757fde8..fba3808261a 100644
--- a/clippy_lints/src/zero_sized_map_values.rs
+++ b/clippy_lints/src/zero_sized_map_values.rs
@@ -5,7 +5,7 @@ use rustc_hir_analysis::hir_ty_to_ty;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::layout::LayoutOf as _;
 use rustc_middle::ty::{Adt, Ty, TypeVisitableExt};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::sym;
 
 declare_clippy_lint! {
diff --git a/declare_clippy_lint/src/lib.rs b/declare_clippy_lint/src/lib.rs
index dc3037f6669..25b2fc9395c 100644
--- a/declare_clippy_lint/src/lib.rs
+++ b/declare_clippy_lint/src/lib.rs
@@ -148,7 +148,7 @@ pub fn declare_clippy_lint(input: TokenStream) -> TokenStream {
     let category_variant = format_ident!("{category}");
 
     let output = quote! {
-        declare_tool_lint! {
+        rustc_session::declare_tool_lint! {
             #(#attrs)*
             pub clippy::#name,
             #level,
-- 
cgit 1.4.1-3-g733a5


From 23d533264fd5a4b80cffcefa73a6ddb207c9f6e2 Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Sun, 26 Nov 2023 18:11:50 +0100
Subject: Fix `box_default` behaviour with empty `vec![]` coming from macro arg

---
 clippy_lints/src/box_default.rs | 10 +++++-----
 tests/ui/box_default.fixed      | 14 ++++++++++++++
 tests/ui/box_default.rs         | 14 ++++++++++++++
 3 files changed, 33 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/box_default.rs b/clippy_lints/src/box_default.rs
index b69dc5c1291..ef12fe344e4 100644
--- a/clippy_lints/src/box_default.rs
+++ b/clippy_lints/src/box_default.rs
@@ -45,7 +45,7 @@ impl LateLintPass<'_> for BoxDefault {
             && let ExprKind::Path(QPath::TypeRelative(ty, seg)) = box_new.kind
             && let ExprKind::Call(arg_path, ..) = arg.kind
             && !in_external_macro(cx.sess(), expr.span)
-            && (expr.span.eq_ctxt(arg.span) || is_vec_expn(cx, arg))
+            && (expr.span.eq_ctxt(arg.span) || is_local_vec_expn(cx, arg, expr))
             && seg.ident.name == sym::new
             && path_def_id(cx, ty).map_or(false, |id| Some(id) == cx.tcx.lang_items().owned_box())
             && is_default_equivalent(cx, arg)
@@ -81,10 +81,10 @@ fn is_plain_default(cx: &LateContext<'_>, arg_path: &Expr<'_>) -> bool {
     }
 }
 
-fn is_vec_expn(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-    macro_backtrace(expr.span)
-        .next()
-        .map_or(false, |call| cx.tcx.is_diagnostic_item(sym::vec_macro, call.def_id))
+fn is_local_vec_expn(cx: &LateContext<'_>, expr: &Expr<'_>, ref_expr: &Expr<'_>) -> bool {
+    macro_backtrace(expr.span).next().map_or(false, |call| {
+        cx.tcx.is_diagnostic_item(sym::vec_macro, call.def_id) && call.span.eq_ctxt(ref_expr.span)
+    })
 }
 
 #[derive(Default)]
diff --git a/tests/ui/box_default.fixed b/tests/ui/box_default.fixed
index 69cabcb32d3..48408e19125 100644
--- a/tests/ui/box_default.fixed
+++ b/tests/ui/box_default.fixed
@@ -90,3 +90,17 @@ fn issue_10381() {
 
     assert!(maybe_get_bar(2).is_some());
 }
+
+#[allow(unused)]
+fn issue_11868() {
+    fn foo(_: &mut Vec<usize>) {}
+
+    macro_rules! bar {
+        ($baz:expr) => {
+            Box::leak(Box::new($baz))
+        };
+    }
+
+    foo(bar!(vec![]));
+    foo(bar!(vec![1]));
+}
diff --git a/tests/ui/box_default.rs b/tests/ui/box_default.rs
index 48fa8bc33bc..58b91270747 100644
--- a/tests/ui/box_default.rs
+++ b/tests/ui/box_default.rs
@@ -90,3 +90,17 @@ fn issue_10381() {
 
     assert!(maybe_get_bar(2).is_some());
 }
+
+#[allow(unused)]
+fn issue_11868() {
+    fn foo(_: &mut Vec<usize>) {}
+
+    macro_rules! bar {
+        ($baz:expr) => {
+            Box::leak(Box::new($baz))
+        };
+    }
+
+    foo(bar!(vec![]));
+    foo(bar!(vec![1]));
+}
-- 
cgit 1.4.1-3-g733a5


From 0d09cb0a6b22066ccf1470b35f50886d675108d1 Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Sun, 26 Nov 2023 22:46:13 +0100
Subject: `manual_try_fold`: check that `fold` is really `Iterator::fold`

---
 clippy_lints/src/methods/manual_try_fold.rs |  5 +++--
 tests/ui/manual_try_fold.rs                 | 30 +++++++++++++++++++++++++++++
 2 files changed, 33 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/manual_try_fold.rs b/clippy_lints/src/methods/manual_try_fold.rs
index 51145afda7f..f93edded729 100644
--- a/clippy_lints/src/methods/manual_try_fold.rs
+++ b/clippy_lints/src/methods/manual_try_fold.rs
@@ -1,14 +1,14 @@
 use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::is_from_proc_macro;
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::implements_trait;
+use clippy_utils::{is_from_proc_macro, is_trait_method};
 use rustc_errors::Applicability;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_span::Span;
+use rustc_span::{sym, Span};
 
 use super::MANUAL_TRY_FOLD;
 
@@ -22,6 +22,7 @@ pub(super) fn check<'tcx>(
 ) {
     if !in_external_macro(cx.sess(), fold_span)
         && msrv.meets(msrvs::ITERATOR_TRY_FOLD)
+        && is_trait_method(cx, expr, sym::Iterator)
         && let init_ty = cx.typeck_results().expr_ty(init)
         && let Some(try_trait) = cx.tcx.lang_items().try_trait()
         && implements_trait(cx, init_ty, try_trait, &[])
diff --git a/tests/ui/manual_try_fold.rs b/tests/ui/manual_try_fold.rs
index bddf03ac3f1..7299d7cf986 100644
--- a/tests/ui/manual_try_fold.rs
+++ b/tests/ui/manual_try_fold.rs
@@ -96,3 +96,33 @@ fn msrv_juust_right() {
         .fold(Some(0i32), |sum, i| sum?.checked_add(*i))
         .unwrap();
 }
+
+mod issue11876 {
+    struct Foo;
+
+    impl Bar for Foo {
+        type Output = u32;
+    }
+
+    trait Bar: Sized {
+        type Output;
+        fn fold<A, F>(self, init: A, func: F) -> Fold<Self, A, F>
+        where
+            A: Clone,
+            F: Fn(A, Self::Output) -> A,
+        {
+            Fold { this: self, init, func }
+        }
+    }
+
+    #[allow(dead_code)]
+    struct Fold<S, A, F> {
+        this: S,
+        init: A,
+        func: F,
+    }
+
+    fn main() {
+        Foo.fold(Some(0), |acc, entry| Some(acc? + entry));
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 0d26f9183b3d8b9354c35d6ecdd4c1367d5d5eec Mon Sep 17 00:00:00 2001
From: J-ZhengLi <lizheng135@huawei.com>
Date: Mon, 27 Nov 2023 10:30:47 +0800
Subject: eliminate the second `visit` to save a bit performance.

Thanks @y21 for the hint!
---
 clippy_lints/src/loops/infinite_loops.rs | 39 ++++++++++++--------------------
 1 file changed, 14 insertions(+), 25 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/infinite_loops.rs b/clippy_lints/src/loops/infinite_loops.rs
index 06f94c075eb..5e474bf45ee 100644
--- a/clippy_lints/src/loops/infinite_loops.rs
+++ b/clippy_lints/src/loops/infinite_loops.rs
@@ -34,27 +34,15 @@ pub(super) fn check<'tcx>(
         return;
     }
 
-    // First, find any `break` or `return` without entering any inner loop,
-    // then, find `return` or labeled `break` which breaks this loop with entering inner loop,
-    // otherwise this loop is a infinite loop.
-    let mut direct_visitor = LoopVisitor {
+    let mut loop_visitor = LoopVisitor {
         cx,
         label,
         is_finite: false,
-        enter_nested_loop: false,
+        loop_depth: 0,
     };
-    direct_visitor.visit_block(loop_block);
+    loop_visitor.visit_block(loop_block);
 
-    let is_finite_loop = direct_visitor.is_finite || {
-        let mut inner_loop_visitor = LoopVisitor {
-            cx,
-            label,
-            is_finite: false,
-            enter_nested_loop: true,
-        };
-        inner_loop_visitor.visit_block(loop_block);
-        inner_loop_visitor.is_finite
-    };
+    let is_finite_loop = loop_visitor.is_finite;
 
     if !is_finite_loop {
         span_lint_and_then(cx, INFINITE_LOOPS, expr.span, "infinite loop detected", |diag| {
@@ -103,26 +91,27 @@ fn get_parent_fn_ret_ty<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>) -> Option
 struct LoopVisitor<'hir, 'tcx> {
     cx: &'hir LateContext<'tcx>,
     label: Option<Label>,
+    loop_depth: usize,
     is_finite: bool,
-    enter_nested_loop: bool,
 }
 
 impl<'hir> Visitor<'hir> for LoopVisitor<'hir, '_> {
     fn visit_expr(&mut self, ex: &'hir Expr<'_>) {
         match &ex.kind {
             ExprKind::Break(hir::Destination { label, .. }, ..) => {
-                // When entering nested loop, only by breaking this loop's label
-                // would be considered as exiting this loop.
-                if self.enter_nested_loop {
-                    if label.is_some() && *label == self.label {
-                        self.is_finite = true;
-                    }
-                } else {
+                // Assuming breaks the loop when `loop_depth` is 0,
+                // as it could only means this `break` breaks current loop or any of its upper loop.
+                // Or, the depth is not zero but the label is matched.
+                if self.loop_depth == 0 || (label.is_some() && *label == self.label) {
                     self.is_finite = true;
                 }
             },
             ExprKind::Ret(..) => self.is_finite = true,
-            ExprKind::Loop(..) if !self.enter_nested_loop => (),
+            ExprKind::Loop(..) => {
+                self.loop_depth += 1;
+                walk_expr(self, ex);
+                self.loop_depth = self.loop_depth.saturating_sub(1);
+            },
             _ => {
                 // Calls to a function that never return
                 if let Some(did) = fn_def_id(self.cx, ex) {
-- 
cgit 1.4.1-3-g733a5


From 1661e7ee76955d7e887f0bab568c9fa012ee93af Mon Sep 17 00:00:00 2001
From: Kisaragi Marine <kisaragi.effective@gmail.com>
Date: Mon, 27 Nov 2023 23:43:39 +0900
Subject: re-implement fix for rust-lang#11357

---
 clippy_lints/src/redundant_closure_call.rs     | 17 ++++++-----
 tests/ui/redundant_closure_call_fixable.fixed  | 15 +++++++++
 tests/ui/redundant_closure_call_fixable.rs     | 15 +++++++++
 tests/ui/redundant_closure_call_fixable.stderr | 42 +++++++++++++++++---------
 4 files changed, 67 insertions(+), 22 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/redundant_closure_call.rs b/clippy_lints/src/redundant_closure_call.rs
index 7971a5d86e3..efdd78a1c92 100644
--- a/clippy_lints/src/redundant_closure_call.rs
+++ b/clippy_lints/src/redundant_closure_call.rs
@@ -4,8 +4,8 @@ use clippy_utils::get_parent_expr;
 use clippy_utils::sugg::Sugg;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
-use rustc_hir::intravisit as hir_visit;
 use rustc_hir::intravisit::{Visitor as HirVisitor, Visitor};
+use rustc_hir::{intravisit as hir_visit, CoroutineKind, CoroutineSource};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::nested_filter;
 use rustc_middle::lint::in_external_macro;
@@ -60,11 +60,14 @@ impl<'tcx> Visitor<'tcx> for ReturnVisitor {
     }
 }
 
-/// Checks if the body is owned by an async closure
-fn is_async_closure(body: &hir::Body<'_>) -> bool {
-    if let hir::ExprKind::Closure(closure) = body.value.kind
-        && let [resume_ty] = closure.fn_decl.inputs
-        && let hir::TyKind::Path(hir::QPath::LangItem(hir::LangItem::ResumeTy, ..)) = resume_ty.kind
+/// Checks if the body is owned by an async closure.
+/// Returns true for `async || whatever_expression`, but false for `|| async { whatever_expression
+/// }`.
+fn is_async_closure(cx: &LateContext<'_>, body: &hir::Body<'_>) -> bool {
+    if let hir::ExprKind::Closure(innermost_closure_generated_by_desugar) = body.value.kind
+        && let desugared_inner_closure_body = cx.tcx.hir().body(innermost_closure_generated_by_desugar.body)
+        // checks whether it is `async || whatever_expression`
+        && let Some(CoroutineKind::Async(CoroutineSource::Closure)) = desugared_inner_closure_body.coroutine_kind
     {
         true
     } else {
@@ -100,7 +103,7 @@ fn find_innermost_closure<'tcx>(
         data = Some((
             body.value,
             closure.fn_decl,
-            if is_async_closure(body) {
+            if is_async_closure(cx, body) {
                 ty::Asyncness::Yes
             } else {
                 ty::Asyncness::No
diff --git a/tests/ui/redundant_closure_call_fixable.fixed b/tests/ui/redundant_closure_call_fixable.fixed
index bf268d0b583..f2cd9862af6 100644
--- a/tests/ui/redundant_closure_call_fixable.fixed
+++ b/tests/ui/redundant_closure_call_fixable.fixed
@@ -3,6 +3,7 @@
 #![allow(clippy::redundant_async_block)]
 #![allow(clippy::type_complexity)]
 #![allow(unused)]
+#![allow(clippy::double_parens)]
 
 async fn something() -> u32 {
     21
@@ -84,3 +85,17 @@ fn issue9956() {
     bar()(42, 5);
     foo(42, 5);
 }
+
+async fn issue11357() {
+    (async {}).await;
+}
+
+mod issue11707 {
+    use core::future::Future;
+
+    fn spawn_on(fut: impl Future<Output = ()>) {}
+
+    fn demo() {
+        spawn_on((async move {}));
+    }
+}
diff --git a/tests/ui/redundant_closure_call_fixable.rs b/tests/ui/redundant_closure_call_fixable.rs
index c8a91049d19..84c6fba5221 100644
--- a/tests/ui/redundant_closure_call_fixable.rs
+++ b/tests/ui/redundant_closure_call_fixable.rs
@@ -3,6 +3,7 @@
 #![allow(clippy::redundant_async_block)]
 #![allow(clippy::type_complexity)]
 #![allow(unused)]
+#![allow(clippy::double_parens)]
 
 async fn something() -> u32 {
     21
@@ -84,3 +85,17 @@ fn issue9956() {
     bar()((|| || 42)()(), 5);
     foo((|| || 42)()(), 5);
 }
+
+async fn issue11357() {
+    (|| async {})().await;
+}
+
+mod issue11707 {
+    use core::future::Future;
+
+    fn spawn_on(fut: impl Future<Output = ()>) {}
+
+    fn demo() {
+        spawn_on(((|| async move {})()));
+    }
+}
diff --git a/tests/ui/redundant_closure_call_fixable.stderr b/tests/ui/redundant_closure_call_fixable.stderr
index a7cdb43693f..9ba5a7c0d17 100644
--- a/tests/ui/redundant_closure_call_fixable.stderr
+++ b/tests/ui/redundant_closure_call_fixable.stderr
@@ -1,5 +1,5 @@
 error: try not to call a closure in the expression where it is declared
-  --> $DIR/redundant_closure_call_fixable.rs:16:13
+  --> $DIR/redundant_closure_call_fixable.rs:17:13
    |
 LL |     let a = (|| 42)();
    |             ^^^^^^^^^ help: try doing something like: `42`
@@ -8,7 +8,7 @@ LL |     let a = (|| 42)();
    = help: to override `-D warnings` add `#[allow(clippy::redundant_closure_call)]`
 
 error: try not to call a closure in the expression where it is declared
-  --> $DIR/redundant_closure_call_fixable.rs:17:13
+  --> $DIR/redundant_closure_call_fixable.rs:18:13
    |
 LL |       let b = (async || {
    |  _____________^
@@ -28,7 +28,7 @@ LL ~     };
    |
 
 error: try not to call a closure in the expression where it is declared
-  --> $DIR/redundant_closure_call_fixable.rs:22:13
+  --> $DIR/redundant_closure_call_fixable.rs:23:13
    |
 LL |       let c = (|| {
    |  _____________^
@@ -48,13 +48,13 @@ LL ~     };
    |
 
 error: try not to call a closure in the expression where it is declared
-  --> $DIR/redundant_closure_call_fixable.rs:27:13
+  --> $DIR/redundant_closure_call_fixable.rs:28:13
    |
 LL |     let d = (async || something().await)();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try doing something like: `async { something().await }`
 
 error: try not to call a closure in the expression where it is declared
-  --> $DIR/redundant_closure_call_fixable.rs:36:13
+  --> $DIR/redundant_closure_call_fixable.rs:37:13
    |
 LL |             (|| m!())()
    |             ^^^^^^^^^^^ help: try doing something like: `m!()`
@@ -65,7 +65,7 @@ LL |     m2!();
    = note: this error originates in the macro `m2` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: try not to call a closure in the expression where it is declared
-  --> $DIR/redundant_closure_call_fixable.rs:31:13
+  --> $DIR/redundant_closure_call_fixable.rs:32:13
    |
 LL |             (|| 0)()
    |             ^^^^^^^^ help: try doing something like: `0`
@@ -76,52 +76,64 @@ LL |     m2!();
    = note: this error originates in the macro `m` which comes from the expansion of the macro `m2` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: try not to call a closure in the expression where it is declared
-  --> $DIR/redundant_closure_call_fixable.rs:44:16
+  --> $DIR/redundant_closure_call_fixable.rs:45:16
    |
 LL |     assert_eq!((|| || 43)()(), 42);
    |                ^^^^^^^^^^^^^^ help: try doing something like: `43`
 
 error: try not to call a closure in the expression where it is declared
-  --> $DIR/redundant_closure_call_fixable.rs:53:10
+  --> $DIR/redundant_closure_call_fixable.rs:54:10
    |
 LL |     dbg!((|| 42)());
    |          ^^^^^^^^^ help: try doing something like: `42`
 
 error: try not to call a closure in the expression where it is declared
-  --> $DIR/redundant_closure_call_fixable.rs:56:13
+  --> $DIR/redundant_closure_call_fixable.rs:57:13
    |
 LL |     let a = (|| || || 123)();
    |             ^^^^^^^^^^^^^^^^ help: try doing something like: `(|| || 123)`
 
 error: try not to call a closure in the expression where it is declared
-  --> $DIR/redundant_closure_call_fixable.rs:60:13
+  --> $DIR/redundant_closure_call_fixable.rs:61:13
    |
 LL |     let a = (|| || || || async || 1)()()()()();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try doing something like: `async { 1 }`
 
 error: try not to call a closure in the expression where it is declared
-  --> $DIR/redundant_closure_call_fixable.rs:69:13
+  --> $DIR/redundant_closure_call_fixable.rs:70:13
    |
 LL |     let a = (|| echo!(|| echo!(|| 1)))()()();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try doing something like: `1`
 
 error: try not to call a closure in the expression where it is declared
-  --> $DIR/redundant_closure_call_fixable.rs:71:13
+  --> $DIR/redundant_closure_call_fixable.rs:72:13
    |
 LL |     let a = (|| echo!((|| 123)))()();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^ help: try doing something like: `123`
 
 error: try not to call a closure in the expression where it is declared
-  --> $DIR/redundant_closure_call_fixable.rs:84:11
+  --> $DIR/redundant_closure_call_fixable.rs:85:11
    |
 LL |     bar()((|| || 42)()(), 5);
    |           ^^^^^^^^^^^^^^ help: try doing something like: `42`
 
 error: try not to call a closure in the expression where it is declared
-  --> $DIR/redundant_closure_call_fixable.rs:85:9
+  --> $DIR/redundant_closure_call_fixable.rs:86:9
    |
 LL |     foo((|| || 42)()(), 5);
    |         ^^^^^^^^^^^^^^ help: try doing something like: `42`
 
-error: aborting due to 14 previous errors
+error: try not to call a closure in the expression where it is declared
+  --> $DIR/redundant_closure_call_fixable.rs:90:5
+   |
+LL |     (|| async {})().await;
+   |     ^^^^^^^^^^^^^^^ help: try doing something like: `(async {})`
+
+error: try not to call a closure in the expression where it is declared
+  --> $DIR/redundant_closure_call_fixable.rs:99:18
+   |
+LL |         spawn_on(((|| async move {})()));
+   |                  ^^^^^^^^^^^^^^^^^^^^^^ help: try doing something like: `(async move {})`
+
+error: aborting due to 16 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 33182495ac8045af2b20210dd628690c52332e44 Mon Sep 17 00:00:00 2001
From: Kisaragi Marine <kisaragi.effective@gmail.com>
Date: Tue, 28 Nov 2023 00:27:51 +0900
Subject: don't add paren on occurrences that is in call args

---
 clippy_lints/src/redundant_closure_call.rs     | 21 ++++++++----
 tests/ui/redundant_closure_call_fixable.fixed  |  9 ++++--
 tests/ui/redundant_closure_call_fixable.rs     |  5 ++-
 tests/ui/redundant_closure_call_fixable.stderr | 44 +++++++++++++++-----------
 4 files changed, 49 insertions(+), 30 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/redundant_closure_call.rs b/clippy_lints/src/redundant_closure_call.rs
index efdd78a1c92..17a17890be7 100644
--- a/clippy_lints/src/redundant_closure_call.rs
+++ b/clippy_lints/src/redundant_closure_call.rs
@@ -5,7 +5,7 @@ use clippy_utils::sugg::Sugg;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_hir::intravisit::{Visitor as HirVisitor, Visitor};
-use rustc_hir::{intravisit as hir_visit, CoroutineKind, CoroutineSource};
+use rustc_hir::{intravisit as hir_visit, CoroutineKind, CoroutineSource, Node};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::nested_filter;
 use rustc_middle::lint::in_external_macro;
@@ -176,12 +176,19 @@ impl<'tcx> LateLintPass<'tcx> for RedundantClosureCall {
                             hint = hint.asyncify();
                         }
 
-                        diag.span_suggestion(
-                            full_expr.span,
-                            "try doing something like",
-                            hint.maybe_par(),
-                            applicability,
-                        );
+                        let is_in_fn_call_arg = clippy_utils::get_parent_node(cx.tcx, expr.hir_id)
+                            .map(|x| match x {
+                                Node::Expr(expr) => matches!(expr.kind, hir::ExprKind::Call(_, _)),
+                                _ => false,
+                            })
+                            .unwrap_or(false);
+
+                        // avoid clippy::double_parens
+                        if !is_in_fn_call_arg {
+                            hint = hint.maybe_par()
+                        };
+
+                        diag.span_suggestion(full_expr.span, "try doing something like", hint, applicability);
                     }
                 },
             );
diff --git a/tests/ui/redundant_closure_call_fixable.fixed b/tests/ui/redundant_closure_call_fixable.fixed
index f2cd9862af6..f272d8359a3 100644
--- a/tests/ui/redundant_closure_call_fixable.fixed
+++ b/tests/ui/redundant_closure_call_fixable.fixed
@@ -3,7 +3,6 @@
 #![allow(clippy::redundant_async_block)]
 #![allow(clippy::type_complexity)]
 #![allow(unused)]
-#![allow(clippy::double_parens)]
 
 async fn something() -> u32 {
     21
@@ -87,7 +86,7 @@ fn issue9956() {
 }
 
 async fn issue11357() {
-    (async {}).await;
+    async {}.await;
 }
 
 mod issue11707 {
@@ -96,6 +95,10 @@ mod issue11707 {
     fn spawn_on(fut: impl Future<Output = ()>) {}
 
     fn demo() {
-        spawn_on((async move {}));
+        spawn_on(async move {});
     }
 }
+
+fn avoid_double_parens() {
+    std::convert::identity(13_i32 + 36_i32).leading_zeros();
+}
diff --git a/tests/ui/redundant_closure_call_fixable.rs b/tests/ui/redundant_closure_call_fixable.rs
index efb08c82e3b..f45db8c9cff 100644
--- a/tests/ui/redundant_closure_call_fixable.rs
+++ b/tests/ui/redundant_closure_call_fixable.rs
@@ -3,7 +3,6 @@
 #![allow(clippy::redundant_async_block)]
 #![allow(clippy::type_complexity)]
 #![allow(unused)]
-#![allow(clippy::double_parens)]
 
 async fn something() -> u32 {
     21
@@ -99,3 +98,7 @@ mod issue11707 {
         spawn_on((|| async move {})());
     }
 }
+
+fn avoid_double_parens() {
+    std::convert::identity((|| 13_i32 + 36_i32)()).leading_zeros();
+}
diff --git a/tests/ui/redundant_closure_call_fixable.stderr b/tests/ui/redundant_closure_call_fixable.stderr
index 16d8797c4aa..028d383ad35 100644
--- a/tests/ui/redundant_closure_call_fixable.stderr
+++ b/tests/ui/redundant_closure_call_fixable.stderr
@@ -1,5 +1,5 @@
 error: try not to call a closure in the expression where it is declared
-  --> $DIR/redundant_closure_call_fixable.rs:17:13
+  --> $DIR/redundant_closure_call_fixable.rs:16:13
    |
 LL |     let a = (|| 42)();
    |             ^^^^^^^^^ help: try doing something like: `42`
@@ -8,7 +8,7 @@ LL |     let a = (|| 42)();
    = help: to override `-D warnings` add `#[allow(clippy::redundant_closure_call)]`
 
 error: try not to call a closure in the expression where it is declared
-  --> $DIR/redundant_closure_call_fixable.rs:18:13
+  --> $DIR/redundant_closure_call_fixable.rs:17:13
    |
 LL |       let b = (async || {
    |  _____________^
@@ -28,7 +28,7 @@ LL ~     };
    |
 
 error: try not to call a closure in the expression where it is declared
-  --> $DIR/redundant_closure_call_fixable.rs:23:13
+  --> $DIR/redundant_closure_call_fixable.rs:22:13
    |
 LL |       let c = (|| {
    |  _____________^
@@ -48,13 +48,13 @@ LL ~     };
    |
 
 error: try not to call a closure in the expression where it is declared
-  --> $DIR/redundant_closure_call_fixable.rs:28:13
+  --> $DIR/redundant_closure_call_fixable.rs:27:13
    |
 LL |     let d = (async || something().await)();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try doing something like: `async { something().await }`
 
 error: try not to call a closure in the expression where it is declared
-  --> $DIR/redundant_closure_call_fixable.rs:37:13
+  --> $DIR/redundant_closure_call_fixable.rs:36:13
    |
 LL |             (|| m!())()
    |             ^^^^^^^^^^^ help: try doing something like: `m!()`
@@ -65,7 +65,7 @@ LL |     m2!();
    = note: this error originates in the macro `m2` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: try not to call a closure in the expression where it is declared
-  --> $DIR/redundant_closure_call_fixable.rs:32:13
+  --> $DIR/redundant_closure_call_fixable.rs:31:13
    |
 LL |             (|| 0)()
    |             ^^^^^^^^ help: try doing something like: `0`
@@ -76,64 +76,70 @@ LL |     m2!();
    = note: this error originates in the macro `m` which comes from the expansion of the macro `m2` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: try not to call a closure in the expression where it is declared
-  --> $DIR/redundant_closure_call_fixable.rs:45:16
+  --> $DIR/redundant_closure_call_fixable.rs:44:16
    |
 LL |     assert_eq!((|| || 43)()(), 42);
    |                ^^^^^^^^^^^^^^ help: try doing something like: `43`
 
 error: try not to call a closure in the expression where it is declared
-  --> $DIR/redundant_closure_call_fixable.rs:54:10
+  --> $DIR/redundant_closure_call_fixable.rs:53:10
    |
 LL |     dbg!((|| 42)());
    |          ^^^^^^^^^ help: try doing something like: `42`
 
 error: try not to call a closure in the expression where it is declared
-  --> $DIR/redundant_closure_call_fixable.rs:57:13
+  --> $DIR/redundant_closure_call_fixable.rs:56:13
    |
 LL |     let a = (|| || || 123)();
    |             ^^^^^^^^^^^^^^^^ help: try doing something like: `(|| || 123)`
 
 error: try not to call a closure in the expression where it is declared
-  --> $DIR/redundant_closure_call_fixable.rs:61:13
+  --> $DIR/redundant_closure_call_fixable.rs:60:13
    |
 LL |     let a = (|| || || || async || 1)()()()()();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try doing something like: `async { 1 }`
 
 error: try not to call a closure in the expression where it is declared
-  --> $DIR/redundant_closure_call_fixable.rs:70:13
+  --> $DIR/redundant_closure_call_fixable.rs:69:13
    |
 LL |     let a = (|| echo!(|| echo!(|| 1)))()()();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try doing something like: `1`
 
 error: try not to call a closure in the expression where it is declared
-  --> $DIR/redundant_closure_call_fixable.rs:72:13
+  --> $DIR/redundant_closure_call_fixable.rs:71:13
    |
 LL |     let a = (|| echo!((|| 123)))()();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^ help: try doing something like: `123`
 
 error: try not to call a closure in the expression where it is declared
-  --> $DIR/redundant_closure_call_fixable.rs:85:11
+  --> $DIR/redundant_closure_call_fixable.rs:84:11
    |
 LL |     bar()((|| || 42)()(), 5);
    |           ^^^^^^^^^^^^^^ help: try doing something like: `42`
 
 error: try not to call a closure in the expression where it is declared
-  --> $DIR/redundant_closure_call_fixable.rs:86:9
+  --> $DIR/redundant_closure_call_fixable.rs:85:9
    |
 LL |     foo((|| || 42)()(), 5);
    |         ^^^^^^^^^^^^^^ help: try doing something like: `42`
 
 error: try not to call a closure in the expression where it is declared
-  --> $DIR/redundant_closure_call_fixable.rs:90:5
+  --> $DIR/redundant_closure_call_fixable.rs:89:5
    |
 LL |     (|| async {})().await;
-   |     ^^^^^^^^^^^^^^^ help: try doing something like: `(async {})`
+   |     ^^^^^^^^^^^^^^^ help: try doing something like: `async {}`
 
 error: try not to call a closure in the expression where it is declared
-  --> $DIR/redundant_closure_call_fixable.rs:99:18
+  --> $DIR/redundant_closure_call_fixable.rs:98:18
    |
 LL |         spawn_on((|| async move {})());
-   |                  ^^^^^^^^^^^^^^^^^^^^ help: try doing something like: `(async move {})`
+   |                  ^^^^^^^^^^^^^^^^^^^^ help: try doing something like: `async move {}`
+
+error: try not to call a closure in the expression where it is declared
+  --> $DIR/redundant_closure_call_fixable.rs:103:28
+   |
+LL |     std::convert::identity((|| 13_i32 + 36_i32)()).leading_zeros();
+   |                            ^^^^^^^^^^^^^^^^^^^^^^ help: try doing something like: `13_i32 + 36_i32`
 
-error: aborting due to 16 previous errors
+error: aborting due to 17 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 0426913ca95d457abefb192cde878d9eaab4b8a0 Mon Sep 17 00:00:00 2001
From: Kisaragi Marine <kisaragi.effective@gmail.com>
Date: Tue, 28 Nov 2023 00:40:13 +0900
Subject: fix dogfood

---
 clippy_lints/src/redundant_closure_call.rs | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/redundant_closure_call.rs b/clippy_lints/src/redundant_closure_call.rs
index 17a17890be7..8bac2e40e01 100644
--- a/clippy_lints/src/redundant_closure_call.rs
+++ b/clippy_lints/src/redundant_closure_call.rs
@@ -176,16 +176,15 @@ impl<'tcx> LateLintPass<'tcx> for RedundantClosureCall {
                             hint = hint.asyncify();
                         }
 
-                        let is_in_fn_call_arg = clippy_utils::get_parent_node(cx.tcx, expr.hir_id)
-                            .map(|x| match x {
+                        let is_in_fn_call_arg =
+                            clippy_utils::get_parent_node(cx.tcx, expr.hir_id).is_some_and(|x| match x {
                                 Node::Expr(expr) => matches!(expr.kind, hir::ExprKind::Call(_, _)),
                                 _ => false,
-                            })
-                            .unwrap_or(false);
+                            });
 
                         // avoid clippy::double_parens
                         if !is_in_fn_call_arg {
-                            hint = hint.maybe_par()
+                            hint = hint.maybe_par();
                         };
 
                         diag.span_suggestion(full_expr.span, "try doing something like", hint, applicability);
-- 
cgit 1.4.1-3-g733a5


From 758d0e8661fd757ed12a07959eae142c695500ed Mon Sep 17 00:00:00 2001
From: J-ZhengLi <lizheng135@huawei.com>
Date: Tue, 28 Nov 2023 10:28:55 +0800
Subject: change name to [`infinite_loop`]; & apply review suggestions;

---
 CHANGELOG.md                             |   2 +-
 clippy_lints/src/declared_lints.rs       |   2 +-
 clippy_lints/src/loops/infinite_loop.rs  | 125 ++++++++++++++++++++++++++++++
 clippy_lints/src/loops/infinite_loops.rs | 128 -------------------------------
 clippy_lints/src/loops/mod.rs            |  12 +--
 tests/ui/infinite_loops.rs               |   8 +-
 tests/ui/infinite_loops.stderr           |  26 ++++---
 7 files changed, 155 insertions(+), 148 deletions(-)
 create mode 100644 clippy_lints/src/loops/infinite_loop.rs
 delete mode 100644 clippy_lints/src/loops/infinite_loops.rs

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5c62cf51559..924d346a9c7 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5147,7 +5147,7 @@ Released 2018-09-13
 [`inefficient_to_string`]: https://rust-lang.github.io/rust-clippy/master/index.html#inefficient_to_string
 [`infallible_destructuring_match`]: https://rust-lang.github.io/rust-clippy/master/index.html#infallible_destructuring_match
 [`infinite_iter`]: https://rust-lang.github.io/rust-clippy/master/index.html#infinite_iter
-[`infinite_loops`]: https://rust-lang.github.io/rust-clippy/master/index.html#infinite_loops
+[`infinite_loop`]: https://rust-lang.github.io/rust-clippy/master/index.html#infinite_loop
 [`inherent_to_string`]: https://rust-lang.github.io/rust-clippy/master/index.html#inherent_to_string
 [`inherent_to_string_shadow_display`]: https://rust-lang.github.io/rust-clippy/master/index.html#inherent_to_string_shadow_display
 [`init_numbered_fields`]: https://rust-lang.github.io/rust-clippy/master/index.html#init_numbered_fields
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 7520b57891e..6422c6cc6df 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -263,7 +263,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::loops::EXPLICIT_INTO_ITER_LOOP_INFO,
     crate::loops::EXPLICIT_ITER_LOOP_INFO,
     crate::loops::FOR_KV_MAP_INFO,
-    crate::loops::INFINITE_LOOPS_INFO,
+    crate::loops::INFINITE_LOOP_INFO,
     crate::loops::ITER_NEXT_LOOP_INFO,
     crate::loops::MANUAL_FIND_INFO,
     crate::loops::MANUAL_FLATTEN_INFO,
diff --git a/clippy_lints/src/loops/infinite_loop.rs b/clippy_lints/src/loops/infinite_loop.rs
new file mode 100644
index 00000000000..9b88dd76e5c
--- /dev/null
+++ b/clippy_lints/src/loops/infinite_loop.rs
@@ -0,0 +1,125 @@
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::{fn_def_id, is_lint_allowed};
+use hir::intravisit::{walk_expr, Visitor};
+use hir::{Expr, ExprKind, FnRetTy, FnSig, Node};
+use rustc_ast::Label;
+use rustc_errors::Applicability;
+use rustc_hir as hir;
+use rustc_lint::LateContext;
+
+use super::INFINITE_LOOP;
+
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &Expr<'_>,
+    loop_block: &'tcx hir::Block<'_>,
+    label: Option<Label>,
+) {
+    if is_lint_allowed(cx, INFINITE_LOOP, expr.hir_id) {
+        return;
+    }
+
+    // Skip check if this loop is not in a function/method/closure. (In some weird case)
+    let Some(parent_fn_ret) = get_parent_fn_ret_ty(cx, expr) else {
+        return;
+    };
+    // Or, its parent function is already returning `Never`
+    if matches!(
+        parent_fn_ret,
+        FnRetTy::Return(hir::Ty {
+            kind: hir::TyKind::Never,
+            ..
+        })
+    ) {
+        return;
+    }
+
+    let mut loop_visitor = LoopVisitor {
+        cx,
+        label,
+        is_finite: false,
+        loop_depth: 0,
+    };
+    loop_visitor.visit_block(loop_block);
+
+    let is_finite_loop = loop_visitor.is_finite;
+
+    if !is_finite_loop {
+        span_lint_and_then(cx, INFINITE_LOOP, expr.span, "infinite loop detected", |diag| {
+            if let FnRetTy::DefaultReturn(ret_span) = parent_fn_ret {
+                diag.span_suggestion(
+                    ret_span,
+                    "if this is intentional, consider specifing `!` as function return",
+                    " -> !",
+                    Applicability::MaybeIncorrect,
+                );
+            } else {
+                diag.help("if this is not intended, try adding a `break` or `return` condition in the loop");
+            }
+        });
+    }
+}
+
+fn get_parent_fn_ret_ty<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>) -> Option<FnRetTy<'tcx>> {
+    for (_, parent_node) in cx.tcx.hir().parent_iter(expr.hir_id) {
+        match parent_node {
+            Node::Item(hir::Item {
+                kind: hir::ItemKind::Fn(FnSig { decl, .. }, _, _),
+                ..
+            })
+            | Node::TraitItem(hir::TraitItem {
+                kind: hir::TraitItemKind::Fn(FnSig { decl, .. }, _),
+                ..
+            })
+            | Node::ImplItem(hir::ImplItem {
+                kind: hir::ImplItemKind::Fn(FnSig { decl, .. }, _),
+                ..
+            })
+            | Node::Expr(Expr {
+                kind: ExprKind::Closure(hir::Closure { fn_decl: decl, .. }),
+                ..
+            }) => return Some(decl.output),
+            _ => (),
+        }
+    }
+    None
+}
+
+struct LoopVisitor<'hir, 'tcx> {
+    cx: &'hir LateContext<'tcx>,
+    label: Option<Label>,
+    loop_depth: usize,
+    is_finite: bool,
+}
+
+impl<'hir> Visitor<'hir> for LoopVisitor<'hir, '_> {
+    fn visit_expr(&mut self, ex: &'hir Expr<'_>) {
+        match &ex.kind {
+            ExprKind::Break(hir::Destination { label, .. }, ..) => {
+                // Assuming breaks the loop when `loop_depth` is 0,
+                // as it could only means this `break` breaks current loop or any of its upper loop.
+                // Or, the depth is not zero but the label is matched.
+                if self.loop_depth == 0 || (label.is_some() && *label == self.label) {
+                    self.is_finite = true;
+                }
+            },
+            ExprKind::Ret(..) => self.is_finite = true,
+            ExprKind::Loop(..) => {
+                self.loop_depth += 1;
+                walk_expr(self, ex);
+                self.loop_depth = self.loop_depth.saturating_sub(1);
+            },
+            _ => {
+                // Calls to a function that never return
+                if let Some(did) = fn_def_id(self.cx, ex) {
+                    let fn_ret_ty = self.cx.tcx.fn_sig(did).skip_binder().output().skip_binder();
+                    if fn_ret_ty.is_never() {
+                        self.is_finite = true;
+                        return;
+                    }
+                }
+                walk_expr(self, ex);
+            },
+        }
+    }
+}
diff --git a/clippy_lints/src/loops/infinite_loops.rs b/clippy_lints/src/loops/infinite_loops.rs
deleted file mode 100644
index 5e474bf45ee..00000000000
--- a/clippy_lints/src/loops/infinite_loops.rs
+++ /dev/null
@@ -1,128 +0,0 @@
-use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::{fn_def_id, is_lint_allowed};
-use hir::intravisit::{walk_expr, Visitor};
-use hir::{Expr, ExprKind, FnRetTy, FnSig, Node};
-use rustc_ast::Label;
-use rustc_errors::Applicability;
-use rustc_hir as hir;
-use rustc_lint::LateContext;
-
-use super::INFINITE_LOOPS;
-
-pub(super) fn check<'tcx>(
-    cx: &LateContext<'tcx>,
-    expr: &Expr<'_>,
-    loop_block: &'tcx hir::Block<'_>,
-    label: Option<Label>,
-) {
-    if is_lint_allowed(cx, INFINITE_LOOPS, expr.hir_id) {
-        return;
-    }
-
-    // Skip check if this loop is not in a function/method/closure. (In some weird case)
-    let Some(parent_fn_ret) = get_parent_fn_ret_ty(cx, expr) else {
-        return;
-    };
-    // Or, its parent function is already returning `Never`
-    if matches!(
-        parent_fn_ret,
-        FnRetTy::Return(hir::Ty {
-            kind: hir::TyKind::Never,
-            ..
-        })
-    ) {
-        return;
-    }
-
-    let mut loop_visitor = LoopVisitor {
-        cx,
-        label,
-        is_finite: false,
-        loop_depth: 0,
-    };
-    loop_visitor.visit_block(loop_block);
-
-    let is_finite_loop = loop_visitor.is_finite;
-
-    if !is_finite_loop {
-        span_lint_and_then(cx, INFINITE_LOOPS, expr.span, "infinite loop detected", |diag| {
-            if let FnRetTy::DefaultReturn(ret_span) = parent_fn_ret {
-                diag.span_suggestion(
-                    ret_span,
-                    "if this is intentional, consider specifing `!` as function return",
-                    " -> !",
-                    Applicability::MaybeIncorrect,
-                );
-            } else {
-                diag.span_help(
-                    expr.span,
-                    "if this is not intended, try adding a `break` or `return` condition in this loop",
-                );
-            }
-        });
-    }
-}
-
-fn get_parent_fn_ret_ty<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>) -> Option<FnRetTy<'tcx>> {
-    for (_, parent_node) in cx.tcx.hir().parent_iter(expr.hir_id) {
-        match parent_node {
-            Node::Item(hir::Item {
-                kind: hir::ItemKind::Fn(FnSig { decl, .. }, _, _),
-                ..
-            })
-            | Node::TraitItem(hir::TraitItem {
-                kind: hir::TraitItemKind::Fn(FnSig { decl, .. }, _),
-                ..
-            })
-            | Node::ImplItem(hir::ImplItem {
-                kind: hir::ImplItemKind::Fn(FnSig { decl, .. }, _),
-                ..
-            })
-            | Node::Expr(Expr {
-                kind: ExprKind::Closure(hir::Closure { fn_decl: decl, .. }),
-                ..
-            }) => return Some(decl.output),
-            _ => (),
-        }
-    }
-    None
-}
-
-struct LoopVisitor<'hir, 'tcx> {
-    cx: &'hir LateContext<'tcx>,
-    label: Option<Label>,
-    loop_depth: usize,
-    is_finite: bool,
-}
-
-impl<'hir> Visitor<'hir> for LoopVisitor<'hir, '_> {
-    fn visit_expr(&mut self, ex: &'hir Expr<'_>) {
-        match &ex.kind {
-            ExprKind::Break(hir::Destination { label, .. }, ..) => {
-                // Assuming breaks the loop when `loop_depth` is 0,
-                // as it could only means this `break` breaks current loop or any of its upper loop.
-                // Or, the depth is not zero but the label is matched.
-                if self.loop_depth == 0 || (label.is_some() && *label == self.label) {
-                    self.is_finite = true;
-                }
-            },
-            ExprKind::Ret(..) => self.is_finite = true,
-            ExprKind::Loop(..) => {
-                self.loop_depth += 1;
-                walk_expr(self, ex);
-                self.loop_depth = self.loop_depth.saturating_sub(1);
-            },
-            _ => {
-                // Calls to a function that never return
-                if let Some(did) = fn_def_id(self.cx, ex) {
-                    let fn_ret_ty = self.cx.tcx.fn_sig(did).skip_binder().output().skip_binder();
-                    if fn_ret_ty.is_never() {
-                        self.is_finite = true;
-                        return;
-                    }
-                }
-                walk_expr(self, ex);
-            },
-        }
-    }
-}
diff --git a/clippy_lints/src/loops/mod.rs b/clippy_lints/src/loops/mod.rs
index 214e406374f..61ff491716b 100644
--- a/clippy_lints/src/loops/mod.rs
+++ b/clippy_lints/src/loops/mod.rs
@@ -3,7 +3,7 @@ mod explicit_counter_loop;
 mod explicit_into_iter_loop;
 mod explicit_iter_loop;
 mod for_kv_map;
-mod infinite_loops;
+mod infinite_loop;
 mod iter_next_loop;
 mod manual_find;
 mod manual_flatten;
@@ -642,7 +642,7 @@ declare_clippy_lint! {
     /// and lint accordingly.
     ///
     /// ### Why is this bad?
-    /// A loop should be gently exited somewhere, or at lease mark its parent function as
+    /// A loop should be gently exited somewhere, or at least mark its parent function as
     /// never return (`!`).
     ///
     /// ### Example
@@ -673,9 +673,9 @@ declare_clippy_lint! {
     /// }
     /// ```
     #[clippy::version = "1.75.0"]
-    pub INFINITE_LOOPS,
+    pub INFINITE_LOOP,
     restriction,
-    "possibly unintended infinite loops"
+    "possibly unintended infinite loop"
 }
 
 pub struct Loops {
@@ -712,7 +712,7 @@ impl_lint_pass!(Loops => [
     MANUAL_FIND,
     MANUAL_WHILE_LET_SOME,
     UNUSED_ENUMERATE_INDEX,
-    INFINITE_LOOPS,
+    INFINITE_LOOP,
 ]);
 
 impl<'tcx> LateLintPass<'tcx> for Loops {
@@ -755,7 +755,7 @@ impl<'tcx> LateLintPass<'tcx> for Loops {
             // also check for empty `loop {}` statements, skipping those in #[panic_handler]
             empty_loop::check(cx, expr, block);
             while_let_loop::check(cx, expr, block);
-            infinite_loops::check(cx, expr, block, label);
+            infinite_loop::check(cx, expr, block, label);
         }
 
         while_let_on_iterator::check(cx, expr);
diff --git a/tests/ui/infinite_loops.rs b/tests/ui/infinite_loops.rs
index 0c18ad620bf..646f1eca56d 100644
--- a/tests/ui/infinite_loops.rs
+++ b/tests/ui/infinite_loops.rs
@@ -1,6 +1,6 @@
 //@no-rustfix
 #![allow(clippy::never_loop)]
-#![warn(clippy::infinite_loops)]
+#![warn(clippy::infinite_loop)]
 
 fn do_something() {}
 
@@ -357,4 +357,10 @@ fn inf_loop_in_closure() {
     };
 }
 
+fn inf_loop_in_res() -> Result<(), i32> {
+    Ok(loop {
+        do_something()
+    })
+}
+
 fn main() {}
diff --git a/tests/ui/infinite_loops.stderr b/tests/ui/infinite_loops.stderr
index ebbc6151188..f58b3cebbc3 100644
--- a/tests/ui/infinite_loops.stderr
+++ b/tests/ui/infinite_loops.stderr
@@ -7,8 +7,8 @@ LL | |         do_something();
 LL | |     }
    | |_____^
    |
-   = note: `-D clippy::infinite-loops` implied by `-D warnings`
-   = help: to override `-D warnings` add `#[allow(clippy::infinite_loops)]`
+   = note: `-D clippy::infinite-loop` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::infinite_loop)]`
 help: if this is intentional, consider specifing `!` as function return
    |
 LL | fn no_break() -> ! {
@@ -71,14 +71,7 @@ LL | |         do_something();
 LL | |     }
    | |_____^
    |
-help: if this is not intended, try adding a `break` or `return` condition in this loop
-  --> $DIR/infinite_loops.rs:33:5
-   |
-LL | /     loop {
-LL | |
-LL | |         do_something();
-LL | |     }
-   | |_____^
+   = help: if this is not intended, try adding a `break` or `return` condition in the loop
 
 error: infinite loop detected
   --> $DIR/infinite_loops.rs:46:5
@@ -251,5 +244,16 @@ help: if this is intentional, consider specifing `!` as function return
 LL |     let _loop_forever = || -> ! {
    |                            ++++
 
-error: aborting due to 16 previous errors
+error: infinite loop detected
+  --> $DIR/infinite_loops.rs:361:8
+   |
+LL |       Ok(loop {
+   |  ________^
+LL | |         do_something()
+LL | |     })
+   | |_____^
+   |
+   = help: if this is not intended, try adding a `break` or `return` condition in the loop
+
+error: aborting due to 17 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 0565267f3763c5f6a244db66f03cbff00ef0c62a Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Tue, 28 Nov 2023 19:14:37 +0100
Subject: rename `DocMarkdown` to `Documentation`

---
 clippy_lints/src/doc/mod.rs | 9 ++++-----
 clippy_lints/src/lib.rs     | 2 +-
 2 files changed, 5 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/doc/mod.rs b/clippy_lints/src/doc/mod.rs
index 18874b1cb8e..a11d5622b4d 100644
--- a/clippy_lints/src/doc/mod.rs
+++ b/clippy_lints/src/doc/mod.rs
@@ -305,15 +305,14 @@ declare_clippy_lint! {
     "suspicious usage of (outer) doc comments"
 }
 
-#[expect(clippy::module_name_repetitions)]
 #[derive(Clone)]
-pub struct DocMarkdown {
+pub struct Documentation {
     valid_idents: FxHashSet<String>,
     in_trait_impl: bool,
     check_private_items: bool,
 }
 
-impl DocMarkdown {
+impl Documentation {
     pub fn new(valid_idents: &[String], check_private_items: bool) -> Self {
         Self {
             valid_idents: valid_idents.iter().cloned().collect(),
@@ -323,7 +322,7 @@ impl DocMarkdown {
     }
 }
 
-impl_lint_pass!(DocMarkdown => [
+impl_lint_pass!(Documentation => [
     DOC_LINK_WITH_QUOTES,
     DOC_MARKDOWN,
     MISSING_SAFETY_DOC,
@@ -334,7 +333,7 @@ impl_lint_pass!(DocMarkdown => [
     SUSPICIOUS_DOC_COMMENTS
 ]);
 
-impl<'tcx> LateLintPass<'tcx> for DocMarkdown {
+impl<'tcx> LateLintPass<'tcx> for Documentation {
     fn check_crate(&mut self, cx: &LateContext<'tcx>) {
         let attrs = cx.tcx.hir().attrs(hir::CRATE_HIR_ID);
         check_attrs(cx, &self.valid_idents, attrs);
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index abe768d50c7..1c59b2df853 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -747,7 +747,7 @@ pub fn register_lints(store: &mut rustc_lint::LintStore, conf: &'static Conf) {
             avoid_breaking_exported_api,
         ))
     });
-    store.register_late_pass(move |_| Box::new(doc::DocMarkdown::new(doc_valid_idents, check_private_items)));
+    store.register_late_pass(move |_| Box::new(doc::Documentation::new(doc_valid_idents, check_private_items)));
     store.register_late_pass(|_| Box::new(neg_multiply::NegMultiply));
     store.register_late_pass(|_| Box::new(let_if_seq::LetIfSeq));
     store.register_late_pass(|_| Box::new(mixed_read_write_in_expression::EvalOrderDependence));
-- 
cgit 1.4.1-3-g733a5


From 0ba9bf9f9ac8adfdcc1b9e033bb127f199397d2d Mon Sep 17 00:00:00 2001
From: Andre Bogus <bogusandre@gmail.com>
Date: Sun, 26 Nov 2023 06:58:25 +0100
Subject: add lint against unit tests in doctests

---
 CHANGELOG.md                                  |  1 +
 clippy_lints/src/declared_lints.rs            |  1 +
 clippy_lints/src/doc/mod.rs                   | 40 +++++++++++++++-
 clippy_lints/src/doc/needless_doctest_main.rs | 67 ++++++++++++++++++++-------
 tests/ui/test_attr_in_doctest.rs              | 51 ++++++++++++++++++++
 tests/ui/test_attr_in_doctest.stderr          | 29 ++++++++++++
 6 files changed, 172 insertions(+), 17 deletions(-)
 create mode 100644 tests/ui/test_attr_in_doctest.rs
 create mode 100644 tests/ui/test_attr_in_doctest.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index abe975fa42b..2e9b755caa0 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5545,6 +5545,7 @@ Released 2018-09-13
 [`tabs_in_doc_comments`]: https://rust-lang.github.io/rust-clippy/master/index.html#tabs_in_doc_comments
 [`temporary_assignment`]: https://rust-lang.github.io/rust-clippy/master/index.html#temporary_assignment
 [`temporary_cstring_as_ptr`]: https://rust-lang.github.io/rust-clippy/master/index.html#temporary_cstring_as_ptr
+[`test_attr_in_doctest`]: https://rust-lang.github.io/rust-clippy/master/index.html#test_attr_in_doctest
 [`tests_outside_test_module`]: https://rust-lang.github.io/rust-clippy/master/index.html#tests_outside_test_module
 [`to_digit_is_some`]: https://rust-lang.github.io/rust-clippy/master/index.html#to_digit_is_some
 [`to_string_in_display`]: https://rust-lang.github.io/rust-clippy/master/index.html#to_string_in_display
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 5a109fcc2cc..b440e267efe 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -140,6 +140,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::doc::MISSING_SAFETY_DOC_INFO,
     crate::doc::NEEDLESS_DOCTEST_MAIN_INFO,
     crate::doc::SUSPICIOUS_DOC_COMMENTS_INFO,
+    crate::doc::TEST_ATTR_IN_DOCTEST_INFO,
     crate::doc::UNNECESSARY_SAFETY_DOC_INFO,
     crate::double_parens::DOUBLE_PARENS_INFO,
     crate::drop_forget_ref::DROP_NON_DROP_INFO,
diff --git a/clippy_lints/src/doc/mod.rs b/clippy_lints/src/doc/mod.rs
index 607af6ba905..f6c8f6269ab 100644
--- a/clippy_lints/src/doc/mod.rs
+++ b/clippy_lints/src/doc/mod.rs
@@ -199,6 +199,39 @@ declare_clippy_lint! {
     "presence of `fn main() {` in code examples"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `#[test]` in doctests unless they are marked with
+    /// either `ignore`, `no_run` or `compile_fail`.
+    ///
+    /// ### Why is this bad?
+    /// Code in examples marked as `#[test]` will somewhat
+    /// surprisingly not be run by `cargo test`. If you really want
+    /// to show how to test stuff in an example, mark it `no_run` to
+    /// make the intent clear.
+    ///
+    /// ### Examples
+    /// ```no_run
+    /// /// An example of a doctest with a `main()` function
+    /// ///
+    /// /// # Examples
+    /// ///
+    /// /// ```
+    /// /// #[test]
+    /// /// fn equality_works() {
+    /// ///     assert_eq!(1_u8, 1);
+    /// /// }
+    /// /// ```
+    /// fn test_attr_in_doctest() {
+    ///     unimplemented!();
+    /// }
+    /// ```
+    #[clippy::version = "1.40.0"]
+    pub TEST_ATTR_IN_DOCTEST,
+    suspicious,
+    "presence of `#[test]` in code examples"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Detects the syntax `['foo']` in documentation comments (notice quotes instead of backticks)
@@ -330,6 +363,7 @@ impl_lint_pass!(DocMarkdown => [
     MISSING_ERRORS_DOC,
     MISSING_PANICS_DOC,
     NEEDLESS_DOCTEST_MAIN,
+    TEST_ATTR_IN_DOCTEST,
     UNNECESSARY_SAFETY_DOC,
     SUSPICIOUS_DOC_COMMENTS
 ]);
@@ -516,6 +550,7 @@ fn check_doc<'a, Events: Iterator<Item = (pulldown_cmark::Event<'a>, Range<usize
     let mut in_heading = false;
     let mut is_rust = false;
     let mut no_test = false;
+    let mut ignore = false;
     let mut edition = None;
     let mut ticks_unbalanced = false;
     let mut text_to_check: Vec<(CowStr<'_>, Range<usize>)> = Vec::new();
@@ -531,6 +566,8 @@ fn check_doc<'a, Events: Iterator<Item = (pulldown_cmark::Event<'a>, Range<usize
                             break;
                         } else if item == "no_test" {
                             no_test = true;
+                        } else if item == "no_run" || item == "compile_fail" {
+                            ignore = true;
                         }
                         if let Some(stripped) = item.strip_prefix("edition") {
                             is_rust = true;
@@ -544,6 +581,7 @@ fn check_doc<'a, Events: Iterator<Item = (pulldown_cmark::Event<'a>, Range<usize
             End(CodeBlock(_)) => {
                 in_code = false;
                 is_rust = false;
+                ignore = false;
             },
             Start(Link(_, url, _)) => in_link = Some(url),
             End(Link(..)) => in_link = None,
@@ -597,7 +635,7 @@ fn check_doc<'a, Events: Iterator<Item = (pulldown_cmark::Event<'a>, Range<usize
                 if in_code {
                     if is_rust && !no_test {
                         let edition = edition.unwrap_or_else(|| cx.tcx.sess.edition());
-                        needless_doctest_main::check(cx, &text, edition, range.clone(), fragments);
+                        needless_doctest_main::check(cx, &text, edition, range.clone(), fragments, ignore);
                     }
                 } else {
                     if in_link.is_some() {
diff --git a/clippy_lints/src/doc/needless_doctest_main.rs b/clippy_lints/src/doc/needless_doctest_main.rs
index 4d7d7611dd8..e50e83834c1 100644
--- a/clippy_lints/src/doc/needless_doctest_main.rs
+++ b/clippy_lints/src/doc/needless_doctest_main.rs
@@ -1,9 +1,9 @@
 use std::ops::Range;
 use std::{io, thread};
 
-use crate::doc::NEEDLESS_DOCTEST_MAIN;
+use crate::doc::{NEEDLESS_DOCTEST_MAIN, TEST_ATTR_IN_DOCTEST};
 use clippy_utils::diagnostics::span_lint;
-use rustc_ast::{Async, Fn, FnRetTy, ItemKind};
+use rustc_ast::{Async, Fn, FnRetTy, Item, ItemKind};
 use rustc_data_structures::sync::Lrc;
 use rustc_errors::emitter::EmitterWriter;
 use rustc_errors::Handler;
@@ -13,14 +13,33 @@ use rustc_parse::parser::ForceCollect;
 use rustc_session::parse::ParseSess;
 use rustc_span::edition::Edition;
 use rustc_span::source_map::{FilePathMapping, SourceMap};
-use rustc_span::{sym, FileName};
+use rustc_span::{sym, FileName, Pos};
 
 use super::Fragments;
 
-pub fn check(cx: &LateContext<'_>, text: &str, edition: Edition, range: Range<usize>, fragments: Fragments<'_>) {
-    fn has_needless_main(code: String, edition: Edition) -> bool {
+fn get_test_spans(item: &Item, test_attr_spans: &mut Vec<Range<usize>>) {
+    test_attr_spans.extend(
+        item.attrs
+            .iter()
+            .find(|attr| attr.has_name(sym::test))
+            .map(|attr| attr.span.lo().to_usize()..item.ident.span.hi().to_usize()),
+    );
+}
+
+pub fn check(
+    cx: &LateContext<'_>,
+    text: &str,
+    edition: Edition,
+    range: Range<usize>,
+    fragments: Fragments<'_>,
+    ignore: bool,
+) {
+    // return whether the code contains a needless `fn main` plus a vector of byte position ranges
+    // of all `#[test]` attributes in not ignored code examples
+    fn check_code_sample(code: String, edition: Edition, ignore: bool) -> (bool, Vec<Range<usize>>) {
         rustc_driver::catch_fatal_errors(|| {
             rustc_span::create_session_globals_then(edition, || {
+                let mut test_attr_spans = vec![];
                 let filename = FileName::anon_source_code(&code);
 
                 let fallback_bundle =
@@ -35,17 +54,21 @@ pub fn check(cx: &LateContext<'_>, text: &str, edition: Edition, range: Range<us
                     Ok(p) => p,
                     Err(errs) => {
                         drop(errs);
-                        return false;
+                        return (false, test_attr_spans);
                     },
                 };
 
                 let mut relevant_main_found = false;
+                let mut eligible = true;
                 loop {
                     match parser.parse_item(ForceCollect::No) {
                         Ok(Some(item)) => match &item.kind {
                             ItemKind::Fn(box Fn {
                                 sig, body: Some(block), ..
                             }) if item.ident.name == sym::main => {
+                                if !ignore {
+                                    get_test_spans(&item, &mut test_attr_spans);
+                                }
                                 let is_async = matches!(sig.header.asyncness, Async::Yes { .. });
                                 let returns_nothing = match &sig.decl.output {
                                     FnRetTy::Default(..) => true,
@@ -58,27 +81,34 @@ pub fn check(cx: &LateContext<'_>, text: &str, edition: Edition, range: Range<us
                                     relevant_main_found = true;
                                 } else {
                                     // This main function should not be linted, we're done
-                                    return false;
+                                    eligible = false;
+                                }
+                            },
+                            // Another function was found; this case is ignored for needless_doctest_main
+                            ItemKind::Fn(box Fn { .. }) => {
+                                eligible = false;
+                                if !ignore {
+                                    get_test_spans(&item, &mut test_attr_spans);
                                 }
                             },
                             // Tests with one of these items are ignored
                             ItemKind::Static(..)
                             | ItemKind::Const(..)
                             | ItemKind::ExternCrate(..)
-                            | ItemKind::ForeignMod(..)
-                            // Another function was found; this case is ignored
-                            | ItemKind::Fn(..) => return false,
+                            | ItemKind::ForeignMod(..) => {
+                                eligible = false;
+                            },
                             _ => {},
                         },
                         Ok(None) => break,
                         Err(e) => {
                             e.cancel();
-                            return false;
+                            return (false, test_attr_spans);
                         },
                     }
                 }
 
-                relevant_main_found
+                (relevant_main_found & eligible, test_attr_spans)
             })
         })
         .ok()
@@ -90,11 +120,16 @@ pub fn check(cx: &LateContext<'_>, text: &str, edition: Edition, range: Range<us
     // Because of the global session, we need to create a new session in a different thread with
     // the edition we need.
     let text = text.to_owned();
-    if thread::spawn(move || has_needless_main(text, edition))
+    let (has_main, test_attr_spans) = thread::spawn(move || check_code_sample(text, edition, ignore))
         .join()
-        .expect("thread::spawn failed")
-        && let Some(span) = fragments.span(cx, range.start..range.end - trailing_whitespace)
-    {
+        .expect("thread::spawn failed");
+    if has_main && let Some(span) = fragments.span(cx, range.start..range.end - trailing_whitespace) {
         span_lint(cx, NEEDLESS_DOCTEST_MAIN, span, "needless `fn main` in doctest");
     }
+    for span in test_attr_spans {
+        let span = (range.start + span.start)..(range.start + span.end);
+        if let Some(span) = fragments.span(cx, span) {
+            span_lint(cx, TEST_ATTR_IN_DOCTEST, span, "unit tests in doctest are not executed");
+        }
+    }
 }
diff --git a/tests/ui/test_attr_in_doctest.rs b/tests/ui/test_attr_in_doctest.rs
new file mode 100644
index 00000000000..4c904f7a09a
--- /dev/null
+++ b/tests/ui/test_attr_in_doctest.rs
@@ -0,0 +1,51 @@
+/// This is a test for `#[test]` in doctests
+///
+/// # Examples
+///
+/// ```
+/// #[test]
+/// fn should_be_linted() {
+///     assert_eq!(1, 1);
+/// }
+/// ```
+///
+/// Make sure we catch multiple tests in one example,
+/// and show that we really parse the attr:
+///
+/// ```
+/// #[test]
+/// fn should_also_be_linted() {
+///     #[cfg(test)]
+///     assert!(true);
+/// }
+///
+/// #[test]
+/// fn should_be_linted_too() {
+///     assert_eq!("#[test]", "
+///     #[test]
+///     ");
+/// }
+/// ```
+///
+/// We don't catch examples that aren't run:
+///
+/// ```ignore
+/// #[test]
+/// fn ignored() { todo!() }
+/// ```
+///
+/// ```no_run
+/// #[test]
+/// fn ignored() { todo!() }
+/// ```
+///
+/// ```compile_fail
+/// #[test]
+/// fn ignored() { Err(()) }
+/// ```
+///
+/// ```txt
+/// #[test]
+/// fn not_even_rust() { panic!("Ouch") }
+/// ```
+fn test_attr_in_doctests() {}
diff --git a/tests/ui/test_attr_in_doctest.stderr b/tests/ui/test_attr_in_doctest.stderr
new file mode 100644
index 00000000000..605259f3bfb
--- /dev/null
+++ b/tests/ui/test_attr_in_doctest.stderr
@@ -0,0 +1,29 @@
+error: unit tests in doctest are not executed
+  --> $DIR/test_attr_in_doctest.rs:6:5
+   |
+LL |   /// #[test]
+   |  _____^
+LL | | /// fn should_be_linted() {
+   | |_______________________^
+   |
+   = note: `-D clippy::test-attr-in-doctest` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::test_attr_in_doctest)]`
+
+error: unit tests in doctest are not executed
+  --> $DIR/test_attr_in_doctest.rs:16:5
+   |
+LL |   /// #[test]
+   |  _____^
+LL | | /// fn should_also_be_linted() {
+   | |____________________________^
+
+error: unit tests in doctest are not executed
+  --> $DIR/test_attr_in_doctest.rs:22:5
+   |
+LL |   /// #[test]
+   |  _____^
+LL | | /// fn should_be_linted_too() {
+   | |___________________________^
+
+error: aborting due to 3 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From e3c73f17ecda066052409c0023c38eb7ffb6990a Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Wed, 29 Nov 2023 19:22:28 +0100
Subject: `option_if_let_else`: do not trigger on expressions returning `()`

Fix #11893

Trigerring on expressions returning `()` uses the arguments of the
`map_or_else()` rewrite only for their side effects. This does lead
to code which is harder to read than the original.
---
 clippy_lints/src/option_if_let_else.rs | 21 ++++++++-------
 tests/ui/option_if_let_else.fixed      | 26 ++++++++++++++----
 tests/ui/option_if_let_else.rs         | 34 +++++++++++++++++-------
 tests/ui/option_if_let_else.stderr     | 48 +++++++++++++++++++---------------
 4 files changed, 85 insertions(+), 44 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/option_if_let_else.rs b/clippy_lints/src/option_if_let_else.rs
index cca90d813e0..89e4e3c740d 100644
--- a/clippy_lints/src/option_if_let_else.rs
+++ b/clippy_lints/src/option_if_let_else.rs
@@ -239,21 +239,24 @@ fn detect_option_if_let_else<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>) ->
         if_then,
         if_else: Some(if_else),
     }) = higher::IfLet::hir(cx, expr)
+        && !cx.typeck_results().expr_ty(expr).is_unit()
+        && !is_else_clause(cx.tcx, expr)
     {
-        if !is_else_clause(cx.tcx, expr) {
-            return try_get_option_occurrence(cx, expr.span.ctxt(), let_pat, let_expr, if_then, if_else);
-        }
+        try_get_option_occurrence(cx, expr.span.ctxt(), let_pat, let_expr, if_then, if_else)
+    } else {
+        None
     }
-    None
 }
 
 fn detect_option_match<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>) -> Option<OptionOccurrence> {
-    if let ExprKind::Match(ex, arms, MatchSource::Normal) = expr.kind {
-        if let Some((let_pat, if_then, if_else)) = try_convert_match(cx, arms) {
-            return try_get_option_occurrence(cx, expr.span.ctxt(), let_pat, ex, if_then, if_else);
-        }
+    if let ExprKind::Match(ex, arms, MatchSource::Normal) = expr.kind
+        && !cx.typeck_results().expr_ty(expr).is_unit()
+        && let Some((let_pat, if_then, if_else)) = try_convert_match(cx, arms)
+    {
+        try_get_option_occurrence(cx, expr.span.ctxt(), let_pat, ex, if_then, if_else)
+    } else {
+        None
     }
-    None
 }
 
 fn try_convert_match<'tcx>(
diff --git a/tests/ui/option_if_let_else.fixed b/tests/ui/option_if_let_else.fixed
index f0113ca696e..363520112ef 100644
--- a/tests/ui/option_if_let_else.fixed
+++ b/tests/ui/option_if_let_else.fixed
@@ -92,11 +92,13 @@ fn pattern_to_vec(pattern: &str) -> Vec<String> {
 }
 
 // #10335
-fn test_result_impure_else(variable: Result<u32, &str>) {
+fn test_result_impure_else(variable: Result<u32, &str>) -> bool {
     variable.map_or_else(|_| {
         println!("Err");
+        false
     }, |binding| {
         println!("Ok {binding}");
+        true
     })
 }
 
@@ -213,15 +215,19 @@ mod issue10729 {
 
     pub fn reproduce(initial: &Option<String>) {
         // 👇 needs `.as_ref()` because initial is an `&Option<_>`
-        initial.as_ref().map_or({}, |value| do_something(value))
+        let _ = initial.as_ref().map_or(42, |value| do_something(value));
     }
 
     pub fn reproduce2(initial: &mut Option<String>) {
-        initial.as_mut().map_or({}, |value| do_something2(value))
+        let _ = initial.as_mut().map_or(42, |value| do_something2(value));
     }
 
-    fn do_something(_value: &str) {}
-    fn do_something2(_value: &mut str) {}
+    fn do_something(_value: &str) -> u32 {
+        todo!()
+    }
+    fn do_something2(_value: &mut str) -> u32 {
+        todo!()
+    }
 }
 
 fn issue11429() {
@@ -237,3 +243,13 @@ fn issue11429() {
 
     let mut _hm = opt.as_ref().map_or_else(|| new_map!(), |hm| hm.clone());
 }
+
+fn issue11893() {
+    use std::io::Write;
+    let mut output = std::io::stdout().lock();
+    if let Some(name) = Some("stuff") {
+        writeln!(output, "{name:?}").unwrap();
+    } else {
+        panic!("Haven't thought about this condition.");
+    }
+}
diff --git a/tests/ui/option_if_let_else.rs b/tests/ui/option_if_let_else.rs
index 18b7af44392..aaa87a0db54 100644
--- a/tests/ui/option_if_let_else.rs
+++ b/tests/ui/option_if_let_else.rs
@@ -115,11 +115,13 @@ fn pattern_to_vec(pattern: &str) -> Vec<String> {
 }
 
 // #10335
-fn test_result_impure_else(variable: Result<u32, &str>) {
+fn test_result_impure_else(variable: Result<u32, &str>) -> bool {
     if let Ok(binding) = variable {
         println!("Ok {binding}");
+        true
     } else {
         println!("Err");
+        false
     }
 }
 
@@ -254,21 +256,25 @@ mod issue10729 {
 
     pub fn reproduce(initial: &Option<String>) {
         // 👇 needs `.as_ref()` because initial is an `&Option<_>`
-        match initial {
+        let _ = match initial {
             Some(value) => do_something(value),
-            None => {},
-        }
+            None => 42,
+        };
     }
 
     pub fn reproduce2(initial: &mut Option<String>) {
-        match initial {
+        let _ = match initial {
             Some(value) => do_something2(value),
-            None => {},
-        }
+            None => 42,
+        };
     }
 
-    fn do_something(_value: &str) {}
-    fn do_something2(_value: &mut str) {}
+    fn do_something(_value: &str) -> u32 {
+        todo!()
+    }
+    fn do_something2(_value: &mut str) -> u32 {
+        todo!()
+    }
 }
 
 fn issue11429() {
@@ -288,3 +294,13 @@ fn issue11429() {
 
     let mut _hm = if let Some(hm) = &opt { hm.clone() } else { new_map!() };
 }
+
+fn issue11893() {
+    use std::io::Write;
+    let mut output = std::io::stdout().lock();
+    if let Some(name) = Some("stuff") {
+        writeln!(output, "{name:?}").unwrap();
+    } else {
+        panic!("Haven't thought about this condition.");
+    }
+}
diff --git a/tests/ui/option_if_let_else.stderr b/tests/ui/option_if_let_else.stderr
index e36357bcb38..55a8360ffd0 100644
--- a/tests/ui/option_if_let_else.stderr
+++ b/tests/ui/option_if_let_else.stderr
@@ -158,8 +158,10 @@ error: use Option::map_or_else instead of an if let/else
    |
 LL | /     if let Ok(binding) = variable {
 LL | |         println!("Ok {binding}");
+LL | |         true
 LL | |     } else {
 LL | |         println!("Err");
+LL | |         false
 LL | |     }
    | |_____^
    |
@@ -167,19 +169,21 @@ help: try
    |
 LL ~     variable.map_or_else(|_| {
 LL +         println!("Err");
+LL +         false
 LL +     }, |binding| {
 LL +         println!("Ok {binding}");
+LL +         true
 LL +     })
    |
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:141:13
+  --> $DIR/option_if_let_else.rs:143:13
    |
 LL |     let _ = if let Some(x) = optional { x + 2 } else { 5 };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `optional.map_or(5, |x| x + 2)`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:151:13
+  --> $DIR/option_if_let_else.rs:153:13
    |
 LL |       let _ = if let Some(x) = Some(0) {
    |  _____________^
@@ -201,13 +205,13 @@ LL ~         });
    |
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:179:13
+  --> $DIR/option_if_let_else.rs:181:13
    |
 LL |     let _ = if let Some(x) = Some(0) { s.len() + x } else { s.len() };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Some(0).map_or(s.len(), |x| s.len() + x)`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:183:13
+  --> $DIR/option_if_let_else.rs:185:13
    |
 LL |       let _ = if let Some(x) = Some(0) {
    |  _____________^
@@ -227,7 +231,7 @@ LL ~     });
    |
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:222:13
+  --> $DIR/option_if_let_else.rs:224:13
    |
 LL |       let _ = match s {
    |  _____________^
@@ -237,7 +241,7 @@ LL | |     };
    | |_____^ help: try: `s.map_or(1, |string| string.len())`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:226:13
+  --> $DIR/option_if_let_else.rs:228:13
    |
 LL |       let _ = match Some(10) {
    |  _____________^
@@ -247,7 +251,7 @@ LL | |     };
    | |_____^ help: try: `Some(10).map_or(5, |a| a + 1)`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:232:13
+  --> $DIR/option_if_let_else.rs:234:13
    |
 LL |       let _ = match res {
    |  _____________^
@@ -257,7 +261,7 @@ LL | |     };
    | |_____^ help: try: `res.map_or(1, |a| a + 1)`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:236:13
+  --> $DIR/option_if_let_else.rs:238:13
    |
 LL |       let _ = match res {
    |  _____________^
@@ -267,31 +271,33 @@ LL | |     };
    | |_____^ help: try: `res.map_or(1, |a| a + 1)`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:240:13
+  --> $DIR/option_if_let_else.rs:242:13
    |
 LL |     let _ = if let Ok(a) = res { a + 1 } else { 5 };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `res.map_or(5, |a| a + 1)`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:257:9
+  --> $DIR/option_if_let_else.rs:259:17
    |
-LL | /         match initial {
+LL |           let _ = match initial {
+   |  _________________^
 LL | |             Some(value) => do_something(value),
-LL | |             None => {},
-LL | |         }
-   | |_________^ help: try: `initial.as_ref().map_or({}, |value| do_something(value))`
+LL | |             None => 42,
+LL | |         };
+   | |_________^ help: try: `initial.as_ref().map_or(42, |value| do_something(value))`
 
 error: use Option::map_or instead of an if let/else
-  --> $DIR/option_if_let_else.rs:264:9
+  --> $DIR/option_if_let_else.rs:266:17
    |
-LL | /         match initial {
+LL |           let _ = match initial {
+   |  _________________^
 LL | |             Some(value) => do_something2(value),
-LL | |             None => {},
-LL | |         }
-   | |_________^ help: try: `initial.as_mut().map_or({}, |value| do_something2(value))`
+LL | |             None => 42,
+LL | |         };
+   | |_________^ help: try: `initial.as_mut().map_or(42, |value| do_something2(value))`
 
 error: use Option::map_or_else instead of an if let/else
-  --> $DIR/option_if_let_else.rs:283:24
+  --> $DIR/option_if_let_else.rs:289:24
    |
 LL |       let mut _hashmap = if let Some(hm) = &opt {
    |  ________________________^
@@ -302,7 +308,7 @@ LL | |     };
    | |_____^ help: try: `opt.as_ref().map_or_else(HashMap::new, |hm| hm.clone())`
 
 error: use Option::map_or_else instead of an if let/else
-  --> $DIR/option_if_let_else.rs:289:19
+  --> $DIR/option_if_let_else.rs:295:19
    |
 LL |     let mut _hm = if let Some(hm) = &opt { hm.clone() } else { new_map!() };
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `opt.as_ref().map_or_else(|| new_map!(), |hm| hm.clone())`
-- 
cgit 1.4.1-3-g733a5


From fff7aa0e18a5b71f5d6329afc9a8da56a3fed561 Mon Sep 17 00:00:00 2001
From: J-ZhengLi <lizheng135@huawei.com>
Date: Wed, 22 Nov 2023 09:29:44 +0800
Subject: expending lint [`blocks_in_if_conditions`] to check match expr as
 well

---
 clippy_lints/src/blocks_in_if_conditions.rs        | 125 +++++++++++----------
 .../ui-toml/excessive_nesting/excessive_nesting.rs |   2 +-
 tests/ui/blocks_in_if_conditions.fixed             |  12 ++
 tests/ui/blocks_in_if_conditions.rs                |  12 ++
 tests/ui/blocks_in_if_conditions.stderr            |  19 +++-
 5 files changed, 106 insertions(+), 64 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/blocks_in_if_conditions.rs b/clippy_lints/src/blocks_in_if_conditions.rs
index 692309629b7..0ec8cc8292e 100644
--- a/clippy_lints/src/blocks_in_if_conditions.rs
+++ b/clippy_lints/src/blocks_in_if_conditions.rs
@@ -5,7 +5,7 @@ use clippy_utils::visitors::{for_each_expr, Descend};
 use clippy_utils::{get_parent_expr, higher};
 use core::ops::ControlFlow;
 use rustc_errors::Applicability;
-use rustc_hir::{BlockCheckMode, Expr, ExprKind};
+use rustc_hir::{BlockCheckMode, Expr, ExprKind, MatchSource};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::declare_lint_pass;
@@ -52,88 +52,89 @@ impl<'tcx> LateLintPass<'tcx> for BlocksInIfConditions {
         if in_external_macro(cx.sess(), expr.span) {
             return;
         }
-        if let Some(higher::If { cond, .. }) = higher::If::hir(expr) {
-            if let ExprKind::Block(block, _) = &cond.kind {
-                if block.rules == BlockCheckMode::DefaultBlock {
-                    if block.stmts.is_empty() {
-                        if let Some(ex) = &block.expr {
-                            // don't dig into the expression here, just suggest that they remove
-                            // the block
-                            if expr.span.from_expansion() || ex.span.from_expansion() {
-                                return;
-                            }
-                            let mut applicability = Applicability::MachineApplicable;
-                            span_lint_and_sugg(
-                                cx,
-                                BLOCKS_IN_IF_CONDITIONS,
-                                cond.span,
-                                BRACED_EXPR_MESSAGE,
-                                "try",
-                                format!(
-                                    "{}",
-                                    snippet_block_with_applicability(
-                                        cx,
-                                        ex.span,
-                                        "..",
-                                        Some(expr.span),
-                                        &mut applicability
-                                    )
-                                ),
-                                applicability,
-                            );
-                        }
-                    } else {
-                        let span = block.expr.as_ref().map_or_else(|| block.stmts[0].span, |e| e.span);
-                        if span.from_expansion() || expr.span.from_expansion() {
+        let Some((cond, keyword)) = higher::If::hir(expr).map(|hif| (hif.cond, "if")).or(
+            if let ExprKind::Match(match_ex, _, MatchSource::Normal) = expr.kind {
+                Some((match_ex, "match"))
+            } else {
+                None
+            },
+        ) else {
+            return;
+        };
+        if let ExprKind::Block(block, _) = &cond.kind {
+            if block.rules == BlockCheckMode::DefaultBlock {
+                if block.stmts.is_empty() {
+                    if let Some(ex) = &block.expr {
+                        // don't dig into the expression here, just suggest that they remove
+                        // the block
+                        if expr.span.from_expansion() || ex.span.from_expansion() {
                             return;
                         }
-                        // move block higher
                         let mut applicability = Applicability::MachineApplicable;
                         span_lint_and_sugg(
                             cx,
                             BLOCKS_IN_IF_CONDITIONS,
-                            expr.span.with_hi(cond.span.hi()),
-                            COMPLEX_BLOCK_MESSAGE,
+                            cond.span,
+                            BRACED_EXPR_MESSAGE,
                             "try",
                             format!(
-                                "let res = {}; if res",
+                                "{}",
                                 snippet_block_with_applicability(
                                     cx,
-                                    block.span,
+                                    ex.span,
                                     "..",
                                     Some(expr.span),
                                     &mut applicability
-                                ),
+                                )
                             ),
                             applicability,
                         );
                     }
+                } else {
+                    let span = block.expr.as_ref().map_or_else(|| block.stmts[0].span, |e| e.span);
+                    if span.from_expansion() || expr.span.from_expansion() {
+                        return;
+                    }
+                    // move block higher
+                    let mut applicability = Applicability::MachineApplicable;
+                    span_lint_and_sugg(
+                        cx,
+                        BLOCKS_IN_IF_CONDITIONS,
+                        expr.span.with_hi(cond.span.hi()),
+                        COMPLEX_BLOCK_MESSAGE,
+                        "try",
+                        format!(
+                            "let res = {}; {keyword} res",
+                            snippet_block_with_applicability(cx, block.span, "..", Some(expr.span), &mut applicability),
+                        ),
+                        applicability,
+                    );
                 }
-            } else {
-                let _: Option<!> = for_each_expr(cond, |e| {
-                    if let ExprKind::Closure(closure) = e.kind {
-                        // do not lint if the closure is called using an iterator (see #1141)
-                        if let Some(parent) = get_parent_expr(cx, e)
-                            && let ExprKind::MethodCall(_, self_arg, _, _) = &parent.kind
-                            && let caller = cx.typeck_results().expr_ty(self_arg)
-                            && let Some(iter_id) = cx.tcx.get_diagnostic_item(sym::Iterator)
-                            && implements_trait(cx, caller, iter_id, &[])
-                        {
-                            return ControlFlow::Continue(Descend::No);
-                        }
+            }
+        } else {
+            let _: Option<!> = for_each_expr(cond, |e| {
+                if let ExprKind::Closure(closure) = e.kind {
+                    // do not lint if the closure is called using an iterator (see #1141)
+                    if let Some(parent) = get_parent_expr(cx, e)
+                        && let ExprKind::MethodCall(_, self_arg, _, _) = &parent.kind
+                        && let caller = cx.typeck_results().expr_ty(self_arg)
+                        && let Some(iter_id) = cx.tcx.get_diagnostic_item(sym::Iterator)
+                        && implements_trait(cx, caller, iter_id, &[])
+                    {
+                        return ControlFlow::Continue(Descend::No);
+                    }
 
-                        let body = cx.tcx.hir().body(closure.body);
-                        let ex = &body.value;
-                        if let ExprKind::Block(block, _) = ex.kind {
-                            if !body.value.span.from_expansion() && !block.stmts.is_empty() {
-                                span_lint(cx, BLOCKS_IN_IF_CONDITIONS, ex.span, COMPLEX_BLOCK_MESSAGE);
-                                return ControlFlow::Continue(Descend::No);
-                            }
+                    let body = cx.tcx.hir().body(closure.body);
+                    let ex = &body.value;
+                    if let ExprKind::Block(block, _) = ex.kind {
+                        if !body.value.span.from_expansion() && !block.stmts.is_empty() {
+                            span_lint(cx, BLOCKS_IN_IF_CONDITIONS, ex.span, COMPLEX_BLOCK_MESSAGE);
+                            return ControlFlow::Continue(Descend::No);
                         }
                     }
-                    ControlFlow::Continue(Descend::Yes)
-                });
-            }
+                }
+                ControlFlow::Continue(Descend::Yes)
+            });
         }
     }
 }
diff --git a/tests/ui-toml/excessive_nesting/excessive_nesting.rs b/tests/ui-toml/excessive_nesting/excessive_nesting.rs
index d737a832dd1..1f61306ca0b 100644
--- a/tests/ui-toml/excessive_nesting/excessive_nesting.rs
+++ b/tests/ui-toml/excessive_nesting/excessive_nesting.rs
@@ -9,7 +9,7 @@
 #![allow(clippy::never_loop)]
 #![allow(clippy::needless_if)]
 #![warn(clippy::excessive_nesting)]
-#![allow(clippy::collapsible_if)]
+#![allow(clippy::collapsible_if, clippy::blocks_in_if_conditions)]
 
 #[macro_use]
 extern crate proc_macros;
diff --git a/tests/ui/blocks_in_if_conditions.fixed b/tests/ui/blocks_in_if_conditions.fixed
index f89c465047e..ad854faa59a 100644
--- a/tests/ui/blocks_in_if_conditions.fixed
+++ b/tests/ui/blocks_in_if_conditions.fixed
@@ -61,4 +61,16 @@ fn block_in_assert() {
     );
 }
 
+// issue #11814
+fn block_in_match_expr(num: i32) -> i32 {
+    let res = {
+        let opt = Some(2);
+        opt
+    }; match res {
+        Some(0) => 1,
+        Some(n) => num * 2,
+        None => 0,
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/blocks_in_if_conditions.rs b/tests/ui/blocks_in_if_conditions.rs
index 34febc5fa2c..faeffa57f1c 100644
--- a/tests/ui/blocks_in_if_conditions.rs
+++ b/tests/ui/blocks_in_if_conditions.rs
@@ -61,4 +61,16 @@ fn block_in_assert() {
     );
 }
 
+// issue #11814
+fn block_in_match_expr(num: i32) -> i32 {
+    match {
+        let opt = Some(2);
+        opt
+    } {
+        Some(0) => 1,
+        Some(n) => num * 2,
+        None => 0,
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/blocks_in_if_conditions.stderr b/tests/ui/blocks_in_if_conditions.stderr
index d80ef9c0fd8..c564276f056 100644
--- a/tests/ui/blocks_in_if_conditions.stderr
+++ b/tests/ui/blocks_in_if_conditions.stderr
@@ -32,5 +32,22 @@ LL |     if true && x == 3 { 6 } else { 10 }
    = note: `-D clippy::nonminimal-bool` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::nonminimal_bool)]`
 
-error: aborting due to 3 previous errors
+error: in an `if` condition, avoid complex blocks or closures with blocks; instead, move the block or closure higher and bind it with a `let`
+  --> $DIR/blocks_in_if_conditions.rs:66:5
+   |
+LL | /     match {
+LL | |         let opt = Some(2);
+LL | |         opt
+LL | |     } {
+   | |_____^
+   |
+help: try
+   |
+LL ~     let res = {
+LL +         let opt = Some(2);
+LL +         opt
+LL ~     }; match res {
+   |
+
+error: aborting due to 4 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 40b558af764a43e8d1c1a22ad34efc3dd3cf4208 Mon Sep 17 00:00:00 2001
From: J-ZhengLi <lizheng135@huawei.com>
Date: Thu, 30 Nov 2023 15:41:54 +0800
Subject: rename [`blocks_in_if_conditions`] to [`blocks_in_conditions`]; add
 more test cases with `match`; minor fixes in message output regarding review
 feedback

---
 CHANGELOG.md                                       |   1 +
 clippy_lints/src/blocks_in_conditions.rs           | 137 ++++++++++++++++++++
 clippy_lints/src/blocks_in_if_conditions.rs        | 140 ---------------------
 clippy_lints/src/declared_lints.rs                 |   2 +-
 clippy_lints/src/lib.rs                            |   4 +-
 clippy_lints/src/renamed_lints.rs                  |   5 +-
 .../ui-toml/excessive_nesting/excessive_nesting.rs |   2 +-
 tests/ui/bind_instead_of_map_multipart.fixed       |   2 +-
 tests/ui/bind_instead_of_map_multipart.rs          |   2 +-
 tests/ui/blocks_in_conditions.fixed                |  88 +++++++++++++
 tests/ui/blocks_in_conditions.rs                   |  88 +++++++++++++
 tests/ui/blocks_in_conditions.stderr               |  57 +++++++++
 tests/ui/blocks_in_conditions_closure.rs           |  89 +++++++++++++
 tests/ui/blocks_in_conditions_closure.stderr       |  39 ++++++
 tests/ui/blocks_in_if_conditions.fixed             |  76 -----------
 tests/ui/blocks_in_if_conditions.rs                |  76 -----------
 tests/ui/blocks_in_if_conditions.stderr            |  53 --------
 tests/ui/blocks_in_if_conditions_closure.rs        |  72 -----------
 tests/ui/blocks_in_if_conditions_closure.stderr    |  28 -----
 tests/ui/manual_filter.fixed                       |   2 +-
 tests/ui/manual_filter.rs                          |   2 +-
 tests/ui/needless_if.fixed                         |   2 +-
 tests/ui/needless_if.rs                            |   2 +-
 tests/ui/needless_late_init.fixed                  |   2 +-
 tests/ui/needless_late_init.rs                     |   2 +-
 tests/ui/rename.fixed                              |   7 +-
 tests/ui/rename.rs                                 |   3 +-
 tests/ui/rename.stderr                             | 120 +++++++++---------
 28 files changed, 583 insertions(+), 520 deletions(-)
 create mode 100644 clippy_lints/src/blocks_in_conditions.rs
 delete mode 100644 clippy_lints/src/blocks_in_if_conditions.rs
 create mode 100644 tests/ui/blocks_in_conditions.fixed
 create mode 100644 tests/ui/blocks_in_conditions.rs
 create mode 100644 tests/ui/blocks_in_conditions.stderr
 create mode 100644 tests/ui/blocks_in_conditions_closure.rs
 create mode 100644 tests/ui/blocks_in_conditions_closure.stderr
 delete mode 100644 tests/ui/blocks_in_if_conditions.fixed
 delete mode 100644 tests/ui/blocks_in_if_conditions.rs
 delete mode 100644 tests/ui/blocks_in_if_conditions.stderr
 delete mode 100644 tests/ui/blocks_in_if_conditions_closure.rs
 delete mode 100644 tests/ui/blocks_in_if_conditions_closure.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index abe975fa42b..b1281704eca 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4946,6 +4946,7 @@ Released 2018-09-13
 [`blanket_clippy_restriction_lints`]: https://rust-lang.github.io/rust-clippy/master/index.html#blanket_clippy_restriction_lints
 [`block_in_if_condition_expr`]: https://rust-lang.github.io/rust-clippy/master/index.html#block_in_if_condition_expr
 [`block_in_if_condition_stmt`]: https://rust-lang.github.io/rust-clippy/master/index.html#block_in_if_condition_stmt
+[`blocks_in_conditions`]: https://rust-lang.github.io/rust-clippy/master/index.html#blocks_in_conditions
 [`blocks_in_if_conditions`]: https://rust-lang.github.io/rust-clippy/master/index.html#blocks_in_if_conditions
 [`bool_assert_comparison`]: https://rust-lang.github.io/rust-clippy/master/index.html#bool_assert_comparison
 [`bool_comparison`]: https://rust-lang.github.io/rust-clippy/master/index.html#bool_comparison
diff --git a/clippy_lints/src/blocks_in_conditions.rs b/clippy_lints/src/blocks_in_conditions.rs
new file mode 100644
index 00000000000..1417e230aee
--- /dev/null
+++ b/clippy_lints/src/blocks_in_conditions.rs
@@ -0,0 +1,137 @@
+use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg};
+use clippy_utils::source::snippet_block_with_applicability;
+use clippy_utils::ty::implements_trait;
+use clippy_utils::visitors::{for_each_expr, Descend};
+use clippy_utils::{get_parent_expr, higher};
+use core::ops::ControlFlow;
+use rustc_errors::Applicability;
+use rustc_hir::{BlockCheckMode, Expr, ExprKind, MatchSource};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_middle::lint::in_external_macro;
+use rustc_session::declare_lint_pass;
+use rustc_span::sym;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `if` conditions that use blocks containing an
+    /// expression, statements or conditions that use closures with blocks.
+    ///
+    /// ### Why is this bad?
+    /// Style, using blocks in the condition makes it hard to read.
+    ///
+    /// ### Examples
+    /// ```no_run
+    /// # fn somefunc() -> bool { true };
+    /// if { true } { /* ... */ }
+    ///
+    /// if { let x = somefunc(); x } { /* ... */ }
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// # fn somefunc() -> bool { true };
+    /// if true { /* ... */ }
+    ///
+    /// let res = { let x = somefunc(); x };
+    /// if res { /* ... */ }
+    /// ```
+    #[clippy::version = "1.45.0"]
+    pub BLOCKS_IN_CONDITIONS,
+    style,
+    "useless or complex blocks that can be eliminated in conditions"
+}
+
+declare_lint_pass!(BlocksInConditions => [BLOCKS_IN_CONDITIONS]);
+
+const BRACED_EXPR_MESSAGE: &str = "omit braces around single expression condition";
+
+impl<'tcx> LateLintPass<'tcx> for BlocksInConditions {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        if in_external_macro(cx.sess(), expr.span) {
+            return;
+        }
+
+        let Some((cond, keyword, desc)) = higher::If::hir(expr)
+            .map(|hif| (hif.cond, "if", "an `if` condition"))
+            .or(if let ExprKind::Match(match_ex, _, MatchSource::Normal) = expr.kind {
+                Some((match_ex, "match", "a `match` scrutinee"))
+            } else {
+                None
+            })
+        else {
+            return;
+        };
+        let complex_block_message = &format!(
+            "in {desc}, avoid complex blocks or closures with blocks; \
+            instead, move the block or closure higher and bind it with a `let`",
+        );
+
+        if let ExprKind::Block(block, _) = &cond.kind {
+            if block.rules == BlockCheckMode::DefaultBlock {
+                if block.stmts.is_empty() {
+                    if let Some(ex) = &block.expr {
+                        // don't dig into the expression here, just suggest that they remove
+                        // the block
+                        if expr.span.from_expansion() || ex.span.from_expansion() {
+                            return;
+                        }
+                        let mut applicability = Applicability::MachineApplicable;
+                        span_lint_and_sugg(
+                            cx,
+                            BLOCKS_IN_CONDITIONS,
+                            cond.span,
+                            BRACED_EXPR_MESSAGE,
+                            "try",
+                            snippet_block_with_applicability(cx, ex.span, "..", Some(expr.span), &mut applicability)
+                                .to_string(),
+                            applicability,
+                        );
+                    }
+                } else {
+                    let span = block.expr.as_ref().map_or_else(|| block.stmts[0].span, |e| e.span);
+                    if span.from_expansion() || expr.span.from_expansion() {
+                        return;
+                    }
+                    // move block higher
+                    let mut applicability = Applicability::MachineApplicable;
+                    span_lint_and_sugg(
+                        cx,
+                        BLOCKS_IN_CONDITIONS,
+                        expr.span.with_hi(cond.span.hi()),
+                        complex_block_message,
+                        "try",
+                        format!(
+                            "let res = {}; {keyword} res",
+                            snippet_block_with_applicability(cx, block.span, "..", Some(expr.span), &mut applicability),
+                        ),
+                        applicability,
+                    );
+                }
+            }
+        } else {
+            let _: Option<!> = for_each_expr(cond, |e| {
+                if let ExprKind::Closure(closure) = e.kind {
+                    // do not lint if the closure is called using an iterator (see #1141)
+                    if let Some(parent) = get_parent_expr(cx, e)
+                        && let ExprKind::MethodCall(_, self_arg, _, _) = &parent.kind
+                        && let caller = cx.typeck_results().expr_ty(self_arg)
+                        && let Some(iter_id) = cx.tcx.get_diagnostic_item(sym::Iterator)
+                        && implements_trait(cx, caller, iter_id, &[])
+                    {
+                        return ControlFlow::Continue(Descend::No);
+                    }
+
+                    let body = cx.tcx.hir().body(closure.body);
+                    let ex = &body.value;
+                    if let ExprKind::Block(block, _) = ex.kind {
+                        if !body.value.span.from_expansion() && !block.stmts.is_empty() {
+                            span_lint(cx, BLOCKS_IN_CONDITIONS, ex.span, complex_block_message);
+                            return ControlFlow::Continue(Descend::No);
+                        }
+                    }
+                }
+                ControlFlow::Continue(Descend::Yes)
+            });
+        }
+    }
+}
diff --git a/clippy_lints/src/blocks_in_if_conditions.rs b/clippy_lints/src/blocks_in_if_conditions.rs
deleted file mode 100644
index 0ec8cc8292e..00000000000
--- a/clippy_lints/src/blocks_in_if_conditions.rs
+++ /dev/null
@@ -1,140 +0,0 @@
-use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg};
-use clippy_utils::source::snippet_block_with_applicability;
-use clippy_utils::ty::implements_trait;
-use clippy_utils::visitors::{for_each_expr, Descend};
-use clippy_utils::{get_parent_expr, higher};
-use core::ops::ControlFlow;
-use rustc_errors::Applicability;
-use rustc_hir::{BlockCheckMode, Expr, ExprKind, MatchSource};
-use rustc_lint::{LateContext, LateLintPass, LintContext};
-use rustc_middle::lint::in_external_macro;
-use rustc_session::declare_lint_pass;
-use rustc_span::sym;
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for `if` conditions that use blocks containing an
-    /// expression, statements or conditions that use closures with blocks.
-    ///
-    /// ### Why is this bad?
-    /// Style, using blocks in the condition makes it hard to read.
-    ///
-    /// ### Examples
-    /// ```no_run
-    /// # fn somefunc() -> bool { true };
-    /// if { true } { /* ... */ }
-    ///
-    /// if { let x = somefunc(); x } { /* ... */ }
-    /// ```
-    ///
-    /// Use instead:
-    /// ```no_run
-    /// # fn somefunc() -> bool { true };
-    /// if true { /* ... */ }
-    ///
-    /// let res = { let x = somefunc(); x };
-    /// if res { /* ... */ }
-    /// ```
-    #[clippy::version = "1.45.0"]
-    pub BLOCKS_IN_IF_CONDITIONS,
-    style,
-    "useless or complex blocks that can be eliminated in conditions"
-}
-
-declare_lint_pass!(BlocksInIfConditions => [BLOCKS_IN_IF_CONDITIONS]);
-
-const BRACED_EXPR_MESSAGE: &str = "omit braces around single expression condition";
-const COMPLEX_BLOCK_MESSAGE: &str = "in an `if` condition, avoid complex blocks or closures with blocks; \
-                                    instead, move the block or closure higher and bind it with a `let`";
-
-impl<'tcx> LateLintPass<'tcx> for BlocksInIfConditions {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if in_external_macro(cx.sess(), expr.span) {
-            return;
-        }
-        let Some((cond, keyword)) = higher::If::hir(expr).map(|hif| (hif.cond, "if")).or(
-            if let ExprKind::Match(match_ex, _, MatchSource::Normal) = expr.kind {
-                Some((match_ex, "match"))
-            } else {
-                None
-            },
-        ) else {
-            return;
-        };
-        if let ExprKind::Block(block, _) = &cond.kind {
-            if block.rules == BlockCheckMode::DefaultBlock {
-                if block.stmts.is_empty() {
-                    if let Some(ex) = &block.expr {
-                        // don't dig into the expression here, just suggest that they remove
-                        // the block
-                        if expr.span.from_expansion() || ex.span.from_expansion() {
-                            return;
-                        }
-                        let mut applicability = Applicability::MachineApplicable;
-                        span_lint_and_sugg(
-                            cx,
-                            BLOCKS_IN_IF_CONDITIONS,
-                            cond.span,
-                            BRACED_EXPR_MESSAGE,
-                            "try",
-                            format!(
-                                "{}",
-                                snippet_block_with_applicability(
-                                    cx,
-                                    ex.span,
-                                    "..",
-                                    Some(expr.span),
-                                    &mut applicability
-                                )
-                            ),
-                            applicability,
-                        );
-                    }
-                } else {
-                    let span = block.expr.as_ref().map_or_else(|| block.stmts[0].span, |e| e.span);
-                    if span.from_expansion() || expr.span.from_expansion() {
-                        return;
-                    }
-                    // move block higher
-                    let mut applicability = Applicability::MachineApplicable;
-                    span_lint_and_sugg(
-                        cx,
-                        BLOCKS_IN_IF_CONDITIONS,
-                        expr.span.with_hi(cond.span.hi()),
-                        COMPLEX_BLOCK_MESSAGE,
-                        "try",
-                        format!(
-                            "let res = {}; {keyword} res",
-                            snippet_block_with_applicability(cx, block.span, "..", Some(expr.span), &mut applicability),
-                        ),
-                        applicability,
-                    );
-                }
-            }
-        } else {
-            let _: Option<!> = for_each_expr(cond, |e| {
-                if let ExprKind::Closure(closure) = e.kind {
-                    // do not lint if the closure is called using an iterator (see #1141)
-                    if let Some(parent) = get_parent_expr(cx, e)
-                        && let ExprKind::MethodCall(_, self_arg, _, _) = &parent.kind
-                        && let caller = cx.typeck_results().expr_ty(self_arg)
-                        && let Some(iter_id) = cx.tcx.get_diagnostic_item(sym::Iterator)
-                        && implements_trait(cx, caller, iter_id, &[])
-                    {
-                        return ControlFlow::Continue(Descend::No);
-                    }
-
-                    let body = cx.tcx.hir().body(closure.body);
-                    let ex = &body.value;
-                    if let ExprKind::Block(block, _) = ex.kind {
-                        if !body.value.span.from_expansion() && !block.stmts.is_empty() {
-                            span_lint(cx, BLOCKS_IN_IF_CONDITIONS, ex.span, COMPLEX_BLOCK_MESSAGE);
-                            return ControlFlow::Continue(Descend::No);
-                        }
-                    }
-                }
-                ControlFlow::Continue(Descend::Yes)
-            });
-        }
-    }
-}
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 5a109fcc2cc..abea2773e74 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -63,7 +63,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::await_holding_invalid::AWAIT_HOLDING_INVALID_TYPE_INFO,
     crate::await_holding_invalid::AWAIT_HOLDING_LOCK_INFO,
     crate::await_holding_invalid::AWAIT_HOLDING_REFCELL_REF_INFO,
-    crate::blocks_in_if_conditions::BLOCKS_IN_IF_CONDITIONS_INFO,
+    crate::blocks_in_conditions::BLOCKS_IN_CONDITIONS_INFO,
     crate::bool_assert_comparison::BOOL_ASSERT_COMPARISON_INFO,
     crate::bool_to_int_with_if::BOOL_TO_INT_WITH_IF_INFO,
     crate::booleans::NONMINIMAL_BOOL_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 1c59b2df853..2f3b4cda996 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -74,7 +74,7 @@ mod assertions_on_result_states;
 mod async_yields_async;
 mod attrs;
 mod await_holding_invalid;
-mod blocks_in_if_conditions;
+mod blocks_in_conditions;
 mod bool_assert_comparison;
 mod bool_to_int_with_if;
 mod booleans;
@@ -653,7 +653,7 @@ pub fn register_lints(store: &mut rustc_lint::LintStore, conf: &'static Conf) {
     store.register_late_pass(|_| Box::<significant_drop_tightening::SignificantDropTightening<'_>>::default());
     store.register_late_pass(|_| Box::new(len_zero::LenZero));
     store.register_late_pass(|_| Box::new(attrs::Attributes));
-    store.register_late_pass(|_| Box::new(blocks_in_if_conditions::BlocksInIfConditions));
+    store.register_late_pass(|_| Box::new(blocks_in_conditions::BlocksInConditions));
     store.register_late_pass(|_| Box::new(unicode::Unicode));
     store.register_late_pass(|_| Box::new(uninit_vec::UninitVec));
     store.register_late_pass(|_| Box::new(unit_return_expecting_ord::UnitReturnExpectingOrd));
diff --git a/clippy_lints/src/renamed_lints.rs b/clippy_lints/src/renamed_lints.rs
index 613f1ecc6fb..81fe9535ad9 100644
--- a/clippy_lints/src/renamed_lints.rs
+++ b/clippy_lints/src/renamed_lints.rs
@@ -4,8 +4,9 @@
 pub static RENAMED_LINTS: &[(&str, &str)] = &[
     ("clippy::almost_complete_letter_range", "clippy::almost_complete_range"),
     ("clippy::blacklisted_name", "clippy::disallowed_names"),
-    ("clippy::block_in_if_condition_expr", "clippy::blocks_in_if_conditions"),
-    ("clippy::block_in_if_condition_stmt", "clippy::blocks_in_if_conditions"),
+    ("clippy::block_in_if_condition_expr", "clippy::blocks_in_conditions"),
+    ("clippy::block_in_if_condition_stmt", "clippy::blocks_in_conditions"),
+    ("clippy::blocks_in_if_conditions", "clippy::blocks_in_conditions"),
     ("clippy::box_vec", "clippy::box_collection"),
     ("clippy::const_static_lifetime", "clippy::redundant_static_lifetimes"),
     ("clippy::cyclomatic_complexity", "clippy::cognitive_complexity"),
diff --git a/tests/ui-toml/excessive_nesting/excessive_nesting.rs b/tests/ui-toml/excessive_nesting/excessive_nesting.rs
index 1f61306ca0b..4375f324aca 100644
--- a/tests/ui-toml/excessive_nesting/excessive_nesting.rs
+++ b/tests/ui-toml/excessive_nesting/excessive_nesting.rs
@@ -9,7 +9,7 @@
 #![allow(clippy::never_loop)]
 #![allow(clippy::needless_if)]
 #![warn(clippy::excessive_nesting)]
-#![allow(clippy::collapsible_if, clippy::blocks_in_if_conditions)]
+#![allow(clippy::collapsible_if, clippy::blocks_in_conditions)]
 
 #[macro_use]
 extern crate proc_macros;
diff --git a/tests/ui/bind_instead_of_map_multipart.fixed b/tests/ui/bind_instead_of_map_multipart.fixed
index 8cbadc67d71..8c77039b3c0 100644
--- a/tests/ui/bind_instead_of_map_multipart.fixed
+++ b/tests/ui/bind_instead_of_map_multipart.fixed
@@ -1,5 +1,5 @@
 #![deny(clippy::bind_instead_of_map)]
-#![allow(clippy::blocks_in_if_conditions)]
+#![allow(clippy::blocks_in_conditions)]
 
 pub fn main() {
     let _ = Some("42").map(|s| if s.len() < 42 { 0 } else { s.len() });
diff --git a/tests/ui/bind_instead_of_map_multipart.rs b/tests/ui/bind_instead_of_map_multipart.rs
index 91d9d11e3c1..44257f3a469 100644
--- a/tests/ui/bind_instead_of_map_multipart.rs
+++ b/tests/ui/bind_instead_of_map_multipart.rs
@@ -1,5 +1,5 @@
 #![deny(clippy::bind_instead_of_map)]
-#![allow(clippy::blocks_in_if_conditions)]
+#![allow(clippy::blocks_in_conditions)]
 
 pub fn main() {
     let _ = Some("42").and_then(|s| if s.len() < 42 { Some(0) } else { Some(s.len()) });
diff --git a/tests/ui/blocks_in_conditions.fixed b/tests/ui/blocks_in_conditions.fixed
new file mode 100644
index 00000000000..2ab441bbd0c
--- /dev/null
+++ b/tests/ui/blocks_in_conditions.fixed
@@ -0,0 +1,88 @@
+#![warn(clippy::blocks_in_conditions)]
+#![allow(unused, clippy::let_and_return, clippy::needless_if)]
+#![warn(clippy::nonminimal_bool)]
+
+macro_rules! blocky {
+    () => {{ true }};
+}
+
+macro_rules! blocky_too {
+    () => {{
+        let r = true;
+        r
+    }};
+}
+
+fn macro_if() {
+    if blocky!() {}
+
+    if blocky_too!() {}
+}
+
+fn condition_has_block() -> i32 {
+    let res = {
+        //~^ ERROR: in an `if` condition, avoid complex blocks or closures with blocks; instead, move the block or closure higher and bind it with a `let`
+        let x = 3;
+        x == 3
+    }; if res {
+        6
+    } else {
+        10
+    }
+}
+
+fn condition_has_block_with_single_expression() -> i32 {
+    if true { 6 } else { 10 }
+    //~^ ERROR: omit braces around single expression condition
+}
+
+fn condition_is_normal() -> i32 {
+    let x = 3;
+    if x == 3 { 6 } else { 10 }
+}
+
+fn condition_is_unsafe_block() {
+    let a: i32 = 1;
+
+    // this should not warn because the condition is an unsafe block
+    if unsafe { 1u32 == std::mem::transmute(a) } {
+        println!("1u32 == a");
+    }
+}
+
+fn block_in_assert() {
+    let opt = Some(42);
+    assert!(
+        opt.as_ref()
+            .map(|val| {
+                let mut v = val * 2;
+                v -= 1;
+                v * 3
+            })
+            .is_some()
+    );
+}
+
+// issue #11814
+fn block_in_match_expr(num: i32) -> i32 {
+    let res = {
+        //~^ ERROR: in a `match` scrutinee, avoid complex blocks or closures with blocks; instead, move the block or closure higher and bind it with a `let`
+        let opt = Some(2);
+        opt
+    }; match res {
+        Some(0) => 1,
+        Some(n) => num * 2,
+        None => 0,
+    };
+
+    match unsafe {
+        let hearty_hearty_hearty = vec![240, 159, 146, 150];
+        String::from_utf8_unchecked(hearty_hearty_hearty).as_str()
+    } {
+        "💖" => 1,
+        "what" => 2,
+        _ => 3,
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/blocks_in_conditions.rs b/tests/ui/blocks_in_conditions.rs
new file mode 100644
index 00000000000..dd5ae4fb486
--- /dev/null
+++ b/tests/ui/blocks_in_conditions.rs
@@ -0,0 +1,88 @@
+#![warn(clippy::blocks_in_conditions)]
+#![allow(unused, clippy::let_and_return, clippy::needless_if)]
+#![warn(clippy::nonminimal_bool)]
+
+macro_rules! blocky {
+    () => {{ true }};
+}
+
+macro_rules! blocky_too {
+    () => {{
+        let r = true;
+        r
+    }};
+}
+
+fn macro_if() {
+    if blocky!() {}
+
+    if blocky_too!() {}
+}
+
+fn condition_has_block() -> i32 {
+    if {
+        //~^ ERROR: in an `if` condition, avoid complex blocks or closures with blocks; instead, move the block or closure higher and bind it with a `let`
+        let x = 3;
+        x == 3
+    } {
+        6
+    } else {
+        10
+    }
+}
+
+fn condition_has_block_with_single_expression() -> i32 {
+    if { true } { 6 } else { 10 }
+    //~^ ERROR: omit braces around single expression condition
+}
+
+fn condition_is_normal() -> i32 {
+    let x = 3;
+    if true && x == 3 { 6 } else { 10 }
+}
+
+fn condition_is_unsafe_block() {
+    let a: i32 = 1;
+
+    // this should not warn because the condition is an unsafe block
+    if unsafe { 1u32 == std::mem::transmute(a) } {
+        println!("1u32 == a");
+    }
+}
+
+fn block_in_assert() {
+    let opt = Some(42);
+    assert!(
+        opt.as_ref()
+            .map(|val| {
+                let mut v = val * 2;
+                v -= 1;
+                v * 3
+            })
+            .is_some()
+    );
+}
+
+// issue #11814
+fn block_in_match_expr(num: i32) -> i32 {
+    match {
+        //~^ ERROR: in a `match` scrutinee, avoid complex blocks or closures with blocks; instead, move the block or closure higher and bind it with a `let`
+        let opt = Some(2);
+        opt
+    } {
+        Some(0) => 1,
+        Some(n) => num * 2,
+        None => 0,
+    };
+
+    match unsafe {
+        let hearty_hearty_hearty = vec![240, 159, 146, 150];
+        String::from_utf8_unchecked(hearty_hearty_hearty).as_str()
+    } {
+        "💖" => 1,
+        "what" => 2,
+        _ => 3,
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/blocks_in_conditions.stderr b/tests/ui/blocks_in_conditions.stderr
new file mode 100644
index 00000000000..b00fe2f632c
--- /dev/null
+++ b/tests/ui/blocks_in_conditions.stderr
@@ -0,0 +1,57 @@
+error: in an `if` condition, avoid complex blocks or closures with blocks; instead, move the block or closure higher and bind it with a `let`
+  --> $DIR/blocks_in_conditions.rs:23:5
+   |
+LL | /     if {
+LL | |
+LL | |         let x = 3;
+LL | |         x == 3
+LL | |     } {
+   | |_____^
+   |
+   = note: `-D clippy::blocks-in-conditions` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::blocks_in_conditions)]`
+help: try
+   |
+LL ~     let res = {
+LL +
+LL +         let x = 3;
+LL +         x == 3
+LL ~     }; if res {
+   |
+
+error: omit braces around single expression condition
+  --> $DIR/blocks_in_conditions.rs:35:8
+   |
+LL |     if { true } { 6 } else { 10 }
+   |        ^^^^^^^^ help: try: `true`
+
+error: this boolean expression can be simplified
+  --> $DIR/blocks_in_conditions.rs:41:8
+   |
+LL |     if true && x == 3 { 6 } else { 10 }
+   |        ^^^^^^^^^^^^^^ help: try: `x == 3`
+   |
+   = note: `-D clippy::nonminimal-bool` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::nonminimal_bool)]`
+
+error: in a `match` scrutinee, avoid complex blocks or closures with blocks; instead, move the block or closure higher and bind it with a `let`
+  --> $DIR/blocks_in_conditions.rs:68:5
+   |
+LL | /     match {
+LL | |
+LL | |         let opt = Some(2);
+LL | |         opt
+LL | |     } {
+   | |_____^
+   |
+help: try
+   |
+LL ~     let res = {
+LL +
+LL +         let opt = Some(2);
+LL +         opt
+LL ~     }; match res {
+   |
+
+error: aborting due to 4 previous errors
+
diff --git a/tests/ui/blocks_in_conditions_closure.rs b/tests/ui/blocks_in_conditions_closure.rs
new file mode 100644
index 00000000000..db31e4ae1a9
--- /dev/null
+++ b/tests/ui/blocks_in_conditions_closure.rs
@@ -0,0 +1,89 @@
+#![warn(clippy::blocks_in_conditions)]
+#![allow(
+    unused,
+    clippy::let_and_return,
+    clippy::needless_if,
+    clippy::unnecessary_literal_unwrap
+)]
+
+fn predicate<F: FnOnce(T) -> bool, T>(pfn: F, val: T) -> bool {
+    pfn(val)
+}
+
+fn pred_test() {
+    let v = 3;
+    let sky = "blue";
+    // This is a sneaky case, where the block isn't directly in the condition,
+    // but is actually inside a closure that the condition is using.
+    // The same principle applies -- add some extra expressions to make sure
+    // linter isn't confused by them.
+    if v == 3
+        && sky == "blue"
+        && predicate(
+            |x| {
+                //~^ ERROR: in an `if` condition, avoid complex blocks or closures with blocks
+                //~| NOTE: `-D clippy::blocks-in-conditions` implied by `-D warnings`
+                let target = 3;
+                x == target
+            },
+            v,
+        )
+    {}
+
+    if predicate(
+        |x| {
+            //~^ ERROR: in an `if` condition, avoid complex blocks or closures with blocks; in
+            let target = 3;
+            x == target
+        },
+        v,
+    ) {}
+}
+
+fn closure_without_block() {
+    if predicate(|x| x == 3, 6) {}
+}
+
+fn macro_in_closure() {
+    let option = Some(true);
+
+    if option.unwrap_or_else(|| unimplemented!()) {
+        unimplemented!()
+    }
+}
+
+fn closure(_: impl FnMut()) -> bool {
+    true
+}
+
+fn function_with_empty_closure() {
+    if closure(|| {}) {}
+}
+
+// issue #11814
+fn match_with_pred() {
+    let v = 3;
+    match Some(predicate(
+        |x| {
+            //~^ ERROR: in a `match` scrutinee, avoid complex blocks or closures with blocks
+            let target = 3;
+            x == target
+        },
+        v,
+    )) {
+        Some(true) => 1,
+        Some(false) => 2,
+        None => 3,
+    };
+}
+
+#[rustfmt::skip]
+fn main() {
+    let mut range = 0..10;
+    range.all(|i| {i < 10} );
+
+    let v = vec![1, 2, 3];
+    if v.into_iter().any(|x| {x == 4}) {
+        println!("contains 4!");
+    }
+}
diff --git a/tests/ui/blocks_in_conditions_closure.stderr b/tests/ui/blocks_in_conditions_closure.stderr
new file mode 100644
index 00000000000..08b98f1b4fc
--- /dev/null
+++ b/tests/ui/blocks_in_conditions_closure.stderr
@@ -0,0 +1,39 @@
+error: in an `if` condition, avoid complex blocks or closures with blocks; instead, move the block or closure higher and bind it with a `let`
+  --> $DIR/blocks_in_conditions_closure.rs:23:17
+   |
+LL |               |x| {
+   |  _________________^
+LL | |
+LL | |
+LL | |                 let target = 3;
+LL | |                 x == target
+LL | |             },
+   | |_____________^
+   |
+   = note: `-D clippy::blocks-in-conditions` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::blocks_in_conditions)]`
+
+error: in an `if` condition, avoid complex blocks or closures with blocks; instead, move the block or closure higher and bind it with a `let`
+  --> $DIR/blocks_in_conditions_closure.rs:34:13
+   |
+LL |           |x| {
+   |  _____________^
+LL | |
+LL | |             let target = 3;
+LL | |             x == target
+LL | |         },
+   | |_________^
+
+error: in a `match` scrutinee, avoid complex blocks or closures with blocks; instead, move the block or closure higher and bind it with a `let`
+  --> $DIR/blocks_in_conditions_closure.rs:67:13
+   |
+LL |           |x| {
+   |  _____________^
+LL | |
+LL | |             let target = 3;
+LL | |             x == target
+LL | |         },
+   | |_________^
+
+error: aborting due to 3 previous errors
+
diff --git a/tests/ui/blocks_in_if_conditions.fixed b/tests/ui/blocks_in_if_conditions.fixed
deleted file mode 100644
index ad854faa59a..00000000000
--- a/tests/ui/blocks_in_if_conditions.fixed
+++ /dev/null
@@ -1,76 +0,0 @@
-#![warn(clippy::blocks_in_if_conditions)]
-#![allow(unused, clippy::let_and_return, clippy::needless_if)]
-#![warn(clippy::nonminimal_bool)]
-
-macro_rules! blocky {
-    () => {{ true }};
-}
-
-macro_rules! blocky_too {
-    () => {{
-        let r = true;
-        r
-    }};
-}
-
-fn macro_if() {
-    if blocky!() {}
-
-    if blocky_too!() {}
-}
-
-fn condition_has_block() -> i32 {
-    let res = {
-        let x = 3;
-        x == 3
-    }; if res {
-        6
-    } else {
-        10
-    }
-}
-
-fn condition_has_block_with_single_expression() -> i32 {
-    if true { 6 } else { 10 }
-}
-
-fn condition_is_normal() -> i32 {
-    let x = 3;
-    if x == 3 { 6 } else { 10 }
-}
-
-fn condition_is_unsafe_block() {
-    let a: i32 = 1;
-
-    // this should not warn because the condition is an unsafe block
-    if unsafe { 1u32 == std::mem::transmute(a) } {
-        println!("1u32 == a");
-    }
-}
-
-fn block_in_assert() {
-    let opt = Some(42);
-    assert!(
-        opt.as_ref()
-            .map(|val| {
-                let mut v = val * 2;
-                v -= 1;
-                v * 3
-            })
-            .is_some()
-    );
-}
-
-// issue #11814
-fn block_in_match_expr(num: i32) -> i32 {
-    let res = {
-        let opt = Some(2);
-        opt
-    }; match res {
-        Some(0) => 1,
-        Some(n) => num * 2,
-        None => 0,
-    }
-}
-
-fn main() {}
diff --git a/tests/ui/blocks_in_if_conditions.rs b/tests/ui/blocks_in_if_conditions.rs
deleted file mode 100644
index faeffa57f1c..00000000000
--- a/tests/ui/blocks_in_if_conditions.rs
+++ /dev/null
@@ -1,76 +0,0 @@
-#![warn(clippy::blocks_in_if_conditions)]
-#![allow(unused, clippy::let_and_return, clippy::needless_if)]
-#![warn(clippy::nonminimal_bool)]
-
-macro_rules! blocky {
-    () => {{ true }};
-}
-
-macro_rules! blocky_too {
-    () => {{
-        let r = true;
-        r
-    }};
-}
-
-fn macro_if() {
-    if blocky!() {}
-
-    if blocky_too!() {}
-}
-
-fn condition_has_block() -> i32 {
-    if {
-        let x = 3;
-        x == 3
-    } {
-        6
-    } else {
-        10
-    }
-}
-
-fn condition_has_block_with_single_expression() -> i32 {
-    if { true } { 6 } else { 10 }
-}
-
-fn condition_is_normal() -> i32 {
-    let x = 3;
-    if true && x == 3 { 6 } else { 10 }
-}
-
-fn condition_is_unsafe_block() {
-    let a: i32 = 1;
-
-    // this should not warn because the condition is an unsafe block
-    if unsafe { 1u32 == std::mem::transmute(a) } {
-        println!("1u32 == a");
-    }
-}
-
-fn block_in_assert() {
-    let opt = Some(42);
-    assert!(
-        opt.as_ref()
-            .map(|val| {
-                let mut v = val * 2;
-                v -= 1;
-                v * 3
-            })
-            .is_some()
-    );
-}
-
-// issue #11814
-fn block_in_match_expr(num: i32) -> i32 {
-    match {
-        let opt = Some(2);
-        opt
-    } {
-        Some(0) => 1,
-        Some(n) => num * 2,
-        None => 0,
-    }
-}
-
-fn main() {}
diff --git a/tests/ui/blocks_in_if_conditions.stderr b/tests/ui/blocks_in_if_conditions.stderr
deleted file mode 100644
index c564276f056..00000000000
--- a/tests/ui/blocks_in_if_conditions.stderr
+++ /dev/null
@@ -1,53 +0,0 @@
-error: in an `if` condition, avoid complex blocks or closures with blocks; instead, move the block or closure higher and bind it with a `let`
-  --> $DIR/blocks_in_if_conditions.rs:23:5
-   |
-LL | /     if {
-LL | |         let x = 3;
-LL | |         x == 3
-LL | |     } {
-   | |_____^
-   |
-   = note: `-D clippy::blocks-in-if-conditions` implied by `-D warnings`
-   = help: to override `-D warnings` add `#[allow(clippy::blocks_in_if_conditions)]`
-help: try
-   |
-LL ~     let res = {
-LL +         let x = 3;
-LL +         x == 3
-LL ~     }; if res {
-   |
-
-error: omit braces around single expression condition
-  --> $DIR/blocks_in_if_conditions.rs:34:8
-   |
-LL |     if { true } { 6 } else { 10 }
-   |        ^^^^^^^^ help: try: `true`
-
-error: this boolean expression can be simplified
-  --> $DIR/blocks_in_if_conditions.rs:39:8
-   |
-LL |     if true && x == 3 { 6 } else { 10 }
-   |        ^^^^^^^^^^^^^^ help: try: `x == 3`
-   |
-   = note: `-D clippy::nonminimal-bool` implied by `-D warnings`
-   = help: to override `-D warnings` add `#[allow(clippy::nonminimal_bool)]`
-
-error: in an `if` condition, avoid complex blocks or closures with blocks; instead, move the block or closure higher and bind it with a `let`
-  --> $DIR/blocks_in_if_conditions.rs:66:5
-   |
-LL | /     match {
-LL | |         let opt = Some(2);
-LL | |         opt
-LL | |     } {
-   | |_____^
-   |
-help: try
-   |
-LL ~     let res = {
-LL +         let opt = Some(2);
-LL +         opt
-LL ~     }; match res {
-   |
-
-error: aborting due to 4 previous errors
-
diff --git a/tests/ui/blocks_in_if_conditions_closure.rs b/tests/ui/blocks_in_if_conditions_closure.rs
deleted file mode 100644
index 539f2df15bd..00000000000
--- a/tests/ui/blocks_in_if_conditions_closure.rs
+++ /dev/null
@@ -1,72 +0,0 @@
-#![warn(clippy::blocks_in_if_conditions)]
-#![allow(
-    unused,
-    clippy::let_and_return,
-    clippy::needless_if,
-    clippy::unnecessary_literal_unwrap
-)]
-
-fn predicate<F: FnOnce(T) -> bool, T>(pfn: F, val: T) -> bool {
-    pfn(val)
-}
-
-fn pred_test() {
-    let v = 3;
-    let sky = "blue";
-    // This is a sneaky case, where the block isn't directly in the condition,
-    // but is actually inside a closure that the condition is using.
-    // The same principle applies -- add some extra expressions to make sure
-    // linter isn't confused by them.
-    if v == 3
-        && sky == "blue"
-        && predicate(
-            |x| {
-                //~^ ERROR: in an `if` condition, avoid complex blocks or closures with blocks
-                //~| NOTE: `-D clippy::blocks-in-if-conditions` implied by `-D warnings`
-                let target = 3;
-                x == target
-            },
-            v,
-        )
-    {}
-
-    if predicate(
-        |x| {
-            //~^ ERROR: in an `if` condition, avoid complex blocks or closures with blocks; in
-            let target = 3;
-            x == target
-        },
-        v,
-    ) {}
-}
-
-fn closure_without_block() {
-    if predicate(|x| x == 3, 6) {}
-}
-
-fn macro_in_closure() {
-    let option = Some(true);
-
-    if option.unwrap_or_else(|| unimplemented!()) {
-        unimplemented!()
-    }
-}
-
-fn closure(_: impl FnMut()) -> bool {
-    true
-}
-
-fn function_with_empty_closure() {
-    if closure(|| {}) {}
-}
-
-#[rustfmt::skip]
-fn main() {
-    let mut range = 0..10;
-    range.all(|i| {i < 10} );
-
-    let v = vec![1, 2, 3];
-    if v.into_iter().any(|x| {x == 4}) {
-        println!("contains 4!");
-    }
-}
diff --git a/tests/ui/blocks_in_if_conditions_closure.stderr b/tests/ui/blocks_in_if_conditions_closure.stderr
deleted file mode 100644
index ab68997d477..00000000000
--- a/tests/ui/blocks_in_if_conditions_closure.stderr
+++ /dev/null
@@ -1,28 +0,0 @@
-error: in an `if` condition, avoid complex blocks or closures with blocks; instead, move the block or closure higher and bind it with a `let`
-  --> $DIR/blocks_in_if_conditions_closure.rs:23:17
-   |
-LL |               |x| {
-   |  _________________^
-LL | |
-LL | |
-LL | |                 let target = 3;
-LL | |                 x == target
-LL | |             },
-   | |_____________^
-   |
-   = note: `-D clippy::blocks-in-if-conditions` implied by `-D warnings`
-   = help: to override `-D warnings` add `#[allow(clippy::blocks_in_if_conditions)]`
-
-error: in an `if` condition, avoid complex blocks or closures with blocks; instead, move the block or closure higher and bind it with a `let`
-  --> $DIR/blocks_in_if_conditions_closure.rs:34:13
-   |
-LL |           |x| {
-   |  _____________^
-LL | |
-LL | |             let target = 3;
-LL | |             x == target
-LL | |         },
-   | |_________^
-
-error: aborting due to 2 previous errors
-
diff --git a/tests/ui/manual_filter.fixed b/tests/ui/manual_filter.fixed
index c1bc4aae92e..a0fb0e32d60 100644
--- a/tests/ui/manual_filter.fixed
+++ b/tests/ui/manual_filter.fixed
@@ -40,7 +40,7 @@ fn main() {
         };
     }
 
-    #[allow(clippy::blocks_in_if_conditions)]
+    #[allow(clippy::blocks_in_conditions)]
     Some(11).filter(|&x| {
                 println!("foo");
                 x > 10 && x < 100
diff --git a/tests/ui/manual_filter.rs b/tests/ui/manual_filter.rs
index ee44909f37e..0ac6cbefc4e 100644
--- a/tests/ui/manual_filter.rs
+++ b/tests/ui/manual_filter.rs
@@ -135,7 +135,7 @@ fn main() {
         };
     }
 
-    #[allow(clippy::blocks_in_if_conditions)]
+    #[allow(clippy::blocks_in_conditions)]
     match Some(11) {
         // Lint, statement is preserved by `.filter`
         Some(x) => {
diff --git a/tests/ui/needless_if.fixed b/tests/ui/needless_if.fixed
index be35dcddbe6..1086ae2c984 100644
--- a/tests/ui/needless_if.fixed
+++ b/tests/ui/needless_if.fixed
@@ -1,7 +1,7 @@
 //@aux-build:proc_macros.rs
 #![feature(let_chains)]
 #![allow(
-    clippy::blocks_in_if_conditions,
+    clippy::blocks_in_conditions,
     clippy::if_same_then_else,
     clippy::ifs_same_cond,
     clippy::let_unit_value,
diff --git a/tests/ui/needless_if.rs b/tests/ui/needless_if.rs
index e2ad17e69a8..131cceaf712 100644
--- a/tests/ui/needless_if.rs
+++ b/tests/ui/needless_if.rs
@@ -1,7 +1,7 @@
 //@aux-build:proc_macros.rs
 #![feature(let_chains)]
 #![allow(
-    clippy::blocks_in_if_conditions,
+    clippy::blocks_in_conditions,
     clippy::if_same_then_else,
     clippy::ifs_same_cond,
     clippy::let_unit_value,
diff --git a/tests/ui/needless_late_init.fixed b/tests/ui/needless_late_init.fixed
index 891b2b01437..6db87049044 100644
--- a/tests/ui/needless_late_init.fixed
+++ b/tests/ui/needless_late_init.fixed
@@ -3,7 +3,7 @@
 #![allow(unused)]
 #![allow(
     clippy::assign_op_pattern,
-    clippy::blocks_in_if_conditions,
+    clippy::blocks_in_conditions,
     clippy::let_and_return,
     clippy::let_unit_value,
     clippy::nonminimal_bool,
diff --git a/tests/ui/needless_late_init.rs b/tests/ui/needless_late_init.rs
index 55399511639..c1e86212a08 100644
--- a/tests/ui/needless_late_init.rs
+++ b/tests/ui/needless_late_init.rs
@@ -3,7 +3,7 @@
 #![allow(unused)]
 #![allow(
     clippy::assign_op_pattern,
-    clippy::blocks_in_if_conditions,
+    clippy::blocks_in_conditions,
     clippy::let_and_return,
     clippy::let_unit_value,
     clippy::nonminimal_bool,
diff --git a/tests/ui/rename.fixed b/tests/ui/rename.fixed
index 4df9be2c21d..7ad35ddc3a0 100644
--- a/tests/ui/rename.fixed
+++ b/tests/ui/rename.fixed
@@ -4,7 +4,7 @@
 
 #![allow(clippy::almost_complete_range)]
 #![allow(clippy::disallowed_names)]
-#![allow(clippy::blocks_in_if_conditions)]
+#![allow(clippy::blocks_in_conditions)]
 #![allow(clippy::box_collection)]
 #![allow(clippy::redundant_static_lifetimes)]
 #![allow(clippy::cognitive_complexity)]
@@ -53,8 +53,9 @@
 #![allow(unused_labels)]
 #![warn(clippy::almost_complete_range)]
 #![warn(clippy::disallowed_names)]
-#![warn(clippy::blocks_in_if_conditions)]
-#![warn(clippy::blocks_in_if_conditions)]
+#![warn(clippy::blocks_in_conditions)]
+#![warn(clippy::blocks_in_conditions)]
+#![warn(clippy::blocks_in_conditions)]
 #![warn(clippy::box_collection)]
 #![warn(clippy::redundant_static_lifetimes)]
 #![warn(clippy::cognitive_complexity)]
diff --git a/tests/ui/rename.rs b/tests/ui/rename.rs
index 940e60068e7..336505ede6f 100644
--- a/tests/ui/rename.rs
+++ b/tests/ui/rename.rs
@@ -4,7 +4,7 @@
 
 #![allow(clippy::almost_complete_range)]
 #![allow(clippy::disallowed_names)]
-#![allow(clippy::blocks_in_if_conditions)]
+#![allow(clippy::blocks_in_conditions)]
 #![allow(clippy::box_collection)]
 #![allow(clippy::redundant_static_lifetimes)]
 #![allow(clippy::cognitive_complexity)]
@@ -55,6 +55,7 @@
 #![warn(clippy::blacklisted_name)]
 #![warn(clippy::block_in_if_condition_expr)]
 #![warn(clippy::block_in_if_condition_stmt)]
+#![warn(clippy::blocks_in_if_conditions)]
 #![warn(clippy::box_vec)]
 #![warn(clippy::const_static_lifetime)]
 #![warn(clippy::cyclomatic_complexity)]
diff --git a/tests/ui/rename.stderr b/tests/ui/rename.stderr
index 30824e154b8..966fa7418c1 100644
--- a/tests/ui/rename.stderr
+++ b/tests/ui/rename.stderr
@@ -13,329 +13,335 @@ error: lint `clippy::blacklisted_name` has been renamed to `clippy::disallowed_n
 LL | #![warn(clippy::blacklisted_name)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::disallowed_names`
 
-error: lint `clippy::block_in_if_condition_expr` has been renamed to `clippy::blocks_in_if_conditions`
+error: lint `clippy::block_in_if_condition_expr` has been renamed to `clippy::blocks_in_conditions`
   --> $DIR/rename.rs:56:9
    |
 LL | #![warn(clippy::block_in_if_condition_expr)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::blocks_in_if_conditions`
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::blocks_in_conditions`
 
-error: lint `clippy::block_in_if_condition_stmt` has been renamed to `clippy::blocks_in_if_conditions`
+error: lint `clippy::block_in_if_condition_stmt` has been renamed to `clippy::blocks_in_conditions`
   --> $DIR/rename.rs:57:9
    |
 LL | #![warn(clippy::block_in_if_condition_stmt)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::blocks_in_if_conditions`
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::blocks_in_conditions`
 
-error: lint `clippy::box_vec` has been renamed to `clippy::box_collection`
+error: lint `clippy::blocks_in_if_conditions` has been renamed to `clippy::blocks_in_conditions`
   --> $DIR/rename.rs:58:9
    |
+LL | #![warn(clippy::blocks_in_if_conditions)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::blocks_in_conditions`
+
+error: lint `clippy::box_vec` has been renamed to `clippy::box_collection`
+  --> $DIR/rename.rs:59:9
+   |
 LL | #![warn(clippy::box_vec)]
    |         ^^^^^^^^^^^^^^^ help: use the new name: `clippy::box_collection`
 
 error: lint `clippy::const_static_lifetime` has been renamed to `clippy::redundant_static_lifetimes`
-  --> $DIR/rename.rs:59:9
+  --> $DIR/rename.rs:60:9
    |
 LL | #![warn(clippy::const_static_lifetime)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::redundant_static_lifetimes`
 
 error: lint `clippy::cyclomatic_complexity` has been renamed to `clippy::cognitive_complexity`
-  --> $DIR/rename.rs:60:9
+  --> $DIR/rename.rs:61:9
    |
 LL | #![warn(clippy::cyclomatic_complexity)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::cognitive_complexity`
 
 error: lint `clippy::derive_hash_xor_eq` has been renamed to `clippy::derived_hash_with_manual_eq`
-  --> $DIR/rename.rs:61:9
+  --> $DIR/rename.rs:62:9
    |
 LL | #![warn(clippy::derive_hash_xor_eq)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::derived_hash_with_manual_eq`
 
 error: lint `clippy::disallowed_method` has been renamed to `clippy::disallowed_methods`
-  --> $DIR/rename.rs:62:9
+  --> $DIR/rename.rs:63:9
    |
 LL | #![warn(clippy::disallowed_method)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::disallowed_methods`
 
 error: lint `clippy::disallowed_type` has been renamed to `clippy::disallowed_types`
-  --> $DIR/rename.rs:63:9
+  --> $DIR/rename.rs:64:9
    |
 LL | #![warn(clippy::disallowed_type)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::disallowed_types`
 
 error: lint `clippy::eval_order_dependence` has been renamed to `clippy::mixed_read_write_in_expression`
-  --> $DIR/rename.rs:64:9
+  --> $DIR/rename.rs:65:9
    |
 LL | #![warn(clippy::eval_order_dependence)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::mixed_read_write_in_expression`
 
 error: lint `clippy::identity_conversion` has been renamed to `clippy::useless_conversion`
-  --> $DIR/rename.rs:65:9
+  --> $DIR/rename.rs:66:9
    |
 LL | #![warn(clippy::identity_conversion)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::useless_conversion`
 
 error: lint `clippy::if_let_some_result` has been renamed to `clippy::match_result_ok`
-  --> $DIR/rename.rs:66:9
+  --> $DIR/rename.rs:67:9
    |
 LL | #![warn(clippy::if_let_some_result)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::match_result_ok`
 
 error: lint `clippy::incorrect_clone_impl_on_copy_type` has been renamed to `clippy::non_canonical_clone_impl`
-  --> $DIR/rename.rs:67:9
+  --> $DIR/rename.rs:68:9
    |
 LL | #![warn(clippy::incorrect_clone_impl_on_copy_type)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::non_canonical_clone_impl`
 
 error: lint `clippy::incorrect_partial_ord_impl_on_ord_type` has been renamed to `clippy::non_canonical_partial_ord_impl`
-  --> $DIR/rename.rs:68:9
+  --> $DIR/rename.rs:69:9
    |
 LL | #![warn(clippy::incorrect_partial_ord_impl_on_ord_type)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::non_canonical_partial_ord_impl`
 
 error: lint `clippy::integer_arithmetic` has been renamed to `clippy::arithmetic_side_effects`
-  --> $DIR/rename.rs:69:9
+  --> $DIR/rename.rs:70:9
    |
 LL | #![warn(clippy::integer_arithmetic)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::arithmetic_side_effects`
 
 error: lint `clippy::logic_bug` has been renamed to `clippy::overly_complex_bool_expr`
-  --> $DIR/rename.rs:70:9
+  --> $DIR/rename.rs:71:9
    |
 LL | #![warn(clippy::logic_bug)]
    |         ^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::overly_complex_bool_expr`
 
 error: lint `clippy::new_without_default_derive` has been renamed to `clippy::new_without_default`
-  --> $DIR/rename.rs:71:9
+  --> $DIR/rename.rs:72:9
    |
 LL | #![warn(clippy::new_without_default_derive)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::new_without_default`
 
 error: lint `clippy::option_and_then_some` has been renamed to `clippy::bind_instead_of_map`
-  --> $DIR/rename.rs:72:9
+  --> $DIR/rename.rs:73:9
    |
 LL | #![warn(clippy::option_and_then_some)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::bind_instead_of_map`
 
 error: lint `clippy::option_expect_used` has been renamed to `clippy::expect_used`
-  --> $DIR/rename.rs:73:9
+  --> $DIR/rename.rs:74:9
    |
 LL | #![warn(clippy::option_expect_used)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::expect_used`
 
 error: lint `clippy::option_map_unwrap_or` has been renamed to `clippy::map_unwrap_or`
-  --> $DIR/rename.rs:74:9
+  --> $DIR/rename.rs:75:9
    |
 LL | #![warn(clippy::option_map_unwrap_or)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::map_unwrap_or`
 
 error: lint `clippy::option_map_unwrap_or_else` has been renamed to `clippy::map_unwrap_or`
-  --> $DIR/rename.rs:75:9
+  --> $DIR/rename.rs:76:9
    |
 LL | #![warn(clippy::option_map_unwrap_or_else)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::map_unwrap_or`
 
 error: lint `clippy::option_unwrap_used` has been renamed to `clippy::unwrap_used`
-  --> $DIR/rename.rs:76:9
+  --> $DIR/rename.rs:77:9
    |
 LL | #![warn(clippy::option_unwrap_used)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::unwrap_used`
 
 error: lint `clippy::ref_in_deref` has been renamed to `clippy::needless_borrow`
-  --> $DIR/rename.rs:77:9
+  --> $DIR/rename.rs:78:9
    |
 LL | #![warn(clippy::ref_in_deref)]
    |         ^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::needless_borrow`
 
 error: lint `clippy::result_expect_used` has been renamed to `clippy::expect_used`
-  --> $DIR/rename.rs:78:9
+  --> $DIR/rename.rs:79:9
    |
 LL | #![warn(clippy::result_expect_used)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::expect_used`
 
 error: lint `clippy::result_map_unwrap_or_else` has been renamed to `clippy::map_unwrap_or`
-  --> $DIR/rename.rs:79:9
+  --> $DIR/rename.rs:80:9
    |
 LL | #![warn(clippy::result_map_unwrap_or_else)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::map_unwrap_or`
 
 error: lint `clippy::result_unwrap_used` has been renamed to `clippy::unwrap_used`
-  --> $DIR/rename.rs:80:9
+  --> $DIR/rename.rs:81:9
    |
 LL | #![warn(clippy::result_unwrap_used)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::unwrap_used`
 
 error: lint `clippy::single_char_push_str` has been renamed to `clippy::single_char_add_str`
-  --> $DIR/rename.rs:81:9
+  --> $DIR/rename.rs:82:9
    |
 LL | #![warn(clippy::single_char_push_str)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::single_char_add_str`
 
 error: lint `clippy::stutter` has been renamed to `clippy::module_name_repetitions`
-  --> $DIR/rename.rs:82:9
+  --> $DIR/rename.rs:83:9
    |
 LL | #![warn(clippy::stutter)]
    |         ^^^^^^^^^^^^^^^ help: use the new name: `clippy::module_name_repetitions`
 
 error: lint `clippy::to_string_in_display` has been renamed to `clippy::recursive_format_impl`
-  --> $DIR/rename.rs:83:9
+  --> $DIR/rename.rs:84:9
    |
 LL | #![warn(clippy::to_string_in_display)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::recursive_format_impl`
 
 error: lint `clippy::unwrap_or_else_default` has been renamed to `clippy::unwrap_or_default`
-  --> $DIR/rename.rs:84:9
+  --> $DIR/rename.rs:85:9
    |
 LL | #![warn(clippy::unwrap_or_else_default)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::unwrap_or_default`
 
 error: lint `clippy::zero_width_space` has been renamed to `clippy::invisible_characters`
-  --> $DIR/rename.rs:85:9
+  --> $DIR/rename.rs:86:9
    |
 LL | #![warn(clippy::zero_width_space)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::invisible_characters`
 
 error: lint `clippy::cast_ref_to_mut` has been renamed to `invalid_reference_casting`
-  --> $DIR/rename.rs:86:9
+  --> $DIR/rename.rs:87:9
    |
 LL | #![warn(clippy::cast_ref_to_mut)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `invalid_reference_casting`
 
 error: lint `clippy::clone_double_ref` has been renamed to `suspicious_double_ref_op`
-  --> $DIR/rename.rs:87:9
+  --> $DIR/rename.rs:88:9
    |
 LL | #![warn(clippy::clone_double_ref)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `suspicious_double_ref_op`
 
 error: lint `clippy::cmp_nan` has been renamed to `invalid_nan_comparisons`
-  --> $DIR/rename.rs:88:9
+  --> $DIR/rename.rs:89:9
    |
 LL | #![warn(clippy::cmp_nan)]
    |         ^^^^^^^^^^^^^^^ help: use the new name: `invalid_nan_comparisons`
 
 error: lint `clippy::drop_bounds` has been renamed to `drop_bounds`
-  --> $DIR/rename.rs:89:9
+  --> $DIR/rename.rs:90:9
    |
 LL | #![warn(clippy::drop_bounds)]
    |         ^^^^^^^^^^^^^^^^^^^ help: use the new name: `drop_bounds`
 
 error: lint `clippy::drop_copy` has been renamed to `dropping_copy_types`
-  --> $DIR/rename.rs:90:9
+  --> $DIR/rename.rs:91:9
    |
 LL | #![warn(clippy::drop_copy)]
    |         ^^^^^^^^^^^^^^^^^ help: use the new name: `dropping_copy_types`
 
 error: lint `clippy::drop_ref` has been renamed to `dropping_references`
-  --> $DIR/rename.rs:91:9
+  --> $DIR/rename.rs:92:9
    |
 LL | #![warn(clippy::drop_ref)]
    |         ^^^^^^^^^^^^^^^^ help: use the new name: `dropping_references`
 
 error: lint `clippy::fn_null_check` has been renamed to `useless_ptr_null_checks`
-  --> $DIR/rename.rs:92:9
+  --> $DIR/rename.rs:93:9
    |
 LL | #![warn(clippy::fn_null_check)]
    |         ^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `useless_ptr_null_checks`
 
 error: lint `clippy::for_loop_over_option` has been renamed to `for_loops_over_fallibles`
-  --> $DIR/rename.rs:93:9
+  --> $DIR/rename.rs:94:9
    |
 LL | #![warn(clippy::for_loop_over_option)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `for_loops_over_fallibles`
 
 error: lint `clippy::for_loop_over_result` has been renamed to `for_loops_over_fallibles`
-  --> $DIR/rename.rs:94:9
+  --> $DIR/rename.rs:95:9
    |
 LL | #![warn(clippy::for_loop_over_result)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `for_loops_over_fallibles`
 
 error: lint `clippy::for_loops_over_fallibles` has been renamed to `for_loops_over_fallibles`
-  --> $DIR/rename.rs:95:9
+  --> $DIR/rename.rs:96:9
    |
 LL | #![warn(clippy::for_loops_over_fallibles)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `for_loops_over_fallibles`
 
 error: lint `clippy::forget_copy` has been renamed to `forgetting_copy_types`
-  --> $DIR/rename.rs:96:9
+  --> $DIR/rename.rs:97:9
    |
 LL | #![warn(clippy::forget_copy)]
    |         ^^^^^^^^^^^^^^^^^^^ help: use the new name: `forgetting_copy_types`
 
 error: lint `clippy::forget_ref` has been renamed to `forgetting_references`
-  --> $DIR/rename.rs:97:9
+  --> $DIR/rename.rs:98:9
    |
 LL | #![warn(clippy::forget_ref)]
    |         ^^^^^^^^^^^^^^^^^^ help: use the new name: `forgetting_references`
 
 error: lint `clippy::into_iter_on_array` has been renamed to `array_into_iter`
-  --> $DIR/rename.rs:98:9
+  --> $DIR/rename.rs:99:9
    |
 LL | #![warn(clippy::into_iter_on_array)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `array_into_iter`
 
 error: lint `clippy::invalid_atomic_ordering` has been renamed to `invalid_atomic_ordering`
-  --> $DIR/rename.rs:99:9
+  --> $DIR/rename.rs:100:9
    |
 LL | #![warn(clippy::invalid_atomic_ordering)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `invalid_atomic_ordering`
 
 error: lint `clippy::invalid_ref` has been renamed to `invalid_value`
-  --> $DIR/rename.rs:100:9
+  --> $DIR/rename.rs:101:9
    |
 LL | #![warn(clippy::invalid_ref)]
    |         ^^^^^^^^^^^^^^^^^^^ help: use the new name: `invalid_value`
 
 error: lint `clippy::invalid_utf8_in_unchecked` has been renamed to `invalid_from_utf8_unchecked`
-  --> $DIR/rename.rs:101:9
+  --> $DIR/rename.rs:102:9
    |
 LL | #![warn(clippy::invalid_utf8_in_unchecked)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `invalid_from_utf8_unchecked`
 
 error: lint `clippy::let_underscore_drop` has been renamed to `let_underscore_drop`
-  --> $DIR/rename.rs:102:9
+  --> $DIR/rename.rs:103:9
    |
 LL | #![warn(clippy::let_underscore_drop)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `let_underscore_drop`
 
 error: lint `clippy::mem_discriminant_non_enum` has been renamed to `enum_intrinsics_non_enums`
-  --> $DIR/rename.rs:103:9
+  --> $DIR/rename.rs:104:9
    |
 LL | #![warn(clippy::mem_discriminant_non_enum)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `enum_intrinsics_non_enums`
 
 error: lint `clippy::panic_params` has been renamed to `non_fmt_panics`
-  --> $DIR/rename.rs:104:9
+  --> $DIR/rename.rs:105:9
    |
 LL | #![warn(clippy::panic_params)]
    |         ^^^^^^^^^^^^^^^^^^^^ help: use the new name: `non_fmt_panics`
 
 error: lint `clippy::positional_named_format_parameters` has been renamed to `named_arguments_used_positionally`
-  --> $DIR/rename.rs:105:9
+  --> $DIR/rename.rs:106:9
    |
 LL | #![warn(clippy::positional_named_format_parameters)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `named_arguments_used_positionally`
 
 error: lint `clippy::temporary_cstring_as_ptr` has been renamed to `temporary_cstring_as_ptr`
-  --> $DIR/rename.rs:106:9
+  --> $DIR/rename.rs:107:9
    |
 LL | #![warn(clippy::temporary_cstring_as_ptr)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `temporary_cstring_as_ptr`
 
 error: lint `clippy::undropped_manually_drops` has been renamed to `undropped_manually_drops`
-  --> $DIR/rename.rs:107:9
+  --> $DIR/rename.rs:108:9
    |
 LL | #![warn(clippy::undropped_manually_drops)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `undropped_manually_drops`
 
 error: lint `clippy::unknown_clippy_lints` has been renamed to `unknown_lints`
-  --> $DIR/rename.rs:108:9
+  --> $DIR/rename.rs:109:9
    |
 LL | #![warn(clippy::unknown_clippy_lints)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `unknown_lints`
 
 error: lint `clippy::unused_label` has been renamed to `unused_labels`
-  --> $DIR/rename.rs:109:9
+  --> $DIR/rename.rs:110:9
    |
 LL | #![warn(clippy::unused_label)]
    |         ^^^^^^^^^^^^^^^^^^^^ help: use the new name: `unused_labels`
 
-error: aborting due to 56 previous errors
+error: aborting due to 57 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 2cda044f8ca27bdbdad32db7fb22dd61a2e014f9 Mon Sep 17 00:00:00 2001
From: clubby789 <jamie@hill-daniel.co.uk>
Date: Thu, 30 Nov 2023 15:48:17 +0000
Subject: Allow `allow`ing `upper_case_acronyms` on enum variants

---
 clippy_lints/src/upper_case_acronyms.rs | 31 ++++++++++++++++++-------------
 tests/ui/upper_case_acronyms.fixed      |  8 ++++++++
 tests/ui/upper_case_acronyms.rs         |  8 ++++++++
 tests/ui/upper_case_acronyms.stderr     |  8 +++++++-
 4 files changed, 41 insertions(+), 14 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/upper_case_acronyms.rs b/clippy_lints/src/upper_case_acronyms.rs
index 0d559821386..d2a1d42f279 100644
--- a/clippy_lints/src/upper_case_acronyms.rs
+++ b/clippy_lints/src/upper_case_acronyms.rs
@@ -1,7 +1,7 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::diagnostics::span_lint_hir_and_then;
 use itertools::Itertools;
 use rustc_errors::Applicability;
-use rustc_hir::{Item, ItemKind};
+use rustc_hir::{HirId, Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::impl_lint_pass;
@@ -77,7 +77,7 @@ fn correct_ident(ident: &str) -> String {
     ident
 }
 
-fn check_ident(cx: &LateContext<'_>, ident: &Ident, be_aggressive: bool) {
+fn check_ident(cx: &LateContext<'_>, ident: &Ident, hir_id: HirId, be_aggressive: bool) {
     let span = ident.span;
     let ident = ident.as_str();
     let corrected = correct_ident(ident);
@@ -89,14 +89,20 @@ fn check_ident(cx: &LateContext<'_>, ident: &Ident, be_aggressive: bool) {
     // upper-case-acronyms-aggressive config option enabled
     || (be_aggressive && ident != corrected)
     {
-        span_lint_and_sugg(
+        span_lint_hir_and_then(
             cx,
             UPPER_CASE_ACRONYMS,
+            hir_id,
             span,
             &format!("name `{ident}` contains a capitalized acronym"),
-            "consider making the acronym lowercase, except the initial letter",
-            corrected,
-            Applicability::MaybeIncorrect,
+            |diag| {
+                diag.span_suggestion(
+                    span,
+                    "consider making the acronym lowercase, except the initial letter",
+                    corrected,
+                    Applicability::MaybeIncorrect,
+                );
+            },
         );
     }
 }
@@ -111,16 +117,15 @@ impl LateLintPass<'_> for UpperCaseAcronyms {
         }
         match it.kind {
             ItemKind::TyAlias(..) | ItemKind::Struct(..) | ItemKind::Trait(..) => {
-                check_ident(cx, &it.ident, self.upper_case_acronyms_aggressive);
+                check_ident(cx, &it.ident, it.hir_id(), self.upper_case_acronyms_aggressive);
             },
             ItemKind::Enum(ref enumdef, _) => {
-                check_ident(cx, &it.ident, self.upper_case_acronyms_aggressive);
+                check_ident(cx, &it.ident, it.hir_id(), self.upper_case_acronyms_aggressive);
                 // check enum variants separately because again we only want to lint on private enums and
                 // the fn check_variant does not know about the vis of the enum of its variants
-                enumdef
-                    .variants
-                    .iter()
-                    .for_each(|variant| check_ident(cx, &variant.ident, self.upper_case_acronyms_aggressive));
+                enumdef.variants.iter().for_each(|variant| {
+                    check_ident(cx, &variant.ident, variant.hir_id, self.upper_case_acronyms_aggressive);
+                });
             },
             _ => {},
         }
diff --git a/tests/ui/upper_case_acronyms.fixed b/tests/ui/upper_case_acronyms.fixed
index 460567b097e..a8023ed00d2 100644
--- a/tests/ui/upper_case_acronyms.fixed
+++ b/tests/ui/upper_case_acronyms.fixed
@@ -59,4 +59,12 @@ enum Yaml {
     Str(String),
 }
 
+// test for issue #7708
+enum AllowOnField {
+    Disallow,
+    //~^ ERROR: name `DISALLOW` contains a capitalized acronym
+    #[allow(clippy::upper_case_acronyms)]
+    ALLOW,
+}
+
 fn main() {}
diff --git a/tests/ui/upper_case_acronyms.rs b/tests/ui/upper_case_acronyms.rs
index 6a20aee62dc..c4711b87ec3 100644
--- a/tests/ui/upper_case_acronyms.rs
+++ b/tests/ui/upper_case_acronyms.rs
@@ -59,4 +59,12 @@ enum YAML {
     Str(String),
 }
 
+// test for issue #7708
+enum AllowOnField {
+    DISALLOW,
+    //~^ ERROR: name `DISALLOW` contains a capitalized acronym
+    #[allow(clippy::upper_case_acronyms)]
+    ALLOW,
+}
+
 fn main() {}
diff --git a/tests/ui/upper_case_acronyms.stderr b/tests/ui/upper_case_acronyms.stderr
index c57b325e91a..009c53c725b 100644
--- a/tests/ui/upper_case_acronyms.stderr
+++ b/tests/ui/upper_case_acronyms.stderr
@@ -67,5 +67,11 @@ error: name `YAML` contains a capitalized acronym
 LL | enum YAML {
    |      ^^^^ help: consider making the acronym lowercase, except the initial letter: `Yaml`
 
-error: aborting due to 11 previous errors
+error: name `DISALLOW` contains a capitalized acronym
+  --> $DIR/upper_case_acronyms.rs:64:5
+   |
+LL |     DISALLOW,
+   |     ^^^^^^^^ help: consider making the acronym lowercase, except the initial letter: `Disallow`
+
+error: aborting due to 12 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 6275e77e6a273144558ce06c862821d330958952 Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Thu, 30 Nov 2023 17:45:04 +0100
Subject: Do not check twice whether `qpath` is a `QPath::TypeRelative` variant

---
 clippy_lints/src/manual_string_new.rs | 22 ++++++++++------------
 1 file changed, 10 insertions(+), 12 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_string_new.rs b/clippy_lints/src/manual_string_new.rs
index 737c70496c2..781db4b97f0 100644
--- a/clippy_lints/src/manual_string_new.rs
+++ b/clippy_lints/src/manual_string_new.rs
@@ -108,18 +108,16 @@ fn parse_call(cx: &LateContext<'_>, span: Span, func: &Expr<'_>, args: &[Expr<'_
 
     let arg_kind = &args[0].kind;
     if let ExprKind::Path(qpath) = &func.kind {
-        if let QPath::TypeRelative(_, _) = qpath {
-            // String::from(...) or String::try_from(...)
-            if let QPath::TypeRelative(ty, path_seg) = qpath
-                && [sym::from, sym::try_from].contains(&path_seg.ident.name)
-                && let TyKind::Path(qpath) = &ty.kind
-                && let QPath::Resolved(_, path) = qpath
-                && let [path_seg] = path.segments
-                && path_seg.ident.name == sym::String
-                && is_expr_kind_empty_str(arg_kind)
-            {
-                warn_then_suggest(cx, span);
-            }
+        // String::from(...) or String::try_from(...)
+        if let QPath::TypeRelative(ty, path_seg) = qpath
+            && [sym::from, sym::try_from].contains(&path_seg.ident.name)
+            && let TyKind::Path(qpath) = &ty.kind
+            && let QPath::Resolved(_, path) = qpath
+            && let [path_seg] = path.segments
+            && path_seg.ident.name == sym::String
+            && is_expr_kind_empty_str(arg_kind)
+        {
+            warn_then_suggest(cx, span);
         } else if let QPath::Resolved(_, path) = qpath {
             // From::from(...) or TryFrom::try_from(...)
             if let [path_seg1, path_seg2] = path.segments
-- 
cgit 1.4.1-3-g733a5


From 512f302fd29fbc4bc4b920b4b22b1d1c49cc3917 Mon Sep 17 00:00:00 2001
From: Martin Nordholts <martin.nordholts@codetale.se>
Date: Fri, 1 Dec 2023 08:15:55 +0100
Subject: needless_borrows_for_generic_args: Handle when field operand impl
 Drop

Before this fix, the lint had a false positive, namely when a reference
was taken to a field when the field operand implements a custom Drop.
The compiler will refuse to partially move a type that implements Drop,
because that would put the operand in a weird state. See added
regression test.
---
 clippy_lints/src/needless_borrows_for_generic_args.rs | 12 ++++++++++--
 tests/ui/needless_borrows_for_generic_args.fixed      | 15 +++++++++++++++
 tests/ui/needless_borrows_for_generic_args.rs         | 15 +++++++++++++++
 3 files changed, 40 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/needless_borrows_for_generic_args.rs b/clippy_lints/src/needless_borrows_for_generic_args.rs
index 85166b0dd95..a32bca3d038 100644
--- a/clippy_lints/src/needless_borrows_for_generic_args.rs
+++ b/clippy_lints/src/needless_borrows_for_generic_args.rs
@@ -2,7 +2,7 @@ use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::mir::{enclosing_mir, expr_local, local_assignments, used_exactly_once, PossibleBorrowerMap};
 use clippy_utils::source::snippet_with_context;
-use clippy_utils::ty::is_copy;
+use clippy_utils::ty::{implements_trait, is_copy};
 use clippy_utils::{expr_use_ctxt, peel_n_hir_expr_refs, DefinedTy, ExprUseNode};
 use rustc_errors::Applicability;
 use rustc_hir::def::{DefKind, Res};
@@ -169,6 +169,7 @@ fn needless_borrow_count<'tcx>(
 ) -> usize {
     let destruct_trait_def_id = cx.tcx.lang_items().destruct_trait();
     let sized_trait_def_id = cx.tcx.lang_items().sized_trait();
+    let drop_trait_def_id = cx.tcx.lang_items().drop_trait();
 
     let fn_sig = cx.tcx.fn_sig(fn_id).instantiate_identity().skip_binder();
     let predicates = cx.tcx.param_env(fn_id).caller_bounds();
@@ -223,7 +224,14 @@ fn needless_borrow_count<'tcx>(
     // elements are modified each time `check_referent` is called.
     let mut args_with_referent_ty = callee_args.to_vec();
 
-    let mut check_reference_and_referent = |reference, referent| {
+    let mut check_reference_and_referent = |reference: &Expr<'tcx>, referent: &Expr<'tcx>| {
+        if let ExprKind::Field(base, _) = &referent.kind {
+            let base_ty = cx.typeck_results().expr_ty(base);
+            if drop_trait_def_id.map_or(false, |id| implements_trait(cx, base_ty, id, &[])) {
+                return false;
+            }
+        }
+
         let referent_ty = cx.typeck_results().expr_ty(referent);
 
         if !is_copy(cx, referent_ty)
diff --git a/tests/ui/needless_borrows_for_generic_args.fixed b/tests/ui/needless_borrows_for_generic_args.fixed
index 2a335516f51..bd7a9a0b984 100644
--- a/tests/ui/needless_borrows_for_generic_args.fixed
+++ b/tests/ui/needless_borrows_for_generic_args.fixed
@@ -284,4 +284,19 @@ fn main() {
         {
         }
     }
+    // address of field when operand impl Drop
+    {
+        struct CustomDrop(String);
+
+        impl Drop for CustomDrop {
+            fn drop(&mut self) {}
+        }
+
+        fn check_str<P: AsRef<str>>(_to: P) {}
+
+        fn test() {
+            let owner = CustomDrop(String::default());
+            check_str(&owner.0); // Don't lint. `owner` can't be partially moved because it impl Drop
+        }
+    }
 }
diff --git a/tests/ui/needless_borrows_for_generic_args.rs b/tests/ui/needless_borrows_for_generic_args.rs
index f0567f486ac..5cfd4ce30cc 100644
--- a/tests/ui/needless_borrows_for_generic_args.rs
+++ b/tests/ui/needless_borrows_for_generic_args.rs
@@ -284,4 +284,19 @@ fn main() {
         {
         }
     }
+    // address of field when operand impl Drop
+    {
+        struct CustomDrop(String);
+
+        impl Drop for CustomDrop {
+            fn drop(&mut self) {}
+        }
+
+        fn check_str<P: AsRef<str>>(_to: P) {}
+
+        fn test() {
+            let owner = CustomDrop(String::default());
+            check_str(&owner.0); // Don't lint. `owner` can't be partially moved because it impl Drop
+        }
+    }
 }
-- 
cgit 1.4.1-3-g733a5


From 504941591f77d818bac0c859043eb264ebc096fe Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Mon, 2 Oct 2023 15:22:42 +0200
Subject: new lint: `repeat_vec_with_capacity`

---
 CHANGELOG.md                                 |   1 +
 clippy_lints/src/declared_lints.rs           |   1 +
 clippy_lints/src/lib.rs                      |   2 +
 clippy_lints/src/repeat_vec_with_capacity.rs | 109 +++++++++++++++++++++++++++
 tests/ui/repeat_vec_with_capacity.fixed      |  38 ++++++++++
 tests/ui/repeat_vec_with_capacity.rs         |  38 ++++++++++
 tests/ui/repeat_vec_with_capacity.stderr     |  40 ++++++++++
 7 files changed, 229 insertions(+)
 create mode 100644 clippy_lints/src/repeat_vec_with_capacity.rs
 create mode 100644 tests/ui/repeat_vec_with_capacity.fixed
 create mode 100644 tests/ui/repeat_vec_with_capacity.rs
 create mode 100644 tests/ui/repeat_vec_with_capacity.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 2e9b755caa0..601c27616e0 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5462,6 +5462,7 @@ Released 2018-09-13
 [`ref_patterns`]: https://rust-lang.github.io/rust-clippy/master/index.html#ref_patterns
 [`regex_macro`]: https://rust-lang.github.io/rust-clippy/master/index.html#regex_macro
 [`repeat_once`]: https://rust-lang.github.io/rust-clippy/master/index.html#repeat_once
+[`repeat_vec_with_capacity`]: https://rust-lang.github.io/rust-clippy/master/index.html#repeat_vec_with_capacity
 [`replace_consts`]: https://rust-lang.github.io/rust-clippy/master/index.html#replace_consts
 [`reserve_after_initialization`]: https://rust-lang.github.io/rust-clippy/master/index.html#reserve_after_initialization
 [`rest_pat_in_fully_bound_structs`]: https://rust-lang.github.io/rust-clippy/master/index.html#rest_pat_in_fully_bound_structs
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index b440e267efe..29c96a7d6da 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -598,6 +598,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::reference::DEREF_ADDROF_INFO,
     crate::regex::INVALID_REGEX_INFO,
     crate::regex::TRIVIAL_REGEX_INFO,
+    crate::repeat_vec_with_capacity::REPEAT_VEC_WITH_CAPACITY_INFO,
     crate::reserve_after_initialization::RESERVE_AFTER_INITIALIZATION_INFO,
     crate::return_self_not_must_use::RETURN_SELF_NOT_MUST_USE_INFO,
     crate::returns::LET_AND_RETURN_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 1c59b2df853..8560edbee76 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -289,6 +289,7 @@ mod ref_option_ref;
 mod ref_patterns;
 mod reference;
 mod regex;
+mod repeat_vec_with_capacity;
 mod reserve_after_initialization;
 mod return_self_not_must_use;
 mod returns;
@@ -1069,6 +1070,7 @@ pub fn register_lints(store: &mut rustc_lint::LintStore, conf: &'static Conf) {
     store.register_late_pass(|_| Box::new(iter_without_into_iter::IterWithoutIntoIter));
     store.register_late_pass(|_| Box::new(iter_over_hash_type::IterOverHashType));
     store.register_late_pass(|_| Box::new(impl_hash_with_borrow_str_and_bytes::ImplHashWithBorrowStrBytes));
+    store.register_late_pass(|_| Box::new(repeat_vec_with_capacity::RepeatVecWithCapacity));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/repeat_vec_with_capacity.rs b/clippy_lints/src/repeat_vec_with_capacity.rs
new file mode 100644
index 00000000000..62e049e54be
--- /dev/null
+++ b/clippy_lints/src/repeat_vec_with_capacity.rs
@@ -0,0 +1,109 @@
+use clippy_utils::consts::{constant, Constant};
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::higher::VecArgs;
+use clippy_utils::macros::root_macro_call;
+use clippy_utils::source::snippet;
+use clippy_utils::{expr_or_init, fn_def_id, match_def_path, paths};
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::{sym, Span};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Looks for patterns such as `vec![Vec::with_capacity(x); n]` or `iter::repeat(Vec::with_capacity(x))`.
+    ///
+    /// ### Why is this bad?
+    /// These constructs work by cloning the element, but cloning a `Vec<_>` does not
+    /// respect the old vector's capacity and effectively discards it.
+    ///
+    /// This makes `iter::repeat(Vec::with_capacity(x))` especially suspicious because the user most certainly
+    /// expected that the yielded `Vec<_>` will have the requested capacity, otherwise one can simply write
+    /// `iter::repeat(Vec::new())` instead and it will have the same effect.
+    ///
+    /// Similarily for `vec![x; n]`, the element `x` is cloned to fill the vec.
+    /// Unlike `iter::repeat` however, the vec repeat macro does not have to clone the value `n` times
+    /// but just `n - 1` times, because it can reuse the passed value for the last slot.
+    /// That means that the last `Vec<_>` gets the requested capacity but all other ones do not.
+    ///
+    /// ### Example
+    /// ```rust
+    /// let _: Vec<Vec<u8>> = vec![Vec::with_capacity(42); 123];
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// let _: Vec<Vec<u8>> = (0..123).map(|_| Vec::with_capacity(42)).collect();
+    /// //                                 ^^^ this closure executes 123 times
+    /// //                                     and the vecs will have the expected capacity
+    /// ```
+    #[clippy::version = "1.74.0"]
+    pub REPEAT_VEC_WITH_CAPACITY,
+    suspicious,
+    "repeating a `Vec::with_capacity` expression which does not retain capacity"
+}
+
+declare_lint_pass!(RepeatVecWithCapacity => [REPEAT_VEC_WITH_CAPACITY]);
+
+fn emit_lint(cx: &LateContext<'_>, span: Span, kind: &str, note: &'static str, sugg_msg: &'static str, sugg: String) {
+    span_lint_and_then(
+        cx,
+        REPEAT_VEC_WITH_CAPACITY,
+        span,
+        &format!("repeating `Vec::with_capacity` using `{kind}`, which does not retain capacity"),
+        |diag| {
+            diag.note(note);
+            diag.span_suggestion_verbose(span, sugg_msg, sugg, Applicability::MaybeIncorrect);
+        },
+    );
+}
+
+/// Checks `vec![Vec::with_capacity(x); n]`
+fn check_vec_macro(cx: &LateContext<'_>, expr: &Expr<'_>) {
+    if let Some(mac_call) = root_macro_call(expr.span)
+        && cx.tcx.is_diagnostic_item(sym::vec_macro, mac_call.def_id)
+        && let Some(VecArgs::Repeat(repeat_expr, len_expr)) = VecArgs::hir(cx, expr)
+        && fn_def_id(cx, repeat_expr).is_some_and(|did| match_def_path(cx, did, &paths::VEC_WITH_CAPACITY))
+        && !len_expr.span.from_expansion()
+        && let Some(Constant::Int(2..)) = constant(cx, cx.typeck_results(), expr_or_init(cx, len_expr))
+    {
+        emit_lint(
+            cx,
+            expr.span.source_callsite(),
+            "vec![x; n]",
+            "only the last `Vec` will have the capacity",
+            "if you intended to initialize multiple `Vec`s with an initial capacity, try",
+            format!(
+                "(0..{}).map(|_| {}).collect::<Vec<_>>()",
+                snippet(cx, len_expr.span, ""),
+                snippet(cx, repeat_expr.span, "..")
+            ),
+        );
+    }
+}
+
+/// Checks `iter::repeat(Vec::with_capacity(x))`
+fn check_repeat_fn(cx: &LateContext<'_>, expr: &Expr<'_>) {
+    if !expr.span.from_expansion()
+        && fn_def_id(cx, expr).is_some_and(|did| cx.tcx.is_diagnostic_item(sym::iter_repeat, did))
+        && let ExprKind::Call(_, [repeat_expr]) = expr.kind
+        && fn_def_id(cx, repeat_expr).is_some_and(|did| match_def_path(cx, did, &paths::VEC_WITH_CAPACITY))
+        && !repeat_expr.span.from_expansion()
+    {
+        emit_lint(
+            cx,
+            expr.span,
+            "iter::repeat",
+            "none of the yielded `Vec`s will have the requested capacity",
+            "if you intended to create an iterator that yields `Vec`s with an initial capacity, try",
+            format!("std::iter::from_fn(|| Some({}))", snippet(cx, repeat_expr.span, "..")),
+        );
+    }
+}
+
+impl LateLintPass<'_> for RepeatVecWithCapacity {
+    fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
+        check_vec_macro(cx, expr);
+        check_repeat_fn(cx, expr);
+    }
+}
diff --git a/tests/ui/repeat_vec_with_capacity.fixed b/tests/ui/repeat_vec_with_capacity.fixed
new file mode 100644
index 00000000000..7a659b36467
--- /dev/null
+++ b/tests/ui/repeat_vec_with_capacity.fixed
@@ -0,0 +1,38 @@
+#![warn(clippy::repeat_vec_with_capacity)]
+
+fn main() {
+    {
+        (0..123).map(|_| Vec::<()>::with_capacity(42)).collect::<Vec<_>>();
+        //~^ ERROR: repeating `Vec::with_capacity` using `vec![x; n]`, which does not retain capacity
+    }
+
+    {
+        let n = 123;
+        (0..n).map(|_| Vec::<()>::with_capacity(42)).collect::<Vec<_>>();
+        //~^ ERROR: repeating `Vec::with_capacity` using `vec![x; n]`, which does not retain capacity
+    }
+
+    {
+        macro_rules! from_macro {
+            ($x:expr) => {
+                vec![$x; 123];
+            };
+        }
+        // vec expansion is from another macro, don't lint
+        from_macro!(Vec::<()>::with_capacity(42));
+    }
+
+    {
+        std::iter::from_fn(|| Some(Vec::<()>::with_capacity(42)));
+        //~^ ERROR: repeating `Vec::with_capacity` using `iter::repeat`, which does not retain capacity
+    }
+
+    {
+        macro_rules! from_macro {
+            ($x:expr) => {
+                std::iter::repeat($x)
+            };
+        }
+        from_macro!(Vec::<()>::with_capacity(42));
+    }
+}
diff --git a/tests/ui/repeat_vec_with_capacity.rs b/tests/ui/repeat_vec_with_capacity.rs
new file mode 100644
index 00000000000..659f2a3953d
--- /dev/null
+++ b/tests/ui/repeat_vec_with_capacity.rs
@@ -0,0 +1,38 @@
+#![warn(clippy::repeat_vec_with_capacity)]
+
+fn main() {
+    {
+        vec![Vec::<()>::with_capacity(42); 123];
+        //~^ ERROR: repeating `Vec::with_capacity` using `vec![x; n]`, which does not retain capacity
+    }
+
+    {
+        let n = 123;
+        vec![Vec::<()>::with_capacity(42); n];
+        //~^ ERROR: repeating `Vec::with_capacity` using `vec![x; n]`, which does not retain capacity
+    }
+
+    {
+        macro_rules! from_macro {
+            ($x:expr) => {
+                vec![$x; 123];
+            };
+        }
+        // vec expansion is from another macro, don't lint
+        from_macro!(Vec::<()>::with_capacity(42));
+    }
+
+    {
+        std::iter::repeat(Vec::<()>::with_capacity(42));
+        //~^ ERROR: repeating `Vec::with_capacity` using `iter::repeat`, which does not retain capacity
+    }
+
+    {
+        macro_rules! from_macro {
+            ($x:expr) => {
+                std::iter::repeat($x)
+            };
+        }
+        from_macro!(Vec::<()>::with_capacity(42));
+    }
+}
diff --git a/tests/ui/repeat_vec_with_capacity.stderr b/tests/ui/repeat_vec_with_capacity.stderr
new file mode 100644
index 00000000000..7e77212bca1
--- /dev/null
+++ b/tests/ui/repeat_vec_with_capacity.stderr
@@ -0,0 +1,40 @@
+error: repeating `Vec::with_capacity` using `vec![x; n]`, which does not retain capacity
+  --> $DIR/repeat_vec_with_capacity.rs:5:9
+   |
+LL |         vec![Vec::<()>::with_capacity(42); 123];
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: only the last `Vec` will have the capacity
+   = note: `-D clippy::repeat-vec-with-capacity` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::repeat_vec_with_capacity)]`
+help: if you intended to initialize multiple `Vec`s with an initial capacity, try
+   |
+LL |         (0..123).map(|_| Vec::<()>::with_capacity(42)).collect::<Vec<_>>();
+   |         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+error: repeating `Vec::with_capacity` using `vec![x; n]`, which does not retain capacity
+  --> $DIR/repeat_vec_with_capacity.rs:11:9
+   |
+LL |         vec![Vec::<()>::with_capacity(42); n];
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: only the last `Vec` will have the capacity
+help: if you intended to initialize multiple `Vec`s with an initial capacity, try
+   |
+LL |         (0..n).map(|_| Vec::<()>::with_capacity(42)).collect::<Vec<_>>();
+   |         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+error: repeating `Vec::with_capacity` using `iter::repeat`, which does not retain capacity
+  --> $DIR/repeat_vec_with_capacity.rs:26:9
+   |
+LL |         std::iter::repeat(Vec::<()>::with_capacity(42));
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: none of the yielded `Vec`s will have the requested capacity
+help: if you intended to create an iterator that yields `Vec`s with an initial capacity, try
+   |
+LL |         std::iter::from_fn(|| Some(Vec::<()>::with_capacity(42)));
+   |         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+error: aborting due to 3 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 76eb781336fc7ce35665b623145d4c66638d3061 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Fri, 1 Dec 2023 17:18:37 +0100
Subject: use `iter::repeat_with` in suggestion and add examples

---
 clippy_lints/src/repeat_vec_with_capacity.rs | 17 +++++++++++------
 tests/ui/repeat_vec_with_capacity.fixed      |  2 +-
 tests/ui/repeat_vec_with_capacity.stderr     |  4 ++--
 3 files changed, 14 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/repeat_vec_with_capacity.rs b/clippy_lints/src/repeat_vec_with_capacity.rs
index 62e049e54be..5a4933a3fce 100644
--- a/clippy_lints/src/repeat_vec_with_capacity.rs
+++ b/clippy_lints/src/repeat_vec_with_capacity.rs
@@ -7,7 +7,7 @@ use clippy_utils::{expr_or_init, fn_def_id, match_def_path, paths};
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_session::declare_lint_pass;
 use rustc_span::{sym, Span};
 
 declare_clippy_lint! {
@@ -22,20 +22,25 @@ declare_clippy_lint! {
     /// expected that the yielded `Vec<_>` will have the requested capacity, otherwise one can simply write
     /// `iter::repeat(Vec::new())` instead and it will have the same effect.
     ///
-    /// Similarily for `vec![x; n]`, the element `x` is cloned to fill the vec.
+    /// Similarly for `vec![x; n]`, the element `x` is cloned to fill the vec.
     /// Unlike `iter::repeat` however, the vec repeat macro does not have to clone the value `n` times
     /// but just `n - 1` times, because it can reuse the passed value for the last slot.
     /// That means that the last `Vec<_>` gets the requested capacity but all other ones do not.
     ///
     /// ### Example
     /// ```rust
+    /// # use std::iter;
+    ///
     /// let _: Vec<Vec<u8>> = vec![Vec::with_capacity(42); 123];
+    /// let _: Vec<Vec<u8>> = iter::repeat(Vec::with_capacity(42)).take(123).collect();
     /// ```
     /// Use instead:
     /// ```rust
-    /// let _: Vec<Vec<u8>> = (0..123).map(|_| Vec::with_capacity(42)).collect();
-    /// //                                 ^^^ this closure executes 123 times
-    /// //                                     and the vecs will have the expected capacity
+    /// # use std::iter;
+    ///
+    /// let _: Vec<Vec<u8>> = iter::repeat_with(|| Vec::with_capacity(42)).take(123).collect();
+    /// //                                      ^^^ this closure executes 123 times
+    /// //                                          and the vecs will have the expected capacity
     /// ```
     #[clippy::version = "1.74.0"]
     pub REPEAT_VEC_WITH_CAPACITY,
@@ -96,7 +101,7 @@ fn check_repeat_fn(cx: &LateContext<'_>, expr: &Expr<'_>) {
             "iter::repeat",
             "none of the yielded `Vec`s will have the requested capacity",
             "if you intended to create an iterator that yields `Vec`s with an initial capacity, try",
-            format!("std::iter::from_fn(|| Some({}))", snippet(cx, repeat_expr.span, "..")),
+            format!("std::iter::repeat_with(|| {})", snippet(cx, repeat_expr.span, "..")),
         );
     }
 }
diff --git a/tests/ui/repeat_vec_with_capacity.fixed b/tests/ui/repeat_vec_with_capacity.fixed
index 7a659b36467..2afe2f43325 100644
--- a/tests/ui/repeat_vec_with_capacity.fixed
+++ b/tests/ui/repeat_vec_with_capacity.fixed
@@ -23,7 +23,7 @@ fn main() {
     }
 
     {
-        std::iter::from_fn(|| Some(Vec::<()>::with_capacity(42)));
+        std::iter::repeat_with(|| Vec::<()>::with_capacity(42));
         //~^ ERROR: repeating `Vec::with_capacity` using `iter::repeat`, which does not retain capacity
     }
 
diff --git a/tests/ui/repeat_vec_with_capacity.stderr b/tests/ui/repeat_vec_with_capacity.stderr
index 7e77212bca1..10b5f121420 100644
--- a/tests/ui/repeat_vec_with_capacity.stderr
+++ b/tests/ui/repeat_vec_with_capacity.stderr
@@ -33,8 +33,8 @@ LL |         std::iter::repeat(Vec::<()>::with_capacity(42));
    = note: none of the yielded `Vec`s will have the requested capacity
 help: if you intended to create an iterator that yields `Vec`s with an initial capacity, try
    |
-LL |         std::iter::from_fn(|| Some(Vec::<()>::with_capacity(42)));
-   |         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+LL |         std::iter::repeat_with(|| Vec::<()>::with_capacity(42));
+   |         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 error: aborting due to 3 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 6d40b105ed69598205e4877db188a62d0817aa94 Mon Sep 17 00:00:00 2001
From: cocodery <cocodery@outlook.com>
Date: Sun, 3 Dec 2023 00:58:47 +0800
Subject: Add a function to check whether binary oprands are nontrivial It's
 hard to check whether oprator is overrided through context of lint So assume
 nontrivial has overrided binary operator

---
 clippy_lints/src/no_effect.rs | 59 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 59 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/no_effect.rs b/clippy_lints/src/no_effect.rs
index 6e65dd628a4..66c013b4f35 100644
--- a/clippy_lints/src/no_effect.rs
+++ b/clippy_lints/src/no_effect.rs
@@ -87,6 +87,10 @@ impl<'tcx> LateLintPass<'tcx> for NoEffect {
 
 fn check_no_effect(cx: &LateContext<'_>, stmt: &Stmt<'_>) -> bool {
     if let StmtKind::Semi(expr) = stmt.kind {
+        // assume nontrivial oprand of `Binary` Expr can skip `check_unnecessary_operation`
+        if has_nontrivial_oprand(expr) {
+            return true;
+        }
         if has_no_effect(cx, expr) {
             span_lint_hir_and_then(
                 cx,
@@ -153,6 +157,61 @@ fn check_no_effect(cx: &LateContext<'_>, stmt: &Stmt<'_>) -> bool {
     false
 }
 
+fn has_nontrivial_oprand(expr: &Expr<'_>) -> bool {
+    if expr.span.from_expansion() {
+        return false;
+    }
+    return match peel_blocks(expr).kind {
+        ExprKind::Binary(_, lhs, rhs) => !check_nontrivial_operand(lhs, rhs),
+        _ => false,
+    };
+}
+
+fn check_nontrivial_operand(lhs: &Expr<'_>, rhs: &Expr<'_>) -> bool {
+    // It's seem that impossable to check whether operator is overrided through context of this lint,
+    // so, this function assume user-defined binary operator is overrided with an side-effect.
+    // The definition of user-defined structure here is `tuple`, `array`, `struct`,
+    // it looks like a little bit simple, but useful.
+    // Althrough this will weaken the ability of this lint,
+    // less miss lint-fix happen.
+
+    // a closure to check whether expr belongs to user-defined structure
+    let closure = |expr: &Expr<'_>| -> bool {
+        match &expr.kind {
+            // check whether expr is a user-defined sturcture
+            ExprKind::Tup(..) | ExprKind::Array(..) | ExprKind::Struct(..) => true,
+            // resolve expr's path
+            ExprKind::Path(rustc_hir::QPath::Resolved(
+                _,
+                rustc_hir::Path {
+                    span: _,
+                    res,
+                    segments: _,
+                },
+            )) => {
+                match res {
+                    Res::Def(defkind, _) => match defkind {
+                        // user-defined
+                        DefKind::Struct | DefKind::Ctor(_, _) => true,
+                        _ => false,
+                    },
+                    _ => false,
+                };
+                false
+            },
+            _ => false,
+        }
+    };
+
+    let lhs_ud = closure(lhs);
+    let rhs_ud = closure(rhs);
+    // one of lhs or rhs is user-defined structure
+    if lhs_ud || rhs_ud {
+        return false;
+    }
+    true
+}
+
 fn has_no_effect(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
     if expr.span.from_expansion() {
         return false;
-- 
cgit 1.4.1-3-g733a5


From 8eea8b1577bb4ca81149f81f5b5abbc12bee2204 Mon Sep 17 00:00:00 2001
From: Kisaragi Marine <kisaragi.effective@gmail.com>
Date: Sun, 3 Dec 2023 10:25:38 +0900
Subject: fix: handle `std::ptr::null{_mut}` close rust-lang#11066 close
 rust-lang#11665 close rust-lang#11911

---
 clippy_lints/src/casts/ptr_as_ptr.rs |  55 ++++++++++++-
 tests/ui/ptr_as_ptr.fixed            | 115 +++++++++++++++++++++++++++
 tests/ui/ptr_as_ptr.rs               | 115 +++++++++++++++++++++++++++
 tests/ui/ptr_as_ptr.stderr           | 146 ++++++++++++++++++++++++++++++++++-
 4 files changed, 426 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/ptr_as_ptr.rs b/clippy_lints/src/casts/ptr_as_ptr.rs
index 0c555c1acc5..35e36e9ef3f 100644
--- a/clippy_lints/src/casts/ptr_as_ptr.rs
+++ b/clippy_lints/src/casts/ptr_as_ptr.rs
@@ -3,12 +3,29 @@ use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::sugg::Sugg;
 use rustc_errors::Applicability;
-use rustc_hir::{Expr, ExprKind, Mutability, TyKind};
+use rustc_hir::{Expr, ExprKind, Mutability, QPath, TyKind};
+use rustc_hir_pretty::qpath_to_string;
 use rustc_lint::LateContext;
 use rustc_middle::ty::{self, TypeAndMut};
+use rustc_span::sym;
 
 use super::PTR_AS_PTR;
 
+enum OmitFollowedCastReason<'a> {
+    None,
+    Null(&'a QPath<'a>),
+    NullMut(&'a QPath<'a>),
+}
+
+impl OmitFollowedCastReason<'_> {
+    fn corresponding_item(&self) -> Option<&QPath<'_>> {
+        match self {
+            OmitFollowedCastReason::None => None,
+            OmitFollowedCastReason::Null(x) | OmitFollowedCastReason::NullMut(x) => Some(*x),
+        }
+    }
+}
+
 pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, msrv: &Msrv) {
     if !msrv.meets(msrvs::POINTER_CAST) {
         return;
@@ -25,7 +42,6 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, msrv: &Msrv) {
         && to_pointee_ty.is_sized(cx.tcx, cx.param_env)
     {
         let mut app = Applicability::MachineApplicable;
-        let cast_expr_sugg = Sugg::hir_with_applicability(cx, cast_expr, "_", &mut app);
         let turbofish = match &cast_to_hir_ty.kind {
             TyKind::Infer => String::new(),
             TyKind::Ptr(mut_ty) => {
@@ -41,13 +57,44 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, msrv: &Msrv) {
             _ => return,
         };
 
+        // following `cast` does not compile because it fails to infer what type is expected
+        // as type argument to `std::ptr::ptr_null` or `std::ptr::ptr_null_mut`, so
+        // we omit following `cast`:
+        let omit_cast = if let ExprKind::Call(func, []) = cast_expr.kind
+            && let ExprKind::Path(ref qpath @ QPath::Resolved(None, path)) = func.kind
+        {
+            let method_defid = path.res.def_id();
+            if cx.tcx.is_diagnostic_item(sym::ptr_null, method_defid) {
+                OmitFollowedCastReason::Null(qpath)
+            } else if cx.tcx.is_diagnostic_item(sym::ptr_null_mut, method_defid) {
+                OmitFollowedCastReason::NullMut(qpath)
+            } else {
+                OmitFollowedCastReason::None
+            }
+        } else {
+            OmitFollowedCastReason::None
+        };
+
+        let (help, final_suggestion) = if let Some(method) = omit_cast.corresponding_item() {
+            // don't force absolute path
+            let method = qpath_to_string(method);
+            ("try call directly", format!("{method}{turbofish}()"))
+        } else {
+            let cast_expr_sugg = Sugg::hir_with_applicability(cx, cast_expr, "_", &mut app);
+
+            (
+                "try `pointer::cast`, a safer alternative",
+                format!("{}.cast{turbofish}()", cast_expr_sugg.maybe_par()),
+            )
+        };
+
         span_lint_and_sugg(
             cx,
             PTR_AS_PTR,
             expr.span,
             "`as` casting between raw pointers without changing its mutability",
-            "try `pointer::cast`, a safer alternative",
-            format!("{}.cast{turbofish}()", cast_expr_sugg.maybe_par()),
+            help,
+            final_suggestion,
             app,
         );
     }
diff --git a/tests/ui/ptr_as_ptr.fixed b/tests/ui/ptr_as_ptr.fixed
index ca13b52ae3b..fa15c323540 100644
--- a/tests/ui/ptr_as_ptr.fixed
+++ b/tests/ui/ptr_as_ptr.fixed
@@ -71,3 +71,118 @@ fn _msrv_1_38() {
     let _ = ptr.cast::<i32>();
     let _ = mut_ptr.cast::<i32>();
 }
+
+#[allow(clippy::unnecessary_cast)]
+mod null {
+    fn use_path_mut() -> *mut u32 {
+        use std::ptr;
+        ptr::null_mut::<u32>()
+    }
+
+    fn full_path_mut() -> *mut u32 {
+        std::ptr::null_mut::<u32>()
+    }
+
+    fn core_path_mut() -> *mut u32 {
+        use core::ptr;
+        ptr::null_mut::<u32>()
+    }
+
+    fn full_core_path_mut() -> *mut u32 {
+        core::ptr::null_mut::<u32>()
+    }
+
+    fn use_path() -> *const u32 {
+        use std::ptr;
+        ptr::null::<u32>()
+    }
+
+    fn full_path() -> *const u32 {
+        std::ptr::null::<u32>()
+    }
+
+    fn core_path() -> *const u32 {
+        use core::ptr;
+        ptr::null::<u32>()
+    }
+
+    fn full_core_path() -> *const u32 {
+        core::ptr::null::<u32>()
+    }
+}
+
+mod null_ptr_infer {
+    fn use_path_mut() -> *mut u32 {
+        use std::ptr;
+        ptr::null_mut()
+    }
+
+    fn full_path_mut() -> *mut u32 {
+        std::ptr::null_mut()
+    }
+
+    fn core_path_mut() -> *mut u32 {
+        use core::ptr;
+        ptr::null_mut()
+    }
+
+    fn full_core_path_mut() -> *mut u32 {
+        core::ptr::null_mut()
+    }
+
+    fn use_path() -> *const u32 {
+        use std::ptr;
+        ptr::null()
+    }
+
+    fn full_path() -> *const u32 {
+        std::ptr::null()
+    }
+
+    fn core_path() -> *const u32 {
+        use core::ptr;
+        ptr::null()
+    }
+
+    fn full_core_path() -> *const u32 {
+        core::ptr::null()
+    }
+}
+
+mod null_entire_infer {
+    fn use_path_mut() -> *mut u32 {
+        use std::ptr;
+        ptr::null_mut()
+    }
+
+    fn full_path_mut() -> *mut u32 {
+        std::ptr::null_mut()
+    }
+
+    fn core_path_mut() -> *mut u32 {
+        use core::ptr;
+        ptr::null_mut()
+    }
+
+    fn full_core_path_mut() -> *mut u32 {
+        core::ptr::null_mut()
+    }
+
+    fn use_path() -> *const u32 {
+        use std::ptr;
+        ptr::null()
+    }
+
+    fn full_path() -> *const u32 {
+        std::ptr::null()
+    }
+
+    fn core_path() -> *const u32 {
+        use core::ptr;
+        ptr::null()
+    }
+
+    fn full_core_path() -> *const u32 {
+        core::ptr::null()
+    }
+}
diff --git a/tests/ui/ptr_as_ptr.rs b/tests/ui/ptr_as_ptr.rs
index 942c8734444..7ab52e63da5 100644
--- a/tests/ui/ptr_as_ptr.rs
+++ b/tests/ui/ptr_as_ptr.rs
@@ -71,3 +71,118 @@ fn _msrv_1_38() {
     let _ = ptr as *const i32;
     let _ = mut_ptr as *mut i32;
 }
+
+#[allow(clippy::unnecessary_cast)]
+mod null {
+    fn use_path_mut() -> *mut u32 {
+        use std::ptr;
+        ptr::null_mut() as *mut u32
+    }
+
+    fn full_path_mut() -> *mut u32 {
+        std::ptr::null_mut() as *mut u32
+    }
+
+    fn core_path_mut() -> *mut u32 {
+        use core::ptr;
+        ptr::null_mut() as *mut u32
+    }
+
+    fn full_core_path_mut() -> *mut u32 {
+        core::ptr::null_mut() as *mut u32
+    }
+
+    fn use_path() -> *const u32 {
+        use std::ptr;
+        ptr::null() as *const u32
+    }
+
+    fn full_path() -> *const u32 {
+        std::ptr::null() as *const u32
+    }
+
+    fn core_path() -> *const u32 {
+        use core::ptr;
+        ptr::null() as *const u32
+    }
+
+    fn full_core_path() -> *const u32 {
+        core::ptr::null() as *const u32
+    }
+}
+
+mod null_ptr_infer {
+    fn use_path_mut() -> *mut u32 {
+        use std::ptr;
+        ptr::null_mut() as *mut _
+    }
+
+    fn full_path_mut() -> *mut u32 {
+        std::ptr::null_mut() as *mut _
+    }
+
+    fn core_path_mut() -> *mut u32 {
+        use core::ptr;
+        ptr::null_mut() as *mut _
+    }
+
+    fn full_core_path_mut() -> *mut u32 {
+        core::ptr::null_mut() as *mut _
+    }
+
+    fn use_path() -> *const u32 {
+        use std::ptr;
+        ptr::null() as *const _
+    }
+
+    fn full_path() -> *const u32 {
+        std::ptr::null() as *const _
+    }
+
+    fn core_path() -> *const u32 {
+        use core::ptr;
+        ptr::null() as *const _
+    }
+
+    fn full_core_path() -> *const u32 {
+        core::ptr::null() as *const _
+    }
+}
+
+mod null_entire_infer {
+    fn use_path_mut() -> *mut u32 {
+        use std::ptr;
+        ptr::null_mut() as _
+    }
+
+    fn full_path_mut() -> *mut u32 {
+        std::ptr::null_mut() as _
+    }
+
+    fn core_path_mut() -> *mut u32 {
+        use core::ptr;
+        ptr::null_mut() as _
+    }
+
+    fn full_core_path_mut() -> *mut u32 {
+        core::ptr::null_mut() as _
+    }
+
+    fn use_path() -> *const u32 {
+        use std::ptr;
+        ptr::null() as _
+    }
+
+    fn full_path() -> *const u32 {
+        std::ptr::null() as _
+    }
+
+    fn core_path() -> *const u32 {
+        use core::ptr;
+        ptr::null() as _
+    }
+
+    fn full_core_path() -> *const u32 {
+        core::ptr::null() as _
+    }
+}
diff --git a/tests/ui/ptr_as_ptr.stderr b/tests/ui/ptr_as_ptr.stderr
index c0ce69b4357..ef64347e935 100644
--- a/tests/ui/ptr_as_ptr.stderr
+++ b/tests/ui/ptr_as_ptr.stderr
@@ -57,5 +57,149 @@ error: `as` casting between raw pointers without changing its mutability
 LL |     let _ = mut_ptr as *mut i32;
    |             ^^^^^^^^^^^^^^^^^^^ help: try `pointer::cast`, a safer alternative: `mut_ptr.cast::<i32>()`
 
-error: aborting due to 9 previous errors
+error: `as` casting between raw pointers without changing its mutability
+  --> $DIR/ptr_as_ptr.rs:79:9
+   |
+LL |         ptr::null_mut() as *mut u32
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try call directly: `ptr::null_mut::<u32>()`
+
+error: `as` casting between raw pointers without changing its mutability
+  --> $DIR/ptr_as_ptr.rs:83:9
+   |
+LL |         std::ptr::null_mut() as *mut u32
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try call directly: `std::ptr::null_mut::<u32>()`
+
+error: `as` casting between raw pointers without changing its mutability
+  --> $DIR/ptr_as_ptr.rs:88:9
+   |
+LL |         ptr::null_mut() as *mut u32
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try call directly: `ptr::null_mut::<u32>()`
+
+error: `as` casting between raw pointers without changing its mutability
+  --> $DIR/ptr_as_ptr.rs:92:9
+   |
+LL |         core::ptr::null_mut() as *mut u32
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try call directly: `core::ptr::null_mut::<u32>()`
+
+error: `as` casting between raw pointers without changing its mutability
+  --> $DIR/ptr_as_ptr.rs:97:9
+   |
+LL |         ptr::null() as *const u32
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try call directly: `ptr::null::<u32>()`
+
+error: `as` casting between raw pointers without changing its mutability
+  --> $DIR/ptr_as_ptr.rs:101:9
+   |
+LL |         std::ptr::null() as *const u32
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try call directly: `std::ptr::null::<u32>()`
+
+error: `as` casting between raw pointers without changing its mutability
+  --> $DIR/ptr_as_ptr.rs:106:9
+   |
+LL |         ptr::null() as *const u32
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try call directly: `ptr::null::<u32>()`
+
+error: `as` casting between raw pointers without changing its mutability
+  --> $DIR/ptr_as_ptr.rs:110:9
+   |
+LL |         core::ptr::null() as *const u32
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try call directly: `core::ptr::null::<u32>()`
+
+error: `as` casting between raw pointers without changing its mutability
+  --> $DIR/ptr_as_ptr.rs:117:9
+   |
+LL |         ptr::null_mut() as *mut _
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try call directly: `ptr::null_mut()`
+
+error: `as` casting between raw pointers without changing its mutability
+  --> $DIR/ptr_as_ptr.rs:121:9
+   |
+LL |         std::ptr::null_mut() as *mut _
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try call directly: `std::ptr::null_mut()`
+
+error: `as` casting between raw pointers without changing its mutability
+  --> $DIR/ptr_as_ptr.rs:126:9
+   |
+LL |         ptr::null_mut() as *mut _
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try call directly: `ptr::null_mut()`
+
+error: `as` casting between raw pointers without changing its mutability
+  --> $DIR/ptr_as_ptr.rs:130:9
+   |
+LL |         core::ptr::null_mut() as *mut _
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try call directly: `core::ptr::null_mut()`
+
+error: `as` casting between raw pointers without changing its mutability
+  --> $DIR/ptr_as_ptr.rs:135:9
+   |
+LL |         ptr::null() as *const _
+   |         ^^^^^^^^^^^^^^^^^^^^^^^ help: try call directly: `ptr::null()`
+
+error: `as` casting between raw pointers without changing its mutability
+  --> $DIR/ptr_as_ptr.rs:139:9
+   |
+LL |         std::ptr::null() as *const _
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try call directly: `std::ptr::null()`
+
+error: `as` casting between raw pointers without changing its mutability
+  --> $DIR/ptr_as_ptr.rs:144:9
+   |
+LL |         ptr::null() as *const _
+   |         ^^^^^^^^^^^^^^^^^^^^^^^ help: try call directly: `ptr::null()`
+
+error: `as` casting between raw pointers without changing its mutability
+  --> $DIR/ptr_as_ptr.rs:148:9
+   |
+LL |         core::ptr::null() as *const _
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try call directly: `core::ptr::null()`
+
+error: `as` casting between raw pointers without changing its mutability
+  --> $DIR/ptr_as_ptr.rs:155:9
+   |
+LL |         ptr::null_mut() as _
+   |         ^^^^^^^^^^^^^^^^^^^^ help: try call directly: `ptr::null_mut()`
+
+error: `as` casting between raw pointers without changing its mutability
+  --> $DIR/ptr_as_ptr.rs:159:9
+   |
+LL |         std::ptr::null_mut() as _
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try call directly: `std::ptr::null_mut()`
+
+error: `as` casting between raw pointers without changing its mutability
+  --> $DIR/ptr_as_ptr.rs:164:9
+   |
+LL |         ptr::null_mut() as _
+   |         ^^^^^^^^^^^^^^^^^^^^ help: try call directly: `ptr::null_mut()`
+
+error: `as` casting between raw pointers without changing its mutability
+  --> $DIR/ptr_as_ptr.rs:168:9
+   |
+LL |         core::ptr::null_mut() as _
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try call directly: `core::ptr::null_mut()`
+
+error: `as` casting between raw pointers without changing its mutability
+  --> $DIR/ptr_as_ptr.rs:173:9
+   |
+LL |         ptr::null() as _
+   |         ^^^^^^^^^^^^^^^^ help: try call directly: `ptr::null()`
+
+error: `as` casting between raw pointers without changing its mutability
+  --> $DIR/ptr_as_ptr.rs:177:9
+   |
+LL |         std::ptr::null() as _
+   |         ^^^^^^^^^^^^^^^^^^^^^ help: try call directly: `std::ptr::null()`
+
+error: `as` casting between raw pointers without changing its mutability
+  --> $DIR/ptr_as_ptr.rs:182:9
+   |
+LL |         ptr::null() as _
+   |         ^^^^^^^^^^^^^^^^ help: try call directly: `ptr::null()`
+
+error: `as` casting between raw pointers without changing its mutability
+  --> $DIR/ptr_as_ptr.rs:186:9
+   |
+LL |         core::ptr::null() as _
+   |         ^^^^^^^^^^^^^^^^^^^^^^ help: try call directly: `core::ptr::null()`
+
+error: aborting due to 33 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From a3ce379adcabc70c7efedf38a8b8f988f3df7d2e Mon Sep 17 00:00:00 2001
From: Kisaragi <48310258+KisaragiEffective@users.noreply.github.com>
Date: Mon, 4 Dec 2023 08:03:39 +0900
Subject: docs(explicit_write): add missing backtick to complete code snippet

---
 clippy_lints/src/explicit_write.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/explicit_write.rs b/clippy_lints/src/explicit_write.rs
index b612cc00bf9..516c0f85702 100644
--- a/clippy_lints/src/explicit_write.rs
+++ b/clippy_lints/src/explicit_write.rs
@@ -16,7 +16,7 @@ declare_clippy_lint! {
     /// replaced with `(e)print!()` / `(e)println!()`
     ///
     /// ### Why is this bad?
-    /// Using `(e)println! is clearer and more concise
+    /// Using `(e)println!` is clearer and more concise
     ///
     /// ### Example
     /// ```rust
-- 
cgit 1.4.1-3-g733a5


From 89774234be1ce368ea2b1c6c127fe254331ee47e Mon Sep 17 00:00:00 2001
From: cocodery <cocodery@outlook.com>
Date: Mon, 4 Dec 2023 15:57:27 +0800
Subject: Rewrite logic of `has_nontrivial_oprand`. Check whether operator is
 overrided with a `struct` operand. The struct here refers to `struct`,
 `enum`, `union`. Add and fix test for `no_effect` lint.

---
 clippy_lints/src/no_effect.rs | 90 ++++++++++++++++---------------------------
 tests/ui/no_effect.rs         | 23 +++++++++++
 tests/ui/no_effect.stderr     | 58 ++++++++++++++--------------
 3 files changed, 86 insertions(+), 85 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/no_effect.rs b/clippy_lints/src/no_effect.rs
index 66c013b4f35..e3930b0568d 100644
--- a/clippy_lints/src/no_effect.rs
+++ b/clippy_lints/src/no_effect.rs
@@ -10,6 +10,7 @@ use rustc_hir::{
 use rustc_infer::infer::TyCtxtInferExt as _;
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
+use rustc_middle::ty;
 use rustc_session::declare_lint_pass;
 use std::ops::Deref;
 
@@ -87,8 +88,13 @@ impl<'tcx> LateLintPass<'tcx> for NoEffect {
 
 fn check_no_effect(cx: &LateContext<'_>, stmt: &Stmt<'_>) -> bool {
     if let StmtKind::Semi(expr) = stmt.kind {
+        // move `expr.span.from_expansion()` ahead
+        if expr.span.from_expansion() {
+            return false;
+        }
+        let expr = peel_blocks(expr);
         // assume nontrivial oprand of `Binary` Expr can skip `check_unnecessary_operation`
-        if has_nontrivial_oprand(expr) {
+        if has_nontrivial_oprand(cx, expr) {
             return true;
         }
         if has_no_effect(cx, expr) {
@@ -157,66 +163,38 @@ fn check_no_effect(cx: &LateContext<'_>, stmt: &Stmt<'_>) -> bool {
     false
 }
 
-fn has_nontrivial_oprand(expr: &Expr<'_>) -> bool {
-    if expr.span.from_expansion() {
-        return false;
-    }
-    return match peel_blocks(expr).kind {
-        ExprKind::Binary(_, lhs, rhs) => !check_nontrivial_operand(lhs, rhs),
-        _ => false,
-    };
-}
-
-fn check_nontrivial_operand(lhs: &Expr<'_>, rhs: &Expr<'_>) -> bool {
-    // It's seem that impossable to check whether operator is overrided through context of this lint,
-    // so, this function assume user-defined binary operator is overrided with an side-effect.
-    // The definition of user-defined structure here is `tuple`, `array`, `struct`,
-    // it looks like a little bit simple, but useful.
-    // Althrough this will weaken the ability of this lint,
-    // less miss lint-fix happen.
-
-    // a closure to check whether expr belongs to user-defined structure
-    let closure = |expr: &Expr<'_>| -> bool {
-        match &expr.kind {
-            // check whether expr is a user-defined sturcture
-            ExprKind::Tup(..) | ExprKind::Array(..) | ExprKind::Struct(..) => true,
-            // resolve expr's path
-            ExprKind::Path(rustc_hir::QPath::Resolved(
-                _,
-                rustc_hir::Path {
-                    span: _,
-                    res,
-                    segments: _,
-                },
-            )) => {
-                match res {
-                    Res::Def(defkind, _) => match defkind {
-                        // user-defined
-                        DefKind::Struct | DefKind::Ctor(_, _) => true,
-                        _ => false,
-                    },
-                    _ => false,
-                };
-                false
-            },
-            _ => false,
-        }
-    };
+fn has_nontrivial_oprand(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+    // It's very hard or impossable to check whether overrided operator have side-effect this lint.
+    // So, this function assume user-defined binary operator is overrided with an side-effect.
+    // The definition of user-defined structure here is `struct`, `enum`, `uniom`,
+    // Althrough this will weaken the ability of this lint, less error lint-fix happen.
+    match expr.kind {
+        ExprKind::Binary(_, lhs, rhs) => {
+            // get type of lhs and rhs
+            let tyck_result = cx.typeck_results();
+            let ty_lhs = tyck_result.expr_ty(lhs).kind();
+            let ty_rhs = tyck_result.expr_ty(rhs).kind();
+            // check whether lhs is a user-defined structure
+            // only need to check lhs in fact
+            let ud_lhs = match ty_lhs {
+                ty::Adt(adt_def, _) => adt_def.is_struct() || adt_def.is_enum() || adt_def.is_union(),
+                _ => false,
+            };
+            let ud_rhs = match ty_rhs {
+                ty::Adt(adt_def, _) => adt_def.is_struct() || adt_def.is_enum() || adt_def.is_union(),
+                _ => false,
+            };
 
-    let lhs_ud = closure(lhs);
-    let rhs_ud = closure(rhs);
-    // one of lhs or rhs is user-defined structure
-    if lhs_ud || rhs_ud {
-        return false;
+            // reference: rust/compiler/rustc_middle/src/ty/typeck_results.rs: `is_method_call`.
+            // use this function to check whether operator is overrided in `ExprKind::Binary`.
+            (ud_lhs || ud_rhs) && tyck_result.is_method_call(expr)
+        },
+        _ => false,
     }
-    true
 }
 
 fn has_no_effect(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-    if expr.span.from_expansion() {
-        return false;
-    }
-    match peel_blocks(expr).kind {
+    match expr.kind {
         ExprKind::Lit(..) | ExprKind::Closure { .. } => true,
         ExprKind::Path(..) => !has_drop(cx, cx.typeck_results().expr_ty(expr)),
         ExprKind::Index(a, b, _) | ExprKind::Binary(_, a, b) => has_no_effect(cx, a) && has_no_effect(cx, b),
diff --git a/tests/ui/no_effect.rs b/tests/ui/no_effect.rs
index c52f4389192..7ffdeef6582 100644
--- a/tests/ui/no_effect.rs
+++ b/tests/ui/no_effect.rs
@@ -9,6 +9,22 @@
     clippy::useless_vec
 )]
 
+use std::fmt::Display;
+use std::ops::Shl;
+
+struct Cout;
+
+impl<T> Shl<T> for Cout
+where
+    T: Display,
+{
+    type Output = Self;
+    fn shl(self, rhs: T) -> Self::Output {
+        println!("{}", rhs);
+        self
+    }
+}
+
 struct Unit;
 struct Tuple(i32);
 struct Struct {
@@ -174,4 +190,11 @@ fn main() {
     GreetStruct1("world");
     GreetStruct2()("world");
     GreetStruct3 {}("world");
+
+    fn n() -> i32 {
+        42
+    }
+
+    Cout << 142;
+    Cout << n();
 }
diff --git a/tests/ui/no_effect.stderr b/tests/ui/no_effect.stderr
index feba35697f5..437e556a7a8 100644
--- a/tests/ui/no_effect.stderr
+++ b/tests/ui/no_effect.stderr
@@ -1,5 +1,5 @@
 error: statement with no effect
-  --> $DIR/no_effect.rs:98:5
+  --> $DIR/no_effect.rs:114:5
    |
 LL |     0;
    |     ^^
@@ -8,151 +8,151 @@ LL |     0;
    = help: to override `-D warnings` add `#[allow(clippy::no_effect)]`
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:101:5
+  --> $DIR/no_effect.rs:117:5
    |
 LL |     s2;
    |     ^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:103:5
+  --> $DIR/no_effect.rs:119:5
    |
 LL |     Unit;
    |     ^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:105:5
+  --> $DIR/no_effect.rs:121:5
    |
 LL |     Tuple(0);
    |     ^^^^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:107:5
+  --> $DIR/no_effect.rs:123:5
    |
 LL |     Struct { field: 0 };
    |     ^^^^^^^^^^^^^^^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:109:5
+  --> $DIR/no_effect.rs:125:5
    |
 LL |     Struct { ..s };
    |     ^^^^^^^^^^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:111:5
+  --> $DIR/no_effect.rs:127:5
    |
 LL |     Union { a: 0 };
    |     ^^^^^^^^^^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:113:5
+  --> $DIR/no_effect.rs:129:5
    |
 LL |     Enum::Tuple(0);
    |     ^^^^^^^^^^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:115:5
+  --> $DIR/no_effect.rs:131:5
    |
 LL |     Enum::Struct { field: 0 };
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:117:5
+  --> $DIR/no_effect.rs:133:5
    |
 LL |     5 + 6;
    |     ^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:119:5
+  --> $DIR/no_effect.rs:135:5
    |
 LL |     *&42;
    |     ^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:121:5
+  --> $DIR/no_effect.rs:137:5
    |
 LL |     &6;
    |     ^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:123:5
+  --> $DIR/no_effect.rs:139:5
    |
 LL |     (5, 6, 7);
    |     ^^^^^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:125:5
+  --> $DIR/no_effect.rs:141:5
    |
 LL |     ..;
    |     ^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:127:5
+  --> $DIR/no_effect.rs:143:5
    |
 LL |     5..;
    |     ^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:129:5
+  --> $DIR/no_effect.rs:145:5
    |
 LL |     ..5;
    |     ^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:131:5
+  --> $DIR/no_effect.rs:147:5
    |
 LL |     5..6;
    |     ^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:133:5
+  --> $DIR/no_effect.rs:149:5
    |
 LL |     5..=6;
    |     ^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:135:5
+  --> $DIR/no_effect.rs:151:5
    |
 LL |     [42, 55];
    |     ^^^^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:137:5
+  --> $DIR/no_effect.rs:153:5
    |
 LL |     [42, 55][1];
    |     ^^^^^^^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:139:5
+  --> $DIR/no_effect.rs:155:5
    |
 LL |     (42, 55).1;
    |     ^^^^^^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:141:5
+  --> $DIR/no_effect.rs:157:5
    |
 LL |     [42; 55];
    |     ^^^^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:143:5
+  --> $DIR/no_effect.rs:159:5
    |
 LL |     [42; 55][13];
    |     ^^^^^^^^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:146:5
+  --> $DIR/no_effect.rs:162:5
    |
 LL |     || x += 5;
    |     ^^^^^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:149:5
+  --> $DIR/no_effect.rs:165:5
    |
 LL |     FooString { s: s };
    |     ^^^^^^^^^^^^^^^^^^^
 
 error: binding to `_` prefixed variable with no side-effect
-  --> $DIR/no_effect.rs:151:5
+  --> $DIR/no_effect.rs:167:5
    |
 LL |     let _unused = 1;
    |     ^^^^^^^^^^^^^^^^
@@ -161,19 +161,19 @@ LL |     let _unused = 1;
    = help: to override `-D warnings` add `#[allow(clippy::no_effect_underscore_binding)]`
 
 error: binding to `_` prefixed variable with no side-effect
-  --> $DIR/no_effect.rs:154:5
+  --> $DIR/no_effect.rs:170:5
    |
 LL |     let _penguin = || println!("Some helpful closure");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: binding to `_` prefixed variable with no side-effect
-  --> $DIR/no_effect.rs:156:5
+  --> $DIR/no_effect.rs:172:5
    |
 LL |     let _duck = Struct { field: 0 };
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: binding to `_` prefixed variable with no side-effect
-  --> $DIR/no_effect.rs:158:5
+  --> $DIR/no_effect.rs:174:5
    |
 LL |     let _cat = [2, 4, 6, 8][2];
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From 2e3c031528c26e01937e9e9434947d1289561051 Mon Sep 17 00:00:00 2001
From: cocodery <cocodery@outlook.com>
Date: Tue, 5 Dec 2023 09:29:20 +0800
Subject: Rename `has_nontrivial_oprand` to `is_operator_overrided` Simpfy code
 of `is_operator_overrided`, directly use `is_method_call` to check if
 operator is overrided, at least one oprand of binary-expr must be ADT-type So
 no need to check type of lhs and rhs

---
 clippy_lints/src/no_effect.rs | 27 +++++++--------------------
 1 file changed, 7 insertions(+), 20 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/no_effect.rs b/clippy_lints/src/no_effect.rs
index e3930b0568d..1d92b928880 100644
--- a/clippy_lints/src/no_effect.rs
+++ b/clippy_lints/src/no_effect.rs
@@ -10,7 +10,6 @@ use rustc_hir::{
 use rustc_infer::infer::TyCtxtInferExt as _;
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_middle::ty;
 use rustc_session::declare_lint_pass;
 use std::ops::Deref;
 
@@ -94,7 +93,7 @@ fn check_no_effect(cx: &LateContext<'_>, stmt: &Stmt<'_>) -> bool {
         }
         let expr = peel_blocks(expr);
         // assume nontrivial oprand of `Binary` Expr can skip `check_unnecessary_operation`
-        if has_nontrivial_oprand(cx, expr) {
+        if is_operator_overrided(cx, expr) {
             return true;
         }
         if has_no_effect(cx, expr) {
@@ -163,31 +162,19 @@ fn check_no_effect(cx: &LateContext<'_>, stmt: &Stmt<'_>) -> bool {
     false
 }
 
-fn has_nontrivial_oprand(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+fn is_operator_overrided(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
     // It's very hard or impossable to check whether overrided operator have side-effect this lint.
     // So, this function assume user-defined binary operator is overrided with an side-effect.
-    // The definition of user-defined structure here is `struct`, `enum`, `uniom`,
+    // The definition of user-defined structure here is ADT-type,
     // Althrough this will weaken the ability of this lint, less error lint-fix happen.
     match expr.kind {
-        ExprKind::Binary(_, lhs, rhs) => {
-            // get type of lhs and rhs
-            let tyck_result = cx.typeck_results();
-            let ty_lhs = tyck_result.expr_ty(lhs).kind();
-            let ty_rhs = tyck_result.expr_ty(rhs).kind();
-            // check whether lhs is a user-defined structure
-            // only need to check lhs in fact
-            let ud_lhs = match ty_lhs {
-                ty::Adt(adt_def, _) => adt_def.is_struct() || adt_def.is_enum() || adt_def.is_union(),
-                _ => false,
-            };
-            let ud_rhs = match ty_rhs {
-                ty::Adt(adt_def, _) => adt_def.is_struct() || adt_def.is_enum() || adt_def.is_union(),
-                _ => false,
-            };
+        ExprKind::Binary(..) => {
+            // No need to check type of `lhs` and `rhs`
+            // because if the operator is overrided, at least one operand is ADT type
 
             // reference: rust/compiler/rustc_middle/src/ty/typeck_results.rs: `is_method_call`.
             // use this function to check whether operator is overrided in `ExprKind::Binary`.
-            (ud_lhs || ud_rhs) && tyck_result.is_method_call(expr)
+            cx.typeck_results().is_method_call(expr)
         },
         _ => false,
     }
-- 
cgit 1.4.1-3-g733a5


From ee2354badf390afc95b5fa180cefd0100c9cedbd Mon Sep 17 00:00:00 2001
From: cocodery <cocodery@outlook.com>
Date: Wed, 6 Dec 2023 12:17:48 +0800
Subject: Add check for unary-operator Fix typo and add test for unary-opeator

---
 clippy_lints/src/no_effect.rs | 10 ++++----
 tests/ui/no_effect.rs         | 12 +++++++--
 tests/ui/no_effect.stderr     | 58 +++++++++++++++++++++----------------------
 3 files changed, 44 insertions(+), 36 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/no_effect.rs b/clippy_lints/src/no_effect.rs
index 1d92b928880..a0e7dbf9ec6 100644
--- a/clippy_lints/src/no_effect.rs
+++ b/clippy_lints/src/no_effect.rs
@@ -93,7 +93,7 @@ fn check_no_effect(cx: &LateContext<'_>, stmt: &Stmt<'_>) -> bool {
         }
         let expr = peel_blocks(expr);
         // assume nontrivial oprand of `Binary` Expr can skip `check_unnecessary_operation`
-        if is_operator_overrided(cx, expr) {
+        if is_operator_overriden(cx, expr) {
             return true;
         }
         if has_no_effect(cx, expr) {
@@ -162,18 +162,18 @@ fn check_no_effect(cx: &LateContext<'_>, stmt: &Stmt<'_>) -> bool {
     false
 }
 
-fn is_operator_overrided(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+fn is_operator_overriden(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
     // It's very hard or impossable to check whether overrided operator have side-effect this lint.
-    // So, this function assume user-defined binary operator is overrided with an side-effect.
+    // So, this function assume user-defined operator is overrided with an side-effect.
     // The definition of user-defined structure here is ADT-type,
     // Althrough this will weaken the ability of this lint, less error lint-fix happen.
     match expr.kind {
-        ExprKind::Binary(..) => {
+        ExprKind::Binary(..) | ExprKind::Unary(..) => {
             // No need to check type of `lhs` and `rhs`
             // because if the operator is overrided, at least one operand is ADT type
 
             // reference: rust/compiler/rustc_middle/src/ty/typeck_results.rs: `is_method_call`.
-            // use this function to check whether operator is overrided in `ExprKind::Binary`.
+            // use this function to check whether operator is overrided in `ExprKind::{Binary, Unary}`.
             cx.typeck_results().is_method_call(expr)
         },
         _ => false,
diff --git a/tests/ui/no_effect.rs b/tests/ui/no_effect.rs
index 7ffdeef6582..777b1e52c2d 100644
--- a/tests/ui/no_effect.rs
+++ b/tests/ui/no_effect.rs
@@ -10,7 +10,7 @@
 )]
 
 use std::fmt::Display;
-use std::ops::Shl;
+use std::ops::{Neg, Shl};
 
 struct Cout;
 
@@ -25,6 +25,14 @@ where
     }
 }
 
+impl Neg for Cout {
+    type Output = Self;
+    fn neg(self) -> Self::Output {
+        println!("hello world");
+        self
+    }
+}
+
 struct Unit;
 struct Tuple(i32);
 struct Struct {
@@ -196,5 +204,5 @@ fn main() {
     }
 
     Cout << 142;
-    Cout << n();
+    -Cout;
 }
diff --git a/tests/ui/no_effect.stderr b/tests/ui/no_effect.stderr
index 437e556a7a8..f5ba234b4cb 100644
--- a/tests/ui/no_effect.stderr
+++ b/tests/ui/no_effect.stderr
@@ -1,5 +1,5 @@
 error: statement with no effect
-  --> $DIR/no_effect.rs:114:5
+  --> $DIR/no_effect.rs:122:5
    |
 LL |     0;
    |     ^^
@@ -8,151 +8,151 @@ LL |     0;
    = help: to override `-D warnings` add `#[allow(clippy::no_effect)]`
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:117:5
+  --> $DIR/no_effect.rs:125:5
    |
 LL |     s2;
    |     ^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:119:5
+  --> $DIR/no_effect.rs:127:5
    |
 LL |     Unit;
    |     ^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:121:5
+  --> $DIR/no_effect.rs:129:5
    |
 LL |     Tuple(0);
    |     ^^^^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:123:5
+  --> $DIR/no_effect.rs:131:5
    |
 LL |     Struct { field: 0 };
    |     ^^^^^^^^^^^^^^^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:125:5
+  --> $DIR/no_effect.rs:133:5
    |
 LL |     Struct { ..s };
    |     ^^^^^^^^^^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:127:5
+  --> $DIR/no_effect.rs:135:5
    |
 LL |     Union { a: 0 };
    |     ^^^^^^^^^^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:129:5
+  --> $DIR/no_effect.rs:137:5
    |
 LL |     Enum::Tuple(0);
    |     ^^^^^^^^^^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:131:5
+  --> $DIR/no_effect.rs:139:5
    |
 LL |     Enum::Struct { field: 0 };
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:133:5
+  --> $DIR/no_effect.rs:141:5
    |
 LL |     5 + 6;
    |     ^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:135:5
+  --> $DIR/no_effect.rs:143:5
    |
 LL |     *&42;
    |     ^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:137:5
+  --> $DIR/no_effect.rs:145:5
    |
 LL |     &6;
    |     ^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:139:5
+  --> $DIR/no_effect.rs:147:5
    |
 LL |     (5, 6, 7);
    |     ^^^^^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:141:5
+  --> $DIR/no_effect.rs:149:5
    |
 LL |     ..;
    |     ^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:143:5
+  --> $DIR/no_effect.rs:151:5
    |
 LL |     5..;
    |     ^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:145:5
+  --> $DIR/no_effect.rs:153:5
    |
 LL |     ..5;
    |     ^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:147:5
+  --> $DIR/no_effect.rs:155:5
    |
 LL |     5..6;
    |     ^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:149:5
+  --> $DIR/no_effect.rs:157:5
    |
 LL |     5..=6;
    |     ^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:151:5
+  --> $DIR/no_effect.rs:159:5
    |
 LL |     [42, 55];
    |     ^^^^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:153:5
+  --> $DIR/no_effect.rs:161:5
    |
 LL |     [42, 55][1];
    |     ^^^^^^^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:155:5
+  --> $DIR/no_effect.rs:163:5
    |
 LL |     (42, 55).1;
    |     ^^^^^^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:157:5
+  --> $DIR/no_effect.rs:165:5
    |
 LL |     [42; 55];
    |     ^^^^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:159:5
+  --> $DIR/no_effect.rs:167:5
    |
 LL |     [42; 55][13];
    |     ^^^^^^^^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:162:5
+  --> $DIR/no_effect.rs:170:5
    |
 LL |     || x += 5;
    |     ^^^^^^^^^^
 
 error: statement with no effect
-  --> $DIR/no_effect.rs:165:5
+  --> $DIR/no_effect.rs:173:5
    |
 LL |     FooString { s: s };
    |     ^^^^^^^^^^^^^^^^^^^
 
 error: binding to `_` prefixed variable with no side-effect
-  --> $DIR/no_effect.rs:167:5
+  --> $DIR/no_effect.rs:175:5
    |
 LL |     let _unused = 1;
    |     ^^^^^^^^^^^^^^^^
@@ -161,19 +161,19 @@ LL |     let _unused = 1;
    = help: to override `-D warnings` add `#[allow(clippy::no_effect_underscore_binding)]`
 
 error: binding to `_` prefixed variable with no side-effect
-  --> $DIR/no_effect.rs:170:5
+  --> $DIR/no_effect.rs:178:5
    |
 LL |     let _penguin = || println!("Some helpful closure");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: binding to `_` prefixed variable with no side-effect
-  --> $DIR/no_effect.rs:172:5
+  --> $DIR/no_effect.rs:180:5
    |
 LL |     let _duck = Struct { field: 0 };
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: binding to `_` prefixed variable with no side-effect
-  --> $DIR/no_effect.rs:174:5
+  --> $DIR/no_effect.rs:182:5
    |
 LL |     let _cat = [2, 4, 6, 8][2];
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From 56d20c2b53db2c2d39ee3e8368c5cd556c35f5b0 Mon Sep 17 00:00:00 2001
From: cocodery <cocodery@outlook.com>
Date: Fri, 8 Dec 2023 21:33:28 +0800
Subject: Fix nits and add test for `unnecessary_operation`

---
 clippy_lints/src/no_effect.rs         | 16 ++++++++-------
 tests/ui/unnecessary_operation.fixed  | 19 ++++++++++++++++++
 tests/ui/unnecessary_operation.rs     | 19 ++++++++++++++++++
 tests/ui/unnecessary_operation.stderr | 38 +++++++++++++++++------------------
 4 files changed, 66 insertions(+), 26 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/no_effect.rs b/clippy_lints/src/no_effect.rs
index a0e7dbf9ec6..5978da83199 100644
--- a/clippy_lints/src/no_effect.rs
+++ b/clippy_lints/src/no_effect.rs
@@ -92,8 +92,10 @@ fn check_no_effect(cx: &LateContext<'_>, stmt: &Stmt<'_>) -> bool {
             return false;
         }
         let expr = peel_blocks(expr);
-        // assume nontrivial oprand of `Binary` Expr can skip `check_unnecessary_operation`
-        if is_operator_overriden(cx, expr) {
+
+        if is_operator_overridden(cx, expr) {
+            // Return `true`, to prevent `check_unnecessary_operation` from
+            // linting on this statement as well.
             return true;
         }
         if has_no_effect(cx, expr) {
@@ -162,18 +164,18 @@ fn check_no_effect(cx: &LateContext<'_>, stmt: &Stmt<'_>) -> bool {
     false
 }
 
-fn is_operator_overriden(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-    // It's very hard or impossable to check whether overrided operator have side-effect this lint.
-    // So, this function assume user-defined operator is overrided with an side-effect.
+fn is_operator_overridden(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+    // It's very hard or impossable to check whether overridden operator have side-effect this lint.
+    // So, this function assume user-defined operator is overridden with an side-effect.
     // The definition of user-defined structure here is ADT-type,
     // Althrough this will weaken the ability of this lint, less error lint-fix happen.
     match expr.kind {
         ExprKind::Binary(..) | ExprKind::Unary(..) => {
             // No need to check type of `lhs` and `rhs`
-            // because if the operator is overrided, at least one operand is ADT type
+            // because if the operator is overridden, at least one operand is ADT type
 
             // reference: rust/compiler/rustc_middle/src/ty/typeck_results.rs: `is_method_call`.
-            // use this function to check whether operator is overrided in `ExprKind::{Binary, Unary}`.
+            // use this function to check whether operator is overridden in `ExprKind::{Binary, Unary}`.
             cx.typeck_results().is_method_call(expr)
         },
         _ => false,
diff --git a/tests/ui/unnecessary_operation.fixed b/tests/ui/unnecessary_operation.fixed
index d0c0298ef4c..463412daec0 100644
--- a/tests/ui/unnecessary_operation.fixed
+++ b/tests/ui/unnecessary_operation.fixed
@@ -7,6 +7,9 @@
 )]
 #![warn(clippy::unnecessary_operation)]
 
+use std::fmt::Display;
+use std::ops::Shl;
+
 struct Tuple(i32);
 struct Struct {
     field: i32,
@@ -50,6 +53,19 @@ fn get_drop_struct() -> DropStruct {
     DropStruct { field: 0 }
 }
 
+struct Cout;
+
+impl<T> Shl<T> for Cout
+where
+    T: Display,
+{
+    type Output = Self;
+    fn shl(self, rhs: T) -> Self::Output {
+        println!("{}", rhs);
+        self
+    }
+}
+
 fn main() {
     get_number();
     get_number();
@@ -87,4 +103,7 @@ fn main() {
         ($($e:expr),*) => {{ $($e;)* }}
     }
     use_expr!(isize::MIN / -(one() as isize), i8::MIN / -one());
+
+    // Issue #11885
+    Cout << 16;
 }
diff --git a/tests/ui/unnecessary_operation.rs b/tests/ui/unnecessary_operation.rs
index e8e3a2d5657..f0d28e28902 100644
--- a/tests/ui/unnecessary_operation.rs
+++ b/tests/ui/unnecessary_operation.rs
@@ -7,6 +7,9 @@
 )]
 #![warn(clippy::unnecessary_operation)]
 
+use std::fmt::Display;
+use std::ops::Shl;
+
 struct Tuple(i32);
 struct Struct {
     field: i32,
@@ -50,6 +53,19 @@ fn get_drop_struct() -> DropStruct {
     DropStruct { field: 0 }
 }
 
+struct Cout;
+
+impl<T> Shl<T> for Cout
+where
+    T: Display,
+{
+    type Output = Self;
+    fn shl(self, rhs: T) -> Self::Output {
+        println!("{}", rhs);
+        self
+    }
+}
+
 fn main() {
     Tuple(get_number());
     Struct { field: get_number() };
@@ -91,4 +107,7 @@ fn main() {
         ($($e:expr),*) => {{ $($e;)* }}
     }
     use_expr!(isize::MIN / -(one() as isize), i8::MIN / -one());
+
+    // Issue #11885
+    Cout << 16;
 }
diff --git a/tests/ui/unnecessary_operation.stderr b/tests/ui/unnecessary_operation.stderr
index fbe495f518f..eeee9ad6006 100644
--- a/tests/ui/unnecessary_operation.stderr
+++ b/tests/ui/unnecessary_operation.stderr
@@ -1,5 +1,5 @@
 error: unnecessary operation
-  --> $DIR/unnecessary_operation.rs:54:5
+  --> $DIR/unnecessary_operation.rs:70:5
    |
 LL |     Tuple(get_number());
    |     ^^^^^^^^^^^^^^^^^^^^ help: statement can be reduced to: `get_number();`
@@ -8,103 +8,103 @@ LL |     Tuple(get_number());
    = help: to override `-D warnings` add `#[allow(clippy::unnecessary_operation)]`
 
 error: unnecessary operation
-  --> $DIR/unnecessary_operation.rs:55:5
+  --> $DIR/unnecessary_operation.rs:71:5
    |
 LL |     Struct { field: get_number() };
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: statement can be reduced to: `get_number();`
 
 error: unnecessary operation
-  --> $DIR/unnecessary_operation.rs:56:5
+  --> $DIR/unnecessary_operation.rs:72:5
    |
 LL |     Struct { ..get_struct() };
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: statement can be reduced to: `get_struct();`
 
 error: unnecessary operation
-  --> $DIR/unnecessary_operation.rs:57:5
+  --> $DIR/unnecessary_operation.rs:73:5
    |
 LL |     Enum::Tuple(get_number());
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: statement can be reduced to: `get_number();`
 
 error: unnecessary operation
-  --> $DIR/unnecessary_operation.rs:58:5
+  --> $DIR/unnecessary_operation.rs:74:5
    |
 LL |     Enum::Struct { field: get_number() };
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: statement can be reduced to: `get_number();`
 
 error: unnecessary operation
-  --> $DIR/unnecessary_operation.rs:59:5
+  --> $DIR/unnecessary_operation.rs:75:5
    |
 LL |     5 + get_number();
    |     ^^^^^^^^^^^^^^^^^ help: statement can be reduced to: `5;get_number();`
 
 error: unnecessary operation
-  --> $DIR/unnecessary_operation.rs:60:5
+  --> $DIR/unnecessary_operation.rs:76:5
    |
 LL |     *&get_number();
    |     ^^^^^^^^^^^^^^^ help: statement can be reduced to: `get_number();`
 
 error: unnecessary operation
-  --> $DIR/unnecessary_operation.rs:61:5
+  --> $DIR/unnecessary_operation.rs:77:5
    |
 LL |     &get_number();
    |     ^^^^^^^^^^^^^^ help: statement can be reduced to: `get_number();`
 
 error: unnecessary operation
-  --> $DIR/unnecessary_operation.rs:62:5
+  --> $DIR/unnecessary_operation.rs:78:5
    |
 LL |     (5, 6, get_number());
    |     ^^^^^^^^^^^^^^^^^^^^^ help: statement can be reduced to: `5;6;get_number();`
 
 error: unnecessary operation
-  --> $DIR/unnecessary_operation.rs:63:5
+  --> $DIR/unnecessary_operation.rs:79:5
    |
 LL |     get_number()..;
    |     ^^^^^^^^^^^^^^^ help: statement can be reduced to: `get_number();`
 
 error: unnecessary operation
-  --> $DIR/unnecessary_operation.rs:64:5
+  --> $DIR/unnecessary_operation.rs:80:5
    |
 LL |     ..get_number();
    |     ^^^^^^^^^^^^^^^ help: statement can be reduced to: `get_number();`
 
 error: unnecessary operation
-  --> $DIR/unnecessary_operation.rs:65:5
+  --> $DIR/unnecessary_operation.rs:81:5
    |
 LL |     5..get_number();
    |     ^^^^^^^^^^^^^^^^ help: statement can be reduced to: `5;get_number();`
 
 error: unnecessary operation
-  --> $DIR/unnecessary_operation.rs:66:5
+  --> $DIR/unnecessary_operation.rs:82:5
    |
 LL |     [42, get_number()];
    |     ^^^^^^^^^^^^^^^^^^^ help: statement can be reduced to: `42;get_number();`
 
 error: unnecessary operation
-  --> $DIR/unnecessary_operation.rs:67:5
+  --> $DIR/unnecessary_operation.rs:83:5
    |
 LL |     [42, 55][get_usize()];
    |     ^^^^^^^^^^^^^^^^^^^^^^ help: statement can be written as: `assert!([42, 55].len() > get_usize());`
 
 error: unnecessary operation
-  --> $DIR/unnecessary_operation.rs:68:5
+  --> $DIR/unnecessary_operation.rs:84:5
    |
 LL |     (42, get_number()).1;
    |     ^^^^^^^^^^^^^^^^^^^^^ help: statement can be reduced to: `42;get_number();`
 
 error: unnecessary operation
-  --> $DIR/unnecessary_operation.rs:69:5
+  --> $DIR/unnecessary_operation.rs:85:5
    |
 LL |     [get_number(); 55];
    |     ^^^^^^^^^^^^^^^^^^^ help: statement can be reduced to: `get_number();`
 
 error: unnecessary operation
-  --> $DIR/unnecessary_operation.rs:70:5
+  --> $DIR/unnecessary_operation.rs:86:5
    |
 LL |     [42; 55][get_usize()];
    |     ^^^^^^^^^^^^^^^^^^^^^^ help: statement can be written as: `assert!([42; 55].len() > get_usize());`
 
 error: unnecessary operation
-  --> $DIR/unnecessary_operation.rs:71:5
+  --> $DIR/unnecessary_operation.rs:87:5
    |
 LL | /     {
 LL | |         get_number()
@@ -112,7 +112,7 @@ LL | |     };
    | |______^ help: statement can be reduced to: `get_number();`
 
 error: unnecessary operation
-  --> $DIR/unnecessary_operation.rs:74:5
+  --> $DIR/unnecessary_operation.rs:90:5
    |
 LL | /     FooString {
 LL | |         s: String::from("blah"),
-- 
cgit 1.4.1-3-g733a5


From cdfa38a9d1262474216a5543c807a5dfc1b213fe Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Sun, 26 Nov 2023 20:24:09 +0100
Subject: new lint: `uninhabited_reference`

---
 CHANGELOG.md                                  |  1 +
 clippy_lints/src/declared_lints.rs            |  1 +
 clippy_lints/src/lib.rs                       |  2 +
 clippy_lints/src/uninhabited_references.rs    | 84 +++++++++++++++++++++++++++
 tests/ui/infallible_destructuring_match.fixed |  2 +-
 tests/ui/infallible_destructuring_match.rs    |  2 +-
 tests/ui/uninhabited_references.rs            | 22 +++++++
 tests/ui/uninhabited_references.stderr        | 39 +++++++++++++
 8 files changed, 151 insertions(+), 2 deletions(-)
 create mode 100644 clippy_lints/src/uninhabited_references.rs
 create mode 100644 tests/ui/uninhabited_references.rs
 create mode 100644 tests/ui/uninhabited_references.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 601c27616e0..01338ed68fd 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5583,6 +5583,7 @@ Released 2018-09-13
 [`undropped_manually_drops`]: https://rust-lang.github.io/rust-clippy/master/index.html#undropped_manually_drops
 [`unicode_not_nfc`]: https://rust-lang.github.io/rust-clippy/master/index.html#unicode_not_nfc
 [`unimplemented`]: https://rust-lang.github.io/rust-clippy/master/index.html#unimplemented
+[`uninhabited_references`]: https://rust-lang.github.io/rust-clippy/master/index.html#uninhabited_references
 [`uninit_assumed_init`]: https://rust-lang.github.io/rust-clippy/master/index.html#uninit_assumed_init
 [`uninit_vec`]: https://rust-lang.github.io/rust-clippy/master/index.html#uninit_vec
 [`uninlined_format_args`]: https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 29c96a7d6da..4bccb7e7c76 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -679,6 +679,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::unicode::INVISIBLE_CHARACTERS_INFO,
     crate::unicode::NON_ASCII_LITERAL_INFO,
     crate::unicode::UNICODE_NOT_NFC_INFO,
+    crate::uninhabited_references::UNINHABITED_REFERENCES_INFO,
     crate::uninit_vec::UNINIT_VEC_INFO,
     crate::unit_return_expecting_ord::UNIT_RETURN_EXPECTING_ORD_INFO,
     crate::unit_types::LET_UNIT_VALUE_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 8560edbee76..f2b7375a742 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -326,6 +326,7 @@ mod tuple_array_conversions;
 mod types;
 mod undocumented_unsafe_blocks;
 mod unicode;
+mod uninhabited_references;
 mod uninit_vec;
 mod unit_return_expecting_ord;
 mod unit_types;
@@ -1071,6 +1072,7 @@ pub fn register_lints(store: &mut rustc_lint::LintStore, conf: &'static Conf) {
     store.register_late_pass(|_| Box::new(iter_over_hash_type::IterOverHashType));
     store.register_late_pass(|_| Box::new(impl_hash_with_borrow_str_and_bytes::ImplHashWithBorrowStrBytes));
     store.register_late_pass(|_| Box::new(repeat_vec_with_capacity::RepeatVecWithCapacity));
+    store.register_late_pass(|_| Box::new(uninhabited_references::UninhabitedReferences));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/uninhabited_references.rs b/clippy_lints/src/uninhabited_references.rs
new file mode 100644
index 00000000000..d41576cadad
--- /dev/null
+++ b/clippy_lints/src/uninhabited_references.rs
@@ -0,0 +1,84 @@
+use clippy_utils::diagnostics::span_lint;
+use rustc_hir::intravisit::FnKind;
+use rustc_hir::{Body, Expr, ExprKind, FnDecl, FnRetTy, TyKind, UnOp};
+use rustc_hir_analysis::hir_ty_to_ty;
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::lint::in_external_macro;
+use rustc_session::declare_lint_pass;
+use rustc_span::def_id::LocalDefId;
+use rustc_span::Span;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// It detects references to uninhabited types, such as `!` and
+    /// warns when those are either dereferenced or returned from a function.
+    ///
+    /// ### Why is this bad?
+    /// Dereferencing a reference to an uninhabited type would create
+    /// an instance of such a type, which cannot exist. This constitutes
+    /// undefined behaviour. Such a reference could have been created
+    /// by `unsafe` code.
+    ///
+    /// ### Example
+    /// The following function can return a reference to an uninhabited type
+    /// (`Infallible`) because it uses `unsafe` code to create it. However,
+    /// the user of such a function could dereference the return value and
+    /// trigger an undefined behavior from safe code.
+    ///
+    /// ```no_run
+    /// fn create_ref() -> &'static std::convert::Infallible {
+    ///     unsafe { std::mem::transmute(&()) }
+    /// }
+    /// ```
+    #[clippy::version = "1.76.0"]
+    pub UNINHABITED_REFERENCES,
+    suspicious,
+    "reference to uninhabited type"
+}
+
+declare_lint_pass!(UninhabitedReferences => [UNINHABITED_REFERENCES]);
+
+impl LateLintPass<'_> for UninhabitedReferences {
+    fn check_expr(&mut self, cx: &LateContext<'_>, expr: &'_ Expr<'_>) {
+        if in_external_macro(cx.tcx.sess, expr.span) {
+            return;
+        }
+
+        if let ExprKind::Unary(UnOp::Deref, _) = expr.kind {
+            let ty = cx.typeck_results().expr_ty_adjusted(expr);
+            if ty.is_privately_uninhabited(cx.tcx, cx.param_env) {
+                span_lint(
+                    cx,
+                    UNINHABITED_REFERENCES,
+                    expr.span,
+                    "dereferencing a reference to an uninhabited type is undefined behavior",
+                );
+            }
+        }
+    }
+
+    fn check_fn(
+        &mut self,
+        cx: &LateContext<'_>,
+        kind: FnKind<'_>,
+        fndecl: &'_ FnDecl<'_>,
+        _: &'_ Body<'_>,
+        span: Span,
+        _: LocalDefId,
+    ) {
+        if in_external_macro(cx.tcx.sess, span) || matches!(kind, FnKind::Closure) {
+            return;
+        }
+        if let FnRetTy::Return(hir_ty) = fndecl.output
+            && let TyKind::Ref(_, mut_ty) = hir_ty.kind
+            && hir_ty_to_ty(cx.tcx, mut_ty.ty).is_privately_uninhabited(cx.tcx, cx.param_env)
+        {
+            span_lint(
+                cx,
+                UNINHABITED_REFERENCES,
+                hir_ty.span,
+                "dereferencing a reference to an uninhabited type would be undefined behavior",
+            );
+        }
+    }
+}
diff --git a/tests/ui/infallible_destructuring_match.fixed b/tests/ui/infallible_destructuring_match.fixed
index 60304177b42..ecf1b14e5b6 100644
--- a/tests/ui/infallible_destructuring_match.fixed
+++ b/tests/ui/infallible_destructuring_match.fixed
@@ -1,6 +1,6 @@
 #![feature(exhaustive_patterns, never_type)]
 #![allow(dead_code, unreachable_code, unused_variables)]
-#![allow(clippy::let_and_return)]
+#![allow(clippy::let_and_return, clippy::uninhabited_references)]
 
 enum SingleVariantEnum {
     Variant(i32),
diff --git a/tests/ui/infallible_destructuring_match.rs b/tests/ui/infallible_destructuring_match.rs
index b77aac4a16c..7cc7cb9d687 100644
--- a/tests/ui/infallible_destructuring_match.rs
+++ b/tests/ui/infallible_destructuring_match.rs
@@ -1,6 +1,6 @@
 #![feature(exhaustive_patterns, never_type)]
 #![allow(dead_code, unreachable_code, unused_variables)]
-#![allow(clippy::let_and_return)]
+#![allow(clippy::let_and_return, clippy::uninhabited_references)]
 
 enum SingleVariantEnum {
     Variant(i32),
diff --git a/tests/ui/uninhabited_references.rs b/tests/ui/uninhabited_references.rs
new file mode 100644
index 00000000000..cd07b590a61
--- /dev/null
+++ b/tests/ui/uninhabited_references.rs
@@ -0,0 +1,22 @@
+#![warn(clippy::uninhabited_references)]
+#![feature(never_type)]
+
+fn ret_uninh_ref() -> &'static std::convert::Infallible {
+    unsafe { std::mem::transmute(&()) }
+}
+
+macro_rules! ret_something {
+    ($name:ident, $ty:ty) => {
+        fn $name(x: &$ty) -> &$ty {
+            &*x
+        }
+    };
+}
+
+ret_something!(id_u32, u32);
+ret_something!(id_never, !);
+
+fn main() {
+    let x = ret_uninh_ref();
+    let _ = *x;
+}
diff --git a/tests/ui/uninhabited_references.stderr b/tests/ui/uninhabited_references.stderr
new file mode 100644
index 00000000000..2cdf320b809
--- /dev/null
+++ b/tests/ui/uninhabited_references.stderr
@@ -0,0 +1,39 @@
+error: dereferencing a reference to an uninhabited type would be undefined behavior
+  --> $DIR/uninhabited_references.rs:4:23
+   |
+LL | fn ret_uninh_ref() -> &'static std::convert::Infallible {
+   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::uninhabited-references` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::uninhabited_references)]`
+
+error: dereferencing a reference to an uninhabited type would be undefined behavior
+  --> $DIR/uninhabited_references.rs:10:30
+   |
+LL |         fn $name(x: &$ty) -> &$ty {
+   |                              ^^^^
+...
+LL | ret_something!(id_never, !);
+   | --------------------------- in this macro invocation
+   |
+   = note: this error originates in the macro `ret_something` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: dereferencing a reference to an uninhabited type is undefined behavior
+  --> $DIR/uninhabited_references.rs:11:14
+   |
+LL |             &*x
+   |              ^^
+...
+LL | ret_something!(id_never, !);
+   | --------------------------- in this macro invocation
+   |
+   = note: this error originates in the macro `ret_something` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: dereferencing a reference to an uninhabited type is undefined behavior
+  --> $DIR/uninhabited_references.rs:21:13
+   |
+LL |     let _ = *x;
+   |             ^^
+
+error: aborting due to 4 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 9083b52122a2b57f0cfefa98e64846c110ade933 Mon Sep 17 00:00:00 2001
From: Jubilee Young <workingjubilee@gmail.com>
Date: Sat, 9 Dec 2023 14:07:25 -0800
Subject: Check $CARGO before $PATH

---
 clippy_dev/src/lint.rs                                      | 10 +++++++---
 clippy_dev/src/serve.rs                                     |  4 ++--
 clippy_lints/src/utils/internal_lints/metadata_collector.rs |  4 ++--
 lintcheck/src/main.rs                                       |  6 +++---
 src/main.rs                                                 |  2 +-
 5 files changed, 15 insertions(+), 11 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_dev/src/lint.rs b/clippy_dev/src/lint.rs
index a19be1bca6c..906a9727810 100644
--- a/clippy_dev/src/lint.rs
+++ b/clippy_dev/src/lint.rs
@@ -1,6 +1,6 @@
 use crate::{cargo_clippy_path, exit_if_err};
-use std::fs;
 use std::process::{self, Command};
+use std::{env, fs};
 
 pub fn run<'a>(path: &str, args: impl Iterator<Item = &'a String>) {
     let is_file = match fs::metadata(path) {
@@ -13,7 +13,7 @@ pub fn run<'a>(path: &str, args: impl Iterator<Item = &'a String>) {
 
     if is_file {
         exit_if_err(
-            Command::new("cargo")
+            Command::new(env::var("CARGO").unwrap_or("cargo".into()))
                 .args(["run", "--bin", "clippy-driver", "--"])
                 .args(["-L", "./target/debug"])
                 .args(["-Z", "no-codegen"])
@@ -23,7 +23,11 @@ pub fn run<'a>(path: &str, args: impl Iterator<Item = &'a String>) {
                 .status(),
         );
     } else {
-        exit_if_err(Command::new("cargo").arg("build").status());
+        exit_if_err(
+            Command::new(env::var("CARGO").unwrap_or("cargo".into()))
+                .arg("build")
+                .status(),
+        );
 
         let status = Command::new(cargo_clippy_path())
             .arg("clippy")
diff --git a/clippy_dev/src/serve.rs b/clippy_dev/src/serve.rs
index 535c25e69f1..ea925f6709f 100644
--- a/clippy_dev/src/serve.rs
+++ b/clippy_dev/src/serve.rs
@@ -2,8 +2,8 @@ use std::ffi::OsStr;
 use std::num::ParseIntError;
 use std::path::Path;
 use std::process::Command;
-use std::thread;
 use std::time::{Duration, SystemTime};
+use std::{env, thread};
 
 /// # Panics
 ///
@@ -16,7 +16,7 @@ pub fn run(port: u16, lint: Option<&String>) -> ! {
 
     loop {
         if mtime("util/gh-pages/lints.json") < mtime("clippy_lints/src") {
-            Command::new("cargo")
+            Command::new(env::var("CARGO").unwrap_or("cargo".into()))
                 .arg("collect-metadata")
                 .spawn()
                 .unwrap()
diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index 373b076f92c..fae1b90ace2 100644
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -28,12 +28,12 @@ use rustc_span::{sym, Loc, Span, Symbol};
 use serde::ser::SerializeStruct;
 use serde::{Serialize, Serializer};
 use std::collections::{BTreeSet, BinaryHeap};
-use std::fmt;
 use std::fmt::Write as _;
 use std::fs::{self, File};
 use std::io::prelude::*;
 use std::path::{Path, PathBuf};
 use std::process::Command;
+use std::{env, fmt};
 
 /// This is the json output file of the lint collector.
 const JSON_OUTPUT_FILE: &str = "../util/gh-pages/lints.json";
@@ -415,7 +415,7 @@ fn get_lint_output(lint_name: &str, example: &[&mut String], clippy_project_root
 
     let prefixed_name = format!("{CLIPPY_LINT_GROUP_PREFIX}{lint_name}");
 
-    let mut cmd = Command::new("cargo");
+    let mut cmd = Command::new(env::var("CARGO").unwrap_or("cargo".into()));
 
     cmd.current_dir(clippy_project_root)
         .env("CARGO_INCREMENTAL", "0")
diff --git a/lintcheck/src/main.rs b/lintcheck/src/main.rs
index 841b605f5fb..88966b41f69 100644
--- a/lintcheck/src/main.rs
+++ b/lintcheck/src/main.rs
@@ -367,7 +367,7 @@ impl Crate {
             //
             // The wrapper is set to the `lintcheck` so we can force enable linting and ignore certain crates
             // (see `crate::driver`)
-            let status = Command::new("cargo")
+            let status = Command::new(env::var("CARGO").unwrap_or("cargo".into()))
                 .arg("check")
                 .arg("--quiet")
                 .current_dir(&self.path)
@@ -441,7 +441,7 @@ impl Crate {
 
 /// Builds clippy inside the repo to make sure we have a clippy executable we can use.
 fn build_clippy() {
-    let status = Command::new("cargo")
+    let status = Command::new(env::var("CARGO").unwrap_or("cargo".into()))
         .arg("build")
         .status()
         .expect("Failed to build clippy!");
@@ -816,7 +816,7 @@ fn lintcheck_test() {
         "--crates-toml",
         "lintcheck/test_sources.toml",
     ];
-    let status = std::process::Command::new("cargo")
+    let status = std::process::Command::new(env::var("CARGO").unwrap_or("cargo".into()))
         .args(args)
         .current_dir("..") // repo root
         .status();
diff --git a/src/main.rs b/src/main.rs
index bbf7d22c850..dffa854177b 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -105,7 +105,7 @@ impl ClippyCmd {
     }
 
     fn into_std_cmd(self) -> Command {
-        let mut cmd = Command::new("cargo");
+        let mut cmd = Command::new(env::var("CARGO").unwrap_or("cargo".into()));
         let clippy_args: String = self
             .clippy_args
             .iter()
-- 
cgit 1.4.1-3-g733a5


From f3f2f17478e958885330e0716a63e7e60596515a Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Tue, 19 Sep 2023 16:32:05 -0400
Subject: Delay several `is_from_proc_macro` checks

---
 clippy_lints/src/as_conversions.rs                 |  9 ++++----
 clippy_lints/src/borrow_deref_ref.rs               |  4 +++-
 clippy_lints/src/manual_float_methods.rs           |  4 +++-
 clippy_lints/src/methods/unnecessary_lazy_eval.rs  |  6 +-----
 clippy_lints/src/needless_if.rs                    |  2 +-
 .../src/operators/arithmetic_side_effects.rs       | 25 ++++++++++++----------
 clippy_lints/src/single_call_fn.rs                 |  2 +-
 7 files changed, 27 insertions(+), 25 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/as_conversions.rs b/clippy_lints/src/as_conversions.rs
index e052d36f115..e3daf75c3eb 100644
--- a/clippy_lints/src/as_conversions.rs
+++ b/clippy_lints/src/as_conversions.rs
@@ -48,11 +48,10 @@ declare_lint_pass!(AsConversions => [AS_CONVERSIONS]);
 
 impl<'tcx> LateLintPass<'tcx> for AsConversions {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &Expr<'tcx>) {
-        if in_external_macro(cx.sess(), expr.span) || is_from_proc_macro(cx, expr) {
-            return;
-        }
-
-        if let ExprKind::Cast(_, _) = expr.kind {
+        if let ExprKind::Cast(_, _) = expr.kind
+            && !in_external_macro(cx.sess(), expr.span)
+            && !is_from_proc_macro(cx, expr)
+        {
             span_lint_and_help(
                 cx,
                 AS_CONVERSIONS,
diff --git a/clippy_lints/src/borrow_deref_ref.rs b/clippy_lints/src/borrow_deref_ref.rs
index d3d4f3c41c8..0ca4a0e067d 100644
--- a/clippy_lints/src/borrow_deref_ref.rs
+++ b/clippy_lints/src/borrow_deref_ref.rs
@@ -57,7 +57,6 @@ impl<'tcx> LateLintPass<'tcx> for BorrowDerefRef {
             && !matches!(deref_target.kind, ExprKind::Unary(UnOp::Deref, ..))
             && let ref_ty = cx.typeck_results().expr_ty(deref_target)
             && let ty::Ref(_, inner_ty, Mutability::Not) = ref_ty.kind()
-            && !is_from_proc_macro(cx, e)
         {
             if let Some(parent_expr) = get_parent_expr(cx, e) {
                 if matches!(parent_expr.kind, ExprKind::Unary(UnOp::Deref, ..))
@@ -75,6 +74,9 @@ impl<'tcx> LateLintPass<'tcx> for BorrowDerefRef {
                     return;
                 }
             }
+            if is_from_proc_macro(cx, e) {
+                return;
+            }
 
             span_lint_and_then(
                 cx,
diff --git a/clippy_lints/src/manual_float_methods.rs b/clippy_lints/src/manual_float_methods.rs
index 31cfb41640d..72cf1d7a354 100644
--- a/clippy_lints/src/manual_float_methods.rs
+++ b/clippy_lints/src/manual_float_methods.rs
@@ -105,7 +105,6 @@ impl<'tcx> LateLintPass<'tcx> for ManualFloatMethods {
             // case somebody does that for some reason
             && (is_infinity(const_1) && is_neg_infinity(const_2)
                 || is_neg_infinity(const_1) && is_infinity(const_2))
-            && !is_from_proc_macro(cx, expr)
             && let Some(local_snippet) = snippet_opt(cx, first.span)
         {
             let variant = match (kind.node, lhs_kind.node, rhs_kind.node) {
@@ -113,6 +112,9 @@ impl<'tcx> LateLintPass<'tcx> for ManualFloatMethods {
                 (BinOpKind::And, BinOpKind::Ne, BinOpKind::Ne) => Variant::ManualIsFinite,
                 _ => return,
             };
+            if is_from_proc_macro(cx, expr) {
+                return;
+            }
 
             span_lint_and_then(cx, variant.lint(), expr.span, variant.msg(), |diag| {
                 match variant {
diff --git a/clippy_lints/src/methods/unnecessary_lazy_eval.rs b/clippy_lints/src/methods/unnecessary_lazy_eval.rs
index 4a651396f14..4429f032605 100644
--- a/clippy_lints/src/methods/unnecessary_lazy_eval.rs
+++ b/clippy_lints/src/methods/unnecessary_lazy_eval.rs
@@ -19,10 +19,6 @@ pub(super) fn check<'tcx>(
     arg: &'tcx hir::Expr<'_>,
     simplify_using: &str,
 ) {
-    if is_from_proc_macro(cx, expr) {
-        return;
-    }
-
     let is_option = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(recv), sym::Option);
     let is_result = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(recv), sym::Result);
     let is_bool = cx.typeck_results().expr_ty(recv).is_bool();
@@ -32,7 +28,7 @@ pub(super) fn check<'tcx>(
             let body = cx.tcx.hir().body(body);
             let body_expr = &body.value;
 
-            if usage::BindingUsageFinder::are_params_used(cx, body) {
+            if usage::BindingUsageFinder::are_params_used(cx, body) || is_from_proc_macro(cx, expr) {
                 return;
             }
 
diff --git a/clippy_lints/src/needless_if.rs b/clippy_lints/src/needless_if.rs
index 41d05d72284..51bee4b51f6 100644
--- a/clippy_lints/src/needless_if.rs
+++ b/clippy_lints/src/needless_if.rs
@@ -44,7 +44,6 @@ impl LateLintPass<'_> for NeedlessIf {
             && block.stmts.is_empty()
             && block.expr.is_none()
             && !in_external_macro(cx.sess(), expr.span)
-            && !is_from_proc_macro(cx, expr)
             && let Some(then_snippet) = snippet_opt(cx, then.span)
             // Ignore
             // - empty macro expansions
@@ -53,6 +52,7 @@ impl LateLintPass<'_> for NeedlessIf {
             // - #[cfg]'d out code
             && then_snippet.chars().all(|ch| matches!(ch, '{' | '}') || ch.is_ascii_whitespace())
             && let Some(cond_snippet) = snippet_opt(cx, cond.span)
+            && !is_from_proc_macro(cx, expr)
         {
             span_lint_and_sugg(
                 cx,
diff --git a/clippy_lints/src/operators/arithmetic_side_effects.rs b/clippy_lints/src/operators/arithmetic_side_effects.rs
index 1a2b20bf438..c081dec9b6b 100644
--- a/clippy_lints/src/operators/arithmetic_side_effects.rs
+++ b/clippy_lints/src/operators/arithmetic_side_effects.rs
@@ -132,7 +132,11 @@ impl ArithmeticSideEffects {
     }
 
     // Common entry-point to avoid code duplication.
-    fn issue_lint(&mut self, cx: &LateContext<'_>, expr: &hir::Expr<'_>) {
+    fn issue_lint<'tcx>(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
+        if is_from_proc_macro(cx, expr) {
+            return;
+        }
+
         let msg = "arithmetic operation that can potentially result in unexpected side-effects";
         span_lint(cx, ARITHMETIC_SIDE_EFFECTS, expr.span, msg);
         self.expr_span = Some(expr.span);
@@ -160,10 +164,10 @@ impl ArithmeticSideEffects {
     fn manage_bin_ops<'tcx>(
         &mut self,
         cx: &LateContext<'tcx>,
-        expr: &hir::Expr<'tcx>,
+        expr: &'tcx hir::Expr<'_>,
         op: &Spanned<hir::BinOpKind>,
-        lhs: &hir::Expr<'tcx>,
-        rhs: &hir::Expr<'tcx>,
+        lhs: &'tcx hir::Expr<'_>,
+        rhs: &'tcx hir::Expr<'_>,
     ) {
         if constant_simple(cx, cx.typeck_results(), expr).is_some() {
             return;
@@ -236,10 +240,10 @@ impl ArithmeticSideEffects {
     /// provided input.
     fn manage_method_call<'tcx>(
         &mut self,
-        args: &[hir::Expr<'tcx>],
+        args: &'tcx [hir::Expr<'_>],
         cx: &LateContext<'tcx>,
-        ps: &hir::PathSegment<'tcx>,
-        receiver: &hir::Expr<'tcx>,
+        ps: &'tcx hir::PathSegment<'_>,
+        receiver: &'tcx hir::Expr<'_>,
     ) {
         let Some(arg) = args.first() else {
             return;
@@ -264,8 +268,8 @@ impl ArithmeticSideEffects {
     fn manage_unary_ops<'tcx>(
         &mut self,
         cx: &LateContext<'tcx>,
-        expr: &hir::Expr<'tcx>,
-        un_expr: &hir::Expr<'tcx>,
+        expr: &'tcx hir::Expr<'_>,
+        un_expr: &'tcx hir::Expr<'_>,
         un_op: hir::UnOp,
     ) {
         let hir::UnOp::Neg = un_op else {
@@ -287,14 +291,13 @@ impl ArithmeticSideEffects {
 
     fn should_skip_expr<'tcx>(&mut self, cx: &LateContext<'tcx>, expr: &hir::Expr<'tcx>) -> bool {
         is_lint_allowed(cx, ARITHMETIC_SIDE_EFFECTS, expr.hir_id)
-            || is_from_proc_macro(cx, expr)
             || self.expr_span.is_some()
             || self.const_span.map_or(false, |sp| sp.contains(expr.span))
     }
 }
 
 impl<'tcx> LateLintPass<'tcx> for ArithmeticSideEffects {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &hir::Expr<'tcx>) {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'tcx>) {
         if self.should_skip_expr(cx, expr) {
             return;
         }
diff --git a/clippy_lints/src/single_call_fn.rs b/clippy_lints/src/single_call_fn.rs
index 396d2717a13..8e181c3ccc7 100644
--- a/clippy_lints/src/single_call_fn.rs
+++ b/clippy_lints/src/single_call_fn.rs
@@ -72,8 +72,8 @@ impl<'tcx> LateLintPass<'tcx> for SingleCallFn {
     ) {
         if self.avoid_breaking_exported_api && cx.effective_visibilities.is_exported(def_id)
             || in_external_macro(cx.sess(), span)
-            || is_from_proc_macro(cx, &(&kind, body, cx.tcx.local_def_id_to_hir_id(def_id), span))
             || is_in_test_function(cx.tcx, body.value.hir_id)
+            || is_from_proc_macro(cx, &(&kind, body, cx.tcx.local_def_id_to_hir_id(def_id), span))
         {
             return;
         }
-- 
cgit 1.4.1-3-g733a5


From 27c5b21fb653d8fab29f920cdc0a922ce34534a4 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Mon, 11 Dec 2023 10:46:14 -0500
Subject: Fix binder handling in `unnecessary_to_owned`

---
 clippy_lints/src/methods/unnecessary_to_owned.rs |  31 ++--
 tests/ui/unnecessary_to_owned.fixed              |  23 ++-
 tests/ui/unnecessary_to_owned.rs                 |  23 ++-
 tests/ui/unnecessary_to_owned.stderr             | 176 ++++++++++++-----------
 4 files changed, 150 insertions(+), 103 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/unnecessary_to_owned.rs b/clippy_lints/src/methods/unnecessary_to_owned.rs
index 395b22ebc5d..c4775b6bd04 100644
--- a/clippy_lints/src/methods/unnecessary_to_owned.rs
+++ b/clippy_lints/src/methods/unnecessary_to_owned.rs
@@ -15,8 +15,7 @@ use rustc_lint::LateContext;
 use rustc_middle::mir::Mutability;
 use rustc_middle::ty::adjustment::{Adjust, Adjustment, OverloadedDeref};
 use rustc_middle::ty::{
-    self, ClauseKind, EarlyBinder, GenericArg, GenericArgKind, GenericArgsRef, ParamTy, ProjectionPredicate,
-    TraitPredicate, Ty,
+    self, ClauseKind, GenericArg, GenericArgKind, GenericArgsRef, ParamTy, ProjectionPredicate, TraitPredicate, Ty,
 };
 use rustc_span::{sym, Symbol};
 use rustc_trait_selection::traits::query::evaluate_obligation::InferCtxtExt as _;
@@ -359,6 +358,7 @@ fn get_input_traits_and_projections<'tcx>(
     (trait_predicates, projection_predicates)
 }
 
+#[expect(clippy::too_many_lines)]
 fn can_change_type<'a>(cx: &LateContext<'a>, mut expr: &'a Expr<'a>, mut ty: Ty<'a>) -> bool {
     for (_, node) in cx.tcx.hir().parent_iter(expr.hir_id) {
         match node {
@@ -387,22 +387,21 @@ fn can_change_type<'a>(cx: &LateContext<'a>, mut expr: &'a Expr<'a>, mut ty: Ty<
                 if let Some((callee_def_id, call_generic_args, recv, call_args)) =
                     get_callee_generic_args_and_args(cx, parent_expr)
                 {
-                    // FIXME: the `instantiate_identity()` below seems incorrect, since we eventually
-                    // call `tcx.try_instantiate_and_normalize_erasing_regions` further down
-                    // (i.e., we are explicitly not in the identity context).
-                    let fn_sig = cx.tcx.fn_sig(callee_def_id).instantiate_identity().skip_binder();
+                    let bound_fn_sig = cx.tcx.fn_sig(callee_def_id);
+                    let fn_sig = bound_fn_sig.skip_binder();
                     if let Some(arg_index) = recv.into_iter().chain(call_args).position(|arg| arg.hir_id == expr.hir_id)
-                        && let Some(param_ty) = fn_sig.inputs().get(arg_index)
-                        && let ty::Param(ParamTy { index: param_index , ..}) = param_ty.kind()
+                        && let param_ty = fn_sig.input(arg_index).skip_binder()
+                        && let ty::Param(ParamTy { index: param_index , ..}) = *param_ty.kind()
                         // https://github.com/rust-lang/rust-clippy/issues/9504 and https://github.com/rust-lang/rust-clippy/issues/10021
-                        && (*param_index as usize) < call_generic_args.len()
+                        && (param_index as usize) < call_generic_args.len()
                     {
                         if fn_sig
+                            .skip_binder()
                             .inputs()
                             .iter()
                             .enumerate()
                             .filter(|(i, _)| *i != arg_index)
-                            .any(|(_, ty)| ty.contains(*param_ty))
+                            .any(|(_, ty)| ty.contains(param_ty))
                         {
                             return false;
                         }
@@ -414,7 +413,7 @@ fn can_change_type<'a>(cx: &LateContext<'a>, mut expr: &'a Expr<'a>, mut ty: Ty<
                                 .iter()
                                 .filter(|predicate| {
                                     if let ClauseKind::Trait(trait_predicate) = predicate.kind().skip_binder()
-                                        && trait_predicate.trait_ref.self_ty() == *param_ty
+                                        && trait_predicate.trait_ref.self_ty() == param_ty
                                     {
                                         true
                                     } else {
@@ -425,7 +424,7 @@ fn can_change_type<'a>(cx: &LateContext<'a>, mut expr: &'a Expr<'a>, mut ty: Ty<
                         let new_subst = cx
                             .tcx
                             .mk_args_from_iter(call_generic_args.iter().enumerate().map(|(i, t)| {
-                                if i == (*param_index as usize) {
+                                if i == param_index as usize {
                                     GenericArg::from(ty)
                                 } else {
                                     t
@@ -433,7 +432,7 @@ fn can_change_type<'a>(cx: &LateContext<'a>, mut expr: &'a Expr<'a>, mut ty: Ty<
                             }));
 
                         if trait_predicates.any(|predicate| {
-                            let predicate = EarlyBinder::bind(predicate).instantiate(cx.tcx, new_subst);
+                            let predicate = bound_fn_sig.rebind(predicate).instantiate(cx.tcx, new_subst);
                             let obligation = Obligation::new(cx.tcx, ObligationCause::dummy(), cx.param_env, predicate);
                             !cx.tcx
                                 .infer_ctxt()
@@ -443,12 +442,12 @@ fn can_change_type<'a>(cx: &LateContext<'a>, mut expr: &'a Expr<'a>, mut ty: Ty<
                             return false;
                         }
 
-                        let output_ty = fn_sig.output();
-                        if output_ty.contains(*param_ty) {
+                        let output_ty = cx.tcx.instantiate_bound_regions_with_erased(fn_sig.output());
+                        if output_ty.contains(param_ty) {
                             if let Ok(new_ty) = cx.tcx.try_instantiate_and_normalize_erasing_regions(
                                 new_subst,
                                 cx.param_env,
-                                EarlyBinder::bind(output_ty),
+                                bound_fn_sig.rebind(output_ty),
                             ) {
                                 expr = parent_expr;
                                 ty = new_ty;
diff --git a/tests/ui/unnecessary_to_owned.fixed b/tests/ui/unnecessary_to_owned.fixed
index 67faabc53cb..2dd1d746626 100644
--- a/tests/ui/unnecessary_to_owned.fixed
+++ b/tests/ui/unnecessary_to_owned.fixed
@@ -1,4 +1,10 @@
-#![allow(clippy::needless_borrow, clippy::needless_borrows_for_generic_args, clippy::ptr_arg)]
+#![allow(
+    clippy::needless_borrow,
+    clippy::needless_borrows_for_generic_args,
+    clippy::ptr_arg,
+    clippy::manual_async_fn,
+    clippy::needless_lifetimes
+)]
 #![warn(clippy::unnecessary_to_owned, clippy::redundant_clone)]
 
 use std::borrow::Cow;
@@ -506,3 +512,18 @@ mod issue_10033 {
         }
     }
 }
+
+mod issue_11952 {
+    use core::future::{Future, IntoFuture};
+
+    fn foo<'a, T: AsRef<[u8]>>(x: T, y: &'a i32) -> impl 'a + Future<Output = Result<(), ()>> {
+        async move {
+            let _y = y;
+            Ok(())
+        }
+    }
+
+    fn bar() {
+        IntoFuture::into_future(foo([], &0));
+    }
+}
diff --git a/tests/ui/unnecessary_to_owned.rs b/tests/ui/unnecessary_to_owned.rs
index 99f9136427d..17fad33402b 100644
--- a/tests/ui/unnecessary_to_owned.rs
+++ b/tests/ui/unnecessary_to_owned.rs
@@ -1,4 +1,10 @@
-#![allow(clippy::needless_borrow, clippy::needless_borrows_for_generic_args, clippy::ptr_arg)]
+#![allow(
+    clippy::needless_borrow,
+    clippy::needless_borrows_for_generic_args,
+    clippy::ptr_arg,
+    clippy::manual_async_fn,
+    clippy::needless_lifetimes
+)]
 #![warn(clippy::unnecessary_to_owned, clippy::redundant_clone)]
 
 use std::borrow::Cow;
@@ -506,3 +512,18 @@ mod issue_10033 {
         }
     }
 }
+
+mod issue_11952 {
+    use core::future::{Future, IntoFuture};
+
+    fn foo<'a, T: AsRef<[u8]>>(x: T, y: &'a i32) -> impl 'a + Future<Output = Result<(), ()>> {
+        async move {
+            let _y = y;
+            Ok(())
+        }
+    }
+
+    fn bar() {
+        IntoFuture::into_future(foo([].to_vec(), &0));
+    }
+}
diff --git a/tests/ui/unnecessary_to_owned.stderr b/tests/ui/unnecessary_to_owned.stderr
index d8971b51dca..ad6fa422b8c 100644
--- a/tests/ui/unnecessary_to_owned.stderr
+++ b/tests/ui/unnecessary_to_owned.stderr
@@ -1,11 +1,11 @@
 error: redundant clone
-  --> $DIR/unnecessary_to_owned.rs:148:64
+  --> $DIR/unnecessary_to_owned.rs:154:64
    |
 LL |     require_c_str(&CString::from_vec_with_nul(vec![0]).unwrap().to_owned());
    |                                                                ^^^^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> $DIR/unnecessary_to_owned.rs:148:20
+  --> $DIR/unnecessary_to_owned.rs:154:20
    |
 LL |     require_c_str(&CString::from_vec_with_nul(vec![0]).unwrap().to_owned());
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -13,55 +13,55 @@ LL |     require_c_str(&CString::from_vec_with_nul(vec![0]).unwrap().to_owned())
    = help: to override `-D warnings` add `#[allow(clippy::redundant_clone)]`
 
 error: redundant clone
-  --> $DIR/unnecessary_to_owned.rs:149:40
+  --> $DIR/unnecessary_to_owned.rs:155:40
    |
 LL |     require_os_str(&OsString::from("x").to_os_string());
    |                                        ^^^^^^^^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> $DIR/unnecessary_to_owned.rs:149:21
+  --> $DIR/unnecessary_to_owned.rs:155:21
    |
 LL |     require_os_str(&OsString::from("x").to_os_string());
    |                     ^^^^^^^^^^^^^^^^^^^
 
 error: redundant clone
-  --> $DIR/unnecessary_to_owned.rs:150:48
+  --> $DIR/unnecessary_to_owned.rs:156:48
    |
 LL |     require_path(&std::path::PathBuf::from("x").to_path_buf());
    |                                                ^^^^^^^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> $DIR/unnecessary_to_owned.rs:150:19
+  --> $DIR/unnecessary_to_owned.rs:156:19
    |
 LL |     require_path(&std::path::PathBuf::from("x").to_path_buf());
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: redundant clone
-  --> $DIR/unnecessary_to_owned.rs:151:35
+  --> $DIR/unnecessary_to_owned.rs:157:35
    |
 LL |     require_str(&String::from("x").to_string());
    |                                   ^^^^^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> $DIR/unnecessary_to_owned.rs:151:18
+  --> $DIR/unnecessary_to_owned.rs:157:18
    |
 LL |     require_str(&String::from("x").to_string());
    |                  ^^^^^^^^^^^^^^^^^
 
 error: redundant clone
-  --> $DIR/unnecessary_to_owned.rs:152:39
+  --> $DIR/unnecessary_to_owned.rs:158:39
    |
 LL |     require_slice(&[String::from("x")].to_owned());
    |                                       ^^^^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> $DIR/unnecessary_to_owned.rs:152:20
+  --> $DIR/unnecessary_to_owned.rs:158:20
    |
 LL |     require_slice(&[String::from("x")].to_owned());
    |                    ^^^^^^^^^^^^^^^^^^^
 
 error: unnecessary use of `into_owned`
-  --> $DIR/unnecessary_to_owned.rs:57:36
+  --> $DIR/unnecessary_to_owned.rs:63:36
    |
 LL |     require_c_str(&Cow::from(c_str).into_owned());
    |                                    ^^^^^^^^^^^^^ help: remove this
@@ -70,415 +70,415 @@ LL |     require_c_str(&Cow::from(c_str).into_owned());
    = help: to override `-D warnings` add `#[allow(clippy::unnecessary_to_owned)]`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:58:19
+  --> $DIR/unnecessary_to_owned.rs:64:19
    |
 LL |     require_c_str(&c_str.to_owned());
    |                   ^^^^^^^^^^^^^^^^^ help: use: `c_str`
 
 error: unnecessary use of `to_os_string`
-  --> $DIR/unnecessary_to_owned.rs:60:20
+  --> $DIR/unnecessary_to_owned.rs:66:20
    |
 LL |     require_os_str(&os_str.to_os_string());
    |                    ^^^^^^^^^^^^^^^^^^^^^^ help: use: `os_str`
 
 error: unnecessary use of `into_owned`
-  --> $DIR/unnecessary_to_owned.rs:61:38
+  --> $DIR/unnecessary_to_owned.rs:67:38
    |
 LL |     require_os_str(&Cow::from(os_str).into_owned());
    |                                      ^^^^^^^^^^^^^ help: remove this
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:62:20
+  --> $DIR/unnecessary_to_owned.rs:68:20
    |
 LL |     require_os_str(&os_str.to_owned());
    |                    ^^^^^^^^^^^^^^^^^^ help: use: `os_str`
 
 error: unnecessary use of `to_path_buf`
-  --> $DIR/unnecessary_to_owned.rs:64:18
+  --> $DIR/unnecessary_to_owned.rs:70:18
    |
 LL |     require_path(&path.to_path_buf());
    |                  ^^^^^^^^^^^^^^^^^^^ help: use: `path`
 
 error: unnecessary use of `into_owned`
-  --> $DIR/unnecessary_to_owned.rs:65:34
+  --> $DIR/unnecessary_to_owned.rs:71:34
    |
 LL |     require_path(&Cow::from(path).into_owned());
    |                                  ^^^^^^^^^^^^^ help: remove this
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:66:18
+  --> $DIR/unnecessary_to_owned.rs:72:18
    |
 LL |     require_path(&path.to_owned());
    |                  ^^^^^^^^^^^^^^^^ help: use: `path`
 
 error: unnecessary use of `to_string`
-  --> $DIR/unnecessary_to_owned.rs:68:17
+  --> $DIR/unnecessary_to_owned.rs:74:17
    |
 LL |     require_str(&s.to_string());
    |                 ^^^^^^^^^^^^^^ help: use: `s`
 
 error: unnecessary use of `into_owned`
-  --> $DIR/unnecessary_to_owned.rs:69:30
+  --> $DIR/unnecessary_to_owned.rs:75:30
    |
 LL |     require_str(&Cow::from(s).into_owned());
    |                              ^^^^^^^^^^^^^ help: remove this
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:70:17
+  --> $DIR/unnecessary_to_owned.rs:76:17
    |
 LL |     require_str(&s.to_owned());
    |                 ^^^^^^^^^^^^^ help: use: `s`
 
 error: unnecessary use of `to_string`
-  --> $DIR/unnecessary_to_owned.rs:71:17
+  --> $DIR/unnecessary_to_owned.rs:77:17
    |
 LL |     require_str(&x_ref.to_string());
    |                 ^^^^^^^^^^^^^^^^^^ help: use: `x_ref.as_ref()`
 
 error: unnecessary use of `to_vec`
-  --> $DIR/unnecessary_to_owned.rs:73:19
+  --> $DIR/unnecessary_to_owned.rs:79:19
    |
 LL |     require_slice(&slice.to_vec());
    |                   ^^^^^^^^^^^^^^^ help: use: `slice`
 
 error: unnecessary use of `into_owned`
-  --> $DIR/unnecessary_to_owned.rs:74:36
+  --> $DIR/unnecessary_to_owned.rs:80:36
    |
 LL |     require_slice(&Cow::from(slice).into_owned());
    |                                    ^^^^^^^^^^^^^ help: remove this
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:75:19
+  --> $DIR/unnecessary_to_owned.rs:81:19
    |
 LL |     require_slice(&array.to_owned());
    |                   ^^^^^^^^^^^^^^^^^ help: use: `array.as_ref()`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:76:19
+  --> $DIR/unnecessary_to_owned.rs:82:19
    |
 LL |     require_slice(&array_ref.to_owned());
    |                   ^^^^^^^^^^^^^^^^^^^^^ help: use: `array_ref.as_ref()`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:77:19
+  --> $DIR/unnecessary_to_owned.rs:83:19
    |
 LL |     require_slice(&slice.to_owned());
    |                   ^^^^^^^^^^^^^^^^^ help: use: `slice`
 
 error: unnecessary use of `into_owned`
-  --> $DIR/unnecessary_to_owned.rs:80:42
+  --> $DIR/unnecessary_to_owned.rs:86:42
    |
 LL |     require_x(&Cow::<X>::Owned(x.clone()).into_owned());
    |                                          ^^^^^^^^^^^^^ help: remove this
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:83:25
+  --> $DIR/unnecessary_to_owned.rs:89:25
    |
 LL |     require_deref_c_str(c_str.to_owned());
    |                         ^^^^^^^^^^^^^^^^ help: use: `c_str`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:84:26
+  --> $DIR/unnecessary_to_owned.rs:90:26
    |
 LL |     require_deref_os_str(os_str.to_owned());
    |                          ^^^^^^^^^^^^^^^^^ help: use: `os_str`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:85:24
+  --> $DIR/unnecessary_to_owned.rs:91:24
    |
 LL |     require_deref_path(path.to_owned());
    |                        ^^^^^^^^^^^^^^^ help: use: `path`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:86:23
+  --> $DIR/unnecessary_to_owned.rs:92:23
    |
 LL |     require_deref_str(s.to_owned());
    |                       ^^^^^^^^^^^^ help: use: `s`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:87:25
+  --> $DIR/unnecessary_to_owned.rs:93:25
    |
 LL |     require_deref_slice(slice.to_owned());
    |                         ^^^^^^^^^^^^^^^^ help: use: `slice`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:89:30
+  --> $DIR/unnecessary_to_owned.rs:95:30
    |
 LL |     require_impl_deref_c_str(c_str.to_owned());
    |                              ^^^^^^^^^^^^^^^^ help: use: `c_str`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:90:31
+  --> $DIR/unnecessary_to_owned.rs:96:31
    |
 LL |     require_impl_deref_os_str(os_str.to_owned());
    |                               ^^^^^^^^^^^^^^^^^ help: use: `os_str`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:91:29
+  --> $DIR/unnecessary_to_owned.rs:97:29
    |
 LL |     require_impl_deref_path(path.to_owned());
    |                             ^^^^^^^^^^^^^^^ help: use: `path`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:92:28
+  --> $DIR/unnecessary_to_owned.rs:98:28
    |
 LL |     require_impl_deref_str(s.to_owned());
    |                            ^^^^^^^^^^^^ help: use: `s`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:93:30
+  --> $DIR/unnecessary_to_owned.rs:99:30
    |
 LL |     require_impl_deref_slice(slice.to_owned());
    |                              ^^^^^^^^^^^^^^^^ help: use: `slice`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:95:29
+  --> $DIR/unnecessary_to_owned.rs:101:29
    |
 LL |     require_deref_str_slice(s.to_owned(), slice.to_owned());
    |                             ^^^^^^^^^^^^ help: use: `s`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:95:43
+  --> $DIR/unnecessary_to_owned.rs:101:43
    |
 LL |     require_deref_str_slice(s.to_owned(), slice.to_owned());
    |                                           ^^^^^^^^^^^^^^^^ help: use: `slice`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:96:29
+  --> $DIR/unnecessary_to_owned.rs:102:29
    |
 LL |     require_deref_slice_str(slice.to_owned(), s.to_owned());
    |                             ^^^^^^^^^^^^^^^^ help: use: `slice`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:96:47
+  --> $DIR/unnecessary_to_owned.rs:102:47
    |
 LL |     require_deref_slice_str(slice.to_owned(), s.to_owned());
    |                                               ^^^^^^^^^^^^ help: use: `s`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:98:26
+  --> $DIR/unnecessary_to_owned.rs:104:26
    |
 LL |     require_as_ref_c_str(c_str.to_owned());
    |                          ^^^^^^^^^^^^^^^^ help: use: `c_str`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:99:27
+  --> $DIR/unnecessary_to_owned.rs:105:27
    |
 LL |     require_as_ref_os_str(os_str.to_owned());
    |                           ^^^^^^^^^^^^^^^^^ help: use: `os_str`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:100:25
+  --> $DIR/unnecessary_to_owned.rs:106:25
    |
 LL |     require_as_ref_path(path.to_owned());
    |                         ^^^^^^^^^^^^^^^ help: use: `path`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:101:24
+  --> $DIR/unnecessary_to_owned.rs:107:24
    |
 LL |     require_as_ref_str(s.to_owned());
    |                        ^^^^^^^^^^^^ help: use: `s`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:102:24
+  --> $DIR/unnecessary_to_owned.rs:108:24
    |
 LL |     require_as_ref_str(x.to_owned());
    |                        ^^^^^^^^^^^^ help: use: `&x`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:103:26
+  --> $DIR/unnecessary_to_owned.rs:109:26
    |
 LL |     require_as_ref_slice(array.to_owned());
    |                          ^^^^^^^^^^^^^^^^ help: use: `array`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:104:26
+  --> $DIR/unnecessary_to_owned.rs:110:26
    |
 LL |     require_as_ref_slice(array_ref.to_owned());
    |                          ^^^^^^^^^^^^^^^^^^^^ help: use: `array_ref`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:105:26
+  --> $DIR/unnecessary_to_owned.rs:111:26
    |
 LL |     require_as_ref_slice(slice.to_owned());
    |                          ^^^^^^^^^^^^^^^^ help: use: `slice`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:107:31
+  --> $DIR/unnecessary_to_owned.rs:113:31
    |
 LL |     require_impl_as_ref_c_str(c_str.to_owned());
    |                               ^^^^^^^^^^^^^^^^ help: use: `c_str`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:108:32
+  --> $DIR/unnecessary_to_owned.rs:114:32
    |
 LL |     require_impl_as_ref_os_str(os_str.to_owned());
    |                                ^^^^^^^^^^^^^^^^^ help: use: `os_str`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:109:30
+  --> $DIR/unnecessary_to_owned.rs:115:30
    |
 LL |     require_impl_as_ref_path(path.to_owned());
    |                              ^^^^^^^^^^^^^^^ help: use: `path`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:110:29
+  --> $DIR/unnecessary_to_owned.rs:116:29
    |
 LL |     require_impl_as_ref_str(s.to_owned());
    |                             ^^^^^^^^^^^^ help: use: `s`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:111:29
+  --> $DIR/unnecessary_to_owned.rs:117:29
    |
 LL |     require_impl_as_ref_str(x.to_owned());
    |                             ^^^^^^^^^^^^ help: use: `&x`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:112:31
+  --> $DIR/unnecessary_to_owned.rs:118:31
    |
 LL |     require_impl_as_ref_slice(array.to_owned());
    |                               ^^^^^^^^^^^^^^^^ help: use: `array`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:113:31
+  --> $DIR/unnecessary_to_owned.rs:119:31
    |
 LL |     require_impl_as_ref_slice(array_ref.to_owned());
    |                               ^^^^^^^^^^^^^^^^^^^^ help: use: `array_ref`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:114:31
+  --> $DIR/unnecessary_to_owned.rs:120:31
    |
 LL |     require_impl_as_ref_slice(slice.to_owned());
    |                               ^^^^^^^^^^^^^^^^ help: use: `slice`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:116:30
+  --> $DIR/unnecessary_to_owned.rs:122:30
    |
 LL |     require_as_ref_str_slice(s.to_owned(), array.to_owned());
    |                              ^^^^^^^^^^^^ help: use: `s`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:116:44
+  --> $DIR/unnecessary_to_owned.rs:122:44
    |
 LL |     require_as_ref_str_slice(s.to_owned(), array.to_owned());
    |                                            ^^^^^^^^^^^^^^^^ help: use: `array`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:117:30
+  --> $DIR/unnecessary_to_owned.rs:123:30
    |
 LL |     require_as_ref_str_slice(s.to_owned(), array_ref.to_owned());
    |                              ^^^^^^^^^^^^ help: use: `s`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:117:44
+  --> $DIR/unnecessary_to_owned.rs:123:44
    |
 LL |     require_as_ref_str_slice(s.to_owned(), array_ref.to_owned());
    |                                            ^^^^^^^^^^^^^^^^^^^^ help: use: `array_ref`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:118:30
+  --> $DIR/unnecessary_to_owned.rs:124:30
    |
 LL |     require_as_ref_str_slice(s.to_owned(), slice.to_owned());
    |                              ^^^^^^^^^^^^ help: use: `s`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:118:44
+  --> $DIR/unnecessary_to_owned.rs:124:44
    |
 LL |     require_as_ref_str_slice(s.to_owned(), slice.to_owned());
    |                                            ^^^^^^^^^^^^^^^^ help: use: `slice`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:119:30
+  --> $DIR/unnecessary_to_owned.rs:125:30
    |
 LL |     require_as_ref_slice_str(array.to_owned(), s.to_owned());
    |                              ^^^^^^^^^^^^^^^^ help: use: `array`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:119:48
+  --> $DIR/unnecessary_to_owned.rs:125:48
    |
 LL |     require_as_ref_slice_str(array.to_owned(), s.to_owned());
    |                                                ^^^^^^^^^^^^ help: use: `s`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:120:30
+  --> $DIR/unnecessary_to_owned.rs:126:30
    |
 LL |     require_as_ref_slice_str(array_ref.to_owned(), s.to_owned());
    |                              ^^^^^^^^^^^^^^^^^^^^ help: use: `array_ref`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:120:52
+  --> $DIR/unnecessary_to_owned.rs:126:52
    |
 LL |     require_as_ref_slice_str(array_ref.to_owned(), s.to_owned());
    |                                                    ^^^^^^^^^^^^ help: use: `s`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:121:30
+  --> $DIR/unnecessary_to_owned.rs:127:30
    |
 LL |     require_as_ref_slice_str(slice.to_owned(), s.to_owned());
    |                              ^^^^^^^^^^^^^^^^ help: use: `slice`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:121:48
+  --> $DIR/unnecessary_to_owned.rs:127:48
    |
 LL |     require_as_ref_slice_str(slice.to_owned(), s.to_owned());
    |                                                ^^^^^^^^^^^^ help: use: `s`
 
 error: unnecessary use of `to_string`
-  --> $DIR/unnecessary_to_owned.rs:123:20
+  --> $DIR/unnecessary_to_owned.rs:129:20
    |
 LL |     let _ = x.join(&x_ref.to_string());
    |                    ^^^^^^^^^^^^^^^^^^ help: use: `x_ref`
 
 error: unnecessary use of `to_vec`
-  --> $DIR/unnecessary_to_owned.rs:125:13
+  --> $DIR/unnecessary_to_owned.rs:131:13
    |
 LL |     let _ = slice.to_vec().into_iter();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `slice.iter().copied()`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:126:13
+  --> $DIR/unnecessary_to_owned.rs:132:13
    |
 LL |     let _ = slice.to_owned().into_iter();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `slice.iter().copied()`
 
 error: unnecessary use of `to_vec`
-  --> $DIR/unnecessary_to_owned.rs:127:13
+  --> $DIR/unnecessary_to_owned.rs:133:13
    |
 LL |     let _ = [std::path::PathBuf::new()][..].to_vec().into_iter();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `[std::path::PathBuf::new()][..].iter().cloned()`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:128:13
+  --> $DIR/unnecessary_to_owned.rs:134:13
    |
 LL |     let _ = [std::path::PathBuf::new()][..].to_owned().into_iter();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `[std::path::PathBuf::new()][..].iter().cloned()`
 
 error: unnecessary use of `to_vec`
-  --> $DIR/unnecessary_to_owned.rs:130:13
+  --> $DIR/unnecessary_to_owned.rs:136:13
    |
 LL |     let _ = IntoIterator::into_iter(slice.to_vec());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `slice.iter().copied()`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:131:13
+  --> $DIR/unnecessary_to_owned.rs:137:13
    |
 LL |     let _ = IntoIterator::into_iter(slice.to_owned());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `slice.iter().copied()`
 
 error: unnecessary use of `to_vec`
-  --> $DIR/unnecessary_to_owned.rs:132:13
+  --> $DIR/unnecessary_to_owned.rs:138:13
    |
 LL |     let _ = IntoIterator::into_iter([std::path::PathBuf::new()][..].to_vec());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `[std::path::PathBuf::new()][..].iter().cloned()`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:133:13
+  --> $DIR/unnecessary_to_owned.rs:139:13
    |
 LL |     let _ = IntoIterator::into_iter([std::path::PathBuf::new()][..].to_owned());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `[std::path::PathBuf::new()][..].iter().cloned()`
 
 error: unnecessary use of `to_vec`
-  --> $DIR/unnecessary_to_owned.rs:195:14
+  --> $DIR/unnecessary_to_owned.rs:201:14
    |
 LL |     for t in file_types.to_vec() {
    |              ^^^^^^^^^^^^^^^^^^^
@@ -494,28 +494,34 @@ LL +         let path = match get_file_path(t) {
    |
 
 error: unnecessary use of `to_vec`
-  --> $DIR/unnecessary_to_owned.rs:218:14
+  --> $DIR/unnecessary_to_owned.rs:224:14
    |
 LL |     let _ = &["x"][..].to_vec().into_iter();
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `["x"][..].iter().cloned()`
 
 error: unnecessary use of `to_vec`
-  --> $DIR/unnecessary_to_owned.rs:223:14
+  --> $DIR/unnecessary_to_owned.rs:229:14
    |
 LL |     let _ = &["x"][..].to_vec().into_iter();
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `["x"][..].iter().copied()`
 
 error: unnecessary use of `to_string`
-  --> $DIR/unnecessary_to_owned.rs:270:24
+  --> $DIR/unnecessary_to_owned.rs:276:24
    |
 LL |         Box::new(build(y.to_string()))
    |                        ^^^^^^^^^^^^^ help: use: `y`
 
 error: unnecessary use of `to_string`
-  --> $DIR/unnecessary_to_owned.rs:378:12
+  --> $DIR/unnecessary_to_owned.rs:384:12
    |
 LL |         id("abc".to_string())
    |            ^^^^^^^^^^^^^^^^^ help: use: `"abc"`
 
-error: aborting due to 79 previous errors
+error: unnecessary use of `to_vec`
+  --> $DIR/unnecessary_to_owned.rs:527:37
+   |
+LL |         IntoFuture::into_future(foo([].to_vec(), &0));
+   |                                     ^^^^^^^^^^^ help: use: `[]`
+
+error: aborting due to 80 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 19f5b853308d7504a95a5ee27d6c3adfe14d4554 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Fri, 1 Dec 2023 16:57:18 +0100
Subject: Add `write_and_append` lint

---
 clippy_lints/src/declared_lints.rs           |  1 +
 clippy_lints/src/ineffective_open_options.rs | 95 ++++++++++++++++++++++++++++
 clippy_lints/src/lib.rs                      |  2 +
 clippy_lints/src/methods/mod.rs              |  2 +-
 4 files changed, 99 insertions(+), 1 deletion(-)
 create mode 100644 clippy_lints/src/ineffective_open_options.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index a9ae22e8d43..d3105ed9d18 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -215,6 +215,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::index_refutable_slice::INDEX_REFUTABLE_SLICE_INFO,
     crate::indexing_slicing::INDEXING_SLICING_INFO,
     crate::indexing_slicing::OUT_OF_BOUNDS_INDEXING_INFO,
+    crate::ineffective_open_options::INEFFECTIVE_OPEN_OPTIONS_INFO,
     crate::infinite_iter::INFINITE_ITER_INFO,
     crate::infinite_iter::MAYBE_INFINITE_ITER_INFO,
     crate::inherent_impl::MULTIPLE_INHERENT_IMPL_INFO,
diff --git a/clippy_lints/src/ineffective_open_options.rs b/clippy_lints/src/ineffective_open_options.rs
new file mode 100644
index 00000000000..955f90d4262
--- /dev/null
+++ b/clippy_lints/src/ineffective_open_options.rs
@@ -0,0 +1,95 @@
+use crate::methods::method_call;
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::peel_blocks;
+use rustc_ast::LitKind;
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty;
+use rustc_session::declare_lint_pass;
+use rustc_span::{sym, BytePos, Span};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks if both `.write(true)` and `.append(true)` methods are called
+    /// on a same `OpenOptions`.
+    ///
+    /// ### Why is this bad?
+    /// `.append(true)` already enables `write(true)`, making this one
+    /// superflous.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # use std::fs::OpenOptions;
+    /// let _ = OpenOptions::new()
+    ///            .write(true)
+    ///            .append(true)
+    ///            .create(true)
+    ///            .open("file.json");
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// # use std::fs::OpenOptions;
+    /// let _ = OpenOptions::new()
+    ///            .append(true)
+    ///            .create(true)
+    ///            .open("file.json");
+    /// ```
+    #[clippy::version = "1.76.0"]
+    pub INEFFECTIVE_OPEN_OPTIONS,
+    suspicious,
+    "usage of both `write(true)` and `append(true)` on same `OpenOptions`"
+}
+
+declare_lint_pass!(IneffectiveOpenOptions => [INEFFECTIVE_OPEN_OPTIONS]);
+
+fn index_if_arg_is_boolean(args: &[Expr<'_>], call_span: Span) -> Option<Span> {
+    if let [arg] = args
+        && let ExprKind::Lit(lit) = peel_blocks(arg).kind
+        && lit.node == LitKind::Bool(true)
+    {
+        // The `.` is not included in the span so we cheat a little bit to include it as well.
+        Some(call_span.with_lo(call_span.lo() - BytePos(1)))
+    } else {
+        None
+    }
+}
+
+impl<'tcx> LateLintPass<'tcx> for IneffectiveOpenOptions {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        let Some(("open", mut receiver, [_arg], _, _)) = method_call(expr) else {
+            return;
+        };
+        let receiver_ty = cx.typeck_results().expr_ty(receiver);
+        match receiver_ty.peel_refs().kind() {
+            ty::Adt(adt, _) if cx.tcx.is_diagnostic_item(sym::FsOpenOptions, adt.did()) => {},
+            _ => return,
+        }
+
+        let mut append = None;
+        let mut write = None;
+
+        while let Some((name, recv, args, _, span)) = method_call(receiver) {
+            if name == "append" {
+                append = index_if_arg_is_boolean(args, span);
+            } else if name == "write" {
+                write = index_if_arg_is_boolean(args, span);
+            }
+            receiver = recv;
+        }
+
+        if let Some(write_span) = write
+            && append.is_some()
+        {
+            span_lint_and_sugg(
+                cx,
+                INEFFECTIVE_OPEN_OPTIONS,
+                write_span,
+                "unnecessary use of `.write(true)` because there is `.append(true)`",
+                "remove `.write(true)`",
+                String::new(),
+                Applicability::MachineApplicable,
+            );
+        }
+    }
+}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 660d3c0bdd2..e4ff7ebb0f7 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -153,6 +153,7 @@ mod implied_bounds_in_impls;
 mod inconsistent_struct_constructor;
 mod index_refutable_slice;
 mod indexing_slicing;
+mod ineffective_open_options;
 mod infinite_iter;
 mod inherent_impl;
 mod inherent_to_string;
@@ -1073,6 +1074,7 @@ pub fn register_lints(store: &mut rustc_lint::LintStore, conf: &'static Conf) {
     store.register_late_pass(|_| Box::new(impl_hash_with_borrow_str_and_bytes::ImplHashWithBorrowStrBytes));
     store.register_late_pass(|_| Box::new(repeat_vec_with_capacity::RepeatVecWithCapacity));
     store.register_late_pass(|_| Box::new(uninhabited_references::UninhabitedReferences));
+    store.register_late_pass(|_| Box::new(ineffective_open_options::IneffectiveOpenOptions));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 25c681bb9d9..b4f60ffadd7 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3906,7 +3906,7 @@ impl_lint_pass!(Methods => [
 ]);
 
 /// Extracts a method call name, args, and `Span` of the method name.
-fn method_call<'tcx>(
+pub fn method_call<'tcx>(
     recv: &'tcx hir::Expr<'tcx>,
 ) -> Option<(&'tcx str, &'tcx hir::Expr<'tcx>, &'tcx [hir::Expr<'tcx>], Span, Span)> {
     if let ExprKind::MethodCall(path, receiver, args, call_span) = recv.kind {
-- 
cgit 1.4.1-3-g733a5


From bd38ff3c9be59c378dc17b04b2f93f396591e389 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Sat, 9 Dec 2023 00:12:07 +0100
Subject: Add new `unconditional_recursion` lint

---
 clippy_lints/src/declared_lints.rs          |   1 +
 clippy_lints/src/lib.rs                     |   2 +
 clippy_lints/src/unconditional_recursion.rs | 124 ++++++++++++++++++++++++++++
 3 files changed, 127 insertions(+)
 create mode 100644 clippy_lints/src/unconditional_recursion.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index d3105ed9d18..ec372d860a3 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -675,6 +675,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::types::REDUNDANT_ALLOCATION_INFO,
     crate::types::TYPE_COMPLEXITY_INFO,
     crate::types::VEC_BOX_INFO,
+    crate::unconditional_recursion::UNCONDITIONAL_RECURSION_INFO,
     crate::undocumented_unsafe_blocks::UNDOCUMENTED_UNSAFE_BLOCKS_INFO,
     crate::undocumented_unsafe_blocks::UNNECESSARY_SAFETY_COMMENT_INFO,
     crate::unicode::INVISIBLE_CHARACTERS_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index e4ff7ebb0f7..b81e77a4880 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -325,6 +325,7 @@ mod trait_bounds;
 mod transmute;
 mod tuple_array_conversions;
 mod types;
+mod unconditional_recursion;
 mod undocumented_unsafe_blocks;
 mod unicode;
 mod uninhabited_references;
@@ -1075,6 +1076,7 @@ pub fn register_lints(store: &mut rustc_lint::LintStore, conf: &'static Conf) {
     store.register_late_pass(|_| Box::new(repeat_vec_with_capacity::RepeatVecWithCapacity));
     store.register_late_pass(|_| Box::new(uninhabited_references::UninhabitedReferences));
     store.register_late_pass(|_| Box::new(ineffective_open_options::IneffectiveOpenOptions));
+    store.register_late_pass(|_| Box::new(unconditional_recursion::UnconditionalRecursion));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/unconditional_recursion.rs b/clippy_lints/src/unconditional_recursion.rs
new file mode 100644
index 00000000000..e267c6d8534
--- /dev/null
+++ b/clippy_lints/src/unconditional_recursion.rs
@@ -0,0 +1,124 @@
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::{get_parent_as_impl, get_trait_def_id, path_res};
+use rustc_ast::BinOpKind;
+use rustc_hir::def::Res;
+use rustc_hir::def_id::{DefId, LocalDefId};
+use rustc_hir::intravisit::FnKind;
+use rustc_hir::{Body, Expr, ExprKind, FnDecl};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::{self, Ty};
+use rustc_session::declare_lint_pass;
+use rustc_span::{sym, Span};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks that there isn't an infinite recursion in `PartialEq` trait
+    /// implementation.
+    ///
+    /// ### Why is this bad?
+    /// This is a hard to find infinite recursion which will crashing any code
+    /// using it.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// enum Foo {
+    ///     A,
+    ///     B,
+    /// }
+    ///
+    /// impl PartialEq for Foo {
+    ///     fn eq(&self, other: &Self) -> bool {
+    ///         self == other // bad!
+    ///     }
+    /// }
+    /// ```
+    /// Use instead:
+    ///
+    /// In such cases, either use `#[derive(PartialEq)]` or don't implement it.
+    #[clippy::version = "1.76.0"]
+    pub UNCONDITIONAL_RECURSION,
+    suspicious,
+    "detect unconditional recursion in some traits implementation"
+}
+
+declare_lint_pass!(UnconditionalRecursion => [UNCONDITIONAL_RECURSION]);
+
+fn get_ty_def_id(ty: Ty<'_>) -> Option<DefId> {
+    match ty.peel_refs().kind() {
+        ty::Adt(adt, _) => Some(adt.did()),
+        ty::Foreign(def_id) => Some(*def_id),
+        _ => None,
+    }
+}
+
+fn is_local(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+    matches!(path_res(cx, expr), Res::Local(_))
+}
+
+impl<'tcx> LateLintPass<'tcx> for UnconditionalRecursion {
+    #[allow(clippy::unnecessary_def_path)]
+    fn check_fn(
+        &mut self,
+        cx: &LateContext<'tcx>,
+        kind: FnKind<'tcx>,
+        _decl: &'tcx FnDecl<'tcx>,
+        body: &'tcx Body<'tcx>,
+        method_span: Span,
+        def_id: LocalDefId,
+    ) {
+        // We don't check code generated from (proc) macro.
+        if method_span.from_expansion() {
+            return;
+        }
+        if let FnKind::Method(name, _) = kind
+            && let [self_arg, other_arg] = cx
+                .tcx
+                .instantiate_bound_regions_with_erased(cx.tcx.fn_sig(def_id).skip_binder())
+                .inputs()
+            && let Some(self_arg) = get_ty_def_id(*self_arg)
+            && let Some(other_arg) = get_ty_def_id(*other_arg)
+            && self_arg == other_arg
+            && let hir_id = cx.tcx.local_def_id_to_hir_id(def_id)
+            && let Some(impl_) = get_parent_as_impl(cx.tcx, hir_id)
+            && let Some(trait_) = impl_.of_trait
+            && let Some(trait_def_id) = trait_.trait_def_id()
+            && Some(trait_def_id) == get_trait_def_id(cx, &["core", "cmp", "PartialEq"])
+        {
+            let to_check_op = if name.name == sym::eq {
+                BinOpKind::Eq
+            } else {
+                BinOpKind::Ne
+            };
+            let expr = body.value.peel_blocks();
+            let is_bad = match expr.kind {
+                ExprKind::Binary(op, left, right) if op.node == to_check_op => {
+                    is_local(cx, left) && is_local(cx, right)
+                },
+                ExprKind::MethodCall(segment, receiver, &[arg], _) if segment.ident.name == name.name => {
+                    if is_local(cx, receiver)
+                        && is_local(cx, &arg)
+                        && let Some(fn_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id)
+                        && let Some(trait_id) = cx.tcx.trait_of_item(fn_id)
+                        && trait_id == trait_def_id
+                    {
+                        true
+                    } else {
+                        false
+                    }
+                },
+                _ => false,
+            };
+            if is_bad {
+                span_lint_and_then(
+                    cx,
+                    UNCONDITIONAL_RECURSION,
+                    method_span,
+                    "function cannot return without recursing",
+                    |diag| {
+                        diag.span_note(expr.span, "recursive call site");
+                    },
+                );
+            }
+        }
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 884bec3d8558aef4c57bae1244fca76ab668e5b6 Mon Sep 17 00:00:00 2001
From: Eric <eric.dianhao.wu@gmail.com>
Date: Tue, 28 Nov 2023 11:57:00 -0800
Subject: emit lints in `check_crate_post` for useless_vec

this fixes issue #11861 by adding an extra map to
keep track of which spans are ok to lint
---
 clippy_lints/src/lib.rs |   3 +
 clippy_lints/src/vec.rs | 157 ++++++++++++++++++++++++++----------------------
 tests/ui/vec.fixed      |  34 +++++++++++
 tests/ui/vec.rs         |  34 +++++++++++
 tests/ui/vec.stderr     |   8 ++-
 5 files changed, 164 insertions(+), 72 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index e4ff7ebb0f7..7758d6a58e6 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -50,6 +50,8 @@ extern crate clippy_utils;
 #[macro_use]
 extern crate declare_clippy_lint;
 
+use std::collections::BTreeMap;
+
 use rustc_data_structures::fx::FxHashSet;
 use rustc_lint::{Lint, LintId};
 
@@ -725,6 +727,7 @@ pub fn register_lints(store: &mut rustc_lint::LintStore, conf: &'static Conf) {
         Box::new(vec::UselessVec {
             too_large_for_stack,
             msrv: msrv(),
+            span_to_lint_map: BTreeMap::new(),
         })
     });
     store.register_late_pass(|_| Box::new(panic_unimplemented::PanicUnimplemented));
diff --git a/clippy_lints/src/vec.rs b/clippy_lints/src/vec.rs
index ba958c5b392..5e13c73f035 100644
--- a/clippy_lints/src/vec.rs
+++ b/clippy_lints/src/vec.rs
@@ -1,25 +1,27 @@
+use std::collections::BTreeMap;
 use std::ops::ControlFlow;
 
 use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::consts::{constant, Constant};
-use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::diagnostics::span_lint_hir_and_then;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::is_copy;
 use clippy_utils::visitors::for_each_local_use_after_expr;
 use clippy_utils::{get_parent_expr, higher, is_trait_method};
 use rustc_errors::Applicability;
-use rustc_hir::{BorrowKind, Expr, ExprKind, Mutability, Node, PatKind};
+use rustc_hir::{BorrowKind, Expr, ExprKind, HirId, Mutability, Node, PatKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::layout::LayoutOf;
 use rustc_middle::ty::{self, Ty};
 use rustc_session::impl_lint_pass;
-use rustc_span::{sym, Span};
+use rustc_span::{sym, DesugaringKind, Span};
 
 #[expect(clippy::module_name_repetitions)]
 #[derive(Clone)]
 pub struct UselessVec {
     pub too_large_for_stack: u64,
     pub msrv: Msrv,
+    pub span_to_lint_map: BTreeMap<Span, Option<(HirId, SuggestedType, String, Applicability)>>,
 }
 
 declare_clippy_lint! {
@@ -69,64 +71,88 @@ pub fn is_allowed_vec_method(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
 
 impl<'tcx> LateLintPass<'tcx> for UselessVec {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        // search for `&vec![_]` or `vec![_]` expressions where the adjusted type is `&[_]`
-        if adjusts_to_slice(cx, expr)
-            && let Some(vec_args) = higher::VecArgs::hir(cx, expr.peel_borrows())
-        {
-            let (suggest_slice, span) = if let ExprKind::AddrOf(BorrowKind::Ref, mutability, _) = expr.kind {
-                // `expr` is `&vec![_]`, so suggest `&[_]` (or `&mut[_]` resp.)
-                (SuggestedType::SliceRef(mutability), expr.span)
-            } else {
-                // `expr` is the `vec![_]` expansion, so suggest `[_]`
-                // and also use the span of the actual `vec![_]` expression
-                (SuggestedType::Array, expr.span.ctxt().outer_expn_data().call_site)
-            };
-
-            self.check_vec_macro(cx, &vec_args, span, suggest_slice);
-        }
+        if let Some(vec_args) = higher::VecArgs::hir(cx, expr.peel_borrows()) {
+            // search for `let foo = vec![_]` expressions where all uses of `foo`
+            // adjust to slices or call a method that exist on slices (e.g. len)
+            if let Node::Local(local) = cx.tcx.hir().get_parent(expr.hir_id)
+                // for now ignore locals with type annotations.
+                // this is to avoid compile errors when doing the suggestion here: let _: Vec<_> = vec![..];
+                && local.ty.is_none()
+                && let PatKind::Binding(_, id, ..) = local.pat.kind
+                && is_copy(cx, vec_type(cx.typeck_results().expr_ty_adjusted(expr.peel_borrows())))
+            {
+                let only_slice_uses = for_each_local_use_after_expr(cx, id, expr.hir_id, |expr| {
+                    // allow indexing into a vec and some set of allowed method calls that exist on slices, too
+                    if let Some(parent) = get_parent_expr(cx, expr)
+                        && (adjusts_to_slice(cx, expr)
+                            || matches!(parent.kind, ExprKind::Index(..))
+                            || is_allowed_vec_method(cx, parent))
+                    {
+                        ControlFlow::Continue(())
+                    } else {
+                        ControlFlow::Break(())
+                    }
+                })
+                .is_continue();
 
-        // search for `let foo = vec![_]` expressions where all uses of `foo`
-        // adjust to slices or call a method that exist on slices (e.g. len)
-        if let Some(vec_args) = higher::VecArgs::hir(cx, expr)
-            && let Node::Local(local) = cx.tcx.hir().get_parent(expr.hir_id)
-            // for now ignore locals with type annotations.
-            // this is to avoid compile errors when doing the suggestion here: let _: Vec<_> = vec![..];
-            && local.ty.is_none()
-            && let PatKind::Binding(_, id, ..) = local.pat.kind
-            && is_copy(cx, vec_type(cx.typeck_results().expr_ty_adjusted(expr)))
-        {
-            let only_slice_uses = for_each_local_use_after_expr(cx, id, expr.hir_id, |expr| {
-                // allow indexing into a vec and some set of allowed method calls that exist on slices, too
-                if let Some(parent) = get_parent_expr(cx, expr)
-                    && (adjusts_to_slice(cx, expr)
-                        || matches!(parent.kind, ExprKind::Index(..))
-                        || is_allowed_vec_method(cx, parent))
-                {
-                    ControlFlow::Continue(())
+                let span = expr.span.ctxt().outer_expn_data().call_site;
+                if only_slice_uses {
+                    self.check_vec_macro(cx, &vec_args, span, expr.hir_id, SuggestedType::Array);
                 } else {
-                    ControlFlow::Break(())
+                    self.span_to_lint_map.insert(span, None);
+                }
+            }
+            // if the local pattern has a specified type, do not lint.
+            else if let Some(_) = higher::VecArgs::hir(cx, expr)
+                && let Node::Local(local) = cx.tcx.hir().get_parent(expr.hir_id)
+                && local.ty.is_some()
+            {
+                let span = expr.span.ctxt().outer_expn_data().call_site;
+                self.span_to_lint_map.insert(span, None);
+            }
+            // search for `for _ in vec![...]`
+            else if let Some(parent) = get_parent_expr(cx, expr)
+                && parent.span.is_desugaring(DesugaringKind::ForLoop)
+                && self.msrv.meets(msrvs::ARRAY_INTO_ITERATOR)
+            {
+                // report the error around the `vec!` not inside `<std macros>:`
+                let span = expr.span.ctxt().outer_expn_data().call_site;
+                self.check_vec_macro(cx, &vec_args, span, expr.hir_id, SuggestedType::Array);
+            }
+            // search for `&vec![_]` or `vec![_]` expressions where the adjusted type is `&[_]`
+            else {
+                let (suggest_slice, span) = if let ExprKind::AddrOf(BorrowKind::Ref, mutability, _) = expr.kind {
+                    // `expr` is `&vec![_]`, so suggest `&[_]` (or `&mut[_]` resp.)
+                    (SuggestedType::SliceRef(mutability), expr.span)
+                } else {
+                    // `expr` is the `vec![_]` expansion, so suggest `[_]`
+                    // and also use the span of the actual `vec![_]` expression
+                    (SuggestedType::Array, expr.span.ctxt().outer_expn_data().call_site)
+                };
+
+                if adjusts_to_slice(cx, expr) {
+                    self.check_vec_macro(cx, &vec_args, span, expr.hir_id, suggest_slice);
+                } else {
+                    self.span_to_lint_map.insert(span, None);
                 }
-            })
-            .is_continue();
-
-            if only_slice_uses {
-                self.check_vec_macro(
-                    cx,
-                    &vec_args,
-                    expr.span.ctxt().outer_expn_data().call_site,
-                    SuggestedType::Array,
-                );
             }
         }
+    }
 
-        // search for `for _ in vec![…]`
-        if let Some(higher::ForLoop { arg, .. }) = higher::ForLoop::hir(expr)
-            && let Some(vec_args) = higher::VecArgs::hir(cx, arg)
-            && self.msrv.meets(msrvs::ARRAY_INTO_ITERATOR)
-        {
-            // report the error around the `vec!` not inside `<std macros>:`
-            let span = arg.span.ctxt().outer_expn_data().call_site;
-            self.check_vec_macro(cx, &vec_args, span, SuggestedType::Array);
+    fn check_crate_post(&mut self, cx: &LateContext<'tcx>) {
+        for (span, lint_opt) in &self.span_to_lint_map {
+            if let Some((hir_id, suggest_slice, snippet, applicability)) = lint_opt {
+                let help_msg = format!(
+                    "you can use {} directly",
+                    match suggest_slice {
+                        SuggestedType::SliceRef(_) => "a slice",
+                        SuggestedType::Array => "an array",
+                    }
+                );
+                span_lint_hir_and_then(cx, USELESS_VEC, *hir_id, *span, "useless use of `vec!`", |diag| {
+                    diag.span_suggestion(*span, help_msg, snippet, *applicability);
+                });
+            }
         }
     }
 
@@ -134,7 +160,7 @@ impl<'tcx> LateLintPass<'tcx> for UselessVec {
 }
 
 #[derive(Copy, Clone)]
-enum SuggestedType {
+pub(crate) enum SuggestedType {
     /// Suggest using a slice `&[..]` / `&mut [..]`
     SliceRef(Mutability),
     /// Suggest using an array: `[..]`
@@ -147,6 +173,7 @@ impl UselessVec {
         cx: &LateContext<'tcx>,
         vec_args: &higher::VecArgs<'tcx>,
         span: Span,
+        hir_id: HirId,
         suggest_slice: SuggestedType,
     ) {
         if span.from_expansion() {
@@ -204,21 +231,9 @@ impl UselessVec {
             },
         };
 
-        span_lint_and_sugg(
-            cx,
-            USELESS_VEC,
-            span,
-            "useless use of `vec!`",
-            &format!(
-                "you can use {} directly",
-                match suggest_slice {
-                    SuggestedType::SliceRef(_) => "a slice",
-                    SuggestedType::Array => "an array",
-                }
-            ),
-            snippet,
-            applicability,
-        );
+        self.span_to_lint_map
+            .entry(span)
+            .or_insert(Some((hir_id, suggest_slice, snippet, applicability)));
     }
 }
 
diff --git a/tests/ui/vec.fixed b/tests/ui/vec.fixed
index bcbca971a78..81b8bd7da77 100644
--- a/tests/ui/vec.fixed
+++ b/tests/ui/vec.fixed
@@ -176,3 +176,37 @@ fn below() {
         let _: String = a;
     }
 }
+
+fn func_needing_vec(_bar: usize, _baz: Vec<usize>) {}
+fn func_not_needing_vec(_bar: usize, _baz: usize) {}
+
+fn issue11861() {
+    macro_rules! this_macro_needs_vec {
+        ($x:expr) => {{
+            func_needing_vec($x.iter().sum(), $x);
+            for _ in $x {}
+        }};
+    }
+    macro_rules! this_macro_doesnt_need_vec {
+        ($x:expr) => {{ func_not_needing_vec($x.iter().sum(), $x.iter().sum()) }};
+    }
+
+    // Do not lint the next line
+    this_macro_needs_vec!(vec![1]);
+    this_macro_doesnt_need_vec!([1]); //~ ERROR: useless use of `vec!`
+
+    macro_rules! m {
+        ($x:expr) => {
+            fn f2() {
+                let _x: Vec<i32> = $x;
+            }
+            fn f() {
+                let _x = $x;
+                $x.starts_with(&[]);
+            }
+        };
+    }
+
+    // should not lint
+    m!(vec![1]);
+}
diff --git a/tests/ui/vec.rs b/tests/ui/vec.rs
index 087425585de..5aca9b2925c 100644
--- a/tests/ui/vec.rs
+++ b/tests/ui/vec.rs
@@ -176,3 +176,37 @@ fn below() {
         let _: String = a;
     }
 }
+
+fn func_needing_vec(_bar: usize, _baz: Vec<usize>) {}
+fn func_not_needing_vec(_bar: usize, _baz: usize) {}
+
+fn issue11861() {
+    macro_rules! this_macro_needs_vec {
+        ($x:expr) => {{
+            func_needing_vec($x.iter().sum(), $x);
+            for _ in $x {}
+        }};
+    }
+    macro_rules! this_macro_doesnt_need_vec {
+        ($x:expr) => {{ func_not_needing_vec($x.iter().sum(), $x.iter().sum()) }};
+    }
+
+    // Do not lint the next line
+    this_macro_needs_vec!(vec![1]);
+    this_macro_doesnt_need_vec!(vec![1]); //~ ERROR: useless use of `vec!`
+
+    macro_rules! m {
+        ($x:expr) => {
+            fn f2() {
+                let _x: Vec<i32> = $x;
+            }
+            fn f() {
+                let _x = $x;
+                $x.starts_with(&[]);
+            }
+        };
+    }
+
+    // should not lint
+    m!(vec![1]);
+}
diff --git a/tests/ui/vec.stderr b/tests/ui/vec.stderr
index fc261838fe3..c9018f94f9d 100644
--- a/tests/ui/vec.stderr
+++ b/tests/ui/vec.stderr
@@ -115,5 +115,11 @@ error: useless use of `vec!`
 LL |     for a in vec![String::new(), String::new()] {
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: you can use an array directly: `[String::new(), String::new()]`
 
-error: aborting due to 19 previous errors
+error: useless use of `vec!`
+  --> $DIR/vec.rs:196:33
+   |
+LL |     this_macro_doesnt_need_vec!(vec![1]);
+   |                                 ^^^^^^^ help: you can use an array directly: `[1]`
+
+error: aborting due to 20 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 1f2ca8127cf74392d57a1e2526295427134e62f9 Mon Sep 17 00:00:00 2001
From: Marti Raudsepp <marti@juffo.org>
Date: Wed, 13 Dec 2023 00:51:44 +0200
Subject: [`doc_markdown`] Recognize words followed by empty parenthesis `()`
 for quoting

---
 clippy_lints/src/doc/markdown.rs                 | 16 +++++++++++++---
 clippy_lints/src/missing_asserts_for_indexing.rs |  2 +-
 tests/ui/doc/doc-fixable.fixed                   |  3 +++
 tests/ui/doc/doc-fixable.rs                      |  3 +++
 tests/ui/doc/doc-fixable.stderr                  | 24 +++++++++++++++++++++++-
 5 files changed, 43 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/doc/markdown.rs b/clippy_lints/src/doc/markdown.rs
index c0b11eb0dd1..a58219c2946 100644
--- a/clippy_lints/src/doc/markdown.rs
+++ b/clippy_lints/src/doc/markdown.rs
@@ -9,11 +9,21 @@ use url::Url;
 use crate::doc::DOC_MARKDOWN;
 
 pub fn check(cx: &LateContext<'_>, valid_idents: &FxHashSet<String>, text: &str, span: Span) {
-    for word in text.split(|c: char| c.is_whitespace() || c == '\'') {
+    for orig_word in text.split(|c: char| c.is_whitespace() || c == '\'') {
         // Trim punctuation as in `some comment (see foo::bar).`
         //                                                   ^^
         // Or even as in `_foo bar_` which is emphasized. Also preserve `::` as a prefix/suffix.
-        let mut word = word.trim_matches(|c: char| !c.is_alphanumeric() && c != ':');
+        let trim_pattern = |c: char| !c.is_alphanumeric() && c != ':';
+        let mut word = orig_word.trim_end_matches(trim_pattern);
+
+        // If word is immediately followed by `()`, claw it back.
+        if let Some(tmp_word) = orig_word.get(..word.len() + 2)
+            && tmp_word.ends_with("()")
+        {
+            word = tmp_word;
+        }
+
+        word = word.trim_start_matches(trim_pattern);
 
         // Remove leading or trailing single `:` which may be part of a sentence.
         if word.starts_with(':') && !word.starts_with("::") {
@@ -84,7 +94,7 @@ fn check_word(cx: &LateContext<'_>, word: &str, span: Span) {
         return;
     }
 
-    if has_underscore(word) || word.contains("::") || is_camel_case(word) {
+    if has_underscore(word) || word.contains("::") || is_camel_case(word) || word.ends_with("()") {
         let mut applicability = Applicability::MachineApplicable;
 
         span_lint_and_then(
diff --git a/clippy_lints/src/missing_asserts_for_indexing.rs b/clippy_lints/src/missing_asserts_for_indexing.rs
index 71470ea2dc6..0f18e943451 100644
--- a/clippy_lints/src/missing_asserts_for_indexing.rs
+++ b/clippy_lints/src/missing_asserts_for_indexing.rs
@@ -94,7 +94,7 @@ enum LengthComparison {
 
 /// Extracts parts out of a length comparison expression.
 ///
-/// E.g. for `v.len() > 5` this returns `Some((LengthComparison::IntLessThanLength, 5, `v.len()`))`
+/// E.g. for `v.len() > 5` this returns `Some((LengthComparison::IntLessThanLength, 5, v.len()))`
 fn len_comparison<'hir>(
     bin_op: BinOp,
     left: &'hir Expr<'hir>,
diff --git a/tests/ui/doc/doc-fixable.fixed b/tests/ui/doc/doc-fixable.fixed
index aee89719728..708ac666675 100644
--- a/tests/ui/doc/doc-fixable.fixed
+++ b/tests/ui/doc/doc-fixable.fixed
@@ -227,3 +227,6 @@ where [(); N.checked_next_power_of_two().unwrap()]: {
 
 /// this checks if the lowerCamelCase issue is fixed
 fn issue_11568() {}
+
+/// There is no try (`do()` or `do_not()`).
+fn parenthesized_word() {}
diff --git a/tests/ui/doc/doc-fixable.rs b/tests/ui/doc/doc-fixable.rs
index b6346b881ad..040d6352c52 100644
--- a/tests/ui/doc/doc-fixable.rs
+++ b/tests/ui/doc/doc-fixable.rs
@@ -227,3 +227,6 @@ where [(); N.checked_next_power_of_two().unwrap()]: {
 
 /// this checks if the lowerCamelCase issue is fixed
 fn issue_11568() {}
+
+/// There is no try (do() or do_not()).
+fn parenthesized_word() {}
diff --git a/tests/ui/doc/doc-fixable.stderr b/tests/ui/doc/doc-fixable.stderr
index 4c9ff41d918..033604e030a 100644
--- a/tests/ui/doc/doc-fixable.stderr
+++ b/tests/ui/doc/doc-fixable.stderr
@@ -319,5 +319,27 @@ help: try
 LL | /// Foo \[bar\] \[baz\] \[qux\]. `DocMarkdownLint`
    |                                  ~~~~~~~~~~~~~~~~~
 
-error: aborting due to 29 previous errors
+error: item in documentation is missing backticks
+  --> $DIR/doc-fixable.rs:231:22
+   |
+LL | /// There is no try (do() or do_not()).
+   |                      ^^^^
+   |
+help: try
+   |
+LL | /// There is no try (`do()` or do_not()).
+   |                      ~~~~~~
+
+error: item in documentation is missing backticks
+  --> $DIR/doc-fixable.rs:231:30
+   |
+LL | /// There is no try (do() or do_not()).
+   |                              ^^^^^^^^
+   |
+help: try
+   |
+LL | /// There is no try (do() or `do_not()`).
+   |                              ~~~~~~~~~~
+
+error: aborting due to 31 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 60c059114c3c1d2bcbe90c71f308b32f7cea1b07 Mon Sep 17 00:00:00 2001
From: J-ZhengLi <lizheng135@huawei.com>
Date: Wed, 13 Dec 2023 11:09:08 +0800
Subject: [`default_numeric_fallback`]: don't lint on return and macro calls
 with stated type

---
 clippy_lints/src/default_numeric_fallback.rs | 41 ++++++++++++++++++++++++----
 tests/ui/default_numeric_fallback_f64.fixed  |  2 +-
 tests/ui/default_numeric_fallback_f64.stderr |  8 +-----
 tests/ui/default_numeric_fallback_i32.fixed  | 34 ++++++++++++++++++++++-
 tests/ui/default_numeric_fallback_i32.rs     | 32 ++++++++++++++++++++++
 tests/ui/default_numeric_fallback_i32.stderr | 26 +++++++++++++-----
 6 files changed, 121 insertions(+), 22 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/default_numeric_fallback.rs b/clippy_lints/src/default_numeric_fallback.rs
index 64a924a776a..712bc075650 100644
--- a/clippy_lints/src/default_numeric_fallback.rs
+++ b/clippy_lints/src/default_numeric_fallback.rs
@@ -4,7 +4,7 @@ use clippy_utils::{get_parent_node, numeric_literal};
 use rustc_ast::ast::{LitFloatType, LitIntType, LitKind};
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_expr, walk_stmt, Visitor};
-use rustc_hir::{Body, Expr, ExprKind, HirId, ItemKind, Lit, Node, Stmt, StmtKind};
+use rustc_hir::{Block, Body, Expr, ExprKind, FnRetTy, HirId, ItemKind, Lit, Node, Stmt, StmtKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::{self, FloatTy, IntTy, PolyFnSig, Ty};
@@ -122,13 +122,42 @@ impl<'a, 'tcx> NumericFallbackVisitor<'a, 'tcx> {
 impl<'a, 'tcx> Visitor<'tcx> for NumericFallbackVisitor<'a, 'tcx> {
     fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
         match &expr.kind {
+            ExprKind::Block(
+                Block {
+                    stmts, expr: Some(_), ..
+                },
+                _,
+            ) => {
+                if let Some(parent) = self.cx.tcx.hir().find_parent(expr.hir_id)
+                    && let Some(fn_sig) = parent.fn_sig()
+                    && let FnRetTy::Return(_ty) = fn_sig.decl.output
+                {
+                    // We cannot check the exact type since it's a `hir::Ty`` which does not implement `is_numeric`
+                    self.ty_bounds.push(ExplicitTyBound(true));
+                    for stmt in *stmts {
+                        self.visit_stmt(stmt);
+                    }
+                    self.ty_bounds.pop();
+                    // Ignore return expr since we know its type was inferred from return ty
+                    return;
+                }
+            },
+
+            // Ignore return expr since we know its type was inferred from return ty
+            ExprKind::Ret(_) => return,
+
             ExprKind::Call(func, args) => {
                 if let Some(fn_sig) = fn_sig_opt(self.cx, func.hir_id) {
                     for (expr, bound) in iter::zip(*args, fn_sig.skip_binder().inputs()) {
-                        // Push found arg type, then visit arg.
-                        self.ty_bounds.push((*bound).into());
-                        self.visit_expr(expr);
-                        self.ty_bounds.pop();
+                        // If is from macro, try to use last bound type (typically pushed when visiting stmt),
+                        // otherwise push found arg type, then visit arg,
+                        if expr.span.from_expansion() {
+                            self.visit_expr(expr);
+                        } else {
+                            self.ty_bounds.push((*bound).into());
+                            self.visit_expr(expr);
+                            self.ty_bounds.pop();
+                        }
                     }
                     return;
                 }
@@ -137,7 +166,7 @@ impl<'a, 'tcx> Visitor<'tcx> for NumericFallbackVisitor<'a, 'tcx> {
             ExprKind::MethodCall(_, receiver, args, _) => {
                 if let Some(def_id) = self.cx.typeck_results().type_dependent_def_id(expr.hir_id) {
                     let fn_sig = self.cx.tcx.fn_sig(def_id).instantiate_identity().skip_binder();
-                    for (expr, bound) in iter::zip(std::iter::once(*receiver).chain(args.iter()), fn_sig.inputs()) {
+                    for (expr, bound) in iter::zip(iter::once(*receiver).chain(args.iter()), fn_sig.inputs()) {
                         self.ty_bounds.push((*bound).into());
                         self.visit_expr(expr);
                         self.ty_bounds.pop();
diff --git a/tests/ui/default_numeric_fallback_f64.fixed b/tests/ui/default_numeric_fallback_f64.fixed
index 9072d233563..e62dc8b255e 100644
--- a/tests/ui/default_numeric_fallback_f64.fixed
+++ b/tests/ui/default_numeric_fallback_f64.fixed
@@ -75,7 +75,7 @@ mod function_def {
     fn ret_f64() -> f64 {
         // Even though the output type is specified,
         // this unsuffixed literal is linted to reduce heuristics and keep codebase simple.
-        1.0_f64
+        1.
     }
 
     fn test() {
diff --git a/tests/ui/default_numeric_fallback_f64.stderr b/tests/ui/default_numeric_fallback_f64.stderr
index 7ea2e3e6819..e81aafdb3f3 100644
--- a/tests/ui/default_numeric_fallback_f64.stderr
+++ b/tests/ui/default_numeric_fallback_f64.stderr
@@ -85,12 +85,6 @@ error: default numeric fallback might occur
 LL |             let y = 1.;
    |                     ^^ help: consider adding suffix: `1.0_f64`
 
-error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_f64.rs:78:9
-   |
-LL |         1.
-   |         ^^ help: consider adding suffix: `1.0_f64`
-
 error: default numeric fallback might occur
   --> $DIR/default_numeric_fallback_f64.rs:84:27
    |
@@ -147,5 +141,5 @@ LL |         inline!(let x = 22.;);
    |
    = note: this error originates in the macro `__inline_mac_fn_internal` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to 24 previous errors
+error: aborting due to 23 previous errors
 
diff --git a/tests/ui/default_numeric_fallback_i32.fixed b/tests/ui/default_numeric_fallback_i32.fixed
index 920cd9f8f77..115cd30a6b3 100644
--- a/tests/ui/default_numeric_fallback_i32.fixed
+++ b/tests/ui/default_numeric_fallback_i32.fixed
@@ -76,7 +76,7 @@ mod function_def {
     fn ret_i32() -> i32 {
         // Even though the output type is specified,
         // this unsuffixed literal is linted to reduce heuristics and keep codebase simple.
-        1_i32
+        1
     }
 
     fn test() {
@@ -186,4 +186,36 @@ fn check_expect_suppression() {
     let x = 21;
 }
 
+mod type_already_infered {
+    // Should NOT lint if bound to return type
+    fn ret_i32() -> i32 {
+        1
+    }
+
+    // Should NOT lint if bound to return type
+    fn ret_if_i32(b: bool) -> i32 {
+        if b { 100 } else { 0 }
+    }
+
+    // Should NOT lint if bound to return type
+    fn ret_i32_tuple() -> (i32, i32) {
+        (0, 1)
+    }
+
+    // Should NOT lint if bound to return type
+    fn ret_stmt(b: bool) -> (i32, i32) {
+        if b {
+            return (0, 1);
+        }
+        (0, 0)
+    }
+
+    #[allow(clippy::useless_vec)]
+    fn vec_macro() {
+        // Should NOT lint in `vec!` call if the type was already stated
+        let data_i32: Vec<i32> = vec![1, 2, 3];
+        let data_i32 = vec![1_i32, 2_i32, 3_i32];
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/default_numeric_fallback_i32.rs b/tests/ui/default_numeric_fallback_i32.rs
index bdb7b5f47bc..a4abfc11320 100644
--- a/tests/ui/default_numeric_fallback_i32.rs
+++ b/tests/ui/default_numeric_fallback_i32.rs
@@ -186,4 +186,36 @@ fn check_expect_suppression() {
     let x = 21;
 }
 
+mod type_already_infered {
+    // Should NOT lint if bound to return type
+    fn ret_i32() -> i32 {
+        1
+    }
+
+    // Should NOT lint if bound to return type
+    fn ret_if_i32(b: bool) -> i32 {
+        if b { 100 } else { 0 }
+    }
+
+    // Should NOT lint if bound to return type
+    fn ret_i32_tuple() -> (i32, i32) {
+        (0, 1)
+    }
+
+    // Should NOT lint if bound to return type
+    fn ret_stmt(b: bool) -> (i32, i32) {
+        if b {
+            return (0, 1);
+        }
+        (0, 0)
+    }
+
+    #[allow(clippy::useless_vec)]
+    fn vec_macro() {
+        // Should NOT lint in `vec!` call if the type was already stated
+        let data_i32: Vec<i32> = vec![1, 2, 3];
+        let data_i32 = vec![1, 2, 3];
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/default_numeric_fallback_i32.stderr b/tests/ui/default_numeric_fallback_i32.stderr
index b03b8b84c33..0da9b77f32e 100644
--- a/tests/ui/default_numeric_fallback_i32.stderr
+++ b/tests/ui/default_numeric_fallback_i32.stderr
@@ -97,12 +97,6 @@ error: default numeric fallback might occur
 LL |             let y = 1;
    |                     ^ help: consider adding suffix: `1_i32`
 
-error: default numeric fallback might occur
-  --> $DIR/default_numeric_fallback_i32.rs:79:9
-   |
-LL |         1
-   |         ^ help: consider adding suffix: `1_i32`
-
 error: default numeric fallback might occur
   --> $DIR/default_numeric_fallback_i32.rs:85:27
    |
@@ -159,5 +153,23 @@ LL |         inline!(let x = 22;);
    |
    = note: this error originates in the macro `__inline_mac_fn_internal` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to 26 previous errors
+error: default numeric fallback might occur
+  --> $DIR/default_numeric_fallback_i32.rs:217:29
+   |
+LL |         let data_i32 = vec![1, 2, 3];
+   |                             ^ help: consider adding suffix: `1_i32`
+
+error: default numeric fallback might occur
+  --> $DIR/default_numeric_fallback_i32.rs:217:32
+   |
+LL |         let data_i32 = vec![1, 2, 3];
+   |                                ^ help: consider adding suffix: `2_i32`
+
+error: default numeric fallback might occur
+  --> $DIR/default_numeric_fallback_i32.rs:217:35
+   |
+LL |         let data_i32 = vec![1, 2, 3];
+   |                                   ^ help: consider adding suffix: `3_i32`
+
+error: aborting due to 28 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From eae2317977acb0d42a93740ae93122a1287d8090 Mon Sep 17 00:00:00 2001
From: J-ZhengLi <lizheng135@huawei.com>
Date: Thu, 14 Dec 2023 09:27:01 +0800
Subject: improve [`cast_sign_loss`], to skip warning on mathmatical expression
 that is always positive

---
 clippy_lints/src/casts/cast_sign_loss.rs | 141 +++++++++++++++++++++++++------
 tests/ui/cast.rs                         |  49 +++++++++++
 tests/ui/cast.stderr                     |  74 +++++++++++++++-
 3 files changed, 238 insertions(+), 26 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/cast_sign_loss.rs b/clippy_lints/src/casts/cast_sign_loss.rs
index bd12ee40628..1df5a25f674 100644
--- a/clippy_lints/src/casts/cast_sign_loss.rs
+++ b/clippy_lints/src/casts/cast_sign_loss.rs
@@ -1,12 +1,14 @@
 use clippy_utils::consts::{constant, Constant};
 use clippy_utils::diagnostics::span_lint;
-use clippy_utils::{method_chain_args, sext};
-use rustc_hir::{Expr, ExprKind};
+use clippy_utils::{clip, method_chain_args, sext};
+use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::LateContext;
-use rustc_middle::ty::{self, Ty};
+use rustc_middle::ty::{self, Ty, UintTy};
 
 use super::CAST_SIGN_LOSS;
 
+const METHODS_RET_POSITIVE: &[&str] = &["abs", "checked_abs", "rem_euclid", "checked_rem_euclid"];
+
 pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_op: &Expr<'_>, cast_from: Ty<'_>, cast_to: Ty<'_>) {
     if should_lint(cx, cast_op, cast_from, cast_to) {
         span_lint(
@@ -25,33 +27,28 @@ fn should_lint(cx: &LateContext<'_>, cast_op: &Expr<'_>, cast_from: Ty<'_>, cast
                 return false;
             }
 
-            // Don't lint for positive constants.
-            let const_val = constant(cx, cx.typeck_results(), cast_op);
-            if let Some(Constant::Int(n)) = const_val
-                && let ty::Int(ity) = *cast_from.kind()
-                && sext(cx.tcx, n, ity) >= 0
-            {
+            // Don't lint if `cast_op` is known to be positive.
+            if let Sign::ZeroOrPositive = expr_sign(cx, cast_op, cast_from) {
                 return false;
             }
 
-            // Don't lint for the result of methods that always return non-negative values.
-            if let ExprKind::MethodCall(path, ..) = cast_op.kind {
-                let mut method_name = path.ident.name.as_str();
-                let allowed_methods = ["abs", "checked_abs", "rem_euclid", "checked_rem_euclid"];
-
-                if method_name == "unwrap"
-                    && let Some(arglist) = method_chain_args(cast_op, &["unwrap"])
-                    && let ExprKind::MethodCall(inner_path, ..) = &arglist[0].0.kind
-                {
-                    method_name = inner_path.ident.name.as_str();
-                }
-
-                if allowed_methods.iter().any(|&name| method_name == name) {
-                    return false;
-                }
+            let (mut uncertain_count, mut negative_count) = (0, 0);
+            // Peel off possible binary expressions, e.g. x * x * y => [x, x, y]
+            let Some(exprs) = exprs_with_selected_binop_peeled(cast_op) else {
+                // Assume cast sign lose if we cannot determine the sign of `cast_op`
+                return true;
+            };
+            for expr in exprs {
+                let ty = cx.typeck_results().expr_ty(expr);
+                match expr_sign(cx, expr, ty) {
+                    Sign::Negative => negative_count += 1,
+                    Sign::Uncertain => uncertain_count += 1,
+                    Sign::ZeroOrPositive => (),
+                };
             }
 
-            true
+            // Lint if there are odd number of uncertain or negative results
+            uncertain_count % 2 == 1 || negative_count % 2 == 1
         },
 
         (false, true) => !cast_to.is_signed(),
@@ -59,3 +56,97 @@ fn should_lint(cx: &LateContext<'_>, cast_op: &Expr<'_>, cast_from: Ty<'_>, cast
         (_, _) => false,
     }
 }
+
+fn get_const_int_eval(cx: &LateContext<'_>, expr: &Expr<'_>, ty: Ty<'_>) -> Option<i128> {
+    if let Constant::Int(n) = constant(cx, cx.typeck_results(), expr)?
+        && let ty::Int(ity) = *ty.kind()
+    {
+        return Some(sext(cx.tcx, n, ity));
+    }
+    None
+}
+
+enum Sign {
+    ZeroOrPositive,
+    Negative,
+    Uncertain,
+}
+
+fn expr_sign(cx: &LateContext<'_>, expr: &Expr<'_>, ty: Ty<'_>) -> Sign {
+    // Try evaluate this expr first to see if it's positive
+    if let Some(val) = get_const_int_eval(cx, expr, ty) {
+        return if val >= 0 { Sign::ZeroOrPositive } else { Sign::Negative };
+    }
+    // Calling on methods that always return non-negative values.
+    if let ExprKind::MethodCall(path, caller, args, ..) = expr.kind {
+        let mut method_name = path.ident.name.as_str();
+
+        if method_name == "unwrap"
+            && let Some(arglist) = method_chain_args(expr, &["unwrap"])
+            && let ExprKind::MethodCall(inner_path, ..) = &arglist[0].0.kind
+        {
+            method_name = inner_path.ident.name.as_str();
+        }
+
+        if method_name == "pow"
+            && let [arg] = args
+        {
+            return pow_call_result_sign(cx, caller, arg);
+        } else if METHODS_RET_POSITIVE.iter().any(|&name| method_name == name) {
+            return Sign::ZeroOrPositive;
+        }
+    }
+
+    Sign::Uncertain
+}
+
+/// Return the sign of the `pow` call's result.
+///
+/// If the caller is a positive number, the result is always positive,
+/// If the `power_of` is a even number, the result is always positive as well,
+/// Otherwise a [`Sign::Uncertain`] will be returned.
+fn pow_call_result_sign(cx: &LateContext<'_>, caller: &Expr<'_>, power_of: &Expr<'_>) -> Sign {
+    let caller_ty = cx.typeck_results().expr_ty(caller);
+    if let Some(caller_val) = get_const_int_eval(cx, caller, caller_ty)
+        && caller_val >= 0
+    {
+        return Sign::ZeroOrPositive;
+    }
+
+    if let Some(Constant::Int(n)) = constant(cx, cx.typeck_results(), power_of)
+        && clip(cx.tcx, n, UintTy::U32) % 2 == 0
+    {
+        return Sign::ZeroOrPositive;
+    }
+
+    Sign::Uncertain
+}
+
+/// Peels binary operators such as [`BinOpKind::Mul`], [`BinOpKind::Div`] or [`BinOpKind::Rem`],
+/// which the result could always be positive under certain condition.
+///
+/// Other operators such as `+`/`-` causing the result's sign hard to determine, which we will
+/// return `None`
+fn exprs_with_selected_binop_peeled<'a>(expr: &'a Expr<'_>) -> Option<Vec<&'a Expr<'a>>> {
+    #[inline]
+    fn collect_operands<'a>(expr: &'a Expr<'a>, operands: &mut Vec<&'a Expr<'a>>) -> Option<()> {
+        match expr.kind {
+            ExprKind::Binary(op, lhs, rhs) => {
+                if matches!(op.node, BinOpKind::Mul | BinOpKind::Div | BinOpKind::Rem) {
+                    collect_operands(lhs, operands);
+                    operands.push(rhs);
+                } else {
+                    // Things are complicated when there are other binary ops exist,
+                    // abort checking by returning `None` for now.
+                    return None;
+                }
+            },
+            _ => operands.push(expr),
+        }
+        Some(())
+    }
+
+    let mut res = vec![];
+    collect_operands(expr, &mut res)?;
+    Some(res)
+}
diff --git a/tests/ui/cast.rs b/tests/ui/cast.rs
index 1ca18170f8a..e9476c80ccb 100644
--- a/tests/ui/cast.rs
+++ b/tests/ui/cast.rs
@@ -365,3 +365,52 @@ fn avoid_subtract_overflow(q: u32) {
 fn issue11426() {
     (&42u8 >> 0xa9008fb6c9d81e42_0e25730562a601c8_u128) as usize;
 }
+
+fn issue11642() {
+    fn square(x: i16) -> u32 {
+        let x = x as i32;
+        (x * x) as u32;
+        x.pow(2) as u32;
+        (-2_i32).pow(2) as u32
+    }
+
+    let _a = |x: i32| -> u32 { (x * x * x * x) as u32 };
+
+    (-2_i32).pow(3) as u32;
+    //~^ ERROR: casting `i32` to `u32` may lose the sign of the value
+
+    let x: i32 = 10;
+    (x * x) as u32;
+    (x * x * x) as u32;
+    //~^ ERROR: casting `i32` to `u32` may lose the sign of the value
+
+    let y: i16 = -2;
+    (y * y * y * y * -2) as u16;
+    //~^ ERROR: casting `i16` to `u16` may lose the sign of the value
+    (y * y * y * y * 2) as u16;
+    (y * y * y * 2) as u16;
+    //~^ ERROR: casting `i16` to `u16` may lose the sign of the value
+    (y * y * y * -2) as u16;
+    //~^ ERROR: casting `i16` to `u16` may lose the sign of the value
+
+    fn foo(a: i32, b: i32, c: i32) -> u32 {
+        (a * a * b * b * c * c) as u32;
+        (a * b * c) as u32;
+        //~^ ERROR: casting `i32` to `u32` may lose the sign of the value
+        (a * -b * c) as u32;
+        //~^ ERROR: casting `i32` to `u32` may lose the sign of the value
+        (a * b * c * c) as u32;
+        (a * -2) as u32;
+        //~^ ERROR: casting `i32` to `u32` may lose the sign of the value
+        (a * b * c * -2) as u32;
+        //~^ ERROR: casting `i32` to `u32` may lose the sign of the value
+        (a / b) as u32;
+        (a / b * c) as u32;
+        //~^ ERROR: casting `i32` to `u32` may lose the sign of the value
+        (a / b + b * c) as u32;
+        //~^ ERROR: casting `i32` to `u32` may lose the sign of the value
+        a.pow(3) as u32;
+        //~^ ERROR: casting `i32` to `u32` may lose the sign of the value
+        (a.abs() * b.pow(2) / c.abs()) as u32
+    }
+}
diff --git a/tests/ui/cast.stderr b/tests/ui/cast.stderr
index bc74f7b728e..4e37af7f378 100644
--- a/tests/ui/cast.stderr
+++ b/tests/ui/cast.stderr
@@ -444,5 +444,77 @@ help: ... or use `try_from` and handle the error accordingly
 LL |     let c = u8::try_from(q / 1000);
    |             ~~~~~~~~~~~~~~~~~~~~~~
 
-error: aborting due to 51 previous errors
+error: casting `i32` to `u32` may lose the sign of the value
+  --> $DIR/cast.rs:379:5
+   |
+LL |     (-2_i32).pow(3) as u32;
+   |     ^^^^^^^^^^^^^^^^^^^^^^
+
+error: casting `i32` to `u32` may lose the sign of the value
+  --> $DIR/cast.rs:384:5
+   |
+LL |     (x * x * x) as u32;
+   |     ^^^^^^^^^^^^^^^^^^
+
+error: casting `i16` to `u16` may lose the sign of the value
+  --> $DIR/cast.rs:388:5
+   |
+LL |     (y * y * y * y * -2) as u16;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: casting `i16` to `u16` may lose the sign of the value
+  --> $DIR/cast.rs:391:5
+   |
+LL |     (y * y * y * 2) as u16;
+   |     ^^^^^^^^^^^^^^^^^^^^^^
+
+error: casting `i16` to `u16` may lose the sign of the value
+  --> $DIR/cast.rs:393:5
+   |
+LL |     (y * y * y * -2) as u16;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^
+
+error: casting `i32` to `u32` may lose the sign of the value
+  --> $DIR/cast.rs:398:9
+   |
+LL |         (a * b * c) as u32;
+   |         ^^^^^^^^^^^^^^^^^^
+
+error: casting `i32` to `u32` may lose the sign of the value
+  --> $DIR/cast.rs:400:9
+   |
+LL |         (a * -b * c) as u32;
+   |         ^^^^^^^^^^^^^^^^^^^
+
+error: casting `i32` to `u32` may lose the sign of the value
+  --> $DIR/cast.rs:403:9
+   |
+LL |         (a * -2) as u32;
+   |         ^^^^^^^^^^^^^^^
+
+error: casting `i32` to `u32` may lose the sign of the value
+  --> $DIR/cast.rs:405:9
+   |
+LL |         (a * b * c * -2) as u32;
+   |         ^^^^^^^^^^^^^^^^^^^^^^^
+
+error: casting `i32` to `u32` may lose the sign of the value
+  --> $DIR/cast.rs:408:9
+   |
+LL |         (a / b * c) as u32;
+   |         ^^^^^^^^^^^^^^^^^^
+
+error: casting `i32` to `u32` may lose the sign of the value
+  --> $DIR/cast.rs:410:9
+   |
+LL |         (a / b + b * c) as u32;
+   |         ^^^^^^^^^^^^^^^^^^^^^^
+
+error: casting `i32` to `u32` may lose the sign of the value
+  --> $DIR/cast.rs:412:9
+   |
+LL |         a.pow(3) as u32;
+   |         ^^^^^^^^^^^^^^^
+
+error: aborting due to 63 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 058b74fce4f34f4ace7d7b02fb938c6b1dc9c531 Mon Sep 17 00:00:00 2001
From: StackOverflowExcept1on
 <109800286+StackOverflowExcept1on@users.noreply.github.com>
Date: Fri, 15 Dec 2023 22:52:38 +0300
Subject: Do not lint `assertions_on_constants` for `const _: () =
 assert!(expr)`

---
 clippy_lints/src/assertions_on_constants.rs | 15 ++++++++++++---
 tests/ui/assertions_on_constants.rs         |  7 +++++++
 tests/ui/assertions_on_constants.stderr     | 10 +++++++++-
 3 files changed, 28 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/assertions_on_constants.rs b/clippy_lints/src/assertions_on_constants.rs
index a15ec199a28..11d614afaf8 100644
--- a/clippy_lints/src/assertions_on_constants.rs
+++ b/clippy_lints/src/assertions_on_constants.rs
@@ -1,7 +1,7 @@
-use clippy_utils::consts::{constant, Constant};
+use clippy_utils::consts::{constant_with_source, Constant, ConstantSource};
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::macros::{find_assert_args, root_macro_call_first_node, PanicExpn};
-use rustc_hir::Expr;
+use rustc_hir::{Expr, Item, ItemKind, Node};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::declare_lint_pass;
 use rustc_span::sym;
@@ -42,9 +42,18 @@ impl<'tcx> LateLintPass<'tcx> for AssertionsOnConstants {
         let Some((condition, panic_expn)) = find_assert_args(cx, e, macro_call.expn) else {
             return;
         };
-        let Some(Constant::Bool(val)) = constant(cx, cx.typeck_results(), condition) else {
+        let Some((Constant::Bool(val), source)) = constant_with_source(cx, cx.typeck_results(), condition) else {
             return;
         };
+        if let ConstantSource::Constant = source
+            && let Some(node) = cx.tcx.hir().find_parent(e.hir_id)
+            && let Node::Item(Item {
+                kind: ItemKind::Const(.., _body_id),
+                ..
+            }) = node
+        {
+            return;
+        }
         if val {
             span_lint_and_help(
                 cx,
diff --git a/tests/ui/assertions_on_constants.rs b/tests/ui/assertions_on_constants.rs
index 10809a6d247..1309ae45d0a 100644
--- a/tests/ui/assertions_on_constants.rs
+++ b/tests/ui/assertions_on_constants.rs
@@ -45,4 +45,11 @@ fn main() {
 
     const CFG_FLAG: &bool = &cfg!(feature = "hey");
     assert!(!CFG_FLAG);
+
+    const _: () = assert!(true);
+    //~^ ERROR: `assert!(true)` will be optimized out by the compiler
+
+    // Don't lint if the value is dependent on a defined constant:
+    const N: usize = 1024;
+    const _: () = assert!(N.is_power_of_two());
 }
diff --git a/tests/ui/assertions_on_constants.stderr b/tests/ui/assertions_on_constants.stderr
index 780d1fe1c8a..099be4ed355 100644
--- a/tests/ui/assertions_on_constants.stderr
+++ b/tests/ui/assertions_on_constants.stderr
@@ -72,5 +72,13 @@ LL |     debug_assert!(true);
    |
    = help: remove it
 
-error: aborting due to 9 previous errors
+error: `assert!(true)` will be optimized out by the compiler
+  --> $DIR/assertions_on_constants.rs:49:19
+   |
+LL |     const _: () = assert!(true);
+   |                   ^^^^^^^^^^^^^
+   |
+   = help: remove it
+
+error: aborting due to 10 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 90ece568d3ec1fb0273db452ce4b65c6bbc9c055 Mon Sep 17 00:00:00 2001
From: StackOverflowExcept1on
 <109800286+StackOverflowExcept1on@users.noreply.github.com>
Date: Fri, 15 Dec 2023 23:02:13 +0300
Subject: simplify pattern

---
 clippy_lints/src/assertions_on_constants.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/assertions_on_constants.rs b/clippy_lints/src/assertions_on_constants.rs
index 11d614afaf8..1e327f7a6df 100644
--- a/clippy_lints/src/assertions_on_constants.rs
+++ b/clippy_lints/src/assertions_on_constants.rs
@@ -48,7 +48,7 @@ impl<'tcx> LateLintPass<'tcx> for AssertionsOnConstants {
         if let ConstantSource::Constant = source
             && let Some(node) = cx.tcx.hir().find_parent(e.hir_id)
             && let Node::Item(Item {
-                kind: ItemKind::Const(.., _body_id),
+                kind: ItemKind::Const(..),
                 ..
             }) = node
         {
-- 
cgit 1.4.1-3-g733a5


From e52405a85943108a0b305a511afd36f6bf037af3 Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Fri, 15 Dec 2023 22:30:27 +0100
Subject: Do not consider `async { (impl IntoFuture).await }` as redundant

---
 clippy_lints/src/redundant_async_block.rs | 4 ++++
 tests/ui/redundant_async_block.fixed      | 8 +++++++-
 tests/ui/redundant_async_block.rs         | 8 +++++++-
 3 files changed, 18 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/redundant_async_block.rs b/clippy_lints/src/redundant_async_block.rs
index 19d9d64b31e..11007450a16 100644
--- a/clippy_lints/src/redundant_async_block.rs
+++ b/clippy_lints/src/redundant_async_block.rs
@@ -3,6 +3,7 @@ use std::ops::ControlFlow;
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::peel_blocks;
 use clippy_utils::source::{snippet, walk_span_to_context};
+use clippy_utils::ty::implements_trait;
 use clippy_utils::visitors::for_each_expr;
 use rustc_errors::Applicability;
 use rustc_hir::{Closure, CoroutineKind, CoroutineSource, Expr, ExprKind, MatchSource};
@@ -49,6 +50,9 @@ impl<'tcx> LateLintPass<'tcx> for RedundantAsyncBlock {
             let Some(expr) = desugar_await(peel_blocks(body_expr)) &&
             // The await prefix must not come from a macro as its content could change in the future.
             expr.span.eq_ctxt(body_expr.span) &&
+            // The await prefix must implement Future, as implementing IntoFuture is not enough.
+            let Some(future_trait) = cx.tcx.lang_items().future_trait() &&
+            implements_trait(cx, cx.typeck_results().expr_ty(expr), future_trait, &[]) &&
             // An async block does not have immediate side-effects from a `.await` point-of-view.
             (!expr.can_have_side_effects() || desugar_async_block(cx, expr).is_some()) &&
             let Some(shortened_span) = walk_span_to_context(expr.span, span.ctxt())
diff --git a/tests/ui/redundant_async_block.fixed b/tests/ui/redundant_async_block.fixed
index d492ea1be75..a1875c1c06e 100644
--- a/tests/ui/redundant_async_block.fixed
+++ b/tests/ui/redundant_async_block.fixed
@@ -1,7 +1,7 @@
 #![allow(unused, clippy::manual_async_fn)]
 #![warn(clippy::redundant_async_block)]
 
-use std::future::Future;
+use std::future::{Future, IntoFuture};
 
 async fn func1(n: usize) -> usize {
     n + 1
@@ -189,3 +189,9 @@ fn await_from_macro_deep() -> impl Future<Output = u32> {
     // or return different things depending on its argument
     async { mac!(async { 42 }) }
 }
+
+// Issue 11959
+fn from_into_future(a: impl IntoFuture<Output = u32>) -> impl Future<Output = u32> {
+    // Do not lint: `a` is not equivalent to this expression
+    async { a.await }
+}
diff --git a/tests/ui/redundant_async_block.rs b/tests/ui/redundant_async_block.rs
index dd96e141006..bb43403a043 100644
--- a/tests/ui/redundant_async_block.rs
+++ b/tests/ui/redundant_async_block.rs
@@ -1,7 +1,7 @@
 #![allow(unused, clippy::manual_async_fn)]
 #![warn(clippy::redundant_async_block)]
 
-use std::future::Future;
+use std::future::{Future, IntoFuture};
 
 async fn func1(n: usize) -> usize {
     n + 1
@@ -189,3 +189,9 @@ fn await_from_macro_deep() -> impl Future<Output = u32> {
     // or return different things depending on its argument
     async { mac!(async { 42 }) }
 }
+
+// Issue 11959
+fn from_into_future(a: impl IntoFuture<Output = u32>) -> impl Future<Output = u32> {
+    // Do not lint: `a` is not equivalent to this expression
+    async { a.await }
+}
-- 
cgit 1.4.1-3-g733a5


From 8892420aa742e1f8e2ae80edd694aba59ac60e87 Mon Sep 17 00:00:00 2001
From: Quinn Sinclair <me@partiallytyped.dev>
Date: Mon, 4 Dec 2023 02:20:47 +0100
Subject: New Lint: `Result_filter_map`

Added the `Result` mirror of `option_filter_map` to catch

```
   .into_iter().filter(Result::is_ok).map(Result::unwrap)
```

changelog: New Lint: [`result_filter_map`]
Co-authored-by: Alex Macleod <alex@macleod.io>
---
 CHANGELOG.md                           |  1 +
 clippy_lints/src/declared_lints.rs     |  1 +
 clippy_lints/src/methods/filter_map.rs | 86 +++++++++++++++++++++++++---------
 clippy_lints/src/methods/mod.rs        | 27 ++++++++++-
 tests/ui/option_filter_map.fixed       |  6 +++
 tests/ui/option_filter_map.rs          |  8 ++++
 tests/ui/option_filter_map.stderr      | 16 ++++---
 tests/ui/result_filter_map.fixed       | 27 +++++++++++
 tests/ui/result_filter_map.rs          | 35 ++++++++++++++
 tests/ui/result_filter_map.stderr      | 41 ++++++++++++++++
 10 files changed, 217 insertions(+), 31 deletions(-)
 create mode 100644 tests/ui/result_filter_map.fixed
 create mode 100644 tests/ui/result_filter_map.rs
 create mode 100644 tests/ui/result_filter_map.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 70aff7f60e0..da6bb32cd45 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5470,6 +5470,7 @@ Released 2018-09-13
 [`reserve_after_initialization`]: https://rust-lang.github.io/rust-clippy/master/index.html#reserve_after_initialization
 [`rest_pat_in_fully_bound_structs`]: https://rust-lang.github.io/rust-clippy/master/index.html#rest_pat_in_fully_bound_structs
 [`result_expect_used`]: https://rust-lang.github.io/rust-clippy/master/index.html#result_expect_used
+[`result_filter_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#result_filter_map
 [`result_large_err`]: https://rust-lang.github.io/rust-clippy/master/index.html#result_large_err
 [`result_map_or_into_option`]: https://rust-lang.github.io/rust-clippy/master/index.html#result_map_or_into_option
 [`result_map_unit_fn`]: https://rust-lang.github.io/rust-clippy/master/index.html#result_map_unit_fn
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 2ce938fbe92..8ae68da3e9f 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -419,6 +419,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::methods::READ_LINE_WITHOUT_TRIM_INFO,
     crate::methods::REDUNDANT_AS_STR_INFO,
     crate::methods::REPEAT_ONCE_INFO,
+    crate::methods::RESULT_FILTER_MAP_INFO,
     crate::methods::RESULT_MAP_OR_INTO_OPTION_INFO,
     crate::methods::SEARCH_IS_SOME_INFO,
     crate::methods::SEEK_FROM_CURRENT_INFO,
diff --git a/clippy_lints/src/methods/filter_map.rs b/clippy_lints/src/methods/filter_map.rs
index 844ab40cab1..fad45041aca 100644
--- a/clippy_lints/src/methods/filter_map.rs
+++ b/clippy_lints/src/methods/filter_map.rs
@@ -14,7 +14,7 @@ use rustc_span::symbol::{sym, Ident, Symbol};
 use rustc_span::Span;
 use std::borrow::Cow;
 
-use super::{MANUAL_FILTER_MAP, MANUAL_FIND_MAP, OPTION_FILTER_MAP};
+use super::{MANUAL_FILTER_MAP, MANUAL_FIND_MAP, OPTION_FILTER_MAP, RESULT_FILTER_MAP};
 
 fn is_method(cx: &LateContext<'_>, expr: &hir::Expr<'_>, method_name: Symbol) -> bool {
     match &expr.kind {
@@ -46,6 +46,9 @@ fn is_method(cx: &LateContext<'_>, expr: &hir::Expr<'_>, method_name: Symbol) ->
 fn is_option_filter_map(cx: &LateContext<'_>, filter_arg: &hir::Expr<'_>, map_arg: &hir::Expr<'_>) -> bool {
     is_method(cx, map_arg, sym::unwrap) && is_method(cx, filter_arg, sym!(is_some))
 }
+fn is_ok_filter_map(cx: &LateContext<'_>, filter_arg: &hir::Expr<'_>, map_arg: &hir::Expr<'_>) -> bool {
+    is_method(cx, map_arg, sym::unwrap) && is_method(cx, filter_arg, sym!(is_ok))
+}
 
 #[derive(Debug, Copy, Clone)]
 enum OffendingFilterExpr<'tcx> {
@@ -273,6 +276,18 @@ fn is_filter_some_map_unwrap(
     (iterator || option) && is_option_filter_map(cx, filter_arg, map_arg)
 }
 
+/// is `filter(|x| x.is_ok()).map(|x| x.unwrap())`
+fn is_filter_ok_map_unwrap(
+    cx: &LateContext<'_>,
+    expr: &hir::Expr<'_>,
+    filter_arg: &hir::Expr<'_>,
+    map_arg: &hir::Expr<'_>,
+) -> bool {
+    // result has no filter, so we only check for iterators
+    let iterator = is_trait_method(cx, expr, sym::Iterator);
+    iterator && is_ok_filter_map(cx, filter_arg, map_arg)
+}
+
 /// lint use of `filter().map()` or `find().map()` for `Iterators`
 #[allow(clippy::too_many_arguments)]
 pub(super) fn check(
@@ -300,30 +315,21 @@ pub(super) fn check(
         return;
     }
 
-    if is_trait_method(cx, map_recv, sym::Iterator)
-
-        // filter(|x| ...is_some())...
-        && let ExprKind::Closure(&Closure { body: filter_body_id, .. }) = filter_arg.kind
-        && let filter_body = cx.tcx.hir().body(filter_body_id)
-        && let [filter_param] = filter_body.params
-        // optional ref pattern: `filter(|&x| ..)`
-        && let (filter_pat, is_filter_param_ref) = if let PatKind::Ref(ref_pat, _) = filter_param.pat.kind {
-            (ref_pat, true)
-        } else {
-            (filter_param.pat, false)
-        }
-
-        && let PatKind::Binding(_, filter_param_id, _, None) = filter_pat.kind
-        && let Some(mut offending_expr) = OffendingFilterExpr::hir(cx, filter_body.value, filter_param_id)
+    if is_filter_ok_map_unwrap(cx, expr, filter_arg, map_arg) {
+        span_lint_and_sugg(
+            cx,
+            RESULT_FILTER_MAP,
+            filter_span.with_hi(expr.span.hi()),
+            "`filter` for `Ok` followed by `unwrap`",
+            "consider using `flatten` instead",
+            reindent_multiline(Cow::Borrowed("flatten()"), true, indent_of(cx, map_span)).into_owned(),
+            Applicability::MachineApplicable,
+        );
 
-        && let ExprKind::Closure(&Closure { body: map_body_id, .. }) = map_arg.kind
-        && let map_body = cx.tcx.hir().body(map_body_id)
-        && let [map_param] = map_body.params
-        && let PatKind::Binding(_, map_param_id, map_param_ident, None) = map_param.pat.kind
+        return;
+    }
 
-        && let Some(check_result) =
-            offending_expr.check_map_call(cx, map_body, map_param_id, filter_param_id, is_filter_param_ref)
-    {
+    if let Some((map_param_ident, check_result)) = is_find_or_filter(cx, map_recv, filter_arg, map_arg) {
         let span = filter_span.with_hi(expr.span.hi());
         let (filter_name, lint) = if is_find {
             ("find", MANUAL_FIND_MAP)
@@ -395,6 +401,40 @@ pub(super) fn check(
     }
 }
 
+fn is_find_or_filter<'a>(
+    cx: &LateContext<'a>,
+    map_recv: &hir::Expr<'_>,
+    filter_arg: &hir::Expr<'_>,
+    map_arg: &hir::Expr<'_>,
+) -> Option<(Ident, CheckResult<'a>)> {
+    if is_trait_method(cx, map_recv, sym::Iterator)
+        // filter(|x| ...is_some())...
+        && let ExprKind::Closure(&Closure { body: filter_body_id, .. }) = filter_arg.kind
+        && let filter_body = cx.tcx.hir().body(filter_body_id)
+        && let [filter_param] = filter_body.params
+        // optional ref pattern: `filter(|&x| ..)`
+        && let (filter_pat, is_filter_param_ref) = if let PatKind::Ref(ref_pat, _) = filter_param.pat.kind {
+            (ref_pat, true)
+        } else {
+            (filter_param.pat, false)
+        }
+
+        && let PatKind::Binding(_, filter_param_id, _, None) = filter_pat.kind
+        && let Some(mut offending_expr) = OffendingFilterExpr::hir(cx, filter_body.value, filter_param_id)
+
+        && let ExprKind::Closure(&Closure { body: map_body_id, .. }) = map_arg.kind
+        && let map_body = cx.tcx.hir().body(map_body_id)
+        && let [map_param] = map_body.params
+        && let PatKind::Binding(_, map_param_id, map_param_ident, None) = map_param.pat.kind
+
+        && let Some(check_result) =
+            offending_expr.check_map_call(cx, map_body, map_param_id, filter_param_id, is_filter_param_ref)
+    {
+        return Some((map_param_ident, check_result));
+    }
+    None
+}
+
 fn acceptable_methods(method: &PathSegment<'_>) -> bool {
     let methods: [Symbol; 8] = [
         sym::clone,
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index b4f60ffadd7..a94524b3ba6 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -1175,7 +1175,8 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for indirect collection of populated `Option`
+    /// Checks for iterators of `Option`s using ``.filter(Option::is_some).map(Option::unwrap)` that may
+    /// be replaced with a `.flatten()` call.
     ///
     /// ### Why is this bad?
     /// `Option` is like a collection of 0-1 things, so `flatten`
@@ -3752,6 +3753,29 @@ declare_clippy_lint! {
     "using `Option.map_or(Err(_), Ok)`, which is more succinctly expressed as `Option.ok_or(_)`"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for iterators of `Result`s using ``.filter(Result::is_ok).map(Result::unwrap)` that may
+    /// be replaced with a `.flatten()` call.
+    ///
+    /// ### Why is this bad?
+    /// `Result` implements `IntoIterator<Item = T>`. This means that `Result` can be flattened
+    /// automatically without suspicious-looking `unwrap` calls.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let _ = std::iter::empty::<Result<i32, ()>>().filter(Result::is_ok).map(Result::unwrap);
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// let _ = std::iter::empty::<Result<i32, ()>>().flatten();
+    /// ```
+    #[clippy::version = "1.76.0"]
+    pub RESULT_FILTER_MAP,
+    complexity,
+    "filtering `Result` for `Ok` then force-unwrapping, which can be one type-safe operation"
+}
+
 pub struct Methods {
     avoid_breaking_exported_api: bool,
     msrv: Msrv,
@@ -3903,6 +3927,7 @@ impl_lint_pass!(Methods => [
     UNNECESSARY_FALLIBLE_CONVERSIONS,
     JOIN_ABSOLUTE_PATHS,
     OPTION_MAP_OR_ERR_OK,
+    RESULT_FILTER_MAP,
 ]);
 
 /// Extracts a method call name, args, and `Span` of the method name.
diff --git a/tests/ui/option_filter_map.fixed b/tests/ui/option_filter_map.fixed
index ee004c0e194..b1c3cfa48a4 100644
--- a/tests/ui/option_filter_map.fixed
+++ b/tests/ui/option_filter_map.fixed
@@ -3,12 +3,18 @@
 
 fn main() {
     let _ = Some(Some(1)).flatten();
+    //~^ ERROR: `filter` for `Some` followed by `unwrap`
     let _ = Some(Some(1)).flatten();
+    //~^ ERROR: `filter` for `Some` followed by `unwrap`
     let _ = Some(1).map(odds_out).flatten();
+    //~^ ERROR: `filter` for `Some` followed by `unwrap`
     let _ = Some(1).map(odds_out).flatten();
+    //~^ ERROR: `filter` for `Some` followed by `unwrap`
 
     let _ = vec![Some(1)].into_iter().flatten();
+    //~^ ERROR: `filter` for `Some` followed by `unwrap`
     let _ = vec![Some(1)].into_iter().flatten();
+    //~^ ERROR: `filter` for `Some` followed by `unwrap`
     let _ = vec![1]
         .into_iter()
         .map(odds_out)
diff --git a/tests/ui/option_filter_map.rs b/tests/ui/option_filter_map.rs
index eae2fa176a8..2550b9cd2b3 100644
--- a/tests/ui/option_filter_map.rs
+++ b/tests/ui/option_filter_map.rs
@@ -3,21 +3,29 @@
 
 fn main() {
     let _ = Some(Some(1)).filter(Option::is_some).map(Option::unwrap);
+    //~^ ERROR: `filter` for `Some` followed by `unwrap`
     let _ = Some(Some(1)).filter(|o| o.is_some()).map(|o| o.unwrap());
+    //~^ ERROR: `filter` for `Some` followed by `unwrap`
     let _ = Some(1).map(odds_out).filter(Option::is_some).map(Option::unwrap);
+    //~^ ERROR: `filter` for `Some` followed by `unwrap`
     let _ = Some(1).map(odds_out).filter(|o| o.is_some()).map(|o| o.unwrap());
+    //~^ ERROR: `filter` for `Some` followed by `unwrap`
 
     let _ = vec![Some(1)].into_iter().filter(Option::is_some).map(Option::unwrap);
+    //~^ ERROR: `filter` for `Some` followed by `unwrap`
     let _ = vec![Some(1)].into_iter().filter(|o| o.is_some()).map(|o| o.unwrap());
+    //~^ ERROR: `filter` for `Some` followed by `unwrap`
     let _ = vec![1]
         .into_iter()
         .map(odds_out)
         .filter(Option::is_some)
+        //~^ ERROR: `filter` for `Some` followed by `unwrap`
         .map(Option::unwrap);
     let _ = vec![1]
         .into_iter()
         .map(odds_out)
         .filter(|o| o.is_some())
+        //~^ ERROR: `filter` for `Some` followed by `unwrap`
         .map(|o| o.unwrap());
 }
 
diff --git a/tests/ui/option_filter_map.stderr b/tests/ui/option_filter_map.stderr
index 148f9d02f5e..6a0fc10822b 100644
--- a/tests/ui/option_filter_map.stderr
+++ b/tests/ui/option_filter_map.stderr
@@ -8,48 +8,50 @@ LL |     let _ = Some(Some(1)).filter(Option::is_some).map(Option::unwrap);
    = help: to override `-D warnings` add `#[allow(clippy::option_filter_map)]`
 
 error: `filter` for `Some` followed by `unwrap`
-  --> $DIR/option_filter_map.rs:6:27
+  --> $DIR/option_filter_map.rs:7:27
    |
 LL |     let _ = Some(Some(1)).filter(|o| o.is_some()).map(|o| o.unwrap());
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
 
 error: `filter` for `Some` followed by `unwrap`
-  --> $DIR/option_filter_map.rs:7:35
+  --> $DIR/option_filter_map.rs:9:35
    |
 LL |     let _ = Some(1).map(odds_out).filter(Option::is_some).map(Option::unwrap);
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
 
 error: `filter` for `Some` followed by `unwrap`
-  --> $DIR/option_filter_map.rs:8:35
+  --> $DIR/option_filter_map.rs:11:35
    |
 LL |     let _ = Some(1).map(odds_out).filter(|o| o.is_some()).map(|o| o.unwrap());
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
 
 error: `filter` for `Some` followed by `unwrap`
-  --> $DIR/option_filter_map.rs:10:39
+  --> $DIR/option_filter_map.rs:14:39
    |
 LL |     let _ = vec![Some(1)].into_iter().filter(Option::is_some).map(Option::unwrap);
    |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
 
 error: `filter` for `Some` followed by `unwrap`
-  --> $DIR/option_filter_map.rs:11:39
+  --> $DIR/option_filter_map.rs:16:39
    |
 LL |     let _ = vec![Some(1)].into_iter().filter(|o| o.is_some()).map(|o| o.unwrap());
    |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
 
 error: `filter` for `Some` followed by `unwrap`
-  --> $DIR/option_filter_map.rs:15:10
+  --> $DIR/option_filter_map.rs:21:10
    |
 LL |           .filter(Option::is_some)
    |  __________^
+LL | |
 LL | |         .map(Option::unwrap);
    | |____________________________^ help: consider using `flatten` instead: `flatten()`
 
 error: `filter` for `Some` followed by `unwrap`
-  --> $DIR/option_filter_map.rs:20:10
+  --> $DIR/option_filter_map.rs:27:10
    |
 LL |           .filter(|o| o.is_some())
    |  __________^
+LL | |
 LL | |         .map(|o| o.unwrap());
    | |____________________________^ help: consider using `flatten` instead: `flatten()`
 
diff --git a/tests/ui/result_filter_map.fixed b/tests/ui/result_filter_map.fixed
new file mode 100644
index 00000000000..e8943dbc72d
--- /dev/null
+++ b/tests/ui/result_filter_map.fixed
@@ -0,0 +1,27 @@
+#![warn(clippy::result_filter_map)]
+#![allow(clippy::map_flatten, clippy::unnecessary_map_on_constructor)]
+
+fn odds_out(x: i32) -> Result<i32, ()> {
+    if x % 2 == 0 { Ok(x) } else { Err(()) }
+}
+
+fn main() {
+    // Unlike the Option version, Result does not have a filter operation => we will check for iterators
+    // only
+    let _ = vec![Ok(1) as Result<i32, ()>]
+        .into_iter()
+        .flatten();
+
+    let _ = vec![Ok(1) as Result<i32, ()>]
+        .into_iter()
+        .flatten();
+
+    let _ = vec![1]
+        .into_iter()
+        .map(odds_out)
+        .flatten();
+    let _ = vec![1]
+        .into_iter()
+        .map(odds_out)
+        .flatten();
+}
diff --git a/tests/ui/result_filter_map.rs b/tests/ui/result_filter_map.rs
new file mode 100644
index 00000000000..bfe47ffcf38
--- /dev/null
+++ b/tests/ui/result_filter_map.rs
@@ -0,0 +1,35 @@
+#![warn(clippy::result_filter_map)]
+#![allow(clippy::map_flatten, clippy::unnecessary_map_on_constructor)]
+
+fn odds_out(x: i32) -> Result<i32, ()> {
+    if x % 2 == 0 { Ok(x) } else { Err(()) }
+}
+
+fn main() {
+    // Unlike the Option version, Result does not have a filter operation => we will check for iterators
+    // only
+    let _ = vec![Ok(1) as Result<i32, ()>]
+        .into_iter()
+        .filter(Result::is_ok)
+        //~^ ERROR: `filter` for `Ok` followed by `unwrap`
+        .map(Result::unwrap);
+
+    let _ = vec![Ok(1) as Result<i32, ()>]
+        .into_iter()
+        .filter(|o| o.is_ok())
+        //~^ ERROR: `filter` for `Ok` followed by `unwrap`
+        .map(|o| o.unwrap());
+
+    let _ = vec![1]
+        .into_iter()
+        .map(odds_out)
+        .filter(Result::is_ok)
+        //~^ ERROR: `filter` for `Ok` followed by `unwrap`
+        .map(Result::unwrap);
+    let _ = vec![1]
+        .into_iter()
+        .map(odds_out)
+        .filter(|o| o.is_ok())
+        //~^ ERROR: `filter` for `Ok` followed by `unwrap`
+        .map(|o| o.unwrap());
+}
diff --git a/tests/ui/result_filter_map.stderr b/tests/ui/result_filter_map.stderr
new file mode 100644
index 00000000000..4687794949d
--- /dev/null
+++ b/tests/ui/result_filter_map.stderr
@@ -0,0 +1,41 @@
+error: `filter` for `Ok` followed by `unwrap`
+  --> $DIR/result_filter_map.rs:13:10
+   |
+LL |           .filter(Result::is_ok)
+   |  __________^
+LL | |
+LL | |         .map(Result::unwrap);
+   | |____________________________^ help: consider using `flatten` instead: `flatten()`
+   |
+   = note: `-D clippy::result-filter-map` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::result_filter_map)]`
+
+error: `filter` for `Ok` followed by `unwrap`
+  --> $DIR/result_filter_map.rs:19:10
+   |
+LL |           .filter(|o| o.is_ok())
+   |  __________^
+LL | |
+LL | |         .map(|o| o.unwrap());
+   | |____________________________^ help: consider using `flatten` instead: `flatten()`
+
+error: `filter` for `Ok` followed by `unwrap`
+  --> $DIR/result_filter_map.rs:26:10
+   |
+LL |           .filter(Result::is_ok)
+   |  __________^
+LL | |
+LL | |         .map(Result::unwrap);
+   | |____________________________^ help: consider using `flatten` instead: `flatten()`
+
+error: `filter` for `Ok` followed by `unwrap`
+  --> $DIR/result_filter_map.rs:32:10
+   |
+LL |           .filter(|o| o.is_ok())
+   |  __________^
+LL | |
+LL | |         .map(|o| o.unwrap());
+   | |____________________________^ help: consider using `flatten` instead: `flatten()`
+
+error: aborting due to 4 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 850d77ed5575d06d274cf6ce0aa6c2c7f4af120b Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Sat, 16 Dec 2023 16:37:58 +0100
Subject: [`redundant_pattern_matching`]: catch `if let true`

---
 clippy_lints/src/format_push_string.rs             |  2 +-
 clippy_lints/src/loops/manual_flatten.rs           |  2 +-
 clippy_lints/src/manual_let_else.rs                |  2 +-
 clippy_lints/src/matches/collapsible_match.rs      |  4 +--
 clippy_lints/src/matches/mod.rs                    |  1 +
 .../src/matches/redundant_pattern_match.rs         | 34 +++++++++++++++++++---
 clippy_lints/src/methods/filter_map.rs             |  2 +-
 clippy_lints/src/option_if_let_else.rs             |  1 +
 clippy_lints/src/question_mark.rs                  |  1 +
 clippy_utils/src/higher.rs                         | 13 +++++++--
 10 files changed, 50 insertions(+), 12 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/format_push_string.rs b/clippy_lints/src/format_push_string.rs
index 3901dd984f9..2b08437d827 100644
--- a/clippy_lints/src/format_push_string.rs
+++ b/clippy_lints/src/format_push_string.rs
@@ -57,7 +57,7 @@ fn is_format(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
             Some(higher::IfLetOrMatch::Match(_, arms, MatchSource::Normal)) => {
                 arms.iter().any(|arm| is_format(cx, arm.body))
             },
-            Some(higher::IfLetOrMatch::IfLet(_, _, then, r#else)) => {
+            Some(higher::IfLetOrMatch::IfLet(_, _, then, r#else, _)) => {
                 is_format(cx, then) || r#else.is_some_and(|e| is_format(cx, e))
             },
             _ => false,
diff --git a/clippy_lints/src/loops/manual_flatten.rs b/clippy_lints/src/loops/manual_flatten.rs
index a726b116956..36de9021f49 100644
--- a/clippy_lints/src/loops/manual_flatten.rs
+++ b/clippy_lints/src/loops/manual_flatten.rs
@@ -20,7 +20,7 @@ pub(super) fn check<'tcx>(
     span: Span,
 ) {
     let inner_expr = peel_blocks_with_stmt(body);
-    if let Some(higher::IfLet { let_pat, let_expr, if_then, if_else: None })
+    if let Some(higher::IfLet { let_pat, let_expr, if_then, if_else: None, .. })
             = higher::IfLet::hir(cx, inner_expr)
         // Ensure match_expr in `if let` statement is the same as the pat from the for-loop
         && let PatKind::Binding(_, pat_hir_id, _, _) = pat.kind
diff --git a/clippy_lints/src/manual_let_else.rs b/clippy_lints/src/manual_let_else.rs
index 92dc4d57ab1..fdf8fa4e277 100644
--- a/clippy_lints/src/manual_let_else.rs
+++ b/clippy_lints/src/manual_let_else.rs
@@ -61,7 +61,7 @@ impl<'tcx> QuestionMark {
             && 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) => {
+                IfLetOrMatch::IfLet(if_let_expr, let_pat, if_then, if_else, ..) => {
                     if let Some(ident_map) = expr_simple_identity_map(local.pat, let_pat, if_then)
                         && let Some(if_else) = if_else
                         && is_never_expr(cx, if_else).is_some()
diff --git a/clippy_lints/src/matches/collapsible_match.rs b/clippy_lints/src/matches/collapsible_match.rs
index 48fc5746b3c..91e6ca7fa8b 100644
--- a/clippy_lints/src/matches/collapsible_match.rs
+++ b/clippy_lints/src/matches/collapsible_match.rs
@@ -41,7 +41,7 @@ fn check_arm<'tcx>(
     let inner_expr = peel_blocks_with_stmt(outer_then_body);
     if let Some(inner) = IfLetOrMatch::parse(cx, inner_expr)
         && let Some((inner_scrutinee, inner_then_pat, inner_else_body)) = match inner {
-            IfLetOrMatch::IfLet(scrutinee, pat, _, els) => Some((scrutinee, pat, els)),
+            IfLetOrMatch::IfLet(scrutinee, pat, _, els, _) => Some((scrutinee, pat, els)),
             IfLetOrMatch::Match(scrutinee, arms, ..) => if arms.len() == 2 && arms.iter().all(|a| a.guard.is_none())
                 // if there are more than two arms, collapsing would be non-trivial
                 // one of the arms must be "wild-like"
@@ -75,7 +75,7 @@ fn check_arm<'tcx>(
         )
         // ...or anywhere in the inner expression
         && match inner {
-            IfLetOrMatch::IfLet(_, _, body, els) => {
+            IfLetOrMatch::IfLet(_, _, body, els, _) => {
                 !is_local_used(cx, body, binding_id) && els.map_or(true, |e| !is_local_used(cx, e, binding_id))
             },
             IfLetOrMatch::Match(_, arms, ..) => !arms.iter().any(|arm| is_local_used(cx, arm, binding_id)),
diff --git a/clippy_lints/src/matches/mod.rs b/clippy_lints/src/matches/mod.rs
index 4c7568f39b4..af6894545b8 100644
--- a/clippy_lints/src/matches/mod.rs
+++ b/clippy_lints/src/matches/mod.rs
@@ -1104,6 +1104,7 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
                     if_let.let_pat,
                     if_let.let_expr,
                     if_let.if_else.is_some(),
+                    if_let.let_span,
                 );
                 needless_match::check_if_let(cx, expr, &if_let);
             }
diff --git a/clippy_lints/src/matches/redundant_pattern_match.rs b/clippy_lints/src/matches/redundant_pattern_match.rs
index 2582f7edcf6..81c084b979a 100644
--- a/clippy_lints/src/matches/redundant_pattern_match.rs
+++ b/clippy_lints/src/matches/redundant_pattern_match.rs
@@ -12,13 +12,13 @@ use rustc_hir::LangItem::{self, OptionNone, OptionSome, PollPending, PollReady,
 use rustc_hir::{Arm, Expr, ExprKind, Guard, Node, Pat, PatKind, QPath, UnOp};
 use rustc_lint::LateContext;
 use rustc_middle::ty::{self, GenericArgKind, Ty};
-use rustc_span::{sym, Symbol};
+use rustc_span::{sym, Span, Symbol};
 use std::fmt::Write;
 use std::ops::ControlFlow;
 
 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
     if let Some(higher::WhileLet { let_pat, let_expr, .. }) = higher::WhileLet::hir(expr) {
-        find_sugg_for_if_let(cx, expr, let_pat, let_expr, "while", false);
+        find_method_sugg_for_if_let(cx, expr, let_pat, let_expr, "while", false);
     }
 }
 
@@ -28,8 +28,34 @@ pub(super) fn check_if_let<'tcx>(
     pat: &'tcx Pat<'_>,
     scrutinee: &'tcx Expr<'_>,
     has_else: bool,
+    let_span: Span,
 ) {
-    find_sugg_for_if_let(cx, expr, pat, scrutinee, "if", has_else);
+    find_if_let_true(cx, pat, scrutinee, let_span);
+    find_method_sugg_for_if_let(cx, expr, pat, scrutinee, "if", has_else);
+}
+
+fn find_if_let_true<'tcx>(cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>, scrutinee: &'tcx Expr<'_>, let_span: Span) {
+    if let PatKind::Lit(lit) = pat.kind
+        && let ExprKind::Lit(lit) = lit.kind
+        && let LitKind::Bool(is_true) = lit.node
+    {
+        let mut snip = snippet(cx, scrutinee.span, "..").into_owned();
+
+        if !is_true {
+            // Invert condition for `if let false = ...`
+            snip.insert(0, '!');
+        }
+
+        span_lint_and_sugg(
+            cx,
+            REDUNDANT_PATTERN_MATCHING,
+            let_span,
+            "using `if let` to pattern match a boolean",
+            "consider using a regular `if` expression",
+            snip,
+            Applicability::MachineApplicable,
+        );
+    }
 }
 
 // Extract the generic arguments out of a type
@@ -100,7 +126,7 @@ fn find_method_and_type<'tcx>(
     }
 }
 
-fn find_sugg_for_if_let<'tcx>(
+fn find_method_sugg_for_if_let<'tcx>(
     cx: &LateContext<'tcx>,
     expr: &'tcx Expr<'_>,
     let_pat: &Pat<'_>,
diff --git a/clippy_lints/src/methods/filter_map.rs b/clippy_lints/src/methods/filter_map.rs
index 844ab40cab1..db15bf2ad6c 100644
--- a/clippy_lints/src/methods/filter_map.rs
+++ b/clippy_lints/src/methods/filter_map.rs
@@ -186,7 +186,7 @@ impl<'tcx> OffendingFilterExpr<'tcx> {
                     match higher::IfLetOrMatch::parse(cx, map_body.value) {
                         // For `if let` we want to check that the variant matching arm references the local created by
                         // its pattern
-                        Some(higher::IfLetOrMatch::IfLet(sc, pat, then, Some(else_)))
+                        Some(higher::IfLetOrMatch::IfLet(sc, pat, then, Some(else_), ..))
                             if let Some((ident, span)) = expr_uses_local(pat, then) =>
                         {
                             (sc, else_, ident, span)
diff --git a/clippy_lints/src/option_if_let_else.rs b/clippy_lints/src/option_if_let_else.rs
index 89e4e3c740d..556c493d36c 100644
--- a/clippy_lints/src/option_if_let_else.rs
+++ b/clippy_lints/src/option_if_let_else.rs
@@ -238,6 +238,7 @@ fn detect_option_if_let_else<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>) ->
         let_expr,
         if_then,
         if_else: Some(if_else),
+        ..
     }) = higher::IfLet::hir(cx, expr)
         && !cx.typeck_results().expr_ty(expr).is_unit()
         && !is_else_clause(cx.tcx, expr)
diff --git a/clippy_lints/src/question_mark.rs b/clippy_lints/src/question_mark.rs
index fc5835408a9..6add1a81a0a 100644
--- a/clippy_lints/src/question_mark.rs
+++ b/clippy_lints/src/question_mark.rs
@@ -256,6 +256,7 @@ impl QuestionMark {
                 let_expr,
                 if_then,
                 if_else,
+                ..
             }) = higher::IfLet::hir(cx, expr)
             && !is_else_clause(cx.tcx, expr)
             && let PatKind::TupleStruct(ref path1, [field], ddpos) = let_pat.kind
diff --git a/clippy_utils/src/higher.rs b/clippy_utils/src/higher.rs
index 3135a033648..b2054bf7d41 100644
--- a/clippy_utils/src/higher.rs
+++ b/clippy_utils/src/higher.rs
@@ -91,6 +91,9 @@ pub struct IfLet<'hir> {
     pub if_then: &'hir Expr<'hir>,
     /// `if let` else expression
     pub if_else: Option<&'hir Expr<'hir>>,
+    /// `if let PAT = EXPR`
+    ///     ^^^^^^^^^^^^^^
+    pub let_span: Span,
 }
 
 impl<'hir> IfLet<'hir> {
@@ -99,9 +102,10 @@ impl<'hir> IfLet<'hir> {
         if let ExprKind::If(
             Expr {
                 kind:
-                    ExprKind::Let(hir::Let {
+                    ExprKind::Let(&hir::Let {
                         pat: let_pat,
                         init: let_expr,
+                        span: let_span,
                         ..
                     }),
                 ..
@@ -129,6 +133,7 @@ impl<'hir> IfLet<'hir> {
                 let_expr,
                 if_then,
                 if_else,
+                let_span,
             });
         }
         None
@@ -146,6 +151,9 @@ pub enum IfLetOrMatch<'hir> {
         &'hir Pat<'hir>,
         &'hir Expr<'hir>,
         Option<&'hir Expr<'hir>>,
+        /// `if let PAT = EXPR`
+        ///     ^^^^^^^^^^^^^^
+        Span,
     ),
 }
 
@@ -160,7 +168,8 @@ impl<'hir> IfLetOrMatch<'hir> {
                      let_pat,
                      if_then,
                      if_else,
-                 }| { Self::IfLet(let_expr, let_pat, if_then, if_else) },
+                     let_span,
+                 }| { Self::IfLet(let_expr, let_pat, if_then, if_else, let_span) },
             ),
         }
     }
-- 
cgit 1.4.1-3-g733a5


From bc22407b79e551d0604097155b512b11aa5516b1 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Sat, 16 Dec 2023 17:40:32 +0100
Subject: add tests, lint on `while let true` and `matches!(.., true)`

---
 clippy_lints/src/loops/while_let_on_iterator.rs    |  2 +-
 clippy_lints/src/matches/mod.rs                    | 21 +++++--
 .../src/matches/redundant_pattern_match.rs         | 70 ++++++++++++++++++----
 clippy_lints/src/utils/author.rs                   |  1 +
 clippy_utils/src/higher.rs                         |  7 ++-
 tests/ui/author/loop.rs                            |  6 +-
 tests/ui/branches_sharing_code/shared_at_bottom.rs |  8 ++-
 .../branches_sharing_code/shared_at_bottom.stderr  | 18 +++---
 tests/ui/collapsible_if.fixed                      |  3 +-
 tests/ui/collapsible_if.rs                         |  3 +-
 tests/ui/collapsible_if.stderr                     | 18 +++---
 tests/ui/if_then_some_else_none.rs                 |  1 +
 tests/ui/if_then_some_else_none.stderr             | 10 ++--
 tests/ui/needless_if.fixed                         |  1 +
 tests/ui/needless_if.rs                            |  1 +
 tests/ui/needless_if.stderr                        | 14 ++---
 tests/ui/nonminimal_bool.rs                        |  7 ++-
 tests/ui/nonminimal_bool.stderr                    | 26 ++++----
 .../redundant_pattern_matching_if_let_true.fixed   | 38 ++++++++++++
 tests/ui/redundant_pattern_matching_if_let_true.rs | 38 ++++++++++++
 .../redundant_pattern_matching_if_let_true.stderr  | 47 +++++++++++++++
 21 files changed, 272 insertions(+), 68 deletions(-)
 create mode 100644 tests/ui/redundant_pattern_matching_if_let_true.fixed
 create mode 100644 tests/ui/redundant_pattern_matching_if_let_true.rs
 create mode 100644 tests/ui/redundant_pattern_matching_if_let_true.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/while_let_on_iterator.rs b/clippy_lints/src/loops/while_let_on_iterator.rs
index 21b9efba54c..d070ee74985 100644
--- a/clippy_lints/src/loops/while_let_on_iterator.rs
+++ b/clippy_lints/src/loops/while_let_on_iterator.rs
@@ -14,7 +14,7 @@ use rustc_span::symbol::sym;
 use rustc_span::Symbol;
 
 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-    if let Some(higher::WhileLet { if_then, let_pat, let_expr }) = higher::WhileLet::hir(expr)
+    if let Some(higher::WhileLet { if_then, let_pat, let_expr, .. }) = higher::WhileLet::hir(expr)
         // check for `Some(..)` pattern
         && let PatKind::TupleStruct(ref pat_path, some_pat, _) = let_pat.kind
         && is_res_lang_ctor(cx, cx.qpath_res(pat_path, let_pat.hir_id), LangItem::OptionSome)
diff --git a/clippy_lints/src/matches/mod.rs b/clippy_lints/src/matches/mod.rs
index af6894545b8..50494f4819f 100644
--- a/clippy_lints/src/matches/mod.rs
+++ b/clippy_lints/src/matches/mod.rs
@@ -469,15 +469,15 @@ declare_clippy_lint! {
 declare_clippy_lint! {
     /// ### What it does
     /// Lint for redundant pattern matching over `Result`, `Option`,
-    /// `std::task::Poll` or `std::net::IpAddr`
+    /// `std::task::Poll`, `std::net::IpAddr` or `bool`s
     ///
     /// ### Why is this bad?
     /// It's more concise and clear to just use the proper
-    /// utility function
+    /// utility function or using the condition directly
     ///
     /// ### Known problems
-    /// This will change the drop order for the matched type. Both `if let` and
-    /// `while let` will drop the value at the end of the block, both `if` and `while` will drop the
+    /// For suggestions involving bindings in patterns, this will change the drop order for the matched type.
+    /// Both `if let` and `while let` will drop the value at the end of the block, both `if` and `while` will drop the
     /// value before entering the block. For most types this change will not matter, but for a few
     /// types this will not be an acceptable change (e.g. locks). See the
     /// [reference](https://doc.rust-lang.org/reference/destructors.html#drop-scopes) for more about
@@ -499,6 +499,10 @@ declare_clippy_lint! {
     ///     Ok(_) => true,
     ///     Err(_) => false,
     /// };
+    ///
+    /// let cond = true;
+    /// if let true = cond {}
+    /// matches!(cond, true);
     /// ```
     ///
     /// The more idiomatic use would be:
@@ -515,6 +519,10 @@ declare_clippy_lint! {
     /// if IpAddr::V4(Ipv4Addr::LOCALHOST).is_ipv4() {}
     /// if IpAddr::V6(Ipv6Addr::LOCALHOST).is_ipv6() {}
     /// Ok::<i32, i32>(42).is_ok();
+    ///
+    /// let cond = true;
+    /// if cond {}
+    /// cond;
     /// ```
     #[clippy::version = "1.31.0"]
     pub REDUNDANT_PATTERN_MATCHING,
@@ -1019,8 +1027,11 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
         let from_expansion = expr.span.from_expansion();
 
         if let ExprKind::Match(ex, arms, source) = expr.kind {
-            if is_direct_expn_of(expr.span, "matches").is_some() {
+            if is_direct_expn_of(expr.span, "matches").is_some()
+                && let [arm, _] = arms
+            {
                 redundant_pattern_match::check_match(cx, expr, ex, arms);
+                redundant_pattern_match::check_matches_true(cx, expr, arm, ex);
             }
 
             if source == MatchSource::Normal && !is_span_match(cx, expr.span) {
diff --git a/clippy_lints/src/matches/redundant_pattern_match.rs b/clippy_lints/src/matches/redundant_pattern_match.rs
index 81c084b979a..e32261ec1e4 100644
--- a/clippy_lints/src/matches/redundant_pattern_match.rs
+++ b/clippy_lints/src/matches/redundant_pattern_match.rs
@@ -1,7 +1,7 @@
 use super::REDUNDANT_PATTERN_MATCHING;
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::{snippet, walk_span_to_context};
-use clippy_utils::sugg::Sugg;
+use clippy_utils::sugg::{make_unop, Sugg};
 use clippy_utils::ty::{is_type_diagnostic_item, needs_ordered_drop};
 use clippy_utils::visitors::{any_temporaries_need_ordered_drop, for_each_expr};
 use clippy_utils::{higher, is_expn_of, is_trait_method};
@@ -17,8 +17,15 @@ use std::fmt::Write;
 use std::ops::ControlFlow;
 
 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-    if let Some(higher::WhileLet { let_pat, let_expr, .. }) = higher::WhileLet::hir(expr) {
+    if let Some(higher::WhileLet {
+        let_pat,
+        let_expr,
+        let_span,
+        ..
+    }) = higher::WhileLet::hir(expr)
+    {
         find_method_sugg_for_if_let(cx, expr, let_pat, let_expr, "while", false);
+        find_if_let_true(cx, let_pat, let_expr, let_span);
     }
 }
 
@@ -34,26 +41,65 @@ pub(super) fn check_if_let<'tcx>(
     find_method_sugg_for_if_let(cx, expr, pat, scrutinee, "if", has_else);
 }
 
+/// Looks for:
+/// * `matches!(expr, true)`
+pub fn check_matches_true<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx Expr<'_>,
+    arm: &'tcx Arm<'_>,
+    scrutinee: &'tcx Expr<'_>,
+) {
+    find_match_true(
+        cx,
+        arm.pat,
+        scrutinee,
+        expr.span.source_callsite(),
+        "using `matches!` to pattern match a bool",
+    );
+}
+
+/// Looks for any of:
+/// * `if let true = ...`
+/// * `if let false = ...`
+/// * `while let true = ...`
 fn find_if_let_true<'tcx>(cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>, scrutinee: &'tcx Expr<'_>, let_span: Span) {
+    find_match_true(cx, pat, scrutinee, let_span, "using `if let` to pattern match a bool");
+}
+
+/// Common logic between `find_if_let_true` and `check_matches_true`
+fn find_match_true<'tcx>(
+    cx: &LateContext<'tcx>,
+    pat: &'tcx Pat<'_>,
+    scrutinee: &'tcx Expr<'_>,
+    span: Span,
+    message: &str,
+) {
     if let PatKind::Lit(lit) = pat.kind
         && let ExprKind::Lit(lit) = lit.kind
-        && let LitKind::Bool(is_true) = lit.node
+        && let LitKind::Bool(pat_is_true) = lit.node
     {
-        let mut snip = snippet(cx, scrutinee.span, "..").into_owned();
+        let mut applicability = Applicability::MachineApplicable;
+
+        let mut sugg = Sugg::hir_with_context(
+            cx,
+            scrutinee,
+            scrutinee.span.source_callsite().ctxt(),
+            "..",
+            &mut applicability,
+        );
 
-        if !is_true {
-            // Invert condition for `if let false = ...`
-            snip.insert(0, '!');
+        if !pat_is_true {
+            sugg = make_unop("!", sugg);
         }
 
         span_lint_and_sugg(
             cx,
             REDUNDANT_PATTERN_MATCHING,
-            let_span,
-            "using `if let` to pattern match a boolean",
-            "consider using a regular `if` expression",
-            snip,
-            Applicability::MachineApplicable,
+            span,
+            message,
+            "consider using the condition directly",
+            sugg.to_string(),
+            applicability,
         );
     }
 }
diff --git a/clippy_lints/src/utils/author.rs b/clippy_lints/src/utils/author.rs
index e83c04eda20..a8bf142f5d5 100644
--- a/clippy_lints/src/utils/author.rs
+++ b/clippy_lints/src/utils/author.rs
@@ -350,6 +350,7 @@ impl<'a, 'tcx> PrintVisitor<'a, 'tcx> {
             let_pat,
             let_expr,
             if_then,
+            ..
         }) = higher::WhileLet::hir(expr.value)
         {
             bind!(self, let_pat, let_expr, if_then);
diff --git a/clippy_utils/src/higher.rs b/clippy_utils/src/higher.rs
index b2054bf7d41..ba682813dad 100644
--- a/clippy_utils/src/higher.rs
+++ b/clippy_utils/src/higher.rs
@@ -362,6 +362,9 @@ pub struct WhileLet<'hir> {
     pub let_expr: &'hir Expr<'hir>,
     /// `while let` loop body
     pub if_then: &'hir Expr<'hir>,
+    /// `while let PAT = EXPR`
+    ///        ^^^^^^^^^^^^^^
+    pub let_span: Span,
 }
 
 impl<'hir> WhileLet<'hir> {
@@ -376,9 +379,10 @@ impl<'hir> WhileLet<'hir> {
                             ExprKind::If(
                                 Expr {
                                     kind:
-                                        ExprKind::Let(hir::Let {
+                                        ExprKind::Let(&hir::Let {
                                             pat: let_pat,
                                             init: let_expr,
+                                            span: let_span,
                                             ..
                                         }),
                                     ..
@@ -399,6 +403,7 @@ impl<'hir> WhileLet<'hir> {
                 let_pat,
                 let_expr,
                 if_then,
+                let_span,
             });
         }
         None
diff --git a/tests/ui/author/loop.rs b/tests/ui/author/loop.rs
index d6de21631e2..ff5b6100117 100644
--- a/tests/ui/author/loop.rs
+++ b/tests/ui/author/loop.rs
@@ -1,5 +1,9 @@
 #![feature(stmt_expr_attributes)]
-#![allow(clippy::never_loop, clippy::while_immutable_condition)]
+#![allow(
+    clippy::never_loop,
+    clippy::while_immutable_condition,
+    clippy::redundant_pattern_matching
+)]
 
 fn main() {
     #[clippy::author]
diff --git a/tests/ui/branches_sharing_code/shared_at_bottom.rs b/tests/ui/branches_sharing_code/shared_at_bottom.rs
index d102efa7a58..549908b8770 100644
--- a/tests/ui/branches_sharing_code/shared_at_bottom.rs
+++ b/tests/ui/branches_sharing_code/shared_at_bottom.rs
@@ -1,6 +1,10 @@
 #![deny(clippy::if_same_then_else, clippy::branches_sharing_code)]
-#![allow(dead_code)]
-#![allow(clippy::equatable_if_let, clippy::uninlined_format_args)]
+#![allow(
+    clippy::equatable_if_let,
+    clippy::uninlined_format_args,
+    clippy::redundant_pattern_matching,
+    dead_code
+)]
 //@no-rustfix
 // This tests the branches_sharing_code lint at the end of blocks
 
diff --git a/tests/ui/branches_sharing_code/shared_at_bottom.stderr b/tests/ui/branches_sharing_code/shared_at_bottom.stderr
index d00717befc1..8223df0fe7b 100644
--- a/tests/ui/branches_sharing_code/shared_at_bottom.stderr
+++ b/tests/ui/branches_sharing_code/shared_at_bottom.stderr
@@ -1,5 +1,5 @@
 error: all if blocks contain the same code at the end
-  --> $DIR/shared_at_bottom.rs:31:5
+  --> $DIR/shared_at_bottom.rs:35:5
    |
 LL | /         let result = false;
 LL | |
@@ -26,7 +26,7 @@ LL ~     result;
    |
 
 error: all if blocks contain the same code at the end
-  --> $DIR/shared_at_bottom.rs:51:5
+  --> $DIR/shared_at_bottom.rs:55:5
    |
 LL | /         println!("Same end of block");
 LL | |
@@ -40,7 +40,7 @@ LL +     println!("Same end of block");
    |
 
 error: all if blocks contain the same code at the end
-  --> $DIR/shared_at_bottom.rs:69:5
+  --> $DIR/shared_at_bottom.rs:73:5
    |
 LL | /         println!(
 LL | |
@@ -61,7 +61,7 @@ LL +     );
    |
 
 error: all if blocks contain the same code at the end
-  --> $DIR/shared_at_bottom.rs:82:9
+  --> $DIR/shared_at_bottom.rs:86:9
    |
 LL | /             println!("Hello World");
 LL | |
@@ -75,7 +75,7 @@ LL +         println!("Hello World");
    |
 
 error: all if blocks contain the same code at the end
-  --> $DIR/shared_at_bottom.rs:99:5
+  --> $DIR/shared_at_bottom.rs:103:5
    |
 LL | /         let later_used_value = "A string value";
 LL | |
@@ -94,7 +94,7 @@ LL +     println!("{}", later_used_value);
    |
 
 error: all if blocks contain the same code at the end
-  --> $DIR/shared_at_bottom.rs:113:5
+  --> $DIR/shared_at_bottom.rs:117:5
    |
 LL | /         let simple_examples = "I now identify as a &str :)";
 LL | |
@@ -112,7 +112,7 @@ LL +     println!("This is the new simple_example: {}", simple_examples);
    |
 
 error: all if blocks contain the same code at the end
-  --> $DIR/shared_at_bottom.rs:179:5
+  --> $DIR/shared_at_bottom.rs:183:5
    |
 LL | /         x << 2
 LL | |
@@ -128,7 +128,7 @@ LL ~     x << 2;
    |
 
 error: all if blocks contain the same code at the end
-  --> $DIR/shared_at_bottom.rs:188:5
+  --> $DIR/shared_at_bottom.rs:192:5
    |
 LL | /         x * 4
 LL | |
@@ -144,7 +144,7 @@ LL +     x * 4
    |
 
 error: all if blocks contain the same code at the end
-  --> $DIR/shared_at_bottom.rs:202:44
+  --> $DIR/shared_at_bottom.rs:206:44
    |
 LL |     if x == 17 { b = 1; a = 0x99; } else { a = 0x99; }
    |                                            ^^^^^^^^^^^
diff --git a/tests/ui/collapsible_if.fixed b/tests/ui/collapsible_if.fixed
index fff6bfcc753..44b0b6e7391 100644
--- a/tests/ui/collapsible_if.fixed
+++ b/tests/ui/collapsible_if.fixed
@@ -3,7 +3,8 @@
     clippy::equatable_if_let,
     clippy::needless_if,
     clippy::nonminimal_bool,
-    clippy::eq_op
+    clippy::eq_op,
+    clippy::redundant_pattern_matching
 )]
 
 #[rustfmt::skip]
diff --git a/tests/ui/collapsible_if.rs b/tests/ui/collapsible_if.rs
index 70bfea231ae..563a273dcdd 100644
--- a/tests/ui/collapsible_if.rs
+++ b/tests/ui/collapsible_if.rs
@@ -3,7 +3,8 @@
     clippy::equatable_if_let,
     clippy::needless_if,
     clippy::nonminimal_bool,
-    clippy::eq_op
+    clippy::eq_op,
+    clippy::redundant_pattern_matching
 )]
 
 #[rustfmt::skip]
diff --git a/tests/ui/collapsible_if.stderr b/tests/ui/collapsible_if.stderr
index e8a36bf48f1..16df3e433db 100644
--- a/tests/ui/collapsible_if.stderr
+++ b/tests/ui/collapsible_if.stderr
@@ -1,5 +1,5 @@
 error: this `if` statement can be collapsed
-  --> $DIR/collapsible_if.rs:14:5
+  --> $DIR/collapsible_if.rs:15:5
    |
 LL | /     if x == "hello" {
 LL | |         if y == "world" {
@@ -18,7 +18,7 @@ LL +     }
    |
 
 error: this `if` statement can be collapsed
-  --> $DIR/collapsible_if.rs:20:5
+  --> $DIR/collapsible_if.rs:21:5
    |
 LL | /     if x == "hello" || x == "world" {
 LL | |         if y == "world" || y == "hello" {
@@ -35,7 +35,7 @@ LL +     }
    |
 
 error: this `if` statement can be collapsed
-  --> $DIR/collapsible_if.rs:26:5
+  --> $DIR/collapsible_if.rs:27:5
    |
 LL | /     if x == "hello" && x == "world" {
 LL | |         if y == "world" || y == "hello" {
@@ -52,7 +52,7 @@ LL +     }
    |
 
 error: this `if` statement can be collapsed
-  --> $DIR/collapsible_if.rs:32:5
+  --> $DIR/collapsible_if.rs:33:5
    |
 LL | /     if x == "hello" || x == "world" {
 LL | |         if y == "world" && y == "hello" {
@@ -69,7 +69,7 @@ LL +     }
    |
 
 error: this `if` statement can be collapsed
-  --> $DIR/collapsible_if.rs:38:5
+  --> $DIR/collapsible_if.rs:39:5
    |
 LL | /     if x == "hello" && x == "world" {
 LL | |         if y == "world" && y == "hello" {
@@ -86,7 +86,7 @@ LL +     }
    |
 
 error: this `if` statement can be collapsed
-  --> $DIR/collapsible_if.rs:44:5
+  --> $DIR/collapsible_if.rs:45:5
    |
 LL | /     if 42 == 1337 {
 LL | |         if 'a' != 'A' {
@@ -103,7 +103,7 @@ LL +     }
    |
 
 error: this `if` statement can be collapsed
-  --> $DIR/collapsible_if.rs:100:5
+  --> $DIR/collapsible_if.rs:101:5
    |
 LL | /     if x == "hello" {
 LL | |         if y == "world" { // Collapsible
@@ -120,7 +120,7 @@ LL +     }
    |
 
 error: this `if` statement can be collapsed
-  --> $DIR/collapsible_if.rs:159:5
+  --> $DIR/collapsible_if.rs:160:5
    |
 LL | /     if matches!(true, true) {
 LL | |         if matches!(true, true) {}
@@ -128,7 +128,7 @@ LL | |     }
    | |_____^ help: collapse nested if block: `if matches!(true, true) && matches!(true, true) {}`
 
 error: this `if` statement can be collapsed
-  --> $DIR/collapsible_if.rs:164:5
+  --> $DIR/collapsible_if.rs:165:5
    |
 LL | /     if matches!(true, true) && truth() {
 LL | |         if matches!(true, true) {}
diff --git a/tests/ui/if_then_some_else_none.rs b/tests/ui/if_then_some_else_none.rs
index 77abd663e0a..abc92459148 100644
--- a/tests/ui/if_then_some_else_none.rs
+++ b/tests/ui/if_then_some_else_none.rs
@@ -1,4 +1,5 @@
 #![warn(clippy::if_then_some_else_none)]
+#![allow(clippy::redundant_pattern_matching)]
 
 fn main() {
     // Should issue an error.
diff --git a/tests/ui/if_then_some_else_none.stderr b/tests/ui/if_then_some_else_none.stderr
index 5c97b06da15..9b3d65cc803 100644
--- a/tests/ui/if_then_some_else_none.stderr
+++ b/tests/ui/if_then_some_else_none.stderr
@@ -1,5 +1,5 @@
 error: this could be simplified with `bool::then`
-  --> $DIR/if_then_some_else_none.rs:5:13
+  --> $DIR/if_then_some_else_none.rs:6:13
    |
 LL |       let _ = if foo() {
    |  _____________^
@@ -16,7 +16,7 @@ LL | |     };
    = help: to override `-D warnings` add `#[allow(clippy::if_then_some_else_none)]`
 
 error: this could be simplified with `bool::then`
-  --> $DIR/if_then_some_else_none.rs:14:13
+  --> $DIR/if_then_some_else_none.rs:15:13
    |
 LL |       let _ = if matches!(true, true) {
    |  _____________^
@@ -31,7 +31,7 @@ LL | |     };
    = help: consider using `bool::then` like: `matches!(true, true).then(|| { /* snippet */ matches!(true, false) })`
 
 error: this could be simplified with `bool::then_some`
-  --> $DIR/if_then_some_else_none.rs:24:28
+  --> $DIR/if_then_some_else_none.rs:25:28
    |
 LL |     let _ = x.and_then(|o| if o < 32 { Some(o) } else { None });
    |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -39,7 +39,7 @@ LL |     let _ = x.and_then(|o| if o < 32 { Some(o) } else { None });
    = help: consider using `bool::then_some` like: `(o < 32).then_some(o)`
 
 error: this could be simplified with `bool::then_some`
-  --> $DIR/if_then_some_else_none.rs:29:13
+  --> $DIR/if_then_some_else_none.rs:30:13
    |
 LL |     let _ = if !x { Some(0) } else { None };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -47,7 +47,7 @@ LL |     let _ = if !x { Some(0) } else { None };
    = help: consider using `bool::then_some` like: `(!x).then_some(0)`
 
 error: this could be simplified with `bool::then`
-  --> $DIR/if_then_some_else_none.rs:85:13
+  --> $DIR/if_then_some_else_none.rs:86:13
    |
 LL |       let _ = if foo() {
    |  _____________^
diff --git a/tests/ui/needless_if.fixed b/tests/ui/needless_if.fixed
index 1086ae2c984..79e33a7218b 100644
--- a/tests/ui/needless_if.fixed
+++ b/tests/ui/needless_if.fixed
@@ -10,6 +10,7 @@
     clippy::nonminimal_bool,
     clippy::short_circuit_statement,
     clippy::unnecessary_operation,
+    clippy::redundant_pattern_matching,
     unused
 )]
 #![warn(clippy::needless_if)]
diff --git a/tests/ui/needless_if.rs b/tests/ui/needless_if.rs
index 131cceaf712..2c135fb22bf 100644
--- a/tests/ui/needless_if.rs
+++ b/tests/ui/needless_if.rs
@@ -10,6 +10,7 @@
     clippy::nonminimal_bool,
     clippy::short_circuit_statement,
     clippy::unnecessary_operation,
+    clippy::redundant_pattern_matching,
     unused
 )]
 #![warn(clippy::needless_if)]
diff --git a/tests/ui/needless_if.stderr b/tests/ui/needless_if.stderr
index c3e83c0f1f5..9a911b4dbac 100644
--- a/tests/ui/needless_if.stderr
+++ b/tests/ui/needless_if.stderr
@@ -1,5 +1,5 @@
 error: this `if` branch is empty
-  --> $DIR/needless_if.rs:26:5
+  --> $DIR/needless_if.rs:27:5
    |
 LL |     if (true) {}
    |     ^^^^^^^^^^^^ help: you can remove it
@@ -8,13 +8,13 @@ LL |     if (true) {}
    = help: to override `-D warnings` add `#[allow(clippy::needless_if)]`
 
 error: this `if` branch is empty
-  --> $DIR/needless_if.rs:28:5
+  --> $DIR/needless_if.rs:29:5
    |
 LL |     if maybe_side_effect() {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^ help: you can remove it: `maybe_side_effect();`
 
 error: this `if` branch is empty
-  --> $DIR/needless_if.rs:33:5
+  --> $DIR/needless_if.rs:34:5
    |
 LL | /     if {
 LL | |         return;
@@ -29,7 +29,7 @@ LL +     });
    |
 
 error: this `if` branch is empty
-  --> $DIR/needless_if.rs:49:5
+  --> $DIR/needless_if.rs:50:5
    |
 LL | /     if {
 LL | |         if let true = true
@@ -54,19 +54,19 @@ LL +     } && true);
    |
 
 error: this `if` branch is empty
-  --> $DIR/needless_if.rs:93:5
+  --> $DIR/needless_if.rs:94:5
    |
 LL |     if { maybe_side_effect() } {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: you can remove it: `({ maybe_side_effect() });`
 
 error: this `if` branch is empty
-  --> $DIR/needless_if.rs:95:5
+  --> $DIR/needless_if.rs:96:5
    |
 LL |     if { maybe_side_effect() } && true {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: you can remove it: `({ maybe_side_effect() } && true);`
 
 error: this `if` branch is empty
-  --> $DIR/needless_if.rs:99:5
+  --> $DIR/needless_if.rs:100:5
    |
 LL |     if true {}
    |     ^^^^^^^^^^ help: you can remove it: `true;`
diff --git a/tests/ui/nonminimal_bool.rs b/tests/ui/nonminimal_bool.rs
index da7876e772e..4d48ef14d31 100644
--- a/tests/ui/nonminimal_bool.rs
+++ b/tests/ui/nonminimal_bool.rs
@@ -1,6 +1,11 @@
 //@no-rustfix: overlapping suggestions
 #![feature(lint_reasons)]
-#![allow(unused, clippy::diverging_sub_expression, clippy::needless_if)]
+#![allow(
+    unused,
+    clippy::diverging_sub_expression,
+    clippy::needless_if,
+    clippy::redundant_pattern_matching
+)]
 #![warn(clippy::nonminimal_bool)]
 #![allow(clippy::useless_vec)]
 
diff --git a/tests/ui/nonminimal_bool.stderr b/tests/ui/nonminimal_bool.stderr
index deae389dbef..fd1568d94e3 100644
--- a/tests/ui/nonminimal_bool.stderr
+++ b/tests/ui/nonminimal_bool.stderr
@@ -1,5 +1,5 @@
 error: this boolean expression can be simplified
-  --> $DIR/nonminimal_bool.rs:13:13
+  --> $DIR/nonminimal_bool.rs:18:13
    |
 LL |     let _ = !true;
    |             ^^^^^ help: try: `false`
@@ -8,43 +8,43 @@ LL |     let _ = !true;
    = help: to override `-D warnings` add `#[allow(clippy::nonminimal_bool)]`
 
 error: this boolean expression can be simplified
-  --> $DIR/nonminimal_bool.rs:16:13
+  --> $DIR/nonminimal_bool.rs:21:13
    |
 LL |     let _ = !false;
    |             ^^^^^^ help: try: `true`
 
 error: this boolean expression can be simplified
-  --> $DIR/nonminimal_bool.rs:18:13
+  --> $DIR/nonminimal_bool.rs:23:13
    |
 LL |     let _ = !!a;
    |             ^^^ help: try: `a`
 
 error: this boolean expression can be simplified
-  --> $DIR/nonminimal_bool.rs:20:13
+  --> $DIR/nonminimal_bool.rs:25:13
    |
 LL |     let _ = false || a;
    |             ^^^^^^^^^^ help: try: `a`
 
 error: this boolean expression can be simplified
-  --> $DIR/nonminimal_bool.rs:25:13
+  --> $DIR/nonminimal_bool.rs:30:13
    |
 LL |     let _ = !(!a && b);
    |             ^^^^^^^^^^ help: try: `a || !b`
 
 error: this boolean expression can be simplified
-  --> $DIR/nonminimal_bool.rs:27:13
+  --> $DIR/nonminimal_bool.rs:32:13
    |
 LL |     let _ = !(!a || b);
    |             ^^^^^^^^^^ help: try: `a && !b`
 
 error: this boolean expression can be simplified
-  --> $DIR/nonminimal_bool.rs:29:13
+  --> $DIR/nonminimal_bool.rs:34:13
    |
 LL |     let _ = !a && !(b && c);
    |             ^^^^^^^^^^^^^^^ help: try: `!(a || b && c)`
 
 error: this boolean expression can be simplified
-  --> $DIR/nonminimal_bool.rs:38:13
+  --> $DIR/nonminimal_bool.rs:43:13
    |
 LL |     let _ = a == b && c == 5 && a == b;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -57,7 +57,7 @@ LL |     let _ = a == b && c == 5;
    |             ~~~~~~~~~~~~~~~~
 
 error: this boolean expression can be simplified
-  --> $DIR/nonminimal_bool.rs:40:13
+  --> $DIR/nonminimal_bool.rs:45:13
    |
 LL |     let _ = a == b || c == 5 || a == b;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -70,7 +70,7 @@ LL |     let _ = a == b || c == 5;
    |             ~~~~~~~~~~~~~~~~
 
 error: this boolean expression can be simplified
-  --> $DIR/nonminimal_bool.rs:42:13
+  --> $DIR/nonminimal_bool.rs:47:13
    |
 LL |     let _ = a == b && c == 5 && b == a;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -83,7 +83,7 @@ LL |     let _ = a == b && c == 5;
    |             ~~~~~~~~~~~~~~~~
 
 error: this boolean expression can be simplified
-  --> $DIR/nonminimal_bool.rs:44:13
+  --> $DIR/nonminimal_bool.rs:49:13
    |
 LL |     let _ = a != b || !(a != b || c == d);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -96,7 +96,7 @@ LL |     let _ = a != b || c != d;
    |             ~~~~~~~~~~~~~~~~
 
 error: this boolean expression can be simplified
-  --> $DIR/nonminimal_bool.rs:46:13
+  --> $DIR/nonminimal_bool.rs:51:13
    |
 LL |     let _ = a != b && !(a != b && c == d);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -109,7 +109,7 @@ LL |     let _ = a != b && c != d;
    |             ~~~~~~~~~~~~~~~~
 
 error: this boolean expression can be simplified
-  --> $DIR/nonminimal_bool.rs:77:8
+  --> $DIR/nonminimal_bool.rs:82:8
    |
 LL |     if matches!(true, true) && true {
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `matches!(true, true)`
diff --git a/tests/ui/redundant_pattern_matching_if_let_true.fixed b/tests/ui/redundant_pattern_matching_if_let_true.fixed
new file mode 100644
index 00000000000..6d910678934
--- /dev/null
+++ b/tests/ui/redundant_pattern_matching_if_let_true.fixed
@@ -0,0 +1,38 @@
+#![warn(clippy::redundant_pattern_matching)]
+#![allow(clippy::needless_if, clippy::no_effect, clippy::nonminimal_bool)]
+
+macro_rules! condition {
+    () => {
+        true
+    };
+}
+
+macro_rules! lettrue {
+    (if) => {
+        if let true = true {}
+    };
+    (while) => {
+        while let true = true {}
+    };
+}
+
+fn main() {
+    let mut k = 5;
+
+    if k > 1 {}
+    if !(k > 5) {}
+    if k > 1 {}
+    if let (true, true) = (k > 1, k > 2) {}
+    while k > 1 {
+        k += 1;
+    }
+    while condition!() {
+        k += 1;
+    }
+
+    k > 5;
+    !(k > 5);
+    // Whole loop is from a macro expansion, don't lint:
+    lettrue!(if);
+    lettrue!(while);
+}
diff --git a/tests/ui/redundant_pattern_matching_if_let_true.rs b/tests/ui/redundant_pattern_matching_if_let_true.rs
new file mode 100644
index 00000000000..a82e673982a
--- /dev/null
+++ b/tests/ui/redundant_pattern_matching_if_let_true.rs
@@ -0,0 +1,38 @@
+#![warn(clippy::redundant_pattern_matching)]
+#![allow(clippy::needless_if, clippy::no_effect, clippy::nonminimal_bool)]
+
+macro_rules! condition {
+    () => {
+        true
+    };
+}
+
+macro_rules! lettrue {
+    (if) => {
+        if let true = true {}
+    };
+    (while) => {
+        while let true = true {}
+    };
+}
+
+fn main() {
+    let mut k = 5;
+
+    if let true = k > 1 {}
+    if let false = k > 5 {}
+    if let (true) = k > 1 {}
+    if let (true, true) = (k > 1, k > 2) {}
+    while let true = k > 1 {
+        k += 1;
+    }
+    while let true = condition!() {
+        k += 1;
+    }
+
+    matches!(k > 5, true);
+    matches!(k > 5, false);
+    // Whole loop is from a macro expansion, don't lint:
+    lettrue!(if);
+    lettrue!(while);
+}
diff --git a/tests/ui/redundant_pattern_matching_if_let_true.stderr b/tests/ui/redundant_pattern_matching_if_let_true.stderr
new file mode 100644
index 00000000000..211a332d79a
--- /dev/null
+++ b/tests/ui/redundant_pattern_matching_if_let_true.stderr
@@ -0,0 +1,47 @@
+error: using `if let` to pattern match a bool
+  --> $DIR/redundant_pattern_matching_if_let_true.rs:22:8
+   |
+LL |     if let true = k > 1 {}
+   |        ^^^^^^^^^^^^^^^^ help: consider using the condition directly: `k > 1`
+   |
+   = note: `-D clippy::redundant-pattern-matching` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::redundant_pattern_matching)]`
+
+error: using `if let` to pattern match a bool
+  --> $DIR/redundant_pattern_matching_if_let_true.rs:23:8
+   |
+LL |     if let false = k > 5 {}
+   |        ^^^^^^^^^^^^^^^^^ help: consider using the condition directly: `!(k > 5)`
+
+error: using `if let` to pattern match a bool
+  --> $DIR/redundant_pattern_matching_if_let_true.rs:24:8
+   |
+LL |     if let (true) = k > 1 {}
+   |        ^^^^^^^^^^^^^^^^^^ help: consider using the condition directly: `k > 1`
+
+error: using `if let` to pattern match a bool
+  --> $DIR/redundant_pattern_matching_if_let_true.rs:26:11
+   |
+LL |     while let true = k > 1 {
+   |           ^^^^^^^^^^^^^^^^ help: consider using the condition directly: `k > 1`
+
+error: using `if let` to pattern match a bool
+  --> $DIR/redundant_pattern_matching_if_let_true.rs:29:11
+   |
+LL |     while let true = condition!() {
+   |           ^^^^^^^^^^^^^^^^^^^^^^^ help: consider using the condition directly: `condition!()`
+
+error: using `matches!` to pattern match a bool
+  --> $DIR/redundant_pattern_matching_if_let_true.rs:33:5
+   |
+LL |     matches!(k > 5, true);
+   |     ^^^^^^^^^^^^^^^^^^^^^ help: consider using the condition directly: `k > 5`
+
+error: using `matches!` to pattern match a bool
+  --> $DIR/redundant_pattern_matching_if_let_true.rs:34:5
+   |
+LL |     matches!(k > 5, false);
+   |     ^^^^^^^^^^^^^^^^^^^^^^ help: consider using the condition directly: `!(k > 5)`
+
+error: aborting due to 7 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 6b444f3092bc9133bbbf67cc989b6dd74a228494 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Sat, 16 Dec 2023 18:15:32 +0100
Subject: Also check code generated by macros

---
 clippy_lints/src/unconditional_recursion.rs |  24 +++--
 tests/ui/unconditional_recursion.rs         |  35 +++++++
 tests/ui/unconditional_recursion.stderr     | 155 ++++++++++------------------
 3 files changed, 104 insertions(+), 110 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unconditional_recursion.rs b/clippy_lints/src/unconditional_recursion.rs
index e267c6d8534..b1fa30aa068 100644
--- a/clippy_lints/src/unconditional_recursion.rs
+++ b/clippy_lints/src/unconditional_recursion.rs
@@ -1,10 +1,10 @@
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::{get_parent_as_impl, get_trait_def_id, path_res};
+use clippy_utils::{get_trait_def_id, path_res};
 use rustc_ast::BinOpKind;
 use rustc_hir::def::Res;
 use rustc_hir::def_id::{DefId, LocalDefId};
 use rustc_hir::intravisit::FnKind;
-use rustc_hir::{Body, Expr, ExprKind, FnDecl};
+use rustc_hir::{Body, Expr, ExprKind, FnDecl, Item, ItemKind, Node};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{self, Ty};
 use rustc_session::declare_lint_pass;
@@ -66,22 +66,32 @@ impl<'tcx> LateLintPass<'tcx> for UnconditionalRecursion {
         method_span: Span,
         def_id: LocalDefId,
     ) {
-        // We don't check code generated from (proc) macro.
-        if method_span.from_expansion() {
-            return;
-        }
+        // If the function is a method...
         if let FnKind::Method(name, _) = kind
+            // That has two arguments.
             && let [self_arg, other_arg] = cx
                 .tcx
                 .instantiate_bound_regions_with_erased(cx.tcx.fn_sig(def_id).skip_binder())
                 .inputs()
             && let Some(self_arg) = get_ty_def_id(*self_arg)
             && let Some(other_arg) = get_ty_def_id(*other_arg)
+            // The two arguments are of the same type.
             && self_arg == other_arg
             && let hir_id = cx.tcx.local_def_id_to_hir_id(def_id)
-            && let Some(impl_) = get_parent_as_impl(cx.tcx, hir_id)
+            && let Some((
+                _,
+                Node::Item(Item {
+                    kind: ItemKind::Impl(impl_),
+                    owner_id,
+                    ..
+                }),
+            )) = cx.tcx.hir().parent_iter(hir_id).next()
+            // We exclude `impl` blocks generated from rustc's proc macros.
+            && !cx.tcx.has_attr(*owner_id, sym::automatically_derived)
+            // It is a implementation of a trait.
             && let Some(trait_) = impl_.of_trait
             && let Some(trait_def_id) = trait_.trait_def_id()
+            // The trait is `PartialEq`.
             && Some(trait_def_id) == get_trait_def_id(cx, &["core", "cmp", "PartialEq"])
         {
             let to_check_op = if name.name == sym::eq {
diff --git a/tests/ui/unconditional_recursion.rs b/tests/ui/unconditional_recursion.rs
index 3095b707c28..1169118de83 100644
--- a/tests/ui/unconditional_recursion.rs
+++ b/tests/ui/unconditional_recursion.rs
@@ -1,6 +1,7 @@
 //@no-rustfix
 
 #![warn(clippy::unconditional_recursion)]
+#![allow(clippy::partialeq_ne_impl)]
 
 enum Foo {
     A,
@@ -123,6 +124,40 @@ impl PartialEq for S3 {
     }
 }
 
+// There should be no warning here!
+#[derive(PartialEq)]
+enum E {
+    A,
+    B,
+}
+
+#[derive(PartialEq)]
+struct Bar<T: PartialEq>(T);
+
+struct S4;
+
+impl PartialEq for S4 {
+    fn eq(&self, other: &Self) -> bool {
+        // No warning here.
+        Bar(self) == Bar(other)
+    }
+}
+
+macro_rules! impl_partial_eq {
+    ($ty:ident) => {
+        impl PartialEq for $ty {
+            fn eq(&self, other: &Self) -> bool {
+                self == other
+            }
+        }
+    };
+}
+
+struct S5;
+
+impl_partial_eq!(S5);
+//~^ ERROR: function cannot return without recursing
+
 fn main() {
     // test code goes here
 }
diff --git a/tests/ui/unconditional_recursion.stderr b/tests/ui/unconditional_recursion.stderr
index 206bd98a59f..1fb01c00f19 100644
--- a/tests/ui/unconditional_recursion.stderr
+++ b/tests/ui/unconditional_recursion.stderr
@@ -1,5 +1,5 @@
 error: function cannot return without recursing
-  --> $DIR/unconditional_recursion.rs:41:5
+  --> $DIR/unconditional_recursion.rs:42:5
    |
 LL |     fn ne(&self, other: &Self) -> bool {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot return without recursing
@@ -12,7 +12,7 @@ LL |         self.ne(other)
    = help: to override `-D warnings` add `#[allow(unconditional_recursion)]`
 
 error: function cannot return without recursing
-  --> $DIR/unconditional_recursion.rs:45:5
+  --> $DIR/unconditional_recursion.rs:46:5
    |
 LL |     fn eq(&self, other: &Self) -> bool {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot return without recursing
@@ -22,20 +22,8 @@ LL |         self.eq(other)
    |
    = help: a `loop` may express intention better if this is on purpose
 
-error: re-implementing `PartialEq::ne` is unnecessary
-  --> $DIR/unconditional_recursion.rs:11:5
-   |
-LL | /     fn ne(&self, other: &Self) -> bool {
-LL | |
-LL | |         self != other
-LL | |     }
-   | |_____^
-   |
-   = note: `-D clippy::partialeq-ne-impl` implied by `-D warnings`
-   = help: to override `-D warnings` add `#[allow(clippy::partialeq_ne_impl)]`
-
 error: function cannot return without recursing
-  --> $DIR/unconditional_recursion.rs:11:5
+  --> $DIR/unconditional_recursion.rs:12:5
    |
 LL | /     fn ne(&self, other: &Self) -> bool {
 LL | |
@@ -44,7 +32,7 @@ LL | |     }
    | |_____^
    |
 note: recursive call site
-  --> $DIR/unconditional_recursion.rs:13:9
+  --> $DIR/unconditional_recursion.rs:14:9
    |
 LL |         self != other
    |         ^^^^^^^^^^^^^
@@ -52,7 +40,7 @@ LL |         self != other
    = help: to override `-D warnings` add `#[allow(clippy::unconditional_recursion)]`
 
 error: function cannot return without recursing
-  --> $DIR/unconditional_recursion.rs:15:5
+  --> $DIR/unconditional_recursion.rs:16:5
    |
 LL | /     fn eq(&self, other: &Self) -> bool {
 LL | |
@@ -61,30 +49,13 @@ LL | |     }
    | |_____^
    |
 note: recursive call site
-  --> $DIR/unconditional_recursion.rs:17:9
+  --> $DIR/unconditional_recursion.rs:18:9
    |
 LL |         self == other
    |         ^^^^^^^^^^^^^
 
-error: re-implementing `PartialEq::ne` is unnecessary
-  --> $DIR/unconditional_recursion.rs:27:5
-   |
-LL | /     fn ne(&self, other: &Self) -> bool {
-LL | |         self != &Foo2::B // no error here
-LL | |     }
-   | |_____^
-
-error: re-implementing `PartialEq::ne` is unnecessary
-  --> $DIR/unconditional_recursion.rs:41:5
-   |
-LL | /     fn ne(&self, other: &Self) -> bool {
-LL | |
-LL | |         self.ne(other)
-LL | |     }
-   | |_____^
-
 error: function cannot return without recursing
-  --> $DIR/unconditional_recursion.rs:41:5
+  --> $DIR/unconditional_recursion.rs:42:5
    |
 LL | /     fn ne(&self, other: &Self) -> bool {
 LL | |
@@ -93,19 +64,19 @@ LL | |     }
    | |_____^
    |
 note: recursive call site
-  --> $DIR/unconditional_recursion.rs:43:9
+  --> $DIR/unconditional_recursion.rs:44:9
    |
 LL |         self.ne(other)
    |         ^^^^^^^^^^^^^^
 
 error: parameter is only used in recursion
-  --> $DIR/unconditional_recursion.rs:41:18
+  --> $DIR/unconditional_recursion.rs:42:18
    |
 LL |     fn ne(&self, other: &Self) -> bool {
    |                  ^^^^^ help: if this is intentional, prefix it with an underscore: `_other`
    |
 note: parameter used here
-  --> $DIR/unconditional_recursion.rs:43:17
+  --> $DIR/unconditional_recursion.rs:44:17
    |
 LL |         self.ne(other)
    |                 ^^^^^
@@ -113,7 +84,7 @@ LL |         self.ne(other)
    = help: to override `-D warnings` add `#[allow(clippy::only_used_in_recursion)]`
 
 error: function cannot return without recursing
-  --> $DIR/unconditional_recursion.rs:45:5
+  --> $DIR/unconditional_recursion.rs:46:5
    |
 LL | /     fn eq(&self, other: &Self) -> bool {
 LL | |
@@ -122,50 +93,25 @@ LL | |     }
    | |_____^
    |
 note: recursive call site
-  --> $DIR/unconditional_recursion.rs:47:9
+  --> $DIR/unconditional_recursion.rs:48:9
    |
 LL |         self.eq(other)
    |         ^^^^^^^^^^^^^^
 
 error: parameter is only used in recursion
-  --> $DIR/unconditional_recursion.rs:45:18
+  --> $DIR/unconditional_recursion.rs:46:18
    |
 LL |     fn eq(&self, other: &Self) -> bool {
    |                  ^^^^^ help: if this is intentional, prefix it with an underscore: `_other`
    |
 note: parameter used here
-  --> $DIR/unconditional_recursion.rs:47:17
+  --> $DIR/unconditional_recursion.rs:48:17
    |
 LL |         self.eq(other)
    |                 ^^^^^
 
-error: re-implementing `PartialEq::ne` is unnecessary
-  --> $DIR/unconditional_recursion.rs:57:5
-   |
-LL | /     fn ne(&self, other: &Self) -> bool {
-LL | |         self.eq(other) // no error
-LL | |     }
-   | |_____^
-
-error: re-implementing `PartialEq::ne` is unnecessary
-  --> $DIR/unconditional_recursion.rs:77:5
-   |
-LL | /     fn ne(&self, other: &Self) -> bool {
-LL | |         self.a() // no error
-LL | |     }
-   | |_____^
-
-error: re-implementing `PartialEq::ne` is unnecessary
-  --> $DIR/unconditional_recursion.rs:89:5
-   |
-LL | /     fn ne(&self, other: &Self) -> bool {
-LL | |
-LL | |         other != self
-LL | |     }
-   | |_____^
-
 error: function cannot return without recursing
-  --> $DIR/unconditional_recursion.rs:89:5
+  --> $DIR/unconditional_recursion.rs:90:5
    |
 LL | /     fn ne(&self, other: &Self) -> bool {
 LL | |
@@ -174,13 +120,13 @@ LL | |     }
    | |_____^
    |
 note: recursive call site
-  --> $DIR/unconditional_recursion.rs:91:9
+  --> $DIR/unconditional_recursion.rs:92:9
    |
 LL |         other != self
    |         ^^^^^^^^^^^^^
 
 error: function cannot return without recursing
-  --> $DIR/unconditional_recursion.rs:93:5
+  --> $DIR/unconditional_recursion.rs:94:5
    |
 LL | /     fn eq(&self, other: &Self) -> bool {
 LL | |
@@ -189,22 +135,13 @@ LL | |     }
    | |_____^
    |
 note: recursive call site
-  --> $DIR/unconditional_recursion.rs:95:9
+  --> $DIR/unconditional_recursion.rs:96:9
    |
 LL |         other == self
    |         ^^^^^^^^^^^^^
 
-error: re-implementing `PartialEq::ne` is unnecessary
-  --> $DIR/unconditional_recursion.rs:103:5
-   |
-LL | /     fn ne(&self, other: &Self) -> bool {
-LL | |
-LL | |         other != other
-LL | |     }
-   | |_____^
-
 error: function cannot return without recursing
-  --> $DIR/unconditional_recursion.rs:103:5
+  --> $DIR/unconditional_recursion.rs:104:5
    |
 LL | /     fn ne(&self, other: &Self) -> bool {
 LL | |
@@ -213,13 +150,13 @@ LL | |     }
    | |_____^
    |
 note: recursive call site
-  --> $DIR/unconditional_recursion.rs:105:9
+  --> $DIR/unconditional_recursion.rs:106:9
    |
 LL |         other != other
    |         ^^^^^^^^^^^^^^
 
 error: equal expressions as operands to `!=`
-  --> $DIR/unconditional_recursion.rs:105:9
+  --> $DIR/unconditional_recursion.rs:106:9
    |
 LL |         other != other
    |         ^^^^^^^^^^^^^^
@@ -227,7 +164,7 @@ LL |         other != other
    = note: `#[deny(clippy::eq_op)]` on by default
 
 error: function cannot return without recursing
-  --> $DIR/unconditional_recursion.rs:107:5
+  --> $DIR/unconditional_recursion.rs:108:5
    |
 LL | /     fn eq(&self, other: &Self) -> bool {
 LL | |
@@ -236,28 +173,19 @@ LL | |     }
    | |_____^
    |
 note: recursive call site
-  --> $DIR/unconditional_recursion.rs:109:9
+  --> $DIR/unconditional_recursion.rs:110:9
    |
 LL |         other == other
    |         ^^^^^^^^^^^^^^
 
 error: equal expressions as operands to `==`
-  --> $DIR/unconditional_recursion.rs:109:9
+  --> $DIR/unconditional_recursion.rs:110:9
    |
 LL |         other == other
    |         ^^^^^^^^^^^^^^
 
-error: re-implementing `PartialEq::ne` is unnecessary
-  --> $DIR/unconditional_recursion.rs:116:5
-   |
-LL | /     fn ne(&self, _other: &Self) -> bool {
-LL | |
-LL | |         self != self
-LL | |     }
-   | |_____^
-
 error: function cannot return without recursing
-  --> $DIR/unconditional_recursion.rs:116:5
+  --> $DIR/unconditional_recursion.rs:117:5
    |
 LL | /     fn ne(&self, _other: &Self) -> bool {
 LL | |
@@ -266,19 +194,19 @@ LL | |     }
    | |_____^
    |
 note: recursive call site
-  --> $DIR/unconditional_recursion.rs:118:9
+  --> $DIR/unconditional_recursion.rs:119:9
    |
 LL |         self != self
    |         ^^^^^^^^^^^^
 
 error: equal expressions as operands to `!=`
-  --> $DIR/unconditional_recursion.rs:118:9
+  --> $DIR/unconditional_recursion.rs:119:9
    |
 LL |         self != self
    |         ^^^^^^^^^^^^
 
 error: function cannot return without recursing
-  --> $DIR/unconditional_recursion.rs:120:5
+  --> $DIR/unconditional_recursion.rs:121:5
    |
 LL | /     fn eq(&self, _other: &Self) -> bool {
 LL | |
@@ -287,16 +215,37 @@ LL | |     }
    | |_____^
    |
 note: recursive call site
-  --> $DIR/unconditional_recursion.rs:122:9
+  --> $DIR/unconditional_recursion.rs:123:9
    |
 LL |         self == self
    |         ^^^^^^^^^^^^
 
 error: equal expressions as operands to `==`
-  --> $DIR/unconditional_recursion.rs:122:9
+  --> $DIR/unconditional_recursion.rs:123:9
    |
 LL |         self == self
    |         ^^^^^^^^^^^^
 
-error: aborting due to 26 previous errors
+error: function cannot return without recursing
+  --> $DIR/unconditional_recursion.rs:149:13
+   |
+LL | /             fn eq(&self, other: &Self) -> bool {
+LL | |                 self == other
+LL | |             }
+   | |_____________^
+...
+LL |   impl_partial_eq!(S5);
+   |   -------------------- in this macro invocation
+   |
+note: recursive call site
+  --> $DIR/unconditional_recursion.rs:150:17
+   |
+LL |                 self == other
+   |                 ^^^^^^^^^^^^^
+...
+LL | impl_partial_eq!(S5);
+   | -------------------- in this macro invocation
+   = note: this error originates in the macro `impl_partial_eq` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: aborting due to 19 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 4cea5a8f33715bfe38824c798a5d75218cbfec04 Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Sat, 16 Dec 2023 14:02:50 +0100
Subject: Do not suggest `[T; n]` instead of `vec![T; n]` if `T` is not `Copy`

---
 clippy_lints/src/vec.rs | 17 ++++++-----------
 tests/ui/vec.fixed      |  7 +++++++
 tests/ui/vec.rs         |  7 +++++++
 3 files changed, 20 insertions(+), 11 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/vec.rs b/clippy_lints/src/vec.rs
index 5e13c73f035..2c33c93412a 100644
--- a/clippy_lints/src/vec.rs
+++ b/clippy_lints/src/vec.rs
@@ -11,8 +11,8 @@ use clippy_utils::{get_parent_expr, higher, is_trait_method};
 use rustc_errors::Applicability;
 use rustc_hir::{BorrowKind, Expr, ExprKind, HirId, Mutability, Node, PatKind};
 use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty;
 use rustc_middle::ty::layout::LayoutOf;
-use rustc_middle::ty::{self, Ty};
 use rustc_session::impl_lint_pass;
 use rustc_span::{sym, DesugaringKind, Span};
 
@@ -79,7 +79,6 @@ impl<'tcx> LateLintPass<'tcx> for UselessVec {
                 // this is to avoid compile errors when doing the suggestion here: let _: Vec<_> = vec![..];
                 && local.ty.is_none()
                 && let PatKind::Binding(_, id, ..) = local.pat.kind
-                && is_copy(cx, vec_type(cx.typeck_results().expr_ty_adjusted(expr.peel_borrows())))
             {
                 let only_slice_uses = for_each_local_use_after_expr(cx, id, expr.hir_id, |expr| {
                     // allow indexing into a vec and some set of allowed method calls that exist on slices, too
@@ -185,6 +184,11 @@ impl UselessVec {
         let snippet = match *vec_args {
             higher::VecArgs::Repeat(elem, len) => {
                 if let Some(Constant::Int(len_constant)) = constant(cx, cx.typeck_results(), len) {
+                    // vec![ty; N] works when ty is Clone, [ty; N] requires it to be Copy also
+                    if !is_copy(cx, cx.typeck_results().expr_ty(elem)) {
+                        return;
+                    }
+
                     #[expect(clippy::cast_possible_truncation)]
                     if len_constant as u64 * size_of(cx, elem) > self.too_large_for_stack {
                         return;
@@ -241,12 +245,3 @@ fn size_of(cx: &LateContext<'_>, expr: &Expr<'_>) -> u64 {
     let ty = cx.typeck_results().expr_ty_adjusted(expr);
     cx.layout_of(ty).map_or(0, |l| l.size.bytes())
 }
-
-/// Returns the item type of the vector (i.e., the `T` in `Vec<T>`).
-fn vec_type(ty: Ty<'_>) -> Ty<'_> {
-    if let ty::Adt(_, args) = ty.kind() {
-        args.type_at(0)
-    } else {
-        panic!("The type of `vec!` is a not a struct?");
-    }
-}
diff --git a/tests/ui/vec.fixed b/tests/ui/vec.fixed
index 81b8bd7da77..b318fd42f7c 100644
--- a/tests/ui/vec.fixed
+++ b/tests/ui/vec.fixed
@@ -210,3 +210,10 @@ fn issue11861() {
     // should not lint
     m!(vec![1]);
 }
+
+fn issue_11958() {
+    fn f(_s: &[String]) {}
+
+    // should not lint, `String` is not `Copy`
+    f(&vec!["test".to_owned(); 2]);
+}
diff --git a/tests/ui/vec.rs b/tests/ui/vec.rs
index 5aca9b2925c..08ad6efa37f 100644
--- a/tests/ui/vec.rs
+++ b/tests/ui/vec.rs
@@ -210,3 +210,10 @@ fn issue11861() {
     // should not lint
     m!(vec![1]);
 }
+
+fn issue_11958() {
+    fn f(_s: &[String]) {}
+
+    // should not lint, `String` is not `Copy`
+    f(&vec!["test".to_owned(); 2]);
+}
-- 
cgit 1.4.1-3-g733a5


From 1c431f4da96fe701388f9ca7ecff1020b402664a Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Mon, 18 Dec 2023 16:36:12 +0100
Subject: Move check for `PartialEq` in `UNCONDITIONAL_RECURSION` lint into its
 own function

---
 clippy_lints/src/unconditional_recursion.rs | 137 +++++++++++++++-------------
 1 file changed, 75 insertions(+), 62 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unconditional_recursion.rs b/clippy_lints/src/unconditional_recursion.rs
index b1fa30aa068..570770523eb 100644
--- a/clippy_lints/src/unconditional_recursion.rs
+++ b/clippy_lints/src/unconditional_recursion.rs
@@ -8,6 +8,7 @@ use rustc_hir::{Body, Expr, ExprKind, FnDecl, Item, ItemKind, Node};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{self, Ty};
 use rustc_session::declare_lint_pass;
+use rustc_span::symbol::Ident;
 use rustc_span::{sym, Span};
 
 declare_clippy_lint! {
@@ -55,6 +56,76 @@ fn is_local(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
     matches!(path_res(cx, expr), Res::Local(_))
 }
 
+fn check_partial_eq(
+    cx: &LateContext<'_>,
+    body: &Body<'_>,
+    method_span: Span,
+    method_def_id: LocalDefId,
+    name: Ident,
+) {
+    let args = cx
+        .tcx
+        .instantiate_bound_regions_with_erased(cx.tcx.fn_sig(method_def_id).skip_binder())
+        .inputs();
+    // That has two arguments.
+    if let [self_arg, other_arg] = args
+        && let Some(self_arg) = get_ty_def_id(*self_arg)
+        && let Some(other_arg) = get_ty_def_id(*other_arg)
+        // The two arguments are of the same type.
+        && self_arg == other_arg
+        && let hir_id = cx.tcx.local_def_id_to_hir_id(method_def_id)
+        && let Some((
+            _,
+            Node::Item(Item {
+                kind: ItemKind::Impl(impl_),
+                owner_id,
+                ..
+            }),
+        )) = cx.tcx.hir().parent_iter(hir_id).next()
+        // We exclude `impl` blocks generated from rustc's proc macros.
+        && !cx.tcx.has_attr(*owner_id, sym::automatically_derived)
+        // It is a implementation of a trait.
+        && let Some(trait_) = impl_.of_trait
+        && let Some(trait_def_id) = trait_.trait_def_id()
+        // The trait is `PartialEq`.
+        && Some(trait_def_id) == get_trait_def_id(cx, &["core", "cmp", "PartialEq"])
+    {
+        let to_check_op = if name.name == sym::eq {
+            BinOpKind::Eq
+        } else {
+            BinOpKind::Ne
+        };
+        let expr = body.value.peel_blocks();
+        let is_bad = match expr.kind {
+            ExprKind::Binary(op, left, right) if op.node == to_check_op => is_local(cx, left) && is_local(cx, right),
+            ExprKind::MethodCall(segment, receiver, &[arg], _) if segment.ident.name == name.name => {
+                if is_local(cx, receiver)
+                    && is_local(cx, &arg)
+                    && let Some(fn_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id)
+                    && let Some(trait_id) = cx.tcx.trait_of_item(fn_id)
+                    && trait_id == trait_def_id
+                {
+                    true
+                } else {
+                    false
+                }
+            },
+            _ => false,
+        };
+        if is_bad {
+            span_lint_and_then(
+                cx,
+                UNCONDITIONAL_RECURSION,
+                method_span,
+                "function cannot return without recursing",
+                |diag| {
+                    diag.span_note(expr.span, "recursive call site");
+                },
+            );
+        }
+    }
+}
+
 impl<'tcx> LateLintPass<'tcx> for UnconditionalRecursion {
     #[allow(clippy::unnecessary_def_path)]
     fn check_fn(
@@ -64,70 +135,12 @@ impl<'tcx> LateLintPass<'tcx> for UnconditionalRecursion {
         _decl: &'tcx FnDecl<'tcx>,
         body: &'tcx Body<'tcx>,
         method_span: Span,
-        def_id: LocalDefId,
+        method_def_id: LocalDefId,
     ) {
         // If the function is a method...
-        if let FnKind::Method(name, _) = kind
-            // That has two arguments.
-            && let [self_arg, other_arg] = cx
-                .tcx
-                .instantiate_bound_regions_with_erased(cx.tcx.fn_sig(def_id).skip_binder())
-                .inputs()
-            && let Some(self_arg) = get_ty_def_id(*self_arg)
-            && let Some(other_arg) = get_ty_def_id(*other_arg)
-            // The two arguments are of the same type.
-            && self_arg == other_arg
-            && let hir_id = cx.tcx.local_def_id_to_hir_id(def_id)
-            && let Some((
-                _,
-                Node::Item(Item {
-                    kind: ItemKind::Impl(impl_),
-                    owner_id,
-                    ..
-                }),
-            )) = cx.tcx.hir().parent_iter(hir_id).next()
-            // We exclude `impl` blocks generated from rustc's proc macros.
-            && !cx.tcx.has_attr(*owner_id, sym::automatically_derived)
-            // It is a implementation of a trait.
-            && let Some(trait_) = impl_.of_trait
-            && let Some(trait_def_id) = trait_.trait_def_id()
-            // The trait is `PartialEq`.
-            && Some(trait_def_id) == get_trait_def_id(cx, &["core", "cmp", "PartialEq"])
-        {
-            let to_check_op = if name.name == sym::eq {
-                BinOpKind::Eq
-            } else {
-                BinOpKind::Ne
-            };
-            let expr = body.value.peel_blocks();
-            let is_bad = match expr.kind {
-                ExprKind::Binary(op, left, right) if op.node == to_check_op => {
-                    is_local(cx, left) && is_local(cx, right)
-                },
-                ExprKind::MethodCall(segment, receiver, &[arg], _) if segment.ident.name == name.name => {
-                    if is_local(cx, receiver)
-                        && is_local(cx, &arg)
-                        && let Some(fn_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id)
-                        && let Some(trait_id) = cx.tcx.trait_of_item(fn_id)
-                        && trait_id == trait_def_id
-                    {
-                        true
-                    } else {
-                        false
-                    }
-                },
-                _ => false,
-            };
-            if is_bad {
-                span_lint_and_then(
-                    cx,
-                    UNCONDITIONAL_RECURSION,
-                    method_span,
-                    "function cannot return without recursing",
-                    |diag| {
-                        diag.span_note(expr.span, "recursive call site");
-                    },
-                );
+        if let FnKind::Method(name, _) = kind {
+            if name.name == sym::eq || name.name == sym::ne {
+                check_partial_eq(cx, body, method_span, method_def_id, name);
             }
         }
     }
-- 
cgit 1.4.1-3-g733a5


From 71ea36b5391be5e19ae31e8d576fe7b31f6c8760 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Sat, 25 Nov 2023 22:35:39 +0100
Subject: Extend `UNNECESSARY_TO_OWNED` to handle `split`

---
 clippy_lints/src/methods/unnecessary_to_owned.rs | 56 ++++++++++++++++++++++++
 1 file changed, 56 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/unnecessary_to_owned.rs b/clippy_lints/src/methods/unnecessary_to_owned.rs
index c4775b6bd04..637368e9361 100644
--- a/clippy_lints/src/methods/unnecessary_to_owned.rs
+++ b/clippy_lints/src/methods/unnecessary_to_owned.rs
@@ -7,6 +7,7 @@ use clippy_utils::ty::{get_iterator_item_ty, implements_trait, is_copy, peel_mid
 use clippy_utils::visitors::find_all_ret_expressions;
 use clippy_utils::{fn_def_id, get_parent_expr, is_diag_item_method, is_diag_trait_item, return_ty};
 use rustc_errors::Applicability;
+use rustc_hir::def::{DefKind, Res};
 use rustc_hir::def_id::DefId;
 use rustc_hir::{BorrowKind, Expr, ExprKind, ItemKind, Node};
 use rustc_hir_typeck::{FnCtxt, Inherited};
@@ -37,6 +38,9 @@ pub fn check<'tcx>(
         if is_cloned_or_copied(cx, method_name, method_def_id) {
             unnecessary_iter_cloned::check(cx, expr, method_name, receiver);
         } else if is_to_owned_like(cx, expr, method_name, method_def_id) {
+            if check_split_call_arg(cx, expr, method_name, receiver) {
+                return;
+            }
             // At this point, we know the call is of a `to_owned`-like function. The functions
             // `check_addr_of_expr` and `check_call_arg` determine whether the call is unnecessary
             // based on its context, that is, whether it is a referent in an `AddrOf` expression, an
@@ -233,6 +237,58 @@ fn check_into_iter_call_arg(
     false
 }
 
+/// Checks whether `expr` is an argument in an `into_iter` call and, if so, determines whether its
+/// call of a `to_owned`-like function is unnecessary.
+fn check_split_call_arg(cx: &LateContext<'_>, expr: &Expr<'_>, method_name: Symbol, receiver: &Expr<'_>) -> bool {
+    if let Some(parent) = get_parent_expr(cx, expr)
+        && let Some((fn_name, argument_expr)) = get_fn_name_and_arg(cx, parent)
+        && fn_name.as_str() == "split"
+        && let Some(receiver_snippet) = snippet_opt(cx, receiver.span)
+        && let Some(arg_snippet) = snippet_opt(cx, argument_expr.span)
+    {
+        // The next suggestion may be incorrect because the removal of the `to_owned`-like
+        // function could cause the iterator to hold a reference to a resource that is used
+        // mutably. See https://github.com/rust-lang/rust-clippy/issues/8148.
+        span_lint_and_sugg(
+            cx,
+            UNNECESSARY_TO_OWNED,
+            parent.span,
+            &format!("unnecessary use of `{method_name}`"),
+            "use",
+            format!("{receiver_snippet}.split({arg_snippet})"),
+            Applicability::MaybeIncorrect,
+        );
+        return true;
+    }
+    false
+}
+
+fn get_fn_name_and_arg<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>) -> Option<(Symbol, Expr<'tcx>)> {
+    match &expr.kind {
+        ExprKind::MethodCall(path, _, [arg_expr], ..) => Some((path.ident.name, *arg_expr)),
+        ExprKind::Call(
+            Expr {
+                kind: ExprKind::Path(qpath),
+                hir_id: path_hir_id,
+                ..
+            },
+            [arg_expr],
+        ) => {
+            // Only return Fn-like DefIds, not the DefIds of statics/consts/etc that contain or
+            // deref to fn pointers, dyn Fn, impl Fn - #8850
+            if let Res::Def(DefKind::Fn | DefKind::Ctor(..) | DefKind::AssocFn, def_id) =
+                cx.typeck_results().qpath_res(qpath, *path_hir_id)
+                && let Some(fn_name) = cx.tcx.opt_item_name(def_id)
+            {
+                Some((fn_name, *arg_expr))
+            } else {
+                None
+            }
+        },
+        _ => None,
+    }
+}
+
 /// Checks whether `expr` is an argument in a function call and, if so, determines whether its call
 /// of a `to_owned`-like function is unnecessary.
 fn check_other_call_arg<'tcx>(
-- 
cgit 1.4.1-3-g733a5


From 25b9ca3f64bd3f7fda96e50f340c9c3459fe2e0a Mon Sep 17 00:00:00 2001
From: Quinn Sinclair <me@partiallytyped.dev>
Date: Wed, 20 Dec 2023 22:49:33 +0200
Subject: New lints `iter_filter_is_some` and `iter_filter_is_ok`

Adds a pair of lints that check for cases of an iterator over `Result`
and `Option` followed by `filter` without being followed by `map` as
that is covered already by a different, specialized lint.

changelog: New Lint: [`iter_filter_is_some`]
changelog: New Lint: [`iter_filter_is_ok`]
---
 CHANGELOG.md                            |  2 +
 clippy_lints/src/declared_lints.rs      |  2 +
 clippy_lints/src/methods/filter_map.rs  |  1 +
 clippy_lints/src/methods/iter_filter.rs | 79 +++++++++++++++++++++++++++++++++
 clippy_lints/src/methods/mod.rs         | 76 +++++++++++++++++++++++++++++--
 tests/ui/iter_filter_is_ok.fixed        |  8 ++++
 tests/ui/iter_filter_is_ok.rs           |  8 ++++
 tests/ui/iter_filter_is_ok.stderr       | 17 +++++++
 tests/ui/iter_filter_is_some.fixed      | 12 +++++
 tests/ui/iter_filter_is_some.rs         | 12 +++++
 tests/ui/iter_filter_is_some.stderr     | 17 +++++++
 11 files changed, 231 insertions(+), 3 deletions(-)
 create mode 100644 clippy_lints/src/methods/iter_filter.rs
 create mode 100644 tests/ui/iter_filter_is_ok.fixed
 create mode 100644 tests/ui/iter_filter_is_ok.rs
 create mode 100644 tests/ui/iter_filter_is_ok.stderr
 create mode 100644 tests/ui/iter_filter_is_some.fixed
 create mode 100644 tests/ui/iter_filter_is_some.rs
 create mode 100644 tests/ui/iter_filter_is_some.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 7beb4eb17d4..9318c85ced9 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5177,6 +5177,8 @@ Released 2018-09-13
 [`items_after_test_module`]: https://rust-lang.github.io/rust-clippy/master/index.html#items_after_test_module
 [`iter_cloned_collect`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_cloned_collect
 [`iter_count`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_count
+[`iter_filter_is_ok`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_filter_is_ok
+[`iter_filter_is_some`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_filter_is_some
 [`iter_kv_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_kv_map
 [`iter_next_loop`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_next_loop
 [`iter_next_slice`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_next_slice
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 38fda36c58a..a00e2d3e044 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -369,6 +369,8 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::methods::ITERATOR_STEP_BY_ZERO_INFO,
     crate::methods::ITER_CLONED_COLLECT_INFO,
     crate::methods::ITER_COUNT_INFO,
+    crate::methods::ITER_FILTER_IS_OK_INFO,
+    crate::methods::ITER_FILTER_IS_SOME_INFO,
     crate::methods::ITER_KV_MAP_INFO,
     crate::methods::ITER_NEXT_SLICE_INFO,
     crate::methods::ITER_NTH_INFO,
diff --git a/clippy_lints/src/methods/filter_map.rs b/clippy_lints/src/methods/filter_map.rs
index a8ca82d20e7..7cfd3d346b6 100644
--- a/clippy_lints/src/methods/filter_map.rs
+++ b/clippy_lints/src/methods/filter_map.rs
@@ -22,6 +22,7 @@ fn is_method(cx: &LateContext<'_>, expr: &hir::Expr<'_>, method_name: Symbol) ->
         hir::ExprKind::Path(QPath::Resolved(_, segments)) => {
             segments.segments.last().unwrap().ident.name == method_name
         },
+        hir::ExprKind::MethodCall(segment, _, _, _) => segment.ident.name == method_name,
         hir::ExprKind::Closure(&hir::Closure { body, .. }) => {
             let body = cx.tcx.hir().body(body);
             let closure_expr = peel_blocks(body.value);
diff --git a/clippy_lints/src/methods/iter_filter.rs b/clippy_lints/src/methods/iter_filter.rs
new file mode 100644
index 00000000000..04dc4820f6a
--- /dev/null
+++ b/clippy_lints/src/methods/iter_filter.rs
@@ -0,0 +1,79 @@
+use rustc_lint::LateContext;
+
+use super::{ITER_FILTER_IS_OK, ITER_FILTER_IS_SOME};
+
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::{indent_of, reindent_multiline};
+use clippy_utils::{is_trait_method, peel_blocks};
+use rustc_errors::Applicability;
+use rustc_hir as hir;
+use rustc_hir::def::Res;
+use rustc_hir::QPath;
+use rustc_span::symbol::{sym, Symbol};
+use rustc_span::Span;
+use std::borrow::Cow;
+
+fn is_method(cx: &LateContext<'_>, expr: &hir::Expr<'_>, method_name: Symbol) -> bool {
+    match &expr.kind {
+        hir::ExprKind::Path(QPath::TypeRelative(_, mname)) => mname.ident.name == method_name,
+        hir::ExprKind::Path(QPath::Resolved(_, segments)) => {
+            segments.segments.last().unwrap().ident.name == method_name
+        },
+        hir::ExprKind::MethodCall(segment, _, _, _) => segment.ident.name == method_name,
+        hir::ExprKind::Closure(&hir::Closure { body, .. }) => {
+            let body = cx.tcx.hir().body(body);
+            let closure_expr = peel_blocks(body.value);
+            let arg_id = body.params[0].pat.hir_id;
+            match closure_expr.kind {
+                hir::ExprKind::MethodCall(hir::PathSegment { ident, .. }, receiver, ..) => {
+                    if ident.name == method_name
+                        && let hir::ExprKind::Path(path) = &receiver.kind
+                        && let Res::Local(ref local) = cx.qpath_res(path, receiver.hir_id)
+                    {
+                        return arg_id == *local;
+                    }
+                    false
+                },
+                _ => false,
+            }
+        },
+        _ => false,
+    }
+}
+
+fn parent_is_map(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> bool {
+    if let hir::Node::Expr(parent_expr) = cx.tcx.hir().get_parent(expr.hir_id) {
+        is_method(cx, parent_expr, rustc_span::sym::map)
+    } else {
+        false
+    }
+}
+
+#[allow(clippy::too_many_arguments)]
+pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, filter_arg: &hir::Expr<'_>, filter_span: Span) {
+    let is_iterator = is_trait_method(cx, expr, sym::Iterator);
+    let parent_is_not_map = !parent_is_map(cx, expr);
+
+    if is_iterator && parent_is_not_map && is_method(cx, filter_arg, sym!(is_some)) {
+        span_lint_and_sugg(
+            cx,
+            ITER_FILTER_IS_SOME,
+            filter_span.with_hi(expr.span.hi()),
+            "`filter` for `is_some` on iterator over `Option`",
+            "consider using `flatten` instead",
+            reindent_multiline(Cow::Borrowed("flatten()"), true, indent_of(cx, filter_span)).into_owned(),
+            Applicability::MaybeIncorrect,
+        );
+    }
+    if is_iterator && parent_is_not_map && is_method(cx, filter_arg, sym!(is_ok)) {
+        span_lint_and_sugg(
+            cx,
+            ITER_FILTER_IS_OK,
+            filter_span.with_hi(expr.span.hi()),
+            "`filter` for `is_ok` on iterator over `Result`s",
+            "consider using `flatten` instead",
+            reindent_multiline(Cow::Borrowed("flatten()"), true, indent_of(cx, filter_span)).into_owned(),
+            Applicability::MaybeIncorrect,
+        );
+    }
+}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index a94524b3ba6..d67fa28b30b 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -38,6 +38,7 @@ mod into_iter_on_ref;
 mod is_digit_ascii_radix;
 mod iter_cloned_collect;
 mod iter_count;
+mod iter_filter;
 mod iter_kv_map;
 mod iter_next_slice;
 mod iter_nth;
@@ -1175,7 +1176,7 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for iterators of `Option`s using ``.filter(Option::is_some).map(Option::unwrap)` that may
+    /// Checks for iterators of `Option`s using `.filter(Option::is_some).map(Option::unwrap)` that may
     /// be replaced with a `.flatten()` call.
     ///
     /// ### Why is this bad?
@@ -3755,7 +3756,7 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for iterators of `Result`s using ``.filter(Result::is_ok).map(Result::unwrap)` that may
+    /// Checks for iterators of `Result`s using `.filter(Result::is_ok).map(Result::unwrap)` that may
     /// be replaced with a `.flatten()` call.
     ///
     /// ### Why is this bad?
@@ -3776,6 +3777,58 @@ declare_clippy_lint! {
     "filtering `Result` for `Ok` then force-unwrapping, which can be one type-safe operation"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of `.filter(Optional::is_some)` that may be replaced with a `.flatten()` call.
+    /// This lint is potentially incorrect as it affects the type of follow-up calls.
+    ///
+    /// ### Why is this bad?
+    /// This pattern is often followed by manual unwrapping of the `Option`. The simplification
+    /// results in more readable and succint code without the need for manual unwrapping.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// // example code where clippy issues a warning
+    /// vec![Some(1)].into_iter().filter(Option::is_some);
+    ///
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// // example code which does not raise clippy warning
+    /// vec![Some(1)].into_iter().flatten();
+    /// ```
+    #[clippy::version = "1.76.0"]
+    pub ITER_FILTER_IS_SOME,
+    complexity,
+    "filtering an iterator over `Option`s for `Some` can be achieved with `flatten`"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of `.filter(Result::is_ok)` that may be replaced with a `.flatten()` call.
+    /// This lint is potentially incorrect as it affects the type of follow-up calls.
+    ///
+    /// ### Why is this bad?
+    /// This pattern is often followed by manual unwrapping of `Result`. The simplification
+    /// results in more readable and succint code without the need for manual unwrapping.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// // example code where clippy issues a warning
+    /// vec![Ok::<i32, String>(1)].into_iter().filter(Result::is_ok);
+    ///
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// // example code which does not raise clippy warning
+    /// vec![Ok::<i32, String>(1)].into_iter().flatten();
+    /// ```
+    #[clippy::version = "1.76.0"]
+    pub ITER_FILTER_IS_OK,
+    complexity,
+    "filtering an iterator over `Result`s for `Ok` can be achieved with `flatten`"
+}
+
 pub struct Methods {
     avoid_breaking_exported_api: bool,
     msrv: Msrv,
@@ -3928,6 +3981,8 @@ impl_lint_pass!(Methods => [
     JOIN_ABSOLUTE_PATHS,
     OPTION_MAP_OR_ERR_OK,
     RESULT_FILTER_MAP,
+    ITER_FILTER_IS_SOME,
+    ITER_FILTER_IS_OK,
 ]);
 
 /// Extracts a method call name, args, and `Span` of the method name.
@@ -4257,7 +4312,22 @@ impl Methods {
                     string_extend_chars::check(cx, expr, recv, arg);
                     extend_with_drain::check(cx, expr, recv, arg);
                 },
-                (name @ ("filter" | "find"), [arg]) => {
+                ("filter", [arg]) => {
+                    if let Some(("cloned", recv2, [], _span2, _)) = method_call(recv) {
+                        // if `arg` has side-effect, the semantic will change
+                        iter_overeager_cloned::check(
+                            cx,
+                            expr,
+                            recv,
+                            recv2,
+                            iter_overeager_cloned::Op::FixClosure(name, arg),
+                            false,
+                        );
+                    }
+
+                    iter_filter::check(cx, expr, arg, span);
+                },
+                ("find", [arg]) => {
                     if let Some(("cloned", recv2, [], _span2, _)) = method_call(recv) {
                         // if `arg` has side-effect, the semantic will change
                         iter_overeager_cloned::check(
diff --git a/tests/ui/iter_filter_is_ok.fixed b/tests/ui/iter_filter_is_ok.fixed
new file mode 100644
index 00000000000..9985877a02a
--- /dev/null
+++ b/tests/ui/iter_filter_is_ok.fixed
@@ -0,0 +1,8 @@
+#![warn(clippy::iter_filter_is_ok)]
+
+fn main() {
+    let _ = vec![Ok(1), Err(2), Ok(3)].into_iter().flatten();
+    //~^ HELP: consider using `flatten` instead
+    let _ = vec![Ok(1), Err(2), Ok(3)].into_iter().flatten();
+    //~^ HELP: consider using `flatten` instead
+}
diff --git a/tests/ui/iter_filter_is_ok.rs b/tests/ui/iter_filter_is_ok.rs
new file mode 100644
index 00000000000..176ce902637
--- /dev/null
+++ b/tests/ui/iter_filter_is_ok.rs
@@ -0,0 +1,8 @@
+#![warn(clippy::iter_filter_is_ok)]
+
+fn main() {
+    let _ = vec![Ok(1), Err(2), Ok(3)].into_iter().filter(Result::is_ok);
+    //~^ HELP: consider using `flatten` instead
+    let _ = vec![Ok(1), Err(2), Ok(3)].into_iter().filter(|a| a.is_ok());
+    //~^ HELP: consider using `flatten` instead
+}
diff --git a/tests/ui/iter_filter_is_ok.stderr b/tests/ui/iter_filter_is_ok.stderr
new file mode 100644
index 00000000000..a5d7da977ff
--- /dev/null
+++ b/tests/ui/iter_filter_is_ok.stderr
@@ -0,0 +1,17 @@
+error: `filter` for `is_ok` on iterator over `Result`s
+  --> $DIR/iter_filter_is_ok.rs:4:52
+   |
+LL |     let _ = vec![Ok(1), Err(2), Ok(3)].into_iter().filter(Result::is_ok);
+   |                                                    ^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
+   |
+   = note: `-D clippy::iter-filter-is-ok` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::iter_filter_is_ok)]`
+
+error: `filter` for `is_ok` on iterator over `Result`s
+  --> $DIR/iter_filter_is_ok.rs:6:52
+   |
+LL |     let _ = vec![Ok(1), Err(2), Ok(3)].into_iter().filter(|a| a.is_ok());
+   |                                                    ^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
+
+error: aborting due to 2 previous errors
+
diff --git a/tests/ui/iter_filter_is_some.fixed b/tests/ui/iter_filter_is_some.fixed
new file mode 100644
index 00000000000..3732a8e72d1
--- /dev/null
+++ b/tests/ui/iter_filter_is_some.fixed
@@ -0,0 +1,12 @@
+#![warn(clippy::iter_filter_is_some)]
+
+fn odds_out(x: i32) -> Option<i32> {
+    if x % 2 == 0 { Some(x) } else { None }
+}
+
+fn main() {
+    let _ = vec![Some(1)].into_iter().flatten();
+    //~^ HELP: consider using `flatten` instead
+    let _ = vec![Some(1)].into_iter().flatten();
+    //~^ HELP: consider using `flatten` instead
+}
diff --git a/tests/ui/iter_filter_is_some.rs b/tests/ui/iter_filter_is_some.rs
new file mode 100644
index 00000000000..5cc457efed5
--- /dev/null
+++ b/tests/ui/iter_filter_is_some.rs
@@ -0,0 +1,12 @@
+#![warn(clippy::iter_filter_is_some)]
+
+fn odds_out(x: i32) -> Option<i32> {
+    if x % 2 == 0 { Some(x) } else { None }
+}
+
+fn main() {
+    let _ = vec![Some(1)].into_iter().filter(Option::is_some);
+    //~^ HELP: consider using `flatten` instead
+    let _ = vec![Some(1)].into_iter().filter(|o| o.is_some());
+    //~^ HELP: consider using `flatten` instead
+}
diff --git a/tests/ui/iter_filter_is_some.stderr b/tests/ui/iter_filter_is_some.stderr
new file mode 100644
index 00000000000..2b1c1cdf7ef
--- /dev/null
+++ b/tests/ui/iter_filter_is_some.stderr
@@ -0,0 +1,17 @@
+error: `filter` for `is_some` on iterator over `Option`
+  --> $DIR/iter_filter_is_some.rs:8:39
+   |
+LL |     let _ = vec![Some(1)].into_iter().filter(Option::is_some);
+   |                                       ^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
+   |
+   = note: `-D clippy::iter-filter-is-some` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::iter_filter_is_some)]`
+
+error: `filter` for `is_some` on iterator over `Option`
+  --> $DIR/iter_filter_is_some.rs:10:39
+   |
+LL |     let _ = vec![Some(1)].into_iter().filter(|o| o.is_some());
+   |                                       ^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
+
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From a556d00c0a514deec2c44ee5cc9dfc3cb95c1737 Mon Sep 17 00:00:00 2001
From: J-ZhengLi <lizheng135@huawei.com>
Date: Thu, 21 Dec 2023 18:20:25 +0800
Subject: stop [`bool_comparison`]'s suggestion from consuming parentheses

---
 clippy_lints/src/needless_bool.rs | 38 +++++++++++++++++++++++++++-----------
 tests/ui/bool_comparison.fixed    |  9 +++++++++
 tests/ui/bool_comparison.rs       |  9 +++++++++
 tests/ui/bool_comparison.stderr   | 20 +++++++++++++++++++-
 4 files changed, 64 insertions(+), 12 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/needless_bool.rs b/clippy_lints/src/needless_bool.rs
index 218ca5e80f3..bf27adb45af 100644
--- a/clippy_lints/src/needless_bool.rs
+++ b/clippy_lints/src/needless_bool.rs
@@ -340,6 +340,12 @@ fn check_comparison<'a, 'tcx>(
         }
         if l_ty.is_bool() && r_ty.is_bool() {
             let mut applicability = Applicability::MachineApplicable;
+            // Eliminate parentheses in `e` by using the lo pos of lhs and hi pos of rhs,
+            // calling `source_callsite` make sure macros are handled correctly, see issue #9907
+            let binop_span = left_side
+                .span
+                .source_callsite()
+                .with_hi(right_side.span.source_callsite().hi());
 
             if op.node == BinOpKind::Eq {
                 let expression_info = one_side_is_unary_not(left_side, right_side);
@@ -347,13 +353,23 @@ fn check_comparison<'a, 'tcx>(
                     span_lint_and_sugg(
                         cx,
                         BOOL_COMPARISON,
-                        e.span,
+                        binop_span,
                         "this comparison might be written more concisely",
                         "try simplifying it as shown",
                         format!(
                             "{} != {}",
-                            snippet_with_applicability(cx, expression_info.left_span, "..", &mut applicability),
-                            snippet_with_applicability(cx, expression_info.right_span, "..", &mut applicability)
+                            snippet_with_applicability(
+                                cx,
+                                expression_info.left_span.source_callsite(),
+                                "..",
+                                &mut applicability
+                            ),
+                            snippet_with_applicability(
+                                cx,
+                                expression_info.right_span.source_callsite(),
+                                "..",
+                                &mut applicability
+                            )
                         ),
                         applicability,
                     );
@@ -362,16 +378,16 @@ fn check_comparison<'a, 'tcx>(
 
             match (fetch_bool_expr(left_side), fetch_bool_expr(right_side)) {
                 (Some(true), None) => left_true.map_or((), |(h, m)| {
-                    suggest_bool_comparison(cx, e, right_side, applicability, m, h);
+                    suggest_bool_comparison(cx, binop_span, right_side, applicability, m, h);
                 }),
                 (None, Some(true)) => right_true.map_or((), |(h, m)| {
-                    suggest_bool_comparison(cx, e, left_side, applicability, m, h);
+                    suggest_bool_comparison(cx, binop_span, left_side, applicability, m, h);
                 }),
                 (Some(false), None) => left_false.map_or((), |(h, m)| {
-                    suggest_bool_comparison(cx, e, right_side, applicability, m, h);
+                    suggest_bool_comparison(cx, binop_span, right_side, applicability, m, h);
                 }),
                 (None, Some(false)) => right_false.map_or((), |(h, m)| {
-                    suggest_bool_comparison(cx, e, left_side, applicability, m, h);
+                    suggest_bool_comparison(cx, binop_span, left_side, applicability, m, h);
                 }),
                 (None, None) => no_literal.map_or((), |(h, m)| {
                     let left_side = Sugg::hir_with_applicability(cx, left_side, "..", &mut applicability);
@@ -379,7 +395,7 @@ fn check_comparison<'a, 'tcx>(
                     span_lint_and_sugg(
                         cx,
                         BOOL_COMPARISON,
-                        e.span,
+                        binop_span,
                         m,
                         "try simplifying it as shown",
                         h(left_side, right_side).to_string(),
@@ -394,17 +410,17 @@ fn check_comparison<'a, 'tcx>(
 
 fn suggest_bool_comparison<'a, 'tcx>(
     cx: &LateContext<'tcx>,
-    e: &'tcx Expr<'_>,
+    span: Span,
     expr: &Expr<'_>,
     mut app: Applicability,
     message: &str,
     conv_hint: impl FnOnce(Sugg<'a>) -> Sugg<'a>,
 ) {
-    let hint = Sugg::hir_with_context(cx, expr, e.span.ctxt(), "..", &mut app);
+    let hint = Sugg::hir_with_context(cx, expr, span.ctxt(), "..", &mut app);
     span_lint_and_sugg(
         cx,
         BOOL_COMPARISON,
-        e.span,
+        span,
         message,
         "try simplifying it as shown",
         conv_hint(hint).to_string(),
diff --git a/tests/ui/bool_comparison.fixed b/tests/ui/bool_comparison.fixed
index e3f2ca72d1c..02f1d09b833 100644
--- a/tests/ui/bool_comparison.fixed
+++ b/tests/ui/bool_comparison.fixed
@@ -165,3 +165,12 @@ fn issue3973() {
     if is_debug == m!(func) {}
     if m!(func) == is_debug {}
 }
+
+#[allow(clippy::unnecessary_cast)]
+fn issue9907() {
+    let _ = (1 >= 2) as usize;
+    let _ = (!m!(func)) as usize;
+    // This is not part of the issue, but an unexpected found when fixing the issue,
+    // the provided span was inside of macro rather than the macro callsite.
+    let _ = ((1 < 2) != m!(func)) as usize;
+}
diff --git a/tests/ui/bool_comparison.rs b/tests/ui/bool_comparison.rs
index d1bc20d6831..5ef696d855e 100644
--- a/tests/ui/bool_comparison.rs
+++ b/tests/ui/bool_comparison.rs
@@ -165,3 +165,12 @@ fn issue3973() {
     if is_debug == m!(func) {}
     if m!(func) == is_debug {}
 }
+
+#[allow(clippy::unnecessary_cast)]
+fn issue9907() {
+    let _ = ((1 < 2) == false) as usize;
+    let _ = (false == m!(func)) as usize;
+    // This is not part of the issue, but an unexpected found when fixing the issue,
+    // the provided span was inside of macro rather than the macro callsite.
+    let _ = ((1 < 2) == !m!(func)) as usize;
+}
diff --git a/tests/ui/bool_comparison.stderr b/tests/ui/bool_comparison.stderr
index 4560df6d4cd..6907dc0523f 100644
--- a/tests/ui/bool_comparison.stderr
+++ b/tests/ui/bool_comparison.stderr
@@ -133,5 +133,23 @@ error: equality checks against true are unnecessary
 LL |     if m!(func) == true {}
    |        ^^^^^^^^^^^^^^^^ help: try simplifying it as shown: `m!(func)`
 
-error: aborting due to 22 previous errors
+error: equality checks against false can be replaced by a negation
+  --> $DIR/bool_comparison.rs:171:14
+   |
+LL |     let _ = ((1 < 2) == false) as usize;
+   |              ^^^^^^^^^^^^^^^^ help: try simplifying it as shown: `1 >= 2`
+
+error: equality checks against false can be replaced by a negation
+  --> $DIR/bool_comparison.rs:172:14
+   |
+LL |     let _ = (false == m!(func)) as usize;
+   |              ^^^^^^^^^^^^^^^^^ help: try simplifying it as shown: `!m!(func)`
+
+error: this comparison might be written more concisely
+  --> $DIR/bool_comparison.rs:175:14
+   |
+LL |     let _ = ((1 < 2) == !m!(func)) as usize;
+   |              ^^^^^^^^^^^^^^^^^^^^ help: try simplifying it as shown: `(1 < 2) != m!(func)`
+
+error: aborting due to 25 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From d020196dc096d255caa72f04a6da5e8e41d2b717 Mon Sep 17 00:00:00 2001
From: cocodery <cocodery@outlook.com>
Date: Fri, 22 Dec 2023 20:17:43 +0800
Subject: Add check for illegal accessing known length array with a constant
 index

---
 clippy_lints/src/indexing_slicing.rs | 18 +++++++++++++++++-
 1 file changed, 17 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/indexing_slicing.rs b/clippy_lints/src/indexing_slicing.rs
index 0ae03d101ab..391db0b0df7 100644
--- a/clippy_lints/src/indexing_slicing.rs
+++ b/clippy_lints/src/indexing_slicing.rs
@@ -170,7 +170,23 @@ impl<'tcx> LateLintPass<'tcx> for IndexingSlicing {
                         return;
                     }
                     // Index is a constant uint.
-                    if constant(cx, cx.typeck_results(), index).is_some() {
+                    if let Some(constant) = constant(cx, cx.typeck_results(), index) {
+                        // only `usize` index is legal in rust array index
+                        // leave other type to rustc
+                        if let Constant::Int(off) = constant
+                            && let ty::Uint(utype) = cx.typeck_results().expr_ty(index).kind()
+                            && *utype == ty::UintTy::Usize
+                            && let ty::Array(_, s) = ty.kind()
+                            && let Some(size) = s.try_eval_target_usize(cx.tcx, cx.param_env)
+                        {
+                            // get constant offset and check whether it is in bounds
+                            let off = usize::try_from(off).unwrap();
+                            let size = usize::try_from(size).unwrap();
+
+                            if off >= size {
+                                span_lint(cx, OUT_OF_BOUNDS_INDEXING, expr.span, "index is out of bounds");
+                            }
+                        }
                         // Let rustc's `const_err` lint handle constant `usize` indexing on arrays.
                         return;
                     }
-- 
cgit 1.4.1-3-g733a5


From 67a33e8cc889e6a4fa99821b4a04db99dc60a1dd Mon Sep 17 00:00:00 2001
From: Takashi Idobe <mail@takashiidobe.com>
Date: Fri, 22 Dec 2023 18:44:20 -0500
Subject: fix typo in infinite loop lint

---
 clippy_lints/src/loops/infinite_loop.rs |  2 +-
 tests/ui/infinite_loops.stderr          | 31 +++++++++++++++----------------
 2 files changed, 16 insertions(+), 17 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/infinite_loop.rs b/clippy_lints/src/loops/infinite_loop.rs
index 9b88dd76e5c..5e099f1e76f 100644
--- a/clippy_lints/src/loops/infinite_loop.rs
+++ b/clippy_lints/src/loops/infinite_loop.rs
@@ -49,7 +49,7 @@ pub(super) fn check<'tcx>(
             if let FnRetTy::DefaultReturn(ret_span) = parent_fn_ret {
                 diag.span_suggestion(
                     ret_span,
-                    "if this is intentional, consider specifing `!` as function return",
+                    "if this is intentional, consider specifying `!` as function return",
                     " -> !",
                     Applicability::MaybeIncorrect,
                 );
diff --git a/tests/ui/infinite_loops.stderr b/tests/ui/infinite_loops.stderr
index f58b3cebbc3..4cddbd5cf53 100644
--- a/tests/ui/infinite_loops.stderr
+++ b/tests/ui/infinite_loops.stderr
@@ -9,7 +9,7 @@ LL | |     }
    |
    = note: `-D clippy::infinite-loop` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::infinite_loop)]`
-help: if this is intentional, consider specifing `!` as function return
+help: if this is intentional, consider specifying `!` as function return
    |
 LL | fn no_break() -> ! {
    |               ++++
@@ -26,7 +26,7 @@ LL | |         do_something();
 LL | |     }
    | |_____^
    |
-help: if this is intentional, consider specifing `!` as function return
+help: if this is intentional, consider specifying `!` as function return
    |
 LL | fn all_inf() -> ! {
    |              ++++
@@ -43,7 +43,7 @@ LL | |             }
 LL | |         }
    | |_________^
    |
-help: if this is intentional, consider specifing `!` as function return
+help: if this is intentional, consider specifying `!` as function return
    |
 LL | fn all_inf() -> ! {
    |              ++++
@@ -57,7 +57,7 @@ LL | |                 do_something();
 LL | |             }
    | |_____________^
    |
-help: if this is intentional, consider specifing `!` as function return
+help: if this is intentional, consider specifying `!` as function return
    |
 LL | fn all_inf() -> ! {
    |              ++++
@@ -84,7 +84,7 @@ LL | |         do_something();
 LL | |     }
    | |_____^
    |
-help: if this is intentional, consider specifing `!` as function return
+help: if this is intentional, consider specifying `!` as function return
    |
 LL | fn no_break_never_ret_noise() -> ! {
    |                               ++++
@@ -101,7 +101,7 @@ LL | |         }
 LL | |     }
    | |_____^
    |
-help: if this is intentional, consider specifing `!` as function return
+help: if this is intentional, consider specifying `!` as function return
    |
 LL | fn break_inner_but_not_outer_1(cond: bool) -> ! {
    |                                            ++++
@@ -118,7 +118,7 @@ LL | |         }
 LL | |     }
    | |_____^
    |
-help: if this is intentional, consider specifing `!` as function return
+help: if this is intentional, consider specifying `!` as function return
    |
 LL | fn break_inner_but_not_outer_2(cond: bool) -> ! {
    |                                            ++++
@@ -132,7 +132,7 @@ LL | |             do_something();
 LL | |         }
    | |_________^
    |
-help: if this is intentional, consider specifing `!` as function return
+help: if this is intentional, consider specifying `!` as function return
    |
 LL | fn break_outer_but_not_inner() -> ! {
    |                                ++++
@@ -149,7 +149,7 @@ LL | |             }
 LL | |         }
    | |_________^
    |
-help: if this is intentional, consider specifing `!` as function return
+help: if this is intentional, consider specifying `!` as function return
    |
 LL | fn break_wrong_loop(cond: bool) -> ! {
    |                                 ++++
@@ -166,7 +166,7 @@ LL | |         }
 LL | |     }
    | |_____^
    |
-help: if this is intentional, consider specifing `!` as function return
+help: if this is intentional, consider specifying `!` as function return
    |
 LL | fn match_like() -> ! {
    |                 ++++
@@ -180,7 +180,7 @@ LL | |         let _x = matches!(result, Ok(v) if v != 0).then_some(0);
 LL | |     }
    | |_____^
    |
-help: if this is intentional, consider specifing `!` as function return
+help: if this is intentional, consider specifying `!` as function return
    |
 LL | fn match_like() -> ! {
    |                 ++++
@@ -197,7 +197,7 @@ LL | |         });
 LL | |     }
    | |_____^
    |
-help: if this is intentional, consider specifing `!` as function return
+help: if this is intentional, consider specifying `!` as function return
    |
 LL | fn match_like() -> ! {
    |                 ++++
@@ -211,7 +211,7 @@ LL | |             do_something();
 LL | |         }
    | |_________^
    |
-help: if this is intentional, consider specifing `!` as function return
+help: if this is intentional, consider specifying `!` as function return
    |
 LL |     fn problematic_trait_method() -> ! {
    |                                   ++++
@@ -225,7 +225,7 @@ LL | |             do_something();
 LL | |         }
    | |_________^
    |
-help: if this is intentional, consider specifing `!` as function return
+help: if this is intentional, consider specifying `!` as function return
    |
 LL |     fn could_be_problematic() -> ! {
    |                               ++++
@@ -239,7 +239,7 @@ LL | |             do_something();
 LL | |         }
    | |_________^
    |
-help: if this is intentional, consider specifing `!` as function return
+help: if this is intentional, consider specifying `!` as function return
    |
 LL |     let _loop_forever = || -> ! {
    |                            ++++
@@ -256,4 +256,3 @@ LL | |     })
    = help: if this is not intended, try adding a `break` or `return` condition in the loop
 
 error: aborting due to 17 previous errors
-
-- 
cgit 1.4.1-3-g733a5


From 9c2be205b3bfe09aa15f6ed3920526f6ce6bf5f6 Mon Sep 17 00:00:00 2001
From: Takashi Idobe <mail@takashiidobe.com>
Date: Fri, 22 Dec 2023 18:54:48 -0500
Subject: fix typos in default constructed unit structs, implied bounds,
 ineffective open options

---
 clippy_lints/src/default_constructed_unit_structs.rs | 2 +-
 clippy_lints/src/implied_bounds_in_impls.rs          | 2 +-
 clippy_lints/src/ineffective_open_options.rs         | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/default_constructed_unit_structs.rs b/clippy_lints/src/default_constructed_unit_structs.rs
index 9ce5acfbcc2..71e1a25c2bc 100644
--- a/clippy_lints/src/default_constructed_unit_structs.rs
+++ b/clippy_lints/src/default_constructed_unit_structs.rs
@@ -42,7 +42,7 @@ declare_clippy_lint! {
     #[clippy::version = "1.71.0"]
     pub DEFAULT_CONSTRUCTED_UNIT_STRUCTS,
     complexity,
-    "unit structs can be contructed without calling `default`"
+    "unit structs can be constructed without calling `default`"
 }
 declare_lint_pass!(DefaultConstructedUnitStructs => [DEFAULT_CONSTRUCTED_UNIT_STRUCTS]);
 
diff --git a/clippy_lints/src/implied_bounds_in_impls.rs b/clippy_lints/src/implied_bounds_in_impls.rs
index 0f5a9ea5d84..fab8ffedb94 100644
--- a/clippy_lints/src/implied_bounds_in_impls.rs
+++ b/clippy_lints/src/implied_bounds_in_impls.rs
@@ -158,7 +158,7 @@ fn try_resolve_type<'tcx>(
 
 /// This function tries to, for all generic type parameters in a supertrait predicate `trait ...<U>:
 /// GenericTrait<U>`, check if the substituted type in the implied-by bound matches with what's
-/// subtituted in the implied bound.
+/// substituted in the implied bound.
 ///
 /// Consider this example.
 /// ```rust,ignore
diff --git a/clippy_lints/src/ineffective_open_options.rs b/clippy_lints/src/ineffective_open_options.rs
index 955f90d4262..af5b1f95739 100644
--- a/clippy_lints/src/ineffective_open_options.rs
+++ b/clippy_lints/src/ineffective_open_options.rs
@@ -16,7 +16,7 @@ declare_clippy_lint! {
     ///
     /// ### Why is this bad?
     /// `.append(true)` already enables `write(true)`, making this one
-    /// superflous.
+    /// superfluous.
     ///
     /// ### Example
     /// ```no_run
-- 
cgit 1.4.1-3-g733a5


From dfb4ff8bbfeb69678c87d2c9526b370e8ae53612 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Thu, 21 Dec 2023 14:01:37 +0100
Subject: [`question_mark`]: also trigger on `return` statements

---
 clippy_lints/src/matches/manual_utils.rs           |  4 +---
 .../src/matches/redundant_pattern_match.rs         |  4 +---
 clippy_lints/src/question_mark.rs                  | 24 +++++++++++++++++-----
 clippy_lints/src/undocumented_unsafe_blocks.rs     |  4 +---
 tests/ui/manual_let_else_question_mark.fixed       | 13 ++++++++++++
 tests/ui/manual_let_else_question_mark.rs          | 15 ++++++++++++++
 tests/ui/manual_let_else_question_mark.stderr      | 10 ++++++++-
 7 files changed, 59 insertions(+), 15 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/manual_utils.rs b/clippy_lints/src/matches/manual_utils.rs
index 0627e458dfe..152aba99ce9 100644
--- a/clippy_lints/src/matches/manual_utils.rs
+++ b/clippy_lints/src/matches/manual_utils.rs
@@ -63,9 +63,7 @@ where
         return None;
     }
 
-    let Some(some_expr) = get_some_expr_fn(cx, some_pat, some_expr, expr_ctxt) else {
-        return None;
-    };
+    let some_expr = get_some_expr_fn(cx, some_pat, some_expr, expr_ctxt)?;
 
     // These two lints will go back and forth with each other.
     if cx.typeck_results().expr_ty(some_expr.expr) == cx.tcx.types.unit
diff --git a/clippy_lints/src/matches/redundant_pattern_match.rs b/clippy_lints/src/matches/redundant_pattern_match.rs
index e32261ec1e4..60331337e56 100644
--- a/clippy_lints/src/matches/redundant_pattern_match.rs
+++ b/clippy_lints/src/matches/redundant_pattern_match.rs
@@ -128,9 +128,7 @@ fn find_method_and_type<'tcx>(
 
             if is_wildcard || is_rest {
                 let res = cx.typeck_results().qpath_res(qpath, check_pat.hir_id);
-                let Some(id) = res.opt_def_id().map(|ctor_id| cx.tcx.parent(ctor_id)) else {
-                    return None;
-                };
+                let id = res.opt_def_id().map(|ctor_id| cx.tcx.parent(ctor_id))?;
                 let lang_items = cx.tcx.lang_items();
                 if Some(id) == lang_items.result_ok_variant() {
                     Some(("is_ok()", try_get_generic_ty(op_ty, 0).unwrap_or(op_ty)))
diff --git a/clippy_lints/src/question_mark.rs b/clippy_lints/src/question_mark.rs
index 6add1a81a0a..a75798cd927 100644
--- a/clippy_lints/src/question_mark.rs
+++ b/clippy_lints/src/question_mark.rs
@@ -96,6 +96,24 @@ enum IfBlockType<'hir> {
     ),
 }
 
+fn find_let_else_ret_expression<'hir>(block: &'hir Block<'hir>) -> Option<&'hir Expr<'hir>> {
+    if let Block {
+        stmts: &[],
+        expr: Some(els),
+        ..
+    } = block
+    {
+        Some(els)
+    } else if let [stmt] = block.stmts
+        && let StmtKind::Semi(expr) = stmt.kind
+        && let ExprKind::Ret(..) = expr.kind
+    {
+        Some(expr)
+    } else {
+        None
+    }
+}
+
 fn check_let_some_else_return_none(cx: &LateContext<'_>, stmt: &Stmt<'_>) {
     if let StmtKind::Local(Local {
         pat,
@@ -103,11 +121,7 @@ fn check_let_some_else_return_none(cx: &LateContext<'_>, stmt: &Stmt<'_>) {
         els: Some(els),
         ..
     }) = stmt.kind
-        && let Block {
-            stmts: &[],
-            expr: Some(els),
-            ..
-        } = els
+        && let Some(els) = find_let_else_ret_expression(els)
         && let Some(inner_pat) = pat_and_expr_can_be_question_mark(cx, pat, els)
     {
         let mut applicability = Applicability::MaybeIncorrect;
diff --git a/clippy_lints/src/undocumented_unsafe_blocks.rs b/clippy_lints/src/undocumented_unsafe_blocks.rs
index 7a6549a7c54..e5bc3b5a25f 100644
--- a/clippy_lints/src/undocumented_unsafe_blocks.rs
+++ b/clippy_lints/src/undocumented_unsafe_blocks.rs
@@ -680,9 +680,7 @@ fn text_has_safety_comment(src: &str, line_starts: &[RelativeBytePos], start_pos
         })
         .filter(|(_, text)| !text.is_empty());
 
-    let Some((line_start, line)) = lines.next() else {
-        return None;
-    };
+    let (line_start, line) = lines.next()?;
     // Check for a sequence of line comments.
     if line.starts_with("//") {
         let (mut line, mut line_start) = (line, line_start);
diff --git a/tests/ui/manual_let_else_question_mark.fixed b/tests/ui/manual_let_else_question_mark.fixed
index b555186cc22..fb465f38a8d 100644
--- a/tests/ui/manual_let_else_question_mark.fixed
+++ b/tests/ui/manual_let_else_question_mark.fixed
@@ -60,3 +60,16 @@ fn foo() -> Option<()> {
 
     Some(())
 }
+
+// lint not just `return None`, but also `return None;` (note the semicolon)
+fn issue11993(y: Option<i32>) -> Option<i32> {
+    let x = y?;
+
+    // don't lint: more than one statement in the else body
+    let Some(x) = y else {
+        todo!();
+        return None;
+    };
+
+    None
+}
diff --git a/tests/ui/manual_let_else_question_mark.rs b/tests/ui/manual_let_else_question_mark.rs
index 5852c7094a4..78b51f9c21c 100644
--- a/tests/ui/manual_let_else_question_mark.rs
+++ b/tests/ui/manual_let_else_question_mark.rs
@@ -65,3 +65,18 @@ fn foo() -> Option<()> {
 
     Some(())
 }
+
+// lint not just `return None`, but also `return None;` (note the semicolon)
+fn issue11993(y: Option<i32>) -> Option<i32> {
+    let Some(x) = y else {
+        return None;
+    };
+
+    // don't lint: more than one statement in the else body
+    let Some(x) = y else {
+        todo!();
+        return None;
+    };
+
+    None
+}
diff --git a/tests/ui/manual_let_else_question_mark.stderr b/tests/ui/manual_let_else_question_mark.stderr
index bf0b1bbf0dd..dec6947697a 100644
--- a/tests/ui/manual_let_else_question_mark.stderr
+++ b/tests/ui/manual_let_else_question_mark.stderr
@@ -53,5 +53,13 @@ error: this could be rewritten as `let...else`
 LL |         let v = if let Some(v_some) = g() { v_some } else { return None };
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let Some(v) = g() else { return None };`
 
-error: aborting due to 6 previous errors
+error: this `let...else` may be rewritten with the `?` operator
+  --> $DIR/manual_let_else_question_mark.rs:71:5
+   |
+LL | /     let Some(x) = y else {
+LL | |         return None;
+LL | |     };
+   | |______^ help: replace it with: `let x = y?;`
+
+error: aborting due to 7 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From e44caea259aef82b81ed50a3b37f4225451a5f8f Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Sat, 23 Dec 2023 16:21:58 +0100
Subject: respect comments in `question_mark`

---
 clippy_lints/src/question_mark.rs            | 7 ++++---
 tests/ui/manual_let_else_question_mark.fixed | 8 ++++++++
 tests/ui/manual_let_else_question_mark.rs    | 8 ++++++++
 3 files changed, 20 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/question_mark.rs b/clippy_lints/src/question_mark.rs
index a75798cd927..509d9483e1d 100644
--- a/clippy_lints/src/question_mark.rs
+++ b/clippy_lints/src/question_mark.rs
@@ -8,7 +8,7 @@ use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::{
     eq_expr_value, get_parent_node, higher, in_constant, is_else_clause, is_lint_allowed, is_path_lang_item,
     is_res_lang_ctor, pat_and_expr_can_be_question_mark, path_to_local, path_to_local_id, peel_blocks,
-    peel_blocks_with_stmt,
+    peel_blocks_with_stmt, span_contains_comment,
 };
 use rustc_errors::Applicability;
 use rustc_hir::def::Res;
@@ -121,8 +121,9 @@ fn check_let_some_else_return_none(cx: &LateContext<'_>, stmt: &Stmt<'_>) {
         els: Some(els),
         ..
     }) = stmt.kind
-        && let Some(els) = find_let_else_ret_expression(els)
-        && let Some(inner_pat) = pat_and_expr_can_be_question_mark(cx, pat, els)
+        && 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)
     {
         let mut applicability = Applicability::MaybeIncorrect;
         let init_expr_str = snippet_with_applicability(cx, init_expr.span, "..", &mut applicability);
diff --git a/tests/ui/manual_let_else_question_mark.fixed b/tests/ui/manual_let_else_question_mark.fixed
index fb465f38a8d..6b29ce75985 100644
--- a/tests/ui/manual_let_else_question_mark.fixed
+++ b/tests/ui/manual_let_else_question_mark.fixed
@@ -71,5 +71,13 @@ fn issue11993(y: Option<i32>) -> Option<i32> {
         return None;
     };
 
+    let Some(x) = y else {
+        // Roses are red,
+        // violets are blue,
+        // please keep this comment,
+        // it's art, you know?
+        return None;
+    };
+
     None
 }
diff --git a/tests/ui/manual_let_else_question_mark.rs b/tests/ui/manual_let_else_question_mark.rs
index 78b51f9c21c..e92c4c1375e 100644
--- a/tests/ui/manual_let_else_question_mark.rs
+++ b/tests/ui/manual_let_else_question_mark.rs
@@ -78,5 +78,13 @@ fn issue11993(y: Option<i32>) -> Option<i32> {
         return None;
     };
 
+    let Some(x) = y else {
+        // Roses are red,
+        // violets are blue,
+        // please keep this comment,
+        // it's art, you know?
+        return None;
+    };
+
     None
 }
-- 
cgit 1.4.1-3-g733a5


From 1576ecce409062fcce415fc873e9a16bc8130122 Mon Sep 17 00:00:00 2001
From: Tethys Svensson <freaken@freaken.dk>
Date: Fri, 22 Dec 2023 11:23:12 +0100
Subject: Move uninhabited_references to nursery

---
 clippy_lints/src/uninhabited_references.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/uninhabited_references.rs b/clippy_lints/src/uninhabited_references.rs
index d41576cadad..903593ecfd7 100644
--- a/clippy_lints/src/uninhabited_references.rs
+++ b/clippy_lints/src/uninhabited_references.rs
@@ -32,7 +32,7 @@ declare_clippy_lint! {
     /// ```
     #[clippy::version = "1.76.0"]
     pub UNINHABITED_REFERENCES,
-    suspicious,
+    nursery,
     "reference to uninhabited type"
 }
 
-- 
cgit 1.4.1-3-g733a5


From 4b1ac31c18be2e7c8175c9a66bf45a038e76ee6e Mon Sep 17 00:00:00 2001
From: Quinn Sinclair <me@partiallytyped.dev>
Date: Sun, 24 Dec 2023 14:40:14 +0200
Subject: Added MSRV and more tests, improved wording

---
 clippy_config/src/msrvs.rs              |  1 +
 clippy_lints/src/methods/iter_filter.rs | 26 ++++++++++++++++++++------
 clippy_lints/src/methods/mod.rs         | 15 +++++++++------
 tests/ui/iter_filter_is_ok.fixed        | 14 ++++++++++++++
 tests/ui/iter_filter_is_ok.rs           | 14 ++++++++++++++
 tests/ui/iter_filter_is_some.fixed      | 18 ++++++++++++++----
 tests/ui/iter_filter_is_some.rs         | 18 ++++++++++++++----
 tests/ui/iter_filter_is_some.stderr     |  4 ++--
 8 files changed, 88 insertions(+), 22 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_config/src/msrvs.rs b/clippy_config/src/msrvs.rs
index b3ef666e306..8dec477cfdd 100644
--- a/clippy_config/src/msrvs.rs
+++ b/clippy_config/src/msrvs.rs
@@ -41,6 +41,7 @@ msrv_aliases! {
     1,35,0 { OPTION_COPIED, RANGE_CONTAINS }
     1,34,0 { TRY_FROM }
     1,30,0 { ITERATOR_FIND_MAP, TOOL_ATTRIBUTES }
+    1,29,0 { ITER_FLATTEN }
     1,28,0 { FROM_BOOL }
     1,27,0 { ITERATOR_TRY_FOLD }
     1,26,0 { RANGE_INCLUSIVE, STRING_RETAIN }
diff --git a/clippy_lints/src/methods/iter_filter.rs b/clippy_lints/src/methods/iter_filter.rs
index 04dc4820f6a..f80bd2e2707 100644
--- a/clippy_lints/src/methods/iter_filter.rs
+++ b/clippy_lints/src/methods/iter_filter.rs
@@ -1,10 +1,10 @@
-use rustc_lint::LateContext;
+use rustc_lint::{LateContext, LintContext};
 
 use super::{ITER_FILTER_IS_OK, ITER_FILTER_IS_SOME};
 
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::{indent_of, reindent_multiline};
-use clippy_utils::{is_trait_method, peel_blocks};
+use clippy_utils::{is_trait_method, peel_blocks, span_contains_comment};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_hir::def::Res;
@@ -54,7 +54,14 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, filter_arg: &hir
     let is_iterator = is_trait_method(cx, expr, sym::Iterator);
     let parent_is_not_map = !parent_is_map(cx, expr);
 
-    if is_iterator && parent_is_not_map && is_method(cx, filter_arg, sym!(is_some)) {
+    if is_iterator
+        && parent_is_not_map
+        && is_method(cx, filter_arg, sym!(is_some))
+        && !span_contains_comment(
+            cx.sess().source_map(), 
+            filter_span.with_hi(expr.span.hi())
+        )
+    {
         span_lint_and_sugg(
             cx,
             ITER_FILTER_IS_SOME,
@@ -62,10 +69,17 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, filter_arg: &hir
             "`filter` for `is_some` on iterator over `Option`",
             "consider using `flatten` instead",
             reindent_multiline(Cow::Borrowed("flatten()"), true, indent_of(cx, filter_span)).into_owned(),
-            Applicability::MaybeIncorrect,
+            Applicability::HasPlaceholders,
         );
     }
-    if is_iterator && parent_is_not_map && is_method(cx, filter_arg, sym!(is_ok)) {
+    if is_iterator
+        && parent_is_not_map
+        && is_method(cx, filter_arg, sym!(is_ok))
+        && !span_contains_comment(
+            cx.sess().source_map(), 
+            filter_span.with_hi(expr.span.hi())
+        )
+    {
         span_lint_and_sugg(
             cx,
             ITER_FILTER_IS_OK,
@@ -73,7 +87,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, filter_arg: &hir
             "`filter` for `is_ok` on iterator over `Result`s",
             "consider using `flatten` instead",
             reindent_multiline(Cow::Borrowed("flatten()"), true, indent_of(cx, filter_span)).into_owned(),
-            Applicability::MaybeIncorrect,
+            Applicability::HasPlaceholders,
         );
     }
 }
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index d67fa28b30b..7a28f10ea87 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3779,8 +3779,8 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of `.filter(Optional::is_some)` that may be replaced with a `.flatten()` call.
-    /// This lint is potentially incorrect as it affects the type of follow-up calls.
+    /// Checks for usage of `.filter(Option::is_some)` that may be replaced with a `.flatten()` call.
+    /// This lint will require additional changes to the follow-up calls as it appects the type.
     ///
     /// ### Why is this bad?
     /// This pattern is often followed by manual unwrapping of the `Option`. The simplification
@@ -3799,14 +3799,14 @@ declare_clippy_lint! {
     /// ```
     #[clippy::version = "1.76.0"]
     pub ITER_FILTER_IS_SOME,
-    complexity,
+    pedantic,
     "filtering an iterator over `Option`s for `Some` can be achieved with `flatten`"
 }
 
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for usage of `.filter(Result::is_ok)` that may be replaced with a `.flatten()` call.
-    /// This lint is potentially incorrect as it affects the type of follow-up calls.
+    /// This lint will require additional changes to the follow-up calls as it appects the type.
     ///
     /// ### Why is this bad?
     /// This pattern is often followed by manual unwrapping of `Result`. The simplification
@@ -3825,7 +3825,7 @@ declare_clippy_lint! {
     /// ```
     #[clippy::version = "1.76.0"]
     pub ITER_FILTER_IS_OK,
-    complexity,
+    pedantic,
     "filtering an iterator over `Result`s for `Ok` can be achieved with `flatten`"
 }
 
@@ -4324,8 +4324,11 @@ impl Methods {
                             false,
                         );
                     }
+                    if self.msrv.meets(msrvs::ITER_FLATTEN) {
 
-                    iter_filter::check(cx, expr, arg, span);
+                        // use the sourcemap to get the span of the closure
+                        iter_filter::check(cx, expr, arg, span);
+                    }
                 },
                 ("find", [arg]) => {
                     if let Some(("cloned", recv2, [], _span2, _)) = method_call(recv) {
diff --git a/tests/ui/iter_filter_is_ok.fixed b/tests/ui/iter_filter_is_ok.fixed
index 9985877a02a..acfd097675c 100644
--- a/tests/ui/iter_filter_is_ok.fixed
+++ b/tests/ui/iter_filter_is_ok.fixed
@@ -5,4 +5,18 @@ fn main() {
     //~^ HELP: consider using `flatten` instead
     let _ = vec![Ok(1), Err(2), Ok(3)].into_iter().flatten();
     //~^ HELP: consider using `flatten` instead
+
+    // Don't lint below
+    let mut counter = 0;
+    let _ = vec![Ok(1), Err(2)].into_iter().filter(|o| {
+        counter += 1;
+        o.is_ok()
+    });
+    let _ = vec![Ok(1), Err(2)].into_iter().filter(|o| {
+        // Roses are red,
+        // Violets are blue,
+        // `Err` is not an `Option`,
+        // and this doesn't ryme
+        o.is_ok()
+    });
 }
diff --git a/tests/ui/iter_filter_is_ok.rs b/tests/ui/iter_filter_is_ok.rs
index 176ce902637..f13a28ad0e3 100644
--- a/tests/ui/iter_filter_is_ok.rs
+++ b/tests/ui/iter_filter_is_ok.rs
@@ -5,4 +5,18 @@ fn main() {
     //~^ HELP: consider using `flatten` instead
     let _ = vec![Ok(1), Err(2), Ok(3)].into_iter().filter(|a| a.is_ok());
     //~^ HELP: consider using `flatten` instead
+
+    // Don't lint below
+    let mut counter = 0;
+    let _ = vec![Ok(1), Err(2)].into_iter().filter(|o| {
+        counter += 1;
+        o.is_ok()
+    });
+    let _ = vec![Ok(1), Err(2)].into_iter().filter(|o| {
+        // Roses are red,
+        // Violets are blue,
+        // `Err` is not an `Option`,
+        // and this doesn't ryme
+        o.is_ok()
+    });
 }
diff --git a/tests/ui/iter_filter_is_some.fixed b/tests/ui/iter_filter_is_some.fixed
index 3732a8e72d1..f70f54b622e 100644
--- a/tests/ui/iter_filter_is_some.fixed
+++ b/tests/ui/iter_filter_is_some.fixed
@@ -1,12 +1,22 @@
 #![warn(clippy::iter_filter_is_some)]
 
-fn odds_out(x: i32) -> Option<i32> {
-    if x % 2 == 0 { Some(x) } else { None }
-}
-
 fn main() {
     let _ = vec![Some(1)].into_iter().flatten();
     //~^ HELP: consider using `flatten` instead
     let _ = vec![Some(1)].into_iter().flatten();
     //~^ HELP: consider using `flatten` instead
+
+    // Don't lint below
+    let mut counter = 0;
+    let _ = vec![Some(1)].into_iter().filter(|o| {
+        counter += 1;
+        o.is_some()
+    });
+    let _ = vec![Some(1)].into_iter().filter(|o| {
+        // Roses are red,
+        // Violets are blue,
+        // `Err` is not an `Option`,
+        // and this doesn't ryme
+        o.is_some()
+    });
 }
diff --git a/tests/ui/iter_filter_is_some.rs b/tests/ui/iter_filter_is_some.rs
index 5cc457efed5..18d450e8a98 100644
--- a/tests/ui/iter_filter_is_some.rs
+++ b/tests/ui/iter_filter_is_some.rs
@@ -1,12 +1,22 @@
 #![warn(clippy::iter_filter_is_some)]
 
-fn odds_out(x: i32) -> Option<i32> {
-    if x % 2 == 0 { Some(x) } else { None }
-}
-
 fn main() {
     let _ = vec![Some(1)].into_iter().filter(Option::is_some);
     //~^ HELP: consider using `flatten` instead
     let _ = vec![Some(1)].into_iter().filter(|o| o.is_some());
     //~^ HELP: consider using `flatten` instead
+
+    // Don't lint below
+    let mut counter = 0;
+    let _ = vec![Some(1)].into_iter().filter(|o| {
+        counter += 1;
+        o.is_some()
+    });
+    let _ = vec![Some(1)].into_iter().filter(|o| {
+        // Roses are red,
+        // Violets are blue,
+        // `Err` is not an `Option`,
+        // and this doesn't ryme
+        o.is_some()
+    });
 }
diff --git a/tests/ui/iter_filter_is_some.stderr b/tests/ui/iter_filter_is_some.stderr
index 2b1c1cdf7ef..a9ef1d547a9 100644
--- a/tests/ui/iter_filter_is_some.stderr
+++ b/tests/ui/iter_filter_is_some.stderr
@@ -1,5 +1,5 @@
 error: `filter` for `is_some` on iterator over `Option`
-  --> $DIR/iter_filter_is_some.rs:8:39
+  --> $DIR/iter_filter_is_some.rs:4:39
    |
 LL |     let _ = vec![Some(1)].into_iter().filter(Option::is_some);
    |                                       ^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
@@ -8,7 +8,7 @@ LL |     let _ = vec![Some(1)].into_iter().filter(Option::is_some);
    = help: to override `-D warnings` add `#[allow(clippy::iter_filter_is_some)]`
 
 error: `filter` for `is_some` on iterator over `Option`
-  --> $DIR/iter_filter_is_some.rs:10:39
+  --> $DIR/iter_filter_is_some.rs:6:39
    |
 LL |     let _ = vec![Some(1)].into_iter().filter(|o| o.is_some());
    |                                       ^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
-- 
cgit 1.4.1-3-g733a5


From 2177f2cb9699a410302d474d7baf3e6d546530e9 Mon Sep 17 00:00:00 2001
From: Quinn Sinclair <me@partiallytyped.dev>
Date: Sun, 24 Dec 2023 14:42:18 +0200
Subject: formatting

---
 clippy_lints/src/methods/iter_filter.rs | 10 ++--------
 clippy_lints/src/methods/mod.rs         |  1 -
 2 files changed, 2 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/iter_filter.rs b/clippy_lints/src/methods/iter_filter.rs
index f80bd2e2707..ade8e3155fa 100644
--- a/clippy_lints/src/methods/iter_filter.rs
+++ b/clippy_lints/src/methods/iter_filter.rs
@@ -57,10 +57,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, filter_arg: &hir
     if is_iterator
         && parent_is_not_map
         && is_method(cx, filter_arg, sym!(is_some))
-        && !span_contains_comment(
-            cx.sess().source_map(), 
-            filter_span.with_hi(expr.span.hi())
-        )
+        && !span_contains_comment(cx.sess().source_map(), filter_span.with_hi(expr.span.hi()))
     {
         span_lint_and_sugg(
             cx,
@@ -75,10 +72,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, filter_arg: &hir
     if is_iterator
         && parent_is_not_map
         && is_method(cx, filter_arg, sym!(is_ok))
-        && !span_contains_comment(
-            cx.sess().source_map(), 
-            filter_span.with_hi(expr.span.hi())
-        )
+        && !span_contains_comment(cx.sess().source_map(), filter_span.with_hi(expr.span.hi()))
     {
         span_lint_and_sugg(
             cx,
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 7a28f10ea87..25b1ea526e2 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -4325,7 +4325,6 @@ impl Methods {
                         );
                     }
                     if self.msrv.meets(msrvs::ITER_FLATTEN) {
-
                         // use the sourcemap to get the span of the closure
                         iter_filter::check(cx, expr, arg, span);
                     }
-- 
cgit 1.4.1-3-g733a5


From a578b9ba0b13e5dde95d2f09aab1b9d5ae699cb6 Mon Sep 17 00:00:00 2001
From: J-ZhengLi <lizheng135@huawei.com>
Date: Mon, 25 Dec 2023 14:28:01 +0800
Subject: make [`mutex_atomic`] more type aware

---
 clippy_lints/src/mutex_atomic.rs | 26 +++++++++++++++++++++++---
 tests/ui/mutex_atomic.rs         | 19 +++++++++++++++++--
 tests/ui/mutex_atomic.stderr     | 30 +++++++++++++++++++++++++++---
 3 files changed, 67 insertions(+), 8 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/mutex_atomic.rs b/clippy_lints/src/mutex_atomic.rs
index a23e12f7a18..4ae4fc9b096 100644
--- a/clippy_lints/src/mutex_atomic.rs
+++ b/clippy_lints/src/mutex_atomic.rs
@@ -6,7 +6,7 @@ use clippy_utils::diagnostics::span_lint;
 use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_hir::Expr;
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty::{self, Ty};
+use rustc_middle::ty::{self, IntTy, Ty, UintTy};
 use rustc_session::declare_lint_pass;
 use rustc_span::sym;
 
@@ -105,8 +105,28 @@ impl<'tcx> LateLintPass<'tcx> for Mutex {
 fn get_atomic_name(ty: Ty<'_>) -> Option<&'static str> {
     match ty.kind() {
         ty::Bool => Some("AtomicBool"),
-        ty::Uint(_) => Some("AtomicUsize"),
-        ty::Int(_) => Some("AtomicIsize"),
+        ty::Uint(uint_ty) => {
+            match uint_ty {
+                UintTy::U8 => Some("AtomicU8"),
+                UintTy::U16 => Some("AtomicU16"),
+                UintTy::U32 => Some("AtomicU32"),
+                UintTy::U64 => Some("AtomicU64"),
+                UintTy::Usize => Some("AtomicUsize"),
+                // There's no `AtomicU128`.
+                UintTy::U128 => None,
+            }
+        },
+        ty::Int(int_ty) => {
+            match int_ty {
+                IntTy::I8 => Some("AtomicI8"),
+                IntTy::I16 => Some("AtomicI16"),
+                IntTy::I32 => Some("AtomicI32"),
+                IntTy::I64 => Some("AtomicI64"),
+                IntTy::Isize => Some("AtomicIsize"),
+                // There's no `AtomicI128`.
+                IntTy::I128 => None,
+            }
+        },
         ty::RawPtr(_) => Some("AtomicPtr"),
         _ => None,
     }
diff --git a/tests/ui/mutex_atomic.rs b/tests/ui/mutex_atomic.rs
index 198b95d8c94..3a51538b742 100644
--- a/tests/ui/mutex_atomic.rs
+++ b/tests/ui/mutex_atomic.rs
@@ -18,9 +18,24 @@ fn main() {
     Mutex::new(&mut x as *mut u32);
     //~^ ERROR: consider using an `AtomicPtr` instead of a `Mutex` here; if you just want
     Mutex::new(0u32);
-    //~^ ERROR: consider using an `AtomicUsize` instead of a `Mutex` here; if you just wan
+    //~^ ERROR: consider using an `AtomicU32` instead of a `Mutex` here; if you just wan
     //~| NOTE: `-D clippy::mutex-integer` implied by `-D warnings`
     Mutex::new(0i32);
-    //~^ ERROR: consider using an `AtomicIsize` instead of a `Mutex` here; if you just wan
+    //~^ ERROR: consider using an `AtomicI32` instead of a `Mutex` here; if you just wan
     Mutex::new(0f32); // there are no float atomics, so this should not lint
+    Mutex::new(0u8);
+    //~^ ERROR: consider using an `AtomicU8` instead of a `Mutex` here; if you just wan
+    Mutex::new(0i16);
+    //~^ ERROR: consider using an `AtomicI16` instead of a `Mutex` here; if you just wan
+    let _x: Mutex<i8> = Mutex::new(0);
+    //~^ ERROR: consider using an `AtomicI8` instead of a `Mutex` here; if you just wan
+    const X: i64 = 0;
+    Mutex::new(X);
+    //~^ ERROR: consider using an `AtomicI64` instead of a `Mutex` here; if you just wan
+
+    // there are no 128 atomics, so these two should not lint
+    {
+        Mutex::new(0u128);
+        let _x: Mutex<i128> = Mutex::new(0);
+    }
 }
diff --git a/tests/ui/mutex_atomic.stderr b/tests/ui/mutex_atomic.stderr
index 483e1ce15f6..91f73d30b53 100644
--- a/tests/ui/mutex_atomic.stderr
+++ b/tests/ui/mutex_atomic.stderr
@@ -31,7 +31,7 @@ error: consider using an `AtomicPtr` instead of a `Mutex` here; if you just want
 LL |     Mutex::new(&mut x as *mut u32);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: consider using an `AtomicUsize` instead of a `Mutex` here; if you just want the locking behavior and not the internal type, consider using `Mutex<()>`
+error: consider using an `AtomicU32` instead of a `Mutex` here; if you just want the locking behavior and not the internal type, consider using `Mutex<()>`
   --> $DIR/mutex_atomic.rs:20:5
    |
 LL |     Mutex::new(0u32);
@@ -40,11 +40,35 @@ LL |     Mutex::new(0u32);
    = note: `-D clippy::mutex-integer` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::mutex_integer)]`
 
-error: consider using an `AtomicIsize` instead of a `Mutex` here; if you just want the locking behavior and not the internal type, consider using `Mutex<()>`
+error: consider using an `AtomicI32` instead of a `Mutex` here; if you just want the locking behavior and not the internal type, consider using `Mutex<()>`
   --> $DIR/mutex_atomic.rs:23:5
    |
 LL |     Mutex::new(0i32);
    |     ^^^^^^^^^^^^^^^^
 
-error: aborting due to 7 previous errors
+error: consider using an `AtomicU8` instead of a `Mutex` here; if you just want the locking behavior and not the internal type, consider using `Mutex<()>`
+  --> $DIR/mutex_atomic.rs:26:5
+   |
+LL |     Mutex::new(0u8);
+   |     ^^^^^^^^^^^^^^^
+
+error: consider using an `AtomicI16` instead of a `Mutex` here; if you just want the locking behavior and not the internal type, consider using `Mutex<()>`
+  --> $DIR/mutex_atomic.rs:28:5
+   |
+LL |     Mutex::new(0i16);
+   |     ^^^^^^^^^^^^^^^^
+
+error: consider using an `AtomicI8` instead of a `Mutex` here; if you just want the locking behavior and not the internal type, consider using `Mutex<()>`
+  --> $DIR/mutex_atomic.rs:30:25
+   |
+LL |     let _x: Mutex<i8> = Mutex::new(0);
+   |                         ^^^^^^^^^^^^^
+
+error: consider using an `AtomicI64` instead of a `Mutex` here; if you just want the locking behavior and not the internal type, consider using `Mutex<()>`
+  --> $DIR/mutex_atomic.rs:33:5
+   |
+LL |     Mutex::new(X);
+   |     ^^^^^^^^^^^^^
+
+error: aborting due to 11 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 8990153997c1dfbab238c5b1c1bf8b1b393e4751 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Tue, 26 Dec 2023 16:00:53 +0100
Subject: Update version attribute for 1.75 lints

---
 clippy_lints/src/iter_without_into_iter.rs | 4 ++--
 clippy_lints/src/manual_hash_one.rs        | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/iter_without_into_iter.rs b/clippy_lints/src/iter_without_into_iter.rs
index 3a5756482a1..c9dc48668f2 100644
--- a/clippy_lints/src/iter_without_into_iter.rs
+++ b/clippy_lints/src/iter_without_into_iter.rs
@@ -49,7 +49,7 @@ declare_clippy_lint! {
     ///     }
     /// }
     /// ```
-    #[clippy::version = "1.74.0"]
+    #[clippy::version = "1.75.0"]
     pub ITER_WITHOUT_INTO_ITER,
     pedantic,
     "implementing `iter(_mut)` without an associated `IntoIterator for (&|&mut) Type` impl"
@@ -101,7 +101,7 @@ declare_clippy_lint! {
     ///     }
     /// }
     /// ```
-    #[clippy::version = "1.74.0"]
+    #[clippy::version = "1.75.0"]
     pub INTO_ITER_WITHOUT_ITER,
     pedantic,
     "implementing `IntoIterator for (&|&mut) Type` without an inherent `iter(_mut)` method"
diff --git a/clippy_lints/src/manual_hash_one.rs b/clippy_lints/src/manual_hash_one.rs
index 252b3a83a18..73687fbbe54 100644
--- a/clippy_lints/src/manual_hash_one.rs
+++ b/clippy_lints/src/manual_hash_one.rs
@@ -40,7 +40,7 @@ declare_clippy_lint! {
     ///
     /// let hash = s.hash_one(&value);
     /// ```
-    #[clippy::version = "1.74.0"]
+    #[clippy::version = "1.75.0"]
     pub MANUAL_HASH_ONE,
     complexity,
     "manual implementations of `BuildHasher::hash_one`"
-- 
cgit 1.4.1-3-g733a5


From 57dd25e2ffbf9c7abd63fcdf057facff7a46c342 Mon Sep 17 00:00:00 2001
From: Quinn Sinclair <me@partiallytyped.dev>
Date: Tue, 26 Dec 2023 20:34:00 +0200
Subject: FP: `needless_return_with_question_mark` with implicit Error
 Conversion

Return with a question mark was triggered in situations where the `?`
desuraging was performing error conversion via `Into`/`From`.

The desugared `?` produces a match over an expression with type
`std::ops::ControlFlow<B,C>` with `B:Result<Infallible, E:Error>` and
`C:Result<_, E':Error>`, and the arms perform the conversion. The patch
adds another check in the lint that checks that `E == E'`. If `E == E'`,
then the `?` is indeed unnecessary.

changelog: False Positive: `needless_return_with_question_mark` when
implicit Error Conversion occurs.
---
 clippy_lints/src/returns.rs                       | 28 ++++++++++++++++++++++-
 tests/ui/needless_return_with_question_mark.fixed | 27 ++++++++++++++++++++++
 tests/ui/needless_return_with_question_mark.rs    | 27 ++++++++++++++++++++++
 3 files changed, 81 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
index 2293b53b42b..2d4e7d269fd 100644
--- a/clippy_lints/src/returns.rs
+++ b/clippy_lints/src/returns.rs
@@ -176,12 +176,37 @@ fn stmt_needs_never_type(cx: &LateContext<'_>, stmt_hir_id: HirId) -> bool {
         })
 }
 
+///
+/// The expression of the desugared `try` operator is a match over an expression with type:
+/// `ControlFlow<A:Result<Infallible, E>, B:Result<_, E'>>`, with final type `B`.
+/// If E and E' are the same type, then there is no error conversion happening.
+/// Error conversion happens when E can be transformed into E' via a `From` or `Into` conversion.
+fn desugar_expr_performs_error_conversion(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+    let ty = cx.typeck_results().expr_ty(expr);
+
+    if let ty::Adt(_, generics) = ty.kind()
+        && let Some(brk) = generics.first()
+        && let Some(cont) = generics.get(1)
+        && let Some(brk_type) = brk.as_type()
+        && let Some(cont_type) = cont.as_type()
+        && let ty::Adt(_, brk_generics) = brk_type.kind()
+        && let ty::Adt(_, cont_generics) = cont_type.kind()
+        && let Some(brk_err) = brk_generics.get(1)
+        && let Some(cont_err) = cont_generics.get(1)
+        && let Some(brk_err_type) = brk_err.as_type()
+        && let Some(cont_err_type) = cont_err.as_type()
+    {
+        return brk_err_type != cont_err_type;
+    }
+    false
+}
+
 impl<'tcx> LateLintPass<'tcx> for Return {
     fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) {
         if !in_external_macro(cx.sess(), stmt.span)
             && let StmtKind::Semi(expr) = stmt.kind
             && let ExprKind::Ret(Some(ret)) = expr.kind
-            && let ExprKind::Match(.., MatchSource::TryDesugar(_)) = ret.kind
+            && let ExprKind::Match(match_expr, _, MatchSource::TryDesugar(..)) = ret.kind
             // Ensure this is not the final stmt, otherwise removing it would cause a compile error
             && let OwnerNode::Item(item) = cx.tcx.hir().owner(cx.tcx.hir().get_parent_item(expr.hir_id))
             && let ItemKind::Fn(_, _, body) = item.kind
@@ -192,6 +217,7 @@ impl<'tcx> LateLintPass<'tcx> for Return {
             && final_stmt.hir_id != stmt.hir_id
             && !is_from_proc_macro(cx, expr)
             && !stmt_needs_never_type(cx, stmt.hir_id)
+            && !desugar_expr_performs_error_conversion(cx, match_expr)
         {
             span_lint_and_sugg(
                 cx,
diff --git a/tests/ui/needless_return_with_question_mark.fixed b/tests/ui/needless_return_with_question_mark.fixed
index 0147c73a94b..8a97d8604a5 100644
--- a/tests/ui/needless_return_with_question_mark.fixed
+++ b/tests/ui/needless_return_with_question_mark.fixed
@@ -77,3 +77,30 @@ fn issue11616() -> Result<(), ()> {
     };
     Ok(())
 }
+
+/// This is a false positive that occurs because of the way `?` is handled.
+/// The `?` operator is also doing a conversion from `Result<T, E>` to `Result<T, E'>`.
+/// In this case the conversion is needed, and thus the `?` operator is also needed.
+fn issue11982() {
+    mod bar {
+        pub struct Error;
+        pub fn foo(_: bool) -> Result<(), Error> {
+            Ok(())
+        }
+    }
+
+    pub struct Error;
+
+    impl From<bar::Error> for Error {
+        fn from(_: bar::Error) -> Self {
+            Error
+        }
+    }
+
+    fn foo(ok: bool) -> Result<(), Error> {
+        if !ok {
+            return bar::foo(ok).map(|_| Ok::<(), Error>(()))?;
+        };
+        Ok(())
+    }
+}
diff --git a/tests/ui/needless_return_with_question_mark.rs b/tests/ui/needless_return_with_question_mark.rs
index 66e1f438f8c..be15b000f5d 100644
--- a/tests/ui/needless_return_with_question_mark.rs
+++ b/tests/ui/needless_return_with_question_mark.rs
@@ -77,3 +77,30 @@ fn issue11616() -> Result<(), ()> {
     };
     Ok(())
 }
+
+/// This is a false positive that occurs because of the way `?` is handled.
+/// The `?` operator is also doing a conversion from `Result<T, E>` to `Result<T, E'>`.
+/// In this case the conversion is needed, and thus the `?` operator is also needed.
+fn issue11982() {
+    mod bar {
+        pub struct Error;
+        pub fn foo(_: bool) -> Result<(), Error> {
+            Ok(())
+        }
+    }
+
+    pub struct Error;
+
+    impl From<bar::Error> for Error {
+        fn from(_: bar::Error) -> Self {
+            Error
+        }
+    }
+
+    fn foo(ok: bool) -> Result<(), Error> {
+        if !ok {
+            return bar::foo(ok).map(|_| Ok::<(), Error>(()))?;
+        };
+        Ok(())
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From c4a80f2e3e8375ff54826840e2e2a5c53a20e2ce Mon Sep 17 00:00:00 2001
From: Yuxiang Qiu <yuxqiu@proton.me>
Date: Fri, 24 Nov 2023 20:56:57 -0500
Subject: feat: add `manual_is_variant_and` lint

---
 CHANGELOG.md                                      |  1 +
 clippy_config/src/msrvs.rs                        |  2 +-
 clippy_lints/src/declared_lints.rs                |  1 +
 clippy_lints/src/lines_filter_map_ok.rs           |  3 +-
 clippy_lints/src/methods/manual_is_variant_and.rs | 59 ++++++++++++++++
 clippy_lints/src/methods/mod.rs                   | 36 +++++++++-
 clippy_lints/src/methods/option_map_unwrap_or.rs  |  2 +-
 clippy_lints/src/methods/path_ends_with_ext.rs    |  2 +-
 tests/ui/manual_is_variant_and.fixed              | 51 ++++++++++++++
 tests/ui/manual_is_variant_and.rs                 | 57 ++++++++++++++++
 tests/ui/manual_is_variant_and.stderr             | 82 +++++++++++++++++++++++
 11 files changed, 290 insertions(+), 6 deletions(-)
 create mode 100644 clippy_lints/src/methods/manual_is_variant_and.rs
 create mode 100644 tests/ui/manual_is_variant_and.fixed
 create mode 100644 tests/ui/manual_is_variant_and.rs
 create mode 100644 tests/ui/manual_is_variant_and.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index e01c09b295c..054d9390dd2 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5293,6 +5293,7 @@ Released 2018-09-13
 [`manual_is_ascii_check`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_is_ascii_check
 [`manual_is_finite`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_is_finite
 [`manual_is_infinite`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_is_infinite
+[`manual_is_variant_and`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_is_variant_and
 [`manual_let_else`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_let_else
 [`manual_main_separator_str`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_main_separator_str
 [`manual_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_map
diff --git a/clippy_config/src/msrvs.rs b/clippy_config/src/msrvs.rs
index 8dec477cfdd..773cce36df4 100644
--- a/clippy_config/src/msrvs.rs
+++ b/clippy_config/src/msrvs.rs
@@ -17,7 +17,7 @@ macro_rules! msrv_aliases {
 // names may refer to stabilized feature flags or library items
 msrv_aliases! {
     1,71,0 { TUPLE_ARRAY_CONVERSIONS, BUILD_HASHER_HASH_ONE }
-    1,70,0 { OPTION_IS_SOME_AND, BINARY_HEAP_RETAIN }
+    1,70,0 { OPTION_RESULT_IS_VARIANT_AND, BINARY_HEAP_RETAIN }
     1,68,0 { PATH_MAIN_SEPARATOR_STR }
     1,65,0 { LET_ELSE, POINTER_CAST_CONSTNESS }
     1,62,0 { BOOL_THEN_SOME, DEFAULT_ENUM_ATTRIBUTE }
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index a00e2d3e044..1db94ad3045 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -385,6 +385,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::methods::JOIN_ABSOLUTE_PATHS_INFO,
     crate::methods::MANUAL_FILTER_MAP_INFO,
     crate::methods::MANUAL_FIND_MAP_INFO,
+    crate::methods::MANUAL_IS_VARIANT_AND_INFO,
     crate::methods::MANUAL_NEXT_BACK_INFO,
     crate::methods::MANUAL_OK_OR_INFO,
     crate::methods::MANUAL_SATURATING_ARITHMETIC_INFO,
diff --git a/clippy_lints/src/lines_filter_map_ok.rs b/clippy_lints/src/lines_filter_map_ok.rs
index 8a0955147bb..29957e423b0 100644
--- a/clippy_lints/src/lines_filter_map_ok.rs
+++ b/clippy_lints/src/lines_filter_map_ok.rs
@@ -96,8 +96,7 @@ fn should_lint(cx: &LateContext<'_>, args: &[Expr<'_>], method_str: &str) -> boo
                 ExprKind::Path(qpath) => cx
                     .qpath_res(qpath, fm_arg.hir_id)
                     .opt_def_id()
-                    .map(|did| match_def_path(cx, did, &paths::CORE_RESULT_OK_METHOD))
-                    .unwrap_or_default(),
+                    .is_some_and(|did| match_def_path(cx, did, &paths::CORE_RESULT_OK_METHOD)),
                 // Detect `|x| x.ok()`
                 ExprKind::Closure(Closure { body, .. }) => {
                     if let Body {
diff --git a/clippy_lints/src/methods/manual_is_variant_and.rs b/clippy_lints/src/methods/manual_is_variant_and.rs
new file mode 100644
index 00000000000..d29acd4622a
--- /dev/null
+++ b/clippy_lints/src/methods/manual_is_variant_and.rs
@@ -0,0 +1,59 @@
+use clippy_config::msrvs::{Msrv, OPTION_RESULT_IS_VARIANT_AND};
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet;
+use clippy_utils::ty::is_type_diagnostic_item;
+use rustc_errors::Applicability;
+use rustc_lint::LateContext;
+use rustc_span::{sym, Span};
+
+use super::MANUAL_IS_VARIANT_AND;
+
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'_>,
+    expr: &'tcx rustc_hir::Expr<'_>,
+    map_recv: &'tcx rustc_hir::Expr<'_>,
+    map_arg: &'tcx rustc_hir::Expr<'_>,
+    map_span: Span,
+    msrv: &Msrv,
+) {
+    // Don't lint if:
+
+    // 1. the `expr` is generated by a macro
+    if expr.span.from_expansion() {
+        return;
+    }
+
+    // 2. the caller of `map()` is neither `Option` nor `Result`
+    let is_option = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(map_recv), sym::Option);
+    let is_result = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(map_recv), sym::Result);
+    if !is_option && !is_result {
+        return;
+    }
+
+    // 3. the caller of `unwrap_or_default` is neither `Option<bool>` nor `Result<bool, _>`
+    if !cx.typeck_results().expr_ty(expr).is_bool() {
+        return;
+    }
+
+    // 4. msrv doesn't meet `OPTION_RESULT_IS_VARIANT_AND`
+    if !msrv.meets(OPTION_RESULT_IS_VARIANT_AND) {
+        return;
+    }
+
+    let lint_msg = if is_option {
+        "called `map(<f>).unwrap_or_default()` on an `Option` value"
+    } else {
+        "called `map(<f>).unwrap_or_default()` on a `Result` value"
+    };
+    let suggestion = if is_option { "is_some_and" } else { "is_ok_and" };
+
+    span_lint_and_sugg(
+        cx,
+        MANUAL_IS_VARIANT_AND,
+        expr.span.with_lo(map_span.lo()),
+        lint_msg,
+        "use",
+        format!("{}({})", suggestion, snippet(cx, map_arg.span, "..")),
+        Applicability::MachineApplicable,
+    );
+}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 25b1ea526e2..0cde17ef5ad 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -51,6 +51,7 @@ mod iter_skip_zero;
 mod iter_with_drain;
 mod iterator_step_by_zero;
 mod join_absolute_paths;
+mod manual_is_variant_and;
 mod manual_next_back;
 mod manual_ok_or;
 mod manual_saturating_arithmetic;
@@ -3829,6 +3830,32 @@ declare_clippy_lint! {
     "filtering an iterator over `Result`s for `Ok` can be achieved with `flatten`"
 }
 
+declare_clippy_lint! {
+    /// Checks for usage of `option.map(f).unwrap_or_default()` and `result.map(f).unwrap_or_default()` where f is a function or closure that returns the `bool` type.
+    ///
+    /// ### Why is this bad?
+    /// Readability. These can be written more concisely as `option.is_some_and(f)` and `result.is_ok_and(f)`.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # let option = Some(1);
+    /// # let result: Result<usize, ()> = Ok(1);
+    /// option.map(|a| a > 10).unwrap_or_default();
+    /// result.map(|a| a > 10).unwrap_or_default();
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// # let option = Some(1);
+    /// # let result: Result<usize, ()> = Ok(1);
+    /// option.is_some_and(|a| a > 10);
+    /// result.is_ok_and(|a| a > 10);
+    /// ```
+    #[clippy::version = "1.76.0"]
+    pub MANUAL_IS_VARIANT_AND,
+    pedantic,
+    "using `.map(f).unwrap_or_default()`, which is more succinctly expressed as `is_some_and(f)` or `is_ok_and(f)`"
+}
+
 pub struct Methods {
     avoid_breaking_exported_api: bool,
     msrv: Msrv,
@@ -3983,6 +4010,7 @@ impl_lint_pass!(Methods => [
     RESULT_FILTER_MAP,
     ITER_FILTER_IS_SOME,
     ITER_FILTER_IS_OK,
+    MANUAL_IS_VARIANT_AND,
 ]);
 
 /// Extracts a method call name, args, and `Span` of the method name.
@@ -4664,7 +4692,13 @@ impl Methods {
                     }
                     unnecessary_literal_unwrap::check(cx, expr, recv, name, args);
                 },
-                ("unwrap_or_default" | "unwrap_unchecked" | "unwrap_err_unchecked", []) => {
+                ("unwrap_or_default", []) => {
+                    if let Some(("map", m_recv, [arg], span, _)) = method_call(recv) {
+                        manual_is_variant_and::check(cx, expr, m_recv, arg, span, &self.msrv);
+                    }
+                    unnecessary_literal_unwrap::check(cx, expr, recv, name, args);
+                },
+                ("unwrap_unchecked" | "unwrap_err_unchecked", []) => {
                     unnecessary_literal_unwrap::check(cx, expr, recv, name, args);
                 },
                 ("unwrap_or_else", [u_arg]) => {
diff --git a/clippy_lints/src/methods/option_map_unwrap_or.rs b/clippy_lints/src/methods/option_map_unwrap_or.rs
index 63e64a5b35d..35deabe49b6 100644
--- a/clippy_lints/src/methods/option_map_unwrap_or.rs
+++ b/clippy_lints/src/methods/option_map_unwrap_or.rs
@@ -72,7 +72,7 @@ pub(super) fn check<'tcx>(
         }
 
         // is_some_and is stabilised && `unwrap_or` argument is false; suggest `is_some_and` instead
-        let suggest_is_some_and = msrv.meets(msrvs::OPTION_IS_SOME_AND)
+        let suggest_is_some_and = msrv.meets(msrvs::OPTION_RESULT_IS_VARIANT_AND)
             && matches!(&unwrap_arg.kind, ExprKind::Lit(lit)
             if matches!(lit.node, rustc_ast::LitKind::Bool(false)));
 
diff --git a/clippy_lints/src/methods/path_ends_with_ext.rs b/clippy_lints/src/methods/path_ends_with_ext.rs
index 094ead9f4ad..29f44ec2a4d 100644
--- a/clippy_lints/src/methods/path_ends_with_ext.rs
+++ b/clippy_lints/src/methods/path_ends_with_ext.rs
@@ -33,7 +33,7 @@ pub(super) fn check(
         && path.chars().all(char::is_alphanumeric)
     {
         let mut sugg = snippet(cx, recv.span, "..").into_owned();
-        if msrv.meets(msrvs::OPTION_IS_SOME_AND) {
+        if msrv.meets(msrvs::OPTION_RESULT_IS_VARIANT_AND) {
             let _ = write!(sugg, r#".extension().is_some_and(|ext| ext == "{path}")"#);
         } else {
             let _ = write!(sugg, r#".extension().map_or(false, |ext| ext == "{path}")"#);
diff --git a/tests/ui/manual_is_variant_and.fixed b/tests/ui/manual_is_variant_and.fixed
new file mode 100644
index 00000000000..8c34b51103c
--- /dev/null
+++ b/tests/ui/manual_is_variant_and.fixed
@@ -0,0 +1,51 @@
+//@aux-build:option_helpers.rs
+#![warn(clippy::manual_is_variant_and)]
+
+#[macro_use]
+extern crate option_helpers;
+
+#[rustfmt::skip]
+fn option_methods() {
+    let opt = Some(1);
+
+    // Check for `option.map(_).unwrap_or_default()` use.
+    // Single line case.
+    let _ = opt.is_some_and(|x| x > 1);
+    // Multi-line cases.
+    let _ = opt.is_some_and(|x| {
+        x > 1
+    });
+    let _ = opt.is_some_and(|x| x > 1);
+    let _ = opt
+        .is_some_and(|x| x > 1);
+
+    // won't fix because the return type of the closure is not `bool`
+    let _ = opt.map(|x| x + 1).unwrap_or_default();
+
+    let opt2 = Some('a');
+    let _ = opt2.is_some_and(char::is_alphanumeric); // should lint
+    let _ = opt_map!(opt2, |x| x == 'a').unwrap_or_default(); // should not lint
+}
+
+#[rustfmt::skip]
+fn result_methods() {
+    let res: Result<i32, ()> = Ok(1);
+
+    // multi line cases
+    let _ = res.is_ok_and(|x| {
+        x > 1
+    });
+    let _ = res.is_ok_and(|x| x > 1);
+
+    // won't fix because the return type of the closure is not `bool`
+    let _ = res.map(|x| x + 1).unwrap_or_default();
+
+    let res2: Result<char, ()> = Ok('a');
+    let _ = res2.is_ok_and(char::is_alphanumeric); // should lint
+    let _ = opt_map!(res2, |x| x == 'a').unwrap_or_default(); // should not lint
+}
+
+fn main() {
+    option_methods();
+    result_methods();
+}
diff --git a/tests/ui/manual_is_variant_and.rs b/tests/ui/manual_is_variant_and.rs
new file mode 100644
index 00000000000..25b2489d942
--- /dev/null
+++ b/tests/ui/manual_is_variant_and.rs
@@ -0,0 +1,57 @@
+//@aux-build:option_helpers.rs
+#![warn(clippy::manual_is_variant_and)]
+
+#[macro_use]
+extern crate option_helpers;
+
+#[rustfmt::skip]
+fn option_methods() {
+    let opt = Some(1);
+
+    // Check for `option.map(_).unwrap_or_default()` use.
+    // Single line case.
+    let _ = opt.map(|x| x > 1)
+        // Should lint even though this call is on a separate line.
+        .unwrap_or_default();
+    // Multi-line cases.
+    let _ = opt.map(|x| {
+        x > 1
+    }
+    ).unwrap_or_default();
+    let _ = opt.map(|x| x > 1).unwrap_or_default();
+    let _ = opt
+        .map(|x| x > 1)
+        .unwrap_or_default();
+
+    // won't fix because the return type of the closure is not `bool`
+    let _ = opt.map(|x| x + 1).unwrap_or_default();
+
+    let opt2 = Some('a');
+    let _ = opt2.map(char::is_alphanumeric).unwrap_or_default(); // should lint
+    let _ = opt_map!(opt2, |x| x == 'a').unwrap_or_default(); // should not lint
+}
+
+#[rustfmt::skip]
+fn result_methods() {
+    let res: Result<i32, ()> = Ok(1);
+
+    // multi line cases
+    let _ = res.map(|x| {
+        x > 1
+    }
+    ).unwrap_or_default();
+    let _ = res.map(|x| x > 1)
+        .unwrap_or_default();
+
+    // won't fix because the return type of the closure is not `bool`
+    let _ = res.map(|x| x + 1).unwrap_or_default();
+
+    let res2: Result<char, ()> = Ok('a');
+    let _ = res2.map(char::is_alphanumeric).unwrap_or_default(); // should lint
+    let _ = opt_map!(res2, |x| x == 'a').unwrap_or_default(); // should not lint
+}
+
+fn main() {
+    option_methods();
+    result_methods();
+}
diff --git a/tests/ui/manual_is_variant_and.stderr b/tests/ui/manual_is_variant_and.stderr
new file mode 100644
index 00000000000..c243de098dc
--- /dev/null
+++ b/tests/ui/manual_is_variant_and.stderr
@@ -0,0 +1,82 @@
+error: called `map(<f>).unwrap_or_default()` on an `Option` value
+  --> $DIR/manual_is_variant_and.rs:13:17
+   |
+LL |       let _ = opt.map(|x| x > 1)
+   |  _________________^
+LL | |         // Should lint even though this call is on a separate line.
+LL | |         .unwrap_or_default();
+   | |____________________________^ help: use: `is_some_and(|x| x > 1)`
+   |
+   = note: `-D clippy::manual-is-variant-and` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::manual_is_variant_and)]`
+
+error: called `map(<f>).unwrap_or_default()` on an `Option` value
+  --> $DIR/manual_is_variant_and.rs:17:17
+   |
+LL |       let _ = opt.map(|x| {
+   |  _________________^
+LL | |         x > 1
+LL | |     }
+LL | |     ).unwrap_or_default();
+   | |_________________________^
+   |
+help: use
+   |
+LL ~     let _ = opt.is_some_and(|x| {
+LL +         x > 1
+LL ~     });
+   |
+
+error: called `map(<f>).unwrap_or_default()` on an `Option` value
+  --> $DIR/manual_is_variant_and.rs:21:17
+   |
+LL |     let _ = opt.map(|x| x > 1).unwrap_or_default();
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `is_some_and(|x| x > 1)`
+
+error: called `map(<f>).unwrap_or_default()` on an `Option` value
+  --> $DIR/manual_is_variant_and.rs:23:10
+   |
+LL |           .map(|x| x > 1)
+   |  __________^
+LL | |         .unwrap_or_default();
+   | |____________________________^ help: use: `is_some_and(|x| x > 1)`
+
+error: called `map(<f>).unwrap_or_default()` on an `Option` value
+  --> $DIR/manual_is_variant_and.rs:30:18
+   |
+LL |     let _ = opt2.map(char::is_alphanumeric).unwrap_or_default(); // should lint
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `is_some_and(char::is_alphanumeric)`
+
+error: called `map(<f>).unwrap_or_default()` on a `Result` value
+  --> $DIR/manual_is_variant_and.rs:39:17
+   |
+LL |       let _ = res.map(|x| {
+   |  _________________^
+LL | |         x > 1
+LL | |     }
+LL | |     ).unwrap_or_default();
+   | |_________________________^
+   |
+help: use
+   |
+LL ~     let _ = res.is_ok_and(|x| {
+LL +         x > 1
+LL ~     });
+   |
+
+error: called `map(<f>).unwrap_or_default()` on a `Result` value
+  --> $DIR/manual_is_variant_and.rs:43:17
+   |
+LL |       let _ = res.map(|x| x > 1)
+   |  _________________^
+LL | |         .unwrap_or_default();
+   | |____________________________^ help: use: `is_ok_and(|x| x > 1)`
+
+error: called `map(<f>).unwrap_or_default()` on a `Result` value
+  --> $DIR/manual_is_variant_and.rs:50:18
+   |
+LL |     let _ = res2.map(char::is_alphanumeric).unwrap_or_default(); // should lint
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `is_ok_and(char::is_alphanumeric)`
+
+error: aborting due to 8 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 08d8ca9edd7a83f15a27012391fc9760ed30e408 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Mon, 18 Dec 2023 23:44:42 +0100
Subject: new lint: `eager_int_transmute`

---
 CHANGELOG.md                                  |  1 +
 clippy_lints/src/declared_lints.rs            |  1 +
 clippy_lints/src/lib.rs                       |  1 +
 clippy_lints/src/transmute/eager_transmute.rs | 74 +++++++++++++++++++++
 clippy_lints/src/transmute/mod.rs             | 61 +++++++++++++++++-
 tests/ui/eager_transmute.fixed                | 72 +++++++++++++++++++++
 tests/ui/eager_transmute.rs                   | 72 +++++++++++++++++++++
 tests/ui/eager_transmute.stderr               | 92 +++++++++++++++++++++++++++
 8 files changed, 373 insertions(+), 1 deletion(-)
 create mode 100644 clippy_lints/src/transmute/eager_transmute.rs
 create mode 100644 tests/ui/eager_transmute.fixed
 create mode 100644 tests/ui/eager_transmute.rs
 create mode 100644 tests/ui/eager_transmute.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 7beb4eb17d4..62f1e8d5a58 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5044,6 +5044,7 @@ Released 2018-09-13
 [`duplicate_mod`]: https://rust-lang.github.io/rust-clippy/master/index.html#duplicate_mod
 [`duplicate_underscore_argument`]: https://rust-lang.github.io/rust-clippy/master/index.html#duplicate_underscore_argument
 [`duration_subsec`]: https://rust-lang.github.io/rust-clippy/master/index.html#duration_subsec
+[`eager_transmute`]: https://rust-lang.github.io/rust-clippy/master/index.html#eager_transmute
 [`else_if_without_else`]: https://rust-lang.github.io/rust-clippy/master/index.html#else_if_without_else
 [`empty_drop`]: https://rust-lang.github.io/rust-clippy/master/index.html#empty_drop
 [`empty_enum`]: https://rust-lang.github.io/rust-clippy/master/index.html#empty_enum
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 38fda36c58a..fc5b8865495 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -651,6 +651,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::trait_bounds::TRAIT_DUPLICATION_IN_BOUNDS_INFO,
     crate::trait_bounds::TYPE_REPETITION_IN_BOUNDS_INFO,
     crate::transmute::CROSSPOINTER_TRANSMUTE_INFO,
+    crate::transmute::EAGER_TRANSMUTE_INFO,
     crate::transmute::TRANSMUTES_EXPRESSIBLE_AS_PTR_CASTS_INFO,
     crate::transmute::TRANSMUTE_BYTES_TO_STR_INFO,
     crate::transmute::TRANSMUTE_FLOAT_TO_INT_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 61935dc7e3c..755a4ff525d 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -22,6 +22,7 @@
 // FIXME: switch to something more ergonomic here, once available.
 // (Currently there is no way to opt into sysroot crates without `extern crate`.)
 extern crate pulldown_cmark;
+extern crate rustc_abi;
 extern crate rustc_arena;
 extern crate rustc_ast;
 extern crate rustc_ast_pretty;
diff --git a/clippy_lints/src/transmute/eager_transmute.rs b/clippy_lints/src/transmute/eager_transmute.rs
new file mode 100644
index 00000000000..01a23c515f5
--- /dev/null
+++ b/clippy_lints/src/transmute/eager_transmute.rs
@@ -0,0 +1,74 @@
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::ty::is_normalizable;
+use clippy_utils::{path_to_local, path_to_local_id};
+use rustc_abi::WrappingRange;
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind, Node};
+use rustc_lint::LateContext;
+use rustc_middle::ty::Ty;
+
+use super::EAGER_TRANSMUTE;
+
+fn peel_parent_unsafe_blocks<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> Option<&'tcx Expr<'tcx>> {
+    for (_, parent) in cx.tcx.hir().parent_iter(expr.hir_id) {
+        match parent {
+            Node::Block(_) => {},
+            Node::Expr(e) if let ExprKind::Block(..) = e.kind => {},
+            Node::Expr(e) => return Some(e),
+            _ => break,
+        }
+    }
+    None
+}
+
+fn range_fully_contained(from: WrappingRange, to: WrappingRange) -> bool {
+    to.contains(from.start) && to.contains(from.end)
+}
+
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx Expr<'tcx>,
+    transmutable: &'tcx Expr<'tcx>,
+    from_ty: Ty<'tcx>,
+    to_ty: Ty<'tcx>,
+) -> bool {
+    if let Some(then_some_call) = peel_parent_unsafe_blocks(cx, expr)
+        && let ExprKind::MethodCall(path, receiver, [arg], _) = then_some_call.kind
+        && cx.typeck_results().expr_ty(receiver).is_bool()
+        && path.ident.name == sym!(then_some)
+        && let ExprKind::Binary(_, lhs, rhs) = receiver.kind
+        && let Some(local_id) = path_to_local(transmutable)
+        && (path_to_local_id(lhs, local_id) || path_to_local_id(rhs, local_id))
+        && is_normalizable(cx, cx.param_env, from_ty)
+        && is_normalizable(cx, cx.param_env, to_ty)
+        // we only want to lint if the target type has a niche that is larger than the one of the source type
+        // e.g. `u8` to `NonZeroU8` should lint, but `NonZeroU8` to `u8` should not
+        && let Ok(from_layout) = cx.tcx.layout_of(cx.param_env.and(from_ty))
+        && let Ok(to_layout) = cx.tcx.layout_of(cx.param_env.and(to_ty))
+        && match (from_layout.largest_niche, to_layout.largest_niche) {
+            (Some(from_niche), Some(to_niche)) => !range_fully_contained(from_niche.valid_range, to_niche.valid_range),
+            (None, Some(_)) => true,
+            (_, None) => false,
+        }
+    {
+        span_lint_and_then(
+            cx,
+            EAGER_TRANSMUTE,
+            expr.span,
+            "this transmute is always evaluated eagerly, even if the condition is false",
+            |diag| {
+                diag.multipart_suggestion(
+                    "consider using `bool::then` to only transmute if the condition holds",
+                    vec![
+                        (path.ident.span, "then".into()),
+                        (arg.span.shrink_to_lo(), "|| ".into()),
+                    ],
+                    Applicability::MaybeIncorrect,
+                );
+            },
+        );
+        true
+    } else {
+        false
+    }
+}
diff --git a/clippy_lints/src/transmute/mod.rs b/clippy_lints/src/transmute/mod.rs
index 95a92afea66..06de7a11031 100644
--- a/clippy_lints/src/transmute/mod.rs
+++ b/clippy_lints/src/transmute/mod.rs
@@ -1,4 +1,5 @@
 mod crosspointer_transmute;
+mod eager_transmute;
 mod transmute_float_to_int;
 mod transmute_int_to_bool;
 mod transmute_int_to_char;
@@ -463,6 +464,62 @@ declare_clippy_lint! {
     "transmute results in a null function pointer, which is undefined behavior"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for integer validity checks, followed by a transmute that is (incorrectly) evaluated
+    /// eagerly (e.g. using `bool::then_some`).
+    ///
+    /// ### Why is this bad?
+    /// Eager evaluation means that the `transmute` call is executed regardless of whether the condition is true or false.
+    /// This can introduce unsoundness and other subtle bugs.
+    ///
+    /// ### Example
+    /// Consider the following function which is meant to convert an unsigned integer to its enum equivalent via transmute.
+    ///
+    /// ```no_run
+    /// #[repr(u8)]
+    /// enum Opcode {
+    ///     Add = 0,
+    ///     Sub = 1,
+    ///     Mul = 2,
+    ///     Div = 3
+    /// }
+    ///
+    /// fn int_to_opcode(op: u8) -> Option<Opcode> {
+    ///     (op < 4).then_some(unsafe { std::mem::transmute(op) })
+    /// }
+    /// ```
+    /// This may appear fine at first given that it checks that the `u8` is within the validity range of the enum,
+    /// *however* the transmute is evaluated eagerly, meaning that it executes even if `op >= 4`!
+    ///
+    /// This makes the function unsound, because it is possible for the caller to cause undefined behavior
+    /// (creating an enum with an invalid bitpattern) entirely in safe code only by passing an incorrect value,
+    /// which is normally only a bug that is possible in unsafe code.
+    ///
+    /// One possible way in which this can go wrong practically is that the compiler sees it as:
+    /// ```rust,ignore (illustrative)
+    /// let temp: Foo = unsafe { std::mem::transmute(op) };
+    /// (0 < 4).then_some(temp)
+    /// ```
+    /// and optimizes away the `(0 < 4)` check based on the assumption that since a `Foo` was created from `op` with the validity range `0..3`,
+    /// it is **impossible** for this condition to be false.
+    ///
+    /// In short, it is possible for this function to be optimized in a way that makes it [never return `None`](https://godbolt.org/z/ocrcenevq),
+    /// even if passed the value `4`.
+    ///
+    /// This can be avoided by instead using lazy evaluation. For the example above, this should be written:
+    /// ```rust,ignore (illustrative)
+    /// fn int_to_opcode(op: u8) -> Option<Opcode> {
+    ///     (op < 4).then(|| unsafe { std::mem::transmute(op) })
+    ///              ^^^^ ^^ `bool::then` only executes the closure if the condition is true!
+    /// }
+    /// ```
+    #[clippy::version = "1.76.0"]
+    pub EAGER_TRANSMUTE,
+    correctness,
+    "eager evaluation of `transmute`"
+}
+
 pub struct Transmute {
     msrv: Msrv,
 }
@@ -484,6 +541,7 @@ impl_lint_pass!(Transmute => [
     TRANSMUTE_UNDEFINED_REPR,
     TRANSMUTING_NULL,
     TRANSMUTE_NULL_TO_FN,
+    EAGER_TRANSMUTE,
 ]);
 impl Transmute {
     #[must_use]
@@ -530,7 +588,8 @@ impl<'tcx> LateLintPass<'tcx> for Transmute {
                 | transmute_float_to_int::check(cx, e, from_ty, to_ty, arg, const_context)
                 | transmute_num_to_bytes::check(cx, e, from_ty, to_ty, arg, const_context)
                 | (unsound_collection_transmute::check(cx, e, from_ty, to_ty)
-                    || transmute_undefined_repr::check(cx, e, from_ty, to_ty));
+                    || transmute_undefined_repr::check(cx, e, from_ty, to_ty))
+                | (eager_transmute::check(cx, e, arg, from_ty, to_ty));
 
             if !linted {
                 transmutes_expressible_as_ptr_casts::check(cx, e, from_ty, from_ty_adjusted, to_ty, arg);
diff --git a/tests/ui/eager_transmute.fixed b/tests/ui/eager_transmute.fixed
new file mode 100644
index 00000000000..e06aa2cc9fd
--- /dev/null
+++ b/tests/ui/eager_transmute.fixed
@@ -0,0 +1,72 @@
+#![feature(rustc_attrs)]
+#![warn(clippy::eager_transmute)]
+#![allow(clippy::transmute_int_to_non_zero)]
+
+use std::num::NonZeroU8;
+
+#[repr(u8)]
+enum Opcode {
+    Add = 0,
+    Sub = 1,
+    Mul = 2,
+    Div = 3,
+}
+
+fn int_to_opcode(op: u8) -> Option<Opcode> {
+    (op < 4).then(|| unsafe { std::mem::transmute(op) })
+}
+
+fn f(op: u8, unrelated: u8) {
+    true.then_some(unsafe { std::mem::transmute::<_, Opcode>(op) });
+    (unrelated < 4).then_some(unsafe { std::mem::transmute::<_, Opcode>(op) });
+    (op < 4).then(|| unsafe { std::mem::transmute::<_, Opcode>(op) });
+    (op > 4).then(|| unsafe { std::mem::transmute::<_, Opcode>(op) });
+    (op == 0).then(|| unsafe { std::mem::transmute::<_, Opcode>(op) });
+}
+
+unsafe fn f2(op: u8) {
+    (op < 4).then(|| std::mem::transmute::<_, Opcode>(op));
+}
+
+#[rustc_layout_scalar_valid_range_end(254)]
+struct NonMaxU8(u8);
+#[rustc_layout_scalar_valid_range_end(254)]
+#[rustc_layout_scalar_valid_range_start(1)]
+struct NonZeroNonMaxU8(u8);
+
+macro_rules! impls {
+    ($($t:ty),*) => {
+        $(
+            impl PartialEq<u8> for $t {
+                fn eq(&self, other: &u8) -> bool {
+                    self.0 == *other
+                }
+            }
+            impl PartialOrd<u8> for $t {
+                fn partial_cmp(&self, other: &u8) -> Option<std::cmp::Ordering> {
+                    self.0.partial_cmp(other)
+                }
+            }
+        )*
+    };
+}
+impls!(NonMaxU8, NonZeroNonMaxU8);
+
+fn niche_tests(v1: u8, v2: NonZeroU8, v3: NonZeroNonMaxU8) {
+    // u8 -> NonZeroU8, do lint
+    let _: Option<NonZeroU8> = (v1 > 0).then(|| unsafe { std::mem::transmute(v1) });
+
+    // NonZeroU8 -> u8, don't lint, target type has no niche and therefore a higher validity range
+    let _: Option<u8> = (v2 > NonZeroU8::new(1).unwrap()).then_some(unsafe { std::mem::transmute(v2) });
+
+    // NonZeroU8 -> NonMaxU8, do lint, different niche
+    let _: Option<NonMaxU8> = (v2 < NonZeroU8::new(255).unwrap()).then(|| unsafe { std::mem::transmute(v2) });
+
+    // NonZeroNonMaxU8 -> NonMaxU8, don't lint, target type has more validity
+    let _: Option<NonMaxU8> = (v3 < 255).then_some(unsafe { std::mem::transmute(v2) });
+
+    // NonZeroU8 -> NonZeroNonMaxU8, do lint, target type has less validity
+    let _: Option<NonZeroNonMaxU8> = (v2 < NonZeroU8::new(255).unwrap()).then(|| unsafe { std::mem::transmute(v2) });
+}
+
+fn main() {}
diff --git a/tests/ui/eager_transmute.rs b/tests/ui/eager_transmute.rs
new file mode 100644
index 00000000000..89ccdf583f3
--- /dev/null
+++ b/tests/ui/eager_transmute.rs
@@ -0,0 +1,72 @@
+#![feature(rustc_attrs)]
+#![warn(clippy::eager_transmute)]
+#![allow(clippy::transmute_int_to_non_zero)]
+
+use std::num::NonZeroU8;
+
+#[repr(u8)]
+enum Opcode {
+    Add = 0,
+    Sub = 1,
+    Mul = 2,
+    Div = 3,
+}
+
+fn int_to_opcode(op: u8) -> Option<Opcode> {
+    (op < 4).then_some(unsafe { std::mem::transmute(op) })
+}
+
+fn f(op: u8, unrelated: u8) {
+    true.then_some(unsafe { std::mem::transmute::<_, Opcode>(op) });
+    (unrelated < 4).then_some(unsafe { std::mem::transmute::<_, Opcode>(op) });
+    (op < 4).then_some(unsafe { std::mem::transmute::<_, Opcode>(op) });
+    (op > 4).then_some(unsafe { std::mem::transmute::<_, Opcode>(op) });
+    (op == 0).then_some(unsafe { std::mem::transmute::<_, Opcode>(op) });
+}
+
+unsafe fn f2(op: u8) {
+    (op < 4).then_some(std::mem::transmute::<_, Opcode>(op));
+}
+
+#[rustc_layout_scalar_valid_range_end(254)]
+struct NonMaxU8(u8);
+#[rustc_layout_scalar_valid_range_end(254)]
+#[rustc_layout_scalar_valid_range_start(1)]
+struct NonZeroNonMaxU8(u8);
+
+macro_rules! impls {
+    ($($t:ty),*) => {
+        $(
+            impl PartialEq<u8> for $t {
+                fn eq(&self, other: &u8) -> bool {
+                    self.0 == *other
+                }
+            }
+            impl PartialOrd<u8> for $t {
+                fn partial_cmp(&self, other: &u8) -> Option<std::cmp::Ordering> {
+                    self.0.partial_cmp(other)
+                }
+            }
+        )*
+    };
+}
+impls!(NonMaxU8, NonZeroNonMaxU8);
+
+fn niche_tests(v1: u8, v2: NonZeroU8, v3: NonZeroNonMaxU8) {
+    // u8 -> NonZeroU8, do lint
+    let _: Option<NonZeroU8> = (v1 > 0).then_some(unsafe { std::mem::transmute(v1) });
+
+    // NonZeroU8 -> u8, don't lint, target type has no niche and therefore a higher validity range
+    let _: Option<u8> = (v2 > NonZeroU8::new(1).unwrap()).then_some(unsafe { std::mem::transmute(v2) });
+
+    // NonZeroU8 -> NonMaxU8, do lint, different niche
+    let _: Option<NonMaxU8> = (v2 < NonZeroU8::new(255).unwrap()).then_some(unsafe { std::mem::transmute(v2) });
+
+    // NonZeroNonMaxU8 -> NonMaxU8, don't lint, target type has more validity
+    let _: Option<NonMaxU8> = (v3 < 255).then_some(unsafe { std::mem::transmute(v2) });
+
+    // NonZeroU8 -> NonZeroNonMaxU8, do lint, target type has less validity
+    let _: Option<NonZeroNonMaxU8> = (v2 < NonZeroU8::new(255).unwrap()).then_some(unsafe { std::mem::transmute(v2) });
+}
+
+fn main() {}
diff --git a/tests/ui/eager_transmute.stderr b/tests/ui/eager_transmute.stderr
new file mode 100644
index 00000000000..5eb163c5fcb
--- /dev/null
+++ b/tests/ui/eager_transmute.stderr
@@ -0,0 +1,92 @@
+error: this transmute is always evaluated eagerly, even if the condition is false
+  --> $DIR/eager_transmute.rs:16:33
+   |
+LL |     (op < 4).then_some(unsafe { std::mem::transmute(op) })
+   |                                 ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::eager-transmute` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::eager_transmute)]`
+help: consider using `bool::then` to only transmute if the condition holds
+   |
+LL |     (op < 4).then(|| unsafe { std::mem::transmute(op) })
+   |              ~~~~ ++
+
+error: this transmute is always evaluated eagerly, even if the condition is false
+  --> $DIR/eager_transmute.rs:22:33
+   |
+LL |     (op < 4).then_some(unsafe { std::mem::transmute::<_, Opcode>(op) });
+   |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider using `bool::then` to only transmute if the condition holds
+   |
+LL |     (op < 4).then(|| unsafe { std::mem::transmute::<_, Opcode>(op) });
+   |              ~~~~ ++
+
+error: this transmute is always evaluated eagerly, even if the condition is false
+  --> $DIR/eager_transmute.rs:23:33
+   |
+LL |     (op > 4).then_some(unsafe { std::mem::transmute::<_, Opcode>(op) });
+   |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider using `bool::then` to only transmute if the condition holds
+   |
+LL |     (op > 4).then(|| unsafe { std::mem::transmute::<_, Opcode>(op) });
+   |              ~~~~ ++
+
+error: this transmute is always evaluated eagerly, even if the condition is false
+  --> $DIR/eager_transmute.rs:24:34
+   |
+LL |     (op == 0).then_some(unsafe { std::mem::transmute::<_, Opcode>(op) });
+   |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider using `bool::then` to only transmute if the condition holds
+   |
+LL |     (op == 0).then(|| unsafe { std::mem::transmute::<_, Opcode>(op) });
+   |               ~~~~ ++
+
+error: this transmute is always evaluated eagerly, even if the condition is false
+  --> $DIR/eager_transmute.rs:28:24
+   |
+LL |     (op < 4).then_some(std::mem::transmute::<_, Opcode>(op));
+   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider using `bool::then` to only transmute if the condition holds
+   |
+LL |     (op < 4).then(|| std::mem::transmute::<_, Opcode>(op));
+   |              ~~~~ ++
+
+error: this transmute is always evaluated eagerly, even if the condition is false
+  --> $DIR/eager_transmute.rs:57:60
+   |
+LL |     let _: Option<NonZeroU8> = (v1 > 0).then_some(unsafe { std::mem::transmute(v1) });
+   |                                                            ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider using `bool::then` to only transmute if the condition holds
+   |
+LL |     let _: Option<NonZeroU8> = (v1 > 0).then(|| unsafe { std::mem::transmute(v1) });
+   |                                         ~~~~ ++
+
+error: this transmute is always evaluated eagerly, even if the condition is false
+  --> $DIR/eager_transmute.rs:63:86
+   |
+LL |     let _: Option<NonMaxU8> = (v2 < NonZeroU8::new(255).unwrap()).then_some(unsafe { std::mem::transmute(v2) });
+   |                                                                                      ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider using `bool::then` to only transmute if the condition holds
+   |
+LL |     let _: Option<NonMaxU8> = (v2 < NonZeroU8::new(255).unwrap()).then(|| unsafe { std::mem::transmute(v2) });
+   |                                                                   ~~~~ ++
+
+error: this transmute is always evaluated eagerly, even if the condition is false
+  --> $DIR/eager_transmute.rs:69:93
+   |
+LL |     let _: Option<NonZeroNonMaxU8> = (v2 < NonZeroU8::new(255).unwrap()).then_some(unsafe { std::mem::transmute(v2) });
+   |                                                                                             ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider using `bool::then` to only transmute if the condition holds
+   |
+LL |     let _: Option<NonZeroNonMaxU8> = (v2 < NonZeroU8::new(255).unwrap()).then(|| unsafe { std::mem::transmute(v2) });
+   |                                                                          ~~~~ ++
+
+error: aborting due to 8 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From ebc0588937403199daba09232d471fd6f77fef17 Mon Sep 17 00:00:00 2001
From: Florian Brucker <mail@florianbrucker.de>
Date: Wed, 27 Dec 2023 18:53:48 +0100
Subject: 6459: Check for redundant `matches!` with `Ready`, `Pending`, `V4`,
 `V6`

---
 .../src/matches/redundant_pattern_match.rs         | 42 +++++++++------------
 tests/ui/redundant_pattern_matching_ipaddr.fixed   |  6 +++
 tests/ui/redundant_pattern_matching_ipaddr.rs      |  6 +++
 tests/ui/redundant_pattern_matching_ipaddr.stderr  | 44 ++++++++++++++--------
 tests/ui/redundant_pattern_matching_poll.fixed     |  6 +++
 tests/ui/redundant_pattern_matching_poll.rs        |  6 +++
 tests/ui/redundant_pattern_matching_poll.stderr    | 44 ++++++++++++++--------
 7 files changed, 98 insertions(+), 56 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/redundant_pattern_match.rs b/clippy_lints/src/matches/redundant_pattern_match.rs
index 60331337e56..a4acdfb1db4 100644
--- a/clippy_lints/src/matches/redundant_pattern_match.rs
+++ b/clippy_lints/src/matches/redundant_pattern_match.rs
@@ -411,31 +411,25 @@ fn get_good_method<'tcx>(
     path_left: &QPath<'_>,
 ) -> Option<(&'static str, Option<&'tcx Guard<'tcx>>)> {
     if let Some(name) = get_ident(path_left) {
-        return match name.as_str() {
-            "Ok" => {
-                find_good_method_for_matches_macro(cx, arms, path_left, Item::Lang(ResultOk), "is_ok()", "is_err()")
-            },
-            "Err" => {
-                find_good_method_for_matches_macro(cx, arms, path_left, Item::Lang(ResultErr), "is_err()", "is_ok()")
-            },
-            "Some" => find_good_method_for_matches_macro(
-                cx,
-                arms,
-                path_left,
-                Item::Lang(OptionSome),
-                "is_some()",
-                "is_none()",
-            ),
-            "None" => find_good_method_for_matches_macro(
-                cx,
-                arms,
-                path_left,
-                Item::Lang(OptionNone),
-                "is_none()",
-                "is_some()",
-            ),
-            _ => None,
+        let (expected_item_left, should_be_left, should_be_right) = match name.as_str() {
+            "Ok" => (Item::Lang(ResultOk), "is_ok()", "is_err()"),
+            "Err" => (Item::Lang(ResultErr), "is_err()", "is_ok()"),
+            "Some" => (Item::Lang(OptionSome), "is_some()", "is_none()"),
+            "None" => (Item::Lang(OptionNone), "is_none()", "is_some()"),
+            "Ready" => (Item::Lang(PollReady), "is_ready()", "is_pending()"),
+            "Pending" => (Item::Lang(PollPending), "is_pending()", "is_ready()"),
+            "V4" => (Item::Diag(sym::IpAddr, sym!(V4)), "is_ipv4()", "is_ipv6()"),
+            "V6" => (Item::Diag(sym::IpAddr, sym!(V6)), "is_ipv6()", "is_ipv4()"),
+            _ => return None,
         };
+        return find_good_method_for_matches_macro(
+            cx,
+            arms,
+            path_left,
+            expected_item_left,
+            should_be_left,
+            should_be_right,
+        );
     }
     None
 }
diff --git a/tests/ui/redundant_pattern_matching_ipaddr.fixed b/tests/ui/redundant_pattern_matching_ipaddr.fixed
index 70dd9fc250f..429d33118a5 100644
--- a/tests/ui/redundant_pattern_matching_ipaddr.fixed
+++ b/tests/ui/redundant_pattern_matching_ipaddr.fixed
@@ -18,6 +18,12 @@ fn main() {
 
     if V6(Ipv6Addr::LOCALHOST).is_ipv6() {}
 
+    // Issue 6459
+    if V4(Ipv4Addr::LOCALHOST).is_ipv4() {}
+
+    // Issue 6459
+    if V6(Ipv6Addr::LOCALHOST).is_ipv6() {}
+
     while V4(Ipv4Addr::LOCALHOST).is_ipv4() {}
 
     while V6(Ipv6Addr::LOCALHOST).is_ipv6() {}
diff --git a/tests/ui/redundant_pattern_matching_ipaddr.rs b/tests/ui/redundant_pattern_matching_ipaddr.rs
index 6e2a2f7b6d2..e7136b72c20 100644
--- a/tests/ui/redundant_pattern_matching_ipaddr.rs
+++ b/tests/ui/redundant_pattern_matching_ipaddr.rs
@@ -18,6 +18,12 @@ fn main() {
 
     if let V6(_) = V6(Ipv6Addr::LOCALHOST) {}
 
+    // Issue 6459
+    if matches!(V4(Ipv4Addr::LOCALHOST), V4(_)) {}
+
+    // Issue 6459
+    if matches!(V6(Ipv6Addr::LOCALHOST), V6(_)) {}
+
     while let V4(_) = V4(Ipv4Addr::LOCALHOST) {}
 
     while let V6(_) = V6(Ipv6Addr::LOCALHOST) {}
diff --git a/tests/ui/redundant_pattern_matching_ipaddr.stderr b/tests/ui/redundant_pattern_matching_ipaddr.stderr
index d36129a2bee..54cefa5e82b 100644
--- a/tests/ui/redundant_pattern_matching_ipaddr.stderr
+++ b/tests/ui/redundant_pattern_matching_ipaddr.stderr
@@ -20,19 +20,31 @@ LL |     if let V6(_) = V6(Ipv6Addr::LOCALHOST) {}
    |     -------^^^^^-------------------------- help: try: `if V6(Ipv6Addr::LOCALHOST).is_ipv6()`
 
 error: redundant pattern matching, consider using `is_ipv4()`
-  --> $DIR/redundant_pattern_matching_ipaddr.rs:21:15
+  --> $DIR/redundant_pattern_matching_ipaddr.rs:22:8
+   |
+LL |     if matches!(V4(Ipv4Addr::LOCALHOST), V4(_)) {}
+   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `V4(Ipv4Addr::LOCALHOST).is_ipv4()`
+
+error: redundant pattern matching, consider using `is_ipv6()`
+  --> $DIR/redundant_pattern_matching_ipaddr.rs:25:8
+   |
+LL |     if matches!(V6(Ipv6Addr::LOCALHOST), V6(_)) {}
+   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `V6(Ipv6Addr::LOCALHOST).is_ipv6()`
+
+error: redundant pattern matching, consider using `is_ipv4()`
+  --> $DIR/redundant_pattern_matching_ipaddr.rs:27:15
    |
 LL |     while let V4(_) = V4(Ipv4Addr::LOCALHOST) {}
    |     ----------^^^^^-------------------------- help: try: `while V4(Ipv4Addr::LOCALHOST).is_ipv4()`
 
 error: redundant pattern matching, consider using `is_ipv6()`
-  --> $DIR/redundant_pattern_matching_ipaddr.rs:23:15
+  --> $DIR/redundant_pattern_matching_ipaddr.rs:29:15
    |
 LL |     while let V6(_) = V6(Ipv6Addr::LOCALHOST) {}
    |     ----------^^^^^-------------------------- help: try: `while V6(Ipv6Addr::LOCALHOST).is_ipv6()`
 
 error: redundant pattern matching, consider using `is_ipv4()`
-  --> $DIR/redundant_pattern_matching_ipaddr.rs:33:5
+  --> $DIR/redundant_pattern_matching_ipaddr.rs:39:5
    |
 LL | /     match V4(Ipv4Addr::LOCALHOST) {
 LL | |         V4(_) => true,
@@ -41,7 +53,7 @@ LL | |     };
    | |_____^ help: try: `V4(Ipv4Addr::LOCALHOST).is_ipv4()`
 
 error: redundant pattern matching, consider using `is_ipv6()`
-  --> $DIR/redundant_pattern_matching_ipaddr.rs:38:5
+  --> $DIR/redundant_pattern_matching_ipaddr.rs:44:5
    |
 LL | /     match V4(Ipv4Addr::LOCALHOST) {
 LL | |         V4(_) => false,
@@ -50,7 +62,7 @@ LL | |     };
    | |_____^ help: try: `V4(Ipv4Addr::LOCALHOST).is_ipv6()`
 
 error: redundant pattern matching, consider using `is_ipv6()`
-  --> $DIR/redundant_pattern_matching_ipaddr.rs:43:5
+  --> $DIR/redundant_pattern_matching_ipaddr.rs:49:5
    |
 LL | /     match V6(Ipv6Addr::LOCALHOST) {
 LL | |         V4(_) => false,
@@ -59,7 +71,7 @@ LL | |     };
    | |_____^ help: try: `V6(Ipv6Addr::LOCALHOST).is_ipv6()`
 
 error: redundant pattern matching, consider using `is_ipv4()`
-  --> $DIR/redundant_pattern_matching_ipaddr.rs:48:5
+  --> $DIR/redundant_pattern_matching_ipaddr.rs:54:5
    |
 LL | /     match V6(Ipv6Addr::LOCALHOST) {
 LL | |         V4(_) => true,
@@ -68,49 +80,49 @@ LL | |     };
    | |_____^ help: try: `V6(Ipv6Addr::LOCALHOST).is_ipv4()`
 
 error: redundant pattern matching, consider using `is_ipv4()`
-  --> $DIR/redundant_pattern_matching_ipaddr.rs:53:20
+  --> $DIR/redundant_pattern_matching_ipaddr.rs:59:20
    |
 LL |     let _ = if let V4(_) = V4(Ipv4Addr::LOCALHOST) {
    |             -------^^^^^-------------------------- help: try: `if V4(Ipv4Addr::LOCALHOST).is_ipv4()`
 
 error: redundant pattern matching, consider using `is_ipv4()`
-  --> $DIR/redundant_pattern_matching_ipaddr.rs:61:20
+  --> $DIR/redundant_pattern_matching_ipaddr.rs:67:20
    |
 LL |     let _ = if let V4(_) = gen_ipaddr() {
    |             -------^^^^^--------------- help: try: `if gen_ipaddr().is_ipv4()`
 
 error: redundant pattern matching, consider using `is_ipv6()`
-  --> $DIR/redundant_pattern_matching_ipaddr.rs:63:19
+  --> $DIR/redundant_pattern_matching_ipaddr.rs:69:19
    |
 LL |     } else if let V6(_) = gen_ipaddr() {
    |            -------^^^^^--------------- help: try: `if gen_ipaddr().is_ipv6()`
 
 error: redundant pattern matching, consider using `is_ipv4()`
-  --> $DIR/redundant_pattern_matching_ipaddr.rs:75:12
+  --> $DIR/redundant_pattern_matching_ipaddr.rs:81:12
    |
 LL |     if let V4(_) = V4(Ipv4Addr::LOCALHOST) {}
    |     -------^^^^^-------------------------- help: try: `if V4(Ipv4Addr::LOCALHOST).is_ipv4()`
 
 error: redundant pattern matching, consider using `is_ipv6()`
-  --> $DIR/redundant_pattern_matching_ipaddr.rs:77:12
+  --> $DIR/redundant_pattern_matching_ipaddr.rs:83:12
    |
 LL |     if let V6(_) = V6(Ipv6Addr::LOCALHOST) {}
    |     -------^^^^^-------------------------- help: try: `if V6(Ipv6Addr::LOCALHOST).is_ipv6()`
 
 error: redundant pattern matching, consider using `is_ipv4()`
-  --> $DIR/redundant_pattern_matching_ipaddr.rs:79:15
+  --> $DIR/redundant_pattern_matching_ipaddr.rs:85:15
    |
 LL |     while let V4(_) = V4(Ipv4Addr::LOCALHOST) {}
    |     ----------^^^^^-------------------------- help: try: `while V4(Ipv4Addr::LOCALHOST).is_ipv4()`
 
 error: redundant pattern matching, consider using `is_ipv6()`
-  --> $DIR/redundant_pattern_matching_ipaddr.rs:81:15
+  --> $DIR/redundant_pattern_matching_ipaddr.rs:87:15
    |
 LL |     while let V6(_) = V6(Ipv6Addr::LOCALHOST) {}
    |     ----------^^^^^-------------------------- help: try: `while V6(Ipv6Addr::LOCALHOST).is_ipv6()`
 
 error: redundant pattern matching, consider using `is_ipv4()`
-  --> $DIR/redundant_pattern_matching_ipaddr.rs:83:5
+  --> $DIR/redundant_pattern_matching_ipaddr.rs:89:5
    |
 LL | /     match V4(Ipv4Addr::LOCALHOST) {
 LL | |         V4(_) => true,
@@ -119,7 +131,7 @@ LL | |     };
    | |_____^ help: try: `V4(Ipv4Addr::LOCALHOST).is_ipv4()`
 
 error: redundant pattern matching, consider using `is_ipv6()`
-  --> $DIR/redundant_pattern_matching_ipaddr.rs:88:5
+  --> $DIR/redundant_pattern_matching_ipaddr.rs:94:5
    |
 LL | /     match V6(Ipv6Addr::LOCALHOST) {
 LL | |         V4(_) => false,
@@ -127,5 +139,5 @@ LL | |         V6(_) => true,
 LL | |     };
    | |_____^ help: try: `V6(Ipv6Addr::LOCALHOST).is_ipv6()`
 
-error: aborting due to 18 previous errors
+error: aborting due to 20 previous errors
 
diff --git a/tests/ui/redundant_pattern_matching_poll.fixed b/tests/ui/redundant_pattern_matching_poll.fixed
index 718c2f8ea3d..08d83f87e4c 100644
--- a/tests/ui/redundant_pattern_matching_poll.fixed
+++ b/tests/ui/redundant_pattern_matching_poll.fixed
@@ -22,6 +22,12 @@ fn main() {
         bar();
     }
 
+    // Issue 6459
+    if Ready(42).is_ready() {}
+
+    // Issue 6459
+    if Pending::<()>.is_pending() {}
+
     while Ready(42).is_ready() {}
 
     while Ready(42).is_pending() {}
diff --git a/tests/ui/redundant_pattern_matching_poll.rs b/tests/ui/redundant_pattern_matching_poll.rs
index daa4761aff5..7bc2b3be4d3 100644
--- a/tests/ui/redundant_pattern_matching_poll.rs
+++ b/tests/ui/redundant_pattern_matching_poll.rs
@@ -22,6 +22,12 @@ fn main() {
         bar();
     }
 
+    // Issue 6459
+    if matches!(Ready(42), Ready(_)) {}
+
+    // Issue 6459
+    if matches!(Pending::<()>, Pending) {}
+
     while let Ready(_) = Ready(42) {}
 
     while let Pending = Ready(42) {}
diff --git a/tests/ui/redundant_pattern_matching_poll.stderr b/tests/ui/redundant_pattern_matching_poll.stderr
index c010c3c4437..de64331b4e8 100644
--- a/tests/ui/redundant_pattern_matching_poll.stderr
+++ b/tests/ui/redundant_pattern_matching_poll.stderr
@@ -20,25 +20,37 @@ LL |     if let Ready(_) = Ready(42) {
    |     -------^^^^^^^^------------ help: try: `if Ready(42).is_ready()`
 
 error: redundant pattern matching, consider using `is_ready()`
-  --> $DIR/redundant_pattern_matching_poll.rs:25:15
+  --> $DIR/redundant_pattern_matching_poll.rs:26:8
+   |
+LL |     if matches!(Ready(42), Ready(_)) {}
+   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Ready(42).is_ready()`
+
+error: redundant pattern matching, consider using `is_pending()`
+  --> $DIR/redundant_pattern_matching_poll.rs:29:8
+   |
+LL |     if matches!(Pending::<()>, Pending) {}
+   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Pending::<()>.is_pending()`
+
+error: redundant pattern matching, consider using `is_ready()`
+  --> $DIR/redundant_pattern_matching_poll.rs:31:15
    |
 LL |     while let Ready(_) = Ready(42) {}
    |     ----------^^^^^^^^------------ help: try: `while Ready(42).is_ready()`
 
 error: redundant pattern matching, consider using `is_pending()`
-  --> $DIR/redundant_pattern_matching_poll.rs:27:15
+  --> $DIR/redundant_pattern_matching_poll.rs:33:15
    |
 LL |     while let Pending = Ready(42) {}
    |     ----------^^^^^^^------------ help: try: `while Ready(42).is_pending()`
 
 error: redundant pattern matching, consider using `is_pending()`
-  --> $DIR/redundant_pattern_matching_poll.rs:29:15
+  --> $DIR/redundant_pattern_matching_poll.rs:35:15
    |
 LL |     while let Pending = Pending::<()> {}
    |     ----------^^^^^^^---------------- help: try: `while Pending::<()>.is_pending()`
 
 error: redundant pattern matching, consider using `is_ready()`
-  --> $DIR/redundant_pattern_matching_poll.rs:35:5
+  --> $DIR/redundant_pattern_matching_poll.rs:41:5
    |
 LL | /     match Ready(42) {
 LL | |         Ready(_) => true,
@@ -47,7 +59,7 @@ LL | |     };
    | |_____^ help: try: `Ready(42).is_ready()`
 
 error: redundant pattern matching, consider using `is_pending()`
-  --> $DIR/redundant_pattern_matching_poll.rs:40:5
+  --> $DIR/redundant_pattern_matching_poll.rs:46:5
    |
 LL | /     match Pending::<()> {
 LL | |         Ready(_) => false,
@@ -56,7 +68,7 @@ LL | |     };
    | |_____^ help: try: `Pending::<()>.is_pending()`
 
 error: redundant pattern matching, consider using `is_pending()`
-  --> $DIR/redundant_pattern_matching_poll.rs:45:13
+  --> $DIR/redundant_pattern_matching_poll.rs:51:13
    |
 LL |       let _ = match Pending::<()> {
    |  _____________^
@@ -66,49 +78,49 @@ LL | |     };
    | |_____^ help: try: `Pending::<()>.is_pending()`
 
 error: redundant pattern matching, consider using `is_ready()`
-  --> $DIR/redundant_pattern_matching_poll.rs:51:20
+  --> $DIR/redundant_pattern_matching_poll.rs:57:20
    |
 LL |     let _ = if let Ready(_) = poll { true } else { false };
    |             -------^^^^^^^^------- help: try: `if poll.is_ready()`
 
 error: redundant pattern matching, consider using `is_ready()`
-  --> $DIR/redundant_pattern_matching_poll.rs:55:20
+  --> $DIR/redundant_pattern_matching_poll.rs:61:20
    |
 LL |     let _ = if let Ready(_) = gen_poll() {
    |             -------^^^^^^^^------------- help: try: `if gen_poll().is_ready()`
 
 error: redundant pattern matching, consider using `is_pending()`
-  --> $DIR/redundant_pattern_matching_poll.rs:57:19
+  --> $DIR/redundant_pattern_matching_poll.rs:63:19
    |
 LL |     } else if let Pending = gen_poll() {
    |            -------^^^^^^^------------- help: try: `if gen_poll().is_pending()`
 
 error: redundant pattern matching, consider using `is_ready()`
-  --> $DIR/redundant_pattern_matching_poll.rs:73:12
+  --> $DIR/redundant_pattern_matching_poll.rs:79:12
    |
 LL |     if let Ready(_) = Ready(42) {}
    |     -------^^^^^^^^------------ help: try: `if Ready(42).is_ready()`
 
 error: redundant pattern matching, consider using `is_pending()`
-  --> $DIR/redundant_pattern_matching_poll.rs:75:12
+  --> $DIR/redundant_pattern_matching_poll.rs:81:12
    |
 LL |     if let Pending = Pending::<()> {}
    |     -------^^^^^^^---------------- help: try: `if Pending::<()>.is_pending()`
 
 error: redundant pattern matching, consider using `is_ready()`
-  --> $DIR/redundant_pattern_matching_poll.rs:77:15
+  --> $DIR/redundant_pattern_matching_poll.rs:83:15
    |
 LL |     while let Ready(_) = Ready(42) {}
    |     ----------^^^^^^^^------------ help: try: `while Ready(42).is_ready()`
 
 error: redundant pattern matching, consider using `is_pending()`
-  --> $DIR/redundant_pattern_matching_poll.rs:79:15
+  --> $DIR/redundant_pattern_matching_poll.rs:85:15
    |
 LL |     while let Pending = Pending::<()> {}
    |     ----------^^^^^^^---------------- help: try: `while Pending::<()>.is_pending()`
 
 error: redundant pattern matching, consider using `is_ready()`
-  --> $DIR/redundant_pattern_matching_poll.rs:81:5
+  --> $DIR/redundant_pattern_matching_poll.rs:87:5
    |
 LL | /     match Ready(42) {
 LL | |         Ready(_) => true,
@@ -117,7 +129,7 @@ LL | |     };
    | |_____^ help: try: `Ready(42).is_ready()`
 
 error: redundant pattern matching, consider using `is_pending()`
-  --> $DIR/redundant_pattern_matching_poll.rs:86:5
+  --> $DIR/redundant_pattern_matching_poll.rs:92:5
    |
 LL | /     match Pending::<()> {
 LL | |         Ready(_) => false,
@@ -125,5 +137,5 @@ LL | |         Pending => true,
 LL | |     };
    | |_____^ help: try: `Pending::<()>.is_pending()`
 
-error: aborting due to 18 previous errors
+error: aborting due to 20 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From e5c9fb68279322000536166a4a82a754904e52f7 Mon Sep 17 00:00:00 2001
From: Florian Brucker <mail@florianbrucker.de>
Date: Wed, 27 Dec 2023 22:15:17 +0100
Subject: 11973: Don't escape `"` in `'"'`

---
 clippy_lints/src/methods/utils.rs   |  1 +
 tests/ui/single_char_pattern.fixed  |  2 ++
 tests/ui/single_char_pattern.rs     |  2 ++
 tests/ui/single_char_pattern.stderr | 26 ++++++++++++++++----------
 4 files changed, 21 insertions(+), 10 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/utils.rs b/clippy_lints/src/methods/utils.rs
index 9ad4250a141..3a0305b4d55 100644
--- a/clippy_lints/src/methods/utils.rs
+++ b/clippy_lints/src/methods/utils.rs
@@ -74,6 +74,7 @@ pub(super) fn get_hint_if_single_char_arg(
             match ch {
                 "'" => "\\'",
                 r"\" => "\\\\",
+                "\\\"" => "\"", // no need to escape `"` in `'"'`
                 _ => ch,
             }
         );
diff --git a/tests/ui/single_char_pattern.fixed b/tests/ui/single_char_pattern.fixed
index 79e7eda4070..9573fdbcfde 100644
--- a/tests/ui/single_char_pattern.fixed
+++ b/tests/ui/single_char_pattern.fixed
@@ -42,6 +42,8 @@ fn main() {
     x.split('\n');
     x.split('\'');
     x.split('\'');
+    // Issue #11973: Don't escape `"` in `'"'`
+    x.split('"');
 
     let h = HashSet::<String>::new();
     h.contains("X"); // should not warn
diff --git a/tests/ui/single_char_pattern.rs b/tests/ui/single_char_pattern.rs
index 81962c0a6e9..8a04480dbc6 100644
--- a/tests/ui/single_char_pattern.rs
+++ b/tests/ui/single_char_pattern.rs
@@ -42,6 +42,8 @@ fn main() {
     x.split("\n");
     x.split("'");
     x.split("\'");
+    // Issue #11973: Don't escape `"` in `'"'`
+    x.split("\"");
 
     let h = HashSet::<String>::new();
     h.contains("X"); // should not warn
diff --git a/tests/ui/single_char_pattern.stderr b/tests/ui/single_char_pattern.stderr
index 6e57ab3489f..781ab316d9d 100644
--- a/tests/ui/single_char_pattern.stderr
+++ b/tests/ui/single_char_pattern.stderr
@@ -182,58 +182,64 @@ LL |     x.split("\'");
    |             ^^^^ help: try using a `char` instead: `'\''`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:49:31
+  --> $DIR/single_char_pattern.rs:46:13
+   |
+LL |     x.split("\"");
+   |             ^^^^ help: try using a `char` instead: `'"'`
+
+error: single-character string constant used as pattern
+  --> $DIR/single_char_pattern.rs:51:31
    |
 LL |     x.replace(';', ",").split(","); // issue #2978
    |                               ^^^ help: try using a `char` instead: `','`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:50:19
+  --> $DIR/single_char_pattern.rs:52:19
    |
 LL |     x.starts_with("\x03"); // issue #2996
    |                   ^^^^^^ help: try using a `char` instead: `'\x03'`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:57:13
+  --> $DIR/single_char_pattern.rs:59:13
    |
 LL |     x.split(r"a");
    |             ^^^^ help: try using a `char` instead: `'a'`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:58:13
+  --> $DIR/single_char_pattern.rs:60:13
    |
 LL |     x.split(r#"a"#);
    |             ^^^^^^ help: try using a `char` instead: `'a'`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:59:13
+  --> $DIR/single_char_pattern.rs:61:13
    |
 LL |     x.split(r###"a"###);
    |             ^^^^^^^^^^ help: try using a `char` instead: `'a'`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:60:13
+  --> $DIR/single_char_pattern.rs:62:13
    |
 LL |     x.split(r###"'"###);
    |             ^^^^^^^^^^ help: try using a `char` instead: `'\''`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:61:13
+  --> $DIR/single_char_pattern.rs:63:13
    |
 LL |     x.split(r###"#"###);
    |             ^^^^^^^^^^ help: try using a `char` instead: `'#'`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:63:13
+  --> $DIR/single_char_pattern.rs:65:13
    |
 LL |     x.split(r#"\"#);
    |             ^^^^^^ help: try using a `char` instead: `'\\'`
 
 error: single-character string constant used as pattern
-  --> $DIR/single_char_pattern.rs:64:13
+  --> $DIR/single_char_pattern.rs:66:13
    |
 LL |     x.split(r"\");
    |             ^^^^ help: try using a `char` instead: `'\\'`
 
-error: aborting due to 39 previous errors
+error: aborting due to 40 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From affde93041299c195649ca2c076bafb744b55c7e Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Wed, 27 Dec 2023 23:38:20 +0100
Subject: lint on nested binary operations involving local and handle
 projections

---
 clippy_lints/src/transmute/eager_transmute.rs | 37 ++++++++++++++++---
 tests/ui/eager_transmute.fixed                | 22 +++++++++++-
 tests/ui/eager_transmute.rs                   | 22 +++++++++++-
 tests/ui/eager_transmute.stderr               | 51 ++++++++++++++++++++++-----
 4 files changed, 117 insertions(+), 15 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/transmute/eager_transmute.rs b/clippy_lints/src/transmute/eager_transmute.rs
index 01a23c515f5..7539b6af385 100644
--- a/clippy_lints/src/transmute/eager_transmute.rs
+++ b/clippy_lints/src/transmute/eager_transmute.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::ty::is_normalizable;
-use clippy_utils::{path_to_local, path_to_local_id};
+use clippy_utils::{eq_expr_value, path_to_local};
 use rustc_abi::WrappingRange;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, Node};
@@ -25,6 +25,36 @@ fn range_fully_contained(from: WrappingRange, to: WrappingRange) -> bool {
     to.contains(from.start) && to.contains(from.end)
 }
 
+/// Checks if a given expression is a binary operation involving a local variable or is made up of
+/// other (nested) binary expressions involving the local. There must be at least one local
+/// reference that is the same as `local_expr`.
+///
+/// This is used as a heuristic to detect if a variable
+/// is checked to be within the valid range of a transmuted type.
+/// All of these would return true:
+/// * `x < 4`
+/// * `x < 4 && x > 1`
+/// * `x.field < 4 && x.field > 1` (given `x.field`)
+/// * `x.field < 4 && unrelated()`
+fn binops_with_local(cx: &LateContext<'_>, local_expr: &Expr<'_>, expr: &Expr<'_>) -> bool {
+    match expr.kind {
+        ExprKind::Binary(_, lhs, rhs) => {
+            binops_with_local(cx, local_expr, lhs) || binops_with_local(cx, local_expr, rhs)
+        },
+        _ => eq_expr_value(cx, local_expr, expr),
+    }
+}
+
+/// Checks if an expression is a path to a local variable (with optional projections), e.g.
+/// `x.field[0].field2` would return true.
+fn is_local_with_projections(expr: &Expr<'_>) -> bool {
+    match expr.kind {
+        ExprKind::Path(_) => path_to_local(expr).is_some(),
+        ExprKind::Field(expr, _) | ExprKind::Index(expr, ..) => is_local_with_projections(expr),
+        _ => false,
+    }
+}
+
 pub(super) fn check<'tcx>(
     cx: &LateContext<'tcx>,
     expr: &'tcx Expr<'tcx>,
@@ -36,9 +66,8 @@ pub(super) fn check<'tcx>(
         && let ExprKind::MethodCall(path, receiver, [arg], _) = then_some_call.kind
         && cx.typeck_results().expr_ty(receiver).is_bool()
         && path.ident.name == sym!(then_some)
-        && let ExprKind::Binary(_, lhs, rhs) = receiver.kind
-        && let Some(local_id) = path_to_local(transmutable)
-        && (path_to_local_id(lhs, local_id) || path_to_local_id(rhs, local_id))
+        && is_local_with_projections(transmutable)
+        && binops_with_local(cx, transmutable, receiver)
         && is_normalizable(cx, cx.param_env, from_ty)
         && is_normalizable(cx, cx.param_env, to_ty)
         // we only want to lint if the target type has a niche that is larger than the one of the source type
diff --git a/tests/ui/eager_transmute.fixed b/tests/ui/eager_transmute.fixed
index e06aa2cc9fd..58c6ee914c6 100644
--- a/tests/ui/eager_transmute.fixed
+++ b/tests/ui/eager_transmute.fixed
@@ -12,16 +12,36 @@ enum Opcode {
     Div = 3,
 }
 
+struct Data {
+    foo: &'static [u8],
+    bar: &'static [u8],
+}
+
 fn int_to_opcode(op: u8) -> Option<Opcode> {
     (op < 4).then(|| unsafe { std::mem::transmute(op) })
 }
 
-fn f(op: u8, unrelated: u8) {
+fn f(op: u8, op2: Data, unrelated: u8) {
     true.then_some(unsafe { std::mem::transmute::<_, Opcode>(op) });
     (unrelated < 4).then_some(unsafe { std::mem::transmute::<_, Opcode>(op) });
     (op < 4).then(|| unsafe { std::mem::transmute::<_, Opcode>(op) });
     (op > 4).then(|| unsafe { std::mem::transmute::<_, Opcode>(op) });
     (op == 0).then(|| unsafe { std::mem::transmute::<_, Opcode>(op) });
+
+    let _: Option<Opcode> = (op > 0 && op < 10).then(|| unsafe { std::mem::transmute(op) });
+    let _: Option<Opcode> = (op > 0 && op < 10 && unrelated == 0).then(|| unsafe { std::mem::transmute(op) });
+
+    // lint even when the transmutable goes through field/array accesses
+    let _: Option<Opcode> = (op2.foo[0] > 0 && op2.foo[0] < 10).then(|| unsafe { std::mem::transmute(op2.foo[0]) });
+
+    // don't lint: wrong index used in the transmute
+    let _: Option<Opcode> = (op2.foo[0] > 0 && op2.foo[0] < 10).then_some(unsafe { std::mem::transmute(op2.foo[1]) });
+
+    // don't lint: no check for the transmutable in the condition
+    let _: Option<Opcode> = (op2.foo[0] > 0 && op2.bar[1] < 10).then_some(unsafe { std::mem::transmute(op2.bar[0]) });
+
+    // don't lint: wrong variable
+    let _: Option<Opcode> = (op2.foo[0] > 0 && op2.bar[1] < 10).then_some(unsafe { std::mem::transmute(op) });
 }
 
 unsafe fn f2(op: u8) {
diff --git a/tests/ui/eager_transmute.rs b/tests/ui/eager_transmute.rs
index 89ccdf583f3..2af311d6c51 100644
--- a/tests/ui/eager_transmute.rs
+++ b/tests/ui/eager_transmute.rs
@@ -12,16 +12,36 @@ enum Opcode {
     Div = 3,
 }
 
+struct Data {
+    foo: &'static [u8],
+    bar: &'static [u8],
+}
+
 fn int_to_opcode(op: u8) -> Option<Opcode> {
     (op < 4).then_some(unsafe { std::mem::transmute(op) })
 }
 
-fn f(op: u8, unrelated: u8) {
+fn f(op: u8, op2: Data, unrelated: u8) {
     true.then_some(unsafe { std::mem::transmute::<_, Opcode>(op) });
     (unrelated < 4).then_some(unsafe { std::mem::transmute::<_, Opcode>(op) });
     (op < 4).then_some(unsafe { std::mem::transmute::<_, Opcode>(op) });
     (op > 4).then_some(unsafe { std::mem::transmute::<_, Opcode>(op) });
     (op == 0).then_some(unsafe { std::mem::transmute::<_, Opcode>(op) });
+
+    let _: Option<Opcode> = (op > 0 && op < 10).then_some(unsafe { std::mem::transmute(op) });
+    let _: Option<Opcode> = (op > 0 && op < 10 && unrelated == 0).then_some(unsafe { std::mem::transmute(op) });
+
+    // lint even when the transmutable goes through field/array accesses
+    let _: Option<Opcode> = (op2.foo[0] > 0 && op2.foo[0] < 10).then_some(unsafe { std::mem::transmute(op2.foo[0]) });
+
+    // don't lint: wrong index used in the transmute
+    let _: Option<Opcode> = (op2.foo[0] > 0 && op2.foo[0] < 10).then_some(unsafe { std::mem::transmute(op2.foo[1]) });
+
+    // don't lint: no check for the transmutable in the condition
+    let _: Option<Opcode> = (op2.foo[0] > 0 && op2.bar[1] < 10).then_some(unsafe { std::mem::transmute(op2.bar[0]) });
+
+    // don't lint: wrong variable
+    let _: Option<Opcode> = (op2.foo[0] > 0 && op2.bar[1] < 10).then_some(unsafe { std::mem::transmute(op) });
 }
 
 unsafe fn f2(op: u8) {
diff --git a/tests/ui/eager_transmute.stderr b/tests/ui/eager_transmute.stderr
index 5eb163c5fcb..65dd6815c3a 100644
--- a/tests/ui/eager_transmute.stderr
+++ b/tests/ui/eager_transmute.stderr
@@ -1,5 +1,5 @@
 error: this transmute is always evaluated eagerly, even if the condition is false
-  --> $DIR/eager_transmute.rs:16:33
+  --> $DIR/eager_transmute.rs:21:33
    |
 LL |     (op < 4).then_some(unsafe { std::mem::transmute(op) })
    |                                 ^^^^^^^^^^^^^^^^^^^^^^^
@@ -12,7 +12,7 @@ LL |     (op < 4).then(|| unsafe { std::mem::transmute(op) })
    |              ~~~~ ++
 
 error: this transmute is always evaluated eagerly, even if the condition is false
-  --> $DIR/eager_transmute.rs:22:33
+  --> $DIR/eager_transmute.rs:27:33
    |
 LL |     (op < 4).then_some(unsafe { std::mem::transmute::<_, Opcode>(op) });
    |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -23,7 +23,7 @@ LL |     (op < 4).then(|| unsafe { std::mem::transmute::<_, Opcode>(op) });
    |              ~~~~ ++
 
 error: this transmute is always evaluated eagerly, even if the condition is false
-  --> $DIR/eager_transmute.rs:23:33
+  --> $DIR/eager_transmute.rs:28:33
    |
 LL |     (op > 4).then_some(unsafe { std::mem::transmute::<_, Opcode>(op) });
    |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -34,7 +34,7 @@ LL |     (op > 4).then(|| unsafe { std::mem::transmute::<_, Opcode>(op) });
    |              ~~~~ ++
 
 error: this transmute is always evaluated eagerly, even if the condition is false
-  --> $DIR/eager_transmute.rs:24:34
+  --> $DIR/eager_transmute.rs:29:34
    |
 LL |     (op == 0).then_some(unsafe { std::mem::transmute::<_, Opcode>(op) });
    |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -45,7 +45,40 @@ LL |     (op == 0).then(|| unsafe { std::mem::transmute::<_, Opcode>(op) });
    |               ~~~~ ++
 
 error: this transmute is always evaluated eagerly, even if the condition is false
-  --> $DIR/eager_transmute.rs:28:24
+  --> $DIR/eager_transmute.rs:31:68
+   |
+LL |     let _: Option<Opcode> = (op > 0 && op < 10).then_some(unsafe { std::mem::transmute(op) });
+   |                                                                    ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider using `bool::then` to only transmute if the condition holds
+   |
+LL |     let _: Option<Opcode> = (op > 0 && op < 10).then(|| unsafe { std::mem::transmute(op) });
+   |                                                 ~~~~ ++
+
+error: this transmute is always evaluated eagerly, even if the condition is false
+  --> $DIR/eager_transmute.rs:32:86
+   |
+LL |     let _: Option<Opcode> = (op > 0 && op < 10 && unrelated == 0).then_some(unsafe { std::mem::transmute(op) });
+   |                                                                                      ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider using `bool::then` to only transmute if the condition holds
+   |
+LL |     let _: Option<Opcode> = (op > 0 && op < 10 && unrelated == 0).then(|| unsafe { std::mem::transmute(op) });
+   |                                                                   ~~~~ ++
+
+error: this transmute is always evaluated eagerly, even if the condition is false
+  --> $DIR/eager_transmute.rs:35:84
+   |
+LL |     let _: Option<Opcode> = (op2.foo[0] > 0 && op2.foo[0] < 10).then_some(unsafe { std::mem::transmute(op2.foo[0]) });
+   |                                                                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider using `bool::then` to only transmute if the condition holds
+   |
+LL |     let _: Option<Opcode> = (op2.foo[0] > 0 && op2.foo[0] < 10).then(|| unsafe { std::mem::transmute(op2.foo[0]) });
+   |                                                                 ~~~~ ++
+
+error: this transmute is always evaluated eagerly, even if the condition is false
+  --> $DIR/eager_transmute.rs:48:24
    |
 LL |     (op < 4).then_some(std::mem::transmute::<_, Opcode>(op));
    |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -56,7 +89,7 @@ LL |     (op < 4).then(|| std::mem::transmute::<_, Opcode>(op));
    |              ~~~~ ++
 
 error: this transmute is always evaluated eagerly, even if the condition is false
-  --> $DIR/eager_transmute.rs:57:60
+  --> $DIR/eager_transmute.rs:77:60
    |
 LL |     let _: Option<NonZeroU8> = (v1 > 0).then_some(unsafe { std::mem::transmute(v1) });
    |                                                            ^^^^^^^^^^^^^^^^^^^^^^^
@@ -67,7 +100,7 @@ LL |     let _: Option<NonZeroU8> = (v1 > 0).then(|| unsafe { std::mem::transmut
    |                                         ~~~~ ++
 
 error: this transmute is always evaluated eagerly, even if the condition is false
-  --> $DIR/eager_transmute.rs:63:86
+  --> $DIR/eager_transmute.rs:83:86
    |
 LL |     let _: Option<NonMaxU8> = (v2 < NonZeroU8::new(255).unwrap()).then_some(unsafe { std::mem::transmute(v2) });
    |                                                                                      ^^^^^^^^^^^^^^^^^^^^^^^
@@ -78,7 +111,7 @@ LL |     let _: Option<NonMaxU8> = (v2 < NonZeroU8::new(255).unwrap()).then(|| u
    |                                                                   ~~~~ ++
 
 error: this transmute is always evaluated eagerly, even if the condition is false
-  --> $DIR/eager_transmute.rs:69:93
+  --> $DIR/eager_transmute.rs:89:93
    |
 LL |     let _: Option<NonZeroNonMaxU8> = (v2 < NonZeroU8::new(255).unwrap()).then_some(unsafe { std::mem::transmute(v2) });
    |                                                                                             ^^^^^^^^^^^^^^^^^^^^^^^
@@ -88,5 +121,5 @@ help: consider using `bool::then` to only transmute if the condition holds
 LL |     let _: Option<NonZeroNonMaxU8> = (v2 < NonZeroU8::new(255).unwrap()).then(|| unsafe { std::mem::transmute(v2) });
    |                                                                          ~~~~ ++
 
-error: aborting due to 8 previous errors
+error: aborting due to 11 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 6c28f0765ea6e7c819292e1ed800895aac9f00ae Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Thu, 28 Dec 2023 05:27:56 +0100
Subject: recognize `contains` calls on ranges

---
 clippy_lints/src/transmute/eager_transmute.rs | 16 ++++++
 tests/ui/eager_transmute.fixed                | 13 +++++
 tests/ui/eager_transmute.rs                   | 13 +++++
 tests/ui/eager_transmute.stderr               | 76 +++++++++++++++++++++++++--
 4 files changed, 113 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/transmute/eager_transmute.rs b/clippy_lints/src/transmute/eager_transmute.rs
index 7539b6af385..c44f5150dd1 100644
--- a/clippy_lints/src/transmute/eager_transmute.rs
+++ b/clippy_lints/src/transmute/eager_transmute.rs
@@ -36,11 +36,27 @@ fn range_fully_contained(from: WrappingRange, to: WrappingRange) -> bool {
 /// * `x < 4 && x > 1`
 /// * `x.field < 4 && x.field > 1` (given `x.field`)
 /// * `x.field < 4 && unrelated()`
+/// * `(1..=3).contains(&x)`
 fn binops_with_local(cx: &LateContext<'_>, local_expr: &Expr<'_>, expr: &Expr<'_>) -> bool {
     match expr.kind {
         ExprKind::Binary(_, lhs, rhs) => {
             binops_with_local(cx, local_expr, lhs) || binops_with_local(cx, local_expr, rhs)
         },
+        ExprKind::MethodCall(path, receiver, [arg], _)
+            if path.ident.name == sym!(contains)
+                // ... `contains` called on some kind of range
+                && let Some(receiver_adt) = cx.typeck_results().expr_ty(receiver).peel_refs().ty_adt_def()
+                && let lang_items = cx.tcx.lang_items()
+                && [
+                    lang_items.range_from_struct(),
+                    lang_items.range_inclusive_struct(),
+                    lang_items.range_struct(),
+                    lang_items.range_to_inclusive_struct(),
+                    lang_items.range_to_struct()
+                ].into_iter().any(|did| did == Some(receiver_adt.did())) =>
+        {
+            eq_expr_value(cx, local_expr, arg.peel_borrows())
+        },
         _ => eq_expr_value(cx, local_expr, expr),
     }
 }
diff --git a/tests/ui/eager_transmute.fixed b/tests/ui/eager_transmute.fixed
index 58c6ee914c6..bece09bba1a 100644
--- a/tests/ui/eager_transmute.fixed
+++ b/tests/ui/eager_transmute.fixed
@@ -42,6 +42,19 @@ fn f(op: u8, op2: Data, unrelated: u8) {
 
     // don't lint: wrong variable
     let _: Option<Opcode> = (op2.foo[0] > 0 && op2.bar[1] < 10).then_some(unsafe { std::mem::transmute(op) });
+
+    // range contains checks
+    let _: Option<Opcode> = (1..=3).contains(&op).then(|| unsafe { std::mem::transmute(op) });
+    let _: Option<Opcode> = ((1..=3).contains(&op) || op == 4).then(|| unsafe { std::mem::transmute(op) });
+    let _: Option<Opcode> = (1..3).contains(&op).then(|| unsafe { std::mem::transmute(op) });
+    let _: Option<Opcode> = (1..).contains(&op).then(|| unsafe { std::mem::transmute(op) });
+    let _: Option<Opcode> = (..3).contains(&op).then(|| unsafe { std::mem::transmute(op) });
+    let _: Option<Opcode> = (..=3).contains(&op).then(|| unsafe { std::mem::transmute(op) });
+
+    // unrelated binding in contains
+    let _: Option<Opcode> = (1..=3)
+        .contains(&unrelated)
+        .then_some(unsafe { std::mem::transmute(op) });
 }
 
 unsafe fn f2(op: u8) {
diff --git a/tests/ui/eager_transmute.rs b/tests/ui/eager_transmute.rs
index 2af311d6c51..a82bd578f76 100644
--- a/tests/ui/eager_transmute.rs
+++ b/tests/ui/eager_transmute.rs
@@ -42,6 +42,19 @@ fn f(op: u8, op2: Data, unrelated: u8) {
 
     // don't lint: wrong variable
     let _: Option<Opcode> = (op2.foo[0] > 0 && op2.bar[1] < 10).then_some(unsafe { std::mem::transmute(op) });
+
+    // range contains checks
+    let _: Option<Opcode> = (1..=3).contains(&op).then_some(unsafe { std::mem::transmute(op) });
+    let _: Option<Opcode> = ((1..=3).contains(&op) || op == 4).then_some(unsafe { std::mem::transmute(op) });
+    let _: Option<Opcode> = (1..3).contains(&op).then_some(unsafe { std::mem::transmute(op) });
+    let _: Option<Opcode> = (1..).contains(&op).then_some(unsafe { std::mem::transmute(op) });
+    let _: Option<Opcode> = (..3).contains(&op).then_some(unsafe { std::mem::transmute(op) });
+    let _: Option<Opcode> = (..=3).contains(&op).then_some(unsafe { std::mem::transmute(op) });
+
+    // unrelated binding in contains
+    let _: Option<Opcode> = (1..=3)
+        .contains(&unrelated)
+        .then_some(unsafe { std::mem::transmute(op) });
 }
 
 unsafe fn f2(op: u8) {
diff --git a/tests/ui/eager_transmute.stderr b/tests/ui/eager_transmute.stderr
index 65dd6815c3a..5f42eec544f 100644
--- a/tests/ui/eager_transmute.stderr
+++ b/tests/ui/eager_transmute.stderr
@@ -78,7 +78,73 @@ LL |     let _: Option<Opcode> = (op2.foo[0] > 0 && op2.foo[0] < 10).then(|| uns
    |                                                                 ~~~~ ++
 
 error: this transmute is always evaluated eagerly, even if the condition is false
-  --> $DIR/eager_transmute.rs:48:24
+  --> $DIR/eager_transmute.rs:47:70
+   |
+LL |     let _: Option<Opcode> = (1..=3).contains(&op).then_some(unsafe { std::mem::transmute(op) });
+   |                                                                      ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider using `bool::then` to only transmute if the condition holds
+   |
+LL |     let _: Option<Opcode> = (1..=3).contains(&op).then(|| unsafe { std::mem::transmute(op) });
+   |                                                   ~~~~ ++
+
+error: this transmute is always evaluated eagerly, even if the condition is false
+  --> $DIR/eager_transmute.rs:48:83
+   |
+LL |     let _: Option<Opcode> = ((1..=3).contains(&op) || op == 4).then_some(unsafe { std::mem::transmute(op) });
+   |                                                                                   ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider using `bool::then` to only transmute if the condition holds
+   |
+LL |     let _: Option<Opcode> = ((1..=3).contains(&op) || op == 4).then(|| unsafe { std::mem::transmute(op) });
+   |                                                                ~~~~ ++
+
+error: this transmute is always evaluated eagerly, even if the condition is false
+  --> $DIR/eager_transmute.rs:49:69
+   |
+LL |     let _: Option<Opcode> = (1..3).contains(&op).then_some(unsafe { std::mem::transmute(op) });
+   |                                                                     ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider using `bool::then` to only transmute if the condition holds
+   |
+LL |     let _: Option<Opcode> = (1..3).contains(&op).then(|| unsafe { std::mem::transmute(op) });
+   |                                                  ~~~~ ++
+
+error: this transmute is always evaluated eagerly, even if the condition is false
+  --> $DIR/eager_transmute.rs:50:68
+   |
+LL |     let _: Option<Opcode> = (1..).contains(&op).then_some(unsafe { std::mem::transmute(op) });
+   |                                                                    ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider using `bool::then` to only transmute if the condition holds
+   |
+LL |     let _: Option<Opcode> = (1..).contains(&op).then(|| unsafe { std::mem::transmute(op) });
+   |                                                 ~~~~ ++
+
+error: this transmute is always evaluated eagerly, even if the condition is false
+  --> $DIR/eager_transmute.rs:51:68
+   |
+LL |     let _: Option<Opcode> = (..3).contains(&op).then_some(unsafe { std::mem::transmute(op) });
+   |                                                                    ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider using `bool::then` to only transmute if the condition holds
+   |
+LL |     let _: Option<Opcode> = (..3).contains(&op).then(|| unsafe { std::mem::transmute(op) });
+   |                                                 ~~~~ ++
+
+error: this transmute is always evaluated eagerly, even if the condition is false
+  --> $DIR/eager_transmute.rs:52:69
+   |
+LL |     let _: Option<Opcode> = (..=3).contains(&op).then_some(unsafe { std::mem::transmute(op) });
+   |                                                                     ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider using `bool::then` to only transmute if the condition holds
+   |
+LL |     let _: Option<Opcode> = (..=3).contains(&op).then(|| unsafe { std::mem::transmute(op) });
+   |                                                  ~~~~ ++
+
+error: this transmute is always evaluated eagerly, even if the condition is false
+  --> $DIR/eager_transmute.rs:61:24
    |
 LL |     (op < 4).then_some(std::mem::transmute::<_, Opcode>(op));
    |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -89,7 +155,7 @@ LL |     (op < 4).then(|| std::mem::transmute::<_, Opcode>(op));
    |              ~~~~ ++
 
 error: this transmute is always evaluated eagerly, even if the condition is false
-  --> $DIR/eager_transmute.rs:77:60
+  --> $DIR/eager_transmute.rs:90:60
    |
 LL |     let _: Option<NonZeroU8> = (v1 > 0).then_some(unsafe { std::mem::transmute(v1) });
    |                                                            ^^^^^^^^^^^^^^^^^^^^^^^
@@ -100,7 +166,7 @@ LL |     let _: Option<NonZeroU8> = (v1 > 0).then(|| unsafe { std::mem::transmut
    |                                         ~~~~ ++
 
 error: this transmute is always evaluated eagerly, even if the condition is false
-  --> $DIR/eager_transmute.rs:83:86
+  --> $DIR/eager_transmute.rs:96:86
    |
 LL |     let _: Option<NonMaxU8> = (v2 < NonZeroU8::new(255).unwrap()).then_some(unsafe { std::mem::transmute(v2) });
    |                                                                                      ^^^^^^^^^^^^^^^^^^^^^^^
@@ -111,7 +177,7 @@ LL |     let _: Option<NonMaxU8> = (v2 < NonZeroU8::new(255).unwrap()).then(|| u
    |                                                                   ~~~~ ++
 
 error: this transmute is always evaluated eagerly, even if the condition is false
-  --> $DIR/eager_transmute.rs:89:93
+  --> $DIR/eager_transmute.rs:102:93
    |
 LL |     let _: Option<NonZeroNonMaxU8> = (v2 < NonZeroU8::new(255).unwrap()).then_some(unsafe { std::mem::transmute(v2) });
    |                                                                                             ^^^^^^^^^^^^^^^^^^^^^^^
@@ -121,5 +187,5 @@ help: consider using `bool::then` to only transmute if the condition holds
 LL |     let _: Option<NonZeroNonMaxU8> = (v2 < NonZeroU8::new(255).unwrap()).then(|| unsafe { std::mem::transmute(v2) });
    |                                                                          ~~~~ ++
 
-error: aborting due to 11 previous errors
+error: aborting due to 17 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From b8aab4bd1dbb842ca79e9c6c1db663935a0b044e Mon Sep 17 00:00:00 2001
From: Kevin Reid <kpreid@switchb.org>
Date: Thu, 28 Dec 2023 09:40:01 -0800
Subject: Polish `missing_enforced_import_renames` documentation
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* Fixes a typo in the name of the lint (`enforce-import-renames`
  instead of `enforced-import-renames`).
* Copyedit “Why” paragraph.
* Make the example configuration use a multi-line list, since it is not
  particularly expected that a real project will have *exactly one*
  rename to enforce (and the old formatting had unbalanced whitespace).
---
 clippy_lints/src/missing_enforced_import_rename.rs | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/missing_enforced_import_rename.rs b/clippy_lints/src/missing_enforced_import_rename.rs
index c1f6c71a63e..c6c188854fd 100644
--- a/clippy_lints/src/missing_enforced_import_rename.rs
+++ b/clippy_lints/src/missing_enforced_import_rename.rs
@@ -13,21 +13,23 @@ use rustc_span::Symbol;
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for imports that do not rename the item as specified
-    /// in the `enforce-import-renames` config option.
+    /// in the `enforced-import-renames` config option.
     ///
     /// Note: Even though this lint is warn-by-default, it will only trigger if
-    /// import renames are defined in the clippy.toml file.
+    /// import renames are defined in the `clippy.toml` file.
     ///
     /// ### Why is this bad?
-    /// Consistency is important, if a project has defined import
-    /// renames they should be followed. More practically, some item names are too
-    /// vague outside of their defining scope this can enforce a more meaningful naming.
+    /// Consistency is important; if a project has defined import renames, then they should be
+    /// followed. More practically, some item names are too vague outside of their defining scope,
+    /// in which case this can enforce a more meaningful naming.
     ///
     /// ### Example
     /// An example clippy.toml configuration:
     /// ```toml
     /// # clippy.toml
-    /// enforced-import-renames = [ { path = "serde_json::Value", rename = "JsonValue" }]
+    /// enforced-import-renames = [
+    ///     { path = "serde_json::Value", rename = "JsonValue" },
+    /// ]
     /// ```
     ///
     /// ```rust,ignore
-- 
cgit 1.4.1-3-g733a5


From 3fceca23bb64e304df56b3bd86d26790b5301bdf Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Fri, 29 Dec 2023 05:16:53 +0000
Subject: Remove mitigations for incorrect node args

---
 clippy_lints/src/methods/unnecessary_to_owned.rs | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/unnecessary_to_owned.rs b/clippy_lints/src/methods/unnecessary_to_owned.rs
index 637368e9361..5f69cf6cd7a 100644
--- a/clippy_lints/src/methods/unnecessary_to_owned.rs
+++ b/clippy_lints/src/methods/unnecessary_to_owned.rs
@@ -445,11 +445,12 @@ fn can_change_type<'a>(cx: &LateContext<'a>, mut expr: &'a Expr<'a>, mut ty: Ty<
                 {
                     let bound_fn_sig = cx.tcx.fn_sig(callee_def_id);
                     let fn_sig = bound_fn_sig.skip_binder();
-                    if let Some(arg_index) = recv.into_iter().chain(call_args).position(|arg| arg.hir_id == expr.hir_id)
+                    if let Some(arg_index) = recv
+                        .into_iter()
+                        .chain(call_args)
+                        .position(|arg| arg.hir_id == expr.hir_id)
                         && let param_ty = fn_sig.input(arg_index).skip_binder()
-                        && let ty::Param(ParamTy { index: param_index , ..}) = *param_ty.kind()
-                        // https://github.com/rust-lang/rust-clippy/issues/9504 and https://github.com/rust-lang/rust-clippy/issues/10021
-                        && (param_index as usize) < call_generic_args.len()
+                        && let ty::Param(ParamTy { index: param_index, .. }) = *param_ty.kind()
                     {
                         if fn_sig
                             .skip_binder()
-- 
cgit 1.4.1-3-g733a5


From fa7dd1c4e0106ce0346236801653188689dbaa43 Mon Sep 17 00:00:00 2001
From: Parker Timmerman <parker@parkertimmerman.com>
Date: Sun, 17 Dec 2023 15:55:06 -0500
Subject: add new lint, pub_underscore_fields - add a new late pass lint, with
 config options - add ui tests for both variations of config option - update
 CHANGELOG.md

github feedback

bump version to 1.77 and run cargo collect-metadata

Change `,` to `;` in `conf.rs`
---
 CHANGELOG.md                                       |  2 +
 book/src/lint_configuration.md                     | 10 +++
 clippy_config/src/conf.rs                          |  7 +-
 clippy_config/src/types.rs                         |  6 ++
 clippy_lints/src/declared_lints.rs                 |  1 +
 clippy_lints/src/lib.rs                            |  7 ++
 clippy_lints/src/pub_underscore_fields.rs          | 83 ++++++++++++++++++++++
 .../all_pub_fields/clippy.toml                     |  1 +
 .../pub_underscore_fields/exported/clippy.toml     |  1 +
 .../pub_underscore_fields.all_pub_fields.stderr    | 60 ++++++++++++++++
 .../pub_underscore_fields.exported.stderr          | 12 ++++
 .../pub_underscore_fields/pub_underscore_fields.rs | 66 +++++++++++++++++
 .../toml_unknown_key/conf_unknown_key.stderr       |  2 +
 13 files changed, 257 insertions(+), 1 deletion(-)
 create mode 100644 clippy_lints/src/pub_underscore_fields.rs
 create mode 100644 tests/ui-toml/pub_underscore_fields/all_pub_fields/clippy.toml
 create mode 100644 tests/ui-toml/pub_underscore_fields/exported/clippy.toml
 create mode 100644 tests/ui-toml/pub_underscore_fields/pub_underscore_fields.all_pub_fields.stderr
 create mode 100644 tests/ui-toml/pub_underscore_fields/pub_underscore_fields.exported.stderr
 create mode 100644 tests/ui-toml/pub_underscore_fields/pub_underscore_fields.rs

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index f82421a687b..0ac7297f8f1 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5483,6 +5483,7 @@ Released 2018-09-13
 [`ptr_eq`]: https://rust-lang.github.io/rust-clippy/master/index.html#ptr_eq
 [`ptr_offset_with_cast`]: https://rust-lang.github.io/rust-clippy/master/index.html#ptr_offset_with_cast
 [`pub_enum_variant_names`]: https://rust-lang.github.io/rust-clippy/master/index.html#pub_enum_variant_names
+[`pub_underscore_fields`]: https://rust-lang.github.io/rust-clippy/master/index.html#pub_underscore_fields
 [`pub_use`]: https://rust-lang.github.io/rust-clippy/master/index.html#pub_use
 [`pub_with_shorthand`]: https://rust-lang.github.io/rust-clippy/master/index.html#pub_with_shorthand
 [`pub_without_shorthand`]: https://rust-lang.github.io/rust-clippy/master/index.html#pub_without_shorthand
@@ -5810,4 +5811,5 @@ Released 2018-09-13
 [`allowed-dotfiles`]: https://doc.rust-lang.org/clippy/lint_configuration.html#allowed-dotfiles
 [`enforce-iter-loop-reborrow`]: https://doc.rust-lang.org/clippy/lint_configuration.html#enforce-iter-loop-reborrow
 [`check-private-items`]: https://doc.rust-lang.org/clippy/lint_configuration.html#check-private-items
+[`pub-underscore-fields-behavior`]: https://doc.rust-lang.org/clippy/lint_configuration.html#pub-underscore-fields-behavior
 <!-- end autogenerated links to configuration documentation -->
diff --git a/book/src/lint_configuration.md b/book/src/lint_configuration.md
index 7c9a8eb1bfb..3b62ae0524a 100644
--- a/book/src/lint_configuration.md
+++ b/book/src/lint_configuration.md
@@ -805,3 +805,13 @@ for _ in &mut *rmvec {}
 * [`missing_errors_doc`](https://rust-lang.github.io/rust-clippy/master/index.html#missing_errors_doc)
 
 
+## `pub-underscore-fields-behavior`
+
+
+**Default Value:** `"PublicallyExported"`
+
+---
+**Affected lints:**
+* [`pub_underscore_fields`](https://rust-lang.github.io/rust-clippy/master/index.html#pub_underscore_fields)
+
+
diff --git a/clippy_config/src/conf.rs b/clippy_config/src/conf.rs
index 67ea0af07e6..77d7f1760c9 100644
--- a/clippy_config/src/conf.rs
+++ b/clippy_config/src/conf.rs
@@ -1,5 +1,5 @@
 use crate::msrvs::Msrv;
-use crate::types::{DisallowedPath, MacroMatcher, MatchLintBehaviour, Rename};
+use crate::types::{DisallowedPath, MacroMatcher, MatchLintBehaviour, PubUnderscoreFieldsBehaviour, Rename};
 use crate::ClippyConfiguration;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_session::Session;
@@ -547,6 +547,11 @@ define_Conf! {
     ///
     /// Whether to also run the listed lints on private items.
     (check_private_items: bool = false),
+    /// Lint: PUB_UNDERSCORE_FIELDS
+    ///
+    /// Lint "public" fields in a struct that are prefixed with an underscore based on their
+    /// exported visibility; or whether they are marked as "pub".
+    (pub_underscore_fields_behavior: PubUnderscoreFieldsBehaviour = PubUnderscoreFieldsBehaviour::PublicallyExported),
 }
 
 /// Search for the configuration file.
diff --git a/clippy_config/src/types.rs b/clippy_config/src/types.rs
index df48cc3f5e3..baee09629ac 100644
--- a/clippy_config/src/types.rs
+++ b/clippy_config/src/types.rs
@@ -126,3 +126,9 @@ unimplemented_serialize! {
     Rename,
     MacroMatcher,
 }
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Deserialize, Serialize)]
+pub enum PubUnderscoreFieldsBehaviour {
+    PublicallyExported,
+    AllPubFields,
+}
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index eae9dfac064..9dd22135d95 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -576,6 +576,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::ptr::MUT_FROM_REF_INFO,
     crate::ptr::PTR_ARG_INFO,
     crate::ptr_offset_with_cast::PTR_OFFSET_WITH_CAST_INFO,
+    crate::pub_underscore_fields::PUB_UNDERSCORE_FIELDS_INFO,
     crate::pub_use::PUB_USE_INFO,
     crate::question_mark::QUESTION_MARK_INFO,
     crate::question_mark_used::QUESTION_MARK_USED_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 755a4ff525d..712fe73f6a1 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -272,6 +272,7 @@ mod permissions_set_readonly_false;
 mod precedence;
 mod ptr;
 mod ptr_offset_with_cast;
+mod pub_underscore_fields;
 mod pub_use;
 mod question_mark;
 mod question_mark_used;
@@ -571,6 +572,7 @@ pub fn register_lints(store: &mut rustc_lint::LintStore, conf: &'static Conf) {
         verbose_bit_mask_threshold,
         warn_on_all_wildcard_imports,
         check_private_items,
+        pub_underscore_fields_behavior,
 
         blacklisted_names: _,
         cyclomatic_complexity_threshold: _,
@@ -1081,6 +1083,11 @@ pub fn register_lints(store: &mut rustc_lint::LintStore, conf: &'static Conf) {
     store.register_late_pass(|_| Box::new(uninhabited_references::UninhabitedReferences));
     store.register_late_pass(|_| Box::new(ineffective_open_options::IneffectiveOpenOptions));
     store.register_late_pass(|_| Box::new(unconditional_recursion::UnconditionalRecursion));
+    store.register_late_pass(move |_| {
+        Box::new(pub_underscore_fields::PubUnderscoreFields {
+            behavior: pub_underscore_fields_behavior,
+        })
+    });
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/pub_underscore_fields.rs b/clippy_lints/src/pub_underscore_fields.rs
new file mode 100644
index 00000000000..00465ce4381
--- /dev/null
+++ b/clippy_lints/src/pub_underscore_fields.rs
@@ -0,0 +1,83 @@
+use clippy_config::types::PubUnderscoreFieldsBehaviour;
+use clippy_utils::attrs::is_doc_hidden;
+use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::is_path_lang_item;
+use rustc_hir::{FieldDef, Item, ItemKind, LangItem};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::impl_lint_pass;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks whether any field of the struct is prefixed with an `_` (underscore) and also marked
+    /// `pub` (public)
+    ///
+    /// ### Why is this bad?
+    /// Fields prefixed with an `_` are inferred as unused, which suggests it should not be marked
+    /// as `pub`, because marking it as `pub` infers it will be used.
+    ///
+    /// ### Example
+    /// ```rust
+    /// struct FileHandle {
+    ///     pub _descriptor: usize,
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// struct FileHandle {
+    ///     _descriptor: usize,
+    /// }
+    /// ```
+    ///
+    /// OR
+    ///
+    /// ```rust
+    /// struct FileHandle {
+    ///     pub descriptor: usize,
+    /// }
+    /// ```
+    #[clippy::version = "1.77.0"]
+    pub PUB_UNDERSCORE_FIELDS,
+    pedantic,
+    "struct field prefixed with underscore and marked public"
+}
+
+pub struct PubUnderscoreFields {
+    pub behavior: PubUnderscoreFieldsBehaviour,
+}
+impl_lint_pass!(PubUnderscoreFields => [PUB_UNDERSCORE_FIELDS]);
+
+impl<'tcx> LateLintPass<'tcx> for PubUnderscoreFields {
+    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
+        // This lint only pertains to structs.
+        let ItemKind::Struct(variant_data, _) = &item.kind else {
+            return;
+        };
+
+        let is_visible = |field: &FieldDef<'_>| match self.behavior {
+            PubUnderscoreFieldsBehaviour::PublicallyExported => cx.effective_visibilities.is_reachable(field.def_id),
+            PubUnderscoreFieldsBehaviour::AllPubFields => {
+                // If there is a visibility span then the field is marked pub in some way.
+                !field.vis_span.is_empty()
+            },
+        };
+
+        for field in variant_data.fields() {
+            // Only pertains to fields that start with an underscore, and are public.
+            if field.ident.as_str().starts_with('_') && is_visible(field)
+                // We ignore fields that have `#[doc(hidden)]`.
+                && !is_doc_hidden(cx.tcx.hir().attrs(field.hir_id))
+                // We ignore fields that are `PhantomData`.
+                && !is_path_lang_item(cx, field.ty, LangItem::PhantomData)
+            {
+                span_lint_and_help(
+                    cx,
+                    PUB_UNDERSCORE_FIELDS,
+                    field.vis_span.to(field.ident.span),
+                    "field marked as public but also inferred as unused because it's prefixed with `_`",
+                    None,
+                    "consider removing the underscore, or making the field private",
+                );
+            }
+        }
+    }
+}
diff --git a/tests/ui-toml/pub_underscore_fields/all_pub_fields/clippy.toml b/tests/ui-toml/pub_underscore_fields/all_pub_fields/clippy.toml
new file mode 100644
index 00000000000..95835d101b1
--- /dev/null
+++ b/tests/ui-toml/pub_underscore_fields/all_pub_fields/clippy.toml
@@ -0,0 +1 @@
+pub-underscore-fields-behavior = "AllPubFields"
\ No newline at end of file
diff --git a/tests/ui-toml/pub_underscore_fields/exported/clippy.toml b/tests/ui-toml/pub_underscore_fields/exported/clippy.toml
new file mode 100644
index 00000000000..94a0d3554bc
--- /dev/null
+++ b/tests/ui-toml/pub_underscore_fields/exported/clippy.toml
@@ -0,0 +1 @@
+pub-underscore-fields-behavior = "PublicallyExported"
\ No newline at end of file
diff --git a/tests/ui-toml/pub_underscore_fields/pub_underscore_fields.all_pub_fields.stderr b/tests/ui-toml/pub_underscore_fields/pub_underscore_fields.all_pub_fields.stderr
new file mode 100644
index 00000000000..c6bd499fd8c
--- /dev/null
+++ b/tests/ui-toml/pub_underscore_fields/pub_underscore_fields.all_pub_fields.stderr
@@ -0,0 +1,60 @@
+error: field marked as public but also inferred as unused because it's prefixed with `_`
+  --> $DIR/pub_underscore_fields.rs:15:9
+   |
+LL |         pub _b: u8,
+   |         ^^^^^^
+   |
+   = help: consider removing the underscore, or making the field private
+   = note: `-D clippy::pub-underscore-fields` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::pub_underscore_fields)]`
+
+error: field marked as public but also inferred as unused because it's prefixed with `_`
+  --> $DIR/pub_underscore_fields.rs:23:13
+   |
+LL |             pub(in crate::inner) _f: Option<()>,
+   |             ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider removing the underscore, or making the field private
+
+error: field marked as public but also inferred as unused because it's prefixed with `_`
+  --> $DIR/pub_underscore_fields.rs:27:13
+   |
+LL |             pub _g: String,
+   |             ^^^^^^
+   |
+   = help: consider removing the underscore, or making the field private
+
+error: field marked as public but also inferred as unused because it's prefixed with `_`
+  --> $DIR/pub_underscore_fields.rs:34:9
+   |
+LL |         pub _a: usize,
+   |         ^^^^^^
+   |
+   = help: consider removing the underscore, or making the field private
+
+error: field marked as public but also inferred as unused because it's prefixed with `_`
+  --> $DIR/pub_underscore_fields.rs:41:9
+   |
+LL |         pub _c: i64,
+   |         ^^^^^^
+   |
+   = help: consider removing the underscore, or making the field private
+
+error: field marked as public but also inferred as unused because it's prefixed with `_`
+  --> $DIR/pub_underscore_fields.rs:44:9
+   |
+LL |         pub _e: Option<u8>,
+   |         ^^^^^^
+   |
+   = help: consider removing the underscore, or making the field private
+
+error: field marked as public but also inferred as unused because it's prefixed with `_`
+  --> $DIR/pub_underscore_fields.rs:57:9
+   |
+LL |         pub(crate) _b: Option<String>,
+   |         ^^^^^^^^^^^^^
+   |
+   = help: consider removing the underscore, or making the field private
+
+error: aborting due to 7 previous errors
+
diff --git a/tests/ui-toml/pub_underscore_fields/pub_underscore_fields.exported.stderr b/tests/ui-toml/pub_underscore_fields/pub_underscore_fields.exported.stderr
new file mode 100644
index 00000000000..b76f6b3d388
--- /dev/null
+++ b/tests/ui-toml/pub_underscore_fields/pub_underscore_fields.exported.stderr
@@ -0,0 +1,12 @@
+error: field marked as public but also inferred as unused because it's prefixed with `_`
+  --> $DIR/pub_underscore_fields.rs:15:9
+   |
+LL |         pub _b: u8,
+   |         ^^^^^^
+   |
+   = help: consider removing the underscore, or making the field private
+   = note: `-D clippy::pub-underscore-fields` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::pub_underscore_fields)]`
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui-toml/pub_underscore_fields/pub_underscore_fields.rs b/tests/ui-toml/pub_underscore_fields/pub_underscore_fields.rs
new file mode 100644
index 00000000000..1d8fee7daad
--- /dev/null
+++ b/tests/ui-toml/pub_underscore_fields/pub_underscore_fields.rs
@@ -0,0 +1,66 @@
+//@revisions: exported all_pub_fields
+//@[all_pub_fields] rustc-env:CLIPPY_CONF_DIR=tests/ui-toml/pub_underscore_fields/all_pub_fields
+//@[exported] rustc-env:CLIPPY_CONF_DIR=tests/ui-toml/pub_underscore_fields/exported
+
+#![allow(unused)]
+#![warn(clippy::pub_underscore_fields)]
+
+use std::marker::PhantomData;
+
+pub mod inner {
+    use std::marker;
+
+    pub struct PubSuper {
+        pub(super) a: usize,
+        pub _b: u8,
+        _c: i32,
+        pub _mark: marker::PhantomData<u8>,
+    }
+
+    mod inner2 {
+        pub struct PubModVisibility {
+            pub(in crate::inner) e: bool,
+            pub(in crate::inner) _f: Option<()>,
+        }
+
+        struct PrivateStructPubField {
+            pub _g: String,
+        }
+    }
+}
+
+fn main() {
+    pub struct StructWithOneViolation {
+        pub _a: usize,
+    }
+
+    // should handle structs with multiple violations
+    pub struct StructWithMultipleViolations {
+        a: u8,
+        _b: usize,
+        pub _c: i64,
+        #[doc(hidden)]
+        pub d: String,
+        pub _e: Option<u8>,
+    }
+
+    // shouldn't warn on anonymous fields
+    pub struct AnonymousFields(pub usize, i32);
+
+    // don't warn on empty structs
+    pub struct Empty1;
+    pub struct Empty2();
+    pub struct Empty3 {};
+
+    pub struct PubCrate {
+        pub(crate) a: String,
+        pub(crate) _b: Option<String>,
+    }
+
+    // shouldn't warn on fields named pub
+    pub struct NamedPub {
+        r#pub: bool,
+        _pub: String,
+        pub(crate) _mark: PhantomData<u8>,
+    }
+}
diff --git a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
index 12828cf9dec..ed4fb84df1a 100644
--- a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
+++ b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
@@ -49,6 +49,7 @@ error: error reading Clippy's configuration file: unknown field `foobar`, expect
            missing-docs-in-crate-items
            msrv
            pass-by-value-size-limit
+           pub-underscore-fields-behavior
            semicolon-inside-block-ignore-singleline
            semicolon-outside-block-ignore-multiline
            single-char-binding-names-threshold
@@ -124,6 +125,7 @@ error: error reading Clippy's configuration file: unknown field `barfoo`, expect
            missing-docs-in-crate-items
            msrv
            pass-by-value-size-limit
+           pub-underscore-fields-behavior
            semicolon-inside-block-ignore-singleline
            semicolon-outside-block-ignore-multiline
            single-char-binding-names-threshold
-- 
cgit 1.4.1-3-g733a5


From 1ee9993a962d9f2990bbdac91c792ca893f10b54 Mon Sep 17 00:00:00 2001
From: Aneesh Kadiyala <143342960+ARandomDev99@users.noreply.github.com>
Date: Fri, 29 Dec 2023 19:23:31 +0530
Subject: add new lint, empty_enum_variants_with_brackets

- Add a new early pass lint.
- Add relevant UI tests.
---
 CHANGELOG.md                                      |   1 +
 clippy_lints/src/declared_lints.rs                |   3 +-
 clippy_lints/src/empty_structs_with_brackets.rs   | 102 ---------------
 clippy_lints/src/empty_with_brackets.rs           | 152 ++++++++++++++++++++++
 clippy_lints/src/lib.rs                           |   4 +-
 tests/ui/empty_enum_variants_with_brackets.fixed  |  27 ++++
 tests/ui/empty_enum_variants_with_brackets.rs     |  27 ++++
 tests/ui/empty_enum_variants_with_brackets.stderr |  36 +++++
 8 files changed, 247 insertions(+), 105 deletions(-)
 delete mode 100644 clippy_lints/src/empty_structs_with_brackets.rs
 create mode 100644 clippy_lints/src/empty_with_brackets.rs
 create mode 100644 tests/ui/empty_enum_variants_with_brackets.fixed
 create mode 100644 tests/ui/empty_enum_variants_with_brackets.rs
 create mode 100644 tests/ui/empty_enum_variants_with_brackets.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 0ac7297f8f1..931517e72f6 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5105,6 +5105,7 @@ Released 2018-09-13
 [`else_if_without_else`]: https://rust-lang.github.io/rust-clippy/master/index.html#else_if_without_else
 [`empty_drop`]: https://rust-lang.github.io/rust-clippy/master/index.html#empty_drop
 [`empty_enum`]: https://rust-lang.github.io/rust-clippy/master/index.html#empty_enum
+[`empty_enum_variants_with_brackets`]: https://rust-lang.github.io/rust-clippy/master/index.html#empty_enum_variants_with_brackets
 [`empty_line_after_doc_comments`]: https://rust-lang.github.io/rust-clippy/master/index.html#empty_line_after_doc_comments
 [`empty_line_after_outer_attr`]: https://rust-lang.github.io/rust-clippy/master/index.html#empty_line_after_outer_attr
 [`empty_loop`]: https://rust-lang.github.io/rust-clippy/master/index.html#empty_loop
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 9dd22135d95..b606bb4aa33 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -150,7 +150,8 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::else_if_without_else::ELSE_IF_WITHOUT_ELSE_INFO,
     crate::empty_drop::EMPTY_DROP_INFO,
     crate::empty_enum::EMPTY_ENUM_INFO,
-    crate::empty_structs_with_brackets::EMPTY_STRUCTS_WITH_BRACKETS_INFO,
+    crate::empty_with_brackets::EMPTY_ENUM_VARIANTS_WITH_BRACKETS_INFO,
+    crate::empty_with_brackets::EMPTY_STRUCTS_WITH_BRACKETS_INFO,
     crate::endian_bytes::BIG_ENDIAN_BYTES_INFO,
     crate::endian_bytes::HOST_ENDIAN_BYTES_INFO,
     crate::endian_bytes::LITTLE_ENDIAN_BYTES_INFO,
diff --git a/clippy_lints/src/empty_structs_with_brackets.rs b/clippy_lints/src/empty_structs_with_brackets.rs
deleted file mode 100644
index 3cf67b3ecbf..00000000000
--- a/clippy_lints/src/empty_structs_with_brackets.rs
+++ /dev/null
@@ -1,102 +0,0 @@
-use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::source::snippet_opt;
-use rustc_ast::ast::{Item, ItemKind, VariantData};
-use rustc_errors::Applicability;
-use rustc_lexer::TokenKind;
-use rustc_lint::{EarlyContext, EarlyLintPass};
-use rustc_session::declare_lint_pass;
-use rustc_span::Span;
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Finds structs without fields (a so-called "empty struct") that are declared with brackets.
-    ///
-    /// ### Why is this bad?
-    /// Empty brackets after a struct declaration can be omitted.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// struct Cookie {}
-    /// ```
-    /// Use instead:
-    /// ```no_run
-    /// struct Cookie;
-    /// ```
-    #[clippy::version = "1.62.0"]
-    pub EMPTY_STRUCTS_WITH_BRACKETS,
-    restriction,
-    "finds struct declarations with empty brackets"
-}
-declare_lint_pass!(EmptyStructsWithBrackets => [EMPTY_STRUCTS_WITH_BRACKETS]);
-
-impl EarlyLintPass for EmptyStructsWithBrackets {
-    fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {
-        let span_after_ident = item.span.with_lo(item.ident.span.hi());
-
-        if let ItemKind::Struct(var_data, _) = &item.kind
-            && has_brackets(var_data)
-            && has_no_fields(cx, var_data, span_after_ident)
-        {
-            span_lint_and_then(
-                cx,
-                EMPTY_STRUCTS_WITH_BRACKETS,
-                span_after_ident,
-                "found empty brackets on struct declaration",
-                |diagnostic| {
-                    diagnostic.span_suggestion_hidden(
-                        span_after_ident,
-                        "remove the brackets",
-                        ";",
-                        Applicability::Unspecified,
-                    );
-                },
-            );
-        }
-    }
-}
-
-fn has_no_ident_token(braces_span_str: &str) -> bool {
-    !rustc_lexer::tokenize(braces_span_str).any(|t| t.kind == TokenKind::Ident)
-}
-
-fn has_brackets(var_data: &VariantData) -> bool {
-    !matches!(var_data, VariantData::Unit(_))
-}
-
-fn has_no_fields(cx: &EarlyContext<'_>, var_data: &VariantData, braces_span: Span) -> bool {
-    if !var_data.fields().is_empty() {
-        return false;
-    }
-
-    // there might still be field declarations hidden from the AST
-    // (conditionally compiled code using #[cfg(..)])
-
-    let Some(braces_span_str) = snippet_opt(cx, braces_span) else {
-        return false;
-    };
-
-    has_no_ident_token(braces_span_str.as_ref())
-}
-
-#[cfg(test)]
-mod unit_test {
-    use super::*;
-
-    #[test]
-    fn test_has_no_ident_token() {
-        let input = "{ field: u8 }";
-        assert!(!has_no_ident_token(input));
-
-        let input = "(u8, String);";
-        assert!(!has_no_ident_token(input));
-
-        let input = " {
-                // test = 5
-        }
-        ";
-        assert!(has_no_ident_token(input));
-
-        let input = " ();";
-        assert!(has_no_ident_token(input));
-    }
-}
diff --git a/clippy_lints/src/empty_with_brackets.rs b/clippy_lints/src/empty_with_brackets.rs
new file mode 100644
index 00000000000..52a88324fc3
--- /dev/null
+++ b/clippy_lints/src/empty_with_brackets.rs
@@ -0,0 +1,152 @@
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::source::snippet_opt;
+use rustc_ast::ast::{Item, ItemKind, Variant, VariantData};
+use rustc_errors::Applicability;
+use rustc_lexer::TokenKind;
+use rustc_lint::{EarlyContext, EarlyLintPass};
+use rustc_session::declare_lint_pass;
+use rustc_span::Span;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Finds structs without fields (a so-called "empty struct") that are declared with brackets.
+    ///
+    /// ### Why is this bad?
+    /// Empty brackets after a struct declaration can be omitted.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// struct Cookie {}
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// struct Cookie;
+    /// ```
+    #[clippy::version = "1.62.0"]
+    pub EMPTY_STRUCTS_WITH_BRACKETS,
+    restriction,
+    "finds struct declarations with empty brackets"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Finds enum variants without fields that are declared with empty brackets.
+    ///
+    /// ### Why is this bad?
+    /// Empty brackets while defining enum variants are redundant and can be omitted.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// enum MyEnum {
+    ///     HasData(u8),
+    ///     HasNoData(), // redundant parentheses
+    /// }
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// enum MyEnum {
+    ///     HasData(u8),
+    ///     HasNoData,
+    /// }
+    /// ```
+    #[clippy::version = "1.77.0"]
+    pub EMPTY_ENUM_VARIANTS_WITH_BRACKETS,
+    restriction,
+    "finds enum variants with empty brackets"
+}
+
+declare_lint_pass!(EmptyWithBrackets => [EMPTY_STRUCTS_WITH_BRACKETS, EMPTY_ENUM_VARIANTS_WITH_BRACKETS]);
+
+impl EarlyLintPass for EmptyWithBrackets {
+    fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {
+        let span_after_ident = item.span.with_lo(item.ident.span.hi());
+
+        if let ItemKind::Struct(var_data, _) = &item.kind
+            && has_brackets(var_data)
+            && has_no_fields(cx, var_data, span_after_ident)
+        {
+            span_lint_and_then(
+                cx,
+                EMPTY_STRUCTS_WITH_BRACKETS,
+                span_after_ident,
+                "found empty brackets on struct declaration",
+                |diagnostic| {
+                    diagnostic.span_suggestion_hidden(
+                        span_after_ident,
+                        "remove the brackets",
+                        ";",
+                        Applicability::Unspecified,
+                    );
+                },
+            );
+        }
+    }
+
+    fn check_variant(&mut self, cx: &EarlyContext<'_>, variant: &Variant) {
+        let span_after_ident = variant.span.with_lo(variant.ident.span.hi());
+
+        if has_brackets(&variant.data) && has_no_fields(cx, &variant.data, span_after_ident) {
+            span_lint_and_then(
+                cx,
+                EMPTY_ENUM_VARIANTS_WITH_BRACKETS,
+                span_after_ident,
+                "enum variant has empty brackets",
+                |diagnostic| {
+                    diagnostic.span_suggestion_hidden(
+                        span_after_ident,
+                        "remove the brackets",
+                        "",
+                        Applicability::MachineApplicable,
+                    );
+                },
+            );
+        }
+    }
+}
+
+fn has_no_ident_token(braces_span_str: &str) -> bool {
+    !rustc_lexer::tokenize(braces_span_str).any(|t| t.kind == TokenKind::Ident)
+}
+
+fn has_brackets(var_data: &VariantData) -> bool {
+    !matches!(var_data, VariantData::Unit(_))
+}
+
+fn has_no_fields(cx: &EarlyContext<'_>, var_data: &VariantData, braces_span: Span) -> bool {
+    if !var_data.fields().is_empty() {
+        return false;
+    }
+
+    // there might still be field declarations hidden from the AST
+    // (conditionally compiled code using #[cfg(..)])
+
+    let Some(braces_span_str) = snippet_opt(cx, braces_span) else {
+        return false;
+    };
+
+    has_no_ident_token(braces_span_str.as_ref())
+}
+
+#[cfg(test)]
+mod unit_test {
+    use super::*;
+
+    #[test]
+    fn test_has_no_ident_token() {
+        let input = "{ field: u8 }";
+        assert!(!has_no_ident_token(input));
+
+        let input = "(u8, String);";
+        assert!(!has_no_ident_token(input));
+
+        let input = " {
+                // test = 5
+        }
+        ";
+        assert!(has_no_ident_token(input));
+
+        let input = " ();";
+        assert!(has_no_ident_token(input));
+    }
+}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 712fe73f6a1..dc24243b574 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -115,7 +115,7 @@ mod duplicate_mod;
 mod else_if_without_else;
 mod empty_drop;
 mod empty_enum;
-mod empty_structs_with_brackets;
+mod empty_with_brackets;
 mod endian_bytes;
 mod entry;
 mod enum_clike;
@@ -949,7 +949,7 @@ pub fn register_lints(store: &mut rustc_lint::LintStore, conf: &'static Conf) {
         })
     });
     store.register_early_pass(|| Box::new(crate_in_macro_def::CrateInMacroDef));
-    store.register_early_pass(|| Box::new(empty_structs_with_brackets::EmptyStructsWithBrackets));
+    store.register_early_pass(|| Box::new(empty_with_brackets::EmptyWithBrackets));
     store.register_late_pass(|_| Box::new(unnecessary_owned_empty_strings::UnnecessaryOwnedEmptyStrings));
     store.register_early_pass(|| Box::new(pub_use::PubUse));
     store.register_late_pass(|_| Box::new(format_push_string::FormatPushString));
diff --git a/tests/ui/empty_enum_variants_with_brackets.fixed b/tests/ui/empty_enum_variants_with_brackets.fixed
new file mode 100644
index 00000000000..1a5e78dd47f
--- /dev/null
+++ b/tests/ui/empty_enum_variants_with_brackets.fixed
@@ -0,0 +1,27 @@
+#![warn(clippy::empty_enum_variants_with_brackets)]
+#![allow(dead_code)]
+
+pub enum PublicTestEnum {
+    NonEmptyBraces { x: i32, y: i32 }, // No error
+    NonEmptyParentheses(i32, i32),     // No error
+    EmptyBraces,                    //~ ERROR: enum variant has empty brackets
+    EmptyParentheses,                //~ ERROR: enum variant has empty brackets
+}
+
+enum TestEnum {
+    NonEmptyBraces { x: i32, y: i32 }, // No error
+    NonEmptyParentheses(i32, i32),     // No error
+    EmptyBraces,                    //~ ERROR: enum variant has empty brackets
+    EmptyParentheses,                //~ ERROR: enum variant has empty brackets
+    AnotherEnum,                       // No error
+}
+
+enum TestEnumWithFeatures {
+    NonEmptyBraces {
+        #[cfg(feature = "thisisneverenabled")]
+        x: i32,
+    }, // No error
+    NonEmptyParentheses(#[cfg(feature = "thisisneverenabled")] i32), // No error
+}
+
+fn main() {}
diff --git a/tests/ui/empty_enum_variants_with_brackets.rs b/tests/ui/empty_enum_variants_with_brackets.rs
new file mode 100644
index 00000000000..ca20b969a24
--- /dev/null
+++ b/tests/ui/empty_enum_variants_with_brackets.rs
@@ -0,0 +1,27 @@
+#![warn(clippy::empty_enum_variants_with_brackets)]
+#![allow(dead_code)]
+
+pub enum PublicTestEnum {
+    NonEmptyBraces { x: i32, y: i32 }, // No error
+    NonEmptyParentheses(i32, i32),     // No error
+    EmptyBraces {},                    //~ ERROR: enum variant has empty brackets
+    EmptyParentheses(),                //~ ERROR: enum variant has empty brackets
+}
+
+enum TestEnum {
+    NonEmptyBraces { x: i32, y: i32 }, // No error
+    NonEmptyParentheses(i32, i32),     // No error
+    EmptyBraces {},                    //~ ERROR: enum variant has empty brackets
+    EmptyParentheses(),                //~ ERROR: enum variant has empty brackets
+    AnotherEnum,                       // No error
+}
+
+enum TestEnumWithFeatures {
+    NonEmptyBraces {
+        #[cfg(feature = "thisisneverenabled")]
+        x: i32,
+    }, // No error
+    NonEmptyParentheses(#[cfg(feature = "thisisneverenabled")] i32), // No error
+}
+
+fn main() {}
diff --git a/tests/ui/empty_enum_variants_with_brackets.stderr b/tests/ui/empty_enum_variants_with_brackets.stderr
new file mode 100644
index 00000000000..6b2f286147f
--- /dev/null
+++ b/tests/ui/empty_enum_variants_with_brackets.stderr
@@ -0,0 +1,36 @@
+error: enum variant has empty brackets
+  --> $DIR/empty_enum_variants_with_brackets.rs:7:16
+   |
+LL |     EmptyBraces {},
+   |                ^^^
+   |
+   = note: `-D clippy::empty-enum-variants-with-brackets` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::empty_enum_variants_with_brackets)]`
+   = help: remove the brackets
+
+error: enum variant has empty brackets
+  --> $DIR/empty_enum_variants_with_brackets.rs:8:21
+   |
+LL |     EmptyParentheses(),
+   |                     ^^
+   |
+   = help: remove the brackets
+
+error: enum variant has empty brackets
+  --> $DIR/empty_enum_variants_with_brackets.rs:14:16
+   |
+LL |     EmptyBraces {},
+   |                ^^^
+   |
+   = help: remove the brackets
+
+error: enum variant has empty brackets
+  --> $DIR/empty_enum_variants_with_brackets.rs:15:21
+   |
+LL |     EmptyParentheses(),
+   |                     ^^
+   |
+   = help: remove the brackets
+
+error: aborting due to 4 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From ca40b0c284a54676ee9e9b560f5ea43b51dfbfbc Mon Sep 17 00:00:00 2001
From: cocodery <cocodery@outlook.com>
Date: Sat, 30 Dec 2023 01:58:30 +0800
Subject: fix/issue#11243: allow 3-digit-grouped binary in
 non_octal_unix_permissions

---
 clippy_lints/src/non_octal_unix_permissions.rs | 36 +++++++++++++++++++-------
 1 file changed, 26 insertions(+), 10 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/non_octal_unix_permissions.rs b/clippy_lints/src/non_octal_unix_permissions.rs
index 49e9e2c00cc..7143ac9cfc1 100644
--- a/clippy_lints/src/non_octal_unix_permissions.rs
+++ b/clippy_lints/src/non_octal_unix_permissions.rs
@@ -1,6 +1,8 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::numeric_literal::{NumericLiteral, Radix};
 use clippy_utils::source::{snippet_opt, snippet_with_applicability};
 use clippy_utils::{match_def_path, paths};
+use rustc_ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
@@ -39,6 +41,24 @@ declare_clippy_lint! {
 
 declare_lint_pass!(NonOctalUnixPermissions => [NON_OCTAL_UNIX_PERMISSIONS]);
 
+fn check_binary_unix_permissions(lit_kind: &LitKind, snip: &str) -> bool {
+    // support binary unix permissions
+    if let Some(num_lit) = NumericLiteral::from_lit_kind(snip, lit_kind) {
+        if num_lit.radix != Radix::Binary {
+            return false;
+        }
+
+        let group_sizes: Vec<usize> = num_lit.integer.split('_').map(str::len).collect();
+        // check whether is binary format unix permissions
+        if group_sizes.len() != 3 {
+            return false;
+        }
+        group_sizes.iter().all(|len| *len == 3)
+    } else {
+        false
+    }
+}
+
 impl<'tcx> LateLintPass<'tcx> for NonOctalUnixPermissions {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
         match &expr.kind {
@@ -51,26 +71,22 @@ impl<'tcx> LateLintPass<'tcx> for NonOctalUnixPermissions {
                         ))
                         || (path.ident.name == sym!(set_mode)
                             && cx.tcx.is_diagnostic_item(sym::FsPermissions, adt.did())))
-                    && let ExprKind::Lit(_) = param.kind
+                    && let ExprKind::Lit(lit_kind) = param.kind
                     && param.span.eq_ctxt(expr.span)
+                    && let Some(snip) = snippet_opt(cx, param.span)
+                    && !(snip.starts_with("0o") || check_binary_unix_permissions(&lit_kind.node, &snip))
                 {
-                    let Some(snip) = snippet_opt(cx, param.span) else {
-                        return;
-                    };
-
-                    if !snip.starts_with("0o") {
-                        show_error(cx, param);
-                    }
+                    show_error(cx, param);
                 }
             },
             ExprKind::Call(func, [param]) => {
                 if let ExprKind::Path(ref path) = func.kind
                     && let Some(def_id) = cx.qpath_res(path, func.hir_id).opt_def_id()
                     && match_def_path(cx, def_id, &paths::PERMISSIONS_FROM_MODE)
-                    && let ExprKind::Lit(_) = param.kind
+                    && let ExprKind::Lit(lit_kind) = param.kind
                     && param.span.eq_ctxt(expr.span)
                     && let Some(snip) = snippet_opt(cx, param.span)
-                    && !snip.starts_with("0o")
+                    && !(snip.starts_with("0o") || check_binary_unix_permissions(&lit_kind.node, &snip))
                 {
                     show_error(cx, param);
                 }
-- 
cgit 1.4.1-3-g733a5


From 0848e120b266517c661aed984838e4e6ca5afdd6 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Sat, 30 Dec 2023 04:11:12 +0100
Subject: add expansion checks to `iter_without_into_iter` and
 `into_iter_without_iter`

---
 clippy_lints/src/iter_without_into_iter.rs |  9 ++++---
 tests/ui/into_iter_without_iter.rs         | 39 +++++++++++++++++++++++++++++
 tests/ui/into_iter_without_iter.stderr     | 38 +++++++++++++++++++++++-----
 tests/ui/iter_without_into_iter.rs         | 31 +++++++++++++++++++++++
 tests/ui/iter_without_into_iter.stderr     | 40 ++++++++++++++++++++++++------
 5 files changed, 140 insertions(+), 17 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/iter_without_into_iter.rs b/clippy_lints/src/iter_without_into_iter.rs
index c9dc48668f2..903d3a2ab89 100644
--- a/clippy_lints/src/iter_without_into_iter.rs
+++ b/clippy_lints/src/iter_without_into_iter.rs
@@ -5,7 +5,8 @@ use clippy_utils::ty::{implements_trait, make_normalized_projection};
 use rustc_ast::Mutability;
 use rustc_errors::Applicability;
 use rustc_hir::{FnRetTy, ImplItemKind, ImplicitSelfKind, ItemKind, TyKind};
-use rustc_lint::{LateContext, LateLintPass};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::{self, Ty};
 use rustc_session::declare_lint_pass;
 use rustc_span::{sym, Symbol};
@@ -152,7 +153,8 @@ fn adt_has_inherent_method(cx: &LateContext<'_>, ty: Ty<'_>, method_name: Symbol
 
 impl LateLintPass<'_> for IterWithoutIntoIter {
     fn check_item(&mut self, cx: &LateContext<'_>, item: &rustc_hir::Item<'_>) {
-        if let ItemKind::Impl(imp) = item.kind
+        if !in_external_macro(cx.sess(), item.span)
+            && let ItemKind::Impl(imp) = item.kind
             && let TyKind::Ref(_, self_ty_without_ref) = &imp.self_ty.kind
             && let Some(trait_ref) = imp.of_trait
             && trait_ref
@@ -219,7 +221,8 @@ impl {self_ty_without_ref} {{
             _ => return,
         };
 
-        if let ImplItemKind::Fn(sig, _) = item.kind
+        if !in_external_macro(cx.sess(), item.span)
+            && let ImplItemKind::Fn(sig, _) = item.kind
             && let FnRetTy::Return(ret) = sig.decl.output
             && is_nameable_in_impl_trait(ret)
             && cx.tcx.generics_of(item_did).params.is_empty()
diff --git a/tests/ui/into_iter_without_iter.rs b/tests/ui/into_iter_without_iter.rs
index 448d0114dff..c8b9076041a 100644
--- a/tests/ui/into_iter_without_iter.rs
+++ b/tests/ui/into_iter_without_iter.rs
@@ -1,5 +1,7 @@
 //@no-rustfix
+//@aux-build:proc_macros.rs
 #![warn(clippy::into_iter_without_iter)]
+extern crate proc_macros;
 
 use std::iter::IntoIterator;
 
@@ -111,6 +113,43 @@ impl IntoIterator for &Alias {
     }
 }
 
+// Fine to lint, the impls comes from a local macro.
+pub struct Issue12037;
+macro_rules! generate_impl {
+    () => {
+        impl<'a> IntoIterator for &'a Issue12037 {
+            type IntoIter = std::slice::Iter<'a, u8>;
+            type Item = &'a u8;
+            fn into_iter(self) -> Self::IntoIter {
+                todo!()
+            }
+        }
+    };
+}
+generate_impl!();
+
+// Impl comes from an external crate
+proc_macros::external! {
+    pub struct ImplWithForeignSpan;
+    impl<'a> IntoIterator for &'a ImplWithForeignSpan {
+        type IntoIter = std::slice::Iter<'a, u8>;
+        type Item = &'a u8;
+        fn into_iter(self) -> Self::IntoIter {
+            todo!()
+        }
+    }
+}
+
+pub struct Allowed;
+#[allow(clippy::into_iter_without_iter)]
+impl<'a> IntoIterator for &'a Allowed {
+    type IntoIter = std::slice::Iter<'a, u8>;
+    type Item = &'a u8;
+    fn into_iter(self) -> Self::IntoIter {
+        todo!()
+    }
+}
+
 fn main() {}
 
 pub mod issue11635 {
diff --git a/tests/ui/into_iter_without_iter.stderr b/tests/ui/into_iter_without_iter.stderr
index 70f3f82a936..a232c7cecc5 100644
--- a/tests/ui/into_iter_without_iter.stderr
+++ b/tests/ui/into_iter_without_iter.stderr
@@ -1,5 +1,5 @@
 error: `IntoIterator` implemented for a reference type without an `iter` method
-  --> $DIR/into_iter_without_iter.rs:7:1
+  --> $DIR/into_iter_without_iter.rs:9:1
    |
 LL | / impl<'a> IntoIterator for &'a S1 {
 LL | |
@@ -23,7 +23,7 @@ LL + }
    |
 
 error: `IntoIterator` implemented for a reference type without an `iter_mut` method
-  --> $DIR/into_iter_without_iter.rs:15:1
+  --> $DIR/into_iter_without_iter.rs:17:1
    |
 LL | / impl<'a> IntoIterator for &'a mut S1 {
 LL | |
@@ -45,7 +45,7 @@ LL + }
    |
 
 error: `IntoIterator` implemented for a reference type without an `iter` method
-  --> $DIR/into_iter_without_iter.rs:25:1
+  --> $DIR/into_iter_without_iter.rs:27:1
    |
 LL | / impl<'a, T> IntoIterator for &'a S2<T> {
 LL | |
@@ -67,7 +67,7 @@ LL + }
    |
 
 error: `IntoIterator` implemented for a reference type without an `iter_mut` method
-  --> $DIR/into_iter_without_iter.rs:33:1
+  --> $DIR/into_iter_without_iter.rs:35:1
    |
 LL | / impl<'a, T> IntoIterator for &'a mut S2<T> {
 LL | |
@@ -89,7 +89,7 @@ LL + }
    |
 
 error: `IntoIterator` implemented for a reference type without an `iter_mut` method
-  --> $DIR/into_iter_without_iter.rs:84:1
+  --> $DIR/into_iter_without_iter.rs:86:1
    |
 LL | / impl<'a, T> IntoIterator for &mut S4<'a, T> {
 LL | |
@@ -110,5 +110,31 @@ LL +     }
 LL + }
    |
 
-error: aborting due to 5 previous errors
+error: `IntoIterator` implemented for a reference type without an `iter` method
+  --> $DIR/into_iter_without_iter.rs:120:9
+   |
+LL | /         impl<'a> IntoIterator for &'a Issue12037 {
+LL | |             type IntoIter = std::slice::Iter<'a, u8>;
+LL | |             type Item = &'a u8;
+LL | |             fn into_iter(self) -> Self::IntoIter {
+LL | |                 todo!()
+LL | |             }
+LL | |         }
+   | |_________^
+...
+LL |   generate_impl!();
+   |   ---------------- in this macro invocation
+   |
+   = note: this error originates in the macro `generate_impl` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: consider implementing `iter`
+   |
+LL ~         
+LL + impl Issue12037 {
+LL +     fn iter(&self) -> std::slice::Iter<'a, u8> {
+LL +         <&Self as IntoIterator>::into_iter(self)
+LL +     }
+LL + }
+   |
+
+error: aborting due to 6 previous errors
 
diff --git a/tests/ui/iter_without_into_iter.rs b/tests/ui/iter_without_into_iter.rs
index 29f526b455c..3054d848efb 100644
--- a/tests/ui/iter_without_into_iter.rs
+++ b/tests/ui/iter_without_into_iter.rs
@@ -1,5 +1,7 @@
 //@no-rustfix
+//@aux-build:proc_macros.rs
 #![warn(clippy::iter_without_into_iter)]
+extern crate proc_macros;
 
 pub struct S1;
 impl S1 {
@@ -121,4 +123,33 @@ impl S12 {
     }
 }
 
+pub struct Issue12037;
+macro_rules! generate_impl {
+    () => {
+        impl Issue12037 {
+            fn iter(&self) -> std::slice::Iter<'_, u8> {
+                todo!()
+            }
+        }
+    };
+}
+generate_impl!();
+
+proc_macros::external! {
+    pub struct ImplWithForeignSpan;
+    impl ImplWithForeignSpan {
+        fn iter(&self) -> std::slice::Iter<'_, u8> {
+            todo!()
+        }
+    }
+}
+
+pub struct Allowed;
+impl Allowed {
+    #[allow(clippy::iter_without_into_iter)]
+    pub fn iter(&self) -> std::slice::Iter<'_, u8> {
+        todo!()
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/iter_without_into_iter.stderr b/tests/ui/iter_without_into_iter.stderr
index af5afd47bfc..4cf20e2aa56 100644
--- a/tests/ui/iter_without_into_iter.stderr
+++ b/tests/ui/iter_without_into_iter.stderr
@@ -1,5 +1,5 @@
 error: `iter` method without an `IntoIterator` impl for `&S1`
-  --> $DIR/iter_without_into_iter.rs:6:5
+  --> $DIR/iter_without_into_iter.rs:8:5
    |
 LL | /     pub fn iter(&self) -> std::slice::Iter<'_, u8> {
 LL | |
@@ -22,7 +22,7 @@ LL + }
    |
 
 error: `iter_mut` method without an `IntoIterator` impl for `&mut S1`
-  --> $DIR/iter_without_into_iter.rs:10:5
+  --> $DIR/iter_without_into_iter.rs:12:5
    |
 LL | /     pub fn iter_mut(&mut self) -> std::slice::IterMut<'_, u8> {
 LL | |
@@ -43,7 +43,7 @@ LL + }
    |
 
 error: `iter` method without an `IntoIterator` impl for `&S3<'a>`
-  --> $DIR/iter_without_into_iter.rs:26:5
+  --> $DIR/iter_without_into_iter.rs:28:5
    |
 LL | /     pub fn iter(&self) -> std::slice::Iter<'_, u8> {
 LL | |
@@ -64,7 +64,7 @@ LL + }
    |
 
 error: `iter_mut` method without an `IntoIterator` impl for `&mut S3<'a>`
-  --> $DIR/iter_without_into_iter.rs:30:5
+  --> $DIR/iter_without_into_iter.rs:32:5
    |
 LL | /     pub fn iter_mut(&mut self) -> std::slice::IterMut<'_, u8> {
 LL | |
@@ -85,7 +85,7 @@ LL + }
    |
 
 error: `iter` method without an `IntoIterator` impl for `&S8<T>`
-  --> $DIR/iter_without_into_iter.rs:67:5
+  --> $DIR/iter_without_into_iter.rs:69:5
    |
 LL | /     pub fn iter(&self) -> std::slice::Iter<'static, T> {
 LL | |         todo!()
@@ -105,7 +105,7 @@ LL + }
    |
 
 error: `iter` method without an `IntoIterator` impl for `&S9<T>`
-  --> $DIR/iter_without_into_iter.rs:75:5
+  --> $DIR/iter_without_into_iter.rs:77:5
    |
 LL | /     pub fn iter(&self) -> std::slice::Iter<'_, T> {
 LL | |
@@ -126,7 +126,7 @@ LL + }
    |
 
 error: `iter_mut` method without an `IntoIterator` impl for `&mut S9<T>`
-  --> $DIR/iter_without_into_iter.rs:79:5
+  --> $DIR/iter_without_into_iter.rs:81:5
    |
 LL | /     pub fn iter_mut(&mut self) -> std::slice::IterMut<'_, T> {
 LL | |
@@ -146,5 +146,29 @@ LL +     }
 LL + }
    |
 
-error: aborting due to 7 previous errors
+error: `iter` method without an `IntoIterator` impl for `&Issue12037`
+  --> $DIR/iter_without_into_iter.rs:130:13
+   |
+LL | /             fn iter(&self) -> std::slice::Iter<'_, u8> {
+LL | |                 todo!()
+LL | |             }
+   | |_____________^
+...
+LL |   generate_impl!();
+   |   ---------------- in this macro invocation
+   |
+   = note: this error originates in the macro `generate_impl` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: consider implementing `IntoIterator` for `&Issue12037`
+   |
+LL ~         
+LL + impl IntoIterator for &Issue12037 {
+LL +     type IntoIter = std::slice::Iter<'_, u8>;
+LL +     type Item = &u8;
+LL +     fn into_iter(self) -> Self::IntoIter {
+LL +         self.iter()
+LL +     }
+LL + }
+   |
+
+error: aborting due to 8 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From c2b3f5c767e69a3788efb01633ae53f6adfcd6dd Mon Sep 17 00:00:00 2001
From: Quinn Sinclair <me@partiallytyped.dev>
Date: Sat, 30 Dec 2023 13:25:33 +0200
Subject: `identity_op` correctly suggests a deference for coerced references

When `identity_op` identifies a `no_op`, provides a suggestion, it also
checks the type of the type of the variable. If the variable is
a reference that's been coerced into a value, e.g.

```
let x = &0i32;
let _ = x + 0;
```

the suggestion will now use a derefence. This is done by identifying
whether the variable is a reference to an integral value, and then
whether it gets dereferenced.

changelog: false positive: [`identity_op`]: corrected suggestion for
reference coerced to value.

fixes: #12050
---
 clippy_lints/src/operators/identity_op.rs | 208 ++++++++++++++++++------------
 tests/ui/identity_op.fixed                |  94 +++++++++++++-
 tests/ui/identity_op.rs                   |  94 +++++++++++++-
 tests/ui/identity_op.stderr               | 154 ++++++++++++++++------
 4 files changed, 426 insertions(+), 124 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/operators/identity_op.rs b/clippy_lints/src/operators/identity_op.rs
index 8ecb038627f..f671517c134 100644
--- a/clippy_lints/src/operators/identity_op.rs
+++ b/clippy_lints/src/operators/identity_op.rs
@@ -18,82 +18,118 @@ pub(crate) fn check<'tcx>(
     right: &'tcx Expr<'_>,
 ) {
     if !is_allowed(cx, op, left, right) {
-        match op {
-            BinOpKind::Add | BinOpKind::BitOr | BinOpKind::BitXor => {
-                check_op(
-                    cx,
-                    left,
-                    0,
-                    expr.span,
-                    peel_hir_expr_refs(right).0.span,
-                    needs_parenthesis(cx, expr, right),
-                );
-                check_op(
-                    cx,
-                    right,
-                    0,
-                    expr.span,
-                    peel_hir_expr_refs(left).0.span,
-                    Parens::Unneeded,
-                );
-            },
-            BinOpKind::Shl | BinOpKind::Shr | BinOpKind::Sub => {
-                check_op(
-                    cx,
-                    right,
-                    0,
-                    expr.span,
-                    peel_hir_expr_refs(left).0.span,
-                    Parens::Unneeded,
-                );
-            },
-            BinOpKind::Mul => {
-                check_op(
-                    cx,
-                    left,
-                    1,
-                    expr.span,
-                    peel_hir_expr_refs(right).0.span,
-                    needs_parenthesis(cx, expr, right),
-                );
-                check_op(
-                    cx,
-                    right,
-                    1,
-                    expr.span,
-                    peel_hir_expr_refs(left).0.span,
-                    Parens::Unneeded,
-                );
-            },
-            BinOpKind::Div => check_op(
+        return;
+    }
+
+    // we need to know whether a ref is coerced to a value
+    // if a ref is coerced, then the suggested lint must deref it
+    // e.g. `let _: i32 = x+0` with `x: &i32` should be replaced with `let _: i32 = *x`.
+    // we do this by checking the _kind_ of the type of the expression
+    // if it's a ref, we then check whether it is erased, and that's it.
+    let (peeled_left_span, left_is_coerced_to_value) = {
+        let expr = peel_hir_expr_refs(left).0;
+        let span = expr.span;
+        let is_coerced = expr_is_erased_ref(cx, expr);
+        (span, is_coerced)
+    };
+
+    let (peeled_right_span, right_is_coerced_to_value) = {
+        let expr = peel_hir_expr_refs(right).0;
+        let span = expr.span;
+        let is_coerced = expr_is_erased_ref(cx, expr);
+        (span, is_coerced)
+    };
+
+    match op {
+        BinOpKind::Add | BinOpKind::BitOr | BinOpKind::BitXor => {
+            check_op(
+                cx,
+                left,
+                0,
+                expr.span,
+                peeled_right_span,
+                needs_parenthesis(cx, expr, right),
+                right_is_coerced_to_value,
+            );
+            check_op(
+                cx,
+                right,
+                0,
+                expr.span,
+                peeled_left_span,
+                Parens::Unneeded,
+                left_is_coerced_to_value,
+            );
+        },
+        BinOpKind::Shl | BinOpKind::Shr | BinOpKind::Sub => {
+            check_op(
+                cx,
+                right,
+                0,
+                expr.span,
+                peeled_left_span,
+                Parens::Unneeded,
+                left_is_coerced_to_value,
+            );
+        },
+        BinOpKind::Mul => {
+            check_op(
+                cx,
+                left,
+                1,
+                expr.span,
+                peeled_right_span,
+                needs_parenthesis(cx, expr, right),
+                right_is_coerced_to_value,
+            );
+            check_op(
                 cx,
                 right,
                 1,
                 expr.span,
-                peel_hir_expr_refs(left).0.span,
+                peeled_left_span,
                 Parens::Unneeded,
-            ),
-            BinOpKind::BitAnd => {
-                check_op(
-                    cx,
-                    left,
-                    -1,
-                    expr.span,
-                    peel_hir_expr_refs(right).0.span,
-                    needs_parenthesis(cx, expr, right),
-                );
-                check_op(
-                    cx,
-                    right,
-                    -1,
-                    expr.span,
-                    peel_hir_expr_refs(left).0.span,
-                    Parens::Unneeded,
-                );
-            },
-            BinOpKind::Rem => check_remainder(cx, left, right, expr.span, left.span),
-            _ => (),
-        }
+                left_is_coerced_to_value,
+            );
+        },
+        BinOpKind::Div => check_op(
+            cx,
+            right,
+            1,
+            expr.span,
+            peeled_left_span,
+            Parens::Unneeded,
+            left_is_coerced_to_value,
+        ),
+        BinOpKind::BitAnd => {
+            check_op(
+                cx,
+                left,
+                -1,
+                expr.span,
+                peeled_right_span,
+                needs_parenthesis(cx, expr, right),
+                right_is_coerced_to_value,
+            );
+            check_op(
+                cx,
+                right,
+                -1,
+                expr.span,
+                peeled_left_span,
+                Parens::Unneeded,
+                left_is_coerced_to_value,
+            );
+        },
+        BinOpKind::Rem => check_remainder(cx, left, right, expr.span, left.span),
+        _ => (),
+    }
+}
+
+fn expr_is_erased_ref(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+    match cx.typeck_results().expr_ty(expr).kind() {
+        ty::Ref(r, ..) => r.is_erased(),
+        _ => false,
     }
 }
 
@@ -144,11 +180,11 @@ fn needs_parenthesis(cx: &LateContext<'_>, binary: &Expr<'_>, right: &Expr<'_>)
 }
 
 fn is_allowed(cx: &LateContext<'_>, cmp: BinOpKind, left: &Expr<'_>, right: &Expr<'_>) -> bool {
-    // This lint applies to integers
-    !cx.typeck_results().expr_ty(left).peel_refs().is_integral()
-        || !cx.typeck_results().expr_ty(right).peel_refs().is_integral()
+    // This lint applies to integers and their references
+    cx.typeck_results().expr_ty(left).peel_refs().is_integral()
+        && cx.typeck_results().expr_ty(right).peel_refs().is_integral()
         // `1 << 0` is a common pattern in bit manipulation code
-        || (cmp == BinOpKind::Shl
+        && !(cmp == BinOpKind::Shl
             && constant_simple(cx, cx.typeck_results(), right) == Some(Constant::Int(0))
             && constant_simple(cx, cx.typeck_results(), left) == Some(Constant::Int(1)))
 }
@@ -161,11 +197,11 @@ fn check_remainder(cx: &LateContext<'_>, left: &Expr<'_>, right: &Expr<'_>, span
         (Some(FullInt::U(lv)), Some(FullInt::U(rv))) => lv < rv,
         _ => return,
     } {
-        span_ineffective_operation(cx, span, arg, Parens::Unneeded);
+        span_ineffective_operation(cx, span, arg, Parens::Unneeded, false);
     }
 }
 
-fn check_op(cx: &LateContext<'_>, e: &Expr<'_>, m: i8, span: Span, arg: Span, parens: Parens) {
+fn check_op(cx: &LateContext<'_>, e: &Expr<'_>, m: i8, span: Span, arg: Span, parens: Parens, is_erased: bool) {
     if let Some(Constant::Int(v)) = constant_simple(cx, cx.typeck_results(), e).map(Constant::peel_refs) {
         let check = match *cx.typeck_results().expr_ty(e).peel_refs().kind() {
             ty::Int(ity) => unsext(cx.tcx, -1_i128, ity),
@@ -178,18 +214,28 @@ fn check_op(cx: &LateContext<'_>, e: &Expr<'_>, m: i8, span: Span, arg: Span, pa
             1 => v == 1,
             _ => unreachable!(),
         } {
-            span_ineffective_operation(cx, span, arg, parens);
+            span_ineffective_operation(cx, span, arg, parens, is_erased);
         }
     }
 }
 
-fn span_ineffective_operation(cx: &LateContext<'_>, span: Span, arg: Span, parens: Parens) {
+fn span_ineffective_operation(
+    cx: &LateContext<'_>,
+    span: Span,
+    arg: Span,
+    parens: Parens,
+    is_ref_coerced_to_val: bool,
+) {
     let mut applicability = Applicability::MachineApplicable;
     let expr_snippet = snippet_with_applicability(cx, arg, "..", &mut applicability);
-
+    let expr_snippet = if is_ref_coerced_to_val {
+        format!("*{expr_snippet}")
+    } else {
+        expr_snippet.into_owned()
+    };
     let suggestion = match parens {
         Parens::Needed => format!("({expr_snippet})"),
-        Parens::Unneeded => expr_snippet.into_owned(),
+        Parens::Unneeded => expr_snippet,
     };
 
     span_lint_and_sugg(
diff --git a/tests/ui/identity_op.fixed b/tests/ui/identity_op.fixed
index f3b4b1fffa0..660e9a21b18 100644
--- a/tests/ui/identity_op.fixed
+++ b/tests/ui/identity_op.fixed
@@ -6,7 +6,9 @@
     clippy::unnecessary_operation,
     clippy::op_ref,
     clippy::double_parens,
-    clippy::uninlined_format_args
+    clippy::uninlined_format_args,
+    clippy::borrow_deref_ref,
+    clippy::deref_addrof
 )]
 
 use std::fmt::Write as _;
@@ -40,32 +42,45 @@ fn main() {
     let x = 0;
 
     x;
+    //~^ ERROR: this operation has no effect
     x;
+    //~^ ERROR: this operation has no effect
     x + 1;
     x;
+    //~^ ERROR: this operation has no effect
     1 + x;
     x - ZERO; //no error, as we skip lookups (for now)
     x;
+    //~^ ERROR: this operation has no effect
     ((ZERO)) | x; //no error, as we skip lookups (for now)
 
     x;
+    //~^ ERROR: this operation has no effect
     x;
+    //~^ ERROR: this operation has no effect
     x / ONE; //no error, as we skip lookups (for now)
 
     x / 2; //no false positive
 
     x & NEG_ONE; //no error, as we skip lookups (for now)
     x;
+    //~^ ERROR: this operation has no effect
 
     let u: u8 = 0;
     u;
+    //~^ ERROR: this operation has no effect
 
     1 << 0; // no error, this case is allowed, see issue 3430
     42;
+    //~^ ERROR: this operation has no effect
     1;
+    //~^ ERROR: this operation has no effect
     42;
+    //~^ ERROR: this operation has no effect
     x;
+    //~^ ERROR: this operation has no effect
     x;
+    //~^ ERROR: this operation has no effect
 
     let mut a = A(String::new());
     let b = a << 0; // no error: non-integer
@@ -73,10 +88,15 @@ fn main() {
     1 * Meter; // no error: non-integer
 
     2;
+    //~^ ERROR: this operation has no effect
     -2;
+    //~^ ERROR: this operation has no effect
     2 + x;
+    //~^ ERROR: this operation has no effect
     -2 + x;
+    //~^ ERROR: this operation has no effect
     x + 1;
+    //~^ ERROR: this operation has no effect
     (x + 1) % 3; // no error
     4 % 3; // no error
     4 % -3; // no error
@@ -85,38 +105,110 @@ fn main() {
     let a = 0;
     let b = true;
     (if b { 1 } else { 2 });
+    //~^ ERROR: this operation has no effect
     (if b { 1 } else { 2 }) + if b { 3 } else { 4 };
+    //~^ ERROR: this operation has no effect
     (match a { 0 => 10, _ => 20 });
+    //~^ ERROR: this operation has no effect
     (match a { 0 => 10, _ => 20 }) + match a { 0 => 30, _ => 40 };
+    //~^ ERROR: this operation has no effect
     (if b { 1 } else { 2 }) + match a { 0 => 30, _ => 40 };
+    //~^ ERROR: this operation has no effect
     (match a { 0 => 10, _ => 20 }) + if b { 3 } else { 4 };
+    //~^ ERROR: this operation has no effect
     (if b { 1 } else { 2 });
+    //~^ ERROR: this operation has no effect
 
     ({ a }) + 3;
+    //~^ ERROR: this operation has no effect
     ({ a } * 2);
+    //~^ ERROR: this operation has no effect
     (loop { let mut c = 0; if c == 10 { break c; } c += 1; }) + { a * 2 };
+    //~^ ERROR: this operation has no effect
 
     fn f(_: i32) {
         todo!();
     }
+
     f(a + { 8 * 5 });
+    //~^ ERROR: this operation has no effect
     f(if b { 1 } else { 2 } + 3);
+    //~^ ERROR: this operation has no effect
+    
     const _: i32 = { 2 * 4 } + 3;
+    //~^ ERROR: this operation has no effect
     const _: i32 = { 1 + 2 * 3 } + 3;
+    //~^ ERROR: this operation has no effect
 
     a as usize;
+    //~^ ERROR: this operation has no effect
     let _ = a as usize;
+    //~^ ERROR: this operation has no effect
     ({ a } as usize);
+    //~^ ERROR: this operation has no effect
 
     2 * { a };
+    //~^ ERROR: this operation has no effect
     (({ a } + 4));
+    //~^ ERROR: this operation has no effect
     1;
+    //~^ ERROR: this operation has no effect
 
     // Issue #9904
     let x = 0i32;
     let _: i32 = x;
+    //~^ ERROR: this operation has no effect
 }
 
 pub fn decide(a: bool, b: bool) -> u32 {
     (if a { 1 } else { 2 }) + if b { 3 } else { 5 }
 }
+
+/// The following tests are from / for issue #12050
+/// In short, the lint didn't work for coerced references,
+/// e.g. let x = &0; let y = x + 0;
+/// because the suggested fix was `let y = x;` but
+/// it should have been `let y = *x;`
+fn issue_12050() {
+    {
+        let x = &0i32;
+        let _: i32 = *x;
+        //~^ ERROR: this operation has no effect
+        let _: i32 = *x;
+        //~^ ERROR: this operation has no effect
+    }
+    {
+        let x = &&0i32;
+        let _: i32 = **x;
+        //~^ ERROR: this operation has no effect
+        let x = &&0i32;
+        let _: i32 = **x;
+        //~^ ERROR: this operation has no effect
+    }
+    {
+        // this is just silly
+        let x = &&&0i32;
+        let _: i32 = ***x;
+        //~^ ERROR: this operation has no effect
+        let _: i32 = ***x;
+        //~^ ERROR: this operation has no effect
+        let x = 0i32;
+        let _: i32 = *&x;
+        //~^ ERROR: this operation has no effect
+        let _: i32 = **&&x;
+        //~^ ERROR: this operation has no effect
+        let _: i32 = *&*&x;
+        //~^ ERROR: this operation has no effect
+        let _: i32 = **&&*&x;
+        //~^ ERROR: this operation has no effect
+    }
+    {
+        // this is getting ridiculous, but we should still see the same
+        // error message so let's just keep going
+        let x = &0i32;
+        let _: i32 = ***&&*&x;
+        //~^ ERROR: this operation has no effect
+        let _: i32 = ***&&*&x;
+        //~^ ERROR: this operation has no effect
+    }
+}
diff --git a/tests/ui/identity_op.rs b/tests/ui/identity_op.rs
index 631aa3b0215..bbef531e9dc 100644
--- a/tests/ui/identity_op.rs
+++ b/tests/ui/identity_op.rs
@@ -6,7 +6,9 @@
     clippy::unnecessary_operation,
     clippy::op_ref,
     clippy::double_parens,
-    clippy::uninlined_format_args
+    clippy::uninlined_format_args,
+    clippy::borrow_deref_ref,
+    clippy::deref_addrof
 )]
 
 use std::fmt::Write as _;
@@ -40,32 +42,45 @@ fn main() {
     let x = 0;
 
     x + 0;
+    //~^ ERROR: this operation has no effect
     x + (1 - 1);
+    //~^ ERROR: this operation has no effect
     x + 1;
     0 + x;
+    //~^ ERROR: this operation has no effect
     1 + x;
     x - ZERO; //no error, as we skip lookups (for now)
     x | (0);
+    //~^ ERROR: this operation has no effect
     ((ZERO)) | x; //no error, as we skip lookups (for now)
 
     x * 1;
+    //~^ ERROR: this operation has no effect
     1 * x;
+    //~^ ERROR: this operation has no effect
     x / ONE; //no error, as we skip lookups (for now)
 
     x / 2; //no false positive
 
     x & NEG_ONE; //no error, as we skip lookups (for now)
     -1 & x;
+    //~^ ERROR: this operation has no effect
 
     let u: u8 = 0;
     u & 255;
+    //~^ ERROR: this operation has no effect
 
     1 << 0; // no error, this case is allowed, see issue 3430
     42 << 0;
+    //~^ ERROR: this operation has no effect
     1 >> 0;
+    //~^ ERROR: this operation has no effect
     42 >> 0;
+    //~^ ERROR: this operation has no effect
     &x >> 0;
+    //~^ ERROR: this operation has no effect
     x >> &0;
+    //~^ ERROR: this operation has no effect
 
     let mut a = A(String::new());
     let b = a << 0; // no error: non-integer
@@ -73,10 +88,15 @@ fn main() {
     1 * Meter; // no error: non-integer
 
     2 % 3;
+    //~^ ERROR: this operation has no effect
     -2 % 3;
+    //~^ ERROR: this operation has no effect
     2 % -3 + x;
+    //~^ ERROR: this operation has no effect
     -2 % -3 + x;
+    //~^ ERROR: this operation has no effect
     x + 1 % 3;
+    //~^ ERROR: this operation has no effect
     (x + 1) % 3; // no error
     4 % 3; // no error
     4 % -3; // no error
@@ -85,38 +105,110 @@ fn main() {
     let a = 0;
     let b = true;
     0 + if b { 1 } else { 2 };
+    //~^ ERROR: this operation has no effect
     0 + if b { 1 } else { 2 } + if b { 3 } else { 4 };
+    //~^ ERROR: this operation has no effect
     0 + match a { 0 => 10, _ => 20 };
+    //~^ ERROR: this operation has no effect
     0 + match a { 0 => 10, _ => 20 } + match a { 0 => 30, _ => 40 };
+    //~^ ERROR: this operation has no effect
     0 + if b { 1 } else { 2 } + match a { 0 => 30, _ => 40 };
+    //~^ ERROR: this operation has no effect
     0 + match a { 0 => 10, _ => 20 } + if b { 3 } else { 4 };
+    //~^ ERROR: this operation has no effect
     (if b { 1 } else { 2 }) + 0;
+    //~^ ERROR: this operation has no effect
 
     0 + { a } + 3;
+    //~^ ERROR: this operation has no effect
     0 + { a } * 2;
+    //~^ ERROR: this operation has no effect
     0 + loop { let mut c = 0; if c == 10 { break c; } c += 1; } + { a * 2 };
+    //~^ ERROR: this operation has no effect
 
     fn f(_: i32) {
         todo!();
     }
+
     f(1 * a + { 8 * 5 });
+    //~^ ERROR: this operation has no effect
     f(0 + if b { 1 } else { 2 } + 3);
+    //~^ ERROR: this operation has no effect
+    
     const _: i32 = { 2 * 4 } + 0 + 3;
+    //~^ ERROR: this operation has no effect
     const _: i32 = 0 + { 1 + 2 * 3 } + 3;
+    //~^ ERROR: this operation has no effect
 
     0 + a as usize;
+    //~^ ERROR: this operation has no effect
     let _ = 0 + a as usize;
+    //~^ ERROR: this operation has no effect
     0 + { a } as usize;
+    //~^ ERROR: this operation has no effect
 
     2 * (0 + { a });
+    //~^ ERROR: this operation has no effect
     1 * ({ a } + 4);
+    //~^ ERROR: this operation has no effect
     1 * 1;
+    //~^ ERROR: this operation has no effect
 
     // Issue #9904
     let x = 0i32;
     let _: i32 = &x + 0;
+    //~^ ERROR: this operation has no effect
 }
 
 pub fn decide(a: bool, b: bool) -> u32 {
     0 + if a { 1 } else { 2 } + if b { 3 } else { 5 }
 }
+
+/// The following tests are from / for issue #12050
+/// In short, the lint didn't work for coerced references,
+/// e.g. let x = &0; let y = x + 0;
+/// because the suggested fix was `let y = x;` but
+/// it should have been `let y = *x;`
+fn issue_12050() {
+    {
+        let x = &0i32;
+        let _: i32 = *x + 0;
+        //~^ ERROR: this operation has no effect
+        let _: i32 = x + 0;
+        //~^ ERROR: this operation has no effect
+    }
+    {
+        let x = &&0i32;
+        let _: i32 = **x + 0;
+        //~^ ERROR: this operation has no effect
+        let x = &&0i32;
+        let _: i32 = *x + 0;
+        //~^ ERROR: this operation has no effect
+    }
+    {
+        // this is just silly
+        let x = &&&0i32;
+        let _: i32 = ***x + 0;
+        //~^ ERROR: this operation has no effect
+        let _: i32 = **x + 0;
+        //~^ ERROR: this operation has no effect
+        let x = 0i32;
+        let _: i32 = *&x + 0;
+        //~^ ERROR: this operation has no effect
+        let _: i32 = **&&x + 0;
+        //~^ ERROR: this operation has no effect
+        let _: i32 = *&*&x + 0;
+        //~^ ERROR: this operation has no effect
+        let _: i32 = **&&*&x + 0;
+        //~^ ERROR: this operation has no effect
+    }
+    {
+        // this is getting ridiculous, but we should still see the same
+        // error message so let's just keep going
+        let x = &0i32;
+        let _: i32 = **&&*&x + 0;
+        //~^ ERROR: this operation has no effect
+        let _: i32 = **&&*&x + 0;
+        //~^ ERROR: this operation has no effect
+    }
+}
diff --git a/tests/ui/identity_op.stderr b/tests/ui/identity_op.stderr
index 2a61327f15f..6bb980035c1 100644
--- a/tests/ui/identity_op.stderr
+++ b/tests/ui/identity_op.stderr
@@ -1,5 +1,5 @@
 error: this operation has no effect
-  --> $DIR/identity_op.rs:42:5
+  --> $DIR/identity_op.rs:44:5
    |
 LL |     x + 0;
    |     ^^^^^ help: consider reducing it to: `x`
@@ -8,238 +8,310 @@ LL |     x + 0;
    = help: to override `-D warnings` add `#[allow(clippy::identity_op)]`
 
 error: this operation has no effect
-  --> $DIR/identity_op.rs:43:5
+  --> $DIR/identity_op.rs:46:5
    |
 LL |     x + (1 - 1);
    |     ^^^^^^^^^^^ help: consider reducing it to: `x`
 
 error: this operation has no effect
-  --> $DIR/identity_op.rs:45:5
+  --> $DIR/identity_op.rs:49:5
    |
 LL |     0 + x;
    |     ^^^^^ help: consider reducing it to: `x`
 
 error: this operation has no effect
-  --> $DIR/identity_op.rs:48:5
+  --> $DIR/identity_op.rs:53:5
    |
 LL |     x | (0);
    |     ^^^^^^^ help: consider reducing it to: `x`
 
 error: this operation has no effect
-  --> $DIR/identity_op.rs:51:5
+  --> $DIR/identity_op.rs:57:5
    |
 LL |     x * 1;
    |     ^^^^^ help: consider reducing it to: `x`
 
 error: this operation has no effect
-  --> $DIR/identity_op.rs:52:5
+  --> $DIR/identity_op.rs:59:5
    |
 LL |     1 * x;
    |     ^^^^^ help: consider reducing it to: `x`
 
 error: this operation has no effect
-  --> $DIR/identity_op.rs:58:5
+  --> $DIR/identity_op.rs:66:5
    |
 LL |     -1 & x;
    |     ^^^^^^ help: consider reducing it to: `x`
 
 error: this operation has no effect
-  --> $DIR/identity_op.rs:61:5
+  --> $DIR/identity_op.rs:70:5
    |
 LL |     u & 255;
    |     ^^^^^^^ help: consider reducing it to: `u`
 
 error: this operation has no effect
-  --> $DIR/identity_op.rs:64:5
+  --> $DIR/identity_op.rs:74:5
    |
 LL |     42 << 0;
    |     ^^^^^^^ help: consider reducing it to: `42`
 
 error: this operation has no effect
-  --> $DIR/identity_op.rs:65:5
+  --> $DIR/identity_op.rs:76:5
    |
 LL |     1 >> 0;
    |     ^^^^^^ help: consider reducing it to: `1`
 
 error: this operation has no effect
-  --> $DIR/identity_op.rs:66:5
+  --> $DIR/identity_op.rs:78:5
    |
 LL |     42 >> 0;
    |     ^^^^^^^ help: consider reducing it to: `42`
 
 error: this operation has no effect
-  --> $DIR/identity_op.rs:67:5
+  --> $DIR/identity_op.rs:80:5
    |
 LL |     &x >> 0;
    |     ^^^^^^^ help: consider reducing it to: `x`
 
 error: this operation has no effect
-  --> $DIR/identity_op.rs:68:5
+  --> $DIR/identity_op.rs:82:5
    |
 LL |     x >> &0;
    |     ^^^^^^^ help: consider reducing it to: `x`
 
 error: this operation has no effect
-  --> $DIR/identity_op.rs:75:5
+  --> $DIR/identity_op.rs:90:5
    |
 LL |     2 % 3;
    |     ^^^^^ help: consider reducing it to: `2`
 
 error: this operation has no effect
-  --> $DIR/identity_op.rs:76:5
+  --> $DIR/identity_op.rs:92:5
    |
 LL |     -2 % 3;
    |     ^^^^^^ help: consider reducing it to: `-2`
 
 error: this operation has no effect
-  --> $DIR/identity_op.rs:77:5
+  --> $DIR/identity_op.rs:94:5
    |
 LL |     2 % -3 + x;
    |     ^^^^^^ help: consider reducing it to: `2`
 
 error: this operation has no effect
-  --> $DIR/identity_op.rs:78:5
+  --> $DIR/identity_op.rs:96:5
    |
 LL |     -2 % -3 + x;
    |     ^^^^^^^ help: consider reducing it to: `-2`
 
 error: this operation has no effect
-  --> $DIR/identity_op.rs:79:9
+  --> $DIR/identity_op.rs:98:9
    |
 LL |     x + 1 % 3;
    |         ^^^^^ help: consider reducing it to: `1`
 
 error: this operation has no effect
-  --> $DIR/identity_op.rs:87:5
+  --> $DIR/identity_op.rs:107:5
    |
 LL |     0 + if b { 1 } else { 2 };
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider reducing it to: `(if b { 1 } else { 2 })`
 
 error: this operation has no effect
-  --> $DIR/identity_op.rs:88:5
+  --> $DIR/identity_op.rs:109:5
    |
 LL |     0 + if b { 1 } else { 2 } + if b { 3 } else { 4 };
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider reducing it to: `(if b { 1 } else { 2 })`
 
 error: this operation has no effect
-  --> $DIR/identity_op.rs:89:5
+  --> $DIR/identity_op.rs:111:5
    |
 LL |     0 + match a { 0 => 10, _ => 20 };
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider reducing it to: `(match a { 0 => 10, _ => 20 })`
 
 error: this operation has no effect
-  --> $DIR/identity_op.rs:90:5
+  --> $DIR/identity_op.rs:113:5
    |
 LL |     0 + match a { 0 => 10, _ => 20 } + match a { 0 => 30, _ => 40 };
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider reducing it to: `(match a { 0 => 10, _ => 20 })`
 
 error: this operation has no effect
-  --> $DIR/identity_op.rs:91:5
+  --> $DIR/identity_op.rs:115:5
    |
 LL |     0 + if b { 1 } else { 2 } + match a { 0 => 30, _ => 40 };
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider reducing it to: `(if b { 1 } else { 2 })`
 
 error: this operation has no effect
-  --> $DIR/identity_op.rs:92:5
+  --> $DIR/identity_op.rs:117:5
    |
 LL |     0 + match a { 0 => 10, _ => 20 } + if b { 3 } else { 4 };
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider reducing it to: `(match a { 0 => 10, _ => 20 })`
 
 error: this operation has no effect
-  --> $DIR/identity_op.rs:93:5
+  --> $DIR/identity_op.rs:119:5
    |
 LL |     (if b { 1 } else { 2 }) + 0;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider reducing it to: `(if b { 1 } else { 2 })`
 
 error: this operation has no effect
-  --> $DIR/identity_op.rs:95:5
+  --> $DIR/identity_op.rs:122:5
    |
 LL |     0 + { a } + 3;
    |     ^^^^^^^^^ help: consider reducing it to: `({ a })`
 
 error: this operation has no effect
-  --> $DIR/identity_op.rs:96:5
+  --> $DIR/identity_op.rs:124:5
    |
 LL |     0 + { a } * 2;
    |     ^^^^^^^^^^^^^ help: consider reducing it to: `({ a } * 2)`
 
 error: this operation has no effect
-  --> $DIR/identity_op.rs:97:5
+  --> $DIR/identity_op.rs:126:5
    |
 LL |     0 + loop { let mut c = 0; if c == 10 { break c; } c += 1; } + { a * 2 };
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider reducing it to: `(loop { let mut c = 0; if c == 10 { break c; } c += 1; })`
 
 error: this operation has no effect
-  --> $DIR/identity_op.rs:102:7
+  --> $DIR/identity_op.rs:133:7
    |
 LL |     f(1 * a + { 8 * 5 });
    |       ^^^^^ help: consider reducing it to: `a`
 
 error: this operation has no effect
-  --> $DIR/identity_op.rs:103:7
+  --> $DIR/identity_op.rs:135:7
    |
 LL |     f(0 + if b { 1 } else { 2 } + 3);
    |       ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider reducing it to: `if b { 1 } else { 2 }`
 
 error: this operation has no effect
-  --> $DIR/identity_op.rs:104:20
+  --> $DIR/identity_op.rs:138:20
    |
 LL |     const _: i32 = { 2 * 4 } + 0 + 3;
    |                    ^^^^^^^^^^^^^ help: consider reducing it to: `{ 2 * 4 }`
 
 error: this operation has no effect
-  --> $DIR/identity_op.rs:105:20
+  --> $DIR/identity_op.rs:140:20
    |
 LL |     const _: i32 = 0 + { 1 + 2 * 3 } + 3;
    |                    ^^^^^^^^^^^^^^^^^ help: consider reducing it to: `{ 1 + 2 * 3 }`
 
 error: this operation has no effect
-  --> $DIR/identity_op.rs:107:5
+  --> $DIR/identity_op.rs:143:5
    |
 LL |     0 + a as usize;
    |     ^^^^^^^^^^^^^^ help: consider reducing it to: `a as usize`
 
 error: this operation has no effect
-  --> $DIR/identity_op.rs:108:13
+  --> $DIR/identity_op.rs:145:13
    |
 LL |     let _ = 0 + a as usize;
    |             ^^^^^^^^^^^^^^ help: consider reducing it to: `a as usize`
 
 error: this operation has no effect
-  --> $DIR/identity_op.rs:109:5
+  --> $DIR/identity_op.rs:147:5
    |
 LL |     0 + { a } as usize;
    |     ^^^^^^^^^^^^^^^^^^ help: consider reducing it to: `({ a } as usize)`
 
 error: this operation has no effect
-  --> $DIR/identity_op.rs:111:9
+  --> $DIR/identity_op.rs:150:9
    |
 LL |     2 * (0 + { a });
    |         ^^^^^^^^^^^ help: consider reducing it to: `{ a }`
 
 error: this operation has no effect
-  --> $DIR/identity_op.rs:112:5
+  --> $DIR/identity_op.rs:152:5
    |
 LL |     1 * ({ a } + 4);
    |     ^^^^^^^^^^^^^^^ help: consider reducing it to: `(({ a } + 4))`
 
 error: this operation has no effect
-  --> $DIR/identity_op.rs:113:5
+  --> $DIR/identity_op.rs:154:5
    |
 LL |     1 * 1;
    |     ^^^^^ help: consider reducing it to: `1`
 
 error: this operation has no effect
-  --> $DIR/identity_op.rs:117:18
+  --> $DIR/identity_op.rs:159:18
    |
 LL |     let _: i32 = &x + 0;
    |                  ^^^^^^ help: consider reducing it to: `x`
 
 error: this operation has no effect
-  --> $DIR/identity_op.rs:121:5
+  --> $DIR/identity_op.rs:164:5
    |
 LL |     0 + if a { 1 } else { 2 } + if b { 3 } else { 5 }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider reducing it to: `(if a { 1 } else { 2 })`
 
-error: aborting due to 40 previous errors
+error: this operation has no effect
+  --> $DIR/identity_op.rs:175:22
+   |
+LL |         let _: i32 = *x + 0;
+   |                      ^^^^^^ help: consider reducing it to: `*x`
+
+error: this operation has no effect
+  --> $DIR/identity_op.rs:177:22
+   |
+LL |         let _: i32 = x + 0;
+   |                      ^^^^^ help: consider reducing it to: `*x`
+
+error: this operation has no effect
+  --> $DIR/identity_op.rs:182:22
+   |
+LL |         let _: i32 = **x + 0;
+   |                      ^^^^^^^ help: consider reducing it to: `**x`
+
+error: this operation has no effect
+  --> $DIR/identity_op.rs:185:22
+   |
+LL |         let _: i32 = *x + 0;
+   |                      ^^^^^^ help: consider reducing it to: `**x`
+
+error: this operation has no effect
+  --> $DIR/identity_op.rs:191:22
+   |
+LL |         let _: i32 = ***x + 0;
+   |                      ^^^^^^^^ help: consider reducing it to: `***x`
+
+error: this operation has no effect
+  --> $DIR/identity_op.rs:193:22
+   |
+LL |         let _: i32 = **x + 0;
+   |                      ^^^^^^^ help: consider reducing it to: `***x`
+
+error: this operation has no effect
+  --> $DIR/identity_op.rs:196:22
+   |
+LL |         let _: i32 = *&x + 0;
+   |                      ^^^^^^^ help: consider reducing it to: `*&x`
+
+error: this operation has no effect
+  --> $DIR/identity_op.rs:198:22
+   |
+LL |         let _: i32 = **&&x + 0;
+   |                      ^^^^^^^^^ help: consider reducing it to: `**&&x`
+
+error: this operation has no effect
+  --> $DIR/identity_op.rs:200:22
+   |
+LL |         let _: i32 = *&*&x + 0;
+   |                      ^^^^^^^^^ help: consider reducing it to: `*&*&x`
+
+error: this operation has no effect
+  --> $DIR/identity_op.rs:202:22
+   |
+LL |         let _: i32 = **&&*&x + 0;
+   |                      ^^^^^^^^^^^ help: consider reducing it to: `**&&*&x`
+
+error: this operation has no effect
+  --> $DIR/identity_op.rs:209:22
+   |
+LL |         let _: i32 = **&&*&x + 0;
+   |                      ^^^^^^^^^^^ help: consider reducing it to: `***&&*&x`
+
+error: this operation has no effect
+  --> $DIR/identity_op.rs:211:22
+   |
+LL |         let _: i32 = **&&*&x + 0;
+   |                      ^^^^^^^^^^^ help: consider reducing it to: `***&&*&x`
+
+error: aborting due to 52 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 79e70ccf6f428c5819d6bd0ecf69eedfd99b0a5f Mon Sep 17 00:00:00 2001
From: cocodery <cocodery@outlook.com>
Date: Sat, 30 Dec 2023 23:03:47 +0800
Subject: add setuid, setgid and sticky bits on high 3-bits of 12

---
 clippy_lints/src/non_octal_unix_permissions.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/non_octal_unix_permissions.rs b/clippy_lints/src/non_octal_unix_permissions.rs
index 7143ac9cfc1..12fd63b50f2 100644
--- a/clippy_lints/src/non_octal_unix_permissions.rs
+++ b/clippy_lints/src/non_octal_unix_permissions.rs
@@ -50,7 +50,7 @@ fn check_binary_unix_permissions(lit_kind: &LitKind, snip: &str) -> bool {
 
         let group_sizes: Vec<usize> = num_lit.integer.split('_').map(str::len).collect();
         // check whether is binary format unix permissions
-        if group_sizes.len() != 3 {
+        if group_sizes.len() != 3 && group_sizes.len() != 4 {
             return false;
         }
         group_sizes.iter().all(|len| *len == 3)
-- 
cgit 1.4.1-3-g733a5


From ab2d1c28d5c03ba5b416614257f68fb5243c2a00 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Mon, 18 Dec 2023 16:43:50 +0100
Subject: Extend `UNCONDITIONAL_RECURSION` to check for `ToString`
 implementations

---
 clippy_lints/src/unconditional_recursion.rs | 69 +++++++++++++++++++++++++----
 1 file changed, 60 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unconditional_recursion.rs b/clippy_lints/src/unconditional_recursion.rs
index 570770523eb..4036ad78a56 100644
--- a/clippy_lints/src/unconditional_recursion.rs
+++ b/clippy_lints/src/unconditional_recursion.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::{get_trait_def_id, path_res};
+use clippy_utils::{expr_or_init, get_trait_def_id, path_res};
 use rustc_ast::BinOpKind;
 use rustc_hir::def::Res;
 use rustc_hir::def_id::{DefId, LocalDefId};
@@ -56,13 +56,8 @@ fn is_local(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
     matches!(path_res(cx, expr), Res::Local(_))
 }
 
-fn check_partial_eq(
-    cx: &LateContext<'_>,
-    body: &Body<'_>,
-    method_span: Span,
-    method_def_id: LocalDefId,
-    name: Ident,
-) {
+#[allow(clippy::unnecessary_def_path)]
+fn check_partial_eq(cx: &LateContext<'_>, body: &Body<'_>, method_span: Span, method_def_id: LocalDefId, name: Ident) {
     let args = cx
         .tcx
         .instantiate_bound_regions_with_erased(cx.tcx.fn_sig(method_def_id).skip_binder())
@@ -126,8 +121,62 @@ fn check_partial_eq(
     }
 }
 
+#[allow(clippy::unnecessary_def_path)]
+fn check_to_string(cx: &LateContext<'_>, body: &Body<'_>, method_span: Span, method_def_id: LocalDefId, name: Ident) {
+    let args = cx
+        .tcx
+        .instantiate_bound_regions_with_erased(cx.tcx.fn_sig(method_def_id).skip_binder())
+        .inputs();
+    // That has one argument.
+    if let [_self_arg] = args
+        && let hir_id = cx.tcx.local_def_id_to_hir_id(method_def_id)
+        && let Some((
+            _,
+            Node::Item(Item {
+                kind: ItemKind::Impl(impl_),
+                owner_id,
+                ..
+            }),
+        )) = cx.tcx.hir().parent_iter(hir_id).next()
+        // We exclude `impl` blocks generated from rustc's proc macros.
+        && !cx.tcx.has_attr(*owner_id, sym::automatically_derived)
+        // It is a implementation of a trait.
+        && let Some(trait_) = impl_.of_trait
+        && let Some(trait_def_id) = trait_.trait_def_id()
+        // The trait is `ToString`.
+        && Some(trait_def_id) == get_trait_def_id(cx, &["alloc", "string", "ToString"])
+    {
+        let expr = expr_or_init(cx, body.value.peel_blocks());
+        let is_bad = match expr.kind {
+            ExprKind::MethodCall(segment, receiver, &[arg], _) if segment.ident.name == name.name => {
+                if is_local(cx, receiver)
+                    && is_local(cx, &arg)
+                    && let Some(fn_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id)
+                    && let Some(trait_id) = cx.tcx.trait_of_item(fn_id)
+                    && trait_id == trait_def_id
+                {
+                    true
+                } else {
+                    false
+                }
+            },
+            _ => false,
+        };
+        if is_bad {
+            span_lint_and_then(
+                cx,
+                UNCONDITIONAL_RECURSION,
+                method_span,
+                "function cannot return without recursing",
+                |diag| {
+                    diag.span_note(expr.span, "recursive call site");
+                },
+            );
+        }
+    }
+}
+
 impl<'tcx> LateLintPass<'tcx> for UnconditionalRecursion {
-    #[allow(clippy::unnecessary_def_path)]
     fn check_fn(
         &mut self,
         cx: &LateContext<'tcx>,
@@ -141,6 +190,8 @@ impl<'tcx> LateLintPass<'tcx> for UnconditionalRecursion {
         if let FnKind::Method(name, _) = kind {
             if name.name == sym::eq || name.name == sym::ne {
                 check_partial_eq(cx, body, method_span, method_def_id, name);
+            } else if name.name == sym::to_string {
+                check_to_string(cx, body, method_span, method_def_id, name);
             }
         }
     }
-- 
cgit 1.4.1-3-g733a5


From 5f1718810f18879dfadd597c7ed45e7a8c932a24 Mon Sep 17 00:00:00 2001
From: Aneesh Kadiyala <143342960+ARandomDev99@users.noreply.github.com>
Date: Sat, 30 Dec 2023 22:22:44 +0530
Subject: Change `empty_enum_variants_with_brackets` applicability to
 `MaybeIncorrect`

---
 clippy_lints/src/empty_with_brackets.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/empty_with_brackets.rs b/clippy_lints/src/empty_with_brackets.rs
index 52a88324fc3..969df6d85b5 100644
--- a/clippy_lints/src/empty_with_brackets.rs
+++ b/clippy_lints/src/empty_with_brackets.rs
@@ -97,7 +97,7 @@ impl EarlyLintPass for EmptyWithBrackets {
                         span_after_ident,
                         "remove the brackets",
                         "",
-                        Applicability::MachineApplicable,
+                        Applicability::MaybeIncorrect,
                     );
                 },
             );
-- 
cgit 1.4.1-3-g733a5


From d3bde854c456419a18ca41938dc645dbb307bd6c Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Sat, 30 Dec 2023 17:01:28 +0100
Subject: Fix false positive in `PartialEq` implementation

---
 clippy_lints/src/unconditional_recursion.rs | 60 +++++++++++++++++++----------
 1 file changed, 39 insertions(+), 21 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unconditional_recursion.rs b/clippy_lints/src/unconditional_recursion.rs
index 4036ad78a56..5366b5513d3 100644
--- a/clippy_lints/src/unconditional_recursion.rs
+++ b/clippy_lints/src/unconditional_recursion.rs
@@ -1,15 +1,15 @@
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::{expr_or_init, get_trait_def_id, path_res};
+use clippy_utils::{expr_or_init, get_trait_def_id};
 use rustc_ast::BinOpKind;
-use rustc_hir::def::Res;
 use rustc_hir::def_id::{DefId, LocalDefId};
-use rustc_hir::intravisit::FnKind;
+use rustc_hir::intravisit::{walk_body, FnKind};
 use rustc_hir::{Body, Expr, ExprKind, FnDecl, Item, ItemKind, Node};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{self, Ty};
 use rustc_session::declare_lint_pass;
 use rustc_span::symbol::Ident;
 use rustc_span::{sym, Span};
+use rustc_trait_selection::traits::error_reporting::suggestions::ReturnsVisitor;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -52,12 +52,19 @@ fn get_ty_def_id(ty: Ty<'_>) -> Option<DefId> {
     }
 }
 
-fn is_local(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-    matches!(path_res(cx, expr), Res::Local(_))
+fn has_conditional_return(body: &Body<'_>, expr: &Expr<'_>) -> bool {
+    let mut visitor = ReturnsVisitor::default();
+
+    walk_body(&mut visitor, body);
+    match visitor.returns.as_slice() {
+        [] => false,
+        [return_expr] => return_expr.hir_id != expr.hir_id,
+        _ => true,
+    }
 }
 
 #[allow(clippy::unnecessary_def_path)]
-fn check_partial_eq(cx: &LateContext<'_>, body: &Body<'_>, method_span: Span, method_def_id: LocalDefId, name: Ident) {
+fn check_partial_eq(cx: &LateContext<'_>, method_span: Span, method_def_id: LocalDefId, name: Ident, expr: &Expr<'_>) {
     let args = cx
         .tcx
         .instantiate_bound_regions_with_erased(cx.tcx.fn_sig(method_def_id).skip_binder())
@@ -90,13 +97,23 @@ fn check_partial_eq(cx: &LateContext<'_>, body: &Body<'_>, method_span: Span, me
         } else {
             BinOpKind::Ne
         };
-        let expr = body.value.peel_blocks();
         let is_bad = match expr.kind {
-            ExprKind::Binary(op, left, right) if op.node == to_check_op => is_local(cx, left) && is_local(cx, right),
-            ExprKind::MethodCall(segment, receiver, &[arg], _) if segment.ident.name == name.name => {
-                if is_local(cx, receiver)
-                    && is_local(cx, &arg)
-                    && let Some(fn_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id)
+            ExprKind::Binary(op, left, right) if op.node == to_check_op => {
+                // Then we check if the left-hand element is of the same type as `self`.
+                if let Some(left_ty) = cx.typeck_results().expr_ty_opt(left)
+                    && let Some(left_id) = get_ty_def_id(left_ty)
+                    && self_arg == left_id
+                    && let Some(right_ty) = cx.typeck_results().expr_ty_opt(right)
+                    && let Some(right_id) = get_ty_def_id(right_ty)
+                    && other_arg == right_id
+                {
+                    true
+                } else {
+                    false
+                }
+            },
+            ExprKind::MethodCall(segment, _receiver, &[_arg], _) if segment.ident.name == name.name => {
+                if let Some(fn_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id)
                     && let Some(trait_id) = cx.tcx.trait_of_item(fn_id)
                     && trait_id == trait_def_id
                 {
@@ -122,7 +139,7 @@ fn check_partial_eq(cx: &LateContext<'_>, body: &Body<'_>, method_span: Span, me
 }
 
 #[allow(clippy::unnecessary_def_path)]
-fn check_to_string(cx: &LateContext<'_>, body: &Body<'_>, method_span: Span, method_def_id: LocalDefId, name: Ident) {
+fn check_to_string(cx: &LateContext<'_>, method_span: Span, method_def_id: LocalDefId, name: Ident, expr: &Expr<'_>) {
     let args = cx
         .tcx
         .instantiate_bound_regions_with_erased(cx.tcx.fn_sig(method_def_id).skip_binder())
@@ -146,12 +163,9 @@ fn check_to_string(cx: &LateContext<'_>, body: &Body<'_>, method_span: Span, met
         // The trait is `ToString`.
         && Some(trait_def_id) == get_trait_def_id(cx, &["alloc", "string", "ToString"])
     {
-        let expr = expr_or_init(cx, body.value.peel_blocks());
         let is_bad = match expr.kind {
-            ExprKind::MethodCall(segment, receiver, &[arg], _) if segment.ident.name == name.name => {
-                if is_local(cx, receiver)
-                    && is_local(cx, &arg)
-                    && let Some(fn_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id)
+            ExprKind::MethodCall(segment, _receiver, &[_arg], _) if segment.ident.name == name.name => {
+                if let Some(fn_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id)
                     && let Some(trait_id) = cx.tcx.trait_of_item(fn_id)
                     && trait_id == trait_def_id
                 {
@@ -187,11 +201,15 @@ impl<'tcx> LateLintPass<'tcx> for UnconditionalRecursion {
         method_def_id: LocalDefId,
     ) {
         // If the function is a method...
-        if let FnKind::Method(name, _) = kind {
+        if let FnKind::Method(name, _) = kind
+            && let expr = expr_or_init(cx, body.value).peel_blocks()
+            // Doesn't have a conditional return.
+            && !has_conditional_return(body, expr)
+        {
             if name.name == sym::eq || name.name == sym::ne {
-                check_partial_eq(cx, body, method_span, method_def_id, name);
+                check_partial_eq(cx, method_span, method_def_id, name, expr);
             } else if name.name == sym::to_string {
-                check_to_string(cx, body, method_span, method_def_id, name);
+                check_to_string(cx, method_span, method_def_id, name, expr);
             }
         }
     }
-- 
cgit 1.4.1-3-g733a5


From fe35e08e9f96f9c829add20351b2fbf28faac324 Mon Sep 17 00:00:00 2001
From: Florian Brucker <mail@florianbrucker.de>
Date: Sun, 17 Dec 2023 18:46:49 +0100
Subject: 8733: Suggest `str.lines` when splitting at hard-coded newlines

Adds a new `splitting_strings_at_newlines` lint that suggests to use
`str.lines` instead of splitting a trimmed string at hard-coded
newlines.
---
 CHANGELOG.md                          |   1 +
 clippy_lints/src/declared_lints.rs    |   1 +
 clippy_lints/src/methods/mod.rs       |  35 ++++++++
 clippy_lints/src/methods/str_split.rs |  38 +++++++++
 tests/ui/str_split.fixed              | 145 ++++++++++++++++++++++++++++++++++
 tests/ui/str_split.rs                 | 145 ++++++++++++++++++++++++++++++++++
 tests/ui/str_split.stderr             |  65 +++++++++++++++
 7 files changed, 430 insertions(+)
 create mode 100644 clippy_lints/src/methods/str_split.rs
 create mode 100644 tests/ui/str_split.fixed
 create mode 100644 tests/ui/str_split.rs
 create mode 100644 tests/ui/str_split.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index e4e068f19d4..b9e441029b2 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5583,6 +5583,7 @@ Released 2018-09-13
 [`stable_sort_primitive`]: https://rust-lang.github.io/rust-clippy/master/index.html#stable_sort_primitive
 [`std_instead_of_alloc`]: https://rust-lang.github.io/rust-clippy/master/index.html#std_instead_of_alloc
 [`std_instead_of_core`]: https://rust-lang.github.io/rust-clippy/master/index.html#std_instead_of_core
+[`str_split_at_newline`]: https://rust-lang.github.io/rust-clippy/master/index.html#str_split_at_newline
 [`str_to_string`]: https://rust-lang.github.io/rust-clippy/master/index.html#str_to_string
 [`string_add`]: https://rust-lang.github.io/rust-clippy/master/index.html#string_add
 [`string_add_assign`]: https://rust-lang.github.io/rust-clippy/master/index.html#string_add_assign
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 9ab38dab1e5..02543ae912a 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -435,6 +435,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::methods::STABLE_SORT_PRIMITIVE_INFO,
     crate::methods::STRING_EXTEND_CHARS_INFO,
     crate::methods::STRING_LIT_CHARS_ANY_INFO,
+    crate::methods::STR_SPLIT_AT_NEWLINE_INFO,
     crate::methods::SUSPICIOUS_COMMAND_ARG_SPACE_INFO,
     crate::methods::SUSPICIOUS_MAP_INFO,
     crate::methods::SUSPICIOUS_SPLITN_INFO,
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 0cde17ef5ad..711cad1dcf6 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -94,6 +94,7 @@ mod single_char_pattern;
 mod single_char_push_string;
 mod skip_while_next;
 mod stable_sort_primitive;
+mod str_split;
 mod str_splitn;
 mod string_extend_chars;
 mod string_lit_chars_any;
@@ -3856,6 +3857,36 @@ declare_clippy_lint! {
     "using `.map(f).unwrap_or_default()`, which is more succinctly expressed as `is_some_and(f)` or `is_ok_and(f)`"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    ///
+    /// Checks for usages of `str.trim().split("\n")` and `str.trim().split("\r\n")`.
+    ///
+    /// ### Why is this bad?
+    ///
+    /// Hard-coding the line endings makes the code less compatible. `str.lines` should be used instead.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// "some\ntext\nwith\nnewlines\n".trim().split('\n');
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// "some\ntext\nwith\nnewlines\n".lines();
+    /// ```
+    ///
+    /// ### Known Problems
+    ///
+    /// This lint cannot detect if the split is intentionally restricted to a single type of newline (`"\n"` or
+    /// `"\r\n"`), for example during the parsing of a specific file format in which precisely one newline type is
+    /// valid.
+    /// ```
+    #[clippy::version = "1.76.0"]
+    pub STR_SPLIT_AT_NEWLINE,
+    pedantic,
+    "splitting a trimmed string at hard-coded newlines"
+}
+
 pub struct Methods {
     avoid_breaking_exported_api: bool,
     msrv: Msrv,
@@ -4011,6 +4042,7 @@ impl_lint_pass!(Methods => [
     ITER_FILTER_IS_SOME,
     ITER_FILTER_IS_OK,
     MANUAL_IS_VARIANT_AND,
+    STR_SPLIT_AT_NEWLINE,
 ]);
 
 /// Extracts a method call name, args, and `Span` of the method name.
@@ -4597,6 +4629,9 @@ impl Methods {
                 ("sort_unstable_by", [arg]) => {
                     unnecessary_sort_by::check(cx, expr, recv, arg, true);
                 },
+                ("split", [arg]) => {
+                    str_split::check(cx, expr, recv, arg);
+                },
                 ("splitn" | "rsplitn", [count_arg, pat_arg]) => {
                     if let Some(Constant::Int(count)) = constant(cx, cx.typeck_results(), count_arg) {
                         suspicious_splitn::check(cx, name, expr, recv, count);
diff --git a/clippy_lints/src/methods/str_split.rs b/clippy_lints/src/methods/str_split.rs
new file mode 100644
index 00000000000..3586e11f56a
--- /dev/null
+++ b/clippy_lints/src/methods/str_split.rs
@@ -0,0 +1,38 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet_with_context;
+use clippy_utils::visitors::is_const_evaluatable;
+use rustc_ast::ast::LitKind;
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind};
+use rustc_lint::LateContext;
+
+use super::STR_SPLIT_AT_NEWLINE;
+
+pub(super) fn check<'a>(cx: &LateContext<'a>, expr: &'_ Expr<'_>, split_recv: &'a Expr<'_>, split_arg: &'_ Expr<'_>) {
+    // We're looking for `A.trim().split(B)`, where the adjusted type of `A` is `&str` (e.g. an
+    // expression returning `String`), and `B` is a `Pattern` that hard-codes a newline (either `"\n"`
+    // or `"\r\n"`). There are a lot of ways to specify a pattern, and this lint only checks the most
+    // basic ones: a `'\n'`, `"\n"`, and `"\r\n"`.
+    if let ExprKind::MethodCall(trim_method_name, trim_recv, [], _) = split_recv.kind
+        && trim_method_name.ident.as_str() == "trim"
+        && cx.typeck_results().expr_ty_adjusted(trim_recv).peel_refs().is_str()
+        && !is_const_evaluatable(cx, trim_recv)
+        && let ExprKind::Lit(split_lit) = split_arg.kind
+        && (matches!(split_lit.node, LitKind::Char('\n'))
+            || matches!(split_lit.node, LitKind::Str(sym, _) if (sym.as_str() == "\n" || sym.as_str() == "\r\n")))
+    {
+        let mut app = Applicability::MaybeIncorrect;
+        span_lint_and_sugg(
+            cx,
+            STR_SPLIT_AT_NEWLINE,
+            expr.span,
+            "using `str.trim().split()` with hard-coded newlines",
+            "use `str.lines()` instead",
+            format!(
+                "{}.lines()",
+                snippet_with_context(cx, trim_recv.span, expr.span.ctxt(), "..", &mut app).0
+            ),
+            app,
+        );
+    }
+}
diff --git a/tests/ui/str_split.fixed b/tests/ui/str_split.fixed
new file mode 100644
index 00000000000..4f33241da7a
--- /dev/null
+++ b/tests/ui/str_split.fixed
@@ -0,0 +1,145 @@
+#![warn(clippy::str_split_at_newline)]
+
+use core::str::Split;
+use std::ops::Deref;
+
+struct NotStr<'a> {
+    s: &'a str,
+}
+
+impl<'a> NotStr<'a> {
+    fn trim(&'a self) -> &'a str {
+        self.s
+    }
+}
+
+struct DerefsIntoNotStr<'a> {
+    not_str: &'a NotStr<'a>,
+}
+
+impl<'a> Deref for DerefsIntoNotStr<'a> {
+    type Target = NotStr<'a>;
+
+    fn deref(&self) -> &Self::Target {
+        self.not_str
+    }
+}
+
+struct DerefsIntoStr<'a> {
+    s: &'a str,
+}
+
+impl<'a> Deref for DerefsIntoStr<'a> {
+    type Target = str;
+
+    fn deref(&self) -> &Self::Target {
+        self.s
+    }
+}
+
+macro_rules! trim_split {
+    ( $x:expr, $y:expr ) => {
+        $x.trim().split($y);
+    };
+}
+
+macro_rules! make_str {
+    ( $x: expr ) => {
+        format!("x={}", $x)
+    };
+}
+
+fn main() {
+    let s1 = "hello\nworld\n";
+    let s2 = s1.to_owned();
+
+    // CASES THAT SHOULD EMIT A LINT
+
+    // Splitting a `str` variable at "\n" or "\r\n" after trimming should warn
+    let _ = s1.lines();
+    #[allow(clippy::single_char_pattern)]
+    let _ = s1.lines();
+    let _ = s1.lines();
+
+    // Splitting a `String` variable at "\n" or "\r\n" after trimming should warn
+    let _ = s2.lines();
+    #[allow(clippy::single_char_pattern)]
+    let _ = s2.lines();
+    let _ = s2.lines();
+
+    // Splitting a variable that derefs into `str` at "\n" or "\r\n" after trimming should warn.
+    let s3 = DerefsIntoStr { s: s1 };
+    let _ = s3.lines();
+    #[allow(clippy::single_char_pattern)]
+    let _ = s3.lines();
+    let _ = s3.lines();
+
+    // If the `&str` is generated by a macro then the macro should not be expanded in the suggested fix.
+    let _ = make_str!(s1).lines();
+
+    // CASES THAT SHOULD NOT EMIT A LINT
+
+    // Splitting a `str` constant at "\n" or "\r\n" after trimming should not warn
+    let _ = "hello\nworld\n".trim().split('\n');
+    #[allow(clippy::single_char_pattern)]
+    let _ = "hello\nworld\n".trim().split("\n");
+    let _ = "hello\nworld\n".trim().split("\r\n");
+
+    // Splitting a `str` variable at "\n" or "\r\n" without trimming should not warn, since it is not
+    // equivalent
+    let _ = s1.split('\n');
+    #[allow(clippy::single_char_pattern)]
+    let _ = s1.split("\n");
+    let _ = s1.split("\r\n");
+
+    // Splitting a `String` variable at "\n" or "\r\n" without trimming should not warn.
+    let _ = s2.split('\n');
+    #[allow(clippy::single_char_pattern)]
+    let _ = s2.split("\n");
+
+    // Splitting a variable that derefs into `str` at "\n" or "\r\n" without trimming should not warn.
+    let _ = s3.split('\n');
+    #[allow(clippy::single_char_pattern)]
+    let _ = s3.split("\n");
+    let _ = s3.split("\r\n");
+    let _ = s2.split("\r\n");
+
+    // Splitting a `str` variable at other separators should not warn
+    let _ = s1.trim().split('\r');
+    #[allow(clippy::single_char_pattern)]
+    let _ = s1.trim().split("\r");
+    let _ = s1.trim().split("\n\r");
+    let _ = s1.trim().split("\r \n");
+
+    // Splitting a `String` variable at other separators should not warn
+    let _ = s2.trim().split('\r');
+    #[allow(clippy::single_char_pattern)]
+    let _ = s2.trim().split("\r");
+    let _ = s2.trim().split("\n\r");
+
+    // Splitting a variable that derefs into `str` at other separators should not warn
+    let _ = s3.trim().split('\r');
+    #[allow(clippy::single_char_pattern)]
+    let _ = s3.trim().split("\r");
+    let _ = s3.trim().split("\n\r");
+    let _ = s3.trim().split("\r \n");
+    let _ = s2.trim().split("\r \n");
+
+    // Using `trim` and `split` on other types should not warn
+    let not_str = NotStr { s: s1 };
+    let _ = not_str.trim().split('\n');
+    #[allow(clippy::single_char_pattern)]
+    let _ = not_str.trim().split("\n");
+    let _ = not_str.trim().split("\r\n");
+    let derefs_into_not_str = DerefsIntoNotStr { not_str: &not_str };
+    let _ = derefs_into_not_str.trim().split('\n');
+    #[allow(clippy::single_char_pattern)]
+    let _ = derefs_into_not_str.trim().split("\n");
+    let _ = derefs_into_not_str.trim().split("\r\n");
+
+    // Code generated by macros should not create a warning
+    trim_split!(s1, "\r\n");
+    trim_split!("hello\nworld\n", "\r\n");
+    trim_split!(s2, "\r\n");
+    trim_split!(s3, "\r\n");
+}
diff --git a/tests/ui/str_split.rs b/tests/ui/str_split.rs
new file mode 100644
index 00000000000..f24caa61c30
--- /dev/null
+++ b/tests/ui/str_split.rs
@@ -0,0 +1,145 @@
+#![warn(clippy::str_split_at_newline)]
+
+use core::str::Split;
+use std::ops::Deref;
+
+struct NotStr<'a> {
+    s: &'a str,
+}
+
+impl<'a> NotStr<'a> {
+    fn trim(&'a self) -> &'a str {
+        self.s
+    }
+}
+
+struct DerefsIntoNotStr<'a> {
+    not_str: &'a NotStr<'a>,
+}
+
+impl<'a> Deref for DerefsIntoNotStr<'a> {
+    type Target = NotStr<'a>;
+
+    fn deref(&self) -> &Self::Target {
+        self.not_str
+    }
+}
+
+struct DerefsIntoStr<'a> {
+    s: &'a str,
+}
+
+impl<'a> Deref for DerefsIntoStr<'a> {
+    type Target = str;
+
+    fn deref(&self) -> &Self::Target {
+        self.s
+    }
+}
+
+macro_rules! trim_split {
+    ( $x:expr, $y:expr ) => {
+        $x.trim().split($y);
+    };
+}
+
+macro_rules! make_str {
+    ( $x: expr ) => {
+        format!("x={}", $x)
+    };
+}
+
+fn main() {
+    let s1 = "hello\nworld\n";
+    let s2 = s1.to_owned();
+
+    // CASES THAT SHOULD EMIT A LINT
+
+    // Splitting a `str` variable at "\n" or "\r\n" after trimming should warn
+    let _ = s1.trim().split('\n');
+    #[allow(clippy::single_char_pattern)]
+    let _ = s1.trim().split("\n");
+    let _ = s1.trim().split("\r\n");
+
+    // Splitting a `String` variable at "\n" or "\r\n" after trimming should warn
+    let _ = s2.trim().split('\n');
+    #[allow(clippy::single_char_pattern)]
+    let _ = s2.trim().split("\n");
+    let _ = s2.trim().split("\r\n");
+
+    // Splitting a variable that derefs into `str` at "\n" or "\r\n" after trimming should warn.
+    let s3 = DerefsIntoStr { s: s1 };
+    let _ = s3.trim().split('\n');
+    #[allow(clippy::single_char_pattern)]
+    let _ = s3.trim().split("\n");
+    let _ = s3.trim().split("\r\n");
+
+    // If the `&str` is generated by a macro then the macro should not be expanded in the suggested fix.
+    let _ = make_str!(s1).trim().split('\n');
+
+    // CASES THAT SHOULD NOT EMIT A LINT
+
+    // Splitting a `str` constant at "\n" or "\r\n" after trimming should not warn
+    let _ = "hello\nworld\n".trim().split('\n');
+    #[allow(clippy::single_char_pattern)]
+    let _ = "hello\nworld\n".trim().split("\n");
+    let _ = "hello\nworld\n".trim().split("\r\n");
+
+    // Splitting a `str` variable at "\n" or "\r\n" without trimming should not warn, since it is not
+    // equivalent
+    let _ = s1.split('\n');
+    #[allow(clippy::single_char_pattern)]
+    let _ = s1.split("\n");
+    let _ = s1.split("\r\n");
+
+    // Splitting a `String` variable at "\n" or "\r\n" without trimming should not warn.
+    let _ = s2.split('\n');
+    #[allow(clippy::single_char_pattern)]
+    let _ = s2.split("\n");
+
+    // Splitting a variable that derefs into `str` at "\n" or "\r\n" without trimming should not warn.
+    let _ = s3.split('\n');
+    #[allow(clippy::single_char_pattern)]
+    let _ = s3.split("\n");
+    let _ = s3.split("\r\n");
+    let _ = s2.split("\r\n");
+
+    // Splitting a `str` variable at other separators should not warn
+    let _ = s1.trim().split('\r');
+    #[allow(clippy::single_char_pattern)]
+    let _ = s1.trim().split("\r");
+    let _ = s1.trim().split("\n\r");
+    let _ = s1.trim().split("\r \n");
+
+    // Splitting a `String` variable at other separators should not warn
+    let _ = s2.trim().split('\r');
+    #[allow(clippy::single_char_pattern)]
+    let _ = s2.trim().split("\r");
+    let _ = s2.trim().split("\n\r");
+
+    // Splitting a variable that derefs into `str` at other separators should not warn
+    let _ = s3.trim().split('\r');
+    #[allow(clippy::single_char_pattern)]
+    let _ = s3.trim().split("\r");
+    let _ = s3.trim().split("\n\r");
+    let _ = s3.trim().split("\r \n");
+    let _ = s2.trim().split("\r \n");
+
+    // Using `trim` and `split` on other types should not warn
+    let not_str = NotStr { s: s1 };
+    let _ = not_str.trim().split('\n');
+    #[allow(clippy::single_char_pattern)]
+    let _ = not_str.trim().split("\n");
+    let _ = not_str.trim().split("\r\n");
+    let derefs_into_not_str = DerefsIntoNotStr { not_str: &not_str };
+    let _ = derefs_into_not_str.trim().split('\n');
+    #[allow(clippy::single_char_pattern)]
+    let _ = derefs_into_not_str.trim().split("\n");
+    let _ = derefs_into_not_str.trim().split("\r\n");
+
+    // Code generated by macros should not create a warning
+    trim_split!(s1, "\r\n");
+    trim_split!("hello\nworld\n", "\r\n");
+    trim_split!(s2, "\r\n");
+    trim_split!(s3, "\r\n");
+}
diff --git a/tests/ui/str_split.stderr b/tests/ui/str_split.stderr
new file mode 100644
index 00000000000..ee0a9653711
--- /dev/null
+++ b/tests/ui/str_split.stderr
@@ -0,0 +1,65 @@
+error: using `str.trim().split()` with hard-coded newlines
+  --> $DIR/str_split.rs:59:13
+   |
+LL |     let _ = s1.trim().split('\n');
+   |             ^^^^^^^^^^^^^^^^^^^^^ help: use `str.lines()` instead: `s1.lines()`
+   |
+   = note: `-D clippy::str-split-at-newline` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::str_split_at_newline)]`
+
+error: using `str.trim().split()` with hard-coded newlines
+  --> $DIR/str_split.rs:61:13
+   |
+LL |     let _ = s1.trim().split("\n");
+   |             ^^^^^^^^^^^^^^^^^^^^^ help: use `str.lines()` instead: `s1.lines()`
+
+error: using `str.trim().split()` with hard-coded newlines
+  --> $DIR/str_split.rs:62:13
+   |
+LL |     let _ = s1.trim().split("\r\n");
+   |             ^^^^^^^^^^^^^^^^^^^^^^^ help: use `str.lines()` instead: `s1.lines()`
+
+error: using `str.trim().split()` with hard-coded newlines
+  --> $DIR/str_split.rs:65:13
+   |
+LL |     let _ = s2.trim().split('\n');
+   |             ^^^^^^^^^^^^^^^^^^^^^ help: use `str.lines()` instead: `s2.lines()`
+
+error: using `str.trim().split()` with hard-coded newlines
+  --> $DIR/str_split.rs:67:13
+   |
+LL |     let _ = s2.trim().split("\n");
+   |             ^^^^^^^^^^^^^^^^^^^^^ help: use `str.lines()` instead: `s2.lines()`
+
+error: using `str.trim().split()` with hard-coded newlines
+  --> $DIR/str_split.rs:68:13
+   |
+LL |     let _ = s2.trim().split("\r\n");
+   |             ^^^^^^^^^^^^^^^^^^^^^^^ help: use `str.lines()` instead: `s2.lines()`
+
+error: using `str.trim().split()` with hard-coded newlines
+  --> $DIR/str_split.rs:72:13
+   |
+LL |     let _ = s3.trim().split('\n');
+   |             ^^^^^^^^^^^^^^^^^^^^^ help: use `str.lines()` instead: `s3.lines()`
+
+error: using `str.trim().split()` with hard-coded newlines
+  --> $DIR/str_split.rs:74:13
+   |
+LL |     let _ = s3.trim().split("\n");
+   |             ^^^^^^^^^^^^^^^^^^^^^ help: use `str.lines()` instead: `s3.lines()`
+
+error: using `str.trim().split()` with hard-coded newlines
+  --> $DIR/str_split.rs:75:13
+   |
+LL |     let _ = s3.trim().split("\r\n");
+   |             ^^^^^^^^^^^^^^^^^^^^^^^ help: use `str.lines()` instead: `s3.lines()`
+
+error: using `str.trim().split()` with hard-coded newlines
+  --> $DIR/str_split.rs:78:13
+   |
+LL |     let _ = make_str!(s1).trim().split('\n');
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `str.lines()` instead: `make_str!(s1).lines()`
+
+error: aborting due to 10 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 457ab585fc5a5174021bed21c4c0a55deef9676c Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Sun, 31 Dec 2023 14:44:11 +0100
Subject: Add `.front()` to `get_first` lint description

---
 clippy_lints/src/methods/mod.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 0cde17ef5ad..7f5c82a3e7a 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -2590,11 +2590,11 @@ declare_clippy_lint! {
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for usage of `x.get(0)` instead of
-    /// `x.first()`.
+    /// `x.first()` or `x.front()`.
     ///
     /// ### Why is this bad?
-    /// Using `x.first()` is easier to read and has the same
-    /// result.
+    /// Using `x.first()` for `Vec`s and slices or `x.front()`
+    /// for `VecDeque`s is easier to read and has the same result.
     ///
     /// ### Example
     /// ```no_run
@@ -2610,7 +2610,7 @@ declare_clippy_lint! {
     #[clippy::version = "1.63.0"]
     pub GET_FIRST,
     style,
-    "Using `x.get(0)` when `x.first()` is simpler"
+    "Using `x.get(0)` when `x.first()` or `x.front()` is simpler"
 }
 
 declare_clippy_lint! {
-- 
cgit 1.4.1-3-g733a5


From ef35e82ea3d40ba271e97764c5b9868f7297d318 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Mon, 1 Jan 2024 02:20:46 +0100
Subject: don't look for safety comments in codeblocks

---
 clippy_lints/src/undocumented_unsafe_blocks.rs | 10 +++++++++-
 tests/ui/unnecessary_safety_comment.rs         | 21 +++++++++++++++++++++
 2 files changed, 30 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/undocumented_unsafe_blocks.rs b/clippy_lints/src/undocumented_unsafe_blocks.rs
index e5bc3b5a25f..add4b3e5637 100644
--- a/clippy_lints/src/undocumented_unsafe_blocks.rs
+++ b/clippy_lints/src/undocumented_unsafe_blocks.rs
@@ -681,11 +681,19 @@ fn text_has_safety_comment(src: &str, line_starts: &[RelativeBytePos], start_pos
         .filter(|(_, text)| !text.is_empty());
 
     let (line_start, line) = lines.next()?;
+    let mut in_codeblock = false;
     // Check for a sequence of line comments.
     if line.starts_with("//") {
         let (mut line, mut line_start) = (line, line_start);
         loop {
-            if line.to_ascii_uppercase().contains("SAFETY:") {
+            // Don't lint if the safety comment is part of a codeblock in a doc comment.
+            // It may or may not be required, and we can't very easily check it (and we shouldn't, since
+            // the safety comment isn't referring to the node we're currently checking)
+            if line.trim_start_matches("///").trim_start().starts_with("```") {
+                in_codeblock = !in_codeblock;
+            }
+
+            if line.to_ascii_uppercase().contains("SAFETY:") && !in_codeblock {
                 return Some(start_pos + BytePos(u32::try_from(line_start).unwrap()));
             }
             match lines.next() {
diff --git a/tests/ui/unnecessary_safety_comment.rs b/tests/ui/unnecessary_safety_comment.rs
index d9a7ad8e56c..bdc6fa0f46b 100644
--- a/tests/ui/unnecessary_safety_comment.rs
+++ b/tests/ui/unnecessary_safety_comment.rs
@@ -73,4 +73,25 @@ mod issue_10084 {
     }
 }
 
+mod issue_12048 {
+    pub const X: u8 = 0;
+
+    /// Returns a pointer to five.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use foo::point_to_five;
+    ///
+    /// let five_pointer = point_to_five();
+    /// // Safety: this pointer always points to a valid five.
+    /// let five = unsafe { *five_pointer };
+    /// assert_eq!(five, 5);
+    /// ```
+    pub fn point_to_five() -> *const u8 {
+        static FIVE: u8 = 5;
+        &FIVE
+    }
+}
+
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 84e797499b803aed222b027e466113d2947c38ad Mon Sep 17 00:00:00 2001
From: roife <roifewu@gmail.com>
Date: Mon, 1 Jan 2024 16:17:22 +0800
Subject: Add autofix for functions in unnecessary_fallible_conversions

---
 .../methods/unnecessary_fallible_conversions.rs    | 101 ++++++++++++++-------
 1 file changed, 68 insertions(+), 33 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/unnecessary_fallible_conversions.rs b/clippy_lints/src/methods/unnecessary_fallible_conversions.rs
index 89cf20c14fc..b646c5953e4 100644
--- a/clippy_lints/src/methods/unnecessary_fallible_conversions.rs
+++ b/clippy_lints/src/methods/unnecessary_fallible_conversions.rs
@@ -2,7 +2,7 @@ use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::get_parent_expr;
 use clippy_utils::ty::implements_trait;
 use rustc_errors::Applicability;
-use rustc_hir::{Expr, ExprKind};
+use rustc_hir::{Expr, ExprKind, QPath};
 use rustc_lint::LateContext;
 use rustc_middle::ty;
 use rustc_middle::ty::print::with_forced_trimmed_paths;
@@ -29,6 +29,7 @@ fn check<'tcx>(
     node_args: ty::GenericArgsRef<'tcx>,
     kind: FunctionKind,
     primary_span: Span,
+    qpath: Option<&QPath<'_>>,
 ) {
     if let &[self_ty, other_ty] = node_args.as_slice()
         // useless_conversion already warns `T::try_from(T)`, so ignore it here
@@ -45,47 +46,79 @@ fn check<'tcx>(
         && implements_trait(cx, self_ty, from_into_trait, &[other_ty])
         && let Some(other_ty) = other_ty.as_type()
     {
+        // Extend the span to include the unwrap/expect call:
+        // `foo.try_into().expect("..")`
+        //      ^^^^^^^^^^^^^^^^^^^^^^^
+        //
+        // `try_into().unwrap()` specifically can be trivially replaced with just `into()`,
+        // so that can be machine-applicable
         let parent_unwrap_call = get_parent_expr(cx, expr).and_then(|parent| {
             if let ExprKind::MethodCall(path, .., span) = parent.kind
                 && let sym::unwrap | sym::expect = path.ident.name
             {
-                Some(span)
+                // include `.` before `unwrap`/`expect`
+                Some(span.with_lo(expr.span.hi()))
             } else {
                 None
             }
         });
-        let (source_ty, target_ty, sugg, span, applicability) = match kind {
-            FunctionKind::TryIntoMethod if let Some(unwrap_span) = parent_unwrap_call => {
-                // Extend the span to include the unwrap/expect call:
-                // `foo.try_into().expect("..")`
-                //      ^^^^^^^^^^^^^^^^^^^^^^^
-                //
-                // `try_into().unwrap()` specifically can be trivially replaced with just `into()`,
-                // so that can be machine-applicable
 
-                (
-                    self_ty,
-                    other_ty,
-                    "into()",
-                    primary_span.with_hi(unwrap_span.hi()),
-                    Applicability::MachineApplicable,
-                )
+        let span = if let Some(unwrap_call) = parent_unwrap_call {
+            primary_span.with_hi(unwrap_call.hi())
+        } else {
+            primary_span
+        };
+
+        let qpath_spans = qpath.and_then(|qpath| match qpath {
+            QPath::Resolved(_, path) => {
+                let segments = path.segments.iter().map(|seg| seg.ident).collect::<Vec<_>>();
+                (segments.len() == 2).then(|| vec![segments[0].span, segments[1].span])
+            },
+            QPath::TypeRelative(_, seg) => Some(vec![seg.ident.span]),
+            QPath::LangItem(_, _) => unreachable!("`TryFrom` and `TryInto` are not lang items"),
+        });
+
+        let (source_ty, target_ty, sugg, applicability) = match (kind, &qpath_spans, parent_unwrap_call) {
+            (FunctionKind::TryIntoMethod, _, Some(unwrap_span)) => {
+                let sugg = vec![(primary_span, String::from("into")), (unwrap_span, String::new())];
+                (self_ty, other_ty, sugg, Applicability::MachineApplicable)
+            },
+            (FunctionKind::TryFromFunction, Some(spans), Some(unwrap_span)) => {
+                let sugg = match spans.len() {
+                    1 => vec![(spans[0], String::from("from")), (unwrap_span, String::new())],
+                    2 => vec![
+                        (spans[0], String::from("From")),
+                        (spans[1], String::from("from")),
+                        (unwrap_span, String::new()),
+                    ],
+                    _ => unreachable!(),
+                };
+                (other_ty, self_ty, sugg, Applicability::MachineApplicable)
+            },
+            (FunctionKind::TryIntoFunction, Some(spans), Some(unwrap_span)) => {
+                let sugg = match spans.len() {
+                    1 => vec![(spans[0], String::from("into")), (unwrap_span, String::new())],
+                    2 => vec![
+                        (spans[0], String::from("Into")),
+                        (spans[1], String::from("into")),
+                        (unwrap_span, String::new()),
+                    ],
+                    _ => unreachable!(),
+                };
+                (self_ty, other_ty, sugg, Applicability::MachineApplicable)
+            },
+            (FunctionKind::TryFromFunction, _, _) => {
+                let sugg = vec![(primary_span, String::from("From::from"))];
+                (other_ty, self_ty, sugg, Applicability::Unspecified)
+            },
+            (FunctionKind::TryIntoFunction, _, _) => {
+                let sugg = vec![(primary_span, String::from("Into::into"))];
+                (self_ty, other_ty, sugg, Applicability::Unspecified)
+            },
+            (FunctionKind::TryIntoMethod, _, _) => {
+                let sugg = vec![(primary_span, String::from("into"))];
+                (self_ty, other_ty, sugg, Applicability::Unspecified)
             },
-            FunctionKind::TryFromFunction => (
-                other_ty,
-                self_ty,
-                "From::from",
-                primary_span,
-                Applicability::Unspecified,
-            ),
-            FunctionKind::TryIntoFunction => (
-                self_ty,
-                other_ty,
-                "Into::into",
-                primary_span,
-                Applicability::Unspecified,
-            ),
-            FunctionKind::TryIntoMethod => (self_ty, other_ty, "into", primary_span, Applicability::Unspecified),
         };
 
         span_lint_and_then(
@@ -97,7 +130,7 @@ fn check<'tcx>(
                 with_forced_trimmed_paths!({
                     diag.note(format!("converting `{source_ty}` to `{target_ty}` cannot fail"));
                 });
-                diag.span_suggestion(span, "use", sugg, applicability);
+                diag.multipart_suggestion("use", sugg, applicability);
             },
         );
     }
@@ -113,6 +146,7 @@ pub(super) fn check_method(cx: &LateContext<'_>, expr: &Expr<'_>) {
             cx.typeck_results().node_args(expr.hir_id),
             FunctionKind::TryIntoMethod,
             path.ident.span,
+            None,
         );
     }
 }
@@ -135,6 +169,7 @@ pub(super) fn check_function(cx: &LateContext<'_>, expr: &Expr<'_>, callee: &Exp
                 _ => return,
             },
             callee.span,
+            Some(qpath),
         );
     }
 }
-- 
cgit 1.4.1-3-g733a5


From 094ce3de3ee98842c9a2ffc74934959973da5d1b Mon Sep 17 00:00:00 2001
From: roife <roifewu@gmail.com>
Date: Mon, 1 Jan 2024 16:28:34 +0800
Subject: Add comments for unnecessary_fallible_conversions

---
 .../methods/unnecessary_fallible_conversions.rs    |  1 +
 tests/ui/unnecessary_fallible_conversions.rs       |  6 ++----
 tests/ui/unnecessary_fallible_conversions.stderr   | 22 +++++++++-------------
 3 files changed, 12 insertions(+), 17 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/unnecessary_fallible_conversions.rs b/clippy_lints/src/methods/unnecessary_fallible_conversions.rs
index b646c5953e4..53069391633 100644
--- a/clippy_lints/src/methods/unnecessary_fallible_conversions.rs
+++ b/clippy_lints/src/methods/unnecessary_fallible_conversions.rs
@@ -63,6 +63,7 @@ fn check<'tcx>(
             }
         });
 
+        // If there is an unwrap/expect call, extend the span to include the call
         let span = if let Some(unwrap_call) = parent_unwrap_call {
             primary_span.with_hi(unwrap_call.hi())
         } else {
diff --git a/tests/ui/unnecessary_fallible_conversions.rs b/tests/ui/unnecessary_fallible_conversions.rs
index f9df782c4e2..9e4fd3b3f90 100644
--- a/tests/ui/unnecessary_fallible_conversions.rs
+++ b/tests/ui/unnecessary_fallible_conversions.rs
@@ -10,10 +10,8 @@ fn main() {
     let _: i64 = i32::try_into(0).unwrap();
     let _: i64 = i32::try_into(0i32).expect("can't happen");
 
-    let _ = <i64 as TryFrom<i32>>::try_from(0)
-        .unwrap();
-    let _ = <i64 as TryFrom<i32>>::try_from(0).
-        expect("can't happen");
+    let _ = <i64 as TryFrom<i32>>::try_from(0).unwrap();
+    let _ = <i64 as TryFrom<i32>>::try_from(0).expect("can't happen");
 
     let _: i64 = <i32 as TryInto<_>>::try_into(0).unwrap();
     let _: i64 = <i32 as TryInto<_>>::try_into(0).expect("can't happen");
diff --git a/tests/ui/unnecessary_fallible_conversions.stderr b/tests/ui/unnecessary_fallible_conversions.stderr
index 603c079bc0e..c16dd239a8b 100644
--- a/tests/ui/unnecessary_fallible_conversions.stderr
+++ b/tests/ui/unnecessary_fallible_conversions.stderr
@@ -81,35 +81,31 @@ LL +     let _: i64 = i32::into(0i32);
 error: use of a fallible conversion when an infallible one could be used
   --> $DIR/unnecessary_fallible_conversions.rs:13:13
    |
-LL |       let _ = <i64 as TryFrom<i32>>::try_from(0)
-   |  _____________^
-LL | |         .unwrap();
-   | |_________________^
+LL |     let _ = <i64 as TryFrom<i32>>::try_from(0).unwrap();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: converting `i32` to `i64` cannot fail
 help: use
    |
-LL -     let _ = <i64 as TryFrom<i32>>::try_from(0)
+LL -     let _ = <i64 as TryFrom<i32>>::try_from(0).unwrap();
 LL +     let _ = <i64 as From<i32>>::from(0);
    |
 
 error: use of a fallible conversion when an infallible one could be used
-  --> $DIR/unnecessary_fallible_conversions.rs:15:13
+  --> $DIR/unnecessary_fallible_conversions.rs:14:13
    |
-LL |       let _ = <i64 as TryFrom<i32>>::try_from(0).
-   |  _____________^
-LL | |         expect("can't happen");
-   | |______________________________^
+LL |     let _ = <i64 as TryFrom<i32>>::try_from(0).expect("can't happen");
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: converting `i32` to `i64` cannot fail
 help: use
    |
-LL -     let _ = <i64 as TryFrom<i32>>::try_from(0).
+LL -     let _ = <i64 as TryFrom<i32>>::try_from(0).expect("can't happen");
 LL +     let _ = <i64 as From<i32>>::from(0);
    |
 
 error: use of a fallible conversion when an infallible one could be used
-  --> $DIR/unnecessary_fallible_conversions.rs:18:18
+  --> $DIR/unnecessary_fallible_conversions.rs:16:18
    |
 LL |     let _: i64 = <i32 as TryInto<_>>::try_into(0).unwrap();
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -122,7 +118,7 @@ LL +     let _: i64 = <i32 as Into<_>>::into(0);
    |
 
 error: use of a fallible conversion when an infallible one could be used
-  --> $DIR/unnecessary_fallible_conversions.rs:19:18
+  --> $DIR/unnecessary_fallible_conversions.rs:17:18
    |
 LL |     let _: i64 = <i32 as TryInto<_>>::try_into(0).expect("can't happen");
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From 70024e16c000edfb56324852414760cc82567217 Mon Sep 17 00:00:00 2001
From: Quinn Sinclair <me@partiallytyped.dev>
Date: Wed, 27 Dec 2023 16:25:59 +0200
Subject: New Lint: [`thread_local_initializer_can_be_made_const`]

Adds a new lint to suggest using `const` on `thread_local!`
initializers that can be evaluated at compile time.

Impl details:

The lint relies on the expansion of `thread_local!`. For non
const-labelled initializers, `thread_local!` produces a function
called `__init` that lazily initializes the value. We check the function
and decide whether the body can be const. The body of the function is
exactly the initializer. If so, we lint the body.

changelog: new lint [`thread_local_initializer_can_be_made_const`]
---
 CHANGELOG.md                                       |   1 +
 clippy_lints/src/declared_lints.rs                 |   1 +
 clippy_lints/src/lib.rs                            |   4 +
 .../thread_local_initializer_can_be_made_const.rs  | 102 +++++++++++++++++++++
 ...hread_local_initializer_can_be_made_const.fixed |  30 ++++++
 .../thread_local_initializer_can_be_made_const.rs  |  30 ++++++
 ...read_local_initializer_can_be_made_const.stderr |  29 ++++++
 7 files changed, 197 insertions(+)
 create mode 100644 clippy_lints/src/thread_local_initializer_can_be_made_const.rs
 create mode 100644 tests/ui/thread_local_initializer_can_be_made_const.fixed
 create mode 100644 tests/ui/thread_local_initializer_can_be_made_const.rs
 create mode 100644 tests/ui/thread_local_initializer_can_be_made_const.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index b9e441029b2..e6c081ca94f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5616,6 +5616,7 @@ Released 2018-09-13
 [`temporary_cstring_as_ptr`]: https://rust-lang.github.io/rust-clippy/master/index.html#temporary_cstring_as_ptr
 [`test_attr_in_doctest`]: https://rust-lang.github.io/rust-clippy/master/index.html#test_attr_in_doctest
 [`tests_outside_test_module`]: https://rust-lang.github.io/rust-clippy/master/index.html#tests_outside_test_module
+[`thread_local_initializer_can_be_made_const`]: https://rust-lang.github.io/rust-clippy/master/index.html#thread_local_initializer_can_be_made_const
 [`to_digit_is_some`]: https://rust-lang.github.io/rust-clippy/master/index.html#to_digit_is_some
 [`to_string_in_display`]: https://rust-lang.github.io/rust-clippy/master/index.html#to_string_in_display
 [`to_string_in_format_args`]: https://rust-lang.github.io/rust-clippy/master/index.html#to_string_in_format_args
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 02543ae912a..f6c9ffea9fc 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -652,6 +652,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::tabs_in_doc_comments::TABS_IN_DOC_COMMENTS_INFO,
     crate::temporary_assignment::TEMPORARY_ASSIGNMENT_INFO,
     crate::tests_outside_test_module::TESTS_OUTSIDE_TEST_MODULE_INFO,
+    crate::thread_local_initializer_can_be_made_const::THREAD_LOCAL_INITIALIZER_CAN_BE_MADE_CONST_INFO,
     crate::to_digit_is_some::TO_DIGIT_IS_SOME_INFO,
     crate::trailing_empty_array::TRAILING_EMPTY_ARRAY_INFO,
     crate::trait_bounds::TRAIT_DUPLICATION_IN_BOUNDS_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index dc24243b574..854c111f9f5 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -323,6 +323,7 @@ mod swap_ptr_to_ref;
 mod tabs_in_doc_comments;
 mod temporary_assignment;
 mod tests_outside_test_module;
+mod thread_local_initializer_can_be_made_const;
 mod to_digit_is_some;
 mod trailing_empty_array;
 mod trait_bounds;
@@ -1088,6 +1089,9 @@ pub fn register_lints(store: &mut rustc_lint::LintStore, conf: &'static Conf) {
             behavior: pub_underscore_fields_behavior,
         })
     });
+    store.register_late_pass(move |_| {
+        Box::new(thread_local_initializer_can_be_made_const::ThreadLocalInitializerCanBeMadeConst::new(msrv()))
+    });
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/thread_local_initializer_can_be_made_const.rs b/clippy_lints/src/thread_local_initializer_can_be_made_const.rs
new file mode 100644
index 00000000000..9fee4c06200
--- /dev/null
+++ b/clippy_lints/src/thread_local_initializer_can_be_made_const.rs
@@ -0,0 +1,102 @@
+use clippy_config::msrvs::Msrv;
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::fn_has_unsatisfiable_preds;
+use clippy_utils::qualify_min_const_fn::is_min_const_fn;
+use clippy_utils::source::snippet;
+use rustc_errors::Applicability;
+use rustc_hir::{intravisit, ExprKind};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_middle::lint::in_external_macro;
+use rustc_session::impl_lint_pass;
+use rustc_span::sym::thread_local_macro;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Suggests to use `const` in `thread_local!` macro if possible.
+    /// ### Why is this bad?
+    ///
+    /// The `thread_local!` macro wraps static declarations and makes them thread-local.
+    /// It supports using a `const` keyword that may be used for declarations that can
+    /// be evaluated as a constant expression. This can enable a more efficient thread
+    /// local implementation that can avoid lazy initialization. For types that do not
+    /// need to be dropped, this can enable an even more efficient implementation that
+    /// does not need to track any additional state.
+    ///
+    /// https://doc.rust-lang.org/std/macro.thread_local.html
+    ///
+    /// ### Example
+    /// ```no_run
+    /// // example code where clippy issues a warning
+    /// thread_local! {
+    ///     static BUF: String = String::new();
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// // example code which does not raise clippy warning
+    /// thread_local! {
+    ///     static BUF: String = const { String::new() };
+    /// }
+    /// ```
+    #[clippy::version = "1.76.0"]
+    pub THREAD_LOCAL_INITIALIZER_CAN_BE_MADE_CONST,
+    perf,
+    "suggest using `const` in `thread_local!` macro"
+}
+
+pub struct ThreadLocalInitializerCanBeMadeConst {
+    msrv: Msrv,
+}
+
+impl ThreadLocalInitializerCanBeMadeConst {
+    #[must_use]
+    pub fn new(msrv: Msrv) -> Self {
+        Self { msrv }
+    }
+}
+
+impl_lint_pass!(ThreadLocalInitializerCanBeMadeConst => [THREAD_LOCAL_INITIALIZER_CAN_BE_MADE_CONST]);
+
+impl<'tcx> LateLintPass<'tcx> for ThreadLocalInitializerCanBeMadeConst {
+    fn check_fn(
+        &mut self,
+        cx: &LateContext<'tcx>,
+        fn_kind: rustc_hir::intravisit::FnKind<'tcx>,
+        _: &'tcx rustc_hir::FnDecl<'tcx>,
+        body: &'tcx rustc_hir::Body<'tcx>,
+        span: rustc_span::Span,
+        defid: rustc_span::def_id::LocalDefId,
+    ) {
+        if in_external_macro(cx.sess(), span)
+            && let Some(callee) = span.source_callee()
+            && let Some(macro_def_id) = callee.macro_def_id
+            && cx.tcx.is_diagnostic_item(thread_local_macro, macro_def_id)
+            && let intravisit::FnKind::ItemFn(..) = fn_kind
+            // Building MIR for `fn`s with unsatisfiable preds results in ICE.
+            && !fn_has_unsatisfiable_preds(cx, defid.to_def_id())
+            && let mir = cx.tcx.optimized_mir(defid.to_def_id())
+            && let Ok(()) = is_min_const_fn(cx.tcx, mir, &self.msrv)
+            // this is the `__init` function emitted by the `thread_local!` macro
+            // when the `const` keyword is not used. We avoid checking the `__init` directly
+            // as that is not a public API.
+            // we know that the function is const-qualifiable, so now we need only to get the
+            // initializer expression to span-lint it.
+            && let ExprKind::Block(block, _) = body.value.kind
+            && let Some(ret_expr) = block.expr
+            && let initializer_snippet = snippet(cx, ret_expr.span, "thread_local! { ... }")
+            && initializer_snippet != "thread_local! { ... }"
+        {
+            span_lint_and_sugg(
+                cx,
+                THREAD_LOCAL_INITIALIZER_CAN_BE_MADE_CONST,
+                ret_expr.span,
+                "initializer for `thread_local` value can be made `const`",
+                "replace with",
+                format!("const {{ {initializer_snippet} }}"),
+                Applicability::MachineApplicable,
+            );
+        }
+    }
+
+    extract_msrv_attr!(LateContext);
+}
diff --git a/tests/ui/thread_local_initializer_can_be_made_const.fixed b/tests/ui/thread_local_initializer_can_be_made_const.fixed
new file mode 100644
index 00000000000..bbde25b0a88
--- /dev/null
+++ b/tests/ui/thread_local_initializer_can_be_made_const.fixed
@@ -0,0 +1,30 @@
+#![warn(clippy::thread_local_initializer_can_be_made_const)]
+
+use std::cell::RefCell;
+
+fn main() {
+    // lint and suggest const
+    thread_local! {
+        static BUF_1: RefCell<String> = const { RefCell::new(String::new()) };
+    }
+    //~^^ ERROR: initializer for `thread_local` value can be made `const`
+
+    // don't lint
+    thread_local! {
+        static BUF_2: RefCell<String> = const { RefCell::new(String::new()) };
+    }
+
+    thread_local! {
+        static SIMPLE:i32 = const { 1 };
+    }
+    //~^^ ERROR: initializer for `thread_local` value can be made `const`
+
+    // lint and suggest const for all non const items
+    thread_local! {
+        static BUF_3_CAN_BE_MADE_CONST: RefCell<String> = const { RefCell::new(String::new()) };
+        static CONST_MIXED_WITH:i32 = const { 1 };
+        static BUF_4_CAN_BE_MADE_CONST: RefCell<String> = const { RefCell::new(String::new()) };
+    }
+    //~^^^^ ERROR: initializer for `thread_local` value can be made `const`
+    //~^^^ ERROR: initializer for `thread_local` value can be made `const`
+}
diff --git a/tests/ui/thread_local_initializer_can_be_made_const.rs b/tests/ui/thread_local_initializer_can_be_made_const.rs
new file mode 100644
index 00000000000..3d7aacf2f09
--- /dev/null
+++ b/tests/ui/thread_local_initializer_can_be_made_const.rs
@@ -0,0 +1,30 @@
+#![warn(clippy::thread_local_initializer_can_be_made_const)]
+
+use std::cell::RefCell;
+
+fn main() {
+    // lint and suggest const
+    thread_local! {
+        static BUF_1: RefCell<String> = RefCell::new(String::new());
+    }
+    //~^^ ERROR: initializer for `thread_local` value can be made `const`
+
+    // don't lint
+    thread_local! {
+        static BUF_2: RefCell<String> = const { RefCell::new(String::new()) };
+    }
+
+    thread_local! {
+        static SIMPLE:i32 = 1;
+    }
+    //~^^ ERROR: initializer for `thread_local` value can be made `const`
+
+    // lint and suggest const for all non const items
+    thread_local! {
+        static BUF_3_CAN_BE_MADE_CONST: RefCell<String> = RefCell::new(String::new());
+        static CONST_MIXED_WITH:i32 = const { 1 };
+        static BUF_4_CAN_BE_MADE_CONST: RefCell<String> = RefCell::new(String::new());
+    }
+    //~^^^^ ERROR: initializer for `thread_local` value can be made `const`
+    //~^^^ ERROR: initializer for `thread_local` value can be made `const`
+}
diff --git a/tests/ui/thread_local_initializer_can_be_made_const.stderr b/tests/ui/thread_local_initializer_can_be_made_const.stderr
new file mode 100644
index 00000000000..b35bd306b52
--- /dev/null
+++ b/tests/ui/thread_local_initializer_can_be_made_const.stderr
@@ -0,0 +1,29 @@
+error: initializer for `thread_local` value can be made `const`
+  --> $DIR/thread_local_initializer_can_be_made_const.rs:8:41
+   |
+LL |         static BUF_1: RefCell<String> = RefCell::new(String::new());
+   |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `const { RefCell::new(String::new()) }`
+   |
+   = note: `-D clippy::thread-local-initializer-can-be-made-const` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::thread_local_initializer_can_be_made_const)]`
+
+error: initializer for `thread_local` value can be made `const`
+  --> $DIR/thread_local_initializer_can_be_made_const.rs:18:29
+   |
+LL |         static SIMPLE:i32 = 1;
+   |                             ^ help: replace with: `const { 1 }`
+
+error: initializer for `thread_local` value can be made `const`
+  --> $DIR/thread_local_initializer_can_be_made_const.rs:24:59
+   |
+LL |         static BUF_3_CAN_BE_MADE_CONST: RefCell<String> = RefCell::new(String::new());
+   |                                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `const { RefCell::new(String::new()) }`
+
+error: initializer for `thread_local` value can be made `const`
+  --> $DIR/thread_local_initializer_can_be_made_const.rs:26:59
+   |
+LL |         static BUF_4_CAN_BE_MADE_CONST: RefCell<String> = RefCell::new(String::new());
+   |                                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `const { RefCell::new(String::new()) }`
+
+error: aborting due to 4 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From ff2919ac5d1f90c146df714b9fd0f716713e96cb Mon Sep 17 00:00:00 2001
From: Lieselotte <52315535+she3py@users.noreply.github.com>
Date: Mon, 1 Jan 2024 18:47:57 +0100
Subject: Remove deadlinks from `unchecked_duration_subtraction`

---
 clippy_lints/src/instant_subtraction.rs | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/instant_subtraction.rs b/clippy_lints/src/instant_subtraction.rs
index 655f4b82aa4..17b6256f982 100644
--- a/clippy_lints/src/instant_subtraction.rs
+++ b/clippy_lints/src/instant_subtraction.rs
@@ -40,7 +40,7 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Lints subtraction between an [`Instant`] and a [`Duration`].
+    /// Lints subtraction between an `Instant` and a `Duration`.
     ///
     /// ### Why is this bad?
     /// Unchecked subtraction could cause underflow on certain platforms, leading to
@@ -57,9 +57,6 @@ declare_clippy_lint! {
     /// # use std::time::{Instant, Duration};
     /// let time_passed = Instant::now().checked_sub(Duration::from_secs(5));
     /// ```
-    ///
-    /// [`Duration`]: std::time::Duration
-    /// [`Instant::now()`]: std::time::Instant::now;
     #[clippy::version = "1.67.0"]
     pub UNCHECKED_DURATION_SUBTRACTION,
     pedantic,
-- 
cgit 1.4.1-3-g733a5


From 88541d66370aba7ec48661617afd4d712f4e6711 Mon Sep 17 00:00:00 2001
From: Yuxiang Qiu <yuxqiu@proton.me>
Date: Tue, 2 Jan 2024 19:21:51 -0500
Subject: fix some typos

---
 book/src/development/macro_expansions.md         | 2 +-
 clippy_lints/src/methods/mod.rs                  | 4 ++--
 clippy_lints/src/missing_asserts_for_indexing.rs | 2 +-
 clippy_lints/src/no_effect.rs                    | 2 +-
 clippy_lints/src/serde_api.rs                    | 2 +-
 clippy_lints/src/wildcard_imports.rs             | 2 +-
 clippy_utils/src/ty/type_certainty/mod.rs        | 6 +++---
 tests/ui/as_conversions.rs                       | 2 +-
 tests/ui/default_numeric_fallback_i32.fixed      | 2 +-
 tests/ui/default_numeric_fallback_i32.rs         | 2 +-
 tests/ui/redundant_as_str.fixed                  | 2 +-
 tests/ui/redundant_as_str.rs                     | 2 +-
 tests/ui/regex.rs                                | 2 +-
 tests/ui/struct_fields.rs                        | 2 +-
 tests/ui/useless_conversion.fixed                | 4 ++--
 tests/ui/useless_conversion.rs                   | 4 ++--
 16 files changed, 21 insertions(+), 21 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/book/src/development/macro_expansions.md b/book/src/development/macro_expansions.md
index c5eb000272d..aecca9ef72e 100644
--- a/book/src/development/macro_expansions.md
+++ b/book/src/development/macro_expansions.md
@@ -102,7 +102,7 @@ let x: Option<u32> = Some(42);
 m!(x, x.unwrap());
 ```
 
-If the `m!(x, x.unwrapp());` line is expanded, we would get two expanded
+If the `m!(x, x.unwrap());` line is expanded, we would get two expanded
 expressions:
 
 - `x.is_some()` (from the `$a.is_some()` line in the `m` macro)
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 4c21f49638b..fbca641cfa3 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -3786,7 +3786,7 @@ declare_clippy_lint! {
     ///
     /// ### Why is this bad?
     /// This pattern is often followed by manual unwrapping of the `Option`. The simplification
-    /// results in more readable and succint code without the need for manual unwrapping.
+    /// results in more readable and succinct code without the need for manual unwrapping.
     ///
     /// ### Example
     /// ```no_run
@@ -3812,7 +3812,7 @@ declare_clippy_lint! {
     ///
     /// ### Why is this bad?
     /// This pattern is often followed by manual unwrapping of `Result`. The simplification
-    /// results in more readable and succint code without the need for manual unwrapping.
+    /// results in more readable and succinct code without the need for manual unwrapping.
     ///
     /// ### Example
     /// ```no_run
diff --git a/clippy_lints/src/missing_asserts_for_indexing.rs b/clippy_lints/src/missing_asserts_for_indexing.rs
index 0f18e943451..bbc4d0a0f9a 100644
--- a/clippy_lints/src/missing_asserts_for_indexing.rs
+++ b/clippy_lints/src/missing_asserts_for_indexing.rs
@@ -331,7 +331,7 @@ fn report_indexes(cx: &LateContext<'_>, map: &UnhashMap<u64, Vec<IndexEntry<'_>>
                     slice,
                 } if indexes.len() > 1 => {
                     // if we have found an `assert!`, let's also check that it's actually right
-                    // and if it convers the highest index and if not, suggest the correct length
+                    // and if it covers the highest index and if not, suggest the correct length
                     let sugg = match comparison {
                         // `v.len() < 5` and `v.len() <= 5` does nothing in terms of bounds checks.
                         // The user probably meant `v.len() > 5`
diff --git a/clippy_lints/src/no_effect.rs b/clippy_lints/src/no_effect.rs
index 5978da83199..6bbe427ea29 100644
--- a/clippy_lints/src/no_effect.rs
+++ b/clippy_lints/src/no_effect.rs
@@ -165,7 +165,7 @@ fn check_no_effect(cx: &LateContext<'_>, stmt: &Stmt<'_>) -> bool {
 }
 
 fn is_operator_overridden(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-    // It's very hard or impossable to check whether overridden operator have side-effect this lint.
+    // It's very hard or impossible to check whether overridden operator have side-effect this lint.
     // So, this function assume user-defined operator is overridden with an side-effect.
     // The definition of user-defined structure here is ADT-type,
     // Althrough this will weaken the ability of this lint, less error lint-fix happen.
diff --git a/clippy_lints/src/serde_api.rs b/clippy_lints/src/serde_api.rs
index 90834d784a5..b4278d879e5 100644
--- a/clippy_lints/src/serde_api.rs
+++ b/clippy_lints/src/serde_api.rs
@@ -6,7 +6,7 @@ use rustc_session::declare_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for mis-uses of the serde API.
+    /// Checks for misuses of the serde API.
     ///
     /// ### Why is this bad?
     /// Serde is very finnicky about how its API should be
diff --git a/clippy_lints/src/wildcard_imports.rs b/clippy_lints/src/wildcard_imports.rs
index 9b0dac6af25..b82bd1d7e7c 100644
--- a/clippy_lints/src/wildcard_imports.rs
+++ b/clippy_lints/src/wildcard_imports.rs
@@ -142,7 +142,7 @@ impl LateLintPass<'_> for WildcardImports {
             } else {
                 // In this case, the `use_path.span` ends right before the `::*`, so we need to
                 // extend it up to the `*`. Since it is hard to find the `*` in weird
-                // formattings like `use _ ::  *;`, we extend it up to, but not including the
+                // formatting like `use _ ::  *;`, we extend it up to, but not including the
                 // `;`. In nested imports, like `use _::{inner::*, _}` there is no `;` and we
                 // can just use the end of the item span
                 let mut span = use_path.span.with_hi(item.span.hi());
diff --git a/clippy_utils/src/ty/type_certainty/mod.rs b/clippy_utils/src/ty/type_certainty/mod.rs
index da71fc3aaa8..adca2ca1c3e 100644
--- a/clippy_utils/src/ty/type_certainty/mod.rs
+++ b/clippy_utils/src/ty/type_certainty/mod.rs
@@ -38,7 +38,7 @@ fn expr_type_certainty(cx: &LateContext<'_>, expr: &Expr<'_>) -> Certainty {
 
         ExprKind::Call(callee, args) => {
             let lhs = expr_type_certainty(cx, callee);
-            let rhs = if type_is_inferrable_from_arguments(cx, expr) {
+            let rhs = if type_is_inferable_from_arguments(cx, expr) {
                 meet(args.iter().map(|arg| expr_type_certainty(cx, arg)))
             } else {
                 Certainty::Uncertain
@@ -57,7 +57,7 @@ fn expr_type_certainty(cx: &LateContext<'_>, expr: &Expr<'_>) -> Certainty {
                 receiver_type_certainty = receiver_type_certainty.with_def_id(self_ty_def_id);
             };
             let lhs = path_segment_certainty(cx, receiver_type_certainty, method, false);
-            let rhs = if type_is_inferrable_from_arguments(cx, expr) {
+            let rhs = if type_is_inferable_from_arguments(cx, expr) {
                 meet(
                     std::iter::once(receiver_type_certainty).chain(args.iter().map(|arg| expr_type_certainty(cx, arg))),
                 )
@@ -279,7 +279,7 @@ fn update_res(cx: &LateContext<'_>, parent_certainty: Certainty, path_segment: &
 }
 
 #[allow(clippy::cast_possible_truncation)]
-fn type_is_inferrable_from_arguments(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+fn type_is_inferable_from_arguments(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
     let Some(callee_def_id) = (match expr.kind {
         ExprKind::Call(callee, _) => {
             let callee_ty = cx.typeck_results().expr_ty(callee);
diff --git a/tests/ui/as_conversions.rs b/tests/ui/as_conversions.rs
index 192eb51ea99..8499c0ac5a0 100644
--- a/tests/ui/as_conversions.rs
+++ b/tests/ui/as_conversions.rs
@@ -17,7 +17,7 @@ fn main() {
 with_span!(
     span
 
-    fn coverting() {
+    fn converting() {
         let x = 0u32 as u64;
     }
 );
diff --git a/tests/ui/default_numeric_fallback_i32.fixed b/tests/ui/default_numeric_fallback_i32.fixed
index 9ef92d8f279..c364c683057 100644
--- a/tests/ui/default_numeric_fallback_i32.fixed
+++ b/tests/ui/default_numeric_fallback_i32.fixed
@@ -184,7 +184,7 @@ fn check_expect_suppression() {
     let x = 21;
 }
 
-mod type_already_infered {
+mod type_already_inferred {
     // Should NOT lint if bound to return type
     fn ret_i32() -> i32 {
         1
diff --git a/tests/ui/default_numeric_fallback_i32.rs b/tests/ui/default_numeric_fallback_i32.rs
index 4b54b8d8458..ffa7b961d1c 100644
--- a/tests/ui/default_numeric_fallback_i32.rs
+++ b/tests/ui/default_numeric_fallback_i32.rs
@@ -184,7 +184,7 @@ fn check_expect_suppression() {
     let x = 21;
 }
 
-mod type_already_infered {
+mod type_already_inferred {
     // Should NOT lint if bound to return type
     fn ret_i32() -> i32 {
         1
diff --git a/tests/ui/redundant_as_str.fixed b/tests/ui/redundant_as_str.fixed
index a38523a7c79..4185b402226 100644
--- a/tests/ui/redundant_as_str.fixed
+++ b/tests/ui/redundant_as_str.fixed
@@ -11,7 +11,7 @@ fn main() {
     let _no_as_str = string.as_bytes();
     let _no_as_str = string.is_empty();
 
-    // These methods are not redundant, and are equivelant to
+    // These methods are not redundant, and are equivalent to
     // doing dereferencing the string and applying the method
     let _not_redundant = string.as_str().escape_unicode();
     let _not_redundant = string.as_str().trim();
diff --git a/tests/ui/redundant_as_str.rs b/tests/ui/redundant_as_str.rs
index 33adb609996..7a74d8a55de 100644
--- a/tests/ui/redundant_as_str.rs
+++ b/tests/ui/redundant_as_str.rs
@@ -11,7 +11,7 @@ fn main() {
     let _no_as_str = string.as_bytes();
     let _no_as_str = string.is_empty();
 
-    // These methods are not redundant, and are equivelant to
+    // These methods are not redundant, and are equivalent to
     // doing dereferencing the string and applying the method
     let _not_redundant = string.as_str().escape_unicode();
     let _not_redundant = string.as_str().trim();
diff --git a/tests/ui/regex.rs b/tests/ui/regex.rs
index 1ea0d65bf1e..4fb6c08bb44 100644
--- a/tests/ui/regex.rs
+++ b/tests/ui/regex.rs
@@ -113,7 +113,7 @@ fn trivial_regex() {
     // #6005: unicode classes in bytes::Regex
     let a_byte_of_unicode = BRegex::new(r"\p{C}");
 
-    // start and end word boundry, introduced in regex 0.10
+    // start and end word boundary, introduced in regex 0.10
     let _ = BRegex::new(r"\<word\>");
     let _ = BRegex::new(r"\b{start}word\b{end}");
 }
diff --git a/tests/ui/struct_fields.rs b/tests/ui/struct_fields.rs
index 8b1a1446e3c..a8b12c6dfe3 100644
--- a/tests/ui/struct_fields.rs
+++ b/tests/ui/struct_fields.rs
@@ -65,7 +65,7 @@ struct NotSnakeCase2 {
     someData_a_b: bool,
 }
 
-// no error, threshold is 3 fiels by default
+// no error, threshold is 3 fields by default
 struct Fooo {
     foo: u8,
     bar: u8,
diff --git a/tests/ui/useless_conversion.fixed b/tests/ui/useless_conversion.fixed
index ed8387b7eb2..ce00fde2f99 100644
--- a/tests/ui/useless_conversion.fixed
+++ b/tests/ui/useless_conversion.fixed
@@ -241,7 +241,7 @@ mod issue11300 {
         foo2::<(), _>([1, 2, 3].into_iter());
 
         // This should lint. Removing the `.into_iter()` means that `I` gets substituted with `[i32; 3]`,
-        // and `i32: Helper2<[i32, 3]>` is true, so this call is indeed unncessary.
+        // and `i32: Helper2<[i32, 3]>` is true, so this call is indeed unnecessary.
         foo3([1, 2, 3]);
     }
 
@@ -253,7 +253,7 @@ mod issue11300 {
 
         S1.foo([1, 2]);
 
-        // ICE that occured in itertools
+        // ICE that occurred in itertools
         trait Itertools {
             fn interleave_shortest<J>(self, other: J)
             where
diff --git a/tests/ui/useless_conversion.rs b/tests/ui/useless_conversion.rs
index 991a7762fc6..39979619586 100644
--- a/tests/ui/useless_conversion.rs
+++ b/tests/ui/useless_conversion.rs
@@ -241,7 +241,7 @@ mod issue11300 {
         foo2::<(), _>([1, 2, 3].into_iter());
 
         // This should lint. Removing the `.into_iter()` means that `I` gets substituted with `[i32; 3]`,
-        // and `i32: Helper2<[i32, 3]>` is true, so this call is indeed unncessary.
+        // and `i32: Helper2<[i32, 3]>` is true, so this call is indeed unnecessary.
         foo3([1, 2, 3].into_iter());
     }
 
@@ -253,7 +253,7 @@ mod issue11300 {
 
         S1.foo([1, 2].into_iter());
 
-        // ICE that occured in itertools
+        // ICE that occurred in itertools
         trait Itertools {
             fn interleave_shortest<J>(self, other: J)
             where
-- 
cgit 1.4.1-3-g733a5


From 090c228873c8109e82857145f71f34c0ccdf28dd Mon Sep 17 00:00:00 2001
From: cocodery <cocodery@outlook.com>
Date: Wed, 3 Jan 2024 22:12:27 +0800
Subject: Fix/Issue11932: assert* in multi-condition after unrolling will cause
 lint  emit warning

---
 clippy_lints/src/booleans.rs | 2 ++
 1 file changed, 2 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/booleans.rs b/clippy_lints/src/booleans.rs
index e11f83f2260..2d0af1017d5 100644
--- a/clippy_lints/src/booleans.rs
+++ b/clippy_lints/src/booleans.rs
@@ -502,6 +502,8 @@ impl<'a, 'tcx> Visitor<'tcx> for NotSimplificationVisitor<'a, 'tcx> {
             && !inner.span.from_expansion()
             && let Some(suggestion) = simplify_not(self.cx, inner)
             && self.cx.tcx.lint_level_at_node(NONMINIMAL_BOOL, expr.hir_id).0 != Level::Allow
+            && let Some(snippet) = snippet_opt(self.cx, expr.span)
+            && !snippet.contains("assert")
         {
             span_lint_and_sugg(
                 self.cx,
-- 
cgit 1.4.1-3-g733a5


From b5a219262891aaa65fc583424a8ab1bba66e8746 Mon Sep 17 00:00:00 2001
From: Yuxiang Qiu <yuxqiu@proton.me>
Date: Wed, 3 Jan 2024 13:05:55 -0500
Subject: fix: incorrect suggestions generated by `manual_retain` lint

---
 clippy_lints/src/manual_retain.rs | 141 ++++++++++++++++++++++++++-----------
 tests/ui/manual_retain.fixed      |  56 +++++++++++++++
 tests/ui/manual_retain.rs         |  56 +++++++++++++++
 tests/ui/manual_retain.stderr     | 142 ++++++++++++++++++++++++++++++++------
 4 files changed, 331 insertions(+), 64 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/manual_retain.rs b/clippy_lints/src/manual_retain.rs
index 1fe247dacb9..6f15fca089e 100644
--- a/clippy_lints/src/manual_retain.rs
+++ b/clippy_lints/src/manual_retain.rs
@@ -11,6 +11,7 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_semver::RustcVersion;
 use rustc_session::impl_lint_pass;
 use rustc_span::symbol::sym;
+use rustc_span::Span;
 
 const ACCEPTABLE_METHODS: [&[&str]; 5] = [
     &paths::BINARYHEAP_ITER,
@@ -28,6 +29,7 @@ const ACCEPTABLE_TYPES: [(rustc_span::Symbol, Option<RustcVersion>); 7] = [
     (sym::Vec, None),
     (sym::VecDeque, None),
 ];
+const MAP_TYPES: [rustc_span::Symbol; 2] = [sym::BTreeMap, sym::HashMap];
 
 declare_clippy_lint! {
     /// ### What it does
@@ -44,6 +46,7 @@ declare_clippy_lint! {
     /// ```no_run
     /// let mut vec = vec![0, 1, 2];
     /// vec.retain(|x| x % 2 == 0);
+    /// vec.retain(|x| x % 2 == 0);
     /// ```
     #[clippy::version = "1.64.0"]
     pub MANUAL_RETAIN,
@@ -74,9 +77,9 @@ impl<'tcx> LateLintPass<'tcx> for ManualRetain {
             && let Some(collect_def_id) = cx.typeck_results().type_dependent_def_id(collect_expr.hir_id)
             && cx.tcx.is_diagnostic_item(sym::iterator_collect_fn, collect_def_id)
         {
-            check_into_iter(cx, parent_expr, left_expr, target_expr, &self.msrv);
-            check_iter(cx, parent_expr, left_expr, target_expr, &self.msrv);
-            check_to_owned(cx, parent_expr, left_expr, target_expr, &self.msrv);
+            check_into_iter(cx, left_expr, target_expr, parent_expr.span, &self.msrv);
+            check_iter(cx, left_expr, target_expr, parent_expr.span, &self.msrv);
+            check_to_owned(cx, left_expr, target_expr, parent_expr.span, &self.msrv);
         }
     }
 
@@ -85,9 +88,9 @@ impl<'tcx> LateLintPass<'tcx> for ManualRetain {
 
 fn check_into_iter(
     cx: &LateContext<'_>,
-    parent_expr: &hir::Expr<'_>,
     left_expr: &hir::Expr<'_>,
     target_expr: &hir::Expr<'_>,
+    parent_expr_span: Span,
     msrv: &Msrv,
 ) {
     if let hir::ExprKind::MethodCall(_, into_iter_expr, [_], _) = &target_expr.kind
@@ -98,16 +101,39 @@ fn check_into_iter(
         && Some(into_iter_def_id) == cx.tcx.lang_items().into_iter_fn()
         && match_acceptable_type(cx, left_expr, msrv)
         && SpanlessEq::new(cx).eq_expr(left_expr, struct_expr)
+        && let hir::ExprKind::MethodCall(_, _, [closure_expr], _) = target_expr.kind
+        && let hir::ExprKind::Closure(closure) = closure_expr.kind
+        && let filter_body = cx.tcx.hir().body(closure.body)
+        && let [filter_params] = filter_body.params
     {
-        suggest(cx, parent_expr, left_expr, target_expr);
+        if match_map_type(cx, left_expr) {
+            if let hir::PatKind::Tuple([key_pat, value_pat], _) = filter_params.pat.kind {
+                if let Some(sugg) = make_sugg(cx, key_pat, value_pat, left_expr, filter_body) {
+                    make_span_lint_and_sugg(cx, parent_expr_span, sugg);
+                }
+            }
+            // Cannot lint other cases because `retain` requires two parameters
+        } else {
+            // Can always move because `retain` and `filter` have the same bound on the predicate
+            // for other types
+            make_span_lint_and_sugg(
+                cx,
+                parent_expr_span,
+                format!(
+                    "{}.retain({})",
+                    snippet(cx, left_expr.span, ".."),
+                    snippet(cx, closure_expr.span, "..")
+                ),
+            );
+        }
     }
 }
 
 fn check_iter(
     cx: &LateContext<'_>,
-    parent_expr: &hir::Expr<'_>,
     left_expr: &hir::Expr<'_>,
     target_expr: &hir::Expr<'_>,
+    parent_expr_span: Span,
     msrv: &Msrv,
 ) {
     if let hir::ExprKind::MethodCall(_, filter_expr, [], _) = &target_expr.kind
@@ -122,16 +148,50 @@ fn check_iter(
         && match_acceptable_def_path(cx, iter_expr_def_id)
         && match_acceptable_type(cx, left_expr, msrv)
         && SpanlessEq::new(cx).eq_expr(left_expr, struct_expr)
+        && let hir::ExprKind::MethodCall(_, _, [closure_expr], _) = filter_expr.kind
+        && let hir::ExprKind::Closure(closure) = closure_expr.kind
+        && let filter_body = cx.tcx.hir().body(closure.body)
+        && let [filter_params] = filter_body.params
     {
-        suggest(cx, parent_expr, left_expr, filter_expr);
+        match filter_params.pat.kind {
+            // hir::PatKind::Binding(_, _, _, None) => {
+            //     // Be conservative now. Do nothing here.
+            //     // TODO: Ideally, we can rewrite the lambda by stripping one level of reference
+            // },
+            hir::PatKind::Tuple([_, _], _) => {
+                // the `&&` reference for the `filter` method will be auto derefed to `ref`
+                // so, we can directly use the lambda
+                // https://doc.rust-lang.org/reference/patterns.html#binding-modes
+                make_span_lint_and_sugg(
+                    cx,
+                    parent_expr_span,
+                    format!(
+                        "{}.retain({})",
+                        snippet(cx, left_expr.span, ".."),
+                        snippet(cx, closure_expr.span, "..")
+                    ),
+                );
+            },
+            hir::PatKind::Ref(pat, _) => make_span_lint_and_sugg(
+                cx,
+                parent_expr_span,
+                format!(
+                    "{}.retain(|{}| {})",
+                    snippet(cx, left_expr.span, ".."),
+                    snippet(cx, pat.span, ".."),
+                    snippet(cx, filter_body.value.span, "..")
+                ),
+            ),
+            _ => {},
+        }
     }
 }
 
 fn check_to_owned(
     cx: &LateContext<'_>,
-    parent_expr: &hir::Expr<'_>,
     left_expr: &hir::Expr<'_>,
     target_expr: &hir::Expr<'_>,
+    parent_expr_span: Span,
     msrv: &Msrv,
 ) {
     if msrv.meets(msrvs::STRING_RETAIN)
@@ -147,43 +207,25 @@ fn check_to_owned(
         && let ty = cx.typeck_results().expr_ty(str_expr).peel_refs()
         && is_type_lang_item(cx, ty, hir::LangItem::String)
         && SpanlessEq::new(cx).eq_expr(left_expr, str_expr)
-    {
-        suggest(cx, parent_expr, left_expr, filter_expr);
-    }
-}
-
-fn suggest(cx: &LateContext<'_>, parent_expr: &hir::Expr<'_>, left_expr: &hir::Expr<'_>, filter_expr: &hir::Expr<'_>) {
-    if let hir::ExprKind::MethodCall(_, _, [closure], _) = filter_expr.kind
-        && let hir::ExprKind::Closure(&hir::Closure { body, .. }) = closure.kind
-        && let filter_body = cx.tcx.hir().body(body)
+        && let hir::ExprKind::MethodCall(_, _, [closure_expr], _) = filter_expr.kind
+        && let hir::ExprKind::Closure(closure) = closure_expr.kind
+        && let filter_body = cx.tcx.hir().body(closure.body)
         && let [filter_params] = filter_body.params
-        && let Some(sugg) = match filter_params.pat.kind {
-            hir::PatKind::Binding(_, _, filter_param_ident, None) => Some(format!(
-                "{}.retain(|{filter_param_ident}| {})",
-                snippet(cx, left_expr.span, ".."),
-                snippet(cx, filter_body.value.span, "..")
-            )),
-            hir::PatKind::Tuple([key_pat, value_pat], _) => make_sugg(cx, key_pat, value_pat, left_expr, filter_body),
-            hir::PatKind::Ref(pat, _) => match pat.kind {
-                hir::PatKind::Binding(_, _, filter_param_ident, None) => Some(format!(
-                    "{}.retain(|{filter_param_ident}| {})",
+    {
+        if let hir::PatKind::Ref(pat, _) = filter_params.pat.kind {
+            make_span_lint_and_sugg(
+                cx,
+                parent_expr_span,
+                format!(
+                    "{}.retain(|{}| {})",
                     snippet(cx, left_expr.span, ".."),
+                    snippet(cx, pat.span, ".."),
                     snippet(cx, filter_body.value.span, "..")
-                )),
-                _ => None,
-            },
-            _ => None,
+                ),
+            );
         }
-    {
-        span_lint_and_sugg(
-            cx,
-            MANUAL_RETAIN,
-            parent_expr.span,
-            "this expression can be written more simply using `.retain()`",
-            "consider calling `.retain()` instead",
-            sugg,
-            Applicability::MachineApplicable,
-        );
+        // Be conservative now. Do nothing for the `Binding` case.
+        // TODO: Ideally, we can rewrite the lambda by stripping one level of reference
     }
 }
 
@@ -229,3 +271,20 @@ fn match_acceptable_type(cx: &LateContext<'_>, expr: &hir::Expr<'_>, msrv: &Msrv
             && acceptable_msrv.map_or(true, |acceptable_msrv| msrv.meets(acceptable_msrv))
     })
 }
+
+fn match_map_type(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> bool {
+    let expr_ty = cx.typeck_results().expr_ty(expr).peel_refs();
+    MAP_TYPES.iter().any(|ty| is_type_diagnostic_item(cx, expr_ty, *ty))
+}
+
+fn make_span_lint_and_sugg(cx: &LateContext<'_>, span: Span, sugg: String) {
+    span_lint_and_sugg(
+        cx,
+        MANUAL_RETAIN,
+        span,
+        "this expression can be written more simply using `.retain()`",
+        "consider calling `.retain()` instead",
+        sugg,
+        Applicability::MachineApplicable,
+    );
+}
diff --git a/tests/ui/manual_retain.fixed b/tests/ui/manual_retain.fixed
index 4dea3e8bfe6..a0a697a3fb3 100644
--- a/tests/ui/manual_retain.fixed
+++ b/tests/ui/manual_retain.fixed
@@ -14,6 +14,9 @@ fn main() {
     _msrv_153();
     _msrv_126();
     _msrv_118();
+
+    issue_10393();
+    issue_12081();
 }
 
 fn binary_heap_retain() {
@@ -23,6 +26,11 @@ fn binary_heap_retain() {
     binary_heap.retain(|x| x % 2 == 0);
     binary_heap.retain(|x| x % 2 == 0);
 
+    // Do lint, because we use pattern matching
+    let mut tuples = BinaryHeap::from([(0, 1), (1, 2), (2, 3)]);
+    tuples.retain(|(ref x, ref y)| *x == 0);
+    tuples.retain(|(x, y)| *x == 0);
+
     // Do not lint, because type conversion is performed
     binary_heap = binary_heap
         .into_iter()
@@ -55,6 +63,9 @@ fn btree_map_retain() {
     btree_map.retain(|_, &mut v| v % 2 == 0);
     btree_map.retain(|k, &mut v| (k % 2 == 0) && (v % 2 == 0));
 
+    // Do not lint, because the parameters are not matched in tuple pattern
+    btree_map = btree_map.into_iter().filter(|t| t.0 % 2 == 0).collect();
+
     // Do not lint.
     btree_map = btree_map
         .into_iter()
@@ -76,6 +87,11 @@ fn btree_set_retain() {
     btree_set.retain(|x| x % 2 == 0);
     btree_set.retain(|x| x % 2 == 0);
 
+    // Do lint, because we use pattern matching
+    let mut tuples = BTreeSet::from([(0, 1), (1, 2), (2, 3)]);
+    tuples.retain(|(ref x, ref y)| *x == 0);
+    tuples.retain(|(x, y)| *x == 0);
+
     // Do not lint, because type conversion is performed
     btree_set = btree_set
         .iter()
@@ -108,6 +124,9 @@ fn hash_map_retain() {
     hash_map.retain(|_, &mut v| v % 2 == 0);
     hash_map.retain(|k, &mut v| (k % 2 == 0) && (v % 2 == 0));
 
+    // Do not lint, because the parameters are not matched in tuple pattern
+    hash_map = hash_map.into_iter().filter(|t| t.0 % 2 == 0).collect();
+
     // Do not lint.
     hash_map = hash_map
         .into_iter()
@@ -128,6 +147,11 @@ fn hash_set_retain() {
     hash_set.retain(|x| x % 2 == 0);
     hash_set.retain(|x| x % 2 == 0);
 
+    // Do lint, because we use pattern matching
+    let mut tuples = HashSet::from([(0, 1), (1, 2), (2, 3)]);
+    tuples.retain(|(ref x, ref y)| *x == 0);
+    tuples.retain(|(x, y)| *x == 0);
+
     // Do not lint, because type conversion is performed
     hash_set = hash_set.into_iter().filter(|x| x % 2 == 0).collect::<HashSet<i8>>();
     hash_set = hash_set
@@ -157,6 +181,9 @@ fn string_retain() {
     // Do lint.
     s.retain(|c| c != 'o');
 
+    // Do not lint, because we need to rewrite the lambda
+    s = s.chars().filter(|c| *c != 'o').to_owned().collect();
+
     // Do not lint, because this expression is not assign.
     let mut bar: String = s.chars().filter(|&c| c != 'o').to_owned().collect();
 
@@ -171,6 +198,11 @@ fn vec_retain() {
     vec.retain(|x| x % 2 == 0);
     vec.retain(|x| x % 2 == 0);
 
+    // Do lint, because we use pattern matching
+    let mut tuples = vec![(0, 1), (1, 2), (2, 3)];
+    tuples.retain(|(ref x, ref y)| *x == 0);
+    tuples.retain(|(x, y)| *x == 0);
+
     // Do not lint, because type conversion is performed
     vec = vec.into_iter().filter(|x| x % 2 == 0).collect::<Vec<i8>>();
     vec = vec.iter().filter(|&x| x % 2 == 0).copied().collect::<Vec<i8>>();
@@ -246,3 +278,27 @@ fn _msrv_118() {
     let mut hash_map: HashMap<i8, i8> = (0..8).map(|x| (x, x * 10)).collect();
     hash_map = hash_map.into_iter().filter(|(k, _)| k % 2 == 0).collect();
 }
+
+fn issue_10393() {
+    // Do lint
+    let mut vec = vec![(0, 1), (1, 2), (2, 3)];
+    vec.retain(|(x, y)| *x == 0);
+
+    // Do lint
+    let mut tuples = vec![(true, -2), (false, 3)];
+    tuples.retain(|(_, n)| *n > 0);
+}
+
+fn issue_12081() {
+    let mut vec = vec![0, 1, 2];
+
+    // Do lint
+    vec.retain(|&x| x == 0);
+    vec.retain(|&x| x == 0);
+    vec.retain(|&x| x == 0);
+
+    // Do lint
+    vec.retain(|x| *x == 0);
+    vec.retain(|x| *x == 0);
+    vec.retain(|x| *x == 0);
+}
diff --git a/tests/ui/manual_retain.rs b/tests/ui/manual_retain.rs
index d839550f33a..7e2c597c2c4 100644
--- a/tests/ui/manual_retain.rs
+++ b/tests/ui/manual_retain.rs
@@ -14,6 +14,9 @@ fn main() {
     _msrv_153();
     _msrv_126();
     _msrv_118();
+
+    issue_10393();
+    issue_12081();
 }
 
 fn binary_heap_retain() {
@@ -23,6 +26,11 @@ fn binary_heap_retain() {
     binary_heap = binary_heap.iter().filter(|&x| x % 2 == 0).copied().collect();
     binary_heap = binary_heap.iter().filter(|&x| x % 2 == 0).cloned().collect();
 
+    // Do lint, because we use pattern matching
+    let mut tuples = BinaryHeap::from([(0, 1), (1, 2), (2, 3)]);
+    tuples = tuples.iter().filter(|(ref x, ref y)| *x == 0).copied().collect();
+    tuples = tuples.iter().filter(|(x, y)| *x == 0).copied().collect();
+
     // Do not lint, because type conversion is performed
     binary_heap = binary_heap
         .into_iter()
@@ -58,6 +66,9 @@ fn btree_map_retain() {
         .filter(|(k, v)| (k % 2 == 0) && (v % 2 == 0))
         .collect();
 
+    // Do not lint, because the parameters are not matched in tuple pattern
+    btree_map = btree_map.into_iter().filter(|t| t.0 % 2 == 0).collect();
+
     // Do not lint.
     btree_map = btree_map
         .into_iter()
@@ -79,6 +90,11 @@ fn btree_set_retain() {
     btree_set = btree_set.iter().filter(|&x| x % 2 == 0).cloned().collect();
     btree_set = btree_set.into_iter().filter(|x| x % 2 == 0).collect();
 
+    // Do lint, because we use pattern matching
+    let mut tuples = BTreeSet::from([(0, 1), (1, 2), (2, 3)]);
+    tuples = tuples.iter().filter(|(ref x, ref y)| *x == 0).copied().collect();
+    tuples = tuples.iter().filter(|(x, y)| *x == 0).copied().collect();
+
     // Do not lint, because type conversion is performed
     btree_set = btree_set
         .iter()
@@ -114,6 +130,9 @@ fn hash_map_retain() {
         .filter(|(k, v)| (k % 2 == 0) && (v % 2 == 0))
         .collect();
 
+    // Do not lint, because the parameters are not matched in tuple pattern
+    hash_map = hash_map.into_iter().filter(|t| t.0 % 2 == 0).collect();
+
     // Do not lint.
     hash_map = hash_map
         .into_iter()
@@ -134,6 +153,11 @@ fn hash_set_retain() {
     hash_set = hash_set.iter().filter(|&x| x % 2 == 0).copied().collect();
     hash_set = hash_set.iter().filter(|&x| x % 2 == 0).cloned().collect();
 
+    // Do lint, because we use pattern matching
+    let mut tuples = HashSet::from([(0, 1), (1, 2), (2, 3)]);
+    tuples = tuples.iter().filter(|(ref x, ref y)| *x == 0).copied().collect();
+    tuples = tuples.iter().filter(|(x, y)| *x == 0).copied().collect();
+
     // Do not lint, because type conversion is performed
     hash_set = hash_set.into_iter().filter(|x| x % 2 == 0).collect::<HashSet<i8>>();
     hash_set = hash_set
@@ -163,6 +187,9 @@ fn string_retain() {
     // Do lint.
     s = s.chars().filter(|&c| c != 'o').to_owned().collect();
 
+    // Do not lint, because we need to rewrite the lambda
+    s = s.chars().filter(|c| *c != 'o').to_owned().collect();
+
     // Do not lint, because this expression is not assign.
     let mut bar: String = s.chars().filter(|&c| c != 'o').to_owned().collect();
 
@@ -177,6 +204,11 @@ fn vec_retain() {
     vec = vec.iter().filter(|&x| x % 2 == 0).cloned().collect();
     vec = vec.into_iter().filter(|x| x % 2 == 0).collect();
 
+    // Do lint, because we use pattern matching
+    let mut tuples = vec![(0, 1), (1, 2), (2, 3)];
+    tuples = tuples.iter().filter(|(ref x, ref y)| *x == 0).copied().collect();
+    tuples = tuples.iter().filter(|(x, y)| *x == 0).copied().collect();
+
     // Do not lint, because type conversion is performed
     vec = vec.into_iter().filter(|x| x % 2 == 0).collect::<Vec<i8>>();
     vec = vec.iter().filter(|&x| x % 2 == 0).copied().collect::<Vec<i8>>();
@@ -252,3 +284,27 @@ fn _msrv_118() {
     let mut hash_map: HashMap<i8, i8> = (0..8).map(|x| (x, x * 10)).collect();
     hash_map = hash_map.into_iter().filter(|(k, _)| k % 2 == 0).collect();
 }
+
+fn issue_10393() {
+    // Do lint
+    let mut vec = vec![(0, 1), (1, 2), (2, 3)];
+    vec = vec.into_iter().filter(|(x, y)| *x == 0).collect();
+
+    // Do lint
+    let mut tuples = vec![(true, -2), (false, 3)];
+    tuples = tuples.into_iter().filter(|(_, n)| *n > 0).collect();
+}
+
+fn issue_12081() {
+    let mut vec = vec![0, 1, 2];
+
+    // Do lint
+    vec = vec.iter().filter(|&&x| x == 0).copied().collect();
+    vec = vec.iter().filter(|&&x| x == 0).cloned().collect();
+    vec = vec.into_iter().filter(|&x| x == 0).collect();
+
+    // Do lint
+    vec = vec.iter().filter(|&x| *x == 0).copied().collect();
+    vec = vec.iter().filter(|&x| *x == 0).cloned().collect();
+    vec = vec.into_iter().filter(|x| *x == 0).collect();
+}
diff --git a/tests/ui/manual_retain.stderr b/tests/ui/manual_retain.stderr
index 0c5b1383b6a..eca065f5335 100644
--- a/tests/ui/manual_retain.stderr
+++ b/tests/ui/manual_retain.stderr
@@ -1,5 +1,5 @@
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/manual_retain.rs:22:5
+  --> $DIR/manual_retain.rs:25:5
    |
 LL |     binary_heap = binary_heap.into_iter().filter(|x| x % 2 == 0).collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `binary_heap.retain(|x| x % 2 == 0)`
@@ -8,31 +8,43 @@ LL |     binary_heap = binary_heap.into_iter().filter(|x| x % 2 == 0).collect();
    = help: to override `-D warnings` add `#[allow(clippy::manual_retain)]`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/manual_retain.rs:23:5
+  --> $DIR/manual_retain.rs:26:5
    |
 LL |     binary_heap = binary_heap.iter().filter(|&x| x % 2 == 0).copied().collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `binary_heap.retain(|x| x % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/manual_retain.rs:24:5
+  --> $DIR/manual_retain.rs:27:5
    |
 LL |     binary_heap = binary_heap.iter().filter(|&x| x % 2 == 0).cloned().collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `binary_heap.retain(|x| x % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/manual_retain.rs:54:5
+  --> $DIR/manual_retain.rs:31:5
+   |
+LL |     tuples = tuples.iter().filter(|(ref x, ref y)| *x == 0).copied().collect();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `tuples.retain(|(ref x, ref y)| *x == 0)`
+
+error: this expression can be written more simply using `.retain()`
+  --> $DIR/manual_retain.rs:32:5
+   |
+LL |     tuples = tuples.iter().filter(|(x, y)| *x == 0).copied().collect();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `tuples.retain(|(x, y)| *x == 0)`
+
+error: this expression can be written more simply using `.retain()`
+  --> $DIR/manual_retain.rs:62:5
    |
 LL |     btree_map = btree_map.into_iter().filter(|(k, _)| k % 2 == 0).collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `btree_map.retain(|k, _| k % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/manual_retain.rs:55:5
+  --> $DIR/manual_retain.rs:63:5
    |
 LL |     btree_map = btree_map.into_iter().filter(|(_, v)| v % 2 == 0).collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `btree_map.retain(|_, &mut v| v % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/manual_retain.rs:56:5
+  --> $DIR/manual_retain.rs:64:5
    |
 LL | /     btree_map = btree_map
 LL | |         .into_iter()
@@ -41,37 +53,49 @@ LL | |         .collect();
    | |__________________^ help: consider calling `.retain()` instead: `btree_map.retain(|k, &mut v| (k % 2 == 0) && (v % 2 == 0))`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/manual_retain.rs:78:5
+  --> $DIR/manual_retain.rs:89:5
    |
 LL |     btree_set = btree_set.iter().filter(|&x| x % 2 == 0).copied().collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `btree_set.retain(|x| x % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/manual_retain.rs:79:5
+  --> $DIR/manual_retain.rs:90:5
    |
 LL |     btree_set = btree_set.iter().filter(|&x| x % 2 == 0).cloned().collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `btree_set.retain(|x| x % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/manual_retain.rs:80:5
+  --> $DIR/manual_retain.rs:91:5
    |
 LL |     btree_set = btree_set.into_iter().filter(|x| x % 2 == 0).collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `btree_set.retain(|x| x % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/manual_retain.rs:110:5
+  --> $DIR/manual_retain.rs:95:5
+   |
+LL |     tuples = tuples.iter().filter(|(ref x, ref y)| *x == 0).copied().collect();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `tuples.retain(|(ref x, ref y)| *x == 0)`
+
+error: this expression can be written more simply using `.retain()`
+  --> $DIR/manual_retain.rs:96:5
+   |
+LL |     tuples = tuples.iter().filter(|(x, y)| *x == 0).copied().collect();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `tuples.retain(|(x, y)| *x == 0)`
+
+error: this expression can be written more simply using `.retain()`
+  --> $DIR/manual_retain.rs:126:5
    |
 LL |     hash_map = hash_map.into_iter().filter(|(k, _)| k % 2 == 0).collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `hash_map.retain(|k, _| k % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/manual_retain.rs:111:5
+  --> $DIR/manual_retain.rs:127:5
    |
 LL |     hash_map = hash_map.into_iter().filter(|(_, v)| v % 2 == 0).collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `hash_map.retain(|_, &mut v| v % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/manual_retain.rs:112:5
+  --> $DIR/manual_retain.rs:128:5
    |
 LL | /     hash_map = hash_map
 LL | |         .into_iter()
@@ -80,64 +104,136 @@ LL | |         .collect();
    | |__________________^ help: consider calling `.retain()` instead: `hash_map.retain(|k, &mut v| (k % 2 == 0) && (v % 2 == 0))`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/manual_retain.rs:133:5
+  --> $DIR/manual_retain.rs:152:5
    |
 LL |     hash_set = hash_set.into_iter().filter(|x| x % 2 == 0).collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `hash_set.retain(|x| x % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/manual_retain.rs:134:5
+  --> $DIR/manual_retain.rs:153:5
    |
 LL |     hash_set = hash_set.iter().filter(|&x| x % 2 == 0).copied().collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `hash_set.retain(|x| x % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/manual_retain.rs:135:5
+  --> $DIR/manual_retain.rs:154:5
    |
 LL |     hash_set = hash_set.iter().filter(|&x| x % 2 == 0).cloned().collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `hash_set.retain(|x| x % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/manual_retain.rs:164:5
+  --> $DIR/manual_retain.rs:158:5
+   |
+LL |     tuples = tuples.iter().filter(|(ref x, ref y)| *x == 0).copied().collect();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `tuples.retain(|(ref x, ref y)| *x == 0)`
+
+error: this expression can be written more simply using `.retain()`
+  --> $DIR/manual_retain.rs:159:5
+   |
+LL |     tuples = tuples.iter().filter(|(x, y)| *x == 0).copied().collect();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `tuples.retain(|(x, y)| *x == 0)`
+
+error: this expression can be written more simply using `.retain()`
+  --> $DIR/manual_retain.rs:188:5
    |
 LL |     s = s.chars().filter(|&c| c != 'o').to_owned().collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `s.retain(|c| c != 'o')`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/manual_retain.rs:176:5
+  --> $DIR/manual_retain.rs:203:5
    |
 LL |     vec = vec.iter().filter(|&x| x % 2 == 0).copied().collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `vec.retain(|x| x % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/manual_retain.rs:177:5
+  --> $DIR/manual_retain.rs:204:5
    |
 LL |     vec = vec.iter().filter(|&x| x % 2 == 0).cloned().collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `vec.retain(|x| x % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/manual_retain.rs:178:5
+  --> $DIR/manual_retain.rs:205:5
    |
 LL |     vec = vec.into_iter().filter(|x| x % 2 == 0).collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `vec.retain(|x| x % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/manual_retain.rs:200:5
+  --> $DIR/manual_retain.rs:209:5
+   |
+LL |     tuples = tuples.iter().filter(|(ref x, ref y)| *x == 0).copied().collect();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `tuples.retain(|(ref x, ref y)| *x == 0)`
+
+error: this expression can be written more simply using `.retain()`
+  --> $DIR/manual_retain.rs:210:5
+   |
+LL |     tuples = tuples.iter().filter(|(x, y)| *x == 0).copied().collect();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `tuples.retain(|(x, y)| *x == 0)`
+
+error: this expression can be written more simply using `.retain()`
+  --> $DIR/manual_retain.rs:232:5
    |
 LL |     vec_deque = vec_deque.iter().filter(|&x| x % 2 == 0).copied().collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `vec_deque.retain(|x| x % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/manual_retain.rs:201:5
+  --> $DIR/manual_retain.rs:233:5
    |
 LL |     vec_deque = vec_deque.iter().filter(|&x| x % 2 == 0).cloned().collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `vec_deque.retain(|x| x % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> $DIR/manual_retain.rs:202:5
+  --> $DIR/manual_retain.rs:234:5
    |
 LL |     vec_deque = vec_deque.into_iter().filter(|x| x % 2 == 0).collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `vec_deque.retain(|x| x % 2 == 0)`
 
-error: aborting due to 22 previous errors
+error: this expression can be written more simply using `.retain()`
+  --> $DIR/manual_retain.rs:291:5
+   |
+LL |     vec = vec.into_iter().filter(|(x, y)| *x == 0).collect();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `vec.retain(|(x, y)| *x == 0)`
+
+error: this expression can be written more simply using `.retain()`
+  --> $DIR/manual_retain.rs:295:5
+   |
+LL |     tuples = tuples.into_iter().filter(|(_, n)| *n > 0).collect();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `tuples.retain(|(_, n)| *n > 0)`
+
+error: this expression can be written more simply using `.retain()`
+  --> $DIR/manual_retain.rs:302:5
+   |
+LL |     vec = vec.iter().filter(|&&x| x == 0).copied().collect();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `vec.retain(|&x| x == 0)`
+
+error: this expression can be written more simply using `.retain()`
+  --> $DIR/manual_retain.rs:303:5
+   |
+LL |     vec = vec.iter().filter(|&&x| x == 0).cloned().collect();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `vec.retain(|&x| x == 0)`
+
+error: this expression can be written more simply using `.retain()`
+  --> $DIR/manual_retain.rs:304:5
+   |
+LL |     vec = vec.into_iter().filter(|&x| x == 0).collect();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `vec.retain(|&x| x == 0)`
+
+error: this expression can be written more simply using `.retain()`
+  --> $DIR/manual_retain.rs:307:5
+   |
+LL |     vec = vec.iter().filter(|&x| *x == 0).copied().collect();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `vec.retain(|x| *x == 0)`
+
+error: this expression can be written more simply using `.retain()`
+  --> $DIR/manual_retain.rs:308:5
+   |
+LL |     vec = vec.iter().filter(|&x| *x == 0).cloned().collect();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `vec.retain(|x| *x == 0)`
+
+error: this expression can be written more simply using `.retain()`
+  --> $DIR/manual_retain.rs:309:5
+   |
+LL |     vec = vec.into_iter().filter(|x| *x == 0).collect();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `vec.retain(|x| *x == 0)`
+
+error: aborting due to 38 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 5960107415caf34a84fc8bb2f2fd303b7e358041 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Sat, 30 Dec 2023 03:15:38 +0100
Subject: new lint: `option_as_ref_cloned`

---
 CHANGELOG.md                                     |  1 +
 README.md                                        |  2 +-
 book/src/README.md                               |  2 +-
 clippy_lints/src/declared_lints.rs               |  1 +
 clippy_lints/src/methods/mod.rs                  | 32 +++++++++++++++++++-
 clippy_lints/src/methods/option_as_ref_cloned.rs | 24 +++++++++++++++
 tests/ui/option_as_ref_cloned.fixed              | 21 ++++++++++++++
 tests/ui/option_as_ref_cloned.rs                 | 21 ++++++++++++++
 tests/ui/option_as_ref_cloned.stderr             | 37 ++++++++++++++++++++++++
 9 files changed, 138 insertions(+), 3 deletions(-)
 create mode 100644 clippy_lints/src/methods/option_as_ref_cloned.rs
 create mode 100644 tests/ui/option_as_ref_cloned.fixed
 create mode 100644 tests/ui/option_as_ref_cloned.rs
 create mode 100644 tests/ui/option_as_ref_cloned.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index e6c081ca94f..4d32bbec914 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5442,6 +5442,7 @@ Released 2018-09-13
 [`only_used_in_recursion`]: https://rust-lang.github.io/rust-clippy/master/index.html#only_used_in_recursion
 [`op_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#op_ref
 [`option_and_then_some`]: https://rust-lang.github.io/rust-clippy/master/index.html#option_and_then_some
+[`option_as_ref_cloned`]: https://rust-lang.github.io/rust-clippy/master/index.html#option_as_ref_cloned
 [`option_as_ref_deref`]: https://rust-lang.github.io/rust-clippy/master/index.html#option_as_ref_deref
 [`option_env_unwrap`]: https://rust-lang.github.io/rust-clippy/master/index.html#option_env_unwrap
 [`option_expect_used`]: https://rust-lang.github.io/rust-clippy/master/index.html#option_expect_used
diff --git a/README.md b/README.md
index 5d490645d89..0450b54121d 100644
--- a/README.md
+++ b/README.md
@@ -5,7 +5,7 @@
 
 A collection of lints to catch common mistakes and improve your [Rust](https://github.com/rust-lang/rust) code.
 
-[There are over 650 lints included in this crate!](https://rust-lang.github.io/rust-clippy/master/index.html)
+[There are over 700 lints included in this crate!](https://rust-lang.github.io/rust-clippy/master/index.html)
 
 Lints are divided into categories, each with a default [lint level](https://doc.rust-lang.org/rustc/lints/levels.html).
 You can choose how much Clippy is supposed to ~~annoy~~ help you by changing the lint level by category.
diff --git a/book/src/README.md b/book/src/README.md
index 486ea3df704..e7972b0db19 100644
--- a/book/src/README.md
+++ b/book/src/README.md
@@ -6,7 +6,7 @@
 A collection of lints to catch common mistakes and improve your
 [Rust](https://github.com/rust-lang/rust) code.
 
-[There are over 650 lints included in this crate!](https://rust-lang.github.io/rust-clippy/master/index.html)
+[There are over 700 lints included in this crate!](https://rust-lang.github.io/rust-clippy/master/index.html)
 
 Lints are divided into categories, each with a default [lint
 level](https://doc.rust-lang.org/rustc/lints/levels.html). You can choose how
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index f6c9ffea9fc..20230106d53 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -410,6 +410,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::methods::NO_EFFECT_REPLACE_INFO,
     crate::methods::OBFUSCATED_IF_ELSE_INFO,
     crate::methods::OK_EXPECT_INFO,
+    crate::methods::OPTION_AS_REF_CLONED_INFO,
     crate::methods::OPTION_AS_REF_DEREF_INFO,
     crate::methods::OPTION_FILTER_MAP_INFO,
     crate::methods::OPTION_MAP_OR_ERR_OK_INFO,
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index fbca641cfa3..cf6f6ad1a0f 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -71,6 +71,7 @@ mod no_effect_replace;
 mod obfuscated_if_else;
 mod ok_expect;
 mod open_options;
+mod option_as_ref_cloned;
 mod option_as_ref_deref;
 mod option_map_or_err_ok;
 mod option_map_or_none;
@@ -3887,6 +3888,31 @@ declare_clippy_lint! {
     "splitting a trimmed string at hard-coded newlines"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of `.as_ref().cloned()` and `.as_mut().cloned()` on `Option`s
+    ///
+    /// ### Why is this bad?
+    /// This can be written more concisely by cloning the `Option` directly.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// fn foo(bar: &Option<Vec<u8>>) -> Option<Vec<u8>> {
+    ///     bar.as_ref().cloned()
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// fn foo(bar: &Option<Vec<u8>>) -> Option<Vec<u8>> {
+    ///     bar.clone()
+    /// }
+    /// ```
+    #[clippy::version = "1.77.0"]
+    pub OPTION_AS_REF_CLONED,
+    pedantic,
+    "cloning an `Option` via `as_ref().cloned()`"
+}
+
 pub struct Methods {
     avoid_breaking_exported_api: bool,
     msrv: Msrv,
@@ -4043,6 +4069,7 @@ impl_lint_pass!(Methods => [
     ITER_FILTER_IS_OK,
     MANUAL_IS_VARIANT_AND,
     STR_SPLIT_AT_NEWLINE,
+    OPTION_AS_REF_CLONED,
 ]);
 
 /// Extracts a method call name, args, and `Span` of the method name.
@@ -4290,7 +4317,10 @@ impl Methods {
                 ("as_mut", []) => useless_asref::check(cx, expr, "as_mut", recv),
                 ("as_ref", []) => useless_asref::check(cx, expr, "as_ref", recv),
                 ("assume_init", []) => uninit_assumed_init::check(cx, expr, recv),
-                ("cloned", []) => cloned_instead_of_copied::check(cx, expr, recv, span, &self.msrv),
+                ("cloned", []) => {
+                    cloned_instead_of_copied::check(cx, expr, recv, span, &self.msrv);
+                    option_as_ref_cloned::check(cx, recv, span);
+                },
                 ("collect", []) if is_trait_method(cx, expr, sym::Iterator) => {
                     needless_collect::check(cx, span, expr, recv, call_span);
                     match method_call(recv) {
diff --git a/clippy_lints/src/methods/option_as_ref_cloned.rs b/clippy_lints/src/methods/option_as_ref_cloned.rs
new file mode 100644
index 00000000000..d7fec360fa2
--- /dev/null
+++ b/clippy_lints/src/methods/option_as_ref_cloned.rs
@@ -0,0 +1,24 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::ty::is_type_diagnostic_item;
+use rustc_errors::Applicability;
+use rustc_hir::Expr;
+use rustc_lint::LateContext;
+use rustc_span::{sym, Span};
+
+use super::{method_call, OPTION_AS_REF_CLONED};
+
+pub(super) fn check(cx: &LateContext<'_>, cloned_recv: &Expr<'_>, cloned_ident_span: Span) {
+    if let Some((method @ ("as_ref" | "as_mut"), as_ref_recv, [], as_ref_ident_span, _)) = method_call(cloned_recv)
+        && is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(as_ref_recv).peel_refs(), sym::Option)
+    {
+        span_lint_and_sugg(
+            cx,
+            OPTION_AS_REF_CLONED,
+            as_ref_ident_span.to(cloned_ident_span),
+            &format!("cloning an `Option<_>` using `.{method}().cloned()`"),
+            "this can be written more concisely by cloning the `Option<_>` directly",
+            "clone".into(),
+            Applicability::MachineApplicable,
+        );
+    }
+}
diff --git a/tests/ui/option_as_ref_cloned.fixed b/tests/ui/option_as_ref_cloned.fixed
new file mode 100644
index 00000000000..394dad219f7
--- /dev/null
+++ b/tests/ui/option_as_ref_cloned.fixed
@@ -0,0 +1,21 @@
+#![warn(clippy::option_as_ref_cloned)]
+#![allow(clippy::clone_on_copy)]
+
+fn main() {
+    let mut x = Some(String::new());
+
+    let _: Option<String> = x.clone();
+    let _: Option<String> = x.clone();
+
+    let y = x.as_ref();
+    let _: Option<&String> = y.clone();
+
+    macro_rules! cloned_recv {
+        () => {
+            x.as_ref()
+        };
+    }
+
+    // Don't lint when part of the expression is from a macro
+    let _: Option<String> = cloned_recv!().cloned();
+}
diff --git a/tests/ui/option_as_ref_cloned.rs b/tests/ui/option_as_ref_cloned.rs
new file mode 100644
index 00000000000..7243957927b
--- /dev/null
+++ b/tests/ui/option_as_ref_cloned.rs
@@ -0,0 +1,21 @@
+#![warn(clippy::option_as_ref_cloned)]
+#![allow(clippy::clone_on_copy)]
+
+fn main() {
+    let mut x = Some(String::new());
+
+    let _: Option<String> = x.as_ref().cloned();
+    let _: Option<String> = x.as_mut().cloned();
+
+    let y = x.as_ref();
+    let _: Option<&String> = y.as_ref().cloned();
+
+    macro_rules! cloned_recv {
+        () => {
+            x.as_ref()
+        };
+    }
+
+    // Don't lint when part of the expression is from a macro
+    let _: Option<String> = cloned_recv!().cloned();
+}
diff --git a/tests/ui/option_as_ref_cloned.stderr b/tests/ui/option_as_ref_cloned.stderr
new file mode 100644
index 00000000000..ea03da3b69f
--- /dev/null
+++ b/tests/ui/option_as_ref_cloned.stderr
@@ -0,0 +1,37 @@
+error: cloning an `Option<_>` using `.as_ref().cloned()`
+  --> $DIR/option_as_ref_cloned.rs:7:31
+   |
+LL |     let _: Option<String> = x.as_ref().cloned();
+   |                               ^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::option-as-ref-cloned` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::option_as_ref_cloned)]`
+help: this can be written more concisely by cloning the `Option<_>` directly
+   |
+LL |     let _: Option<String> = x.clone();
+   |                               ~~~~~
+
+error: cloning an `Option<_>` using `.as_mut().cloned()`
+  --> $DIR/option_as_ref_cloned.rs:8:31
+   |
+LL |     let _: Option<String> = x.as_mut().cloned();
+   |                               ^^^^^^^^^^^^^^^
+   |
+help: this can be written more concisely by cloning the `Option<_>` directly
+   |
+LL |     let _: Option<String> = x.clone();
+   |                               ~~~~~
+
+error: cloning an `Option<_>` using `.as_ref().cloned()`
+  --> $DIR/option_as_ref_cloned.rs:11:32
+   |
+LL |     let _: Option<&String> = y.as_ref().cloned();
+   |                                ^^^^^^^^^^^^^^^
+   |
+help: this can be written more concisely by cloning the `Option<_>` directly
+   |
+LL |     let _: Option<&String> = y.clone();
+   |                                ~~~~~
+
+error: aborting due to 3 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From e75841397365ff207553551f14ab35122774f23c Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Thu, 4 Jan 2024 17:13:18 +0100
Subject: Add .as_ref() to suggestion to remove .to_string()

---
 clippy_lints/src/methods/unnecessary_to_owned.rs | 19 ++++++++++++++++---
 tests/ui/unnecessary_to_owned_on_split.fixed     | 18 +++++++++++++++++-
 tests/ui/unnecessary_to_owned_on_split.rs        | 18 +++++++++++++++++-
 tests/ui/unnecessary_to_owned_on_split.stderr    | 24 +++++++++++++++---------
 4 files changed, 65 insertions(+), 14 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/unnecessary_to_owned.rs b/clippy_lints/src/methods/unnecessary_to_owned.rs
index 5f69cf6cd7a..12106d44e36 100644
--- a/clippy_lints/src/methods/unnecessary_to_owned.rs
+++ b/clippy_lints/src/methods/unnecessary_to_owned.rs
@@ -3,13 +3,13 @@ use super::unnecessary_iter_cloned::{self, is_into_iter};
 use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_opt;
-use clippy_utils::ty::{get_iterator_item_ty, implements_trait, is_copy, peel_mid_ty_refs};
+use clippy_utils::ty::{get_iterator_item_ty, implements_trait, is_copy, is_type_lang_item, peel_mid_ty_refs};
 use clippy_utils::visitors::find_all_ret_expressions;
 use clippy_utils::{fn_def_id, get_parent_expr, is_diag_item_method, is_diag_trait_item, return_ty};
 use rustc_errors::Applicability;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::def_id::DefId;
-use rustc_hir::{BorrowKind, Expr, ExprKind, ItemKind, Node};
+use rustc_hir::{BorrowKind, Expr, ExprKind, ItemKind, LangItem, Node};
 use rustc_hir_typeck::{FnCtxt, Inherited};
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::LateContext;
@@ -246,6 +246,19 @@ fn check_split_call_arg(cx: &LateContext<'_>, expr: &Expr<'_>, method_name: Symb
         && let Some(receiver_snippet) = snippet_opt(cx, receiver.span)
         && let Some(arg_snippet) = snippet_opt(cx, argument_expr.span)
     {
+        // We may end-up here because of an expression like `x.to_string().split(…)` where the type of `x`
+        // implements `AsRef<str>` but does not implement `Deref<Target = str>`. In this case, we have to
+        // add `.as_ref()` to the suggestion.
+        let as_ref = if is_type_lang_item(cx, cx.typeck_results().expr_ty(expr), LangItem::String)
+            && let Some(deref_trait_id) = cx.tcx.get_diagnostic_item(sym::Deref)
+            && cx.get_associated_type(cx.typeck_results().expr_ty(receiver), deref_trait_id, "Target")
+                != Some(cx.tcx.types.str_)
+        {
+            ".as_ref()"
+        } else {
+            ""
+        };
+
         // The next suggestion may be incorrect because the removal of the `to_owned`-like
         // function could cause the iterator to hold a reference to a resource that is used
         // mutably. See https://github.com/rust-lang/rust-clippy/issues/8148.
@@ -255,7 +268,7 @@ fn check_split_call_arg(cx: &LateContext<'_>, expr: &Expr<'_>, method_name: Symb
             parent.span,
             &format!("unnecessary use of `{method_name}`"),
             "use",
-            format!("{receiver_snippet}.split({arg_snippet})"),
+            format!("{receiver_snippet}{as_ref}.split({arg_snippet})"),
             Applicability::MaybeIncorrect,
         );
         return true;
diff --git a/tests/ui/unnecessary_to_owned_on_split.fixed b/tests/ui/unnecessary_to_owned_on_split.fixed
index 53dc3c43e2f..f87c898f9b7 100644
--- a/tests/ui/unnecessary_to_owned_on_split.fixed
+++ b/tests/ui/unnecessary_to_owned_on_split.fixed
@@ -1,4 +1,18 @@
-#[allow(clippy::single_char_pattern)]
+#![allow(clippy::single_char_pattern)]
+
+struct Issue12068;
+
+impl AsRef<str> for Issue12068 {
+    fn as_ref(&self) -> &str {
+        ""
+    }
+}
+
+impl ToString for Issue12068 {
+    fn to_string(&self) -> String {
+        String::new()
+    }
+}
 
 fn main() {
     let _ = "a".split('a').next().unwrap();
@@ -9,6 +23,8 @@ fn main() {
     //~^ ERROR: unnecessary use of `to_owned`
     let _ = "a".split("a").next().unwrap();
     //~^ ERROR: unnecessary use of `to_owned`
+    let _ = Issue12068.as_ref().split('a').next().unwrap();
+    //~^ ERROR: unnecessary use of `to_string`
 
     let _ = [1].split(|x| *x == 2).next().unwrap();
     //~^ ERROR: unnecessary use of `to_vec`
diff --git a/tests/ui/unnecessary_to_owned_on_split.rs b/tests/ui/unnecessary_to_owned_on_split.rs
index 62400e7eee1..db5719e5880 100644
--- a/tests/ui/unnecessary_to_owned_on_split.rs
+++ b/tests/ui/unnecessary_to_owned_on_split.rs
@@ -1,4 +1,18 @@
-#[allow(clippy::single_char_pattern)]
+#![allow(clippy::single_char_pattern)]
+
+struct Issue12068;
+
+impl AsRef<str> for Issue12068 {
+    fn as_ref(&self) -> &str {
+        ""
+    }
+}
+
+impl ToString for Issue12068 {
+    fn to_string(&self) -> String {
+        String::new()
+    }
+}
 
 fn main() {
     let _ = "a".to_string().split('a').next().unwrap();
@@ -9,6 +23,8 @@ fn main() {
     //~^ ERROR: unnecessary use of `to_owned`
     let _ = "a".to_owned().split("a").next().unwrap();
     //~^ ERROR: unnecessary use of `to_owned`
+    let _ = Issue12068.to_string().split('a').next().unwrap();
+    //~^ ERROR: unnecessary use of `to_string`
 
     let _ = [1].to_vec().split(|x| *x == 2).next().unwrap();
     //~^ ERROR: unnecessary use of `to_vec`
diff --git a/tests/ui/unnecessary_to_owned_on_split.stderr b/tests/ui/unnecessary_to_owned_on_split.stderr
index cfb3766d15e..4cfaeed3384 100644
--- a/tests/ui/unnecessary_to_owned_on_split.stderr
+++ b/tests/ui/unnecessary_to_owned_on_split.stderr
@@ -1,5 +1,5 @@
 error: unnecessary use of `to_string`
-  --> $DIR/unnecessary_to_owned_on_split.rs:4:13
+  --> $DIR/unnecessary_to_owned_on_split.rs:18:13
    |
 LL |     let _ = "a".to_string().split('a').next().unwrap();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `"a".split('a')`
@@ -8,46 +8,52 @@ LL |     let _ = "a".to_string().split('a').next().unwrap();
    = help: to override `-D warnings` add `#[allow(clippy::unnecessary_to_owned)]`
 
 error: unnecessary use of `to_string`
-  --> $DIR/unnecessary_to_owned_on_split.rs:6:13
+  --> $DIR/unnecessary_to_owned_on_split.rs:20:13
    |
 LL |     let _ = "a".to_string().split("a").next().unwrap();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `"a".split("a")`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned_on_split.rs:8:13
+  --> $DIR/unnecessary_to_owned_on_split.rs:22:13
    |
 LL |     let _ = "a".to_owned().split('a').next().unwrap();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `"a".split('a')`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned_on_split.rs:10:13
+  --> $DIR/unnecessary_to_owned_on_split.rs:24:13
    |
 LL |     let _ = "a".to_owned().split("a").next().unwrap();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `"a".split("a")`
 
+error: unnecessary use of `to_string`
+  --> $DIR/unnecessary_to_owned_on_split.rs:26:13
+   |
+LL |     let _ = Issue12068.to_string().split('a').next().unwrap();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `Issue12068.as_ref().split('a')`
+
 error: unnecessary use of `to_vec`
-  --> $DIR/unnecessary_to_owned_on_split.rs:13:13
+  --> $DIR/unnecessary_to_owned_on_split.rs:29:13
    |
 LL |     let _ = [1].to_vec().split(|x| *x == 2).next().unwrap();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `[1].split(|x| *x == 2)`
 
 error: unnecessary use of `to_vec`
-  --> $DIR/unnecessary_to_owned_on_split.rs:15:13
+  --> $DIR/unnecessary_to_owned_on_split.rs:31:13
    |
 LL |     let _ = [1].to_vec().split(|x| *x == 2).next().unwrap();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `[1].split(|x| *x == 2)`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned_on_split.rs:17:13
+  --> $DIR/unnecessary_to_owned_on_split.rs:33:13
    |
 LL |     let _ = [1].to_owned().split(|x| *x == 2).next().unwrap();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `[1].split(|x| *x == 2)`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned_on_split.rs:19:13
+  --> $DIR/unnecessary_to_owned_on_split.rs:35:13
    |
 LL |     let _ = [1].to_owned().split(|x| *x == 2).next().unwrap();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `[1].split(|x| *x == 2)`
 
-error: aborting due to 8 previous errors
+error: aborting due to 9 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 2666f39d3e5d4b354065056102ef4856aa23fdae Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Wed, 3 Jan 2024 22:14:36 +0100
Subject: Detect unconditional recursion between Default trait impl and static
 methods

---
 clippy_lints/src/lib.rs                     |   2 +-
 clippy_lints/src/unconditional_recursion.rs | 271 +++++++++++++++++++++++-----
 2 files changed, 231 insertions(+), 42 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 854c111f9f5..efdd3925949 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1083,7 +1083,7 @@ pub fn register_lints(store: &mut rustc_lint::LintStore, conf: &'static Conf) {
     store.register_late_pass(|_| Box::new(repeat_vec_with_capacity::RepeatVecWithCapacity));
     store.register_late_pass(|_| Box::new(uninhabited_references::UninhabitedReferences));
     store.register_late_pass(|_| Box::new(ineffective_open_options::IneffectiveOpenOptions));
-    store.register_late_pass(|_| Box::new(unconditional_recursion::UnconditionalRecursion));
+    store.register_late_pass(|_| Box::<unconditional_recursion::UnconditionalRecursion>::default());
     store.register_late_pass(move |_| {
         Box::new(pub_underscore_fields::PubUnderscoreFields {
             behavior: pub_underscore_fields_behavior,
diff --git a/clippy_lints/src/unconditional_recursion.rs b/clippy_lints/src/unconditional_recursion.rs
index 5366b5513d3..e90306ded61 100644
--- a/clippy_lints/src/unconditional_recursion.rs
+++ b/clippy_lints/src/unconditional_recursion.rs
@@ -1,13 +1,19 @@
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::{expr_or_init, get_trait_def_id};
+use clippy_utils::{expr_or_init, get_trait_def_id, path_def_id};
 use rustc_ast::BinOpKind;
+use rustc_data_structures::fx::FxHashMap;
+use rustc_hir as hir;
+use rustc_hir::def::{DefKind, Res};
 use rustc_hir::def_id::{DefId, LocalDefId};
-use rustc_hir::intravisit::{walk_body, FnKind};
-use rustc_hir::{Body, Expr, ExprKind, FnDecl, Item, ItemKind, Node};
+use rustc_hir::intravisit::{walk_body, walk_expr, FnKind, Visitor};
+use rustc_hir::{Body, Expr, ExprKind, FnDecl, HirId, Item, ItemKind, Node, QPath, TyKind};
+use rustc_hir_analysis::hir_ty_to_ty;
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty::{self, Ty};
-use rustc_session::declare_lint_pass;
-use rustc_span::symbol::Ident;
+use rustc_middle::hir::map::Map;
+use rustc_middle::hir::nested_filter;
+use rustc_middle::ty::{self, AssocKind, Ty, TyCtxt};
+use rustc_session::impl_lint_pass;
+use rustc_span::symbol::{kw, Ident};
 use rustc_span::{sym, Span};
 use rustc_trait_selection::traits::error_reporting::suggestions::ReturnsVisitor;
 
@@ -42,7 +48,26 @@ declare_clippy_lint! {
     "detect unconditional recursion in some traits implementation"
 }
 
-declare_lint_pass!(UnconditionalRecursion => [UNCONDITIONAL_RECURSION]);
+#[derive(Default)]
+pub struct UnconditionalRecursion {
+    /// The key is the `DefId` of the type implementing the `Default` trait and the value is the
+    /// `DefId` of the return call.
+    default_impl_for_type: FxHashMap<DefId, DefId>,
+}
+
+impl_lint_pass!(UnconditionalRecursion => [UNCONDITIONAL_RECURSION]);
+
+fn span_error(cx: &LateContext<'_>, method_span: Span, expr: &Expr<'_>) {
+    span_lint_and_then(
+        cx,
+        UNCONDITIONAL_RECURSION,
+        method_span,
+        "function cannot return without recursing",
+        |diag| {
+            diag.span_note(expr.span, "recursive call site");
+        },
+    );
+}
 
 fn get_ty_def_id(ty: Ty<'_>) -> Option<DefId> {
     match ty.peel_refs().kind() {
@@ -52,17 +77,60 @@ fn get_ty_def_id(ty: Ty<'_>) -> Option<DefId> {
     }
 }
 
-fn has_conditional_return(body: &Body<'_>, expr: &Expr<'_>) -> bool {
+fn get_hir_ty_def_id(tcx: TyCtxt<'_>, hir_ty: rustc_hir::Ty<'_>) -> Option<DefId> {
+    let TyKind::Path(qpath) = hir_ty.kind else { return None };
+    match qpath {
+        QPath::Resolved(_, path) => path.res.opt_def_id(),
+        QPath::TypeRelative(_, _) => {
+            let ty = hir_ty_to_ty(tcx, &hir_ty);
+
+            match ty.kind() {
+                ty::Alias(ty::Projection, proj) => {
+                    Res::<HirId>::Def(DefKind::Trait, proj.trait_ref(tcx).def_id).opt_def_id()
+                },
+                _ => None,
+            }
+        },
+        QPath::LangItem(..) => None,
+    }
+}
+
+fn get_return_calls_in_body<'tcx>(body: &'tcx Body<'tcx>) -> Vec<&'tcx Expr<'tcx>> {
     let mut visitor = ReturnsVisitor::default();
 
-    walk_body(&mut visitor, body);
-    match visitor.returns.as_slice() {
+    visitor.visit_body(body);
+    visitor.returns
+}
+
+fn has_conditional_return(body: &Body<'_>, expr: &Expr<'_>) -> bool {
+    match get_return_calls_in_body(body).as_slice() {
         [] => false,
         [return_expr] => return_expr.hir_id != expr.hir_id,
         _ => true,
     }
 }
 
+fn get_impl_trait_def_id(cx: &LateContext<'_>, method_def_id: LocalDefId) -> Option<DefId> {
+    let hir_id = cx.tcx.local_def_id_to_hir_id(method_def_id);
+    if let Some((
+        _,
+        Node::Item(Item {
+            kind: ItemKind::Impl(impl_),
+            owner_id,
+            ..
+        }),
+    )) = cx.tcx.hir().parent_iter(hir_id).next()
+        // We exclude `impl` blocks generated from rustc's proc macros.
+        && !cx.tcx.has_attr(*owner_id, sym::automatically_derived)
+        // It is a implementation of a trait.
+        && let Some(trait_) = impl_.of_trait
+    {
+        trait_.trait_def_id()
+    } else {
+        None
+    }
+}
+
 #[allow(clippy::unnecessary_def_path)]
 fn check_partial_eq(cx: &LateContext<'_>, method_span: Span, method_def_id: LocalDefId, name: Ident, expr: &Expr<'_>) {
     let args = cx
@@ -75,20 +143,7 @@ fn check_partial_eq(cx: &LateContext<'_>, method_span: Span, method_def_id: Loca
         && let Some(other_arg) = get_ty_def_id(*other_arg)
         // The two arguments are of the same type.
         && self_arg == other_arg
-        && let hir_id = cx.tcx.local_def_id_to_hir_id(method_def_id)
-        && let Some((
-            _,
-            Node::Item(Item {
-                kind: ItemKind::Impl(impl_),
-                owner_id,
-                ..
-            }),
-        )) = cx.tcx.hir().parent_iter(hir_id).next()
-        // We exclude `impl` blocks generated from rustc's proc macros.
-        && !cx.tcx.has_attr(*owner_id, sym::automatically_derived)
-        // It is a implementation of a trait.
-        && let Some(trait_) = impl_.of_trait
-        && let Some(trait_def_id) = trait_.trait_def_id()
+        && let Some(trait_def_id) = get_impl_trait_def_id(cx, method_def_id)
         // The trait is `PartialEq`.
         && Some(trait_def_id) == get_trait_def_id(cx, &["core", "cmp", "PartialEq"])
     {
@@ -125,15 +180,7 @@ fn check_partial_eq(cx: &LateContext<'_>, method_span: Span, method_def_id: Loca
             _ => false,
         };
         if is_bad {
-            span_lint_and_then(
-                cx,
-                UNCONDITIONAL_RECURSION,
-                method_span,
-                "function cannot return without recursing",
-                |diag| {
-                    diag.span_note(expr.span, "recursive call site");
-                },
-            );
+            span_error(cx, method_span, expr);
         }
     }
 }
@@ -177,15 +224,156 @@ fn check_to_string(cx: &LateContext<'_>, method_span: Span, method_def_id: Local
             _ => false,
         };
         if is_bad {
-            span_lint_and_then(
+            span_error(cx, method_span, expr);
+        }
+    }
+}
+
+fn is_default_method_on_current_ty(tcx: TyCtxt<'_>, qpath: QPath<'_>, implemented_ty_id: DefId) -> bool {
+    match qpath {
+        QPath::Resolved(_, path) => match path.segments {
+            [first, .., last] => last.ident.name == kw::Default && first.res.opt_def_id() == Some(implemented_ty_id),
+            _ => false,
+        },
+        QPath::TypeRelative(ty, segment) => {
+            if segment.ident.name != kw::Default {
+                return false;
+            }
+            if matches!(
+                ty.kind,
+                TyKind::Path(QPath::Resolved(
+                    _,
+                    hir::Path {
+                        res: Res::SelfTyAlias { .. },
+                        ..
+                    },
+                ))
+            ) {
+                return true;
+            }
+            get_hir_ty_def_id(tcx, *ty) == Some(implemented_ty_id)
+        },
+        QPath::LangItem(..) => false,
+    }
+}
+
+struct CheckCalls<'a, 'tcx> {
+    cx: &'a LateContext<'tcx>,
+    map: Map<'tcx>,
+    implemented_ty_id: DefId,
+    found_default_call: bool,
+    method_span: Span,
+}
+
+impl<'a, 'tcx> Visitor<'tcx> for CheckCalls<'a, 'tcx>
+where
+    'tcx: 'a,
+{
+    type NestedFilter = nested_filter::OnlyBodies;
+
+    fn nested_visit_map(&mut self) -> Self::Map {
+        self.map
+    }
+
+    #[allow(clippy::unnecessary_def_path)]
+    fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) {
+        if self.found_default_call {
+            return;
+        }
+        walk_expr(self, expr);
+
+        if let ExprKind::Call(f, _) = expr.kind
+            && let ExprKind::Path(qpath) = f.kind
+            && is_default_method_on_current_ty(self.cx.tcx, qpath, self.implemented_ty_id)
+            && let Some(method_def_id) = path_def_id(self.cx, f)
+            && let Some(trait_def_id) = self.cx.tcx.trait_of_item(method_def_id)
+            && Some(trait_def_id) == get_trait_def_id(self.cx, &["core", "default", "Default"])
+        {
+            self.found_default_call = true;
+            span_error(self.cx, self.method_span, expr);
+        }
+    }
+}
+
+impl UnconditionalRecursion {
+    #[allow(clippy::unnecessary_def_path)]
+    fn init_default_impl_for_type_if_needed(&mut self, cx: &LateContext<'_>) {
+        if self.default_impl_for_type.is_empty()
+            && let Some(default_trait_id) = get_trait_def_id(cx, &["core", "default", "Default"])
+        {
+            let impls = cx.tcx.trait_impls_of(default_trait_id);
+            for (ty, impl_def_ids) in impls.non_blanket_impls() {
+                let Some(self_def_id) = ty.def() else { continue };
+                for impl_def_id in impl_def_ids {
+                    if !cx.tcx.has_attr(*impl_def_id, sym::automatically_derived) &&
+                        let Some(assoc_item) = cx
+                            .tcx
+                            .associated_items(impl_def_id)
+                            .in_definition_order()
+                            // We're not interested in foreign implementations of the `Default` trait.
+                            .find(|item| {
+                                item.kind == AssocKind::Fn && item.def_id.is_local() && item.name == kw::Default
+                            })
+                        && let Some(body_node) = cx.tcx.hir().get_if_local(assoc_item.def_id)
+                        && let Some(body_id) = body_node.body_id()
+                        && let body = cx.tcx.hir().body(body_id)
+                        // We don't want to keep it if it has conditional return.
+                        && let [return_expr] = get_return_calls_in_body(body).as_slice()
+                        && let ExprKind::Call(call_expr, _) = return_expr.kind
+                        // We need to use typeck here to infer the actual function being called.
+                        && let body_def_id = cx.tcx.hir().enclosing_body_owner(call_expr.hir_id)
+                        && let Some(body_owner) = cx.tcx.hir().maybe_body_owned_by(body_def_id)
+                        && let typeck = cx.tcx.typeck_body(body_owner)
+                        && let Some(call_def_id) = typeck.type_dependent_def_id(call_expr.hir_id)
+                    {
+                        self.default_impl_for_type.insert(self_def_id, call_def_id);
+                    }
+                }
+            }
+        }
+    }
+
+    fn check_default_new<'tcx>(
+        &mut self,
+        cx: &LateContext<'tcx>,
+        decl: &FnDecl<'tcx>,
+        body: &'tcx Body<'tcx>,
+        method_span: Span,
+        method_def_id: LocalDefId,
+    ) {
+        // We're only interested into static methods.
+        if decl.implicit_self.has_implicit_self() {
+            return;
+        }
+        // We don't check trait implementations.
+        if get_impl_trait_def_id(cx, method_def_id).is_some() {
+            return;
+        }
+
+        let hir_id = cx.tcx.local_def_id_to_hir_id(method_def_id);
+        if let Some((
+            _,
+            Node::Item(Item {
+                kind: ItemKind::Impl(impl_),
+                ..
+            }),
+        )) = cx.tcx.hir().parent_iter(hir_id).next()
+            && let Some(implemented_ty_id) = get_hir_ty_def_id(cx.tcx, *impl_.self_ty)
+            && {
+                self.init_default_impl_for_type_if_needed(cx);
+                true
+            }
+            && let Some(return_def_id) = self.default_impl_for_type.get(&implemented_ty_id)
+            && method_def_id.to_def_id() == *return_def_id
+        {
+            let mut c = CheckCalls {
                 cx,
-                UNCONDITIONAL_RECURSION,
+                map: cx.tcx.hir(),
+                implemented_ty_id,
+                found_default_call: false,
                 method_span,
-                "function cannot return without recursing",
-                |diag| {
-                    diag.span_note(expr.span, "recursive call site");
-                },
-            );
+            };
+            walk_body(&mut c, body);
         }
     }
 }
@@ -195,7 +383,7 @@ impl<'tcx> LateLintPass<'tcx> for UnconditionalRecursion {
         &mut self,
         cx: &LateContext<'tcx>,
         kind: FnKind<'tcx>,
-        _decl: &'tcx FnDecl<'tcx>,
+        decl: &'tcx FnDecl<'tcx>,
         body: &'tcx Body<'tcx>,
         method_span: Span,
         method_def_id: LocalDefId,
@@ -211,6 +399,7 @@ impl<'tcx> LateLintPass<'tcx> for UnconditionalRecursion {
             } else if name.name == sym::to_string {
                 check_to_string(cx, method_span, method_def_id, name, expr);
             }
+            self.check_default_new(cx, decl, body, method_span, method_def_id);
         }
     }
 }
-- 
cgit 1.4.1-3-g733a5


From 9e4e8ef1023d02367a8919f4d13df913f2232cb2 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Fri, 5 Jan 2024 16:44:01 +0100
Subject: Don't emit `struct_field_names` lint if all fields are booleans and
 don't start with the type's name

---
 clippy_lints/src/item_name_repetitions.rs | 5 +++++
 1 file changed, 5 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/item_name_repetitions.rs b/clippy_lints/src/item_name_repetitions.rs
index a9f1612ff05..276c1abb60c 100644
--- a/clippy_lints/src/item_name_repetitions.rs
+++ b/clippy_lints/src/item_name_repetitions.rs
@@ -1,6 +1,7 @@
 //! lint on enum variants that are prefixed or suffixed by the same characters
 
 use clippy_utils::diagnostics::{span_lint, span_lint_and_help, span_lint_hir};
+use clippy_utils::is_bool;
 use clippy_utils::macros::span_is_local;
 use clippy_utils::source::is_present_in_source;
 use clippy_utils::str_utils::{camel_case_split, count_match_end, count_match_start, to_camel_case, to_snake_case};
@@ -231,6 +232,10 @@ fn check_fields(cx: &LateContext<'_>, threshold: u64, item: &Item<'_>, fields: &
             (false, _) => ("pre", prefix),
             (true, false) => ("post", postfix),
         };
+        if fields.iter().all(|field| is_bool(field.ty)) {
+            // If all fields are booleans, we don't want to emit this lint.
+            return;
+        }
         span_lint_and_help(
             cx,
             STRUCT_FIELD_NAMES,
-- 
cgit 1.4.1-3-g733a5


From fd9d330839c5ae8ddfa3438b0db422515b06ad36 Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Mon, 29 May 2023 22:05:07 -0500
Subject: Don't lint `let_unit_value` when `()` is explicit

---
 clippy_lints/src/unit_types/let_unit_value.rs | 21 +++++++++-
 tests/ui/crashes/ice-8821.fixed               | 10 -----
 tests/ui/crashes/ice-8821.rs                  |  2 -
 tests/ui/crashes/ice-8821.stderr              | 11 ------
 tests/ui/let_unit.fixed                       | 50 ++++++++++++------------
 tests/ui/let_unit.rs                          | 48 +++++++++++------------
 tests/ui/let_unit.stderr                      | 56 ++-------------------------
 7 files changed, 71 insertions(+), 127 deletions(-)
 delete mode 100644 tests/ui/crashes/ice-8821.fixed
 delete mode 100644 tests/ui/crashes/ice-8821.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unit_types/let_unit_value.rs b/clippy_lints/src/unit_types/let_unit_value.rs
index ef67f4b04b5..ed0958197f8 100644
--- a/clippy_lints/src/unit_types/let_unit_value.rs
+++ b/clippy_lints/src/unit_types/let_unit_value.rs
@@ -13,12 +13,31 @@ use rustc_middle::ty;
 use super::LET_UNIT_VALUE;
 
 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, local: &'tcx Local<'_>) {
+    // skip `let () = { ... }`
+    if let PatKind::Tuple(fields, ..) = local.pat.kind
+        && fields.is_empty()
+    {
+        return;
+    }
+
     if let Some(init) = local.init
         && !local.pat.span.from_expansion()
         && !in_external_macro(cx.sess(), local.span)
         && !is_from_async_await(local.span)
         && cx.typeck_results().pat_ty(local.pat).is_unit()
     {
+        // skip `let awa = ()`
+        if let ExprKind::Tup([]) = init.kind {
+            return;
+        }
+
+        // skip `let _: () = { ... }`
+        if let Some(ty) = local.ty
+            && let TyKind::Tup([]) = ty.kind
+        {
+            return;
+        }
+
         if (local.ty.map_or(false, |ty| !matches!(ty.kind, TyKind::Infer))
             || matches!(local.pat.kind, PatKind::Tuple([], ddpos) if ddpos.as_opt_usize().is_none()))
             && expr_needs_inferred_result(cx, init)
@@ -34,7 +53,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, local: &'tcx Local<'_>) {
                     |diag| {
                         diag.span_suggestion(
                             local.pat.span,
-                            "use a wild (`_`) binding",
+                            "use a wildcard binding",
                             "_",
                             Applicability::MaybeIncorrect, // snippet
                         );
diff --git a/tests/ui/crashes/ice-8821.fixed b/tests/ui/crashes/ice-8821.fixed
deleted file mode 100644
index a25bb46f9ff..00000000000
--- a/tests/ui/crashes/ice-8821.fixed
+++ /dev/null
@@ -1,10 +0,0 @@
-#![warn(clippy::let_unit_value)]
-
-fn f() {}
-static FN: fn() = f;
-
-fn main() {
-    FN();
-    //~^ ERROR: this let-binding has unit value
-    //~| NOTE: `-D clippy::let-unit-value` implied by `-D warnings`
-}
diff --git a/tests/ui/crashes/ice-8821.rs b/tests/ui/crashes/ice-8821.rs
index 082f7c92646..fb87b79aeed 100644
--- a/tests/ui/crashes/ice-8821.rs
+++ b/tests/ui/crashes/ice-8821.rs
@@ -5,6 +5,4 @@ static FN: fn() = f;
 
 fn main() {
     let _: () = FN();
-    //~^ ERROR: this let-binding has unit value
-    //~| NOTE: `-D clippy::let-unit-value` implied by `-D warnings`
 }
diff --git a/tests/ui/crashes/ice-8821.stderr b/tests/ui/crashes/ice-8821.stderr
deleted file mode 100644
index 94ebb20918e..00000000000
--- a/tests/ui/crashes/ice-8821.stderr
+++ /dev/null
@@ -1,11 +0,0 @@
-error: this let-binding has unit value
-  --> $DIR/ice-8821.rs:7:5
-   |
-LL |     let _: () = FN();
-   |     ^^^^^^^^^^^^^^^^^ help: omit the `let` binding: `FN();`
-   |
-   = note: `-D clippy::let-unit-value` implied by `-D warnings`
-   = help: to override `-D warnings` add `#[allow(clippy::let_unit_value)]`
-
-error: aborting due to 1 previous error
-
diff --git a/tests/ui/let_unit.fixed b/tests/ui/let_unit.fixed
index f98ce9d50a9..4d41b5e5e50 100644
--- a/tests/ui/let_unit.fixed
+++ b/tests/ui/let_unit.fixed
@@ -13,7 +13,14 @@ fn main() {
     let _y = 1; // this is fine
     let _z = ((), 1); // this as well
     if true {
-        ();
+        // do not lint this, since () is explicit
+        let _a = ();
+        let () = dummy();
+        let () = ();
+        () = dummy();
+        () = ();
+        let _a: () = ();
+        let _a: () = dummy();
     }
 
     consume_units_with_for_loop(); // should be fine as well
@@ -23,6 +30,8 @@ fn main() {
     let_and_return!(()) // should be fine
 }
 
+fn dummy() {}
+
 // Related to issue #1964
 fn consume_units_with_for_loop() {
     // `for_let_unit` lint should not be triggered by consuming them using for loop.
@@ -74,40 +83,29 @@ fn _returns_generic() {
         x.then(|| T::default())
     }
 
-    let _: () = f(); // Ok
-    let _: () = f(); // Lint.
+    let _: () = f();
+    let x: () = f();
 
-    let _: () = f2(0i32); // Ok
-    let _: () = f2(0i32); // Lint.
+    let _: () = f2(0i32);
+    let x: () = f2(0i32);
 
-    f3(()); // Lint
-    f3(()); // Lint
+    let _: () = f3(());
+    let x: () = f3(());
 
-    // Should lint:
-    // fn f4<T>(mut x: Vec<T>) -> T {
-    //    x.pop().unwrap()
-    // }
-    // let _: () = f4(vec![()]);
-    // let x: () = f4(vec![()]);
+    fn f4<T>(mut x: Vec<T>) -> T {
+        x.pop().unwrap()
+    }
+    let _: () = f4(vec![()]);
+    let x: () = f4(vec![()]);
 
-    // Ok
     let _: () = {
         let x = 5;
         f2(x)
     };
 
-    let _: () = if true { f() } else { f2(0) }; // Ok
-    let _: () = if true { f() } else { f2(0) }; // Lint
-
-    // Ok
-    let _: () = match Some(0) {
-        None => f2(1),
-        Some(0) => f(),
-        Some(1) => f2(3),
-        Some(_) => f2('x'),
-    };
+    let _: () = if true { f() } else { f2(0) };
+    let x: () = if true { f() } else { f2(0) };
 
-    // Lint
     match Some(0) {
         None => f2(1),
         Some(0) => f(),
@@ -155,7 +153,7 @@ fn _returns_generic() {
         {
             let _: () = x;
             let _: () = y;
-            z;
+            let _: () = z;
             let _: () = x1;
             let _: () = x2;
             let _: () = opt;
diff --git a/tests/ui/let_unit.rs b/tests/ui/let_unit.rs
index 6d942ca8908..daa660be25e 100644
--- a/tests/ui/let_unit.rs
+++ b/tests/ui/let_unit.rs
@@ -13,7 +13,14 @@ fn main() {
     let _y = 1; // this is fine
     let _z = ((), 1); // this as well
     if true {
+        // do not lint this, since () is explicit
         let _a = ();
+        let () = dummy();
+        let () = ();
+        () = dummy();
+        () = ();
+        let _a: () = ();
+        let _a: () = dummy();
     }
 
     consume_units_with_for_loop(); // should be fine as well
@@ -23,6 +30,8 @@ fn main() {
     let_and_return!(()) // should be fine
 }
 
+fn dummy() {}
+
 // Related to issue #1964
 fn consume_units_with_for_loop() {
     // `for_let_unit` lint should not be triggered by consuming them using for loop.
@@ -74,41 +83,30 @@ fn _returns_generic() {
         x.then(|| T::default())
     }
 
-    let _: () = f(); // Ok
-    let x: () = f(); // Lint.
+    let _: () = f();
+    let x: () = f();
 
-    let _: () = f2(0i32); // Ok
-    let x: () = f2(0i32); // Lint.
+    let _: () = f2(0i32);
+    let x: () = f2(0i32);
 
-    let _: () = f3(()); // Lint
-    let x: () = f3(()); // Lint
+    let _: () = f3(());
+    let x: () = f3(());
 
-    // Should lint:
-    // fn f4<T>(mut x: Vec<T>) -> T {
-    //    x.pop().unwrap()
-    // }
-    // let _: () = f4(vec![()]);
-    // let x: () = f4(vec![()]);
+    fn f4<T>(mut x: Vec<T>) -> T {
+        x.pop().unwrap()
+    }
+    let _: () = f4(vec![()]);
+    let x: () = f4(vec![()]);
 
-    // Ok
     let _: () = {
         let x = 5;
         f2(x)
     };
 
-    let _: () = if true { f() } else { f2(0) }; // Ok
-    let x: () = if true { f() } else { f2(0) }; // Lint
-
-    // Ok
-    let _: () = match Some(0) {
-        None => f2(1),
-        Some(0) => f(),
-        Some(1) => f2(3),
-        Some(_) => f2('x'),
-    };
+    let _: () = if true { f() } else { f2(0) };
+    let x: () = if true { f() } else { f2(0) };
 
-    // Lint
-    let _: () = match Some(0) {
+    let x = match Some(0) {
         None => f2(1),
         Some(0) => f(),
         Some(1) => f2(3),
diff --git a/tests/ui/let_unit.stderr b/tests/ui/let_unit.stderr
index de106f50e0e..00a3c439ba0 100644
--- a/tests/ui/let_unit.stderr
+++ b/tests/ui/let_unit.stderr
@@ -8,13 +8,7 @@ LL |     let _x = println!("x");
    = help: to override `-D warnings` add `#[allow(clippy::let_unit_value)]`
 
 error: this let-binding has unit value
-  --> $DIR/let_unit.rs:16:9
-   |
-LL |         let _a = ();
-   |         ^^^^^^^^^^^^ help: omit the `let` binding: `();`
-
-error: this let-binding has unit value
-  --> $DIR/let_unit.rs:51:5
+  --> $DIR/let_unit.rs:60:5
    |
 LL | /     let _ = v
 LL | |         .into_iter()
@@ -37,45 +31,9 @@ LL +         .unwrap();
    |
 
 error: this let-binding has unit value
-  --> $DIR/let_unit.rs:78:5
-   |
-LL |     let x: () = f(); // Lint.
-   |     ^^^^-^^^^^^^^^^^
-   |         |
-   |         help: use a wild (`_`) binding: `_`
-
-error: this let-binding has unit value
-  --> $DIR/let_unit.rs:81:5
+  --> $DIR/let_unit.rs:109:5
    |
-LL |     let x: () = f2(0i32); // Lint.
-   |     ^^^^-^^^^^^^^^^^^^^^^
-   |         |
-   |         help: use a wild (`_`) binding: `_`
-
-error: this let-binding has unit value
-  --> $DIR/let_unit.rs:83:5
-   |
-LL |     let _: () = f3(()); // Lint
-   |     ^^^^^^^^^^^^^^^^^^^ help: omit the `let` binding: `f3(());`
-
-error: this let-binding has unit value
-  --> $DIR/let_unit.rs:84:5
-   |
-LL |     let x: () = f3(()); // Lint
-   |     ^^^^^^^^^^^^^^^^^^^ help: omit the `let` binding: `f3(());`
-
-error: this let-binding has unit value
-  --> $DIR/let_unit.rs:100:5
-   |
-LL |     let x: () = if true { f() } else { f2(0) }; // Lint
-   |     ^^^^-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |         |
-   |         help: use a wild (`_`) binding: `_`
-
-error: this let-binding has unit value
-  --> $DIR/let_unit.rs:111:5
-   |
-LL | /     let _: () = match Some(0) {
+LL | /     let x = match Some(0) {
 LL | |         None => f2(1),
 LL | |         Some(0) => f(),
 LL | |         Some(1) => f2(3),
@@ -93,11 +51,5 @@ LL +         Some(_) => (),
 LL +     };
    |
 
-error: this let-binding has unit value
-  --> $DIR/let_unit.rs:158:13
-   |
-LL |             let _: () = z;
-   |             ^^^^^^^^^^^^^^ help: omit the `let` binding: `z;`
-
-error: aborting due to 10 previous errors
+error: aborting due to 3 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From bd6e9202b47ec68841d58b1574361e09c5d7775b Mon Sep 17 00:00:00 2001
From: cocodery <cocodery@outlook.com>
Date: Sat, 6 Jan 2024 14:12:41 +0800
Subject: modify check that any macros will be ingored in this lint, and add
 test

---
 clippy_lints/src/booleans.rs |  3 +--
 tests/ui/nonminimal_bool.rs  | 11 +++++++++++
 2 files changed, 12 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/booleans.rs b/clippy_lints/src/booleans.rs
index 2d0af1017d5..2d1c250ace9 100644
--- a/clippy_lints/src/booleans.rs
+++ b/clippy_lints/src/booleans.rs
@@ -499,11 +499,10 @@ struct NotSimplificationVisitor<'a, 'tcx> {
 impl<'a, 'tcx> Visitor<'tcx> for NotSimplificationVisitor<'a, 'tcx> {
     fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
         if let ExprKind::Unary(UnOp::Not, inner) = &expr.kind
+            && !expr.span.from_expansion()
             && !inner.span.from_expansion()
             && let Some(suggestion) = simplify_not(self.cx, inner)
             && self.cx.tcx.lint_level_at_node(NONMINIMAL_BOOL, expr.hir_id).0 != Level::Allow
-            && let Some(snippet) = snippet_opt(self.cx, expr.span)
-            && !snippet.contains("assert")
         {
             span_lint_and_sugg(
                 self.cx,
diff --git a/tests/ui/nonminimal_bool.rs b/tests/ui/nonminimal_bool.rs
index 4d48ef14d31..f7c3df7066f 100644
--- a/tests/ui/nonminimal_bool.rs
+++ b/tests/ui/nonminimal_bool.rs
@@ -145,3 +145,14 @@ fn issue10836() {
     // Should not lint
     let _: bool = !!Foo(true);
 }
+
+fn issue11932() {
+    let x: i32 = unimplemented!();
+
+    #[allow(clippy::nonminimal_bool)]
+    let _ = x % 2 == 0 || {
+        // Should not lint
+        assert!(x > 0);
+        x % 3 == 0
+    };
+}
-- 
cgit 1.4.1-3-g733a5


From 60c647b262d09ed104c6945ff29ab0ee35a2dee4 Mon Sep 17 00:00:00 2001
From: cocodery <cocodery@outlook.com>
Date: Sat, 6 Jan 2024 21:41:25 +0800
Subject: Fix bug: allow no- '_'-split binary format string, add test

---
 clippy_lints/src/non_octal_unix_permissions.rs | 11 ++++++++---
 tests/ui/non_octal_unix_permissions.fixed      |  4 ++++
 tests/ui/non_octal_unix_permissions.rs         |  4 ++++
 tests/ui/non_octal_unix_permissions.stderr     |  2 +-
 4 files changed, 17 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/non_octal_unix_permissions.rs b/clippy_lints/src/non_octal_unix_permissions.rs
index 12fd63b50f2..e732a882cbe 100644
--- a/clippy_lints/src/non_octal_unix_permissions.rs
+++ b/clippy_lints/src/non_octal_unix_permissions.rs
@@ -50,10 +50,15 @@ fn check_binary_unix_permissions(lit_kind: &LitKind, snip: &str) -> bool {
 
         let group_sizes: Vec<usize> = num_lit.integer.split('_').map(str::len).collect();
         // check whether is binary format unix permissions
-        if group_sizes.len() != 3 && group_sizes.len() != 4 {
-            return false;
+        if group_sizes.len() == 1 && (num_lit.integer.len() == 9 || num_lit.integer.len() == 12) {
+            // 0bxxxxxxxxx or 0bxxxxxxxxxxxx
+            true
+        } else if group_sizes.len() == 3 || group_sizes.len() == 4 {
+            // 0bxxx_xxx_xxx or 0bxxx_xxx_xxx_xxx
+            group_sizes.iter().all(|len| *len == 3)
+        } else {
+            false
         }
-        group_sizes.iter().all(|len| *len == 3)
     } else {
         false
     }
diff --git a/tests/ui/non_octal_unix_permissions.fixed b/tests/ui/non_octal_unix_permissions.fixed
index 245d36cb734..237f5f5b97a 100644
--- a/tests/ui/non_octal_unix_permissions.fixed
+++ b/tests/ui/non_octal_unix_permissions.fixed
@@ -25,9 +25,13 @@ fn main() {
 
     permissions.set_mode(0o644);
     permissions.set_mode(0o704);
+    // no error
+    permissions.set_mode(0b111_000_100);
 
     // DirBuilderExt::mode
     let mut builder = DirBuilder::new();
     builder.mode(0o755);
     builder.mode(0o406);
+    // no error
+    permissions.set_mode(0b111000100);
 }
diff --git a/tests/ui/non_octal_unix_permissions.rs b/tests/ui/non_octal_unix_permissions.rs
index d1559cba554..c8da5dbcec2 100644
--- a/tests/ui/non_octal_unix_permissions.rs
+++ b/tests/ui/non_octal_unix_permissions.rs
@@ -25,9 +25,13 @@ fn main() {
 
     permissions.set_mode(644);
     permissions.set_mode(0o704);
+    // no error
+    permissions.set_mode(0b111_000_100);
 
     // DirBuilderExt::mode
     let mut builder = DirBuilder::new();
     builder.mode(755);
     builder.mode(0o406);
+    // no error
+    permissions.set_mode(0b111000100);
 }
diff --git a/tests/ui/non_octal_unix_permissions.stderr b/tests/ui/non_octal_unix_permissions.stderr
index 78c8f1a2fcf..83688c1b451 100644
--- a/tests/ui/non_octal_unix_permissions.stderr
+++ b/tests/ui/non_octal_unix_permissions.stderr
@@ -20,7 +20,7 @@ LL |     permissions.set_mode(644);
    |                          ^^^ help: consider using an octal literal instead: `0o644`
 
 error: using a non-octal value to set unix file permissions
-  --> $DIR/non_octal_unix_permissions.rs:31:18
+  --> $DIR/non_octal_unix_permissions.rs:33:18
    |
 LL |     builder.mode(755);
    |                  ^^^ help: consider using an octal literal instead: `0o755`
-- 
cgit 1.4.1-3-g733a5


From 28c133b4bc2795d78c0bc15d99af5e5f44093a2d Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Sat, 6 Jan 2024 16:56:24 +0100
Subject: Extend `map_clone` lint to also work on non-explicit closures

---
 clippy_lints/src/methods/map_clone.rs | 98 +++++++++++++++++++++++------------
 1 file changed, 64 insertions(+), 34 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/map_clone.rs b/clippy_lints/src/methods/map_clone.rs
index cc6eeaa86e5..c8d5a358098 100644
--- a/clippy_lints/src/methods/map_clone.rs
+++ b/clippy_lints/src/methods/map_clone.rs
@@ -2,7 +2,7 @@ use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::{is_copy, is_type_diagnostic_item};
-use clippy_utils::{is_diag_trait_item, peel_blocks};
+use clippy_utils::{is_diag_trait_item, match_def_path, paths, peel_blocks};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
@@ -19,50 +19,63 @@ pub(super) fn check(cx: &LateContext<'_>, e: &hir::Expr<'_>, recv: &hir::Expr<'_
         && (cx.tcx.impl_of_method(method_id).map_or(false, |id| {
             is_type_diagnostic_item(cx, cx.tcx.type_of(id).instantiate_identity(), sym::Option)
         }) || is_diag_trait_item(cx, method_id, sym::Iterator))
-        && let hir::ExprKind::Closure(&hir::Closure { body, .. }) = arg.kind
     {
-        let closure_body = cx.tcx.hir().body(body);
-        let closure_expr = peel_blocks(closure_body.value);
-        match closure_body.params[0].pat.kind {
-            hir::PatKind::Ref(inner, hir::Mutability::Not) => {
-                if let hir::PatKind::Binding(hir::BindingAnnotation::NONE, .., name, None) = inner.kind {
-                    if ident_eq(name, closure_expr) {
-                        lint_explicit_closure(cx, e.span, recv.span, true, msrv);
-                    }
-                }
-            },
-            hir::PatKind::Binding(hir::BindingAnnotation::NONE, .., name, None) => {
-                match closure_expr.kind {
-                    hir::ExprKind::Unary(hir::UnOp::Deref, inner) => {
-                        if ident_eq(name, inner) {
-                            if let ty::Ref(.., Mutability::Not) = cx.typeck_results().expr_ty(inner).kind() {
+        match arg.kind {
+            hir::ExprKind::Closure(&hir::Closure { body, .. }) => {
+                let closure_body = cx.tcx.hir().body(body);
+                let closure_expr = peel_blocks(closure_body.value);
+                match closure_body.params[0].pat.kind {
+                    hir::PatKind::Ref(inner, hir::Mutability::Not) => {
+                        if let hir::PatKind::Binding(hir::BindingAnnotation::NONE, .., name, None) = inner.kind {
+                            if ident_eq(name, closure_expr) {
                                 lint_explicit_closure(cx, e.span, recv.span, true, msrv);
                             }
                         }
                     },
-                    hir::ExprKind::MethodCall(method, obj, [], _) => {
-                        if ident_eq(name, obj) && method.ident.name == sym::clone
-                        && let Some(fn_id) = cx.typeck_results().type_dependent_def_id(closure_expr.hir_id)
-                        && let Some(trait_id) = cx.tcx.trait_of_item(fn_id)
-                        && cx.tcx.lang_items().clone_trait().map_or(false, |id| id == trait_id)
-                        // no autoderefs
-                        && !cx.typeck_results().expr_adjustments(obj).iter()
-                            .any(|a| matches!(a.kind, Adjust::Deref(Some(..))))
-                        {
-                            let obj_ty = cx.typeck_results().expr_ty(obj);
-                            if let ty::Ref(_, ty, mutability) = obj_ty.kind() {
-                                if matches!(mutability, Mutability::Not) {
-                                    let copy = is_copy(cx, *ty);
-                                    lint_explicit_closure(cx, e.span, recv.span, copy, msrv);
+                    hir::PatKind::Binding(hir::BindingAnnotation::NONE, .., name, None) => {
+                        match closure_expr.kind {
+                            hir::ExprKind::Unary(hir::UnOp::Deref, inner) => {
+                                if ident_eq(name, inner) {
+                                    if let ty::Ref(.., Mutability::Not) = cx.typeck_results().expr_ty(inner).kind() {
+                                        lint_explicit_closure(cx, e.span, recv.span, true, msrv);
+                                    }
                                 }
-                            } else {
-                                lint_needless_cloning(cx, e.span, recv.span);
-                            }
+                            },
+                            hir::ExprKind::MethodCall(method, obj, [], _) => {
+                                if ident_eq(name, obj) && method.ident.name == sym::clone
+                                && let Some(fn_id) = cx.typeck_results().type_dependent_def_id(closure_expr.hir_id)
+                                && let Some(trait_id) = cx.tcx.trait_of_item(fn_id)
+                                && cx.tcx.lang_items().clone_trait().map_or(false, |id| id == trait_id)
+                                // no autoderefs
+                                && !cx.typeck_results().expr_adjustments(obj).iter()
+                                    .any(|a| matches!(a.kind, Adjust::Deref(Some(..))))
+                                {
+                                    let obj_ty = cx.typeck_results().expr_ty(obj);
+                                    if let ty::Ref(_, ty, mutability) = obj_ty.kind() {
+                                        if matches!(mutability, Mutability::Not) {
+                                            let copy = is_copy(cx, *ty);
+                                            lint_explicit_closure(cx, e.span, recv.span, copy, msrv);
+                                        }
+                                    } else {
+                                        lint_needless_cloning(cx, e.span, recv.span);
+                                    }
+                                }
+                            },
+                            _ => {},
                         }
                     },
                     _ => {},
                 }
             },
+            hir::ExprKind::Path(qpath) => {
+                if let Some(path_def_id) = cx.qpath_res(&qpath, arg.hir_id).opt_def_id()
+                    && match_def_path(cx, path_def_id, &paths::CLONE_TRAIT_METHOD)
+                {
+                    // FIXME: It would be better to infer the type to check if it's copyable or not
+                    // to suggest to use `.copied()` instead of `.cloned()` where applicable.
+                    lint_path(cx, e.span, recv.span);
+                }
+            },
             _ => {},
         }
     }
@@ -88,6 +101,23 @@ fn lint_needless_cloning(cx: &LateContext<'_>, root: Span, receiver: Span) {
     );
 }
 
+fn lint_path(cx: &LateContext<'_>, replace: Span, root: Span) {
+    let mut applicability = Applicability::MachineApplicable;
+
+    span_lint_and_sugg(
+        cx,
+        MAP_CLONE,
+        replace,
+        "you are explicitly cloning with `.map()`",
+        "consider calling the dedicated `cloned` method",
+        format!(
+            "{}.cloned()",
+            snippet_with_applicability(cx, root, "..", &mut applicability),
+        ),
+        applicability,
+    );
+}
+
 fn lint_explicit_closure(cx: &LateContext<'_>, replace: Span, root: Span, is_copy: bool, msrv: &Msrv) {
     let mut applicability = Applicability::MachineApplicable;
 
-- 
cgit 1.4.1-3-g733a5


From 5b7a0de3e776f3cd231722d66812db9f37c4d6a0 Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Sun, 7 Jan 2024 10:42:00 +0100
Subject: Do not suggest `bool::then()` and `bool::then_some` in `const`
 contexts

---
 clippy_lints/src/if_then_some_else_none.rs | 7 ++++++-
 tests/ui/if_then_some_else_none.rs         | 5 +++++
 2 files changed, 11 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/if_then_some_else_none.rs b/clippy_lints/src/if_then_some_else_none.rs
index cd6c46a71a8..8f48941c4a9 100644
--- a/clippy_lints/src/if_then_some_else_none.rs
+++ b/clippy_lints/src/if_then_some_else_none.rs
@@ -3,7 +3,7 @@ use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::eager_or_lazy::switch_to_eager_eval;
 use clippy_utils::source::snippet_with_context;
 use clippy_utils::sugg::Sugg;
-use clippy_utils::{contains_return, higher, is_else_clause, is_res_lang_ctor, path_res, peel_blocks};
+use clippy_utils::{contains_return, higher, in_constant, is_else_clause, is_res_lang_ctor, path_res, peel_blocks};
 use rustc_errors::Applicability;
 use rustc_hir::LangItem::{OptionNone, OptionSome};
 use rustc_hir::{Expr, ExprKind};
@@ -74,6 +74,11 @@ impl<'tcx> LateLintPass<'tcx> for IfThenSomeElseNone {
             return;
         }
 
+        // `bool::then()` and `bool::then_some()` are not const
+        if in_constant(cx, expr.hir_id) {
+            return;
+        }
+
         let ctxt = expr.span.ctxt();
 
         if let Some(higher::If {
diff --git a/tests/ui/if_then_some_else_none.rs b/tests/ui/if_then_some_else_none.rs
index abc92459148..ccde154bd56 100644
--- a/tests/ui/if_then_some_else_none.rs
+++ b/tests/ui/if_then_some_else_none.rs
@@ -130,3 +130,8 @@ fn issue11394(b: bool, v: Result<(), ()>) -> Result<(), ()> {
 
     Ok(())
 }
+
+const fn issue12103(x: u32) -> Option<u32> {
+    // Should not issue an error in `const` context
+    if x > 42 { Some(150) } else { None }
+}
-- 
cgit 1.4.1-3-g733a5


From 78aa2e29e273fed22c53065ffc319ae75af0266c Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Sun, 7 Jan 2024 13:13:29 +0100
Subject: Handle "calls" inside the closure as well in `map_clone` lint

---
 clippy_lints/src/methods/map_clone.rs | 31 ++++++++++++++++++++++---------
 1 file changed, 22 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/map_clone.rs b/clippy_lints/src/methods/map_clone.rs
index c8d5a358098..652d2b80081 100644
--- a/clippy_lints/src/methods/map_clone.rs
+++ b/clippy_lints/src/methods/map_clone.rs
@@ -61,26 +61,39 @@ pub(super) fn check(cx: &LateContext<'_>, e: &hir::Expr<'_>, recv: &hir::Expr<'_
                                     }
                                 }
                             },
+                            hir::ExprKind::Call(call, [_]) => {
+                                if let hir::ExprKind::Path(qpath) = call.kind {
+                                    handle_path(cx, call, &qpath, e, recv);
+                                }
+                            },
                             _ => {},
                         }
                     },
                     _ => {},
                 }
             },
-            hir::ExprKind::Path(qpath) => {
-                if let Some(path_def_id) = cx.qpath_res(&qpath, arg.hir_id).opt_def_id()
-                    && match_def_path(cx, path_def_id, &paths::CLONE_TRAIT_METHOD)
-                {
-                    // FIXME: It would be better to infer the type to check if it's copyable or not
-                    // to suggest to use `.copied()` instead of `.cloned()` where applicable.
-                    lint_path(cx, e.span, recv.span);
-                }
-            },
+            hir::ExprKind::Path(qpath) => handle_path(cx, arg, &qpath, e, recv),
             _ => {},
         }
     }
 }
 
+fn handle_path(
+    cx: &LateContext<'_>,
+    arg: &hir::Expr<'_>,
+    qpath: &hir::QPath<'_>,
+    e: &hir::Expr<'_>,
+    recv: &hir::Expr<'_>,
+) {
+    if let Some(path_def_id) = cx.qpath_res(qpath, arg.hir_id).opt_def_id()
+        && match_def_path(cx, path_def_id, &paths::CLONE_TRAIT_METHOD)
+    {
+        // FIXME: It would be better to infer the type to check if it's copyable or not
+        // to suggest to use `.copied()` instead of `.cloned()` where applicable.
+        lint_path(cx, e.span, recv.span);
+    }
+}
+
 fn ident_eq(name: Ident, path: &hir::Expr<'_>) -> bool {
     if let hir::ExprKind::Path(hir::QPath::Resolved(None, path)) = path.kind {
         path.segments.len() == 1 && path.segments[0].ident == name
-- 
cgit 1.4.1-3-g733a5


From a843996e81cd6993b9125708558c3ec5b674baf1 Mon Sep 17 00:00:00 2001
From: cocodery <cocodery@outlook.com>
Date: Sun, 7 Jan 2024 22:35:21 +0800
Subject: Simplify check function, weirdly binary format literals happen not
 often

---
 clippy_lints/src/non_octal_unix_permissions.rs | 33 ++++----------------------
 1 file changed, 4 insertions(+), 29 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/non_octal_unix_permissions.rs b/clippy_lints/src/non_octal_unix_permissions.rs
index e732a882cbe..2701d6bdca3 100644
--- a/clippy_lints/src/non_octal_unix_permissions.rs
+++ b/clippy_lints/src/non_octal_unix_permissions.rs
@@ -1,8 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::numeric_literal::{NumericLiteral, Radix};
 use clippy_utils::source::{snippet_opt, snippet_with_applicability};
 use clippy_utils::{match_def_path, paths};
-use rustc_ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
@@ -41,29 +39,6 @@ declare_clippy_lint! {
 
 declare_lint_pass!(NonOctalUnixPermissions => [NON_OCTAL_UNIX_PERMISSIONS]);
 
-fn check_binary_unix_permissions(lit_kind: &LitKind, snip: &str) -> bool {
-    // support binary unix permissions
-    if let Some(num_lit) = NumericLiteral::from_lit_kind(snip, lit_kind) {
-        if num_lit.radix != Radix::Binary {
-            return false;
-        }
-
-        let group_sizes: Vec<usize> = num_lit.integer.split('_').map(str::len).collect();
-        // check whether is binary format unix permissions
-        if group_sizes.len() == 1 && (num_lit.integer.len() == 9 || num_lit.integer.len() == 12) {
-            // 0bxxxxxxxxx or 0bxxxxxxxxxxxx
-            true
-        } else if group_sizes.len() == 3 || group_sizes.len() == 4 {
-            // 0bxxx_xxx_xxx or 0bxxx_xxx_xxx_xxx
-            group_sizes.iter().all(|len| *len == 3)
-        } else {
-            false
-        }
-    } else {
-        false
-    }
-}
-
 impl<'tcx> LateLintPass<'tcx> for NonOctalUnixPermissions {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
         match &expr.kind {
@@ -76,10 +51,10 @@ impl<'tcx> LateLintPass<'tcx> for NonOctalUnixPermissions {
                         ))
                         || (path.ident.name == sym!(set_mode)
                             && cx.tcx.is_diagnostic_item(sym::FsPermissions, adt.did())))
-                    && let ExprKind::Lit(lit_kind) = param.kind
+                    && let ExprKind::Lit(_) = param.kind
                     && param.span.eq_ctxt(expr.span)
                     && let Some(snip) = snippet_opt(cx, param.span)
-                    && !(snip.starts_with("0o") || check_binary_unix_permissions(&lit_kind.node, &snip))
+                    && !(snip.starts_with("0o") || snip.starts_with("0b"))
                 {
                     show_error(cx, param);
                 }
@@ -88,10 +63,10 @@ impl<'tcx> LateLintPass<'tcx> for NonOctalUnixPermissions {
                 if let ExprKind::Path(ref path) = func.kind
                     && let Some(def_id) = cx.qpath_res(path, func.hir_id).opt_def_id()
                     && match_def_path(cx, def_id, &paths::PERMISSIONS_FROM_MODE)
-                    && let ExprKind::Lit(lit_kind) = param.kind
+                    && let ExprKind::Lit(_) = param.kind
                     && param.span.eq_ctxt(expr.span)
                     && let Some(snip) = snippet_opt(cx, param.span)
-                    && !(snip.starts_with("0o") || check_binary_unix_permissions(&lit_kind.node, &snip))
+                    && !(snip.starts_with("0o") || snip.starts_with("0b"))
                 {
                     show_error(cx, param);
                 }
-- 
cgit 1.4.1-3-g733a5


From bbadce9ec0a8855ab72852af1a6ed1f68c9ce0c2 Mon Sep 17 00:00:00 2001
From: Quinn Sinclair <me@partiallytyped.dev>
Date: Wed, 3 Jan 2024 04:03:00 +0200
Subject: Fixed ICE introduced in #12004

Issue: in #12004, we emit a lint for `filter(Option::is_some)`. If the
parent expression is a `.map` we don't emit that lint as there exists a
more specialized lint for that.

The ICE introduced in #12004 is a consequence of the assumption that a
parent expression after a filter would be a method call with the filter
call being the receiver. However, it is entirely possible to have a
closure of the form

```
|| { vec![Some(1), None].into_iter().filter(Option::is_some) }
```
The previous implementation looked at the parent expression; namely the
closure, and tried to check the parameters by indexing [0] on an empty
list.

This commit is an overhaul of the lint with significantly more FP tests
and checks.

Impl details:

1. We verify that the filter method we are in is a proper trait method
   to avoid FPs.
2. We check that the parent expression is not a map by checking whether
   it exists; if is a trait method; and then a method call.
3. We check that we don't have comments in the span.
4. We verify that we are in an Iterator of Option and Result.
5. We check the contents of the filter.
  1. For closures we peel it. If it is not a single expression, we don't
     lint.
  2. For paths, we do a typecheck to avoid FPs for types that impl
     functions with the same names.
  3. For calls, we verify the type, via the path, and that the param of
     the closure is the single argument to the call.
  4. For method calls we verify that the receiver is the parameter of
     the closure. Since we handle single, non-block exprs, the
     parameter can't be shadowed, so no FP.

This commit also adds additional FP tests.
---
 clippy_lints/src/methods/filter_map.rs  |   3 +-
 clippy_lints/src/methods/iter_filter.rs | 206 +++++++++++++++++++++-------
 tests/ui/iter_filter_is_ok.fixed        | 193 +++++++++++++++++++++++++-
 tests/ui/iter_filter_is_ok.rs           | 193 +++++++++++++++++++++++++-
 tests/ui/iter_filter_is_ok.stderr       |  74 ++++++++--
 tests/ui/iter_filter_is_some.fixed      | 231 ++++++++++++++++++++++++++++++--
 tests/ui/iter_filter_is_some.rs         | 231 ++++++++++++++++++++++++++++++--
 tests/ui/iter_filter_is_some.stderr     |  62 +++++++--
 8 files changed, 1092 insertions(+), 101 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/filter_map.rs b/clippy_lints/src/methods/filter_map.rs
index 7cfd3d346b6..e489899c19e 100644
--- a/clippy_lints/src/methods/filter_map.rs
+++ b/clippy_lints/src/methods/filter_map.rs
@@ -26,13 +26,14 @@ fn is_method(cx: &LateContext<'_>, expr: &hir::Expr<'_>, method_name: Symbol) ->
         hir::ExprKind::Closure(&hir::Closure { body, .. }) => {
             let body = cx.tcx.hir().body(body);
             let closure_expr = peel_blocks(body.value);
-            let arg_id = body.params[0].pat.hir_id;
             match closure_expr.kind {
                 hir::ExprKind::MethodCall(hir::PathSegment { ident, .. }, receiver, ..) => {
                     if ident.name == method_name
                         && let hir::ExprKind::Path(path) = &receiver.kind
                         && let Res::Local(ref local) = cx.qpath_res(path, receiver.hir_id)
+                        && !body.params.is_empty()
                     {
+                        let arg_id = body.params[0].pat.hir_id;
                         return arg_id == *local;
                     }
                     false
diff --git a/clippy_lints/src/methods/iter_filter.rs b/clippy_lints/src/methods/iter_filter.rs
index ade8e3155fa..9f84321ced4 100644
--- a/clippy_lints/src/methods/iter_filter.rs
+++ b/clippy_lints/src/methods/iter_filter.rs
@@ -1,87 +1,197 @@
+use clippy_utils::ty::get_iterator_item_ty;
+use hir::ExprKind;
 use rustc_lint::{LateContext, LintContext};
 
 use super::{ITER_FILTER_IS_OK, ITER_FILTER_IS_SOME};
 
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::{indent_of, reindent_multiline};
-use clippy_utils::{is_trait_method, peel_blocks, span_contains_comment};
+use clippy_utils::{get_parent_expr, is_trait_method, peel_blocks, span_contains_comment};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
-use rustc_hir::def::Res;
 use rustc_hir::QPath;
-use rustc_span::symbol::{sym, Symbol};
+use rustc_span::symbol::{sym, Ident, Symbol};
 use rustc_span::Span;
 use std::borrow::Cow;
 
-fn is_method(cx: &LateContext<'_>, expr: &hir::Expr<'_>, method_name: Symbol) -> bool {
-    match &expr.kind {
-        hir::ExprKind::Path(QPath::TypeRelative(_, mname)) => mname.ident.name == method_name,
-        hir::ExprKind::Path(QPath::Resolved(_, segments)) => {
-            segments.segments.last().unwrap().ident.name == method_name
+///
+/// Returns true if the expression is a method call to `method_name`
+/// e.g. `a.method_name()` or `Option::method_name`.
+///
+/// The type-checker verifies for us that the method accepts the right kind of items
+/// (e.g. `Option::is_some` accepts `Option<_>`), so we don't need to check that.
+///
+/// How to capture each case:
+///
+/// `.filter(|a| { std::option::Option::is_some(a) })`
+///          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ <- this is a closure, getting unwrapped and
+/// recursively checked.
+/// `std::option::Option::is_some(a)`
+///  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ <- this is a call. It unwraps to a path with
+/// `QPath::TypeRelative`. Since this is a type relative path, we need to check the method name, the
+/// type, and that the parameter of the closure is passed in the call. This part is the dual of
+/// `receiver.method_name()` below.
+///
+/// `filter(std::option::Option::is_some);`
+///          ^^^^^^^^^^^^^^^^^^^^^^^^^^^ <- this is a type relative path, like above, we check the
+/// type and the method name.
+///
+/// `filter(|a| a.is_some());`
+///         ^^^^^^^^^^^^^^^ <- this is a method call inside a closure,
+/// we check that the parameter of the closure is the receiver of the method call and don't allow
+/// any other parameters.
+fn is_method(
+    cx: &LateContext<'_>,
+    expr: &hir::Expr<'_>,
+    type_symbol: Symbol,
+    method_name: Symbol,
+    params: &[&hir::Pat<'_>],
+) -> bool {
+    fn pat_is_recv(ident: Ident, param: &hir::Pat<'_>) -> bool {
+        match param.kind {
+            hir::PatKind::Binding(_, _, other, _) => ident == other,
+            hir::PatKind::Ref(pat, _) => pat_is_recv(ident, pat),
+            _ => false,
+        }
+    }
+    match expr.kind {
+        hir::ExprKind::MethodCall(hir::PathSegment { ident, .. }, recv, ..) => {
+            // compare the identifier of the receiver to the parameter
+            // we are in a filter => closure has a single parameter and a single, non-block
+            // expression, this means that the parameter shadows all outside variables with
+            // the same name => avoid FPs. If the parameter is not the receiver, then this hits
+            // outside variables => avoid FP
+            if ident.name == method_name
+                && let ExprKind::Path(QPath::Resolved(None, path)) = recv.kind
+                && let &[seg] = path.segments
+                && params.iter().any(|p| pat_is_recv(seg.ident, p))
+            {
+                return true;
+            }
+            false
+        },
+        // This is used to check for complete paths via `|a| std::option::Option::is_some(a)`
+        // this then unwraps to a path with `QPath::TypeRelative`
+        // we pass the params as they've been passed to the current call through the closure
+        hir::ExprKind::Call(expr, [param]) => {
+            // this will hit the `QPath::TypeRelative` case and check that the method name is correct
+            if is_method(cx, expr, type_symbol, method_name, params)
+                // we then check that this is indeed passing the parameter of the closure
+                && let ExprKind::Path(QPath::Resolved(None, path)) = param.kind
+                && let &[seg] = path.segments
+                && params.iter().any(|p| pat_is_recv(seg.ident, p))
+            {
+                return true;
+            }
+            false
+        },
+        hir::ExprKind::Path(QPath::TypeRelative(ty, mname)) => {
+            let ty = cx.typeck_results().node_type(ty.hir_id);
+            if let Some(did) = cx.tcx.get_diagnostic_item(type_symbol)
+                && ty.ty_adt_def() == cx.tcx.type_of(did).skip_binder().ty_adt_def()
+            {
+                return mname.ident.name == method_name;
+            }
+            false
         },
-        hir::ExprKind::MethodCall(segment, _, _, _) => segment.ident.name == method_name,
         hir::ExprKind::Closure(&hir::Closure { body, .. }) => {
             let body = cx.tcx.hir().body(body);
             let closure_expr = peel_blocks(body.value);
-            let arg_id = body.params[0].pat.hir_id;
-            match closure_expr.kind {
-                hir::ExprKind::MethodCall(hir::PathSegment { ident, .. }, receiver, ..) => {
-                    if ident.name == method_name
-                        && let hir::ExprKind::Path(path) = &receiver.kind
-                        && let Res::Local(ref local) = cx.qpath_res(path, receiver.hir_id)
-                    {
-                        return arg_id == *local;
-                    }
-                    false
-                },
-                _ => false,
-            }
+            let params = body.params.iter().map(|param| param.pat).collect::<Vec<_>>();
+            is_method(cx, closure_expr, type_symbol, method_name, params.as_slice())
         },
         _ => false,
     }
 }
 
 fn parent_is_map(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> bool {
-    if let hir::Node::Expr(parent_expr) = cx.tcx.hir().get_parent(expr.hir_id) {
-        is_method(cx, parent_expr, rustc_span::sym::map)
-    } else {
-        false
+    if let Some(expr) = get_parent_expr(cx, expr)
+        && is_trait_method(cx, expr, sym::Iterator)
+        && let hir::ExprKind::MethodCall(path, _, _, _) = expr.kind
+        && path.ident.name == rustc_span::sym::map
+    {
+        return true;
     }
+    false
 }
 
-#[allow(clippy::too_many_arguments)]
-pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, filter_arg: &hir::Expr<'_>, filter_span: Span) {
-    let is_iterator = is_trait_method(cx, expr, sym::Iterator);
-    let parent_is_not_map = !parent_is_map(cx, expr);
+enum FilterType {
+    IsSome,
+    IsOk,
+}
 
-    if is_iterator
-        && parent_is_not_map
-        && is_method(cx, filter_arg, sym!(is_some))
-        && !span_contains_comment(cx.sess().source_map(), filter_span.with_hi(expr.span.hi()))
+/// Returns the `FilterType` of the expression if it is a filter over an Iter<Option> or
+/// Iter<Result> with the parent expression not being a map, and not having a comment in the span of
+/// the filter. If it is not a filter over an Iter<Option> or Iter<Result> then it returns None
+///
+/// How this is done:
+/// 1. we know that this is invoked in a method call with `filter` as the method name via `mod.rs`
+/// 2. we check that we are in a trait method. Therefore we are in an
+/// `(x as Iterator).filter({filter_arg})` method call.
+/// 3. we check that the parent expression is not a map. This is because we don't want to lint
+///    twice, and we already have a specialized lint for that.
+/// 4. we check that the span of the filter does not contain a comment.
+/// 5. we get the type of the `Item` in the `Iterator`, and compare against the type of Option and
+///   Result.
+/// 6. we finally check the contents of the filter argument to see if it is a call to `is_some` or
+///   `is_ok`.
+/// 7. if all of the above are true, then we return the `FilterType`
+fn expression_type(
+    cx: &LateContext<'_>,
+    expr: &hir::Expr<'_>,
+    filter_arg: &hir::Expr<'_>,
+    filter_span: Span,
+) -> Option<FilterType> {
+    if !is_trait_method(cx, expr, sym::Iterator)
+        || parent_is_map(cx, expr)
+        || span_contains_comment(cx.sess().source_map(), filter_span.with_hi(expr.span.hi()))
     {
-        span_lint_and_sugg(
+        return None;
+    }
+    if let hir::ExprKind::MethodCall(_, receiver, _, _) = expr.kind
+        && let receiver_ty = cx.typeck_results().expr_ty(receiver)
+        && let Some(iter_item_ty) = get_iterator_item_ty(cx, receiver_ty)
+    {
+        if let Some(opt_defid) = cx.tcx.get_diagnostic_item(sym::Option)
+            && let opt_ty = cx.tcx.type_of(opt_defid).skip_binder()
+            && iter_item_ty.ty_adt_def() == opt_ty.ty_adt_def()
+            && is_method(cx, filter_arg, sym::Option, sym!(is_some), &[])
+        {
+            return Some(FilterType::IsSome);
+        }
+
+        if let Some(opt_defid) = cx.tcx.get_diagnostic_item(sym::Result)
+            && let opt_ty = cx.tcx.type_of(opt_defid).skip_binder()
+            && iter_item_ty.ty_adt_def() == opt_ty.ty_adt_def()
+            && is_method(cx, filter_arg, sym::Result, sym!(is_ok), &[])
+        {
+            return Some(FilterType::IsOk);
+        }
+    }
+    None
+}
+
+pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, filter_arg: &hir::Expr<'_>, filter_span: Span) {
+    // we are in a filter inside an iterator
+    match expression_type(cx, expr, filter_arg, filter_span) {
+        None => (),
+        Some(FilterType::IsOk) => span_lint_and_sugg(
             cx,
-            ITER_FILTER_IS_SOME,
+            ITER_FILTER_IS_OK,
             filter_span.with_hi(expr.span.hi()),
-            "`filter` for `is_some` on iterator over `Option`",
+            "`filter` for `is_ok` on iterator over `Result`s",
             "consider using `flatten` instead",
             reindent_multiline(Cow::Borrowed("flatten()"), true, indent_of(cx, filter_span)).into_owned(),
             Applicability::HasPlaceholders,
-        );
-    }
-    if is_iterator
-        && parent_is_not_map
-        && is_method(cx, filter_arg, sym!(is_ok))
-        && !span_contains_comment(cx.sess().source_map(), filter_span.with_hi(expr.span.hi()))
-    {
-        span_lint_and_sugg(
+        ),
+        Some(FilterType::IsSome) => span_lint_and_sugg(
             cx,
-            ITER_FILTER_IS_OK,
+            ITER_FILTER_IS_SOME,
             filter_span.with_hi(expr.span.hi()),
-            "`filter` for `is_ok` on iterator over `Result`s",
+            "`filter` for `is_some` on iterator over `Option`",
             "consider using `flatten` instead",
             reindent_multiline(Cow::Borrowed("flatten()"), true, indent_of(cx, filter_span)).into_owned(),
             Applicability::HasPlaceholders,
-        );
+        ),
     }
 }
diff --git a/tests/ui/iter_filter_is_ok.fixed b/tests/ui/iter_filter_is_ok.fixed
index a5ca41528af..80db8b29c18 100644
--- a/tests/ui/iter_filter_is_ok.fixed
+++ b/tests/ui/iter_filter_is_ok.fixed
@@ -1,21 +1,72 @@
 #![warn(clippy::iter_filter_is_ok)]
+#![allow(
+    clippy::map_identity,
+    clippy::result_filter_map,
+    clippy::needless_borrow,
+    clippy::redundant_closure
+)]
 
 fn main() {
-    let _ = vec![Ok(1), Err(2), Ok(3)].into_iter().flatten();
-    //~^ HELP: consider using `flatten` instead
-    let _ = vec![Ok(1), Err(2), Ok(3)].into_iter().flatten();
-    //~^ HELP: consider using `flatten` instead
+    {
+        let _ = vec![Ok(1), Err(2), Ok(3)].into_iter().flatten();
+        //~^ HELP: consider using `flatten` instead
+        let _ = vec![Ok(1), Err(2), Ok(3)].into_iter().flatten();
+        //~^ HELP: consider using `flatten` instead
+        #[rustfmt::skip]
+        let _ = vec![Ok(1), Err(2)].into_iter().flatten();
+        //~^ HELP: consider using `flatten` instead
+    }
 
-    #[rustfmt::skip]
-    let _ = vec![Ok(1), Err(2)].into_iter().flatten();
-    //~^ HELP: consider using `flatten` instead
+    {
+        let _ = vec![Ok(1), Err(2), Ok(3)].into_iter().flatten();
+        //~^ HELP: consider using `flatten` instead
 
+        let _ = vec![Ok(1), Err(2), Ok(3)].into_iter().flatten();
+        //~^ HELP: consider using `flatten` instead
+
+        #[rustfmt::skip]
+        let _ = vec![Ok(1), Err(2)].into_iter().flatten();
+        //~^ HELP: consider using `flatten` instead
+    }
+
+    {
+        let _ = vec![Ok(1), Err(2), Ok(3)]
+            .into_iter()
+            .flatten();
+        //~^ HELP: consider using `flatten` instead
+
+        let _ = vec![Ok(1), Err(2), Ok(3)]
+            .into_iter()
+            .flatten();
+        //~^ HELP: consider using `flatten` instead
+        #[rustfmt::skip]
+        let _ = vec![Ok(1), Err(2), Ok(3)].into_iter().flatten();
+        //~^ HELP: consider using `flatten` instead
+    }
+
+    {
+        let _ = vec![Ok(1), Err(2), Ok(3)].into_iter().flatten();
+        //~^ HELP: consider using `flatten` instead
+
+        let _ = vec![Ok(1), Err(2), Ok(3)].into_iter().flatten();
+        //~^ HELP: consider using `flatten` instead
+
+        #[rustfmt::skip]
+        let _ = vec![Ok(1), Err(2)].into_iter().flatten();
+        //~^ HELP: consider using `flatten` instead
+    }
+}
+
+fn avoid_linting_when_filter_has_side_effects() {
     // Don't lint below
     let mut counter = 0;
     let _ = vec![Ok(1), Err(2)].into_iter().filter(|o| {
         counter += 1;
         o.is_ok()
     });
+}
+
+fn avoid_linting_when_commented() {
     let _ = vec![Ok(1), Err(2)].into_iter().filter(|o| {
         // Roses are red,
         // Violets are blue,
@@ -24,3 +75,131 @@ fn main() {
         o.is_ok()
     });
 }
+
+fn ice_12058() {
+    // check that checking the parent node doesn't cause an ICE
+    // by indexing the parameters of a closure without parameters
+    Some(1).or_else(|| {
+        vec![Ok(1), Err(())].into_iter().filter(|z| *z != Ok(2));
+        None
+    });
+}
+
+fn avoid_linting_map() {
+    // should not lint
+    let _ = vec![Ok(1), Err(())]
+        .into_iter()
+        .filter(|o| o.is_ok())
+        .map(|o| o.unwrap());
+
+    // should not lint
+    let _ = vec![Ok(1), Err(())].into_iter().filter(|o| o.is_ok()).map(|o| o);
+}
+
+fn avoid_false_positive_due_to_is_ok_and_iterator_impl() {
+    #[derive(Default, Clone)]
+    struct Foo {}
+
+    impl Foo {
+        fn is_ok(&self) -> bool {
+            true
+        }
+    }
+
+    impl Iterator for Foo {
+        type Item = Foo;
+        fn next(&mut self) -> Option<Self::Item> {
+            Some(Foo::default())
+        }
+    }
+
+    let data = vec![Foo::default()];
+    // should not lint
+    let _ = data.clone().into_iter().filter(Foo::is_ok);
+    // should not lint
+    let _ = data.clone().into_iter().filter(|f| f.is_ok());
+}
+
+fn avoid_false_positive_due_to_is_ok_and_into_iterator_impl() {
+    #[derive(Default, Clone)]
+    struct Foo {}
+
+    impl Foo {
+        fn is_ok(&self) -> bool {
+            true
+        }
+    }
+
+    let data = vec![Foo::default()];
+    // should not lint
+    let _ = data.clone().into_iter().filter(Foo::is_ok);
+    // should not lint
+    let _ = data.clone().into_iter().filter(|f| f.is_ok());
+}
+
+fn avoid_fp_for_trivial() {
+    let _ = vec![Ok(1), Err(()), Ok(3)]
+        .into_iter()
+        // should not lint
+        .filter(|o| (Err(()) as Result<i32, ()>).is_ok());
+}
+
+fn avoid_false_positive_due_to_method_name() {
+    fn is_ok(x: &Result<i32, i32>) -> bool {
+        x.is_ok()
+    }
+
+    vec![Ok(1), Err(2), Ok(3)].into_iter().filter(is_ok);
+    // should not lint
+}
+
+fn avoid_fp_due_to_trait_type() {
+    struct Foo {
+        bar: i32,
+    }
+    impl Foo {
+        fn is_ok(obj: &Result<i32, i32>) -> bool {
+            obj.is_ok()
+        }
+    }
+    vec![Ok(1), Err(2), Ok(3)].into_iter().filter(Foo::is_ok);
+    // should not lint
+}
+
+fn avoid_fp_with_call_to_outside_var() {
+    let outside: Result<i32, ()> = Ok(1);
+
+    let _ = vec![Ok(1), Err(2), Ok(3)]
+        .into_iter()
+        // should not lint
+        .filter(|o| outside.is_ok());
+
+    let _ = vec![Ok(1), Err(2), Ok(3)]
+        .into_iter()
+        // should not lint
+        .filter(|o| Result::is_ok(&outside));
+
+    let _ = vec![Ok(1), Err(2), Ok(3)]
+        .into_iter()
+        // should not lint
+        .filter(|o| std::result::Result::is_ok(&outside));
+}
+
+fn avoid_fp_with_call_to_outside_var_mix_match_types() {
+    let outside = Some(1);
+
+    let _ = vec![Ok(1), Err(2), Ok(3)]
+        .into_iter()
+        // should not lint
+        .filter(|o| outside.is_some());
+
+    let _ = vec![Ok(1), Err(2), Ok(3)]
+        .into_iter()
+        // should not lint
+        .filter(|o| Option::is_some(&outside));
+
+    let _ = vec![Ok(1), Err(2), Ok(3)]
+        .into_iter()
+        // should not lint
+        .filter(|o| std::option::Option::is_some(&outside));
+}
diff --git a/tests/ui/iter_filter_is_ok.rs b/tests/ui/iter_filter_is_ok.rs
index e4e73f5ada1..89b083b84f3 100644
--- a/tests/ui/iter_filter_is_ok.rs
+++ b/tests/ui/iter_filter_is_ok.rs
@@ -1,21 +1,72 @@
 #![warn(clippy::iter_filter_is_ok)]
+#![allow(
+    clippy::map_identity,
+    clippy::result_filter_map,
+    clippy::needless_borrow,
+    clippy::redundant_closure
+)]
 
 fn main() {
-    let _ = vec![Ok(1), Err(2), Ok(3)].into_iter().filter(Result::is_ok);
-    //~^ HELP: consider using `flatten` instead
-    let _ = vec![Ok(1), Err(2), Ok(3)].into_iter().filter(|a| a.is_ok());
-    //~^ HELP: consider using `flatten` instead
+    {
+        let _ = vec![Ok(1), Err(2), Ok(3)].into_iter().filter(Result::is_ok);
+        //~^ HELP: consider using `flatten` instead
+        let _ = vec![Ok(1), Err(2), Ok(3)].into_iter().filter(|a| a.is_ok());
+        //~^ HELP: consider using `flatten` instead
+        #[rustfmt::skip]
+        let _ = vec![Ok(1), Err(2)].into_iter().filter(|o| { o.is_ok() });
+        //~^ HELP: consider using `flatten` instead
+    }
 
-    #[rustfmt::skip]
-    let _ = vec![Ok(1), Err(2)].into_iter().filter(|o| { o.is_ok() });
-    //~^ HELP: consider using `flatten` instead
+    {
+        let _ = vec![Ok(1), Err(2), Ok(3)].into_iter().filter(|&a| a.is_ok());
+        //~^ HELP: consider using `flatten` instead
 
+        let _ = vec![Ok(1), Err(2), Ok(3)].into_iter().filter(|&a| a.is_ok());
+        //~^ HELP: consider using `flatten` instead
+
+        #[rustfmt::skip]
+        let _ = vec![Ok(1), Err(2)].into_iter().filter(|&o| { o.is_ok() });
+        //~^ HELP: consider using `flatten` instead
+    }
+
+    {
+        let _ = vec![Ok(1), Err(2), Ok(3)]
+            .into_iter()
+            .filter(std::result::Result::is_ok);
+        //~^ HELP: consider using `flatten` instead
+
+        let _ = vec![Ok(1), Err(2), Ok(3)]
+            .into_iter()
+            .filter(|a| std::result::Result::is_ok(a));
+        //~^ HELP: consider using `flatten` instead
+        #[rustfmt::skip]
+        let _ = vec![Ok(1), Err(2), Ok(3)].into_iter().filter(|a| { std::result::Result::is_ok(a) });
+        //~^ HELP: consider using `flatten` instead
+    }
+
+    {
+        let _ = vec![Ok(1), Err(2), Ok(3)].into_iter().filter(|ref a| a.is_ok());
+        //~^ HELP: consider using `flatten` instead
+
+        let _ = vec![Ok(1), Err(2), Ok(3)].into_iter().filter(|ref a| a.is_ok());
+        //~^ HELP: consider using `flatten` instead
+
+        #[rustfmt::skip]
+        let _ = vec![Ok(1), Err(2)].into_iter().filter(|ref o| { o.is_ok() });
+        //~^ HELP: consider using `flatten` instead
+    }
+}
+
+fn avoid_linting_when_filter_has_side_effects() {
     // Don't lint below
     let mut counter = 0;
     let _ = vec![Ok(1), Err(2)].into_iter().filter(|o| {
         counter += 1;
         o.is_ok()
     });
+}
+
+fn avoid_linting_when_commented() {
     let _ = vec![Ok(1), Err(2)].into_iter().filter(|o| {
         // Roses are red,
         // Violets are blue,
@@ -24,3 +75,131 @@ fn main() {
         o.is_ok()
     });
 }
+
+fn ice_12058() {
+    // check that checking the parent node doesn't cause an ICE
+    // by indexing the parameters of a closure without parameters
+    Some(1).or_else(|| {
+        vec![Ok(1), Err(())].into_iter().filter(|z| *z != Ok(2));
+        None
+    });
+}
+
+fn avoid_linting_map() {
+    // should not lint
+    let _ = vec![Ok(1), Err(())]
+        .into_iter()
+        .filter(|o| o.is_ok())
+        .map(|o| o.unwrap());
+
+    // should not lint
+    let _ = vec![Ok(1), Err(())].into_iter().filter(|o| o.is_ok()).map(|o| o);
+}
+
+fn avoid_false_positive_due_to_is_ok_and_iterator_impl() {
+    #[derive(Default, Clone)]
+    struct Foo {}
+
+    impl Foo {
+        fn is_ok(&self) -> bool {
+            true
+        }
+    }
+
+    impl Iterator for Foo {
+        type Item = Foo;
+        fn next(&mut self) -> Option<Self::Item> {
+            Some(Foo::default())
+        }
+    }
+
+    let data = vec![Foo::default()];
+    // should not lint
+    let _ = data.clone().into_iter().filter(Foo::is_ok);
+    // should not lint
+    let _ = data.clone().into_iter().filter(|f| f.is_ok());
+}
+
+fn avoid_false_positive_due_to_is_ok_and_into_iterator_impl() {
+    #[derive(Default, Clone)]
+    struct Foo {}
+
+    impl Foo {
+        fn is_ok(&self) -> bool {
+            true
+        }
+    }
+
+    let data = vec![Foo::default()];
+    // should not lint
+    let _ = data.clone().into_iter().filter(Foo::is_ok);
+    // should not lint
+    let _ = data.clone().into_iter().filter(|f| f.is_ok());
+}
+
+fn avoid_fp_for_trivial() {
+    let _ = vec![Ok(1), Err(()), Ok(3)]
+        .into_iter()
+        // should not lint
+        .filter(|o| (Err(()) as Result<i32, ()>).is_ok());
+}
+
+fn avoid_false_positive_due_to_method_name() {
+    fn is_ok(x: &Result<i32, i32>) -> bool {
+        x.is_ok()
+    }
+
+    vec![Ok(1), Err(2), Ok(3)].into_iter().filter(is_ok);
+    // should not lint
+}
+
+fn avoid_fp_due_to_trait_type() {
+    struct Foo {
+        bar: i32,
+    }
+    impl Foo {
+        fn is_ok(obj: &Result<i32, i32>) -> bool {
+            obj.is_ok()
+        }
+    }
+    vec![Ok(1), Err(2), Ok(3)].into_iter().filter(Foo::is_ok);
+    // should not lint
+}
+
+fn avoid_fp_with_call_to_outside_var() {
+    let outside: Result<i32, ()> = Ok(1);
+
+    let _ = vec![Ok(1), Err(2), Ok(3)]
+        .into_iter()
+        // should not lint
+        .filter(|o| outside.is_ok());
+
+    let _ = vec![Ok(1), Err(2), Ok(3)]
+        .into_iter()
+        // should not lint
+        .filter(|o| Result::is_ok(&outside));
+
+    let _ = vec![Ok(1), Err(2), Ok(3)]
+        .into_iter()
+        // should not lint
+        .filter(|o| std::result::Result::is_ok(&outside));
+}
+
+fn avoid_fp_with_call_to_outside_var_mix_match_types() {
+    let outside = Some(1);
+
+    let _ = vec![Ok(1), Err(2), Ok(3)]
+        .into_iter()
+        // should not lint
+        .filter(|o| outside.is_some());
+
+    let _ = vec![Ok(1), Err(2), Ok(3)]
+        .into_iter()
+        // should not lint
+        .filter(|o| Option::is_some(&outside));
+
+    let _ = vec![Ok(1), Err(2), Ok(3)]
+        .into_iter()
+        // should not lint
+        .filter(|o| std::option::Option::is_some(&outside));
+}
diff --git a/tests/ui/iter_filter_is_ok.stderr b/tests/ui/iter_filter_is_ok.stderr
index f3acbe38d8a..d99e2e0446d 100644
--- a/tests/ui/iter_filter_is_ok.stderr
+++ b/tests/ui/iter_filter_is_ok.stderr
@@ -1,23 +1,77 @@
 error: `filter` for `is_ok` on iterator over `Result`s
-  --> $DIR/iter_filter_is_ok.rs:4:52
+  --> $DIR/iter_filter_is_ok.rs:11:56
    |
-LL |     let _ = vec![Ok(1), Err(2), Ok(3)].into_iter().filter(Result::is_ok);
-   |                                                    ^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
+LL |         let _ = vec![Ok(1), Err(2), Ok(3)].into_iter().filter(Result::is_ok);
+   |                                                        ^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
    |
    = note: `-D clippy::iter-filter-is-ok` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::iter_filter_is_ok)]`
 
 error: `filter` for `is_ok` on iterator over `Result`s
-  --> $DIR/iter_filter_is_ok.rs:6:52
+  --> $DIR/iter_filter_is_ok.rs:13:56
    |
-LL |     let _ = vec![Ok(1), Err(2), Ok(3)].into_iter().filter(|a| a.is_ok());
-   |                                                    ^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
+LL |         let _ = vec![Ok(1), Err(2), Ok(3)].into_iter().filter(|a| a.is_ok());
+   |                                                        ^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
 
 error: `filter` for `is_ok` on iterator over `Result`s
-  --> $DIR/iter_filter_is_ok.rs:10:45
+  --> $DIR/iter_filter_is_ok.rs:16:49
    |
-LL |     let _ = vec![Ok(1), Err(2)].into_iter().filter(|o| { o.is_ok() });
-   |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
+LL |         let _ = vec![Ok(1), Err(2)].into_iter().filter(|o| { o.is_ok() });
+   |                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
 
-error: aborting due to 3 previous errors
+error: `filter` for `is_ok` on iterator over `Result`s
+  --> $DIR/iter_filter_is_ok.rs:21:56
+   |
+LL |         let _ = vec![Ok(1), Err(2), Ok(3)].into_iter().filter(|&a| a.is_ok());
+   |                                                        ^^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
+
+error: `filter` for `is_ok` on iterator over `Result`s
+  --> $DIR/iter_filter_is_ok.rs:24:56
+   |
+LL |         let _ = vec![Ok(1), Err(2), Ok(3)].into_iter().filter(|&a| a.is_ok());
+   |                                                        ^^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
+
+error: `filter` for `is_ok` on iterator over `Result`s
+  --> $DIR/iter_filter_is_ok.rs:28:49
+   |
+LL |         let _ = vec![Ok(1), Err(2)].into_iter().filter(|&o| { o.is_ok() });
+   |                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
+
+error: `filter` for `is_ok` on iterator over `Result`s
+  --> $DIR/iter_filter_is_ok.rs:35:14
+   |
+LL |             .filter(std::result::Result::is_ok);
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
+
+error: `filter` for `is_ok` on iterator over `Result`s
+  --> $DIR/iter_filter_is_ok.rs:40:14
+   |
+LL |             .filter(|a| std::result::Result::is_ok(a));
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
+
+error: `filter` for `is_ok` on iterator over `Result`s
+  --> $DIR/iter_filter_is_ok.rs:43:56
+   |
+LL |         let _ = vec![Ok(1), Err(2), Ok(3)].into_iter().filter(|a| { std::result::Result::is_ok(a) });
+   |                                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
+
+error: `filter` for `is_ok` on iterator over `Result`s
+  --> $DIR/iter_filter_is_ok.rs:48:56
+   |
+LL |         let _ = vec![Ok(1), Err(2), Ok(3)].into_iter().filter(|ref a| a.is_ok());
+   |                                                        ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
+
+error: `filter` for `is_ok` on iterator over `Result`s
+  --> $DIR/iter_filter_is_ok.rs:51:56
+   |
+LL |         let _ = vec![Ok(1), Err(2), Ok(3)].into_iter().filter(|ref a| a.is_ok());
+   |                                                        ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
+
+error: `filter` for `is_ok` on iterator over `Result`s
+  --> $DIR/iter_filter_is_ok.rs:55:49
+   |
+LL |         let _ = vec![Ok(1), Err(2)].into_iter().filter(|ref o| { o.is_ok() });
+   |                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
+
+error: aborting due to 12 previous errors
 
diff --git a/tests/ui/iter_filter_is_some.fixed b/tests/ui/iter_filter_is_some.fixed
index c3fa93f0ab2..abc3a47fa46 100644
--- a/tests/ui/iter_filter_is_some.fixed
+++ b/tests/ui/iter_filter_is_some.fixed
@@ -1,23 +1,70 @@
 #![warn(clippy::iter_filter_is_some)]
+#![allow(
+    clippy::map_identity,
+    clippy::result_filter_map,
+    clippy::needless_borrow,
+    clippy::option_filter_map,
+    clippy::redundant_closure
+)]
+
+use std::collections::HashMap;
 
 fn main() {
-    let _ = vec![Some(1)].into_iter().flatten();
-    //~^ HELP: consider using `flatten` instead
-    let _ = vec![Some(1)].into_iter().flatten();
-    //~^ HELP: consider using `flatten` instead
+    {
+        let _ = vec![Some(1), None, Some(3)].into_iter().flatten();
+        //~^ HELP: consider using `flatten` instead
+        let _ = vec![Some(1), None, Some(3)].into_iter().flatten();
+        //~^ HELP: consider using `flatten` instead
+        #[rustfmt::skip]
+        let _ = vec![Some(1), None, Some(3)].into_iter().flatten();
+        //~^ HELP: consider using `flatten` instead
+    }
+
+    {
+        let _ = vec![Some(1), None, Some(3)]
+            .into_iter()
+            .flatten();
+        //~^ HELP: consider using `flatten` instead
+
+        let _ = vec![Some(1), None, Some(3)]
+            .into_iter()
+            .flatten();
+        //~^ HELP: consider using `flatten` instead
+        #[rustfmt::skip]
+        let _ = vec![Some(1), None, Some(3)].into_iter().flatten();
+        //~^ HELP: consider using `flatten` instead
+    }
+
+    {
+        let _ = vec![Some(1), None, Some(3)].into_iter().flatten();
+        //~^ HELP: consider using `flatten` instead
+
+        #[rustfmt::skip]
+        let _ = vec![Some(1), None, Some(3)].into_iter().flatten();
+        //~^ HELP: consider using `flatten` instead
+    }
+
+    {
+        let _ = vec![Some(1), None, Some(3)].into_iter().flatten();
+        //~^ HELP: consider using `flatten` instead
 
-    #[rustfmt::skip]
-    let _ = vec![Some(1)].into_iter().flatten();
-    //~^ HELP: consider using `flatten` instead
+        #[rustfmt::skip]
+        let _ = vec![Some(1), None, Some(3)].into_iter().flatten();
+        //~^ HELP: consider using `flatten` instead
+    }
+}
 
+fn avoid_linting_when_filter_has_side_effects() {
     // Don't lint below
     let mut counter = 0;
-    let _ = vec![Some(1)].into_iter().filter(|o| {
+    let _ = vec![Some(1), None, Some(3)].into_iter().filter(|o| {
         counter += 1;
         o.is_some()
     });
+}
 
-    let _ = vec![Some(1)].into_iter().filter(|o| {
+fn avoid_linting_when_commented() {
+    let _ = vec![Some(1), None, Some(3)].into_iter().filter(|o| {
         // Roses are red,
         // Violets are blue,
         // `Err` is not an `Option`,
@@ -25,3 +72,169 @@ fn main() {
         o.is_some()
     });
 }
+
+fn ice_12058() {
+    // check that checking the parent node doesn't cause an ICE
+    // by indexing the parameters of a closure without parameters
+    Some(1).or_else(|| {
+        vec![Some(1), None, Some(3)].into_iter().filter(|z| *z != Some(2));
+        None
+    });
+}
+
+fn avoid_linting_map() {
+    // should not lint
+    let _ = vec![Some(1), None, Some(3)]
+        .into_iter()
+        .filter(|o| o.is_some())
+        .map(|o| o.unwrap());
+
+    // should not lint
+    let _ = vec![Some(1), None, Some(3)]
+        .into_iter()
+        .filter(|o| o.is_some())
+        .map(|o| o);
+}
+
+fn avoid_false_positive_due_to_is_some_and_iterator_impl() {
+    #[derive(Default, Clone)]
+    struct Foo {}
+
+    impl Foo {
+        fn is_some(&self) -> bool {
+            true
+        }
+    }
+
+    impl Iterator for Foo {
+        type Item = Foo;
+        fn next(&mut self) -> Option<Self::Item> {
+            Some(Foo::default())
+        }
+    }
+
+    let data = vec![Foo::default()];
+    // should not lint
+    let _ = data.clone().into_iter().filter(Foo::is_some);
+    // should not lint
+    let _ = data.clone().into_iter().filter(|f| f.is_some());
+}
+
+fn avoid_false_positive_due_to_is_some_and_into_iterator_impl() {
+    #[derive(Default, Clone)]
+    struct Foo {}
+
+    impl Foo {
+        fn is_some(&self) -> bool {
+            true
+        }
+    }
+
+    let data = vec![Foo::default()];
+    // should not lint
+    let _ = data.clone().into_iter().filter(Foo::is_some);
+    // should not lint
+    let _ = data.clone().into_iter().filter(|f| f.is_some());
+}
+
+fn avoid_unpack_fp() {
+    let _ = vec![(Some(1), None), (None, Some(3))]
+        .into_iter()
+        // should not lint
+        .filter(|(a, _)| a.is_some());
+    let _ = vec![(Some(1), None), (None, Some(3))]
+        .into_iter()
+        // should not lint
+        .filter(|(a, _)| a.is_some())
+        .collect::<Vec<_>>();
+
+    let m = HashMap::from([(1, 1)]);
+    let _ = vec![1, 2, 4].into_iter().filter(|a| m.get(a).is_some());
+    // should not lint
+}
+
+fn avoid_fp_for_external() {
+    let value = HashMap::from([(1, 1)]);
+    let _ = vec![Some(1), None, Some(3)]
+        .into_iter()
+        // should not lint
+        .filter(|o| value.get(&1).is_some());
+
+    let value = Option::Some(1);
+    let _ = vec![Some(1), None, Some(3)]
+        .into_iter()
+        // should not lint
+        .filter(|o| value.is_some());
+}
+
+fn avoid_fp_for_trivial() {
+    let value = HashMap::from([(1, 1)]);
+    let _ = vec![Some(1), None, Some(3)]
+        .into_iter()
+        // should not lint
+        .filter(|o| Some(1).is_some());
+    let _ = vec![Some(1), None, Some(3)]
+        .into_iter()
+        // should not lint
+        .filter(|o| None::<i32>.is_some());
+}
+
+fn avoid_false_positive_due_to_method_name() {
+    fn is_some(x: &Option<i32>) -> bool {
+        x.is_some()
+    }
+
+    vec![Some(1), None, Some(3)].into_iter().filter(is_some);
+    // should not lint
+}
+
+fn avoid_fp_due_to_trait_type() {
+    struct Foo {
+        bar: i32,
+    }
+    impl Foo {
+        fn is_some(obj: &Option<i32>) -> bool {
+            obj.is_some()
+        }
+    }
+    vec![Some(1), None, Some(3)].into_iter().filter(Foo::is_some);
+    // should not lint
+}
+
+fn avoid_fp_with_call_to_outside_var() {
+    let outside = Some(1);
+
+    let _ = vec![Some(1), None, Some(3)]
+        .into_iter()
+        // should not lint
+        .filter(|o| outside.is_some());
+
+    let _ = vec![Some(1), None, Some(3)]
+        .into_iter()
+        // should not lint
+        .filter(|o| Option::is_some(&outside));
+
+    let _ = vec![Some(1), None, Some(3)]
+        .into_iter()
+        // should not lint
+        .filter(|o| std::option::Option::is_some(&outside));
+}
+
+fn avoid_fp_with_call_to_outside_var_mix_match_types() {
+    let outside: Result<i32, ()> = Ok(1);
+
+    let _ = vec![Some(1), None, Some(3)]
+        .into_iter()
+        // should not lint
+        .filter(|o| outside.is_ok());
+
+    let _ = vec![Some(1), None, Some(3)]
+        .into_iter()
+        // should not lint
+        .filter(|o| Result::is_ok(&outside));
+
+    let _ = vec![Some(1), None, Some(3)]
+        .into_iter()
+        // should not lint
+        .filter(|o| std::result::Result::is_ok(&outside));
+}
diff --git a/tests/ui/iter_filter_is_some.rs b/tests/ui/iter_filter_is_some.rs
index b023776abe4..c74775a82ba 100644
--- a/tests/ui/iter_filter_is_some.rs
+++ b/tests/ui/iter_filter_is_some.rs
@@ -1,23 +1,70 @@
 #![warn(clippy::iter_filter_is_some)]
+#![allow(
+    clippy::map_identity,
+    clippy::result_filter_map,
+    clippy::needless_borrow,
+    clippy::option_filter_map,
+    clippy::redundant_closure
+)]
+
+use std::collections::HashMap;
 
 fn main() {
-    let _ = vec![Some(1)].into_iter().filter(Option::is_some);
-    //~^ HELP: consider using `flatten` instead
-    let _ = vec![Some(1)].into_iter().filter(|o| o.is_some());
-    //~^ HELP: consider using `flatten` instead
+    {
+        let _ = vec![Some(1), None, Some(3)].into_iter().filter(Option::is_some);
+        //~^ HELP: consider using `flatten` instead
+        let _ = vec![Some(1), None, Some(3)].into_iter().filter(|a| a.is_some());
+        //~^ HELP: consider using `flatten` instead
+        #[rustfmt::skip]
+        let _ = vec![Some(1), None, Some(3)].into_iter().filter(|o| { o.is_some() });
+        //~^ HELP: consider using `flatten` instead
+    }
+
+    {
+        let _ = vec![Some(1), None, Some(3)]
+            .into_iter()
+            .filter(std::option::Option::is_some);
+        //~^ HELP: consider using `flatten` instead
+
+        let _ = vec![Some(1), None, Some(3)]
+            .into_iter()
+            .filter(|a| std::option::Option::is_some(a));
+        //~^ HELP: consider using `flatten` instead
+        #[rustfmt::skip]
+        let _ = vec![Some(1), None, Some(3)].into_iter().filter(|a| { std::option::Option::is_some(a) });
+        //~^ HELP: consider using `flatten` instead
+    }
+
+    {
+        let _ = vec![Some(1), None, Some(3)].into_iter().filter(|&a| a.is_some());
+        //~^ HELP: consider using `flatten` instead
+
+        #[rustfmt::skip]
+        let _ = vec![Some(1), None, Some(3)].into_iter().filter(|&o| { o.is_some() });
+        //~^ HELP: consider using `flatten` instead
+    }
+
+    {
+        let _ = vec![Some(1), None, Some(3)].into_iter().filter(|ref a| a.is_some());
+        //~^ HELP: consider using `flatten` instead
 
-    #[rustfmt::skip]
-    let _ = vec![Some(1)].into_iter().filter(|o| { o.is_some() });
-    //~^ HELP: consider using `flatten` instead
+        #[rustfmt::skip]
+        let _ = vec![Some(1), None, Some(3)].into_iter().filter(|ref o| { o.is_some() });
+        //~^ HELP: consider using `flatten` instead
+    }
+}
 
+fn avoid_linting_when_filter_has_side_effects() {
     // Don't lint below
     let mut counter = 0;
-    let _ = vec![Some(1)].into_iter().filter(|o| {
+    let _ = vec![Some(1), None, Some(3)].into_iter().filter(|o| {
         counter += 1;
         o.is_some()
     });
+}
 
-    let _ = vec![Some(1)].into_iter().filter(|o| {
+fn avoid_linting_when_commented() {
+    let _ = vec![Some(1), None, Some(3)].into_iter().filter(|o| {
         // Roses are red,
         // Violets are blue,
         // `Err` is not an `Option`,
@@ -25,3 +72,169 @@ fn main() {
         o.is_some()
     });
 }
+
+fn ice_12058() {
+    // check that checking the parent node doesn't cause an ICE
+    // by indexing the parameters of a closure without parameters
+    Some(1).or_else(|| {
+        vec![Some(1), None, Some(3)].into_iter().filter(|z| *z != Some(2));
+        None
+    });
+}
+
+fn avoid_linting_map() {
+    // should not lint
+    let _ = vec![Some(1), None, Some(3)]
+        .into_iter()
+        .filter(|o| o.is_some())
+        .map(|o| o.unwrap());
+
+    // should not lint
+    let _ = vec![Some(1), None, Some(3)]
+        .into_iter()
+        .filter(|o| o.is_some())
+        .map(|o| o);
+}
+
+fn avoid_false_positive_due_to_is_some_and_iterator_impl() {
+    #[derive(Default, Clone)]
+    struct Foo {}
+
+    impl Foo {
+        fn is_some(&self) -> bool {
+            true
+        }
+    }
+
+    impl Iterator for Foo {
+        type Item = Foo;
+        fn next(&mut self) -> Option<Self::Item> {
+            Some(Foo::default())
+        }
+    }
+
+    let data = vec![Foo::default()];
+    // should not lint
+    let _ = data.clone().into_iter().filter(Foo::is_some);
+    // should not lint
+    let _ = data.clone().into_iter().filter(|f| f.is_some());
+}
+
+fn avoid_false_positive_due_to_is_some_and_into_iterator_impl() {
+    #[derive(Default, Clone)]
+    struct Foo {}
+
+    impl Foo {
+        fn is_some(&self) -> bool {
+            true
+        }
+    }
+
+    let data = vec![Foo::default()];
+    // should not lint
+    let _ = data.clone().into_iter().filter(Foo::is_some);
+    // should not lint
+    let _ = data.clone().into_iter().filter(|f| f.is_some());
+}
+
+fn avoid_unpack_fp() {
+    let _ = vec![(Some(1), None), (None, Some(3))]
+        .into_iter()
+        // should not lint
+        .filter(|(a, _)| a.is_some());
+    let _ = vec![(Some(1), None), (None, Some(3))]
+        .into_iter()
+        // should not lint
+        .filter(|(a, _)| a.is_some())
+        .collect::<Vec<_>>();
+
+    let m = HashMap::from([(1, 1)]);
+    let _ = vec![1, 2, 4].into_iter().filter(|a| m.get(a).is_some());
+    // should not lint
+}
+
+fn avoid_fp_for_external() {
+    let value = HashMap::from([(1, 1)]);
+    let _ = vec![Some(1), None, Some(3)]
+        .into_iter()
+        // should not lint
+        .filter(|o| value.get(&1).is_some());
+
+    let value = Option::Some(1);
+    let _ = vec![Some(1), None, Some(3)]
+        .into_iter()
+        // should not lint
+        .filter(|o| value.is_some());
+}
+
+fn avoid_fp_for_trivial() {
+    let value = HashMap::from([(1, 1)]);
+    let _ = vec![Some(1), None, Some(3)]
+        .into_iter()
+        // should not lint
+        .filter(|o| Some(1).is_some());
+    let _ = vec![Some(1), None, Some(3)]
+        .into_iter()
+        // should not lint
+        .filter(|o| None::<i32>.is_some());
+}
+
+fn avoid_false_positive_due_to_method_name() {
+    fn is_some(x: &Option<i32>) -> bool {
+        x.is_some()
+    }
+
+    vec![Some(1), None, Some(3)].into_iter().filter(is_some);
+    // should not lint
+}
+
+fn avoid_fp_due_to_trait_type() {
+    struct Foo {
+        bar: i32,
+    }
+    impl Foo {
+        fn is_some(obj: &Option<i32>) -> bool {
+            obj.is_some()
+        }
+    }
+    vec![Some(1), None, Some(3)].into_iter().filter(Foo::is_some);
+    // should not lint
+}
+
+fn avoid_fp_with_call_to_outside_var() {
+    let outside = Some(1);
+
+    let _ = vec![Some(1), None, Some(3)]
+        .into_iter()
+        // should not lint
+        .filter(|o| outside.is_some());
+
+    let _ = vec![Some(1), None, Some(3)]
+        .into_iter()
+        // should not lint
+        .filter(|o| Option::is_some(&outside));
+
+    let _ = vec![Some(1), None, Some(3)]
+        .into_iter()
+        // should not lint
+        .filter(|o| std::option::Option::is_some(&outside));
+}
+
+fn avoid_fp_with_call_to_outside_var_mix_match_types() {
+    let outside: Result<i32, ()> = Ok(1);
+
+    let _ = vec![Some(1), None, Some(3)]
+        .into_iter()
+        // should not lint
+        .filter(|o| outside.is_ok());
+
+    let _ = vec![Some(1), None, Some(3)]
+        .into_iter()
+        // should not lint
+        .filter(|o| Result::is_ok(&outside));
+
+    let _ = vec![Some(1), None, Some(3)]
+        .into_iter()
+        // should not lint
+        .filter(|o| std::result::Result::is_ok(&outside));
+}
diff --git a/tests/ui/iter_filter_is_some.stderr b/tests/ui/iter_filter_is_some.stderr
index 1f2b10036fe..2eb00633e88 100644
--- a/tests/ui/iter_filter_is_some.stderr
+++ b/tests/ui/iter_filter_is_some.stderr
@@ -1,23 +1,65 @@
 error: `filter` for `is_some` on iterator over `Option`
-  --> $DIR/iter_filter_is_some.rs:4:39
+  --> $DIR/iter_filter_is_some.rs:14:58
    |
-LL |     let _ = vec![Some(1)].into_iter().filter(Option::is_some);
-   |                                       ^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
+LL |         let _ = vec![Some(1), None, Some(3)].into_iter().filter(Option::is_some);
+   |                                                          ^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
    |
    = note: `-D clippy::iter-filter-is-some` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::iter_filter_is_some)]`
 
 error: `filter` for `is_some` on iterator over `Option`
-  --> $DIR/iter_filter_is_some.rs:6:39
+  --> $DIR/iter_filter_is_some.rs:16:58
    |
-LL |     let _ = vec![Some(1)].into_iter().filter(|o| o.is_some());
-   |                                       ^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
+LL |         let _ = vec![Some(1), None, Some(3)].into_iter().filter(|a| a.is_some());
+   |                                                          ^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
 
 error: `filter` for `is_some` on iterator over `Option`
-  --> $DIR/iter_filter_is_some.rs:10:39
+  --> $DIR/iter_filter_is_some.rs:19:58
    |
-LL |     let _ = vec![Some(1)].into_iter().filter(|o| { o.is_some() });
-   |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
+LL |         let _ = vec![Some(1), None, Some(3)].into_iter().filter(|o| { o.is_some() });
+   |                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
 
-error: aborting due to 3 previous errors
+error: `filter` for `is_some` on iterator over `Option`
+  --> $DIR/iter_filter_is_some.rs:26:14
+   |
+LL |             .filter(std::option::Option::is_some);
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
+
+error: `filter` for `is_some` on iterator over `Option`
+  --> $DIR/iter_filter_is_some.rs:31:14
+   |
+LL |             .filter(|a| std::option::Option::is_some(a));
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
+
+error: `filter` for `is_some` on iterator over `Option`
+  --> $DIR/iter_filter_is_some.rs:34:58
+   |
+LL |         let _ = vec![Some(1), None, Some(3)].into_iter().filter(|a| { std::option::Option::is_some(a) });
+   |                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
+
+error: `filter` for `is_some` on iterator over `Option`
+  --> $DIR/iter_filter_is_some.rs:39:58
+   |
+LL |         let _ = vec![Some(1), None, Some(3)].into_iter().filter(|&a| a.is_some());
+   |                                                          ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
+
+error: `filter` for `is_some` on iterator over `Option`
+  --> $DIR/iter_filter_is_some.rs:43:58
+   |
+LL |         let _ = vec![Some(1), None, Some(3)].into_iter().filter(|&o| { o.is_some() });
+   |                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
+
+error: `filter` for `is_some` on iterator over `Option`
+  --> $DIR/iter_filter_is_some.rs:48:58
+   |
+LL |         let _ = vec![Some(1), None, Some(3)].into_iter().filter(|ref a| a.is_some());
+   |                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
+
+error: `filter` for `is_some` on iterator over `Option`
+  --> $DIR/iter_filter_is_some.rs:52:58
+   |
+LL |         let _ = vec![Some(1), None, Some(3)].into_iter().filter(|ref o| { o.is_some() });
+   |                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
+
+error: aborting due to 10 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 4ab6924bca42b5d6c5753dd3d3a9e5a2b9eae258 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Sat, 6 Jan 2024 19:32:52 +0100
Subject: Extend `useless_asref` lint on `map(clone)`

---
 clippy_lints/src/methods/useless_asref.rs | 135 +++++++++++++++++++++++++++++-
 1 file changed, 132 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/useless_asref.rs b/clippy_lints/src/methods/useless_asref.rs
index 84ee64e88a6..f3aa8858250 100644
--- a/clippy_lints/src/methods/useless_asref.rs
+++ b/clippy_lints/src/methods/useless_asref.rs
@@ -1,19 +1,52 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::walk_ptrs_ty_depth;
-use clippy_utils::{get_parent_expr, is_trait_method};
+use clippy_utils::{get_parent_expr, is_diag_trait_item, match_def_path, paths, peel_blocks};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
-use rustc_span::sym;
+use rustc_middle::ty::adjustment::Adjust;
+use rustc_middle::ty::{Ty, TyCtxt, TypeSuperVisitable, TypeVisitable, TypeVisitor};
+use rustc_span::{sym, Span};
+
+use core::ops::ControlFlow;
 
 use super::USELESS_ASREF;
 
+/// Returns the first type inside the `Option`/`Result` type passed as argument.
+fn get_enum_ty(enum_ty: Ty<'_>) -> Option<Ty<'_>> {
+    struct ContainsTyVisitor {
+        level: usize,
+    }
+
+    impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for ContainsTyVisitor {
+        type BreakTy = Ty<'tcx>;
+
+        fn visit_ty(&mut self, t: Ty<'tcx>) -> ControlFlow<Self::BreakTy> {
+            self.level += 1;
+            if self.level == 1 {
+                t.super_visit_with(self)
+            } else {
+                ControlFlow::Break(t)
+            }
+        }
+    }
+
+    match enum_ty.visit_with(&mut ContainsTyVisitor { level: 0 }) {
+        ControlFlow::Break(ty) => Some(ty),
+        ControlFlow::Continue(()) => None,
+    }
+}
+
 /// Checks for the `USELESS_ASREF` lint.
 pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, call_name: &str, recvr: &hir::Expr<'_>) {
     // when we get here, we've already checked that the call name is "as_ref" or "as_mut"
     // check if the call is to the actual `AsRef` or `AsMut` trait
-    if is_trait_method(cx, expr, sym::AsRef) || is_trait_method(cx, expr, sym::AsMut) {
+    let Some(def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id) else {
+        return;
+    };
+
+    if is_diag_trait_item(cx, def_id, sym::AsRef) || is_diag_trait_item(cx, def_id, sym::AsMut) {
         // check if the type after `as_ref` or `as_mut` is the same as before
         let rcv_ty = cx.typeck_results().expr_ty(recvr);
         let res_ty = cx.typeck_results().expr_ty(expr);
@@ -39,5 +72,101 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, call_name: &str,
                 applicability,
             );
         }
+    } else if match_def_path(cx, def_id, &["core", "option", "Option", call_name])
+        || match_def_path(cx, def_id, &["core", "result", "Result", call_name])
+    {
+        let rcv_ty = cx.typeck_results().expr_ty(recvr).peel_refs();
+        let res_ty = cx.typeck_results().expr_ty(expr).peel_refs();
+
+        if let Some(rcv_ty) = get_enum_ty(rcv_ty)
+            && let Some(res_ty) = get_enum_ty(res_ty)
+            // If the only thing the `as_mut`/`as_ref` call is doing is adding references and not
+            // changing the type, then we can move forward.
+            && rcv_ty.peel_refs() == res_ty.peel_refs()
+            && let Some(parent) = get_parent_expr(cx, expr)
+            && let hir::ExprKind::MethodCall(segment, _, args, _) = parent.kind
+            && segment.ident.span != expr.span
+            // We check that the called method name is `map`.
+            && segment.ident.name == sym::map
+            // And that it only has one argument.
+            && let [arg] = args
+        {
+            match arg.kind {
+                hir::ExprKind::Closure(&hir::Closure { body, .. }) => {
+                    // If it's a closure, we need to check what is called.
+                    let closure_body = cx.tcx.hir().body(body);
+                    let closure_expr = peel_blocks(closure_body.value);
+                    match closure_expr.kind {
+                        hir::ExprKind::MethodCall(method, obj, [], _) => {
+                            if method.ident.name == sym::clone
+                                && let Some(fn_id) = cx.typeck_results().type_dependent_def_id(closure_expr.hir_id)
+                                && let Some(trait_id) = cx.tcx.trait_of_item(fn_id)
+                                // We check it's the `Clone` trait.
+                                && cx.tcx.lang_items().clone_trait().map_or(false, |id| id == trait_id)
+                                // no autoderefs
+                                && !cx.typeck_results().expr_adjustments(obj).iter()
+                                    .any(|a| matches!(a.kind, Adjust::Deref(Some(..))))
+                            {
+                                lint_as_ref_clone(cx, expr.span.with_hi(parent.span.hi()), recvr, call_name);
+                            }
+                        },
+                        hir::ExprKind::Call(call, [_]) => {
+                            if let hir::ExprKind::Path(qpath) = call.kind {
+                                check_qpath(
+                                    cx,
+                                    expr.span.with_hi(parent.span.hi()),
+                                    recvr,
+                                    call_name,
+                                    qpath,
+                                    call.hir_id,
+                                );
+                            }
+                        },
+                        _ => {},
+                    }
+                },
+                hir::ExprKind::Path(qpath) => check_qpath(
+                    cx,
+                    expr.span.with_hi(parent.span.hi()),
+                    recvr,
+                    call_name,
+                    qpath,
+                    arg.hir_id,
+                ),
+                _ => {},
+            }
+        }
     }
 }
+
+fn check_qpath(
+    cx: &LateContext<'_>,
+    span: Span,
+    recvr: &hir::Expr<'_>,
+    call_name: &str,
+    qpath: hir::QPath<'_>,
+    hir_id: hir::HirId,
+) {
+    // We check it's calling the `clone` method of the `Clone` trait.
+    if let Some(path_def_id) = cx.qpath_res(&qpath, hir_id).opt_def_id()
+        && match_def_path(cx, path_def_id, &paths::CLONE_TRAIT_METHOD)
+    {
+        lint_as_ref_clone(cx, span, recvr, call_name);
+    }
+}
+
+fn lint_as_ref_clone(cx: &LateContext<'_>, span: Span, recvr: &hir::Expr<'_>, call_name: &str) {
+    let mut applicability = Applicability::MachineApplicable;
+    span_lint_and_sugg(
+        cx,
+        USELESS_ASREF,
+        span,
+        &format!("this call to `{call_name}.map(...)` does nothing"),
+        "try",
+        format!(
+            "{}.clone()",
+            snippet_with_applicability(cx, recvr.span, "..", &mut applicability)
+        ),
+        applicability,
+    );
+}
-- 
cgit 1.4.1-3-g733a5


From c2d071c11c008b08d841d30bae40f8acfdac0c6e Mon Sep 17 00:00:00 2001
From: Eugene <git@talagrand.org>
Date: Tue, 9 Jan 2024 06:50:17 -0800
Subject: Documentation edits for arc_with_non_send_sync

Arc's documentation uses the term "thread", aligning to that terminology. Fix typo in "Rc".
---
 clippy_lints/src/arc_with_non_send_sync.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/arc_with_non_send_sync.rs b/clippy_lints/src/arc_with_non_send_sync.rs
index 657d52d0e9e..58738d52878 100644
--- a/clippy_lints/src/arc_with_non_send_sync.rs
+++ b/clippy_lints/src/arc_with_non_send_sync.rs
@@ -14,8 +14,8 @@ declare_clippy_lint! {
     /// This lint warns when you use `Arc` with a type that does not implement `Send` or `Sync`.
     ///
     /// ### Why is this bad?
-    /// `Arc<T>` is an Atomic `RC<T>` and guarantees that updates to the reference counter are
-    /// Atomic. This is useful in multiprocessing scenarios. To send an `Arc<T>` across processes
+    /// `Arc<T>` is an Atomic `Rc<T>` and guarantees that updates to the reference counter are
+    /// Atomic. This is useful in multithreading scenarios. To send an `Arc<T>` across threads
     /// and make use of the atomic ref counter, `T` must be [both `Send` and `Sync`](https://doc.rust-lang.org/std/sync/struct.Arc.html#impl-Send-for-Arc%3CT%3E),
     /// either `T` should be made `Send + Sync` or an `Rc` should be used instead of an `Arc`
     ///
-- 
cgit 1.4.1-3-g733a5


From 8791a28c4ab4d6b5d4f20c6785e8d65ff02c30cc Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Tue, 9 Jan 2024 16:35:10 +0100
Subject: Also handle `Result` type for `map_clone` lint

---
 clippy_lints/src/methods/map_clone.rs | 1 +
 tests/ui/map_clone.fixed              | 6 ++++++
 tests/ui/map_clone.rs                 | 6 ++++++
 tests/ui/map_clone.stderr             | 8 +++++++-
 4 files changed, 20 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/map_clone.rs b/clippy_lints/src/methods/map_clone.rs
index 652d2b80081..33b77cdc33d 100644
--- a/clippy_lints/src/methods/map_clone.rs
+++ b/clippy_lints/src/methods/map_clone.rs
@@ -18,6 +18,7 @@ pub(super) fn check(cx: &LateContext<'_>, e: &hir::Expr<'_>, recv: &hir::Expr<'_
     if let Some(method_id) = cx.typeck_results().type_dependent_def_id(e.hir_id)
         && (cx.tcx.impl_of_method(method_id).map_or(false, |id| {
             is_type_diagnostic_item(cx, cx.tcx.type_of(id).instantiate_identity(), sym::Option)
+                || is_type_diagnostic_item(cx, cx.tcx.type_of(id).instantiate_identity(), sym::Result)
         }) || is_diag_trait_item(cx, method_id, sym::Iterator))
     {
         match arg.kind {
diff --git a/tests/ui/map_clone.fixed b/tests/ui/map_clone.fixed
index 74e4ea5ce01..144c42a1cb6 100644
--- a/tests/ui/map_clone.fixed
+++ b/tests/ui/map_clone.fixed
@@ -70,4 +70,10 @@ fn main() {
     //~^ ERROR: you are explicitly cloning with `.map()`
     let y = x.cloned();
     //~^ ERROR: you are explicitly cloning with `.map()`
+
+    // Testing with `Result` now.
+    let x: Result<String, ()> = Ok(String::new());
+    let x = x.as_ref(); // We do this to prevent triggering the `useless_asref` lint.
+    let y = x.cloned();
+    //~^ ERROR: you are explicitly cloning with `.map()`
 }
diff --git a/tests/ui/map_clone.rs b/tests/ui/map_clone.rs
index 0aac8024f67..e264d8ffc53 100644
--- a/tests/ui/map_clone.rs
+++ b/tests/ui/map_clone.rs
@@ -70,4 +70,10 @@ fn main() {
     //~^ ERROR: you are explicitly cloning with `.map()`
     let y = x.map(String::clone);
     //~^ ERROR: you are explicitly cloning with `.map()`
+
+    // Testing with `Result` now.
+    let x: Result<String, ()> = Ok(String::new());
+    let x = x.as_ref(); // We do this to prevent triggering the `useless_asref` lint.
+    let y = x.map(|x| String::clone(x));
+    //~^ ERROR: you are explicitly cloning with `.map()`
 }
diff --git a/tests/ui/map_clone.stderr b/tests/ui/map_clone.stderr
index aae4dae634a..7c6dc08f604 100644
--- a/tests/ui/map_clone.stderr
+++ b/tests/ui/map_clone.stderr
@@ -55,5 +55,11 @@ error: you are explicitly cloning with `.map()`
 LL |     let y = x.map(String::clone);
    |             ^^^^^^^^^^^^^^^^^^^^ help: consider calling the dedicated `cloned` method: `x.cloned()`
 
-error: aborting due to 9 previous errors
+error: you are explicitly cloning with `.map()`
+  --> $DIR/map_clone.rs:77:13
+   |
+LL |     let y = x.map(|x| String::clone(x));
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling the dedicated `cloned` method: `x.cloned()`
+
+error: aborting due to 10 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From e90eea78948a13a810a4c6268f85670fdb4533e3 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Tue, 9 Jan 2024 16:57:54 +0100
Subject: Clean up code in `map_clone` and `useless_asref` lints

---
 clippy_lints/src/methods/map_clone.rs     | 19 ++++--
 clippy_lints/src/methods/useless_asref.rs | 99 ++++++++++++++-----------------
 2 files changed, 59 insertions(+), 59 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/map_clone.rs b/clippy_lints/src/methods/map_clone.rs
index 33b77cdc33d..527e557987d 100644
--- a/clippy_lints/src/methods/map_clone.rs
+++ b/clippy_lints/src/methods/map_clone.rs
@@ -5,6 +5,7 @@ use clippy_utils::ty::{is_copy, is_type_diagnostic_item};
 use clippy_utils::{is_diag_trait_item, match_def_path, paths, peel_blocks};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
+use rustc_hir::def_id::DefId;
 use rustc_lint::LateContext;
 use rustc_middle::mir::Mutability;
 use rustc_middle::ty;
@@ -14,12 +15,22 @@ use rustc_span::{sym, Span};
 
 use super::MAP_CLONE;
 
+fn should_run_lint(cx: &LateContext<'_>, method_id: DefId) -> bool {
+    if is_diag_trait_item(cx, method_id, sym::Iterator) {
+        return true;
+    }
+    if !cx.tcx.impl_of_method(method_id).map_or(false, |id| {
+        is_type_diagnostic_item(cx, cx.tcx.type_of(id).instantiate_identity(), sym::Option)
+            || is_type_diagnostic_item(cx, cx.tcx.type_of(id).instantiate_identity(), sym::Result)
+    }) {
+        return false;
+    }
+    return true;
+}
+
 pub(super) fn check(cx: &LateContext<'_>, e: &hir::Expr<'_>, recv: &hir::Expr<'_>, arg: &hir::Expr<'_>, msrv: &Msrv) {
     if let Some(method_id) = cx.typeck_results().type_dependent_def_id(e.hir_id)
-        && (cx.tcx.impl_of_method(method_id).map_or(false, |id| {
-            is_type_diagnostic_item(cx, cx.tcx.type_of(id).instantiate_identity(), sym::Option)
-                || is_type_diagnostic_item(cx, cx.tcx.type_of(id).instantiate_identity(), sym::Result)
-        }) || is_diag_trait_item(cx, method_id, sym::Iterator))
+        && should_run_lint(cx, method_id)
     {
         match arg.kind {
             hir::ExprKind::Closure(&hir::Closure { body, .. }) => {
diff --git a/clippy_lints/src/methods/useless_asref.rs b/clippy_lints/src/methods/useless_asref.rs
index f3aa8858250..c15ca40e8d8 100644
--- a/clippy_lints/src/methods/useless_asref.rs
+++ b/clippy_lints/src/methods/useless_asref.rs
@@ -91,67 +91,56 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, call_name: &str,
             // And that it only has one argument.
             && let [arg] = args
         {
-            match arg.kind {
-                hir::ExprKind::Closure(&hir::Closure { body, .. }) => {
-                    // If it's a closure, we need to check what is called.
-                    let closure_body = cx.tcx.hir().body(body);
-                    let closure_expr = peel_blocks(closure_body.value);
-                    match closure_expr.kind {
-                        hir::ExprKind::MethodCall(method, obj, [], _) => {
-                            if method.ident.name == sym::clone
-                                && let Some(fn_id) = cx.typeck_results().type_dependent_def_id(closure_expr.hir_id)
-                                && let Some(trait_id) = cx.tcx.trait_of_item(fn_id)
-                                // We check it's the `Clone` trait.
-                                && cx.tcx.lang_items().clone_trait().map_or(false, |id| id == trait_id)
-                                // no autoderefs
-                                && !cx.typeck_results().expr_adjustments(obj).iter()
-                                    .any(|a| matches!(a.kind, Adjust::Deref(Some(..))))
-                            {
-                                lint_as_ref_clone(cx, expr.span.with_hi(parent.span.hi()), recvr, call_name);
-                            }
-                        },
-                        hir::ExprKind::Call(call, [_]) => {
-                            if let hir::ExprKind::Path(qpath) = call.kind {
-                                check_qpath(
-                                    cx,
-                                    expr.span.with_hi(parent.span.hi()),
-                                    recvr,
-                                    call_name,
-                                    qpath,
-                                    call.hir_id,
-                                );
-                            }
-                        },
-                        _ => {},
-                    }
-                },
-                hir::ExprKind::Path(qpath) => check_qpath(
-                    cx,
-                    expr.span.with_hi(parent.span.hi()),
-                    recvr,
-                    call_name,
-                    qpath,
-                    arg.hir_id,
-                ),
-                _ => {},
+            if is_calling_clone(cx, arg) {
+                lint_as_ref_clone(cx, expr.span.with_hi(parent.span.hi()), recvr, call_name);
             }
         }
     }
 }
 
-fn check_qpath(
-    cx: &LateContext<'_>,
-    span: Span,
-    recvr: &hir::Expr<'_>,
-    call_name: &str,
-    qpath: hir::QPath<'_>,
-    hir_id: hir::HirId,
-) {
+fn check_qpath(cx: &LateContext<'_>, qpath: hir::QPath<'_>, hir_id: hir::HirId) -> bool {
     // We check it's calling the `clone` method of the `Clone` trait.
-    if let Some(path_def_id) = cx.qpath_res(&qpath, hir_id).opt_def_id()
-        && match_def_path(cx, path_def_id, &paths::CLONE_TRAIT_METHOD)
-    {
-        lint_as_ref_clone(cx, span, recvr, call_name);
+    if let Some(path_def_id) = cx.qpath_res(&qpath, hir_id).opt_def_id() {
+        match_def_path(cx, path_def_id, &paths::CLONE_TRAIT_METHOD)
+    } else {
+        false
+    }
+}
+
+fn is_calling_clone(cx: &LateContext<'_>, arg: &hir::Expr<'_>) -> bool {
+    match arg.kind {
+        hir::ExprKind::Closure(&hir::Closure { body, .. }) => {
+            // If it's a closure, we need to check what is called.
+            let closure_body = cx.tcx.hir().body(body);
+            let closure_expr = peel_blocks(closure_body.value);
+            match closure_expr.kind {
+                hir::ExprKind::MethodCall(method, obj, [], _) => {
+                    if method.ident.name == sym::clone
+                        && let Some(fn_id) = cx.typeck_results().type_dependent_def_id(closure_expr.hir_id)
+                        && let Some(trait_id) = cx.tcx.trait_of_item(fn_id)
+                        // We check it's the `Clone` trait.
+                        && cx.tcx.lang_items().clone_trait().map_or(false, |id| id == trait_id)
+                        // no autoderefs
+                        && !cx.typeck_results().expr_adjustments(obj).iter()
+                            .any(|a| matches!(a.kind, Adjust::Deref(Some(..))))
+                    {
+                        true
+                    } else {
+                        false
+                    }
+                },
+                hir::ExprKind::Call(call, [_]) => {
+                    if let hir::ExprKind::Path(qpath) = call.kind {
+                        check_qpath(cx, qpath, call.hir_id)
+                    } else {
+                        false
+                    }
+                },
+                _ => false,
+            }
+        },
+        hir::ExprKind::Path(qpath) => check_qpath(cx, qpath, arg.hir_id),
+        _ => false,
     }
 }
 
-- 
cgit 1.4.1-3-g733a5


From 83ae5edd50bf81810821fa9ceaf256036305aed9 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Tue, 9 Jan 2024 17:31:59 +0100
Subject: Don't lint with `map_clone` if current type is `Option` or `Result`
 and method call is `as_ref`.

---
 clippy_lints/src/methods/map_clone.rs | 15 +++++++++++----
 1 file changed, 11 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/map_clone.rs b/clippy_lints/src/methods/map_clone.rs
index 527e557987d..19eea00d545 100644
--- a/clippy_lints/src/methods/map_clone.rs
+++ b/clippy_lints/src/methods/map_clone.rs
@@ -15,22 +15,29 @@ use rustc_span::{sym, Span};
 
 use super::MAP_CLONE;
 
-fn should_run_lint(cx: &LateContext<'_>, method_id: DefId) -> bool {
+fn should_run_lint(cx: &LateContext<'_>, e: &hir::Expr<'_>, method_id: DefId) -> bool {
     if is_diag_trait_item(cx, method_id, sym::Iterator) {
         return true;
     }
     if !cx.tcx.impl_of_method(method_id).map_or(false, |id| {
-        is_type_diagnostic_item(cx, cx.tcx.type_of(id).instantiate_identity(), sym::Option)
-            || is_type_diagnostic_item(cx, cx.tcx.type_of(id).instantiate_identity(), sym::Result)
+        let identity = cx.tcx.type_of(id).instantiate_identity();
+        is_type_diagnostic_item(cx, identity, sym::Option) || is_type_diagnostic_item(cx, identity, sym::Result)
     }) {
         return false;
     }
+    // We check if the previous method call is `as_ref`.
+    if let hir::ExprKind::MethodCall(path1, receiver, _, _) = &e.kind
+        && let hir::ExprKind::MethodCall(path2, _, _, _) = &receiver.kind
+    {
+        return path2.ident.name != sym::as_ref || path1.ident.name != sym::map;
+    }
+
     return true;
 }
 
 pub(super) fn check(cx: &LateContext<'_>, e: &hir::Expr<'_>, recv: &hir::Expr<'_>, arg: &hir::Expr<'_>, msrv: &Msrv) {
     if let Some(method_id) = cx.typeck_results().type_dependent_def_id(e.hir_id)
-        && should_run_lint(cx, method_id)
+        && should_run_lint(cx, e, method_id)
     {
         match arg.kind {
             hir::ExprKind::Closure(&hir::Closure { body, .. }) => {
-- 
cgit 1.4.1-3-g733a5


From f7ef9a6f1fd1ea4126ec1e9173b23baa8449906c Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Tue, 9 Jan 2024 17:58:09 +0100
Subject: Fix dogfood and add code comments

---
 clippy_lints/src/methods/map_clone.rs     | 14 ++++++++++----
 clippy_lints/src/methods/useless_asref.rs |  5 ++---
 2 files changed, 12 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/map_clone.rs b/clippy_lints/src/methods/map_clone.rs
index 19eea00d545..f9f636bbbf7 100644
--- a/clippy_lints/src/methods/map_clone.rs
+++ b/clippy_lints/src/methods/map_clone.rs
@@ -15,14 +15,20 @@ use rustc_span::{sym, Span};
 
 use super::MAP_CLONE;
 
+// If this `map` is called on an `Option` or a `Result` and the previous call is `as_ref`, we don't
+// run this lint because it would overlap with `useless_asref` which provides a better suggestion
+// in this case.
 fn should_run_lint(cx: &LateContext<'_>, e: &hir::Expr<'_>, method_id: DefId) -> bool {
     if is_diag_trait_item(cx, method_id, sym::Iterator) {
         return true;
     }
-    if !cx.tcx.impl_of_method(method_id).map_or(false, |id| {
+    // We check if it's an `Option` or a `Result`.
+    if let Some(id) = cx.tcx.impl_of_method(method_id) {
         let identity = cx.tcx.type_of(id).instantiate_identity();
-        is_type_diagnostic_item(cx, identity, sym::Option) || is_type_diagnostic_item(cx, identity, sym::Result)
-    }) {
+        if !is_type_diagnostic_item(cx, identity, sym::Option) && !is_type_diagnostic_item(cx, identity, sym::Result) {
+            return false;
+        }
+    } else {
         return false;
     }
     // We check if the previous method call is `as_ref`.
@@ -32,7 +38,7 @@ fn should_run_lint(cx: &LateContext<'_>, e: &hir::Expr<'_>, method_id: DefId) ->
         return path2.ident.name != sym::as_ref || path1.ident.name != sym::map;
     }
 
-    return true;
+    true
 }
 
 pub(super) fn check(cx: &LateContext<'_>, e: &hir::Expr<'_>, recv: &hir::Expr<'_>, arg: &hir::Expr<'_>, msrv: &Msrv) {
diff --git a/clippy_lints/src/methods/useless_asref.rs b/clippy_lints/src/methods/useless_asref.rs
index c15ca40e8d8..66727e5a29d 100644
--- a/clippy_lints/src/methods/useless_asref.rs
+++ b/clippy_lints/src/methods/useless_asref.rs
@@ -90,10 +90,9 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, call_name: &str,
             && segment.ident.name == sym::map
             // And that it only has one argument.
             && let [arg] = args
+            && is_calling_clone(cx, arg)
         {
-            if is_calling_clone(cx, arg) {
-                lint_as_ref_clone(cx, expr.span.with_hi(parent.span.hi()), recvr, call_name);
-            }
+            lint_as_ref_clone(cx, expr.span.with_hi(parent.span.hi()), recvr, call_name);
         }
     }
 }
-- 
cgit 1.4.1-3-g733a5


From 7c389acd277eada4d2e0856707361cce24c9b23f Mon Sep 17 00:00:00 2001
From: cocodery <cocodery@outlook.com>
Date: Thu, 11 Jan 2024 14:52:03 +0800
Subject: Fix error warning span for issue12045

---
 clippy_lints/src/no_effect.rs |  2 +-
 tests/ui/no_effect.stderr     | 16 ++++++++--------
 2 files changed, 9 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/no_effect.rs b/clippy_lints/src/no_effect.rs
index 6bbe427ea29..2a2c2b331ba 100644
--- a/clippy_lints/src/no_effect.rs
+++ b/clippy_lints/src/no_effect.rs
@@ -155,7 +155,7 @@ fn check_no_effect(cx: &LateContext<'_>, stmt: &Stmt<'_>) -> bool {
                 cx,
                 NO_EFFECT_UNDERSCORE_BINDING,
                 init.hir_id,
-                stmt.span,
+                ident.span,
                 "binding to `_` prefixed variable with no side-effect",
             );
             return true;
diff --git a/tests/ui/no_effect.stderr b/tests/ui/no_effect.stderr
index f5ba234b4cb..8140ba1feee 100644
--- a/tests/ui/no_effect.stderr
+++ b/tests/ui/no_effect.stderr
@@ -152,31 +152,31 @@ LL |     FooString { s: s };
    |     ^^^^^^^^^^^^^^^^^^^
 
 error: binding to `_` prefixed variable with no side-effect
-  --> $DIR/no_effect.rs:175:5
+  --> $DIR/no_effect.rs:175:9
    |
 LL |     let _unused = 1;
-   |     ^^^^^^^^^^^^^^^^
+   |         ^^^^^^^
    |
    = note: `-D clippy::no-effect-underscore-binding` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::no_effect_underscore_binding)]`
 
 error: binding to `_` prefixed variable with no side-effect
-  --> $DIR/no_effect.rs:178:5
+  --> $DIR/no_effect.rs:178:9
    |
 LL |     let _penguin = || println!("Some helpful closure");
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |         ^^^^^^^^
 
 error: binding to `_` prefixed variable with no side-effect
-  --> $DIR/no_effect.rs:180:5
+  --> $DIR/no_effect.rs:180:9
    |
 LL |     let _duck = Struct { field: 0 };
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |         ^^^^^
 
 error: binding to `_` prefixed variable with no side-effect
-  --> $DIR/no_effect.rs:182:5
+  --> $DIR/no_effect.rs:182:9
    |
 LL |     let _cat = [2, 4, 6, 8][2];
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |         ^^^^
 
 error: aborting due to 29 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 82841aada409384bfaf13cbfc2705addd156a2cf Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Thu, 11 Jan 2024 17:03:11 +0100
Subject: Fix suggestion for `map_clone` on types implementing `Copy`

---
 clippy_lints/src/methods/map_clone.rs | 20 ++++++++++++++------
 1 file changed, 14 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/map_clone.rs b/clippy_lints/src/methods/map_clone.rs
index f9f636bbbf7..27e17b43b01 100644
--- a/clippy_lints/src/methods/map_clone.rs
+++ b/clippy_lints/src/methods/map_clone.rs
@@ -113,9 +113,15 @@ fn handle_path(
     if let Some(path_def_id) = cx.qpath_res(qpath, arg.hir_id).opt_def_id()
         && match_def_path(cx, path_def_id, &paths::CLONE_TRAIT_METHOD)
     {
-        // FIXME: It would be better to infer the type to check if it's copyable or not
-        // to suggest to use `.copied()` instead of `.cloned()` where applicable.
-        lint_path(cx, e.span, recv.span);
+        // The `copied` and `cloned` methods are only available on `&T` and `&mut T` in `Option`
+        // and `Result`.
+        if let ty::Adt(_, args) = cx.typeck_results().expr_ty(recv).kind()
+            && let args = args.as_slice()
+            && let Some(ty) = args.iter().find_map(|generic_arg| generic_arg.as_type())
+            && ty.is_ref()
+        {
+            lint_path(cx, e.span, recv.span, is_copy(cx, ty.peel_refs()));
+        }
     }
 }
 
@@ -139,17 +145,19 @@ fn lint_needless_cloning(cx: &LateContext<'_>, root: Span, receiver: Span) {
     );
 }
 
-fn lint_path(cx: &LateContext<'_>, replace: Span, root: Span) {
+fn lint_path(cx: &LateContext<'_>, replace: Span, root: Span, is_copy: bool) {
     let mut applicability = Applicability::MachineApplicable;
 
+    let replacement = if is_copy { "copied" } else { "cloned" };
+
     span_lint_and_sugg(
         cx,
         MAP_CLONE,
         replace,
         "you are explicitly cloning with `.map()`",
-        "consider calling the dedicated `cloned` method",
+        &format!("consider calling the dedicated `{replacement}` method"),
         format!(
-            "{}.cloned()",
+            "{}.{replacement}()",
             snippet_with_applicability(cx, root, "..", &mut applicability),
         ),
         applicability,
-- 
cgit 1.4.1-3-g733a5


From 153b83f61bc064dd09d23927784bab2c18f7db54 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Fri, 12 Jan 2024 13:39:42 +0100
Subject: [`useless_asref`]: check that the clone receiver is the local

---
 clippy_lints/src/methods/useless_asref.rs | 26 +++++++++++++++++++++++---
 tests/ui/useless_asref.fixed              | 31 +++++++++++++++++++++++++++++++
 tests/ui/useless_asref.rs                 | 31 +++++++++++++++++++++++++++++++
 tests/ui/useless_asref.stderr             | 20 +++++++++++++++++++-
 4 files changed, 104 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/useless_asref.rs b/clippy_lints/src/methods/useless_asref.rs
index 66727e5a29d..d6c79db4d70 100644
--- a/clippy_lints/src/methods/useless_asref.rs
+++ b/clippy_lints/src/methods/useless_asref.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::walk_ptrs_ty_depth;
-use clippy_utils::{get_parent_expr, is_diag_trait_item, match_def_path, paths, peel_blocks};
+use clippy_utils::{get_parent_expr, is_diag_trait_item, match_def_path, path_to_local_id, paths, peel_blocks};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
@@ -111,6 +111,23 @@ fn is_calling_clone(cx: &LateContext<'_>, arg: &hir::Expr<'_>) -> bool {
         hir::ExprKind::Closure(&hir::Closure { body, .. }) => {
             // If it's a closure, we need to check what is called.
             let closure_body = cx.tcx.hir().body(body);
+
+            // |x| ...
+            //  ^
+            let [
+                hir::Param {
+                    pat:
+                        hir::Pat {
+                            kind: hir::PatKind::Binding(_, local_id, ..),
+                            ..
+                        },
+                    ..
+                },
+            ] = closure_body.params
+            else {
+                return false;
+            };
+
             let closure_expr = peel_blocks(closure_body.value);
             match closure_expr.kind {
                 hir::ExprKind::MethodCall(method, obj, [], _) => {
@@ -122,14 +139,17 @@ fn is_calling_clone(cx: &LateContext<'_>, arg: &hir::Expr<'_>) -> bool {
                         // no autoderefs
                         && !cx.typeck_results().expr_adjustments(obj).iter()
                             .any(|a| matches!(a.kind, Adjust::Deref(Some(..))))
+                        && path_to_local_id(obj, *local_id)
                     {
                         true
                     } else {
                         false
                     }
                 },
-                hir::ExprKind::Call(call, [_]) => {
-                    if let hir::ExprKind::Path(qpath) = call.kind {
+                hir::ExprKind::Call(call, [recv]) => {
+                    if let hir::ExprKind::Path(qpath) = call.kind
+                        && path_to_local_id(recv, *local_id)
+                    {
                         check_qpath(cx, qpath, call.hir_id)
                     } else {
                         false
diff --git a/tests/ui/useless_asref.fixed b/tests/ui/useless_asref.fixed
index 88b95095bc0..d39d8a74b26 100644
--- a/tests/ui/useless_asref.fixed
+++ b/tests/ui/useless_asref.fixed
@@ -144,6 +144,37 @@ fn foo() {
     //~^ ERROR: this call to `as_ref.map(...)` does nothing
 }
 
+mod issue12135 {
+    pub struct Struct {
+        field: Option<InnerStruct>,
+    }
+
+    #[derive(Clone)]
+    pub struct Foo;
+
+    #[derive(Clone)]
+    struct InnerStruct {
+        x: Foo,
+    }
+
+    impl InnerStruct {
+        fn method(&self) -> &Foo {
+            &self.x
+        }
+    }
+
+    pub fn f(x: &Struct) -> Option<Foo> {
+        x.field.clone();
+        //~^ ERROR: this call to `as_ref.map(...)` does nothing
+        x.field.clone();
+        //~^ ERROR: this call to `as_ref.map(...)` does nothing
+        x.field.clone();
+        //~^ ERROR: this call to `as_ref.map(...)` does nothing
+
+        x.field.as_ref().map(|v| v.method().clone())
+    }
+}
+
 fn main() {
     not_ok();
     ok();
diff --git a/tests/ui/useless_asref.rs b/tests/ui/useless_asref.rs
index 504dc1f5cbf..76277e7b7a4 100644
--- a/tests/ui/useless_asref.rs
+++ b/tests/ui/useless_asref.rs
@@ -144,6 +144,37 @@ fn foo() {
     //~^ ERROR: this call to `as_ref.map(...)` does nothing
 }
 
+mod issue12135 {
+    pub struct Struct {
+        field: Option<InnerStruct>,
+    }
+
+    #[derive(Clone)]
+    pub struct Foo;
+
+    #[derive(Clone)]
+    struct InnerStruct {
+        x: Foo,
+    }
+
+    impl InnerStruct {
+        fn method(&self) -> &Foo {
+            &self.x
+        }
+    }
+
+    pub fn f(x: &Struct) -> Option<Foo> {
+        x.field.as_ref().map(|v| v.clone());
+        //~^ ERROR: this call to `as_ref.map(...)` does nothing
+        x.field.as_ref().map(Clone::clone);
+        //~^ ERROR: this call to `as_ref.map(...)` does nothing
+        x.field.as_ref().map(|v| Clone::clone(v));
+        //~^ ERROR: this call to `as_ref.map(...)` does nothing
+
+        x.field.as_ref().map(|v| v.method().clone())
+    }
+}
+
 fn main() {
     not_ok();
     ok();
diff --git a/tests/ui/useless_asref.stderr b/tests/ui/useless_asref.stderr
index deb5d90f2f6..583b48732d4 100644
--- a/tests/ui/useless_asref.stderr
+++ b/tests/ui/useless_asref.stderr
@@ -88,5 +88,23 @@ error: this call to `as_ref.map(...)` does nothing
 LL |     let z = x.as_ref().map(|z| String::clone(z));
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `x.clone()`
 
-error: aborting due to 14 previous errors
+error: this call to `as_ref.map(...)` does nothing
+  --> $DIR/useless_asref.rs:167:9
+   |
+LL |         x.field.as_ref().map(|v| v.clone());
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `x.field.clone()`
+
+error: this call to `as_ref.map(...)` does nothing
+  --> $DIR/useless_asref.rs:169:9
+   |
+LL |         x.field.as_ref().map(Clone::clone);
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `x.field.clone()`
+
+error: this call to `as_ref.map(...)` does nothing
+  --> $DIR/useless_asref.rs:171:9
+   |
+LL |         x.field.as_ref().map(|v| Clone::clone(v));
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `x.field.clone()`
+
+error: aborting due to 17 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From c8cd09a8e60ce2aae86963d3c8e7d63f33203f55 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Fri, 12 Jan 2024 15:37:43 +0100
Subject: Fix false positive in `PartialEq` check in `unconditional_recursion`
 lint

---
 clippy_lints/src/unconditional_recursion.rs | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unconditional_recursion.rs b/clippy_lints/src/unconditional_recursion.rs
index e90306ded61..2c283002087 100644
--- a/clippy_lints/src/unconditional_recursion.rs
+++ b/clippy_lints/src/unconditional_recursion.rs
@@ -167,7 +167,15 @@ fn check_partial_eq(cx: &LateContext<'_>, method_span: Span, method_def_id: Loca
                     false
                 }
             },
-            ExprKind::MethodCall(segment, _receiver, &[_arg], _) if segment.ident.name == name.name => {
+            ExprKind::MethodCall(segment, receiver, &[_arg], _) if segment.ident.name == name.name => {
+                if let Some(ty) = cx.typeck_results().expr_ty_opt(receiver)
+                    && let Some(ty_id) = get_ty_def_id(ty)
+                    && self_arg != ty_id
+                {
+                    // Since this called on a different type, the lint should not be
+                    // triggered here.
+                    return;
+                }
                 if let Some(fn_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id)
                     && let Some(trait_id) = cx.tcx.trait_of_item(fn_id)
                     && trait_id == trait_def_id
-- 
cgit 1.4.1-3-g733a5


From 68aceeed03014fab17269b0f0cb5e79b5097e557 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Fri, 12 Jan 2024 22:48:09 +0100
Subject: Improve help message for `search_is_some` lint

---
 clippy_lints/src/methods/search_is_some.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/search_is_some.rs b/clippy_lints/src/methods/search_is_some.rs
index 6339011c92f..ef1baa6c988 100644
--- a/clippy_lints/src/methods/search_is_some.rs
+++ b/clippy_lints/src/methods/search_is_some.rs
@@ -63,7 +63,7 @@ pub(super) fn check<'tcx>(
                     SEARCH_IS_SOME,
                     method_span.with_hi(expr.span.hi()),
                     &msg,
-                    "use `any()` instead",
+                    "consider using",
                     format!(
                         "any({})",
                         any_search_snippet.as_ref().map_or(&*search_snippet, String::as_str)
@@ -77,7 +77,7 @@ pub(super) fn check<'tcx>(
                     SEARCH_IS_SOME,
                     expr.span,
                     &msg,
-                    "use `!_.any()` instead",
+                    "consider using",
                     format!(
                         "!{iter}.any({})",
                         any_search_snippet.as_ref().map_or(&*search_snippet, String::as_str)
@@ -118,7 +118,7 @@ pub(super) fn check<'tcx>(
                         SEARCH_IS_SOME,
                         method_span.with_hi(expr.span.hi()),
                         &msg,
-                        "use `contains()` instead",
+                        "consider using",
                         format!("contains({find_arg})"),
                         applicability,
                     );
@@ -132,7 +132,7 @@ pub(super) fn check<'tcx>(
                         SEARCH_IS_SOME,
                         expr.span,
                         &msg,
-                        "use `!_.contains()` instead",
+                        "consider using",
                         format!("!{string}.contains({find_arg})"),
                         applicability,
                     );
-- 
cgit 1.4.1-3-g733a5


From e02535696948a921937e4768421cf4cf9b8e7a53 Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Sat, 13 Jan 2024 13:14:16 +0100
Subject: from_over_into: suggest a correct conversion to ()

---
 clippy_lints/src/from_over_into.rs |  9 ++++++---
 tests/ui/from_over_into.fixed      |  8 ++++++++
 tests/ui/from_over_into.rs         |  8 ++++++++
 tests/ui/from_over_into.stderr     | 16 +++++++++++++++-
 4 files changed, 37 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/from_over_into.rs b/clippy_lints/src/from_over_into.rs
index fa1f98ba013..93527bcdf5c 100644
--- a/clippy_lints/src/from_over_into.rs
+++ b/clippy_lints/src/from_over_into.rs
@@ -6,8 +6,8 @@ use clippy_utils::source::snippet_opt;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_path, Visitor};
 use rustc_hir::{
-    GenericArg, GenericArgs, HirId, Impl, ImplItemKind, ImplItemRef, Item, ItemKind, PatKind, Path, PathSegment, Ty,
-    TyKind,
+    FnRetTy, GenericArg, GenericArgs, HirId, Impl, ImplItemKind, ImplItemRef, Item, ItemKind, PatKind, Path,
+    PathSegment, Ty, TyKind,
 };
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::nested_filter::OnlyBodies;
@@ -181,6 +181,9 @@ fn convert_to_from(
     let from = snippet_opt(cx, self_ty.span)?;
     let into = snippet_opt(cx, target_ty.span)?;
 
+    let return_type = matches!(sig.decl.output, FnRetTy::Return(_))
+        .then_some(String::from("Self"))
+        .unwrap_or_default();
     let mut suggestions = vec![
         // impl Into<T> for U  ->  impl From<T> for U
         //      ~~~~                    ~~~~
@@ -199,7 +202,7 @@ fn convert_to_from(
         (self_ident.span, format!("val: {from}")),
         // fn into(self) -> T  ->  fn into(self) -> Self
         //                  ~                       ~~~~
-        (sig.decl.output.span(), String::from("Self")),
+        (sig.decl.output.span(), return_type),
     ];
 
     let mut finder = SelfFinder {
diff --git a/tests/ui/from_over_into.fixed b/tests/ui/from_over_into.fixed
index 18d285693e6..4a68505ee0b 100644
--- a/tests/ui/from_over_into.fixed
+++ b/tests/ui/from_over_into.fixed
@@ -89,4 +89,12 @@ fn msrv_1_41() {
     }
 }
 
+fn issue_12138() {
+    struct Hello;
+
+    impl From<Hello> for () {
+        fn from(val: Hello) {}
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/from_over_into.rs b/tests/ui/from_over_into.rs
index 779ef709e92..bf3ed0c2b64 100644
--- a/tests/ui/from_over_into.rs
+++ b/tests/ui/from_over_into.rs
@@ -89,4 +89,12 @@ fn msrv_1_41() {
     }
 }
 
+fn issue_12138() {
+    struct Hello;
+
+    impl Into<()> for Hello {
+        fn into(self) {}
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/from_over_into.stderr b/tests/ui/from_over_into.stderr
index 784843ce5fd..f1370ed844f 100644
--- a/tests/ui/from_over_into.stderr
+++ b/tests/ui/from_over_into.stderr
@@ -86,5 +86,19 @@ LL ~         fn from(val: Vec<T>) -> Self {
 LL ~             FromOverInto(val)
    |
 
-error: aborting due to 6 previous errors
+error: an implementation of `From` is preferred since it gives you `Into<_>` for free where the reverse isn't true
+  --> $DIR/from_over_into.rs:95:5
+   |
+LL |     impl Into<()> for Hello {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: `impl From<Local> for Foreign` is allowed by the orphan rules, for more information see
+           https://doc.rust-lang.org/reference/items/implementations.html#trait-implementation-coherence
+help: replace the `Into` implementation with `From<issue_12138::Hello>`
+   |
+LL ~     impl From<Hello> for () {
+LL ~         fn from(val: Hello) {}
+   |
+
+error: aborting due to 7 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From e0228eeb94501cd864b0fb6edb019f401111d586 Mon Sep 17 00:00:00 2001
From: Quinn Sinclair <me@partiallytyped.dev>
Date: Wed, 3 Jan 2024 13:36:44 +0200
Subject: Fixes FP in `redundant_closure_call` when closures are passed to
 macros

There are cases where the closure call is needed in some macros, this in
particular occurs when the closure has parameters. To handle this case,
we allow the lint when there are no parameters in the closure, or the
closure is outside a macro invocation.

fixes: #11274, #1553
changelog: FP: [`redundant_closure_call`] when closures with parameters
are passed in macros.
---
 clippy_lints/src/redundant_closure_call.rs    | 14 ++++++++++++--
 tests/ui/redundant_closure_call_fixable.fixed |  9 +++++++++
 tests/ui/redundant_closure_call_fixable.rs    |  9 +++++++++
 3 files changed, 30 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/redundant_closure_call.rs b/clippy_lints/src/redundant_closure_call.rs
index cde08dfcc74..bd893893435 100644
--- a/clippy_lints/src/redundant_closure_call.rs
+++ b/clippy_lints/src/redundant_closure_call.rs
@@ -2,6 +2,7 @@ use crate::rustc_lint::LintContext;
 use clippy_utils::diagnostics::{span_lint, span_lint_and_then};
 use clippy_utils::get_parent_expr;
 use clippy_utils::sugg::Sugg;
+use hir::Param;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_hir::intravisit::{Visitor as HirVisitor, Visitor};
@@ -11,6 +12,7 @@ use rustc_middle::hir::nested_filter;
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty;
 use rustc_session::declare_lint_pass;
+use rustc_span::ExpnKind;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -87,7 +89,12 @@ fn find_innermost_closure<'tcx>(
     cx: &LateContext<'tcx>,
     mut expr: &'tcx hir::Expr<'tcx>,
     mut steps: usize,
-) -> Option<(&'tcx hir::Expr<'tcx>, &'tcx hir::FnDecl<'tcx>, ty::Asyncness)> {
+) -> Option<(
+    &'tcx hir::Expr<'tcx>,
+    &'tcx hir::FnDecl<'tcx>,
+    ty::Asyncness,
+    &'tcx [Param<'tcx>],
+)> {
     let mut data = None;
 
     while let hir::ExprKind::Closure(closure) = expr.kind
@@ -108,6 +115,7 @@ fn find_innermost_closure<'tcx>(
             } else {
                 ty::Asyncness::No
             },
+            body.params,
         ));
         steps -= 1;
     }
@@ -150,7 +158,9 @@ impl<'tcx> LateLintPass<'tcx> for RedundantClosureCall {
             // without this check, we'd end up linting twice.
             && !matches!(recv.kind, hir::ExprKind::Call(..))
             && let (full_expr, call_depth) = get_parent_call_exprs(cx, expr)
-            && let Some((body, fn_decl, coroutine_kind)) = find_innermost_closure(cx, recv, call_depth)
+            && let Some((body, fn_decl, coroutine_kind, params)) = find_innermost_closure(cx, recv, call_depth)
+            // outside macros we lint properly. Inside macros, we lint only ||() style closures.
+            && (!matches!(expr.span.ctxt().outer_expn_data().kind, ExpnKind::Macro(_, _)) || params.is_empty())
         {
             span_lint_and_then(
                 cx,
diff --git a/tests/ui/redundant_closure_call_fixable.fixed b/tests/ui/redundant_closure_call_fixable.fixed
index f272d8359a3..ce5c7f2600b 100644
--- a/tests/ui/redundant_closure_call_fixable.fixed
+++ b/tests/ui/redundant_closure_call_fixable.fixed
@@ -102,3 +102,12 @@ mod issue11707 {
 fn avoid_double_parens() {
     std::convert::identity(13_i32 + 36_i32).leading_zeros();
 }
+
+fn fp_11274() {
+    macro_rules! m {
+        ($closure:expr) => {
+            $closure(1)
+        };
+    }
+    m!(|x| println!("{x}"));
+}
diff --git a/tests/ui/redundant_closure_call_fixable.rs b/tests/ui/redundant_closure_call_fixable.rs
index f45db8c9cff..ac09390e6ea 100644
--- a/tests/ui/redundant_closure_call_fixable.rs
+++ b/tests/ui/redundant_closure_call_fixable.rs
@@ -102,3 +102,12 @@ mod issue11707 {
 fn avoid_double_parens() {
     std::convert::identity((|| 13_i32 + 36_i32)()).leading_zeros();
 }
+
+fn fp_11274() {
+    macro_rules! m {
+        ($closure:expr) => {
+            $closure(1)
+        };
+    }
+    m!(|x| println!("{x}"));
+}
-- 
cgit 1.4.1-3-g733a5


From be5707ce1b608f607ca9327537076dc95869347b Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Sat, 13 Jan 2024 17:46:46 +0100
Subject: lint on `.map(|&x| x.clone())`

---
 clippy_lints/src/methods/useless_asref.rs | 32 ++++++++++---------------------
 tests/ui/useless_asref.fixed              |  5 +++++
 tests/ui/useless_asref.rs                 |  5 +++++
 tests/ui/useless_asref.stderr             |  8 +++++++-
 4 files changed, 27 insertions(+), 23 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/useless_asref.rs b/clippy_lints/src/methods/useless_asref.rs
index d6c79db4d70..514015af045 100644
--- a/clippy_lints/src/methods/useless_asref.rs
+++ b/clippy_lints/src/methods/useless_asref.rs
@@ -1,7 +1,9 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::walk_ptrs_ty_depth;
-use clippy_utils::{get_parent_expr, is_diag_trait_item, match_def_path, path_to_local_id, paths, peel_blocks};
+use clippy_utils::{
+    get_parent_expr, is_diag_trait_item, match_def_path, path_to_local_id, paths, peel_blocks, strip_pat_refs,
+};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
@@ -108,26 +110,12 @@ fn check_qpath(cx: &LateContext<'_>, qpath: hir::QPath<'_>, hir_id: hir::HirId)
 
 fn is_calling_clone(cx: &LateContext<'_>, arg: &hir::Expr<'_>) -> bool {
     match arg.kind {
-        hir::ExprKind::Closure(&hir::Closure { body, .. }) => {
+        hir::ExprKind::Closure(&hir::Closure { body, .. })
             // If it's a closure, we need to check what is called.
-            let closure_body = cx.tcx.hir().body(body);
-
-            // |x| ...
-            //  ^
-            let [
-                hir::Param {
-                    pat:
-                        hir::Pat {
-                            kind: hir::PatKind::Binding(_, local_id, ..),
-                            ..
-                        },
-                    ..
-                },
-            ] = closure_body.params
-            else {
-                return false;
-            };
-
+            if let closure_body = cx.tcx.hir().body(body)
+                && let [param] = closure_body.params
+                && let hir::PatKind::Binding(_, local_id, ..) = strip_pat_refs(param.pat).kind =>
+        {
             let closure_expr = peel_blocks(closure_body.value);
             match closure_expr.kind {
                 hir::ExprKind::MethodCall(method, obj, [], _) => {
@@ -139,7 +127,7 @@ fn is_calling_clone(cx: &LateContext<'_>, arg: &hir::Expr<'_>) -> bool {
                         // no autoderefs
                         && !cx.typeck_results().expr_adjustments(obj).iter()
                             .any(|a| matches!(a.kind, Adjust::Deref(Some(..))))
-                        && path_to_local_id(obj, *local_id)
+                        && path_to_local_id(obj, local_id)
                     {
                         true
                     } else {
@@ -148,7 +136,7 @@ fn is_calling_clone(cx: &LateContext<'_>, arg: &hir::Expr<'_>) -> bool {
                 },
                 hir::ExprKind::Call(call, [recv]) => {
                     if let hir::ExprKind::Path(qpath) = call.kind
-                        && path_to_local_id(recv, *local_id)
+                        && path_to_local_id(recv, local_id)
                     {
                         check_qpath(cx, qpath, call.hir_id)
                     } else {
diff --git a/tests/ui/useless_asref.fixed b/tests/ui/useless_asref.fixed
index d39d8a74b26..c98f2928e03 100644
--- a/tests/ui/useless_asref.fixed
+++ b/tests/ui/useless_asref.fixed
@@ -171,6 +171,11 @@ mod issue12135 {
         x.field.clone();
         //~^ ERROR: this call to `as_ref.map(...)` does nothing
 
+        // https://github.com/rust-lang/rust-clippy/pull/12136#discussion_r1451565223
+        #[allow(clippy::clone_on_copy)]
+        Some(1).clone();
+        //~^ ERROR: this call to `as_ref.map(...)` does nothing
+
         x.field.as_ref().map(|v| v.method().clone())
     }
 }
diff --git a/tests/ui/useless_asref.rs b/tests/ui/useless_asref.rs
index 76277e7b7a4..f9d603f116d 100644
--- a/tests/ui/useless_asref.rs
+++ b/tests/ui/useless_asref.rs
@@ -171,6 +171,11 @@ mod issue12135 {
         x.field.as_ref().map(|v| Clone::clone(v));
         //~^ ERROR: this call to `as_ref.map(...)` does nothing
 
+        // https://github.com/rust-lang/rust-clippy/pull/12136#discussion_r1451565223
+        #[allow(clippy::clone_on_copy)]
+        Some(1).as_ref().map(|&x| x.clone());
+        //~^ ERROR: this call to `as_ref.map(...)` does nothing
+
         x.field.as_ref().map(|v| v.method().clone())
     }
 }
diff --git a/tests/ui/useless_asref.stderr b/tests/ui/useless_asref.stderr
index 583b48732d4..e158df2664d 100644
--- a/tests/ui/useless_asref.stderr
+++ b/tests/ui/useless_asref.stderr
@@ -106,5 +106,11 @@ error: this call to `as_ref.map(...)` does nothing
 LL |         x.field.as_ref().map(|v| Clone::clone(v));
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `x.field.clone()`
 
-error: aborting due to 17 previous errors
+error: this call to `as_ref.map(...)` does nothing
+  --> $DIR/useless_asref.rs:176:9
+   |
+LL |         Some(1).as_ref().map(|&x| x.clone());
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Some(1).clone()`
+
+error: aborting due to 18 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 44f5d969d5820cdf907817f0ce2d81cc54589f77 Mon Sep 17 00:00:00 2001
From: blyxyas <blyxyas@gmail.com>
Date: Sun, 14 Jan 2024 01:14:05 +0100
Subject: Change `PublicallyExported` -> `PubliclyExported`

---
 book/src/lint_configuration.md                           | 4 ++--
 clippy_config/src/conf.rs                                | 2 +-
 clippy_config/src/types.rs                               | 2 +-
 clippy_lints/src/pub_underscore_fields.rs                | 2 +-
 tests/ui-toml/pub_underscore_fields/exported/clippy.toml | 2 +-
 5 files changed, 6 insertions(+), 6 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/book/src/lint_configuration.md b/book/src/lint_configuration.md
index 99853f8bc2b..27680467877 100644
--- a/book/src/lint_configuration.md
+++ b/book/src/lint_configuration.md
@@ -808,10 +808,10 @@ Whether to also run the listed lints on private items.
 
 
 ## `pub-underscore-fields-behavior`
-Meow "public" fields in a struct that are prefixed with an underscore based on their
+Lint "public" fields in a struct that are prefixed with an underscore based on their
 exported visibility, or whether they are marked as "pub".
 
-**Default Value:** `"PublicallyExported"`
+**Default Value:** `"PubliclyExported"`
 
 ---
 **Affected lints:**
diff --git a/clippy_config/src/conf.rs b/clippy_config/src/conf.rs
index e68969137d0..25a3467b377 100644
--- a/clippy_config/src/conf.rs
+++ b/clippy_config/src/conf.rs
@@ -551,7 +551,7 @@ define_Conf! {
     ///
     /// Lint "public" fields in a struct that are prefixed with an underscore based on their
     /// exported visibility, or whether they are marked as "pub".
-    (pub_underscore_fields_behavior: PubUnderscoreFieldsBehaviour = PubUnderscoreFieldsBehaviour::PublicallyExported),
+    (pub_underscore_fields_behavior: PubUnderscoreFieldsBehaviour = PubUnderscoreFieldsBehaviour::PubliclyExported),
 }
 
 /// Search for the configuration file.
diff --git a/clippy_config/src/types.rs b/clippy_config/src/types.rs
index baee09629ac..435aa9244c5 100644
--- a/clippy_config/src/types.rs
+++ b/clippy_config/src/types.rs
@@ -129,6 +129,6 @@ unimplemented_serialize! {
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Deserialize, Serialize)]
 pub enum PubUnderscoreFieldsBehaviour {
-    PublicallyExported,
+    PubliclyExported,
     AllPubFields,
 }
diff --git a/clippy_lints/src/pub_underscore_fields.rs b/clippy_lints/src/pub_underscore_fields.rs
index 00465ce4381..88b5a6cfe2a 100644
--- a/clippy_lints/src/pub_underscore_fields.rs
+++ b/clippy_lints/src/pub_underscore_fields.rs
@@ -54,7 +54,7 @@ impl<'tcx> LateLintPass<'tcx> for PubUnderscoreFields {
         };
 
         let is_visible = |field: &FieldDef<'_>| match self.behavior {
-            PubUnderscoreFieldsBehaviour::PublicallyExported => cx.effective_visibilities.is_reachable(field.def_id),
+            PubUnderscoreFieldsBehaviour::PubliclyExported => cx.effective_visibilities.is_reachable(field.def_id),
             PubUnderscoreFieldsBehaviour::AllPubFields => {
                 // If there is a visibility span then the field is marked pub in some way.
                 !field.vis_span.is_empty()
diff --git a/tests/ui-toml/pub_underscore_fields/exported/clippy.toml b/tests/ui-toml/pub_underscore_fields/exported/clippy.toml
index 94a0d3554bc..2b79cbd46e4 100644
--- a/tests/ui-toml/pub_underscore_fields/exported/clippy.toml
+++ b/tests/ui-toml/pub_underscore_fields/exported/clippy.toml
@@ -1 +1 @@
-pub-underscore-fields-behavior = "PublicallyExported"
\ No newline at end of file
+pub-underscore-fields-behavior = "PubliclyExported"
\ No newline at end of file
-- 
cgit 1.4.1-3-g733a5


From d975e267b951475647c54fa3905f5ff83cb64ae7 Mon Sep 17 00:00:00 2001
From: Kristof Mattei <864376+Kristof-Mattei@users.noreply.github.com>
Date: Sat, 13 Jan 2024 17:44:27 -0700
Subject: fix: add fix for bug, fix test name

---
 clippy_lints/src/cargo/multiple_crate_versions.rs                     | 2 +-
 tests/ui-cargo/multiple_crate_versions/12145_with_dashes/Cargo.stderr | 2 +-
 tests/ui-cargo/multiple_crate_versions/12145_with_dashes/Cargo.toml   | 3 ++-
 3 files changed, 4 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/cargo/multiple_crate_versions.rs b/clippy_lints/src/cargo/multiple_crate_versions.rs
index ec681adb7ae..a28934266cb 100644
--- a/clippy_lints/src/cargo/multiple_crate_versions.rs
+++ b/clippy_lints/src/cargo/multiple_crate_versions.rs
@@ -16,7 +16,7 @@ pub(super) fn check(cx: &LateContext<'_>, metadata: &Metadata) {
 
     if let Some(resolve) = &metadata.resolve
         && let Some(local_id) = packages.iter().find_map(|p| {
-            if p.name == local_name.as_str() {
+            if p.name.replace('-', "_") == local_name.as_str() {
                 Some(&p.id)
             } else {
                 None
diff --git a/tests/ui-cargo/multiple_crate_versions/12145_with_dashes/Cargo.stderr b/tests/ui-cargo/multiple_crate_versions/12145_with_dashes/Cargo.stderr
index 24a5402f542..8f0ca764924 100644
--- a/tests/ui-cargo/multiple_crate_versions/12145_with_dashes/Cargo.stderr
+++ b/tests/ui-cargo/multiple_crate_versions/12145_with_dashes/Cargo.stderr
@@ -3,4 +3,4 @@ error: multiple versions for dependency `winapi`: 0.2.8, 0.3.9
   = note: `-D clippy::multiple-crate-versions` implied by `-D warnings`
   = help: to override `-D warnings` add `#[allow(clippy::multiple_crate_versions)]`
 
-error: could not compile `multiple-crate-versions-with-dashes` (bin "multiple-crate-versions-with-dashes") due to 1 previous error
+error: could not compile `multiple-crate-versions` (bin "multiple-crate-versions") due to 1 previous error
diff --git a/tests/ui-cargo/multiple_crate_versions/12145_with_dashes/Cargo.toml b/tests/ui-cargo/multiple_crate_versions/12145_with_dashes/Cargo.toml
index 8ce6b0d5e5d..d39ad6c909a 100644
--- a/tests/ui-cargo/multiple_crate_versions/12145_with_dashes/Cargo.toml
+++ b/tests/ui-cargo/multiple_crate_versions/12145_with_dashes/Cargo.toml
@@ -1,7 +1,8 @@
 # Should not lint for dev or build dependencies. See issue 5041.
 
 [package]
-name = "multiple-crate-versions-with-dashes"
+# purposefully separated by - instead of _
+name = "multiple-crate-versions"
 version = "0.1.0"
 publish = false
 
-- 
cgit 1.4.1-3-g733a5


From 0774489086504093fe09bdafeb4c9f3e4739b138 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Sun, 14 Jan 2024 06:12:15 +0100
Subject: find function path references early in the lint pass

---
 clippy_lints/src/needless_pass_by_ref_mut.rs | 77 +++++++++-------------------
 1 file changed, 24 insertions(+), 53 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/needless_pass_by_ref_mut.rs b/clippy_lints/src/needless_pass_by_ref_mut.rs
index 64ef709e2fa..d2eef6ae433 100644
--- a/clippy_lints/src/needless_pass_by_ref_mut.rs
+++ b/clippy_lints/src/needless_pass_by_ref_mut.rs
@@ -5,16 +5,15 @@ use clippy_utils::visitors::for_each_expr_with_closures;
 use clippy_utils::{get_parent_node, inherits_cfg, is_from_proc_macro, is_self};
 use rustc_data_structures::fx::{FxHashSet, FxIndexMap};
 use rustc_errors::Applicability;
-use rustc_hir::intravisit::{walk_qpath, FnKind, Visitor};
+use rustc_hir::intravisit::FnKind;
 use rustc_hir::{
     BlockCheckMode, Body, Closure, Expr, ExprKind, FnDecl, HirId, HirIdMap, HirIdSet, Impl, ItemKind, Mutability, Node,
-    PatKind, QPath,
+    PatKind,
 };
 use rustc_hir_typeck::expr_use_visitor as euv;
 use rustc_infer::infer::{InferCtxt, TyCtxtInferExt};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::map::associated_body;
-use rustc_middle::hir::nested_filter::OnlyBodies;
 use rustc_middle::mir::FakeReadCause;
 use rustc_middle::ty::{self, Ty, TyCtxt, UpvarId, UpvarPath};
 use rustc_session::impl_lint_pass;
@@ -234,12 +233,29 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByRefMut<'tcx> {
         }
     }
 
-    fn check_crate_post(&mut self, cx: &LateContext<'tcx>) {
-        cx.tcx.hir().visit_all_item_likes_in_crate(&mut FnNeedsMutVisitor {
-            cx,
-            used_fn_def_ids: &mut self.used_fn_def_ids,
-        });
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
+        // #11182; do not lint if mutability is required elsewhere
+        if let ExprKind::Path(..) = expr.kind
+            && let Some(parent) = get_parent_node(cx.tcx, expr.hir_id)
+            && let ty::FnDef(def_id, _) = cx.typeck_results().expr_ty(expr).kind()
+            && let Some(def_id) = def_id.as_local()
+        {
+            if let Node::Expr(e) = parent
+                && let ExprKind::Call(call, _) = e.kind
+                && call.hir_id == expr.hir_id
+            {
+                return;
+            }
 
+            // We don't need to check each argument individually as you cannot coerce a function
+            // taking `&mut` -> `&`, for some reason, so if we've gotten this far we know it's
+            // passed as a `fn`-like argument (or is unified) and should ignore every "unused"
+            // argument entirely
+            self.used_fn_def_ids.insert(def_id);
+        }
+    }
+
+    fn check_crate_post(&mut self, cx: &LateContext<'tcx>) {
         for (fn_def_id, unused) in self
             .fn_def_ids_to_maybe_unused_mut
             .iter()
@@ -501,48 +517,3 @@ impl<'tcx> euv::Delegate<'tcx> for MutablyUsedVariablesCtxt<'tcx> {
         }
     }
 }
-
-/// A final pass to check for paths referencing this function that require the argument to be
-/// `&mut`, basically if the function is ever used as a `fn`-like argument.
-struct FnNeedsMutVisitor<'a, 'tcx> {
-    cx: &'a LateContext<'tcx>,
-    used_fn_def_ids: &'a mut FxHashSet<LocalDefId>,
-}
-
-impl<'tcx> Visitor<'tcx> for FnNeedsMutVisitor<'_, 'tcx> {
-    type NestedFilter = OnlyBodies;
-
-    fn nested_visit_map(&mut self) -> Self::Map {
-        self.cx.tcx.hir()
-    }
-
-    fn visit_qpath(&mut self, qpath: &'tcx QPath<'tcx>, hir_id: HirId, _: Span) {
-        walk_qpath(self, qpath, hir_id);
-
-        let Self { cx, used_fn_def_ids } = self;
-
-        // #11182; do not lint if mutability is required elsewhere
-        if let Node::Expr(expr) = cx.tcx.hir_node(hir_id)
-            && let Some(parent) = get_parent_node(cx.tcx, expr.hir_id)
-            && let ty::FnDef(def_id, _) = cx
-                .tcx
-                .typeck(cx.tcx.hir().enclosing_body_owner(hir_id))
-                .expr_ty(expr)
-                .kind()
-            && let Some(def_id) = def_id.as_local()
-        {
-            if let Node::Expr(e) = parent
-                && let ExprKind::Call(call, _) = e.kind
-                && call.hir_id == expr.hir_id
-            {
-                return;
-            }
-
-            // We don't need to check each argument individually as you cannot coerce a function
-            // taking `&mut` -> `&`, for some reason, so if we've gotten this far we know it's
-            // passed as a `fn`-like argument (or is unified) and should ignore every "unused"
-            // argument entirely
-            used_fn_def_ids.insert(def_id);
-        }
-    }
-}
-- 
cgit 1.4.1-3-g733a5


From 1bcaf29e0b3574597341c70a25bf263c77658ba0 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Sun, 14 Jan 2024 14:13:04 +0100
Subject: Correctly suggest `std` or `core` path depending if this is a
 `no_std` crate

---
 clippy_lints/src/default_instead_of_iter_empty.rs     | 16 +++++++++++-----
 clippy_lints/src/mem_replace.rs                       | 19 ++++++++++++++-----
 .../methods/iter_on_single_or_empty_collections.rs    | 10 +++-------
 clippy_lints/src/methods/unnecessary_sort_by.rs       |  4 ++--
 clippy_lints/src/operators/ptr_eq.rs                  |  8 ++++----
 clippy_lints/src/transmute/transmute_int_to_char.rs   |  7 +++++--
 clippy_lints/src/transmute/transmute_ref_to_ref.rs    |  8 +++++---
 7 files changed, 44 insertions(+), 28 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/default_instead_of_iter_empty.rs b/clippy_lints/src/default_instead_of_iter_empty.rs
index 2472e2ee76f..7287b3fcec9 100644
--- a/clippy_lints/src/default_instead_of_iter_empty.rs
+++ b/clippy_lints/src/default_instead_of_iter_empty.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::last_path_segment;
 use clippy_utils::source::snippet_with_context;
+use clippy_utils::{is_no_std_crate, last_path_segment};
 use rustc_errors::Applicability;
 use rustc_hir::{def, Expr, ExprKind, GenericArg, QPath, TyKind};
 use rustc_lint::{LateContext, LateLintPass};
@@ -42,12 +42,17 @@ impl<'tcx> LateLintPass<'tcx> for DefaultIterEmpty {
             && ty.span.ctxt() == ctxt
         {
             let mut applicability = Applicability::MachineApplicable;
-            let sugg = make_sugg(cx, ty_path, ctxt, &mut applicability);
+            let path = if is_no_std_crate(cx) {
+                "core::iter::empty"
+            } else {
+                "std::iter::empty"
+            };
+            let sugg = make_sugg(cx, ty_path, ctxt, &mut applicability, path);
             span_lint_and_sugg(
                 cx,
                 DEFAULT_INSTEAD_OF_ITER_EMPTY,
                 expr.span,
-                "`std::iter::empty()` is the more idiomatic way",
+                &format!("`{path}()` is the more idiomatic way"),
                 "try",
                 sugg,
                 applicability,
@@ -61,6 +66,7 @@ fn make_sugg(
     ty_path: &rustc_hir::QPath<'_>,
     ctxt: SyntaxContext,
     applicability: &mut Applicability,
+    path: &str,
 ) -> String {
     if let Some(last) = last_path_segment(ty_path).args
         && let Some(iter_ty) = last.args.iter().find_map(|arg| match arg {
@@ -69,10 +75,10 @@ fn make_sugg(
         })
     {
         format!(
-            "std::iter::empty::<{}>()",
+            "{path}::<{}>()",
             snippet_with_context(cx, iter_ty.span, ctxt, "..", applicability).0
         )
     } else {
-        "std::iter::empty()".to_owned()
+        format!("{path}()")
     }
 }
diff --git a/clippy_lints/src/mem_replace.rs b/clippy_lints/src/mem_replace.rs
index c22f76484d0..919a959073a 100644
--- a/clippy_lints/src/mem_replace.rs
+++ b/clippy_lints/src/mem_replace.rs
@@ -3,7 +3,7 @@ use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg, span_lin
 use clippy_utils::source::{snippet, snippet_with_applicability};
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::is_non_aggregate_primitive_type;
-use clippy_utils::{is_default_equivalent, is_res_lang_ctor, path_res, peel_ref_operators};
+use clippy_utils::{is_default_equivalent, is_no_std_crate, is_res_lang_ctor, path_res, peel_ref_operators};
 use rustc_errors::Applicability;
 use rustc_hir::LangItem::OptionNone;
 use rustc_hir::{Expr, ExprKind};
@@ -123,6 +123,10 @@ fn check_replace_option_with_none(cx: &LateContext<'_>, dest: &Expr<'_>, expr_sp
     );
 }
 
+fn get_top_crate(cx: &LateContext<'_>) -> &'static str {
+    if is_no_std_crate(cx) { "core" } else { "std" }
+}
+
 fn check_replace_with_uninit(cx: &LateContext<'_>, src: &Expr<'_>, dest: &Expr<'_>, expr_span: Span) {
     if let Some(method_def_id) = cx.typeck_results().type_dependent_def_id(src.hir_id)
         // check if replacement is mem::MaybeUninit::uninit().assume_init()
@@ -136,7 +140,8 @@ fn check_replace_with_uninit(cx: &LateContext<'_>, src: &Expr<'_>, dest: &Expr<'
             "replacing with `mem::MaybeUninit::uninit().assume_init()`",
             "consider using",
             format!(
-                "std::ptr::read({})",
+                "{}::ptr::read({})",
+                get_top_crate(cx),
                 snippet_with_applicability(cx, dest.span, "", &mut applicability)
             ),
             applicability,
@@ -157,7 +162,8 @@ fn check_replace_with_uninit(cx: &LateContext<'_>, src: &Expr<'_>, dest: &Expr<'
                 "replacing with `mem::uninitialized()`",
                 "consider using",
                 format!(
-                    "std::ptr::read({})",
+                    "{}::ptr::read({})",
+                    get_top_crate(cx),
                     snippet_with_applicability(cx, dest.span, "", &mut applicability)
                 ),
                 applicability,
@@ -184,14 +190,17 @@ fn check_replace_with_default(cx: &LateContext<'_>, src: &Expr<'_>, dest: &Expr<
         return;
     }
     if is_default_equivalent(cx, src) && !in_external_macro(cx.tcx.sess, expr_span) {
+        let top_crate = get_top_crate(cx);
         span_lint_and_then(
             cx,
             MEM_REPLACE_WITH_DEFAULT,
             expr_span,
-            "replacing a value of type `T` with `T::default()` is better expressed using `std::mem::take`",
+            &format!(
+                "replacing a value of type `T` with `T::default()` is better expressed using `{top_crate}::mem::take`"
+            ),
             |diag| {
                 if !expr_span.from_expansion() {
-                    let suggestion = format!("std::mem::take({})", snippet(cx, dest.span, ""));
+                    let suggestion = format!("{top_crate}::mem::take({})", snippet(cx, dest.span, ""));
 
                     diag.span_suggestion(
                         expr_span,
diff --git a/clippy_lints/src/methods/iter_on_single_or_empty_collections.rs b/clippy_lints/src/methods/iter_on_single_or_empty_collections.rs
index 70abe4891d9..e1ed272231a 100644
--- a/clippy_lints/src/methods/iter_on_single_or_empty_collections.rs
+++ b/clippy_lints/src/methods/iter_on_single_or_empty_collections.rs
@@ -58,10 +58,10 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, method_name: &str, re
         return;
     }
 
+    let top_crate = if is_no_std_crate(cx) { "core" } else { "std" };
     if let Some(i) = item {
         let sugg = format!(
-            "{}::iter::once({}{})",
-            if is_no_std_crate(cx) { "core" } else { "std" },
+            "{top_crate}::iter::once({}{})",
             iter_type.ref_prefix(),
             snippet(cx, i.span, "...")
         );
@@ -81,11 +81,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, method_name: &str, re
             expr.span,
             &format!("`{method_name}` call on an empty collection"),
             "try",
-            if is_no_std_crate(cx) {
-                "core::iter::empty()".to_string()
-            } else {
-                "std::iter::empty()".to_string()
-            },
+            format!("{top_crate}::iter::empty()"),
             Applicability::MaybeIncorrect,
         );
     }
diff --git a/clippy_lints/src/methods/unnecessary_sort_by.rs b/clippy_lints/src/methods/unnecessary_sort_by.rs
index 4949ccd770e..a92fe9e55a4 100644
--- a/clippy_lints/src/methods/unnecessary_sort_by.rs
+++ b/clippy_lints/src/methods/unnecessary_sort_by.rs
@@ -204,7 +204,7 @@ pub(super) fn check<'tcx>(
             cx,
             UNNECESSARY_SORT_BY,
             expr.span,
-            "use Vec::sort_by_key here instead",
+            "consider using `sort_by_key`",
             "try",
             format!(
                 "{}.sort{}_by_key(|{}| {})",
@@ -227,7 +227,7 @@ pub(super) fn check<'tcx>(
             cx,
             UNNECESSARY_SORT_BY,
             expr.span,
-            "use Vec::sort here instead",
+            "consider using `sort`",
             "try",
             format!(
                 "{}.sort{}()",
diff --git a/clippy_lints/src/operators/ptr_eq.rs b/clippy_lints/src/operators/ptr_eq.rs
index 9db2e24630a..31b51193fb1 100644
--- a/clippy_lints/src/operators/ptr_eq.rs
+++ b/clippy_lints/src/operators/ptr_eq.rs
@@ -1,4 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::is_no_std_crate;
 use clippy_utils::source::snippet_opt;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind};
@@ -6,8 +7,6 @@ use rustc_lint::LateContext;
 
 use super::PTR_EQ;
 
-static LINT_MSG: &str = "use `std::ptr::eq` when comparing raw pointers";
-
 pub(super) fn check<'tcx>(
     cx: &LateContext<'tcx>,
     expr: &'tcx Expr<'_>,
@@ -26,13 +25,14 @@ pub(super) fn check<'tcx>(
             && let Some(left_snip) = snippet_opt(cx, left_var.span)
             && let Some(right_snip) = snippet_opt(cx, right_var.span)
         {
+            let top_crate = if is_no_std_crate(cx) { "core" } else { "std" };
             span_lint_and_sugg(
                 cx,
                 PTR_EQ,
                 expr.span,
-                LINT_MSG,
+                &format!("use `{top_crate}::ptr::eq` when comparing raw pointers"),
                 "try",
-                format!("std::ptr::eq({left_snip}, {right_snip})"),
+                format!("{top_crate}::ptr::eq({left_snip}, {right_snip})"),
                 Applicability::MachineApplicable,
             );
         }
diff --git a/clippy_lints/src/transmute/transmute_int_to_char.rs b/clippy_lints/src/transmute/transmute_int_to_char.rs
index 7d31c375f8c..71e8a26a566 100644
--- a/clippy_lints/src/transmute/transmute_int_to_char.rs
+++ b/clippy_lints/src/transmute/transmute_int_to_char.rs
@@ -1,6 +1,6 @@
 use super::TRANSMUTE_INT_TO_CHAR;
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::sugg;
+use clippy_utils::{is_no_std_crate, sugg};
 use rustc_ast as ast;
 use rustc_errors::Applicability;
 use rustc_hir::Expr;
@@ -34,7 +34,10 @@ pub(super) fn check<'tcx>(
                     diag.span_suggestion(
                         e.span,
                         "consider using",
-                        format!("std::char::from_u32({arg}).unwrap()"),
+                        format!(
+                            "{}::char::from_u32({arg}).unwrap()",
+                            if is_no_std_crate(cx) { "core" } else { "std" }
+                        ),
                         Applicability::Unspecified,
                     );
                 },
diff --git a/clippy_lints/src/transmute/transmute_ref_to_ref.rs b/clippy_lints/src/transmute/transmute_ref_to_ref.rs
index 98e9ea2d775..c923b4b6dd4 100644
--- a/clippy_lints/src/transmute/transmute_ref_to_ref.rs
+++ b/clippy_lints/src/transmute/transmute_ref_to_ref.rs
@@ -1,7 +1,7 @@
 use super::{TRANSMUTE_BYTES_TO_STR, TRANSMUTE_PTR_TO_PTR};
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::snippet;
-use clippy_utils::sugg;
+use clippy_utils::{is_no_std_crate, sugg};
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, Mutability};
 use rustc_lint::LateContext;
@@ -29,6 +29,8 @@ pub(super) fn check<'tcx>(
 
             let snippet = snippet(cx, arg.span, "..");
 
+            let top_crate = if is_no_std_crate(cx) { "core" } else { "std" };
+
             span_lint_and_sugg(
                 cx,
                 TRANSMUTE_BYTES_TO_STR,
@@ -36,9 +38,9 @@ pub(super) fn check<'tcx>(
                 &format!("transmute from a `{from_ty}` to a `{to_ty}`"),
                 "consider using",
                 if const_context {
-                    format!("std::str::from_utf8_unchecked{postfix}({snippet})")
+                    format!("{top_crate}::str::from_utf8_unchecked{postfix}({snippet})")
                 } else {
-                    format!("std::str::from_utf8{postfix}({snippet}).unwrap()")
+                    format!("{top_crate}::str::from_utf8{postfix}({snippet}).unwrap()")
                 },
                 Applicability::MaybeIncorrect,
             );
-- 
cgit 1.4.1-3-g733a5


From 5d06fbb46d2434c50d3c50695e4a0f0bb187fdb5 Mon Sep 17 00:00:00 2001
From: Kristof Mattei <864376+Kristof-Mattei@users.noreply.github.com>
Date: Sun, 14 Jan 2024 09:25:31 -0700
Subject: fix: don't allocate new string when not needed

---
 clippy_lints/src/cargo/multiple_crate_versions.rs | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/cargo/multiple_crate_versions.rs b/clippy_lints/src/cargo/multiple_crate_versions.rs
index a28934266cb..8e86c0017e1 100644
--- a/clippy_lints/src/cargo/multiple_crate_versions.rs
+++ b/clippy_lints/src/cargo/multiple_crate_versions.rs
@@ -16,7 +16,12 @@ pub(super) fn check(cx: &LateContext<'_>, metadata: &Metadata) {
 
     if let Some(resolve) = &metadata.resolve
         && let Some(local_id) = packages.iter().find_map(|p| {
-            if p.name.replace('-', "_") == local_name.as_str() {
+            if p.name
+                .chars()
+                .into_iter()
+                .map(|c| if c == '-' { '_' } else { c })
+                .eq(local_name.as_str().chars())
+            {
                 Some(&p.id)
             } else {
                 None
-- 
cgit 1.4.1-3-g733a5


From b1c52d502d6c0441c944225287281c70282c1c9b Mon Sep 17 00:00:00 2001
From: Kristof Mattei <864376+Kristof-Mattei@users.noreply.github.com>
Date: Sun, 14 Jan 2024 09:32:36 -0700
Subject: chore: add comments to explain reasoning

---
 clippy_lints/src/cargo/multiple_crate_versions.rs | 3 +++
 1 file changed, 3 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/cargo/multiple_crate_versions.rs b/clippy_lints/src/cargo/multiple_crate_versions.rs
index 8e86c0017e1..c487ffb1c82 100644
--- a/clippy_lints/src/cargo/multiple_crate_versions.rs
+++ b/clippy_lints/src/cargo/multiple_crate_versions.rs
@@ -16,6 +16,9 @@ pub(super) fn check(cx: &LateContext<'_>, metadata: &Metadata) {
 
     if let Some(resolve) = &metadata.resolve
         && let Some(local_id) = packages.iter().find_map(|p| {
+            // p.name contains the original crate names with dashes intact
+            // local_name contains the crate name as a namespace, with the dashes converted to underscores
+            // the code below temporarily rectifies this discrepancy
             if p.name
                 .chars()
                 .into_iter()
-- 
cgit 1.4.1-3-g733a5


From ea585ef321b6ba63635984772fe576e6a4e461fc Mon Sep 17 00:00:00 2001
From: Kristof Mattei <864376+Kristof-Mattei@users.noreply.github.com>
Date: Sun, 14 Jan 2024 09:40:14 -0700
Subject: chore: remove unneeded into_iter

---
 clippy_lints/src/cargo/multiple_crate_versions.rs | 1 -
 1 file changed, 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/cargo/multiple_crate_versions.rs b/clippy_lints/src/cargo/multiple_crate_versions.rs
index c487ffb1c82..6b4af6753c3 100644
--- a/clippy_lints/src/cargo/multiple_crate_versions.rs
+++ b/clippy_lints/src/cargo/multiple_crate_versions.rs
@@ -21,7 +21,6 @@ pub(super) fn check(cx: &LateContext<'_>, metadata: &Metadata) {
             // the code below temporarily rectifies this discrepancy
             if p.name
                 .chars()
-                .into_iter()
                 .map(|c| if c == '-' { '_' } else { c })
                 .eq(local_name.as_str().chars())
             {
-- 
cgit 1.4.1-3-g733a5


From e8ec99811b80372012d3ece0e0f31f5722785eec Mon Sep 17 00:00:00 2001
From: Kristof Mattei <864376+Kristof-Mattei@users.noreply.github.com>
Date: Sun, 14 Jan 2024 14:00:13 -0700
Subject: fix: crates are limited to ASCII values

---
 clippy_lints/src/cargo/multiple_crate_versions.rs | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/cargo/multiple_crate_versions.rs b/clippy_lints/src/cargo/multiple_crate_versions.rs
index 6b4af6753c3..57b7b7497fe 100644
--- a/clippy_lints/src/cargo/multiple_crate_versions.rs
+++ b/clippy_lints/src/cargo/multiple_crate_versions.rs
@@ -20,9 +20,10 @@ pub(super) fn check(cx: &LateContext<'_>, metadata: &Metadata) {
             // local_name contains the crate name as a namespace, with the dashes converted to underscores
             // the code below temporarily rectifies this discrepancy
             if p.name
-                .chars()
-                .map(|c| if c == '-' { '_' } else { c })
-                .eq(local_name.as_str().chars())
+                .as_bytes()
+                .iter()
+                .map(|b| if b == &b'-' { &b'_' } else { b })
+                .eq(local_name.as_str().as_bytes())
             {
                 Some(&p.id)
             } else {
-- 
cgit 1.4.1-3-g733a5


From 33d8e47e98bf45fdc105d1fadb37dd03789ba1b3 Mon Sep 17 00:00:00 2001
From: Adam Reichold <adam.reichold@t-online.de>
Date: Sun, 10 Dec 2023 07:34:48 +0100
Subject: Try to improve wording and fix dead link in description of
 arc_with_non_send_sync lint.

---
 clippy_lints/src/arc_with_non_send_sync.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/arc_with_non_send_sync.rs b/clippy_lints/src/arc_with_non_send_sync.rs
index 58738d52878..1102c7fb236 100644
--- a/clippy_lints/src/arc_with_non_send_sync.rs
+++ b/clippy_lints/src/arc_with_non_send_sync.rs
@@ -14,10 +14,10 @@ declare_clippy_lint! {
     /// This lint warns when you use `Arc` with a type that does not implement `Send` or `Sync`.
     ///
     /// ### Why is this bad?
-    /// `Arc<T>` is an Atomic `Rc<T>` and guarantees that updates to the reference counter are
-    /// Atomic. This is useful in multithreading scenarios. To send an `Arc<T>` across threads
-    /// and make use of the atomic ref counter, `T` must be [both `Send` and `Sync`](https://doc.rust-lang.org/std/sync/struct.Arc.html#impl-Send-for-Arc%3CT%3E),
-    /// either `T` should be made `Send + Sync` or an `Rc` should be used instead of an `Arc`
+    /// `Arc<T>` is a thread-safe `Rc<T>` and guarantees that updates to the reference counter
+    /// use atomic operations. To send an `Arc<T>` across thread boundaries and
+    /// share ownership between multiple threads, `T` must be [both `Send` and `Sync`](https://doc.rust-lang.org/std/sync/struct.Arc.html#thread-safety),
+    /// so either `T` should be made `Send + Sync` or an `Rc` should be used instead of an `Arc`
     ///
     /// ### Example
     /// ```no_run
-- 
cgit 1.4.1-3-g733a5


From 6c201db005c546bb16ce19c81d6b68f262b0203a Mon Sep 17 00:00:00 2001
From: atwam <wam@atwam.com>
Date: Wed, 4 Oct 2023 13:56:18 +0100
Subject: Add suspicious_open_options lint.

Checks for the suspicious use of OpenOptions::create()
without an explicit OpenOptions::truncate().

create() alone will either create a new file or open an
existing file. If the file already exists, it will be
overwritten when written to, but the file will not be
truncated by default. If less data is written to the file
than it already contains, the remainder of the file will
remain unchanged, and the end of the file will contain old
data.
In most cases, one should either use `create_new` to ensure
the file is created from scratch, or ensure `truncate` is
called so that the truncation behaviour is explicit.
`truncate(true)` will ensure the file is entirely overwritten
with new data, whereas `truncate(false)` will explicitely
keep the default behavior.

```rust
use std::fs::OpenOptions;

OpenOptions::new().create(true).truncate(true);
```
---
 CHANGELOG.md                                    |   1 +
 clippy_lints/src/declared_lints.rs              |   1 +
 clippy_lints/src/methods/mod.rs                 |  32 +++++
 clippy_lints/src/methods/open_options.rs        | 156 ++++++++++--------------
 tests/ui/open_options.rs                        |   3 +
 tests/ui/open_options.stderr                    |  31 +++--
 tests/ui/seek_to_start_instead_of_rewind.fixed  |   3 +
 tests/ui/seek_to_start_instead_of_rewind.rs     |   3 +
 tests/ui/seek_to_start_instead_of_rewind.stderr |   2 +-
 9 files changed, 131 insertions(+), 101 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 4d32bbec914..db4b4c2aef6 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5606,6 +5606,7 @@ Released 2018-09-13
 [`suspicious_else_formatting`]: https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_else_formatting
 [`suspicious_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_map
 [`suspicious_op_assign_impl`]: https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_op_assign_impl
+[`suspicious_open_options`]: https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_open_options
 [`suspicious_operation_groupings`]: https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_operation_groupings
 [`suspicious_splitn`]: https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_splitn
 [`suspicious_to_owned`]: https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_to_owned
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 20230106d53..639edd8da30 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -439,6 +439,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::methods::STR_SPLIT_AT_NEWLINE_INFO,
     crate::methods::SUSPICIOUS_COMMAND_ARG_SPACE_INFO,
     crate::methods::SUSPICIOUS_MAP_INFO,
+    crate::methods::SUSPICIOUS_OPEN_OPTIONS_INFO,
     crate::methods::SUSPICIOUS_SPLITN_INFO,
     crate::methods::SUSPICIOUS_TO_OWNED_INFO,
     crate::methods::TYPE_ID_ON_BOX_INFO,
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 89ea3597dc0..84fb583595b 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -2827,6 +2827,37 @@ declare_clippy_lint! {
     "nonsensical combination of options for opening a file"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for the suspicious use of OpenOptions::create()
+    /// without an explicit OpenOptions::truncate().
+    ///
+    /// ### Why is this bad?
+    /// create() alone will either create a new file or open an
+    /// existing file. If the file already exists, it will be
+    /// overwritten when written to, but the file will not be
+    /// truncated by default. If less data is written to the file
+    /// than it already contains, the remainder of the file will
+    /// remain unchanged, and the end of the file will contain old
+    /// data.
+    /// In most cases, one should either use `create_new` to ensure
+    /// the file is created from scratch, or ensure `truncate` is
+    /// called so that the truncation behaviour is explicit. `truncate(true)`
+    /// will ensure the file is entirely overwritten with new data, whereas
+    /// `truncate(false)` will explicitely keep the default behavior.
+    ///
+    /// ### Example
+    /// ```rust
+    /// use std::fs::OpenOptions;
+    ///
+    /// OpenOptions::new().create(true).truncate(true);
+    /// ```
+    #[clippy::version = "1.73.0"]
+    pub SUSPICIOUS_OPEN_OPTIONS,
+    suspicious,
+    "suspicious combination of options for opening a file"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     ///* Checks for [push](https://doc.rust-lang.org/std/path/struct.PathBuf.html#method.push)
@@ -4033,6 +4064,7 @@ impl_lint_pass!(Methods => [
     MAP_ERR_IGNORE,
     MUT_MUTEX_LOCK,
     NONSENSICAL_OPEN_OPTIONS,
+    SUSPICIOUS_OPEN_OPTIONS,
     PATH_BUF_PUSH_OVERWRITE,
     RANGE_ZIP_WITH_LEN,
     REPEAT_ONCE,
diff --git a/clippy_lints/src/methods/open_options.rs b/clippy_lints/src/methods/open_options.rs
index 65c986dcacc..81508a5cf65 100644
--- a/clippy_lints/src/methods/open_options.rs
+++ b/clippy_lints/src/methods/open_options.rs
@@ -1,3 +1,5 @@
+use rustc_data_structures::fx::FxHashMap;
+
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_ast::ast::LitKind;
@@ -6,7 +8,7 @@ use rustc_lint::LateContext;
 use rustc_span::source_map::Spanned;
 use rustc_span::{sym, Span};
 
-use super::NONSENSICAL_OPEN_OPTIONS;
+use super::{NONSENSICAL_OPEN_OPTIONS, SUSPICIOUS_OPEN_OPTIONS};
 
 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>, recv: &'tcx Expr<'_>) {
     if let Some(method_id) = cx.typeck_results().type_dependent_def_id(e.hir_id)
@@ -19,20 +21,32 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>, recv: &'tcx
     }
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+#[derive(Eq, PartialEq, Clone)]
 enum Argument {
-    True,
-    False,
+    Set(bool),
     Unknown,
 }
 
-#[derive(Debug)]
+#[derive(Debug, Eq, PartialEq, Hash, Clone)]
 enum OpenOption {
-    Write,
+    Append,
+    Create,
+    CreateNew,
     Read,
     Truncate,
-    Create,
-    Append,
+    Write,
+}
+impl std::fmt::Display for OpenOption {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            OpenOption::Append => write!(f, "append"),
+            OpenOption::Create => write!(f, "create"),
+            OpenOption::CreateNew => write!(f, "create_new"),
+            OpenOption::Read => write!(f, "read"),
+            OpenOption::Truncate => write!(f, "truncate"),
+            OpenOption::Write => write!(f, "write"),
+        }
+    }
 }
 
 fn get_open_options(cx: &LateContext<'_>, argument: &Expr<'_>, options: &mut Vec<(OpenOption, Argument)>) {
@@ -48,7 +62,7 @@ fn get_open_options(cx: &LateContext<'_>, argument: &Expr<'_>, options: &mut Vec
                         ..
                     } = span
                     {
-                        if *lit { Argument::True } else { Argument::False }
+                        Argument::Set(*lit)
                     } else {
                         // The function is called with a literal which is not a boolean literal.
                         // This is theoretically possible, but not very likely.
@@ -62,6 +76,9 @@ fn get_open_options(cx: &LateContext<'_>, argument: &Expr<'_>, options: &mut Vec
                 "create" => {
                     options.push((OpenOption::Create, argument_option));
                 },
+                "create_new" => {
+                    options.push((OpenOption::CreateNew, argument_option));
+                },
                 "append" => {
                     options.push((OpenOption::Append, argument_option));
                 },
@@ -82,97 +99,52 @@ fn get_open_options(cx: &LateContext<'_>, argument: &Expr<'_>, options: &mut Vec
     }
 }
 
-fn check_open_options(cx: &LateContext<'_>, options: &[(OpenOption, Argument)], span: Span) {
-    let (mut create, mut append, mut truncate, mut read, mut write) = (false, false, false, false, false);
-    let (mut create_arg, mut append_arg, mut truncate_arg, mut read_arg, mut write_arg) =
-        (false, false, false, false, false);
-    // This code is almost duplicated (oh, the irony), but I haven't found a way to
-    // unify it.
+fn check_open_options(cx: &LateContext<'_>, settings: &[(OpenOption, Argument)], span: Span) {
+    // The args passed to these methods, if they have been called
+    let mut options = FxHashMap::default();
+    for (option, arg) in settings {
+        if options.insert(option.clone(), arg.clone()).is_some() {
+            span_lint(
+                cx,
+                NONSENSICAL_OPEN_OPTIONS,
+                span,
+                &format!("the method `{}` is called more than once", &option),
+            );
+        }
+    }
 
-    for option in options {
-        match *option {
-            (OpenOption::Create, arg) => {
-                if create {
-                    span_lint(
-                        cx,
-                        NONSENSICAL_OPEN_OPTIONS,
-                        span,
-                        "the method `create` is called more than once",
-                    );
-                } else {
-                    create = true;
-                }
-                create_arg = create_arg || (arg == Argument::True);
-            },
-            (OpenOption::Append, arg) => {
-                if append {
-                    span_lint(
-                        cx,
-                        NONSENSICAL_OPEN_OPTIONS,
-                        span,
-                        "the method `append` is called more than once",
-                    );
-                } else {
-                    append = true;
-                }
-                append_arg = append_arg || (arg == Argument::True);
-            },
-            (OpenOption::Truncate, arg) => {
-                if truncate {
-                    span_lint(
-                        cx,
-                        NONSENSICAL_OPEN_OPTIONS,
-                        span,
-                        "the method `truncate` is called more than once",
-                    );
-                } else {
-                    truncate = true;
-                }
-                truncate_arg = truncate_arg || (arg == Argument::True);
-            },
-            (OpenOption::Read, arg) => {
-                if read {
-                    span_lint(
-                        cx,
-                        NONSENSICAL_OPEN_OPTIONS,
-                        span,
-                        "the method `read` is called more than once",
-                    );
-                } else {
-                    read = true;
-                }
-                read_arg = read_arg || (arg == Argument::True);
-            },
-            (OpenOption::Write, arg) => {
-                if write {
-                    span_lint(
-                        cx,
-                        NONSENSICAL_OPEN_OPTIONS,
-                        span,
-                        "the method `write` is called more than once",
-                    );
-                } else {
-                    write = true;
-                }
-                write_arg = write_arg || (arg == Argument::True);
-            },
+    if let (Some(Argument::Set(true)), Some(Argument::Set(true))) =
+        (options.get(&OpenOption::Read), options.get(&OpenOption::Truncate))
+    {
+        if options.get(&OpenOption::Write).unwrap_or(&Argument::Set(false)) == &Argument::Set(false) {
+            span_lint(
+                cx,
+                NONSENSICAL_OPEN_OPTIONS,
+                span,
+                "file opened with `truncate` and `read`",
+            );
         }
     }
 
-    if read && truncate && read_arg && truncate_arg && !(write && write_arg) {
-        span_lint(
-            cx,
-            NONSENSICAL_OPEN_OPTIONS,
-            span,
-            "file opened with `truncate` and `read`",
-        );
+    if let (Some(Argument::Set(true)), Some(Argument::Set(true))) =
+        (options.get(&OpenOption::Append), options.get(&OpenOption::Truncate))
+    {
+        if options.get(&OpenOption::Write).unwrap_or(&Argument::Set(false)) == &Argument::Set(false) {
+            span_lint(
+                cx,
+                NONSENSICAL_OPEN_OPTIONS,
+                span,
+                "file opened with `append` and `truncate`",
+            );
+        }
     }
-    if append && truncate && append_arg && truncate_arg {
+
+    if let (Some(Argument::Set(true)), None) = (options.get(&OpenOption::Create), options.get(&OpenOption::Truncate)) {
         span_lint(
             cx,
-            NONSENSICAL_OPEN_OPTIONS,
+            SUSPICIOUS_OPEN_OPTIONS,
             span,
-            "file opened with `append` and `truncate`",
+            "file opened with `create`, but `truncate` behavior not defined",
         );
     }
 }
diff --git a/tests/ui/open_options.rs b/tests/ui/open_options.rs
index 0cdc5bf2bb5..dd380f4101a 100644
--- a/tests/ui/open_options.rs
+++ b/tests/ui/open_options.rs
@@ -2,6 +2,7 @@ use std::fs::OpenOptions;
 
 #[allow(unused_must_use)]
 #[warn(clippy::nonsensical_open_options)]
+#[warn(clippy::suspicious_open_options)]
 fn main() {
     OpenOptions::new().read(true).truncate(true).open("foo.txt");
     //~^ ERROR: file opened with `truncate` and `read`
@@ -19,4 +20,6 @@ fn main() {
     //~^ ERROR: the method `append` is called more than once
     OpenOptions::new().truncate(true).truncate(false).open("foo.txt");
     //~^ ERROR: the method `truncate` is called more than once
+    OpenOptions::new().create(true).open("foo.txt");
+    //~^ ERROR: file opened with `create`, but `truncate` behavior not defined
 }
diff --git a/tests/ui/open_options.stderr b/tests/ui/open_options.stderr
index 7ac826f52fa..be6be250f22 100644
--- a/tests/ui/open_options.stderr
+++ b/tests/ui/open_options.stderr
@@ -1,5 +1,5 @@
 error: file opened with `truncate` and `read`
-  --> $DIR/open_options.rs:6:5
+  --> $DIR/open_options.rs:7:5
    |
 LL |     OpenOptions::new().read(true).truncate(true).open("foo.txt");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -8,40 +8,55 @@ LL |     OpenOptions::new().read(true).truncate(true).open("foo.txt");
    = help: to override `-D warnings` add `#[allow(clippy::nonsensical_open_options)]`
 
 error: file opened with `append` and `truncate`
-  --> $DIR/open_options.rs:9:5
+  --> $DIR/open_options.rs:10:5
    |
 LL |     OpenOptions::new().append(true).truncate(true).open("foo.txt");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: the method `read` is called more than once
-  --> $DIR/open_options.rs:12:5
+  --> $DIR/open_options.rs:13:5
    |
 LL |     OpenOptions::new().read(true).read(false).open("foo.txt");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: the method `create` is called more than once
-  --> $DIR/open_options.rs:14:5
+  --> $DIR/open_options.rs:15:5
    |
 LL |     OpenOptions::new().create(true).create(false).open("foo.txt");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
+error: file opened with `create`, but `truncate` behavior not defined
+  --> $DIR/open_options.rs:15:5
+   |
+LL |     OpenOptions::new().create(true).create(false).open("foo.txt");
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::suspicious-open-options` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::suspicious_open_options)]`
+
 error: the method `write` is called more than once
-  --> $DIR/open_options.rs:16:5
+  --> $DIR/open_options.rs:17:5
    |
 LL |     OpenOptions::new().write(true).write(false).open("foo.txt");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: the method `append` is called more than once
-  --> $DIR/open_options.rs:18:5
+  --> $DIR/open_options.rs:19:5
    |
 LL |     OpenOptions::new().append(true).append(false).open("foo.txt");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: the method `truncate` is called more than once
-  --> $DIR/open_options.rs:20:5
+  --> $DIR/open_options.rs:21:5
    |
 LL |     OpenOptions::new().truncate(true).truncate(false).open("foo.txt");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 7 previous errors
+error: file opened with `create`, but `truncate` behavior not defined
+  --> $DIR/open_options.rs:23:5
+   |
+LL |     OpenOptions::new().create(true).open("foo.txt");
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 9 previous errors
 
diff --git a/tests/ui/seek_to_start_instead_of_rewind.fixed b/tests/ui/seek_to_start_instead_of_rewind.fixed
index 15cc8d54faa..8859a68320f 100644
--- a/tests/ui/seek_to_start_instead_of_rewind.fixed
+++ b/tests/ui/seek_to_start_instead_of_rewind.fixed
@@ -80,6 +80,7 @@ fn main() {
         .write(true)
         .read(true)
         .create(true)
+        .truncate(true)
         .open("foo.txt")
         .unwrap();
 
@@ -104,6 +105,7 @@ fn msrv_1_54() {
         .write(true)
         .read(true)
         .create(true)
+        .truncate(true)
         .open("foo.txt")
         .unwrap();
 
@@ -124,6 +126,7 @@ fn msrv_1_55() {
         .write(true)
         .read(true)
         .create(true)
+        .truncate(true)
         .open("foo.txt")
         .unwrap();
 
diff --git a/tests/ui/seek_to_start_instead_of_rewind.rs b/tests/ui/seek_to_start_instead_of_rewind.rs
index 197225ffbd5..7b72efb34ff 100644
--- a/tests/ui/seek_to_start_instead_of_rewind.rs
+++ b/tests/ui/seek_to_start_instead_of_rewind.rs
@@ -80,6 +80,7 @@ fn main() {
         .write(true)
         .read(true)
         .create(true)
+        .truncate(true)
         .open("foo.txt")
         .unwrap();
 
@@ -104,6 +105,7 @@ fn msrv_1_54() {
         .write(true)
         .read(true)
         .create(true)
+        .truncate(true)
         .open("foo.txt")
         .unwrap();
 
@@ -124,6 +126,7 @@ fn msrv_1_55() {
         .write(true)
         .read(true)
         .create(true)
+        .truncate(true)
         .open("foo.txt")
         .unwrap();
 
diff --git a/tests/ui/seek_to_start_instead_of_rewind.stderr b/tests/ui/seek_to_start_instead_of_rewind.stderr
index 05c11cf7f8c..b6b0d2effa8 100644
--- a/tests/ui/seek_to_start_instead_of_rewind.stderr
+++ b/tests/ui/seek_to_start_instead_of_rewind.stderr
@@ -14,7 +14,7 @@ LL |     t.seek(SeekFrom::Start(0));
    |       ^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `rewind()`
 
 error: used `seek` to go to the start of the stream
-  --> $DIR/seek_to_start_instead_of_rewind.rs:133:7
+  --> $DIR/seek_to_start_instead_of_rewind.rs:136:7
    |
 LL |     f.seek(SeekFrom::Start(0));
    |       ^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `rewind()`
-- 
cgit 1.4.1-3-g733a5


From 6fb471d646045ce7c3e81483bc1db2cbb4c9f69c Mon Sep 17 00:00:00 2001
From: atwam <wam@atwam.com>
Date: Tue, 10 Oct 2023 12:08:17 +0100
Subject: More helpful text, small style changes.

---
 clippy_lints/src/methods/mod.rs          |  8 ++--
 clippy_lints/src/methods/open_options.rs | 75 +++++++++++++++++++-------------
 clippy_utils/src/paths.rs                |  2 +
 tests/ui/open_options.rs                 |  1 -
 tests/ui/open_options.stderr             | 35 ++++++++-------
 5 files changed, 71 insertions(+), 50 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 84fb583595b..3d6a16f9ac6 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -2829,8 +2829,8 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for the suspicious use of OpenOptions::create()
-    /// without an explicit OpenOptions::truncate().
+    /// Checks for the suspicious use of `OpenOptions::create()`
+    /// without an explicit `OpenOptions::truncate()`.
     ///
     /// ### Why is this bad?
     /// create() alone will either create a new file or open an
@@ -2850,9 +2850,11 @@ declare_clippy_lint! {
     /// ```rust
     /// use std::fs::OpenOptions;
     ///
+    /// OpenOptions::new().create(true);
+    ///
     /// OpenOptions::new().create(true).truncate(true);
     /// ```
-    #[clippy::version = "1.73.0"]
+    #[clippy::version = "1.75.0"]
     pub SUSPICIOUS_OPEN_OPTIONS,
     suspicious,
     "suspicious combination of options for opening a file"
diff --git a/clippy_lints/src/methods/open_options.rs b/clippy_lints/src/methods/open_options.rs
index 81508a5cf65..c54a7506836 100644
--- a/clippy_lints/src/methods/open_options.rs
+++ b/clippy_lints/src/methods/open_options.rs
@@ -1,6 +1,6 @@
 use rustc_data_structures::fx::FxHashMap;
 
-use clippy_utils::diagnostics::span_lint;
+use clippy_utils::diagnostics::{span_lint, span_lint_and_then};
 use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_ast::ast::LitKind;
 use rustc_hir::{Expr, ExprKind};
@@ -13,7 +13,11 @@ use super::{NONSENSICAL_OPEN_OPTIONS, SUSPICIOUS_OPEN_OPTIONS};
 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>, recv: &'tcx Expr<'_>) {
     if let Some(method_id) = cx.typeck_results().type_dependent_def_id(e.hir_id)
         && let Some(impl_id) = cx.tcx.impl_of_method(method_id)
-        && is_type_diagnostic_item(cx, cx.tcx.type_of(impl_id).instantiate_identity(), sym::FsOpenOptions)
+        && (
+            is_type_diagnostic_item(cx, cx.tcx.type_of(impl_id).instantiate_identity(), sym::FsOpenOptions) ||
+            match_type(cx, cx.tcx.type_of(impl_id).instantiate_identity(), &paths::TOKIO_IO_OPEN_OPTIONS)
+        )
+
     {
         let mut options = Vec::new();
         get_open_options(cx, recv, &mut options);
@@ -49,12 +53,12 @@ impl std::fmt::Display for OpenOption {
     }
 }
 
-fn get_open_options(cx: &LateContext<'_>, argument: &Expr<'_>, options: &mut Vec<(OpenOption, Argument)>) {
-    if let ExprKind::MethodCall(path, receiver, arguments, _) = argument.kind {
+fn get_open_options(cx: &LateContext<'_>, argument: &Expr<'_>, options: &mut Vec<(OpenOption, Argument, Span)>) {
+    if let ExprKind::MethodCall(path, receiver, arguments, span) = argument.kind {
         let obj_ty = cx.typeck_results().expr_ty(receiver).peel_refs();
 
         // Only proceed if this is a call on some object of type std::fs::OpenOptions
-        if is_type_diagnostic_item(cx, obj_ty, sym::FsOpenOptions) && !arguments.is_empty() {
+        if !arguments.is_empty() && (is_type_diagnostic_item(cx, obj_ty, sym::FsOpenOptions)) {
             let argument_option = match arguments[0].kind {
                 ExprKind::Lit(span) => {
                     if let Spanned {
@@ -74,22 +78,22 @@ fn get_open_options(cx: &LateContext<'_>, argument: &Expr<'_>, options: &mut Vec
 
             match path.ident.as_str() {
                 "create" => {
-                    options.push((OpenOption::Create, argument_option));
+                    options.push((OpenOption::Create, argument_option, span));
                 },
                 "create_new" => {
-                    options.push((OpenOption::CreateNew, argument_option));
+                    options.push((OpenOption::CreateNew, argument_option, span));
                 },
                 "append" => {
-                    options.push((OpenOption::Append, argument_option));
+                    options.push((OpenOption::Append, argument_option, span));
                 },
                 "truncate" => {
-                    options.push((OpenOption::Truncate, argument_option));
+                    options.push((OpenOption::Truncate, argument_option, span));
                 },
                 "read" => {
-                    options.push((OpenOption::Read, argument_option));
+                    options.push((OpenOption::Read, argument_option, span));
                 },
                 "write" => {
-                    options.push((OpenOption::Write, argument_option));
+                    options.push((OpenOption::Write, argument_option, span));
                 },
                 _ => (),
             }
@@ -99,24 +103,25 @@ fn get_open_options(cx: &LateContext<'_>, argument: &Expr<'_>, options: &mut Vec
     }
 }
 
-fn check_open_options(cx: &LateContext<'_>, settings: &[(OpenOption, Argument)], span: Span) {
+fn check_open_options(cx: &LateContext<'_>, settings: &[(OpenOption, Argument, Span)], span: Span) {
     // The args passed to these methods, if they have been called
     let mut options = FxHashMap::default();
-    for (option, arg) in settings {
-        if options.insert(option.clone(), arg.clone()).is_some() {
+    for (option, arg, sp) in settings {
+        if let Some((_, prev_span)) = options.insert(option.clone(), (arg.clone(), *sp)) {
             span_lint(
                 cx,
                 NONSENSICAL_OPEN_OPTIONS,
-                span,
+                prev_span,
                 &format!("the method `{}` is called more than once", &option),
             );
         }
     }
 
-    if let (Some(Argument::Set(true)), Some(Argument::Set(true))) =
-        (options.get(&OpenOption::Read), options.get(&OpenOption::Truncate))
-    {
-        if options.get(&OpenOption::Write).unwrap_or(&Argument::Set(false)) == &Argument::Set(false) {
+    if_chain! {
+        if let Some((Argument::Set(true), _)) = options.get(&OpenOption::Read);
+        if let Some((Argument::Set(true), _)) = options.get(&OpenOption::Truncate);
+        if let None | Some((Argument::Set(false), _)) = options.get(&OpenOption::Write);
+        then {
             span_lint(
                 cx,
                 NONSENSICAL_OPEN_OPTIONS,
@@ -126,10 +131,11 @@ fn check_open_options(cx: &LateContext<'_>, settings: &[(OpenOption, Argument)],
         }
     }
 
-    if let (Some(Argument::Set(true)), Some(Argument::Set(true))) =
-        (options.get(&OpenOption::Append), options.get(&OpenOption::Truncate))
-    {
-        if options.get(&OpenOption::Write).unwrap_or(&Argument::Set(false)) == &Argument::Set(false) {
+    if_chain! {
+        if let Some((Argument::Set(true), _)) = options.get(&OpenOption::Append);
+        if let Some((Argument::Set(true), _)) = options.get(&OpenOption::Truncate);
+        if let None | Some((Argument::Set(false), _)) = options.get(&OpenOption::Write);
+        then {
             span_lint(
                 cx,
                 NONSENSICAL_OPEN_OPTIONS,
@@ -139,12 +145,21 @@ fn check_open_options(cx: &LateContext<'_>, settings: &[(OpenOption, Argument)],
         }
     }
 
-    if let (Some(Argument::Set(true)), None) = (options.get(&OpenOption::Create), options.get(&OpenOption::Truncate)) {
-        span_lint(
-            cx,
-            SUSPICIOUS_OPEN_OPTIONS,
-            span,
-            "file opened with `create`, but `truncate` behavior not defined",
-        );
+    if_chain! {
+        if let Some((Argument::Set(true), create_span)) = options.get(&OpenOption::Create);
+        if let None = options.get(&OpenOption::Truncate);
+        then {
+            span_lint_and_then(
+                cx,
+                SUSPICIOUS_OPEN_OPTIONS,
+                *create_span,
+                "file opened with `create`, but `truncate` behavior not defined",
+                |diag| {
+                    diag
+                    //.span_suggestion(create_span.shrink_to_hi(), "add", ".truncate(true)".to_string(), rustc_errors::Applicability::MaybeIncorrect)
+                    .help("if you intend to overwrite an existing file entirely, call `.truncate(true)`. if you instead know that you may want to keep some parts of the old file, call `.truncate(false)`");
+                },
+            );
+        }
     }
 }
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index 0a820a1754c..2771e49736e 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -50,6 +50,8 @@ pub const LATE_CONTEXT: [&str; 2] = ["rustc_lint", "LateContext"];
 pub const LATE_LINT_PASS: [&str; 3] = ["rustc_lint", "passes", "LateLintPass"];
 pub const LINT: [&str; 2] = ["rustc_lint_defs", "Lint"];
 pub const MSRV: [&str; 3] = ["clippy_config", "msrvs", "Msrv"];
+#[expect(clippy::invalid_paths)] // internal lints do not know about all external crates
+pub const TOKIO_IO_OPEN_OPTIONS: [&str; 3] = ["tokio", "fs", "OpenOptions"];
 pub const OS_STRING_AS_OS_STR: [&str; 5] = ["std", "ffi", "os_str", "OsString", "as_os_str"];
 pub const OS_STR_TO_OS_STRING: [&str; 5] = ["std", "ffi", "os_str", "OsStr", "to_os_string"];
 pub const PARKING_LOT_MUTEX_GUARD: [&str; 3] = ["lock_api", "mutex", "MutexGuard"];
diff --git a/tests/ui/open_options.rs b/tests/ui/open_options.rs
index dd380f4101a..3f486b76e72 100644
--- a/tests/ui/open_options.rs
+++ b/tests/ui/open_options.rs
@@ -1,5 +1,4 @@
 use std::fs::OpenOptions;
-
 #[allow(unused_must_use)]
 #[warn(clippy::nonsensical_open_options)]
 #[warn(clippy::suspicious_open_options)]
diff --git a/tests/ui/open_options.stderr b/tests/ui/open_options.stderr
index be6be250f22..ecab243069d 100644
--- a/tests/ui/open_options.stderr
+++ b/tests/ui/open_options.stderr
@@ -1,5 +1,5 @@
 error: file opened with `truncate` and `read`
-  --> $DIR/open_options.rs:7:5
+  --> $DIR/open_options.rs:6:5
    |
 LL |     OpenOptions::new().read(true).truncate(true).open("foo.txt");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -8,55 +8,58 @@ LL |     OpenOptions::new().read(true).truncate(true).open("foo.txt");
    = help: to override `-D warnings` add `#[allow(clippy::nonsensical_open_options)]`
 
 error: file opened with `append` and `truncate`
-  --> $DIR/open_options.rs:10:5
+  --> $DIR/open_options.rs:9:5
    |
 LL |     OpenOptions::new().append(true).truncate(true).open("foo.txt");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: the method `read` is called more than once
-  --> $DIR/open_options.rs:13:5
+  --> $DIR/open_options.rs:12:35
    |
 LL |     OpenOptions::new().read(true).read(false).open("foo.txt");
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                                   ^^^^^^^^^^^
 
 error: the method `create` is called more than once
-  --> $DIR/open_options.rs:15:5
+  --> $DIR/open_options.rs:14:37
    |
 LL |     OpenOptions::new().create(true).create(false).open("foo.txt");
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                                     ^^^^^^^^^^^^^
 
 error: file opened with `create`, but `truncate` behavior not defined
-  --> $DIR/open_options.rs:15:5
+  --> $DIR/open_options.rs:14:24
    |
 LL |     OpenOptions::new().create(true).create(false).open("foo.txt");
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                        ^^^^^^^^^^^^
    |
+   = help: if you intend to overwrite an existing file entirely, call `.truncate(true)`. if you instead know that you may want to keep some parts of the old file, call `.truncate(false)`
    = note: `-D clippy::suspicious-open-options` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::suspicious_open_options)]`
 
 error: the method `write` is called more than once
-  --> $DIR/open_options.rs:17:5
+  --> $DIR/open_options.rs:16:36
    |
 LL |     OpenOptions::new().write(true).write(false).open("foo.txt");
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                                    ^^^^^^^^^^^^
 
 error: the method `append` is called more than once
-  --> $DIR/open_options.rs:19:5
+  --> $DIR/open_options.rs:18:37
    |
 LL |     OpenOptions::new().append(true).append(false).open("foo.txt");
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                                     ^^^^^^^^^^^^^
 
 error: the method `truncate` is called more than once
-  --> $DIR/open_options.rs:21:5
+  --> $DIR/open_options.rs:20:39
    |
 LL |     OpenOptions::new().truncate(true).truncate(false).open("foo.txt");
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                                       ^^^^^^^^^^^^^^^
 
 error: file opened with `create`, but `truncate` behavior not defined
-  --> $DIR/open_options.rs:23:5
+  --> $DIR/open_options.rs:22:24
    |
 LL |     OpenOptions::new().create(true).open("foo.txt");
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                        ^^^^^^^^^^^^
+   |
+   = help: if you intend to overwrite an existing file entirely, call `.truncate(true)`. if you instead know that you may want to keep some parts of the old file, call `.truncate(false)`
 
 error: aborting due to 9 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 2ec8729962aae2fc3c72f388a8249e13f241bc20 Mon Sep 17 00:00:00 2001
From: atwam <wam@atwam.com>
Date: Tue, 10 Oct 2023 13:30:24 +0100
Subject: PR Fixes

---
 clippy_lints/src/methods/open_options.rs | 37 ++++++++++++--------------------
 tests/ui/open_options.stderr             | 12 +++++++++--
 2 files changed, 24 insertions(+), 25 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/open_options.rs b/clippy_lints/src/methods/open_options.rs
index c54a7506836..c006ea192ee 100644
--- a/clippy_lints/src/methods/open_options.rs
+++ b/clippy_lints/src/methods/open_options.rs
@@ -1,6 +1,7 @@
 use rustc_data_structures::fx::FxHashMap;
 
 use clippy_utils::diagnostics::{span_lint, span_lint_and_then};
+use clippy_utils::paths;
 use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_ast::ast::LitKind;
 use rustc_hir::{Expr, ExprKind};
@@ -117,11 +118,10 @@ fn check_open_options(cx: &LateContext<'_>, settings: &[(OpenOption, Argument, S
         }
     }
 
-    if_chain! {
-        if let Some((Argument::Set(true), _)) = options.get(&OpenOption::Read);
-        if let Some((Argument::Set(true), _)) = options.get(&OpenOption::Truncate);
-        if let None | Some((Argument::Set(false), _)) = options.get(&OpenOption::Write);
-        then {
+    if let Some((Argument::Set(true), _)) = options.get(&OpenOption::Read)
+        && let Some((Argument::Set(true), _)) = options.get(&OpenOption::Truncate)
+        && let None | Some((Argument::Set(false), _)) = options.get(&OpenOption::Write)
+        {
             span_lint(
                 cx,
                 NONSENSICAL_OPEN_OPTIONS,
@@ -129,37 +129,28 @@ fn check_open_options(cx: &LateContext<'_>, settings: &[(OpenOption, Argument, S
                 "file opened with `truncate` and `read`",
             );
         }
-    }
 
-    if_chain! {
-        if let Some((Argument::Set(true), _)) = options.get(&OpenOption::Append);
-        if let Some((Argument::Set(true), _)) = options.get(&OpenOption::Truncate);
-        if let None | Some((Argument::Set(false), _)) = options.get(&OpenOption::Write);
-        then {
+    if let Some((Argument::Set(true), _)) = options.get(&OpenOption::Append)
+        && let Some((Argument::Set(true), _)) = options.get(&OpenOption::Truncate)
+        {
             span_lint(
                 cx,
                 NONSENSICAL_OPEN_OPTIONS,
                 span,
                 "file opened with `append` and `truncate`",
             );
-        }
     }
 
-    if_chain! {
-        if let Some((Argument::Set(true), create_span)) = options.get(&OpenOption::Create);
-        if let None = options.get(&OpenOption::Truncate);
-        then {
-            span_lint_and_then(
+    if let Some((Argument::Set(true), create_span)) = options.get(&OpenOption::Create)
+        && let None = options.get(&OpenOption::Truncate)
+        {
+            span_lint_and_help(
                 cx,
                 SUSPICIOUS_OPEN_OPTIONS,
                 *create_span,
                 "file opened with `create`, but `truncate` behavior not defined",
-                |diag| {
-                    diag
-                    //.span_suggestion(create_span.shrink_to_hi(), "add", ".truncate(true)".to_string(), rustc_errors::Applicability::MaybeIncorrect)
-                    .help("if you intend to overwrite an existing file entirely, call `.truncate(true)`. if you instead know that you may want to keep some parts of the old file, call `.truncate(false)`");
-                },
+                Some(span),
+                "if you intend to overwrite an existing file entirely, call `.truncate(true)`. if you instead know that you may want to keep some parts of the old file, call `.truncate(false)`"
             );
-        }
     }
 }
diff --git a/tests/ui/open_options.stderr b/tests/ui/open_options.stderr
index ecab243069d..11ba7444c97 100644
--- a/tests/ui/open_options.stderr
+++ b/tests/ui/open_options.stderr
@@ -31,7 +31,11 @@ error: file opened with `create`, but `truncate` behavior not defined
 LL |     OpenOptions::new().create(true).create(false).open("foo.txt");
    |                        ^^^^^^^^^^^^
    |
-   = help: if you intend to overwrite an existing file entirely, call `.truncate(true)`. if you instead know that you may want to keep some parts of the old file, call `.truncate(false)`
+help: if you intend to overwrite an existing file entirely, call `.truncate(true)`. if you instead know that you may want to keep some parts of the old file, call `.truncate(false)`
+  --> $DIR/open_options.rs:14:5
+   |
+LL |     OpenOptions::new().create(true).create(false).open("foo.txt");
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    = note: `-D clippy::suspicious-open-options` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::suspicious_open_options)]`
 
@@ -59,7 +63,11 @@ error: file opened with `create`, but `truncate` behavior not defined
 LL |     OpenOptions::new().create(true).open("foo.txt");
    |                        ^^^^^^^^^^^^
    |
-   = help: if you intend to overwrite an existing file entirely, call `.truncate(true)`. if you instead know that you may want to keep some parts of the old file, call `.truncate(false)`
+help: if you intend to overwrite an existing file entirely, call `.truncate(true)`. if you instead know that you may want to keep some parts of the old file, call `.truncate(false)`
+  --> $DIR/open_options.rs:22:5
+   |
+LL |     OpenOptions::new().create(true).open("foo.txt");
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to 9 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 84588a8815641a445a29f5fb0ea21767e6e4bbdf Mon Sep 17 00:00:00 2001
From: atwam <wam@atwam.com>
Date: Thu, 26 Oct 2023 11:30:12 +0100
Subject: Add suggestion/fix to suspicious_open_options

Also rebase and fix conflicts
---
 clippy_lints/src/methods/open_options.rs | 66 +++++++++++++++++---------------
 tests/ui/open_options.rs                 | 19 ++++++---
 tests/ui/open_options.stderr             | 48 +++++++----------------
 tests/ui/open_options_fixable.fixed      |  7 ++++
 tests/ui/open_options_fixable.rs         |  7 ++++
 tests/ui/open_options_fixable.stderr     | 12 ++++++
 6 files changed, 89 insertions(+), 70 deletions(-)
 create mode 100644 tests/ui/open_options_fixable.fixed
 create mode 100644 tests/ui/open_options_fixable.rs
 create mode 100644 tests/ui/open_options_fixable.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/open_options.rs b/clippy_lints/src/methods/open_options.rs
index c006ea192ee..cbe504a9c63 100644
--- a/clippy_lints/src/methods/open_options.rs
+++ b/clippy_lints/src/methods/open_options.rs
@@ -2,23 +2,24 @@ use rustc_data_structures::fx::FxHashMap;
 
 use clippy_utils::diagnostics::{span_lint, span_lint_and_then};
 use clippy_utils::paths;
-use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::ty::{is_type_diagnostic_item, match_type};
 use rustc_ast::ast::LitKind;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::LateContext;
+use rustc_middle::ty::Ty;
 use rustc_span::source_map::Spanned;
 use rustc_span::{sym, Span};
 
 use super::{NONSENSICAL_OPEN_OPTIONS, SUSPICIOUS_OPEN_OPTIONS};
 
+fn is_open_options(cx: &LateContext<'_>, ty: Ty<'_>) -> bool {
+    is_type_diagnostic_item(cx, ty, sym::FsOpenOptions) || match_type(cx, ty, &paths::TOKIO_IO_OPEN_OPTIONS)
+}
+
 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>, recv: &'tcx Expr<'_>) {
     if let Some(method_id) = cx.typeck_results().type_dependent_def_id(e.hir_id)
         && let Some(impl_id) = cx.tcx.impl_of_method(method_id)
-        && (
-            is_type_diagnostic_item(cx, cx.tcx.type_of(impl_id).instantiate_identity(), sym::FsOpenOptions) ||
-            match_type(cx, cx.tcx.type_of(impl_id).instantiate_identity(), &paths::TOKIO_IO_OPEN_OPTIONS)
-        )
-
+        && is_open_options(cx, cx.tcx.type_of(impl_id).instantiate_identity())
     {
         let mut options = Vec::new();
         get_open_options(cx, recv, &mut options);
@@ -59,7 +60,7 @@ fn get_open_options(cx: &LateContext<'_>, argument: &Expr<'_>, options: &mut Vec
         let obj_ty = cx.typeck_results().expr_ty(receiver).peel_refs();
 
         // Only proceed if this is a call on some object of type std::fs::OpenOptions
-        if !arguments.is_empty() && (is_type_diagnostic_item(cx, obj_ty, sym::FsOpenOptions)) {
+        if !arguments.is_empty() && is_open_options(cx, obj_ty) {
             let argument_option = match arguments[0].kind {
                 ExprKind::Lit(span) => {
                     if let Spanned {
@@ -121,36 +122,39 @@ fn check_open_options(cx: &LateContext<'_>, settings: &[(OpenOption, Argument, S
     if let Some((Argument::Set(true), _)) = options.get(&OpenOption::Read)
         && let Some((Argument::Set(true), _)) = options.get(&OpenOption::Truncate)
         && let None | Some((Argument::Set(false), _)) = options.get(&OpenOption::Write)
-        {
-            span_lint(
-                cx,
-                NONSENSICAL_OPEN_OPTIONS,
-                span,
-                "file opened with `truncate` and `read`",
-            );
-        }
+    {
+        span_lint(
+            cx,
+            NONSENSICAL_OPEN_OPTIONS,
+            span,
+            "file opened with `truncate` and `read`",
+        );
+    }
 
     if let Some((Argument::Set(true), _)) = options.get(&OpenOption::Append)
         && let Some((Argument::Set(true), _)) = options.get(&OpenOption::Truncate)
-        {
-            span_lint(
-                cx,
-                NONSENSICAL_OPEN_OPTIONS,
-                span,
-                "file opened with `append` and `truncate`",
-            );
+    {
+        span_lint(
+            cx,
+            NONSENSICAL_OPEN_OPTIONS,
+            span,
+            "file opened with `append` and `truncate`",
+        );
     }
 
     if let Some((Argument::Set(true), create_span)) = options.get(&OpenOption::Create)
         && let None = options.get(&OpenOption::Truncate)
-        {
-            span_lint_and_help(
-                cx,
-                SUSPICIOUS_OPEN_OPTIONS,
-                *create_span,
-                "file opened with `create`, but `truncate` behavior not defined",
-                Some(span),
-                "if you intend to overwrite an existing file entirely, call `.truncate(true)`. if you instead know that you may want to keep some parts of the old file, call `.truncate(false)`"
-            );
+    {
+        span_lint_and_then(
+            cx,
+            SUSPICIOUS_OPEN_OPTIONS,
+            *create_span,
+            "file opened with `create`, but `truncate` behavior not defined",
+            |diag| {
+                diag
+                    .span_suggestion(create_span.shrink_to_hi(), "add", ".truncate(true)".to_string(), rustc_errors::Applicability::MaybeIncorrect)
+                    .help("if you intend to overwrite an existing file entirely, call `.truncate(true)`. if you instead know that you may want to keep some parts of the old file, call `.truncate(false)`");
+            },
+        );
     }
 }
diff --git a/tests/ui/open_options.rs b/tests/ui/open_options.rs
index 3f486b76e72..726ec1b3ab0 100644
--- a/tests/ui/open_options.rs
+++ b/tests/ui/open_options.rs
@@ -1,7 +1,6 @@
 use std::fs::OpenOptions;
 #[allow(unused_must_use)]
 #[warn(clippy::nonsensical_open_options)]
-#[warn(clippy::suspicious_open_options)]
 fn main() {
     OpenOptions::new().read(true).truncate(true).open("foo.txt");
     //~^ ERROR: file opened with `truncate` and `read`
@@ -11,14 +10,24 @@ fn main() {
 
     OpenOptions::new().read(true).read(false).open("foo.txt");
     //~^ ERROR: the method `read` is called more than once
-    OpenOptions::new().create(true).create(false).open("foo.txt");
-    //~^ ERROR: the method `create` is called more than once
+    OpenOptions::new()
+        .create(true)
+        .truncate(true) // Ensure we don't trigger suspicious open options by having create without truncate
+        .create(false)
+        //~^ ERROR: the method `create` is called more than once
+        .open("foo.txt");
     OpenOptions::new().write(true).write(false).open("foo.txt");
     //~^ ERROR: the method `write` is called more than once
     OpenOptions::new().append(true).append(false).open("foo.txt");
     //~^ ERROR: the method `append` is called more than once
     OpenOptions::new().truncate(true).truncate(false).open("foo.txt");
     //~^ ERROR: the method `truncate` is called more than once
-    OpenOptions::new().create(true).open("foo.txt");
-    //~^ ERROR: file opened with `create`, but `truncate` behavior not defined
+
+    std::fs::File::options().read(true).read(false).open("foo.txt");
+    //~^ ERROR: the method `read` is called more than once
+
+    let mut options = std::fs::OpenOptions::new();
+    options.read(true);
+    options.read(false);
+    //~^ ERROR: the method `read` is called more than once
 }
diff --git a/tests/ui/open_options.stderr b/tests/ui/open_options.stderr
index 11ba7444c97..3e7d5a3499d 100644
--- a/tests/ui/open_options.stderr
+++ b/tests/ui/open_options.stderr
@@ -1,5 +1,5 @@
 error: file opened with `truncate` and `read`
-  --> $DIR/open_options.rs:6:5
+  --> $DIR/open_options.rs:5:5
    |
 LL |     OpenOptions::new().read(true).truncate(true).open("foo.txt");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -8,66 +8,46 @@ LL |     OpenOptions::new().read(true).truncate(true).open("foo.txt");
    = help: to override `-D warnings` add `#[allow(clippy::nonsensical_open_options)]`
 
 error: file opened with `append` and `truncate`
-  --> $DIR/open_options.rs:9:5
+  --> $DIR/open_options.rs:8:5
    |
 LL |     OpenOptions::new().append(true).truncate(true).open("foo.txt");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: the method `read` is called more than once
-  --> $DIR/open_options.rs:12:35
+  --> $DIR/open_options.rs:11:35
    |
 LL |     OpenOptions::new().read(true).read(false).open("foo.txt");
    |                                   ^^^^^^^^^^^
 
 error: the method `create` is called more than once
-  --> $DIR/open_options.rs:14:37
+  --> $DIR/open_options.rs:16:10
    |
-LL |     OpenOptions::new().create(true).create(false).open("foo.txt");
-   |                                     ^^^^^^^^^^^^^
-
-error: file opened with `create`, but `truncate` behavior not defined
-  --> $DIR/open_options.rs:14:24
-   |
-LL |     OpenOptions::new().create(true).create(false).open("foo.txt");
-   |                        ^^^^^^^^^^^^
-   |
-help: if you intend to overwrite an existing file entirely, call `.truncate(true)`. if you instead know that you may want to keep some parts of the old file, call `.truncate(false)`
-  --> $DIR/open_options.rs:14:5
-   |
-LL |     OpenOptions::new().create(true).create(false).open("foo.txt");
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   = note: `-D clippy::suspicious-open-options` implied by `-D warnings`
-   = help: to override `-D warnings` add `#[allow(clippy::suspicious_open_options)]`
+LL |         .create(false)
+   |          ^^^^^^^^^^^^^
 
 error: the method `write` is called more than once
-  --> $DIR/open_options.rs:16:36
+  --> $DIR/open_options.rs:19:36
    |
 LL |     OpenOptions::new().write(true).write(false).open("foo.txt");
    |                                    ^^^^^^^^^^^^
 
 error: the method `append` is called more than once
-  --> $DIR/open_options.rs:18:37
+  --> $DIR/open_options.rs:21:37
    |
 LL |     OpenOptions::new().append(true).append(false).open("foo.txt");
    |                                     ^^^^^^^^^^^^^
 
 error: the method `truncate` is called more than once
-  --> $DIR/open_options.rs:20:39
+  --> $DIR/open_options.rs:23:39
    |
 LL |     OpenOptions::new().truncate(true).truncate(false).open("foo.txt");
    |                                       ^^^^^^^^^^^^^^^
 
-error: file opened with `create`, but `truncate` behavior not defined
-  --> $DIR/open_options.rs:22:24
-   |
-LL |     OpenOptions::new().create(true).open("foo.txt");
-   |                        ^^^^^^^^^^^^
-   |
-help: if you intend to overwrite an existing file entirely, call `.truncate(true)`. if you instead know that you may want to keep some parts of the old file, call `.truncate(false)`
-  --> $DIR/open_options.rs:22:5
+error: the method `read` is called more than once
+  --> $DIR/open_options.rs:26:41
    |
-LL |     OpenOptions::new().create(true).open("foo.txt");
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |     std::fs::File::options().read(true).read(false).open("foo.txt");
+   |                                         ^^^^^^^^^^^
 
-error: aborting due to 9 previous errors
+error: aborting due to 8 previous errors
 
diff --git a/tests/ui/open_options_fixable.fixed b/tests/ui/open_options_fixable.fixed
new file mode 100644
index 00000000000..90a129a9bdf
--- /dev/null
+++ b/tests/ui/open_options_fixable.fixed
@@ -0,0 +1,7 @@
+use std::fs::OpenOptions;
+#[allow(unused_must_use)]
+#[warn(clippy::suspicious_open_options)]
+fn main() {
+    OpenOptions::new().create(true).truncate(true).open("foo.txt");
+    //~^ ERROR: file opened with `create`, but `truncate` behavior not defined
+}
diff --git a/tests/ui/open_options_fixable.rs b/tests/ui/open_options_fixable.rs
new file mode 100644
index 00000000000..3a9e522ba15
--- /dev/null
+++ b/tests/ui/open_options_fixable.rs
@@ -0,0 +1,7 @@
+use std::fs::OpenOptions;
+#[allow(unused_must_use)]
+#[warn(clippy::suspicious_open_options)]
+fn main() {
+    OpenOptions::new().create(true).open("foo.txt");
+    //~^ ERROR: file opened with `create`, but `truncate` behavior not defined
+}
diff --git a/tests/ui/open_options_fixable.stderr b/tests/ui/open_options_fixable.stderr
new file mode 100644
index 00000000000..1ef49c54afc
--- /dev/null
+++ b/tests/ui/open_options_fixable.stderr
@@ -0,0 +1,12 @@
+error: file opened with `create`, but `truncate` behavior not defined
+  --> $DIR/open_options_fixable.rs:5:24
+   |
+LL |     OpenOptions::new().create(true).open("foo.txt");
+   |                        ^^^^^^^^^^^^- help: add: `.truncate(true)`
+   |
+   = help: if you intend to overwrite an existing file entirely, call `.truncate(true)`. if you instead know that you may want to keep some parts of the old file, call `.truncate(false)`
+   = note: `-D clippy::suspicious-open-options` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::suspicious_open_options)]`
+
+error: aborting due to previous error
+
-- 
cgit 1.4.1-3-g733a5


From 515fe65ba8f1006bec5e4e906aaeb345b05834bc Mon Sep 17 00:00:00 2001
From: atwam <wam@atwam.com>
Date: Thu, 11 Jan 2024 12:49:49 +0000
Subject: Fix conflicts

- New ineffective_open_options had to be fixed.
- Now not raising an issue on missing `truncate` when `append(true)`
  makes the intent clear.
- Try implementing more advanced tests for non-chained operations. Fail
---
 clippy_lints/src/methods/open_options.rs | 31 ++++++++++++++++++++++++-------
 tests/ui/ineffective_open_options.fixed  |  9 ++++++++-
 tests/ui/ineffective_open_options.rs     |  9 ++++++++-
 tests/ui/open_options.rs                 |  3 ++-
 tests/ui/open_options_fixable.stderr     |  4 ++--
 5 files changed, 44 insertions(+), 12 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/open_options.rs b/clippy_lints/src/methods/open_options.rs
index cbe504a9c63..d45ba2a7728 100644
--- a/clippy_lints/src/methods/open_options.rs
+++ b/clippy_lints/src/methods/open_options.rs
@@ -1,8 +1,8 @@
 use rustc_data_structures::fx::FxHashMap;
 
 use clippy_utils::diagnostics::{span_lint, span_lint_and_then};
-use clippy_utils::paths;
 use clippy_utils::ty::{is_type_diagnostic_item, match_type};
+use clippy_utils::{match_any_def_paths, paths};
 use rustc_ast::ast::LitKind;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::LateContext;
@@ -19,7 +19,7 @@ fn is_open_options(cx: &LateContext<'_>, ty: Ty<'_>) -> bool {
 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>, recv: &'tcx Expr<'_>) {
     if let Some(method_id) = cx.typeck_results().type_dependent_def_id(e.hir_id)
         && let Some(impl_id) = cx.tcx.impl_of_method(method_id)
-        && is_open_options(cx, cx.tcx.type_of(impl_id).instantiate_identity())
+    //&& is_open_options(cx, cx.tcx.type_of(impl_id).instantiate_identity())
     {
         let mut options = Vec::new();
         get_open_options(cx, recv, &mut options);
@@ -27,7 +27,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>, recv: &'tcx
     }
 }
 
-#[derive(Eq, PartialEq, Clone)]
+#[derive(Eq, PartialEq, Clone, Debug)]
 enum Argument {
     Set(bool),
     Unknown,
@@ -55,7 +55,11 @@ impl std::fmt::Display for OpenOption {
     }
 }
 
-fn get_open_options(cx: &LateContext<'_>, argument: &Expr<'_>, options: &mut Vec<(OpenOption, Argument, Span)>) {
+fn get_open_options(
+    cx: &LateContext<'_>,
+    argument: &Expr<'_>,
+    options: &mut Vec<(OpenOption, Argument, Span)>,
+) -> bool {
     if let ExprKind::MethodCall(path, receiver, arguments, span) = argument.kind {
         let obj_ty = cx.typeck_results().expr_ty(receiver).peel_refs();
 
@@ -72,7 +76,8 @@ fn get_open_options(cx: &LateContext<'_>, argument: &Expr<'_>, options: &mut Vec
                     } else {
                         // The function is called with a literal which is not a boolean literal.
                         // This is theoretically possible, but not very likely.
-                        return;
+                        // We'll ignore it for now
+                        return get_open_options(cx, receiver, options);
                     }
                 },
                 _ => Argument::Unknown,
@@ -100,8 +105,19 @@ fn get_open_options(cx: &LateContext<'_>, argument: &Expr<'_>, options: &mut Vec
                 _ => (),
             }
 
-            get_open_options(cx, receiver, options);
+            get_open_options(cx, receiver, options)
+        } else {
+            false
         }
+    } else if let ExprKind::Call(callee, _) = argument.kind
+        && let ExprKind::Path(path) = callee.kind
+        && let Some(did) = cx.qpath_res(&path, callee.hir_id).opt_def_id()
+    {
+        match_any_def_paths(cx, did, &[&paths::TOKIO_IO_OPEN_OPTIONS]).is_some()
+        //is_type_diagnostic_item(cx, ty, sym::FsOpenOptions) || match_type(cx, ty,
+        // &paths::TOKIO_IO_OPEN_OPTIONS)
+    } else {
+        false
     }
 }
 
@@ -144,6 +160,7 @@ fn check_open_options(cx: &LateContext<'_>, settings: &[(OpenOption, Argument, S
 
     if let Some((Argument::Set(true), create_span)) = options.get(&OpenOption::Create)
         && let None = options.get(&OpenOption::Truncate)
+        && let None | Some((Argument::Set(false), _)) = options.get(&OpenOption::Append)
     {
         span_lint_and_then(
             cx,
@@ -153,7 +170,7 @@ fn check_open_options(cx: &LateContext<'_>, settings: &[(OpenOption, Argument, S
             |diag| {
                 diag
                     .span_suggestion(create_span.shrink_to_hi(), "add", ".truncate(true)".to_string(), rustc_errors::Applicability::MaybeIncorrect)
-                    .help("if you intend to overwrite an existing file entirely, call `.truncate(true)`. if you instead know that you may want to keep some parts of the old file, call `.truncate(false)`");
+                    .help("if you intend to overwrite an existing file entirely, call `.truncate(true)`. if you instead know that you may want to keep some parts of the old file, call `.truncate(false)`. Alternatively, use `.append` to append to the file instead of overwriting it.");
             },
         );
     }
diff --git a/tests/ui/ineffective_open_options.fixed b/tests/ui/ineffective_open_options.fixed
index 3af8f3c5aaa..88489dc46bb 100644
--- a/tests/ui/ineffective_open_options.fixed
+++ b/tests/ui/ineffective_open_options.fixed
@@ -26,16 +26,23 @@ fn main() {
         .unwrap();
     let file = OpenOptions::new()
         .create(true)
+        .truncate(true)
         .write(true)
         .append(false)
         .open("dump.json")
         .unwrap();
     let file = OpenOptions::new()
         .create(true)
+        .truncate(true)
         .write(false)
         .append(false)
         .open("dump.json")
         .unwrap();
     let file = OpenOptions::new().create(true).append(true).open("dump.json").unwrap();
-    let file = OpenOptions::new().create(true).write(true).open("dump.json").unwrap();
+    let file = OpenOptions::new()
+        .create(true)
+        .truncate(true)
+        .write(true)
+        .open("dump.json")
+        .unwrap();
 }
diff --git a/tests/ui/ineffective_open_options.rs b/tests/ui/ineffective_open_options.rs
index 4eaf6293c40..db8bca3e2ac 100644
--- a/tests/ui/ineffective_open_options.rs
+++ b/tests/ui/ineffective_open_options.rs
@@ -26,16 +26,23 @@ fn main() {
         .unwrap();
     let file = OpenOptions::new()
         .create(true)
+        .truncate(true)
         .write(true)
         .append(false)
         .open("dump.json")
         .unwrap();
     let file = OpenOptions::new()
         .create(true)
+        .truncate(true)
         .write(false)
         .append(false)
         .open("dump.json")
         .unwrap();
     let file = OpenOptions::new().create(true).append(true).open("dump.json").unwrap();
-    let file = OpenOptions::new().create(true).write(true).open("dump.json").unwrap();
+    let file = OpenOptions::new()
+        .create(true)
+        .truncate(true)
+        .write(true)
+        .open("dump.json")
+        .unwrap();
 }
diff --git a/tests/ui/open_options.rs b/tests/ui/open_options.rs
index 726ec1b3ab0..873094dd724 100644
--- a/tests/ui/open_options.rs
+++ b/tests/ui/open_options.rs
@@ -29,5 +29,6 @@ fn main() {
     let mut options = std::fs::OpenOptions::new();
     options.read(true);
     options.read(false);
-    //~^ ERROR: the method `read` is called more than once
+    //#~^ ERROR: the method `read` is called more than once
+    options.open("foo.txt");
 }
diff --git a/tests/ui/open_options_fixable.stderr b/tests/ui/open_options_fixable.stderr
index 1ef49c54afc..de88af87cd4 100644
--- a/tests/ui/open_options_fixable.stderr
+++ b/tests/ui/open_options_fixable.stderr
@@ -4,9 +4,9 @@ error: file opened with `create`, but `truncate` behavior not defined
 LL |     OpenOptions::new().create(true).open("foo.txt");
    |                        ^^^^^^^^^^^^- help: add: `.truncate(true)`
    |
-   = help: if you intend to overwrite an existing file entirely, call `.truncate(true)`. if you instead know that you may want to keep some parts of the old file, call `.truncate(false)`
+   = help: if you intend to overwrite an existing file entirely, call `.truncate(true)`. if you instead know that you may want to keep some parts of the old file, call `.truncate(false)`. Alternatively, use `.append` to append to the file instead of overwriting it.
    = note: `-D clippy::suspicious-open-options` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::suspicious_open_options)]`
 
-error: aborting due to previous error
+error: aborting due to 1 previous error
 
-- 
cgit 1.4.1-3-g733a5


From f09cd88199e730e63a4ffb5df4ea13d64c834e2d Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Sun, 14 Jan 2024 00:11:42 +0100
Subject: fix false positive in `suspicious_open_options`, make paths work

---
 clippy_lints/src/methods/mod.rs          | 11 +++++--
 clippy_lints/src/methods/open_options.rs | 49 +++++++++++++++++++++++++-------
 clippy_utils/src/paths.rs                | 10 +++++--
 tests/ui/open_options.rs                 | 24 ++++++++++++++--
 tests/ui/open_options.stderr             | 16 +++++------
 tests/ui/open_options_fixable.stderr     |  4 ++-
 6 files changed, 87 insertions(+), 27 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 3d6a16f9ac6..03bcf108914 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -2833,10 +2833,11 @@ declare_clippy_lint! {
     /// without an explicit `OpenOptions::truncate()`.
     ///
     /// ### Why is this bad?
-    /// create() alone will either create a new file or open an
+    /// `create()` alone will either create a new file or open an
     /// existing file. If the file already exists, it will be
     /// overwritten when written to, but the file will not be
-    /// truncated by default. If less data is written to the file
+    /// truncated by default.
+    /// If less data is written to the file
     /// than it already contains, the remainder of the file will
     /// remain unchanged, and the end of the file will contain old
     /// data.
@@ -2847,10 +2848,14 @@ declare_clippy_lint! {
     /// `truncate(false)` will explicitely keep the default behavior.
     ///
     /// ### Example
-    /// ```rust
+    /// ```rust,no_run
     /// use std::fs::OpenOptions;
     ///
     /// OpenOptions::new().create(true);
+    /// ```
+    /// Use instead:
+    /// ```rust,no_run
+    /// use std::fs::OpenOptions;
     ///
     /// OpenOptions::new().create(true).truncate(true);
     /// ```
diff --git a/clippy_lints/src/methods/open_options.rs b/clippy_lints/src/methods/open_options.rs
index d45ba2a7728..77484ab91a9 100644
--- a/clippy_lints/src/methods/open_options.rs
+++ b/clippy_lints/src/methods/open_options.rs
@@ -19,11 +19,12 @@ fn is_open_options(cx: &LateContext<'_>, ty: Ty<'_>) -> bool {
 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>, recv: &'tcx Expr<'_>) {
     if let Some(method_id) = cx.typeck_results().type_dependent_def_id(e.hir_id)
         && let Some(impl_id) = cx.tcx.impl_of_method(method_id)
-    //&& is_open_options(cx, cx.tcx.type_of(impl_id).instantiate_identity())
+        && is_open_options(cx, cx.tcx.type_of(impl_id).instantiate_identity())
     {
         let mut options = Vec::new();
-        get_open_options(cx, recv, &mut options);
-        check_open_options(cx, &options, e.span);
+        if get_open_options(cx, recv, &mut options) {
+            check_open_options(cx, &options, e.span);
+        }
     }
 }
 
@@ -55,6 +56,9 @@ impl std::fmt::Display for OpenOption {
     }
 }
 
+/// Collects information about a method call chain on `OpenOptions`.
+/// Returns false if an unexpected expression kind was found "on the way",
+/// and linting should then be avoided.
 fn get_open_options(
     cx: &LateContext<'_>,
     argument: &Expr<'_>,
@@ -102,7 +106,16 @@ fn get_open_options(
                 "write" => {
                     options.push((OpenOption::Write, argument_option, span));
                 },
-                _ => (),
+                _ => {
+                    // Avoid linting altogether if this method is from a trait.
+                    // This might be a user defined extension trait with a method like `truncate_write`
+                    // which would be a false positive
+                    if let Some(method_def_id) = cx.typeck_results().type_dependent_def_id(argument.hir_id)
+                        && cx.tcx.trait_of_item(method_def_id).is_some()
+                    {
+                        return false;
+                    }
+                },
             }
 
             get_open_options(cx, receiver, options)
@@ -113,9 +126,17 @@ fn get_open_options(
         && let ExprKind::Path(path) = callee.kind
         && let Some(did) = cx.qpath_res(&path, callee.hir_id).opt_def_id()
     {
-        match_any_def_paths(cx, did, &[&paths::TOKIO_IO_OPEN_OPTIONS]).is_some()
-        //is_type_diagnostic_item(cx, ty, sym::FsOpenOptions) || match_type(cx, ty,
-        // &paths::TOKIO_IO_OPEN_OPTIONS)
+        match_any_def_paths(
+            cx,
+            did,
+            &[
+                &paths::TOKIO_IO_OPEN_OPTIONS_NEW,
+                &paths::OPEN_OPTIONS_NEW,
+                &paths::FILE_OPTIONS,
+                &paths::TOKIO_FILE_OPTIONS,
+            ],
+        )
+        .is_some()
     } else {
         false
     }
@@ -168,9 +189,17 @@ fn check_open_options(cx: &LateContext<'_>, settings: &[(OpenOption, Argument, S
             *create_span,
             "file opened with `create`, but `truncate` behavior not defined",
             |diag| {
-                diag
-                    .span_suggestion(create_span.shrink_to_hi(), "add", ".truncate(true)".to_string(), rustc_errors::Applicability::MaybeIncorrect)
-                    .help("if you intend to overwrite an existing file entirely, call `.truncate(true)`. if you instead know that you may want to keep some parts of the old file, call `.truncate(false)`. Alternatively, use `.append` to append to the file instead of overwriting it.");
+                diag.span_suggestion(
+                    create_span.shrink_to_hi(),
+                    "add",
+                    ".truncate(true)".to_string(),
+                    rustc_errors::Applicability::MaybeIncorrect,
+                )
+                .help("if you intend to overwrite an existing file entirely, call `.truncate(true)`")
+                .help(
+                    "if you instead know that you may want to keep some parts of the old file, call `.truncate(false)`",
+                )
+                .help("alternatively, use `.append(true)` to append to the file instead of overwriting it");
             },
         );
     }
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index 2771e49736e..0051f784514 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -26,6 +26,7 @@ pub const EARLY_CONTEXT: [&str; 2] = ["rustc_lint", "EarlyContext"];
 pub const EARLY_LINT_PASS: [&str; 3] = ["rustc_lint", "passes", "EarlyLintPass"];
 pub const F32_EPSILON: [&str; 4] = ["core", "f32", "<impl f32>", "EPSILON"];
 pub const F64_EPSILON: [&str; 4] = ["core", "f64", "<impl f64>", "EPSILON"];
+pub const FILE_OPTIONS: [&str; 4] = ["std", "fs", "File", "options"];
 #[expect(clippy::invalid_paths)] // internal lints do not know about all external crates
 pub const FUTURES_IO_ASYNCREADEXT: [&str; 3] = ["futures_util", "io", "AsyncReadExt"];
 #[expect(clippy::invalid_paths)] // internal lints do not know about all external crates
@@ -50,8 +51,7 @@ pub const LATE_CONTEXT: [&str; 2] = ["rustc_lint", "LateContext"];
 pub const LATE_LINT_PASS: [&str; 3] = ["rustc_lint", "passes", "LateLintPass"];
 pub const LINT: [&str; 2] = ["rustc_lint_defs", "Lint"];
 pub const MSRV: [&str; 3] = ["clippy_config", "msrvs", "Msrv"];
-#[expect(clippy::invalid_paths)] // internal lints do not know about all external crates
-pub const TOKIO_IO_OPEN_OPTIONS: [&str; 3] = ["tokio", "fs", "OpenOptions"];
+pub const OPEN_OPTIONS_NEW: [&str; 4] = ["std", "fs", "OpenOptions", "new"];
 pub const OS_STRING_AS_OS_STR: [&str; 5] = ["std", "ffi", "os_str", "OsString", "as_os_str"];
 pub const OS_STR_TO_OS_STRING: [&str; 5] = ["std", "ffi", "os_str", "OsStr", "to_os_string"];
 pub const PARKING_LOT_MUTEX_GUARD: [&str; 3] = ["lock_api", "mutex", "MutexGuard"];
@@ -91,9 +91,15 @@ pub const SYMBOL_TO_IDENT_STRING: [&str; 4] = ["rustc_span", "symbol", "Symbol",
 pub const SYM_MODULE: [&str; 3] = ["rustc_span", "symbol", "sym"];
 pub const SYNTAX_CONTEXT: [&str; 3] = ["rustc_span", "hygiene", "SyntaxContext"];
 #[expect(clippy::invalid_paths)] // internal lints do not know about all external crates
+pub const TOKIO_FILE_OPTIONS: [&str; 5] = ["tokio", "fs", "file", "File", "options"];
+#[expect(clippy::invalid_paths)] // internal lints do not know about all external crates
 pub const TOKIO_IO_ASYNCREADEXT: [&str; 5] = ["tokio", "io", "util", "async_read_ext", "AsyncReadExt"];
 #[expect(clippy::invalid_paths)] // internal lints do not know about all external crates
 pub const TOKIO_IO_ASYNCWRITEEXT: [&str; 5] = ["tokio", "io", "util", "async_write_ext", "AsyncWriteExt"];
+#[expect(clippy::invalid_paths)] // internal lints do not know about all external crates
+pub const TOKIO_IO_OPEN_OPTIONS: [&str; 4] = ["tokio", "fs", "open_options", "OpenOptions"];
+#[expect(clippy::invalid_paths)] // internal lints do not know about all external crates
+pub const TOKIO_IO_OPEN_OPTIONS_NEW: [&str; 5] = ["tokio", "fs", "open_options", "OpenOptions", "new"];
 pub const VEC_AS_MUT_SLICE: [&str; 4] = ["alloc", "vec", "Vec", "as_mut_slice"];
 pub const VEC_AS_SLICE: [&str; 4] = ["alloc", "vec", "Vec", "as_slice"];
 pub const VEC_DEQUE_ITER: [&str; 5] = ["alloc", "collections", "vec_deque", "VecDeque", "iter"];
diff --git a/tests/ui/open_options.rs b/tests/ui/open_options.rs
index 873094dd724..4acb3780df4 100644
--- a/tests/ui/open_options.rs
+++ b/tests/ui/open_options.rs
@@ -1,6 +1,18 @@
+#![allow(unused_must_use)]
+#![warn(clippy::nonsensical_open_options)]
+
 use std::fs::OpenOptions;
-#[allow(unused_must_use)]
-#[warn(clippy::nonsensical_open_options)]
+
+trait OpenOptionsExt {
+    fn truncate_write(&mut self, opt: bool) -> &mut Self;
+}
+
+impl OpenOptionsExt for OpenOptions {
+    fn truncate_write(&mut self, opt: bool) -> &mut Self {
+        self.truncate(opt).write(opt)
+    }
+}
+
 fn main() {
     OpenOptions::new().read(true).truncate(true).open("foo.txt");
     //~^ ERROR: file opened with `truncate` and `read`
@@ -29,6 +41,12 @@ fn main() {
     let mut options = std::fs::OpenOptions::new();
     options.read(true);
     options.read(false);
-    //#~^ ERROR: the method `read` is called more than once
+    // Possible future improvement: recognize open options method call chains across statements.
     options.open("foo.txt");
+
+    let mut options = std::fs::OpenOptions::new();
+    options.truncate(true);
+    options.create(true).open("foo.txt");
+
+    OpenOptions::new().create(true).truncate_write(true).open("foo.txt");
 }
diff --git a/tests/ui/open_options.stderr b/tests/ui/open_options.stderr
index 3e7d5a3499d..4f84d1d09f9 100644
--- a/tests/ui/open_options.stderr
+++ b/tests/ui/open_options.stderr
@@ -1,5 +1,5 @@
 error: file opened with `truncate` and `read`
-  --> $DIR/open_options.rs:5:5
+  --> $DIR/open_options.rs:17:5
    |
 LL |     OpenOptions::new().read(true).truncate(true).open("foo.txt");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -8,43 +8,43 @@ LL |     OpenOptions::new().read(true).truncate(true).open("foo.txt");
    = help: to override `-D warnings` add `#[allow(clippy::nonsensical_open_options)]`
 
 error: file opened with `append` and `truncate`
-  --> $DIR/open_options.rs:8:5
+  --> $DIR/open_options.rs:20:5
    |
 LL |     OpenOptions::new().append(true).truncate(true).open("foo.txt");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: the method `read` is called more than once
-  --> $DIR/open_options.rs:11:35
+  --> $DIR/open_options.rs:23:35
    |
 LL |     OpenOptions::new().read(true).read(false).open("foo.txt");
    |                                   ^^^^^^^^^^^
 
 error: the method `create` is called more than once
-  --> $DIR/open_options.rs:16:10
+  --> $DIR/open_options.rs:28:10
    |
 LL |         .create(false)
    |          ^^^^^^^^^^^^^
 
 error: the method `write` is called more than once
-  --> $DIR/open_options.rs:19:36
+  --> $DIR/open_options.rs:31:36
    |
 LL |     OpenOptions::new().write(true).write(false).open("foo.txt");
    |                                    ^^^^^^^^^^^^
 
 error: the method `append` is called more than once
-  --> $DIR/open_options.rs:21:37
+  --> $DIR/open_options.rs:33:37
    |
 LL |     OpenOptions::new().append(true).append(false).open("foo.txt");
    |                                     ^^^^^^^^^^^^^
 
 error: the method `truncate` is called more than once
-  --> $DIR/open_options.rs:23:39
+  --> $DIR/open_options.rs:35:39
    |
 LL |     OpenOptions::new().truncate(true).truncate(false).open("foo.txt");
    |                                       ^^^^^^^^^^^^^^^
 
 error: the method `read` is called more than once
-  --> $DIR/open_options.rs:26:41
+  --> $DIR/open_options.rs:38:41
    |
 LL |     std::fs::File::options().read(true).read(false).open("foo.txt");
    |                                         ^^^^^^^^^^^
diff --git a/tests/ui/open_options_fixable.stderr b/tests/ui/open_options_fixable.stderr
index de88af87cd4..e327661713b 100644
--- a/tests/ui/open_options_fixable.stderr
+++ b/tests/ui/open_options_fixable.stderr
@@ -4,7 +4,9 @@ error: file opened with `create`, but `truncate` behavior not defined
 LL |     OpenOptions::new().create(true).open("foo.txt");
    |                        ^^^^^^^^^^^^- help: add: `.truncate(true)`
    |
-   = help: if you intend to overwrite an existing file entirely, call `.truncate(true)`. if you instead know that you may want to keep some parts of the old file, call `.truncate(false)`. Alternatively, use `.append` to append to the file instead of overwriting it.
+   = help: if you intend to overwrite an existing file entirely, call `.truncate(true)`
+   = help: if you instead know that you may want to keep some parts of the old file, call `.truncate(false)`
+   = help: alternatively, use `.append(true)` to append to the file instead of overwriting it
    = note: `-D clippy::suspicious-open-options` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::suspicious_open_options)]`
 
-- 
cgit 1.4.1-3-g733a5


From 874f851ac5d82a5e2c68e46ddf850b8047f40415 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Mon, 15 Jan 2024 20:53:00 +0100
Subject: Use `std_or_core` instead of doing check by hand every time

---
 clippy_lints/src/default_instead_of_iter_empty.rs        | 11 ++++-------
 clippy_lints/src/mem_replace.rs                          | 16 ++++++----------
 .../src/methods/iter_on_single_or_empty_collections.rs   |  4 ++--
 clippy_lints/src/operators/ptr_eq.rs                     |  4 ++--
 clippy_lints/src/transmute/transmute_int_to_char.rs      |  8 +++-----
 clippy_lints/src/transmute/transmute_ref_to_ref.rs       |  6 +++---
 6 files changed, 20 insertions(+), 29 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/default_instead_of_iter_empty.rs b/clippy_lints/src/default_instead_of_iter_empty.rs
index 7287b3fcec9..e617c19eff0 100644
--- a/clippy_lints/src/default_instead_of_iter_empty.rs
+++ b/clippy_lints/src/default_instead_of_iter_empty.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_context;
-use clippy_utils::{is_no_std_crate, last_path_segment};
+use clippy_utils::{last_path_segment, std_or_core};
 use rustc_errors::Applicability;
 use rustc_hir::{def, Expr, ExprKind, GenericArg, QPath, TyKind};
 use rustc_lint::{LateContext, LateLintPass};
@@ -42,12 +42,9 @@ impl<'tcx> LateLintPass<'tcx> for DefaultIterEmpty {
             && ty.span.ctxt() == ctxt
         {
             let mut applicability = Applicability::MachineApplicable;
-            let path = if is_no_std_crate(cx) {
-                "core::iter::empty"
-            } else {
-                "std::iter::empty"
-            };
-            let sugg = make_sugg(cx, ty_path, ctxt, &mut applicability, path);
+            let Some(path) = std_or_core(cx) else { return };
+            let path = format!("{path}::iter::empty");
+            let sugg = make_sugg(cx, ty_path, ctxt, &mut applicability, &path);
             span_lint_and_sugg(
                 cx,
                 DEFAULT_INSTEAD_OF_ITER_EMPTY,
diff --git a/clippy_lints/src/mem_replace.rs b/clippy_lints/src/mem_replace.rs
index 919a959073a..fa4f4a47e38 100644
--- a/clippy_lints/src/mem_replace.rs
+++ b/clippy_lints/src/mem_replace.rs
@@ -3,7 +3,7 @@ use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg, span_lin
 use clippy_utils::source::{snippet, snippet_with_applicability};
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::is_non_aggregate_primitive_type;
-use clippy_utils::{is_default_equivalent, is_no_std_crate, is_res_lang_ctor, path_res, peel_ref_operators};
+use clippy_utils::{is_default_equivalent, is_res_lang_ctor, path_res, peel_ref_operators, std_or_core};
 use rustc_errors::Applicability;
 use rustc_hir::LangItem::OptionNone;
 use rustc_hir::{Expr, ExprKind};
@@ -123,15 +123,12 @@ fn check_replace_option_with_none(cx: &LateContext<'_>, dest: &Expr<'_>, expr_sp
     );
 }
 
-fn get_top_crate(cx: &LateContext<'_>) -> &'static str {
-    if is_no_std_crate(cx) { "core" } else { "std" }
-}
-
 fn check_replace_with_uninit(cx: &LateContext<'_>, src: &Expr<'_>, dest: &Expr<'_>, expr_span: Span) {
     if let Some(method_def_id) = cx.typeck_results().type_dependent_def_id(src.hir_id)
         // check if replacement is mem::MaybeUninit::uninit().assume_init()
         && cx.tcx.is_diagnostic_item(sym::assume_init, method_def_id)
     {
+        let Some(top_crate) = std_or_core(cx) else { return };
         let mut applicability = Applicability::MachineApplicable;
         span_lint_and_sugg(
             cx,
@@ -140,8 +137,7 @@ fn check_replace_with_uninit(cx: &LateContext<'_>, src: &Expr<'_>, dest: &Expr<'
             "replacing with `mem::MaybeUninit::uninit().assume_init()`",
             "consider using",
             format!(
-                "{}::ptr::read({})",
-                get_top_crate(cx),
+                "{top_crate}::ptr::read({})",
                 snippet_with_applicability(cx, dest.span, "", &mut applicability)
             ),
             applicability,
@@ -154,6 +150,7 @@ fn check_replace_with_uninit(cx: &LateContext<'_>, src: &Expr<'_>, dest: &Expr<'
         && let Some(repl_def_id) = cx.qpath_res(repl_func_qpath, repl_func.hir_id).opt_def_id()
     {
         if cx.tcx.is_diagnostic_item(sym::mem_uninitialized, repl_def_id) {
+            let Some(top_crate) = std_or_core(cx) else { return };
             let mut applicability = Applicability::MachineApplicable;
             span_lint_and_sugg(
                 cx,
@@ -162,8 +159,7 @@ fn check_replace_with_uninit(cx: &LateContext<'_>, src: &Expr<'_>, dest: &Expr<'
                 "replacing with `mem::uninitialized()`",
                 "consider using",
                 format!(
-                    "{}::ptr::read({})",
-                    get_top_crate(cx),
+                    "{top_crate}::ptr::read({})",
                     snippet_with_applicability(cx, dest.span, "", &mut applicability)
                 ),
                 applicability,
@@ -190,7 +186,7 @@ fn check_replace_with_default(cx: &LateContext<'_>, src: &Expr<'_>, dest: &Expr<
         return;
     }
     if is_default_equivalent(cx, src) && !in_external_macro(cx.tcx.sess, expr_span) {
-        let top_crate = get_top_crate(cx);
+        let Some(top_crate) = std_or_core(cx) else { return };
         span_lint_and_then(
             cx,
             MEM_REPLACE_WITH_DEFAULT,
diff --git a/clippy_lints/src/methods/iter_on_single_or_empty_collections.rs b/clippy_lints/src/methods/iter_on_single_or_empty_collections.rs
index e1ed272231a..4c7c56e7174 100644
--- a/clippy_lints/src/methods/iter_on_single_or_empty_collections.rs
+++ b/clippy_lints/src/methods/iter_on_single_or_empty_collections.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet;
-use clippy_utils::{get_expr_use_or_unification_node, is_no_std_crate, is_res_lang_ctor, path_res};
+use clippy_utils::{get_expr_use_or_unification_node, is_res_lang_ctor, path_res, std_or_core};
 
 use rustc_errors::Applicability;
 use rustc_hir::LangItem::{OptionNone, OptionSome};
@@ -58,7 +58,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, method_name: &str, re
         return;
     }
 
-    let top_crate = if is_no_std_crate(cx) { "core" } else { "std" };
+    let Some(top_crate) = std_or_core(cx) else { return };
     if let Some(i) = item {
         let sugg = format!(
             "{top_crate}::iter::once({}{})",
diff --git a/clippy_lints/src/operators/ptr_eq.rs b/clippy_lints/src/operators/ptr_eq.rs
index 31b51193fb1..a69989e400b 100644
--- a/clippy_lints/src/operators/ptr_eq.rs
+++ b/clippy_lints/src/operators/ptr_eq.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::is_no_std_crate;
 use clippy_utils::source::snippet_opt;
+use clippy_utils::std_or_core;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::LateContext;
@@ -25,7 +25,7 @@ pub(super) fn check<'tcx>(
             && let Some(left_snip) = snippet_opt(cx, left_var.span)
             && let Some(right_snip) = snippet_opt(cx, right_var.span)
         {
-            let top_crate = if is_no_std_crate(cx) { "core" } else { "std" };
+            let Some(top_crate) = std_or_core(cx) else { return };
             span_lint_and_sugg(
                 cx,
                 PTR_EQ,
diff --git a/clippy_lints/src/transmute/transmute_int_to_char.rs b/clippy_lints/src/transmute/transmute_int_to_char.rs
index 71e8a26a566..2a6c2481254 100644
--- a/clippy_lints/src/transmute/transmute_int_to_char.rs
+++ b/clippy_lints/src/transmute/transmute_int_to_char.rs
@@ -1,6 +1,6 @@
 use super::TRANSMUTE_INT_TO_CHAR;
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::{is_no_std_crate, sugg};
+use clippy_utils::{std_or_core, sugg};
 use rustc_ast as ast;
 use rustc_errors::Applicability;
 use rustc_hir::Expr;
@@ -25,6 +25,7 @@ pub(super) fn check<'tcx>(
                 e.span,
                 &format!("transmute from a `{from_ty}` to a `char`"),
                 |diag| {
+                    let Some(top_crate) = std_or_core(cx) else { return };
                     let arg = sugg::Sugg::hir(cx, arg, "..");
                     let arg = if let ty::Int(_) = from_ty.kind() {
                         arg.as_ty(ast::UintTy::U32.name_str())
@@ -34,10 +35,7 @@ pub(super) fn check<'tcx>(
                     diag.span_suggestion(
                         e.span,
                         "consider using",
-                        format!(
-                            "{}::char::from_u32({arg}).unwrap()",
-                            if is_no_std_crate(cx) { "core" } else { "std" }
-                        ),
+                        format!("{top_crate}::char::from_u32({arg}).unwrap()"),
                         Applicability::Unspecified,
                     );
                 },
diff --git a/clippy_lints/src/transmute/transmute_ref_to_ref.rs b/clippy_lints/src/transmute/transmute_ref_to_ref.rs
index c923b4b6dd4..6c885ebdea1 100644
--- a/clippy_lints/src/transmute/transmute_ref_to_ref.rs
+++ b/clippy_lints/src/transmute/transmute_ref_to_ref.rs
@@ -1,7 +1,7 @@
 use super::{TRANSMUTE_BYTES_TO_STR, TRANSMUTE_PTR_TO_PTR};
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::snippet;
-use clippy_utils::{is_no_std_crate, sugg};
+use clippy_utils::{std_or_core, sugg};
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, Mutability};
 use rustc_lint::LateContext;
@@ -25,12 +25,12 @@ pub(super) fn check<'tcx>(
             && let ty::Uint(ty::UintTy::U8) = slice_ty.kind()
             && from_mutbl == to_mutbl
         {
+            let Some(top_crate) = std_or_core(cx) else { return true };
+
             let postfix = if *from_mutbl == Mutability::Mut { "_mut" } else { "" };
 
             let snippet = snippet(cx, arg.span, "..");
 
-            let top_crate = if is_no_std_crate(cx) { "core" } else { "std" };
-
             span_lint_and_sugg(
                 cx,
                 TRANSMUTE_BYTES_TO_STR,
-- 
cgit 1.4.1-3-g733a5


From a1989046c195f40f90670318c848bf843152ab74 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Mon, 15 Jan 2024 23:26:38 +0100
Subject: Don't emit `derive_partial_eq_without_eq` lint if the type has the
 `non_exhaustive` attribute

---
 clippy_lints/src/derive.rs | 16 ++++++++++++++--
 1 file changed, 14 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/derive.rs b/clippy_lints/src/derive.rs
index d8abe411030..aab2550ba6e 100644
--- a/clippy_lints/src/derive.rs
+++ b/clippy_lints/src/derive.rs
@@ -11,8 +11,8 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::nested_filter;
 use rustc_middle::traits::Reveal;
 use rustc_middle::ty::{
-    self, ClauseKind, GenericArgKind, GenericParamDefKind, ImplPolarity, ParamEnv, ToPredicate, TraitPredicate, Ty,
-    TyCtxt,
+    self, AdtDef, ClauseKind, GenericArgKind, GenericParamDefKind, ImplPolarity, ParamEnv, ToPredicate, TraitPredicate,
+    Ty, TyCtxt,
 };
 use rustc_session::declare_lint_pass;
 use rustc_span::def_id::LocalDefId;
@@ -442,6 +442,17 @@ impl<'tcx> Visitor<'tcx> for UnsafeVisitor<'_, 'tcx> {
     }
 }
 
+fn has_non_exhaustive_attr(cx: &LateContext<'_>, adt: AdtDef<'_>) -> bool {
+    adt.is_variant_list_non_exhaustive()
+        || cx.tcx.has_attr(adt.did(), sym::non_exhaustive)
+        || adt.variants().iter().any(|variant_def| {
+            variant_def.is_field_list_non_exhaustive() || cx.tcx.has_attr(variant_def.def_id, sym::non_exhaustive)
+        })
+        || adt
+            .all_fields()
+            .any(|field_def| cx.tcx.has_attr(field_def.did, sym::non_exhaustive))
+}
+
 /// Implementation of the `DERIVE_PARTIAL_EQ_WITHOUT_EQ` lint.
 fn check_partial_eq_without_eq<'tcx>(cx: &LateContext<'tcx>, span: Span, trait_ref: &hir::TraitRef<'_>, ty: Ty<'tcx>) {
     if let ty::Adt(adt, args) = ty.kind()
@@ -449,6 +460,7 @@ fn check_partial_eq_without_eq<'tcx>(cx: &LateContext<'tcx>, span: Span, trait_r
         && let Some(eq_trait_def_id) = cx.tcx.get_diagnostic_item(sym::Eq)
         && let Some(def_id) = trait_ref.trait_def_id()
         && cx.tcx.is_diagnostic_item(sym::PartialEq, def_id)
+        && !has_non_exhaustive_attr(cx, *adt)
         && let param_env = param_env_for_derived_eq(cx.tcx, adt.did(), eq_trait_def_id)
         && !implements_trait_with_env(cx.tcx, param_env, ty, eq_trait_def_id, adt.did(),&[])
         // If all of our fields implement `Eq`, we can implement `Eq` too
-- 
cgit 1.4.1-3-g733a5


From 169e2ab55b490a2b3103372b97a5d315ce8438e7 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Tue, 16 Jan 2024 12:12:28 +0100
Subject: Correctly handle type relative in `trait_duplication_in_bounds` lint

---
 clippy_lints/src/trait_bounds.rs | 14 ++++++++++----
 1 file changed, 10 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/trait_bounds.rs b/clippy_lints/src/trait_bounds.rs
index e4054393d0a..768623b5d03 100644
--- a/clippy_lints/src/trait_bounds.rs
+++ b/clippy_lints/src/trait_bounds.rs
@@ -390,6 +390,14 @@ fn get_trait_info_from_bound<'a>(bound: &'a GenericBound<'_>) -> Option<(Res, &'
     }
 }
 
+fn get_ty_res(ty: Ty<'_>) -> Option<Res> {
+    match ty.kind {
+        TyKind::Path(QPath::Resolved(_, path)) => Some(path.res),
+        TyKind::Path(QPath::TypeRelative(ty, _)) => get_ty_res(*ty),
+        _ => None,
+    }
+}
+
 // FIXME: ComparableTraitRef does not support nested bounds needed for associated_type_bounds
 fn into_comparable_trait_ref(trait_ref: &TraitRef<'_>) -> ComparableTraitRef {
     ComparableTraitRef(
@@ -401,10 +409,8 @@ fn into_comparable_trait_ref(trait_ref: &TraitRef<'_>) -> ComparableTraitRef {
             .filter_map(|segment| {
                 // get trait bound type arguments
                 Some(segment.args?.args.iter().filter_map(|arg| {
-                    if let GenericArg::Type(ty) = arg
-                        && let TyKind::Path(QPath::Resolved(_, path)) = ty.kind
-                    {
-                        return Some(path.res);
+                    if let GenericArg::Type(ty) = arg {
+                        return get_ty_res(**ty);
                     }
                     None
                 }))
-- 
cgit 1.4.1-3-g733a5


From 0e961cd854c9b1752d00a2b53ec3b5b0ee668e34 Mon Sep 17 00:00:00 2001
From: J-ZhengLi <lizheng135@huawei.com>
Date: Thu, 18 Jan 2024 18:53:41 +0800
Subject: fix suggestion error with attr macros

---
 clippy_lints/src/semicolon_if_nothing_returned.rs |  6 ++++++
 tests/ui/semicolon_if_nothing_returned.fixed      | 13 ++++++++++---
 tests/ui/semicolon_if_nothing_returned.rs         |  9 ++++++++-
 tests/ui/semicolon_if_nothing_returned.stderr     | 14 +-------------
 4 files changed, 25 insertions(+), 17 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/semicolon_if_nothing_returned.rs b/clippy_lints/src/semicolon_if_nothing_returned.rs
index 2cd3e57f885..6540626f7d5 100644
--- a/clippy_lints/src/semicolon_if_nothing_returned.rs
+++ b/clippy_lints/src/semicolon_if_nothing_returned.rs
@@ -5,6 +5,7 @@ use rustc_errors::Applicability;
 use rustc_hir::{Block, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::declare_lint_pass;
+use rustc_span::{ExpnKind, MacroKind, Span};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -39,6 +40,7 @@ impl<'tcx> LateLintPass<'tcx> for SemicolonIfNothingReturned {
     fn check_block(&mut self, cx: &LateContext<'tcx>, block: &'tcx Block<'tcx>) {
         if !block.span.from_expansion()
             && let Some(expr) = block.expr
+            && !from_attr_macro(expr.span)
             && let t_expr = cx.typeck_results().expr_ty(expr)
             && t_expr.is_unit()
             && let mut app = Applicability::MachineApplicable
@@ -63,3 +65,7 @@ impl<'tcx> LateLintPass<'tcx> for SemicolonIfNothingReturned {
         }
     }
 }
+
+fn from_attr_macro(span: Span) -> bool {
+    matches!(span.ctxt().outer_expn_data().kind, ExpnKind::Macro(MacroKind::Attr, _))
+}
diff --git a/tests/ui/semicolon_if_nothing_returned.fixed b/tests/ui/semicolon_if_nothing_returned.fixed
index bc96b959fc5..cdfa5d9cc78 100644
--- a/tests/ui/semicolon_if_nothing_returned.fixed
+++ b/tests/ui/semicolon_if_nothing_returned.fixed
@@ -129,19 +129,26 @@ fn let_else_stmts() {
 mod issue12123 {
     #[rustfmt::skip]
     mod this_triggers {
-        #[fake_main];
+        #[fake_main]
         async fn main() {
-            
+
         }
     }
 
     mod and_this {
-        #[fake_main];
+        #[fake_main]
         async fn main() {
             println!("hello");
         }
     }
 
+    #[rustfmt::skip]
+    mod maybe_this {
+        /** */ #[fake_main]
+        async fn main() {
+        }
+    }
+
     mod but_this_does_not {
         #[fake_main]
         async fn main() {}
diff --git a/tests/ui/semicolon_if_nothing_returned.rs b/tests/ui/semicolon_if_nothing_returned.rs
index e5713ce062b..315b7e4f383 100644
--- a/tests/ui/semicolon_if_nothing_returned.rs
+++ b/tests/ui/semicolon_if_nothing_returned.rs
@@ -131,7 +131,7 @@ mod issue12123 {
     mod this_triggers {
         #[fake_main]
         async fn main() {
-            
+
         }
     }
 
@@ -142,6 +142,13 @@ mod issue12123 {
         }
     }
 
+    #[rustfmt::skip]
+    mod maybe_this {
+        /** */ #[fake_main]
+        async fn main() {
+        }
+    }
+
     mod but_this_does_not {
         #[fake_main]
         async fn main() {}
diff --git a/tests/ui/semicolon_if_nothing_returned.stderr b/tests/ui/semicolon_if_nothing_returned.stderr
index 0d5381ef621..09c4d12f216 100644
--- a/tests/ui/semicolon_if_nothing_returned.stderr
+++ b/tests/ui/semicolon_if_nothing_returned.stderr
@@ -31,17 +31,5 @@ error: consider adding a `;` to the last statement for consistent formatting
 LL |         ptr::drop_in_place(s.as_mut_ptr())
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: add a `;` here: `ptr::drop_in_place(s.as_mut_ptr());`
 
-error: consider adding a `;` to the last statement for consistent formatting
-  --> $DIR/semicolon_if_nothing_returned.rs:132:9
-   |
-LL |         #[fake_main]
-   |         ^^^^^^^^^^^^ help: add a `;` here: `#[fake_main];`
-
-error: consider adding a `;` to the last statement for consistent formatting
-  --> $DIR/semicolon_if_nothing_returned.rs:139:9
-   |
-LL |         #[fake_main]
-   |         ^^^^^^^^^^^^ help: add a `;` here: `#[fake_main];`
-
-error: aborting due to 7 previous errors
+error: aborting due to 5 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From efd8dafa2f701280c2dd5ee31716ffa0c18e484b Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Thu, 18 Jan 2024 17:15:11 +0100
Subject: [`default_numeric_fallback`]: improve const context detection

---
 clippy_lints/src/default_numeric_fallback.rs | 14 +++++-----
 tests/ui/default_numeric_fallback_i32.fixed  | 40 ++++++++++++++++++++++++++++
 tests/ui/default_numeric_fallback_i32.rs     | 40 ++++++++++++++++++++++++++++
 3 files changed, 87 insertions(+), 7 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/default_numeric_fallback.rs b/clippy_lints/src/default_numeric_fallback.rs
index 712bc075650..c4437a3c4b3 100644
--- a/clippy_lints/src/default_numeric_fallback.rs
+++ b/clippy_lints/src/default_numeric_fallback.rs
@@ -1,10 +1,10 @@
 use clippy_utils::diagnostics::span_lint_hir_and_then;
+use clippy_utils::numeric_literal;
 use clippy_utils::source::snippet_opt;
-use clippy_utils::{get_parent_node, numeric_literal};
 use rustc_ast::ast::{LitFloatType, LitIntType, LitKind};
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_expr, walk_stmt, Visitor};
-use rustc_hir::{Block, Body, Expr, ExprKind, FnRetTy, HirId, ItemKind, Lit, Node, Stmt, StmtKind};
+use rustc_hir::{Block, Body, ConstContext, Expr, ExprKind, FnRetTy, HirId, Lit, Stmt, StmtKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::{self, FloatTy, IntTy, PolyFnSig, Ty};
@@ -50,11 +50,11 @@ declare_lint_pass!(DefaultNumericFallback => [DEFAULT_NUMERIC_FALLBACK]);
 
 impl<'tcx> LateLintPass<'tcx> for DefaultNumericFallback {
     fn check_body(&mut self, cx: &LateContext<'tcx>, body: &'tcx Body<'_>) {
-        let is_parent_const = if let Some(Node::Item(item)) = get_parent_node(cx.tcx, body.id().hir_id) {
-            matches!(item.kind, ItemKind::Const(..))
-        } else {
-            false
-        };
+        let hir = cx.tcx.hir();
+        let is_parent_const = matches!(
+            hir.body_const_context(hir.body_owner_def_id(body.id())),
+            Some(ConstContext::Const { inline: false } | ConstContext::Static(_))
+        );
         let mut visitor = NumericFallbackVisitor::new(cx, is_parent_const);
         visitor.visit_body(body);
     }
diff --git a/tests/ui/default_numeric_fallback_i32.fixed b/tests/ui/default_numeric_fallback_i32.fixed
index c364c683057..e7038082c08 100644
--- a/tests/ui/default_numeric_fallback_i32.fixed
+++ b/tests/ui/default_numeric_fallback_i32.fixed
@@ -216,4 +216,44 @@ mod type_already_inferred {
     }
 }
 
+mod issue12159 {
+    #![allow(non_upper_case_globals, clippy::exhaustive_structs)]
+    pub struct Foo;
+
+    static F: i32 = 1;
+    impl Foo {
+        const LIFE_u8: u8 = 42;
+        const LIFE_i8: i8 = 42;
+        const LIFE_u16: u16 = 42;
+        const LIFE_i16: i16 = 42;
+        const LIFE_u32: u32 = 42;
+        const LIFE_i32: i32 = 42;
+        const LIFE_u64: u64 = 42;
+        const LIFE_i64: i64 = 42;
+        const LIFE_u128: u128 = 42;
+        const LIFE_i128: i128 = 42;
+        const LIFE_usize: usize = 42;
+        const LIFE_isize: isize = 42;
+        const LIFE_f32: f32 = 42.;
+        const LIFE_f64: f64 = 42.;
+
+        const fn consts() {
+            const LIFE_u8: u8 = 42;
+            const LIFE_i8: i8 = 42;
+            const LIFE_u16: u16 = 42;
+            const LIFE_i16: i16 = 42;
+            const LIFE_u32: u32 = 42;
+            const LIFE_i32: i32 = 42;
+            const LIFE_u64: u64 = 42;
+            const LIFE_i64: i64 = 42;
+            const LIFE_u128: u128 = 42;
+            const LIFE_i128: i128 = 42;
+            const LIFE_usize: usize = 42;
+            const LIFE_isize: isize = 42;
+            const LIFE_f32: f32 = 42.;
+            const LIFE_f64: f64 = 42.;
+        }
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/default_numeric_fallback_i32.rs b/tests/ui/default_numeric_fallback_i32.rs
index ffa7b961d1c..d8eeda70491 100644
--- a/tests/ui/default_numeric_fallback_i32.rs
+++ b/tests/ui/default_numeric_fallback_i32.rs
@@ -216,4 +216,44 @@ mod type_already_inferred {
     }
 }
 
+mod issue12159 {
+    #![allow(non_upper_case_globals, clippy::exhaustive_structs)]
+    pub struct Foo;
+
+    static F: i32 = 1;
+    impl Foo {
+        const LIFE_u8: u8 = 42;
+        const LIFE_i8: i8 = 42;
+        const LIFE_u16: u16 = 42;
+        const LIFE_i16: i16 = 42;
+        const LIFE_u32: u32 = 42;
+        const LIFE_i32: i32 = 42;
+        const LIFE_u64: u64 = 42;
+        const LIFE_i64: i64 = 42;
+        const LIFE_u128: u128 = 42;
+        const LIFE_i128: i128 = 42;
+        const LIFE_usize: usize = 42;
+        const LIFE_isize: isize = 42;
+        const LIFE_f32: f32 = 42.;
+        const LIFE_f64: f64 = 42.;
+
+        const fn consts() {
+            const LIFE_u8: u8 = 42;
+            const LIFE_i8: i8 = 42;
+            const LIFE_u16: u16 = 42;
+            const LIFE_i16: i16 = 42;
+            const LIFE_u32: u32 = 42;
+            const LIFE_i32: i32 = 42;
+            const LIFE_u64: u64 = 42;
+            const LIFE_i64: i64 = 42;
+            const LIFE_u128: u128 = 42;
+            const LIFE_i128: i128 = 42;
+            const LIFE_usize: usize = 42;
+            const LIFE_isize: isize = 42;
+            const LIFE_f32: f32 = 42.;
+            const LIFE_f64: f64 = 42.;
+        }
+    }
+}
+
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From c6079a6880ffa29a49edeb48520f220963b01c3e Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Fri, 19 Jan 2024 01:06:08 +0100
Subject: blocks_in_conditions: do not warn if condition comes from macro

---
 clippy_lints/src/blocks_in_conditions.rs |  5 +++++
 tests/ui/blocks_in_conditions.fixed      | 14 ++++++++++++++
 tests/ui/blocks_in_conditions.rs         | 14 ++++++++++++++
 3 files changed, 33 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/blocks_in_conditions.rs b/clippy_lints/src/blocks_in_conditions.rs
index 1417e230aee..ff4dffd0607 100644
--- a/clippy_lints/src/blocks_in_conditions.rs
+++ b/clippy_lints/src/blocks_in_conditions.rs
@@ -67,6 +67,11 @@ impl<'tcx> LateLintPass<'tcx> for BlocksInConditions {
         );
 
         if let ExprKind::Block(block, _) = &cond.kind {
+            if !block.span.eq_ctxt(expr.span) {
+                // If the block comes from a macro, or as an argument to a macro,
+                // do not lint.
+                return;
+            }
             if block.rules == BlockCheckMode::DefaultBlock {
                 if block.stmts.is_empty() {
                     if let Some(ex) = &block.expr {
diff --git a/tests/ui/blocks_in_conditions.fixed b/tests/ui/blocks_in_conditions.fixed
index 2ab441bbd0c..efef60567a9 100644
--- a/tests/ui/blocks_in_conditions.fixed
+++ b/tests/ui/blocks_in_conditions.fixed
@@ -85,4 +85,18 @@ fn block_in_match_expr(num: i32) -> i32 {
     }
 }
 
+// issue #12162
+macro_rules! timed {
+    ($name:expr, $body:expr $(,)?) => {{
+        let __scope = ();
+        $body
+    }};
+}
+
+fn issue_12162() {
+    if timed!("check this!", false) {
+        println!();
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/blocks_in_conditions.rs b/tests/ui/blocks_in_conditions.rs
index dd5ae4fb486..8bd8a939eb1 100644
--- a/tests/ui/blocks_in_conditions.rs
+++ b/tests/ui/blocks_in_conditions.rs
@@ -85,4 +85,18 @@ fn block_in_match_expr(num: i32) -> i32 {
     }
 }
 
+// issue #12162
+macro_rules! timed {
+    ($name:expr, $body:expr $(,)?) => {{
+        let __scope = ();
+        $body
+    }};
+}
+
+fn issue_12162() {
+    if timed!("check this!", false) {
+        println!();
+    }
+}
+
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 9661f9b17773d20efb11b77d4fc59d4d8daae4f9 Mon Sep 17 00:00:00 2001
From: Chris Wu <chriswuyyy123@gmail.com>
Date: Fri, 19 Jan 2024 15:01:33 +0800
Subject: Add new condition  to avoid derived code trigger lint

---
 clippy_lints/src/no_effect.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/no_effect.rs b/clippy_lints/src/no_effect.rs
index 2a2c2b331ba..55b23a1f718 100644
--- a/clippy_lints/src/no_effect.rs
+++ b/clippy_lints/src/no_effect.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::{span_lint_hir, span_lint_hir_and_then};
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::has_drop;
-use clippy_utils::{get_parent_node, is_lint_allowed, peel_blocks};
+use clippy_utils::{any_parent_is_automatically_derived, get_parent_node, is_lint_allowed, peel_blocks};
 use rustc_errors::Applicability;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::{
@@ -144,6 +144,7 @@ fn check_no_effect(cx: &LateContext<'_>, stmt: &Stmt<'_>) -> bool {
         }
     } else if let StmtKind::Local(local) = stmt.kind {
         if !is_lint_allowed(cx, NO_EFFECT_UNDERSCORE_BINDING, local.hir_id)
+            && !any_parent_is_automatically_derived(cx.tcx, local.hir_id)
             && let Some(init) = local.init
             && local.els.is_none()
             && !local.pat.span.from_expansion()
-- 
cgit 1.4.1-3-g733a5


From 73d7ce6abf877f22c7355b3b203e1587e58741bd Mon Sep 17 00:00:00 2001
From: Chris Wu <chriswuyyy123@gmail.com>
Date: Fri, 19 Jan 2024 21:05:58 +0800
Subject: Move the new check to the end of checks

---
 clippy_lints/src/no_effect.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/no_effect.rs b/clippy_lints/src/no_effect.rs
index 55b23a1f718..5983e206894 100644
--- a/clippy_lints/src/no_effect.rs
+++ b/clippy_lints/src/no_effect.rs
@@ -144,13 +144,13 @@ fn check_no_effect(cx: &LateContext<'_>, stmt: &Stmt<'_>) -> bool {
         }
     } else if let StmtKind::Local(local) = stmt.kind {
         if !is_lint_allowed(cx, NO_EFFECT_UNDERSCORE_BINDING, local.hir_id)
-            && !any_parent_is_automatically_derived(cx.tcx, local.hir_id)
             && let Some(init) = local.init
             && local.els.is_none()
             && !local.pat.span.from_expansion()
             && has_no_effect(cx, init)
             && let PatKind::Binding(_, _, ident, _) = local.pat.kind
             && ident.name.to_ident_string().starts_with('_')
+            && !any_parent_is_automatically_derived(cx.tcx, local.hir_id)
         {
             span_lint_hir(
                 cx,
-- 
cgit 1.4.1-3-g733a5


From 6267b6ca09b4a91c83bd11a72aeffaf96fa55702 Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Fri, 19 Jan 2024 23:25:36 +0100
Subject: no_effect_underscore_binding: _ prefixed variables can be used

Prefixing a variable with a `_` does not mean that it will not be used.
If such a variable is used later, do not warn about the fact that its
initialization does not have a side effect as this is fine.
---
 clippy_lints/src/lib.rs       |   2 +-
 clippy_lints/src/no_effect.rs | 180 +++++++++++++++++++++++++-----------------
 tests/ui/no_effect.rs         |   2 +
 3 files changed, 109 insertions(+), 75 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index efdd3925949..8004590e8e7 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -719,7 +719,7 @@ pub fn register_lints(store: &mut rustc_lint::LintStore, conf: &'static Conf) {
     store.register_late_pass(|_| Box::new(needless_update::NeedlessUpdate));
     store.register_late_pass(|_| Box::new(needless_borrowed_ref::NeedlessBorrowedRef));
     store.register_late_pass(|_| Box::new(borrow_deref_ref::BorrowDerefRef));
-    store.register_late_pass(|_| Box::new(no_effect::NoEffect));
+    store.register_late_pass(|_| Box::<no_effect::NoEffect>::default());
     store.register_late_pass(|_| Box::new(temporary_assignment::TemporaryAssignment));
     store.register_late_pass(move |_| Box::new(transmute::Transmute::new(msrv())));
     store.register_late_pass(move |_| {
diff --git a/clippy_lints/src/no_effect.rs b/clippy_lints/src/no_effect.rs
index 5983e206894..0d234f7f9b5 100644
--- a/clippy_lints/src/no_effect.rs
+++ b/clippy_lints/src/no_effect.rs
@@ -1,16 +1,18 @@
 use clippy_utils::diagnostics::{span_lint_hir, span_lint_hir_and_then};
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::has_drop;
-use clippy_utils::{any_parent_is_automatically_derived, get_parent_node, is_lint_allowed, peel_blocks};
+use clippy_utils::{any_parent_is_automatically_derived, get_parent_node, is_lint_allowed, path_to_local, peel_blocks};
 use rustc_errors::Applicability;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::{
-    is_range_literal, BinOpKind, BlockCheckMode, Expr, ExprKind, ItemKind, Node, PatKind, Stmt, StmtKind, UnsafeSource,
+    is_range_literal, BinOpKind, BlockCheckMode, Expr, ExprKind, HirId, HirIdMap, ItemKind, Node, PatKind, Stmt,
+    StmtKind, UnsafeSource,
 };
 use rustc_infer::infer::TyCtxtInferExt as _;
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_session::declare_lint_pass;
+use rustc_session::impl_lint_pass;
+use rustc_span::Span;
 use std::ops::Deref;
 
 declare_clippy_lint! {
@@ -74,95 +76,125 @@ declare_clippy_lint! {
     "outer expressions with no effect"
 }
 
-declare_lint_pass!(NoEffect => [NO_EFFECT, UNNECESSARY_OPERATION, NO_EFFECT_UNDERSCORE_BINDING]);
+#[derive(Default)]
+pub struct NoEffect {
+    underscore_bindings: HirIdMap<Span>,
+    local_bindings: Vec<Vec<HirId>>,
+}
+
+impl_lint_pass!(NoEffect => [NO_EFFECT, UNNECESSARY_OPERATION, NO_EFFECT_UNDERSCORE_BINDING]);
 
 impl<'tcx> LateLintPass<'tcx> for NoEffect {
     fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) {
-        if check_no_effect(cx, stmt) {
+        if self.check_no_effect(cx, stmt) {
             return;
         }
         check_unnecessary_operation(cx, stmt);
     }
-}
 
-fn check_no_effect(cx: &LateContext<'_>, stmt: &Stmt<'_>) -> bool {
-    if let StmtKind::Semi(expr) = stmt.kind {
-        // move `expr.span.from_expansion()` ahead
-        if expr.span.from_expansion() {
-            return false;
+    fn check_block(&mut self, _: &LateContext<'tcx>, _: &'tcx rustc_hir::Block<'tcx>) {
+        self.local_bindings.push(Vec::default());
+    }
+
+    fn check_block_post(&mut self, cx: &LateContext<'tcx>, _: &'tcx rustc_hir::Block<'tcx>) {
+        for hir_id in self.local_bindings.pop().unwrap() {
+            if let Some(span) = self.underscore_bindings.remove(&hir_id) {
+                span_lint_hir(
+                    cx,
+                    NO_EFFECT_UNDERSCORE_BINDING,
+                    hir_id,
+                    span,
+                    "binding to `_` prefixed variable with no side-effect",
+                );
+            }
         }
-        let expr = peel_blocks(expr);
+    }
 
-        if is_operator_overridden(cx, expr) {
-            // Return `true`, to prevent `check_unnecessary_operation` from
-            // linting on this statement as well.
-            return true;
+    fn check_expr(&mut self, _: &LateContext<'tcx>, expr: &'tcx rustc_hir::Expr<'tcx>) {
+        if let Some(def_id) = path_to_local(expr) {
+            self.underscore_bindings.remove(&def_id);
         }
-        if has_no_effect(cx, expr) {
-            span_lint_hir_and_then(
-                cx,
-                NO_EFFECT,
-                expr.hir_id,
-                stmt.span,
-                "statement with no effect",
-                |diag| {
-                    for parent in cx.tcx.hir().parent_iter(stmt.hir_id) {
-                        if let Node::Item(item) = parent.1
-                            && let ItemKind::Fn(..) = item.kind
-                            && let Some(Node::Block(block)) = get_parent_node(cx.tcx, stmt.hir_id)
-                            && let [.., final_stmt] = block.stmts
-                            && final_stmt.hir_id == stmt.hir_id
-                        {
-                            let expr_ty = cx.typeck_results().expr_ty(expr);
-                            let mut ret_ty = cx
-                                .tcx
-                                .fn_sig(item.owner_id)
-                                .instantiate_identity()
-                                .output()
-                                .skip_binder();
+    }
+}
 
-                            // Remove `impl Future<Output = T>` to get `T`
-                            if cx.tcx.ty_is_opaque_future(ret_ty)
-                                && let Some(true_ret_ty) = cx.tcx.infer_ctxt().build().get_impl_future_output_ty(ret_ty)
+impl NoEffect {
+    fn check_no_effect(&mut self, cx: &LateContext<'_>, stmt: &Stmt<'_>) -> bool {
+        if let StmtKind::Semi(expr) = stmt.kind {
+            // move `expr.span.from_expansion()` ahead
+            if expr.span.from_expansion() {
+                return false;
+            }
+            let expr = peel_blocks(expr);
+
+            if is_operator_overridden(cx, expr) {
+                // Return `true`, to prevent `check_unnecessary_operation` from
+                // linting on this statement as well.
+                return true;
+            }
+            if has_no_effect(cx, expr) {
+                span_lint_hir_and_then(
+                    cx,
+                    NO_EFFECT,
+                    expr.hir_id,
+                    stmt.span,
+                    "statement with no effect",
+                    |diag| {
+                        for parent in cx.tcx.hir().parent_iter(stmt.hir_id) {
+                            if let Node::Item(item) = parent.1
+                                && let ItemKind::Fn(..) = item.kind
+                                && let Some(Node::Block(block)) = get_parent_node(cx.tcx, stmt.hir_id)
+                                && let [.., final_stmt] = block.stmts
+                                && final_stmt.hir_id == stmt.hir_id
                             {
-                                ret_ty = true_ret_ty;
-                            }
+                                let expr_ty = cx.typeck_results().expr_ty(expr);
+                                let mut ret_ty = cx
+                                    .tcx
+                                    .fn_sig(item.owner_id)
+                                    .instantiate_identity()
+                                    .output()
+                                    .skip_binder();
+
+                                // Remove `impl Future<Output = T>` to get `T`
+                                if cx.tcx.ty_is_opaque_future(ret_ty)
+                                    && let Some(true_ret_ty) =
+                                        cx.tcx.infer_ctxt().build().get_impl_future_output_ty(ret_ty)
+                                {
+                                    ret_ty = true_ret_ty;
+                                }
 
-                            if !ret_ty.is_unit() && ret_ty == expr_ty {
-                                diag.span_suggestion(
-                                    stmt.span.shrink_to_lo(),
-                                    "did you mean to return it?",
-                                    "return ",
-                                    Applicability::MaybeIncorrect,
-                                );
+                                if !ret_ty.is_unit() && ret_ty == expr_ty {
+                                    diag.span_suggestion(
+                                        stmt.span.shrink_to_lo(),
+                                        "did you mean to return it?",
+                                        "return ",
+                                        Applicability::MaybeIncorrect,
+                                    );
+                                }
                             }
                         }
-                    }
-                },
-            );
-            return true;
-        }
-    } else if let StmtKind::Local(local) = stmt.kind {
-        if !is_lint_allowed(cx, NO_EFFECT_UNDERSCORE_BINDING, local.hir_id)
-            && let Some(init) = local.init
-            && local.els.is_none()
-            && !local.pat.span.from_expansion()
-            && has_no_effect(cx, init)
-            && let PatKind::Binding(_, _, ident, _) = local.pat.kind
-            && ident.name.to_ident_string().starts_with('_')
-            && !any_parent_is_automatically_derived(cx.tcx, local.hir_id)
-        {
-            span_lint_hir(
-                cx,
-                NO_EFFECT_UNDERSCORE_BINDING,
-                init.hir_id,
-                ident.span,
-                "binding to `_` prefixed variable with no side-effect",
-            );
-            return true;
+                    },
+                );
+                return true;
+            }
+        } else if let StmtKind::Local(local) = stmt.kind {
+            if !is_lint_allowed(cx, NO_EFFECT_UNDERSCORE_BINDING, local.hir_id)
+                && let Some(init) = local.init
+                && local.els.is_none()
+                && !local.pat.span.from_expansion()
+                && has_no_effect(cx, init)
+                && let PatKind::Binding(_, hir_id, ident, _) = local.pat.kind
+                && ident.name.to_ident_string().starts_with('_')
+                && !any_parent_is_automatically_derived(cx.tcx, local.hir_id)
+            {
+                if let Some(l) = self.local_bindings.last_mut() {
+                    l.push(hir_id);
+                    self.underscore_bindings.insert(hir_id, ident.span);
+                }
+                return true;
+            }
         }
+        false
     }
-    false
 }
 
 fn is_operator_overridden(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
diff --git a/tests/ui/no_effect.rs b/tests/ui/no_effect.rs
index 777b1e52c2d..dabeda72f0c 100644
--- a/tests/ui/no_effect.rs
+++ b/tests/ui/no_effect.rs
@@ -181,6 +181,8 @@ fn main() {
     //~^ ERROR: binding to `_` prefixed variable with no side-effect
     let _cat = [2, 4, 6, 8][2];
     //~^ ERROR: binding to `_` prefixed variable with no side-effect
+    let _issue_12166 = 42;
+    let underscore_variable_above_can_be_used_dont_lint = _issue_12166;
 
     #[allow(clippy::no_effect)]
     0;
-- 
cgit 1.4.1-3-g733a5


From 49b0c3f4f1b43e5dcac88c965c32a8e804d7fb3c Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Thu, 18 Jan 2024 18:17:46 +0100
Subject: Improve wording for suggestion messages

---
 clippy_lints/src/loops/same_item_push.rs                            | 2 +-
 clippy_lints/src/methods/join_absolute_paths.rs                     | 2 +-
 clippy_lints/src/methods/manual_saturating_arithmetic.rs            | 2 +-
 clippy_lints/src/methods/option_as_ref_deref.rs                     | 2 +-
 clippy_lints/src/methods/option_map_or_err_ok.rs                    | 2 +-
 clippy_lints/src/methods/option_map_or_none.rs                      | 6 +++---
 clippy_lints/src/methods/result_map_or_else_none.rs                 | 2 +-
 clippy_lints/src/methods/single_char_pattern.rs                     | 2 +-
 clippy_lints/src/methods/unnecessary_join.rs                        | 2 +-
 .../src/utils/internal_lints/almost_standard_lint_formulation.rs    | 2 +-
 10 files changed, 12 insertions(+), 12 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/same_item_push.rs b/clippy_lints/src/loops/same_item_push.rs
index c245eaf1ab4..920a887a6fd 100644
--- a/clippy_lints/src/loops/same_item_push.rs
+++ b/clippy_lints/src/loops/same_item_push.rs
@@ -31,7 +31,7 @@ pub(super) fn check<'tcx>(
             vec.span,
             "it looks like the same item is being pushed into this Vec",
             None,
-            &format!("try using vec![{item_str};SIZE] or {vec_str}.resize(NEW_SIZE, {item_str})"),
+            &format!("consider using vec![{item_str};SIZE] or {vec_str}.resize(NEW_SIZE, {item_str})"),
         );
     }
 
diff --git a/clippy_lints/src/methods/join_absolute_paths.rs b/clippy_lints/src/methods/join_absolute_paths.rs
index 02f28779cf6..aa1ec60d434 100644
--- a/clippy_lints/src/methods/join_absolute_paths.rs
+++ b/clippy_lints/src/methods/join_absolute_paths.rs
@@ -42,7 +42,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, recv: &'tcx Expr<'tcx>, join_a
                     )
                     .span_suggestion(
                         expr_span,
-                        "if this is intentional, try using `Path::new` instead",
+                        "if this is intentional, consider using `Path::new`",
                         format!("PathBuf::from({arg_str})"),
                         Applicability::Unspecified,
                     );
diff --git a/clippy_lints/src/methods/manual_saturating_arithmetic.rs b/clippy_lints/src/methods/manual_saturating_arithmetic.rs
index 04bdbc1ea25..bf437db7e72 100644
--- a/clippy_lints/src/methods/manual_saturating_arithmetic.rs
+++ b/clippy_lints/src/methods/manual_saturating_arithmetic.rs
@@ -50,7 +50,7 @@ pub fn check(
         super::MANUAL_SATURATING_ARITHMETIC,
         expr.span,
         "manual saturating arithmetic",
-        &format!("try using `saturating_{arith}`"),
+        &format!("consider using `saturating_{arith}`"),
         format!(
             "{}.saturating_{arith}({})",
             snippet_with_applicability(cx, arith_lhs.span, "..", &mut applicability),
diff --git a/clippy_lints/src/methods/option_as_ref_deref.rs b/clippy_lints/src/methods/option_as_ref_deref.rs
index 756dbe62d84..88e2af15658 100644
--- a/clippy_lints/src/methods/option_as_ref_deref.rs
+++ b/clippy_lints/src/methods/option_as_ref_deref.rs
@@ -97,7 +97,7 @@ pub(super) fn check(
         };
         let method_hint = if is_mut { "as_deref_mut" } else { "as_deref" };
         let hint = format!("{}.{method_hint}()", snippet(cx, as_ref_recv.span, ".."));
-        let suggestion = format!("try using {method_hint} instead");
+        let suggestion = format!("consider using {method_hint}");
 
         let msg = format!("called `{current_method}` on an `Option` value");
         span_lint_and_sugg(
diff --git a/clippy_lints/src/methods/option_map_or_err_ok.rs b/clippy_lints/src/methods/option_map_or_err_ok.rs
index 91e39d5a1cd..4e424d4c066 100644
--- a/clippy_lints/src/methods/option_map_or_err_ok.rs
+++ b/clippy_lints/src/methods/option_map_or_err_ok.rs
@@ -33,7 +33,7 @@ pub(super) fn check<'tcx>(
             OPTION_MAP_OR_ERR_OK,
             expr.span,
             msg,
-            "try using `ok_or` instead",
+            "consider using `ok_or`",
             format!("{self_snippet}.ok_or({err_snippet})"),
             Applicability::MachineApplicable,
         );
diff --git a/clippy_lints/src/methods/option_map_or_none.rs b/clippy_lints/src/methods/option_map_or_none.rs
index ff4d8cc9e3e..193deafccf6 100644
--- a/clippy_lints/src/methods/option_map_or_none.rs
+++ b/clippy_lints/src/methods/option_map_or_none.rs
@@ -72,7 +72,7 @@ pub(super) fn check<'tcx>(
                 OPTION_MAP_OR_NONE,
                 expr.span,
                 msg,
-                "try using `map` instead",
+                "consider using `map`",
                 format!("{self_snippet}.map({arg_snippet} {func_snippet})"),
                 Applicability::MachineApplicable,
             );
@@ -85,7 +85,7 @@ pub(super) fn check<'tcx>(
             OPTION_MAP_OR_NONE,
             expr.span,
             msg,
-            "try using `and_then` instead",
+            "consider using `and_then`",
             format!("{self_snippet}.and_then({func_snippet})"),
             Applicability::MachineApplicable,
         );
@@ -97,7 +97,7 @@ pub(super) fn check<'tcx>(
             RESULT_MAP_OR_INTO_OPTION,
             expr.span,
             msg,
-            "try using `ok` instead",
+            "consider using `ok`",
             format!("{self_snippet}.ok()"),
             Applicability::MachineApplicable,
         );
diff --git a/clippy_lints/src/methods/result_map_or_else_none.rs b/clippy_lints/src/methods/result_map_or_else_none.rs
index bc16a112816..3b0dc506305 100644
--- a/clippy_lints/src/methods/result_map_or_else_none.rs
+++ b/clippy_lints/src/methods/result_map_or_else_none.rs
@@ -34,7 +34,7 @@ pub(super) fn check<'tcx>(
             RESULT_MAP_OR_INTO_OPTION,
             expr.span,
             msg,
-            "try using `ok` instead",
+            "consider using `ok`",
             format!("{self_snippet}.ok()"),
             Applicability::MachineApplicable,
         );
diff --git a/clippy_lints/src/methods/single_char_pattern.rs b/clippy_lints/src/methods/single_char_pattern.rs
index 3983f0c0cab..363b1f2b812 100644
--- a/clippy_lints/src/methods/single_char_pattern.rs
+++ b/clippy_lints/src/methods/single_char_pattern.rs
@@ -57,7 +57,7 @@ pub(super) fn check(
                 SINGLE_CHAR_PATTERN,
                 arg.span,
                 "single-character string constant used as pattern",
-                "try using a `char` instead",
+                "consider using a `char`",
                 hint,
                 applicability,
             );
diff --git a/clippy_lints/src/methods/unnecessary_join.rs b/clippy_lints/src/methods/unnecessary_join.rs
index e2b389e96da..c3ad4db3875 100644
--- a/clippy_lints/src/methods/unnecessary_join.rs
+++ b/clippy_lints/src/methods/unnecessary_join.rs
@@ -32,7 +32,7 @@ pub(super) fn check<'tcx>(
             UNNECESSARY_JOIN,
             span.with_hi(expr.span.hi()),
             r#"called `.collect::<Vec<String>>().join("")` on an iterator"#,
-            "try using",
+            "consider using",
             "collect::<String>()".to_owned(),
             applicability,
         );
diff --git a/clippy_lints/src/utils/internal_lints/almost_standard_lint_formulation.rs b/clippy_lints/src/utils/internal_lints/almost_standard_lint_formulation.rs
index 5ddedb24b15..4822970e47e 100644
--- a/clippy_lints/src/utils/internal_lints/almost_standard_lint_formulation.rs
+++ b/clippy_lints/src/utils/internal_lints/almost_standard_lint_formulation.rs
@@ -66,7 +66,7 @@ impl<'tcx> LateLintPass<'tcx> for AlmostStandardFormulation {
                                         ident.span,
                                         "non-standard lint formulation",
                                         None,
-                                        &format!("try using `{}` instead", formulation.correction),
+                                        &format!("consider using `{}`", formulation.correction),
                                     );
                                 }
                                 return;
-- 
cgit 1.4.1-3-g733a5


From fd6e752f4e4fef715144b360fb7e29b4f3d10df9 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Sat, 20 Jan 2024 16:57:43 +0100
Subject: Move `has_non_exhaustive_attr` function into `clippy_utils`

---
 clippy_lints/src/derive.rs | 19 ++++---------------
 clippy_utils/src/attrs.rs  | 12 ++++++++++++
 2 files changed, 16 insertions(+), 15 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/derive.rs b/clippy_lints/src/derive.rs
index aab2550ba6e..081cbcb770f 100644
--- a/clippy_lints/src/derive.rs
+++ b/clippy_lints/src/derive.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_note, span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::ty::{implements_trait, implements_trait_with_env, is_copy};
-use clippy_utils::{is_lint_allowed, match_def_path, paths};
+use clippy_utils::{has_non_exhaustive_attr, is_lint_allowed, match_def_path, paths};
 use rustc_errors::Applicability;
 use rustc_hir::def_id::DefId;
 use rustc_hir::intravisit::{walk_expr, walk_fn, walk_item, FnKind, Visitor};
@@ -11,8 +11,8 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::nested_filter;
 use rustc_middle::traits::Reveal;
 use rustc_middle::ty::{
-    self, AdtDef, ClauseKind, GenericArgKind, GenericParamDefKind, ImplPolarity, ParamEnv, ToPredicate, TraitPredicate,
-    Ty, TyCtxt,
+    self, ClauseKind, GenericArgKind, GenericParamDefKind, ImplPolarity, ParamEnv, ToPredicate, TraitPredicate, Ty,
+    TyCtxt,
 };
 use rustc_session::declare_lint_pass;
 use rustc_span::def_id::LocalDefId;
@@ -442,17 +442,6 @@ impl<'tcx> Visitor<'tcx> for UnsafeVisitor<'_, 'tcx> {
     }
 }
 
-fn has_non_exhaustive_attr(cx: &LateContext<'_>, adt: AdtDef<'_>) -> bool {
-    adt.is_variant_list_non_exhaustive()
-        || cx.tcx.has_attr(adt.did(), sym::non_exhaustive)
-        || adt.variants().iter().any(|variant_def| {
-            variant_def.is_field_list_non_exhaustive() || cx.tcx.has_attr(variant_def.def_id, sym::non_exhaustive)
-        })
-        || adt
-            .all_fields()
-            .any(|field_def| cx.tcx.has_attr(field_def.did, sym::non_exhaustive))
-}
-
 /// Implementation of the `DERIVE_PARTIAL_EQ_WITHOUT_EQ` lint.
 fn check_partial_eq_without_eq<'tcx>(cx: &LateContext<'tcx>, span: Span, trait_ref: &hir::TraitRef<'_>, ty: Ty<'tcx>) {
     if let ty::Adt(adt, args) = ty.kind()
@@ -460,7 +449,7 @@ fn check_partial_eq_without_eq<'tcx>(cx: &LateContext<'tcx>, span: Span, trait_r
         && let Some(eq_trait_def_id) = cx.tcx.get_diagnostic_item(sym::Eq)
         && let Some(def_id) = trait_ref.trait_def_id()
         && cx.tcx.is_diagnostic_item(sym::PartialEq, def_id)
-        && !has_non_exhaustive_attr(cx, *adt)
+        && !has_non_exhaustive_attr(cx.tcx, *adt)
         && let param_env = param_env_for_derived_eq(cx.tcx, adt.did(), eq_trait_def_id)
         && !implements_trait_with_env(cx.tcx, param_env, ty, eq_trait_def_id, adt.did(),&[])
         // If all of our fields implement `Eq`, we can implement `Eq` too
diff --git a/clippy_utils/src/attrs.rs b/clippy_utils/src/attrs.rs
index ad8619f0d3d..2d0c2cf1253 100644
--- a/clippy_utils/src/attrs.rs
+++ b/clippy_utils/src/attrs.rs
@@ -1,5 +1,6 @@
 use rustc_ast::{ast, attr};
 use rustc_errors::Applicability;
+use rustc_middle::ty::{AdtDef, TyCtxt};
 use rustc_session::Session;
 use rustc_span::sym;
 use std::str::FromStr;
@@ -159,3 +160,14 @@ pub fn is_doc_hidden(attrs: &[ast::Attribute]) -> bool {
         .filter_map(ast::Attribute::meta_item_list)
         .any(|l| attr::list_contains_name(&l, sym::hidden))
 }
+
+pub fn has_non_exhaustive_attr(tcx: TyCtxt<'_>, adt: AdtDef<'_>) -> bool {
+    adt.is_variant_list_non_exhaustive()
+        || tcx.has_attr(adt.did(), sym::non_exhaustive)
+        || adt.variants().iter().any(|variant_def| {
+            variant_def.is_field_list_non_exhaustive() || tcx.has_attr(variant_def.def_id, sym::non_exhaustive)
+        })
+        || adt
+            .all_fields()
+            .any(|field_def| tcx.has_attr(field_def.did, sym::non_exhaustive))
+}
-- 
cgit 1.4.1-3-g733a5


From f73879e096301b921cc763c15f7020ff72736988 Mon Sep 17 00:00:00 2001
From: Quinn Sinclair <me@partiallytyped.dev>
Date: Thu, 21 Dec 2023 13:26:46 +0200
Subject: `unused_io_amount` captures `Ok(_)`s

Partial rewrite of `unused_io_account` to lint over Ok(_).

Moved the check to `check_block` to simplify context checking for
expressions and allow us to check only some expressions.

For match (expr, arms) we emit a lint for io ops used on `expr` when an
arm is `Ok(_)`. Also considers the cases when there are guards in the
arms. It also captures `if let Ok(_) = ...` cases.

For `Ok(_)` it emits a note indicating where the value is ignored.

changelog: False Negatives [`unused_io_amount`]: Extended
`unused_io_amount` to catch `Ok(_)`s in `If let` and match exprs.
---
 clippy_lints/src/unused_io_amount.rs | 292 +++++++++++++++++++++++------------
 tests/ui/unused_io_amount.rs         |  87 +++++++++++
 tests/ui/unused_io_amount.stderr     | 141 ++++++++++++++---
 3 files changed, 400 insertions(+), 120 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unused_io_amount.rs b/clippy_lints/src/unused_io_amount.rs
index 1de9adfcb96..adc66e15ff5 100644
--- a/clippy_lints/src/unused_io_amount.rs
+++ b/clippy_lints/src/unused_io_amount.rs
@@ -1,9 +1,10 @@
-use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
-use clippy_utils::{is_trait_method, is_try, match_trait_method, paths};
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::{is_res_lang_ctor, is_trait_method, match_trait_method, paths};
+use hir::{ExprKind, PatKind};
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::declare_lint_pass;
-use rustc_span::sym;
+use rustc_span::{sym, Span};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -45,126 +46,219 @@ declare_clippy_lint! {
 
 declare_lint_pass!(UnusedIoAmount => [UNUSED_IO_AMOUNT]);
 
+#[derive(Copy, Clone)]
+enum IoOp {
+    AsyncWrite(bool),
+    AsyncRead(bool),
+    SyncRead(bool),
+    SyncWrite(bool),
+}
+
 impl<'tcx> LateLintPass<'tcx> for UnusedIoAmount {
-    fn check_stmt(&mut self, cx: &LateContext<'_>, s: &hir::Stmt<'_>) {
-        let (hir::StmtKind::Semi(expr) | hir::StmtKind::Expr(expr)) = s.kind else {
-            return;
-        };
+    /// We perform the check on the block level.
+    /// If we want to catch match and if expressions that act as returns of the block
+    ///   we need to check them at `check_expr` or `check_block` as they are not stmts
+    ///   but we can't check them at `check_expr` because we need the broader context
+    ///   because we should do this only for the final expression of the block, and not for
+    ///   `StmtKind::Local` which binds values => the io amount is used.
+    ///
+    /// To check for unused io amount in stmts, we only consider `StmtKind::Semi`.
+    /// `StmtKind::Local` is not considered because it binds values => the io amount is used.
+    /// `StmtKind::Expr` is not considered because requires unit type => the io amount is used.
+    /// `StmtKind::Item` is not considered because it's not an expression.
+    ///
+    /// We then check the individual expressions via `check_expr`. We use the same logic for
+    /// semi expressions and the final expression as we need to check match and if expressions
+    /// for binding of the io amount to `Ok(_)`.
+    ///
+    /// We explicitly check for the match source to be Normal as it needs special logic
+    /// to consider the arms, and we want to avoid breaking the logic for situations where things
+    /// get desugared to match.
+    fn check_block(&mut self, cx: &LateContext<'tcx>, block: &'tcx hir::Block<'tcx>) {
+        for stmt in block.stmts {
+            if let hir::StmtKind::Semi(exp) = stmt.kind {
+                check_expr(cx, exp);
+            }
+        }
 
-        match expr.kind {
-            hir::ExprKind::Match(res, _, _) if is_try(cx, expr).is_some() => {
-                if let hir::ExprKind::Call(func, [ref arg_0, ..]) = res.kind {
-                    if matches!(
-                        func.kind,
-                        hir::ExprKind::Path(hir::QPath::LangItem(hir::LangItem::TryTraitBranch, ..))
-                    ) {
-                        check_map_error(cx, arg_0, expr);
+        if let Some(exp) = block.expr
+            && matches!(exp.kind, hir::ExprKind::If(_, _, _) | hir::ExprKind::Match(_, _, _))
+        {
+            check_expr(cx, exp);
+        }
+    }
+}
+
+fn check_expr<'a>(cx: &LateContext<'a>, expr: &'a hir::Expr<'a>) {
+    match expr.kind {
+        hir::ExprKind::If(cond, _, _)
+            if let ExprKind::Let(hir::Let { pat, init, .. }) = cond.kind
+                && pattern_is_ignored_ok(cx, pat)
+                && let Some(op) = should_lint(cx, init) =>
+        {
+            emit_lint(cx, cond.span, op, &[pat.span]);
+        },
+        hir::ExprKind::Match(expr, arms, hir::MatchSource::Normal) if let Some(op) = should_lint(cx, expr) => {
+            let found_arms: Vec<_> = arms
+                .iter()
+                .filter_map(|arm| {
+                    if pattern_is_ignored_ok(cx, arm.pat) {
+                        Some(arm.span)
+                    } else {
+                        None
                     }
-                } else {
-                    check_map_error(cx, res, expr);
-                }
-            },
-            hir::ExprKind::MethodCall(path, arg_0, ..) => match path.ident.as_str() {
-                "expect" | "unwrap" | "unwrap_or" | "unwrap_or_else" | "is_ok" | "is_err" => {
-                    check_map_error(cx, arg_0, expr);
-                },
-                _ => (),
-            },
-            _ => (),
+                })
+                .collect();
+            if !found_arms.is_empty() {
+                emit_lint(cx, expr.span, op, found_arms.as_slice());
+            }
+        },
+        _ if let Some(op) = should_lint(cx, expr) => {
+            emit_lint(cx, expr.span, op, &[]);
+        },
+        _ => {},
+    };
+}
+
+fn should_lint<'a>(cx: &LateContext<'a>, mut inner: &'a hir::Expr<'a>) -> Option<IoOp> {
+    inner = unpack_match(inner);
+    inner = unpack_try(inner);
+    inner = unpack_call_chain(inner);
+    inner = unpack_await(inner);
+    // we type-check it to get whether it's a read/write or their vectorized forms
+    // and keep only the ones that are produce io amount
+    check_io_mode(cx, inner)
+}
+
+fn pattern_is_ignored_ok(cx: &LateContext<'_>, pat: &hir::Pat<'_>) -> bool {
+    // the if checks whether we are in a result Ok( ) pattern
+    // and the return checks whether it is unhandled
+
+    if let PatKind::TupleStruct(ref path, inner_pat, ddp) = pat.kind
+        // we check against Result::Ok to avoid linting on Err(_) or something else.
+        && is_res_lang_ctor(cx, cx.qpath_res(path, pat.hir_id), hir::LangItem::ResultOk)
+    {
+        return match (inner_pat, ddp.as_opt_usize()) {
+            // Ok(_) pattern
+            ([inner_pat], None) if matches!(inner_pat.kind, PatKind::Wild) => true,
+            // Ok(..) pattern
+            ([], Some(0)) => true,
+            _ => false,
+        };
+    }
+    false
+}
+
+fn unpack_call_chain<'a>(mut expr: &'a hir::Expr<'a>) -> &'a hir::Expr<'a> {
+    while let hir::ExprKind::MethodCall(path, receiver, ..) = expr.kind {
+        if matches!(
+            path.ident.as_str(),
+            "unwrap" | "expect" | "unwrap_or" | "unwrap_or_else" | "ok" | "is_ok" | "is_err" | "or_else" | "or"
+        ) {
+            expr = receiver;
+        } else {
+            break;
         }
     }
+    expr
+}
+
+fn unpack_try<'a>(mut expr: &'a hir::Expr<'a>) -> &'a hir::Expr<'a> {
+    while let hir::ExprKind::Call(func, [ref arg_0, ..]) = expr.kind
+        && matches!(
+            func.kind,
+            hir::ExprKind::Path(hir::QPath::LangItem(hir::LangItem::TryTraitBranch, ..))
+        )
+    {
+        expr = arg_0;
+    }
+    expr
+}
+
+fn unpack_match<'a>(mut expr: &'a hir::Expr<'a>) -> &'a hir::Expr<'a> {
+    while let hir::ExprKind::Match(res, _, _) = expr.kind {
+        expr = res;
+    }
+    expr
 }
 
 /// If `expr` is an (e).await, return the inner expression "e" that's being
 /// waited on.  Otherwise return None.
-fn try_remove_await<'a>(expr: &'a hir::Expr<'a>) -> Option<&hir::Expr<'a>> {
+fn unpack_await<'a>(expr: &'a hir::Expr<'a>) -> &hir::Expr<'a> {
     if let hir::ExprKind::Match(expr, _, hir::MatchSource::AwaitDesugar) = expr.kind {
         if let hir::ExprKind::Call(func, [ref arg_0, ..]) = expr.kind {
             if matches!(
                 func.kind,
                 hir::ExprKind::Path(hir::QPath::LangItem(hir::LangItem::IntoFutureIntoFuture, ..))
             ) {
-                return Some(arg_0);
+                return arg_0;
             }
         }
     }
-
-    None
+    expr
 }
 
-fn check_map_error(cx: &LateContext<'_>, call: &hir::Expr<'_>, expr: &hir::Expr<'_>) {
-    let mut call = call;
-    while let hir::ExprKind::MethodCall(path, receiver, ..) = call.kind {
-        if matches!(path.ident.as_str(), "or" | "or_else" | "ok") {
-            call = receiver;
-        } else {
-            break;
-        }
-    }
+/// Check whether the current expr is a function call for an IO operation
+fn check_io_mode(cx: &LateContext<'_>, call: &hir::Expr<'_>) -> Option<IoOp> {
+    let hir::ExprKind::MethodCall(path, ..) = call.kind else {
+        return None;
+    };
 
-    if let Some(call) = try_remove_await(call) {
-        check_method_call(cx, call, expr, true);
-    } else {
-        check_method_call(cx, call, expr, false);
+    let vectorized = match path.ident.as_str() {
+        "write_vectored" | "read_vectored" => true,
+        "write" | "read" => false,
+        _ => {
+            return None;
+        },
+    };
+
+    match (
+        is_trait_method(cx, call, sym::IoRead),
+        is_trait_method(cx, call, sym::IoWrite),
+        match_trait_method(cx, call, &paths::FUTURES_IO_ASYNCREADEXT)
+            || match_trait_method(cx, call, &paths::TOKIO_IO_ASYNCREADEXT),
+        match_trait_method(cx, call, &paths::TOKIO_IO_ASYNCWRITEEXT)
+            || match_trait_method(cx, call, &paths::FUTURES_IO_ASYNCWRITEEXT),
+    ) {
+        (true, _, _, _) => Some(IoOp::SyncRead(vectorized)),
+        (_, true, _, _) => Some(IoOp::SyncWrite(vectorized)),
+        (_, _, true, _) => Some(IoOp::AsyncRead(vectorized)),
+        (_, _, _, true) => Some(IoOp::AsyncWrite(vectorized)),
+        _ => None,
     }
 }
 
-fn check_method_call(cx: &LateContext<'_>, call: &hir::Expr<'_>, expr: &hir::Expr<'_>, is_await: bool) {
-    if let hir::ExprKind::MethodCall(path, ..) = call.kind {
-        let symbol = path.ident.as_str();
-        let read_trait = if is_await {
-            match_trait_method(cx, call, &paths::FUTURES_IO_ASYNCREADEXT)
-                || match_trait_method(cx, call, &paths::TOKIO_IO_ASYNCREADEXT)
-        } else {
-            is_trait_method(cx, call, sym::IoRead)
-        };
-        let write_trait = if is_await {
-            match_trait_method(cx, call, &paths::FUTURES_IO_ASYNCWRITEEXT)
-                || match_trait_method(cx, call, &paths::TOKIO_IO_ASYNCWRITEEXT)
-        } else {
-            is_trait_method(cx, call, sym::IoWrite)
-        };
+fn emit_lint(cx: &LateContext<'_>, span: Span, op: IoOp, wild_cards: &[Span]) {
+    let (msg, help) = match op {
+        IoOp::AsyncRead(false) => (
+            "read amount is not handled",
+            Some("use `AsyncReadExt::read_exact` instead, or handle partial reads"),
+        ),
+        IoOp::SyncRead(false) => (
+            "read amount is not handled",
+            Some("use `Read::read_exact` instead, or handle partial reads"),
+        ),
+        IoOp::SyncWrite(false) => (
+            "written amount is not handled",
+            Some("use `Write::write_all` instead, or handle partial writes"),
+        ),
+        IoOp::AsyncWrite(false) => (
+            "written amount is not handled",
+            Some("use `AsyncWriteExt::write_all` instead, or handle partial writes"),
+        ),
+        IoOp::SyncRead(true) | IoOp::AsyncRead(true) => ("read amount is not handled", None),
+        IoOp::SyncWrite(true) | IoOp::AsyncWrite(true) => ("written amount is not handled", None),
+    };
 
-        match (read_trait, write_trait, symbol, is_await) {
-            (true, _, "read", false) => span_lint_and_help(
-                cx,
-                UNUSED_IO_AMOUNT,
-                expr.span,
-                "read amount is not handled",
-                None,
-                "use `Read::read_exact` instead, or handle partial reads",
-            ),
-            (true, _, "read", true) => span_lint_and_help(
-                cx,
-                UNUSED_IO_AMOUNT,
-                expr.span,
-                "read amount is not handled",
-                None,
-                "use `AsyncReadExt::read_exact` instead, or handle partial reads",
-            ),
-            (true, _, "read_vectored", _) => {
-                span_lint(cx, UNUSED_IO_AMOUNT, expr.span, "read amount is not handled");
-            },
-            (_, true, "write", false) => span_lint_and_help(
-                cx,
-                UNUSED_IO_AMOUNT,
-                expr.span,
-                "written amount is not handled",
-                None,
-                "use `Write::write_all` instead, or handle partial writes",
-            ),
-            (_, true, "write", true) => span_lint_and_help(
-                cx,
-                UNUSED_IO_AMOUNT,
-                expr.span,
-                "written amount is not handled",
-                None,
-                "use `AsyncWriteExt::write_all` instead, or handle partial writes",
-            ),
-            (_, true, "write_vectored", _) => {
-                span_lint(cx, UNUSED_IO_AMOUNT, expr.span, "written amount is not handled");
-            },
-            _ => (),
+    span_lint_and_then(cx, UNUSED_IO_AMOUNT, span, msg, |diag| {
+        if let Some(help_str) = help {
+            diag.help(help_str);
         }
-    }
+        for span in wild_cards {
+            diag.span_note(
+                *span,
+                "the result is consumed here, but the amount of I/O bytes remains unhandled",
+            );
+        }
+    });
 }
diff --git a/tests/ui/unused_io_amount.rs b/tests/ui/unused_io_amount.rs
index 62aec6e9eaf..9974600dad5 100644
--- a/tests/ui/unused_io_amount.rs
+++ b/tests/ui/unused_io_amount.rs
@@ -1,4 +1,5 @@
 #![allow(dead_code, clippy::needless_pass_by_ref_mut)]
+#![allow(clippy::redundant_pattern_matching)]
 #![warn(clippy::unused_io_amount)]
 
 extern crate futures;
@@ -142,4 +143,90 @@ async fn undetected_bad_async_write<W: AsyncWrite + Unpin>(w: &mut W) {
     future.await.unwrap();
 }
 
+fn match_okay_underscore<T: io::Read + io::Write>(s: &mut T) {
+    match s.write(b"test") {
+        //~^ ERROR: written amount is not handled
+        Ok(_) => todo!(),
+        //~^ NOTE: the result is consumed here, but the amount of I/O bytes remains unhandled
+        Err(_) => todo!(),
+    };
+
+    let mut buf = [0u8; 4];
+    match s.read(&mut buf) {
+        //~^ ERROR: read amount is not handled
+        Ok(_) => todo!(),
+        //~^ NOTE: the result is consumed here, but the amount of I/O bytes remains unhandled
+        Err(_) => todo!(),
+    }
+}
+
+fn match_okay_underscore_read_expr<T: io::Read + io::Write>(s: &mut T) {
+    match s.read(&mut [0u8; 4]) {
+        //~^ ERROR: read amount is not handled
+        Ok(_) => todo!(),
+        //~^ NOTE: the result is consumed here, but the amount of I/O bytes remains unhandled
+        Err(_) => todo!(),
+    }
+}
+
+fn match_okay_underscore_write_expr<T: io::Read + io::Write>(s: &mut T) {
+    match s.write(b"test") {
+        //~^ ERROR: written amount is not handled
+        Ok(_) => todo!(),
+        //~^ NOTE: the result is consumed here, but the amount of I/O bytes remains unhandled
+        Err(_) => todo!(),
+    }
+}
+
+fn returned_value_should_not_lint<T: io::Read + io::Write>(s: &mut T) -> Result<usize, std::io::Error> {
+    s.write(b"test")
+}
+
+fn if_okay_underscore_read_expr<T: io::Read + io::Write>(s: &mut T) {
+    if let Ok(_) = s.read(&mut [0u8; 4]) {
+        //~^ ERROR: read amount is not handled
+        todo!()
+    }
+}
+
+fn if_okay_underscore_write_expr<T: io::Read + io::Write>(s: &mut T) {
+    if let Ok(_) = s.write(b"test") {
+        //~^ ERROR: written amount is not handled
+        todo!()
+    }
+}
+
+fn if_okay_dots_write_expr<T: io::Read + io::Write>(s: &mut T) {
+    if let Ok(..) = s.write(b"test") {
+        //~^ ERROR: written amount is not handled
+        todo!()
+    }
+}
+
+fn if_okay_underscore_write_expr_true_negative<T: io::Read + io::Write>(s: &mut T) {
+    if let Ok(bound) = s.write(b"test") {
+        todo!()
+    }
+}
+
+fn match_okay_underscore_true_neg<T: io::Read + io::Write>(s: &mut T) {
+    match s.write(b"test") {
+        Ok(bound) => todo!(),
+        Err(_) => todo!(),
+    };
+}
+
+fn true_negative<T: io::Read + io::Write>(s: &mut T) {
+    let mut buf = [0u8; 4];
+    let read_amount = s.read(&mut buf).unwrap();
+}
+
+fn on_return_should_not_raise<T: io::Read + io::Write>(s: &mut T) -> io::Result<usize> {
+    /// this is bad code because it goes around the problem of handling the read amount
+    /// by returning it, which makes it impossible to know this is a resonpose from the
+    /// correct account.
+    let mut buf = [0u8; 4];
+    s.read(&mut buf)
+}
+
 fn main() {}
diff --git a/tests/ui/unused_io_amount.stderr b/tests/ui/unused_io_amount.stderr
index f9aef596a1c..4af56d264bf 100644
--- a/tests/ui/unused_io_amount.stderr
+++ b/tests/ui/unused_io_amount.stderr
@@ -1,5 +1,5 @@
 error: written amount is not handled
-  --> $DIR/unused_io_amount.rs:9:5
+  --> $DIR/unused_io_amount.rs:10:5
    |
 LL |     s.write(b"test")?;
    |     ^^^^^^^^^^^^^^^^^
@@ -9,7 +9,7 @@ LL |     s.write(b"test")?;
    = help: to override `-D warnings` add `#[allow(clippy::unused_io_amount)]`
 
 error: read amount is not handled
-  --> $DIR/unused_io_amount.rs:12:5
+  --> $DIR/unused_io_amount.rs:13:5
    |
 LL |     s.read(&mut buf)?;
    |     ^^^^^^^^^^^^^^^^^
@@ -17,7 +17,7 @@ LL |     s.read(&mut buf)?;
    = help: use `Read::read_exact` instead, or handle partial reads
 
 error: written amount is not handled
-  --> $DIR/unused_io_amount.rs:18:5
+  --> $DIR/unused_io_amount.rs:19:5
    |
 LL |     s.write(b"test").unwrap();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -25,7 +25,7 @@ LL |     s.write(b"test").unwrap();
    = help: use `Write::write_all` instead, or handle partial writes
 
 error: read amount is not handled
-  --> $DIR/unused_io_amount.rs:21:5
+  --> $DIR/unused_io_amount.rs:22:5
    |
 LL |     s.read(&mut buf).unwrap();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -33,19 +33,19 @@ LL |     s.read(&mut buf).unwrap();
    = help: use `Read::read_exact` instead, or handle partial reads
 
 error: read amount is not handled
-  --> $DIR/unused_io_amount.rs:26:5
+  --> $DIR/unused_io_amount.rs:27:5
    |
 LL |     s.read_vectored(&mut [io::IoSliceMut::new(&mut [])])?;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: written amount is not handled
-  --> $DIR/unused_io_amount.rs:28:5
+  --> $DIR/unused_io_amount.rs:29:5
    |
 LL |     s.write_vectored(&[io::IoSlice::new(&[])])?;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: read amount is not handled
-  --> $DIR/unused_io_amount.rs:36:5
+  --> $DIR/unused_io_amount.rs:37:5
    |
 LL |     reader.read(&mut result).ok()?;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -53,7 +53,7 @@ LL |     reader.read(&mut result).ok()?;
    = help: use `Read::read_exact` instead, or handle partial reads
 
 error: read amount is not handled
-  --> $DIR/unused_io_amount.rs:46:5
+  --> $DIR/unused_io_amount.rs:47:5
    |
 LL |     reader.read(&mut result).or_else(|err| Err(err))?;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -61,7 +61,7 @@ LL |     reader.read(&mut result).or_else(|err| Err(err))?;
    = help: use `Read::read_exact` instead, or handle partial reads
 
 error: read amount is not handled
-  --> $DIR/unused_io_amount.rs:59:5
+  --> $DIR/unused_io_amount.rs:60:5
    |
 LL |     reader.read(&mut result).or(Err(Error::Kind))?;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -69,7 +69,7 @@ LL |     reader.read(&mut result).or(Err(Error::Kind))?;
    = help: use `Read::read_exact` instead, or handle partial reads
 
 error: read amount is not handled
-  --> $DIR/unused_io_amount.rs:67:5
+  --> $DIR/unused_io_amount.rs:68:5
    |
 LL | /     reader
 LL | |
@@ -82,7 +82,7 @@ LL | |         .expect("error");
    = help: use `Read::read_exact` instead, or handle partial reads
 
 error: written amount is not handled
-  --> $DIR/unused_io_amount.rs:77:5
+  --> $DIR/unused_io_amount.rs:78:5
    |
 LL |     s.write(b"ok").is_ok();
    |     ^^^^^^^^^^^^^^^^^^^^^^
@@ -90,7 +90,7 @@ LL |     s.write(b"ok").is_ok();
    = help: use `Write::write_all` instead, or handle partial writes
 
 error: written amount is not handled
-  --> $DIR/unused_io_amount.rs:79:5
+  --> $DIR/unused_io_amount.rs:80:5
    |
 LL |     s.write(b"err").is_err();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -98,7 +98,7 @@ LL |     s.write(b"err").is_err();
    = help: use `Write::write_all` instead, or handle partial writes
 
 error: read amount is not handled
-  --> $DIR/unused_io_amount.rs:82:5
+  --> $DIR/unused_io_amount.rs:83:5
    |
 LL |     s.read(&mut buf).is_ok();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -106,7 +106,7 @@ LL |     s.read(&mut buf).is_ok();
    = help: use `Read::read_exact` instead, or handle partial reads
 
 error: read amount is not handled
-  --> $DIR/unused_io_amount.rs:84:5
+  --> $DIR/unused_io_amount.rs:85:5
    |
 LL |     s.read(&mut buf).is_err();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -114,7 +114,7 @@ LL |     s.read(&mut buf).is_err();
    = help: use `Read::read_exact` instead, or handle partial reads
 
 error: written amount is not handled
-  --> $DIR/unused_io_amount.rs:89:5
+  --> $DIR/unused_io_amount.rs:90:5
    |
 LL |     w.write(b"hello world").await.unwrap();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -122,7 +122,7 @@ LL |     w.write(b"hello world").await.unwrap();
    = help: use `AsyncWriteExt::write_all` instead, or handle partial writes
 
 error: read amount is not handled
-  --> $DIR/unused_io_amount.rs:95:5
+  --> $DIR/unused_io_amount.rs:96:5
    |
 LL |     r.read(&mut buf[..]).await.unwrap();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -130,7 +130,15 @@ LL |     r.read(&mut buf[..]).await.unwrap();
    = help: use `AsyncReadExt::read_exact` instead, or handle partial reads
 
 error: written amount is not handled
-  --> $DIR/unused_io_amount.rs:109:9
+  --> $DIR/unused_io_amount.rs:104:5
+   |
+LL |     w.write(b"hello world");
+   |     ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use `AsyncWriteExt::write_all` instead, or handle partial writes
+
+error: written amount is not handled
+  --> $DIR/unused_io_amount.rs:110:9
    |
 LL |         w.write(b"hello world").await?;
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -138,7 +146,7 @@ LL |         w.write(b"hello world").await?;
    = help: use `AsyncWriteExt::write_all` instead, or handle partial writes
 
 error: read amount is not handled
-  --> $DIR/unused_io_amount.rs:118:9
+  --> $DIR/unused_io_amount.rs:119:9
    |
 LL |         r.read(&mut buf[..]).await.or(Err(Error::Kind))?;
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -146,7 +154,7 @@ LL |         r.read(&mut buf[..]).await.or(Err(Error::Kind))?;
    = help: use `AsyncReadExt::read_exact` instead, or handle partial reads
 
 error: written amount is not handled
-  --> $DIR/unused_io_amount.rs:127:5
+  --> $DIR/unused_io_amount.rs:128:5
    |
 LL |     w.write(b"hello world").await.unwrap();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -154,12 +162,103 @@ LL |     w.write(b"hello world").await.unwrap();
    = help: use `AsyncWriteExt::write_all` instead, or handle partial writes
 
 error: read amount is not handled
-  --> $DIR/unused_io_amount.rs:133:5
+  --> $DIR/unused_io_amount.rs:134:5
    |
 LL |     r.read(&mut buf[..]).await.unwrap();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: use `AsyncReadExt::read_exact` instead, or handle partial reads
 
-error: aborting due to 20 previous errors
+error: written amount is not handled
+  --> $DIR/unused_io_amount.rs:147:11
+   |
+LL |     match s.write(b"test") {
+   |           ^^^^^^^^^^^^^^^^
+   |
+   = help: use `Write::write_all` instead, or handle partial writes
+note: the result is consumed here, but the amount of I/O bytes remains unhandled
+  --> $DIR/unused_io_amount.rs:149:9
+   |
+LL |         Ok(_) => todo!(),
+   |         ^^^^^^^^^^^^^^^^
+
+error: read amount is not handled
+  --> $DIR/unused_io_amount.rs:155:11
+   |
+LL |     match s.read(&mut buf) {
+   |           ^^^^^^^^^^^^^^^^
+   |
+   = help: use `Read::read_exact` instead, or handle partial reads
+note: the result is consumed here, but the amount of I/O bytes remains unhandled
+  --> $DIR/unused_io_amount.rs:157:9
+   |
+LL |         Ok(_) => todo!(),
+   |         ^^^^^^^^^^^^^^^^
+
+error: read amount is not handled
+  --> $DIR/unused_io_amount.rs:164:11
+   |
+LL |     match s.read(&mut [0u8; 4]) {
+   |           ^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use `Read::read_exact` instead, or handle partial reads
+note: the result is consumed here, but the amount of I/O bytes remains unhandled
+  --> $DIR/unused_io_amount.rs:166:9
+   |
+LL |         Ok(_) => todo!(),
+   |         ^^^^^^^^^^^^^^^^
+
+error: written amount is not handled
+  --> $DIR/unused_io_amount.rs:173:11
+   |
+LL |     match s.write(b"test") {
+   |           ^^^^^^^^^^^^^^^^
+   |
+   = help: use `Write::write_all` instead, or handle partial writes
+note: the result is consumed here, but the amount of I/O bytes remains unhandled
+  --> $DIR/unused_io_amount.rs:175:9
+   |
+LL |         Ok(_) => todo!(),
+   |         ^^^^^^^^^^^^^^^^
+
+error: read amount is not handled
+  --> $DIR/unused_io_amount.rs:186:8
+   |
+LL |     if let Ok(_) = s.read(&mut [0u8; 4]) {
+   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use `Read::read_exact` instead, or handle partial reads
+note: the result is consumed here, but the amount of I/O bytes remains unhandled
+  --> $DIR/unused_io_amount.rs:186:12
+   |
+LL |     if let Ok(_) = s.read(&mut [0u8; 4]) {
+   |            ^^^^^
+
+error: written amount is not handled
+  --> $DIR/unused_io_amount.rs:193:8
+   |
+LL |     if let Ok(_) = s.write(b"test") {
+   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use `Write::write_all` instead, or handle partial writes
+note: the result is consumed here, but the amount of I/O bytes remains unhandled
+  --> $DIR/unused_io_amount.rs:193:12
+   |
+LL |     if let Ok(_) = s.write(b"test") {
+   |            ^^^^^
+
+error: written amount is not handled
+  --> $DIR/unused_io_amount.rs:200:8
+   |
+LL |     if let Ok(..) = s.write(b"test") {
+   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use `Write::write_all` instead, or handle partial writes
+note: the result is consumed here, but the amount of I/O bytes remains unhandled
+  --> $DIR/unused_io_amount.rs:200:12
+   |
+LL |     if let Ok(..) = s.write(b"test") {
+   |            ^^^^^^
+
+error: aborting due to 28 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 95a084f2eb24465cc9bed7f3998ae7f7076f833a Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Sun, 21 Jan 2024 03:21:54 +0100
Subject: [`multiple_crate_versions`]: add a configuration option for allowed
 duplicate dependencies

---
 CHANGELOG.md                                                   |  1 +
 book/src/lint_configuration.md                                 | 10 ++++++++++
 clippy_config/src/conf.rs                                      |  4 ++++
 clippy_lints/src/cargo/mod.rs                                  |  6 +++++-
 clippy_lints/src/cargo/multiple_crate_versions.rs              |  9 +++++++--
 clippy_lints/src/lib.rs                                        |  2 ++
 .../12176_allow_duplicate_crates/Cargo.toml                    | 10 ++++++++++
 .../12176_allow_duplicate_crates/clippy.toml                   |  1 +
 .../12176_allow_duplicate_crates/src/main.rs                   |  3 +++
 tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr         |  2 ++
 10 files changed, 45 insertions(+), 3 deletions(-)
 create mode 100644 tests/ui-cargo/multiple_crate_versions/12176_allow_duplicate_crates/Cargo.toml
 create mode 100644 tests/ui-cargo/multiple_crate_versions/12176_allow_duplicate_crates/clippy.toml
 create mode 100644 tests/ui-cargo/multiple_crate_versions/12176_allow_duplicate_crates/src/main.rs

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index db4b4c2aef6..5fa45ceeb39 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5815,6 +5815,7 @@ Released 2018-09-13
 [`absolute-paths-max-segments`]: https://doc.rust-lang.org/clippy/lint_configuration.html#absolute-paths-max-segments
 [`absolute-paths-allowed-crates`]: https://doc.rust-lang.org/clippy/lint_configuration.html#absolute-paths-allowed-crates
 [`allowed-dotfiles`]: https://doc.rust-lang.org/clippy/lint_configuration.html#allowed-dotfiles
+[`allowed-duplicate-crates`]: https://doc.rust-lang.org/clippy/lint_configuration.html#allowed-duplicate-crates
 [`enforce-iter-loop-reborrow`]: https://doc.rust-lang.org/clippy/lint_configuration.html#enforce-iter-loop-reborrow
 [`check-private-items`]: https://doc.rust-lang.org/clippy/lint_configuration.html#check-private-items
 [`pub-underscore-fields-behavior`]: https://doc.rust-lang.org/clippy/lint_configuration.html#pub-underscore-fields-behavior
diff --git a/book/src/lint_configuration.md b/book/src/lint_configuration.md
index 32c19d851fe..7f7aff92bf1 100644
--- a/book/src/lint_configuration.md
+++ b/book/src/lint_configuration.md
@@ -768,6 +768,16 @@ Additional dotfiles (files or directories starting with a dot) to allow
 * [`path_ends_with_ext`](https://rust-lang.github.io/rust-clippy/master/index.html#path_ends_with_ext)
 
 
+## `allowed-duplicate-crates`
+A list of crate names to allow duplicates of
+
+**Default Value:** `[]`
+
+---
+**Affected lints:**
+* [`multiple_crate_versions`](https://rust-lang.github.io/rust-clippy/master/index.html#multiple_crate_versions)
+
+
 ## `enforce-iter-loop-reborrow`
 Whether to recommend using implicit into iter for reborrowed values.
 
diff --git a/clippy_config/src/conf.rs b/clippy_config/src/conf.rs
index 3ba7c564796..626b23f7309 100644
--- a/clippy_config/src/conf.rs
+++ b/clippy_config/src/conf.rs
@@ -523,6 +523,10 @@ define_Conf! {
     ///
     /// Additional dotfiles (files or directories starting with a dot) to allow
     (allowed_dotfiles: FxHashSet<String> = FxHashSet::default()),
+    /// Lint: MULTIPLE_CRATE_VERSIONS.
+    ///
+    /// A list of crate names to allow duplicates of
+    (allowed_duplicate_crates: FxHashSet<String> = FxHashSet::default()),
     /// Lint: EXPLICIT_ITER_LOOP.
     ///
     /// Whether to recommend using implicit into iter for reborrowed values.
diff --git a/clippy_lints/src/cargo/mod.rs b/clippy_lints/src/cargo/mod.rs
index fea6924d89e..d8107f61f37 100644
--- a/clippy_lints/src/cargo/mod.rs
+++ b/clippy_lints/src/cargo/mod.rs
@@ -6,6 +6,7 @@ mod wildcard_dependencies;
 use cargo_metadata::MetadataCommand;
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::is_lint_allowed;
+use rustc_data_structures::fx::FxHashSet;
 use rustc_hir::hir_id::CRATE_HIR_ID;
 use rustc_lint::{LateContext, LateLintPass, Lint};
 use rustc_session::impl_lint_pass;
@@ -128,6 +129,8 @@ declare_clippy_lint! {
     /// ### Known problems
     /// Because this can be caused purely by the dependencies
     /// themselves, it's not always possible to fix this issue.
+    /// In those cases, you can allow that specific crate using
+    /// the `allowed_duplicate_crates` configuration option.
     ///
     /// ### Example
     /// ```toml
@@ -163,6 +166,7 @@ declare_clippy_lint! {
 }
 
 pub struct Cargo {
+    pub allowed_duplicate_crates: FxHashSet<String>,
     pub ignore_publish: bool,
 }
 
@@ -208,7 +212,7 @@ impl LateLintPass<'_> for Cargo {
         {
             match MetadataCommand::new().exec() {
                 Ok(metadata) => {
-                    multiple_crate_versions::check(cx, &metadata);
+                    multiple_crate_versions::check(cx, &metadata, &self.allowed_duplicate_crates);
                 },
                 Err(e) => {
                     for lint in WITH_DEPS_LINTS {
diff --git a/clippy_lints/src/cargo/multiple_crate_versions.rs b/clippy_lints/src/cargo/multiple_crate_versions.rs
index 57b7b7497fe..3f30a77fcfe 100644
--- a/clippy_lints/src/cargo/multiple_crate_versions.rs
+++ b/clippy_lints/src/cargo/multiple_crate_versions.rs
@@ -3,13 +3,14 @@
 use cargo_metadata::{DependencyKind, Metadata, Node, Package, PackageId};
 use clippy_utils::diagnostics::span_lint;
 use itertools::Itertools;
+use rustc_data_structures::fx::FxHashSet;
 use rustc_hir::def_id::LOCAL_CRATE;
 use rustc_lint::LateContext;
 use rustc_span::DUMMY_SP;
 
 use super::MULTIPLE_CRATE_VERSIONS;
 
-pub(super) fn check(cx: &LateContext<'_>, metadata: &Metadata) {
+pub(super) fn check(cx: &LateContext<'_>, metadata: &Metadata, allowed_duplicate_crates: &FxHashSet<String>) {
     let local_name = cx.tcx.crate_name(LOCAL_CRATE);
     let mut packages = metadata.packages.clone();
     packages.sort_by(|a, b| a.name.cmp(&b.name));
@@ -31,7 +32,11 @@ pub(super) fn check(cx: &LateContext<'_>, metadata: &Metadata) {
             }
         })
     {
-        for (name, group) in &packages.iter().group_by(|p| p.name.clone()) {
+        for (name, group) in &packages
+            .iter()
+            .filter(|p| !allowed_duplicate_crates.contains(&p.name))
+            .group_by(|p| &p.name)
+        {
             let group: Vec<&Package> = group.collect();
 
             if group.len() <= 1 {
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 8004590e8e7..feb4d188f39 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -574,6 +574,7 @@ pub fn register_lints(store: &mut rustc_lint::LintStore, conf: &'static Conf) {
         warn_on_all_wildcard_imports,
         check_private_items,
         pub_underscore_fields_behavior,
+        ref allowed_duplicate_crates,
 
         blacklisted_names: _,
         cyclomatic_complexity_threshold: _,
@@ -947,6 +948,7 @@ pub fn register_lints(store: &mut rustc_lint::LintStore, conf: &'static Conf) {
     store.register_late_pass(move |_| {
         Box::new(cargo::Cargo {
             ignore_publish: cargo_ignore_publish,
+            allowed_duplicate_crates: allowed_duplicate_crates.clone(),
         })
     });
     store.register_early_pass(|| Box::new(crate_in_macro_def::CrateInMacroDef));
diff --git a/tests/ui-cargo/multiple_crate_versions/12176_allow_duplicate_crates/Cargo.toml b/tests/ui-cargo/multiple_crate_versions/12176_allow_duplicate_crates/Cargo.toml
new file mode 100644
index 00000000000..79317659ac0
--- /dev/null
+++ b/tests/ui-cargo/multiple_crate_versions/12176_allow_duplicate_crates/Cargo.toml
@@ -0,0 +1,10 @@
+[package]
+name = "multiple_crate_versions"
+version = "0.1.0"
+publish = false
+
+[workspace]
+
+[dependencies]
+winapi = "0.2"
+ansi_term = "=0.11.0"
diff --git a/tests/ui-cargo/multiple_crate_versions/12176_allow_duplicate_crates/clippy.toml b/tests/ui-cargo/multiple_crate_versions/12176_allow_duplicate_crates/clippy.toml
new file mode 100644
index 00000000000..121361de2fe
--- /dev/null
+++ b/tests/ui-cargo/multiple_crate_versions/12176_allow_duplicate_crates/clippy.toml
@@ -0,0 +1 @@
+allowed-duplicate-crates = ["winapi"]
diff --git a/tests/ui-cargo/multiple_crate_versions/12176_allow_duplicate_crates/src/main.rs b/tests/ui-cargo/multiple_crate_versions/12176_allow_duplicate_crates/src/main.rs
new file mode 100644
index 00000000000..4bc61dd6299
--- /dev/null
+++ b/tests/ui-cargo/multiple_crate_versions/12176_allow_duplicate_crates/src/main.rs
@@ -0,0 +1,3 @@
+#![warn(clippy::multiple_crate_versions)]
+
+fn main() {}
diff --git a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
index ed4fb84df1a..09fc9dfa463 100644
--- a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
+++ b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
@@ -11,6 +11,7 @@ error: error reading Clippy's configuration file: unknown field `foobar`, expect
            allow-private-module-inception
            allow-unwrap-in-tests
            allowed-dotfiles
+           allowed-duplicate-crates
            allowed-idents-below-min-chars
            allowed-scripts
            arithmetic-side-effects-allowed
@@ -87,6 +88,7 @@ error: error reading Clippy's configuration file: unknown field `barfoo`, expect
            allow-private-module-inception
            allow-unwrap-in-tests
            allowed-dotfiles
+           allowed-duplicate-crates
            allowed-idents-below-min-chars
            allowed-scripts
            arithmetic-side-effects-allowed
-- 
cgit 1.4.1-3-g733a5


From ad4d90b4a95887834ac93339ff388ed58cc8840d Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Sun, 21 Jan 2024 14:54:01 +0100
Subject: respect `#[allow]` attribute in `single_call_fn` lint

---
 clippy_lints/src/single_call_fn.rs | 12 +++++++-----
 tests/ui/single_call_fn.rs         | 11 +++++++++++
 2 files changed, 18 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/single_call_fn.rs b/clippy_lints/src/single_call_fn.rs
index 8e181c3ccc7..03877420774 100644
--- a/clippy_lints/src/single_call_fn.rs
+++ b/clippy_lints/src/single_call_fn.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::diagnostics::span_lint_hir_and_then;
 use clippy_utils::{is_from_proc_macro, is_in_test_function};
 use rustc_data_structures::fx::FxHashMap;
 use rustc_hir::def_id::LocalDefId;
@@ -88,16 +88,18 @@ impl<'tcx> LateLintPass<'tcx> for SingleCallFn {
         };
         cx.tcx.hir().visit_all_item_likes_in_crate(&mut v);
 
-        for usage in self.def_id_to_usage.values() {
+        for (&def_id, usage) in &self.def_id_to_usage {
             let single_call_fn_span = usage.0;
             if let [caller_span] = *usage.1 {
-                span_lint_and_help(
+                span_lint_hir_and_then(
                     cx,
                     SINGLE_CALL_FN,
+                    cx.tcx.local_def_id_to_hir_id(def_id),
                     single_call_fn_span,
                     "this function is only used once",
-                    Some(caller_span),
-                    "used here",
+                    |diag| {
+                        diag.span_help(caller_span, "used here");
+                    },
                 );
             }
         }
diff --git a/tests/ui/single_call_fn.rs b/tests/ui/single_call_fn.rs
index 3cc8061647d..c20214feccc 100644
--- a/tests/ui/single_call_fn.rs
+++ b/tests/ui/single_call_fn.rs
@@ -69,6 +69,17 @@ fn e() {
 #[test]
 fn k() {}
 
+mod issue12182 {
+    #[allow(clippy::single_call_fn)]
+    fn print_foo(text: &str) {
+        println!("{text}");
+    }
+
+    fn use_print_foo() {
+        print_foo("foo");
+    }
+}
+
 #[test]
 fn l() {
     k();
-- 
cgit 1.4.1-3-g733a5


From 3b8f62f85e4b671307afacdadbe374340ab68bab Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Thu, 18 Jan 2024 17:58:56 +0100
Subject: Add new `unnecessary_result_map_or_else` lint

---
 clippy_lints/src/declared_lints.rs                 |  1 +
 clippy_lints/src/methods/map_unwrap_or.rs          |  2 +-
 clippy_lints/src/methods/mod.rs                    | 28 +++++++
 .../src/methods/unnecessary_result_map_or_else.rs  | 95 ++++++++++++++++++++++
 4 files changed, 125 insertions(+), 1 deletion(-)
 create mode 100644 clippy_lints/src/methods/unnecessary_result_map_or_else.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 20230106d53..cab4647e08a 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -451,6 +451,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::methods::UNNECESSARY_JOIN_INFO,
     crate::methods::UNNECESSARY_LAZY_EVALUATIONS_INFO,
     crate::methods::UNNECESSARY_LITERAL_UNWRAP_INFO,
+    crate::methods::UNNECESSARY_RESULT_MAP_OR_ELSE_INFO,
     crate::methods::UNNECESSARY_SORT_BY_INFO,
     crate::methods::UNNECESSARY_TO_OWNED_INFO,
     crate::methods::UNWRAP_OR_DEFAULT_INFO,
diff --git a/clippy_lints/src/methods/map_unwrap_or.rs b/clippy_lints/src/methods/map_unwrap_or.rs
index 52ea584a2c8..3226fa9cd3f 100644
--- a/clippy_lints/src/methods/map_unwrap_or.rs
+++ b/clippy_lints/src/methods/map_unwrap_or.rs
@@ -21,7 +21,7 @@ pub(super) fn check<'tcx>(
     unwrap_arg: &'tcx hir::Expr<'_>,
     msrv: &Msrv,
 ) -> bool {
-    // lint if the caller of `map()` is an `Option`
+    // lint if the caller of `map()` is an `Option` or a `Result`.
     let is_option = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(recv), sym::Option);
     let is_result = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(recv), sym::Result);
 
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 89ea3597dc0..f769696edc4 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -113,6 +113,7 @@ mod unnecessary_iter_cloned;
 mod unnecessary_join;
 mod unnecessary_lazy_eval;
 mod unnecessary_literal_unwrap;
+mod unnecessary_result_map_or_else;
 mod unnecessary_sort_by;
 mod unnecessary_to_owned;
 mod unwrap_expect_used;
@@ -3913,6 +3914,31 @@ declare_clippy_lint! {
     "cloning an `Option` via `as_ref().cloned()`"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of `.map_or_else()` "map closure" for `Result` type.
+    ///
+    /// ### Why is this bad?
+    /// This can be written more concisely by using `unwrap_or_else()`.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # fn handle_error(_: ()) -> u32 { 0 }
+    /// let x: Result<u32, ()> = Ok(0);
+    /// let y = x.map_or_else(|err| handle_error(err), |n| n);
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// # fn handle_error(_: ()) -> u32 { 0 }
+    /// let x: Result<u32, ()> = Ok(0);
+    /// let y = x.unwrap_or_else(|err| handle_error(err));
+    /// ```
+    #[clippy::version = "1.77.0"]
+    pub UNNECESSARY_RESULT_MAP_OR_ELSE,
+    suspicious,
+    "making no use of the \"map closure\" when calling `.map_or_else(|err| handle_error(err), |n| n)`"
+}
+
 pub struct Methods {
     avoid_breaking_exported_api: bool,
     msrv: Msrv,
@@ -4070,6 +4096,7 @@ impl_lint_pass!(Methods => [
     MANUAL_IS_VARIANT_AND,
     STR_SPLIT_AT_NEWLINE,
     OPTION_AS_REF_CLONED,
+    UNNECESSARY_RESULT_MAP_OR_ELSE,
 ]);
 
 /// Extracts a method call name, args, and `Span` of the method name.
@@ -4553,6 +4580,7 @@ impl Methods {
                 },
                 ("map_or_else", [def, map]) => {
                     result_map_or_else_none::check(cx, expr, recv, def, map);
+                    unnecessary_result_map_or_else::check(cx, expr, recv, def, map);
                 },
                 ("next", []) => {
                     if let Some((name2, recv2, args2, _, _)) = method_call(recv) {
diff --git a/clippy_lints/src/methods/unnecessary_result_map_or_else.rs b/clippy_lints/src/methods/unnecessary_result_map_or_else.rs
new file mode 100644
index 00000000000..7b0cf48ac43
--- /dev/null
+++ b/clippy_lints/src/methods/unnecessary_result_map_or_else.rs
@@ -0,0 +1,95 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::peel_blocks;
+use clippy_utils::source::snippet;
+use clippy_utils::ty::is_type_diagnostic_item;
+use rustc_errors::Applicability;
+use rustc_hir as hir;
+use rustc_hir::{Closure, Expr, ExprKind, HirId, QPath, Stmt, StmtKind};
+use rustc_lint::LateContext;
+use rustc_span::symbol::sym;
+
+use super::UNNECESSARY_RESULT_MAP_OR_ELSE;
+
+fn emit_lint(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'_>, def_arg: &Expr<'_>) {
+    let msg = "unused \"map closure\" when calling `Result::map_or_else` value";
+    let self_snippet = snippet(cx, recv.span, "..");
+    let err_snippet = snippet(cx, def_arg.span, "..");
+    span_lint_and_sugg(
+        cx,
+        UNNECESSARY_RESULT_MAP_OR_ELSE,
+        expr.span,
+        msg,
+        "consider using `unwrap_or_else`",
+        format!("{self_snippet}.unwrap_or_else({err_snippet})"),
+        Applicability::MachineApplicable,
+    );
+}
+
+fn get_last_chain_binding_hir_id(mut hir_id: HirId, statements: &[Stmt<'_>]) -> Option<HirId> {
+    for stmt in statements {
+        if let StmtKind::Local(local) = stmt.kind
+            && let Some(init) = local.init
+            && let ExprKind::Path(QPath::Resolved(_, path)) = init.kind
+            && let hir::def::Res::Local(local_hir_id) = path.res
+            && local_hir_id == hir_id
+        {
+            hir_id = local.pat.hir_id;
+        } else {
+            return None;
+        }
+    }
+    Some(hir_id)
+}
+
+fn handle_qpath(
+    cx: &LateContext<'_>,
+    expr: &Expr<'_>,
+    recv: &Expr<'_>,
+    def_arg: &Expr<'_>,
+    expected_hir_id: HirId,
+    qpath: QPath<'_>,
+) {
+    if let QPath::Resolved(_, path) = qpath
+        && let hir::def::Res::Local(hir_id) = path.res
+        && expected_hir_id == hir_id
+    {
+        emit_lint(cx, expr, recv, def_arg);
+    }
+}
+
+/// lint use of `_.map_or_else(|err| err, |n| n)` for `Result`s.
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx Expr<'_>,
+    recv: &'tcx Expr<'_>,
+    def_arg: &'tcx Expr<'_>,
+    map_arg: &'tcx Expr<'_>,
+) {
+    // lint if the caller of `map_or_else()` is a `Result`
+    if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(recv), sym::Result)
+        && let ExprKind::Closure(&Closure { body, .. }) = map_arg.kind
+        && let body = cx.tcx.hir().body(body)
+        && let Some(first_param) = body.params.first()
+    {
+        let body_expr = peel_blocks(body.value);
+
+        match body_expr.kind {
+            ExprKind::Path(qpath) => {
+                handle_qpath(cx, expr, recv, def_arg, first_param.pat.hir_id, qpath);
+            },
+            // If this is a block (that wasn't peeled off), then it means there are statements.
+            ExprKind::Block(block, _) => {
+                if let Some(block_expr) = block.expr
+                    // First we ensure that this is a "binding chain" (each statement is a binding
+                    // of the previous one) and that it is a binding of the closure argument.
+                    && let Some(last_chain_binding_id) =
+                        get_last_chain_binding_hir_id(first_param.pat.hir_id, block.stmts)
+                    && let ExprKind::Path(qpath) = block_expr.kind
+                {
+                    handle_qpath(cx, expr, recv, def_arg, last_chain_binding_id, qpath);
+                }
+            },
+            _ => {},
+        }
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From e456c28e11921174d50e8329ca78903e6e53b3cc Mon Sep 17 00:00:00 2001
From: Marc Dominik Migge <marcmigge@gmx.net>
Date: Fri, 19 Jan 2024 17:05:14 +0100
Subject: Don't warn about modulo arithmetic when comparing to zero

Add lint configuration for `modulo_arithmetic`

Collect meta-data
---
 CHANGELOG.md                                       |  1 +
 book/src/lint_configuration.md                     | 10 ++++++
 clippy_config/src/conf.rs                          |  4 +++
 clippy_lints/src/lib.rs                            |  8 ++++-
 clippy_lints/src/operators/mod.rs                  | 15 ++++++--
 clippy_lints/src/operators/modulo_arithmetic.rs    | 27 ++++++++++++++-
 tests/ui-toml/modulo_arithmetic/clippy.toml        |  1 +
 .../ui-toml/modulo_arithmetic/modulo_arithmetic.rs | 10 ++++++
 .../modulo_arithmetic/modulo_arithmetic.stderr     | 40 ++++++++++++++++++++++
 .../toml_unknown_key/conf_unknown_key.stderr       |  3 ++
 tests/ui/modulo_arithmetic_integral.rs             |  8 +++++
 11 files changed, 122 insertions(+), 5 deletions(-)
 create mode 100644 tests/ui-toml/modulo_arithmetic/clippy.toml
 create mode 100644 tests/ui-toml/modulo_arithmetic/modulo_arithmetic.rs
 create mode 100644 tests/ui-toml/modulo_arithmetic/modulo_arithmetic.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5fa45ceeb39..2a3055c19f0 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5819,4 +5819,5 @@ Released 2018-09-13
 [`enforce-iter-loop-reborrow`]: https://doc.rust-lang.org/clippy/lint_configuration.html#enforce-iter-loop-reborrow
 [`check-private-items`]: https://doc.rust-lang.org/clippy/lint_configuration.html#check-private-items
 [`pub-underscore-fields-behavior`]: https://doc.rust-lang.org/clippy/lint_configuration.html#pub-underscore-fields-behavior
+[`allow-comparison-to-zero`]: https://doc.rust-lang.org/clippy/lint_configuration.html#allow-comparison-to-zero
 <!-- end autogenerated links to configuration documentation -->
diff --git a/book/src/lint_configuration.md b/book/src/lint_configuration.md
index 7f7aff92bf1..1b321b8bcb8 100644
--- a/book/src/lint_configuration.md
+++ b/book/src/lint_configuration.md
@@ -828,3 +828,13 @@ exported visibility, or whether they are marked as "pub".
 * [`pub_underscore_fields`](https://rust-lang.github.io/rust-clippy/master/index.html#pub_underscore_fields)
 
 
+## `allow-comparison-to-zero`
+Don't lint when comparing the result of a modulo operation to zero.
+
+**Default Value:** `true`
+
+---
+**Affected lints:**
+* [`modulo_arithmetic`](https://rust-lang.github.io/rust-clippy/master/index.html#modulo_arithmetic)
+
+
diff --git a/clippy_config/src/conf.rs b/clippy_config/src/conf.rs
index 4e9ddbf8259..8b45f250b10 100644
--- a/clippy_config/src/conf.rs
+++ b/clippy_config/src/conf.rs
@@ -567,6 +567,10 @@ define_Conf! {
     /// Lint "public" fields in a struct that are prefixed with an underscore based on their
     /// exported visibility, or whether they are marked as "pub".
     (pub_underscore_fields_behavior: PubUnderscoreFieldsBehaviour = PubUnderscoreFieldsBehaviour::PubliclyExported),
+    /// Lint: MODULO_ARITHMETIC.
+    ///
+    /// Don't lint when comparing the result of a modulo operation to zero.
+    (allow_comparison_to_zero: bool = true),
 }
 
 /// Search for the configuration file.
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index feb4d188f39..72d1aee767c 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -575,6 +575,7 @@ pub fn register_lints(store: &mut rustc_lint::LintStore, conf: &'static Conf) {
         check_private_items,
         pub_underscore_fields_behavior,
         ref allowed_duplicate_crates,
+        allow_comparison_to_zero,
 
         blacklisted_names: _,
         cyclomatic_complexity_threshold: _,
@@ -968,7 +969,12 @@ pub fn register_lints(store: &mut rustc_lint::LintStore, conf: &'static Conf) {
     store.register_late_pass(|_| Box::new(default_instead_of_iter_empty::DefaultIterEmpty));
     store.register_late_pass(move |_| Box::new(manual_rem_euclid::ManualRemEuclid::new(msrv())));
     store.register_late_pass(move |_| Box::new(manual_retain::ManualRetain::new(msrv())));
-    store.register_late_pass(move |_| Box::new(operators::Operators::new(verbose_bit_mask_threshold)));
+    store.register_late_pass(move |_| {
+        Box::new(operators::Operators::new(
+            verbose_bit_mask_threshold,
+            allow_comparison_to_zero,
+        ))
+    });
     store.register_late_pass(|_| Box::<std_instead_of_core::StdReexports>::default());
     store.register_late_pass(move |_| Box::new(instant_subtraction::InstantSubtraction::new(msrv())));
     store.register_late_pass(|_| Box::new(partialeq_to_none::PartialeqToNone));
diff --git a/clippy_lints/src/operators/mod.rs b/clippy_lints/src/operators/mod.rs
index 4c09c4eea58..e002429e3a4 100644
--- a/clippy_lints/src/operators/mod.rs
+++ b/clippy_lints/src/operators/mod.rs
@@ -771,6 +771,7 @@ declare_clippy_lint! {
 pub struct Operators {
     arithmetic_context: numeric_arithmetic::Context,
     verbose_bit_mask_threshold: u64,
+    modulo_arithmetic_allow_comparison_to_zero: bool,
 }
 impl_lint_pass!(Operators => [
     ABSURD_EXTREME_COMPARISONS,
@@ -801,10 +802,11 @@ impl_lint_pass!(Operators => [
     SELF_ASSIGNMENT,
 ]);
 impl Operators {
-    pub fn new(verbose_bit_mask_threshold: u64) -> Self {
+    pub fn new(verbose_bit_mask_threshold: u64, modulo_arithmetic_allow_comparison_to_zero: bool) -> Self {
         Self {
             arithmetic_context: numeric_arithmetic::Context::default(),
             verbose_bit_mask_threshold,
+            modulo_arithmetic_allow_comparison_to_zero,
         }
     }
 }
@@ -835,12 +837,19 @@ impl<'tcx> LateLintPass<'tcx> for Operators {
                 cmp_owned::check(cx, op.node, lhs, rhs);
                 float_cmp::check(cx, e, op.node, lhs, rhs);
                 modulo_one::check(cx, e, op.node, rhs);
-                modulo_arithmetic::check(cx, e, op.node, lhs, rhs);
+                modulo_arithmetic::check(
+                    cx,
+                    e,
+                    op.node,
+                    lhs,
+                    rhs,
+                    self.modulo_arithmetic_allow_comparison_to_zero,
+                );
             },
             ExprKind::AssignOp(op, lhs, rhs) => {
                 self.arithmetic_context.check_binary(cx, e, op.node, lhs, rhs);
                 misrefactored_assign_op::check(cx, e, op.node, lhs, rhs);
-                modulo_arithmetic::check(cx, e, op.node, lhs, rhs);
+                modulo_arithmetic::check(cx, e, op.node, lhs, rhs, false);
             },
             ExprKind::Assign(lhs, rhs, _) => {
                 assign_op_pattern::check(cx, e, lhs, rhs);
diff --git a/clippy_lints/src/operators/modulo_arithmetic.rs b/clippy_lints/src/operators/modulo_arithmetic.rs
index cb3916484c1..40d4a842bef 100644
--- a/clippy_lints/src/operators/modulo_arithmetic.rs
+++ b/clippy_lints/src/operators/modulo_arithmetic.rs
@@ -1,7 +1,7 @@
 use clippy_utils::consts::{constant, Constant};
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::sext;
-use rustc_hir::{BinOpKind, Expr};
+use rustc_hir::{BinOpKind, Expr, ExprKind, Node};
 use rustc_lint::LateContext;
 use rustc_middle::ty::{self, Ty};
 use std::fmt::Display;
@@ -14,8 +14,13 @@ pub(super) fn check<'tcx>(
     op: BinOpKind,
     lhs: &'tcx Expr<'_>,
     rhs: &'tcx Expr<'_>,
+    allow_comparison_to_zero: bool,
 ) {
     if op == BinOpKind::Rem {
+        if allow_comparison_to_zero && used_in_comparison_with_zero(cx, e) {
+            return;
+        }
+
         let lhs_operand = analyze_operand(lhs, cx, e);
         let rhs_operand = analyze_operand(rhs, cx, e);
         if let Some(lhs_operand) = lhs_operand
@@ -28,6 +33,26 @@ pub(super) fn check<'tcx>(
     };
 }
 
+fn used_in_comparison_with_zero(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+    let Some(Node::Expr(parent_expr)) = cx.tcx.hir().find_parent(expr.hir_id) else {
+        return false;
+    };
+    let ExprKind::Binary(op, lhs, rhs) = parent_expr.kind else {
+        return false;
+    };
+
+    if op.node == BinOpKind::Eq || op.node == BinOpKind::Ne {
+        if let Some(Constant::Int(0)) = constant(cx, cx.typeck_results(), rhs) {
+            return true;
+        }
+        if let Some(Constant::Int(0)) = constant(cx, cx.typeck_results(), lhs) {
+            return true;
+        }
+    }
+
+    false
+}
+
 struct OperandInfo {
     string_representation: Option<String>,
     is_negative: bool,
diff --git a/tests/ui-toml/modulo_arithmetic/clippy.toml b/tests/ui-toml/modulo_arithmetic/clippy.toml
new file mode 100644
index 00000000000..de80f4ae598
--- /dev/null
+++ b/tests/ui-toml/modulo_arithmetic/clippy.toml
@@ -0,0 +1 @@
+allow-comparison-to-zero = false
diff --git a/tests/ui-toml/modulo_arithmetic/modulo_arithmetic.rs b/tests/ui-toml/modulo_arithmetic/modulo_arithmetic.rs
new file mode 100644
index 00000000000..27d27564baf
--- /dev/null
+++ b/tests/ui-toml/modulo_arithmetic/modulo_arithmetic.rs
@@ -0,0 +1,10 @@
+#![warn(clippy::modulo_arithmetic)]
+
+fn main() {
+    let a = -1;
+    let b = 2;
+    let c = a % b == 0;
+    let c = a % b != 0;
+    let c = 0 == a % b;
+    let c = 0 != a % b;
+}
diff --git a/tests/ui-toml/modulo_arithmetic/modulo_arithmetic.stderr b/tests/ui-toml/modulo_arithmetic/modulo_arithmetic.stderr
new file mode 100644
index 00000000000..da644b05a11
--- /dev/null
+++ b/tests/ui-toml/modulo_arithmetic/modulo_arithmetic.stderr
@@ -0,0 +1,40 @@
+error: you are using modulo operator on types that might have different signs
+  --> $DIR/modulo_arithmetic.rs:6:13
+   |
+LL |     let c = a % b == 0;
+   |             ^^^^^
+   |
+   = note: double check for expected result especially when interoperating with different languages
+   = note: or consider using `rem_euclid` or similar function
+   = note: `-D clippy::modulo-arithmetic` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::modulo_arithmetic)]`
+
+error: you are using modulo operator on types that might have different signs
+  --> $DIR/modulo_arithmetic.rs:7:13
+   |
+LL |     let c = a % b != 0;
+   |             ^^^^^
+   |
+   = note: double check for expected result especially when interoperating with different languages
+   = note: or consider using `rem_euclid` or similar function
+
+error: you are using modulo operator on types that might have different signs
+  --> $DIR/modulo_arithmetic.rs:8:18
+   |
+LL |     let c = 0 == a % b;
+   |                  ^^^^^
+   |
+   = note: double check for expected result especially when interoperating with different languages
+   = note: or consider using `rem_euclid` or similar function
+
+error: you are using modulo operator on types that might have different signs
+  --> $DIR/modulo_arithmetic.rs:9:18
+   |
+LL |     let c = 0 != a % b;
+   |                  ^^^^^
+   |
+   = note: double check for expected result especially when interoperating with different languages
+   = note: or consider using `rem_euclid` or similar function
+
+error: aborting due to 4 previous errors
+
diff --git a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
index fc683e514ba..24fdfd945bd 100644
--- a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
+++ b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
@@ -3,6 +3,7 @@ error: error reading Clippy's configuration file: unknown field `foobar`, expect
            absolute-paths-max-segments
            accept-comment-above-attributes
            accept-comment-above-statement
+           allow-comparison-to-zero
            allow-dbg-in-tests
            allow-expect-in-tests
            allow-mixed-uninlined-format-args
@@ -80,6 +81,7 @@ error: error reading Clippy's configuration file: unknown field `barfoo`, expect
            absolute-paths-max-segments
            accept-comment-above-attributes
            accept-comment-above-statement
+           allow-comparison-to-zero
            allow-dbg-in-tests
            allow-expect-in-tests
            allow-mixed-uninlined-format-args
@@ -157,6 +159,7 @@ error: error reading Clippy's configuration file: unknown field `allow_mixed_uni
            absolute-paths-max-segments
            accept-comment-above-attributes
            accept-comment-above-statement
+           allow-comparison-to-zero
            allow-dbg-in-tests
            allow-expect-in-tests
            allow-mixed-uninlined-format-args
diff --git a/tests/ui/modulo_arithmetic_integral.rs b/tests/ui/modulo_arithmetic_integral.rs
index 4dbed24026c..c427b8580e1 100644
--- a/tests/ui/modulo_arithmetic_integral.rs
+++ b/tests/ui/modulo_arithmetic_integral.rs
@@ -114,4 +114,12 @@ fn main() {
     a_usize % b_usize;
     let mut a_usize: usize = 1;
     a_usize %= 2;
+
+    // No lint when comparing to zero
+    let a = -1;
+    let mut b = 2;
+    let c = a % b == 0;
+    let c = 0 == a % b;
+    let c = a % b != 0;
+    let c = 0 != a % b;
 }
-- 
cgit 1.4.1-3-g733a5


From 42d13f8eb0b5ed893ffd92c81f10c43499cb3cad Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Sat, 20 Jan 2024 20:26:06 +0100
Subject: [`unconditional_recursion`]: compare by types instead of `DefId`s

---
 clippy_lints/src/unconditional_recursion.rs | 86 ++++++++++++++++-------------
 tests/ui/unconditional_recursion.rs         | 35 ++++++++++++
 2 files changed, 82 insertions(+), 39 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unconditional_recursion.rs b/clippy_lints/src/unconditional_recursion.rs
index 209035804e4..224ec475c51 100644
--- a/clippy_lints/src/unconditional_recursion.rs
+++ b/clippy_lints/src/unconditional_recursion.rs
@@ -69,14 +69,6 @@ fn span_error(cx: &LateContext<'_>, method_span: Span, expr: &Expr<'_>) {
     );
 }
 
-fn get_ty_def_id(ty: Ty<'_>) -> Option<DefId> {
-    match ty.peel_refs().kind() {
-        ty::Adt(adt, _) => Some(adt.did()),
-        ty::Foreign(def_id) => Some(*def_id),
-        _ => None,
-    }
-}
-
 fn get_hir_ty_def_id<'tcx>(tcx: TyCtxt<'tcx>, hir_ty: rustc_hir::Ty<'tcx>) -> Option<DefId> {
     let TyKind::Path(qpath) = hir_ty.kind else { return None };
     match qpath {
@@ -131,21 +123,49 @@ fn get_impl_trait_def_id(cx: &LateContext<'_>, method_def_id: LocalDefId) -> Opt
     }
 }
 
-#[allow(clippy::unnecessary_def_path)]
+/// When we have `x == y` where `x = &T` and `y = &T`, then that resolves to
+/// `<&T as PartialEq<&T>>::eq`, which is not the same as `<T as PartialEq<T>>::eq`,
+/// however we still would want to treat it the same, because we know that it's a blanket impl
+/// that simply delegates to the `PartialEq` impl with one reference removed.
+///
+/// Still, we can't just do `lty.peel_refs() == rty.peel_refs()` because when we have `x = &T` and
+/// `y = &&T`, this is not necessarily the same as `<T as PartialEq<T>>::eq`
+///
+/// So to avoid these FNs and FPs, we keep removing a layer of references from *both* sides
+/// until both sides match the expected LHS and RHS type (or they don't).
+fn matches_ty<'tcx>(
+    mut left: Ty<'tcx>,
+    mut right: Ty<'tcx>,
+    expected_left: Ty<'tcx>,
+    expected_right: Ty<'tcx>,
+) -> bool {
+    while let (&ty::Ref(_, lty, _), &ty::Ref(_, rty, _)) = (left.kind(), right.kind()) {
+        if lty == expected_left && rty == expected_right {
+            return true;
+        }
+        left = lty;
+        right = rty;
+    }
+    false
+}
+
 fn check_partial_eq(cx: &LateContext<'_>, method_span: Span, method_def_id: LocalDefId, name: Ident, expr: &Expr<'_>) {
-    let args = cx
-        .tcx
-        .instantiate_bound_regions_with_erased(cx.tcx.fn_sig(method_def_id).skip_binder())
-        .inputs();
+    let Some(sig) = cx
+        .typeck_results()
+        .liberated_fn_sigs()
+        .get(cx.tcx.local_def_id_to_hir_id(method_def_id))
+    else {
+        return;
+    };
+
     // That has two arguments.
-    if let [self_arg, other_arg] = args
-        && let Some(self_arg) = get_ty_def_id(*self_arg)
-        && let Some(other_arg) = get_ty_def_id(*other_arg)
+    if let [self_arg, other_arg] = sig.inputs()
+        && let &ty::Ref(_, self_arg, _) = self_arg.kind()
+        && let &ty::Ref(_, other_arg, _) = other_arg.kind()
         // The two arguments are of the same type.
-        && self_arg == other_arg
         && let Some(trait_def_id) = get_impl_trait_def_id(cx, method_def_id)
         // The trait is `PartialEq`.
-        && Some(trait_def_id) == get_trait_def_id(cx, &["core", "cmp", "PartialEq"])
+        && cx.tcx.is_diagnostic_item(sym::PartialEq, trait_def_id)
     {
         let to_check_op = if name.name == sym::eq {
             BinOpKind::Eq
@@ -154,31 +174,19 @@ fn check_partial_eq(cx: &LateContext<'_>, method_span: Span, method_def_id: Loca
         };
         let is_bad = match expr.kind {
             ExprKind::Binary(op, left, right) if op.node == to_check_op => {
-                // Then we check if the left-hand element is of the same type as `self`.
-                if let Some(left_ty) = cx.typeck_results().expr_ty_opt(left)
-                    && let Some(left_id) = get_ty_def_id(left_ty)
-                    && self_arg == left_id
-                    && let Some(right_ty) = cx.typeck_results().expr_ty_opt(right)
-                    && let Some(right_id) = get_ty_def_id(right_ty)
-                    && other_arg == right_id
-                {
-                    true
-                } else {
-                    false
-                }
+                // Then we check if the LHS matches self_arg and RHS matches other_arg
+                let left_ty = cx.typeck_results().expr_ty_adjusted(left);
+                let right_ty = cx.typeck_results().expr_ty_adjusted(right);
+                matches_ty(left_ty, right_ty, self_arg, other_arg)
             },
-            ExprKind::MethodCall(segment, receiver, &[_arg], _) if segment.ident.name == name.name => {
-                if let Some(ty) = cx.typeck_results().expr_ty_opt(receiver)
-                    && let Some(ty_id) = get_ty_def_id(ty)
-                    && self_arg != ty_id
-                {
-                    // Since this called on a different type, the lint should not be
-                    // triggered here.
-                    return;
-                }
+            ExprKind::MethodCall(segment, receiver, [arg], _) if segment.ident.name == name.name => {
+                let receiver_ty = cx.typeck_results().expr_ty_adjusted(receiver);
+                let arg_ty = cx.typeck_results().expr_ty_adjusted(arg);
+
                 if let Some(fn_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id)
                     && let Some(trait_id) = cx.tcx.trait_of_item(fn_id)
                     && trait_id == trait_def_id
+                    && matches_ty(receiver_ty, arg_ty, self_arg, other_arg)
                 {
                     true
                 } else {
diff --git a/tests/ui/unconditional_recursion.rs b/tests/ui/unconditional_recursion.rs
index 7b898a6e0e7..2ad7c410da5 100644
--- a/tests/ui/unconditional_recursion.rs
+++ b/tests/ui/unconditional_recursion.rs
@@ -288,4 +288,39 @@ impl PartialEq for S15<'_> {
     }
 }
 
+mod issue12154 {
+    struct MyBox<T>(T);
+
+    impl<T> std::ops::Deref for MyBox<T> {
+        type Target = T;
+        fn deref(&self) -> &T {
+            &self.0
+        }
+    }
+
+    impl<T: PartialEq> PartialEq for MyBox<T> {
+        fn eq(&self, other: &Self) -> bool {
+            (**self).eq(&**other)
+        }
+    }
+
+    // Not necessarily related to the issue but another FP from the http crate that was fixed with it:
+    // https://docs.rs/http/latest/src/http/header/name.rs.html#1424
+    // We used to simply peel refs from the LHS and RHS, so we couldn't differentiate
+    // between `PartialEq<T> for &T` and `PartialEq<&T> for T` impls.
+    #[derive(PartialEq)]
+    struct HeaderName;
+    impl<'a> PartialEq<&'a HeaderName> for HeaderName {
+        fn eq(&self, other: &&'a HeaderName) -> bool {
+            *self == **other
+        }
+    }
+
+    impl<'a> PartialEq<HeaderName> for &'a HeaderName {
+        fn eq(&self, other: &HeaderName) -> bool {
+            *other == *self
+        }
+    }
+}
+
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From fd3e966bdded5d556d01f1db5c3d6a78539661f8 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Fri, 26 Jan 2024 00:23:13 +0100
Subject: avoid linting on `#[track_caller]` functions in `redundant_closure`

---
 clippy_lints/src/eta_reduction.rs | 14 +++++++++++---
 tests/ui/eta.fixed                | 17 +++++++++++++++++
 tests/ui/eta.rs                   | 17 +++++++++++++++++
 tests/ui/eta.stderr               |  2 +-
 4 files changed, 46 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/eta_reduction.rs b/clippy_lints/src/eta_reduction.rs
index 450cee4007c..1ea5b789805 100644
--- a/clippy_lints/src/eta_reduction.rs
+++ b/clippy_lints/src/eta_reduction.rs
@@ -21,8 +21,8 @@ use rustc_trait_selection::traits::error_reporting::InferCtxtExt as _;
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for closures which just call another function where
-    /// the function can be called directly. `unsafe` functions or calls where types
-    /// get adjusted are ignored.
+    /// the function can be called directly. `unsafe` functions, calls where types
+    /// get adjusted or where the callee is marked `#[track_caller]` are ignored.
     ///
     /// ### Why is this bad?
     /// Needlessly creating a closure adds code for no benefit
@@ -136,7 +136,14 @@ impl<'tcx> LateLintPass<'tcx> for EtaReduction {
                     .map_or(callee_ty, |a| a.target.peel_refs());
 
                 let sig = match callee_ty_adjusted.kind() {
-                    ty::FnDef(def, _) => cx.tcx.fn_sig(def).skip_binder().skip_binder(),
+                    ty::FnDef(def, _) => {
+                        // Rewriting `x(|| f())` to `x(f)` where f is marked `#[track_caller]` moves the `Location`
+                        if cx.tcx.has_attr(*def, sym::track_caller) {
+                            return;
+                        }
+
+                        cx.tcx.fn_sig(def).skip_binder().skip_binder()
+                    },
                     ty::FnPtr(sig) => sig.skip_binder(),
                     ty::Closure(_, subs) => cx
                         .tcx
@@ -186,6 +193,7 @@ impl<'tcx> LateLintPass<'tcx> for EtaReduction {
             },
             ExprKind::MethodCall(path, self_, args, _) if check_inputs(typeck, body.params, Some(self_), args) => {
                 if let Some(method_def_id) = typeck.type_dependent_def_id(body.value.hir_id)
+                    && !cx.tcx.has_attr(method_def_id, sym::track_caller)
                     && check_sig(cx, closure, cx.tcx.fn_sig(method_def_id).skip_binder().skip_binder())
                 {
                     span_lint_and_then(
diff --git a/tests/ui/eta.fixed b/tests/ui/eta.fixed
index 32c7499bf73..3aeb4dae30b 100644
--- a/tests/ui/eta.fixed
+++ b/tests/ui/eta.fixed
@@ -346,6 +346,23 @@ fn angle_brackets_and_args() {
     dyn_opt.map(<dyn TestTrait>::method_on_dyn);
 }
 
+// https://github.com/rust-lang/rust-clippy/issues/12199
+fn track_caller_fp() {
+    struct S;
+    impl S {
+        #[track_caller]
+        fn add_location(self) {}
+    }
+
+    #[track_caller]
+    fn add_location() {}
+
+    fn foo(_: fn()) {}
+    fn foo2(_: fn(S)) {}
+    foo(|| add_location());
+    foo2(|s| s.add_location());
+}
+
 fn _late_bound_to_early_bound_regions() {
     struct Foo<'a>(&'a u32);
     impl<'a> Foo<'a> {
diff --git a/tests/ui/eta.rs b/tests/ui/eta.rs
index 25b7431ba8c..b9b3303b371 100644
--- a/tests/ui/eta.rs
+++ b/tests/ui/eta.rs
@@ -346,6 +346,23 @@ fn angle_brackets_and_args() {
     dyn_opt.map(|d| d.method_on_dyn());
 }
 
+// https://github.com/rust-lang/rust-clippy/issues/12199
+fn track_caller_fp() {
+    struct S;
+    impl S {
+        #[track_caller]
+        fn add_location(self) {}
+    }
+
+    #[track_caller]
+    fn add_location() {}
+
+    fn foo(_: fn()) {}
+    fn foo2(_: fn(S)) {}
+    foo(|| add_location());
+    foo2(|s| s.add_location());
+}
+
 fn _late_bound_to_early_bound_regions() {
     struct Foo<'a>(&'a u32);
     impl<'a> Foo<'a> {
diff --git a/tests/ui/eta.stderr b/tests/ui/eta.stderr
index 951e4ac749c..7c4d2d7093e 100644
--- a/tests/ui/eta.stderr
+++ b/tests/ui/eta.stderr
@@ -161,7 +161,7 @@ LL |     dyn_opt.map(|d| d.method_on_dyn());
    |                 ^^^^^^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `<dyn TestTrait>::method_on_dyn`
 
 error: redundant closure
-  --> $DIR/eta.rs:389:19
+  --> $DIR/eta.rs:406:19
    |
 LL |     let _ = f(&0, |x, y| f2(x, y));
    |                   ^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `f2`
-- 
cgit 1.4.1-3-g733a5


From 14e15206ed1ce8b50c4d2038f10d2793faf87723 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Wed, 17 Jan 2024 15:56:53 +0100
Subject: Warn if an item coming from more recent version than MSRV is used

---
 CHANGELOG.md                                       |   1 +
 clippy_config/src/msrvs.rs                         |  11 ++
 clippy_lints/src/declared_lints.rs                 |   1 +
 clippy_lints/src/incompatible_msrv.rs              | 133 +++++++++++++++++++++
 clippy_lints/src/lib.rs                            |   3 +
 .../min_rust_version/min_rust_version.fixed        |   2 +-
 tests/ui-toml/min_rust_version/min_rust_version.rs |   2 +-
 tests/ui/incompatible_msrv.rs                      |  23 ++++
 tests/ui/incompatible_msrv.stderr                  |  23 ++++
 9 files changed, 197 insertions(+), 2 deletions(-)
 create mode 100644 clippy_lints/src/incompatible_msrv.rs
 create mode 100644 tests/ui/incompatible_msrv.rs
 create mode 100644 tests/ui/incompatible_msrv.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5fa45ceeb39..7db5d4c45df 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5198,6 +5198,7 @@ Released 2018-09-13
 [`implied_bounds_in_impls`]: https://rust-lang.github.io/rust-clippy/master/index.html#implied_bounds_in_impls
 [`impossible_comparisons`]: https://rust-lang.github.io/rust-clippy/master/index.html#impossible_comparisons
 [`imprecise_flops`]: https://rust-lang.github.io/rust-clippy/master/index.html#imprecise_flops
+[`incompatible_msrv`]: https://rust-lang.github.io/rust-clippy/master/index.html#incompatible_msrv
 [`inconsistent_digit_grouping`]: https://rust-lang.github.io/rust-clippy/master/index.html#inconsistent_digit_grouping
 [`inconsistent_struct_constructor`]: https://rust-lang.github.io/rust-clippy/master/index.html#inconsistent_struct_constructor
 [`incorrect_clone_impl_on_copy_type`]: https://rust-lang.github.io/rust-clippy/master/index.html#incorrect_clone_impl_on_copy_type
diff --git a/clippy_config/src/msrvs.rs b/clippy_config/src/msrvs.rs
index 72d5b9aff28..856644b8568 100644
--- a/clippy_config/src/msrvs.rs
+++ b/clippy_config/src/msrvs.rs
@@ -3,6 +3,7 @@ use rustc_semver::RustcVersion;
 use rustc_session::Session;
 use rustc_span::{sym, Symbol};
 use serde::Deserialize;
+use std::fmt;
 
 macro_rules! msrv_aliases {
     ($($major:literal,$minor:literal,$patch:literal {
@@ -58,6 +59,16 @@ pub struct Msrv {
     stack: Vec<RustcVersion>,
 }
 
+impl fmt::Display for Msrv {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if let Some(msrv) = self.current() {
+            write!(f, "{msrv}")
+        } else {
+            f.write_str("1.0.0")
+        }
+    }
+}
+
 impl<'de> Deserialize<'de> for Msrv {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 639edd8da30..5342a6722db 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -212,6 +212,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::implicit_saturating_add::IMPLICIT_SATURATING_ADD_INFO,
     crate::implicit_saturating_sub::IMPLICIT_SATURATING_SUB_INFO,
     crate::implied_bounds_in_impls::IMPLIED_BOUNDS_IN_IMPLS_INFO,
+    crate::incompatible_msrv::INCOMPATIBLE_MSRV_INFO,
     crate::inconsistent_struct_constructor::INCONSISTENT_STRUCT_CONSTRUCTOR_INFO,
     crate::index_refutable_slice::INDEX_REFUTABLE_SLICE_INFO,
     crate::indexing_slicing::INDEXING_SLICING_INFO,
diff --git a/clippy_lints/src/incompatible_msrv.rs b/clippy_lints/src/incompatible_msrv.rs
new file mode 100644
index 00000000000..f2f0e7d4266
--- /dev/null
+++ b/clippy_lints/src/incompatible_msrv.rs
@@ -0,0 +1,133 @@
+use clippy_config::msrvs::Msrv;
+use clippy_utils::diagnostics::span_lint;
+use rustc_attr::{StabilityLevel, StableSince};
+use rustc_data_structures::fx::FxHashMap;
+use rustc_hir::{Expr, ExprKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::TyCtxt;
+use rustc_semver::RustcVersion;
+use rustc_session::impl_lint_pass;
+use rustc_span::def_id::DefId;
+use rustc_span::Span;
+
+declare_clippy_lint! {
+    /// ### What it does
+    ///
+    /// This lint checks that no function newer than the defined MSRV (minimum
+    /// supported rust version) is used in the crate.
+    ///
+    /// ### Why is this bad?
+    ///
+    /// It would prevent the crate to be actually used with the specified MSRV.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// // MSRV of 1.3.0
+    /// use std::thread::sleep;
+    /// use std::time::Duration;
+    ///
+    /// // Sleep was defined in `1.4.0`.
+    /// sleep(Duration::new(1, 0));
+    /// ```
+    ///
+    /// To fix this problem, either increase your MSRV or use another item
+    /// available in your current MSRV.
+    #[clippy::version = "1.77.0"]
+    pub INCOMPATIBLE_MSRV,
+    suspicious,
+    "ensures that all items used in the crate are available for the current MSRV"
+}
+
+pub struct IncompatibleMsrv {
+    msrv: Msrv,
+    is_above_msrv: FxHashMap<DefId, RustcVersion>,
+}
+
+impl_lint_pass!(IncompatibleMsrv => [INCOMPATIBLE_MSRV]);
+
+impl IncompatibleMsrv {
+    pub fn new(msrv: Msrv) -> Self {
+        Self {
+            msrv,
+            is_above_msrv: FxHashMap::default(),
+        }
+    }
+
+    #[allow(clippy::cast_lossless)]
+    fn get_def_id_version(&mut self, tcx: TyCtxt<'_>, def_id: DefId) -> RustcVersion {
+        if let Some(version) = self.is_above_msrv.get(&def_id) {
+            return *version;
+        }
+        let version = if let Some(version) = tcx
+            .lookup_stability(def_id)
+            .and_then(|stability| match stability.level {
+                StabilityLevel::Stable {
+                    since: StableSince::Version(version),
+                    ..
+                } => Some(RustcVersion::new(
+                    version.major as _,
+                    version.minor as _,
+                    version.patch as _,
+                )),
+                _ => None,
+            }) {
+            version
+        } else if let Some(parent_def_id) = tcx.opt_parent(def_id) {
+            self.get_def_id_version(tcx, parent_def_id)
+        } else {
+            RustcVersion::new(1, 0, 0)
+        };
+        self.is_above_msrv.insert(def_id, version);
+        version
+    }
+
+    fn emit_lint_if_under_msrv(&mut self, cx: &LateContext<'_>, def_id: DefId, span: Span) {
+        if def_id.is_local() {
+            // We don't check local items since their MSRV is supposed to always be valid.
+            return;
+        }
+        let version = self.get_def_id_version(cx.tcx, def_id);
+        if self.msrv.meets(version) {
+            return;
+        }
+        self.emit_lint_for(cx, span, version);
+    }
+
+    fn emit_lint_for(&self, cx: &LateContext<'_>, span: Span, version: RustcVersion) {
+        span_lint(
+            cx,
+            INCOMPATIBLE_MSRV,
+            span,
+            &format!(
+                "current MSRV (Minimum Supported Rust Version) is `{}` but this item is stable since `{version}`",
+                self.msrv
+            ),
+        );
+    }
+}
+
+impl<'tcx> LateLintPass<'tcx> for IncompatibleMsrv {
+    extract_msrv_attr!(LateContext);
+
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
+        if self.msrv.current().is_none() {
+            // If there is no MSRV, then no need to check anything...
+            return;
+        }
+        match expr.kind {
+            ExprKind::MethodCall(_, _, _, span) => {
+                if let Some(method_did) = cx.typeck_results().type_dependent_def_id(expr.hir_id) {
+                    self.emit_lint_if_under_msrv(cx, method_did, span);
+                }
+            },
+            ExprKind::Call(call, [_]) => {
+                if let ExprKind::Path(qpath) = call.kind
+                    && let Some(path_def_id) = cx.qpath_res(&qpath, call.hir_id).opt_def_id()
+                {
+                    self.emit_lint_if_under_msrv(cx, path_def_id, call.span);
+                }
+            },
+            _ => {},
+        }
+    }
+}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index feb4d188f39..907ff938293 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -26,6 +26,7 @@ extern crate rustc_abi;
 extern crate rustc_arena;
 extern crate rustc_ast;
 extern crate rustc_ast_pretty;
+extern crate rustc_attr;
 extern crate rustc_data_structures;
 extern crate rustc_driver;
 extern crate rustc_errors;
@@ -153,6 +154,7 @@ mod implicit_return;
 mod implicit_saturating_add;
 mod implicit_saturating_sub;
 mod implied_bounds_in_impls;
+mod incompatible_msrv;
 mod inconsistent_struct_constructor;
 mod index_refutable_slice;
 mod indexing_slicing;
@@ -1094,6 +1096,7 @@ pub fn register_lints(store: &mut rustc_lint::LintStore, conf: &'static Conf) {
     store.register_late_pass(move |_| {
         Box::new(thread_local_initializer_can_be_made_const::ThreadLocalInitializerCanBeMadeConst::new(msrv()))
     });
+    store.register_late_pass(move |_| Box::new(incompatible_msrv::IncompatibleMsrv::new(msrv())));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/tests/ui-toml/min_rust_version/min_rust_version.fixed b/tests/ui-toml/min_rust_version/min_rust_version.fixed
index 6c58e07d846..497f783087a 100644
--- a/tests/ui-toml/min_rust_version/min_rust_version.fixed
+++ b/tests/ui-toml/min_rust_version/min_rust_version.fixed
@@ -1,4 +1,4 @@
-#![allow(clippy::redundant_clone, clippy::unnecessary_operation)]
+#![allow(clippy::redundant_clone, clippy::unnecessary_operation, clippy::incompatible_msrv)]
 #![warn(clippy::manual_non_exhaustive, clippy::borrow_as_ptr, clippy::manual_bits)]
 
 use std::mem::{size_of, size_of_val};
diff --git a/tests/ui-toml/min_rust_version/min_rust_version.rs b/tests/ui-toml/min_rust_version/min_rust_version.rs
index e1dc3f4389c..6e7874108a3 100644
--- a/tests/ui-toml/min_rust_version/min_rust_version.rs
+++ b/tests/ui-toml/min_rust_version/min_rust_version.rs
@@ -1,4 +1,4 @@
-#![allow(clippy::redundant_clone, clippy::unnecessary_operation)]
+#![allow(clippy::redundant_clone, clippy::unnecessary_operation, clippy::incompatible_msrv)]
 #![warn(clippy::manual_non_exhaustive, clippy::borrow_as_ptr, clippy::manual_bits)]
 
 use std::mem::{size_of, size_of_val};
diff --git a/tests/ui/incompatible_msrv.rs b/tests/ui/incompatible_msrv.rs
new file mode 100644
index 00000000000..a92017fb0f6
--- /dev/null
+++ b/tests/ui/incompatible_msrv.rs
@@ -0,0 +1,23 @@
+#![warn(clippy::incompatible_msrv)]
+#![feature(custom_inner_attributes)]
+#![clippy::msrv = "1.3.0"]
+
+use std::collections::hash_map::Entry;
+use std::collections::HashMap;
+use std::thread::sleep;
+use std::time::Duration;
+
+fn foo() {
+    let mut map: HashMap<&str, u32> = HashMap::new();
+    assert_eq!(map.entry("poneyland").key(), &"poneyland");
+    //~^ ERROR: is `1.3.0` but this item is stable since `1.10.0`
+    if let Entry::Vacant(v) = map.entry("poneyland") {
+        v.into_key();
+        //~^ ERROR: is `1.3.0` but this item is stable since `1.12.0`
+    }
+    // Should warn for `sleep` but not for `Duration` (which was added in `1.3.0`).
+    sleep(Duration::new(1, 0));
+    //~^ ERROR: is `1.3.0` but this item is stable since `1.4.0`
+}
+
+fn main() {}
diff --git a/tests/ui/incompatible_msrv.stderr b/tests/ui/incompatible_msrv.stderr
new file mode 100644
index 00000000000..bd5ecd6ed2f
--- /dev/null
+++ b/tests/ui/incompatible_msrv.stderr
@@ -0,0 +1,23 @@
+error: current MSRV (Minimum Supported Rust Version) is `1.3.0` but this item is stable since `1.10.0`
+  --> $DIR/incompatible_msrv.rs:12:39
+   |
+LL |     assert_eq!(map.entry("poneyland").key(), &"poneyland");
+   |                                       ^^^^^
+   |
+   = note: `-D clippy::incompatible-msrv` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::incompatible_msrv)]`
+
+error: current MSRV (Minimum Supported Rust Version) is `1.3.0` but this item is stable since `1.12.0`
+  --> $DIR/incompatible_msrv.rs:15:11
+   |
+LL |         v.into_key();
+   |           ^^^^^^^^^^
+
+error: current MSRV (Minimum Supported Rust Version) is `1.3.0` but this item is stable since `1.4.0`
+  --> $DIR/incompatible_msrv.rs:19:5
+   |
+LL |     sleep(Duration::new(1, 0));
+   |     ^^^^^
+
+error: aborting due to 3 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 6d76d145653bbe05e3ac49ea12626f52a1582970 Mon Sep 17 00:00:00 2001
From: Andrew Banchich <git@andrew.banchi.ch>
Date: Wed, 10 Jan 2024 18:52:20 -0500
Subject: add to_string_trait_impl lint

---
 CHANGELOG.md                                  |   1 +
 clippy_lints/src/declared_lints.rs            |   1 +
 clippy_lints/src/lib.rs                       |   2 +
 clippy_lints/src/returns.rs                   |  15 +--
 clippy_lints/src/to_string_trait_impl.rs      |  67 ++++++++++
 tests/ui/format_args.fixed                    |   1 +
 tests/ui/format_args.rs                       |   1 +
 tests/ui/format_args.stderr                   |  50 ++++----
 tests/ui/to_string_trait_impl.rs              |  31 +++++
 tests/ui/to_string_trait_impl.stderr          |  16 +++
 tests/ui/unconditional_recursion.rs           |   3 +
 tests/ui/unconditional_recursion.stderr       |  14 +--
 tests/ui/unnecessary_to_owned.fixed           |   3 +
 tests/ui/unnecessary_to_owned.rs              |   3 +
 tests/ui/unnecessary_to_owned.stderr          | 170 +++++++++++++-------------
 tests/ui/unnecessary_to_owned_on_split.fixed  |   1 +
 tests/ui/unnecessary_to_owned_on_split.rs     |   1 +
 tests/ui/unnecessary_to_owned_on_split.stderr |  18 +--
 18 files changed, 265 insertions(+), 133 deletions(-)
 create mode 100644 clippy_lints/src/to_string_trait_impl.rs
 create mode 100644 tests/ui/to_string_trait_impl.rs
 create mode 100644 tests/ui/to_string_trait_impl.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 7db5d4c45df..927697a7c0f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5623,6 +5623,7 @@ Released 2018-09-13
 [`to_digit_is_some`]: https://rust-lang.github.io/rust-clippy/master/index.html#to_digit_is_some
 [`to_string_in_display`]: https://rust-lang.github.io/rust-clippy/master/index.html#to_string_in_display
 [`to_string_in_format_args`]: https://rust-lang.github.io/rust-clippy/master/index.html#to_string_in_format_args
+[`to_string_trait_impl`]: https://rust-lang.github.io/rust-clippy/master/index.html#to_string_trait_impl
 [`todo`]: https://rust-lang.github.io/rust-clippy/master/index.html#todo
 [`too_many_arguments`]: https://rust-lang.github.io/rust-clippy/master/index.html#too_many_arguments
 [`too_many_lines`]: https://rust-lang.github.io/rust-clippy/master/index.html#too_many_lines
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 5342a6722db..7d6f3f3458e 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -657,6 +657,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::tests_outside_test_module::TESTS_OUTSIDE_TEST_MODULE_INFO,
     crate::thread_local_initializer_can_be_made_const::THREAD_LOCAL_INITIALIZER_CAN_BE_MADE_CONST_INFO,
     crate::to_digit_is_some::TO_DIGIT_IS_SOME_INFO,
+    crate::to_string_trait_impl::TO_STRING_TRAIT_IMPL_INFO,
     crate::trailing_empty_array::TRAILING_EMPTY_ARRAY_INFO,
     crate::trait_bounds::TRAIT_DUPLICATION_IN_BOUNDS_INFO,
     crate::trait_bounds::TYPE_REPETITION_IN_BOUNDS_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 907ff938293..10fe5ffebf4 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -327,6 +327,7 @@ mod temporary_assignment;
 mod tests_outside_test_module;
 mod thread_local_initializer_can_be_made_const;
 mod to_digit_is_some;
+mod to_string_trait_impl;
 mod trailing_empty_array;
 mod trait_bounds;
 mod transmute;
@@ -1097,6 +1098,7 @@ pub fn register_lints(store: &mut rustc_lint::LintStore, conf: &'static Conf) {
         Box::new(thread_local_initializer_can_be_made_const::ThreadLocalInitializerCanBeMadeConst::new(msrv()))
     });
     store.register_late_pass(move |_| Box::new(incompatible_msrv::IncompatibleMsrv::new(msrv())));
+    store.register_late_pass(|_| Box::new(to_string_trait_impl::ToStringTraitImpl));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
index 2293b53b42b..bb49985c162 100644
--- a/clippy_lints/src/returns.rs
+++ b/clippy_lints/src/returns.rs
@@ -18,6 +18,7 @@ use rustc_session::declare_lint_pass;
 use rustc_span::def_id::LocalDefId;
 use rustc_span::{BytePos, Pos, Span};
 use std::borrow::Cow;
+use std::fmt::Display;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -146,14 +147,14 @@ impl<'tcx> RetReplacement<'tcx> {
     }
 }
 
-impl<'tcx> ToString for RetReplacement<'tcx> {
-    fn to_string(&self) -> String {
+impl<'tcx> Display for RetReplacement<'tcx> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            Self::Empty => String::new(),
-            Self::Block => "{}".to_string(),
-            Self::Unit => "()".to_string(),
-            Self::IfSequence(inner, _) => format!("({inner})"),
-            Self::Expr(inner, _) => inner.to_string(),
+            Self::Empty => write!(f, ""),
+            Self::Block => write!(f, "{{}}"),
+            Self::Unit => write!(f, "()"),
+            Self::IfSequence(inner, _) => write!(f, "({inner})"),
+            Self::Expr(inner, _) => write!(f, "{inner}"),
         }
     }
 }
diff --git a/clippy_lints/src/to_string_trait_impl.rs b/clippy_lints/src/to_string_trait_impl.rs
new file mode 100644
index 00000000000..e1cea99085f
--- /dev/null
+++ b/clippy_lints/src/to_string_trait_impl.rs
@@ -0,0 +1,67 @@
+use clippy_utils::diagnostics::span_lint_and_help;
+use rustc_hir::{Impl, Item, ItemKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::declare_lint_pass;
+use rustc_span::sym;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for direct implementations of `ToString`.
+    /// ### Why is this bad?
+    /// This trait is automatically implemented for any type which implements the `Display` trait.
+    /// As such, `ToString` shouldn’t be implemented directly: `Display` should be implemented instead,
+    /// and you get the `ToString` implementation for free.
+    /// ### Example
+    /// ```no_run
+    /// struct Point {
+    ///   x: usize,
+    ///   y: usize,
+    /// }
+    ///
+    /// impl ToString for Point {
+    ///   fn to_string(&self) -> String {
+    ///     format!("({}, {})", self.x, self.y)
+    ///   }
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// struct Point {
+    ///   x: usize,
+    ///   y: usize,
+    /// }
+    ///
+    /// impl std::fmt::Display for Point {
+    ///   fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    ///     write!(f, "({}, {})", self.x, self.y)
+    ///   }
+    /// }
+    /// ```
+    #[clippy::version = "1.77.0"]
+    pub TO_STRING_TRAIT_IMPL,
+    style,
+    "check for direct implementations of `ToString`"
+}
+
+declare_lint_pass!(ToStringTraitImpl => [TO_STRING_TRAIT_IMPL]);
+
+impl<'tcx> LateLintPass<'tcx> for ToStringTraitImpl {
+    fn check_item(&mut self, cx: &LateContext<'tcx>, it: &'tcx Item<'tcx>) {
+        if let ItemKind::Impl(Impl {
+            of_trait: Some(trait_ref),
+            ..
+        }) = it.kind
+            && let Some(trait_did) = trait_ref.trait_def_id()
+            && cx.tcx.is_diagnostic_item(sym::ToString, trait_did)
+        {
+            span_lint_and_help(
+                cx,
+                TO_STRING_TRAIT_IMPL,
+                it.span,
+                "direct implementation of `ToString`",
+                None,
+                "prefer implementing `Display` instead",
+            );
+        }
+    }
+}
diff --git a/tests/ui/format_args.fixed b/tests/ui/format_args.fixed
index ddd5976c408..cab20b11e07 100644
--- a/tests/ui/format_args.fixed
+++ b/tests/ui/format_args.fixed
@@ -14,6 +14,7 @@ use std::panic::Location;
 
 struct Somewhere;
 
+#[allow(clippy::to_string_trait_impl)]
 impl ToString for Somewhere {
     fn to_string(&self) -> String {
         String::from("somewhere")
diff --git a/tests/ui/format_args.rs b/tests/ui/format_args.rs
index 18e1bc1af67..bc3645cb2c2 100644
--- a/tests/ui/format_args.rs
+++ b/tests/ui/format_args.rs
@@ -14,6 +14,7 @@ use std::panic::Location;
 
 struct Somewhere;
 
+#[allow(clippy::to_string_trait_impl)]
 impl ToString for Somewhere {
     fn to_string(&self) -> String {
         String::from("somewhere")
diff --git a/tests/ui/format_args.stderr b/tests/ui/format_args.stderr
index dcdfa668aff..2f1714296d6 100644
--- a/tests/ui/format_args.stderr
+++ b/tests/ui/format_args.stderr
@@ -1,5 +1,5 @@
 error: `to_string` applied to a type that implements `Display` in `format!` args
-  --> $DIR/format_args.rs:76:72
+  --> $DIR/format_args.rs:77:72
    |
 LL |     let _ = format!("error: something failed at {}", Location::caller().to_string());
    |                                                                        ^^^^^^^^^^^^ help: remove this
@@ -8,145 +8,145 @@ LL |     let _ = format!("error: something failed at {}", Location::caller().to_
    = help: to override `-D warnings` add `#[allow(clippy::to_string_in_format_args)]`
 
 error: `to_string` applied to a type that implements `Display` in `write!` args
-  --> $DIR/format_args.rs:80:27
+  --> $DIR/format_args.rs:81:27
    |
 LL |         Location::caller().to_string()
    |                           ^^^^^^^^^^^^ help: remove this
 
 error: `to_string` applied to a type that implements `Display` in `writeln!` args
-  --> $DIR/format_args.rs:85:27
+  --> $DIR/format_args.rs:86:27
    |
 LL |         Location::caller().to_string()
    |                           ^^^^^^^^^^^^ help: remove this
 
 error: `to_string` applied to a type that implements `Display` in `print!` args
-  --> $DIR/format_args.rs:87:63
+  --> $DIR/format_args.rs:88:63
    |
 LL |     print!("error: something failed at {}", Location::caller().to_string());
    |                                                               ^^^^^^^^^^^^ help: remove this
 
 error: `to_string` applied to a type that implements `Display` in `println!` args
-  --> $DIR/format_args.rs:88:65
+  --> $DIR/format_args.rs:89:65
    |
 LL |     println!("error: something failed at {}", Location::caller().to_string());
    |                                                                 ^^^^^^^^^^^^ help: remove this
 
 error: `to_string` applied to a type that implements `Display` in `eprint!` args
-  --> $DIR/format_args.rs:89:64
+  --> $DIR/format_args.rs:90:64
    |
 LL |     eprint!("error: something failed at {}", Location::caller().to_string());
    |                                                                ^^^^^^^^^^^^ help: remove this
 
 error: `to_string` applied to a type that implements `Display` in `eprintln!` args
-  --> $DIR/format_args.rs:90:66
+  --> $DIR/format_args.rs:91:66
    |
 LL |     eprintln!("error: something failed at {}", Location::caller().to_string());
    |                                                                  ^^^^^^^^^^^^ help: remove this
 
 error: `to_string` applied to a type that implements `Display` in `format_args!` args
-  --> $DIR/format_args.rs:91:77
+  --> $DIR/format_args.rs:92:77
    |
 LL |     let _ = format_args!("error: something failed at {}", Location::caller().to_string());
    |                                                                             ^^^^^^^^^^^^ help: remove this
 
 error: `to_string` applied to a type that implements `Display` in `assert!` args
-  --> $DIR/format_args.rs:92:70
+  --> $DIR/format_args.rs:93:70
    |
 LL |     assert!(true, "error: something failed at {}", Location::caller().to_string());
    |                                                                      ^^^^^^^^^^^^ help: remove this
 
 error: `to_string` applied to a type that implements `Display` in `assert_eq!` args
-  --> $DIR/format_args.rs:93:73
+  --> $DIR/format_args.rs:94:73
    |
 LL |     assert_eq!(0, 0, "error: something failed at {}", Location::caller().to_string());
    |                                                                         ^^^^^^^^^^^^ help: remove this
 
 error: `to_string` applied to a type that implements `Display` in `assert_ne!` args
-  --> $DIR/format_args.rs:94:73
+  --> $DIR/format_args.rs:95:73
    |
 LL |     assert_ne!(0, 0, "error: something failed at {}", Location::caller().to_string());
    |                                                                         ^^^^^^^^^^^^ help: remove this
 
 error: `to_string` applied to a type that implements `Display` in `panic!` args
-  --> $DIR/format_args.rs:95:63
+  --> $DIR/format_args.rs:96:63
    |
 LL |     panic!("error: something failed at {}", Location::caller().to_string());
    |                                                               ^^^^^^^^^^^^ help: remove this
 
 error: `to_string` applied to a type that implements `Display` in `println!` args
-  --> $DIR/format_args.rs:96:20
+  --> $DIR/format_args.rs:97:20
    |
 LL |     println!("{}", X(1).to_string());
    |                    ^^^^^^^^^^^^^^^^ help: use this: `*X(1)`
 
 error: `to_string` applied to a type that implements `Display` in `println!` args
-  --> $DIR/format_args.rs:97:20
+  --> $DIR/format_args.rs:98:20
    |
 LL |     println!("{}", Y(&X(1)).to_string());
    |                    ^^^^^^^^^^^^^^^^^^^^ help: use this: `***Y(&X(1))`
 
 error: `to_string` applied to a type that implements `Display` in `println!` args
-  --> $DIR/format_args.rs:98:24
+  --> $DIR/format_args.rs:99:24
    |
 LL |     println!("{}", Z(1).to_string());
    |                        ^^^^^^^^^^^^ help: remove this
 
 error: `to_string` applied to a type that implements `Display` in `println!` args
-  --> $DIR/format_args.rs:99:20
+  --> $DIR/format_args.rs:100:20
    |
 LL |     println!("{}", x.to_string());
    |                    ^^^^^^^^^^^^^ help: use this: `**x`
 
 error: `to_string` applied to a type that implements `Display` in `println!` args
-  --> $DIR/format_args.rs:100:20
+  --> $DIR/format_args.rs:101:20
    |
 LL |     println!("{}", x_ref.to_string());
    |                    ^^^^^^^^^^^^^^^^^ help: use this: `***x_ref`
 
 error: `to_string` applied to a type that implements `Display` in `println!` args
-  --> $DIR/format_args.rs:102:39
+  --> $DIR/format_args.rs:103:39
    |
 LL |     println!("{foo}{bar}", foo = "foo".to_string(), bar = "bar");
    |                                       ^^^^^^^^^^^^ help: remove this
 
 error: `to_string` applied to a type that implements `Display` in `println!` args
-  --> $DIR/format_args.rs:103:52
+  --> $DIR/format_args.rs:104:52
    |
 LL |     println!("{foo}{bar}", foo = "foo", bar = "bar".to_string());
    |                                                    ^^^^^^^^^^^^ help: remove this
 
 error: `to_string` applied to a type that implements `Display` in `println!` args
-  --> $DIR/format_args.rs:104:39
+  --> $DIR/format_args.rs:105:39
    |
 LL |     println!("{foo}{bar}", bar = "bar".to_string(), foo = "foo");
    |                                       ^^^^^^^^^^^^ help: remove this
 
 error: `to_string` applied to a type that implements `Display` in `println!` args
-  --> $DIR/format_args.rs:105:52
+  --> $DIR/format_args.rs:106:52
    |
 LL |     println!("{foo}{bar}", bar = "bar", foo = "foo".to_string());
    |                                                    ^^^^^^^^^^^^ help: remove this
 
 error: `to_string` applied to a type that implements `Display` in `print!` args
-  --> $DIR/format_args.rs:117:37
+  --> $DIR/format_args.rs:118:37
    |
 LL |     print!("{}", (Location::caller().to_string()));
    |                                     ^^^^^^^^^^^^ help: remove this
 
 error: `to_string` applied to a type that implements `Display` in `print!` args
-  --> $DIR/format_args.rs:118:39
+  --> $DIR/format_args.rs:119:39
    |
 LL |     print!("{}", ((Location::caller()).to_string()));
    |                                       ^^^^^^^^^^^^ help: remove this
 
 error: `to_string` applied to a type that implements `Display` in `format!` args
-  --> $DIR/format_args.rs:146:38
+  --> $DIR/format_args.rs:147:38
    |
 LL |         let x = format!("{} {}", a, b.to_string());
    |                                      ^^^^^^^^^^^^ help: remove this
 
 error: `to_string` applied to a type that implements `Display` in `println!` args
-  --> $DIR/format_args.rs:160:24
+  --> $DIR/format_args.rs:161:24
    |
 LL |         println!("{}", original[..10].to_string());
    |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use this: `&original[..10]`
diff --git a/tests/ui/to_string_trait_impl.rs b/tests/ui/to_string_trait_impl.rs
new file mode 100644
index 00000000000..b0731632d45
--- /dev/null
+++ b/tests/ui/to_string_trait_impl.rs
@@ -0,0 +1,31 @@
+#![warn(clippy::to_string_trait_impl)]
+
+use std::fmt::{self, Display};
+
+struct Point {
+    x: usize,
+    y: usize,
+}
+
+impl ToString for Point {
+    fn to_string(&self) -> String {
+        format!("({}, {})", self.x, self.y)
+    }
+}
+
+struct Foo;
+
+impl Display for Foo {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "Foo")
+    }
+}
+
+struct Bar;
+
+impl Bar {
+    #[allow(clippy::inherent_to_string)]
+    fn to_string(&self) -> String {
+        String::from("Bar")
+    }
+}
diff --git a/tests/ui/to_string_trait_impl.stderr b/tests/ui/to_string_trait_impl.stderr
new file mode 100644
index 00000000000..55fa9f12c0e
--- /dev/null
+++ b/tests/ui/to_string_trait_impl.stderr
@@ -0,0 +1,16 @@
+error: direct implementation of `ToString`
+  --> $DIR/to_string_trait_impl.rs:10:1
+   |
+LL | / impl ToString for Point {
+LL | |     fn to_string(&self) -> String {
+LL | |         format!("({}, {})", self.x, self.y)
+LL | |     }
+LL | | }
+   | |_^
+   |
+   = help: prefer implementing `Display` instead
+   = note: `-D clippy::to-string-trait-impl` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::to_string_trait_impl)]`
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/unconditional_recursion.rs b/tests/ui/unconditional_recursion.rs
index 7b898a6e0e7..0a3acdae9d3 100644
--- a/tests/ui/unconditional_recursion.rs
+++ b/tests/ui/unconditional_recursion.rs
@@ -206,6 +206,7 @@ impl PartialEq for S8 {
 
 struct S9;
 
+#[allow(clippy::to_string_trait_impl)]
 impl std::string::ToString for S9 {
     fn to_string(&self) -> String {
         //~^ ERROR: function cannot return without recursing
@@ -215,6 +216,7 @@ impl std::string::ToString for S9 {
 
 struct S10;
 
+#[allow(clippy::to_string_trait_impl)]
 impl std::string::ToString for S10 {
     fn to_string(&self) -> String {
         //~^ ERROR: function cannot return without recursing
@@ -225,6 +227,7 @@ impl std::string::ToString for S10 {
 
 struct S11;
 
+#[allow(clippy::to_string_trait_impl)]
 impl std::string::ToString for S11 {
     fn to_string(&self) -> String {
         //~^ ERROR: function cannot return without recursing
diff --git a/tests/ui/unconditional_recursion.stderr b/tests/ui/unconditional_recursion.stderr
index 094b80d4586..93a5eac91d8 100644
--- a/tests/ui/unconditional_recursion.stderr
+++ b/tests/ui/unconditional_recursion.stderr
@@ -23,7 +23,7 @@ LL |         self.eq(other)
    = help: a `loop` may express intention better if this is on purpose
 
 error: function cannot return without recursing
-  --> $DIR/unconditional_recursion.rs:210:5
+  --> $DIR/unconditional_recursion.rs:211:5
    |
 LL |     fn to_string(&self) -> String {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot return without recursing
@@ -34,7 +34,7 @@ LL |         self.to_string()
    = help: a `loop` may express intention better if this is on purpose
 
 error: function cannot return without recursing
-  --> $DIR/unconditional_recursion.rs:219:5
+  --> $DIR/unconditional_recursion.rs:221:5
    |
 LL |     fn to_string(&self) -> String {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot return without recursing
@@ -45,7 +45,7 @@ LL |         x.to_string()
    = help: a `loop` may express intention better if this is on purpose
 
 error: function cannot return without recursing
-  --> $DIR/unconditional_recursion.rs:229:5
+  --> $DIR/unconditional_recursion.rs:232:5
    |
 LL |     fn to_string(&self) -> String {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot return without recursing
@@ -326,7 +326,7 @@ LL |         mine == theirs
    |         ^^^^^^^^^^^^^^
 
 error: function cannot return without recursing
-  --> $DIR/unconditional_recursion.rs:244:5
+  --> $DIR/unconditional_recursion.rs:247:5
    |
 LL | /     fn new() -> Self {
 LL | |
@@ -335,13 +335,13 @@ LL | |     }
    | |_____^
    |
 note: recursive call site
-  --> $DIR/unconditional_recursion.rs:246:9
+  --> $DIR/unconditional_recursion.rs:249:9
    |
 LL |         Self::default()
    |         ^^^^^^^^^^^^^^^
 
 error: function cannot return without recursing
-  --> $DIR/unconditional_recursion.rs:283:5
+  --> $DIR/unconditional_recursion.rs:286:5
    |
 LL | /     fn eq(&self, other: &Self) -> bool {
 LL | |
@@ -352,7 +352,7 @@ LL | |     }
    | |_____^
    |
 note: recursive call site
-  --> $DIR/unconditional_recursion.rs:287:9
+  --> $DIR/unconditional_recursion.rs:290:9
    |
 LL |         mine.eq(theirs)
    |         ^^^^^^^^^^^^^^^
diff --git a/tests/ui/unnecessary_to_owned.fixed b/tests/ui/unnecessary_to_owned.fixed
index 2dd1d746626..7f01c981a93 100644
--- a/tests/ui/unnecessary_to_owned.fixed
+++ b/tests/ui/unnecessary_to_owned.fixed
@@ -27,6 +27,7 @@ impl AsRef<str> for X {
     }
 }
 
+#[allow(clippy::to_string_trait_impl)]
 impl ToString for X {
     fn to_string(&self) -> String {
         self.0.to_string()
@@ -265,6 +266,7 @@ mod issue_8507 {
         }
     }
 
+    #[allow(clippy::to_string_trait_impl)]
     impl ToString for Y {
         fn to_string(&self) -> String {
             self.0.to_string()
@@ -338,6 +340,7 @@ mod issue_9317 {
 
     struct Bytes {}
 
+    #[allow(clippy::to_string_trait_impl)]
     impl ToString for Bytes {
         fn to_string(&self) -> String {
             "123".to_string()
diff --git a/tests/ui/unnecessary_to_owned.rs b/tests/ui/unnecessary_to_owned.rs
index 17fad33402b..a270ed1e1c2 100644
--- a/tests/ui/unnecessary_to_owned.rs
+++ b/tests/ui/unnecessary_to_owned.rs
@@ -27,6 +27,7 @@ impl AsRef<str> for X {
     }
 }
 
+#[allow(clippy::to_string_trait_impl)]
 impl ToString for X {
     fn to_string(&self) -> String {
         self.0.to_string()
@@ -265,6 +266,7 @@ mod issue_8507 {
         }
     }
 
+    #[allow(clippy::to_string_trait_impl)]
     impl ToString for Y {
         fn to_string(&self) -> String {
             self.0.to_string()
@@ -338,6 +340,7 @@ mod issue_9317 {
 
     struct Bytes {}
 
+    #[allow(clippy::to_string_trait_impl)]
     impl ToString for Bytes {
         fn to_string(&self) -> String {
             "123".to_string()
diff --git a/tests/ui/unnecessary_to_owned.stderr b/tests/ui/unnecessary_to_owned.stderr
index ad6fa422b8c..95ff5f2ec2c 100644
--- a/tests/ui/unnecessary_to_owned.stderr
+++ b/tests/ui/unnecessary_to_owned.stderr
@@ -1,11 +1,11 @@
 error: redundant clone
-  --> $DIR/unnecessary_to_owned.rs:154:64
+  --> $DIR/unnecessary_to_owned.rs:155:64
    |
 LL |     require_c_str(&CString::from_vec_with_nul(vec![0]).unwrap().to_owned());
    |                                                                ^^^^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> $DIR/unnecessary_to_owned.rs:154:20
+  --> $DIR/unnecessary_to_owned.rs:155:20
    |
 LL |     require_c_str(&CString::from_vec_with_nul(vec![0]).unwrap().to_owned());
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -13,55 +13,55 @@ LL |     require_c_str(&CString::from_vec_with_nul(vec![0]).unwrap().to_owned())
    = help: to override `-D warnings` add `#[allow(clippy::redundant_clone)]`
 
 error: redundant clone
-  --> $DIR/unnecessary_to_owned.rs:155:40
+  --> $DIR/unnecessary_to_owned.rs:156:40
    |
 LL |     require_os_str(&OsString::from("x").to_os_string());
    |                                        ^^^^^^^^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> $DIR/unnecessary_to_owned.rs:155:21
+  --> $DIR/unnecessary_to_owned.rs:156:21
    |
 LL |     require_os_str(&OsString::from("x").to_os_string());
    |                     ^^^^^^^^^^^^^^^^^^^
 
 error: redundant clone
-  --> $DIR/unnecessary_to_owned.rs:156:48
+  --> $DIR/unnecessary_to_owned.rs:157:48
    |
 LL |     require_path(&std::path::PathBuf::from("x").to_path_buf());
    |                                                ^^^^^^^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> $DIR/unnecessary_to_owned.rs:156:19
+  --> $DIR/unnecessary_to_owned.rs:157:19
    |
 LL |     require_path(&std::path::PathBuf::from("x").to_path_buf());
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: redundant clone
-  --> $DIR/unnecessary_to_owned.rs:157:35
+  --> $DIR/unnecessary_to_owned.rs:158:35
    |
 LL |     require_str(&String::from("x").to_string());
    |                                   ^^^^^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> $DIR/unnecessary_to_owned.rs:157:18
+  --> $DIR/unnecessary_to_owned.rs:158:18
    |
 LL |     require_str(&String::from("x").to_string());
    |                  ^^^^^^^^^^^^^^^^^
 
 error: redundant clone
-  --> $DIR/unnecessary_to_owned.rs:158:39
+  --> $DIR/unnecessary_to_owned.rs:159:39
    |
 LL |     require_slice(&[String::from("x")].to_owned());
    |                                       ^^^^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> $DIR/unnecessary_to_owned.rs:158:20
+  --> $DIR/unnecessary_to_owned.rs:159:20
    |
 LL |     require_slice(&[String::from("x")].to_owned());
    |                    ^^^^^^^^^^^^^^^^^^^
 
 error: unnecessary use of `into_owned`
-  --> $DIR/unnecessary_to_owned.rs:63:36
+  --> $DIR/unnecessary_to_owned.rs:64:36
    |
 LL |     require_c_str(&Cow::from(c_str).into_owned());
    |                                    ^^^^^^^^^^^^^ help: remove this
@@ -70,415 +70,415 @@ LL |     require_c_str(&Cow::from(c_str).into_owned());
    = help: to override `-D warnings` add `#[allow(clippy::unnecessary_to_owned)]`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:64:19
+  --> $DIR/unnecessary_to_owned.rs:65:19
    |
 LL |     require_c_str(&c_str.to_owned());
    |                   ^^^^^^^^^^^^^^^^^ help: use: `c_str`
 
 error: unnecessary use of `to_os_string`
-  --> $DIR/unnecessary_to_owned.rs:66:20
+  --> $DIR/unnecessary_to_owned.rs:67:20
    |
 LL |     require_os_str(&os_str.to_os_string());
    |                    ^^^^^^^^^^^^^^^^^^^^^^ help: use: `os_str`
 
 error: unnecessary use of `into_owned`
-  --> $DIR/unnecessary_to_owned.rs:67:38
+  --> $DIR/unnecessary_to_owned.rs:68:38
    |
 LL |     require_os_str(&Cow::from(os_str).into_owned());
    |                                      ^^^^^^^^^^^^^ help: remove this
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:68:20
+  --> $DIR/unnecessary_to_owned.rs:69:20
    |
 LL |     require_os_str(&os_str.to_owned());
    |                    ^^^^^^^^^^^^^^^^^^ help: use: `os_str`
 
 error: unnecessary use of `to_path_buf`
-  --> $DIR/unnecessary_to_owned.rs:70:18
+  --> $DIR/unnecessary_to_owned.rs:71:18
    |
 LL |     require_path(&path.to_path_buf());
    |                  ^^^^^^^^^^^^^^^^^^^ help: use: `path`
 
 error: unnecessary use of `into_owned`
-  --> $DIR/unnecessary_to_owned.rs:71:34
+  --> $DIR/unnecessary_to_owned.rs:72:34
    |
 LL |     require_path(&Cow::from(path).into_owned());
    |                                  ^^^^^^^^^^^^^ help: remove this
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:72:18
+  --> $DIR/unnecessary_to_owned.rs:73:18
    |
 LL |     require_path(&path.to_owned());
    |                  ^^^^^^^^^^^^^^^^ help: use: `path`
 
 error: unnecessary use of `to_string`
-  --> $DIR/unnecessary_to_owned.rs:74:17
+  --> $DIR/unnecessary_to_owned.rs:75:17
    |
 LL |     require_str(&s.to_string());
    |                 ^^^^^^^^^^^^^^ help: use: `s`
 
 error: unnecessary use of `into_owned`
-  --> $DIR/unnecessary_to_owned.rs:75:30
+  --> $DIR/unnecessary_to_owned.rs:76:30
    |
 LL |     require_str(&Cow::from(s).into_owned());
    |                              ^^^^^^^^^^^^^ help: remove this
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:76:17
+  --> $DIR/unnecessary_to_owned.rs:77:17
    |
 LL |     require_str(&s.to_owned());
    |                 ^^^^^^^^^^^^^ help: use: `s`
 
 error: unnecessary use of `to_string`
-  --> $DIR/unnecessary_to_owned.rs:77:17
+  --> $DIR/unnecessary_to_owned.rs:78:17
    |
 LL |     require_str(&x_ref.to_string());
    |                 ^^^^^^^^^^^^^^^^^^ help: use: `x_ref.as_ref()`
 
 error: unnecessary use of `to_vec`
-  --> $DIR/unnecessary_to_owned.rs:79:19
+  --> $DIR/unnecessary_to_owned.rs:80:19
    |
 LL |     require_slice(&slice.to_vec());
    |                   ^^^^^^^^^^^^^^^ help: use: `slice`
 
 error: unnecessary use of `into_owned`
-  --> $DIR/unnecessary_to_owned.rs:80:36
+  --> $DIR/unnecessary_to_owned.rs:81:36
    |
 LL |     require_slice(&Cow::from(slice).into_owned());
    |                                    ^^^^^^^^^^^^^ help: remove this
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:81:19
+  --> $DIR/unnecessary_to_owned.rs:82:19
    |
 LL |     require_slice(&array.to_owned());
    |                   ^^^^^^^^^^^^^^^^^ help: use: `array.as_ref()`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:82:19
+  --> $DIR/unnecessary_to_owned.rs:83:19
    |
 LL |     require_slice(&array_ref.to_owned());
    |                   ^^^^^^^^^^^^^^^^^^^^^ help: use: `array_ref.as_ref()`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:83:19
+  --> $DIR/unnecessary_to_owned.rs:84:19
    |
 LL |     require_slice(&slice.to_owned());
    |                   ^^^^^^^^^^^^^^^^^ help: use: `slice`
 
 error: unnecessary use of `into_owned`
-  --> $DIR/unnecessary_to_owned.rs:86:42
+  --> $DIR/unnecessary_to_owned.rs:87:42
    |
 LL |     require_x(&Cow::<X>::Owned(x.clone()).into_owned());
    |                                          ^^^^^^^^^^^^^ help: remove this
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:89:25
+  --> $DIR/unnecessary_to_owned.rs:90:25
    |
 LL |     require_deref_c_str(c_str.to_owned());
    |                         ^^^^^^^^^^^^^^^^ help: use: `c_str`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:90:26
+  --> $DIR/unnecessary_to_owned.rs:91:26
    |
 LL |     require_deref_os_str(os_str.to_owned());
    |                          ^^^^^^^^^^^^^^^^^ help: use: `os_str`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:91:24
+  --> $DIR/unnecessary_to_owned.rs:92:24
    |
 LL |     require_deref_path(path.to_owned());
    |                        ^^^^^^^^^^^^^^^ help: use: `path`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:92:23
+  --> $DIR/unnecessary_to_owned.rs:93:23
    |
 LL |     require_deref_str(s.to_owned());
    |                       ^^^^^^^^^^^^ help: use: `s`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:93:25
+  --> $DIR/unnecessary_to_owned.rs:94:25
    |
 LL |     require_deref_slice(slice.to_owned());
    |                         ^^^^^^^^^^^^^^^^ help: use: `slice`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:95:30
+  --> $DIR/unnecessary_to_owned.rs:96:30
    |
 LL |     require_impl_deref_c_str(c_str.to_owned());
    |                              ^^^^^^^^^^^^^^^^ help: use: `c_str`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:96:31
+  --> $DIR/unnecessary_to_owned.rs:97:31
    |
 LL |     require_impl_deref_os_str(os_str.to_owned());
    |                               ^^^^^^^^^^^^^^^^^ help: use: `os_str`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:97:29
+  --> $DIR/unnecessary_to_owned.rs:98:29
    |
 LL |     require_impl_deref_path(path.to_owned());
    |                             ^^^^^^^^^^^^^^^ help: use: `path`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:98:28
+  --> $DIR/unnecessary_to_owned.rs:99:28
    |
 LL |     require_impl_deref_str(s.to_owned());
    |                            ^^^^^^^^^^^^ help: use: `s`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:99:30
+  --> $DIR/unnecessary_to_owned.rs:100:30
    |
 LL |     require_impl_deref_slice(slice.to_owned());
    |                              ^^^^^^^^^^^^^^^^ help: use: `slice`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:101:29
+  --> $DIR/unnecessary_to_owned.rs:102:29
    |
 LL |     require_deref_str_slice(s.to_owned(), slice.to_owned());
    |                             ^^^^^^^^^^^^ help: use: `s`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:101:43
+  --> $DIR/unnecessary_to_owned.rs:102:43
    |
 LL |     require_deref_str_slice(s.to_owned(), slice.to_owned());
    |                                           ^^^^^^^^^^^^^^^^ help: use: `slice`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:102:29
+  --> $DIR/unnecessary_to_owned.rs:103:29
    |
 LL |     require_deref_slice_str(slice.to_owned(), s.to_owned());
    |                             ^^^^^^^^^^^^^^^^ help: use: `slice`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:102:47
+  --> $DIR/unnecessary_to_owned.rs:103:47
    |
 LL |     require_deref_slice_str(slice.to_owned(), s.to_owned());
    |                                               ^^^^^^^^^^^^ help: use: `s`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:104:26
+  --> $DIR/unnecessary_to_owned.rs:105:26
    |
 LL |     require_as_ref_c_str(c_str.to_owned());
    |                          ^^^^^^^^^^^^^^^^ help: use: `c_str`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:105:27
+  --> $DIR/unnecessary_to_owned.rs:106:27
    |
 LL |     require_as_ref_os_str(os_str.to_owned());
    |                           ^^^^^^^^^^^^^^^^^ help: use: `os_str`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:106:25
+  --> $DIR/unnecessary_to_owned.rs:107:25
    |
 LL |     require_as_ref_path(path.to_owned());
    |                         ^^^^^^^^^^^^^^^ help: use: `path`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:107:24
+  --> $DIR/unnecessary_to_owned.rs:108:24
    |
 LL |     require_as_ref_str(s.to_owned());
    |                        ^^^^^^^^^^^^ help: use: `s`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:108:24
+  --> $DIR/unnecessary_to_owned.rs:109:24
    |
 LL |     require_as_ref_str(x.to_owned());
    |                        ^^^^^^^^^^^^ help: use: `&x`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:109:26
+  --> $DIR/unnecessary_to_owned.rs:110:26
    |
 LL |     require_as_ref_slice(array.to_owned());
    |                          ^^^^^^^^^^^^^^^^ help: use: `array`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:110:26
+  --> $DIR/unnecessary_to_owned.rs:111:26
    |
 LL |     require_as_ref_slice(array_ref.to_owned());
    |                          ^^^^^^^^^^^^^^^^^^^^ help: use: `array_ref`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:111:26
+  --> $DIR/unnecessary_to_owned.rs:112:26
    |
 LL |     require_as_ref_slice(slice.to_owned());
    |                          ^^^^^^^^^^^^^^^^ help: use: `slice`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:113:31
+  --> $DIR/unnecessary_to_owned.rs:114:31
    |
 LL |     require_impl_as_ref_c_str(c_str.to_owned());
    |                               ^^^^^^^^^^^^^^^^ help: use: `c_str`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:114:32
+  --> $DIR/unnecessary_to_owned.rs:115:32
    |
 LL |     require_impl_as_ref_os_str(os_str.to_owned());
    |                                ^^^^^^^^^^^^^^^^^ help: use: `os_str`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:115:30
+  --> $DIR/unnecessary_to_owned.rs:116:30
    |
 LL |     require_impl_as_ref_path(path.to_owned());
    |                              ^^^^^^^^^^^^^^^ help: use: `path`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:116:29
+  --> $DIR/unnecessary_to_owned.rs:117:29
    |
 LL |     require_impl_as_ref_str(s.to_owned());
    |                             ^^^^^^^^^^^^ help: use: `s`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:117:29
+  --> $DIR/unnecessary_to_owned.rs:118:29
    |
 LL |     require_impl_as_ref_str(x.to_owned());
    |                             ^^^^^^^^^^^^ help: use: `&x`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:118:31
+  --> $DIR/unnecessary_to_owned.rs:119:31
    |
 LL |     require_impl_as_ref_slice(array.to_owned());
    |                               ^^^^^^^^^^^^^^^^ help: use: `array`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:119:31
+  --> $DIR/unnecessary_to_owned.rs:120:31
    |
 LL |     require_impl_as_ref_slice(array_ref.to_owned());
    |                               ^^^^^^^^^^^^^^^^^^^^ help: use: `array_ref`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:120:31
+  --> $DIR/unnecessary_to_owned.rs:121:31
    |
 LL |     require_impl_as_ref_slice(slice.to_owned());
    |                               ^^^^^^^^^^^^^^^^ help: use: `slice`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:122:30
+  --> $DIR/unnecessary_to_owned.rs:123:30
    |
 LL |     require_as_ref_str_slice(s.to_owned(), array.to_owned());
    |                              ^^^^^^^^^^^^ help: use: `s`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:122:44
+  --> $DIR/unnecessary_to_owned.rs:123:44
    |
 LL |     require_as_ref_str_slice(s.to_owned(), array.to_owned());
    |                                            ^^^^^^^^^^^^^^^^ help: use: `array`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:123:30
+  --> $DIR/unnecessary_to_owned.rs:124:30
    |
 LL |     require_as_ref_str_slice(s.to_owned(), array_ref.to_owned());
    |                              ^^^^^^^^^^^^ help: use: `s`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:123:44
+  --> $DIR/unnecessary_to_owned.rs:124:44
    |
 LL |     require_as_ref_str_slice(s.to_owned(), array_ref.to_owned());
    |                                            ^^^^^^^^^^^^^^^^^^^^ help: use: `array_ref`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:124:30
+  --> $DIR/unnecessary_to_owned.rs:125:30
    |
 LL |     require_as_ref_str_slice(s.to_owned(), slice.to_owned());
    |                              ^^^^^^^^^^^^ help: use: `s`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:124:44
+  --> $DIR/unnecessary_to_owned.rs:125:44
    |
 LL |     require_as_ref_str_slice(s.to_owned(), slice.to_owned());
    |                                            ^^^^^^^^^^^^^^^^ help: use: `slice`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:125:30
+  --> $DIR/unnecessary_to_owned.rs:126:30
    |
 LL |     require_as_ref_slice_str(array.to_owned(), s.to_owned());
    |                              ^^^^^^^^^^^^^^^^ help: use: `array`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:125:48
+  --> $DIR/unnecessary_to_owned.rs:126:48
    |
 LL |     require_as_ref_slice_str(array.to_owned(), s.to_owned());
    |                                                ^^^^^^^^^^^^ help: use: `s`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:126:30
+  --> $DIR/unnecessary_to_owned.rs:127:30
    |
 LL |     require_as_ref_slice_str(array_ref.to_owned(), s.to_owned());
    |                              ^^^^^^^^^^^^^^^^^^^^ help: use: `array_ref`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:126:52
+  --> $DIR/unnecessary_to_owned.rs:127:52
    |
 LL |     require_as_ref_slice_str(array_ref.to_owned(), s.to_owned());
    |                                                    ^^^^^^^^^^^^ help: use: `s`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:127:30
+  --> $DIR/unnecessary_to_owned.rs:128:30
    |
 LL |     require_as_ref_slice_str(slice.to_owned(), s.to_owned());
    |                              ^^^^^^^^^^^^^^^^ help: use: `slice`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:127:48
+  --> $DIR/unnecessary_to_owned.rs:128:48
    |
 LL |     require_as_ref_slice_str(slice.to_owned(), s.to_owned());
    |                                                ^^^^^^^^^^^^ help: use: `s`
 
 error: unnecessary use of `to_string`
-  --> $DIR/unnecessary_to_owned.rs:129:20
+  --> $DIR/unnecessary_to_owned.rs:130:20
    |
 LL |     let _ = x.join(&x_ref.to_string());
    |                    ^^^^^^^^^^^^^^^^^^ help: use: `x_ref`
 
 error: unnecessary use of `to_vec`
-  --> $DIR/unnecessary_to_owned.rs:131:13
+  --> $DIR/unnecessary_to_owned.rs:132:13
    |
 LL |     let _ = slice.to_vec().into_iter();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `slice.iter().copied()`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:132:13
+  --> $DIR/unnecessary_to_owned.rs:133:13
    |
 LL |     let _ = slice.to_owned().into_iter();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `slice.iter().copied()`
 
 error: unnecessary use of `to_vec`
-  --> $DIR/unnecessary_to_owned.rs:133:13
+  --> $DIR/unnecessary_to_owned.rs:134:13
    |
 LL |     let _ = [std::path::PathBuf::new()][..].to_vec().into_iter();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `[std::path::PathBuf::new()][..].iter().cloned()`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:134:13
+  --> $DIR/unnecessary_to_owned.rs:135:13
    |
 LL |     let _ = [std::path::PathBuf::new()][..].to_owned().into_iter();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `[std::path::PathBuf::new()][..].iter().cloned()`
 
 error: unnecessary use of `to_vec`
-  --> $DIR/unnecessary_to_owned.rs:136:13
+  --> $DIR/unnecessary_to_owned.rs:137:13
    |
 LL |     let _ = IntoIterator::into_iter(slice.to_vec());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `slice.iter().copied()`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:137:13
+  --> $DIR/unnecessary_to_owned.rs:138:13
    |
 LL |     let _ = IntoIterator::into_iter(slice.to_owned());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `slice.iter().copied()`
 
 error: unnecessary use of `to_vec`
-  --> $DIR/unnecessary_to_owned.rs:138:13
+  --> $DIR/unnecessary_to_owned.rs:139:13
    |
 LL |     let _ = IntoIterator::into_iter([std::path::PathBuf::new()][..].to_vec());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `[std::path::PathBuf::new()][..].iter().cloned()`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned.rs:139:13
+  --> $DIR/unnecessary_to_owned.rs:140:13
    |
 LL |     let _ = IntoIterator::into_iter([std::path::PathBuf::new()][..].to_owned());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `[std::path::PathBuf::new()][..].iter().cloned()`
 
 error: unnecessary use of `to_vec`
-  --> $DIR/unnecessary_to_owned.rs:201:14
+  --> $DIR/unnecessary_to_owned.rs:202:14
    |
 LL |     for t in file_types.to_vec() {
    |              ^^^^^^^^^^^^^^^^^^^
@@ -494,31 +494,31 @@ LL +         let path = match get_file_path(t) {
    |
 
 error: unnecessary use of `to_vec`
-  --> $DIR/unnecessary_to_owned.rs:224:14
+  --> $DIR/unnecessary_to_owned.rs:225:14
    |
 LL |     let _ = &["x"][..].to_vec().into_iter();
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `["x"][..].iter().cloned()`
 
 error: unnecessary use of `to_vec`
-  --> $DIR/unnecessary_to_owned.rs:229:14
+  --> $DIR/unnecessary_to_owned.rs:230:14
    |
 LL |     let _ = &["x"][..].to_vec().into_iter();
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `["x"][..].iter().copied()`
 
 error: unnecessary use of `to_string`
-  --> $DIR/unnecessary_to_owned.rs:276:24
+  --> $DIR/unnecessary_to_owned.rs:278:24
    |
 LL |         Box::new(build(y.to_string()))
    |                        ^^^^^^^^^^^^^ help: use: `y`
 
 error: unnecessary use of `to_string`
-  --> $DIR/unnecessary_to_owned.rs:384:12
+  --> $DIR/unnecessary_to_owned.rs:387:12
    |
 LL |         id("abc".to_string())
    |            ^^^^^^^^^^^^^^^^^ help: use: `"abc"`
 
 error: unnecessary use of `to_vec`
-  --> $DIR/unnecessary_to_owned.rs:527:37
+  --> $DIR/unnecessary_to_owned.rs:530:37
    |
 LL |         IntoFuture::into_future(foo([].to_vec(), &0));
    |                                     ^^^^^^^^^^^ help: use: `[]`
diff --git a/tests/ui/unnecessary_to_owned_on_split.fixed b/tests/ui/unnecessary_to_owned_on_split.fixed
index f87c898f9b7..e0ba216f41b 100644
--- a/tests/ui/unnecessary_to_owned_on_split.fixed
+++ b/tests/ui/unnecessary_to_owned_on_split.fixed
@@ -8,6 +8,7 @@ impl AsRef<str> for Issue12068 {
     }
 }
 
+#[allow(clippy::to_string_trait_impl)]
 impl ToString for Issue12068 {
     fn to_string(&self) -> String {
         String::new()
diff --git a/tests/ui/unnecessary_to_owned_on_split.rs b/tests/ui/unnecessary_to_owned_on_split.rs
index db5719e5880..70efc6ebba5 100644
--- a/tests/ui/unnecessary_to_owned_on_split.rs
+++ b/tests/ui/unnecessary_to_owned_on_split.rs
@@ -8,6 +8,7 @@ impl AsRef<str> for Issue12068 {
     }
 }
 
+#[allow(clippy::to_string_trait_impl)]
 impl ToString for Issue12068 {
     fn to_string(&self) -> String {
         String::new()
diff --git a/tests/ui/unnecessary_to_owned_on_split.stderr b/tests/ui/unnecessary_to_owned_on_split.stderr
index 4cfaeed3384..9aea15b48bf 100644
--- a/tests/ui/unnecessary_to_owned_on_split.stderr
+++ b/tests/ui/unnecessary_to_owned_on_split.stderr
@@ -1,5 +1,5 @@
 error: unnecessary use of `to_string`
-  --> $DIR/unnecessary_to_owned_on_split.rs:18:13
+  --> $DIR/unnecessary_to_owned_on_split.rs:19:13
    |
 LL |     let _ = "a".to_string().split('a').next().unwrap();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `"a".split('a')`
@@ -8,49 +8,49 @@ LL |     let _ = "a".to_string().split('a').next().unwrap();
    = help: to override `-D warnings` add `#[allow(clippy::unnecessary_to_owned)]`
 
 error: unnecessary use of `to_string`
-  --> $DIR/unnecessary_to_owned_on_split.rs:20:13
+  --> $DIR/unnecessary_to_owned_on_split.rs:21:13
    |
 LL |     let _ = "a".to_string().split("a").next().unwrap();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `"a".split("a")`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned_on_split.rs:22:13
+  --> $DIR/unnecessary_to_owned_on_split.rs:23:13
    |
 LL |     let _ = "a".to_owned().split('a').next().unwrap();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `"a".split('a')`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned_on_split.rs:24:13
+  --> $DIR/unnecessary_to_owned_on_split.rs:25:13
    |
 LL |     let _ = "a".to_owned().split("a").next().unwrap();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `"a".split("a")`
 
 error: unnecessary use of `to_string`
-  --> $DIR/unnecessary_to_owned_on_split.rs:26:13
+  --> $DIR/unnecessary_to_owned_on_split.rs:27:13
    |
 LL |     let _ = Issue12068.to_string().split('a').next().unwrap();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `Issue12068.as_ref().split('a')`
 
 error: unnecessary use of `to_vec`
-  --> $DIR/unnecessary_to_owned_on_split.rs:29:13
+  --> $DIR/unnecessary_to_owned_on_split.rs:30:13
    |
 LL |     let _ = [1].to_vec().split(|x| *x == 2).next().unwrap();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `[1].split(|x| *x == 2)`
 
 error: unnecessary use of `to_vec`
-  --> $DIR/unnecessary_to_owned_on_split.rs:31:13
+  --> $DIR/unnecessary_to_owned_on_split.rs:32:13
    |
 LL |     let _ = [1].to_vec().split(|x| *x == 2).next().unwrap();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `[1].split(|x| *x == 2)`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned_on_split.rs:33:13
+  --> $DIR/unnecessary_to_owned_on_split.rs:34:13
    |
 LL |     let _ = [1].to_owned().split(|x| *x == 2).next().unwrap();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `[1].split(|x| *x == 2)`
 
 error: unnecessary use of `to_owned`
-  --> $DIR/unnecessary_to_owned_on_split.rs:35:13
+  --> $DIR/unnecessary_to_owned_on_split.rs:36:13
    |
 LL |     let _ = [1].to_owned().split(|x| *x == 2).next().unwrap();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `[1].split(|x| *x == 2)`
-- 
cgit 1.4.1-3-g733a5


From ff5afac6167f1af9413bc8bc7a95626a91a489f2 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Sat, 27 Jan 2024 17:07:10 +0100
Subject: [`never_loop`]: recognize `?` desugaring in try blocks

---
 clippy_lints/src/loops/never_loop.rs |  6 +++---
 tests/ui/never_loop.rs               | 11 ++++++++++-
 2 files changed, 13 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/never_loop.rs b/clippy_lints/src/loops/never_loop.rs
index 62bc663191f..245a903f998 100644
--- a/clippy_lints/src/loops/never_loop.rs
+++ b/clippy_lints/src/loops/never_loop.rs
@@ -201,12 +201,12 @@ fn never_loop_expr<'tcx>(
                 })
             })
         },
-        ExprKind::Block(b, l) => {
-            if l.is_some() {
+        ExprKind::Block(b, _) => {
+            if b.targeted_by_break {
                 local_labels.push((b.hir_id, false));
             }
             let ret = never_loop_block(cx, b, local_labels, main_loop_id);
-            let jumped_to = l.is_some() && local_labels.pop().unwrap().1;
+            let jumped_to = b.targeted_by_break && local_labels.pop().unwrap().1;
             match ret {
                 NeverLoopResult::Diverging if jumped_to => NeverLoopResult::Normal,
                 _ => ret,
diff --git a/tests/ui/never_loop.rs b/tests/ui/never_loop.rs
index c67a6d4494e..92f173d9db4 100644
--- a/tests/ui/never_loop.rs
+++ b/tests/ui/never_loop.rs
@@ -1,4 +1,4 @@
-#![feature(inline_const)]
+#![feature(inline_const, try_blocks)]
 #![allow(
     clippy::eq_op,
     clippy::single_match,
@@ -400,6 +400,15 @@ pub fn test32() {
     }
 }
 
+pub fn issue12205() -> Option<()> {
+    loop {
+        let _: Option<_> = try {
+            None?;
+            return Some(());
+        };
+    }
+}
+
 fn main() {
     test1();
     test2();
-- 
cgit 1.4.1-3-g733a5


From 3aa2c279c8d1a64c8ecbf4c4e9f1b5bc8f9c4883 Mon Sep 17 00:00:00 2001
From: Quinn Sinclair <me@partiallytyped.dev>
Date: Sun, 28 Jan 2024 22:43:40 +0100
Subject: rewrote to match only Result::err cons

---
 clippy_lints/src/returns.rs                        | 42 ++++++++--------------
 tests/ui/needless_return_with_question_mark.fixed  | 15 +++++---
 tests/ui/needless_return_with_question_mark.rs     | 14 +++++---
 tests/ui/needless_return_with_question_mark.stderr |  8 +----
 4 files changed, 35 insertions(+), 44 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
index 2d4e7d269fd..1047793b822 100644
--- a/clippy_lints/src/returns.rs
+++ b/clippy_lints/src/returns.rs
@@ -2,10 +2,14 @@ use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then, span_lin
 use clippy_utils::source::{snippet_opt, snippet_with_context};
 use clippy_utils::sugg::has_enclosing_paren;
 use clippy_utils::visitors::{for_each_expr_with_closures, Descend};
-use clippy_utils::{fn_def_id, is_from_proc_macro, is_inside_let_else, path_to_local_id, span_find_starting_semi};
+use clippy_utils::{
+    fn_def_id, is_from_proc_macro, is_inside_let_else, is_res_lang_ctor, path_res, path_to_local_id,
+    span_find_starting_semi,
+};
 use core::ops::ControlFlow;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::FnKind;
+use rustc_hir::LangItem::ResultErr;
 use rustc_hir::{
     Block, Body, Expr, ExprKind, FnDecl, HirId, ItemKind, LangItem, MatchSource, Node, OwnerNode, PatKind, QPath, Stmt,
     StmtKind,
@@ -176,37 +180,20 @@ fn stmt_needs_never_type(cx: &LateContext<'_>, stmt_hir_id: HirId) -> bool {
         })
 }
 
-///
-/// The expression of the desugared `try` operator is a match over an expression with type:
-/// `ControlFlow<A:Result<Infallible, E>, B:Result<_, E'>>`, with final type `B`.
-/// If E and E' are the same type, then there is no error conversion happening.
-/// Error conversion happens when E can be transformed into E' via a `From` or `Into` conversion.
-fn desugar_expr_performs_error_conversion(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-    let ty = cx.typeck_results().expr_ty(expr);
-
-    if let ty::Adt(_, generics) = ty.kind()
-        && let Some(brk) = generics.first()
-        && let Some(cont) = generics.get(1)
-        && let Some(brk_type) = brk.as_type()
-        && let Some(cont_type) = cont.as_type()
-        && let ty::Adt(_, brk_generics) = brk_type.kind()
-        && let ty::Adt(_, cont_generics) = cont_type.kind()
-        && let Some(brk_err) = brk_generics.get(1)
-        && let Some(cont_err) = cont_generics.get(1)
-        && let Some(brk_err_type) = brk_err.as_type()
-        && let Some(cont_err_type) = cont_err.as_type()
-    {
-        return brk_err_type != cont_err_type;
-    }
-    false
-}
-
 impl<'tcx> LateLintPass<'tcx> for Return {
     fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) {
         if !in_external_macro(cx.sess(), stmt.span)
             && let StmtKind::Semi(expr) = stmt.kind
             && let ExprKind::Ret(Some(ret)) = expr.kind
-            && let ExprKind::Match(match_expr, _, MatchSource::TryDesugar(..)) = ret.kind
+            // return Err(...)? desugars to a match
+            // over a Err(...).branch()
+            // which breaks down to a branch call, with the callee being
+            // the constructor of the Err variant
+            && let ExprKind::Match(maybe_cons, _, MatchSource::TryDesugar(_)) = ret.kind
+            && let ExprKind::Call(_, [maybe_result_err]) = maybe_cons.kind
+            && let ExprKind::Call(maybe_constr, _) = maybe_result_err.kind
+            && is_res_lang_ctor(cx, path_res(cx, maybe_constr), ResultErr)
+
             // Ensure this is not the final stmt, otherwise removing it would cause a compile error
             && let OwnerNode::Item(item) = cx.tcx.hir().owner(cx.tcx.hir().get_parent_item(expr.hir_id))
             && let ItemKind::Fn(_, _, body) = item.kind
@@ -217,7 +204,6 @@ impl<'tcx> LateLintPass<'tcx> for Return {
             && final_stmt.hir_id != stmt.hir_id
             && !is_from_proc_macro(cx, expr)
             && !stmt_needs_never_type(cx, stmt.hir_id)
-            && !desugar_expr_performs_error_conversion(cx, match_expr)
         {
             span_lint_and_sugg(
                 cx,
diff --git a/tests/ui/needless_return_with_question_mark.fixed b/tests/ui/needless_return_with_question_mark.fixed
index 2b0a835bc7f..9b7da852663 100644
--- a/tests/ui/needless_return_with_question_mark.fixed
+++ b/tests/ui/needless_return_with_question_mark.fixed
@@ -78,9 +78,6 @@ fn issue11616() -> Result<(), ()> {
     Ok(())
 }
 
-/// This is a false positive that occurs because of the way `?` is handled.
-/// The `?` operator is also doing a conversion from `Result<T, E>` to `Result<T, E'>`.
-/// In this case the conversion is needed, and thus the `?` operator is also needed.
 fn issue11982() {
     mod bar {
         pub struct Error;
@@ -115,10 +112,18 @@ fn issue11982_no_conversion() {
 
     fn foo(ok: bool) -> Result<(), bar::Error> {
         if !ok {
-            bar::foo(ok).map(|_| Ok::<(), bar::Error>(()))?;
-            //~^ ERROR: unneeded `return` statement with `?` operator
+            return bar::foo(ok).map(|_| Ok::<(), bar::Error>(()))?;
         };
         Ok(())
     }
+}
 
+fn general_return() {
+    fn foo(ok: bool) -> Result<(), ()> {
+        let bar = Result::Ok(Result::<(), ()>::Ok(()));
+        if !ok {
+            return bar?;
+        };
+        Ok(())
+    }
 }
diff --git a/tests/ui/needless_return_with_question_mark.rs b/tests/ui/needless_return_with_question_mark.rs
index ecbf00254f0..68e76d2b640 100644
--- a/tests/ui/needless_return_with_question_mark.rs
+++ b/tests/ui/needless_return_with_question_mark.rs
@@ -78,9 +78,6 @@ fn issue11616() -> Result<(), ()> {
     Ok(())
 }
 
-/// This is a false positive that occurs because of the way `?` is handled.
-/// The `?` operator is also doing a conversion from `Result<T, E>` to `Result<T, E'>`.
-/// In this case the conversion is needed, and thus the `?` operator is also needed.
 fn issue11982() {
     mod bar {
         pub struct Error;
@@ -116,7 +113,16 @@ fn issue11982_no_conversion() {
     fn foo(ok: bool) -> Result<(), bar::Error> {
         if !ok {
             return bar::foo(ok).map(|_| Ok::<(), bar::Error>(()))?;
-            //~^ ERROR: unneeded `return` statement with `?` operator
+        };
+        Ok(())
+    }
+}
+
+fn general_return() {
+    fn foo(ok: bool) -> Result<(), ()> {
+        let bar = Result::Ok(Result::<(), ()>::Ok(()));
+        if !ok {
+            return bar?;
         };
         Ok(())
     }
diff --git a/tests/ui/needless_return_with_question_mark.stderr b/tests/ui/needless_return_with_question_mark.stderr
index 59c212bcbb3..17aa212ae8d 100644
--- a/tests/ui/needless_return_with_question_mark.stderr
+++ b/tests/ui/needless_return_with_question_mark.stderr
@@ -13,11 +13,5 @@ error: unneeded `return` statement with `?` operator
 LL |         return Err(())?;
    |         ^^^^^^^ help: remove it
 
-error: unneeded `return` statement with `?` operator
-  --> $DIR/needless_return_with_question_mark.rs:118:13
-   |
-LL |             return bar::foo(ok).map(|_| Ok::<(), bar::Error>(()))?;
-   |             ^^^^^^^ help: remove it
-
-error: aborting due to 3 previous errors
+error: aborting due to 2 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From b3d53774e7ffcde40b18e18be700f63204ec96bd Mon Sep 17 00:00:00 2001
From: modelflat <zhykreg@gmail.com>
Date: Mon, 21 Aug 2023 14:39:42 +0200
Subject: Make `redundant_closure_for_method_calls` suggest relative paths
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Fixes #10854.

Co-authored-by: Alejandra González <blyxyas@gmail.com>
---
 clippy_lints/src/eta_reduction.rs |  36 ++--------
 clippy_utils/src/lib.rs           | 134 +++++++++++++++++++++++++++++++++++++-
 tests/ui/eta.fixed                |  54 +++++++++++++++
 tests/ui/eta.rs                   |  54 +++++++++++++++
 tests/ui/eta.stderr               |  26 +++++++-
 5 files changed, 271 insertions(+), 33 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/eta_reduction.rs b/clippy_lints/src/eta_reduction.rs
index 1ea5b789805..40be71a0e5d 100644
--- a/clippy_lints/src/eta_reduction.rs
+++ b/clippy_lints/src/eta_reduction.rs
@@ -3,15 +3,14 @@ use clippy_utils::higher::VecArgs;
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::type_diagnostic_name;
 use clippy_utils::usage::{local_used_after_expr, local_used_in};
-use clippy_utils::{higher, is_adjusted, path_to_local, path_to_local_id};
+use clippy_utils::{get_path_from_caller_to_method_type, higher, is_adjusted, path_to_local, path_to_local_id};
 use rustc_errors::Applicability;
-use rustc_hir::def_id::DefId;
 use rustc_hir::{BindingAnnotation, Expr, ExprKind, FnRetTy, Param, PatKind, QPath, TyKind, Unsafety};
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{
-    self, Binder, ClosureArgs, ClosureKind, EarlyBinder, FnSig, GenericArg, GenericArgKind, GenericArgsRef,
-    ImplPolarity, List, Region, RegionKind, Ty, TypeVisitableExt, TypeckResults,
+    self, Binder, ClosureArgs, ClosureKind, FnSig, GenericArg, GenericArgKind, ImplPolarity, List, Region, RegionKind,
+    Ty, TypeVisitableExt, TypeckResults,
 };
 use rustc_session::declare_lint_pass;
 use rustc_span::symbol::sym;
@@ -203,11 +202,12 @@ impl<'tcx> LateLintPass<'tcx> for EtaReduction {
                         "redundant closure",
                         |diag| {
                             let args = typeck.node_args(body.value.hir_id);
-                            let name = get_ufcs_type_name(cx, method_def_id, args);
+                            let caller = self_.hir_id.owner.def_id;
+                            let type_name = get_path_from_caller_to_method_type(cx.tcx, caller, method_def_id, args);
                             diag.span_suggestion(
                                 expr.span,
                                 "replace the closure with the method itself",
-                                format!("{}::{}", name, path.ident.name),
+                                format!("{}::{}", type_name, path.ident.name),
                                 Applicability::MachineApplicable,
                             );
                         },
@@ -309,27 +309,3 @@ fn has_late_bound_to_non_late_bound_regions(from_sig: FnSig<'_>, to_sig: FnSig<'
         .zip(to_sig.inputs_and_output)
         .any(|(from_ty, to_ty)| check_ty(from_ty, to_ty))
 }
-
-fn get_ufcs_type_name<'tcx>(cx: &LateContext<'tcx>, method_def_id: DefId, args: GenericArgsRef<'tcx>) -> String {
-    let assoc_item = cx.tcx.associated_item(method_def_id);
-    let def_id = assoc_item.container_id(cx.tcx);
-    match assoc_item.container {
-        ty::TraitContainer => cx.tcx.def_path_str(def_id),
-        ty::ImplContainer => {
-            let ty = cx.tcx.type_of(def_id).instantiate_identity();
-            match ty.kind() {
-                ty::Adt(adt, _) => cx.tcx.def_path_str(adt.did()),
-                ty::Array(..)
-                | ty::Dynamic(..)
-                | ty::Never
-                | ty::RawPtr(_)
-                | ty::Ref(..)
-                | ty::Slice(_)
-                | ty::Tuple(_) => {
-                    format!("<{}>", EarlyBinder::bind(ty).instantiate(cx.tcx, args))
-                },
-                _ => ty.to_string(),
-            }
-        },
-    }
-}
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 4e499ff4cc6..74284c959cb 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -75,6 +75,7 @@ use core::mem;
 use core::ops::ControlFlow;
 use std::collections::hash_map::Entry;
 use std::hash::BuildHasherDefault;
+use std::iter::{once, repeat};
 use std::sync::{Mutex, MutexGuard, OnceLock};
 
 use itertools::Itertools;
@@ -84,6 +85,7 @@ use rustc_data_structures::packed::Pu128;
 use rustc_data_structures::unhash::UnhashMap;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::def_id::{CrateNum, DefId, LocalDefId, LocalModDefId, LOCAL_CRATE};
+use rustc_hir::definitions::{DefPath, DefPathData};
 use rustc_hir::hir_id::{HirIdMap, HirIdSet};
 use rustc_hir::intravisit::{walk_expr, FnKind, Visitor};
 use rustc_hir::LangItem::{OptionNone, OptionSome, ResultErr, ResultOk};
@@ -102,8 +104,8 @@ use rustc_middle::ty::binding::BindingMode;
 use rustc_middle::ty::fast_reject::SimplifiedType;
 use rustc_middle::ty::layout::IntegerExt;
 use rustc_middle::ty::{
-    self as rustc_ty, Binder, BorrowKind, ClosureKind, FloatTy, IntTy, ParamEnv, ParamEnvAnd, Ty, TyCtxt, TypeAndMut,
-    TypeVisitableExt, UintTy, UpvarCapture,
+    self as rustc_ty, Binder, BorrowKind, ClosureKind, EarlyBinder, FloatTy, GenericArgsRef, IntTy, ParamEnv,
+    ParamEnvAnd, Ty, TyCtxt, TypeAndMut, TypeVisitableExt, UintTy, UpvarCapture,
 };
 use rustc_span::hygiene::{ExpnKind, MacroKind};
 use rustc_span::source_map::SourceMap;
@@ -3264,3 +3266,131 @@ pub fn is_never_expr<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> Option<
             })
     }
 }
+
+/// Produces a path from a local caller to the type of the called method. Suitable for user
+/// output/suggestions.
+///
+/// Returned path can be either absolute (for methods defined non-locally), or relative (for local
+/// methods).
+pub fn get_path_from_caller_to_method_type<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    from: LocalDefId,
+    method: DefId,
+    args: GenericArgsRef<'tcx>,
+) -> String {
+    let assoc_item = tcx.associated_item(method);
+    let def_id = assoc_item.container_id(tcx);
+    match assoc_item.container {
+        rustc_ty::TraitContainer => get_path_to_callee(tcx, from, def_id),
+        rustc_ty::ImplContainer => {
+            let ty = tcx.type_of(def_id).instantiate_identity();
+            get_path_to_ty(tcx, from, ty, args)
+        },
+    }
+}
+
+fn get_path_to_ty<'tcx>(tcx: TyCtxt<'tcx>, from: LocalDefId, ty: Ty<'tcx>, args: GenericArgsRef<'tcx>) -> String {
+    match ty.kind() {
+        rustc_ty::Adt(adt, _) => get_path_to_callee(tcx, from, adt.did()),
+        // TODO these types need to be recursively resolved as well
+        rustc_ty::Array(..)
+        | rustc_ty::Dynamic(..)
+        | rustc_ty::Never
+        | rustc_ty::RawPtr(_)
+        | rustc_ty::Ref(..)
+        | rustc_ty::Slice(_)
+        | rustc_ty::Tuple(_) => format!("<{}>", EarlyBinder::bind(ty).instantiate(tcx, args)),
+        _ => ty.to_string(),
+    }
+}
+
+/// Produce a path from some local caller to the callee. Suitable for user output/suggestions.
+fn get_path_to_callee(tcx: TyCtxt<'_>, from: LocalDefId, callee: DefId) -> String {
+    // only search for a relative path if the call is fully local
+    if callee.is_local() {
+        let callee_path = tcx.def_path(callee);
+        let caller_path = tcx.def_path(from.to_def_id());
+        maybe_get_relative_path(&caller_path, &callee_path, 2)
+    } else {
+        tcx.def_path_str(callee)
+    }
+}
+
+/// Tries to produce a relative path from `from` to `to`; if such a path would contain more than
+/// `max_super` `super` items, produces an absolute path instead. Both `from` and `to` should be in
+/// the local crate.
+///
+/// Suitable for user output/suggestions.
+///
+/// This ignores use items, and assumes that the target path is visible from the source
+/// path (which _should_ be a reasonable assumption since we in order to be able to use an object of
+/// certain type T, T is required to be visible).
+///
+/// TODO make use of `use` items. Maybe we should have something more sophisticated like
+/// rust-analyzer does? <https://docs.rs/ra_ap_hir_def/0.0.169/src/ra_ap_hir_def/find_path.rs.html#19-27>
+fn maybe_get_relative_path(from: &DefPath, to: &DefPath, max_super: usize) -> String {
+    use itertools::EitherOrBoth::{Both, Left, Right};
+
+    // 1. skip the segments common for both paths (regardless of their type)
+    let unique_parts = to
+        .data
+        .iter()
+        .zip_longest(from.data.iter())
+        .skip_while(|el| matches!(el, Both(l, r) if l == r))
+        .map(|el| match el {
+            Both(l, r) => Both(l.data, r.data),
+            Left(l) => Left(l.data),
+            Right(r) => Right(r.data),
+        });
+
+    // 2. for the remaning segments, construct relative path using only mod names and `super`
+    let mut go_up_by = 0;
+    let mut path = Vec::new();
+    for el in unique_parts {
+        match el {
+            Both(l, r) => {
+                // consider:
+                // a::b::sym:: ::    refers to
+                // c::d::e  ::f::sym
+                // result should be super::super::c::d::e::f
+                //
+                // alternatively:
+                // a::b::c  ::d::sym refers to
+                // e::f::sym:: ::
+                // result should be super::super::super::super::e::f
+                if let DefPathData::TypeNs(s) = l {
+                    path.push(s.to_string());
+                }
+                if let DefPathData::TypeNs(_) = r {
+                    go_up_by += 1;
+                }
+            },
+            // consider:
+            // a::b::sym:: ::    refers to
+            // c::d::e  ::f::sym
+            // when looking at `f`
+            Left(DefPathData::TypeNs(sym)) => path.push(sym.to_string()),
+            // consider:
+            // a::b::c  ::d::sym refers to
+            // e::f::sym:: ::
+            // when looking at `d`
+            Right(DefPathData::TypeNs(_)) => go_up_by += 1,
+            _ => {},
+        }
+    }
+
+    if go_up_by > max_super {
+        // `super` chain would be too long, just use the absolute path instead
+        once(String::from("crate"))
+            .chain(to.data.iter().filter_map(|el| {
+                if let DefPathData::TypeNs(sym) = el.data {
+                    Some(sym.to_string())
+                } else {
+                    None
+                }
+            }))
+            .join("::")
+    } else {
+        repeat(String::from("super")).take(go_up_by).chain(path).join("::")
+    }
+}
diff --git a/tests/ui/eta.fixed b/tests/ui/eta.fixed
index 3aeb4dae30b..da28ec2e653 100644
--- a/tests/ui/eta.fixed
+++ b/tests/ui/eta.fixed
@@ -417,3 +417,57 @@ fn _closure_with_types() {
     let _ = f2(|x: u32| f(x));
     let _ = f2(|x| -> u32 { f(x) });
 }
+
+/// https://github.com/rust-lang/rust-clippy/issues/10854
+/// This is to verify that redundant_closure_for_method_calls resolves suggested paths to relative.
+mod issue_10854 {
+    pub mod test_mod {
+        pub struct Test;
+
+        impl Test {
+            pub fn method(self) -> i32 {
+                0
+            }
+        }
+
+        pub fn calls_test(test: Option<Test>) -> Option<i32> {
+            test.map(Test::method)
+        }
+
+        pub fn calls_outer(test: Option<super::Outer>) -> Option<i32> {
+            test.map(super::Outer::method)
+        }
+    }
+
+    pub struct Outer;
+
+    impl Outer {
+        pub fn method(self) -> i32 {
+            0
+        }
+    }
+
+    pub fn calls_into_mod(test: Option<test_mod::Test>) -> Option<i32> {
+        test.map(test_mod::Test::method)
+    }
+
+    mod a {
+        pub mod b {
+            pub mod c {
+                pub fn extreme_nesting(test: Option<super::super::super::d::Test>) -> Option<i32> {
+                    test.map(crate::issue_10854::d::Test::method)
+                }
+            }
+        }
+    }
+
+    mod d {
+        pub struct Test;
+
+        impl Test {
+            pub fn method(self) -> i32 {
+                0
+            }
+        }
+    }
+}
diff --git a/tests/ui/eta.rs b/tests/ui/eta.rs
index b9b3303b371..f924100f8f4 100644
--- a/tests/ui/eta.rs
+++ b/tests/ui/eta.rs
@@ -417,3 +417,57 @@ fn _closure_with_types() {
     let _ = f2(|x: u32| f(x));
     let _ = f2(|x| -> u32 { f(x) });
 }
+
+/// https://github.com/rust-lang/rust-clippy/issues/10854
+/// This is to verify that redundant_closure_for_method_calls resolves suggested paths to relative.
+mod issue_10854 {
+    pub mod test_mod {
+        pub struct Test;
+
+        impl Test {
+            pub fn method(self) -> i32 {
+                0
+            }
+        }
+
+        pub fn calls_test(test: Option<Test>) -> Option<i32> {
+            test.map(|t| t.method())
+        }
+
+        pub fn calls_outer(test: Option<super::Outer>) -> Option<i32> {
+            test.map(|t| t.method())
+        }
+    }
+
+    pub struct Outer;
+
+    impl Outer {
+        pub fn method(self) -> i32 {
+            0
+        }
+    }
+
+    pub fn calls_into_mod(test: Option<test_mod::Test>) -> Option<i32> {
+        test.map(|t| t.method())
+    }
+
+    mod a {
+        pub mod b {
+            pub mod c {
+                pub fn extreme_nesting(test: Option<super::super::super::d::Test>) -> Option<i32> {
+                    test.map(|t| t.method())
+                }
+            }
+        }
+    }
+
+    mod d {
+        pub struct Test;
+
+        impl Test {
+            pub fn method(self) -> i32 {
+                0
+            }
+        }
+    }
+}
diff --git a/tests/ui/eta.stderr b/tests/ui/eta.stderr
index 7c4d2d7093e..945de466d83 100644
--- a/tests/ui/eta.stderr
+++ b/tests/ui/eta.stderr
@@ -166,5 +166,29 @@ error: redundant closure
 LL |     let _ = f(&0, |x, y| f2(x, y));
    |                   ^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `f2`
 
-error: aborting due to 27 previous errors
+error: redundant closure
+  --> $DIR/eta.rs:434:22
+   |
+LL |             test.map(|t| t.method())
+   |                      ^^^^^^^^^^^^^^ help: replace the closure with the method itself: `Test::method`
+
+error: redundant closure
+  --> $DIR/eta.rs:438:22
+   |
+LL |             test.map(|t| t.method())
+   |                      ^^^^^^^^^^^^^^ help: replace the closure with the method itself: `super::Outer::method`
+
+error: redundant closure
+  --> $DIR/eta.rs:451:18
+   |
+LL |         test.map(|t| t.method())
+   |                  ^^^^^^^^^^^^^^ help: replace the closure with the method itself: `test_mod::Test::method`
+
+error: redundant closure
+  --> $DIR/eta.rs:458:30
+   |
+LL |                     test.map(|t| t.method())
+   |                              ^^^^^^^^^^^^^^ help: replace the closure with the method itself: `crate::issue_10854::d::Test::method`
+
+error: aborting due to 31 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From ce8b4b6ac021e842916a101dfe5dbc74c4bc33b7 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Mon, 29 Jan 2024 14:54:28 +0100
Subject: Remove fixed FIXME

---
 clippy_lints/src/methods/unnecessary_fold.rs | 1 -
 1 file changed, 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/unnecessary_fold.rs b/clippy_lints/src/methods/unnecessary_fold.rs
index f3577ef6082..2046692bbd0 100644
--- a/clippy_lints/src/methods/unnecessary_fold.rs
+++ b/clippy_lints/src/methods/unnecessary_fold.rs
@@ -99,7 +99,6 @@ fn check_fold_with_op(
             cx,
             UNNECESSARY_FOLD,
             fold_span.with_hi(expr.span.hi()),
-            // TODO #2371 don't suggest e.g., .any(|x| f(x)) if we can suggest .any(f)
             "this `.fold` can be written more succinctly using another method",
             "try",
             sugg,
-- 
cgit 1.4.1-3-g733a5


From d02df12bd5e9ad2016328786d6a117afe0f1604a Mon Sep 17 00:00:00 2001
From: J-ZhengLi <lizheng135@huawei.com>
Date: Mon, 18 Dec 2023 17:57:22 +0800
Subject: add configuration for [`wildcard_imports`] to ignore certain imports

---
 clippy_config/src/conf.rs                              |  5 +++++
 clippy_lints/src/lib.rs                                |  8 +++++++-
 clippy_lints/src/wildcard_imports.rs                   | 18 ++++++++++++++++--
 tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr |  2 ++
 tests/ui-toml/wildcard_imports_whitelist/clippy.toml   |  1 +
 .../wildcard_imports_whitelist/wildcard_imports.fixed  | 18 ++++++++++++++++++
 .../wildcard_imports_whitelist/wildcard_imports.rs     | 18 ++++++++++++++++++
 .../wildcard_imports_whitelist/wildcard_imports.stderr | 11 +++++++++++
 8 files changed, 78 insertions(+), 3 deletions(-)
 create mode 100644 tests/ui-toml/wildcard_imports_whitelist/clippy.toml
 create mode 100644 tests/ui-toml/wildcard_imports_whitelist/wildcard_imports.fixed
 create mode 100644 tests/ui-toml/wildcard_imports_whitelist/wildcard_imports.rs
 create mode 100644 tests/ui-toml/wildcard_imports_whitelist/wildcard_imports.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_config/src/conf.rs b/clippy_config/src/conf.rs
index 8b45f250b10..e4e512482ac 100644
--- a/clippy_config/src/conf.rs
+++ b/clippy_config/src/conf.rs
@@ -571,6 +571,11 @@ define_Conf! {
     ///
     /// Don't lint when comparing the result of a modulo operation to zero.
     (allow_comparison_to_zero: bool = true),
+    /// Lint: WILDCARD_IMPORTS.
+    ///
+    /// List of path segments to ignore when checking wildcard imports,
+    /// could get overrided by `warn_on_all_wildcard_imports`.
+    (ignored_wildcard_imports: Vec<String> = Vec::new()),
 }
 
 /// Search for the configuration file.
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 7da916ade2a..678058a5411 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -545,6 +545,7 @@ pub fn register_lints(store: &mut rustc_lint::LintStore, conf: &'static Conf) {
         excessive_nesting_threshold,
         future_size_threshold,
         ref ignore_interior_mutability,
+        ref ignored_wildcard_imports,
         large_error_threshold,
         literal_representation_threshold,
         matches_for_let_else,
@@ -876,7 +877,12 @@ pub fn register_lints(store: &mut rustc_lint::LintStore, conf: &'static Conf) {
         ))
     });
     store.register_early_pass(|| Box::new(option_env_unwrap::OptionEnvUnwrap));
-    store.register_late_pass(move |_| Box::new(wildcard_imports::WildcardImports::new(warn_on_all_wildcard_imports)));
+    store.register_late_pass(move |_| {
+        Box::new(wildcard_imports::WildcardImports::new(
+            warn_on_all_wildcard_imports,
+            ignored_wildcard_imports.clone(),
+        ))
+    });
     store.register_late_pass(|_| Box::<redundant_pub_crate::RedundantPubCrate>::default());
     store.register_late_pass(|_| Box::new(unnamed_address::UnnamedAddress));
     store.register_late_pass(|_| Box::<dereference::Dereferencing<'_>>::default());
diff --git a/clippy_lints/src/wildcard_imports.rs b/clippy_lints/src/wildcard_imports.rs
index b82bd1d7e7c..4eb45e6f8da 100644
--- a/clippy_lints/src/wildcard_imports.rs
+++ b/clippy_lints/src/wildcard_imports.rs
@@ -1,6 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::is_test_module_or_function;
 use clippy_utils::source::{snippet, snippet_with_applicability};
+use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Applicability;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::{Item, ItemKind, PathSegment, UseKind};
@@ -100,13 +101,15 @@ declare_clippy_lint! {
 pub struct WildcardImports {
     warn_on_all: bool,
     test_modules_deep: u32,
+    ignored_segments: Vec<String>,
 }
 
 impl WildcardImports {
-    pub fn new(warn_on_all: bool) -> Self {
+    pub fn new(warn_on_all: bool, ignored_wildcard_imports: Vec<String>) -> Self {
         Self {
             warn_on_all,
             test_modules_deep: 0,
+            ignored_segments: ignored_wildcard_imports,
         }
     }
 }
@@ -190,6 +193,7 @@ impl WildcardImports {
         item.span.from_expansion()
             || is_prelude_import(segments)
             || (is_super_only_import(segments) && self.test_modules_deep > 0)
+            || is_ignored_via_config(segments, &self.ignored_segments)
     }
 }
 
@@ -198,10 +202,20 @@ impl WildcardImports {
 fn is_prelude_import(segments: &[PathSegment<'_>]) -> bool {
     segments
         .iter()
-        .any(|ps| ps.ident.name.as_str().contains(sym::prelude.as_str()))
+        .any(|ps| ps.ident.as_str().contains(sym::prelude.as_str()))
 }
 
 // Allow "super::*" imports in tests.
 fn is_super_only_import(segments: &[PathSegment<'_>]) -> bool {
     segments.len() == 1 && segments[0].ident.name == kw::Super
 }
+
+// Allow skipping imports containing user configured segments,
+// i.e. "...::utils::...::*" if user put `ignored-wildcard-imports = ["utils"]` in `Clippy.toml`
+fn is_ignored_via_config(segments: &[PathSegment<'_>], ignored_segments: &[String]) -> bool {
+    let segments_set: FxHashSet<&str> = segments.iter().map(|s| s.ident.as_str()).collect();
+    let ignored_set: FxHashSet<&str> = ignored_segments.iter().map(String::as_str).collect();
+    // segment matching need to be exact instead of using 'contains', in case user unintentionaly put
+    // a single character in the config thus skipping most of the warnings.
+    segments_set.intersection(&ignored_set).next().is_some()
+}
diff --git a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
index 24fdfd945bd..b1e000abec8 100644
--- a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
+++ b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
@@ -39,6 +39,7 @@ error: error reading Clippy's configuration file: unknown field `foobar`, expect
            excessive-nesting-threshold
            future-size-threshold
            ignore-interior-mutability
+           ignored-wildcard-imports
            large-error-threshold
            literal-representation-threshold
            matches-for-let-else
@@ -117,6 +118,7 @@ error: error reading Clippy's configuration file: unknown field `barfoo`, expect
            excessive-nesting-threshold
            future-size-threshold
            ignore-interior-mutability
+           ignored-wildcard-imports
            large-error-threshold
            literal-representation-threshold
            matches-for-let-else
diff --git a/tests/ui-toml/wildcard_imports_whitelist/clippy.toml b/tests/ui-toml/wildcard_imports_whitelist/clippy.toml
new file mode 100644
index 00000000000..1d28cac588b
--- /dev/null
+++ b/tests/ui-toml/wildcard_imports_whitelist/clippy.toml
@@ -0,0 +1 @@
+ignored-wildcard-imports = ["utils"]
diff --git a/tests/ui-toml/wildcard_imports_whitelist/wildcard_imports.fixed b/tests/ui-toml/wildcard_imports_whitelist/wildcard_imports.fixed
new file mode 100644
index 00000000000..5ef30b054b3
--- /dev/null
+++ b/tests/ui-toml/wildcard_imports_whitelist/wildcard_imports.fixed
@@ -0,0 +1,18 @@
+#![warn(clippy::wildcard_imports)]
+
+mod utils {
+    pub fn print() {}
+}
+
+mod utils_plus {
+    pub fn do_something() {}
+}
+
+use utils::*;
+use utils_plus::do_something;
+//~^ ERROR: usage of wildcard import
+
+fn main() {
+    print();
+    do_something();
+}
diff --git a/tests/ui-toml/wildcard_imports_whitelist/wildcard_imports.rs b/tests/ui-toml/wildcard_imports_whitelist/wildcard_imports.rs
new file mode 100644
index 00000000000..5ea91a8d70a
--- /dev/null
+++ b/tests/ui-toml/wildcard_imports_whitelist/wildcard_imports.rs
@@ -0,0 +1,18 @@
+#![warn(clippy::wildcard_imports)]
+
+mod utils {
+    pub fn print() {}
+}
+
+mod utils_plus {
+    pub fn do_something() {}
+}
+
+use utils::*;
+use utils_plus::*;
+//~^ ERROR: usage of wildcard import
+
+fn main() {
+    print();
+    do_something();
+}
diff --git a/tests/ui-toml/wildcard_imports_whitelist/wildcard_imports.stderr b/tests/ui-toml/wildcard_imports_whitelist/wildcard_imports.stderr
new file mode 100644
index 00000000000..15f522cb5af
--- /dev/null
+++ b/tests/ui-toml/wildcard_imports_whitelist/wildcard_imports.stderr
@@ -0,0 +1,11 @@
+error: usage of wildcard import
+  --> $DIR/wildcard_imports.rs:12:5
+   |
+LL | use utils_plus::*;
+   |     ^^^^^^^^^^^^^ help: try: `utils_plus::do_something`
+   |
+   = note: `-D clippy::wildcard-imports` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::wildcard_imports)]`
+
+error: aborting due to 1 previous error
+
-- 
cgit 1.4.1-3-g733a5


From 314bddee95f88a405ec4b44db5576e3745ee1699 Mon Sep 17 00:00:00 2001
From: J-ZhengLi <lizheng135@huawei.com>
Date: Mon, 29 Jan 2024 11:29:15 +0800
Subject: add more test cases & improve docs & replace `Vec` with `FxHashSet`
 for segments

---
 clippy_config/src/conf.rs                            | 17 ++++++++++++++---
 clippy_lints/src/wildcard_imports.rs                 | 10 ++++------
 tests/ui-toml/wildcard_imports/clippy.toml           |  3 +++
 .../ui-toml/wildcard_imports/wildcard_imports.fixed  | 19 +++++++++++++++++++
 tests/ui-toml/wildcard_imports/wildcard_imports.rs   | 19 +++++++++++++++++++
 .../ui-toml/wildcard_imports/wildcard_imports.stderr | 20 ++++++++++++++++----
 .../wildcard_imports.fixed                           |  8 ++++++++
 .../wildcard_imports_whitelist/wildcard_imports.rs   |  8 ++++++++
 .../wildcard_imports.stderr                          |  2 +-
 9 files changed, 92 insertions(+), 14 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_config/src/conf.rs b/clippy_config/src/conf.rs
index e4e512482ac..d03f805e2fc 100644
--- a/clippy_config/src/conf.rs
+++ b/clippy_config/src/conf.rs
@@ -573,9 +573,20 @@ define_Conf! {
     (allow_comparison_to_zero: bool = true),
     /// Lint: WILDCARD_IMPORTS.
     ///
-    /// List of path segments to ignore when checking wildcard imports,
-    /// could get overrided by `warn_on_all_wildcard_imports`.
-    (ignored_wildcard_imports: Vec<String> = Vec::new()),
+    /// List of path segments to ignore when checking wildcard imports.
+    ///
+    /// #### Example
+    ///
+    /// ```toml
+    /// ignored-wildcard-imports = [ "utils", "common" ]
+    /// ```
+    ///
+    /// #### Noteworthy
+    ///
+    /// 1. This configuration has no effects if used with `warn_on_all_wildcard_imports = true`.
+    /// 2. Paths with any segment that containing the word 'prelude'
+    /// are already ignored by default.
+    (ignored_wildcard_imports: FxHashSet<String> = FxHashSet::default()),
 }
 
 /// Search for the configuration file.
diff --git a/clippy_lints/src/wildcard_imports.rs b/clippy_lints/src/wildcard_imports.rs
index 4eb45e6f8da..7318ffc9587 100644
--- a/clippy_lints/src/wildcard_imports.rs
+++ b/clippy_lints/src/wildcard_imports.rs
@@ -101,11 +101,11 @@ declare_clippy_lint! {
 pub struct WildcardImports {
     warn_on_all: bool,
     test_modules_deep: u32,
-    ignored_segments: Vec<String>,
+    ignored_segments: FxHashSet<String>,
 }
 
 impl WildcardImports {
-    pub fn new(warn_on_all: bool, ignored_wildcard_imports: Vec<String>) -> Self {
+    pub fn new(warn_on_all: bool, ignored_wildcard_imports: FxHashSet<String>) -> Self {
         Self {
             warn_on_all,
             test_modules_deep: 0,
@@ -212,10 +212,8 @@ fn is_super_only_import(segments: &[PathSegment<'_>]) -> bool {
 
 // Allow skipping imports containing user configured segments,
 // i.e. "...::utils::...::*" if user put `ignored-wildcard-imports = ["utils"]` in `Clippy.toml`
-fn is_ignored_via_config(segments: &[PathSegment<'_>], ignored_segments: &[String]) -> bool {
-    let segments_set: FxHashSet<&str> = segments.iter().map(|s| s.ident.as_str()).collect();
-    let ignored_set: FxHashSet<&str> = ignored_segments.iter().map(String::as_str).collect();
+fn is_ignored_via_config(segments: &[PathSegment<'_>], ignored_segments: &FxHashSet<String>) -> bool {
     // segment matching need to be exact instead of using 'contains', in case user unintentionaly put
     // a single character in the config thus skipping most of the warnings.
-    segments_set.intersection(&ignored_set).next().is_some()
+    segments.iter().any(|seg| ignored_segments.contains(seg.ident.as_str()))
 }
diff --git a/tests/ui-toml/wildcard_imports/clippy.toml b/tests/ui-toml/wildcard_imports/clippy.toml
index 875aaeef6c9..56a945e48bb 100644
--- a/tests/ui-toml/wildcard_imports/clippy.toml
+++ b/tests/ui-toml/wildcard_imports/clippy.toml
@@ -1 +1,4 @@
 warn-on-all-wildcard-imports = true
+
+# This should be ignored since `warn-on-all-wildcard-imports` has higher precedence
+ignored-wildcard-imports = ["utils"]
diff --git a/tests/ui-toml/wildcard_imports/wildcard_imports.fixed b/tests/ui-toml/wildcard_imports/wildcard_imports.fixed
index 1752f48856c..af72d6be0e0 100644
--- a/tests/ui-toml/wildcard_imports/wildcard_imports.fixed
+++ b/tests/ui-toml/wildcard_imports/wildcard_imports.fixed
@@ -3,9 +3,28 @@
 mod prelude {
     pub const FOO: u8 = 1;
 }
+
+mod utils {
+    pub const BAR: u8 = 1;
+    pub fn print() {}
+}
+
+mod my_crate {
+    pub mod utils {
+        pub fn my_util_fn() {}
+    }
+}
+
+use utils::{BAR, print};
+//~^ ERROR: usage of wildcard import
+use my_crate::utils::my_util_fn;
+//~^ ERROR: usage of wildcard import
 use prelude::FOO;
 //~^ ERROR: usage of wildcard import
 
 fn main() {
     let _ = FOO;
+    let _ = BAR;
+    print();
+    my_util_fn();
 }
diff --git a/tests/ui-toml/wildcard_imports/wildcard_imports.rs b/tests/ui-toml/wildcard_imports/wildcard_imports.rs
index 331c2c59c22..91009dd8835 100644
--- a/tests/ui-toml/wildcard_imports/wildcard_imports.rs
+++ b/tests/ui-toml/wildcard_imports/wildcard_imports.rs
@@ -3,9 +3,28 @@
 mod prelude {
     pub const FOO: u8 = 1;
 }
+
+mod utils {
+    pub const BAR: u8 = 1;
+    pub fn print() {}
+}
+
+mod my_crate {
+    pub mod utils {
+        pub fn my_util_fn() {}
+    }
+}
+
+use utils::*;
+//~^ ERROR: usage of wildcard import
+use my_crate::utils::*;
+//~^ ERROR: usage of wildcard import
 use prelude::*;
 //~^ ERROR: usage of wildcard import
 
 fn main() {
     let _ = FOO;
+    let _ = BAR;
+    print();
+    my_util_fn();
 }
diff --git a/tests/ui-toml/wildcard_imports/wildcard_imports.stderr b/tests/ui-toml/wildcard_imports/wildcard_imports.stderr
index f11fda6a0c6..a733d786d0e 100644
--- a/tests/ui-toml/wildcard_imports/wildcard_imports.stderr
+++ b/tests/ui-toml/wildcard_imports/wildcard_imports.stderr
@@ -1,11 +1,23 @@
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:6:5
+  --> $DIR/wildcard_imports.rs:18:5
    |
-LL | use prelude::*;
-   |     ^^^^^^^^^^ help: try: `prelude::FOO`
+LL | use utils::*;
+   |     ^^^^^^^^ help: try: `utils::{BAR, print}`
    |
    = note: `-D clippy::wildcard-imports` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::wildcard_imports)]`
 
-error: aborting due to 1 previous error
+error: usage of wildcard import
+  --> $DIR/wildcard_imports.rs:20:5
+   |
+LL | use my_crate::utils::*;
+   |     ^^^^^^^^^^^^^^^^^^ help: try: `my_crate::utils::my_util_fn`
+
+error: usage of wildcard import
+  --> $DIR/wildcard_imports.rs:22:5
+   |
+LL | use prelude::*;
+   |     ^^^^^^^^^^ help: try: `prelude::FOO`
+
+error: aborting due to 3 previous errors
 
diff --git a/tests/ui-toml/wildcard_imports_whitelist/wildcard_imports.fixed b/tests/ui-toml/wildcard_imports_whitelist/wildcard_imports.fixed
index 5ef30b054b3..d539525c45e 100644
--- a/tests/ui-toml/wildcard_imports_whitelist/wildcard_imports.fixed
+++ b/tests/ui-toml/wildcard_imports_whitelist/wildcard_imports.fixed
@@ -8,11 +8,19 @@ mod utils_plus {
     pub fn do_something() {}
 }
 
+mod my_crate {
+    pub mod utils {
+        pub fn my_util_fn() {}
+    }
+}
+
+use my_crate::utils::*;
 use utils::*;
 use utils_plus::do_something;
 //~^ ERROR: usage of wildcard import
 
 fn main() {
     print();
+    my_util_fn();
     do_something();
 }
diff --git a/tests/ui-toml/wildcard_imports_whitelist/wildcard_imports.rs b/tests/ui-toml/wildcard_imports_whitelist/wildcard_imports.rs
index 5ea91a8d70a..9169d16a08b 100644
--- a/tests/ui-toml/wildcard_imports_whitelist/wildcard_imports.rs
+++ b/tests/ui-toml/wildcard_imports_whitelist/wildcard_imports.rs
@@ -8,11 +8,19 @@ mod utils_plus {
     pub fn do_something() {}
 }
 
+mod my_crate {
+    pub mod utils {
+        pub fn my_util_fn() {}
+    }
+}
+
+use my_crate::utils::*;
 use utils::*;
 use utils_plus::*;
 //~^ ERROR: usage of wildcard import
 
 fn main() {
     print();
+    my_util_fn();
     do_something();
 }
diff --git a/tests/ui-toml/wildcard_imports_whitelist/wildcard_imports.stderr b/tests/ui-toml/wildcard_imports_whitelist/wildcard_imports.stderr
index 15f522cb5af..12c2f9cbada 100644
--- a/tests/ui-toml/wildcard_imports_whitelist/wildcard_imports.stderr
+++ b/tests/ui-toml/wildcard_imports_whitelist/wildcard_imports.stderr
@@ -1,5 +1,5 @@
 error: usage of wildcard import
-  --> $DIR/wildcard_imports.rs:12:5
+  --> $DIR/wildcard_imports.rs:19:5
    |
 LL | use utils_plus::*;
    |     ^^^^^^^^^^^^^ help: try: `utils_plus::do_something`
-- 
cgit 1.4.1-3-g733a5


From 3106219e24c9d52a739ffaf38c10f0c1357f30f3 Mon Sep 17 00:00:00 2001
From: Bruno Andreotti <bandreotti@proton.me>
Date: Tue, 30 Jan 2024 16:17:02 -0300
Subject: Don't lint slice type annotations for byte strings

---
 clippy_lints/src/redundant_type_annotations.rs | 11 ++++++++++-
 tests/ui/redundant_type_annotations.rs         |  7 ++++++-
 tests/ui/redundant_type_annotations.stderr     |  4 ++--
 3 files changed, 18 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/redundant_type_annotations.rs b/clippy_lints/src/redundant_type_annotations.rs
index 07fcb69afbc..c8352c05265 100644
--- a/clippy_lints/src/redundant_type_annotations.rs
+++ b/clippy_lints/src/redundant_type_annotations.rs
@@ -188,7 +188,6 @@ impl LateLintPass<'_> for RedundantTypeAnnotations {
                     match init_lit.node {
                         // In these cases the annotation is redundant
                         LitKind::Str(..)
-                        | LitKind::ByteStr(..)
                         | LitKind::Byte(..)
                         | LitKind::Char(..)
                         | LitKind::Bool(..)
@@ -202,6 +201,16 @@ impl LateLintPass<'_> for RedundantTypeAnnotations {
                             }
                         },
                         LitKind::Err => (),
+                        LitKind::ByteStr(..) => {
+                            // We only lint if the type annotation is an array type (e.g. &[u8; 4]).
+                            // If instead it is a slice (e.g. &[u8]) it may not be redundant, so we
+                            // don't lint.
+                            if let hir::TyKind::Ref(_, mut_ty) = ty.kind
+                                && matches!(mut_ty.ty.kind, hir::TyKind::Array(..))
+                            {
+                                span_lint(cx, REDUNDANT_TYPE_ANNOTATIONS, local.span, "redundant type annotation");
+                            }
+                        },
                     }
                 },
                 _ => (),
diff --git a/tests/ui/redundant_type_annotations.rs b/tests/ui/redundant_type_annotations.rs
index acf53fea2bb..dc9b073ffba 100644
--- a/tests/ui/redundant_type_annotations.rs
+++ b/tests/ui/redundant_type_annotations.rs
@@ -196,13 +196,18 @@ fn test_simple_types() {
     let _var: &str = "test";
     //~^ ERROR: redundant type annotation
 
-    let _var: &[u8] = b"test";
+    let _var: &[u8; 4] = b"test";
     //~^ ERROR: redundant type annotation
 
     let _var: bool = false;
     //~^ ERROR: redundant type annotation
 }
 
+fn issue12212() {
+    // This should not be linted
+    let _var: &[u8] = b"test";
+}
+
 fn issue11190() {}
 
 fn main() {}
diff --git a/tests/ui/redundant_type_annotations.stderr b/tests/ui/redundant_type_annotations.stderr
index d1f26f1832e..48df465ad49 100644
--- a/tests/ui/redundant_type_annotations.stderr
+++ b/tests/ui/redundant_type_annotations.stderr
@@ -94,8 +94,8 @@ LL |     let _var: &str = "test";
 error: redundant type annotation
   --> $DIR/redundant_type_annotations.rs:199:5
    |
-LL |     let _var: &[u8] = b"test";
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |     let _var: &[u8; 4] = b"test";
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: redundant type annotation
   --> $DIR/redundant_type_annotations.rs:202:5
-- 
cgit 1.4.1-3-g733a5


From 6619e8c27da89c8fc7972eecc410b39ddc250bd7 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Wed, 31 Jan 2024 18:33:41 +0000
Subject: Add `lint_groups_priority` lint

Warns when a lint group in Cargo.toml's `[lints]` section shares the
same priority as a lint
---
 CHANGELOG.md                                       |   1 +
 clippy_lints/src/cargo/lint_groups_priority.rs     | 168 +++++++++++++++++++++
 clippy_lints/src/cargo/mod.rs                      |  43 +++++-
 clippy_lints/src/declared_lints.rs                 |   1 +
 .../lint_groups_priority/fail/Cargo.stderr         |  45 ++++++
 .../ui-cargo/lint_groups_priority/fail/Cargo.toml  |  20 +++
 .../ui-cargo/lint_groups_priority/fail/src/lib.rs  |   1 +
 .../ui-cargo/lint_groups_priority/pass/Cargo.toml  |  10 ++
 .../ui-cargo/lint_groups_priority/pass/src/lib.rs  |   1 +
 9 files changed, 289 insertions(+), 1 deletion(-)
 create mode 100644 clippy_lints/src/cargo/lint_groups_priority.rs
 create mode 100644 tests/ui-cargo/lint_groups_priority/fail/Cargo.stderr
 create mode 100644 tests/ui-cargo/lint_groups_priority/fail/Cargo.toml
 create mode 100644 tests/ui-cargo/lint_groups_priority/fail/src/lib.rs
 create mode 100644 tests/ui-cargo/lint_groups_priority/pass/Cargo.toml
 create mode 100644 tests/ui-cargo/lint_groups_priority/pass/src/lib.rs

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 471163499e5..e19a1ae0262 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5277,6 +5277,7 @@ Released 2018-09-13
 [`let_with_type_underscore`]: https://rust-lang.github.io/rust-clippy/master/index.html#let_with_type_underscore
 [`lines_filter_map_ok`]: https://rust-lang.github.io/rust-clippy/master/index.html#lines_filter_map_ok
 [`linkedlist`]: https://rust-lang.github.io/rust-clippy/master/index.html#linkedlist
+[`lint_groups_priority`]: https://rust-lang.github.io/rust-clippy/master/index.html#lint_groups_priority
 [`little_endian_bytes`]: https://rust-lang.github.io/rust-clippy/master/index.html#little_endian_bytes
 [`logic_bug`]: https://rust-lang.github.io/rust-clippy/master/index.html#logic_bug
 [`lossy_float_literal`]: https://rust-lang.github.io/rust-clippy/master/index.html#lossy_float_literal
diff --git a/clippy_lints/src/cargo/lint_groups_priority.rs b/clippy_lints/src/cargo/lint_groups_priority.rs
new file mode 100644
index 00000000000..a39b972b56a
--- /dev/null
+++ b/clippy_lints/src/cargo/lint_groups_priority.rs
@@ -0,0 +1,168 @@
+use super::LINT_GROUPS_PRIORITY;
+use clippy_utils::diagnostics::span_lint_and_then;
+use rustc_data_structures::fx::FxHashSet;
+use rustc_errors::Applicability;
+use rustc_lint::{unerased_lint_store, LateContext};
+use rustc_span::{BytePos, Pos, SourceFile, Span, SyntaxContext};
+use serde::{Deserialize, Serialize};
+use std::collections::BTreeMap;
+use std::ops::Range;
+use std::path::Path;
+use toml::Spanned;
+
+#[derive(Deserialize, Serialize, Debug)]
+struct LintConfigTable {
+    level: String,
+    priority: Option<i64>,
+}
+
+#[derive(Deserialize, Debug)]
+#[serde(untagged)]
+enum LintConfig {
+    Level(String),
+    Table(LintConfigTable),
+}
+
+impl LintConfig {
+    fn level(&self) -> &str {
+        match self {
+            LintConfig::Level(level) => level,
+            LintConfig::Table(table) => &table.level,
+        }
+    }
+
+    fn priority(&self) -> i64 {
+        match self {
+            LintConfig::Level(_) => 0,
+            LintConfig::Table(table) => table.priority.unwrap_or(0),
+        }
+    }
+
+    fn is_implicit(&self) -> bool {
+        if let LintConfig::Table(table) = self {
+            table.priority.is_none()
+        } else {
+            true
+        }
+    }
+}
+
+type LintTable = BTreeMap<Spanned<String>, Spanned<LintConfig>>;
+
+#[derive(Deserialize, Debug)]
+struct Lints {
+    #[serde(default)]
+    rust: LintTable,
+    #[serde(default)]
+    clippy: LintTable,
+}
+
+#[derive(Deserialize, Debug)]
+struct CargoToml {
+    lints: Lints,
+}
+
+#[derive(Default, Debug)]
+struct LintsAndGroups {
+    lints: Vec<Spanned<String>>,
+    groups: Vec<(Spanned<String>, Spanned<LintConfig>)>,
+}
+
+fn toml_span(range: Range<usize>, file: &SourceFile) -> Span {
+    Span::new(
+        file.start_pos + BytePos::from_usize(range.start),
+        file.start_pos + BytePos::from_usize(range.end),
+        SyntaxContext::root(),
+        None,
+    )
+}
+
+fn check_table(cx: &LateContext<'_>, table: LintTable, groups: &FxHashSet<&str>, file: &SourceFile) {
+    let mut by_priority = BTreeMap::<_, LintsAndGroups>::new();
+    for (name, config) in table {
+        let lints_and_groups = by_priority.entry(config.as_ref().priority()).or_default();
+        if groups.contains(name.get_ref().as_str()) {
+            lints_and_groups.groups.push((name, config));
+        } else {
+            lints_and_groups.lints.push(name);
+        }
+    }
+    let low_priority = by_priority
+        .iter()
+        .find(|(_, lints_and_groups)| !lints_and_groups.lints.is_empty())
+        .map_or(-1, |(&lowest_lint_priority, _)| lowest_lint_priority - 1);
+
+    for (priority, LintsAndGroups { lints, groups }) in by_priority {
+        let Some(last_lint_alphabetically) = lints.last() else {
+            continue;
+        };
+
+        for (group, config) in groups {
+            span_lint_and_then(
+                cx,
+                LINT_GROUPS_PRIORITY,
+                toml_span(group.span(), file),
+                &format!(
+                    "lint group `{}` has the same priority ({priority}) as a lint",
+                    group.as_ref()
+                ),
+                |diag| {
+                    let config_span = toml_span(config.span(), file);
+                    if config.as_ref().is_implicit() {
+                        diag.span_label(config_span, "has an implicit priority of 0");
+                    }
+                    // add the label to next lint after this group that has the same priority
+                    let lint = lints
+                        .iter()
+                        .filter(|lint| lint.span().start > group.span().start)
+                        .min_by_key(|lint| lint.span().start)
+                        .unwrap_or(last_lint_alphabetically);
+                    diag.span_label(toml_span(lint.span(), file), "has the same priority as this lint");
+                    diag.note("the order of the lints in the table is ignored by Cargo");
+                    let mut suggestion = String::new();
+                    Serialize::serialize(
+                        &LintConfigTable {
+                            level: config.as_ref().level().into(),
+                            priority: Some(low_priority),
+                        },
+                        toml::ser::ValueSerializer::new(&mut suggestion),
+                    )
+                    .unwrap();
+                    diag.span_suggestion_verbose(
+                        config_span,
+                        format!(
+                            "to have lints override the group set `{}` to a lower priority",
+                            group.as_ref()
+                        ),
+                        suggestion,
+                        Applicability::MaybeIncorrect,
+                    );
+                },
+            );
+        }
+    }
+}
+
+pub fn check(cx: &LateContext<'_>) {
+    if let Ok(file) = cx.tcx.sess.source_map().load_file(Path::new("Cargo.toml"))
+        && let Some(src) = file.src.as_deref()
+        && let Ok(cargo_toml) = toml::from_str::<CargoToml>(src)
+    {
+        let mut rustc_groups = FxHashSet::default();
+        let mut clippy_groups = FxHashSet::default();
+        for (group, ..) in unerased_lint_store(cx.tcx.sess).get_lint_groups() {
+            match group.split_once("::") {
+                None => {
+                    rustc_groups.insert(group);
+                },
+                Some(("clippy", group)) => {
+                    clippy_groups.insert(group);
+                },
+                _ => {},
+            }
+        }
+
+        check_table(cx, cargo_toml.lints.rust, &rustc_groups, &file);
+        check_table(cx, cargo_toml.lints.clippy, &clippy_groups, &file);
+    }
+}
diff --git a/clippy_lints/src/cargo/mod.rs b/clippy_lints/src/cargo/mod.rs
index d8107f61f37..95d5449781b 100644
--- a/clippy_lints/src/cargo/mod.rs
+++ b/clippy_lints/src/cargo/mod.rs
@@ -1,5 +1,6 @@
 mod common_metadata;
 mod feature_name;
+mod lint_groups_priority;
 mod multiple_crate_versions;
 mod wildcard_dependencies;
 
@@ -165,6 +166,43 @@ declare_clippy_lint! {
     "wildcard dependencies being used"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for lint groups with the same priority as lints in the `Cargo.toml`
+    /// [`[lints]` table](https://doc.rust-lang.org/cargo/reference/manifest.html#the-lints-section).
+    ///
+    /// This lint will be removed once [cargo#12918](https://github.com/rust-lang/cargo/issues/12918)
+    /// is resolved.
+    ///
+    /// ### Why is this bad?
+    /// The order of lints in the `[lints]` is ignored, to have a lint override a group the
+    /// `priority` field needs to be used, otherwise the sort order is undefined.
+    ///
+    /// ### Known problems
+    /// Does not check lints inherited using `lints.workspace = true`
+    ///
+    /// ### Example
+    /// ```toml
+    /// # Passed as `--allow=clippy::similar_names --warn=clippy::pedantic`
+    /// # which results in `similar_names` being `warn`
+    /// [lints.clippy]
+    /// pedantic = "warn"
+    /// similar_names = "allow"
+    /// ```
+    /// Use instead:
+    /// ```toml
+    /// # Passed as `--warn=clippy::pedantic --allow=clippy::similar_names`
+    /// # which results in `similar_names` being `allow`
+    /// [lints.clippy]
+    /// pedantic = { level = "warn", priority = -1 }
+    /// similar_names = "allow"
+    /// ```
+    #[clippy::version = "1.76.0"]
+    pub LINT_GROUPS_PRIORITY,
+    correctness,
+    "a lint group in `Cargo.toml` at the same priority as a lint"
+}
+
 pub struct Cargo {
     pub allowed_duplicate_crates: FxHashSet<String>,
     pub ignore_publish: bool,
@@ -175,7 +213,8 @@ impl_lint_pass!(Cargo => [
     REDUNDANT_FEATURE_NAMES,
     NEGATIVE_FEATURE_NAMES,
     MULTIPLE_CRATE_VERSIONS,
-    WILDCARD_DEPENDENCIES
+    WILDCARD_DEPENDENCIES,
+    LINT_GROUPS_PRIORITY,
 ]);
 
 impl LateLintPass<'_> for Cargo {
@@ -188,6 +227,8 @@ impl LateLintPass<'_> for Cargo {
         ];
         static WITH_DEPS_LINTS: &[&Lint] = &[MULTIPLE_CRATE_VERSIONS];
 
+        lint_groups_priority::check(cx);
+
         if !NO_DEPS_LINTS
             .iter()
             .all(|&lint| is_lint_allowed(cx, lint, CRATE_HIR_ID))
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 23d0983151a..b96a7af9070 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -71,6 +71,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::borrow_deref_ref::BORROW_DEREF_REF_INFO,
     crate::box_default::BOX_DEFAULT_INFO,
     crate::cargo::CARGO_COMMON_METADATA_INFO,
+    crate::cargo::LINT_GROUPS_PRIORITY_INFO,
     crate::cargo::MULTIPLE_CRATE_VERSIONS_INFO,
     crate::cargo::NEGATIVE_FEATURE_NAMES_INFO,
     crate::cargo::REDUNDANT_FEATURE_NAMES_INFO,
diff --git a/tests/ui-cargo/lint_groups_priority/fail/Cargo.stderr b/tests/ui-cargo/lint_groups_priority/fail/Cargo.stderr
new file mode 100644
index 00000000000..103e60d8484
--- /dev/null
+++ b/tests/ui-cargo/lint_groups_priority/fail/Cargo.stderr
@@ -0,0 +1,45 @@
+error: lint group `rust_2018_idioms` has the same priority (0) as a lint
+ --> Cargo.toml:7:1
+  |
+7 | rust_2018_idioms = "warn"
+  | ^^^^^^^^^^^^^^^^   ------ has an implicit priority of 0
+8 | bare_trait_objects = "allow"
+  | ------------------ has the same priority as this lint
+  |
+  = note: the order of the lints in the table is ignored by Cargo
+  = note: `#[deny(clippy::lint_groups_priority)]` on by default
+help: to have lints override the group set `rust_2018_idioms` to a lower priority
+  |
+7 | rust_2018_idioms = { level = "warn", priority = -1 }
+  |                    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+error: lint group `unused` has the same priority (0) as a lint
+  --> Cargo.toml:10:1
+   |
+10 | unused = { level = "deny" }
+   | ^^^^^^   ------------------ has an implicit priority of 0
+11 | unused_braces = { level = "allow", priority = 1 }
+12 | unused_attributes = { level = "allow" }
+   | ----------------- has the same priority as this lint
+   |
+   = note: the order of the lints in the table is ignored by Cargo
+help: to have lints override the group set `unused` to a lower priority
+   |
+10 | unused = { level = "deny", priority = -1 }
+   |          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+error: lint group `pedantic` has the same priority (-1) as a lint
+  --> Cargo.toml:19:1
+   |
+19 | pedantic = { level = "warn", priority = -1 }
+   | ^^^^^^^^
+20 | similar_names = { level = "allow", priority = -1 }
+   | ------------- has the same priority as this lint
+   |
+   = note: the order of the lints in the table is ignored by Cargo
+help: to have lints override the group set `pedantic` to a lower priority
+   |
+19 | pedantic = { level = "warn", priority = -2 }
+   |            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+error: could not compile `fail` (lib) due to 3 previous errors
diff --git a/tests/ui-cargo/lint_groups_priority/fail/Cargo.toml b/tests/ui-cargo/lint_groups_priority/fail/Cargo.toml
new file mode 100644
index 00000000000..4ce41f78171
--- /dev/null
+++ b/tests/ui-cargo/lint_groups_priority/fail/Cargo.toml
@@ -0,0 +1,20 @@
+[package]
+name = "fail"
+version = "0.1.0"
+publish = false
+
+[lints.rust]
+rust_2018_idioms = "warn"
+bare_trait_objects = "allow"
+
+unused = { level = "deny" }
+unused_braces = { level = "allow", priority = 1 }
+unused_attributes = { level = "allow" }
+
+# `warnings` is not a group so the order it is passed does not matter
+warnings = "deny"
+deprecated  = "allow"
+
+[lints.clippy]
+pedantic = { level = "warn", priority = -1 }
+similar_names = { level = "allow", priority = -1 }
diff --git a/tests/ui-cargo/lint_groups_priority/fail/src/lib.rs b/tests/ui-cargo/lint_groups_priority/fail/src/lib.rs
new file mode 100644
index 00000000000..8b137891791
--- /dev/null
+++ b/tests/ui-cargo/lint_groups_priority/fail/src/lib.rs
@@ -0,0 +1 @@
+
diff --git a/tests/ui-cargo/lint_groups_priority/pass/Cargo.toml b/tests/ui-cargo/lint_groups_priority/pass/Cargo.toml
new file mode 100644
index 00000000000..e9fcf803d93
--- /dev/null
+++ b/tests/ui-cargo/lint_groups_priority/pass/Cargo.toml
@@ -0,0 +1,10 @@
+[package]
+name = "pass"
+version = "0.1.0"
+publish = false
+
+[lints.clippy]
+pedantic = { level = "warn", priority = -1 }
+style = { level = "warn", priority = 1 }
+similar_names = "allow"
+dbg_macro = { level = "warn", priority = 2 }
diff --git a/tests/ui-cargo/lint_groups_priority/pass/src/lib.rs b/tests/ui-cargo/lint_groups_priority/pass/src/lib.rs
new file mode 100644
index 00000000000..8b137891791
--- /dev/null
+++ b/tests/ui-cargo/lint_groups_priority/pass/src/lib.rs
@@ -0,0 +1 @@
+
-- 
cgit 1.4.1-3-g733a5


From fe8c2e24bd5697d7bf4f0b55bf2e88aa9096d4bb Mon Sep 17 00:00:00 2001
From: Quinn Sinclair <me@partiallytyped.dev>
Date: Tue, 30 Jan 2024 21:41:26 +0100
Subject: Fixed FP in `unused_io_amount` for `Ok(lit)`, `unrachable!`

We introduce the following rules for match exprs.
- `panic!` and `unreachable!` are treated as consumption.
- guard expressions in any arm imply consumption.

For match exprs:
- Lint only if exacrtly 2 non-consuming arms exist
- Lint only if one arm is an `Ok(_)` and the other is `Err(_)`

Added additional requirement that for a block return expression
that is a match, the source must be `Normal`.

changelog: FP [`unused_io_amount`] when matching Ok(literal)
---
 clippy_lints/src/unused_io_amount.rs | 101 ++++++++++++++++++++++++++---------
 tests/ui/unused_io_amount.rs         |  43 +++++++++++++++
 tests/ui/unused_io_amount.stderr     |   8 +--
 3 files changed, 123 insertions(+), 29 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/unused_io_amount.rs b/clippy_lints/src/unused_io_amount.rs
index adc66e15ff5..6b3ea7700b7 100644
--- a/clippy_lints/src/unused_io_amount.rs
+++ b/clippy_lints/src/unused_io_amount.rs
@@ -1,5 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::{is_res_lang_ctor, is_trait_method, match_trait_method, paths};
+use clippy_utils::macros::{is_panic, root_macro_call_first_node};
+use clippy_utils::{is_res_lang_ctor, is_trait_method, match_trait_method, paths, peel_blocks};
 use hir::{ExprKind, PatKind};
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass};
@@ -82,37 +83,72 @@ impl<'tcx> LateLintPass<'tcx> for UnusedIoAmount {
         }
 
         if let Some(exp) = block.expr
-            && matches!(exp.kind, hir::ExprKind::If(_, _, _) | hir::ExprKind::Match(_, _, _))
+            && matches!(
+                exp.kind,
+                hir::ExprKind::If(_, _, _) | hir::ExprKind::Match(_, _, hir::MatchSource::Normal)
+            )
         {
             check_expr(cx, exp);
         }
     }
 }
 
+fn non_consuming_err_arm<'a>(cx: &LateContext<'a>, arm: &hir::Arm<'a>) -> bool {
+    // if there is a guard, we consider the result to be consumed
+    if arm.guard.is_some() {
+        return false;
+    }
+    if is_unreachable_or_panic(cx, arm.body) {
+        // if the body is unreachable or there is a panic,
+        // we consider the result to be consumed
+        return false;
+    }
+
+    if let PatKind::TupleStruct(ref path, [inner_pat], _) = arm.pat.kind {
+        return is_res_lang_ctor(cx, cx.qpath_res(path, inner_pat.hir_id), hir::LangItem::ResultErr);
+    }
+
+    false
+}
+
+fn non_consuming_ok_arm<'a>(cx: &LateContext<'a>, arm: &hir::Arm<'a>) -> bool {
+    // if there is a guard, we consider the result to be consumed
+    if arm.guard.is_some() {
+        return false;
+    }
+    if is_unreachable_or_panic(cx, arm.body) {
+        // if the body is unreachable or there is a panic,
+        // we consider the result to be consumed
+        return false;
+    }
+
+    if is_ok_wild_or_dotdot_pattern(cx, arm.pat) {
+        return true;
+    }
+    false
+}
+
 fn check_expr<'a>(cx: &LateContext<'a>, expr: &'a hir::Expr<'a>) {
     match expr.kind {
         hir::ExprKind::If(cond, _, _)
             if let ExprKind::Let(hir::Let { pat, init, .. }) = cond.kind
-                && pattern_is_ignored_ok(cx, pat)
+                && is_ok_wild_or_dotdot_pattern(cx, pat)
                 && let Some(op) = should_lint(cx, init) =>
         {
             emit_lint(cx, cond.span, op, &[pat.span]);
         },
-        hir::ExprKind::Match(expr, arms, hir::MatchSource::Normal) if let Some(op) = should_lint(cx, expr) => {
-            let found_arms: Vec<_> = arms
-                .iter()
-                .filter_map(|arm| {
-                    if pattern_is_ignored_ok(cx, arm.pat) {
-                        Some(arm.span)
-                    } else {
-                        None
-                    }
-                })
-                .collect();
-            if !found_arms.is_empty() {
-                emit_lint(cx, expr.span, op, found_arms.as_slice());
+        // we will capture only the case where the match is Ok( ) or Err( )
+        // prefer to match the minimum possible, and expand later if needed
+        // to avoid false positives on something as used as this
+        hir::ExprKind::Match(expr, [arm1, arm2], hir::MatchSource::Normal) if let Some(op) = should_lint(cx, expr) => {
+            if non_consuming_ok_arm(cx, arm1) && non_consuming_err_arm(cx, arm2) {
+                emit_lint(cx, expr.span, op, &[arm1.pat.span]);
+            }
+            if non_consuming_ok_arm(cx, arm2) && non_consuming_err_arm(cx, arm1) {
+                emit_lint(cx, expr.span, op, &[arm2.pat.span]);
             }
         },
+        hir::ExprKind::Match(_, _, hir::MatchSource::Normal) => {},
         _ if let Some(op) = should_lint(cx, expr) => {
             emit_lint(cx, expr.span, op, &[]);
         },
@@ -130,25 +166,40 @@ fn should_lint<'a>(cx: &LateContext<'a>, mut inner: &'a hir::Expr<'a>) -> Option
     check_io_mode(cx, inner)
 }
 
-fn pattern_is_ignored_ok(cx: &LateContext<'_>, pat: &hir::Pat<'_>) -> bool {
+fn is_ok_wild_or_dotdot_pattern<'a>(cx: &LateContext<'a>, pat: &hir::Pat<'a>) -> bool {
     // the if checks whether we are in a result Ok( ) pattern
     // and the return checks whether it is unhandled
 
-    if let PatKind::TupleStruct(ref path, inner_pat, ddp) = pat.kind
+    if let PatKind::TupleStruct(ref path, inner_pat, _) = pat.kind
         // we check against Result::Ok to avoid linting on Err(_) or something else.
         && is_res_lang_ctor(cx, cx.qpath_res(path, pat.hir_id), hir::LangItem::ResultOk)
     {
-        return match (inner_pat, ddp.as_opt_usize()) {
-            // Ok(_) pattern
-            ([inner_pat], None) if matches!(inner_pat.kind, PatKind::Wild) => true,
-            // Ok(..) pattern
-            ([], Some(0)) => true,
-            _ => false,
-        };
+        if matches!(inner_pat, []) {
+            return true;
+        }
+
+        if let [cons_pat] = inner_pat
+            && matches!(cons_pat.kind, PatKind::Wild)
+        {
+            return true;
+        }
+        return false;
     }
     false
 }
 
+// this is partially taken from panic_unimplemented
+fn is_unreachable_or_panic(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> bool {
+    let expr = peel_blocks(expr);
+    let Some(macro_call) = root_macro_call_first_node(cx, expr) else {
+        return false;
+    };
+    if is_panic(cx, macro_call.def_id) {
+        return !cx.tcx.hir().is_inside_const_context(expr.hir_id);
+    }
+    matches!(cx.tcx.item_name(macro_call.def_id).as_str(), "unreachable")
+}
+
 fn unpack_call_chain<'a>(mut expr: &'a hir::Expr<'a>) -> &'a hir::Expr<'a> {
     while let hir::ExprKind::MethodCall(path, receiver, ..) = expr.kind {
         if matches!(
diff --git a/tests/ui/unused_io_amount.rs b/tests/ui/unused_io_amount.rs
index 9974600dad5..7e5a10c911b 100644
--- a/tests/ui/unused_io_amount.rs
+++ b/tests/ui/unused_io_amount.rs
@@ -229,4 +229,47 @@ fn on_return_should_not_raise<T: io::Read + io::Write>(s: &mut T) -> io::Result<
     s.read(&mut buf)
 }
 
+pub fn unwrap_in_block(rdr: &mut dyn std::io::Read) -> std::io::Result<usize> {
+    let read = { rdr.read(&mut [0])? };
+    Ok(read)
+}
+
+pub fn consumed_example(rdr: &mut dyn std::io::Read) {
+    match rdr.read(&mut [0]) {
+        Ok(0) => println!("EOF"),
+        Ok(_) => println!("fully read"),
+        Err(_) => println!("fail"),
+    };
+    match rdr.read(&mut [0]) {
+        Ok(0) => println!("EOF"),
+        Ok(_) => println!("fully read"),
+        Err(_) => println!("fail"),
+    }
+}
+
+pub fn unreachable_or_panic(rdr: &mut dyn std::io::Read) {
+    {
+        match rdr.read(&mut [0]) {
+            Ok(_) => unreachable!(),
+            Err(_) => println!("expected"),
+        }
+    }
+
+    {
+        match rdr.read(&mut [0]) {
+            Ok(_) => panic!(),
+            Err(_) => println!("expected"),
+        }
+    }
+}
+
+pub fn wildcards(rdr: &mut dyn std::io::Read) {
+    {
+        match rdr.read(&mut [0]) {
+            Ok(1) => todo!(),
+            _ => todo!(),
+        }
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/unused_io_amount.stderr b/tests/ui/unused_io_amount.stderr
index 4af56d264bf..1aab56966a8 100644
--- a/tests/ui/unused_io_amount.stderr
+++ b/tests/ui/unused_io_amount.stderr
@@ -180,7 +180,7 @@ note: the result is consumed here, but the amount of I/O bytes remains unhandled
   --> $DIR/unused_io_amount.rs:149:9
    |
 LL |         Ok(_) => todo!(),
-   |         ^^^^^^^^^^^^^^^^
+   |         ^^^^^
 
 error: read amount is not handled
   --> $DIR/unused_io_amount.rs:155:11
@@ -193,7 +193,7 @@ note: the result is consumed here, but the amount of I/O bytes remains unhandled
   --> $DIR/unused_io_amount.rs:157:9
    |
 LL |         Ok(_) => todo!(),
-   |         ^^^^^^^^^^^^^^^^
+   |         ^^^^^
 
 error: read amount is not handled
   --> $DIR/unused_io_amount.rs:164:11
@@ -206,7 +206,7 @@ note: the result is consumed here, but the amount of I/O bytes remains unhandled
   --> $DIR/unused_io_amount.rs:166:9
    |
 LL |         Ok(_) => todo!(),
-   |         ^^^^^^^^^^^^^^^^
+   |         ^^^^^
 
 error: written amount is not handled
   --> $DIR/unused_io_amount.rs:173:11
@@ -219,7 +219,7 @@ note: the result is consumed here, but the amount of I/O bytes remains unhandled
   --> $DIR/unused_io_amount.rs:175:9
    |
 LL |         Ok(_) => todo!(),
-   |         ^^^^^^^^^^^^^^^^
+   |         ^^^^^
 
 error: read amount is not handled
   --> $DIR/unused_io_amount.rs:186:8
-- 
cgit 1.4.1-3-g733a5


From 46dd8263a08a09e522d6990d11a3aa5e58702a50 Mon Sep 17 00:00:00 2001
From: J-ZhengLi <lizheng135@huawei.com>
Date: Fri, 2 Feb 2024 09:22:42 +0800
Subject: rename conf option to `allowed_wildcard_imports`

---
 CHANGELOG.md                                       |  1 +
 book/src/lint_configuration.md                     | 22 ++++++++++++++++++++++
 clippy_config/src/conf.rs                          |  8 ++++----
 clippy_lints/src/lib.rs                            |  4 ++--
 clippy_lints/src/wildcard_imports.rs               | 14 +++++++-------
 .../toml_unknown_key/conf_unknown_key.stderr       |  5 +++--
 tests/ui-toml/wildcard_imports/clippy.toml         |  2 +-
 .../ui-toml/wildcard_imports_whitelist/clippy.toml |  2 +-
 8 files changed, 41 insertions(+), 17 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 471163499e5..c4cddd0b4b8 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5823,4 +5823,5 @@ Released 2018-09-13
 [`check-private-items`]: https://doc.rust-lang.org/clippy/lint_configuration.html#check-private-items
 [`pub-underscore-fields-behavior`]: https://doc.rust-lang.org/clippy/lint_configuration.html#pub-underscore-fields-behavior
 [`allow-comparison-to-zero`]: https://doc.rust-lang.org/clippy/lint_configuration.html#allow-comparison-to-zero
+[`allowed-wildcard-imports`]: https://doc.rust-lang.org/clippy/lint_configuration.html#allowed-wildcard-imports
 <!-- end autogenerated links to configuration documentation -->
diff --git a/book/src/lint_configuration.md b/book/src/lint_configuration.md
index 1b321b8bcb8..669cdb0735d 100644
--- a/book/src/lint_configuration.md
+++ b/book/src/lint_configuration.md
@@ -838,3 +838,25 @@ Don't lint when comparing the result of a modulo operation to zero.
 * [`modulo_arithmetic`](https://rust-lang.github.io/rust-clippy/master/index.html#modulo_arithmetic)
 
 
+## `allowed-wildcard-imports`
+List of path segments allowed to have wildcard imports.
+
+#### Example
+
+```toml
+allowed-wildcard-imports = [ "utils", "common" ]
+```
+
+#### Noteworthy
+
+1. This configuration has no effects if used with `warn_on_all_wildcard_imports = true`.
+2. Paths with any segment that containing the word 'prelude'
+are already allowed by default.
+
+**Default Value:** `[]`
+
+---
+**Affected lints:**
+* [`wildcard_imports`](https://rust-lang.github.io/rust-clippy/master/index.html#wildcard_imports)
+
+
diff --git a/clippy_config/src/conf.rs b/clippy_config/src/conf.rs
index d03f805e2fc..a7a81b6f421 100644
--- a/clippy_config/src/conf.rs
+++ b/clippy_config/src/conf.rs
@@ -573,20 +573,20 @@ define_Conf! {
     (allow_comparison_to_zero: bool = true),
     /// Lint: WILDCARD_IMPORTS.
     ///
-    /// List of path segments to ignore when checking wildcard imports.
+    /// List of path segments allowed to have wildcard imports.
     ///
     /// #### Example
     ///
     /// ```toml
-    /// ignored-wildcard-imports = [ "utils", "common" ]
+    /// allowed-wildcard-imports = [ "utils", "common" ]
     /// ```
     ///
     /// #### Noteworthy
     ///
     /// 1. This configuration has no effects if used with `warn_on_all_wildcard_imports = true`.
     /// 2. Paths with any segment that containing the word 'prelude'
-    /// are already ignored by default.
-    (ignored_wildcard_imports: FxHashSet<String> = FxHashSet::default()),
+    /// are already allowed by default.
+    (allowed_wildcard_imports: FxHashSet<String> = FxHashSet::default()),
 }
 
 /// Search for the configuration file.
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 678058a5411..5636f46b22f 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -524,6 +524,7 @@ pub fn register_lints(store: &mut rustc_lint::LintStore, conf: &'static Conf) {
         ref allowed_dotfiles,
         ref allowed_idents_below_min_chars,
         ref allowed_scripts,
+        ref allowed_wildcard_imports,
         ref arithmetic_side_effects_allowed_binary,
         ref arithmetic_side_effects_allowed_unary,
         ref arithmetic_side_effects_allowed,
@@ -545,7 +546,6 @@ pub fn register_lints(store: &mut rustc_lint::LintStore, conf: &'static Conf) {
         excessive_nesting_threshold,
         future_size_threshold,
         ref ignore_interior_mutability,
-        ref ignored_wildcard_imports,
         large_error_threshold,
         literal_representation_threshold,
         matches_for_let_else,
@@ -880,7 +880,7 @@ pub fn register_lints(store: &mut rustc_lint::LintStore, conf: &'static Conf) {
     store.register_late_pass(move |_| {
         Box::new(wildcard_imports::WildcardImports::new(
             warn_on_all_wildcard_imports,
-            ignored_wildcard_imports.clone(),
+            allowed_wildcard_imports.clone(),
         ))
     });
     store.register_late_pass(|_| Box::<redundant_pub_crate::RedundantPubCrate>::default());
diff --git a/clippy_lints/src/wildcard_imports.rs b/clippy_lints/src/wildcard_imports.rs
index 7318ffc9587..5410e8ac117 100644
--- a/clippy_lints/src/wildcard_imports.rs
+++ b/clippy_lints/src/wildcard_imports.rs
@@ -101,15 +101,15 @@ declare_clippy_lint! {
 pub struct WildcardImports {
     warn_on_all: bool,
     test_modules_deep: u32,
-    ignored_segments: FxHashSet<String>,
+    allowed_segments: FxHashSet<String>,
 }
 
 impl WildcardImports {
-    pub fn new(warn_on_all: bool, ignored_wildcard_imports: FxHashSet<String>) -> Self {
+    pub fn new(warn_on_all: bool, allowed_wildcard_imports: FxHashSet<String>) -> Self {
         Self {
             warn_on_all,
             test_modules_deep: 0,
-            ignored_segments: ignored_wildcard_imports,
+            allowed_segments: allowed_wildcard_imports,
         }
     }
 }
@@ -193,7 +193,7 @@ impl WildcardImports {
         item.span.from_expansion()
             || is_prelude_import(segments)
             || (is_super_only_import(segments) && self.test_modules_deep > 0)
-            || is_ignored_via_config(segments, &self.ignored_segments)
+            || is_allowed_via_config(segments, &self.allowed_segments)
     }
 }
 
@@ -211,9 +211,9 @@ fn is_super_only_import(segments: &[PathSegment<'_>]) -> bool {
 }
 
 // Allow skipping imports containing user configured segments,
-// i.e. "...::utils::...::*" if user put `ignored-wildcard-imports = ["utils"]` in `Clippy.toml`
-fn is_ignored_via_config(segments: &[PathSegment<'_>], ignored_segments: &FxHashSet<String>) -> bool {
+// i.e. "...::utils::...::*" if user put `allowed-wildcard-imports = ["utils"]` in `Clippy.toml`
+fn is_allowed_via_config(segments: &[PathSegment<'_>], allowed_segments: &FxHashSet<String>) -> bool {
     // segment matching need to be exact instead of using 'contains', in case user unintentionaly put
     // a single character in the config thus skipping most of the warnings.
-    segments.iter().any(|seg| ignored_segments.contains(seg.ident.as_str()))
+    segments.iter().any(|seg| allowed_segments.contains(seg.ident.as_str()))
 }
diff --git a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
index b1e000abec8..f097d2503e1 100644
--- a/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
+++ b/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
@@ -15,6 +15,7 @@ error: error reading Clippy's configuration file: unknown field `foobar`, expect
            allowed-duplicate-crates
            allowed-idents-below-min-chars
            allowed-scripts
+           allowed-wildcard-imports
            arithmetic-side-effects-allowed
            arithmetic-side-effects-allowed-binary
            arithmetic-side-effects-allowed-unary
@@ -39,7 +40,6 @@ error: error reading Clippy's configuration file: unknown field `foobar`, expect
            excessive-nesting-threshold
            future-size-threshold
            ignore-interior-mutability
-           ignored-wildcard-imports
            large-error-threshold
            literal-representation-threshold
            matches-for-let-else
@@ -94,6 +94,7 @@ error: error reading Clippy's configuration file: unknown field `barfoo`, expect
            allowed-duplicate-crates
            allowed-idents-below-min-chars
            allowed-scripts
+           allowed-wildcard-imports
            arithmetic-side-effects-allowed
            arithmetic-side-effects-allowed-binary
            arithmetic-side-effects-allowed-unary
@@ -118,7 +119,6 @@ error: error reading Clippy's configuration file: unknown field `barfoo`, expect
            excessive-nesting-threshold
            future-size-threshold
            ignore-interior-mutability
-           ignored-wildcard-imports
            large-error-threshold
            literal-representation-threshold
            matches-for-let-else
@@ -173,6 +173,7 @@ error: error reading Clippy's configuration file: unknown field `allow_mixed_uni
            allowed-duplicate-crates
            allowed-idents-below-min-chars
            allowed-scripts
+           allowed-wildcard-imports
            arithmetic-side-effects-allowed
            arithmetic-side-effects-allowed-binary
            arithmetic-side-effects-allowed-unary
diff --git a/tests/ui-toml/wildcard_imports/clippy.toml b/tests/ui-toml/wildcard_imports/clippy.toml
index 56a945e48bb..68815c1756a 100644
--- a/tests/ui-toml/wildcard_imports/clippy.toml
+++ b/tests/ui-toml/wildcard_imports/clippy.toml
@@ -1,4 +1,4 @@
 warn-on-all-wildcard-imports = true
 
 # This should be ignored since `warn-on-all-wildcard-imports` has higher precedence
-ignored-wildcard-imports = ["utils"]
+allowed-wildcard-imports = ["utils"]
diff --git a/tests/ui-toml/wildcard_imports_whitelist/clippy.toml b/tests/ui-toml/wildcard_imports_whitelist/clippy.toml
index 1d28cac588b..6b7882e64a8 100644
--- a/tests/ui-toml/wildcard_imports_whitelist/clippy.toml
+++ b/tests/ui-toml/wildcard_imports_whitelist/clippy.toml
@@ -1 +1 @@
-ignored-wildcard-imports = ["utils"]
+allowed-wildcard-imports = ["utils"]
-- 
cgit 1.4.1-3-g733a5


From eb05b07451b91c7a707adac828841fa1d99725bf Mon Sep 17 00:00:00 2001
From: roife <roifewu@gmail.com>
Date: Fri, 2 Feb 2024 15:28:34 +0800
Subject: Move qpath_spans into FunctionKind

---
 .../methods/unnecessary_fallible_conversions.rs    | 49 ++++++++++------------
 1 file changed, 23 insertions(+), 26 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/unnecessary_fallible_conversions.rs b/clippy_lints/src/methods/unnecessary_fallible_conversions.rs
index 53069391633..4ef26cba468 100644
--- a/clippy_lints/src/methods/unnecessary_fallible_conversions.rs
+++ b/clippy_lints/src/methods/unnecessary_fallible_conversions.rs
@@ -12,15 +12,15 @@ use super::UNNECESSARY_FALLIBLE_CONVERSIONS;
 
 /// What function is being called and whether that call is written as a method call or a function
 /// call
-#[derive(Copy, Clone)]
+#[derive(Clone)]
 #[expect(clippy::enum_variant_names)]
 enum FunctionKind {
     /// `T::try_from(U)`
-    TryFromFunction,
+    TryFromFunction(Option<Vec<Span>>),
     /// `t.try_into()`
     TryIntoMethod,
     /// `U::try_into(t)`
-    TryIntoFunction,
+    TryIntoFunction(Option<Vec<Span>>),
 }
 
 fn check<'tcx>(
@@ -29,15 +29,14 @@ fn check<'tcx>(
     node_args: ty::GenericArgsRef<'tcx>,
     kind: FunctionKind,
     primary_span: Span,
-    qpath: Option<&QPath<'_>>,
 ) {
     if let &[self_ty, other_ty] = node_args.as_slice()
         // useless_conversion already warns `T::try_from(T)`, so ignore it here
         && self_ty != other_ty
         && let Some(self_ty) = self_ty.as_type()
         && let Some(from_into_trait) = cx.tcx.get_diagnostic_item(match kind {
-            FunctionKind::TryFromFunction => sym::From,
-            FunctionKind::TryIntoMethod | FunctionKind::TryIntoFunction => sym::Into,
+            FunctionKind::TryFromFunction(_) => sym::From,
+            FunctionKind::TryIntoMethod | FunctionKind::TryIntoFunction(_) => sym::Into,
         })
         // If `T: TryFrom<U>` and `T: From<U>` both exist, then that means that the `TryFrom`
         // _must_ be from the blanket impl and cannot have been manually implemented
@@ -70,21 +69,12 @@ fn check<'tcx>(
             primary_span
         };
 
-        let qpath_spans = qpath.and_then(|qpath| match qpath {
-            QPath::Resolved(_, path) => {
-                let segments = path.segments.iter().map(|seg| seg.ident).collect::<Vec<_>>();
-                (segments.len() == 2).then(|| vec![segments[0].span, segments[1].span])
-            },
-            QPath::TypeRelative(_, seg) => Some(vec![seg.ident.span]),
-            QPath::LangItem(_, _) => unreachable!("`TryFrom` and `TryInto` are not lang items"),
-        });
-
-        let (source_ty, target_ty, sugg, applicability) = match (kind, &qpath_spans, parent_unwrap_call) {
-            (FunctionKind::TryIntoMethod, _, Some(unwrap_span)) => {
+        let (source_ty, target_ty, sugg, applicability) = match (kind, parent_unwrap_call) {
+            (FunctionKind::TryIntoMethod, Some(unwrap_span)) => {
                 let sugg = vec![(primary_span, String::from("into")), (unwrap_span, String::new())];
                 (self_ty, other_ty, sugg, Applicability::MachineApplicable)
             },
-            (FunctionKind::TryFromFunction, Some(spans), Some(unwrap_span)) => {
+            (FunctionKind::TryFromFunction(Some(spans)), Some(unwrap_span)) => {
                 let sugg = match spans.len() {
                     1 => vec![(spans[0], String::from("from")), (unwrap_span, String::new())],
                     2 => vec![
@@ -96,7 +86,7 @@ fn check<'tcx>(
                 };
                 (other_ty, self_ty, sugg, Applicability::MachineApplicable)
             },
-            (FunctionKind::TryIntoFunction, Some(spans), Some(unwrap_span)) => {
+            (FunctionKind::TryIntoFunction(Some(spans)), Some(unwrap_span)) => {
                 let sugg = match spans.len() {
                     1 => vec![(spans[0], String::from("into")), (unwrap_span, String::new())],
                     2 => vec![
@@ -108,15 +98,15 @@ fn check<'tcx>(
                 };
                 (self_ty, other_ty, sugg, Applicability::MachineApplicable)
             },
-            (FunctionKind::TryFromFunction, _, _) => {
+            (FunctionKind::TryFromFunction(_), _) => {
                 let sugg = vec![(primary_span, String::from("From::from"))];
                 (other_ty, self_ty, sugg, Applicability::Unspecified)
             },
-            (FunctionKind::TryIntoFunction, _, _) => {
+            (FunctionKind::TryIntoFunction(_), _) => {
                 let sugg = vec![(primary_span, String::from("Into::into"))];
                 (self_ty, other_ty, sugg, Applicability::Unspecified)
             },
-            (FunctionKind::TryIntoMethod, _, _) => {
+            (FunctionKind::TryIntoMethod, _) => {
                 let sugg = vec![(primary_span, String::from("into"))];
                 (self_ty, other_ty, sugg, Applicability::Unspecified)
             },
@@ -147,7 +137,6 @@ pub(super) fn check_method(cx: &LateContext<'_>, expr: &Expr<'_>) {
             cx.typeck_results().node_args(expr.hir_id),
             FunctionKind::TryIntoMethod,
             path.ident.span,
-            None,
         );
     }
 }
@@ -160,17 +149,25 @@ pub(super) fn check_function(cx: &LateContext<'_>, expr: &Expr<'_>, callee: &Exp
         && let Some(item_def_id) = cx.qpath_res(qpath, callee.hir_id).opt_def_id()
         && let Some(trait_def_id) = cx.tcx.trait_of_item(item_def_id)
     {
+        let qpath_spans = match qpath {
+            QPath::Resolved(_, path) => {
+                let segments = path.segments.iter().map(|seg| seg.ident).collect::<Vec<_>>();
+                (segments.len() == 2).then(|| vec![segments[0].span, segments[1].span])
+            },
+            QPath::TypeRelative(_, seg) => Some(vec![seg.ident.span]),
+            QPath::LangItem(_, _) => unreachable!("`TryFrom` and `TryInto` are not lang items"),
+        };
+
         check(
             cx,
             expr,
             cx.typeck_results().node_args(callee.hir_id),
             match cx.tcx.get_diagnostic_name(trait_def_id) {
-                Some(sym::TryFrom) => FunctionKind::TryFromFunction,
-                Some(sym::TryInto) => FunctionKind::TryIntoFunction,
+                Some(sym::TryFrom) => FunctionKind::TryFromFunction(qpath_spans),
+                Some(sym::TryInto) => FunctionKind::TryIntoFunction(qpath_spans),
                 _ => return,
             },
             callee.span,
-            Some(qpath),
         );
     }
 }
-- 
cgit 1.4.1-3-g733a5


From e83c7d49dbc18112bfaa7197a87145a99a9570fc Mon Sep 17 00:00:00 2001
From: roife <roifewu@gmail.com>
Date: Fri, 2 Feb 2024 18:59:33 +0800
Subject: Refactor sugg builder in unnecessary_fallible_conversions

---
 .../methods/unnecessary_fallible_conversions.rs    | 119 +++++++++++++--------
 1 file changed, 72 insertions(+), 47 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/unnecessary_fallible_conversions.rs b/clippy_lints/src/methods/unnecessary_fallible_conversions.rs
index 4ef26cba468..42ad700a574 100644
--- a/clippy_lints/src/methods/unnecessary_fallible_conversions.rs
+++ b/clippy_lints/src/methods/unnecessary_fallible_conversions.rs
@@ -10,17 +10,64 @@ use rustc_span::{sym, Span};
 
 use super::UNNECESSARY_FALLIBLE_CONVERSIONS;
 
+#[derive(Copy, Clone)]
+enum SpansKind {
+    TraitFn { trait_span: Span, fn_span: Span },
+    Fn { fn_span: Span },
+}
+
 /// What function is being called and whether that call is written as a method call or a function
 /// call
-#[derive(Clone)]
+#[derive(Copy, Clone)]
 #[expect(clippy::enum_variant_names)]
 enum FunctionKind {
     /// `T::try_from(U)`
-    TryFromFunction(Option<Vec<Span>>),
+    TryFromFunction(Option<SpansKind>),
     /// `t.try_into()`
     TryIntoMethod,
     /// `U::try_into(t)`
-    TryIntoFunction(Option<Vec<Span>>),
+    TryIntoFunction(Option<SpansKind>),
+}
+
+impl FunctionKind {
+    fn applicability(&self, parent_unwrap_call: &Option<Span>) -> Applicability {
+        if parent_unwrap_call.is_none() {
+            return Applicability::Unspecified;
+        }
+        match &self {
+            FunctionKind::TryFromFunction(None) | FunctionKind::TryIntoFunction(None) => Applicability::Unspecified,
+            _ => Applicability::MachineApplicable,
+        }
+    }
+
+    fn default_sugg(&self, primary_span: Span) -> Vec<(Span, String)> {
+        match *self {
+            FunctionKind::TryFromFunction(_) => vec![(primary_span, String::from("From::from"))],
+            FunctionKind::TryIntoFunction(_) => vec![(primary_span, String::from("Into::into"))],
+            FunctionKind::TryIntoMethod => vec![(primary_span, String::from("into"))],
+        }
+    }
+
+    fn machine_applicable_sugg(&self, primary_span: Span, unwrap_span: Span) -> Vec<(Span, String)> {
+        let mut sugg = match *self {
+            FunctionKind::TryFromFunction(Some(spans)) => match spans {
+                SpansKind::TraitFn { trait_span, fn_span } => {
+                    vec![(trait_span, String::from("From")), (fn_span, String::from("from"))]
+                },
+                SpansKind::Fn { fn_span } => vec![(fn_span, String::from("from"))],
+            },
+            FunctionKind::TryIntoFunction(Some(spans)) => match spans {
+                SpansKind::TraitFn { trait_span, fn_span } => {
+                    vec![(trait_span, String::from("Into")), (fn_span, String::from("into"))]
+                },
+                SpansKind::Fn { fn_span } => vec![(fn_span, String::from("into"))],
+            },
+            FunctionKind::TryIntoMethod => vec![(primary_span, String::from("into"))],
+            _ => unreachable!(),
+        };
+        sugg.push((unwrap_span, String::new()));
+        sugg
+    }
 }
 
 fn check<'tcx>(
@@ -69,47 +116,17 @@ fn check<'tcx>(
             primary_span
         };
 
-        let (source_ty, target_ty, sugg, applicability) = match (kind, parent_unwrap_call) {
-            (FunctionKind::TryIntoMethod, Some(unwrap_span)) => {
-                let sugg = vec![(primary_span, String::from("into")), (unwrap_span, String::new())];
-                (self_ty, other_ty, sugg, Applicability::MachineApplicable)
-            },
-            (FunctionKind::TryFromFunction(Some(spans)), Some(unwrap_span)) => {
-                let sugg = match spans.len() {
-                    1 => vec![(spans[0], String::from("from")), (unwrap_span, String::new())],
-                    2 => vec![
-                        (spans[0], String::from("From")),
-                        (spans[1], String::from("from")),
-                        (unwrap_span, String::new()),
-                    ],
-                    _ => unreachable!(),
-                };
-                (other_ty, self_ty, sugg, Applicability::MachineApplicable)
-            },
-            (FunctionKind::TryIntoFunction(Some(spans)), Some(unwrap_span)) => {
-                let sugg = match spans.len() {
-                    1 => vec![(spans[0], String::from("into")), (unwrap_span, String::new())],
-                    2 => vec![
-                        (spans[0], String::from("Into")),
-                        (spans[1], String::from("into")),
-                        (unwrap_span, String::new()),
-                    ],
-                    _ => unreachable!(),
-                };
-                (self_ty, other_ty, sugg, Applicability::MachineApplicable)
-            },
-            (FunctionKind::TryFromFunction(_), _) => {
-                let sugg = vec![(primary_span, String::from("From::from"))];
-                (other_ty, self_ty, sugg, Applicability::Unspecified)
-            },
-            (FunctionKind::TryIntoFunction(_), _) => {
-                let sugg = vec![(primary_span, String::from("Into::into"))];
-                (self_ty, other_ty, sugg, Applicability::Unspecified)
-            },
-            (FunctionKind::TryIntoMethod, _) => {
-                let sugg = vec![(primary_span, String::from("into"))];
-                (self_ty, other_ty, sugg, Applicability::Unspecified)
-            },
+        let (source_ty, target_ty) = match kind {
+            FunctionKind::TryIntoMethod | FunctionKind::TryIntoFunction(_) => (self_ty, other_ty),
+            FunctionKind::TryFromFunction(_) => (other_ty, self_ty),
+        };
+
+        let applicability = kind.applicability(&parent_unwrap_call);
+
+        let sugg = if applicability == Applicability::MachineApplicable {
+            kind.machine_applicable_sugg(primary_span, parent_unwrap_call.unwrap())
+        } else {
+            kind.default_sugg(primary_span)
         };
 
         span_lint_and_then(
@@ -151,10 +168,18 @@ pub(super) fn check_function(cx: &LateContext<'_>, expr: &Expr<'_>, callee: &Exp
     {
         let qpath_spans = match qpath {
             QPath::Resolved(_, path) => {
-                let segments = path.segments.iter().map(|seg| seg.ident).collect::<Vec<_>>();
-                (segments.len() == 2).then(|| vec![segments[0].span, segments[1].span])
+                if let [trait_seg, fn_seg] = path.segments {
+                    Some(SpansKind::TraitFn {
+                        trait_span: trait_seg.ident.span,
+                        fn_span: fn_seg.ident.span,
+                    })
+                } else {
+                    None
+                }
             },
-            QPath::TypeRelative(_, seg) => Some(vec![seg.ident.span]),
+            QPath::TypeRelative(_, seg) => Some(SpansKind::Fn {
+                fn_span: seg.ident.span,
+            }),
             QPath::LangItem(_, _) => unreachable!("`TryFrom` and `TryInto` are not lang items"),
         };
 
-- 
cgit 1.4.1-3-g733a5


From 015ac1095417a61f293ca46b7f320ac935176c83 Mon Sep 17 00:00:00 2001
From: roife <roifewu@gmail.com>
Date: Sat, 3 Feb 2024 00:50:20 +0800
Subject: Refactor machine_applicable_sugg in unnecessary_fallible_conversions

---
 .../methods/unnecessary_fallible_conversions.rs    | 41 +++++++++++++---------
 1 file changed, 24 insertions(+), 17 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/unnecessary_fallible_conversions.rs b/clippy_lints/src/methods/unnecessary_fallible_conversions.rs
index 42ad700a574..72bd8f7e000 100644
--- a/clippy_lints/src/methods/unnecessary_fallible_conversions.rs
+++ b/clippy_lints/src/methods/unnecessary_fallible_conversions.rs
@@ -34,6 +34,7 @@ impl FunctionKind {
         if parent_unwrap_call.is_none() {
             return Applicability::Unspecified;
         }
+
         match &self {
             FunctionKind::TryFromFunction(None) | FunctionKind::TryIntoFunction(None) => Applicability::Unspecified,
             _ => Applicability::MachineApplicable,
@@ -41,30 +42,36 @@ impl FunctionKind {
     }
 
     fn default_sugg(&self, primary_span: Span) -> Vec<(Span, String)> {
-        match *self {
-            FunctionKind::TryFromFunction(_) => vec![(primary_span, String::from("From::from"))],
-            FunctionKind::TryIntoFunction(_) => vec![(primary_span, String::from("Into::into"))],
-            FunctionKind::TryIntoMethod => vec![(primary_span, String::from("into"))],
-        }
+        let replacement = match *self {
+            FunctionKind::TryFromFunction(_) => "From::from",
+            FunctionKind::TryIntoFunction(_) => "Into::into",
+            FunctionKind::TryIntoMethod => "into",
+        };
+
+        vec![(primary_span, String::from(replacement))]
     }
 
     fn machine_applicable_sugg(&self, primary_span: Span, unwrap_span: Span) -> Vec<(Span, String)> {
+        use FunctionKind::*;
+        use SpansKind::*;
+
+        let (trait_name, fn_name) = {
+            let (a, b) = match self {
+                TryFromFunction(_) => ("From", "from"),
+                TryIntoFunction(_) | TryIntoMethod => ("Into", "into"),
+            };
+            (a.to_string(), b.to_string())
+        };
+
         let mut sugg = match *self {
-            FunctionKind::TryFromFunction(Some(spans)) => match spans {
-                SpansKind::TraitFn { trait_span, fn_span } => {
-                    vec![(trait_span, String::from("From")), (fn_span, String::from("from"))]
-                },
-                SpansKind::Fn { fn_span } => vec![(fn_span, String::from("from"))],
+            TryFromFunction(Some(spans)) | TryIntoFunction(Some(spans)) => match spans {
+                TraitFn { trait_span, fn_span } => vec![(trait_span, trait_name), (fn_span, fn_name)],
+                Fn { fn_span } => vec![(fn_span, fn_name)],
             },
-            FunctionKind::TryIntoFunction(Some(spans)) => match spans {
-                SpansKind::TraitFn { trait_span, fn_span } => {
-                    vec![(trait_span, String::from("Into")), (fn_span, String::from("into"))]
-                },
-                SpansKind::Fn { fn_span } => vec![(fn_span, String::from("into"))],
-            },
-            FunctionKind::TryIntoMethod => vec![(primary_span, String::from("into"))],
+            TryIntoMethod => vec![(primary_span, fn_name)],
             _ => unreachable!(),
         };
+
         sugg.push((unwrap_span, String::new()));
         sugg
     }
-- 
cgit 1.4.1-3-g733a5


From fb9fd513f57ea6939c20829286b2c44398c35d2d Mon Sep 17 00:00:00 2001
From: roife <roifewu@gmail.com>
Date: Sat, 3 Feb 2024 13:46:16 +0800
Subject: Remove wildcard usage for patterns

---
 .../src/methods/unnecessary_fallible_conversions.rs | 21 ++++++++-------------
 1 file changed, 8 insertions(+), 13 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/unnecessary_fallible_conversions.rs b/clippy_lints/src/methods/unnecessary_fallible_conversions.rs
index 72bd8f7e000..bb23ae5f843 100644
--- a/clippy_lints/src/methods/unnecessary_fallible_conversions.rs
+++ b/clippy_lints/src/methods/unnecessary_fallible_conversions.rs
@@ -52,23 +52,18 @@ impl FunctionKind {
     }
 
     fn machine_applicable_sugg(&self, primary_span: Span, unwrap_span: Span) -> Vec<(Span, String)> {
-        use FunctionKind::*;
-        use SpansKind::*;
-
-        let (trait_name, fn_name) = {
-            let (a, b) = match self {
-                TryFromFunction(_) => ("From", "from"),
-                TryIntoFunction(_) | TryIntoMethod => ("Into", "into"),
-            };
-            (a.to_string(), b.to_string())
+        let (trait_name, fn_name) = match self {
+            FunctionKind::TryFromFunction(_) => ("From".to_owned(), "from".to_owned()),
+            FunctionKind::TryIntoFunction(_) | FunctionKind::TryIntoMethod => ("Into".to_owned(), "into".to_owned()),
         };
 
         let mut sugg = match *self {
-            TryFromFunction(Some(spans)) | TryIntoFunction(Some(spans)) => match spans {
-                TraitFn { trait_span, fn_span } => vec![(trait_span, trait_name), (fn_span, fn_name)],
-                Fn { fn_span } => vec![(fn_span, fn_name)],
+            FunctionKind::TryFromFunction(Some(spans)) | FunctionKind::TryIntoFunction(Some(spans)) => match spans {
+                SpansKind::TraitFn { trait_span, fn_span } => vec![(trait_span, trait_name), (fn_span, fn_name)],
+                SpansKind::Fn { fn_span } => vec![(fn_span, fn_name)],
             },
-            TryIntoMethod => vec![(primary_span, fn_name)],
+            FunctionKind::TryIntoMethod => vec![(primary_span, fn_name)],
+            // Or the suggestion is not machine-applicable
             _ => unreachable!(),
         };
 
-- 
cgit 1.4.1-3-g733a5


From abced206d7b9f07f39c1324913f498851e948799 Mon Sep 17 00:00:00 2001
From: Seo Sanghyeon <sanxiyn@gmail.com>
Date: Thu, 1 Feb 2024 06:09:55 +0900
Subject: Avoid deleting labeled blocks

---
 clippy_lints/src/no_effect.rs        | 2 +-
 tests/ui/unnecessary_operation.fixed | 7 +++++++
 tests/ui/unnecessary_operation.rs    | 7 +++++++
 3 files changed, 15 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/no_effect.rs b/clippy_lints/src/no_effect.rs
index 0d234f7f9b5..580160efeb7 100644
--- a/clippy_lints/src/no_effect.rs
+++ b/clippy_lints/src/no_effect.rs
@@ -357,7 +357,7 @@ fn reduce_expression<'a>(cx: &LateContext<'_>, expr: &'a Expr<'a>) -> Option<Vec
             }
         },
         ExprKind::Block(block, _) => {
-            if block.stmts.is_empty() {
+            if block.stmts.is_empty() && !block.targeted_by_break {
                 block.expr.as_ref().and_then(|e| {
                     match block.rules {
                         BlockCheckMode::UnsafeBlock(UnsafeSource::UserProvided) => None,
diff --git a/tests/ui/unnecessary_operation.fixed b/tests/ui/unnecessary_operation.fixed
index 463412daec0..11761c6c90e 100644
--- a/tests/ui/unnecessary_operation.fixed
+++ b/tests/ui/unnecessary_operation.fixed
@@ -106,4 +106,11 @@ fn main() {
 
     // Issue #11885
     Cout << 16;
+
+    // Issue #11575
+    // Bad formatting is required to trigger the bug
+    #[rustfmt::skip]
+    'label: {
+        break 'label
+    };
 }
diff --git a/tests/ui/unnecessary_operation.rs b/tests/ui/unnecessary_operation.rs
index f0d28e28902..de0081289ac 100644
--- a/tests/ui/unnecessary_operation.rs
+++ b/tests/ui/unnecessary_operation.rs
@@ -110,4 +110,11 @@ fn main() {
 
     // Issue #11885
     Cout << 16;
+
+    // Issue #11575
+    // Bad formatting is required to trigger the bug
+    #[rustfmt::skip]
+    'label: {
+        break 'label
+    };
 }
-- 
cgit 1.4.1-3-g733a5


From be47e32e9e6e27ce8ff5c674e4d2104761b5c875 Mon Sep 17 00:00:00 2001
From: xFrednet <xFrednet@gmail.com>
Date: Sun, 4 Feb 2024 16:18:31 +0100
Subject: Update version attributes for 1.76 lints

---
 clippy_lints/src/doc/mod.rs                  | 2 +-
 clippy_lints/src/iter_over_hash_type.rs      | 2 +-
 clippy_lints/src/loops/mod.rs                | 2 +-
 clippy_lints/src/repeat_vec_with_capacity.rs | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/doc/mod.rs b/clippy_lints/src/doc/mod.rs
index ba452775015..2b4ce6ddfaa 100644
--- a/clippy_lints/src/doc/mod.rs
+++ b/clippy_lints/src/doc/mod.rs
@@ -226,7 +226,7 @@ declare_clippy_lint! {
     ///     unimplemented!();
     /// }
     /// ```
-    #[clippy::version = "1.40.0"]
+    #[clippy::version = "1.76.0"]
     pub TEST_ATTR_IN_DOCTEST,
     suspicious,
     "presence of `#[test]` in code examples"
diff --git a/clippy_lints/src/iter_over_hash_type.rs b/clippy_lints/src/iter_over_hash_type.rs
index 8110c1970d9..6c6eff9ba48 100644
--- a/clippy_lints/src/iter_over_hash_type.rs
+++ b/clippy_lints/src/iter_over_hash_type.rs
@@ -34,7 +34,7 @@ declare_clippy_lint! {
     ///         let value = &my_map[key];
     ///     }
     /// ```
-    #[clippy::version = "1.75.0"]
+    #[clippy::version = "1.76.0"]
     pub ITER_OVER_HASH_TYPE,
     restriction,
     "iterating over unordered hash-based types (`HashMap` and `HashSet`)"
diff --git a/clippy_lints/src/loops/mod.rs b/clippy_lints/src/loops/mod.rs
index 3c9bde86bb6..b5e39b33c6a 100644
--- a/clippy_lints/src/loops/mod.rs
+++ b/clippy_lints/src/loops/mod.rs
@@ -672,7 +672,7 @@ declare_clippy_lint! {
     ///     }
     /// }
     /// ```
-    #[clippy::version = "1.75.0"]
+    #[clippy::version = "1.76.0"]
     pub INFINITE_LOOP,
     restriction,
     "possibly unintended infinite loop"
diff --git a/clippy_lints/src/repeat_vec_with_capacity.rs b/clippy_lints/src/repeat_vec_with_capacity.rs
index 5a4933a3fce..fcb79f6d694 100644
--- a/clippy_lints/src/repeat_vec_with_capacity.rs
+++ b/clippy_lints/src/repeat_vec_with_capacity.rs
@@ -42,7 +42,7 @@ declare_clippy_lint! {
     /// //                                      ^^^ this closure executes 123 times
     /// //                                          and the vecs will have the expected capacity
     /// ```
-    #[clippy::version = "1.74.0"]
+    #[clippy::version = "1.76.0"]
     pub REPEAT_VEC_WITH_CAPACITY,
     suspicious,
     "repeating a `Vec::with_capacity` expression which does not retain capacity"
-- 
cgit 1.4.1-3-g733a5


From a3baebcb3147773c9673e4ea166e3419201e8b9f Mon Sep 17 00:00:00 2001
From: Marcin Serwin <marcin.serwin0@protonmail.com>
Date: Tue, 2 Jan 2024 22:54:17 +0100
Subject: Add ref_as_ptr lint

Author:    Marcin Serwin <marcin.serwin0@protonmail.com>
---
 CHANGELOG.md                               |   1 +
 README.md                                  |   2 +-
 book/src/README.md                         |   2 +-
 clippy_config/src/msrvs.rs                 |   1 +
 clippy_lints/src/casts/mod.rs              |  30 +++-
 clippy_lints/src/casts/ref_as_ptr.rs       |  55 ++++++
 clippy_lints/src/declared_lints.rs         |   1 +
 clippy_lints/src/only_used_in_recursion.rs |   5 +-
 tests/ui/borrow_as_ptr.fixed               |   1 +
 tests/ui/borrow_as_ptr.rs                  |   1 +
 tests/ui/borrow_as_ptr.stderr              |   4 +-
 tests/ui/borrow_as_ptr_no_std.fixed        |   1 +
 tests/ui/borrow_as_ptr_no_std.rs           |   1 +
 tests/ui/borrow_as_ptr_no_std.stderr       |   4 +-
 tests/ui/ref_as_ptr.fixed                  | 110 ++++++++++++
 tests/ui/ref_as_ptr.rs                     | 110 ++++++++++++
 tests/ui/ref_as_ptr.stderr                 | 269 +++++++++++++++++++++++++++++
 17 files changed, 588 insertions(+), 10 deletions(-)
 create mode 100644 clippy_lints/src/casts/ref_as_ptr.rs
 create mode 100644 tests/ui/ref_as_ptr.fixed
 create mode 100644 tests/ui/ref_as_ptr.rs
 create mode 100644 tests/ui/ref_as_ptr.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index e6c081ca94f..a03878c54c7 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5522,6 +5522,7 @@ Released 2018-09-13
 [`redundant_slicing`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_slicing
 [`redundant_static_lifetimes`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_static_lifetimes
 [`redundant_type_annotations`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_type_annotations
+[`ref_as_ptr`]: https://rust-lang.github.io/rust-clippy/master/index.html#ref_as_ptr
 [`ref_binding_to_reference`]: https://rust-lang.github.io/rust-clippy/master/index.html#ref_binding_to_reference
 [`ref_in_deref`]: https://rust-lang.github.io/rust-clippy/master/index.html#ref_in_deref
 [`ref_option_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#ref_option_ref
diff --git a/README.md b/README.md
index 5d490645d89..0450b54121d 100644
--- a/README.md
+++ b/README.md
@@ -5,7 +5,7 @@
 
 A collection of lints to catch common mistakes and improve your [Rust](https://github.com/rust-lang/rust) code.
 
-[There are over 650 lints included in this crate!](https://rust-lang.github.io/rust-clippy/master/index.html)
+[There are over 700 lints included in this crate!](https://rust-lang.github.io/rust-clippy/master/index.html)
 
 Lints are divided into categories, each with a default [lint level](https://doc.rust-lang.org/rustc/lints/levels.html).
 You can choose how much Clippy is supposed to ~~annoy~~ help you by changing the lint level by category.
diff --git a/book/src/README.md b/book/src/README.md
index 486ea3df704..e7972b0db19 100644
--- a/book/src/README.md
+++ b/book/src/README.md
@@ -6,7 +6,7 @@
 A collection of lints to catch common mistakes and improve your
 [Rust](https://github.com/rust-lang/rust) code.
 
-[There are over 650 lints included in this crate!](https://rust-lang.github.io/rust-clippy/master/index.html)
+[There are over 700 lints included in this crate!](https://rust-lang.github.io/rust-clippy/master/index.html)
 
 Lints are divided into categories, each with a default [lint
 level](https://doc.rust-lang.org/rustc/lints/levels.html). You can choose how
diff --git a/clippy_config/src/msrvs.rs b/clippy_config/src/msrvs.rs
index 3507e106fab..0032a66365c 100644
--- a/clippy_config/src/msrvs.rs
+++ b/clippy_config/src/msrvs.rs
@@ -16,6 +16,7 @@ macro_rules! msrv_aliases {
 
 // names may refer to stabilized feature flags or library items
 msrv_aliases! {
+    1,76,0 { PTR_FROM_REF }
     1,71,0 { TUPLE_ARRAY_CONVERSIONS, BUILD_HASHER_HASH_ONE }
     1,70,0 { OPTION_RESULT_IS_VARIANT_AND, BINARY_HEAP_RETAIN }
     1,68,0 { PATH_MAIN_SEPARATOR_STR }
diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index e05b8f66d86..14f2f4a7f59 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -18,6 +18,7 @@ mod fn_to_numeric_cast_any;
 mod fn_to_numeric_cast_with_truncation;
 mod ptr_as_ptr;
 mod ptr_cast_constness;
+mod ref_as_ptr;
 mod unnecessary_cast;
 mod utils;
 mod zero_ptr;
@@ -689,6 +690,30 @@ declare_clippy_lint! {
     "using `0 as *{const, mut} T`"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for casts of references to pointer using `as`
+    /// and suggests `std::ptr::from_ref` and `std::ptr::from_mut` instead.
+    ///
+    /// ### Why is this bad?
+    /// Using `as` casts may result in silently changing mutability or type.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let a_ref = &1;
+    /// let a_ptr = a_ref as *const _;
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// let a_ref = &1;
+    /// let a_ptr = std::ptr::from_ref(a_ref);
+    /// ```
+    #[clippy::version = "1.77.0"]
+    pub REF_AS_PTR,
+    pedantic,
+    "using `as` to cast a reference to pointer"
+}
+
 pub struct Casts {
     msrv: Msrv,
 }
@@ -724,6 +749,7 @@ impl_lint_pass!(Casts => [
     AS_PTR_CAST_MUT,
     CAST_NAN_TO_INT,
     ZERO_PTR,
+    REF_AS_PTR,
 ]);
 
 impl<'tcx> LateLintPass<'tcx> for Casts {
@@ -771,7 +797,9 @@ impl<'tcx> LateLintPass<'tcx> for Casts {
 
             as_underscore::check(cx, expr, cast_to_hir);
 
-            if self.msrv.meets(msrvs::BORROW_AS_PTR) {
+            if self.msrv.meets(msrvs::PTR_FROM_REF) {
+                ref_as_ptr::check(cx, expr, cast_expr, cast_to_hir);
+            } else if self.msrv.meets(msrvs::BORROW_AS_PTR) {
                 borrow_as_ptr::check(cx, expr, cast_expr, cast_to_hir);
             }
         }
diff --git a/clippy_lints/src/casts/ref_as_ptr.rs b/clippy_lints/src/casts/ref_as_ptr.rs
new file mode 100644
index 00000000000..d600d2aec1b
--- /dev/null
+++ b/clippy_lints/src/casts/ref_as_ptr.rs
@@ -0,0 +1,55 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::is_no_std_crate;
+use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::sugg::Sugg;
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, Mutability, Ty, TyKind};
+use rustc_lint::LateContext;
+use rustc_middle::ty::{self, TypeAndMut};
+
+use super::REF_AS_PTR;
+
+pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_expr: &Expr<'_>, cast_to_hir_ty: &Ty<'_>) {
+    let (cast_from, cast_to) = (
+        cx.typeck_results().expr_ty(cast_expr),
+        cx.typeck_results().expr_ty(expr),
+    );
+
+    if matches!(cast_from.kind(), ty::Ref(..))
+        && let ty::RawPtr(TypeAndMut { mutbl: to_mutbl, .. }) = cast_to.kind()
+    {
+        let core_or_std = if is_no_std_crate(cx) { "core" } else { "std" };
+        let fn_name = match to_mutbl {
+            Mutability::Not => "from_ref",
+            Mutability::Mut => "from_mut",
+        };
+
+        let mut app = Applicability::MachineApplicable;
+        let turbofish = match &cast_to_hir_ty.kind {
+            TyKind::Infer => String::new(),
+            TyKind::Ptr(mut_ty) => {
+                if matches!(mut_ty.ty.kind, TyKind::Infer) {
+                    String::new()
+                } else {
+                    format!(
+                        "::<{}>",
+                        snippet_with_applicability(cx, mut_ty.ty.span, "/* type */", &mut app)
+                    )
+                }
+            },
+            _ => return,
+        };
+
+        let cast_expr_sugg = Sugg::hir_with_applicability(cx, cast_expr, "_", &mut app);
+
+        span_lint_and_sugg(
+            cx,
+            REF_AS_PTR,
+            expr.span,
+            "reference as raw pointer",
+            "try",
+            format!("{core_or_std}::ptr::{fn_name}{turbofish}({cast_expr_sugg})"),
+            app,
+        );
+    }
+}
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index f6c9ffea9fc..ccb7b25066d 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -96,6 +96,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::casts::FN_TO_NUMERIC_CAST_WITH_TRUNCATION_INFO,
     crate::casts::PTR_AS_PTR_INFO,
     crate::casts::PTR_CAST_CONSTNESS_INFO,
+    crate::casts::REF_AS_PTR_INFO,
     crate::casts::UNNECESSARY_CAST_INFO,
     crate::casts::ZERO_PTR_INFO,
     crate::checked_conversions::CHECKED_CONVERSIONS_INFO,
diff --git a/clippy_lints/src/only_used_in_recursion.rs b/clippy_lints/src/only_used_in_recursion.rs
index d621051ef16..ae14016f482 100644
--- a/clippy_lints/src/only_used_in_recursion.rs
+++ b/clippy_lints/src/only_used_in_recursion.rs
@@ -252,7 +252,7 @@ impl<'tcx> LateLintPass<'tcx> for OnlyUsedInRecursion {
                 {
                     (
                         trait_item_id,
-                        FnKind::ImplTraitFn(cx.tcx.erase_regions(trait_ref.args) as *const _ as usize),
+                        FnKind::ImplTraitFn(std::ptr::from_ref(cx.tcx.erase_regions(trait_ref.args)) as usize),
                         usize::from(sig.decl.implicit_self.has_implicit_self()),
                     )
                 } else {
@@ -390,7 +390,6 @@ fn has_matching_args(kind: FnKind, args: GenericArgsRef<'_>) -> bool {
             GenericArgKind::Type(ty) => matches!(*ty.kind(), ty::Param(ty) if ty.index as usize == idx),
             GenericArgKind::Const(c) => matches!(c.kind(), ConstKind::Param(c) if c.index as usize == idx),
         }),
-        #[allow(trivial_casts)]
-        FnKind::ImplTraitFn(expected_args) => args as *const _ as usize == expected_args,
+        FnKind::ImplTraitFn(expected_args) => std::ptr::from_ref(args) as usize == expected_args,
     }
 }
diff --git a/tests/ui/borrow_as_ptr.fixed b/tests/ui/borrow_as_ptr.fixed
index 6c0de96d65e..289a5ef38b8 100644
--- a/tests/ui/borrow_as_ptr.fixed
+++ b/tests/ui/borrow_as_ptr.fixed
@@ -5,6 +5,7 @@ fn a() -> i32 {
     0
 }
 
+#[clippy::msrv = "1.75"]
 fn main() {
     let val = 1;
     let _p = std::ptr::addr_of!(val);
diff --git a/tests/ui/borrow_as_ptr.rs b/tests/ui/borrow_as_ptr.rs
index c37c5357c82..b5328cb22dc 100644
--- a/tests/ui/borrow_as_ptr.rs
+++ b/tests/ui/borrow_as_ptr.rs
@@ -5,6 +5,7 @@ fn a() -> i32 {
     0
 }
 
+#[clippy::msrv = "1.75"]
 fn main() {
     let val = 1;
     let _p = &val as *const i32;
diff --git a/tests/ui/borrow_as_ptr.stderr b/tests/ui/borrow_as_ptr.stderr
index 43a7a6bf5b5..b9861805905 100644
--- a/tests/ui/borrow_as_ptr.stderr
+++ b/tests/ui/borrow_as_ptr.stderr
@@ -1,5 +1,5 @@
 error: borrow as raw pointer
-  --> $DIR/borrow_as_ptr.rs:10:14
+  --> $DIR/borrow_as_ptr.rs:11:14
    |
 LL |     let _p = &val as *const i32;
    |              ^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::addr_of!(val)`
@@ -8,7 +8,7 @@ LL |     let _p = &val as *const i32;
    = help: to override `-D warnings` add `#[allow(clippy::borrow_as_ptr)]`
 
 error: borrow as raw pointer
-  --> $DIR/borrow_as_ptr.rs:17:18
+  --> $DIR/borrow_as_ptr.rs:18:18
    |
 LL |     let _p_mut = &mut val_mut as *mut i32;
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::addr_of_mut!(val_mut)`
diff --git a/tests/ui/borrow_as_ptr_no_std.fixed b/tests/ui/borrow_as_ptr_no_std.fixed
index a361a36474d..f66554de300 100644
--- a/tests/ui/borrow_as_ptr_no_std.fixed
+++ b/tests/ui/borrow_as_ptr_no_std.fixed
@@ -2,6 +2,7 @@
 #![feature(lang_items, start, libc)]
 #![no_std]
 
+#[clippy::msrv = "1.75"]
 #[start]
 fn main(_argc: isize, _argv: *const *const u8) -> isize {
     let val = 1;
diff --git a/tests/ui/borrow_as_ptr_no_std.rs b/tests/ui/borrow_as_ptr_no_std.rs
index b3fe01442b7..1fc254aafa7 100644
--- a/tests/ui/borrow_as_ptr_no_std.rs
+++ b/tests/ui/borrow_as_ptr_no_std.rs
@@ -2,6 +2,7 @@
 #![feature(lang_items, start, libc)]
 #![no_std]
 
+#[clippy::msrv = "1.75"]
 #[start]
 fn main(_argc: isize, _argv: *const *const u8) -> isize {
     let val = 1;
diff --git a/tests/ui/borrow_as_ptr_no_std.stderr b/tests/ui/borrow_as_ptr_no_std.stderr
index 2f258bcf966..1ef0a948a32 100644
--- a/tests/ui/borrow_as_ptr_no_std.stderr
+++ b/tests/ui/borrow_as_ptr_no_std.stderr
@@ -1,5 +1,5 @@
 error: borrow as raw pointer
-  --> $DIR/borrow_as_ptr_no_std.rs:8:14
+  --> $DIR/borrow_as_ptr_no_std.rs:9:14
    |
 LL |     let _p = &val as *const i32;
    |              ^^^^^^^^^^^^^^^^^^ help: try: `core::ptr::addr_of!(val)`
@@ -8,7 +8,7 @@ LL |     let _p = &val as *const i32;
    = help: to override `-D warnings` add `#[allow(clippy::borrow_as_ptr)]`
 
 error: borrow as raw pointer
-  --> $DIR/borrow_as_ptr_no_std.rs:11:18
+  --> $DIR/borrow_as_ptr_no_std.rs:12:18
    |
 LL |     let _p_mut = &mut val_mut as *mut i32;
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `core::ptr::addr_of_mut!(val_mut)`
diff --git a/tests/ui/ref_as_ptr.fixed b/tests/ui/ref_as_ptr.fixed
new file mode 100644
index 00000000000..7a946393f25
--- /dev/null
+++ b/tests/ui/ref_as_ptr.fixed
@@ -0,0 +1,110 @@
+#![warn(clippy::ref_as_ptr)]
+#![allow(clippy::unnecessary_mut_passed)]
+
+fn main() {
+    let _ = std::ptr::from_ref(&1u8);
+    let _ = std::ptr::from_ref::<u32>(&2u32);
+    let _ = std::ptr::from_ref::<f64>(&3.0f64);
+
+    let _ = std::ptr::from_ref(&4) as *const f32;
+    let _ = std::ptr::from_ref::<f32>(&5.0f32) as *const u32;
+
+    let _ = std::ptr::from_ref(&mut 6u8);
+    let _ = std::ptr::from_ref::<u32>(&mut 7u32);
+    let _ = std::ptr::from_ref::<f64>(&mut 8.0f64);
+
+    let _ = std::ptr::from_ref(&mut 9) as *const f32;
+    let _ = std::ptr::from_ref::<f32>(&mut 10.0f32) as *const u32;
+
+    let _ = std::ptr::from_mut(&mut 11u8);
+    let _ = std::ptr::from_mut::<u32>(&mut 12u32);
+    let _ = std::ptr::from_mut::<f64>(&mut 13.0f64);
+
+    let _ = std::ptr::from_mut(&mut 14) as *const f32;
+    let _ = std::ptr::from_mut::<f32>(&mut 15.0f32) as *const u32;
+
+    let _ = std::ptr::from_ref(&1u8);
+    let _ = std::ptr::from_ref::<u32>(&2u32);
+    let _ = std::ptr::from_ref::<f64>(&3.0f64);
+
+    let _ = std::ptr::from_ref(&4) as *const f32;
+    let _ = std::ptr::from_ref::<f32>(&5.0f32) as *const u32;
+
+    let val = 1;
+    let _ = std::ptr::from_ref(&val);
+    let _ = std::ptr::from_ref::<i32>(&val);
+
+    let _ = std::ptr::from_ref(&val) as *const f32;
+    let _ = std::ptr::from_ref::<i32>(&val) as *const f64;
+
+    let mut val: u8 = 2;
+    let _ = std::ptr::from_mut::<u8>(&mut val);
+    let _ = std::ptr::from_mut(&mut val);
+
+    let _ = std::ptr::from_ref::<u8>(&mut val);
+    let _ = std::ptr::from_ref(&mut val);
+
+    let _ = std::ptr::from_ref::<u8>(&mut val) as *const f64;
+    let _: *const Option<u8> = std::ptr::from_ref(&mut val) as *const _;
+
+    let _ = std::ptr::from_ref::<[usize; 7]>(&std::array::from_fn(|i| i * i));
+    let _ = std::ptr::from_ref::<[usize; 8]>(&mut std::array::from_fn(|i| i * i));
+    let _ = std::ptr::from_mut::<[usize; 9]>(&mut std::array::from_fn(|i| i * i));
+}
+
+#[clippy::msrv = "1.75"]
+fn _msrv_1_75() {
+    let val = &42_i32;
+    let mut_val = &mut 42_i32;
+
+    // `std::ptr::from_{ref, mut}` was stabilized in 1.76. Do not lint this
+    let _ = val as *const i32;
+    let _ = mut_val as *mut i32;
+}
+
+#[clippy::msrv = "1.76"]
+fn _msrv_1_76() {
+    let val = &42_i32;
+    let mut_val = &mut 42_i32;
+
+    let _ = std::ptr::from_ref::<i32>(val);
+    let _ = std::ptr::from_mut::<i32>(mut_val);
+}
+
+fn foo(val: &[u8]) {
+    let _ = std::ptr::from_ref(val);
+    let _ = std::ptr::from_ref::<[u8]>(val);
+}
+
+fn bar(val: &mut str) {
+    let _ = std::ptr::from_mut(val);
+    let _ = std::ptr::from_mut::<str>(val);
+}
+
+struct X<'a>(&'a i32);
+
+impl<'a> X<'a> {
+    fn foo(&self) -> *const i64 {
+        std::ptr::from_ref(self.0) as *const _
+    }
+
+    fn bar(&mut self) -> *const i64 {
+        std::ptr::from_ref(self.0) as *const _
+    }
+}
+
+struct Y<'a>(&'a mut i32);
+
+impl<'a> Y<'a> {
+    fn foo(&self) -> *const i64 {
+        std::ptr::from_ref(self.0) as *const _
+    }
+
+    fn bar(&mut self) -> *const i64 {
+        std::ptr::from_ref(self.0) as *const _
+    }
+
+    fn baz(&mut self) -> *const i64 {
+        std::ptr::from_mut(self.0) as *mut _
+    }
+}
diff --git a/tests/ui/ref_as_ptr.rs b/tests/ui/ref_as_ptr.rs
new file mode 100644
index 00000000000..6f745505b46
--- /dev/null
+++ b/tests/ui/ref_as_ptr.rs
@@ -0,0 +1,110 @@
+#![warn(clippy::ref_as_ptr)]
+#![allow(clippy::unnecessary_mut_passed)]
+
+fn main() {
+    let _ = &1u8 as *const _;
+    let _ = &2u32 as *const u32;
+    let _ = &3.0f64 as *const f64;
+
+    let _ = &4 as *const _ as *const f32;
+    let _ = &5.0f32 as *const f32 as *const u32;
+
+    let _ = &mut 6u8 as *const _;
+    let _ = &mut 7u32 as *const u32;
+    let _ = &mut 8.0f64 as *const f64;
+
+    let _ = &mut 9 as *const _ as *const f32;
+    let _ = &mut 10.0f32 as *const f32 as *const u32;
+
+    let _ = &mut 11u8 as *mut _;
+    let _ = &mut 12u32 as *mut u32;
+    let _ = &mut 13.0f64 as *mut f64;
+
+    let _ = &mut 14 as *mut _ as *const f32;
+    let _ = &mut 15.0f32 as *mut f32 as *const u32;
+
+    let _ = &1u8 as *const _;
+    let _ = &2u32 as *const u32;
+    let _ = &3.0f64 as *const f64;
+
+    let _ = &4 as *const _ as *const f32;
+    let _ = &5.0f32 as *const f32 as *const u32;
+
+    let val = 1;
+    let _ = &val as *const _;
+    let _ = &val as *const i32;
+
+    let _ = &val as *const _ as *const f32;
+    let _ = &val as *const i32 as *const f64;
+
+    let mut val: u8 = 2;
+    let _ = &mut val as *mut u8;
+    let _ = &mut val as *mut _;
+
+    let _ = &mut val as *const u8;
+    let _ = &mut val as *const _;
+
+    let _ = &mut val as *const u8 as *const f64;
+    let _: *const Option<u8> = &mut val as *const _ as *const _;
+
+    let _ = &std::array::from_fn(|i| i * i) as *const [usize; 7];
+    let _ = &mut std::array::from_fn(|i| i * i) as *const [usize; 8];
+    let _ = &mut std::array::from_fn(|i| i * i) as *mut [usize; 9];
+}
+
+#[clippy::msrv = "1.75"]
+fn _msrv_1_75() {
+    let val = &42_i32;
+    let mut_val = &mut 42_i32;
+
+    // `std::ptr::from_{ref, mut}` was stabilized in 1.76. Do not lint this
+    let _ = val as *const i32;
+    let _ = mut_val as *mut i32;
+}
+
+#[clippy::msrv = "1.76"]
+fn _msrv_1_76() {
+    let val = &42_i32;
+    let mut_val = &mut 42_i32;
+
+    let _ = val as *const i32;
+    let _ = mut_val as *mut i32;
+}
+
+fn foo(val: &[u8]) {
+    let _ = val as *const _;
+    let _ = val as *const [u8];
+}
+
+fn bar(val: &mut str) {
+    let _ = val as *mut _;
+    let _ = val as *mut str;
+}
+
+struct X<'a>(&'a i32);
+
+impl<'a> X<'a> {
+    fn foo(&self) -> *const i64 {
+        self.0 as *const _ as *const _
+    }
+
+    fn bar(&mut self) -> *const i64 {
+        self.0 as *const _ as *const _
+    }
+}
+
+struct Y<'a>(&'a mut i32);
+
+impl<'a> Y<'a> {
+    fn foo(&self) -> *const i64 {
+        self.0 as *const _ as *const _
+    }
+
+    fn bar(&mut self) -> *const i64 {
+        self.0 as *const _ as *const _
+    }
+
+    fn baz(&mut self) -> *const i64 {
+        self.0 as *mut _ as *mut _
+    }
+}
diff --git a/tests/ui/ref_as_ptr.stderr b/tests/ui/ref_as_ptr.stderr
new file mode 100644
index 00000000000..371d42df528
--- /dev/null
+++ b/tests/ui/ref_as_ptr.stderr
@@ -0,0 +1,269 @@
+error: reference as raw pointer
+  --> $DIR/ref_as_ptr.rs:5:13
+   |
+LL |     let _ = &1u8 as *const _;
+   |             ^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_ref(&1u8)`
+   |
+   = note: `-D clippy::ref-as-ptr` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::ref_as_ptr)]`
+
+error: reference as raw pointer
+  --> $DIR/ref_as_ptr.rs:6:13
+   |
+LL |     let _ = &2u32 as *const u32;
+   |             ^^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_ref::<u32>(&2u32)`
+
+error: reference as raw pointer
+  --> $DIR/ref_as_ptr.rs:7:13
+   |
+LL |     let _ = &3.0f64 as *const f64;
+   |             ^^^^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_ref::<f64>(&3.0f64)`
+
+error: reference as raw pointer
+  --> $DIR/ref_as_ptr.rs:9:13
+   |
+LL |     let _ = &4 as *const _ as *const f32;
+   |             ^^^^^^^^^^^^^^ help: try: `std::ptr::from_ref(&4)`
+
+error: reference as raw pointer
+  --> $DIR/ref_as_ptr.rs:10:13
+   |
+LL |     let _ = &5.0f32 as *const f32 as *const u32;
+   |             ^^^^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_ref::<f32>(&5.0f32)`
+
+error: reference as raw pointer
+  --> $DIR/ref_as_ptr.rs:12:13
+   |
+LL |     let _ = &mut 6u8 as *const _;
+   |             ^^^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_ref(&mut 6u8)`
+
+error: reference as raw pointer
+  --> $DIR/ref_as_ptr.rs:13:13
+   |
+LL |     let _ = &mut 7u32 as *const u32;
+   |             ^^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_ref::<u32>(&mut 7u32)`
+
+error: reference as raw pointer
+  --> $DIR/ref_as_ptr.rs:14:13
+   |
+LL |     let _ = &mut 8.0f64 as *const f64;
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_ref::<f64>(&mut 8.0f64)`
+
+error: reference as raw pointer
+  --> $DIR/ref_as_ptr.rs:16:13
+   |
+LL |     let _ = &mut 9 as *const _ as *const f32;
+   |             ^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_ref(&mut 9)`
+
+error: reference as raw pointer
+  --> $DIR/ref_as_ptr.rs:17:13
+   |
+LL |     let _ = &mut 10.0f32 as *const f32 as *const u32;
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_ref::<f32>(&mut 10.0f32)`
+
+error: reference as raw pointer
+  --> $DIR/ref_as_ptr.rs:19:13
+   |
+LL |     let _ = &mut 11u8 as *mut _;
+   |             ^^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_mut(&mut 11u8)`
+
+error: reference as raw pointer
+  --> $DIR/ref_as_ptr.rs:20:13
+   |
+LL |     let _ = &mut 12u32 as *mut u32;
+   |             ^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_mut::<u32>(&mut 12u32)`
+
+error: reference as raw pointer
+  --> $DIR/ref_as_ptr.rs:21:13
+   |
+LL |     let _ = &mut 13.0f64 as *mut f64;
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_mut::<f64>(&mut 13.0f64)`
+
+error: reference as raw pointer
+  --> $DIR/ref_as_ptr.rs:23:13
+   |
+LL |     let _ = &mut 14 as *mut _ as *const f32;
+   |             ^^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_mut(&mut 14)`
+
+error: reference as raw pointer
+  --> $DIR/ref_as_ptr.rs:24:13
+   |
+LL |     let _ = &mut 15.0f32 as *mut f32 as *const u32;
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_mut::<f32>(&mut 15.0f32)`
+
+error: reference as raw pointer
+  --> $DIR/ref_as_ptr.rs:26:13
+   |
+LL |     let _ = &1u8 as *const _;
+   |             ^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_ref(&1u8)`
+
+error: reference as raw pointer
+  --> $DIR/ref_as_ptr.rs:27:13
+   |
+LL |     let _ = &2u32 as *const u32;
+   |             ^^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_ref::<u32>(&2u32)`
+
+error: reference as raw pointer
+  --> $DIR/ref_as_ptr.rs:28:13
+   |
+LL |     let _ = &3.0f64 as *const f64;
+   |             ^^^^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_ref::<f64>(&3.0f64)`
+
+error: reference as raw pointer
+  --> $DIR/ref_as_ptr.rs:30:13
+   |
+LL |     let _ = &4 as *const _ as *const f32;
+   |             ^^^^^^^^^^^^^^ help: try: `std::ptr::from_ref(&4)`
+
+error: reference as raw pointer
+  --> $DIR/ref_as_ptr.rs:31:13
+   |
+LL |     let _ = &5.0f32 as *const f32 as *const u32;
+   |             ^^^^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_ref::<f32>(&5.0f32)`
+
+error: reference as raw pointer
+  --> $DIR/ref_as_ptr.rs:34:13
+   |
+LL |     let _ = &val as *const _;
+   |             ^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_ref(&val)`
+
+error: reference as raw pointer
+  --> $DIR/ref_as_ptr.rs:35:13
+   |
+LL |     let _ = &val as *const i32;
+   |             ^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_ref::<i32>(&val)`
+
+error: reference as raw pointer
+  --> $DIR/ref_as_ptr.rs:37:13
+   |
+LL |     let _ = &val as *const _ as *const f32;
+   |             ^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_ref(&val)`
+
+error: reference as raw pointer
+  --> $DIR/ref_as_ptr.rs:38:13
+   |
+LL |     let _ = &val as *const i32 as *const f64;
+   |             ^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_ref::<i32>(&val)`
+
+error: reference as raw pointer
+  --> $DIR/ref_as_ptr.rs:41:13
+   |
+LL |     let _ = &mut val as *mut u8;
+   |             ^^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_mut::<u8>(&mut val)`
+
+error: reference as raw pointer
+  --> $DIR/ref_as_ptr.rs:42:13
+   |
+LL |     let _ = &mut val as *mut _;
+   |             ^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_mut(&mut val)`
+
+error: reference as raw pointer
+  --> $DIR/ref_as_ptr.rs:44:13
+   |
+LL |     let _ = &mut val as *const u8;
+   |             ^^^^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_ref::<u8>(&mut val)`
+
+error: reference as raw pointer
+  --> $DIR/ref_as_ptr.rs:45:13
+   |
+LL |     let _ = &mut val as *const _;
+   |             ^^^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_ref(&mut val)`
+
+error: reference as raw pointer
+  --> $DIR/ref_as_ptr.rs:47:13
+   |
+LL |     let _ = &mut val as *const u8 as *const f64;
+   |             ^^^^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_ref::<u8>(&mut val)`
+
+error: reference as raw pointer
+  --> $DIR/ref_as_ptr.rs:48:32
+   |
+LL |     let _: *const Option<u8> = &mut val as *const _ as *const _;
+   |                                ^^^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_ref(&mut val)`
+
+error: reference as raw pointer
+  --> $DIR/ref_as_ptr.rs:50:13
+   |
+LL |     let _ = &std::array::from_fn(|i| i * i) as *const [usize; 7];
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_ref::<[usize; 7]>(&std::array::from_fn(|i| i * i))`
+
+error: reference as raw pointer
+  --> $DIR/ref_as_ptr.rs:51:13
+   |
+LL |     let _ = &mut std::array::from_fn(|i| i * i) as *const [usize; 8];
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_ref::<[usize; 8]>(&mut std::array::from_fn(|i| i * i))`
+
+error: reference as raw pointer
+  --> $DIR/ref_as_ptr.rs:52:13
+   |
+LL |     let _ = &mut std::array::from_fn(|i| i * i) as *mut [usize; 9];
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_mut::<[usize; 9]>(&mut std::array::from_fn(|i| i * i))`
+
+error: reference as raw pointer
+  --> $DIR/ref_as_ptr.rs:70:13
+   |
+LL |     let _ = val as *const i32;
+   |             ^^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_ref::<i32>(val)`
+
+error: reference as raw pointer
+  --> $DIR/ref_as_ptr.rs:71:13
+   |
+LL |     let _ = mut_val as *mut i32;
+   |             ^^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_mut::<i32>(mut_val)`
+
+error: reference as raw pointer
+  --> $DIR/ref_as_ptr.rs:75:13
+   |
+LL |     let _ = val as *const _;
+   |             ^^^^^^^^^^^^^^^ help: try: `std::ptr::from_ref(val)`
+
+error: reference as raw pointer
+  --> $DIR/ref_as_ptr.rs:76:13
+   |
+LL |     let _ = val as *const [u8];
+   |             ^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_ref::<[u8]>(val)`
+
+error: reference as raw pointer
+  --> $DIR/ref_as_ptr.rs:80:13
+   |
+LL |     let _ = val as *mut _;
+   |             ^^^^^^^^^^^^^ help: try: `std::ptr::from_mut(val)`
+
+error: reference as raw pointer
+  --> $DIR/ref_as_ptr.rs:81:13
+   |
+LL |     let _ = val as *mut str;
+   |             ^^^^^^^^^^^^^^^ help: try: `std::ptr::from_mut::<str>(val)`
+
+error: reference as raw pointer
+  --> $DIR/ref_as_ptr.rs:88:9
+   |
+LL |         self.0 as *const _ as *const _
+   |         ^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_ref(self.0)`
+
+error: reference as raw pointer
+  --> $DIR/ref_as_ptr.rs:92:9
+   |
+LL |         self.0 as *const _ as *const _
+   |         ^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_ref(self.0)`
+
+error: reference as raw pointer
+  --> $DIR/ref_as_ptr.rs:100:9
+   |
+LL |         self.0 as *const _ as *const _
+   |         ^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_ref(self.0)`
+
+error: reference as raw pointer
+  --> $DIR/ref_as_ptr.rs:104:9
+   |
+LL |         self.0 as *const _ as *const _
+   |         ^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_ref(self.0)`
+
+error: reference as raw pointer
+  --> $DIR/ref_as_ptr.rs:108:9
+   |
+LL |         self.0 as *mut _ as *mut _
+   |         ^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_mut(self.0)`
+
+error: aborting due to 44 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 7c3908f86c61547e1a15873c156be5be8c012a06 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Sun, 4 Feb 2024 20:12:15 +0100
Subject: [`redundant_locals`]: take by-value closure captures into account

---
 clippy_lints/src/redundant_locals.rs | 30 ++++++++++++++++++-
 tests/ui/redundant_locals.rs         | 36 +++++++++++++++++++++++
 tests/ui/redundant_locals.stderr     | 56 ++++++++++++++++++------------------
 3 files changed, 93 insertions(+), 29 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/redundant_locals.rs b/clippy_lints/src/redundant_locals.rs
index 2c511ee0bc0..b0040bfa582 100644
--- a/clippy_lints/src/redundant_locals.rs
+++ b/clippy_lints/src/redundant_locals.rs
@@ -2,10 +2,12 @@ use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::is_from_proc_macro;
 use clippy_utils::ty::needs_ordered_drop;
 use rustc_ast::Mutability;
-use rustc_hir::def::Res;
+use rustc_hir::def::{DefKind, Res};
 use rustc_hir::{BindingAnnotation, ByRef, ExprKind, HirId, Local, Node, Pat, PatKind, QPath};
+use rustc_hir_typeck::expr_use_visitor::PlaceBase;
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
+use rustc_middle::ty::UpvarCapture;
 use rustc_session::declare_lint_pass;
 use rustc_span::symbol::Ident;
 use rustc_span::DesugaringKind;
@@ -69,6 +71,7 @@ impl<'tcx> LateLintPass<'tcx> for RedundantLocals {
             // the local is user-controlled
             && !in_external_macro(cx.sess(), local.span)
             && !is_from_proc_macro(cx, expr)
+            && !is_closure_capture(cx, local.hir_id, binding_id)
         {
             span_lint_and_help(
                 cx,
@@ -82,6 +85,31 @@ impl<'tcx> LateLintPass<'tcx> for RedundantLocals {
     }
 }
 
+/// Checks if the enclosing body is a closure and if the given local is captured by value.
+///
+/// In those cases, the redefinition may be necessary to force a move:
+/// ```
+/// fn assert_static<T: 'static>(_: T) {}
+///
+/// let v = String::new();
+/// let closure = || {
+///   let v = v; // <- removing this redefinition makes `closure` no longer `'static`
+///   dbg!(&v);
+/// };
+/// assert_static(closure);
+/// ```
+fn is_closure_capture(cx: &LateContext<'_>, redefinition: HirId, root_variable: HirId) -> bool {
+    let body = cx.tcx.hir().enclosing_body_owner(redefinition);
+    if let DefKind::Closure = cx.tcx.def_kind(body) {
+        cx.tcx.closure_captures(body).iter().any(|c| {
+            matches!(c.info.capture_kind, UpvarCapture::ByValue)
+                && matches!(c.place.base, PlaceBase::Upvar(upvar) if upvar.var_path.hir_id == root_variable)
+        })
+    } else {
+        false
+    }
+}
+
 /// Find the annotation of a binding introduced by a pattern, or `None` if it's not introduced.
 fn find_binding(pat: &Pat<'_>, name: Ident) -> Option<BindingAnnotation> {
     let mut ret = None;
diff --git a/tests/ui/redundant_locals.rs b/tests/ui/redundant_locals.rs
index 182d067a5e9..40bd89bc595 100644
--- a/tests/ui/redundant_locals.rs
+++ b/tests/ui/redundant_locals.rs
@@ -1,6 +1,7 @@
 //@aux-build:proc_macros.rs
 #![allow(unused, clippy::no_effect, clippy::needless_pass_by_ref_mut)]
 #![warn(clippy::redundant_locals)]
+#![feature(async_closure)]
 
 extern crate proc_macros;
 use proc_macros::{external, with_span};
@@ -163,3 +164,38 @@ fn drop_compose() {
     let b = ComposeDrop { d: WithDrop(1) };
     let a = a;
 }
+
+fn issue12225() {
+    fn assert_static<T: 'static>(_: T) {}
+
+    let v1 = String::new();
+    let v2 = String::new();
+    let v3 = String::new();
+    let v4 = String::new();
+
+    assert_static(|| {
+        let v1 = v1;
+        dbg!(&v1);
+    });
+    assert_static(async {
+        let v2 = v2;
+        dbg!(&v2);
+    });
+    assert_static(|| async {
+        let v3 = v3;
+        dbg!(&v3);
+    });
+    assert_static(async || {
+        let v4 = v4;
+        dbg!(&v4);
+    });
+
+    fn foo(a: &str, b: &str) {}
+
+    let do_not_move = String::new();
+    let things_to_move = vec!["a".to_string(), "b".to_string()];
+    let futures = things_to_move.into_iter().map(|move_me| async {
+        let move_me = move_me;
+        foo(&do_not_move, &move_me)
+    });
+}
diff --git a/tests/ui/redundant_locals.stderr b/tests/ui/redundant_locals.stderr
index 30ab4aa2ea9..610d587ddad 100644
--- a/tests/ui/redundant_locals.stderr
+++ b/tests/ui/redundant_locals.stderr
@@ -1,11 +1,11 @@
 error: redundant redefinition of a binding `x`
-  --> $DIR/redundant_locals.rs:12:5
+  --> $DIR/redundant_locals.rs:13:5
    |
 LL |     let x = x;
    |     ^^^^^^^^^^
    |
 help: `x` is initially defined here
-  --> $DIR/redundant_locals.rs:11:9
+  --> $DIR/redundant_locals.rs:12:9
    |
 LL |     let x = 1;
    |         ^
@@ -13,157 +13,157 @@ LL |     let x = 1;
    = help: to override `-D warnings` add `#[allow(clippy::redundant_locals)]`
 
 error: redundant redefinition of a binding `x`
-  --> $DIR/redundant_locals.rs:17:5
+  --> $DIR/redundant_locals.rs:18:5
    |
 LL |     let mut x = x;
    |     ^^^^^^^^^^^^^^
    |
 help: `x` is initially defined here
-  --> $DIR/redundant_locals.rs:16:9
+  --> $DIR/redundant_locals.rs:17:9
    |
 LL |     let mut x = 1;
    |         ^^^^^
 
 error: redundant redefinition of a binding `x`
-  --> $DIR/redundant_locals.rs:47:5
+  --> $DIR/redundant_locals.rs:48:5
    |
 LL |     let x = x;
    |     ^^^^^^^^^^
    |
 help: `x` is initially defined here
-  --> $DIR/redundant_locals.rs:46:14
+  --> $DIR/redundant_locals.rs:47:14
    |
 LL | fn parameter(x: i32) {
    |              ^
 
 error: redundant redefinition of a binding `x`
-  --> $DIR/redundant_locals.rs:52:5
+  --> $DIR/redundant_locals.rs:53:5
    |
 LL |     let x = x;
    |     ^^^^^^^^^^
    |
 help: `x` is initially defined here
-  --> $DIR/redundant_locals.rs:51:9
+  --> $DIR/redundant_locals.rs:52:9
    |
 LL |     let x = 1;
    |         ^
 
 error: redundant redefinition of a binding `x`
-  --> $DIR/redundant_locals.rs:53:5
+  --> $DIR/redundant_locals.rs:54:5
    |
 LL |     let x = x;
    |     ^^^^^^^^^^
    |
 help: `x` is initially defined here
-  --> $DIR/redundant_locals.rs:52:9
+  --> $DIR/redundant_locals.rs:53:9
    |
 LL |     let x = x;
    |         ^
 
 error: redundant redefinition of a binding `x`
-  --> $DIR/redundant_locals.rs:54:5
+  --> $DIR/redundant_locals.rs:55:5
    |
 LL |     let x = x;
    |     ^^^^^^^^^^
    |
 help: `x` is initially defined here
-  --> $DIR/redundant_locals.rs:53:9
+  --> $DIR/redundant_locals.rs:54:9
    |
 LL |     let x = x;
    |         ^
 
 error: redundant redefinition of a binding `x`
-  --> $DIR/redundant_locals.rs:55:5
+  --> $DIR/redundant_locals.rs:56:5
    |
 LL |     let x = x;
    |     ^^^^^^^^^^
    |
 help: `x` is initially defined here
-  --> $DIR/redundant_locals.rs:54:9
+  --> $DIR/redundant_locals.rs:55:9
    |
 LL |     let x = x;
    |         ^
 
 error: redundant redefinition of a binding `a`
-  --> $DIR/redundant_locals.rs:61:5
+  --> $DIR/redundant_locals.rs:62:5
    |
 LL |     let a = a;
    |     ^^^^^^^^^^
    |
 help: `a` is initially defined here
-  --> $DIR/redundant_locals.rs:59:9
+  --> $DIR/redundant_locals.rs:60:9
    |
 LL |     let a = 1;
    |         ^
 
 error: redundant redefinition of a binding `b`
-  --> $DIR/redundant_locals.rs:62:5
+  --> $DIR/redundant_locals.rs:63:5
    |
 LL |     let b = b;
    |     ^^^^^^^^^^
    |
 help: `b` is initially defined here
-  --> $DIR/redundant_locals.rs:60:9
+  --> $DIR/redundant_locals.rs:61:9
    |
 LL |     let b = 2;
    |         ^
 
 error: redundant redefinition of a binding `x`
-  --> $DIR/redundant_locals.rs:68:9
+  --> $DIR/redundant_locals.rs:69:9
    |
 LL |         let x = x;
    |         ^^^^^^^^^^
    |
 help: `x` is initially defined here
-  --> $DIR/redundant_locals.rs:67:13
+  --> $DIR/redundant_locals.rs:68:13
    |
 LL |         let x = 1;
    |             ^
 
 error: redundant redefinition of a binding `x`
-  --> $DIR/redundant_locals.rs:75:9
+  --> $DIR/redundant_locals.rs:76:9
    |
 LL |         let x = x;
    |         ^^^^^^^^^^
    |
 help: `x` is initially defined here
-  --> $DIR/redundant_locals.rs:74:13
+  --> $DIR/redundant_locals.rs:75:13
    |
 LL |         let x = 1;
    |             ^
 
 error: redundant redefinition of a binding `x`
-  --> $DIR/redundant_locals.rs:78:9
+  --> $DIR/redundant_locals.rs:79:9
    |
 LL |         let x = x;
    |         ^^^^^^^^^^
    |
 help: `x` is initially defined here
-  --> $DIR/redundant_locals.rs:77:6
+  --> $DIR/redundant_locals.rs:78:6
    |
 LL |     |x: i32| {
    |      ^
 
 error: redundant redefinition of a binding `x`
-  --> $DIR/redundant_locals.rs:97:9
+  --> $DIR/redundant_locals.rs:98:9
    |
 LL |         let x = x;
    |         ^^^^^^^^^^
    |
 help: `x` is initially defined here
-  --> $DIR/redundant_locals.rs:94:9
+  --> $DIR/redundant_locals.rs:95:9
    |
 LL |     let x = 1;
    |         ^
 
 error: redundant redefinition of a binding `a`
-  --> $DIR/redundant_locals.rs:152:5
+  --> $DIR/redundant_locals.rs:153:5
    |
 LL |     let a = a;
    |     ^^^^^^^^^^
    |
 help: `a` is initially defined here
-  --> $DIR/redundant_locals.rs:150:9
+  --> $DIR/redundant_locals.rs:151:9
    |
 LL |     let a = WithoutDrop(1);
    |         ^
-- 
cgit 1.4.1-3-g733a5


From 6807977153d9af737bac95693ccc211206538ec7 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Mon, 5 Feb 2024 15:41:59 +0100
Subject: also check for coroutines

---
 clippy_lints/src/redundant_locals.rs | 16 +++++++---------
 tests/ui/redundant_locals.rs         | 12 +++++++++++-
 2 files changed, 18 insertions(+), 10 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/redundant_locals.rs b/clippy_lints/src/redundant_locals.rs
index b0040bfa582..700a5dd4a85 100644
--- a/clippy_lints/src/redundant_locals.rs
+++ b/clippy_lints/src/redundant_locals.rs
@@ -2,7 +2,7 @@ use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::is_from_proc_macro;
 use clippy_utils::ty::needs_ordered_drop;
 use rustc_ast::Mutability;
-use rustc_hir::def::{DefKind, Res};
+use rustc_hir::def::Res;
 use rustc_hir::{BindingAnnotation, ByRef, ExprKind, HirId, Local, Node, Pat, PatKind, QPath};
 use rustc_hir_typeck::expr_use_visitor::PlaceBase;
 use rustc_lint::{LateContext, LateLintPass, LintContext};
@@ -71,7 +71,7 @@ impl<'tcx> LateLintPass<'tcx> for RedundantLocals {
             // the local is user-controlled
             && !in_external_macro(cx.sess(), local.span)
             && !is_from_proc_macro(cx, expr)
-            && !is_closure_capture(cx, local.hir_id, binding_id)
+            && !is_by_value_closure_capture(cx, local.hir_id, binding_id)
         {
             span_lint_and_help(
                 cx,
@@ -98,16 +98,14 @@ impl<'tcx> LateLintPass<'tcx> for RedundantLocals {
 /// };
 /// assert_static(closure);
 /// ```
-fn is_closure_capture(cx: &LateContext<'_>, redefinition: HirId, root_variable: HirId) -> bool {
-    let body = cx.tcx.hir().enclosing_body_owner(redefinition);
-    if let DefKind::Closure = cx.tcx.def_kind(body) {
-        cx.tcx.closure_captures(body).iter().any(|c| {
+fn is_by_value_closure_capture(cx: &LateContext<'_>, redefinition: HirId, root_variable: HirId) -> bool {
+    let closure_def_id = cx.tcx.hir().enclosing_body_owner(redefinition);
+
+    cx.tcx.is_closure_or_coroutine(closure_def_id.to_def_id())
+        && cx.tcx.closure_captures(closure_def_id).iter().any(|c| {
             matches!(c.info.capture_kind, UpvarCapture::ByValue)
                 && matches!(c.place.base, PlaceBase::Upvar(upvar) if upvar.var_path.hir_id == root_variable)
         })
-    } else {
-        false
-    }
 }
 
 /// Find the annotation of a binding introduced by a pattern, or `None` if it's not introduced.
diff --git a/tests/ui/redundant_locals.rs b/tests/ui/redundant_locals.rs
index 40bd89bc595..f6909828aa9 100644
--- a/tests/ui/redundant_locals.rs
+++ b/tests/ui/redundant_locals.rs
@@ -1,7 +1,7 @@
 //@aux-build:proc_macros.rs
 #![allow(unused, clippy::no_effect, clippy::needless_pass_by_ref_mut)]
 #![warn(clippy::redundant_locals)]
-#![feature(async_closure)]
+#![feature(async_closure, coroutines)]
 
 extern crate proc_macros;
 use proc_macros::{external, with_span};
@@ -172,6 +172,8 @@ fn issue12225() {
     let v2 = String::new();
     let v3 = String::new();
     let v4 = String::new();
+    let v5 = String::new();
+    let v6 = String::new();
 
     assert_static(|| {
         let v1 = v1;
@@ -189,6 +191,14 @@ fn issue12225() {
         let v4 = v4;
         dbg!(&v4);
     });
+    assert_static(static || {
+        let v5 = v5;
+        yield;
+    });
+    assert_static(|| {
+        let v6 = v6;
+        yield;
+    });
 
     fn foo(a: &str, b: &str) {}
 
-- 
cgit 1.4.1-3-g733a5


From 7f80b449f570613aea32f30f64ec5bb3189e1d26 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Sun, 3 Dec 2023 23:41:01 +0100
Subject: new lint: `manual_c_str_literals`

---
 CHANGELOG.md                                      |   1 +
 book/src/lint_configuration.md                    |   1 +
 clippy_config/src/conf.rs                         |   2 +-
 clippy_config/src/msrvs.rs                        |   1 +
 clippy_lints/src/declared_lints.rs                |   1 +
 clippy_lints/src/methods/manual_c_str_literals.rs | 197 ++++++++++++++++++++++
 clippy_lints/src/methods/mod.rs                   |  37 ++++
 tests/ui/manual_c_str_literals.fixed              |  60 +++++++
 tests/ui/manual_c_str_literals.rs                 |  60 +++++++
 tests/ui/manual_c_str_literals.stderr             |  83 +++++++++
 tests/ui/strlen_on_c_strings.fixed                |   2 +-
 tests/ui/strlen_on_c_strings.rs                   |   2 +-
 12 files changed, 444 insertions(+), 3 deletions(-)
 create mode 100644 clippy_lints/src/methods/manual_c_str_literals.rs
 create mode 100644 tests/ui/manual_c_str_literals.fixed
 create mode 100644 tests/ui/manual_c_str_literals.rs
 create mode 100644 tests/ui/manual_c_str_literals.stderr

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 6b68c659ea7..e88f6df853a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5340,6 +5340,7 @@ Released 2018-09-13
 [`manual_assert`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_assert
 [`manual_async_fn`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_async_fn
 [`manual_bits`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_bits
+[`manual_c_str_literals`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_c_str_literals
 [`manual_clamp`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_clamp
 [`manual_filter`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_filter
 [`manual_filter_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_filter_map
diff --git a/book/src/lint_configuration.md b/book/src/lint_configuration.md
index 669cdb0735d..f2357e2b5de 100644
--- a/book/src/lint_configuration.md
+++ b/book/src/lint_configuration.md
@@ -151,6 +151,7 @@ The minimum rust version that the project supports. Defaults to the `rust-versio
 * [`manual_try_fold`](https://rust-lang.github.io/rust-clippy/master/index.html#manual_try_fold)
 * [`manual_hash_one`](https://rust-lang.github.io/rust-clippy/master/index.html#manual_hash_one)
 * [`iter_kv_map`](https://rust-lang.github.io/rust-clippy/master/index.html#iter_kv_map)
+* [`manual_c_str_literals`](https://rust-lang.github.io/rust-clippy/master/index.html#manual_c_str_literals)
 
 
 ## `cognitive-complexity-threshold`
diff --git a/clippy_config/src/conf.rs b/clippy_config/src/conf.rs
index a7a81b6f421..9741b94d504 100644
--- a/clippy_config/src/conf.rs
+++ b/clippy_config/src/conf.rs
@@ -260,7 +260,7 @@ define_Conf! {
     ///
     /// Suppress lints whenever the suggested change would cause breakage for other crates.
     (avoid_breaking_exported_api: bool = true),
-    /// Lint: MANUAL_SPLIT_ONCE, MANUAL_STR_REPEAT, CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, OPTION_MAP_UNWRAP_OR, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR, IF_THEN_SOME_ELSE_NONE, APPROX_CONSTANT, DEPRECATED_CFG_ATTR, INDEX_REFUTABLE_SLICE, MAP_CLONE, BORROW_AS_PTR, MANUAL_BITS, ERR_EXPECT, CAST_ABS_TO_UNSIGNED, UNINLINED_FORMAT_ARGS, MANUAL_CLAMP, MANUAL_LET_ELSE, UNCHECKED_DURATION_SUBTRACTION, COLLAPSIBLE_STR_REPLACE, SEEK_FROM_CURRENT, SEEK_REWIND, UNNECESSARY_LAZY_EVALUATIONS, TRANSMUTE_PTR_TO_REF, ALMOST_COMPLETE_RANGE, NEEDLESS_BORROW, DERIVABLE_IMPLS, MANUAL_IS_ASCII_CHECK, MANUAL_REM_EUCLID, MANUAL_RETAIN, TYPE_REPETITION_IN_BOUNDS, TUPLE_ARRAY_CONVERSIONS, MANUAL_TRY_FOLD, MANUAL_HASH_ONE, ITER_KV_MAP.
+    /// Lint: MANUAL_SPLIT_ONCE, MANUAL_STR_REPEAT, CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, OPTION_MAP_UNWRAP_OR, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR, IF_THEN_SOME_ELSE_NONE, APPROX_CONSTANT, DEPRECATED_CFG_ATTR, INDEX_REFUTABLE_SLICE, MAP_CLONE, BORROW_AS_PTR, MANUAL_BITS, ERR_EXPECT, CAST_ABS_TO_UNSIGNED, UNINLINED_FORMAT_ARGS, MANUAL_CLAMP, MANUAL_LET_ELSE, UNCHECKED_DURATION_SUBTRACTION, COLLAPSIBLE_STR_REPLACE, SEEK_FROM_CURRENT, SEEK_REWIND, UNNECESSARY_LAZY_EVALUATIONS, TRANSMUTE_PTR_TO_REF, ALMOST_COMPLETE_RANGE, NEEDLESS_BORROW, DERIVABLE_IMPLS, MANUAL_IS_ASCII_CHECK, MANUAL_REM_EUCLID, MANUAL_RETAIN, TYPE_REPETITION_IN_BOUNDS, TUPLE_ARRAY_CONVERSIONS, MANUAL_TRY_FOLD, MANUAL_HASH_ONE, ITER_KV_MAP, MANUAL_C_STR_LITERALS.
     ///
     /// The minimum rust version that the project supports. Defaults to the `rust-version` field in `Cargo.toml`
     #[default_text = ""]
diff --git a/clippy_config/src/msrvs.rs b/clippy_config/src/msrvs.rs
index dc6df9d82ed..f4389db627d 100644
--- a/clippy_config/src/msrvs.rs
+++ b/clippy_config/src/msrvs.rs
@@ -17,6 +17,7 @@ macro_rules! msrv_aliases {
 
 // names may refer to stabilized feature flags or library items
 msrv_aliases! {
+    1,77,0 { C_STR_LITERALS }
     1,76,0 { PTR_FROM_REF }
     1,71,0 { TUPLE_ARRAY_CONVERSIONS, BUILD_HASHER_HASH_ONE }
     1,70,0 { OPTION_RESULT_IS_VARIANT_AND, BINARY_HEAP_RETAIN }
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 4182524581b..0a5baabd973 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -387,6 +387,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::methods::ITER_SKIP_ZERO_INFO,
     crate::methods::ITER_WITH_DRAIN_INFO,
     crate::methods::JOIN_ABSOLUTE_PATHS_INFO,
+    crate::methods::MANUAL_C_STR_LITERALS_INFO,
     crate::methods::MANUAL_FILTER_MAP_INFO,
     crate::methods::MANUAL_FIND_MAP_INFO,
     crate::methods::MANUAL_IS_VARIANT_AND_INFO,
diff --git a/clippy_lints/src/methods/manual_c_str_literals.rs b/clippy_lints/src/methods/manual_c_str_literals.rs
new file mode 100644
index 00000000000..cb9fb373c10
--- /dev/null
+++ b/clippy_lints/src/methods/manual_c_str_literals.rs
@@ -0,0 +1,197 @@
+use clippy_config::msrvs::{self, Msrv};
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::get_parent_expr;
+use clippy_utils::source::snippet;
+use rustc_ast::{LitKind, StrStyle};
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind, Node, QPath, TyKind};
+use rustc_lint::LateContext;
+use rustc_span::{sym, Span, Symbol};
+
+use super::MANUAL_C_STR_LITERALS;
+
+/// Checks:
+/// - `b"...".as_ptr()`
+/// - `b"...".as_ptr().cast()`
+/// - `"...".as_ptr()`
+/// - `"...".as_ptr().cast()`
+///
+/// Iff the parent call of `.cast()` isn't `CStr::from_ptr`, to avoid linting twice.
+pub(super) fn check_as_ptr<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx Expr<'tcx>,
+    receiver: &'tcx Expr<'tcx>,
+    msrv: &Msrv,
+) {
+    if let ExprKind::Lit(lit) = receiver.kind
+        && let LitKind::ByteStr(_, StrStyle::Cooked) | LitKind::Str(_, StrStyle::Cooked) = lit.node
+        && let casts_removed = peel_ptr_cast_ancestors(cx, expr)
+        && !get_parent_expr(cx, casts_removed).is_some_and(
+            |parent| matches!(parent.kind, ExprKind::Call(func, _) if is_c_str_function(cx, func).is_some()),
+        )
+        && let Some(sugg) = rewrite_as_cstr(cx, lit.span)
+        && msrv.meets(msrvs::C_STR_LITERALS)
+    {
+        span_lint_and_sugg(
+            cx,
+            MANUAL_C_STR_LITERALS,
+            receiver.span,
+            "manually constructing a nul-terminated string",
+            r#"use a `c""` literal"#,
+            sugg,
+            // an additional cast may be needed, since the type of `CStr::as_ptr` and
+            // `"".as_ptr()` can differ and is platform dependent
+            Applicability::HasPlaceholders,
+        );
+    }
+}
+
+/// Checks if the callee is a "relevant" `CStr` function considered by this lint.
+/// Returns the function name.
+fn is_c_str_function(cx: &LateContext<'_>, func: &Expr<'_>) -> Option<Symbol> {
+    if let ExprKind::Path(QPath::TypeRelative(cstr, fn_name)) = &func.kind
+        && let TyKind::Path(QPath::Resolved(_, ty_path)) = &cstr.kind
+        && cx.tcx.lang_items().c_str() == ty_path.res.opt_def_id()
+    {
+        Some(fn_name.ident.name)
+    } else {
+        None
+    }
+}
+
+/// Checks calls to the `CStr` constructor functions:
+/// - `CStr::from_bytes_with_nul(..)`
+/// - `CStr::from_bytes_with_nul_unchecked(..)`
+/// - `CStr::from_ptr(..)`
+pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, func: &Expr<'_>, args: &[Expr<'_>], msrv: &Msrv) {
+    if let Some(fn_name) = is_c_str_function(cx, func)
+        && let [arg] = args
+        && msrv.meets(msrvs::C_STR_LITERALS)
+    {
+        match fn_name.as_str() {
+            name @ ("from_bytes_with_nul" | "from_bytes_with_nul_unchecked")
+                if !arg.span.from_expansion()
+                    && let ExprKind::Lit(lit) = arg.kind
+                    && let LitKind::ByteStr(_, StrStyle::Cooked) | LitKind::Str(_, StrStyle::Cooked) = lit.node =>
+            {
+                check_from_bytes(cx, expr, arg, name);
+            },
+            "from_ptr" => check_from_ptr(cx, expr, arg),
+            _ => {},
+        }
+    }
+}
+
+/// Checks `CStr::from_ptr(b"foo\0".as_ptr().cast())`
+fn check_from_ptr(cx: &LateContext<'_>, expr: &Expr<'_>, arg: &Expr<'_>) {
+    if let ExprKind::MethodCall(method, lit, ..) = peel_ptr_cast(arg).kind
+        && method.ident.name == sym::as_ptr
+        && !lit.span.from_expansion()
+        && let ExprKind::Lit(lit) = lit.kind
+        && let LitKind::ByteStr(_, StrStyle::Cooked) = lit.node
+        && let Some(sugg) = rewrite_as_cstr(cx, lit.span)
+    {
+        span_lint_and_sugg(
+            cx,
+            MANUAL_C_STR_LITERALS,
+            expr.span,
+            "calling `CStr::from_ptr` with a byte string literal",
+            r#"use a `c""` literal"#,
+            sugg,
+            Applicability::MachineApplicable,
+        );
+    }
+}
+/// Checks `CStr::from_bytes_with_nul(b"foo\0")`
+fn check_from_bytes(cx: &LateContext<'_>, expr: &Expr<'_>, arg: &Expr<'_>, method: &str) {
+    let (span, applicability) = if let Some(parent) = get_parent_expr(cx, expr)
+        && let ExprKind::MethodCall(method, ..) = parent.kind
+        && [sym::unwrap, sym::expect].contains(&method.ident.name)
+    {
+        (parent.span, Applicability::MachineApplicable)
+    } else if method == "from_bytes_with_nul_unchecked" {
+        // `*_unchecked` returns `&CStr` directly, nothing needs to be changed
+        (expr.span, Applicability::MachineApplicable)
+    } else {
+        // User needs to remove error handling, can't be machine applicable
+        (expr.span, Applicability::HasPlaceholders)
+    };
+
+    let Some(sugg) = rewrite_as_cstr(cx, arg.span) else {
+        return;
+    };
+
+    span_lint_and_sugg(
+        cx,
+        MANUAL_C_STR_LITERALS,
+        span,
+        "calling `CStr::new` with a byte string literal",
+        r#"use a `c""` literal"#,
+        sugg,
+        applicability,
+    );
+}
+
+/// Rewrites a byte string literal to a c-str literal.
+/// `b"foo\0"` -> `c"foo"`
+///
+/// Returns `None` if it doesn't end in a NUL byte.
+fn rewrite_as_cstr(cx: &LateContext<'_>, span: Span) -> Option<String> {
+    let mut sugg = String::from("c") + snippet(cx, span.source_callsite(), "..").trim_start_matches('b');
+
+    // NUL byte should always be right before the closing quote.
+    if let Some(quote_pos) = sugg.rfind('"') {
+        // Possible values right before the quote:
+        // - literal NUL value
+        if sugg.as_bytes()[quote_pos - 1] == b'\0' {
+            sugg.remove(quote_pos - 1);
+        }
+        // - \x00
+        else if sugg[..quote_pos].ends_with("\\x00") {
+            sugg.replace_range(quote_pos - 4..quote_pos, "");
+        }
+        // - \0
+        else if sugg[..quote_pos].ends_with("\\0") {
+            sugg.replace_range(quote_pos - 2..quote_pos, "");
+        }
+        // No known suffix, so assume it's not a C-string.
+        else {
+            return None;
+        }
+    }
+
+    Some(sugg)
+}
+
+fn get_cast_target<'tcx>(e: &'tcx Expr<'tcx>) -> Option<&'tcx Expr<'tcx>> {
+    match &e.kind {
+        ExprKind::MethodCall(method, receiver, [], _) if method.ident.as_str() == "cast" => Some(receiver),
+        ExprKind::Cast(expr, _) => Some(expr),
+        _ => None,
+    }
+}
+
+/// `x.cast()` -> `x`
+/// `x as *const _` -> `x`
+/// `x` -> `x` (returns the same expression for non-cast exprs)
+fn peel_ptr_cast<'tcx>(e: &'tcx Expr<'tcx>) -> &'tcx Expr<'tcx> {
+    get_cast_target(e).map_or(e, peel_ptr_cast)
+}
+
+/// Same as `peel_ptr_cast`, but the other way around, by walking up the ancestor cast expressions:
+///
+/// `foo(x.cast() as *const _)`
+///      ^ given this `x` expression, returns the `foo(...)` expression
+fn peel_ptr_cast_ancestors<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'tcx>) -> &'tcx Expr<'tcx> {
+    let mut prev = e;
+    for (_, node) in cx.tcx.hir().parent_iter(e.hir_id) {
+        if let Node::Expr(e) = node
+            && get_cast_target(e).is_some()
+        {
+            prev = e;
+        } else {
+            break;
+        }
+    }
+    prev
+}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index bac72fd255a..e8a7a321bf4 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -51,6 +51,7 @@ mod iter_skip_zero;
 mod iter_with_drain;
 mod iterator_step_by_zero;
 mod join_absolute_paths;
+mod manual_c_str_literals;
 mod manual_is_variant_and;
 mod manual_next_back;
 mod manual_ok_or;
@@ -3977,6 +3978,39 @@ declare_clippy_lint! {
     "making no use of the \"map closure\" when calling `.map_or_else(|err| handle_error(err), |n| n)`"
 }
 
+declare_clippy_lint! {
+    /// Checks for the manual creation of C strings (a string with a `NUL` byte at the end), either
+    /// through one of the `CStr` constructor functions, or more plainly by calling `.as_ptr()`
+    /// on a (byte) string literal with a hardcoded `\0` byte at the end.
+    ///
+    /// ### Why is this bad?
+    /// This can be written more concisely using `c"str"` literals and is also less error-prone,
+    /// because the compiler checks for interior `NUL` bytes and the terminating `NUL` byte is inserted automatically.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # use std::ffi::CStr;
+    /// # mod libc { pub unsafe fn puts(_: *const i8) {} }
+    /// fn needs_cstr(_: &CStr) {}
+    ///
+    /// needs_cstr(CStr::from_bytes_with_nul(b"Hello\0").unwrap());
+    /// unsafe { libc::puts("World\0".as_ptr().cast()) }
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// # use std::ffi::CStr;
+    /// # mod libc { pub unsafe fn puts(_: *const i8) {} }
+    /// fn needs_cstr(_: &CStr) {}
+    ///
+    /// needs_cstr(c"Hello");
+    /// unsafe { libc::puts(c"World".as_ptr()) }
+    /// ```
+    #[clippy::version = "1.76.0"]
+    pub MANUAL_C_STR_LITERALS,
+    pedantic,
+    r#"creating a `CStr` through functions when `c""` literals can be used"#
+}
+
 pub struct Methods {
     avoid_breaking_exported_api: bool,
     msrv: Msrv,
@@ -4136,6 +4170,7 @@ impl_lint_pass!(Methods => [
     STR_SPLIT_AT_NEWLINE,
     OPTION_AS_REF_CLONED,
     UNNECESSARY_RESULT_MAP_OR_ELSE,
+    MANUAL_C_STR_LITERALS,
 ]);
 
 /// Extracts a method call name, args, and `Span` of the method name.
@@ -4163,6 +4198,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             hir::ExprKind::Call(func, args) => {
                 from_iter_instead_of_collect::check(cx, expr, args, func);
                 unnecessary_fallible_conversions::check_function(cx, expr, func);
+                manual_c_str_literals::check(cx, expr, func, args, &self.msrv);
             },
             hir::ExprKind::MethodCall(method_call, receiver, args, _) => {
                 let method_span = method_call.ident.span;
@@ -4381,6 +4417,7 @@ impl Methods {
                     }
                 },
                 ("as_mut", []) => useless_asref::check(cx, expr, "as_mut", recv),
+                ("as_ptr", []) => manual_c_str_literals::check_as_ptr(cx, expr, recv, &self.msrv),
                 ("as_ref", []) => useless_asref::check(cx, expr, "as_ref", recv),
                 ("assume_init", []) => uninit_assumed_init::check(cx, expr, recv),
                 ("cloned", []) => {
diff --git a/tests/ui/manual_c_str_literals.fixed b/tests/ui/manual_c_str_literals.fixed
new file mode 100644
index 00000000000..a24d7088c88
--- /dev/null
+++ b/tests/ui/manual_c_str_literals.fixed
@@ -0,0 +1,60 @@
+#![warn(clippy::manual_c_str_literals)]
+#![allow(clippy::no_effect)]
+
+use std::ffi::CStr;
+
+macro_rules! cstr {
+    ($s:literal) => {
+        CStr::from_bytes_with_nul(concat!($s, "\0").as_bytes()).unwrap()
+    };
+}
+
+macro_rules! macro_returns_c_str {
+    () => {
+        CStr::from_bytes_with_nul(b"foo\0").unwrap();
+    };
+}
+
+macro_rules! macro_returns_byte_string {
+    () => {
+        b"foo\0"
+    };
+}
+
+#[clippy::msrv = "1.76.0"]
+fn pre_stabilization() {
+    CStr::from_bytes_with_nul(b"foo\0");
+}
+
+#[clippy::msrv = "1.77.0"]
+fn post_stabilization() {
+    c"foo";
+}
+
+fn main() {
+    c"foo";
+    c"foo";
+    c"foo";
+    c"foo\\0sdsd";
+    CStr::from_bytes_with_nul(br"foo\\0sdsd\0").unwrap();
+    CStr::from_bytes_with_nul(br"foo\x00").unwrap();
+    CStr::from_bytes_with_nul(br##"foo#a\0"##).unwrap();
+
+    unsafe { c"foo" };
+    unsafe { c"foo" };
+    let _: *const _ = c"foo".as_ptr();
+    let _: *const _ = c"foo".as_ptr();
+    let _: *const _ = "foo".as_ptr(); // not a C-string
+    let _: *const _ = "".as_ptr();
+    let _: *const _ = c"foo".as_ptr().cast::<i8>();
+    let _ = "电脑".as_ptr();
+    let _ = "电脑\\".as_ptr();
+    let _ = c"电脑\\".as_ptr();
+    let _ = c"电脑".as_ptr();
+    let _ = c"电脑".as_ptr();
+
+    // Macro cases, don't lint:
+    cstr!("foo");
+    macro_returns_c_str!();
+    CStr::from_bytes_with_nul(macro_returns_byte_string!()).unwrap();
+}
diff --git a/tests/ui/manual_c_str_literals.rs b/tests/ui/manual_c_str_literals.rs
new file mode 100644
index 00000000000..0a007786720
--- /dev/null
+++ b/tests/ui/manual_c_str_literals.rs
@@ -0,0 +1,60 @@
+#![warn(clippy::manual_c_str_literals)]
+#![allow(clippy::no_effect)]
+
+use std::ffi::CStr;
+
+macro_rules! cstr {
+    ($s:literal) => {
+        CStr::from_bytes_with_nul(concat!($s, "\0").as_bytes()).unwrap()
+    };
+}
+
+macro_rules! macro_returns_c_str {
+    () => {
+        CStr::from_bytes_with_nul(b"foo\0").unwrap();
+    };
+}
+
+macro_rules! macro_returns_byte_string {
+    () => {
+        b"foo\0"
+    };
+}
+
+#[clippy::msrv = "1.76.0"]
+fn pre_stabilization() {
+    CStr::from_bytes_with_nul(b"foo\0");
+}
+
+#[clippy::msrv = "1.77.0"]
+fn post_stabilization() {
+    CStr::from_bytes_with_nul(b"foo\0");
+}
+
+fn main() {
+    CStr::from_bytes_with_nul(b"foo\0");
+    CStr::from_bytes_with_nul(b"foo\x00");
+    CStr::from_bytes_with_nul(b"foo\0").unwrap();
+    CStr::from_bytes_with_nul(b"foo\\0sdsd\0").unwrap();
+    CStr::from_bytes_with_nul(br"foo\\0sdsd\0").unwrap();
+    CStr::from_bytes_with_nul(br"foo\x00").unwrap();
+    CStr::from_bytes_with_nul(br##"foo#a\0"##).unwrap();
+
+    unsafe { CStr::from_ptr(b"foo\0".as_ptr().cast()) };
+    unsafe { CStr::from_ptr(b"foo\0".as_ptr() as *const _) };
+    let _: *const _ = b"foo\0".as_ptr();
+    let _: *const _ = "foo\0".as_ptr();
+    let _: *const _ = "foo".as_ptr(); // not a C-string
+    let _: *const _ = "".as_ptr();
+    let _: *const _ = b"foo\0".as_ptr().cast::<i8>();
+    let _ = "电脑".as_ptr();
+    let _ = "电脑\\".as_ptr();
+    let _ = "电脑\\\0".as_ptr();
+    let _ = "电脑\0".as_ptr();
+    let _ = "电脑\x00".as_ptr();
+
+    // Macro cases, don't lint:
+    cstr!("foo");
+    macro_returns_c_str!();
+    CStr::from_bytes_with_nul(macro_returns_byte_string!()).unwrap();
+}
diff --git a/tests/ui/manual_c_str_literals.stderr b/tests/ui/manual_c_str_literals.stderr
new file mode 100644
index 00000000000..8de4e16f010
--- /dev/null
+++ b/tests/ui/manual_c_str_literals.stderr
@@ -0,0 +1,83 @@
+error: calling `CStr::new` with a byte string literal
+  --> $DIR/manual_c_str_literals.rs:31:5
+   |
+LL |     CStr::from_bytes_with_nul(b"foo\0");
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use a `c""` literal: `c"foo"`
+   |
+   = note: `-D clippy::manual-c-str-literals` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::manual_c_str_literals)]`
+
+error: calling `CStr::new` with a byte string literal
+  --> $DIR/manual_c_str_literals.rs:35:5
+   |
+LL |     CStr::from_bytes_with_nul(b"foo\0");
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use a `c""` literal: `c"foo"`
+
+error: calling `CStr::new` with a byte string literal
+  --> $DIR/manual_c_str_literals.rs:36:5
+   |
+LL |     CStr::from_bytes_with_nul(b"foo\x00");
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use a `c""` literal: `c"foo"`
+
+error: calling `CStr::new` with a byte string literal
+  --> $DIR/manual_c_str_literals.rs:37:5
+   |
+LL |     CStr::from_bytes_with_nul(b"foo\0").unwrap();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use a `c""` literal: `c"foo"`
+
+error: calling `CStr::new` with a byte string literal
+  --> $DIR/manual_c_str_literals.rs:38:5
+   |
+LL |     CStr::from_bytes_with_nul(b"foo\\0sdsd\0").unwrap();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use a `c""` literal: `c"foo\\0sdsd"`
+
+error: calling `CStr::from_ptr` with a byte string literal
+  --> $DIR/manual_c_str_literals.rs:43:14
+   |
+LL |     unsafe { CStr::from_ptr(b"foo\0".as_ptr().cast()) };
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use a `c""` literal: `c"foo"`
+
+error: calling `CStr::from_ptr` with a byte string literal
+  --> $DIR/manual_c_str_literals.rs:44:14
+   |
+LL |     unsafe { CStr::from_ptr(b"foo\0".as_ptr() as *const _) };
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use a `c""` literal: `c"foo"`
+
+error: manually constructing a nul-terminated string
+  --> $DIR/manual_c_str_literals.rs:45:23
+   |
+LL |     let _: *const _ = b"foo\0".as_ptr();
+   |                       ^^^^^^^^ help: use a `c""` literal: `c"foo"`
+
+error: manually constructing a nul-terminated string
+  --> $DIR/manual_c_str_literals.rs:46:23
+   |
+LL |     let _: *const _ = "foo\0".as_ptr();
+   |                       ^^^^^^^ help: use a `c""` literal: `c"foo"`
+
+error: manually constructing a nul-terminated string
+  --> $DIR/manual_c_str_literals.rs:49:23
+   |
+LL |     let _: *const _ = b"foo\0".as_ptr().cast::<i8>();
+   |                       ^^^^^^^^ help: use a `c""` literal: `c"foo"`
+
+error: manually constructing a nul-terminated string
+  --> $DIR/manual_c_str_literals.rs:52:13
+   |
+LL |     let _ = "电脑\\\0".as_ptr();
+   |             ^^^^^^^^^^ help: use a `c""` literal: `c"电脑\\"`
+
+error: manually constructing a nul-terminated string
+  --> $DIR/manual_c_str_literals.rs:53:13
+   |
+LL |     let _ = "电脑\0".as_ptr();
+   |             ^^^^^^^^ help: use a `c""` literal: `c"电脑"`
+
+error: manually constructing a nul-terminated string
+  --> $DIR/manual_c_str_literals.rs:54:13
+   |
+LL |     let _ = "电脑\x00".as_ptr();
+   |             ^^^^^^^^^^ help: use a `c""` literal: `c"电脑"`
+
+error: aborting due to 13 previous errors
+
diff --git a/tests/ui/strlen_on_c_strings.fixed b/tests/ui/strlen_on_c_strings.fixed
index 8304e2afd8b..1e7d04ffb9d 100644
--- a/tests/ui/strlen_on_c_strings.fixed
+++ b/tests/ui/strlen_on_c_strings.fixed
@@ -1,5 +1,5 @@
 #![warn(clippy::strlen_on_c_strings)]
-#![allow(dead_code)]
+#![allow(dead_code, clippy::manual_c_str_literals)]
 #![feature(rustc_private)]
 extern crate libc;
 
diff --git a/tests/ui/strlen_on_c_strings.rs b/tests/ui/strlen_on_c_strings.rs
index deba40a9ea5..c3ad03591d4 100644
--- a/tests/ui/strlen_on_c_strings.rs
+++ b/tests/ui/strlen_on_c_strings.rs
@@ -1,5 +1,5 @@
 #![warn(clippy::strlen_on_c_strings)]
-#![allow(dead_code)]
+#![allow(dead_code, clippy::manual_c_str_literals)]
 #![feature(rustc_private)]
 extern crate libc;
 
-- 
cgit 1.4.1-3-g733a5


From 3c76b2ceff3526b2d46abb1bbd38180131578808 Mon Sep 17 00:00:00 2001
From: roife <roifewu@gmail.com>
Date: Thu, 8 Feb 2024 13:45:57 +0800
Subject: Merging the calculation of sugg and applicability

---
 .../methods/unnecessary_fallible_conversions.rs    | 25 +++++++++++-----------
 1 file changed, 12 insertions(+), 13 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/unnecessary_fallible_conversions.rs b/clippy_lints/src/methods/unnecessary_fallible_conversions.rs
index bb23ae5f843..d46b584f8f4 100644
--- a/clippy_lints/src/methods/unnecessary_fallible_conversions.rs
+++ b/clippy_lints/src/methods/unnecessary_fallible_conversions.rs
@@ -30,14 +30,19 @@ enum FunctionKind {
 }
 
 impl FunctionKind {
-    fn applicability(&self, parent_unwrap_call: &Option<Span>) -> Applicability {
-        if parent_unwrap_call.is_none() {
-            return Applicability::Unspecified;
-        }
+    fn appl_sugg(&self, parent_unwrap_call: Option<Span>, primary_span: Span) -> (Applicability, Vec<(Span, String)>) {
+        let Some(unwrap_span) = parent_unwrap_call else {
+            return (Applicability::Unspecified, self.default_sugg(primary_span));
+        };
 
         match &self {
-            FunctionKind::TryFromFunction(None) | FunctionKind::TryIntoFunction(None) => Applicability::Unspecified,
-            _ => Applicability::MachineApplicable,
+            FunctionKind::TryFromFunction(None) | FunctionKind::TryIntoFunction(None) => {
+                (Applicability::Unspecified, self.default_sugg(primary_span))
+            },
+            _ => (
+                Applicability::MachineApplicable,
+                self.machine_applicable_sugg(primary_span, unwrap_span),
+            ),
         }
     }
 
@@ -123,13 +128,7 @@ fn check<'tcx>(
             FunctionKind::TryFromFunction(_) => (other_ty, self_ty),
         };
 
-        let applicability = kind.applicability(&parent_unwrap_call);
-
-        let sugg = if applicability == Applicability::MachineApplicable {
-            kind.machine_applicable_sugg(primary_span, parent_unwrap_call.unwrap())
-        } else {
-            kind.default_sugg(primary_span)
-        };
+        let (applicability, sugg) = kind.appl_sugg(parent_unwrap_call, primary_span);
 
         span_lint_and_then(
             cx,
-- 
cgit 1.4.1-3-g733a5


From 4a5e30dca7ce6271f34ca8c88c5733aa6969b5ab Mon Sep 17 00:00:00 2001
From: Trevor Gross <tmgross@umich.edu>
Date: Fri, 9 Feb 2024 22:56:07 -0600
Subject: Refactor a portion of 'non_expressive_names.rs' for clarity

---
 clippy_lints/src/non_expressive_names.rs | 128 +++++++++++++++----------------
 1 file changed, 62 insertions(+), 66 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/non_expressive_names.rs b/clippy_lints/src/non_expressive_names.rs
index ba9230dab7a..66b0a53fdd7 100644
--- a/clippy_lints/src/non_expressive_names.rs
+++ b/clippy_lints/src/non_expressive_names.rs
@@ -119,7 +119,6 @@ impl<'a, 'tcx> SimilarNamesLocalVisitor<'a, 'tcx> {
 
 // this list contains lists of names that are allowed to be similar
 // the assumption is that no name is ever contained in multiple lists.
-#[rustfmt::skip]
 const ALLOWED_TO_BE_SIMILAR: &[&[&str]] = &[
     &["parsed", "parser"],
     &["lhs", "rhs"],
@@ -189,7 +188,6 @@ impl<'a, 'tcx, 'b> SimilarNamesNameVisitor<'a, 'tcx, 'b> {
         }
     }
 
-    #[expect(clippy::too_many_lines)]
     fn check_ident(&mut self, ident: Ident) {
         let interned_name = ident.name.as_str();
         if interned_name.chars().any(char::is_uppercase) {
@@ -219,71 +217,18 @@ impl<'a, 'tcx, 'b> SimilarNamesNameVisitor<'a, 'tcx, 'b> {
             if allowed_to_be_similar(interned_name, existing_name.exemptions) {
                 continue;
             }
-            match existing_name.len.cmp(&count) {
-                Ordering::Greater => {
-                    if existing_name.len - count != 1
-                        || levenstein_not_1(interned_name, existing_name.interned.as_str())
-                    {
-                        continue;
-                    }
-                },
-                Ordering::Less => {
-                    if count - existing_name.len != 1
-                        || levenstein_not_1(existing_name.interned.as_str(), interned_name)
-                    {
-                        continue;
-                    }
-                },
-                Ordering::Equal => {
-                    let mut interned_chars = interned_name.chars();
-                    let interned_str = existing_name.interned.as_str();
-                    let mut existing_chars = interned_str.chars();
-                    let first_i = interned_chars.next().expect("we know we have at least one char");
-                    let first_e = existing_chars.next().expect("we know we have at least one char");
-                    let eq_or_numeric = |(a, b): (char, char)| a == b || a.is_numeric() && b.is_numeric();
-
-                    if eq_or_numeric((first_i, first_e)) {
-                        let last_i = interned_chars.next_back().expect("we know we have at least two chars");
-                        let last_e = existing_chars.next_back().expect("we know we have at least two chars");
-                        if eq_or_numeric((last_i, last_e)) {
-                            if interned_chars
-                                .zip(existing_chars)
-                                .filter(|&ie| !eq_or_numeric(ie))
-                                .count()
-                                != 1
-                            {
-                                continue;
-                            }
-                        } else {
-                            let second_last_i = interned_chars
-                                .next_back()
-                                .expect("we know we have at least three chars");
-                            let second_last_e = existing_chars
-                                .next_back()
-                                .expect("we know we have at least three chars");
-                            if !eq_or_numeric((second_last_i, second_last_e))
-                                || second_last_i == '_'
-                                || !interned_chars.zip(existing_chars).all(eq_or_numeric)
-                            {
-                                // allowed similarity foo_x, foo_y
-                                // or too many chars differ (foo_x, boo_y) or (foox, booy)
-                                continue;
-                            }
-                        }
-                    } else {
-                        let second_i = interned_chars.next().expect("we know we have at least two chars");
-                        let second_e = existing_chars.next().expect("we know we have at least two chars");
-                        if !eq_or_numeric((second_i, second_e))
-                            || second_i == '_'
-                            || !interned_chars.zip(existing_chars).all(eq_or_numeric)
-                        {
-                            // allowed similarity x_foo, y_foo
-                            // or too many chars differ (x_foo, y_boo) or (xfoo, yboo)
-                            continue;
-                        }
-                    }
-                },
+
+            let existing_str = existing_name.interned.as_str();
+            let dissimilar = match existing_name.len.cmp(&count) {
+                Ordering::Greater => existing_name.len - count != 1 || levenstein_not_1(interned_name, existing_str),
+                Ordering::Less => count - existing_name.len != 1 || levenstein_not_1(existing_str, interned_name),
+                Ordering::Equal => Self::equal_length_strs_not_similar(interned_name, existing_str),
+            };
+
+            if dissimilar {
+                continue;
             }
+
             span_lint_and_then(
                 self.0.cx,
                 SIMILAR_NAMES,
@@ -302,6 +247,57 @@ impl<'a, 'tcx, 'b> SimilarNamesNameVisitor<'a, 'tcx, 'b> {
             len: count,
         });
     }
+
+    fn equal_length_strs_not_similar(interned_name: &str, existing_name: &str) -> bool {
+        let mut interned_chars = interned_name.chars();
+        let mut existing_chars = existing_name.chars();
+        let first_i = interned_chars.next().expect("we know we have at least one char");
+        let first_e = existing_chars.next().expect("we know we have at least one char");
+        let eq_or_numeric = |(a, b): (char, char)| a == b || a.is_numeric() && b.is_numeric();
+
+        if eq_or_numeric((first_i, first_e)) {
+            let last_i = interned_chars.next_back().expect("we know we have at least two chars");
+            let last_e = existing_chars.next_back().expect("we know we have at least two chars");
+            if eq_or_numeric((last_i, last_e)) {
+                if interned_chars
+                    .zip(existing_chars)
+                    .filter(|&ie| !eq_or_numeric(ie))
+                    .count()
+                    != 1
+                {
+                    return true;
+                }
+            } else {
+                let second_last_i = interned_chars
+                    .next_back()
+                    .expect("we know we have at least three chars");
+                let second_last_e = existing_chars
+                    .next_back()
+                    .expect("we know we have at least three chars");
+                if !eq_or_numeric((second_last_i, second_last_e))
+                    || second_last_i == '_'
+                    || !interned_chars.zip(existing_chars).all(eq_or_numeric)
+                {
+                    // allowed similarity foo_x, foo_y
+                    // or too many chars differ (foo_x, boo_y) or (foox, booy)
+                    return true;
+                }
+            }
+        } else {
+            let second_i = interned_chars.next().expect("we know we have at least two chars");
+            let second_e = existing_chars.next().expect("we know we have at least two chars");
+            if !eq_or_numeric((second_i, second_e))
+                || second_i == '_'
+                || !interned_chars.zip(existing_chars).all(eq_or_numeric)
+            {
+                // allowed similarity x_foo, y_foo
+                // or too many chars differ (x_foo, y_boo) or (xfoo, yboo)
+                return true;
+            }
+        }
+
+        false
+    }
 }
 
 impl<'a, 'b> SimilarNamesLocalVisitor<'a, 'b> {
-- 
cgit 1.4.1-3-g733a5


From 09f18f61c6111674244471d49d7f82d826913022 Mon Sep 17 00:00:00 2001
From: Trevor Gross <tmgross@umich.edu>
Date: Fri, 9 Feb 2024 23:19:27 -0600
Subject: [similar_names] don't raise if the first character is different

A lot of cases of the "noise" cases of `similar_names` come from two
idents with a different first letter, which is easy enough to
differentiate visually but causes this lint to be raised.

Do not raise the lint in these cases, as long as the first character
does not have a lookalike.

Link: https://github.com/rust-lang/rust-clippy/issues/10926
---
 clippy_lints/src/non_expressive_names.rs | 18 ++++++++++++
 tests/ui/similar_names.rs                |  5 +---
 tests/ui/similar_names.stderr            | 50 +++++++++-----------------------
 3 files changed, 32 insertions(+), 41 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/non_expressive_names.rs b/clippy_lints/src/non_expressive_names.rs
index 66b0a53fdd7..b8c3c7fa65a 100644
--- a/clippy_lints/src/non_expressive_names.rs
+++ b/clippy_lints/src/non_expressive_names.rs
@@ -131,6 +131,14 @@ const ALLOWED_TO_BE_SIMILAR: &[&[&str]] = &[
     &["iter", "item"],
 ];
 
+/// Characters that look visually similar
+const SIMILAR_CHARS: &[(char, char)] = &[('l', 'i'), ('l', '1'), ('i', '1'), ('u', 'v')];
+
+/// Return true if two characters are visually similar
+fn chars_are_similar(a: char, b: char) -> bool {
+    a == b || SIMILAR_CHARS.contains(&(a, b)) || SIMILAR_CHARS.contains(&(b, a))
+}
+
 struct SimilarNamesNameVisitor<'a, 'tcx, 'b>(&'b mut SimilarNamesLocalVisitor<'a, 'tcx>);
 
 impl<'a, 'tcx, 'b> Visitor<'tcx> for SimilarNamesNameVisitor<'a, 'tcx, 'b> {
@@ -219,6 +227,16 @@ impl<'a, 'tcx, 'b> SimilarNamesNameVisitor<'a, 'tcx, 'b> {
             }
 
             let existing_str = existing_name.interned.as_str();
+
+            // The first char being different is usually enough to set identifiers apart, as long
+            // as the characters aren't too similar.
+            if !chars_are_similar(
+                interned_name.chars().next().expect("len >= 1"),
+                existing_str.chars().next().expect("len >= 1"),
+            ) {
+                continue;
+            }
+
             let dissimilar = match existing_name.len.cmp(&count) {
                 Ordering::Greater => existing_name.len - count != 1 || levenstein_not_1(interned_name, existing_str),
                 Ordering::Less => count - existing_name.len != 1 || levenstein_not_1(existing_str, interned_name),
diff --git a/tests/ui/similar_names.rs b/tests/ui/similar_names.rs
index f46af56c6e2..f0969334491 100644
--- a/tests/ui/similar_names.rs
+++ b/tests/ui/similar_names.rs
@@ -17,13 +17,10 @@ fn main() {
     let specter: i32;
     let spectre: i32;
 
+    // ok; first letter is different enough
     let apple: i32;
-
     let bpple: i32;
-    //~^ ERROR: binding's name is too similar to existing binding
-
     let cpple: i32;
-    //~^ ERROR: binding's name is too similar to existing binding
 
     let a_bar: i32;
     let b_bar: i32;
diff --git a/tests/ui/similar_names.stderr b/tests/ui/similar_names.stderr
index 44ae3532a48..0cadb44ecf1 100644
--- a/tests/ui/similar_names.stderr
+++ b/tests/ui/similar_names.stderr
@@ -1,88 +1,64 @@
 error: binding's name is too similar to existing binding
-  --> $DIR/similar_names.rs:22:9
-   |
-LL |     let bpple: i32;
-   |         ^^^^^
-   |
-note: existing binding defined here
-  --> $DIR/similar_names.rs:20:9
-   |
-LL |     let apple: i32;
-   |         ^^^^^
-   = note: `-D clippy::similar-names` implied by `-D warnings`
-   = help: to override `-D warnings` add `#[allow(clippy::similar_names)]`
-
-error: binding's name is too similar to existing binding
-  --> $DIR/similar_names.rs:25:9
-   |
-LL |     let cpple: i32;
-   |         ^^^^^
-   |
-note: existing binding defined here
-  --> $DIR/similar_names.rs:20:9
-   |
-LL |     let apple: i32;
-   |         ^^^^^
-
-error: binding's name is too similar to existing binding
-  --> $DIR/similar_names.rs:50:9
+  --> $DIR/similar_names.rs:47:9
    |
 LL |     let bluby: i32;
    |         ^^^^^
    |
 note: existing binding defined here
-  --> $DIR/similar_names.rs:49:9
+  --> $DIR/similar_names.rs:46:9
    |
 LL |     let blubx: i32;
    |         ^^^^^
+   = note: `-D clippy::similar-names` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::similar_names)]`
 
 error: binding's name is too similar to existing binding
-  --> $DIR/similar_names.rs:55:9
+  --> $DIR/similar_names.rs:52:9
    |
 LL |     let coke: i32;
    |         ^^^^
    |
 note: existing binding defined here
-  --> $DIR/similar_names.rs:53:9
+  --> $DIR/similar_names.rs:50:9
    |
 LL |     let cake: i32;
    |         ^^^^
 
 error: binding's name is too similar to existing binding
-  --> $DIR/similar_names.rs:74:9
+  --> $DIR/similar_names.rs:71:9
    |
 LL |     let xyzeabc: i32;
    |         ^^^^^^^
    |
 note: existing binding defined here
-  --> $DIR/similar_names.rs:72:9
+  --> $DIR/similar_names.rs:69:9
    |
 LL |     let xyz1abc: i32;
    |         ^^^^^^^
 
 error: binding's name is too similar to existing binding
-  --> $DIR/similar_names.rs:79:9
+  --> $DIR/similar_names.rs:76:9
    |
 LL |     let parsee: i32;
    |         ^^^^^^
    |
 note: existing binding defined here
-  --> $DIR/similar_names.rs:77:9
+  --> $DIR/similar_names.rs:74:9
    |
 LL |     let parser: i32;
    |         ^^^^^^
 
 error: binding's name is too similar to existing binding
-  --> $DIR/similar_names.rs:101:16
+  --> $DIR/similar_names.rs:98:16
    |
 LL |         bpple: sprang,
    |                ^^^^^^
    |
 note: existing binding defined here
-  --> $DIR/similar_names.rs:100:16
+  --> $DIR/similar_names.rs:97:16
    |
 LL |         apple: spring,
    |                ^^^^^^
 
-error: aborting due to 7 previous errors
+error: aborting due to 5 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 5250afb77d5f14a82539fef4bfbb96d6d56f639a Mon Sep 17 00:00:00 2001
From: Trevor Gross <tmgross@umich.edu>
Date: Fri, 9 Feb 2024 23:36:31 -0600
Subject: Remove '#[expect(clippy::similar_names)]' where needed to pass
 dogfood tests

---
 clippy_lints/src/item_name_repetitions.rs       |  1 -
 clippy_lints/src/operators/double_comparison.rs |  1 -
 clippy_lints/src/operators/op_ref.rs            |  2 +-
 clippy_utils/src/ast_utils.rs                   |  4 +--
 clippy_utils/src/hir_utils.rs                   |  5 +--
 clippy_utils/src/qualify_min_const_fn.rs        |  1 -
 tests/ui/approx_const.rs                        |  1 -
 tests/ui/approx_const.stderr                    | 46 ++++++++++++-------------
 8 files changed, 27 insertions(+), 34 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/item_name_repetitions.rs b/clippy_lints/src/item_name_repetitions.rs
index 276c1abb60c..0b4c416d94d 100644
--- a/clippy_lints/src/item_name_repetitions.rs
+++ b/clippy_lints/src/item_name_repetitions.rs
@@ -385,7 +385,6 @@ impl LateLintPass<'_> for ItemNameRepetitions {
         assert!(last.is_some());
     }
 
-    #[expect(clippy::similar_names)]
     fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
         let item_name = item.ident.name.as_str();
         let item_camel = to_camel_case(item_name);
diff --git a/clippy_lints/src/operators/double_comparison.rs b/clippy_lints/src/operators/double_comparison.rs
index d48e8286f2c..d72a2fc3b1a 100644
--- a/clippy_lints/src/operators/double_comparison.rs
+++ b/clippy_lints/src/operators/double_comparison.rs
@@ -8,7 +8,6 @@ use rustc_span::Span;
 
 use super::DOUBLE_COMPARISONS;
 
-#[expect(clippy::similar_names)]
 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, op: BinOpKind, lhs: &'tcx Expr<'_>, rhs: &'tcx Expr<'_>, span: Span) {
     let (lkind, llhs, lrhs, rkind, rlhs, rrhs) = match (&lhs.kind, &rhs.kind) {
         (ExprKind::Binary(lb, llhs, lrhs), ExprKind::Binary(rb, rlhs, rrhs)) => {
diff --git a/clippy_lints/src/operators/op_ref.rs b/clippy_lints/src/operators/op_ref.rs
index 7d8aa3f56fe..c2b27c9b229 100644
--- a/clippy_lints/src/operators/op_ref.rs
+++ b/clippy_lints/src/operators/op_ref.rs
@@ -11,7 +11,7 @@ use rustc_middle::ty::{self, Ty};
 
 use super::OP_REF;
 
-#[expect(clippy::similar_names, clippy::too_many_lines)]
+#[expect(clippy::too_many_lines)]
 pub(crate) fn check<'tcx>(
     cx: &LateContext<'tcx>,
     e: &'tcx Expr<'_>,
diff --git a/clippy_utils/src/ast_utils.rs b/clippy_utils/src/ast_utils.rs
index adc35bd82ae..63f7d58af26 100644
--- a/clippy_utils/src/ast_utils.rs
+++ b/clippy_utils/src/ast_utils.rs
@@ -2,7 +2,7 @@
 //!
 //! - The `eq_foobar` functions test for semantic equality but ignores `NodeId`s and `Span`s.
 
-#![allow(clippy::similar_names, clippy::wildcard_imports, clippy::enum_glob_use)]
+#![allow(clippy::wildcard_imports, clippy::enum_glob_use)]
 
 use crate::{both, over};
 use rustc_ast::ptr::P;
@@ -296,7 +296,7 @@ pub fn eq_item<K>(l: &Item<K>, r: &Item<K>, mut eq_kind: impl FnMut(&K, &K) -> b
     eq_id(l.ident, r.ident) && over(&l.attrs, &r.attrs, eq_attr) && eq_vis(&l.vis, &r.vis) && eq_kind(&l.kind, &r.kind)
 }
 
-#[expect(clippy::too_many_lines)] // Just a big match statement
+#[expect(clippy::similar_names, clippy::too_many_lines)] // Just a big match statement
 pub fn eq_item_kind(l: &ItemKind, r: &ItemKind) -> bool {
     use ItemKind::*;
     match (l, r) {
diff --git a/clippy_utils/src/hir_utils.rs b/clippy_utils/src/hir_utils.rs
index 4fa93ad23c3..36013ae0c1f 100644
--- a/clippy_utils/src/hir_utils.rs
+++ b/clippy_utils/src/hir_utils.rs
@@ -132,7 +132,6 @@ impl HirEqInterExpr<'_, '_, '_> {
     }
 
     /// Checks whether two blocks are the same.
-    #[expect(clippy::similar_names)]
     fn eq_block(&mut self, left: &Block<'_>, right: &Block<'_>) -> bool {
         use TokenKind::{Semi, Whitespace};
         if left.stmts.len() != right.stmts.len() {
@@ -247,7 +246,7 @@ impl HirEqInterExpr<'_, '_, '_> {
         res
     }
 
-    #[expect(clippy::similar_names, clippy::too_many_lines)]
+    #[expect(clippy::too_many_lines)]
     pub fn eq_expr(&mut self, left: &Expr<'_>, right: &Expr<'_>) -> bool {
         if !self.check_ctxt(left.span.ctxt(), right.span.ctxt()) {
             return false;
@@ -463,7 +462,6 @@ impl HirEqInterExpr<'_, '_, '_> {
         }
     }
 
-    #[expect(clippy::similar_names)]
     fn eq_qpath(&mut self, left: &QPath<'_>, right: &QPath<'_>) -> bool {
         match (left, right) {
             (&QPath::Resolved(ref lty, lpath), &QPath::Resolved(ref rty, rpath)) => {
@@ -1158,7 +1156,6 @@ pub fn hash_expr(cx: &LateContext<'_>, e: &Expr<'_>) -> u64 {
     h.finish()
 }
 
-#[expect(clippy::similar_names)]
 fn eq_span_tokens(
     cx: &LateContext<'_>,
     left: impl SpanRange,
diff --git a/clippy_utils/src/qualify_min_const_fn.rs b/clippy_utils/src/qualify_min_const_fn.rs
index 81f4fcc2133..41f52ce8895 100644
--- a/clippy_utils/src/qualify_min_const_fn.rs
+++ b/clippy_utils/src/qualify_min_const_fn.rs
@@ -389,7 +389,6 @@ fn is_const_fn(tcx: TyCtxt<'_>, def_id: DefId, msrv: &Msrv) -> bool {
         })
 }
 
-#[expect(clippy::similar_names)] // bit too pedantic
 fn is_ty_const_destruct<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>, body: &Body<'tcx>) -> bool {
     // FIXME(effects, fee1-dead) revert to const destruct once it works again
     #[expect(unused)]
diff --git a/tests/ui/approx_const.rs b/tests/ui/approx_const.rs
index 2c3e0978c52..3c4ed036789 100644
--- a/tests/ui/approx_const.rs
+++ b/tests/ui/approx_const.rs
@@ -1,5 +1,4 @@
 #[warn(clippy::approx_constant)]
-#[allow(clippy::similar_names)]
 fn main() {
     let my_e = 2.7182;
     //~^ ERROR: approximate value of `f{32, 64}::consts::E` found
diff --git a/tests/ui/approx_const.stderr b/tests/ui/approx_const.stderr
index 4b5cd2a7a62..cb530eaf734 100644
--- a/tests/ui/approx_const.stderr
+++ b/tests/ui/approx_const.stderr
@@ -1,5 +1,5 @@
 error: approximate value of `f{32, 64}::consts::E` found
-  --> $DIR/approx_const.rs:4:16
+  --> $DIR/approx_const.rs:3:16
    |
 LL |     let my_e = 2.7182;
    |                ^^^^^^
@@ -9,7 +9,7 @@ LL |     let my_e = 2.7182;
    = help: to override `-D warnings` add `#[allow(clippy::approx_constant)]`
 
 error: approximate value of `f{32, 64}::consts::E` found
-  --> $DIR/approx_const.rs:6:20
+  --> $DIR/approx_const.rs:5:20
    |
 LL |     let almost_e = 2.718;
    |                    ^^^^^
@@ -17,7 +17,7 @@ LL |     let almost_e = 2.718;
    = help: consider using the constant directly
 
 error: approximate value of `f{32, 64}::consts::FRAC_1_PI` found
-  --> $DIR/approx_const.rs:10:24
+  --> $DIR/approx_const.rs:9:24
    |
 LL |     let my_1_frac_pi = 0.3183;
    |                        ^^^^^^
@@ -25,7 +25,7 @@ LL |     let my_1_frac_pi = 0.3183;
    = help: consider using the constant directly
 
 error: approximate value of `f{32, 64}::consts::FRAC_1_SQRT_2` found
-  --> $DIR/approx_const.rs:14:28
+  --> $DIR/approx_const.rs:13:28
    |
 LL |     let my_frac_1_sqrt_2 = 0.70710678;
    |                            ^^^^^^^^^^
@@ -33,7 +33,7 @@ LL |     let my_frac_1_sqrt_2 = 0.70710678;
    = help: consider using the constant directly
 
 error: approximate value of `f{32, 64}::consts::FRAC_1_SQRT_2` found
-  --> $DIR/approx_const.rs:16:32
+  --> $DIR/approx_const.rs:15:32
    |
 LL |     let almost_frac_1_sqrt_2 = 0.70711;
    |                                ^^^^^^^
@@ -41,7 +41,7 @@ LL |     let almost_frac_1_sqrt_2 = 0.70711;
    = help: consider using the constant directly
 
 error: approximate value of `f{32, 64}::consts::FRAC_2_PI` found
-  --> $DIR/approx_const.rs:20:24
+  --> $DIR/approx_const.rs:19:24
    |
 LL |     let my_frac_2_pi = 0.63661977;
    |                        ^^^^^^^^^^
@@ -49,7 +49,7 @@ LL |     let my_frac_2_pi = 0.63661977;
    = help: consider using the constant directly
 
 error: approximate value of `f{32, 64}::consts::FRAC_2_SQRT_PI` found
-  --> $DIR/approx_const.rs:24:27
+  --> $DIR/approx_const.rs:23:27
    |
 LL |     let my_frac_2_sq_pi = 1.128379;
    |                           ^^^^^^^^
@@ -57,7 +57,7 @@ LL |     let my_frac_2_sq_pi = 1.128379;
    = help: consider using the constant directly
 
 error: approximate value of `f{32, 64}::consts::FRAC_PI_2` found
-  --> $DIR/approx_const.rs:28:24
+  --> $DIR/approx_const.rs:27:24
    |
 LL |     let my_frac_pi_2 = 1.57079632679;
    |                        ^^^^^^^^^^^^^
@@ -65,7 +65,7 @@ LL |     let my_frac_pi_2 = 1.57079632679;
    = help: consider using the constant directly
 
 error: approximate value of `f{32, 64}::consts::FRAC_PI_3` found
-  --> $DIR/approx_const.rs:32:24
+  --> $DIR/approx_const.rs:31:24
    |
 LL |     let my_frac_pi_3 = 1.04719755119;
    |                        ^^^^^^^^^^^^^
@@ -73,7 +73,7 @@ LL |     let my_frac_pi_3 = 1.04719755119;
    = help: consider using the constant directly
 
 error: approximate value of `f{32, 64}::consts::FRAC_PI_4` found
-  --> $DIR/approx_const.rs:36:24
+  --> $DIR/approx_const.rs:35:24
    |
 LL |     let my_frac_pi_4 = 0.785398163397;
    |                        ^^^^^^^^^^^^^^
@@ -81,7 +81,7 @@ LL |     let my_frac_pi_4 = 0.785398163397;
    = help: consider using the constant directly
 
 error: approximate value of `f{32, 64}::consts::FRAC_PI_6` found
-  --> $DIR/approx_const.rs:40:24
+  --> $DIR/approx_const.rs:39:24
    |
 LL |     let my_frac_pi_6 = 0.523598775598;
    |                        ^^^^^^^^^^^^^^
@@ -89,7 +89,7 @@ LL |     let my_frac_pi_6 = 0.523598775598;
    = help: consider using the constant directly
 
 error: approximate value of `f{32, 64}::consts::FRAC_PI_8` found
-  --> $DIR/approx_const.rs:44:24
+  --> $DIR/approx_const.rs:43:24
    |
 LL |     let my_frac_pi_8 = 0.3926990816987;
    |                        ^^^^^^^^^^^^^^^
@@ -97,7 +97,7 @@ LL |     let my_frac_pi_8 = 0.3926990816987;
    = help: consider using the constant directly
 
 error: approximate value of `f{32, 64}::consts::LN_10` found
-  --> $DIR/approx_const.rs:48:20
+  --> $DIR/approx_const.rs:47:20
    |
 LL |     let my_ln_10 = 2.302585092994046;
    |                    ^^^^^^^^^^^^^^^^^
@@ -105,7 +105,7 @@ LL |     let my_ln_10 = 2.302585092994046;
    = help: consider using the constant directly
 
 error: approximate value of `f{32, 64}::consts::LN_2` found
-  --> $DIR/approx_const.rs:52:19
+  --> $DIR/approx_const.rs:51:19
    |
 LL |     let my_ln_2 = 0.6931471805599453;
    |                   ^^^^^^^^^^^^^^^^^^
@@ -113,7 +113,7 @@ LL |     let my_ln_2 = 0.6931471805599453;
    = help: consider using the constant directly
 
 error: approximate value of `f{32, 64}::consts::LOG10_E` found
-  --> $DIR/approx_const.rs:56:22
+  --> $DIR/approx_const.rs:55:22
    |
 LL |     let my_log10_e = 0.4342944819032518;
    |                      ^^^^^^^^^^^^^^^^^^
@@ -121,7 +121,7 @@ LL |     let my_log10_e = 0.4342944819032518;
    = help: consider using the constant directly
 
 error: approximate value of `f{32, 64}::consts::LOG2_E` found
-  --> $DIR/approx_const.rs:60:21
+  --> $DIR/approx_const.rs:59:21
    |
 LL |     let my_log2_e = 1.4426950408889634;
    |                     ^^^^^^^^^^^^^^^^^^
@@ -129,7 +129,7 @@ LL |     let my_log2_e = 1.4426950408889634;
    = help: consider using the constant directly
 
 error: approximate value of `f{32, 64}::consts::LOG2_10` found
-  --> $DIR/approx_const.rs:64:19
+  --> $DIR/approx_const.rs:63:19
    |
 LL |     let log2_10 = 3.321928094887362;
    |                   ^^^^^^^^^^^^^^^^^
@@ -137,7 +137,7 @@ LL |     let log2_10 = 3.321928094887362;
    = help: consider using the constant directly
 
 error: approximate value of `f{32, 64}::consts::LOG10_2` found
-  --> $DIR/approx_const.rs:68:19
+  --> $DIR/approx_const.rs:67:19
    |
 LL |     let log10_2 = 0.301029995663981;
    |                   ^^^^^^^^^^^^^^^^^
@@ -145,7 +145,7 @@ LL |     let log10_2 = 0.301029995663981;
    = help: consider using the constant directly
 
 error: approximate value of `f{32, 64}::consts::PI` found
-  --> $DIR/approx_const.rs:72:17
+  --> $DIR/approx_const.rs:71:17
    |
 LL |     let my_pi = 3.1415;
    |                 ^^^^^^
@@ -153,7 +153,7 @@ LL |     let my_pi = 3.1415;
    = help: consider using the constant directly
 
 error: approximate value of `f{32, 64}::consts::PI` found
-  --> $DIR/approx_const.rs:74:21
+  --> $DIR/approx_const.rs:73:21
    |
 LL |     let almost_pi = 3.14;
    |                     ^^^^
@@ -161,7 +161,7 @@ LL |     let almost_pi = 3.14;
    = help: consider using the constant directly
 
 error: approximate value of `f{32, 64}::consts::SQRT_2` found
-  --> $DIR/approx_const.rs:78:18
+  --> $DIR/approx_const.rs:77:18
    |
 LL |     let my_sq2 = 1.4142;
    |                  ^^^^^^
@@ -169,7 +169,7 @@ LL |     let my_sq2 = 1.4142;
    = help: consider using the constant directly
 
 error: approximate value of `f{32, 64}::consts::TAU` found
-  --> $DIR/approx_const.rs:82:18
+  --> $DIR/approx_const.rs:81:18
    |
 LL |     let my_tau = 6.2832;
    |                  ^^^^^^
@@ -177,7 +177,7 @@ LL |     let my_tau = 6.2832;
    = help: consider using the constant directly
 
 error: approximate value of `f{32, 64}::consts::TAU` found
-  --> $DIR/approx_const.rs:84:22
+  --> $DIR/approx_const.rs:83:22
    |
 LL |     let almost_tau = 6.28;
    |                      ^^^^
-- 
cgit 1.4.1-3-g733a5


From 9012d55c022e55bc154e023cb802c5083e905369 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sat, 10 Feb 2024 09:35:29 -0500
Subject: Don't lint `incompatible_msrv` in test code

---
 clippy_lints/src/incompatible_msrv.rs | 11 ++++++-----
 tests/ui/incompatible_msrv.rs         |  5 +++++
 2 files changed, 11 insertions(+), 5 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/incompatible_msrv.rs b/clippy_lints/src/incompatible_msrv.rs
index f2f0e7d4266..475938d6adf 100644
--- a/clippy_lints/src/incompatible_msrv.rs
+++ b/clippy_lints/src/incompatible_msrv.rs
@@ -1,8 +1,9 @@
 use clippy_config::msrvs::Msrv;
 use clippy_utils::diagnostics::span_lint;
+use clippy_utils::is_in_test_function;
 use rustc_attr::{StabilityLevel, StableSince};
 use rustc_data_structures::fx::FxHashMap;
-use rustc_hir::{Expr, ExprKind};
+use rustc_hir::{Expr, ExprKind, HirId};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::TyCtxt;
 use rustc_semver::RustcVersion;
@@ -81,13 +82,13 @@ impl IncompatibleMsrv {
         version
     }
 
-    fn emit_lint_if_under_msrv(&mut self, cx: &LateContext<'_>, def_id: DefId, span: Span) {
+    fn emit_lint_if_under_msrv(&mut self, cx: &LateContext<'_>, def_id: DefId, node: HirId, span: Span) {
         if def_id.is_local() {
             // We don't check local items since their MSRV is supposed to always be valid.
             return;
         }
         let version = self.get_def_id_version(cx.tcx, def_id);
-        if self.msrv.meets(version) {
+        if self.msrv.meets(version) || is_in_test_function(cx.tcx, node) {
             return;
         }
         self.emit_lint_for(cx, span, version);
@@ -117,14 +118,14 @@ impl<'tcx> LateLintPass<'tcx> for IncompatibleMsrv {
         match expr.kind {
             ExprKind::MethodCall(_, _, _, span) => {
                 if let Some(method_did) = cx.typeck_results().type_dependent_def_id(expr.hir_id) {
-                    self.emit_lint_if_under_msrv(cx, method_did, span);
+                    self.emit_lint_if_under_msrv(cx, method_did, expr.hir_id, span);
                 }
             },
             ExprKind::Call(call, [_]) => {
                 if let ExprKind::Path(qpath) = call.kind
                     && let Some(path_def_id) = cx.qpath_res(&qpath, call.hir_id).opt_def_id()
                 {
-                    self.emit_lint_if_under_msrv(cx, path_def_id, call.span);
+                    self.emit_lint_if_under_msrv(cx, path_def_id, expr.hir_id, call.span);
                 }
             },
             _ => {},
diff --git a/tests/ui/incompatible_msrv.rs b/tests/ui/incompatible_msrv.rs
index a92017fb0f6..0fa047c7102 100644
--- a/tests/ui/incompatible_msrv.rs
+++ b/tests/ui/incompatible_msrv.rs
@@ -20,4 +20,9 @@ fn foo() {
     //~^ ERROR: is `1.3.0` but this item is stable since `1.4.0`
 }
 
+#[test]
+fn test() {
+    sleep(Duration::new(1, 0));
+}
+
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From b3b9919d1b4b321b0a9b7955ee06b9ecb755ce7e Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Sat, 10 Feb 2024 17:37:51 +0100
Subject: [`to_string_trait_impl`]: take specialization into account

---
 clippy_lints/src/to_string_trait_impl.rs |  3 +++
 tests/ui/to_string_trait_impl.rs         | 44 ++++++++++++++++++++++++++++++++
 tests/ui/to_string_trait_impl.stderr     | 16 ++++++++++--
 3 files changed, 61 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/to_string_trait_impl.rs b/clippy_lints/src/to_string_trait_impl.rs
index e1cea99085f..59ae185c9de 100644
--- a/clippy_lints/src/to_string_trait_impl.rs
+++ b/clippy_lints/src/to_string_trait_impl.rs
@@ -1,4 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::ty::implements_trait;
 use rustc_hir::{Impl, Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::declare_lint_pass;
@@ -53,6 +54,8 @@ impl<'tcx> LateLintPass<'tcx> for ToStringTraitImpl {
         }) = it.kind
             && let Some(trait_did) = trait_ref.trait_def_id()
             && cx.tcx.is_diagnostic_item(sym::ToString, trait_did)
+            && let Some(display_did) = cx.tcx.get_diagnostic_item(sym::Display)
+            && !implements_trait(cx, cx.tcx.type_of(it.owner_id).instantiate_identity(), display_did, &[])
         {
             span_lint_and_help(
                 cx,
diff --git a/tests/ui/to_string_trait_impl.rs b/tests/ui/to_string_trait_impl.rs
index b0731632d45..4c1202d4203 100644
--- a/tests/ui/to_string_trait_impl.rs
+++ b/tests/ui/to_string_trait_impl.rs
@@ -1,4 +1,5 @@
 #![warn(clippy::to_string_trait_impl)]
+#![feature(min_specialization)]
 
 use std::fmt::{self, Display};
 
@@ -29,3 +30,46 @@ impl Bar {
         String::from("Bar")
     }
 }
+
+mod issue12263 {
+    pub struct MyStringWrapper<'a>(&'a str);
+
+    impl std::fmt::Display for MyStringWrapper<'_> {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            self.0.fmt(f)
+        }
+    }
+
+    impl ToString for MyStringWrapper<'_> {
+        fn to_string(&self) -> String {
+            self.0.to_string()
+        }
+    }
+
+    pub struct S<T>(T);
+    impl std::fmt::Display for S<String> {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            todo!()
+        }
+    }
+    // no specialization if the generics differ, so lint
+    impl ToString for S<i32> {
+        fn to_string(&self) -> String {
+            todo!()
+        }
+    }
+
+    pub struct S2<T>(T);
+    impl std::fmt::Display for S2<String> {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            todo!()
+        }
+    }
+
+    // also specialization if the generics don't differ
+    impl ToString for S2<String> {
+        fn to_string(&self) -> String {
+            todo!()
+        }
+    }
+}
diff --git a/tests/ui/to_string_trait_impl.stderr b/tests/ui/to_string_trait_impl.stderr
index 55fa9f12c0e..0051ea25ae0 100644
--- a/tests/ui/to_string_trait_impl.stderr
+++ b/tests/ui/to_string_trait_impl.stderr
@@ -1,5 +1,5 @@
 error: direct implementation of `ToString`
-  --> $DIR/to_string_trait_impl.rs:10:1
+  --> $DIR/to_string_trait_impl.rs:11:1
    |
 LL | / impl ToString for Point {
 LL | |     fn to_string(&self) -> String {
@@ -12,5 +12,17 @@ LL | | }
    = note: `-D clippy::to-string-trait-impl` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::to_string_trait_impl)]`
 
-error: aborting due to 1 previous error
+error: direct implementation of `ToString`
+  --> $DIR/to_string_trait_impl.rs:56:5
+   |
+LL | /     impl ToString for S<i32> {
+LL | |         fn to_string(&self) -> String {
+LL | |             todo!()
+LL | |         }
+LL | |     }
+   | |_____^
+   |
+   = help: prefer implementing `Display` instead
+
+error: aborting due to 2 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From c4d11083d9ee8efb873cff069b0282be68a37ab2 Mon Sep 17 00:00:00 2001
From: granddaifuku <daifukuformac@gmail.com>
Date: Sun, 11 Feb 2024 03:51:26 +0900
Subject: fix: ICE when array index exceeds usize

---
 clippy_lints/src/indexing_slicing.rs | 1 +
 tests/ui/crashes/ice-12253.rs        | 5 +++++
 2 files changed, 6 insertions(+)
 create mode 100644 tests/ui/crashes/ice-12253.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/indexing_slicing.rs b/clippy_lints/src/indexing_slicing.rs
index 391db0b0df7..35fcd8cdd35 100644
--- a/clippy_lints/src/indexing_slicing.rs
+++ b/clippy_lints/src/indexing_slicing.rs
@@ -174,6 +174,7 @@ impl<'tcx> LateLintPass<'tcx> for IndexingSlicing {
                         // only `usize` index is legal in rust array index
                         // leave other type to rustc
                         if let Constant::Int(off) = constant
+                            && off <= usize::MAX as u128
                             && let ty::Uint(utype) = cx.typeck_results().expr_ty(index).kind()
                             && *utype == ty::UintTy::Usize
                             && let ty::Array(_, s) = ty.kind()
diff --git a/tests/ui/crashes/ice-12253.rs b/tests/ui/crashes/ice-12253.rs
new file mode 100644
index 00000000000..41f50035144
--- /dev/null
+++ b/tests/ui/crashes/ice-12253.rs
@@ -0,0 +1,5 @@
+#[allow(overflowing_literals, unconditional_panic, clippy::no_effect)]
+fn main() {
+    let arr: [i32; 5] = [0; 5];
+    arr[0xfffffe7ffffffffffffffffffffffff];
+}
-- 
cgit 1.4.1-3-g733a5


From ac7c6e54176a7e7d987b8c5d48716267a964e839 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sat, 10 Feb 2024 16:10:05 -0500
Subject: Don't allow derive macros to silence `disallowed_macros` for their
 own call.

---
 clippy_lints/src/disallowed_macros.rs              | 84 ++++++++++++++--------
 .../disallowed_macros/auxiliary/proc_macros.rs     | 29 ++++++++
 tests/ui-toml/disallowed_macros/clippy.toml        |  1 +
 .../ui-toml/disallowed_macros/disallowed_macros.rs |  6 ++
 .../disallowed_macros/disallowed_macros.stderr     | 38 +++++-----
 5 files changed, 112 insertions(+), 46 deletions(-)
 create mode 100644 tests/ui-toml/disallowed_macros/auxiliary/proc_macros.rs

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/disallowed_macros.rs b/clippy_lints/src/disallowed_macros.rs
index 656b3d9bfaf..4652cec722e 100644
--- a/clippy_lints/src/disallowed_macros.rs
+++ b/clippy_lints/src/disallowed_macros.rs
@@ -1,13 +1,16 @@
 use clippy_config::types::DisallowedPath;
-use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::diagnostics::{span_lint_and_then, span_lint_hir_and_then};
 use clippy_utils::macros::macro_backtrace;
 use rustc_ast::Attribute;
 use rustc_data_structures::fx::FxHashSet;
+use rustc_errors::Diagnostic;
 use rustc_hir::def_id::DefIdMap;
-use rustc_hir::{Expr, ExprKind, ForeignItem, HirId, ImplItem, Item, Pat, Path, Stmt, TraitItem, Ty};
+use rustc_hir::{
+    Expr, ExprKind, ForeignItem, HirId, ImplItem, Item, ItemKind, OwnerId, Pat, Path, Stmt, TraitItem, Ty,
+};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::impl_lint_pass;
-use rustc_span::{ExpnId, Span};
+use rustc_span::{ExpnId, MacroKind, Span};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -57,6 +60,10 @@ pub struct DisallowedMacros {
     conf_disallowed: Vec<DisallowedPath>,
     disallowed: DefIdMap<usize>,
     seen: FxHashSet<ExpnId>,
+
+    // Track the most recently seen node that can have a `derive` attribute.
+    // Needed to use the correct lint level.
+    derive_src: Option<OwnerId>,
 }
 
 impl DisallowedMacros {
@@ -65,10 +72,11 @@ impl DisallowedMacros {
             conf_disallowed,
             disallowed: DefIdMap::default(),
             seen: FxHashSet::default(),
+            derive_src: None,
         }
     }
 
-    fn check(&mut self, cx: &LateContext<'_>, span: Span) {
+    fn check(&mut self, cx: &LateContext<'_>, span: Span, derive_src: Option<OwnerId>) {
         if self.conf_disallowed.is_empty() {
             return;
         }
@@ -80,18 +88,26 @@ impl DisallowedMacros {
 
             if let Some(&index) = self.disallowed.get(&mac.def_id) {
                 let conf = &self.conf_disallowed[index];
-
-                span_lint_and_then(
-                    cx,
-                    DISALLOWED_MACROS,
-                    mac.span,
-                    &format!("use of a disallowed macro `{}`", conf.path()),
-                    |diag| {
-                        if let Some(reason) = conf.reason() {
-                            diag.note(reason);
-                        }
-                    },
-                );
+                let msg = format!("use of a disallowed macro `{}`", conf.path());
+                let add_note = |diag: &mut Diagnostic| {
+                    if let Some(reason) = conf.reason() {
+                        diag.note(reason);
+                    }
+                };
+                if matches!(mac.kind, MacroKind::Derive)
+                    && let Some(derive_src) = derive_src
+                {
+                    span_lint_hir_and_then(
+                        cx,
+                        DISALLOWED_MACROS,
+                        cx.tcx.local_def_id_to_hir_id(derive_src.def_id),
+                        mac.span,
+                        &msg,
+                        add_note,
+                    );
+                } else {
+                    span_lint_and_then(cx, DISALLOWED_MACROS, mac.span, &msg, add_note);
+                }
             }
         }
     }
@@ -110,49 +126,57 @@ impl LateLintPass<'_> for DisallowedMacros {
     }
 
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
-        self.check(cx, expr.span);
+        self.check(cx, expr.span, None);
         // `$t + $t` can have the context of $t, check also the span of the binary operator
         if let ExprKind::Binary(op, ..) = expr.kind {
-            self.check(cx, op.span);
+            self.check(cx, op.span, None);
         }
     }
 
     fn check_stmt(&mut self, cx: &LateContext<'_>, stmt: &Stmt<'_>) {
-        self.check(cx, stmt.span);
+        self.check(cx, stmt.span, None);
     }
 
     fn check_ty(&mut self, cx: &LateContext<'_>, ty: &Ty<'_>) {
-        self.check(cx, ty.span);
+        self.check(cx, ty.span, None);
     }
 
     fn check_pat(&mut self, cx: &LateContext<'_>, pat: &Pat<'_>) {
-        self.check(cx, pat.span);
+        self.check(cx, pat.span, None);
     }
 
     fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
-        self.check(cx, item.span);
-        self.check(cx, item.vis_span);
+        self.check(cx, item.span, self.derive_src);
+        self.check(cx, item.vis_span, None);
+
+        if matches!(
+            item.kind,
+            ItemKind::Struct(..) | ItemKind::Enum(..) | ItemKind::Union(..)
+        ) && macro_backtrace(item.span).all(|m| !matches!(m.kind, MacroKind::Derive))
+        {
+            self.derive_src = Some(item.owner_id);
+        }
     }
 
     fn check_foreign_item(&mut self, cx: &LateContext<'_>, item: &ForeignItem<'_>) {
-        self.check(cx, item.span);
-        self.check(cx, item.vis_span);
+        self.check(cx, item.span, None);
+        self.check(cx, item.vis_span, None);
     }
 
     fn check_impl_item(&mut self, cx: &LateContext<'_>, item: &ImplItem<'_>) {
-        self.check(cx, item.span);
-        self.check(cx, item.vis_span);
+        self.check(cx, item.span, None);
+        self.check(cx, item.vis_span, None);
     }
 
     fn check_trait_item(&mut self, cx: &LateContext<'_>, item: &TraitItem<'_>) {
-        self.check(cx, item.span);
+        self.check(cx, item.span, None);
     }
 
     fn check_path(&mut self, cx: &LateContext<'_>, path: &Path<'_>, _: HirId) {
-        self.check(cx, path.span);
+        self.check(cx, path.span, None);
     }
 
     fn check_attribute(&mut self, cx: &LateContext<'_>, attr: &Attribute) {
-        self.check(cx, attr.span);
+        self.check(cx, attr.span, self.derive_src);
     }
 }
diff --git a/tests/ui-toml/disallowed_macros/auxiliary/proc_macros.rs b/tests/ui-toml/disallowed_macros/auxiliary/proc_macros.rs
new file mode 100644
index 00000000000..dbfce16858a
--- /dev/null
+++ b/tests/ui-toml/disallowed_macros/auxiliary/proc_macros.rs
@@ -0,0 +1,29 @@
+extern crate proc_macro;
+use proc_macro::Delimiter::{Brace, Bracket, Parenthesis};
+use proc_macro::Spacing::{Alone, Joint};
+use proc_macro::{Group, Ident, Punct, Span, TokenStream, TokenTree as TT};
+
+#[proc_macro_derive(Derive)]
+pub fn derive(_: TokenStream) -> TokenStream {
+    TokenStream::from_iter([
+        TT::from(Punct::new('#', Alone)),
+        TT::from(Group::new(
+            Bracket,
+            TokenStream::from_iter([
+                TT::from(Ident::new("allow", Span::call_site())),
+                TT::from(Group::new(
+                    Parenthesis,
+                    TokenStream::from_iter([
+                        TT::from(Ident::new("clippy", Span::call_site())),
+                        TT::from(Punct::new(':', Joint)),
+                        TT::from(Punct::new(':', Alone)),
+                        TT::from(Ident::new("disallowed_macros", Span::call_site())),
+                    ]),
+                )),
+            ]),
+        )),
+        TT::from(Ident::new("impl", Span::call_site())),
+        TT::from(Ident::new("Foo", Span::call_site())),
+        TT::from(Group::new(Brace, TokenStream::new())),
+    ])
+}
diff --git a/tests/ui-toml/disallowed_macros/clippy.toml b/tests/ui-toml/disallowed_macros/clippy.toml
index 85f1b71eb66..8b4f3b713bb 100644
--- a/tests/ui-toml/disallowed_macros/clippy.toml
+++ b/tests/ui-toml/disallowed_macros/clippy.toml
@@ -10,4 +10,5 @@ disallowed-macros = [
     "macros::item",
     "macros::binop",
     "macros::attr",
+    "proc_macros::Derive",
 ]
diff --git a/tests/ui-toml/disallowed_macros/disallowed_macros.rs b/tests/ui-toml/disallowed_macros/disallowed_macros.rs
index 4a3d55e13c9..e63a99e74cb 100644
--- a/tests/ui-toml/disallowed_macros/disallowed_macros.rs
+++ b/tests/ui-toml/disallowed_macros/disallowed_macros.rs
@@ -1,9 +1,12 @@
 //@aux-build:macros.rs
+//@aux-build:proc_macros.rs
 
 #![allow(unused)]
 
 extern crate macros;
+extern crate proc_macros;
 
+use proc_macros::Derive;
 use serde::Serialize;
 
 fn main() {
@@ -40,3 +43,6 @@ trait Y {
 impl Y for S {
     macros::item!();
 }
+
+#[derive(Derive)]
+struct Foo;
diff --git a/tests/ui-toml/disallowed_macros/disallowed_macros.stderr b/tests/ui-toml/disallowed_macros/disallowed_macros.stderr
index 3c6f59b16e7..986a7b171c4 100644
--- a/tests/ui-toml/disallowed_macros/disallowed_macros.stderr
+++ b/tests/ui-toml/disallowed_macros/disallowed_macros.stderr
@@ -1,5 +1,5 @@
 error: use of a disallowed macro `std::println`
-  --> $DIR/disallowed_macros.rs:10:5
+  --> $DIR/disallowed_macros.rs:13:5
    |
 LL |     println!("one");
    |     ^^^^^^^^^^^^^^^
@@ -8,25 +8,25 @@ LL |     println!("one");
    = help: to override `-D warnings` add `#[allow(clippy::disallowed_macros)]`
 
 error: use of a disallowed macro `std::println`
-  --> $DIR/disallowed_macros.rs:11:5
+  --> $DIR/disallowed_macros.rs:14:5
    |
 LL |     println!("two");
    |     ^^^^^^^^^^^^^^^
 
 error: use of a disallowed macro `std::cfg`
-  --> $DIR/disallowed_macros.rs:12:5
+  --> $DIR/disallowed_macros.rs:15:5
    |
 LL |     cfg!(unix);
    |     ^^^^^^^^^^
 
 error: use of a disallowed macro `std::vec`
-  --> $DIR/disallowed_macros.rs:13:5
+  --> $DIR/disallowed_macros.rs:16:5
    |
 LL |     vec![1, 2, 3];
    |     ^^^^^^^^^^^^^
 
 error: use of a disallowed macro `serde::Serialize`
-  --> $DIR/disallowed_macros.rs:15:14
+  --> $DIR/disallowed_macros.rs:18:14
    |
 LL |     #[derive(Serialize)]
    |              ^^^^^^^^^
@@ -34,43 +34,43 @@ LL |     #[derive(Serialize)]
    = note: no serializing (from clippy.toml)
 
 error: use of a disallowed macro `macros::expr`
-  --> $DIR/disallowed_macros.rs:18:13
+  --> $DIR/disallowed_macros.rs:21:13
    |
 LL |     let _ = macros::expr!();
    |             ^^^^^^^^^^^^^^^
 
 error: use of a disallowed macro `macros::stmt`
-  --> $DIR/disallowed_macros.rs:19:5
+  --> $DIR/disallowed_macros.rs:22:5
    |
 LL |     macros::stmt!();
    |     ^^^^^^^^^^^^^^^
 
 error: use of a disallowed macro `macros::pat`
-  --> $DIR/disallowed_macros.rs:20:9
+  --> $DIR/disallowed_macros.rs:23:9
    |
 LL |     let macros::pat!() = 1;
    |         ^^^^^^^^^^^^^^
 
 error: use of a disallowed macro `macros::ty`
-  --> $DIR/disallowed_macros.rs:21:12
+  --> $DIR/disallowed_macros.rs:24:12
    |
 LL |     let _: macros::ty!() = "";
    |            ^^^^^^^^^^^^^
 
 error: use of a disallowed macro `macros::item`
-  --> $DIR/disallowed_macros.rs:22:5
+  --> $DIR/disallowed_macros.rs:25:5
    |
 LL |     macros::item!();
    |     ^^^^^^^^^^^^^^^
 
 error: use of a disallowed macro `macros::binop`
-  --> $DIR/disallowed_macros.rs:23:13
+  --> $DIR/disallowed_macros.rs:26:13
    |
 LL |     let _ = macros::binop!(1);
    |             ^^^^^^^^^^^^^^^^^
 
 error: use of a disallowed macro `macros::attr`
-  --> $DIR/disallowed_macros.rs:28:1
+  --> $DIR/disallowed_macros.rs:31:1
    |
 LL | / macros::attr! {
 LL | |     struct S;
@@ -78,22 +78,28 @@ LL | | }
    | |_^
 
 error: use of a disallowed macro `macros::item`
-  --> $DIR/disallowed_macros.rs:33:5
+  --> $DIR/disallowed_macros.rs:36:5
    |
 LL |     macros::item!();
    |     ^^^^^^^^^^^^^^^
 
 error: use of a disallowed macro `macros::item`
-  --> $DIR/disallowed_macros.rs:37:5
+  --> $DIR/disallowed_macros.rs:40:5
    |
 LL |     macros::item!();
    |     ^^^^^^^^^^^^^^^
 
 error: use of a disallowed macro `macros::item`
-  --> $DIR/disallowed_macros.rs:41:5
+  --> $DIR/disallowed_macros.rs:44:5
    |
 LL |     macros::item!();
    |     ^^^^^^^^^^^^^^^
 
-error: aborting due to 15 previous errors
+error: use of a disallowed macro `proc_macros::Derive`
+  --> $DIR/disallowed_macros.rs:47:10
+   |
+LL | #[derive(Derive)]
+   |          ^^^^^^
+
+error: aborting due to 16 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From d1acbf576e704dca5da757dabfe49248028ff18c Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Sun, 11 Feb 2024 00:17:21 +0100
Subject: extract supertrait collection to separate function

---
 clippy_lints/src/implied_bounds_in_impls.rs | 156 ++++++++++++++--------------
 1 file changed, 80 insertions(+), 76 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/implied_bounds_in_impls.rs b/clippy_lints/src/implied_bounds_in_impls.rs
index fab8ffedb94..3527a39e2da 100644
--- a/clippy_lints/src/implied_bounds_in_impls.rs
+++ b/clippy_lints/src/implied_bounds_in_impls.rs
@@ -1,16 +1,17 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet;
 use rustc_errors::{Applicability, SuggestionStyle};
-use rustc_hir::def_id::{DefId, LocalDefId};
+use rustc_hir::def_id::DefId;
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::{
-    Body, FnDecl, FnRetTy, GenericArg, GenericBound, ImplItem, ImplItemKind, ItemKind, TraitBoundModifier, TraitItem,
-    TraitItemKind, TyKind,
+    Body, FnDecl, FnRetTy, GenericArg, GenericBound, ImplItem, ImplItemKind, ItemKind, OpaqueTy, TraitBoundModifier,
+    TraitItem, TraitItemKind, TyKind, TypeBinding,
 };
 use rustc_hir_analysis::hir_ty_to_ty;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{self, ClauseKind, Generics, Ty, TyCtxt};
 use rustc_session::declare_lint_pass;
+use rustc_span::def_id::LocalDefId;
 use rustc_span::Span;
 
 declare_clippy_lint! {
@@ -50,20 +51,17 @@ declare_clippy_lint! {
 }
 declare_lint_pass!(ImpliedBoundsInImpls => [IMPLIED_BOUNDS_IN_IMPLS]);
 
-#[allow(clippy::too_many_arguments)]
 fn emit_lint(
     cx: &LateContext<'_>,
     poly_trait: &rustc_hir::PolyTraitRef<'_>,
     opaque_ty: &rustc_hir::OpaqueTy<'_>,
     index: usize,
-    // The bindings that were implied
+    // The bindings that were implied, used for suggestion purposes since removing a bound with associated types
+    // means we might need to then move it to a different bound
     implied_bindings: &[rustc_hir::TypeBinding<'_>],
-    // The original bindings that `implied_bindings` are implied from
-    implied_by_bindings: &[rustc_hir::TypeBinding<'_>],
-    implied_by_args: &[GenericArg<'_>],
-    implied_by_span: Span,
+    bound: &ImplTraitBound<'_>,
 ) {
-    let implied_by = snippet(cx, implied_by_span, "..");
+    let implied_by = snippet(cx, bound.impl_trait_bound_span, "..");
 
     span_lint_and_then(
         cx,
@@ -93,17 +91,17 @@ fn emit_lint(
             // If we're going to suggest removing `Deref<..>`, we'll need to put `<Target = u8>` on `DerefMut`
             let omitted_assoc_tys: Vec<_> = implied_bindings
                 .iter()
-                .filter(|binding| !implied_by_bindings.iter().any(|b| b.ident == binding.ident))
+                .filter(|binding| !bound.bindings.iter().any(|b| b.ident == binding.ident))
                 .collect();
 
             if !omitted_assoc_tys.is_empty() {
                 // `<>` needs to be added if there aren't yet any generic arguments or bindings
-                let needs_angle_brackets = implied_by_args.is_empty() && implied_by_bindings.is_empty();
-                let insert_span = match (implied_by_args, implied_by_bindings) {
+                let needs_angle_brackets = bound.args.is_empty() && bound.bindings.is_empty();
+                let insert_span = match (bound.args, bound.bindings) {
                     ([.., arg], [.., binding]) => arg.span().max(binding.span).shrink_to_hi(),
                     ([.., arg], []) => arg.span().shrink_to_hi(),
                     ([], [.., binding]) => binding.span.shrink_to_hi(),
-                    ([], []) => implied_by_span.shrink_to_hi(),
+                    ([], []) => bound.impl_trait_bound_span.shrink_to_hi(),
                 };
 
                 let mut associated_tys_sugg = if needs_angle_brackets {
@@ -223,42 +221,64 @@ fn is_same_generics<'tcx>(
         })
 }
 
+struct ImplTraitBound<'tcx> {
+    /// The span of the bound in the `impl Trait` type
+    impl_trait_bound_span: Span,
+    /// The predicates defined in the trait referenced by this bound
+    predicates: &'tcx [(ty::Clause<'tcx>, Span)],
+    /// The `DefId` of the trait being referenced by this bound
+    trait_def_id: DefId,
+    /// The generic arguments on the `impl Trait` bound
+    args: &'tcx [GenericArg<'tcx>],
+    /// The associated types on this bound
+    bindings: &'tcx [TypeBinding<'tcx>],
+}
+
+/// Given an `impl Trait` type, gets all the supertraits from each bound ("implied bounds").
+///
+/// For `impl Deref + DerefMut + Eq` this returns `[Deref, PartialEq]`.
+/// The `Deref` comes from `DerefMut` because `trait DerefMut: Deref {}`, and `PartialEq` comes from
+/// `Eq`.
+fn collect_supertrait_bounds<'tcx>(cx: &LateContext<'tcx>, opaque_ty: &OpaqueTy<'tcx>) -> Vec<ImplTraitBound<'tcx>> {
+    opaque_ty
+        .bounds
+        .iter()
+        .filter_map(|bound| {
+            if let GenericBound::Trait(poly_trait, TraitBoundModifier::None) = bound
+                && let [.., path] = poly_trait.trait_ref.path.segments
+                && poly_trait.bound_generic_params.is_empty()
+                && let Some(trait_def_id) = path.res.opt_def_id()
+                && let predicates = cx.tcx.super_predicates_of(trait_def_id).predicates
+                // If the trait has no supertrait, there is no need to collect anything from that bound
+                && !predicates.is_empty()
+            {
+                Some(ImplTraitBound {
+                    predicates,
+                    args: path.args.map_or([].as_slice(), |p| p.args),
+                    bindings: path.args.map_or([].as_slice(), |p| p.bindings),
+                    trait_def_id,
+                    impl_trait_bound_span: bound.span(),
+                })
+            } else {
+                None
+            }
+        })
+        .collect()
+}
+
 fn check(cx: &LateContext<'_>, decl: &FnDecl<'_>) {
     if let FnRetTy::Return(ty) = decl.output
-        &&let TyKind::OpaqueDef(item_id, ..) = ty.kind
+        && let TyKind::OpaqueDef(item_id, ..) = ty.kind
         && let item = cx.tcx.hir().item(item_id)
         && let ItemKind::OpaqueTy(opaque_ty) = item.kind
         // Very often there is only a single bound, e.g. `impl Deref<..>`, in which case
         // we can avoid doing a bunch of stuff unnecessarily.
         && opaque_ty.bounds.len() > 1
     {
-        // Get all the (implied) trait predicates in the bounds.
-        // For `impl Deref + DerefMut` this will contain [`Deref`].
-        // The implied `Deref` comes from `DerefMut` because `trait DerefMut: Deref {}`.
-        // N.B. (G)ATs are fine to disregard, because they must be the same for all of its supertraits.
-        // Example:
-        // `impl Deref<Target = i32> + DerefMut<Target = u32>` is not allowed.
-        // `DerefMut::Target` needs to match `Deref::Target`.
-        let implied_bounds: Vec<_> = opaque_ty
-            .bounds
-            .iter()
-            .filter_map(|bound| {
-                if let GenericBound::Trait(poly_trait, TraitBoundModifier::None) = bound
-                    && let [.., path] = poly_trait.trait_ref.path.segments
-                    && poly_trait.bound_generic_params.is_empty()
-                    && let Some(trait_def_id) = path.res.opt_def_id()
-                    && let predicates = cx.tcx.super_predicates_of(trait_def_id).predicates
-                    && !predicates.is_empty()
-                // If the trait has no supertrait, there is nothing to add.
-                {
-                    Some((bound.span(), path, predicates, trait_def_id))
-                } else {
-                    None
-                }
-            })
-            .collect();
+        let supertraits = collect_supertrait_bounds(cx, opaque_ty);
 
-        // Lint all bounds in the `impl Trait` type that are also in the `implied_bounds` vec.
+        // Lint all bounds in the `impl Trait` type that we've previously also seen in the set of
+        // supertraits of each of the bounds.
         // This involves some extra logic when generic arguments are present, since
         // simply comparing trait `DefId`s won't be enough. We also need to compare the generics.
         for (index, bound) in opaque_ty.bounds.iter().enumerate() {
@@ -267,42 +287,26 @@ fn check(cx: &LateContext<'_>, decl: &FnDecl<'_>) {
                 && let implied_args = path.args.map_or([].as_slice(), |a| a.args)
                 && let implied_bindings = path.args.map_or([].as_slice(), |a| a.bindings)
                 && let Some(def_id) = poly_trait.trait_ref.path.res.opt_def_id()
-                && let Some((implied_by_span, implied_by_args, implied_by_bindings)) =
-                    implied_bounds
-                        .iter()
-                        .find_map(|&(span, implied_by_path, preds, implied_by_def_id)| {
-                            let implied_by_args = implied_by_path.args.map_or([].as_slice(), |a| a.args);
-                            let implied_by_bindings = implied_by_path.args.map_or([].as_slice(), |a| a.bindings);
-
-                            preds.iter().find_map(|(clause, _)| {
-                                if let ClauseKind::Trait(tr) = clause.kind().skip_binder()
-                                    && tr.def_id() == def_id
-                                    && is_same_generics(
-                                        cx.tcx,
-                                        tr.trait_ref.args,
-                                        implied_by_args,
-                                        implied_args,
-                                        implied_by_def_id,
-                                        def_id,
-                                    )
-                                {
-                                    Some((span, implied_by_args, implied_by_bindings))
-                                } else {
-                                    None
-                                }
-                            })
-                        })
+                && let Some(bound) = supertraits.iter().find(|bound| {
+                    bound.predicates.iter().any(|(clause, _)| {
+                        if let ClauseKind::Trait(tr) = clause.kind().skip_binder()
+                            && tr.def_id() == def_id
+                        {
+                            is_same_generics(
+                                cx.tcx,
+                                tr.trait_ref.args,
+                                bound.args,
+                                implied_args,
+                                bound.trait_def_id,
+                                def_id,
+                            )
+                        } else {
+                            false
+                        }
+                    })
+                })
             {
-                emit_lint(
-                    cx,
-                    poly_trait,
-                    opaque_ty,
-                    index,
-                    implied_bindings,
-                    implied_by_bindings,
-                    implied_by_args,
-                    implied_by_span,
-                );
+                emit_lint(cx, poly_trait, opaque_ty, index, implied_bindings, bound);
             }
         }
     }
-- 
cgit 1.4.1-3-g733a5


From a38f44ca93bc5e77b8d26bd2884c8b1f84281ca6 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Sun, 11 Feb 2024 00:19:58 +0100
Subject: extract finding implied bound to separate function

---
 clippy_lints/src/implied_bounds_in_impls.rs | 58 +++++++++++++++++------------
 1 file changed, 35 insertions(+), 23 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/implied_bounds_in_impls.rs b/clippy_lints/src/implied_bounds_in_impls.rs
index 3527a39e2da..cc6ece45fcd 100644
--- a/clippy_lints/src/implied_bounds_in_impls.rs
+++ b/clippy_lints/src/implied_bounds_in_impls.rs
@@ -61,7 +61,7 @@ fn emit_lint(
     implied_bindings: &[rustc_hir::TypeBinding<'_>],
     bound: &ImplTraitBound<'_>,
 ) {
-    let implied_by = snippet(cx, bound.impl_trait_bound_span, "..");
+    let implied_by = snippet(cx, bound.span, "..");
 
     span_lint_and_then(
         cx,
@@ -101,7 +101,7 @@ fn emit_lint(
                     ([.., arg], [.., binding]) => arg.span().max(binding.span).shrink_to_hi(),
                     ([.., arg], []) => arg.span().shrink_to_hi(),
                     ([], [.., binding]) => binding.span.shrink_to_hi(),
-                    ([], []) => bound.impl_trait_bound_span.shrink_to_hi(),
+                    ([], []) => bound.span.shrink_to_hi(),
                 };
 
                 let mut associated_tys_sugg = if needs_angle_brackets {
@@ -223,8 +223,9 @@ fn is_same_generics<'tcx>(
 
 struct ImplTraitBound<'tcx> {
     /// The span of the bound in the `impl Trait` type
-    impl_trait_bound_span: Span,
-    /// The predicates defined in the trait referenced by this bound
+    span: Span,
+    /// The predicates defined in the trait referenced by this bound. This also contains the actual
+    /// supertrait bounds
     predicates: &'tcx [(ty::Clause<'tcx>, Span)],
     /// The `DefId` of the trait being referenced by this bound
     trait_def_id: DefId,
@@ -257,7 +258,7 @@ fn collect_supertrait_bounds<'tcx>(cx: &LateContext<'tcx>, opaque_ty: &OpaqueTy<
                     args: path.args.map_or([].as_slice(), |p| p.args),
                     bindings: path.args.map_or([].as_slice(), |p| p.bindings),
                     trait_def_id,
-                    impl_trait_bound_span: bound.span(),
+                    span: bound.span(),
                 })
             } else {
                 None
@@ -266,6 +267,34 @@ fn collect_supertrait_bounds<'tcx>(cx: &LateContext<'tcx>, opaque_ty: &OpaqueTy<
         .collect()
 }
 
+/// Given a bound in an `impl Trait` type, looks for a trait in the set of supertraits (previously
+/// collected in [`collect_supertrait_bounds`]) that matches (same trait and generic arguments).
+fn find_bound_in_supertraits<'a, 'tcx>(
+    cx: &LateContext<'tcx>,
+    trait_def_id: DefId,
+    args: &'tcx [GenericArg<'tcx>],
+    bounds: &'a [ImplTraitBound<'tcx>],
+) -> Option<&'a ImplTraitBound<'tcx>> {
+    bounds.iter().find(|bound| {
+        bound.predicates.iter().any(|(clause, _)| {
+            if let ClauseKind::Trait(tr) = clause.kind().skip_binder()
+                && tr.def_id() == trait_def_id
+            {
+                is_same_generics(
+                    cx.tcx,
+                    tr.trait_ref.args,
+                    bound.args,
+                    args,
+                    bound.trait_def_id,
+                    trait_def_id,
+                )
+            } else {
+                false
+            }
+        })
+    })
+}
+
 fn check(cx: &LateContext<'_>, decl: &FnDecl<'_>) {
     if let FnRetTy::Return(ty) = decl.output
         && let TyKind::OpaqueDef(item_id, ..) = ty.kind
@@ -287,24 +316,7 @@ fn check(cx: &LateContext<'_>, decl: &FnDecl<'_>) {
                 && let implied_args = path.args.map_or([].as_slice(), |a| a.args)
                 && let implied_bindings = path.args.map_or([].as_slice(), |a| a.bindings)
                 && let Some(def_id) = poly_trait.trait_ref.path.res.opt_def_id()
-                && let Some(bound) = supertraits.iter().find(|bound| {
-                    bound.predicates.iter().any(|(clause, _)| {
-                        if let ClauseKind::Trait(tr) = clause.kind().skip_binder()
-                            && tr.def_id() == def_id
-                        {
-                            is_same_generics(
-                                cx.tcx,
-                                tr.trait_ref.args,
-                                bound.args,
-                                implied_args,
-                                bound.trait_def_id,
-                                def_id,
-                            )
-                        } else {
-                            false
-                        }
-                    })
-                })
+                && let Some(bound) = find_bound_in_supertraits(cx, def_id, implied_args, &supertraits)
             {
                 emit_lint(cx, poly_trait, opaque_ty, index, implied_bindings, bound);
             }
-- 
cgit 1.4.1-3-g733a5


From a595a2c98b37e1bf2081841e41942693ab336b4c Mon Sep 17 00:00:00 2001
From: Yuri Astrakhan <YuriAstrakhan@gmail.com>
Date: Sun, 11 Feb 2024 04:22:32 -0500
Subject: Minor refactor format-impls

* Move all linting logic into a single format implementations struct

This should help with the future format-args improvements.

TODO: do the same with format_args.rs, perhaps in the same PR
---
 clippy_lints/src/format_impl.rs | 203 +++++++++++++++++++++-------------------
 1 file changed, 106 insertions(+), 97 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/format_impl.rs b/clippy_lints/src/format_impl.rs
index 9360eb1fa91..93517076cda 100644
--- a/clippy_lints/src/format_impl.rs
+++ b/clippy_lints/src/format_impl.rs
@@ -7,7 +7,7 @@ use rustc_hir::{Expr, ExprKind, Impl, ImplItem, ImplItemKind, QPath};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::impl_lint_pass;
 use rustc_span::symbol::kw;
-use rustc_span::{sym, Span, Symbol};
+use rustc_span::{sym, Symbol};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -119,123 +119,132 @@ impl<'tcx> LateLintPass<'tcx> for FormatImpl {
     }
 
     fn check_impl_item_post(&mut self, cx: &LateContext<'_>, impl_item: &ImplItem<'_>) {
-        // Assume no nested Impl of Debug and Display within eachother
+        // Assume no nested Impl of Debug and Display within each other
         if is_format_trait_impl(cx, impl_item).is_some() {
             self.format_trait_impl = None;
         }
     }
 
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        let Some(format_trait_impl) = self.format_trait_impl else {
-            return;
-        };
-
-        if format_trait_impl.name == sym::Display {
-            check_to_string_in_display(cx, expr);
+        if let Some(format_trait_impl) = self.format_trait_impl {
+            let linter = FormatImplExpr {
+                cx,
+                expr,
+                format_trait_impl,
+            };
+            linter.check_to_string_in_display();
+            linter.check_self_in_format_args();
+            linter.check_print_in_format_impl();
         }
-
-        check_self_in_format_args(cx, expr, format_trait_impl);
-        check_print_in_format_impl(cx, expr, format_trait_impl);
     }
 }
 
-fn check_to_string_in_display(cx: &LateContext<'_>, expr: &Expr<'_>) {
-    if let ExprKind::MethodCall(path, self_arg, ..) = expr.kind
-        // Get the hir_id of the object we are calling the method on
-        // Is the method to_string() ?
-        && path.ident.name == sym::to_string
-        // Is the method a part of the ToString trait? (i.e. not to_string() implemented
-        // separately)
-        && let Some(expr_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id)
-        && is_diag_trait_item(cx, expr_def_id, sym::ToString)
-        // Is the method is called on self
-        && let ExprKind::Path(QPath::Resolved(_, path)) = self_arg.kind
-        && let [segment] = path.segments
-        && segment.ident.name == kw::SelfLower
-    {
-        span_lint(
-            cx,
-            RECURSIVE_FORMAT_IMPL,
-            expr.span,
-            "using `self.to_string` in `fmt::Display` implementation will cause infinite recursion",
-        );
-    }
+struct FormatImplExpr<'a, 'tcx> {
+    cx: &'a LateContext<'tcx>,
+    expr: &'tcx Expr<'tcx>,
+    format_trait_impl: FormatTraitNames,
 }
 
-fn check_self_in_format_args<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, impl_trait: FormatTraitNames) {
-    // Check each arg in format calls - do we ever use Display on self (directly or via deref)?
-    if let Some(outer_macro) = root_macro_call_first_node(cx, expr)
-        && let macro_def_id = outer_macro.def_id
-        && is_format_macro(cx, macro_def_id)
-        && let Some(format_args) = find_format_args(cx, expr, outer_macro.expn)
-    {
-        for piece in &format_args.template {
-            if let FormatArgsPiece::Placeholder(placeholder) = piece
-                && let trait_name = match placeholder.format_trait {
-                    FormatTrait::Display => sym::Display,
-                    FormatTrait::Debug => sym::Debug,
-                    FormatTrait::LowerExp => sym!(LowerExp),
-                    FormatTrait::UpperExp => sym!(UpperExp),
-                    FormatTrait::Octal => sym!(Octal),
-                    FormatTrait::Pointer => sym::Pointer,
-                    FormatTrait::Binary => sym!(Binary),
-                    FormatTrait::LowerHex => sym!(LowerHex),
-                    FormatTrait::UpperHex => sym!(UpperHex),
+impl<'a, 'tcx> FormatImplExpr<'a, 'tcx> {
+    fn check_to_string_in_display(&self) {
+        if self.format_trait_impl.name == sym::Display
+            && let ExprKind::MethodCall(path, self_arg, ..) = self.expr.kind
+            // Get the hir_id of the object we are calling the method on
+            // Is the method to_string() ?
+            && path.ident.name == sym::to_string
+            // Is the method a part of the ToString trait? (i.e. not to_string() implemented
+            // separately)
+            && let Some(expr_def_id) = self.cx.typeck_results().type_dependent_def_id(self.expr.hir_id)
+            && is_diag_trait_item(self.cx, expr_def_id, sym::ToString)
+            // Is the method is called on self
+            && let ExprKind::Path(QPath::Resolved(_, path)) = self_arg.kind
+            && let [segment] = path.segments
+            && segment.ident.name == kw::SelfLower
+        {
+            span_lint(
+                self.cx,
+                RECURSIVE_FORMAT_IMPL,
+                self.expr.span,
+                "using `self.to_string` in `fmt::Display` implementation will cause infinite recursion",
+            );
+        }
+    }
+
+    fn check_self_in_format_args(&self) {
+        // Check each arg in format calls - do we ever use Display on self (directly or via deref)?
+        if let Some(outer_macro) = root_macro_call_first_node(self.cx, self.expr)
+            && let macro_def_id = outer_macro.def_id
+            && is_format_macro(self.cx, macro_def_id)
+            && let Some(format_args) = find_format_args(self.cx, self.expr, outer_macro.expn)
+        {
+            for piece in &format_args.template {
+                if let FormatArgsPiece::Placeholder(placeholder) = piece
+                    && let trait_name = match placeholder.format_trait {
+                        FormatTrait::Display => sym::Display,
+                        FormatTrait::Debug => sym::Debug,
+                        FormatTrait::LowerExp => sym!(LowerExp),
+                        FormatTrait::UpperExp => sym!(UpperExp),
+                        FormatTrait::Octal => sym!(Octal),
+                        FormatTrait::Pointer => sym::Pointer,
+                        FormatTrait::Binary => sym!(Binary),
+                        FormatTrait::LowerHex => sym!(LowerHex),
+                        FormatTrait::UpperHex => sym!(UpperHex),
+                    }
+                    && trait_name == self.format_trait_impl.name
+                    && let Ok(index) = placeholder.argument.index
+                    && let Some(arg) = format_args.arguments.all_args().get(index)
+                    && let Ok(arg_expr) = find_format_arg_expr(self.expr, arg)
+                {
+                    self.check_format_arg_self(arg_expr);
                 }
-                && trait_name == impl_trait.name
-                && let Ok(index) = placeholder.argument.index
-                && let Some(arg) = format_args.arguments.all_args().get(index)
-                && let Ok(arg_expr) = find_format_arg_expr(expr, arg)
-            {
-                check_format_arg_self(cx, expr.span, arg_expr, impl_trait);
             }
         }
     }
-}
 
-fn check_format_arg_self(cx: &LateContext<'_>, span: Span, arg: &Expr<'_>, impl_trait: FormatTraitNames) {
-    // Handle multiple dereferencing of references e.g. &&self
-    // Handle dereference of &self -> self that is equivalent (i.e. via *self in fmt() impl)
-    // Since the argument to fmt is itself a reference: &self
-    let reference = peel_ref_operators(cx, arg);
-    let map = cx.tcx.hir();
-    // Is the reference self?
-    if path_to_local(reference).map(|x| map.name(x)) == Some(kw::SelfLower) {
-        let FormatTraitNames { name, .. } = impl_trait;
-        span_lint(
-            cx,
-            RECURSIVE_FORMAT_IMPL,
-            span,
-            &format!("using `self` as `{name}` in `impl {name}` will cause infinite recursion"),
-        );
+    fn check_format_arg_self(&self, arg: &Expr<'_>) {
+        // Handle multiple dereferencing of references e.g. &&self
+        // Handle dereference of &self -> self that is equivalent (i.e. via *self in fmt() impl)
+        // Since the argument to fmt is itself a reference: &self
+        let reference = peel_ref_operators(self.cx, arg);
+        let map = self.cx.tcx.hir();
+        // Is the reference self?
+        if path_to_local(reference).map(|x| map.name(x)) == Some(kw::SelfLower) {
+            let FormatTraitNames { name, .. } = self.format_trait_impl;
+            span_lint(
+                self.cx,
+                RECURSIVE_FORMAT_IMPL,
+                self.expr.span,
+                &format!("using `self` as `{name}` in `impl {name}` will cause infinite recursion"),
+            );
+        }
     }
-}
 
-fn check_print_in_format_impl(cx: &LateContext<'_>, expr: &Expr<'_>, impl_trait: FormatTraitNames) {
-    if let Some(macro_call) = root_macro_call_first_node(cx, expr)
-        && let Some(name) = cx.tcx.get_diagnostic_name(macro_call.def_id)
-    {
-        let replacement = match name {
-            sym::print_macro | sym::eprint_macro => "write",
-            sym::println_macro | sym::eprintln_macro => "writeln",
-            _ => return,
-        };
+    fn check_print_in_format_impl(&self) {
+        if let Some(macro_call) = root_macro_call_first_node(self.cx, self.expr)
+            && let Some(name) = self.cx.tcx.get_diagnostic_name(macro_call.def_id)
+        {
+            let replacement = match name {
+                sym::print_macro | sym::eprint_macro => "write",
+                sym::println_macro | sym::eprintln_macro => "writeln",
+                _ => return,
+            };
 
-        let name = name.as_str().strip_suffix("_macro").unwrap();
+            let name = name.as_str().strip_suffix("_macro").unwrap();
 
-        span_lint_and_sugg(
-            cx,
-            PRINT_IN_FORMAT_IMPL,
-            macro_call.span,
-            &format!("use of `{name}!` in `{}` impl", impl_trait.name),
-            "replace with",
-            if let Some(formatter_name) = impl_trait.formatter_name {
-                format!("{replacement}!({formatter_name}, ..)")
-            } else {
-                format!("{replacement}!(..)")
-            },
-            Applicability::HasPlaceholders,
-        );
+            span_lint_and_sugg(
+                self.cx,
+                PRINT_IN_FORMAT_IMPL,
+                macro_call.span,
+                &format!("use of `{name}!` in `{}` impl", self.format_trait_impl.name),
+                "replace with",
+                if let Some(formatter_name) = self.format_trait_impl.formatter_name {
+                    format!("{replacement}!({formatter_name}, ..)")
+                } else {
+                    format!("{replacement}!(..)")
+                },
+                Applicability::HasPlaceholders,
+            );
+        }
     }
 }
 
-- 
cgit 1.4.1-3-g733a5


From 67bdb0e11c27df7c8f089976141a1a7526903743 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Sun, 11 Feb 2024 12:57:26 +0100
Subject: [`incompatible_msrv`]: allow expressions that come from desugaring

---
 clippy_lints/src/incompatible_msrv.rs | 7 ++++++-
 tests/ui/incompatible_msrv.rs         | 8 ++++++++
 tests/ui/incompatible_msrv.stderr     | 6 +++---
 3 files changed, 17 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/incompatible_msrv.rs b/clippy_lints/src/incompatible_msrv.rs
index 475938d6adf..cd000fcd184 100644
--- a/clippy_lints/src/incompatible_msrv.rs
+++ b/clippy_lints/src/incompatible_msrv.rs
@@ -9,7 +9,7 @@ use rustc_middle::ty::TyCtxt;
 use rustc_semver::RustcVersion;
 use rustc_session::impl_lint_pass;
 use rustc_span::def_id::DefId;
-use rustc_span::Span;
+use rustc_span::{ExpnKind, Span};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -91,6 +91,11 @@ impl IncompatibleMsrv {
         if self.msrv.meets(version) || is_in_test_function(cx.tcx, node) {
             return;
         }
+        if let ExpnKind::AstPass(_) | ExpnKind::Desugaring(_) = span.ctxt().outer_expn_data().kind {
+            // Desugared expressions get to cheat and stability is ignored.
+            // Intentionally not using `.from_expansion()`, since we do still care about macro expansions
+            return;
+        }
         self.emit_lint_for(cx, span, version);
     }
 
diff --git a/tests/ui/incompatible_msrv.rs b/tests/ui/incompatible_msrv.rs
index 0fa047c7102..8ef1f554bc3 100644
--- a/tests/ui/incompatible_msrv.rs
+++ b/tests/ui/incompatible_msrv.rs
@@ -4,6 +4,7 @@
 
 use std::collections::hash_map::Entry;
 use std::collections::HashMap;
+use std::future::Future;
 use std::thread::sleep;
 use std::time::Duration;
 
@@ -25,4 +26,11 @@ fn test() {
     sleep(Duration::new(1, 0));
 }
 
+#[clippy::msrv = "1.63.0"]
+async fn issue12273(v: impl Future<Output = ()>) {
+    // `.await` desugaring has a call to `IntoFuture::into_future` marked #[stable(since = "1.64.0")],
+    // but its stability is ignored
+    v.await;
+}
+
 fn main() {}
diff --git a/tests/ui/incompatible_msrv.stderr b/tests/ui/incompatible_msrv.stderr
index bd5ecd6ed2f..9e1c81b82bc 100644
--- a/tests/ui/incompatible_msrv.stderr
+++ b/tests/ui/incompatible_msrv.stderr
@@ -1,5 +1,5 @@
 error: current MSRV (Minimum Supported Rust Version) is `1.3.0` but this item is stable since `1.10.0`
-  --> $DIR/incompatible_msrv.rs:12:39
+  --> $DIR/incompatible_msrv.rs:13:39
    |
 LL |     assert_eq!(map.entry("poneyland").key(), &"poneyland");
    |                                       ^^^^^
@@ -8,13 +8,13 @@ LL |     assert_eq!(map.entry("poneyland").key(), &"poneyland");
    = help: to override `-D warnings` add `#[allow(clippy::incompatible_msrv)]`
 
 error: current MSRV (Minimum Supported Rust Version) is `1.3.0` but this item is stable since `1.12.0`
-  --> $DIR/incompatible_msrv.rs:15:11
+  --> $DIR/incompatible_msrv.rs:16:11
    |
 LL |         v.into_key();
    |           ^^^^^^^^^^
 
 error: current MSRV (Minimum Supported Rust Version) is `1.3.0` but this item is stable since `1.4.0`
-  --> $DIR/incompatible_msrv.rs:19:5
+  --> $DIR/incompatible_msrv.rs:20:5
    |
 LL |     sleep(Duration::new(1, 0));
    |     ^^^^^
-- 
cgit 1.4.1-3-g733a5


From 4cc7b7e09287c1a4908d73c1104b222858193e85 Mon Sep 17 00:00:00 2001
From: J-ZhengLi <lizheng135@huawei.com>
Date: Mon, 12 Feb 2024 04:16:11 +0800
Subject: stop linting [`blocks_in_conditions`] on `match` on proc macros

---
 clippy_lints/src/blocks_in_conditions.rs | 4 ++--
 tests/ui/blocks_in_conditions.fixed      | 2 +-
 tests/ui/blocks_in_conditions.stderr     | 8 +-------
 3 files changed, 4 insertions(+), 10 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/blocks_in_conditions.rs b/clippy_lints/src/blocks_in_conditions.rs
index ff4dffd0607..eae87db26c6 100644
--- a/clippy_lints/src/blocks_in_conditions.rs
+++ b/clippy_lints/src/blocks_in_conditions.rs
@@ -2,7 +2,7 @@ use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg};
 use clippy_utils::source::snippet_block_with_applicability;
 use clippy_utils::ty::implements_trait;
 use clippy_utils::visitors::{for_each_expr, Descend};
-use clippy_utils::{get_parent_expr, higher};
+use clippy_utils::{get_parent_expr, higher, is_from_proc_macro};
 use core::ops::ControlFlow;
 use rustc_errors::Applicability;
 use rustc_hir::{BlockCheckMode, Expr, ExprKind, MatchSource};
@@ -94,7 +94,7 @@ impl<'tcx> LateLintPass<'tcx> for BlocksInConditions {
                     }
                 } else {
                     let span = block.expr.as_ref().map_or_else(|| block.stmts[0].span, |e| e.span);
-                    if span.from_expansion() || expr.span.from_expansion() {
+                    if span.from_expansion() || expr.span.from_expansion() || is_from_proc_macro(cx, cond) {
                         return;
                     }
                     // move block higher
diff --git a/tests/ui/blocks_in_conditions.fixed b/tests/ui/blocks_in_conditions.fixed
index ac1ad68ffc2..caf29e23d54 100644
--- a/tests/ui/blocks_in_conditions.fixed
+++ b/tests/ui/blocks_in_conditions.fixed
@@ -104,7 +104,7 @@ fn issue_12162() {
 mod issue_12016 {
     #[proc_macro_attr::fake_desugar_await]
     pub async fn await_becomes_block() -> i32 {
-        let res = await; match res {
+        match Some(1).await {
             Some(1) => 2,
             Some(2) => 3,
             _ => 0,
diff --git a/tests/ui/blocks_in_conditions.stderr b/tests/ui/blocks_in_conditions.stderr
index cb2f6da3516..4d3efb4ffd1 100644
--- a/tests/ui/blocks_in_conditions.stderr
+++ b/tests/ui/blocks_in_conditions.stderr
@@ -53,11 +53,5 @@ LL +         opt
 LL ~     }; match res {
    |
 
-error: in a `match` scrutinee, avoid complex blocks or closures with blocks; instead, move the block or closure higher and bind it with a `let`
-  --> $DIR/blocks_in_conditions.rs:107:9
-   |
-LL |         match Some(1).await {
-   |         ^^^^^^^^^^^^^^^^^^^ help: try: `let res = await; match res`
-
-error: aborting due to 5 previous errors
+error: aborting due to 4 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 92616c0aaac07bf589a2d40502dd5dec804e8318 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Mon, 27 Nov 2023 00:43:47 +0100
Subject: [`implied_bounds_in_impls`]: avoid linting on overlapping associated
 types

---
 clippy_lints/src/implied_bounds_in_impls.rs |  9 +++++++
 tests/ui/implied_bounds_in_impls.fixed      | 29 ++++++++++++++++++++++
 tests/ui/implied_bounds_in_impls.rs         | 29 ++++++++++++++++++++++
 tests/ui/implied_bounds_in_impls.stderr     | 38 ++++++++++++++++++++++++++++-
 4 files changed, 104 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/implied_bounds_in_impls.rs b/clippy_lints/src/implied_bounds_in_impls.rs
index cc6ece45fcd..174db30a7cd 100644
--- a/clippy_lints/src/implied_bounds_in_impls.rs
+++ b/clippy_lints/src/implied_bounds_in_impls.rs
@@ -317,6 +317,15 @@ fn check(cx: &LateContext<'_>, decl: &FnDecl<'_>) {
                 && let implied_bindings = path.args.map_or([].as_slice(), |a| a.bindings)
                 && let Some(def_id) = poly_trait.trait_ref.path.res.opt_def_id()
                 && let Some(bound) = find_bound_in_supertraits(cx, def_id, implied_args, &supertraits)
+                // If the implied bound has a type binding that also exists in the implied-by trait,
+                // then we shouldn't lint. See #11880 for an example.
+                && let assocs = cx.tcx.associated_items(bound.trait_def_id)
+                && !implied_bindings.iter().any(|binding| {
+                    assocs
+                        .filter_by_name_unhygienic(binding.ident.name)
+                        .next()
+                        .is_some_and(|assoc| assoc.kind == ty::AssocKind::Type)
+                    })
             {
                 emit_lint(cx, poly_trait, opaque_ty, index, implied_bindings, bound);
             }
diff --git a/tests/ui/implied_bounds_in_impls.fixed b/tests/ui/implied_bounds_in_impls.fixed
index fa117aaddcd..18f29e900c1 100644
--- a/tests/ui/implied_bounds_in_impls.fixed
+++ b/tests/ui/implied_bounds_in_impls.fixed
@@ -121,4 +121,33 @@ mod issue11435 {
     fn f3() -> impl Trait4<i8, X = i32, Y = i128> {}
 }
 
+fn issue11880() {
+    trait X {
+        type T;
+        type U;
+    }
+    trait Y: X {
+        type T;
+        type V;
+    }
+    impl X for () {
+        type T = i32;
+        type U = String;
+    }
+    impl Y for () {
+        type T = u32;
+        type V = Vec<u8>;
+    }
+
+    // Can't constrain `X::T` through `Y`
+    fn f() -> impl X<T = i32> + Y {}
+    fn f2() -> impl X<T = i32> + Y<T = u32> {}
+
+    // X::T is never constrained in the first place, so it can be omitted
+    // and left unconstrained
+    fn f3() -> impl Y {}
+    fn f4() -> impl Y<T = u32> {}
+    fn f5() -> impl Y<T = u32, U = String> {}
+}
+
 fn main() {}
diff --git a/tests/ui/implied_bounds_in_impls.rs b/tests/ui/implied_bounds_in_impls.rs
index c96aac151a7..b7951e7dfba 100644
--- a/tests/ui/implied_bounds_in_impls.rs
+++ b/tests/ui/implied_bounds_in_impls.rs
@@ -121,4 +121,33 @@ mod issue11435 {
     fn f3() -> impl Trait3<i8, i16, i64, X = i32, Y = i128> + Trait4<i8, X = i32> {}
 }
 
+fn issue11880() {
+    trait X {
+        type T;
+        type U;
+    }
+    trait Y: X {
+        type T;
+        type V;
+    }
+    impl X for () {
+        type T = i32;
+        type U = String;
+    }
+    impl Y for () {
+        type T = u32;
+        type V = Vec<u8>;
+    }
+
+    // Can't constrain `X::T` through `Y`
+    fn f() -> impl X<T = i32> + Y {}
+    fn f2() -> impl X<T = i32> + Y<T = u32> {}
+
+    // X::T is never constrained in the first place, so it can be omitted
+    // and left unconstrained
+    fn f3() -> impl X + Y {}
+    fn f4() -> impl X + Y<T = u32> {}
+    fn f5() -> impl X<U = String> + Y<T = u32> {}
+}
+
 fn main() {}
diff --git a/tests/ui/implied_bounds_in_impls.stderr b/tests/ui/implied_bounds_in_impls.stderr
index fb44f2aba17..3b09e4582e3 100644
--- a/tests/ui/implied_bounds_in_impls.stderr
+++ b/tests/ui/implied_bounds_in_impls.stderr
@@ -192,5 +192,41 @@ LL -     fn f3() -> impl Trait3<i8, i16, i64, X = i32, Y = i128> + Trait4<i8, X
 LL +     fn f3() -> impl Trait4<i8, X = i32, Y = i128> {}
    |
 
-error: aborting due to 16 previous errors
+error: this bound is already specified as the supertrait of `Y`
+  --> $DIR/implied_bounds_in_impls.rs:148:21
+   |
+LL |     fn f3() -> impl X + Y {}
+   |                     ^
+   |
+help: try removing this bound
+   |
+LL -     fn f3() -> impl X + Y {}
+LL +     fn f3() -> impl Y {}
+   |
+
+error: this bound is already specified as the supertrait of `Y<T = u32>`
+  --> $DIR/implied_bounds_in_impls.rs:149:21
+   |
+LL |     fn f4() -> impl X + Y<T = u32> {}
+   |                     ^
+   |
+help: try removing this bound
+   |
+LL -     fn f4() -> impl X + Y<T = u32> {}
+LL +     fn f4() -> impl Y<T = u32> {}
+   |
+
+error: this bound is already specified as the supertrait of `Y<T = u32>`
+  --> $DIR/implied_bounds_in_impls.rs:150:21
+   |
+LL |     fn f5() -> impl X<U = String> + Y<T = u32> {}
+   |                     ^^^^^^^^^^^^^
+   |
+help: try removing this bound
+   |
+LL -     fn f5() -> impl X<U = String> + Y<T = u32> {}
+LL +     fn f5() -> impl Y<T = u32, U = String> {}
+   |
+
+error: aborting due to 19 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From a18e0a11f7a0a62a7fcaec178aad34f880b659dc Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Thu, 8 Feb 2024 22:36:41 +0100
Subject: Extend `NONMINIMAL_BOOL` lint

---
 clippy_lints/src/booleans.rs    | 26 ++++++++++++++++++++++++++
 tests/ui/nonminimal_bool.rs     |  8 ++++++++
 tests/ui/nonminimal_bool.stderr | 26 +++++++++++++++++++++++++-
 3 files changed, 59 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/booleans.rs b/clippy_lints/src/booleans.rs
index 2d1c250ace9..3c17f65f0d3 100644
--- a/clippy_lints/src/booleans.rs
+++ b/clippy_lints/src/booleans.rs
@@ -85,6 +85,32 @@ impl<'tcx> LateLintPass<'tcx> for NonminimalBool {
     ) {
         NonminimalBoolVisitor { cx }.visit_body(body);
     }
+
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
+        if let ExprKind::Unary(UnOp::Not, sub) = expr.kind
+            && !expr.span.from_expansion()
+            && let ExprKind::Binary(op, left, right) = sub.kind
+        {
+            let new_op = match op.node {
+                BinOpKind::Eq => "!=",
+                BinOpKind::Ne => "==",
+                _ => return,
+            };
+            let Some(left) = snippet_opt(cx, left.span) else { return };
+            let Some(right) = snippet_opt(cx, right.span) else {
+                return;
+            };
+            span_lint_and_sugg(
+                cx,
+                NONMINIMAL_BOOL,
+                expr.span,
+                "this boolean expression can be simplified",
+                "try",
+                format!("{left} {new_op} {right}"),
+                Applicability::MachineApplicable,
+            );
+        }
+    }
 }
 struct NonminimalBoolVisitor<'a, 'tcx> {
     cx: &'a LateContext<'tcx>,
diff --git a/tests/ui/nonminimal_bool.rs b/tests/ui/nonminimal_bool.rs
index f7c3df7066f..ee092b9aca6 100644
--- a/tests/ui/nonminimal_bool.rs
+++ b/tests/ui/nonminimal_bool.rs
@@ -156,3 +156,11 @@ fn issue11932() {
         x % 3 == 0
     };
 }
+
+fn issue_5794() {
+    let a = 0;
+    if !(12 == a) {} //~ ERROR: this boolean expression can be simplified
+    if !(a == 12) {} //~ ERROR: this boolean expression can be simplified
+    if !(12 != a) {} //~ ERROR: this boolean expression can be simplified
+    if !(a != 12) {} //~ ERROR: this boolean expression can be simplified
+}
diff --git a/tests/ui/nonminimal_bool.stderr b/tests/ui/nonminimal_bool.stderr
index fd1568d94e3..856b5cd0869 100644
--- a/tests/ui/nonminimal_bool.stderr
+++ b/tests/ui/nonminimal_bool.stderr
@@ -114,5 +114,29 @@ error: this boolean expression can be simplified
 LL |     if matches!(true, true) && true {
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `matches!(true, true)`
 
-error: aborting due to 13 previous errors
+error: this boolean expression can be simplified
+  --> $DIR/nonminimal_bool.rs:162:8
+   |
+LL |     if !(12 == a) {}
+   |        ^^^^^^^^^^ help: try: `12 != a`
+
+error: this boolean expression can be simplified
+  --> $DIR/nonminimal_bool.rs:163:8
+   |
+LL |     if !(a == 12) {}
+   |        ^^^^^^^^^^ help: try: `a != 12`
+
+error: this boolean expression can be simplified
+  --> $DIR/nonminimal_bool.rs:164:8
+   |
+LL |     if !(12 != a) {}
+   |        ^^^^^^^^^^ help: try: `12 == a`
+
+error: this boolean expression can be simplified
+  --> $DIR/nonminimal_bool.rs:165:8
+   |
+LL |     if !(a != 12) {}
+   |        ^^^^^^^^^^ help: try: `a == 12`
+
+error: aborting due to 17 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 5e7c437d415871052fdd92f0d402ac9fd050fefa Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Fri, 9 Feb 2024 20:47:31 +0100
Subject: Extend `NONMINIMAL_BOOL` to check inverted boolean values

---
 clippy_lints/src/booleans.rs    | 124 +++++++++++++++++++++++++++++++++-------
 tests/ui/bool_comparison.fixed  |   2 +-
 tests/ui/bool_comparison.rs     |   2 +-
 tests/ui/nonminimal_bool.rs     |   9 +++
 tests/ui/nonminimal_bool.stderr |  77 ++++++++++++++++++++++++-
 5 files changed, 191 insertions(+), 23 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/booleans.rs b/clippy_lints/src/booleans.rs
index 3c17f65f0d3..0d66f2d644d 100644
--- a/clippy_lints/src/booleans.rs
+++ b/clippy_lints/src/booleans.rs
@@ -87,31 +87,115 @@ impl<'tcx> LateLintPass<'tcx> for NonminimalBool {
     }
 
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
-        if let ExprKind::Unary(UnOp::Not, sub) = expr.kind
-            && !expr.span.from_expansion()
-            && let ExprKind::Binary(op, left, right) = sub.kind
-        {
-            let new_op = match op.node {
-                BinOpKind::Eq => "!=",
-                BinOpKind::Ne => "==",
-                _ => return,
+        match expr.kind {
+            ExprKind::Unary(UnOp::Not, sub) => check_inverted_condition(cx, expr.span, sub),
+            // This check the case where an element in a boolean comparison is inverted, like:
+            //
+            // ```
+            // let a = true;
+            // !a == false;
+            // ```
+            ExprKind::Binary(op, left, right) if matches!(op.node, BinOpKind::Eq | BinOpKind::Ne) => {
+                check_inverted_bool_in_condition(cx, expr.span, op.node, left, right);
+            },
+            _ => {},
+        }
+    }
+}
+
+fn inverted_bin_op_eq_str(op: BinOpKind) -> Option<&'static str> {
+    match op {
+        BinOpKind::Eq => Some("!="),
+        BinOpKind::Ne => Some("=="),
+        _ => None,
+    }
+}
+
+fn bin_op_eq_str(op: BinOpKind) -> Option<&'static str> {
+    match op {
+        BinOpKind::Eq => Some("=="),
+        BinOpKind::Ne => Some("!="),
+        _ => None,
+    }
+}
+
+fn check_inverted_condition(cx: &LateContext<'_>, expr_span: Span, sub_expr: &Expr<'_>) {
+    if !expr_span.from_expansion()
+        && let ExprKind::Binary(op, left, right) = sub_expr.kind
+        && let Some(left) = snippet_opt(cx, left.span)
+        && let Some(right) = snippet_opt(cx, right.span)
+    {
+        let Some(op) = inverted_bin_op_eq_str(op.node) else {
+            return;
+        };
+        span_lint_and_sugg(
+            cx,
+            NONMINIMAL_BOOL,
+            expr_span,
+            "this boolean expression can be simplified",
+            "try",
+            format!("{left} {op} {right}",),
+            Applicability::MachineApplicable,
+        );
+    }
+}
+
+fn check_inverted_bool_in_condition(
+    cx: &LateContext<'_>,
+    expr_span: Span,
+    op: BinOpKind,
+    left: &Expr<'_>,
+    right: &Expr<'_>,
+) {
+    if expr_span.from_expansion()
+        && (!cx.typeck_results().node_types()[left.hir_id].is_bool()
+            || !cx.typeck_results().node_types()[right.hir_id].is_bool())
+    {
+        return;
+    }
+
+    let suggestion = match (left.kind, right.kind) {
+        (ExprKind::Unary(UnOp::Not, left_sub), ExprKind::Unary(UnOp::Not, right_sub)) => {
+            let Some(left) = snippet_opt(cx, left_sub.span) else {
+                return;
+            };
+            let Some(right) = snippet_opt(cx, right_sub.span) else {
+                return;
+            };
+            let Some(op) = bin_op_eq_str(op) else { return };
+            format!("{left} {op} {right}")
+        },
+        (ExprKind::Unary(UnOp::Not, left_sub), _) => {
+            let Some(left) = snippet_opt(cx, left_sub.span) else {
+                return;
             };
-            let Some(left) = snippet_opt(cx, left.span) else { return };
             let Some(right) = snippet_opt(cx, right.span) else {
                 return;
             };
-            span_lint_and_sugg(
-                cx,
-                NONMINIMAL_BOOL,
-                expr.span,
-                "this boolean expression can be simplified",
-                "try",
-                format!("{left} {new_op} {right}"),
-                Applicability::MachineApplicable,
-            );
-        }
-    }
+            let Some(op) = inverted_bin_op_eq_str(op) else { return };
+            format!("{left} {op} {right}")
+        },
+        (_, ExprKind::Unary(UnOp::Not, right_sub)) => {
+            let Some(left) = snippet_opt(cx, left.span) else { return };
+            let Some(right) = snippet_opt(cx, right_sub.span) else {
+                return;
+            };
+            let Some(op) = inverted_bin_op_eq_str(op) else { return };
+            format!("{left} {op} {right}")
+        },
+        _ => return,
+    };
+    span_lint_and_sugg(
+        cx,
+        NONMINIMAL_BOOL,
+        expr_span,
+        "this boolean expression can be simplified",
+        "try",
+        suggestion,
+        Applicability::MachineApplicable,
+    );
 }
+
 struct NonminimalBoolVisitor<'a, 'tcx> {
     cx: &'a LateContext<'tcx>,
 }
diff --git a/tests/ui/bool_comparison.fixed b/tests/ui/bool_comparison.fixed
index 02f1d09b833..54bdf7f5d70 100644
--- a/tests/ui/bool_comparison.fixed
+++ b/tests/ui/bool_comparison.fixed
@@ -1,6 +1,6 @@
 #![allow(clippy::needless_if)]
 #![warn(clippy::bool_comparison)]
-#![allow(clippy::non_canonical_partial_ord_impl)]
+#![allow(clippy::non_canonical_partial_ord_impl, clippy::nonminimal_bool)]
 
 fn main() {
     let x = true;
diff --git a/tests/ui/bool_comparison.rs b/tests/ui/bool_comparison.rs
index 5ef696d855e..4fdf2305242 100644
--- a/tests/ui/bool_comparison.rs
+++ b/tests/ui/bool_comparison.rs
@@ -1,6 +1,6 @@
 #![allow(clippy::needless_if)]
 #![warn(clippy::bool_comparison)]
-#![allow(clippy::non_canonical_partial_ord_impl)]
+#![allow(clippy::non_canonical_partial_ord_impl, clippy::nonminimal_bool)]
 
 fn main() {
     let x = true;
diff --git a/tests/ui/nonminimal_bool.rs b/tests/ui/nonminimal_bool.rs
index ee092b9aca6..908ef6cb2a0 100644
--- a/tests/ui/nonminimal_bool.rs
+++ b/tests/ui/nonminimal_bool.rs
@@ -163,4 +163,13 @@ fn issue_5794() {
     if !(a == 12) {} //~ ERROR: this boolean expression can be simplified
     if !(12 != a) {} //~ ERROR: this boolean expression can be simplified
     if !(a != 12) {} //~ ERROR: this boolean expression can be simplified
+
+    let b = true;
+    let c = false;
+    if !b == true {} //~ ERROR: this boolean expression can be simplified
+    if !b != true {} //~ ERROR: this boolean expression can be simplified
+    if true == !b {} //~ ERROR: this boolean expression can be simplified
+    if true != !b {} //~ ERROR: this boolean expression can be simplified
+    if !b == !c {} //~ ERROR: this boolean expression can be simplified
+    if !b != !c {} //~ ERROR: this boolean expression can be simplified
 }
diff --git a/tests/ui/nonminimal_bool.stderr b/tests/ui/nonminimal_bool.stderr
index 856b5cd0869..a317c8328d9 100644
--- a/tests/ui/nonminimal_bool.stderr
+++ b/tests/ui/nonminimal_bool.stderr
@@ -138,5 +138,80 @@ error: this boolean expression can be simplified
 LL |     if !(a != 12) {}
    |        ^^^^^^^^^^ help: try: `a == 12`
 
-error: aborting due to 17 previous errors
+error: this boolean expression can be simplified
+  --> $DIR/nonminimal_bool.rs:169:8
+   |
+LL |     if !b == true {}
+   |        ^^^^^^^^^^ help: try: `b != true`
+
+error: this comparison might be written more concisely
+  --> $DIR/nonminimal_bool.rs:169:8
+   |
+LL |     if !b == true {}
+   |        ^^^^^^^^^^ help: try simplifying it as shown: `b != true`
+   |
+   = note: `-D clippy::bool-comparison` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::bool_comparison)]`
+
+error: equality checks against true are unnecessary
+  --> $DIR/nonminimal_bool.rs:169:8
+   |
+LL |     if !b == true {}
+   |        ^^^^^^^^^^ help: try simplifying it as shown: `!b`
+
+error: this boolean expression can be simplified
+  --> $DIR/nonminimal_bool.rs:170:8
+   |
+LL |     if !b != true {}
+   |        ^^^^^^^^^^ help: try: `b == true`
+
+error: inequality checks against true can be replaced by a negation
+  --> $DIR/nonminimal_bool.rs:170:8
+   |
+LL |     if !b != true {}
+   |        ^^^^^^^^^^ help: try simplifying it as shown: `!(!b)`
+
+error: this boolean expression can be simplified
+  --> $DIR/nonminimal_bool.rs:171:8
+   |
+LL |     if true == !b {}
+   |        ^^^^^^^^^^ help: try: `true != b`
+
+error: this comparison might be written more concisely
+  --> $DIR/nonminimal_bool.rs:171:8
+   |
+LL |     if true == !b {}
+   |        ^^^^^^^^^^ help: try simplifying it as shown: `true != b`
+
+error: equality checks against true are unnecessary
+  --> $DIR/nonminimal_bool.rs:171:8
+   |
+LL |     if true == !b {}
+   |        ^^^^^^^^^^ help: try simplifying it as shown: `!b`
+
+error: this boolean expression can be simplified
+  --> $DIR/nonminimal_bool.rs:172:8
+   |
+LL |     if true != !b {}
+   |        ^^^^^^^^^^ help: try: `true == b`
+
+error: inequality checks against true can be replaced by a negation
+  --> $DIR/nonminimal_bool.rs:172:8
+   |
+LL |     if true != !b {}
+   |        ^^^^^^^^^^ help: try simplifying it as shown: `!(!b)`
+
+error: this boolean expression can be simplified
+  --> $DIR/nonminimal_bool.rs:173:8
+   |
+LL |     if !b == !c {}
+   |        ^^^^^^^^ help: try: `b == c`
+
+error: this boolean expression can be simplified
+  --> $DIR/nonminimal_bool.rs:174:8
+   |
+LL |     if !b != !c {}
+   |        ^^^^^^^^ help: try: `b != c`
+
+error: aborting due to 29 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 83555914edf10727bab5a97113ce2b3faa9abb7b Mon Sep 17 00:00:00 2001
From: Gabriel Fernandes <fernandesbgabriel@gmail.com>
Date: Sun, 11 Feb 2024 21:11:13 -0300
Subject: [mem_replace_with_default] No longer triggers on unused expression

---
 clippy_lints/src/mem_replace.rs   |  6 ++++--
 tests/ui/mem_replace.fixed        |  8 ++++++++
 tests/ui/mem_replace.rs           |  8 ++++++++
 tests/ui/mem_replace.stderr       | 10 +++++-----
 tests/ui/mem_replace_macro.rs     |  4 ++--
 tests/ui/mem_replace_macro.stderr |  6 +++---
 6 files changed, 30 insertions(+), 12 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/mem_replace.rs b/clippy_lints/src/mem_replace.rs
index fa4f4a47e38..1cdb7921f81 100644
--- a/clippy_lints/src/mem_replace.rs
+++ b/clippy_lints/src/mem_replace.rs
@@ -3,7 +3,9 @@ use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg, span_lin
 use clippy_utils::source::{snippet, snippet_with_applicability};
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::is_non_aggregate_primitive_type;
-use clippy_utils::{is_default_equivalent, is_res_lang_ctor, path_res, peel_ref_operators, std_or_core};
+use clippy_utils::{
+    is_default_equivalent, is_expr_used_or_unified, is_res_lang_ctor, path_res, peel_ref_operators, std_or_core,
+};
 use rustc_errors::Applicability;
 use rustc_hir::LangItem::OptionNone;
 use rustc_hir::{Expr, ExprKind};
@@ -232,7 +234,7 @@ impl<'tcx> LateLintPass<'tcx> for MemReplace {
             // Check that second argument is `Option::None`
             if is_res_lang_ctor(cx, path_res(cx, src), OptionNone) {
                 check_replace_option_with_none(cx, dest, expr.span);
-            } else if self.msrv.meets(msrvs::MEM_TAKE) {
+            } else if self.msrv.meets(msrvs::MEM_TAKE) && is_expr_used_or_unified(cx.tcx, expr) {
                 check_replace_with_default(cx, src, dest, expr.span);
             }
             check_replace_with_uninit(cx, src, dest, expr.span);
diff --git a/tests/ui/mem_replace.fixed b/tests/ui/mem_replace.fixed
index 453d0bcc57c..78d8b3e9bce 100644
--- a/tests/ui/mem_replace.fixed
+++ b/tests/ui/mem_replace.fixed
@@ -71,6 +71,14 @@ fn dont_lint_primitive() {
     let _ = std::mem::replace(&mut pint, 0);
 }
 
+// lint is disabled for expressions that are not used because changing to `take` is not the
+// recommended fix. Additionally, the `replace` is #[must_use], so that lint will provide
+// the correct suggestion
+fn dont_lint_not_used() {
+    let mut s = String::from("foo");
+    std::mem::replace(&mut s, String::default());
+}
+
 fn main() {
     replace_option_with_none();
     replace_with_default();
diff --git a/tests/ui/mem_replace.rs b/tests/ui/mem_replace.rs
index 0c4e0f6032d..28915bf6dae 100644
--- a/tests/ui/mem_replace.rs
+++ b/tests/ui/mem_replace.rs
@@ -71,6 +71,14 @@ fn dont_lint_primitive() {
     let _ = std::mem::replace(&mut pint, 0);
 }
 
+// lint is disabled for expressions that are not used because changing to `take` is not the
+// recommended fix. Additionally, the `replace` is #[must_use], so that lint will provide
+// the correct suggestion
+fn dont_lint_not_used() {
+    let mut s = String::from("foo");
+    std::mem::replace(&mut s, String::default());
+}
+
 fn main() {
     replace_option_with_none();
     replace_with_default();
diff --git a/tests/ui/mem_replace.stderr b/tests/ui/mem_replace.stderr
index ae5f4e5340a..c8ddf585fd2 100644
--- a/tests/ui/mem_replace.stderr
+++ b/tests/ui/mem_replace.stderr
@@ -119,31 +119,31 @@ LL |     let _ = std::mem::replace(&mut slice, &[]);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::mem::take(&mut slice)`
 
 error: replacing a value of type `T` with `T::default()` is better expressed using `std::mem::take`
-  --> $DIR/mem_replace.rs:89:13
+  --> $DIR/mem_replace.rs:97:13
    |
 LL |     let _ = std::mem::replace(&mut s, String::default());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::mem::take(&mut s)`
 
 error: replacing an `Option` with `None`
-  --> $DIR/mem_replace.rs:119:13
+  --> $DIR/mem_replace.rs:127:13
    |
 LL |     let _ = std::mem::replace(&mut f.0, None);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider `Option::take()` instead: `f.0.take()`
 
 error: replacing an `Option` with `None`
-  --> $DIR/mem_replace.rs:120:13
+  --> $DIR/mem_replace.rs:128:13
    |
 LL |     let _ = std::mem::replace(&mut *f, None);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider `Option::take()` instead: `(*f).take()`
 
 error: replacing an `Option` with `None`
-  --> $DIR/mem_replace.rs:121:13
+  --> $DIR/mem_replace.rs:129:13
    |
 LL |     let _ = std::mem::replace(&mut b.opt, None);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider `Option::take()` instead: `b.opt.take()`
 
 error: replacing a value of type `T` with `T::default()` is better expressed using `std::mem::take`
-  --> $DIR/mem_replace.rs:123:13
+  --> $DIR/mem_replace.rs:131:13
    |
 LL |     let _ = std::mem::replace(&mut b.val, String::default());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::mem::take(&mut b.val)`
diff --git a/tests/ui/mem_replace_macro.rs b/tests/ui/mem_replace_macro.rs
index 132873858b7..c14ea2942f3 100644
--- a/tests/ui/mem_replace_macro.rs
+++ b/tests/ui/mem_replace_macro.rs
@@ -7,6 +7,6 @@ use proc_macros::{external, inline_macros};
 #[inline_macros]
 fn main() {
     let s = &mut String::from("foo");
-    inline!(std::mem::replace($s, Default::default()));
-    external!(std::mem::replace($s, Default::default()));
+    let _ = inline!(std::mem::replace($s, Default::default()));
+    let _ = external!(std::mem::replace($s, Default::default()));
 }
diff --git a/tests/ui/mem_replace_macro.stderr b/tests/ui/mem_replace_macro.stderr
index c6435e94e96..63043e6bf26 100644
--- a/tests/ui/mem_replace_macro.stderr
+++ b/tests/ui/mem_replace_macro.stderr
@@ -1,8 +1,8 @@
 error: replacing a value of type `T` with `T::default()` is better expressed using `std::mem::take`
-  --> $DIR/mem_replace_macro.rs:10:13
+  --> $DIR/mem_replace_macro.rs:10:21
    |
-LL |     inline!(std::mem::replace($s, Default::default()));
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |     let _ = inline!(std::mem::replace($s, Default::default()));
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::mem-replace-with-default` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::mem_replace_with_default)]`
-- 
cgit 1.4.1-3-g733a5


From 7c8690ca978c20f675234e34f6bf062e2f5c718c Mon Sep 17 00:00:00 2001
From: Yuri Astrakhan <YuriAstrakhan@gmail.com>
Date: Mon, 12 Feb 2024 13:20:52 -0500
Subject: Minor refactor format-args

* Move all linting logic into a single format implementations struct

This should help with the future format-args improvements.
---
 clippy_lints/src/format_args.rs | 511 ++++++++++++++++++++--------------------
 1 file changed, 260 insertions(+), 251 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/format_args.rs b/clippy_lints/src/format_args.rs
index 8af321e4d55..0cd000915ed 100644
--- a/clippy_lints/src/format_args.rs
+++ b/clippy_lints/src/format_args.rs
@@ -4,7 +4,7 @@ use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::is_diag_trait_item;
 use clippy_utils::macros::{
     find_format_arg_expr, find_format_args, format_arg_removal_span, format_placeholder_format_span, is_assert_macro,
-    is_format_macro, is_panic, root_macro_call, root_macro_call_first_node, FormatParamUsage,
+    is_format_macro, is_panic, root_macro_call, root_macro_call_first_node, FormatParamUsage, MacroCall,
 };
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::{implements_trait, is_type_lang_item};
@@ -20,7 +20,6 @@ use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::ty::adjustment::{Adjust, Adjustment};
 use rustc_middle::ty::Ty;
 use rustc_session::impl_lint_pass;
-use rustc_span::def_id::DefId;
 use rustc_span::edition::Edition::Edition2021;
 use rustc_span::{sym, Span, Symbol};
 
@@ -189,32 +188,18 @@ impl<'tcx> LateLintPass<'tcx> for FormatArgs {
             && is_format_macro(cx, macro_call.def_id)
             && let Some(format_args) = find_format_args(cx, expr, macro_call.expn)
         {
-            for piece in &format_args.template {
-                if let FormatArgsPiece::Placeholder(placeholder) = piece
-                    && let Ok(index) = placeholder.argument.index
-                    && let Some(arg) = format_args.arguments.all_args().get(index)
-                {
-                    let arg_expr = find_format_arg_expr(expr, arg);
-
-                    check_unused_format_specifier(cx, placeholder, arg_expr);
-
-                    if placeholder.format_trait != FormatTrait::Display
-                        || placeholder.format_options != FormatOptions::default()
-                        || is_aliased(&format_args, index)
-                    {
-                        continue;
-                    }
+            let linter = FormatArgsExpr {
+                cx,
+                expr,
+                macro_call,
+                format_args: &format_args,
+                ignore_mixed: self.ignore_mixed,
+            };
 
-                    if let Ok(arg_hir_expr) = arg_expr {
-                        let name = cx.tcx.item_name(macro_call.def_id);
-                        check_format_in_format_args(cx, macro_call.span, name, arg_hir_expr);
-                        check_to_string_in_format_args(cx, name, arg_hir_expr);
-                    }
-                }
-            }
+            linter.check_templates();
 
             if self.msrv.meets(msrvs::FORMAT_ARGS_CAPTURE) {
-                check_uninlined_args(cx, &format_args, macro_call.span, macro_call.def_id, self.ignore_mixed);
+                linter.check_uninlined_args();
             }
         }
     }
@@ -222,255 +207,279 @@ impl<'tcx> LateLintPass<'tcx> for FormatArgs {
     extract_msrv_attr!(LateContext);
 }
 
-fn check_unused_format_specifier(
-    cx: &LateContext<'_>,
-    placeholder: &FormatPlaceholder,
-    arg_expr: Result<&Expr<'_>, &rustc_ast::Expr>,
-) {
-    let ty_or_ast_expr = arg_expr.map(|expr| cx.typeck_results().expr_ty(expr).peel_refs());
-
-    let is_format_args = match ty_or_ast_expr {
-        Ok(ty) => is_type_lang_item(cx, ty, LangItem::FormatArguments),
-        Err(expr) => matches!(expr.peel_parens_and_refs().kind, rustc_ast::ExprKind::FormatArgs(_)),
-    };
-
-    let options = &placeholder.format_options;
-
-    let arg_span = match arg_expr {
-        Ok(expr) => expr.span,
-        Err(expr) => expr.span,
-    };
-
-    if let Some(placeholder_span) = placeholder.span
-        && is_format_args
-        && *options != FormatOptions::default()
-    {
-        span_lint_and_then(
-            cx,
-            UNUSED_FORMAT_SPECS,
-            placeholder_span,
-            "format specifiers have no effect on `format_args!()`",
-            |diag| {
-                let mut suggest_format = |spec| {
-                    let message = format!("for the {spec} to apply consider using `format!()`");
-
-                    if let Some(mac_call) = root_macro_call(arg_span)
-                        && cx.tcx.is_diagnostic_item(sym::format_args_macro, mac_call.def_id)
-                    {
-                        diag.span_suggestion(
-                            cx.sess().source_map().span_until_char(mac_call.span, '!'),
-                            message,
-                            "format",
-                            Applicability::MaybeIncorrect,
-                        );
-                    } else {
-                        diag.help(message);
-                    }
-                };
+struct FormatArgsExpr<'a, 'tcx> {
+    cx: &'a LateContext<'tcx>,
+    expr: &'tcx Expr<'tcx>,
+    macro_call: MacroCall,
+    format_args: &'a rustc_ast::FormatArgs,
+    ignore_mixed: bool,
+}
 
-                if options.width.is_some() {
-                    suggest_format("width");
+impl<'a, 'tcx> FormatArgsExpr<'a, 'tcx> {
+    fn check_templates(&self) {
+        for piece in &self.format_args.template {
+            if let FormatArgsPiece::Placeholder(placeholder) = piece
+                && let Ok(index) = placeholder.argument.index
+                && let Some(arg) = self.format_args.arguments.all_args().get(index)
+            {
+                let arg_expr = find_format_arg_expr(self.expr, arg);
+
+                self.check_unused_format_specifier(placeholder, arg_expr);
+
+                if let Ok(arg_expr) = arg_expr
+                    && placeholder.format_trait == FormatTrait::Display
+                    && placeholder.format_options == FormatOptions::default()
+                    && !self.is_aliased(index)
+                {
+                    let name = self.cx.tcx.item_name(self.macro_call.def_id);
+                    self.check_format_in_format_args(name, arg_expr);
+                    self.check_to_string_in_format_args(name, arg_expr);
                 }
+            }
+        }
+    }
 
-                if options.precision.is_some() {
-                    suggest_format("precision");
-                }
+    fn check_unused_format_specifier(
+        &self,
+        placeholder: &FormatPlaceholder,
+        arg_expr: Result<&Expr<'_>, &rustc_ast::Expr>,
+    ) {
+        let ty_or_ast_expr = arg_expr.map(|expr| self.cx.typeck_results().expr_ty(expr).peel_refs());
 
-                if let Some(format_span) = format_placeholder_format_span(placeholder) {
-                    diag.span_suggestion_verbose(
-                        format_span,
-                        "if the current behavior is intentional, remove the format specifiers",
-                        "",
-                        Applicability::MaybeIncorrect,
-                    );
-                }
-            },
-        );
-    }
-}
+        let is_format_args = match ty_or_ast_expr {
+            Ok(ty) => is_type_lang_item(self.cx, ty, LangItem::FormatArguments),
+            Err(expr) => matches!(expr.peel_parens_and_refs().kind, rustc_ast::ExprKind::FormatArgs(_)),
+        };
 
-fn check_uninlined_args(
-    cx: &LateContext<'_>,
-    args: &rustc_ast::FormatArgs,
-    call_site: Span,
-    def_id: DefId,
-    ignore_mixed: bool,
-) {
-    if args.span.from_expansion() {
-        return;
-    }
-    if call_site.edition() < Edition2021 && (is_panic(cx, def_id) || is_assert_macro(cx, def_id)) {
-        // panic!, assert!, and debug_assert! before 2021 edition considers a single string argument as
-        // non-format
-        return;
+        let options = &placeholder.format_options;
+
+        let arg_span = match arg_expr {
+            Ok(expr) => expr.span,
+            Err(expr) => expr.span,
+        };
+
+        if let Some(placeholder_span) = placeholder.span
+            && is_format_args
+            && *options != FormatOptions::default()
+        {
+            span_lint_and_then(
+                self.cx,
+                UNUSED_FORMAT_SPECS,
+                placeholder_span,
+                "format specifiers have no effect on `format_args!()`",
+                |diag| {
+                    let mut suggest_format = |spec| {
+                        let message = format!("for the {spec} to apply consider using `format!()`");
+
+                        if let Some(mac_call) = root_macro_call(arg_span)
+                            && self.cx.tcx.is_diagnostic_item(sym::format_args_macro, mac_call.def_id)
+                        {
+                            diag.span_suggestion(
+                                self.cx.sess().source_map().span_until_char(mac_call.span, '!'),
+                                message,
+                                "format",
+                                Applicability::MaybeIncorrect,
+                            );
+                        } else {
+                            diag.help(message);
+                        }
+                    };
+
+                    if options.width.is_some() {
+                        suggest_format("width");
+                    }
+
+                    if options.precision.is_some() {
+                        suggest_format("precision");
+                    }
+
+                    if let Some(format_span) = format_placeholder_format_span(placeholder) {
+                        diag.span_suggestion_verbose(
+                            format_span,
+                            "if the current behavior is intentional, remove the format specifiers",
+                            "",
+                            Applicability::MaybeIncorrect,
+                        );
+                    }
+                },
+            );
+        }
     }
 
-    let mut fixes = Vec::new();
-    // If any of the arguments are referenced by an index number,
-    // and that argument is not a simple variable and cannot be inlined,
-    // we cannot remove any other arguments in the format string,
-    // because the index numbers might be wrong after inlining.
-    // Example of an un-inlinable format:  print!("{}{1}", foo, 2)
-    for (pos, usage) in format_arg_positions(args) {
-        if !check_one_arg(args, pos, usage, &mut fixes, ignore_mixed) {
+    fn check_uninlined_args(&self) {
+        if self.format_args.span.from_expansion() {
+            return;
+        }
+        if self.macro_call.span.edition() < Edition2021
+            && (is_panic(self.cx, self.macro_call.def_id) || is_assert_macro(self.cx, self.macro_call.def_id))
+        {
+            // panic!, assert!, and debug_assert! before 2021 edition considers a single string argument as
+            // non-format
             return;
         }
-    }
 
-    if fixes.is_empty() {
-        return;
-    }
+        let mut fixes = Vec::new();
+        // If any of the arguments are referenced by an index number,
+        // and that argument is not a simple variable and cannot be inlined,
+        // we cannot remove any other arguments in the format string,
+        // because the index numbers might be wrong after inlining.
+        // Example of an un-inlinable format:  print!("{}{1}", foo, 2)
+        for (pos, usage) in self.format_arg_positions() {
+            if !self.check_one_arg(pos, usage, &mut fixes) {
+                return;
+            }
+        }
 
-    // multiline span display suggestion is sometimes broken: https://github.com/rust-lang/rust/pull/102729#discussion_r988704308
-    // in those cases, make the code suggestion hidden
-    let multiline_fix = fixes.iter().any(|(span, _)| cx.sess().source_map().is_multiline(*span));
-
-    // Suggest removing each argument only once, for example in `format!("{0} {0}", arg)`.
-    fixes.sort_unstable_by_key(|(span, _)| *span);
-    fixes.dedup_by_key(|(span, _)| *span);
-
-    span_lint_and_then(
-        cx,
-        UNINLINED_FORMAT_ARGS,
-        call_site,
-        "variables can be used directly in the `format!` string",
-        |diag| {
-            diag.multipart_suggestion_with_style(
-                "change this to",
-                fixes,
-                Applicability::MachineApplicable,
-                if multiline_fix { CompletelyHidden } else { ShowCode },
-            );
-        },
-    );
-}
+        if fixes.is_empty() {
+            return;
+        }
 
-fn check_one_arg(
-    args: &rustc_ast::FormatArgs,
-    pos: &FormatArgPosition,
-    usage: FormatParamUsage,
-    fixes: &mut Vec<(Span, String)>,
-    ignore_mixed: bool,
-) -> bool {
-    let index = pos.index.unwrap();
-    let arg = &args.arguments.all_args()[index];
-
-    if !matches!(arg.kind, FormatArgumentKind::Captured(_))
-        && let rustc_ast::ExprKind::Path(None, path) = &arg.expr.kind
-        && let [segment] = path.segments.as_slice()
-        && segment.args.is_none()
-        && let Some(arg_span) = format_arg_removal_span(args, index)
-        && let Some(pos_span) = pos.span
-    {
-        let replacement = match usage {
-            FormatParamUsage::Argument => segment.ident.name.to_string(),
-            FormatParamUsage::Width => format!("{}$", segment.ident.name),
-            FormatParamUsage::Precision => format!(".{}$", segment.ident.name),
-        };
-        fixes.push((pos_span, replacement));
-        fixes.push((arg_span, String::new()));
-        true // successful inlining, continue checking
-    } else {
-        // Do not continue inlining (return false) in case
-        // * if we can't inline a numbered argument, e.g. `print!("{0} ...", foo.bar, ...)`
-        // * if allow_mixed_uninlined_format_args is false and this arg hasn't been inlined already
-        pos.kind != FormatArgPositionKind::Number
-            && (!ignore_mixed || matches!(arg.kind, FormatArgumentKind::Captured(_)))
-    }
-}
+        // multiline span display suggestion is sometimes broken: https://github.com/rust-lang/rust/pull/102729#discussion_r988704308
+        // in those cases, make the code suggestion hidden
+        let multiline_fix = fixes
+            .iter()
+            .any(|(span, _)| self.cx.sess().source_map().is_multiline(*span));
 
-fn check_format_in_format_args(cx: &LateContext<'_>, call_site: Span, name: Symbol, arg: &Expr<'_>) {
-    let expn_data = arg.span.ctxt().outer_expn_data();
-    if expn_data.call_site.from_expansion() {
-        return;
-    }
-    let Some(mac_id) = expn_data.macro_def_id else { return };
-    if !cx.tcx.is_diagnostic_item(sym::format_macro, mac_id) {
-        return;
+        // Suggest removing each argument only once, for example in `format!("{0} {0}", arg)`.
+        fixes.sort_unstable_by_key(|(span, _)| *span);
+        fixes.dedup_by_key(|(span, _)| *span);
+
+        span_lint_and_then(
+            self.cx,
+            UNINLINED_FORMAT_ARGS,
+            self.macro_call.span,
+            "variables can be used directly in the `format!` string",
+            |diag| {
+                diag.multipart_suggestion_with_style(
+                    "change this to",
+                    fixes,
+                    Applicability::MachineApplicable,
+                    if multiline_fix { CompletelyHidden } else { ShowCode },
+                );
+            },
+        );
     }
-    span_lint_and_then(
-        cx,
-        FORMAT_IN_FORMAT_ARGS,
-        call_site,
-        &format!("`format!` in `{name}!` args"),
-        |diag| {
-            diag.help(format!(
-                "combine the `format!(..)` arguments with the outer `{name}!(..)` call"
-            ));
-            diag.help("or consider changing `format!` to `format_args!`");
-        },
-    );
-}
 
-fn check_to_string_in_format_args(cx: &LateContext<'_>, name: Symbol, value: &Expr<'_>) {
-    if !value.span.from_expansion()
-        && let ExprKind::MethodCall(_, receiver, [], to_string_span) = value.kind
-        && let Some(method_def_id) = cx.typeck_results().type_dependent_def_id(value.hir_id)
-        && is_diag_trait_item(cx, method_def_id, sym::ToString)
-        && let receiver_ty = cx.typeck_results().expr_ty(receiver)
-        && let Some(display_trait_id) = cx.tcx.get_diagnostic_item(sym::Display)
-        && let (n_needed_derefs, target) =
-            count_needed_derefs(receiver_ty, cx.typeck_results().expr_adjustments(receiver).iter())
-        && implements_trait(cx, target, display_trait_id, &[])
-        && let Some(sized_trait_id) = cx.tcx.lang_items().sized_trait()
-        && let Some(receiver_snippet) = snippet_opt(cx, receiver.span)
-    {
-        let needs_ref = !implements_trait(cx, receiver_ty, sized_trait_id, &[]);
-        if n_needed_derefs == 0 && !needs_ref {
-            span_lint_and_sugg(
-                cx,
-                TO_STRING_IN_FORMAT_ARGS,
-                to_string_span.with_lo(receiver.span.hi()),
-                &format!("`to_string` applied to a type that implements `Display` in `{name}!` args"),
-                "remove this",
-                String::new(),
-                Applicability::MachineApplicable,
-            );
+    fn check_one_arg(&self, pos: &FormatArgPosition, usage: FormatParamUsage, fixes: &mut Vec<(Span, String)>) -> bool {
+        let index = pos.index.unwrap();
+        let arg = &self.format_args.arguments.all_args()[index];
+
+        if !matches!(arg.kind, FormatArgumentKind::Captured(_))
+            && let rustc_ast::ExprKind::Path(None, path) = &arg.expr.kind
+            && let [segment] = path.segments.as_slice()
+            && segment.args.is_none()
+            && let Some(arg_span) = format_arg_removal_span(self.format_args, index)
+            && let Some(pos_span) = pos.span
+        {
+            let replacement = match usage {
+                FormatParamUsage::Argument => segment.ident.name.to_string(),
+                FormatParamUsage::Width => format!("{}$", segment.ident.name),
+                FormatParamUsage::Precision => format!(".{}$", segment.ident.name),
+            };
+            fixes.push((pos_span, replacement));
+            fixes.push((arg_span, String::new()));
+            true // successful inlining, continue checking
         } else {
-            span_lint_and_sugg(
-                cx,
-                TO_STRING_IN_FORMAT_ARGS,
-                value.span,
-                &format!("`to_string` applied to a type that implements `Display` in `{name}!` args"),
-                "use this",
-                format!(
-                    "{}{:*>n_needed_derefs$}{receiver_snippet}",
-                    if needs_ref { "&" } else { "" },
-                    ""
-                ),
-                Applicability::MachineApplicable,
-            );
+            // Do not continue inlining (return false) in case
+            // * if we can't inline a numbered argument, e.g. `print!("{0} ...", foo.bar, ...)`
+            // * if allow_mixed_uninlined_format_args is false and this arg hasn't been inlined already
+            pos.kind != FormatArgPositionKind::Number
+                && (!self.ignore_mixed || matches!(arg.kind, FormatArgumentKind::Captured(_)))
         }
     }
-}
 
-fn format_arg_positions(
-    format_args: &rustc_ast::FormatArgs,
-) -> impl Iterator<Item = (&FormatArgPosition, FormatParamUsage)> {
-    format_args.template.iter().flat_map(|piece| match piece {
-        FormatArgsPiece::Placeholder(placeholder) => {
-            let mut positions = ArrayVec::<_, 3>::new();
+    fn check_format_in_format_args(&self, name: Symbol, arg: &Expr<'_>) {
+        let expn_data = arg.span.ctxt().outer_expn_data();
+        if expn_data.call_site.from_expansion() {
+            return;
+        }
+        let Some(mac_id) = expn_data.macro_def_id else { return };
+        if !self.cx.tcx.is_diagnostic_item(sym::format_macro, mac_id) {
+            return;
+        }
+        span_lint_and_then(
+            self.cx,
+            FORMAT_IN_FORMAT_ARGS,
+            self.macro_call.span,
+            &format!("`format!` in `{name}!` args"),
+            |diag| {
+                diag.help(format!(
+                    "combine the `format!(..)` arguments with the outer `{name}!(..)` call"
+                ));
+                diag.help("or consider changing `format!` to `format_args!`");
+            },
+        );
+    }
 
-            positions.push((&placeholder.argument, FormatParamUsage::Argument));
-            if let Some(FormatCount::Argument(position)) = &placeholder.format_options.width {
-                positions.push((position, FormatParamUsage::Width));
-            }
-            if let Some(FormatCount::Argument(position)) = &placeholder.format_options.precision {
-                positions.push((position, FormatParamUsage::Precision));
+    fn check_to_string_in_format_args(&self, name: Symbol, value: &Expr<'_>) {
+        let cx = self.cx;
+        if !value.span.from_expansion()
+            && let ExprKind::MethodCall(_, receiver, [], to_string_span) = value.kind
+            && let Some(method_def_id) = cx.typeck_results().type_dependent_def_id(value.hir_id)
+            && is_diag_trait_item(cx, method_def_id, sym::ToString)
+            && let receiver_ty = cx.typeck_results().expr_ty(receiver)
+            && let Some(display_trait_id) = cx.tcx.get_diagnostic_item(sym::Display)
+            && let (n_needed_derefs, target) =
+                count_needed_derefs(receiver_ty, cx.typeck_results().expr_adjustments(receiver).iter())
+            && implements_trait(cx, target, display_trait_id, &[])
+            && let Some(sized_trait_id) = cx.tcx.lang_items().sized_trait()
+            && let Some(receiver_snippet) = snippet_opt(cx, receiver.span)
+        {
+            let needs_ref = !implements_trait(cx, receiver_ty, sized_trait_id, &[]);
+            if n_needed_derefs == 0 && !needs_ref {
+                span_lint_and_sugg(
+                    cx,
+                    TO_STRING_IN_FORMAT_ARGS,
+                    to_string_span.with_lo(receiver.span.hi()),
+                    &format!("`to_string` applied to a type that implements `Display` in `{name}!` args"),
+                    "remove this",
+                    String::new(),
+                    Applicability::MachineApplicable,
+                );
+            } else {
+                span_lint_and_sugg(
+                    cx,
+                    TO_STRING_IN_FORMAT_ARGS,
+                    value.span,
+                    &format!("`to_string` applied to a type that implements `Display` in `{name}!` args"),
+                    "use this",
+                    format!(
+                        "{}{:*>n_needed_derefs$}{receiver_snippet}",
+                        if needs_ref { "&" } else { "" },
+                        ""
+                    ),
+                    Applicability::MachineApplicable,
+                );
             }
+        }
+    }
 
-            positions
-        },
-        FormatArgsPiece::Literal(_) => ArrayVec::new(),
-    })
-}
+    fn format_arg_positions(&self) -> impl Iterator<Item = (&FormatArgPosition, FormatParamUsage)> {
+        self.format_args.template.iter().flat_map(|piece| match piece {
+            FormatArgsPiece::Placeholder(placeholder) => {
+                let mut positions = ArrayVec::<_, 3>::new();
 
-/// Returns true if the format argument at `index` is referred to by multiple format params
-fn is_aliased(format_args: &rustc_ast::FormatArgs, index: usize) -> bool {
-    format_arg_positions(format_args)
-        .filter(|(position, _)| position.index == Ok(index))
-        .at_most_one()
-        .is_err()
+                positions.push((&placeholder.argument, FormatParamUsage::Argument));
+                if let Some(FormatCount::Argument(position)) = &placeholder.format_options.width {
+                    positions.push((position, FormatParamUsage::Width));
+                }
+                if let Some(FormatCount::Argument(position)) = &placeholder.format_options.precision {
+                    positions.push((position, FormatParamUsage::Precision));
+                }
+
+                positions
+            },
+            FormatArgsPiece::Literal(_) => ArrayVec::new(),
+        })
+    }
+
+    /// Returns true if the format argument at `index` is referred to by multiple format params
+    fn is_aliased(&self, index: usize) -> bool {
+        self.format_arg_positions()
+            .filter(|(position, _)| position.index == Ok(index))
+            .at_most_one()
+            .is_err()
+    }
 }
 
 fn count_needed_derefs<'tcx, I>(mut ty: Ty<'tcx>, mut iter: I) -> (usize, Ty<'tcx>)
-- 
cgit 1.4.1-3-g733a5


From 2c3ae882e85a902cfad7ec4eee7c3086cfd8da08 Mon Sep 17 00:00:00 2001
From: Yuri Astrakhan <YuriAstrakhan@gmail.com>
Date: Mon, 12 Feb 2024 13:32:09 -0500
Subject: Make macro_call a ref

---
 clippy_lints/src/format_args.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/format_args.rs b/clippy_lints/src/format_args.rs
index 0cd000915ed..61f550ce0be 100644
--- a/clippy_lints/src/format_args.rs
+++ b/clippy_lints/src/format_args.rs
@@ -191,7 +191,7 @@ impl<'tcx> LateLintPass<'tcx> for FormatArgs {
             let linter = FormatArgsExpr {
                 cx,
                 expr,
-                macro_call,
+                macro_call: &macro_call,
                 format_args: &format_args,
                 ignore_mixed: self.ignore_mixed,
             };
@@ -210,7 +210,7 @@ impl<'tcx> LateLintPass<'tcx> for FormatArgs {
 struct FormatArgsExpr<'a, 'tcx> {
     cx: &'a LateContext<'tcx>,
     expr: &'tcx Expr<'tcx>,
-    macro_call: MacroCall,
+    macro_call: &'a MacroCall,
     format_args: &'a rustc_ast::FormatArgs,
     ignore_mixed: bool,
 }
-- 
cgit 1.4.1-3-g733a5


From c1c2c3e60c667660f73074199f261b73638e3593 Mon Sep 17 00:00:00 2001
From: Ethiraric <ethiraric@gmail.com>
Date: Mon, 12 Feb 2024 23:16:47 +0100
Subject: Ignore imported items in `min_ident_chars`

Suppress the `min_ident_chars` warning for items whose name we cannot
control. Do not warn for `use a::b`, but warn for `use a::b as c`, since
`c` is a local identifier.

Fixes #12232
---
 clippy_lints/src/min_ident_chars.rs                | 34 ++++++++++++++++++++--
 .../min_ident_chars/auxiliary/extern_types.rs      |  6 ++++
 tests/ui-toml/min_ident_chars/min_ident_chars.rs   |  5 +++-
 .../ui-toml/min_ident_chars/min_ident_chars.stderr | 28 +++++++++++-------
 4 files changed, 58 insertions(+), 15 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/min_ident_chars.rs b/clippy_lints/src/min_ident_chars.rs
index 41168230752..79883c4ec77 100644
--- a/clippy_lints/src/min_ident_chars.rs
+++ b/clippy_lints/src/min_ident_chars.rs
@@ -3,7 +3,7 @@ use clippy_utils::is_from_proc_macro;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::intravisit::{walk_item, Visitor};
-use rustc_hir::{GenericParamKind, HirId, Item, ItemKind, ItemLocalId, Node, Pat, PatKind};
+use rustc_hir::{GenericParamKind, HirId, Item, ItemKind, ItemLocalId, Node, Pat, PatKind, UsePath};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::impl_lint_pass;
@@ -105,11 +105,26 @@ impl Visitor<'_> for IdentVisitor<'_, '_> {
 
         let str = ident.as_str();
         if conf.is_ident_too_short(cx, str, ident.span) {
-            if let Node::Item(item) = node
-                && let ItemKind::Use(..) = item.kind
+            // Check whether the node is part of a `use` statement. We don't want to emit a warning if the user
+            // has no control over the type.
+            let usenode = opt_as_use_node(node).or_else(|| {
+                cx.tcx
+                    .hir()
+                    .parent_iter(hir_id)
+                    .find_map(|(_, node)| opt_as_use_node(node))
+            });
+
+            // If the name of the identifier is the same as the one of the imported item, this means that we
+            // found a `use foo::bar`. We can early-return to not emit the warning.
+            // If however the identifier is different, this means it is an alias (`use foo::bar as baz`). In
+            // this case, we need to emit the warning for `baz`.
+            if let Some(imported_item_path) = usenode
+                && let Some(Res::Def(_, imported_item_defid)) = imported_item_path.res.first()
+                && cx.tcx.item_name(*imported_item_defid).as_str() == str
             {
                 return;
             }
+
             // `struct Awa<T>(T)`
             //                ^
             if let Node::PathSegment(path) = node {
@@ -160,3 +175,16 @@ fn emit_min_ident_chars(conf: &MinIdentChars, cx: &impl LintContext, ident: &str
     };
     span_lint(cx, MIN_IDENT_CHARS, span, &help);
 }
+
+/// Attempt to convert the node to an [`ItemKind::Use`] node.
+///
+/// If it is, return the [`UsePath`] contained within.
+fn opt_as_use_node(node: Node<'_>) -> Option<&'_ UsePath<'_>> {
+    if let Node::Item(item) = node
+        && let ItemKind::Use(path, _) = item.kind
+    {
+        Some(path)
+    } else {
+        None
+    }
+}
diff --git a/tests/ui-toml/min_ident_chars/auxiliary/extern_types.rs b/tests/ui-toml/min_ident_chars/auxiliary/extern_types.rs
index 06a144f2218..1f1f1c6f1a3 100644
--- a/tests/ui-toml/min_ident_chars/auxiliary/extern_types.rs
+++ b/tests/ui-toml/min_ident_chars/auxiliary/extern_types.rs
@@ -1,3 +1,9 @@
 #![allow(nonstandard_style, unused)]
 
 pub struct Aaa;
+pub struct Bbb;
+
+pub const N: u32 = 3;
+
+pub const M: u32 = 2;
+pub const LONGER: u32 = 32;
diff --git a/tests/ui-toml/min_ident_chars/min_ident_chars.rs b/tests/ui-toml/min_ident_chars/min_ident_chars.rs
index 4326c7159c8..ded3c72c3e0 100644
--- a/tests/ui-toml/min_ident_chars/min_ident_chars.rs
+++ b/tests/ui-toml/min_ident_chars/min_ident_chars.rs
@@ -3,7 +3,10 @@
 #![warn(clippy::min_ident_chars)]
 
 extern crate extern_types;
-use extern_types::Aaa;
+use extern_types::{Aaa, LONGER, M, N as W};
+
+pub const N: u32 = 0;
+pub const LONG: u32 = 32;
 
 struct Owo {
     Uwu: u128,
diff --git a/tests/ui-toml/min_ident_chars/min_ident_chars.stderr b/tests/ui-toml/min_ident_chars/min_ident_chars.stderr
index 7f00fac4924..b498fd33650 100644
--- a/tests/ui-toml/min_ident_chars/min_ident_chars.stderr
+++ b/tests/ui-toml/min_ident_chars/min_ident_chars.stderr
@@ -1,47 +1,53 @@
-error: this ident is too short (3 <= 3)
-  --> $DIR/min_ident_chars.rs:6:19
+error: this ident is too short (1 <= 3)
+  --> $DIR/min_ident_chars.rs:6:41
    |
-LL | use extern_types::Aaa;
-   |                   ^^^
+LL | use extern_types::{Aaa, LONGER, M, N as W};
+   |                                         ^
    |
    = note: `-D clippy::min-ident-chars` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::min_ident_chars)]`
 
+error: this ident is too short (1 <= 3)
+  --> $DIR/min_ident_chars.rs:8:11
+   |
+LL | pub const N: u32 = 0;
+   |           ^
+
 error: this ident is too short (3 <= 3)
-  --> $DIR/min_ident_chars.rs:10:5
+  --> $DIR/min_ident_chars.rs:13:5
    |
 LL |     aaa: Aaa,
    |     ^^^
 
 error: this ident is too short (3 <= 3)
-  --> $DIR/min_ident_chars.rs:15:9
+  --> $DIR/min_ident_chars.rs:18:9
    |
 LL |     let vvv = 1;
    |         ^^^
 
 error: this ident is too short (3 <= 3)
-  --> $DIR/min_ident_chars.rs:16:9
+  --> $DIR/min_ident_chars.rs:19:9
    |
 LL |     let uuu = 1;
    |         ^^^
 
 error: this ident is too short (1 <= 3)
-  --> $DIR/min_ident_chars.rs:17:14
+  --> $DIR/min_ident_chars.rs:20:14
    |
 LL |     let (mut a, mut b) = (1, 2);
    |              ^
 
 error: this ident is too short (1 <= 3)
-  --> $DIR/min_ident_chars.rs:17:21
+  --> $DIR/min_ident_chars.rs:20:21
    |
 LL |     let (mut a, mut b) = (1, 2);
    |                     ^
 
 error: this ident is too short (1 <= 3)
-  --> $DIR/min_ident_chars.rs:18:9
+  --> $DIR/min_ident_chars.rs:21:9
    |
 LL |     for i in 0..1000 {}
    |         ^
 
-error: aborting due to 7 previous errors
+error: aborting due to 8 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From b32d7c063106a1ac4a989be7d051b756f007c1f3 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Wed, 14 Feb 2024 13:31:02 +0000
Subject: Allow negative literals in `redundant_guards`

---
 clippy_lints/src/matches/redundant_guards.rs |  8 +++-
 tests/ui/redundant_guards.fixed              |  8 ++++
 tests/ui/redundant_guards.rs                 |  8 ++++
 tests/ui/redundant_guards.stderr             | 56 ++++++++++++++++++++--------
 4 files changed, 62 insertions(+), 18 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/matches/redundant_guards.rs b/clippy_lints/src/matches/redundant_guards.rs
index dfaaeb14ca3..a4374b28fa1 100644
--- a/clippy_lints/src/matches/redundant_guards.rs
+++ b/clippy_lints/src/matches/redundant_guards.rs
@@ -5,7 +5,7 @@ use clippy_utils::visitors::{for_each_expr, is_local_used};
 use rustc_ast::{BorrowKind, LitKind};
 use rustc_errors::Applicability;
 use rustc_hir::def::{DefKind, Res};
-use rustc_hir::{Arm, BinOpKind, Expr, ExprKind, MatchSource, Node, Pat, PatKind};
+use rustc_hir::{Arm, BinOpKind, Expr, ExprKind, MatchSource, Node, Pat, PatKind, UnOp};
 use rustc_lint::LateContext;
 use rustc_span::symbol::Ident;
 use rustc_span::{Span, Symbol};
@@ -269,7 +269,11 @@ fn expr_can_be_pat(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
                     Res::Def(DefKind::Struct | DefKind::Enum | DefKind::Ctor(..), ..),
                 )
             },
-            ExprKind::AddrOf(..) | ExprKind::Array(..) | ExprKind::Tup(..) | ExprKind::Struct(..) => true,
+            ExprKind::AddrOf(..)
+            | ExprKind::Array(..)
+            | ExprKind::Tup(..)
+            | ExprKind::Struct(..)
+            | ExprKind::Unary(UnOp::Neg, _) => true,
             ExprKind::Lit(lit) if !matches!(lit.node, LitKind::Float(..)) => true,
             _ => false,
         } {
diff --git a/tests/ui/redundant_guards.fixed b/tests/ui/redundant_guards.fixed
index aef26ef225c..0a2ae911ad4 100644
--- a/tests/ui/redundant_guards.fixed
+++ b/tests/ui/redundant_guards.fixed
@@ -117,6 +117,14 @@ fn h(v: Option<u32>) {
     };
 }
 
+fn negative_literal(i: i32) {
+    match i {
+        -1 => {},
+        1 => {},
+        _ => {},
+    }
+}
+
 // Do not lint
 
 fn f(s: Option<std::ffi::OsString>) {
diff --git a/tests/ui/redundant_guards.rs b/tests/ui/redundant_guards.rs
index 5d476f5b040..c8656f26ef3 100644
--- a/tests/ui/redundant_guards.rs
+++ b/tests/ui/redundant_guards.rs
@@ -117,6 +117,14 @@ fn h(v: Option<u32>) {
     };
 }
 
+fn negative_literal(i: i32) {
+    match i {
+        i if i == -1 => {},
+        i if i == 1 => {},
+        _ => {},
+    }
+}
+
 // Do not lint
 
 fn f(s: Option<std::ffi::OsString>) {
diff --git a/tests/ui/redundant_guards.stderr b/tests/ui/redundant_guards.stderr
index f78d2a814f9..27bd8bfabb1 100644
--- a/tests/ui/redundant_guards.stderr
+++ b/tests/ui/redundant_guards.stderr
@@ -108,7 +108,31 @@ LL +         Some(0) => ..,
    |
 
 error: redundant guard
-  --> $DIR/redundant_guards.rs:165:28
+  --> $DIR/redundant_guards.rs:122:14
+   |
+LL |         i if i == -1 => {},
+   |              ^^^^^^^
+   |
+help: try
+   |
+LL -         i if i == -1 => {},
+LL +         -1 => {},
+   |
+
+error: redundant guard
+  --> $DIR/redundant_guards.rs:123:14
+   |
+LL |         i if i == 1 => {},
+   |              ^^^^^^
+   |
+help: try
+   |
+LL -         i if i == 1 => {},
+LL +         1 => {},
+   |
+
+error: redundant guard
+  --> $DIR/redundant_guards.rs:173:28
    |
 LL |             Some(ref x) if x == &1 => {},
    |                            ^^^^^^^
@@ -120,7 +144,7 @@ LL +             Some(1) => {},
    |
 
 error: redundant guard
-  --> $DIR/redundant_guards.rs:166:28
+  --> $DIR/redundant_guards.rs:174:28
    |
 LL |             Some(ref x) if &1 == x => {},
    |                            ^^^^^^^
@@ -132,7 +156,7 @@ LL +             Some(1) => {},
    |
 
 error: redundant guard
-  --> $DIR/redundant_guards.rs:167:28
+  --> $DIR/redundant_guards.rs:175:28
    |
 LL |             Some(ref x) if let &2 = x => {},
    |                            ^^^^^^^^^^
@@ -144,7 +168,7 @@ LL +             Some(2) => {},
    |
 
 error: redundant guard
-  --> $DIR/redundant_guards.rs:168:28
+  --> $DIR/redundant_guards.rs:176:28
    |
 LL |             Some(ref x) if matches!(x, &3) => {},
    |                            ^^^^^^^^^^^^^^^
@@ -156,7 +180,7 @@ LL +             Some(3) => {},
    |
 
 error: redundant guard
-  --> $DIR/redundant_guards.rs:188:32
+  --> $DIR/redundant_guards.rs:196:32
    |
 LL |             B { ref c, .. } if c == &1 => {},
    |                                ^^^^^^^
@@ -168,7 +192,7 @@ LL +             B { c: 1, .. } => {},
    |
 
 error: redundant guard
-  --> $DIR/redundant_guards.rs:189:32
+  --> $DIR/redundant_guards.rs:197:32
    |
 LL |             B { ref c, .. } if &1 == c => {},
    |                                ^^^^^^^
@@ -180,7 +204,7 @@ LL +             B { c: 1, .. } => {},
    |
 
 error: redundant guard
-  --> $DIR/redundant_guards.rs:190:32
+  --> $DIR/redundant_guards.rs:198:32
    |
 LL |             B { ref c, .. } if let &1 = c => {},
    |                                ^^^^^^^^^^
@@ -192,7 +216,7 @@ LL +             B { c: 1, .. } => {},
    |
 
 error: redundant guard
-  --> $DIR/redundant_guards.rs:191:32
+  --> $DIR/redundant_guards.rs:199:32
    |
 LL |             B { ref c, .. } if matches!(c, &1) => {},
    |                                ^^^^^^^^^^^^^^^
@@ -204,7 +228,7 @@ LL +             B { c: 1, .. } => {},
    |
 
 error: redundant guard
-  --> $DIR/redundant_guards.rs:201:26
+  --> $DIR/redundant_guards.rs:209:26
    |
 LL |         Some(Some(x)) if x.is_empty() => {},
    |                          ^^^^^^^^^^^^
@@ -216,7 +240,7 @@ LL +         Some(Some("")) => {},
    |
 
 error: redundant guard
-  --> $DIR/redundant_guards.rs:212:26
+  --> $DIR/redundant_guards.rs:220:26
    |
 LL |         Some(Some(x)) if x.is_empty() => {},
    |                          ^^^^^^^^^^^^
@@ -228,7 +252,7 @@ LL +         Some(Some([])) => {},
    |
 
 error: redundant guard
-  --> $DIR/redundant_guards.rs:217:26
+  --> $DIR/redundant_guards.rs:225:26
    |
 LL |         Some(Some(x)) if x.is_empty() => {},
    |                          ^^^^^^^^^^^^
@@ -240,7 +264,7 @@ LL +         Some(Some([])) => {},
    |
 
 error: redundant guard
-  --> $DIR/redundant_guards.rs:228:26
+  --> $DIR/redundant_guards.rs:236:26
    |
 LL |         Some(Some(x)) if x.starts_with(&[]) => {},
    |                          ^^^^^^^^^^^^^^^^^^
@@ -252,7 +276,7 @@ LL +         Some(Some([..])) => {},
    |
 
 error: redundant guard
-  --> $DIR/redundant_guards.rs:233:26
+  --> $DIR/redundant_guards.rs:241:26
    |
 LL |         Some(Some(x)) if x.starts_with(&[1]) => {},
    |                          ^^^^^^^^^^^^^^^^^^^
@@ -264,7 +288,7 @@ LL +         Some(Some([1, ..])) => {},
    |
 
 error: redundant guard
-  --> $DIR/redundant_guards.rs:238:26
+  --> $DIR/redundant_guards.rs:246:26
    |
 LL |         Some(Some(x)) if x.starts_with(&[1, 2]) => {},
    |                          ^^^^^^^^^^^^^^^^^^^^^^
@@ -276,7 +300,7 @@ LL +         Some(Some([1, 2, ..])) => {},
    |
 
 error: redundant guard
-  --> $DIR/redundant_guards.rs:243:26
+  --> $DIR/redundant_guards.rs:251:26
    |
 LL |         Some(Some(x)) if x.ends_with(&[1, 2]) => {},
    |                          ^^^^^^^^^^^^^^^^^^^^
@@ -287,5 +311,5 @@ LL -         Some(Some(x)) if x.ends_with(&[1, 2]) => {},
 LL +         Some(Some([.., 1, 2])) => {},
    |
 
-error: aborting due to 24 previous errors
+error: aborting due to 26 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 9492de509fbf0793019dfe5ff8583b9a2c88dd83 Mon Sep 17 00:00:00 2001
From: Ethiraric <ethiraric@gmail.com>
Date: Wed, 14 Feb 2024 18:26:06 +0100
Subject: [`case_sensitive_file_extension_comparisons`]: Don't trigger on
 digits-only extensions

---
 .../src/methods/case_sensitive_file_extension_comparisons.rs         | 1 +
 tests/ui/case_sensitive_file_extension_comparisons.fixed             | 5 +++++
 tests/ui/case_sensitive_file_extension_comparisons.rs                | 5 +++++
 3 files changed, 11 insertions(+)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/case_sensitive_file_extension_comparisons.rs b/clippy_lints/src/methods/case_sensitive_file_extension_comparisons.rs
index a37087d0abf..a5df863d800 100644
--- a/clippy_lints/src/methods/case_sensitive_file_extension_comparisons.rs
+++ b/clippy_lints/src/methods/case_sensitive_file_extension_comparisons.rs
@@ -38,6 +38,7 @@ pub(super) fn check<'tcx>(
         && ext_str.starts_with('.')
         && (ext_str.chars().skip(1).all(|c| c.is_uppercase() || c.is_ascii_digit())
             || ext_str.chars().skip(1).all(|c| c.is_lowercase() || c.is_ascii_digit()))
+        && !ext_str.chars().skip(1).all(|c| c.is_ascii_digit())
         && let recv_ty = cx.typeck_results().expr_ty(recv).peel_refs()
         && (recv_ty.is_str() || is_type_lang_item(cx, recv_ty, LangItem::String))
     {
diff --git a/tests/ui/case_sensitive_file_extension_comparisons.fixed b/tests/ui/case_sensitive_file_extension_comparisons.fixed
index a816224c91c..8b4a165a97c 100644
--- a/tests/ui/case_sensitive_file_extension_comparisons.fixed
+++ b/tests/ui/case_sensitive_file_extension_comparisons.fixed
@@ -63,4 +63,9 @@ fn main() {
     let _ = String::new().ends_with("a.ext");
     let _ = "str".ends_with("a.extA");
     TestStruct {}.ends_with("a.ext");
+
+    // Shouldn't fail if the extension has no ascii letter
+    let _ = String::new().ends_with(".123");
+    let _ = "str".ends_with(".123");
+    TestStruct {}.ends_with(".123");
 }
diff --git a/tests/ui/case_sensitive_file_extension_comparisons.rs b/tests/ui/case_sensitive_file_extension_comparisons.rs
index 994de2805f7..e4b8178110b 100644
--- a/tests/ui/case_sensitive_file_extension_comparisons.rs
+++ b/tests/ui/case_sensitive_file_extension_comparisons.rs
@@ -51,4 +51,9 @@ fn main() {
     let _ = String::new().ends_with("a.ext");
     let _ = "str".ends_with("a.extA");
     TestStruct {}.ends_with("a.ext");
+
+    // Shouldn't fail if the extension has no ascii letter
+    let _ = String::new().ends_with(".123");
+    let _ = "str".ends_with(".123");
+    TestStruct {}.ends_with(".123");
 }
-- 
cgit 1.4.1-3-g733a5


From 2526765fc83d0591828e95c7a621ee672244de12 Mon Sep 17 00:00:00 2001
From: Seo Sanghyeon <sanxiyn@gmail.com>
Date: Thu, 15 Feb 2024 06:22:15 +0900
Subject: Check trait items

---
 clippy_lints/src/min_ident_chars.rs | 12 ++++++--
 tests/ui/min_ident_chars.rs         |  6 ++++
 tests/ui/min_ident_chars.stderr     | 56 ++++++++++++++++++++++++-------------
 3 files changed, 53 insertions(+), 21 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/min_ident_chars.rs b/clippy_lints/src/min_ident_chars.rs
index 79883c4ec77..ec07f283c46 100644
--- a/clippy_lints/src/min_ident_chars.rs
+++ b/clippy_lints/src/min_ident_chars.rs
@@ -2,8 +2,8 @@ use clippy_utils::diagnostics::span_lint;
 use clippy_utils::is_from_proc_macro;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_hir::def::{DefKind, Res};
-use rustc_hir::intravisit::{walk_item, Visitor};
-use rustc_hir::{GenericParamKind, HirId, Item, ItemKind, ItemLocalId, Node, Pat, PatKind, UsePath};
+use rustc_hir::intravisit::{walk_item, walk_trait_item, Visitor};
+use rustc_hir::{GenericParamKind, HirId, Item, ItemKind, ItemLocalId, Node, Pat, PatKind, TraitItem, UsePath};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::impl_lint_pass;
@@ -66,6 +66,14 @@ impl LateLintPass<'_> for MinIdentChars {
         walk_item(&mut IdentVisitor { conf: self, cx }, item);
     }
 
+    fn check_trait_item(&mut self, cx: &LateContext<'_>, item: &TraitItem<'_>) {
+        if self.min_ident_chars_threshold == 0 {
+            return;
+        }
+
+        walk_trait_item(&mut IdentVisitor { conf: self, cx }, item);
+    }
+
     // This is necessary as `Node::Pat`s are not visited in `visit_id`. :/
     fn check_pat(&mut self, cx: &LateContext<'_>, pat: &Pat<'_>) {
         if let PatKind::Binding(_, _, ident, ..) = pat.kind
diff --git a/tests/ui/min_ident_chars.rs b/tests/ui/min_ident_chars.rs
index f99c35d5c57..1d89f26b6ee 100644
--- a/tests/ui/min_ident_chars.rs
+++ b/tests/ui/min_ident_chars.rs
@@ -37,6 +37,12 @@ struct Vec4 {
 
 struct AA<T, E>(T, E);
 
+trait Trait {
+    const A: u32 = 0;
+    type A;
+    fn a() {}
+}
+
 fn main() {
     // Allowed idents
     let w = 1;
diff --git a/tests/ui/min_ident_chars.stderr b/tests/ui/min_ident_chars.stderr
index e4181157ea2..7490878d572 100644
--- a/tests/ui/min_ident_chars.stderr
+++ b/tests/ui/min_ident_chars.stderr
@@ -68,112 +68,130 @@ LL |     F,
    |     ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:51:9
+  --> $DIR/min_ident_chars.rs:41:11
+   |
+LL |     const A: u32 = 0;
+   |           ^
+
+error: this ident consists of a single char
+  --> $DIR/min_ident_chars.rs:42:10
+   |
+LL |     type A;
+   |          ^
+
+error: this ident consists of a single char
+  --> $DIR/min_ident_chars.rs:43:8
+   |
+LL |     fn a() {}
+   |        ^
+
+error: this ident consists of a single char
+  --> $DIR/min_ident_chars.rs:57:9
    |
 LL |     let h = 1;
    |         ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:52:9
+  --> $DIR/min_ident_chars.rs:58:9
    |
 LL |     let e = 2;
    |         ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:53:9
+  --> $DIR/min_ident_chars.rs:59:9
    |
 LL |     let l = 3;
    |         ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:54:9
+  --> $DIR/min_ident_chars.rs:60:9
    |
 LL |     let l = 4;
    |         ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:55:9
+  --> $DIR/min_ident_chars.rs:61:9
    |
 LL |     let o = 6;
    |         ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:59:10
+  --> $DIR/min_ident_chars.rs:65:10
    |
 LL |     let (h, o, w) = (1, 2, 3);
    |          ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:59:13
+  --> $DIR/min_ident_chars.rs:65:13
    |
 LL |     let (h, o, w) = (1, 2, 3);
    |             ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:60:10
+  --> $DIR/min_ident_chars.rs:66:10
    |
 LL |     for (a, (r, e)) in (0..1000).enumerate().enumerate() {}
    |          ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:60:14
+  --> $DIR/min_ident_chars.rs:66:14
    |
 LL |     for (a, (r, e)) in (0..1000).enumerate().enumerate() {}
    |              ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:60:17
+  --> $DIR/min_ident_chars.rs:66:17
    |
 LL |     for (a, (r, e)) in (0..1000).enumerate().enumerate() {}
    |                 ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:62:16
+  --> $DIR/min_ident_chars.rs:68:16
    |
 LL |     while let (d, o, _i, n, g) = (true, true, false, false, true) {}
    |                ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:62:19
+  --> $DIR/min_ident_chars.rs:68:19
    |
 LL |     while let (d, o, _i, n, g) = (true, true, false, false, true) {}
    |                   ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:62:29
+  --> $DIR/min_ident_chars.rs:68:29
    |
 LL |     while let (d, o, _i, n, g) = (true, true, false, false, true) {}
    |                             ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:66:9
+  --> $DIR/min_ident_chars.rs:72:9
    |
 LL |     let o = 1;
    |         ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:67:9
+  --> $DIR/min_ident_chars.rs:73:9
    |
 LL |     let o = O { o };
    |         ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:81:4
+  --> $DIR/min_ident_chars.rs:87:4
    |
 LL | fn b() {}
    |    ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:82:21
+  --> $DIR/min_ident_chars.rs:88:21
    |
 LL | fn wrong_pythagoras(a: f32, b: f32) -> f32 {
    |                     ^
 
 error: this ident consists of a single char
-  --> $DIR/min_ident_chars.rs:82:29
+  --> $DIR/min_ident_chars.rs:88:29
    |
 LL | fn wrong_pythagoras(a: f32, b: f32) -> f32 {
    |                             ^
 
-error: aborting due to 29 previous errors
+error: aborting due to 32 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From f35eec867a1c64018e1b725094155ccccee73b27 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Wed, 14 Feb 2024 17:51:29 +0100
Subject: Add new lint `DEPRECATED_CLIPPY_CFG_ATTR`

---
 CHANGELOG.md                       |   1 +
 clippy_lints/src/attrs.rs          | 125 ++++++++++++++++++++++++++++---------
 clippy_lints/src/declared_lints.rs |   1 +
 3 files changed, 99 insertions(+), 28 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 6080fd3663b..053f7de5446 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5071,6 +5071,7 @@ Released 2018-09-13
 [`default_trait_access`]: https://rust-lang.github.io/rust-clippy/master/index.html#default_trait_access
 [`default_union_representation`]: https://rust-lang.github.io/rust-clippy/master/index.html#default_union_representation
 [`deprecated_cfg_attr`]: https://rust-lang.github.io/rust-clippy/master/index.html#deprecated_cfg_attr
+[`deprecated_clippy_cfg_attr`]: https://rust-lang.github.io/rust-clippy/master/index.html#deprecated_clippy_cfg_attr
 [`deprecated_semver`]: https://rust-lang.github.io/rust-clippy/master/index.html#deprecated_semver
 [`deref_addrof`]: https://rust-lang.github.io/rust-clippy/master/index.html#deref_addrof
 [`deref_by_slicing`]: https://rust-lang.github.io/rust-clippy/master/index.html#deref_by_slicing
diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs
index da38422874b..755f4ad3c89 100644
--- a/clippy_lints/src/attrs.rs
+++ b/clippy_lints/src/attrs.rs
@@ -433,6 +433,32 @@ declare_clippy_lint! {
     "prevent from misusing the wrong attr name"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `#[cfg_attr(feature = "cargo-clippy", ...)]` and for
+    /// `#[cfg(feature = "cargo-clippy")]` and suggests to replace it with
+    /// `#[cfg_attr(clippy, ...)]` or `#[cfg(clippy)]`.
+    ///
+    /// ### Why is this bad?
+    /// This feature has been deprecated for years and shouldn't be used anymore.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// #[cfg(feature = "cargo-clippy")]
+    /// struct Bar;
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// #[cfg(clippy)]
+    /// struct Bar;
+    /// ```
+    #[clippy::version = "1.78.0"]
+    pub DEPRECATED_CLIPPY_CFG_ATTR,
+    suspicious,
+    "usage of `cfg(feature = \"cargo-clippy\")` instead of `cfg(clippy)`"
+}
+
 declare_lint_pass!(Attributes => [
     ALLOW_ATTRIBUTES_WITHOUT_REASON,
     INLINE_ALWAYS,
@@ -794,6 +820,7 @@ impl_lint_pass!(EarlyAttributes => [
     EMPTY_LINE_AFTER_DOC_COMMENTS,
     NON_MINIMAL_CFG,
     MAYBE_MISUSED_CFG,
+    DEPRECATED_CLIPPY_CFG_ATTR,
 ]);
 
 impl EarlyLintPass for EarlyAttributes {
@@ -803,6 +830,7 @@ impl EarlyLintPass for EarlyAttributes {
 
     fn check_attribute(&mut self, cx: &EarlyContext<'_>, attr: &Attribute) {
         check_deprecated_cfg_attr(cx, attr, &self.msrv);
+        check_deprecated_cfg(cx, attr);
         check_mismatched_target_os(cx, attr);
         check_minimal_cfg_condition(cx, attr);
         check_misused_cfg(cx, attr);
@@ -857,39 +885,80 @@ fn check_empty_line_after_outer_attr(cx: &EarlyContext<'_>, item: &rustc_ast::It
     }
 }
 
+fn check_cargo_clippy_attr(cx: &EarlyContext<'_>, item: &rustc_ast::MetaItem) {
+    if item.has_name(sym::feature) && item.value_str().is_some_and(|v| v.as_str() == "cargo-clippy") {
+        span_lint_and_sugg(
+            cx,
+            DEPRECATED_CLIPPY_CFG_ATTR,
+            item.span,
+            "`feature = \"cargo-clippy\"` was replaced by `clippy`",
+            "replace with",
+            "clippy".to_string(),
+            Applicability::MachineApplicable,
+        );
+    }
+}
+
+fn check_deprecated_cfg_recursively(cx: &EarlyContext<'_>, attr: &rustc_ast::MetaItem) {
+    if let Some(ident) = attr.ident() {
+        if ["any", "all", "not"].contains(&ident.name.as_str()) {
+            let Some(list) = attr.meta_item_list() else { return };
+            for item in list.iter().filter_map(|item| item.meta_item()) {
+                check_deprecated_cfg_recursively(cx, item);
+            }
+        } else {
+            check_cargo_clippy_attr(cx, attr);
+        }
+    }
+}
+
+fn check_deprecated_cfg(cx: &EarlyContext<'_>, attr: &Attribute) {
+    if attr.has_name(sym::cfg)
+        && let Some(list) = attr.meta_item_list()
+    {
+        for item in list.iter().filter_map(|item| item.meta_item()) {
+            check_deprecated_cfg_recursively(cx, item);
+        }
+    }
+}
+
 fn check_deprecated_cfg_attr(cx: &EarlyContext<'_>, attr: &Attribute, msrv: &Msrv) {
-    if msrv.meets(msrvs::TOOL_ATTRIBUTES)
-        // check cfg_attr
-        && attr.has_name(sym::cfg_attr)
+    // check cfg_attr
+    if attr.has_name(sym::cfg_attr)
         && let Some(items) = attr.meta_item_list()
         && items.len() == 2
-        // check for `rustfmt`
         && let Some(feature_item) = items[0].meta_item()
-        && feature_item.has_name(sym::rustfmt)
-        // check for `rustfmt_skip` and `rustfmt::skip`
-        && let Some(skip_item) = &items[1].meta_item()
-        && (skip_item.has_name(sym!(rustfmt_skip))
-            || skip_item
-                .path
-                .segments
-                .last()
-                .expect("empty path in attribute")
-                .ident
-                .name
-                == sym::skip)
-        // Only lint outer attributes, because custom inner attributes are unstable
-        // Tracking issue: https://github.com/rust-lang/rust/issues/54726
-        && attr.style == AttrStyle::Outer
     {
-        span_lint_and_sugg(
-            cx,
-            DEPRECATED_CFG_ATTR,
-            attr.span,
-            "`cfg_attr` is deprecated for rustfmt and got replaced by tool attributes",
-            "use",
-            "#[rustfmt::skip]".to_string(),
-            Applicability::MachineApplicable,
-        );
+        // check for `rustfmt`
+        if feature_item.has_name(sym::rustfmt)
+            && msrv.meets(msrvs::TOOL_ATTRIBUTES)
+            // check for `rustfmt_skip` and `rustfmt::skip`
+            && let Some(skip_item) = &items[1].meta_item()
+            && (skip_item.has_name(sym!(rustfmt_skip))
+                || skip_item
+                    .path
+                    .segments
+                    .last()
+                    .expect("empty path in attribute")
+                    .ident
+                    .name
+                    == sym::skip)
+            // Only lint outer attributes, because custom inner attributes are unstable
+            // Tracking issue: https://github.com/rust-lang/rust/issues/54726
+            && attr.style == AttrStyle::Outer
+        {
+            span_lint_and_sugg(
+                cx,
+                DEPRECATED_CFG_ATTR,
+                attr.span,
+                "`cfg_attr` is deprecated for rustfmt and got replaced by tool attributes",
+                "use",
+                "#[rustfmt::skip]".to_string(),
+                Applicability::MachineApplicable,
+            );
+        } else {
+            check_deprecated_cfg_recursively(cx, feature_item);
+        }
     }
 }
 
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index b96a7af9070..c4d26e65b1a 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -51,6 +51,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::attrs::ALLOW_ATTRIBUTES_WITHOUT_REASON_INFO,
     crate::attrs::BLANKET_CLIPPY_RESTRICTION_LINTS_INFO,
     crate::attrs::DEPRECATED_CFG_ATTR_INFO,
+    crate::attrs::DEPRECATED_CLIPPY_CFG_ATTR_INFO,
     crate::attrs::DEPRECATED_SEMVER_INFO,
     crate::attrs::EMPTY_LINE_AFTER_DOC_COMMENTS_INFO,
     crate::attrs::EMPTY_LINE_AFTER_OUTER_ATTR_INFO,
-- 
cgit 1.4.1-3-g733a5


From f4eb6bd709cedf9e0b0baf904e06cbebcc884c64 Mon Sep 17 00:00:00 2001
From: Gabriel Goller <g.goller@proxmox.com>
Date: Thu, 15 Feb 2024 11:05:25 +0100
Subject: fix: documentation of `blocks_in_conditions` lint

Updated documentation + example of `blocks_in_conditions` lint, which
has been updated recently to include `match` statements as well.
---
 clippy_lints/src/blocks_in_conditions.rs | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/blocks_in_conditions.rs b/clippy_lints/src/blocks_in_conditions.rs
index eae87db26c6..62ef810f12b 100644
--- a/clippy_lints/src/blocks_in_conditions.rs
+++ b/clippy_lints/src/blocks_in_conditions.rs
@@ -13,7 +13,7 @@ use rustc_span::sym;
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for `if` conditions that use blocks containing an
+    /// Checks for `if` and `match` conditions that use blocks containing an
     /// expression, statements or conditions that use closures with blocks.
     ///
     /// ### Why is this bad?
@@ -25,6 +25,8 @@ declare_clippy_lint! {
     /// if { true } { /* ... */ }
     ///
     /// if { let x = somefunc(); x } { /* ... */ }
+    ///
+    /// match { let e = somefunc(); e } { /* ... */ }
     /// ```
     ///
     /// Use instead:
@@ -34,6 +36,9 @@ declare_clippy_lint! {
     ///
     /// let res = { let x = somefunc(); x };
     /// if res { /* ... */ }
+    ///
+    /// let res = { let e = somefunc(); e };
+    /// match res { /* ... */ }
     /// ```
     #[clippy::version = "1.45.0"]
     pub BLOCKS_IN_CONDITIONS,
-- 
cgit 1.4.1-3-g733a5


From 183fade0ef7a5b98b81a9a054b6ff70d3cf3532b Mon Sep 17 00:00:00 2001
From: Gabriel Goller <g.goller@proxmox.com>
Date: Thu, 15 Feb 2024 11:44:22 +0100
Subject: fix: example in blocks_in_conditions lint

Example in blocks_in_conditions lint didn't compile.
---
 clippy_lints/src/blocks_in_conditions.rs | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/blocks_in_conditions.rs b/clippy_lints/src/blocks_in_conditions.rs
index 62ef810f12b..2eb0dac9742 100644
--- a/clippy_lints/src/blocks_in_conditions.rs
+++ b/clippy_lints/src/blocks_in_conditions.rs
@@ -26,7 +26,10 @@ declare_clippy_lint! {
     ///
     /// if { let x = somefunc(); x } { /* ... */ }
     ///
-    /// match { let e = somefunc(); e } { /* ... */ }
+    /// match { let e = somefunc(); e } {
+    ///     // ...
+    /// #   _ => {}
+    /// }
     /// ```
     ///
     /// Use instead:
@@ -38,7 +41,10 @@ declare_clippy_lint! {
     /// if res { /* ... */ }
     ///
     /// let res = { let e = somefunc(); e };
-    /// match res { /* ... */ }
+    /// match res {
+    ///     // ...
+    /// #   _ => {}
+    /// }
     /// ```
     #[clippy::version = "1.45.0"]
     pub BLOCKS_IN_CONDITIONS,
-- 
cgit 1.4.1-3-g733a5


From f0adfe74b6e83e2fea8ad46710670b29572f4885 Mon Sep 17 00:00:00 2001
From: Centri3 <114838443+Centri3@users.noreply.github.com>
Date: Tue, 6 Jun 2023 21:32:27 -0500
Subject: lint `new_without_default` on const fns too

---
 clippy_lints/src/new_without_default.rs |  4 ----
 tests/ui/new_without_default.fixed      | 10 ++++++++--
 tests/ui/new_without_default.rs         |  4 ++--
 tests/ui/new_without_default.stderr     | 19 ++++++++++++++++++-
 4 files changed, 28 insertions(+), 9 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/new_without_default.rs b/clippy_lints/src/new_without_default.rs
index 9de6ad42137..b3b8a5e9963 100644
--- a/clippy_lints/src/new_without_default.rs
+++ b/clippy_lints/src/new_without_default.rs
@@ -75,10 +75,6 @@ impl<'tcx> LateLintPass<'tcx> for NewWithoutDefault {
                     if let hir::ImplItemKind::Fn(ref sig, _) = impl_item.kind {
                         let name = impl_item.ident.name;
                         let id = impl_item.owner_id;
-                        if sig.header.constness == hir::Constness::Const {
-                            // can't be implemented by default
-                            return;
-                        }
                         if sig.header.unsafety == hir::Unsafety::Unsafe {
                             // can't be implemented for unsafe new
                             return;
diff --git a/tests/ui/new_without_default.fixed b/tests/ui/new_without_default.fixed
index 1c7ba1a48c9..85408c4e17f 100644
--- a/tests/ui/new_without_default.fixed
+++ b/tests/ui/new_without_default.fixed
@@ -132,12 +132,18 @@ impl PrivateItem {
     } // We don't lint private items on public structs
 }
 
-struct Const;
+pub struct Const;
+
+impl Default for Const {
+    fn default() -> Self {
+        Self::new()
+    }
+}
 
 impl Const {
     pub const fn new() -> Const {
         Const
-    } // const fns can't be implemented via Default
+    } // While Default is not const, it can still call const functions, so we should lint this
 }
 
 pub struct IgnoreGenericNew;
diff --git a/tests/ui/new_without_default.rs b/tests/ui/new_without_default.rs
index 964aa0f63da..3ac7292c236 100644
--- a/tests/ui/new_without_default.rs
+++ b/tests/ui/new_without_default.rs
@@ -114,12 +114,12 @@ impl PrivateItem {
     } // We don't lint private items on public structs
 }
 
-struct Const;
+pub struct Const;
 
 impl Const {
     pub const fn new() -> Const {
         Const
-    } // const fns can't be implemented via Default
+    } // While Default is not const, it can still call const functions, so we should lint this
 }
 
 pub struct IgnoreGenericNew;
diff --git a/tests/ui/new_without_default.stderr b/tests/ui/new_without_default.stderr
index acba5b0d7bd..6652a264205 100644
--- a/tests/ui/new_without_default.stderr
+++ b/tests/ui/new_without_default.stderr
@@ -55,6 +55,23 @@ LL +     }
 LL + }
    |
 
+error: you should consider adding a `Default` implementation for `Const`
+  --> $DIR/new_without_default.rs:120:5
+   |
+LL | /     pub const fn new() -> Const {
+LL | |         Const
+LL | |     } // While Default is not const, it can still call const functions, so we should lint this
+   | |_____^
+   |
+help: try adding this
+   |
+LL + impl Default for Const {
+LL +     fn default() -> Self {
+LL +         Self::new()
+LL +     }
+LL + }
+   |
+
 error: you should consider adding a `Default` implementation for `NewNotEqualToDerive`
   --> $DIR/new_without_default.rs:180:5
    |
@@ -149,5 +166,5 @@ LL +     }
 LL + }
    |
 
-error: aborting due to 8 previous errors
+error: aborting due to 9 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 9b5e4c6d57decaa419e3af48d0c6b95cb5b7620e Mon Sep 17 00:00:00 2001
From: beetrees <b@beetr.ee>
Date: Fri, 16 Feb 2024 19:02:19 +0000
Subject: Ensure ASM syntax detect `global_asm!` and `asm!` only on x86
 architectures

---
 clippy_lints/src/asm_syntax.rs        | 37 +++++++++++++++---
 tests/ui/asm_syntax.rs                | 39 -------------------
 tests/ui/asm_syntax.stderr            | 46 ----------------------
 tests/ui/asm_syntax_not_x86.rs        | 24 ++++++++++++
 tests/ui/asm_syntax_x86.i686.stderr   | 73 +++++++++++++++++++++++++++++++++++
 tests/ui/asm_syntax_x86.rs            | 52 +++++++++++++++++++++++++
 tests/ui/asm_syntax_x86.x86_64.stderr | 73 +++++++++++++++++++++++++++++++++++
 7 files changed, 253 insertions(+), 91 deletions(-)
 delete mode 100644 tests/ui/asm_syntax.rs
 delete mode 100644 tests/ui/asm_syntax.stderr
 create mode 100644 tests/ui/asm_syntax_not_x86.rs
 create mode 100644 tests/ui/asm_syntax_x86.i686.stderr
 create mode 100644 tests/ui/asm_syntax_x86.rs
 create mode 100644 tests/ui/asm_syntax_x86.x86_64.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/asm_syntax.rs b/clippy_lints/src/asm_syntax.rs
index feb6437ee26..c2fa56e1360 100644
--- a/clippy_lints/src/asm_syntax.rs
+++ b/clippy_lints/src/asm_syntax.rs
@@ -2,8 +2,11 @@ use std::fmt;
 
 use clippy_utils::diagnostics::span_lint_and_help;
 use rustc_ast::ast::{Expr, ExprKind, InlineAsmOptions};
-use rustc_lint::{EarlyContext, EarlyLintPass, Lint};
+use rustc_ast::{InlineAsm, Item, ItemKind};
+use rustc_lint::{EarlyContext, EarlyLintPass, Lint, LintContext};
 use rustc_session::declare_lint_pass;
+use rustc_span::Span;
+use rustc_target::asm::InlineAsmArch;
 
 #[derive(Clone, Copy, PartialEq, Eq)]
 enum AsmStyle {
@@ -31,8 +34,14 @@ impl std::ops::Not for AsmStyle {
     }
 }
 
-fn check_expr_asm_syntax(lint: &'static Lint, cx: &EarlyContext<'_>, expr: &Expr, check_for: AsmStyle) {
-    if let ExprKind::InlineAsm(ref inline_asm) = expr.kind {
+fn check_asm_syntax(
+    lint: &'static Lint,
+    cx: &EarlyContext<'_>,
+    inline_asm: &InlineAsm,
+    span: Span,
+    check_for: AsmStyle,
+) {
+    if matches!(cx.sess().asm_arch, Some(InlineAsmArch::X86 | InlineAsmArch::X86_64)) {
         let style = if inline_asm.options.contains(InlineAsmOptions::ATT_SYNTAX) {
             AsmStyle::Att
         } else {
@@ -43,7 +52,7 @@ fn check_expr_asm_syntax(lint: &'static Lint, cx: &EarlyContext<'_>, expr: &Expr
             span_lint_and_help(
                 cx,
                 lint,
-                expr.span,
+                span,
                 &format!("{style} x86 assembly syntax used"),
                 None,
                 &format!("use {} x86 assembly syntax", !style),
@@ -89,7 +98,15 @@ declare_lint_pass!(InlineAsmX86IntelSyntax => [INLINE_ASM_X86_INTEL_SYNTAX]);
 
 impl EarlyLintPass for InlineAsmX86IntelSyntax {
     fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
-        check_expr_asm_syntax(Self::get_lints()[0], cx, expr, AsmStyle::Intel);
+        if let ExprKind::InlineAsm(inline_asm) = &expr.kind {
+            check_asm_syntax(Self::get_lints()[0], cx, inline_asm, expr.span, AsmStyle::Intel);
+        }
+    }
+
+    fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {
+        if let ItemKind::GlobalAsm(inline_asm) = &item.kind {
+            check_asm_syntax(Self::get_lints()[0], cx, inline_asm, item.span, AsmStyle::Intel);
+        }
     }
 }
 
@@ -130,6 +147,14 @@ declare_lint_pass!(InlineAsmX86AttSyntax => [INLINE_ASM_X86_ATT_SYNTAX]);
 
 impl EarlyLintPass for InlineAsmX86AttSyntax {
     fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
-        check_expr_asm_syntax(Self::get_lints()[0], cx, expr, AsmStyle::Att);
+        if let ExprKind::InlineAsm(inline_asm) = &expr.kind {
+            check_asm_syntax(Self::get_lints()[0], cx, inline_asm, expr.span, AsmStyle::Att);
+        }
+    }
+
+    fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {
+        if let ItemKind::GlobalAsm(inline_asm) = &item.kind {
+            check_asm_syntax(Self::get_lints()[0], cx, inline_asm, item.span, AsmStyle::Att);
+        }
     }
 }
diff --git a/tests/ui/asm_syntax.rs b/tests/ui/asm_syntax.rs
deleted file mode 100644
index 0a7eb86bc03..00000000000
--- a/tests/ui/asm_syntax.rs
+++ /dev/null
@@ -1,39 +0,0 @@
-//@only-target-x86_64
-//@ignore-target-aarch64
-
-#[warn(clippy::inline_asm_x86_intel_syntax)]
-mod warn_intel {
-    pub(super) unsafe fn use_asm() {
-        use std::arch::asm;
-        asm!("");
-        //~^ ERROR: Intel x86 assembly syntax used
-        asm!("", options());
-        //~^ ERROR: Intel x86 assembly syntax used
-        asm!("", options(nostack));
-        //~^ ERROR: Intel x86 assembly syntax used
-        asm!("", options(att_syntax));
-        asm!("", options(nostack, att_syntax));
-    }
-}
-
-#[warn(clippy::inline_asm_x86_att_syntax)]
-mod warn_att {
-    pub(super) unsafe fn use_asm() {
-        use std::arch::asm;
-        asm!("");
-        asm!("", options());
-        asm!("", options(nostack));
-        asm!("", options(att_syntax));
-        //~^ ERROR: AT&T x86 assembly syntax used
-        asm!("", options(nostack, att_syntax));
-        //~^ ERROR: AT&T x86 assembly syntax used
-    }
-}
-
-#[cfg(target_arch = "x86_64")]
-fn main() {
-    unsafe {
-        warn_att::use_asm();
-        warn_intel::use_asm();
-    }
-}
diff --git a/tests/ui/asm_syntax.stderr b/tests/ui/asm_syntax.stderr
deleted file mode 100644
index 537ea8c57e9..00000000000
--- a/tests/ui/asm_syntax.stderr
+++ /dev/null
@@ -1,46 +0,0 @@
-error: Intel x86 assembly syntax used
-  --> $DIR/asm_syntax.rs:8:9
-   |
-LL |         asm!("");
-   |         ^^^^^^^^
-   |
-   = help: use AT&T x86 assembly syntax
-   = note: `-D clippy::inline-asm-x86-intel-syntax` implied by `-D warnings`
-   = help: to override `-D warnings` add `#[allow(clippy::inline_asm_x86_intel_syntax)]`
-
-error: Intel x86 assembly syntax used
-  --> $DIR/asm_syntax.rs:10:9
-   |
-LL |         asm!("", options());
-   |         ^^^^^^^^^^^^^^^^^^^
-   |
-   = help: use AT&T x86 assembly syntax
-
-error: Intel x86 assembly syntax used
-  --> $DIR/asm_syntax.rs:12:9
-   |
-LL |         asm!("", options(nostack));
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: use AT&T x86 assembly syntax
-
-error: AT&T x86 assembly syntax used
-  --> $DIR/asm_syntax.rs:26:9
-   |
-LL |         asm!("", options(att_syntax));
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: use Intel x86 assembly syntax
-   = note: `-D clippy::inline-asm-x86-att-syntax` implied by `-D warnings`
-   = help: to override `-D warnings` add `#[allow(clippy::inline_asm_x86_att_syntax)]`
-
-error: AT&T x86 assembly syntax used
-  --> $DIR/asm_syntax.rs:28:9
-   |
-LL |         asm!("", options(nostack, att_syntax));
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: use Intel x86 assembly syntax
-
-error: aborting due to 5 previous errors
-
diff --git a/tests/ui/asm_syntax_not_x86.rs b/tests/ui/asm_syntax_not_x86.rs
new file mode 100644
index 00000000000..33cea480681
--- /dev/null
+++ b/tests/ui/asm_syntax_not_x86.rs
@@ -0,0 +1,24 @@
+//@ignore-target-i686
+//@ignore-target-x86
+//@needs-asm-support
+
+#[warn(clippy::inline_asm_x86_intel_syntax)]
+#[warn(clippy::inline_asm_x86_att_syntax)]
+mod dont_warn {
+    use std::arch::{asm, global_asm};
+
+    pub(super) unsafe fn use_asm() {
+        asm!("");
+        asm!("", options());
+        asm!("", options(nostack));
+    }
+
+    global_asm!("");
+    global_asm!("", options());
+}
+
+fn main() {
+    unsafe {
+        dont_warn::use_asm();
+    }
+}
diff --git a/tests/ui/asm_syntax_x86.i686.stderr b/tests/ui/asm_syntax_x86.i686.stderr
new file mode 100644
index 00000000000..dee78f97e68
--- /dev/null
+++ b/tests/ui/asm_syntax_x86.i686.stderr
@@ -0,0 +1,73 @@
+error: Intel x86 assembly syntax used
+  --> $DIR/asm_syntax_x86.rs:10:9
+   |
+LL |         asm!("");
+   |         ^^^^^^^^
+   |
+   = help: use AT&T x86 assembly syntax
+   = note: `-D clippy::inline-asm-x86-intel-syntax` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::inline_asm_x86_intel_syntax)]`
+
+error: Intel x86 assembly syntax used
+  --> $DIR/asm_syntax_x86.rs:12:9
+   |
+LL |         asm!("", options());
+   |         ^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use AT&T x86 assembly syntax
+
+error: Intel x86 assembly syntax used
+  --> $DIR/asm_syntax_x86.rs:14:9
+   |
+LL |         asm!("", options(nostack));
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use AT&T x86 assembly syntax
+
+error: Intel x86 assembly syntax used
+  --> $DIR/asm_syntax_x86.rs:20:5
+   |
+LL |     global_asm!("");
+   |     ^^^^^^^^^^^^^^^
+   |
+   = help: use AT&T x86 assembly syntax
+   = note: this error originates in the macro `global_asm` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: Intel x86 assembly syntax used
+  --> $DIR/asm_syntax_x86.rs:22:5
+   |
+LL |     global_asm!("", options());
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use AT&T x86 assembly syntax
+   = note: this error originates in the macro `global_asm` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: AT&T x86 assembly syntax used
+  --> $DIR/asm_syntax_x86.rs:35:9
+   |
+LL |         asm!("", options(att_syntax));
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use Intel x86 assembly syntax
+   = note: `-D clippy::inline-asm-x86-att-syntax` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::inline_asm_x86_att_syntax)]`
+
+error: AT&T x86 assembly syntax used
+  --> $DIR/asm_syntax_x86.rs:37:9
+   |
+LL |         asm!("", options(nostack, att_syntax));
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use Intel x86 assembly syntax
+
+error: AT&T x86 assembly syntax used
+  --> $DIR/asm_syntax_x86.rs:43:5
+   |
+LL |     global_asm!("", options(att_syntax));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use Intel x86 assembly syntax
+   = note: this error originates in the macro `global_asm` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: aborting due to 8 previous errors
+
diff --git a/tests/ui/asm_syntax_x86.rs b/tests/ui/asm_syntax_x86.rs
new file mode 100644
index 00000000000..835943b4389
--- /dev/null
+++ b/tests/ui/asm_syntax_x86.rs
@@ -0,0 +1,52 @@
+//@revisions: i686 x86_64
+//@[i686] only-target-i686
+//@[x86_64] only-target-x86_64
+
+#[warn(clippy::inline_asm_x86_intel_syntax)]
+mod warn_intel {
+    use std::arch::{asm, global_asm};
+
+    pub(super) unsafe fn use_asm() {
+        asm!("");
+        //~^ ERROR: Intel x86 assembly syntax used
+        asm!("", options());
+        //~^ ERROR: Intel x86 assembly syntax used
+        asm!("", options(nostack));
+        //~^ ERROR: Intel x86 assembly syntax used
+        asm!("", options(att_syntax));
+        asm!("", options(nostack, att_syntax));
+    }
+
+    global_asm!("");
+    //~^ ERROR: Intel x86 assembly syntax used
+    global_asm!("", options());
+    //~^ ERROR: Intel x86 assembly syntax used
+    global_asm!("", options(att_syntax));
+}
+
+#[warn(clippy::inline_asm_x86_att_syntax)]
+mod warn_att {
+    use std::arch::{asm, global_asm};
+
+    pub(super) unsafe fn use_asm() {
+        asm!("");
+        asm!("", options());
+        asm!("", options(nostack));
+        asm!("", options(att_syntax));
+        //~^ ERROR: AT&T x86 assembly syntax used
+        asm!("", options(nostack, att_syntax));
+        //~^ ERROR: AT&T x86 assembly syntax used
+    }
+
+    global_asm!("");
+    global_asm!("", options());
+    global_asm!("", options(att_syntax));
+    //~^ ERROR: AT&T x86 assembly syntax used
+}
+
+fn main() {
+    unsafe {
+        warn_att::use_asm();
+        warn_intel::use_asm();
+    }
+}
diff --git a/tests/ui/asm_syntax_x86.x86_64.stderr b/tests/ui/asm_syntax_x86.x86_64.stderr
new file mode 100644
index 00000000000..dee78f97e68
--- /dev/null
+++ b/tests/ui/asm_syntax_x86.x86_64.stderr
@@ -0,0 +1,73 @@
+error: Intel x86 assembly syntax used
+  --> $DIR/asm_syntax_x86.rs:10:9
+   |
+LL |         asm!("");
+   |         ^^^^^^^^
+   |
+   = help: use AT&T x86 assembly syntax
+   = note: `-D clippy::inline-asm-x86-intel-syntax` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::inline_asm_x86_intel_syntax)]`
+
+error: Intel x86 assembly syntax used
+  --> $DIR/asm_syntax_x86.rs:12:9
+   |
+LL |         asm!("", options());
+   |         ^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use AT&T x86 assembly syntax
+
+error: Intel x86 assembly syntax used
+  --> $DIR/asm_syntax_x86.rs:14:9
+   |
+LL |         asm!("", options(nostack));
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use AT&T x86 assembly syntax
+
+error: Intel x86 assembly syntax used
+  --> $DIR/asm_syntax_x86.rs:20:5
+   |
+LL |     global_asm!("");
+   |     ^^^^^^^^^^^^^^^
+   |
+   = help: use AT&T x86 assembly syntax
+   = note: this error originates in the macro `global_asm` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: Intel x86 assembly syntax used
+  --> $DIR/asm_syntax_x86.rs:22:5
+   |
+LL |     global_asm!("", options());
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use AT&T x86 assembly syntax
+   = note: this error originates in the macro `global_asm` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: AT&T x86 assembly syntax used
+  --> $DIR/asm_syntax_x86.rs:35:9
+   |
+LL |         asm!("", options(att_syntax));
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use Intel x86 assembly syntax
+   = note: `-D clippy::inline-asm-x86-att-syntax` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::inline_asm_x86_att_syntax)]`
+
+error: AT&T x86 assembly syntax used
+  --> $DIR/asm_syntax_x86.rs:37:9
+   |
+LL |         asm!("", options(nostack, att_syntax));
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use Intel x86 assembly syntax
+
+error: AT&T x86 assembly syntax used
+  --> $DIR/asm_syntax_x86.rs:43:5
+   |
+LL |     global_asm!("", options(att_syntax));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: use Intel x86 assembly syntax
+   = note: this error originates in the macro `global_asm` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: aborting due to 8 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From d1e8a5956ffd73e65288b447c68ac11a7ac26577 Mon Sep 17 00:00:00 2001
From: Victor Song <vsong1618@gmail.com>
Date: Sat, 17 Feb 2024 17:19:19 -0600
Subject: fix: make `#[allow]` work on field for `pub_underscore_fields`

Add test for future regression
---
 clippy_lints/src/pub_underscore_fields.rs                    | 10 ++++++----
 tests/ui-toml/pub_underscore_fields/pub_underscore_fields.rs |  6 ++++++
 2 files changed, 12 insertions(+), 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/pub_underscore_fields.rs b/clippy_lints/src/pub_underscore_fields.rs
index 88b5a6cfe2a..d20d4a605a2 100644
--- a/clippy_lints/src/pub_underscore_fields.rs
+++ b/clippy_lints/src/pub_underscore_fields.rs
@@ -1,6 +1,6 @@
 use clippy_config::types::PubUnderscoreFieldsBehaviour;
 use clippy_utils::attrs::is_doc_hidden;
-use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::diagnostics::span_lint_hir_and_then;
 use clippy_utils::is_path_lang_item;
 use rustc_hir::{FieldDef, Item, ItemKind, LangItem};
 use rustc_lint::{LateContext, LateLintPass};
@@ -69,13 +69,15 @@ impl<'tcx> LateLintPass<'tcx> for PubUnderscoreFields {
                 // We ignore fields that are `PhantomData`.
                 && !is_path_lang_item(cx, field.ty, LangItem::PhantomData)
             {
-                span_lint_and_help(
+                span_lint_hir_and_then(
                     cx,
                     PUB_UNDERSCORE_FIELDS,
+                    field.hir_id,
                     field.vis_span.to(field.ident.span),
                     "field marked as public but also inferred as unused because it's prefixed with `_`",
-                    None,
-                    "consider removing the underscore, or making the field private",
+                    |diag| {
+                        diag.help("consider removing the underscore, or making the field private");
+                    },
                 );
             }
         }
diff --git a/tests/ui-toml/pub_underscore_fields/pub_underscore_fields.rs b/tests/ui-toml/pub_underscore_fields/pub_underscore_fields.rs
index 1d8fee7daad..4ee8dbb8834 100644
--- a/tests/ui-toml/pub_underscore_fields/pub_underscore_fields.rs
+++ b/tests/ui-toml/pub_underscore_fields/pub_underscore_fields.rs
@@ -63,4 +63,10 @@ fn main() {
         _pub: String,
         pub(crate) _mark: PhantomData<u8>,
     }
+
+    // shouldn't warn when `#[allow]` is used on field level
+    pub struct AllowedViolations {
+        #[allow(clippy::pub_underscore_fields)]
+        pub _first: u32,
+    }
 }
-- 
cgit 1.4.1-3-g733a5


From 087c7c828d5e5730fbf8cfe4cbc398e27c66a60e Mon Sep 17 00:00:00 2001
From: roife <roifewu@gmail.com>
Date: Sat, 30 Dec 2023 21:31:19 +0800
Subject: Add check for same guards in match_same_arms

---
 clippy_lints/src/casts/cast_possible_truncation.rs |  3 +-
 clippy_lints/src/matches/match_same_arms.rs        | 66 +++++++++++++---------
 tests/ui/match_same_arms2.rs                       | 14 +++++
 tests/ui/match_same_arms2.stderr                   | 51 +++++++++++------
 4 files changed, 87 insertions(+), 47 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/casts/cast_possible_truncation.rs b/clippy_lints/src/casts/cast_possible_truncation.rs
index f99a51e2b88..fbbb559319e 100644
--- a/clippy_lints/src/casts/cast_possible_truncation.rs
+++ b/clippy_lints/src/casts/cast_possible_truncation.rs
@@ -131,8 +131,7 @@ pub(super) fn check(
 
             let cast_from_ptr_size = def.repr().int.map_or(true, |ty| matches!(ty, IntegerType::Pointer(_),));
             let suffix = match (cast_from_ptr_size, is_isize_or_usize(cast_to)) {
-                (false, false) if from_nbits > to_nbits => "",
-                (true, false) if from_nbits > to_nbits => "",
+                (_, false) if from_nbits > to_nbits => "",
                 (false, true) if from_nbits > 64 => "",
                 (false, true) if from_nbits > 32 => " on targets with 32-bit wide pointers",
                 _ => return,
diff --git a/clippy_lints/src/matches/match_same_arms.rs b/clippy_lints/src/matches/match_same_arms.rs
index d645e6c6c05..ae302f0f075 100644
--- a/clippy_lints/src/matches/match_same_arms.rs
+++ b/clippy_lints/src/matches/match_same_arms.rs
@@ -64,38 +64,50 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>]) {
         let min_index = usize::min(lindex, rindex);
         let max_index = usize::max(lindex, rindex);
 
-        let mut local_map: HirIdMap<HirId> = HirIdMap::default();
-        let eq_fallback = |a: &Expr<'_>, b: &Expr<'_>| {
-            if let Some(a_id) = path_to_local(a)
-                && let Some(b_id) = path_to_local(b)
-                && let entry = match local_map.entry(a_id) {
-                    HirIdMapEntry::Vacant(entry) => entry,
-                    // check if using the same bindings as before
-                    HirIdMapEntry::Occupied(entry) => return *entry.get() == b_id,
-                }
+        let check_eq_with_pat = |expr_a: &Expr<'_>, expr_b: &Expr<'_>| {
+            let mut local_map: HirIdMap<HirId> = HirIdMap::default();
+            let eq_fallback = |a: &Expr<'_>, b: &Expr<'_>| {
+                if let Some(a_id) = path_to_local(a)
+                    && let Some(b_id) = path_to_local(b)
+                    && let entry = match local_map.entry(a_id) {
+                        HirIdMapEntry::Vacant(entry) => entry,
+                        // check if using the same bindings as before
+                        HirIdMapEntry::Occupied(entry) => return *entry.get() == b_id,
+                    }
                 // the names technically don't have to match; this makes the lint more conservative
                 && cx.tcx.hir().name(a_id) == cx.tcx.hir().name(b_id)
-                && cx.typeck_results().expr_ty(a) == cx.typeck_results().expr_ty(b)
-                && pat_contains_local(lhs.pat, a_id)
-                && pat_contains_local(rhs.pat, b_id)
-            {
-                entry.insert(b_id);
-                true
-            } else {
-                false
-            }
-        };
-        // Arms with a guard are ignored, those can’t always be merged together
-        // If both arms overlap with an arm in between then these can't be merged either.
-        !(backwards_blocking_idxs[max_index] > min_index && forwards_blocking_idxs[min_index] < max_index)
-                && lhs.guard.is_none()
-                && rhs.guard.is_none()
-                && SpanlessEq::new(cx)
-                    .expr_fallback(eq_fallback)
-                    .eq_expr(lhs.body, rhs.body)
+                    && cx.typeck_results().expr_ty(a) == cx.typeck_results().expr_ty(b)
+                    && pat_contains_local(lhs.pat, a_id)
+                    && pat_contains_local(rhs.pat, b_id)
+                {
+                    entry.insert(b_id);
+                    true
+                } else {
+                    false
+                }
+            };
+
+            SpanlessEq::new(cx)
+                .expr_fallback(eq_fallback)
+                .eq_expr(expr_a, expr_b)
                 // these checks could be removed to allow unused bindings
                 && bindings_eq(lhs.pat, local_map.keys().copied().collect())
                 && bindings_eq(rhs.pat, local_map.values().copied().collect())
+        };
+
+        let check_same_guard = || match (&lhs.guard, &rhs.guard) {
+            (None, None) => true,
+            (Some(lhs_guard), Some(rhs_guard)) => check_eq_with_pat(lhs_guard, rhs_guard),
+            _ => false,
+        };
+
+        let check_same_body = || check_eq_with_pat(lhs.body, rhs.body);
+
+        // Arms with different guard are ignored, those can’t always be merged together
+        // If both arms overlap with an arm in between then these can't be merged either.
+        !(backwards_blocking_idxs[max_index] > min_index && forwards_blocking_idxs[min_index] < max_index)
+            && check_same_guard()
+            && check_same_body()
     };
 
     let indexed_arms: Vec<(usize, &Arm<'_>)> = arms.iter().enumerate().collect();
diff --git a/tests/ui/match_same_arms2.rs b/tests/ui/match_same_arms2.rs
index 3428ff45906..85ad0962eb4 100644
--- a/tests/ui/match_same_arms2.rs
+++ b/tests/ui/match_same_arms2.rs
@@ -67,6 +67,20 @@ fn match_same_arms() {
         _ => (),
     }
 
+    // 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)) {
+        (Some(a), None) if a == 42 => a,
+        (None, Some(a)) if a == 42 => a, //~ ERROR: this match arm has an identical body to another arm
+        _ => 0,
+    };
+
     match (Some(42), Some(42)) {
         (Some(a), ..) => bar(a), //~ ERROR: this match arm has an identical body to another arm
         (.., Some(a)) => bar(a),
diff --git a/tests/ui/match_same_arms2.stderr b/tests/ui/match_same_arms2.stderr
index 6abbb582763..f4c38c1af89 100644
--- a/tests/ui/match_same_arms2.stderr
+++ b/tests/ui/match_same_arms2.stderr
@@ -71,7 +71,22 @@ LL |         (Some(a), None) => bar(a),
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this match arm has an identical body to another arm
-  --> tests/ui/match_same_arms2.rs:71:9
+  --> tests/ui/match_same_arms2.rs:80: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,
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: this match arm has an identical body to another arm
+  --> tests/ui/match_same_arms2.rs:85:9
    |
 LL |         (Some(a), ..) => bar(a),
    |         -------------^^^^^^^^^^
@@ -80,13 +95,13 @@ LL |         (Some(a), ..) => bar(a),
    |
    = help: or try changing either arm body
 note: other arm here
-  --> tests/ui/match_same_arms2.rs:72:9
+  --> tests/ui/match_same_arms2.rs:86:9
    |
 LL |         (.., Some(a)) => bar(a),
    |         ^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this match arm has an identical body to another arm
-  --> tests/ui/match_same_arms2.rs:105:9
+  --> tests/ui/match_same_arms2.rs:119:9
    |
 LL |         (Ok(x), Some(_)) => println!("ok {}", x),
    |         ----------------^^^^^^^^^^^^^^^^^^^^^^^^
@@ -95,13 +110,13 @@ LL |         (Ok(x), Some(_)) => println!("ok {}", x),
    |
    = help: or try changing either arm body
 note: other arm here
-  --> tests/ui/match_same_arms2.rs:106:9
+  --> tests/ui/match_same_arms2.rs:120:9
    |
 LL |         (Ok(_), Some(x)) => println!("ok {}", x),
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this match arm has an identical body to another arm
-  --> tests/ui/match_same_arms2.rs:121:9
+  --> tests/ui/match_same_arms2.rs:135:9
    |
 LL |         Ok(_) => println!("ok"),
    |         -----^^^^^^^^^^^^^^^^^^
@@ -110,13 +125,13 @@ LL |         Ok(_) => println!("ok"),
    |
    = help: or try changing either arm body
 note: other arm here
-  --> tests/ui/match_same_arms2.rs:120:9
+  --> tests/ui/match_same_arms2.rs:134:9
    |
 LL |         Ok(3) => println!("ok"),
    |         ^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this match arm has an identical body to another arm
-  --> tests/ui/match_same_arms2.rs:148:9
+  --> tests/ui/match_same_arms2.rs:162:9
    |
 LL |           1 => {
    |           ^ help: try merging the arm patterns: `1 | 0`
@@ -128,7 +143,7 @@ LL | |         },
    |
    = help: or try changing either arm body
 note: other arm here
-  --> tests/ui/match_same_arms2.rs:145:9
+  --> tests/ui/match_same_arms2.rs:159:9
    |
 LL | /         0 => {
 LL | |             empty!(0);
@@ -136,7 +151,7 @@ LL | |         },
    | |_________^
 
 error: match expression looks like `matches!` macro
-  --> tests/ui/match_same_arms2.rs:167:16
+  --> tests/ui/match_same_arms2.rs:181:16
    |
 LL |       let _ans = match x {
    |  ________________^
@@ -150,7 +165,7 @@ LL | |     };
    = 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:199:9
+  --> tests/ui/match_same_arms2.rs:213:9
    |
 LL |         Foo::X(0) => 1,
    |         ---------^^^^^
@@ -159,13 +174,13 @@ LL |         Foo::X(0) => 1,
    |
    = help: or try changing either arm body
 note: other arm here
-  --> tests/ui/match_same_arms2.rs:201:9
+  --> 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:209:9
+  --> tests/ui/match_same_arms2.rs:223:9
    |
 LL |         Foo::Z(_) => 1,
    |         ---------^^^^^
@@ -174,13 +189,13 @@ LL |         Foo::Z(_) => 1,
    |
    = help: or try changing either arm body
 note: other arm here
-  --> tests/ui/match_same_arms2.rs:207:9
+  --> tests/ui/match_same_arms2.rs:221:9
    |
 LL |         Foo::X(0) => 1,
    |         ^^^^^^^^^^^^^^
 
 error: this match arm has an identical body to another arm
-  --> tests/ui/match_same_arms2.rs:232:9
+  --> tests/ui/match_same_arms2.rs:246:9
    |
 LL |         Some(Bar { y: 0, x: 5, .. }) => 1,
    |         ----------------------------^^^^^
@@ -189,13 +204,13 @@ LL |         Some(Bar { y: 0, x: 5, .. }) => 1,
    |
    = help: or try changing either arm body
 note: other arm here
-  --> tests/ui/match_same_arms2.rs:229:9
+  --> tests/ui/match_same_arms2.rs:243:9
    |
 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:246:9
+  --> tests/ui/match_same_arms2.rs:260:9
    |
 LL |         1 => cfg!(not_enable),
    |         -^^^^^^^^^^^^^^^^^^^^
@@ -204,10 +219,10 @@ LL |         1 => cfg!(not_enable),
    |
    = help: or try changing either arm body
 note: other arm here
-  --> tests/ui/match_same_arms2.rs:245:9
+  --> tests/ui/match_same_arms2.rs:259:9
    |
 LL |         0 => cfg!(not_enable),
    |         ^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 13 previous errors
+error: aborting due to 14 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From aa8a82ec269a34d9bed7919ba8926c8551efdbeb Mon Sep 17 00:00:00 2001
From: "taiga.watanabe" <taiga.watanabe@va-sa-ra.co.jp>
Date: Tue, 20 Feb 2024 14:25:56 +0900
Subject: FIX: issue-12279 ---- UPDATE: add async block into test.

FIX: no_effect

Fixed asynchronous function parameter names with underscores so that warnings are not displayed when underscores are added to parameter names

ADD: test case
---
 clippy_lints/src/no_effect.rs      |  5 ++--
 tests/ui/no_effect_async_fn.rs     | 50 ++++++++++++++++++++++++++++++++++++++
 tests/ui/no_effect_async_fn.stderr | 29 ++++++++++++++++++++++
 3 files changed, 82 insertions(+), 2 deletions(-)
 create mode 100644 tests/ui/no_effect_async_fn.rs
 create mode 100644 tests/ui/no_effect_async_fn.stderr

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/no_effect.rs b/clippy_lints/src/no_effect.rs
index 580160efeb7..6adb5098ed3 100644
--- a/clippy_lints/src/no_effect.rs
+++ b/clippy_lints/src/no_effect.rs
@@ -5,8 +5,8 @@ use clippy_utils::{any_parent_is_automatically_derived, get_parent_node, is_lint
 use rustc_errors::Applicability;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::{
-    is_range_literal, BinOpKind, BlockCheckMode, Expr, ExprKind, HirId, HirIdMap, ItemKind, Node, PatKind, Stmt,
-    StmtKind, UnsafeSource,
+    is_range_literal, BinOpKind, BlockCheckMode, Expr, ExprKind, HirId, HirIdMap, ItemKind, LocalSource, Node, PatKind,
+    Stmt, StmtKind, UnsafeSource,
 };
 use rustc_infer::infer::TyCtxtInferExt as _;
 use rustc_lint::{LateContext, LateLintPass, LintContext};
@@ -178,6 +178,7 @@ impl NoEffect {
             }
         } else if let StmtKind::Local(local) = stmt.kind {
             if !is_lint_allowed(cx, NO_EFFECT_UNDERSCORE_BINDING, local.hir_id)
+                && !matches!(local.source, LocalSource::AsyncFn)
                 && let Some(init) = local.init
                 && local.els.is_none()
                 && !local.pat.span.from_expansion()
diff --git a/tests/ui/no_effect_async_fn.rs b/tests/ui/no_effect_async_fn.rs
new file mode 100644
index 00000000000..ef0f3d1df1a
--- /dev/null
+++ b/tests/ui/no_effect_async_fn.rs
@@ -0,0 +1,50 @@
+#![warn(clippy::no_effect_underscore_binding)]
+#![no_main]
+
+trait AsyncTrait {
+    async fn bar(i: u64);
+}
+
+struct Bar;
+
+impl AsyncTrait for Bar {
+    // Shouldn't lint `binding to `_` prefixed variable with no side-effect`
+    async fn bar(_i: u64) {
+        let _a = 0;
+        //~^ ERROR: binding to `_` prefixed variable with no side-effect
+
+        // Shouldn't lint `binding to `_` prefixed variable with no side-effect`
+        let _b = num();
+
+        let _ = async {
+            let _c = 0;
+            //~^ ERROR: binding to `_` prefixed variable with no side-effect
+
+            // Shouldn't lint `binding to `_` prefixed variable with no side-effect`
+            let _d = num();
+        }
+        .await;
+    }
+}
+
+// Shouldn't lint `binding to `_` prefixed variable with no side-effect`
+async fn foo(_i: u64) {
+    let _a = 0;
+    //~^ ERROR: binding to `_` prefixed variable with no side-effect
+
+    // Shouldn't lint `binding to `_` prefixed variable with no side-effect`
+    let _b = num();
+
+    let _ = async {
+        let _c = 0;
+        //~^ ERROR: binding to `_` prefixed variable with no side-effect
+
+        // Shouldn't lint `binding to `_` prefixed variable with no side-effect`
+        let _d = num();
+    }
+    .await;
+}
+
+fn num() -> usize {
+    0
+}
diff --git a/tests/ui/no_effect_async_fn.stderr b/tests/ui/no_effect_async_fn.stderr
new file mode 100644
index 00000000000..2325eb9aae5
--- /dev/null
+++ b/tests/ui/no_effect_async_fn.stderr
@@ -0,0 +1,29 @@
+error: binding to `_` prefixed variable with no side-effect
+  --> tests/ui/no_effect_async_fn.rs:20:17
+   |
+LL |             let _c = 0;
+   |                 ^^
+   |
+   = note: `-D clippy::no-effect-underscore-binding` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::no_effect_underscore_binding)]`
+
+error: binding to `_` prefixed variable with no side-effect
+  --> tests/ui/no_effect_async_fn.rs:13:13
+   |
+LL |         let _a = 0;
+   |             ^^
+
+error: binding to `_` prefixed variable with no side-effect
+  --> tests/ui/no_effect_async_fn.rs:39:13
+   |
+LL |         let _c = 0;
+   |             ^^
+
+error: binding to `_` prefixed variable with no side-effect
+  --> tests/ui/no_effect_async_fn.rs:32:9
+   |
+LL |     let _a = 0;
+   |         ^^
+
+error: aborting due to 4 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 672bd5e3876290185e1e1b421ff0f0d50ea1e568 Mon Sep 17 00:00:00 2001
From: "taiga.watanabe" <taiga.watanabe@va-sa-ra.co.jp>
Date: Wed, 21 Feb 2024 10:42:45 +0900
Subject: DELETE: Known problems Section

The `Known problems` section was removed because it is old information.
---
 clippy_lints/src/no_effect.rs | 4 ----
 1 file changed, 4 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/no_effect.rs b/clippy_lints/src/no_effect.rs
index 6adb5098ed3..1b4e1ed066b 100644
--- a/clippy_lints/src/no_effect.rs
+++ b/clippy_lints/src/no_effect.rs
@@ -43,10 +43,6 @@ declare_clippy_lint! {
     /// executed. However, as they have no effect and shouldn't be used further on, all they
     /// do is make the code less readable.
     ///
-    /// ### Known problems
-    /// Further usage of this variable is not checked, which can lead to false positives if it is
-    /// used later in the code.
-    ///
     /// ### Example
     /// ```rust,ignore
     /// let _i_serve_no_purpose = 1;
-- 
cgit 1.4.1-3-g733a5


From 9cde201ba1c4ca23fb3d1776969b58b2e8d8997e Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Tue, 20 Feb 2024 17:53:06 +0100
Subject: Extend `unnecessary_to_owned` to handle `Borrow` trait in map types

---
 clippy_lints/src/methods/unnecessary_to_owned.rs | 98 +++++++++++++++++++++++-
 1 file changed, 96 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/methods/unnecessary_to_owned.rs b/clippy_lints/src/methods/unnecessary_to_owned.rs
index 64fcd9f8f45..c234e4f9b11 100644
--- a/clippy_lints/src/methods/unnecessary_to_owned.rs
+++ b/clippy_lints/src/methods/unnecessary_to_owned.rs
@@ -3,7 +3,9 @@ use super::unnecessary_iter_cloned::{self, is_into_iter};
 use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_opt;
-use clippy_utils::ty::{get_iterator_item_ty, implements_trait, is_copy, is_type_lang_item, peel_mid_ty_refs};
+use clippy_utils::ty::{
+    get_iterator_item_ty, implements_trait, is_copy, is_type_diagnostic_item, is_type_lang_item, peel_mid_ty_refs,
+};
 use clippy_utils::visitors::find_all_ret_expressions;
 use clippy_utils::{fn_def_id, get_parent_expr, is_diag_item_method, is_diag_trait_item, return_ty};
 use rustc_errors::Applicability;
@@ -16,7 +18,8 @@ use rustc_lint::LateContext;
 use rustc_middle::mir::Mutability;
 use rustc_middle::ty::adjustment::{Adjust, Adjustment, OverloadedDeref};
 use rustc_middle::ty::{
-    self, ClauseKind, GenericArg, GenericArgKind, GenericArgsRef, ParamTy, ProjectionPredicate, TraitPredicate, Ty,
+    self, ClauseKind, GenericArg, GenericArgKind, GenericArgsRef, ImplPolarity, ParamTy, ProjectionPredicate,
+    TraitPredicate, Ty,
 };
 use rustc_span::{sym, Symbol};
 use rustc_trait_selection::traits::query::evaluate_obligation::InferCtxtExt as _;
@@ -53,6 +56,8 @@ pub fn check<'tcx>(
             }
             check_other_call_arg(cx, expr, method_name, receiver);
         }
+    } else {
+        check_borrow_predicate(cx, expr);
     }
 }
 
@@ -590,3 +595,92 @@ fn is_to_string_on_string_like<'a>(
         false
     }
 }
+
+fn is_a_std_map_type(cx: &LateContext<'_>, ty: Ty<'_>) -> bool {
+    is_type_diagnostic_item(cx, ty, sym::HashSet)
+        || is_type_diagnostic_item(cx, ty, sym::HashMap)
+        || is_type_diagnostic_item(cx, ty, sym::BTreeMap)
+        || is_type_diagnostic_item(cx, ty, sym::BTreeSet)
+}
+
+fn is_str_and_string(cx: &LateContext<'_>, arg_ty: Ty<'_>, original_arg_ty: Ty<'_>) -> bool {
+    original_arg_ty.is_str() && is_type_lang_item(cx, arg_ty, LangItem::String)
+}
+
+fn is_slice_and_vec(cx: &LateContext<'_>, arg_ty: Ty<'_>, original_arg_ty: Ty<'_>) -> bool {
+    (original_arg_ty.is_slice() || original_arg_ty.is_array() || original_arg_ty.is_array_slice())
+        && is_type_diagnostic_item(cx, arg_ty, sym::Vec)
+}
+
+// This function will check the following:
+// 1. The argument is a non-mutable reference.
+// 2. It calls `to_owned()`, `to_string()` or `to_vec()`.
+// 3. That the method is called on `String` or on `Vec` (only types supported for the moment).
+fn check_if_applicable_to_argument<'tcx>(cx: &LateContext<'tcx>, arg: &Expr<'tcx>) {
+    if let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Not, expr) = arg.kind
+        && let ExprKind::MethodCall(method_path, caller, &[], _) = expr.kind
+        && let Some(method_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id)
+        && let method_name = method_path.ident.name.as_str()
+        && match method_name {
+            "to_owned" => cx.tcx.is_diagnostic_item(sym::to_owned_method, method_def_id),
+            "to_string" => cx.tcx.is_diagnostic_item(sym::to_string_method, method_def_id),
+            "to_vec" => cx
+                .tcx
+                .impl_of_method(method_def_id)
+                .filter(|&impl_did| cx.tcx.type_of(impl_did).instantiate_identity().is_slice())
+                .is_some(),
+            _ => false,
+        }
+        && let original_arg_ty = cx.typeck_results().node_type(caller.hir_id).peel_refs()
+        && let arg_ty = cx.typeck_results().expr_ty(arg)
+        && let ty::Ref(_, arg_ty, Mutability::Not) = arg_ty.kind()
+        // FIXME: try to fix `can_change_type` to make it work in this case.
+        // && can_change_type(cx, caller, *arg_ty)
+        && let arg_ty = arg_ty.peel_refs()
+        // For now we limit this lint to `String` and `Vec`.
+        && (is_str_and_string(cx, arg_ty, original_arg_ty) || is_slice_and_vec(cx, arg_ty, original_arg_ty))
+        && let Some(snippet) = snippet_opt(cx, caller.span)
+    {
+        span_lint_and_sugg(
+            cx,
+            UNNECESSARY_TO_OWNED,
+            arg.span,
+            &format!("unnecessary use of `{method_name}`"),
+            "replace it with",
+            if original_arg_ty.is_array() {
+                format!("{snippet}.as_slice()")
+            } else {
+                snippet
+            },
+            Applicability::MaybeIncorrect,
+        );
+    }
+}
+
+// In std "map types", the getters all expect a `Borrow<Key>` generic argument. So in here, we
+// check that:
+// 1. This is a method with only one argument that doesn't come from a trait.
+// 2. That it has `Borrow` in its generic predicates.
+// 3. `Self` is a std "map type" (ie `HashSet`, `HashMap`, BTreeSet`, `BTreeMap`).
+fn check_borrow_predicate<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>) {
+    if let ExprKind::MethodCall(_, caller, &[arg], _) = expr.kind
+        && let Some(method_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id)
+        && cx.tcx.trait_of_item(method_def_id).is_none()
+        && let Some(borrow_id) = cx.tcx.get_diagnostic_item(sym::Borrow)
+        && cx.tcx.predicates_of(method_def_id).predicates.iter().any(|(pred, _)| {
+            if let ClauseKind::Trait(trait_pred) = pred.kind().skip_binder()
+                && trait_pred.polarity == ImplPolarity::Positive
+                && trait_pred.trait_ref.def_id == borrow_id
+            {
+                true
+            } else {
+                false
+            }
+        })
+        && let caller_ty = cx.typeck_results().expr_ty(caller)
+        // For now we limit it to "map types".
+        && is_a_std_map_type(cx, caller_ty)
+    {
+        check_if_applicable_to_argument(cx, &arg);
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 635acb6804ac5e944ca86375c05c262c582163e7 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Tue, 20 Feb 2024 17:58:23 +0100
Subject: Fix newly detected lint issues

---
 clippy_config/src/conf.rs           | 2 +-
 clippy_lints/src/min_ident_chars.rs | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_config/src/conf.rs b/clippy_config/src/conf.rs
index 6a1d7cb852a..b781259ad96 100644
--- a/clippy_config/src/conf.rs
+++ b/clippy_config/src/conf.rs
@@ -648,7 +648,7 @@ fn deserialize(file: &SourceFile) -> TryConf {
             extend_vec_if_indicator_present(&mut conf.conf.doc_valid_idents, DEFAULT_DOC_VALID_IDENTS);
             extend_vec_if_indicator_present(&mut conf.conf.disallowed_names, DEFAULT_DISALLOWED_NAMES);
             // TODO: THIS SHOULD BE TESTED, this comment will be gone soon
-            if conf.conf.allowed_idents_below_min_chars.contains(&"..".to_owned()) {
+            if conf.conf.allowed_idents_below_min_chars.contains("..") {
                 conf.conf
                     .allowed_idents_below_min_chars
                     .extend(DEFAULT_ALLOWED_IDENTS_BELOW_MIN_CHARS.iter().map(ToString::to_string));
diff --git a/clippy_lints/src/min_ident_chars.rs b/clippy_lints/src/min_ident_chars.rs
index ec07f283c46..31bc59fe940 100644
--- a/clippy_lints/src/min_ident_chars.rs
+++ b/clippy_lints/src/min_ident_chars.rs
@@ -53,7 +53,7 @@ impl MinIdentChars {
             && str.len() <= self.min_ident_chars_threshold as usize
             && !str.starts_with('_')
             && !str.is_empty()
-            && self.allowed_idents_below_min_chars.get(&str.to_owned()).is_none()
+            && !self.allowed_idents_below_min_chars.contains(str)
     }
 }
 
-- 
cgit 1.4.1-3-g733a5


From b72996e3220d4a32f1d2bd40c3e0b8ae5d87d351 Mon Sep 17 00:00:00 2001
From: "Christopher B. Speir" <chris@cbspeir.dev>
Date: Tue, 20 Feb 2024 20:07:54 -0600
Subject: Add check for 'in_external_macro' and 'is_from_proc_macro' inside
 [infinite_loop] lint.

---
 clippy_lints/src/loops/infinite_loop.rs | 11 ++++++++---
 tests/ui/infinite_loops.rs              | 27 ++++++++++++++++++++++++++
 tests/ui/infinite_loops.stderr          | 34 ++++++++++++++++-----------------
 3 files changed, 52 insertions(+), 20 deletions(-)

(limited to 'clippy_lints/src')

diff --git a/clippy_lints/src/loops/infinite_loop.rs b/clippy_lints/src/loops/infinite_loop.rs
index 5e099f1e76f..5b5bb88c179 100644
--- a/clippy_lints/src/loops/infinite_loop.rs
+++ b/clippy_lints/src/loops/infinite_loop.rs
@@ -1,17 +1,18 @@
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::{fn_def_id, is_lint_allowed};
+use clippy_utils::{fn_def_id, is_from_proc_macro, is_lint_allowed};
 use hir::intravisit::{walk_expr, Visitor};
 use hir::{Expr, ExprKind, FnRetTy, FnSig, Node};
 use rustc_ast::Label;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
-use rustc_lint::LateContext;
+use rustc_lint::{LateContext, LintContext};
+use rustc_middle::lint::in_external_macro;
 
 use super::INFINITE_LOOP;
 
 pub(super) fn check<'tcx>(
     cx: &LateContext<'tcx>,
-    expr: &Expr<'_>,
+    expr: &Expr<'tcx>,
     loop_block: &'tcx hir::Block<'_>,
     label: Option<Label>,
 ) {
@@ -34,6 +35,10 @@ pub(super) fn check<'tcx>(
         return;
     }
 
+    if in_external_macro(cx.sess(), expr.span) || is_from_proc_macro(cx, expr) {
+        return;
+    }
+
     let mut loop_visitor = LoopVisitor {
         cx,
         label,
diff --git a/tests/ui/infinite_loops.rs b/tests/ui/infinite_loops.rs
index 646f1eca56d..52fbbaa8e31 100644
--- a/tests/ui/infinite_loops.rs
+++ b/tests/ui/infinite_loops.rs
@@ -1,7 +1,12 @@
 //@no-rustfix
+//@aux-build:proc_macros.rs
+
 #![allow(clippy::never_loop)]
 #![warn(clippy::infinite_loop)]
 
+extern crate proc_macros;
+use proc_macros::{external, with_span};
+
 fn do_something() {}
 
 fn no_break() {
@@ -363,4 +368,26 @@ fn inf_loop_in_res() -> Result<(), i32> {
     })
 }
 
+with_span! { span
+    fn no_loop() {}
+}
+
+with_span! { span
+    fn with_loop() {
+        loop {
+            do_nothing();
+        }
+    }
+}
+
+fn do_nothing() {}
+
+fn span_inside_fn() {
+    with_span! { span
+        loop {
+            do_nothing();
+        }
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/infinite_loops.stderr b/tests/ui/infinite_loops.stderr
index 012696f3828..ec6bd81dc17 100644
--- a/tests/ui/infinite_loops.stderr
+++ b/tests/ui/infinite_loops.stderr
@@ -1,5 +1,5 @@
 error: infinite loop detected
-  --> tests/ui/infinite_loops.rs:8:5
+  --> tests/ui/infinite_loops.rs:13:5
    |
 LL | /     loop {
 LL | |
@@ -15,7 +15,7 @@ LL | fn no_break() -> ! {
    |               ++++
 
 error: infinite loop detected
-  --> tests/ui/infinite_loops.rs:15:5
+  --> tests/ui/infinite_loops.rs:20:5
    |
 LL | /     loop {
 LL | |
@@ -32,7 +32,7 @@ LL | fn all_inf() -> ! {
    |              ++++
 
 error: infinite loop detected
-  --> tests/ui/infinite_loops.rs:17:9
+  --> tests/ui/infinite_loops.rs:22:9
    |
 LL | /         loop {
 LL | |
@@ -49,7 +49,7 @@ LL | fn all_inf() -> ! {
    |              ++++
 
 error: infinite loop detected
-  --> tests/ui/infinite_loops.rs:19:13
+  --> tests/ui/infinite_loops.rs:24:13
    |
 LL | /             loop {
 LL | |
@@ -63,7 +63,7 @@ LL | fn all_inf() -> ! {
    |              ++++
 
 error: infinite loop detected
-  --> tests/ui/infinite_loops.rs:33:5
+  --> tests/ui/infinite_loops.rs:38:5
    |
 LL | /     loop {
 LL | |
@@ -74,7 +74,7 @@ LL | |     }
    = help: if this is not intended, try adding a `break` or `return` condition in the loop
 
 error: infinite loop detected
-  --> tests/ui/infinite_loops.rs:46:5
+  --> tests/ui/infinite_loops.rs:51:5
    |
 LL | /     loop {
 LL | |         fn inner_fn() -> ! {
@@ -90,7 +90,7 @@ LL | fn no_break_never_ret_noise() -> ! {
    |                               ++++
 
 error: infinite loop detected
-  --> tests/ui/infinite_loops.rs:89:5
+  --> tests/ui/infinite_loops.rs:94:5
    |
 LL | /     loop {
 LL | |
@@ -107,7 +107,7 @@ LL | fn break_inner_but_not_outer_1(cond: bool) -> ! {
    |                                            ++++
 
 error: infinite loop detected
-  --> tests/ui/infinite_loops.rs:100:5
+  --> tests/ui/infinite_loops.rs:105:5
    |
 LL | /     loop {
 LL | |
@@ -124,7 +124,7 @@ LL | fn break_inner_but_not_outer_2(cond: bool) -> ! {
    |                                            ++++
 
 error: infinite loop detected
-  --> tests/ui/infinite_loops.rs:114:9
+  --> tests/ui/infinite_loops.rs:119:9
    |
 LL | /         loop {
 LL | |
@@ -138,7 +138,7 @@ LL | fn break_outer_but_not_inner() -> ! {
    |                                ++++
 
 error: infinite loop detected
-  --> tests/ui/infinite_loops.rs:137:9
+  --> tests/ui/infinite_loops.rs:142:9
    |
 LL | /         loop {
 LL | |
@@ -155,7 +155,7 @@ LL | fn break_wrong_loop(cond: bool) -> ! {
    |                                 ++++
 
 error: infinite loop detected
-  --> tests/ui/infinite_loops.rs:177:5
+  --> tests/ui/infinite_loops.rs:182:5
    |
 LL | /     loop {
 LL | |
@@ -172,7 +172,7 @@ LL | fn match_like() -> ! {
    |                 ++++
 
 error: infinite loop detected
-  --> tests/ui/infinite_loops.rs:218:5
+  --> tests/ui/infinite_loops.rs:223:5
    |
 LL | /     loop {
 LL | |
@@ -186,7 +186,7 @@ LL | fn match_like() -> ! {
    |                 ++++
 
 error: infinite loop detected
-  --> tests/ui/infinite_loops.rs:223:5
+  --> tests/ui/infinite_loops.rs:228:5
    |
 LL | /     loop {
 LL | |
@@ -203,7 +203,7 @@ LL | fn match_like() -> ! {
    |                 ++++
 
 error: infinite loop detected
-  --> tests/ui/infinite_loops.rs:328:9
+  --> tests/ui/infinite_loops.rs:333:9
    |
 LL | /         loop {
 LL | |
@@ -217,7 +217,7 @@ LL |     fn problematic_trait_method() -> ! {
    |                                   ++++
 
 error: infinite loop detected
-  --> tests/ui/infinite_loops.rs:338:9
+  --> tests/ui/infinite_loops.rs:343:9
    |
 LL | /         loop {
 LL | |
@@ -231,7 +231,7 @@ LL |     fn could_be_problematic() -> ! {
    |                               ++++
 
 error: infinite loop detected
-  --> tests/ui/infinite_loops.rs:347:9
+  --> tests/ui/infinite_loops.rs:352:9
    |
 LL | /         loop {
 LL | |
@@ -245,7 +245,7 @@ LL |     let _loop_forever = || -> ! {
    |                            ++++
 
 error: infinite loop detected
-  --> tests/ui/infinite_loops.rs:361:8
+  --> tests/ui/infinite_loops.rs:366:8
    |
 LL |       Ok(loop {
    |  ________^
-- 
cgit 1.4.1-3-g733a5


From f35d87f21101b2310f9466f6a00253d05041107e Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Fri, 16 Feb 2024 17:44:01 +0100
Subject: Add `unneeded_clippy_cfg_attr` lint

---
 CHANGELOG.md                       |  1 +
 clippy_lints/src/attrs.rs          | 97 +++++++++++++++++++++++++++++++++++++-
 clippy_lints/src/declared_lints.rs |  1 +
 3 files changed, 98 insertions(+), 1 deletion(-)

(limited to 'clippy_lints/src')

diff --git a/CHANGELOG.md b/CHANGELOG.md
index b35475c7340..c2f47ad9720 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5726,6 +5726,7 @@ Released 2018-09-13
 [`unknown_clippy_lints`]: https://rust-lang.github.io/rust-clippy/master/index.html#unknown_clippy_lints
 [`unnecessary_box_returns`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_box_returns
 [`unnecessary_cast`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_cast
+[`unnecessary_clippy_cfg`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_clippy_cfg
 [`unnecessary_fallible_conversions`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_fallible_conversions
 [`unnecessary_filter_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_filter_map
 [`unnecessary_find_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_find_map
diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs
index 755f4ad3c89..f90a7dbbfe5 100644
--- a/clippy_lints/src/attrs.rs
+++ b/clippy_lints/src/attrs.rs
@@ -1,7 +1,9 @@
 //! checks for attributes
 
 use clippy_config::msrvs::{self, Msrv};
-use clippy_utils::diagnostics::{span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then};
+use clippy_utils::diagnostics::{
+    span_lint, span_lint_and_help, span_lint_and_note, span_lint_and_sugg, span_lint_and_then,
+};
 use clippy_utils::is_from_proc_macro;
 use clippy_utils::macros::{is_panic, macro_backtrace};
 use clippy_utils::source::{first_line_of_span, is_present_in_source, snippet_opt, without_block_comments};
@@ -459,6 +461,30 @@ declare_clippy_lint! {
     "usage of `cfg(feature = \"cargo-clippy\")` instead of `cfg(clippy)`"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `#[cfg_attr(clippy, allow(clippy::lint))]`
+    /// and suggests to replace it with `#[allow(clippy::lint)]`.
+    ///
+    /// ### Why is this bad?
+    /// There is no reason to put clippy attributes behind a clippy `cfg` as they are not
+    /// run by anything else than clippy.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// #![cfg_attr(clippy, allow(clippy::deprecated_cfg_attr))]
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// #![allow(clippy::deprecated_cfg_attr)]
+    /// ```
+    #[clippy::version = "1.78.0"]
+    pub UNNECESSARY_CLIPPY_CFG,
+    suspicious,
+    "usage of `cfg_attr(clippy, allow(clippy::lint))` instead of `allow(clippy::lint)`"
+}
+
 declare_lint_pass!(Attributes => [
     ALLOW_ATTRIBUTES_WITHOUT_REASON,
     INLINE_ALWAYS,
@@ -821,6 +847,7 @@ impl_lint_pass!(EarlyAttributes => [
     NON_MINIMAL_CFG,
     MAYBE_MISUSED_CFG,
     DEPRECATED_CLIPPY_CFG_ATTR,
+    UNNECESSARY_CLIPPY_CFG,
 ]);
 
 impl EarlyLintPass for EarlyAttributes {
@@ -958,6 +985,74 @@ fn check_deprecated_cfg_attr(cx: &EarlyContext<'_>, attr: &Attribute, msrv: &Msr
             );
         } else {
             check_deprecated_cfg_recursively(cx, feature_item);
+            if let Some(behind_cfg_attr) = items[1].meta_item() {
+                check_clippy_cfg_attr(cx, feature_item, behind_cfg_attr, attr);
+            }
+        }
+    }
+}
+
+fn check_clippy_cfg_attr(
+    cx: &EarlyContext<'_>,
+    cfg_attr: &rustc_ast::MetaItem,
+    behind_cfg_attr: &rustc_ast::MetaItem,
+    attr: &Attribute,
+) {
+    if cfg_attr.has_name(sym::clippy)
+        && let Some(ident) = behind_cfg_attr.ident()
+        // FIXME: replace with `from_symbol` once https://github.com/rust-lang/rust/pull/121230
+        // is merged.
+        && Level::from_str(ident.name.as_str()).is_some()
+        && let Some(items) = behind_cfg_attr.meta_item_list()
+    {
+        let nb_items = items.len();
+        let mut clippy_lints = Vec::with_capacity(items.len());
+        for item in items {
+            if let Some(meta_item) = item.meta_item()
+                && let [part1, _] = meta_item.path.segments.as_slice()
+                && part1.ident.name == sym::clippy
+            {
+                clippy_lints.push(item.span());
+            }
+        }
+        if clippy_lints.is_empty() {
+            return;
+        }
+        if nb_items == clippy_lints.len() {
+            if let Some(snippet) = snippet_opt(cx, behind_cfg_attr.span) {
+                span_lint_and_sugg(
+                    cx,
+                    UNNECESSARY_CLIPPY_CFG,
+                    attr.span,
+                    "no need to put clippy lints behind a `clippy` cfg",
+                    "replace with",
+                    format!(
+                        "#{}[{}]",
+                        if attr.style == AttrStyle::Inner { "!" } else { "" },
+                        snippet
+                    ),
+                    Applicability::MachineApplicable,
+                );
+            }
+        } else {
+            let snippet = clippy_lints
+                .iter()
+                .filter_map(|sp| snippet_opt(cx, *sp))
+                .collect::<Vec<_>>()
+                .join(",");
+            span_lint_and_note(
+                cx,
+                UNNECESSARY_CLIPPY_CFG,
+                clippy_lints,
+                "no need to put clippy lints behind a `clippy` cfg",
+                None,
+                &format!(
+                    "write instead: `#{}[{}({})]`",
+                    if attr.style == AttrStyle::Inner { "!" } else { "" },
+                    ident.name,
+                    snippet
+                ),
+            );
         }
     }
 }
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 60744fee34d..76595e2e26e 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -60,6 +60,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::attrs::MISMATCHED_TARGET_OS_INFO,
     crate::attrs::NON_MINIMAL_CFG_INFO,
     crate::attrs::SHOULD_PANIC_WITHOUT_EXPECT_INFO,
+    crate::attrs::UNNECESSARY_CLIPPY_CFG_INFO,
     crate::attrs::USELESS_ATTRIBUTE_INFO,
     crate::await_holding_invalid::AWAIT_HOLDING_INVALID_TYPE_INFO,
     crate::await_holding_invalid::AWAIT_HOLDING_LOCK_INFO,
-- 
cgit 1.4.1-3-g733a5